diff --git a/.gitignore b/.gitignore index 50d4f7c4e..f7720865b 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,10 @@ __pycache__/ *.py[cod] *$py.class +# Virtual Environments +venv/ +econ-ark/ + # C extensions *.so @@ -262,6 +266,9 @@ Web # Emacs automatic backup files *~ +# Vim swap files +*.swp + # Autogenerated equations eq @@ -272,3 +279,6 @@ eq nate-notes/ *_region_*.* + +# VSCode +settings.json \ No newline at end of file diff --git a/.travis.yml b/.travis.yml index 8355d4505..8f0e9509a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -6,4 +6,5 @@ cache: pip install: - pip install -r requirements.txt script: - - pytest HARK/tests + - pytest + # - flake8 HARK diff --git a/CHANGES.md b/CHANGES.md new file mode 100644 index 000000000..8eae65f02 --- /dev/null +++ b/CHANGES.md @@ -0,0 +1,81 @@ +HARK +Version 0.10.1 +Release Notes + +# Introduction + +This document contains the release notes for the 0.10.1 version of HARK. HARK aims to produce an open source repository of highly modular, easily interoperable code for solving, simulating, and estimating dynamic economic models with heterogeneous agents. + +For more information on HARK, see [our Github organization](https://github.com/econ-ark). + +## Changes + +### 0.10.1 + +Release Date: 05-30-2019 + +No changes from 0.10.0.dev3. + +### 0.10.0.dev3 + +Release Date: 05-18-2019 + +#### Major Changes +- Fixes multithreading problems by using Parallels(backend='multiprocessing'). ([287](https://github.com/econ-ark/HARK/pull/287)) +- Fixes bug caused by misapplication of check_conditions. ([284](https://github.com/econ-ark/HARK/pull/284)) +- Adds functions to calculate quadrature nodes and weights for numerically evaluating expectations in the presence of (log-)normally distributed random variables. ([258](https://github.com/econ-ark/HARK/pull/258)) + +#### Minor Changes +- Adds method decorator which validates that arguments passed in are not empty. ([282](https://github.com/econ-ark/HARK/pull/282) +- Lints a variety of files. These PRs include some additional/related minor changes, like replacing an exec function, removing some lambdas, adding some files to .gitignore, etc. ([274](https://github.com/econ-ark/HARK/pull/274), [276](https://github.com/econ-ark/HARK/pull/276), [277](https://github.com/econ-ark/HARK/pull/277), [278](https://github.com/econ-ark/HARK/pull/278), [281](https://github.com/econ-ark/HARK/pull/281)) +- Adds vim swp files to gitignore. ([269](https://github.com/econ-ark/HARK/pull/269)) +- Adds version dunder in init. ([265](https://github.com/econ-ark/HARK/pull/265)) +- Adds flake8 to requirements.txt and config. ([261](https://github.com/econ-ark/HARK/pull/261)) +- Adds some unit tests for IndShockConsumerType. ([256](https://github.com/econ-ark/HARK/pull/256)) + +### 0.10.0.dev2 + +Release Date: 04-18-2019 + +#### Major Changes + +None + +#### Minor Changes + +* Fix verbosity check in ConsIndShockModel. ([250](https://github.com/econ-ark/HARK/pull/250)) + +#### Other Changes + +None + +### 0.10.0.dev1 + +Release Date: 04-12-2019 + +#### Major Changes + +* Adds [tools](https://github.com/econ-ark/HARK/blob/master/HARK/dcegm.py) to solve problems that arise from the interaction of discrete and continuous variables, using the [DCEGM](https://github.com/econ-ark/DemARK/blob/master/notebooks/DCEGM-Upper-Envelope.ipynb) method of [Iskhakov et al.](https://onlinelibrary.wiley.com/doi/abs/10.3982/QE643), who apply the their discrete-continuous solution algorithm to the problem of optimal endogenous retirement; their results are replicated using our new tool [here](https://github.com/econ-ark/REMARK/blob/master/REMARKs/EndogenousRetirement/Endogenous-Retirement.ipynb). ([226](https://github.com/econ-ark/HARK/pull/226)) +* Parameters of ConsAggShockModel.CobbDouglasEconomy.updateAFunc and ConsAggShockModel.CobbDouglasMarkovEconomy.updateAFunc that govern damping and the number of discarded 'burn-in' periods were previously hardcoded, now proper instance-level parameters. ([244](https://github.com/econ-ark/HARK/pull/244)) +* Improve accuracy and performance of functions for evaluating the integrated value function and conditional choice probabilities for models with extreme value type I taste shocks. ([242](https://github.com/econ-ark/HARK/pull/242)) +* Add calcLogSum, calcChoiceProbs, calcLogSumChoiceProbs to HARK.interpolation. ([209](https://github.com/econ-ark/HARK/pull/209), [217](https://github.com/econ-ark/HARK/pull/217)) +* Create tool to produce an example "template" of a REMARK based on SolvingMicroDSOPs. ([176](https://github.com/econ-ark/HARK/pull/176)) + +#### Minor Changes + +* Moved old utilities tests. ([245](https://github.com/econ-ark/HARK/pull/245)) +* Deleted old files related to "cstwMPCold". ([239](https://github.com/econ-ark/HARK/pull/239)) +* Set numpy floating point error level to ignore. ([238](https://github.com/econ-ark/HARK/pull/238)) +* Fixed miscellaneous imports. ([212](https://github.com/econ-ark/HARK/pull/212), [224](https://github.com/econ-ark/HARK/pull/224), [225](https://github.com/econ-ark/HARK/pull/225)) +* Improve the tests of buffer stock model impatience conditions in IndShockConsumerType. ([219](https://github.com/econ-ark/HARK/pull/219)) +* Add basic support for Travis continuous integration testing. ([208](https://github.com/econ-ark/HARK/pull/208)) +* Add SciPy to requirements.txt. ([207](https://github.com/econ-ark/HARK/pull/207)) +* Fix indexing bug in bilinear interpolation. ([194](https://github.com/econ-ark/HARK/pull/194)) +* Update the build process to handle Python 2 and 3 compatibility. ([172](https://github.com/econ-ark/HARK/pull/172)) +* Add MPCnow attribute to ConsGenIncProcessModel. ([170](https://github.com/econ-ark/HARK/pull/170)) +* All standalone demo files have been removed. The content that was in these files can now be found in similarly named Jupyter notebooks in the DEMARK repository. Some of these notebooks are also linked from econ-ark.org. ([229](https://github.com/econ-ark/HARK/pull/229), [243](https://github.com/econ-ark/HARK/pull/243)) + +#### Other Notes + +* Not all changes from 0.9.1 may be listed in these release notes. If you are having trouble addressing a breaking change, please reach out to us. + diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000..1b489aee9 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,38 @@ +# Contributing to Econ-ARK + +### Welcome! + +Thank you for considering contributing to Econ-ARK! We're a young project with a small but committed community that's hoping to grow while maintaining our friendly and responsive culture. Whether you're an economist or a technologist, a writer or a coder, an undergrad or a full professor, a professional or a hobbyist, there's a place for you in the Econ-ARK community. + +We're still creating our contribution infrastructure, so this document is a work in progress. If you have any questions please feel free to @ or otherwise reach out project manager [Shauna](https://github.com/shaunagm), or lead developers [Chris](https://github.com/llorracc) and [Matt](https://github.com/mnwhite). If you prefer to connect through email, you can send it to __econ-ark at jhuecon dot org__. + +### How to Contribute + +We're open to all kinds of contributions, from bug reports to help with our docs to suggestions on how to improve our code. The best way to figure out if the contribution you'd like to make is something we'd merge or otherwise accept, is to open up an issue in our issue tracker. Please create an issue rather than immediately submitting pull request, unless the change you'd like to make is so minor you won't mind if the pull request is rejected. For bigger contributions, we want to proactively talk things through so we don't end up wasting your time. + +While we're thrilled to receive all kinds of contributions, there are a few key areas we'd especially like help with: + +* porting existing heterogenous agent/agent based models into HARK +* curating and expanding the collection of projects which use Econ-ARK (which we store in the [remark](https://github.com/econ-ark/REMARK) repository) +* creating demonstrations of how to use Econ-ARK (which we store in the [DemARK](https://github.com/econ-ark/DemARK) repository) +* expanding test coverage of our existing code + +If you'd like to help with those or any other kind of contribution, reach out to us and we'll help you do so. + +We don't currently have guidelines for opening issues or pull requests, so include as much information as seems relevant to you, and we'll ask you if we need to know more. + +### Responding to Issues & Pull Requests + +We're trying to get better at managing our open issues and pull requests. We've created a new set of goals for all issues and pull requests in our Econ-ARK repos: + +1. Initial response within one or two days. +2. Substantive response within two weeks. +3. Resolution of issue/pull request within three months. + +If you've been waiting on us for more than two weeks for any reason, please feel free to give us a nudge. Correspondingly, we ask that you respond to any questions or requests from us within two weeks as well, even if it's just to say, "Sorry, I can't get to this for a while yet". If we don't hear back from you, we may close your issue or pull request. If you want to re-open it, just ask - we're glad to do so. + +### Getting Started + +The [quick start guide](https://github.com/econ-ark/HARK#ii-quick-start-guide) in our README provides instructions for how to get started running HARK. This also serves as a setup guide for new contributors. If you run into any problems, please let us know by opening an issue in the issue tracker. + +Thanks again! We're so glad to have you in our community. diff --git a/Examples/Gentle-Intro-To-HARK.ipynb b/Examples/Gentle-Intro-To-HARK.ipynb new file mode 100644 index 000000000..2a56d9fc3 --- /dev/null +++ b/Examples/Gentle-Intro-To-HARK.ipynb @@ -0,0 +1,540 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Gentle Introduction to HARK\n", + "\n", + "This notebook provides a simple, hands-on tutorial for first time HARK users -- and potentially first time Python users. It does not go \"into the weeds\" - we have hidden some code cells that do boring things that you don't need to digest on your first experience with HARK. Our aim is to convey a feel for how the toolkit works.\n", + "\n", + "For readers for whom this is your very first experience with Python, we have put important Python concepts in $\\textbf{boldface}$. For those for whom this is the first time they have used a Jupyter notebook, we have put Jupyter instructions in $\\textit{italics}.$ Only cursory definitions (if any) are provided here. If you want to learn more, there are many online Python and Jupyter tutorials." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# This cell has a bit of initial setup. You can click the triangle to the left to expand it.\n", + "# Click the \"Run\" button immediately above the notebook in order to execute the contents of any cell\n", + "# WARNING: Each cell in the notebook relies upon results generated by previous cells\n", + "# The most common problem beginners have is to execute a cell before all its predecessors\n", + "# If you do this, you can restart the kernel (see the \"Kernel\" menu above) and start over\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# The first step is to be able to bring things in from different directories\n", + "import os\n", + "import sys\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + "\n", + "from copy import deepcopy\n", + "from time import clock\n", + "\n", + "import numpy as np\n", + "\n", + "import HARK\n", + "from Examples.util import log_progress\n", + "from HARK.utilities import plotFuncs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Your First HARK Model: Perfect Foresight\n", + "\n", + "$$\\newcommand{\\CRRA}{\\rho}\\newcommand{\\DiscFac}{\\beta}$$\n", + "We start with almost the simplest possible consumption model: A consumer with CRRA utility \n", + "\n", + "\\begin{equation}\n", + "U(C) = \\frac{C^{1-\\CRRA}}{1-\\rho}\n", + "\\end{equation}\n", + "\n", + "has perfect foresight about everything except the (stochastic) date of death, which occurs with constant probability implying a \"survival probability\" $\\newcommand{\\LivPrb}{\\aleph}\\LivPrb < 1$. Permanent labor income $P_t$ grows from period to period by a factor $\\Gamma_t$. At the beginning of each period $t$, the consumer has some amount of market resources $M_t$ (which includes both market wealth and currrent income) and must choose how much of those resources to consume $C_t$ and how much to retain in a riskless asset $A_t$ which will earn return factor $R$. The agent's flow of utility $U(C_t)$ from consumption is geometrically discounted by factor $\\beta$. Between periods, the agent dies with probability $\\mathsf{D}_t$, ending his problem.\n", + "\n", + "The agent's problem can be written in Bellman form as:\n", + "\n", + "\\begin{eqnarray*}\n", + "V_t(M_t,P_t) &=& \\max_{C_t}~U(C_t) + \\beta \\aleph V_{t+1}(M_{t+1},P_{t+1}), \\\\\n", + "& s.t. & \\\\\n", + "%A_t &=& M_t - C_t, \\\\\n", + "M_{t+1} &=& R (M_{t}-C_{t}) + Y_{t+1}, \\\\\n", + "P_{t+1} &=& \\Gamma_{t+1} P_t, \\\\\n", + "\\end{eqnarray*}\n", + "\n", + "A particular perfect foresight agent's problem can be characterized by values of risk aversion $\\rho$, discount factor $\\beta$, and return factor $R$, along with sequences of income growth factors $\\{ \\Gamma_t \\}$ and survival probabilities $\\{\\mathsf{\\aleph}_t\\}$. To keep things simple, let's forget about \"sequences\" of income growth and mortality, and just think about an $\\textit{infinite horizon}$ consumer with constant income growth and survival probability.\n", + "\n", + "## Representing Agents in HARK\n", + "\n", + "HARK represents agents solving this type of problem as $\\textbf{instances}$ of the $\\textbf{class}$ $\\texttt{PerfForesightConsumerType}$, a $\\textbf{subclass}$ of $\\texttt{AgentType}$. To make agents of this class, we must import the class itself into our workspace. (Run the cell below in order to do this)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The $\\texttt{PerfForesightConsumerType}$ class contains within itself the python code that constructs the solution for the perfect foresight model we are studying here, as specifically articulated in [these lecture notes](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA/). \n", + "\n", + "To create an instance of $\\texttt{PerfForesightConsumerType}$, we simply call the class as if it were a function, passing as arguments the specific parameter values we want it to have. In the hidden cell below, we define a $\\textbf{dictionary}$ named $\\texttt{PF_dictionary}$ with these parameter values:\n", + "\n", + "| Param | Description | Code | Value |\n", + "| :---: | --- | --- | :---: |\n", + "| $\\rho$ | Relative risk aversion | $\\texttt{CRRA}$ | 2.5 |\n", + "| $\\beta$ | Discount factor | $\\texttt{DiscFac}$ | 0.96 |\n", + "| $R$ | Risk free interest factor | $\\texttt{Rfree}$ | 1.03 |\n", + "| $\\newcommand{\\LivFac}{\\aleph}\\LivFac$ | Survival probability | $\\texttt{LivPrb}$ | 0.98 |\n", + "| $\\Gamma$ | Income growth factor | $\\texttt{PermGroFac}$ | 1.01 |\n", + "\n", + "\n", + "For now, don't worry about the specifics of dictionaries. All you need to know is that a dictionary lets us pass many arguments wrapped up in one simple data structure." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# This cell defines a parameter dictionary. You can expand it if you want to see what that looks like.\n", + "PF_dictionary = {\n", + " 'CRRA' : 2.5,\n", + " 'DiscFac' : 0.96,\n", + " 'Rfree' : 1.03,\n", + " 'LivPrb' : [0.98],\n", + " 'PermGroFac' : [1.01],\n", + " 'T_cycle' : 1,\n", + " 'cycles' : 0,\n", + " 'AgentCount' : 10000\n", + "}\n", + "\n", + "# To those curious enough to open this hidden cell, you might notice that we defined\n", + "# a few extra parameters in that dictionary: T_cycle, cycles, and AgentCount. Don't\n", + "# worry about these for now." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make an $\\textbf{object}$ named $\\texttt{PFexample}$ which is an $\\textbf{instance}$ of the $\\texttt{PerfForesightConsumerType}$ class. The object $\\texttt{PFexample}$ will bundle together the abstract mathematical description of the solution embodied in $\\texttt{PerfForesightConsumerType}$, and the specific set of parameter values defined in $\\texttt{PF_dictionary}$. Such a bundle is created passing $\\texttt{PF_dictionary}$ to the class $\\texttt{PerfForesightConsumerType}$:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PFexample = PerfForesightConsumerType(**PF_dictionary) \n", + "# the asterisks ** basically say \"here come some arguments\" to PerfForesightConsumerType" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In $\\texttt{PFexample}$, we now have _defined_ the problem of a particular infinite horizon perfect foresight consumer who knows how to solve this problem. \n", + "\n", + "## Solving an Agent's Problem\n", + "\n", + "To tell the agent actually to solve the problem, we call the agent's $\\texttt{solve}$ $\\textbf{method}$. (A $\\textbf{method}$ is essentially a function that an object runs that affects the object's own internal characteristics -- in this case, the method adds the consumption function to the contents of $\\texttt{PFexample}$.)\n", + "\n", + "The cell below calls the $\\texttt{solve}$ method for $\\texttt{PFexample}$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PFexample.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Running the $\\texttt{solve}$ method creates the $\\textbf{attribute}$ of $\\texttt{PFexample}$ named $\\texttt{solution}$. In fact, every subclass of $\\texttt{AgentType}$ works the same way: The class definition contains the abstract algorithm that knows how to solve the model, but to obtain the particular solution for a specific instance (paramterization/configuration), that instance must be instructed to $\\texttt{solve()}$ its problem. \n", + "\n", + "The $\\texttt{solution}$ attribute is always a $\\textit{list}$ of solutions to a single period of the problem. In the case of an infinite horizon model like the one here, there is just one element in that list -- the solution to all periods of the infinite horizon problem. The consumption function stored as the first element (element 0) of the solution list can be retrieved by:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "PFexample.solution[0].cFunc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the results proven in the associated [the lecture notes](http://econ.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA/) is that, for the specific problem defined above, there is a solution in which the _ratio_ $c = C/P$ is a linear function of the _ratio_ of market resources to permanent income, $m = M/P$. \n", + "\n", + "This is why $\\texttt{cFunc}$ can be represented by a linear interpolation. It can be plotted between an $m$ ratio of 0 and 10 using the command below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mPlotTop=10\n", + "plotFuncs(PFexample.solution[0].cFunc,0.,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The figure illustrates one of the surprising features of the perfect foresight model: A person with zero money should be spending at a rate more than double their income (that is, $\\texttt{cFunc}(0.) \\approx 2.08$ - the intersection on the vertical axis). How can this be?\n", + "\n", + "The answer is that we have not incorporated any constraint that would prevent the agent from borrowing against the entire PDV of future earnings-- human wealth. How much is that? What's the minimum value of $m_t$ where the consumption function is defined? We can check by retrieving the $\\texttt{hNrm}$ **attribute** of the solution, which calculates the value of human wealth normalized by permanent income:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "humanWealth = PFexample.solution[0].hNrm\n", + "mMinimum = PFexample.solution[0].mNrmMin\n", + "print(\"This agent's human wealth is \" + str(humanWealth) + ' times his current income level.')\n", + "print(\"This agent's consumption function is defined (consumption is positive) down to m_t = \" + str(mMinimum))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yikes! Let's take a look at the bottom of the consumption function. In the cell below, set the bounds of the $\\texttt{plotFuncs}$ function to display down to the lowest defined value of the consumption function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# YOUR FIRST HANDS-ON EXERCISE!\n", + "# Fill in the value for \"mPlotBottom\" to plot the consumption function from the point where it is zero.\n", + "# plotFuncs(PFexample.solution[0].cFunc,mPlotBottom,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Changing Agent Parameters\n", + "\n", + "Suppose you wanted to change one (or more) of the parameters of the agent's problem and see what that does. We want to compare consumption functions before and after we change parameters, so let's make a new instance of $\\texttt{PerfForesightConsumerType}$ by copying $\\texttt{PFexample}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NewExample = deepcopy(PFexample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In Python, you can set an $\\textbf{attribute}$ of an object just like any other variable. For example, we could make the new agent less patient:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "NewExample.DiscFac = 0.90\n", + "NewExample.solve()\n", + "mPlotBottom = mMinimum\n", + "plotFuncs([PFexample.solution[0].cFunc,NewExample.solution[0].cFunc],mPlotBottom,mPlotTop)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(Note that you can pass a **list** of functions to $\\texttt{plotFuncs}$ as the first argument rather than just a single function. Lists are written inside of [square brackets].)\n", + "\n", + "Let's try to deal with the \"problem\" of massive human wealth by making another consumer who has essentially no future income. We can virtually eliminate human wealth by making the permanent income growth factor $\\textit{very}$ small.\n", + "\n", + "In $\\texttt{PFexample}$, the agent's income grew by 1 percent per period -- his $\\texttt{PermGroFac}$ took the value 1.01. What if our new agent had a growth factor of 0.01 -- his income $\\textit{shrinks}$ by 99 percent each period? In the cell below, set $\\texttt{NewExample}$'s discount factor back to its original value, then set its $\\texttt{PermGroFac}$ attribute so that the growth factor is 0.01 each period.\n", + "\n", + "Important: Recall that the model at the top of this document said that an agent's problem is characterized by a sequence of income growth factors, but we tabled that concept. Because $\\texttt{PerfForesightConsumerType}$ treats $\\texttt{PermGroFac}$ as a $\\textit{time-varying}$ attribute, it must be specified as a $\\textbf{list}$ (with a single element in this case)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Revert NewExample's discount factor and make his future income minuscule\n", + "# print(\"your lines here\")\n", + "\n", + "# Compare the old and new consumption functions\n", + "plotFuncs([PFexample.solution[0].cFunc,NewExample.solution[0].cFunc],0.,10.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now $\\texttt{NewExample}$'s consumption function has the same slope (MPC) as $\\texttt{PFexample}$, but it emanates from (almost) zero-- he has basically no future income to borrow against!\n", + "\n", + "If you'd like, use the cell above to alter $\\texttt{NewExample}$'s other attributes (relative risk aversion, etc) and see how the consumption function changes. However, keep in mind that \\textit{no solution exists} for some combinations of parameters. HARK should let you know if this is the case if you try to solve such a model.\n", + "\n", + "\n", + "## Your Second HARK Model: Adding Income Shocks\n", + "\n", + "Linear consumption functions are pretty boring, and you'd be justified in feeling unimpressed if all HARK could do was plot some lines. Let's look at another model that adds two important layers of complexity: income shocks and (artificial) borrowing constraints.\n", + "\n", + "Specifically, our new type of consumer receives two income shocks at the beginning of each period: a completely transitory shock $\\theta_t$ and a completely permanent shock $\\psi_t$. Moreover, lenders will not let the agent borrow money such that his ratio of end-of-period assets $A_t$ to permanent income $P_t$ is less than $\\underline{a}$. As with the perfect foresight problem, this model can be framed in terms of $\\textit{normalized}$ variables, e.g. $m_t \\equiv M_t/P_t$. (See [here](http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) for all the theory).\n", + "\n", + "\\begin{eqnarray*}\n", + "v_t(m_t) &=& \\max_{c_t} ~ U(c_t) ~ + \\phantom{\\LivFac} \\beta \\mathbb{E} [(\\Gamma_{t+1}\\psi_{t+1})^{1-\\rho} v_{t+1}(m_{t+1}) ], \\\\\n", + "a_t &=& m_t - c_t, \\\\\n", + "a_t &\\geq& \\underline{a}, \\\\\n", + "m_{t+1} &=& R/(\\Gamma_{t+1} \\psi_{t+1}) a_t + \\theta_{t+1}, \\\\\n", + "\\mathbb{E}[\\psi]=\\mathbb{E}[\\theta] &=& 1, \\\\\n", + "u(c) &=& \\frac{c^{1-\\rho}}{1-\\rho}.\n", + "\\end{eqnarray*}\n", + "\n", + "HARK represents agents with this kind of problem as instances of the class $\\texttt{IndShockConsumerType}$. To create an $\\texttt{IndShockConsumerType}$, we must specify the same set of parameters as for a $\\texttt{PerfForesightConsumerType}$, as well as an artificial borrowing constraint $\\underline{a}$ and a sequence of income shock joint. It's easy enough to pick a borrowing constraint -- say, zero -- but how would we specify the distributions of the shocks? Can't the joint distribution of permanent and transitory shocks be just about anything?\n", + "\n", + "$\\textit{Yes}$, and HARK can handle whatever correlation structure a user might care to specify. However, the default behavior of $\\texttt{IndShockConsumerType}$ is that the distribution of permanent income shocks is mean one lognormal, and the distribution of transitory shocks is mean one lognormal augmented with a point mass representing unemployment. The distributions are independent of each other by default, and are approximated with $N$ point equiprobable distributions.\n", + "\n", + "Let's make an infinite horizon instance of $\\texttt{IndShockConsumerType}$ with the same parameters as our original perfect foresight agent, plus the extra parameters to specify the income shock distribution and the artificial borrowing constraint. As before, we'll make a dictionary:\n", + "\n", + "\n", + "| Param | Description | Code | Value |\n", + "| :---: | --- | --- | :---: |\n", + "| $\\underline{a}$ | Artificial borrowing constraint | $\\texttt{BoroCnstArt}$ | 0.0 |\n", + "| $\\sigma_\\psi$ | Underlying stdev of permanent income shocks | $\\texttt{PermShkStd}$ | 0.1 |\n", + "| $\\sigma_\\theta$ | Underlying stdev of transitory income shocks | $\\texttt{TranShkStd}$ | 0.1 |\n", + "| $N_\\psi$ | Number of discrete permanent income shocks | $\\texttt{PermShkCount}$ | 7 |\n", + "| $N_\\theta$ | Number of discrete transitory income shocks | $\\texttt{TranShkCount}$ | 7 |\n", + "| $\\mho$ | Unemployment probability | $\\texttt{UnempPrb}$ | 0.05 |\n", + "| $\\underline{\\theta}$ | Transitory shock when unemployed | $\\texttt{IncUnemp}$ | 0.3 |" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 2 + ] + }, + "outputs": [], + "source": [ + "# This cell defines a parameter dictionary for making an instance of IndShockConsumerType.\n", + "\n", + "IndShockDictionary = {\n", + " 'CRRA': 2.5, # The dictionary includes our original parameters...\n", + " 'Rfree': 1.03,\n", + " 'DiscFac': 0.96,\n", + " 'LivPrb': [0.98],\n", + " 'PermGroFac': [1.01],\n", + " 'PermShkStd': [0.1], # ... and the new parameters for constructing the income process. \n", + " 'PermShkCount': 7,\n", + " 'TranShkStd': [0.1],\n", + " 'TranShkCount': 7,\n", + " 'UnempPrb': 0.05,\n", + " 'IncUnemp': 0.3,\n", + " 'BoroCnstArt': 0.0,\n", + " 'aXtraMin': 0.001, # aXtra parameters specify how to construct the grid of assets.\n", + " 'aXtraMax': 50., # Don't worry about these for now\n", + " 'aXtraNestFac': 3,\n", + " 'aXtraCount': 48,\n", + " 'aXtraExtra': [None],\n", + " 'vFuncBool': False, # These booleans indicate whether the value function should be calculated\n", + " 'CubicBool': False, # and whether to use cubic spline interpolation. You can ignore them.\n", + " 'aNrmInitMean' : -10.,\n", + " 'aNrmInitStd' : 0.0, # These parameters specify the (log) distribution of normalized assets\n", + " 'pLvlInitMean' : 0.0, # and permanent income for agents at \"birth\". They are only relevant in\n", + " 'pLvlInitStd' : 0.0, # simulation and you don't need to worry about them.\n", + " 'PermGroFacAgg' : 1.0,\n", + " 'T_retire': 0, # What's this about retirement? ConsIndShock is set up to be able to\n", + " 'UnempPrbRet': 0.0, # handle lifecycle models as well as infinite horizon problems. Swapping\n", + " 'IncUnempRet': 0.0, # out the structure of the income process is easy, but ignore for now.\n", + " 'T_age' : None,\n", + " 'T_cycle' : 1,\n", + " 'cycles' : 0,\n", + " 'AgentCount': 10000,\n", + " 'tax_rate':0.0,\n", + "}\n", + " \n", + "# Hey, there's a lot of parameters we didn't tell you about! Yes, but you don't need to\n", + "# think about them for now." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As before, we need to import the relevant subclass of $\\texttt{AgentType}$ into our workspace, then create an instance by passing the dictionary to the class as if the class were a function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "IndShockExample = IndShockConsumerType(**IndShockDictionary)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can solve our new agent's problem just like before, using the $\\texttt{solve}$ method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "IndShockExample.solve()\n", + "plotFuncs(IndShockExample.solution[0].cFunc,0.,10.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Changing Constructed Attributes\n", + "\n", + "In the parameter dictionary above, we chose values for HARK to use when constructing its numeric representation of $F_t$, the joint distribution of permanent and transitory income shocks. When $\\texttt{IndShockExample}$ was created, those parameters ($\\texttt{TranShkStd}$, etc) were used by the $\\textbf{constructor}$ or $\\textbf{initialization}$ method of $\\texttt{IndShockConsumerType}$ to construct an attribute called $\\texttt{IncomeDstn}$.\n", + "\n", + "Suppose you were interested in changing (say) the amount of permanent income risk. From the section above, you might think that you could simply change the attribute $\\texttt{TranShkStd}$, solve the model again, and it would work.\n", + "\n", + "That's $\\textit{almost}$ true-- there's one extra step. $\\texttt{TranShkStd}$ is a primitive input, but it's not the thing you $\\textit{actually}$ want to change. Changing $\\texttt{TranShkStd}$ doesn't actually update the income distribution... unless you tell it to (just like changing an agent's preferences does not change the consumption function that was stored for the old set of parameters -- until you invoke the $\\texttt{solve}$ method again). In the cell below, we invoke the method $\\texttt{updateIncomeProcess}$ so HARK knows to reconstruct the attribute $\\texttt{IncomeDstn}$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "OtherExample = deepcopy(IndShockExample) # Make a copy so we can compare consumption functions\n", + "OtherExample.PermShkStd = [0.2] # Double permanent income risk (note that it's a one element list)\n", + "OtherExample.updateIncomeProcess() # Call the method to reconstruct the representation of F_t\n", + "OtherExample.solve()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the cell below, use your blossoming HARK skills to plot the consumption function for $\\texttt{IndShockExample}$ and $\\texttt{OtherExample}$ on the same figure." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use the line(s) below to plot the consumptions functions against each other\n" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py", + "metadata_filter": { + "cells": "collapsed" + } + }, + "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.3" + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/HARK/ConsumptionSaving/ConsIndShockModelDemos/__init__.py b/Examples/__init__.py similarity index 100% rename from HARK/ConsumptionSaving/ConsIndShockModelDemos/__init__.py rename to Examples/__init__.py diff --git a/Examples/tests/test_gentle_intro_to_hark.py b/Examples/tests/test_gentle_intro_to_hark.py new file mode 100644 index 000000000..3a2d6c574 --- /dev/null +++ b/Examples/tests/test_gentle_intro_to_hark.py @@ -0,0 +1,43 @@ +''' +Tests that the gentle intro to HARK notebook runs correctly +''' +from __future__ import print_function, division +from __future__ import absolute_import + +from builtins import str +from builtins import zip +from builtins import range +from builtins import object + +import os +import sys + +import nbformat +import unittest +from nbconvert.preprocessors import ExecutePreprocessor + +class TestGentleIntroToHark(unittest.TestCase): + + def test_notebook_runs(self): + # we only test that the notebook works in python3 + if sys.version_info[0] < 3: + return + + test_path = os.path.dirname(os.path.realpath(__file__)) + nb_path = os.path.join(test_path, '..', 'Gentle-Intro-To-HARK.ipynb') + with open(nb_path) as nb_f: + nb = nbformat.read(nb_f, as_version=nbformat.NO_CONVERT) + + ep = ExecutePreprocessor(timeout=60, kernel_name='python3') + ep.allow_errors = True + # this actually runs the notebook + ep.preprocess(nb, {}) + + errors = [] + for cell in nb.cells: + if 'outputs' in cell: + for output in cell['outputs']: + if output.output_type == 'error': + errors.append(output) + + self.assertFalse(errors) diff --git a/Examples/util.py b/Examples/util.py new file mode 100644 index 000000000..876172940 --- /dev/null +++ b/Examples/util.py @@ -0,0 +1,55 @@ +from ipywidgets import IntProgress, HTML, VBox +from IPython.display import display + +def log_progress(sequence, every=None, size=None, name='Items'): + is_iterator = False + if size is None: + try: + size = len(sequence) + except TypeError: + is_iterator = True + if size is not None: + if every is None: + if size <= 200: + every = 1 + else: + every = int(size / 200) # every 0.5% + else: + assert every is not None, 'sequence is iterator, set every' + + if is_iterator: + progress = IntProgress(min=0, max=1, value=1) + progress.bar_style = 'info' + else: + progress = IntProgress(min=0, max=size, value=0) + label = HTML() + box = VBox(children=[label, progress]) + display(box) + + index = 0 + try: + for index, record in enumerate(sequence, 1): + if index == 1 or index % every == 0: + if is_iterator: + label.value = '{name}: {index} / ?'.format( + name=name, + index=index + ) + else: + progress.value = index + label.value = u'{name}: {index} / {size}'.format( + name=name, + index=index, + size=size + ) + yield record + except: + progress.bar_style = 'danger' + raise + else: + progress.bar_style = 'success' + progress.value = index + label.value = "{name}: {index}".format( + name=name, + index=str(index or '?') + ) diff --git a/HARK/BayerLuetticke/DCT-Copula-Illustration.ipynb b/HARK/BayerLuetticke/DCT-Copula-Illustration.ipynb new file mode 100644 index 000000000..b56d27dcb --- /dev/null +++ b/HARK/BayerLuetticke/DCT-Copula-Illustration.ipynb @@ -0,0 +1,1288 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dimension Reduction in [Bayer and Luetticke (2018)](https://cepr.org/active/publications/discussion_papers/dp.php?dpno=13071)\n", + "\n", + "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/HARK/BayerLuetticke?filepath=notebooks%2FHARK%2FBayerLuetticke%2FTwoAsset.ipynb)\n", + "\n", + "\n", + "This companion to the [main notebook](TwoAsset.ipynb) explains in more detail how they reduce the dimensionality of the problem\n", + "\n", + "- Based on original slides by Christian Bayer and Ralph Luetticke \n", + "- Original Jupyter notebook by Seungcheol Lee \n", + "- Further edits by Chris Carroll, Tao Wang \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Preliminaries\n", + "\n", + "In StE in the model, in any given period, a consumer in state $s$ (which comprises liquid assets $m$, illiquid assets $k$, and human capital $\\newcommand{hLev}{p}\\hLev$) has two key choices:\n", + "1. To adjust ('a') or not adjust ('n') their holdings of illiquid assets $k$\n", + "1. Contingent on that choice, decide the level of consumption, yielding consumption functions:\n", + " * $c_n(s)$ - nonadjusters\n", + " * $c_a(s)$ - adjusters\n", + "\n", + "The usual envelope theorem applies here, so marginal value wrt the liquid asset equals marginal utility with respect to consumption:\n", + "$[\\frac{d v}{d m} = \\frac{d u}{d c}]$.\n", + "In practice, the authors solve the problem using the marginal value of money $\\texttt{Vm} = dv/dm$, but because the marginal utility function is invertible it is trivial to recover $\\texttt{c}$ from $(u^{\\prime})^{-1}(\\texttt{Vm} )$. The consumption function is therefore computed from the $\\texttt{Vm}$ function" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "code_folding": [ + 0, + 6, + 17, + 21 + ] + }, + "outputs": [], + "source": [ + "# Setup stuff\n", + "\n", + "# This is a jupytext paired notebook that autogenerates a corresponding .py file\n", + "# which can be executed from a terminal command line via \"ipython [name].py\"\n", + "# But a terminal does not permit inline figures, so we need to test jupyter vs terminal\n", + "# Google \"how can I check if code is executed in the ipython notebook\"\n", + "def in_ipynb():\n", + " try:\n", + " if str(type(get_ipython())) == \"\":\n", + " return True\n", + " else:\n", + " return False\n", + " except NameError:\n", + " return False\n", + "\n", + "# Determine whether to make the figures inline (for spyder or jupyter)\n", + "# vs whatever is the automatic setting that will apply if run from the terminal\n", + "if in_ipynb():\n", + " # %matplotlib inline generates a syntax error when run from the shell\n", + " # so do this instead\n", + " get_ipython().run_line_magic('matplotlib', 'inline') \n", + "else:\n", + " get_ipython().run_line_magic('matplotlib', 'auto') \n", + " \n", + "# The tools for navigating the filesystem\n", + "import sys\n", + "import os\n", + "\n", + "# Find pathname to this file:\n", + "my_file_path = os.path.dirname(os.path.abspath(\"TwoAsset.ipynb\"))\n", + "\n", + "# Relative directory for pickled code\n", + "code_dir = os.path.join(my_file_path, \"BayerLuetticke_code/TwoAssetCode\") \n", + "\n", + "sys.path.insert(0, code_dir)\n", + "sys.path.insert(0, my_file_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "# Load precalculated Stationary Equilibrium (StE) object EX3SS\n", + "\n", + "import pickle\n", + "os.chdir(code_dir) # Go to the directory with pickled code\n", + "\n", + "## EX3SS_20.p is the information in the stationary equilibrium \n", + "## (20: the number of illiquid and liquid weath gridpoints)\n", + "### The comments above are original, but it seems that there are 30 not 20 points now\n", + "\n", + "EX3SS=pickle.load(open(\"EX3SS_20.p\", \"rb\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dimensions\n", + "\n", + "The imported StE solution to the problem represents the functions at a set of gridpoints of\n", + " * liquid assets ($n_m$ points), illiquid assets ($n_k$), and human capital ($n_h$)\n", + " * (In the code these are $\\{\\texttt{nm ,nk ,nh}\\}$)\n", + "\n", + "So even if the grids are fairly sparse for each state variable, the total number of combinations of the idiosyncratic state variables is large: $n = n_m \\times n_k \\times n_h$. So, e.g., $\\bar{c}$ is a set of size $n$ containing the level of consumption at each possible combination of gridpoints.\n", + "\n", + "In the \"real\" micro problem, it would almost never happen that a continuous variable like $m$ would end up being exactly equal to one of the prespecified gridpoints. But the functions need to be evaluated at such points. This is addressed by linear interpolation. That is, if, say, the grid had $m_{8} = 40$ and $m_{9} = 50$ then and a consumer ended up with $m = 45$ then the approximation is that $\\tilde{c}(45) = 0.5 \\bar{c}_{8} + 0.5 \\bar{c}_{9}$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "code_folding": [ + 0 + ], + "lines_to_next_cell": 2, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "c_n is of dimension: (30, 30, 4)\n", + "c_a is of dimension: (30, 30, 4)\n", + "Vk is of dimension:(30, 30, 4)\n", + "Vm is of dimension:(30, 30, 4)\n", + "For convenience, these are all constructed from the same exogenous grids:\n", + "30 gridpoints for liquid assets;\n", + "30 gridpoints for illiquid assets;\n", + "4 gridpoints for individual productivity.\n", + "\n", + "Therefore, the joint distribution is of size: \n", + "30 * 30 * 4 = 3600\n" + ] + } + ], + "source": [ + "# Show dimensions of the consumer's problem (state space)\n", + "\n", + "print('c_n is of dimension: ' + str(EX3SS['mutil_c_n'].shape))\n", + "print('c_a is of dimension: ' + str(EX3SS['mutil_c_a'].shape))\n", + "\n", + "print('Vk is of dimension:' + str(EX3SS['Vk'].shape))\n", + "print('Vm is of dimension:' + str(EX3SS['Vm'].shape))\n", + "\n", + "print('For convenience, these are all constructed from the same exogenous grids:')\n", + "print(str(len(EX3SS['grid']['m']))+' gridpoints for liquid assets;')\n", + "print(str(len(EX3SS['grid']['k']))+' gridpoints for illiquid assets;')\n", + "print(str(len(EX3SS['grid']['h']))+' gridpoints for individual productivity.')\n", + "print('')\n", + "print('Therefore, the joint distribution is of size: ')\n", + "print(str(EX3SS['mpar']['nm'])+\n", + " ' * '+str(EX3SS['mpar']['nk'])+\n", + " ' * '+str(EX3SS['mpar']['nh'])+\n", + " ' = '+ str(EX3SS['mpar']['nm']*EX3SS['mpar']['nk']*EX3SS['mpar']['nh']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Dimension Reduction\n", + "\n", + "The authors use different dimensionality reduction methods for the consumer's problem and the distribution across idiosyncratic states" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### The consumer's problem: Basis Functions\n", + "\n", + "The idea is to find an efficient \"compressed\" representation of our functions (e.g., the consumption function). The analogy to image compression is that nearby pixels are likely to have identical or very similar colors, so we need only to find an efficient way to represent the way in which the colors change from one pixel to another. Similarly, consumption at a given point $s_{i}$ is likely to be close to consumption point another point $s_{j}$ that is \"close\" in the state space (similar wealth, income, etc), so a function that captures that similarity efficiently can preserve most of the information without keeping all of the points.\n", + "\n", + "Like linear interpolation, the [DCT transformation](https://en.wikipedia.org/wiki/Discrete_cosine_transform) is a method of representing a continuous function using a finite set of numbers. It uses a set of independent basis functions to do this.\n", + "\n", + "But it turns out that some of those basis functions are much more important than others in representing the steady-state functions. Dimension reduction is accomplished by basically ignoring all basis functions that make small contributions to the steady state distribution. \n", + "\n", + "##### When might this go wrong?\n", + "\n", + "Suppose the consumption function changes in a recession in ways that change behavior radically at some states. Like, suppose unemployment almost never happens in steady state, but it can happen in temporary recessions. Suppose further that, even for employed people, _worries_ about unemployment cause many of them to prudently withdraw some of their illiquid assets -- behavior opposite of what people in the same state would be doing during expansions. In that case, the DCT functions that represented the steady state function would have had no incentive to be able to represent well the part of the space that is never seen in steady state, so any functions that might help do so might well have been dropped in the dimension reduction stage.\n", + "\n", + "On the whole, it seems unlikely that this kind of thing is a major problem, because the vast majority of the variation that people experience is idiosyncratic. There is always unemployment, for example; it just moves up and down a bit with aggregate shocks, but since the experience is in fact well represented in the steady state the method should have no trouble capturing it.\n", + "\n", + "Where it might have more trouble is in representing economies in which there are multiple equilibria in which behavior is quite different." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For the distribution of agents across states: Copula\n", + "\n", + "The other tool the authors use is the [\"copula,\"](https://en.wikipedia.org/wiki/Copula_(probability_theory)) which allows us to represent the distribution of people across idiosyncratic states efficiently\n", + "\n", + "The copula is computed from the joint distribution of states in StE and will be used to transform the marginal distributions back to joint distributions.\n", + "\n", + " * In general, a multivariate joint distribution is not uniquely determined by marginal distributions only. A copula, to put it simply, is a compressed representation of the joint distribution of the rank order of points; together with the marginal distributions this expands to a complete representation of the joint distribution\n", + " * The crucial assumption of a fixed copula is that what aggregate shocks do is to squeeze or distort the steady state distribution, but leave the rank structure of the distribution the same. Think of representing a balloon by a set of points on its surface; the copula assumption is effectively that when something happens to the balloon (more air is put in it, or it is squeezed on one side, say), we can represent what happens to the points by thinking about how the relationship between points is distorted, rather than having to reconstruct the shape of the balloon with a completely independent set of new points. Which points are close to which other points does not change, but the distances between them can change. If the distances between them change in a particularly simple way, you can represent what has happened with a small amount of information. For example, if the balloon is perfectly spherical, then adding a given amount of air might increase the distances between adjacent points by 5 percent. (See the video illustration here)\n", + " \n", + "- In the context of this model, the assumption that allows us to use a copula is that the rank order correlation (e.g. the correlation of where you rank in the distribution of liquid assets and illiquid assets) remains the same after the aggregate shocks are introduced to StE. That is, the fact that you are richer than me, and Bill Gates is richer than you, does not change in a recession. _How much_ richer you are than me, and Gates than you, can change, but the rank order does not.\n", + "\n", + "- In this case we just need to represent how the marginal distributions of each state change, instead of the full joint distributions\n", + "\n", + "- This reduces the number of points for which we need to track transitions from $3600 = 30 \\times 30 \\times 4$ to $64 = 30+30+4$. Or the total number of points we need to contemplate goes from $3600^2 \\approx 13 million$ to $64^2=4096. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "code_folding": [], + "lines_to_next_cell": 2, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The copula consists of two parts: gridpoints and values at those gridpoints:\n", + " gridpoints have dimensionality of (3600, 3)\n", + " where the first element is total number of gridpoints\n", + " and the second element is number of state variables,\n", + " whose values also are of dimension of 3600\n", + " each entry of which is the probability that all three of the\n", + " state variables are below the corresponding point.\n" + ] + } + ], + "source": [ + "# Get some specs about the copula, which is precomputed in the EX3SS object\n", + "\n", + "print('The copula consists of two parts: gridpoints and values at those gridpoints:'+ \\\n", + " '\\n gridpoints have dimensionality of '+str(EX3SS['Copula']['grid'].shape) + \\\n", + " '\\n where the first element is total number of gridpoints' + \\\n", + " '\\n and the second element is number of state variables' + \\\n", + " ',\\n whose values also are of dimension of '+str(EX3SS['Copula']['value'].shape[0]) + \\\n", + " '\\n each entry of which is the probability that all three of the'\n", + " '\\n state variables are below the corresponding point.')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "code_folding": [] + }, + "outputs": [], + "source": [ + "## Import necessary libraries\n", + "\n", + "from __future__ import print_function\n", + "import sys \n", + "sys.path.insert(0,'../')\n", + "\n", + "import numpy as np\n", + "from numpy.linalg import matrix_rank\n", + "import scipy as sc\n", + "from scipy.stats import norm \n", + "from scipy.interpolate import interp1d, interp2d, griddata, RegularGridInterpolator, interpn\n", + "import multiprocessing as mp\n", + "from multiprocessing import Pool, cpu_count, Process\n", + "from math import ceil\n", + "import math as mt\n", + "from scipy import sparse as sp # used to work with sparse matrices\n", + "from scipy import linalg #linear algebra \n", + "from math import log, cos, pi, sqrt\n", + "import time\n", + "from SharedFunc3 import Transition, ExTransitions, GenWeight, MakeGridkm, Tauchen, Fastroot\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "import scipy.io #scipy input and output\n", + "import scipy.fftpack as sf # scipy discrete fourier transforms\n", + "\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n", + "\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "## State reduction and discrete cosine transformation\n", + "\n", + "class StateReduc_Dct:\n", + " \n", + " def __init__(self, par, mpar, grid, Output, targets, Vm, Vk, \n", + " joint_distr, Copula, c_n_guess, c_a_guess, psi_guess,\n", + " m_n_star, m_a_star, cap_a_star, mutil_c_n, mutil_c_a,mutil_c, P_H):\n", + " \n", + " self.par = par # Parameters of the theoretical model\n", + " self.mpar = mpar # Parameters of the numerical representation\n", + " self.grid = grid # Discrete grid\n", + " self.Output = Output # Results of the calculations\n", + " self.targets = targets # Like, debt-to-GDP ratio or other desiderata\n", + " self.Vm = Vm # Marginal value from liquid cash-on-hand\n", + " self.Vk = Vk # Marginal value of capital\n", + " self.joint_distr = joint_distr # Multidimensional histogram\n", + " self.Copula = Copula # Encodes rank marginal correlation of joint distribution\n", + " self.mutil_c = mutil_c # Marginal utility of consumption\n", + " self.P_H = P_H # Transition matrix for macro states (not including distribution)\n", + " \n", + " \n", + " def StateReduc(self):\n", + " \"\"\"\n", + " input\n", + " -----\n", + " self: dict, stored results from a StE \n", + " \n", + " output\n", + " ------\n", + " Newly generated\n", + " ===============\n", + " X_ss: ndarray, stacked states, including \n", + " Y_ss: ndarray, controls \n", + " Gamma_state: ndarray, marginal distributions of individual states \n", + " grid: ndarray, discrete grids\n", + " targets: ndarray, debt-to-GDP ratio or other desiderata\n", + " P_H: transition probability of\n", + " indexMUdct: ndarray, indices selected after dct operation on marginal utility of consumption\n", + " indexVKdct: ndarray, indices selected after dct operation on marginal value of capital\n", + " State: ndarray, dimension equal to reduced states\n", + " State_m: ndarray, dimension equal to reduced states\n", + " Contr: ndarray, dimension equal to reduced controls\n", + " Contr_m: ndarray, dimension equal to reduced controls\n", + " \n", + " Passed down from the input\n", + " ==========================\n", + " Copula: dict, grids and values\n", + " joint_distr: ndarray, nk x nm x nh\n", + " Output: dict, outputs from the model \n", + " par: dict, parameters of the theoretical model\n", + " mpar:dict, parameters of the numerical representation\n", + " aggrshock: string, type of aggregate shock used to purturb the StE \n", + " \"\"\"\n", + " \n", + " # Inverse of CRRA on x for utility and marginal utility\n", + " invutil = lambda x : ((1-self.par['xi'])*x)**(1./(1-self.par['xi'])) \n", + " invmutil = lambda x : (1./x)**(1./self.par['xi']) \n", + " \n", + " # X=States\n", + " # Marg dist of liquid assets summing over pty and illiquid assets k\n", + " Xss=np.asmatrix(np.concatenate((np.sum(np.sum(self.joint_distr.copy(),axis=1),axis =1), \n", + " np.transpose(np.sum(np.sum(self.joint_distr.copy(),axis=0),axis=1)),# marg dist k\n", + " np.sum(np.sum(self.joint_distr.copy(),axis=1),axis=0), # marg dist pty (\\approx income)\n", + " [np.log(self.par['RB'])],[ 0.]))).T # Given the constant interest rate\n", + " \n", + " # Y=\"controls\" (according to this literature's odd terminology)\n", + " # c = invmarg(marg(c)), so first bit gets consumption policy function\n", + " Yss=np.asmatrix(np.concatenate((invmutil(self.mutil_c.copy().flatten(order = 'F')),\\\n", + " invmutil(self.Vk.copy().flatten(order = 'F')),\n", + " [np.log(self.par['Q'])], # Question: Price of the illiquid asset, right?\n", + " [ np.log(self.par['PI'])], # Inflation\n", + " [ np.log(self.Output)], \n", + " [np.log(self.par['G'])], # Gov spending\n", + " [np.log(self.par['W'])], # Wage\n", + " [np.log(self.par['R'])], # Nominal R\n", + " [np.log(self.par['PROFITS'])], \n", + " [np.log(self.par['N'])], # Hours worked\n", + " [np.log(self.targets['T'])], # Taxes\n", + " [np.log(self.grid['K'])], # Kapital\n", + " [np.log(self.targets['B'])]))).T # Government debt\n", + " \n", + " # Mapping for Histogram\n", + " # Gamma_state matrix reduced set of states\n", + " # nm = number of gridpoints for liquid assets\n", + " # nk = number of gridpoints for illiquid assets\n", + " # nh = number of gridpoints for human capital (pty)\n", + " Gamma_state = np.zeros( # Create zero matrix of size [nm + nk + nh,nm + nk + nh - 4]\n", + " (self.mpar['nm']+self.mpar['nk']+self.mpar['nh'],\n", + " self.mpar['nm']+self.mpar['nk']+self.mpar['nh'] - 4)) \n", + " # Question: Why 4? 4 = 3+1, 3: sum to 1 for m, k, h and 1: for entrepreneurs \n", + "\n", + " # Impose adding-up conditions: \n", + " # In each of the block matrices, probabilities must add to 1\n", + " \n", + " for j in range(self.mpar['nm']-1): # np.squeeze reduces one-dimensional matrix to vector\n", + " Gamma_state[0:self.mpar['nm'],j] = -np.squeeze(Xss[0:self.mpar['nm']])\n", + " Gamma_state[j,j]=1. - Xss[j] # \n", + " Gamma_state[j,j]=Gamma_state[j,j] - np.sum(Gamma_state[0:self.mpar['nm'],j])\n", + " bb = self.mpar['nm'] # Question: bb='bottom base'? because bb shorter to type than self.mpar['nm'] everywhere\n", + "\n", + " for j in range(self.mpar['nk']-1):\n", + " Gamma_state[bb+np.arange(0,self.mpar['nk'],1), bb+j-1] = -np.squeeze(Xss[bb+np.arange(0,self.mpar['nk'],1)])\n", + " Gamma_state[bb+j,bb-1+j] = 1. - Xss[bb+j] \n", + " Gamma_state[bb+j,bb-1+j] = (Gamma_state[bb+j,bb-1+j] - \n", + " np.sum(Gamma_state[bb+np.arange(0,self.mpar['nk']),bb-1+j]))\n", + " bb = self.mpar['nm'] + self.mpar['nk']\n", + "\n", + " for j in range(self.mpar['nh']-2): \n", + " # Question: Why -2? 1 for h sum to 1 and 1 for entrepreneur Some other symmetry/adding-up condition.\n", + " Gamma_state[bb+np.arange(0,self.mpar['nh']-1,1), bb+j-2] = -np.squeeze(Xss[bb+np.arange(0,self.mpar['nh']-1,1)])\n", + " Gamma_state[bb+j,bb-2+j] = 1. - Xss[bb+j]\n", + " Gamma_state[bb+j,bb-2+j] = Gamma_state[bb+j,bb-2+j] - np.sum(Gamma_state[bb+np.arange(0,self.mpar['nh']-1,1),bb-2+j])\n", + "\n", + " # Number of other state variables not including the gridded -- here, just the interest rate \n", + " self.mpar['os'] = len(Xss) - (self.mpar['nm']+self.mpar['nk']+self.mpar['nh'])\n", + " # For each gridpoint there are two \"regular\" controls: consumption and illiquid saving\n", + " # Counts the number of \"other\" controls (PROFITS, Q, etc)\n", + " self.mpar['oc'] = len(Yss) - 2*(self.mpar['nm']*self.mpar['nk']*self.mpar['nh'])\n", + " \n", + " aggrshock = self.par['aggrshock']\n", + " accuracy = self.par['accuracy']\n", + " \n", + " # Do the dct on the steady state marginal utility\n", + " # Returns an array of indices for the used basis vectors\n", + " indexMUdct = self.do_dct(invmutil(self.mutil_c.copy().flatten(order='F')),\n", + " self.mpar,accuracy)\n", + "\n", + " # Do the dct on the steady state marginal value of capital\n", + " # Returns an array of indices for the used basis vectors\n", + " indexVKdct = self.do_dct(invmutil(self.Vk.copy()),self.mpar,accuracy)\n", + " \n", + " # Calculate the numbers of states and controls\n", + " aux = np.shape(Gamma_state)\n", + " self.mpar['numstates'] = np.int64(aux[1] + self.mpar['os'])\n", + " self.mpar['numcontrols'] = np.int64(len(indexMUdct) + \n", + " len(indexVKdct) + \n", + " self.mpar['oc'])\n", + " \n", + " # Size of the reduced matrices to be used in the Fsys\n", + " # Set to zero because in steady state they are zero\n", + " State = np.zeros((self.mpar['numstates'],1))\n", + " State_m = State\n", + " Contr = np.zeros((self.mpar['numcontrols'],1))\n", + " Contr_m = Contr\n", + " \n", + " return {'Xss': Xss, 'Yss':Yss, 'Gamma_state': Gamma_state, \n", + " 'par':self.par, 'mpar':self.mpar, 'aggrshock':aggrshock,\n", + " 'Copula':self.Copula,'grid':self.grid,'targets':self.targets,'P_H':self.P_H, \n", + " 'joint_distr': self.joint_distr, 'Output': self.Output, 'indexMUdct':indexMUdct, 'indexVKdct':indexVKdct,\n", + " 'State':State, 'State_m':State_m, 'Contr':Contr, 'Contr_m':Contr_m}\n", + "\n", + " # Discrete cosine transformation magic happens here\n", + " # sf is scipy.fftpack tool\n", + " def do_dct(self, obj, mpar, level):\n", + " \"\"\"\n", + " input\n", + " -----\n", + " obj: ndarray nm x nk x nh \n", + " dimension of states before dct \n", + " mpar: dict\n", + " parameters in the numerical representaion of the model, e.g. nm, nk and nh\n", + " level: float \n", + " accuracy level for dct \n", + " output\n", + " ------\n", + " index_reduced: ndarray n_dct x 1 \n", + " an array of indices that select the needed grids after dct\n", + " \n", + " \"\"\"\n", + " obj = np.reshape(obj.copy(),(mpar['nm'],mpar['nk'],mpar['nh']),order='F')\n", + " X1 = sf.dct(obj,norm='ortho',axis=0) # dct is operated along three dimensions axis=0/1/2\n", + " X2 = sf.dct(X1.copy(),norm='ortho',axis=1)\n", + " X3 = sf.dct(X2.copy(),norm='ortho',axis=2)\n", + "\n", + " # Pick the coefficients that are big\n", + " XX = X3.flatten(order='F') \n", + " ind = np.argsort(abs(XX.copy()))[::-1]\n", + " # i will \n", + " i = 1 \n", + " # Sort from smallest (=best) to biggest (=worst)\n", + " # and count how many are 'good enough to keep'\n", + " while linalg.norm(XX[ind[:i]].copy())/linalg.norm(XX) < level:\n", + " i += 1 \n", + " \n", + " needed = i # Question:Isn't this counting the ones that are NOT needed?\n", + " \n", + " index_reduced = np.sort(ind[:i]) # Retrieve the good \n", + " \n", + " return index_reduced" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "## Choose an aggregate shock to perturb(one of three shocks: MP, TFP, Uncertainty)\n", + "\n", + "EX3SS['par']['aggrshock'] = 'MP'\n", + "EX3SS['par']['rhoS'] = 0.0 # Persistence of variance\n", + "EX3SS['par']['sigmaS'] = 0.001 # STD of variance shocks\n", + "\n", + "#EX3SS['par']['aggrshock'] = 'TFP'\n", + "#EX3SS['par']['rhoS'] = 0.95\n", + "#EX3SS['par']['sigmaS'] = 0.0075\n", + " \n", + "#EX3SS['par']['aggrshock'] = 'Uncertainty'\n", + "#EX3SS['par']['rhoS'] = 0.84 # Persistence of variance\n", + "#EX3SS['par']['sigmaS'] = 0.54 # STD of variance shocks" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "## Choose an accuracy of approximation with DCT\n", + "### Determines number of basis functions chosen -- enough to match this accuracy\n", + "### EX3SS is precomputed steady-state pulled in above\n", + "EX3SS['par']['accuracy'] = 0.99999 \n", + "\n", + "## 20190607: CDC to TW: Please try to figure out what this is" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [], + "source": [ + "## Implement state reduction and DCT\n", + "### Do state reduction on steady state\n", + "EX3SR=StateReduc_Dct(**EX3SS) # Takes StE result as input and get ready to invoke state reduction operation\n", + "SR=EX3SR.StateReduc() # StateReduc is operated " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "code_folding": [ + 7, + 10, + 12 + ], + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What are the results from the state reduction?\n", + "\n", + "\n", + "To achieve an accuracy of 0.99999\n", + "\n", + "The dimension of the policy functions is reduced to 154 from 3600\n", + "The dimension of the marginal value functions is reduced to 94 from (30, 30, 4)\n", + "The total number of control variables is 259=154+94+ # of other macro controls\n", + "\n", + "\n", + "The copula represents the joint distribution with a vector of size (64, 60)\n", + "The dimension of states including exogenous state, is 66\n", + "It simply stacks all grids of different \n", + " state variables regardless of their joint distributions. \n", + " This is due to the assumption that the rank order remains the same.\n", + "The total number of state variables is 62=60+ the number of macro states (like the interest rate)\n" + ] + } + ], + "source": [ + "print('What are the results from the state reduction?')\n", + "#print('Newly added attributes after the operation include \\n'+str(set(SR.keys())-set(EX3SS.keys())))\n", + "\n", + "print('\\n')\n", + "\n", + "print('To achieve an accuracy of '+str(EX3SS['par']['accuracy'])+'\\n') \n", + "\n", + "print('The dimension of the policy functions is reduced to '+str(SR['indexMUdct'].shape[0]) \\\n", + " +' from '+str(EX3SS['mpar']['nm']*EX3SS['mpar']['nk']*EX3SS['mpar']['nh'])\n", + " )\n", + "print('The dimension of the marginal value functions is reduced to '+str(SR['indexVKdct'].shape[0]) \\\n", + " + ' from ' + str(EX3SS['Vk'].shape))\n", + "print('The total number of control variables is '+str(SR['Contr'].shape[0])+'='+str(SR['indexMUdct'].shape[0]) + \\\n", + " '+'+str(SR['indexVKdct'].shape[0])+'+ # of other macro controls')\n", + "print('\\n')\n", + "print('The copula represents the joint distribution with a vector of size '+str(SR['Gamma_state'].shape) )\n", + "print('The dimension of states including exogenous state, is ' +str(SR['Xss'].shape[0]))\n", + "\n", + "print('It simply stacks all grids of different\\\n", + " \\n state variables regardless of their joint distributions.\\\n", + " \\n This is due to the assumption that the rank order remains the same.')\n", + "print('The total number of state variables is '+str(SR['State'].shape[0]) + '='+\\\n", + " str(SR['Gamma_state'].shape[1])+'+ the number of macro states (like the interest rate)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Graphical Illustration\n", + "\n", + "#### Policy/value functions\n", + "\n", + "Taking the consumption function as an example, we plot consumption by adjusters and non-adjusters over a range of $k$ and $m$ that encompasses x percent of the mass of the distribution function. \n", + "\n", + "We plot the functions for the top and bottom values of the wage $h$ distribution\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "code_folding": [ + 0 + ], + "scrolled": true + }, + "outputs": [], + "source": [ + "## Graphical illustration\n", + "\n", + "### In 2D, we can look at how the number of grid points of \n", + "### one state is redcued at given grid values of other states. \n", + "\n", + "mgrid_fix = 0 ## these are or arbitrary grid points.\n", + "kgrid_fix = 0\n", + "hgrid_fix = 2\n", + "\n", + "\n", + "xi = EX3SS['par']['xi']\n", + "\n", + "invmutil = lambda x : (1./x)**(1./xi) \n", + "\n", + "### convert marginal utilities back to consumption function\n", + "mut_StE = EX3SS['mutil_c']\n", + "mut_n_StE = EX3SS['mutil_c_n'] # marginal utility of non-adjusters\n", + "mut_a_StE = EX3SS['mutil_c_a'] # marginal utility of adjusters \n", + "\n", + "c_StE = invmutil(mut_StE)\n", + "cn_StE = invmutil(mut_n_StE)\n", + "ca_StE = invmutil(mut_a_StE)\n", + "\n", + "\n", + "### grid values \n", + "dim_StE = mut_StE.shape\n", + "mgrid = EX3SS['grid']['m']\n", + "kgrid = EX3SS['grid']['k']\n", + "hgrid = EX3SS['grid']['h']\n", + "\n", + "## indexMUdct is one dimension, needs to be unraveled to 3 dimensions\n", + "\n", + "mut_rdc_idx = np.unravel_index(SR['indexMUdct'],dim_StE,order='F')\n", + "\n", + "## these are filtered indices for the fixed grids of other two states \n", + "\n", + "mgrid_rdc = mut_rdc_idx[0][(mut_rdc_idx[1]==kgrid_fix) & (mut_rdc_idx[2]==hgrid_fix)]\n", + "kgrid_rdc = mut_rdc_idx[1][(mut_rdc_idx[0]==mgrid_fix) & (mut_rdc_idx[2]==hgrid_fix)]\n", + "hgrid_rdc = mut_rdc_idx[2][(mut_rdc_idx[0]==mgrid_fix) & (mut_rdc_idx[1]==kgrid_fix)]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## 3D scatter plots of consumption function \n", + "## at all grids and grids after dct for both adjusters and non-adjusters\n", + "\n", + "## full grids \n", + "mmgrid,kkgrid = np.meshgrid(mgrid,kgrid)\n", + "\n", + "\n", + "### for adjusters \n", + "fig = plt.figure(figsize=(14,14))\n", + "fig.suptitle('Consumption of non-adjusters at grid points of m and k(for different h)',\n", + " fontsize=(13))\n", + "for hgrid_id in range(EX3SS['mpar']['nh']):\n", + " ## prepare the reduced grids \n", + " hgrid_fix=hgrid_id\n", + " fix_bool = mut_rdc_idx[2]==hgrid_fix # for a fixed h grid value \n", + " rdc_id = (mut_rdc_idx[0][fix_bool], \n", + " mut_rdc_idx[1][fix_bool],\n", + " mut_rdc_idx[2][fix_bool])\n", + " mmgrid_rdc = mmgrid[rdc_id[0]].T[0]\n", + " kkgrid_rdc = kkgrid[rdc_id[1]].T[0]\n", + " mut_n_rdc= mut_n_StE[rdc_id]\n", + " c_n_rdc = cn_StE[rdc_id]\n", + " c_a_rdc = ca_StE[rdc_id]\n", + " mmax = mmgrid_rdc.max()\n", + " kmax = kkgrid_rdc.max()\n", + " \n", + " ## plots \n", + " ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d')\n", + " ax.scatter(mmgrid,kkgrid,cn_StE[:,:,hgrid_fix],marker='.',\n", + " label='StE(before dct): non-adjuster')\n", + " ax.scatter(mmgrid_rdc,kkgrid_rdc,c_n_rdc,c='red',marker='o',\n", + " label='StE(after dct):non-adjuster')\n", + " ax.set_xlabel('m',fontsize=13)\n", + " ax.set_ylabel('k',fontsize=13)\n", + " ax.set_zlabel(r'$c_a(m,k)$',fontsize=13)\n", + " \n", + " ax.set_xlim([0,mmax*1.1])\n", + " ax.set_ylim([0,kmax*1.2])\n", + " ax.set_title(r'$h({})$'.format(hgrid_fix))\n", + " ax.view_init(20, 240)\n", + "ax.legend(loc=9)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxsAAANsCAYAAAAz+bWwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xl0ZNV9L/rvrpJq1jzPVZJ6pqFxA45vEuN7r4eExMQ49y2HJCakTcIzdmL7meTiicA1j9g3k+8LN4mdOAtjAnZyMzhxMPFITKChUSN6omnN6pbUUg9qzSrVtN8fZ+BUqapUwzk1SN/PWlrdUtU5Z1fVqb3Pbw+/I6SUICIiIiIiMput2AUgIiIiIqLticEGERERERFZgsEGERERERFZgsEGERERERFZgsEGERERERFZgsEGERERERFZgsEGUZkQQnQLIVaEEO1FLMNNQoiTQohlIcSXTNrn94UQD6n/L/prLGdCiDNCiA+kefyzQojnLDz+p4UQ/2LV/nMhhHhACDGnnlc3F7s8mRJCRIQQ70jx2N1CiJEttn+PEOJ5w+8OIcQ3hRDXhBBXTC5u4rFHhBB3q///aSHEQsLjfyqEuKJ+Js1CiF4hxItCiCUhxD9aWbZ8CSH8QggphOhM85xvCiE+VMhyEZUyBhtUFtSL3H8SQlxWG6QhIcSXhBBtxS6bFZJdTEgpz0spfVLKmWKVC8CjAJ6VUlZJKT9u9s7NfI2ZXJAVgxBiQgjxq1bsW0p5QEr5TSv2neHxH5VSvjfT5wshHhJCfN+q8qgXhI8C+M/qefWKVccqJUIIAeBPAPye4c//DcAtADqklI2FKouU8nkpZa2hbP8JwBEA+9TP5BKABwBcAFAjpbyjUGVLZGKd8XsAHhVCuE3YF1HZY7BBJU8I8S4A/wHgHIBDUspqALcCuKr+S4XTC+BksQtRKEIIuxCi5OtJIURlsctQovwAYlLK14tdkAJ7NwAHgB8Z/tYLYFRKuZbLDk38LvQCuCilvJzwt1Myx7sMl9r5L6V8A8AIgDuLXRaikiCl5A9/SvoHwDCAv97iOR4A/wtK79gVAP8EoNvw+HMA/gjA3wNYBjAK4BcMj98IJaBZBDAP4EUAdYZtP5twPAngp9T/PwTgBwC+COAylCDo/wHQA+CH6vGOQ+nJM5bnSwC+DWAFwBkAP6s+9jYAQQAx9bEVAO+AcuEkAXQa9vNhKEHYIoCXAPy04TGtXI8CuKT+PLzF+3i9WuZrAMYAfBaAXX1sQS1TUC3TO5Ns3wngWfV9WATwPIDDhscFgE8BmFLf5z9Ry/iQ+njca1Rfw/cTjqF/HgDqAPyd+p4vAjgN4KdTvYfqNtcB+Dco58l5AL8PoDLh+B8C8DqADQCtAH4JwFn1s5wD8Hia9/BjAN5Qn6vtX3sP/yXhPfxuin1Uqu/NJQCzAH4XysXL3erjd6u//476Xp5R/z4B4FcN+/k59XWsQDnXvgTguTRlnwDwIJTvwgqAAQA3Gx6vUB8fUz+/HwC4LuGc+37C/j6tPm9F/Xz+k/rYBwCEAEQMn1Gv+hn8G5Tz7RqU786eNGVO+h1Q97+ufp4rUC60k23/HIA/BvCPeLNu+K8A3qmWd0l9rCqXz9xQX9wH4BX1OS8B2Gt4vArA19T3dBLAr6nvyztSHO9uACOG338GwEUAP6/+/ucA/sLw+GMJ7/XjGXzf/UjyXUhxrv4x3jxX/zviz9V3AIio//9dxH8vfwjgBICouv8VAB9Sn/vTUM7DefUz+SQAYdwngA+q5V42tAN/CGBc3e5ZAP2ZtANIU2ckvF7tffmg+r4sA/gugLaE5z0E4J/T1bf84c9O+Sl6AfjDn3Q/AHarFfumC9uE530ZwMsAOgB4AfyV2ohpDedzUC4ufxLKiN4noFzMeNTHX4RyEWVXG8+fAOA1bLtVsBEGcI+6/c+qjef3AexT9/ckDBeW6j6XAbwLygXcr6gNnV99/G4YLibUv2mNnHYhfqf6mt6q7uNDAFYB9CSU6/9WH3+r+vtPpngPa6BcSH8OgFMt+xiA3zE8ZwKGi9kk++gGcDuURt8NJQCcxJsX8x+EclFyGErP62fUMj2U4jU+hPTBxqMA/hWAD0ogsxtAIM172AwlMLlXPX4HlAvqBxOO/wMoQYYDyvkUBvBf1Od4YQjqkrwHvwggoJbnRvU9vTfT91B9zoNQLl571ffx/1PLcLfhtUWgBCRuvHke6/tWt90A8Kvq5/9u9fx4Ls1xJwDMGD6fB6AEjtXq45+CciG5Vz1HHoJykas9Hvd5qfsbAXAAynfjTwAMGx5P9vk+BeAv1f3boVwQt6Qo71bfgXdAvdBN85qfU1/jT6jHe1R9D/4WQL368zqAT+fxmUsAx6B8P5xQAuTvGR7/KpQ6qBXK9/Af1G3ekeJ4d0M9t6GcyxcQH9S/DOC3E7ZJ/GzSft+R/LtgT1KWzwEYAtAP5Vz8c8Sfq3GfAZJ/L5+DoY5Vz5dlAL+gfiZ7oQQQdxn2KdVzpQZvnv9PQQmqW9TyPgzle1RpOE66dmBT2ZK8Xu19+TaARgDVAF4A8JdJzompdPviD392yk/JTw+gHa9J/Xc61RPUof27oDRW01LKVQAfh9J43mJ46jellC9IKWMAvgKlkdqlPhaCciHQJaUMSylfUveTqSEp5V9JKaNSyu9AuaD9NynlWSllGEojmLg49Z+klN+TUkaklH8D5aL3l7M45q8D+LKU8mV1H1+FMsXJuI8hKeVfqI+/DOA1ADel2N/PQXkfHpFSbkgpz0IZrbkn0wJJZc3FP0sp16SU61B6Srvx5vt8l1rm41LKEJQe4NnMX/ImIQANAPZA6fUcklKOp3n+XQBOSCm/LKUMSSmn1TLclfC8h6WUs2oZJZSLp71CiHop5aqU8nmkIKX8eynluFQMAvg6lJ7ybNwF4H9KKcfU9/G/Q+lxNQoDeEBKuS6TT425E8AxKeWT6uf/XSgjflv5quHz+SKU0YGfVx/7dQBflFK+IaXcAPA/oATWP5dmf1+WUp6RUkahdAL0CyFq0jw/BOXitlf9Pp2UUs6leG4m34FM/K36nY9C6RhoA/AHUsp5KeU8lAvLlIvLM/zM/0D9fmwAeBzq91Ctv34FwOfUc24Ryue9FSGE+CKA34bS8XHc8FgdlBGZdDL9vuvfBfX9SXQXlHNiRD1X74fyncnHhwH8nZTyW+o58AaU0ZnE7+kDUspFKeWaEKIRyjl/n5RyTj1/H4byWb7VsE26diAbD0spr0gpl6DU74n16hKUQJVox2OwQaVOm9fbkeY5TQBcUHrlAABSyhUoPehdhuddNDyuBRJV6r+/DuX78B9CiHEhxOeFEBVZlPNiwu9rCX9bMxxLM5Hk95QZTpLoguE1q0aR4jWrVpOUw7i/CSml8UIhcX9pCSEahRBPCCHOCyGWoPS4Am8GjZ0wvG61wZ/MdP9J/AGUntevAbgshPiaEKIlzfMDAH5SCLGg/QD4aygXt0bGMq4BuA3KVJVRIcRxIUTKi1khxJ1CiFeEEFeFEIsAPoI3X3+mOmB4X9SLuMsJz7moXrimEvdeq9IFYhp9G/VcOI83z8u4c079/CaQ/hwxnoOJ37tkfkct578IIS6qmYt8KZ6byXcgE4nf1WR/S1nmDD/zxPdB218TlJGFCcPjmXxOzQA+CuAPpZSJ36FrUHrc08n0+z6B9BK/06tQ6t58BADcmfA9/T0ogYMmhjfrF20bADhp2GYeyshypu1ANlJ9nppq9fhEOx6DDSppUsohbL3Q7jKU6SJaYwP14qQZ8Y1RuuOMSymPSCk7oUwDugdv9qKtQJk6o+3brLSs/iS/T6n/T+zFTuYCDK9Z1YsMX3OK/fWomWxy3d/vQ+1JlMpCfq2R1/Y5DcPrVo/Vk2Z/ce+9Sn//1VGGz0gpr4My9aIDSgACJH8PJ6FMJak1/NRIKRMvZuO2lVI+J6W8Hcq0iUcAPCmE6EvcuRCiC0rP+CNQ5nDXAPjfePP1pypXomkY3hc1q03ixetW+4l7r1WJ50sy+jbq59ONN8/LuHNO7ZX3I/dzbtNrkFJellL+tpSyH8p0l3dAmeufjNnfgaxl+JmncxnKCIPf8LdMPqc5KFPj/kAI8cGExwYB7N9i+0y/71mdZ0IIL5S6Nx+TUNbpGb+n1VLKA4bnyIRASQu4diVs55FSPp3hcTP5bmbqOiifA9GOx2CDysF9AH5FCPGodqGv5mb/lBDiA2rv6hMAPi+EaBdCeKAsAnwDyjzpLQkhfs0QRCxAmQ8fUX8fAPALQogmIUQVgP/XpNf1PiHEf1WzvNwJZZrGN9THZgE0CyHS9U4+DuBeIcQtQogKNa/9IQCZNqyJ/hXKCNGn1Zz8e6BM5/hqFvuohtILfE0N+L6Y8PjXAfymEOItagaZB7B5VMFoAMBbhBCH1df4UcRf7L5XCLFPCGGHEpgE8ebnluw9fALATUKII0IIlxDCpub4/5lUBRBCtAghflEIUaNOI9HuGZBsSokPSr16GUBYCPETUNapGM1i62kbXwfwO0KIgBDCBSWIy7a+fhrAW9Ve9wohxDuhzIHfyhHD5/M7UNbf/Kv62OMAflcIsVsIoa25qTA8nq1ZAN3qvgAAQogPqK9bQFn0rS1sTuZxmPsdyEUmn3lKav31FICH1XOtGsrnncm2L0AJOP5QCHGf4aF/wtZT98z4vgNvnqt9alD8P5F5oJXKnwH4JfX7Xal+tvuFELem2kAqKXSfAvBnQogOABBC1Aoh7kgzMpYok3o3U+9CZtMWibY9BhtU8qSU3wPwU1B66k4JIZahLMhrBvDv6tM+AeXC9BUo0z7aANyeYo5xMv8FwHEhxAqAo1Aarb9RH/sTKIHLKJQ1D7leWCX6KpSsVYtQFgS/X0qpTQn5IYDvARhXpwRsamSllE9BmZP8JJQ1IvcBuE1KOZFLYdS54u+GkoVnDkpGoCegZJrJ1O/hzUXYJ6EsejV+Bk8A+FMoWZnm1Of+OE2ZnoMSOD4LZdpCC5TPXtOn7msJylSOdSgBDJDkPZRSzgL4zwDepz7/GpRMQ71pXpMNyrSYCfXc+98Afi3Z+6zOe/89AN+CEpQ8gM0Xvo8A+FWh3FztOymO+ftq2Y+p5bwIZdFyumlTiWUZhXJvhQfVsnwCypqJrXwFyoL0a1AyOv2cem4AyqjR01Cy78xB+d68W523nou/g9KTPqt+RgEoC6z/HW9maXsVSoahTcz+DuQiw898Kx+DMnXqDQCnoJzTGdVdUspXoZzTnxFCaOf+vwFIeVNAdTszvu+Acq7+G5QMW+NQ6t98pkZCSnkayjqhj0M59y9BCSy3mo74G1Aykz2nfldPAfi/kPkaki3r3UyogdsuKO0I0Y4n4kchiagQhHIX5+9LKR8pdllKiTo1aQRK9qF8531vG2rP7DUAt0opX7TwOBNQEi08adUxqDDU0bpPSynfXuyy7DRCiKcB/EBKmUlwT7TtZbMAlojIam+BMtKTuBh6RxFC1EHJoPMDKNOY/gRKb/GOuAM25U9K+SyUEUEqMCklb+ZHZMBpVERUEoQQfwzlvhy/JTnkaocy3WoeytSUTgDvlUoaZSIiorLBaVRERERERGQJjmwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElGGwQEREREZElKrZ4XBakFERElI4odgFKGNspIqLiS9lOcWSDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDiIiIiIgswWCDylZXVxdeffXVpI996lOfwpe+9KWM9nPLLbfgzJkzZhaNiIiI7RQRGGxQmbp27RpmZmawd+/eTY9dvnwZTzzxBO699179b/Pz87jjjjvg9XrR09ODp556Sn/s/vvvx4MPPliQchMR0c6QbTv12GOP4aabboLT6cTdd98d93y2U1TOGGxQWTp16hQCgQA8Hs+mxx5//HHcdtttcLvd+t8+8pGPwOFwYG5uDn/zN3+DD3/4w3ov0e23344f/ehHuHjxYsHKT0RE21u27VR7ezs++9nP4siRI5uez3aKyhmDDSpLJ0+eRF9fHz72sY+hqakJ7e3t+N73vgcA+M53voNbb71Vf+7q6ir+/u//Hp///Ofh8/nwUz/1U7j99tvx9a9/HQDgcrlw+PBhfPe73y3KayEiou0nm3YKAN7//vfjfe97HxoaGjbti+0UlTMGG1SWTp48iYGBAdx2222Ym5vDvffeiy9+8YsAlN6kPXv26M8dGhqC3W7H7t279b/dcMMNcfNf9+3bhxMnThTuBRAR0baWTTuVCbZTVK4YbFBZOnXqFD7zmc/gPe95D2w2G/bv368/trCwgKqqKv33lZUV1NTUxG1fU1OD5eVl/feqqiosLCxYX3AiItoRsmmnMsF2isoVgw0qO1JKnD59Gu9973v1v50+fVqvyOvq6uICCZ/Ph6Wlpbh9LC0txVX0y8vLqK2ttbjkRES0E2TbTmWC7RSVKwYbVHbGx8cBAP39/frfBgcHcejQIQDA9ddfj6GhIf2x3bt3IxKJYHh4WP/biRMncODAAf33s2fP4oYbbrC66EREtANk205lgu0UlSsGG1R2Tp48iYMHD0IIof9tcHBQr4Rvu+02/Pu//7v+mNfrxfvf/348+OCDWF1dxQsvvIBvfetb+OAHPwgA2NjYwPHjx/Gud72rsC+EiIi2pWzbKQCIRCIIBoOIRqOIRqMIBoOIRCIA2E5ReWOwQWXn1KlTcb07V69exezsLK677joAwF133YVnnnkG6+vr+nP+7M/+DOvr62hubsadd96JP//zP9dHNv75n/8Z73jHO9De3l7YF0JERNtSLu3UI488ArfbjS984Qt48skn4Xa78cgjjwBgO0XlTUgp0z2e9kGiUvXpT38azc3N+PjHP77lc9/61rfiq1/9qt4IEJUgsfVTdiy2U1SW2E7RNpOynWKwQURU+hhspMZ2ioio+FK2U5xGRURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQURERERElmCwQVQkUkrEYrFiF4OIiCgltlOUr4piF4Bou5NS6oFFNBqN+7HZbHC73bDb7bDZGPsTEVHhJbZTxvZKCAGXy4WKigq2U5QTIaVM93jaB4noTVpFnRhUxGIxjI+PIxAI6M8VQuj/VlZWAgBsNhsqKyshhNAfJ1LxhEiN7RRRhhLbKWN7NTExAb/frz9Xa4uklHA4HACUdkoLOthOUYKUJwRHNoiyYOz90X4ikYj+f+PztIraZrPh2rVr6O/v37Qv7XFtnxsbG7DZbLDb7bDb7azMiYgoK8Z2Skq5qfPL+DxjOzU/P4++vr6k+9TaolgshlAoBCEEKioq2E5RRhhsECWRGFAYK+rE0UBjZZ1rpWvsQZJSIhwOIxKJsDInIqKkUk3RNbZTxoDCzHYKgN5O2e12VFRUsJ2ilBhs0I6WaurTtWvXAAA1NTVJK2urGKdXaUFHMBgEAHi9XlbmREQ7TKp2anl5GcFgEA0NDfpzjW2VVe1FYjsViUTiOse4roMSMdigbS/dwrdkoxQAsLa2BiEE6uvri1FkvSxCCFy9ehVXr17F7t27WZkTEW1DuUzR3djYwMrKCpqbmy0tF4CUgYtxtEMLOowjHewgI4DBBm0jqaY+RaPRTc/dqven1CpIbehbq8y5mJyIqPyYOUW3UHV/JscxBh3GbItcf0gAgw0qQ8mGlEOhEC5duoSWlhb9OfnOUS21ytFYmXMxORFR6Uo19Wl6ehptbW36cwo1RbdQEtcfTk1Nwev1oq6uju3UDsZgg0pStgvfYrEY5ubm0N7ebtrxS6VSTCwLF5MTERVfLlN0L168iM7OzmIUt6C017u0tISKigouJt/hGGxQUaXL+Z0o3dSnUq64kt3LJhKJYG1tDbFYDE1NTVuWP90QunExeTgcRkVFBStzIiKTmDlF12zlUM8bU7xzMfnOxGCDLJdq4dulS5fiFmDnM/WpVCvcUCiE1dVVhEIhDA0NYW1tDaFQCHa7HR6PB0IIjIyMoLu7G+3t7Ukr3i1uvAlg8yK9S5cuoaamBh6Ph5U5EVEGkk19mpubM62dsqK8Zu9vZWUFa2trWF1dxerqKtbX1xGLxdDc3Ay/3w+n05n1Po0dY1xMvjMx2CDTZDL1SSOEwPj4OBobG02rYMyueLM5bjAYjKug19bWEI1GUVlZCY/HAwBoamqC1+vVF3ZLKfXenvPnz+PFF19Ee3s7urq69LuKa/vP9D3SKuy5uTl9PQcXkxMRKbKdomt2O1UKIpGI3k5p/2pt2OTkJLxeL7xeL5qbm+FyuSCEwPz8PF599VVUVVXB7/fD5/NldKxk7RcXk+88DDYoa6kWvhnT82nSLXwrt4vfWCyG9fX1uIBibW0NUkq4XC54PB54vV50dHTA4/GgoqJC3255eRl1dXVJ9+twONDf349AIICpqSkcO3YMjY2N6OnpgcvlyqmsUkq90uZiciLaacycoluO9aWUEqFQKC6gWF1d1afaau1VXV0dOjo64HK5MDAwgAMHDmzajxAC7e3taGtrw5UrV3D27FlUVFQgEAigtrZ2y7JkkjaX6w+3NwYblFTi1KdwOIyVlRW4XK6kIwilMKRslkgkgmAwiHA4rAcXwWAQQgh4PB69km5qajJ1mpLdbkdPTw+6urowNzeHwcFB+Hw++Hy+nN9XVuZEtF0lm6K7sLAAj8eT8t4U26Wd0kgp9Y4vYydYNBqFw+GA1+uFx+NBc3MzPB4PHA5HzscSQqCpqQlNTU1YXFzE+Pg4QqEQ/H5/yrWHmU4D1v7V2qnFxUW9E287fV47FYONHS7ThW+RSARvvPEGbrzxxrLt6THSKjTjKIXW62O32/XRitraWrS3t+tDyYVgs9nQ1taG1tZWzM/P4+zZs5BSora2FnV1dRmVI1kGK+1fLiYnonKSzRTdM2fO4Oabb952QUUsFts0SrG8vIxoNIrV1VW9E6y+vh5ut1sfWbdKTU0NDh06hNXVVUxMTKRce5htZkft+mJ6ehp1dXWw2WxcTL4NMNjYITKZ+pSu90er7Mut8tbWUyTOT9V6fYyjFH6/X1/bMDU1BZvNhoaGBlPKkOt9PhoaGtDb24vFxUVcuHABw8PD8Pv9aG5uTrvPdMdMt0iPlTkRFYsZU3TLvTNMW09hHKUIBoOw2Wxwu93wer3w+Xxobm7WnxcIBIpWXq/XiwMHDmBjYwPnz5/H0aNH9bWHFRUVeV03aKPvvJlt+WOwsY0Ye38ikcim+araBWbiTYQy+dKW+hdbe52XLl2Ky6KhjVBoQ8mJ6ynSKZXXLKWE2+3Gvn379AV8o6Oj6OrqQnt7O+x2e9JtMkmna1ykNzU1hYaGBvh8vm3XK0hEpSHZKIX2/+0+RVejradI7ARLtp6is7MTTqcz6etfW1srQumTczqd2LVrl7728OWXX0ZjY2PSNTKZ0AJMYzvF9Yfli8FGGcpk4dvFixcRi8XQ2dkJIUTeX0rty15sqbJoCCH0bBpaFg23251zT30pvNZkPB4P9u3bh1AopPcitbW1obu7e1MGq0xplfmVK1dQXV2NUCgEIQTXdRBRzjKZojs/P4+FhQX09fUV9N4UhSKlxPr6elymwtXVVbzyyitx6ylaWlr0TIXlrqKiAn6/H93d3ZidncXU1BSi0Sh2796dcQYrTeJUYK4/LF8MNkpUsoVv2Ux90lKqluO0mEyyaHg8nrgsGrFYDCdOnIDf7y928TfJd/pZsu2NGaymp6dx7NgxNDQ0oKenB263G0D2IzPGcwkA7/hKRFvKZ4qudpFY6u3UVnV4NBrdlKlwfX0dAOJG1uvr67GysoJbbrnFtLKVar1ss9nQ3t6Oy5cvo66uDmfPnoXdbkcgEEiZmdEo1XvO9YflicFGkWWb8zvTIWWzv3BWjGyYnUWjVEcjzJDq87SgXKrnAAAgAElEQVTb7eju7tYzWJ04cQIejwfhcDinc8B4biWu6+AiPaKdKbGdSuz8StYDnWk7VU71djgc3tQJpk3r0TrBqqqq0NLSknJk3cy2uRzeOyEE6urq0N3drWewGhoaQiAQSJnBCsh+KjDbqdLGYKNAtur9eeONN7B3714A6XN+Z8rsSjyfCjJVr8/a2hpGR0fjsmh4PJ6kaxDKWb6fQ6apA1tbW9HS0oL5+XmcOHECp0+fRn9/f1YZrJLtN9Vi8u025YFop9tqim6ydirfKSyldsGcuJ4iGAxicHBQv5A1jlKkW09BCmPQoGWwWltbS5vBKnG7rRjbqYWFBVy+fBl9fX1cTF5CGGyYKNnUJ+NCbePzEnt/1tbWTL3ILkaPUWIWja16fY4fP46DBw8WtIzFYvY0qnTHaWhoQE1NDXp6ejA1NYWhoSH4/X60tLSYksGKd3wlKl/5TNE1u50qZu+ztp4icQ1gLBaD0+nUO8EqKytx4MABOJ3OopW1nCVrVzweD/bv349QKITJyUm8+OKL6OjoQGdnp75uJZfpx0IoN7ENBoNcTF5iGGzkIF1FnXiBn23WJ7NYFWwky6Kxurqq9/pkmkWDspPLe+jz+XD99ddjfX0dExMTGBsbQ2dnJzo6OkzJYCWlxOXLlyGEQGNjIytzohJi1RRdK8pppWg0umm6bqr1FMlG1mdmZrbFwu1S5HA49AxW2trDxsZG9PT05LzWUdtOW7fKxeSlgcFGGqmmPk1PT6OlpUU/mRMr61KQb7CRrNdHy6Jh7PXZTlk0rFKIaVTJttEqVC1tbigUwoULF/QMVl1dXXHrYLIdQQGAlZUVCCFQU1PDxeRERZCqnZqdnUVdXV1c3WzGFF0z77dkZqeYtp4iFApheHgYa2trSUfWW1tb4XK5Mm6ry21dSanJ5HypqKhAT08Purq6MDs7i8HBQYRCIbS2tqKqqirn43ExeenY8cFGuoVvqUYpLl26hNbW1pJeW5BpBZlNr4/ZWTRKnZkVUaGmUaXbxuFwoK+vD36/H9PT0xgYGEBdXR38fj/cbnfOx9EW43GRHpE1cpmiOz8/j+rqarhcLtPKobUrxQo2jCPrxo4w43oKAGhoaEBXVxdH1ktANueLlsGqra0Nx44dw9jYGKampjLOYKUdL9XC/FTrD9lOWW/HBBuZ3JtCs1XvjzYvsJQlVuLGLBpaJZ1trw8r7fKRroI3M4NVYi8SF5MT5c7MKbo2m830dsqKxCPJ9qfNu0+8k3bieorW1lZ4PJ640ZulpSXU19ebVkag9BaxF1q+dXcuay+0mwRGIpGMM1gB2JQdLdm+k60/1IIOtlPW2HbBRigUQiQSQWVlJaLRKBYXF+F2uzPK+Z0prRe31EgpsbGxgbW1NVy5cgWLi4tYXFzclEWjoaEB3d3dcDgc2+aLZfbrMPPzteI+G2ZsY8xgde3aNbz66qt47bXX0Nvbi/r6+owzWCU+j4vJidLTpnNo7dTS0tKm1N75TtG1YvqP2fvURipmZ2f1zrBgMAhAmf6pBRUNDQ1Fy1TI+io/uZ4v2vmfTQYr43ZbMbZTsVgMoVAI4XAYTqdzW10blYptF2x85StfQTgcxt133w0hBM6cOYPDhw+bGrEWe2Rjq14fr9erj1js2bNnx6ynKMUAcCvZrpGwqgz19fXw+XzYtWsXzp8/j+HhYfgzyGCVrhcpcTE5F+kRKZ555hk8//zz+OxnPwsAGB4exq5du+ByuUz7XpTSyEY4HN6U9WljYwOAksVwY2Mjp/UUVPrBUL4LvTXJMli1t7ejq6tr0zVONscztlNjY2NoampCQ0MD1x+abNsFG06nE6urq6ioUF6aFXfStmJkI9n+tPUUxko6016fa9eu4cqVKzsm0NjO8l0gns021dXVegaryclJjI6OoqurK+8MVtq/WtBx/vx5dHV1sTKnHcnhcCAcDuvfKWOyEbNYMbKRru0zjqynWk+htVfayHowGMTIyAh6enpMLafZSrUjq1TLlciMYEOTLoOVy+XachpVujJqaxABxK0/ZDuVv20ZbIRCIf33chhKDofDepYrbZTCuJ7C6/Wiuroara2tcLvdGQ8RlktFtN2V6jSqdNu43W7s3btXDwyOHj2K1tZW/SIh1+NovUiTk5Noa2vjYnLakRLbKSs6sKwYgdf2mThKkTiy7vF4kq6nSMaqFO1mzmTYCay6Xsh3GlUqxgxWc3NzGBwchM/ng8/nyzvTGtcfmm9bBhva8CxgzVByLvvUen0SK2ltfYmWWcSs9RQMNna2XBvbxG0qKyv1DFYzMzN6Bquenh54PJ68GvXEDFY2m413fKUdIbGdsiIwyDeASTayvrCwgBMnTugBhdfrRWNjI9xud07rKdjBsP2ZNY0qFZvNhra2NrS2tuLq1at44403AAB1dXUZZ7BKdUwuJjfPtgs2tOFpjVU9Rqn2GYvFsL6+Hpf5aX19fVOvT1tbW1yvz/Hjx9He3m7aAjgGG6XDjPtsFLtSs9vt6OrqQmdnJy5duoRTp07p88vzuWBIXKTHO77STpCsnSrW+gptPYVxlCLVyPro6Cj6+vrg8XhMK6dV7bOZIxtsS3NndbChEUK5uWwgEMDy8jImJycxNDQEv9+P5ubmjPYVi8W2TJurJTUQQnD9YRa2XbBRiB4jIQQikQiWlpbien6M6ym0oCLTXp9CpRTMByvc3CVWRtpNE202G6qrq9Nua9YohRmEEGhpaUFzczOuXbuGU6dOYXV1Fbt37844g1Wq/XIxOe0UhRiBN7Z9W42sG9f/pRtZN7vzzqoLebZV2SuFTi2jfIIUbRqwlsFqdHQ0bQarTI+ZbP0hb2abmW0ZbCTOhc2nEg+FQpuGkpeXl7GwsIDq6mp4vV7U1NSgra0t4/UUyZRDsLHTmFFxSCkRDAaxsbGBiYkJfaRLSgmXy4VIJAKHw4He3l7U1NSYUOrC0DJYNTU1oaamBjMzM3ovUktLS86jHckqc97xlbYbq9YWGkfWFxYWcPXqVVy4cGHLkfVMlUM7ZXYdUep1jtnl0zrCtNGu1dVVxGIxBAKBnO5fUuggxng8Ywar8+fPp81glW1ZE9d1zM/P698vTg/cbNsFGw6HI+tgQ7sgTAwqotEoKisr40Ypuru7cf78eTQ0NJh646CdWImbyYoKN9vnJ1bQa2trAKCvyXG73WhsbNQrIy3zxcrKCkZGRiClRF9f36Z5pqXW42QkpYTX60VHRweCwSAmJiYwNjaGzs5OdHZ25jUtMLEy1+6hU1VVxcqcylq+nWLG9RSpRtYdDgdcLhd6enpKdnpuOSRwAUp3pCSfciVrs1ZWVjAwMACXyxWXPUwIgQsXLmB4eBi9vb1obGzMuE0q1DSqdNs5HA709/cjEAhgampqUwarfI6ptVMXL15EU1OTPgWYi8njbbtgI12WD63Xx1hBa+spXC6XPpTc3t4Oj8ejp89NZLfbSyZ/eaH2Vw4K8XrTBRXGCtoYVKytrWFsbAwtLS1Jy1tbW4vDhw9jaWkJY2NjeoWuVfKlzFg5u1wuPYPVhQsXTM9gFQqFcPr0abzlLW/hYnIqa5lmo0o2sh4KhWC32+HxeODxeFKOrE9PTwOAqTfCK5dpVPSmTNusuro6rK+v46abbtq0vc1mww033IDV1VWMjY1hdHQUgUAg47UQuZY712AjVWeU3W5PmsEqEAjA5/OlXLOR6XG1Kb+8me1mBQs2jhw5gm9/+9tobm7G6dOnAQAf+MAHcO7cOQDAwsICamtr8dprr23a1u/3o6qqSo8WBwYGUh7H6XQiGAzi+eefh9/vx9LSElZWVhCNRiGE0Ctor9eLpqamnIa8rKggrZizy0o8d9oc58uXL2ccVOSruroahw4dwsrKCsbHxzEyMoJAIJBz3vBCSFaxV1ZWore3Ny6DVW1tLfx+PzweT86vRzuWNhedi8mpXBnXbGgjd0tLS/rNWo3rKRJH1jPNVGjVesVSDzbKoYxWyKUjzEi7RkrH6/Xi4MGDWF9fx/j4OEZHR+H3+9Ha2pqyDSzGyMZW7bExg9X8/DzeeOMNvUMrV1qgwvWHyRUs2Lj77rvx0Y9+FHfddZf+t29+85v6/z/5yU+mnbP+ox/9CI2NjUkfC4fDuP/++3H27FmcP39enyP/qU99Ci6XC42NjWhtbS3p7BRWVJDloNhThFJV0BsbG3C5XKivr887qMj2Nfp8vrgKfXZ2FjabDfX19SU3fSjda7PZbOjs7ERHR4eewcrpdKK7uzvvYIOVOVnB6k6xc+fO4cyZMzhx4gTm5uZwyy234P7779enczQ3N6OtrQ1erzflyHqmbDYbIpFIXvtIZHYAwwXi2TO2WZcvX8b6+jrm5uYAWNcRlsjtdmP//v36WsTx8XF0d3ejo6MjZTanXFgdpAgh0NDQgIaGBiwtLWFgYACDg4Po7e3NetQmWdpc7V8uJi9gsPH2t78dExMTSR+TUuJv//Zv8cMf/jCnfVdWVuIXf/EXsWfPHqyuruK3fuu38OSTTwIARkdH875nRaJipiks1v7KXba9PhcuXIDL5do09amQtAo9FothbW0NR48eTVuhF0MmFbuWwaqlpQXXrl3D6OgoVlZWcOXKlaymiiWOiHAxOZnNyk4xAHjsscfQ2NiIvXv3wuPx4Nlnn4XX69WnPLW1tZnwKhTl0ClmBSu+98V4zZm0Wdq6nL6+vrzbhFw6/pxOJ/bs2YPe3l5MTk7i6NGj6OjoQFdXl6nT97KR68i5lvBn//79uHDhAkZHR9HV1ZXxLQnSTcFKXH+4E29mWxJrNp5//nm0tLRg165dSR8XQuDd7343hBC499578Zu/+ZubnvP2t78dADAzM1OQlIKlXomXS6Ng9shGLBbTpyIkVtButxsejwc+n8/SXh+z2e12tLe3w+fzlUyFrsn286urq8PBgwcxODiIixcvYnh4GD09PWmH4Y3HyqYy13qQyuEzptJgZacYAPzpn/4pAKWe+sIXvgCv1wvAupv6lXrbZ0VgUA5lNMpn+tPs7CxCoVDR67jKykr09/fD7/fjwoULeOmll/T1esWQ62cmpdyUwero0aNpM1gZt82k4y1VO7Xd1x+WRLDx9NNP484770z5+AsvvID29nZcunQJ73rXu7B37149uEhUiJsllUslXurBRj6MKR5XVlb0Svr48eN6NhZtXY7b7c6pMjbri29GQCWEgMPhwK5duxAIBPRKsK2tDd3d3VmnsDRLLq9NSonKykocPHgQwWAQk5OTGB8f16dcpZo+kkmPlbEy5x1fyUxmdIoZn2tk1ZSnUu8Us0Kpfse1oCIcDutp0K1eB5ht+fJVUVGBQCCA7u5uTE9P49ixY9jY2EAoFIpLEmKlfNY4GtszYwYr7bU0NDTA7/fHZbBKtu1WEtsp7VpGy2ZVqudwPooebEQiEfzDP/wDjh8/nvI57e3tAIDm5mbccccdOHbsWMpgw+VybRrZsKLC3anBRqHXWCRmENPuUwEgLqhobm7G2toabr75ZlOOW0oNamJZKioq0Nvbi56eHj2NX1NTE/x+f8EqdE0uFbtxhMLlcunD8FNTU3j55ZfR3NyMnp6eTa8lm0whxso8Fovh+PHjuP7667mug3JmZqcYEH9RXA4dWFbt0wrFbEvTjVS43W7EYjF9wX+pja6bVS/a7XZ0d3ejs7MTP/7xjzEwMIC6ujoEAoGkF+pmyucaJdm2xteiZbDyer0IBAKoqqrSn5dLJiutnQoGg5iZmUFtbe22XX9Y9GDj+9//Pvbu3YvOzs6kj2s3lKmqqsLq6iq++93v4sEHH0y5v2Q3S7Lyzqxm7nOnBRvGMmYTVKQaqdhOX8xEyV6bMY2flvVJq9ALJZfzIVmAUllZiUAggJ6enqQZrHI9lvb81dVVANjxi/QoN2Z3igHQExwYA2MzlUsAY7ZClXGroCLV6Porr7yC5uZm08pRynWYzWaDw+HA2972NszOzmJwcBDV1dUIBAJ6vW62fK9R0iU8MWawOnfuHIQQCAQCqKuryzttrs1m0zvHt2M7VbBg484778Rzzz2HK1euoLOzEw8//DA+9KEP4Rvf+Mam3qKZmRncc889eOaZZzA3N4c77rgDgFLh//Iv/zJ+5md+JuVx7HY7otGo/rtV06hKvWGwqlcrX8agIhgM4vXXX990M6qtgopyk2/lt9XnaMz6pFXo2rCsVRW6sWy5jGxkksHq8uXLegYrLQVwLudDspSExkV626UyJ+uY3SmWbBpVOQQGVpSz1BmDipWVFaytrWUUVBSqbKW4r0RCCP1CXavX3W43ent74fP5TD2W1bMvEjNYjY+PY3h4OG76fraMZd6ui8kLFmw8/fTTSf/++OOPb/pbe3s7nnnmGQBAb28vTpw4kfFxEhfZWHXRXeoNQ7GH0DMZqbDb7fD7/fB6vWX9JbJappWnsUL/8Y9/nFWFnuu5kklO81y2EUKgubkZzc3Negar9fV1eL3erBuTxOPt5EV6lF6hOsUA66dRlUsAY7Zcy5hsHeD6+jrW19cRjUZRU1Oz7TrCEqWq+8yczdDc3IympibMz8/j7NmzqKioQF9fH6qrq005RiGneldXV+OGG27A+vo6XnrpJbzyyivo7u7OOIOVJllHWrJ2qpxvZlv0aVRWK5eRDSsq8UI0CvlMf7p27dq2rbSNzPgcsqlYhBCorKzELbfcEleh9/b2pk3bmUvlZdY0qnTq6upQV1eHyclJTE9P46WXXso4g1W643ExOSUqVKdYonJpU7ZDsJFtm3X27Fm9U2ynMrsuNI4OLCwsYHh4GIDyPaqrq8tr38W4d5fb7YbL5cKNN96IqamprJO3ZJo2t5xvZrttgw3thCuX3h0rRjbMFIvFEIvFcOnSJT21bGIF7fP5tnWvTz7y6THK9bxIrNBHRkYgpURfX9+mCj3XY+S6QDyX89PpdKKlpQUdHR16Nq6Ojg50dnamvQHaVtOvjJW5lBKhUAhCiG25SI9KhzZCrp1jO3FtoZXMWAe4k6Srl638zGtra3H48GEsLS1hbGwMw8PD6O3tzWu0vRh1tpQSTqczaQarnp4euN3utNtmMtpvbKfK7Wa22y7YSDYXdqdOo8qFdgM5bSh5bW1Nr6CDwSDW1tZQXV2NlpYWuFwuU24kROmZUXmmqtC1m+rleoxc12zks/bC5XJh9+7d6O3txYULF/QMVt3d3XA6nSm324pxzqxWmS8uLsLtdsPtdpd8ZU7lxeFwIBQK6Re65TICX2prNhKDisXFRZw6dQp2u92UoKKcAqxyVl1djUOHDmFlZQXj4+NYW1vD3Nxc3nfyLiTtuFoGq66uLszNzeHEiRPweDybMlhpsum0S9ZOLS0tweFwwOv1lmw7te2CjURWVI7lMuSdjhZUGHt9tIXaHo8HXq8XVVVVaG1t1YOKwcFBU+/pUKpfCo1Z5Stm5ZcosUIfGRlBIBBAfX19zmW0ehqVJvF91HK69/T04OLFizh+/Dhqamo2TXnINYuVEAKTk5Noa2uDEMp9Top9E0XKXDQm8cVn38DrM0t44Gf34rqO1FMIi8HpdGJjY0MPZMuhTSnmhXemIxU+nw89PT1pp4xS6fL5fDh48CAWFxdx9epVjI2NoaenR6+Ht5JrZ5YVhBBobW1FS0tL0gxW2uvJNfmJ1k7Nzs7C7XbDbreXbDu17YONcppGZUWPUS5BRboysoen8HJZEL0VrUJfX1/Xgw5tqpzVFXWuwVeqstlsNnR0dKC9vR2XL1/GmTNnUFlZqa9RyTcloTZEXSoBI222HAzjV/7qZYxfXsXn33cd3ndjB547dwlPHzuPjXAUv/t/TuKZj/10sYsZRxvZALhA3Cjf6U9Xr141vQ7bCe1eKXWKAcr5u3//fgSDQUxMTGBiYkJffJ3u8y211wFszmA1MTGBoaEh+P1+tLS05B0gGdupUrVtgw3jmo1ySP+XbzmTBRXaHbUTg4pcp4SUQ8Yss5RSuawsi9vtxv79+7G8vIzjx4/j6NGj6O7uRkdHh2VBR64V61aNiDGD1cLCAsbGxhAOh7MehjdKTJtLpen54SsYv7KKcDSG//WDIbzvxg40+JQpdRV2G5qqNk+vKzaHw6HfgLZcAgMzy6kFFeFwGOPj46atqSiVKclkDpfLhb179yIUCmFychJHjx5FZ2cnOjs7k/bgl9o0v0TV1dW4/vrrsb6+jomJCYyNjcHr9aK2tjbnfZZDO7Utgw2tx8jlcpXF+ops9pksqFhfX4cQYlNQsb6+btodtSl3ZvS0WD1n1eFwwOfz4frrr9cr9I6ODnR1dZk+JJvrNKpYLJbxFL7a2lrceOONWF1dxblz57CwsIDp6Wm0tbVlFegUYqSH8newowYVNgFU2HDrLuWGaYe6avEXv3oYo5dX8AuHOopcws2MN6Atl/UVubR9W41UxGIxLtTOw3ac7puMw+HArl27EAgE9AQh7e3t6O7u3pQgpBzOIbfbjX379iEUCuHkyZMYHx9HJBLJaap6ObRT2zLY0CpxbVpQOQ5PZxNUpBqpsCJdHXuMCi+XaVS5ZohKVqFnk8LPqvLlup3X64Xf78fMzAxWV1czzmClKYdKnICueg+++4lbMbcUxIH2N/P1/2R/I36yv7GIJUvNGGxsh7WFuU5/suKO2hyBL69jZENL497T04OpqSk9QUhPTw8cDkde7UsxOBwONDQ0oK2tDdFoFMeOHUN9fT38fn/aDFZG5dBObctgo7KyMm54upQXyWlBxfLyMoLBIObn57MOKgqpHO8FUmyFfo1m3NU7sUI/duwYmpqa4Pf74XA48i5fPtmoctmusrJSz2ClNVBNTU3o6elJmsEq32NS4TVVOUtyulQq5TiNSguKEqfr5psG3cxe9VIODigzmXx+drsdPT096OrqwszMDAYGBlBfX49wOFywziyzaCmwtdkEmWSwStxe+54V+xoxlW0ZbGhZPoDS6TGKRqNYX1/X08lqFbTNZoPH40E0GoXT6dTzMZfiCVOKZSoX+bx3uWZTMuMYySr0uro6BAIBuFyurI6hyScbVb5BSkVFBfx+P7q7u3Hx4kW8+uqrqKqqQiAQSHrTLgYbZBXjAvFSzByVbKRieXkZ0WgUGxsb8Hg88Pl8eadBzyf1diGUarnMVkqfQTZlsdls6OzsRHt7O2ZnZzE1NYXh4WH09/dnPDKQ7THNlhgsGDNYDQ0NAQD8fn/KrJHl0E5t22DDyiwf6QKYaDQaN/1Ju0+FFlR4vV5UV1ejra1NX1MCALOzswiFQvB4PKaW1UycRmUO7cZxy8vL8Hg8GS0MMzsbVbJt0h1Dq9A7OjowOzuLwcFBVFdX5/TdyicblVlBijGD1ZUrV/QMVoFAIO7zKIceIypPiZ1iZst0n8agIvHeSlqbpQUVwWAQV69exa5du0wtZ6lPe+JISWHl0kbYbDa0t7djamoK9fX1OHHiBLxeLwKBAHw+nyXHNEuyYMGYwWp5eRnj4+MYHh7WM1gZy8pgo0isTimoBRvLy8ubUsoag4qamhq0t7fHBRVb7XOn2e6VeDgcxvLyMlZWVnDu3Dmsrq4iEonA6XTC4/FgZmYGNpsNfX19KfPCZ/semTGNKhUhBNra2tDa2orLly9jZmYGJ0+eRG9vb0YVeq7l07bLdWQj1fGEEGhqakJTUxMWFxcxPj6OUCgEv9+PpqamsqjEqTwZ26lCSLxhay5p0MPhsCV1dqkHGzuJlFKfhaEFoHa7Hf39/RnX8WaUIZ8L/+bmZrS3t+Pq1at4/fXX4XA40Nvbi+rq6pTb5JsiPR9bHbuqqioug9Xo6Ci6urrQ0dEBu91eFu3Utg02jD1G+ZwIiSMVWgW9vr6OCxcuZB1UpGLF2hKz7bRKPJvPMhqN6ueHVkmHQiFUVFToC5FbWlrg8/n037W1BCsrKxgZGYEQImnQUcgF4pnS0sx6PB50dHTg7Nmz+jqPrW6mpc1PzVY+WawyqYhrampw6NAhrK6uYmJiAiMjIwiFQiU1vYC2D+PIhpmMyUU2NjZw6tSplOsAs53+ZNV0r1JW6uXLlZQSGxsberu1sLCAhYUFDAwMxC3ob2pqQjQaxdmzZ1FZWVnQoCMXWn0thEBjYyMaGxtx7do1DA8PAwB6e3tRV1eXcrtc5Huxn+mxjRmsLly4oCdwiUQiDDaKwel0IhwOA8h8ZCNVUJFspMLhcGBwcBD79+83rczlcCFfDsPdZtkq44oWUBjX3mjTDRoaGtDd3Q2HwwEhBObn5zE/P59yulRNTQ0OHz6MxcVFjIyMAAD6+/vjLtpLLdjQGId6FxYWMDIyAikl+vr6klbo+Rwrn/tzZLOd1+vFgQMHsLGxgRdeeAEvvvgiOjs7sXv37m174UGFZ2yncpFJxkJt1DSfNRVGpZJOt5D7A8p/BD4cDse1WSsrK/o6Ua3dam1thc1mw3XXXRe3bSwWQ0VFBZqamjA/P59V0JHr+5bPhX+ybevq6vQ2dmxsDCMjI+jt7Y1bA2H2MbORbbDicDjQ19cHv9+P6elp/dqht7c37wQuVtmWwYbD4dCHhxNPgGyCilQjFVLKklvMR+bS1lVcuXJFr6TX1tYAxE85SFx7k2pfmVREqYKOQqU3zPdCura2FocPH8bS0hLGxsYwPDyM3t5eNDQ0xO3biulQVmzndDrhcrlwyy234MqVKww0yFTGEfh08kmDfunSJVPXAZbiQvZkdlJbavy8tRF2Y2ChjbD7fD54vV60trbC6/VuSv29urq6ZR1XX1+P+vr6uKCjr68vZbakQqY5z2Tbmpoa3HjjjVhZWdGDjkAggKamprzu4p3vyEau29vtdnR3d2NmZga1tbU4ffo03va2t5l+bywzFDTYOHLkCL797W+jubkZp0+fBgA89NBD+Mu//Es0NTUBAB599FHcdtttm7Z99tln8bGPfQzRaBT33HMPHt2cnLMAACAASURBVHjggZTHcTqdWF5exrlz51BTU4ONjQ2cPHkyrzUVRlYt5iv1CnK7NgqhUChufqoWgLpcLtTX18Pr9aKxsREej6cgQ5WJQcfS0hKWl5fR0NCQ0faFGtlI9dlVV1fj0KFDWFlZwfj4uF6ha3fytno6VLLt8rlHSEVFBdra2nLenigZYyITQPk+GS8Sc7m3UiKz26pyCDbK4TXnSwtAl5aWsLGxgatXryIYDMJut+tZwhoaGvR7T2QimzbAGHS88cYbWwYd2bJ6lEG7ge3a2hrGx8cxOjqaVx2fb2edGdu3tbXpazhKUUGDjbvvvhsf/ehHcdddd8X9/ROf+ATuv//+lNtFo1F85CMfwfe+9z10dnbi5ptvxu233x43jenMmTP4+te/jtdffx0vv/wyvvOd7+Cd73wn7rvvPtjtduzatSuvNRVWs6pCM3u+eSk3CluJRCJxAcXKygoikQgcDoc+lNzR0QGv14vJyUlUV1ejsbF4NwTTgo4XX3wR4+PjmJiY2DS9KplCBhvptvH5fDh48CDW19f1Ct3v9+eVVaqQQQrtTFZ3ioVCIQwNDeHMmTOYn5/Hf/zHf+DIkSNYW1vD5ORkyd1byahcgo1SCw5yJaVEMBiMa7eMI+zRaBQulwvd3d1Fub7ZKugoxsgGkPm1hcfjwYEDBxAMBjE0NISrV69iamoK7e3tWbUZxRrZ0OQzKlMoBQ023v72t2NiYiLr7Y4dO4b+/n709vYCAH7pl34J3/rWt+KCDZfLhVtvvRX33XcfvvKVr2Dfvn24/fbbAQBzc3NZ5VsuBisrcbMqoFJq9NIxTpXTKuiNjQ3Y7XZ9KLmpqQmBQMC0u2Knk+9nYLfb9YXLo6OjkFKmDTpKJdjQuN1u7N+/HxsbG5iYmMD09DRaW1vR1NRUkAq9HCpiKh1WdooNDAzgvvvuw+7du7GysoLW1lYcOXIE+/btw8DAAPbv31/S9Ww5BBtWsLp8Usq4dRXav7FYDC6XK67dMt4ocXp6GgBMub7J5zWmCjpyDZYLnZTD5XIhEAjo1w5Hjx5FZ2cnOjs7MxopKPSajVRKue4oiTUbjz32GJ544gncdNNN+KM/+qNNC0unp6fR1dWl/97Z2YmXX3457jl9fX3o6+sDoJw4VmT5sJKVIxtmKbUeqMQUfevr63jllVf0aQc+nw91dXXo6urSF2uXKyEEampq8Ja3vAWLi4t60NHX17dp4XmpBRsap9OJPXv2IBqNIhwO4+jRo/odU62s0HMdSTEq53OHsmNlp9hNN92EY8eOAQC+9rWv4fz58/rjZncOaczcpxVZE0utXUm2PzNJKbG4uJjRCHuhp8Skeq25Tq+qqKhANBrNuhzFyAAopURlZSV2796NQCCA8+fPx7VRiWtcjHbCyES+ih5sfPjDH8bnPvc5CCHwuc99Dp/85Cfx13/913HPSVZxpDsRE+fClgOr7geyHRhT9BnnNAPQU/T5fD44nU7cdNNNZfO6M20QE5+XadCRbVlyCTZyqSC1GwTW1NToFXpbWxu6u7vTjjTls2Yj1xERIo0ZnWJGidmotDbAzIsOK0a3Sz0bFVAa391UI+zr6+uYnZ2F1+tFc3NzwUbYC0kLOi5duoSTJ0/itddey2pNRzGCDWOnlDYy4/f7ceHCBbz88stoaWnRs0yaXV4zOsRKXdGDjZaWFv3/v/Ebv4Gf//mf3/Sczs5OXLhwQf9dm1OXSqFvlmSGchieLsRwd7KhZC1FnzaU3NDQkHSx9sTEREl+YVNVREKIjMqbanst6FhaWopLOWu320tyZMO4nc1m0+/L0dPTg6mpKRw7dgxNTU3w+/2mVuiFDlJo+7GiU6yysjKunbKqw6kc2oBSHonY6jUnjrCvrKzo6dCTjbAPDAxgz549ppbRDFZ8rrW1taipqUFPT09WC8mLESwma1/sdjv8fj+6u7sxPT2NV155BY2NjfD7/XA6nfrzir1moxwUPdi4ePGingXgH//xHzfleAaAm2++GcPDwxgfH0dHRwe+8Y1v4Kmnnkq5Ty0blVExIuVs7LRgIxKJIBwO49KlS4hEIlhZWUE4HEZlZaU+UtHW1pY0RV+hlPL5YlRdXR0XdIRCoax7ygoZbCT24tjtdvT09KCrqwszMzMYGBhAXV0dAoEAXC5X3Ha5jlBwYTnlw4pOscTpvlZNUcr1Jpqp9mdFGc3en1UBUSYj7C0tLSW3sD9TVmXarKurw80334xr165lHHQUYxpVqmPabDb9jt2zs7M4fvw4amtrEQgE4Ha7Tckmtd3bmoJexd1555147rnncOXKFXR2duLhhx/Gc889h9deew1CCPj9fnz5y18GAMzMzOCee+7BM888g4qKCjz22GN4z3veg2g0iiNHjuDAgQMpj+NyuXD16lX9d6vmwpqpHIKNXGgp+oyVs5aiLxQKwefzobGxMasUfYVg5vuW774yPXe1oGNmZgZDQ0MYGBhAf39/RtOrCj2ykWw7bXqVVqEPDg6iuroagUAAHo+HIxtUNFZ1ihmnUVkxRcnsAKYc2ikz9mccYb969ap+nx3jCLuWFp11RGqJn0OmQUexplFt9VnabDa0t7ejra0Nc3NzeO211/Q0w4W4g/hWSvkat6DBxtNPP73pbx/60IeSPre9vR3PPPOM/vttt92WNNVgMonTqKyYCwuY+4Uo90pcG0o29vqsr68DgD6UXFNTg46ODjidTggh8Prrr6O1tXXLu5BuB4VcoKxlLenq6sLo6Cii0WjaO3oDuZ3L+aSwTfddFEKgra0Nra2tuHz5Mk6dOgW3241wOFzQoIHBxs5UqE6xxJv67dRpVMXsFEu8CV7iCLs2WtHQ0BA3ulVKzLoGKWRygq2CjmItEM/0mEIItLa2oqWlBVeuXMHQ0BBisRiWl5dNu9dIpordoZypok+jskJisFEuaWVLvRLXet42NjbiKue1tTXEYrG4oeTm5ua4FH2FKB8ptPe0uroaN954I5aWljA6OorR0dG0QUexplGlIoRAc3MzmpqaMD8/r/ck9fb2bnmvkVyOl2w77fwt5R4jMlehOsUSE5lYUR+aHcCUSzuVuD/jXdiNN27N5CZ4Wtr0UlTqMza2Kl9i0FFRUYH+/v6SDzY0Qgj93jszMzM4d+4cbDYbent780rYko1y6RTblsGGy+Uqu4V3pZhSMBwOx1XOV65cwdzcnN7j4/V60dXVBY/HU7KVcSkodECVWGlmEnTkckFu9jSqVIQQaGhogNfrRSAQiFsMn260xng83p+DSk1isFEO7ZRVc/rNKqOUEqFQCOFwGBMTE/pibQD6XdhramrQ3t5e0jf53U4yeY8Tgw4tDW0h5VPfSynh8Xiwa9cuLC4uYmxsDJFIBL29vaivr7f0PCuXdmpbBhupplGZyapRAzNlWkZtKNkYWIRCIVRUVOjzU1taWmCz2VBXV2faXbV30shGIRu1VBfzWtCxvLyMkZGRTUFHqQYbRrW1tTh8+DCWlpYwNjaG4eFh9Pb2oqGhIeU+85lGxYsRskqhplGZvU+z5dIOaEFF4mJt7bU6nU7U1tZuugleocpXjqyaRpUNLeg4f/48xsbGMDg4iP7+/oJMTcqnvje2MTU1NXo7OzY2hpGREfT29qKxsdGS9qRc2qltGWw4nc64SnynDk8D8V/2WCwWl6JPW1dhs9n0kYqGhgY9l3TiCTw/P296+XaCYo9sJKqqqooLOkZGRlBTU5P1Av1ce1TMGPatrq7GoUOHsLKygvHxcYyMjCAQCKC5uXnTa+eaDSpFhRiBt2LE3GxbtX1atkJjh1i6m+DNzMwgFouV7BqLnSTXAEbL6tXa2opz587BbrdbHnTkE2wl27aqqgo33HAD1tbW9KAjEAigpaXF1OCgXNqpbRtslOPIhplDycFgEKFQCNPT0wiHw1hbWwPw5lByVVUV2trashpK3ik9PFYoxZ4HY9Bx6tQpRKNR1NTUZDQ1CSjOyEYin8+HgwcPYn19HePj4xgdHYXf70dra6teARczKCJKpRBrNsqhztbKqN0EzxhYaOsltBH2Yt0Er9TfQzOU0mvUylJXV4ebbroJ165dyyjoyOc15NMupWsrPB4PrrvuOgSDQYyPj2NsbAw9PT1oa2szpX0pl7WF2zLYKMQ0qlIZ2QiFQptugheLxeByuRAOh+F0OtHe3p70JniFKmOh9me2Uv7ippNtpVlVVYXOzk4Eg0FMTk5iZGQE/f39WwYdVmWjyoXb7cb+/fuxsbGBiYkJjI+Po7u7Gx0dHaYsECcyWzm2U2bQRti1Nuvy5cuYm5uDw+FIehO8XBbtlvo6lVJVqGxU2ZYl26AjF/nU95m8TpfLhX379mFjYwOTk5M4evSofu+OfJRLO7Utg41CTKMq9IV3JBLZlKLPOJTs9XrjhpIB4OzZs6ivr98RqWVLWalNo0rF7XZj9+7dWF5exujo6JZBh9XZqHLhdDqxZ88eBAIBvUIPhUI5fQbl0mNE5Snxpn7l0E5lQ7sJnnGkIvEmeFVVVQiHw6ivr9ez+ph1bCo+s0e/two6zJ4KlalsLvidTid2796NQCCA8+fP4+jRowiHw4hEIjndwJjBRhFpvfqacplGBUAfSjYGFolDyU1NTRkNJZf6SEQpX8BZ0egXSq436NMqrKqqKhw6dCgu6Ojr60N9fX3ex8lnu2w4HA7s2rULgUAAzz//PF566SW0tbWhu7s74ykY5VKJU3lKvKlfOY9sGG+Cp/0bjUbjboLX0NCQdIR9ZWXF1LKYXbeU+gi8WUopjW4mKXMTg46+vr68brKYbzaqbLfV7i3S1dWFF198Mac2CiifdmpbBhuFyPKR7z61m+AlVtCDg4OmDCUDpR9sAOyBsooZmaUSgw4te5UWdOQTbBSqcqyoqIDT6cRb3/pWTE1N4dixY2hqaoLf799yQXy5VOJUnux2OyKRiP57OXSKRSIRRKNRzMzMJL0Jns/nQ1tbG7xeb8a9tOXQTpWyUgkQkrG6Q8oYdAwNDUEIgWg0mktR82qXYrFYzuuIbP8/e28e5Vhdp40/N/ueVCWVVPaqJLV0d3V3Va80nEFBm0YUkFFoAQWEcfAVHHV0fvI6uMDI23DGbZxBmCOovI7iAC6MvC07aItdXb1VL9VLVaX2fa8klVTW+/ujvbdvUtlzk9x05znHY5PKvfebu3w+97M8z4fHg1QqxbZt2zA+Po6uri7odDo0NDRALBZndexK8FOXZLDBJeIdVUpOlOgDEDcEz2AwwO/3Y9u2bSVfYxXFBfMaMOUavV4vNBoNbDYbq8Yin2uezrinCjoKcSSl2IYJPp8Pu90Oq9WKiYkJHDlyBDU1NWhsbIREIkm6TaUY8SoqE4n3VqpgY34lhG/9v15EYyQe+XAz6pSZX0Ao5OsDqCF4TJ9FDcELh8OIRqMph+DlCq4HG1z2o1xdF4VSVb+poGN2dhYnT57E8ePH4XQ6oVKpst5HIe29bLRg8fl82Gw2WCwWTE5O4ujRoxl9FHN7ruOSDDZKJSmYuM9CSskA98u/XN8fl8B01jMzM1hdXcXExAREIhF9L5hMJng8Hhw8eBB2ux0mk4kVo5FvG1WmbRKDjpWVlZyMOROlmumRCB6PB4vFArPZjKmpKRw/fhwqlQqNjY2QyWRx360UI17FpQGCIHB8wo+7ft2JOoUIT9++ETUyIZ7rHMPBwSUAwH++N4KHr2/Kep+ZfB9VYWfKymYagnf48GFYrdbCfiwDl7IfqCRQ18Dn88X9LxgMQigUwuVypZ1nlAqlbLVVqVRQq9VobGxEb28v3V6VjZ8qlO9RSFWEuS2Px4PZbIbJZML09DSOHz8OpVIJh8Oxxkclbs/lKtclGWwUW+UjEokgFAphbm4Os7OzrJSSAe4HGwD3MymlBjVcimmcmTLDCoUCMpkMGo0Gdrs97hrHYjHodDrY7XYMDg6is7MTDQ0NMBqNBd0LxQo2KFBBx9DQEMbGxnD48OGknA42wfaLP0EQMBqNqK+vx+zsLE6dOgWpVAqHw0ELKjBL41w24lVUHv7YO4svPH8cnqv+AbPeIOqUYvB4PPy8exHLgTBWghG8cXYWt201waSRQMi/cP9ZNKkznMlA+YB0Q/CYFXY2huDlimoSq/RI5rc8Hg+i0ShCoVBcG7dAIEAkEsHAwAAGBwezUipkHiff9RUSpGg0Gmzbtg1LS0tZBx2FVifYDlQIgkB9fT0MBgPm5uZw6tQpSCQSOByOOBWuSkmKXZLBhlAojCPeFaOUTCkHGAwGVkrJxcLlQuguBahJ60wDHYlEIBaLaWedrHI1Pj4OYO35o/5bKBSiubkZDQ0NGBgYwNDQEJxOZ9IBddmg2MEGBYlEApPJBL1eTw8HdDqd0Gq1Oe0nGxTLoBIEAb1ej7q6OiwsLODs2bMQCARwOBwVY8Sr4CZOjS3jKy+dgEElxn/csQUqycWe7h++2YtAKIKYVIO3zs/hE9vM4PF42GQQY9QTAQFgg/HCC8XeLUbUyUWIkCR2t+oyHjccDtP+anZ2FqFQCCMjI3FV1UTlwlzBJpmY60mxSg9esvVbq6urWF5ehtPpXLO9XC7H5s2b6UGwAwMDcLlcUKvVaY9dahGRxO2YQUdfXx94PF7KoKPQ6kSxAhWCIFBXVwedToeFhQWcO3eODp7UanXF+KlLMtjItheWArOUTAUWzFKyQqFYU0oeGBiASqXKOsIvB7heKeGqESdJEpFIBMvLy1heXqZbC6hJ61QGkO3hUiKRCK2trVhdXYXb7cbg4CDNjcgVpQg2KCOpUCjoad5MTgebQUexlVIIgoBWq4VWq8XS0hL6+/uxsrJSsAZ6FZcuRhf8ePHIKLY21OJ9zWtlW/f94SwGZ30YXfDj5e4JfOoKO/23a1sN6J3xIbgawybzhRcfgiBwe5sSN29zoEYuhEUjpT//QJIgI9UQPIFAQMuhq1QqiMVi2Gw21n43Zbe5GmxcrkkxapgvM6jIxW+trq4mPXfMz6hBsMvLy+jr68tq3gUXlBg1Gg22bt1KBx0EQcDlcsUFHcWoTmSDbIOFRB/ldrsRi8WgVCrTcjq4gksy2EgEj8dDJBKJKx0ydb8TS8l6vT5jKZmrL8pMVMIay41IJBJnnCmeDTVNW6fTwWAwQCqVlsxoSiQSbNiwAX6/H263G36/HwsLC1m3KbFNEM92G4VCgc2bNxcl6Chl9oZyTKdPn8bs7Czm5+fR3t7O6gCpKrgN6hlK90x8+qddGFkIQPyXIfzugavgrIufZ7TBpMLp8WWQAFwJf/vcNU5cu06PvR/9CNZ98zoAF/wUSZLYaI7PuiYOwaOSYTweL6Ny4cTERN7qPKlQrUSUH5TfWlpaQjgcpq+zRCKBQqGgRWeK5bfUajWtAnX27FlIJBK4XK41nIJytVGlQrqgo1RzNpKtOddtNRoNtmzZAq/Xi1OnTiESiUAmk6G+vj6vNZQCJQ827r33XrzyyivQ6/U4ffo0AOCf/umf8Pvf/x4ikQhOpxM//elPodFo1mzb0NAApVIJPp8PgUCAI0eOpDwOn8/H66+/Dp1OB4IgEAgEMDk5SZcO5XI5LBYLZDJZXqVkgiA4N5k1EcXIGHFhano+oBw2M6igWuIo48zk2fT19UGn07FSuco36yGTybBx40YsLS1hZGQEbrcbTU1NSZ+NxOOVorKRaptUQUdtbW3J1T4Kub8oUqRUKs1KgrCKSwOnxpZxz8+6wCMI/N97d2CdMXmftz8cBXDh/loNr32hf+hD67DLqYVOIcYmS/wzSxAE1hlV4AU99L1NEATNBaQCC4r/xRyCV19fn/VLJJVoYxNUp0C+LViJ4HpwUM71kSRJV6+S+S2CIKBWq2G32/MaCFcoampqsH37dszPz+PkyZNQKBRwOp2QSqX0+svZRpUKyYIOPp9f1AniqVBIRUWpVMJkMiEajWJqagpCoRAGgyGvfRUbJb8777nnHjz44IO466676M92796Nffv2QSAQ4Ktf/Sr27duHJ554Iun277zzDnS65H2rP/zhD/GHP/wBk5OTmJycxH//93/jrrvugs1mg0qlWtOLWAioLBSXcbm0PSUikfi2srICkiTjWuLMZjPEYnFFlNz5fD7a29vh8XjQ398PAGtKwEyUO9igkCroyJc/lY8jKCTjRG2bq9BDFdxDOBrDxFIAZo0UAn76++HnnUNY8AQQi8Vw0xf3oe+/9wFYmxT7zr5/xy+PzeBKpxYbTBd717NJis3OzuL06dMIh8O4++670dHRgV27doEkSTohlk65MFsUIynGdb9SKX4qEcyuC+r/Y7FYylZuABgdHYVQKGTFPuX7wkwQBHQ6HbRaLWZnZ9Hd3Q2NRgOHw8HZYIMCM+jo7u7G6uoq1q1bl7PKYrmqItSxpVIpnE4nq23dbKPkHvTqq6/G0NBQ3GfXXXcd/e8rrrgCL730Ul77vvbaa3Hrrbeivr4eHR0deOaZZ0AQBObm5uDxeApZ9hpcjpUNriEWi8UZZr/fj66uLgiFQrpaYbVa865ecQ0qlQpbtmzB0tISzp8/T2feKfUkCqUMNrIxkolBh9/vx/z8fE6VjnyNORvBBnD59oFfCohEY/jYU3+Be8aHTRYNfvmZnWmv5wda9fh99xgAAciZXvrzxKTYyz/9d/xHHkmxRx55BAcOHMDGjRsBAHfeeSd27doFHo+HsbExzifFKiE44PL6SJJcIy8bCoXi/FahBP5ygCm2MTU1haNHj0Imk+UlnlPqIEWj0UCn00Gj0aTkdKRDqduo2Dp2KcG5dN1PfvIT7N27N+nfCILAddddB4IgcP/99+Pv//7v4/7e1taWcju2jVmxKhtcJ96VY38keWEwIrNSQbUXUDyb2tpazM/PY8eOHaytjy2kuqb5nkuNRoPt27djYWEBPT09kMlkcDqdSTW4C11jOuTaSkEFHQcOHMD4+HhO7VX5GtRyZpyq4AZmvEH0z/gAksSxkUV4g5E4ZahE7Gkz4vV/vAYT42O473fn6c/ZSop985vfpP99zTXXYNu2bVCr1XQmm00Uw/dVgl/hAlLJovv9foyMjKTl2uRyDDbXywYI4oKsuMFgwPnz5zE5OQmRSISGhoasKzD5voAXOitDpVLBYrGkJZInQzHVqLLZvhL8FKeCjcceewwCgQB33nln0r+/9957MJlMmJmZwe7du9Ha2oqrr746436LMdSvmOVprgYbQPHnbESj0bigginTR2V9dDpd0vaCSnjg2ERtbS127NiBubk5nDx5Ekqlkm5TyvVclKoaAlxoC9u0aRN8Ph8GBgbQ398Pl8uVNugod2WjispFvUqCXQ4tDvTN4UMb66EUZ3Z71loZop7UGdlCkmJMiMVieiZUsQIDrgcwXN9fNshFFv3o0aNYv359SdeXLdgM1Hg8HrRaLfh8PkQiEQ4dOgSTyQSbzZYxSVVIZYONCkM26lVsHbdQP1MpfoozwcZzzz2HV155BW+99VbKm8xkMgEA9Ho9brnlFnR1daUMNqhZGEKhsGgTxNkm3nHd6LJpiEiSRDgcxvLyMrxeb5xMHxVUFENelktg43wSxEUN7pmZGRw7dgx8Pj9nVYpy8DwUCgU2bdqElZUVuN3uuDkdifstJ2ejisoGj0fgmbu3IRiJQSIsvC2FzaSYSCRCMBj86zqL46cut8oG22AGbIXKy1IotpQ3l0AQBGw2G8xmM0ZGRtDZ2QmLxQKr1ZrSvpa6jQpIXmGggg5K6pcgCHq+ReJxq21U6cGJYOPVV1/FE088gT/+8Y8pW0GoErNSqcTKygpef/11fOMb30i5T7FYjGAwWLRgoxLK0wA3elfD4fAa4ls0GkUsFqMl+kotL1tKpDOAbFaxDAYD9Ho9Tp48icHBQQSDwayDtVIFG8kMulwujws6mJK51HerlY0qCgFBEKwEGmwnxZiVjcvVT3F1f5S87OLiIlZXVzE9PV1SedlSo9ht4Xw+H42NjbBarRgaGsLBgwdht9thMplYs7OFPD/pfIxaraaDjv7+/jVBB1faqLh8H5Y82Lj99tvx7rvvYm5uDhaLBY888gj27duHYDCI3bt3A7jQD/v0009jYmICf/d3f4f9+/djenoat9xyC4ALRuCOO+7A9ddfn/I4IpGoqOXpSnAMxbjx0q0vUV7W5/PRQ6aoybVMednBwUE6E3RZIha78D8WSYAEQUClUqGurg6xWAxdXV2or6/PKI3IBQWrdEFHlbNRRblRjKRYJfoptvdZ7mCDkpdltkEx5WWBC+IcjY2Nl7wqHdvvDMnsr0AggMvlgs1mw9DQEDo7O9HY2Ij6+vq45FK+9r6Y8rWpgo5y+plK8VOsPjmrq6sQCARpH8jnn39+zWf33Xdf0u+aTCbs378fAOBwOHDixIms11Ls8nQlOAa2+3WZD1MyeVngwmwIuVyetbws18vnbCDVb+T19IAQCID29py3zXQ8giBgsVhgMpkwOjqasV+WSwpWyYKOfAcDVtWoqkhENn6qHEmxSvFTXK/Ap0MmeVmVSgWj0RgnLzs5OYlIJHLJBxrFugapbKdIJEJzczPsdjsGBgYwNDQEh8MBvV6f91oKJYhn6ysSgw6PxwOfz5f14F0mqsFGDgiFQvj973+PI0eOQCQSYdu2bbjmmmvWSHKWElQbFVA5BrfcGZ5kiEaj9FCh2dlZ+v8T5WXlcnnONzyXX+CKcW3pf8/OghgaAnHu3IVgIxQC2dAA6PVJ11FIEMDj8WC322GxWOh+WavVCovFEne9ytlGlQrMoOP06dMIBAKora1NyulId7xqG1UVQG5+qlRJMaafqoQqBMD9CjyVZEsnLyuXyytSXrbYKEZlIxPEYjHWrVuHQCAAt9uNwcFBOmmZz/FK2c5EBR0HDhzAwMAABgcH4XK51nA6Mh23EF5qpfgpVoKNZ599Fl/72tewdetWhMNhPPvss7jpYlI/5AAAIABJREFUppvw+OOP5zwchS0Uuxe2Uox4tvtLlJelZPp4PB6d9VEqlZBKpWhqamJtjZcjSJEI/OFhwOcDIRCAHBwEWlrY238Sg5upX7aYczYyrS0T5HI5bDYbPB4PJiYmknI62DweG9tWwT1w1U8xk2Js41JPiiWTl/V6vbTvZ0NeljoOV8FlG5WLDZVKpWhra4Pf78exY8fg8XggFotRU1NTlOOxuS2fz8fWrVvXDN7NJugo1M9cFsEGdZK+973v4Te/+Q2uueYaAMDAwAA+9rGP4ZlnnsEXvvCFsmQOquXp1PuLRCJrZPqi0WicvGxdXR2kUmncTTw/P4+lpaWir+9SwxpjolYj1tIC/tgYEIkA69YBKYwS2xUHZr/s4OAg3S9b7CoFc235qkqJxWK0tLRgZWUFAwMDcLvdcDgc0Ol0KddRqCEmCILTzryKzKgUP1UMVLKfSkS28rKxWAxjY2OsycsWo/LCViKDi3M2EpHr75TJZNDr9ZBIJBgaGoLb7UZTU1PRX9wLVYUiCGJNexWQOeiotlHlgMXFRbS2tgK4UKp2OBzYv38/brjhBtx5550wGAxsHCYnVCsbFxAKhTAzM7OG+EYZZ4PBAIfDkVUZ73IJDkqF8Ec/CohE4C0vp/1ePsYz0zYikQgtLS0IBoMYGBjAwsIC5ufnYTabsz5eqQIU6liUQZXL5di4cSMddAwMDKQMOirFEFdRfHDdTxUDleCnEveXKC9LDXHNVl52ZWWl6qfyRDnaqFJtJ5PJYLPZ6Bd3Ho8Hl8sFpVKZdrtyqUIxkUvQwWawweXEGCuVDavVCrfbDaPRCJFIhEgkAqPRiLm5OZo4XGowCeKVkN0pdJ+UvCzTQIdCIfB4PAgEAiiVyjXEt3Ljcglekv3G2MaNF14CxGKQLBPoc9mG6pf1er1YWFjA2NgYXC5X0VqUCpGwTdyOCjr8fj/cbnfSoKMabFTBZT/FbKMqBrjmpxJBycv6fD6cP3+errIXKi/LlTavSwGFvC+wMS+DenFfXFzEuXPnIBKJ4HK5knI6uNY2m03QUW2jygLUD/zyl7+MhYUFBINBiMViCAQC+P1+CIVC1gffZYtiSwqyrfRE7TPTOmOxGE3YpoIKprysQqGgiW+Li4vweDxobGws2fouJbBpeJLtK5v9l+qFniAItLa2IhKJoL+/HwMDA2hqakrbL1vqYCOVGoxMJosLOihOh06nK7g0XkXlo1L8VDHAlap+OnlZsVgMkiRRX19Py6IXAq4k0yoNxXjZLiTYSERNTQ22b9+O+fl5nD59GnK5HE6nE1KptODjUSjWvcMMOtxuN0iSpIOOQoOFSuEWFvRUU+XKT37yk2v+Njo6is9//vPQ6XSFHCJvFJt4V4zJrEwjziS+MWX6ANCE7WyIb5UqUVjFRZTqhR64cG9t2rQJPp8PfX19aftl83mRL2ReRqbtkgUdGo0GYrE45+NVcemA637qUuNshEKhuKAik7ysz+fDyMhITgo+hayv3PurIjuksvdarRa1tbWYnZ1Fd3c31Go1nE4nHbRy+cVbrVZjy5YtcUEHj8crOCFWCdzCvIIN6oL+4Ac/QCQSQVtbG8xmMyQSCdatW0cTOVtYVNjJFZVUnqaIb36/H6OjoxgYGEA4HIZIJKKrFTabDTKZLKebshjENrb3dzkY8WS/kSRJBAIBCASCtMTUQuZs5LoN895SKBTo6OhI2y9b6spGtvc+M+g4efIkgsEgFApFWiJ5OnDdiFeRHJXip4rZwlXMYCOxyp6vvOzl4gcuR7BZ2WCCIAjo9XrU1dVhenoaR48ehVarhUgkqggpY2bQcfz4cZw/fx7r1q1jLeDmIvIKNqib54477kBXVxcOHz6Mf/mXf8HU1BTefvttrF+/ns7Ql6uFQSwWIxwOF23/+ZaSV1dX47I+TOIbSZJQqVSor6+HSCQqeI3VDA83QDnlsbEx+rpT6krhcBhOpxN6vT6lUS7FC3Kq65quXzZfNapCe3izhUwmg8lkQiQSwfT0dFx7VTZ8lCoqG5XipxYXF+M+YzM7y4bNTpSXnZ6eRiQSwcjISE5V9kzHYAuXm59i615JvO+ohJjX60VNTU1ec9PybWPN9hkgCAL19fXQ6/WYnJxEb28vVCoVTCZTRQxhVKvV0Gq10Gq1a9qrLjUUdDUaGxvR2NiIvXv34vHHH8ePfvQj+gKXu0+aSRAvBjIZtFTyskziW11dHWQyGf1Q9ff3Q6FQsBJoZLPGKlIj34oCc1aJ1+tFIBBAOByGXC5HXV0djEYj3ZdMZQfdbjeGhobQ1NS0ZgJpsQnizG3SPbPJ+mUjkUhealT5St8WIpnrcDjg9/vjJHPr6urSth9WKxqXBrjspxLbqNiURaX2lwuykZetra2lA/lyrDGb/V0uwQub3RWBQCDOf0WjUUilUsjlcoyNjUGj0cDpdLL2fpIOuT4DPB4PZrMZoVAIXq8Xhw4dgtFohM1m43zQEYvF6ACJ2V7ldDqh0WjKvTzWUNBV6OzsBI/Hg1qthsFgwP79+9Ha2orm5uayO+tS9MLGYrG0xDeqlGwwGOB0OjPe9Fw3klzfXylBVSu8Xi993cPhcNysEr1eD6lUioGBAWg0Gmi12jX7kUgkaGtrozkSg4ODaG5uptuVStWqlO11YPbLnjx5Ev39/WhuboZEIina2grZjhmkyGQyemgUUzI3WdBRKQofVWQGl/1UIkG8VDaxEHnZsbExVtdSyX4gX5Tr9zKrVJTvoq47QRAQi8VriPqxWAxNTU2YmZnB4cOHYTAY0NDQkNVLfKntPQDodDps2LABo6Oj6OzshNVqhdVq5aw9Zyb6knE6LpWgI69gg3LE/f39eOGFF+D3++mXjbq6urjvlMuQF6OywSS+eb1eeL1eHD58GDKZDHK5vGB5Wa6/zF+OTgGIlxX2er10jzVzkJTdbi8o40NxJJaWlnD27FlIJBK4XK68nqFiByhUv6xGo4FGo8GxY8eg1WrR2NiY8RzkW1ZnsyKSTdBRDTYqH5XgpxKTYlR7Lpt95yRJYnl5OW2VPRd52XR+IByN4f+81o+h+QAeus6JFkPm1pvLzU+V6l5L5NR4vV6aC6pUKtd0V4yNjdFBebI1G41GGAyGnF7iyxFsEAQBPp+PhoYGWCwWDA8P4+DBg7DZbDCbzazb9ULvtWTtyFTQQU0kzybo4HolPq9gg7pYn/zkJ5MqfABYYyxLnUGSSCTweDx5bZsN8c1kMmFlZQXbt29nbc2Xm9EFuNUbT/Wo+nw+eDwe2ikzZYWtVivkcnnRXkQ1Gg22b9+Oubk5nDhxAgqFIi/pylIRoQ0GA6xWKyYmJnD48GHo9Xo0NDSkHBJZyFC/fLdLda0Sgw6K01FXV1cNNi4BVIKfShQyKUSqNlWVPRAIYGpqCgqFghV5WR6Ph0gkgjOTXvzz789DKxfhu3+7DmqpEG+em8OrZ2YRjMTw6P4+/OLTHRn3x3W/Vwl+NBKJxFXZKQU2JqfGZrPllRBjPg88Hg92ux1msxlDQ0M4ePAgGhsbYTQaWX1uCqlkM7cTCARwOp2w2WwYHBxEZ2cnGhoaWF1voTYjna9RqVQ5Bx1cRcHNbMwTPT8/j+npaXg8HkQiEUilUlgsFhgMhpJHXcnaqJIRoJjEN6qkCGSWly2G8aFas9jcH5eNbjkjcao3mWmgqR5VhUIBoVAIk8mUtq8/W+RqjAiCQF1dHXQ6HYaHhzE9PY3+/v6cStelAPW7CIKA2WyG0WjE+Pg4urq6UvbLlkKNKnG7TMdLFnRYLBZ6O65njKrIjErxU9n6gGRDXEmSpO0XU172yJEjBSlu/dm9gO+9NYBNZhW+/qEm2g/82zuDGF4IYHxpFa+cnsGd283QKy/ITIv4PJg02UlOV8LLPFeQ2P42PT1N89KoakU2CmC5IvG5EAgEcLlcsFqtGBgYwPDwMJqamtZISBdLjSrddsmOJxQK0dzcDLvdjsHBQQwNDWUUZskWbMzJyLR9qqBDpVJVjH8qONggCALLy8t455138Nprr6GnpwcLCwvg8/moq6uD1WpFW1sbbrjhBqxbt46NNWcFkUgUp0ZFEASWlpbozHUy4ptWq81aXrYYF5jt2R3FMOKV6BQSSdvM3mSlUpmUU3P+/PmyT1un2pUWFhYgFApx6NAhWK1WWCyWopSuc0WikeTxeLBarTCZTBgdHcWhQ4dgNpthtVppx1dsdZJE5CqZSwUdvb29WFxcxMzMDOrr63M+bhXcApf9VGIbFdPGsiUvmwlHR5bxP6emccOGOuxsiB/k+ej+PsyvhDDlCWLP+jo4ZBf8ynqjEqcmvCABOHUyAMBWmxr/9vENGF9axfUb6rI6NteTYkB5/F40Gl3DC4xEInHtb1qtFiqVCgaDoeDj5WNjxWIx1q1bB7/fH8c5pFqxilGRzrRduuOJxWK0trZidXUVbrcbg4ODtEJhvmCjspHt9olBRzQaZX1oZ7FQcLBx5swZPPzwwzh79iyuueYaPPDAA7BarSAIAlNTUzhy5AjefvttHDhwAF/96lexa9cu3HvvvXjllVeg1+tx+vRpAMDCwgL27t2LoaEhNDQ04IUXXkg6vfi5557Dt7/9bQDAww8/jLvvvjvu77FYDMPDw+ju7kZ3dzfuuOMOfPGLX0QgEMDExARUKlVK4lu5wXUjWQzVEDYfFJIk45wy5ZiZ80p0Oh2kUmnFtMhQRpcqXQ8ODuLgwYNwOByor69Pek1KGWwkOw6zX3ZkZASdnZ10v2y+bVTFHAaYCJlMBqfTiVgshtnZWfh8vpK+gFbBPrjmpyhQlY1YLIZwOIxwOIzx8XGEQqGsq+zZYM4XQjASg1mzVsghEI7iwRdOIxiJ4fUzs3j98zuhlFx8NWjUyeANRgACMKslICJhkCSJz7+/AdtsamhkQmwwXpy/s6MhtxaPy83vJQOzw4JKiAGgE2Kp3ln8fj8nMtsymQybN2+Gx+NBb28vBAIBmpqaAJS2Mpyt75NIJNiwYQP8fj/6+/sxODiISCSS1zELrWzksz0VdMzPz+PEiRM4cuQImpubaS4aF5F3sEGdoDfffBPbt2/Hb37zm6Tfu+WWWwAAP/nJT7C6ugoAuOeee/Dggw/irrvuor/3+OOP4wMf+AAeeughPP7443j88cfxxBNPxO1rYWEBjzzyCI4cOQKCILB161bcdNNNtLGfmZnBnj170NDQQJO2v/SlL2HDhg04efIkmpqaSiLbli+43qbEpXJ3JBJZQ9r2+/0YHh6Oc8xcmB7N1ss/ZcBtNlucXC5bpetckSlwEAgEcDgcsFqtdH+vSqWKGwyYLdjq4c1lO5FIhA0bNlRMYFrFWnDRT5EkiWPHjuHkyZN4++23cejQIWzduhU/+tGPwOPxIBQKYTQacx7imgr9S1F84enDiJHA/97jws2b1mbBCcY/Eh+X739sPf7YNw9XnRy2WilmZ30XgniCwFXO2sRd5Qyu+z02QZIkotEoZmZm6IpVMBikK1UKhQJ2uz2na8+l36tSqbBt2zbMz8/j1KlTdItXrigVsVwmk2HTpk20XO6RI0fgcrly4kQU6m8L2V4ul0OtVqOpqQkrKyuXZrBBPQj/8A//AABYWVmBXC5f8z3K2d977730Z1dffTWGhobivvfyyy/j3XffBQDcfffdeP/737/GiL/22mvYvXs3PYtg9+7dePXVV3H77bcDAPR6PY4fPw4AePvtt/Hiiy9i48aN9HrZLjex/eJdLScnPx6zR9Xn8yEQCNDSwkqlkm4jOHbsGDZs2FDS9RUbyQyRWCzG+vXrU5augdI4oGyNpFAoRFNTE+x2O06cOIH5+XlIJJKceuTLMZ+D2o5LzryK3MBFPwUAzzzzDFpbW3HddddhYWEBv/rVrwBcaN/MdoAaSZJ45fQMFvxh3NphhEyUvI3qzHwMq5EYCABvnptdE2xIhXz86BNteOXUDPasr4NCHP9aIBPx8aENevq/ue5XuOJHo9HomoRYNBpFMBhEIBCAWq2G2WyGWCzmhI1hM0lFSaR3d3fD7XbD7/fn1E1SahUrqpW+ubkZfX19IAgCTU1NWSXG2BATyfe8U8dWqVRJK6xcQkFtVNSFffXVV/H6669j165dMBgMtCRmbW0t5HI53S5DkUmTYXp6GkajEQBgNBoxMzOz5jvj4+OwWq30f1ssFoyPjyfdH5sqH6VCJRDE2UTi+mKx2BrSdmKPan19fUm4FInnbWQhgGf/MgqTRox7d1kh5Jcm253OeKYqXZcyIMzlOohEIuj1esRiMSwsLND9stmQ8MtBLK9WNC4NcM1PEQSBp556CgAwMjKCX/ziF/TfcvFTr56ZxWOv9iNKknDPruDRjyQnge80CvCXaR4C4Sg+tcOS9DvtFjXaLdlNLWbbl3LhRbsQUEIzTL9F8QIpv8Uc5nr06FHWhs1xpdMgGQiCoAnrwWAQXV1dMJvNsNlsGW1rOeYxEQQBlUqFrVu3YmlpCefOnYNQKITL5Uob/JdzVk85j50rWAk2+Hw+Dh06hN/+9reIRqOor6+HVqtFTU0N7r77buzZswdA4UYl2YOVap+pJrNyGVzJyJRif9TMEr/fD4/HQ/eeymSytD2qxUYwEsNznWMYGPfifnUYKtWFz586MIzTk14cGwM2mpS40pF9+0CxDUJi6ToYDCIUCkEmkxXtmPmCJEmIRCI0NjYiEAjQJD2Xy5V06CGFQjgbhQYplWLMq0iOSvJTXROrmBqYwqeulNHKTqngC0ZBkiRiMRLe1dT95kYFH689sAU8Ph88Fu5lLvuVYuyPiWyGuTJnV6RaHxdRjHNGPXuUcAjVTtvQ0ACTyZTyXJQ62EjcjpKgn5+fR09PD83jS+ZTy5mYqqSkWEHBBvUjd+/ejd27dwMA5ubm0NXVhZ/97Gf43e9+h507d2LPnj0Zb2SDwYDJyUkYjUZMTk5Cr9ev+Y7FYqFL2MCFSabvf//7k+4vmcpHtbJRelDa78w2KKpHlSAICIXCnHtU2cDIQgBdw0vYYlXDobtoQP7UP4+XT04hFA7hF8dm8PCHL7wA65UiYALg8wnUyErH+8nFeFKl64MHD+L06dPQ6/WcE0Jg/h6pVIq2tjasrKygv78fAwMDcLlcScvB+aqTVCsbVXDZTzGDjdMTXvzw0BIiMeD4ZBD/dU972rXcvMmA4YUA5nwhfOnaxpTfoxSu2Ag0AO5XzNkCJS88OzuLpaUlLC4uAgCdEGNjmCvXwPa1YNp7Pp8Pp9NJy+V2dnamrGyXQ8Uq2XaUT6XmXqnVajgcDno4aCFrZQOV5KcKr+MlQKfT4YYbbsC1116Ln//857QkW6YTctNNN+G5557DQw89hOeeew4333zzmu/s2bMHX/va1+iH/vXXX8e+ffuS7k8ikRQ92GD7BuO69G2m/UUikTVtULFYjFZTUavVsFgstJrK1NQUQqFQVv3J+WA5EIZYwINEGN/LHI7G8NDL57C8GsaLxybx009tpvudlWIB+DwCBElAI7243eeubsBmswp6pRjr6nNfbyH3Si7bEgRBE5vn5uZo+Vmbzcaq7nq+SGYc5XI5Nm/eDK/XSwcdTU1NUFFlJRRG9K4GG1Ukoth+6n9/69twj8+gViZM66eYwUYgHAUAkOTFf6eDSMDDVz7oyPi9SqocsIFc7QSTF0j5rtXVVXqYK8UPbG1t5YQNLTUKudbJXsRFIhFaW1sRCATQ39+PoaEhNDc3x5GySz2fI51/IYiLc6+mp6dx7Ngx1NbWwuFwQCQSVSsbWYKVYGNlZQUTExNQq9WQy+WQy+WQSCQIBAJ46qmncNNNN9GTmAHg9ttvx7vvvou5uTlYLBY88sgjeOihh3Dbbbfh2Wefhc1mw4svvggAOHLkCJ5++mk888wzqK2txde//nV6avc3vvENmoSXiETORrEMJJtRLdedArU/kiTjZldQPap8Pp+W6mP2qJYDb5ydxZN/GoZCzMe/3rIORvXFTESMvNAuJeTxEIrGEI1dPEc7GzT42h4Xzg8M48MdF7OWYgEP17bkp8VdqLHOB3w+ny5dDw8P05NT05WuS4F0z4tSqURHRweWl5fR29sLPp+PpqYmKBSKKmejioJRKj814AHEH3scH/jeAfC6/m9aP8WswG+zqfGJjWoMLEbwhd35D+FLBNeTWMVAqvVRw1yZxO1oNErzAinfxeQFLi4uYm5u7pIPNFLZ2GL5C6lUio0bN8Lr9aKvrw8A0NzcXBZ7n83xCIJAfX09DAYDJiYmcPjwYej1emg0mmplIwsU9CZI/dA//elPuP/++3HttdfCYDCgsbEROp0Or732GkwmE4D4G/b5559Pur+33nprzWfbtm3DM888Q//3vffeG6cYkgqJQ/2KVdm41IMNZo/q8vIyPB4PDh8+HNejqtfrIZVKcz4P+a7PH4ri3b551ClE2G5PLlH3xrk58HkEllcj6Jn0xQUbYgEPX/+QC6+emcW1zdo4TXmCIHBFYw00wWmIBeV3LvncX8xzyufz4XA4YLFYMDAwgIMHD8LlcrEyGT0fZPN71Go1tm3bhoWFBZw5cwYSiQTRaLSkZfVKMuJVpEep/dQbZ6YRI/gQSaTY87lv4tO3b0m5NmYgQBAEPt5WA4FAAGPdWsWsfHEptudmA2p2BVWtoHiBlPJQtrzASvm9XEQ29l6pVGLLli1YXFxET08P5HJ53vYeyC84ysXPEgQBs9kMo9GI8fFxnDlzBmKxGJFIpOTJ1UriFrLC2bjqqqvw5JNP4sSJE+ju7sb+/fvR09MDl8uF733vewBQ8qyARCIpuhoVF4ODROSyP6pHlSnVB1zsUa2trcXKygq2bt3K6hpzxY/+NIR3euch4PHwLzc2Y5NZteY7H2nT43tvD0IrF2Gzea18XSb1FTavQ6EBacptl5dBHD0K8tprMx4vsXRNyeWWWi4vl5f42tpamqQ3PT2Nnp4eOJ1OSKXSnI6Xb4aMsllcN+JVpEcuforH4+HU2DJqFSKYNdnfZ0zcuNmE/z4yimiUxO07bBm/z7y/Llc/VQiS8QL9fj96enroaoVWqy05L7DSUO7Oj5qaGuzYsQOzs7OYnJxEb28vnE5nTpzDUrbb8ng8epbX0NAQOjs7YbFYYLVas37fZSMZXCn3NCthmEqlwo033ogbb7yR/uzNN9/En//857i+61KiFG1UVMaIrUCqVMQ7kiQRCATijDOzR1WhUMBqtUIul8fdyOFwGGNjY6yuj/q9MZLEm+fmML8Sxkfa9HHVhkQsBSLgEQRIkPAFk6uwXN2kxY4GDQR8HgS8yn1ZTHo/RKPA6CiI/n7w3ngDMasVpEYD/HWgTzoDT5WufT4fent76aCjVMg18CIIAjqdDjKZDHq9Ht3d3dBoNHA4HFkPi8rX+XCJWF9F4cjGT33vjV787C9D4BEEnv/MFVhvyt1/tZnV6PraB0GCzKo6ynzGCYJANJqZr5EL2A5gyim2ki0vsLu7Gx0dHawck2vBVSLYTIaUO7FCEAT0ej19Pbu6umA0GmG327N6zyq1ihWFmpoaNDY20i3LNpsNZrO5aBK/FC67YCMZPvjBDyIcDuPBBx/Er3/9a0Sj0ZJWN0rRRlWMXli2y92xWAwejyfOOEejUUil0pQ9qun2Vyx0DS3h3/84hFiMxPhSAF/5oDPldx+42o6fHxqHSSPGzobUmflEYnilYs159/nA+/WvQbjdgEIB3n/8B8jduxH7yEdSb5MAhUIRV7oOBAIIBAI5VQ3yQb5tTZQTqqurw9TUFI4ePQqtVovGxsaiqMFUkhGvIn8k+qk/np9BKBKDgEfg1PhSXsEGcIG8nQuolw4ej4dIJLWMbT6oxMpGIi/Q6/XGDXOlZldQBO5ka+Qy2Dp/XA6CgPxfpgmCgMVigdFoxMjICDo7O2G322EymdLa5XIEG9S2AoEATqcTNpsta4nfQv1MJfkpVoKN2dlZvPzyy2hvb4dEIoFcLoder8fo6CjOnj3LxiFyBp/Pj3sQK6E8XWjwkmic/X4//H4/xsfHoVQqYTAY4HQ68+4rzOX3+oIRDM754ayTp5xsywSTpB2JpT+GUS3B/3dd6mCEayjUkK2BWo3YJz4B/ne/C6yugmxtRezDH06/TQrU1NRg27ZteO+999Dd3Y2amhpaZaMYyLfMTYEgCBiNxjiSnsFgQENDA6v9spVkxKvIDtn4qS9+sAlfeekUTGoJdq+vL/qaCCJ+gGCxkmJc5mzEYjFEo1FMTk6mnF2RLy+Qi+Dqbyh3G1Uy8Pl8NDY20pxDSi5Xr9cn3W+5gg2mrxAKhWhqaoLdbqd5kg6HAwaDIanEbzXYyALUBZqfn8eXv/xlKBQKWCwWNDY2QiKR4PTp0/joRz8KILOkYDGQWJ5m+2EqlxGPxWIIBAJx1YpQKASRSEQbZ51OB6lUiqNHj2LdunWsrTEbhCIxfOmlM5j1hWCvleL7H1+fVOOd+Xt3OWpw3y4rZn0hfLzDWNL1chkpFUKWlkA2NIDcuBHE0aNALAb8NcOXT6uSSCTCzp076Rf4+vp6NDQ0sF6NZEtQgcfjwWKxwGQyYWxsDIcOHYLJZGJN4rfQoKiK0uE7r53HP+5uBi9Fu2QufuqaVgOOfb34QUbi+ihUQlKskP2l4gWGQiGEw2HWZlew3VrE9QoCW+CqzRMKhWhpacHq6iotl9vU1LRG5a3UKlbUtsmOSfEkV1dXMTAwQA+v1el09PcL9TOVxC0sKNigflxrayuWl5exvLyM7u5unDhxAm63G/fccw+tHFXuE1GpRjwSiawxziRJ0j2NNTU1NEmp2Mj293pWI5jxBiETCzA470coEsvY0sQjCHx0c2mdfKlQ6D2SNIPT0gKypQUQCEDu2kUHGtTxcnneKINHqWzU19djdHQUBw8ehN1uz6r3NFsUmslJBI/Ho/tjqXI7RdK7XDJGlztXY3g2AAAgAElEQVSeOziErfYaXNO6dsAeUFl+qpjcQjb3l2mN1OwKZkIsGS9QJpOBz+fj8OHDsNkyk+mrqCywPfBOIpGgra0NPp8PfX19NOdQqVQWdLxC1pkpYJBIJFi/fj38fj/cbjc9vFar1bLSRlUp3EJWORtqtRrve9/78L73vY/N3eYNpjRtsXph2TLiJEkiFAohEAhgcHAQPp9vTY+q2WyGXC4vCfeFJEn82b2AieUgrl9fB7VUmLUj1MqFuHlTPd7qncOndlouGe5EoaCcL+WAA4EATCZT2gpCyvPNbBliTDOlkI8MMQU+n4+GhgaYzWZaZSOxDFyM4UmFgCq3W61WDA8P04FSvutkBkXlfgGtIjPUsuwdLtf8FJ/Pp+d7VAq3kLk/5uwKyrZRsyuUSmVOvEAu4nKpbBRjEnYx9glc4Bx2dHRgaWkJZ8+ehUQiQVNTEyfaqFJBJpPR4izU8NpCk2JsJ++KiYKDjVgshqGhIajVagiFQqhUqjhjWa4TkXjjsJ3dAfI34rFYbI2iBqXRHA6HIZfLYTAYytqjenrCi++8NYhIjMTZKR++9eHsFYsIgsC9V1px75XWjN/jshEvxPhQs0l8Ph8WFhbg8XgglUrjnK9QKMTU1BQ6OzvR2NgIo9GYtKez2PdAqgCA6j21Wq1wu9106Vqr1ZZN9SMTmCS9wcFBepBbsnObDtXKRuXg32/vwBZbeglnrvop4KJyYrGCDTbtbCgUwtLSEgKBAHp6etbMrtDr9XA4HGXPtnLZr3AZsViMTohR/iscDqOmpgZNTU2QJElsZUIx7b1Go8H27dsxNzeH7u5urK6uIhwO53z/FdpGlUsCWKFQoL29HV6vF2fPnsXKygo8Hk9eyq2V5KcKDjYWFhZw/fXXo62tDUajEU8++eQa0hsXwHZ2B8jOiFODhZikbQD0pG3mYCG/34+BgQHo9cnbAUqJcIwESBIESIQiF5wf14ODciAWi8VdXyqrR80mqampQSAQQGNjIxQKRdy2JEnS5De3242RkRE0NzennDZcLkgkEmzYsAErKyt06drlcpUs2MjnnhMKhWhubsbMzAw8Hg+Gh4fhcDhSEgsTUUlG/HLH+1sy20su+ylqirhcLudMGxVzdgVl10KhEIRCIRQKBQiCgN1ur86uqGBQLdpUYLGwsICZmRmo1eo4QRkej4fl5WUcO3aMfl/JVoyjFO8LBEGgrq4OOp0OBw4cwPHjx1FfXw+73Z7TOgtVo8oVSqUSra2t6OvrQ29vLwQCAVwu15r3hHSoJG5hwcGGTqfDkSNH8PDDD2N4eBgAN9sOiq3yQc2uYFYrgsEgbZwVCkVG48xG9SVGkhiY80MrF6Emh9aCRHRYVPi7q2wYWQjg1i2XH2E7mZFMNM4UuZG6vqnUvqamppKTvP/6mUgkwrp167CysoLe3l4MDQ2hubkZCoWiJJWNbEuxcrkc7e3tWF5exvnz52m1M5lMlvWx8nmJL6SKwufzaZKe2+3G4OAgnE5nHEmPrXVWwV1w2U+JRCJ6JlQ52qiYvMBksysoXqBIJKKDoaWlpZxeisqJGEni5RPT8AQjuG2LEdIc23ovhSRbKBSi302opCfVoq1UKmGxWCAUCqHVapOSrinZcUqMo1RzJHIBQRAQCoXYvn07xsbG6HkXFoulqOssdFsqmbewsICenh5IpVK4XK6s/Gol+SnWhvr98Ic/ZGNXrIJ6eefz+awaDGqw0MrKCoaHh+F2u+lsNnOwEGWcswUb1Zdn3hvB/p5ZSIU8/ODjG/LeD0EQuHGjoaC1ZHMMrhrxaDSKpaUlzM3N0RNpmcY52dDDQiGXy9HR0UHPvlAqlVCr1SUJNnKBWq1GR0cHurq6cOLECajVajidzqxECvIxzPkaVGbWhzLoTJJeMjWTQo9ZBXfBVT/FHEBbrDaqWCwWN7uCyRvLdnYFc3/FABsvpoPzfvymewrq1Sh2/PWz/zk5jSfecCNGkhhfDOBr1zcVvlgOgXnOKGI+8xqvrq5CKBRCqVTSSpUymWzNuZ6ZmUl7HEqMw2Qy0TK0TU1NGRM3pQzqqQRTQ0MDLBYLBgcHk3IOk21XCEG8kBYsatva2lrs2LEDc3NzOHnyJJRKJZxOZ9rWNeb2XEmepAKrBHHqglEvL+X+8WKxGKFQCFKpNC8jTpG2mdUK6qWTKnnX1NTAZDKxovHPxsv30VEPhHwC/lAUI4uBgtd0qSPROHu9XgSDQYRCIfD5fNTW1qKuri6pcc7lGLlsW1NTgx07dmBqagq9vb2QSqVFHYqZD8mMJEmIxWJs3bqVHrKXTYk93zYqtuQME0l6brcbTU1N0Gg0Gbet4tIAF/0UNYCWrQQMxQv0+XyYm5tDKBTC6OgoPbuCapOp1NkVp8Y9OD3pw3XrdNDKL8rkfu5XpzHtDUJAkLhuVwC2WilWghGQJIkYCXiD7E5nzwdsXWPq/WRxcRGLi4vwer30fJJiEvMFAgGam5thtVrR19eHoaEhtLS0JOUclCOZSP1WgUCApqYm2Gy2NZzDRLAVMOSzLfPaMFvCZmZmcOzYMdTW1qacfVVJfoq1YMPn89Fl1WQ3NvWiX8oTQ5Wnswk2YrFYHKk3m8FCAwMDkMlkrA0TY8MI3b3TjH9/dwjNJiXaTEqcTp+sKCtKXdlgErep/0UiEUgkEtoBm0wmiMVinD17FjabrWytAgRxYXgdSZKYmJhAZ2cnGjJMI80X+YocUD3v1JA9qnRtsVhgs9mSPuv5GMd8DWq6IIoi6Xk8HvT39wMAXC4X7TArKWNURfbgsp+ijptrUoyaXUH5Lqq9kyJtKxQKiMVi2O121tfOFpjKkRRmvUEQBAGdIv4la3QxgPufP4VIjMRvT0zhhfu20H8LRy+eO2o47Mc6jJhYDmIpEMGXrm3Me23lBFNUhskNjMViUKlUMBgMsNlsBc0nyTWpI5VKsWnTJrqtllKEYmbiS9lGlQpisRjr16+P4xw2NzfHBUflaqNK5dsIgoDBYIBer8fk5CQOHz4cx+/NtD0XwVqw8a1vfQtWq5WWnxQKhVCr1airq4NEIinLCWEacSYfItVgIYrUm+1goUKM0KI/DH8oCrPm4oPJhlG70lGLKx3FIxiX23BkC0qOkdmnSvUh53KNyw0ej0f3TDNJ5MmyM/mCjWoDs8ROSc8mU9gqdWUj03YqlQpbtmzB0tISzp8/D6FQCJfLVVFGvIrswUU/lW0bFcULZHIrks2uSGzvnJycZF32nW0k+r53e+fw0MvnQRDADz6+HjsbLqqNLfnDIAFEYyTmfaG4/fzw1g34r65x1GMRDt2FnneJkI9/2u0sye9gA0xuIHWdgYuiMkxuoNvthkajYdUf5Aq1Wo1t27ZhdnZ2DYmcC8EGBSbnsLe3l1ZblMlkJZG+zWdbgiBgMplQX1+P8fFxdHV1xZHfK8lPsRZsLC8v4+2338bS0hImJydx5ZVXQq/XQ6vVQq/Xw2QyQafT0ZNaKZw/fx579+6l/3tgYACPPvoovvjFL9Kfvfvuu7j55pvR2HghK/G3f/u3+MY3vpFxTSKRCGfPnsXIyAhUKhUWFxfR1dWV0Thni3z7awfn/fjqb88iFCXxd1da8ZG/ciO4kEGpREQiEXi9XoRCIZw5cwYrKyu0HGOicS4H2MiaUCRyv99Pk8hbWlpYqbywGQBQ0rNUcDQ8PBw3NbXUnI1st6MkFCmS3srKClZXVyGXy3M+bhXcRb5+qpgQiURr2qgSkyVUJlsqldJV2GxbZLjoV146PonOwUV8epcVG4zKNWt8/dwcQn+tUrzbOx8XbLSZlLhrpwWHhpbwwNXx1Zr1RiX+z82tOHz4MGtrLeb5y0TcNpvNUCgUnH+hJAgCer0eOp0ujkTOtfsOuBgczc3N0ZxDiUSS9/tBIYpQ2W7L4/FgtVrXDK+NRqOcvzcosPb29eMf/xgAcOrUKdx0000Qi8Voa2tDT08Puru76SE/N9xwQ1w2uaWlBd3d3QAuZKPNZjNuueWWNfv/m7/5G7zyyisZ1/GXv/wFv/zlL3HixAmcOXMGHo8Ht912G6677joEAgFs3ryZtUg7XyN0ftoHfzgGEZ9A59DSZRts5PN7KeNM/Y8iOCqVFxxWMYjb5QbzfpXJZGhvb6dJ5AqFAi6Xq6AJ8sWoNjCDo/7+frpfttycjUygSHoHDhzAqVOnoFKp0N7ezpnsXBWFIV8/VcykWDQaxXvvvYeBgQFs3LgRHo8Hx48fZy1ZUgzSeSE4P+3Dd98aQDASw4lxL974/M41vuC2LUa827cAPgHctKk+bnuCIPC//saO//U33G0LSwRFzqcCijNnzsRJCSuVypTE7VKusdBjJ5LIl5aWsLCwkPOco1JAp9NBq9ViamoK586dg0qlyot/W0pyOY/Ho8nvIyMjWFhYwOTkJBoaGvI6finBaqr3wIED+MxnPoObb74ZBw4cwN69e+FyuQAAHo8HZ86cSXsh33rrLTidzoJ6S9VqNfbu3YvHHnsM999/P770pS9h/fr1CAaDmJ+fZ/WGz9eIb7drYK2ZxvxKGB/vuCgrWwnBRqnWRxG3mT2qlJQwRX5LJG4vLy9DqVSytgYuqECl+g5FIp+ensaRI0dQX1+PhjSTyDMdo1gBgEwmw6ZNm+D1etHb2wu/34+VlZWctcTZ5mykA0EQEAgE2LlzJzweD+ecZBWFIR8/xXZS7ODBg/jWt76FyclJeL1etLe3w263o6GhAX6/H9u2bWPhl15AqfzKciCMf/z1Gcx4Q3jsphZsMicfUiYWXHwmJYKLvCjmGtstavzpS7tAAODz8pO9LhcSh7omErcFAgEcDgedILsUQZHIqdkd4+PjKUnk5QTFOaTeNTo7O2G1WnOa7F1IK1O+Poq6h2ZmZhAOh9HZ2Ymrr766aCIybIC1YOOdd97BfffdhwceeABf/vKX8cILL+Duu+/Gz3/+czgcDqhUKlxxxRVp9/GrX/0Kt99+e9K/HTx4EJs3b4bJZMJ3vvMdbNiQXNaV+TmlRgUUZ4J4vkZcKxfhqU9sXPPCdqkankxIJOczidtKpRIqlQpmsxlisbgiz1GxyGcEQaC+vh56vZ4urTY0NOR8T5ai2qBUKrF161b86U9/Qk9PD+RyOVwuV1YTaYvJ2UgHgiDWqFRVUdlgw0+xkRRrbW3Fz372M9TX1+Of//mfsWnTJnz4wx8GwL4fKFWw8eqZWZya8CISI/GDtwfxk09tTvq9Bq0M37llHY6NLuOW9vqUaxTkEWRQyLdlM92+kiEVcZs5oySRuO31ellXiGILbK+Jz+dj/fr1CAQCKUnkXIFOp8P69evTcg6ToRDOBhs+yuVyweVycTrQAFgINqio7oEHHsDDDz+Me++9F9FoFLfddhsOHTqExx57DN///vehUqnSRoChUAj/8z//g3379q3525YtWzA8PAyFQoH9+/fjox/9KPr6+jKuTSgU0sFGpirEoj+MlVAEFo00y19+4UJHo/lL6ZXK2HCJpMXsRZ6fn4fH48HS0hJtnLVaLRoaGuIUF8oBrleYmKBKq2azGW63G36/H/Pz81mTBvMNNvLNyOzYsYOW9dNqtXA4HGmvdyk4G1Vc2mDLTwHsJMVqai5yEJhJsWIg3wr8oj+MR/f3IkYCX/9Q0xpVqEQ06eXg8wgIeATaTOkrzFc5a3GV86KQSTECIrb9Xi7E7VKCrd9YDJ9HXYN0JPJSrCMTqGc+E+cw1baFtFEVEiRQ6+bK+106FPxUUEb5F7/4BTo6OgBciGaj0Si++93v4oMf/CCWlpagUqnS3kR/+MMfsGXLFhgMawfJMUtvN9xwAz73uc9hbm4OOp0u7drEYjFWV1cBpK9sMAnb9+6y4qZN2Q2z4/F4nFf5KCeSSTIyidu1tbUQiURobW0t91KLjlLI6gmFQrS2tmJubg6jo6NZk8hLyaMALsr61dXVYWJiAl1dXTCZTLDZbEkNbyk5G1VcmmDLTxUjKcZUTSwG8n2R/+nBURxwLwAg8Mx7I3hojyvt97dY1fjZpzZjfiWMKxpzqwiyHWwU+vIVCoVo37W0tITl5WWcOHEijrgtl8vzflGspGRWIWDa7kQSeWdnJ+x2+5pJ5OVIjiYeMxnnsLm5GWq1OuO2uSAWixWUWKWOfVkEGxQ6OjriTjr1ED755JOoq6uL+ywZnn/++ZTZoqmpKXr6Y1dXF2KxWFZZW4FYgjdGojhzYBh3bDOlfMDPT68gEI5ByCdwaGgx62CjGK1ZbIPNcnI6UOQ3ykAzidupJm4vLy/D7/cXdV1cQKGOJddrx+Px0N7ejqWlpeQk8okJwGSKW18+ClFskAktFguMRiPdBma322EymeLuk0I4G4WusRKMeBXZo1A/VaykGKVGVQyEooB7IYiGaAxCfvbPkV4por9fr8pOgKLFUJ65RInINnhhErcTJ25TgYXVagUAbN6cvC2snGAzaCnWe0LiPjNNIudCsEEhkXPI4/HQ3Nwcp1JYDs5GJYKVYGN+fh5qtTppSaylpYX+97vvvov29vY1fdB+vx9vvPEG/vM//5P+7OmnnwYAfPazn8VLL72Ep556CgKBAFKpFL/61a+yuhmnRSb0TRKQe6ZBAtiWok1wh12N39dKMecL4dYtpuRfSgIej8f5DAXbGSOK/MasWASDQYhEIiiVyqTDDzPtr4rUKOT8aDQamkR+9OhRGAwGNMhkED3xBKLf/CZQW0sfo5SVjUTw+Xw0NjbCYrHQzsfpdEKv19MBfbWyUUWhKNRPAcVJihWzshGKxHDfC72Y9Ybwy/Mn8dynsldjvGO7GTqFCDES2LOubs3f2bQBpeCVZCJup5ITXl1drSYd8kS6a5pqEnk5FLky+RiKc7iwsIDTp09DoVDA6XRCIpEUXNm4XO6tgoINypk/+uijcDgc2L17N2pra6FSqSAWixGNRjEzM4OBgQEcOnQIBw4cwL/927+tMeIymQzz8/Nxn332s5+l//3ggw/iwQcfzHl9YgEfwIWbXSZM/dJRKxfhyb1tOe+/EtSjClljMuJ2IBCA2+2GQqGAWq2GxWKBSCS6bB6YfJF4frK9JoU6dJpEXlsL77e/jTm3G9rpaYj37QNpsSD2+c+XPdigIBQK0dLSgtXV1TVyuaXkbHD9ma4iN7Dlp4qVFJNIJHT/P9uY9gYx6wsjSpLomfBiNRKDVJhd6w+PIHD9en3Sv7GdgS6GL/V4PAgEAlkTt9OtrYr8kM09kjiJXCQSldwGZ+tjKGl0inOo0+kQiUQKIohfLgmxgoIN6iTdd999+MpXvoIf//jH2LhxI8xmM4RCIQKBABYWFjA9PQ2CIPDAAw/AZrOxsvBs0CT1o07uQcf29dizvg4nj0+xuv9KaqPKhGg0GjdV3efzgSTJuInbDQ0NOH78ODZu3FjStVU6Uv3GcDSGbOaXs+HseCIRNDfeCOK738WywYCVU6eAG26A+q/VOS4EGxQkEgna2trg8/nQ19eHQCCQlypUlVheBcCenypaUixNG9WiPwypkAdJlgFCIswaCXbaVfjzwBJu3WLMOtDIhGJwLPLdXzLitt/vx/j4ONRqNSvE7cvFT5WijSoVKBL55OQkenp60NfXl5JEngyFXKNcfjuTczg+Po7h4WGMjo6iIQ/p+WobVY7YtGkTXn/9dZw/fx4vvvgijhw5gtnZWahUKmzYsAF33HEHrr/++rhtSJJE9+gSojESW+01RbnJJWIRnGJv1hyMXFGpbVRM4jY1ZIggCHqqutFohEKhSPrgVLM87OC33VP42aExtNYr8fgtG1K+TOQjY5vybw4H+BIJaqRSRPh8nBaJ0H/0aFqljXTHKbaRVCgU6OjoQH9/P8bHx3Hy5Ek0NTVBKs1OMa5KLK+CiXz8VCmQrI2KJEk8f2QCP3hnEHKRAL/4dDtM6tzlQnkEgcdvdMHtdmPjxvQE71xQrmCDSdxOnLitUCho4vbJkyfR0tJSdlXDyx253iMEQUCn00GtVkMsFtOTyBNJ5Om2z3ed+XAjrVYrxsbGQJIkLT1vMpmy3hdbbVSV8F7GGkE8FouhpaUFDz/8cNrvUDfMm2en8cSr5wES+PwHXLi53czWUmgw1aiKAa5n5kmSBEmSmJ+fx+rqKnw+HwKBAAQCAU1+s9vtkMlkWb9ccSWbVQqw8QAPzvuxr3MF2nPn8M0bWmD4K9Hype4pyMUC9M2soHfGh03mtSoXQO5GMO33eTxEP/1pkFdcAeLgQbS1tWGJJHH69GnacGarf15KEp9MJoPNZoNCoUB3dzc0Gg2cTmfGFohqZaOKROTqp0qBROlbSqr2191TiJFAIBzFoaEl3LK5Ps1eUqMYdrbYwUY2xO10E7fZXB/XlLKKhWL54nwTWelI5Km2K4Q7Ucgz73A4YLPZMDg4iIMHD8LlcqGuri7jei4nX8NasEGdMOoFlwlKmot5UscXA4hEYyAADM8XR5FILBYjEAgUZd9A/vrlxQBJkggEAnFZn1AoRBtsjUYDg8GQNXH7ckeuhvfVMzM4M+nDxzqMsNdezLy/fGIaC6sxeOcDeLt3DrdvuxBUv89Vi/09M6hTSdColafaLbuoqQH5vvcBAMj3vx8AoAHgdDrpHlS9Xo+GhoaMpet8MjKFcId4PB7q6uqg0+kwOTmJw4cPo76+Hna7PeVa89UwZzqA6rNyaSFXP1UKJAYb1MvtJ7Ya8a9vDkAu5mNXjlKyTBSjAs/mCzhJkohEIpifn8fMzEzWxO0q2EeqwK2UYAYNqUjkySaRF1IlYGPwrkgkQktLCwKBQBznkDlTJ9m2hShZVRJYnz6TrebvTe1mnJu6MG30EzusbC8DQPGHJRUrM5/pxmcSt6msTyQSgVQqXUPcPnXqFKxWa9atJ1UkRyRGYnJ5FQalGCJBvHHon13BUwdGECNJ9M6s4OnbL3JaNpmV+MNJQCzgoZUhC/mZq6y4ebMBBrUc4jR91KxWNtJAqVRi48aNGB0dxaFDh2j9czazSGxUGgiCgMlkQn19PUZHR9HZ2QmbzQaLxbJm36UmlldROWBbm35g1ofRxQCucmohyEFeFrjQRpWssnHrFhOuX6+HRMjLSbI2EcXgFubr+1JN3I5GoxAIBKirq8uauF2M9RV7XxQuh0pJvkjmWxJJ5MkmkbMRMOQL5rZSqRQbN26Ez+dDb28vBgcH0dzcnHTeVaEDASvJT5V21CUDtXIRHv/YpqIeQywWJ+2FZevhLEVlgyJuU8Z5ZWUljrhNTeJM1ZtaDEPE1jnkehsVBZIk8e0/9OH46DLsWhm++7fr4py/iM8DjwAiURJSUXzgcG2LDqszUrStb4VZI8Xy8jJ9LYPBIGQOB8QZdPiLHWxQ2/B4PHrORWLpms3j5IpkQQO1VrPZTJeuHQ4H6uvr6WNUJXOrKAXOT3lx69N/AQDs2VCPf701t3kMiX6K6VeUksJddDEqG9n4Poq4zSRvA8knbvf19UGn06XNAucCrviWcDSGfa/1Y3ghgK9e50Kznt0qdiXM2WBzHekmkZcz2EgGhUKBLVu2YHFxET09PZDJZHC5XHGJ30J8TaX5qbIFG6WASCSKU/ngulxfOBxGNBrF8PAwVlZW4ojb+U4tvVz6TSnkc33Hl1ZxasKLdosq6fCqSIzE0ZFlaGRCDM37MecLwcgga9pqpfjGh5rQN+vHtc0XdPWZQaKKWMWU+wxmeDz6WppMJgiFQgwNDWFkZAQtLS1xg4KYv6fYvz9xG0qCNhAIoLe3ly5dK5VKVo+TLdJNWRUIBGhqaoLNZoPb7aZL1zqdriDp20oy4lWUF30zXpAkEIpEcWJsKeftE9Wo2K5ElIKzkS1xO9+J2/mg1MHGwcFFPH1gGFc5avCZq2wgCAJvnpvDH87MIhiJ4dH9vfivezpKuqZ8QFWfPB4PLXdvt9vpGTLFRiY/QRDxk8gpEnk+QicUivniXlNTgx07dmB2dhbHjx+HVqtFY2MjLfF7uQwEvKSDjVQZI7YuUL5GnCRJhEIh2jB7vV6srq5CIBAgEolAKBTmTNxme42Z9sf1oCNbrIaj+KffnoV3NYIauRDP3rlpTcuCkM/DzZsNePnENK5y1tAkbwqRSASNShI6RDAz0o/BlZW4IFEkEqG9vT2uNYA6h+3t7VhYWMDJkydRU1MDp9MZ92Kdz7lmKwiQSqXYvHkzlpeXcfbsWTozk+8go2JOAheLxVi/fj38fj/6+vowODgIiUQCtTo58b4Y66zi8sQHWg3Y1jCG/hkfHv7w+py3T1SjYrsSwWYFniJuB4NBjI6OIhgM0r6L4lekI26nApeTYsy1kSSJ35yYwsCcH3fvtECvvOgLHvrdOfz/7L15fGNneff9Pdp3yZJtWZa87+OZzIxnzR4oCYFACAnQFNrwsDwk8KSlpU3TUrY+0NKXh1LaUqAvvIWyvPQt+xa2QMjGjD2effHu8b7vi2yt5/3DOWckWZIlWfLYE/8+n8ky0rnPre267mv5/a4lX5DOiWVuq7Kzx2WmwLxm89VKBS5ralPYtxLhcFgOEhcWFmSxEKn6VFRUhFarZWBggMHBwYR8iWwiVd8SSyI/c+ZMxueTXJ9ppACpoKCAkZERTp06hcvlIhQKZaWysRPOYzd8sBFLvMtmxigVIy4RtyN7VP1+P1qtVj6MFhUVyeS3s2fPUlhYmDXJvu3cb5rLUrfXH+JU/xwem46qgsSla18wzIo/hEalYHE1SCgsEo9C8e5bSnnnzSWEQyHm5+ZYWlpiYWFBrj5JjrakpASj0RhlQMbGxpJm9Ox2O8ePH2d4eJiWlhZKSkooKSnJuOUok2uS3ctqtXLkyJGo0rVarU7bSG6FFK3BYGD//v0sLCxw9uxZvF4vBoMhbtUo2f12gvHexfaAXqPkK+84mvH1idSosoXNtJZ4vd6oioVE3JY4gqWlpVkhbuda3SodhEWR9rElXFYdeaOp5HIAACAASURBVIZoP3zi6iyffroXfzBM+9gS/88fXmuZKzBpWAmEEEC+7nCpjc88tIeRuVVeuzf+gMStQigUkvkyCwsLcku20WjEYrGg0+morq6OqmBL2Lt3L4uLi7S3t2MwGKipqUGrzU3wlK6fkEjkBQUFnD9/ntbW1rSDoq1KoAqCgNvtpqioiIGBAWZnZxkZGaGsrCxtf7rTkmIvq2Aj2xmjWIMWSX6TDHQoFEKv12M2m8nLy6OkpCTpj3Q7Gd1E6+0EfObXvbT0z6FSCnz2oUZK7fEJ8la9mj++q5yn26e4b19h1LyLYDDI7OxsFF9Gag3IRDY4GQRBwOPxUFRUJPMlamtrt4Qgnso1saXrnp4eHA5HWkFRpmXfTF6TxWKhsLAQvV7PxYsXMZvNVFdXp+Qgd1rGaBfx0dw7zbdPD3L/fjd31BZc7+0khE6ny6mfgo2TEIl8V6KJ221tbeTl5WVNeGS7cCwA/vdTXfyibRK1UsF/v+sg+YZrx6RwxBZD4ej9fvEP9vF0+xT73OaoNtubK7LDQ0kHsVxPiS8T2cYbO0trbm4ublJM+lwsFgtHjhxhfHyc1tZWiouLMzok5wparRar1UplZWVCEnkibPXBXalUUlFRwfj4OD6fj5MnT1JZWZlWq9pOS4rd0MFGIpWPbCAUCsn9jG1tbVFZAom4XVlZmfbU0p0QbFwPpyDdM9Uf18j8KgpBIBSGGa8/YbABayTu2yutLC4u0t/fz+LiIjMzM6ysrGC1WjcdWKRzWJayNF6vl46ODpaWltLKIGUabKT6uqTSdSAQYG5ujpMnT1JdXZ1Sv+xWE7bD4TA2m42ysjLGx8c5/dIAw2SCCpu53y62D1YDId79tVZ8gRA/vzTOi0++Eqthew54i22jyoV6VCQ2Im6n4ru2u19JtN78SoB/e7YPo1bFY7eXoVWt/53/rneWQEhEIEzH+DIFlTZ5rVsr83j8znJ6p7y8+5ZoFc18k4aHDxdnvLdMEQ6HZeERqWIhCIJcscgmX0YQBIqKiigoKKCvr0+2/6nMlEgVmxESEQQhKYk82/fMBmpra/H7/fT09NDf309NTQ12u33D63aan7qhg41kKh/pIBAIRGUIpNYZqTUj2z/m7WzEs4lU99YxvsTfPtWFTq3gE6+vSzhJN9JY/MldFfzHiUFqnUZuckeXUyM/T4nMKPUcm0wmKioqEEVxnXLEVsJgMHDw4EEuXLjA1atX8Xq9snJLMmQabKQLhUKBy+UiLy+Prq4u+vv7qa2tTVq63qwTyeQ6hUIhO8jCwkK5Vc3tdlNaWhrXWO80I76L+FAIAiIgIP1jeyKXbVQScdvv93Pp0iW8Xi8KhUK2dZn6rp3gp+Kt99lnrvKTixMIAtgNav7omGfdcx67vZRP/aqXynwDR8qi55sIgsDbjmR/AHGqkJKc0p/p6Wmmp6ex2WyYzWY8Hg8mkynnSTGlUklVVRVut5vOzk76+/upr6+P24KVy30kui4RiTzRJPLrFWxICTidTkdjYyNLS0sy57C2tjbp+7nT/NQNH2zEG5aUCBL5LbKUHEt+czgccoY7HA5z+vTprBKmtnvb0/UIXn56aYJlf4j51QDPdc/w8KHE2SPJaNQXmfjUGxsIBALMzszIxlmaoL4ZMuNWQqfTUV9fj8/nkw2mx+PZUK0jXWTKv0hF/zz2mnSxmcpG5P2kKenFxcX09fVx4sQJysvLKS4ujnreTjPiu1gPnVrJV99xhB+eG+Y1e11Y9duzqgHr26gyqWxE+q7IiduSrRMEgYqKCvR6fVa+27nglWzGrzx1aYJvnBrm9fsK+YPDiecDaZQKENbup1bGf86DB1w8eMAl/38oFMp4X5uBVIGKbOONFB4pKSmRZ5NkSzI4Xeh0Otn+X7lyRW5X3cyclGwmpVKdRL6ZFt/NInIfJpOJgwcPMjc3R3t7O1qtlurqagwGw7rrdpqfelkFG5EGMhn5Tcr6RBK34yEXB9TtTOjezHqiKLLoC2HSKlFEZB9SWetIuY3ne2bQqZTsK04e6U9PT8u9x1JgYbFYMJlMcg//VgcW2RgYVFJSgsvloqenh5MnT1JXVxe31JrpZ5PJNZGvKZXSdS7VqOIh0f2krFxJSYnsgKqqquRWgJ1mxHcRHwdL8zhYen0OYekgXrvvRkmxZL4r3sTtubm5tEQSNsJ2qmz4gmE+9lQnYRE++0wfr6zNT7je+19RQZ5BjUGj5E1NG7c8bXZvqSIYDEZVLJaXl+UKVCLhEVgTH9kOiTKr1crRo0cZHR3l1KlTcuU4E2y2kh0PUntyaWlplJy7lCjOtMU3VxURm83G4cOHmZqa4vz589hsNqqqqqKCuJ3GLdw2wUZ5eTlmsxmlUolKpaK1tTXqcVEUef/7389TTz2FwWDgq1/9Kk1NTUnXlNqoVlZW8Pv9rKys0N/fj9/vT0p+SxW5Cja2U8Yo3nqZ4HPP9vPL9kkai8x8/PW1aU3Evb3KTk2BEZVCIN+09hn5/X5ZB1yqQK2srDA3NxdFDt4JP8JkiDRmKpWKuro6mc/R399PXV1dVNYjm5wNoa0NBgYQX/3qlK7ZqHS91ZWNjbJVGo2G+vp6VlZW6O7ulmd07DQjvoudDaVSGWXzI5Ni6RK3twq5DDZEUeTnVyYZnlvlLYeKsWww2FClELDoVCyuBtEoBUxaJTMJnmvQKHns9rKs7TsTSByLycnJuMIjpaWlcQOLeMjmZ5CNpFhxcTFOp5OrV69y8uTJqPkxud5HKtdFVmIiK/HS/rdqr6lAEAQKCgrIz8+Xgzin00l5eTkqlWrHJcW2TbAB8Mwzz8SdVgzws5/9jK6uLrq6umhubua9730vzc3NcZ974sQJWltbOXHiBFeuXOH222/n05/+NBaLBZvNhsvlSpu4vVXItWLW9VgvLIr8sm0Sm0HNlbFFxhd9eGypcyF8Ph8q/1pQMdK7Flio1WosFkuUdPDp06epqqraUT/AVBBrzCQ+x/T0NOfPn8fhcMiEzqxwNrxehN5eFN/7HkJXFyG3G7GoCCJ+m8nuk6h0rVQqt9Sgp5qt0uv17Nu3j8XFRbq6uvB6vbhcrg2v28XLD7lIiknf0fn5eVZXV5mfn2dqaorBwcGsiI7kArnM9j/fM8v//lkXgZDI5dFF/ulNjUmfr1QIfP3tB3i+e4Yj5TaMWlVW97eZtSIrFpJUuuS/8vLysqpouF2gVCqprq7G4/Hw4osvcvr0aerq6jCZTCldn2t7D+sr8aurqwSDwbR/W1tx4JeCuKKiIgYHBzl58iSlpaUZyc9fT1x/q5UifvjDH/LII48gCALHjx9nbm6O0dHRuIeCX//61zidTh599FF6enp4+umnAejp6cFgMGwLY50I2yE4yDYUgsAr6xz8pnOaBqcJ50uDkGL3JoriuoqFz+dDo9HI5eSNWtu2KzLdb7LPzuFwcPz4cQYHB2lubqasrAyLxZJRsBF5jdDXh/Jv/xZhehpRo0H15JOE3vc+wvfdJz8nFcMeW7peWlrKqJVjM5yNdK4zm800NTVx+fJlRkZG8Hq97NmzJ26/7C5evshmUuyFF17g7NmzDA0Nce+99/LXf/3XVFZWYrPZKC8v39KJ2+kgl37K6w8C11pvU4HLquMtEVy+6+H34gmPKJVK2XeVl5djNBq5dOmSzJ/Zboi16Zt5D3U6HXq9nqqqKi5duoTVaqW6unrDGWJbJSQSWYl/7rnnaG5upqSkBI/Hk7Lf2EpiuUKhoKysDLfbzdWrV+nt7SUvL++6n+9SxbY5dQuCwD333IMgCDz66KO85z3viXp8eHiYkpJrUnMej4fh4eG4wcaHPvQhYK3VJhgMRt0jl5KC2cB2CjZ8wTA/ujCGSqngdXsLUSsVGa/3p6+o4J03l2DWqdZUYsRrk2h7e3vlwCKy77i4uBitVrvjAotsYiNjJggCpaWlMp+jv78/7ZaK2HuIe/YQevRRVJ/4BILXS+jhh6MCjVT2FQmpdD0wMEBvby8XLlygtrY2Jf3zdO8ViUyDFK1WS01NTU7mHezixkY6SbHOzk5cLhevec1ruHz5Ms8//zyCIDAyMkI4HM56oJHNg9FGfiAUFvm7n3fROjDPn9xVzqvqk885iVzvVfUFdE14GZxd4f2vqMjKfrONZIqGO0F4JB4SfZ6CIGzqddhsNo4dO8bIyAgtLS14PB5KSkoS2uZMbW6m32+FQoFGo+Ho0aNJSeTxcD1amVQqFTU1NajVasbHx2lubuamm266biIBqWLbBBsvvvgixcXFTExMcPfdd1NfX88dd9whPx7vC5hKZjVSSWInHB62U7Dx7TMjfKt1BBBQCPCGm4oyWk8URVZXV/EtLjI1smac/X4/arWaYDCI2WzG7Xaj0Wh2lHHeKqTynqjVaurr6xkfH6etrY1z585RV1eXUvYsnpEWRkYIHzuG6PEgDAykdM1G0Ov1uFwu7HY7Z86cIT8/P6W2kK2qbEgQRRGlUilPSt/FLiRkMyn29re/PWrdyP/OdlJMsttbFWxcHFng51cm8YdEPv7z7pSCDek1qxQCf3xXeU73lw6CwSDBYJC+vr6sKRpu93NItiEIa5OzI/kctbW1CSuE14M/sRGJPBf33AwUCgXFxcU4HI6cTXPPJrZNsFFcvFYCLSws5I1vfCMtLS1RwYbH42FwcFD+/6GhIfmaRIgng7Zb2UgdIfmtEgmHU1tDCiwi+1QDgQA6nQ6z2YzVasXj8cjk/fb2dgoKsjPdN9s/+lwbkVTWT/ez0+l05OfnU1RUxLlz5+QhdukONAq/+c3wtreBQgHLyyldsxGkbG1BQQEOh4Ph4eGUStebkSXcyorILm585CIpFotcJMWyrbK2kS8tsqxVpNVKqHBs3Ia4Xfye3++PqlhIgUUwGESn02VFeGS7+qmtODhLWXmPx0NHRwcDAwPU1dVFtdduVRtVIkiV+IWFhQ3l3K+nrwiHw6jVagwGw45Iim2LYGN5eZlwOIzZbGZ5eZlf/vKXfOQjH4l6zv3338/nPvc5Hn74YZqbm7FarWmTOHdKsJHtPWZqxN/c5EIhgFqp4L69TmC9asjKykqUcU4UWGwVbsSMUboZM0EQyM/Px263y6pQ5XHmScReE4XIikgcYl+mRHTpGmnmhcvlkjNdiSbRZipLCJk54l01ql0kQi6SYrHIhZ9KJ4B5rmualv553nSwiPIEgcJGh/kii45v/o8DdEwsc3vVxtOQrwfHIp6ioVqtlisWkYHFqVOnKCoq2tL9pYtAKEwwLKJXb0+eTyT0ej0HDhxgdnaWixcvytKuarX6ugcbEiwWy4Zy7pu552b3m2kS7nphWwQb4+PjvPGNbwTWSpZvfetbuffee/niF78IwGOPPcZrX/tannrqKXnAyVe+8pWU15c+1O1Alt4ImWS1RudXmVsJUuc0yjMsNrOeBINGKU9YlbTdV1dX6e/vZ2VlhWAwiF6vx2w2ZyTBuJ0/j+2yr0T7WFgJ8N2zI9gMau6/yYVSIcjPjzzQS3yO7u5uBgcHqaurW9fbudnAYTPXSJmukpKSqEnkVqs16rqtNKqbCW52ceMi10mxSD+VqzaqjXB12suTP2zHHwzzm84pnnrf0YzXK3cYEgYrme4vVcSuFznwMDawsFgsOJ3OHSWVHgiFo+TjB2ZWePvXzuH1h/jb19Vy757C67i71JGXl8exY8cYHh6mpaWFkpIS1Gr1tgg2IL6ce2QlfjO+abN+Zqf5qW0RbFRWVnL+/Pl1f//YY4/J/y0IAv/2b/+W1rrx2qgiCePZwlb2wsaid8rLE99vIxgWedOBIjk42AykwCLSOEuBRTgcxmKxrBsws4vcIBwOc2ZokfCYnztr8mUH86UX+vnFlXEUgoBNr+YVdYlb0dRqNQ0NDSwtLdHR0SH3pkp8jmzO5tjotSS6RqfTsW/fPrl0LZG0pe/cVhrV3TaqXcRDLpNi0mA/nU6XkzaqVKslwdBLVWsgEEq8h2wHRNkMNnw+H16vF5/Px+DgIKurq1HCIztV0RDW7O6TP2jn6Y4p7qpx8OjetSrGc90zLPlChIH/ah3NKNjI9mE91c9TEAQ8Hg9FRUX09PTQ19cXd2BtKvfL1WeaSM4908AINu9ndpqf2hbBxlbhRiDexaJv2os/GEalFLg0upT2elJgIZWTl5aWCAaDGAwGzGYzDoeD8vJyuSfwypUrWK3WrAQa27mysdUIhsLMegM4jBoUimvfpYsTfv7zUj8ICvqmvLz7tvKo60Sig+pk30WTycShQ4eYnJzk7Nmzcln4elY2YiGVrqempjh37hwOh2M32NjFtkCukmJwbQCtFGxcr8pGTaGRv76nmpN9szxyNHHiajtwLCRFw9iKhVarJRgMkpeXR3Fx8Y4MLEbnV3nyB+0oFAL/1xvqcVrWWpHnVoI80zmNSiHwfM8Mb6m2UwTcUpnHv7/Qjz8o8sB+5/XdfIaQhtZqNBqGh4c5e/bsuqG1ybBVnJNYOfdMpdE3W7HfaX7qZRVs5Ip4dz2N7tFyGze5zYwt+HjkmDvpeuFweF3FQppGK6lqVFRUpKSDvYvsIRAK8xffuUTnxBJ31uTzV/fWyo8t+sKEwiIKpcjkol/++0dvLyffpMFmUHFHtUP++1QMrkTQluZzZEIuyyQASPUaQRCiSOTLy8sMDg6mpX++Gew0I76LnQ+psgGp+6nnumc4PTDHmw66KMlLrjqXTqLt/puc3H9T8gPrVieK4gUWyaTSe3t7sVgs23KWhYTuyWUuDi9yZ40duzE6effl3w1yeXQRgK+1DPHEq6oAsOpV1DtNdE0uU5lvwKJds1OV+QZ+8fgxVgOhdWulimx/npke/jUaDR6PB7PZzPnz57Hb7VRVVW2oWriVylASiXxwcJCenp605dwhu5WNnRBMvyyCDelLmCviXTY10dM14iatir+7v37d30uBxcLCAqurq4yOjhIKhTY9jXYnfKm3IwZmVvhl+yQH3BYOl9miHhtb8NE1sYRNr+aZzimeuKdG5mAccmlYVBhZCSl5561l8jUmnYq331y67j6pGlxpQJDL5aK5uZnLly/T2NiIzWbb8Np07hN7TTq/E4lEPjAwgM/nS0oizyZ2g41dbDU0Gg0+nw9ILTDonfLy5A/a8AXDPNM5zY8eO5L0+dlOtOWyjSpW0VCSSr+RZjBNLwd4+9cuEwqLfL1liO+953DU49UFBjSqNRtUlX9NqUkhCPzHH93E8NwqbpuO3u4u+TGDRolBs7lzyHZQypK+B9LQWokrIQ20S7TmZojlmcJgMFBUVJS2nDtkh7Oxk/zUDR9sqNVqAoEAWq12y8rT0v9n8kXKJGMUDodZXl6OMs6iKGIwGBBFEZPJlFFgka39bcVauUA2De9Hf9rJ5JKfn16a4AsP78NpvpZ9clm07PdYOTs4z+v2FcmBBoBGKfDorSWYzeas7SUSGo0Gq9WK0+mku7sbjUaTUoZmq1qvYO1zkEjk3d3dsv55JIk8m9hpGaNd7HxotdqoysZGfipwTZccX3Bjn5ZtW5ut4EUKLObn55mdnWV+fl7mrmxG0fB6+5b/ah3hx5fGedthN6/du54/MeMNEBZFAmGRsQXfuscfPlRMaZ4ehULgeHl0AkitVKRMvL+e2EylQbpOEARKSkpkPsfJkyepq6uLy+m4HipWkq9IRiLf6NpMsRtsbDNIRlzKguSCeBe5ZufEMh/7aSc6tYKPv64Oty31shpsnDGSAotIjoUoinLFwul0RpUcR0dHCQaDWQk0tjuu18Hw55cn+EXbFK/fV8gr6+IPKRJFEVEUCQZD9Pf3MxpcU7apra3F4XDw9w/sYSUQXpeZStcQZhoEGI3GKJm/wsJCKioqElYiZOWcEycQm5oghcPAZsvcOp2OvXv3sri4SEdHB2q1OoroHnuvTLHTjPgudj4ig41UqgZ1ThNPvKqKlr453n58Y1GQbCfaMuVYJJJKV6lUaLVaamtrsyaVfr2CjYlFH//0zFWCYZGPPdXJK+sc6CLkaAVBoMqh44+Oeni2a5pHb1tfoRYEgVtTkAzOJnLRRpXpdbF+Qhpau7y8LM/nqK2tjeJLZFop2Iy9j6f+WFxcLMu5J5tEvsvZuMGgVqvx+XyYzeZNGdxQWOTS6CL5Rk1UABHrGJ66NMGSL8jCqshz3dP8weH1PIpkiNxjOBxmaWlJNsyRgYXFYsHlcmEymZK2plxvTslWY6v3Nr8S4IsvDKBWCvzLb/u4uTIPvVopa7gvLCzg9Xp5sETD2WkF+4stVLnsmExrDqanp0eWpDVkob94sxUHiSsxMDDAyZMnqayspKioaN2aYjiMYnER5d/+LaG/+RvEW29dGwCYBNkyjmazWQ6Mzp07h91up7KyMop7ko1s1W5VYxdbhcg2qlSrBg8eKOLBA6nNfthqP7DRDKZYqfTZ2VmmpqayFmjk4rfbP7PCh3/cgUWv4u9eX4dVH5/rZtQo0SgFEEVMOlWURG3k/t53Rxnvu6MszgrpIZuvVTrPSAlNaShvdXV1yi22EnJRaTAajTQ1NckCIpFtS+m26W52nxDfp0XKuSebRL7bRnWDQVL5gM1ld7704gA/uzKJSiHwmYf2UGZfOxjGGt3DZVae7ZpGrVSwrzjxmPtYhEIhlpeXmZubw+v1Mjo6CqwpCJnN5pQCi0TYrsHGdg5chhaC/PzZAZrK8nhVgmoFgE6txKRVMrvsw6IR6LhyGb9vTcPdYrFgNpvR6XTccfQo98eoRikUCg4ePCirQzmdTioqKqIMyFZVNiKvUSgUlL80BLC7u5uBgQHq6+uj2pbK//Vf0ff1IayuovrgBxEdDoJf/jLkJ36vsk3gKygoID8/X9Zo93g8lJSUbFr/fCuJhru4cRAMhfnK7/qYW/bz6F1VWHSpCy/EEsRzxS3MFmI5FisrK1ED8tKdwbQTkmL//MxVLo8uIggC3zs3xjtuLon7PKNWxdfefoCWvjnuqLZHtcVuN4iiKLdgr6yscObMGYCohKZSqaSrqwudTpd25SnTYGMj2x1vaG04HM6ogyPbwYaE2EnkUuVOalHebaO6wRBbns7UALWPL6EQ1nplh2ZX5GAj1ojfVmWnusCISiGQb4pvXEOh0LqKhSAIGI1rRDBpjkU2SOe5UOB6OeA/L63gFYP87uo8NQVG+fMOBoPy5yZVLd5Rq2DMb+RQmZ1SZ9664VD9/f1JjZlUTejv75dJ0IWFa32+1yPYkKDRaNizZ4/cthTJ5xh8+GGcX/oSTE9DKEToiSeSBhqZ7m0jRGq09/X1cfLkSaqqqsjLy9vUvXaDjV1EIhQWWQmEMGkTu8zvnhnis7/qJCSKTC75+NSb9qe8fraSYomQrcO3JJU+OzvLzMwMZ86ciQos7HY7ZWVlaUujX49g4/zwAheGF3h1QwGF5o0P0BUOAyeuzgJQuoH6V4XDQMU241XEBoULCwtRojEqlYr9+/dHfXaiKKKYnOTwoUNMTE7S2tqK2+2mtLR0w4NuNtuo4iF2aO3ExATFxcUZ3S+XialIOfdIEnk226h2gr+64YONbGWM/uctpfzLs32U5uk4VHotwxvPqBVZrhmuUCgUVUpeXl5GEAS5YuF2uzGZTPKXZnx8nNXV1aypW2Ub27kakQwzy36MWhVaVWo/bq1SYMEvohDCTI6Psjy2ytLSEkqlUlZEqaiowGAwZOWHrlAoqKiowOVy0dHRweDgIPX161XGcoGNDKbZbJbnc5w5cwan04nfYEBYXUWsrUXo6YEU5HNzmYlRqVRUV1fj8Xjo7u7m6tWrO/J7uovth/mVAG/8/IuMzK3w3jureP+rauM+Lxi+9n0LJhmIFw+RfioXNjZTjkW84a4GgwGVSoVOp6OhoSEj6ex4+9tKjMyv8t5vXSQQEvneuTG+H6MGFQ/vu6OMhiITJq2S4xV5W7DLzBGp6CUFF4FAQA4KY+dnAUxMTKyvDKyuonz6aYT77sPpdJKfn09vby/Nzc0y3zDZHraCsC0NrRUEgYmJCbxeb0IuXzxspp0p1YAhVs69ubkZu92+20Z1IyG2FzbTYKOx2My//8G+dX8fuWYwGIyqWEiBhXQ4LSkpwWg0Jv2C7IRy8k5ro/rB+TG+cnIIq07FZx7aE7fiFMmPWVhY4KGyAB2LUF9kptiqw2wu2PCzSxfxvos6nY79+/czOzvLhQsXCAQCaX1nc6USJQiCrLjR39/P/Ooq4+99L/b77kPR1YWYwsTXTPeWDiQS+dTUFBcuXOD8+fPU1NRkPHhpF7s4OzDL1KIPQYRvNg8kDDbecriE6SU/s14/7/+9mrTukevKxkZrRrbTxJvBFHs4nZ+fZ2xsLCuBhoStJLAvrAQRgbAoMuMNpLSmUiHwqvrk1duthvQapRkkUmCxurqKTqfDYrFgs9k2bGOLB+VvfgODgzAzg+LHP0a021Hedx81NTW43W7a29vlpFg89cKtVodSq9VyR8jZs2c3FDnZ7P0g/UBFknN3uVxcunSJ2dlZ7HZ7RnLuu8HGdcBv2if47ukhXrOviNfdFF1Gy1YbVSykdpqlpSV6e3sJBAIolUq5YpFKYBEP2z3Y2Anlulj8qn0KrUrB/EqA9vElbjHYoqamS1LBkdUmn8/HvXc2ZI2wGA6HEUVRdqgSmS0UCsUlI+fl5XH8+HFefPFFzp49S3V1dVyidixyLUkrVWCGh4cZy8uj5/TplGVot1Iu12AwkJeXh9vtlgdDxZLId7GLVLDfY8OsUzPr9fPAwcSCH2qlgj9JM8iQEOunso1IP5BsuKvFYqGgoGDD4a654ICkC1EU+UbLMBdGFnn0tlKqC4zrHk+EOqeR99xayou9s3HVoLYzAoGA7LtmZmaYnZ2VKxYWiyXjGSSSYmIoFCIcDhPctw9V/wATJjtFy16U99yD8NJ3wmAw0NTUJFe7i4qKKC8vz8rhd7NBioC8PwAAIABJREFUSqzIidQxkO35HEDGPBGVSoXL5UKn0zE2NkZ/f39cEnkyyIqQO+RMtuODjdVAiE8+1YZKIfDZp7u4tSqfvIgJmtmobET26UsVC6mdRqlUUlBQgMvlysoPLRXZw3TX267BSzprBUJhvP5QQgWQRBBFkdfU2fjCi0PYNBCa6KV1OiwT4JxOJ9XV1euyH5v5EccGFqFQiLm5OVkRTRAElEql/Bwp8Ii9nyAI6PV6ampqGBwcZGhoiPr6+qQzN7bqQK9QKGhsbGRxcZH29vaUyIOZZGIydQTSvfLz8+XSdUtLS8r9xrAzA+tdZB95Rg2//vM7mV8J4LSkJ2WeKiLbqLKJyBlMMzMzDA0NZW246/X2K6cH5/n88/34gmG6J5ejWqFSqdS+4+aShCTvXCPV1yqdPaTgwuv1olKpZPERi8VCSUlJRjOHIv2UKIr4wzA2MUVhvn3NT5lMfGDWyQurBipVPr6hUKKPscfSwV7iy9XU1FBQUCC/xq20obEytJEiJ1IFJt77tFnORqbXhsNhtFot9fX1CUnkG2En+agdH2yolQrsRg2Tiz4sejX6mDkFaQ9LCgSiAguv1xvVp19WVobRaJQ/5J6eHnQ6XdbKWbmY9Lpd26hShdcf4s+/d4XhuVXedNDFI8cS68qvrKzIWbuFhQWCwSDlBgOffU0RdpsFq8WS1ZkjkqGWjHasqpMgCOzbt4+uri70ej3V1dXrJFpFUSQYDKJQKNZVOURRRKvV0tjYyPz8PFeuXMFisaxbJ/L5yeAPru1XG6H7vhmnIMnQTkxMcPr0aYqKiigrK4tbus7kPpmWimPJcx6PB5fLJTvFyspKnE7njjLWu4iPwRkvH/jvc+g1Sv7pLQdwmLJTjYyETq2MmpWQbUT6qUyx0XBXs9lMeXn5thvumul6+pc+D4UgyP+dq/1lE4lsjiQcI0nORiY1E3EEZ2dnU7JhkX4q9n0RBIFnumb58LM+1IpOPnqbhbsO7UGp1vBbnxGVSkEfBgZ9ApVx/JRCoaCyspLi4mJ5BkZDQ0PS15oMmR7g4/mXZCInEraCsxEPkfdNRCK/keaj7fhXolQI/OtbD3Kmf46bPNZ1DiGyFzbWAEmBhZQ1WFlZQaVSyT/u/Pz8DQnA28HobvV6W43eKS8j8z6MWhW/uDLJI8c8iKK4rk91cXGR3t5erFZrSnKL6WIjg61SqWQjHGmA1Go1TU1N8oG8pKQEt9stV0+kzygcDsuH5EhjLv3barVy9OhRRkZGaGlpoaysTF4ndi/x0DWxxF99/zJhET5xfwONL0kzbzYDJQgCTqeTgoICWVGrqqpq3WF+K9uo4jkBpVJJVVWVTCKXSteR+vHb9YCyi8T4zK86OT84hyAIfO1EP392d3xOxXZGpJ9KBekOdx0eHkYUxawdXjbrV3qnvABU5hsyXq/RZebv76/nyugibzroyngv1wPhcDhKFUpSpDSZTFgsFkpLSzPmCEbO6Yo674TCfOIXvVweXeLJe6q4tcohr//fZ8cIhkXCokDPqgHbuXM4nU7u3VPIL9unaHCZKXM75M6LeH5K4hvOzMxw/vx5rFZrRt+RXKhYxRM5KS8vlzsMtoqzEXtt5Ocbj0SeyiTynYJtEWwMDg7yyCOPMDY2hkKh4D3veQ/vf//7o57z29/+lje84Q1UVFQA8OCDD/KRj3wEgEKzjnv3xh9upNFo5B5Hv9/P6uoqFy9eXBdYFBQUZKQs9HJqe8r2eqm+15X5BtxWDf3TXu6tMnD+/HmZAGc2m7FarXg8Hq5cucKePXuy0pcvHf6DweC61xvZChUbWCSCdCB3OBxcvXqVU6dORXEdYoMOqbUqXlDjdrtxOp10d3fT0tISVR4WRRF/SOQjP2qjb9rLn72qioMla4fpZ7umWfIFUQgCT7dPZi3YiHxfKioqKC4upqurS57PIfWhZlKl2ExlI9FrkipFS0tLdHR0oFQq5Wm0W13638XmUV1oWqvUiVCRvzOFADQaDYuLi3EfSzbcNdUZTAqFgmAwmLX9bsYP/Lp9kg/9pBOAj762hnv3FGa83itqHbyidr0iUrb98mYgcWSk4GJ6epqFhQWsVqvMETQajRnP0JJ4FqFQiLmVICf75tjvNuO26VEqlbK/au2d5bddM/iCYT7+s25++ScF8joP7C/i4sgiaqXA3Xs9VBfU0t/fzwOuBd57vIEy1zUCczw/FWkz7XY7x44do6enh5GREcbGxtKqIueKWB4rciIlxbRa7XWZyZSoKhJJIpcmkVdXV2dEIt9O2BbBhkql4h//8R9pampicXGRQ4cOcffdd7Nnz56o591+++385Cc/2XC9xcVFXnjhBU6fPs33vvc9vvGNb3DkyBE++MEPolAoqKqqWjcLIVNs97an6/nlnFry0zowT6PLRMkGuuSRiFdxeletCo3BgdNulQflZfO1SYYzFArJgcTo6CgejyfKYG82wyBNF5UOulJrlVSBkV6TKIosLS0lbK1QqVRo8kton1IzdqaNqgITtbW1iKLI5fFVTvXPolYIfOn5Pj7/1gMA3Fpp5ycXRgmLcFdttKpKNt9LrVbL3poagh/9KOfuvx+dxUJNTU3GlY3NtlElgslk4tChQ0xPT3P+/Hny8vIoKyu7IbJILye8984qap1mdGoFt1XnTi1os0mxZNDpdExNTckJMb/fT1tbG8vLy1HiFZkOd91OSafmvnl8wbVA4OTVuU0FG8lwPaqUoihGtfFK5PtIjmAgEKC8vByTyZT2+vH81NjYmDwM9t3fuszkkh+1UsHPHj+GJSLx5rbpQRDQqBRUxZDp37DfxW3VDnQqBcaXZslUVFRQVFREZ2cnFyZHo+RkpeSYlJCL11rlcrlYXFxkamqKwcFBGhoaUnrNuVaxkpJibrebrq4u5ubmMvosYHOKUOFwOOnvOHISeVdXV0IS+U4JQLZFsOFyuXC51sqgZrOZhoYGhoeH1wUbqWJ4eJhnn32WQ4cO8frXv57y8nL+8A//EFjrccymDOZuZSM+wqLIkz9sZ2LBh1Gr5MtvuynuQCxRFJmdnY0akhdZcSosLMxaYCjvLYbAHfnapMCisbGR/v5+Lly4kLLaUjowmUxRrVXFxcUYjUa5X3dlZQWtVisP94tVrfIFQjzx3Ussrgax6NT8Y42dU6dOYTAYcFksaFUK/KEweyOm2De4zHzznYcRRTDprn0WWXXKoohw5gxCWxv6X/yCIzfdxHR+Pq1zc4gZ3CvTMnU6TsDhcHD8+HFGRkY4ffp0VJvALrY/FAqBu/c4c36fbCfFAoEAZ86c4fTp03z729+mv7+fp556is9+9rMAFBcXZxRYxEMuJ4ini4cPF/Nc9zRhEd56xL3p9RLtL9cQxehZFhJHUK/XY7FYEvbdj4yMpLR+rJ86eXWO75wb5949+dzTUIBCoaCmpoahoSHOnz9PZVU1ows+RBFEMczMciBqin1FvoFv/I+D9Ex5ubNmfTXIYVzfcqzX69m/f7+ckHE6nVEJGSnZmqi1SqlUsnfvXubn57l06RI2m43q6uqk7Xy5DjYkaDQaGhsbGRwcpKenh4sXL6Y9IX2zLVip+BidTse+ffvWkch3GrZFsBGJvr4+zp49y7Fjx9Y9duLECfbv309xcTGf/vSnaWxsjLtGfX09//AP/wCsBR7ZLB/HYrtXNiD7GZ7Ugg2Y9QbQqBSsBsKs+EPoVYJMgJNUvbxeL5OTk1kfkifvI0lgEdkOBaz74VdXV7O8vEx7ezsGgyEhKTtdSIMe5+fnWVhYANamjIuiSElJiZxB+vmVCf7hN4Mc8AT5i1dVoVZeK1mHRPCHRNTKtaCioNCJx+Xk7NmzrE4N8Q+vrcOv0rPXFZ0FMSaYgJy19zwUQvkv/4LQ3AxmM6qPf5zCm2/G+oUv8LuWFs6dO0dNTQ2FhYUp3TObZMFkkNrTbDYbp0+f5uTJk9TW1uJ2J5Y63cXLC9lOii0sLPDlL3+ZQ4cO8epXv5qZmRk+/OEPA3Dq1CksFkvWfpeZ+pXVQAitar0092aCl8p8Az9/PNq/Zzs4yIUf9fl8UTwLn88nS85uliOYyE/BSy1wYZEnfthJIBSmuX+eY1X5FJjWbHl5eTlFRUV0dHTwjr16ft4f5tWNhZTZ13cT1BSaqClMP4vvcDjIy8ujv7+flpYWampq5IF+8VqApXNRJN/w2LFjMheh/CWlqHif+2YVCNOFXq+nqKiIvLw8WltbcblclKco47uZpFS6vi2WRL66ukowGMwqLzWX2FbBxtLSEg899BCf/exn15WKmpqa6O/vx2Qy8dRTT/HAAw/Q1dW14ZparZbl5eVcbTknGZntkoFKtF4qUCDyx7cU8YML49yUr6Cv/QL9grBuDsnp06ezGqWHQiFgvcHaKLBIBKPRSFNTE2NjY7S2tlJWVpZUszsWEpFTCiwWFxdlIqBKb6KsrEyeIC+1Vq2urlJdXc1XTgwiiiInemfpnfJSW2iUS9Z6tYKPvLaWX7VNck9DIYaXVNgkqdfZ6REUCgV+R/yBSzmDSkXwc59DfffdsLICeXkE//VfUWq16PV6amvXeoElPkcyGV/YmspGJARhbQjnnj17WF1dTfv6Xbw8kI2kmMPh4Etf+hIAP/nJT/jNb34jPybZ7WwGG+n6lX9+5ipfax6iptDIV/5of5TiUy4O89uFYwHg9/ujWqGWl5dpa2uTJWfdbvemZjCFQiGCwSBTSz6++OIgDoOGd93sRqtWRSXC5ApCOIxGpcAfDKMQBNTKaNsmkbPd7imOFHRTXKzKOv9Maj9yuVx0dHQwNDQUt7UqkkMiY3ERYXoaT3m5zDccGhqioaFh3VlvM/vOtCKiVCplkZO+vj5OnDhBdXX1hkmxbKlRpQqJRJ6Xl8eLL75Ic3MzFRUVctvmdkbSYCMQCq/7UucKgUCAhx56iLe97W08+OCD6x6P/EK+9rWv5X3vex9TU1Pk5yfv0dXpdMzMzGR9vxKyTbzb7pWSeOvFEuAkyUWn0cgTtxdisVgyJsAlQjxlKLVazeDgIOUvyTtmi2chCAIul4v8/Hx6enoYHR2lrq5uXZ+n1K8rldQXFhYIhUKywojb7cZkMiEoFHz0xx2cHhzhlbV+/vxVawfu2NaqapuWixMBrHo1LqtuXcm6qcTK4bK8dYpPWq02auCS0+mUe3q3AsLoKDgchB5+GOW3voUwMoL4EmdDKgnPz8/T1taG0WikpqYmYXYml5yNZNdptdrdqeO7iItcJcUi+VlS5eB6Sqr/f6dHUCgEBmZWaB9b4mDJtVbS7d72lM7+gsFgVMVCEo+xWCxYLBaKioq4ePEiBw4cSHsf8ZSh1Go1w8PDVFZW8n9+3c+z3TOoFAIlDhMPJVDVUikUfPWRA/zs8gR31jiwJZg3lZ+fT15eHlevXqW1tTUnLcBSYBPZWlVaWkogEJCTavPz8wQCAUpKSggFgyhbW1G0tBB+4gnUajUNDQ0sLi6m5ANSxWYSU5Fck8rKSpnPsVFSLJtqVOlCp9Nx6NAhlpaWMl5jK5E02AiGRHIoLS5DFEXe9a530dDQwAc+8IG4z4lUNGhpaSEcDstlvGSQ1KhyhZ3Osfj22VG+dWqEo+VWnnhVFUrFxhOqV1dXGRsbW0eAiye5mA0kkvKD6IpFY2MjQ0NDnDt3jrq6OvLy8rK2B1hzEvX19fK8C6l8vrS0xPz8PH6/P2oKb6KJ1ROLPs4MzmPXq/l1xxSP31UhSzZHqlbZ7L1cHpzm2L4yeZhhbPYoVg0kMiuUbOBSLiFWVxP47ndBpyP85jfDS04k0rharVaOHDnC+Pg4p06dori4OC45e6srG5vJVO3ixkeukmKxQ/22g195ZV0+v2qfwqpXU1MYTSjeDvvLZD2phVUKLCJnWVgsFiorK+O28qZig8LhMBOLPma9firt15JDsS27NTU1jI2NceHCBQhrkZbWqJLfI9UWKKVSGdUCLA2GzUYLsATpTFVQUMDIyAi9vb2YTCY52CkrK1sLHvr6UH70oyjm5hDCYZRPPkn4934P8d57MZvNHDlyhLGxMU6dOkVJSQklJSVb1jqb7DqtVitzTdra2jAYDNTW1q4LiLaCs5HsWpVKhd1uz2iNrUbSE2HsgLxc4cUXX+TrX/86+/btk7MHf//3f8/AwAAAjz32GN/5znf4whe+gEqlQq/X81//9V8pfci5mswqYTsR7zJZ75stwxg0Sk5cnWVgdoUKx7VsbjwCnNfrlYnL+fn5VFRUZNWISe9lpOJGPIOdqGJR/lKZtr29nZGREWpra7OyP0k+WcrahEIhZmdnGR8fx+PxsHfvXn7ZMct/nxnhjmqBd5fnJfx+Oowa9habuTSyyO3VdrSq9a9DpVLRUFdLqWeZjo4OFqfH16lWSc4sUg0kXvtYvIFLOc3aKxQgtW5FtHDF7k0QBIqKiuTSdTyJv0yDja3u+93FjY9cJsUSVTayhUzW+/jranns9lLyjZp186u2e7AB12ZZRM4ikdokpQG9BoNhUwe+SD/VNbnM//zW2hyjR466ee8d5Qn9lNvtpqCgAIW2DbOgobbUxX17sytysNkWYAlSgCb5vuXlZbnyY7VaaWpqAqCzs5OlpSWKi4uvHcrLygjffTc/+cHvGFdo+f1KM8Y770TagdQ1UFBQQE9PDydPnsy4wrGZYCPRd2CjpNhWcjYiETu0didgW3A2brvttg0NzeOPP87jjz+e9to6nW7dsKRsHii2u9HdaL3DpVZODcxTYNKSp4HJyUnZOPv9fnmWhUSAm5iYQKFQUFxcnJX9RfZ3xh5EVapr/avpfF56vZ4DBw4wMTFBa2urTKBL9UcZz7gqlUrZuDqdTlkhy+fz0dnZyeUrV/jii6sYtSp+eGGc+/YVUWyNz5VQKgQ++UADc94AeQZ10n0ZjUYOHjwot1Z5PB48Ho9c4Ygk5kl/4iF24JLD4djyCaWJnIE0bM/tdtPZ2Ul/f79cut5MG1UmbXuRwc1OMeK72BrkMikWO9RvOySxBEHAY4svWb7dCN2R09MXFhaYnZ0lFArh8/miWlg3czAMhUJJFQzbxlcJhiEYFnm+Z5bHX1GVdE2NRsOxpv1Ul03T1dXF0ODafIVsvrexLcAjIyPU19cnlHqVJNcl3ydxDKXKT0VFBUajMe4e9+/fz+/aB/k/PzrNqxudHNlThUKh4NfT8FHLQYKCgrbpBT6pUqGIUVdUqVTU1dWxvLxMS0sL3d3d7N27d0uUoVKZz5EoKbbZysb1asG6HtgWwUYuEVvZ2ImciFysJxHgHq5VcsiixCh46evplPtUPR5Pwh96pvtLpLgxOjpKUVGRbLQhdQJ3IkjtSHa7ne7ubtnIGo3R7QDxCNwAOoOJ6ZCOWreHRoc14X60Wi379u1jenoaR8slJrwhCqyGhD21EhSCgD2O1GCy1xI7ENBiseDz+Zifn5f/BIPBpEZQGrg0NDREc3MzVVVVcT/PmWU/v+udoabQRJ1zPTclE4iiiDA3ByoVxPS6w1pAdNNNN0W1qdlstoyDjUwqWjvRiO9ia5DLpFgqbVRDcys8+YN21AqBT72xgUJz6gexbAcv2UY6fi+SGye1REXOsnC5XNjtdpaWlqisrExrH6IocnpgDr1aQW3BteqvxAeUpjnHExr5vYYCvnlqmLFFH++9ozzlezocDmw2m2zbIwehZgtSC/DCwgJXrlwhLy+PioqKdTwL6X20Wq0UFxdjNpvXJW1EUaRrYokCszbKz00t+fnAj/rwB8P8ZmiUTy5OUVtby6KjEFEzRjgsMpfvksUKYjsWYC25ZrfbsdlstLa2JmyvjYfNVLNTuS42KTYwMCBL0meCzbZR7bRk2A0fbCQqT2eLrLwdMlAbrRcOh5mZmYkakqdWq+VsxV3FrpSH5KWjwpSK5OyhQ4fo7e3l8uXL1NfXZ729RyKjzc3NcfHiRfLy8jCbzXIGLJLAHWlcP/SjNs4PTWHVz/PFt96ESZvcKDgcDj7/9lt49nw3Ov88vuUFDJrsckZEUcRutxMOhzl79iyiKGKxWLDZbNjtdsrLy9FoNAkHLUlQKBSUlpbKcok9k16KR6epcF1r9/jIj9vomlhCq1LypT88iNOijdpHpoZO9clPgtVK6EMfSvgcq9XK0aNHGRsbo7OzE6PRuKFhFs6ehbk5xFe8Qt7jVhLLd7GLzWBsRWBBuJYIiedX/u8XBmgfWyODfuPUMB94ZeoH6Vy0KWUTieyJ1MobSeAOBoMYDAbMZrPMjYut0E5NTaV030g/JYoi/9kywn+cHAYRPvVAHbdW2VEoFBw4cID+/n7Onz9PQ0NDXMKww6jhh+89mv6L5xrPYmlpifb2dsxmc9a5j36/H5/Ph91uZ2JigoGBAUwmk8ztS7Ul+pO/6OYH50fRqBT897sPyxX8ZX+QkCgSFkW8QYH9Bw7Q1dmJxyTy0EEnk8sh/vxVVesq8sA6P+VwOPB4PHIloba2dkPe01bN55CSYnNzc7S2ttLV1UVdXV3a7V+baaPaidzCl0WwEVue3s6ViEujS7SO+tmzLxy3l38jBIPBqFkWS0tL+Hw+pqenszIkTwpeIhGpDBUbcUcqQsXrX9VoNNTX18vBgKRskY0fkpT1l/p2RVFkenqa8fFxysrKEhK4AS6PLqJXK5hfCTCx6Is7kDAWJp2a+441sLKyQnt7O8PDw3FJZakgHA5HzeJYWlqKauUqKSlhYWGBq1evotFocDgcUYoaka1ViYIOjUbDea+Nr3RO8PWe8zx5Wz53NjWgVquZWQ6gVigIhUWWfEGcbC7YUPz0p+z9p39CMTEBCgXCxYuEHntMDg5iIZX/w+EwIyMjiQnuoRDMzaH64AdhZITAb34DFsuWE8t3sYtM8dSFUZ74UT8rFQ/w8ysT3LunMG6wUVto5Fcv+YSamAnQG2G7BxuwniMY2cprsVhk4nEqB+J4rzeegmHk85VKJRdHl/G9JC/bNbXKXfXX7lVVVYXT6aStrQ2bzUZlZWVWFRZhTZHw0KFDDA8Pc+rUKbldJ10Eg8Eo/7G8vIxGo5H9h8fjAaC7u5uFhQVcLpf8vs4s+/nkL7pQKQT++t6aqMGAAL/tnCIQEhEIc2V0UQ42yuwG/vQVlfyqbZJ33VqKIWIg4F2+Lpx1TorM13xhJC8v0k9J/kWqJBQXF9Pe3s7g4CD19fWy1G4scsHZSAabzSZX30+dOoXb7U7r7LLbRnWDIVaNKt5heTPIZmXj8sgiH/tZD8teP159P+9/RXLt5FAoxNLSUpSyRmR/pWSY29raqKmpycoepUNsMBiMa7AzlZy12WwcOXJEluxLt5QcSeCWiOxBQYPBZKKkMI+SkhK5Lczr9dLe3s7y8nJClY733FbG15uHeGWVnXJHetUWiTMyOTnJ6dOnKSkpwe12J83eeb3edYFR5OdoNBrXvZ8Gg4H8/Pyo1ipJ5jAyezSz5ONTv+rBGwjxV6+upcR+7fWcHZxHIYBSrWMmqKGlpYWysjI+eG8N32od5lCJlcp8w7r9pmskw01NiIKwFhyEQqDTIe7du+F1giCQn5+Py+WK4nNIPceKr3wF9eOPI2o0oFCgdbsJ/tVfEX7rW3crG7vYETjRO40/KBIWlLT0zXHvnsK4h+W3HXFT4TCgVio4Wm5L6x7bsY3K7/dHVSy8Xi8dHR2YzWb5QJzpLItkfiqZ0Mj/urOCq9NeLDoVD+wvWreuyWTi8OHDDA4OcurUKWpra7OuBiQIAh6Ph4KCAjo7OxkZGaGuri7hvKRwOBzFs5CI8FJLdFVVVcJhuXv37pV5fNJ08H97to+n26cQgCKLjvfHVNAevb2Mv/95FyV5eo5XRFfv33bUw9uOeqL+Lt2BgLHfU71ez8GDB5menubs2bM4nU7Ky8vjtndlmmDaTNDocrkoLi7m6tWraak+ZkONCnYOt/CGDza2A/FufiXAV08OoVcreeSYe52yh4Rpb4BQWERgTR41EhK3ILJPFZCVNaQhebFf3kAgsCmOhfTvSI3w0dFR7HY7er0+qTJUulAoFClljyIJ3LFZf4vFgtPpZGAhxN/8qJ1gaJ6/vCefWwuvOS2DwcDBgwcZHx9PSCB/TaOT1zRmrg4iCAKFhYXY7XZ6e3tlzXOLxSK3BUjBhd/vl/uNnU4nNTU1KRs/lUpFTU0NQ5NzPHeug8r8aM1yQRB4pmuac0PzKASBb7YM8uSra+XX+sjxEtoHJ6h1mXnNoWp0yiq6u7tZXhjmL++qj6vRnlEmyOVixe1GGBqCcJhwYyOkYZAjS9eXL1/GbDavqXO9852EWltRfPOb4PcTuvdeQh/8IOLVq7vBxi52BN5+SxnPtI8zOjrDW4+sTayP56cEQeDWqswOtte7shEIBKIqFrGtvNIsi/3796e9djgc5isnh/hV2xSPHHVxd30+KpWKmZkZCgsLMZlMKfupPS4zT/2v40mfIwgCpaWlFBQU0N7eztjYWNalZeEaH3Bqaopz585RXFyMx+NhZWUl7iwnKUAzm80JX+eJ3hme+P4V8o0avvSH+ykwabHb7Rw9epT+/n5OnTqFQWFG9ZIEvsO0/jU9dLCYBw+kp2oVORCws7NTHgio0+miEm3z8/PAWluZKK6dhYTnn0e8/XYcDgfHjx+nv78/6lAv7WOr2qgiEVmRqa6ujuJzxJvFFXvf68H3uF644YMNnU63jniX7WBjo/X+39YRftk2CUCBWcMb42RMAG6usPG6vYWc7x7kkUMFjI6OysZZFMUoAlyqB9J0nEyslF/kGhJ52+l0otPpaGtro7i4OOvqGXAtezQ0NERLS4t8D0kdA9gw63/uyjBefwiVQuCF7hlurYqWn5QUJhwOB11dXYyOjuaEMwJrg5bC4TBnzpyR9261WrHZbJSWlm5qEi3A4OwKf/b9LnxBkfvqFCwsRKtWldkNaFQKwiLUFBhDErkWAAAgAElEQVSi+Bz7PVb+5piOW27ZJ6/X0NDA0tISbW1t8tTvyFawTI3zckUFgb/4C/D5EPr6Urom9l42m42jR48yOjrKqVOn8Hg8VC4sgF4Pej3C7Cy8xFvZbBvVTskY7WJno7rQzK//7DZuvfVWqj/xBmB7SN9mithWXkkqVUqMJWrlTZcPKPmpwdlVvvTiIIFwmI/9rId79jjJy8tj3759tLW1yXyEbB/OpAq2lLSqrKzccOJ0uvD5fITDYex2O/39/XR1dckcvYKCgrR5HZ9/ro+l1SAr/hC/vDIpVyGkYKCoqAjFlTbUe/W4XS4eOOiOu85m2rBdLhdjY2OcOHECpVKJzWbDarVSWFhIdXW1HGgEl5dRDgyg/uIXCRcVIZaVodBqo4IWqbXKaDRueRuVdG3kPfUvtY7Nzs5y6dIlrFYr1dXVcQPRbFU2dgpu+GAj12pUqaxnfqnfXxDApF1f+pMyFYuLixwxLFBfESQ4N0YgC0PyEgUbyQjcUmCRSHI2Ly+PI0eO0Nvby+nTp2loaFin8pQJIt8LKdMhiiK9vb1otVqqqqqoq6tLKci6rcrOjy+MsRoMc9++xBUKtVrNnj17ZM5IYWFhyuoXsZDK2ZHKVgqFIopnMTs7y+DgoDwAaSPjKIoiV0aXUCsFap3xsyQ9k8usBMKolQJt0yHefeeRqNaqw2U2PvOmvawGQjS6zPJekxlZKeCT9MU9Hg8lJSXyoSUToz5+991UvdQ6JR46lNI18UrcgiBQXFxMYWEhV69e5dzdd1P8oQ/h8HgQLlyQr9tKydxd3JgIhsJ87MeXuTyywIdft4em0uyKPkhQqVTr2n23M7dQQiqtvImkUlNBrJ+SDneRfsph1qNSCogocBjVaNQqeQ+HDx+WM/b19fErtZuBlLSy2+10dnbKSatELU/JIE0yl/yHNNNKEgEpKysjEAjQ1tZGIBDAarWiVCqZWvLzp9++xKIvyKcf3JN08N9t1XY6x5dAENjvWd+mrNfrOdx0kLLJSXp6ehgdIWkLcDKEQqGo1yPxRiT5+OrqasbGxuRZVZHtaEI4jOpDH0Jx9Sr4fCj+8i+hqorQpz4FSqVc6Z6dneXChQuycMpWDgOU9xrn2ry8PI4dO8bIyIicMJWUzCTscjZuMOR6WFIqRvz3D7koNGtQKQSOlRiYmJiQD6OBQAC9Xo/ZbMbhcFBeXs65c+dobGzM6v4SaYRH9q9C6pKz0iTU+fl5Ll26lBGx2+fzRRkjn8/HdECDX6nnlpprE7hFUWRiYoKuri4qKirkoVnJ4MnT8/V3NCGKbDgVHa5xRiTHVFdXh82WuC9aCowieRahUEh2siUlJXF13Y1GI4WFhVFyvMmqKT+9NM6/P98PwN+8pnZdjyzA4TIbdU4jw3Or/NExt9xatby8NhBQp9O9NBDwWkAoimJU2TqewY3UF+/t7aW5uZm6urpNCQysg9+PcPo04s03x304mSOQXueKx0NnZyd9XV3UHTiAic0FG9luh9jFzsWznZP86NwIq4EQT37nAr/6wJ05uU+sgMN2VDmMbeVdXl7m7NmzmEympK28qSKRnwKS+im7ScU3/kcTpwfmuavWse59rKiooLCwkCtXruSM2K3RaNi7dy/T09OcO3cOt9stV5bjQRIAieRZxLYCx7OzWq2Ww4cPywTyqqoqvt+xzOXRBcIifO7Zq/zzm/fFvSfAe24t4/YqBzaDOuEcqGQtwIkgiqIsIR87n8NqtVJZWRk36IzXWqXX60GpJPQXf8GPP/Z5vmup4W3zbbziT/947XsQcX1eXh7Hjx9ncHCQxcVFxsbG0h5cmCsZWUEQcLvdOJ1Orl69SnNzMzU1NbKq1m4b1Q2G2KF+uTDiidaTDtOLi4sU+tYO0z0+fdSQvEynZSZCrJQfrPXLzszMYLfbMwoskkGasCkRuxPJAko9u5FZGynLIc31GFwI8Q/fvUwwvMiAT8ufvnKtp18Qrs3M6OzsZGxsLKXskUIQIA0bIjkmaQK5TqeTe3H9fr9sSKXAyGAwYLFY0i5nazQaKmvqmJub5+LFi+Tn58clvAH0THkJhUXCIvRNe+MGGyatis+8aT3ZWhoIKFUnbDYbKpVqneRvY2NjUqlcKbB0u920t7fLai4nemcYnPHy6kYn1g3miiSC8OyzqP7yLwk8/zzE6W9NxajGK11nqn++E434LnKHIqsOEdColFHCCrlAZDBwvduo4s2yCIfDUa28CwsLHD58OOU1VwIhnm6fotSuZ5/LFFcZamJiQm5FSkdopKrASFUShS6j0RhF7K6vr0+aTMoU0syMnp4euepvMBjkIC1SAETiWZSWlkYlpq6MLnLu6iJ31WrRx+F3RhLIOzo60Hj9qJVrh/B9xclFVQRBYI9rvX+OB5VKRW1trSzHazKZqK6uRqVSsbq6GsWzCAQCcSXkU4FOp0NfVMnnn+nC1dXKmw95KCsrY8Eb4MOu2wkplJwzFvGsL4g+jp+SODQDAwPMzs4yNDSU8BwSD5utbGwEKSnm8Xjo6OiQ+RzZ4IrsJNzwwUY8NapI4/bVk4P87PIk9+4p4B03l6S9vtRGJQ3Jk4zz6uqqLDVnNptxu92b7s2PRTIpv0hD3dTURHt7O3Nzc1RXV2f9SyoRuwsLC2lrayMvL4/8/Hz5/Ug1azMxPEMwLCII0D+9su4+arWaxsZGZmZmUsoeZQqtVkt5eTnDw8O88MILqFQqObCQSHiZlMkldIwv8cEftiGK8LH76lGF5jh16lSUSoeENx0s5uqUF61KwT0NqUkgRipzzc/Ps7Kygl6vx+v14vf7qa+vX3efyAA10tHDmhRi/4yXPUVmmpqaGBwc5FenO/jWcxdBqeLCyAKfuH9Pem/C6Cjqt7wFZmYQlpdR33IL4tGjBL/85XX7SvXzjSxdt7W1YTQaqaqqSuv7vhON+C5yh8ZiK//5zqP0TCzx2n2uLbtvLriFiSBVaSP9lzTLQkqmxJtlkQ7HAuCvftBGc98cgiDwxd/fw54iU1Q7VFNTE52dnczMzFBfX5/16oN0KM3Pz5ftg3R4zhZEUZRbnPx+P83NzVG8BKl9KNE9O8eXeMfXziICxysm+Je3JK5SaLVabrrpJoqLp9CKnRhtDl53JP0zzEbQ6XRUVFQwNDTEc889h1qtlgf/Se1dqSRNw6LIL9smUSkEfq8uuoX4T/77EiPzq2hVCg6U+xgfb8FT5Eaj07ISBp1ShbowX/5dxJN0VygUNDY2ykNhLRZLQr5EJLZqZoXE8ZmZmeHChQusrq4SCAQ2PXx2p3ALXxbBRqI2qsXVIN89N4ZJo+R758d48EBRShlaKUu/uLjI3Nwc/z975x0mV1n2/8+ZunVmtveS7SW9Q5AOoUZpgkonIEUprz8EQUVF8QVFREFp0lSEKGhUeIGAtAApm57tm+29zc7M7k495/z+mJyTmd2Z3dnNRonke11coDvtTHme577vbxkZGWH//v3qYTo9PT3ikLxIEcoZKvCawln5wSH3pa6uLqqqqubUrk+W5SDbPVmW6enpoauri6ysrLAC7lBYkW/h9LJk2oed3HxSftjbJSYmqpoRZZoylevDVAiVIK7YBiYlJZGTk0NXVxdut5vs7OywHt8zweamYZweEY0AHzQO8c1TCkhLS6O+vl7N5lCKmSxLFL+8JLxFbDidiDIxmljYKdSqvr6+g9SqQ65VgRaE4P9ejbpFbvnTHmwuLwuyzDx4QSUJCQnExpuRGcfrcmG1j8/8TUhPR7zjDrR33YV8UNwt3n13yOubyUagjK57e3vxer0RB0LN9vmO4b8fS3MTjphWQ0Hg709Zw4+ExkKW5aCJu91uD0nljfQANLEZELhPKfQU5TadVhceUcaoExgclyY1bLRaLQsWLKC/v58dO3aoDay5RkxMDEuXLlX3w1BNnkihNHaU9dfpdKq5IBN1CXl5edNOUzpHXAB4fBLNg5Gtq8nJyXz59ARVQ1lWVhZxV38iptIdpqamkp+fT2dnJ263m/T09BlpNZ/7tF2lBH/rtEIuXX5IfK5MZgDycrLJM+fT0NDAd9bE0S1ZOLMyA0Osf7I40SpXOfcoUEJhFb1EXl7elLqTf3cad2JiIqtXr+aDDz5g27Zt5ObmzrhpejRqC//ri42Ji3ZgxyjGoCUvMZoOq5PchOiQwW2BNqsKT1Xp0sfHxzNv3jwaGxtZunTpnL3mwB/SRGeo6QqLcFBGr0lJSdTW1tLf3z8ji1XldU0UcIuiqHY5AsenY2Nj1NbWAlBQEFnSrUGr4Y7TCiO6rULtsdvt1NTUROQ4ooRGBdKhAulEWVlZqk1iICwWiypEmyggl2SZrS1WAFbNS/BTt6bBmsJE3qjuQ5bh5BL/ITgqKopFixapNocZGRmqIDuS1x+J7SEcolYpG7riWvVmTT8vbe9iTWEiN6zJVQ8LfTYXNpeXaJ2Wul6H+jrKUozcdHImTf0OlpvH2blz55T6k0kHJ0FATkoCjQZSU8FuR86a7HxyOKPmwsJCJEkKGl1PtzkGbjxHS8foGP47MJFG5fP5DvsxlSwLhbq6fft2VXSsmFbMlsorCIK6P4VyMJyYufTD88v46VuNFKfGcUpp+OI/NTUVi8VCXV0dfX19s0pnjuS1Z2dnq1OOvr6+ae1rA88CNptNPQsojZ2MjAyioqLwSTLvNwyR6jawKCWK/Px8deo/3TTlhKJETilN9k+/10aejaXshw6Hg7q6uoi0KbPdT8xms2pBrhSnWq2W4TEPX39pLwOjbh66oIKV+cEFeqfVhccnIwiyWlQp+M1lC3h5RxeLs0yUHjRCWbhwIVlDQzQ2NoJDg5SYN6mbL8uySgGWZRncbhgfR0hIUPUSTU1NbNu2LaxBwJGmUYWCIAgYDAZWrlzJgQMH1KZYpEXv0agtFKbpnny2I0cjgCzLLF68mM2bNwPQ1tZGVFQUaWl+hyKnV6R1yEleYjRGLWGdNRThb0xMTNCPTxRFdu/ezbII3XVCYWJhsWvXLgoKCrBYLEGL9Vx1XGVZpquri87OTkpLS0lICN21CyXg1uij+GerhEvW8s1TCslNDt9BkWWZjo4ONZQo3PMcLiRJor29Xd2YlO6RstEqr9/lchEdHa1utCaTaUY/WEmSaGtro7+/X32eN/b38fgHrcjI3HRiPucvCG1rPBFOr4gs+wveiRBFkdbWVgYHB0lPT1ddPZSumdlsnvHrl2SZ5sFx0uKNxEf5Nzqfz0dLSwtDw8Pcv10ixqjD5ZX4zVcWkpMQ7f9OShJPfNTG1tYRrlydw1mV6dhsNjo6OpgfEMo3PDxMfX09ycnJYbNRtm/fzurVAR72ra0I3d3Iy5ejeeMNpPPOA63Wb9t2EHV1daSkpMy487h9+3YWLVqkHlKsViv19fVYLBYKCwvDvm81NTVkZGSQkJCAwWD4LBUcn5kX8hnEUb9PASxatIiPPvoIQRDo7e3F4/GQm5sb8f3DZVkoE/fm5mZWrlw5Z85Q+/fvVw0kAveouZwM9vX10dzcfMSmHODfp3p7e2ltbVUTu0MJnuGQbbnJZAo7sf/R6/X8c38fAL+5bCHL8yzq83R3d9PR0UFhYeGsksEjvZ7Ozk66urooKipSp7perzdIZ+FyuWa0nwyPedBoBCwH2R+SJNHR0UFPTw9FRUVsanHz83eaECWZBVkmfn91cAO23+Hme/+oQ6/V8KPzSkmMjayAVPZdpSBU9oKJn5HVauXEtjY0e/Yg/fznQY8xlZV7dXU1WVlZs9LwfPLJJxx//PEzvt/E+yqBlgClpaXTWvA3NzcTExNDeno6er3+szSND7u4/NdPNoBJkwGla6uItgSHg5rOUVW0pbgJRUL/manwLhLL2UWLFlFbW4vNZqOwsPCIcFeVKUdNTQ1xcXHk5+cH0YlCCbijoqL4v+o+tve0IAhe/lDVwz1nhS82FI5sSkoKNTU1R4QjC/7PICcnh6ioKKqrq9X/T9lolanL4VLbJgrIo6Oj6R6JQpRlkGHA4Zn+QQ5iovAv1Pga/MVxTEwMJSUlxMfHz/r1P/qvZv5VP4gpWsfjly7EEqNXhWuZY2Ok7dtJ56iXFFMMiTH+zUQQBHRaLbecNI+bT5TV7lGoTlBiYiKrVq2io6ODLVu2qOGMgR2oSa89Px85P99//V/6EgDaO+9EOuss5NNOU+8XyUKqu/JKxPXrkU88UX0/A+8XyoowVEbMMRrVMfynMJFGNdW+4vP5VCqvsl4rWRYK5WWiLq61tXXS9z1cV3eqfUppgM2fP5/6+npsNhslJSVzvq4DpKX5MzPq6urUJs+R6OhaLBZycnJoaGiguroao9GodvhnKnhuHBjD7ZMwaDW0DY+rxYZC8UxOTqa+vp7e3t4jNrXJysoiKiqKpqYmamtr0Wq16PV6tbBQpjCR7ifvNwxy52s1aAR4/GABpdFoyMvLIy0tjYaGBozjXrQawe+6GcLIJDXeyJNfnXloo7LvJiUlUV9fT11dHQaDAZ/Pp7IqckdGWPjKK2gaGxFGRxFuvhn53HORzj0XmNrK/d+l2ZgKCtV9aGiIPXv2kJiYOKXpzNG4T32mio0333yT2267DVEUWb9+PXdP4HC73W6uvPJKduzYQVJSEq+88gr5Bw8rU0GWZXbu3KmmibtcLjo7O4mNjSU+Pp6MjIyQ9JlIMNWPNZIFO5QzlE6nU4W4iiZhKtu5mULxRrfZbBiNRvr6+ujq6iI5OZmUlBRSU1OJiYkJeW3JsQZ0WgFJlskIY503EdHR0XPGkYXgjoZCEQB/1ykvLw+Px0Nvby95eXkRdY9G3T56bC7mJcegi+AHrCwMvb295A20sCwjhpiYGC5cEpmAdCbja1mW6evro7q6mry8vJC2fiNOL21D45SmxYVNp9/eNkKUXoPd6aPD6sQSc2jDjo2N5bErj+PT2g7EkR6G+3uICeCQKv9WivSJlAkFyuaTnp7Oyx/uZ/jTA1xx8gKSE0zTjqqFTz5BqK1F87e/ITQ1IbW1IZ111rR8WuG99/z3++tfEbq7ES+5BOnCC0MuxoFWhM3NzSFH10fjIn4M/x3Q6XT4fD4MBkNQsaGs14FUXo1Go07c582bF3a9ngobdnbzs03NFCTH8PRXKonWayb9TgMn6xNpu3q9noULF9Lb28uOHTvmVAsYCIPBoD5PVVWVOn2YLaaaeJeVleFyuWhvbyclJSUim/WJuPvMYr7/zzoyzVGcXTk540kRditU1nDreqQIdA4LzKeKi4sjOzsbSZLo6uoiIyNjknZBlmVkmJb++/r+Pjyi//v4r4ZBtYAC1MyLzMFBdGIDUaYkTlsS+UQuFCRJUvf2kZERNaNDYXv09fWRkZFxiNKckIA33sQzyUuxZcZw81gbsRUVCAHf53BW7v9uzcZUUFLSOzs72bp1a1i9yWfpNUeKz0yxIYoit9xyC5s2bSI7O5sVK1awbt06KioOudz87ne/IyEhgaamJl5++WXuuusuXnnllZCP9+677/LGG29QVVVFR0cHP/7xj7npppuYN28eycnJMxpPT4dAjYXy35Eu2OGgTAWU6YPCjZzpQWjiwVxJIw8MXaqoqMDtdlNTU4Pdbp8yBXVFfgI/WVeG3eXjuILIaVETObK9vb2UlJRE5BThdrsn2ewpHY2MjAxKSkomFYpZWVnU19fT09NDaWlpWCewMbePW17ex/CYhxX5Fr5/TmnE15ORkUFycjJZjY243WMY8QGTrydQRDhxfK3QjsK9D8oCmZSUxIEDB9RsDkUQP+4R+eYr+7COeylLi+PnF4XOZ7lyVQ5PbW5jcY5Z5cQGIsag47RF8/D5coICAc1ms+oJH0gpyMnJQRRFhse9DI56KU2LQ3Mwz2R7xygv17nx+iT6Xt/NVctSps1gETo60N1/P7IgoNm6FaGrC+nkk6ftOmk+/hjtT38KGg3Cli3o6urwnnrqtPkcJSUljI+P09DQQFtbm6rnOFZsHMN0OFJNMYPBgN1ux+PxMDo6itVqZWhoCEEQZjRxH3X7+LTFSnl6HNmWQ4YWE/eppze3+6muVifb22ycVJyoTtdnsk8ptMOamppZaQEjRXp6ujrlUCiz0+0foYLllA6/otMzGo14RIkH32qi29bJ3WuLWb48VTXSKCsrm5GTZGVmPK/esGLa2ylZFo2NjfT29lJeXh6RAUk4G/bAFO6JHfGsrCwOHDgQZKjSYXVy1Qu7GHX7eOTi+awpDF8ofnlpJh82DqHRCJw3P3RIbnJyMueelEBra6tafEZCTQrMrAoslqbK6OiRzfyttov5HVtZUuHPrvhz3iqe1OqRBA02OY8fZmdDCKvciVbudrudrBB6wUhe95GAIAjk5OSQnp6u6jlKS0uDCvljblSHgW3btlFUVKSKiS+77DI2btwYVGxs3LiRH/zgBwBcfPHFfOMb3wh7qJBlmbPPPpt7772XU089lVdffTWIC3s4mGg5K4qimvYZShh3OIiNjWXZsmXqD7iioiKsyDWwY650BZRRoyJgC3Uwh0PTh87Ozml9yBdlzz6FNSoqisWLF4ftUoWybVXcPRISEiK22VO6RwMDA+zcuZPc3FwyMzMnfVd67G6GxjzEGLTsbLfN+HqUBHKr1cqePXvUsX8gd1oxFJjp+FqSZbXjpNfrKSsrw263U1tbqwoAh8c8WMe9ROs11PWNBt0nEGdVpnJW5fScZ61WS3Z2NgaDgb179yJJkmrhbDabyc/PVxf+7hEnt/25GpdP5OzKNL55il/c7/SK/teh0WJOTiI+PpadO3eqk5qQtI1LL0XatAnNm2+CICDedx8UFCDt3TvleyV+97to3n4bYfdukGV8v/0tcnExDAxM+x7HxMQEWREmJiaqYsNjOIZQmOumWFtbG++99x7bt2+nsbGRtWvXct1113H66acTGxtLeXn5jA/uN7y0j9ahcbQagdeuX0pCtE49GDkcDlV3eGJRIm/UDGDQaViUm3hY1uxRUVEsWbJE3T/Ky8vnPK0bDq3rfX19k/aPQGdBJShP0VxOFSwH8Mb+fv6xrw+vKPHj/2vgmcsXM3/+fAYHB9m5c+dhTx/CQafTUV5ezsjICHv37iU9PT3IGEQRpSvXpHT4Z2rDrtVqKSkpweFwqPvH+316hse8gMzzn7ZPWWysyE/go2+dAILfyGWq5yksLCQ9PV0NlJ0ovA/VfIuOjp5ULLm8Io39YyQag+mA1d0O/ufVGnyiTGVGHGmWbrq6uhCjjGDUAwKa2AR1vxFFMaRrleJKtnXrVmpra8nMzJxRQ/dw6FeRFCrKnq84SComJ9HR0UdlU2xOi41+hwu3V5pV+FFXVxc5OYc8orOzs9m6dWvY2+h0OsxmM0NDQyFtLU8//fSQzzMbjYXy73CWs6WlpdTU1FBQUKAKz+cSGo2GgoICkpOT2b9/v+pU5PV6GRkZYcBqwzXq74gp42DFnWkm/FalolYcq+Lj44+YZkTphlVXV3PgwAFiYmIYHx8POpjPhYVwSkqKuvHv3LlTDVlSMC8phuMLEqlqG+HqGeasTKRDaTQa2tvbaWtrIzMzMyJ3qFCQZJkH3mzk4wPDXLA4nRtOyFf/ZjKZWL58OZ2dnWzbto15BQWcU5nKxweGuWp1bkRuWIHw+XxBC3+gCL28vByPx8MLmw9Q43DwtdXJnJV9SKPTYXXi9IgYdAK7OmxqIXFySTJdVifD416uPi6XxFi/9mfnzp1TuoIwMoLvgQcQtm+H1lY0zz8PpaVTf/6yjNDTg3jPPWjeeguhpgbOP39G74FiRdjV1UV7ezu9vb3k5+cfNR2jY/j3Ya6bYtXV1QwPD3PZZZdRV1fHb37zGzIzM7HZbPT29ka89ir7lCzLtAyN4/VJ6HUaukecJET716CysjLq6+vJzs4mKyuL+84r42urckmNN8w6lDMQgftHYFr3XB+KBMEf8hoVFUVdXR2NjY1otdqgoLyZrr1JsQYEAXRaDSlxh5pZycnJWCyWGU8fZgqLxcLy5ctpaGjgk08+IT4+HpfL79ik7IdTFUsAHzQM0mN3s25hekjjEfBTjZX9I26sA4MWZDSsrZi+EWXQRf45Kq6Hvb29bN26VW1cKplbinYkMzNTbdIGQpRkvvbcTjqtLtJNRv5yw3L0B4scm9OLAIiyjM3lY+HCZQwNDTE6Ns5lidFoouK4/uCeGWgjHRhcq2lsRC4p8V/XwfT3vr4+tmzZQnFxcUQ0vcOhMs2kUImNjWXp0qUMDg6ya9cuUlJSjsqm2JwVG9XdNr61YQ+iJHP76cWcuzBzRvcPVemFErNNd5tQ0Gq1iKKITqdTRXjhEM5yNlDAPXFikZKSgsVioba2lsHBQUpLS+dcLOfz+fD5fKSkpNDR0UFTUxNxcXH8pVlgd5+HEwoT+d65S+fkgKRU/HOZtqrwSgOnLsrmEBMTw9DQkNoRieQa+h1u6vtGWZxtVt2VwkGn01FWVsbIyAj79u0jLS1NpfVoNQL3nBWZxWCkdKixsTHq6uqQJGmSe1kk6LW7+bTZSkKMnr/u7uWa43LVhRYObeqpqak0NjZynMnLNV+pmHYTDOWwIggCsXHxePWxFBQVEx8bzP0eGHXz8UA7SF5+/mYty9INpCT56XOLc8wszTXTODDGNauz1QVQp9Fw9fF5Qc+tZH8UFhaq4vqJriC+v/zF/x9f/CJCRwf688/HcuONaLOzQ6aLH3wz8DQ2AoTM6YgUCs2vq6sLl8vF1q1b+cIXvnDULejHcGQx102xc845h3POOQfwHyqUqXugRXsoTLVPfefMQp7c7O9UL85LUhsQBoOBFStW0NDQwJ49e6ioqKA4NfKchEgRExPDsmXLaGtro6qqioqKilnnICkI5YwYExNDWloaPp+PgYGBGeXpTMSJxUk8dEEFfQ7/YT0QyvRheHiYPXv2zFmYrMvlCtpPFHpwamoqQ/F3WzAAACAASURBVENDJCYmUlRUFFHB+fGBYe78aw2SLLOjfYSfXRiaTguH9o8LUlLISqjFKwmcUDl7DaWCQMqz8o8oipjNZlwuFz6fj4qKClV/+n7DIL/euI81hYnccWpB0Ps56vbRMjgOAnSOOBkZ95IS75+8rS5I4IpVOezvtnPrKf6iPykpieNWryLrYLPIPWohPipZvV7l3CdJEnJrK/qrr8a7YQPCQU2LVquloKCAzMxM6urq6OjomNLKHQ5P3zeb+yYnJ5OYmEhnZydtbW0qY+VowZydiGt7HP4up1bDlubhGRcb2dnZdHR0qP+7s7OTzMzMkLfJzvYfbGw2W0SCNIPBgNvtVulNE6cVUzlDRWrlp9frWbBggUoPOpwDuiRJtPUO0zk4gkVwqn7eyjh48eLFuN1udlXXs7tXJMUUzZY2GzaXT7WlO1wompHk5GRqamrUzkqknbaJOguPx6P+OEKlqHq9Xurr6+nv75+WIzvm9nHbhv043D5yE6J5/LIFES38FouFFStW0NLSon5G4X6sodyhIqVDKZ2Inp4eqqqqSMzIZVwbS0VGPEbd9O9fSpyB/KRoWoedrMy3BBUagTAajcyfP1+lAU3MAAnk9gZ+BoEOK4JGw70b69jb1UN5uoOHLqwI8q6LM+owR+uxuQTyUvS0tTbT3+sfjRsNBn50fpl626mClmRZZkePh4d3NbA8N4FLsmMnuYIo0H3ta2h27wZBIP+RR9C8+CK+Dz6AWR4kZgJZlikpKflMOJQcw2cPR7IpFhhAG5gPNXGfUqYkE/cp5X4XLMnigiWhOeharZby8nIGBgbYsWPHYYutw0EQBPLz89Uph7I2RfI+KNNWZe8IdEaU9DGQYGFlXhJazaHHys3NVfMyItEChoKSeRQOSphsuCl5JNcU6PZoNBrDpnArtvHbt2+PSHg/PO5BBnyiTH+ErohRUVGcuHKJSjXOycmZMvwukmtSKM+JiYmTmBV2u536+nq16XTPxjrGvSIdVidry1OpzDw0NTdH67lgcTob9/ZxVkUqyQHTJo0g8I2T5016PRqNhvz8fNLT02loaFADcpUmnODzYbz5ZoS2NoSeHvRXXYWcn498/fXqNSs0b8UVKpyVOxxePsdspyIajYbc3FwGBwcZGxtj69atHH/88UdF5sacFRsnFifzjz3d2J1eLl0xMzoKwIoVK2hsbKSlpYWsrCxefvllXnrppaDbrFu3jhdeeIHjjjuOv/zlL5x66qkRL+JKF1qSJNxuN16vF5jeGWomUOhBFouF6urqiMbISrdZ+dE6HA76xkSe2OtDROBLC9O44aTKSY8RGxvLF1Yv57XmKuoGR1kxLwnTNB3+2UDpUikLXygubqjNYWJw1HR8YL1eHzFH1uby4XD7MOg0dI44kYk8hECj0ai2rHV1dZhMJgoKClQP8lDuUDk5OcTFxc04yTozMxNDnIXrXtzBmEdiWX4iD164YNr76rUaHrl4Pv0Od0SOX4mJiSxbtozGxkY2b96sdkj1ej3a6Hg0xlgqK0Nze0fdPvZ02kiI0VPT62Bk3Bvkfx6t1/LolxfQ0DdKZWY8pijdpEDAia5VvTYXf93Ty7zkGM6Zn64enP5SN05UdBRv1Q5wzoJ0Vq1aRUtLi+oKomyovueeQ3/GGTA4iCwIOB9/HP1U7mWyjG79enwPPACHSWNUOk7HCo1jCIXDbYq9V9/P8x+38qUQBYGyT4miqO5THo9H/V3N1T4F/mm82WympqaGwcHBsFq+w4VC21HSrSsqKoIO6Ir5hLJ3jI6OoiRWm81mioqKVKetHpuLS56uwiNKnFGWwk++WK4+jtFoZNGiRWqzbyYBaTOBVqultLRU1VhkZGSQm5sbtE9N1I4EpnAruoRQ7mEjTi/vNwxSmWGiODWW3NxcNQywp6dnyiJqbUUqezvtdFid3HVm5GGAcIhqHJhAPnESFW4qrlxTWlqaarXskyRufWU/W1qquWp1Dred6p8+KBTgrq4utm3bRmqsli67hEYQSIqbfF3fO6eU70Vo2BIIxR1LKRjS0tL8TTi9Ht/FF/OLFz5k47KbueLAh1x+/im4Q7grJiUlsWrVKtrb29myZQtFRUWTjHMOpyE1F5qL4mL/53wkLKePBObsVaaaonjh2pWzfyE6HY899hhr165FFEWuvfZaKisr+f73v8/y5ctZt24d1113HVdccQVFRUUkJiby8ssvR/TYbW1tbNq0iYsuugiz2Uxvby8HDhyYdQdkOkRHR6ui7qqqKiorK4mNjVU5/oHdAJ/PpzpJpKenU1JSwuYDVoSaA0RpBWoGXGG/lAa9nl9fuZrGjl4GO1sY6O8/IpqRic5Yii5E8XkPtznMBpFwZDNMRr66IosPG4e4dHnWjHUKXq8Xt9tNYmIifX19dHR0EBcXR0pKyrTuUDOFzS0jaQzERcvsaRuitbV1Wmcm8PNjsxNC06LCWefGx8eTk5PD0NCQ370mPZ87N9Yz7hnh8pUCly2f3O2MNWg5vSyFTXUDnFScRELM5OtOjjOQHHeos5aWlkZSUhK7a5toat/G0vmHNBiCIPCLfzWzr8uBTuP/rBbnWJAkiTyLjvZRmbgoLSlxRjXnQ3EF6ejooLS0lCitFmFsDOmkk5A2bybq/vuRBweRLr540msTtm1DqK5Gs2ED2pQUpNNOQz711Cnf2+lwTKtxDOFwOE0xt0/kG3/ciVeUqGodZk1REqnxhxoADQ0NvP7662rHPDo6mvr6esrLyw9LvB0OBoOBRYsW0dXVdURF3RqNhqKiIqxWK7t27cJsNqPVanE4HEiSpDoj5ubmTtnUaegfwyvKeEWZT1usk/4eqAUMnHIcicOYxWJR05+3bt1Kenq6SvVSGlVKPlWk2pH1v99N27ATrUZg440rSTMZ1U67IogvKCgI6RZp0Gq49+ySWV+P4tBnt9tVJoPZbFan+6Gm4uGK0+aBcaraR0CA57Z0cOsp84IaUtnZ2aSmpnK3sY4tneOctriYdFNkNvozQd2IwFP1BhYN2zi+bxvz5s3DlpjBHwpPQELgsbK1LIo2kJHht6wXRTHItUqZlGRkZNDQ0KBSq5RC7N+l2QgFpVgJpXf5rOK/PkEc/GFGX//61ykuLuZHP/oRRqNRTfIM5BDONZS8h5aWFvR6PYIgqAd15Z9Qzkpjbh8/eL2eTquLb51ewPK86S1mvV4vdXV1qmB9Lg7LgZZ0yuRC4Qh7PB5VY3GkusDDw8M0NDQcFkc2kA6ldM4C6VDK5lpfX49erw9bgLq8IgadZsaFjSTLPP5+C9vaRrh8ZRZFxlGGhoZUW9lIMJWIO1zya39/P69taeC1FoiNMpBlieaxS8NPVTyiNKXLyER80jzM/77VhIDE1WVaSlJjKC4uxmAwcPffatjdYUOn1fDTL5ZRmRHP8PAw3X0DiOZs8hKjVf5tr82FR5TITYxhYGCAxsZG0lNSmGe3o21uZujFF0nbvh05Px/p+OORbrrJ7zZ1ELqzz0bz0Ueg14PPB2lpeLZs4ZOGhlkluyqproIgzHnY1mHi6NhR/jP4t+5Tb7zxBrfffrvaFLv33nuDmmIul4srrriCXbt2qU2xgoICfKLE6p++i93lI1qv5cNvnxIkzO7v7+fWW29FEAQeeeQRTCYT/f39HDhwYJL15VxjbGzssCzWQ2FiY83j8RATE4Pb7QZQm3CRwukVueGPe2joG+WuM4u4cEl4qrYsy/T09NDW1janU45Quj2dTofT6SQxMdFPL51lYXjczz7C6ZUwaAWev3IJFRnBgbler5eGhga8Xi9lZWURuVBFglCOV5Ik4fP51Om10WjkmY/beG13D19ZnsUVq8KzV8Y9Il96YhsjTi+Lskw8ffnisLdV9nh1+jDD753LK/JWzQCp8QaOKzj0+5BlmdUPfYTLK6LTCNyzQk+S3ovO5uB7+wyM66NJllz8/drFaNNSg8Jq9e++i+BwTGpujYyMUFdXh8VioaioCJfLRVNTE4sXh7++cBgbG6OxsXFW9wW/UcWSJUvQ6/VHpBFxGAi7T30uig3w/6AeeeQRNmzYwBNPPKFailVXV6uC4cOpEAOpRIqft2JRFxcXx9DQEB6Ph8rKyiP65VCKm9kssArHX1lMFRGecjCPj49XD7XK5pSQkBCSKibJMhv39NJhdXLZ8ixS42d3zaIo0tTUxOjo6LQc2enC8sxmc9jOmSzL9Pf309zcrKaEK9+Hl7Z38odtXRSlxPDQBRVhg/MihSIgD5WoPt242hAdx6MfddFpdXLHaYUsyApfKFvH3Nz+p5302D3ceUYBZyyInN4oSjIfNA6hEfziyYlF1s82NfFB4xA+UeLKVdmclmegubnZvzGZk3ltZweJepGyeK/6W1DS5JXu0d5OG/durEGU4fZTCzizIg1JkmhtbaW3t5f5PT3E33EHBllG8PmQCwrw/vnPEEhb8XgwFBWBwwE+H97t25FKS/n000+PFRufHxw1+1RT/yhv1/TyhaIUFoSwEJdlmRdeeIFf/vKXPProo6xYsQKXy0V1dTUmk4nCwsIj1tyRJImWlhaGh4eprKyMWI8AoS3LFU2CunYF/J6GhoZoaGhg3rx5pKenT/HIhweXy0Vtba1qwTqTKUdgvpDdbg/ZqFJ0e8q6NTg4OKUWcCr8q36Ax95v5YTCRO44rSDseWRoaIjGxsZZNeGmy7Qwm82q45XL5aK+vh6NRkNy9jzOe2IHkgwaAT74nzXEGcO/l2MeH21DTopTY8NqDhVIkkRbW5s6iZpYVCtn1FDXec/GWjbVDiAI8KMzcyiKF9VJzL2feLC6ZPQ6DRu/voIMSzRDQ0PsqG7AKphYu6wYS0zAGi+KSCMjRJ9yCsLYGJ6dOxFMJpiwP3d2dtLe3k56ejqjo6MsWjTzVHSHw0FLSwsLFy6c8X0BtmzZwooVK9DpdEfNPvW5KTYUVFVVccMNN3Dddddx1VVXAaiH2UgKgTGPj32dNtKiZHSiM0g8rPxgTSZTSCrR4OAgjY2NR0yUp0AJ6IuOjg4bsKSEHSmbw0T/bpPJNG3nRJZldZGYmHK+vdXKD15vQJJlluSYeSCAXzsbjIyMUF9fT3p6uloYTuUOFa7jPx2U7pHH46G8vJyoqCgueboKjeDv2PzvlyqChGyzhdJ5a21tVb8LSvdPGVcrBV7g5/dB4xAPvd2IViNQkBzLLy+ZP+1zORwO6uvriYuLo7CwMKL35LXdPTyzuQ0EuOnEfM5fEHwgqOlx8P1/1GHQafjROYXEC26sViv9/f34fD4SExNVSpxXY+Dev9fRZ3dz1xmFLM/zp8Bu2NnNsx+3o9MKnFSczN1nHaIBuFwu6urqyL39dtJqaxEkCfR6vH//O/Ly5YdeSH8/hspKpAsuQLNpE75HH8V33nls3bqV4447btrrnIhjxcZRif+6faqhoYFrrrmGtWvXcscdd6DRaGhra2NgYGDGhcBMoXRwc3NzQ+rmlE544N4ReAg3mUwqf38qKKYgkiRRXl5+xESusizT3d2t5hSEmhCFSuFWKF6Bh/CJhV6n1cmj7zWTmxjDzSfm4xwfo7a2NmwTbq4giiIHDhzAbreH1FgoCNQiBjYQDTHxDHj0LClIJT566jNPf38/tQ1NfHeLD48IcVE63vzG6mmLiJnC6XRSX1+v0muNRiNVbSN845V9xBi0PHvFYvKTYoLYCnf8o42GIS86DXx9eQIXLMnEbDZjNBrptbvYVDvA0hxL0J4tSZJqcV5UVKQ6mOnvvBPdU09Rn5iNJGgoH2zDd/HFiM8/P+m77PV6qa6uxmq1smzZshkXl3a7nfb2dubPn37/DoVPP/2U1atXo9Fojpp96nNXbIDf6/mb3/wmdrudX/3qVyQkJKidlomFwEQB9wMfDNA9JhFv1PLgOblkJCfMSDzs8Xiora1Fr9dTWlp6RER5yuvu6uqis7NTteINdFYKDDsymUxT+ndPh1BTjj2dNu79ex0+UeL4wsSIk7nDQZIk7HY7zc3N2O12DAYDer0+ZJdpLhBI4Xq9xcc/9/eTbjLy6CXziZ2iozPdNQSOq0dHR/HKWlweL+ZoXfj8iQC0DI7zP6/uxyvKrFuYFpTBMRUCaQXmtBzqbBpK0+LDFk7PftLOhh1dgMDlK7O4/ODYPHDkPmy1Mj4+TvTBAq/bbaB7DFbnxTHU2YLRaKS4uJgPm2384t0DGLQaCpNj+flFFUiSxMCol/ter8fplfjBeWWkm6LY1TFCSWoc6QeF8YNf/CIx/f3Etbejczj87iHZ2fheegksFpBl2LcPwymn4H33XeSKCnwaDTt27GDVqlURfzYKlGJDo9F81hw+jhUb4fFfuU95PB6++93vUlVVxVNPPaXmb9TW1oYtBOYKPp9Pbbrk5eWpB3G73Q74hd+CMZY/7nMQH23k1lMLiJ7lxLevr4/m5maKi4tnbV0bCVwul9qEy8vLC9rXJ07xTSZTRFOQa17cxa4Om7/pcn4ZZ1X4KTnt7e309PTMiW38VLDb7dTV1ZGcnExubq5qLx9IGVb2R2WP9PgkvvTkNobGvGRbovjz9cunpQf7fD627WtgZ4eN81eVkZc2PbV7OoiSzIGBMbISoog1HHqvFepgdnY2D31i5aOmYWRZ5qLyeM7OlVV9otlsZtBr4BcfdJJlieK+c0tnxDoYcYxRW99IjF7wu1ZpNPzr8tv5TvG5APyweiNn/v5hhIOaG8UBTr3/yAgtLS14vV7i4uIoKiqK+OA/MjJCd3d3UD7PTHA0NsWODhn7HCMuLo5nn32WV155hbPPPpuHH36YNWvWsHTpUvbt20dHRwexsbE4HI4gAXdqWhojkh1LvAaPTyI2IRWTaWYBPwaDgYULF9Ld3X1ERHmBIvTx8XEEQWDXrl1ERUWRlZVFVlYWcXFxc1rkxMbGsnz5ctra2ti+fTsVFRUszDLx7TMK6bG5I0quDnUNoehQKSkpZGRk0N7ePiW/WJZlhsb8h/jZdGAUm8Pm5maWRlk566ISMpPNEesaJl6DzWYL6pTl5+fT6xS4+2+1eEUdNx2XRm1trRrYGK54nZccw2OXLmR4zDOjCYvijpWSksK1z2+jw+bFFBPFU5cvDinOu2RpJjanF9Hn47gMDXV1dUEjd4vFQklxsTrB67a5+PlLe3H7RD5oiuXxy5aorlVxplRi9FrcPonjChIQBAG7WyQhRsdvL1uguj/d8vJeWgbHiDXoePbKJZii9TTcdRfHOxwI112HJzYWfVsbFBSA2Qw+H/q1axFaWsDjQX/hhcg5OXhff/2Ym9QxHPUwGAw8+OCDbNq0iQsuuIDvfe97nHvuuSxfvpz6+nqGhoYoKyubs6J4ooHJ+Pg4TqeT3bt3k5aWRmZmZpBr1Q9fr+eNmiEEARJjDVx/Qt40zxAaaWlpak5Vf3//nIu6AxskOp2OgYEBenp6SElJIS0tjaysrFnrH2KNOvWgHnswSE8QBPLy8khJSaG2tlY9iM7lnqt8Vk6nE7PZTFdXFy0tLSQkJJCSkjKl2H5ozEOf3Y0MNA+O4/SI0zbQdDodxy+pYH6hv7jxOvzWtodzTd96tZpPmoeJj9Lxt6+vJD5KhyiKGAwG0tPTaW9vJ0NyoUGDViuwpjiFxeWZQd/3bODFeTM7XwC0Do1z+XO7cHpFvnViFs6DrlXb4rNx6/yPv9WSx1kmk5pno3v9dTT19Uh33QX4PwNFwN/T08P27dvJzc2NiNp2OOLyoxWfy2ID/AvCaaedhtPpZP369ZhMJrxeL08//TSCIDA4OEhFRQUJCcEV/K2nzONPVd18oSiRLMvsFihBEMjKylITtBVP6tkckJQxqbJBBFKJlBRxnU6n0p0SExOPyDRF8VVPTk6mtraWxMRETiiM7JoiDcsLRFpamhoaFYoj+5sPW3ljfz+5CdH84pLKWXXdtFotxcXFOBwOamtrEUeTwn5O4UTcFouF5ORkCgsLJ22gbzd1M+YW0esEqro93LN2hepgNpWAPMsSNem7J8kyPTY3yXH6KbM89Ho96KOJNgqMO13UN7WQsqhEDb602+2MjIxgs9lYHeO/Bo1oICUlhY+HotjRbufyVelUZAZTETw+CUmW0WoExj2imvKbnJxMc3MzN1dIpOXkU5GbyotbOnhlRzcZZiOPXFxJrMF/IGgfHseg1TDuFRkZ91tTy7IMa9aglSS0Hg94PHi3bUO65Ra0V1yB+PWvo7vhBtBoYGgI8f77kQ6aMRzDMRztEASBM888k3fffZdrr72Wd999lwceeIDKykp6e3tVq9LZdM89Hk8QbUhZd3cNa3myaoSC5BieueI4dLJITU0Nvb29xMcfanDEGLQIgv81RodJrI4UinWtkk1UWlo6ae+NBBOZCIGTmMAUbkXLMTw8fFji8Z+sK+Plqi5yEqI5oTB4TVTCcTs7OyPOywiHUPuLWzCQmmgm7eAe6fV6qa2tZWxsjIyMjLB7b7rJyDmVabxV28/FSzJnNKlX7GuVayouLp70/vkkCV0E+/7HB4YRJQmH08v7O2tJ0zmD9COLFi1i4UKZJbvrMMXGsHJCoTEdZFnmV++1sLXVyjdPnhckIP+oaRinV0SU4f8a7bxw5Ura29s5rjCafxmNCBotV+QVAiB4PAjV1ejvvhtNXx+uU09FKCpSCwalkZeamqq6k033m/w85jh9LmlU4D/gnnfeeSxZsoQlS5awZcsWqqqqePrpp8nNzcXhcFBTU0NmZuacpIWGgyIsGxoampaLG4orq9PpJukswr3W0dFRampqSElJIT8//4hek8IvLi8vD9qgInGHmgkdanR0VOXIBnZavvTENqL0GkbdIr+4qJKStMNLsFV4noGhURNF3MpnYLFYIrqGTquTO1+rwekV+cG5pSzO8RcXY2NjQR2xSLp8D73dyIeNw2Raonj0y/OnLK7q+0b5885uKlKMFBvtDA0NodfrJ9HSAnnXLYPj3LphHzqtgEYQePWGFZMe983qfnZ32rhoSSZJsXr+VNVFSpyBi5Zk4nKOU19fj9Fo5P5PnUiA0yPy43VlLMo2I8syHzUN8nJVD8cXJrKn00ZNzygVJg+/uGAJ2h/+EO0//gEDA34hn0ZD0/PPk71kCTELF4LHA0Yjnl27cGZkUFtby9KlS6d93wIhy7IqLD9Gozp64PKK8uGaNhwNkCSJX//61/z+97/niSeeoKKiAqfTGdSwCrfmhNLo6fV6dc0K3DvO+vUW+hxuDFqBH68r54zyFFUY293drerznF6Rl7Z3EqXTcunyzIgOmJHA6XRSU1NDfHw8hYWFUzbHAhOrp9K8jbl9GPWaoNc4kWo8m+JmJtdUW1ur6iinWtOnMwkxm838vWaYn7/TjFGn4Y/XLCU/KUa9r6JPOdLaUEVXp9jmGgwGnviolSc+bKU8PZ7nrlwcRGsSRTFo0v/KfjtvtIqUp0bxywuKSU6whHxfAinASmif8j0fcXpp6h9jQdbkwNw9nTZu+OMe3D4Jc7SeD/5njfo3/2RjJ06vyH3nlqqp8S6Xi4aGBjXcNTo6Gv1998Ejv+TFxecwZojmuh0bMX5hDT3PPYfVaqW0NJgiPjo6Sl1dHUajkZKSkpA64IGBAUZGRtSsjJniaKRRfW6LjVB4//33ufXWW7nzzju58MILkSSJxsZGXC4XFRUVR/RDVbi4OTk5akjUxLC/wKpfcbmK9FD+2u5u3q0b5ILF6czTO2blODJTOBwOqqur/YI0gwGHwxGxO9RMEIoj+9yn7fx5ZzelaXH875fKI0ruDofAJO7h4WFGR0cxGo2kZ2SwsclDdZ+La4/PYU3hzDtkoiQjyfIkqlfgplFYWEhq6tSj4nW/3UqMQcuoW+TRS+ZTmBJsKamEiwVOjxR6oAs9j7zXCjJ8d90CcpIni91Gxr1c/8c9OL0iJamx/OLiqYVtP3mzgY8ah9BoBO46s5iTipNUx69nPmjggx6BgpR4zqhIZVNNP+fOT+O8BWn+Q43VyU2v7McSpad72M4TV64gyxJN4jdvQvvSSyBJoNPhzclBHh5G73Ih+HxgMCAXFWF77z0aZmFJKIoi27dvV4V3x4qNowMrf/KO/Ndb1pBlmRml9WjFrl27WL9+PVdccQXr168HoKWlBavVqpqcKIfV2Wj0fvh6PW/s70OrEdiwfnlQ3o/i4DiTRPDZQEnQ7unpUYub6cJjJzpeKXjuk3Z+/UELybEGXlm/jISY4Nsoxc2RoDtNvCbl0ByoT5lYMHm9XrVgMplMITMtLvtdFXV9Y+gEgf93RuGkDCW32019fb1qhX8kzy6KxiI3N5eL/9iMW5TQawV+/sViCuNl9bomFkxqsneE3yGv10tjYyNOp5OysjJknZHzf7uNcY9IaVosL14V3FzqtDq56OkqREmmIDmGDeuXB/3d5RXxiBKmqOB1fm+XnYbOAdLFfrIy0snLyeHVr/+Ah9KPQxI0XNLyKV+573IG7Hby9u4lbdkyhAmNLWWva2pqIisra1K2Vl9fHw6Hg6Kioojf50AcjdrCY8XGBAwNDXHDDTdgMpl48MEHiYuLY2BggKampiPqde5yubBarbS2tuJ2uzEajVO6Es0EA6NurnlxNwatgFeUefXrK3CO+qlBh5NhMRHh6FCSJKkF25HsHo2PjwdNBNwiROlnlo0RSsRtMBiCRHZ6vZ6enh4272/huTqIMuoxaDW8MmExmy36HW6qux0szDYRr/c70/h8vim91X+/tYM/VXWxJNvMfeeW4HE5Q05eQk2Pnv+0nZerupAkiZUpEtevyQ2pG+m2uWgeGGNJjpm2YSc/ebORpFg9PzyvdNIG/vA7B3i7th+dRuDbZxZh0GqYlxxDuikKURTZX9/EsNXKz3ZKRBv1uH0SL127FFOUHo9P5O6/1VLb4wCfG50xGlO0nmf2vUzC++8gtLaC2+13p7r0UnQvv+y3xuyQEQAAIABJREFUxo2JwffaaziWL+fAgQMztiT0er3s2rWLlStXHlWL+Ocd8+97S/7hukouWpb9n34p/zaMj49z++2309vby2233UZNTQ3Lli1jaGgIg8FAQkKCerCbqUZPkmWqux2km42kxE3uykqSRHNzMzabjYqKikmhq3MBJYV7YGCAjo4OBEEgKioqaIofaXjsmb/+lAGHB4NOw/3nl3Jm+eTGjTK56erqOqJTDlEUGRoa4sCBA/h8PrRarWoRPFXBNBEb9/bwo9cbiDPqeOnapWELbeXskpeXN2NDgaExDx81DbE426xOTsJBcZL61bYR9gzKROvgwVMsZKUkYLFYZnx+ESWZV3d1M+YRuWx5VtCk3mazUV9fj02I495/DeKTZJBhx3dOnHR91d0OqnscnFGeHLRHybKMT5rc5NvZPsKNf9oLwNryFK6q8O/1Bx79C4+VrUUSNKxr/JjrH74Rk8lEam4ussmEq60tKBBQvQ5RpKWlhYGBgaA4gp6eHpxOJwUFBRG/J4E4Vmz8l0CSJJ5++mmefPJJHn/8cRYtWjSnXudTeZKbzWa8Xi+tra3TunMMjLr5/j/qGXX7+O7ZJZSGoQqNe0Su+8Nu7E4vGeYonvraIjSCoGZYjI2NUVFRMSOR3EzpUIruITk5WRV1DzjctFudLMg0YdDNzQg+cDQ+HUdWEdmNjIyon0U4z/FQ6B0ZY/2LO3D5ZFbMS+anF1Qe9ut3+0SufXE3NqePpDg9v7tiMTqNRvVWz8zMJCcnJ+g1KbqdYesIow67v1iNjqHOrsccH8vahdnopljo/1U/wC/ebQbgpi/kURYzxuDgIKWlpWF5p9/7ex27O214JZlbT57HOfODk+vH3D7+ub+P5FgDm2r72d89SrRBy5NfXUhirH/Rt9kdXPviLuxeiDIakCWJLJOO6+Yb8brGEDUGHt7hRm8wMDTqpSQtlus+3sBJz/8y7LWMl5Vhe+cdunt6WLAgfIhhKLjdbvbt28fy5cvRarVHJHn4MHCs2AiDVQ+8I//15jVkfg4mG26fSI91nN/96mdUVW2ntrYWnU7HmjVruO+++zCZTDQ1NaHT6Y6o2yGA1Wqlrq5OTVmeLSYK0202W1AKd3y8PxR0eHiYioqKGQUBAvzmwxZ+93E7pig9G65fFrKAUjCXUw7FTjdQU1k7JJJiiWVxXjI+n4+uri4KCwtJS0ub/gEnYNwjotcK0xqg+Hw+mpqaGB8fp6ysLCI2gyzLnPebrQyMetBpBN64ZTWWGL36t8C9X7H+N5vNaHU69rb0UpKdQllRwazfvz/v7OKhtw8gyTIXL83kO2uD6UaSJNHW3sGP3m6lxipwwwl5XLcmMoMCt0/kmhd3U9PjYP2aXL5xcoH6mC9vbeXh99vxijJ58QI/OCGeuLg4fP96n5c089Anp/I/Ygspjz3C2P5anlx5ISbXGNfs/AfChRfgff75kEXH+Ph40KTJarXi8XjIz8+f1ftzrNj4L0N1dTXXXnstF110ETfffDOCIMzY61zplCuLzcRDeThP8kiyMl7b1c2Tm9vQazWsnpfAd88umXQbBf0ON7U9DhblmLFEB385h4eHqa+vn8SHVHA4YXkT3wsl+Cgjv5hv/f0A4x6R5XkWfnDu4VnjToQiAFR4kzqdTqUSKSJol8tFdHR0UC7HTA+YfXY3e5q7MY72UDQvj8zMzMOaEtmcXi5/bif6g1OoDdcvV7s6oijS3NzM4OAgKSkpuN3uoIU+sMh7uaqTF7Z0IgC3nVrA2orwNCxZltnf7UCSZRZmmfjdJ+38c28vS5JELplvCWnp99fd3Tz7SQdajcBtpxSwq9PGwqx4Ti+b/DyXPlOFR5Tw+mTWLUqjNDWOlblx2G022vuG2dU6xD8OePCiwYuWM8qSuWxFLvnJsbxZ3c+Tm1vpsblIiTPgGBnle+88xTlb30AzcXnSarFfeinbrr4ag8HAqlWrZvRZKLzqpUuXHis2jiK4faJ8ODTJowVOj8i6xzbTPeKkxCTy+FeXkJmZSXt7O1dddRUrVqzgnnvuQa/X093dTUdHBxUVFbMKmIsUPp+Purq6GWVlBE7A7Xa7aqYRGAAY6nHsdnuQY99MftsDDjfxUbqIrFEDpxwzEd+Hy7RQ1uWX9lh5cWsnMvDLS+ZzfEEiHo+H+vp6ZFmmtLT0iAb+KllVSojxVPu1JMus+N8PkWTQaQSevKgAk+BSA/MC9/74g9aw6n0lSaXATWz47em04fRKrMq3TPn5vbClnV+914Ikw9mVqWFzugI1FqWlpWrDdE+njR3tNtZWpE4yU9nVYePGP+3FK4poBYE/XpihFriG6Die3OOkf1zi/nXlzM80HdQTDjNit5Pi6SU9PZ151dX85NkPeK3yVDSSxN2bX+TCX95N1E034bv6auSD58WJGBwcpKGhgaioKBITE2dVbByt2sL/WLEhSTI7263ER+kpTT/8kLQjBZfLxbe//W0aGhr47W9/S1paWliv81DBQLIsB/0wQwUDhUPgohdq06judnDP32uRZJmbT8zn7MqZd0cUKGF2Pp+P4uLioJTRuQjLC4TD4eDNrft5plok1mjAqNfyp+uWzfrxQkHpvrS3t9Pf349er8doNBIdG8/LdS46HSK3nlLA0ty5GZcr3aOxsTHKy8uRdQai9doZUbgUvL6/jzer+1m3MI2TCi1BG5jX61U52WazOSwf94kPW/nb3l6Q4drjc/jysqwQzzQZNqeXrzy7k3ijFofbx6/Oy2Ggu53c3NygQkqWZVqGxok16PjO32rodbjRagR+/eUFk0bum5sGefbjNlxuD912NwLwtYooTi7xh/6ZzWae39LFn3d0MDDmIzFGT1yUnp9d6Bf2j3tErn5xFx3DTlxekfhxOxftfJNvbf4DekkMei7plFPo/f3vaWhoQBAEysrKIqZEjI2N0djYyOLFi48VG0cXPhdNsepuG5c9tQVRlBBlqLv/LPX36PP5eOCBB3jrrbd46qmnmDdv3r9NXwGHsjImUo2na7bN1BBECbNzOBxHjMKlQKHlhhKqh7quQLMW5boCceNLe/i0xYpWELj1lHlcfVyu+jeF7hSu4Tdb1PWOEh+lVWlWSkq8Yps88UwRSCN+Y38fr9WNsTJDz1XLU9W1OlL9R2BIX0lJCR8csHHv32sRELjxxDyuCbj+Sff1ivzqvWbsTh/fOr1QnYaHgzL5z8jIwGBO5UtP+htcyXEGNt16XNB19QxaufOdYcZ8sDI7hvvPKcRsNvsbkiGoVX/e0c3P3mkC4JYT8zkpQ6K3t5e3Ht7IxrIT0cgy396+gcu+UEznky+QIIjE3bQe8eab0SQkTPosJUli9+7d2O12KioqptVjTsTRqi38jxUbL37ayguftKLVCPz0woUsyztyXP7DhSzL/POf/+See+7hxz/+Maeffjqi6LcDdLvdmEwmRkdH8Xg8aidDcfiYiwOLsmmEcpHqs7txesVpOZXhMJEONTIygtvtJikpifT09DkPy1Pg9Yn8eONu9veMcuPJhZwx//D41qFcSZQiLzo6mq6uLn+wYVQaP327Ga1GIMNk5ImvzozXPx1GRkb4zdv7eb8bitLi+flF84mJ0BYyFDVNp9Ph0sbydquXojQTlx+Xh0YQphWQ25xenvm4HYNWw3VrcmnsH2Vr6winlSZPEo8HQpRkbt2wj/ZhJzkJ0ZwzP5X6XgcrEj3EyM6QabU3/WkvLYPjCAIUJMeQHm/gisVmvOP+a/H5fMTHx7Oh3sOnHU7GvRJajcDyPAsPfLEMo06LLMs0Doxx+4Z92Mfd2N0y6SYjN59cwBcXptFtc/HA/zWyq9OGw+XD4HJyQusufv2Pn2EUveprkcvK6H33XQYGBsjJyVHdUgK7XuHgcDhoaWlh4cKFx4qNowufi2LD45P46jNb2Ntp4ysrcvjhFyebNGzevJlbbrmF2267jUsvvRRZlmlqamJ0dFQVjx8pOJ1O9u/fj06nIzo6OiiFO1A/Utc3Rq/dzReKEmedQm21Wqmvrz/i4YaK+UhXVxfp6enqVCYwWC7SJmJ1t4Nv/7WGhBg9v/ry/EkHaEUA7Xa7KS8vn3X2h4LnP23nNx+2IgBPfnWR6nYIh1wc4+LisFgs6kF84nXNxIQmFBShdHNzM+8NxvLnfVZkWeaM8hR+duHMaccj416+/886XF6JH51fGpQRJYoira2t7G/r5/6tHrySjEEDj58WMykNXmuMpt/hITcxGo0g0Gd387XndmId93L/+aVBtOCHNjXxp+1dyLLMBYszuO/cUsadTlynnskv164n3eviG4/dzRMrL+SZlRegF0Ve/cP/I9dswHf55Ujf+c4kalVrayuAaghQVlYWMT3waNUW/seKje9v3M/mxkFEWeZ/zijhi4sj67z+pzA6Ospbb73Fd77zHWJiYnA4HDz++ONqoVFaWnpEbeYUUd7IyAiVlZWz6uhESofy+XwqF1hJHz9SUCyGle5bJFMfJU1cuY6xsbFJIu5Q3Ze+vj62VjfxTK2ALGg5rSyZ208tnPNruvSZKlxuN2MuLz8+v5TVJaH5zIEFknIoVxb/wA3szteqqe72i7zvO7eElfmHCnNlDC9JUtgDtXXcwzUv7sbtkzBF6fjTdcumnLg4vSKtQ+O4fSLf/Xs9oiRTmBzLT8/Np66uTvWr1+l0/u9l7zBv7+9he7udVqsHWRA4pSCOLy/NpDAzWf0shsc8vLi1g417ekmM0dNlc7MgK54fnFumjrq3t1r56VuNdI84GfNIROkELluRzR2nFWJzern7b7Vsa7Xi8YiAzIKeJja8dBdGyQeAbLHQvW8fVquVkhI/rXBgYEDtek31HbPZbHR0dDB//vxjxcbRhc9FsQEH13CvNGWuhdVq5cYbb0Sv1/Pwww8THx/P0NAQDQ0Nc2qHGpjTodCGoqOj1Ql/ZWXlJArSnk4b1/9xDwJwVmUqPzyvbNbPr6Sce71eysvL58xxKVSmhV6vVwP0SkpKDrsQmApKlz47O5usrKxZH/av+/1udrSPIAgCt50yjytWZgWZn4yNjSHLMl6vVw2ji/TgOjjq4Webmog1aPl/ZxRN21DzJ5DX8+DmIQSdkV9cMp+C5JlpbwB+/V4zz37agSzLnL8gnfvXlQU16RT95TttHvZbNVyzKovTF+ZiMBj4qGmIrhEX5y9MC0osB9iwo5uHNjUhSjLFqbFBzlUDDjff2ViL+P/ZO88wqcrz/3+m7mybne2drWyjCkjH3qIYxUTRxIaKqFhihZi/UUmCQRNLjLH8LLHFWFJsWEBElCoibXvvfafu9Dnn/2I9h5ntVcHwvS5fuLPsnDPleZ77vr9FgPUX5FHZ3s0d/yokXKfmiZ9mYGutJSEsjDue2UO1IRGN6OP+Q++SXbSXcMFD8gP3wNSpKObMOWIlX12NTqcjMTFR1j5FR0fL++pgOFa1haoHHnhgsH846INjQXpMKCXNVnLiw7hyQfqYrEknGqIocsEFF2Cz2bj00kvR6/W0trZy2WWXMWXKFGJjY2VLtsjISAQR/rSpgie3VqPXqQftJA8XCoWCqKgoQkJCKCwsRKlUDtl18Hg8mEwmWlpaqKmpoaamBpPJhEqlIioqirS0NNLS0oiLiyMiIoKgoCAUCgUqlYr4+Hh8Ph/FxcWEhIRM2Lg6KCiIpKQkjEYjVVVVGAyGgE1DFEUcDgcdHR00NjZSVVVFY2OjPEVKTEwkMzOTpKQkoqKiCA0NHVCUFhYWRkZyAikqM9l6kUsXZKPVjP8X1ebycrjZTrIhmOmhZlz2brkobWtro7a2lqqqKjo7O1EqlRgMBiZNmiS/F3q9Xn4vAPbUmKjtsqNWKjhvajyx4Ue6k9J7pdFoKCoqQhAE9Hp9wOfC4fbx34MtCKKIVq1kYVYU9V1OYsK0/X5+NColsWFB2Fw+PilqwyeIiMBX1Rbi4+KIUvXoYZqbm2lsbEQleJieYsCt0lFp9GBxCbTYRXbUdbMoO0bWCAVrVczPiMLm8rG3zozd7aPd6uKT4nZmTzIQGx5EsiGYeRmRbKvowuz04vGKHKi3UNRk5MKZSZyRF8fhRit1Jici0Boezb+nnMovvv0IjSigcDqx3H47brdbpnOEhoaSnJyMyWSipKQEnU7XbxfJ6XRis9mIjY1FpVIdbaFLD/7QF3AU44Ef+gK+LygUQwuCg4OD+dnPfobJZOLWW29l5syZsgi5srISs9lMZGTkiD7fUk5HW1sbdXV1ssOOZKihj0ngv1UCHUIo55yYS0x0dE8Qqs9HRESEvM7srjaxrbwTt68nEO3ns5JG/VoolUr5u1pYWCg7OI4EEt1Wcr3adqCCx7bW0mm1My0lkuTkZDIyMmT7UrfbTXl5OeHh4RNWcISEhJCQkEBLSwt1dXVERkaOuHstiiLRwUq+qOgiUqfkzHg7xrZmOYckMTGRjIwMJk2aREJCAg0NDZhMJiIjI4cl6v79R2V8UtROWZuNEK2KE1L7D6CVoFQqSU2M49w8AwXaToKVAgZDj27D6fHxwo46vqkzMS05fNC8lgaTg53VRpQKmBqlIKS7R5sk6X4SEhLIysri5GnpnJwWjLOzsWdv7PRyxzuFbK/sorLDzjm9NIzBWiXvHmgB4BdzkslLCOMvn1fxVUUXi7Ki+PmsJC6ckUC4Ts0DH5bRYHTg9AhMitVzygk5dNkd5Dz2MFsmzyPB1kl8Sx33n3kDb049gxOfe5T0x/+I66KL0Pz5zwhnnEFXVxdarZawsDCCg4NJSUnBbrdTVFSEVqsd1JjG6/X26F6/C248Vvap4wLxUWL37t3ccMMNrFq1issvvxw44nWujU3n3g8r0amVoIB3VvYNQBsLvF4vpaWl+Hw+WZQ31rC8dquLklYb05P1RPgJyJ1OJ0VFRYSGhk6oBzn0jBSLiorQ6/Vog4Kw+HXLxiLi7g+9ObIATq+ATt3XSWI0aO6yIji7sVnNtLW1UdrpJlKvZ35u0pAuV71hc3n5vKyDRL2OGSl6nvuqluoOO6uWpDE57gilSbLZ6+rq6sPH3VdnYneNkfyEcJ74vAqPT2TZzASuXTiwg4coinxR3MT+2k7eKzKiVYg4BbjhxCgWZkVj7OxAEATy8vIIDg7GJ4jsrTXxh4/K8InQaHIQFx7EnWdkcnZBfMDf/aiwjT9tqqCj24P4XRH0u/Pz5PF1Z3fPNKayvVtehLINKt68fi4qtZZfvPgNRc1W+W8Gu+wcfmI5SqC2uhq73U5WVt+plRREJV23v8lDV1cXra2t5Ofno1arJ/SzPgocn2wMjOP71AAoKSlhxYoVLF26lFtvvRWlUimH802ZMqUPJRICXZT6y3jqb/1a+98iPilqR6VUsOasbC6elYQgCDKFS3I7tLt93P3vQhqMTtadn8uMlMEPqcOF2+2mpKQEpVJJbm7ugIfz/qbJ/hbzl7xSRIvFRZBayd+vPIGCxL56Uil0NSIiYszOlL3h8Ql8XtZBfHgQM1Ii5AZJfy6E/uhvGjOSfVMURVpbW6muriYzM5O4uLhB96dHNlXw5t5GFIqe93skRaMUkNvS0kJOTg6vHTDx8q56FMC1iyZx40kZAb/b2/nqYJcCrS6En0xNICrSQL3Zw0OflJMaGcyvz54c4Gzp9XqprKxkU2kXLxe5cftEpiXpeW3FLDw+ARHQfle8mx0ebC4vyYZgnt5Ww/PbaxGBS2cnc89ZR/Iw3tjbyKOfVaJSKLjttEwe+6wSpULB04ZGFHNyCCku5vFNTexInY4CkQV1B7FrdNy8801OqtmP46OPqA4OJiwjo48LmdvtpqysTM4S8Q9ElmC32ykrKzvmtIXHi40xwGq1snr1ahwOB0888QQGgwGTycQ3h4p5pkiB09fDS79/nJ2WJDqUFGSn1WpRKpV9uLHDXQTtbh/XvbYfi9NLgj5Itsb1fz5pg8rLyyMiYnw2iP4s9JRKJaWdHl4t9pAYGcqfL55OzCBWhWOBxJF1Op1sbg/l83Ij8zIi+e25OSMSdkvJ7iaTSQ6b8hfUf1Xv5Lmv6nC53Vw9PZxLTpo66pH/7mojv9tYBt/pI/5ySV97VynBVBI2+i9GX5R18PCmSlRKSNDrWDYzgRPTIokJ08puKtJ9SLqX0HA9933WRofdS4fNTUJ4ECemG7j3nBy6rWbKyspkPZFSqeTLik4e+qScDqsbt09Ao1Jy+dwUbjk1I+B1/aSojXUflmJyeBEBlQJuOimNG0/usSI0Ozxc9OzXNFtc8r+J0sIbv8wmIjaB09Z9gj3oSLEwubWKT1++jfLvaGUZGUc2rd6QaCUxMTFkZvZYNHZ0dNDZ2SlTB48XG8cMju9Tg8DlcnHvvfdy8OBBnn32WRISErDZbBQWFpKUlERsbGyAFbvU/fZ3TBzqu/Cbd4v5qLANlVLB2rOz+dkJRw6fktthZmbmqCxeR4KWlhaqq6vJycmRtQgStWY4dNvzn95NfZcDrVrJa1fPImcAO3lJy9HS0jKue+LvNpby/qFWAJ5aPo0T0yNlF0Kz2Ux+fj4hISFyMWgymfokjBsMhiF1lqIosqmknVaLi4tmJhIa1LNHSEYxko5goOmNy+vjX982E6JV8dPpCaMyQnE4HJSUlPB2mZuPq5wogMtPTOLyGQZ5D5KoxdJ99aeNufLv+zjQaCFIreT//SRHTgP3h9Fk5oF3D9HhUnL/T6fiERRc9/p+BEHkqUunMyctkO73/PZantlWi4jIpbOTsXt8dNk9rD0rm8QIHXVdDkK0Kv60uYKPCtsAODUnmmRDMCdN0hGx9Kfc8tN70HnctIRF41Wp0Pq83LjrbS4s2kqitYO2lpaAqZ8/zGYzJSUl6PV6srOzA4pnm81GVVXVMact/MFoVD8GBAUFceGFF+LxeLjpppuYOnUq2dnZpCYlkKo0kh+t5qqTcgfNOBgOBqJDSeNWu90uc0kNBoNMwRFEkW3lnVS0d5MaGYxK2f/nwOTw8NY3TWjVSiwOLxfPTgr4XSkQLjIykpKSEpxOpzwCHQlcLhddXV00NTVRXV1NfX29nAIbFxdHZmYmKSkp/OOwDaPDS7vFQbjCxfS02AkRAKpUKmJjYxEUah7eXEWETkmt0cXZ+XHy4tsbUqHnT+tqamqSU1+TkpLIyMggMTGRyMhIQkJC2FTSSVlbN0qlioy4MMSOajQazYimGxLcPoFPS9rxCTAlMQyXV6Cm0yEL3QC0Wi2JiYmy/a8/bSguPIiKdht2j48Ws4MdFZ18UdxIsqeRtrY2RFEkIiKCSZMmkZ6eTnx8PJEGA6fkxqJSKKjtcmB1eSlstrKr2sjpU5KYnDEJi8VCaWkpISEh5CVHsygrii1lHVicXryCwLf1FgqbLZxTECdfZ3ZsKJPjQtlc2hPMJAJ7as20mB2clhuLTqPi7IJY3vi6Ed93x0mHD76sNjNN28E1rz/O66nz5demK9TArTveoHT58h5XEm0PTay/1zgkJITk5GS6u7vl0bUoirjdbqKjo4+p8fRxHN+nBoNareass84iNjaWFStWYLVa+fzzzzEYDHR3d9PQ0IBarSYyMpLU1FT5e28wGAgODh7W92BueiQ+QWTJ5GgumZ0UcPgMDg4mISGBmpoa2tvbiYqKGvfvljSNcTqdsuNSfX09giAE0IaGotsuyY5GrVRw+dwUTkwf2LRGoVBgMBjkPdHhcIxqT+yNF7bX0Wh2olIomJqkpyAxHJ/Ph0KhkPV50r6p1WqJjY0lIyOD1NRUYmJiCA8PR6PRDHkd28o7+fW7xeysMlLb5ZCDDlUqFXFxcTItVxTFPrRcALVSybRkPXkJ4QGP7ao2cuXL3/JpcTtn5MUMajWsUqkICwsjXuPAaO4mPRzOShFQKcCjDmVTo4Lw6AQWTc0MoHn3xs4qI3VGBwoFXHRCIrFhWvbUmAjSKOV9PFin45wZqcxLUNJSW8G7pTYOtdjxCiJur8DCrEjsbp98vVOT9Gg1Ck5IjUAfrObV3Q1Ud9ppMDmYHBdGkiEIvU5DiEbF5pJ21EoFNZ0O9jdY+KzCzOzp6Zx/ZhZL//t/vJs0C0GpxKnR8XVKAV9kzuby/R/B/fcjCAJAn31Kp9ORnJwsRyCoVCrCw3teaymTJi4u7pjap45PNsYJlZWVXH311Zx66qncddddqFQqmpubqaurG5HX+WjoUKIoyr7WBQUF8ujtk6I2nthShQhcMS+FX5w4sOPTO/ua+Ky0g4tmJnBmPwmr/tcnZY0UFBT0O4aHI93+kYq4Ad4/1MJzX9aiVSu5ZXYoYaKd/Pz8EfNxhwtRFHnggxJ2VLSTGq7giUtnER4WKt+H/9h9pONp6HEMe2RzBVqVkrvOyKLL5mTbwQqy9SInTh+5fWN5m40ms4tGk4NXdzcAcNPJ6Zw/rW9Hx+VyyZbGUmFqNptpMjl5Yr8XpUpJp91HaqSO3/wkhzmDuMJ5fAKPb6ni7W+aCFIrsLh8xIRpeWTZFGZNipCtDlUqFTk5OVjcIite2U91p0NeSBL0Wt694UTCdUfe+y/K27npjcMBi83yWQncv7THW72oyczPn98XcC3v/Dye1tZWXnjtAPsmTQcgyGln380noEhORhRFRFGUF/H+gpb8X6Py8nLMZjNRUVHHaVTHHka1T9V0dNPZ7WbWpLEfEo92rFu3jvfff1/WwOXl5fHAAw+QmZlJR0cHFRUVfWxrJwLNzc3U1taOOaW7P3G6f6ZFeHg4LS0tNDQ0kJ+fP26Th/4giiK1tbUyBXMsuSZFTRZ+814xMcEKbpgZgsdhC8hRCg8Pp7m5mc7OTvLz8/ul2QwH7x1s4Xcby/D4BOakGXj+8pl9fsd/otKfC2F/WP78XkpbbWhUyj4TLrfbHbCXSpNzaWLR2toqBw9e/1YJhU02gtQKnr5sOrMmDZx14vD4eP9gK0kRQSzOjubaV/dT2GxFrVJHs+bvAAAgAElEQVTw3g1z+7h+ud1u/rujkA07TCiVSm49NZO/bavB4xP5/fm5nNMrQmDj4VYe+LAUQRAJ16mxuXwkReh4e+UctGolVqeHujYjV71ehNsr4hUhWAXJEVo+ePEWykxePshbwuszf4JHpSHaYeKzMyLgnHPkfQqQC4fea5HH46GiogKLxUJeXp7sRFlQUHBM7VPHdLFRWlrK8uXL5f+vqqpi3bp1XHnllSxfvpyamhrS09N56623iIyMRBRFbrvtNjZu3EhISAh///vfmTVr1rhdj8fj4f7772fHjh0899xzpKSkDOp1PpA71GjpUDabjaKiIjm0551vm3lhex0o4ILp8QFcyLFCcpFKSEggNTW1z32MJIm7PzSZnYRqVUQEa+SRYkJCApMmTZqQg4EginRYXXhsRqoqK9AGBVFp9BKpU5IRb5Dvo78AxpHAaHdz3WsHcLh9JOk1XJfjGZKPOxBe2FHL2980IyIyNSmctKgQLjsxmZhQLXa7XR5FSxaUbreb2NhYsrKy0Ol0vH+whbe/baKhy4FCqUAQRG49NYNlMwfn3/7j6wb+vLkSj7fH7z9Io+T/nTOZi77bWNrb26msrCQ5OZnQqDgufeEbGkxHqFDBGiVfr1kS8Ll+c28DD24sD3iewvtOobu7G5PJxMp3Kqi1HFmOvrhxak+6cFQ0d557G5VRKfx54xOkVhwAP3tPaTEfaCH3R0VFBY2NjcTHxw/LKvd7xo/7NDw2jHif2l9v4ooXdgNw9cJ07jxrfKmuRxNe3F7N5oN13H5WPidmxSEIAo8//jhvvPEGTz/9NAUFBbI2T6JeTmS3VErp1uv1w3ou/4wEi8UiW4L7hwAO9F2VRLcGg4HMzMwJvS9pShoZGTns55IO4P60IX8NSe/APAnSXh8dHU1GRsaI78vtE3hiSxUNRgd3nZlNauTADS+LxSK7JQ31XI9squCdfc2AyJM/yyFJ58VkMgW8ZxIlqr9mo7TX/36PlzqLB51axeMXT2FeRiTNZhfxeu2gAnKAeRu+xO0T0KqU/O2yqdjdApkxoX3C/aqb2qmoqOQbo5Z/HrYAUJAYztQkPWfmxciTLVEU+biojQ6bmz9tqkCtUuLxCaiVsCBRw+V5PVOHQpOKzVUO9jVaEURQKmDv2pNQKBTowsN56YSl7Eibwc073yT3vl/BVVfJ1+LfHFOpVP3uU1arVdYlBQUFMXXq1OPFxg8Bn89HcnIyu3fv5qmnniIqKoq1a9fyxz/+EaPRyIYNG9i4cSNPPvkkGzduZPfu3dx2223s3r173K9ly5Yt/OpXv2Lt2rVccMEFiKIou4BIrgNSWJ7UJZdyOcbqmSwIApWVlVgsFjIn5/GPb9tweQWuXTgpQPg9Fkhe4yaTiebmHoeLiIgIoqKixlXE7Q+fz8fh0gq6TBbmzRxeevtQkBLF/cMLQ0JC0Ov1/P3rVr6qdxIWEsyTy6czKWp83LjqjQ5ueuMgSqUCjVLBS1fMoKKqGq/dQn5+/rC6RxKsTi8v7qyjocvOgQYzguAjPVzJJZOVxBtCZQtdvV6PUqmUO1Umk0kWn9V02rnjnUIqO7oJD1Lh8Aj87IRE1pyVjWqQRX1TcRt3/7sQt1+m3jn5MTx6cY+GRHouo9FIfGomF79ShM115Jf1WgW71p4S8DcXPPwFZqcg////nRFEuJ8V8LpNdZS22lh/QQHTvxOWKoqL8alUVAoCbN5M7OWX97HbHE73CKChoQGv14tarcZgMBAdHT28N+L7wfFiY2CMeJ96dVctD20sxusTmJFq4O0bFk7Edf3gONRg5hfP78Ll8RETFsSOX58uP/bNN9+wcuVKVqxYwYoVK1AoFNTW1tLW1sbUqVPHZY0dCNI0oK2tjSlTpshTa/8GXElDJ4/t6ECngtsXRJESFzniYNzezzWWaYCEXdVG/nugmZ9OS2BhVuAkaLAph3/RJLEWhjvth56clRd21OLyCqxcnEawWkldXR2tra3jphuxOr08sqkCQYR7zspCr9PI1y49V25ubp81VqJ6G00m9tZ0EaL0khXXUwh+UOHk7QPtnDs1nrvOyBqyqSYIAjsPV/LS7mbmZMdz/cmTueGNQ+yrM5MZG8LrK2YN6sj21jeN/PWLGualG7C5vOyrM6NUKvjX9SeSFBFYcAiCwLYDFdzzcSM+lCCCVxTRqpT85ieTWZIVhU7hlQvCJ3d18FWjD0EEjapnP/nk5vmyQ6Qoiqz/uJytZZ2sXJLGJd8J5xWbNyM2NFBz8smE3ncfikcfJaZXNtZw9ilRFCkvL6ehoYHs7GwyMjKOGc3Gj6bY+PTTT3nwwQfZvn07ubm5bN26lcTERJqbmznllFMoLS1l1apVnHLKKVx22WUAAb833mhubuayyy5DrVaj0WhYsGABixYtwuVyyZ3siQjLkyCJ8jIyMmS3pdFAEAS6u7sDRNy9aV1Op5PS0lJSU1MDUqbHExXt3az5TxFOt5dl6T7Omj5pRNMAURQD7sNisQTch7/WBWD1Pw9S19mN3eli9fw4LlyQNy5dMVEU+ff+ZnZVGzl5cjQv72rA5fWxelESkc7mIbtH/k4xkjiwzCjwSrEHhxe8IiRG6PjDT/P7dVKBI4FOkpuKxeXjljcPUdhs7dFOiDAlMZwXrphJ2ADaFYDPStr41duFsp4CYEZyGG9ce8R9zWaz9TinqYK4+r32gH//zd3z5Y6e1NW7aYsbjwgL0sN54co5jATd3d2UlpYSFBTE5MmT+2zcQ1Gr6urqUCgUpKamotFojjYu7PFiY2CMeJ/q6naz4qU9tFldPLZ8JvMzj6rCctxQ2W7jwqe24/YKpEeH8sntJwU83t3dza233kpXVxdPPvkkUVFRmM1miouLJzQwT+o8G41GioqK5MLG6XTK5hqP7TLxZbUFhULBDUvSWLUkfUzPKU0DxpKobnf7OOWx7bi8AkFqJZ/dtpBwXd81UhLg63Q6dDpdv0GAIw3Me2FHLU9vq0EU4ZLZyaz5ziFJcseSJkVj6XQ/+lklr+1pABEuOzGZu8/MDnjc355VEuBLZwKpKSTpK6CH4rTwka9QAEqlgvdunNvnwD8QJAG5qNRwzQcdqJQ96/bbK2fj8oikRQcTPIgmBOCUx7ZjdnjRqhRMTerRPNx3bg5pUYGFtNnazeHiMm7bbMYjgFcQ0akgRAOPnxlJdKQBg8GAXq/HI4hc+sI3NJlcxIZr+c+qE0cUTul0OikrK0MURXJycvrQqIcqOtra2jAajbJuKDU1ddjP/T3gx19sXHPNNcyaNYubb75ZdoWSEBkZidFoZOnSpaxdu5bFixcDcPrpp7NhwwbmzBnZoWYo/Pa3v+XDDz9k2rRpeDweampq2LBhA7NmzcLtdlNUVESHW0VodBJz0iNHnaI6FDweDyUlJSgUikHtAP3R2xqwrNPNG6U+IkO1PHhuFmnx/Yv7vF6v7OxUUFAw7km1//q2if/7qg6NSsGJaQYunazAarXK7hy9ITkr+XN6pfG0wWAYcDwt4UCDmSe2VJEWFcwlOWqK6zuITExlSV7ikGPc4eLdAy08va0arVpJfkIYv5iTTJjXREfbke6Rv6WhyWSSpy+972NbeSd/31VPi8VJu9VNsFbJzadksnx2/2GZoijS2NhIQ0MDWVlZaEIN3P7OYb6uNSF8960P1Sp56YqZTE0euGP2UWELd/6rOOBnt5+azsolRyh70nP9vw/K2dN25PdeP79nAZcW8fEYB/sn1qakpJCSktJvd6g/alVNTQ0ajYbk5OTjxcaxhWNmn/ohsL2ig/31RpadkEKSoe+EVhRF3nrrLdavX88jjzzC4sWLZXt1ySJ6PFKKJffBdRvL+KTcQm6kkrtODCZCr8dutyMIAlOnTpUpUU99Uc3Lu+oBWHd+Xp9shNHAPxy3oKBgxNMbh8fHqY/twOHpERNvuW0BoUHqfh0Jg4KC5ElNQUHBmDQq8F2x8UUNAnDJrCTWnj1ZfkzSbTY1NY1JD/P89lqe+bIWgJWLJrFqSXrAXmoymXC73ahUKhwOB+np6aSmpg64VgqiyE+f3kO7zU2oVsWHq+dR1mqjqNnGOVNiiQwZ3JVRWs/XvlvCt+0isycZEEWRw81WYkK1/GvViYMWHB8VtvKnTZVEhmio7rDjFUUyo0P42axELp6VhOgNdGAsbHPxWZ2XQ12gVChQKBVsvX2hPOGR4PD4KG2xkRMfNmSg4UCQwhvj4+P7DZsdiFrV0tJCd3e37DR5nEY1Tnj/QBPbKzq4bO4kZqT2LxJyu90kJSVRWFgou2j0V2ycd955/PrXvw4oNh5++GFmz549rtfs8/kCPgCHDh3i2muvZfny5axatYqK9m5+9eZBXG4PS6cncvsE84UlFyv/RUgURWxODz7XET/17u5ugoKCAqYW6z6u4mCjGY9P5OZTMjhv6uDWhR0dHZSXl4+7zWGD0cE9/ynC7vbxwHm5zEwN9CA3GAzyoVzqtEgHcr1ePyb+fVGzlXv+XYjD6eSMbD1rzp85LgfRRpODu/9dhNnhRRBF1EoFC9L1/HJKCLW1tQiCECBGH8rSsLDJyj3/KaTZ7EKjUuDyCvx0ejz3nZs7YEHrcrkoLS0FIDU9i1v/VcI39ZaA31l/fi4XnjCwjuO1PfWs/7hC/v8InZIvfrVAXsBNJpOcVP/2ISPftnn57dJ85mSNfuI2FPxpXJJLmz/66x5VV1cTHBxMYmLi8WLj2MIPvk+NBddccw0ffPABcXFxHD58GIC7776b999/H61WS1ZWFi+99FKfz/B4o7a2liuvvJKFCxeydu1aNBqNvHfk5eWN+Pkl1xz/yWVQcAhXvd+JRtkzWXzrujlkxPQc+CU76qysLOLi4hBEkS2lHYRqVSzIHF/hujS9GU1K94EGM+8daGJBspYUnUfWKPrvmyEhIfLfHKu+QoLL6+P57XW4vQLXL0nrk4INPdMAKYg3Ozt7xBQbt9fHP/fUYrfbWRAPjm4bzXb4rBFmTzLwi/kZciPRf+/Izc0dsMFocXrYV2dmWrIeq9PL8uf34hVEsmNDefO64TV6PR4Ph0rK8DjsXL+pG7VSgVKh4LTcaCKCNdx2auaADpIAW0o7WPvfItxeAUEQUSvh5BQVV0wLC2h4qdU9heOG9/fzSbmVS2Ylsvr0iTuf+WeOZGdnExMTE/B4f/tUc3MzLpdLplAdLzbGAQ1GO1e/9DVKekSo79+ypN/fe/fdd3nqqaf49NNPAY4KGlVvOBwO7rrrLmpqarhyzQae3t0OokC81sO6n2T024Ed7+c/dOgQGo0GTVAQf93ZQalRYPGkEG5cnIJer+9XxC05Q2lUSjYsK2By3NCOUNJEBRi3rhiATxARRBHR55U5vZWtJpK1DrQqJSkpKcTGxo5IVD8cbC5p59HPKlEAWQYll2QKFOTlERU5ts3f5/PRZTSzo7yFJ3f2fB66PQpmJYdw2ylphCg81NfXy5vvcGC0u7n+9QOUtnb3LFTA5NgQXrpyFoaQgd8HyZEmPjGRtZvaONRkC3j8k5tPJDVqYM/52eu34vxOkjE/HlbPOUJPi4iICPgMmM1mSktLiYqKIiMjY0IXy5FQq6qrqwkPDychIeF4sXFs4ZguNrZt20ZYWBhXXnmlXGx8+umnnHbaaajVatasWQPAhg0bJvxavF4vv/vd79iyZQvPPfccaWlpOBwOCgsLiYyMHPCwLCWMS4WF1Nn3F3FL373rXz/At/VmkiJ0vLVyNkHqI99/t9tNcXExGo2GnJycCeWj+3w+ysvLsdvtcuhgf+hvujxSR0J/F8fx0I34o7K9m/WflJNq0HHvOTloVAqampqoq6sjJydnUO3ZQAwAad0ODw9n6d/20Gh2olMrefGKE5iSFHjtUkBuWlrakLS7/fVmVv3jIC6vj6hQLQ9dkM/BRgtLp8WTOAx6lclk4sF3D7Gl3ktihI5WqwsFChZmRXHJrCSWZEfJz99bfL+v2cXudtjX7AaFgnOnxPOHC/IHfC6JAiwVbuN1jukPI6FWNTc3IwgC6enpx9Q+dVQXG502F1e8sBu728ekqBBeuXZev7936aWXcvbZZ7NixQqgpysUHR0tC8S7urp4+OGH+fDDD/nrX/8qC8RvvfVW9uzZ873djyiKvPvuu9z3wDrmXLMOVXgsN52UBuYmedQ62rC33pBE3P7i5+DgYARBoNHk4G+FCiJDgzDaPbx349xBqVwNxp4Am94WckOhtbWVqqqqIRe8weBvBSy5Wmi1WpyqUP64vQufqGRxdjQ3zY+lpKSE5OTkcS/cHB4fT2yposXi4qTsKF7aWYfK52LNkjjmTssZ1mFZGqf7O0RJ3bAwfQQv7jOxvdqMy+MDhYIUg477zs0lM0pLaWkpoigO2j3yh9np4YbXD3Cw0Sp/gTVKBX+7bBqLsgZ+H6RpQFdXF2u3u2m1eeXHZiaH8Y/vtBiSsF66F8l28r1qH8mRYVy9JHvIBdB/7J+VlUVsbOyQ9zVaDEStkj5bJpNJ1r9MmzZNdko5Vhbx4zi2iw3oofAtXbpULjb88Z///Id33nmH119//Xu7nm3btnHLLbdw55138rOf/QxRFKmursZoNFJQUIAoigH6N2DAzn5v+ASReqODpAhdQNqzBFEUZdv40UxURgppopLxXaJzb42ilDM1kPW8PzaXtPPMthpOyYlm9ckZfX5PmnLExMTIIahjxVUvf8v+BjNatZL7/ELtnE4nJSUlAYWbdG/SeudvqzuQq9cFz+yhttOOVq3klatmkR4dTL3RSUZMsEwp9nq9VFRUyNa1A9HTRFHkr1ur2VNr4pJZSfzuozI8PpFJkcG8e+PcYd2vIAjU1NTwwq5GPq4V8PhEFAoIUim5ZUEss2J6hPiS+5VUOGm1WuxuH3/aVEG328c9Z2UTPcSZRhRFebqXnp5OQkLChDaFJWpVXFyc/PmQ9KbSPmU2m8nNzSUuLu6Y2qeO6mIDoKzVSlGThYXZ0cSF9/0i2O12UlNTqaqqkt0YOjs7ueSSS6irq2PSpEm8/fbbREVFIYoiN998Mx9//DEhISG89NJL467XGA4aGxu56qqrmD59Or/97W/RarVyd2A0B/OBRNz+i4i/+NloMvOrNw/Q7FBycm4cv/lJzojvwePrcQ0aSm8ihdLodDpycoY+mEuaEelLNZCobl+did9+UIpKAbHhQTx/+Ux8Ph8VFRXYbDYKCkaeXzEc/Pq/RRS12PB4Bc6dHEqG1srCmfl9OLIDpYr7O0T17oZtKW3n4U2VNJudhGiUKBRKNizLY0l2jDx5GK4I3+HxsfLV/exrCKRErVqUwm2nTx7gX/XAarVSWFjINZ865J9dPjOSZZODsFgs8uYr3ctYKGpSDoggCBNuNyuN/U0mk8ynDvNzu/J6vezZs4fdu3czY8YMeQJ6lOB4sTEwfvB9aqwYrNg4//zzWb58OZdffvmEX4cg9BzcFAoFXV1drFq1CpVKxWmnnUZ7ezsLFy7EZrMRHh5OXFzcsBPGRwO73U5hYaE8Ae3vULWzqosXd9Zxem4sl87pX582GKTOfldXFy0tLfh8PiIjI4mMjJQ7+yO5t7kbtuH2iWhVigETyKXDckdHx6BZVcPFmv8U8VlpB0oFPH7xVBZ+RznzentsZxsbG+ns7ESj0QRQcofSLUqoNzr4595GZqboOWlyND9/bi+tVhfTkvS8cEVgPofJZKK0tFS23x/s7xc1W7n6lW9xeQVCtCpEsSfo9blfzhhSB+H1emlobuHFbZXsbhFo6gaVEi6bEcUNJ6UP+96GCynrQiqmJirzS3qu8vJy2tvb0el0cjCltE8plUq++eYbdu3aRXx8PKtXr56waxkFjt1i48cKn8/Hhg0beP/993n22WfJzs7G5XJRWFg4pNd5f1zYsLCwgAP5UF80l8fLt4VlqH0Opk2dOiJBd0V7N/f+txifKPK78/MGdD2SIIXQ1NfXB3SqJCtA6UAuaUb8i6SBRpdeQeCprTWUttpYtSSNjJgQ9tWZmRwXSojY4441Gj7uUPistJ3HP6tCEEUEEVQKuDhbwezkUKKiomRrQylnRFogBuv0+b9OO6q6WPdhKU3mI7kUV8xL4e4zs/H5fFRWVmKz2QYUxvvDKwhc+vw3FLUEUqL2rFlMWFD/r6tUJBmNRoqq63n+gIe8WA2rFk+SN6iJOFhIHR0pS2WsG4X/JMlkMmGxWFAqlXJxtGPHDt555x3OPvtsCgsL2bdvHxqNhrlz57Jo0SJOOeWUYVPXviccLzYGxjG/Tw1UbPzhD39g7969/Pvf/57w4MGPDzdz51sHiA0P4qEz43nqT+spLCzE4XCg1+tZtmwZN9xwA0qlkuLiYlQqFbm5uRNKdZIO5p2dnRQUFAQc8kRRZMEjX+H0+NCqe/Qf6dEDr4nDacpZLBYqKyvJzs4e1bT1gqf30GR2olYqeO+mucSGDbyvWq1WiouLiY2N7VcgPFw4PD4+ONRCZBDkG3poqlvKu9jdIrA0L4JT8hIICQmhurpaNosZLYOiptPOxf+3F0EU8QoiX9y+kDqjk7z4MHlKJSW4d3Z2kpeXN2jI4Su76tlVbaSw2YrF6UWlgNTIYM6fnsCKBT1uk71ZAWazOWDaVNfZzR+31BOtD+WRi2dgGEJ0PhZMBAXY5XIFTC1EUZTPDKWlpTz22GMsW7aM8vJy9u7diyAIzJ49m0WLFnHyyScfd6M6GmEymbjuuus4fPgwCoWCF198kdzc3B8kAFDCzp07ufHGG7npppv45S9/CRDgP67T6eQDucVi6XMg1+v1Y6Je+YvyYmJj6ex2ExWiRaUceGN7cUcdb+9rQqmAcwriuOXUzCGfRxq7FxUVyc4KgiAEjN5HGvznj1vePERVRzchWjX/d/kMwrVKKioq6O7uJj8/f1ynHF02Fy/vqOLDwg5cXh/BSpEFSWpOSfSRnpZGamrqmDbg/Q0mfvVWIR02N1LqRFZMMP+4djbhQUdCDiULx8E2KVEUmfPQVhxHGFH8Y8UJzPzObKG/hc7fDlipVFJWVgYMLgIcD0gHi/b29n693If6t1KhZzKZ6O7ulidJBoOB4OBgCgsL2blzJ7t376a0tJTExEQOHz7M8uXLWbdu3ZiSf78HHC82Bsb3sk/VdHTz0o5q5kyK4vwhgi9H/Lf7KTZefvllnnnmGT777LMJzbyQcMFfv6KkpSd5+fZT0pgX46WgoACVSkVRURErVqxg2bJlrF69Whaq1tXVUVBQMK7fHZvLy+p/HqLe6OD3P81jYeYRO17/BpIoipz5l110drvRqpW8f+Nc4sKPrE+9nRWH25STHCO1Wu2IdSNd3W62lncyPVlPduzQ3W//g/lIphz+GVEmk0mmshoMBgRNCJe8UozHJ6BRKfnqrkWyLqatrY3KykqZMjbS/dYniNzy1iG2V3axbGYiO6q6MNu95MaH8srVgecjm81GSUkJERERZGZmDnowv/+DEj4ubMfm8qJWQpBayfozE4hVO7Hb7bJGZiDnQmka4HQ6B6VxjQfGQgGWHNmk/dY/a8VgMBAWFkZ5eTk7d+5k165dckjz4cOHOfvss9mwYQOxsbET3ngYA44XGwBXXXUVS5Ys4brrrsPtdmO321m/fv0PGgAIPdXy6tWrcbvd5J57LZ9XWTm3IIZpoVaCgoKIiooaUYd8pPB4PBQVFfHKYQfFRshPDGfDsvwBLV6Lmq385r1iRBHuPy+XE1L7WqP2JxjU6XTo9XpcLhcWi4UpU6aMm1Bu2bM92huPT+Svy6cRFx5EiFZFV1cXZWVlY5pySCFTUsHn8/lwKEN47oCdqi43EcEaXF6BM3OjOD3eiT64Z5Mai6CsvM3Gta/up6PbE/Dzf10/i/yEiIBR/FDdI4/Hw8yHvkIEgpTwnysysX6XxCsVrtLna6CN1T8VfKLNDOx2O6WlpWi12n5F3dI9+dPtPB6PTLeTLIP37NnDzp072bNnD0ajkWnTprFw4UIWL14sH6K6u7tZv34911xzDVlZWRN2T+OAo3Z3OQrwvexTZz76BbWd3QRpVLyxcv6gltAjRe9i4+OPP+aOO+7giy++mFA9kz+e/ryCp7ZWolYqeOuGBeTEB67NTqeTtWvXUlxczNNPP01CQgLd3d0UFhaOKbuiN9472MLvPyrD7RXIjg3lnet7tGI+n4+ysjJcLpesb2w0Ofi4qJ3ZqXoy9IpRB+b1hr9uZCxWstBDOb7nP0V8W2/m9tMyuWBGX0OawaYc/WUr+Xf2JZdCCRanhzOf2IXT4yM0SM3WOxZidXqxOLxkxITg8XgoKyvD4/GQl5c3KuqqTxCp7bKz/IVv8AkiPkHkjLwYMqJDufGkdLlZKYoiDQ0NNDY2Mnny5H4p4i6XC6PJxDdV7Ty6vYMOp4hGpeCZZenkp8aO6Mwj0biG04gbK4ZDAfb5fPL7JhWF/tRdf0rUrl27aGpqIj8/n0WLFrF48WJmzJiBWq3G7XbzxBNPsHjxYhYsWDBh9zQOOF5sWCwWZsyYQVVVVcAH94d2rrJarTz66KPs3r2bw6VVKM+5h3CdlsjYeP5x9Qk011fj8/nIz8+fUDcEl9fH0r/uJFjhxaPU8uKVswZ1h7C5euxa9TpNT6XfYaalw0Q4DqxW66BWgHBEKDfWEbKEXdVd/OPrRmanRrC9qotGk4sVC1L5+aykYbuOQP8dcv8Dee+U9wc+KOHzsk5MDg/BGiXZsaGsPSkOa1vDiFyk+kOT2ckFT++h2z+mG/j23iUEfVcUDBbo1PtA7nC5MeiPULtGGiol0bjMZvOI085HCn9Rd2pqKpGRkQGbrUSJkt6TlpYWuRu0b98+goKCZErU4sWLJ1zY9z3gmL74Ccb3sk+d/uet1HfZCdKo+Md185mWMj7FxmWXXcbWrVvp6OggPj6eBx98kIceegiXyyUfzubPn88zzzwzLr2UWkIAACAASURBVM83GKrabUQEa4gegP4jiiIbN27k17/+NevWrePMM89EFEUqKyuxWq1MmTJlzNPP4hYrV7+yH0S4YEYC954TqDFrb2+nrKysxx5XEPoE5hkMhjFNyf3hcDgoKioiLCyM7OzsUdFm9taaWP3Pg7h9IqFaFV/dtbjf3/OfciQnJ8uTmf6ylYa6jgMNZr4o7+TsgjiUCrji798iiCLXL07jukVpwBGb+kmTJo0qjFcQRe76VyFfVnSh16np7HajUSk5f1o8F52QyNSkIw0wSayuVqtJTk6WTV+sVqscEBgREYFLqWNzmZFpSeHMmjQ6YwDJ+autrW3EE/LRwJ8CHBcXh8VikRuTQEDBazKZ2LlzJzt37pQpUXPmzJH3qfEq2H9A/HiLDen6h3qD9u/fz/XXX09BQQEHDhxg9uzZPPHEEyQnJ/+gAYAej4d3332X+fPnE5+YxMV/3crhijriwrVsXLMUrUY9Jq/zkeDxLZV8UthGWqiX2xcnMDm7f92IvxWg2Wymsr2b/yv0IipU/HJ2PL+YnzGs0bO0uHZ1dfXh444W++pM3P9BKTqNEq1KyQNL80iPDkajUspTDn+R9WCC9OFsWt1uL89+Wcu/v23C4vQhIhIepOaRC/MIdzQDPfa/o6W6dXW7WPLnHQFfxIcvzGPp9CNFr9Q9qq+vJyYmRn5//LNG/FNdxwqr1UpJSQkGg2HI8fho4K/lMRqNmEwmRFFEp9ORn5+PTqcLoERJ76k0tTjxxBMnVMD3A+GY3oEmGN/LPlXRZuPFr6qZkx7JRbNSvo+nPGrR3NzM1VdfTU5ODg8++CA6nU6m5I5W7+CP2i47rRYXc9IMiN8VFP5Tcq1WKx/CBwqR3Xi4lee313Fmfiw3npQ+6muRaDPNzc3k5+ePmDLWZnWx7Nmv8QkiM1L0PPuLGQF/W5paSM5egiDgdruJiooiOzt7UPer4eDNbxp55NMKvCLkxYfx6M+n0O3yMjkuTA7jdTgcY6Ibr/7nQXZUGfH6BNSqnr33jWtnkRqhDaB72e12vF4vcXFxpKamEh4ePmGHa7vdTklJCTqdjsmTJ497s9afEmU0GjEajfh8PoKCguRmXGlpaQAlKjY2Vt6n5s+fj16vP9aLi974cRYb1R3d3PX2fgQBHv75dCbHD0zJ2bt3L/Pnz2f79u3MmzeP2267Db1ez5NPPvmDBgD2htnh4XB9F++88AQHvt7Fs88+S3Jy8rC8zscDdrcPnVpBbW0tza3tKKImkRKpQ+Wxy4uhQqEI4PVvrbTwl63VaFQKpiSG89CFBSO75+/4uONB0bE4Pdz21mFarS4QQalUMDNFz+9/mo8gCJjNZioqKnA4HKjV6j40otEsSF5B4MnPq3l9TwN2T4/KQqmAq+alctVM/Zg4sgDNRhunP/m1/P9f3bmQCJ1a7qBI3u9BQUG4XC6CgoKGnOCMFf7j8f7CiEYCj8cToBvxer0B4nqPx8PWrVtZt24dAFqtlpkzZ8rdoPz8/KMt2Ggi8KPakcYZR/U+Nd7oLwSwq6urX+3hRMLn8/Hoo4/yzjvv8PTTT5OXlyfrHaQD3ki/l6Io4nA4Ag7fA03JRVGksbGRhoaGProRQRSZ+8cv8Yk9lJyhxOPDQXd3N0VFRYO6Yw2EZrOTqg47M5PDcNltFNd38NhXrYSoBG6cE0FijCFgaiElnUtWw2NpnrRbXVz58rd02NzccFIaz31Zh4jITSelc/WCSQByI260e7DJ4eHNvY28vKsOm8uHVqVg9QwNU2O1fRpe40HjGi78rWvHsgdDoOW7yWTC4/HIGiCpCbx7927uv/9+7HY7KpWKqVOn9qFE/cjx4yw2nt1WyRt76lCiYOn0RO4YJIm7paWF+fPnU1NTA8CXX37JH//4RyoqKo66AEDo+ZJs3ryZO++8k9/85jcsXbo0wOt8ypQpE2Lt6p/P8cjWRko6PYRqlTx0Tiqp8dH9jnBNdg/3vV9Ch83NvedMJjM2hPouJ5kxIf36qPcHyba2u7t7zAdlt0+gtNXG2v8UoVWINFpcnBCr5IIsNZNi9PLCUFdXR3p6+pBBRMOBKIr8fVc9j26uxOf3rYkMVrH1VwvGvLh2mK3895t6pkQKqDx22bGiv2RxKd/k+/AFdzp7nL+USiU5OTlDTk+kw4S/S5RKpQpIcW1qapKnFt9++y1arZa5c+eycOFC6urqePXVV3n22WeZP3/+hN3XUYjjxcbAOKr3qfFGfyGA99xzT7/aw/GEIIj84cNidld3suYneSyZ3DO9+Prrr7n++utZuXIlV155JQqFgoaGBpqampgyZcqgdEtpCis1GqQ8KH+LcP/9ps3q4tpX99PZ7eZPF01hYVaUXARI2RVSIXLe33bTbnOjUSrYuHr+oKGmw38NBnbH6g3/ta53o+7RPVZ213WjUin41amZXDm/f0chi8VCcXEx8fHxY6bYiKLIq7sbeHxLj5tiRnQIGTEhXDQzkcXZ0TJN1mKxkJ+fP2SBI+kyZZquw0GNXcNbpW5OSNFz73n5qAcpNsda4IwE/gLy4U5w/N87fwcs6bPZ1dUVQIkCmDNnDgsXLsRqtfLMM8+wfv16zjvvvAm7r6MQP85i45taI/f++xAiIg/+dAoLsgbvri5ZsoTnn3+e3NxcHnjgAbq7uwGOygBACe3t7Sy742FscVO59qzZXLskE5PJRElJiXyYHC2ksJjeIT96fc+BfPV/axEAm93J6lkh/GTB9CHpQC6vj9X/PESrxUVeQhgPLysY0SIiLUBpaWkjOihLtoby4mCx8O9Kga9bfXgEBTqNinh9EA8uzSP3O+9zr9crCw4les5Y8cbXDfzuo/KAn4VqFXy99hSZZjAUR3Yg3Yj/gXyoDom0uLpcLvLy8iakMPWHJCDvLcSXONVSceFwOAL4x8HBwRw6dEguLsrLy4ekRLW3twN8b8LZowTHi42BcVTvUxOB3oLygbSH44k91V1c+/LXuD0+IkOD2HXv6fJjNpuNm2++GavVyl/+8hciIyOx2WwUFhaSlJRESkoP7WwsgXkAr+1p4LHPKvEJItOTI3jl6hOAI5Rc/0Zch83NlxWdzEyJICNmfN2JpCIgMTGR1NQei1ZJDCz953A4BiycHtlUwdv7mgBYf0E+CzIjOdBgoSAhvE9RNJ5TjhaLk2tfPUCX3Y3LI+ATRdRKBb8+ezJn5MdiCD7idti7wOltPztYw2u4kIJkTSbThOsAAYxGo6z38deK9g549XczlPSNpaWl7Nixg127dlFcXExcXFwAJao3JUzaw6XP/v8IfpzFBvSMCEXEfgP/emP//v2yE1VmZiYvvfQSgiAc1QGATo+Pc//yJd2mTtqNVp5bns/C2dPweDwj9jrvLRh2u90BYTG9g3C2lLbz0s56ZqVGcOmUMLYdrCA7PY3ZOQN/eZrMTla+foAwrQqry8u7NwyeTt4fvF4vpaWleL1e8vPz+y1w3G53wMLuP9L0tzXcXW3kwQ9LaTQ70amVqFVKNizLZ7FfkrZUBKSlpY3LlOOdfQ389oPAgqPot6fK9yaFA0kdFuleetOIxkPsKBVvSUlJ8qY4UZD4v0ajkYiICOx2Oz6fTy5eIyIicLvdAS5RJpOJadOm/a9RokaD48XGwDjq96nxRu9iw2Aw9EsHHk/UddpZ+uSXCKJIfqKet29YGPC4KIq88cYbbNiwgT//+c9kZ2dTW1uLIAg4HA60Wm3AGq3X60dMBy5ssnLNa/sRRZFVi9O49juxswSpETdp0qR+13KHx8ea/xRR02nngfNyRy1ClrQWZWVlsshZqVQG0IsHO3x7fAKfFrcToVOzKCuKnz23l0azk7AgFR/cNI9gTd81UCoCpCyisazl3S4vpz2xE4fbi0+AYI2S9OgQ2flL2oONRiMhISEyPXckDa+RwGKxUFJSQnR09ITSxOFI8dba2orBYMDpdMrnB2mfAgJcolpaWgJcoqZPn/6/QIkaDX68xcZEIT09XaYMqdVq9u7dOyAvdiIzOQRB5NqX99JgtKNTeGj6x2+4/BeXsnLlShQKxYBe5707/TabDbVa3SdVfLh4/1ALz2yrwe12cePsCC5YNK3fQ6Egijz5eTVflHdy7tQ4CpusODw+1p49ecScWSlVPTMzk5CQEPlA3vteDAbDoBOX7ZWd3P9BKW1WF6IICgVcMS+Vu87IkhdsacrhdrvJz88fs5j61jf3s7m0Z7OPD1Xz+Z1LgCPTpKamJhobG1GpVAGd/pFaNA4HPp9P7vqNZ/dI2nClbpDVakWtVhMcHExzczOfffYZv/zlLzlw4AC7d+9m37596HQ65s2bJy/aY+HQ/o/h+Is0MI6qfaq+y86694uI0wdx39ICdP0cHMeKH6LYAChsMlPcbOWsKfHodYEd+JqaGj755BM2bdrE5s2bSUhI4NJLL+Xqq6/G6/VSW1tLTk5Ov/anI0Gz2YnF6ZUn1BJEUUShUAzarPrgUCvrNpb22OrGhfLOyhOH9Zz9UYak7AeVSkVjY+OoXZ2cHh8LHvkKhQJUCgWvXHUCRruH6Sl6woICD7TSJMBsNlNQUDCmPImDjRbe3NvIx0Vt+ESRIJWS1y5KDGh46XQ62traiIuL+16KgLq6OlpbW8fVRWqggNeQkBC6urp47733uPrqqykpKelDiVq8eDGLFi0ac3H3P4TjxcZIkZ6ezt69ewOErwPxYic6k8Pm8lLSbGFyXDgaPNxxxx00NDbxt6f+SkxMDN3d3Rw6dIiwsDCCgoJGnSo+GB75tILPyzrwiSI/L9AzLdRKfn6+3AXoD2/ubeSlnXUoFQpOy43httMyhzXl8J/AGI1GbDYbGo2GlJQUoqKiRnUv++vN3PLWIYzdnoCgvDeunR2Qpi3ZAY6H3qG+y055q5UZceqA8CVpmhQeHk5bWxtWq3VYHNmxQnKRioyMJDMzc8SvoZQu3psSJXW7goKCAihRLS0tlJSUcOGFF3LVVVcxd+7c7yWc7EeK4zvdwDiq9qnrXv6abWXtaFRKfnNeAb+YN2ncn+OHoFENhS1btlBSUsL8+fPJy8tj/fr1fPnllzz33HOkpqbicrkoLCwkPDycrKz+nQ5Hize+buSRTRVkx4by0lUzCdWq5QA7/wKnsMnKile/RQGckRfLHy7I7/O3eidWSxam/iL14ODggL1hrM2qZ76s4bU9DZyeE8OOqi4sLh+xYVrevWFuvwG7kqnKaCbWUsNLWsdf2tfF4U6RX84w8JNpSX0aXpKVbHt7+5CZTuMByUUqJCSE7OzsEU8Q/N0MJQcs/4BXKZlb0ls0NjZSVFTEaaedxvXXX8+CBQsm1CXrR47/vWKjpMWCsdvD3IyoQdOwB0J/xcYPnckh4cnNpTy/pRBj8Q4yjHtRKhQ8+OCDCIKAIAjjGpYnoabTzh8/LSdUqyYrNoRPClsp0Hu5bn7igB2PvbUmHtxYitcnolIqUCkUrDk7m4WZUfLv+C98Eo+3t2WrVquVHSVyc3OJiorq81zDQUmLlWtf24/R7g34+atXzWB22pG/6e+WMZKNo/cmJYnKJBpR7/AlCQNxZCcCoihSV1dHc3PzkGFVbrc7wCVKSnyXxugSJWrHjh3s2bMHs9nM9OnTAyhRTU1N3Hrrrdx5550sWrRowu7rfwDHd76BcVTtU2v/dZD3DjShUih45OIZnDN19Lq6gdC72Lj77rv71R5+X3C4faz51wGaTE7WXzRNDgT8/PPPue2221izZg0XXnghgJyBMGXKlHFrsJz2+A6Mdg9BaiUblhVw8uSe4sLlclFUVCQfXFUqFcUtVprMTk7KjkajUnK40cxTn1cyOUrJqYk9a7g/X1+aXgwHUrMqMzOT+Pj4Ed9Hm9XFT/66CxEQRFiYbiA7LoxbT8voE7IrTTkkQfdAjRx/EX7vhld/9OmBYLPZKC4unjDLc39IoYq1tbVDWin7NydNJlMfN0NRFNm7d69MiWptbe1DiTKbzaxZs4azzjqLSy65ZMLu638A/1vFxsEGE3e9fQCfIHLxnFRuOHnkycAZGRlERkaiUChYtWoV119//YCj6u8rkwPgiy+/YsVblYRpQKkLw7D/dWbnZ3Dfffeh1WrH1eu8Pzg9Pi567mv0OjVWp5e7F0QQ7LUyberUfhe7mk47n5d28Na+RjQqJRqlgl+cEM2MKBGLxTKihc/pdFJUVERoaOioA5YajHYueOZrHB4h4OcHfnMSml5/b6gpx2AdlJFuUv6ZI9+HUM7hcFBcXExwcLDcPepd9Gk0moAgqcbGRnlqIVGi5s+fLy/acXFxAxZKEsXhOEaN4y/ewDiq9imH28c7+xqIDdNy9pTxd4PrLwTwwgsv7Fd7+H3hjT11/P6DIjw+kbkZUbx23Tz5sc7OTlauXInBYGDDhg2EhoZisVgoKioaUFsxUjz4YSkfHm5Fp1bxzvVziAs/0iCSbLqldGaNRiMfTi0WC2u22el0igSplTz58zzmZQ28jg0HHo+HkpISFAoFubm5I7JTF0WRhzdV8MGh1p5sqO+C8s6bGs8ls5MoSOzbRJR0KpIQ3+VyBVCGersojcUIRcocaWpqmvDcL+hpeJWWliKKIrm5uWi12gHdDKU9t6OjI8AlSqlUBgTnDTYJOr5PjRn/W8XGx4eb2fBRKUoFzE6P5OGf/3/27ju+xrv9A/jnjOwdQRKRvZcgMSI0tKjxaNWuETVLq2h5mgctWi2tXdWhqPEULa09iqD1ICEkiAwRQqbsnZz5/f2R37mbSE5knFsSud6vV15tzrrvO865v+e6v9f3uro8/0nPSE9Ph7W1NbKysjBw4EBs2bIFI0aMaBE9OZYevovwh7lwsDDAN+O6YN3XX+H0mdP4ads2ODo6NrnWeV0qu4bG4n5WCeQKJQQCwN5MB2/bS+BoXz1nVZXTH5eSjZXnUpBRLIdYAOhoCfGWtwWm9XWAkUHD0mqq9nd4XhqXOrn/3yivqr1T/NDdvuZVftUsh1wuh6OjI1cDvqCggFv8rDqRP9slvTGKi4sRFxfH+0I5VeWU1NRU5OTkVAssVOt5nq0SZWdnV61KFKVEvVA0AqrXKsepl8nf97Px3r5bYAx4s6s1Vr3pU+1+pVKJbdu2Ydu2bdi6dSu6dOnCra1QKBRcENBYjDE8yC5FR2MdGOtqoVymwJIjcXiSV4ZFwTaw0pEiNzcXBQUF0NPTg6WlJTdDO/7nKCRll0FLJMDeqd1ga66H/DIZrIx1mnQ+z8zMxKNHjxq9TmXer3dxJSkPUoUS2iIhtMRC/DErAJ1M/wkWVNX+8vPzkZ6eDolEAhMTE5ibm3PHx8cMRFlZGeLi4prUWb0+VBf0UlNT8fTpU4jFYhgZGcHMzIwbc+Pi4rjGeXFxcbC0tOTGqZ49e1JK1IvVtoKNMqkcX59JQFZRBT4a7Aan9k27SrxixQoYGhrip59+ahFpVAolQ3pBOToa6+JaUg6+OBUPA5Qj6b+fYv7cWRg/fjwA1LvWeUNJ5Uok55bhw99jYKQjRkaRBP2czBHcUQojoRSmpqYoKSnhOryamppCrGeIb69kIjy5EHllUhjpiNHD3hSfj3CHgXbDqzqUlZVxTQ4bs/4gPb8Er1VplBe1pC90quSGqrqDVp2eVXV1tbGxaXQDwPpQ5chmZWU1qmNtbape7VKVLVSlRKmqrZ04cQJdunRBbGxsrSlRfC4OJM9Fo6V6rXKcai4bN27E9u3bIRAI4OPjg59//lkjZb+vJuUgu1iCId5WavsrxcTEYNq0aRgzZgzmzJkDoVDIpcg29Uq5Ko21sLAQR29n4MfIAsiVgKOZFr57y5G7qq9KPfLy8oKuri6eFklw+HYGvKyM4G1thNE/RaKwXI7RXa0QOtil0fsD/JPGpaurC1dX1wZ9KS+ukOOP6Ax891cyJHIFdMRCfDfWE50NlNx5vLZqfwkJCS+kd0XVpoqurq4amUmrrcGr6oKeoaEhTp8+jW+++QZBQUGIj4/n0vFUwYWPjw9ViWpebSvYaKrS0lIolUoYGRmhtLQUAwcOxKeffoqwsLAW15Njxu4bSC+ogESuwIJgW+xbtxQCgQAbNmyAsbFxjVrnmjr5MMaw5UIi/rj9FMXlchhoVfaTmNvNECYog7Ozc43p8bxSKVb/mYj/PchFqUQBgQCwNdfHtom+sDJpeB8IxhiSk5ORnZ0NT0/PBgdUCqUSD7JL4WRhADBltfKzEomkWik8Q0NDKBSKalfiNF016lmqZlUNzZF9dgGgaoG9at2IkZERUlJSqjXO09XVha2tLff+nT9/PgUXLQsFG+q1unHq1pN8FJbL8IpLewgbsaawsdLS0hAUFITY2Fjo6elh7NixGDp0KKZOncrL9i7FZ2FTWCL6u7XHB6+6QCAQoLy8HIsXL0ZSUhK+//57dOjQAeXl5dzFo/rO6Kqu6qvO26o0VhMTE6SUa2HxiUcQABjo0QErh7shOrUQVia6sDbRRX5+PterqupFwf89yMWiP2IhlSthpCvGmXm9UC5VwNyg8ef6ql/KGxJQqS54hd1Lx84bWXAzYRjnqQ8zMzMuZai2C16qBrklJSXw9PTkvcdSRUUF4uLioKOjAxcXl3pfhFNlPlRNaXu2wWt2djbX2+LmzZsQCoVwcXHBtWvXMH78eKxYsYK3i36kUSjYAIDHuaWQypVw6Vj34umHDx9i5MiRACoXV7399ttYunQpcnNzW1xPjv+GP8auq8nQ1xYhpLcdHmaXAsnX8csPG/DNN9/A398fCoWC657p6enZqC/JVRsWFRQUcLMWGVIdbA7PRWaxHEIARnpiLB3kCAtpJvT09GqkcUnkCiw9Go/z8dmQ/n+rbR2xABtHeSHYrXFrTFSpR6pGPc8LqNR1dq1vXmvVkryNWQTYEPXJkVX929S2AFBVJer27dtccPHgwQPY29sjMDAQffr0QY8ePbgBqaSkBN988w0WLVrEezBFGoSCDfVa1Th1MT4LHxyIAgBM6+OAhQNdX9i209LS0KtXL9y+fRvGxsZ488038cEHH2DQoEG8bK/rZ2dRJlVAWyzEgVm94GVdmfbKGMPx48exdOlSfPHFF3j11Ve5i0d5eXlcY76qVLMWqi+mqguCqnP2s2msd9KKkFFYgf5uFvj81H2cjc2CUCDA/undYd9OHzKZjFsP4O7uDi0tLZRI5Hh7502k5Fdggr81jt15igqZEosHOWFc905N+luoAioTE5Naq3GpFjqrjrFq7yhTU1MYGho26GJhfn4+EhISajRa5UN9FnSra/Ba9d9PXUpU37590bNnT+5vIJVKsWnTJm4tLWkxKNi4kZyHpYfvgjHgw4GuGOKj2RQnhUIBf39/dOrUCSdOnMCjR48wfvx45OXloVu3bti7dy+0tbUhkUgwZcoU3Lx5E+3atcOvv/4Ke3v7Rm+XMYa0gnKUSOSYty8KCiWDhaEOPu9vjnfeeQdDhw7F/PnzIRKJuC/Jz8shVX0Zr9o0T1VVqbaGRdeScrHkWDwKy2WQKRi0RAJM7GGDMa7ayMjIqJEKpFAyLD8Rj8PRmdXeYH0dzfDjJL9G/R2USiWSkpJQWFhYY6CqWrK1sLAQZWVlXGdX1ZX+huacqgYqpVIJd3d33r+Yq3JkDQwMYGtrW+14VJ1cVSft8vJyREREIDw8HBERESguLq6WEuXu7k6zFv9v8eLFOH78OLS1teHk5ISff/651sHrzJkzmD9/PhQKBWbMmIHQ0FAAUPs55wEFG+q1qnHqp78fYv3ZBCgZ0M/VAttD6tfrQVM2b96MpUuXQk9PD4MGDcIvv/zC27Ze3/Q3UvLKIBIK8OfCfjVmsNPS0jB16lR4eXlh+fLl0NHRQUFBAeLi4tCxY0eIRCIUFhaitLSUayqnuqrfkHSZoVvDkVEogbZIgOXD3dDJRBcOFvow1tXi1laoKh0qGYNErsSxO5lYe66yW7mNmS7+5d0Rr7q3h1P7xlfQYozh8ePHePr0KRwcHCCXy7keRUKhsMa6uaZSzXKUlpZyTWT5JJFIEB8fD5FIBAcHB65jfNU1jqrjUygUiIyM5C6CUUqUei/DONVmgo0915Kx4/IjiIQCDPLqiNAhNetrN8WGDRsQGRmJoqIinDhxAmPHjsVbb72F8ePH491330WXLl0wZ84cfPfdd7hz5w5++OEHHDhwAIcPH8avv/7a5O1nFJYjZOd1SOVKiEUCuHU0xuiulji5cwOio6Px448/wsrKiqt1rlrYJRQKuYZFqpNC1YZF9V1kdju1EO//ehd5pTLuTePeXh8/jnfHo8SEGrMOjDEsOxaPw7czq72Oh6U+fp/VE41VUFDApR6JRKIaV8BMTU1r1EhvClUtd75mOVRT6aqrQfn5+ZDL5dDR0YG7uzuMjIzw5MkT7oQdHR0NPT29alWi2rdvTwvk1Dh79iwGDBgAsViMjz/+GADw1VdfVXuMQqGAq6srzp07BxsbGwQEBGD//v3w9PRU+znnAf0Dqteqxqn8Uinm7b+F/DIZNoz1g5ulZsuU17nt/HyMGjUKv/76K0xNTTFmzBiMHj0akyZN4mV7OSUSnL33FH6dTeFpbQyZQom91x5DplAiJNAeuloiKBQKLFu2DEeOHIGPjw8UCgXee+897jzn6uoKY2PjJp3DzsVl4bNTiXCy0IdAAMRmlMBAR4Rjc3rAUEeMiooKrgeIalxMKyjH2ztvoUQiB2MMSgYY6Ijxw9s+8LIyhrAB+1O1KaAq5UsqlcLExASOjo6N6qbeEHzPcjzb4DUvLw8ymQxaWlpwd3eHiYkJsrKyaqREBQQEoE+fPujbty/vsy+t2cswTrWZYCOrqALLjsSgXKbAZ294w8FCcw3UUlNTERISgqVLl2LDhg04fvw42rdvj8zMTIjFYly7dg0rVqzAn3/+icGDB2PFihXo3bs35HI5LC0tkZ2drZEP2c3Hefj7CQ3igAAAIABJREFUfjaORKdDX0uECrkSW9/uipS74Vi8eDE+/fRTDB48GKmpqSgqKkJeXh60tbUhFAqrXXFo7JfxxKwSTN0dhfzy6n0s9k31haE0n+t6WvXqyqLfY3DqXna1x8d+2r/e26zaKb3q+gS5XA6BQABvb2/em+VVLc/X1FkOuVyudu2IqlP6zZs3ERoaioqKCigUCjg7O1dLidLEYs+26PDhwzh06FCNK71VP78AsHr1agBAaGio2s85D2gUVu+lGaf4dvDgQZw5cwY7duwAAOzZswfh4eH47rvvXsj2t/2dhM3nE8EATA20h5/wCRYvXgwrKyt07twZcXFxGD16NGbMmAGBQICMjAw8efIEnp6eGmsm1+3Lv4D/79Yd7NIOTh0MMD3QFmKhgOtgrVoDKFUokVlYgVHbIiFVKCFTMBhoC/G6V0d8/i93tdt4tt+Sava5amYAY4wrd+7l5cV7dT9VOnVZWRk8PT2bNE48GzxVLQajuqAXExODFStWIDU1FQBga2tbrUpUQ9PCSKXWOk61mTmqDsa62Dbln3UUjDHEpBVBKASXR9pYCxYswNdff43i4mIAlXXFTU1NuSlAGxsbpKWlAaicNu7cuTMAQCwWw8TEBLm5udWaBzZWdztzuHQ0woX4bOSUSFBYJsP7v9zCqzbaGDnyLcybNw9aWlpwdnbGN998A1NTU6SmpsLGxqZaydrGculgiF+mdceobdX7WLy96w4iQ4PQrrQEt2/fhp2dHbcob90ob0Q+/h+ySmQAACujut+SVRv4FBYWVstrtbe3r3YCy83NxZ07d+Dg4ABLS8031lLR1taGj48PsrKycPPmTTg5OaFDhw71eq5qUFLlIQPgBiRra2suJerQoUOIiIhAUVERunTpgpkzZ6KwsBD79u3D4sWL0a9fP96Or63YuXMnxo0bV+P2qp9ZoPLzHBERUefnnJDGUCoZ7qUXwdpUF+0Mm55G8yxbW1uEh4dzqaRhYWEvbH0hUNmDRMkABoZymQKvDHoFUVFR3FX9oqIivPfee7hy5Qo2b94Ma2trmJqaIiYmpt5r8p7n3b722H71MQy0xTgXn42LibnIL5Nhcg8b2NnZwdzcHPfu3eMCIFtzfSwf5ord4al4mFMKuRK4kpTHvZ6qPKtqXKqa8tW+fXs4OTnVmg4kEAjg5OQECwsL3Llzh/cKUiKRCO7u7sjLy0N0dDQ6d+5c73G/rgavbm5ukMlkiIyMxPHjxxEREYHs7Gx4e3vjzTffBGMMO3bswNy5c7nGjqTxWus41WaCjWedvpuBDecTAQBLhrhjgEfjUmBOnDiBDh06oHv37rh06RKAykDmWVXTh9TdpwnGulr4bmI3bL34AJcTs5FWUI6fsyvQzdwb58Mu4OyfZ/DLL7+goqICjo6OsLKyQkJCAnJzc5tc6xwA7Nvp4/T7vdB/49VqlxsvJ+ZhsFdH+Pv7Iz4+HtnZ2dz2Ln0YhJN3M5BZLMXUXv98WNRVq1B9Ge/cuXOdea3t2rWDv78/EhISuDKyfFau6NChA0xNTREfH4+nT59yiw6rHk/VJoBVB6UOHTrAyckJjx8/VpsStXjx4hopUSEhISgpKeHtmF4Gr732GjIzM2vc/sUXX+CNN97g/l8sFmPixIk1HqfuM8v3Z5m0PUsO38XJuxnQEglxYl4QrE01m2Pfs2dPjB49Gt26dYNYLEbXrl0xa9YsjW6jLjP7OaKoQg6pXIEFr7li3fkH2BfxGIO8LLFhbBcYGxtjz549+OWXXzBkyBBs3LgRvXr1gr+/P5KSkhAVFQUvL68mrWeY1dcOs/raIfRILM7GZkMiU+DgzTQcu52JQ7MC0MnUqNr2PD09MdzHEgPc2mP63mjczyrBRD9zJCYmcuVZjYyMuJQoAwODBp0HTExMEBAQgAcPHnDb43N22tzcHP7+/njw4AGio6Ph4eFRbXvqqhmq+nc4ODggMzOTS4m6desWRCIRlxL13nvv1QhiQkJCkJKSwtsxvQxe9nGqzQYbD7JLIVMoIQDwMKcUAxr5OleuXMGxY8dw6tQpVFRUoKioCAsWLEBBQQHkcjnEYjFSU1NhbW0NoDKqTElJgY2NDZcyo+lOr53N9fHhIFek5JUhr1QKka4eoooY1lwrwg9z5+GVV17BzJkzERISgmnTpsHLywtPnz7FzZs34ebmBjOzms3tGqKDkQ7OzwvAq1X6WAQ5Vy5IF4vF8Pb2xtOnTxEZGcktyhvmY1U5NVulqlLVqVlra+tGLWzW0tKqtj0XFxeNzCKpo62tDV9fXzx9+hQ3btzg1nFUrS6iKmUrFotx+/ZtHD9+HOHh4UhKSoKDgwMCAwMxderUeqVEdezYkfeKWC3JwYMHsWLFCsTFxeH69eu1XpVNSEioduXn4cOH+Oyzz7BgwQKsWLECP/30E9q3b4/ly5dDS0sL2dnZOHHiBMLCwmo9Cas+syqqz7OFhYXazzkhjfF3YjZk8spxKS6jSOPBBgCsXLkSK1eu1Pjr1oe+thifDPcEUDnLsftaMkQC4Oy9TKTmu6KzeWVFqUmTJqFXr16YOnUqXn31VXz00UdwcXFBbm4ubt26pbbiUUMsed0FHYx0cCAyDVK5EkoAj3PL0MlUFyKRCK6ursjJycHNmzdhZmYGxhjme8kg7mIAU9PKrAQ7OzuNLLQViURwc3NDXl4eoqKiYG9vD0tLzXefVxGLxdwsR1RUFNq1awexWIzCwkJUVFRw1QxtbW2hq6uLe/fu4ezZswgPD0dCQgKsra0RGBiIsWPHYt26dc9NiTI2NoaXlxcvx9IS0ThVU5tZs/GszMIKrDoZC5FAgKXDPSBTMJRK5HDp0Pg8wkuXLmHdunU4ceIExowZg1GjRnELcnx9fTF37lxs3boVd+/e5RaI//HHH/jtt980fHSVKmQKzNp7E1cf5EDJGBgDLIy0sX9mL1gZCDF//nzk5ORgy5YtaNeuXaNqnddFrlDgdloRvKyMoKtVM64tLCxEbGwsBAIB9zd/Nq9VkydbiUSCuLg4aGtrw9XVVaOVLlQNpZ5NiZLL5Xj8+DH69esHfX19hIeHc1WiSkpK0KVLF24ht5ubG1WJeo64uDgIhULMnj0b69ate24KiEKhQKdOnRAREQE7OzuuQeeiRYsAVFbv+PDDD/HXX3+p/fIil8vh6uqKsLAwdOrUCQEBAdi3bx+8vLzUfs55QFMm6r0049RvkSn47Hgs3CyNsHd6D+g3ouFpa8EYw8jvruJhdgnMDbThZW2M64/yseA1F0zsZQegMn3n008/RUREBLZt24ZOnTpBKpVyjfKeLa3eGH/GZuHrcw/g28kYX/7LFeWl/xTkkEgk0NfXR3l5OXR0dODl5cV75UGZTIb79+9DLpfz0s/p2QavSqUSSqUSKSkp8PPzg6WlJW7cuMHNsOfk5MDb25srQevt7c1bx/CXBY1TtdzRVoONqmLSCvHRb7ehYAyz+zlijH/n5z+pFlWDjYcPH3Klxrp27Yr//ve/0NHRQUVFBSZPnoyoqCiYm5vjwIEDcHR01PAR/UMmV2L23khcvJ+Nqv/U/x7sijnBzjh48CBWrVqFr7/+Gv369auxaE1TpfKUSmW1qkqqFCJV11NVyVojI34rszDGkJ6ejpSUlCbN4tR2PLq6utwieyMjIyQnJ+PatWs4f/48d5IYOnQo+vTpgz59+lCVqCYIDg6u10n87NmzWLlyJa5cuQIANU7izs7OkEgkXCnoXr164YcffkB6ejpmzJiBU6dOAQBOnTqFBQsWQKFQYNq0aVi6dCkAqP2c84DeKOq99ONUqUQOBWMw1m2eBmYFBQWYMWMGYmJiIBAIsHPnTvTu3bvJr1shUyA+sxjlUgVm7Y2ETK6ElkiI7SH+cLM0gql+5RftsLAwLFy4EEuWLMG//vUvAJVXbtPT0+Hl5dXghq5A7ReI1PVbYowhMzMTjx8/1sjsf32oKh02ZRanajXDwsLCGg1ejY2NuZSosLAwnDt3DoaGhhgyZAiCgoLQt29fjaznbKtonKpyBwUbwJGoNGw8fx9aQiF6Oprji5E+zb1LGqVQMkzbdQN/3a9e9SnQ0Qz7ZgXiyZMnmDJlCnr27IklS5ZAS0sLBQUFXIfVxiyuVgUQqvUWVfNaTU1Na+S1lpSUIDY2Fh07doStrS3vJ7fy8nLExsbCyMgITk5Oz71So25huuqkLRaLER0dzc1cPHz4EI6OjlyVKDs7O3z00Ufw8PDAZ599xuuxtQX1PYlPmzYN3bp1w/vvvw+g8iS+a9cuGBsbw9/fH+vXr38hXxw0gEZ79V7qcSo6pQBTdkRAwRi+fbsb+rvVr/iEJoWEhKBv376YMWMGpFIpysrKNNpMLbdEgsGb/oZUrgRD5ZvdQEeMcx++AkOdytmdnJwcTJ8+He3bt8eaNWugr6+PkpIS3Lt3D9bW1s9dXF21qVzVfksNKfGumv1XpcLyPRMtlUoRFxcHsVgMNze3587G19bg9dlqhrGxsVzjvKopUUFBQfDw8MCKFSugVCqxfft2Xo+tLaBxqsodFGwAeaVSLD18F/llUgzy7IjzcVno42yBucFOGv/SW1FRgX79+kEikUAul2P06NFYuXIl700AlUolRn1/FVEphdVuT14zDEDlFNyqVatw/vx5bNu2Dfb29pDJZIiPj4dQKKzzRKdaUKY6yRUXF3OVtlRXiOozFaxUKvHgwQOUlJTwvkhOtd9PnjxBZmYmPD09uVmV2q54VW24ZGxsjNLS0mopUaWlpfDz8+NSolxdXWsMRIwx5Ofna3yNTktWn9xVALC3t+eaKz58+BC2trYAKt+XqampkMlk8PDwwMWLF2FmZlavk7hUKoW1tTXu3bvHrWt5+vQpLCwsIBAI8MknnyAjIwM7d+7U/IFrHgUb6r3U49Sa03HYcfkRBAJgoKcltk7s9kK3r6qA9/DhQ14vAmUVVSA+sxgzdt+ASCiATMGgLRZi3gAXzAl2AlA5Rnz//ffYuXMnvv/+e3h7e3MlXcvLy6ulOUkkkmoXiJ7Xcby+VI35VE3o+C6trppVSU5O5tY4qjxbYhdAtTL2MpkM169f51KicnNzuZSooKAgtSlReXl5NE7Vgsap56Jgo74Gb/obWkIBKuRK/DTFX6P9OIB/vpgbGhpCJpMhKCgImzdvxoYNG15IE0CPpSdRrvjnd1WwoXL58mW8//77WLhwIcaMGQMAXK1zDw8PmJiYQC6XV7tCVHVBmSqFqClXfPLy8pCQkMBbo7xnFRUVISYmBrq6lQsDy8rKuJQoU1NTGBoacilR4eHhuH37NgwMDNCrVy8EBQWhT58+3ImBVFff3FV7e3tERkbWWLz/73//G+bm5ggNDcWaNWuQn5+Pr776ql4n8aNHj2Lr1q04e/ZsrfcnJydj+PDhiImJafwBvjj05lLvpR6n7qYWYtKOCCiUDN9N7IZ+rk1bGN1Q0dHRmDVrFjw9PXH79m10794dmzdv5u1L9veXkvDdxQcolykgFgICgRBxn79e7TF37tzB9OnTMWHCBMyaNQsKhQIpKSlITU2FgYEB11CuarqQpisRFhUVIS4url6zKppQXl6Ou3fvQigUQltbu1oqsuoYMzIycPXqVURERHBVonr06MFdBKOUqNrROKUx1Gejvlw7GiIuvQgSuRIzd0eir4sFlg33hEiomQ+oQCDg8ktlMhlkMhkEAgEuXLiAffv2Aaicsl6xYgXmzJmDo0ePYsWKFQCA0aNH4/333wdjrNEnjLgvhmHGrggk55Zh+9SAGvf37dsXly5dwuzZsxEWFoavv/4aJSUlMDIyQnR0NAQCAXR1dbmrJ9bW1hqfgVCV5lOVyHVzc9PoQCGTybhASZXiZWxsDJlMhlOnTmHgwIGQSCQ4evRojZSo6dOnIyAggBrn1ZOHh0eTnn/06FGupHRISAiCg4NrdE5VZ//+/ZgwYUK12zIyMrgeL4cPH4a3t3eT9o8QvvnYmCD8P6+CgUFfWwylkuGz47GIeJSLj193R7A7v2lVcrkct27dwpYtW9CzZ0/Mnz8fa9asweeff87L9uYEO2FiL1sM3vg3SiVy+NrUTNeytbXFsmXL8Pnnn2PLli0QiURYtWoVfHx8kJ2dDTMzM7i4uPCa5qRKcUlMTER0dDQ8PT01mgevrsErYwxhYWHw9fWFjo4Ozpw5g/DwcNy/fx+dOnVCYGAgxo0bh/Xr1zdqLUtbROMU/2hm4xllUjnupBYi9I87MNXVRnaJBNOC7DGhhy30tcWwt7fHqlWrMGnSpEZvQ6FQoHv37njw4AHee+89LF68GL169cKDBw8AACkpKRgyZAhiYmLg7e2NM2fOwMbGBgDg5OSEiIgIXsu3RkRE4MqVK9i3bx+Sk5Ph6OiIZcuWoWvXrsjJyUFJSQm8vLxeyBfujIyMJi3KY4yhvLy8WkqUSCTiZmFMTExQUlLCpURFRUXh7t27cHJywrRp09CvX79aU6JIwzzvCo+DgwPMzMwgEAgwe/Zsrva/qakpCgoKuMep8o+zs7NhamoKPz8//PnnnzUWypWVlaFz5854+PAhTEz+ado5efJkLmi2t7fHjz/+yJ3UWzi6HKlemxqnrj/Kw4zdNyCRK2Gqr4WIJa/VeIwmximVzMxM9OrVC8nJyQAqZ7/XrFmDkydPNvm161JYJsOD7BJ4dzKGjvifVB/GGIYNGwZvb2/07t0bBQUF2LBhA9asWYPg4GAAeKFpTkDlepLExMQGNXR9VtXU3cLCwhqL1SUSCZcSdfPmTcTExKB9+/aYOXMmXnnlFXh5eVGVqCaicarJaGajvvS1xejl2A6BTha4fD8beaVS/HzlEW6nFGDNKF+NbEMkEiE6OhoFBQUYOXIk4uLiajzmRTUBrM3hw4fh5uaGX375hatqcO/ePfTv3x/t2rXjanM35cRaX1ZWVjA1NUVsbCyMjY3h5ORU5xd/dYsAVbMwrq6uePjwYY2UqN69e6Nfv34IDQ2FgYEBPvnkEzx+/Bju7u68Ht/LoD7NiJ7nypUrsLa2RlZWFgYOHAh3d/dau6JraWkhNTW1xu3W1tbcCRwA9PX1kZubW+Nxe/furdf+ENJSWZnoAgJASySEXTuDyrVneWWwMNSBgY7mh3RLS0t07twZCQkJcHNzQ1hYGDw9PTW+nWeZ6Guhu13NC0wCgaDaZx0ABg4ciJCQEFy4cAGffPIJ7O3tYW5ujrt37zaoU3ZjWVhYwNjYGHFxccjJyXluaXV11RmrNnhNS0vj1lrcunULYrGYS4n64IMP0L59e6xduxbR0dGYN28eb8f2sqBxqnlRsKHGZyO8cOhmKr7/6wGeFkoQFpeFyduvA1r6GtuGqakpgoODER4e3qxNAJ+1Zs2aar//9ddfCA0NxahRo/DDDz/A0tIS3bt3R2xsLHJzc+Hq6srrFRU9PT1069YNjx8/RmRkZLWrVaqqV6qTtkKh4FK8nJ2dIRQKER0djYsXLyI8PByPHj2Ck5MTAgMDMWPGDAQEBNQ69b1+/XrI5XLejqklqs8iuZSUFEyZMgWZmZkQCoWYNWsWzp8/DwDVGhEBaFDqm+r93qFDB4wcORLXr19Hv3790LFjR25KOSMjg/fglpCWrrO5Pg7ODkRcRhFe9eiAL0/GYf+NJ9DXFuPEvCB0MNb8jPOWLVswceJESKVSODo64ueff9b4NprCxsYGZ8+exZo1azB06FD8+OOPcHJyQkBAAOLj45GbmwsPDw+Nr9uoStXQNT09HZGRkdwaR6B6SlRBQQGkUim3WN3R0RHa2tq4e/cuTp06hYiICCQkJMDGxgaBgYEYP348NmzYUGtK1JIlS2iconGqVaBgQw2xSIjR3W2QXliOXVeSIVMoEZ1aAAxajDxJ5RWSsrIyTJgwAXK5HL/99lu9pmuzs7O5hWvl5eU4f/48Pv74Y/Tv3x+HDh3C+PHjsXv3bi7SHjFiBHbv3o3evXvj0KFDGDBgwAtf4KWjo4MNGzbg9OnTePPNN7Fy5UoMGjQIXbp0QWpqKiIjI6tVc+KDQCCAnZ0d9PX1cevWLejo6ECpVHIpUapup8XFxVxK1PXr11FWVsZViVq3bl2D8ng12fSvNfD29sYff/yB2bNnq32MWCzG+vXr0a1bNxQXF6N79+4YOHAgd6Vz4cKFXG3w+iotLeUqxZSWluLs2bP49NNPAfzz/g8NDa32uSCkLXOzNIKbZeX59mRMBuQKhgqZAtEpBejrUn0BeWPGqWf5+fkhMjJSI/vOF5FIhKVLl6J///6YPHky3n//fUyYMAFeXl54+vQpIiMj4e7uzmsJUYFAAGtra+jp6SEmJoYbQ6qmRHXq1IlLifrjjz8QERGBvLw8+Pj4IDAwEMuXL29QShSNUzXRONXytK13aQOJRUIsfM0VYMAPfyVByRhg2B6bExlsrsVj9QeT4e/vj2+//bbeJ4aMjAyEhIRAoVBAqVRi7NixGD58ODw9PTF+/HhubcT06dMBANOnT8fkyZPh7OzMNQFsDgKBAEOHDkW3bt3wzjvvICwsDJ999hk6d+4MMzMz3Lt3D1ZWVujcubPGgqGqKVEFBQUoLy+Hvr4+bGxsUFBQgE2bNmH69OmIjY3lUqKMjIzQu3dvBAcHY8mSJWjXrh1V36in+iySs7Ky4nJHjYyM4OHhgbS0NLVpFYcPH8a8efOQnZ2NYcOG1Zq7+vTpU4wcORJA5RXAt99+G6+/Xll9JjQ0FGPHjsWOHTtga2uLgwcPauhoCXk5zAhyxNdn4tHRWBe7rz7C+/ujgJ4hACrXW/zrX/9q8DilKQqFAv7+/ujUqRNOnDjxQrYZGBiIv/76C3PnzkVYWBg2btyIjh07wtjYGPfu3YOZmRkcHBw0tg5PqVSiuLiYm7lQNXi1srJCeXk5Nm7ciAkTJiApKYlLidLS0qqWEmVlZUXjVD3RONU60QLxelp/NgHfXUqCQqGsXALDAGdxLs5/EdLcu/bCKZVKbNy4Eb/++it++OEHuLu7q6113hBSqbTaArmqKVGmpqYQCASIioriZi5yc3ORkJCAYcOGYfbs2WpTokjD1LcRUXJyMvr164eYmBgYGxu35kZErQF9E1GvzY9TUrkSmYXleH3zZYAxlFVI0Ev0CBEn9+PdSaPw8ccfN8t+bdiwAZGRkSgqKnphwYYKYwx79uzBxo0bsWnTJvTo0QOMMTx69IjrN6Gnp9fg162twWvVhrWqlCjVeov09HQkJiYiKCgIH3zwAXr27PlCFq2/7GicapHUjlNUYqeePhrkhpDedgAYVPHZA4UFhn3zN6/bTUlJQf/+/eHh4QEvLy9s3rwZQGUvioEDB8LFxQUDBw5Efn4+gMoT7AcffABnZ2f4+vri1q1bGt8noVCIjz76CN999x1mzJiBn3/+GQKBAO7u7rCxscHNmzdrXfRUFWMMJSUlSEtLw7179xAeHo47d+6gqKgI5ubm6NKlC5ycnJCUlIStW7fijTfewGuvvYb9+/fDysoK69evx5UrV5CYmIiKigrIZDIKNOrhtddeg7e3d42fo0ePNuh1SkpKMGrUKGzatAnGxsYAgDlz5iApKQnR0dGwsrLCRx99xMchEEKeoS0WwspUD07tDQGBAFDIcU1iAzZwEUZNnt4s+5SamoqTJ09ixowZzbJ9gUCAkJAQ/Pbbb1i6dCnWrl0LpVIJR0dHuLi44Pbt27UuGK6KMYaysjKkp6dzM+jR0dHIy8uDsbExvL294e7ujrS0NOzYsQNjx47FK6+8gm3btsHIyAgrVqzA//73Pzx+/JjL56dA4/lonHr51DmzcSk+i/Fdw7u1sR/3CeDQ859raQJBjcZ4mpSRkYGMjIxquYdHjhzBrl27am0ic+rUKWzZsoVbaDZ//nxERETwtn8lJSWYN28eCgsLsWXLFpiZmUEikeDevXswNDTkFmkrFIpqKVEVFRXQ19fnZi0MDAyQlJTEzVpUTYkKCgpCYGCg2pQo1Xu4rU1D17fr6ZkzZzB//nwoFArMmDEDoaGhAKC2a/3zrhjJZDIMHz4cgwcPxocffljrY1pZI6LWoG29uRumzc9sqMgUSmQWVqDvqpMQa+tCzgAwJab3scMnb/i90H0ZPXo0/vOf/6C4uBjr1q174TMbVUmlUixbtgyRkZHYtm0brK2tIZPJEB8fD6FQCDc3N4jFYi4lSjVOVa1maGJiAkNDQ6SmplarEqWtrY2ePXtyjfMsLS3VjkVN6ZHVWtE41aY0bmZj1ak4pBWUa353WrOIvdATKCqvHgGArAJPnz7lbXNWVlbo1q0bgOq5h0ePHkVISGUKV0hICI4cOQKgsrnMlClTIBAI0KtXLxQUFCAjI4O3/TM0NMTOnTsxduxYDBkyBFeuXIGOjg5sbGwglUpx+fJlhIeHIzIyEpmZmdDV1YW7uzv8/PxQWlqK33//HTNnzkRgYCBWrlyJ4uJizJo1CxEREbh8+TK+/vprjBgxos4O3QKBoM2dwIF/FsrVVnpPRaFQ4L333sPp06cRGxuL/fv3IzY2FgDw8ccfY+HChUhMTISZmRl27Njx3G0yxjB9+nR4eHjUOIFXfZ+9LI2ICGlNtERCdDbXByL3w1CLQVssgkDAsOPyQ17HqWedOHECHTp0QPfu3V/YNuuira2Nr776CqGhoRg5ciROnDgBsVgMKysriMViXLlyhSsqkpqaCrFYDGdnZ3Tv3h1yuRzHjx/HvHnz0KdPHyxatAgZGRl4++238ffff+PatWvYtGkTxowZ89y1FzRO1Y7GqZdfnQvERQIBSirkyCmRwMKQUlRUlnoVI828GxKziqFz5xD69VuCc+fOwdbWltftJicnIyoqCj179sTTp0+5BVBWVlbIysoCAKSlpaFz587cc2xsbJCWlsZrQxjGGHx9fTFhwgRMnjwZurq6sLW1xbfffgsHBwfs27cPAoEAHh7PV5tcAAAgAElEQVQeiIiIwPXr11FeXo5u3bohMDAQGzZs4GZASP3VZ6Hc9evX4ezsDEdHRwDA+PHjcfToUXh4eNToWj937lx88cUXdS6Su3LlCvbu3QsfHx/4+VVeKf3yyy8xdOhQ/Pvf/67RiIgQ0gye3ML7zm9hd6Y18stEMClLRb9+/V7IOAVU9iM4duwYTp06hYqKChQVFWHSpEn473//y/u26+Lo6IhZs2Zh0aJFWLx4MczMzLB9+3Y4OTnh5MmTePToEV555RUcPHgQ169fR35+Pnx9fbmLYZ6entQ4r4FonCLAc4KN6UEO+GD/LShR2XeitxN/XatbC1UX1X/0BDas5X27teUe1qY5mgBeuXIFW7duRZ8+fXDs2DEcO3YM58+fx7Fjx3D//n3ExMSgvLwcjDEsX74cy5Ytg7m5eZu8yvOi1RZ8RkREIDc3F6amplzZRBsbG8hksuc2IgoKCqr1PQa8nI2ICGmNVOPURKkC6YXlcGhnAOHaF7d2Y/Xq1Vi9ejUA4NKlS1i3bl2zBxoJCQn4z3/+gz59+mD//v2IiIjA3r17cerUKTx58gRRUVFQKBQ4evQolixZgoULF9aZEkU0h8apl1+dwUZ+mRQSuRJCgQCn72bC3sIAViYNr95AmkYmk2HUqFGYOHEi3nrrLQBQ20RG1QRQpWqDQL707dsXffv25X7v0aMHHBwccO3aNbz77rvo3r07dHR08Pvvv+PYsWOYMGECr/vzMmlq11N1wWdzBKWE8CWtoBymelq8dNBuzfS0RZWLxgnc3d1x+PBh7vc+ffrAw8MDu3fvxrvvvovNmzfDwMAAFy5cwKZNmzBr1iw6J9YTjVPkeerMWxno2RGm+tpQMIaL97MQsvM6op7kv6h9I1Cfe6hqIgOgRhPAPXv2gDGG8PBwmJiY8JpCpc706dOxfft2BAYGclWiRo0ahV27dr3wfWkJ1FUPq+rixYvw8/PjfnR1dfH+++8jJiYG/v7+KC0thVgshlgshp2dXb22qy74tLCw4LrWV72dkNZmS1giBm34C8FrL9EawxYoODi4WReH12XIkCE4cOAAgoODuSpRAwYMwNGjR9vkl1oapwhf6gw2HNsb4o85gRjk2QFaQiHyS2VYdSIW15JyXtT+tXmq3MMLFy5wH+5Tp04hNDQU586dg4uLC86dO8dVbhg6dCgcHR3h7OyMmTNn4rvvvmvmI6iuLZ7AAWDNmjV49dVXkZiYiFdffRVr1qyp8Zj+/fsjOjoa0dHRuHDhAvT19TFo0CDu/rVr13L3q/JQnycgIACJiYl49OgRpFIpDhw4gBEjRkAgEHBd6wFQ11PSah2JToNCWdlBOzI5r7l3h7wEaJyicYpoGGOsrh/GGGMJmUXszW//xzyWnWZ914Sxnl+cZ9cf5jJCSP24urqy9PR0xhhj6enpzNXVtc7H//jjj+ztt9/mfg8JCWEHDx6s9pg//viDderUiWlra7MOHTqwQYMGMcYYS0tLY0OGDOEed/LkSebi4sIcHR3ZqlWruNuTkpJYQEAAc3JyYqNHj2YVFRVNPk7Cm+edq9vszy/hycxt2SnW96sLLKuonJ27l8mO305jcoWyKX9v0gyePHnCgoODmbu7O/P09GSbNm1q7l1qU2icIk2k9jxd7w7iZVI5xv54DUnZpZArlDDR08Lnb3hjiM+LT9EhdZs2bRpXelBVPzovLw/jxo1DcnIy7O3t8dtvv8HMzAyMMcyfPx+nTp2Cvr4+du3axZXaJZpjamqKgoIC7nczM7Nap6hVBgwYgA8//BDDhw8HAEydOhXXrl2Djo4Od8WJmhi2KW3zUmv9sAqZAtoiIf64lYqVJ2IBBszq54h5r7o0976RBlDXV8rT07O5d61NoHGKNFHTO4jra4uxZUI3dDLVg1AA5JVKsfDXaOy++kgzu0g0ZurUqThz5ky129RNj54+fRqJiYlITEzEtm3bMGfOnObY5ZeCprqeZmRk4O7duxg8eDB32+rVqxEfH48bN24gLy8PX331laZ3n5BWS1dLBKFQgMd5ZZDJlZAqlHicW4qoJ/nIL5U29+6RelLXV4poDo1TpDk0qLGBg4UBtr7dDUY6WmAMqJArsfxYLFYcvcvX/pFG6NevH8zNzavd1lKaALYG9VkkBwAikYhbRzNixAicP38eMTExOH78OAwMDCCRSODl5YUhQ4Zw1cMAVKseVpvffvsNI0eOhJaWFnebqlmUjo4O3nnnHVy/fl2zB03IS2BaHwf0c22PHg7myCqWIGTndQze9DdySyTNvWukgar2lSI10ThFWpMGd1FzszTC9qn+0NP+p7HNrmtPELTmvEZ3jGhWQ5sAtmX1WSQHAHp6etxCuGPHjnG319bxVF31sNrs37+/Rnlg1QDAGMORI0eo6ykhtTAz0Ma2Kf7YO70nbqcWQipXolyqwKbz93ExIau5d4/UU337SrVlNE6R1qRRLZv9Opvhx0ndqyVnpRZI0GX5aQ3tFnlRaluz01YrcaiomwWqD8YYLly4gNGjR1d7vrrqYZGRkZgxYwb3/OTkZKSkpOCVV16p9roTJ06Ej48PfHx8kJOTg2XLljX1MAl5qS14zQXaYiFEQgF+u5GCD/ZF4UL8U7XNvkjLUFtfKVITjVOkNan3AvHa/H7zCT46WD2FKnnNMA3sFmmq5ORkDB8+nFsg7ubmhkuXLnFNAIODg5GQkIDZs2cjODiYu0JR9XFtVX0XyYnFYvj5+UEsFiM0NBRvvvkmcnJy0KtXLzx48AAAkJKSgiFDhnD/DoQ0Utu+AlC3OsepIZv/xoOsEiiUDGKhEK97W+KbCV1f1L6RBmCMISQkBObm5ti0aVNz706LRuMUaYHUjlNNarc6qrstDkSk4MaTyje8PjVvbbFU06OhoaE1mgB+++23GD9+PCIiIpqtCeCLVlfH0/p68uQJrK2t8fDhQwwYMAA+Pj61Tvm39ZkiQprTxnF+WHHsHm49zodIwHAmJhNKJYNQSJ/LlkbVV8rHx4fr0fDll19i6NChzbxnzYPGKfKyaFQaVVUH5/bBnnf88dFrzohe/rom9ok00YQJE9C7d28kJCTAxsYGO3bsaLVNAJ+nPovkoqOj0bt3b3h5ecHX1xe//vort0iuto6n9V0kp+pk6ujoiODgYERFRbXYjqf29vZYtWoV+vfvD0NDQ/j4+ODOnTvYv38/nJ2dYWJighkzZnD7TcjLwt3SGHum9YSntQmYQIARflYUaLRQQUFBYIzhzp073DqDlyHQoHGqfmiceonV1YTjxfUBIaRxFi9ezFavXs0YY2z16tXs3//+d43HJCQksPv37zPGKhsJWVpasvz8fMZY7U2IFi1aVO01Fy9eXOM18/LyuOZC2dnZzNnZmd27d48xxtjo0aPZ/v37GWOMzZ49m23dulUTh9okdnZ2zNnZmcXGxjKpVMomTpzIHB0d2cyZM1lJSQl7/Pgxa9++Pfvll1+ae1dJ7Zq9eV4L/qkXhULJCkql9X04IRpD41T90DjV6qk9T1OwQep0+vRp5urqypycnLgTW0vS0I6njDHm6+vLndRrO4nn5OSwAQMGMGdnZzZgwACWm5vLGGPsxo0bbPr06Ywxxq5cucK8vb2Zr68v8/b2Ztu3b+ee3xI7ntrZ2bGvv/6a+/3kyZMMAMvKyuJuGzNmDFuwYEFz7B55vub+Qt+Sf0gbR+MUjVOkRaBggzScXC5njo6OLCkpiUkkEubr68tdFWkpTExMqv1uampa5+MjIiKYu7s7UygUjLHKk7irqyvz8fFhCxYsaBEnXD7Y2dmxvXv3cr9fvHiRiUSiao8JCQnhBinS4jT3F/qW/EPaMBqnXh40TrV6as/TTV6zQV5e169fh7OzMxwdHaGtrY3x48c3uMuoJmiy4+nkyZPx888/QyisfOtTx1NCCGm9aJwipOWjYIOopYmGf2fOnIGbmxucnZ1rbTokkUgwbtw4ODs7o2fPnkhOTubuW716NZydnZGSkoL169cjJiam2s8bb7xR70VyRUVFGDZsGFatWoVevXpxt1PHU0IIab1onCKk5aNgg6jFWNMa/ikUCrz33ns4ffo0YmNjsX//fsTGxlZ7zI4dO2BmZoYHDx5g4cKF+PjjjwEAsbGxOHDgAO7du4czZ85g7ty5UCgUNbZRn46nUqkUI0eOxJQpUzBmzJhq91HHU0IIab1onCKkFagrx+qFZ3uRFuXq1ats0KBB3O9ffvkl+/LLLzX6/EGDBrGrV68yxhiTyWSsXbt2TKlU1nhs1cdVVZ9Fcnv37mVisZh16dKF+4mKimKMMda/f3/m7e3NvLy82MSJE1lxcXG9j4+QF6i510W05B/ShtE4RUiLofY8TW34iFoBAQFITEzEo0eP0KlTJxw4cAD79u2r9/Nrm96OiIhQ+xixWAwTExPk5uYiLS2t2jSyuqnxdu3aISwsrMbt/v7+2L59OwBg0qRJmDRpUq37eOHChXofDyGEkJaFxilCWj4KNohaYrEY3377LQYPHgyFQoFp06bBy8ur3s9n9ZjeVveY+jyXEEJI20bjFCEtHwUbpE5Dhw5tdAdXGxsbpKSkcL/X1qVU9RgbGxvI5XIUFhbC3Ny8Xs8lhBBCaJwipGWjBeKEN1Wnt6VSKQ4cOIARI0ZUe0zVhXOHDh3CgAEDIBAIMGLECBw4cAASiQSPHj1CYmIievTo0RyHQQgh5CVF4xQh/KOZDcIbddPbn376Kfz9/TFixAhMnz4dkydPhrOzM8zNzXHgwAEAgJeXF8aOHQtPT0+IxWJs3boVIpGomY+IEELIy4TGKUL4J6gt57CKOu8khBDyQlAiuHo0ThFCSPNTO05RGhUhhBBCCCGEFxRsEEIIIYQQQnhBwQYhhBBCCCGEFxRsEEIIIYQQQnhBwQYhhBBCCCGEFxRsEEIIIYQQQnhBwQYhhBBCCCGEFxRsEEIIIYQQQnhBwQYhhBBCCCGEF+Ln3E9dawkhhLRkNE4RQkgLRjMbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhBQUbhBBCCCGEEF5QsEEIIYQQQgjhhfg597MXsheEEELqImjuHWjBaJwihJDmp3acopkNQgghhBBCCC8o2CCEEEIIIYTwgoINQgghhBBCCC8o2CCEEEIIIYTw4nkLxAkhhBBC6iSTyZCamoqKiorm3hXShujq6sLGxgZaWlrNvSukDgLG6izkQVU+CCGk+VE1KvVonGoBHj16BCMjI7Rr1w4CAb1dCf8YY8jNzUVxcTEcHByae3cIVaMihBBCCF8qKioo0CAvlEAgQLt27Wg2rRWgYIMQQgghTUaBBnnR6D3XOlCwQQghhJBW74svvoCXlxd8fX3h5+eHiIgIAMCmTZtQVlbGPc7e3h4+Pj7w8/ODn58fPvjgA+6+BQsW4O+//+Yel5OTU+/tSyQSvPbaa/Dz88Ovv/6qoaOq3fP27ciRI4iNjeV+X7RoES5cuKCx7QcHByMyMhIAMHToUBQUFDT4NS5duoSrV69qbJ9Iy0ULxAkhhBDSql27dg0nTpzArVu3oKOjg5ycHEilUgCVwcakSZOgr6/PPf7ixYuwsLCo9hp5eXkIDw/Hpk2bGrUPUVFRkMlkiI6OrvdzFAoFRCJRo7ZXlyNHjmD48OHw9PQEAMybNw8zZ87EgAEDNL6tU6dONep5ly5dgqGhIQIDA+v9HLlcDrGYvrq2NjSzQQghhJBWLSMjAxYWFtDR0QEAWFhYwNraGt988w3S09PRv39/9O/fv87XOHToEF5//fVqt61duxY9evRAjx498ODBAwBAdnY2Ro0ahYCAAAQEBODKlSvIysrCpEmTEB0dDT8/PyQlJSEsLAxdu3aFj48Ppk2bBolEAqByVuKzzz5DUFAQDh48iKSkJLz++uvo3r07+vbti/j4+Br7lpubi0GDBqFr166YPXs2qhb32bNnD3x9fdGlSxdMnjwZV69exbFjx7B48WJuX+zs7JCbm4vMzMw6/wbXr19HYGAgunbtisDAQCQkJAAAysvLMX78ePj6+mLcuHEoLy/nnqOaZUlOToa3tzd3+7p167BixQoAwDfffANPT0/4+vpi/PjxSE5Oxg8//ICNGzfCz88Ply9frvXvCgArVqzArFmzMGjQIEyZMqXO/SctFGOsrh9CWiwbGxt28+bNWu8LDQ1lGzdurNfrBAQEsJiYGE3uGiGa9rxzdVv+IS1AbGxsg5+jUChZVlEFUyqVTd5+cXEx69KlC3NxcWFz5sxhly5d4u6zs7Nj2dnZ1X739vZmXbp0YV26dGEbNmxgjDE2ZcoUduzYsWqPW7VqFWOMsd27d7Nhw4YxxhibMGECu3z5MmOMscePHzN3d3fGGGMXL17kHlNeXs5sbGzY0aNHWUlJCZs8eTI3JtnZ2bGvvvqKpaSksMzMTDZgwAB2//59xhhj4eHhrH///jWOb+LEiWzZsmWMMcZOnDjBALDs7GwWExPDXF1duePLzc1ljDEWEhLCDh48WO01ZsyYwQ4dOsQYY+yTTz5hR48erbGdwsJCJpPJGGOMnTt3jr311luMMcbWr1/P3nnnHcYYY7dv32YikYjduHGj2t/30aNHzMvLi3uttWvXsuXLlzPGGLOysmIVFRWMMcby8/MZY4wtX76crV27lnu8ur/r8uXLWbdu3VhZWVmN/WWsce89wgu152maiyKtUn5+PtLT0+Hu7l7jvuzsbOzZs4e7CiWRSDB37lycP38eeXl5cHZ2xpdffokhQ4YAqMxl/fTTT/H777+/0GMghJC2SqlkmPBTOG4+zkd3OzPsn9kLQmHjF/saGhri5s2buHz5Mi5evIhx48ZhzZo1mDp1aq2Pry2NKiMjA+3bt69224QJE7j/Lly4EABw/vz5aushioqKUFxcXO15CQkJsLe3h7W1NXR1dRESEoKtW7diwYIFAIC33noLubm5cHBwwNWrVzFmzBhIpVIoFApIpVLcvXsXlpaW3P7cvn0b06ZNAwAMGzYMZmZmAIALFy5g9OjR3LGYm5ur/Rt16NAB6enpAIDPPvus1scUFhYiJCQEiYmJEAgEkMlkAIC///6bW9vi6+sLX19ftdupja+vLyZOnIg333wTb775Zq2PqevvOmLECOjp6TVom6TloGCDtEp3796Fg4NDtRxclV27dmHo0KHciUkul6Nz587466+/YGtri1OnTmHs2LG4e/cu7O3tMWLECLz77rvIyMiAlZXViz4UQghpc3JLpbj5OB9yJcPNx/nILZWivZFOk15TJBIhODgYwcHB8PHxwe7du9UGG7XR09OrUUa1arUj1f8rlUpcu3atzi+/jDEolUro6OjUuiZDIpHAxMQEAGBqaoro/2PvzcPbqq/8/7f23ZZsWbJk7c7ibHZC4qR8yy+Qh28oWym0w1AKBRq2oWWGKbSddIHCtEPpwkzbh+kABQZm2mFroTAUKKVNCgUnsZ3YiROTxZa3xPuuxVrv7w9/7+VqtSTfK1/Zn9fz+ElsXX3uR9LV59zzOee8T1sbgsEgFAoFxGIxgsEgTp06BbVaDY1GA4lEgkAggHA4DLlcnnCeXBWZ5ubmFrxhv//++7Fr1y68+uqr6OnpwUUXXZT2vUiHVCpFPB5POB/N73//e7z33nt4/fXX8b3vfQ/Hjx9PeX6291Wj0WQ9N0HYkJoNQkly9OhR1NbW4p577kFVVRWsViv++Mc/AgDeeustXHjhhcyxGo0GDz74IFwuF8RiMa688kq43W60trYCmO9AunXrVrzzzjtL8loIBAJhpWHUyrHVaYBULMJWpwFGrXzhJ2Xh5MmTOH36NPN7W1sbnE4nAECn06VEHtKxbt06JiJOQ6tKvfjiizj//PMBAJdccgkee+yxhHMlU1dXh97eXgwNDaGvrw8/+9nPsGrVKszMzAAAZmdnodPpUFZWBrfbjZdffhkqlQoikQjt7e3MjT1d57Fz5068++67mJmZwVtvvYXJyUkAwMUXX4yXXnoJ4+PjAOaL3DO95lOnTiXUVKRjenoaNTU1AOY37mh27tyJX//61wCAjo4OHD16NOW5ZrMZIyMjGB8fRygUwhtvvAFg3ono7+/Hrl278KMf/QhTU1Pw+Xwpc8zlfSWUJsTZIJQkR48eRUtLCy6//HIMDw/jzjvvxA9/+EMA81GPtWvXZnzu8PAwTp06hQ0bNjB/W7duHdrb23mfN4FAIBDmd8mfv/0TaPrmxXjhjk8sul+Cz+fDzTffzBQhnzhxgilOvuOOO3DZZZclFIjv2rWLkb6li46vuOIK7N+/P2HcUCiEHTt24Gc/+xn+7d/+DcB8sXNLSwvq6+uxfv16PP744ynzUSqV+OEPf4i///u/x2WXXYbKykrcddddGBwcBDBfcK1UKgEAv/71r/H000+joaEBa9aswX/8x3+go6MDMpmMiX5897vfxeHDh7Fr1y688847cDgcAIANGzbg29/+Ni688EI0NDTg3nvvBQB8/vOfx49//GNs2bIFXV1diEQiOHPmDLZt2wYAeOCBB/D666+nzPsb3/gGvvnNb+KTn/wkYrEY8/e77roLPp8P9fX1+NGPfoTt27cnPE8kEkEmk+GBBx7Ajh07cOWVVzJpzrFYDDfeeCM2bdqELVu24Ktf/Sr0ej0+/elP49VXX2UKxHN5XwmliYhiKRqkIeuDBMJScf755+Paa69lFtaXX34ZTzzxBN59913IZDIcO3YsbT1HJBLBZZddhtraWjzxxBPM37/97W9jcHAQzzzzTNFeA4GQB6RzVWaInRIAnZ2dWLdu3VJPY9FccMEFeOONN6DX6xc9VmdnJwwGA6qrqwHMRx1GR0exdu1atLa2Yv369WlThiiKgs/nw+zsLKqrqyEWz+8Lnz17FpFIBC6XK++5vPrqqzh8+DC+973vLeo1JROLxWAymTA0NASZTMbp2LmyXK69ZUBGO0UiG4SSg6IodHR04NOf/jTzt46ODkZP3GAwpA2Zx+NxfPGLX4RcLk8I1QLzIW0ujAuBQCAQSpdHH30UfX19ix6HoigEg8EEuxIMBhnnQiKRJNQ3sBGJRNDpdIhEIhgdHWX+vpieHNFoFPfdd19Bz83Ghg0bcNttty2Zo0EoDUiBOKHk8Hq9AIBVq1Yxfzty5AijcFFfX49Tp06hsbGReZyiKNx6660YHh7Gm2++mbIwdnZ24sYbbyzC7AkEAoEgVHbs2MHJOHRDQbrvBwAEAgFGRYouRs9W+ExRFFOzAcwXXGdTm8rGtddeW9DzFiJdTxACIRkS2SCUHEePHsWmTZsScnyPHDmChoYGAMDll1+Ov/zlLwnPueuuu9DZ2Yn//d//TQlbh0IhtLa2Yvfu3fxPnkAgEAjLnkAgwBR807AjG+Xl5QkR+EgkgomJCcRiMVAUhenpaUxMTKCsrAzAfGTe7/czvxMIpQSJbBBKjmPHjjGOBQCmKyqtsnHTTTdh8+bNzMLe29uLJ554AgqFgsmdBYAnnngCN9xwA15//XVcdNFFsFqtRX8tBAKBQFh+BIPBBGn2aDSKSCTCOBuVlZU4ceIE4vE4U5MxMjKC3t5eUBQFhUIBu93OpGFNTU1Bp9MlyN4SCKUCKRAnLEu+9a1vwWQyMQ2UsrFjxw48/fTTC0oCEghLCCkQzwyxUwKAFOnmz8DAAGQyGcxm84LHdnZ2wuVykcZ2aSDXnmDIaKeIs0EgEAjChzgbmSF2SgCQGz7CUkGuPcFA1KgIBAKBQCAsX/7lX/4FGzZsQH19PTZv3oyDBw8CAH76058iEAgwx7lcLmzatInps/EP//APzGP/+I//iPfeey/reT766CNs3rwZW7ZsQWtrK37xi19w+jr279+PK6+8MusxDz/8MPP/cDiMnTt3IhqNcnLO119/HY888khB47DnRSDQEGeDQCAQCARCSdPU1IQ33ngDhw8fxtGjR/Huu+/CbrcDSHU2AGDfvn1oa2tDW1sbfv7znwOY74Nx4MAB7Ny5M+u5fve73+Ezn/kMjhw5gsrKyrydDYqiMsre5gr7pl4ul+Piiy9mup0vlquuusW/flUAACAASURBVAp79+5d9Lxyhd08kLA8Ic4GgUAgEAiEpWFsjJNhBgcHYTQaGalZo9EIq9WKn//85zh37hx27dqV0EE8Hb/5zW9w6aWXMr//8z//MxobG7Fx40bccccdoCgKb775Jn7605/iqaeewq5du7B37150dXVh8+bN+PrXvw4A+PGPf4zGxkbU19fju9/9LgCgp6cH69atw5e//GWcd9556O/vTzj322+/jbq6OlxwwQV45ZVXmL/7fD586UtfwqZNm1BfX4/f/va32Lt3L4LBIDZv3owbbrgBAHD11Vfj17/+ddrXddddd2Hbtm3YsGEDM59s53z22Wdx9913AwBuueUW/OY3v2Ee02q1zPu9c+dObN68GRs3bsT777+fdl6/+tWvsH37dmzevBl33nkn41hotVqm23hTU1PWz4WwDKAoKtsPgUAgEJaehdbqlfxDEAAnTpzI/0l9fRQllVJUf/+izz87O0s1NDRQq1evpu666y5q//79zGNOp5MaHR1N+H3jxo1UQ0MD1dDQQP3rv/4rRVEUddNNN1Gvv/46c9z4+Djz/xtvvJF57Lvf/S714x//mKIoivJ6vdSGDRuY4/7whz9Qt99+OxWPx6lYLEZdccUV1F/+8hfK6/VSIpGIampqSpl7MBikbDYbderUKSoej1PXXnstdcUVV1AURVHf+MY3qHvuuYc5dmJigqIoitJoNAljRKNRymg0Mr83NDSkvI5oNEpdeOGFVHt7e9Zz/ud//if1la98haIoirr55pupl19+mRmLPu9PfvIT6vvf/z4z7szMTMq8Tpw4QV155ZVUOBymKIqi7rrrLuq5556jKIqiAFAvvvhiyntRCAVdewQ+yLhOE+lbAoFAIBAIxSMcBq6/HvjoIyAaBS69FFi7FnjhBaDATtRarRatra14//33sW/fPlx33XV45JFHcMstt6Q9ft++fTAajQl/GxwcRFVVVcIxP/rRjxAIBDAxMYENGzbg05/+dNZ5vPPOO3jnnXewZcsWAPORidOnT8PhcMDpdOITn/hEynM++ugjuN1urF69GgBw44034sknnwQAvPvuu3jhhReYY+mmgMlIJBLI5XLMzs5Cp9Ohra2Neeyll17Ck08+iWg0isHBQUZyN9M5c6GxsRF79uxBJBLB1Vdfjc2bN6cc86c//Qmtra1Mg91gMAiTycTM93Of+1zO5yOUNsTZIBAIBAKBUDzkcmDVKoBO3Tl+HLjiioIdDRqJRIKLLroIF110ETZt2oTnnnsuo7ORDrqrNzDfrfvLX/4yWlpaYLfb8eCDDzKPZYOiKHzzm9/EnXfemfD3np6erN3C2c3/ksfL9FgyoVAISqUy4W9erxc/+clP0NzcDIPBgFtuuYV5HbmMK5VKmfoSiqKYzug7d+7Ee++9h9///vf44he/iK9//eu46aabUuZ+88034wc/+EHKuEqlEhKJJKfXRSh9SM0GgUAgEAiE4nLvvR//XyRK/L0ATp48idOnTzO/t7W1wel0AgB0Ol1Ct+5MrFu3DmfOnAEA5obcaDTC5/Ml1C2wSR77U5/6FJ555hn4fD4AwNmzZzEyMpL1vHV1dfB6vejq6gIAPP/888xjl1xyCR577DHm98nJSQCATCZDJBJh/j4+Po6qqirIkhy2mZkZaDQalJeXY3h4GG+99daC52TjcrnQ2toKAHjttdeYc/b29sJkMuH222/HrbfeisOHD6fM6+KLL8ZvfvMb5vVPTEygt7c363tBWJ4QZ4NAIBAIBEJxmZwEbrwR6OwEbrhh/vdF4PP5cPPNN2P9+vWor6/HiRMn8OCDDwIA7rjjDlx22WUJBeK7du1ipG/pHfkrrrgC+/fvBwDo9Xrcfvvt2LRpE66++momFSiZyspKfPKTn8TGjRvx9a9/HZdccgm+8IUv4Pzzz8emTZvwN3/zNws6OkqlEk8++SSuuOIKXHDBBYyTBADf+c53MDk5iY0bN6KhoQH79u1jXlN9fT1TiL1v3z5cfvnlzPPotKaGhgZs2bIFGzZswJ49e/DJT35ywXMCH0c9br/9dvzlL3/B9u3bcfDgQSY6s3//fkb+97e//S3uueeelHmtX78e3//+93HJJZegvr4eu3fvxuDgYNb3grA8IU39CAQCQfiQpn6ZIXZKACyXxmoXXHAB3njjDej1+qWeSl589rOfxQ9+8AOsXbt20WM9+uijmJmZwUMPPcTBzPhnuVx7ywDS1I9AIBAIBAIhG48++ij6+vqWehp5EQ6HcfXVV3PiaDz++ON49tlnceONN3IwMwJhHhLZIBAIBOFDIhuZIXZKAJDdZcJSQa49wUAiGwQCgUAgEAgEAqG4EGeDQCAQCATColkgU4JA4BxyzZUGpM8GgVAEKIpCPB5HPB5HLBZDPB5HNBqFSCSCUqmEVCrNWUudQCAQhIZSqcT4+DgqKyvJWlai0Dfuyf8C8+pU9I9QoCgK4+PjKb1FCMKD1GwQCBxBUVSCU0E7FrFYDAMDA7Barcxx9IItFosZXXSpVAqJRAKxmAQcCSkIx8ILD2KnBEAkEsHAwEBOje8ISw/73o/+fywWy9hoL9nJEIrToVQqYbPZUvqLEJaEjBcFiWwQCHnCdipoZ4KOVrB3hNg7QYODg7Db7SnjiEQiiMViUBSFaDSKaDQKiUTCRDqEsqATCARCNmQyGdxu91JPg/D/SLZTbHsVj8cTbAtta5qbm7F9+/a0Y8nlcub/wMcbZcROEXKBOBsEQgaSU5/YC3UybMci3cK70GJMP4+iKMRiMXR0dGDDhg2QSCSQSCRkMScQCARCCulSdGlblQxtZzLZlHzsVDweRygUglgsJnaKsCDE2SCsaNKlPkWjUUxPT4OiKGi1WuY4eqEVi8W8Lar0OejzRyIRRKNRJsWKLOYEAoGwssiUouvz+TA3N4fy8nLmuGLaKXpexE4RFoI4G4QVQaZaCnbqE41IJMLMzAxEIhGziC8F7AWdXszZKVYEAoFAWD7km6Lr9/sxOzuLiooKXucEpI960H9j26lIJAKpVErsFCEB4mwQlhW5pD4l11OkK8gW0iLJdjroug5STE4gEAilCVcpukK3U/TmGLFTBOJsEEqOdIVvkUgE4+PjMBgMCccuJqQspIUcyL6YkyI9AoFAEA6ZUnRHRkYSIhHFSn1aDPnMKbn+MBaLQSwWM06HEF8fgX+Is0EQLJlSn9IVvkWjUfT393Om8c6Wpy02CzUpSl7MR0dHoVAooNfrSb4sgUAgFJF8U3R7enpgNBoFuU5TFIVwOAy/3w+/349AIAC/349oNAqr1Qq73Q6pNLfbxuRi8nA4jEgkAoVCAblcLsjXT+AP4mwQlhx6kWbvhGRLfUq3O0IfW2oLWKb55vI66PdjamoKWq0WGo2GFOkRCAQCD3CVogtwa6cKGYuiKASDQQQCAcahoP9/4sQJqNVqaDQaVFVVwel0QiKRYGRkBAcPHoTRaITT6cy5kR7b6ejt7UV5eTlMJhOpP1xhEGeDUBTSFb5NTk5Cq9Vm7E2RT8hVyAtW8u4WXUjn8/lAURTMZnOCUVoospEOdr8OUkxOIBAI+ZMuRXdychIajSZtlELIqU/AfJO+YDCYEKkIBoMA5pvh0U6FXq+HWq3GkSNHsHnz5oQxaLvscrngcDgwNDSEI0eOQKfTweVyMYqNC8FuZAuA1B+uMIizQeCUfArfPvroIzQ2NnJWb1DITTqfUBSFubk5+P1+hMNhdHZ2IhAIIBaLQSaTQa1WQywWo7u7GzabDTU1NUyIOp/3g53yRYrJCQQCITv5pOh2dnZyaqe4hLZ5kUgkIULh9/uZHhhqtRpqtRo6nQ5msxkqlapgWyAWi2G1WmGxWDA+Po7Ozk5IJBK43W7o9foF35/kDUVSf7hyIM4GIW8yFb7R/2cfl233Z7ksKvF4PGX3KBAIgKIoZvdIJBKhpqYGarWacSgoimIW/YGBARw8eBAmkwk2m61gZ4Mm3WJOOr4SCISVBBcpukJZLymKQigUSnAqpqamEIlEmOiLWq1GRUUFbDYbFAoFr302jEYjjEYjZmZm4PV6cerUKbhcLphMpoznTbZVmYrJSZPA5QdxNggZYTsV0WgUc3NzkEgkGQvfhB5SXizRaDRl92hubg4ikYjZPaLzXOmoBTBv8KamplBWVpZ2XJlMBrfbDafTiXPnzuHw4cMIh8MIBAJQq9ULzitbRCe5SC8UCsHv96O8vJykWBEIhJInOfUpGAym2KnFpOgWG3rzKrmWIh6PQ6FQME5FdXU1ysvLEQwG4Xa7l2y+ZWVlaGhoQCAQQG9vL7q6umC322G1WiGRSBKOzWSr2HaKNAlcnhBng5BT6lMkEsHx48exZcuWrIVvpQ690AUCAaauIhAIIBwOQyKRMA5FeXk5rFYrlEolZwuhWCyGzWaD2WzGwYMHcezYMSgUCrjd7gWbCy40B/Zi3tHRgcbGRsRiMbKYEwiEkiDXFN3W1lZs27YtY28KoRCLxRI2rgKBAObm5gAAKpWKsTVGoxEqlSrlxh0AwuFwsaedEbVajXXr1iEcDqO/vx9NTU2wWCxwOByQyWTMcdk+D3Y6MKk/XF4QZ2OFkJz6xF6s00UpACTs/tDHLBcng66noBd6erGn6ykoioJCoUBVVRU0Gg2TflToufJ9rlwux/bt2zE5OYmuri7EYjG43e600r75jJ9cpEc6vhIIBKHARYqu0DbDaClZtlNx6NAhZvNKrVajvLwcFosFKpWq5NdguVyO2tpauFwunD17Fs3NzTAYDHC5XHnbKlJ/uHwgzsYyI5/CN/bOTy4746XIQvUUdEg6uZ5iYGAAEokkpUlgsaDfb4PBAIPBAJ/PB6/Xi9OnT8PpdKK6uppZcPN1ZrIV6ZHFnEAg8E06dcJsvSmEnvq00OYVbWeqqqowOTnJFJwvZyQSCRwOB+x2O4aHh9He3o5wOIzy8vK87CopJl8eEGejRFkopDw8PIx4PA6LxcLJQk1/2YVKLBZDNBrF4OBgXvUUmVjK15ru3FqtFps2bcLc3Bx6e3vh9XoZBatCyFSkR4rJCQQCVyxkpyYnJzEzMwOn07lgbwohEI/H0/amWGjzio2QnSY+EIlEqK6uhtlsxuHDhzEwMIDBwUG43W5UVFQUFOkgxeSlB3E2BEw6zW92SJn+4mUqfKMoKm2eZ6lC53Amh6TD4TDEYjHToZSPeorFzjvfeWQ6XqlUYu3atfB4PBgYGMCBAwcgFotRWVm56HmmKyYnizmBQMjGYlJ0xWIx4vG44OxUNBpl7EsoFEJ7ezuzHqpUKmg0Gmg0GphMpkVJyXJBqazLIpEICoUCq1atglgsRk9PD6NgldxraqFxaDsVDodx4sQJNDQ0kPpDgUOcDQGQvFCzF+xk6C/aQl8qrr9wxYxs5BKSpqMUdD1FPB5HW1sbHA5HUebIJ7k4J2wFq+bmZpw8eRJjY2NwuVw5KVhlI1kZpLW1lSzmBMIKh68U3aWKItM3q8mbV3QNGx0Nl0gkWLNmjWA2r9gIOdsgHbRt0+l0CZH6dL2mFoL+LCKRCPMvKSYXLsTZKBLpCt/YIeWuri7U1tYuqPmdK0JPewLm3xPamSg0JL0cyedzE4vF0Gq1qKmpQTgczkvBaiHoay8QCAAgxeQEwkogW+oTH3aKb+LxONNcle1U0FKydJqt2WxmNq/YDA8P89qzYiWRvJHGjtT39/czvaacTifkcnlO49HXH6k/FDYr4+6tiBRa+DY1NcVpKJlrZ2MxC22m/hSBQAA9PT1511OUGlymUWUb32QywWQy5aRglS/ZivSW2+dFICx3Ck3RnZ6eFqydisViTGSiu7ubsTMAEjavKioqoFarBZe6tZKRyWTweDxwuVw4d+4cWlpaoNfrF4zUZ7qnIvWHwoM4GwWSq+Y3kOhUZKKU056A9PUUfr8fkUgkY3+KlpYWbNiwoWhzLBXy/dySnZlcFKwKJVORHu10kMWcQBAOfKTockkhdoq2M+xoOF1PoVarEY/HodPpUF1dDaVSSTZDBMRCG290r6mamhqMjo6io6MDcrk8Y6SejmwkQ+oPhQdxNrKQSfN7eHgYBoMh5SIXkjwfX85GPvUULpdrUf0plguFfA6FRDaSyaRgxcV1kVzXEQ6HIRKJSF0HgVBkMqXojo6OQqvVMumnXKU+FRKpzUQmO8W2M2xbQ9sZevOqsrISDocDcrmcmVNzczOqqqo4mV+2ORLyJ9drhx2pn5qaQnd3N6LRKFwuF4xGY4IIzkK1q2w7RTqTLx3E2UD+hW8DAwMwGAyCDsMudoFM15/C7/ejubl5RddTFEq+zgOXJOfF+v1+JtqRS15sNpJfVyQSwfj4OMrLy0meM4HAIfmm6A4NDcHpdEKhUHA2B3Z6FRfQGxUjIyOMjQkGg4jH41AqlYxTYbFYoNFoiJ1ZBuR77ej1emzZsgV+vx9erxdnzpyBw+GAxWJJm0mS7Zz09UvqD4vPivrm5pL6lMvuTylcmLk6G5nqKUSi1P4Ufr8f27dvL8LshcFSfs5cRDaSofNiBwcHoVKpcs6LzQX2Yt7d3Y21a9eCoihSpEcg5EkhKbrp8tHFYjHnGxeFbmJlsjN0Oqbf74dGo4HRaFyWdXulDpfOZaFoNBps3LgRoVAIvb29aGpqKkjynRSTLw3LztlI3v2Zm5uDRCJhFmv2l6bQkDKtDS5k2EahkHqKUnOyuJ4bl0a6kA7ffI4vEokS8mK5VLCi50OHqEnHVwIhPexoOr3BkxylWEzqEx/pP9nGpKMUyU5Fsp3R6/WMnaFFQtxuN6fz5BKSRsUdXETFFAoF1qxZA4/Hg66uLoyNjeHkyZNwOp1QKpU5j0OKyYvLsnM2nn76aYRCIdxwww0AgMOHD+O8885jioO4uICEuviw81xHR0cxPT2N6enpFVNPIcTPZCHSvf98q1exn8OHglWyig3p+EogJPLWW2/hgw8+wNe+9jUAQEdHB1avXg2VSsXZjQ5fkY1MXbRjsRjkcjmTYkvbmWypmkK1paVEKa2jXKbgSaVSWCwWhMNh6HQ6HDlyBDqdDi6XC1qtNudx0hWTT01NoaqqitgpDll2zkY8Hoff72fqKdgazFyx1JGNdPUUyf0ppFIpNBoN6urqSJ5rCVLsGo90Clau/9fZNV+SFUJIkR6BkIrP52PsFP0vl98F2jEolFgslmJnZmZmcOTIkYQUW4PBsKi6vVJwNoQ6R6HOq1jQtsZqtcJisWB8fBydnZ2QSCRwu90wGAw5j8W2U52dndDr9cROcciyuwtVKBQIh8PM7/SCy2UuHp9KT+wLOp96iuQ816mpKYyMjBBHQwAILY0qG8kKVt3d3QnOwWLmk65Ij3R8JaxE5HJ5ip1aqvqKSCSSYmfYUrJqtRo6nQ5msxmxWAx1dXWcFZ3z9Z3nWjFrJUOnpCc3OywELj8XAAmp8SKRCEajEUajEdPT0/B6vTh16hRcLhdMJlPO52WnLZJicu5YdneiCoUCoVCI+Z2PKMRid4zYsG+6BgYGmJ2kfOsp0s1xpe96lDJ8FIjnA61g5Xa78cEHH+DAgQMwm805KVgl10alg72LNDExAZ/PB4fDQYr0CCuCYtgp9pgURSEUCqU4FfQmArvhnc1my6gkx/U8iZ0SDtFoFLFYDENDQwnKYPRardVq4fF48kpRSoYPW5VuvPLycmzevJmpCerq6oLdbofVas1LRTRdXQdpZlsYy87ZkMvliEQizO985K0WMuZC/SlomV2u6inIIi4cCrlWhIJMJoNSqcSOHTty7uyaj0ERiUTMziopJiesFBQKRYqd4uImnk6xDQQCmJ6extTUFHp6ehCPx6FQKBinorq6Gmq1Ou/daq7tCp8RHS4jG0JakxcL3Wmdvg+hMybEYjHC4TBCoRDKyspgsViYgmuRSITZ2Vl0dnZCKpXC4/EULCbCdWQjG2q1GuvXr0c4HEZfXx+amppgsVjgcDgyXvvpPutM9YekmW3uLDtnI3nHiMsoBHvMTItPLvUU6fpTHD58GBaLhbO0p+W2QJY6fBZ887FblDw2u7PryMgIo2Dl8XhQVla2qPnQaY60E0+KyQnLHblcnhLZyGe9puVi2ZGKubk5AIBKpYJGo4FMJkNZWRlqamo46wlVCs4GYZ5sTkW6jAmKonD48GE4nc6Ecej1vLKyEpWVlZiamkJXVxfi8Tg8Hg8qKipynhMfn3UuEQa5XI5Vq1bB7Xbj7NmzOHToECoqKuByuaBSqVLmmMneJBeTh8NhYqdyZFk6G+xcWL7C05FIBDMzMwXVU6SDLOLCg++Fg16w0v0933FynWu+Y6eTizabzTCbzZicnMSZM2fSKlgV6iyRYnLCSiBTbSGbdJLlgUAA4XA4pxTbvr4+yOVyTpvPloKd4mOOQoaiKOZehP6ha25oBUq23HCm15Pre6bX63HeeedhdnYW3d3dOH36NDweT0Jn72xz5atmIxckEgkcDgfsdjuGh4fR3t4OtVoNt9sNnU6X8xwz2SlSf5iZZelsLGbHiE2m/hQ+nw8TExMoKysrqJ4iHaWwiAsZIX+56QK70dFR5hqiu+RSFIXq6uqUWgi+IiFcyupmUrAqxKFJdsZJMTlhOaNUKhk7RUfzpqam4PP5UlJs2VKydMRiqer2SsFO8TGmEGwpWzCG/QMAwWCQUQbLVnPDJTqdDg0NDQmdvd1uN8xmc1aHhst5FTqeSCRCdXU1s2l26tQpUBQFt9uNsrKyvNKA6X+TmwQSO5XIsnM2kms2ckmjWqieIrk/RV9fH/R6PYxGI2fzLoVFXOhw3YivkOewU+jo6ygejyMajWJ2djahSy4w7wwPDw+jubkZlZWVcLvdvNZ4FJLitNDxyQpWfr8fvb29sNlsOe2qLjSndEV6pOMrgQ/6+/tx0003YWhoCGKxGHfccQfuueceTExM4LrrrkNPTw9cLhdeeumltLKazz33HL7//e8DAL7zne/g5ptvZh6jKAodHR346KOPcOjQIXi9XjQ2NuL++++HyWRi1obkFNtC4SuqT+wUv0Sj0RSHgo5m0fciFRUVsNvtmJiYQCQSgcPhWPR5C71xpzt7z83Nwev1oru7Gw6HA1arNWV9LlaBeD7PraioQEVFBWZnZ+H1enHy5Emm2WY+9iVbMTmpP1yGzkY2lY9C6ymSkUgkvDVL4hKyiPNDJqcCAHMdsZ2Kubk5dHd3w+PxJIxDL2Z2ux01NTUYGhpCa2srlEplXjca+aZR8VUPQitYjY2NIRaLMQpWDocjq4JVrudgL+bt7e1wOp0oKysjHV8JnCGVSvHoo48yaSJbt27F7t278eyzz+Liiy/G3r178cgjj+CRRx7BD3/4w4TnTkxM4KGHHkJLSwtEIhG2bt2Kq666inFKRCIR/v3f/x0OhwMbN27Ehx9+iN/97ndQKpXo7e2FUqksqK9NJopdryiE8fgYk691hS05nMmpqKysZNbPdPMQ0pqnVCqxbt06hMNh9Pb2oqmpCTabLedNp0LIN40qGzqdDvX19ZienkZbW1vB8yfF5OkpmrOxZ88evPHGGzCZTOjo6AAAXHfddTh58iSA+b4Qer0ebW1tKc91uVzQ6XSMl9jS0pLxPLSz8d5778HpdGJmZgazs7OIxWIF11Mks1IXyGL0FhESFEWlGINsTkWm6yiX18huTNTd3Y3e3l4cO3YMHo8HGo1mwXkKwdmgEYlE8Hg8cLlcOSlYFbKDRD+H7vhKivQIXGCxWGCxWADM33ysW7cOZ8+exWuvvYb9+/cDAG6++WZcdNFFKc7GH/7wB+zevZspmN29ezfefvttXH/99cwxjz/+OADA7/fjF7/4BaP2I3SJdj7H5MuuCGU8OhWbbUMOHTrESA7TToXT6Vy0CqUQkMvlWL16NdxuN6MAZbVa4XA4BBfZSIdCoYBWq0V9fT36+/tx4MABmEymnGTfk+fFrusIBoOYnJyExWJZkXaqaM7GLbfcgrvvvhs33XQT87cXX3yR+f99992XVUpt3759GdOWYrEY7r33XnR2dmJgYAB+vx9PPvkk/umf/glKpRIVFRWwWCycfbgkPL28SBepmJqagkgkgk6ny9mp4AKRSASDwYBQKASTyYTjx49DLpejtraWKWDL9LxcKIazQZOrghVFUXm/p8kKVqSYnMA1PT09OHLkCHbs2IHh4WHGCbFYLBgZGUk5/uzZs7Db7czvNpsNZ8+eTTt2unRfIUi0L0QpbIot1fc+2amg+2WxnYqqqipMTk5i+/btSzLHbHDtCNASuU6nEwMDAzh48CBCoRAikUheN+3Z4DKywR5TLBZDJpPltWmWCXp+8XgcfX19MBqNK7L+sGjOxs6dO9HT05P2MYqi8NJLL+HPf/5zQWNLJBJce+21WL16NSKRCL70pS/hV7/6FQDA6/VyvltQKpENPubINcWMbOST/qTRaKBSqThNa8gHkejjbqiTk5M4efIkxGIxPB4P9Hp9wrF8OpVcfD4iUXYFq0KcDfZz0hWTk46vhMXg8/nwuc99Dj/96U9TpJ0zkUmfPx0SiSRhw6qUIhul4GzwaUvD4XCKUxGNRtPWd6a7qV5pdWYSiQROpxN2ux3vvfceWlpaYDAY4Ha7mcheofBx/5A8JnvTbHR0lNk0c7vdefUaSd4gW2n1h4Ko2Xj//fdhNpuxevXqtI+LRCJccsklEIlEuPPOO3HHHXekHHPBBRcAAMbGxlIkBfnYMSqFRVzokQ2uHUCaTE4FRVGMBv1CkYrx8XHO5rfYaILBYMC2bdswPT2N7u5uRKNRRt+c/pyFGNlIRzoFK5VKBZPJlNc4mXa0SDE5YbFEIhF87nOfww033IDPfvazAACz2YzBwUFYLBYMDg6mvV5tNhuTagUAAwMDuOiii9KeI3l9FovFiEajnL6OUohsCBW2EmUwGER3dzdCoVCKU2E2mxmFsFKHhrXHgAAAIABJREFU789VLBZDLpfj/PPPx/DwMI4cOQKdTge3271gqnAmiuFs0IhEIphMJphMJkxOTjK22OVy5S37uxKLyQXhbDz//PMJea3JfPDBB7BarRgZGcHu3btRV1eHnTt3pj22GH02SmXHaLnXWCQ7FcFgEM3NzXk5FdnGXkrSvcfl5eXYsmULo29OSw3yqUbF1+fNVrBqb2/HqVOnEIlE8lKwyvZ5plvMo9Eocx0I5RomCAuKonDrrbdi3bp1uPfee5m/X3XVVXjuueewd+9ePPfcc/jMZz6T8txPfepT+Na3voXJyUkAwDvvvIMf/OAHOZ23FDaw+BqTa/KZI0VRCZEKukYvGo1CLpczN8FGoxEVFRXLwqnIRjHWRZHoY9nZsbExdHR0QKlUwuPxZE0VTkcxnQ029KYZW/bX4XDAYrFktEuZJN7TFZMvx/rDJXc2otEoXnnlFbS2tmY8xmq1AgBMJhOuueYaHDp0aMmdDaEv4qXgbOQ6x1wjFXK5HFu3bi35HeyF3hNa3zwQCKC7uxuBQADDw8NZ9c3ZYwvB2aCha6q0Wi2CwSCamppQXV29oIJVrrm67MW8ra0NDQ0NUCgUy3IxJyyeDz74AP/93/+NTZs2YfPmzQCAhx9+GHv37sXf/u3f4umnn4bD4cDLL78MAGhpacHjjz+Op556ChUVFbj//vvR2NgIAHjggQeydldmRyX5simlYPu4Jt0ck50K+icWizFOhUajQXV1NTQaTYIaYEdHB3Q6nWAdjVJdw0QiEaqqqlBVVYWJiYmsqcKZ4MM+5SNYQsv+hkIhRoHLarXCbrenKEpmm2tyMflyrD9ccmfj3XffRV1dHWw2W9rH/X4/4vE4dDod/H4/3nnnHTzwwAMZx5NKpQnhaL6KuYUeLSmVmg02+UrKJi8IfX19gnQ0+LrBV6vV2LhxI6amppiwrtPpzLq7IjRngz4HXUyYazFeIQpWdDRkuS7mhMVzwQUXZFw3//SnP6X8bdu2bXjqqaeY3/fs2YM9e/YseJ50aVRCFx2hx+R6nlxC7xBPTU0xTVTpnlkKhYKRt7dYLClORSnC5ee7lE4k3esiU6pwJgqp91uIQmyeQqHAmjVr4PF4mGL4qqoqOJ1OKBQKALnZrHT1h8ulmDzrN61nzAeXUcvJia6//nrs378fY2NjsNlseOihh3DrrbfihRdeSEmhOnfuHG677Ta8+eabGB4exjXXXANgPgryhS98AZdeemnG8yR/GKUQhQBKQ42KqzFppyISiaC3txfBYLAgSVnCPGKxGOvWrUvYXaF7dySnJPHtbBRyfbANRj4KVvkuvPF4nHEsSDE5QUgIeb3me8xCoCgKoVAoJVIRj8cRDoehUCig1+s5aZAolNdcDLLtvBcDOlXY5/Ohu7sbp0+fhsfjQVVVVdo5LFUaVSakUilcLhccDgeGhoZw+PBh6HQ6uFwuTpoElnL9YdZvYPeYnzNn4/nnn0/792effTblb1arFW+++SYAwOPxoL29Pa9zJSsJlEpkg+sFbakXyIUiFbFYjCkOXs5ORb6fQ6GLHb274na7GaejpqYmIaRbDGejECcg3SYBW8Hq9OnTiMfjjIIVfUw+JM8tW5Hecr0WCcKB2KmFoSgKc3NzjO3w+XwIBAKIx+NQKpVMz6yamhpoNBpIJBIcP34cDoej4KJjQirF3oSh+1wEAgF4vV50dXXB6XSiuro6YW1e6jSqTLD7Zo2Pj6Ozs5OJruVLOjtFS/OWUjF5VmdjozV3WS8hQee9iUSikllw+ajZ4JpMcyw0/enw4cOoqqoq+VB2LhRzQZDJZFi1ahVcLhfTlMhisRTUVKkYzsZCzzEYDNi6dWuCglUkEinIKCykYEU6vhKKCR1tW6l2iobtVLBtCO1U0DbEbrdDrVbz1pF6JZNtHV6qjUu1Wo0NGzZgbm4Ovb298Hq9cDgcqKmpYbJBhBTZSEYk+ljCvre3F319fTh48CBcLhdMJlNe52HbqVJsZpv1Ls9UtjgN5KWgVNOoSsHZoKj5jtrs8PVi05+WOvqy1PAZtpZKpXC73XA4HDh79iwOHTqE8vJyxGKxnMcoVmQjl2uFrWD14YcfoqmpCTabLWcFq4VIXszD4TDC4TCUSiXkcrngF3NCaUE39uPL2RBibWHyxhSt/tTc3AyVSsVEKioqKgp2KkpFbIWQO0qlEmvXrk3oSl5TU4NYLCZoZ4ONWq1GdXU1ampq0NPTg66uLjgcDlit1oLTq+hU4EAgAJlMBqVSKVg7tSy3lEl4enFkilQEAgH09PRAq9VyUlMh1C8F1yx1UbZEIoHD4YDNZkN3dzeGh4fR2dmZU1OlQuZeSIO+fM6hVCqhVCrR2NiI/v7+nBWscoW9mHd3d8NsNjOyl2RHlcAVCoUCoVCIuUEQ+gZWPmPmqiBoNBrh8/kE2VGbIDzkcnlC1L6/vx+VlZWorKzkTC2ML2eDThdWq9VYv349wuEw+vr68OGHHzIKVvm8BnYx+cDAAFQqFSwWi2Dt1LJ0NvhW+SgVw7AQ+aY/HT16FHV1dZzc0JUCS+UM8XUdiMViVFVVIRgMwmAwME2VPB5PWsUnei75vA+5StIu5hw0MpksLwWrfKF3cek0v5XiHBOKg1wuRygUAlA6alTJdioejzMCH3Q9Rb7Rbq6/V0LauCsliqE8yBV01D4cDiMajeLQoUMwGo1wuVwF1UWw4aJmI5dxacfJ7XYzmQeVlZVwOp1QqVR5jU1RlCAdDDbL0tkAPv7i8KUcJbTwdDYWKynLniOXCNkoLPW8+Fr06cgD3VRpdHQUx44dg0qlgsfjgVarTTleKGlUmUinYKVUKuF2uxMUrAqBnlspFeIRSgO5XM70hOLLMeDKptBOxezsLHw+H2ZmZhAMBgEgIVJhMpmgUqmWVGCBpFGtHESi+a7e69atw9DQEFpbW6HX6+F2u/O+Yafhy+nKNC6deWC32zE8PIz29nao1Wq43e6cmxyWgp1als4GnQurUChKJrLBhbFJdirojtoAd5KyZNHNn2LIxxYyF3qhppsqdXZ2Mv0uysvLU47PdXy+06gykYuCVb7wtctFILAb0PKx2VSInYrH40x0gm1HADA3bzKZjLmZI9+NpYerm0v2tcIu2Pf5fJBIJHA6nYITc2ELAdHqTyMjI2hvb4dGo4Hb7U7ZQMt1TK5ZyJaIRB93Vp+YmMCpU6cAAC6Xa8F+I6Vgp4R15XAEnQvLp7OxlIYh10gF1x21S6GIfbnAZ2QjnYgCnfc6NTWFM2fOAJiXnc7XeShUjYrrhZIrBatSWMQJpQltp4Di1xbSTgXbhgSDQSanXKPRQKvVwmw2Q6lUMt+BsbExzMzMCFpWdiVFNrjYoKQ7q09OTsLn86GlpYVRAdNqtVCr1YhGozh48CDMZjOcTqdguqmnkzM3m80wmUwYHx/HiRMnIJfLU/o0ZYPPNKpcbCPbHs/OzjL2y+VywWw2px2jFOzUsnQ2ZDJZwo6REKMQyaRzYBab/sRHR+3l1gukGBTSZ4MvFnIG9Ho9tm7dipmZGXR3d8Pn86G8vDxnJ6KQmo18n5PP+0MrWAWDQTQ1NeWtYFUKizihNElOo+JrU8zn8zH1FOmcCp1Oh+rqaqhUqgW/h3xK33IpN7oS7Eq+RCIRJlJB309Eo1HI5XJotVpGzaihoSFhbaTr1lwuFwYGBnDo0CHBOB2Zrhu25Cwd5QbmN9AMBkNBY3Ix13zrKnQ6Herr6xEMBtHb24uurq60DXvZdkqom7jL0tnge8eI68WMLV/W09PDiaQsHwj1Ii4F8n3vihnZSEdZWRk2b96M7u5uDA0N4eDBg3C73Qtqg/PRZ4OLcygUCqhUKmzbti0vBatSKpoklBZsZ2OxNiUWi6VEKubm5hAIBNDX1weNRoOysjJYLJZFyWPyKY5CvmfcEIvFUpyKcDgMqVTKKEmazWZoNJoEZyEQCGB2djbjDbFYLGZUDemCZpPJBKfTuWSiMblcN3SUm95AO336NNxuN4xGY9rn8plGVahzplKpUFdXh0gkwvTOMpvNjP0qhU0x4mwUQKFjZotUAPMKCxUVFUvuVGSCpFEVB74jG/mgVCphtVphMpnQ09OD7u5uuFwuVFdXc7ZQ57tQFpJ2RZ8jXwWrUtgxIpQmCoUCc3NzAHK/tjI5FWKxmIlUlJeXw2q1QqlUorm5GevXr+dsznxGNrhipaRRxeNxzM3NYW5uDl1dXcy1IJFImA1KWt2IS2dALBYzu+vnzp1Dc3Mzqqqq4HK5iu505GNv6A00v9/PdCVPl5q0GKdgobku9p4uk/0Kh8OCt0/L0tmgC8SBpZGpzSX9SavVJjgVw8PDmJubg9ls5nSuQkeIizjXFJJGxefCUYiULa0NPjc3h56eHqaTa3JDomJENgpN1WLPM1cFq1LYMSKUJmw7lUw0Gk1xKuiOwfSNpF6vZ5yKYt1o8JVCzDXLya7Q9xPsSEUgEGCUh+RyOUwmE2pqaqBQKIp6LdhsNlitVubGl5afLZbTUYi90Wg02LhxI4LBILOB5nQ6YbFYeOtKDhRmtzLBtl+0ouTJkyexatUqVFVVcXIOrlm2zgbfaVTxeLwgp2KhMYWMUHd4+ILLBYeiKExPTyeEt+nQtsfjSUlPWuo0qkzHK5VK1NXVIRwOo7e3N6UGolA1Kr4jG5mewy4onJqaYhSsPB4PKioqeCleJwibPXv24I033oDJZEJHRwcA4LrrrsPJkycBAFNTU9Dr9Whra0t5rsvlgk6ng0QigVQqRUtLS8bzKBQKTE9Po6OjA5WVlZibm0N7eztCoRAkEgkTqTAYDLDZbAXdSJaCXLnQI+bFunlnK0DRdoK+n6Dlhemifbq+5ty5c4jH4zAajZycv5DXynY6BgcH0dLSgsrKSrjd7gSnQ2i1PiqVCuvWrUMoFGJsmd1u56UrOcCPEAqtKKnX62Gz2eD1eqHX6wXZC21ZOhtsSUEunI1kp8Ln82F2dhYtLS15OxWZ4GPHiA9WQngaKPx10iov7F0ov9+PeDyOeDwOrVbLhJylUilisRh6e3vR3d3NOB1LWSCe6/FyuRyrV6+G2+1GX18fmpqaYLVaUVZWJtjIRrbniESiFAWrU6dOMQpWQm+YROCOW265BXfffTduuukm5m8vvvgi8//77ruPkYZOx759+zLe/J04cQLPPPMMTpw4gcOHD8NgMGDXrl24++67IZVKmaapQk2JWGolxqUYD+DW7tEKULSNoP+lFaDYKVBCTKfOhFgsRk1NDSwWC4aGhtDS0oKKigq43e5FN9rLBBdRCIVCgTVr1jC2rK+vD0ajEVVVVZxK/XIZ2Ug3tsFggNlsXvKi/UwsS2eDHdnI98Yq10hFIBBAY2MjZ3MW8o03jVAN4FLAvlZoY0Hr0avVami1WpSXl6OmpgY+nw/T09Oora1NGIM2LnR6Und3N7q7u1FWVpZzM59C5s1l3ww6MuN0OtHf34/jx48zha987a4UktqUz3NoBau5uTl8+OGHzI7XqlWryHdgBbBz50709PSkfYyiKLz00kv485//XNDYWq0Wl156Ke677z489dRTqKmpwbXXXgsAGBoa4u2mjCtKIbIhJGgFqORoxYkTJxinoqamBmq1uuAbW6GtSeyeF4ODg2htbYXBYIDL5eJ8rlymPMlkMtTW1iIajSISieDgwYOcFsDzmZJbCrWFy9LZYEc20pHNqVCpVMzNYlVVVcbGRaUQnuYaoe8Y8QFbh5wdrYjH4wmh7Wydc/1+/4LnYTsd7e3tGBsbg0KhWFD9qZDXw4fyk0QiYYqs+/r60NzczOTvcn0DVYwidGD+M1EqlWhsbMTY2JhgF3FC8Xj//fdhNpuxevXqtI+LRCJccsklEIlEuPPOO3HHHXckPO5wOOBwOADMX1/Z7JQQKQVnYynGoxWg0qXJsm2E2+1GW1sbNm/ezNn8uILrWgWRSMQ4HUNDQzhy5AhT0K5UKjk5Bx/1FXRq7fr165kC+MrKSrhcrkXNm89azFKoLVy2zkYoFGLUGiKRSIqkbK5ORbEoBf1yrhHavNi7UOPj4xgdHUV3dzejQ67RaGCz2aBWq3lLq1EqlbBYLIjFYhgfH09Ir8qk/pQPfMvMikQilJeXo7a2FkNDQ2htbYVer2c6DnNBIQvrYvJlZTIZrFZrQc8lLC+ef/55XH/99Rkf/+CDD2C1WjEyMoLdu3ejrq4OO3fuTHssWzWxVFiJzgYbdjNE2qmg1cBop6KyspKRJOXbxgl9sw6Y/zwsFguqqqrQ1NSEI0eOoLy8HB6PZ9FOBx/3N7StYBdh085SWVkZ3G53WuXCheDTIRDyfR5NUZ2NdIV3Dz74IH75y18yFfQPP/wwLr/88pTnvv3227jnnnsQi8Vw2223Ye/evQmPj42N4a9//SuOHz+Ot956C6+88gqee+45fPvb30Y8HodarRaEU5GJUnA2SiH6kgu0fCQ7UhEKhRJ2oeicWS7UwQq5wZfJZHC73QnpVemcDr6dh0KPZ4fSR0ZG0N7eDo1GA4/Hs+juw4VK3wp9MSYIm2g0ildeeQWtra0Zj6GdUpPJhGuuuQaHDh3K6GzI5XLMzs4m/E3oNw2l4GxwATv7YXp6GrOzszhz5gyAxDTZYquBlTpyuRzbt2/H8PAw43QsZiOKj+9Lsq2gnaXq6mpG+UmlUsHtdueV7sx39IFWJxMqRXU20hXeAcBXv/pVfO1rX8v4vFgshq985Sv44x//CJvNhsbGRlx11VUJ+uE9PT1oa2vDhg0bcNFFF6G+vh6f//znAQDNzc0wmUz8vCiO4GsR53q8UtmBAua/3OnqKmhNeq1WC4PBALvdnrILRSvCLAXsBTRdTUe2SEcuYxc6l1xIt1DTak9jY2NMTUdtbW3BdSlcSN8SCPny7rvvoq6uDjabLe3jdHqlTqeD3+/HO++8gwceeCDjeEqlEmNjY8zv9Hoo5Lx2vqRvl8quUBSFUCiUYCMCgQCTJqvVaiGXy2E0GlFdXb2s15Bs1wkX1w89vkgkQnV1NcxmM0ZGRtDW1oaysjJ4PJ68nY5ifl9o5aeqqipMTEzgo48+YmoWswlG8DnXUqKozka2wrtsHDp0CKtWrYLH4wEAfP7zn8drr72W4Gxs27YN27ZtAwB4vV7EYjFO5lwsSkHlQ6jQBiMajaK3t5eJVgAfSwbqdDpUV1czkoFCINtnkzzHTE5HZWUlr3KYXEVCRCIRqqqqmIX65MmTEIvFzHc6H4ohr0s/h0Yo1wyBf66//nrs378fY2NjsNlseOihh3DrrbfihRdeSEmhOnfuHG677Ta8+eabGB4exjXXXANgPgryhS98AZdeemnG8yTXFtLKiVze0HLtwPAZged7vHS1d7FYDAqFgolmV1RUpKTJnjlzBkqlclk7GsUg+Tpkb0SNjo6ivb0dWq0WHo8n5zQlPtOoMiESiVBZWYnKykpMTU2hq6sLsViMkUvPNJ+VvuEliJqNxx57DP/1X/+Fbdu24dFHH4XBYEh4/OzZs7Db7czvNpsNBw8ezDhetmZJQmW57RjxRSQSSZEMpA0G/a/QJAOz3YDnW4eR7HTQC12ui64Q0q4qKipQUVGB6elpdHd3w+/3Y2JiAgaDIadz8SF9m+k5QrmGCMXj+eefT/v3Z599NuVvVqsVb775JgDA4/Ggvb095/PIZLIEO8VXTyiubQAfc+QSuq7i7NmzjJ2IRqOQyWSMU2G1WnNWgBKC3SsGS/Ua2RGD0dFRHD16NGenoxhpVNnQ6/U477zzMDs7C6/XizNnzsDtdqOqqipljJXes2nJnY277roL999/P0QiEe6//37cd999eOaZZxKOSfclyHYxKBSKFAUgoYewSiEXtpjj0eoebMciEolAJpMxdRUWiwUajYYxGM3NzaiuruZ0fkvFQuemnQ6fz4fm5mYcOHAgp/QqITgbNOXl5diyZQvef/999Pf34/Tp0/B4PDAajVnH4Fv6lkboawahtFEqlQkF4ivRBixmzEy1d9FoFCqViomkut1uwfYeEBp8rncLradsp2NsbAzHjh2DWq3OWucnlLRDnU6H+vp6BAIBeL1edHV1weVyobq6mhlrpdcNLrmzwS7Avf3223HllVemHGOz2dDf38/8PjAwkFUdRqlUYmJigvmdr1xYLhHSIl5M4vF4SqRibm6O6aBLq3twpXWdK0v5vuVzboVCAY1Gg/r6eia9yu12w2w2Z4ya5NutO19nI9+beolEgoaGBvj9/oTdoWyvoRhRChLZIBQCRVEYnglBrZCgTJn5JjdTGhWXcD3mUtgptgIU/UPX3tG9Kti1d/39/ZDJZLBYLJzOk7A4cl236ZRbo9GIsbExdHR0QKVSoba2NsXpEIqzQaNWq7FhwwbMzc2hp6cH3d3dcDqdsFqtJLKx1BMYHBxkFoVXX30VGzduTDmmsbERp0+fhtfrRU1NDV544QX8z//8T8YxFQpFQniajwWSoijB58IKaVeLoijMzc0l7EKNj49jdnaWCW0vV3WPQq6TXI+nx05Or/J6vWlv2PmObOS7e8O+njQaDTZu3IhgMJiwUFssloRFuljSt8TZICzEXCSGj4ZmYdIpYNXPF7f++aMRvNZ2Dhq5BF+9ZA1MuvTynsVwNoRkAxYak60ARW8+sRulajQalJWVwWKxZLURQhdG4RquXm8xNmTzGZ/tdIyPjzNOh8fjgVarBcBfGtVi132lUom6ujqEw2H09vaiqakJ0WiU8+83UDq1hUV1NtIV3u3fvx9tbW0QiURwuVx44oknACQW3kmlUjz22GP41Kc+hVgshj179mDDhg0ZzyOTydIu4lyqC5VC4R1fTtZCj6erq6C7ZdOOBZ3TaLfbeeuWXark+5mxr8GFnI5ipFEtNnKiUqmwbt06hEIh9PT0MB28bTYbU9tU7JoNIS/iBP6Zi8TQcXYaerUMq0wfr1e/PtiHI32TUMok2HtZHYxaBU6cm4FaLoYvFMXg1FxGZ0MulyfYKT7WayFGNihqvlEqbRumpqYwPT0NkUiU0Ci1UKl6oTsHXCL0jA02hX4mIpEIRqMRlZWVmJiYwIkTJ6BQKFBbWyu4yEYycrkcq1evhtvtxl//+lc0NzfDYrHA4XBwltpXKtdAUZ2NdIV3t956a9pj2YV3AHD55Zen7b+RjuRcWL7C06WyY8TleGyi0WhKXUU0GoVcLmcMRk1NDTQaTVpHrxS+IFxQyGeQT2QjHZmcjkIiD3w7G5mOVygUWLt2LTweD7M7VFNTA4lEUpQoBYlsrCzicQqnR3xQysRwViama7x6ZADvnx6DTCzGvZesYR4fmZmDSiZGKBLH7FwURq0Cl26sxnNNvVhbrcYac+aNlOSmfqUS2cgHWgEqnaAHnQKl1WphtVpRUVHB2TwJwmOxN8VsFajx8XF0dnYy1xaXG5Z83LxLpVKmx8i5c+dw6NAhVFVVweVyLTo9vFTs1JKnUfFBqYan+Q6xFUo8Hme+1IFAAAMDA0wfCnakopBCvJWyA8XXDf5CxyY7HcPDw0yDIiGoV+Xi/MhkMqxatQoulwv9/f04c+YMysrKUFNTk/P1Fo/H8742S2URJ+ROMByDVCKCTJL6uf7l1AheOXIWIojwlV2rsLb64xuYmWAUcokY0TiFQPhjWfUbdjjxxtFzqDVp4aqcV85Zbdbh+1enpgMnU4p2KhP0xhPbqVhI0IPG5/NxenNXCqljQoTvHXIux6edjvfeew8fffQRZDLZono3seFz3ZdKpXA4HLDZbBgcHERLSwsMBgNcLlfBjQ1LxU4tS2ejGOFprp0DvqRv84HOmWVHKthN8GKxGPR6PSwWCxQKxaIXjpUS2ciXfK6DXBdw2ukQi8Xw+Xw4cOBA1iLsfMen4TNyIpVK4Xa7IRKJMD09ndfuEKnZIBzpm8R/NfWiXCXDPRevhkGTeM0Mz4QgggjRWBwT/hCAj29cPrfVhreODaK6XIm1rGiFo1KNL+9aVdB8kp2NUkijisViiMViGBwcTFCAkkgkCelP+ezYlsrG3UqErrUEsOg0dD4cNqlUisbGRkxOTuLkyZOQSCSora1FWVlZwWMWIy1JLBajpqYGVqsVw8PDaGtrg06ng9vtzqi8lYlSsVPL0tkoRni6lNOoKOrjrqnsnSiKopiuqRqNBmazOaEJntfrhVarhVKZPgeZkJ5iFIjnilQqhd1uR3l5edZCcvb4QlOvonN4N23ahHPnzjG7Q263O+O1SfpsLG+O9k9hYDKIT9RWokKT/ib3w65xKGVijPtD8I77U5yN3evNmAqGoZHLsNme2OvJqFXgi+e7OJ2zkNOo4vE4U6xN2wd64ykcDiMSicBgMMBms3Gy8ST0yIHQ58cF0WgUoVAIZ8+eZT5zOi06EonAZDLB5XItqtaAr5t4g8GAbdu2YXJyEqdOnYJYLMaqVasKcjqKWQMhEn3cTX1sbAzHjx+HXC7PK0pTKrWFy9bZoNWoKIqCP0IhHOW2ozjXuyd8ORuRSASTk5MJjgU7Z1ar1cJut6d0Tc2E0B2s5QCf70kh6lWFjJ8ri2nQJxaLYbPZUFNTg6GhIRw5cgRlZWVwu90pzaBIzcby5dxUEE9/4AVFUTg1Mot//L9r0h73f2or8d9NPlRpFfAYU3cPK7UK/N2FhUUpCiFZNXEppG/pnWu2UxEIBACA2XjS6XSorq5mNp6am5vhcDg4m6PQ1aOEfANXCLQjyc5gmJubY94zg8EAs9kMjUYDmUzGiOsMDQ3h0KFDqK6uhtPpzKkhIpti3MTTTsfU1BROnz4NkUiE2tpalJeX5zzGUqz7tPJWVVUVJiYmcOrUKQDzjUKTm1wnUyp2alk5G8FwDCOzc4iLpcyO0QHvFPZ559DpG8Pnd+ggl3LzoQgtskE3wWMbjZmZGfj9fpSXl0Oj0aC6ujptzmw+c1xJcCkpyNe5F1uSy3c6AAAgAElEQVRTIQT1qkLS/diLq0gkYupQRkdHcezYsRSJxMU6Gyvt2i9FKADZPqUtDgPWWcogFYsgTVOzUWySIxt8y8qyFaDon3g8zihAaTQaGI1GqNXqot68LIVq4kqB/szpn0AgkJDBwJYSnpqaYpRCkxGLxbDb7aipqUF/fz8OHjwIq9UKh8ORV3pVsdZRvV6PrVu3Ynp6Gl1dXaAoCqtWrcrJ6VhqdaeKigpUVFRgZmYGXV1dTLPbysrKtPMizgaPBMJRDE7PoUqnYJomxeMUXms7i1FfCDF/GKHw/I5R93gAZUoJJoNRzMxFYdRy0xhuqXZPMu1K0A2O2E3wurq6UFNTs6j8xeQ5rpQdo6Wsn+GjZmOh47OpV3GlLpWOQp2AdK9BJPq4A+3ExAQ6OzshlUpRW1tL0qiWMVa9Crf/f270TQTxCU9l1mOVMu7kzxcLXwXibOnxyclJTExMQCQSJShA2Wy2nKPZfCN0u1IKEXh6s5F9XxCJRBKUIRfKYMjFlojFYjidTthsNvT19aGpqQk2mw12u33Ba2kp3sPy8nKcd955CU5HbW0t9Hp91ucJ4d6krKwMW7Zsgc/nS2h2azKZEuZXKnZKsM5GJBbH6GwIBrUcKvnHFzFFUXi97RxGZ0MoU0nxhR1OyCRixCgKk4EwypUynJ0FQpEoAKDRqcfrw6NYY5TDoOZG1xjgJ+TNJlt4m25wpNPpsjY4Elr0JR1CX8SXCr4Wu3zVq8bHxzE2Nga73Z7TnPiW1qXPkW1xZUskTk5O4vTp05idnYVGo0FlZfab0XzOQxAOG2v02FiT/QZCaEilUkSjUeb3fG1KNBpFIBBIucGUSqVM3R29+WQ2m/l4CZxA1KNyh9340OfzYXR0FJFIBOfOnUvZbFyspGo2JBIJ3G437HY7+vr6cODAgYReSJnmvlQ38bTTQUcLYrEYamtrF0xREgJarRabNm1CMBiE1+tFV1cXXC4XqqurmTWjFOzUkjob8TgFsTj9xfeHjiH0jPuhV8vxt9vsTPpTnAJm5iLQKqXwh2OIxijIJIBMIsbu9WYcOzuNC1dV4o+h+c6ja0wafHZ9GcrKdJBkOFchcLmg0aHOcDjMaEfTTfDoBaSQ8PZyXnRLiULqHvI5lo+be9rp8Pl8mJ6extmzZ3lRryqkQDyfcxgMBmzduhWHDx/G8PAwhoaGsoak2RQSDSEQciX5us+0XrOlx+mbTLYCFO1Ep7vBDIfDgr8REfom1lLZUTpCxXYm2WlvWq2W+d1qtRZ9fsC8w+zxeGC325leSE6nE1arNeW6W+r0JODjaMHs7CzOnDmDM2fOYNWqVSXhdKhUKqxfv55pduv1emG326FUKgX/HQeWyNmgKAr7To6i89wMtrkM2JEU+qYoCuemg9Cr5ZgOhhGMxBhnQyIW4bKN1WgfmEadWZcQ9Vhl0mGVSYfp6WlBqlFl0yLXarUQiUSoqamBWq0uuK6CjdB3jFaSM5RukY1Go2mVPbjss7HY4yUSCdasWQOKonJWrypGgXi+i6tUKsXq1ashEonQ3d2NM2fOwOPxMJ3suToPgVAoIpEIwWAQIyMjaaXHNRoN9Ho9ampqclaA4jsCzwVCT6Pim3g8zkSo6J9wOMxEqOimh+ma44ZCIU5rCwsdi+6F5HA40NPTgwMHDsDlcsFisTBjCsHZoNHpdIzT0dXVhTNnzqC2tpa3xpJcXt/sZrd9fX3wer1Qq9WIRqOc3DfyBeczC0fj6Bn3Qy2XwGZQpz3GH47hxLlpVJcp0dI7gW2uioSog0gkwsV1ZjT3TGCHpxLlqsQbMnuFBvaKzFrExVD5yKZGxV480u1EZdIin5qa4qy+gkbIO0YrBbo4c2RkhDEmdJ0NMK84kXzzns+izOcCTjsDCoUiZ/UqPqVyF/scrVaL+vp6BAKBlJB08pjxeJxZvIViJAnFYc+ePXjjjTdgMpnQ0dEBAHjwwQfxy1/+ElVVVQCAhx9+GJdffnnKc99++23cc889iMViuO2227B3796Ex+PxOPr6+nDs2DFEIhFce+21uOyyy1BXVweJRAKxWAytVpsiPV4IpbChs1I2sWjJ+Wg0ip6enoTUaDpCZTAYYLfbIZfLS3LNkcvlWLNmDZxOJ7xeL3p6ehj7JkR0Oh02b94Mn8/HOB3RaJRzx4gPR4tuZKhUKjE4OIiDBw+irq5uyaJcC8G5s3HQO47W3klIxSL8zVY7qstTde/VMgkcFWr0TQSwzlKWNr2p1qRFrUlb0BxkMlnRmvoFAoEULXLg48WjvLw8r50oruco5PGWI+zQN31NhEIhyOVyiMXiBPUPYP7Gw+v1wuv1ora2FlVVVXmnUeWD0NSriiVJm/wctVqNDRs2YG5ujglJOxyOhPB/ISlehOXBLbfcgrvvvhs33XRTwt+/+tWv4mtf+1rG58ViMXzlK1/BH//4R9hsNjQ2NuKqq67C+vXrmWP+7u/+DiMjI9i4cb7L+De+8Q1s2rQJs7Oz8Pl8cLvdnL0OriXaabi8eRKqc0BTyPzoLAa2LaAl52OxGFQq1ZIofxVCIZ+1QqFAXV1dgp0wmUw8zXDxaLVaNDQ0wOfz4eDBg2hubmYiHVxc53xGyekaRafTycv4XJGTs3FmZBZ9EwHU2/QwahVZjw1GYpBJRIjF5ou80yEWi3BlvRX+cBRaBfdhn+QPdbGRjWTZQJ/Ph4mJCYyMjECn0zHRCpPJBJVKJZjFQ+g7RkI3MtnIFPqmU+I0Gg1qamqg0WgwNDQEAKipqUkYg6IoJmIQDAbR1dUFr9cLmUwmmDSqfNWrYrFY0aVv/3/23jQ6rupMG31OzXOVpJonlWqQ5EmeIZAOgYADIYkJ6f7iBvJBlsnUDd2de+lcuLnA+kgny2bdDN29kg5JIGkn3U0+kiZNwnWABHAgYFkekAcZbEklyZaseagq1TzdH+59ODVJNZxTOmXXsxYLS6ratavOqffd7/Q85aCUsZfJZOju7kYikaB7ju12O+x2e7ON6irGDTfcgNHR0Yqf19fXB6/XC7fbDQD4y7/8S7zwwgs5wcaPfvQj+t8vvvgiduzYAYqisLy8zLo9ZJskBEBVSYXV0Kh+hckOSc4HsVgMQqEwRxzX4/HQVdKjR4/yMtNf6prWcp2Jn4hGozh79iyCwSAMBgP0ej0vk5cqlQpyuRwbNmzIaa8qZ8ZvJXDpS5i6Uw3dRhWIJvHywDTEQgoTi9FVVVSv9+ghEwmhlYthb5GXfJxAQEEtY48daiUIBIIc1o+VkEwmC+YqiIomMR4OhwNSqRQajYYuqfMRjXyY5wPI55cfaIbDYQCXs+MqlYqV0rdcLsfGjRsRDodx/PhxvPvuu+ju7l51cG2tdTCKsVe1tLRAqVSW9TrVslGxPechkUjg8/ngcrlodhWxWFwgDtjE1Y3vfe97+NnPfoYdO3bg29/+dsH3c2JiAg6Hg/7ZbrfjyJEjZa1d73bfWtbk+4wFF+3D8Xg8p1qRr1mh1WphtVpLskNezZDL5XC5XLh06RImJyfh9/vh9XorYgesJ5RKJXp6ehAOh+H3+zE8PAy32111kMTlvEqjVOBXDTZEAgpiAYVoMo025epUaiqpCDd08usAXsw4ptPpgrkKMpRFKhVMFc18zM/P8/4gz4VTYNtx8ekzZN4ThJ8eAB1oqlQqOJ3OikvflRgDwizT0tKC0dFR+P1++Hw+1mZ5uGavikQiCAQC6O3tLYu9qpqMT7UMVuU8h/TBulwuHD9+HOfPn0c4HIbX64VUunJVt4krG3/1V3+Fxx57DBRF4bHHHsNDDz2En/zkJzmPKWbPVvv+kO8YF8mhShJt5YLvfqXWQ12+ZsXc3BwymQxmZmZyEo5KpbIhDnl8QTabhUQiQVdXF5aXlzE0NEQHHXxlg1Iqldi0aRMikQiGh4fpoGMlYpFi4LqywQe9nNWwarChlIpw5zY75sNxOEoMfPMVRDk1mUwiGAzC7/fTcxVEBK/aoayrkeUDYL/cvRYgWSpmC1Q0GgVFUXSgKZPJYDab16Rylc1moVQqsXXrVgQCAZw/fx4ikQher5dWxGY+di0rG/kQCATo7OwEAE7Yq4DqKxuVsnCp1Wq43W5Eo1Gk0+mKXq+JKw/M1pcvfOEL+MQnPlHwGLvdjosXL9I/j4+PrziwSbQ2yEwX36sQAP/1m8pdL1+zgsn+xaScl0gkEIvFvB285QMbVaXrq1QqbNmyhaagJUFHOQrfzPXqBYVCQQcdfr8ffr+/oqCDy+pDJpOhE+J8rqiV1eBlUEthULOT1SvG8vHVr34Vv/3tbyGRSODxePDTn/60qMKjy+WCWq2GUCiESCTCsWPHcv4+MTGB/v5+nDlzBktLS7jmmmtw77334vrrrwdFUTCZTDCbzTUzfAD8P8gDjVHu5hr5g3qkLU4mk9HVCoPBAIVCkfP+YrHYmvY/kr1otVrs2LEDCwsLOHv2LGQyGbxeL93ew3XwwNxLJetzxV5V7XOqHSoXiUR0IqKJqxuTk5OwWCwAgF//+tf0gDcTO3fuxODgIEZGRmCz2fCLX/wC//Ef/1FyTaIizlWw0QitWfVo9y1G3EE0KpizFcXOBuFwmFcV+EZFMd9DKGgDgQCGhoZAURR8Ph/UanVV63ENhUKBjRs3IhqN5rRX5at654NLzaZGmS2s+2mqGMvHrl27sG/fPohEIjz88MPYt28fnnzyyaLPf/3116HX64v+7d/+7d8QCASwadMmqNVqvPrqq5DL5Zifn8fS0hKrWWous1B8Zfng83rZbJYudTOZwfIH9VQqVd2DiFLXtNR7L/b41tZW7Ny5E3Nzczh16hTUajU8Hg+A6oIBrpBvVFdjr6pHlYKA7TmPJq5c3HXXXTh06BDm5uZgt9vxxBNP4NChQ+jv7wdFUXC5XPjhD38IALh06RI+//nP4+DBgxCJRPje976HW2+9Fel0Gnv37sWGDRtKvo5YLEY8Hqd1lhqhssFnP8Ac2B4aGiqqWUGIO8ptPeFzku1KCYK0Wi22b9+OxcVFvPfee7RuR34lnwkufFm5nycZIieq3n6/f8UKPtdtVI3gp+oebBRj+fjoRz9K//sDH/gAfvWrX1W19sMPP0z/+8knn6TpRRshu0PW5HOwwReQLBWzYpHJZOgBPrVaTdPL8tlRlEKpa0ZRFM3kMTMzg3feeQcymYxXswSVslfVS9SvGjSKEW+CfTz77LMFv7v//vuLPtZqteLgwYP0z7fffntR/Y1ikEqltAAtl8xRfF6zmvXyW2GZmhVisRjpdLrhNSvqjXq2UZVCS0sLdu7cWbKSX+l61eyxEptPVL3LqeA3Kxs8w09+8hPs2bOn6N8oisJHP/pRUBSFL33pS/jiF79Ych2hUIh0Og2RSNRwwQabWGunUAvyaQWJOGIpZdWjR4+yylHPNVYyPqv9zWQywWg04vz585iYmIBYLIbL5SpKZsDEWjuU/KBjZmaG1hYpd1/1Yt9oFCPeROOCtFEB3CTFGmEOZLX1SmlWyGSyHJFcQju/tLSEmZkZ1piOuCJGudoCoEreM6nkz8/P4/Tp01AqlfB4PJDL32c45eIzrLZqzvRrzEoHEYttVjZ4Fmx885vfhEgkwj333FP072+99RasVitmZmawa9cudHd344Ybbij6WIlEQh9MG2FIDuD/jAWXTobQy+bTCioUijUXR6wVKxnFStqrij23paUFFEVBJpOhr68PZrMZ7e3tJVvF6hFslGP4iHGWSCRYWFgom70K4Lb/Nf91GsGIN9G4kEgkOcEG330KF2uS9VbTrCAMkUzNinrs72pBPT6zSuw2RVHQ6/Voa2vD7Ows+vv7odVq4Xa7IZPJOKts1LKmTCbDunXr6KBjZGQELpeL0+oa00/x+WzEm2DjwIEDePHFF/Hqq6+W/MAIG4TRaMSdd96Jvr6+VYMNQk93NVY2+FgpyWQydJZqfn4es7OztJAdcShNWsHKjbLD4YDNZsOFCxdw5MgR2Gw2OByOgr7kta5s5EMkEsFut6O1tbUs9iqCZrDRxJUA4qcAbnwKHysb+dpF8/Pz9P+ZmhXVJpeawUb14No3VAOKomA0GmEwGDA9PY133nkHOp0Odrt9zduoSoEEHfF4HCMjI5iZmYFSqeTEpzSKn2I12CAMPpUO4L700kt48skn8cc//rGkiBZhj1Cr1QiHw3jllVfw+OOPl1yzHuVpvldLuGANKRcr9dSS0rdCoYBOp7viKQUrRSX3APNwLxAI4HK5YLfbaWE6p9MJm81GGyO+BRukSrHaIPlaoFEyRk1Uhmr9FBeQSqVIJpMA+BkYFEMl+2RqVhA/kEwmc0RyDQYD1Go1vF4vq/tkC83ghR3U6nsoioLZbIbJZMLk5CROnjyJdDpNs7mxAbar5lKpFN3d3VCr1bh48SJ6e3vR3t4Oi8XCWoBwVQUbiUQCv/3tb3Hs2DFIJBLs2LEDN910U1EmgWIsH/v27UM8HseuXbsAXB4Sf+qpp3JYPqanp3HnnXcCuNzDeffdd+O2224ruaf8jBHfS8lkTT5TCpZaL9+hLC8vI5VKQSqV5tDLkp5agtHRUV44/GJg83Pjkm622NoikQhutxsOhwOjo6M4fPgwXC4XrFYr73qF8/fDp6CjUYx4E+WhEj9VL9TDT9UjgClHs8JgMKCjo6NgrmxhYQGxWIzT/TWxOviWiCoFiqJgtVqh0+nwzjvv4OjRozAajWXNLNZrj/kQiUQwGAxwOBwYGRmhE4FWq7VmH9MofoqVk94zzzyDr33ta9i+fTuSySSeeeYZ7N69G/v37y9QPq6W5cPtduPkyZNl74nrysbV2EZFBBJnZ2cLHAozqCjmUJooH5Ves1LGUSwWw+fzob29HX6/H4cPH+adOF0pQ7lS0FEv8C0wa6I2VOKn6gWu2ai4WDOTySAYDCIYDBbVrCCzFeXqWfGx3beRwKaNymQyCIVCCIVCtI9PJpOQSqXo7Owsqn9WLri4JgqFAps3b8bExERZM4urgSubTyomREE9kUjQicD29vaago6rItggF+Y73/kOnn/+edx0000ALisH//mf/zmefvpp/N3f/d2aSKk3YhsVn4KNVCpVIIIUj8dBURQ9X1GJQ2F7f40Erisbq0EikaC7uxuxWAxvv/02jh07Bq/XC71ev+aH6UrZq0ZGRpBMJitmr6rlHl3rz6iJ2tAofooL1GJjmfN15P+JRALJZBKpVAptbW0Va1awvcdS67EJroIhNvZZy76Ybc7Ly8sIBALIZrOIRCJQq9V04lAoFCIej2NoaAgCgQA+n6/qaiCb14Z8hgKBAA6HA1arFePj4zhy5AisViucTmfF9yVXB/f8WRCJRILOzk64XC6MjY3h8OHDBS3P1a7NV7BS2VhcXER3dzeAy6Vqt9uNgwcP4vbbb8c999xT12wkQaO2UdU72CiHAcRisUCpVCIQCGBxcRFut5u1PTZRCK4O0jKZDHK5HD09PfD7/fD7/fB6vaxRRFaDcvfPDDreeustXrJXNcFv8N1PcYFyEm3583WLgRDenQ5DKRHAZ7zsA1pbW2nNiuHhYbS2tqK1tZWVPfIpyVYPrEU7aCQSoa9vKBSi5xzUajVUKhXa2toQDAaRTqfhcDgKnq9Wq2nRvYGBASgUCni93hwq2tXAdtUgfz2hUIj29vacmUW73Q6Hw1H2YZzrykY+JBIJfD4fXC4XXelwOByw2+1l75m5Np/9HCuVDYfDgeHhYVgsFkgkEqRSKVgsFszNzSEcDrO114qQTyl4NbB8rLYekwGE/D+bzZbNANIIGaMrAdUOiJcLuVyOTZs20Sq7fr8fPp+vphJ5tag0k0QCpq1bt5Y909EoZeYmuAGf/ZRMJqtrZYNZsQ6HwxibDWJoMQmfXg63UQOVSoW3p4FjIQHEQgG29LjgbJWvuCbbe+Qb+L4/JojgLQkqmBTyKpWKFjosJgQbCoWKrsm0qy0tLbjmmmtoKlqdTgePx1PWgDbXwQaBUChER0cHHA5HxVUDLoONlV6btDwzKx3lBh2N4t9qCjbIG3zooYewsLCAeDwOqVQKkUiESCQCsViMVCrFykYrBbM83QhVCDbXJJmMxcVFBINBBAIBJBKJHHpZu90OhUJRUZmxkYwun8BlG1Ute1GpVNiyZQtCoRAGBwcBAD6fD2q1mpPXXm0/laCSQfJGMcZNcAM++ylmUoxNkIp1IBBAOBzG799+ByOLMXh0Itj1l4MKvdGEZ4eyiKWzmJwT4M92uCAXC5EYuQixUIBMFoglC2e8+B5sXA1+irQ7kfanqampAsFbh8NRkY+vRN+JUNFOTk7i6NGjMJlMcLlcdSV8Wc13iEQieDweOJ3OHKKUlZig6tVGVQpisRherzcn6LDb7bDb7SWvY6P4t5ruDJIZ/+xnP1vwt4sXL+Jv/uZvoNfra3mJqpHfRsU2+DAHwuQrZ4rhAZfpZSmKglwuh9fr5VRU5kpFo1Hflov8x6vVamzbtg1LS0t47733aIOnVCorWrca1NpvWk7Q0Rz0vrrBdz9VS7DB9AGX5oOYWAhBS8UgElBQKBRQKBRIZgV4fVaKVFaGuZAIN13vhYCikMpkQVEzoJAbUOzeZIJcLIReJYHXUGgD2PZ9jRBsrGXwkj8/uby8jEwmA4VCgVQqRScP2RC8reT5hBXKbDZjfHycbltyOp1FbTrbswXl2nUmUQphgiJBR/7zuaxsVEKaQwKl9vZ2jI2Nobe3t6R2FtAYs4VVBRvkgvzjP/4jUqkUNm7cCJvNRguZSKVSdHV1oauri+39lg0mywcXqDdN4Ur0soRasK2tDQqFgv5Cz8/PY2lpqWjJtNr98d0p8BHVvMd6DD/nQ6fTYefOnZifn6f7crm+PpXOU5R6vysFHbVmfvhuxJsojkbxU9FotKzHlvIBEokEkCjw7NkoElkK29ut+OxOO4DL36/x6TlQAgHEWSCZef/7LBJQ+Pz1TpwcD2C9RQ25+PIhplUpwZ7tpbWPrrTD/Gqo1/c/m80iFovRLVDLy8tF5ydVKhV94BwbG4NMJoNMJqvLHotBIBDQNK4kG9/e3g6bzZbz2dWrjaoUCBNUPB6H3+/H2NhY3RJT1fogZtBB5lBWCjr4jKqCDXIx7r77bvT19eHo0aP4h3/4B0xNTeG1117D+vXr6UPzWpV3ZDIZLZbEBbhio8pkMghHIpicDyCbiCIejSASiZTFV15svWZwwA9UeqCu5LFsG8e2tja0trZiZmYGU1NTOHv2LNxuNycOrdL9rxacFAs6imWwmrjy0Sh+KhAI5PyOaFYw5+suLUbw6sU0ZFIJPrNZD1ueD7i4GEX23Ch0EiHGF9/XrKAoCjIhcN+1dgxMLWOHUwsB47tg08lg01X2vb4a2aPYRjqdzgkqlpeXkU6nIZPJ6MDCbDaXxfbI1udXqy8hB2OiJXH48GF4PB4YjUb6mqxlsEEglUqxbt26HB/h8XhgMBg4baOq9bN1u91wOp20OKDVai0Y5uczamqj6ujoQEdHB/bs2YP9+/fjX/7lX+ievbXuIROLxZxXNmotJadSKcwsBjGzGIIkE8Xi/DxmZ2dxblmKmbgAFp0Sd2xxQaNSVnWjNoLR5Su4/NyYGUqj0QiFQlHwmLU+HFMUhba2NqjVarS2tuLEiRNobW2F2+1mTa0VqDzjU24pnhl0nDt3DvPz85iamipbHLDJYHXloBo/tXfvXrz44oswGo04c+YMAOCrX/0qfvvb30IikcDj8eCnP/1pUVIFl8sFtVoNoVAIkUiEY8eOldxbLBbD+QuT2PfPP8Idt/wZIpEIjh49WqBZMTochGBhEdEsMJtVYWNLS846Np0MH/a1Ymg2go+tN9C/J/dwp0mFThM74oV8T2Lxab18pi/y38mTJ6FUKqFWq2EymeDxeKqad+CjfycVhFgshqGhIYyOjnKiDl/rAZ74iGg0iuHhYYyMjHDWTslWECMSidDR0QGn00lXOggVNd+1zWoKNnp7eyEQCKDVamEymXDw4EF0d3ejs7Nzzfuk+cRfns1mMbsUwkJgGZJMjC6PJrICHJkRICMUo8emhdsoREtLC86ej8BnFGMunAQlllX9OfLJ6NZjPT4ikUggEokgFothenoakUgEFEVBqVRCoVCgv7+/4BBfaWWDy8BeIBDAbDbDZDLRw4BsqbUC7Fc28iGTyeByuQBcViouV5G8UYbumlgd1fipz33uc3jwwQdx77330r/btWsX9u3bB5FIhIcffhj79u3Dk08+WfQ1X3/99ZIHl4mJCezduxdTU1NIyXSgNn4clrgZOzMa6JQRbN26taBFwq1P423/EsQU4ChSiRBQFD6+sT7UvU0/UBxMXRJStSCtzkzR22g0im3btjWMfan22shkMmzcuBHhcBiDg4MIBoOw2Wys7ouNM6ZcLqf3OTAwgEgkAoPBwBq1M8C+nyaMW06nE2+88QaOHDkCm822pi2hq6GqYIM44qGhITz33HOIRCJ0i4XBYMh5zFoFHFwHG8WG5JLpDFKpFGKR9w1OOBzGUiyNvlkKQpEEf+ZpxTafDzKZDLPLCZxNTkEhFWI5I4RQeJkR5bqOFhwdC2CjRQ21lF9iSVeCU+ACTHYQUhonXOapVAo6nQ4WiwVyuZw2OtlsFh6Phz7EWywWtLe3102wbjXk83eTYUCi1mqxWOB0OumMXDV7qdQIVxMEkOG8ctmrqn2dJviFWvzUDTfcgNHR0ZzfffSjH6X//YEPfAC/+tWvir+wWI7huQjUujSkokL7bTQa8bOf/Qwmkwnf/vlv8Pzpeazr7MRsjEKbUIhMJlMQbGywqPHQzW4IqMszFWsJvvuVevipRCKR0wLFJGYh85Pt7e1Fq8BctGCzAa4SV0qlElu2bMHAwACmpqYQCoXg8/lqJiBh2/cplUo4nU4sLi7iwoULGB4eZo0SnqtKuVAohFQqxURteGkAACAASURBVLXXXotgMMj6+myiqmCD3JCf/exnizJ8ACgwlvWudEil0pK80Wwgm80ilUphamoKy8vLGJ8P4c2xCERCIW7p1MHWpqHVVccW4xjKzkIqFiAulNNCOHqVBJusGkyFYriuowXR+Riy2Sw2WNTYYKmdfrQZHHCDVCqFcDic42yIXolarS7gMh8eHoZOpytqXCmKgs1mg9lspnsx0+l0RS169aDJJWCqtV68eJHOqDidzqr2Us2AeDXBBnlOuZS5zWCj8cGln/rJT36CPXv2FPw+mkgDmz6J/7nv3yBansZXbt2AL37xizmPEYvFtICgp0UMTWoRerUEN/raMDM6V9Jm61VrG2QQsNFCnL8eXwfOM5kM4vE4QqEQhoaGsLy8jHg8DolEQlcr2tvbc4hZrjSw5V9kMhk8Hg/EYjHOnDkDpVIJr9db9SwgF2fKbDZLz3QQSvhsNguv1wutVlvTulzeH0KhcE3FectBzaTIzAs+Pz+P6elpBINBpFIpyOVy2O32svuk2USxyka1N2cikcDY9CJOXVxEiygBNXV5FiQejyMej6OlpQXTWS1s6SjS2SwkLTpYre/fmHadDF6DAsFYGpvtGvr3AorCde73e29HF/id4eH7emyjGDtINBrNYQexWq1QKpUrMkOUc98JhUK4XC7YbDb86U9/wtGjR+HxeFb97nD5+a20b7Jfu92ewwfO5msUQzUZomKBw2pBB/M5zdmNxke1fqrYt+ub3/wmRCIR7rnnnoK/BWNJ7PrEHTC3arAUiuD73/oiuru7ccMNNxTdl1YpQ3vkPP6Pj3wBADDL8kGeCwgEAlZ1SfgycM4UxGOK3gqFQlAURSeRmjTy1YF8B5kEJCdOnEBbWxs6OjoqngXkKtggaxJK+EAggKGhIQgEAni93qp0qLiqbDTSbGHNwQZFUQgEAnj99dfx8ssvY2BgAAsLCxAKhTAYDHA4HNi4cSNuv/12rFu3jo09l4X8YIO0PRU7FGayWQgoCul0mm6FIf8lk0mIxWIcukRBJBFjWqTAvdetg0omRl9fH9rb2wEAnZI4hhfiEAOwt+QqrkpEAtzSbSh43Xxwod3B14wR30CEEElQMTc3h4WFBVp5lQzylcMOUgvEYjHkcjk2b95M0/P5fL6S/aNcVgzLWZspnDQ8PIxQKIRLly6VzQDF1YB4/nNK7aVU0KFSqRrGiDexOir1U8l0Bv/75Bzim/8H+vzzuMZ9OWt44MABvPjii3j11VeL3h9GtRSf2tGB/vEl7P1wJ9qG70RfX1/JYKOUn2ITXLAm8jnptNp6TLYvYu/zBfFIV4JQKMTc3ByCwSDvM8e1YiU7yYYtZK5PURRMJhOMRiMuXbqEo0ePwmw2o729vexBeS6qBcUO71qtFtu3b8fi4mKODpVKVT7hwlqLBfIBNQcbZ8+exaOPPop3330XN910Ex544AE4HA5QFIWpqSkcO3YMr732Gt588008/PDDuO6669jY96rIF0tiGiAmQ8TJC/PoHQuiVZzCdpMIqiI9l9lsFkPZSSyEk5BLhBAX6cM1qKW4a8dlbnKxsLqLz5cMTz3XW4ssHjODFQqFEA6HAeT22yaTSdjtdmg0mlVWYx+klLthwwaEw2GcP38eIyMj6OzsLMiqrHWwQSAWi+F2uxEIBBAMBjE6OppDe8jGawDsVTbykR90DA0NQSwWX7HB9dWGSv2U2deD87NRIBnDi6cncY27DS+99BKefPJJ/PGPfyzKIAcAkUgEN3So8fEeK8LhMF555RU8/vjjJfeV76e4CDbYBt+DDSZKCeIRti+tVgubzbaiIB7fK/CNgmK2nrQRWywWml3J6XTCbrevarO5uCYrHd5bWlpydKiIYHIpW5C/brOyUSWIA//DH/6AnTt34vnnny/6uDvvvBPA5R7XWOwy/3cxWsGFhQXs2bMHo6OjcLlceO6559CSR+8HXM4sfeMb3wAAPProo7jvvvsKHpPOZGkF8VAohEwmg0QigcHBQUSj0RyGiHMLGXRYDQglAM96K9qKDN9RFIWPbTBiYikGg0oCqaj4zVhtkMF8HT4b8UYzuqVEkkgGS61Ww+FwQKlUFhiY2dlZVvdRqUEgj1cqldi6dSut7i2VSuHz+ei5Hy5R6b6z2SxEIhG6u7sRi8VoOkGPxwO9Xl90rWpeo5aZjdVAgo6ZmRmcO3cOhw8fxrp162A2myt6zSbWFolUBpFECmqpEEKhsGI/9fDffhlvh9qQEEjx0//3cbTPfRz79u1DPB7Hrl27AFweEn/qqadw6dIlfP7zn8fBgwcxPT1Nr5VKpXD33XfjtttuK7nPfPHZRrCxfJyxYNr6YDCI5eVl9PX1FQjiKZXKqihm+YxGOWyuBIFAQLfljo6O4vDhw+jo6FixQs5FVr8cf0TawObn53Hq1CmoVCp4PJ4VfTJXlY1Gmi2s+ltH3uDf/u3fAgDC4XDRAVgSee3du5f+XTFawf379+Pmm2/GI488gv3792P//v0FtIILCwt44okncOzYMVAUhe3bt2P37t10UBKPx/Hz5w/i5YFpDL13GvPHX8ahQ4fwox/9iO4VbGlpyaHs3C5cxKmJIIxqCTSy0h+HSipCF0s85aVwtQcHtSCdTiOdTuPSpUs56rokg6VWq2GxWCCTVU8lXC8Uu2Y6nQ47duzA3Nwc+vv7odPp4PF4eFPZyH+8TCbDhg0bEIlEMDQ0hJGREXi93oJ2sHpVNip9jlgsRltbG9xuN6v96U1wj+V4Ct/9/XnMLcfxiR4Ldq03V+ynbrrpJsSSaQSiSRjVl7Pe999/f9HXs1qtOHjwIADA7Xbj5MmTZe81X3yWq8oGm3ZirSvw+UrqoVAoRxBPqVRCJpNh586drLznq8WPck3iU25brtfrpdtyx8bGaMG9gnmqOlc2mKAoCnq9Hm1tbZidnUV/fz+0Wm1J8dt6BBt8P9fUFOKTm+ell17CK6+8guuuuw4mkwk6nQ46nQ6tra1QKpV0uwxFUaAoqiit4AsvvIBDhw4BAO677z7ceOONBcHGyy+/jF27dtEHll27duGll17CXXfdRT/mT2cvwG51oUVvRKBFhKe/c7kKcvr0aajV6gJtgGvaddhgUUMmFkIkqC77zBb4zvLBl/USiUROtYJoVySTSaTTaRiNRrjd7poyWGvtXIrdWxRFwWAwQK/X03S5YrG4ZgrBUmAjEFAoFOjp6cHy8jKGhobg9/vh8/lymD0qfY1qZjaqrYbIZLIVh/+b4B8ml6KYDcXQopDgiH8Bt6wzVeWnZGIhZGJurz2pwBNwEWwQqlU+BxvF1stms0UpZgUCAd3yashTUgcuf3fHx8d5f/hiA2vtpypBJfegRCLBunXrEI1G6WRVZ2dnTrcLF8ERoUkvFxRFwWg0wmAwYHp6uqT4LZdtVFd8ZQN4/wMUCoU4cuQIfv3rXyOdTsNsNtNVhPvuuw+33norgJUPFdPT07BYLAAAi8WC2UAEb5yfhVUrg9d0uU99YmIiR57dbrdjYmKC/lkqleLRv9mLV85OY3ZyAqET71PfljLiFEVBJeVHWZUvh/mVUE/jxtSuIP/F43GIxWKo1Wp6voLQDh49ejTn/uAL2DY0FPW+5sXx48dx/vx5esaETcNTS2UjHyqVClu2bEEwGMTg4CAoioLP5+N8TwBKEkOs9pxGyRg1kQtHqwIdehXGFsL4y51OVv0U28gfEOfCZvPdr5AgjxlUEHKWfEE8pk5RvfbHNvi+P65Qje2Wy+XYtGkTlpeXMTg4CL/fT88ucs1GVQkoisoRvz127Bj0ej1cLhckEkmzjQo1BhvkTe7atYvuY52bm0NfXx/+9V//Ff/1X/+Fa6+9FrfeemvFXy6RazvOTgZxamIJ96ikaFFKiq6Rf2N4jWrYdAq8ezaMgV8v5+y1OXhX+3pcgWhXMIe20+k0zQal1Wpht9ubtIMMEFVkh8OBUCiE3t5euN1u1qimuZin0Gg0OcwekUikZGtLMdQi6lfpcxrFiDeRC5lYiK/c4kM6k4WIMUfHhZ+qea8yGeeVDXKYZ6tCV+seSWWa2PpIJIJIJIKLFy+uKohXLvjsR/kKrtuoaoFKpcqZXZRIJFAqlTXdI8VQ62fATAQSli2TydQMNsACG1U+9Ho9br/9dnzkIx/Bz3/+c1q8aLUPhESEFosFk5OT0ChkiKfSkAqFEAovX3y73U63WgHA+Pg4brzxxoK15BIhFDJpQS8s3w0G246Gj8ELszQ+NzeHaDSKycnJgkE+lUp1RbWvcDlXIRKJ4PP56D7X0dFR+Hy+mqka2axs5IMwe7zxxhu0wNNqQ3bkNerZRtVEY4KiKIiEpe/Fav0U26gHGxXbvq9cP0DoxPMr00xBPKfTCaVSiePHj2P9+vWs7a8J9sDWvcNGMENmF5mMUCaTiRbQrRVs2X2BQAC73Q6r1Yrx8XGaobESat9y0Eh+ipV3HQ6HcenSJWi1WiiVSkyGMzg9EcDFYArPP/8D7N69G+l0esUPeffu3Thw4AAeeeQRHDhwALt3uLBrnQltKik0sstZyVtvvRVf+9rXsLi4CAB45ZVXsG/fvqLr5WeMuKJZbcRe2FrWqwRMZ0NK5MzSuEQigVwuh8fjuaIdBJdBLvP+k0qlWL9+PcLhMAYHB+k+V0LfW+k+6jG8LRKJcM011+QM2Xk8npLOo14D4o1kxJsoD/l+igwSR6NR/OAH5fkptiGRSHKSYo3aRlVKEI8QdNRbEO9K9idcgVzTcDhM++tQKIR4PA6dTofOzs6q1b7J+mwN7Ov1ejidTkQiERw/fhx6vb5gdmct90ggEAjgdDpx8eJFuo3TarXC6XSykkxtJD9Vk1Ulb/SNN97Al770JXzkIx+BwWTGTOsmtKoUeOvUONZbL6sKMy/gXXfdhUOHDmFubg52ux1PPPEEHnnkEXzmM5/BM888A6fTiV/+8pdobdXi2LFj+H+eegpPP/00Wltb8dhjj2Hnzp0AgMcff7yk2Fk9xJKI0eVrsAHUT9QvlUrl9NwSZ6NQKKBWq4uWxqemphCPx3nrGPi6r9WgVCqxZcsWBAIBnDt3DhKJBD6fr2ImLi4rG0zkD9kdP368pKpsvaoUjWTEm1gZxfyUyWRCR0cH9Ho9Xn75ZVitlzWS6v2dFwqFOX6Jq8oGW2sSjapIJAK/319AJ54viHcl4EptoyKsXkwhW4qioNFo6ADR6XRCJBIhGAzixIkTNR/q2Z5dbGlpwbp16zAxMYG+vr6aD/JctZJRFAWXywWHw0Hridjtdjgcjpr8TCPNFrIys/HBD34Q3//+93Hy5Em809+PM6emMb0UQZtaiv/rn74GADkX/9lnny263quvvlrwux07duDpp5+mf967d28OjW4prCTqxxautEpEOetlMhlafZVkPvKdjd1uh0KhWPULz+cvBxf3ChdYyThqtVrs3LkTc3NzOHnyJDQaTUXvq17BBgEZsjMajTTblslkgsvlorPN9apSMHvc+XyfNrE6ivmp/v5+HDx4EAMDA/B6vfjOd74DAGt+QOYyKVYpyBwdOYySOTqxWIxUKtVQdOJXO5LJZE61gjA4KpVKqNVqmM1miMViqFQqGI3GnOdms1maBZEc6qs5KHOV+BQIBHA4HLBarTnCgDabrSq7z+W9LBQK0dHRAYfDgbGxMRw+fLjqvQKNlRRjpV6s0WjwyU9+Ep/85CcBANFEGr9+6TUMHD+MFp12lWdzg3oN3vE92KhlvUwmU1BSJawQRLvCbDY3nc0qqFcbVSkQPvCJiQlcunQJQ0NDOQf4Wtau5fGlIBAIaFXZ8fHxnNJzvahvuRCMamJtke+nAOAPf/gD/vSnP9GthmsB5neGi3bf1XwfUxCP/BeNRiEUCmmKWaYgXjgcxujoKAwGA6v75Cv47tuY+2Ney3whW8Lg2N7eTjM4MrGwsLDieyWHeovFgrGxsYoJSdiuGuT7AnKQJ8KA1RCm1Mvui0QieDweOJ1OWsTQ5XLBarWyTsrCF3DSnCqXCHH37l34nTiFBx98EP/5n/+JdDpd16xRvQbvrpSB7mIMISTzQWgHHQ4H3n33XfT09NR9f02URjnGiaIomEwmTExMQCwW48iRI6tmp7hgo6oEpN/VZrPRGSuFQlHx4HtzZqOJUrjllluQTCbXzE8Bl7835LsmEAhYF5Fk2tl8QTwifkoE8VQqFUwmE+RyecnvTCMwO7INPvqpTCaDeDyOVCqFxcVFhEKhnGvJVeWJHJTtdjstvOfz+Uq2tBNw0aJUbD2xWJxDmDIyMkITpqz2+vVm5CJ7bW9vx8jICK2cbjaby9pHI/kpVoKN2dlZvPDCC9iyZQtkMhmUSiWMRiMuXryId999l42XqBj16IVl+7BcD9aQbDZLt0GRzAfRriDOplTmI51O89Lo8h1cGrBK26IEAgHa29ths9nojIrb7S5q3LgeEC9378zSc39/P/x+PwQCAaxWa1mGtto2Kr5nNJuoDHz0U/n3GFt+irD+kYBieHgYyWSyIIFUTf99IySJ+Ly/aj4/ZksboYbPZrPIZDLQaDR0u2ktA9KV7okQkpBuh9HRUXR2dkKlUlW9h0qwmo0m+4tEIrQwoM/ng06nK/mctaL/lUgk6OrqQjweh9/vx+joKNxuN4xG44r7aSQ/xYqo3/z8PB566CG6X7+jowMymQxnzpzBpz71KQD1pxSkKKqgPM22AeKissHmeplMBul0GhMTE7TTSafTkMvlUKvV0Gq1sNlskEqla3LDNoLT4juqNY4ikQherxcOhyOHLlev1+esXWlPLpdtVyKRCK2trTCZTIhEIujt7S0rC9QcEL+6wWc/BRS2UVVqE0m7a74gHqGYFYvFMJlMMJlMrLw/PtjtTDaLt4YXMROK46bONrQq2dVbYKLe75dQw5NkIFFNJ21QzAF8v98PjUazalWhXFTjS4gGxuLiIgYGBqBSqeD1egsYBetV2ciHQqFAT08PQqEQzp8/D4qiSgZFa233pVIp1q1bh1gsRldlPB4P9Hp90fd61QyIkzfX3d2NQCCAQCCA/v5+nDx5EsPDw/jc5z5HD3OvxQfBNBCNUNmodj1mFosYqGg0CoqikEwmkc1mYTab6Z7beu+vCe5QiQEv9lhm9odJl6vVajmnyq3G+WQyGUgkEjgcDrS3t5eVBWrqbFzduJL8FLNaQYa2AazI+jc4OAiZTMba/VxvPzAfTuD3787CoJLgxk49hAIKw7MR/ObUFAQCCoFoCnuvd9RtP2xhpS4DElgYDAYoFAreHySBy9pJ11xzDc0oaDQac2YDuZjZqARqtZoWlD179izkcjm8Xm+OthNfhA1lMhk2bNiASCSC4eFh+P1+eL1etLa25uyvGsHatQKrMxtarRYf/vCH8eEPf5jNZWsCuXm4YqOq98xGvlBSKBSis1jFDNTRo0dht9tZ22Mz2KgcXBuwWoINAoVCgc2bNyMYDOL8+fMQiUTQ6XQVVza4fHz+c0gWKBqN0lkgr9db0Jtb68wGH5xPE+yBb35KIBDQ+h4k2GCy/jEPokxBPIfDAaVSuep3iO+zhQQTSzGcmghinVkFV5uC/v1vTk3jvellZLKAvUWOLpMKMrEAAgGFZDoLpZTbGRs23i+TbCUSieDkyZPIZDK0DsladxkA7PgpJqPgxYsXceTIEXrujm0/WO2MIBGUnZubQ39/P3Q6HTweDyQSCW+CDQKFQoFNmzYhHA5jeHgYw8PDdNABNFZSrOZgI5PJYHR0FFqtFmKxGBqNpmBWYi2Q30bViMqsqVQqJ6hgalcwebDztQi4AkVRyGSzSKYzEAuvjHJ8o4NtKluNRpOj0CqRSGC1WstSaK30UM+WQJ9cLsfGjRvp3ly/3w+fz4eWlhb6Oc3KxtWNavzU3r178eKLL8JoNOLMmTMALjP27NmzB6Ojo3C5XHjuuefo+4yJAwcO4Bvf+AYA4NFHH8V9991Xcm8ymQy/+93voNFooNPpEAqFsLS0RB9EdTpdTYJ4fKnAA8BiJIlgLAVHiwwCxntJZ7J4+u0LiCXSeNu/iK/d5oVcfDmI0MhESGWyEAkoKCSXf+dokeMLH3RiMZzAJtvaMYkVA1NzivhtADTNrFgsxoYNG3Iy6lcamLOBIyMj6O3tZf0+rCUwoCiKpvNl0qyn02nWgw023rNSqURPTw+Wl5dpH+f1ehvKT9UcbCwsLOC2227Dxo0bYbFY8P3vf7/goL9WaJQ2KiKUtLi4iOXlZZw+fZqmHiSsEmshlBRNpiEVCWinEIqn8frFFM6mJ3DbegMs2urVRBsBbN3DhG2GGTiGQiEkEglYLBZ0dHRU3d5WaxtVKRBRvcXFRRw/fpweJl1pn/Vgr1rpOaQ3lwwsDg8Pw+fzNduomqjKT33uc5/Dgw8+iHvvvZf+3f79+3HzzTfjkUcewf79+7F//348+eSTBa/1xBNP4NixY6AoCtu3b8fu3btzgpLnn38eP/vZzzA6OopLly7h+eefx1/8xV+gs7MTYrEY69evZ+298yXYmFtO4J8PjSCWzOBGXytu32jKXRcUiq36yU0meAwKaGRiOFreP6B7DUrAoKx4H2yBtC8zAwvit0mXQbHq09zcXF1V6tcSIpEIPp8PDocDvb29OH36NLq7u1cc0i4XbFVirFYrzGYzxsfHsbCwgImJCbjdbtbOWmz6EpVKhS1btiAYDGJoaAjLy8tob29nZW2uUfMdr9frcezYMTz66KMYGxsDwM+2A75Q3+YP8zHp6qRSKYRCITwez4rUg2yj2Je2/2IAR8eWYNLI8LENBoiFAkwH4wgnsxAKgPeml6/oYKMW55yvzLqwsIBQKEQ7oLa2NrhcLggEAszMzNClZrvdXvE151KkDwB0Oh02btxI612sRJfLNXtVuc8hA4uBQABDQ0MIBoMIh8MVObhmsHFloRo/dcMNN2B0dDTndy+88AIOHToEALjvvvtw4403FgQbL7/8Mnbt2kW3OuzatQsvvfQS7rrrLvoxPT09+O53vwuXy4Vdu3Zh//79MJlMWF5exuLiYo3vNhds+75S6/lnw/j9uTl0GpW40VdIMzofTiCWzEAuFsA/H835m1BA4fMfdOD0RBDrzGq6qgEAEpEAW+yV6XWx6TtJuzTx28SuJxIJun1ZrVbDaDTW1W+zDS5biGQyGdRqNdrb2zE8PAyhUIjOzk4oFIrVn7wC2NovoVmfnp5GNptFb28vXZmp9TW4+Fw1Gg22bduGkydP4tKlS1hYWEBPT0/NnyeXYE3U75//+Z/ZWIpVEKMoFAo5m9lYaU2maidzmI+UU/V6fQ5dXTwex3vvvVe3GyaTzeKP5+cxPB/BdS4dNljfL0cPTC2jRSnGZDCGQDQFvUoCo1oChZhCOgP4WMgoXQltVMVK5oRekogeJhIJuN1uKJWFn5nT6YTVaoXf70dvby+8Xm/Fe+CissF8PDHEVquVVj3t6OiAxWLJWa9eA+LlBgFarRbbt2/Hm2++ifPnz0Mmk8Hj8RS9DrW8ThONATb81PT0NCwWCwDAYrFgZmam4DETExNwON4fWLbb7ZiYmMh5DPN7LpVKaQHatfBT5aCc7+r/PjGJWDKN4dkIuk2qgmSUW6/AVocWE0sx3L6+UBDQopHCqjUW/L7eyE8WBQIBxGIxZLNZun3Z4XCU1VpaDzRScKNSqbB9+3bMz8/j1KlT0Gq19LxEpeCK9tXlcsHlctG6Fx6PZ1UK2pXApS8Ri8Xo7u6m/81nsFrLIwaJGLa1/hIQYT+5XM5ZG1Umk8lhlSCHzng8nqPaWc4wHxeOJpXJ4sjoItIZYJtDAxkjYxSIpjA4G4ZeJcHRC8GcYGOzTY3DI0uw62TQyi/fJlq5GDfZRdi23QaJ6Oo7iBWjJGS2upW6xqu1a4jFYnR1dSEajWJwcJB2dGq1etU9cdVGRR7PfC9EzInQ5Y6NjcHr9dK0fJW2K1WrBl6pXREKhdixYwcWFhZw+vRpqFQqunrI5t6aaAxw7aeK2fCVXkMqldICtHypwDPx0tkZ/HFwATvbdbhzc2k1ZqNagveml6GQCOnZCibEQgHu2mGteh9cgJkQzBezVavVMJlMMJvNmJiYYK21jU0/30jJOqbtbmtrQ2trKz0vYbFY0N7eXlHrEhcVA2L3RSIRurq6cihoiTBgtWtyAbK2VqvlfWsea7tbXl6meYtL8QED9R0Yzw822PhiMrMei4uLmJubg0AgoIf5NBoNPVBb6RehGiOUTGewHE9DKxflDNwRTCxnMBMPQkgBMpEA25zvl6NVUiGMailmlhPYaMk92G60atBlUkEkyBu0p8BaoMHXykY2m0U6ncbi4iJmZmbo4JFrSkK5XI6enh68+eabePfdd6FQKOD1eiGTrdyuxlVQX8qYSyQSrFu3jh7IJmJOpIpY6/oroVrDLRAIoNfr0dbWhtnZWZqFxO12F81QNtmorkzU6qdMJhMmJydhsVgwOTkJo7EwE2+32+lWKwAYHx/HjTfeWHJPxE+R1+XTbGEilcFr5+ZhVkvQO7KIm7vaoJUXz6Des9OG4dkIjGpJycestkc25+Tyf47H4zmBRSwWy0kIlhKzJcQsVzq4ZmLKX585LzE2NlZx6xIX+81fk1DQhsNhmhre5/NBqy2/rY/Lz7WRkmKsBRv/63/9LzgcDlrpVywWQ6vVwmAwsMrxXQkkEklOebpSIx6Px3OqFUS7gmQ9SEnVbDazst9KnUIqk8XBgRlMB+PwGJS4uUtf8BiJ4HKAkAUgz8s2iYUCfGKTCdFEGqoi9IFsME7xHdlsFpFIJMcJJZNJJJNJiMVitLW1VR08VguhUIidO3diZmYGJ06cKOArz98/121UpZAvlhSLxWC1lp+5rMYI12q4KYqC0WiEwWDA1NQUjh8/Dr1eX6CkXC2tYhP8Rq1+avfu3Thw4AAeeeQRHDhwAHfccUfBb5ywWQAAIABJREFUY2699VZ87Wtfo2cvXnnlFezbt6/kmsw2Kq6CjXQ6Tf/8xtACekcW8UF3Cz7oWVkMTiyksN6iwtnJZbj1CqikpY8MMrEQG6yrV2NL7ZGtAz0Rs52amqLtejKZhFQqpf222WyGTCZrJhLqiFK2WyAQoKOjA3a7Paed2GAobLUrZz0u9qhUKunBbEIN7/P51rwl96oMNgKBAF577TUsLS1hcnIS119/PYxGI9ra2mA0GmG1WqHX62ml1nqgXCOef+BkDn8RTnO9Xk9XSAjGxsZYH0QjBnc+nEAoloJNJyt56I8l05gOxqFXSeCfi+CmzmxBdcOsFGBbpxGZDOBoKcyQiwQU1DJ+l9/YApPrnFzrdDpNC2IxqYTPnj0Lu91eVGW0UlRjFCmKgslkgsFgoPnKi2V9uBwQL/fxRCzpzJkzuHjxIiKRCDwez6oVmbWkpKUoChaLBSaTCZcuXUJfXx9MJhMd1DWSEW+ifFTip+666y4cOnQIc3NzsNvteOKJJ/DII4/gM5/5DJ555hk4nU788pe/BAAcO3YMTz31FJ5++mm0trbisccew86dOwEAjz/++IoKz8zKBhfVXoFAgFQqBQCIJNL4/85MQycX47enp7Hdqc1prc0HRVH4n9fYsRBOQKcQQyjg5nBe7ftOp9M5Q9vLy8vIZrNIJpOIx+NFRQ6rwdVQ2agHKmknHh0dRVdXFzSa4tTG9Qw2CJjU8GfOnIFSqVy1+4DLxFUjJcVYO2X++Mc/BgCcPn0au3fvhlQqxcaNGzEwMID+/n6k02nIZDLcfvvtddOFkEgkSCaTAN6vbDC1K5jGSS6X0wfOcoe/uKIUDESTeOHUNBKpDLpNKtzYWbxPUCkRYpNVg3MzYVzXoSvaRkVRFOw6fvJ5c9lGRa4z0wkByOnF9Xg8vO9zJHzlzCFyn88Hvf5yFWstKxv5kMvl8Pl8oCgKJ06cWJUudy0qG/kQCASw2+2wWq10UGe1Wunhw2bm88pCJX7q2WefLbrGq6++WvC7HTt24Omnn6Z/3rt3L61KvhqYFfhKKhvjS1Fks4Bdt3KGnlnVl4gEMGukmArEYdXJymqJFQooGNTcDkOX4wuIejpJFkUiEQgEAnpmzmKxQKVSQSgUoq+vjzVK0KvFBtSjjaockHbiYDCIc+fOQSqVwufzFczYcbXfctYkMyek+4BQxRc723I1yM712myD1ZPWm2++iS984Qu444478Oabb2LPnj0060YwGMTZs2cLDh7nzp3Dnj176J/9fj++/vWv4ytf+Qr9u0OHDuGOO+5AR0cHAODTn/40Hn/88RX3Qm7sgwcPwmQywefzIRAI4OTJk3S1wmq11qRdUUlrViCaRDyVgUFVWpiJGNxYMoNkOgOpSIBQLLni61/nbsF17kJRqasJxAnF43GcOXOmYHC7Wo0Srr/ElQRaJOsTiURysj58Cjay2SyEQiGMRiOMRiMmJibQ29sLu90Op9NZkIGpVdmbTZCgzm6348KFCwiHw7hw4UIOq1ATVwaq8VNcgjkgXm4C5uxkCAeOjAMA/nK7FVsdpXvImfOKIgGFL3+oHZOBOCxaadEE1VqA+b6z2SxisVhOa2v+zFyxToMm+I1K/QmpIhCl79bWVrjd7px217U8aJPuA6PRiEuXLuHo0aMwm81ob2/PsR9cVh8aabaQNYv6+uuv4/7778cDDzyAhx56CM899xzuu+8+/PznP4fb7YZGo8EHPvCBgud1dXWhv78fwOWSqM1mw5133lnwuA996EN48cUXV93Hyy+/jCeffBLz8/O0Cuudd96Jjo4O+P1+bN26tfY3+98od+h8PpzACyenkMxkcX1HS0nFU3KzGNUSXNfRgplQAtudlfGLX8lgDvkRR8Qc8iO9n2wPbtcKNjMwCoUCmzdvRiAQwLvvvotwOIx4PF5WtZDrYIMZPAgEAjgcDlitVoyOjuLw4cNwuVywWq30Y9gW9WMDQqEQHR0duHTpEhKJBI4fP47rr7+eV/dTE9WjWj/FJfKpb8vBTCiOdOZy2+xUML7iY/MDGLlYCLeeH3z8pLU1Ho9jeHgY0WiU1p0i+hXVzMyxOXDORQcDX1HPAfFyQFHvK31PTEygr68PNpsNTqeTN1l9iqJgs9lgsVjo6jhTj4rrykajBNw1BxvkzT7wwAN49NFHsXfvXqTTaXzmM5/BkSNH8M1vfhPf/e53odFoVv1gXn31VXg8nprKn9u2bcNzzz0HvV6P+++/H/fccw927tyJVCrFCX95OZWNYCyFRDoLqViA6VACm8pYt6dEQFIN2DzscjWjkg9CJ0wCCzK4zRzys1gsOUN+S0tLZQ1slQO+9+hqtVrs3LkTb731Fk6dOpUzb1AK9ahs5D+eiFQ6HI6c4T+9Xl81G1U9HAxFUXS2mw8OrYnawKafqhWxZBqTgRgsWhlkYmFOu2+52ObUwT8XRTqbxXUdK1e2qyFH4QL5ra2E5YnY7NbWVrS2tvJeL4Bv4IrBi4BJLrBWoCgKdrsdFouFTl7xDaQ6brPZ6D2S1qrmgDgLwQZ5o//+7/9OVw2EQiHS6TS+/e1v45ZbbsHS0hI0Gs2qB7hf/OIXOSqrTBw+fBibN2+G1WrFt771LWzYsKHo45gMBlKpFLFYDAA72YmpYBz94wE4W+RYb1HnDN6tBLtOhi6TCsFYEtsc7AURVwqYg9vEGaXT6Zw5GjK43ajgqrdULBZj69atmJycLDlETrAWwQaBRCJBd3c3otEohoaGMDIyAoPBwHllo9bvfDPQuDLApp+qBZlMFv/y+hBG5yNwtMjxf360K6eyUS40MhH2Xl9eix9btO+VgDA5ltIkym9tPXXqFDQaDWuBBttUumyDj8msbDaLRCKBubk5OsFHzk9KpRJdXV01CQ6zcT2Yyau3334b77zzDjo7O6vSv+AKIpEIXq8XTqcTfr8fMzMzUKvVnA20CwQC3t7nTLDWRrV169acD5MYke9///t0ALBSz3wikcBvfvObohSB27Ztw9jYGFQqFQ4ePIhPfepTGBwcXHVPbIslvXpuDplsFhcXY7D991BeOUZDLBTgphJD3lyDb0aXyR4yPz+PYDCIQCBAD24bDAa43W7eD25XgkoZoyrFakPk1a5dqwhgMcjlcmzatAmhUAinT59GOp2G2Wwum/WL64ApH3z53jTBDmr1U7Uikc5gbCECvUqC8cUoosl0jp/iAlwScTAr0MSuEyZHUoE2Go2Qy+WrDrGzCTbfM5efX62odl/MuRimUvry8jJaWlqgVqtpemAACIVCOHnyJFpaWuDxeKoOCtm6zhKJBAqFAl1dXRgZGaG1nsoRwq0XSIJNpVJhbGwMfX196OzsREvL1Tljy8qJbn5+vqSCYVdXF/3vQ4cOYcuWLdDpdAWP+93vfodt27bBZDIV/I1JfXb77bfjr//6rzE3N1dwmMpHPqVgrWiRi3BxMQaFRAiJSIAEB5zobINtQ1nJWqXUWUl2y2AwQCqVoru7m7X9XQmo9jDNHCI/f/48xsbGCgzwWlU28qFWq9HR0YGFhQUMDAyURSFYDRqpzNwEt2DDT9UKmViI3ZutOHRuFh/vsUAlFeWwUXEBtrQ7MpkMzewXi8Vw/PjxnAq0VquF3W6HRFKaBKUU+Hygb3SUakkmczHkuvn9fthstgKq2Ww2i7a2NrS1tdFzEw6HA3a7fU1tK2nB27JlC5aWlioSwq0nRCIRzGYzTCYTBgcH4ff74fP5SlL6XqmoKdggjvzrX/863G43du3ahdbWVmg0GkilUqTTaczMzMDv9+PIkSN488038U//9E9Fjfizzz5bsoVqamoKJpMJFEWhr68PmUymrLIZyRgl0xmcngjhvYU0NqcyVStg39xtwFQwDp1cBLlYiHADGMh6GHFSfmUas3LUWQOBAEKhEKd74wsqYYyqBMUO+AqFgjbAZ8+ehVKphM/nq+uAeLmPVyqVWL9+PU0hWExgrxZUE2zw/TvdRGWo1k9pNFr0X1xELJnBDldr1X4jHzevM+Hmde8n1WQyGRYWFlhZuxiq8QHJZLJgvoKiLgvaqlQqiEQi9PT0sN72xBbYrmw0CjKZTIFIbSqVKqslebX3SeYmzGYzRkZG6Ar6auJ7XIHpn3Q6XY4Q7mq06/UE2adKpcLWrVuxtLSEc+fOQSKRwOfz1dSa1kio6UoQJ37//ffj7//+7/HjH/8YmzZtgs1mg1gsRjQaxcLCAqanp0FRFB544AE4nc6CdSKRCH7/+9/jhz/8If27p556CgDw5S9/Gb/61a/wgx/8ACKRCHK5HL/4xS/KMgCkF3ZoNoIjo4uYWEzj3akQNturY3iSigRob32f67kRsjFcVDbyjVkikYBUKqUrFuWqszbC58cGir1H8rtinxFbAYFOp8M111yD6elpHD9+HEqlsoCrvNq12Xw8oRA0GAy0wJ7VaoXT6ay5pWUthQOb4Aeq9VOnJwJ45k8jyAJYjCTx8R4LJ/vjuo1qNUHb/PmKaDQKkUhE23OHwwGlUpnznZiZmWH1O8KFL1irin69kMlkkEgkMD8/j9nZWVqklrQkt7W1weVylR0Qlmu/iXq23W6nK+ikXaieyN8v04+Mj4/jyJEjvKjA5PsTEhjNzc3Rs0put5tX1RguwErY19PTg1deeQXnzp3DL3/5Sxw7dgyzs7PQaDTYsGED7r77btx2220ln69QKDA/P5/zuy9/+cv0vx988EE8+OCDFe+LsHxIhOSGpCAqocZdDdgqT3ONag0lM0vCdETDw8M55ddyBBCbKAQbQ9zlvIbZbIbRaMTAwADGx8ehUChKDpHXspdqKiFMI0wE9iwWC8bGxtDb27viwHu5e2oGG00AlfupVCaDLAAKFOIp7hh5mO2+BGwzCGaz2aKJonyGv7VKFF1N9LLVIJ1O0yQq5Ppls1lkMhnodLo1EamVy+XYvHkzlpaWMDAwALVaDa/XWzcil1LfEYFAAKfTCavVSldg3G433R1Tb5TyQXq9Hm1tbZienq65qt8I9ztrd2Ymk0FXVxceffTRFR9TTydO2KjcegU+tsGIU5lprDOzF303Qma+3M+bObjNVFZXKBT0fEVHRwfeeecdbNq0GnlveeD758cmpSBXbVRAefsUCATQ6/WQyWRYXl5Gb2/vqiwe9ahsFLs/hUIh3G437HY7RkZGcPjwYXi93qrK9dVQ5XKt5dHE2qESP7XZrsOnt9kQSaRxc3fhLCFbyK9sEKraWqp6xJ4vLy9jaWkJCwsLOHr0KG3Pa2X4a4Rgo54D4mMLUQzNhrHJqoZxFbX11ewRkyI4FArltLDlK6UPDQ2htbWVlfmiaj8vUkGfmprC0aNHYbVa0d7eXhcbutJnSSowDocDw8PD9AxjqQFtrs4iK/kgZjKQVPUtFgva29s5JapYC7AWbJAbi2RQmCCtEuXcfKfGl3Dy4hI22bTY4qxtal8qlSIQCICiKLjaFJhVClhVTG3UygazH7fY4DbTmF2tWMsgiKssRTabpQ0wGSInSuTFSuBcsFFVsr5EIkFXVxdNlzs6OloW1TQTtbZRNULGqInyUYmfEgkFuGWdmfM95VPfVkpVS4g4mDSzxJ4TNqhkMoktW7awtmc+BwdcIpHK4MTFAORiAXpsGlAUheV4Cj9+6wKSqQyOjCzi/77VW7bdyPfF4XA4hyK4WAsbl6i2rZeiKFgsFhiNRoyNjeHw4cPweDxrVk1gQiaTYcOGDVheXqZ9XmdnZ4EmF1esnZlMZtVqBbOqf+HCBfT29sLpdMJms5W89o3wfWGC9ZobMdjVIJ5K483BObQoxHhreA7dFg1k4uoPvI1MKcgWstksFhYWEIvFivbjFhvcXglrbTgiiTQuLETQopDApLny2re4vJ+YxpQ5RD4wMACVSgWv15vTElePAfFy7jtCl0sqMidOnEBnZ2dZPcLVBhtrfZ83wS1q8VNsI1/Ur1QSi9CVMivQsVgMYrGYtudtbW0F9jyRSGBiYoLVPfO97anW/YXjKUwE4rDrZBAz1nr13Bx+/94cKAB7rxNgg1WNbJYkWiiks/jv1rtCEBKVSCSC9957D/F4vCZfzHyvfAGpSttsNgwODuLChQvo6uqCVlvdnCybUKlU2LZtGxYWFnD69GloNBp4PB7a53HVeVOJHxUKhejo6IDdbsfo6Ch6e3vR0dEBs9lcsAafJA3KwdqP6jMgEQpg1sgwGYjCrJVBUuN8RbFgg+1eWC4qG9XssRhvdjweRzweh0wmQ0tLC0wm06p851ztrxhWcwgXF6OIJdNwtSkg/u974fXzcxhfikEsEOB/bLNALePVLVwUlX5eXFY28sEcIj927BjMZjNcLheEQiHrlYpaH69SqaBQKNDR0VE2XW5zZqMJvqNYZSO/rZWwCslkspwKdDnzFVxU4LlItLG5x1r2l8pk8dSfLmA6GIdZI8Vf/5md/lsinYGAAjJZIJm5vL5aJsLnPmDHuekwtjm1EFAU4vF4ATujWCyGWq2GUCiE0+mETqfj1WGRzesplUqxceNGhEIhvPfee5BKpbzpAmltbcW1116Lqakp2ue1t7dzWtmo1J+IxWL4fD44nU4MDw9jdHQUXq8Xer2e3mOj+SlendQoisInN1uxGEmgRSGBQFDbhc8fvCMGiK0bigtl1nL2WIreLp83WyKRYGBgAE6nk7f0aplsFpOBGFRSUU7gcCkQw8GBGWQyWWxzanGt63JLXSKVhUhAIZ3NIp0pzvLEJwNeKbiulJUqk5O+UVLCdblcFTuHaoKTatTAW1pacM0112B2dhYnTpxAW1sb3G530VJ1NVWKRjPiTdQH586dw549e+if/X4/vv71r+MrX/kK/btDhw7hjjvuQEdHBwDg05/+NB5//PEV102n0wgEAvjWt76Fj33sY1haWsKpU6dyqhWVsArlg4vAgO1EW71t9nw4gQNHxpFOZ3HvtfacKnkyncFsKAGdXISZUByJ9Pvv85YuPSRCARQSITZa1XSST0dFsV4ZxuzoFMbjcVrUsBg746lTp1hJ+gHs+wu2r4NarcaOHTswOzuLqakpDA0NweVyrTklLWn7MplMuHDhAo4cOQKbzcbJa9UyAyiVSrF+/XpEIhG6ldjn80Gn0zWcnyr7igdjSYgFAsgl3PbxS0QCmDTsUIDJZLKcYINkeNi6QFwZceaapVgoyKDfao6Iq95atozSqZkkQovTUIiFuHOLGSrp5Vsylc4ikwGEAgrJ1PvG/qbONpydWoZZI4FOwQ7HO9dgfv6klB4MBpFIJOB2uwt6R7msbKy0tkAggMvlgs1mw/DwMBYWFhAIBMoOVLluu2IabYqiYDQaYTAYaKGpYoN1TerbJthCV1cX+vv7AVy2yzabDXfeeWfB4z70oQ/hxRdfXHGtTCaDe+65B+fOnUMmk4FIJMKmTZtgMpmQzWbR0dFRYBeqBRcVeLYTbWz7qVAii6HZCLptUoiKJC1PTQQxGYhBSFHoG1vCJze9TwAgFwvxqc0mvO1fxEe69FBIRPSMD5VOYJs+i1BoEadPXqDF8VQqFTQaDWw2W1WihlcyiK1WKpUQi8U4cuQIXC4XrFbrmn9OTJ83ODiIYDCImZkZGAwG1vbGRluuQqFAT08PQqEQBgcHASBnCH+tP8dyUFawMTQdwitnpyEWCvDn2+1oVdaH2qxWlKpssAW2y9OpVArpdBoXL15EJBJZkYWiXKz1XEkyncFr5+YwFUrgI75WOFrfP7hSFIX5SBo6gxDRRBrheJoONuwtMvyZpwWRZBqbrO8rbeoUYlzvro04oF4ggUUsFsPAwABdStdoNHTW8tSpU2htbaVpC7mszJS7tlgsxv/P3pvGRnae54LPWWrf92Jt3ItkN9nsZq92JDmxLY2j4Dpqyx7Ldq4SXA9k2aMLI5mbuRdxIAQIrjMIHCBzYY+dwUzsQTITBVe5iRVNK7HHu1vdJHtjL9zZ3HcWWXsVazlnfrC/07VvPEUW5XqAhtTNw6++qjrnfb93eZ63t7cXwWAQ6+vrWFtbK0oiz0QtwcNhgxOKovKIda2trXA4HDUnF5rBRhPl8KMf/QidnZ1obW2t6fdpmsaf/umfor29HdPT0/ja176G3//93wdwMMOiUVqKjmpNMdfbiybx1kQMkoVVfKgjjs8MOfKuaTUetObyPNBhzk+mXG7TY8AqRSgUwtzcFkKhEEZHRysajndSUe+uAIqiBNs8OzuL5eVleL1eGI3Gur1mpZBIJGhvb0ckEsHm5qYgnCIG10RMf6LRaDA0NIS9vT2B9xOLxY58xkktqCjYWPBFIWVpRBNp7IT3T0ywUagXtlGMeO7E7VgsBoZhkEwmwTCMaCoU9XYK0UQavkgCFrW0IJl/K5TA4m4MGjmLO8vBrGADAM7aJPBJWHitKlg0T+8rmqIw4NTmLtewSCQSCAaDBXt0aZpGZ2cnVCqVYMyJYW9pacHq6iqGh4fh8XhgNpvrtsdqy7kURaG/vx+RSKQoiTx3/XoQxCu5PpNY9/jxY9y8eROdnZ01OdCmGlUT5fDWW2/hc5/7XMGf3bhxA4ODg3A4HPjGN76B06dPF7yuq6sLwEEF/jBqVOVQj3v4OIINjucxuRGGhKHRZVEWfV970SQSaR46CY2lvXjBazrMSvzPH+9EmudhULBZvpgMxyPdA0ajEaFQCBcuXDj0+zyJEDtQlUgk6OvrQyQSEYYC9vT0HHurN1FrHBgYQDAYxPT0tMCdOMze6hHEGQwG9Pf3Y3x8HPfu3YPb7UZnZ6eoryE2Kgo2zrh0WPFH4dTL4TJUPoH4uCGTySpS+agVlZSnM4nbhF8Rj8ezejqtVqvQwzk2Ngar1SrqoLx6TWZNcTz++cEmArEkzGoprg7mKyYYlBJo5CxC+2mcbtHkrWVUMHj2dP3lJcVELvkvFosJ36dWq83r0fX7/UV7dElm3m63Y25uDnfv3q1bVr1WAjfhSBQikYuxfjXXl/tsJBIJenp6EI/HMTs7i729vaozZ83KRhOlkEgk8M477+DP/uzP8n42NDSExcVFqNVqXLt2DS+99JLQ9lAMuUIm9SJ0i73eUQcb1+f28P37G6Ao4Pcuu3DaUTgZ1WpUYNAmRYRhcfVM9nyUQm3Jj3le6B4oNBwvnU5jaWnp8G8yA42uYnkUUKlUOHfuHHw+H8bGxmAwGNDZ2VkzN+mwyKyca7VaXLhwATs7OxgbG4Ner0dnZ2dNlax6qlwplUr09/c3DPm+FCoKNqxaOX7vw+313ovokEqlWRmjerRRZa6XOaGV/MlVEHE4HJDJZEWNfz32WC14nseKP45kmkerUQEmo+c1c9/JNIdwPAW1nMVeNIU0D7A5b0spZfDy2RbEkmnoFNlG5CTIJ5LAglQtSKCo1WoLkv9q3RvLsujp6cHu7i7GxsZw9+5d0bM9hwkGipHIM/tu6z2Xo5o2Lblcjv7+fszNzWF9fR23b9+G1+uFRpMf8BZ6nWaw0UQxvPfeexgaGoLNlj/oT6t9egB+8cUX8ZWvfAU7OzslK5a57b4nYX6TGLab43nsRZPQytmK1vPHkqAoCmmOR3C/+ER3hqbwEY8cLpcdQArLy8vCDAsAxz5PqlGrpcclrmIymXDlyhWBe+d2u+FyuY7cBhfyR2TK99ramjCw0OPxVHXP1GtILPFTFEWdiHa+hlKjEhv1bKPiOE6Ql52amsorvZpMJrS2tlZ9E9Sjv7ba9Vb8cbz7cAvggQ93GjCY0c6UuT+FhMEz3UZMb0bw4XZNQSIecED6l7JHYzhqNZg8z2e1Qvn9foyNjQkKX9VITR4GCoUCer0eHo8HY2NjgtKSGOodYlQeCKHO4XBgbm4Oy8vL6O7uFiaRHxVBvFLIZDJ4PB5otVpMTExAoVCgq6sLCkXxCm0z2GiiFP7u7/6uaAvVxsaGMMhsZGQEHMcJz0Yx5LZRHTfPrhKIscd/vLeBkUU/HDo5XvSU91Mf6TYhmkhDytIYcmf30qdSqawkn8/nQyQSgU6nO5bheE1Uh8wK//z8PG7evInu7m5YLJYj20Mx/0hRFJxOJ+x2u5Boa29vR0tLS0X+q15zm06an/pABxtyuVyUNqpUKpU35RM4KAPyPF+w9For6pHt5zgOu5EEFFIGigqGJCafTCaiKSCezM8gZe6vx6pGj7U2ctJxOVWe5wvqoMtkMqEVSq1Ww+v1ilJZqOaQTz4Pk8mEy5cvY2VlRTT1DjHbnKRSaV7fbTpdPNsoxn5qlbGlKAp6vR4XL17Ezs4O7t27B4PBgI6OjoLJgJNmxJs4OkSjUfzwhz/EX/3VXwn/9p3vfAcA8Prrr+Ptt9/Gt7/9bbAsC4VCgbfeeqvsPVvvdt96QIw93l0JwqKSYi0QRyghg6aML9DKWXz2vOOA7xjYw3rGxHSGYYSkUGtrKyiKgtvtrqiSWQ6NHvw1aqWkFrAsi+7ubrhcriw+hxjfYzmU80eEF0jUGhcXF9Hd3V2WZ1kvf3LSuIUf6GCjljaqTOJ2piEjpdfcDMno6Cj0er1oe65HsHFvLYxZfwhKKYOrg3Yoy8gXe4wKfKhdj/00l1XVIOudJGQGFqRqQQYdEudUqLVtY2Pj2N4reV2apuHxeNDS0iKod/T09MBgOBo1rkqCAdJ3u7e3h1u3bmF8fBxdXV0VVfSOorLBcZzQA0xRFCwWC8xms1AWL8Q/OWlGvImjg1KphM/ny/q3119/Xfj/N954A2+88UZVazIMkxWo10OqVmwQP5VMc3i0HoZGxqDTUp1U7/O9Zrz3aAv9Dg0MinRBv1dqOJ5arYbFYoFSmU8W/1V5bsU8KzTSjCqFQoHBwUH4/X6Mj49DrVaju7u7ru1ClQYFJNEWjUYxMzMjKFcVC4gaaVjgceIDHWyUIt7lZrfD4XDFhqyeENvRUBSFFf8+VDIFQvEUArFk2WCDpSmcdReWfGvkLA8h42ff+xfAAAAgAElEQVRWoTIDC6KDXoozc9wo9NkS9Y5wOIypqSmwLAuv11uyFajY2tW+70qvNxgMUCqVMBgMGB0dLTjzotB+6sXZyPyd3NfILIsvLy/j5s2b8Hg8cDqdgo04LpJiE796KNSq2Kg2loD4gX8d38aPp31gGQqvP9NaUEa2GD7SbcKzXUbQFIWlpYOZFdvb2wWrzdXw4zL3JwYa2ed90KHX63Hp0iVsbGwInInM+RJiolr/qFQqMTg4iEAgILTodnd3Qy7PnhN3FJWNk4CGCTba2tqg0WjAMAxYlsWtW7eyfs7zPL761a/i2rVrUCqV+N73voehoaGSa5KhfqlUCrFYDLFYDCsrK1hYWEAymcwyZEfRj18JijmaFMdjbjsCCU2h3Vx5AERRFM45FLi/w6PbooJFI57K1WFxGCOeqfKV2d42MzOTNUVdTFWvw6CaNqpi16rVapw/fx7b29u4e/curFZrVZ/fUeiok6msi4uLZXtb6y2VS16jlFxu25OBTqRPuKOjo249tk00UQlOQhsVsd3+WAosc0DajiUqa6PkeR6xWCzLdkejUUgkEpjN5oqEVCrdXxPVIfPzTqfTQhLW4XAcikh/mO+C+BWr1YrFxUXcuHEDHR0ddeG21nK/6XQ6XLx4Edvb27hz547AsyQJq2awcYCGCTYA4Cc/+UnR/rf33nsPMzMzmJmZwfDwML785S9jeHi44LX379/H6Ogobt26hcXFRVy6dAlf//rXYbVaYTAYhCmfjYhiRvLBahA35vdAAXix34ZWY2VZbYqiYNdI0d8uzvyG4zDimYEFaYVKJBLCgCUSWDx48AADAwMn6gEshHIGz2KxwGQyYWlpCZFIBGtraxWR1Y6qTE7TdFZv69LSUsHhTdUay1pnZpT7HYlEAq/XC4/Hg7m5OWxvb8PlclX1Ok00cViQ+7tewUbu8+OPJsHQFDTy6o8BxA/8Vr8VEoaCQSlBjz2fu1dMoTF3ON729jYAwOl01v4Gm6gZHMchmUxifX0dsVgM4XAYwEGCi0z97urqEnWydrVgGAYdHR3CtO9oNIpAICDK4D3gcERuijqYkk5adEdGRuB0OuHxeOraRnWSkmINFWyUwve//328+uqroCgKV65cgd/vx/r6OlpaWvKufeedd6DVavHZz34W169fx/Xr1wEACwsLUCqVDRtoAMUP8ymOB00BHA+kucoP+8ehh17NWrkolPVKJpNCK5Rer4fb7W6YioXYqPSzJapQKysr8Pv9WF5eRm9vb0nDe9Q9ubkk8oWFBXi9XmHa6VFUNqr5HblcjtOnT+PRo0fY2dlBIBDA4OAgVKrqetGbaKIaFOIb1GviN3mtR+sh/O3IKhiawpee8cBd5fwssp5BKcFnzx9M6OY4DqFQOGumVK5CY1tbW8EWxXq0D9fTTx0Wx1l14TgOkUhESNyFw2FBjRE4CPhUKhUYhhHuGY7jMD09jaWlJfT29lY9sVpM3yOTydDX14dAIIDp6WnIZDJ4vd689qVqIYZELU3TgqoWqcKk0+m6czZOQtDRMMEGRVF44YUXQFEUvvSlL+G1117L+vnq6ircbrfwd5fLhdXV1YLBxh//8R8DyL956pExqsRoBJ7og2sryCAVM5KDTi0YioKUpSqualSzx+MAz/NIpVLY3NwsGFiQrFelwaHYD9xxE8QrAU3TOHXqFEKhECYnJyGXywv2jQLHRwDMJJE/fPgQWq0WXV1dVRv3Wgni1f4Oy7Lo6uoCy7JN7kYTR456DfXL9ANTm2FBbXDBF6s62CAVi9XV1awDKxmOZ7FYqpLsbgTJ96PCUfopElhkJu/I96TVarNmjYyNjcHhcBT0t3K5HGfOnIHf78fDhw+h0+nQ1dVVsX0U2/fw/MG07wsXLgjtS1arFW1tbTWrgoq5R5Zl0dnZCZfLhevXr+PWrVsFq/uHAc/zRz4j5jBomGDj+vXrcDgc2NrawvPPP4/e3l4899xzws8LGY5ayK5H3Qu76Ivih5M7oAD81oAVdm3p6LuY0ZWyNIY81ZcL62HYajHipGJBsimkFYrwaaoNLEq9jpgIxVNgaKosqb4WFKvs1AKNRpNleG02W57K0nGrjRgMBly+fFkg+yWTyaqex1rKxrW2XtE0Db1e3ww2mjhy1CPYIGsSe3C5zYBH62EYlBKcbimdpSa9+5liKoTzaLPZRBmOV48K/AcdgVgS/zQVhnaVwuc/pIJaSiMajWb52MwA0Gazoaurq+j3VMnnr9frcfnyZWEAn8fjgcvlqpi0LxaIXc9sX1peXj6UTHw9/KNMJhMGzBLlqszq/mFw0oRMGibYcDgOSrFWqxVXr17FyMhIVrDhcrmwvLws/H1lZUX4nUpxHCofG6F9gAJSaR7b4WTNwUatqEeAVW5/5fp0jUYjWltbAQATExNoa2sTdX+1IMXxSKQ4IajgeR4LuzH8cj4ElqHxbwasMKmOpv2uGjJ57u8Rw0sI2p2dncKQseMONsgeCdnvF7/4BUZHRysekHRUlY2TRrxr4oOBzANU5rMdiB3M4NApaj9Y5K7p1Mvxx5/oEn5GkDscLxKJgKZpQaHR6XRCrVZjfX39YB0RORaN2u7bCLg5v4fJzTB+vduENpMSHMfhp5MbmN6Og9rZBx3bxVkzJVQsxJz9lQuKejqAb25uDsPDw2Ul2etN5qZpGq2trXA4HIJMfLWVhHrafbVaLVT3Hz16BJVKhe7u7kO1g580P9UQwUYkEgHHcdBoNIhEIvjBD36AN998M+uaT37yk/jmN7+JV155BcPDw9DpdAVbqDJBbsZM4l0qlRJ9/6UOcb02NdYD+2BoCh2m8qVqsbNa9S7ZlgssSvXpJhKJhnAI+ykO//xgE3vRJC636XHmyWyRVX8cLENhP5WGL5I8kmBDjM+DELQdDgdmZmaEPttGAsMwkEqlOH/+PB4/flyURJ4JsaRv6/E7TTRxGEilUqFakOkD5n1R/B/Xl8DzwO9ecaHHVltGtJBfyQ0sCg3HUyqVBZ8FsZNY9UgENoJvqQbJNIeHawfzsLxWlWDrtkL7+K+3V0BxKTyc38DnvDTS6TTScSkAHjKpDBf7O3DOc7j5S9Umo1iWRU9PDyKRCCYnJ4W/H0ULb7H1iEx85rDZnp6eiobzHkUyzmAw4NKlS9jc3MTt27dhsVjQ3t5eU1B40vxUQwQbm5ubuHr1KoADA/j5z38en/jEJ7Ims7744ou4du0aurq6oFQq8d3vfrfq1ymX7QjGDwKRSrgVBMRIFrtJdQoJXhq0i7bHaiHmejzPI51OY3t7W+jVrZQA2AhY88fw89ldWDUyPNtlhIQ5eFD3oknsRhLQKyWY3AwLwUavTY2taBA6OQuX/nDks2oghkwucFDC7e/vRzAYxOTkJPb392GxWMTaZt5eagEh+2U6B6/XW5CUfVSBw0kz4k2cfJABtLnBxuOdKJJpHgwFzGxFag42eJ7H7u6uMFsqHo+DZVkhsDCbzVXNlGr0ysFxV3CLged5cEU+tx9MbONHUz6AS+Mzp7UwSxIHLVHxFBIxHmmKRYdFg8HBAz7ZRZ6HQTkOi8WC027xBgtXC5VKJUiyH1ULb7n1CE/Q5/NhbGwMBoMBnZ2dJc8mR1X5pygKdrsdVqs1a86Ty+Wqeu7USfJTDRFsdHR0YGxsLO/fMyezUhSFb33rW4d6nVJVg+W9GP51YhsUD/xmvxUOXWWHy0YODg6zHs/zecSydDotVC3MZjPa29sPFVjUw2GtBeJIpA+moJNggmB0MYAUz2N2+8BpO58EECaVBE69HBvBBJ7pepodMqkk+NyFo5VirMbgVXqtVqvFxYsXMTo6iomJCYTDYdEHIx3WUBPnsLu7iwcPHggk8kwOTy2vcRjORhNNHBVIsAFk28VBpxa3lwJIcTwutJbn7PE8nzd1e39/H4lEAjKZDEajsarheMXQKH7qqNYTA/spDv/n+0t4MB/B78hC+HC3IovHODG7C/9eEjTDIBSTocduFpJ3vQP7WA/E0W1VCVlwiqLg0LCw6xtjSC2RZCctvF1dXbBarXVT86pkXZPJhCtXrggcE7fbXfRQf9R2n7R+Zc556uzsrPgza6pRNSAq0S/fDiWeZB0obIf2qwo2Mol3h8VxGF2O4/JaoUjFQqvVCqU+iUSCiYkJ2O12aDQa0fYoFnbjHEYfboMHcNalw4c6ssvKbqMCtxYDUEiZrOqVhKHxW/02pDkeDH28D2213301mUiFQgGv1wufzyc4A7F008WQDQQAo9GIy5cvY319XZgY6/F4wDBMTc9Zs7LRxEmATCYTpEcz/ZRZLcUffrwDQOEWVjITgcwgyh1WS4bjTUxMwOVyiUJMJXv5oAcH1SIYT2E7tF8w0cXzPGbW9jC5ugcJkvjHkTlI/ItZ7ca/91EnfjYXgEbO4qM9ZrAZvsiulcGura/cuxiZ/cwWXiKV29fXB4lEcqSVjUxkckzIob67uzuvyi+WD6sWLMuiu7sbbrcbs7OzQnVfry9drTppfuoDH2ywLItUKgWpVFqyz7TLqsLibgw0BXSYK9fVF7vXtN4EcRJYZGpsp9PpqiQLxdQvr3QtjucxuujHViiBD7UbYFbn8ydS3MF1LMMgnsr/ns+5tGg1KqCQMAXVpXIDjUaXvq32eyBSeZ2dnXA6nYIz6OnpOXTwKGYJmqIoOByOrEnkZLJ3tZW0wwYbJyFj1MTRYz0Qg5ShYVKLcwDMrGzkJsWIncytNGdy4/R6PVwuV1HCaaMLj5z04CWaSOO//HQewVgKfXY1XjlrzhpCm0wmwbNyaKU8NmM0nh9w4tJQa946L58rzy04CZDJZBgYGEAgEMCjR4+gVCpF/T5q8TfkUO9yubL4HMT3HbeAClGtCoVCmJ6eBsMw6O7uLjrnqRlsNBhkMhn29/chlUpLBgZaOYurZyvnVhA0spHkOA77+/uIRCKCo+J5XuBYWK3WqhUrjuth3Art495KEAoJjfcf7+KTZ/K/K4uShsNqQCTJY9CZf3imKOrIFKVqRTXffbXGMfN6opseCAQwPj4OjUaT17ZUDeoxzZRMjHW5XJidncXW1lbV6jfNykYTYmPksQ//98gSGIrCv/9YN9qrSE4VQ2Zlg+d5YZpzbqW5Vm6c2MIjjZ5kA8RJivE8j8XdGPz7hdfieR7xeBzz67tY2/ZDihRuTe3ivGqv4Kyoc2c43HnwCP3dpkPvTWzUIzjT6XS4dOkSFhcXsbm5iaWlJbjd7kP7isMEBgqFAoODg/D7/RgfH4darUZ3d/exBxsEGo0G58+fh8/nw4MHD6DT6dDZ2Znnm0+an2roYIPneeyEE1BKGahktW1VKpUWLE+LhXqoR9WyXrHhPRRFQSqViiaFJ7ZT2I1x+KexDbToZLjYqgdd5GFXSlnIWBqxBIcuS+HsHU1RON2irovc31FCbM5GqeuJMyBtS06nEx6PpyE0ygmkUilOnToFiqKws7ODcDhclEReaF/NYKOJSpBIcfine6vYjezjU+dcsBaQKW9ra4Ps1EfBmdpBMVK8fN6ZFWzwPI+vfvWruHbtGpRKJb73ve9haGio6GvG43E8fPgQ6+vr+JM/+RO0tbXh6tWrSKVSSKVSVQ/HK4ZGTorVaz0x8JNpH/5lfBtBfxKn+mMwyamsikUikYBcLodarcZHugxYCHJ4sd+OgSciI7mQsjQ0UlpUW9moa2WuabPZ4PP5EIvFcPPmTfT09BxqwJ0Y/kav1+PSpUvC3CeZTFb1OIV6wmQywWg0Cr7ZbrdnEe9Pmp9q6FPZnaU9vD/ng0LC4DPn3dApqycjlypPiwGxjWQl8rwksMhshcod3kMCi42NDSQSibL9f5VCzPdLURTub6dglaRwb2Uf7SYlrJrCgYRWzuLqoB2RRBq2IteIiXqV4Ml3FwgEwPN8QdWOeqGYgc5sW3r8+LHA5xBjbTFBprKyLFsy45OJwwwCbIQsVxNHh0drAfxsagsShsa7zBr+3TMdBa/7h2/+Kd6ZCEApY9HvzLar7733HmZmZjAzM4Ph4WF8+ctfxvDwcMF13n77bfz5n/85BgYGwHEcXnjhBXzmM5+BTCbD+Pg43G63aO/tV63t6bDrEaL9xPIO4tEIYokUfjZyD6dtB9UlnU6X17bWUfh2aQJPkz5EKndqakpo4VUoqpteT9YTwz5nzn26c+cOZmZmQNO0MJvqsDjsPolvttvtWFxcxI0bN9DW1gan09kMNipBPJnGzcc+cDyPD3eaIZcUJn2u7MWglDKI7KcRiCVrCjZIGxVQn1JtPSobmXvkOC5vemtmYEHI2sWIs2I7mXJYD8QRS3JwG+R5JLlCMMgpRBJpKCUMVGWmdOsUkkMNtjpqkD7rZDKJqamprImuWu1B5it38B5Qv8pGOZAeUZfLhampKUSjUYTD4YpIpUdBriPGtRCJvJS6Vi2fUTPQ+NWDXimFhKGRSvMFqxoEdq0Mf/Rbpwr+7Pvf/z5effVVUBSFK1euwO/3Y319veBMqE9/+tP49Kc/DQD48pe/DK/XC41Gg2QyWZcKfCMd5uu9HpCfuElxPN6+s46Z7Qh++4xNkDgHICh4kQRePB6HXC7HeZsCwX0FrNJ9XP31i1BIGzo/eyjUM2GUubZKpcLQ0BC2t7dx9+5dWK1WtLe3VyX+UQ/fp9fr4XA44PP5hEBIpyuvAFcKYrUXE+K9y+USEoKZa58Ef3UsT87kehD3VwIAAJ1CivOthYfRXG434UcTm3AblGipcc6BTCZDMnkwgbXRKxscxyEejyMYDAoHvczDaUtLC9RqdVUPpdg3Yan3uxncxz8/2ESa5zHk1uFyW/khQ/1mBq5uGzRytuZWuUYAUYYhzioYDArEe57n89rYyOHc5XJhZmYGKysr6O3tPTLORikoFAoMDAzg5s2bePjwIXQ6Hbq6uo5dozzzNXJJ5Ddu3EBHRwfsdvuJMLxNNB7azSr8wfM9CO0n0Wsv3AZDURReeOEFUBSFL33pS3jttdeyfr66uppVkXC5XFhdXS07gDbXT4l98G704KAefioXa/447iwHoJJSeHt0EZqEGqFQCLFYTFDw0mq1goIXWePKADA6OvqBDjTqjUL3CpHKXVpaKph0K7ee2PcMx3GQyWQ4ffo0QqEQpqamIJVK4fV6Cw4qrARiJ+EkEgl6enoQi8Vw48YNjI2Nobe3t27zs8TEsTw9ahkLCgAPQFPigGnXyfGFK/mKDdVAIpFkVTYaJdhIp9MCxyIYDCISiQhqQQzD1BRYiLm/Uii2XiLNgeMBhqIRTZT/nCmKAgWgpUKZ4UYBKbFnBhbJZLLo1PTR0dH8NrZEAsz770Py8Y+jv78ffr8fDx8+hEwmq6qsXI9gg1wrkUhw8eJFrK2tCRrlxch91WZwarknC5WNc0nkZBK5wXC4abpN/GrCYyqtBnT9+nU4HA5sbW3h+eefR29vL5577jnh54Xu60qei6No923kNiqgcpvA8TySaR4ytvghjuwvkUgINnpzN4h4MAw/R2HIqYZKpRJl5shx4iTJBRf6jGmaRltbG1paWjAzM4Pl5WX09vaWVUesR7CRuSYhae/s7ODOnTuwWq1oa2urmjtVD+EU4CAhqFQq4fV6sbCwAJPJ1PAtVccSbHRa1bg6dKAq49RX369XDXL1y4+jjSqdTue1QgGAWq0WtNBJYLG9vY1wOHzo8h1BtU6B43mMr4ewn+LR79DkGfRSD45TL8eHOwwIxVM46yqcGTyJyC2xk0m/Wq0WOp0Obre7rIoTuUe4VArU0hLg94N/9AhoaQF0Oug9Hly+fBmTk5NYW1sTKlmlPu9apG8rNXzESFIUBafTmcXn8Hq9MJmy1VTqVWWp9HcIiTwcDmN6ehoLCwvo6empav0mmigHQiC1Wq24evUqRkZGsoINl8uF5eVl4e8rKysVkU4z/VQ9Dif1aKM6juAllkzjf//lEtYDcbw0aMeV9qdJBRJYhEIhbG5uIpVKYWNjQ6hYDNrt6D/Nwh9PoUUrP/aZSo0GnucPZo1xnPAHACQTE0ifOQP6yfiAWtcu9bsymQz9/f0VqyPWO9gADu5JUn1ZXl7G8PAw2tra4HA4qvKj9QoCOI6DTqfD4OBgwwcaQJlgYzMYh61E72qtoCgKLsPR6EkXG5YkFnKNZKHAgqIooRXK6XRCpVKV5FgcZ7l7cTeGn8/ugqEppDgurxWq1Ho0RWX1wVayt0ZDMplEKBRCNBrFxMQEEokEJBIJtFptwRJ7IZB7jOd5pNNpoYpFMmjMwgL27o1jXmtD97UfwnjlPPBEAcpkMoGiKPj9fqG1ivA7clHvA37mtSzLwuv1IhqNYmpqCouLi+jt7YVSqTySvQCVGW61Wo2hoSH4fD7cv38f8XgciUSiJknfRrw/mzg+RCIRcBwHjUaDSCSCH/zgB3jzzTezrvnkJz+Jb37zm3jllVcwPDwMnU5XtoUKyPZT9YDYwcFxcUBW/XGs+uPQyhj88NEa7FRAaIViWRZarVaYFyWTyQpKZavlx8/7a5SKBMdxgp8CgFAoBJVKBYqiwMZioEMhJEdvg1arAZsNtMFQk12s1N7nqiMWm/hdrzaqQv6FTPp2OByYm5vD8PAwvF5vRWpa9eYyniQfVTLY+G93VvD5S601EbMbBfUsT6fTaSSTSWxtbWF9fR2RSAQURQkVC6fTCbVaXdXNdtzlboaiQIECx/FgjyBaPs6+31QqJQSFhCfDsqxAuG9vb4dWqy27bqbBzs2MpEGDMXnwy7vjONVqR2trK9LPfgTvjgfBRVKYkrnxyuXLoFMpwYEzDIPe3l4Eg0FMTk4KOuC5nIl6HvCLlX+VSiXOnTuH3d1djI2NwWg0orOzs2qjWosRrmb/RDbwZz/7WUUk8iaaKIfNzU1cvXoVwIHt+PznP49PfOIT+M53vgMAeP311/Hiiy/i2rVr6OrqglKpxHe/+92K1s70U/XASSaIkwRQKBSCfy8IPhLE0h6Fj3VpIJfLYbVaoVAosmzDysqKaHsTG8d1QCR+Kvd8QVEUGIZBT08PZmZmnqr83b6Nfxpbxy/SVvT/4yj+rVcF7sXfBC2Tgaarl++t9HrCx7NarXj8+LFwuM+sph9FZSMXEokEvb29iEQiWUMBScKtEOrVRnUSUTLYSHM8kkeoZFQPiKVGlU6ns2ZYkMCClLJcLlfVgUUhHMYphOIpSBgqS92r2vfsNsjxiVNmJNI8Osz5D1E9enXFRLG9ZVacCEeGpmloNBpoNBq0t7dDqVQKhmFsbCzPgQHFDXYsySGR5mFSy4R7gKZpXJ/axuRWCgzTAleCw+joKFr1RlB6PdJWK+jtTdDxOCiNBolEQmixAwCtVouLFy9ifX0dIyMj8Hg8cLlcdStlV3Ot0WjElStXsLKyguHhYZjN5qr2UosRrrYkTVEHM2YuX76MhYUF3LhxoywJsZHv7SaOFx0dHRgbG8v799dff134f4qi8K1vfavqtY+isnGcwUYyzeH63B7SPI9nOo0F23N5ni+ZANJoNOjr7sDXBxRIpLiSgiK/6ge8UoEFCRRIdwVN01jajeFvR3agk5vxvIU9qCp0e/GL+wk4EMFDqOF/5iMwSKXC2plrlUMt915uNX1paQm9vb1QKBTHEmwQqFQqnDt3Dj6fD2NjYzAYDOjs7CwooHLS5GnriZLBxsf7bDCr6z/ToJ7I7YWt5KZPpVJZrVAksCAGz+12Q6VSgaZpzM/PQ61WF211qRa1OoWprTB+PrMLOUvjk2dsWRKx1axHUVTZibhiztmoB3LnkIRCoayKU+b3V26ddDpdsNKUabADsSS+/3AH+ykOz3Qacdrx9F5IpDmwNI00x6PF4YKuzYmZmRl4eo2ASgeLV4eJ5WWEQiEh+HG5XEin08JrkCwPKeH29vZCr9fXtbJRybUURcHtdsNut+PRo0fY29tDS0tL3crLtVRPgAMSeWdnp0AiX1xcLEoiPwpVrSaayIVMJstKNIiNSuY3VYNq/dTtpQDeebAJigI4jsfzfZaswGJvbw+BQABjY2NFE0CZKCerXg8xmEYFqapnBgEExIcQu3lvNYRVfxy/1mmESfX0M/zp9A7C+ynshBO43O7EhQstePzgAbpi65g0d6GfC0LHJQQeX2YgU0nAcRi7SqrpPp8Pd+/ehcVigUajObI2qmIwmUy4cuUKVldXBQGV3Javpj95ipLBRm/LySf5liPeZQYWJJNSLLAohHrP2agUy7txyCU0ook0fJGkEGyIHVU32oPD8zyi0ajw3d27dw8AsuSCu7u7y6p6EUNN/gCAz+eDxWIBwzCY90Uxsx1Dv0ODNnP23IlAPI1YkoNSSmNlL54VbPxahwlaWQAyKo1UaAfzwSBisRikXBLJ3QUkdTq0tbVBp9MJ31UmSY+madA0DZZl0dPTg3A4jMnJScjl8rIE8kKflZjBBoFEIoHb7QbDMFhYWKhoWFOtlY3DvF8iaxgOhzE1NQWGYeD1erPK4M1MVBPHAZlMBp/PV7f1j7uyQfEckskkUskk1leXMRKaB8Mwgp91uVwAgMHBQdH2+EGsUhbyU7u7u1AoFIKviCZ5qOUs2Byft7wXw9+NroICsOqP4cvPtQs/89pUeLAWhEJKo0UnP5BYPXcOdocDY4+XYFUZwOufitYQu5rrp0pVjA97diCH++XlZUxNTUGr1Yp6mK9lLYqi4HK5YLfbMT8/j5s3b6K7u1uQoj0Kf9JoZ7Ji+MALR2f2wqZSKaRSKSwtLQkVC4ZhhIy3x+OpKOOdieM24gQDDg02g/to0crRosuuRjXC/sQAzx/MsshUhkqlUlAqldBqtZBIJBgYGCiriV3IYKc5HgxNCdWKvr4+zM7Owufzoa3Ti1/MBSCX0vjRlA+/a1Rm8VkcOjnaTAoEoimcdWsRi8UQCAQQDAYRDAZBp1KQKJVIMTrY7XZ4vV4wDAOO4ya6/g8AACAASURBVATD2dnZKRio3OwRyeiT6sz58+extbWF8fFxsCxbF4NWS9VEKpViYGAAOzs7Qgaqvb29oFxgvQjiua9R6HryGZIyuF6vFyaRN4ONJo4D9W6jOsqkWG7LMRFJ+YhTBplch2e8Nug02S3HYvNVTsoBrBQEBcMnPiATxB90dXVhfn4ejx49Qk9PD34wG8KNx3vwWtX4d7/mzvJTDE2Bpimk0vl8zMttBrSbVJBJaOhJVwRFQWe341mbDWtraxi9cwdtbW3CLKNCfqqa1qpaQMjaDMNgeXkZo6OjJUVUqsFhAheWZYWBuDMzMwKfo94E8ZOEhgg2lpeX8eqrr2JjYwM0TeO1117DV7/61axrfvrTn+K3f/u30d5+EI1/6lOfylMCyUQgEMDdu3fx/vvvY3t7G//wD/+AP/qjP0IqlYJEIkFrayuUSqUoHItGqGzYtDJ84VK+8kY9goOjCDZ4vrpZFsBBJSK3gpFpsHMz4+S7vz4fwMxWFEMeHS4+Ud8igcvu7i7GH95HPKxEUqmFWS0FnbEG2aNXHkZgP4DHj5agUCig1WphMpnQ3t5edBgeMZw2mw0zMzNYXV3NqghkGnPSVkUMuc1mg1Qqxfj4OIaHh9HT01O2falelQ1yPfk8zWYzjEajIBfY3t6eV4WppbJR7Z7KvQbJlK2trWF0dBROpxNWq1V4Hx+EA0sTJwNSqVQY6gc8lSEV6x6s1A8kUhymtyIwqSQl5x+RNqVCXLhinQGXyuxPTDQ6tzAXuQqGuUIjDMNgP81j1b8Pp0EBdcaAQSImMj4xgR+Mc+h0mDC9FUYgloJJ9VSFz6GT44sfcmMjtI9z7mxpfYqiYNMWbpmnKEqwjbOzs4KfIrMwCgUdDMNkvQex24kYhoHNZoPZbMbk5CRUKhW6u7trUh0kECPRpFAocObMGfj9fiEZWOtAwA8aGiLYYFkWf/EXf4GhoSGEQiGcP38ezz//PE6dOpV13bPPPot333237HoTExN47bXXcO7cOeh0OvT19eEP//APIZVKMTIyUpEUYaWo1qjdWvRjbDWEM04NLrbq837eKJWSUuvVA4lEIiuwILMsNBpNxbMsgKc8i0IGm2XZvB7W8H4KM9tR2HQy3FkOYsijz9JfNxqN+NCVy9DPzmNmaQ29mhYsLiwIbVtSqRQ6nU6QNa7FsMjlciGwuX//PsxmM9ra2oTAqVjJmqZp6HQ6dHR0YHJyEsvLy+jp6Sm5h3oGG7mBXGtrK1paWjA3NyfsjQw3rCXjU60zqOR64kjtdjsWFhZw+/ZtsCx7og4qTZx8ZAqZAE+FQo462Hj77jrurgQgZWj8/kc7YFY/tbmZgQWp3N69e7dqLlwx/Co9c6X8FMMwWTYeOPhsvv3LeSztxmBWS/EHH++ENIO3otVqceniRUxEJ/DTqTUMtZuhk+cf73rsGvTYSw/MKwaJRIK+vj5BJVGr1aKzs1OoXJP3QYj+mckxsYMNsh4RUdnY2MDo6ChcLhfcbndN96CYe9Tr9bh06RKmp6exuroKpVIpqhriSVS5aohgo6WlRQgANBoN+vr6sLq6mhdsVIq+vj784he/AAD89V//NTY2Ng4V8ZYCRVGCRnU5JFIc7i4HYdFIcG85iAGHJks5iqzXCJWSeq5HpAyDT/gLIyMjwiwLjUaDlpaWsrMsgHzFDZqmsbm5iZaWFqwFE/jpzB5sWjleOG3NMsyZUEoZeAwKLO7FcMquFgIN0gpAWqHC4TBaNCx2NtcglUrh9Xqh0+lEfeCNRiMuXrwolIfLtVaR+06pVGJoaAjb29u4c+cO7HY72traDmXYxKoiSKVS9PX1CVwT8tnVYthr2VOlnwEhkRuNRty/fx8jIyM4depU1SpbTTRRC3LbqIgfEOtwUmkFfjucgIyhsZ/msO7zYz+QFOwfAEEMxel0IhaL4cKFC6LsrxH9lFjI9VMURWFra0toB9qJJKGQstApJEW/7xTHY9Ufh14hgS+SQCyRhlSRr+j1e79+Ci9fimNhbgYP7o+VlWatBVqtFhcuXBAqwqVaq8g9XK9gAzh43y0tLYJU7s2bN9HT05M3eLaaNcUARVGCCAnP8xWpIVaKk9ie1RDBRiYWFhZw9+5dXL58Oe9nN27cwODgIBwOB77xjW/g9OnTZdeTyWRZ5WmxUY3Kh4Sh4DHKsbgXg8egyJP/I+s1utGtZj1CwCdVi0gkkiVlKJPJcPHixaoDC4LMHtH+/n7Mzc3h0aNHmE2boJCxWPHHsR3aLzqpnqYoPN9nxo4/hGQ0hPHx8Sz1Kq1Wi9bW1qyM3dbWFiYmJuByuQ4lRVtwP2Vaq3ieRyQSQSAQwM7ODpRKJfjlZVAUBYvLBZPJhIWFhTyiWrUQW+lKrVbjwoULQkCk0+mKXivmnqo1yCzLwmAwoKOjo6499E00kYncYOMo/UCmet9ZbRQ/3Q7AqaRARwC+yCDaeg/HbbT1KkWmnyqmDNXT04PFxUXcv38fYaUD700HIGFo/I8faSvqpyQMjc8MteCn0z48222DtkDVgkCjPKiU7+3t4cGDB7BYLIdOPuUis7Vqbm6uZGtVOp1GPB4X7bWBwr6AYRh0d3fD6XQKUrnVBFv1qBZwHAeWZdHR0QGn04nZ2VlhX7X4wMx1m8HGIRAOh/Hyyy/jL//yL/MIP0NDQ1hcXIRarca1a9fw0ksvYWZmpuyaUqm0YSazUhSFj/daEN5PQS1jC97YjW50Sz2Mpfp3Mw/tmWssPzkoZyLXYAPAvC+GNMej06qGhHlans194Pr6+hAIBDAzPI7FmAxuuwV6ZbYMMFGvIn/S6bQQWDgcDmGoXzFYrVaYTCY8fvxYVIJaJuRyOfr7+7GxsYHbt28LlTmO44S9tnk8UDMM8Pd/D7As+M99DrRSiY6ODjgcDqG1KnPSd6Wol6yuxWKByWTC5OSkMAyTZMUqgZicjWK/Q9M01Gp1WQWzJpoQC7lD/cTmApL1SGBBbHQ4HAbP84J639kuF54521v23m90P3UUKCQ0QpDpnwr5qa6uLkQiEfyv1+4hGqMhkauxHiieFAOAC60GXGjNl+suBoPBgIsXL2JpaQkjIyMVT72uBmTQXWZrlcvlyhJJicfjkMvlBwNtMyTdD4NS/iZTKndsbAwmkwkdHR0FhUpy16yH0ApZk6ghhkIhTE1NCVX+WlqvM4ONk9JO1TDBRjKZxMsvv4wvfOEL+NSnPpX388zD3IsvvoivfOUr2NnZKdvmkNsLK3b/YLUZKIamsmZg5KLRjXhmiTRzlgVxWuQgXGn/Lsl8lDLYC7sx/HjWD5qiwNEsBl2lMwI6nQ7//ccvY3x2Hr6tJWyuJMFxHAKBABKJhKBeZbFY0NHRUZTAXQoki0JkVFUqVdHBPpUikUgIBjoQCGB/fx9KpRIOhwP7+/vw+/3o6uoSqhX07dtg/v7vsR7jQIGHfepPkP7sZ4ELFyCXy3H27FnB4Foslqrug3pWEWiaht1uB8dx2N3dFYY1HSbTUwi1ZH9OYsaoiZOPYm1UwAGvLJnmYVBWZ1s4jhMSKz6fD36/H8FgECqVSmhXrTWobnRCt9jrZbYF5a5LggmeovHDiW3sRlP4zX4rLOrSrdsqlQq/87Fz+M6Pp8DF92CkzQDyeZyHAU3TaGtrg81mw9TUFFZXV+H1eiGTiTM/LZ1OC0k7mUyGzc1NrK6uwmAwoKWlBU6nU2iJFhKIKyugTCbQOYnHalCJfzKZTLh8+bIweLaQUEm1a1aLQgkvjUaD8+fPY2dnB3fu3Cmp2lhq3ZPmpxoi2OB5Hl/84hfR19eHP/iDPyh4zcbGhtDrNjIyAo7jKurJK1Se5jhOMLCheAqji35o5CzOuXVg6eputkY3ksDhiXeZ1YCtrS3s7+9jdXW1aqdVSMqP4zj4fD6YTCaBHJefCdp/ogBFIVUi25dMJoWDOuGDqOQyrK2tQaFQoKenB2q1uujv1wK1Wo2hoSGsr6/j1q1bWf2rpUAGWpG9RiIRSKVSaLVa6HS6gmTznUAYj6ZmoV1ZOZikOjSE2YUt/Oj6JAAKL1zqgXtwEPQTQ0RRlGBwl5aWEIlEsLm5CavVWnZ/Yis/FbpeIpGgp6cHoVBImB0ipiM8LAn9pGSMmjj5KNZGtR6I49u/WEQixeGz5x15KkIEJLDIlJxNp9NCxYLY1/7+/qN6S1WhkfxeIQVDmqaxsbEhqNUV8lOP1kL4ybQPDE2D43n83oc8ZV/LY1Ti658+h0QigenpadzzbaK3t1d0BSOFQoGzZ89ie3sbd+/ehdPprLoFmCQYic8i7cZExKWjowMqlQqpVApzc3NYWVmBSqUS3gtprWL/9m+R+tCHkH7uuTzVqkpRqW2naRoejwd2ux2zs7NCpb9QYqtewUahfVIUJVT5iWpjW1sbHA5HRXtoEsRrxPXr1/E3f/M3GBgYwNmzZwEAX//617G0tAQAeP311/H222/j29/+NliWhUKhwFtvvVX2w44mUqBYScGMETkY31oKYG4nglSah1UjQ6uxeBmzEBqd0F3LlOZSsyw0Gg3MZjM8ntKGNFfKL57iMLMVgVrOosuiFgKLc+fOYXp6Gru7u8L8iVx0WFR4JplGkuMx8GRgXmZGJRAIIBqNgmVZaLVaYZifXC4XPs+trS08ePBAUEgSmwjmcDhgsVgwMzODtbU19Pb2QqVSCZ8F4a0EAgFhWjjZa2dnZ9ak3EJGLxhP4t3xPcSTenQraEG1KugPgzeZwPFAOBwDldEukalo0tbWhpWVFWxtbQkGt1TgVa82qkLXazQaXLhwAVtbW7h16xZaWlpE6TE+TBtVE03UExzH4/25HexGE/j1HmvRpNiKP4FoIg2FhMH4egjn3Lqs5E9uYKHRaISKbWamNBKJYG9v7zje6rGg2kN0MclZomB49uxZYe5Sb29vQcEZtZwBw9BIpTkYVdUJ0kilUvT398Pn8+HevXtwOBxwu92iHygtFguMRqPQAlyMO8DzPOLxOAKBgBBckHtMp9OVbDcu1FrV0dEB2Y9+hMWfj+L/SZph+X/H8Ds/+Rnwu/8WVHt71a1V1fobqVSKU6dOCYkthUKB7u7uvMSW2J93uX0SjqbD4cDc3ByGh4cranc7iX6qIYKNZ555puwB+4033sAbb7xR8ZoLO2G893ATq2tAOPF07dy2J62cRZoDWIaGvABhuxxOMqGb5w9mWWSqLiWTScjlcmi1WhiNRrTlzLJYXV0tuF45g317fhfT2wfT2Q1qpaDhrlQqMTg4KBw029vb89QaKPBo01IIBIKYmVoVhkTlZlSKPdQUdTCXwmg0Ym5uDuvr61nBgFgg0oBbW1u4e/cuJBKJEIyq1WrodDq4XC5oNJqihuLucgC3Fv3osanwbJdJeE+heBrxZApKGYsIL8FvPFGtillVsPQOQK/XoVPH56mBEGNHgo6BgQH4/X48fPgQBoMhS7owE/UmY+deT74ji8WChYUF3LhxA11dXRVVYYqh2UbVRKNiciOEt0aXAR7wR5L4DXd+uy/HcfBalLCqGOyG4nCxHG7fvo10Op3XClquBaPRORFH1ZZVSmiEYRiE9tN49+E2lDIW/2bABskTtUiGYXD69GkhGChUGWg1KvGV59oQiqfQa6+tgm4ymaDX6zE/P183PmChFmC3253HsyDzosxmc9XtxvFkGj+cC2Ofb8F5CXfg2zs68N7YLqJ7UUxAgekzfTjt8VQ8hTwTtVYhSGJrc3MTt27dgtPphMfjqZvNJxX8ciABWiQSwfT0tDAUsBjX8iT6qYYINuqB2a0IJAyFFGhEuKdvM5d4d9alhVUjhYylYdVU375RjzaqelVKcmdZEOIWObS7XK6yLSwURQn64MUMdqY+OPnvQbm0+JokGJiensby8jIsFgvi8TiCwSA4jhNI5uUO66VAHuhAIICHDx+KotJBhvoRI53Js0gkEtjb28viWSTSHB77YlBKGThyhmZxPI/RRT8sagkmNsIY8uihlh3cuzatFKdaNNgMJXC5zZCnWpVOboI39WR9prlBB4Fer8/qZe3o6Mhr/ap3sFGs6kDTtKDcMTMzI/A5iMpJNWgGG02IDbEG0BKJbQ6AhKWEysaDBw+g0+mEDCwAvOhUQq3WCZXlWnhhYvuVkwAyy6KUgiHJzJNn/mfja3iwFkKK4+ExyHG5PTvDTIKBx48f4/bt23kV4jbT4WVmGYZBV1eXIBeu0WiKJoVqQWZXgEQiwdbWFtbW1gryLMphN5LAWiCODrMKSunTKsfd5QB+ObsLmgLUcjN+88IFzM3NweJbwrTMBWUqAZtBCYphQCGbu1lJa9VhWp4oioLdbofFYsH8/Dxu3rwJr9db01rlUK1fVKlUWeR2khDMfeZPop/6wAYb/U4dFnwRmFRSUNGn5ePcYIOhKbgN1bVOZaIeqiFiBC9kloXf70coFBJmWZBDu91uF9qMSoHjOKQ5DniyJ4qisLu7C7PZLBikXINdCFc6DDAoJdDIWaGqQUq1me1QqVQKLMtiaWkJVqsV586dOxTpuhB0Ol2WSkdPT4+gh10KqVQqr3Urc6if2+3OC9bi8Timp6extraGnp4e3FqJYGw1CJam8KmzLbBkBLg0RcFrVWFyMwyXXg5FxgwWlqbxXHe+GEKxgYA0TQv9taR1Sy6XZ6mBuN1u2Gw2oZe1r69PONQfZRtVIchkMvT39yMQCGBiYgIqlarq5+ywnI0mmsiFWANovTY1vvhMO9778c8x8l//Hv/bzfcxPT2Nr33ta3jzzTehUCiEA5EYELsC32goJDnr9/sRi8WgUChKKkNlwqSSgud5sDQFnaJwKxSpDASDQYyPj8NkMqH9SSuQmFCr1Th//rwwz6KzsxNWq7WqNarhWZDp4BqNpiJbHk2k8V9+8hih/TTaTQq88esdws80chY0fXBs0CslQqLP/dJzUEbSsDM8DG0O4XqBZM/nDwQsBDH4FSSoI1K50WgU0WhU1LkktXIrTCYTrly5gtXVVYyMjMDtdsPlcgn32EnkFn5ggw27To4vPtOOmZkUfrkfEf79JBC6q0XmADoyy4JhGGi1WoGgdeHChYoCC6IKxXEc0jzw42kf1vz7eKbLiB6bGna7HQzD4OHDh1UZP4WEwSmbAoFAAHNzG1mVFZ1OB4PBgNbWVqEXNp1O4/Hjx7h37x76+vpEJ3ZnqnRMTk5ibW0NXq9XCGwIzyLTSBOehU6nQ1dXVxbPAjjI8ry/uI0WnRy9toNDu1wux5kzZ4Ty++K+BiytBMfzSKTz75uPdJtw3qOHUspkTTIvBzKhdGVlBYuLi1lBEOmvzZS/JMac9LISx6nVatHV1XUkBPFKnDMJDDc2NrC6uoqFhYWKy96H5WycFCPehPhIpjn4wgmY1VKwGQNBxRpAS1EUznkMeEAHcOH5j+F/+uq/x9WrV/HOO+8AAGZnZ0Wfi/BBqWwUkpxNpjmE4mkYVBKwLCv0vI+Pj8Pj8VRMvH22ywSbRg4pS6G9TJWCDLdbWloS+A96vbhqUhR1MM/CYrFgamoK6+vr6OnpKUggL8azyBzEWEzIhbQABwIBPHr0CEajEe3t7ZjcjOD/m9xGv0OLj/aYsz7DaCKNSCINjYzFZnA/y2ecbtHg9WfbkEzzWS1lqg9/GC/w/EEAtbSENrm87EDAQkGHmGRuQp7/+c9/jrGxMRiNRtEqSYdJXlEUBZfLBbvdLlRgyOysk5gUO5Zgg+N4PFgNIBRP4pzHAJWsPtugKApyubwg8U4siL1eJQEBIRvnzrLQaDRobW2FUqkUbsR0Oo319fW8dUtphBOehT+SxGogCZNGjvvrUfS7DrL/LS0tMJlMmJqawsbGRkHCXLEqACFFlyvVkuxRKBSqa/ZIoVBgcHAQKysruHHjBtRqNVKpVFbrltvthlqtLvvaP57aQTCexPRmBFa1LIskSMrvqpnHGJ5dw5muNjh0+S1rFEVBU2JgE/D0syUOJRqNQiaTQafTobW1FXK5HAsLC0in07BarcJAQLJ+ZgaQSSZBxWLQGo24dOkS1tbWMDIyAr1en/V75VDPSggpez9+/BjpdBo3b94UWtNKrVFrG1VzvsavNtIcj2/9ZBaPt8M41aLFlz7SWfA+E2MA7auvvnrwmul01vBZsSsRJ7WyUUjBkIAcQnmKxvduLGFxN4Zzbh2+cMkF4IAMbTAYMDs7i7t376Kvr6+sTaMpqiq+BUlaWa1WoQLb1dUlWssTgVQqxcDAQBaB3GazZfnY/f39qnkWuXaYJHeWl5cxOjqKt5dk0KiU+JfxLZxxarMq8SaVBL99xo4HayF81GvKWoeiKHRbC3+OJICqZCCg4KdyWqvqoRzFsiyuXLlSkzpUMYixT5Zl0d3dDZfLhZmZGSwuLsJsNjeDjUqwvBfFz6a3QFMU9lMcPtZnq9tr5Q71q0dwUC8jXmwAE8lUuFyusofg3ExBbrY3s3c1t8RsUjMwa6TYiyRxvjVbsYIYP0LsttlskEgkwj4ZhhFKtYWqAJWCELqWl5cxMjKC3t7eQ2eP9vf3s+ZZkNkbTqcTwWAQNE3j9OnTUKlUSKQ5TK6HII1G4LWpn0jwFoZKxmArnICMoSBh8r8ThmEw0NuNTo8Tk5OTGB/3o7u7u6CyCUEpJSudTgebzSa0CWSiUGsVOURnql7x774Lenwc3JtvCk7AZrPh3r172NnZgclkqmj+Rb0rIaQlqrOzE06nE9PT0wKfo1jVq9ZgQ+y2vSZOFsL7KTzejsCuk2N8PYT9FAe5JDsAFXsAbe59epL8lFjIPFwWEhohfMBcP7UbSWBxLwa7VoZ7KwG8csEpVIVZlkVvby/29vYwNjZWk+RrJVAqlYIE+ujoaBZPTwwQnkU4HIZCocD8/DxmZ2dhtVphsViq4lkAB5/1uw82cX1uF891m/Bi/9MzGEVR8Hg8sNls+Nflu1jaiMJpyU8KUxSFZ7pMeKar/AiCQiimWkXsb6afym2tqkewQV7T4/GgpaUFs7OzWHkiM1/rDCgxKxAKhQJnzpyB3+/HgwcPwLIsPB6P6IFtvXAsu5QwNChQSHE8ZDUoQFUDuVxeUOVDLIhlxDPlDOPxuKA6QnTSqxnAlGmwgafEcLVaLUj5letdBQApS+OlwRbspziBqMzzfFZlhRx+CWGyu7sbRqNR1KibkKEtFkuWbF0lD1mxKgA5rBfiWRC1JovFgm3ocGs5CAqAXMKUJAD+hteMrr24wE0pBjLhdGtrC7dv3xbK/ACKlsErUbLKhdFozMpSdXZ2Ph0IODUF9m/+BtHHi0jH4lD/h/8A7oUXgBdeAMuysNvtgjKGQqGA1+stGRTVUtmopoKQabRJa5rf78ejR4+g0WjQ1dWVt79aDH0tPI8mPljQylk85zXj+qwP/91pW16gUa8BtJlo9Aq8GMgNLHiex97eHnQ6XZbQSLnnUa+U4LxbjzvLAXy811Kw/ZRM056bm8Pt27fR19cnuhohRR1IoJOqP1E9LGU3C6Ecz6KzsxMqlQqRSASTk5Pw+/3CHJVKEUmk8fNZH6waGX48tYPf6DFncQSBA97cf3zpIsYeryO0uYytteW6KDeRdrS1tbW8WVXFWqvqPWeCtJUddgZUPdqd9Ho9Ojo64PP5MDo6iv7+/qq5PMeBYwk2HHoFXjrnRGQ/hc4ipTaxUGxYklioxYhnEqNJ1YLMstBoNGBZFoODgxUdpjmOQyCWxMR6EDaNDJ4nc0IyM0FnzpzB1NQULBYLWltbK775eZ5Hcj+OcDCI1QJa2y0tLVmzMXw+H6anp6vqka0G5JBOske5nBGO44TPMxAICBUW0rpls9kglckB6oBwXQx6vR4XL17E4uIiJienEKf1UMjLtxTJJQy6rZU5MIqiYDQaQVEUFhYWMD09DalUKgSXtcgNFoIQqFmtmJiaEUrWCrcbO0Y7vr8pQVLL4GN8Eq2nTgHptPB9kiBjc3MTo6OjcLlccLvdBe+fWqRvD6t2pdfrcenSJeF+yN1fkyDeRC2gKAqfPu/Gy0P5GfB6DqDN9Ev14BYeJ3IlZ8nzn+unSIa7s7Oz4mQETVH43EUnPnvBUbLyzDAMvF6voEZos9nqcniWyWQ4c+YMtre3cfv27ZKznchcq8yEWKU8C0IgX11dFaopQShw7dEWOs0qfOK0tejnoZQy6DCrMLcdgdeqLir7L5cwuNzjAtftwMLCQt25KeVaq9LpNPZ8PiQnJkA995yoeyiE3BlQDoej6jNUPZ49nueh1+tx+vTpZmWjHNxG8Rj/pSCRSI69jYrIo5LgIpFICJKzBoMBHo8nK/uxtbVV8AYqphH+46kd+KJJPNyI4pULSugUkqyHQafT4cKFC5ifnxeyOoVaTzLbizJlXCs9/JpMJly8eLGqHtlqkZk9Gh8fx/z8PNRqNSKRiMCz0Ol08Hg8eS1m/mgS/+32GlJpDr952gabtniWgqZptLe3w2i24Icj41BLk3BonDXvmwRC5PMlgRDhWTAMg8ePH0OhUIheGk2kOfzrlB/bIS36TIzQWsW5OxCf2IMCPFb0LWhtaRFK1qRsTfgSZrMZ8/PzGB4eRm9vb556V61tUZWi2PrkfrBarVkyhmazuaaWqJM4mbWJ+qDQfVCvAbQEmXNxGq0SUQiFDlOFlKEAYDO0j3+d8MGmleHFfjsYOru6Tg7PpBLb19dXVftKqUAjE4SXUM4fHhaZnBHCbWRZNquFl/AsdDpdTQkmQiK2WCyYnp7G/3U/BKlSh0VfDKcdGrQWOWfRFIX/4dc82I0kYVJLyt6fRJLcbrdjcnISMpmsbAtwLchsrZqYmIBSqYRerxe6KTiOg2VrC97vfQ947rksdcV6gaIOpPnNZjMWFhayiNrlUK/kFVmXYZhmsNEoyM0IiJ0xynUKiUQiSxkqFosJbTuEZ1FJKa6YwSavSTJCACCTSUDFOLA0BYYpXHYm/e4WuMreOAAAIABJREFUiwWPHj2C2WwW9NwDgUDePgu1F1WC3B5ZsSahkkoQMdSJRAIqlQpqtRp7e3tobW0t24u76o8hvJ+ClKEwux0uGWwQ6DRqvPzRi9jc3MTt27ezSrzFkNkSR/ZLuDYkuFCpVHnfk8lkErJUHR0dVQ+0W/BFcGcpiC6rEmecT520P5rEVnAfBrUEyxHglSetVTvBLWheeBYwWNDum8LKyopQEaJpGl6vVzDmhKTmcDgwOTkJiUQCr9crqKIcFWejGDJJdFNTU1haWoJCoag62G2qUTVRCvUYQAs8zdxm/p20wTYqyB6JTy1G4Cb//ZfJTczvxjG1FUOPXVeQiE165s1mM8bHx4W2IbEPbMQfWq3WugmQEJVIuVyOcDiMGzduQCaTwWq1Qq/Xl+VZ8DyPrVACcgkNnaJ0ACKTyTAwMIDu7UncmNmCQauEtozwjoShK/KBmchtAXa73XA6naLYymQyKbQQBwIBpNNphMNh+Hw+OBwOnOvqgvw//2e8FdXhu5Zn8Fv/8X/BM61aJP/TfyorlVsOlZwJGYYROIPEx5QbDlyvygbHcScmyCA4WbutEZk3kpgZo1QqBb/fj3g8jgcPHiAWi4FlWeHAXs0si0xlKJIFJ6pSmQa7kDH8eI8FczsRWNQyaOX5RokYPXLw5TgOa2trWF1dRWtrK7xeb0GS8WFwmB7ZZDKZpbJBAiGdTndgpF1uKBVPpf+IRvidO3fQ19dXVCfboZdDJWWQTPPoMFfer0uy+yaTCTMzM0IvLnmdRCKRxbMgFSGdTger1VqxOgnJUlmtVszMzAizOcjr8DyPnUgCSikDlTR7PZ7//9l77+jI7vr8/zW9aDSa0aivurSq27t7owQHbFPsEEIzAVLsgBN6TCg/4EsICeAkxGEDoYRiA8E2BAwYG7PG6y3avuq9d03vM/f+/tB+7s5IM9JoJIEX73POnrN7dmbunTv3ft6fd3meR+aZ7nlMejXHBpzUOHIU3ojdrKPUZmTKE+baWpvSWTNde5DSmRlkeZa55nryIakjlEoNJCcnh7179zIzM8Pp06cpLS2lqqpq3Q7iqyHT5ETIGDqdTs6ePUswGMThcGRcLbw6RnUVvy8sjVOxWGzTPj8bLFWGUqlUuN1urFarEptSCY0IFFh0dE9L6DTqVRX3zGYze/fuVWRl10PSXQliTGZ4eFjppmTj2L0az6KpqQmTycTQ0BDz8/PK3mAlHB108vjZSQxaNfffXEOJdeXXA9x7UwM3NJXin5ukr+Nc1oaoK0FU+h0OB/39/bS1ta35OOlGnvPy8sjLy2PLli0MOiP8pm+B1lIz8fgC5/r7Kb7uVtqeGaRQE+En2iquuesmhYcrYsrSxD0TrCUpMBqN7Ny5E6fTyfnz51eUyt3MzsaVVgx7SSQbicg22RAbdvGACC8L0X6tra3NSHEpEym/lpYWuru7KS0tzagrkGPQKpXspepFPp9PWfSsVis1NTXk5OSgUqmUVqUsy1RVVa35mqyGTGZk040XJfIsEhOh8+Mejp2apirfpJABRTfF7XZz4cIFioqKUs5V2s163rhvCzKgT6EWtRp0Oh2NjY0KkU1sYIWkryBxrxZEVoNer6e1tRWn08mFCxcUp/NTI25Ojbgx6zW8bnepQtqHSwEgV8+oM0SeSYtBt/j9YrEYXo+HbZYAZTE33uEJOqeNWK1WioqKFHnh3t5epVu0tLKfSg2kqKgIh8OhtJX1ev2mdjbWumjb7XbKysqQJIkTJ05QWVmZkQrN1WTjKl4M+H2PUSXGKfGsJo54qVQqmpub6erqwm63U1tbu+pzc8eOEhqLLdhMOrbYVl8jVSoVVVVVFBQU0NnZqRBjN6PLUVNTo3Q5xHHScUYy4VmkE/Koq6tTvJ2EqV6643RP+TBo1QQicSbd4YySDb1GTUtZHpTl4fP56OzsVLpDGy3prdVqaWxsVEjUgmuzdNOdzv8jNzcXS66ViLmQstIaKh2XC4CSLPPtk4No1WoGZv185I+2UhYL0T80QkHQyYytmP2+CaipSSKRi078Wrsc2XQg7HY7hw4dYmxsjOPHj1NVVbWsy7NZgiNXYpxSrVLteHFr5WUAWZbZvXs3R44cQaVSMTY2ppCR0iFxw+71epM27GLTLroOsixz8uRJDhw4kHRMTyiGUbsogZpKyk/cKOkqQfF4nP7+frxeLy0tLSnHQcS4TmI1JVG9yGq1rqpeJEkSAwMDOJ1OWlpaNlyhY+lxZmdnKS4uJhwO4/V6k8aL8vLyUo4XJeIbL4yQa9Qy64twz56yJC8LcZyhoSHm5uZoamrKqkolIMtyUrXK4/EAKNfV7/fjdDo3RI7XH4kx5Q5TYNEntcwlSWJkZISpqSn64g5krRF/OMZrdpQuC9jhWJzhaSeqSIBo0KdU10QilJeXl7aDJUkSo6OjTE5OJqlWJV4LWZbB50P32GPI996rfE4wGOT48ePk5OSwbdu2jEaXuru7cTgcGSv0eL1eBgcH2bFjR0avB+jq6qKwsJC8vDz6+/tZWFigoaFhRbLu+fPnqampITc3d80J1CbjRXMiL0Jc8XEKYO/evTz11FPodDrm5ubweDzU1tau/sYMceLEiaQ4lYiVJGcTN29L12ZZlhkeHmZmZoaWlpZN4T6I44h1MNvuQ6bHGR0dZWJiQlnXRec6Fc9CFMXSdU5jkoQ3FFvkUS7ZhI6NjTE+Pk5DQ4NiQpiIofkA3z4xhiNHz1sPlmflRybLMuPj44yNjaVc1zcK4jijo6OKOa+4XqFQKO31+mXnDL9on0WrUfFXN1Yrao+yLPOlZwYZdwXJNWr54CvqF9WyJiaYOnaCMxYbB+cmsb/utagSinuJ43xrSTpisRinTp1K6ZmTCaLRKH19fbjd7qT9wKlTp2htbV13AXIpenp6sNvtFBYWotPpXkyJR9qL/Qff2VjK0VhaMZIkSZmvF50LsQHOzc1V1CDS/ZiJN7JYsJ/vm6dj2k9Bjp7bWwvQazVrkpyFy10BwX0oLy/H4XAom16Px0M0GlUI3GsZ10mEWq2mvr5e6T6UlJRQWVm57k2WLMvLCOfRaBS9Xs/4+Dh2u53du3evmcDbXJLL2TE3JVZDyla8ILIVFxfT2dm5JmWTpbwQcX1TKW8JBAIBRRpv69atWalHybLMkxdnmPVFsBg0/Mm+LUrnRZhGFRcX4z/bybkpJ9vqKyi26pXrm3i+QimsaIXqWioI1aqSkhJ6enoUfXGROKgA9dAQqrY2tP/1X0SamqCqCtWWLZhMJux2Ow6HgzNnzlBcXEx1gq9HKqy1MpOtZ4bgmzQ2NhIIBJRZ28TxtPUe5yquYiNgMBgIh8PodLoN5xYmQsSpaCzOsDOI3aTDbtYlKUNlIjkLi/GvurpaEewQXeWNTtITuxwdHR0Zd1PWClFxdzgcnDt3blkxbMuWLRlvHGOSxFeeG2ZwPsC+Shtv3He5wKlSqaioqFDk3CcnJ2loaEiKH9UOMx99VcO6vk8igVzI8SZy7dYLUZgVcQigt7dXiSeVtVt5qtcFMXh1WUlSNx5g2hNGo1ERjS+qaiae97uvr6Rv1k+53XRZlresjJLX3cXLolH6+/sZuHhxVUPATEar1rvuC6lcn89HV1cXer2ehoaGTSeIw5XDLXxRJRs///nPee9730s8Hued73wnH/7wh5P+PxwO89a3vpVTp07hcDh49NFHqa6uzvjzZVkmGo3i8/kIBAJKJ0DIjRYXF1NfX592k+QORpl0hyi2GskzapQbOh6PK3wNlUrFwEKIwlwjC4EoEVlDbhZEa+GN4Xa70ev19Pb20t/fT2lpKfn5+Ur1YKMgFDoEx6KlpSUt9yEVBM9CbHyX8ixM+SUYDQYKLHokSWJ4eJjTp0+veRb3YI2dbWW5GHWalHrqAoJbIAjXW7duTapor+TCbbPZMr6+gjA3NTVFW1sbNTU1iuylJMvM+SJYDFrM+vQbbxnwhmLkGDSEohKxuMzSl+v1evY01VBinWBmpouj871KYrGW810Ngmi4zBDQ60X3wQ/S7owyWNjC3g98lOLdLcQeekjp8InRpZGRkSTFjnSSj5upXpXqPeK3mp+f59y5czgcDmpra5MS9KvJxlX8vpConLhRY1RLhUb8fr/SsXuyc46jgy5MOg3vvaWWojWShRMhuA8DAwNZxY9MkZOTsyEcC0jmWSw1TLVarezduxen08n4+Dj5+fkZyRcnwh2MMTgXoMRq4NSIi3v2LpfmFfP/Qlo1MX5sJIQc79zcHGfPns3K3DDdOJRIxhL5fk6nk56eHvoHPZyYWVzr8816XtGS7AfxRy1FBKMSdrOO5pJkzkeOQcvO8tR7g0wMAdcyWrVRRG6hqDY7O8vp06eJRqOrvykLXIlx6kWTbMTjce677z6eeuopysvL2b9/P3fccQctLS3Ka772ta8pUnKPPPIIH/rQh3j00UdTfp5o77a1tREMBrnlllu46667uP7669FqtZSWli7baKSDJEnEJYn/Oz+JJxTDpNdyz+5i9FqNUnm+eCnDttvtXFPn4OiAk8biXOw5q28AxcZX/BEBQSx6ZWVlGI1G5ufn6e3tJS8vb8Ml52AxwG3duhW328358+fTKkkJ/oo430SehegCJBLje2d8PN0+h0oFr95ezBabaU0zskuRaTtZVHUcDgft7e309/djMpnw+/1KUBEk7mwdzsVxSktLKSgoUIjdTU1NnJ4M0j7uJceg4XW7y9ImHGqVile2FtE+4aGuMAeTTp0UBBPHt+x2OxUVFUxPT+N0OpUxoY1GXJdDzFHPQsjF7CVPE/2nPstzn/4apmiYXzZeyxs/+yHkS8m2GL8Qz0NpaSnd3d2Mjo6mVOzYbPWqld7jcDg4dOgQo6Ojy2Ztr8SK0VX8YUB0NiC7ZEMkFOOuIM/3O6ktMLOnwqp8Xl1dHe3t7YoK07g7So5eRzAaxx2KUbTOySTRJXe5XJw/f57y8vINUypKhOimFBYW0tHRQX5+/qpKUoJnkdhpz8Qw1WKxUFhYSGdnJ9PT02vqXtvNOnaVWzk37uG2xsK00ryCcJ2fn09PT48ik7vRozcABQUF2O12BgYGViV2JxbkhFCL0WhUZHp19lIeOz9LidrA3U1l6BO8OoRAzNzJbpwLM4sy/+bl160w18C7r8+eLyoMAScnJ5cZAsLlNVySJKSJCdQOB+oUo8QbqRolOI0FBQUcOXJEKXamK7xlg6vJxjpw4sQJ6uvrlRnVN77xjTzxxBNJycYTTzzBJz7xCQDe8IY3cP/996e9Sf7xH/+RY8eOsW/fPrRaLd/61reorKxkdnYWn8+XckYSkpWhEjcrcUkmKoFRp0VGhVanx3BJEShxQ2uz2WiqraW5JDftbHwqFQbBBamrq0u78RVytV1dXczOztLY2Lhu07dUEF0OUaWqrq5W5lbFmJk433QyrolY8EdRqRZJX65AlC22xdEcUaUSuuobwX1IrL6Iayy6V6LiUltbm9ZkaT3Q6XS0tLQoxO5zTiN59nx84Tj+cCxtshGJRNBFvNToPDiHR5nujSjdtpKSkpTjW1arFZ/PR3d3N2azmfr6+rV7SsgyU54wOXpNEk8kLsk82T5DTJKQZR1379rJ8EAf6tNnMeg1uFv3Un3hBCO9vTgvBXGTyYRGo1GeR1FJE4odS7sIa10sN9qgT0hslpaW0t/fz/Hjx2lsbLwiF/Gr+MNAYrIhEt90WKpgmIhHTk/hDEQ5O+GjujCXskvrbXFxMXa7nY6ODubn5/njbeX8+PwM2+25yqz8RkCYovb29nL27FlaWlqyklFfDaJ7PTIyQltbG83NzcrGeSWexWp+FuFYnK4pH4W5BsryjBiNRnbt2qV0r+vr6zPiPqhVKt58sII3StKKJrICOp2O1tZW5ufns+4+ZAKNRqMIg3R1dWGz2aiurk7qWni93hWFWgB+cGSIhUCECVeQXeV5tJYlJy1qtZrbDzRRWVbE4OAQevcI4bB5w+8FlWrRa6mwsHBFQ0DDHXcQv+46ol/6UpLQAWzO5l2tVqPX69m9eze9vb2KVO5G8JquxDj1okk2xsfHqaioUP5dXl7O8ePH075Gq9WSl5fH/Px8SpLpRz7yEeXvP/3pT5XXJFaMVlqwVSrVMp7Fa3aW0TPjoybfjGmJ9KjJZGLv3r0MDQ0ltZGXyuElzoCmMp5bDTqdju3btysL32qE17Ug0dk8kdx14cIF7Ha7IpO7VlWL1rJcnMEIWrWausLkCneirnpnZyc5OTlr4p4kjm+J8xXVF6GdnhhUotEovb29TE9PJ3ESVoMrGOXsqJsCi57W0tSJpICo6kgX+zjSM8yurZU4LIudqET1Lbfbjd/vR6fTKV2WtfibWCwW9uzZo9wLS6s6q6Ft2MWpETcGrZrX7S7FZhItaNBqVASiMkatingsSn5+PnONWynItWIw26i8rhJ9YSENNpsShCRJWqZaJRQ7RBdBGEP9rjobqz1boh0vEjev10s4HN6UzuFVXMVK0Ov1ytiFGE2EzBQME4VGrCY9M74oBq0ao06z7Bg7d+5cJA0PtPPn+9dmnJcpNBoNTU1NzM/Pc/r0aWpqaigpKdnw46jVasrLy9Hr9Zw9e1a5DokKgWvhWQB8/9QEZ0fd6LVq3veyegoseqV7nZ+fT3d3N1NTUzQ2Nma0TmSSaCTC4XBgs9mUYt9GbVATEQqFCAQC5OXlMT09zcjIyCKB215AV8CM3VbEjQ2OFc+9ymGmf9aPQaehwJL6OqhUKrZXONhe4WB2dpYzZ85smPfWUoi1PFEdq7a2FtOnP83Usy/w3ZJrsHX7+bPrb0TzoQ8g3XGH8vxslh8GLO4Nd+zYgcvl4uLFi9hsNurq6tZVKL6abKwDqchwqVpdq70mFfR6vbIJlSSJaDSaNEuXasFOhaJcA0W5qTeCckKF12g0cvz4cbRaLTabbUWCcbYoKSlRqlSzs7Ns3bp1zZ+dbqMuxnUED0AoYw0MDKRVxloJFoOWP2opXvE1ZrOZPXv2MD4+Tltb2zKOBayszW21WpeNb6WC6D4sLCysyXTwaP8C4+7QYsXLYljVDEmtVnNo+1Yatjjo6enh+LFx5b5KJUOcLRJHuPr6+hRvDovFgjcU49igE6NOzcEa+zK53xlvGJNOTSi62HmxmXQKV6glJ0Cf14VVijE67Fo0I2xqomXvXiYmJpicnKRQp0uay0705pBGRtB/85tIH/+4klCWlJTQ29vL2NiYcu6ZYiM4GytBzNoeOXKE8+fPU1RUREtLy9VRqqv4ncFgMBAKhS4TuJfEqUQC90px6i0Hy2mf8FKaZ1ym1ic+p7y8XIkfgpe1Gfe6w+Fg3759dHd3MzMzQ3Nz87o3Wamk3cXG0ufz4XK5aGhoyNpfYs4XwaDTEIlJ+MKxpI206NgKk1chRrLREN0Hj8ezbtPBlfiJYgRNkiS6u7v5Vdcs3T4DKrWfPLOOvZXpJw1e2VJIU7EFq0mLI4Nx8cLCQvLz8xkcHOTkyZM0NjZueKIbiUm8MBokbq6kwBSlra2Nlvp6njo2ykyOjRFNEXtCM7S2tCBfknUWBejNXuttNhsHDx5kfHycEydOpJTKzRSbJam7mXjRJBvl5eWMjo4q/x4bG6OsrCzla8rLy4nFYrjdbmUc6sK4i44JL7srbDQsIRoJX4RbbrmF3NxcRkdHGRsbo7q6OmsXxnA4nPQAJ7Zpy8rK2Lp1K0NDQwSDQUpLSzelUmowGNi1a5dCgl5pDCmRZyEWaVFRt1qt5BcWc2YigDsusbXckaQaIZSxXC4X586d27T2rgiCQnFEEPNEcJEkSTFJymR8ayXk5+cro2KiBb9S9cik0xCNSeg0KvTa1N870QHV4/Eokn8lJSXEYjFmZ2eV4LQZVZ3m5mbcbrei1jIp2xicDxCNS5TmGalf0lU6UGXj150T2PRR5kf7GO3yKx3DsgIbTbWVKSuCS1WrEpWdVCoVqslJtP/8z+j+538I3nknqupq1Ha74h/idrtpa2tjcHCQpqamjDYfG8nZWAlarZZDhw4xNzd3NdG4ik1BNC6hVS9XxxkYGOCFF16gqalJ6W4ODAysWeXOatRxTW3qMeFEiDGkwcFBRaJzrYWkTKDT6di2bRvT09NKISkTyetseRY+ny8piVprjLh7Txk/75ihxmGmKj/19RAcC9HlSPzNNhKCkyDMDRsbG1ccNZZlWVGHEtdMpVIpalor8RN37NhBt7+PY6PjmMwmtCsIsMDimFhNwdrG7zQaDfX19fj9frq6urIeAfaHY3hCMUqsyQ7sJ4acPNk+A4BuezE37dtHv91O2Td/zDm1FlMsQsGhPajq61Fx2UNKXKfN7HDA5T1OSUkJfX19yviu3W5f0+dcidzCF43PRiwWo6GhgaeffpotW7awf/9+vvvd79La2qq85stf/jIXLlzgP//zP3nkkUf40Y9+xPe//30CkRhff36IPJMObyjKu26oRZtQxX3mmWf40Ic+xOtf/3ruu+8+VCoVg4ODOJ3OjBbYREfrxMqA2Khbrda0bdq5uTl6e3sznvPMFoFAgI6ODsUoSCzSYv4SUDbqVqt12Ua9a8rLMz1zaNVqtpXlcm2aYBWPx+nr68Pn82XV5UiHVDO2arWaUChERUUFlZWVWSeGAv2zfjyhGE0llstSeqC0XVciGkbiEqMLi5rfRbmGZZJ/Sx1Q8/LyMBiSF0IxwhUOh9c0wpUKfbN+XhhYoNph5rq6/GUa7qOjo/y2Y4QJ2U6uJYfX7Cgh34ByvoLLIgK3zWbLKnlbWFigt7dXCey648fRv+Y1nCmoZtJSyIGJThzFdsJnzybNyJ46dYr8/HwmJiaorq6mrKxsxUVzYmKCcDhMTU1Nxud24sSJNcsrHz16lGuvvVYZxXgR4cqIKL8fXDE+Gz89P8Ev2qfZUZ7HvdfVJCnqtbW18b73vY8DBw7w4IMPotPpGBsbY2JigtbW1k3zsABwuVx0dXUpPKbN2sCEw2E6OzsVadDENV3EgMQCnpB2z8vLIzc3N+NnOdFvaTP9P+ByjK+qqtrUaydk1sUGXavVJsm1u91uotGosqb7MfL98wvodRredV1V2lGnRETiEicHF5ibnqREF6QlgQez0ZBlmampKYaGhtZ07VzBKA89M4AvHOO2xkL+qPWywtXxQSePnBpHluF1u0u5sf7SdMRrX8vRQzdTOjpElVnH7PvelxQHc3NzKSsrw263r9kQcCWIeJIOIukS8uyZjvudPHmSXbt2odPpNiXJXQfSXrgXTbIB8LOf/YwHHniAeDzOO97xDh588EE+9rGPsW/fPu644w5CoRBvectbOHPmDPn5+TzyyCPU1tYSi0v8oG2MeX+Y0jwTr9uzvDUVCoX40Ic+RFdXFw8//DAlJSXKAitm3WF5B0A4hYukYiVjtHSIRCJ0dnYqDtQb6eSZyLNwu93MzMwQDocV3wOxSK92zHFXiP+7MIUsw00NjmUydEvhdDrp7u7OSnFEXONE3kLijG1i8hYOh+nu7kalUmU8I5sKU54Qj5+dQgYai3O4tXG5ad3IyAiTk5PLKg0rOaCKc14L90ZcO+Fpkk135lvHRjHo1Lj8Ue7eu9zcMB6PMzc3x8mOfuRYlHyzVum8iT8bIS4w5QkxPOfHGHUTdM4sepr897d57OmLGKNhrKo4r/6vTyNfShIEn+P06dNs27YNtVpNX18fHo9nRRnk8fFxotEo1WuQuj527Bj79+9f0/N2Ndm4InFFJBuyLPPAo2cpthqYcof46KtbKMpN3lzEYjE++9nP8uSTT3L48GFlNKi9vZ2ysrJN6SgnHrunp4doNEpzc/Om3f/C0G54eBiHw0E0GlViQKLx20obr1FnkB+enqAo18Dde5KVkBLh9Xrp7OyksLCQqqqqTRs9EdduIwpJ6RCPx3G73YyNjTE3N4dOp1OERMSanvibPX5ukmODTmJxmVdvL+bmhswMVAUSCeRrUYtcK6KXPDP8fr8yAtwz7WV4IcieStuyEa2eaR+HfztMrlGLxaDlfS+rU/4vLsmcHXMjyTK7K/JQyTJerxeXy6XE71gshsPhYMuWLUlxMFtDwJWwWrIhMDs7S29vb0YeVQDHjx9XxI+ulDj1oko21oNQNM6cL0xhrgGDNvUPJcsyP/3pT/nIRz7Cpz71KW688UYGBgaUzaOYh0104F7PqM7SY09MTDA6Okpzc/akvET/DTGqIwjRYpGORCJ0dHRQWFi4plncOV+EmCRRnGvI6D2iy+H3+2lubk7rcu73+5VzTlSzSnQNX+1409PTDAwMUFtbS1FR0ZoXgWlPmMfOTiIj01Rs4ZbG1F2mYDBIe3u7ohDm8/mSJP/EdV7vRl1U3oSqmM1mY8Ef4fToomHhaiT0I71zdEz5sJl0vHZnCfFossGfLMtKEBKJVGlpaVbJTVySWfBHyDVqkwinwWic750cR5JljDoNb9ixKP2b+5Wv8lyni1CejeaRLq4/8hiYzcpirlKpOHPmDDt27FCqMiKwmc1mtm7dumwBHR0dRZZlKisrMz7vF154gYMHD67p+15NNq5IXDFx6nvHR3hhYI7aQgv33VKPTpP63nz++ee57777+Ju/+Rve+MY3IkkSvb29hEIhWlpaNvXenJmZob+/f8PER5byLISfhdlsxuPxkJeXR2Nj45o614d/O8TwfJBgNM47rq1kW1l63d7fZZdjYWGBnp6edcv+iriZOJ2gUqmUuGkymRgZGVGKcKmq211TXr7xwihqtYp3X1+VleJYotN5fX19RuNv2cLtdi8WFk1WftAbR5KhzGbk726rS3pdJCbx7RNjDC8E+ZO9pbSUWpVzDYVCSmIh4mBubq7CnTWbzcRiMfr7+/H5fEmqVYnfWfvZzxK/4w64VBDL9nfMNNkAFP+xiYkJ6uvrV9zniNim0WiumDj1B5O8sfy5AAAgAElEQVRsZAKn08nPfvYznn32Wf73f/8Xq9XKbbfdxgc+8AEikQizs7O0tLRsijqHQCAQoL29HYfDseo8aWIHQPhZJCoXiepPOondwcFBFhYWaG1t3RSDJYHELkdBQUFSMhSJRBTzuUy7LOkQjUbp7u4mHo9nNSM7OLc4RtVQfHmMKp2xk1arxefzUVNTs6nVxMTZ1YuBXLzhOJGYzOv3lFJoSf39otEoLreb0RknsYCXeDSc1LWwWq3LAndictPQ0LCmGdFfd8/RM+0jz6zjdbtKlSpi6FKyEZUkLAYtf7pvMbh6fvtbui50Et5/LYfOn0D7trcSTHA7d7vdmCcm2P3880hf+IJybUVbfWBggIqKiiTi/sjIiKI8kynWstAvfY9ard4UWel14GqykR5XTJySZRl3MIrFoE0a9U0Fl8vFX//1XwPwhS98AavVyuzsLH19fRuqQpgK4XCYjo4OZWQn0zV7NZ6F1WpN4lmIkc/Jyck1GfT9omOGX3XOotOq+ZubayjNW3385HfV5UgcNW5ubs4o9oYvrY8idkYiEcxmM50eLcNeFa/aUcaO8uVcDXE/VFZWphxFdQejqFUqco3rG0EOhUJ0d3ejVqtpaGjIenQnJkn8tm+BUEzipq2OpHFmWLwfLvQO8aVnR7BYcqkssvL+l9Wn/qwUPiCrxcFELFWt0ul04PUSn55h8pV3Yd23E8vnPo2qshLNJcPmtSKbGBQOh+np6SEUCqXlkl6JRbGXVLIxNDTEo48+yoEDB9i1axdf/epX+eEPf8jDDz9MU1MTfr+f9vZ2ioqKqKqq2rQNptj4zc/PK4lA4qZX4YbEoMBmxWHPvAOwFG63m87Ozk0hdSeaEbpcLlwuF7ColCVGuNb7IJwbczO8EGRvRR5b7Iudk/XMyC714IjFYsuSIRGEIpEI3d3dSJKUVXITisbRa9VpzZwEZFlmcnKSx04M4NfbyM/L5Z69ZViNOqXCJao1ifrn4pxXU+BKRCAQoLu7G71er3QQREelONfAtrLlHZVvHRtFr1XhDsa4Z28ZdvPl33TWG2bMFaLGYcZ2ybQpHo/jcrkYGRnB5XKh1WqTOll5k5MYP/tZtD/+McFf/ALq6lAnSPbGYjEGBgaYn5+nqakJu93O0NAQOp2OLVu2ZHz9ryYbLxn8QcWpRMiyzDe+8Q0eeughHnroIfbv3084HKa9vZ3c3Fzq6uo2bdMsqtoTExO0tLSknN1PJZSSDc/C7/crqkuZkLolWWZ4fpFDlwkXQXlfQhFuNVGQ9UKMaYuOsuLZlWaMWGyQBd9v1hvmn57qw2LQEotLfOqO5pTHicViSRMGm1lYFMlNRUVFVp2btmEn3z4xhkql4rbGAl69PbUc8vmReY5eHKQxX82hnc0YjUYCgUBS916okIm4stbxdoBwNM709BTjoyNUVVVR8/rX80Tcwa/r9mGIRXn/898h74ufI3733VmNVmUTgwTcbreSDC0l0V9NNq5AnDx5kne/+928613v4q1vfSsA/f39eL1eWltbN4V8I9p9k5OTjIyMoNPplo1v9bokTo96sBq13LWrdFkFYC1IHHdqaWnJypl0aQcgUXJQnLPZbMbpdNLT00NFRcWqpN/V4ApEefTUODmGxe/+5gOXfVhisRi9vb0Eg8G0I1zxeDyp8pEo+SfOOZMHVSQ36apHqXBuzM3xISdFuQZu31a8THY2FXyBEM+d6UQTC1FRZCMQCBCJRJT7YmkylC1kWWZmZkbpIJyYVeMKRonEZV6/q5TCJfLOg3N+jg26qCkwcbDanvT9RSUzsXWdeF+Idn88Hl+cx33hBbSvfwPPVu5kPK+IW/rbKM8zEOzoWGa0JLo+Op0Ok8mExWKhtLQ04+95Ndl4yeAPPk51d3dz77338qpXvYoHHngAtVrN8PAwMzMztLa2kpOTs/qHZIlEdSebzaasqYFAYE08i9WQWIRraWnZ1O/k9Xrp6OiguLh4UwuLgsvhdDrJzc0lGAwCZDRGHIjE+edf9eEJxqgvzOEvb6xe8Vgul4vu7m6Ki4uz5gJmAlEMcrvdSsI27goSiEjUFZpXLK6dG3PzjRdGkYFXtRbxypailK8TojyTk5PMzMyg0WiUUSibzbauCQmB3mkfXz82ikmn5p3XlOOeHiU8PMyxL/8f4/pcQjo97y6JUf/FT2fF55BlmRdeeCHrZEN8xsTEBENDQ1RWVioF46vJxhUKn8/H/fffj9fr5V//9V+x2+3Mz8/T09OzISpSiUpLU/NuJt1BSm0mSh02LBYLMzMzxOPxJFLeD05NEJMl3IEYd+4syahNvBoWFhbo7u5WCPHpHpalpPNE5aLEilW6xUxUWkQikG0ACkXj/PD0BL5wnGqHOUl1IvE79fT0KEoSiXPBYtMrzjmd5F8mSJzzbGpqWjUQfufEGDqtCqc/yutSbOBhucGfz+dDr9ej1+txu92UlJRQW1u7rqBxbsxNz4yfvZV51BYkn7MIGs/0zBMy5JNrNnL3pY5KOohulkguQqEQZrM5KYFLDALd015GFoJU5Ei4J4cpKCgg99vf5yfP9ZAb9qPXqLnrfz6PXF6uaIcnLuSyLDM7O6uMHgpSeSZYa7KRGByuJhtXFF4ScSocDvPggw9y5swZDh8+TGlpqeLDsNEqUql4FpFIBIDq6mocDkfSehqJScz7IxTm6tdsYrcUHo+Hzs5OSktLN8X8TUCSJAYGBnA6nRuW3IhY73K5lDFis9mM0Whkfn6e4uLiNflluAJRpjxhqh2mZQaNqSA6N6IrnOlYWjbweDx0dXUR0OTy0+E4kqziNduLuLkh/X5JkmXOjbkJRSX2VtnQa9Rpu/eJBbapqamsRoBjksTz/QuEohI31Dsw6y9fw++eGKN9yksoEucNe8q4pjYfr9uNb/c1/GD7y6mcH+eu5nz4r8PKexJ5h8KXLe13lSSOHz/ONddck/H5pv0el/YfCwsLNDU10dnZ+YeVbISicTmTG/wPAbIs873vfY/Pfe5z/Mu//AvXXnutQrQ2Go0Zm+aJanqimpVOp1tULMrN5VeDIXwRGatJxz17yxSCoCDlCQ3ywTk/z/bOU5pn5LbGgrREwrUiGo3S09Oj8B6Ea21iK3yjCNEiEVhPl8MXjuEKRCmyGpK6A4kyiS6XS+m0lJWVUVhYuCGVj1QQrU0xapcuaFyY8PDCgJMSq4FXtRahVavSKlqJ62yxWJRrlBg0sjU/8oVjfPfEGFaTFn94kUiZ6jeYd7p5/mwXxfm57G29LEcpy7LSuna5XEkJnKgyGY1GwjGJaW8YR44+yZ/FG4rxvZNjGPUaZBnecmALo6OjqD/6cY4Oh/HZHOwdOMOutqfBaFQWcsOb3kT0E59AnWCq193dTSgUUhRLMplXX2uyEY/HOXnyJIcOHbqabFxZeEkkG7D4TP7yl7/k/e9/Px/72Me4/fbbicfjCpctG9O8tfAsBD9PjLDC4obuy78ZYswZpKnYknadWQuEkazX691QifVUEMnNWrsc6byrzjq1XJyXuGFrIa/bU560pguievMmSsrCYgFVjODU1dVtmpKULMs82dbDI6enyM+zcrCukD/dvzKvLjF2C35KJt17MQKs0+loaGjIaJN9dtTNN4+NggpubSjgNTsuj211T3n5xrFRjDoNf3VjtWLYrP7v/2bslltYeOYZSouKyH/1q5d182VZRvP008gvf3naLkdiPNko+P1+uru7WVhY4LrrriMnJ+eKiVMrJhvfOjok372vApP+pZFwAAwODvK2t72NG2+8kQ9+8INoNJq0WudLeRZLFSOEmpUyiy5JfOvYGBo1xOKLTq+Jkn2ClGcymbJyBM8Eopo+Pj7O9PS0otOcLQcAFk2qwjEpaaMpIMadBNkpmy5HpjOuoo0sJGXXE/B84RhPd80Sk+C2pgJspssPdGLQSJcIxONx5hacBHxexZslmwROjBLl5OQo2uqT7hCjziD1hTkpHYIFInGJH52ZxBWMUmE38sfbUs/HwmWi5vDwMHl5ecRiMWX+erXW9ePnJpnyhMk1aLl7b5mSFIaicb5/agJ/JE5pnoG7di5uTqJtbfR39jBVW8/1HefRvuudix/k8aDq7ER/621w8ACh734XVUkJarWa3t5e7HY7FouFrq4uRYVlpU3IWpONaDTKmTNnOHDgwNVk4wpCx4RHbl5Fve0PDdPT07zjHe+goqKCz3zmM5hMJqamphgcHKS5uXlF47fVeBaJxNreGT/z/jA7tuQpVWEh1CHL8iLXMQaffrKHIouBOV+Yz9zZvGHFMZHcbLb/x2pdDlF4SbxuQulIFF9ycnIIxST+4cddlFgNTHvDfOKPG8lZEhd9Ph+dnZ3Y7fZ1d65XQqKS1NatWzMq0ETjEr/pmScSl7i5oSCpE5AOoWic77eNMjg2ya3VZg7uvDyhsdSPyuv1KsXXRD+qtXyn2dlZ+vv7qaiowFZQzLeOjzPvj/CWg+XLFLfOj3v476MjALyiuZDbtyW7vYeicdRqVcoxZyHJm1K1qqsLzf6DSJ/8BPEH3ptytCoxnmw0jhw5glarpaysjMbGxg3//HUgu2Tj35/pld+wt4KSDRjhuZIQjUb55Cc/yXPPPcfhw4epqKjA6/Vy8eJFZSFOrP4kei2s7mcRpGvaR0NhDhX5y4lciaS8tahzpEK6ilWifN7o6Kji/5GNaV4oGufH56dwBaLsr7azuyJ1BV6Mpa1G6k6spotzXotUbmLQWA8B8Py4m6P9TjQa2FGWx8Ga5a1bv99PZ2cnubm5lJaWJjm3bgR5TUAQyIeHhymrqOapoQiowKjT8Gf7VybpBaNxnIEoBRZ90oK6VFrR4/Gg0WjIyckhEAggy7ISdIfmA5wacVFbkLPs95Vlma+/MIpBq8IfjvNnB8vJ0V++j9zBKPP+CKV5xmW8I8HvEYaAloICOq2lPFu7jwr3NH/Uc5TYw/+B/Ja30NvbS2FhoRIw5+bm6OnpWXEsYa3JRiQS4fz58+zbtw+NRrNuE8kNxktnJ71G3P/d0/J7bttKQ/HmVYpfjJAkiX/913/lO9/5Dg8//DAtLS2KdLfdbqempgZJkpI67Ut5Fitt9sacQR769QDRuMy+KhtvPpBcsRbJTUNDA8+NRTg55OLWxgJua9pY89rflf8HXO5ci+54oslsuoQsEZIs89XfjtAz46O+KId3X1+VksMg5MinpqZWdQVfL0KhkMJ9a2hoWLGIcnzIyfdOjqNSwcublm/OV8P4+DgDAwPk5OQQj8c3xDg2FcQIcNvQAscWjFjNBmoLcnjHtcnS6JIsc2bUTTAa50CVPa0fy0pIUq2qqiK3upr/K9/NU/UH2DnZy9sv/pLQ879FdclDTRktTIgnG42jR49y6NAhfD7fpppFZ4G0cWrFaNpQnLsmpYc/FOh0Ot7znveQk5PDTTfdRFlZGfn5+Xzyk5/E7/cjyzLbt2/PSvVhi83EFlv6aqxKpaKiooL8/Pw1K2MlenAsXSALCwupq6tbtkDm5+czNTVFW1sbDQ0N5Oendg5PB1cwijMQxWbW0TPtS5tsOBwO9u/fT09PD9PT00qXI9055+XlUVxcvOYOj1qtpr6+XpllFhvZtS5whRYDWrUKSZIpsSYH42g0qpyvWq1menqaiYkJiouLKSsro6GhYUO7UmI8rKCggItdPUxNebE5CsnJoOpk0mkw5WmIRqPMOReSrrNQ4SorK6OpqSnpGrlcLi5evEhBQQFHprUYdBpODDmpKTAndXlUKhUvbyrg3LiHvVW2pEQDIM+kI8+0PLjN+yMcHQ1jd9ShUvs4efIkLV/7Gie/8D1sIR9D9lJmXvlq4q96Fa6+PiK/+AWaO+9Ezs9HpVJRUFBAfn4+w8PDHDt2TNElXw8kSdq0KuNVbB5kGYKR+O/7NH7nUKvVPPDAA9x44428613v4s1vfjMtLS0sLCwQjUYZHh7GbDYrI4/19fVr4q2FYxKyDDqNikCK61tSUoLNZqOjo4MWi4U7XtO4Kc+PVqulpaWF2dlZTp06RV1d3bqf9UQs5c5JksTY2BiwyE9Zi6iKWqXiHddVsOCPYjfr0pKlVSoVVVVVFBYW0tnZicViWZPE8FpgNBrZuXMnMzMztLW1UVNTQ3Fxccr7wKBRLe4WZTDoVlEEu5TILp04KCkpwe/3E4vF2LZtW9YFv95pH/9zYoyiXD33XlOZ1CHSarU0NDSgtsxz5OcdzIVCvLJ5uQeIWqVib2X2idzQfIBfdMxTX1hFmSVK25kzHGxu5umi/ZR65jhXupV5Tx+WmhpkWSYWiyldDkmSNqUTl0hU38wkdaNxlSB+CbIs0zHhwRuOofWM86H3/S0HDhygubmZxx57DLvdzuc+9zlycnJ+Z1rnokrvdruXza2mcjrXarVJFau1jCyFQiE6OjqUcZ1MF71oXOKpzlkm3CFu2upga1H6hUUs6hMTE0xNTaHVajEajdhstqzOORXikoyMjPbSwy7GnbIhy3lDMWLxOFopopDXfD5fEnlNnLPQIddoNBnPk0qyzJHeeUYWglxbl099YWYExZ7RaU6297GztpSW+uWJ1GqEO3HOMUniN73zjDtD3Lg1n2pH8vElSWJkZISfnB0jYsynJN/KG/aUpjXNTPX9RhaCaNQqym3Jo3k/vTDNjC9MKBrnNdtLKDCp6D1+HNW73s+JilYcARc3m3xMPfxlbDYb1XV1SM3NhE6cWKZaFQqFkiqf5ksGgmtVAgkEAvT09LBr166rnY0rCL9on5Jf1lyMRv3Su0Tt7e0cPnyYEydO0N/fT1VVFX/6p3/Km970JmKxGN3d3dTU1FBSkn6EMh1kWebowAJTnjA3NxQsc3JOfN3IyAjT09ObbpoXiUTo6upCrVbT2NiYNT9lcnaBoWkXJsmPmuWdc7VarXQ5NpuonjjulE3BbylmfWEm3WHqCs3Lij+CsxmNRmlqaloWbyVZ5vyYm0h80YFbjMMJ0ZhEroUkSUnd+6UTB4JAnp+fT01NzZoTqa88N8S4K4Q/EuetB8vZWZ66kOkKRBgem8A/N0FtbW3aRCodZFlmeCGIxbBcRvkff9GLLxwnHIvzwK21FOVoGf3Nbzj/D1/mWOUO6udH+fM3XofqnX+ufJYsyyDLhCMRenp62LNnz5q+92qQJIkTJ05ccdzCq8nGJYzMB3j8zDioYNsWK7c2XW4fSpLE4cOHOXz4MF/+8pfZuXOnonUuKhKbWRF1Op10dHRgty/Kjmbrwr0aEke4mpqa1kRKFgoNif9OtTiJc87JyWFiYkLZIG6ExLArGOX/LkwTjUvc3lpM8aWOxFpmZMNLzOdisVgSec1isaz4fuF0vpriFyw6tv/w9AQ2s5aYJCdJ+66GeDyuyETW1dUhSVIS4S4nJ0epaKYj3E17wjx+dhKrWYtGpeKevak9LLz+ACfOd5Fr0LCjpTHjhLB90sNveuYBuL21iOoENawX+uc41jdDLBLmYJGETopgNhho+H//jxfe+Zdsf/4Ihbt2Yvj0p5mfnOPp6n3Ygx5uGT4D7/tbYh/96DI1EKG2VlBQQFVVFadPn14TOc/n8zEwMMCOHTuuJhtXFl4ycWophoeHGRwcZO/evVgsFn74wx/yqU99in/6p3/ixhtvJBqN0tnZiUajyXpUNlMIOdnN3pxD8gjXSgW/RPEToZ6n0Rt5rD+OP65mW7mdd99Qk/b98Xg8qeC3mR4WwWCQzs5OhbOZzW/lC8f4/FN9+MIxagtyuO+m1N9NiLek899KJRufyDnMy8vL6PwEF3BiYmJxSsFs5dmeOQoseq6tzV9RJvf5/nmeODeFWa/h/ptrV52yiUQi9PX1EQqFaGpqyvi3erprlifbZ9BpVNx/cy1bbJfj238fHaF90otJp+b9L6tf9JI6cQL93Xdz/O8+yK5//xKq++6DBx4ALhVUXS6Kq6vp/7u/w33PPWzbtm3D/c1Onz59xXELryYblzDuCvKjU2NIssyeKjs3bF0+B3fx4kXe8Y53cPfdd/NXf/VXqFSqTdE6T+cmGgqF0Gg0bNu2bd0dgJUgDJZERSKTRCrVoi7cPEX1I9XiJDwsMtmcr4aOSQ9H+uYxaDU0FOVwXd3lICSqb5OTkzQ1NWGz2VISz7Px4Uh1LXp7ewmHwzQ1NaUlMYdjcR47O4U7GGV7mZVr61avaMmyrHBDhLxiOLzoIF5VVYXdbmfAGWHOH2XnFmvKESaBYDTOY2cn8QZj7K7M40D1ypKCgphXVlZGeXk5vkicX3fPoVGruKWhYBkRsm3YyclhF5Ikc111LsWGmHLOMhDVWigpsFFelL/YHYpJnBl1Y9CosEtuZqan2P3EEzz/8zYmrYUEdEZe0/cCxU88gv4LX0CqqyP+sY8ldTkkSWJ0dJTR0VFkWeb666/P+J7yeDyMjIywbdu2q8nGlYWXTJwScAUi/PziFPYcPUu7OiMjI7z1rW/l4MGD/P3f//2iqMQlT6fm5uaslO0yhSRJint2tp5OmSIUCiVtzlUqVRIZWXShl4qfzPki/NNTfeSZdAQicT5zR9Oqa4Qw6CsrK9v0Lofg5wllyrVg0QiwH5NOjUoFn3x1U9rXikTK6XRSU1NDLHZ5fQaU62az2dbFOYTLvJGfD0aYiRlRqTT8xQ1VNBSn74LJssy8P4pJp14WW1aCEIoRI9ThOBwdmMdi0HKg2r4swfna88P0zwUIReO87VBFUgclFI3TO+OnKNegFC8Tz0+IqlgsFmKxGM0f+QjTrgi/sjfQ7BzjZQYvoW9+E/WlgvRG3DdXKrfwarKRgKE5P/5wjK3FuWmJRMFgkA984AP09/fz8MMPU1RUpPADspF4TWc8l0hES6z6T09PKxWdVO3WSFxi0h0iz6RLmq1fKyRJYnh4mNnZ2WWt8USFCaHCtR5Xa9HajcViWTl1CzgDkUudDZlXtRYleZOI9vns7CzDw8OLEqtLVLiy6Q5Ne8JcmPBQlW9aNkKW6AGSLkBFYhL+SAybSZf6/5fIBEajUYVrYbPZFLnciYkJRkZGsBZX8txYFI0GtuSZViX4hWNxApF4yuMv7VbB4v0qHHj9OWX0OmNIElxbZ2fHljzlNR6Ph+m5BU4OLhCLhtlemkNBvp28vDziWhOySkWhJfl3Pj7o5PSoG1mWeUVLERVWLb29vWjvegvPV+3EEI/y2tgElvc/wPxfvhetGqxf/iLSTTehzs9PWsx9vkUeiMViyVgowOVyMT4+TmtrK1qtdtPkIrPE1WQjPV5ScQrgW0eHaBteICbJ/OVNdewoT57djsVifPrTn+ZXv/oVhw8fprq6Gr/fv2YeYLYQXUYx1rLREJ1zl8vFxMQEbrc7qVC0UhdalmV+dnGac+MeXtlSyN7KzHwbEuV4N9upOxwO09XVpXSkMq1ey7LM8/0LtE96ubWxIOVYcywWS4opwjzWarVSXV2NzWbbtLXvv37dxXPd01gsObz/lc3UZjg6vFaIotPk5CTdkXzOzSx6xLzzuipaSpOFJMZdQR49NYEjR8+f7C1L62ciCn1iPHnW5WXUp6Is34JDFyUajXLDnXfyiQNvIqrWENCb+OBvvon9yceQd+4EMjcEXAmhUIj29nb27t17Ndn4Q4csy/zkJz/hwQcf5DOf+Qy33XZbRlrniVXpRKnctRrPCX5FqhGup7tn6Z72YdZpeMOespRytGuBUOHKzc1VzOYSFSYyGS3KFIILsxKBbTVE44ukRjWXyWsul2tZp8Xn8zE5ObnuGdlvHhsFZMIxiTftL192vcXmPBN1rKUygT6fT+HhiORipU5LJBKh7UIXT/X7sTsK2FZu49bG7JQqzo+7OT7oor4wh5saHMuqQX6/n2fb2jk9J2Oz2bmh0oQx7lfUwxK9OBKrYhPuED+9MI0ky9zWVEB94eXrcXbMzfP9C6iAV28voTLfRDAaR9vURPddr6ey7SRF50/TkbeFp+sPoJZl7uz8DeWEUHk8BC4lvSqVSlmQ6+vr6ezsxGazKdLB6bCwsKCIF1xNNq4ovOTi1I9Oj/FUxzRajZr33FrP1jRKXM899xz3338/f/u3f8vdd9+NLMtJ/hWb2XnYyBGuVJ3zxLEenU5HT08PNpttU+Vk4XKXI90IUjYYdwUZd4VoKrEopqqyLDMzM8PAwEDWpPhUqoNqtXoZfy+Rd5OpOtb5cQ8/OT9FQ7GF1+0qzYgzFYzGaRtawD8/jUMTXJdiJMDIQpALE252bMmjwr58giAUCvGfvzzH+ZkYVmsu776hZlmykQ5CCGZ+wYnXs1jos1gsSlz7wQUnFye86LVqHri1Fos6Sld7O50f+TLtxXXkRAK87/pycv7uPQDIR45guvdegn19qxoCrgThN7J79+6rycZLBePj47z97W+ntbWVj3/84xgMBmVmv7GxEbPZnPSQx2IxpSq9mgv3Uow5A4y7wmwtWvRWEC28qampJIOgH5yewB+JEYpKvH536bLq8WoQDtHinEWnJR6PE4vFaG1tXbcc74w3glGnTjniIzTclzqqr/aZmSyoSx9u0YYXpo3ZPLSPn51kyhvGpNOsWBUR8nlCklKj0RCJXCaeL+WH2Gw2VDojv+icJRCJ80ctRSldyFOhe2Saiz397Kgto74muwrmV58fJj9Hx6w3wp/s26J0yYQCiTjvibnF864scVBeXo7Zksu5CZ8il7lU7rZj0sNveufRqFXs3JIsKRyXZIYXAug0asptRma8EX56cTExeVVLITHPLNP9/ege+DinC+uQ1Bpe1n+CEs8cPr2J0qI85BuuJ/5v/0Y4HFYWZFmWGR8fZ3h4mJqamrTSy3Nzc4qJ4tVk44rCSy5ORWIS58ZcWAxamkpW9hhxOp38xV/8BQaDgX/+538mNzdXkSKvr6/fVOlMWZaZmppieHiYxsbGjNyfs+2cy7KsjDVvNlE9Ho8njYutx3TQHZsPrTwAACAASURBVIzyT7/sIxiNU+Uw895bapP+PxKJJPmarBQTE5USl6oOij3HSutaIBCgq6sLs9m8anHmUz/rRgY8wRjvvbU25WZ/xe/tdtPd3Y3D4aC6unrN620kJvH//aybaFxGr1XzD7c3pPTLCETi/PLcEO65KW5q3kJlZWVKUZVAIKDENSEF75ZNPDkYxWE18dc31yVNi/zHbwYZmg8iIXP/TTVUO8zIPT2o9x/k7J7rqWs/Q/61+4g8/jh0duK94w1MxzVUfuA+tK/5Y9Tl5Vl1OXw+H/39/ezcufNqsvH7whe/+EW++tWvolKp2L59O1//+tc3tXIDi4vO5z//eX74wx/ytre9jf7+fu666y58Ph8Gg4Hi4mIlE86WyOOPxPjeyXEAzHoNb0pw6PT5fHR0dFBcXExlZSVzvghtIy7K8ozs2GJd8UZeuklP7LSk8ocQFZ31OIKfHXVzbNCJTqPitbtK05rSiS5HqjZ8KgfSTAjR6a7BemZkA5E4k+4QDot+xbE1ocQluhw6nU7ptIg/S4NIz7SPp7vnMOrU1DjM3NyQ+bkljjsJJa4xZ4DOKR9bi3KWKU8txXN983RMenGY1Fy7RY/Xs3ithTCBuNZms5lYLKaYH6kdFRwbCaBSqdibggcSjMY50jtPJLZoGmXUqTkx5MQXjnNNrV2p6gGcHnXRNuxCpYLd5XnsLM/D4w9iq67maMV2dPEYrTMDPNZ6C2GNjr0TnVw3fB6Py8Xc3Byzs7Ps2rVLuU+j0Sh9fX14PJ6UHjYzMzO43W4l8byabFwxuKLi1O8DkiTx9a9/nX//93/n3/7t39izZw+RSISOjg6l2LKZ93swGKSjo4O8vLykzoMsy7h8AU72TaONB8mVA2ndyzOFiIm/i3ExYTq4ni7HIoekF61ajVmv4aOvakj5OhETBb8xMX67XK4kpUSh8JjN/icxJq6UjD7aNk7bsAurScff3lab1RRF4riTmDIIRePM+SIUWw0rmkNGYhKferKHcFTCqFPz0TTJhkBiTKyrq0OlUuF0OumbdCLHIpTlXy70iXvuGy+M0D8bIBCN8af7ytlXdbnjM+sL82zPPOU2I4dq7Jd5g7KMNxBmYmQQv9/P7scfJ/4fh/nszffi15vYMdXHu04+ht/rBdY+WuXxeBgeHmb79u1Xk43fB8bHx7n++usVB+577rmH22+/nbe//e2bdsxYLMY73/lOzp8/jyRJxGIxbrjhBv7hH/4Bq9WqqAVt27ZtXZWPQCTOI23jROIS+WbdMtUgSZIyao2nUloSVQ+xqK8WcBIdwVtaWtbMr/hl5wxjziCh2KJi1FLHz0REo1G6urqIRCLk5+fj8/nw+XzrciAFGJzzc37cS1NJDo2Xxg+ynZFNB3GtRaUk0UzRaDQqGvj19fVpj7Xgj/Dj89NE4hIvbyqgpmDt860+n2+xUpVj4eicAb1eSyQq8eaD5cu6MIl6806nkzm3H6vZQL7dhs1mwxPXcXrcR4XdxP4q27LF0ePx8JtTHZxz6rDn27m5sYDWUivBaJxYXCbXuHxRHJwL8GTHNDqNivqCHG5JGPtyBaM8eXEGkLm5oYAjffO4A1EOPfd/VN15C6NtbZR8+OM83norxliEYu88VX/2cpzXXacYLYr548Rz9Xq9Sdr2IsmbmprC7/crfjRXk40rBldMnPp9o7Ozk3vvvZc777yT+++/H7VarSgQtrS0JLskbzBkWWZwcJCpqSkcDgfBYJBgMMizEzDgVWE2GPi7l9dTVbD+cxCy8S6Xa9NVpESXw+/309zcnFWsPzXipHvKzw1bHWk7BJFIhPn5eYaGhgiHw+j1+qTC4FrHmUPROM/3L2DWazhQbV82BpXYUWlsbFwWZ2OSxLgrhCNHv+5x7WAwSHd3N6g1/HLSwIwvSnOJhT+/rmrF9405g7RPemktzaU8zXVLNDd2uVzKWLXBYGBK7eC50TBGvY77bqxe9hlnR918r20co07NfTfVULTKdEFMkvja8yP0zvi5ucHBTdU5iwXae/+KL7X+MeZoCEMswkeuL0X64AcVqVwh557J73elcgv/oJKNQ4cOce7cOaxWK3fddRfvec97eMUrXrGpx71w4QJNTU3odDo8Hg/33Xcf4XCYL33pS9hsNqUbIKoR2WLWG2bSE6LaYU6q/iYikZRXUFCwTGlJOMemq6SvBUJFaq0EwAV/hOf65rGZdVxbm7+scrFULjcej6PVagkEAlRWVq67UhWTJL7xwihmvQZ/OM5bEjbd2c7IJm7SXS5X0rWejhjwyVr2VTuSdOrFeMHQ0NCKxwpF48QlOaUaRyoCdyrIsszY+DjfPjqIPtdOicPGPXvLkGKXW+4ulyspIRJur4mf/90TY8jIeMNx7t5TllJ3X5ZlTnUNMj4xycFt9Rhz83n8/BSRWJxbGpYTFme8YZ44N0VMkrmmxo5Bp2Zgzs+uLXlsSVj4pzwhnjg3RZ5RSyQS5pZKPU6nk33XXMvJilZmc2xcO3we/VAv2kvjE4rmOcurR6J6Nzg4SGVlJeXl5UxOThIOh6mpqbmiFvGruHLi1IsB4XCYD3/4w1y8eJGvfOUrlJSU4PP5aG9v31DZ2rOjLo73z9KSryJfE8br9aJWqzEajXg8HkpLS6mpqeHwb4cZmAsiyTJ/fVM1tVkUVdLB7XbT2dlJeXk5W7Zs+Z10OTbiWEuNBn0+X1L8FtLn6znWT85P8Uz3HABvv6YirY+F6KhUVlZmPdGQCWRZpndkks/+vJfyAithlZ5/fG3LivK4qSAESmbmnQxMOclRhbHmXDa3tFqtihnvV57txSmZUekMvOVgOXtSGAB6QlF0GnXSSPCYM8iFCQ/byqxJyeG0J8znn+qj2Gpg3hfhs3c1A6DdupVfW6rpLqzi9q7fsuXHj8Du3UnfXZbljLocVyq3cFOSDX84xvHBecx6Lfuq7GhXaG1tJB566CEefPBBTCYTr3jFK/jOd77zOzluImRZ5jvf+Q6f//zn+eIXv8ihQ4eUCr0wItrotpeYNxQV6dnZWQAKCwux2+0ZE8/XCvG9ACXhWgtW0/K2Wq3KZ4pjZTK3uhJkWeZHZyeZ9UWwm3W8fncp2iXVhNUqOqkSolSb9Hn/oo+GTqPCatTxhj1ly84ncsn4Jx6PZ6zEFZdknumZZXg+yHV1+TSXrF4JlCSJ8ek52jr6MRHBatJhMBjQmHLxyEa2ljkota8c5H/dPUf3tA+LQcPr95Sh16iZ9YWxGLTLKlvhcJje3l6GnGEGIlasOQYq7CZu2uogGJGwGC53G+Z8EcKx/5+9846vq67///POrJvkZu+9k9KVlLZpoYCUJYgWZGtZFikI/FQERJaooCJflSWI4yGoX0S/glRkWCizK93NarOaPW7GvTd333PO7494Dvcm92bfWkpe/7VN7zn3Jvm8z/v9fg0BQ5iWl2q6iAjTIAhjBVDmIJuGhtnaaKJv1MvqHAOLshIxGo0Yv/tdBEmi/otfpOS223DW1EyYYk7WdMgUsOHhYeLj4wkLCyMnJwedTneipYkvNBvBsdBszBCSJPGvf/2Lu+66i4ceeohzzz0XURQ5evQoDoeDioqKGZ+x8rlosVjoMY3w+8MOIvVaNDod959fRFxsjPI7JQiCcq2k7EI+arOQFhPOaYXx816n5GvZ7fZZi+Ldgsi7jSYcHoH1pUlBrVh9rzWTLcdkNUXeWoz/XLxeL01NTTO+lowth3rZ2mACFVy7Kniz4XsteXsz3U1R26CdYbuH8jTDtMJgJUnilf3dvFvbwbIEuOz0U6aMFJBdyeTPTpIkogzR/O2ohxG3isKUaDafnhvw5+qYycpz79QThofN6xeRGDe1LbRbEPnB60dwekTCdGruO79YcS/13WysK0rgosVjA2bNj36EqqaGw3ffTcnVVzP64YdEjxvSTlanfPFp1RaGpNl4/8gABztHEESJzy9OozA5dKtZGcPDw1xyySW89NJLGI1GvvzlL3PppZdyzTXXhPS6oy4vBzqGiY3QUZEeq/xwNDU1ce211/K5z32Ob33rW2g0mnnzOvfVLMg5C5GRkX4P6f39/TMS5c0Fsih+soAl34ZIvm/Abw08nYaov7+f5ubmWbtzwNi2YGDUTUKUnkh98F/UgYEBjh49SkpKChqNBovF4pfFIfNigzVZVqeXv+zpwuUVKUiK4tzy4PdrMploamqa1qRq0Obm5T3dJBh0OD0iX1k5MQzQ92dkZGTET3wO0NnZSXp6Oh/1q7G6BMI0aq6oyggqcIexg3TA6iYmQkuUXsuHzYMc7rISqddwybK0gAW4q2+AP3/YiDbCwCWritjTbqHP6gqYK+L0ePnTjmOYLDai1R6WxXn8OMjyNi7YZzM8PMyRI0cUf/Xxh7AkSYiiiFqtnkCtGh0dZd++feh0OpYtWzZvDmvziIVmIzgWmo1Zore3l+uuu478/HwefvhhwsPDlUn2ZOe5IAh+WVCykYhi1x5p4GfvHmPU5SU5Oow71xcGnFDLG/K5nOfThSyKn02i+u62Yf64uwu1Cs4oTuQLiyf//7LteSB9o5zvJD8g+352U9WUQJhtBojTI7CjdZgInYYVucZpbRDkDAtZIzrZGdltdvKLd1rwCCKn5hq5oioz6NcGgq+AXM77kjc+8mcn12O5Psh5Xhanh4dfP0J8lJ5hm4cffKE0aJwBfJJ2Lgf/7mgdYXvrMKcVxrMyz79OKc2GV0SvUXH/BSV+ry1KEg6PQKQusOOU1WqlsbERg8FAQUHBhO/1eGqVSqXye51Pq7YwJM3G3mPDfHB0ALVKxReXZZAVHzq+pIyXX36ZN954g9/85jcA/OEPf2DHjh08/fTTIb3uW7W9HOmzIkoSG5Znkhn3yXt1u93cf//97Ny5k+eee46MjAzsdjuHDx+etngt0Dp1upoFWZQXExNDQUFBQAeGbrMTQYSsuOnnYgSCy+VSxIbFxcUTXIsCNUSz/SVxu900NDSgUqkoKSmZEx3MF8FSzwVBULZScor7dDFoc2N2eMgwhk852fEVWpeWlgad6LgFkdcO9GKyuVmaGcupuUa/oD9fy1zfh3RfyIFOf9nfhzEhifDwcK5akUmETjNtetZf93XjcAvYXAJfWpqGTqNCrVKNpaz6QM5saens46A9luzkWMwOLxtXZvj9jDgcDtCFI+oNFKYnkBRvnPEDvyiKCge9oKBggrhxsulRa2srDoeD4eFhli5dOidL5BBgodkIjjk1G7taB3m3YYCV+fGcURLaB94TEaIo8j//8z+89NJLPPPMM5SVleFyuaitrVUeiGTO+3gjkcks2wesLo4NOShMippwJvjC7XZTX1+PTqejuLg4pIJX2e1QFMUZbcgPdVn43fZ2RAkuPCWFs0undvCS9Y2jo6OkpKRgt9sVa/DxJhvTFgc7PWxvGSbJoGdZ1ifDTd+k87KysnkLGA4EURRpa2vDZDIp5iOB0DRg45n329CqVeQmRHDz6cGT2oPB4XDQ0tLCwMAAOr2e7T0iPU4t55Ulsro4NWg2liRJvN0wwI7WYc4sSuS0ouAp877/p7Ozk6NtHfy9I5wUowGLy8vDF5VMqN2dww4Odo3RqLLjZ67R8RXh5+TkBHRIDEat+rRqC0PSbIiiRPuQHZ1WTYZx9sLomWDnzp1cf/317N69m4iICK699lqqqqr4xje+EdLrvtfYz/6OEdQqFZetyCIlZuKKduvWrfy///f/+O53v8tFF12keJ1bLBYqKiqUta6vkEmeGskHk3yoB1qnTgZfO8DxKedtJhv/qhtAkuCMknjKU2dnaSuKIjabjZGREXp7e7FYLERGRpKQkOBnVThdOD0Cb9YNMOLwcE5Zkl84ny/kjcpsp2KBJkz6sDA6nWFIugjWlaUTZxi79uDgIEePHp037m/nsJ3GfhslyVF+DSqMTXQaGhqUhnT8A7fH42FwaIT+oRHctk+C/rrd4ZgFLWuKUsiMn16xae8fZtu+RvKTolm1uITaXhu72kYoTI5iXdHEfA1f9JidfNwyRFpsOMnRerY2mFCr4POnpJIe4Hs2NDzMS+/X0mUTWZSoJS9Wo+RxGI3GGQVBTgWZxuXxeBQbal8Eajra2toIDw8nOTkZvV7/qXH5WMDsmw2PIPKdvx7EEKbB4vTy8BcXBdXEneyoqalh06ZNfPnLXyYhIQGdTkdGRgYul4u4uDjlPJ+OkchMIUkS3d3ddHR0hDzlHD7ZkE/X+leSJOp6RnELIqdkRE+g3srwtY6XBygajQaHw6FoVOZiPvL77e0c6rKgUqm4ZV0eeYkzqx0zhShJONwCkfqJU3qbzUZ9fb0yzBz/MyFKEu82mui2ODm3LHlKcbXvc4Tc1Mo6lYiICA63dvO3Ix7Sk+OQUE2ajh4MdrfA3/f34PKKbFiaFrAJtjmcPPTKfgZtXkoyk/j2ucUz1o1MFx6PRxkwlpSUTDBoCFSnPq3awpNGIA7wwAMP8NJLL6HValm2bBnPP//8hKl/Y2Mjl19+ufLnlpYWvv/973PHHXfM6ppur0jzgBVDmG7SDY7JZOKGG24gKSmJRx99lMjISPr6+pQgIq/X6xc8J0//Z/PAY3Z4aOgdJSVGr1icWq1W6urqSE9PVyz66nqsvHvEhEalYkWOkcqcqYN8ILCrlW/In0ajoaGhIehGZSq0Ddp5o66PSL2WZEMY51UEbyTkLYe8eQh2kPsmzvo2cuNpXMeGHLxe24dWraIoyd8dyZe3Ohdvdbcg8sKODrQaFYIg8ZVVWROE8vI2oL+/n5ycHARBYGRkRPGc991ahIWFMWRz8/LebiL1GtQqFVefOv2VtZxD0dnZyQ5zDNkpRgasbq6oygiYhRIIO1uHOdBlRhDhtMJ4ylMNfmmrshV0bGysIsTPysqat1CsYJgOtUre5LS1tREdHU1KSsqCZuPThVnXKVGUeOytRjqHHSQa9Nx9ftmkdIuTAX0WJ//Y301yTBifPyUNrUbNW2+9xfPPP099fT1ms5m8vDw2b97Mueeeq4TIzsXyfLqw2+3U1tYSHx+vUGdCBdn6V6/Xz2qjEoga7Gsd7ztA8XVxLCsrm7Ul/++3t3Owy4paDbecPrHZgLHa0drayuDgoF8G10zhEUSe/6id5gF//YEv5G1AV1cXRUVFQWl3geBwuRkeHsY+OsbckEPz5M9u/GDV5vLyoy2H6TKZWZGXwOb1FTP+WfywaZC/7e9Bo1JxelFCUDqczeWl7lgf9v52sjNS56VxmwxyDld0dPSU1Kqenh4EQSA3N/dTVadOqmZjphAEgYyMDHbu3ElOzuQWa3OFx+Nh//79PPbYY2zfvh29Xs8ll1zCZZddpmwCZHeBueKV/T30j7oAFZctT1e6d9miTxbKqbQ6ao6NIIoSlQEC2OCTELeZulrJiaS9vb0ztlS0OD28eqAXh1vg9OIESoOk4/pC3nLIkypf8fnIyAgOh4Pw8HA/R4pAn3W/1cXf9/cgirAiN5aqnIl6l9lyZGV4RZG/7OnG4vQQE67j8soMxXbQ6/X6aS0cDoeyuSgoKMBoDEwtcngEXt7bjd0lUJAUyfqyZFxegVGXQFykblqTGZfLxV8+OEzzkJtF+Rmcmp/Iu0cGiY/ScU5Z0qQ0sEGrg38d7MDjcFBscKNBUNJWAzlbeb1eZe1fUlIyp6DIqTAZtcrtHit4I//J5qioqCA+Ph69Xv+pOcQXMLc6ZXd7aTPZyYyPOOG2GoIgUFVVRUZGBlu2bJmX13z2vWbqeyx4BYmvn1HAooxYjh49iiAIFBcXo1KpeOmll3jkkUd47LHHWLNmDV6v1y9sda7W4JNBpukMDg5SUVERUttamc7S3t4+pb5RTjEPRA2WsxmmmjLLupFg1JmpYHV62dk2RqOaKkdrdHSU+vr6WTdugZyVgl3P6XTS0NCATqejqKhowjOBnAkif3Zdgxa2tHgRNXqurkylsjBtWpS2UZeXnmE7rqEuXA47paWlRERGcqTPRphWTW5CxKSfSV2Phd9+3IEEXLosjdX5k1Nl5aFfX1+fkgMSKkxGrfJ4PIptr8lkIj8/n7S0tE9VnfpMNxtvvfUWDz30EB999FHIr/XYY49RW1vLypUrMRqN/OxnP+PKK69k06ZNqFSqefU6f+1gL50jTrRqFZdXpU8ooPKBN55+FEizINO45MYiGEcyGOSApaSkpBlNB1xeAbc3cDbDeMj0s8HBQY4dO4bX61VcreTmwjeccCr0W104PAKZxogJ3uMy5sqRtTg99JldxOgEBOfYIdwzaGHEDXnJsaQnxSmTMd/NQ2FhYdDgQavTi9nhITkmDCT4v/09jDg8lKcaOL1oeoGAkiTR3jNA17FmmlwxqMJjsHnGEszlTJRgaavyZ200GqfNhZZzQOTMi1BSl+TEeKfTSWRk5Bht7j+NszxJa2lpYfv27RQWFnL++eeH7F5mgYVmIzhO2jr1+OOPU1NTg8Vimbdm4297O3mnvh+9VsX/O7uE7CBZR21tbWzcuJE1a9Zw1113odPplKFOaWlpyI1HZNva8RsVQZT4d8MAvRYX55UnkxIzs5ylQJD1jfJkWa1WT6D0yBvl2VCDfeH1ejly5Agul2tOW47pQBRF2tvb6evro7S0dEb0NK8o8tuPOjjaP8oZxQl8/pTJRfG+1vHZ2dmEhYVNSDKXa0TDkMBLe7qJ0mspTI5i46qJJidTQRaQtzoj2dUPKpWKr63NoSRl8uT4tkE7XlGiIHH6Whk5B0Sr1VJcXDxvOtFAkB0qzWYzBoNBoeL5hhZ3dXWxY8cOYmNj/Zg6JwAWmo1AuP7661m+fDm33nrrcb+2w+Hgm9/8Ju3t7Tz99NMkJSXNm9e5zeWl2WQjyRAWVO/g8Xiora1VqERWqxWHwzEvNK7xkNe6Q0NDlJeXz1m8FogX63vfTqdzyvTT2aCu14LJ6mFxRoyyLbJYLNTX10+LIys7uMhbC/mhNzY2lqjoGF4/YsXhkTBG6ri8ciJdwel00tjYiEajmfLAG/wPrcoYocUjSFx9aiYWhxdDuCYo33j8vb5d08DHrSNkpiZxXkkcgnPU777lrcVME37Hw3eik5eXR0pKyrxQNeTtlm+QU1RUFHq9nkOHDrF9+3bOP/989u/fz44dO+js7KS4uJjq6mouvPBCSkpK5nwP84iFZiM4Tso61dnZycaNG7n33nt5/PHH563Z8Agi9T0WYiN05CRMfhZ7PB4efvhhtm3bxnPPPUd2djYOh4Pa2lri4uJCTnUSBIEjR47gdrspKytDr9dztH+UZz84hkatIi8xkq+fljvn68jufe3t7ZjNZsLCwvwottM94yRJYlfbMI19Ns4sSQwa0Adz33IEgyhJCKLkR82dSl8x2Wu5vGJA1oMMedgnn7OyQ6ZarSY3N5ekpKQJDdXAqItn3mvD7hH4yqmZVKTPXi/6662H2d46TGRUNBurcye4R80nZK1PZmbmvFGAx5vp2O12IiIiiIiIoKWlhVdeeYXLLruMw4cPs3PnTpqbm8nNzaW6uppzzz2X5cuXz8M7mzcsNBvj4Xa7SU9Pp7a2dkahdPMJSZJ45ZVXuP/++3n00Uc544wz5ux1Ptm1bDbbBEcRjUaD3W6nuLiY5OTkoL8803UomgzypCojI2Pav6iBeLEmh0izTU9+cixnVqQTGWBrISeCy5OIua79B0Zd/N/eHjQaFckGPV9Ykqb8WyCObCCNCBCQzwtjovgXd3ai1Yz9+Ssrs4JuVeTpohwUGehzFCWJj5qHODZoZ3V+PM0DNlpNdtKM4Vx4SsqktCrf++7sG8TrdhJriCQrK4v4+Ph5FXL7wu1209TUhNPppKSkZMZNqcvlUgqevJWTBeixsbFYLBZ27NjBjh072L17NwBHjx7lmmuu4Rvf+EbIH5zmiIVmIzhOyjp16aWXcs8992C1WnnsscfmrdmYDbZt28Ztt93GnXfeyYYNGwCUM2/RokWz1q/5om3Qzh93d5Jk0HPNqVl+tuSyHW9RUREurYFfvjtmqboqL47LKjNmdB1RFBX3PllPJrv3xcbGotPpaGpqmhX9qM/i4rF/N6HTqDGEafnueUWTfr285ZCbqenkLE0Gq9PLsx+0MWhzc/WpmSzyeYiXJImOjg66u7vnZIkvD8221vXQMWhlkVEkxRg1gU4m2/8Goxu7vSJeUfL7Pg/Z3BzoNJOTEDntcMcRu4e/7unAPNjPmfkGTikLrt2cD8ishpGRkVlRgH0pUXKYrm9j63K52LVrl1KrJEmivr6eiy++mG9/+9uUlpZ+KuvUZ7bZePXVV3nqqad46623jts1PYJIY6+VcK2aguRPxE/yBGvp0qXcd9996PX6aXmdTwbfnAWz2Yzb7SYqKspvUiNPNyabVLm9Im/U9WMadXN2aSLZc7QxlnUjssh6/MTDV7NgNpv9pv/ytuXlfb0IoojVKXDJsjSSgrhc+KZ0FxUVBaUfTQcjDg8v7+nGI0gUJY9pIsa/r76+PpqbmxXXCF+NiCycnwwdQ3aaTXZKUw2kxoSzu22YI/02KnNiJ+hWPB4PR48exeVyjfFWJyn2XlHktx+3k2jQY7K6uXplJlH6sY1VoPRz2bdc9nzXaDQKjSuQnex8Q/ZyDybqBn8OsCyc1+v1yn0bDAaam5vZvn07O3bs4PDhw8THx7N69WrWrl3L6tWrMRqN9PX18Z3vfIfvfe97FBcXh/R9zRELzUZwnHR1asuWLbz++us8/fTTbNu27b/ebMDYJH7Tpk1ER0fzk5/8BIPBoOjX5MHHXPDrD49xbMiBw+PlqysnhszJgu7w8HDCEzMxOwXKUqOnFPRPZmgi68nGP7z56kZmso0fcXj46VtNODwCBUlR3LJuenavct7IZAOk6eBAp5kXdnZiCNOSGhsWcOvjcDior68nMjJySuqqL7Va3lpIkoSZSF496iJMr6c8WJzNwgAAIABJREFUI4Yb10y8Dvg/mJeVlWEwTE5xenxrM13DTnRaFXedU0hc5PSHrb40rrl+jtOBLwU4kKhbvieZcuxr8OJbXzs6Oti+fTs7d+5k//79REREsGrVKtauXcuaNWtISkrCbDbzwAMPsGHDBtatWxey9zQP+HQ0G20mG06PQEGyYYI7z3zjiiuu4Nxzz+W6664L6XV8sbNlkO0tg6iALyzNIM+ncxcEgUcffZR//vOfPPvssxQUFPh5nRcWFgbtZqea1ATL4rC5veg0avQaNZIkKd7Zvodrx7CDfx7qIzpCg0Gv4+IlcysoMoaGhmhsbCQtLQ2dTue3bRnPix1/YLx/1ER97yhReg0blqVPGswHY8XG18d9tlOPfqsLs8NLdnw4kndsOtHaO8TAsIXEcIgzjjVDNpuNoaGhOVk4Wp1e/rS7k7goHRaHl+urswNuI4aHh2lsbJxSrL6/w8ye9hGKkyMoNar8wv4CpZ8HgsvlorGxEYDi4uKQc407Ojro6emhsLCQuLg45Z5HRkb8OMBGoxGNRsPevXuVaVBnZyclJSVUV1ezdu1ali1bFtJp13HAQrMRHCdds3HPPffwwgsvoNVqcTqdWCwWNmzYwIsvvvhfvS9RFPn1r3/Ns88+y5NPPsnSpUvxeDx+joCzpd6+f3SQ1w71EaZV8Y0z8gNqMXz1a+Xl5ROmyoEMTWQXPHlYNRO2gEyTnQm1uWvESY/ZSWmqAUOQpPFA8Hg8HDlyBK/XS2lp6ay2HMN2N09ua8Pq9HBZZXpAgxPwtxr2dZHy/fxGRkaw2+0BjVXahxw8sU0O7IvjqhWTux9arVbq6+v9AvoC4cdvNjFoc6NSwZ3rC0k0zJzZ4fF4aGpqwuFwzGpDPhOMpwAnJSUpdvqywYtMOZafww4ePKjUqebmZvLy8qiurmbNmjWceuqpIa2rxwEnfrPRMWTn//Z2IgGr8hNYlT/zaf50YbfbycrKoqWlJeR+3r7Y3mxiV+sQABcuSacgaWKX//HHH7N582ZuvfVWrrzySgBF4CXnZIwXcQuCMEHEPdWarb7XygdHBzGEa7l4caqS/myxWKirq1PyJOxugVcO9GJzeVlTED9rbiVMdPNwOp0IgoBWq6WwsJD4+PhpcUkFUcI06sYQrlEm9FPBd8sx021RsNRSKSyaDzo9aPVhLM+Jo9rH2WK2HFkZXlHk1f29mEbd5CRGUpIcRU27maKkKJZm+f/MCoJAa2srw8PDlJaWKgYDgaYqU4X9TQdy2vlM6HAzhfwzbjKZGBgYQJIkYmNjSU9PVyhR8tZi9+7deL1eKisrleYiNzf3RF41zwYLzUZwnHTNhi9OlM2GL+rq6rjuuuvYsGEDt9xyi2LJ2d7ePushiyRJ9FpcROo1U1pu22w2amtrFdqO/IA8V0OTQBAEgebmZqxW65wsz6cLecsxW/2a2yvi8orTMleRmym5Doui6Ec9nSxw8Gj/KIM2N0syYxVNhyRJWF1eInSagHbuHR0d9Pb2UlJSgtE40Wq/z+JiZ9sw+YmRfhSw2UDekCclJYWsHrjdbkZGRhgaGqKvr0+hRMl1yul0snPnTnbs2MHOnTsZHR1lyZIlrFmzhrVr11JSUvKZqVMnTLPRarLxj/1dqFSwNCuO04tDS9WYDkZGRrjxxhs5fPgwKpWK3/72t6xevXrWr+fyChzushCmVVGeFos6CCffbDazefNmRFHkBz/4AYcOHSItLQ2TyYRGo/HLtJA5pjPFa4d6sTg9WJ0CF1Sk+KVgyqI8l8tFeXk5qLW4BXFGUxpfjYjv+tD3IJM7eJkyNttwPhmDNjc1x0ZIjg5jaWZgW0B5yzGZt7rM/fdt5nw5lXIB6xh2sOVgLxqNiryEKNaXTUyrlj3IZ8ORdXtFzA4PxkgtL+zsIkKvxuLwctWKzICFZGRkRPGNV6vVyvTfl0s7Xweb73rct8GZDSRJUjI55AR0eRopU6J27tzJ5s2bSU9Px2q1kpCQ4EeJio2NDenK/ATASf3m5oiFZuO/AKfTyXe+8x2OHDnCM888o6Rk19bWKu6D8/k76WtnLgtpRVFEFEXFDCSUbnbyFnk+8kbsboFwnTqods53yyEL4+cKp9vLe/U9uBw2ciLd2H1s7EVRxGQyUVhYOKca/Hb9AG/V95MaE87mdbkBheUyjSsiIoKioqKQfs983biKi4vn5KAWbHjnu/Wpq6vja1/7GkajEbvdjsFg8KNEJSYmfmbr1AnTbIiixKEuM3a3l6VZcURMQY05Hti4cSOnnXYaN954I263G7vdHrAbn09IksSLL77Ijh07eOONN7Db7VRWVvLAAw+QnZ1Ne3v7vHidtw/ZebvBREKUjvPKkwkPcCjITcB0XJ08Ho/ftmWmD7put5v6+nq0Wu2sV/GvHOhh2O7B5RH50tK0oJaIvqtP2RPcN3xO5v5P1cyJksSBTgsjdjeVOUbCtRo+ah7C5hY4rTBemc7NhCMbDK8f7qN9yIExUseGZWnoNWolbV7m0sKYAF126yotLQ2pLzh8EkZkNBrJz8+f1gZH1uX4+tX7ZnKo1Wr27NmjrJrlZm3FihUcPXqUQ4cO8fzzz3PKKaeE9L2dYDipK9Qc8V9pNjyCyHtH+vEIEmeWBD5DTwaM2N28uLMdFXD1ymyMPjx6SZL45z//yT333MMPfvADzj77bCRJorm5GYvFQkVFxaxoIbLDka8xiG8Iq9FoVOzMZd1Idnb2BFenve0jtAzaWVsQT2rM3Okp8yHofrOun3/XD5CXFMmNa3LQT0IZl2twXl7ejDUxsm5TPmd3dDnZO6BCp9dzzakZrC3x/6zkgFyVSkVJScmsGpwf/usIKpWKYbubW9blKXbp4+Fbg+c6ZJwOHA4HDQ0NhIWFUVRUNK1np0Buhr4ujHq9ngMHDih1qqWlhfz8fFauXElfXx8ffPABv/zlLznttNNC+t5OMJz4zcaJBovFwpIlS2hpaTnuneiTTz7J4sWLqayspKuri+uuu45zzjmHb37zm2g0mnnzOhclacqwN1mUFxYWRnFxMRqNRplEm81mjnQNsr/LSka0hmU5CXPyIPelOpWUlMz4Qfm9oyZqe6yEadRcujw94CpeXnuazWaGh4eVKXpWVhZxcXETUktngqYBG2/V9aPTqilOimJd8SeC9GAc2enC5fHS1juMymPDOWrBZrNNyBLxfdCXG5zw8PBpH66zhe8GJ1AOiOxu5dsUyfcdExOD2WyeQImqqqoKSok6evQoer0+5EGcJxgWmo3g+K/UqY+bTLy44xio4MJT0rlgcdrU/+lTiNcP9fD6oR4ALjgljQtOmfg+e3p62LhxI6WlpTz00EOEhYUpurzpPExOxxhkskFGoNDBXouTx//djEqlIilaz7fPLpzbB+EDmeqUn58/YzfL+15rwBCmxTTq4o6zCsgwTl4rPR4PjY2NiKJIaWlp0BBduSbL2+HxlNl3m0Z4o7YfCbj61AxWBNFzyPaus6FxfdQ0yKsH+8iOj2DT2pwpxftut5vGxkYkSaKkpGTOblyTQZIk+vr6aG1tDSggl58N5OeD8ZQyu93Orl27FDG3zWZj6dKlCiWquLjYr051dXVhNpvH2CGfHSw0GzPF/v372bRpE+Xl5Rw4cIDKykp+8YtfhFRsJGO8zazb7eZ73/seNTU1PPfcc6Snp+N0Ojl8+PBx8Tp3uVy0trbS19dHeHg4oigqVK7Xm50YIsKxeUSuqMqYkms7HTidTurq6oiKiqKwsHDaegePINJtdhIdpiU+Sj/mTjFk5kiXCa3Hjspj91t7ylsLmWs814TQfquLVw/0IIiwpiAOrwimUTeV2bHER+mV9yYnrU4mVh8/lZKF3PK9T4eL7Nu8HY/pkWw37PV6iYuLY3R0dIK7lcFg4OjRo0pzUVtbS3x8vNJYfEYoUbPBwgcSHP+VOrWrdZDffdSGSgVfXJrBORXzY55xomF/+zC/+7gNgOuqc1maHfghVRAEfvazn/G3v/2NX/3qV5SUlAQdVgWyYZ/KGETGgNXF3w/0Ehuu5YtLUwnTflIf5Afl4uJiCI/mp2814faKFCRP3xlqupCF8fImYLoDnTdq+/l3wwC5CZFsOm3yzYYv5C1Hfn4+8fHxE9LMfR22DAbDhGcCl1fgw+YhwjRqVuXH+eUtjX/mmItY3S2I6NSqGZ3hsg5wPihqU0F2chwdHSUxMRG73c7o6Cg6nc5vCHbs2DGlsThw4ABRUVEKJaq6uvqzQImaDRaajZmipqaGVatW8dFHH7Fy5Upuv/12YmJiePjhh0N63V6zk38e6iE6TMvnF6cpwm1Jknj77bf51re+xX333cfnP/95YP69zkVRZNBs5V8HuzCZbZTHekmM0ikFoLu7m+TkZHJzc1GpVAq9xxCm4cuV6X4H/1zgOy2fruBQ9q+Wi5jH42HngBoHYcRHR/KV6jwiggjK5XRpeRMwWx7psN2N2yshSiKvHuhDr1WRZAjjosWfPIj4TlhkK9nxabXzIeSWISeSCoJASUnJvLpd+FKiRkZG8Hg8aLXasa3XkSNcddVVHDhwQGkuuru7KS0tVZqLpUuXftpdoo4XFqpacPxX6pQgSuxuHcIrSpyaFz/lFPfTjI4hOwBZ07A+37VrFzfddBM33XQT11xzDYODg5hMJvr7+4mIiEAQBD8b9piYmBkNy/64u5MDHRY8oshXV2axbJxhhuziGBUVhSYunT6rm0XpMfMyCAuE3t5eWltbZ2Q8YnOPiainYhaAf9bU0NAQAwMDqFQqUlJSiI+Px2g0znoj4BVF/rS7i7oeKxctTmVNvv+wTd7gzHfwYMB78Xppbm5mdHSUsrIyIiPnZrPvi0CBujqdDpvNxsGDB/nKV75CQ0PDBEqUXKdWrFgR0q3LSYSFZmOm6O3tZdWqVbS1tQHwwQcfKNa0ocTbtb20D9mxuQXOX5RK0bh8hf7+fq6//noyMjL40Y9+RERExJy8zgNN0M1SOPtMKozRERQkG1lf/slEXA6wGx4epqKiAo0ujD6ri7hI3YwE5NOFLDgcH7Dkm7MgP6DL/tVyEdPr9fxhRyeoJNxeiatOzZjUvcqX6jTXLceIw8Pf9vbgEgQWpUVzetEn1CJZUzE4OEh3dzeiKBIXF0d8fPyM0mpnCnl6JDuNzbRw+AYVypQoeSIpf+4jIyNs376dDz/8kL1793LkyBHOPvtsvvCFLyiUqIVp0Kyw8KEFx2e2Tp1oEEWRQ4cOsW3bNn75y1/icrlISEjg2WefJTY2lu7ubjIyMqZtIxsIWxsGeL22H40abj4tj7zEiQ+lcoBdT08P5eXlczKwmA5cLhd1dXWK6Hmm7oMyjvRZ6RiyUxCrQnLZJmgF5ObMZDLR3Nw8541114iT/9naTKJBj90t8P2LSid8jdfrVYKGy8rKQu7GZTabaWhoIDk5mZycnFnVwkABr76bM7vdzs6dO/n444/ZvXs3tbW1rF69mg0bNgSkRC1g2jj5mg2zw4NOoyJymtans8Fpp53G888/T0lJCQ8++CA2m42f/vSnIbseQFO/lbdq+wjTqdmwLJO4qIkTbVEUeeKJJ3jhhRf41a9+RXl5ud9Kt7S0NOBkPlAeh7w69H1AH7a7eWV/L25B5PSiBMpSJx7Uk4nyYCxxu6nfRk5CJOmxc5uky4LDvr4+4uPjcTgcfjkLkz2g91lcHO6xkJ8QSV5iFHU9Fhp6bSzOjKEwKTAlTqZxRUZGzqlwDNrcWB0e4sPBZv3ERUWlUilcUKPRiMVimTVHdqbwnR6VlpZOSguUf17kQ1vWicif+XhK1OHDh0lMTFSmQXKzfuutt/KTn/yE6urqkL2vzwAWmo3gOGHr1H8bTqeT008/HZfLhdfr5dJLL+Whhx4K2fVsNhtf//rXWbVqFStXrqS2tpbHH3+cxx9/nNWrVyMIgvLgWlFRMauNrShJNA/YiNRryDBO/uA7OjpKXV0dKSkpZGdnh/Rs9c0AKS0tnZaZjO8Ap7V3iN/UDCJIkBcfwaY1mRiNxqCUMlnvAMxa0O30CDyxrZU+i4tVeXFcujw96NfKieChtDyXIYcqmkwmSktLJ03p9nUzlAePvgGv0dHRtLW1KVsLmRIluxmuWbOGkZERbr31VjZt2sSGDRtC9r4+Azi5mo0jvVberu9Dr1GzYXkGCYbQrLf279+vOFHl5+fzu9/9bk6C7Oli1OVFq1ZN6W6yb98+vva1r3HNNddw4403TvA6Dw8Pn3Fyqgyb24vHK2GMDL56lp05PB6Pnz2fKEm8uLMTjyiiQsVVKzJm5NTiuzaWJ+gajYaIiAjMZjMpKSkUFBTM+LCzuwVe3NVJdLgGm0vg2tVZfrzV8fcgF46Z2Nb6ZnIECkUKliQuc2TlzzLUK9tA0yPZUUw+tD0ej59LFMDevXsnUKJkgdySJUsCUqIEQQCYddO2AGCh2ZgMJ2SdOhEgb4ANBgMej4e1a9fyi1/8glWrVh23e2hubua6665j3bp13HnnnWi1WkV/MNPMo9lAFMWA7liSJPGv2n52tA6zriiBz5XOj92+w+GgtraW2NhYCgoK/GqsIAh+mU2+9cGlieD53YOoVJBhDOeOswqmdT3ZMGa2Ww63V2TE4SHRoJ+S1uWbOTLfVKdACJRXJVOifANefeuUVqtl//79SnMh05Xl4LxglChJkvB6vQu03rnh5Go2/l3XR6vJhsMjcN6iVIpTQrsinQq5ublER0ej0WjQarXU1NQct2vb7XbuuOMOuru72bhxI3V1dXzuc59jeHiYsLAwUlNT/bYWc4FbEKk5NoJXlFiRY1Q8tH1FeQkJCUiSxP/WdGFxegnTabiqKmNSPrNMK/IN+5OdSGSxlnxgy4XDbDZTUVExo5WuVxT5274eRuweUmLCqMqOpaFvlILEKL80d1/42tYG2nL4uluNjIwoAYvywTdZKFIgDA4OcuTIEbKzs0MqlJMbuubmZoaGhtDr9RMEcjIlavv27ezevRtRFKmsrFSaiwVK1HHFwgcdHCdknTrRYLfbWbt2Lc888wwrV66c99cfdXl5p6GP6DAdpxcnofHJkfJ4PDz44IN89NFHPPvss2RlZSnaCoPBQGFh4bzSVjyCiEqF3zBJzsmQ6cZWp5fvv95IokGPadTND75QOq+aw2PHjtHb20tqaioul8svdDBYaN6BLjPtgw5W5ceRNIMhqmxbK6e4h/qBWR5WpaSkzHueyng4HA5aW1vp7+9Hp9Oh0+n8XKJsNpvSWOzatQu73c6yZcuUDXtRUdECJer44eRqNvqtTt441EtUmIbzT0kLKZVqOsjNzaWmpmaC5ed8wyuI7G0fxukRqcqNwzlq4ZFHHmHnzp10dnYSERHBWWedxT333EN0dDQtLS1z8jofj/peK+80mtCoVFTlxFLlY50nc1blLIlRt0j7kIO02HASDWNNjt0tYHV6iNIIWP/TXMi8//Fhf1MdXjKNa6b6A4dHYMjmISFKx//WdKFWq3B7RK5emRkwgAg+2XJ0dHSQk5ODKIp+9oLyfRuNxnk55L1eL01NTdjt9nnjyE62cQkPD+ell15iz549rFy5kn379lFbW+tHiVq9ejUxMYGDEhdwXLDwwQfHCVmnThQIgkBlZSVNTU3ccsst/PjHPw7JdV7a3cH7RwaQgE2n57M0ayKN6J133uGOO+7g7rvv5uKLLwZQQtcqKirmxe2xfcjB8x8dQ6NWsWltDmk+NF7ZRhagsKiY5z7upH3YQWFSFDetndtDs3zGyoMnm82GRqPB6XSSkJAwqfvgZNjbMcKWg32Uphq4ZFm6XxM3HvKWYzrZWHOFKIq0tLQwPDxMWVkZBoNhzq85WcBrZGQk7777Ln/5y18455xzOHToEAcPHsRgMCiUqOrqahISEhbq1H8PJ1ezcaLheDUbTf2jbDnYjUatYkmmkRVZBt577z1WrlxJXFwc7e3tbNy4kaqqKu699170ev2MvM6nQtugjX8dHismZxTHU57mz6OUHaS6u7sVUZ4cjNNrGuIfhwYwO9wUJ0awrjhRmaDPll4jJ507nU7Ky8tnRD2SJImX93UzNOrBEKbhsqqMCRaEvt7vIyMjOBwOvF4vUVFRFBQUEBsbG9KJiTyJmw1H1teZa2RkZIJ1LuAXnNfd3U1SUhKNjY3cdddd3HzzzQvr5BMLC9UzOD4VdcrlFdjXPoIhTEtF+vFv3EdGRvjSl77EE088waJFi+b99f9vbyf/rutDpVJx8xkFLMoI7CBoMpm48cYbSUhI4NFHHyUqKgqLxUJdXd28WJ++eqCX7f9xCTuvPJmzA9CjZEvw3IJCBF0USdFh07aglRFsq+1LU1apVIqpytDQEBUVFTOmHj30z0Y0ahVmh4c7zsqfUqciB+RqNJrjsuWwWq3U19eTmJg4IRNpKox3M3S73QEpUTJ1t7W1lczMTA4dOsSmTZu4++6759VdcQFzxkKzEUrk5eURFxeHSqXipptuYtOmTSG5TseQnb/v60KUJNYWJVKVM9Etyev18qMf/Yg333yT5557jry8POXw0ev1itf5bNE14kSUJDKNY9sHQZToMTuJCtNgjNDhdDrp7++nra0NtVqNXq8nJiYGUW/gnWNOEgxjqa9XrsiYy0fhB5l6NNOUVZvbS6/ZRVK0nugw7ZROS+Hh4X6WvNMVAc4FMkfWYrFQVlYWcPInp+363vt4Z66hoSGFElVTU4MoilRVVSmUKHkV3tPTw/e//31+/vOfL1j9nVhYaDaC41NRp/6+r4u363pRq1TccmYhZWnBRa+hwkMPPURUVBTf/va35/21nR6BXa2DGMJ0LMs2TtowiKLIr371K37zm9/w1FNPsXjxYgRBoLGxEa/XqwTzzQYtJhvPf9SORq3iprU5ZMYFfjh3Op3U1tYqeoDxD8mdww68okRO/Nj/9xUhBzNXmQxms5n6+voZD4/+t6aLmmMjxEfpuf2svEkdFX0hW/Iery3HsWPHGBgYmFTQ7VtjZbMU3xo7OjrqR4lyOBx+lCiZbjc8PMz999/PAw88EPIh7wJmhIVmI5To7u4mPT2d/v5+1q9fzxNPPMHpp58ekmt1DNlxCyK5CVGTrlM//PBDbrnlFm6//XYuv/xyYCzRsqura96sAEVR5J3aLna3mvC6XaxMEkmKiVDs+YaGhrBarWNbh/BwdrQM0z7soDo/jqy4CBr7RnF4RMrTDHPmyvqmrE6nUImiiMViUaYqvrSi6WxcHA4HdXV1REdHK8K1UMKXI5uVlTVBZBgREaHce1RUFA0NDco0qK6ujqSkJD+XqAVK1BjuvPNOXnvtNfR6PQUFBfzud78L2EC+8cYb3H777QiCwI033sjdd98NjOXcXHHFFQwNDbF8+XJeeOGFOWujgmDhmxUcn4o69acdx9jeMoggSWw6vSAgzWi+MTAwgE6nw2g04nA4OOecc7jrrru48MILQ37t6eDQoUNcf/31XH755Xz9619HrVYrVKDS0tJZG7I4PAIqmNKYRJIkhcZVXl6uUIEOtg/x/EdtuN1u1qWryDWIysRdduKbzVZbEASampqw2WyUl5dPayovD/TionTTbjRkyEGrWq121jSumcBms1FXV4fRaCQ3N9dvCDY+4FWmesvNhS8l6rTTTqO6upr4+PiFOsXJUadO2mZj1OWlc9hOcnS4kt58PPDggw9iMBhCMjkKBlGUODZkR6tW+YUuDQ8Pc/PNN6PVavnZz35GdHS0YgWYmpo6Y69zp9Pp51YkiiKHRvTY0KPS6rmkMpPMOP8VsUwFkkOBZLQPOdhyqBe1ChZnxFJdMPtMC1/IhaqoqMhv4iEL9OR7FwTBTycyUyE3cNy2HHIWyvDwMH19fXg8HmJiYkhPTyc2NhZRFP0oUb29vRNcomYbUniy46233uKss85Cq9Vy1113AUzgtAuCQHFxMW+//TaZmZmsWLGCP//5z5SXl3PZZZexYcMGrrjiCr7+9a+zZMkSbr755lDc6kLFDY5PRZ0yOzy8XddLbISOM0uS0c6QtjMbHDx4kI0bNyIIAqIoctlll3H//feH/LozgcPh4Nvf/jatra08/fTTJCcn43Q6OXz4MHFxcX75SnPFsN1N26CDvIRIxWlRkiQGBgZobGwkLCwMURQ5aBKpGVCh1+s5uzyFLy7LnJfry5DpzbJYPdSWvHKI7Pi6OJ+QKVFynXI6nRgMBjIyMjAajWg0Gvbt26fUqba2NgoLCxWXqKqqqoVtehCcDHXqpG02/ndXO/1WJ5F6LdesypmR9epMYLPZEEWR6OhobDYb69ev5/777+e8884LyfUCYX/HMO81DqBSwReXZpKd8MkDvyiK/P73v+eJJ57gl7/8JZWVlcp0xW63B/U6DyR2k4Va8uRfp9MxZHOzo22YhEg9K3KNmEbd1PVYyUuIJOc/9+H1emloaECSJEpLS9HpdHQMO3jtYC8SUJkdS058JA6PQFZcBLo5FmG5UEmSRHh4OKOjo+j1er917XxOeOx2u2LPl5+fP6cth+wSJU+DfMMK5c+9o6ODa665hoSEBKxWK2q12o8SFWo/+ZMVf//73/nrX//KH//4R7+/3759Ow8++CBvvvkmAI888ggAd999N0lJSfT29qLVaid83Txj4RsaHJ/aOvVZQq/ZyV/3dpAQpWfD8ky/bbYkSfzjH//gvvvu40c/+hFnnnkmMDaRHRwcZNGiRXM2yvAIIj9+q4khm4toLVyzKBKrxaxkNsXExGCxWPB4PGQXlvBa7Zju47Ll6ZNawM/6fv5jdy7TxkI0aVbgcrmor69Hp9PNecsxnYBXk8nEDTfcoFjKut1uli9fPoEStYCZ4dNap07KcackSdjdAhE6LW6viCCGrhb19fXxpS99CRh7qL7qqquOa6MBYHcJqNVj+gmHx+v3b2q1muuvv541a9Zw7bXXcuGFF3LbbbdRUlKE6zFNAAAgAElEQVTCwMAAe/bsobi4GIPB4CeG9hW75efnK2K38YiP0nNBRQrwiW+5JEk09du46tRMIvVjdsCLFi2ir6+PmpoaSkpKyIyL49zyJBwekbhIHf842IsgSizNiqU6f2ZbDl+RmdlsVny3AUXrMJc08KkQGRnJ8uXL6ejooKamhtLSUkWEPRVkOpd8aDscDiUtNjMzk8jISBoaGnj33Xf9KFEXXXQRPT09HDp0iOeee46lS5eG7P19VvDb3/5WoRz6oquri6ysLOXPmZmZ7Ny5k8HBQUXEKP99V1fXcbvfBSzg04QtB7tp7h+l3itRmhrDsuxPKFIqlYqLL76YqqoqNm7cyDvvvMN9991Hfn4+8fHxHDhwQNkCzASyns1sNtNnGqa104Reo8Kp0REWkUBWZsYEKtPg4CBH6g7x+YJ8UlJS/F5rT/sIHcNO1hbGz8iaNhB0Oh0VFRX09/ezZ8+ekGsrwsLCWLJkCb29vdTU1Mwo4yTQ8FGmHaemplJYWEhzc7NC3T148CAxMTGsXr0am83GBx98wBNPPMG6detC9v4+K/i01qmTstlQqVRcuDiNQ11m8hKjiAoL3dvMz8/nwIEDM/o/giBQVVVFRkYGW7ZsmfM9LM024hUl9Fo1+Umf2M95BVFZ1ZeUlLBt2za++93vcvHFF7N582YOHTrE2WefzYEDB9DpdKSmpipcy9lOPSJ0aoZsHiL0GuxugRaTjZSYMJIMYaSkpBAbG0tdXR0mk0mZbHQMOxBFCa1GjcMtTPr6vsUj0EQlI8O/eMjaisHBwYAiwPmCSqUiOzubxMRE6urqAgY6wScOJoHoXEVFRQol6l//+tcEStSdd945gRLV0NCAw+EIyXs6WXD22WfT29s74e9/+MMfKvabP/zhD9FqtVx99dUTvi7Q9lelUgX9+wUsYAETkW6M4EDHCHqtOii1OSMjgzfffJOf/OQnnH/++Tz77LMUFRVRWVlJQ0ODkigdjBYqux/6OgjKeraczDRuOSeNPR0WVufHkZ0eWMSckJBAVVUV9fX1mEwmSkpK0Gq1dJudvLSnGxXQMezgtjPz5+VzSU5Oxmg0Ul9fT39/v3K9UEClUpGWlkZ8fDz19fX09fVRXFw84XqBAl59h48ajYa9e/fyzjvvsGPHDo4dO0ZRURHV1dXcfPPNLF++3I8S1dHRQVtbW0je08mCk71OnZTNBkByTDifizkxLdF+8YtfUFZWhsVimZfXi9RrOb3YfyKys2WQ3W1DFKdGs74sBZvNxiOPPMK+ffs4duwY9957L2eccQaZmZksW7aMjo4O+vr6SE9Pn3WjoVKpuGBRCt0jTpKi9bxdP8CQ3YNeo+bKFRlE6DSEh4cr16upqaG8vJwMYxSrC+KxOL0sz/LfCARKXJWLR2pq6pTuWhERESxfvpz29nZ27949b+L4YIiMjKSyspL29nZ27dpFbm4ugiAolCg5lyMuLo7c3FxMJpOfSxSgUKJuuOGGKSlRpaWlIXsvJyJefvllHnzwQerr69m1axdVVVUTvqaxsdFv8tPS0sL3v/997rjjDh588EF+/etfk5SUxAMPPIBOp2NgYIAtW7awdevWgJ91ZmYmHR0dyp87OztJT08nMTFRsRXWarXK3y9gAXOBKErY3F4MYdqTqnk9tyKV/KQoDGHaCdo+X2g0Gu655x7OPPNMNm7cyObNm7n66qs55ZRT6O7upqamhrKyMmJjYxUqj7yVlyRJGd4UFxcTERHh9xnGxcHyHH/RebfZydb6AXISIjmtcEyQrNPpOOWUU5QtQGlpKVr12Gt5BZHwSUJqZwO9Xs/ixYv9tg6h3MbLW46enh6lTgF+bobyAC8rKwuz2eznEuV0OqmsrKS6upqf//znUw7ysrKy/KbuJzsW6tREnLSajang9oroNKrjfph3dnayceNG7r33Xh5//PF52WyMhyRJPL2tmZToMHotTr5anUukVsXrr7/OqlWrSE5Opq+vj+uuu47c3Fx+8IMfEB4ePq9e5wB/3NWJ0ysgSXDliowJThqBxOqhEHKPv95s/MCnA3mq5huc5/F4cDgcVFZWYjQa/Vyi6uvrSU5O9nOJio6OPqkeMOYb9fX1qNVqbrrpJh577LGAh7gvBEEgIyODnTt3kpOTM8HA4Y033uCb3/wm7733XlAKg9frpbi4mK1bt5KRkcGKFSv405/+REVFBV/+8pe55JJLFOHd4sWL2bx587y/bxY0G5PhpKlTgijx6/ebqeuxsDo/kStXZv+3b+m4wCOIOD0C0eH+gy6z2cytt96K2+3m0Ucfpa6ujoSEBIaGhlCpVEp2kKxnm81G4H+2NtNvdeMRRG47M5/seH9tiMPhoLa2FqPRiBidQp/VzZLMGGLCQ+Ps5HQ6qaurIyoqisLCwnl3Ohwf8Do6OorX61U0nGlpaX6UqEOHDhEbG6sE561evXrBJWoKLNSpiThpNxuTYVfrILtah8lPjOK8RamoJ7GQnW/ccccd/OQnP8FqtYbsGiqVikXpMRzqNpMdH4lBr8XuEVixbj0J0WPbnpSUFLZs2cLPf/5zzj33XJ555hnKy8tZsWIFjY2NDA4OzsnrHOC8imQa+6xkx0UEtOyLioqipKSEpqYmWltb0el0ijVefHw8eXl58yrkNhgMVFVV0drayp49eygvL59TYu34xkgURaUxKikpQRAEdu/ezV//+lduu+02RduxZs0a7rrrLhYvXrzgEjVDlJWVzejrt27dSkFBATk5OQH//dZbb8XlcrF+/XoAVq1axa9+9Su6u7u58cYbef3119FqtTz55JOce+65CILA9ddfT0VFBTDmCHLFFVfwve99j2XLlnHDDTfM7Q0u4DMNi8NDXY+VdGME21sGubQqc86GGSc6Rl1efvHvI/RbXHxpeQZnlIyFz4qiyLvvvktqair/+Mc/WLVqFUuXLuV73/selZWV9Pb2YrFYSE9Pn1OwW1ykjvZhB2EaNRG6iZ91REQElZWVtLW1MdzewPLycqJC1GgAyva/s7OT3bt3K1uc2UIOeJXrlG/Aa2FhISqVir179/LGG2/wjW98A71er2Rb3HLLLSxfvjzk4vWTDQt1aiI+k086e46NkBoTRotpFKvTS2wInCYCYcuWLSQnJ1NZWcm2bdtCeq3Ti5Ooyo0nQqfB6RX4S00HNpeXRRmxnPmfw1ytVvPNb36TdevWsWnTJq699lquu+46ysvLFTH3XLzOE6L0VOd/IkDzeDx+k385LTQ5OZmUlBQ6OjrIzMz0E+XNN9RqNQUFBSQlJXH48GHS0tKmZQEsSRI2m83PJUp2uJIbo/7+fj9KlOwSddFFF/G1r32Nhx56iFWrVnHbbbeF7P0twB//+7//y5VXXun3d08++SR/+MMfqKqqYvfu3QF/vtPT03n99deVP19wwQVccMEFE74uPz+fXbt2zf+NL+AzidgIHYszYznYOcJpRUknVKPR0dHBV7/6VXp7e1Gr1WzatInbb799zq/bNeygz+LEGKnn4+ZBpdlQqVTU19dz1lln8d3vfheTycS1117L1q1bWbJkCUVFRQwNDbFv3z4KCgpITk6e1fUvr8pgcUYMSdFhJEUHFn2rVCry8vJISEjg8OHDZGRkkJGREbLpvkqlIisri/j4eOrq6pQaM9U2XnYz9NU0+roZZmdnT6BEuVwuxSXqq1/9Ko8++ihFRUXceeedIXlvC5iIz0Kd+kzSqD5uMrG3fYTs+Ag+vzh90nC8+cQ999zDCy+8gFY7llZtsVjYsGEDL774Ykiv229x8tLuDqLDtei0ai6vysItiET6bBtsNhu33XYbQ0NDPPHEE8THxysJq7IobCa0o/Gp1rJFq5y2ajQaJ3hqezwe6uvr0Wg0IRXJyZDTua1WKxUVFX7TMUEQ/Ny5nE4nUVFRyqEdHh5OfX29HyUqNTVVoUStXLlyAiVKEATa2tooKCgI6fs6kTAd7ipAbm4u0dHRaDQaWlpayM4eo494vV46OzvxeDyUlZXx7rvvEhcXxxlnnDHletrtdpOenk5tba3SwPb19ZGYmIhKpeK+++6jp6eH3/72t/P/xucfC5yF4Dip6pQkSTg9IuE69QlFVenp6aGnp4fly5djtVqprKzklVdeoby8fE6va3d7efKdJrrNDi6ryqK6IHgOhNvt5v7772fXrl08++yzZGRk4Ha7qa+vR6/XT6nhmw8IgsDRo0dxOBxBrePnE77p3L7Bg/K/jXcz9A14NRgMHD16VGkuxlOiqquriYuL8/s5kySJpqYmioqKQvq+TiQs1Kl5w2cvZ2MqONzCf/Uw37ZtG4899lhINBvjIYoSO1oGaR+2U5UTx55jIwxYnawpTPSzH5QkiZdffpkf/vCH/PSnP2Xt2rVIkjQtr3NfIXegQ0/+BZ0Oenp6OHbsGCUlJbPeqswEQ0NDNDQ0KIeuxWJBkiS/xkimRMnNhZw4K2dbLFCiAmO63NXc3FxqamomBE595zvfIT4+nrvvvptHH32U4eFhfvzjH0/rEH/11Vd56qmneOuttwL+e1tbGxdeeCGHDx+e/Rs8fjhxnjpPPJy0depExsUXX8ytt96qUDvmAlGU8IiiX/aG2e6ha8RBflLUhJyst99+m29961vce++9Shp6V1cXXV1dITcBkWEymTh69GjILWtlWK1WDh8+rGRcBdI0ypQoublob2+nuLhYGYItUKICY6FOzRsWNBvjEaH3P7wkSeJgpxnTqIuqnPjjRq06HlCrVVQXJlIN9JgdDFidxEXqqeuxTPA6v+yyy1i5ciVf/epXqa6u5u677/bzOpeTwF0ulx8PVHYBiY2NDegCMhOkpaVhNBoVC9mZblWmgiRJjI6OKvcuU6LMZjO1tbWsX78ejUbDxx9/zI4dO6ipqUGlUrFixQrWrFnDpk2bZpy+/lnFTLmr4/Hqq68qlMONGzdyxhlnTEhODYY///nPE1bTPT09SpL93//+dxYtWjSn+1vAAo43XF4Bt1ecIKY+nmhra2Pfvn2sXLlyXl5PrVYRpv6kJjvcAj97q5Fhh4fCZAO3f85/yr5+/Xq2bt3KDTfcwL///W8eeeQRMjMzlbrhazoSKiQmJhITE0N9fT0DAwOUlJTM61YlUMCrVqvFZrPR0NBAZWUlSUlJygBs165duN1uxSXqqquumvfaebJioU6FHp/ZzcZ49Jgd/HVPJ1q1ioy4CL6wJCPg18nuTddcc01I78fpdHL66afjcrnwer1ceumlPPTQQ3N+XbdX5PVDPfSYHZxRkkRZWmDhmdfr5eGHH+add97hqaeeor+/H41Gg9vtVgRmcXFxfmni8w1Jkjh27Bj9/f1UVFTMWswtU6LkQ1sO/fOlRNXV1bF9+3bee+89PvroIzIyMvjiF78YlBK1gJlhqglPXl6eslm66aab2LRpEwBGo5GRkRHl6+Tv28DAAEajkaVLl/Lmm2/6CeVgLNU9KyuLlpYWP3HlV77yFfbv349KpSI3N5dnn31WOdRPcCz88AXHZ6ZODdnc/PztI1hcHq5akc2p+YFD2UJZp0ZHR1m3bh333nsvGzZsmPfXBzCNunh4Sx3R4VqcHoGfXrok4PkriiJPPfUUv//973nmmWdYtGgRgiDQ1NSkuCuFepIvSRLd3d10dHTMScwdiB0gB7wajUaioqI4cuQIO3bs4P333+e9997DaDTypS99idNOO43Vq1dPoEQtYGZYqFNzxsJmYyqEaTVoVCrcXhFDAOek434/YWG88847GAwGPB4Pa9eu5fzzz2fVqlVzel29Vs3FS9MR/hOiFwzvv/++ors488wzWbRoEXfccQfV1dVYrVba29tJTEyck0vGVJB/0WRRXnp6OpmZmVMeprL3uiyQA5RVc1paGl6vl927d/Paa6+xY8cOpZmprq7mwQcf5P+3d+9RTV/ZHsC/eSAYeQYfgBEYyCCPgFpBiw+sWMTXMKIWUamoOKUVbdG5a0mvbcfO7Ygdl9au2srckU4ZZgmKt77agtbWjq3yEJSWR0FQEIRYICAK8gjJuX94+V1TCEQlJMD+rJU/kvxCzg/1tz2/c/be9vb2eP3112FiYjIgWwSGO12aEfXn8uXLcHBwQF1dHYKCguDu7o6AgIAex5mYmODOnTs9Xv91opxIJIJCoehxXHJysk7jIcQY3Va0oqmtExamQmRXNGqdbOiLUqnEypUrsW7dOr1NNIBHxUWW+dgjv+oeVk3XvkLB5/Oxbds2BAQEICoqCmvXrsUrr7yCyZMno76+Hnl5eU/UKftp8Hg8TJw4ETY2NigqKoKtra1OpdX7avDq5uYGAMjLy8P58+eRlZWF6upqbkvUjh07kJCQgF27duH+/ftYunSp3s5vuKA4ZViG/1+1kRCPGYWV0yV40K6Eo/j/76Dfe9gJMxNBjz2j+sbj8bhEMKVSCaVSOWB3LHg8HoSCvn9WWVkZnnvuOcTExMDExATR0dE4deoUZs+eDQcHB1hbW6OoqIjrWaHPuykWFhbw9fVFeXk58vPz4enpySWXP74lqrtmeHf53PHjx8PV1RW//PILtyUqLy8PfD6f2xIVHR3d6wTm2LFjA9Z0cajQJUmut4o0Fy5cAACNRkQAnmi1q7vJ0Pjx4xEaGoqcnBwEBARgwoQJ3JKyXC5/6oozhAwHLuPMYWdpBkVrJ+a56T9P4HGMMURFRcHDwwM7duzQ63fxeDwEedohyNNOp+OnTJmCS5cuYceOHQgPD8cnn3yCcePGwdLSEkVFRVAoFJBKpXrdUtTd0LWyshJ5eXnw8vKCSPSoeeHj1Qy7t+52N3gVi8VwdnZGU1OTxpYopVLJbYmKiIjotRrV4cOH0dzcrLdzMkYUp4Ymmmw8ZoKlGSY81nU873YjMm82wtxUgFW+k2BuqvnrevjwIdasWYOuri4cP378mXo29EalUmH69OkoLy9HTEzMgO2P1UV0dLTG82PHjiExMRGLFi3CRx99hGnTpmH69Om4desWrl271qOa00DrrlBVV1eHnJwcWFlZQalUcuVzra2t4ezsDDMzMxQVFeHcuXPIyspCSUkJ7O3tMWvWLKxatQr79u2Dubl5v5MjHo+n11UbYySTyfD555/3+LN/nFAoxP79+zUq0gQFBXEVabZv3841ItJVa2sr1Go1LCws0NraivPnz+Odd94BAISEhCApKQlxcXFISkrS+Q4UIcOR1WgTvLnYAyrGdC6LO1Bx6vLly0hOToa3tzemTp0KANizZ0+vpTYNQSQS4fDhwzh58iSWLVuGvXv3Yt68eZg2bRqqqqqQm5v7TNtxdcHn8+Hi4gIbGxtcu3YNFhYWUKvVGtUMJRIJRCIRysrKcOnSJa5KlI2NDfz9/REcHIzdu3frvCWK4lRPFKeMD002+lDR0AoLMyHutyvR1NqpMdm4e/cufve738HX1xeHDh3SS7k9gUCA/Px83Lt3D6GhoSgsLDRYohCfz8cf/vAHzJkzBxs3bsTy5csRExMDqVQ6ILXOtekun9tdhpbH48HW1hbNzc346quvEB0djdLSUpw+fRrZ2dmoq6uDt7c3Zs2ahV27dkEmk1GVKB3pkiRnb2/P7R21sLCAh4cHVwGmNydPnsS2bdtQX1+PpUuX9rp39ZdffkFoaCiAR7lCa9euxaJFiwAAcXFxCAsLQ2JiIhwdHZGWljZAZ0vI0MTn88DvZWv0/XYl7ja3w8lWxL02kHGquzqhMePxeFixYgX8/PwQGRmJixcvYteuXXBycoKNjQ0KCgowadIkODg4DOhqfG8FU8RiMR4+fIizZ89i/fr1qK2t5W6CVVdXY/LkyZg1axa2bduGadOmUZUoHVGcGpooQbwPVYpWXPi5DnaWpgjyssPDDhWmzJyNsGULceLYUURHR2Pnzp2DMpZ3330XY8aMeeLZuD60t7cjLi4OP//8Mw4fPgw7O7sBqXWuVqs1tkS1trZyW6K6E9HlcjmuXLmCzMxMlJSUoKCgAAsWLMDKlSsxd+5cvTZaGil0KdcHPKpIExAQwJVj3L17Nz777DNYWlrC19cX+/fvH5TSxSME/aXWbkTHKQBoV6qwN70EitYOuNtZYN/GIKxduxapqamDGqeMSVdXF/bu3Yv09HT87W9/g4uLC1QqFUpLS6FUKuHp6flUhU1+3eC1paUFJiYmGnGqsbGR2xJVUFCA/Px8+Pv7Y/Xq1ZgzZ45ODfpI3yhOGSWtcYr+tvfB0XYMNs35DZb4PEqoPnHtDjBpGv71XQFEIhFiYmL09t319fVcdYO2tjZcuHAB7u7uevu+J2FmZoYPPvgAr7/+OpYvX47z58/DxMQEPj4+sLCwQG5uLh48eNDvz1EqlWhoaEB5eTny8vKQk5ODqqoqbina19cXfD4fGRkZXHL6tm3bcPv2bYSFheHLL79Ebm4u6uvrMXHiRJ2Sx0e6F198ETKZrMfj9OnTT/RzWlpasHLlShw8eBCWlpYAgNdeew03b95Efn4+7O3t8cc//lEfp0AI+ZUH7V1oetgJG5EJbjW0AgA+/fRTvccpYyYUCvHWW29h3759iIiIQEpKCvh8Pjw9PWFnZ4fc3Fw0NTX1+3NUKhUaGxu5LcNZWVm4desW1Go1HB0dMX36dIwePRrfffcd4uLiEBAQgE2bNqGwsBCLFi3C559/zjWrHT16NFxdXWmi0Q+KU8MPrWzoqLlNiX9lVWLfnr9g0eJFaLp6FhXVd3Du7Cm9zIp/+uknREZGQqVSQa1WIywsjNsfaEzkcjk2bNgANzc3vPvuuzAzM0NLS0uPWueMsR5VorrzIrobEnV2dmo0zmtoaIBMJuMaEnl7e/e6YtLV1QUAI267lK5dTzMyMvDGG29ApVJh8+bNiIuLAwBUVFQgPDwcjY2NeO6555CcnIxRo0b1e8dIqVRi2bJlCA4O1pooOsQaEQ0FNIvWbsTHKcYYMgrv4lp1ExZ72WPFvGnYvXs3zp07h4qKCqSnp4/ou7f37t3Dli1bAAAHDhyApaUl2tvbUVRU1KOXU3t7O1cqvXtL1ONxijGG3NxcrnHenTt34O7uzsWpadOm9bpiwhiDUqkccdulKE6NKNRBfCAU1zZjSdgGxG5cBVvPWUg6mgb5T5fw7fFErs38YOut6sIbb7wxqGNQqVQ4cOAA0tLSkJCQAHd3d3R2dqKkpAQtLS0QiURoa2uDmZmZRkfx7i1RWVlZuHbtGgQCAVclau7cuQO+r3a40aXrqUqlgpubG77++mtIJBL4+fkhJSUFnp6eCAsLw4oVKxAeHo5XX30VU6ZMwWuvvdbnRZwxhsjISIjFYhw8eFDjvccbEX3wwQfIzs5Gamqqfk5+5KF/CNpRnPqV7j4b85eG4o3//C/cyLmIr786Y7A4ZQwYY/jss8/w4Ycf4sMPP4Sfnx9UKhVu3LgBhUIBc3NztLW1YdSoURpbohQKBXcD7OrVq1AqlfD19eUmF7Qlqm8Up0YUmmwMFGdnZ/zHO38BnGfAWjQKn6eloeiLv+Prr7+Go6PjoI9HLpdDLpdrVF04deqU1kQofWlubkZSUhL27NmDsWPHwtTUFAkJCRAIBLhw4QImTJgAqVTKXbRLS0vh4ODAXbBnzpyJMWPG0OTiKfR10c3MzOTucAJAfHw8gEcJbePGjcPdu3chFAqRmZmJLVu2oL6+vs9GRD/88APmzp0Lb29vLsB2V6QZwo2IhgL6h6EdxalfcXZ2xlvvvocycx+0tnfhxvUruH32I4PFKWPR2tqKEydO4O2334aVlRU6Ojrw6aefwtzcHJmZmWhvb8ecOXO4OFVYWAixWMzFKX9/f1hbW1OcegoUp0YEauo3UCorK6FUqXGu8C5qm9uwb+ercN1vuKTtJ626oA///ve/8dZbb8Hf3x8HDx7EF198gZaWFpSVlaGgoAC5ubm4ceMGRCIRoqOj8fbbb0Mmk+mlghfRVFNTg0mTJnHPJRIJsrOzoVAoYG1tzW09k0gkUCqV/TYi6qsizXBsRETIUFRZWQnF/3XhFpkKMH1WAM7tizGa/yRv2rQJX3zxBcaPHz9oW1hKSkqwceNGzJgxA/Hx8bhy5QqKi4tRVVWF0tJSZGVlobKyEgcPHkR0dDRiY2O1bokiA4vi1PDX52SjS6WGgM8zmguUsTAR8LFsigMYY0b1u6msrMT169cHtR8HAMybNw/ff/8993z16tX485//jOTkZERGRmLr1q2ws7PDRx99hJycHMTGxg7q+IayZ+162tsFtzuHprfXCSHDg625KdbOdETBnft4wX2cUf373rBhA7Zu3Yr169cP2ne6u7sjMzOTe7527VokJiYiISEBmzdvRmRkJJydnXH06FEkJSXhzTffNKrfmTGjOEX60+dGw79/fwv/c+0OOrpUgzWeIcWY/tL3VnXBUHg8Hv70pz8hPT0d4eHhmDhxIgQCAWJjY5GUlGTQsRlKY2MjgoKC8Nvf/hZBQUG9VkG5ePEipk6dyj3MzMywdetWFBYWwtfXF62trRAKhRAKhXByctLpeyUSCaqrq7nnd+7cgYODA8aOHYt79+5xyfXdrxMy1JwrkqO4dmR1UdbVjN/YImrub+A6ztzQQ9EQEBAAsVhs0DHweDxs3rwZly5dwvr167kk8YiICHz11VdGFd8HC8Upoi99TjYsTE1wt7kd9Q86Bms85CkolUqsXLkS69atw4oVKww9nD6N1CXpvXv3YsGCBSgrK8OCBQuwd+/eHsfMnz8f+fn5yM/Px7fffguRSISFCxdy7+/bt497v7uDb3/8/PxQVlaGiooKdHZ2IjU1FSEhIeDxeJg/fz5OnDgBANT1lAxZZ3+U478v3YK8uc3QQyHDBMUpilNkYPU52bjfroTtGFOMNTcdrPGQJ8QYQ1RUFDw8PLSWdyOGd/r0aURGRgIAIiMjcerUqT6PP3HiBBYvXgyRSKT1mJMnT0IikSAzMxNLl7Ug/5AAAAnVSURBVC5FcHAwAKC2thZLliwB8Kgc8KFDhxAcHAwPDw+EhYXBy8sLAPD+++/jwIEDkEqlUCgUiIqKGohTJWRQ8Xk8MABqShMn5JlQnCL60mc1qrZOFTMR8CAUPJqT3Gl6iC4Vg6NYBD5/5C0xGqO+qi4Q42Ftbc01aQQAGxubPhtKBQYGYseOHVi2bBmAR3ucMzMzYWpqyt1xMjWlmwAjCF1wtTjzYw1ztBFhquPI7SMxFFGPA+NDcYo8o2cvfVuleIjT+TVQM4Z5buPowj5EGaIKyEjRV5JcZGSkzhdxuVwOHx8f1NbWcsv5crkcdnZ26OzsxCuvvAJXV1ejbPJI9IYmG9rRmsYQRJMNw6A4RfRIa5zSuRNNm7ILKsYg4PPQ0tE1MMMig27Dhg3IyMgw9DCMmi5JcgAgEAi4JLmQkBBcuHABhYWFOHv2LMaMGYOOjg54eXlh8eLFmDBhAuRyOYBHF+Tx48dr/f7jx48jNDRUY9+wvb09eDweTE1NsXHjRuTk5AzsSRMyjNQ/6MCZH2tQcOde/weTQbdmzRr4+/ujtLQUEokEiYmJhh7SkENxigwlOk82XMaZY4azGF4OlnjOyQZNrZ3Ir2pC3YN2fY6PDDBjqAJi7HRJkgOA0aNHc4lwZ86c4V7fuXMntm/fjrKyMtjY2CAxMREhISFcJa7+ktxSUlKwZs0ajde6AwBjDKdOnYJMJnvW0yRk2Pr0cgW+Ka5D4g8VqLtPMcrYpKSkQC6Xcz0TaB/+k6M4RYaSp+ogrlYzJGfdRkt7F0xN+HjZ3wmmQmrQNlTQ8nXfJk+ejO+++w729vaQy+V44YUXUFpa2uM4c3NztLS0aLzGGOvR8XT37t04evQowsLCUFVVBUdHR6SlpUEsFiM3NxcJCQk4cuQIgEd/NrNnz0Z1dTWXgwM82htbX18PxhimTp2KhIQEmJsbVzlLole0jUq7HnFq37kSVCkeQsDn4T+XemC8hZkhxkWI3lCcIkbo2XM2HqdWM3x2pRKdKjV4AFb7TUKXmkEsGkWJ40MATTb6pmuSnFAoxNSpUyEUChEXF4fly5ejoaEBzz//PMrLywEA1dXVWLx4Mf2uybOiC6t2PeKUoqUDOZWNcLYVwcPeyhBjIkSvKE4RI6Q1TvXZQVwbPp+HkKkOuHH3AeytzXD2x1o0tynhI7FGgNu4px8mIYOkryQ5XVVVVcHBwQG3bt1CYGAgvL29e22oOBKbQxFiSLbmplgss9d4rfyXByioaYavsxiTxNpLdRJiLChOkeFC55yNXxtrbopZ0rEYYypEc5sS1qNHobKhdSDHRki/dEmSy8/Ph7+/P7y8vODj44Njx45xSXK9dTzVNUmuu5Opi4sLXnjhBVy/ft1oO546Ozvjvffew/z582Fubg5vb2/89NNPSElJgVQqhZWVFTZv3syNm5Dh5GFnFxIu3cKlsnp8fLEcXSq1oYdERhCKU7qhODV8PfVko9vYMabwmmiFLrUas6VjB2JMRI+GWxUQXZLkRCIR/vnPf6KoqAgZGRmIjY3VWH7+dcdTXZLkmpqa0NHRAQBoaGjA5cuX4enpadQdT5OSkvDJJ5+gqakJU6ZMQWhoKC5evIgff/wRBQUFOHPmDI4fP27oYRIy4HjggccDVGoGIZ9Hd3HJoKI4pTuKU8MUY6yvBxnh0tPTmZubG3N1dWXx8fGGHk4Pbm5urLa2ljHGWG1tLXNzc+v3Mz4+PuzGjRuMMcYiIyNZWlqaxvsNDQ0sMDCQSaVSFhgYyBQKBWOMsatXr7KoqCjGGGOXL19mMpmM+fj4MJlMxo4cOcJ9/ubNm8zPz4+5urqyVatWsfb29gE512fh5OTE/vrXv3LPv/zySwaA1dXVca+99NJLLDY21hDDI/3r71o9kh86ud3QyjIKa1ntvYe6foQMERSnKE4Ro6D1Ok2TDaJVV1cXc3FxYTdv3mQdHR3Mx8eHFRUVGXpYGqysrDSeW1tb93l8dnY2c3d3ZyqVijH26CLu5ubGvL29WWxsrFFccPXBycmJJScnc88vXrzIBAKBxjGRkZFckCJGx9D/oTfmBxnBKE4NHxSnhjyt1+ln3kZFhq+cnBxIpVK4uLhg1KhRCA8Px+nTpwd9HC+++CJkMlmPx5OORS6X4+WXX8Y//vEPrlxffHw8SkpKcPXqVTQ2NuL999/XxykQQgjRA4pThBg/mmwQrWpqajBp0iTuuUQiQU1NzRP9jIyMDEyePBlSqbTXfaodHR1YvXo1pFIpZs6cicrKSu69+Ph4SKVSVFdXY//+/SgsLNR4/P73v9c5Se7+/ftYunQp3nvvPTz//PPc69TxlBBChi6KU4QYP5psEK0Y69lm5UkSK1UqFWJiYpCeno7i4mKkpKSguLhY45jExETY2NigvLwc27dvx86dOwEAxcXFSE1N5ZLltmzZApVK1eM7dEmS6+zsRGhoKNavX4+XXnpJ4z3qeEoIIUMXxSlChoC+9lgN+m4vYlSuXLnCFi5cyD3fs2cP27Nnz4B+fuHChezKlSuMMcaUSiWztbVlarW6x7GPH/c4XZLkkpOTmVAoZFOmTOEe169fZ4wxNn/+fCaTyZiXlxdbt24de/Dggc7nR8ggMnRehDE/yAhGcYoQo6H1Ov1UTf3IyODn54eysjJUVFRg4sSJSE1NxdGjR3X+fG/L29nZ2VqPEQqFsLKygkKhQE1NjcYysralcVtbW3zzzTc9Xvf19cWRI0cAABEREYiIiOh1jN9++63O50MIIcS4UJwixPjRZINoJRQKcejQIQQHB0OlUmHTpk3w8vLS+fNMh+Vtbcfo8llCCCEjG8UpQowfTTZIn5YsWYIlS5Y81WclEgmqq6u55711Ke0+RiKRoKurC83NzRCLxTp9lhBCCKE4RYhxowRxojePL293dnYiNTUVISEhGsc8njh34sQJBAYGgsfjISQkBKmpqejo6EBFRQXKysowY8YMQ5wGIYSQYYriFCH6RysbRG+0LW+/88478PX1RUhICKKiovDyyy9DKpVCLBYjNTUVAODl5YWwsDB4enpCKBTi448/hkAgMPAZEUIIGU4oThGif7ze9hw+ps83CSGEDAraCK4dxSlCCDE8rXGKtlERQgghhBBC9IImG4QQQgghhBC9oMkGIYQQQgghRC9oskEIIYQQQgjRC5psEEIIIYQQQvSCJhuEEEIIIYQQvaDJBiGEEEIIIUQvaLJBCCGEEEII0QuabBBCCCGEEEL0QtjP+9S1lhBCiDGjOEUIIUaMVjYIIYQQQgghekGTDUIIIYQQQohe0GSDEEIIIYQQohc02SCEEEIIIYToBU02CCGEEEIIIXpBkw1CCCGEEEKIXvwvbCN49mdcKMQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### for adjusters \n", + "fig = plt.figure(figsize=(14,14))\n", + "fig.suptitle('Consumption of adjusters at grid points of m and k(for different h)',\n", + " fontsize=(13))\n", + "for hgrid_id in range(EX3SS['mpar']['nh']):\n", + " ## prepare the reduced grids \n", + " hgrid_fix=hgrid_id\n", + " fix_bool = mut_rdc_idx[2]==hgrid_fix # for a fixed h grid value \n", + " rdc_id = (mut_rdc_idx[0][fix_bool], \n", + " mut_rdc_idx[1][fix_bool],\n", + " mut_rdc_idx[2][fix_bool])\n", + " mmgrid_rdc = mmgrid[rdc_id[0]].T[0]\n", + " kkgrid_rdc = kkgrid[rdc_id[1]].T[0]\n", + " mut_n_rdc= mut_n_StE[rdc_id]\n", + " c_n_rdc = cn_StE[rdc_id]\n", + " c_a_rdc = ca_StE[rdc_id]\n", + " mmax = mmgrid_rdc.max()\n", + " kmax = kkgrid_rdc.max()\n", + " \n", + " ## plots \n", + " ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d')\n", + " ax.scatter(mmgrid,kkgrid,ca_StE[:,:,hgrid_fix],marker='.',\n", + " label='StE(before dct): adjuster')\n", + " ax.scatter(mmgrid_rdc,kkgrid_rdc,c_a_rdc,c='red',marker='*',\n", + " label='StE(after dct):adjuster')\n", + " ax.set_xlabel('m',fontsize=13)\n", + " ax.set_ylabel('k',fontsize=13)\n", + " ax.set_zlabel(r'$c_n(m,k)$',fontsize=13)\n", + " ax.set_xlim([0,mmax*1.1])\n", + " ax.set_ylim([0,kmax*1.2])\n", + " ax.set_title(r'$h({})$'.format(hgrid_fix))\n", + " ax.view_init(20, 240)\n", + "ax.legend(loc=9)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### compare adjusters and non-adjusters after DCT\n", + "\n", + "fig = plt.figure(figsize=(14,14))\n", + "fig.suptitle('Consumption of adjusters/non-adjusters at grid points of m and k(for different h)',\n", + " fontsize=(13))\n", + "for hgrid_id in range(EX3SS['mpar']['nh']):\n", + " ## prepare the reduced grids \n", + " hgrid_fix=hgrid_id\n", + " fix_bool = mut_rdc_idx[2]==hgrid_fix # for a fixed h grid value \n", + " rdc_id = (mut_rdc_idx[0][fix_bool], \n", + " mut_rdc_idx[1][fix_bool],\n", + " mut_rdc_idx[2][fix_bool])\n", + " mmgrid_rdc = mmgrid[rdc_id[0]].T[0]\n", + " kkgrid_rdc = kkgrid[rdc_id[1]].T[0]\n", + " mut_n_rdc= mut_n_StE[rdc_id]\n", + " c_n_rdc = cn_StE[rdc_id]\n", + " c_a_rdc = ca_StE[rdc_id]\n", + " \n", + " ## plots \n", + " ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d')\n", + " #ax.scatter(mmgrid,kkgrid,cn_StE[:,:,hgrid_fix],marker='.',\n", + " # label='StE(before dct): non-adjuster')\n", + " #ax.scatter(mmgrid,kkgrid,ca_StE[:,:,hgrid_fix],c='yellow',marker='.',\n", + " # label='StE(before dct): adjuster')\n", + " ax.scatter(mmgrid_rdc,kkgrid_rdc,c_n_rdc,c='red',marker='o',\n", + " label='StE(after dct):non-adjuster')\n", + " ax.scatter(mmgrid_rdc,kkgrid_rdc,c_a_rdc,c='blue',marker='*',\n", + " label='StE(after dct):adjuster')\n", + " ax.set_xlabel('m',fontsize=13)\n", + " ax.set_ylabel('k',fontsize=13)\n", + " ax.set_zlabel(r'$c_a(m,k)$',fontsize=13)\n", + " ax.set_title(r'$h({})$'.format(hgrid_fix))\n", + " ax.set_xlim(0,400)\n", + " ax.view_init(20, 240)\n", + "ax.legend(loc=9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Observation\n", + "\n", + "- For a given grid value of productivity, the remaining grid points after DCT to represent the whole consumption function are concentrated in low values of $k$ and $m$. This is because the slopes of the surfaces of marginal utility are changing the most in these regions. For larger values of $k$ and $m$ the functions become smooth and only slightly concave, so they can be represented by many fewer points\n", + "- For different grid values of productivity (2 sub plots), the numbers of grid points in the DCT operation differ. From the lowest to highest values of productivity, there are 78, 33, 25 and 18 grid points, respectively. They add up to the total number of gridpoints of 154 after DCT operation, as we noted above for marginal utility function. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Distribution of states \n", + "\n", + "- We first plot the distribution of $k$ fixing $m$ and $h$. Next, we plot the joint distribution of $m$ and $k$ only fixing $h$ in 3-dimenstional space. \n", + "- The joint-distribution can be represented by marginal distributions of $m$, $k$ and $h$ and a copula that describes the correlation between the three states. The former is straightfoward. We plot the copula only. Copula is essentially a multivariate cummulative distribution function where each marginal is uniform. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "### Marginalize along h grids\n", + "\n", + "joint_distr = EX3SS['joint_distr']\n", + "joint_distr_km = EX3SS['joint_distr'].sum(axis=2)\n", + "\n", + "### Plot distributions in 2 dimensional graph \n", + "\n", + "fig = plt.figure(figsize=(10,10))\n", + "plt.suptitle('Marginal distribution of k at different m')\n", + "\n", + "for hgrid_id in range(EX3SS['mpar']['nh']):\n", + " ax = plt.subplot(2,2,hgrid_id+1)\n", + " ax.set_title(r'$h({})$'.format(hgrid_fix))\n", + " ax.set_xlabel('k',size=12)\n", + " for id in range(EX3SS['mpar']['nm']): \n", + " ax.plot(kgrid,joint_distr[id,:,hgrid_id])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "code_folding": [ + 0 + ] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## Plot joint distribution of k and m in 3d graph\n", + "\n", + "fig = plt.figure(figsize=(14,14))\n", + "fig.suptitle('Joint distribution of m and k(for different h)',\n", + " fontsize=(13))\n", + "for hgrid_id in range(EX3SS['mpar']['nh']):\n", + " ## plots \n", + " ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d')\n", + " ax.plot_surface(mmgrid,kkgrid,joint_distr[:,:,hgrid_fix], rstride=1, cstride=1,\n", + " cmap='viridis', edgecolor='none')\n", + " ax.set_xlabel('m',fontsize=13)\n", + " ax.set_ylabel('k',fontsize=13)\n", + " #ax.set_zlabel(r'$p(m,k)$',fontsize=10)\n", + " ax.set_title(r'$h({})$'.format(hgrid_fix))\n", + " ax.set_xlim(0,400)\n", + " ax.view_init(20, 40)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Commulative probability distribution function in StE')" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "copula_value = EX3SS['Copula']['value']\n", + "fig=plt.plot(copula_value)\n", + "plt.title(\"Commulative probability distribution function in StE\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice the cdfs in StE copula have 4 modes, corresponding to the number of $h$ grids. Each of the four parts of the cdf is a joint-distribution of $m$ and $k$. It can be presented in 3-dimensional graph as below. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "code_folding": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "## plot copula \n", + "\n", + "cdf=EX3SS['Copula']['value'].reshape(4,30,30) # important: 4,30,30 not 30,30,4? \n", + "\n", + "fig = plt.figure(figsize=(14,14))\n", + "fig.suptitle('Copula of m and k(for different h)',\n", + " fontsize=(13))\n", + "for hgrid_id in range(EX3SS['mpar']['nh']):\n", + " ## plots \n", + " ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d')\n", + " ax.plot_surface(mmgrid,kkgrid,cdf[hgrid_fix,:,:], rstride=1, cstride=1,\n", + " cmap='viridis', edgecolor='None')\n", + " ax.set_xlabel('m',fontsize=13)\n", + " ax.set_ylabel('k',fontsize=13)\n", + " ax.set_title(r'$h({})$'.format(hgrid_fix))\n", + " ax.set_xlim(0,400)\n", + " ax.view_init(30, 45)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given the assumption that the copula remains the same after aggregate risk is introduced, we can use the same copula and the marginal distributions to recover the full joint-distribution of the states. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Summary: what do we achieve after the transformation?\n", + "\n", + "- Using the DCT, the dimension of policy function and value functions are reduced both from 3600 to 154 and 94, respectively.\n", + "- By marginalizing the joint distribution with the fixed copula assumption, the marginal distribution is of dimension 64 compared to its joint distribution of a dimension of 3600.\n", + "\n", + "\n" + ] + } + ], + "metadata": { + "cite2c": { + "citations": { + "6202365/L5GBWHBM": { + "author": [ + { + "family": "Reiter", + "given": "Michael" + } + ], + "container-title": "Journal of Economic Dynamics and Control", + "id": "undefined", + "issue": "1", + "issued": { + "month": 1, + "year": 2010 + }, + "note": "Citation Key: reiterBackward", + "page": "28-35", + "page-first": "28", + "title": "Solving the Incomplete Markets Model with Aggregate Uncertainty by Backward Induction", + "type": "article-journal", + "volume": "34" + }, + "6202365/UKUXJHCN": { + "author": [ + { + "family": "Reiter", + "given": "Michael" + } + ], + "id": "6202365/UKUXJHCN", + "note": "Citation Key: reiter2002recursive \nbibtex*[publisher=Citeseer]", + "title": "Recursive computation of heterogeneous agent models", + "type": "article-journal" + }, + "6202365/VPUXICUR": { + "author": [ + { + "family": "Krusell", + "given": "Per" + }, + { + "family": "Smith", + "given": "Anthony A." + } + ], + "container-title": "Journal of Political Economy", + "id": "6202365/VPUXICUR", + "issue": "5", + "issued": { + "year": 1998 + }, + "page": "867–896", + "page-first": "867", + "title": "Income and Wealth Heterogeneity in the Macroeconomy", + "type": "article-journal", + "volume": "106" + }, + "6202365/WN76AW6Q": { + "author": [ + { + "family": "SeHyoun Ahn, Greg Kaplan, Benjamin Moll, Thomas Winberry", + "given": "" + }, + { + "family": "Wolf", + "given": "Christian" + } + ], + "editor": [ + { + "family": "Parker", + "given": "Jonathan" + }, + { + "family": "Martin S. Eichenbaum", + "given": "Organizers" + } + ], + "id": "6202365/WN76AW6Q", + "issued": { + "year": 2017 + }, + "note": "Citation Key: akmwwInequality \nbibtex*[booktitle=NBER Macroeconomics Annual;publisher=MIT Press;location=Cambridge, MA]", + "title": "When Inequality Matters for Macro and Macro Matters for Inequality", + "type": "article-journal", + "volume": "32" + }, + "undefined": { + "author": [ + { + "family": "Reiter", + "given": "Michael" + } + ], + "container-title": "Journal of Economic Dynamics and Control", + "id": "undefined", + "issue": "1", + "issued": { + "month": 1, + "year": 2010 + }, + "note": "Citation Key: reiterBackward", + "page": "28-35", + "page-first": "28", + "title": "Solving the Incomplete Markets Model with Aggregate Uncertainty by Backward Induction", + "type": "article-journal", + "volume": "34" + } + } + }, + "jupytext": { + "formats": "ipynb,py:percent" + }, + "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.7" + }, + "latex_envs": { + "LaTeX_envs_menu_present": true, + "autoclose": false, + "autocomplete": true, + "bibliofile": "biblio.bib", + "cite_by": "apalike", + "current_citInitial": 1, + "eqLabelWithNumbers": true, + "eqNumInitial": 1, + "hotkeys": { + "equation": "Ctrl-E", + "itemize": "Ctrl-I" + }, + "labels_anchors": false, + "latex_user_defs": false, + "report_style_numbering": false, + "user_envs_cfg": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": {}, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/HARK/BayerLuetticke/DCT-Copula-Illustration.py b/HARK/BayerLuetticke/DCT-Copula-Illustration.py new file mode 100644 index 000000000..add78f14f --- /dev/null +++ b/HARK/BayerLuetticke/DCT-Copula-Illustration.py @@ -0,0 +1,705 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.2' +# jupytext_version: 1.1.3 +# kernelspec: +# display_name: Python 3 +# language: python +# name: python3 +# --- + +# %% [markdown] +# # Dimension Reduction in [Bayer and Luetticke (2018)](https://cepr.org/active/publications/discussion_papers/dp.php?dpno=13071) +# +# [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/econ-ark/HARK/BayerLuetticke?filepath=notebooks%2FHARK%2FBayerLuetticke%2FTwoAsset.ipynb) +# +# +# This companion to the [main notebook](TwoAsset.ipynb) explains in more detail how they reduce the dimensionality of the problem +# +# - Based on original slides by Christian Bayer and Ralph Luetticke +# - Original Jupyter notebook by Seungcheol Lee +# - Further edits by Chris Carroll, Tao Wang +# + +# %% [markdown] +# ### Preliminaries +# +# In StE in the model, in any given period, a consumer in state $s$ (which comprises liquid assets $m$, illiquid assets $k$, and human capital $\newcommand{hLev}{p}\hLev$) has two key choices: +# 1. To adjust ('a') or not adjust ('n') their holdings of illiquid assets $k$ +# 1. Contingent on that choice, decide the level of consumption, yielding consumption functions: +# * $c_n(s)$ - nonadjusters +# * $c_a(s)$ - adjusters +# +# The usual envelope theorem applies here, so marginal value wrt the liquid asset equals marginal utility with respect to consumption: +# $[\frac{d v}{d m} = \frac{d u}{d c}]$. +# In practice, the authors solve the problem using the marginal value of money $\texttt{Vm} = dv/dm$, but because the marginal utility function is invertible it is trivial to recover $\texttt{c}$ from $(u^{\prime})^{-1}(\texttt{Vm} )$. The consumption function is therefore computed from the $\texttt{Vm}$ function + +# %% {"code_folding": [0, 6, 17, 21]} +# Setup stuff + +# This is a jupytext paired notebook that autogenerates a corresponding .py file +# which can be executed from a terminal command line via "ipython [name].py" +# But a terminal does not permit inline figures, so we need to test jupyter vs terminal +# Google "how can I check if code is executed in the ipython notebook" +def in_ipynb(): + try: + if str(type(get_ipython())) == "": + return True + else: + return False + except NameError: + return False + +# Determine whether to make the figures inline (for spyder or jupyter) +# vs whatever is the automatic setting that will apply if run from the terminal +if in_ipynb(): + # %matplotlib inline generates a syntax error when run from the shell + # so do this instead + get_ipython().run_line_magic('matplotlib', 'inline') +else: + get_ipython().run_line_magic('matplotlib', 'auto') + +# The tools for navigating the filesystem +import sys +import os + +# Find pathname to this file: +my_file_path = os.path.dirname(os.path.abspath("TwoAsset.ipynb")) + +# Relative directory for pickled code +code_dir = os.path.join(my_file_path, "BayerLuetticke_code/TwoAssetCode") + +sys.path.insert(0, code_dir) +sys.path.insert(0, my_file_path) + +# %% {"code_folding": [0]} +# Load precalculated Stationary Equilibrium (StE) object EX3SS + +import pickle +os.chdir(code_dir) # Go to the directory with pickled code + +## EX3SS_20.p is the information in the stationary equilibrium +## (20: the number of illiquid and liquid weath gridpoints) +### The comments above are original, but it seems that there are 30 not 20 points now + +EX3SS=pickle.load(open("EX3SS_20.p", "rb")) + +# %% [markdown] +# ### Dimensions +# +# The imported StE solution to the problem represents the functions at a set of gridpoints of +# * liquid assets ($n_m$ points), illiquid assets ($n_k$), and human capital ($n_h$) +# * (In the code these are $\{\texttt{nm ,nk ,nh}\}$) +# +# So even if the grids are fairly sparse for each state variable, the total number of combinations of the idiosyncratic state variables is large: $n = n_m \times n_k \times n_h$. So, e.g., $\bar{c}$ is a set of size $n$ containing the level of consumption at each possible combination of gridpoints. +# +# In the "real" micro problem, it would almost never happen that a continuous variable like $m$ would end up being exactly equal to one of the prespecified gridpoints. But the functions need to be evaluated at such points. This is addressed by linear interpolation. That is, if, say, the grid had $m_{8} = 40$ and $m_{9} = 50$ then and a consumer ended up with $m = 45$ then the approximation is that $\tilde{c}(45) = 0.5 \bar{c}_{8} + 0.5 \bar{c}_{9}$. +# + +# %% {"code_folding": [0]} +# Show dimensions of the consumer's problem (state space) + +print('c_n is of dimension: ' + str(EX3SS['mutil_c_n'].shape)) +print('c_a is of dimension: ' + str(EX3SS['mutil_c_a'].shape)) + +print('Vk is of dimension:' + str(EX3SS['Vk'].shape)) +print('Vm is of dimension:' + str(EX3SS['Vm'].shape)) + +print('For convenience, these are all constructed from the same exogenous grids:') +print(str(len(EX3SS['grid']['m']))+' gridpoints for liquid assets;') +print(str(len(EX3SS['grid']['k']))+' gridpoints for illiquid assets;') +print(str(len(EX3SS['grid']['h']))+' gridpoints for individual productivity.') +print('') +print('Therefore, the joint distribution is of size: ') +print(str(EX3SS['mpar']['nm'])+ + ' * '+str(EX3SS['mpar']['nk'])+ + ' * '+str(EX3SS['mpar']['nh'])+ + ' = '+ str(EX3SS['mpar']['nm']*EX3SS['mpar']['nk']*EX3SS['mpar']['nh'])) + + +# %% [markdown] +# ### Dimension Reduction +# +# The authors use different dimensionality reduction methods for the consumer's problem and the distribution across idiosyncratic states + +# %% [markdown] +# #### The consumer's problem: Basis Functions +# +# The idea is to find an efficient "compressed" representation of our functions (e.g., the consumption function). The analogy to image compression is that nearby pixels are likely to have identical or very similar colors, so we need only to find an efficient way to represent the way in which the colors change from one pixel to another. Similarly, consumption at a given point $s_{i}$ is likely to be close to consumption point another point $s_{j}$ that is "close" in the state space (similar wealth, income, etc), so a function that captures that similarity efficiently can preserve most of the information without keeping all of the points. +# +# Like linear interpolation, the [DCT transformation](https://en.wikipedia.org/wiki/Discrete_cosine_transform) is a method of representing a continuous function using a finite set of numbers. It uses a set of independent basis functions to do this. +# +# But it turns out that some of those basis functions are much more important than others in representing the steady-state functions. Dimension reduction is accomplished by basically ignoring all basis functions that make small contributions to the steady state distribution. +# +# ##### When might this go wrong? +# +# Suppose the consumption function changes in a recession in ways that change behavior radically at some states. Like, suppose unemployment almost never happens in steady state, but it can happen in temporary recessions. Suppose further that, even for employed people, _worries_ about unemployment cause many of them to prudently withdraw some of their illiquid assets -- behavior opposite of what people in the same state would be doing during expansions. In that case, the DCT functions that represented the steady state function would have had no incentive to be able to represent well the part of the space that is never seen in steady state, so any functions that might help do so might well have been dropped in the dimension reduction stage. +# +# On the whole, it seems unlikely that this kind of thing is a major problem, because the vast majority of the variation that people experience is idiosyncratic. There is always unemployment, for example; it just moves up and down a bit with aggregate shocks, but since the experience is in fact well represented in the steady state the method should have no trouble capturing it. +# +# Where it might have more trouble is in representing economies in which there are multiple equilibria in which behavior is quite different. + +# %% [markdown] +# #### For the distribution of agents across states: Copula +# +# The other tool the authors use is the ["copula,"](https://en.wikipedia.org/wiki/Copula_(probability_theory)) which allows us to represent the distribution of people across idiosyncratic states efficiently +# +# The copula is computed from the joint distribution of states in StE and will be used to transform the marginal distributions back to joint distributions. +# +# * In general, a multivariate joint distribution is not uniquely determined by marginal distributions only. A copula, to put it simply, is a compressed representation of the joint distribution of the rank order of points; together with the marginal distributions this expands to a complete representation of the joint distribution +# * The crucial assumption of a fixed copula is that what aggregate shocks do is to squeeze or distort the steady state distribution, but leave the rank structure of the distribution the same. Think of representing a balloon by a set of points on its surface; the copula assumption is effectively that when something happens to the balloon (more air is put in it, or it is squeezed on one side, say), we can represent what happens to the points by thinking about how the relationship between points is distorted, rather than having to reconstruct the shape of the balloon with a completely independent set of new points. Which points are close to which other points does not change, but the distances between them can change. If the distances between them change in a particularly simple way, you can represent what has happened with a small amount of information. For example, if the balloon is perfectly spherical, then adding a given amount of air might increase the distances between adjacent points by 5 percent. (See the video illustration here) +# +# - In the context of this model, the assumption that allows us to use a copula is that the rank order correlation (e.g. the correlation of where you rank in the distribution of liquid assets and illiquid assets) remains the same after the aggregate shocks are introduced to StE. That is, the fact that you are richer than me, and Bill Gates is richer than you, does not change in a recession. _How much_ richer you are than me, and Gates than you, can change, but the rank order does not. +# +# - In this case we just need to represent how the marginal distributions of each state change, instead of the full joint distributions +# +# - This reduces the number of points for which we need to track transitions from $3600 = 30 \times 30 \times 4$ to $64 = 30+30+4$. Or the total number of points we need to contemplate goes from $3600^2 \approx 13 million$ to $64^2=4096. + +# %% {"code_folding": []} +# Get some specs about the copula, which is precomputed in the EX3SS object + +print('The copula consists of two parts: gridpoints and values at those gridpoints:'+ \ + '\n gridpoints have dimensionality of '+str(EX3SS['Copula']['grid'].shape) + \ + '\n where the first element is total number of gridpoints' + \ + '\n and the second element is number of state variables' + \ + ',\n whose values also are of dimension of '+str(EX3SS['Copula']['value'].shape[0]) + \ + '\n each entry of which is the probability that all three of the' + '\n state variables are below the corresponding point.') + + +# %% {"code_folding": []} +## Import necessary libraries + +from __future__ import print_function +import sys +sys.path.insert(0,'../') + +import numpy as np +from numpy.linalg import matrix_rank +import scipy as sc +from scipy.stats import norm +from scipy.interpolate import interp1d, interp2d, griddata, RegularGridInterpolator, interpn +import multiprocessing as mp +from multiprocessing import Pool, cpu_count, Process +from math import ceil +import math as mt +from scipy import sparse as sp # used to work with sparse matrices +from scipy import linalg #linear algebra +from math import log, cos, pi, sqrt +import time +from SharedFunc3 import Transition, ExTransitions, GenWeight, MakeGridkm, Tauchen, Fastroot +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import scipy.io #scipy input and output +import scipy.fftpack as sf # scipy discrete fourier transforms + +from mpl_toolkits.mplot3d import Axes3D +from matplotlib.ticker import LinearLocator, FormatStrFormatter + +import seaborn as sns + + +# %% {"code_folding": [0]} +## State reduction and discrete cosine transformation + +class StateReduc_Dct: + + def __init__(self, par, mpar, grid, Output, targets, Vm, Vk, + joint_distr, Copula, c_n_guess, c_a_guess, psi_guess, + m_n_star, m_a_star, cap_a_star, mutil_c_n, mutil_c_a,mutil_c, P_H): + + self.par = par # Parameters of the theoretical model + self.mpar = mpar # Parameters of the numerical representation + self.grid = grid # Discrete grid + self.Output = Output # Results of the calculations + self.targets = targets # Like, debt-to-GDP ratio or other desiderata + self.Vm = Vm # Marginal value from liquid cash-on-hand + self.Vk = Vk # Marginal value of capital + self.joint_distr = joint_distr # Multidimensional histogram + self.Copula = Copula # Encodes rank marginal correlation of joint distribution + self.mutil_c = mutil_c # Marginal utility of consumption + self.P_H = P_H # Transition matrix for macro states (not including distribution) + + + def StateReduc(self): + """ + input + ----- + self: dict, stored results from a StE + + output + ------ + Newly generated + =============== + X_ss: ndarray, stacked states, including + Y_ss: ndarray, controls + Gamma_state: ndarray, marginal distributions of individual states + grid: ndarray, discrete grids + targets: ndarray, debt-to-GDP ratio or other desiderata + P_H: transition probability of + indexMUdct: ndarray, indices selected after dct operation on marginal utility of consumption + indexVKdct: ndarray, indices selected after dct operation on marginal value of capital + State: ndarray, dimension equal to reduced states + State_m: ndarray, dimension equal to reduced states + Contr: ndarray, dimension equal to reduced controls + Contr_m: ndarray, dimension equal to reduced controls + + Passed down from the input + ========================== + Copula: dict, grids and values + joint_distr: ndarray, nk x nm x nh + Output: dict, outputs from the model + par: dict, parameters of the theoretical model + mpar:dict, parameters of the numerical representation + aggrshock: string, type of aggregate shock used to purturb the StE + """ + + # Inverse of CRRA on x for utility and marginal utility + invutil = lambda x : ((1-self.par['xi'])*x)**(1./(1-self.par['xi'])) + invmutil = lambda x : (1./x)**(1./self.par['xi']) + + # X=States + # Marg dist of liquid assets summing over pty and illiquid assets k + Xss=np.asmatrix(np.concatenate((np.sum(np.sum(self.joint_distr.copy(),axis=1),axis =1), + np.transpose(np.sum(np.sum(self.joint_distr.copy(),axis=0),axis=1)),# marg dist k + np.sum(np.sum(self.joint_distr.copy(),axis=1),axis=0), # marg dist pty (\approx income) + [np.log(self.par['RB'])],[ 0.]))).T # Given the constant interest rate + + # Y="controls" (according to this literature's odd terminology) + # c = invmarg(marg(c)), so first bit gets consumption policy function + Yss=np.asmatrix(np.concatenate((invmutil(self.mutil_c.copy().flatten(order = 'F')),\ + invmutil(self.Vk.copy().flatten(order = 'F')), + [np.log(self.par['Q'])], # Question: Price of the illiquid asset, right? + [ np.log(self.par['PI'])], # Inflation + [ np.log(self.Output)], + [np.log(self.par['G'])], # Gov spending + [np.log(self.par['W'])], # Wage + [np.log(self.par['R'])], # Nominal R + [np.log(self.par['PROFITS'])], + [np.log(self.par['N'])], # Hours worked + [np.log(self.targets['T'])], # Taxes + [np.log(self.grid['K'])], # Kapital + [np.log(self.targets['B'])]))).T # Government debt + + # Mapping for Histogram + # Gamma_state matrix reduced set of states + # nm = number of gridpoints for liquid assets + # nk = number of gridpoints for illiquid assets + # nh = number of gridpoints for human capital (pty) + Gamma_state = np.zeros( # Create zero matrix of size [nm + nk + nh,nm + nk + nh - 4] + (self.mpar['nm']+self.mpar['nk']+self.mpar['nh'], + self.mpar['nm']+self.mpar['nk']+self.mpar['nh'] - 4)) + # Question: Why 4? 4 = 3+1, 3: sum to 1 for m, k, h and 1: for entrepreneurs + + # Impose adding-up conditions: + # In each of the block matrices, probabilities must add to 1 + + for j in range(self.mpar['nm']-1): # np.squeeze reduces one-dimensional matrix to vector + Gamma_state[0:self.mpar['nm'],j] = -np.squeeze(Xss[0:self.mpar['nm']]) + Gamma_state[j,j]=1. - Xss[j] # + Gamma_state[j,j]=Gamma_state[j,j] - np.sum(Gamma_state[0:self.mpar['nm'],j]) + bb = self.mpar['nm'] # Question: bb='bottom base'? because bb shorter to type than self.mpar['nm'] everywhere + + for j in range(self.mpar['nk']-1): + Gamma_state[bb+np.arange(0,self.mpar['nk'],1), bb+j-1] = -np.squeeze(Xss[bb+np.arange(0,self.mpar['nk'],1)]) + Gamma_state[bb+j,bb-1+j] = 1. - Xss[bb+j] + Gamma_state[bb+j,bb-1+j] = (Gamma_state[bb+j,bb-1+j] - + np.sum(Gamma_state[bb+np.arange(0,self.mpar['nk']),bb-1+j])) + bb = self.mpar['nm'] + self.mpar['nk'] + + for j in range(self.mpar['nh']-2): + # Question: Why -2? 1 for h sum to 1 and 1 for entrepreneur Some other symmetry/adding-up condition. + Gamma_state[bb+np.arange(0,self.mpar['nh']-1,1), bb+j-2] = -np.squeeze(Xss[bb+np.arange(0,self.mpar['nh']-1,1)]) + Gamma_state[bb+j,bb-2+j] = 1. - Xss[bb+j] + Gamma_state[bb+j,bb-2+j] = Gamma_state[bb+j,bb-2+j] - np.sum(Gamma_state[bb+np.arange(0,self.mpar['nh']-1,1),bb-2+j]) + + # Number of other state variables not including the gridded -- here, just the interest rate + self.mpar['os'] = len(Xss) - (self.mpar['nm']+self.mpar['nk']+self.mpar['nh']) + # For each gridpoint there are two "regular" controls: consumption and illiquid saving + # Counts the number of "other" controls (PROFITS, Q, etc) + self.mpar['oc'] = len(Yss) - 2*(self.mpar['nm']*self.mpar['nk']*self.mpar['nh']) + + aggrshock = self.par['aggrshock'] + accuracy = self.par['accuracy'] + + # Do the dct on the steady state marginal utility + # Returns an array of indices for the used basis vectors + indexMUdct = self.do_dct(invmutil(self.mutil_c.copy().flatten(order='F')), + self.mpar,accuracy) + + # Do the dct on the steady state marginal value of capital + # Returns an array of indices for the used basis vectors + indexVKdct = self.do_dct(invmutil(self.Vk.copy()),self.mpar,accuracy) + + # Calculate the numbers of states and controls + aux = np.shape(Gamma_state) + self.mpar['numstates'] = np.int64(aux[1] + self.mpar['os']) + self.mpar['numcontrols'] = np.int64(len(indexMUdct) + + len(indexVKdct) + + self.mpar['oc']) + + # Size of the reduced matrices to be used in the Fsys + # Set to zero because in steady state they are zero + State = np.zeros((self.mpar['numstates'],1)) + State_m = State + Contr = np.zeros((self.mpar['numcontrols'],1)) + Contr_m = Contr + + return {'Xss': Xss, 'Yss':Yss, 'Gamma_state': Gamma_state, + 'par':self.par, 'mpar':self.mpar, 'aggrshock':aggrshock, + 'Copula':self.Copula,'grid':self.grid,'targets':self.targets,'P_H':self.P_H, + 'joint_distr': self.joint_distr, 'Output': self.Output, 'indexMUdct':indexMUdct, 'indexVKdct':indexVKdct, + 'State':State, 'State_m':State_m, 'Contr':Contr, 'Contr_m':Contr_m} + + # Discrete cosine transformation magic happens here + # sf is scipy.fftpack tool + def do_dct(self, obj, mpar, level): + """ + input + ----- + obj: ndarray nm x nk x nh + dimension of states before dct + mpar: dict + parameters in the numerical representaion of the model, e.g. nm, nk and nh + level: float + accuracy level for dct + output + ------ + index_reduced: ndarray n_dct x 1 + an array of indices that select the needed grids after dct + + """ + obj = np.reshape(obj.copy(),(mpar['nm'],mpar['nk'],mpar['nh']),order='F') + X1 = sf.dct(obj,norm='ortho',axis=0) # dct is operated along three dimensions axis=0/1/2 + X2 = sf.dct(X1.copy(),norm='ortho',axis=1) + X3 = sf.dct(X2.copy(),norm='ortho',axis=2) + + # Pick the coefficients that are big + XX = X3.flatten(order='F') + ind = np.argsort(abs(XX.copy()))[::-1] + # i will + i = 1 + # Sort from smallest (=best) to biggest (=worst) + # and count how many are 'good enough to keep' + while linalg.norm(XX[ind[:i]].copy())/linalg.norm(XX) < level: + i += 1 + + needed = i # Question:Isn't this counting the ones that are NOT needed? + + index_reduced = np.sort(ind[:i]) # Retrieve the good + + return index_reduced + +# %% {"code_folding": [0]} +## Choose an aggregate shock to perturb(one of three shocks: MP, TFP, Uncertainty) + +EX3SS['par']['aggrshock'] = 'MP' +EX3SS['par']['rhoS'] = 0.0 # Persistence of variance +EX3SS['par']['sigmaS'] = 0.001 # STD of variance shocks + +#EX3SS['par']['aggrshock'] = 'TFP' +#EX3SS['par']['rhoS'] = 0.95 +#EX3SS['par']['sigmaS'] = 0.0075 + +#EX3SS['par']['aggrshock'] = 'Uncertainty' +#EX3SS['par']['rhoS'] = 0.84 # Persistence of variance +#EX3SS['par']['sigmaS'] = 0.54 # STD of variance shocks + +# %% {"code_folding": [0]} +## Choose an accuracy of approximation with DCT +### Determines number of basis functions chosen -- enough to match this accuracy +### EX3SS is precomputed steady-state pulled in above +EX3SS['par']['accuracy'] = 0.99999 + +## 20190607: CDC to TW: Please try to figure out what this is + +# %% {"code_folding": [0]} +## Implement state reduction and DCT +### Do state reduction on steady state +EX3SR=StateReduc_Dct(**EX3SS) # Takes StE result as input and get ready to invoke state reduction operation +SR=EX3SR.StateReduc() # StateReduc is operated + +# %% {"code_folding": [7, 10, 12]} +print('What are the results from the state reduction?') +#print('Newly added attributes after the operation include \n'+str(set(SR.keys())-set(EX3SS.keys()))) + +print('\n') + +print('To achieve an accuracy of '+str(EX3SS['par']['accuracy'])+'\n') + +print('The dimension of the policy functions is reduced to '+str(SR['indexMUdct'].shape[0]) \ + +' from '+str(EX3SS['mpar']['nm']*EX3SS['mpar']['nk']*EX3SS['mpar']['nh']) + ) +print('The dimension of the marginal value functions is reduced to '+str(SR['indexVKdct'].shape[0]) \ + + ' from ' + str(EX3SS['Vk'].shape)) +print('The total number of control variables is '+str(SR['Contr'].shape[0])+'='+str(SR['indexMUdct'].shape[0]) + \ + '+'+str(SR['indexVKdct'].shape[0])+'+ # of other macro controls') +print('\n') +print('The copula represents the joint distribution with a vector of size '+str(SR['Gamma_state'].shape) ) +print('The dimension of states including exogenous state, is ' +str(SR['Xss'].shape[0])) + +print('It simply stacks all grids of different\ + \n state variables regardless of their joint distributions.\ + \n This is due to the assumption that the rank order remains the same.') +print('The total number of state variables is '+str(SR['State'].shape[0]) + '='+\ + str(SR['Gamma_state'].shape[1])+'+ the number of macro states (like the interest rate)') + + +# %% [markdown] +# ### Graphical Illustration +# +# #### Policy/value functions +# +# Taking the consumption function as an example, we plot consumption by adjusters and non-adjusters over a range of $k$ and $m$ that encompasses x percent of the mass of the distribution function. +# +# We plot the functions for the top and bottom values of the wage $h$ distribution +# + +# %% {"code_folding": [0]} +## Graphical illustration + +### In 2D, we can look at how the number of grid points of +### one state is redcued at given grid values of other states. + +mgrid_fix = 0 ## these are or arbitrary grid points. +kgrid_fix = 0 +hgrid_fix = 2 + + +xi = EX3SS['par']['xi'] + +invmutil = lambda x : (1./x)**(1./xi) + +### convert marginal utilities back to consumption function +mut_StE = EX3SS['mutil_c'] +mut_n_StE = EX3SS['mutil_c_n'] # marginal utility of non-adjusters +mut_a_StE = EX3SS['mutil_c_a'] # marginal utility of adjusters + +c_StE = invmutil(mut_StE) +cn_StE = invmutil(mut_n_StE) +ca_StE = invmutil(mut_a_StE) + + +### grid values +dim_StE = mut_StE.shape +mgrid = EX3SS['grid']['m'] +kgrid = EX3SS['grid']['k'] +hgrid = EX3SS['grid']['h'] + +## indexMUdct is one dimension, needs to be unraveled to 3 dimensions + +mut_rdc_idx = np.unravel_index(SR['indexMUdct'],dim_StE,order='F') + +## these are filtered indices for the fixed grids of other two states + +mgrid_rdc = mut_rdc_idx[0][(mut_rdc_idx[1]==kgrid_fix) & (mut_rdc_idx[2]==hgrid_fix)] +kgrid_rdc = mut_rdc_idx[1][(mut_rdc_idx[0]==mgrid_fix) & (mut_rdc_idx[2]==hgrid_fix)] +hgrid_rdc = mut_rdc_idx[2][(mut_rdc_idx[0]==mgrid_fix) & (mut_rdc_idx[1]==kgrid_fix)] + +# %% {"code_folding": []} +## 3D scatter plots of consumption function +## at all grids and grids after dct for both adjusters and non-adjusters + +## full grids +mmgrid,kkgrid = np.meshgrid(mgrid,kgrid) + + +### for adjusters +fig = plt.figure(figsize=(14,14)) +fig.suptitle('Consumption of non-adjusters at grid points of m and k(for different h)', + fontsize=(13)) +for hgrid_id in range(EX3SS['mpar']['nh']): + ## prepare the reduced grids + hgrid_fix=hgrid_id + fix_bool = mut_rdc_idx[2]==hgrid_fix # for a fixed h grid value + rdc_id = (mut_rdc_idx[0][fix_bool], + mut_rdc_idx[1][fix_bool], + mut_rdc_idx[2][fix_bool]) + mmgrid_rdc = mmgrid[rdc_id[0]].T[0] + kkgrid_rdc = kkgrid[rdc_id[1]].T[0] + mut_n_rdc= mut_n_StE[rdc_id] + c_n_rdc = cn_StE[rdc_id] + c_a_rdc = ca_StE[rdc_id] + mmax = mmgrid_rdc.max() + kmax = kkgrid_rdc.max() + + ## plots + ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d') + ax.scatter(mmgrid,kkgrid,cn_StE[:,:,hgrid_fix],marker='.', + label='StE(before dct): non-adjuster') + ax.scatter(mmgrid_rdc,kkgrid_rdc,c_n_rdc,c='red',marker='o', + label='StE(after dct):non-adjuster') + ax.set_xlabel('m',fontsize=13) + ax.set_ylabel('k',fontsize=13) + ax.set_zlabel(r'$c_a(m,k)$',fontsize=13) + + ax.set_xlim([0,mmax*1.1]) + ax.set_ylim([0,kmax*1.2]) + ax.set_title(r'$h({})$'.format(hgrid_fix)) + ax.view_init(20, 240) +ax.legend(loc=9) + +# %% {"code_folding": [0]} +### for adjusters +fig = plt.figure(figsize=(14,14)) +fig.suptitle('Consumption of adjusters at grid points of m and k(for different h)', + fontsize=(13)) +for hgrid_id in range(EX3SS['mpar']['nh']): + ## prepare the reduced grids + hgrid_fix=hgrid_id + fix_bool = mut_rdc_idx[2]==hgrid_fix # for a fixed h grid value + rdc_id = (mut_rdc_idx[0][fix_bool], + mut_rdc_idx[1][fix_bool], + mut_rdc_idx[2][fix_bool]) + mmgrid_rdc = mmgrid[rdc_id[0]].T[0] + kkgrid_rdc = kkgrid[rdc_id[1]].T[0] + mut_n_rdc= mut_n_StE[rdc_id] + c_n_rdc = cn_StE[rdc_id] + c_a_rdc = ca_StE[rdc_id] + mmax = mmgrid_rdc.max() + kmax = kkgrid_rdc.max() + + ## plots + ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d') + ax.scatter(mmgrid,kkgrid,ca_StE[:,:,hgrid_fix],marker='.', + label='StE(before dct): adjuster') + ax.scatter(mmgrid_rdc,kkgrid_rdc,c_a_rdc,c='red',marker='*', + label='StE(after dct):adjuster') + ax.set_xlabel('m',fontsize=13) + ax.set_ylabel('k',fontsize=13) + ax.set_zlabel(r'$c_n(m,k)$',fontsize=13) + ax.set_xlim([0,mmax*1.1]) + ax.set_ylim([0,kmax*1.2]) + ax.set_title(r'$h({})$'.format(hgrid_fix)) + ax.view_init(20, 240) +ax.legend(loc=9) + +# %% {"code_folding": [0]} +### compare adjusters and non-adjusters after DCT + +fig = plt.figure(figsize=(14,14)) +fig.suptitle('Consumption of adjusters/non-adjusters at grid points of m and k(for different h)', + fontsize=(13)) +for hgrid_id in range(EX3SS['mpar']['nh']): + ## prepare the reduced grids + hgrid_fix=hgrid_id + fix_bool = mut_rdc_idx[2]==hgrid_fix # for a fixed h grid value + rdc_id = (mut_rdc_idx[0][fix_bool], + mut_rdc_idx[1][fix_bool], + mut_rdc_idx[2][fix_bool]) + mmgrid_rdc = mmgrid[rdc_id[0]].T[0] + kkgrid_rdc = kkgrid[rdc_id[1]].T[0] + mut_n_rdc= mut_n_StE[rdc_id] + c_n_rdc = cn_StE[rdc_id] + c_a_rdc = ca_StE[rdc_id] + + ## plots + ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d') + #ax.scatter(mmgrid,kkgrid,cn_StE[:,:,hgrid_fix],marker='.', + # label='StE(before dct): non-adjuster') + #ax.scatter(mmgrid,kkgrid,ca_StE[:,:,hgrid_fix],c='yellow',marker='.', + # label='StE(before dct): adjuster') + ax.scatter(mmgrid_rdc,kkgrid_rdc,c_n_rdc,c='red',marker='o', + label='StE(after dct):non-adjuster') + ax.scatter(mmgrid_rdc,kkgrid_rdc,c_a_rdc,c='blue',marker='*', + label='StE(after dct):adjuster') + ax.set_xlabel('m',fontsize=13) + ax.set_ylabel('k',fontsize=13) + ax.set_zlabel(r'$c_a(m,k)$',fontsize=13) + ax.set_title(r'$h({})$'.format(hgrid_fix)) + ax.set_xlim(0,400) + ax.view_init(20, 240) +ax.legend(loc=9) + +# %% [markdown] +# ##### Observation +# +# - For a given grid value of productivity, the remaining grid points after DCT to represent the whole consumption function are concentrated in low values of $k$ and $m$. This is because the slopes of the surfaces of marginal utility are changing the most in these regions. For larger values of $k$ and $m$ the functions become smooth and only slightly concave, so they can be represented by many fewer points +# - For different grid values of productivity (2 sub plots), the numbers of grid points in the DCT operation differ. From the lowest to highest values of productivity, there are 78, 33, 25 and 18 grid points, respectively. They add up to the total number of gridpoints of 154 after DCT operation, as we noted above for marginal utility function. + +# %% [markdown] +# #### Distribution of states +# +# - We first plot the distribution of $k$ fixing $m$ and $h$. Next, we plot the joint distribution of $m$ and $k$ only fixing $h$ in 3-dimenstional space. +# - The joint-distribution can be represented by marginal distributions of $m$, $k$ and $h$ and a copula that describes the correlation between the three states. The former is straightfoward. We plot the copula only. Copula is essentially a multivariate cummulative distribution function where each marginal is uniform. +# + +# %% {"code_folding": [0]} +### Marginalize along h grids + +joint_distr = EX3SS['joint_distr'] +joint_distr_km = EX3SS['joint_distr'].sum(axis=2) + +### Plot distributions in 2 dimensional graph + +fig = plt.figure(figsize=(10,10)) +plt.suptitle('Marginal distribution of k at different m') + +for hgrid_id in range(EX3SS['mpar']['nh']): + ax = plt.subplot(2,2,hgrid_id+1) + ax.set_title(r'$h({})$'.format(hgrid_fix)) + ax.set_xlabel('k',size=12) + for id in range(EX3SS['mpar']['nm']): + ax.plot(kgrid,joint_distr[id,:,hgrid_id]) + +# %% {"code_folding": [0]} +## Plot joint distribution of k and m in 3d graph + +fig = plt.figure(figsize=(14,14)) +fig.suptitle('Joint distribution of m and k(for different h)', + fontsize=(13)) +for hgrid_id in range(EX3SS['mpar']['nh']): + ## plots + ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d') + ax.plot_surface(mmgrid,kkgrid,joint_distr[:,:,hgrid_fix], rstride=1, cstride=1, + cmap='viridis', edgecolor='none') + ax.set_xlabel('m',fontsize=13) + ax.set_ylabel('k',fontsize=13) + #ax.set_zlabel(r'$p(m,k)$',fontsize=10) + ax.set_title(r'$h({})$'.format(hgrid_fix)) + ax.set_xlim(0,400) + ax.view_init(20, 40) + +# %% +copula_value = EX3SS['Copula']['value'] +fig=plt.plot(copula_value) +plt.title("Commulative probability distribution function in StE") + +# %% [markdown] +# Notice the cdfs in StE copula have 4 modes, corresponding to the number of $h$ grids. Each of the four parts of the cdf is a joint-distribution of $m$ and $k$. It can be presented in 3-dimensional graph as below. + +# %% {"code_folding": []} +## plot copula + +cdf=EX3SS['Copula']['value'].reshape(4,30,30) # important: 4,30,30 not 30,30,4? + +fig = plt.figure(figsize=(14,14)) +fig.suptitle('Copula of m and k(for different h)', + fontsize=(13)) +for hgrid_id in range(EX3SS['mpar']['nh']): + ## plots + ax = fig.add_subplot(2,2,hgrid_id+1, projection='3d') + ax.plot_surface(mmgrid,kkgrid,cdf[hgrid_fix,:,:], rstride=1, cstride=1, + cmap='viridis', edgecolor='None') + ax.set_xlabel('m',fontsize=13) + ax.set_ylabel('k',fontsize=13) + ax.set_title(r'$h({})$'.format(hgrid_fix)) + ax.set_xlim(0,400) + ax.view_init(30, 45) + +# %% [markdown] +# Given the assumption that the copula remains the same after aggregate risk is introduced, we can use the same copula and the marginal distributions to recover the full joint-distribution of the states. + +# %% [markdown] +# ### Summary: what do we achieve after the transformation? +# +# - Using the DCT, the dimension of policy function and value functions are reduced both from 3600 to 154 and 94, respectively. +# - By marginalizing the joint distribution with the fixed copula assumption, the marginal distribution is of dimension 64 compared to its joint distribution of a dimension of 3600. +# +# +# diff --git a/HARK/BayerLuetticke/TwoAsset.py b/HARK/BayerLuetticke/TwoAsset.py index 2d8b7cf41..3c7dd10cc 100644 --- a/HARK/BayerLuetticke/TwoAsset.py +++ b/HARK/BayerLuetticke/TwoAsset.py @@ -1,133 +1,16 @@ # --- # jupyter: -# cite2c: -# citations: -# 6202365/L5GBWHBM: -# author: -# - family: Reiter -# given: Michael -# container-title: Journal of Economic Dynamics and Control -# id: undefined -# issue: '1' -# issued: -# month: 1 -# year: 2010 -# note: 'Citation Key: reiterBackward' -# page: 28-35 -# page-first: '28' -# title: Solving the Incomplete Markets Model with Aggregate Uncertainty by -# Backward Induction -# type: article-journal -# volume: '34' -# 6202365/UKUXJHCN: -# author: -# - family: Reiter -# given: Michael -# id: 6202365/UKUXJHCN -# note: "Citation Key: reiter2002recursive \nbibtex*[publisher=Citeseer]" -# title: Recursive computation of heterogeneous agent models -# type: article-journal -# 6202365/VPUXICUR: -# author: -# - family: Krusell -# given: Per -# - family: Smith -# given: Anthony A. -# container-title: Journal of Political Economy -# id: 6202365/VPUXICUR -# issue: '5' -# issued: -# year: 1998 -# page: "867\u2013896" -# page-first: '867' -# title: Income and Wealth Heterogeneity in the Macroeconomy -# type: article-journal -# volume: '106' -# 6202365/WN76AW6Q: -# author: -# - family: SeHyoun Ahn, Greg Kaplan, Benjamin Moll, Thomas Winberry -# given: '' -# - family: Wolf -# given: Christian -# editor: -# - family: Parker -# given: Jonathan -# - family: Martin S. Eichenbaum -# given: Organizers -# id: 6202365/WN76AW6Q -# issued: -# year: 2017 -# note: "Citation Key: akmwwInequality \nbibtex*[booktitle=NBER Macroeconomics\ -# \ Annual;publisher=MIT Press;location=Cambridge, MA]" -# title: When Inequality Matters for Macro and Macro Matters for Inequality -# type: article-journal -# volume: '32' -# undefined: -# author: -# - family: Reiter -# given: Michael -# container-title: Journal of Economic Dynamics and Control -# id: undefined -# issue: '1' -# issued: -# month: 1 -# year: 2010 -# note: 'Citation Key: reiterBackward' -# page: 28-35 -# page-first: '28' -# title: Solving the Incomplete Markets Model with Aggregate Uncertainty by -# Backward Induction -# type: article-journal -# volume: '34' # jupytext: # formats: ipynb,py:light # text_representation: # extension: .py # format_name: light -# format_version: '1.3' -# jupytext_version: 0.8.3 +# format_version: '1.4' +# jupytext_version: 1.1.3 # 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.7 -# varInspector: -# cols: -# lenName: 16 -# lenType: 16 -# lenVar: 40 -# kernels_config: -# python: -# delete_cmd_postfix: '' -# delete_cmd_prefix: 'del ' -# library: var_list.py -# varRefreshCmd: print(var_dic_list()) -# r: -# delete_cmd_postfix: ') ' -# delete_cmd_prefix: rm( -# library: var_list.r -# varRefreshCmd: 'cat(var_dic_list()) ' -# types_to_exclude: -# - module -# - function -# - builtin_function_or_method -# - instance -# - _Feature -# window_display: false -# widgets: -# application/vnd.jupyter.widget-state+json: -# state: {} -# version_major: 2 -# version_minor: 0 # --- # # [Bayer and Luetticke (2018)](https://cepr.org/active/publications/discussion_papers/dp.php?dpno=13071) @@ -145,12 +28,14 @@ # The Bayer-Luetticke method has the following broad features: # * The model is formulated and solved in discrete time (in contrast with some other recent approaches ) # * Solution begins by calculation of the steady-state equilibrium (StE) with no aggregate shocks -# * Dimensionality reduction is performed immediately after calculation of the StE -# * This involves finding a representation of the individual policy function using a particular class of basis functions -# * The method captures the business-cycle-induced _deviations_ of the individual policy functions from those that characterize the riskless StE -# * This is done using the same basis functions originally optimized to match the StE individual policy function (akin to image compression) -# * The method of capturing dynamic deviations from a reference frame is akin to video compression -# * Similar methods are used for capturing dynamics of distributions +# * "Dimensionality reduction" of the consumer's decision problem is performed before any further analysis is done +# * "Dimensionality reduction" is just a particularly efficient method of approximating a function +# * It involves finding a representation of the function using some class of basis functions +# * Dimensionality reduction of the joint distribution is accomplished using a "copula" +# * See the companion notebook for description of the copula +# * The method approximates the business-cycle-induced _deviations_ of the individual policy functions from those that characterize the riskless StE +# * This is done using the same basis functions originally optimized to match the StE individual policy function +# * The method of capturing dynamic deviations from a reference frame is akin to video compression # ### Setup # @@ -199,7 +84,7 @@ # \bar{v} = \bar{u} + \beta \Pi_{\bar{h}}\bar{v} # \end{equation} # holds for the optimal policy -# * A linear interpolant is used for the value function +# * A linear interpolator is used to represent the value function # * For the distribution, which (by the definition of steady state) is constant: # # \begin{eqnarray} @@ -219,8 +104,10 @@ # # This can be solved by (jointly): # 1. Finding $d\bar{\mu}$ as the unit-eigenvalue of $\Pi_{\bar{h}}$ -# 2. Using fast solution techniques for the decision problem, e.g. EGM +# 2. Using standard solution techniques for the micro decision problem given $P$ +# * Like wage and interest rate # 3. Using a root-finder to solve for $P$ +# * This basically iterates the other two steps until it finds values where they are consistent # #### Introducing aggregate risk # @@ -238,7 +125,7 @@ # v_t = \bar{u}_{P_t} + \beta \Pi_{h_t} v_{t+1} # \end{equation} # holds for policy $h_t$ which optimizes with respect to $v_{t+1}$ and $P_t$ -# * and a sequence of histograms, such that +# * and a sequence of "histograms" (discretized distributions), such that # \begin{equation} # d\mu_{t+1} = d\mu_t \Pi_{h_t} # \end{equation} @@ -283,14 +170,16 @@ def in_ipynb(): sys.path.insert(0, code_dir) sys.path.insert(0, my_file_path) -# + {"code_folding": [0]} -## Change working folder and load Stationary equilibrium (StE) +# + {"code_folding": []} +## Load Stationary equilibrium (StE) object EX3SS_20 import pickle os.chdir(code_dir) # Go to the directory with pickled code ## EX3SS_20.p is the information in the stationary equilibrium (20: the number of illiquid and liquid weath grids ) EX3SS=pickle.load(open("EX3SS_20.p", "rb")) + + # - # #### Compact notation (Schmitt-Grohe and Uribe, 2004) @@ -322,10 +211,10 @@ def in_ipynb(): # * Standard techniques can solve the discretized version # #### So, is all solved? -# The dimensionality of the system F is still an issue +# The dimensionality of the system F is a big problem # * With high dimensional idiosyncratic states, discretized value functions and distributions become large objects # * For example: -# * 4 income states $\times$ 100 illiquid capital states $\times$ 100 liquid capital states $\rightarrow$ $\geq$ 40,000 variables in $F$ +# * 4 income states $\times$ 100 illiquid capital states $\times$ 100 liquid capital states $\rightarrow$ $\geq$ 40,000 values in $F$ # * Same number of state variables # ### Bayer-Luetticke method @@ -335,7 +224,9 @@ def in_ipynb(): # * Use Chebychev polynomials on roots grid # * Define a reference "frame": the steady-state equilibrium (StE) # * Represent fluctuations as differences from this reference frame -# * Assume all coefficients of the DCT from the StE that are close to zero do not change when there is an aggregate shock (small things stay small and unchanged) +# * Assume all coefficients of the DCT from the StE that are close to zero do not change when there is an aggregate shock (small things stay small) +# * When would this be problematic? +# * In video, # # 2. Assume no changes in the rank correlation structure of $\mu$ # * Calculate the Copula, $\bar{C}$ of $\mu$ in the StE @@ -345,7 +236,7 @@ def in_ipynb(): # # The approach follows the insight of KS in that it uses the fact that some moments of the distribution do not matter for aggregate dynamics -# + {"code_folding": [0]} +# + {"code_folding": []} ## Import necessary libraries from __future__ import print_function @@ -386,7 +277,7 @@ def in_ipynb(): # \end{array}\right. # \end{equation} -# + {"code_folding": []} +# + {"code_folding": [0]} ## State reduction and Discrete cosine transformation class StateReduc_Dct: @@ -531,32 +422,31 @@ def do_dct(self, obj, mpar, level): # - # 2) Decoding -# * Now we reconstruct $\tilde{v}_t=\tilde{v}(\theta_t)=dct^{-1}(\tilde{\Theta}(\theta_i))$ -# * idct is the inverse dct that goes from the $\theta$ vector to the corresponding values +# * Now we reconstruct $\tilde{v}_t=\tilde{v}(\theta_t)=dct^{-1}(\tilde{\Theta}(\theta_{t}))$ +# * idct=$dct^{-1}$ is the inverse dct that goes from the $\theta$ vector to the corresponding values # * This means that in the StE the reduction step adds no addtional approximation error: # * Remember that $\tilde{v}(0)=\bar{v}$ by construction -# * Yet, it allows to reduce the number of derivatives that need to be calculated from the outset. +# * But it allows us to reduce the number of derivatives that need to be calculated from the outset. +# * We only calculate derivatives for those basis functions that make an important contribution to the representation of the policy or value functions # # 3) The histogram is recovered the same way # * $\mu_t$ is approximated as $\bar{C}(\bar{\mu_t}^1,...,\bar{\mu_t}^n)$, where $n$ is the dimensionality of the idiosyncratic states # * The StE distribution is obtained when $\mu = \bar{C}(\bar{\mu}^1,...,\bar{\mu}^n)$ # * Typically prices are only influenced through the marginal distributions -# * The approach ensures that changes in the mass of one, say wealth, state are distributed in a sensible way across the other dimension +# * The approach ensures that changes in the mass of one state (say, wealth) are distributed in a sensible way across the other dimensions # * The implied distributions look "similar" to the StE one (different in (Reiter, 2009)) # -# 4) Too many equations -# * The system +# 4) The large system above is now transformed into a much smaller system: # \begin{align} # F(\{d\mu_t^1,...,d\mu_t^n\}, S_t, \{d\mu_{t+1}^1,...,d\mu_{t+1}^n\}, S_{t+1}, \theta_t, P_t, \theta_{t+1}, P_{t+1}) # &= \begin{bmatrix} # d\bar{C}(\bar{\mu}_t^1,...,\bar{\mu}_t^n) - d\bar{C}(\bar{\mu}_t^1,...,\bar{\mu}_t^n)\Pi_{h_t} \\ -# dct[idct(\tilde{\Theta(\theta_t)}) - (\bar{u}_{h_t} + \beta \Pi_{h_t}idct(\tilde{\Theta(\theta_{t+1})}] \\ +# dct\left[idct(\tilde{\Theta}(\theta_t) - (\bar{u}_{h_t} + \beta \Pi_{h_t}idct(\tilde{\Theta}(\theta_{t+1})))\right] \\ # S_{t+1} - H(S_t,d\mu_t) \\ # \Phi(h_t,d\mu_t,P_t,S_t) \\ # \end{bmatrix} # \end{align} -# has too many equations -# * Uses only difference in marginals and the differences on $\mathop{I}$ +# # ### The two-asset HANK model # @@ -608,7 +498,7 @@ def do_dct(self, obj, mpar, level): # # - Individual state variables: $b$, $k$ and $h$, the joint distribution of individual states $\Theta$ # - Individual control variables: $c$, $n$, $b'$, $k'$ -# - Optimal policy for adjust and non-adjust cases are $c^*_a$, $n^*_a$ $k^*_a$ and $b^*_a$ and $c^*_n$, $n^*_n$ and $b^*_n$, respetively +# - Optimal policy for adjusters and nonadjusters are $c^*_a$, $n^*_a$ $k^*_a$ and $b^*_a$ and $c^*_n$, $n^*_n$ and $b^*_n$, respectively # # + {"code_folding": []} @@ -674,7 +564,7 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro # invmutil = lambda x : (1./x)**(1./par['xi']) invmutil = lambda x : np.power(1./x,1./par['xi']) - # Generate meshes for m,k,h # Question: m not b? + # Generate meshes for m,k,h # number of states, controls in reduced system nx = mpar['numstates'] # number of states @@ -710,7 +600,7 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro marginal_mind = range(mpar['nm']-1) marginal_kind = range(mpar['nm']-1,mpar['nm']+mpar['nk']-2) # probs add to 1 marginal_hind = range(mpar['nm']+mpar['nk']-2, - mpar['nm']+mpar['nk']+mpar['nh']-4) # Question: Why 4? + mpar['nm']+mpar['nk']+mpar['nh']-4) # Question: Why 4? Awesome guy not perturbed # index for the interest rate on government bonds = liquid assets RBind = NxNx @@ -781,6 +671,7 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro B = np.exp(Control[Bind]) # Aggregate Controls (t) # Question: Why are there more here than for t+1? + # Only include t+1's that show up in eqbm conditions (Envelope thm) PIminus = np.exp(Controlminus[PIind]) Qminus = np.exp(Controlminus[Qind]) Yminus = np.exp(Controlminus[Yind]) @@ -812,7 +703,7 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro ## States ## Marginal Distributions (Marginal histograms) - #LHS[distr_ind] = Distribution[:mpar['nm']*mpar['nh']-1-mpar['nh']].copy() Question: Why commented out + LHS[marginal_mind] = Distribution[:mpar['nm']-1] LHS[marginal_kind] = Distribution[mpar['nm']:mpar['nm'] +mpar['nk']-1] @@ -963,12 +854,15 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro c_n_star = result_EGM_policyupdate['c_n_star'] m_n_star = result_EGM_policyupdate['m_n_star'] - # Question: Is this max value of ind pty? Why needed? + # Question: Is this max value of ind pty? Why needed? Victor "Awesome" state meshaux = meshes.copy() meshaux['h'][:,:,-1] = 1000. ## Update Marginal Value of Bonds # Question: Marginal utility is weighted average of u' from c and u' from leisure? + # GHH preferences (can write optimization problem for the composite good) + # Just to make everybody have the same labor supply (it's about eqbm prices) + # easier to do the steady state mutil_c_n = mutil(c_n_star.copy()) mutil_c_a = mutil(c_a_star.copy()) mutil_c_aux = par['nu']*mutil_c_a + (1-par['nu'])*mutil_c_n @@ -1034,7 +928,7 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro ## Liquid assets of the k-adjusters ra_genweight = GenWeight(m_a_star,grid['m']) Dist_m_a = ra_genweight['weight'].copy() - idm_a = ra_genweight['index'].copy() # Question: idm_a is index of original exogenous m grid + idm_a = ra_genweight['index'].copy() # idm_a is index of original exogenous m grid ## Liquid assets of the k-nonadjusters rn_genweight = GenWeight(m_n_star,grid['m']) @@ -1202,7 +1096,7 @@ def Fsys(State, Stateminus, Control_sparse, Controlminus_sparse, StateSS, Contro 'k_a_star':k_a_star,'c_n_star':c_n_star,'m_n_star':m_n_star,'P':P} -# + {"code_folding": [0]} +# + {"code_folding": []} ## Update policy in transition (found in Fsys) def EGM_policyupdate(EVm,EVk, Qminus, PIminus, RBminus, inc, meshes,grid,par,mpar): diff --git a/HARK/ConsumptionSaving/ConsAggShockModel.py b/HARK/ConsumptionSaving/ConsAggShockModel.py index 026304dff..9f54707fd 100644 --- a/HARK/ConsumptionSaving/ConsAggShockModel.py +++ b/HARK/ConsumptionSaving/ConsAggShockModel.py @@ -16,26 +16,27 @@ CRRAutility_invP, CRRAutility_inv, combineIndepDstns,\ approxMeanOneLognormal from HARK.simulation import drawDiscrete, drawUniform -from .ConsIndShockModel import ConsumerSolution, IndShockConsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import ConsumerSolution, IndShockConsumerType from HARK import HARKobject, Market, AgentType from copy import deepcopy import matplotlib.pyplot as plt -utility = CRRAutility -utilityP = CRRAutilityP -utilityPP = CRRAutilityPP +utility = CRRAutility +utilityP = CRRAutilityP +utilityPP = CRRAutilityPP utilityP_inv = CRRAutilityP_inv utility_invP = CRRAutility_invP -utility_inv = CRRAutility_inv +utility_inv = CRRAutility_inv + class MargValueFunc2D(HARKobject): ''' A class for representing a marginal value function in models where the standard envelope condition of dvdm(m,M) = u'(c(m,M)) holds (with CRRA utility). ''' - distance_criteria = ['cFunc','CRRA'] + distance_criteria = ['cFunc', 'CRRA'] - def __init__(self,cFunc,CRRA): + def __init__(self, cFunc, CRRA): ''' Constructor for a new marginal value function object. @@ -57,11 +58,12 @@ def __init__(self,cFunc,CRRA): self.cFunc = deepcopy(cFunc) self.CRRA = CRRA - def __call__(self,m,M): - return utilityP(self.cFunc(m,M),gam=self.CRRA) + def __call__(self, m, M): + return utilityP(self.cFunc(m, M), gam=self.CRRA) ############################################################################### + class AggShockConsumerType(IndShockConsumerType): ''' A class to represent consumers who face idiosyncratic (transitory and per- @@ -72,18 +74,18 @@ class AggShockConsumerType(IndShockConsumerType): evolves over time and take aggregate shocks into account when making their decision about how much to consume. ''' - def __init__(self,time_flow=True,**kwds): + def __init__(self, time_flow=True, **kwds): ''' Make a new instance of AggShockConsumerType, an extension of IndShockConsumerType. Sets appropriate solver and input lists. ''' - AgentType.__init__(self,solution_terminal=deepcopy(IndShockConsumerType.solution_terminal_), - time_flow=time_flow,pseudo_terminal=False,**kwds) + AgentType.__init__(self, solution_terminal=deepcopy(IndShockConsumerType.solution_terminal_), + time_flow=time_flow, pseudo_terminal=False, **kwds) # Add consumer-type specific objects, copying to create independent versions self.time_vary = deepcopy(IndShockConsumerType.time_vary_) self.time_inv = deepcopy(IndShockConsumerType.time_inv_) - self.delFromTimeInv('Rfree','vFuncBool','CubicBool') + self.delFromTimeInv('Rfree', 'vFuncBool', 'CubicBool') self.poststate_vars = IndShockConsumerType.poststate_vars_ self.solveOnePeriod = solveConsAggShock self.update() @@ -101,8 +103,11 @@ def reset(self): None ''' self.initializeSim() - self.aLvlNow = self.kInit*np.ones(self.AgentCount) # Start simulation near SS + self.aLvlNow = self.kInit*np.ones(self.AgentCount) # Start simulation near SS self.aNrmNow = self.aLvlNow/self.pLvlNow + + def preSolve(self): + self.updateSolutionTerminal() def updateSolutionTerminal(self): ''' @@ -117,12 +122,14 @@ def updateSolutionTerminal(self): ------- None ''' - cFunc_terminal = BilinearInterp(np.array([[0.0,0.0],[1.0,1.0]]),np.array([0.0,1.0]),np.array([0.0,1.0])) - vPfunc_terminal = MargValueFunc2D(cFunc_terminal,self.CRRA) + cFunc_terminal = BilinearInterp(np.array([[0.0, 0.0], [1.0, 1.0]]), np.array([0.0, 1.0]), np.array([0.0, 1.0])) + vPfunc_terminal = MargValueFunc2D(cFunc_terminal, self.CRRA) mNrmMin_terminal = ConstantFunction(0) - self.solution_terminal = ConsumerSolution(cFunc=cFunc_terminal,vPfunc=vPfunc_terminal,mNrmMin=mNrmMin_terminal) + self.solution_terminal = ConsumerSolution(cFunc=cFunc_terminal, + vPfunc=vPfunc_terminal, + mNrmMin=mNrmMin_terminal) - def getEconomyData(self,Economy): + def getEconomyData(self, Economy): ''' Imports economy-determined objects into self from a Market. Instances of AggShockConsumerType "live" in some macroeconomy that has @@ -142,20 +149,19 @@ def getEconomyData(self,Economy): ------- None ''' - self.T_sim = Economy.act_T # Need to be able to track as many periods as economy runs - self.kInit = Economy.kSS # Initialize simulation assets to steady state - self.aNrmInitMean = np.log(0.00000001) # Initialize newborn assets to nearly zero - self.Mgrid = Economy.MSS*self.MgridBase # Aggregate market resources grid adjusted around SS capital ratio - self.AFunc = Economy.AFunc # Next period's aggregate savings function - self.Rfunc = Economy.Rfunc # Interest factor as function of capital ratio - self.wFunc = Economy.wFunc # Wage rate as function of capital ratio - self.DeprFac = Economy.DeprFac # Rate of capital depreciation - self.PermGroFacAgg = Economy.PermGroFacAgg # Aggregate permanent productivity growth - self.addAggShkDstn(Economy.AggShkDstn) # Combine idiosyncratic and aggregate shocks into one dstn - self.addToTimeInv('Mgrid','AFunc','Rfunc', 'wFunc','DeprFac','PermGroFacAgg') - + self.T_sim = Economy.act_T # Need to be able to track as many periods as economy runs + self.kInit = Economy.kSS # Initialize simulation assets to steady state + self.aNrmInitMean = np.log(0.00000001) # Initialize newborn assets to nearly zero + self.Mgrid = Economy.MSS*self.MgridBase # Aggregate market resources grid adjusted around SS capital ratio + self.AFunc = Economy.AFunc # Next period's aggregate savings function + self.Rfunc = Economy.Rfunc # Interest factor as function of capital ratio + self.wFunc = Economy.wFunc # Wage rate as function of capital ratio + self.DeprFac = Economy.DeprFac # Rate of capital depreciation + self.PermGroFacAgg = Economy.PermGroFacAgg # Aggregate permanent productivity growth + self.addAggShkDstn(Economy.AggShkDstn) # Combine idiosyncratic and aggregate shocks into one dstn + self.addToTimeInv('Mgrid', 'AFunc', 'Rfunc', 'wFunc', 'DeprFac', 'PermGroFacAgg') - def addAggShkDstn(self,AggShkDstn): + def addAggShkDstn(self, AggShkDstn): ''' Updates attribute IncomeDstn by combining idiosyncratic shocks with aggregate shocks. @@ -174,10 +180,9 @@ def addAggShkDstn(self,AggShkDstn): self.IncomeDstn = self.IncomeDstnWithoutAggShocks else: self.IncomeDstnWithoutAggShocks = self.IncomeDstn - self.IncomeDstn = [combineIndepDstns(self.IncomeDstn[t],AggShkDstn) for t in range(self.T_cycle)] + self.IncomeDstn = [combineIndepDstns(self.IncomeDstn[t], AggShkDstn) for t in range(self.T_cycle)] - - def simBirth(self,which_agents): + def simBirth(self, which_agents): ''' Makes new consumers for the given indices. Initialized variables include aNrm and pLvl, as well as time variables t_age and t_cycle. Normalized assets and permanent income levels @@ -192,8 +197,8 @@ def simBirth(self,which_agents): ------- None ''' - IndShockConsumerType.simBirth(self,which_agents) - if hasattr(self,'aLvlNow'): + IndShockConsumerType.simBirth(self, which_agents) + if hasattr(self, 'aLvlNow'): self.aLvlNow[which_agents] = self.aNrmNow[which_agents]*self.pLvlNow[which_agents] else: self.aLvlNow = self.aNrmNow*self.pLvlNow @@ -223,7 +228,7 @@ def simDeath(self): # Just select a random set of agents to die how_many_die = int(round(self.AgentCount*(1.0-self.LivPrb[0]))) - base_bool = np.zeros(self.AgentCount,dtype=bool) + base_bool = np.zeros(self.AgentCount, dtype=bool) base_bool[0:how_many_die] = True who_dies = self.RNG.permutation(base_bool) if self.T_age is not None: @@ -267,7 +272,7 @@ def getShocks(self): ------- None ''' - IndShockConsumerType.getShocks(self) # Update idiosyncratic shocks + IndShockConsumerType.getShocks(self) # Update idiosyncratic shocks self.TranShkNow = self.TranShkNow*self.TranShkAggNow*self.wRteNow self.PermShkNow = self.PermShkNow*self.PermShkAggNow @@ -288,13 +293,14 @@ def getControls(self): MaggNow = self.getMaggNow() for t in range(self.T_cycle): these = t == self.t_cycle - cNrmNow[these] = self.solution[t].cFunc(self.mNrmNow[these],MaggNow[these]) - MPCnow[these] = self.solution[t].cFunc.derivativeX(self.mNrmNow[these],MaggNow[these]) # Marginal propensity to consume + cNrmNow[these] = self.solution[t].cFunc(self.mNrmNow[these], MaggNow[these]) + MPCnow[these] = self.solution[t].cFunc.derivativeX(self.mNrmNow[these], + MaggNow[these]) # Marginal propensity to consume self.cNrmNow = cNrmNow self.MPCnow = MPCnow return None - def getMaggNow(self): # This function exists to be overwritten in StickyE model + def getMaggNow(self): # This function exists to be overwritten in StickyE model return self.MaggNow*np.ones(self.AgentCount) def marketAction(self): @@ -333,7 +339,7 @@ def calcBoundingValues(self): ''' raise NotImplementedError() - def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): + def makeEulerErrorFunc(self, mMax=100, approx_inc_dstn=True): ''' Creates a "normalized Euler error" function for this instance, mapping from market resources to "consumption error per dollar of consumption." @@ -360,8 +366,6 @@ def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): raise NotImplementedError() - - class AggShockMarkovConsumerType(AggShockConsumerType): ''' A class for representing ex ante heterogeneous "types" of consumers who @@ -369,13 +373,12 @@ class AggShockMarkovConsumerType(AggShockConsumerType): permanent and transitory), who lives in an environment where the macroeconomic state is subject to Markov-style discrete state evolution. ''' - def __init__(self,**kwds): - AggShockConsumerType.__init__(self,**kwds) + def __init__(self, **kwds): + AggShockConsumerType.__init__(self, **kwds) self.addToTimeInv('MrkvArray') self.solveOnePeriod = solveConsAggMarkov - - def addAggShkDstn(self,AggShkDstn): + def addAggShkDstn(self, AggShkDstn): ''' Variation on AggShockConsumerType.addAggShkDstn that handles the Markov state. AggShkDstn is a list of aggregate productivity shock distributions @@ -389,10 +392,9 @@ def addAggShkDstn(self,AggShkDstn): IncomeDstnOut = [] N = self.MrkvArray.shape[0] for t in range(self.T_cycle): - IncomeDstnOut.append([combineIndepDstns(self.IncomeDstn[t][n],AggShkDstn[n]) for n in range(N)]) + IncomeDstnOut.append([combineIndepDstns(self.IncomeDstn[t][n], AggShkDstn[n]) for n in range(N)]) self.IncomeDstn = IncomeDstnOut - def updateSolutionTerminal(self): ''' Update the terminal period solution. This method should be run when a @@ -410,8 +412,8 @@ def updateSolutionTerminal(self): # Make replicated terminal period solution StateCount = self.MrkvArray.shape[0] - self.solution_terminal.cFunc = StateCount*[self.solution_terminal.cFunc] - self.solution_terminal.vPfunc = StateCount*[self.solution_terminal.vPfunc] + self.solution_terminal.cFunc = StateCount*[self.solution_terminal.cFunc] + self.solution_terminal.vPfunc = StateCount*[self.solution_terminal.vPfunc] self.solution_terminal.mNrmMin = StateCount*[self.solution_terminal.mNrmMin] def getShocks(self): @@ -430,19 +432,21 @@ def getShocks(self): ------- None ''' - PermShkNow = np.zeros(self.AgentCount) # Initialize shock arrays + PermShkNow = np.zeros(self.AgentCount) # Initialize shock arrays TranShkNow = np.zeros(self.AgentCount) newborn = self.t_age == 0 for t in range(self.T_cycle): these = t == self.t_cycle N = np.sum(these) if N > 0: - IncomeDstnNow = self.IncomeDstn[t-1][self.MrkvNow] # set current income distribution - PermGroFacNow = self.PermGroFac[t-1] # and permanent growth factor - Indices = np.arange(IncomeDstnNow[0].size) # just a list of integers + IncomeDstnNow = self.IncomeDstn[t-1][self.MrkvNow] # set current income distribution + PermGroFacNow = self.PermGroFac[t-1] # and permanent growth factor + Indices = np.arange(IncomeDstnNow[0].size) # just a list of integers # Get random draws of income shocks from the discrete distribution - EventDraws = drawDiscrete(N,X=Indices,P=IncomeDstnNow[0],exact_match=True,seed=self.RNG.randint(0,2**31-1)) - PermShkNow[these] = IncomeDstnNow[1][EventDraws]*PermGroFacNow # permanent "shock" includes expected growth + EventDraws = drawDiscrete(N, X=Indices, P=IncomeDstnNow[0], + exact_match=True, seed=self.RNG.randint(0, 2**31-1)) + # permanent "shock" includes expected growth + PermShkNow[these] = IncomeDstnNow[1][EventDraws]*PermGroFacNow TranShkNow[these] = IncomeDstnNow[2][EventDraws] # That procedure used the *last* period in the sequence for newborns, but that's not right @@ -450,23 +454,24 @@ def getShocks(self): N = np.sum(newborn) if N > 0: these = newborn - IncomeDstnNow = self.IncomeDstn[0][self.MrkvNow] # set current income distribution - PermGroFacNow = self.PermGroFac[0] # and permanent growth factor - Indices = np.arange(IncomeDstnNow[0].size) # just a list of integers + IncomeDstnNow = self.IncomeDstn[0][self.MrkvNow] # set current income distribution + PermGroFacNow = self.PermGroFac[0] # and permanent growth factor + Indices = np.arange(IncomeDstnNow[0].size) # just a list of integers # Get random draws of income shocks from the discrete distribution - EventDraws = drawDiscrete(N,X=Indices,P=IncomeDstnNow[0],exact_match=False,seed=self.RNG.randint(0,2**31-1)) - PermShkNow[these] = IncomeDstnNow[1][EventDraws]*PermGroFacNow # permanent "shock" includes expected growth + EventDraws = drawDiscrete(N, X=Indices, P=IncomeDstnNow[0], + exact_match=False, seed=self.RNG.randint(0, 2**31-1)) + # permanent "shock" includes expected growth + PermShkNow[these] = IncomeDstnNow[1][EventDraws]*PermGroFacNow TranShkNow[these] = IncomeDstnNow[2][EventDraws] # PermShkNow[newborn] = 1.0 # TranShkNow[newborn] = 1.0 # Store the shocks in self - self.EmpNow = np.ones(self.AgentCount,dtype=bool) + self.EmpNow = np.ones(self.AgentCount, dtype=bool) self.EmpNow[TranShkNow == self.IncUnemp] = False self.TranShkNow = TranShkNow*self.TranShkAggNow*self.wRteNow self.PermShkNow = PermShkNow*self.PermShkAggNow - def getControls(self): ''' Calculates consumption for each consumer of this type using the consumption functions. @@ -488,29 +493,30 @@ def getControls(self): MrkvNow = self.getMrkvNow() StateCount = self.MrkvArray.shape[0] - MrkvBoolArray = np.zeros((StateCount,self.AgentCount),dtype=bool) + MrkvBoolArray = np.zeros((StateCount, self.AgentCount), dtype=bool) for i in range(StateCount): - MrkvBoolArray[i,:] = i == MrkvNow + MrkvBoolArray[i, :] = i == MrkvNow for t in range(self.T_cycle): these = t == self.t_cycle for i in range(StateCount): - those = np.logical_and(these,MrkvBoolArray[i,:]) - cNrmNow[those] = self.solution[t].cFunc[i](self.mNrmNow[those],MaggNow[those]) - MPCnow[those] = self.solution[t].cFunc[i].derivativeX(self.mNrmNow[those],MaggNow[those]) # Marginal propensity to consume + those = np.logical_and(these, MrkvBoolArray[i, :]) + cNrmNow[those] = self.solution[t].cFunc[i](self.mNrmNow[those], MaggNow[those]) + # Marginal propensity to consume + MPCnow[those] = self.solution[t].cFunc[i].derivativeX(self.mNrmNow[those], MaggNow[those]) self.cNrmNow = cNrmNow self.MPCnow = MPCnow return None - def getMrkvNow(self): # This function exists to be overwritten in StickyE model - return self.MrkvNow*np.ones(self.AgentCount,dtype=int) + def getMrkvNow(self): # This function exists to be overwritten in StickyE model + return self.MrkvNow*np.ones(self.AgentCount, dtype=int) ############################################################################### -def solveConsAggShock(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,PermGroFac, - PermGroFacAgg,aXtraGrid,BoroCnstArt,Mgrid,AFunc,Rfunc,wFunc,DeprFac): +def solveConsAggShock(solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, PermGroFac, + PermGroFacAgg, aXtraGrid, BoroCnstArt, Mgrid, AFunc, Rfunc, wFunc, DeprFac): ''' Solve one period of a consumption-saving problem with idiosyncratic and aggregate shocks (transitory and permanent). This is a basic solver that @@ -566,7 +572,7 @@ def solveConsAggShock(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,PermGroFac, mNrmMinNext = solution_next.mNrmMin # Unpack the income shocks - ShkPrbsNext = IncomeDstn[0] + ShkPrbsNext = IncomeDstn[0] PermShkValsNext = IncomeDstn[1] TranShkValsNext = IncomeDstn[2] PermShkAggValsNext = IncomeDstn[3] @@ -577,84 +583,86 @@ def solveConsAggShock(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,PermGroFac, aNrmNow = aXtraGrid aCount = aNrmNow.size Mcount = Mgrid.size - aXtra_tiled = np.tile(np.reshape(aNrmNow,(1,aCount,1)),(Mcount,1,ShkCount)) + aXtra_tiled = np.tile(np.reshape(aNrmNow, (1, aCount, 1)), (Mcount, 1, ShkCount)) # Make tiled versions of the income shocks # Dimension order: Mnow, aNow, Shk - ShkPrbsNext_tiled = np.tile(np.reshape(ShkPrbsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - PermShkValsNext_tiled = np.tile(np.reshape(PermShkValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - TranShkValsNext_tiled = np.tile(np.reshape(TranShkValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - PermShkAggValsNext_tiled = np.tile(np.reshape(PermShkAggValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - TranShkAggValsNext_tiled = np.tile(np.reshape(TranShkAggValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) + ShkPrbsNext_tiled = np.tile(np.reshape(ShkPrbsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + PermShkValsNext_tiled = np.tile(np.reshape(PermShkValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + TranShkValsNext_tiled = np.tile(np.reshape(TranShkValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + PermShkAggValsNext_tiled = np.tile(np.reshape(PermShkAggValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + TranShkAggValsNext_tiled = np.tile(np.reshape(TranShkAggValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) # Calculate returns to capital and labor in the next period - AaggNow_tiled = np.tile(np.reshape(AFunc(Mgrid),(Mcount,1,1)),(1,aCount,ShkCount)) - kNext_array = AaggNow_tiled/(PermGroFacAgg*PermShkAggValsNext_tiled) # Next period's aggregate capital to labor ratio - kNextEff_array = kNext_array/TranShkAggValsNext_tiled # Same thing, but account for *transitory* shock - R_array = Rfunc(kNextEff_array) # Interest factor on aggregate assets - Reff_array = R_array/LivPrb # Effective interest factor on individual assets *for survivors* - wEff_array = wFunc(kNextEff_array)*TranShkAggValsNext_tiled # Effective wage rate (accounts for labor supply) - PermShkTotal_array = PermGroFac*PermGroFacAgg*PermShkValsNext_tiled*PermShkAggValsNext_tiled # total / combined permanent shock - Mnext_array = kNext_array*R_array + wEff_array # next period's aggregate market resources + AaggNow_tiled = np.tile(np.reshape(AFunc(Mgrid), (Mcount, 1, 1)), (1, aCount, ShkCount)) + kNext_array = AaggNow_tiled/(PermGroFacAgg*PermShkAggValsNext_tiled) # Next period's aggregate capital/labor ratio + kNextEff_array = kNext_array/TranShkAggValsNext_tiled # Same thing, but account for *transitory* shock + R_array = Rfunc(kNextEff_array) # Interest factor on aggregate assets + Reff_array = R_array/LivPrb # Effective interest factor on individual assets *for survivors* + wEff_array = wFunc(kNextEff_array)*TranShkAggValsNext_tiled # Effective wage rate (accounts for labor supply) + PermShkTotal_array = PermGroFac * PermGroFacAgg *\ + PermShkValsNext_tiled * PermShkAggValsNext_tiled # total / combined permanent shock + Mnext_array = kNext_array*R_array + wEff_array # next period's aggregate market resources # Find the natural borrowing constraint for each value of M in the Mgrid. # There is likely a faster way to do this, but someone needs to do the math: # is aNrmMin determined by getting the worst shock of all four types? - aNrmMin_candidates = PermGroFac*PermGroFacAgg*PermShkValsNext_tiled[:,0,:]*PermShkAggValsNext_tiled[:,0,:]/Reff_array[:,0,:]*\ - (mNrmMinNext(Mnext_array[:,0,:]) - wEff_array[:,0,:]*TranShkValsNext_tiled[:,0,:]) - aNrmMin_vec = np.max(aNrmMin_candidates,axis=1) + aNrmMin_candidates = PermGroFac*PermGroFacAgg*PermShkValsNext_tiled[:, 0, :] * \ + PermShkAggValsNext_tiled[:, 0, :]/Reff_array[:, 0, :] * \ + (mNrmMinNext(Mnext_array[:, 0, :]) - wEff_array[:, 0, :] * + TranShkValsNext_tiled[:, 0, :]) + aNrmMin_vec = np.max(aNrmMin_candidates, axis=1) BoroCnstNat_vec = aNrmMin_vec - aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec,(Mcount,1,1)),(1,aCount,ShkCount)) + aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec, (Mcount, 1, 1)), (1, aCount, ShkCount)) aNrmNow_tiled = aNrmMin_tiled + aXtra_tiled # Calculate market resources next period (and a constant array of capital-to-labor ratio) mNrmNext_array = Reff_array*aNrmNow_tiled/PermShkTotal_array + TranShkValsNext_tiled*wEff_array # Find marginal value next period at every income shock realization and every aggregate market resource gridpoint - vPnext_array = Reff_array*PermShkTotal_array**(-CRRA)*vPfuncNext(mNrmNext_array,Mnext_array) + vPnext_array = Reff_array*PermShkTotal_array**(-CRRA)*vPfuncNext(mNrmNext_array, Mnext_array) # Calculate expectated marginal value at the end of the period at every asset gridpoint - EndOfPrdvP = DiscFac*LivPrb*np.sum(vPnext_array*ShkPrbsNext_tiled,axis=2) + EndOfPrdvP = DiscFac*LivPrb*np.sum(vPnext_array*ShkPrbsNext_tiled, axis=2) # Calculate optimal consumption from each asset gridpoint cNrmNow = EndOfPrdvP**(-1.0/CRRA) - mNrmNow = aNrmNow_tiled[:,:,0] + cNrmNow + mNrmNow = aNrmNow_tiled[:, :, 0] + cNrmNow # Loop through the values in Mgrid and make a linear consumption function for each cFuncBaseByM_list = [] for j in range(Mcount): - c_temp = np.insert(cNrmNow[j,:],0,0.0) # Add point at bottom - m_temp = np.insert(mNrmNow[j,:] - BoroCnstNat_vec[j],0,0.0) - cFuncBaseByM_list.append(LinearInterp(m_temp,c_temp)) + c_temp = np.insert(cNrmNow[j, :], 0, 0.0) # Add point at bottom + m_temp = np.insert(mNrmNow[j, :] - BoroCnstNat_vec[j], 0, 0.0) + cFuncBaseByM_list.append(LinearInterp(m_temp, c_temp)) # Add the M-specific consumption function to the list # Construct the overall unconstrained consumption function by combining the M-specific functions - BoroCnstNat = LinearInterp(np.insert(Mgrid,0,0.0),np.insert(BoroCnstNat_vec,0,0.0)) - cFuncBase = LinearInterpOnInterp1D(cFuncBaseByM_list,Mgrid) - cFuncUnc = VariableLowerBoundFunc2D(cFuncBase,BoroCnstNat) + BoroCnstNat = LinearInterp(np.insert(Mgrid, 0, 0.0), np.insert(BoroCnstNat_vec, 0, 0.0)) + cFuncBase = LinearInterpOnInterp1D(cFuncBaseByM_list, Mgrid) + cFuncUnc = VariableLowerBoundFunc2D(cFuncBase, BoroCnstNat) # Make the constrained consumption function and combine it with the unconstrained component - cFuncCnst = BilinearInterp(np.array([[0.0,0.0],[1.0,1.0]]), - np.array([BoroCnstArt,BoroCnstArt+1.0]),np.array([0.0,1.0])) - cFuncNow = LowerEnvelope2D(cFuncUnc,cFuncCnst) + cFuncCnst = BilinearInterp(np.array([[0.0, 0.0], [1.0, 1.0]]), + np.array([BoroCnstArt, BoroCnstArt+1.0]), np.array([0.0, 1.0])) + cFuncNow = LowerEnvelope2D(cFuncUnc, cFuncCnst) # Make the minimum m function as the greater of the natural and artificial constraints - mNrmMinNow = UpperEnvelope(BoroCnstNat,ConstantFunction(BoroCnstArt)) + mNrmMinNow = UpperEnvelope(BoroCnstNat, ConstantFunction(BoroCnstArt)) # Construct the marginal value function using the envelope condition - vPfuncNow = MargValueFunc2D(cFuncNow,CRRA) + vPfuncNow = MargValueFunc2D(cFuncNow, CRRA) # Pack up and return the solution - solution_now = ConsumerSolution(cFunc=cFuncNow,vPfunc=vPfuncNow,mNrmMin=mNrmMinNow) + solution_now = ConsumerSolution(cFunc=cFuncNow, vPfunc=vPfuncNow, mNrmMin=mNrmMinNow) return solution_now ############################################################################### - -def solveConsAggMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,MrkvArray, - PermGroFac,PermGroFacAgg,aXtraGrid,BoroCnstArt,Mgrid, - AFunc,Rfunc,wFunc,DeprFac): +def solveConsAggMarkov(solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, MrkvArray, + PermGroFac, PermGroFacAgg, aXtraGrid, BoroCnstArt, Mgrid, + AFunc, Rfunc, wFunc, DeprFac): ''' Solve one period of a consumption-saving problem with idiosyncratic and aggregate shocks (transitory and permanent). Moreover, the macroeconomic @@ -728,21 +736,21 @@ def solveConsAggMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,MrkvArray, mNrmMinNext = solution_next.mNrmMin[j] # Unpack the income shocks - ShkPrbsNext = IncomeDstn[j][0] + ShkPrbsNext = IncomeDstn[j][0] PermShkValsNext = IncomeDstn[j][1] TranShkValsNext = IncomeDstn[j][2] PermShkAggValsNext = IncomeDstn[j][3] TranShkAggValsNext = IncomeDstn[j][4] ShkCount = ShkPrbsNext.size - aXtra_tiled = np.tile(np.reshape(aXtraGrid,(1,aCount,1)),(Mcount,1,ShkCount)) + aXtra_tiled = np.tile(np.reshape(aXtraGrid, (1, aCount, 1)), (Mcount, 1, ShkCount)) # Make tiled versions of the income shocks # Dimension order: Mnow, aNow, Shk - ShkPrbsNext_tiled = np.tile(np.reshape(ShkPrbsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - PermShkValsNext_tiled = np.tile(np.reshape(PermShkValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - TranShkValsNext_tiled = np.tile(np.reshape(TranShkValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - PermShkAggValsNext_tiled = np.tile(np.reshape(PermShkAggValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) - TranShkAggValsNext_tiled = np.tile(np.reshape(TranShkAggValsNext,(1,1,ShkCount)),(Mcount,aCount,1)) + ShkPrbsNext_tiled = np.tile(np.reshape(ShkPrbsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + PermShkValsNext_tiled = np.tile(np.reshape(PermShkValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + TranShkValsNext_tiled = np.tile(np.reshape(TranShkValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + PermShkAggValsNext_tiled = np.tile(np.reshape(PermShkAggValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) + TranShkAggValsNext_tiled = np.tile(np.reshape(TranShkAggValsNext, (1, 1, ShkCount)), (Mcount, aCount, 1)) # Make a tiled grid of end-of-period aggregate assets. These lines use # next prd state j's aggregate saving rule to get a relevant set of Aagg, @@ -757,47 +765,52 @@ def solveConsAggMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,MrkvArray, # conditional marginal value functions are constructed is not relevant # to the values at which it will actually be evaluated. AaggGrid = AFunc[j](Mgrid) - AaggNow_tiled = np.tile(np.reshape(AaggGrid,(Mcount,1,1)),(1,aCount,ShkCount)) + AaggNow_tiled = np.tile(np.reshape(AaggGrid, (Mcount, 1, 1)), (1, aCount, ShkCount)) # Calculate returns to capital and labor in the next period - kNext_array = AaggNow_tiled/(PermGroFacAgg[j]*PermShkAggValsNext_tiled) # Next period's aggregate capital to labor ratio - kNextEff_array = kNext_array/TranShkAggValsNext_tiled # Same thing, but account for *transitory* shock - R_array = Rfunc(kNextEff_array) # Interest factor on aggregate assets - Reff_array = R_array/LivPrb # Effective interest factor on individual assets *for survivors* - wEff_array = wFunc(kNextEff_array)*TranShkAggValsNext_tiled # Effective wage rate (accounts for labor supply) - PermShkTotal_array = PermGroFac*PermGroFacAgg[j]*PermShkValsNext_tiled*PermShkAggValsNext_tiled # total / combined permanent shock - Mnext_array = kNext_array*R_array + wEff_array # next period's aggregate market resources + kNext_array = AaggNow_tiled/(PermGroFacAgg[j] * + PermShkAggValsNext_tiled) # Next period's aggregate capital to labor ratio + kNextEff_array = kNext_array/TranShkAggValsNext_tiled # Same thing, but account for *transitory* shock + R_array = Rfunc(kNextEff_array) # Interest factor on aggregate assets + Reff_array = R_array/LivPrb # Effective interest factor on individual assets *for survivors* + wEff_array = wFunc(kNextEff_array)*TranShkAggValsNext_tiled # Effective wage rate (accounts for labor supply) + PermShkTotal_array = PermGroFac*PermGroFacAgg[j] * \ + PermShkValsNext_tiled*PermShkAggValsNext_tiled # total / combined permanent shock + Mnext_array = kNext_array*R_array + wEff_array # next period's aggregate market resources # Find the natural borrowing constraint for each value of M in the Mgrid. # There is likely a faster way to do this, but someone needs to do the math: # is aNrmMin determined by getting the worst shock of all four types? - aNrmMin_candidates = PermGroFac*PermGroFacAgg[j]*PermShkValsNext_tiled[:,0,:]*PermShkAggValsNext_tiled[:,0,:]/Reff_array[:,0,:]*\ - (mNrmMinNext(Mnext_array[:,0,:]) - wEff_array[:,0,:]*TranShkValsNext_tiled[:,0,:]) - aNrmMin_vec = np.max(aNrmMin_candidates,axis=1) + aNrmMin_candidates = PermGroFac*PermGroFacAgg[j]*PermShkValsNext_tiled[:, 0, :] * \ + PermShkAggValsNext_tiled[:, 0, :]/Reff_array[:, 0, :] * \ + (mNrmMinNext(Mnext_array[:, 0, :]) - wEff_array[:, 0, :]*TranShkValsNext_tiled[:, 0, :]) + aNrmMin_vec = np.max(aNrmMin_candidates, axis=1) BoroCnstNat_vec = aNrmMin_vec - aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec,(Mcount,1,1)),(1,aCount,ShkCount)) + aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec, (Mcount, 1, 1)), (1, aCount, ShkCount)) aNrmNow_tiled = aNrmMin_tiled + aXtra_tiled # Calculate market resources next period (and a constant array of capital-to-labor ratio) mNrmNext_array = Reff_array*aNrmNow_tiled/PermShkTotal_array + TranShkValsNext_tiled*wEff_array - # Find marginal value next period at every income shock realization and every aggregate market resource gridpoint - vPnext_array = Reff_array*PermShkTotal_array**(-CRRA)*vPfuncNext(mNrmNext_array,Mnext_array) + # Find marginal value next period at every income shock + # realization and every aggregate market resource gridpoint + vPnext_array = Reff_array*PermShkTotal_array**(-CRRA)*vPfuncNext(mNrmNext_array, Mnext_array) # Calculate expectated marginal value at the end of the period at every asset gridpoint - EndOfPrdvP = DiscFac*LivPrb*np.sum(vPnext_array*ShkPrbsNext_tiled,axis=2) + EndOfPrdvP = DiscFac*LivPrb*np.sum(vPnext_array*ShkPrbsNext_tiled, axis=2) # Make the conditional end-of-period marginal value function - BoroCnstNat = LinearInterp(np.insert(AaggGrid,0,0.0),np.insert(BoroCnstNat_vec,0,0.0)) - EndOfPrdvPnvrs = np.concatenate((np.zeros((Mcount,1)),EndOfPrdvP**(-1./CRRA)),axis=1) - EndOfPrdvPnvrsFunc_base = BilinearInterp(np.transpose(EndOfPrdvPnvrs),np.insert(aXtraGrid,0,0.0),AaggGrid) - EndOfPrdvPnvrsFunc = VariableLowerBoundFunc2D(EndOfPrdvPnvrsFunc_base,BoroCnstNat) - EndOfPrdvPfunc_cond.append(MargValueFunc2D(EndOfPrdvPnvrsFunc,CRRA)) + BoroCnstNat = LinearInterp(np.insert(AaggGrid, 0, 0.0), np.insert(BoroCnstNat_vec, 0, 0.0)) + EndOfPrdvPnvrs = np.concatenate((np.zeros((Mcount, 1)), EndOfPrdvP**(-1./CRRA)), axis=1) + EndOfPrdvPnvrsFunc_base = BilinearInterp(np.transpose(EndOfPrdvPnvrs), np.insert(aXtraGrid, 0, 0.0), AaggGrid) + EndOfPrdvPnvrsFunc = VariableLowerBoundFunc2D(EndOfPrdvPnvrsFunc_base, BoroCnstNat) + EndOfPrdvPfunc_cond.append(MargValueFunc2D(EndOfPrdvPnvrsFunc, CRRA)) BoroCnstNat_cond.append(BoroCnstNat) # Prepare some objects that are the same across all current states - aXtra_tiled = np.tile(np.reshape(aXtraGrid,(1,aCount)),(Mcount,1)) - cFuncCnst = BilinearInterp(np.array([[0.0,0.0],[1.0,1.0]]),np.array([BoroCnstArt,BoroCnstArt+1.0]),np.array([0.0,1.0])) + aXtra_tiled = np.tile(np.reshape(aXtraGrid, (1, aCount)), (Mcount, 1)) + cFuncCnst = BilinearInterp(np.array([[0.0, 0.0], [1.0, 1.0]]), + np.array([BoroCnstArt, BoroCnstArt+1.0]), np.array([0.0, 1.0])) # Now loop through *this* period's discrete states, calculating end-of-period # marginal value (weighting across state transitions), then construct consumption @@ -808,24 +821,24 @@ def solveConsAggMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,MrkvArray, for i in range(StateCount): # Find natural borrowing constraint for this state by Aagg AaggNow = AFunc[i](Mgrid) - aNrmMin_candidates = np.zeros((StateCount,Mcount)) + np.nan + aNrmMin_candidates = np.zeros((StateCount, Mcount)) + np.nan for j in range(StateCount): - if MrkvArray[i,j] > 0.: # Irrelevant if transition is impossible - aNrmMin_candidates[j,:] = BoroCnstNat_cond[j](AaggNow) - aNrmMin_vec = np.nanmax(aNrmMin_candidates,axis=0) + if MrkvArray[i, j] > 0.: # Irrelevant if transition is impossible + aNrmMin_candidates[j, :] = BoroCnstNat_cond[j](AaggNow) + aNrmMin_vec = np.nanmax(aNrmMin_candidates, axis=0) BoroCnstNat_vec = aNrmMin_vec # Make tiled grids of aNrm and Aagg - aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec,(Mcount,1)),(1,aCount)) + aNrmMin_tiled = np.tile(np.reshape(aNrmMin_vec, (Mcount, 1)), (1, aCount)) aNrmNow_tiled = aNrmMin_tiled + aXtra_tiled - AaggNow_tiled = np.tile(np.reshape(AaggNow,(Mcount,1)),(1,aCount)) + AaggNow_tiled = np.tile(np.reshape(AaggNow, (Mcount, 1)), (1, aCount)) # Loop through feasible transitions and calculate end-of-period marginal value - EndOfPrdvP = np.zeros((Mcount,aCount)) + EndOfPrdvP = np.zeros((Mcount, aCount)) for j in range(StateCount): - if MrkvArray[i,j] > 0.: - temp = EndOfPrdvPfunc_cond[j](aNrmNow_tiled,AaggNow_tiled) - EndOfPrdvP += MrkvArray[i,j]*temp + if MrkvArray[i, j] > 0.: + temp = EndOfPrdvPfunc_cond[j](aNrmNow_tiled, AaggNow_tiled) + EndOfPrdvP += MrkvArray[i, j]*temp # Calculate consumption and the endogenous mNrm gridpoints for this state cNrmNow = EndOfPrdvP**(-1./CRRA) @@ -834,34 +847,33 @@ def solveConsAggMarkov(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,MrkvArray, # Loop through the values in Mgrid and make a piecewise linear consumption function for each cFuncBaseByM_list = [] for n in range(Mcount): - c_temp = np.insert(cNrmNow[n,:],0,0.0) # Add point at bottom - m_temp = np.insert(mNrmNow[n,:] - BoroCnstNat_vec[n],0,0.0) - cFuncBaseByM_list.append(LinearInterp(m_temp,c_temp)) + c_temp = np.insert(cNrmNow[n, :], 0, 0.0) # Add point at bottom + m_temp = np.insert(mNrmNow[n, :] - BoroCnstNat_vec[n], 0, 0.0) + cFuncBaseByM_list.append(LinearInterp(m_temp, c_temp)) # Add the M-specific consumption function to the list # Construct the unconstrained consumption function by combining the M-specific functions - BoroCnstNat = LinearInterp(np.insert(Mgrid,0,0.0),np.insert(BoroCnstNat_vec,0,0.0)) - cFuncBase = LinearInterpOnInterp1D(cFuncBaseByM_list,Mgrid) - cFuncUnc = VariableLowerBoundFunc2D(cFuncBase,BoroCnstNat) + BoroCnstNat = LinearInterp(np.insert(Mgrid, 0, 0.0), np.insert(BoroCnstNat_vec, 0, 0.0)) + cFuncBase = LinearInterpOnInterp1D(cFuncBaseByM_list, Mgrid) + cFuncUnc = VariableLowerBoundFunc2D(cFuncBase, BoroCnstNat) # Combine the constrained consumption function with unconstrained component - cFuncNow.append(LowerEnvelope2D(cFuncUnc,cFuncCnst)) + cFuncNow.append(LowerEnvelope2D(cFuncUnc, cFuncCnst)) # Make the minimum m function as the greater of the natural and artificial constraints - mNrmMinNow.append(UpperEnvelope(BoroCnstNat,ConstantFunction(BoroCnstArt))) + mNrmMinNow.append(UpperEnvelope(BoroCnstNat, ConstantFunction(BoroCnstArt))) # Construct the marginal value function using the envelope condition - vPfuncNow.append(MargValueFunc2D(cFuncNow[-1],CRRA)) + vPfuncNow.append(MargValueFunc2D(cFuncNow[-1], CRRA)) # Pack up and return the solution - solution_now = ConsumerSolution(cFunc=cFuncNow,vPfunc=vPfuncNow,mNrmMin=mNrmMinNow) + solution_now = ConsumerSolution(cFunc=cFuncNow, vPfunc=vPfuncNow, mNrmMin=mNrmMinNow) return solution_now ############################################################################### - class CobbDouglasEconomy(Market): ''' A class to represent an economy with a Cobb-Douglas aggregate production @@ -873,7 +885,7 @@ class CobbDouglasEconomy(Market): Note: The current implementation assumes a constant labor supply, but this will be generalized in the future. ''' - def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): + def __init__(self, agents=[], tolerance=0.0001, act_T=1000, **kwds): ''' Make a new instance of CobbDouglasEconomy by filling in attributes specific to this kind of market. @@ -893,35 +905,46 @@ def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): ------- None ''' - Market.__init__(self,agents=agents, - sow_vars=['MaggNow','AaggNow','RfreeNow','wRteNow','PermShkAggNow','TranShkAggNow','KtoLnow'], - reap_vars=['aLvlNow','pLvlNow'], - track_vars=['MaggNow','AaggNow'], - dyn_vars=['AFunc'], - tolerance=tolerance, - act_T=act_T) + Market.__init__(self, agents=agents, + sow_vars=['MaggNow', 'AaggNow', 'RfreeNow', + 'wRteNow', 'PermShkAggNow', 'TranShkAggNow', 'KtoLnow'], + reap_vars=['aLvlNow', 'pLvlNow'], + track_vars=['MaggNow', 'AaggNow'], + dyn_vars=['AFunc'], + tolerance=tolerance, + act_T=act_T) self.assignParameters(**kwds) - self.max_loops = 20 self.update() + # Use previously hardcoded values for AFunc updating if not passed + # as part of initialization dictionary. This is to prevent a last + # minute update to HARK before a release from having a breaking change. + if not hasattr(self, 'DampingFac'): + self.DampingFac = 0.5 + if not hasattr(self, 'max_loops'): + self.max_loops = 20 + if not hasattr(self, 'T_discard'): + self.T_discard = 200 + if not hasattr(self, 'verbose'): + self.verbose = True - def millRule(self,aLvlNow,pLvlNow): + def millRule(self, aLvlNow, pLvlNow): ''' Function to calculate the capital to labor ratio, interest factor, and wage rate based on each agent's current state. Just calls calcRandW(). See documentation for calcRandW for more information. ''' - return self.calcRandW(aLvlNow,pLvlNow) + return self.calcRandW(aLvlNow, pLvlNow) - def calcDynamics(self,MaggNow,AaggNow): + def calcDynamics(self, MaggNow, AaggNow): ''' Calculates a new dynamic rule for the economy: end of period savings as a function of aggregate market resources. Just calls calcAFunc(). See documentation for calcAFunc for more information. ''' - return self.calcAFunc(MaggNow,AaggNow) + return self.calcAFunc(MaggNow, AaggNow) def update(self): ''' @@ -937,14 +960,15 @@ def update(self): ------- None ''' - self.kSS = ((self.getPermGroFacAggLR()**(self.CRRA)/self.DiscFac - (1.0-self.DeprFac))/self.CapShare)**(1.0/(self.CapShare-1.0)) + self.kSS = ((self.getPermGroFacAggLR() ** + (self.CRRA)/self.DiscFac - (1.0-self.DeprFac))/self.CapShare)**(1.0/(self.CapShare-1.0)) self.KtoYSS = self.kSS**(1.0-self.CapShare) self.wRteSS = (1.0-self.CapShare)*self.kSS**(self.CapShare) self.RfreeSS = (1.0 + self.CapShare*self.kSS**(self.CapShare-1.0) - self.DeprFac) self.MSS = self.kSS*self.RfreeSS + self.wRteSS - self.convertKtoY = lambda KtoY : KtoY**(1.0/(1.0 - self.CapShare)) # converts K/Y to K/L - self.Rfunc = lambda k : (1.0 + self.CapShare*k**(self.CapShare-1.0) - self.DeprFac) - self.wFunc = lambda k : ((1.0-self.CapShare)*k**(self.CapShare)) + self.convertKtoY = lambda KtoY: KtoY**(1.0/(1.0 - self.CapShare)) # converts K/Y to K/L + self.Rfunc = lambda k: (1.0 + self.CapShare*k**(self.CapShare-1.0) - self.DeprFac) + self.wFunc = lambda k: ((1.0-self.CapShare)*k**(self.CapShare)) self.KtoLnow_init = self.kSS self.MaggNow_init = self.kSS self.AaggNow_init = self.kSS @@ -953,8 +977,7 @@ def update(self): self.PermShkAggNow_init = 1.0 self.TranShkAggNow_init = 1.0 self.makeAggShkDstn() - self.AFunc = AggregateSavingRule(self.intercept_prev,self.slope_prev) - + self.AFunc = AggregateSavingRule(self.intercept_prev, self.slope_prev) def getPermGroFacAggLR(self): ''' @@ -973,7 +996,6 @@ def getPermGroFacAggLR(self): ''' return self.PermGroFacAgg - def makeAggShkDstn(self): ''' Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. @@ -987,9 +1009,9 @@ def makeAggShkDstn(self): ------- None ''' - self.TranShkAggDstn = approxMeanOneLognormal(sigma=self.TranShkAggStd,N=self.TranShkAggCount) - self.PermShkAggDstn = approxMeanOneLognormal(sigma=self.PermShkAggStd,N=self.PermShkAggCount) - self.AggShkDstn = combineIndepDstns(self.PermShkAggDstn,self.TranShkAggDstn) + self.TranShkAggDstn = approxMeanOneLognormal(sigma=self.TranShkAggStd, N=self.TranShkAggCount) + self.PermShkAggDstn = approxMeanOneLognormal(sigma=self.PermShkAggStd, N=self.PermShkAggCount) + self.AggShkDstn = combineIndepDstns(self.PermShkAggDstn, self.TranShkAggDstn) def reset(self): ''' @@ -998,11 +1020,11 @@ def reset(self): Parameters ---------- - none + None Returns ------- - none + None ''' self.Shk_idx = 0 Market.reset(self) @@ -1015,15 +1037,15 @@ def makeAggShkHist(self): Parameters ---------- - none + None Returns ------- - none + None ''' sim_periods = self.act_T - Events = np.arange(self.AggShkDstn[0].size) # just a list of integers - EventDraws = drawDiscrete(N=sim_periods,P=self.AggShkDstn[0],X=Events,seed=0) + Events = np.arange(self.AggShkDstn[0].size) # just a list of integers + EventDraws = drawDiscrete(N=sim_periods, P=self.AggShkDstn[0], X=Events, seed=0) PermShkAggHist = self.AggShkDstn[1][EventDraws] TranShkAggHist = self.AggShkDstn[2][EventDraws] @@ -1031,7 +1053,7 @@ def makeAggShkHist(self): self.PermShkAggHist = PermShkAggHist*self.PermGroFacAgg self.TranShkAggHist = TranShkAggHist - def calcRandW(self,aLvlNow,pLvlNow): + def calcRandW(self, aLvlNow, pLvlNow): ''' Calculates the interest factor and wage rate this period using each agent's capital stock to get the aggregate capital ratio. @@ -1050,9 +1072,9 @@ def calcRandW(self,aLvlNow,pLvlNow): aggregate permanent and transitory shocks. ''' # Calculate aggregate savings - AaggPrev = np.mean(np.array(aLvlNow))/np.mean(pLvlNow) # End-of-period savings from last period + AaggPrev = np.mean(np.array(aLvlNow))/np.mean(pLvlNow) # End-of-period savings from last period # Calculate aggregate capital this period - AggregateK = np.mean(np.array(aLvlNow)) # ...becomes capital today + AggregateK = np.mean(np.array(aLvlNow)) # ...becomes capital today # This version uses end-of-period assets and # permanent income to calculate aggregate capital, unlike the Mathematica # version, which first applies the idiosyncratic permanent income shocks @@ -1069,15 +1091,15 @@ def calcRandW(self,aLvlNow,pLvlNow): KtoLnow = AggregateK/AggregateL self.KtoYnow = KtoLnow**(1.0-self.CapShare) RfreeNow = self.Rfunc(KtoLnow/TranShkAggNow) - wRteNow = self.wFunc(KtoLnow/TranShkAggNow) - MaggNow = KtoLnow*RfreeNow + wRteNow*TranShkAggNow + wRteNow = self.wFunc(KtoLnow/TranShkAggNow) + MaggNow = KtoLnow*RfreeNow + wRteNow*TranShkAggNow self.KtoLnow = KtoLnow # Need to store this as it is a sow variable # Package the results into an object and return it - AggVarsNow = CobbDouglasAggVars(MaggNow,AaggPrev,KtoLnow,RfreeNow,wRteNow,PermShkAggNow,TranShkAggNow) + AggVarsNow = CobbDouglasAggVars(MaggNow, AaggPrev, KtoLnow, RfreeNow, wRteNow, PermShkAggNow, TranShkAggNow) return AggVarsNow - def calcAFunc(self,MaggNow,AaggNow): + def calcAFunc(self, MaggNow, AaggNow): ''' Calculate a new aggregate savings rule based on the history of the aggregate savings and aggregate market resources from a simulation. @@ -1085,30 +1107,30 @@ def calcAFunc(self,MaggNow,AaggNow): Parameters ---------- MaggNow : [float] - List of the history of the simulated aggregate market resources for an economy. + List of the history of the simulated aggregate market resources for an economy. AaggNow : [float] - List of the history of the simulated aggregate savings for an economy. + List of the history of the simulated aggregate savings for an economy. Returns ------- (unnamed) : CapDynamicRule Object containing a new savings rule ''' - verbose = True - discard_periods = 200 # Throw out the first T periods to allow the simulation to approach the SS - update_weight = 0.80 # Proportional weight to put on new function vs old function parameters + verbose = self.verbose + discard_periods = self.T_discard # Throw out the first T periods to allow the simulation to approach the SS + update_weight = 1. - self.DampingFac # Proportional weight to put on new function vs old function parameters total_periods = len(MaggNow) # Regress the log savings against log market resources - logAagg = np.log(AaggNow[discard_periods:total_periods]) + logAagg = np.log(AaggNow[discard_periods:total_periods]) logMagg = np.log(MaggNow[discard_periods-1:total_periods-1]) - slope, intercept, r_value, p_value, std_err = stats.linregress(logMagg,logAagg) + slope, intercept, r_value, p_value, std_err = stats.linregress(logMagg, logAagg) # Make a new aggregate savings rule by combining the new regression parameters # with the previous guess intercept = update_weight*intercept + (1.0-update_weight)*self.intercept_prev slope = update_weight*slope + (1.0-update_weight)*self.slope_prev - AFunc = AggregateSavingRule(intercept,slope) # Make a new next-period capital function + AFunc = AggregateSavingRule(intercept, slope) # Make a new next-period capital function # Save the new values as "previous" values for the next iteration self.intercept_prev = intercept @@ -1117,9 +1139,9 @@ def calcAFunc(self,MaggNow,AaggNow): # Plot aggregate resources vs aggregate savings for this run and print the new parameters if verbose: print('intercept=' + str(intercept) + ', slope=' + str(slope) + ', r-sq=' + str(r_value**2)) - #plot_start = discard_periods - #plt.plot(logMagg[plot_start:],logAagg[plot_start:],'.k') - #plt.show() + # plot_start = discard_periods + # plt.plot(logMagg[plot_start:],logAagg[plot_start:],'.k') + # plt.show() return AggShocksDynamicRule(AFunc) @@ -1130,7 +1152,7 @@ class SmallOpenEconomy(Market): exogenously determined by some "global" rate. However, the economy is still subject to aggregate productivity shocks. ''' - def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): + def __init__(self, agents=[], tolerance=0.0001, act_T=1000, **kwds): ''' Make a new instance of SmallOpenEconomy by filling in attributes specific to this kind of market. @@ -1149,13 +1171,15 @@ def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): ------- None ''' - Market.__init__(self,agents=agents, - sow_vars=['MaggNow','AaggNow','RfreeNow','wRteNow','PermShkAggNow','TranShkAggNow','KtoLnow'], - reap_vars=[], - track_vars=['MaggNow','AaggNow'], - dyn_vars=[], - tolerance=tolerance, - act_T=act_T) + Market.__init__(self, + agents=agents, + sow_vars=['MaggNow', 'AaggNow', 'RfreeNow', 'wRteNow', + 'PermShkAggNow', 'TranShkAggNow', 'KtoLnow'], + reap_vars=[], + track_vars=['MaggNow', 'AaggNow'], + dyn_vars=[], + tolerance=tolerance, + act_T=act_T) self.assignParameters(**kwds) self.update() @@ -1199,9 +1223,9 @@ def makeAggShkDstn(self): ------- None ''' - self.TranShkAggDstn = approxMeanOneLognormal(sigma=self.TranShkAggStd,N=self.TranShkAggCount) - self.PermShkAggDstn = approxMeanOneLognormal(sigma=self.PermShkAggStd,N=self.PermShkAggCount) - self.AggShkDstn = combineIndepDstns(self.PermShkAggDstn,self.TranShkAggDstn) + self.TranShkAggDstn = approxMeanOneLognormal(sigma=self.TranShkAggStd, N=self.TranShkAggCount) + self.PermShkAggDstn = approxMeanOneLognormal(sigma=self.PermShkAggStd, N=self.PermShkAggCount) + self.AggShkDstn = combineIndepDstns(self.PermShkAggDstn, self.TranShkAggDstn) def millRule(self): ''' @@ -1212,7 +1236,7 @@ def millRule(self): ''' return self.getAggShocks() - def calcDynamics(self,KtoLnow): + def calcDynamics(self, KtoLnow): ''' Calculates a new dynamic rule for the economy, which is just an empty object. There is no "dynamic rule" for a small open economy, because K/L does not generate w and R. @@ -1251,8 +1275,8 @@ def makeAggShkHist(self): None ''' sim_periods = self.act_T - Events = np.arange(self.AggShkDstn[0].size) # just a list of integers - EventDraws = drawDiscrete(N=sim_periods,P=self.AggShkDstn[0],X=Events,seed=0) + Events = np.arange(self.AggShkDstn[0].size) # just a list of integers + EventDraws = drawDiscrete(N=sim_periods, P=self.AggShkDstn[0], X=Events, seed=0) PermShkAggHist = self.AggShkDstn[1][EventDraws] TranShkAggHist = self.AggShkDstn[2][EventDraws] @@ -1282,7 +1306,7 @@ def getAggShocks(self): # Factor prices are constant RfreeNow = self.Rfunc(1.0/PermShkAggNow) - wRteNow = self.wFunc(1.0/PermShkAggNow) + wRteNow = self.wFunc(1.0/PermShkAggNow) # Aggregates are irrelavent AaggNow = 1.0 @@ -1290,7 +1314,7 @@ def getAggShocks(self): KtoLnow = 1.0/PermShkAggNow # Package the results into an object and return it - AggVarsNow = CobbDouglasAggVars(MaggNow,AaggNow,KtoLnow,RfreeNow,wRteNow,PermShkAggNow,TranShkAggNow) + AggVarsNow = CobbDouglasAggVars(MaggNow, AaggNow, KtoLnow, RfreeNow, wRteNow, PermShkAggNow, TranShkAggNow) return AggVarsNow @@ -1305,7 +1329,7 @@ class CobbDouglasMarkovEconomy(CobbDouglasEconomy): productivity growth factor can vary over time. ''' - def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): + def __init__(self, agents=[], tolerance=0.0001, act_T=1000, **kwds): ''' Make a new instance of CobbDouglasMarkovEconomy by filling in attributes specific to this kind of market. @@ -1325,10 +1349,9 @@ def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): ------- None ''' - CobbDouglasEconomy.__init__(self,agents=agents,tolerance=tolerance,act_T=act_T,**kwds) + CobbDouglasEconomy.__init__(self, agents=agents, tolerance=tolerance, act_T=act_T, **kwds) self.sow_vars.append('MrkvNow') - def update(self): ''' Use primitive parameters (and perfect foresight calibrations) to make @@ -1347,10 +1370,9 @@ def update(self): StateCount = self.MrkvArray.shape[0] AFunc_all = [] for i in range(StateCount): - AFunc_all.append(AggregateSavingRule(self.intercept_prev[i],self.slope_prev[i])) + AFunc_all.append(AggregateSavingRule(self.intercept_prev[i], self.slope_prev[i])) self.AFunc = AFunc_all - def getPermGroFacAggLR(self): ''' Calculates and returns the long run permanent income growth factor. This @@ -1369,14 +1391,13 @@ def getPermGroFacAggLR(self): # Find the long run distribution of Markov states w, v = np.linalg.eig(np.transpose(self.MrkvArray)) idx = (np.abs(w-1.0)).argmin() - x = v[:,idx].astype(float) + x = v[:, idx].astype(float) LR_dstn = (x/np.sum(x)) # Return the weighted average of aggregate permanent income growth factors - PermGroFacAggLR = np.dot(LR_dstn,np.array(self.PermGroFacAgg)) + PermGroFacAggLR = np.dot(LR_dstn, np.array(self.PermGroFacAgg)) return PermGroFacAggLR - def makeAggShkDstn(self): ''' Creates the attributes TranShkAggDstn, PermShkAggDstn, and AggShkDstn. @@ -1397,15 +1418,14 @@ def makeAggShkDstn(self): StateCount = self.MrkvArray.shape[0] for i in range(StateCount): - TranShkAggDstn.append(approxMeanOneLognormal(sigma=self.TranShkAggStd[i],N=self.TranShkAggCount)) - PermShkAggDstn.append(approxMeanOneLognormal(sigma=self.PermShkAggStd[i],N=self.PermShkAggCount)) - AggShkDstn.append(combineIndepDstns(PermShkAggDstn[-1],TranShkAggDstn[-1])) + TranShkAggDstn.append(approxMeanOneLognormal(sigma=self.TranShkAggStd[i], N=self.TranShkAggCount)) + PermShkAggDstn.append(approxMeanOneLognormal(sigma=self.PermShkAggStd[i], N=self.PermShkAggCount)) + AggShkDstn.append(combineIndepDstns(PermShkAggDstn[-1], TranShkAggDstn[-1])) self.TranShkAggDstn = TranShkAggDstn self.PermShkAggDstn = PermShkAggDstn self.AggShkDstn = AggShkDstn - def makeAggShkHist(self): ''' Make simulated histories of aggregate transitory and permanent shocks. @@ -1421,19 +1441,19 @@ def makeAggShkHist(self): ------- None ''' - self.makeMrkvHist() # Make a (pseudo)random sequence of Markov states + self.makeMrkvHist() # Make a (pseudo)random sequence of Markov states sim_periods = self.act_T # For each Markov state in each simulated period, draw the aggregate shocks # that would occur in that state in that period StateCount = self.MrkvArray.shape[0] - PermShkAggHistAll = np.zeros((StateCount,sim_periods)) - TranShkAggHistAll = np.zeros((StateCount,sim_periods)) + PermShkAggHistAll = np.zeros((StateCount, sim_periods)) + TranShkAggHistAll = np.zeros((StateCount, sim_periods)) for i in range(StateCount): - Events = np.arange(self.AggShkDstn[i][0].size) # just a list of integers - EventDraws = drawDiscrete(N=sim_periods,P=self.AggShkDstn[i][0],X=Events,seed=0) - PermShkAggHistAll[i,:] = self.AggShkDstn[i][1][EventDraws] - TranShkAggHistAll[i,:] = self.AggShkDstn[i][2][EventDraws] + Events = np.arange(self.AggShkDstn[i][0].size) # just a list of integers + EventDraws = drawDiscrete(N=sim_periods, P=self.AggShkDstn[i][0], X=Events, seed=0) + PermShkAggHistAll[i, :] = self.AggShkDstn[i][1][EventDraws] + TranShkAggHistAll[i, :] = self.AggShkDstn[i][2][EventDraws] # Select the actual history of aggregate shocks based on the sequence # of Markov states that the economy experiences @@ -1441,14 +1461,13 @@ def makeAggShkHist(self): TranShkAggHist = np.zeros(sim_periods) for i in range(StateCount): these = i == self.MrkvNow_hist - PermShkAggHist[these] = PermShkAggHistAll[i,these]*self.PermGroFacAgg[i] - TranShkAggHist[these] = TranShkAggHistAll[i,these] + PermShkAggHist[these] = PermShkAggHistAll[i, these]*self.PermGroFacAgg[i] + TranShkAggHist[these] = TranShkAggHistAll[i, these] # Store the histories self.PermShkAggHist = PermShkAggHist self.TranShkAggHist = TranShkAggHist - def makeMrkvHist(self): ''' Makes a history of macroeconomic Markov states, stored in the attribute @@ -1465,32 +1484,32 @@ def makeMrkvHist(self): ------- None ''' - if hasattr(self,'loops_max'): + if hasattr(self, 'loops_max'): loops_max = self.loops_max - else: # Maximum number of loops; final act_T never exceeds act_T*loops_max - loops_max = 10 + else: # Maximum number of loops; final act_T never exceeds act_T*loops_max + loops_max = 10 - state_T_min = 50 # Choose minimum number of periods in each state for a valid Markov sequence - logit_scale = 0.2 # Scaling factor on logit choice shocks when jumping to a new state + state_T_min = 50 # Choose minimum number of periods in each state for a valid Markov sequence + logit_scale = 0.2 # Scaling factor on logit choice shocks when jumping to a new state # Values close to zero make the most underrepresented states very likely to visit, while # large values of logit_scale make any state very likely to be jumped to. # Reset act_T to the level actually specified by the user - if hasattr(self,'act_T_orig'): + if hasattr(self, 'act_T_orig'): act_T = self.act_T_orig - else: # Or store it for the first time + else: # Or store it for the first time self.act_T_orig = self.act_T act_T = self.act_T # Find the long run distribution of Markov states w, v = np.linalg.eig(np.transpose(self.MrkvArray)) idx = (np.abs(w-1.0)).argmin() - x = v[:,idx].astype(float) + x = v[:, idx].astype(float) LR_dstn = (x/np.sum(x)) # Initialize the Markov history and set up transitions - MrkvNow_hist = np.zeros(self.act_T_orig,dtype=int) - cutoffs = np.cumsum(self.MrkvArray,axis=1) + MrkvNow_hist = np.zeros(self.act_T_orig, dtype=int) + cutoffs = np.cumsum(self.MrkvArray, axis=1) loops = 0 go = True MrkvNow = self.MrkvNow_init @@ -1499,35 +1518,35 @@ def makeMrkvHist(self): # Add histories until each state has been visited at least state_T_min times while go: - draws = drawUniform(N=self.act_T_orig,seed=loops) - for s in range(draws.size): # Add act_T_orig more periods + draws = drawUniform(N=self.act_T_orig, seed=loops) + for s in range(draws.size): # Add act_T_orig more periods MrkvNow_hist[t] = MrkvNow - MrkvNow = np.searchsorted(cutoffs[MrkvNow,:],draws[s]) + MrkvNow = np.searchsorted(cutoffs[MrkvNow, :], draws[s]) t += 1 # Calculate the empirical distribution state_T = np.zeros(StateCount) for i in range(StateCount): - state_T[i] = np.sum(MrkvNow_hist==i) + state_T[i] = np.sum(MrkvNow_hist == i) # Check whether each state has been visited state_T_min times if np.all(state_T >= state_T_min): - go = False # If so, terminate the loop + go = False # If so, terminate the loop continue # Choose an underrepresented state to "jump" to - if np.any(state_T == 0): # If any states have *never* been visited, randomly choose one of those + if np.any(state_T == 0): # If any states have *never* been visited, randomly choose one of those never_visited = np.where(np.array(state_T == 0))[0] MrkvNow = np.random.choice(never_visited) - else: # Otherwise, use logit choice probabilities to visit an underrepresented state - emp_dstn = state_T/act_T - ratios = LR_dstn/emp_dstn + else: # Otherwise, use logit choice probabilities to visit an underrepresented state + emp_dstn = state_T/act_T + ratios = LR_dstn/emp_dstn ratios_adj = ratios - np.max(ratios) ratios_exp = np.exp(ratios_adj/logit_scale) ratios_sum = np.sum(ratios_exp) jump_probs = ratios_exp/ratios_sum - cum_probs = np.cumsum(jump_probs) - MrkvNow = np.searchsorted(cum_probs,draws[-1]) + cum_probs = np.cumsum(jump_probs) + MrkvNow = np.searchsorted(cum_probs, draws[-1]) loops += 1 # Make the Markov state history longer by act_T_orig periods @@ -1535,16 +1554,15 @@ def makeMrkvHist(self): go = False print('makeMrkvHist reached maximum number of loops without generating a valid sequence!') else: - MrkvNow_new = np.zeros(self.act_T_orig,dtype=int) - MrkvNow_hist = np.concatenate((MrkvNow_hist,MrkvNow_new)) + MrkvNow_new = np.zeros(self.act_T_orig, dtype=int) + MrkvNow_hist = np.concatenate((MrkvNow_hist, MrkvNow_new)) act_T += self.act_T_orig # Store the results as attributes of self self.MrkvNow_hist = MrkvNow_hist self.act_T = act_T - - def millRule(self,aLvlNow,pLvlNow): + def millRule(self, aLvlNow, pLvlNow): ''' Function to calculate the capital to labor ratio, interest factor, and wage rate based on each agent's current state. Just calls calcRandW() @@ -1553,12 +1571,11 @@ def millRule(self,aLvlNow,pLvlNow): See documentation for calcRandW for more information. ''' MrkvNow = self.MrkvNow_hist[self.Shk_idx] - temp = self.calcRandW(aLvlNow,pLvlNow) - temp(MrkvNow = MrkvNow) + temp = self.calcRandW(aLvlNow, pLvlNow) + temp(MrkvNow=MrkvNow) return temp - - def calcAFunc(self,MaggNow,AaggNow): + def calcAFunc(self, MaggNow, AaggNow): ''' Calculate a new aggregate savings rule based on the history of the aggregate savings and aggregate market resources from a simulation. @@ -1576,30 +1593,30 @@ def calcAFunc(self,MaggNow,AaggNow): (unnamed) : CapDynamicRule Object containing new saving rules for each Markov state. ''' - verbose = True - discard_periods = 200 # Throw out the first T periods to allow the simulation to approach the SS - update_weight = 0.8 # Proportional weight to put on new function vs old function parameters + verbose = self.verbose + discard_periods = self.T_discard # Throw out the first T periods to allow the simulation to approach the SS + update_weight = 1. - self.DampingFac # Proportional weight to put on new function vs old function parameters total_periods = len(MaggNow) # Trim the histories of M_t and A_t and convert them to logs - logAagg = np.log(AaggNow[discard_periods:total_periods]) - logMagg = np.log(MaggNow[discard_periods-1:total_periods-1]) - MrkvHist = self.MrkvNow_hist[discard_periods-1:total_periods-1] + logAagg = np.log(AaggNow[discard_periods:total_periods]) + logMagg = np.log(MaggNow[discard_periods-1:total_periods-1]) + MrkvHist = self.MrkvNow_hist[discard_periods-1:total_periods-1] # For each Markov state, regress A_t on M_t and update the saving rule AFunc_list = [] rSq_list = [] for i in range(self.MrkvArray.shape[0]): these = i == MrkvHist - slope, intercept, r_value, p_value, std_err = stats.linregress(logMagg[these],logAagg[these]) - #if verbose: + slope, intercept, r_value, p_value, std_err = stats.linregress(logMagg[these], logAagg[these]) + # if verbose: # plt.plot(logMagg[these],logAagg[these],'.') # Make a new aggregate savings rule by combining the new regression parameters # with the previous guess intercept = update_weight*intercept + (1.0-update_weight)*self.intercept_prev[i] slope = update_weight*slope + (1.0-update_weight)*self.slope_prev[i] - AFunc_list.append(AggregateSavingRule(intercept,slope)) # Make a new next-period capital function + AFunc_list.append(AggregateSavingRule(intercept, slope)) # Make a new next-period capital function rSq_list.append(r_value**2) # Save the new values as "previous" values for the next iteration @@ -1608,21 +1625,22 @@ def calcAFunc(self,MaggNow,AaggNow): # Plot aggregate resources vs aggregate savings for this run and print the new parameters if verbose: - print('intercept=' + str(self.intercept_prev) + ', slope=' + str(self.slope_prev) + ', r-sq=' + str(rSq_list)) - #plt.show() + print('intercept=' + str(self.intercept_prev) + + ', slope=' + str(self.slope_prev) + ', r-sq=' + str(rSq_list)) + # plt.show() return AggShocksDynamicRule(AFunc_list) -class SmallOpenMarkovEconomy(CobbDouglasMarkovEconomy,SmallOpenEconomy): +class SmallOpenMarkovEconomy(CobbDouglasMarkovEconomy, SmallOpenEconomy): ''' A class for representing a small open economy, where the wage rate and interest rate are exogenously determined by some "global" rate. However, the economy is still subject to aggregate productivity shocks. This version supports a discrete Markov state. All methods in this class inherit from the two parent classes. ''' - def __init__(self,agents=[],tolerance=0.0001,act_T=1000,**kwds): - CobbDouglasMarkovEconomy.__init__(self,agents=agents,tolerance=tolerance,act_T=act_T,**kwds) + def __init__(self, agents=[], tolerance=0.0001, act_T=1000, **kwds): + CobbDouglasMarkovEconomy.__init__(self, agents=agents, tolerance=tolerance, act_T=act_T, **kwds) self.reap_vars = [] self.dyn_vars = [] @@ -1636,11 +1654,11 @@ def makeAggShkDstn(self): def millRule(self): MrkvNow = self.MrkvNow_hist[self.Shk_idx] - temp = SmallOpenEconomy.getAggShocks(self) - temp(MrkvNow = MrkvNow) + temp = SmallOpenEconomy.getAggShocks(self) + temp(MrkvNow=MrkvNow) return temp - def calcDynamics(self,KtoLnow): + def calcDynamics(self, KtoLnow): return HARKobject() def makeAggShkHist(self): @@ -1654,7 +1672,7 @@ class CobbDouglasAggVars(HARKobject): the interest factor, the wage rate, and the aggregate permanent and tran- sitory shocks. ''' - def __init__(self,MaggNow,AaggNow,KtoLnow,RfreeNow,wRteNow,PermShkAggNow,TranShkAggNow): + def __init__(self, MaggNow, AaggNow, KtoLnow, RfreeNow, wRteNow, PermShkAggNow, TranShkAggNow): ''' Make a new instance of CobbDouglasAggVars. @@ -1680,20 +1698,21 @@ def __init__(self,MaggNow,AaggNow,KtoLnow,RfreeNow,wRteNow,PermShkAggNow,TranShk ------- None ''' - self.MaggNow = MaggNow - self.AaggNow = AaggNow - self.KtoLnow = KtoLnow - self.RfreeNow = RfreeNow - self.wRteNow = wRteNow + self.MaggNow = MaggNow + self.AaggNow = AaggNow + self.KtoLnow = KtoLnow + self.RfreeNow = RfreeNow + self.wRteNow = wRteNow self.PermShkAggNow = PermShkAggNow self.TranShkAggNow = TranShkAggNow + class AggregateSavingRule(HARKobject): ''' A class to represent agent beliefs about aggregate saving at the end of this period (AaggNow) as a function of (normalized) aggregate market resources at the beginning of the period (MaggNow). ''' - def __init__(self,intercept,slope): + def __init__(self, intercept, slope): ''' Make a new instance of CapitalEvoRule. @@ -1708,11 +1727,11 @@ def __init__(self,intercept,slope): ------- new instance of CapitalEvoRule ''' - self.intercept = intercept - self.slope = slope - self.distance_criteria = ['slope','intercept'] + self.intercept = intercept + self.slope = slope + self.distance_criteria = ['slope', 'intercept'] - def __call__(self,Mnow): + def __call__(self, Mnow): ''' Evaluates aggregate savings as a function of the aggregate market resources this period. @@ -1733,7 +1752,7 @@ class AggShocksDynamicRule(HARKobject): ''' Just a container class for passing the dynamic rule in the aggregate shocks model to agents. ''' - def __init__(self,AFunc): + def __init__(self, AFunc): ''' Make a new instance of CapDynamicRule. @@ -1753,20 +1772,21 @@ def __init__(self,AFunc): ############################################################################### def main(): - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params from time import clock from HARK.utilities import plotFuncs - mystr = lambda number : "{:.4f}".format(number) - solve_agg_shocks_micro = False # Solve an AggShockConsumerType's microeconomic problem - solve_agg_shocks_market = True # Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy + def mystr(number): return "{:.4f}".format(number) - solve_markov_micro = False # Solve an AggShockMarkovConsumerType's microeconomic problem - solve_markov_market = False # Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy - solve_krusell_smith = True # Solve a simple Krusell-Smith-style two state, two shock model - solve_poly_state = False # Solve a CobbDouglasEconomy with many states, potentially utilizing the "state jumper" + solve_agg_shocks_micro = False # Solve an AggShockConsumerType's microeconomic problem + solve_agg_shocks_market = True # Solve for the equilibrium aggregate saving rule in a CobbDouglasEconomy - ################ EXAMPLE IMPLEMENTATIONS OF AggShockConsumerType ########## + solve_markov_micro = False # Solve an AggShockMarkovConsumerType's microeconomic problem + solve_markov_market = True # Solve for the equilibrium aggregate saving rule in a CobbDouglasMarkovEconomy + solve_krusell_smith = True # Solve a simple Krusell-Smith-style two state, two shock model + solve_poly_state = False # Solve a CobbDouglasEconomy with many states, potentially utilizing the "state jumper" + + # EXAMPLE IMPLEMENTATIONS OF AggShockConsumerType ### if solve_agg_shocks_micro or solve_agg_shocks_market: # Make an aggregate shocks consumer type @@ -1774,8 +1794,8 @@ def main(): AggShockExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - EconomyExample = CobbDouglasEconomy(agents = [AggShockExample],**Params.init_cobb_douglas) - EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks + EconomyExample = CobbDouglasEconomy(agents=[AggShockExample], **Params.init_cobb_douglas) + EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks # Have the consumers inherit relevant objects from the economy AggShockExample.getEconomyData(EconomyExample) @@ -1787,12 +1807,13 @@ def main(): t_end = clock() print('Solving an aggregate shocks consumer took ' + mystr(t_end-t_start) + ' seconds.') print('Consumption function at each aggregate market resources-to-labor ratio gridpoint:') - m_grid = np.linspace(0,10,200) + m_grid = np.linspace(0, 10, 200) AggShockExample.unpackcFunc() for M in AggShockExample.Mgrid.tolist(): mMin = AggShockExample.solution[0].mNrmMin(M) - c_at_this_M = AggShockExample.cFunc[0](m_grid+mMin,M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin,c_at_this_M) + c_at_this_M = AggShockExample.cFunc[0](m_grid+mMin, M*np.ones_like(m_grid)) + plt.plot(m_grid+mMin, c_at_this_M) + plt.ylim(0., None) plt.show() if solve_agg_shocks_market: @@ -1804,18 +1825,19 @@ def main(): print('Solving the "macroeconomic" aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') print('Aggregate savings as a function of aggregate market resources:') - plotFuncs(EconomyExample.AFunc,0,2*EconomyExample.kSS) + plotFuncs(EconomyExample.AFunc, 0, 2*EconomyExample.kSS) print('Consumption function at each aggregate market resources gridpoint (in general equilibrium):') AggShockExample.unpackcFunc() - m_grid = np.linspace(0,10,200) + m_grid = np.linspace(0, 10, 200) AggShockExample.unpackcFunc() for M in AggShockExample.Mgrid.tolist(): mMin = AggShockExample.solution[0].mNrmMin(M) - c_at_this_M = AggShockExample.cFunc[0](m_grid+mMin,M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin,c_at_this_M) + c_at_this_M = AggShockExample.cFunc[0](m_grid+mMin, M*np.ones_like(m_grid)) + plt.plot(m_grid+mMin, c_at_this_M) + plt.ylim(0., None) plt.show() - ######### EXAMPLE IMPLEMENTATIONS OF AggShockMarkovConsumerType ########### + # EXAMPLE IMPLEMENTATIONS OF AggShockMarkovConsumerType # if solve_markov_micro or solve_markov_market or solve_krusell_smith: # Make a Markov aggregate shocks consumer type @@ -1824,9 +1846,11 @@ def main(): AggShockMrkvExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - MrkvEconomyExample = CobbDouglasMarkovEconomy(agents = [AggShockMrkvExample],**Params.init_mrkv_cobb_douglas) - MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks - AggShockMrkvExample.getEconomyData(MrkvEconomyExample) # Have the consumers inherit relevant objects from the economy + MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample], **Params.init_mrkv_cobb_douglas) + MrkvEconomyExample.DampingFac = 0.2 # Turn down damping + MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks + AggShockMrkvExample.getEconomyData( + MrkvEconomyExample) # Have the consumers inherit relevant objects from the economy if solve_markov_micro: # Solve the microeconomic model for the Markov aggregate shocks example type (and display results) @@ -1835,14 +1859,16 @@ def main(): t_end = clock() print('Solving an aggregate shocks Markov consumer took ' + mystr(t_end-t_start) + ' seconds.') - print('Consumption function at each aggregate market resources-to-labor ratio gridpoint (for each macro state):') - m_grid = np.linspace(0,10,200) + print('Consumption function at each aggregate market \ + resources-to-labor ratio gridpoint (for each macro state):') + m_grid = np.linspace(0, 10, 200) AggShockMrkvExample.unpackcFunc() for i in range(2): for M in AggShockMrkvExample.Mgrid.tolist(): mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M) - c_at_this_M = AggShockMrkvExample.cFunc[0][i](m_grid+mMin,M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin,c_at_this_M) + c_at_this_M = AggShockMrkvExample.cFunc[0][i](m_grid+mMin, M*np.ones_like(m_grid)) + plt.plot(m_grid+mMin, c_at_this_M) + plt.ylim(0., None) plt.show() if solve_markov_market: @@ -1853,29 +1879,31 @@ def main(): t_end = clock() print('Solving the "macroeconomic" aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') - print('Aggregate savings as a function of aggregate market resources (for each macro state):') - m_grid = np.linspace(0,10,200) + print('Consumption function at each aggregate market \ + resources-to-labor ratio gridpoint (for each macro state):') + m_grid = np.linspace(0, 10, 200) AggShockMrkvExample.unpackcFunc() for i in range(2): for M in AggShockMrkvExample.Mgrid.tolist(): mMin = AggShockMrkvExample.solution[0].mNrmMin[i](M) - c_at_this_M = AggShockMrkvExample.cFunc[0][i](m_grid+mMin,M*np.ones_like(m_grid)) - plt.plot(m_grid+mMin,c_at_this_M) + c_at_this_M = AggShockMrkvExample.cFunc[0][i](m_grid+mMin, M*np.ones_like(m_grid)) + plt.plot(m_grid+mMin, c_at_this_M) + plt.ylim(0., None) plt.show() if solve_krusell_smith: # Make a Krusell-Smith agent type # NOTE: These agents aren't exactly like KS, as they don't have serially correlated unemployment KSexampleType = deepcopy(AggShockMrkvExample) - KSexampleType.IncomeDstn[0] = [[np.array([0.96,0.04]),np.array([1.0,1.0]),np.array([1.0/0.96,0.0])], - [np.array([0.90,0.10]),np.array([1.0,1.0]),np.array([1.0/0.90,0.0])]] + KSexampleType.IncomeDstn[0] = [[np.array([0.96, 0.04]), np.array([1.0, 1.0]), np.array([1.0/0.96, 0.0])], + [np.array([0.90, 0.10]), np.array([1.0, 1.0]), np.array([1.0/0.90, 0.0])]] # Make a KS economy KSeconomy = deepcopy(MrkvEconomyExample) KSeconomy.agents = [KSexampleType] - KSeconomy.AggShkDstn = [[np.array([1.0]),np.array([1.0]),np.array([1.05])], - [np.array([1.0]),np.array([1.0]),np.array([0.95])]] - KSeconomy.PermGroFacAgg = [1.0,1.0] + KSeconomy.AggShkDstn = [[np.array([1.0]), np.array([1.0]), np.array([1.05])], + [np.array([1.0]), np.array([1.0]), np.array([0.95])]] + KSeconomy.PermGroFacAgg = [1.0, 1.0] KSexampleType.getEconomyData(KSeconomy) KSeconomy.makeAggShkHist() @@ -1886,24 +1914,23 @@ def main(): t_end = clock() print('Solving the Krusell-Smith model took ' + str(t_end - t_start) + ' seconds.') - if solve_poly_state: - StateCount = 15 # Number of Markov states - GrowthAvg = 1.01 # Average permanent income growth factor - GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range - Persistence = 0.90 # Probability of staying in the same Markov state - PermGroFacAgg = np.linspace(GrowthAvg-GrowthWidth,GrowthAvg+GrowthWidth,num=StateCount) + StateCount = 15 # Number of Markov states + GrowthAvg = 1.01 # Average permanent income growth factor + GrowthWidth = 0.02 # PermGroFacAgg deviates from PermGroFacAgg in this range + Persistence = 0.90 # Probability of staying in the same Markov state + PermGroFacAgg = np.linspace(GrowthAvg-GrowthWidth, GrowthAvg+GrowthWidth, num=StateCount) # Make the Markov array with chosen states and persistence - PolyMrkvArray = np.zeros((StateCount,StateCount)) + PolyMrkvArray = np.zeros((StateCount, StateCount)) for i in range(StateCount): for j in range(StateCount): - if i==j: - PolyMrkvArray[i,j] = Persistence - elif (i==(j-1)) or (i==(j+1)): - PolyMrkvArray[i,j] = 0.5*(1.0 - Persistence) - PolyMrkvArray[0,0] += 0.5*(1.0 - Persistence) - PolyMrkvArray[StateCount-1,StateCount-1] += 0.5*(1.0 - Persistence) + if i == j: + PolyMrkvArray[i, j] = Persistence + elif (i == (j-1)) or (i == (j+1)): + PolyMrkvArray[i, j] = 0.5*(1.0 - Persistence) + PolyMrkvArray[0, 0] += 0.5*(1.0 - Persistence) + PolyMrkvArray[StateCount-1, StateCount-1] += 0.5*(1.0 - Persistence) # Make a consumer type to inhabit the economy PolyStateExample = AggShockMarkovConsumerType(**Params.init_agg_mrkv_shocks) @@ -1913,7 +1940,7 @@ def main(): PolyStateExample.cycles = 0 # Make a Cobb-Douglas economy for the agents - PolyStateEconomy = CobbDouglasMarkovEconomy(agents = [PolyStateExample],**Params.init_mrkv_cobb_douglas) + PolyStateEconomy = CobbDouglasMarkovEconomy(agents=[PolyStateExample], **Params.init_mrkv_cobb_douglas) PolyStateEconomy.MrkvArray = PolyMrkvArray PolyStateEconomy.PermGroFacAgg = PermGroFacAgg PolyStateEconomy.PermShkAggStd = StateCount*[0.006] @@ -1922,8 +1949,9 @@ def main(): PolyStateEconomy.intercept_prev = StateCount*[0.0] PolyStateEconomy.update() PolyStateEconomy.makeAggShkDstn() - PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks - PolyStateExample.getEconomyData(PolyStateEconomy) # Have the consumers inherit relevant objects from the economy + PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks + PolyStateExample.getEconomyData( + PolyStateEconomy) # Have the consumers inherit relevant objects from the economy # Solve the many state model t_start = clock() @@ -1932,6 +1960,6 @@ def main(): t_end = clock() print('Solving a model with ' + str(StateCount) + ' states took ' + str(t_end - t_start) + ' seconds.') + if __name__ == '__main__': main() - diff --git a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py index b81bedff7..d2a5f3c58 100644 --- a/HARK/ConsumptionSaving/ConsGenIncProcessModel.py +++ b/HARK/ConsumptionSaving/ConsGenIncProcessModel.py @@ -17,25 +17,26 @@ CRRAutility_invP, CRRAutility_inv, CRRAutilityP_invP,\ getPercentiles from HARK.simulation import drawLognormal, drawDiscrete, drawUniform -from .ConsIndShockModel import ConsIndShockSetup, ConsumerSolution, IndShockConsumerType - -utility = CRRAutility -utilityP = CRRAutilityP -utilityPP = CRRAutilityPP -utilityP_inv = CRRAutilityP_inv -utility_invP = CRRAutility_invP -utility_inv = CRRAutility_inv +from HARK.ConsumptionSaving.ConsIndShockModel import ConsIndShockSetup, ConsumerSolution, IndShockConsumerType + +utility = CRRAutility +utilityP = CRRAutilityP +utilityPP = CRRAutilityPP +utilityP_inv = CRRAutilityP_inv +utility_invP = CRRAutility_invP +utility_inv = CRRAutility_inv utilityP_invP = CRRAutilityP_invP + class ValueFunc2D(HARKobject): ''' A class for representing a value function in a model where persistent income is explicitly included as a state variable. The underlying interpolation is in the space of (m,p) --> u_inv(v); this class "re-curves" to the value function. ''' - distance_criteria = ['func','CRRA'] + distance_criteria = ['func', 'CRRA'] - def __init__(self,vFuncNvrs,CRRA): + def __init__(self, vFuncNvrs, CRRA): ''' Constructor for a new value function object. @@ -55,7 +56,7 @@ def __init__(self,vFuncNvrs,CRRA): self.func = deepcopy(vFuncNvrs) self.CRRA = CRRA - def __call__(self,m,p): + def __call__(self, m, p): ''' Evaluate the value function at given levels of market resources m and persistent income p. @@ -73,7 +74,7 @@ def __call__(self,m,p): Lifetime value of beginning this period with market resources m and persistent income p; has same size as inputs m and p. ''' - return utility(self.func(m,p),gam=self.CRRA) + return utility(self.func(m, p), gam=self.CRRA) class MargValueFunc2D(HARKobject): @@ -83,9 +84,9 @@ class MargValueFunc2D(HARKobject): This is copied from ConsAggShockModel, with the second state variable re- labeled as persistent income p. ''' - distance_criteria = ['cFunc','CRRA'] + distance_criteria = ['cFunc', 'CRRA'] - def __init__(self,cFunc,CRRA): + def __init__(self, cFunc, CRRA): ''' Constructor for a new marginal value function object. @@ -107,7 +108,7 @@ def __init__(self,cFunc,CRRA): self.cFunc = deepcopy(cFunc) self.CRRA = CRRA - def __call__(self,m,p): + def __call__(self, m, p): ''' Evaluate the marginal value function at given levels of market resources m and persistent income p. @@ -126,9 +127,9 @@ def __call__(self,m,p): market resources m and persistent income p; has same size as inputs m and p. ''' - return utilityP(self.cFunc(m,p),gam=self.CRRA) + return utilityP(self.cFunc(m, p), gam=self.CRRA) - def derivativeX(self,m,p): + def derivativeX(self, m, p): ''' Evaluate the first derivative with respect to market resources of the marginal value function at given levels of market resources m and per- @@ -148,9 +149,9 @@ def derivativeX(self,m,p): with market resources m and persistent income p; has same size as inputs m and p. ''' - c = self.cFunc(m,p) - MPC = self.cFunc.derivativeX(m,p) - return MPC*utilityPP(c,gam=self.CRRA) + c = self.cFunc(m, p) + MPC = self.cFunc.derivativeX(m, p) + return MPC*utilityPP(c, gam=self.CRRA) class MargMargValueFunc2D(HARKobject): @@ -158,9 +159,9 @@ class MargMargValueFunc2D(HARKobject): A class for representing a marginal marginal value function in models where the standard envelope condition of v'(m,p) = u'(c(m,p)) holds (with CRRA utility). ''' - distance_criteria = ['cFunc','CRRA'] + distance_criteria = ['cFunc', 'CRRA'] - def __init__(self,cFunc,CRRA): + def __init__(self, cFunc, CRRA): ''' Constructor for a new marginal marginal value function object. @@ -182,7 +183,7 @@ def __init__(self,cFunc,CRRA): self.cFunc = deepcopy(cFunc) self.CRRA = CRRA - def __call__(self,m,p): + def __call__(self, m, p): ''' Evaluate the marginal marginal value function at given levels of market resources m and persistent income p. @@ -200,16 +201,16 @@ def __call__(self,m,p): Marginal marginal value of beginning this period with market resources m and persistent income p; has same size as inputs. ''' - c = self.cFunc(m,p) - MPC = self.cFunc.derivativeX(m,p) - return MPC*utilityPP(c,gam=self.CRRA) + c = self.cFunc(m, p) + MPC = self.cFunc.derivativeX(m, p) + return MPC*utilityPP(c, gam=self.CRRA) class pLvlFuncAR1(HARKobject): ''' A class for representing AR1-style persistent income growth functions. ''' - def __init__(self,pLogMean,PermGroFac,Corr): + def __init__(self, pLogMean, PermGroFac, Corr): ''' Make a new pLvlFuncAR1 instance. @@ -230,7 +231,7 @@ def __init__(self,pLogMean,PermGroFac,Corr): self.LogGroFac = np.log(PermGroFac) self.Corr = Corr - def __call__(self,pLvlNow): + def __call__(self, pLvlNow): ''' Returns expected persistent income level next period as a function of this period's persistent income level. @@ -260,8 +261,8 @@ class ConsGenIncProcessSolver(ConsIndShockSetup): current persistent income into expected next period persistent income (subject to shocks). ''' - def __init__(self,solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree, - pLvlNextFunc,BoroCnstArt,aXtraGrid,pLvlGrid,vFuncBool,CubicBool): + def __init__(self, solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, + pLvlNextFunc, BoroCnstArt, aXtraGrid, pLvlGrid, vFuncBool, CubicBool): ''' Constructor for a new solver for a one period problem with idiosyncratic shocks to persistent and transitory income, with persistent income tracked @@ -305,12 +306,12 @@ def __init__(self,solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree, ------- None ''' - self.assignParameters(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree,pLvlNextFunc, - BoroCnstArt,aXtraGrid,pLvlGrid,vFuncBool,CubicBool) + self.assignParameters(solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, pLvlNextFunc, + BoroCnstArt, aXtraGrid, pLvlGrid, vFuncBool, CubicBool) self.defUtilityFuncs() - def assignParameters(self,solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree, - pLvlNextFunc,BoroCnstArt,aXtraGrid,pLvlGrid,vFuncBool,CubicBool): + def assignParameters(self, solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, + pLvlNextFunc, BoroCnstArt, aXtraGrid, pLvlGrid, vFuncBool, CubicBool): ''' Assigns inputs as attributes of self for use by other methods @@ -352,12 +353,14 @@ def assignParameters(self,solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree, ------- none ''' - ConsIndShockSetup.assignParameters(self,solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree, - 0.0,BoroCnstArt,aXtraGrid,vFuncBool,CubicBool) # dummy value for PermGroFac + ConsIndShockSetup.assignParameters(self, solution_next, IncomeDstn, + LivPrb, DiscFac, CRRA, Rfree, + 0.0, BoroCnstArt, aXtraGrid, + vFuncBool, CubicBool) # dummy value for PermGroFac self.pLvlNextFunc = pLvlNextFunc self.pLvlGrid = pLvlGrid - def setAndUpdateValues(self,solution_next,IncomeDstn,LivPrb,DiscFac): + def setAndUpdateValues(self, solution_next, IncomeDstn, LivPrb, DiscFac): ''' Unpacks some of the inputs (and calculates simple objects based on them), storing the results in self for use by other methods. These include: @@ -386,18 +389,21 @@ def setAndUpdateValues(self,solution_next,IncomeDstn,LivPrb,DiscFac): None ''' # Run basic version of this method - ConsIndShockSetup.setAndUpdateValues(self,solution_next,IncomeDstn,LivPrb,DiscFac) + ConsIndShockSetup.setAndUpdateValues(self, solution_next, IncomeDstn, LivPrb, DiscFac) self.mLvlMinNext = solution_next.mLvlMin # Replace normalized human wealth (scalar) with human wealth level as function of persistent income self.hNrmNow = 0.0 - pLvlCount = self.pLvlGrid.size - IncShkCount = self.PermShkValsNext.size - pLvlNext = np.tile(self.pLvlNextFunc(self.pLvlGrid),(IncShkCount,1))*np.tile(self.PermShkValsNext,(pLvlCount,1)).transpose() - hLvlGrid = 1.0/self.Rfree*np.sum((np.tile(self.TranShkValsNext,(pLvlCount,1)).transpose()*pLvlNext + solution_next.hLvl(pLvlNext))*np.tile(self.ShkPrbsNext,(pLvlCount,1)).transpose(),axis=0) - self.hLvlNow = LinearInterp(np.insert(self.pLvlGrid,0,0.0),np.insert(hLvlGrid,0,0.0)) + pLvlCount = self.pLvlGrid.size + IncShkCount = self.PermShkValsNext.size + pLvlNext = np.tile(self.pLvlNextFunc(self.pLvlGrid), (IncShkCount, 1))*np.tile(self.PermShkValsNext, + (pLvlCount, 1)).transpose() + hLvlGrid = 1.0/self.Rfree*np.sum((np.tile(self.TranShkValsNext, (pLvlCount, 1)) + .transpose()*pLvlNext + solution_next.hLvl(pLvlNext)) * + np.tile(self.ShkPrbsNext, (pLvlCount, 1)).transpose(), axis=0) + self.hLvlNow = LinearInterp(np.insert(self.pLvlGrid, 0, 0.0), np.insert(hLvlGrid, 0, 0.0)) - def defBoroCnst(self,BoroCnstArt): + def defBoroCnst(self, BoroCnstArt): ''' Defines the constrained portion of the consumption function as cFuncNowCnst, an attribute of self. @@ -417,26 +423,27 @@ def defBoroCnst(self,BoroCnstArt): # Make temporary grids of income shocks and next period income values ShkCount = self.TranShkValsNext.size pLvlCount = self.pLvlGrid.size - PermShkVals_temp = np.tile(np.reshape(self.PermShkValsNext,(1,ShkCount)),(pLvlCount,1)) - TranShkVals_temp = np.tile(np.reshape(self.TranShkValsNext,(1,ShkCount)),(pLvlCount,1)) - pLvlNext_temp = np.tile(np.reshape(self.pLvlNextFunc(self.pLvlGrid),(pLvlCount,1)),(1,ShkCount))*PermShkVals_temp + PermShkVals_temp = np.tile(np.reshape(self.PermShkValsNext, (1, ShkCount)), (pLvlCount, 1)) + TranShkVals_temp = np.tile(np.reshape(self.TranShkValsNext, (1, ShkCount)), (pLvlCount, 1)) + pLvlNext_temp = np.tile(np.reshape(self.pLvlNextFunc(self.pLvlGrid), + (pLvlCount, 1)), (1, ShkCount))*PermShkVals_temp # Find the natural borrowing constraint for each persistent income level aLvlMin_candidates = (self.mLvlMinNext(pLvlNext_temp) - TranShkVals_temp*pLvlNext_temp)/self.Rfree - aLvlMinNow = np.max(aLvlMin_candidates,axis=1) - self.BoroCnstNat = LinearInterp(np.insert(self.pLvlGrid,0,0.0),np.insert(aLvlMinNow,0,0.0)) + aLvlMinNow = np.max(aLvlMin_candidates, axis=1) + self.BoroCnstNat = LinearInterp(np.insert(self.pLvlGrid, 0, 0.0), np.insert(aLvlMinNow, 0, 0.0)) # Define the minimum allowable mLvl by pLvl as the greater of the natural and artificial borrowing constraints if self.BoroCnstArt is not None: - self.BoroCnstArt = LinearInterp(np.array([0.0,1.0]),np.array([0.0,self.BoroCnstArt])) - self.mLvlMinNow = UpperEnvelope(self.BoroCnstArt,self.BoroCnstNat) + self.BoroCnstArt = LinearInterp(np.array([0.0, 1.0]), np.array([0.0, self.BoroCnstArt])) + self.mLvlMinNow = UpperEnvelope(self.BoroCnstArt, self.BoroCnstNat) else: self.mLvlMinNow = self.BoroCnstNat # Define the constrained consumption function as "consume all" shifted by mLvlMin - cFuncNowCnstBase = BilinearInterp(np.array([[0.,0.],[1.,1.]]),np.array([0.0,1.0]),np.array([0.0,1.0])) - self.cFuncNowCnst = VariableLowerBoundFunc2D(cFuncNowCnstBase,self.mLvlMinNow) - + cFuncNowCnstBase = BilinearInterp(np.array([[0., 0.], [1., 1.]]), + np.array([0.0, 1.0]), np.array([0.0, 1.0])) + self.cFuncNowCnst = VariableLowerBoundFunc2D(cFuncNowCnstBase, self.mLvlMinNow) def prepareToCalcEndOfPrdvP(self): ''' @@ -456,31 +463,31 @@ def prepareToCalcEndOfPrdvP(self): pLvlNow : np.array 2D array of persistent income levels this period. ''' - ShkCount = self.TranShkValsNext.size - pLvlCount = self.pLvlGrid.size - aNrmCount = self.aXtraGrid.size - pLvlNow = np.tile(self.pLvlGrid,(aNrmCount,1)).transpose() - aLvlNow = np.tile(self.aXtraGrid,(pLvlCount,1))*pLvlNow + self.BoroCnstNat(pLvlNow) - pLvlNow_tiled = np.tile(pLvlNow,(ShkCount,1,1)) - aLvlNow_tiled = np.tile(aLvlNow,(ShkCount,1,1)) # shape = (ShkCount,pLvlCount,aNrmCount) + ShkCount = self.TranShkValsNext.size + pLvlCount = self.pLvlGrid.size + aNrmCount = self.aXtraGrid.size + pLvlNow = np.tile(self.pLvlGrid, (aNrmCount, 1)).transpose() + aLvlNow = np.tile(self.aXtraGrid, (pLvlCount, 1))*pLvlNow + self.BoroCnstNat(pLvlNow) + pLvlNow_tiled = np.tile(pLvlNow, (ShkCount, 1, 1)) + aLvlNow_tiled = np.tile(aLvlNow, (ShkCount, 1, 1)) # shape = (ShkCount,pLvlCount,aNrmCount) if self.pLvlGrid[0] == 0.0: # aLvl turns out badly if pLvl is 0 at bottom - aLvlNow[0,:] = self.aXtraGrid - aLvlNow_tiled[:,0,:] = np.tile(self.aXtraGrid,(ShkCount,1)) + aLvlNow[0, :] = self.aXtraGrid + aLvlNow_tiled[:, 0, :] = np.tile(self.aXtraGrid, (ShkCount, 1)) # Tile arrays of the income shocks and put them into useful shapes - PermShkVals_tiled = np.transpose(np.tile(self.PermShkValsNext,(aNrmCount,pLvlCount,1)),(2,1,0)) - TranShkVals_tiled = np.transpose(np.tile(self.TranShkValsNext,(aNrmCount,pLvlCount,1)),(2,1,0)) - ShkPrbs_tiled = np.transpose(np.tile(self.ShkPrbsNext,(aNrmCount,pLvlCount,1)),(2,1,0)) + PermShkVals_tiled = np.transpose(np.tile(self.PermShkValsNext, (aNrmCount, pLvlCount, 1)), (2, 1, 0)) + TranShkVals_tiled = np.transpose(np.tile(self.TranShkValsNext, (aNrmCount, pLvlCount, 1)), (2, 1, 0)) + ShkPrbs_tiled = np.transpose(np.tile(self.ShkPrbsNext, (aNrmCount, pLvlCount, 1)), (2, 1, 0)) # Get cash on hand next period pLvlNext = self.pLvlNextFunc(pLvlNow_tiled)*PermShkVals_tiled mLvlNext = self.Rfree*aLvlNow_tiled + pLvlNext*TranShkVals_tiled # Store and report the results - self.ShkPrbs_temp = ShkPrbs_tiled - self.pLvlNext = pLvlNext - self.mLvlNext = mLvlNext - self.aLvlNow = aLvlNow + self.ShkPrbs_temp = ShkPrbs_tiled + self.pLvlNext = pLvlNext + self.mLvlNext = mLvlNext + self.aLvlNow = aLvlNow return aLvlNow, pLvlNow def calcEndOfPrdvP(self): @@ -499,10 +506,11 @@ def calcEndOfPrdvP(self): EndOfPrdVP : np.array A 2D array of end-of-period marginal value of assets. ''' - EndOfPrdvP = self.DiscFacEff*self.Rfree*np.sum(self.vPfuncNext(self.mLvlNext,self.pLvlNext)*self.ShkPrbs_temp,axis=0) + EndOfPrdvP = self.DiscFacEff*self.Rfree*np.sum(self.vPfuncNext(self.mLvlNext, self.pLvlNext) * + self.ShkPrbs_temp, axis=0) return EndOfPrdvP - def makeEndOfPrdvFunc(self,EndOfPrdvP): + def makeEndOfPrdvFunc(self, EndOfPrdvP): ''' Construct the end-of-period value function for this period, storing it as an attribute of self for use by other methods. @@ -517,30 +525,36 @@ def makeEndOfPrdvFunc(self,EndOfPrdvP): ------- none ''' - vLvlNext = self.vFuncNext(self.mLvlNext,self.pLvlNext) # value in many possible future states - EndOfPrdv = self.DiscFacEff*np.sum(vLvlNext*self.ShkPrbs_temp,axis=0) # expected value, averaging across states - EndOfPrdvNvrs = self.uinv(EndOfPrdv) # value transformed through inverse utility - EndOfPrdvNvrsP = EndOfPrdvP*self.uinvP(EndOfPrdv) + vLvlNext = self.vFuncNext(self.mLvlNext, self.pLvlNext) # value in many possible future states + EndOfPrdv = self.DiscFacEff*np.sum( + vLvlNext*self.ShkPrbs_temp, axis=0) # expected value, averaging across states + EndOfPrdvNvrs = self.uinv(EndOfPrdv) # value transformed through inverse utility + EndOfPrdvNvrsP = EndOfPrdvP*self.uinvP(EndOfPrdv) # Add points at mLvl=zero - EndOfPrdvNvrs = np.concatenate((np.zeros((self.pLvlGrid.size,1)),EndOfPrdvNvrs),axis=1) - if hasattr(self,'MedShkDstn'): - EndOfPrdvNvrsP = np.concatenate((np.zeros((self.pLvlGrid.size,1)),EndOfPrdvNvrsP),axis=1) + EndOfPrdvNvrs = np.concatenate((np.zeros((self.pLvlGrid.size, 1)), EndOfPrdvNvrs), axis=1) + if hasattr(self, 'MedShkDstn'): + EndOfPrdvNvrsP = np.concatenate((np.zeros((self.pLvlGrid.size, 1)), EndOfPrdvNvrsP), axis=1) else: - EndOfPrdvNvrsP = np.concatenate((np.reshape(EndOfPrdvNvrsP[:,0],(self.pLvlGrid.size,1)),EndOfPrdvNvrsP),axis=1) # This is a very good approximation, vNvrsPP = 0 at the asset minimum - aLvl_temp = np.concatenate((np.reshape(self.BoroCnstNat(self.pLvlGrid),(self.pLvlGrid.size,1)),self.aLvlNow),axis=1) + EndOfPrdvNvrsP = np.concatenate((np.reshape(EndOfPrdvNvrsP[:, 0], + (self.pLvlGrid.size, 1)), + EndOfPrdvNvrsP), axis=1) + # This is a very good approximation, vNvrsPP = 0 at the asset minimum + aLvl_temp = np.concatenate((np.reshape(self.BoroCnstNat(self.pLvlGrid), + (self.pLvlGrid.size, 1)), self.aLvlNow), axis=1) # Make an end-of-period value function for each persistent income level in the grid EndOfPrdvNvrsFunc_list = [] for p in range(self.pLvlGrid.size): - EndOfPrdvNvrsFunc_list.append(CubicInterp(aLvl_temp[p,:]-self.BoroCnstNat(self.pLvlGrid[p]),EndOfPrdvNvrs[p,:],EndOfPrdvNvrsP[p,:])) - EndOfPrdvNvrsFuncBase = LinearInterpOnInterp1D(EndOfPrdvNvrsFunc_list,self.pLvlGrid) + EndOfPrdvNvrsFunc_list.append(CubicInterp(aLvl_temp[p, :]-self.BoroCnstNat(self.pLvlGrid[p]), + EndOfPrdvNvrs[p, :], EndOfPrdvNvrsP[p, :])) + EndOfPrdvNvrsFuncBase = LinearInterpOnInterp1D(EndOfPrdvNvrsFunc_list, self.pLvlGrid) # Re-adjust the combined end-of-period value function to account for the natural borrowing constraint shifter - EndOfPrdvNvrsFunc = VariableLowerBoundFunc2D(EndOfPrdvNvrsFuncBase,self.BoroCnstNat) - self.EndOfPrdvFunc = ValueFunc2D(EndOfPrdvNvrsFunc,self.CRRA) + EndOfPrdvNvrsFunc = VariableLowerBoundFunc2D(EndOfPrdvNvrsFuncBase, self.BoroCnstNat) + self.EndOfPrdvFunc = ValueFunc2D(EndOfPrdvNvrsFunc, self.CRRA) - def getPointsForInterpolation(self,EndOfPrdvP,aLvlNow): + def getPointsForInterpolation(self, EndOfPrdvP, aLvlNow): ''' Finds endogenous interpolation points (c,m) for the consumption function. @@ -563,17 +577,18 @@ def getPointsForInterpolation(self,EndOfPrdvP,aLvlNow): mLvlNow = cLvlNow + aLvlNow # Limiting consumption is zero as m approaches mNrmMin - c_for_interpolation = np.concatenate((np.zeros((self.pLvlGrid.size,1)),cLvlNow),axis=-1) - m_for_interpolation = np.concatenate((self.BoroCnstNat(np.reshape(self.pLvlGrid,(self.pLvlGrid.size,1))),mLvlNow),axis=-1) + c_for_interpolation = np.concatenate((np.zeros((self.pLvlGrid.size, 1)), cLvlNow), axis=-1) + m_for_interpolation = np.concatenate((self.BoroCnstNat(np.reshape(self.pLvlGrid, + (self.pLvlGrid.size, 1))), mLvlNow), axis=-1) # Limiting consumption is MPCmin*mLvl as p approaches 0 - m_temp = np.reshape(m_for_interpolation[0,:],(1,m_for_interpolation.shape[1])) - m_for_interpolation = np.concatenate((m_temp,m_for_interpolation),axis=0) - c_for_interpolation = np.concatenate((self.MPCminNow*m_temp,c_for_interpolation),axis=0) + m_temp = np.reshape(m_for_interpolation[0, :], (1, m_for_interpolation.shape[1])) + m_for_interpolation = np.concatenate((m_temp, m_for_interpolation), axis=0) + c_for_interpolation = np.concatenate((self.MPCminNow*m_temp, c_for_interpolation), axis=0) return c_for_interpolation, m_for_interpolation - def usePointsForInterpolation(self,cLvl,mLvl,pLvl,interpolator): + def usePointsForInterpolation(self, cLvl, mLvl, pLvl, interpolator): ''' Constructs a basic solution for this period, including the consumption function and marginal value function. @@ -596,10 +611,10 @@ def usePointsForInterpolation(self,cLvl,mLvl,pLvl,interpolator): consumption function, marginal value function, and minimum m. ''' # Construct the unconstrained consumption function - cFuncNowUnc = interpolator(mLvl,pLvl,cLvl) + cFuncNowUnc = interpolator(mLvl, pLvl, cLvl) # Combine the constrained and unconstrained functions into the true consumption function - cFuncNow = LowerEnvelope2D(cFuncNowUnc,self.cFuncNowCnst) + cFuncNow = LowerEnvelope2D(cFuncNowUnc, self.cFuncNowCnst) # Make the marginal value function vPfuncNow = self.makevPfunc(cFuncNow) @@ -608,7 +623,7 @@ def usePointsForInterpolation(self,cLvl,mLvl,pLvl,interpolator): solution_now = ConsumerSolution(cFunc=cFuncNow, vPfunc=vPfuncNow, mNrmMin=0.0) return solution_now - def makevPfunc(self,cFunc): + def makevPfunc(self, cFunc): ''' Constructs the marginal value function for this period. @@ -623,10 +638,10 @@ def makevPfunc(self,cFunc): vPfunc : function Marginal value (of market resources) function for this period. ''' - vPfunc = MargValueFunc2D(cFunc,self.CRRA) + vPfunc = MargValueFunc2D(cFunc, self.CRRA) return vPfunc - def makevFunc(self,solution): + def makevFunc(self, solution): ''' Creates the value function for this period, defined over market resources m and persistent income p. self must have the attribute EndOfPrdvFunc in @@ -648,42 +663,45 @@ def makevFunc(self,solution): pSize = self.pLvlGrid.size # Compute expected value and marginal value on a grid of market resources - pLvl_temp = np.tile(self.pLvlGrid,(mSize,1)) # Tile pLvl across m values - mLvl_temp = np.tile(self.mLvlMinNow(self.pLvlGrid),(mSize,1)) + np.tile(np.reshape(self.aXtraGrid,(mSize,1)),(1,pSize))*pLvl_temp - cLvlNow = solution.cFunc(mLvl_temp,pLvl_temp) - aLvlNow = mLvl_temp - cLvlNow - vNow = self.u(cLvlNow) + self.EndOfPrdvFunc(aLvlNow,pLvl_temp) - vPnow = self.uP(cLvlNow) + pLvl_temp = np.tile(self.pLvlGrid, (mSize, 1)) # Tile pLvl across m values + mLvl_temp = np.tile(self.mLvlMinNow(self.pLvlGrid), (mSize, 1)) +\ + np.tile(np.reshape(self.aXtraGrid, (mSize, 1)), (1, pSize))*pLvl_temp + cLvlNow = solution.cFunc(mLvl_temp, pLvl_temp) + aLvlNow = mLvl_temp - cLvlNow + vNow = self.u(cLvlNow) + self.EndOfPrdvFunc(aLvlNow, pLvl_temp) + vPnow = self.uP(cLvlNow) # Calculate pseudo-inverse value and its first derivative (wrt mLvl) - vNvrs = self.uinv(vNow) # value transformed through inverse utility - vNvrsP = vPnow*self.uinvP(vNow) + vNvrs = self.uinv(vNow) # value transformed through inverse utility + vNvrsP = vPnow*self.uinvP(vNow) # Add data at the lower bound of m - mLvl_temp = np.concatenate((np.reshape(self.mLvlMinNow(self.pLvlGrid),(1,pSize)),mLvl_temp),axis=0) - vNvrs = np.concatenate((np.zeros((1,pSize)),vNvrs),axis=0) - vNvrsP = np.concatenate((np.reshape(vNvrsP[0,:],(1,vNvrsP.shape[1])),vNvrsP),axis=0) + mLvl_temp = np.concatenate((np.reshape(self.mLvlMinNow(self.pLvlGrid), (1, pSize)), mLvl_temp), axis=0) + vNvrs = np.concatenate((np.zeros((1, pSize)), vNvrs), axis=0) + vNvrsP = np.concatenate((np.reshape(vNvrsP[0, :], (1, vNvrsP.shape[1])), vNvrsP), axis=0) # Add data at the lower bound of p - MPCminNvrs = self.MPCminNow**(-self.CRRA/(1.0-self.CRRA)) - m_temp = np.reshape(mLvl_temp[:,0],(mSize+1,1)) - mLvl_temp = np.concatenate((m_temp,mLvl_temp),axis=1) - vNvrs = np.concatenate((MPCminNvrs*m_temp,vNvrs),axis=1) - vNvrsP = np.concatenate((MPCminNvrs*np.ones((mSize+1,1)),vNvrsP),axis=1) + MPCminNvrs = self.MPCminNow**(-self.CRRA/(1.0-self.CRRA)) + m_temp = np.reshape(mLvl_temp[:, 0], (mSize+1, 1)) + mLvl_temp = np.concatenate((m_temp, mLvl_temp), axis=1) + vNvrs = np.concatenate((MPCminNvrs*m_temp, vNvrs), axis=1) + vNvrsP = np.concatenate((MPCminNvrs*np.ones((mSize+1, 1)), vNvrsP), axis=1) # Construct the pseudo-inverse value function vNvrsFunc_list = [] for j in range(pSize+1): - pLvl = np.insert(self.pLvlGrid,0,0.0)[j] - vNvrsFunc_list.append(CubicInterp(mLvl_temp[:,j]-self.mLvlMinNow(pLvl),vNvrs[:,j],vNvrsP[:,j],MPCminNvrs*self.hLvlNow(pLvl),MPCminNvrs)) - vNvrsFuncBase = LinearInterpOnInterp1D(vNvrsFunc_list,np.insert(self.pLvlGrid,0,0.0)) # Value function "shifted" - vNvrsFuncNow = VariableLowerBoundFunc2D(vNvrsFuncBase,self.mLvlMinNow) + pLvl = np.insert(self.pLvlGrid, 0, 0.0)[j] + vNvrsFunc_list.append(CubicInterp(mLvl_temp[:, j]-self.mLvlMinNow(pLvl), + vNvrs[:, j], vNvrsP[:, j], MPCminNvrs*self.hLvlNow(pLvl), MPCminNvrs)) + vNvrsFuncBase = LinearInterpOnInterp1D(vNvrsFunc_list, + np.insert(self.pLvlGrid, 0, 0.0)) # Value function "shifted" + vNvrsFuncNow = VariableLowerBoundFunc2D(vNvrsFuncBase, self.mLvlMinNow) # "Re-curve" the pseudo-inverse value function into the value function - vFuncNow = ValueFunc2D(vNvrsFuncNow,self.CRRA) + vFuncNow = ValueFunc2D(vNvrsFuncNow, self.CRRA) return vFuncNow - def makeBasicSolution(self,EndOfPrdvP,aLvl,pLvl,interpolator): + def makeBasicSolution(self, EndOfPrdvP, aLvl, pLvl, interpolator): ''' Given end of period assets and end of period marginal value, construct the basic solution for this period. @@ -707,14 +725,13 @@ def makeBasicSolution(self,EndOfPrdvP,aLvl,pLvl,interpolator): The solution to this period's consumption-saving problem, with a consumption function, marginal value function, and minimum m. ''' - cLvl,mLvl = self.getPointsForInterpolation(EndOfPrdvP,aLvl) - pLvl_temp = np.concatenate((np.reshape(self.pLvlGrid,(self.pLvlGrid.size,1)),pLvl),axis=-1) - pLvl_temp = np.concatenate((np.zeros((1,mLvl.shape[1])),pLvl_temp)) - solution_now = self.usePointsForInterpolation(cLvl,mLvl,pLvl_temp,interpolator) + cLvl, mLvl = self.getPointsForInterpolation(EndOfPrdvP, aLvl) + pLvl_temp = np.concatenate((np.reshape(self.pLvlGrid, (self.pLvlGrid.size, 1)), pLvl), axis=-1) + pLvl_temp = np.concatenate((np.zeros((1, mLvl.shape[1])), pLvl_temp)) + solution_now = self.usePointsForInterpolation(cLvl, mLvl, pLvl_temp, interpolator) return solution_now - - def makeLinearcFunc(self,mLvl,pLvl,cLvl): + def makeLinearcFunc(self, mLvl, pLvl, cLvl): ''' Makes a quasi-bilinear interpolation to represent the (unconstrained) consumption function. @@ -733,21 +750,24 @@ def makeLinearcFunc(self,mLvl,pLvl,cLvl): cFuncUnc : LinearInterp The unconstrained consumption function for this period. ''' - cFunc_by_pLvl_list = [] # list of consumption functions for each pLvl + cFunc_by_pLvl_list = [] # list of consumption functions for each pLvl for j in range(pLvl.shape[0]): - pLvl_j = pLvl[j,0] - m_temp = mLvl[j,:] - self.BoroCnstNat(pLvl_j) - c_temp = cLvl[j,:] # Make a linear consumption function for this pLvl + pLvl_j = pLvl[j, 0] + m_temp = mLvl[j, :] - self.BoroCnstNat(pLvl_j) + c_temp = cLvl[j, :] # Make a linear consumption function for this pLvl if pLvl_j > 0: - cFunc_by_pLvl_list.append(LinearInterp(m_temp,c_temp,lower_extrap=True,slope_limit=self.MPCminNow,intercept_limit=self.MPCminNow*self.hLvlNow(pLvl_j))) + cFunc_by_pLvl_list.append(LinearInterp(m_temp, c_temp, lower_extrap=True, + slope_limit=self.MPCminNow, + intercept_limit=self.MPCminNow*self.hLvlNow(pLvl_j))) else: - cFunc_by_pLvl_list.append(LinearInterp(m_temp,c_temp,lower_extrap=True)) - pLvl_list = pLvl[:,0] - cFuncUncBase = LinearInterpOnInterp1D(cFunc_by_pLvl_list,pLvl_list) # Combine all linear cFuncs - cFuncUnc = VariableLowerBoundFunc2D(cFuncUncBase,self.BoroCnstNat) # Re-adjust for natural borrowing constraint (as lower bound) + cFunc_by_pLvl_list.append(LinearInterp(m_temp, c_temp, lower_extrap=True)) + pLvl_list = pLvl[:, 0] + cFuncUncBase = LinearInterpOnInterp1D(cFunc_by_pLvl_list, pLvl_list) # Combine all linear cFuncs + cFuncUnc = VariableLowerBoundFunc2D( + cFuncUncBase, self.BoroCnstNat) # Re-adjust for natural borrowing constraint (as lower bound) return cFuncUnc - def makeCubiccFunc(self,mLvl,pLvl,cLvl): + def makeCubiccFunc(self, mLvl, pLvl, cLvl): ''' Makes a quasi-cubic spline interpolation of the unconstrained consumption function for this period. Function is cubic splines with respect to mLvl, @@ -768,29 +788,35 @@ def makeCubiccFunc(self,mLvl,pLvl,cLvl): The unconstrained consumption function for this period. ''' # Calculate the MPC at each gridpoint - EndOfPrdvPP = self.DiscFacEff*self.Rfree*self.Rfree*np.sum(self.vPPfuncNext(self.mLvlNext,self.pLvlNext)*self.ShkPrbs_temp,axis=0) - dcda = EndOfPrdvPP/self.uPP(np.array(cLvl[1:,1:])) - MPC = dcda/(dcda+1.) - MPC = np.concatenate((np.reshape(MPC[:,0],(MPC.shape[0],1)),MPC),axis=1) # Stick an extra MPC value at bottom; MPCmax doesn't work - MPC = np.concatenate((self.MPCminNow*np.ones((1,self.aXtraGrid.size+1)),MPC),axis=0) + EndOfPrdvPP = self.DiscFacEff*self.Rfree*self.Rfree*np.sum( + self.vPPfuncNext(self.mLvlNext, self.pLvlNext)*self.ShkPrbs_temp, axis=0) + dcda = EndOfPrdvPP/self.uPP(np.array(cLvl[1:, 1:])) + MPC = dcda/(dcda+1.) + MPC = np.concatenate((np.reshape(MPC[:, 0], + (MPC.shape[0], 1)), MPC), axis=1) + # Stick an extra MPC value at bottom; MPCmax doesn't work + MPC = np.concatenate((self.MPCminNow*np.ones((1, self.aXtraGrid.size+1)), MPC), axis=0) # Make cubic consumption function with respect to mLvl for each persistent income level - cFunc_by_pLvl_list = [] # list of consumption functions for each pLvl + cFunc_by_pLvl_list = [] # list of consumption functions for each pLvl for j in range(pLvl.shape[0]): - pLvl_j = pLvl[j,0] - m_temp = mLvl[j,:] - self.BoroCnstNat(pLvl_j) - c_temp = cLvl[j,:] # Make a cubic consumption function for this pLvl - MPC_temp = MPC[j,:] + pLvl_j = pLvl[j, 0] + m_temp = mLvl[j, :] - self.BoroCnstNat(pLvl_j) + c_temp = cLvl[j, :] # Make a cubic consumption function for this pLvl + MPC_temp = MPC[j, :] if pLvl_j > 0: - cFunc_by_pLvl_list.append(CubicInterp(m_temp,c_temp,MPC_temp,lower_extrap=True,slope_limit=self.MPCminNow,intercept_limit=self.MPCminNow*self.hLvlNow(pLvl_j))) - else: # When pLvl=0, cFunc is linear - cFunc_by_pLvl_list.append(LinearInterp(m_temp,c_temp,lower_extrap=True)) - pLvl_list = pLvl[:,0] - cFuncUncBase = LinearInterpOnInterp1D(cFunc_by_pLvl_list,pLvl_list) # Combine all linear cFuncs - cFuncUnc = VariableLowerBoundFunc2D(cFuncUncBase,self.BoroCnstNat) # Re-adjust for lower bound of natural borrowing constraint + cFunc_by_pLvl_list.append(CubicInterp( + m_temp, c_temp, MPC_temp, lower_extrap=True, + slope_limit=self.MPCminNow, intercept_limit=self.MPCminNow*self.hLvlNow(pLvl_j))) + else: # When pLvl=0, cFunc is linear + cFunc_by_pLvl_list.append(LinearInterp(m_temp, c_temp, lower_extrap=True)) + pLvl_list = pLvl[:, 0] + cFuncUncBase = LinearInterpOnInterp1D(cFunc_by_pLvl_list, pLvl_list) # Combine all linear cFuncs + cFuncUnc = VariableLowerBoundFunc2D(cFuncUncBase, self.BoroCnstNat) + # Re-adjust for lower bound of natural borrowing constraint return cFuncUnc - def addMPCandHumanWealth(self,solution): + def addMPCandHumanWealth(self, solution): ''' Take a solution and add human wealth and the bounding MPCs to it. @@ -805,14 +831,14 @@ def addMPCandHumanWealth(self,solution): The solution to this period's consumption-saving problem, but now with human wealth and the bounding MPCs. ''' - solution.hNrm = 0.0 # Can't have None or setAndUpdateValues breaks, should fix - solution.hLvl = self.hLvlNow - solution.mLvlMin= self.mLvlMinNow + solution.hNrm = 0.0 # Can't have None or setAndUpdateValues breaks, should fix + solution.hLvl = self.hLvlNow + solution.mLvlMin = self.mLvlMinNow solution.MPCmin = self.MPCminNow - solution.MPCmax = 0.0 # MPCmax is actually a function in this model + solution.MPCmax = 0.0 # MPCmax is actually a function in this model return solution - def addvPPfunc(self,solution): + def addvPPfunc(self, solution): ''' Adds the marginal marginal value function to an existing solution, so that the next solver can evaluate vPP and thus use cubic interpolation. @@ -829,8 +855,8 @@ def addvPPfunc(self,solution): The same solution passed as input, but with the marginal marginal value function for this period added as the attribute vPPfunc. ''' - vPPfuncNow = MargMargValueFunc2D(solution.cFunc,self.CRRA) - solution.vPPfunc = vPPfuncNow + vPPfuncNow = MargMargValueFunc2D(solution.cFunc, self.CRRA) + solution.vPPfunc = vPPfuncNow return solution def solve(self): @@ -851,7 +877,7 @@ def solve(self): tion of persistent income. Might also include a value function and marginal marginal value function, depending on options selected. ''' - aLvl,pLvl = self.prepareToCalcEndOfPrdvP() + aLvl, pLvl = self.prepareToCalcEndOfPrdvP() EndOfPrdvP = self.calcEndOfPrdvP() if self.vFuncBool: self.makeEndOfPrdvFunc(EndOfPrdvP) @@ -859,8 +885,8 @@ def solve(self): interpolator = self.makeCubiccFunc else: interpolator = self.makeLinearcFunc - solution = self.makeBasicSolution(EndOfPrdvP,aLvl,pLvl,interpolator) - solution = self.addMPCandHumanWealth(solution) + solution = self.makeBasicSolution(EndOfPrdvP, aLvl, pLvl, interpolator) + solution = self.addMPCandHumanWealth(solution) if self.vFuncBool: solution.vFunc = self.makevFunc(solution) if self.CubicBool: @@ -868,8 +894,8 @@ def solve(self): return solution -def solveConsGenIncProcess(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree,pLvlNextFunc, - BoroCnstArt,aXtraGrid,pLvlGrid,vFuncBool,CubicBool): +def solveConsGenIncProcess(solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, pLvlNextFunc, + BoroCnstArt, aXtraGrid, pLvlGrid, vFuncBool, CubicBool): ''' Solves the one period problem of a consumer who experiences persistent and transitory shocks to his income. Unlike in ConsIndShock, consumers do not @@ -918,10 +944,10 @@ def solveConsGenIncProcess(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree,pL function (defined over market resources and persistent income), a marginal value function, bounding MPCs, and normalized human wealth. ''' - solver = ConsGenIncProcessSolver(solution_next,IncomeDstn,LivPrb,DiscFac,CRRA,Rfree, - pLvlNextFunc,BoroCnstArt,aXtraGrid,pLvlGrid,vFuncBool,CubicBool) + solver = ConsGenIncProcessSolver(solution_next, IncomeDstn, LivPrb, DiscFac, CRRA, Rfree, + pLvlNextFunc, BoroCnstArt, aXtraGrid, pLvlGrid, vFuncBool, CubicBool) solver.prepareToSolve() # Do some preparatory work - solution_now = solver.solve() # Solve the period + solution_now = solver.solve() # Solve the period return solution_now @@ -935,11 +961,11 @@ class GenIncProcessConsumerType(IndShockConsumerType): values for risk aversion, discount factor, the interest rate, the grid of end-of-period assets, and an artificial borrowing constraint. ''' - cFunc_terminal_ = BilinearInterp(np.array([[0.0,0.0],[1.0,1.0]]),np.array([0.0,1.0]),np.array([0.0,1.0])) - solution_terminal_ = ConsumerSolution(cFunc = cFunc_terminal_, mNrmMin=0.0, hNrm=0.0, MPCmin=1.0, MPCmax=1.0) - poststate_vars_ = ['aLvlNow','pLvlNow'] + cFunc_terminal_ = BilinearInterp(np.array([[0.0, 0.0], [1.0, 1.0]]), np.array([0.0, 1.0]), np.array([0.0, 1.0])) + solution_terminal_ = ConsumerSolution(cFunc=cFunc_terminal_, mNrmMin=0.0, hNrm=0.0, MPCmin=1.0, MPCmax=1.0) + poststate_vars_ = ['aLvlNow', 'pLvlNow'] - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self, cycles=1, time_flow=True, **kwds): ''' Instantiate a new ConsumerType with given data. See ConsumerParameters.init_explicit_perm_inc for a dictionary of the @@ -957,8 +983,11 @@ def __init__(self,cycles=1,time_flow=True,**kwds): None ''' # Initialize a basic ConsumerType - IndShockConsumerType.__init__(self,cycles=cycles,time_flow=time_flow,**kwds) - self.solveOnePeriod = solveConsGenIncProcess # idiosyncratic shocks solver with explicit persistent income + IndShockConsumerType.__init__(self, cycles=cycles, time_flow=time_flow, **kwds) + self.solveOnePeriod = solveConsGenIncProcess # idiosyncratic shocks solver with explicit persistent income + + def preSolve(self): + self.updateSolutionTerminal() def update(self): ''' @@ -990,13 +1019,14 @@ def updateSolutionTerminal(self): ------- None ''' - self.solution_terminal.vFunc = ValueFunc2D(self.cFunc_terminal_,self.CRRA) - self.solution_terminal.vPfunc = MargValueFunc2D(self.cFunc_terminal_,self.CRRA) - self.solution_terminal.vPPfunc = MargMargValueFunc2D(self.cFunc_terminal_,self.CRRA) - self.solution_terminal.hNrm = 0.0 # Don't track normalized human wealth - self.solution_terminal.hLvl = lambda p : np.zeros_like(p) # But do track absolute human wealth by persistent income - self.solution_terminal.mLvlMin = lambda p : np.zeros_like(p) # And minimum allowable market resources by perm inc - + self.solution_terminal.vFunc = ValueFunc2D(self.cFunc_terminal_, self.CRRA) + self.solution_terminal.vPfunc = MargValueFunc2D(self.cFunc_terminal_, self.CRRA) + self.solution_terminal.vPPfunc = MargMargValueFunc2D(self.cFunc_terminal_, self.CRRA) + self.solution_terminal.hNrm = 0.0 # Don't track normalized human wealth + self.solution_terminal.hLvl = lambda p: np.zeros_like(p) + # But do track absolute human wealth by persistent income + self.solution_terminal.mLvlMin = lambda p: np.zeros_like(p) + # And minimum allowable market resources by perm inc def updatepLvlNextFunc(self): ''' @@ -1012,11 +1042,10 @@ def updatepLvlNextFunc(self): ------- None ''' - pLvlNextFuncBasic = LinearInterp(np.array([0.,1.]),np.array([0.,1.])) + pLvlNextFuncBasic = LinearInterp(np.array([0., 1.]), np.array([0., 1.])) self.pLvlNextFunc = self.T_cycle*[pLvlNextFuncBasic] self.addToTimeVary('pLvlNextFunc') - def installRetirementFunc(self): ''' Installs a special pLvlNextFunc representing retirement in the correct @@ -1033,12 +1062,11 @@ def installRetirementFunc(self): ------- None ''' - if (not hasattr(self,'pLvlNextFuncRet')) or self.T_retire == 0: + if (not hasattr(self, 'pLvlNextFuncRet')) or self.T_retire == 0: return t = self.T_retire self.pLvlNextFunc[t] = self.pLvlNextFuncRet - def updatepLvlGrid(self): ''' Update the grid of persistent income levels. Currently only works for @@ -1063,38 +1091,41 @@ def updatepLvlGrid(self): # Simulate the distribution of persistent income levels by t_cycle in a lifecycle model if self.cycles == 1: - pLvlNow = drawLognormal(self.AgentCount,mu=self.pLvlInitMean,sigma=self.pLvlInitStd,seed=31382) - pLvlGrid = [] # empty list of time-varying persistent income grids + pLvlNow = drawLognormal(self.AgentCount, mu=self.pLvlInitMean, sigma=self.pLvlInitStd, seed=31382) + pLvlGrid = [] # empty list of time-varying persistent income grids # Calculate distribution of persistent income in each period of lifecycle for t in range(len(self.PermShkStd)): if t > 0: - PermShkNow = drawDiscrete(N=self.AgentCount,P=self.PermShkDstn[t-1][0],X=self.PermShkDstn[t-1][1],exact_match=False,seed=t) + PermShkNow = drawDiscrete(N=self.AgentCount, P=self.PermShkDstn[t-1][0], + X=self.PermShkDstn[t-1][1], exact_match=False, seed=t) pLvlNow = self.pLvlNextFunc[t-1](pLvlNow)*PermShkNow - pLvlGrid.append(getPercentiles(pLvlNow,percentiles=self.pLvlPctiles)) + pLvlGrid.append(getPercentiles(pLvlNow, percentiles=self.pLvlPctiles)) # Calculate "stationary" distribution in infinite horizon (might vary across periods of cycle) elif self.cycles == 0: - T_long = 1000 # Number of periods to simulate to get to "stationary" distribution - pLvlNow = drawLognormal(self.AgentCount,mu=self.pLvlInitMean,sigma=self.pLvlInitStd,seed=31382) - t_cycle = np.zeros(self.AgentCount,dtype=int) + T_long = 1000 # Number of periods to simulate to get to "stationary" distribution + pLvlNow = drawLognormal(self.AgentCount, mu=self.pLvlInitMean, sigma=self.pLvlInitStd, seed=31382) + t_cycle = np.zeros(self.AgentCount, dtype=int) for t in range(T_long): - LivPrb = LivPrbAll[t_cycle] # Determine who dies and replace them with newborns - draws = drawUniform(self.AgentCount,seed=t) + LivPrb = LivPrbAll[t_cycle] # Determine who dies and replace them with newborns + draws = drawUniform(self.AgentCount, seed=t) who_dies = draws > LivPrb - pLvlNow[who_dies] = drawLognormal(np.sum(who_dies),mu=self.pLvlInitMean,sigma=self.pLvlInitStd,seed=t+92615) + pLvlNow[who_dies] = drawLognormal(np.sum(who_dies), mu=self.pLvlInitMean, + sigma=self.pLvlInitStd, seed=t+92615) t_cycle[who_dies] = 0 - for j in range(self.T_cycle): # Update persistent income + for j in range(self.T_cycle): # Update persistent income these = t_cycle == j - PermShkTemp = drawDiscrete(N=np.sum(these),P=self.PermShkDstn[j][0],X=self.PermShkDstn[j][1],exact_match=False,seed=t+13*j) + PermShkTemp = drawDiscrete(N=np.sum(these), P=self.PermShkDstn[j][0], + X=self.PermShkDstn[j][1], exact_match=False, seed=t+13*j) pLvlNow[these] = self.pLvlNextFunc[j](pLvlNow[these])*PermShkTemp t_cycle = t_cycle + 1 t_cycle[t_cycle == self.T_cycle] = 0 # We now have a "long run stationary distribution", extract percentiles - pLvlGrid = [] # empty list of time-varying persistent income grids + pLvlGrid = [] # empty list of time-varying persistent income grids for t in range(self.T_cycle): these = t_cycle == t - pLvlGrid.append(getPercentiles(pLvlNow[these],percentiles=self.pLvlPctiles)) + pLvlGrid.append(getPercentiles(pLvlNow[these], percentiles=self.pLvlPctiles)) # Throw an error if cycles>1 else: @@ -1106,7 +1137,7 @@ def updatepLvlGrid(self): if not orig_time: self.timeRev() - def simBirth(self,which_agents): + def simBirth(self, which_agents): ''' Makes new consumers for the given indices. Initialized variables include aNrm and pLvl, as well as time variables t_age and t_cycle. Normalized assets and persistent income levels @@ -1122,13 +1153,14 @@ def simBirth(self,which_agents): None ''' # Get and store states for newly born agents - N = np.sum(which_agents) # Number of new consumers to make - aNrmNow_new = drawLognormal(N,mu=self.aNrmInitMean,sigma=self.aNrmInitStd,seed=self.RNG.randint(0,2**31-1)) - self.pLvlNow[which_agents] = drawLognormal(N,mu=self.pLvlInitMean,sigma=self.pLvlInitStd,seed=self.RNG.randint(0,2**31-1)) + N = np.sum(which_agents) # Number of new consumers to make + aNrmNow_new = drawLognormal(N, mu=self.aNrmInitMean, sigma=self.aNrmInitStd, + seed=self.RNG.randint(0, 2**31-1)) + self.pLvlNow[which_agents] = drawLognormal(N, mu=self.pLvlInitMean, sigma=self.pLvlInitStd, + seed=self.RNG.randint(0, 2**31-1)) self.aLvlNow[which_agents] = aNrmNow_new*self.pLvlNow[which_agents] - self.t_age[which_agents] = 0 # How many periods since each agent was born - self.t_cycle[which_agents] = 0 # Which period of the cycle each agent is currently in - + self.t_age[which_agents] = 0 # How many periods since each agent was born + self.t_cycle[which_agents] = 0 # Which period of the cycle each agent is currently in def getStates(self): ''' @@ -1153,8 +1185,7 @@ def getStates(self): pLvlNow[these] = self.pLvlNextFunc[t-1](self.pLvlNow[these])*self.PermShkNow[these] self.pLvlNow = pLvlNow # Updated persistent income level self.bLvlNow = RfreeNow*aLvlPrev # Bank balances before labor income - self.mLvlNow = self.bLvlNow + self.TranShkNow*self.pLvlNow # Market resources after income - + self.mLvlNow = self.bLvlNow + self.TranShkNow*self.pLvlNow # Market resources after income def getControls(self): ''' @@ -1169,11 +1200,13 @@ def getControls(self): None ''' cLvlNow = np.zeros(self.AgentCount) + np.nan + MPCnow = np.zeros(self.AgentCount) + np.nan for t in range(self.T_cycle): these = t == self.t_cycle - cLvlNow[these] = self.solution[t].cFunc(self.mLvlNow[these],self.pLvlNow[these]) + cLvlNow[these] = self.solution[t].cFunc(self.mLvlNow[these], self.pLvlNow[these]) + MPCnow[these] = self.solution[t].cFunc.derivativeX(self.mLvlNow[these], self.pLvlNow[these]) self.cLvlNow = cLvlNow - + self.MPCnow = MPCnow def getPostStates(self): ''' @@ -1223,7 +1256,7 @@ def updatepLvlNextFunc(self): pLvlNextFunc = [] for t in range(self.T_cycle): - pLvlNextFunc.append(LinearInterp(np.array([0.,1.]),np.array([0.,self.PermGroFac[t]]))) + pLvlNextFunc.append(LinearInterp(np.array([0., 1.]), np.array([0., self.PermGroFac[t]]))) self.pLvlNextFunc = pLvlNextFunc self.addToTimeVary('pLvlNextFunc') @@ -1261,10 +1294,10 @@ def updatepLvlNextFunc(self): self.timeFwd() pLvlNextFunc = [] - pLogMean = self.pLvlInitMean # Initial mean (log) persistent income + pLogMean = self.pLvlInitMean # Initial mean (log) persistent income for t in range(self.T_cycle): - pLvlNextFunc.append(pLvlFuncAR1(pLogMean,self.PermGroFac[t],self.PrstIncCorr)) + pLvlNextFunc.append(pLvlFuncAR1(pLogMean, self.PermGroFac[t], self.PrstIncCorr)) pLogMean += np.log(self.PermGroFac[t]) self.pLvlNextFunc = pLvlNextFunc @@ -1276,18 +1309,19 @@ def updatepLvlNextFunc(self): ############################################################################### def main(): - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params from HARK.utilities import plotFuncs from time import clock import matplotlib.pyplot as plt - mystr = lambda number : "{:.4f}".format(number) + def mystr(number): return "{:.4f}".format(number) do_simulation = False # Display information about the pLvlGrid used in these examples print('The infinite horizon examples presented here use a grid of persistent income levels (pLvlGrid)') print('based on percentiles of the long run distribution of pLvl for the given parameters. These percentiles') - print('are specified in the attribute pLvlPctiles. Here, the lowest percentile is ' + str(Params.init_explicit_perm_inc['pLvlPctiles'][0]*100) + ' and the highest') + print('are specified in the attribute pLvlPctiles. Here, the lowest percentile is ' + + str(Params.init_explicit_perm_inc['pLvlPctiles'][0]*100) + ' and the highest') print('percentile is ' + str(Params.init_explicit_perm_inc['pLvlPctiles'][-1]*100) + '.\n') # Make and solve an example "explicit permanent income" consumer with idiosyncratic shocks @@ -1300,12 +1334,13 @@ def main(): # Plot the consumption function at various permanent income levels print('Consumption function by pLvl for explicit permanent income consumer:') pLvlGrid = ExplicitExample.pLvlGrid[0] - mLvlGrid = np.linspace(0,20,300) + mLvlGrid = np.linspace(0, 20, 300) for p in pLvlGrid: M_temp = mLvlGrid + ExplicitExample.solution[0].mLvlMin(p) - C = ExplicitExample.solution[0].cFunc(M_temp,p*np.ones_like(M_temp)) - plt.plot(M_temp,C) - plt.xlim(0.,20.) + C = ExplicitExample.solution[0].cFunc(M_temp, p*np.ones_like(M_temp)) + plt.plot(M_temp, C) + plt.xlim(0., 20.) + plt.ylim(0., None) plt.xlabel('Market resource level mLvl') plt.ylabel('Consumption level cLvl') plt.show() @@ -1315,25 +1350,27 @@ def main(): t_start = clock() NormalizedExample.solve() t_end = clock() - print('Solving the equivalent problem with permanent income normalized out took ' + mystr(t_end-t_start) + ' seconds.') + print('Solving the equivalent problem with permanent income normalized out took ' + + mystr(t_end-t_start) + ' seconds.') # Show that the normalized consumption function for the "explicit permanent income" consumer # is almost identical for every permanent income level (and the same as the normalized problem's # cFunc), but is less accurate due to extrapolation outside the bounds of pLvlGrid. print('Normalized consumption function by pLvl for explicit permanent income consumer:') pLvlGrid = ExplicitExample.pLvlGrid[0] - mNrmGrid = np.linspace(0,20,300) + mNrmGrid = np.linspace(0, 20, 300) for p in pLvlGrid: M_temp = mNrmGrid*p + ExplicitExample.solution[0].mLvlMin(p) - C = ExplicitExample.solution[0].cFunc(M_temp,p*np.ones_like(M_temp)) - plt.plot(M_temp/p,C/p) - plt.xlim(0.,20.) + C = ExplicitExample.solution[0].cFunc(M_temp, p*np.ones_like(M_temp)) + plt.plot(M_temp/p, C/p) + plt.xlim(0., 20.) + plt.ylim(0., None) plt.xlabel('Normalized market resources mNrm') plt.ylabel('Normalized consumption cNrm') plt.show() print('Consumption function for normalized problem (without explicit permanent income):') mNrmMin = NormalizedExample.solution[0].mNrmMin - plotFuncs(NormalizedExample.solution[0].cFunc,mNrmMin,mNrmMin+20.) + plotFuncs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin+20) print('The "explicit permanent income" solution deviates from the solution to the normalized problem because') print('of errors from extrapolating beyond the bounds of the pLvlGrid. The error is largest for pLvl values') @@ -1341,13 +1378,13 @@ def main(): # Plot the value function at various permanent income levels if ExplicitExample.vFuncBool: - pGrid = np.linspace(0.1,3.0,24) - M = np.linspace(0.001,5,300) + pGrid = np.linspace(0.1, 3.0, 24) + M = np.linspace(0.001, 5, 300) for p in pGrid: M_temp = M+ExplicitExample.solution[0].mLvlMin(p) - C = ExplicitExample.solution[0].vFunc(M_temp,p*np.ones_like(M_temp)) - plt.plot(M_temp,C) - plt.ylim([-200,0]) + C = ExplicitExample.solution[0].vFunc(M_temp, p*np.ones_like(M_temp)) + plt.plot(M_temp, C) + plt.ylim([-200, 0]) plt.xlabel('Market resource level mLvl') plt.ylabel('Value v') plt.show() @@ -1355,11 +1392,11 @@ def main(): # Simulate some data if do_simulation: ExplicitExample.T_sim = 500 - ExplicitExample.track_vars = ['mLvlNow','cLvlNow','pLvlNow'] - ExplicitExample.makeShockHistory() # This is optional + ExplicitExample.track_vars = ['mLvlNow', 'cLvlNow', 'pLvlNow'] + ExplicitExample.makeShockHistory() # This is optional ExplicitExample.initializeSim() ExplicitExample.simulate() - plt.plot(np.mean(ExplicitExample.mLvlNow_hist,axis=1)) + plt.plot(np.mean(ExplicitExample.mLvlNow_hist, axis=1)) plt.xlabel('Simulated time period') plt.ylabel('Average market resources mLvl') plt.show() @@ -1374,14 +1411,16 @@ def main(): print('Solving a persistent income shocks consumer took ' + mystr(t_end-t_start) + ' seconds.') # Plot the consumption function at various levels of persistent income pLvl - print('Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of ' + str(PersistentExample.PrstIncCorr) + ':') + print('Consumption function by persistent income level pLvl for a consumer with AR1 coefficient of ' + + str(PersistentExample.PrstIncCorr) + ':') pLvlGrid = PersistentExample.pLvlGrid[0] - mLvlGrid = np.linspace(0,20,300) + mLvlGrid = np.linspace(0, 20, 300) for p in pLvlGrid: M_temp = mLvlGrid + PersistentExample.solution[0].mLvlMin(p) - C = PersistentExample.solution[0].cFunc(M_temp,p*np.ones_like(M_temp)) - plt.plot(M_temp,C) - plt.xlim(0.,20.) + C = PersistentExample.solution[0].cFunc(M_temp, p*np.ones_like(M_temp)) + plt.plot(M_temp, C) + plt.xlim(0., 20.) + plt.ylim(0., None) plt.xlabel('Market resource level mLvl') plt.ylabel('Consumption level cLvl') plt.show() @@ -1389,12 +1428,12 @@ def main(): # Plot the value function at various persistent income levels if PersistentExample.vFuncBool: pGrid = PersistentExample.pLvlGrid[0] - M = np.linspace(0.001,5,300) + M = np.linspace(0.001, 5, 300) for p in pGrid: M_temp = M+PersistentExample.solution[0].mLvlMin(p) - C = PersistentExample.solution[0].vFunc(M_temp,p*np.ones_like(M_temp)) - plt.plot(M_temp,C) - plt.ylim([-200,0]) + C = PersistentExample.solution[0].vFunc(M_temp, p*np.ones_like(M_temp)) + plt.plot(M_temp, C) + plt.ylim([-200, 0]) plt.xlabel('Market resource level mLvl') plt.ylabel('Value v') plt.show() @@ -1402,14 +1441,14 @@ def main(): # Simulate some data if do_simulation: PersistentExample.T_sim = 500 - PersistentExample.track_vars = ['mLvlNow','cLvlNow','pLvlNow'] + PersistentExample.track_vars = ['mLvlNow', 'cLvlNow', 'pLvlNow'] PersistentExample.initializeSim() PersistentExample.simulate() - plt.plot(np.mean(PersistentExample.mLvlNow_hist,axis=1)) + plt.plot(np.mean(PersistentExample.mLvlNow_hist, axis=1)) plt.xlabel('Simulated time period') plt.ylabel('Average market resources mLvl') plt.show() + if __name__ == '__main__': main() - diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 4ffd9a6d5..b8b7f17ef 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -727,16 +727,16 @@ def defBoroCnst(self,BoroCnstArt): # Calculate the minimum allowable value of money resources in this period self.BoroCnstNat = (self.solution_next.mNrmMin - self.TranShkMinNext)*\ (self.PermGroFac*self.PermShkMinNext)/self.Rfree - - # Note: need to be sure to handle BoroCnstArt==None appropriately. + + # Note: need to be sure to handle BoroCnstArt==None appropriately. # In Py2, this would evaluate to 5.0: np.max([None, 5.0]). - # However in Py3, this raises a TypeError. Thus here we need to directly + # However in Py3, this raises a TypeError. Thus here we need to directly # address the situation in which BoroCnstArt == None: if BoroCnstArt is None: self.mNrmMinNow = self.BoroCnstNat else: self.mNrmMinNow = np.max([self.BoroCnstNat,BoroCnstArt]) - if self.BoroCnstNat < self.mNrmMinNow: + if self.BoroCnstNat < self.mNrmMinNow: self.MPCmaxEff = 1.0 # If actually constrained, MPC near limit is 1 else: self.MPCmaxEff = self.MPCmaxNow @@ -793,6 +793,12 @@ def prepareToCalcEndOfPrdvP(self): aNrmNow : np.array A 1D array of end-of-period assets; also stored as attribute of self. ''' + + # We define aNrmNow all the way from BoroCnstNat up to max(self.aXtraGrid) + # even if BoroCnstNat < BoroCnstArt, so we can construct the consumption + # function as the lower envelope of the (by the artificial borrowing con- + # straint) uconstrained consumption function, and the artificially con- + # strained consumption function. aNrmNow = np.asarray(self.aXtraGrid) + self.BoroCnstNat ShkCount = self.TranShkValsNext.size aNrm_temp = np.tile(aNrmNow,(ShkCount,1)) @@ -1461,7 +1467,7 @@ class PerfForesightConsumerType(AgentType): poststate_vars_ = ['aNrmNow','pLvlNow'] shock_vars_ = [] - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self,cycles=1, time_flow=True,verbose=False,quiet=False, **kwds): ''' Instantiate a new consumer type with given data. See ConsumerParameters.init_perfect_foresight for a dictionary of @@ -1487,7 +1493,13 @@ def __init__(self,cycles=1,time_flow=True,**kwds): self.time_inv = deepcopy(self.time_inv_) self.poststate_vars = deepcopy(self.poststate_vars_) self.shock_vars = deepcopy(self.shock_vars_) + self.verbose = verbose + self.quiet = quiet self.solveOnePeriod = solvePerfForesight # solver for perfect foresight model + + + def preSolve(self): + self.updateSolutionTerminal() def updateSolutionTerminal(self): ''' @@ -1533,7 +1545,6 @@ def initializeSim(self): AgentType.initializeSim(self) - def simBirth(self,which_agents): ''' Makes new consumers for the given indices. Initialized variables include aNrm and pLvl, as @@ -1678,11 +1689,11 @@ def getPostStates(self): self.aLvlNow = self.aNrmNow*self.pLvlNow # Useful in some cases to precalculate asset level return None - def checkConditions(self,verbose=False): + def checkConditions(self,verbose=False,verbose_reference=False,public_call=False): ''' - This method checks whether the instance's type satisfies the growth impatiance condition - (GIC), return impatiance condition (RIC), absolute impatiance condition (AIC), weak return - impatiance condition (WRIC), finite human wealth condition (FHWC) and finite value of + This method checks whether the instance's type satisfies the growth impatience condition + (GIC), return impatience condition (RIC), absolute impatience condition (AIC), weak return + impatience condition (WRIC), finite human wealth condition (FHWC) and finite value of autarky condition (FVAC). These are the conditions that are sufficient for nondegenerate solutions under infinite horizon with a 1 period cycle. Depending on the model at hand, a different combination of these conditions must be satisfied. To check which conditions are @@ -1691,8 +1702,8 @@ def checkConditions(self,verbose=False): Parameters ---------- verbose : boolean - Specifies different levels of verbosity of feedback. When false, it only reports whether the - instance's type fails to satisfy a particular condition. When true, it reports all results, i.e. + Specifies different levels of verbosity of feedback. When False, it only reports whether the + instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. the factor values for all conditions. Returns @@ -1700,35 +1711,45 @@ def checkConditions(self,verbose=False): None ''' if self.cycles!=0 or self.T_cycle > 1: - print('This method only checks for the conditions for infinite horizon models with a 1 period cycle') + if verbose == True: + print('This method only checks for the conditions for infinite horizon models with a 1 period cycle') return + + violated = False #Evaluate and report on the return impatience condition - RIC=(self.LivPrb[0]*(self.Rfree*self.DiscFac)**(1/self.CRRA))/self.Rfree - if RIC<1: - print('The return impatiance factor value for the supplied parameter values satisfies the return impatiance condition.') + + RIF = (self.LivPrb[0]*(self.Rfree*self.DiscFac)**(1/self.CRRA))/self.Rfree + if RIF<1: + if public_call: + print('The return impatience factor value for the supplied parameter values satisfies the return impatience condition.') else: - print('The given type violates the return impatience condition with the supplied parameter values. Therefore, a nondegenerate solution may not be available. See Table 3 in "Theoretical Foundations of Buffer Stock Saving" (Carroll, 2011) to check which conditions are sufficient for a nondegenerate solution.') - if verbose: - print('The return impatiance factor value for the supplied parameter values is ' + str(RIC)) + violated = True + print('The given type violates the Return Impatience Condition with the supplied parameter values; the factor is %1.5f ' % (RIF)) #Evaluate and report on the absolute impatience condition - AIC=self.LivPrb[0]*(self.Rfree*self.DiscFac)**(1/self.CRRA) - if AIC<1: - print('The absolute impatiance factor value for the supplied parameter values satisfies the absolute impatiance condition.') + AIF = self.LivPrb[0]*(self.Rfree*self.DiscFac)**(1/self.CRRA) + if AIF<1: + if public_call: + print('The absolute impatience factor value for the supplied parameter values satisfies the absolute impatience condition.') else: - print('The given type violates the absolute impatience condition with the supplied parameter values. Therefore, a nondegenerate solution may not be available. See Table 3 in "Theoretical Foundations of Buffer Stock Saving" (Carroll, 2011) to check which conditions are sufficient for a nondegenerate solution.') - if verbose: - print('The absolute impatiance factor value for the supplied parameter values is ' + str(AIC)) + print('The given type violates the absolute impatience condition with the supplied parameter values; the AIF is %1.5f ' % (AIF)) + if verbose: + violated = True + print(' Therefore, the absolute amount of consumption is expected to grow over time') #Evaluate and report on the finite human wealth condition - FHWC=self.PermGroFac[0]/self.Rfree - if FHWC<1: - print('The finite human wealth factor value for the supplied parameter values satisfies the finite human wealth condition.') + FHWF = self.PermGroFac[0]/self.Rfree + if FHWF<1: + if public_call: + print('The finite human wealth factor value for the supplied parameter values satisfies the finite human wealth condition.') else: - print('The given type violates the finite human wealth condition with the supplied parameter values. Therefore, a nondegenerate solution may not be available. See Table 3 in "Theoretical Foundations of Buffer Stock Saving" (Carroll, 2011) to check which conditions are sufficient for a nondegenerate solution.') - if verbose: - print('The finite human wealth factor value for the supplied parameter values is ' + str(FHWC)) + print('The given type violates the finite human wealth condition; the finite human wealth factor value %2.5f ' % (FHWF)) + violated = True + if verbose and violated and verbose_reference: + print('[!] For more information on the conditions, see Table 3 in "Theoretical Foundations of Buffer Stock Saving" at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/') + + return violated class IndShockConsumerType(PerfForesightConsumerType): @@ -1742,7 +1763,7 @@ class IndShockConsumerType(PerfForesightConsumerType): time_inv_ = PerfForesightConsumerType.time_inv_ + ['BoroCnstArt','vFuncBool','CubicBool'] shock_vars_ = ['PermShkNow','TranShkNow'] - def __init__(self,cycles=1,time_flow=True,**kwds): + def __init__(self,cycles=1,time_flow=True,verbose=False,quiet=False,**kwds): ''' Instantiate a new ConsumerType with given data. See ConsumerParameters.init_idiosyncratic_shocks for a dictionary of @@ -1760,17 +1781,17 @@ def __init__(self,cycles=1,time_flow=True,**kwds): None ''' # Initialize a basic AgentType - PerfForesightConsumerType.__init__(self,cycles=cycles,time_flow=time_flow,**kwds) + PerfForesightConsumerType.__init__(self,cycles=cycles,time_flow=time_flow, + verbose=verbose,quiet=quiet, **kwds) # Add consumer-type specific objects, copying to create independent versions self.solveOnePeriod = solveConsIndShock # idiosyncratic shocks solver self.update() # Make assets grid, income process, terminal solution + def updateIncomeProcess(self): ''' - Updates this agent's income process based on his own attributes. The - function that generates the discrete income process can be swapped out - for a different process. + Updates this agent's income process based on his own attributes. Parameters ---------- @@ -1990,73 +2011,76 @@ def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): self.eulerErrorFunc = eulerErrorFunc def preSolve(self): - PerfForesightConsumerType.preSolve(self) self.updateSolutionTerminal() + if not self.quiet: + self.checkConditions(verbose=self.verbose,public_call=False) - def checkConditions(self,verbose=False): + def checkConditions(self,verbose=False,public_call=True): ''' - This method checks whether the instance's type satisfies the growth impatiance condition - (GIC), return impatiance condition (RIC), absolute impatiance condition (AIC), weak return - impatiance condition (WRIC), finite human wealth condition (FHWC) and finite value of + This method checks whether the instance's type satisfies the growth impatience condition + (GIC), return impatience condition (RIC), absolute impatience condition (AIC), weak return + impatience condition (WRIC), finite human wealth condition (FHWC) and finite value of autarky condition (FVAC). These are the conditions that are sufficient for nondegenerate solutions under infinite horizon with a 1 period cycle. Depending on the model at hand, a - different combination of these conditions must be satisfied. To check which conditions are - relevant to the model at hand, a reference to the relevant theoretical literature is made. + different combination of these conditions must be satisfied. (For an exposition of the + conditions, see http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/) Parameters ---------- verbose : boolean - Specifies different levels of verbosity of feedback. When false, it only reports whether the - instance's type fails to satisfy a particular condition. When true, it reports all results, i.e. + Specifies different levels of verbosity of feedback. When False, it only reports whether the + instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. the factor values for all conditions. Returns ------- None ''' - PerfForesightConsumerType.checkConditions(self) + violated = PerfForesightConsumerType.checkConditions(self, verbose=verbose, verbose_reference=False) if self.cycles!=0 or self.T_cycle > 1: return - #Some initial conditions - exp_psi_inv=0 - exp_psi_to_one_minus_rho=0 - - #Get expected psi inverse - for i in range(len(self.PermShkDstn[1])): - exp_psi_inv=exp_psi_inv+(1.0/self.PermShkCount)*(self.PermShkDstn[1][i])**(-1) - - #Get expected psi to the power one minus CRRA - for i in range(len(self.PermShkDstn[1])): - exp_psi_to_one_minus_rho=exp_psi_to_one_minus_rho+(1.0/self.PermShkCount)*(self.PermShkDstn[1][i])**(1-self.CRRA) - + EPermShkInv=np.dot(self.PermShkDstn[0][0],1/self.PermShkDstn[0][1]) + PermGroFacAdj=self.PermGroFac[0]*EPermShkInv + Thorn=self.LivPrb[0]*(self.Rfree*self.DiscFac)**(1/self.CRRA) + GIF=Thorn/PermGroFacAdj #Evaluate and report on the growth impatience condition - GIC=(self.LivPrb[0]*exp_psi_inv*(self.Rfree*self.DiscFac)**(1/self.CRRA))/self.PermGroFac[0] - if GIC<1: - print('The growth impatiance factor value for the supplied parameter values satisfies the growth impatiance condition.') + if GIF<1: + if public_call: + print('The growth impatience factor value for the supplied parameter values satisfies the growth impatience condition.') else: - print('The given type violates the growth impatience condition with the supplied parameter values. Therefore, a nondegenerate solution may not be available. See Table 3 in "Theoretical Foundations of Buffer Stock Saving" (Carroll, 2011) to check which conditions are sufficient for a nondegenerate solution.') - if verbose: - print('The growth impatiance factor value for the supplied parameter values is ' + str(GIC)) + violated = True + print('The given parameter values violate the growth impatience condition for this consumer type; the GIF is: %2.4f' % (GIF)) + if verbose: + print(' Therefore, a target level of wealth does not exist.') #Evaluate and report on the weak return impatience condition - WRIC=(self.LivPrb[0]*(self.UnempPrb**(1/self.CRRA))*(self.Rfree*self.DiscFac)**(1/self.CRRA))/self.Rfree - if WRIC<1: - print('The weak return impatiance factor value for the supplied parameter values satisfies the weak return impatiance condition.') + WRIF=(self.LivPrb[0]*(self.UnempPrb**(1/self.CRRA))*(self.Rfree*self.DiscFac)**(1/self.CRRA))/self.Rfree + if WRIF<1: + if public_call: + print('The weak return impatience factor value for the supplied parameter values satisfies the weak return impatience condition.') else: - print('The given type violates the weak return impatience condition with the supplied parameter values. Therefore, a nondegenerate solution may not be available. See Table 3 in "Theoretical Foundations of Buffer Stock Saving" (Carroll, 2011) to check which conditions are sufficient for a nondegenerate solution.') - if verbose: - print('The weak return impatiance factor value for the supplied parameter values is ' + str(WRIC)) + violated = True + print('The given type violates the weak return impatience condition with the supplied parameter values. The WRIF is: %2.4f' % (WRIF)) + if verbose: + print(' Therefore, a nondegenerate solution is not available.') #Evaluate and report on the finite value of autarky condition - FVAC=self.LivPrb[0]*self.DiscFac*exp_psi_to_one_minus_rho*(self.PermGroFac[0]**(1-self.CRRA)) - if FVAC<1: - print('The finite value of autarky factor value for the supplied parameter values satisfies the finite value of autarky condition.') + EPermShkValFunc=np.dot(self.PermShkDstn[0][0],self.PermShkDstn[0][1]**(1-self.CRRA)) + FVAF=self.LivPrb[0]*self.DiscFac*EPermShkValFunc*(self.PermGroFac[0]**(1-self.CRRA)) + if FVAF<1: + if public_call: + print('The finite value of autarky factor value for the supplied parameter values satisfies the finite value of autarky condition.') else: - print('The given type violates the finite value of autarky condition with the supplied parameter values. Therefore, a nondegenerate solution may not be available. See Table 3 in "Theoretical Foundations of Buffer Stock Saving" (Carroll, 2011) to check which conditions are sufficient for a nondegenerate solution.') - if verbose: - print('The finite value of autarky factor value for the supplied parameter values is ' + str(FVAC)) + print('The given type violates the finite value of autarky condition with the supplied parameter values. The FVAF is %2.4f' %(FVAF)) + violated = True + if verbose: + print(' Therefore, a nondegenerate solution is not available.') + + if verbose and violated: + print('\n[!] For more information on the conditions, see Table 3 in "Theoretical Foundations of Buffer Stock Saving" at http://econ.jhu.edu/people/ccarroll/papers/BufferStockTheory/') + class KinkedRconsumerType(IndShockConsumerType): ''' @@ -2092,6 +2116,9 @@ def __init__(self,cycles=1,time_flow=True,**kwds): # Add consumer-type specific objects, copying to create independent versions self.solveOnePeriod = solveConsKinkedR # kinked R solver self.update() # Make assets grid, income process, terminal solution + + def preSolve(self): + self.updateSolutionTerminal() def calcBoundingValues(self): ''' @@ -2147,7 +2174,7 @@ def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): Has option to use approximate income distribution stored in self.IncomeDstn or to use a (temporary) very dense approximation. - NOT YET IMPLEMENTED FOR THIS CLASS + SHOULD BE INHERITED FROM ConsIndShockModel Parameters ---------- @@ -2185,21 +2212,21 @@ def getRfree(self): def checkConditions(self,verbose=False): ''' - This method checks whether the instance's type satisfies the growth impatiance condition - (GIC), return impatiance condition (RIC), absolute impatiance condition (AIC), weak return - impatiance condition (WRIC), finite human wealth condition (FHWC) and finite value of + This method checks whether the instance's type satisfies the growth impatience condition + (GIC), return impatience condition (RIC), absolute impatience condition (AIC), weak return + impatience condition (WRIC), finite human wealth condition (FHWC) and finite value of autarky condition (FVAC). These are the conditions that are sufficient for nondegenerate - solutions under infinite horizon with a 1 period cycle. Depending on the model at hand, a + infinite horizon solutions with a 1 period cycle. Depending on the model at hand, a different combination of these conditions must be satisfied. To check which conditions are relevant to the model at hand, a reference to the relevant theoretical literature is made. - NOT YET IMPLEMENTED FOR THIS CLASS + SHOULD BE INHERITED FROM ConsIndShockModel Parameters ---------- verbose : boolean - Specifies different levels of verbosity of feedback. When false, it only reports whether the - instance's type fails to satisfy a particular condition. When true, it reports all results, i.e. + Specifies different levels of verbosity of feedback. When False, it only reports whether the + instance's type fails to satisfy a particular condition. When True, it reports all results, i.e. the factor values for all conditions. Returns @@ -2410,7 +2437,7 @@ def constructAssetsGrid(parameters): #################################################################################################### def main(): - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params from HARK.utilities import plotFuncsDer, plotFuncs from time import clock mystr = lambda number : "{:.4f}".format(number) @@ -2557,4 +2584,3 @@ def main(): if __name__ == '__main__': main() - diff --git a/HARK/ConsumptionSaving/ConsIndShockModelDemos/TryAlternativeParameterValues.py b/HARK/ConsumptionSaving/ConsIndShockModelDemos/TryAlternativeParameterValues.py deleted file mode 100644 index a29e3e521..000000000 --- a/HARK/ConsumptionSaving/ConsIndShockModelDemos/TryAlternativeParameterValues.py +++ /dev/null @@ -1,42 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Thu Nov 9 09:40:49 2017 - -@author: ccarroll@llorracc.org -""" -from __future__ import division, print_function -from builtins import str -from builtins import range -import pylab # the plotting tools - -xPoints=100 # number of points at which to sample a function when plotting it using pylab -mMinVal = 0. # minimum value of the consumer's cash-on-hand to show in plots -mMaxVal = 5. # maximum value of the consumer's cash-on-hand to show in plots - -import HARK.ConsumptionSaving.ConsumerParameters as Params # Read in the database of parameters -my_dictionary = Params.init_idiosyncratic_shocks # Create a dictionary containing the default values of the parameters -import numpy as np # Get the suite of tools for doing numerical computation in python -from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType # Set up the tools for solving a consumer's problem - -# define a function that generates the plot -def perturbParameterToGetcPlotList(base_dictionary,param_name,param_min,param_max,N=20,time_vary=False): - param_vec = np.linspace(param_min,param_max,num=N,endpoint=True) # vector of alternative values of the parameter to examine - thisConsumer = IndShockConsumerType(**my_dictionary) # create an instance of the consumer type - thisConsumer.cycles = 0 # Make this type have an infinite horizon - x = np.linspace(mMinVal,mMaxVal,xPoints,endpoint=True) # Define a vector of x values that span the range from the minimum to the maximum values of m - - for j in range(N): # loop from the first to the last values of the parameter - if time_vary: # Some parameters are time-varying; others are not - setattr(thisConsumer,param_name,[param_vec[j]]) - else: - setattr(thisConsumer,param_name,param_vec[j]) - thisConsumer.update() # set up the preliminaries required to solve the problem - thisConsumer.solve() # solve the problem - y = thisConsumer.solution[0].cFunc(x) # Get the values of the consumption function at the points in the vector of x points - pylab.plot(x,y,label=str(round(param_vec[j],3))) # plot it and generate a label indicating the rounded value of the parameter - pylab.legend(loc='upper right') # put the legend in the upper right - return pylab # return the figure - -cPlot_by_DiscFac = perturbParameterToGetcPlotList(my_dictionary,'DiscFac',0.899,0.999,5,False) # create the figure -cPlot_by_DiscFac.show() # show it - diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py index 73affbaff..b3682220e 100644 --- a/HARK/ConsumptionSaving/ConsMarkovModel.py +++ b/HARK/ConsumptionSaving/ConsMarkovModel.py @@ -9,10 +9,8 @@ from builtins import range from copy import deepcopy import numpy as np -from .ConsIndShockModel import ConsIndShockSolver, ValueFunc, MargValueFunc, ConsumerSolution, IndShockConsumerType -from .ConsAggShockModel import AggShockConsumerType -from HARK.utilities import combineIndepDstns, warnings # Because of "patch" to warnings modules -from HARK import Market, HARKobject +from HARK.ConsumptionSaving.ConsIndShockModel import ConsIndShockSolver, ValueFunc, \ + MargValueFunc, ConsumerSolution, IndShockConsumerType from HARK.simulation import drawDiscrete, drawUniform from HARK.interpolation import CubicInterp, LowerEnvelope, LinearInterp from HARK.utilities import CRRAutility, CRRAutilityP, CRRAutilityPP, CRRAutilityP_inv, \ @@ -725,9 +723,8 @@ def checkMarkovInputs(self): def preSolve(self): """ - Do preSolve stuff inherited from IndShockConsumerType, then check to make sure that the - inputs that are specific to MarkovConsumerType are of the right shape (if arrays) or length - (if lists). + Check to make sure that the inputs that are specific to MarkovConsumerType + are of the right shape (if arrays) or length (if lists). Parameters ---------- @@ -737,7 +734,7 @@ def preSolve(self): ------- None """ - IndShockConsumerType.preSolve(self) + self.updateSolutionTerminal() self.checkMarkovInputs() def updateSolutionTerminal(self): @@ -974,7 +971,7 @@ def makeEulerErrorFunc(self,mMax=100,approx_inc_dstn=True): ############################################################################### def main(): - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params from HARK.utilities import plotFuncs from time import clock from copy import copy @@ -1026,7 +1023,7 @@ def main(): start_time = clock() SerialUnemploymentExample.solve() end_time = clock() - print('Solving a Markov consumer took ' + mystr(end_time-start_time) + ' seconds.') + print('Solving a Markov consumer with serially correlated unemployment took ' + mystr(end_time-start_time) + ' seconds.') print('Consumption functions for each discrete state:') plotFuncs(SerialUnemploymentExample.solution[0].cFunc,0,50) if SerialUnemploymentExample.vFuncBool: diff --git a/HARK/ConsumptionSaving/ConsMedModel.py b/HARK/ConsumptionSaving/ConsMedModel.py index 13719c77c..75b2502ad 100644 --- a/HARK/ConsumptionSaving/ConsMedModel.py +++ b/HARK/ConsumptionSaving/ConsMedModel.py @@ -11,14 +11,13 @@ from HARK.utilities import approxLognormal, addDiscreteOutcomeConstantMean, CRRAutilityP_inv,\ CRRAutility, CRRAutility_inv, CRRAutility_invP, CRRAutilityPP,\ makeGridExpMult, NullFunc -from HARK.simulation import drawLognormal -from .ConsIndShockModel import ConsumerSolution +from HARK.ConsumptionSaving.ConsIndShockModel import ConsumerSolution from HARK.interpolation import BilinearInterpOnInterp1D, TrilinearInterp, BilinearInterp, CubicInterp,\ LinearInterp, LowerEnvelope3D, UpperEnvelope, LinearInterpOnInterp1D,\ VariableLowerBoundFunc3D -from .ConsGenIncProcessModel import ConsGenIncProcessSolver, PersistentShockConsumerType,\ - ValueFunc2D, MargValueFunc2D, MargMargValueFunc2D, \ - VariableLowerBoundFunc2D +from HARK.ConsumptionSaving.ConsGenIncProcessModel import ConsGenIncProcessSolver,\ + PersistentShockConsumerType, ValueFunc2D, MargValueFunc2D,\ + MargMargValueFunc2D, VariableLowerBoundFunc2D from copy import deepcopy utility_inv = CRRAutility_inv @@ -532,6 +531,9 @@ def __init__(self,cycles=1,time_flow=True,**kwds): self.solveOnePeriod = solveConsMedShock # Choose correct solver self.addToTimeInv('CRRAmed') self.addToTimeVary('MedPrice') + + def preSolve(self): + self.updateSolutionTerminal() def update(self): ''' @@ -1359,7 +1361,7 @@ def solveConsMedShock(solution_next,IncomeDstn,MedShkDstn,LivPrb,DiscFac,CRRA,CR ############################################################################### def main(): - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params from HARK.utilities import CRRAutility_inv from time import clock import matplotlib.pyplot as plt diff --git a/HARK/ConsumptionSaving/ConsPrefShockModel.py b/HARK/ConsumptionSaving/ConsPrefShockModel.py index f83032c68..636c8c3dd 100644 --- a/HARK/ConsumptionSaving/ConsPrefShockModel.py +++ b/HARK/ConsumptionSaving/ConsPrefShockModel.py @@ -12,7 +12,7 @@ from builtins import range import numpy as np from HARK.utilities import approxMeanOneLognormal -from .ConsIndShockModel import IndShockConsumerType, ConsumerSolution, ConsIndShockSolver, \ +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType, ConsumerSolution, ConsIndShockSolver, \ ValueFunc, MargValueFunc, KinkedRconsumerType, ConsKinkedRsolver from HARK.interpolation import LinearInterpOnInterp1D, LinearInterp, CubicInterp, LowerEnvelope @@ -43,6 +43,9 @@ def __init__(self,cycles=1,time_flow=True,**kwds): ''' IndShockConsumerType.__init__(self,cycles=cycles,time_flow=time_flow,**kwds) self.solveOnePeriod = solveConsPrefShock # Choose correct solver + + def preSolve(self): + self.updateSolutionTerminal() def update(self): ''' @@ -207,6 +210,9 @@ def __init__(self,cycles=1,time_flow=True,**kwds): self.solveOnePeriod = solveConsKinkyPref # Choose correct solver self.addToTimeInv('Rboro','Rsave') self.delFromTimeInv('Rfree') + + def preSolve(self): + self.updateSolutionTerminal() def getRfree(self): # Specify which getRfree to use return KinkedRconsumerType.getRfree(self) @@ -594,7 +600,7 @@ def solveConsKinkyPref(solution_next,IncomeDstn,PrefShkDstn, ############################################################################### def main(): - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params import matplotlib.pyplot as plt from HARK.utilities import plotFuncs from time import clock @@ -618,6 +624,8 @@ def main(): PrefShk = PrefShockExample.PrefShkDstn[0][1][j] c = PrefShockExample.solution[0].cFunc(m,PrefShk*np.ones_like(m)) plt.plot(m,c) + plt.xlim([0.,None]) + plt.ylim([0.,None]) plt.show() print('Consumption function (and MPC) when shock=1:') @@ -625,6 +633,8 @@ def main(): k = PrefShockExample.solution[0].cFunc.derivativeX(m,np.ones_like(m)) plt.plot(m,c) plt.plot(m,k) + plt.xlim([0.,None]) + plt.ylim([0.,None]) plt.show() if PrefShockExample.vFuncBool: @@ -657,6 +667,7 @@ def main(): PrefShk = KinkyPrefExample.PrefShkDstn[0][1][j] c = KinkyPrefExample.solution[0].cFunc(m,PrefShk*np.ones_like(m)) plt.plot(m,c) + plt.ylim([0.,None]) plt.show() print('Consumption function (and MPC) when shock=1:') @@ -664,6 +675,7 @@ def main(): k = KinkyPrefExample.solution[0].cFunc.derivativeX(m,np.ones_like(m)) plt.plot(m,c) plt.plot(m,k) + plt.ylim([0.,None]) plt.show() if KinkyPrefExample.vFuncBool: diff --git a/HARK/ConsumptionSaving/ConsRepAgentModel.py b/HARK/ConsumptionSaving/ConsRepAgentModel.py index 82d0179ae..1f58c2c3b 100644 --- a/HARK/ConsumptionSaving/ConsRepAgentModel.py +++ b/HARK/ConsumptionSaving/ConsRepAgentModel.py @@ -11,7 +11,7 @@ import numpy as np from HARK.interpolation import LinearInterp from HARK.simulation import drawUniform, drawDiscrete -from .ConsIndShockModel import IndShockConsumerType, ConsumerSolution, MargValueFunc +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType, ConsumerSolution, MargValueFunc def solveConsRepAgent(solution_next,DiscFac,CRRA,IncomeDstn,CapShare,DeprFac,PermGroFac,aXtraGrid): ''' @@ -209,6 +209,9 @@ def __init__(self,time_flow=True,**kwds): self.AgentCount = 1 # Hardcoded, because this is rep agent self.solveOnePeriod = solveConsRepAgent self.delFromTimeInv('Rfree','BoroCnstArt','vFuncBool','CubicBool') + + def preSolve(self): + self.updateSolutionTerminal() def getStates(self): ''' @@ -257,6 +260,9 @@ def __init__(self,time_flow=True,**kwds): ''' RepAgentConsumerType.__init__(self,time_flow=time_flow,**kwds) self.solveOnePeriod = solveConsRepAgentMarkov + + def preSolve(self): + self.updateSolutionTerminal() def updateSolutionTerminal(self): ''' @@ -331,7 +337,7 @@ def main(): from copy import deepcopy from time import clock from HARK.utilities import plotFuncs - from . import ConsumerParameters as Params + import HARK.ConsumptionSaving.ConsumerParameters as Params # Make a quick example dictionary RA_params = deepcopy(Params.init_idiosyncratic_shocks) diff --git a/HARK/ConsumptionSaving/ConsumerParameters.py b/HARK/ConsumptionSaving/ConsumerParameters.py index c63472541..dbeca20e0 100644 --- a/HARK/ConsumptionSaving/ConsumerParameters.py +++ b/HARK/ConsumptionSaving/ConsumerParameters.py @@ -179,6 +179,10 @@ CRRAPF = CRRA # Coefficient of relative risk aversion of perfect foresight calibration intercept_prev = 0.0 # Intercept of aggregate savings function slope_prev = 1.0 # Slope of aggregate savings function +verbose_cobb_douglas = True # Whether to print solution progress to screen while solving +T_discard = 200 # Number of simulated "burn in" periods to discard when updating AFunc +DampingFac = 0.5 # Damping factor when updating AFunc; puts DampingFac weight on old params, rest on new +max_loops = 20 # Maximum number of AFunc updating loops to allow # Make a dictionary to specify an aggregate shocks consumer init_agg_shocks = copy(init_idiosyncratic_shocks) @@ -205,7 +209,11 @@ 'AggregateL':1.0, 'act_T':1200, 'intercept_prev': intercept_prev, - 'slope_prev': slope_prev + 'slope_prev': slope_prev, + 'verbose': verbose_cobb_douglas, + 'T_discard': T_discard, + 'DampingFac': DampingFac, + 'max_loops': max_loops } # ----------------------------------------------------------------------------- diff --git a/HARK/ConsumptionSaving/Demos/Chinese_Growth.py b/HARK/ConsumptionSaving/Demos/Chinese_Growth.py deleted file mode 100644 index ba95e8b21..000000000 --- a/HARK/ConsumptionSaving/Demos/Chinese_Growth.py +++ /dev/null @@ -1,297 +0,0 @@ -""" -China's high net saving rate (approximately 25%) is a puzzle for economists, particularly in -light of a consistently high income growth rate. - -If the last exercise made you worry that invoking difficult-to-measure "uncertainty" can explain -anything (e.g. "the stock market fell today because the risk aversion of the representative -agent increased"), the next exercise may reassure you. It is designed to show that there are -limits to the phenomena that can be explained by invoking uncertainty. - -It asks "what beliefs about uncertainty would Chinese consumers need to hold in order to generate a -saving rate of 25%, given the rapid pace of Chinese growth"? - -#################################################################################################### -#################################################################################################### - -The first step is to create the ConsumerType we want to solve the model for. - -Model set up: - * "Standard" infinite horizon consumption/savings model, with mortality and - permanent and temporary shocks to income - * Markov state that represents the state of the Chinese economy (to be detailed later) - * Ex-ante heterogeneity in consumers' discount factors - -In our experiment, consumers will live in a stationary, low-growth environment (intended to -approximate China before 1978). Then, unexpectedly, income growth will surge at the same time -that income uncertainty increases (intended to approximate the effect of economic reforms in China -since 1978.) Consumers believe the high-growth, high-uncertainty state is highly persistent, but -temporary. - -HARK's MarkovConsumerType will be a very convient way to run this experiment. So we need to -prepare the parameters to create that ConsumerType, and then create it. -""" -from __future__ import division, print_function -### First bring in default parameter values from cstwPMC. We will change these as necessary. - -# Now, bring in what we need from the cstwMPC parameters -from builtins import str -from builtins import range -import HARK.cstwMPC.SetupParamsCSTW as cstwParams - -# Initialize the cstwMPC parameters -from copy import deepcopy -init_China_parameters = deepcopy(cstwParams.init_infinite) - -### Now, change the parameters as necessary -import numpy as np - -# For a Markov model, we need a Markov transition array. Create that array. -# Remember, for this simple example, we just have a low-growth state, and a high-growth state -StateCount = 2 #number of Markov states -ProbGrowthEnds = (1./160.) #probability agents assign to the high-growth state ending -MrkvArray = np.array([[1.,0.],[ProbGrowthEnds,1.-ProbGrowthEnds]]) #Markov array -init_China_parameters['MrkvArray'] = [MrkvArray] #assign the Markov array as a parameter - -# One other parameter to change: the number of agents in simulation -# We want to increase this, because later on when we vastly increase the variance of the permanent -# income shock, things get wonky. -# It is important to note that we need to change this value here, before we have used the parameters -# to initialize the MarkovConsumerType. This is because this parameter is used during initialization. -# Other parameters that are not used during initialization can also be assigned here, -# by changing the appropriate value in the init_China_parameters_dictionary; however, -# they can also be changed later, by altering the appropriate attribute of the initialized -# MarkovConsumerType. -init_China_parameters['AgentCount'] = 10000 - -### Import and initialize the HARK ConsumerType we want -### Here, we bring in an agent making a consumption/savings decision every period, subject -### to transitory and permanent income shocks, AND a Markov shock -from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType -ChinaExample = MarkovConsumerType(**init_China_parameters) - -# Currently, Markov states can differ in their interest factor, permanent growth factor, -# survival probability, and income distribution. Each of these needs to be specifically set. -# Do that here, except income distribution. That will be done later, because we want to examine -# the effects of different income distributions. - -ChinaExample.assignParameters(PermGroFac = [np.array([1.,1.06 ** (.25)])], #needs to be a list, with 0th element of shape of shape (StateCount,) - Rfree = np.array(StateCount*[init_China_parameters['Rfree']]), #need to be an array, of shape (StateCount,) - LivPrb = [np.array(StateCount*[init_China_parameters['LivPrb']][0])], #needs to be a list, with 0th element of shape of shape (StateCount,) - cycles = 0) -ChinaExample.track_vars = ['aNrmNow','cNrmNow','pLvlNow'] # Names of variables to be tracked - -#################################################################################################### -#################################################################################################### -""" -Now, add in ex-ante heterogeneity in consumers' discount factors -""" - -# The cstwMPC parameters do not define a discount factor, since there is ex-ante heterogeneity -# in the discount factor. To prepare to create this ex-ante heterogeneity, first create -# the desired number of consumer types - -num_consumer_types = 7 # declare the number of types we want -ChineseConsumerTypes = [] # initialize an empty list - -for nn in range(num_consumer_types): - # Now create the types, and append them to the list ChineseConsumerTypes - newType = deepcopy(ChinaExample) - ChineseConsumerTypes.append(newType) - -## Now, generate the desired ex-ante heterogeneity, by giving the different consumer types -## each with their own discount factor - -# First, decide the discount factors to assign -from HARK.utilities import approxUniform - -bottomDiscFac = 0.9800 -topDiscFac = 0.9934 -DiscFac_list = approxUniform(N=num_consumer_types,bot=bottomDiscFac,top=topDiscFac)[1] - -# Now, assign the discount factors we want to the ChineseConsumerTypes -for j in range(num_consumer_types): - ChineseConsumerTypes[j].DiscFac = DiscFac_list[j] - -#################################################################################################### -#################################################################################################### -""" -Now, write the function to perform the experiment. - -Recall that all parameters have been assigned appropriately, except for the income process. -This is because we want to see how much uncertainty needs to accompany the high-growth state -to generate the desired high savings rate. - -Therefore, among other things, this function will have to initialize and assign -the appropriate income process. -""" - -# First create the income distribution in the low-growth state, which we will not change -from HARK.ConsumptionSaving.ConsIndShockModel import constructLognormalIncomeProcessUnemployment -import HARK.ConsumptionSaving.ConsumerParameters as IncomeParams - -LowGrowthIncomeDstn = constructLognormalIncomeProcessUnemployment(IncomeParams)[0][0] - -# Remember the standard deviation of the permanent income shock in the low-growth state for later -LowGrowth_PermShkStd = IncomeParams.PermShkStd - - - -def calcNatlSavingRate(PrmShkVar_multiplier,RNG_seed = 0): - """ - This function actually performs the experiment we want. - - Remember this experiment is: get consumers into the steady-state associated with the low-growth - regime. Then, give them an unanticipated shock that increases the income growth rate - and permanent income uncertainty at the same time. What happens to the path for - the national saving rate? Can an increase in permanent income uncertainty - explain the high Chinese saving rate since economic reforms began? - - The inputs are: - * PrmShkVar_multiplier, the number by which we want to multiply the variance - of the permanent shock in the low-growth state to get the variance of the - permanent shock in the high-growth state - * RNG_seed, an integer to seed the random number generator for simulations. This useful - because we are going to run this function for different values of PrmShkVar_multiplier, - and we may not necessarily want the simulated agents in each run to experience - the same (normalized) shocks. - """ - - # First, make a deepcopy of the ChineseConsumerTypes (each with their own discount factor), - # because we are going to alter them - ChineseConsumerTypesNew = deepcopy(ChineseConsumerTypes) - - # Set the uncertainty in the high-growth state to the desired amount, keeping in mind - # that PermShkStd is a list of length 1 - PrmShkStd_multiplier = PrmShkVar_multiplier ** .5 - IncomeParams.PermShkStd = [LowGrowth_PermShkStd[0] * PrmShkStd_multiplier] - - # Construct the appropriate income distributions - HighGrowthIncomeDstn = constructLognormalIncomeProcessUnemployment(IncomeParams)[0][0] - - # To calculate the national saving rate, we need national income and national consumption - # To get those, we are going to start national income and consumption at 0, and then - # loop through each agent type and see how much they contribute to income and consumption. - NatlIncome = 0. - NatlCons = 0. - - for ChineseConsumerTypeNew in ChineseConsumerTypesNew: - ### For each consumer type (i.e. each discount factor), calculate total income - ### and consumption - - # First give each ConsumerType their own random number seed - RNG_seed += 19 - ChineseConsumerTypeNew.seed = RNG_seed - - # Set the income distribution in each Markov state appropriately - ChineseConsumerTypeNew.IncomeDstn = [[LowGrowthIncomeDstn,HighGrowthIncomeDstn]] - - # Solve the problem for this ChineseConsumerTypeNew - ChineseConsumerTypeNew.solve() - - """ - Now we are ready to simulate. - - This case will be a bit different than most, because agents' *perceptions* of the probability - of changes in the Chinese economy will differ from the actual probability of changes. - Specifically, agents think there is a 0% chance of moving out of the low-growth state, and - that there is a (1./160) chance of moving out of the high-growth state. In reality, we - want the Chinese economy to reach the low growth steady state, and then move into the - high growth state with probability 1. Then we want it to persist in the high growth - state for 40 years. - """ - - ## Now, simulate 500 quarters to get to steady state, then 40 years of high growth - ChineseConsumerTypeNew.T_sim = 660 - - # Ordinarily, the simulate method for a MarkovConsumerType randomly draws Markov states - # according to the transition probabilities in MrkvArray *independently* for each simulated - # agent. In this case, however, we want the discrete state to be *perfectly coordinated* - # across agents-- it represents a macroeconomic state, not a microeconomic one! In fact, - # we don't want a random history at all, but rather a specific, predetermined history: 125 - # years of low growth, followed by 40 years of high growth. - - # To do this, we're going to "hack" our consumer type a bit. First, we set the attribute - # MrkvPrbsInit so that all of the initial Markov states are in the low growth state. Then - # we initialize the simulation and run it for 500 quarters. However, as we do not - # want the Markov state to change during this time, we change its MrkvArray to always be in - # the low growth state with probability 1. - - ChineseConsumerTypeNew.MrkvPrbsInit = np.array([1.0,0.0]) # All consumers born in low growth state - ChineseConsumerTypeNew.MrkvArray[0] = np.array([[1.0,0.0],[1.0,0.0]]) # Stay in low growth state - ChineseConsumerTypeNew.initializeSim() # Clear the history and make all newborn agents - ChineseConsumerTypeNew.simulate(500) # Simulate 500 quarders of data - - # Now we want the high growth state to occur for the next 160 periods. We change the initial - # Markov probabilities so that any agents born during this time (to replace an agent who - # died) is born in the high growth state. Moreover, we change the MrkvArray to *always* be - # in the high growth state with probability 1. Then we simulate 160 more quarters. - - ChineseConsumerTypeNew.MrkvPrbsInit = np.array([0.0,1.0]) # All consumers born in low growth state - ChineseConsumerTypeNew.MrkvArray[0] = np.array([[0.0,1.0],[0.0,1.0]]) # Stay in low growth state - ChineseConsumerTypeNew.simulate(160) # Simulate 160 quarders of data - - # Now, get the aggregate income and consumption of this ConsumerType over time - IncomeOfThisConsumerType = np.sum((ChineseConsumerTypeNew.aNrmNow_hist*ChineseConsumerTypeNew.pLvlNow_hist* - (ChineseConsumerTypeNew.Rfree[0] - 1.)) + - ChineseConsumerTypeNew.pLvlNow_hist, axis=1) - - ConsOfThisConsumerType = np.sum(ChineseConsumerTypeNew.cNrmNow_hist*ChineseConsumerTypeNew.pLvlNow_hist,axis=1) - - # Add the income and consumption of this ConsumerType to national income and consumption - NatlIncome += IncomeOfThisConsumerType - NatlCons += ConsOfThisConsumerType - - - # After looping through all the ConsumerTypes, calculate and return the path of the national - # saving rate - NatlSavingRate = (NatlIncome - NatlCons) / NatlIncome - - return NatlSavingRate - - -#################################################################################################### -#################################################################################################### -""" -Now we can use the function we just defined to calculate the path of the national saving rate -following the economic reforms, for a given value of the increase to the variance of permanent -income accompanying the reforms. We are going to graph this path for various values for this -increase. - -Remember, we want to see if any plausible value for this increase can explain the high -Chinese saving rate. -""" - -# Declare the number of periods before the reforms to plot in the graph -quarters_before_reform_to_plot = 5 - -# Declare the quarters we want to plot results for -quarters_to_plot = np.arange(-quarters_before_reform_to_plot ,160,1) - -# Create a list to hold the paths of the national saving rate -NatlSavingsRates = [] - -# Create a list of floats to multiply the variance of the permanent shock to income by -PermShkVarMultipliers = (1.,2.,4.,8.,11.) - -# Loop through the desired multipliers, then get the path of the national saving rate -# following economic reforms, assuming that the variance of the permanent income shock -# was multiplied by the given multiplier -index = 0 -for PermShkVarMultiplier in PermShkVarMultipliers: - NatlSavingsRates.append(calcNatlSavingRate(PermShkVarMultiplier,RNG_seed = index)[-160 - quarters_before_reform_to_plot :]) - index +=1 - -# We've calculated the path of the national saving rate as we wanted -# All that's left is to graph the results! -import pylab as plt -plt.ylabel('Natl Savings Rate') -plt.xlabel('Quarters Since Economic Reforms') -plt.plot(quarters_to_plot,NatlSavingsRates[0],label=str(PermShkVarMultipliers[0]) + ' x variance') -plt.plot(quarters_to_plot,NatlSavingsRates[1],label=str(PermShkVarMultipliers[1]) + ' x variance') -plt.plot(quarters_to_plot,NatlSavingsRates[2],label=str(PermShkVarMultipliers[2]) + ' x variance') -plt.plot(quarters_to_plot,NatlSavingsRates[3],label=str(PermShkVarMultipliers[3]) + ' x variance') -plt.plot(quarters_to_plot,NatlSavingsRates[4],label=str(PermShkVarMultipliers[4]) + ' x variance') -plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, - ncol=2, mode="expand", borderaxespad=0.) #put the legend on top -plt.show() - diff --git a/HARK/ConsumptionSaving/Demos/NonDurables_During_Great_Recession.py b/HARK/ConsumptionSaving/Demos/NonDurables_During_Great_Recession.py deleted file mode 100644 index e60eee070..000000000 --- a/HARK/ConsumptionSaving/Demos/NonDurables_During_Great_Recession.py +++ /dev/null @@ -1,230 +0,0 @@ -""" -At the onset of the Great Recession, there was a large drop (6.32%, according to FRED) in consumer -spending on non-durables. Some economists have proffered that this could be attributed to precautionary -motives-- a perceived increase in household income uncertainty induces more saving (less consumption) -to protect future consumption against bad income shocks. How large of an increase in the standard -deviation of (log) permanent income shocks would be necessary to see an 6.32% drop in consumption in -one quarter? What about transitory income shocks? How high would the perceived unemployment -probability have to be? - -#################################################################################################### -#################################################################################################### - -The first step is to create the ConsumerType we want to solve the model for. - -Model set up: - * "Standard" infinite horizon consumption/savings model, with mortality and - permanent and temporary shocks to income - * Ex-ante heterogeneity in consumers' discount factors - -With this basic setup, HARK's IndShockConsumerType is the appropriate ConsumerType. -So we need to prepare the parameters to create that ConsumerType, and then create it. -""" - -## Import some things from cstwMPC -from __future__ import division, print_function -from builtins import str -from builtins import range -import numpy as np -from copy import deepcopy - -# Now, bring in what we need from the cstwMPC parameters -import HARK.cstwMPC.SetupParamsCSTW as cstwParams -from HARK.utilities import approxUniform - -## Import the HARK ConsumerType we want -## Here, we bring in an agent making a consumption/savings decision every period, subject -## to transitory and permanent income shocks. -from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType - -# Now initialize a baseline consumer type, using default parameters from infinite horizon cstwMPC -BaselineType = IndShockConsumerType(**cstwParams.init_infinite) -BaselineType.AgentCount = 10000 # Assign the baseline consumer type to have many agents in simulation - -#################################################################################################### -#################################################################################################### -""" -Now, add in ex-ante heterogeneity in consumers' discount factors -""" - -# The cstwMPC parameters do not define a discount factor, since there is ex-ante heterogeneity -# in the discount factor. To prepare to create this ex-ante heterogeneity, first create -# the desired number of consumer types -num_consumer_types = 7 # declare the number of types we want -ConsumerTypes = [] # initialize an empty list - -for nn in range(num_consumer_types): - # Now create the types, and append them to the list ConsumerTypes - newType = deepcopy(BaselineType) - ConsumerTypes.append(newType) - ConsumerTypes[-1].seed = nn # give each consumer type a different RNG seed - -## Now, generate the desired ex-ante heterogeneity, by giving the different consumer types -## each their own discount factor - -# First, decide the discount factors to assign -bottomDiscFac = 0.9800 -topDiscFac = 0.9934 -DiscFac_list = approxUniform(N=num_consumer_types,bot=bottomDiscFac,top=topDiscFac)[1] - -# Now, assign the discount factors we want -for j in range(num_consumer_types): - ConsumerTypes[j].DiscFac = DiscFac_list[j] - -##################################################################################################### -##################################################################################################### -""" -Now, solve and simulate the model for each consumer type -""" - -for ConsumerType in ConsumerTypes: - ### First solve the problem for this ConsumerType. - ConsumerType.solve() - - ### Now simulate many periods to get to the stationary distribution - ConsumerType.T_sim = 1000 - ConsumerType.initializeSim() - ConsumerType.simulate() - -##################################################################################################### -##################################################################################################### -""" -Now, create functions to see how aggregate consumption changes after household income uncertainty -increases in various ways -""" - -# In order to see how consumption changes, we need to be able to calculate average consumption -# in the last period. Create a function do to that here. -def calcAvgC(ConsumerTypes): - """ - This function calculates average consumption in the economy in last simulated period, - averaging across ConsumerTypes. - """ - # Make arrays with all types' (normalized) consumption and permanent income level - cNrm = np.concatenate([ThisType.cNrmNow for ThisType in ConsumerTypes]) - pLvl = np.concatenate([ThisType.pLvlNow for ThisType in ConsumerTypes]) - - # Calculate and return average consumption level in the economy - avgC = np.mean(cNrm*pLvl) - return avgC - -# Now create a function to run the experiment we want -- change income uncertainty, and see -# how consumption changes -def cChangeAfterUncertaintyChange(ConsumerTypes,newVals,paramToChange): - """ - Function to calculate the change in average consumption after change(s) in income uncertainty - Inputs: - * consumerTypes, a list of consumer types - * newvals, a list of new values to use for the income parameters - * paramToChange, a string telling the function which part of the income process to change - """ - - # Initialize an empty list to hold the changes in consumption that happen after parameters change. - changesInConsumption = [] - - # Get average consumption before parameters change - oldAvgC = calcAvgC(ConsumerTypes) - - # Now loop through the new income parameter values to assign, first assigning them, and then - # solving and simulating another period with those values - for newVal in newVals: - if paramToChange in ["PermShkStd","TranShkStd"]: # These parameters are time-varying, and thus are contained in a list. - thisVal = [newVal] # We need to make sure that our updated values are *also* in a (one element) list. - else: - thisVal = newVal - - # Copy everything we have from the consumerTypes - ConsumerTypesNew = deepcopy(ConsumerTypes) - - for index,ConsumerTypeNew in enumerate(ConsumerTypesNew): - setattr(ConsumerTypeNew,paramToChange,thisVal) # Set the changed value of the parameter - - # Because we changed the income process, and the income process is created - # during initialization, we need to be sure to update the income process - ConsumerTypeNew.updateIncomeProcess() - - # Solve the new problem - ConsumerTypeNew.solve() - - # Initialize the new consumer type to have the same distribution of assets and permanent - # income as the stationary distribution we simulated above - ConsumerTypeNew.initializeSim() # Reset the tracked history - ConsumerTypeNew.aNrmNow = ConsumerTypes[index].aNrmNow # Set assets to stationary distribution - ConsumerTypeNew.pLvlNow = ConsumerTypes[index].pLvlNow # Set permanent income to stationary dstn - - # Simulate one more period, which changes the values in cNrm and pLvl for each agent type - ConsumerTypeNew.simOnePeriod() - - # Calculate the percent change in consumption, for this value newVal for the given parameter - newAvgC = calcAvgC(ConsumerTypesNew) - changeInConsumption = 100. * (newAvgC - oldAvgC) / oldAvgC - - # Append the change in consumption to the list changesInConsumption - changesInConsumption.append(changeInConsumption) - - # Return the list of changes in consumption - return changesInConsumption - -## Define functions that calculate the change in average consumption after income process changes -def cChangeAfterPrmShkChange(newVals): - return cChangeAfterUncertaintyChange(ConsumerTypes,newVals,"PermShkStd") - -def cChangeAfterTranShkChange(newVals): - return cChangeAfterUncertaintyChange(ConsumerTypes,newVals,"TranShkStd") - -def cChangeAfterUnempPrbChange(newVals): - return cChangeAfterUncertaintyChange(ConsumerTypes,newVals,"UnempPrb") - -## Now, plot the functions we want - -# Import a useful plotting function from HARK.utilities -from HARK.utilities import plotFuncs -import matplotlib.pyplot as plt # We need this module to change the y-axis on the graphs - -ratio_min = 1. # minimum number to multiply income parameter by -targetChangeInC = -6.32 # Source: FRED -num_points = 10 #number of parameter values to plot in graphs - -## First change the variance of the permanent income shock -perm_ratio_max = 5.0 #??? # Put whatever value in you want! maximum number to multiply std of perm income shock by - -perm_min = BaselineType.PermShkStd[0] * ratio_min -perm_max = BaselineType.PermShkStd[0] * perm_ratio_max - -plt.ylabel('% Change in Consumption') -plt.xlabel('Std. Dev. of Perm. Income Shock (Baseline = ' + str(round(BaselineType.PermShkStd[0],2)) + ')') -plt.title('Change in Cons. Following Increase in Perm. Income Uncertainty') -plt.ylim(-20.,5.) -plt.hlines(targetChangeInC,perm_min,perm_max) -plotFuncs([cChangeAfterPrmShkChange],perm_min,perm_max,N=num_points) - - -### Now change the variance of the temporary income shock -#temp_ratio_max = ??? # Put whatever value in you want! maximum number to multiply std dev of temp income shock by -# -#temp_min = BaselineType.TranShkStd[0] * ratio_min -#temp_max = BaselineType.TranShkStd[0] * temp_ratio_max -# -#plt.ylabel('% Change in Consumption') -#plt.xlabel('Std. Dev. of Temp. Income Shock (Baseline = ' + str(round(BaselineType.TranShkStd[0],2)) + ')') -#plt.title('Change in Cons. Following Increase in Temp. Income Uncertainty') -#plt.ylim(-20.,5.) -#plt.hlines(targetChangeInC,temp_min,temp_max) -#plotFuncs([cChangeAfterTranShkChange],temp_min,temp_max,N=num_points) -# -# -# -### Now change the probability of unemployment -#unemp_ratio_max = ??? # Put whatever value in you want! maximum number to multiply prob of unemployment by -# -#unemp_min = BaselineType.UnempPrb * ratio_min -#unemp_max = BaselineType.UnempPrb * unemp_ratio_max -# -#plt.ylabel('% Change in Consumption') -#plt.xlabel('Unemployment Prob. (Baseline = ' + str(round(BaselineType.UnempPrb,2)) + ')') -#plt.title('Change in Cons. Following Increase in Unemployment Prob.') -#plt.ylim(-20.,5.) -#plt.hlines(targetChangeInC,unemp_min,unemp_max) -#plotFuncs([cChangeAfterUnempPrbChange],unemp_min,unemp_max,N=num_points) -# -# diff --git a/HARK/ConsumptionSaving/RepAgentModel.py b/HARK/ConsumptionSaving/RepAgentModel.py index dbeea42af..6dbae740a 100644 --- a/HARK/ConsumptionSaving/RepAgentModel.py +++ b/HARK/ConsumptionSaving/RepAgentModel.py @@ -1,384 +1,11 @@ ''' -This module contains models for solving representative agent macroeconomic models. -This stands in contrast to all other model modules in HARK, which (unsurprisingly) -take a heterogeneous agents approach. In these models, all attributes are either -time invariant or exist on a short cycle. +This file appears to be an old version of what is now ConsRepAgentModel.py. +Its previous contents have been entirely removed and replaced with a universal +import from ConsRepAgentModel. Whenever a user imports from this file, they +will get a warning that they should import from ConsRepAgentModel instead. ''' -from __future__ import division, print_function -from __future__ import absolute_import -from builtins import str -from builtins import range -import numpy as np -from HARK.interpolation import LinearInterp -from HARK.simulation import drawUniform, drawDiscrete -from .ConsIndShockModel import IndShockConsumerType, ConsumerSolution, MargValueFunc -def solveConsRepAgent(solution_next,DiscFac,CRRA,IncomeDstn,CapShare,DeprFac,PermGroFac,aXtraGrid): - ''' - Solve one period of the simple representative agent consumption-saving model. - - Parameters - ---------- - solution_next : ConsumerSolution - Solution to the next period's problem (i.e. previous iteration). - DiscFac : float - Intertemporal discount factor for future utility. - CRRA : float - Coefficient of relative risk aversion. - IncomeDstn : [np.array] - A list containing three arrays of floats, representing a discrete - approximation to the income process between the period being solved - and the one immediately following (in solution_next). Order: event - probabilities, permanent shocks, transitory shocks. - CapShare : float - Capital's share of income in Cobb-Douglas production function. - DeprFac : float - Depreciation rate of capital. - PermGroFac : float - Expected permanent income growth factor at the end of this period. - aXtraGrid : np.array - Array of "extra" end-of-period asset values-- assets above the - absolute minimum acceptable level. In this model, the minimum acceptable - level is always zero. - - Returns - ------- - solution_now : ConsumerSolution - Solution to this period's problem (new iteration). - ''' - # Unpack next period's solution and the income distribution - vPfuncNext = solution_next.vPfunc - ShkPrbsNext = IncomeDstn[0] - PermShkValsNext = IncomeDstn[1] - TranShKValsNext = IncomeDstn[2] - - # Make tiled versions of end-of-period assets, shocks, and probabilities - aNrmNow = aXtraGrid - aNrmCount = aNrmNow.size - ShkCount = ShkPrbsNext.size - aNrm_tiled = np.tile(np.reshape(aNrmNow,(aNrmCount,1)),(1,ShkCount)) - - # Tile arrays of the income shocks and put them into useful shapes - PermShkVals_tiled = np.tile(np.reshape(PermShkValsNext,(1,ShkCount)),(aNrmCount,1)) - TranShkVals_tiled = np.tile(np.reshape(TranShKValsNext,(1,ShkCount)),(aNrmCount,1)) - ShkPrbs_tiled = np.tile(np.reshape(ShkPrbsNext,(1,ShkCount)),(aNrmCount,1)) - - # Calculate next period's capital-to-permanent-labor ratio under each combination - # of end-of-period assets and shock realization - kNrmNext = aNrm_tiled/(PermGroFac*PermShkVals_tiled) - - # Calculate next period's market resources - KtoLnext = kNrmNext/TranShkVals_tiled - RfreeNext = 1. - DeprFac + CapShare*KtoLnext**(CapShare-1.) - wRteNext = (1.-CapShare)*KtoLnext**CapShare - mNrmNext = RfreeNext*kNrmNext + wRteNext*TranShkVals_tiled - - # Calculate end-of-period marginal value of assets for the RA - vPnext = vPfuncNext(mNrmNext) - EndOfPrdvP = DiscFac*np.sum(RfreeNext*(PermGroFac*PermShkVals_tiled)**(-CRRA)*vPnext*ShkPrbs_tiled,axis=1) - - # Invert the first order condition to get consumption, then find endogenous gridpoints - cNrmNow = EndOfPrdvP**(-1./CRRA) - mNrmNow = aNrmNow + cNrmNow - - # Construct the consumption function and the marginal value function - cFuncNow = LinearInterp(np.insert(mNrmNow,0,0.0),np.insert(cNrmNow,0,0.0)) - vPfuncNow = MargValueFunc(cFuncNow,CRRA) - - # Construct and return the solution for this period - solution_now = ConsumerSolution(cFunc=cFuncNow,vPfunc=vPfuncNow) - return solution_now - - - -def solveConsRepAgentMarkov(solution_next,MrkvArray,DiscFac,CRRA,IncomeDstn,CapShare,DeprFac,PermGroFac,aXtraGrid): - ''' - Solve one period of the simple representative agent consumption-saving model. - This version supports a discrete Markov process. - - Parameters - ---------- - solution_next : ConsumerSolution - Solution to the next period's problem (i.e. previous iteration). - MrkvArray : np.array - Markov transition array between this period and next period. - DiscFac : float - Intertemporal discount factor for future utility. - CRRA : float - Coefficient of relative risk aversion. - IncomeDstn : [[np.array]] - A list of lists containing three arrays of floats, representing a discrete - approximation to the income process between the period being solved - and the one immediately following (in solution_next). Order: event - probabilities, permanent shocks, transitory shocks. - CapShare : float - Capital's share of income in Cobb-Douglas production function. - DeprFac : float - Depreciation rate of capital. - PermGroFac : [float] - Expected permanent income growth factor for each state we could be in - next period. - aXtraGrid : np.array - Array of "extra" end-of-period asset values-- assets above the - absolute minimum acceptable level. In this model, the minimum acceptable - level is always zero. - - Returns - ------- - solution_now : ConsumerSolution - Solution to this period's problem (new iteration). - ''' - # Define basic objects - StateCount = MrkvArray.shape[0] - aNrmNow = aXtraGrid - aNrmCount = aNrmNow.size - EndOfPrdvP_cond = np.zeros((StateCount,aNrmCount)) + np.nan - - # Loop over *next period* states, calculating conditional EndOfPrdvP - for j in range(StateCount): - # Define next-period-state conditional objects - vPfuncNext = solution_next.vPfunc[j] - ShkPrbsNext = IncomeDstn[j][0] - PermShkValsNext = IncomeDstn[j][1] - TranShKValsNext = IncomeDstn[j][2] - - # Make tiled versions of end-of-period assets, shocks, and probabilities - ShkCount = ShkPrbsNext.size - aNrm_tiled = np.tile(np.reshape(aNrmNow,(aNrmCount,1)),(1,ShkCount)) - - # Tile arrays of the income shocks and put them into useful shapes - PermShkVals_tiled = np.tile(np.reshape(PermShkValsNext,(1,ShkCount)),(aNrmCount,1)) - TranShkVals_tiled = np.tile(np.reshape(TranShKValsNext,(1,ShkCount)),(aNrmCount,1)) - ShkPrbs_tiled = np.tile(np.reshape(ShkPrbsNext,(1,ShkCount)),(aNrmCount,1)) - - # Calculate next period's capital-to-permanent-labor ratio under each combination - # of end-of-period assets and shock realization - kNrmNext = aNrm_tiled/(PermGroFac[j]*PermShkVals_tiled) - - # Calculate next period's market resources - KtoLnext = kNrmNext/TranShkVals_tiled - RfreeNext = 1. - DeprFac + CapShare*KtoLnext**(CapShare-1.) - wRteNext = (1.-CapShare)*KtoLnext**CapShare - mNrmNext = RfreeNext*kNrmNext + wRteNext*TranShkVals_tiled - - # Calculate end-of-period marginal value of assets for the RA - vPnext = vPfuncNext(mNrmNext) - EndOfPrdvP_cond[j,:] = DiscFac*np.sum(RfreeNext*(PermGroFac[j]*PermShkVals_tiled)**(-CRRA)*vPnext*ShkPrbs_tiled,axis=1) - - # Apply the Markov transition matrix to get unconditional end-of-period marginal value - EndOfPrdvP = np.dot(MrkvArray,EndOfPrdvP_cond) - - # Construct the consumption function and marginal value function for each discrete state - cFuncNow_list = [] - vPfuncNow_list = [] - for i in range(StateCount): - # Invert the first order condition to get consumption, then find endogenous gridpoints - cNrmNow = EndOfPrdvP[i,:]**(-1./CRRA) - mNrmNow = aNrmNow + cNrmNow - - # Construct the consumption function and the marginal value function - cFuncNow_list.append(LinearInterp(np.insert(mNrmNow,0,0.0),np.insert(cNrmNow,0,0.0))) - vPfuncNow_list.append(MargValueFunc(cFuncNow_list[-1],CRRA)) - - # Construct and return the solution for this period - solution_now = ConsumerSolution(cFunc=cFuncNow_list,vPfunc=vPfuncNow_list) - return solution_now - - - -class RepAgentConsumerType(IndShockConsumerType): - ''' - A class for representing representative agents with inelastic labor supply. - ''' - time_inv_ = IndShockConsumerType.time_inv_ + ['CapShare','DeprFac'] - - def __init__(self,time_flow=True,**kwds): - ''' - Make a new instance of a representative agent. - - Parameters - ---------- - time_flow : boolean - Whether time is currently "flowing" forward for this instance. - - Returns - ------- - None - ''' - IndShockConsumerType.__init__(self,cycles=0,time_flow=time_flow,**kwds) - self.AgentCount = 1 # Hardcoded, because this is rep agent - self.solveOnePeriod = solveConsRepAgent - self.delFromTimeInv('Rfree','BoroCnstArt','vFuncBool','CubicBool') - - def getStates(self): - ''' - Calculates updated values of normalized market resources and permanent income level. - Uses pLvlNow, aNrmNow, PermShkNow, TranShkNow. - - Parameters - ---------- - None - - Returns - ------- - None - ''' - pLvlPrev = self.pLvlNow - aNrmPrev = self.aNrmNow - - # Calculate new states: normalized market resources and permanent income level - self.pLvlNow = pLvlPrev*self.PermShkNow # Updated permanent income level - self.kNrmNow = aNrmPrev/self.PermShkNow - self.yNrmNow = self.kNrmNow**self.CapShare*self.TranShkNow**(1.-self.CapShare) - self.Rfree = 1. + self.CapShare*self.kNrmNow**(self.CapShare-1.)*self.TranShkNow**(1.-self.CapShare) - self.DeprFac - self.wRte = (1.-self.CapShare)*self.kNrmNow**self.CapShare*self.TranShkNow**(-self.CapShare) - self.mNrmNow = self.Rfree*self.kNrmNow + self.wRte*self.TranShkNow - - -class RepAgentMarkovConsumerType(RepAgentConsumerType): - ''' - A class for representing representative agents with inelastic labor supply - and a discrete MarkovState - ''' - time_inv_ = RepAgentConsumerType.time_inv_ + ['MrkvArray'] - - def __init__(self,time_flow=True,**kwds): - ''' - Make a new instance of a representative agent with Markov state. - - Parameters - ---------- - time_flow : boolean - Whether time is currently "flowing" forward for this instance. - - Returns - ------- - None - ''' - RepAgentConsumerType.__init__(self,time_flow=time_flow,**kwds) - self.solveOnePeriod = solveConsRepAgentMarkov - - def updateSolutionTerminal(self): - ''' - Update the terminal period solution. This method should be run when a - new AgentType is created or when CRRA changes. - - Parameters - ---------- - None - - Returns - ------- - None - ''' - RepAgentConsumerType.updateSolutionTerminal(self) - - # Make replicated terminal period solution - StateCount = self.MrkvArray.shape[0] - self.solution_terminal.cFunc = StateCount*[self.cFunc_terminal_] - self.solution_terminal.vPfunc = StateCount*[self.solution_terminal.vPfunc] - self.solution_terminal.mNrmMin = StateCount*[self.solution_terminal.mNrmMin] - - - def getShocks(self): - ''' - Draws a new Markov state and income shocks for the representative agent. - - Parameters - ---------- - None - - Returns - ------- - None - ''' - cutoffs = np.cumsum(self.MrkvArray[self.MrkvNow,:]) - MrkvDraw = drawUniform(N=1,seed=self.RNG.randint(0,2**31-1)) - self.MrkvNow = np.searchsorted(cutoffs,MrkvDraw) - - t = self.t_cycle[0] - i = self.MrkvNow[0] - IncomeDstnNow = self.IncomeDstn[t-1][i] # set current income distribution - PermGroFacNow = self.PermGroFac[t-1][i] # and permanent growth factor - Indices = np.arange(IncomeDstnNow[0].size) # just a list of integers - # Get random draws of income shocks from the discrete distribution - EventDraw = drawDiscrete(N=1,X=Indices,P=IncomeDstnNow[0],exact_match=False,seed=self.RNG.randint(0,2**31-1)) - PermShkNow = IncomeDstnNow[1][EventDraw]*PermGroFacNow # permanent "shock" includes expected growth - TranShkNow = IncomeDstnNow[2][EventDraw] - self.PermShkNow = np.array(PermShkNow) - self.TranShkNow = np.array(TranShkNow) - - - def getControls(self): - ''' - Calculates consumption for the representative agent using the consumption functions. - - Parameters - ---------- - None - - Returns - ------- - None - ''' - t = self.t_cycle[0] - i = self.MrkvNow[0] - self.cNrmNow = self.solution[t].cFunc[i](self.mNrmNow) - - -############################################################################### -def main(): - from copy import deepcopy - from time import clock - from HARK.utilities import plotFuncs - from . import ConsumerParameters as Params - - # Make a quick example dictionary - RA_params = deepcopy(Params.init_idiosyncratic_shocks) - RA_params['DeprFac'] = 0.05 - RA_params['CapShare'] = 0.36 - RA_params['UnempPrb'] = 0.0 - RA_params['LivPrb'] = [1.0] - - # Make and solve a rep agent model - RAexample = RepAgentConsumerType(**RA_params) - t_start = clock() - RAexample.solve() - t_end = clock() - print('Solving a representative agent problem took ' + str(t_end-t_start) + ' seconds.') - plotFuncs(RAexample.solution[0].cFunc,0,20) - - # Simulate the representative agent model - RAexample.T_sim = 2000 - RAexample.track_vars = ['cNrmNow','mNrmNow','Rfree','wRte'] - RAexample.initializeSim() - t_start = clock() - RAexample.simulate() - t_end = clock() - print('Simulating a representative agent for ' + str(RAexample.T_sim) + ' periods took ' + str(t_end-t_start) + ' seconds.') - - # Make and solve a Markov representative agent - RA_markov_params = deepcopy(RA_params) - RA_markov_params['PermGroFac'] = [[0.97,1.03]] - RA_markov_params['MrkvArray'] = np.array([[0.99,0.01],[0.01,0.99]]) - RA_markov_params['MrkvNow'] = 0 - RAmarkovExample = RepAgentMarkovConsumerType(**RA_markov_params) - RAmarkovExample.IncomeDstn[0] = 2*[RAmarkovExample.IncomeDstn[0]] - t_start = clock() - RAmarkovExample.solve() - t_end = clock() - print('Solving a two state representative agent problem took ' + str(t_end-t_start) + ' seconds.') - plotFuncs(RAmarkovExample.solution[0].cFunc,0,10) - - # Simulate the two state representative agent model - RAmarkovExample.T_sim = 2000 - RAmarkovExample.track_vars = ['cNrmNow','mNrmNow','Rfree','wRte','MrkvNow'] - RAmarkovExample.initializeSim() - t_start = clock() - RAmarkovExample.simulate() - t_end = clock() - print('Simulating a two state representative agent for ' + str(RAexample.T_sim) + ' periods took ' + str(t_end-t_start) + ' seconds.') - -if __name__ == '__main__': - main() +import warnings +from HARK.ConsumptionSaving.ConsRepAgentModel import * +warnings.warn('Please import from ConsRepAgentModel rather than RepAgentModel. This module will be removed in a future version of HARK.') \ No newline at end of file diff --git a/HARK/ConsumptionSaving/TractableBufferStockModel.py b/HARK/ConsumptionSaving/TractableBufferStockModel.py index 88f78d578..057b4c3d5 100644 --- a/HARK/ConsumptionSaving/TractableBufferStockModel.py +++ b/HARK/ConsumptionSaving/TractableBufferStockModel.py @@ -474,7 +474,7 @@ def main(): # contained in the HARK folder. Also import the ConsumptionSavingModel import numpy as np # numeric Python from HARK.utilities import plotFuncs # basic plotting tools - from .ConsMarkovModel import MarkovConsumerType # An alternative, much longer way to solve the TBS model + from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType # An alternative, much longer way to solve the TBS model from time import clock # timing utility do_simulation = True diff --git a/HARK/__init__.py b/HARK/__init__.py index c4d09cb22..b36e35f84 100644 --- a/HARK/__init__.py +++ b/HARK/__init__.py @@ -1,2 +1,4 @@ from __future__ import absolute_import from .core import * + +__version__ = '0.10.1' diff --git a/HARK/core.py b/HARK/core.py index 1b339d29a..55b7136d3 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -21,7 +21,8 @@ from time import clock from .parallel import multiThreadCommands, multiThreadCommandsFake -def distanceMetric(thing_A,thing_B): + +def distanceMetric(thing_A, thing_B): ''' A "universal distance" metric that can be used as a default in many settings. @@ -42,12 +43,12 @@ def distanceMetric(thing_A,thing_B): typeB = type(thing_B) if typeA is list and typeB is list: - lenA = len(thing_A) # If both inputs are lists, then the distance between - lenB = len(thing_B) # them is the maximum distance between corresponding - if lenA == lenB: # elements in the lists. If they differ in length, - distance_temp = [] # the distance is the difference in lengths. + lenA = len(thing_A) # If both inputs are lists, then the distance between + lenB = len(thing_B) # them is the maximum distance between corresponding + if lenA == lenB: # elements in the lists. If they differ in length, + distance_temp = [] # the distance is the difference in lengths. for n in range(lenA): - distance_temp.append(distanceMetric(thing_A[n],thing_B[n])) + distance_temp.append(distanceMetric(thing_A[n], thing_B[n])) distance = max(distance_temp) else: distance = float(abs(lenA - lenB)) @@ -57,7 +58,7 @@ def distanceMetric(thing_A,thing_B): # If both inputs are array-like, return the maximum absolute difference b/w # corresponding elements (if same shape); return largest difference in dimensions # if shapes do not align. - elif hasattr(thing_A,'shape') and hasattr(thing_B,'shape'): + elif hasattr(thing_A, 'shape') and hasattr(thing_B, 'shape'): if thing_A.shape == thing_B.shape: distance = np.max(abs(thing_A - thing_B)) else: @@ -69,16 +70,17 @@ def distanceMetric(thing_A,thing_B): distance = 0.0 else: distance = thing_A.distance(thing_B) - else: # Failsafe: the inputs are very far apart + else: # Failsafe: the inputs are very far apart distance = 1000.0 return distance + class HARKobject(object): ''' A superclass for object classes in HARK. Comes with two useful methods: a generic/universal distance method and an attribute assignment method. ''' - def distance(self,other): + def distance(self, other): ''' A generic distance method, which requires the existence of an attribute called distance_criteria, giving a list of strings naming the attributes @@ -98,14 +100,14 @@ def distance(self,other): distance_list = [0.0] for attr_name in self.distance_criteria: try: - obj_A = getattr(self,attr_name) - obj_B = getattr(other,attr_name) - distance_list.append(distanceMetric(obj_A,obj_B)) - except: - distance_list.append(1000.0) # if either object lacks attribute, they are not the same + obj_A = getattr(self, attr_name) + obj_B = getattr(other, attr_name) + distance_list.append(distanceMetric(obj_A, obj_B)) + except AttributeError: + distance_list.append(1000.0) # if either object lacks attribute, they are not the same return max(distance_list) - def assignParameters(self,**kwds): + def assignParameters(self, **kwds): ''' Assign an arbitrary number of attributes to this agent. @@ -120,16 +122,16 @@ def assignParameters(self,**kwds): none ''' for key in kwds: - setattr(self,key,kwds[key]) + setattr(self, key, kwds[key]) - def __call__(self,**kwds): + def __call__(self, **kwds): ''' Assign an arbitrary number of attributes to this agent, as a convenience. See assignParameters. ''' self.assignParameters(**kwds) - def getAvg(self,varname,**kwds): + def getAvg(self, varname, **kwds): ''' Calculates the average of an attribute of this instance. Returns NaN if no such attribute. @@ -144,11 +146,12 @@ def getAvg(self,varname,**kwds): avg : float or np.array The average of this attribute. Might be an array if the axis keyword is passed. ''' - if hasattr(self,varname): - return np.mean(getattr(self,varname),**kwds) + if hasattr(self, varname): + return np.mean(getattr(self, varname), **kwds) else: return np.nan + class Solution(HARKobject): ''' A superclass for representing the "solution" to a single period problem in a @@ -158,6 +161,7 @@ class Solution(HARKobject): replacing each instance of Solution with HARKobject in the other modules. ''' + class AgentType(HARKobject): ''' A superclass for economic agents in the HARK framework. Each model should @@ -170,8 +174,8 @@ class AgentType(HARKobject): 'solveOnePeriod' should appear in exactly one of these lists, depending on whether the same solution method is used in all periods of the model. ''' - def __init__(self,solution_terminal=None,cycles=1,time_flow=False,pseudo_terminal=True, - tolerance=0.000001,seed=0,**kwds): + def __init__(self, solution_terminal=None, cycles=1, time_flow=False, pseudo_terminal=True, + tolerance=0.000001, seed=0, **kwds): ''' Initialize an instance of AgentType by setting attributes. @@ -211,18 +215,18 @@ def __init__(self,solution_terminal=None,cycles=1,time_flow=False,pseudo_termina ''' if solution_terminal is None: solution_terminal = NullFunc() - self.solution_terminal = solution_terminal - self.cycles = cycles - self.time_flow = time_flow - self.pseudo_terminal = pseudo_terminal - self.solveOnePeriod = NullFunc() - self.tolerance = tolerance - self.seed = seed - self.track_vars = [] - self.poststate_vars = [] - self.read_shocks = False - self.assignParameters(**kwds) - self.resetRNG() + self.solution_terminal = solution_terminal # NOQA + self.cycles = cycles # NOQA + self.time_flow = time_flow # NOQA + self.pseudo_terminal = pseudo_terminal # NOQA + self.solveOnePeriod = NullFunc() # NOQA + self.tolerance = tolerance # NOQA + self.seed = seed # NOQA + self.track_vars = [] # NOQA + self.poststate_vars = [] # NOQA + self.read_shocks = False # NOQA + self.assignParameters(**kwds) # NOQA + self.resetRNG() # NOQA def timeReport(self): ''' @@ -288,7 +292,7 @@ def timeRev(self): if self.time_flow: self.timeFlip() - def addToTimeVary(self,*params): + def addToTimeVary(self, *params): ''' Adds any number of parameters to time_vary for this instance. @@ -305,7 +309,7 @@ def addToTimeVary(self,*params): if param not in self.time_vary: self.time_vary.append(param) - def addToTimeInv(self,*params): + def addToTimeInv(self, *params): ''' Adds any number of parameters to time_inv for this instance. @@ -322,7 +326,7 @@ def addToTimeInv(self,*params): if param not in self.time_inv: self.time_inv.append(param) - def delFromTimeVary(self,*params): + def delFromTimeVary(self, *params): ''' Removes any number of parameters from time_vary for this instance. @@ -339,7 +343,7 @@ def delFromTimeVary(self,*params): if param in self.time_vary: self.time_vary.remove(param) - def delFromTimeInv(self,*params): + def delFromTimeInv(self, *params): ''' Removes any number of parameters from time_inv for this instance. @@ -356,7 +360,7 @@ def delFromTimeInv(self,*params): if param in self.time_inv: self.time_inv.remove(param) - def solve(self,verbose=False): + def solve(self, verbose=False): ''' Solve the model for this instance of an agent type by backward induction. Loops through the sequence of one period problems, passing the solution @@ -372,12 +376,16 @@ def solve(self,verbose=False): none ''' - self.preSolve() # Do pre-solution stuff - self.solution = solveAgent(self,verbose) # Solve the model by backward induction - if self.time_flow: # Put the solution in chronological order if this instance's time flow runs that way - self.solution.reverse() - self.addToTimeVary('solution') # Add solution to the list of time-varying attributes - self.postSolve() # Do post-solution stuff + # Ignore floating point "errors". Numpy calls it "errors", but really it's excep- + # tions with well-defined answers such as 1.0/0.0 that is np.inf, -1.0/0.0 that is + # -np.inf, np.inf/np.inf is np.nan and so on. + with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): + self.preSolve() # Do pre-solution stuff + self.solution = solveAgent(self, verbose) # Solve the model by backward induction + if self.time_flow: # Put the solution in chronological order if this instance's time flow runs that way + self.solution.reverse() + self.addToTimeVary('solution') # Add solution to the list of time-varying attributes + self.postSolve() # Do post-solution stuff def resetRNG(self): ''' @@ -398,10 +406,9 @@ def checkElementsOfTimeVaryAreLists(self): A method to check that elements of time_vary are lists. """ for param in self.time_vary: - assert type(getattr(self,param))==list,param + ' is not a list, but should be' + \ + assert type(getattr(self, param)) == list, param + ' is not a list, but should be' + \ ' because it is in time_vary' - def preSolve(self): ''' A method that is run immediately before the model is solved, to check inputs or to prepare @@ -448,12 +455,13 @@ def initializeSim(self): ''' self.resetRNG() self.t_sim = 0 - all_agents = np.ones(self.AgentCount,dtype=bool) + all_agents = np.ones(self.AgentCount, dtype=bool) blank_array = np.zeros(self.AgentCount) for var_name in self.poststate_vars: - exec('self.' + var_name + ' = copy(blank_array)') - self.t_age = np.zeros(self.AgentCount,dtype=int) # Number of periods since agent entry - self.t_cycle = np.zeros(self.AgentCount,dtype=int) # Which cycle period each agent is on + setattr(self, var_name, copy(blank_array)) + # exec('self.' + var_name + ' = copy(blank_array)') + self.t_age = np.zeros(self.AgentCount, dtype=int) # Number of periods since agent entry + self.t_cycle = np.zeros(self.AgentCount, dtype=int) # Which cycle period each agent is on self.simBirth(all_agents) self.clearHistory() return None @@ -474,18 +482,18 @@ def simOnePeriod(self): None ''' self.getMortality() # Replace some agents with "newborns" - if self.read_shocks: # If shock histories have been pre-specified, use those + if self.read_shocks: # If shock histories have been pre-specified, use those self.readShocks() else: # Otherwise, draw shocks as usual according to subclass-specific method self.getShocks() - self.getStates() # Determine each agent's state at decision time + self.getStates() # Determine each agent's state at decision time self.getControls() # Determine each agent's choice or control variables based on states - self.getPostStates() # Determine each agent's post-decision / end-of-period states using states and controls + self.getPostStates() # Determine each agent's post-decision / end-of-period states using states and controls # Advance time for all agents - self.t_age = self.t_age + 1 # Age all consumers by one period - self.t_cycle = self.t_cycle + 1 # Age all consumers within their cycle - self.t_cycle[self.t_cycle == self.T_cycle] = 0 # Resetting to zero for those who have reached the end + self.t_age = self.t_age + 1 # Age all consumers by one period + self.t_cycle = self.t_cycle + 1 # Age all consumers within their cycle + self.t_cycle[self.t_cycle == self.T_cycle] = 0 # Resetting to zero for those who have reached the end def makeShockHistory(self): ''' @@ -511,7 +519,7 @@ def makeShockHistory(self): # Make blank history arrays for each shock variable for var_name in self.shock_vars: - setattr(self,var_name+'_hist',np.zeros((self.T_sim,self.AgentCount))+np.nan) + setattr(self, var_name+'_hist', np.zeros((self.T_sim, self.AgentCount)) + np.nan) # Make and store the history of shocks for each period for t in range(self.T_sim): @@ -520,9 +528,9 @@ def makeShockHistory(self): for var_name in self.shock_vars: exec('self.' + var_name + '_hist[self.t_sim,:] = self.' + var_name) self.t_sim += 1 - self.t_age = self.t_age + 1 # Age all consumers by one period - self.t_cycle = self.t_cycle + 1 # Age all consumers within their cycle - self.t_cycle[self.t_cycle == self.T_cycle] = 0 # Resetting to zero for those who have reached the end + self.t_age = self.t_age + 1 # Age all consumers by one period + self.t_cycle = self.t_cycle + 1 # Age all consumers within their cycle + self.t_cycle[self.t_cycle == self.T_cycle] = 0 # Resetting to zero for those who have reached the end # Restore the flow of time and flag that shocks can be read rather than simulated self.read_shocks = True @@ -566,10 +574,10 @@ def simDeath(self): Boolean array of size self.AgentCount indicating which agents die and are replaced. ''' print('AgentType subclass must define method simDeath!') - who_dies = np.ones(self.AgentCount,dtype=bool) + who_dies = np.ones(self.AgentCount, dtype=bool) return who_dies - def simBirth(self,which_agents): + def simBirth(self, which_agents): ''' Makes new agents for the simulation. Takes a boolean array as an input, indicating which agent indices are to be "born". Does nothing by default, must be overwritten by a subclass. @@ -618,7 +626,7 @@ def readShocks(self): None ''' for var_name in self.shock_vars: - setattr(self,var_name,getattr(self,var_name+'_hist')[self.t_sim,:]) + setattr(self, var_name, getattr(self, var_name + '_hist')[self.t_sim, :]) def getStates(self): ''' @@ -667,7 +675,7 @@ def getPostStates(self): ''' return None - def simulate(self,sim_periods=None): + def simulate(self, sim_periods=None): ''' Simulates this agent type for a given number of periods (defaults to self.T_sim if no input). Records histories of attributes named in self.track_vars in attributes named varname_hist. @@ -680,19 +688,23 @@ def simulate(self,sim_periods=None): ------- None ''' - orig_time = self.time_flow - self.timeFwd() - if sim_periods is None: - sim_periods = self.T_sim + # Ignore floating point "errors". Numpy calls it "errors", but really it's excep- + # tions with well-defined answers such as 1.0/0.0 that is np.inf, -1.0/0.0 that is + # -np.inf, np.inf/np.inf is np.nan and so on. + with np.errstate(divide='ignore', over='ignore', under='ignore', invalid='ignore'): + orig_time = self.time_flow + self.timeFwd() + if sim_periods is None: + sim_periods = self.T_sim - for t in range(sim_periods): - self.simOnePeriod() - for var_name in self.track_vars: - exec('self.' + var_name + '_hist[self.t_sim,:] = self.' + var_name) - self.t_sim += 1 + for t in range(sim_periods): + self.simOnePeriod() + for var_name in self.track_vars: + exec('self.' + var_name + '_hist[self.t_sim,:] = self.' + var_name) + self.t_sim += 1 - if not orig_time: - self.timeRev() + if not orig_time: + self.timeRev() def clearHistory(self): ''' @@ -710,7 +722,7 @@ def clearHistory(self): exec('self.' + var_name + '_hist = np.zeros((self.T_sim,self.AgentCount)) + np.nan') -def solveAgent(agent,verbose): +def solveAgent(agent, verbose): ''' Solve the dynamic model for one agent type. This function iterates on "cycles" of an agent's model either a given number of times or until solution convergence @@ -734,8 +746,8 @@ def solveAgent(agent,verbose): agent.timeRev() # Check to see whether this is an (in)finite horizon problem - cycles_left = agent.cycles - infinite_horizon = cycles_left == 0 + cycles_left = agent.cycles # NOQA + infinite_horizon = cycles_left == 0 # NOQA # Initialize the solution, which includes the terminal solution if it's not a pseudo-terminal period solution = [] @@ -743,15 +755,15 @@ def solveAgent(agent,verbose): solution.append(deepcopy(agent.solution_terminal)) # Initialize the process, then loop over cycles - solution_last = agent.solution_terminal - go = True - completed_cycles = 0 - max_cycles = 5000 # escape clause + solution_last = agent.solution_terminal # NOQA + go = True # NOQA + completed_cycles = 0 # NOQA + max_cycles = 5000 # NOQA - escape clause if verbose: t_last = clock() while go: # Solve a cycle of the model, recording it if horizon is finite - solution_cycle = solveOneCycle(agent,solution_last) + solution_cycle = solveOneCycle(agent, solution_last) if not infinite_horizon: solution += solution_cycle @@ -761,7 +773,7 @@ def solveAgent(agent,verbose): if completed_cycles > 0: solution_distance = solution_now.distance(solution_last) go = (solution_distance > agent.tolerance and completed_cycles < max_cycles) - else: # Assume solution does not converge after only one cycle + else: # Assume solution does not converge after only one cycle solution_distance = 100.0 go = True else: @@ -776,16 +788,16 @@ def solveAgent(agent,verbose): if verbose: t_now = clock() if infinite_horizon: - print('Finished cycle #' + str(completed_cycles) + ' in ' + str(t_now-t_last) +\ - ' seconds, solution distance = ' + str(solution_distance)) + print('Finished cycle #' + str(completed_cycles) + ' in ' + str(t_now-t_last) + + ' seconds, solution distance = ' + str(solution_distance)) else: - print('Finished cycle #' + str(completed_cycles) + ' of ' + str(agent.cycles) +\ - ' in ' + str(t_now-t_last) + ' seconds.') + print('Finished cycle #' + str(completed_cycles) + ' of ' + str(agent.cycles) + + ' in ' + str(t_now-t_last) + ' seconds.') t_last = t_now # Record the last cycle if horizon is infinite (solution is still empty!) if infinite_horizon: - solution = solution_cycle # PseudoTerminal=False impossible for infinite horizon + solution = solution_cycle # PseudoTerminal=False impossible for infinite horizon # Restore the direction of time to its original orientation, then return the solution if original_time_flow: @@ -793,7 +805,7 @@ def solveAgent(agent,verbose): return solution -def solveOneCycle(agent,solution_last): +def solveOneCycle(agent, solution_last): ''' Solve one "cycle" of the dynamic model for one agent type. This function iterates over the periods within an agent's cycle, updating the time-varying @@ -818,7 +830,7 @@ def solveOneCycle(agent,solution_last): # Calculate number of periods per cycle, defaults to 1 if all variables are time invariant if len(agent.time_vary) > 0: name = agent.time_vary[0] - T = len(eval('agent.' + name)) + T = len(eval('agent.' + name)) else: T = 1 @@ -826,12 +838,12 @@ def solveOneCycle(agent,solution_last): always_same_solver = 'solveOnePeriod' not in agent.time_vary if always_same_solver: solveOnePeriod = agent.solveOnePeriod - these_args = getArgNames(solveOnePeriod) + these_args = getArgNames(solveOnePeriod) # Construct a dictionary to be passed to the solver time_inv_string = '' for name in agent.time_inv: - time_inv_string += ' \'' + name + '\' : agent.' +name + ',' + time_inv_string += ' \'' + name + '\' : agent.' + name + ',' time_vary_string = '' for name in agent.time_vary: time_vary_string += ' \'' + name + '\' : None,' @@ -839,7 +851,7 @@ def solveOneCycle(agent,solution_last): # Initialize the solution for this cycle, then iterate on periods solution_cycle = [] - solution_next = solution_last + solution_next = solution_last for t in range(T): # Update which single period solver to use (if it depends on time) if not always_same_solver: @@ -864,8 +876,8 @@ def solveOneCycle(agent,solution_last): return solution_cycle -#======================================================================== -#======================================================================== +# ======================================================================== +# ======================================================================== class Market(HARKobject): ''' @@ -873,8 +885,8 @@ class Market(HARKobject): dynamic general equilibrium models to solve the "macroeconomic" model as a layer on top of the "microeconomic" models of one or more AgentTypes. ''' - def __init__(self,agents=[],sow_vars=[],reap_vars=[],const_vars=[],track_vars=[],dyn_vars=[], - millRule=None,calcDynamics=None,act_T=1000,tolerance=0.000001): + def __init__(self, agents=[], sow_vars=[], reap_vars=[], const_vars=[], track_vars=[], dyn_vars=[], + millRule=None, calcDynamics=None, act_T=1000, tolerance=0.000001): ''' Make a new instance of the Market class. @@ -919,25 +931,25 @@ def __init__(self,agents=[],sow_vars=[],reap_vars=[],const_vars=[],track_vars=[] ------- None ''' - self.agents = agents - self.reap_vars = reap_vars - self.sow_vars = sow_vars - self.const_vars = const_vars - self.track_vars = track_vars - self.dyn_vars = dyn_vars - if millRule is not None: # To prevent overwriting of method-based millRules + self.agents = agents # NOQA + self.reap_vars = reap_vars # NOQA + self.sow_vars = sow_vars # NOQA + self.const_vars = const_vars # NOQA + self.track_vars = track_vars # NOQA + self.dyn_vars = dyn_vars # NOQA + if millRule is not None: # To prevent overwriting of method-based millRules self.millRule = millRule - if calcDynamics is not None: # Ditto for calcDynamics + if calcDynamics is not None: # Ditto for calcDynamics self.calcDynamics = calcDynamics - self.act_T = act_T - self.tolerance = tolerance - self.max_loops = 1000 - - self.print_parallel_error_once = True - # Print the error associated with calling the parallel method - # "solveAgents" one time. If set to false, the error will never - # print. See "solveAgents" for why this prints once or never. - + self.act_T = act_T # NOQA + self.tolerance = tolerance # NOQA + self.max_loops = 1000 # NOQA + + self.print_parallel_error_once = True + # Print the error associated with calling the parallel method + # "solveAgents" one time. If set to false, the error will never + # print. See "solveAgents" for why this prints once or never. + def solveAgents(self): ''' Solves the microeconomic problem for all AgentTypes in this market. @@ -950,17 +962,19 @@ def solveAgents(self): ------- None ''' - #for this_type in self.agents: - # this_type.solve() + # for this_type in self.agents: + # this_type.solve() try: - multiThreadCommands(self.agents,['solve()']) + multiThreadCommands(self.agents, ['solve()']) except Exception as err: if self.print_parallel_error_once: - # Set flag to False so this is only printed once. + # Set flag to False so this is only printed once. self.print_parallel_error_once = False - print("**** WARNING: could not execute multiThreadCommands in HARK.core.Market.solveAgents(), so using the serial version instead. This will likely be slower. The multiTreadCommands() functions failed with the following error:", '\n ', sys.exc_info()[0], ':', err) #sys.exc_info()[0]) - multiThreadCommandsFake(self.agents,['solve()']) - + print("**** WARNING: could not execute multiThreadCommands in HARK.core.Market.solveAgents() ", + "so using the serial version instead. This will likely be slower. " + "The multiTreadCommands() functions failed with the following error:", '\n', + sys.exc_info()[0], ':', err) # sys.exc_info()[0]) + multiThreadCommandsFake(self.agents, ['solve()']) def solve(self): ''' @@ -976,15 +990,15 @@ def solve(self): ------- None ''' - go = True - max_loops = self.max_loops # Failsafe against infinite solution loop + go = True + max_loops = self.max_loops # Failsafe against infinite solution loop completed_loops = 0 - old_dynamics = None + old_dynamics = None - while go: # Loop until the dynamic process converges or we hit the loop cap - self.solveAgents() # Solve each AgentType's micro problem - self.makeHistory() # "Run" the model while tracking aggregate variables - new_dynamics = self.updateDynamics() # Find a new aggregate dynamic rule + while go: # Loop until the dynamic process converges or we hit the loop cap + self.solveAgents() # Solve each AgentType's micro problem + self.makeHistory() # "Run" the model while tracking aggregate variables + new_dynamics = self.updateDynamics() # Find a new aggregate dynamic rule # Check to see if the dynamic rule has converged (if this is not the first loop) if completed_loops > 0: @@ -993,11 +1007,11 @@ def solve(self): distance = 1000000.0 # Move to the next loop if the terminal conditions are not met - old_dynamics = new_dynamics + old_dynamics = new_dynamics completed_loops += 1 - go = distance >= self.tolerance and completed_loops < max_loops + go = distance >= self.tolerance and completed_loops < max_loops - self.dynamics = new_dynamics # Store the final dynamic rule in self + self.dynamics = new_dynamics # Store the final dynamic rule in self def reap(self): ''' @@ -1015,8 +1029,8 @@ def reap(self): for var_name in self.reap_vars: harvest = [] for this_type in self.agents: - harvest.append(getattr(this_type,var_name)) - setattr(self,var_name,harvest) + harvest.append(getattr(this_type, var_name)) + setattr(self, var_name, harvest) def sow(self): ''' @@ -1032,9 +1046,9 @@ def sow(self): none ''' for var_name in self.sow_vars: - this_seed = getattr(self,var_name) + this_seed = getattr(self, var_name) for this_type in self.agents: - setattr(this_type,var_name,this_seed) + setattr(this_type, var_name, this_seed) def mill(self): ''' @@ -1062,8 +1076,8 @@ def mill(self): product = self.millRule(**mill_dict) for j in range(len(self.sow_vars)): this_var = self.sow_vars[j] - this_product = getattr(product,this_var) - setattr(self,this_var,this_product) + this_product = getattr(product, this_var) + setattr(self, this_var, this_product) def cultivate(self): ''' @@ -1096,12 +1110,12 @@ def reset(self): ------- none ''' - for var_name in self.track_vars: # Reset the history of tracked variables - setattr(self,var_name + '_hist',[]) - for var_name in self.sow_vars: # Set the sow variables to their initial levels - initial_val = getattr(self,var_name + '_init') - setattr(self,var_name,initial_val) - for this_type in self.agents: # Reset each AgentType in the market + for var_name in self.track_vars: # Reset the history of tracked variables + setattr(self, var_name + '_hist', []) + for var_name in self.sow_vars: # Set the sow variables to their initial levels + initial_val = getattr(self, var_name + '_init') + setattr(self, var_name, initial_val) + for this_type in self.agents: # Reset each AgentType in the market this_type.reset() def store(self): @@ -1118,8 +1132,8 @@ def store(self): none ''' for var_name in self.track_vars: - value_now = getattr(self,var_name) - getattr(self,var_name + '_hist').append(value_now) + value_now = getattr(self, var_name) + getattr(self, var_name + '_hist').append(value_now) def makeHistory(self): ''' @@ -1134,13 +1148,13 @@ def makeHistory(self): ------- none ''' - self.reset() # Initialize the state of the market + self.reset() # Initialize the state of the market for t in range(self.act_T): - self.sow() # Distribute aggregated information/state to agents - self.cultivate() # Agents take action - self.reap() # Collect individual data from agents - self.mill() # Process individual data into aggregate data - self.store() # Record variables of interest + self.sow() # Distribute aggregated information/state to agents + self.cultivate() # Agents take action + self.reap() # Collect individual data from agents + self.mill() # Process individual data into aggregate data + self.store() # Record variables of interest def updateDynamics(self): ''' @@ -1167,11 +1181,11 @@ def updateDynamics(self): update_dict = eval('{' + history_vars_string + '}') # Calculate a new dynamic rule and distribute it to the agents in agent_list - dynamics = self.calcDynamics(**update_dict) # User-defined dynamics calculator + dynamics = self.calcDynamics(**update_dict) # User-defined dynamics calculator for var_name in self.dyn_vars: - this_obj = getattr(dynamics,var_name) + this_obj = getattr(dynamics, var_name) for this_type in self.agents: - setattr(this_type,var_name,this_obj) + setattr(this_type, var_name, this_obj) return dynamics @@ -1182,21 +1196,21 @@ def updateDynamics(self): # Define a function to run the copying: def copy_module(target_path, my_directory_full_path, my_module): ''' - Helper function for copy_module_to_local(). Provides the actual copy - functionality, with highly cautious safeguards against copying over - important things. - + Helper function for copy_module_to_local(). Provides the actual copy + functionality, with highly cautious safeguards against copying over + important things. + Parameters ---------- target_path : string String, file path to target location - + my_directory_full_path: string String, full pathname to this file's directory - + my_module : string String, name of the module to copy - + Returns ------- none @@ -1206,35 +1220,42 @@ def copy_module(target_path, my_directory_full_path, my_module): print("Goodbye!") return elif target_path == os.path.expanduser("~") or os.path.normpath(target_path) == os.path.expanduser("~"): - print("You have indicated that the target location is "+target_path+" -- that is, you want to wipe out your home directory with the contents of "+my_module+". My programming does not allow me to do that.\n\nGoodbye!") + print("You have indicated that the target location is " + target_path + + " -- that is, you want to wipe out your home directory with the contents of " + my_module + + ". My programming does not allow me to do that.\n\nGoodbye!") return elif os.path.exists(target_path): - print("There is already a file or directory at the location "+target_path+". For safety reasons this code does not overwrite existing files.\nPlease remove the file at "+target_path+" and try again.") + print("There is already a file or directory at the location " + target_path + + ". For safety reasons this code does not overwrite existing files.\n Please remove the file at " + + target_path + + " and try again.") return else: - user_input = input("""You have indicated you want to copy module:\n """+ my_module - + """\nto:\n """+ target_path +"""\nIs that correct? Please indicate: y / [n]\n\n""") + user_input = input("""You have indicated you want to copy module:\n """ + my_module + + """\nto:\n """ + target_path + """\nIs that correct? Please indicate: y / [n]\n\n""") if user_input == 'y' or user_input == 'Y': - #print("copy_tree(",my_directory_full_path,",", target_path,")") + # print("copy_tree(",my_directory_full_path,",", target_path,")") copy_tree(my_directory_full_path, target_path) else: print("Goodbye!") return + def print_helper(): - + my_directory_full_path = os.path.dirname(os.path.realpath(__file__)) - + print(my_directory_full_path) + def copy_module_to_local(full_module_name): ''' - This function contains simple code to copy a submodule to a location on - your hard drive, as specified by you. The purpose of this code is to provide - users with a simple way to access a *copy* of code that usually sits deep in - the Econ-ARK package structure, for purposes of tinkering and experimenting - directly. This is meant to be a simple way to explore HARK code. To interact - with the codebase under active development, please refer to the documentation + This function contains simple code to copy a submodule to a location on + your hard drive, as specified by you. The purpose of this code is to provide + users with a simple way to access a *copy* of code that usually sits deep in + the Econ-ARK package structure, for purposes of tinkering and experimenting + directly. This is meant to be a simple way to explore HARK code. To interact + with the codebase under active development, please refer to the documentation under github.com/econ-ark/HARK/ To execute, do the following on the Python command line: @@ -1242,7 +1263,7 @@ def copy_module_to_local(full_module_name): from HARK.core import copy_module_to_local copy_module_to_local("FULL-HARK-MODULE-NAME-HERE") - For example, if you want SolvingMicroDSOPs you would enter + For example, if you want SolvingMicroDSOPs you would enter from HARK.core import copy_module_to_local copy_module_to_local("HARK.SolvingMicroDSOPs") @@ -1251,14 +1272,17 @@ def copy_module_to_local(full_module_name): # Find a default directory -- user home directory: home_directory_RAW = os.path.expanduser("~") - # Thanks to https://stackoverflow.com/a/4028943 + # Thanks to https://stackoverflow.com/a/4028943 # Find the directory of the HARK.core module: - #my_directory_full_path = os.path.dirname(os.path.realpath(__file__)) + # my_directory_full_path = os.path.dirname(os.path.realpath(__file__)) hark_core_directory_full_path = os.path.dirname(os.path.realpath(__file__)) # From https://stackoverflow.com/a/5137509 - # Important note from that answer: - # (Note that the incantation above won't work if you've already used os.chdir() to change your current working directory, since the value of the __file__ constant is relative to the current working directory and is not changed by an os.chdir() call.) + # Important note from that answer: + # (Note that the incantation above won't work if you've already used os.chdir() + # to change your current working directory, + # since the value of the __file__ constant is relative to the current working directory and is not changed by an + # os.chdir() call.) # # NOTE: for this specific file that I am testing, the path should be: # '/home/npalmer/anaconda3/envs/py3fresh/lib/python3.6/site-packages/HARK/SolvingMicroDSOPs/---example-file--- @@ -1266,7 +1290,9 @@ def copy_module_to_local(full_module_name): # Split out the name of the module. Break if proper format is not followed: all_module_names_list = full_module_name.split('.') # Assume put in at correct format if all_module_names_list[0] != "HARK": - print("\nWarning: the module name does not start with 'HARK'. Instead it is: '"+all_module_names_list[0]+"' -- please format the full namespace of the module you want. For example, 'HARK.SolvingMicroDSOPs'") + print("\nWarning: the module name does not start with 'HARK'. Instead it is: '" + + all_module_names_list[0]+"' --please format the full namespace of the module you want. \n" + "For example, 'HARK.SolvingMicroDSOPs'") print("\nGoodbye!") return @@ -1278,8 +1304,8 @@ def copy_module_to_local(full_module_name): head_path, my_module = os.path.split(my_directory_full_path) home_directory_with_module = os.path.join(home_directory_RAW, my_module) - - print("\n\n\nmy_directory_full_path:",my_directory_full_path,'\n\n\n') + + print("\n\n\nmy_directory_full_path:", my_directory_full_path, '\n\n\n') # Interact with the user: # - Ask the user for the target place to copy the directory @@ -1289,42 +1315,39 @@ def copy_module_to_local(full_module_name): # - If not, just copy there # - Quit - target_path = input("""You have invoked the 'replicate' process for the current module:\n """ + - my_module + """\nThe default copy location is your home directory:\n """+ - home_directory_with_module +"""\nPlease enter one of the three options in single quotes below, excluding the quotes: - + target_path = input("""You have invoked the 'replicate' process for the current module:\n """ + + my_module + """\nThe default copy location is your home directory:\n """ + + home_directory_with_module + """\nPlease enter one of the three options in single quotes below, excluding the quotes: + 'q' or return/enter to quit the process 'y' to accept the default home directory: """+home_directory_with_module+""" 'n' to specify your own pathname\n\n""") - if target_path == 'n' or target_path == 'N': target_path = input("""Please enter the full pathname to your target directory location: """) - + # Clean up: target_path = os.path.expanduser(target_path) target_path = os.path.expandvars(target_path) target_path = os.path.normpath(target_path) - + # Check to see if they included the module name; if not add it here: temp_head, temp_tail = os.path.split(target_path) if temp_tail != my_module: target_path = os.path.join(target_path, my_module) - + elif target_path == 'y' or target_path == 'Y': # Just using the default path: target_path = home_directory_with_module else: # Assume "quit" - return - - if target_path != 'q' and target_path != 'Q' or target_path == '': - # Run the copy command: - copy_module(target_path, my_directory_full_path, my_module) - - return + return + if target_path != 'q' and target_path != 'Q' or target_path == '': + # Run the copy command: + copy_module(target_path, my_directory_full_path, my_module) + return def main(): diff --git a/HARK/cstwMPC/SetupParamsCSTWold.py b/HARK/cstwMPC/SetupParamsCSTWold.py deleted file mode 100644 index 1183f724a..000000000 --- a/HARK/cstwMPC/SetupParamsCSTWold.py +++ /dev/null @@ -1,296 +0,0 @@ -''' -Loads parameters used in the cstwMPC estimations. -''' -import numpy as np -import csv -from copy import copy, deepcopy -import os - -# Choose percentiles of the data to match and which estimation to run -do_lifecycle = False # Use lifecycle model if True, perpetual youth if False -do_beta_dist = True # Do beta-dist version if True, beta-point if False -run_estimation = False # Runs the estimation if True -find_beta_vs_KY = False # Computes K/Y ratio for a wide range of beta; should have do_beta_dist = False -do_sensitivity = [False, False, False, False, False, False, False, False] # Choose which sensitivity analyses to run: rho, xi_sigma, psi_sigma, mu, urate, mortality, g, R -do_liquid = False # Matches liquid assets data when True, net worth data when False -do_tractable = False # Uses a "tractable consumer" rather than solving full model when True -do_agg_shocks = True # Solve the FBS aggregate shocks version of the model -SCF_data_file = 'SCFwealthDataReduced.txt' -percentiles_to_match = [0.2, 0.4, 0.6, 0.8] # Which points of the Lorenz curve to match in beta-dist (must be in (0,1)) -#percentiles_to_match = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] # Can use this line if you want to match more percentiles -if do_beta_dist: - pref_type_count = 7 # Number of discrete beta types in beta-dist -else: - pref_type_count = 1 # Just one beta type in beta-point - -# Set basic parameters for the lifecycle micro model -init_age = 24 # Starting age for agents -Rfree = 1.04**(0.25) # Quarterly interest factor -working_T = 41*4 # Number of working periods -retired_T = 55*4 # Number of retired periods -total_T = working_T+retired_T # Total number of periods -CRRA = 1.0 # Coefficient of relative risk aversion -DiscFac_guess = 0.99 # Initial starting point for discount factor -UnempPrb = 0.07 # Probability of unemployment while working -UnempPrbRet = 0.0005 # Probabulity of "unemployment" while retired -IncUnemp = 0.15 # Unemployment benefit replacement rate -IncUnempRet = 0.0 # Ditto when retired -P0_sigma = 0.4 # Standard deviation of initial permanent income -BoroCnstArt = 0.0 # Artificial borrowing constraint - -# Set grid sizes -PermShkCount = 5 # Number of points in permanent income shock grid -TranShkCount = 5 # Number of points in transitory income shock grid -aXtraMin = 0.00001 # Minimum end-of-period assets in grid -aXtraMax = 20 # Maximum end-of-period assets in grid -aXtraCount = 20 # Number of points in assets grid -exp_nest = 3 # Number of times to 'exponentially nest' when constructing assets grid -sim_pop_size = 2000 # Number of simulated agents per preference type -CubicBool = False # Whether to use cubic spline interpolation -vFuncBool = False # Whether to calculate the value function during solution - -# Set random seeds -a0_seed = 138 # Seed for initial wealth draws -P0_seed = 666 # Seed for initial permanent income draws - -# Define the paths of permanent and transitory shocks (from Sabelhaus and Song) -TranShkStd = (np.concatenate((np.linspace(0.1,0.12,17), 0.12*np.ones(17), np.linspace(0.12,0.075,61), np.linspace(0.074,0.007,68), np.zeros(retired_T+1)))*4)**0.5 -TranShkStd = np.ndarray.tolist(TranShkStd) -PermShkStd = np.concatenate((((0.00011342*(np.linspace(24,64.75,working_T-1)-47)**2 + 0.01)/(11.0/4.0))**0.5,np.zeros(retired_T+1))) -PermShkStd = np.ndarray.tolist(PermShkStd) - -# Import survival probabilities from SSA data -data_location = os.path.dirname(os.path.abspath(__file__)) -f = open(data_location + '/' + 'USactuarial.txt','r') -actuarial_reader = csv.reader(f,delimiter='\t') -raw_actuarial = list(actuarial_reader) -base_death_probs = [] -for j in range(len(raw_actuarial)): - base_death_probs += [float(raw_actuarial[j][4])] # This effectively assumes that everyone is a white woman -f.close - -# Import adjustments for education and apply them to the base mortality rates -f = open(data_location + '/' + 'EducMortAdj.txt','r') -adjustment_reader = csv.reader(f,delimiter=' ') -raw_adjustments = list(adjustment_reader) -d_death_probs = [] -h_death_probs = [] -c_death_probs = [] -for j in range(76): - d_death_probs += [base_death_probs[j + init_age]*float(raw_adjustments[j][1])] - h_death_probs += [base_death_probs[j + init_age]*float(raw_adjustments[j][2])] - c_death_probs += [base_death_probs[j + init_age]*float(raw_adjustments[j][3])] -for j in range(76,96): - d_death_probs += [base_death_probs[j + init_age]*float(raw_adjustments[75][1])] - h_death_probs += [base_death_probs[j + init_age]*float(raw_adjustments[75][2])] - c_death_probs += [base_death_probs[j + init_age]*float(raw_adjustments[75][3])] -LivPrb_d = [] -LivPrb_h = [] -LivPrb_c = [] -for j in range(len(d_death_probs)): # Convert annual mortality rates to quarterly survival rates - LivPrb_d += 4*[(1 - d_death_probs[j])**0.25] - LivPrb_h += 4*[(1 - h_death_probs[j])**0.25] - LivPrb_c += 4*[(1 - c_death_probs[j])**0.25] - -# Define permanent income growth rates for each education level (from Cagetti 2003) -PermGroFac_d_base = [5.2522391e-002, 5.0039782e-002, 4.7586132e-002, 4.5162424e-002, 4.2769638e-002, 4.0408757e-002, 3.8080763e-002, 3.5786635e-002, 3.3527358e-002, 3.1303911e-002, 2.9117277e-002, 2.6968437e-002, 2.4858374e-002, 2.2788068e-002, 2.0758501e-002, 1.8770655e-002, 1.6825511e-002, 1.4924052e-002, 1.3067258e-002, 1.1256112e-002, 9.4915947e-003, 7.7746883e-003, 6.1063742e-003, 4.4876340e-003, 2.9194495e-003, 1.4028022e-003, -6.1326258e-005, -1.4719542e-003, -2.8280999e-003, -4.1287819e-003, -5.3730185e-003, -6.5598280e-003, -7.6882288e-003, -8.7572392e-003, -9.7658777e-003, -1.0713163e-002, -1.1598112e-002, -1.2419745e-002, -1.3177079e-002, -1.3869133e-002, -4.3985368e-001, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003, -8.5623256e-003] -PermGroFac_h_base = [4.1102173e-002, 4.1194381e-002, 4.1117402e-002, 4.0878307e-002, 4.0484168e-002, 3.9942056e-002, 3.9259042e-002, 3.8442198e-002, 3.7498596e-002, 3.6435308e-002, 3.5259403e-002, 3.3977955e-002, 3.2598035e-002, 3.1126713e-002, 2.9571062e-002, 2.7938153e-002, 2.6235058e-002, 2.4468848e-002, 2.2646594e-002, 2.0775369e-002, 1.8862243e-002, 1.6914288e-002, 1.4938576e-002, 1.2942178e-002, 1.0932165e-002, 8.9156095e-003, 6.8995825e-003, 4.8911556e-003, 2.8974003e-003, 9.2538802e-004, -1.0178097e-003, -2.9251214e-003, -4.7894755e-003, -6.6038005e-003, -8.3610250e-003, -1.0054077e-002, -1.1675886e-002, -1.3219380e-002, -1.4677487e-002, -1.6043137e-002, -5.5864350e-001, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002, -1.0820465e-002] -PermGroFac_c_base = [3.9375106e-002, 3.9030288e-002, 3.8601230e-002, 3.8091011e-002, 3.7502710e-002, 3.6839406e-002, 3.6104179e-002, 3.5300107e-002, 3.4430270e-002, 3.3497746e-002, 3.2505614e-002, 3.1456953e-002, 3.0354843e-002, 2.9202363e-002, 2.8002591e-002, 2.6758606e-002, 2.5473489e-002, 2.4150316e-002, 2.2792168e-002, 2.1402124e-002, 1.9983263e-002, 1.8538663e-002, 1.7071404e-002, 1.5584565e-002, 1.4081224e-002, 1.2564462e-002, 1.1037356e-002, 9.5029859e-003, 7.9644308e-003, 6.4247695e-003, 4.8870812e-003, 3.3544449e-003, 1.8299396e-003, 3.1664424e-004, -1.1823620e-003, -2.6640003e-003, -4.1251914e-003, -5.5628564e-003, -6.9739162e-003, -8.3552918e-003, -6.8938447e-001, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004, -6.1023256e-004] -PermGroFac_d_base += 31*[PermGroFac_d_base[-1]] # Add 31 years of the same permanent income growth rate to the end of the sequence -PermGroFac_h_base += 31*[PermGroFac_h_base[-1]] -PermGroFac_c_base += 31*[PermGroFac_c_base[-1]] -PermGroFac_d_retire = PermGroFac_d_base[40] # Store the big shock to permanent income at retirement -PermGroFac_h_retire = PermGroFac_h_base[40] -PermGroFac_c_retire = PermGroFac_c_base[40] -PermGroFac_d_base[40] = PermGroFac_d_base[39] # Overwrite the "retirement drop" with the adjacent growth rate -PermGroFac_h_base[40] = PermGroFac_h_base[39] -PermGroFac_c_base[40] = PermGroFac_c_base[39] -PermGroFac_d = [] -PermGroFac_h = [] -PermGroFac_c = [] -for j in range(len(PermGroFac_d_base)): # Make sequences of quarterly permanent income growth factors from annual permanent income growth rates - PermGroFac_d += 4*[(1 + PermGroFac_d_base[j])**0.25] - PermGroFac_h += 4*[(1 + PermGroFac_h_base[j])**0.25] - PermGroFac_c += 4*[(1 + PermGroFac_c_base[j])**0.25] -PermGroFac_d[working_T-1] = 1 + PermGroFac_d_retire # Put the big shock at retirement back into the sequence -PermGroFac_h[working_T-1] = 1 + PermGroFac_h_retire -PermGroFac_c[working_T-1] = 1 + PermGroFac_c_retire - -# Set population macro parameters -pop_growth = 1.01**(0.25) # population growth rate -TFP_growth = 1.015**(0.25) # TFP growth rate -d_pct = 0.11 # proportion of HS dropouts -h_pct = 0.55 # proportion of HS graduates -c_pct = 0.34 # proportion of college graduates -P0_d = 5 # average initial permanent income, dropouts -P0_h = 7.5 # average initial permanent income, HS grads -P0_c = 12 # average initial permanent income, college grads -a0_values = [0.17, 0.5, 0.83] # initial wealth/income ratio values -a0_probs = [1.0/3.0, 1.0/3.0, 1.0/3.0] # ...and probabilities - -# Calculate the social security tax rate for the economy -d_income = np.concatenate((np.array([1]),np.cumprod(PermGroFac_d)))*P0_d -h_income = np.concatenate((np.array([1]),np.cumprod(PermGroFac_h)))*P0_h -c_income = np.concatenate((np.array([1]),np.cumprod(PermGroFac_c)))*P0_c -cohort_weight = pop_growth**np.array(np.arange(0,-(total_T+1),-1)) -econ_weight = TFP_growth**np.array(np.arange(0,-(total_T+1),-1)) -d_survival_cum = np.concatenate((np.array([1]),np.cumprod(LivPrb_d))) -h_survival_cum = np.concatenate((np.array([1]),np.cumprod(LivPrb_h))) -c_survival_cum = np.concatenate((np.array([1]),np.cumprod(LivPrb_c))) -total_income_working = (d_pct*d_income[0:working_T]*d_survival_cum[0:working_T] + h_pct*h_income[0:working_T]*h_survival_cum[0:working_T] + c_pct*c_income[0:working_T]*c_survival_cum[0:working_T])*cohort_weight[0:working_T]*econ_weight[0:working_T] -total_income_retired = (d_pct*d_income[working_T:total_T]*d_survival_cum[working_T:total_T] + h_pct*h_income[working_T:total_T]*h_survival_cum[working_T:total_T] + c_pct*c_income[working_T:total_T]*c_survival_cum[working_T:total_T])*cohort_weight[working_T:total_T]*econ_weight[working_T:total_T] -tax_rate_SS = np.sum(total_income_retired)/np.sum(total_income_working) -tax_rate_U = UnempPrb*IncUnemp -tax_rate = tax_rate_SS + tax_rate_U - -# Generate normalized weighting vectors for each age and education level -age_size_d = d_pct*cohort_weight*d_survival_cum -age_size_h = h_pct*cohort_weight*h_survival_cum -age_size_c = c_pct*cohort_weight*c_survival_cum -total_pop_size = sum(age_size_d) + sum(age_size_h) + sum(age_size_c) -age_weight_d = age_size_d/total_pop_size -age_weight_h = age_size_h/total_pop_size -age_weight_c = age_size_c/total_pop_size -age_weight_all = np.concatenate((age_weight_d,age_weight_h,age_weight_c)) -age_weight_short = np.concatenate((age_weight_d[0:total_T],age_weight_h[0:total_T],age_weight_c[0:total_T])) -total_output = np.sum(total_income_working)/total_pop_size - -# Set indiividual parameters for the infinite horizon model -l_bar = 10.0/9.0 # Labor supply per individual (constant) -PermGroFac_i = [1.000**0.25] # Permanent income growth factor (no perm growth) -beta_i = 0.99 # Default intertemporal discount factor -LivPrb_i = [1.0 - 1.0/160.0] # Survival probability -PermShkStd_i = [(0.01*4/11)**0.5] # Standard deviation of permanent shocks to income -TranShkStd_i = [(0.01*4)**0.5] # Standard deviation of transitory shocks to income -sim_periods = 1000 # Number of periods to simulate (idiosyncratic shocks model) -sim_periods_agg_shocks = 3000# Number of periods to simulate (aggregate shocks model) -Nagents_agg_shocks = 4800 # Number of agents to simulate (aggregate shocks model) -age_weight_i = LivPrb_i**np.arange(0,sim_periods,dtype=float) # Weight on each cohort, from youngest to oldest -total_pop_size_i = np.sum(age_weight_i) -age_weight_i = age_weight_i/total_pop_size_i # *Normalized* weight on each cohort -if not do_lifecycle: - age_weight_all = age_weight_i - age_weight_short = age_weight_i[0:sim_periods] - total_output = l_bar - -# Set aggregate parameters for the infinite horizon model -PermShkAggCount = 3 # Number of discrete permanent aggregate shocks -TranShkAggCount = 3 # Number of discrete transitory aggregate shocks -PermShkAggStd = np.sqrt(0.00004) # Standard deviation of permanent aggregate shocks -TranShkAggStd = np.sqrt(0.00001) # Standard deviation of transitory aggregate shocks -CapShare = 0.36 # Capital's share of output -DeprFac = 0.025 # Capital depreciation factor -CRRAPF = 1.0 # CRRA in perfect foresight calibration -DiscFacPF = 0.99 # Discount factor in perfect foresight calibration -slope_prev = 1.0 # Initial slope of kNextFunc (aggregate shocks model) -intercept_prev = 0.0 # Initial intercept of kNextFunc (aggregate shocks model) - -# Import the SCF wealth data -f = open(data_location + '/' + SCF_data_file,'r') -SCF_reader = csv.reader(f,delimiter='\t') -SCF_raw = list(SCF_reader) -SCF_wealth = np.zeros(len(SCF_raw)) + np.nan -SCF_weights = deepcopy(SCF_wealth) -for j in range(len(SCF_raw)): - SCF_wealth[j] = float(SCF_raw[j][0]) - SCF_weights[j] = float(SCF_raw[j][1]) - - -# Make dictionaries for lifecycle consumer types -init_dropout = {"CRRA":CRRA, - "Rfree":Rfree, - "PermGroFac":PermGroFac_d, - "BoroCnstArt":BoroCnstArt, - "CubicBool":CubicBool, - "vFuncBool":vFuncBool, - "PermShkStd":PermShkStd, - "PermShkCount":PermShkCount, - "TranShkStd":TranShkStd, - "TranShkCount":TranShkCount, - "T_total":total_T, - "UnempPrb":UnempPrb, - "UnempPrbRet":UnempPrbRet, - "T_retire":working_T-1, - "IncUnemp":IncUnemp, - "IncUnempRet":IncUnempRet, - "aXtraMin":aXtraMin, - "aXtraMax":aXtraMax, - "aXtraCount":aXtraCount, - "aXtraExtra":[], - "exp_nest":exp_nest, - "LivPrb":LivPrb_d, - "DiscFac":DiscFac_guess, # dummy value, will be overwritten - "tax_rate":tax_rate_SS, # for math reasons, only SS tax goes here - 'Nagents':sim_pop_size, - 'sim_periods':total_T+1, - } -init_highschool = copy(init_dropout) -init_highschool["PermGroFac"] = PermGroFac_h -init_highschool["LivPrb"] = LivPrb_h -adj_highschool = {"PermGroFac":PermGroFac_h,"LivPrb":LivPrb_h} -init_college = copy(init_dropout) -init_college["PermGroFac"] = PermGroFac_c -init_college["LivPrb"] = LivPrb_c -adj_college = {"PermGroFac":PermGroFac_c,"LivPrb":LivPrb_c} - -# Make a dictionary for the infinite horizon type -init_infinite = {"CRRA":CRRA, - "Rfree":1.01/LivPrb_i[0], - "PermGroFac":PermGroFac_i, - "BoroCnstArt":BoroCnstArt, - "CubicBool":CubicBool, - "vFuncBool":vFuncBool, - "PermShkStd":PermShkStd_i, - "PermShkCount":PermShkCount, - "TranShkStd":TranShkStd_i, - "TranShkCount":TranShkCount, - "UnempPrb":UnempPrb, - "IncUnemp":IncUnemp, - "UnempPrbRet":None, - "IncUnempRet":None, - "aXtraMin":aXtraMin, - "aXtraMax":aXtraMax, - "aXtraCount":aXtraCount, - "aXtraExtra":[None], - "aXtraNestFac":exp_nest, - "LivPrb":LivPrb_i, - "beta":beta_i, # dummy value, will be overwritten - "cycles":0, - "T_total":1, - "T_retire":0, - "tax_rate":0.0, - 'sim_periods':sim_periods, - 'Nagents':sim_pop_size, - 'l_bar':l_bar, - } - -# Make a dictionary for the aggregate shocks type -init_agg_shocks = deepcopy(init_infinite) -init_agg_shocks['Nagents'] = Nagents_agg_shocks -init_agg_shocks['sim_periods'] = sim_periods_agg_shocks -init_agg_shocks['tolerance'] = 0.0001 -init_agg_shocks['kGridBase'] = np.array([0.3,0.6,0.8,0.9,0.98,1.0,1.02,1.1,1.2,1.6]) - -# Make a dictionary for the aggrege shocks market -aggregate_params = {'PermShkAggCount': PermShkAggCount, - 'TranShkAggCount': TranShkAggCount, - 'PermShkAggStd': PermShkAggStd, - 'TranShkAggStd': TranShkAggStd, - 'DeprFac': DeprFac, - 'CapShare': CapShare, - 'CRRA': CRRAPF, - 'DiscFac': DiscFacPF, - 'LivPrb': LivPrb_i[0], - 'slope_prev': slope_prev, - 'intercept_prev': intercept_prev, - } - -beta_save = DiscFac_guess # Hacky way to save progress of estimation -diff_save = 1000000.0 # Hacky way to save progress of estimation - - -if __name__ == '__main__': - print("Sorry, SetupParamsCSTW doesn't actually do anything on its own.") - print("This module is imported by cstwMPC, providing data and calibrated") - print("parameters for the various estimations. Please see that module if") - print("you want more interesting output.") diff --git a/HARK/cstwMPC/cstwMPCold.py b/HARK/cstwMPC/cstwMPCold.py deleted file mode 100644 index adf79ffdf..000000000 --- a/HARK/cstwMPC/cstwMPCold.py +++ /dev/null @@ -1,861 +0,0 @@ -''' -Nearly all of the estimations for the paper "The Distribution of Wealth and the -Marginal Propensity to Consume", by Chris Carroll, Jiri Slacalek, Kiichi Tokuoka, -and Matthew White. The micro model is a very slightly altered version of -ConsIndShockModel; the macro model is ConsAggShockModel. See SetupParamsCSTW -for parameters and execution options. -''' - -import numpy as np -from copy import deepcopy -from time import time -from HARK.utilities import approxMeanOneLognormal, combineIndepDstns, approxUniform, calcWeightedAvg, \ - getPercentiles, getLorenzShares, calcSubpopAvg -from HARK.simulation import drawDiscrete, drawMeanOneLognormal -from HARK import AgentType -from HARK.parallel import multiThreadCommandsFake -import SetupParamsCSTW as Params -import HARK.ConsumptionSaving.ConsIndShockModel as Model -from HARK.ConsumptionSaving.ConsAggShockModel import CobbDouglasEconomy, AggShockConsumerType -from scipy.optimize import golden, brentq -import matplotlib.pyplot as plt -import csv - -# ================================================================= -# ====== Make an extension of the basic ConsumerType ============== -# ================================================================= - -class cstwMPCagent(Model.IndShockConsumerType): - ''' - A consumer type in the cstwMPC model; a slight modification of base ConsumerType. - ''' - def __init__(self,time_flow=True,**kwds): - ''' - Make a new consumer type for the cstwMPC model. - - Parameters - ---------- - time_flow : boolean - Indictator for whether time is "flowing" forward for this agent. - **kwds : keyword arguments - Any number of keyword arguments of the form key=value. Each value - will be assigned to the attribute named in self. - - Returns - ------- - new instance of cstwMPCagent - ''' - # Initialize a basic AgentType - AgentType.__init__(self,solution_terminal=deepcopy(Model.IndShockConsumerType.solution_terminal_), - time_flow=time_flow,pseudo_terminal=False,**kwds) - - # Add consumer-type specific objects, copying to create independent versions - self.time_vary = deepcopy(Model.IndShockConsumerType.time_vary_) - self.time_inv = deepcopy(Model.IndShockConsumerType.time_inv_) - self.solveOnePeriod = Model.solveConsIndShock - self.update() - - def simulateCSTW(self): - ''' - The simulation method for the no aggregate shocks version of the model. - Initializes the agent type, simulates a history of state and control - variables, and stores the wealth history in self.W_history and the - annualized MPC history in self.kappa_history. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - self.initializeSim() - self.simConsHistory() - self.W_history = self.pHist*self.bHist/self.Rfree - if Params.do_lifecycle: - self.W_history = self.W_history*self.cohort_scale - self.kappa_history = 1.0 - (1.0 - self.MPChist)**4 - - def update(self): - ''' - Update the income process, the assets grid, and the terminal solution. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - orig_flow = self.time_flow - if self.cycles == 0: # hacky fix for labor supply l_bar - self.updateIncomeProcessAlt() - else: - self.updateIncomeProcess() - self.updateAssetsGrid() - self.updateSolutionTerminal() - self.timeFwd() - self.resetRNG() - if self.cycles > 0: - self.IncomeDstn = Model.applyFlatIncomeTax(self.IncomeDstn, - tax_rate=self.tax_rate, - T_retire=self.T_retire, - unemployed_indices=range(0,(self.TranShkCount+1)* - self.PermShkCount,self.TranShkCount+1)) - self.makeIncShkHist() - if not orig_flow: - self.timeRev() - - def updateIncomeProcessAlt(self): - ''' - An alternative method for constructing the income process in the infinite - horizon model, where the labor supply l_bar creates a small oddity. - - Parameters - ---------- - none - - Returns - ------- - none - ''' - tax_rate = (self.IncUnemp*self.UnempPrb)/(self.l_bar*(1.0-self.UnempPrb)) - TranShkDstn = deepcopy(approxMeanOneLognormal(self.TranShkCount,sigma=self.TranShkStd[0],tail_N=0)) - TranShkDstn[0] = np.insert(TranShkDstn[0]*(1.0-self.UnempPrb),0,self.UnempPrb) - TranShkDstn[1] = np.insert(self.l_bar*TranShkDstn[1]*(1.0-tax_rate),0,self.IncUnemp) - PermShkDstn = approxMeanOneLognormal(self.PermShkCount,sigma=self.PermShkStd[0],tail_N=0) - self.IncomeDstn = [combineIndepDstns(PermShkDstn,TranShkDstn)] - self.TranShkDstn = TranShkDstn - self.PermShkDstn = PermShkDstn - self.addToTimeVary('IncomeDstn') - - -def assignBetaDistribution(type_list,DiscFac_list): - ''' - Assigns the discount factors in DiscFac_list to the types in type_list. If - there is heterogeneity beyond the discount factor, then the same DiscFac is - assigned to consecutive types. - - Parameters - ---------- - type_list : [cstwMPCagent] - The list of types that should be assigned discount factors. - DiscFac_list : [float] or np.array - List of discount factors to assign to the types. - - Returns - ------- - none - ''' - DiscFac_N = len(DiscFac_list) - type_N = len(type_list)/DiscFac_N - j = 0 - b = 0 - while j < len(type_list): - t = 0 - while t < type_N: - type_list[j](DiscFac = DiscFac_list[b]) - t += 1 - j += 1 - b += 1 - - -# ================================================================= -# ====== Make some data analysis and reporting tools ============== -# ================================================================= - -def calculateKYratioDifference(sim_wealth,weights,total_output,target_KY): - ''' - Calculates the absolute distance between the simulated capital-to-output - ratio and the true U.S. level. - - Parameters - ---------- - sim_wealth : numpy.array - Array with simulated wealth values. - weights : numpy.array - List of weights for each row of sim_wealth. - total_output : float - Denominator for the simulated K/Y ratio. - target_KY : float - Actual U.S. K/Y ratio to match. - - Returns - ------- - distance : float - Absolute distance between simulated and actual K/Y ratios. - ''' - sim_K = calcWeightedAvg(sim_wealth,weights)/(Params.l_bar) - sim_KY = sim_K/total_output - distance = (sim_KY - target_KY)**1.0 - return distance - - -def calculateLorenzDifference(sim_wealth,weights,percentiles,target_levels): - ''' - Calculates the sum of squared differences between the simulatedLorenz curve - at the specified percentile levels and the target Lorenz levels. - - Parameters - ---------- - sim_wealth : numpy.array - Array with simulated wealth values. - weights : numpy.array - List of weights for each row of sim_wealth. - percentiles : [float] - Points in the distribution of wealth to match. - target_levels : np.array - Actual U.S. Lorenz curve levels at the specified percentiles. - - Returns - ------- - distance : float - Sum of squared distances between simulated and target Lorenz curves. - ''' - sim_lorenz = getLorenzShares(sim_wealth,weights=weights,percentiles=percentiles) - distance = sum((100*sim_lorenz-100*target_levels)**2) - return distance - - -# Define the main simulation process for matching the K/Y ratio -def simulateKYratioDifference(DiscFac,nabla,N,type_list,weights,total_output,target): - ''' - Assigns a uniform distribution over DiscFac with width 2*nabla and N points, then - solves and simulates all agent types in type_list and compares the simuated - K/Y ratio to the target K/Y ratio. - - Parameters - ---------- - DiscFac : float - Center of the uniform distribution of discount factors. - nabla : float - Width of the uniform distribution of discount factors. - N : int - Number of discrete consumer types. - type_list : [cstwMPCagent] - List of agent types to solve and simulate after assigning discount factors. - weights : np.array - Age-conditional array of population weights. - total_output : float - Total output of the economy, denominator for the K/Y calculation. - target : float - Target level of capital-to-output ratio. - - Returns - ------- - my_diff : float - Difference between simulated and target capital-to-output ratios. - ''' - if type(DiscFac) in (list,np.ndarray,np.array): - DiscFac = DiscFac[0] - DiscFac_list = approxUniform(N,DiscFac-nabla,DiscFac+nabla)[1] # only take values, not probs - assignBetaDistribution(type_list,DiscFac_list) - multiThreadCommandsFake(type_list,beta_point_commands) - my_diff = calculateKYratioDifference(np.vstack((this_type.W_history for this_type in type_list)), - np.tile(weights/float(N),N),total_output,target) - return my_diff - - -mystr = lambda number : "{:.3f}".format(number) -''' -Truncates a float at exactly three decimal places when displaying as a string. -''' - -def makeCSTWresults(DiscFac,nabla,save_name=None): - ''' - Produces a variety of results for the cstwMPC paper (usually after estimating). - - Parameters - ---------- - DiscFac : float - Center of the uniform distribution of discount factors - nabla : float - Width of the uniform distribution of discount factors - save_name : string - Name to save the calculated results, for later use in producing figures - and tables, etc. - - Returns - ------- - none - ''' - DiscFac_list = approxUniform(N=Params.pref_type_count,bot=DiscFac-nabla,top=DiscFac+nabla)[1] - assignBetaDistribution(est_type_list,DiscFac_list) - multiThreadCommandsFake(est_type_list,beta_point_commands) - - lorenz_distance = np.sqrt(betaDistObjective(nabla)) - - makeCSTWstats(DiscFac,nabla,est_type_list,Params.age_weight_all,lorenz_distance,save_name) - - -def makeCSTWstats(DiscFac,nabla,this_type_list,age_weight,lorenz_distance=0.0,save_name=None): - ''' - Displays (and saves) a bunch of statistics. Separate from makeCSTWresults() - for compatibility with the aggregate shock model. - - Parameters - ---------- - DiscFac : float - Center of the uniform distribution of discount factors - nabla : float - Width of the uniform distribution of discount factors - this_type_list : [cstwMPCagent] - List of agent types in the economy. - age_weight : np.array - Age-conditional array of weights for the wealth data. - lorenz_distance : float - Distance between simulated and actual Lorenz curves, for display. - save_name : string - Name to save the calculated results, for later use in producing figures - and tables, etc. - - Returns - ------- - none - ''' - sim_length = this_type_list[0].sim_periods - sim_wealth = (np.vstack((this_type.W_history for this_type in this_type_list))).flatten() - sim_wealth_short = (np.vstack((this_type.W_history[0:sim_length,:] for this_type in this_type_list))).flatten() - sim_kappa = (np.vstack((this_type.kappa_history for this_type in this_type_list))).flatten() - sim_income = (np.vstack((this_type.pHist[0:sim_length,:]*np.asarray(this_type.TranShkHist[0:sim_length,:]) for this_type in this_type_list))).flatten() - sim_ratio = (np.vstack((this_type.W_history[0:sim_length,:]/this_type.pHist[0:sim_length,:] for this_type in this_type_list))).flatten() - if Params.do_lifecycle: - sim_unemp = (np.vstack((np.vstack((this_type.IncUnemp == this_type.TranShkHist[0:Params.working_T,:],np.zeros((Params.retired_T+1,this_type_list[0].Nagents),dtype=bool))) for this_type in this_type_list))).flatten() - sim_emp = (np.vstack((np.vstack((this_type.IncUnemp != this_type.TranShkHist[0:Params.working_T,:],np.zeros((Params.retired_T+1,this_type_list[0].Nagents),dtype=bool))) for this_type in this_type_list))).flatten() - sim_ret = (np.vstack((np.vstack((np.zeros((Params.working_T,this_type_list[0].Nagents),dtype=bool),np.ones((Params.retired_T+1,this_type_list[0].Nagents),dtype=bool))) for this_type in this_type_list))).flatten() - else: - sim_unemp = np.vstack((this_type.IncUnemp == this_type.TranShkHist[0:sim_length,:] for this_type in this_type_list)).flatten() - sim_emp = np.vstack((this_type.IncUnemp != this_type.TranShkHist[0:sim_length,:] for this_type in this_type_list)).flatten() - sim_ret = np.zeros(sim_emp.size,dtype=bool) - sim_weight_all = np.tile(np.repeat(age_weight,this_type_list[0].Nagents),Params.pref_type_count) - - if Params.do_beta_dist and Params.do_lifecycle: - kappa_mean_by_age_type = (np.mean(np.vstack((this_type.kappa_history for this_type in this_type_list)),axis=1)).reshape((Params.pref_type_count*3,DropoutType.T_total+1)) - kappa_mean_by_age_pref = np.zeros((Params.pref_type_count,DropoutType.T_total+1)) + np.nan - for j in range(Params.pref_type_count): - kappa_mean_by_age_pref[j,] = Params.d_pct*kappa_mean_by_age_type[3*j+0,] + Params.h_pct*kappa_mean_by_age_type[3*j+1,] + Params.c_pct*kappa_mean_by_age_type[3*j+2,] - kappa_mean_by_age = np.mean(kappa_mean_by_age_pref,axis=0) - kappa_lo_beta_by_age = kappa_mean_by_age_pref[0,:] - kappa_hi_beta_by_age = kappa_mean_by_age_pref[Params.pref_type_count-1,:] - - lorenz_fig_data = makeLorenzFig(Params.SCF_wealth,Params.SCF_weights,sim_wealth,sim_weight_all) - mpc_fig_data = makeMPCfig(sim_kappa,sim_weight_all) - - kappa_all = calcWeightedAvg(np.vstack((this_type.kappa_history for this_type in this_type_list)),np.tile(age_weight/float(Params.pref_type_count),Params.pref_type_count)) - kappa_unemp = np.sum(sim_kappa[sim_unemp]*sim_weight_all[sim_unemp])/np.sum(sim_weight_all[sim_unemp]) - kappa_emp = np.sum(sim_kappa[sim_emp]*sim_weight_all[sim_emp])/np.sum(sim_weight_all[sim_emp]) - kappa_ret = np.sum(sim_kappa[sim_ret]*sim_weight_all[sim_ret])/np.sum(sim_weight_all[sim_ret]) - - my_cutoffs = [(0.99,1),(0.9,1),(0.8,1),(0.6,0.8),(0.4,0.6),(0.2,0.4),(0.0,0.2)] - kappa_by_ratio_groups = calcSubpopAvg(sim_kappa,sim_ratio,my_cutoffs,sim_weight_all) - kappa_by_income_groups = calcSubpopAvg(sim_kappa,sim_income,my_cutoffs,sim_weight_all) - - quintile_points = getPercentiles(sim_wealth_short,weights=sim_weight_all,percentiles=[0.2, 0.4, 0.6, 0.8]) - wealth_quintiles = np.ones(sim_wealth_short.size,dtype=int) - wealth_quintiles[sim_wealth_short > quintile_points[0]] = 2 - wealth_quintiles[sim_wealth_short > quintile_points[1]] = 3 - wealth_quintiles[sim_wealth_short > quintile_points[2]] = 4 - wealth_quintiles[sim_wealth_short > quintile_points[3]] = 5 - MPC_cutoff = getPercentiles(sim_kappa,weights=sim_weight_all,percentiles=[2.0/3.0]) - these_quintiles = wealth_quintiles[sim_kappa > MPC_cutoff] - these_weights = sim_weight_all[sim_kappa > MPC_cutoff] - hand_to_mouth_total = np.sum(these_weights) - hand_to_mouth_pct = [] - for q in range(5): - hand_to_mouth_pct.append(np.sum(these_weights[these_quintiles == (q+1)])/hand_to_mouth_total) - - results_string = 'Estimate is DiscFac=' + str(DiscFac) + ', nabla=' + str(nabla) + '\n' - results_string += 'Lorenz distance is ' + str(lorenz_distance) + '\n' - results_string += 'Average MPC for all consumers is ' + mystr(kappa_all) + '\n' - results_string += 'Average MPC in the top percentile of W/Y is ' + mystr(kappa_by_ratio_groups[0]) + '\n' - results_string += 'Average MPC in the top decile of W/Y is ' + mystr(kappa_by_ratio_groups[1]) + '\n' - results_string += 'Average MPC in the top quintile of W/Y is ' + mystr(kappa_by_ratio_groups[2]) + '\n' - results_string += 'Average MPC in the second quintile of W/Y is ' + mystr(kappa_by_ratio_groups[3]) + '\n' - results_string += 'Average MPC in the middle quintile of W/Y is ' + mystr(kappa_by_ratio_groups[4]) + '\n' - results_string += 'Average MPC in the fourth quintile of W/Y is ' + mystr(kappa_by_ratio_groups[5]) + '\n' - results_string += 'Average MPC in the bottom quintile of W/Y is ' + mystr(kappa_by_ratio_groups[6]) + '\n' - results_string += 'Average MPC in the top percentile of y is ' + mystr(kappa_by_income_groups[0]) + '\n' - results_string += 'Average MPC in the top decile of y is ' + mystr(kappa_by_income_groups[1]) + '\n' - results_string += 'Average MPC in the top quintile of y is ' + mystr(kappa_by_income_groups[2]) + '\n' - results_string += 'Average MPC in the second quintile of y is ' + mystr(kappa_by_income_groups[3]) + '\n' - results_string += 'Average MPC in the middle quintile of y is ' + mystr(kappa_by_income_groups[4]) + '\n' - results_string += 'Average MPC in the fourth quintile of y is ' + mystr(kappa_by_income_groups[5]) + '\n' - results_string += 'Average MPC in the bottom quintile of y is ' + mystr(kappa_by_income_groups[6]) + '\n' - results_string += 'Average MPC for the employed is ' + mystr(kappa_emp) + '\n' - results_string += 'Average MPC for the unemployed is ' + mystr(kappa_unemp) + '\n' - results_string += 'Average MPC for the retired is ' + mystr(kappa_ret) + '\n' - results_string += 'Of the population with the 1/3 highest MPCs...' + '\n' - results_string += mystr(hand_to_mouth_pct[0]*100) + '% are in the bottom wealth quintile,' + '\n' - results_string += mystr(hand_to_mouth_pct[1]*100) + '% are in the second wealth quintile,' + '\n' - results_string += mystr(hand_to_mouth_pct[2]*100) + '% are in the third wealth quintile,' + '\n' - results_string += mystr(hand_to_mouth_pct[3]*100) + '% are in the fourth wealth quintile,' + '\n' - results_string += 'and ' + mystr(hand_to_mouth_pct[4]*100) + '% are in the top wealth quintile.' + '\n' - print(results_string) - - if save_name is not None: - with open('./Results/' + save_name + 'LorenzFig.txt','w') as f: - my_writer = csv.writer(f, delimiter='\t',) - for j in range(len(lorenz_fig_data[0])): - my_writer.writerow([lorenz_fig_data[0][j], lorenz_fig_data[1][j], lorenz_fig_data[2][j]]) - f.close() - with open('./Results/' + save_name + 'MPCfig.txt','w') as f: - my_writer = csv.writer(f, delimiter='\t') - for j in range(len(mpc_fig_data[0])): - my_writer.writerow([lorenz_fig_data[0][j], mpc_fig_data[1][j]]) - f.close() - if Params.do_beta_dist and Params.do_lifecycle: - with open('./Results/' + save_name + 'KappaByAge.txt','w') as f: - my_writer = csv.writer(f, delimiter='\t') - for j in range(len(kappa_mean_by_age)): - my_writer.writerow([kappa_mean_by_age[j], kappa_lo_beta_by_age[j], kappa_hi_beta_by_age[j]]) - f.close() - with open('./Results/' + save_name + 'Results.txt','w') as f: - f.write(results_string) - f.close() - - -def makeLorenzFig(real_wealth,real_weights,sim_wealth,sim_weights): - ''' - Produces a Lorenz curve for the distribution of wealth, comparing simulated - to actual data. A sub-function of makeCSTWresults(). - - Parameters - ---------- - real_wealth : np.array - Data on household wealth. - real_weights : np.array - Weighting array of the same size as real_wealth. - sim_wealth : np.array - Simulated wealth holdings of many households. - sim_weights :np.array - Weighting array of the same size as sim_wealth. - - Returns - ------- - these_percents : np.array - An array of percentiles of households, by wealth. - real_lorenz : np.array - Lorenz shares for real_wealth corresponding to these_percents. - sim_lorenz : np.array - Lorenz shares for sim_wealth corresponding to these_percents. - ''' - these_percents = np.linspace(0.0001,0.9999,201) - real_lorenz = getLorenzShares(real_wealth,weights=real_weights,percentiles=these_percents) - sim_lorenz = getLorenzShares(sim_wealth,weights=sim_weights,percentiles=these_percents) - plt.plot(100*these_percents,real_lorenz,'-k',linewidth=1.5) - plt.plot(100*these_percents,sim_lorenz,'--k',linewidth=1.5) - plt.xlabel('Wealth percentile',fontsize=14) - plt.ylabel('Cumulative wealth ownership',fontsize=14) - plt.title('Simulated vs Actual Lorenz Curves',fontsize=16) - plt.legend(('Actual','Simulated'),loc=2,fontsize=12) - plt.ylim(-0.01,1) - plt.show() - return (these_percents,real_lorenz,sim_lorenz) - - -def makeMPCfig(kappa,weights): - ''' - Plot the CDF of the marginal propensity to consume. A sub-function of makeCSTWresults(). - - Parameters - ---------- - kappa : np.array - Array of (annualized) marginal propensities to consume for the economy. - weights : np.array - Age-conditional weight array for the data in kappa. - - Returns - ------- - these_percents : np.array - Array of percentiles of the marginal propensity to consume. - kappa_percentiles : np.array - Array of MPCs corresponding to the percentiles in these_percents. - ''' - these_percents = np.linspace(0.0001,0.9999,201) - kappa_percentiles = getPercentiles(kappa,weights,percentiles=these_percents) - plt.plot(kappa_percentiles,these_percents,'-k',linewidth=1.5) - plt.xlabel('Marginal propensity to consume',fontsize=14) - plt.ylabel('Cumulative probability',fontsize=14) - plt.title('CDF of the MPC',fontsize=16) - plt.show() - return (these_percents,kappa_percentiles) - - -def calcKappaMean(DiscFac,nabla): - ''' - Calculates the average MPC for the given parameters. This is a very small - sub-function of sensitivityAnalysis. - - Parameters - ---------- - DiscFac : float - Center of the uniform distribution of discount factors - nabla : float - Width of the uniform distribution of discount factors - - Returns - ------- - kappa_all : float - Average marginal propensity to consume in the population. - ''' - DiscFac_list = approxUniform(N=Params.pref_type_count,bot=DiscFac-nabla,top=DiscFac+nabla)[1] - assignBetaDistribution(est_type_list,DiscFac_list) - multiThreadCommandsFake(est_type_list,beta_point_commands) - - kappa_all = calcWeightedAvg(np.vstack((this_type.kappa_history for this_type in est_type_list)), - np.tile(Params.age_weight_all/float(Params.pref_type_count), - Params.pref_type_count)) - return kappa_all - - -def sensitivityAnalysis(parameter,values,is_time_vary): - ''' - Perform a sensitivity analysis by varying a chosen parameter over given values - and re-estimating the model at each. Only works for perpetual youth version. - Saves numeric results in a file named SensitivityPARAMETER.txt. - - Parameters - ---------- - parameter : string - Name of an attribute/parameter of cstwMPCagent on which to perform a - sensitivity analysis. The attribute should be a single float. - values : [np.array] - Array of values that the parameter should take on in the analysis. - is_time_vary : boolean - Indicator for whether the parameter of analysis is time_varying (i.e. - is an element of cstwMPCagent.time_vary). While the sensitivity analysis - should only be used for the perpetual youth model, some parameters are - still considered "time varying" in the consumption-saving model and - are encapsulated in a (length=1) list. - - Returns - ------- - none - ''' - fit_list = [] - DiscFac_list = [] - nabla_list = [] - kappa_list = [] - for value in values: - print('Now estimating model with ' + parameter + ' = ' + str(value)) - Params.diff_save = 1000000.0 - old_value_storage = [] - for this_type in est_type_list: - old_value_storage.append(getattr(this_type,parameter)) - if is_time_vary: - setattr(this_type,parameter,[value]) - else: - setattr(this_type,parameter,value) - this_type.update() - output = golden(betaDistObjective,brack=bracket,tol=10**(-4),full_output=True) - nabla = output[0] - fit = output[1] - DiscFac = Params.DiscFac_save - kappa = calcKappaMean(DiscFac,nabla) - DiscFac_list.append(DiscFac) - nabla_list.append(nabla) - fit_list.append(fit) - kappa_list.append(kappa) - with open('./Results/Sensitivity' + parameter + '.txt','w') as f: - my_writer = csv.writer(f, delimiter='\t',) - for j in range(len(DiscFac_list)): - my_writer.writerow([values[j], kappa_list[j], DiscFac_list[j], nabla_list[j], fit_list[j]]) - f.close() - j = 0 - for this_type in est_type_list: - setattr(this_type,parameter,old_value_storage[j]) - this_type.update() - j += 1 - - -# Only run below this line if module is run rather than imported: -if __name__ == "__main__": - # ================================================================= - # ====== Make the list of consumer types for estimation =========== - #================================================================== - - # Set target Lorenz points and K/Y ratio (MOVE THIS TO SetupParams) - if Params.do_liquid: - lorenz_target = np.array([0.0, 0.004, 0.025,0.117]) - KY_target = 6.60 - else: # This is hacky until I can find the liquid wealth data and import it - lorenz_target = getLorenzShares(Params.SCF_wealth,weights=Params.SCF_weights,percentiles=Params.percentiles_to_match) - #lorenz_target = np.array([-0.002, 0.01, 0.053,0.171]) - KY_target = 10.26 - - # Make a vector of initial wealth-to-permanent income ratios - a_init = drawDiscrete(N=Params.sim_pop_size,P=Params.a0_probs,X=Params.a0_values,seed=Params.a0_seed) - - # Make the list of types for this run, whether infinite or lifecycle - if Params.do_lifecycle: - # Make cohort scaling array - cohort_scale = Params.TFP_growth**(-np.arange(Params.total_T+1)) - cohort_scale_array = np.tile(np.reshape(cohort_scale,(Params.total_T+1,1)),(1,Params.sim_pop_size)) - - # Make base consumer types for each education level - DropoutType = cstwMPCagent(**Params.init_dropout) - DropoutType.a_init = a_init - DropoutType.cohort_scale = cohort_scale_array - HighschoolType = deepcopy(DropoutType) - HighschoolType(**Params.adj_highschool) - CollegeType = deepcopy(DropoutType) - CollegeType(**Params.adj_college) - DropoutType.update() - HighschoolType.update() - CollegeType.update() - - # Make initial distributions of permanent income for each education level - p_init_base = drawMeanOneLognormal(N=Params.sim_pop_size, sigma=Params.P0_sigma, seed=Params.P0_seed) - DropoutType.p_init = Params.P0_d*p_init_base - HighschoolType.p_init = Params.P0_h*p_init_base - CollegeType.p_init = Params.P0_c*p_init_base - - # Set the type list for the lifecycle estimation - short_type_list = [DropoutType, HighschoolType, CollegeType] - spec_add = 'LC' - - else: - # Make the base infinite horizon type and assign income shocks - InfiniteType = cstwMPCagent(**Params.init_infinite) - InfiniteType.tolerance = 0.0001 - InfiniteType.a_init = 0*np.ones_like(a_init) - - # Make histories of permanent income levels for the infinite horizon type - p_init_base = np.ones(Params.sim_pop_size,dtype=float) - InfiniteType.p_init = p_init_base - - # Use a "tractable consumer" instead if desired. - # If you want this to work, you must edit TractableBufferStockModel slightly. - # See comments around line 34 in that module for instructions. - if Params.do_tractable: - from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType - TractableInfType = TractableConsumerType(DiscFac=0.99, # will be overwritten - UnempPrb=1-InfiniteType.LivPrb[0], - Rfree=InfiniteType.Rfree, - PermGroFac=InfiniteType.PermGroFac[0], - CRRA=InfiniteType.CRRA, - sim_periods=InfiniteType.sim_periods, - IncUnemp=InfiniteType.IncUnemp, - Nagents=InfiniteType.Nagents) - TractableInfType.p_init = InfiniteType.p_init - TractableInfType.timeFwd() - TractableInfType.TranShkHist = InfiniteType.TranShkHist - TractableInfType.PermShkHist = InfiniteType.PermShkHist - TractableInfType.a_init = InfiniteType.a_init - - # Set the type list for the infinite horizon estimation - if Params.do_tractable: - short_type_list = [TractableInfType] - spec_add = 'TC' - else: - short_type_list = [InfiniteType] - spec_add = 'IH' - - # Expand the estimation type list if doing beta-dist - if Params.do_beta_dist: - long_type_list = [] - for j in range(Params.pref_type_count): - long_type_list += deepcopy(short_type_list) - est_type_list = long_type_list - else: - est_type_list = short_type_list - - if Params.do_liquid: - wealth_measure = 'Liquid' - else: - wealth_measure = 'NetWorth' - - - # ================================================================= - # ====== Define estimation objectives ============================= - #================================================================== - - # Set commands for the beta-point estimation - beta_point_commands = ['solve()','unpackcFunc()','timeFwd()','simulateCSTW()'] - - # Make the objective function for the beta-point estimation - betaPointObjective = lambda DiscFac : simulateKYratioDifference(DiscFac, - nabla=0, - N=1, - type_list=est_type_list, - weights=Params.age_weight_all, - total_output=Params.total_output, - target=KY_target) - - # Make the objective function for the beta-dist estimation - def betaDistObjective(nabla): - # Make the "intermediate objective function" for the beta-dist estimation - #print('Trying nabla=' + str(nabla)) - intermediateObjective = lambda DiscFac : simulateKYratioDifference(DiscFac, - nabla=nabla, - N=Params.pref_type_count, - type_list=est_type_list, - weights=Params.age_weight_all, - total_output=Params.total_output, - target=KY_target) - if Params.do_tractable: - top = 0.98 - else: - top = 0.998 - DiscFac_new = brentq(intermediateObjective,0.90,top,xtol=10**(-8)) - N=Params.pref_type_count - sim_wealth = (np.vstack((this_type.W_history for this_type in est_type_list))).flatten() - sim_weights = np.tile(np.repeat(Params.age_weight_all,Params.sim_pop_size),N) - my_diff = calculateLorenzDifference(sim_wealth,sim_weights,Params.percentiles_to_match,lorenz_target) - print('DiscFac=' + str(DiscFac_new) + ', nabla=' + str(nabla) + ', diff=' + str(my_diff)) - if my_diff < Params.diff_save: - Params.DiscFac_save = DiscFac_new - return my_diff - - - - # ================================================================= - # ========= Estimating the model ================================== - #================================================================== - - if Params.run_estimation: - # Estimate the model and time it - t_start = time() - if Params.do_beta_dist: - bracket = (0,0.015) # large nablas break IH version - nabla = golden(betaDistObjective,brack=bracket,tol=10**(-4)) - DiscFac = Params.DiscFac_save - spec_name = spec_add + 'betaDist' + wealth_measure - else: - nabla = 0 - if Params.do_tractable: - bot = 0.9 - top = 0.98 - else: - bot = 0.9 - top = 1.0 - DiscFac = brentq(betaPointObjective,bot,top,xtol=10**(-8)) - spec_name = spec_add + 'betaPoint' + wealth_measure - t_end = time() - print('Estimate is DiscFac=' + str(DiscFac) + ', nabla=' + str(nabla) + ', took ' + str(t_end-t_start) + ' seconds.') - #spec_name=None - makeCSTWresults(DiscFac,nabla,spec_name) - - - - # ================================================================= - # ========= Relationship between DiscFac and K/Y ratio =============== - #================================================================== - - if Params.find_beta_vs_KY: - t_start = time() - DiscFac_list = np.linspace(0.95,1.01,201) - KY_ratio_list = [] - for DiscFac in DiscFac_list: - KY_ratio_list.append(betaPointObjective(DiscFac) + KY_target) - KY_ratio_list = np.array(KY_ratio_list) - t_end = time() - plt.plot(DiscFac_list,KY_ratio_list,'-k',linewidth=1.5) - plt.xlabel(r'Discount factor $\beta$',fontsize=14) - plt.ylabel('Capital to output ratio',fontsize=14) - print('That took ' + str(t_end-t_start) + ' seconds.') - plt.show() - with open('./Results/' + spec_add + '_KYbyBeta' + '.txt','w') as f: - my_writer = csv.writer(f, delimiter='\t',) - for j in range(len(DiscFac_list)): - my_writer.writerow([DiscFac_list[j], KY_ratio_list[j]]) - f.close() - - - - # ================================================================= - # ========= Sensitivity analysis ================================== - #================================================================== - - # Sensitivity analysis only set up for infinite horizon model! - if Params.do_lifecycle: - bracket = (0,0.015) - else: - bracket = (0,0.015) # large nablas break IH version - spec_name = None - - if Params.do_sensitivity[0]: # coefficient of relative risk aversion sensitivity analysis - CRRA_list = np.linspace(0.5,4.0,15).tolist() #15 - sensitivityAnalysis('CRRA',CRRA_list,False) - - if Params.do_sensitivity[1]: # transitory income stdev sensitivity analysis - TranShkStd_list = [0.01] + np.linspace(0.05,0.8,16).tolist() #16 - sensitivityAnalysis('TranShkStd',TranShkStd_list,True) - - if Params.do_sensitivity[2]: # permanent income stdev sensitivity analysis - PermShkStd_list = np.linspace(0.02,0.18,17).tolist() #17 - sensitivityAnalysis('PermShkStd',PermShkStd_list,True) - - if Params.do_sensitivity[3]: # unemployment benefits sensitivity analysis - IncUnemp_list = np.linspace(0.0,0.8,17).tolist() #17 - sensitivityAnalysis('IncUnemp',IncUnemp_list,False) - - if Params.do_sensitivity[4]: # unemployment rate sensitivity analysis - UnempPrb_list = np.linspace(0.02,0.12,16).tolist() #16 - sensitivityAnalysis('UnempPrb',UnempPrb_list,False) - - if Params.do_sensitivity[5]: # mortality rate sensitivity analysis - LivPrb_list = 1.0 - np.linspace(0.003,0.0125,16).tolist() #16 - sensitivityAnalysis('LivPrb',LivPrb_list,True) - - if Params.do_sensitivity[6]: # permanent income growth rate sensitivity analysis - PermGroFac_list = np.linspace(0.00,0.04,17).tolist() #17 - sensitivityAnalysis('PermGroFac',PermGroFac_list,True) - - if Params.do_sensitivity[7]: # interest rate sensitivity analysis - Rfree_list = (np.linspace(1.0,1.04,17)/InfiniteType.survival_prob[0]).tolist() - sensitivityAnalysis('Rfree',Rfree_list,False) - - - # ======================================================================= - # ========= FBS aggregate shocks model ================================== - #======================================================================== - if Params.do_agg_shocks: - # These are the perpetual youth estimates in case we want to skip estimation (and we do) - beta_point_estimate = 0.989142 - beta_dist_estimate = 0.985773 - nabla_estimate = 0.0077 - - # Make a set of consumer types for the FBS aggregate shocks model - BaseAggShksType = AggShockConsumerType(**Params.init_agg_shocks) - agg_shocks_type_list = [] - for j in range(Params.pref_type_count): - new_type = deepcopy(BaseAggShksType) - new_type.seed = j - new_type.resetRNG() - new_type.makeIncShkHist() - agg_shocks_type_list.append(new_type) - if Params.do_beta_dist: - beta_agg = beta_dist_estimate - nabla_agg = nabla_estimate - else: - beta_agg = beta_point_estimate - nabla_agg = 0.0 - DiscFac_list_agg = approxUniform(N=Params.pref_type_count,bot=beta_agg-nabla_agg,top=beta_agg+nabla_agg)[1] - assignBetaDistribution(agg_shocks_type_list,DiscFac_list_agg) - - # Make a market for solving the FBS aggregate shocks model - agg_shocks_market = CobbDouglasEconomy(agents = agg_shocks_type_list, - act_T = Params.sim_periods_agg_shocks, - tolerance = 0.0001, - **Params.aggregate_params) - agg_shocks_market.makeAggShkHist() - - # Edit the consumer types so they have the right data - for this_type in agg_shocks_market.agents: - this_type.p_init = drawMeanOneLognormal(N=this_type.Nagents,sigma=0.9,seed=0) - this_type.getEconomyData(agg_shocks_market) - - # Solve the aggregate shocks version of the model - t_start = time() - agg_shocks_market.solve() - t_end = time() - print('Solving the aggregate shocks model took ' + str(t_end - t_start) + ' seconds.') - for this_type in agg_shocks_type_list: - this_type.W_history = this_type.pHist*this_type.bHist - this_type.kappa_history = 1.0 - (1.0 - this_type.MPChist)**4 - agg_shock_weights = np.concatenate((np.zeros(200),np.ones(Params.sim_periods_agg_shocks-200))) - agg_shock_weights = agg_shock_weights/np.sum(agg_shock_weights) - makeCSTWstats(beta_agg,nabla_agg,agg_shocks_type_list,agg_shock_weights) diff --git a/HARK/dcegm.py b/HARK/dcegm.py new file mode 100644 index 000000000..773d95f13 --- /dev/null +++ b/HARK/dcegm.py @@ -0,0 +1,198 @@ +""" +Functions for working with the discrete-continuous EGM (DCEGM) algorithm as +described in "The endogenous grid method for discrete-continuous dynamic +choice models with (or without) taste shocks" by Iskhakov et al. (2016) +[https://doi.org/10.3982/QE643 and ijrsDCEGM2017 in our Zotero] +""" +import numpy as np +from HARK.interpolation import LinearInterp + + +def calcSegments(x, v): + """ + Find index vectors `rise` and `fall` such that `rise` holds the indeces `i` + such that x[i+1]>x[i] and `fall` holds indeces `j` such that either + - x[j+1] < x[j] or, + - x[j]>x[j-1] and v[j] x[i-1] # true if grid decreases on index decrement + val_fell = v[i] < v[i-1] # true if value rises on index decrement + + if (ip1_falls and i_rose) or (val_fell and i_rose): + + # we are in a region where the endogenous grid is decreasing or + # the value function rises by stepping back in the grid. + fall = np.append(fall, i) # add the index to the vector + + # We now iterate from the current index onwards until we find point + # where resources rises again. Unfortunately, we need to check + # each points, as there can be multiple spells of falling endogenous + # grids, so we cannot use bisection or some other fast algorithm. + k = i + while x[k+1] < x[k]: + k = k + 1 + # k now holds either the next index the starts a new rising + # region, or it holds the length of M, `m_len`. + + rise = np.append(rise, k) + + # Set the index to the point where resources again is rising + i = k + + i = i + 1 + + # Add the last index for convenience (then all segments are complete, as + # len(fall) == len(rise), and we can form them by range(rise[j], fall[j]+1). + fall = np.append(fall, len(v)-1) + + return rise, fall +# think! nanargmax makes everythign super ugly because numpy changed the wraning +# in all nan slices to a valueerror...it's nans, aaarghgghg + + +def calcMultilineEnvelope(M, C, V_T, commonM): + """ + Do the envelope step of the DCEGM algorithm. Takes in market ressources, + consumption levels, and inverse values from the EGM step. These represent + (m, c) pairs that solve the necessary first order conditions. This function + calculates the optimal (m, c, v_t) pairs on the commonM grid. + + Parameters + ---------- + M : np.array + market ressources from EGM step + C : np.array + consumption from EGM step + V_T : np.array + transformed values at the EGM grid + commonM : np.array + common grid to do upper envelope calculations on + + Returns + ------- + + + """ + m_len = len(commonM) + rise, fall = calcSegments(M, V_T) + + num_kinks = len(fall) # number of kinks / falling EGM grids + + # Use these segments to sequentially find upper envelopes. commonVARNAME + # means the VARNAME evaluated on the common grid with a cloumn for each kink + # discovered in calcSegments. This means that commonVARNAME is a matrix + # common grid length-by-number of segments to consider. In the end, we'll + # use nanargmax over the columns to pick out the best (transformed) values. + # This is why we fill the arrays with np.nan's. + commonV_T = np.empty((m_len, num_kinks)) + commonV_T[:] = np.nan + commonC = np.empty((m_len, num_kinks)) + commonC[:] = np.nan + + # Now, loop over all segments as defined by the "kinks" or the combination + # of "rise" and "fall" indeces. These (rise[j], fall[j]) pairs define regions + for j in range(num_kinks): + # Find points in the common grid that are in the range of the points in + # the interval defined by (rise[j], fall[j]). + below = M[rise[j]] >= commonM # boolean array of bad indeces below + above = M[fall[j]] <= commonM # boolen array of bad indeces above + in_range = below + above == 0 # pick out elements that are neither + + # create range of indeces in the input arrays + idxs = range(rise[j], fall[j]+1) + # grab ressource values at the relevant indeces + m_idx_j = M[idxs] + + # based in in_range, find the relevant ressource values to interpolate + m_eval = commonM[in_range] + + # re-interpolate to common grid + commonV_T[in_range, j] = LinearInterp(m_idx_j, V_T[idxs], lower_extrap=True)(m_eval) # NOQA + commonC[in_range, j] = LinearInterp(m_idx_j, C[idxs], lower_extrap=True)(m_eval) # NOQA Interpolat econsumption also. May not be nesserary + # for each row in the commonV_T matrix, see if all entries are np.nan. This + # would mean that we have no valid value here, so we want to use this boolean + # vector to filter out irrelevant entries of commonV_T. + row_all_nan = np.array([np.all(np.isnan(row)) for row in commonV_T]) + # Now take the max of all these line segments. + idx_max = np.zeros(commonM.size, dtype=int) + idx_max[row_all_nan == False] = np.nanargmax(commonV_T[row_all_nan == False], axis=1) + + # prefix with upper for variable that are "upper enveloped" + upperV_T = np.zeros(m_len) + + # Set the non-nan rows to the maximum over columns + upperV_T[row_all_nan == False] = np.nanmax(commonV_T[row_all_nan == False, :], axis=1) + # Set the rest to nan + upperV_T[row_all_nan] = np.nan + + # Add the zero point in the bottom + if np.isnan(upperV_T[0]): + # in transformed space space, utility of zero-consumption (-inf) is 0.0 + upperV_T[0] = 0.0 + # commonM[0] is typically 0, so this is safe, but maybe it should be 0.0 + commonC[0] = commonM[0] + + # Extrapolate if NaNs are introduced due to the common grid + # going outside all the sub-line segments + IsNaN = np.isnan(upperV_T) + upperV_T[IsNaN] = LinearInterp(commonM[IsNaN == False], upperV_T[IsNaN == False])(commonM[IsNaN]) + LastBeforeNaN = np.append(np.diff(IsNaN) > 0, 0) + LastId = LastBeforeNaN*idx_max # Find last id-number + idx_max[IsNaN] = LastId[IsNaN] + # Linear index used to get optimal consumption based on "id" from max + ncols = commonC.shape[1] + rowidx = np.cumsum(ncols*np.ones(len(commonM), dtype=int))-ncols + idx_linear = np.unravel_index(rowidx+idx_max, commonC.shape) + upperC = commonC[idx_linear] + upperC[IsNaN] = LinearInterp(commonM[IsNaN == 0], upperC[IsNaN == 0])(commonM[IsNaN]) + + # TODO calculate cross points of line segments to get the true vertical drops + + upperM = commonM.copy() # anticipate this TODO + + return upperM, upperC, upperV_T + + +def main(): + print("Sorry, HARK.dcegm doesn't actually do anything on its own.") + + +if __name__ == '__main__': + main() diff --git a/HARK/interpolation.py b/HARK/interpolation.py index c04cd3e11..7913a3986 100644 --- a/HARK/interpolation.py +++ b/HARK/interpolation.py @@ -3362,11 +3362,12 @@ def _derY(self,x,y): # Calculate the derivative with respect to x (and return it) dfdy = y_alpha*dfda + y_beta*dfdb return dfdy - + ############################################################################### ## Functions used in discrete choice models with T1EV taste shocks ############ ############################################################################### + def calcLogSumChoiceProbs(Vals, sigma): ''' Returns the final optimal value and choice probabilities given the choice @@ -3384,14 +3385,34 @@ def calcLogSumChoiceProbs(Vals, sigma): P : [numpy.array] A numpy.array that holds the discrete choice probabilities ''' + # Assumes that NaNs have been replaced by -numpy.inf or similar + if sigma == 0.0: + # We could construct a linear index here and use unravel_index. + Pflat = np.argmax(Vals, axis=0) + + V = np.zeros(Vals[0].shape) + Probs = np.zeros(Vals.shape) + for i in range(Vals.shape[0]): + optimalIndices = Pflat == i + V[optimalIndices] = Vals[i][optimalIndices] + Probs[i][optimalIndices] = 1 + return V, Probs + + # else we have a taste shock + maxV = np.max(Vals, axis=0) + + # calculate maxV+sigma*log(sum_i=1^J exp((V[i]-maxV))/sigma) + sumexp = np.sum(np.exp((Vals-maxV)/sigma), axis=0) + LogSumV = np.log(sumexp) + LogSumV = maxV + sigma*LogSumV - return calcLogSum(Vals, sigma), calcChoiceProbs(Vals, sigma) + Probs = np.exp((Vals-LogSumV)/sigma) + return LogSumV, Probs def calcChoiceProbs(Vals, sigma): ''' Returns the choice probabilities given the choice specific value functions `Vals`. Probabilities are degenerate if sigma == 0.0. - Parameters ---------- Vals : [numpy.array] @@ -3413,14 +3434,14 @@ def calcChoiceProbs(Vals, sigma): Probs[i][Pflat==i] = 1 return Probs - Probs = np.divide(np.exp((Vals-Vals[0])/sigma), np.sum(np.exp((Vals-Vals[0])/sigma), axis=0)) + maxV = np.max(Vals, axis=0) + Probs = np.divide(np.exp((Vals-maxV)/sigma), np.sum(np.exp((Vals-maxV)/sigma), axis=0)) return Probs def calcLogSum(Vals, sigma): ''' Returns the optimal value given the choice specific value functions Vals. - Parameters ---------- Vals : [numpy.array] @@ -3440,13 +3461,13 @@ def calcLogSum(Vals, sigma): return V # else we have a taste shock - maxV = Vals.max() + maxV = np.max(Vals, axis=0) # calculate maxV+sigma*log(sum_i=1^J exp((V[i]-maxV))/sigma) sumexp = np.sum(np.exp((Vals-maxV)/sigma), axis=0) - V = np.log(sumexp) - V = maxV + sigma*V - return V + LogSumV = np.log(sumexp) + LogSumV = maxV + sigma*LogSumV + return LogSumV def main(): print("Sorry, HARK.interpolation doesn't actually do much on its own.") diff --git a/HARK/parallel.py b/HARK/parallel.py index 9e84b8ef5..602117300 100644 --- a/HARK/parallel.py +++ b/HARK/parallel.py @@ -84,13 +84,13 @@ def multiThreadCommands(agent_list,command_list,num_jobs=None): multiThreadCommandsFake(agent_list,command_list) return None - # Default umber of parallel jobs is the smaller of number of AgentTypes in + # Default number of parallel jobs is the smaller of number of AgentTypes in # the input and the number of available cores. if num_jobs is None: num_jobs = min(len(agent_list),multiprocessing.cpu_count()) # Send each command in command_list to each of the types in agent_list to be run - agent_list_out = Parallel(n_jobs=num_jobs)(delayed(runCommands)(*args) for args in zip(agent_list, len(agent_list)*[command_list])) + agent_list_out = Parallel(backend='multiprocessing',n_jobs=num_jobs)(delayed(runCommands)(*args) for args in zip(agent_list, len(agent_list)*[command_list])) # Replace the original types with the output from the parallel call for j in range(len(agent_list)): diff --git a/HARK/tests/test_initial.py b/HARK/tests/test_HARKutilities.py similarity index 73% rename from HARK/tests/test_initial.py rename to HARK/tests/test_HARKutilities.py index 59ff06760..7624ee064 100644 --- a/HARK/tests/test_initial.py +++ b/HARK/tests/test_HARKutilities.py @@ -4,31 +4,27 @@ from __future__ import print_function, division from __future__ import absolute_import -from builtins import str -from builtins import zip -from builtins import range -from builtins import object - import HARK.utilities # Bring in modules we need import unittest import numpy as np + class testsForHARKutilities(unittest.TestCase): def setUp(self): - self.c_vals = np.linspace(.5,10.,20) - self.CRRA_vals = np.linspace(1.,10.,10) + self.c_vals = np.linspace(.5, 10., 20) + self.CRRA_vals = np.linspace(1., 10., 10) - def first_diff_approx(self,func,x,delta,*args): + def first_diff_approx(self, func, x, delta, *args): """ Take the first (centered) difference approximation to the derivative of a function. """ - return (func(x+delta,*args) - func(x-delta,*args)) / (2. * delta) + return (func(x+delta, *args) - func(x-delta, *args)) / (2. * delta) - def derivative_func_comparison(self,deriv,func): + def derivative_func_comparison(self, deriv, func): """ This method computes the first difference approximation to the derivative of a function "func" and the (supposedly) closed-form derivative of that function ("deriv") over a @@ -42,23 +38,23 @@ def derivative_func_comparison(self,deriv,func): # Calculate the difference between the derivative of the function and the # first difference approximation to that derivative. - diff = abs(deriv(c,CRRA) - self.first_diff_approx(func,c,.000001,CRRA)) + diff = abs(deriv(c, CRRA) - self.first_diff_approx(func, c, .000001, CRRA)) # Make sure the derivative and its approximation are close - self.assertLess(diff,.01) + self.assertLess(diff, .01) def test_CRRAutilityP(self): # Test the first derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityP,HARK.utilities.CRRAutility) + self.derivative_func_comparison(HARK.utilities.CRRAutilityP, HARK.utilities.CRRAutility) def test_CRRAutilityPP(self): # Test the second derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityPP,HARK.utilities.CRRAutilityP) + self.derivative_func_comparison(HARK.utilities.CRRAutilityPP, HARK.utilities.CRRAutilityP) def test_CRRAutilityPPP(self): # Test the third derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityPPP,HARK.utilities.CRRAutilityPP) + self.derivative_func_comparison(HARK.utilities.CRRAutilityPPP, HARK.utilities.CRRAutilityPP) def test_CRRAutilityPPPP(self): # Test the fourth derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityPPPP,HARK.utilities.CRRAutilityPPP) + self.derivative_func_comparison(HARK.utilities.CRRAutilityPPPP, HARK.utilities.CRRAutilityPPP) diff --git a/HARK/tests/test_TractableBufferStockModel.py b/HARK/tests/test_TractableBufferStockModel.py new file mode 100644 index 000000000..234e9250c --- /dev/null +++ b/HARK/tests/test_TractableBufferStockModel.py @@ -0,0 +1,59 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu Mar 24 11:01:50 2016 + +@author: kaufmana +""" + +import numpy as np +import HARK.ConsumptionSaving.TractableBufferStockModel as Model +import unittest + + +class FuncTest(unittest.TestCase): + + def setUp(self): + base_primitives = {'UnempPrb': .015, + 'DiscFac': 0.9, + 'Rfree': 1.1, + 'PermGroFac': 1.05, + 'CRRA': .95} + test_model = Model.TractableConsumerType(**base_primitives) + test_model.solve() + cNrm_list = np.array([0.0, + 0.6170411710160961, + 0.7512931350607787, + 0.8242071925443384, + 0.8732633069358244, + 0.9090443048442146, + 0.9362584565290604, + 0.9574865107447327, + 0.9743235996720729, + 0.9878347049396029, + 0.9987694718922687, + 1.0499840337356576, + 1.0988370658458553, + 1.1079081119060201, + 1.1185500922622567, + 1.1309953859705277, + 1.1454986397022289, + 1.1623357560591763, + 1.1818022106863713, + 1.2042108062871855, + 1.2298890682784422, + 1.2591765689896088, + 1.2924225145436121, + 1.329983925942064, + 1.372224689976677, + 1.4195156568037894, + 1.4722358408529614, + 1.5307746658958221]) + return np.array(test_model.solution[0].cNrm_list), cNrm_list + + def test_equalityOfSolutions(self): + results = self.setUp() + self.assertTrue(np.allclose(results[0], results[1], atol=1e-08)) + + +if __name__ == '__main__': + unittest.main() diff --git a/HARK/tests/test_approxDstns.py b/HARK/tests/test_approxDstns.py new file mode 100644 index 000000000..940845c96 --- /dev/null +++ b/HARK/tests/test_approxDstns.py @@ -0,0 +1,26 @@ +""" +This file implements unit tests apprixomate distributions. +""" + +# Bring in modules we need +import HARK.utilities as util +import unittest +import numpy as np + +class testsForDCEGM(unittest.TestCase): + def setUp(self): + # setup the parameters to loop over + self.muNormals = np.linspace(-3.0, 2.0, 50) + self.stdNormals = np.linspace(0.01, 2.0, 50) + + def test_mu_normal(self): + for muNormal in self.muNormals: + for stdNormal in self.stdNormals: + w, x = util.approxNormal(40, muNormal) + self.assertTrue(sum(w*x)-muNormal<1e-12) + + def test_mu_lognormal_from_normal(self): + for muNormal in self.muNormals: + for stdNormal in self.stdNormals: + w, x = util.approxLognormalGaussHermite(40, muNormal, stdNormal) + self.assertTrue(abs(sum(w*x)-util.calcLognormalStyleParsFromNormalPars(muNormal, stdNormal)[0])<1e-12) diff --git a/HARK/tests/test_dcegm.py b/HARK/tests/test_dcegm.py new file mode 100644 index 000000000..ee4962bca --- /dev/null +++ b/HARK/tests/test_dcegm.py @@ -0,0 +1,49 @@ +""" +This file implements unit tests to check discrete choice functions +""" +from HARK import dcegm + +# Bring in modules we need +import unittest +import numpy as np + + +class testsForDCEGM(unittest.TestCase): + + def setUp(self): + self.commonM = np.linspace(0, 10.0, 30) + self.m_in = np.array([1.0, 2.0, 3.0, 2.5, 2.0, 4.0, 5.0, 6.0]) + self.c_in = np.array([1.0, 2.0, 3.0, 2.5, 2.0, 4.0, 5.0, 6.0]) + self.v_in = np.array([0.5, 1.0, 1.5, 0.75, 0.5, 3.5, 5.0, 7.0]) + + def test_crossing(self): + # Test that the upper envelope has the approximate correct value + # where the two increasing segments with m_1 = [2, 3] and m_2 = [2.0, 4.0] + # is the correct value. + # + # Calculate the crossing by hand + slope_1 = (1.5 - 1.0)/(3.0 - 2.0) + slope_2 = (3.5 - 0.5)/(4.0 - 2.0) + m_cross = 2.0 + (0.5 - 1.0)/(slope_1 - slope_2) + + m_out, c_out, v_out = dcegm.calcMultilineEnvelope(self.m_in, self.c_in, self.v_in, self.commonM) + + m_idx = 0 + for m in m_out: + if m > m_cross: + break + m_idx += 1 + + # Just right of the cross, the second segment is optimal + true_v = 0.5 + (m_out[m_idx] - 2.0)*slope_2 + self.assertTrue(abs(v_out[m_idx] - true_v) < 1e-12) + + # also test that first elements are 0 etc + + # def test_crossing_in_grid(self): + # # include crossing m in common grid + # commonM_augmented = np.append(self.commonM, m_cross).sort() + # + # m_out, c_out, v_out = calcMultilineEnvelope(self.m_in, self.c_in, self.v_in, self.commonM) + # + # self.assertTrue( diff --git a/HARK/tests/test_modelInits.py b/HARK/tests/test_modelInits.py new file mode 100644 index 000000000..4d4d9b2e2 --- /dev/null +++ b/HARK/tests/test_modelInits.py @@ -0,0 +1,66 @@ +""" +This file tests whether HARK's models are initialized correctly. +""" + + +# Bring in modules we need +import unittest +import numpy as np +import HARK.ConsumptionSaving.ConsumerParameters as Params +from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import KinkedRconsumerType +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType +from HARK.utilities import plotFuncsDer, plotFuncs +from copy import copy + +class testInitialization(unittest.TestCase): + # We don't need a setUp method for the tests to run, but it's convenient + # if we want to test various things on the same model in different test_* + # methods. + def test_PerfForesightConsumerType(self): + try: + model = PerfForesightConsumerType(**Params.init_perfect_foresight) + except: + self.fail("PerfForesightConsumerType failed to initialize with Params.init_perfect_foresight.") + + def test_IndShockConsumerType(self): + try: + model = IndShockConsumerType(**Params.init_lifecycle) + except: + self.fail("IndShockConsumerType failed to initialize with Params.init_lifecycle.") + + def test_KinkedRconsumerType(self): + try: + model = KinkedRconsumerType(**Params.init_kinked_R) + except: + self.fail("KinkedRconsumerType failed to initialize with Params.init_kinked_R.") + + def test_MarkovConsumerType(self): + try: + unemp_length = 5 # Averange length of unemployment spell + urate_good = 0.05 # Unemployment rate when economy is in good state + urate_bad = 0.12 # Unemployment rate when economy is in bad state + bust_prob = 0.01 # Probability of economy switching from good to bad + recession_length = 20 # Averange length of bad state + p_reemploy =1.0/unemp_length + p_unemploy_good = p_reemploy*urate_good/(1-urate_good) + p_unemploy_bad = p_reemploy*urate_bad/(1-urate_bad) + boom_prob = 1.0/recession_length + MrkvArray = np.array([[(1-p_unemploy_good)*(1-bust_prob),p_unemploy_good*(1-bust_prob), + (1-p_unemploy_good)*bust_prob,p_unemploy_good*bust_prob], + [p_reemploy*(1-bust_prob),(1-p_reemploy)*(1-bust_prob), + p_reemploy*bust_prob,(1-p_reemploy)*bust_prob], + [(1-p_unemploy_bad)*boom_prob,p_unemploy_bad*boom_prob, + (1-p_unemploy_bad)*(1-boom_prob),p_unemploy_bad*(1-boom_prob)], + [p_reemploy*boom_prob,(1-p_reemploy)*boom_prob, + p_reemploy*(1-boom_prob),(1-p_reemploy)*(1-boom_prob)]]) + + # Make a consumer with serially correlated unemployment, subject to boom and bust cycles + init_serial_unemployment = copy(Params.init_idiosyncratic_shocks) + init_serial_unemployment['MrkvArray'] = [MrkvArray] + init_serial_unemployment['UnempPrb'] = 0 # to make income distribution when employed + init_serial_unemployment['global_markov'] = False + SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment) + except: + self.fail("MarkovConsumerType failed to initialize with boom/bust unemployment.") diff --git a/HARK/tests/test_modelcomparisons.py b/HARK/tests/test_modelcomparisons.py new file mode 100644 index 000000000..d8b3f6ee7 --- /dev/null +++ b/HARK/tests/test_modelcomparisons.py @@ -0,0 +1,151 @@ +""" +This file implements unit tests for several of the ConsumptionSaving models in HARK. +These tests compare the output of different models in specific cases in which those models +should yield the same output. The code will pass these tests if and only if the output is close +"enough". +""" + +# Bring in modules we need +import unittest +from copy import deepcopy +import numpy as np + +# Bring in the HARK models we want to test +from HARK.ConsumptionSaving.ConsIndShockModel import solvePerfForesight, IndShockConsumerType +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType +from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType + + +class Compare_PerfectForesight_and_Infinite(unittest.TestCase): + """ + Class to compare output of the perfect foresight and infinite horizon models. + When income uncertainty is removed from the infinite horizon model, it reduces in theory to + the perfect foresight model. This class implements tests to make sure it reduces in practice + to the perfect foresight model as well. + """ + + def setUp(self): + """ + Prepare to compare the models by initializing and solving them + """ + # Set up and solve infinite type + import HARK.ConsumptionSaving.ConsumerParameters as Params + + InfiniteType = IndShockConsumerType(**Params.init_idiosyncratic_shocks) + InfiniteType.assignParameters(LivPrb=[1.], + DiscFac=0.955, + PermGroFac=[1.], + PermShkStd=[0.], + TempShkStd=[0.], + T_total=1, T_retire=0, BoroCnstArt=None, UnempPrb=0., + cycles=0 + ) # This is what makes the type infinite horizon + + InfiniteType.updateIncomeProcess() + InfiniteType.solve() + InfiniteType.timeFwd() + InfiniteType.unpackcFunc() + + # Make and solve a perfect foresight consumer type with the same parameters + PerfectForesightType = deepcopy(InfiniteType) + PerfectForesightType.solveOnePeriod = solvePerfForesight + + PerfectForesightType.solve() + PerfectForesightType.unpackcFunc() + PerfectForesightType.timeFwd() + + self.InfiniteType = InfiniteType + self.PerfectForesightType = PerfectForesightType + + def test_consumption(self): + """" + Now compare the consumption functions and make sure they are "close" + """ + def diffFunc(m): return self.PerfectForesightType.solution[0].cFunc(m) - \ + self.InfiniteType.cFunc[0](m) + points = np.arange(0.5, 10., .01) + difference = diffFunc(points) + max_difference = np.max(np.abs(difference)) + + self.assertLess(max_difference, 0.01) + + +class Compare_TBS_and_Markov(unittest.TestCase): + """ + Class to compare output of the Tractable Buffer Stock and Markov models. + The only uncertainty in the TBS model is over when the agent will enter an absorbing state + with 0 income. With the right transition arrays and income processes, this is just a special + case of the Markov model. So with the right inputs, we should be able to solve the two + different models and get the same outputs. + """ + def setUp(self): + # Set up and solve TBS + base_primitives = {'UnempPrb': .015, + 'DiscFac': 0.9, + 'Rfree': 1.1, + 'PermGroFac': 1.05, + 'CRRA': .95} + TBSType = TractableConsumerType(**base_primitives) + TBSType.solve() + + # Set up and solve Markov + MrkvArray = [np.array([[1.0-base_primitives['UnempPrb'], base_primitives['UnempPrb']],[0.0, 1.0]])] + Markov_primitives = {"CRRA": base_primitives['CRRA'], + "Rfree": np.array(2*[base_primitives['Rfree']]), + "PermGroFac": [np.array(2*[base_primitives['PermGroFac'] / + (1.0-base_primitives['UnempPrb'])])], + "BoroCnstArt": None, + "PermShkStd": [0.0], + "PermShkCount": 1, + "TranShkStd": [0.0], + "TranShkCount": 1, + "T_total": 1, + "UnempPrb": 0.0, + "UnempPrbRet": 0.0, + "T_retire": 0, + "IncUnemp": 0.0, + "IncUnempRet": 0.0, + "aXtraMin": 0.001, + "aXtraMax": TBSType.mUpperBnd, + "aXtraCount": 48, + "aXtraExtra": [None], + "aXtraNestFac": 3, + "LivPrb":[np.array([1.0,1.0]),], + "DiscFac": base_primitives['DiscFac'], + 'Nagents': 1, + 'psi_seed': 0, + 'xi_seed': 0, + 'unemp_seed': 0, + 'tax_rate': 0.0, + 'vFuncBool': False, + 'CubicBool': True, + 'MrkvArray': MrkvArray, + 'T_cycle':1 + } + + MarkovType = MarkovConsumerType(**Markov_primitives) + MarkovType.cycles = 0 + employed_income_dist = [np.ones(1), np.ones(1), np.ones(1)] + unemployed_income_dist = [np.ones(1), np.ones(1), np.zeros(1)] + MarkovType.IncomeDstn = [[employed_income_dist, unemployed_income_dist]] + + MarkovType.solve() + MarkovType.unpackcFunc() + + self.TBSType = TBSType + self.MarkovType = MarkovType + + def test_consumption(self): + # Now compare the consumption functions and make sure they are "close" + + def diffFunc(m): return self.TBSType.solution[0].cFunc(m) - self.MarkovType.cFunc[0][0](m) + points = np.arange(0.1, 10., .01) + difference = diffFunc(points) + max_difference = np.max(np.abs(difference)) + + self.assertLess(max_difference, 0.01) + + +if __name__ == '__main__': + # Run all the tests + unittest.main() diff --git a/HARK/tests/test_validators.py b/HARK/tests/test_validators.py new file mode 100644 index 000000000..375cd0740 --- /dev/null +++ b/HARK/tests/test_validators.py @@ -0,0 +1,38 @@ +import unittest + +from HARK.validators import non_empty + +class ValidatorsTests(unittest.TestCase): + ''' + Tests for validator decorators which validate function arguments + ''' + + def test_non_empty(self): + @non_empty('list_a') + def foo(list_a, list_b): + pass + + try: + foo([1], []) + except Exception: + self.fail() + with self.assertRaisesRegexp( + TypeError, + 'Expected non-empty argument for parameter list_a', + ): + foo([], [1]) + + @non_empty('list_a', 'list_b') + def foo(list_a, list_b): + pass + + with self.assertRaisesRegexp( + TypeError, + 'Expected non-empty argument for parameter list_b', + ): + foo([1], []) + with self.assertRaisesRegexp( + TypeError, + 'Expected non-empty argument for parameter list_a', + ): + foo([], [1]) diff --git a/HARK/utilities.py b/HARK/utilities.py index 83f8371b1..81553a252 100644 --- a/HARK/utilities.py +++ b/HARK/utilities.py @@ -12,6 +12,7 @@ import functools import warnings import numpy as np # Python's numeric library, abbreviated "np" +import math try: import matplotlib.pyplot as plt # Python's plotting library except ImportError: @@ -551,6 +552,32 @@ def approxMeanOneLognormal(N, sigma=1.0, **kwargs): pmf,X = approxLognormal(N=N, mu=mu_adj, sigma=sigma, **kwargs) return [pmf,X] +def approxNormal(N, mu=0.0, sigma=1.0): + x, w = np.polynomial.hermite.hermgauss(N) + # normalize w + pmf = w*np.pi**-0.5 + # correct x + X = math.sqrt(2.0)*sigma*x + mu + return [pmf, X] + +def approxLognormalGaussHermite(N, mu=0.0, sigma=1.0): + pmf, X = approxNormal(N, mu, sigma) + return pmf, np.exp(X) + +def calcNormalStyleParsFromLognormalPars(avgLognormal, stdLognormal): + varLognormal = stdLognormal**2 + avgNormal = math.log(avgLognormal/math.sqrt(1+varLognormal/avgLognormal**2)) + varNormal = math.sqrt(math.log(1+varLognormal/avgLognormal**2)) + stdNormal = math.sqrt(varNormal) + return avgNormal, stdNormal + +def calcLognormalStyleParsFromNormalPars(muNormal, stdNormal): + varNormal = stdNormal**2 + avgLognormal = math.exp(muNormal+varNormal*0.5) + varLognormal = (math.exp(varNormal)-1)*math.exp(2*muNormal+varNormal) + stdLognormal = math.sqrt(varLognormal) + return avgLognormal, stdLognormal + def approxBeta(N,a=1.0,b=1.0): ''' Calculate a discrete approximation to the beta distribution. May be quite diff --git a/HARK/validators.py b/HARK/validators.py new file mode 100644 index 000000000..fd467c6fd --- /dev/null +++ b/HARK/validators.py @@ -0,0 +1,35 @@ +''' +Decorators which can be used for validating arguments passed into decorated functions +''' + +from __future__ import print_function + +import sys +from functools import wraps + +if sys.version_info[0] < 3: + from funcsigs import signature +else: + from inspect import signature + + +def non_empty(*parameter_names): + ''' + Enforces arguments to parameters passed in have len > 0 + ''' + + def _decorator(f): + sig = signature(f) + # TODO - add validation that parameter names are in signature + + @wraps(f) + def _inner(*args, **kwargs): + bindings = sig.bind(*args, **kwargs) + for parameter_name in parameter_names: + if not len(bindings.arguments[parameter_name]): + raise TypeError( + 'Expected non-empty argument for parameter {}'.format(parameter_name) + ) + return f(*args, **kwargs) + return _inner + return _decorator diff --git a/MANIFEST.in b/MANIFEST.in index 8dd76ae48..492b95d00 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,4 +1,4 @@ -# Include the README +# Include the README, CHANGES, and CONTRIBUTING files include *.md # Include the license file diff --git a/README.md b/README.md index 1bdeb099c..86667d5eb 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ # Heterogeneous Agents Resources and toolKit (HARK) -pre-release 0.9.1 - 13 July, 2018 +pre-release 0.10.1 Click the Badge for Citation Info. [![DOI](https://zenodo.org/badge/50448254.svg)](https://zenodo.org/badge/latestdoi/50448254) @@ -7,151 +7,217 @@ Click the Badge for Citation Info. Table of Contents: -* [I. Introduction](#i-introduction) -* [II. Quick start guide](#ii-quick-start-guide) -* [III. List of files in repository](#iii-list-of-files-in-repository) -* [IV. Warnings and disclaimers](#iv-warnings-and-disclaimers) -* [V. License Information](#v-license) +* [1. Introduction](#i-introduction) +* [2. Quick start guide](#ii-quick-start-guide) + * [Installing](#Installing-HARK) + * [Learning HARK](#Learning-HARK) +* [3. List of files in repository](#iii-list-of-files-in-repository) +* [4. Warnings and disclaimers](#iv-warnings-and-disclaimers) +* [5. License Information](#v-license) ## I. INTRODUCTION -Welcome to HARK! We are tremendously excited you're here. HARK is -very much a work in progress, but we hope you find it valuable. We -*really* hope you find it so valuable that you decide to contribute -to it yourself. This document will tell you how to get HARK up and -running on your machine, and what you will find in HARK once you do. +Welcome to HARK! This document will tell you how to get HARK up and +running on your machine, how to get started using it, and give you an +overview of the main elements of the toolkit. -If you have any comments on the code or documentation, we'd love to -hear from you! Our email addresses are: +If you have any comments on the code or documentation, or (even better) if you want to +contribute new content to HARK, we'd love to hear from you! +Our email addresses are: * Chris Carroll: ccarroll@llorracc.org * Matthew White: mnwhite@gmail.com -* Nathan Palmer: Nathan.Palmer@ofr.treasury.gov -* David Low: David.Low@cfpb.gov -* Alexander Kaufman: akaufman10@gmail.com GitHub repository: https://github.com/econ-ark/HARK Online documentation: https://econ-ark.github.io/HARK -User guide: /Documentation/HARKmanual.pdf (in the repository) +User guide: [Documentation/HARKmanual.pdf](Documentation/HARKmanual.pdf) (in the [HARK repository](https://github.com/econ-ark/HARK)) + +Demonstrations of HARK functionality: [DemARK](https://github.com/econ-ark/DemARK/) + +Replications and Explorations Made using the ARK : [REMARK](https://github.com/econ-ark/REMARK/) ## II. QUICK START GUIDE -This is going to be easy, friend. HARK is written in Python, specifically the -Anaconda distribution of Python. Follow these easy steps to get HARK going: - -1) Go to https://www.continuum.io/downloads and download Anaconda for your -operating system - -2) Install Anaconda, using the instructions provided on that page. Now you have -installed everything you need to run most of HARK. But you still need to get HARK -on your machine. - -3) To get HARK on your machine, you should know that HARK is managed with version -control software called "Git". HARK is hosted on a website called "GitHub" devoted -to hosting projects managed with Git. - - If you don't want to know more than that, you don't have to. Go to HARK's page -on GitHub (https://github.com/econ-ark/HARK), click the "Clone or download" button -in the upper right hand corner of the page, then click "Download ZIP". Unzip it -into an empty directory. Maybe call that directory /HARK ? The choice is yours. - - You can also clone HARK off GitHub using Git. This is slightly more difficult, -because it involves installing Git on your machine and learning a little about -how to use Git. We believe this is an investment worth making, but it is up to you. -To learn more about Git, read the documentation at https://git-scm.com/documentation -or visit many other great Git resources on the internet. - -4) Open Spyder, an interactive development environment (IDE) for Python -(specifically, iPython). On Windows, open a command prompt and type "spyder". -On Linux, open the command line and type "spyder". On Mac, open the command -line and type "spyder". - -5) Navigate to the directory where you put the HARK files. This can be done -within Spyder by doing "import os" and then using os.chdir() to change directories. -chdir works just like cd at a command prompt on most operating systems, except that -it takes a string as input: os.chdir('Music') moves to the Music subdirectory -of the current working directory. - -6) Run one of HARK's modules. You can either type "run MODULENAME" after navigating -to the correct directory (see step 5), or click the green arrow "run" button in -Spyder's toolbar after opening the module in the editor. Every module should -do *something* when run, but that something might not be very interesting in -some cases. For starters, check out /ConsumptionSavingModel/ConsIndShockModel.py -See section III below for a full list of modules that produce non-trivial output. - -7) The Python environment can be cleared or reset with ctrl+. Note that -this will also change the current working directory back to its default. -To change the default directory (the "global working directory"), see -Tools-->Preferences-->Global working directory; you might need to restart -Spyder for the change to take effect. - -8) Read the more complete documentation in [HARKmanual.pdf](https://github.com/econ-ark/HARK/blob/master/Documentation/HARKmanual.pdf). - -9) OPTIONAL: If you want to use HARK's multithreading capabilities, you will -need two Python packages that do not come automatically with Anaconda: joblib -and dill. Assuming you have the necessary permissions on your machine, the -easiest way to do this is through Anaconda. Go to the command line, and type -"conda install joblib" and then "conda install dill" (accept defaults if prompted). -If this doesn't work, but you have Git, you can just clone the packages directly -off GitHub. Go to the command line and navigate to the directory you want to put -these packages in. Then type "git clone https://github.com/joblib/joblib.git" -and then "git clone https://github.com/uqfoundation/dill". Joblib should work -after this, but there is one more step to get dill working. Navigate to dill's -directory in the command line, and then type "python setup.py build". Then you -should have joblib and dill working on your machine. - -Note: If you did not put joblib and dill in one of the paths in sys.path, you will -need to add the joblib and dill directories to sys.path. The easiest way to do this -is to open up Anaconda, and type: - -```python -import sys -sys.path.append('path_to_joblib_directory') -sys.path.append('path_to_dill_directory') +### Installing HARK +HARK is an open source project written in Python. It's compatible with both Python +2 and 3, and with the Anaconda distributions of python 2 and 3. But we recommend +using python 3; eventually support for python 2 will end. + +#### Installing HARK with pip + +The simplest way to install HARK is to use [pip](https://pip.pypa.io/en/stable/installing/). + +To install HARK with pip, at a command line type `pip install econ-ark`. + +If you are installing via pip, we recommend using a virtual environment such as [virtualenv](https://virtualenv.pypa.io/en/latest/). Creation of a virtual environment isolates the installation of `econ-ark` from the installations of any other python tools and packages. + +To install `virtualenv`, then to create an environment named `econ-ark`, and finally to activate that environment: + +``` +cd [directory where you want to store the econ-ark virtual environment] +pip install virtualenv +virtualenv econ-ark +source activate econ-ark +``` + +---- +#### Using HARK with Anaconda + +Installing HARK with pip does not give you full access to HARK's many graphical capabilities. One way to access these capabilities is by using [Anaconda](https://anaconda.com/why-anaconda), which is a distribution of python along with many packages that are frequently used in scientific computing.. + +1. Download Anaconda for your operating system and follow the installation instructions [at Anaconda.com](https://www.anaconda.com/distribution/#download-section). + +1. Anaconda includes its own virtual environment system called `conda` which stores environments in a preset location (so you don't have to choose). So in order to create and activate an econ-ark virtual environment: +``` +conda create -n econ-ark anaconda +conda activate econ-ark +``` +1. Open Spyder, an interactive development environment (IDE) for Python (specifically, iPython). You may be able to do this through Anaconda's graphical interface, or you can do so from the command line/prompt. To do so, simply open a command line/prompt and type `spyder`. + +1. To verify that spyder has access to HARK try typing `pip install econ-ark` into the iPython shell within Spyder. If you have successfully installed HARK as above, you should see a lot of messages saying 'Requirement satisfied'. + + * If that doesn't work, you will need to manually add HARK to your Spyder environment. To do this, you'll need to get the code from Github and import it into Spyder. To get the code from Github, you can either clone it or download a zipped file. + + * If you have `git` installed on the command line, type `git clone git@github.com:econ-ark/HARK.git` in your chosen directory ([more details here](https://git-scm.com/documentation)). + + * If you do not have `git` available on your computer, you can download the [GitHub Desktop app](https://desktop.github.com/) and use it to make a local clone + + * If you don't want to clone HARK, but just to download it, go to [the HARK repository on GitHub](https://github.com/econ-ark/HARK). In the upper righthand corner is a button that says "clone or download". Click the "Download Zip" option and then unzip the contents into your chosen directory. + + Once you've got a copy of HARK in a directory, return to Spyder and navigate to that directory where you put HARK. This can be done within Spyder by doing `import os` and then using `os.chdir()` to change directories. `chdir` works just like cd at a command prompt on most operating systems, except that it takes a string as input: `os.chdir('Music')` moves to the Music subdirectory of the current working directory. + +6) Most of the modules in HARK are just collections of tools. There are a few demonstration +applications that use the tools that you automatically get when you install HARK -- they are listed below in [Application Modules](#application-modules). A much larger set of uses of HARK can be found at two repositories: + * [DemARK](https://github.com/econ-ark/DemARK): Demonstrations of the use of HARK + * [REMARK](https://github.com/econ-ark/REMARK): Replications of existing papers made using HARK + +You will want to obtain your own local copy of these repos using: +``` +git clone https://github.com/econ-ark/DemARK.git +``` +and similarly for the REMARK repo. Once you have downloaded them, you will find that each repo contains a `notebooks` directory that contains a number of [jupyter notebooks](https://jupyter.org/). If you have the jupyter notebook tool installed (it is installed as part of Anaconda), you should be able to launch the +jupyter notebook app from the command line with the command: + +``` +jupyter notebook +``` +and from there you can open the notebooks and execute them. + +#### Learning HARK + +We have a set of 30-second [Elevator Spiels](https://github.com/econ-ark/PARK/blob/master/Elevator-Spiels.md#capsule-summaries-of-what-the-econ-ark-project-is) describing the project, tailored to people with several different kinds of background. + +The most broadly applicable advice is to go to [Econ-ARK](https://econ-ark.org) and click on "Notebooks", and choose [A Gentle Introduction to HARK](https://github.com/econ-ark/DemARK/blob/master/notebooks/Gentle-Intro-To-HARK.ipynb) which will launch as a [jupyter notebook](https://jupyter.org/). + +##### [For people with a technical/scientific/computing background but little economics background](https://github.com/econ-ark/PARK/blob/master/Elevator-Spiels.md#for-people-with-a-technicalscientificcomputing-background-but-no-economics-background) + +* [A Gentle Introduction to HARK](https://github.com/econ-ark/DemARK/blob/master/notebooks/Gentle-Intro-To-HARK.ipynb) + +##### [For economists who have done some structural modeling](https://github.com/econ-ark/PARK/blob/master/Elevator-Spiels.md#for-economists-who-have-done-some-structural-modeling) + +* A full replication of the [Iskhakov, Jørgensen, Rust, and Schjerning](https://onlinelibrary.wiley.com/doi/abs/10.3982/QE643) paper for solving the discrete-continuous retirement saving problem + * An informal discussion of the issues involved is [here](https://github.com/econ-ark/DemARK/blob/master/notebooks/DCEGM-Upper-Envelope.ipynb) (part of the [DemARK](https://github.com/econ-ark/DemARK) repo) + +* [Structural-Estimates-From-Empirical-MPCs](https://github.com/econ-ark/DemARK/blob/master/notebooks/Structural-Estimates-From-Empirical-MPCs-Fagereng-et-al.ipynb) is an example of the use of the toolkit in a discussion of a well known paper. (Yes, it is easy enough to use that you can estimate a structural model on somebody else's data in the limited time available for writing a discussion) + +##### [For economists who have not yet done any structural modeling but might be persuadable to start](https://github.com/econ-ark/PARK/blob/master/Elevator-Spiels.md#for-economists-who-have-not-yet-done-any-structural-modeling-but-might-be-persuadable-to-start) + +* Start with [A Gentle Introduction to HARK](https://github.com/econ-ark/DemARK/blob/master/notebooks/Gentle-Intro-To-HARK.ipynb) to get your feet wet + +* A simple indirect inference/simulated method of moments structural estimation along the lines of Gourinchas and Parker's 2002 Econometrica paper or Cagetti's 2003 paper is performed by the [SolvingMicroDSOPs](https://github.com/econ-ark/REMARK/tree/master/REMARKs/SolvingMicroDSOPs) [REMARK](https://github.com/econ-ark/REMARK); this code implements the solution methods described in the corresponding section of [these lecture notes](http://www.econ2.jhu.edu/people/ccarroll/SolvingMicroDSOPs/) + +##### [For Other Developers of Software for Computational Economics](https://github.com/econ-ark/PARK/blob/master/Elevator-Spiels.md#for-other-developers-of-software-for-computational-economics) + + +* Our workhorse module is [ConsIndShockModel.py](https://github.com/econ-ark/HARK/blob/master/HARK/ConsumptionSaving/ConsIndShockModel.py) + * which is explored and explained (a bit) in [this jupyter notebook](https://github.com/econ-ark/DemARK/blob/master/notebooks/ConsIndShockModel.ipynb) + +### Making changes to HARK + +If you want to make changes or contributions (yay!) to HARK, you'll need to have access to the source files. Installing HARK via pip (either at the command line, or inside Spyder) makes it hard to access those files (and it's a bad idea to mess with the original code anyway because you'll likely forget what changes you made). If you are adept at GitHub, you can [fork](https://help.github.com/en/articles/fork-a-repo) the repo. If you are less experienced, you should download a personal copy of HARK again using `git clone` (see above) or the GitHub Desktop app. + +1. Navigate to wherever you want to put the repository and type `git clone git@github.com:econ-ark/HARK.git` ([more details here](https://git-scm.com/documentation)). If you get a permission denied error, you may need to setup SSH for GitHub, or you can clone using HTTPS: 'git clone https://github.com/econ-ark/HARK.git'. + +2. Then, create and activate a [virtual environment]([virtualenv]((https://virtualenv.pypa.io/en/latest/))). + +For Mac or Linux: + +Install virtualenv if you need to and then type: + +``` +virtualenv econ-ark +source econ-ark/bin/activate +``` +For Windows: ``` +virtualenv econ-ark +econ-ark\\Scripts\\activate.bat +``` + +3. Once the virtualenv is activated, you may see `(econ-ark)` in your command prompt (depending on how your machine is configured) + +3. Make sure to change to HARK directory, and install HARK's requirements into the virtual environment with `pip install -r requirements.txt`. + +4. To check that everything has been set up correctly, run HARK's tests with `python -m unittest`. + +### Trouble with installation? + +We've done our best to give correct, thorough instructions on how to install HARK but we know this information may be inaccurate or incomplete. Please let us know if you run into trouble so we can update this guide! Here's a list of platforms and versions this guide has been verified for: + +| Installation Type | Platform | Python Version | Date Tested | Tested By | +| ------------- |:-------------:| -----:| -----:|-----:| +| basic pip install | Linux (16.04) | 3 | 2019-04-24 | @shaunagm | +| anaconda | Linux (16.04) | 3 | 2019-04-24 | @shaunagm | +| basic pip install | MacOS 10.13.2 "High Sierra" | 2.7| 2019-04-26 | @llorracc | + +### Next steps + +To learn more about how to use HARK, check out our [user manual](Documentation/HARKmanual.pdf). + +For help making changes to HARK, check out our [contributing guide](CONTRIBUTING.md). + ## III. LIST OF FILES IN REPOSITORY -This section contains descriptions of every file included in the HARK -repository at the time of the beta release, categorized for convenience. +This section contains descriptions of the main files in the repo. Documentation files: -* [README.md](https://github.com/econ-ark/HARK/blob/master/README.md): The file you are currently reading. -* [Documentation/HARKdoc.pdf](https://github.com/econ-ark/HARK/blob/master/Documentation/HARKdoc.pdf): A mini-user guide produced for a December 2015 workshop on HARK, unofficially representing the alpha version. Somewhat out of date. -* [Documentation/HARKmanual.pdf](https://github.com/econ-ark/HARK/blob/master/Documentation/HARKmanual.pdf): A user guide for HARK, written for the beta release at CEF 2016 in Bordeaux. Should contain 90% fewer lies relative to HARKdoc.pdf. - * [Documentation/HARKmanual.tex](https://github.com/econ-ark/HARK/blob/master/Documentation/HARKmanual.tex): LaTeX source for the user guide. Open source code probably requires an open source manual as well. -* [Documentation/ConsumptionSavingModels.pdf](https://github.com/econ-ark/HARK/blob/master/Documentation/ConsumptionSavingModels.pdf): Mathematical descriptions of the various consumption-saving models in HARK and how they map into the code. - * [Documentation/ConsumptionSavingModels.tex](https://github.com/econ-ark/HARK/blob/master/Documentation/ConsumptionSavingModels.tex): LaTeX source for the "models" writeup. -* [Documentation/NARK.pdf](https://github.com/econ-ark/HARK/blob/master/Documentation/NARK.pdf): Variable naming conventions for HARK, plus concordance with LaTeX variable definitions. Still in development. +* [README.md](README.md): The file you are currently reading. +* [Documentation/HARKdoc.pdf](Documentation/HARKdoc.pdf): A mini-user guide produced for a December 2015 workshop on HARK, unofficially representing the alpha version. (Substantially out of date). +* [Documentation/HARKmanual.pdf](Documentation/HARKmanual.pdf): A user guide for HARK, written for the beta release at CEF 2016 in Bordeaux. Should contain 90% fewer lies relative to HARKdoc.pdf. + * [Documentation/HARKmanual.tex](Documentation/HARKmanual.tex): LaTeX source for the user guide. Open source code probably requires an open source manual as well. +* [Documentation/ConsumptionSavingModels.pdf](Documentation/ConsumptionSavingModels.pdf): Mathematical descriptions of the various consumption-saving models in HARK and how they map into the code. + * [Documentation/ConsumptionSavingModels.tex](Documentation/ConsumptionSavingModels.tex): LaTeX source for the "models" writeup. +* [Documentation/NARK.pdf](Documentation/NARK.pdf): Variable naming conventions for HARK, plus concordance with LaTeX variable definitions. Still in development. Tool modules: -* HARKcore.py: +* [HARK/core.py](HARK/core.py): Frameworks for "microeconomic" and "macroeconomic" models in HARK. We somewhat abuse those terms as shorthand; see the user guide for a description of what we mean. Every model in HARK extends the classes AgentType and Market in this module. Does nothing when run. -* HARKutilities.py: +* [HARK/utilities.py](HARK/utilities.py): General purpose tools and utilities. Contains literal utility functions (in the economic sense), functions for making discrete approximations to continuous distributions, basic plotting functions for convenience, and a few unclassifiable things. Does nothing when run. -* HARKestimation.py: +* [HARK/estimation.py](HARK/estimation.py): Functions for estimating models. As is, it only has a few wrapper functions for scipy.optimize optimization routines. Will be expanded in the future with more interesting things. Does nothing when run. -* HARKsimulation.py: +* [HARK/simulation.py](HARK/simulation.py): Functions for generating simulated data. Functions in this module have names like drawUniform, generating (lists of) arrays of draws from various distributions. Does nothing when run. -* HARKinterpolation.py: +* [HARK/interpolation.py](HARK/interpolation.py): Classes for representing interpolated function approximations. Has 1D-4D interpolation methods, mostly based on linear or cubic spline interpolation. Will have ND methods in the future. Does nothing when run. -* HARKparallel.py: +* [HARK/parallel.py](HARK/parallel.py): Early version of parallel processing in HARK. Works with instances of the AgentType class (or subclasses of it), distributing commands (as methods) to be run on a list of AgentTypes. Only works with local CPU. @@ -160,31 +226,31 @@ Tool modules: when run. Model modules: -* ConsumptionSavingModel/TractableBufferStockModel.py: - A "tractable" model of consumption and saving in which agents face one +* [ConsumptionSaving/TractableBufferStockModel.py](HARK/ConsumptionSaving/TractableBufferStockModel.py): + * A "tractable" model of consumption and saving in which agents face one simple risk with constant probability: that they will become permanently unemployed and receive no further income. Unlike other models in HARK, this one is not solved by iterating on a sequence of one period problems. Instead, it uses a "backshooting" routine that has been shoehorned into the AgentType.solve framework. Solves an example of the model when run, then solves the same model again using MarkovConsumerType. -* ConsumptionSavingModel/ConsIndShockModel.py: - Consumption-saving models with idiosyncratic shocks to income. Shocks +* [ConsumptionSaving/ConsIndShockModel.py](HARK/ConsumptionSaving/ConsIndShockModel.py): + * Consumption-saving models with idiosyncratic shocks to income. Shocks are fully transitory or fully permanent. Solves perfect foresight model, a model with idiosyncratic income shocks, and a model with idiosyncratic income shocks and a different interest rate on borrowing vs saving. When run, solves several examples of these models, including a standard infinite horizon problem, a ten period lifecycle model, a four period "cyclical" model, and versions with perfect foresight and "kinked R". -* ConsumptionSavingModel/ConsPrefShockModel.py: - Consumption-saving models with idiosyncratic shocks to income and multi- +* [ConsumptionSaving/ConsPrefShockModel.py](HARK/ConsumptionSaving/ConsPrefShockModel.py): + * Consumption-saving models with idiosyncratic shocks to income and multi- plicative shocks to utility. Currently has two models: one that extends the idiosyncratic shocks model, and another that extends the "kinked R" model. The second model has very little new code, and is created merely by merging the two "parent models" via multiple inheritance. When run, solves examples of the preference shock models. -* ConsumptionSavingModel/ConsMarkovModel.py: - Consumption-saving models with a discrete state that evolves according to +* [ConsumptionSaving/ConsMarkovModel.py](HARK/ConsumptionSaving/ConsMarkovModel.py): + * Consumption-saving models with a discrete state that evolves according to a Markov rule. Discrete states can vary by their income distribution, interest factor, and/or expected permanent income growth rate. When run, solves four example models: (1) A serially correlated unemployment model @@ -193,16 +259,16 @@ Model modules: shocks for the next N periods. (3) A model with a time-varying permanent income growth rate that is serially correlated. (4) A model with a time- varying interest factor that is serially correlated. -* ConsumptionSavingModel/ConsAggShockModel.py: - Consumption-saving models with idiosyncratic and aggregate income shocks. +* [ConsumptionSaving/ConsAggShockModel.py](HARK/ConsumptionSaving/ConsAggShockModel.py): + * Consumption-saving models with idiosyncratic and aggregate income shocks. Currently has a micro model with a basic solver (linear spline consumption function only, no value function), and a Cobb-Douglas economy for the agents to "live" in (as a "macroeconomy"). When run, solves an example of the micro model in partial equilibrium, then solves the general equilibrium problem to find an evolution rule for the capital-to-labor ratio that is justified by consumers' collective actions. -* FashionVictim/FashionVictimModel.py: - A very serious model about choosing to dress as a jock or a punk. Used to +* [FashionVictim/FashionVictimModel.py](HARK/FashionVictim/FashionVictimModel.py): + * A very serious model about choosing to dress as a jock or a punk. Used to demonstrate micro and macro framework concepts from HARKcore. It might be the simplest model possible for this purpose, or close to it. When run, the module solves the microeconomic problem of a "fashion victim" for an @@ -211,9 +277,10 @@ Model modules: for the evolution of the style distribution in the population that is justi- fied by fashion victims' collective actions. -Application modules: -* SolvingMicroDSOPs/StructEstimation.py: - Conducts a very simple structural estimation using the idiosyncratic shocks +Application modules: + +* [SolvingMicroDSOPs/Code/StructEstimation.py](HARK/SolvingMicroDSOPs/Code/StructEstimation.py): + * Conducts a very simple structural estimation using the idiosyncratic shocks model in ConsIndShocksModel. Estimates an adjustment factor to an age-varying sequence of discount factors (taken from Cagetti (2003)) and a coefficient of relative risk aversion that makes simulated agents' wealth profiles best @@ -221,51 +288,49 @@ Application modules: the calculation of standard errors by bootstrap and can construct a contour map of the objective function. Based on section 9 of Chris Carroll's lecture notes "Solving Microeconomic Dynamic Stochastic Optimization Problems". -* cstwMPC/cstwMPC.py: - Conducts the estimations for the paper "The Distribution of Wealth and the +* [cstwMPC/cstwMPC.py](HARK/cstwMPC/cstwMPC.py): + * Conducts the estimations for the paper "The Distribution of Wealth and the Marginal Propensity to Consume" by Carroll, Slacalek, Tokuoka, and White (2016). Runtime options are set in SetupParamsCSTW.py, specifying choices such as: perpetual youth vs lifecycle, beta-dist vs beta-point, liquid assets vs net worth, aggregate vs idiosyncratic shocks, etc. Uses ConsIndShockModel and ConsAggShockModel; can demonststrate HARK's "macro" framework on a real model. -* cstwMPC/MakeCSTWfigs.py: - Makes various figures for the text of the cstwMPC paper. Requires many output +* [cstwMPC/MakeCSTWfigs.py](HARK/cstwMPC/MakeCSTWfigs.py): + * Makes various figures for the text of the [cstwMPC](http://econ.jhu.edu/people/ccarroll/papers/cstwMPC) paper. Requires many output files produced by cstwMPC.py, from various specifications, which are not distributed with HARK. Has not been tested in quite some time. -* cstwMPC/MakeCSTWfigsForSlides.py: - Makes various figures for the slides for the cstwMPC paper. Requires many +* [cstwMPC/MakeCSTWfigsForSlides.py](HARK/cstwMPC/MakeCSTWfigsForSlides.py): + * Makes various figures for the slides for the cstwMPC paper. Requires many output files produced by cstwMPC.py, from various specifications, which are not distributed with HARK. Has not been tested in quite some time. Parameter and data modules: -* ConsumptionSaving/ConsumerParameters.py: - Defines dictionaries with the minimal set of parameters needed to solve the +* [ConsumptionSaving/ConsumerParameters.py](HARK/ConsumptionSaving/ConsumerParameters.py): + * Defines dictionaries with the minimal set of parameters needed to solve the models in ConsIndShockModel, ConsAggShockModel, ConsPrefShockModel, and ConsMarkovModel. These dictionaries are used to make examples when those modules are run. Does nothing when run itself. -* SolvingMicroDSOPs/SetupSCFdata.py: - Imports 2004 SCF data for use by SolvingMicroDSOPs/StructEstimation.py. -* cstwMPC/SetupParamsCSTW.py: - Loads calibrated model parameters for cstwMPC.py, chooses specification. -* FashionVictim/FashionVictimParams.py: - Example parameters for FashionVictimModel.py, loaded when that module is run. +* [SolvingMicroDSOPs/SetupSCFdata.py](HARK/SolvingMicroDSOPs/Calibration/SetupSCFdata.py): + * Imports 2004 SCF data for use by SolvingMicroDSOPs/StructEstimation.py. +* [cstwMPC/SetupParamsCSTW.py](HARK/cstwMPC/SetupParamsCSTW.py): + * Loads calibrated model parameters for cstwMPC.py, chooses specification. +* [FashionVictim/FashionVictimParams.py](HARK/FashionVictim/FashionVictimParams.py): + * Example parameters for FashionVictimModel.py, loaded when that module is run. Test modules: -* Testing/ComparisonTests.py: - Early version of unit testing for HARK, still in development. Compares +* [Testing/Comparison_UnitTests.py](Testing/Comparison_UnitTests.py): + * Early version of unit testing for HARK, still in development. Compares the perfect foresight model solution to the idiosyncratic shocks model solution with shocks turned off; also compares the tractable buffer stock model solution to the same model solved using a "Markov" description. -* Testing/ModelTesting.py: - Early version of unit testing for HARK, still in development. Defines a +* [Testing/ModelTesting.py](Testing/ModelTesting.py): + * Early version of unit testing for HARK, still in development. Defines a few wrapper classes to run unit tests on subclasses of AgentType. -* Testing/ModelTestingExample.py - An example of ModelTesting.py in action, using TractableBufferStockModel. -* Testing/TBSunitTests.py: - Early version of unit testing for HARK, still in development. Runs a test +* [Testing/TractableBufferStockModel_UnitTests.py](Testing/TractableBufferStockModel_UnitTests.py) + * Early version of unit testing for HARK, still in development. Runs a test on TractableBufferStockModel. -* Testing/MultithreadDemo.py: - Demonstrates the multithreading functionality in HARKparallel.py. When +* [Testing/MultithreadDemo.py](Testing/MultithreadDemo.py): + * Demonstrates the multithreading functionality in HARKparallel.py. When run, it solves oneexample consumption-saving model with idiosyncratic shocks to income, then solves *many* such models serially, varying the coefficient of relative risk aversion between rho=1 and rho=8, displaying @@ -274,76 +339,68 @@ Test modules: the results graphically along with the timing. Data files: -* SolvingMicroDSOPs/SCFdata.csv: - SCF 2004 data for use in SolvingMicroDSOPs/StructEstimation.py, loaded by +* [SolvingMicroDSOPs/Calibration/SCFdata.csv](HARK/SolvingMicroDSOPs/Calibration/SCFdata.csv): + * SCF 2004 data for use in SolvingMicroDSOPs/StructEstimation.py, loaded by SolvingMicroDSOPs/EstimationParameters.py. -* cstwMPC/SCFwealthDataReduced.txt: - SCF 2004 data with just net worth and data weights, for use by cstwMPC.py -* cstwMPC/USactuarial.txt: - U.S. mortality data from the Social Security Administration, for use by +* [cstwMPC/SCFwealthDataReduced.txt](HARK/cstwMPC/SCFwealthDataReduced.txt): + * SCF 2004 data with just net worth and data weights, for use by cstwMPC.py +* [cstwMPC/USactuarial.txt](HARK/cstwMPC/USactuarial.txt): + * U.S. mortality data from the Social Security Administration, for use by cstwMPC.py when running a lifecycle specification. -* cstwMPC/EducMortAdj.txt: - Mortality adjusters by education and age (columns by sex and race), for use +* [cstwMPC/EducMortAdj.txt](HARK/cstwMPC/EducMortAdj.txt): + * Mortality adjusters by education and age (columns by sex and race), for use by cstwMPC.py when running a lifecycle specification. Taken from an appendix of PAPER. Other files that you don't need to worry about: -* */index.py: - A file used by Sphinx when generating html documentation for HARK. Users +* /index.py: + * A file used by Sphinx when generating html documentation for HARK. Users don't need to worry about it. Several copies are found throughout HARK. -* .gitignore: - A file that tells git which files (or types of files) might be found in +* [.gitignore](.gitignore): + * A file that tells git which files (or types of files) might be found in the repository directory tree, but should be ignored (not tracked) for the repo. Currently ignores compiled Python code, LaTex auxiliary files, etc. -* LICENSE: - License text for HARK, Apache 2.0. Read it if you're a lawyer! -* SolvingMicroDSOPs/SMMcontour.png: - Contour plot of the objective function for SolvingMicroDSOPs/StructEstimation.py. +* [LICENSE](LICENSE): + * License text for HARK, Apache 2.0. Read it if you're a lawyer! +* [SolvingMicroDSOPs/Figures/SMMcontour.png](HARK/SolvingMicroDSOPs/Figures/SMMcontour.png): + * Contour plot of the objective function for SolvingMicroDSOPs/StructEstimation.py. Generated when that module is run, along with a PDF version. -* cstwMPC/Figures/placeholder.txt: - A placeholder file because git doesn't like empty folders, but cstwMPC.py +* [cstwMPC/Figures/placeholder.txt](HARK/cstwMPC/Figures/placeholder.txt): + * A placeholder file because git doesn't like empty folders, but cstwMPC.py needs the /Figures directory to exist when it runs. -* cstwMPC/Results/placeholder.txt: - A placeholder file because git doesn't like empty folders, but cstwMPC.py - needs the /Results directory to exist when it runs. -* Documentation/conf.py: - A configuration file for producing html documentation with Sphinx, generated +* [Documentation/conf.py](Documentation/conf.py): + * A configuration file for producing html documentation with Sphinx, generated by sphinx-quickstart. -* Documentation/includeme.rst: - A very small file used by Sphinx to produce documentation. -* Documentation/index.rst: - A list of modules to be included in HARK's Sphinx documentation. This should +* [Documentation/includeme.rst](Documentation/includeme.rst): + * A very small file used by Sphinx to produce documentation. +* [Documentation/index.rst](Documentation/index.rst): + * A list of modules to be included in HARK's Sphinx documentation. This should be edited if a new tool or model module is added to HARK. -* Documentation/instructions.md: - A markdown file with instructions for how to set up and run Sphinx. You +* [Documentation/instructions.md](Documentation/instructions.md): + * A markdown file with instructions for how to set up and run Sphinx. You don't need to read it. -* Documentation/simple-steps-getting-sphinx-working.md: - Another markdown file with instructions for how to set up and run Sphinx. -* Documentation/make.bat: - A batch file for producing Sphinx documentation, generated by sphinx-quickstart. -* Documentation/Makefile: - Another Sphinx auxiliary file generated by sphinx-quickstart. -* Documentation/econtex.sty: - LaTeX style file with notation definitions. -* Documentation/econtex.cls: - LaTeX class file with document layout for the user manual. -* Documentation/econtexSetup.sty: - LaTeX style file with notation definitions. -* Documentation/econtexShortcuts.sty: - LaTeX style file with notation definitions. -* Documentation/UserGuidePic.pdf: - Image for the front cover of the user guide, showing the consumption +* [Documentation/simple-steps-getting-sphinx-working.md](Documentation/simple-steps-getting-sphinx-working.md): + * Another markdown file with instructions for how to set up and run Sphinx. +* [Documentation/make.bat](Documentation/make.bat): + * A batch file for producing Sphinx documentation, generated by sphinx-quickstart. +* [Documentation/Makefile](Documentation/Makefile): + * Another Sphinx auxiliary file generated by sphinx-quickstart. +* [Documentation/econtex.sty](Documentation/econtex.sty): + * LaTeX style file with notation definitions. +* [Documentation/econtex.cls](Documentation/econtex.cls): + * LaTeX class file with document layout for the user manual. +* [Documentation/econtexSetup.sty](Documentation/econtexSetup.sty): + * LaTeX style file with notation definitions. +* [Documentation/econtexShortcuts.sty](Documentation/econtexShortcuts.sty): + * LaTeX style file with notation definitions. +* [Documentation/UserGuidePic.pdf](Documentation/UserGuidePic.pdf): + * Image for the front cover of the user guide, showing the consumption function for the KinkyPref model. ## IV. WARNINGS AND DISCLAIMERS -This is an early beta version of HARK. The code has not been -extensively tested as it should be. We hope it is useful, but -there are absolutely no guarantees (expressed or implied) that -it works or will do what you want. Use at your own risk. And -please, let us know if you find bugs by posting an issue to the -GitHub page! +This is a beta version of HARK. The code has not been extensively tested as it should be. We hope it is useful, but there are absolutely no guarantees (expressed or implied) that it works or will do what you want. Use at your own risk. And please, let us know if you find bugs by posting an issue to [the GitHub page](https://github.com/econ-ark/HARK)! ## V. License diff --git a/Testing/Comparison_UnitTests.py b/Testing/Comparison_UnitTests.py deleted file mode 100644 index 9aa65d5f7..000000000 --- a/Testing/Comparison_UnitTests.py +++ /dev/null @@ -1,165 +0,0 @@ -""" -This file implements unit tests for several of the ConsumptionSaving models in HARK. - -These tests compare the output of different models in specific cases in which those models -should yield the same output. The code will pass these tests if and only if the output is close -"enough". -""" -from __future__ import print_function, division -from __future__ import absolute_import - -from builtins import str -from builtins import zip -from builtins import range -from builtins import object - -# Bring in modules we need -import unittest -from copy import deepcopy -import numpy as np - - -# Bring in the HARK models we want to test -from HARK.ConsumptionSaving.ConsIndShockModel import solvePerfForesight, IndShockConsumerType -from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType -from HARK.ConsumptionSaving.TractableBufferStockModel import TractableConsumerType - - -class Compare_PerfectForesight_and_Infinite(unittest.TestCase): - """ - Class to compare output of the perfect foresight and infinite horizon models. - - When income uncertainty is removed from the infinite horizon model, it reduces in theory to - the perfect foresight model. This class implements tests to make sure it reduces in practice - to the perfect foresight model as well. - """ - - def setUp(self): - """ - Prepare to compare the models by initializing and solving them - """ - # Set up and solve infinite type - import HARK.ConsumptionSaving.ConsumerParameters as Params - - InfiniteType = IndShockConsumerType(**Params.init_idiosyncratic_shocks) - InfiniteType.assignParameters(LivPrb = [1.], - DiscFac = 0.955, - PermGroFac = [1.], - PermShkStd = [0.], - TempShkStd = [0.], - T_total = 1, T_retire = 0, BoroCnstArt = None, UnempPrb = 0., - cycles = 0) # This is what makes the type infinite horizon - - InfiniteType.updateIncomeProcess() - InfiniteType.solve() - InfiniteType.timeFwd() - InfiniteType.unpackcFunc() - - - # Make and solve a perfect foresight consumer type with the same parameters - PerfectForesightType = deepcopy(InfiniteType) - PerfectForesightType.solveOnePeriod = solvePerfForesight - - PerfectForesightType.solve() - PerfectForesightType.unpackcFunc() - PerfectForesightType.timeFwd() - - self.InfiniteType = InfiniteType - self.PerfectForesightType = PerfectForesightType - - - def test_consumption(self): - """" - Now compare the consumption functions and make sure they are "close" - """ - diffFunc = lambda m : self.PerfectForesightType.solution[0].cFunc(m) - \ - self.InfiniteType.cFunc[0](m) - points = np.arange(0.5,10.,.01) - difference = diffFunc(points) - max_difference = np.max(np.abs(difference)) - - self.assertLess(max_difference,0.01) - - - -class Compare_TBS_and_Markov(unittest.TestCase): - """ - Class to compare output of the Tractable Buffer Stock and Markov models. - - The only uncertainty in the TBS model is over when the agent will enter an absorbing state - with 0 income. With the right transition arrays and income processes, this is just a special - case of the Markov model. So with the right inputs, we should be able to solve the two - different models and get the same outputs. - """ - def setUp(self): - # Set up and solve TBS - base_primitives = {'UnempPrb' : .015, - 'DiscFac' : 0.9, - 'Rfree' : 1.1, - 'PermGroFac' : 1.05, - 'CRRA' : .95} - - - TBSType = TractableConsumerType(**base_primitives) - TBSType.solve() - - # Set up and solve Markov - MrkvArray = np.array([[1.0-base_primitives['UnempPrb'],base_primitives['UnempPrb']], - [0.0,1.0]]) - Markov_primitives = {"CRRA":base_primitives['CRRA'], - "Rfree":np.array(2*[base_primitives['Rfree']]), - "PermGroFac":[np.array(2*[base_primitives['PermGroFac']/ - (1.0-base_primitives['UnempPrb'])])], - "BoroCnstArt":None, - "PermShkStd":[0.0], - "PermShkCount":1, - "TranShkStd":[0.0], - "TranShkCount":1, - "T_total":1, - "UnempPrb":0.0, - "UnempPrbRet":0.0, - "T_retire":0, - "IncUnemp":0.0, - "IncUnempRet":0.0, - "aXtraMin":0.001, - "aXtraMax":TBSType.mUpperBnd, - "aXtraCount":48, - "aXtraExtra":[None], - "aXtraNestFac":3, - "LivPrb":[1.0], - "DiscFac":base_primitives['DiscFac'], - 'Nagents':1, - 'psi_seed':0, - 'xi_seed':0, - 'unemp_seed':0, - 'tax_rate':0.0, - 'vFuncBool':False, - 'CubicBool':True, - 'MrkvArray':MrkvArray - } - - MarkovType = MarkovConsumerType(**Markov_primitives) - MarkovType.cycles = 0 - employed_income_dist = [np.ones(1),np.ones(1),np.ones(1)] - unemployed_income_dist = [np.ones(1),np.ones(1),np.zeros(1)] - MarkovType.IncomeDstn = [[employed_income_dist,unemployed_income_dist]] - - MarkovType.solve() - MarkovType.unpackcFunc() - - self.TBSType = TBSType - self.MarkovType = MarkovType - - def test_consumption(self): - # Now compare the consumption functions and make sure they are "close" - - diffFunc = lambda m : self.TBSType.solution[0].cFunc(m) - self.MarkovType.cFunc[0][0](m) - points = np.arange(0.1,10.,.01) - difference = diffFunc(points) - max_difference = np.max(np.abs(difference)) - - self.assertLess(max_difference,0.01) - -if __name__ == '__main__': - # Run all the tests - unittest.main() diff --git a/Testing/HARKutilities_UnitTests.py b/Testing/HARKutilities_UnitTests.py deleted file mode 100644 index 26bbd874a..000000000 --- a/Testing/HARKutilities_UnitTests.py +++ /dev/null @@ -1,68 +0,0 @@ -""" -This file implements unit tests to check HARK/utilities.py -""" -from __future__ import print_function, division -from __future__ import absolute_import - -from builtins import str -from builtins import zip -from builtins import range -from builtins import object - -import HARK.utilities - -# Bring in modules we need -import unittest -import numpy as np - -class testsForHARKutilities(unittest.TestCase): - - def setUp(self): - self.c_vals = np.linspace(.5,10.,20) - self.CRRA_vals = np.linspace(1.,10.,10) - - def first_diff_approx(self,func,x,delta,*args): - """ - Take the first (centered) difference approximation to the derivative of a function. - - """ - return (func(x+delta,*args) - func(x-delta,*args)) / (2. * delta) - - def derivative_func_comparison(self,deriv,func): - """ - This method computes the first difference approximation to the derivative of a function - "func" and the (supposedly) closed-form derivative of that function ("deriv") over a - grid. It then checks that these two things are "close enough." - """ - - # Loop through different values of consumption - for c in self.c_vals: - # Loop through different values of risk aversion - for CRRA in self.CRRA_vals: - - # Calculate the difference between the derivative of the function and the - # first difference approximation to that derivative. - diff = abs(deriv(c,CRRA) - self.first_diff_approx(func,c,.000001,CRRA)) - - # Make sure the derivative and its approximation are close - self.assertLess(diff,.01) - - def test_CRRAutilityP(self): - # Test the first derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityP,HARK.utilities.CRRAutility) - - def test_CRRAutilityPP(self): - # Test the second derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityPP,HARK.utilities.CRRAutilityP) - - def test_CRRAutilityPPP(self): - # Test the third derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityPPP,HARK.utilities.CRRAutilityPP) - - def test_CRRAutilityPPPP(self): - # Test the fourth derivative of the utility function - self.derivative_func_comparison(HARK.utilities.CRRAutilityPPPP,HARK.utilities.CRRAutilityPPP) - -if __name__ == '__main__': - print('testing Harkutilities.py') - unittest.main() diff --git a/Testing/ModelTesting.py b/Testing/ModelTesting.py index 5b2b32115..1f4603ed5 100644 --- a/Testing/ModelTesting.py +++ b/Testing/ModelTesting.py @@ -25,46 +25,40 @@ class parameterCheck(object): parameters based on the original parameters. ''' - def __init__(self, model, base_primitives, multiplier = .1, N_param_values_in_range = 2): + def __init__(self, model, base_primitives, multiplier=.1, N_param_values_in_range=2): ''' Inputs ---------- model: an instance of AgentType with a working .solve() function - base_primitives: dictionary of input parameters for the the model - multiplier: coefficient that determines the range for each parameter within testing sets. the range for each parameter P is [P-P*multiplier,P+P*multiplier]. All testing parameters will be within this range - N_param_ values_in_range: number of different parameter values to test within the given range - ''' - self._model = model - self._base_primitives = base_primitives - self._multiplier = multiplier + self._model = model + self._base_primitives = base_primitives + self._multiplier = multiplier self.N_param_values_in_range = N_param_values_in_range - self.dict_of_min_max_and_N = self.makeParameterDictionary() - self._parametersToTest = self.findTestParameters() + self.dict_of_min_max_and_N = self.makeParameterDictionary() + self._parametersToTest = self.findTestParameters() - self.test_results = [] - self.validParams = [] - self.failedParams = [] + self.test_results = [] + self.validParams = [] + self.failedParams = [] def makeParameterDictionary(self): ''' Returns a dictionary that specifies the min, max, and number of values to check for each parameter - Inputs ---------- none - Returns ---------- dict_of_min_max_and_N: dictionary @@ -72,27 +66,24 @@ def makeParameterDictionary(self): consisting of (1) the minimum value of that parameter to ry, (2) the maximum value of that parameter to try, and (3) the number of values for that parameter to try ''' - dict_of_min_max_and_N = {key:(value-self._multiplier*value, # the min - value+self._multiplier*value, # the max - self.N_param_values_in_range) # number of param values to try - for key,value in self._base_primitives.items()} + dict_of_min_max_and_N = {key: (value-self._multiplier*value, # the min + value+self._multiplier*value, # the max + self.N_param_values_in_range) # number of param values to try + for key, value in self._base_primitives.items()} N_combinations = self.N_param_values_in_range**len(self._base_primitives) - print("There are " + str(N_combinations)+ " parameter combinations to test.") + print("There are " + str(N_combinations) + " parameter combinations to test.") return dict_of_min_max_and_N def findTestParameters(self): ''' This function creates sets (dictionaries) of parameters to test in the model - It returns a list of parameter sets (dictionaries) for testing - Inputs ---------- none - Returns ---------- parametersToTest: list @@ -102,25 +93,23 @@ def findTestParameters(self): 2nd test run should use a value of 1.02 for Rfree. ''' parameterLists = [] - keyOrder = [] - parametersToTest = [] - for key,value in list(self.dict_of_min_max_and_N.items()): + keyOrder = [] + parametersToTest = [] + for key, value in list(self.dict_of_min_max_and_N.items()): parameterRange = np.linspace(*value) parameterLists.append(parameterRange) keyOrder.append(key) for param_combination in itertools.product(*parameterLists): - parametersToTest.append(dict(list(zip(keyOrder,param_combination)))) + parametersToTest.append(dict(list(zip(keyOrder, param_combination)))) return parametersToTest def testParameters(self): ''' Runs the model on the test parameters and stores the error results. Also prints out the error messages that were thrown. - Inputs ---------- none - Returns ---------- None @@ -132,54 +121,47 @@ def testParameters(self): def narrowParameters(self): ''' this function needs to be able to identify the valid parameter space - then it can plug in those values to the makeParameterDictionary function and rerun the models - self._iterator = self.makeParameterDictionary() - parameterLists = [] for k,v in self._iterator.iteritems(): parameterRange = np.arange(*v) parameterLists.append(parameterRange) pairwise = list(all_pairs(parameterLists, previously_tested=self._testedParams)) print("Subsequent round of testing reduced to " + str(len(pairwise)) + " pairwise combinations of parameters") - self.runModel(pairwise) ''' raise NotImplementedError() - def runModel(self,parametersToTest): + def runModel(self, parametersToTest): ''' run the model using each set of test parameters. for each model, a new object (an instance of parameterInstanceCheck) records the results of the test. - Each result is places in the appropriate list (failedParams or validParams) - Inputs ---------- parametersToTest: list A list of dictionaries produced by findTestParameters. See the documentation for findTestParameters for more info. - Returns ---------- None ''' for i in range(len(parametersToTest)): - tempDict = dict(self._base_primitives) + tempDict = dict(self._base_primitives) tempParams = parametersToTest[i] - testData = parameterInstanceCheck(i,tempParams,tempDict) - Test = self._model(**tempParams) + testData = parameterInstanceCheck(i, tempParams, tempDict) + Test = self._model(**tempParams) print('Attempting to solve with parameter set ' + str(i)) try: Test.solve() - #TODO: Insert allowed exceptions here so they don't count as errors! + # TODO: Insert allowed exceptions here so they don't count as errors! except Exception as e: - testData.errorBoolean = True - testData.errorCode = str(e) - testData._tracebackText = sys.exc_info() + testData.errorBoolean = True + testData.errorCode = str(e) + testData._tracebackText = sys.exc_info() self.test_results.append(testData) for i in range(len(self.test_results)): @@ -191,11 +173,9 @@ def runModel(self,parametersToTest): def printErrors(self): ''' Print out the test numbers and error codes for all failed tests - Inputs ---------- none - Returns ---------- None @@ -205,22 +185,20 @@ def printErrors(self): print("test no " + str(i) + " failed with the following error code:") print(self.test_results[i].errorCode) - def printTestResults(self,test_number): + def printTestResults(self, test_number): """ This method prints out the results for a specific test. - Inputs ---------- test_number: int The number of the test to print results for - Returns ---------- None """ print("-----------------------------------------------------------------------") print("Showing specific results for test number " + str(test_number)) - #get a test result and find out more info + # get a test result and find out more info test = TBSCheck.test_results[test_number] print("the test number is : " + str(test.testNumber)) print("") @@ -236,53 +214,41 @@ class parameterInstanceCheck(object): ''' this class holds information for a single test of a model ''' - def __init__(self,testNumber,tested_primitives,original_primitives,errorBoolean=False, - errorCode=None,tracebackText=None): + def __init__(self, testNumber, tested_primitives, original_primitives, errorBoolean=False, + errorCode=None, tracebackText=None): ''' - Inputs ---------- testNumber: int The number of the test - - tested_primitives: dict the set of parameters that was tested - original_primitives: dict the original parameters that test parameters were constructed from - errorBoolean: boolean indicator of an error - errorCode: None or string text of the error (exception type included), if there is one. None otherwise. - tracebackText: full traceback, printable using the traceback.prin_excpetino function - ''' - self.testNumber = testNumber + self.testNumber = testNumber self.original_primitives = original_primitives - self.tested_primitives = tested_primitives - self.errorBoolean = errorBoolean - self.errorCode = errorCode - self._tracebackText = tracebackText - + self.tested_primitives = tested_primitives + self.errorBoolean = errorBoolean + self.errorCode = errorCode + self._tracebackText = tracebackText def traceback(self): ''' function that prints a traceback for an errror - Inputs ---------- none - Returns ---------- None - ''' try: traceback.print_exception(*self._tracebackText) @@ -299,18 +265,16 @@ def traceback(self): # Bring in the TractableBufferStockModel to test it import HARK.ConsumptionSaving.TractableBufferStockModel as Model - - base_primitives = {'UnempPrb' : .015, - 'DiscFac' : 0.9, - 'Rfree' : 1.1, - 'PermGroFac' : 1.05, - 'CRRA' : .95} + base_primitives = {'UnempPrb': .015, + 'DiscFac': 0.9, + 'Rfree': 1.1, + 'PermGroFac': 1.05, + 'CRRA': .95} # Assign a model and base parameters to be checked - TBSCheck = parameterCheck(Model.TractableConsumerType,base_primitives) + TBSCheck = parameterCheck(Model.TractableConsumerType, base_primitives) - #run the testing function. This runs the model multiple times + # run the testing function. This runs the model multiple times TBSCheck.testParameters() - TBSCheck.printTestResults(4) - + TBSCheck.printTestResults(4) \ No newline at end of file diff --git a/Testing/MultithreadDemo.py b/Testing/MultithreadDemo.py deleted file mode 100644 index 84ec61c73..000000000 --- a/Testing/MultithreadDemo.py +++ /dev/null @@ -1,91 +0,0 @@ -''' -A demonstration of parallel processing in HARK using HARK.parallel. -A benchmark consumption-saving model is solved for individuals whose CRRA varies -between 1 and 8. The infinite horizon model is solved serially and then in -parallel. Note that HARK.parallel will not work "out of the box", as Anaconda -does not include two packages needed for it; see HARK/parallel.py. When given a -sufficiently large amount of work for each thread to do, the maximum speedup -factor seems to be around P/2, where P is the number of processors. -''' -from __future__ import print_function, division -from __future__ import absolute_import - -from builtins import str -from builtins import zip -from builtins import range -from builtins import object - - -import HARK.ConsumptionSaving.ConsumerParameters as Params # Parameters for a consumer type -import HARK.ConsumptionSaving.ConsIndShockModel as Model # Consumption-saving model with idiosyncratic shocks -from HARK.utilities import plotFuncs, plotFuncsDer # Basic plotting tools -from time import clock # Timing utility -from copy import deepcopy # "Deep" copying for complex objects -from HARK.parallel import multiThreadCommandsFake, multiThreadCommands # Parallel processing -mystr = lambda number : "{:.4f}".format(number)# Format numbers as strings -import numpy as np # Numeric Python - -if __name__ == '__main__': # Parallel calls *must* be inside a call to __main__ - type_count = 32 # Number of values of CRRA to solve - - # Make the basic type that we'll use as a template. - # The basic type has an artificially dense assets grid, as the problem to be - # solved must be sufficiently large for multithreading to be faster than - # single-threading (looping), due to overhead. - BasicType = Model.IndShockConsumerType(**Params.init_idiosyncratic_shocks) - BasicType.cycles = 0 - BasicType(aXtraMax = 100, aXtraCount = 64) - BasicType(vFuncBool = False, CubicBool = True) - BasicType.updateAssetsGrid() - BasicType.timeFwd() - - # Solve the basic type and plot the results, to make sure things are working - start_time = clock() - BasicType.solve() - end_time = clock() - print('Solving the basic consumer took ' + mystr(end_time-start_time) + ' seconds.') - BasicType.unpackcFunc() - print('Consumption function:') - plotFuncs(BasicType.cFunc[0],0,5) # plot consumption - print('Marginal consumption function:') - plotFuncsDer(BasicType.cFunc[0],0,5) # plot MPC - if BasicType.vFuncBool: - print('Value function:') - plotFuncs(BasicType.solution[0].vFunc,0.2,5) - - # Make many copies of the basic type, each with a different risk aversion - BasicType.vFuncBool = False # just in case it was set to True above - my_agent_list = [] - CRRA_list = np.linspace(1,8,type_count) # All the values that CRRA will take on - for i in range(type_count): - this_agent = deepcopy(BasicType) # Make a new copy of the basic type - this_agent.assignParameters(CRRA = CRRA_list[i]) # Give it a unique CRRA value - my_agent_list.append(this_agent) # Addd it to the list of agent types - - # Make a list of commands to be run in parallel; these should be methods of ConsumerType - do_this_stuff = ['updateSolutionTerminal()','solve()','unpackcFunc()'] - - # Solve the model for each type by looping over the types (not multithreading) - start_time = clock() - multiThreadCommandsFake(my_agent_list, do_this_stuff) # Fake multithreading, just loops - end_time = clock() - print('Solving ' + str(type_count) + ' types without multithreading took ' + mystr(end_time-start_time) + ' seconds.') - - # Plot the consumption functions for all types on one figure - plotFuncs([this_type.cFunc[0] for this_type in my_agent_list],0,5) - - # Delete the solution for each type to make sure we're not just faking it - for i in range(type_count): - my_agent_list[i].solution = None - my_agent_list[i].cFunc = None - my_agent_list[i].time_vary.remove('solution') - my_agent_list[i].time_vary.remove('cFunc') - - # And here's HARK's initial attempt at multithreading: - start_time = clock() - multiThreadCommands(my_agent_list, do_this_stuff) # Actual multithreading - end_time = clock() - print('Solving ' + str(type_count) + ' types with multithreading took ' + mystr(end_time-start_time) + ' seconds.') - - # Plot the consumption functions for all types on one figure to see if it worked - plotFuncs([this_type.cFunc[0] for this_type in my_agent_list],0,5) diff --git a/Testing/TractableBufferStockModel_UnitTests.py b/Testing/TractableBufferStockModel_UnitTests.py deleted file mode 100644 index 5a9af43e8..000000000 --- a/Testing/TractableBufferStockModel_UnitTests.py +++ /dev/null @@ -1,64 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Thu Mar 24 11:01:50 2016 - -@author: kaufmana -""" -from __future__ import print_function, division -from __future__ import absolute_import - -from builtins import str -from builtins import zip -from builtins import range -from builtins import object - -import HARK.ConsumptionSaving.TractableBufferStockModel as Model -import unittest - -class FuncTest(unittest.TestCase): - - def setUp(self): - base_primitives = {'UnempPrb' : .015, - 'DiscFac' : 0.9, - 'Rfree' : 1.1, - 'PermGroFac' : 1.05, - 'CRRA' : .95} - test_model = Model.TractableConsumerType(**base_primitives) - test_model.solve() - cNrm_list = [0.0, - 0.6170411710160961, - 0.7512931350607787, - 0.8242071925443384, - 0.8732633069358244, - 0.9090443048442146, - 0.9362584565290604, - 0.9574865107447327, - 0.9743235996720729, - 0.9878347049396029, - 0.9987694718922687, - 1.0499840337356576, - 1.0988370658458553, - 1.1079081119060201, - 1.1185500922622567, - 1.1309953859705277, - 1.1454986397022289, - 1.1623357560591763, - 1.1818022106863713, - 1.2042108062871855, - 1.2298890682784422, - 1.2591765689896088, - 1.2924225145436121, - 1.329983925942064, - 1.372224689976677, - 1.4195156568037894, - 1.4722358408529614, - 1.5307746658958221] - return test_model.solution[0].cNrm_list,cNrm_list - - def test1(self): - results = self.setUp() - self.assertEqual(results[0],results[1]) - - -if __name__ == '__main__': - unittest.main() diff --git a/requirements.txt b/requirements.txt index ea07a6bbb..9e16229e5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -6,3 +6,7 @@ future joblib dill scipy +flake8 +jupyter +funcsigs +jupyter diff --git a/setup.cfg b/setup.cfg index a1bb0d6cb..e20572e11 100644 --- a/setup.cfg +++ b/setup.cfg @@ -12,4 +12,8 @@ license_file = LICENSE # bdist_wheel from trying to make a universal wheel. For more see: # https://packaging.python.org/tutorials/distributing-packages/#wheels +[flake8] +exclude = .git +max-line-length = 119 + universal=1 diff --git a/setup.py b/setup.py index ac0472894..cbc72e075 100644 --- a/setup.py +++ b/setup.py @@ -42,7 +42,7 @@ # For a discussion on single-sourcing the version across setup.py and the # project code, see # https://packaging.python.org/en/latest/single_source_version.html - version='0.9.1', # Required + version='0.10.1', # Required # This is a one-line description or tagline of what your project does. This # corresponds to the "Summary" metadata field: @@ -152,7 +152,9 @@ 'numpydoc', 'dill', 'joblib', - 'future'], # Optional + 'future', # Optional + 'funcsigs', + 'jupyter'], python_requires='>=2.7',