BufferStockTheory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "06633a3a",
   "metadata": {},
   "source": [
    "# Theoretical Foundations of Buffer Stock Saving\n",
    "\n",
    "<cite data-cite=\"6202365/8AH9AXN2\"></cite>\n",
    "\n",
    "\n",
    "[![econ-ark.org](https://img.shields.io/badge/Powered%20by-Econ--ARK-3e8acc.svg)](https://econ-ark.org/materials/bufferstocktheory)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e97a4428",
   "metadata": {},
   "source": [
    "<a id='interactive-dashboard'></a>\n",
    "\n",
    "[This notebook](https://econ-ark.org/materials/bufferstocktheory?launch) uses the [Econ-ARK/HARK](https://github.com/econ-ark/HARK) toolkit to reproduce and illustrate key results of the paper [Theoretical Foundations of Buffer Stock Saving](https://econ-ark.github.io/BufferStockTheory/).\n",
    "\n",
    "An [interactive dashboard](https://econ-ark.org/materials/bufferstocktheory?dashboard) allows you to modify parameters to see how (some of) the figures change.\n",
    "\n",
    "\n",
    "- In JupyterLab, click on the $\\bullet$$\\bullet$$\\bullet$ patterns to expose the runnable code\n",
    "- in either a Jupyter notebook or JupyterLab:\n",
    "\n",
    "    * Click the double triangle <span class=reload>&#x23e9;</span> above to execute the code and generate the figures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf242f9e",
   "metadata": {},
   "source": [
    "`# Setup Python Below`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb5a02b9-01a6-4ec9-9780-66fe5910f005",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4184f542-7aaf-46ee-9cb3-cbc0f53583be",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Import required python packages\n",
    "import os.path\n",
    "import sys\n",
    "import subprocess\n",
    "import logging\n",
    "import numpy as np\n",
    "from copy import deepcopy\n",
    "import warnings\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams['svg.hashsalt'] = \"42\" # Prevent mpl from generating random noise (for reproducibility)\n",
    "import matplotlib.pyplot as plt\n",
    "warnings.filterwarnings(\"ignore\") # Ignore some harmless but alarming warning messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "327a592f-f315-4853-a580-f0ebf0f406e2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Make sure other required tools (like HARK) are installed\n",
    "if os.path.isdir('binder'):  # Folder defining requirements exists\n",
    "    # File requirements.out should be created first time notebook is run\n",
    "    if not os.path.isfile('./binder/requirements.out'):\n",
    "        try:\n",
    "            output = subprocess.check_output(\n",
    "                [sys.executable, '-m', 'pip', 'install','--user','-r','./binder/requirements.txt'],stderr=subprocess.STDOUT) \n",
    "            requirements_out = open(\"./binder/requirements.out\",\"w\")\n",
    "            requirements_out.write(output.decode(\"utf8\"))\n",
    "        except subprocess.CalledProcessError as e:\n",
    "            print(output.decode(\"utf8\"))\n",
    "            print(e.output.decode(\"utf8\"),e.returncode)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd73238",
   "metadata": {},
   "source": [
    "`# Setup HARK Below`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1b28cfe6",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from HARK import __version__ as HARKversion\n",
    "from HARK.utilities import (\n",
    "    plot_funcs, find_gui, make_figs, determine_platform,\n",
    "    test_latex_installation, setup_latex_env_notebook)\n",
    "from HARK.ConsumptionSaving.ConsIndShockModel import (\n",
    "    PerfForesightConsumerType, IndShockConsumerType, init_perfect_foresight, init_idiosyncratic_shocks)\n",
    "\n",
    "\n",
    "# Whether to save the figures to Figures_dir\n",
    "saveFigs = True\n",
    "\n",
    "# Whether to draw the figures\n",
    "drawFigs = True\n",
    "\n",
    "pf = determine_platform() # latex checking depends on platform\n",
    "try: # test whether latex is installed on command line \n",
    "    latexExists = test_latex_installation(pf)\n",
    "except ImportError:  # windows and MacOS requires manual latex install\n",
    "    latexExists = False\n",
    "\n",
    "setup_latex_env_notebook(pf, latexExists)\n",
    "\n",
    "# check if GUI is present; if not then switch drawFigs to False and force saveFigs to be True\n",
    "if not find_gui():\n",
    "    drawFigs, saveFigs = False, True\n",
    "\n",
    "# Font sizes for figures\n",
    "fssml, fsmid, fsbig = 18, 22, 26\n",
    "\n",
    "def makeFig(figure_name, target_dir=\"./Figures\"):\n",
    "    print('')\n",
    "    make_figs(figure_name, saveFigs, drawFigs, target_dir)\n",
    "    print('')\n",
    "    \n",
    "base_params = deepcopy(init_idiosyncratic_shocks)\n",
    "# Uninteresting housekeeping and details\n",
    "# Make global variables for the things that were lists above \n",
    "PermGroFac, PermShkStd, TranShkStd = base_params['PermGroFac'][0], base_params['PermShkStd'][0], base_params['TranShkStd'][0]\n",
    "\n",
    "# Some technical settings that are not interesting for our purposes\n",
    "base_params['LivPrb'] = [1.0]   # 100 percent chance of living to next period\n",
    "base_params['BoroCnstArt'] = None    # No artificial borrowing constraint\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d0c3a33",
   "metadata": {
    "tags": []
   },
   "source": [
    "## [The Problem](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory/BufferStockTheory3.html#The-Problem)\n",
    "\n",
    "The paper [calibrates](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Calibration) a small set of parameters:\n",
    "\n",
    "\\begin{align}\n",
    " &\n",
    "\\newcommand\\maththorn{\\mathord{\\pmb{\\text{\\TH}}}}\n",
    "\\newcommand{\\aLvl}{\\mathbf{a}}\n",
    "\\newcommand{\\aNrm}{{a}}\n",
    "\\newcommand{\\BalGroRte}{\\tilde}\n",
    "\\newcommand{\\Bal}{\\check}\n",
    "\\newcommand{\\bLvl}{{\\mathbf{b}}}\n",
    "\\newcommand{\\bNrm}{{b}}\n",
    "\\newcommand{\\cFunc}{\\mathrm{c}}\n",
    "\\newcommand{\\cLvl}{{\\mathbf{c}}}\n",
    "\\newcommand{\\cNrm}{{c}}\n",
    "\\newcommand{\\CRRA}{\\rho}\n",
    "\\newcommand{\\DiscFac}{\\beta}\n",
    "\\newcommand{\\dLvl}{{\\mathbf{d}}}\n",
    "\\newcommand{\\dNrm}{{d}}\n",
    "\\newcommand{\\Ex}{\\mathbb{E}}\n",
    "\\newcommand{\\hLvl}{{\\mathbf{h}}}\n",
    "\\newcommand{\\hNrm}{{h}}\n",
    "\\newcommand{\\IncUnemp}{\\mu}\n",
    "\\newcommand{\\mLvl}{{\\mathbf{m}}}\n",
    "\\newcommand{\\mNrm}{{m}}\n",
    "\\newcommand{\\MPC}{\\kappa}\n",
    "\\newcommand{\\PatFac}{\\pmb{\\unicode[0.55,0.05]{0x00DE}}}\n",
    "\\newcommand{\\PatRte}{\\pmb{\\unicode[0.55,0.05]{0x00FE}}}\n",
    "\\newcommand{\\PermGroFacAdj}{\\tilde{\\Phi}}\n",
    "\\newcommand{\\PermGroFac}{\\pmb{\\Phi}}\n",
    "\\newcommand{\\PermShkStd}{\\sigma_{\\PermShk}}\n",
    "\\newcommand{\\PermShk}{\\pmb{\\Psi}} % New\n",
    "\\newcommand{\\pLvl}{{\\mathbf{p}}}\n",
    "\\newcommand{\\Rfree}{\\mathsf{R}}\n",
    "\\newcommand{\\RNrm}{\\mathcal{R}}\n",
    "\\newcommand{\\Thorn}{\\pmb{\\TH}}\n",
    "\\newcommand{\\TranShkAll}{\\pmb{\\xi}}\n",
    "\\newcommand{\\TranShkStd}{\\sigma_{\\TranShk}}\n",
    "\\newcommand{\\TranShk}{\\pmb{\\theta}}\n",
    "\\newcommand{\\Trg}{\\hat}\n",
    "\\newcommand{\\uFunc}{\\mathrm{u}}\n",
    "\\newcommand{\\UnempPrb}{\\wp}\n",
    "\\newcommand{\\vLvl}{{\\mathbf{v}}}\n",
    "\\newcommand{\\vNrm}{{v}}\n",
    "\\renewcommand{\\APFac}{\\pmb{\\unicode[0.55,0.05]{0x00DE}}}\n",
    "\\end{align}\n",
    "\n",
    "| Parameter | Description | Python Variable | Value |\n",
    "|:---:      | :---:       | :---:  | :---: |\n",
    "| $\\PermGroFac$ | Permanent Income Growth Factor | $\\texttt{PermGroFac}$ | 1.03 |\n",
    "| $\\Rfree$ | Interest Factor | $\\texttt{Rfree}$ | 1.04 |\n",
    "| $\\DiscFac$ | Time Preference Factor | $\\texttt{DiscFac}$ | 0.96 |\n",
    "| $\\CRRA$ | Coeﬃcient of Relative Risk Aversion| $\\texttt{CRRA}$ | 2 |\n",
    "| $\\UnempPrb$ | Probability of Unemployment | $\\texttt{UnempPrb}$ | 0.005 |\n",
    "| $\\TranShk^{\\large u}$ | Income when Unemployed | $\\texttt{IncUnemp}$ | 0. |\n",
    "| $\\PermShkStd$ | Std Dev of Log Permanent Shock| $\\texttt{PermShkStd}$ | 0.1 |\n",
    "| $\\TranShkStd$ | Std Dev of Log Transitory Shock| $\\texttt{TranShkStd}$ | 0.1 |\n",
    "\n",
    "that define the preferences and environment of microeconomic consumers as detailed below.  (For notational conventions used here and in the paper, see the [NARK](https://github.com/econ-ark/HARK/blob/BST-HARK-pre-release-v4/Documentation/NARK/NARK.pdf).)\n",
    "\n",
    "The objective of such a consumer with a horizon of $n$ periods is to maximize the value obtained from the sequence of consumption choices __**c**__ from period $t=T-n$ to a terminal period $T$:\n",
    "\n",
    "\\begin{equation}\n",
    "\\mathbf{v}_{t} = \\sum_{i=0}^{n} \\DiscFac^{n}\\mathrm{u}(\\mathbf{c}_{t+n})\n",
    "\\end{equation}\n",
    "\n",
    "The infinite-horizon solution is defined as the limit of the first period solution $\\mathrm{c}_{T-n}$ as the horizon $n$ goes to infinity."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ce47bf3",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Details\n",
    "For a microeconomic consumer who begins period $t$ with __**m**__arket resources boldface $\\mLvl_{t}$ (=net worth plus current income), the amount that remains after __**c**__onsumption of $\\cLvl_{t}$ will be end-of-period __**a**__ssets $\\aLvl_{t}$,\n",
    "\n",
    "<!-- Next period's 'Balances' $B_{t+1}$ reflect this period's $\\aLvl_{t}$ augmented by return factor $R$:-->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b73882d7",
   "metadata": {},
   "source": [
    "\\begin{eqnarray}\n",
    "\\aLvl_{t}   &=&\\mLvl_{t}-\\cLvl_{t}. \\notag\n",
    "\\end{eqnarray}\n",
    "\n",
    "The consumer's __**p**__ermanent noncapital income $\\pLvl$ grows by a predictable factor $\\PermGroFac$ and is subject to an unpredictable multiplicative shock $\\Ex_{t}[\\PermShk_{t+1}]=1$,\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\pLvl_{t+1} & = & \\pLvl_{t} \\PermGroFac \\PermShk_{t+1}, \\notag\n",
    "\\end{eqnarray}\n",
    "\n",
    "and, if the consumer is employed, actual income is permanent income multiplied by a transitory shock $\\TranShk^{\\large e}$.  There is also a probability $\\UnempPrb$ that the consumer will be temporarily unemployed and experience income of $\\TranShk^{\\large u}  = 0$.  We construct $\\TranShk^{\\large e}$ so that its mean value is $1/(1-\\UnempPrb)$ because in that case the mean level of the transitory shock (accounting for both unemployed and employed states) is exactly\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\Ex_{t}[\\TranShk_{t+1}] & = & \\TranShk^{\\large{u}}  \\times \\UnempPrb + (1-\\UnempPrb) \\times \\Ex_{t}[\\TranShk^{\\large{e}}_{t+1}] \\notag\n",
    "\\\\ & = & 0 \\times \\UnempPrb + (1-\\UnempPrb) \\times 1/(1-\\UnempPrb)  \\notag\n",
    "\\\\ & = & 1. \\notag\n",
    "\\end{eqnarray}\n",
    "\n",
    "  We can combine the unemployment shock $\\TranShk^{\\large u}$ and the transitory shock to employment income $\\TranShk^{\\large e}$ into $\\TranShkAll_{t+1}$, so that next period's market resources are\n",
    "\\begin{eqnarray}\n",
    "    \\mLvl_{t+1} &=& \\aLvl_{t}\\Rfree +\\pLvl_{t+1}\\TranShkAll_{t+1}.  \\notag\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5e16be6",
   "metadata": {},
   "source": [
    "When the consumer has a CRRA utility function $u(\\cLvl)=\\frac{\\cLvl^{1-\\CRRA}}{1-\\CRRA}$, the paper shows that the problem can be written in terms of ratios (nonbold font) of level (bold font) variables to permanent income, e.g. $m_{t} \\equiv \\mLvl_{t}/\\pLvl_{t}$, and the Bellman form of [the problem reduces to](https://econ-ark.github.io/BufferStockTheory/#The-Related-Problem):\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "v_t(m_t) &=& \\max_{c_t}~~ u(c_t) + \\DiscFac~\\Ex_{t} [(\\PermGroFac\\PermShk_{t+1})^{1-\\CRRA} v_{t+1}(m_{t+1}) ] \\\\\n",
    "& s.t. & \\\\\n",
    "a_t &=& m_t - c_t \\\\\n",
    "m_{t+1} &=& a_t \\Rfree/(\\PermGroFac \\PermShk_{t+1}) + \\TranShkAll_{t+1} \\\\\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3ff616b5",
   "metadata": {
    "lines_to_next_cell": 0,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set the parameters for the baseline results in the paper\n",
    "base_params['PermGroFac'] = [1.03]         # Permanent income growth factor\n",
    "base_params['Rfree'] = Rfree = 1.04        # Interest factor on assets\n",
    "base_params['DiscFac'] = DiscFac = 0.96    # Time Preference Factor\n",
    "base_params['CRRA'] = CRRA = 2.00          # Coefficient of relative risk aversion\n",
    "# Probability of unemployment (e.g. Probability of Zero Income in the paper)\n",
    "base_params['UnempPrb'] = UnempPrb = 0.005\n",
    "base_params['IncUnemp'] = IncUnemp = 0.0   # Induces natural borrowing constraint\n",
    "base_params['PermShkStd'] = [0.1]          # Standard deviation of log permanent income shocks\n",
    "base_params['TranShkStd'] = [0.1]          # Standard deviation of log transitory income shocks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8220cc68",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Convergence of the Consumption Rules\n",
    "\n",
    "Under the given parameter values, [the paper's first figure](https://econ-ark.github.io/BufferStockTheory/#Convergence-of-the-Consumption-Rules) depicts the successive consumption rules that apply in the last period of life $(c_{T}(m))$, the second-to-last period, and earlier periods $(c_{T-n})$.  The consumption function to which these converge is $c(m)$:\n",
    "\n",
    "\\begin{equation}\n",
    "c(m) = \\lim_{n \\uparrow \\infty} c_{T-n}(m) \\notag\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf782ac2",
   "metadata": {},
   "source": [
    "`# Create a buffer stock consumer instance:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e0894c22",
   "metadata": {
    "lines_to_next_cell": 2,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\n",
      ".................................................................."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "(quietly=False and messaging_level < logging.WARNING, so some model information is provided below):\n",
      "\n",
      "The model has the following parameter values:\n",
      "\n",
      "\tDiscFac: 0.96\n",
      "\tLivPrb: 1.0\n",
      "\tCRRA: 2.0\n",
      "\tRfree: 1.04\n",
      "\tPermGroFac: 1.03\n",
      "\tIncShkDstn: <HARK.distribution.DiscreteDistribution object at 0x13ff0a620>\n",
      "\tPermShkDstn: <HARK.distribution.DiscreteDistribution object at 0x13ff09d50>\n",
      "\tTranShkDstn: <HARK.distribution.DiscreteDistribution object at 0x10f3916c0>\n",
      "\tBoroCnstArt: None\n",
      "\tMaxKinks: None\n",
      "\tsolverType: HARK\n",
      "\tsolveMethod: EGM\n",
      "\teventTiming: EOP\n",
      "\thorizon: infinite\n",
      "\targs: ()\n",
      "\n",
      "The model's transition equations are:\n",
      "\n",
      "chosen_to_next_choice step:\n",
      "\tkNrm = aNrm\n",
      "\tRNrm = Rfree / (PermGroFac * PermShk)\n",
      "\tbNrm = kNrm * RNrm\n",
      "\tyNrm = TranShk\n",
      "\tmNrm = bNrm + yNrm\n",
      "\n",
      "choice_to_chosen step:\n",
      "\taNrm = mNrm - cNrm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "..................................\n"
     ]
    }
   ],
   "source": [
    "# Create a buffer stock consumer instance by invoking the IndShockConsumerType class\n",
    "# with the parameter dictionary \"base_params\"\n",
    "\n",
    "base_params['cycles'] = 100  # periods to solve from end\n",
    "# Construct finite horizon agent with baseline parameters\n",
    "baseAgent_Fin = \\\n",
    "    IndShockConsumerType(**base_params)  # Don't babble during setup\n",
    "\n",
    "baseAgent_Fin.solve()  # Solve the model quietly\n",
    "\n",
    "baseAgent_Fin.unpack('cFunc')  # Retrieve consumption functions\n",
    "cFunc = baseAgent_Fin.cFunc    # Shortcut"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a60998f1",
   "metadata": {},
   "source": [
    "`# Plot the consumption rules:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "25a5746d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Saving figure cFuncsConverge in ./Figures\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+IAAALtCAYAAACsO94qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADYxklEQVR4nOzdd1yVdf/H8TfuUYrYTq2wcmRlB03rbgctwAmSZVmWUAHmCjRzZCVBOQELqKxMU8EtjRvMyiwXlOY2TkOzTMUD7gHX749+h9vBEoHrjNfz8fBx38IZ73M8Gu/r+7m+l4dhGIYAAAAAAEC1qGF2AAAAAAAA3AlFHAAAAACAakQRBwAAAACgGlHEAQAAAACoRhRxAAAAAACqEUUcAAAAAIBqRBEHAAAAAKAaUcQBAAAAAKhGFHEAAAAAAKoRRRwAAAAAgGpEEQcAAAAAoBpRxAEAAAAAqEYUcQAAAAAAqhFFHAAAAACAakQRBwAAAACgGlHEAQAAAACoRhRxAAAAAACqEUUcAAAAAIBqVKsqHtRqtSo2NlZr166Vl5eXPD09ZbPZFB0dLV9f36p4SgAAAAAAnEKlrojbbDaFhYXJx8dHPj4+ysrKUkZGhlJTU4v+Nzk5uTKfEgAAAAAAp+JhGIZRGQ9ks9nk4+Oj3NxcZWVlydvb+7Tvp6WlKTo6WpKUk5NTGU8JAAAAAIDTqZQibi/hVqtVWVlZslgsZz+Rh4ckydvbmyIOAAAAAHBblTKaHhwcLKvVqtDQ0GJLuCT5+vrK09NTSUlJlfGUAAAAAAA4pfNeEU9LS1NwcLCkf0fOzxxJBwAAAAAA/3PeRbxly5ayWq2yWCzKysqqrFwAAAAAALik8xpNt1qtslqtkqSQkJBKCQQAAAAAgCs7ryKemZlZ9P+5PjgAAAAAAGU7ryJ+6u7nJW3SBgAAAAAA/qdSdk339PSsjIcBAAAAAMDlnVcR79ixoyTJy8ur3PdJTk4+n6cEAAAAAMCpnVcRt58Xbt+wrSzBwcGy2Wzn85QAAAAAADi18yrinp6eioqKkvTv9cRLYrPZFBwcrI4dOxbdHgAAAAAAd3Te1xGX/l3pzszMVFZWlry9vYu+brValZaWpoyMDMXGxrKhGwAAAADA7VV4RfzYsWMaM2aMjh07ptTUVMXGxiosLEx+fn5Fv6Kjo2WxWJSRkUEJR7U79TMKOCI+o3B0fEbh6PiMwtHxGUVJKrwinp+fr8aNGysvL0+NGjWq7FzAeeMzCkfHZxSOjs8oHB2fUTg6PqMoSaVcvgwAAAAAAJQPRRwAAAAAgGpUq7w3PHbs2GnnNtgvQ5aXl1fpoYDKkJ+ff9r/Ao6GzygcHZ9RODo+o3B0fEYrn2EY2rdvn7y8vFSjxv/WlevWrau6deuamOzclPsc8TFjxujVV1+t6jwAAAAAAJyT0aNHa8yYMWbHKLdyF/EzV8Tz8vLUokUL7dixg40HAAAAAABVLj8/X82bN9cff/yhxo0bF33d2VbEyz2aXtILa9SoEUUcAAAAAFBtGjdu7NQ9lM3aAAAAAACoRhRxAAAAAACqEUUcAAAAAIBqRBEHAAAAAKAaUcQBAAAAAKhGFHEAAAAAAKoRRRwAAAAAgGpEEQcAAAAAoBpRxAEAAAAAqEYUcQAAAAAAqhFFHAAAAACAakQRBwAAAACgGlHEAQAAAACoRhRxAAAAAACqEUUcAAAAAIBqRBEHAAAAAKAaUcQBAAAAAKhGFHEAAAAAAKoRRRwAAAAAgGpEEQcAAAAAoBpRxAEAAAAAqEYUcQAAAAAAqhFFHAAAAACAakQRBwAAAACgGlHEAQAAAACoRhRxAAAAAACqEUUcAAAAAIBqRBEHAAAAAKAaUcQBAAAAAKhGFHEAAAAAAKoRRRwAAAAAgGpEEQcAAAAAoBpRxAEAAAAAqEYUcQAAAAAAqhFFHAAAAACAakQRBwAAAACgGlHEAQAAAACoRhRxAAAAAACqEUUcAAAAAIBqRBEHAAAAAKAaUcQBAAAAAKhGFHEAAAAAAKoRRRwAAAAAgGpEEQcAAAAAoBpRxAEAAAAAqEYUcQAA4NQ2bNiggIAA7d271+woAACUC0UcAAA4rd27dysgIEDp6ekaOnSo2XEAACgXijgAAHBKhw8fVpcuXfT777/ruuuu0/jx482OBABAuVDEAQCA0yksLFTfvn21evVqeXl5KT09XU2bNjU7FgAA5UIRBwAATmfEiBFKS0tT7dq1NX/+fF133XVmRwIAoNwo4gAAwKl88MEHevPNNyVJ7733nu666y6TEwEAcG4o4gAAwGl89dVXCgsLkySNHDlSTz75pMmJAAA4dxRxAADgFLZs2aKePXvq5MmT6t27t1599VWzIwEAUCEUcQAA4PD27Nkjf39/2Ww23X777frggw/k4eFhdiwAACqEIg4AABza0aNH1a1bN1mtVnl7e2vBggWqV6+e2bEAAKgwijgAAHBYhmGoX79++v7779W4cWOlp6fr4osvNjsWAADnhSIOAAAc1pgxY/Tpp5+qVq1amjdvnlq3bm12JAAAzhtFHAAAOKTp06dr7NixkqR3331X9913n8mJAACoHBRxAADgcL799ls988wzkqTo6Oii/w8AgCugiAMAAIeyfft2de/eXSdOnFBQUJDGjRtndiQAACoVRRwAADiMffv2yd/fX7m5ubr11lv18ccfq0YNflwBALgW/ssGAAAcwvHjx9WjRw9t375dLVq00MKFC1W/fn2zYwEAUOko4gAAwHSGYah///769ttv1ahRI6Wnp+uyyy4zOxYAAFWCIg4AAEz3xhtv6OOPP1bNmjU1Z84ctWvXzuxIAABUGYo4AAAw1axZszRy5EhJUkJCgh588EGTEwEAULUo4gAAwDTff/+9nnrqKUnS4MGD9dxzz5kbCACAakARBwAAprBareratauOHTumLl26KC4uzuxIAABUC4o4AACodjabTf7+/tq7d68sFotmzpypmjVrmh0LAIBqQREHAADV6sSJEwoKCtKWLVt05ZVXavHixWrYsKHZsQAAqDYUcQAAUG0Mw9Dzzz+vpUuXqmHDhlqyZImuuOIKs2MBAFCtKOIAAKDavPXWW3r//fdVo0YNzZ49W+3btzc7EgAA1Y4iDgAAqsXcuXMVHR0tSZo0aZL8/f1NTgQAgDko4gAAoMqtXr1affr0kSRFREQoMjLS5EQAAJiHIg4AAKrU77//ri5duujo0aN65JFHNHHiRLMj4f9lZ2fLZrO5zfMCgKOgiAMAgCqTn5+vgIAA7d69WzfddJNmzZqlWrVqmR0LkjIzM5WZmSlPT89qf26LxaL+/ftTxgG4LYo4AACoEidPnlRISIg2bNigyy+/XEuWLNGFF15odixIslqtSkpKUlRUlGkZUlJSFBwcbNrzu6vg4GD5+PioSZMmSk5ONjuO04mLi5OPj49atmzJ5xfnhSIOAAAqnWEYGjBggL744gs1aNBAixcvVvPmzc2Ohf8XHByslJQUUzN4enoqLCxMYWFhpuaoSn5+frJarcV+z2q1qmXLloqLi1N2dvZpX09LS5Ofn58yMzMrPVNsbKxCQkKYRqig0NBQDR8+XFartcT3MDMzkwMdKBNFHAAAVLrJkyfrnXfekYeHh2bMmCEfHx+zI+H/RUdHKyQkxJSR9DMFBQVp7dq1pxVRV5GWllZmkbZarYqOjpaPj488PDzk4eFRtNIaFhYmX1/fSs/l7e1t6iSEs/P09FRQUJAsFkuJt7GX9KysrGpMBmfDSVoAAKBSLVq0SIMHD5b073XDu3XrZm4gFLHZbEpOTtb+/fvNjlIkNjZW/fv3d6nSYrPZii7VVxpfX195enoWFTdvb2/5+fkpNDTUIQ6UoGReXl4lfi80NFQdOnQotawDFHEAAFBpsrOz1bt3bxmGodDQ0KJCDscQExOj0NBQs2OcxtfXVzabTdnZ2S5TXGJiYhQUFKS4uLhSb+fn58fqtItylc8yqg6j6QAAoFLs3LlTgYGBOnz4sPz8/JSQkCAPDw+zY+EUycnJCgkJMTvGWYKCgpSUlGR2jEqRnZ2tjh07qmnTpmZHAeDAKOIAAOC8HTx4UIGBgdq1a5fatm2r1NRU1a5d2+xYOIX9fGVHXKkLCQlxmY2tkpKSFBQUZHYMAA6O0XQAAHBeCgoK1Lt3b/3000+65JJLlJ6ersaNG5sdC2fIyMioks2/KoP94ICzj6fHxcWV69zw6mbfDM/b27vKzz1PS0vTmjVrin4/fPhweXp6Ki4uTvv27ZPVaq2yjegcxak7qjvz5xlViyIOAADOy5AhQ7RkyRLVq1dPixYt0tVXX212JKeTlpam2bNnS/p3E6jc3FyFhIRU6spqZmZmucbS09LSlJGRobVr1yokJKToHGar1arY2FhJUm5urqxWq4YPH16U0WazKSYmpqiAnHn/slgsFmVmZjptcbFarfL09JS3t/c53c++gZ6np6dycnJktVor7c8+Ojq6qPh6eXlpzpw5stls5d4nwF6emzZtqn379hVtQlfSawwODpaXl1fRaQbZ2dm65ppr5Ovrq5SUFHl6eio5Obnokm5hYWFau3atrFarQkNDFRsbWzQZkZWVJU9Pz6LP3Pnkquh9KiIuLq7o74Gvr68yMjLO+v7s2bNltVrVq1cvJSUlKTMzs+hgif0ghv39Kuu5quM1oYoYFZSXl2dIMvLy8ir6EAAAwMklJCQYkgxJxpw5c8yO43RycnIMi8Vi+Pr6Gvv37z/te1FRUUZGRkalPZenp6eRmppaZp7Q0FDDMAwjIyPDkGRkZGQYSUlJRV+3i42NLfp+VlaWERQUdNpryMrKMiQZsbGx5coXFBRkBAUFnduLciAlvT85OTnF3j4nJ8fw9fU1kpKSzvqer6+vERUVdV55SnqM/fv3G6GhoYakYp/bfpvismVkZBienp5GVlbWWfexv94zRUVFGZ6eniU+T2pqqiHJiIqKMqKiooo+Q76+voak0z5TFclVkfuUh6+vr+Hr61vi9z09PYv9/v79+4v+bgUFBRlJSUln/T0PDQ01vL29S3zsqnpNzsJVeihFHAAAVEh6erpRo0YNQ5Ixbty4annOAwcOGNOmTTPWrVtXLc9XlXJyckr8Yd1eas4sd+dDUpk/oIeGhhYVR3tZ8Pb2LrbQ2Yu2r69viQXafv/yiIqKMiwWS7lue6qkpKSig0Hn+6uiBz6SkpLOem/LKuL79+8v8SDF/v37Sy3KZSmryNn/bEt6/NL+TKOioop97JI+y/bPSWmvxdvb+6ximZOTc9aBo4rkqsh9yqOsIm4/wFba9y0WS7GfgZycnFI/j1X1mpyFq/RQijgAADhn69atMy644AJDkvH0008bhYWFVfZchYWFxurVq43+/fsbDRo0MCQZV155ZZU9X3XYv3+/4enpaXh6ep61Em4Y/xYTSUVFZP/+/Ya3t3dRYbGvHnt7excVIPvXLBaL4enpeVqJtxe7kkqh3anFwV4kSyoT9jJX0mswjHMr4rGxsSWunDqykgp1WUW8LL6+vhV6P+wlrqwSX9Jt7MW5pIM29u+fWhLtn6/iDhzZv1faCr/9816aiuSqyH3Kq6wiXp7vl/aaS5omqcrX5CxcpYdyjjgAADgnf/31lwICAnTw4EHde++9evfdd6vkMmW5ubmaMWOG3n33XW3atEm1atXSyZMnJUmGYVT681Wn/v37y2azKSoqqtjzQFNTU5Wbm1u0odWcOXNksViUmpp62u18fHyUm5t71nmoZ24YZj8n18vLq8RMNptNYWFhRb+3P2Zx5+hK/9sAzL4ZV0nfL+/5qlW9iVhViYmJKfE9Oh/2c+YzMzPPaWOztLQ0SarwZmgxMTFFz19SLun0zf9K+7PLzc2VpDIv51bW3gAVyVWR+1Snsl7zvn37zvqao78mlB9FHAAAlNuhQ4cUGBioHTt2qFWrVpo7d67q1KlTaY9fWFior7/+WikpKZo7d65OnjxZVLrtJdzZWa3WorJ0avE91Zk/ZGdlZZ1VwqV/y25xm3r5+fkVbZom/a8MlcbT0/O0x8rMzJSnp2eJP/Dbi3pJP+zbL5cWHBxc5nNL/x4kODWzM0hLS5Ofn1+VPHbLli0l/ftnfC6Fyr7ZV0U37LIftCnrcnJn/ln5+vpq7dq1Z93OfkCmrNdQVt6K5Kroa6kupR0YK4mjvyaUH0UcAACUS2FhoZ544gllZWWpadOmSk9PV5MmTSrlsXft2qUPP/xQSUlJ+uOPP05b/XY19h2lLRZLucqSzWaTj4/PWV+3F92SiuCpj32uP/DbH7u08lRWUbfvAt+rV69yPWdubq7TrYqvWbOmwqvh5b1UW05Ozjk9rr2oVZTVapW3t3epO6sX972kpCS1bNnyrNeVlJSk0NDQ894NvyK5KvpaHJkrviZ3RREHAADlMmzYMM2fP1916tTRggULilbszldERISmTp0qDw8PFRYWSip79XvXrl1VMg5/vuLj4xUREVHqbcq7QmiXmZlZbJktbUXaarUW+/Xyll37Y5dU8st6DVartaiQlbdc22w2p7rsUnJystLS0ooOWpzJXoj9/PyK3oOUlBRZLBaFhYUpOTm5qKSW5lwPTnh7exf9+VRERe9vs9kUGxur6Oho+fn5ydvbW7Nnz5afn1+5LmFX1sGiiuQ63/fCEbnia3JXNcwOAAAAHF9KSoreeustSdK0adN0xx13VNpj7969W4ZhOGSxPlc7d+4s8zb2MfGOHTuW6zGDgoJKPAe7pOtWn1nu7Lcp77hqWSvi9tXukoq6fdX/1NF7+zh+Sfbt21ehUd3k5GR5eHhUyq9zKTihoaHKyclRVlZWsb/sB08yMjKKvmZfFbYfEOnQoUOJj2//szrXA172z1VFV8bP9bNiN3v2bEVFRSkjI6NoBTw1NbXc15GvilwVfS2OzBVfk7uiiAMAgFJlZGTo+eeflyS9+uqreuyxxyr18VNTU5Wdna2wsDBdcMEFkqQaNUr/EeWKK66Q8e/VXxzq15tvvlnm67WXr7JWOm02W4mrrZLOaRMv+3OVt5yVVvLtzy2VXNTtpfvUAwL2cl4S+8jtuQoNDa20P7/zHZ8ur44dO55WzIuTkZEhT0/Pco/229nf89IOfJT2ORg+fLikfzcILM2Zj3/qY5b22amoiuSq6GtxZK74mtwVRRwAAJRo06ZNCgoKUkFBgfr06aORI0dWyfPccsstSkxM1D///KPp06fr9ttvlyTVrFmzSp7PTPZV4tJWX61Wq4KDg0tcMbXf91w2CrNYLOUq4vYf4EsrgNnZ2fL29i62bNlstrNG49PS0srctM1qtVba6Q6OpLiVy6ioqFLPLbfvlp6amnrOo+menp6Kiooq2l27OPY/4+KyWSwWBQUFlZovOTn5rIMIHTt2VHBwcJWt1FYkV0VfiyNzxdfkrijiAACgWLt375a/v7/y8/N1xx136L333qvy8fH69eurT58+Wr58ubZu3aqhQ4cWXfbIVUq5xWJRaGioYmJiziotNptNcXFxio2NLbWElWcztTP5+voW7ahdmrLODy/rue2Z7SXdarUWjSuX5lx3B3d09lMQStqxPiwsTMHBwWcdkLEftIiNja3w+xEbG6tevXoVe/AjOTm56M9o9uzZxRbn1NRUWSyWYu+fmZkpLy+vsw7CREVFyWq1qkmTJqeN+zdp0kQ+Pj6Kjo4usaTn5uaW6yBRRXJV5D7lYbVaS70aQXm+X9Jrtr9PJb1fVfWaUL08jHJeiPPYsWM6duxY0e/z8/PVvHlz5eXlqVGjRlUWEAAAVL8jR47o3nvv1apVq9SyZUutXLlSF110kSlZTpw4ofT0dKWkpOjzzz+XYRi64oor9Oeff5qSp7KkpaVp9uzZ8vLyOq1wh4WFlflDtJ+fn9auXav9+/eX+/kyMzMVHBxc5n2io6OVlpZW4m7dmZmZCgsLU0ZGRqmj69HR0UUr+mWNpWdnZ8vHx8fprw9vf932qQA7i8UiLy+vs673brPZFBMTI6vVKpvNptzcXHXo0EHR0dGVUqSSk5OL/pzsB7SCgoLk5eWlJk2ayNPTU15eXkpKSiq29J96/5YtW8pms8nX17fY1dawsDDl5uYqJCSk6HFzc3OL3oukpCRZrdbTRvKDg4OVmZlZVDjtI+1ZWVnlfl1l5Tqf+xQnOjpaycnJRZm9vb0VFhZWdC58cd+PjY0tujRgcd8/dYXb/ne7pPtXxWtyNvn5+WrcuLF27NhxWg+tW7eu6tata2Kyc1PuIj5mzBi9+uqrZ32dIg4AgGspLCzUo48+qtTUVDVp0kQrV67U9ddfb3YsSdKff/6pDz/8ULfeemuVXb/ZGXh4eCgoKKjYa4uXpkmTJsrKynK41bK4uDjl5OSUWdjhmMLCwuTp6VnmpdzCwsKUmZl5zpdkA05lL+JnGj16tMaMGVP9gSqIFXEAAHCaESNGaNy4capdu7YyMjJ09913mx0Jp7CvHsfGxp7zjtTR0dGSVOFrX1eVli1bFo3bwrnYbDY1adKkXNMM9tvm5OQ43MEgOA9XWREv93XEne2FAQCAc/fhhx9q3Lhxkv69ZBkl3PGsXbtW0rmdH24XFhZWVOIdhX2Hdkq4cyrtPOgzeXp6nvPmc0BJGjVq5NQLwmzWBgAAJElff/110YZaI0aMUN++fU1OhOLYx9ErUly9vb0VGhqq5OTkyo5VYdHR0UpJSTE7BirIvnt+eT5TbCQG/E+5V8QBAIDr2rp1q3r06KETJ04oJCREY8eONTsSTpGcnKysrCxZrdaiXcuDg4Pl5eWl4ODgc1odHz58uO6//3716tXL9NXJzMxMVsNdQEZGhsLCwmSz2Uo8XSI5OVlJSUllbsQGuItynyN+JvtsPueIAwDg3Pbu3avOnTsrJydHnTt31ldffaX69eubHQtVKDs7WzExMee82VtlstlsCg4OPmsncTivtLQ0ZWRkyNPTs2iX9n379slms8nPz6/Ynb+Bc+UqPZQiDgCAGzt27Jh8fX313Xff6eqrr9aqVat0ySWXmB0L1SAtLU1Wq/WcN3yrLGFhYZV2mS4A7sNVeijniAMA4KYMw1C/fv303XffqXHjxkpPT6eEu5GgoCBZLJai6xVXp+zsbMXGxlLCAbgtzhEHAMBNjR07VjNnzlStWrWUlpamtm3bmh0J1awiO69XBs4JB+DuWBEHAMANzZgxQ2PGjJEkTZ061bRCBgCAO6KIAwDgZr777jv169dPkvTSSy+pf//+JicCAMC9UMQBAHAjv/zyi7p166bjx4+rR48eevPNN82OBACA26GIAwDgJnJzc+Xv7699+/apQ4cOmj59umrU4EcBAACqG//1BQDADRw/flw9e/bUtm3b1Lx5cy1atEgNGjQwOxYAAG6JIg4AgIszDENhYWH6+uuvdeGFFyo9PV2XX3652bEAAHBbFHEAAFxcTEyMPvzwQ9WoUUOzZ8/WjTfeaHYkAADcGkUcAAAXNmfOHI0YMUKSFB8fr4cfftjkRAAAgCIOAICLWrlypZ588klJ0sCBA/XCCy+YnAgAAEgUcQAAXNKvv/6qLl266NixYwoMDNTbb79tdiQAAPD/KOIAALgYm82mgIAA7dmzR+3bt9fMmTNVs2ZNs2MBAID/RxEHAMCFnDhxQsHBwdq0aZOuuOIKLV68WBdccIHZsQAAwCko4gAAuAjDMBQeHq7MzEw1bNhQS5YsUbNmzcyOBQAAzkARBwDARYwfP14pKSny8PDQp59+qltuucXsSAAAoBgUcQAAXMD8+fMVFRUlSZowYYICAwNNTgQAAEpCEQcAwMmtXbtWjz/+uAzD0AsvvKAXX3zR7EgAAKAUFHEAAJzYH3/8ocDAQB05ckQPPfSQJk+eLA8PD7NjAQCAUlDEAQBwUvn5+QoICNDff/+tG2+8UbNnz1atWrXMjgUAAMpAEQcAwAmdPHlSjz76qH7++WddeumlWrJkiRo1amR2LAAAUA4UcQAAnIxhGBo4cKA+//xz1a9fX4sXL1aLFi3MjgUAAMqJIg4AgJOJj49XYmKiPDw89Mknn6hjx45mRwIAAOeAIg4AgBNZsmSJBg0aJEmKjY1Vjx49TE4EAADOFUUcAAAn8eOPP+rRRx9VYWGhnn32WQ0dOtTsSAAAoAIo4gAAOIE///xTgYGBOnTokHx9fTV16lQuUwYAgJOiiAMA4OAOHjyowMBA/fnnn2rTpo1SU1NVu3Zts2MBAIAKoogDAODACgoK9Pjjj+vHH3/UxRdfrPT0dHl6epodCwAAnAeKOAAADuyll17SokWLVLduXS1cuFDXXHON2ZEAAMB5oogDAOCg3nnnHU2cOFGS9NFHH+m2224zOREAAKgMFHEAABzQF198ocjISEnS66+/rpCQEJMTAQCAykIRBwDAwfz888/q1auXCgoK1LdvX7388stmRwIAAJWIIg4AgAP5+++/FRAQoAMHDujuu+9WcnIylykDAMDFUMQBAHAQhw8fVpcuXfTHH3/o+uuv17x581SnTh2zYwEAgEpGEQcAwAEUFhbqySef1Jo1a+Tl5aX09HR5eXmZHQsAAFQBijgAAA7g5Zdf1ty5c1WnTh0tWLBA1157rdmRAABAFaGIAwBgsvfee0+xsbGSpPfff1933nmnyYkAAEBVoogDAGCipUuX6vnnn5ckjRo1Sn369DE5EQAAqGoUcQAATLJ582b17NlTJ0+e1GOPPaYxY8aYHQkAAFQDijgAACb4559/5O/vr7y8PP3nP//R+++/z2XKAABwExRxAACq2dGjR9WtWzf9+uuv8vb21vz581WvXj2zYwEAXEB2drZsNpvbPK+zoogDAFCNCgsL9fTTT+uHH36Qp6en0tPTdfHFF5sdCwDgAjIzM5WZmSlPT89qf26LxaL+/ftTxsuJIg4AQDUaPXq0Zs2apVq1amnevHlq3bq12ZEAAC7AarUqKSlJUVFRpmVISUlRcHCwac/vTCjiAABUk48//livv/66JCk5OVn33nuvyYkAAK4iODhYKSkppmbw9PRUWFiYwsLCTM3hDCjiAABUg2+++UbPPvusJGn48OF6+umnTU4EAHAV0dHRCgkJMWUk/UxBQUFau3atsrOzzY7i0DwMwzAqcsf8/Hw1btxYeXl5atSoUWXnAgDAZWzbtk2dO3fW/v37FRwcrFmzZqlGDY6FAwDOn81m0zXXXKP9+/ebHaVIZmamoqOjlZWVVemP7So9lJ8CAACoQvv27ZO/v7/279+vTp066aOPPqKEAwAqTUxMjEJDQ82OcRpfX1/ZbDZWxUvBTwIAAFSRY8eOqXv37vrll1901VVXaeHChapfv77ZsQAALiQ5OVkhISFmxzhLUFCQkpKSzI7hsCjiAABUAcMw1L9/fy1fvlyNGjVSenq6Lr30UrNjAQBcSGZmpqR/Lx3maEJCQpScnGx2DIdFEQcAoAq8/vrrmj59umrWrKm0tDTdcMMNZkcCALiYjIwM+fr6mh2jWPaDA4ynF6+W2QEAAHA1n376qUaNGiVJmjp1qvz8/ExOBACQpLS0NM2ePVuS5OXlpdzcXIWEhCgoKMjkZBWTmZlZrrH0tLQ0ZWRkaO3atQoJCSm61rjValVsbKwkKTc3V1arVcOHDy96P2w2m2JiYmSz2STprPuXxWKxKDMz0yFX7M1GEQcAoBKtWLFCTz31lCRpyJAhDreBDgC4I6vVquDgYHl5eSk1NfW0y3xFR0fL09PTYVeWS2O1WuXt7V3mbTIyMpSUlKTMzEz5+fnJYrHIarUqKyvrtPO44+LiFBwcrIyMDHl5eSkmJkYpKSlF71d2drZ8fHwkqVxl3NvbW2vWrKn4C3RhjKYDAFBJcnJy1K1bNx0/flzdunUrWmUAAJjHarXKx8dHXl5eysjIOK2Ex8XFKS4uTqmpqeYFPA82m63MIh4bG6vo6OjTvhYWFqacnJyzNlOzH4yIjY1VTEzMWQct7Cvb5d2EzdvbW1artVy3dTesiAMAUAn2798vf39/7d27Vz4+Pvrkk09Us2ZNs2MBgFuz2WxFK7jFlW17obSfQnTq7b29vU9bCc7NzVWHDh2Kvma1WmW1WtWrVy9Tdge3j4ufWpSLc+qquf18bW9v72IPFufm5kr6dwT9119/Pe+MTZs2pYiXgCIOAMB5On78uHr27KmtW7eqWbNmWrRokRo2bGh2LABwe/3795fNZlNUVFSxhTU1NVW5ublFK8Fz5syRxWI5q7T7+PgoNzdXGRkZp339zJXmymQfp1+6dGmx2e0F18vLq8THsNlsCgsLK/q9PX9JE1v2oj58+PBin/PUIl8eZR0kcGcUcQAAzoNhGHr++ee1bNkyXXDBBVqyZImuuOIKs2MBgNuzWq1KS0uTpNPK6KnO3EQsKyur2JXz7OzsYjd08/PzK1qZriz2c9mtVmupO47bV69L4+npeVruzMxMeXp6lrh5mr2ol3S+vP1yacHBwWU+t/TvQYLKfn9cBUUcAIDzEBcXpw8++EA1atTQ7NmzdfPNN5sdCQBcXlZWlrKyskrdENM+Lm6xWMq1gnvqWPqp7OWzpCtglHd1uLzsBwLS0tKKnrs4pa2EF8f+WKVtSldWUbfvON+rV69yPWdubi6r4iVgszYAACooLS1Nw4YNkyRNnjxZjzzyiMmJAMC15ebm6vnnn1fHjh0VHh6uLVu2lHhb+2pyeXdDz8zMLLZglrZKbLVaTb80V3lWxqX/vY6SDiiU9X7ZV+gtFku5y3V5NpNzVxRxAAAqYNWqVXriiSckSZGRkYqIiDA5EQC4rsLCQqWkpOj666/Xu+++K8MwFBwcrMaNG5d4H3tB7dixY7meIygoqMTzoj09PYstlGZeotKep7yj32WtiNtXu0sq6vYJg1PH/O2j/yXZt2/fOa/cuwuKOAAA5+i3335Tly5ddPToUfn7+2vixIlmRwIAl7VmzRp17txZoaGh2rdvn2644QYtW7ZMM2fO1OWXX17i/Tp06CCp7A3DbDZbqSPgmZmZDnmN8VN3by+P0g4oSGUXdXvpPvXgQ1m7xZfnOufuiiIOAMA5yMvLU0BAgP755x/dfPPN+vTTT7lMGQBUgb179yo0NFSdOnXSmjVrdOGFF2rixIn68ccfdc8995R5f/vKbWkbntl3JreX9jPZ71vSKrHZLBZLuYq4vUSXdm53dna2vL29iy3ONptNVqv1tJKelpZW5qZtVqtVLVu2LDOfO6KIAwBQTidOnFCvXr20ceNGXX755VqyZIkuvPBCs2MBgEspKCjQu+++q1atWiklJUWGYahPnz7aunWrBg4cqNq1a5frcSwWi0JDQxUTE3PW+LbNZlNcXJxiY2OVmppa4qp5eTY4M5Ovr6/WrFlT5u3KOj+8rNdpf3/sJd1qtSojI6PM0fzs7GyHfe/Mxq7pAACUg2EYioyM1H//+181aNBAixcvVrNmzcyOBQAuZeXKlYqIiFBWVpYk6cYbb1RiYqLuvPPOCj1eUlKS/Pz81L9/f3l5eZ1WuMPCwsocm87IyCh1nPtUJe26XpqgoKASr+ldHn5+fuW6lJj9NRR3CTY7b2/vUq+LnpGRoejo6KJJg7LG0u3TBGZvZueoPAzDMCpyx/z8fDVu3Fh5eXlq1KhRZecCAMChTJgwQUOGDJGHh4fmz5+vrl27mh0JAFzGnj17NGzYMH3wwQeSpEaNGum1117TCy+8oFq1zFs79PDwUFBQULHXFq9q9tHv/fv3l3qee5MmTZSVleVw52LHxcUpJyenzMJ+rlylhzKaDgBAGRYuXKihQ4dKkt5++21KOABUkoKCAiUmJur6668vKuF9+/bVtm3bNGDAAFNLuH1Ft7y7rpslNDS00stuZUhKSjpth3WcjiIOAEApsrKy9Nhjj8kwDD333HMaNGiQ2ZEAwCV8//336tChgyIiImSz2dS+fXutWLFCH374oS699FKz42nt2rWSHPf8cLuwsDAlJyebHeM09h3aGUsvGUUcAIAS7NixQ4GBgTp8+LAeeOABTZkyRR4eHmbHAgCntnv3bj311FP6z3/+o59++kmenp5KSEjQ2rVrdfvtt5sdr4h9HN2sMmm/Drr9f0vi7e2t0NBQhyrj0dHRSklJMTuGQ2OzNgAAinHgwAEFBgbqr7/+0g033KA5c+aUe6deAMDZTp48qalTp2rUqFHKy8uTJPXr109vvvmmLr74YpPT/Ss5OVlZWVmyWq1FO4kHBwfLy8tLwcHB1bI6HhYWptzc3NOev0OHDvLx8Slxl/Lhw4fr/vvvV69evcq8bnpVy8zMZDW8HNisDQCAM5w8eVLdunVTenq6LrnkEq1evVpXXXWV2bEAwGktX75cERERWr9+vaR/V5kTExPVuXNnk5O5juzsbMXExJiysZydzWZTcHBw0eXSqoKr9FBG0wEAOMPgwYOVnp6uevXqadGiRZRwAKigv//+W08++aTuuusurV+/Xk2aNNE777yj1atXU8IrmcViUUhIiOLi4kzLEB0d7ZAbxzkiijgAAKeIj49XfHy8JGn69Onq1KmTyYkAwPmcOHFCkyZNUqtWrTR9+nR5eHiof//+2rZtm5577jnVrFnT7IguKSgoSBaLRTabrdqfOzs7W7GxsQ53GTVHxTniAAD8v/T0dA0cOFCS9OabbyooKMjcQADghL755htFRERow4YNkv69/FdiYqLDXwbMVZi1yzvnhJ8bVsQBAJC0bt06PfrooyosLNQzzzyjqKgosyMBgFPZtWuXHn/8cd1zzz3asGGDmjZtquTkZK1cuZISDpyBIg4AcHu7du1SQECADh48qPvuu09Tp07lMmUAUE4nTpzQ+PHj1apVK82cOVMeHh567rnntHXrVvXv3181alA5gDMxmg4AcGuHDh1SYGCgdu7cqdatWystLU116tQxOxYAOIWvvvpKERER2rx5sySpU6dOSkxMlI+Pj8nJAMfG4SkAgNsqKCjQ448/ruzsbF100UVKT09XkyZNzI4FAA5v586devTRR3X//fdr8+bNuuiii/T+++/r+++/p4QD5UARBwC4rejoaC1cuFB169bVwoUL2ekVAMpw/PhxxcXFqXXr1po9e7Zq1Kih8PBwbdu2Tf369WMMHSgnRtMBAG4pKSlJ48ePlyRNmzZNt99+u8mJAMCxZWZmKjIyUlu2bJEk3X777UpISNAtt9xicjLA+XDICgDgdv773/8qPDxckjR27Fj17t3b5EQA4Lh27Nih4OBg+fn5acuWLbrkkkv04Ycfavny5ZRwoIIo4gAAt7JhwwYFBweroKBATzzxhF555RWzIwGAQzp27JhiYmKKNrKsUaOGBgwYoK1bt6pv376MoQPngdF0AIDb2L17twICApSfn6+77rpLKSkpXKYMAIrx5ZdfKjIyUtu3b5ck3XHHHUpMTNRNN91kcjLANXAYCwDgFo4cOaKuXbvq999/17XXXqt58+apbt26ZscCAIfy+++/q0ePHnrooYe0fft2XXbZZZo+fbq+/fZbSjhQiSjiAACXV1hYqCeffFKrVq2Sl5eX0tPT1bRpU7NjAYDDOHr0qF5//XW1adNG8+fPV82aNTVo0CBt3bpVffr0YXoIqGSMpgMAXN4rr7yitLQ01a5dW/Pnz9f1119vdiQAcBifffaZBgwYoJycHEnSXXfdpcTERLVr187kZIDrYkUcAODSpk2bppiYGEnSe++9p7vuusvkRADgGH799Vd17dpV/v7+ysnJ0eWXX66ZM2fq66+/poQDVYwiDgBwWcuWLVNoaKikf1fFn3zySZMTAYD5jhw5oldffVVt27bVokWLVKtWLQ0dOlRbt25V7969GUMHqgGj6QAAl7Rlyxb16NFDJ0+e1KOPPqqxY8eaHQkATLd48WK9+OKL+vXXXyVJ9957rxISEtS2bVuTkwHuhRVxAIDL2bNnj/z9/WWz2XTbbbdp2rRprPAAcGs5OTkKCAhQly5d9Ouvv+rKK6/U7NmztXTpUko4YAKKOADApRw9elTdu3eX1WrVNddco4ULF6pevXpmxwIAUxw+fFijRo3SDTfcoPT0dNWuXVvR0dHasmWLevXqxUFKwCSMpgMAXIZhGHrmmWe0YsUKNW7cWOnp6br44ovNjgUA1c4wDC1cuFADBw7U77//Lkny9fVVfHy8WrdubXI6ABRxAIDLGDNmjGbOnKlatWpp7ty5atOmjdmRAKDabd++XQMGDNAXX3whSWrevLkmTJignj17sgIOOIhyF/Fjx47p2LFjRb/Pz8+vkkAAAFTEJ598UrQh27vvvqv777/f5EQAUL0OHTqkcePG6e2339bx48dVu3ZtDR06VCNGjFDDhg3NjgdUqjP7aN26dVW3bl2T0py7cp8jHhMTo8aNGxf9at68eVXmAgCg3JYvX65nnnlGkhQdHV30/wHAHRiGoblz56pt27YaN26cjh8/rgcffFAbNmzQuHHjKOFwSc2bNz+tn8bExJgd6Zx4GIZhlOeGxa2IN2/eXHl5eWrUqFGVBQQAoDS//PKLOnXqpNzcXPXs2VNz5sxRjRrsRQrAPWzdulWRkZHKyMiQJLVo0UKTJk1St27dGEOHS8rPz1fjxo21Y8eO03qos62Il3s03dleGADA9eXm5srf31+5ubnq2LGjPv74Y0o4ALdw8OBBvf7665owYYJOnDihOnXqKCoqSsOHD1eDBg3MjgdUuUaNGjn1gjCbtQEAnNLx48fVo0cPbdu2TS1atNCiRYv44ROAyzMMQ2lpaRo8eLB27twpSXrkkUc0efJkXXvttSanA1BeFHEAgNMxDEOhoaH65ptvdOGFFyo9PV2XXXaZ2bEAoEpt3rxZkZGRWrp0qSTp6quv1uTJkxUYGMgYOuBkmN8DADidcePG6aOPPlLNmjWVmpqqdu3amR0JAKrMgQMH9NJLL+mmm27S0qVLVbduXY0ePVqbNm1Sly5dKOGAE2JFHADgVGbPnq1XXnlFkhQfH68HH3zQ5EQAUDUMw9Ds2bM1ZMgQ7dq1S5IUGBioSZMmydvb2+R0AM4HRRwA4DR++OEH9e3bV5I0aNAgPf/88yYnAoCqsXHjRkVGRmrZsmWSJG9vb02ZMkX+/v4mJwNQGRhNBwA4BavVqq5du+rYsWPq0qWL3nrrLbMjAUCly8/P15AhQ9S+fXstW7ZM9erV09ixY7Vx40ZKOOBCWBEHADg8m82mgIAA7dmzR7fccotmzJihmjVrmh0LACqNYRiaOXOmhg4dqr///luS1K1bN02cOFFXX321ueEAVDqKOADAoZ04cUJBQUHavHmzrrzySi1evFgXXHCB2bEAoNL8/PPPioiI0LfffitJuvbaaxUfH6+HHnrI5GQAqgqj6QAAh2UYhl544QUtXbpUDRs21JIlS3TllVeaHQsAKkVeXp4GDhyoW265Rd9++63q16+vN954Qxs2bKCEAy6OFXEAgMN6++239d5776lGjRqaNWuW2rdvb3YkADhvhmFo+vTpioqK0u7duyVJPXv21IQJE9SiRQuT0wGoDhRxAIBDmjdvnqKjoyVJEydOVEBAgMmJAOD8rVu3TuHh4VqxYoUkqVWrVpoyZYoeeOABk5MBqE6MpgMAHM6aNWvUp08fGYah8PBwRUZGmh0JAM6LzWZTZGSkLBaLVqxYoYYNG+rNN9/U+vXrKeGAG2JFHADgUP744w8FBgbqyJEjevjhhzVp0iR5eHiYHQsAKqSwsFAfffSRoqOjtWfPHklSr169NH78eDVr1szkdADMQhEHADiM/Px8+fv7a/fu3brxxhs1e/Zs1arFf6oAOKfs7GyFh4dr5cqVkqQ2bdooPj5e999/v8nJAJiN0XQAgEM4efKkQkJCtGHDBl122WVasmSJLrzwQrNjAcA5y83N1QsvvKAOHTpo5cqVuuCCC/TWW2/pp59+ooQDkMSKOADAARiGoRdffFFffPGF6tevr8WLF7NzMACnU1hYqA8++EDDhw/X3r17JUm9e/fWW2+9xaUXAZyGIg4AMN3kyZM1depUeXh4aMaMGerQoYPZkQDgnKxdu1bh4eFavXq1JOmGG25QQkKC7rnnHnODAXBIjKYDAEy1ePFiDR48WJIUFxen7t27m5wIAMpv3759CgsL06233qrVq1frwgsv1IQJE/Tjjz9SwgGUiBVxAIBpfvzxR/Xu3VuGYSg0NFRDhgwxOxIAlEtBQYHee+89vfzyy8rNzZUk9enTR3Fxcbr88stNTgfA0VHEAQCm2LlzpwICAnTo0CH5+fkpISGBy5QBcAqrV69WeHi41q5dK0m68cYblZiYqDvvvNPkZACcBaPpAIBqd/DgQQUGBmrXrl1q27atUlNTVbt2bbNjAUCp9uzZo/79+6tz585au3atGjVqpMmTJys7O5sSDuCcsCIOAKhWBQUFeuyxx/TTTz/pkksuUXp6uho3bmx2LAAoUUFBgZKSkvTKK69o//79kqS+ffsqNjZWl156qcnpADgjijgAoFoNHTpUixcvVr169bRw4UJdffXVZkcCgBL98MMPioiIUHZ2tiSpffv2SkhI0H/+8x+TkwFwZoymAwCqzdSpUzVp0iRJ0kcffaTOnTubGwgASvDPP/+oX79+uv3225Wdna3GjRsrPj5ea9asoYQDOG+siAMAqsXnn3+uyMhISdIbb7yhXr16mZwIAM528uRJvfPOOxo5cqTy8vIkSf369VNMTIwuueQSk9MBcBUUcQBAlVu/fr169eqlwsJCPfXUUxo+fLjZkQDgLCtWrFB4eLjWrVsnSbJYLEpMTGR6B0ClYzQdAFCl/vrrLwUEBOjgwYO65557lJSUxGXKADiU3bt3q2/fvrrjjju0bt06NWnSRFOnTtXq1asp4QCqBCviAIAqc+jQIXXp0kU7duzQ9ddfr7lz56pOnTpmxwIASf+OoScmJmrUqFHKz8+Xh4eHnn32WY0bN04XXXSR2fEAuDCKOACgShQWFuqJJ57Q2rVr1bRpU3322Wfy8vIyOxYASJK+/fZbRURE6Oeff5YkdejQQYmJibr11ltNTgbAHTCaDgCoEsOGDdP8+fNVp04dLViwQC1btjQ7EgDor7/+Up8+fXT33Xfr559/lpeXl5KSkrRy5UpKOIBqQxEHAFS6lJQUvfXWW5KkDz74QHfccYfJiQC4uxMnTmjChAlq1aqVZsyYIQ8PD4WFhWnbtm0KDQ1VzZo1zY4IwI0wmg4AqFSZmZl6/vnnJUljxozR448/bnIiAO7u66+/VkREhDZu3ChJ6tSpkxISEtShQweTkwFwV6yIAwAqzaZNmxQUFKSCggI9/vjjGjVqlNmRALixP//8U71799a9996rjRs36qKLLtJ7772n77//nhIOwFQUcQBApfjnn3/k7++vvLw83XHHHXr//fe5TBkAUxw/flxvvfWWWrdurVmzZqlGjRp64YUXtHXrVj3zzDOqUYMfgQGYi9F0AMB5O3LkiLp27arffvtNLVu21Pz581W3bl2zYwFwQ0uXLlVERIS2bNkiSbrtttuUmJioW265xeRkAPA/HA4EAJyXwsJCPfXUU1q5cqWaNGmi9PR0rr8LoNrt2LFDvXr1kq+vr7Zs2aKLL75Y06ZN03fffUcJB+BwKOIAgPMyatQozZkzR7Vr19a8efPUqlUrsyMBcCPHjx/Xm2++qdatWys1NVU1atRQZGSktm3bpqeeeooxdAAOidF0AECFffjhh3rjjTckScnJybrnnnvMDQTArfz3v/8tKt2SdMcddyghIUE333yzyckAoHQcIgQAVMjXX3+t0NBQSdLLL7+sp556ytxAANzGH3/8oZ49e+rBBx/Utm3bdOmll+rjjz/Wt99+SwkH4BQo4gCAc7Z161b16NFDJ06cUK9evfTaa6+ZHQmAGzh27JjeeOMNtW7dWvPmzVPNmjU1cOBAbd26VU888QRXagDgNBhNBwCck71798rf31/79+9X586d9eGHH3IOJoAq9/nnn2vAgAH65ZdfJEl33XWXEhISdOONN5qcDADOHT85AQDK7dixY+revbtycnJ09dVXa+HChapfv77ZsQC4sN9++03dunXTI488ol9++UWXX365ZsyYoa+//poSDsBpUcQBAOViGIaeffZZfffdd2rUqJHS09N1ySWXmB0LgIs6evSoxo4dqzZt2mjhwoWqVauWhgwZoi1btuixxx5jDB2AU2M0HQBQLmPHjtUnn3yimjVrKi0tTW3btjU7EgAXtWTJEr344ouyWq2SpHvvvVcJCQn8uwPAZbAiDgAo04wZMzRmzBhJ0jvvvCM/Pz9zAwFwSVarVYGBgQoMDJTVatUVV1yhWbNmaenSpZRwAC6FIg4AKNV3332nfv36SZKGDh2q/v37m5wIgKs5cuSIxowZo7Zt22rJkiWqVauWoqKitHXrVoWEhDCGDsDlMJoOAChRTk6OunXrpuPHj6t79+6KjY01OxIAF2IYhhYvXqyBAwfq119/lST5+voqPj5erVu3NjkdAFQdijgAoFj79++Xv7+/9u3bpw4dOuiTTz7hMmUAKs0vv/yiAQMG6PPPP5ckNWvWTBMnTlTPnj1ZAQfg8viJCgBwluPHj6tHjx7aunWrmjdvrkWLFqlBgwZmxwLgAg4fPqyRI0fqhhtu0Oeff67atWtr+PDh2rJli4KCgijhANwCK+IAgNMYhqHnnntOX3/9tS688EItWbJEl19+udmxADg5wzC0YMECDRo0SL///rsk6cEHH9SUKVN0/fXXm5wOAKoXRRwAcJo333xT06ZNU40aNTR79mzddNNNZkcC4OS2bdumAQMG6Msvv5QktWjRQpMmTVK3bt1YAQfglhhNBwAUSU1N1csvvyxJmjJlih5++GGTEwFwZocOHdLLL7+sdu3a6csvv1SdOnU0YsQIbd68Wd27d6eEA3BbrIgDACRJK1eu1JNPPilJevHFFxUeHm5yIgDOyjAMzZ07V4MHD9aOHTskSQ8//LAmT56s6667zuR0AGA+ijgAQL/99pu6du2qo0ePKiAgQOPHjzc7EgAntWXLFkVGRiozM1OSdPXVV2vy5MkKDAxkBRwA/h+j6QDg5vLy8uTv769//vlH7du316effqqaNWuaHQuAkzl48KCio6N10003KTMzU3Xr1tWoUaO0adMmdenShRIOAKdgRRwA3NiJEycUHBysTZs26YorrtDixYt1wQUXmB0LgBMxDENz5szRkCFD9Oeff0qSAgICNGnSJLVs2dLkdADgmCjiAOCmDMNQRESEMjIy1KBBAy1evFjNmjUzOxYAJ7Jp0yZFRkbqq6++kiR5e3tr8uTJCggIMDkZADg2RtMBwE1NmDBBycnJ8vDw0KeffiqLxWJ2JABO4sCBAxo6dKhuvvlmffXVV6pXr55effVVbdy4kRIOAOXAijgAuKEFCxbopZdekvRvIe/SpYvJiQA4A8Mw9Omnn2ro0KH666+/JEldu3bVxIkTdc0115icDgCcB0UcANxMVlaWHnvsMRmGoeeff14vvvii2ZEAOIENGzYoIiJC33zzjSTp2muv1ZQpU/Twww+bnAwAnA+j6QDgRnbs2KHAwEAdOXJEDz30kKZMmcJOxgBKlZ+fr8GDB6t9+/b65ptvVL9+fb3++uvasGEDJRwAKogVcQBwEwcOHFBAQID++usvtWvXTrNnz1atWvxnAEDxDMPQjBkz9NJLL+nvv/+WJPXo0UMTJkzQVVddZXI6AHBu/AQGAG7g5MmTCgkJ0fr163XppZdqyZIlatSokdmxADio9evXKyIiQsuXL5ckXXfddYqPj9eDDz5ocjIAcA2MpgOAGxg0aJA+//xz1a9fX4sXL2Y1C0Cx8vLyNHDgQFksFi1fvlwNGjTQuHHj9PPPP1PCAaASsSIOAC5uypQpSkhIkCRNnz5dHTt2NDkRAEdjGIamT5+uqKgo7d69W5IUFBSk8ePHq0WLFianAwDXQxEHABe2ZMkSDRo0SJIUGxurnj17mpwIgKNZt26dwsPDtWLFCklSq1atFB8fLz8/P5OTAYDrYjQdAFzUTz/9pEcffVSFhYV69tlni64bDgCSZLPZFBkZKYvFohUrVqhhw4aKjY3V+vXrKeEAUMVYEQcAF7Rr1y4FBATo0KFDuv/++zV16lQuUwZAklRYWKiPPvpI0dHR2rNnjySpV69eGj9+vJo1a2ZyOgBwDxRxAHAxhw4dUmBgoP7880+1bt1aaWlpql27ttmxADiA7OxsRURE6IcffpAktWnTRvHx8br//vtNTgYA7oXRdABwIQUFBXrssceUnZ2tiy++WOnp6fL09DQ7FgCT7d+/X+Hh4erYsaN++OEHXXDBBXrrrbf0008/UcIBwASsiAOAC4mKitKiRYtUt25dLVy4UN7e3mZHAmCiwsJCTZs2TcOGDdPevXslSb1799Zbb72lK6+80uR0AOC+KOIA4CLeffddTZgwQZL00Ucf6bbbbjM5EQAzZWVlKTw8XKtWrZIk3XDDDUpISNA999xjbjAAAKPpAOAKvvzyS0VEREiSXnvtNYWEhJicCIBZ9u3bp+eee04dO3bUqlWrdOGFF2r8+PH68ccfKeEA4CBYEQcAJ7dhwwYFBweroKBAffv21YgRI8yOBMAEhYWFev/99zV8+HDt27dPkvT444/rrbfe0uWXX25yOgDAqSjiAODE/v77b/n7++vAgQO6++67lZyczGXKADe0Zs0ahYeHa82aNZKkdu3aKTExUXfddZfJyQAAxWE0HQCc1OHDh9W1a1f98ccfuu666zR37lzVqVPH7FgAqtHevXsVGhqqTp06ac2aNWrUqJEmTpyo7OxsSjgAODBWxAHACRUWFurJJ5/U6tWr5eXlpfT0dDVt2tTsWACqSUFBgd577z29/PLLys3NlSQ98cQTiouL02WXXWZyOgBAWSjiAOCEXn75Zc2dO1e1a9fW/Pnzdd1115kdCUA1WbVqlcLDw5WVlSVJuummm5SYmKg77rjD5GQAgPJiNB0AnMz777+v2NhYSdIHH3zA+CngJvbs2aNnn31WnTt3VlZWlho1aqQpU6YoKyuLEg4AToYVcQBwIkuXLtVzzz0nSRo1apT69OljciIAVa2goEBJSUl65ZVXtH//fklS3759FRsbq0svvdTkdACAiqCIA4CT2Lx5s3r27KmTJ0+qd+/eGjNmjNmRAFSxH374QREREcrOzpYktW/fXomJibr99ttNTgYAOB+MpgOAE9izZ4/8/f2Vl5en22+/XR988AGXKQNc2D///KN+/frp9ttvV3Z2tjw9PZWQkKC1a9dSwgHABbAiDgAO7ujRo+rWrZt+/fVXeXt7a8GCBapXr57ZsQBUgZMnT+rdd9/VyJEjZbPZJEn9+vVTTEyMLrnkEnPDAQAqDUUcAByYYRh6+umn9f3338vT01Pp6em6+OKLzY4FoAqsWLFC4eHhWrdunSTJYrEoMTFRnTt3NjkZAKCyMZoOAA5s9OjRmjVrlmrVqqW5c+eqdevWZkcCUMl2796tvn376o477tC6devUpEkTTZ06VatXr6aEA4CLYkUcABzUxx9/rNdee02SlJSUpPvuu8/kRAAq08mTJzV16lSNHDlS+fn58vDw0DPPPKOYmBhddNFFZscDAFQhijgAOKBvv/1Wzz77rCRp2LBh6tevn8mJAFSm5cuXKyIiQuvXr5ckdejQQYmJibr11ltNTgYAqA6MpgOAg9m+fbu6d++uEydOKCgoSG+88YbZkQBUkr/++ktPPPGE7rrrLq1fv15eXl5KSkrSypUrKeEA4EYo4gDgQPbt26dHHnlEubm5uvXWW/Xxxx+rRg3+qQac3YkTJzRx4kS1atVKn3zyiTw8PBQaGqpt27YpNDRUNWvWNDsiAKAaMZoOAA7i2LFj6t69u3755RddddVVWrRokerXr292LADn6ZtvvlFERIQ2bNggSerYsaMSExPVsWNHk5MBAMzCMgsAOADDMNS/f38tX75cjRo10pIlS3TppZeaHQvAedi1a5cef/xx3XPPPdqwYYOaNm2qlJQUrVy5khIOAG6OIg4ADuCNN97Q9OnTVbNmTaWmpqpdu3ZmRwJQQSdOnND48ePVqlUrzZw5Ux4eHnruuee0bds2Pfvss5xuAgBgNB0AzPbpp59q5MiRkqTExEQ98MADJicCUFHLli1TRESENm3aJEnq1KmTEhMT5ePjY3IyAIAj4ZAsAJjo+++/19NPPy1JGjx4sMLCwkxOBKAi/vzzTz366KO67777tGnTJl100UV6//339f3331PCAQBnoYgDgEmsVqu6du2qY8eOqWvXroqLizM7EoBzdPz4cb311ltq1aqVZs+erRo1aig8PFzbtm1Tv379GEMHABSr3KPpx44d07Fjx4p+n5+fXyWBAMAd7N+/X/7+/tq7d68sFotmzJjB5YsAJ7N06VJFRERoy5YtkqTbbrtNiYmJuuWWW0xOBgCu78w+WrduXdWtW9ekNOeu3IdpY2Ji1Lhx46JfzZs3r8pcAOCyjh8/rqCgIG3ZskXNmjXT4sWL1bBhQ7NjASinnTt3qlevXvL19dWWLVt08cUXa9q0afruu+8o4QBQTZo3b35aP42JiTE70jnxMAzDKM8Ni1sRb968ufLy8tSoUaMqCwgArsR+mbL3339fF1xwgb777jvdfPPNZscCUA7Hjx/XxIkT9dprr+nQoUNFY+hjx46Vp6en2fEAwC3k5+ercePG2rFjx2k91NlWxMs9mu5sLwwAHFFcXJzef/991ahRQ7NmzaKEA04iIyNDkZGR2rp1qyTpjjvuUEJCAn+HAcAkjRo1cuoFYXYQAYBqkpaWpmHDhkmSJk2aJH9/f5MTASjLH3/8oaCgID3wwAPaunWrLr30Un388cf69ttvKeEAgAqjiANANVi9erWeeOIJSVJkZKQiIyNNTgSgNMeOHdO4cePUpk0bzZ07VzVr1tTAgQO1detWPfHEE/Lw8DA7IgDAiZV7NB0AUDG///67unTpoqNHj+qRRx7RhAkTzI4EoBRffPGFBgwYoO3bt0uS7rzzTiUmJurGG280ORkAwFWwIg4AVSgvL0/+/v7avXu3br75Zs2aNUu1anEMFHBEv//+u3r06KGHH35Y27dv12WXXaZPPvlE33zzDSUcAFCpKOIAUEVOnjypkJAQbdy4UZdffrkWL16sCy+80OxYAM5w9OhRvf7662rTpo3mz5+vmjVratCgQdq6dasef/xxxtABAJWOZRkAqAKGYSgyMlJffvmlGjRooMWLF6t58+ZmxwJwhs8++0wDBgxQTk6OJOnuu+9WQkKC2rVrZ3IyAIArY0UcAKrApEmT9O6778rDw0MzZsyQj4+P2ZEAnOLXX39V165d5e/vr5ycHF1++eWaOXOmli1bRgkHAFQ5ijgAVLKFCxdqyJAhkqS33npL3bp1MzcQgCJHjhzRq6++qrZt22rRokWqVauWhg4dqq1bt6p3796MoQMAqgWj6QBQibKzs/XYY4/JMAyFhYVp8ODBZkcC8P+WLFmiF198UVarVZJ07733KiEhQW3btjU5GQDA3bAiDgCVZOfOnQoMDNThw4f1wAMPKD4+ntU1wAFYrVYFBgYqMDBQVqtVV155pWbNmqWlS5dSwgEApqCIA0AlOHDggAICArRr1y7dcMMNmjNnjmrXrm12LMCtHTlyRKNHj1bbtm21ZMkS1apVS1FRUdqyZYtCQkI4UAYAMA2j6QBwngoKCtS7d2+tW7dOl1xyiZYsWaLGjRubHQtwW4ZhaNGiRRo4cKB+++03SZKvr6/i4+PVunVrc8MBACCKOACct8GDBys9PV316tXTokWLdPXVV5sdCXBbv/zyi1588UV99tlnkqRmzZpp4sSJ6tmzJyvgAACHwWg6AJyHhIQETZkyRZI0ffp0derUyeREgHs6fPiwRo4cqRtuuEGfffaZateurWHDhmnLli0KCgqihAMAHAor4gBQQZ999plefPFFSVJMTIyCgoJMTgS4H8MwtHDhQg0cOFC///67JOmBBx7QlClT1KpVK5PTAQBQPIo4AFTAunXrFBISosLCQvXr10/R0dFmRwLczvbt2zVgwAB98cUXkqQWLVpo4sSJ6t69OyvgAACHxmg6AJyjv/76SwEBATp48KDuvfdevfPOO/zQD1SjQ4cOacSIEWrXrp2++OIL1alTRyNGjNDmzZvVo0cP/j4CABweK+IAcA4OHTqkwMBA7dy5U61atdLcuXNVp04ds2MBbsEwDM2bN0+DBg3Sjh07JEkPPfSQpkyZouuuu87kdAAAlB9FHADKqaCgQH369FFWVpYuuugipaenq0mTJmbHAtzC1q1bFRkZqYyMDEnSVVddpUmTJqlr166sgAMAnA6j6QBQTsOGDdOCBQtUp04dLViwQC1btjQ7EuDyDh48qGHDhunGG29URkaG6tatq5EjR2rTpk3q1q0bJRwA4JRYEQeAckhOTtbbb78tSfrwww/1n//8x+REgGszDENpaWkaPHiwdu7cKUl65JFHNHnyZF177bUmpwMA4PxQxAGgDBkZGXrhhRckSa+++qp69+5tciLAtW3evFmRkZFaunSpJOnqq6/W5MmTFRgYyAo4AMAlMJoOAKXYuHGjgoKCis4PHzlypNmRAJd14MABRUVF6aabbtLSpUtVt25djR49Wps2bVKXLl0o4QAAl8GKOACUYPfu3fL391d+fr7uvPNOvffeexQBoAoYhqHZs2dryJAh2rVrlyQpMDBQkyZNkre3t8npAACofBRxACjGkSNH1LVrV/3++++69tprNX/+fNWtW9fsWIDL2bhxoyIjI7Vs2TJJkre3t6ZMmSJ/f3+TkwEAUHUYTQeAMxQWFqpv375atWqVmjRpovT0dDVt2tTsWIBLOXDggIYOHar27dtr2bJlqlevnl599VVt3LiREg4AcHmsiAPAGV555RWlpqaqdu3amj9/vq6//nqzIwEuwzAMffrppxo6dKj++usvSVLXrl01ceJEXXPNNSanAwCgelDEAeAU06ZNU0xMjCQpJSVFd999t8mJANexYcMGRURE6JtvvpEkXXvttZoyZYoefvhhk5MBAFC9GE0HgP+3bNkyhYaGSpJGjBihvn37mpwIcA15eXkaNGiQ2rdvr2+++Ub169fX66+/rp9//pkSDgBwS6yIA4CkrVu3qkePHjp58qRCQkI0duxYsyMBTs8wDM2YMUMvvfSS/v77b0lSjx49NGHCBF111VUmpwMAwDwUcQBub+/evfL395fNZtNtt92mDz/8UDVqMDAEnI/169crIiJCy5cvlyRdd911io+P14MPPmhyMgAAzMdPmgDc2tGjR9WtWzfl5OTommuu0YIFC1SvXj2zYwFOKy8vTwMHDpTFYtHy5cvVoEEDjRs3Tj///DMlHACA/8eKOAC3ZRiGnnnmGa1YsUKNGzdWenq6LrnkErNjAU7JMAxNnz5dUVFR2r17tySpZ8+emjBhglq0aGFyOgAAHAtFHIDbevXVVzVz5kzVqlVLc+fOVZs2bcyOBDildevWKTw8XCtWrJAktWrVSvHx8fLz8zM5GQAAjonRdABu6ZNPPtGrr74qSXrnnXd0//33m5wIcD42m02RkZGyWCxasWKFGjZsqDfffFPr16+nhAMAUApWxAG4neXLl+uZZ56RJEVFRenZZ581ORHgXAoLC/XRRx8pOjpae/bskST16tVL48ePV7NmzUxOBwCA46OIA3Arv/zyi7p3767jx4+rR48eiomJMTsS4FSys7MVERGhH374QZLUpk0bxcfHM1UCAMA5YDQdgNvIzc2Vv7+/9u3bp44dO2r69Olcpgwop/379ys8PFwdO3bUDz/8oIYNGyouLk4//fQTJRwAgHPEijgAt3D8+HH17NlT27ZtU4sWLbRo0SI1aNDA7FiAwyssLNS0adM0bNgw7d27V5L06KOP6u2339aVV15pcjoAAJwTRRyAyzMMQ6Ghofr666914YUXasmSJbrsssvMjgU4vKysLIWHh2vVqlWSpLZt2yohIUH33nuvyckAAHBuzGQCcHkxMTH66KOPVLNmTc2ZM0c33nij2ZEAh7Zv3z4999xz6tixo1atWqULL7xQ48eP108//UQJBwCgErAiDsClzZ49WyNGjJAkxcfH66GHHjI5EeC4CgsL9f7772v48OHat2+fJOnxxx/XW2+9pcsvv9zkdAAAuA6KOACX9cMPP6hv376SpIEDB+r55583ORHguNasWaPw8HCtWbNGktSuXTslJCTo7rvvNjkZAACuh9F0AC7p119/VdeuXXXs2DEFBgbq7bffNjsS4JD27t2r0NBQderUSWvWrFGjRo00ceJEZWdnU8IBAKgirIgDcDk2m03+/v7as2ePbrnlFs2cOVM1a9Y0OxbgUAoKCpSSkqIRI0YoNzdXkvTEE08oLi6OzQwBAKhiFHEALuXEiRMKDg7W5s2bdeWVV2rx4sW64IILzI4FOJRVq1YpPDxcWVlZkqQbb7xRiYmJuvPOO01OBgCAe2A0HYDLMAxD4eHhyszMVMOGDbV48WKucwycYs+ePXr22WfVuXNnZWVlqVGjRpo8ebKys7Mp4QAAVCNWxAG4jLffflspKSmqUaOGPv30U91yyy1mRwIcQkFBgZKSkjRixAjZbDZJUt++fRUbG6tLL73U3HAAALghijgAlzBv3jxFR0dLkiZMmKDAwECTEwGO4YcfflBERISys7MlSe3bt1dCQoL+85//mJwMAAD3xWg6AKe3Zs0a9enTp2g0fcCAAWZHAkz3zz//qF+/frr99tuVnZ2txo0bKz4+XmvWrKGEAwBgMlbEATi1P/74Q126dNGRI0f08MMPa9KkSfLw8DA7FmCakydP6t1339XIkSOLxtCffvppvfnmm7rkkkvMDQcAACRRxAE4sfz8fAUEBOjvv//WjTfeqFmzZqlWLf5Zg/tasWKFwsPDtW7dOknSLbfcosTERN12220mJwMAAKdiNB2AUzp58qRCQkL0888/67LLLtOSJUvUqFEjs2MBpti9e7f69u2rO+64Q+vWrVOTJk00depUrVmzhhIOAIADYukIgNMxDEMvvviivvjiC9WvX1+LFy9WixYtzI4FVLuTJ09q6tSpGjlypPLz8yVJzz77rMaNG6eLL77Y5HQAAKAkFHEATmfKlCmaOnWqPDw8NGPGDHXo0MHsSEC1W758uSIiIrR+/XpJko+PjxITE9WpUyeTkwEAgLIwmg7AqSxevFiDBg2SJMXGxqp79+4mJwKq119//aUnnnhCd911l9avXy8vLy+9++67WrVqFSUcAAAnQREH4DR+/PFH9e7dW4ZhqH///ho6dKjZkYBqc+LECU2cOFGtWrXSJ598Ig8PD4WGhmrbtm0KCwtTzZo1zY4IAADKidF0AE7hzz//VEBAgA4dOiRfX18lJiZymTK4jW+++UYRERHasGGDJKljx45KTExUx44dTU4GAAAqghVxAA7v4MGDCgwM1K5du9S2bVulpqaqdu3aZscCqtyuXbv0+OOP65577tGGDRvUtGlTpaSkaOXKlZRwAACcGEUcgEMrKCjQY489ph9//FEXX3yxlixZIk9PT7NjAVXqxIkTGj9+vFq1aqWZM2fKw8NDzz33nLZt26Znn31WNWrwn28AAJwZo+kAHNrQoUO1ePFi1a1bVwsXLtQ111xjdiSgSi1btkwRERHatGmTJKlTp05KSEjg6gAAALgQDqkDcFhTp07VpEmTJEkff/yxbrvtNnMDAVXozz//1KOPPqr77rtPmzZt0kUXXaT33ntP33//PSUcAAAXQxEH4JC++OILDRgwQJL0xhtvqFevXiYnAqrG8ePHFRcXp1atWmn27NmqUaOGXnjhBW3dulXPPPMMY+gAALggRtMBOJyff/5ZvXr1UkFBgfr27avhw4ebHQmoEkuXLlVERIS2bNkiSbrtttuUmJioW265xeRkAACgKnGYHYBD+fvvv+Xv768DBw7o7rvvVnJyMpcpg8vZuXOnevXqJV9fX23ZskUXX3yxpk2bpu+++44SDgCAG6CIA3AYhw8fVpcuXbRjxw5df/31mjdvnurUqWN2LKDSHD9+XLGxsWrdurVSU1NVo0YNRUZGatu2bXrqqacYQwcAwE0wmg7AIRQWFuqJJ57QmjVr1LRpU6Wnp8vLy8vsWEClycjIUGRkpLZu3SpJ+s9//qOEhAS1b9/e3GAAAKDacegdgEMYPnx40Qr4/Pnzde2115odCagUf/zxh4KCgvTAAw9o69atuvTSS/XRRx9p+fLllHAAANwURRyA6VJSUhQXFydJev/993XnnXeanAg4f8eOHdO4cePUpk0bzZ07VzVr1tSLL76orVu36sknn2TvAwAA3Bij6QBMlZmZqRdeeEGSNHr0aPXp08fkRMD5s19+b/v27ZKkO++8UwkJCbrppptMTgYAABwBK+IATLNp0yYFBQXp5MmTeuyxxzR69GizIwHn5ffff1ePHj308MMPa/v27brsssv0ySef6JtvvqGEAwCAIhRxAKb4559/5O/vr7y8PP3nP//R+++/z6gunNbRo0f1+uuvq02bNpo/f75q1qypQYMGaevWrXr88cf5bAMAgNMwmg6g2h05ckRdu3bVb7/9Jm9vby1YsED16tUzOxZQIZ999pkGDBignJwcSdLdd9+thIQEtWvXzuRkAADAUbEiDqBaFRYW6umnn9bKlSvl6emp9PR0XXTRRWbHAs7Zr7/+qq5du8rf3185OTm6/PLLNXPmTC1btowSDgAASkURB1CtRo8erdmzZ6tWrVqaN2+eWrdubXYk4JwcOXJEr776qtq2batFixapVq1aGjJkiLZs2aLevXszhg4AAMrEaDqAavPRRx/p9ddflyQlJyfr3nvvNTkRcG6WLFmiF198UVarVZJ07733KiEhQW3btjU5GQAAcCasiAOoFl9//bX69+8vSRo+fLiefvppkxMB5We1WhUYGKjAwEBZrVZdccUVmjVrlpYuXUoJBwAA54wiDqDKbdu2TT169NCJEycUHBxctCoOOLojR45o9OjRatu2rZYsWaJatWrppZde0pYtWxQSEsIYOgAAqBBG0wFUqb1798rf31/79+9Xp06d9NFHH6lGDY4BwrEZhqFFixZp4MCB+u233yRJ999/v+Lj49WmTRtzwwEAAKdHEQdQZY4dO6bu3bvrl19+0dVXX62FCxeqfv36ZscCSvXLL79owIAB+vzzzyVJzZo104QJExQUFMQKOAAAqBQsSwGoEoZh6Nlnn9V3332nRo0aacmSJbr00kvNjgWU6PDhwxo5cqRuuOEGff7556pdu7aGDRumzZs3Kzg4mBIOAAAqDSviAKrEa6+9pk8++UQ1a9ZUWlqabrjhBrMjAcUyDEMLFy7UwIED9fvvv0uSHnjgAU2ZMkWtWrUyOR0AAHBFFHEAlW7mzJkaPXq0JGnq1Kny8/MzORFQvO3bt2vAgAH64osvJEnNmzfXpEmT1L17d1bAAQBAlWE0HUClWrFiRdGlyYYOHarQ0FCTEwFnO3TokEaMGKF27drpiy++UJ06dfTyyy9r8+bN6tGjByUcAABUKVbEAVSanJwcdevWTcePH1e3bt305ptvmh0JOI1hGJo/f74GDRqkP/74Q5L04IMPasqUKbr++utNTgcAANwFRRxApdi/f7/8/f21d+9e+fj4FJ0fDjiKbdu2acCAAfryyy8lSS1atNCkSZPUrVs3VsABAEC1YjQdwHk7fvy4evbsqa1bt6pZs2ZavHixGjZsaHYsQNL/xtBvvPFGffnll6pTp45GjBihzZs3cy44AAAwBSviAM6LYRh67rnntGzZMl1wwQVKT0/X5ZdfbnYsoGgMfeDAgdqxY4ck6aGHHtKUKVN03XXXmZwOAAC4M4o4gPMSGxuradOmqUaNGpo9e7ZuuukmsyMB2rZtmyIjI/Xf//5X0r9j6JMnT1bXrl1ZAQcAAKZjNB1AhaWmpmr48OGSpMmTJ+uRRx4xORHc3aFDh/Tyyy+rXbt2+u9//6s6derolVde0ebNmzkXHAAAOAxWxAFUyKpVq/Tkk09KkgYMGKCIiAiTE8GdGYahefPmadCgQUVj6A8//LAmT57MGDoAAHA4FHEA5+y3335Tly5ddPToUfn7+2vChAlmR4IbO3MM/aqrrtLkyZPVpUsXVsABAIBDYjQdwDnJy8uTv7+//vnnH91888369NNPuUwZTFHcGPrIkSO1adMmzgUHAAAOjRVxAOV24sQJBQcHa9OmTbriiiu0ZMkSXXjhhWbHgpsxDENz587V4MGDi8bQH3nkEU2ePFnXXnutyekAAADKRhEHUC6GYSgyMlIZGRlq0KCBFi9erGbNmpkdC25my5YtioyMVGZmpiTp6quv1uTJkxUYGMgKOAAAcBrlLuLHjh3TsWPHin6fn59fJYEAOKYJEyYoKSlJHh4emjlzpiwWi9mR4EYOHjyo119/XRMmTNCJEydUt25dRUdHa9iwYapfv77Z8QAAQDU7s4/WrVtXdevWNSnNuSv3OeIxMTFq3Lhx0a/mzZtXZS4ADmTBggV66aWXJEnjx49X165dTU4Ed2EYhlJTU9WmTRvFxsbqxIkTeuSRR7Rx40a9+uqrlHAAANxU8+bNT+unMTExZkc6Jx6GYRjluWFxK+LNmzdXXl6eGjVqVGUBAZgrKytLd911lw4fPqznnntOU6dOZQQY1YIxdAAAcKb8/Hw1btxYO3bsOK2HOtuKeLlH053thQE4fzt27FBgYKAOHz6sBx98UPHx8RQgVDnG0AEAQFkaNWrk1AvCbNYGoFgHDhxQQECA/vrrL7Vr105z5sxRrVr8k4GqYxiG0tLSNHjwYO3cuVOS5O/vr8mTJ6tly5YmpwMAAKg8/FQN4CwnT57Uo48+qvXr1+vSSy/VkiVLnPqIIxzfli1bFBERoaVLl0r6dwx9ypQpCgwMNDkZAABA5Sv3Zm0A3MfgwYP12WefqX79+lq0aJGuuuoqsyPBRR08eFDR0dG66aabtHTpUtWtW1ejR4/Wpk2bKOEAAMBlsSIO4DTx8fGKj4+XJE2fPl233nqryYngiuy7oQ8ePFh//vmnJCkgIECTJk1iDB0AALg8ijiAIunp6Ro4cKAk6c0331TPnj3NDQSXtHnzZkVGRhaNoV9zzTVFu6EDAAC4A0bTAUiS1q1bp5CQEBUWFuqZZ55RVFSU2ZHgYoobQx8zZow2btxICQcAAG6FFXEA2rVrlwICAnTo0CHdd999euedd7hMGSpNcWPogYGBmjRpkry9vU1OBwAAUP0o4oCbO3TokAIDA7Vz5061bt1aaWlpql27ttmx4CI2b96siIgIffXVV5L+HUOfMmWKAgICTE4GAABgHkbTATdWUFCgxx9/XNnZ2brooouUnp6uJk2amB0LLuDAgQOKiorSTTfdpK+++kr16tUrGkOnhAMAAHfHijjgxqKiorRw4ULVrVtXCxcuZEwY580wDM2ZM0eDBw/Wrl27JDGGDgAAcCaKOOCm3n33XU2YMEGSNG3aNN1+++0mJ4Kz27RpkyIjI4vG0L29vTV58mRWwAEAAM7AaDrghr788ktFRERIksaOHavevXubnAjO7MCBA3rppZd08803F42hv/rqq4yhAwAAlIAVccDNbNiwQcHBwSooKNCTTz6pV155xexIcFKGYWj27NkaMmRI0Rh6ly5dNGnSJF1zzTUmpwMAAHBcFHHAjfz999/y9/fXgQMHdNdddyk5OZnLlKFCNm3apIiICC1btkzSv2PoU6ZMkb+/v8nJAAAAHB+j6YCbOHz4sLp27ao//vhD1113nebNm6e6deuaHQtO5tQx9GXLlp02hk4JBwDAfNnZ2bLZbG7zvM6KIg64gcLCQvXt21erV6+Wl5eX0tPT1bRpU7NjwYkYhqFPP/1UrVu31ttvv62TJ0+qa9eu2rRpk0aNGqV69eqZHREAALeXmZmpzMxMeXp6VvtzWywW9e/fnzJeThRxwA2MGDFCaWlpql27tubPn6/rrrvO7EhwIhs3btR9992nxx57TLt27VLLli2Vnp6uBQsWcC44AAAOwmq1KikpSVFRUaZlSElJUXBwsGnP70wo4oCL++CDD/Tmm29Kkt577z3dddddJieCszhw4ICGDh2q9u3b6+uvv1a9evX02muvacOGDXrkkUfMjgcAAE4RHByslJQUUzN4enoqLCxMYWFhpuZwBhRxwIV99dVXRf8Qjhw5Uk8++aTJieAM7GPorVq10vjx43Xy5El169ZNmzdv1iuvvMIYOgAADiY6OlohISGmjKSfKSgoSGvXrlV2drbZURyah2EYRkXumJ+fr8aNGysvL0+NGjWq7FwAztOWLVt02223yWaz6dFHH9XMmTPZIR1l2rhxo8LDw/XNN99Iklq2bKn4+Hg9/PDDJicDAADFsdlsuuaaa7R//36zoxTJzMxUdHS0srKyKv2xXaWHsiIOuKA9e/bI399fNptNt99+u6ZNm0YJR6ny8/M1ZMgQ3Xzzzfrmm29Uv379ojF0SjgAAI4rJiZGoaGhZsc4ja+vr2w2G6vipaCIAy7m6NGj6tatm6xWq6655hotWLCAUWKUyDAMzZw5U61bt9aECRNUUFCgbt26adOmTYyhAwDgBJKTkxUSEmJ2jLMEBQUpKSnJ7BgOiyIOuBDDMNSvXz99//33aty4sdLT03XxxRebHQsOasOGDbr33nv1+OOP66+//tK1116rzz77TPPnz9fVV19tdjwAAFCGzMxMSf9eOszRhISEKDk52ewYDosiDriQMWPG6NNPP1WtWrU0b948tWnTxuxIcED5+fkaPHiw2rdvXzSG/vrrr+vnn39mDB0AACeSkZEhX19fs2MUy35wgPH04tUyOwCAyjF9+nSNHTtWkvTuu+/qvvvuMzkRHI19DH3o0KH6+++/JUndu3fXxIkTddVVV5mcDgCAqpeWlqbZs2dLkry8vJSbm6uQkBAFBQWZnKxiMjMzyzWWnpaWpoyMDK1du1YhISFF1xq3Wq2KjY2VJOXm5spqtWr48OFF74fNZlNMTIxsNpsknXX/slgsFmVmZjrkir3ZKOKAC/j222/1zDPPSPr38hX2/w/YbdiwQeHh4fr2228lSddee63i4+P10EMPmZwMAICqZ7VaFRwcLC8vL6Wmpp52ma/o6Gh5eno67MpyaaxWq7y9vcu8TUZGhpKSkpSZmSk/Pz9ZLBZZrVZlZWWddh53XFycgoODlZGRIS8vL8XExCglJaXo/crOzpaPj48klauMe3t7a82aNRV/gS6M0XTAyW3fvl3du3fXiRMn1LNnT40bN87sSHAgp46hf/vtt0Vj6Bs2bKCEAwDcgtVqlY+Pj7y8vJSRkXFaCY+Li1NcXJxSU1PNC3gebDZbmUU8NjZW0dHRp30tLCxMOTk5Z22mZj8YERsbq5iYmLMOWthXtsu7CZu3t7esVmu5butuWBEHnNi+ffvk7++v3Nxc3Xrrrfr4449VowbH18AYOgAA0r9F1b6CW1zZthdKPz+/s27v7e192kpwbm6uOnToUPQ1q9Uqq9WqXr16mbI7uH1c/NSiXJxTV83t52t7e3sXjaSfKjc3V9K/I+i//vrreWds2rQpRbwEFHHASR0/flw9evTQ9u3b1aJFCy1cuFANGjQwOxYcwM8//6yIiAjG0AEAbq9///6y2WyKiooqtrCmpqYqNze3aCV4zpw5slgsZ5V2Hx8f5ebmKiMj47Svn7nSXBn8/Pzk5+enoKAgeXt7Kzs7WzExMWedy24vuF5eXiU+ls1mU1hYWNHv7fmLK+HS/4r68OHDi32/Ti3y5VHWQQJ3xtIZ4IQMw1D//v317bff6sILL1R6erouu+wys2PBZHl5eRo0aJBuueWWojH0N954gzF0AIBbslqtSktLk6TTyuipLBbLaeeGZ2VlFbtynp2dXew55H5+furYsWMlJf6X1WpVdHS0WrZsKQ8PD/n4+Khjx45nbShnX70ujaen52n3y8zMlKenZ4mbp9mLeknny9svlxYcHFyu1+Ll5VW0co/TsSIOOKE33nhDH3/8sWrWrKnU1FS1a9fO7EgwkWEYmjFjhl566aWiMfQePXpowoQJjKEDANyWfVzcYrGUawX31LH0U9nLp318/UzlXR0uL4vFUnQOt4+Pj3x9fYt9jtJWwotjfx2lbUpXVlG37zjfq1evcj1nbm4uq+IloIgDTmbWrFkaOXKkJCkhIUEPPvigyYlgpp9//lnh4eFavny5JOm6665TfHw8nwsAgNuzj1GXdzf0zMzMYgtmaavEVqu10ndb9/LyKvflwaTyl1376yjpgEJZ75fValV2drYsFku5y3V5NpNzV4ymA07k+++/11NPPSVJGjx4sJ577jlzA8E0p46hL1++XPXr19e4ceP0888/U8IBAND/RrfLOzoeFBRU4nnRnp6exRbK0NDQ88p4Pux5yjv6XdaKuH21u6Sibp8wOHXM3z76X5J9+/ad88q9u6CIA07CarWqa9euOnbsmLp06aK4uDizI8EEhmHok08+UatWrTRp0iQVFBSoZ8+e2rJli4YPH666deuaHREAgCp14sQJZWdn65NPPin1dh06dJBU9oZhNputqKQWJzMzs9qvMZ6cnFx0abWwsLBi8526e3t5lHZAQSq7qNtL96kHH8raLb481zl3V4ymA07AZrPJ399fe/fu1S233KKZM2eqZs2aZsdCNVu/fr0iIiKKxtCvv/56xcfH64EHHjA5GQAAVcMwDO3cuVOrVq3SypUrtWrVKq1du1ZHjx6VJAUEBJRYtMPCwpScnFziRmvSv0UxLCysxOuI28e1S1olrgr2XdxPLbBNmjRRSkrKWRu2WSyWchVxe4ku7dzu7OxseXt7F1ucbTbbWWP4aWlpZW7aZrVaK30zO1dBEQcc3IkTJxQUFKQtW7boyiuv1OLFi9WwYUOzY6Ea5eXlafTo0UpISFBBQYEaNGigV155RYMHD2YFHADgUg4dOqS1a9eeVrx37dp11u08PT3VqVOnUs+PtlgsCg0NVUxMjEJDQ0+7nc1mU3JysnJycpSamlriY5Rng7PKVtxBgdDQUPXv3/+sIu7r66s1a9aU+ZhlnR9e1uu0vz/2km61WpWRkVHminh2drZSUlLKzOeOKOKAAzMMQ88//7yWLl2qhg0basmSJbryyivNjoVqYhiGpk+frqioKO3evVuS1LNnT02YMEEtWrQwOR0AAOensLBQW7duLSrcK1eu1IYNG1RQUHDa7WrWrKmbbrpJnTt3VqdOndS5c2ddd911qlGj7LNsk5KS5Ofnp/79+8vLy+u0wh0WFlbm2HRGRkap49ynKmnX9dIEBQWVeE3vU7Vs2VI2m61oszQ7Pz+/cl1KzP4azizyp/L29i71uugZGRmKjo4uOke8PCVcUok7sLs7D8MwjIrcMT8/X40bN1ZeXp4aNWpU2bkASIqLi1N0dLRq1KihRYsWyd/f3+xIqCbr1q1TRESEvvvuO0mMoQMAnN/evXtPW+levXq18vLyzrpds2bNigp3p06d5OPjowYNGpiQWPLw8FBQUFCJo+uVLSwsTJ6enmeV8+TkZIWFhSkjI+OsVesmTZooKyvL4c7FjouLU05OTpmF/Vy5Sg9lRRxwUHPnzi06Kjlx4kRKuJuw2WxFY+iFhYVq0KCBRo4cqUGDBjGGDgBwGsePH9e6detOW+3Oyck563b169dXx44dTyvejjL9Z1/Rrc5znOfMmVPseLh9Z3T7BnSnCg0NVVJSUrlW1qtTUlJStR3AcEYUccABrV69Wn369JEkRUREaMCAASYnQlWzj6G/9NJL+ueffyT9O642YcIENW/e3OR0AACUzDAM/fHHH6eV7uzsbB07duys27Zu3fq0EfN27dqpVi3HrCRr166VVL3nh4eGhhZbqGfPnl3i9bvDwsLk4+PjUEXcvkM7Y+klc8xPPeDGfv/9d3Xp0kVHjx7VI488ookTJ5odCVVs3bp1Cg8P14oVKyRJrVq1Unx8fLXu0AoAQHkdPHhQa9eu1cqVK4vK999//33W7by8vE4r3R07dlSTJk1MSFwx9tXc6iyTYWFhio6OPq1Up6WlyWq1Kisrq9j7eHt7KzQ0VMnJyaZe1/xU0dHRbNJWBoo44EDy8vIUEBCg3bt366abbtKsWbMc9igxzp/NZtOoUaOUmJhYNIY+atQoDRo0SHXq1DE7HgAAKiws1JYtW87aUK2wsPC029WqVUvt27cvKt2dO3dWy5Yt5eHhYVLyiklOTlZWVpasVmvRTuLBwcHy8vJScHBwla+Oe3t7F5Vx6X8j6b/++mup10MfPny47r//fvXq1avM66ZXtczMTFbDy4HN2gAHcfLkSQUEBOjLL7/UZZddptWrVzOS7KIKCwuLdkO3j6EHBwdr/Pjx/JkDAEx16oZqK1eu1OrVq5Wfn3/W7Vq0aHHaed0Wi0X169c3ITHssrOzFRMTY+p52TabTcHBwUWXS6sKrtJDWWoDHIBhGBowYIC+/PJL1a9fX4sXL6aQuajixtATEhKq9fwzAACk0zdUs694F7ehWoMGDdSxY8ei0t2pUyddccUVJiRGaSwWi0JCQhQXF6eoqChTMkRHR1f6LumuiiIOOIDJkyfrnXfekYeHh2bOnFnsjphwbmeOoTds2FCjRo3SwIEDGUMHAFS5c9lQrU2bNqeNmN9www2cKuckgoKClJmZKZvNVu0j6tnZ2YqNjTV9NN5Z8DcKMNmiRYs0ePBgSdJbb72lbt26mRsIlaq4MfRevXpp/PjxatasmcnpAACu6lw3VLOvdt96660UKSdn1pQd54SfG4o4YKLs7Gz17t1bhmEoNDS0qJDDNfz0008KDw/X999/L+nfS7bEx8czhg4AqFTutqEa4Aoo4oBJdu7cqcDAQB0+fFh+fn5KSEjgP4QuwmazaeTIkZo6dSpj6ACASseGaoDzo4gDJjh48KACAwO1a9cutW3bVqmpqapdu7bZsXCeCgsL9fHHHysqKkp79uyRxBg6AOD8nLqhmr18s6Ea4Pwo4kA1KygoUO/evfXTTz/pkksuUXp6uho3bmx2LJynH3/8UeHh4frhhx8k/TuGnpCQoPvvv9/kZAAAZ8GGaoD74G8rUM2GDBmiJUuWqF69elq4cKGuvvpqsyPhPOzfv18jR47UO++8UzSGPnr0aL344ouMoQMASsWGaoD7oogD1SgxMVGTJ0+WJH388cfq3LmzyYlQUYWFhfroo48UHR1dNIYeEhKit99+mzF0AMBZ2FANwKko4kA1+eyzzzRgwABJ0rhx4xQcHGxyIlTUmWPobdq0UXx8PGPoAIAi5d1QrXnz5qetdrOhGuAeKOJANVi/fr1CQkJUWFiop59+WsOGDTM7EiqAMXQAQHHOdUO1U3cyZ0M1wD1RxIEq9tdffykgIEAHDx7Uvffeq3fffZfxMifDGDoAwO5cNlRr3br1aavd7dq1Y0M1AJIo4kCVOnTokAIDA7Vjxw61atVKc+fOZeXUyWRnZys8PFwrV66U9O8YekJCgu677z6TkwEAqsO5bqhmX+1mQzUApaGIA1WksLBQTzzxhLKystS0aVOlp6erSZMmZsdCOe3fv1+vvPKK3n333aIx9DFjxmjAgAEcTAEAF8WGagCqC0UcqCLR0dGaP3++6tSpowULFqhly5ZmR0I5FBYW6sMPP1R0dLT27t0rSXr00Uf19ttv68orrzQ5HQCgMrGhGgCzUMSBKpCcnKy3335bkjRt2jTdcccdJidCeZw5ht62bVslJCTo3nvvNTkZAOB8saEaAEdCEQcqWUZGhl544QVJ0pgxY/TYY4+ZnAhlyc3NLRpDNwxDF1xwQdEYeu3atc2OBwA4R/YN1U5d7WZDNQCOhH9lgEq0adMmBQUFqaCgQH369NGoUaPMjoRSFDeG3rt3b7399tusfgCAEzl1QzV7+WZDNQCOjCIOVJLdu3fL399f+fn5uuOOO/Tee++xaYsDK24MPTExUffcc4+5wQAApbJvqHbqandJG6rdfPPNp612X3vttfy3GYBDoIgDleDIkSPq2rWrfvvtN7Vs2VLz589X3bp1zY6FYuzfv18jR47UO++8o8LCQsbQAcDBnbqh2qpVq7Rq1apSN1Szr3azoRoAR0YRB85TYWGh+vbtq1WrVqlJkyZKT0/XRRddZHYsnKGwsFAff/yxoqKitGfPHkmMoQOAo2FDNaB6ZWdny9vbu9pP0TDreR0JRRw4TyNHjlRqaqpq166tefPmqVWrVmZHwhl++uknhYeH6/vvv5cktWnTRomJieyGDgAmYkM1wFyZmZnKzs5WVFRUtT+3xWJRcHCwUlJS3LaM8y8YcB6mTZumcePGSZJSUlI4v9jB2Gw2jRo1SomJiSosLFTDhg2LxtDr1KljdjwAcCsV3VCtY8eOatKkiQmJAddltVqVlJSk1NRU0zKkpKQoODhYGRkZpmUwE0UcqKBly5YpNDRUkjRixAj17dvX5ESwMwxD06dP10svvaR//vlHktSrVy+NHz9ezZo1MzkdALg+NlQDHFtwcLCWLl1qagZPT0+FhYUpLCxMSUlJpmYxA0UcqICtW7eqZ8+eOnnypEJCQjR27FizI+H/rV+/XuHh4fruu+8kSa1atVJCQoJ8fX1NTgYArosN1QDnER0drZCQEIcYCQ8KClJMTIyys7NlsVjMjlOtPAzDMCpyx/z8fDVu3Fh5eXlq1KhRZecCHNbevXvVuXNn5eTkqHPnzvrqq6/4IcIB5OXlafTo0UpISFBBQYEaNGigUaNGadCgQYyhA0Alsm+odupqd0kbqnXo0OG01W42VAPMZbPZdM0112j//v1mRymSmZmp6OhoZWVllev2rtJDWREHzsGxY8fUvXt35eTk6Oqrr9bChQsp4SYzDEMzZszQ0KFDtXv3bkn/Hl2dMGGCmjdvbnI6AHBuhmFox44dRYV71apVysrKKnVDNftqNxuqAY4nJiam6NRKR+Hr6yubzeZ2q+L86wiUk2EY6tevn7777js1btxY6enpuuSSS8yO5dY2bNig8PBwffvtt5Kk66+/XvHx8XrggQdMTgYAzokN1QDXlpycbPq54cUJCgpSUlKSW50rThEHymns2LGaOXOmatasqbS0NLVt29bsSG4rPz9fY8aM0ZQpU1RQUKD69etr5MiRGjx4sOrWrWt2PABwCmyoBriXzMxMSXLIVeeQkBD5+PhQxAGcbsaMGRozZowk6Z133mHjL5MYhqFZs2ZpyJAh+uuvvyRJPXr00MSJE9WiRQuT0wGAYztzQ7XVq1crLy/vrNuxoRrgmjIyMhz2Z1j7wQF3Gk+niANl+O6779SvXz9J0ksvvaT+/fubnMg9bdy4UREREfr6668lSddee63i4+P10EMPmRsMABwQG6oBxUtLS9Ps2bMl/XuKRW5urkJCQhQUFGRysqqXmZmpkJCQMm+XlpamjIwMrV27ViEhIYqKipL077XHY2NjJUm5ubmyWq0aPnx40Xtns9kUExMjm80mSWfdvywWi0WZmZkUcQDSL7/8om7duun48ePq0aOH3nzzTbMjuZ0DBw5o7NixmjRpkk6ePKn69etrxIgRGjJkiOrVq2d2PAAwHRuqAWWzWq0KDg6Wl5eXUlNTT7t0V3R0tDw9PR12tbiyWK1WeXt7l3mbjIwMJSUlKTMzU35+frJYLLJarcrKyjptdDwuLk7BwcHKyMiQl5eXYmJilJKSUvTeZmdny8fHR5LKVca9vb21Zs2air9AJ8O/vEAJcnNz5e/vr3379qlDhw6aPn26atSoYXYst2EYhubMmaPBgwdr165dkqRu3bpp4sSJuvrqq80NBwAmsm+odupqNxuqASWzWq3y8fFRhw4dlJGRcdr34uLiFBcXJ5vN5vJF3GazlVnEY2NjFR0dfdrXwsLCijZTO5X9/YqNjZWnp6dSU1NP+759ZTspKancRdx+Hrs7oIgDxTh+/Lh69uypbdu2qXnz5lq0aJEaNGhgdiy3sXnzZkVEROirr76SJLVs2VJTpkzRI488YnIyAKheZ26otmrVKv38889sqAaUk81mK1qVPbMoSioql35+fmfd3tvb+7TV3dzcXHXo0KHoa1arVVarVb169XL4Tcbs4+KnTgIU59RV8+zsbEn/vg/2kfRT5ebmSvp3BP3XX38974xNmzaV1Wo978dxFhRx4AyGYSgsLExff/21LrzwQqWnp+vyyy83O5ZbOHjwoF577TVNmDBBJ0+eVL169fTyyy/rpZdeYgwdgFtgQzWgcvXv3182m01RUVHFltDU1FTl5uYWre7OmTNHFovlrNLu4+Oj3Nzcs1bUz1w9rkz2cfqlS5eWWKCjo6Nls9nUsmVL5eTkKCwsrNhzrO0F18vLq8Tns9lsCgsLK/q9/bUWV8Kl/xX14cOHF5vv1CJfHmUdJHA1FHHgDDExMfrwww9Vo0YNzZ49WzfeeKPZkVyeYRiaO3euBg0apJ07d0qSAgMDNWnSpHL/4w0AzoYN1YCqZbValZaWJkmnFcxTnVlas7Kyil05z87OLnZDNz8/v6LV5spiP5fdarUWldni+Pj4KDY2tugggn01PzU19azXZV+9Lo2np+dprzEzM1Oenp4lbp5mL+oljfTbx8yDg4PLfG7p34MElf1eOjKKOHCKOXPmaMSIEZKk+Ph4PfzwwyYncn1bt25VZGRk0T/m11xzjSZPnqzAwECTkwFA5WFDNaD62cfFLRZLuQ7snzqWfip7obSPr5+pshcN7AcC0tLSSjxnOi0t7azz2j09PRUWFqbo6OizVu5LWwkvjv15Sztvvqyibt+dvlevXuV6ztzcXLdaFedfdeD/rVy5Uk8++aQk6cUXX9QLL7xgciLXdujQIb3xxht6++23deLECdWtW1fDhg1TdHQ045UAnN65bKhmL9xsqAZULvtqcnk3YcvMzCy2NJa28mu1Wk3Z5C0pKanYAmyxWIrG1YsrteUtu/bXXNLBh7LeW/tqvsViKXe5Ls9mcq6EIg5I+vXXX9WlSxcdO3ZMgYGBGj9+vNmRXJZhGJo/f74GDhyoHTt2SJIeeeQRTZkyRS1btjQ5HQCcu4psqGYv32yoBlQd+zh2x44dy3X7kq4lnp2dLU9Pz2JLYmhoaMUDnofMzMxidyK3Z8zMzDzt9di/Xt7R77JWxO2r3SUVdfs0wqmnBKSlpZV6vfZ9+/ad88q9M6OIw+3ZbDYFBARoz549at++vWbOnKmaNWuaHcslbd++XZGRkfryyy8lSVdddZWmTJmiwMBAfhAF4DTYUA1wDh06dCgq0aWx2Wxau3Ztqec6l1Ygq1tpZdpeZM88J/zUnd5LGiU/VWkHH6Syi7r93PxTD1QkJSWV+j6W5zrnroQiDrd24sQJBQcHa9OmTbriiiu0ePFiXXDBBWbHcjmHDx/WuHHj9NZbb+n48eOqU6eOoqOjNWzYMC4LB8ChnThxQuvXry8aL1+5cqV++eWXs27HhmqA4wkLC1NycrKys7NLHaEOCwsrdoM26X8j2CWt/JrBXrKbNm1a4m2KK+sWi6Vclwezl+jSzu3Ozs6Wt7d3scXZZrOdNbKflpZW5qZtVqu13NMLroAiDrdlGIbCw8OVmZmphg0basmSJWrWrJnZsVyKYRhauHChBg4cqN9//12S9NBDDyk+Pl7XXnutyekA4Gx//vnnaaV77dq1Onr0/9q787Aoy/1/4G92kH0TRGTHPRfQ3D2eXLJwT1xarHNKKFNLPUp6NDWPEpZZmhrYvpmKpqKVQZmWu4DmrmyyCLIO+zrz/P7wN8+XcWbYYWbg/bquuRhm7meezxga7/ncz31XKI3jgmpE2s/Pzw9BQUEIDQ1FUFCQQmdcIpEgIiICiYmJ2L9/v9queUMWLWtrdU3frmt19HHjxuHixYv1vn5914fX92ci/7OUh/SkpCRER0fXu9d6XFwcdu/eXW997QX/j0Ed1pYtW7B7927o6elhz549GDhwoKZLalcSEhKwePFi/PzzzwAANzc3fPTRR5g6dSqnoRORVigvL0dsbKw4xfzcuXPiFoq12draKiyo9vjjj3NBNSIdER4ejvHjx2P+/Pmws7NTCNzBwcH1ToWOjo6uc4p2bepWXa/LzJkz1e7TrY78PeTl5amsofaY2saPH9+grcTk77euaeReXl517qEeHR2NkJAQ8RrxhoRwQHk7ufaMQZw6pB9//FFc4OKDDz7gVlktqLy8HKGhoQgLCxOnoS9fvhyrVq3iNHQi0hhBEJCYmKjQ7b5y5QpqamoUxhkYGKBfv35i6B46dCh8fX35ASKRDps5c2aTr/FuzPXhNjY2SExMbNJ5Wpqqrrm8g13ftdhhYWF1fjgwbty4et/nuHHjEBsb28BqH/45a2rhO01hEKcO59KlS3juuecgCAIWLFiAN954Q9MltRtRUVFYvHgxUlJSAAATJkzA9u3b0b17d80WRkQdTmFhIS5evKgQvFV1j5ydnTFs2DAxdPv7+8Pc3FwDFRORtpF3abXxuuVx48apvN5bPjVd3bTxoKAghIeHN7oL39rCw8PVXqffXjGIU4eSmpqKyZMno7y8HBMnTsRHH33ELkcLSEpKwhtvvIGjR48CeLhS8NatWzFjxgz++RJRq5NKpbh586ZC6L5x4wYEQVAYZ2xsDH9/f4Vud7du3fjvFBGpdOnSJQDadX24XHBwMObPn6/0eHR0dJ17dwcHB8Pf31+rgrh8hfaONC0dYBCnDqSoqAiTJk1CVlYWHnvsMezdu5cL6zRTeXk5Nm/ejNDQUFRWVsLIyAjLli3D6tWr2VEiolaTk5MjXtN97tw5XLhwAcXFxUrjPD09FUJ3//79YWJiooGKiUgXyTu0mgqI8u52fn6+UrCeOXMmQkNDFfbmlkgkiIyMFBdbU8XLywtBQUGIiIjQmqngISEhHWqRNjmmEOoQampqMGfOHFy9ehVOTk44evQorKysNF2WTjt27BgWL14sTosaN24ctm/fjp49e2q4MiJqT6qqqnDlyhWFBdVUXZtobm6Oxx9/XGH7MCcnJw1UTEStrbi4GElJSeJMx5YUERGB2NhYJCUliauDBwYGws7ODoGBgW3SHQ8ODkZ+fr7C+QcNGgR/f3+F8BwbG4uQkBAkJSXBxsYGsbGx2L9/f70Ly61cuRJjx47FrFmz6t1jvbXFxMR0yG44AOgJj87baqCioiJYW1ujsLCQgYa0miAIWLRoEXbs2AEzMzOcPHlSK6/10RXJycl48803ceTIEQBA165dsXXrVsycOZPTO4moWQRBQHp6usIU89jYWFRWViqN7dWrl0K3u0+fPjAwMNBA1UTU0qRSKdLT05GUlKTylpubK45lFmmauLg4hIaGavS6bIlEgsDAwDo7+Kq0lxzKjji1e9u3b8eOHTsAAN9++y1DeBNVVFTgvffew6ZNm1BRUQFDQ0MsXboUa9asgYWFhabLIyIdVFZWJm4fJr/dv39faZydnZ1C6B48eLDGuzhE1DwSiUQhXCcnJ4v3U1JSlHY0eJSDgwO8vLwgkUh0Ooxpip+fH2bPno3NmzeLOwm1tZCQkHq3NWvP2BGndu3o0aOYOnUqZDIZwsLCNPYPja77+eefsWjRInE66BNPPIGPP/4YvXr10nBlRKQrBEFAQkKC0vZhUqlUYZyBgQH69++vELx9fHw444ZIx1RXVyMtLU1tV7ugoKDO442NjeHp6QkvLy+lm6enJywtLdvonbRvMTExGDRoUJt/uBkXFwcvL68mnbe95FAGcWq34uPjMWrUKJSWluKVV15BREQEf5FrpHv37uHNN9/EoUOHAAAuLi744IMPMGvWLP5ZElGdCgsLceHCBYXgLV94qLYuXboobR/WqVMnDVRMRI0hCALy8/MVOtm1b6mpqUoftD3KyclJZdD28vKCi4sL9PX12+jdkC5pLzm0wVPTKysrFa7RKioqapWCiFpCRkYGJk+ejNLSUowdOxY7d+5kcGyEyspKvP/++9i4cSPKy8thaGiIN998E2+//TY/gSYiJVKpFDdu3FAI3Tdv3lTaPszExERp+zBXV1f++0ykpaqqqnDv3j21Xe368oCpqanKbrb8K3dYoeZ49OfPxMREp3bGaHAQDw0Nxfr161uzFqIWUVJSgsmTJyMjIwO9evVCZGQkjIyMNF2Wzjh+/DgWLVqEu3fvAgDGjBmDjz/+GH369NFwZUSkLbKzs5W2DyspKVEa5+XlpbR9mLGxsQYqJiJVBEFAbm6u2qCdnp4OmUxW52u4uLio7Wo7OTmxq02tplu3bgrfr127FuvWrdNMMU3Q4Knpqjri3bp10/kpAdS+SKVSzJgxA0eOHIGjoyPOnz8PT09PTZelE1JTU7F06VIcOHAAwMPpolu2bMGcOXPYrSLqwKqqqnD58mWFbndycrLSOAsLC6Xtwzp37qyBiomotoqKCqSkpCiFbPmUclUfotXWqVMntUHbw8MDZmZmbfROiB6ST01PS0tTyKHttiOua2+MOqbly5fjyJEjMDExweHDhxnCG6CqqgoffPABNmzYgLKyMhgYGOCNN97A2rVr+SEbUQcjCALS0tIUQndcXJzS9mF6enro3bu3GLiHDh2K3r17c/swIg0QBAEPHjxQ29XOyMio83g9PT24urqqDduOjo78QJ60kpWVlU7/rsrty6jd2LVrF7Zu3QoA+OqrrzBs2DANV6T9YmJisHDhQty+fRsAMHr0aOzYsQN9+/bVcGVE1BZKS0uVtg/LzMxUGmdvb6+0fZi1tbUGKibqmMrKypCcnKx2YbTy8vI6j7e0tFQbtN3d3dlsI9IABnFqF3755RcsWrQIAPC///0Ps2fP1nBF2i09PR1Lly7F/v37ATxctfT999/Hc889x0+9idopQRBw9+5dhdD9999/K61qbGhoqLR9mLe3N/9tIGpFMpkMmZmZarvaWVlZdR6vr68PNzc3tQuj2dvb8+8wkZZhECedd/XqVcyaNQtSqRQvvvgiVq1apemStFZ1dTU++ugjrFu3DqWlpdDX18eiRYuwfv16dreI2hmJRKK0fZiqfXtdXFwUtg/z8/Pj9mFEraCkpERtRzs5OVnpEpBHWVtbw9vbW2VX283NjQvTEukYBnHSaVlZWZg0aRKKi4vxj3/8g3uF1+HUqVNYsGABrl+/DgAYMWIEduzYgf79+2u4MiJqrpqaGly/fl0hdN+6dUtpnKmpqcrtw4io+aRSKTIyMtR2tXNycuo83tDQEO7u7gqd7No3W1vbNnonRNQWGMRJZ5WVlWHKlClITU2Fr68vDh48yG1xVMjKysLy5cvx7bffAgAcHBzw3nvvYd68edxShEhHPXjwQCF0X7x4EaWlpUrjvL29FUJ3v379+O8kUTMUFhaq7WqnpKSgurq6zuPt7e3VXqvt6uoKQ0P+aq7N4uLi4OXlBRsbmw5xXmpd/NtOOkkmk2HevHm4ePEi7OzscOzYMdjZ2Wm6LK0ilUqxa9cu/Pe//0VRURH09PQQHByMjRs38s+KSIdUVlYqbR+WkpKiNM7S0lJp+zBHR8e2L5hIh9XU1CAtLU3tVl95eXl1Hm9kZAQPDw+VQdvT05OXgemwmJgYxMXFYcWKFW1+bj8/PwQGBmL37t0M4+0IgzjppFWrVuHAgQMwNjbGoUOH4Ovrq+mStMq5c+ewYMECxMfHAwAGDRqEnTt3YvDgwRqujIjqIggCUlNTlbYPq6qqUhinp6eHPn36KHS7e/bsye3DiBqgoKBA7fTxe/fuKS1g+KjOnTur7Wq7uLjw72E7lJSUhPDwcHGRW03YvXs3AgMDER0drbEaqGUxiJPO+fTTTxEWFgYA+OyzzzBq1CgNV6Q98vLy8NZbb+HTTz8FANjY2CA0NBTz58/nLwZEWqi0tBSXLl1SCN6qVkd2cHBQ2j5Ml/dOJWpNVVVVSE1NVTuFXCKR1Hm8iYmJymu05V1tCwuLtnkjpDUCAwPx22+/abQGGxsbBAcHIzg4GOHh4RqthVoGgzjplN9++w2vvfYaAODtt9/G888/r+GKtINMJsPnn3+OkJAQ5OfnAwBeeuklhIWFoXPnzhqujoiAh39PVW0fJpPJFMYZGhpiwIABCsHby8uLC1ES/X+CICA/Px+JiYkqg3ZaWprS36tHdenSRWmLL/mtS5cuXEOFRCEhIZg9e7ZWTAmfOXMmQkNDERcXBz8/P02XQ82kJwiC0JQDi4qKYG1tjcLCQn4qT23i5s2bGDZsGAoLCzF37lx89913/MUUQHx8PBYsWIBz584BAPr164cdO3Zg5MiRGq6MqGMrKCjA+fPnce7cOZw/fx7nz59XuX2Yq6urQuj28/ODmZmZBiom0h7yrrY8XD8auouKiuo83szMTO30cQ8PD27RRw0ikUjg6emp8t9uTYmJiUFISAhiY2M1XYrGtJccyo446YTs7GwEBASgsLAQI0aMwOeff97hQ7hEIsGaNWuwc+dOyGQyWFpa4p133sHChQu56ipRG6upqcG1a9cUut23b99WGmdqaopBgwYpLKjG7cOoIxIEQbxWW1VnOzU1td6udteuXcWO9qP7azs5OXX43xOo+UJDQxEUFKTpMhSMGzcOEomEXfF2gL+tk9arqKjAtGnTkJycDC8vL/z4448wNTXVdFkaIwgCvv32WyxfvhwPHjwAAMyZMwdbtmyBi4uLhqsj6hjk24edPXtW3D6srKxMaZyPj4/S9mFGRkYaqJio7VVXVyt0tR8N3YWFhXUeL+9qPxqy5eG7I/8uQG0jIiJC49eGqzJz5kyEh4fzWnEdxyBOWk0mk+Gll17C2bNnYWNjg2PHjnXo7XiuXbuG119/HadOnQIA9OzZEx9//DHGjh2r4cqI2q+qqipcuXJFDN1nz55VuX2YlZUVhgwZIna6hwwZAgcHh7YvmKgN1V6B/NHOdmpqar0rkLu4uCiFbHnwZlebNCkmJgYAtLLrPHv2bPj7+zOI6zgGcdJqa9euxd69e2FoaIgDBw6gZ8+emi5JI4qLi7F+/Xp89NFHqKmpQadOnbBmzRosXboUxsbGmi6PqF3JyMhQCN2xsbGorKxUGPPo9mHDhg1Dz549ucATtTvyfbVVTR9PTEysdwVyU1NTlSGb12qTtouOjsa4ceM0XYZK8g8HOD1dtzGIk9b6+uuv8b///Q/Aw6lBTzzxhIYranuCICAyMhJLlixBRkYGAGDatGn48MMP4e7uruHqiHRfRUUF4uLiFKaZp6enK42zs7NTCN2DBw+GtbW1BiomankSiUTt9PGG7Kvt7Oyscgq5t7c3nJyc+AEVaZXIyEjs3bsXwMN/2/Pz8zF79mzMnDlTYVxMTAxmz57doNeLjo7GpUuXMHv2bKxYsQLAw73H5dvt5ufnIykpCStXrhTPI5FIEBoaKn6Y9ejx9fHz80NMTAyDuA5jECetdPLkSbzyyisAgJUrV+Jf//qXhitqe3fu3MHChQsRHR0NAPDy8sL27dvx9NNPa7gyIt0kCALu3bsnLqZ29uxZxMfHo7q6WmGcvr4++vXrJ4buoUOHwtfXl1NkSWfV1NQgPT1d7cJo8m0v1TExMVE7fdzDwwPm5uZt9E6Imi4pKQmBgYGws7PD/v37FbYjCwkJgY2NjUIHPCkpCV5eXvW+ZnR0NMLDwxETE4Px48fDz88PSUlJiI2NVZg6vnnzZgQGBiI6Ohp2dnYIDQ3F7t27xTri4uLg7+8PAA0K415eXrh48WIj/gRI2zCIk9a5c+cOpk+fjurqagQGBopd8Y6irKwMmzZtwnvvvYeqqiqYmJjgrbfeQkhICLc0ImqEsrIyXLp0SaHbnZWVpTTO0dERw4YNE0P3oEGDYGFhoYGKiZqusLBQ5dRxeVe7pqamzuOdnJzUTiHnvtqk65KSkuDv749BgwaJDQ65zZs3Y/PmzZBIJApBXCKR1BvEw8LCEBISovBYcHCwuJhabfLXDgsLg42NDfbv36/wvLyzHR4e3uAgLr+OnXQTgzhplby8PAQEBKCgoABDhgzBV1991aH+5x8VFYXFixeLC0FNnDgR27dvh4+Pj2YLI9JygiAgMTFRIXRfuXJFaUqtoaEhBgwYIIbuoUOHwtPTk91u0npSqVTsaqvqbOfl5dV5vLGxMTw9PVVOIff09OSHT9RuSSQSsdP8aPgFIAbm8ePHKxwDQKFrrkrtrnlcXByAhwFZPiW9NvnMk0uXLiE5Oblxb0IFe3t7JCUlNft1SHMYxElrVFZWYvr06UhISIC7uzsOHz7cYTrAycnJeOONNxAVFQUA6NatGz788ENMnz6dAYFIheLiYly8eFEM3efOnUNubq7SOBcXF4XQ7e/v32H+XSHdU1RUhOTkZKWQnZiYiHv37ildRvEoR0dHlddpe3l5wcXFpUN9sE0kN3/+fEgkEqxYsUJlsN6/fz/y8/OVpqUDD68hV0cikSA4OFj8Xt5pVxXCgf8L6itXrlRZR+0g3xD1fUhA2o9BnLSCIAh45ZVX8Oeff8LKygrHjh2Dk5OTpstqdZWVlXjvvfewceNGVFRUwNDQEMuWLcOaNWt4zR3R/yeTyXDnzh2FlcyvX78OmUymMM7Y2Bj+/v4Ki6q5urrywyzSGlKpFBkZGWoXRlP1YVJtRkZGYlf70c62p6cnLC0t2+idEOmGpKQkREZGAoBCaK5N1WJn9a2bADwMwrUXeIuJiYGNjY3axdPkQV3dSuzyaeaBgYH1nht4+CFBfbsWkHZjECet8L///Q/ffvstDAwMsH//fvTp00fTJbW6X3/9FQsXLsTdu3cBAP/85z+xY8cO9OrVS8OVEWmWRCLB+fPnxdB9/vx5lb9suLu7K4TuAQMGwMTEpO0LJqqluLhYZVc7KSkJKSkpqKqqqvN4BwcHldPHvby80LVrVxgYGLTROyHSffJp535+fg3uNAN1d8JVkYfourY7qy+oy1dynzVrVoPOmZ+fz664jmMQJ43bs2cP3n77bQDAjh07MGHCBA1X1LrS09OxZMkS8RNaZ2dnbNmyBXPnzmXnjjocqVSKGzduKKxkfvPmTaVxZmZmGDRokBi6hwwZAhcXFw1UTB2dTCZT6mrX7mzn5OTUebyRkRE8PDxUrkLu6ekJKyurNnonRO2ffLp3U/cDb2jYlXe7a19n3pg6kpKSxD3BGxquG7KYHGk3BnHSqNOnT+Oll14CACxbtkzttKH2oLq6Gh999BHWrVuH0tJS6OvrY9GiRVi/fj33I6YOIzc3V6HbfeHCBRQXFyuN8/b2Vtg+rF+/fjAyMtJAxdQRlZSUIDk5WeX08eTk5Hq72vb29mpXIHd1dWVXm6iNyKeYDx48uFHHyQNuQ6d+19cRl3e71QV1eee+9u/BkZGRSnub15aXl9fozj1pFwZx0pjExERMmzYNVVVVmDZtmtrFLdqDkydP4vXXX8f169cBAMOHD8fOnTvRv39/DVdG1Hpqampw9epVhZXM5Zdi1GZubo7HH39cDN1DhgxB586dNVAxdRQymQyZmZkqp48nJiYiOzu7zuMNDQ3h7u6udgo5P1wl0g6DBg1CXFxcvV1miUSCS5cuiUFaPj4pKUntVPLa5OdQ16GuL6jLZ0kGBQWJj4WHh9cZxBuyzzlpNwZx0oiCggIEBAQgNzcX/v7+4vXh7U1WVhaWL1+Ob7/9FsDDa/82b96MF198kavXUrvz4MEDhdB98eJFlJWVKY3r0aOHwkrmffv2bZd//0mzSktLFbratTvbycnJqKysrPN4W1tbtSuQu7q6wtCQv0IRtQapVIrCwkLk5+cr3PLy8pQey8/Px4kTJ2BqaqrytYKDgxEREYG4uLg6p4UHBwer3Ne7IduDyUN0Xdd2x8XFif+OPEoikSApKUmhvsjIyHoXbUtKSmp0p5+0C/8vQm2uqqoKzzzzDG7fvg1XV1ccOXKk3a0QXlNTg127dmH16tUoKiqCnp4egoKCsGnTJk4jonahqqoKV65cUVjJPCUlRWmctbU1hgwZIobuIUOG8O8AtQiZTIasrCyVe2onJSUhKyurzuMNDAzErraqFchtbW3b6J0QtU9SqRQFBQUqw7O6UJ2XlweJRAJBEBp8nvz8fLVrhvj5+SEoKAihoaEICgpS6IxLJBJEREQgMTER+/fvV+qajxs3DhcvXqz3/PVdH15fN1x+XnlIT0pKQnR0tDhdXZ24uDjs3r273vpIezGIU5sSBAGvvfYaTpw4AQsLCxw9erTdLbh07tw5vPbaa7h8+TIAwN/fH7t27eKnlqTTMjIyFEJ3bGysUkdRT08PvXv3Frvdw4YNQ8+ePTn7g5qsoqJCYQXy2l+Tk5NRUVFR5/HW1tbw9vZWOX3czc2NXW2iBqipqUFBQUGd4VnV483dWsvCwgJ2dnaws7ODvb29eL/2zd7evt5LQcLDwzF+/HjMnz8fdnZ2CoE7ODhY7fTu8ePHN2grMfmU9LqmkXt5eSEkJETt89HR0QgJCRGvEW9ICAdUb71GukNPaMxHTrUUFRXB2toahYWFXOGTGuzdd9/FypUroa+vj6ioKDz99NOaLqnF5ObmYuXKlfj0008BPPyHedOmTQgKCuK0W9IpFRUViIuLU5hmnp6erjTOzs5OYfuwwYMH89pYahRBEJCXlyeG69pBOzExERkZGXUer6+vr9DVfrS7za420f+pqqoSO9SNCdVFRUXNOq+VlZVSeFYXquX3bW1tYWxs3ELvvOlsbW0RGxurdddib968GYmJifUG9vaqveRQfhRMbSYyMhIrV64EAHz00UftJoTLZDJ89tlneOutt8TVOV966SWEhYVxwSnSeoIgIDU1VaHbHR8fj+rqaoVx+vr66Nevn8JK5r6+vtxyj+pVU1ODtLQ0pZAtv1/fL/kWFhZiV1sesOVf3dzcuJo+dTiVlZUN6kg/+lxJSUmzzmtjY1NneFb1nI2NjU7/HQ0KCkJ4eLjWLSgcHh6udE076R4GcWoT58+fxwsvvAAAWLRoERYuXKjhilpGXFwcFixYgPPnzwMAHnvsMezcuRMjR47UcGVEqlVUVCA2NhZnz54Vb5mZmUrjHB0dMWzYMDF0Dxo0CBYWFhqomHRBSUmJ2q72vXv3UFNTU+fxLi4uCiG79n0HBwd+4EPtUnV1tUJYzsvLU3n/0VCtahHMhtLT04OtrW29HelHb7a2th1ydl9wcDD8/f21KojLV2jntHTdxyBOrS4lJQVTpkxBRUUFAgICsHXrVk2X1GyFhYVYs2YNduzYAZlMBgsLC7zzzjtYuHChTn/yS+1PWloazpw5I4ZuVd1uAwMDDBgwQCF4e3p6MvyQSBAEZGVlqe1q17fdl7GxMTw9PZVCtre3Nzw8PNCpU6c2eidELU8mk6GwsFBtkFZ1Py8vD8XFxU0+p76+PmxtbevtSD/6mLW1dYcM1E3l5eWFoKAgREREKGwtpkkhISFcpK2dYBCnVlVYWIhJkyYhOzsb/fv3x549e3T6fwCCIGDv3r1YsmSJuCLv7Nmz8cEHH7S7RedI91RWViIuLk6h263qGtvOnTuLoXvYsGEYNGgQgxChsrIS9+7dU9nVTkpKQnl5eZ3H29nZqe1qd+3alYv2kdYTBAFlZWUKYbkhobqgoAAymaxJ59TT04ONjQ3s7e3F4Fz7vqrv7ezsYGVlxb9TbWTlypUYO3YsZs2aVe9+5K0tJiaG3fB2hEGcWk11dTVmzZqF69evo0uXLjh69CgsLS01XVaT3b17FwsWLBC3ofD19cWOHTvUbldB1NrS09MVQndcXByqqqoUxhgYGKB///4KwZvd7o6roKBAIWDXDtxpaWl1bhmkr68PNzc3hWu0awduTf+CSlRbVVWVUge6IaH60X9DG8Pc3FxloFYVsOX3bWxsdLpB0RHY2Nhg9+7dmD9/vkavy5ZIJAgLCxO3SyPdxyBOrUIQBCxatAi//vorOnXqhKioKLi6umq6rCapqKjAu+++i9DQUFRVVcHExASrVq3CihUrYGpqqunyqIOorKxEfHy8QvBWtZJ57Wu75d1uc3NzDVRMmiCVSpGRkaF2CnlBQUGdx3fq1EkpZMu/d3d314pVjKljkUqlkEgkdU7xVvVccxYmMzIyalCIrv29nZ0dTExMWvCdkzbx8/PD7NmzsXnzZqxYsUIjNYSEhHTYVdLbKwZxahVbt25FeHg49PT08P3338Pf31/TJTXJr7/+itdffx0JCQkAgAkTJmDHjh3w8fHRcGXU3sn37ZbfYmNjVXa7+/XrpxC8vby82O1u58rKysS9tR8N3CkpKfV29JydnVVOH/fy8oKTkxN/fqhVCIKAkpKSRl1DnZ+fj4KCgjpnatRFT09P5fTu+kK1ubk5/x6QkpkzZyImJgYSiaTNZwDFxcUhLCyMM4/aGe4jTi3u8OHDmD59OgRBwJYtW7B06VJNl9Ro9+/fx5IlS7Bv3z4AQJcuXfDhhx8iMDCQ/3OmFldVVaXU7U5LS1Ma5+DgoBC6Bw8ezG53OyQIAnJyctR2tVWtcl+bkZERPDw8VE4f9/Ly4s8MNVvtxclyc3PF4Fzf/eZM+7a0tKwzSKu6b2Njw+uoidqh9pJD2RGnFhUbG4tnn30WgiDg1VdfxZIlSzRdUqPU1NRg586dWL16NYqLi6Gvr49FixbhnXfe0em/6KRd7t+/r9TtrqysVBgj37e7dvD29vbmB0HtRHV1NVJTU9UujFbftFpra2uVe2t7e3vD1dWV15xSg9XU1KCgoKDeEF37sfz8fEil0iadz8TEpMGd6doLlPGyCCJqbxjEqcWkpaVh8uTJKCsrw4QJE7Bt2zadCg0XLlzAq6++ivj4eADAkCFDsGvXLgwcOFDDlZEuq6qqwuXLlxWCd2pqqtI4e3t7pW439+3WbUVFRWq72qmpqXUGGT09Pbi6uqpdhdzOzq4N3wnpisrKSoWp3fUF6tzcXEgkkiafz8LCQgzMDg4Odd6Xf+3UqZNO/W5ARNRaGMSpRRQXF2Py5MnIzMxEnz59sG/fPp3ZT7ugoACrVq1CeHg4BEGAjY0N3n33XcyfP59T2qjRMjMzlbrdFRUVCmP09fXx2GOPKQRvHx8f/nKqY2QyGTIzM9WG7dzc3DqPNzU1VRmyvb294e7uzsUgO7BHt9FSF6Ifvd+cBcrkW2g1NFDb29tzcTIiomZgEKdmq6mpwdy5c3HlyhV07twZR48ehbW1tabLqpcgCPjuu++wbNkyZGdnAwDmzZuH9957D507d9ZwdaQLqqurlbrd9+7dUxpnZ2en1O3W5a38OpLKykqkpKQgISFBKXAnJycrfcjyKEdHR7VdbWdnZ37Y1wHIFynLzc0Vbw0J1/X9bKmjr68POzu7RgVqOzs7GBryV0IiorbEf3Wp2ZYuXYpjx47B1NQUR44cgYeHh6ZLqtetW7ewYMECnDhxAgDQq1cv7Ny5E2PGjNFsYaTVsrKyFEL3pUuXVHa7+/btqxC8fX192e3WYsXFxUhMTBTDdu379e2tbWBgAHd3d5VdbU9PT64t0Q6Vl5crhOqG3Jq6SJmRkVGjArWDgwOsra35AQ8RkQ5gEKdm2b59O7Zv3w4A+OabbzBkyBANV1S38vJybNy4EZs3b0Z1dTXMzMywZs0aLFu2jAvBkIKamhpcvXoVZ86cwZkzZ3D27FkkJycrjbOzs8PQoUPF0P3444+z261laq9Crips5+Tk1Hm8hYWFwsJotQO3m5sbO4k6rLq6WuxE13XLyckR75eVlTXpXKampnBwcBBv9QVqe3t7WFhY8EM8IqJ2ir89UJMdO3YMb775JgAgNDQUM2fO1GxB9fjpp5+wcOFCMUxNmjQJ27Ztg6enp4YrI21QUFCAc+fOicH7/PnzKC0tVRijp6eHPn36YPjw4WLw7t69O39R1gJSqRTp6elqw3Z9187Kp5B7e3vDx8dH4b6joyP/G+sAqVQqrv7d0FthYWGTzmVoaAgHBwc4OjoqhOu6bp06dWrhd0xERLqMQZya5MqVK5gzZw5kMhlefvllhISEaLoktdLT0/HGG2/g4MGDAABXV1ds374dU6dO5S/XHZQgCLh9+7YYus+cOYObN28qjbOyssKwYcPE4P3444/rxPoH7VVlZSWSk5OVwrb8eu26pv/q6emhW7duKsO2t7c3p5BrGUEQUFRU1KhQnZ+fD5lM1uhz6enpiV3oht6srKz4/w8iImoWBnFqtPv372PSpEkoKSnBE088gZ07d2rlLyQ1NTXYtm0b3n77bZSWlsLAwABLlizB2rVruS1UB1NaWoqLFy8qTDPPz89XGte9e3cMHz5cvPXq1YvXWrYx+ZZfqsJ2fddrGxkZKVyjXTtse3p6coVnDaqpqVGY5l379uhj8nE1NTVNOpe1tbVScK6rc21jY8N914mIqM0xiFOjlJaWYvLkyUhPT0fPnj0RGRmplddWnz17Fq+++ir+/vtvAMCIESOwa9cuPPbYYxqujFqbIAhIS0tT6HZfvnxZac9mU1NTPP7442LoHjp0KBwdHTVUdcchCAKys7NVhu2EhIR6t/yysLBQmjouv+/q6spA1UbKy8sbFKjl9wsKCpp0HnNz80Z1qu3t7XVm60wiIurYGMSpwaRSKZ577jnExcXBwcEBR48eha2trabLUlBQUICVK1ciPDwcAGBvb4/NmzfjpZdeYmeznaqqqsLly5cVgndGRobSuK5du2LEiBFi8O7fv79WfojUHkilUqSlpantbDfkem11YZvXa7c8QRBQWFjYoEAtvzVlwTI9PT3Y2dnB0dFRvMm71aq+t7e3h5mZWSu8YyIiIs1jEKcGCwkJweHDh2FsbIxDhw7B29tb0yWJBEHADz/8gCVLluDBgwcAgH//+98ICwuDg4ODhqujlpSdnY2zZ8+KoVvVFmIGBgYYOHCgwjTzbt26aaji9qmiokK8XvvRsJ2cnIzq6mq1x9a+XvvRwO3l5cXrtZuppqZGXAm8odPA6/rvpY6RkVGDArX8ZmdnxxkLRERE/x+DODVIeHg4tmzZAgD48ssvMWLECA1X9H8SExOxYMEC/PrrrwCAnj17Ijw8HKNHj9ZwZdRcUqkUN27cUOh2JyQkKI2zt7dXCN2DBg3iCsUtoLCwUKGTXTtsp6en13m9trGxMTw9PVWGbQ8PD16v3QgymQz5+fnIzs5GTk6OwldVj+Xn59f530YdCwuLBgVq+WNcsIyIiKjpGMSpXr/++itef/11AMA777yDuXPnariih6qqqrBlyxa88847qKiogImJCVavXo3ly5fzl3wdVVRUhPPnz4uh+9y5cygqKlIaJ99CTH7z9fVlIGgC+f7aCQkJKrf8qu96bUtLS7VbfnXt2pXdTzUEQYBEIqk3UMu/5ubmNmk18NrTwOsK1PL7nAZORETUdhjEqU7Xrl1DYGAgpFIpXnjhBaxevVrTJQEATp8+jeDgYFy/fh0AMHbsWOzatQu+vr4arowaShAEJCUlKXS7r169qtTJMzc3x9ChQ8XQPWTIEK1bm0CbCYKArKwsMWw/elP1QUdtnTt3Vhu2HRwc+AEIHv4ZFxcX1xuo5fdzcnKatCK4ra0tHB0d0blzZ/Fr7fu1v9rb28PQkP+LJyIi0lb8vzSp9eDBA0yaNAlFRUUYPXo0du/erfFfugsKChASEoLdu3cDeLio09atW/Hss89qvDaqW2VlJWJjY3H69GkxeGdnZyuN8/T0VOh29+3bl4GiHjKZDJmZmUhISMDdu3eVwnZpaanaY+XXa8tD9qP7a1taWrbhO9EeFRUVyMnJwYMHD8QQLb+vqotd1x7m6lhZWakN0o+GbAcHB64GTkRE1I7wt1tSqby8HFOnTsW9e/fg4+ODgwcPanS6tyAI2LNnD5YsWSKGt1deeQVhYWGws7PTWF2kXl5eHs6cOYO//voLp0+fxqVLl1BZWakwxtjYGP7+/mLoHjZsGLp06aKhirWbTCZDenq6GK5rB+7ExESUl5erPVZfXx/u7u7w8fGBr68vfHx8xJunpydMTU3b8J1oRu3p4LVDtaqg/eDBg3pnCqhibm5eZ5f60a+8hIaIiKjjYhAnJTKZDPPmzcP58+dhZ2eHY8eOwd7eXmP1JCYm4rXXXkN0dDQAoFevXggPD8eoUaM0VhMpEgQBCQkJOH36tBi8b926pTTO0dFR3EJsxIgR8PPz6xAhsKGkUilSU1MVutnywJ2UlKT0QUZtBgYG8PT0FAN27cDt4eHRLrdqq66uVuhaqwvV8scauzK4kZEROnfuDCcnJzFg177VDtWOjo5cIJCIiIgajEGclKxevRqRkZEwMjLCwYMH0b17d43UUVVVhffffx8bNmwQF2Nbs2YNli9f3i5DhS6pqqpCXFwcTp8+Ld5UTTPv2bMnRowYgZEjR2LEiBHw8fHp8JcQ1NTUICUlRWn6+N27d+vd9svIyAheXl4KHW154HZzc2sXU5dLS0vx4MEDZGVlKYXpR4N2QUFBo1/f2tpaDNLygF07aNd+zNrausP/vBIREVHrYBAnBV988QVCQ0MBAJ9++in+8Y9/aKSOv/76C8HBwbhx4wYAYNy4cdi1axd8fHw0Uk9HV1BQgDNnzoih+8KFC0p7dxsbG2Pw4MFi8B42bFiH3cO9qqoKKSkpKq/XTklJqXOhLhMTE/Fa7UcDd7du3XRyJXJ5uK4dsB+9L/++ruvZVTEwMICjo6PaMF37MUdHR87AICIiIq3AIE6i33//HUFBQQAedsXnzZvX5jXk5+cjJCQEn376KQAuxqYJgiAgOTlZnGJ++vRpcXX62uzt7TFixAjx5u/v36FCTkVFBZKTk1UukHbv3r06t5syMzNTCtrym6urK/T19dvwnTRN7XBdX8AuKSlp1GubmZnByckJTk5OcHZ2rrNrbWtrqxN/XkRERES1MYgTAODWrVt45plnUFNTgzlz5uCdd95p0/MLgoB9+/Zh8eLF4hTn+fPn49133+VibK2suroaly9fVgjeWVlZSuN8fX3FKeYjRoxAjx492v2HIxUVFUhMTFQI2vL7aWlpSlut1WZubq60MJr81qVLF60Mj5WVlXjw4AEyMzORmZlZZ8Buarh2dnYWQ/aj38vvW1hYtPufLSIiIurYGMQJOTk5CAgIgEQiwbBhw/DFF1+06S/BqampWLBgAY4dOwbg4WJsERERGDlyZJvV0JEUFhbi7NmzYvC+cOECysrKFMYYGRnB399fnGY+fPhwdO7cWUMVt67q6mqkpKTgzp07uHv3Lu7evSveT01NrTNsW1lZqVyJ3MfHB05OTloRJgVBQFFRETIzM5GVlSWGbFX38/PzG/XapqamYniuL2AzXBMRERH9HwbxDq6iogLTp09HUlISPD09cfjw4TabXiyVSrFz506sWrUKJSUlMDIywn//+1+89dZb3NanBd27d08M3X/99ReuXbumFC5tbW3FlcxHjhyJQYMGwczMTEMVtzyZTIa0tDQxYNcO3cnJyXVes21tbQ1fX1/xVjtsOzg4aCxcSqVS5OTkNChg17W12aOMjIzQpUsXODs7qwzZte9bWloyXBMRERE1AYN4ByYIAl5++WWcPn0a1tbWOHbsGBwdHdvk3NeuXcP8+fNx7tw5AMDw4cOxe/du9O7du03O314JgoCbN2/izz//xJ9//olTp04hLS1NaZy3t7fC9d29evXSyqnSjSEIAjIzM5WC9p07d5CYmFjn1l+dOnUSg3b37t0V7rd12C4vL683WGdmZiI7O7vO69AfZWVlhS5duoghW919Ozs7hmsiIiKiVsYg3oGtW7cO33//PQwNDXHgwAH06tWr1c9ZWVmJjRs34t1330V1dTUsLS0RFhaG4OBgnQ+CmlBTU4P4+HgxdP/111/Iy8tTGGNgYICBAwdi1KhRYvB2dnbWUMXNIwgC8vLyVE4jv3v3bp0rbhsbG8Pb21shbMu/uri4tGr4FAQBBQUFakN17e8LCwsb/Lp6enro3LlzgwI297gmIiIi0h4M4h3Ut99+Ky7ItmvXLowdO7bVz/nXX39h/vz5uHXrFgBgypQp2LFjB1xdXVv93O1FeXk5zp8/j1OnTuHPP//E2bNnlcKnqakphg4dilGjRmH06NEYOnQoLCwsNFRx0xQWFqoM2nfu3IFEIlF7nIGBATw8PJS62r6+vnBzc2vxrb9kMhlyc3ORkZGBjIwMtV3srKysOjvyjzI1Na03WHfp0gWOjo4wNOQ/40RERES6hr/BdUB//vknXn75ZQDAihUr8Morr7Tq+QoLC/HWW2/hk08+AQA4Oztj+/bteOaZZzgFth4FBQU4ffq0ONX80qVLqK6uVhhjY2ODkSNHYtSoURg1ahT8/f1hbGysoYobrqysDAkJCSq72/KV89Vxc3NTOZXc09Ozxd57eXm5GLDV3TIzM5X+e9TF1ta2Qd1ra2tr/t0gIiIiascYxDuYu3fvYtq0aaiqqsIzzzyD0NDQVj3f4cOHsWDBAty/fx8A8Morr2Dz5s2wtbVt1fPqqvv374uh+88//8TVq1eVFlZzcXERQ/eoUaPQt29frZ3WL18k7fbt20o3Vdeu1+bs7Kzymm1vb+9mLSQnk8mQk5NTb8iuq/Nem56eHpycnODi4gIXFxe1IdvZ2ZmLEBIRERERAAbxDiU/Px8BAQHIz8/H4MGD8fXXX7dagMvJycHixYvxww8/AHi4B3VERATGjBnTKufTRYIgICEhQWFhtaSkJKVx3bt3Vwjenp6eWtctLSoqUhm27969W+eK3XZ2diqnkfv4+MDKyqrRdZSVlTWoi13XKum1mZubo2vXrnBxcUHXrl1V3pydnWFkZNToWomIiIio42IQ7yCqqqowY8YM3L17F25ubjhy5EirLN4kCAL27duHhQsXIjc3FwYGBvjPf/6DtWvXtqvtsJpCvqL5H3/8gZMnT+LkyZN48OCBwhh9fX30799fDN0jR47UmoXVampqkJKSojJwZ2VlqT3OyMgIPj4+6NGjh9LN3t6+QeeWyWTIzs6uN2Q3dKEzeRdbXbiW36ysrLTuQw8iIiIi0n0M4h2AIAgICgrCyZMnYWlpiWPHjrVKuMvKysKCBQvw448/AgAee+wxfP755xg0aFCLn0sXCIKAGzduiMH7jz/+QE5OjsIYY2NjPP7442LwHj58OKytrTVU8UP5+fliwL5165Z4PzExEVVVVWqPc3Z2Vhm2PTw86lxQTD5VPDU1FWlpaUpfMzIykJWV1egudl03Z2dnLnJGRERERBrD30Q7gE2bNuGrr76CgYEB9u/fj759+7bo6wuCgG+++QZvvvkmCgoKYGhoiP/+979YtWqVTiwa1lJkMplC8D558qRS8DYzM8Pw4cMxZswYjB49Go8//jhMTU3bvNaqqiokJSWp7G7n5uaqPc7U1BS+vr7o0aMHevbsKYbt7t27q/0AoaioSGXAln9NS0urM+DL6evr19vFdnFxYRebiIiIiLQeg3g7t3fvXqxevRoAsH37djz55JMt+vrp6ekIDg7GTz/9BAAYOHAgvvjiC/Tv379Fz6ONagdvefh+NMSamZlhxIgRGDNmDMaMGYPBgwe36YcTRUVFuHXrFm7cuIGbN2/i5s2buHXrFpKSkiCVStUe5+rqqrK77ebmprCuQFVVFTIyMnD58mW1Ybsh08X19PTg4uKCbt26wc3NTfzq6urKLjYRERERtTv8rbYdO3v2LF588UUAwJIlS/Daa6+12GsLgoDPP/8cS5cuRVFREYyNjbFu3Tr85z//abcLV8lkMly/fl0heOfl5SmM6dSpk0LwHjRoUJsE75ycHDFoy0P3jRs3kJGRofYYc3NzlWG7e/fuMDc3F6/LlgfqQ4cOKQXtrKwspVXdVbG1tVUI2I9+dXFxabc/N0REREREj2IQb6eSkpIwdepUVFZWYsqUKXjvvfda7LXv37+P+fPni13wIUOG4PPPP0fv3r1b7BzaQCaT4dq1awrBOz8/X2FMp06dMHLkSDF4t+Ye3oIgICMjQ6G7Lb9f13RyZ2dn9O7dG7169UKvXr3Qs2dP9OzZE05OTsjKykJycjJSUlJw584d/Prrr0hOTkZqairS09MbNGXcxMSkzpDdrVs3WFhYtOQfBRERERGRTmMQb4ckEgkCAgKQk5ODgQMH4rvvvoOBgUGzX1cQBPzwww94/fXXUVBQAGNjY2zYsAHLli1rkdfXNPl2Yr/99ht+++03/P7770rB29zcXCl4t3QnVyqVIjk5Wam7fevWLRQXF6s9zsPDA7169RJDd8+ePWFvbw+JRCKG7StXruDw4cNITk7GvXv3UF1dXWct+vr66NKlS51B28HBgddkExERERE1AoN4O1NdXY2ZM2fi1q1b6Nq1K6KiolqkG5mTk4MFCxYgMjISAODn54evv/4affr0afZra1JWVpYYvGNiYpCWlqbwvIWFhRi8//GPf7Ro8K6ursadO3cUwvbNmzdx+/ZtVFZWqjzGwMAAvr6+YtB2c3MT//tmZmYiJSUFN27cwE8//YSUlJQ69/AGAENDQ7i5ucHDwwOenp7w9PSEh4cH3N3d0a1bN04ZJyIiIiJqBQzi7YggCFiwYAF+++03mJub4+jRo+jatWuzX/fw4cMICgpCdnY2DA0NsXr1aqxatUonA1phYSFOnjwpBu8bN24oPG9sbIzhw4dj7NixGDt2LAYNGtTs9ymTyZCamoqrV6/i2rVr4tdbt26p7UibmpqiR48e8PX1RefOnWFhYQE9PT2UlJQgLS0NCQkJiImJqbNDDjxcBM3V1VUM2LW/enp6wsXFhQugERERERG1Mf4G3o68//77+PTTT6Gvr48ffvgBAwYMaNbrSSQSvPHGG/j6668BAH369MHXX38NPz+/Fqi2bVRUVODs2bNi8L506ZLCauF6enoYOHAgxo0bh7Fjx2LkyJHo1KlTk8+Xk5OjFLivXbuGkpISleMtLS3Ro0cPODs7i9tulZWVISsrCwkJCbhy5Uq953R2dlYK2PL73bp161BbyBERERER6QIG8Xbi4MGDCAkJAQB88MEHmDRpUrNe7+TJk3jhhReQlpYGfX19LF++HOvXr4eJiUlLlNtqpFIp4uPjxenmf/75JyoqKhTG+Pr6YuzYsRg3bhzGjBkDe3v7Rp+npKQE169fVwjcV69eRXZ2tsrxRkZGcHd3h5OTE8zMzCCVSiGRSJCamopLly7VeS57e3ulgC3/6u7uDjMzs0bXT0REREREmsMg3g5cvHgRzz//PARBwOuvv47Fixc3+bWqqqqwbt06vPvuuxAEAd7e3vj6668xfPjwFqy4ZWVlZeH48eM4fvw4fv31V6UtxZydncWp5mPHjoWbm1uDX1sqleLOnTu4cuWKQuhOSkpSOV5PTw+Ojo6ws7ODoaEhKioqkJOTg8LCQiQkJCAhIUHlcU5OTvD19YWPj4/4VX6zsrJq+B8GERERERFpPQZxHZeamorJkyejvLwcTz31FD788MMmr2B9+/ZtPPfcc4iNjQUAvPzyy/jwww+1buupqqoqnDlzBr/88guOHz+Oy5cvKzxvaWmJf/7zn2Lw7t27d4P+TMrKynD16lVcvnwZ8fHxuHz5Mv7++2+1C55ZWlrCwsICMpkMxcXFKCsrgyAIyM7OVtkZ79Kli1LQ9vX1hbe3NywtLZv0Z0FERERERLqHQVyHFRUVISAgAA8ePMBjjz2GH374oUkLbwmCgE8//RRvvvkmysrKYGtri927d+OZZ55phaqbJjk5Gb/88gt++eUX/P7770rXXPv7+2PixImYOHEihgwZUu8Ca3l5eWLYjo+PR3x8PG7fvg2ZTKY01sjICJaWlpDJZCgqKhLHFBcXKy2W5uLiorKz7e3trXUfaBARERERkWYwiOuompoazJ49G9euXYOzszOOHj3apCnMubm5mD9/Pg4dOgQAeOKJJ/DVV1/B1dW1hStunNLSUpw8eVIM33fv3lV4vnPnzpgwYQImTpyI8ePHo3PnzipfRxAE3Lt3Twzb8uCdnp6ucryxsTH09fUVriuvrq5W2E+8U6dO6NmzJ3r16iVuI9a9e3d4eXnB3Ny8Bd49ERERERG1ZwziOkgQBCxevBi//PILzMzMEBUV1ajrnuViYmIwb948ZGZmwsjICKGhoViyZAn09fVboer6JSQkICoqCj/99BNOnTqFqqoq8TlDQ0MMHz4cTz75JCZOnIgBAwYo1SkIAtLS0nDhwgVcvHgRFy9eRHx8PCQSicrzGRgYKKygDkDhnPb29mLYrn3r1q2bxv6MiIiIiIhI9zGI66CPPvoIu3btgp6eHr777jsMGjSoUcfX1NRg3bp12LRpEwRBQK9evfD99983e7uzxpJKpTh37hyOHDmCqKgo3Lx5U+F5d3d3TJw4EU8++SSeeOIJWFtbKzyfl5cnBu4LFy7gwoULalctV3d+AHBzc1MZuB0cHJr/JomIiIiIiB7BIK5joqKisHTpUgDA5s2bMX369EYdf//+fcydOxenTp0CAAQHB+ODDz5o1t7ZjVFcXIxff/0VR44cwU8//YTc3FzxOUNDQ4wePRqTJk3CU089hR49eoiLrJWVleH06dNi4L548SISExMbde6uXbuiX79+6NevH/r27YtevXqhR48evHabiIiIiIjaFIO4DomPj8fcuXMhCALmz5+PZcuWNer448eP44UXXkBOTg4sLCywe/duzJkzp5Wq/T+pqamIiopCVFQUTpw4oTD928bGBk8//TSmTJmCJ598EjY2NpDJZLh16xY+++wzMXhfu3ZNaRq5Op06dcJjjz2Gfv36KXy1s7NrrbdIRERERETUYAziOiI9PR2TJk1CaWkpxo8fjx07djR4m7KamhqsXbsWmzZtAgD0798f+/fvh6+vb6vUKggCrl27hgMHDuDQoUO4cuWKwvM+Pj6YMmUKJk+ejBEjRkAqleLixYv45JNPcPr0afz1119qr+t+VNeuXTFw4ED4+fmhf//+6N+/Pzw9PXkNNxERERERaS0GcR1QUlKCyZMn4/79++jduzf27dtX7/ZcchkZGZg7dy7+/PNPAMBrr72GDz74AKampi1aoyAIuHTpEg4ePIgDBw4orHKur6+P4cOHi+Hb3t4ep0+fxrFjx7By5UpcunQJNTU19Z7Dw8MD/v7+8PPzg5+fHwYOHAgnJ6cWfR9EREREREStjUFcy0mlUjz77LO4fPkyHB0dcfToUdjY2DTo2D/++AOzZs1CTk4OLC0t8emnn2LWrFktVptMJsOZM2dw4MABHDx4EKmpqeJzJiYmePLJJzFjxgwMGzYM165dw4kTJzBt2jTcvn273tfu3r07Bg0aJIbuAQMGwNbWtsVqJyIiIiIi0hQGcS33n//8B1FRUTA1NcWRI0fg6elZ7zGCIGDbtm1YtmwZpFIpBgwYgP3798PHx6fZ9QiCgNjYWOzZswd79+5FRkaG+Jy5uTmefvppPPnkk+jUqRPOnTuHTZs24c6dO3W+prW1NYYPH45hw4Zh6NChGDx4cIM/bCAiIiIiItI1DOJabOfOnfjwww8BAF999RWGDh1a7zHl5eUIDg7GN998AwB47rnnEBER0exV0W/evIk9e/Zgz549SEhIEB+3srLC008/DV9fX+Tn5yM6OhqRkZEQBEHl6+jr66NPnz4YNWoUhg4diqFDh8LHx6fB17sTERERERHpOgZxLfXzzz9j0aJFAICNGzc2aEr5vXv3MH36dMTHx8PAwABbtmzB4sWLmxxyHzx4gO+//x5ff/01Ll++LD5uamqKMWPGwMnJCTdu3EBkZKTaa7xNTEwwZMgQjB8/HqNGjcLgwYPbbKs0IiIiIiIibcQgroX+/vtvzJo1CzKZDC+99BJWrlxZ7zG///47Zs2ahby8PDg6OmLfvn0YM2ZMo89dUVGBqKgofPXVV/jll1/ELcMMDAwwcOBAGBoa4ubNm/jll19UHm9ubo4RI0ZgwoQJGD16NAYMGNDgheWIiIiIiIg6AgZxLZOZmYlJkyahpKQEY8aMQXh4eJ0dbUEQsHXrVixfvhwymQz+/v44ePAg3NzcGnXey5cvY/fu3fj+++8Vtg7z8PAAAKSlpeHSpUtKx5mYmGD48OGYOnUqxo4di969e3PrMCIiIiIiojowiGuR0tJSTJkyBWlpaejevTsOHDgAY2NjteMrKirw8ssv4/vvvwcAvPjii9i1axfMzMwadL6SkhL88MMPiIiIwMWLF8XHraysoK+vD4lEgpSUFIVj9PT00Lt3b0ybNg1PP/00Bg8ezI43ERERERFRIzCIawmZTIYXXngBly5dgr29PY4dOwY7Ozu143NycjB16lScPXsWhoaG+PDDD7FgwYIGXQ9+9epVfPzxx/j+++9RUlIC4OEiaiYmJigvL0dRUZHCeAsLC4wdOxbPP/88JkyYACsrq+a9WSIiIiIiog6swUG8srISlZWV4vePhjVqnrfeegs//vgjjI2NcejQoTq3Grt16xYCAgKQlJQEGxsbHDx4EP/85z/rfH2pVIqjR4/io48+wokTJ8THDQ0NUVNTA5lMhvLycvFxNzc3zJo1C3PmzMHAgQM53ZyIiIiIiLTGo3nUxMQEJiYmGqqm8RocxENDQ7F+/frWrKXD2r17N9577z0AwOeff46RI0eqHfv777/jmWeegUQigZeXF3766Sf06NFD7fjCwkJ89tln+Pjjj5GcnKz0fO3Vzn19ffHiiy/i+eefh7u7ezPeERERERERUevp1q2bwvdr167FunXrNFNME+gJ6jZ8foSqjni3bt1QWFjIqcrNEBMTg4kTJ0IqlWLdunVYu3at2rFffPEFgoKCUFNTg+HDh+PQoUNwdHRUOfbBgwfYunUrdu7cieLiYrWv6ePjg+DgYLzwwgtwcnJq9vshIiIiIiJqLUVFRbC2tkZaWppCDm23HXFde2O64MaNG5g5cyakUimee+45vP322yrHyWQyrFmzBps2bQIAzJkzB1988QVMTU2Vxt67dw/vv/8+du/erfDBSW3Ozs6YN28eFi9ejK5du7bcGyIiIiIiImoDVlZWOt0Q5mJtGpKdnY2AgAAUFhZi5MiR+Oyzz1QutFZeXo5//etf2Lt3LwBg9erVWL9+vdI12wkJCdi4cSO++eYbce/v2oyNjTF58mSsX78effr0aZ03RURERERERPViENeA8vJyTJ06FSkpKfD29saPP/6ocrZB7ZXRjYyMEBERgZdeeklhTGZmJjZs2ICIiAiVAdzHxwcrVqzAiy++WOdWaERERERERNQ2GMTbmEwmw0svvYRz587B1tYWx44dg4ODg9K4pKQkTJgwAYmJiSpXRi8sLMTmzZuxZcsWpSnoBgYGCAgIwJYtW+pcfZ2IiIiIiIjaHoN4G3v77bexb98+GBoa4uDBgypXPL969SomTJiArKwseHh44Oeff0bPnj0BAFVVVdi+fTvWr1+vtAibubk5goKCsH79elhaWrbJ+yEiIiIiIqLGYRBvQ19++SU2btwI4OGWZWPGjFEac+bMGQQEBEAikaBv3744fvw4XFxcAADR0dF4+eWXkZaWpnCMg4MDNmzYgKCgIO73TUREREREpOWY2trIH3/8gaCgIADAqlWrlK71BoBffvkF48aNg0QiwbBhw3Dq1Cm4uLggLS0NAQEBmDBhgkIIt7e3R0REBLKzs/Hqq68yhBMREREREekAJrc2cPv2bcyYMQPV1dWYNWsWNmzYoDTmhx9+wOTJk1FeXo6JEyciOjoalpaW2LhxIzw9PfHTTz+JY21sbPDJJ58gJycH8+fPV7naOhEREREREWknTk1vZbm5uQgICEBBQQGGDh2KL7/8UqlzvWvXLrz++usQBAFz587Fl19+iYSEBDz11FNITU0VxxkaGmLVqlVYu3Ytu99EREREREQ6immuFVVWVmL69OlITEyEh4cHDh06BDMzM/F5QRCwYcMGLFiwAIIgYMGCBfjqq6+wZs0a9OnTRyGET5kyBfn5+Sr3ECciIiIiIiLdwY54KxEEAa+88gr++usvWFlZ4dixY3BychKfl8lkWLp0KT766CMAD1dTf/bZZ+Hh4YH79++L43x9fXH48GH06tWrzd8DERERERERtTwG8Vbyzjvv4Ntvv4WBgQEiIyPRu3dv8bnq6mq8/PLL+OabbwAAW7duRU5OjrhFGfBwGnp4eDj+/e9/t3ntRERERERE1HoYxFvBd999h3Xr1gF4eP33+PHjxefKy8sxe/ZsREVFwcDAANu2bcN7772HlJQUcYyfnx9+//13WFtbt3HlRERERERE1NoYxFvYX3/9JXax//Of/2D+/Pnic2VlZZg6dSpiYmJgamqK//73v3jjjTdQU1MD4GEX/LPPPsO8efM0UjsRERERERG1PgbxFpSYmIhp06ahqqoK06ZNQ1hYmPhcaWkpJk+ejBMnTqBTp0548sknsWbNGvH5AQMG4NSpU7C0tNRE6URERERERNRGuPx2CykoKEBAQADy8vLg7++Pb7/9VlzdvKSkBAEBAThx4gQsLCxgb2+PH3/8UTx2w4YNiI+PZwgnIiIiIiLqANgRbwFVVVWYMWMGbt++jW7duiEqKgrm5uYAgOLiYjz99NP466+/0KlTJ1RWViItLQ0AYGpqijNnzmDgwIGaLJ+IiIiIiIjaEIN4MwmCgFdffRV//PEHLCwscPToUXTp0gUAUFRUhKeeegpnzpyBiYkJysrKxOP69u2LixcvwtTUVFOlExERERERkQZwanozvfvuu/jiiy+gr6+PvXv3ol+/fgCAwsJCPPnkkzhz5gyMjIxQWVkpHrNixQpcvXqVIZyIiIiIiKgDYke8Gfbt24dVq1YBALZt24ann34aACCRSDBhwgRcvHgRBgYGqK6uBgAYGBjg999/x+jRozVWMxEREREREWkWg3gTnTt3Ttxm7I033sDrr78OAMjPz8eECRMQGxsLPT09SKVSAIClpSUSEhLQuXNnjdVMREREREREmsep6U2QkpKCqVOnorKyEpMmTcKWLVsAAHl5eRg3bhxiY2MBPLx+HAC8vLyQl5fHEE5EREREREQM4o1VWFiIgIAAZGdnY8CAAdizZw8MDAyQm5uLsWPHIj4+XmH8+PHjkZiYCCMjIw1VTERERERERNqEQbwRqqurERgYiBs3bsDFxQVRUVGwsLBAdnY2nnjiCVy5ckVh/NKlS/Hrr79qqFoiIiIiIiLSRrxGvIEEQcDChQsRHR2NTp06ISoqCq6urnjw4AGeeOIJ3LhxQ2H8V199JV5DTkRERERERCTHIN5AH3zwASIiIqCnp4c9e/bAz88PeXl5GD9+vEIINzAwwNmzZzF48GANVktERERERETaikG8AQ4dOoTly5cDALZs2YIpU6aIW5RdvXpVHGdkZITbt2/D09NTU6USERERERGRlmMQr8elS5fw7LPPQhAEvPbaa3jzzTdRXFyMp556CnFxceI4U1NTpKamwtHRUYPVEhERERERkbZjEK9DWloaJk+ejPLyckycOBHbtm1DeXk5Jk2ahHPnzonjLC0tkZmZCXNzcw1WS0RERERERLqAq6arUVxcjEmTJiErKwt9+/bF3r17UVNTg6lTp+LUqVPiOAcHB+Tm5jKEExERERERUYMwiKtQU1OD2bNn4++//4aTkxOOHj0KU1NTzJgxAzExMeK4bt264cGDBzA2NtZgtURERERERKRLGMRVWLJkCX7++WeYmZnhyJEj6Nq1K2bNmoWff/5ZHNO7d2/cu3cP+vr8IyQiIiIiIqKGY4p8xLZt2/Dxxx8DAL755hv4+/tjzpw5OHz4sDhm6NChuH79OvT09DRVJhEREREREekoBvFajh49iiVLlgAAwsLCMH36dMybNw8HDhwQx0ycOBFnz57VVIlERERERESk4xjE/7/Lly9jzpw5kMlkePnll/Gf//wHQUFB+P7778Uxc+fOVZieTkRERERERNRYDOIAMjIyMGnSJJSWlmLs2LHYuXMn3njjDXz22WfimOeff14hlBMRERERERE1RYcP4iUlJZg8eTIyMjLQs2dPREZGYvXq1eJ14sDDTvg333yjwSqJiIiIiIiovejQQVwqleK5555DfHw8HB0dcezYMWzduhXvvfeeOGbWrFnshBMREREREVGL6dBBfMWKFThy5AhMTExw6NAh7N+/H++88474/DPPPIO9e/dqsEIiIiIiIiJqbzpsEP/kk0/wwQcfAAC+/PJLXLhwAW+99Zb4/LRp0xAZGamp8oiIiIiIiKid6pBB/Pjx41i4cCEAYMOGDSgqKhK3LQOASZMm4ccff9RUeURERERERNSOGWq6gLZ27do1BAYGQiqVYt68efDy8sJzzz0nPv/UU08hKipKgxUSERERERFRe9ahgnhWVhYCAgJQXFyM0aNHY8aMGZg2bZr4/IQJE/DTTz9prkAiIiIiIiJq9zpMEC8rK8PUqVORmpoKX19fLF++HJMnTxafHzt2LI4fP67BComIiIiIiKgj6BDXiMtkMsybNw8XLlyAnZ0dNm/erBDCR48ejZiYGA1WSERERERERB1Fhwjiq1atwoEDB2BkZIQPP/wQM2bMEJ8bPnw4Tp48qcHqiIiIiIiIqCNp90H8s88+Q1hYGAAgLCwML730EgRBAAAMGTIEp0+f1mR5RERERERE1MG06yD+22+/4dVXXwUALFu2DCEhIZDJZAAAPz8/nDt3TpPlERERERERUQfUboP4zZs38cwzz6CmpgYzZ87Exx9/jOrqagBAjx49EBsbq+EKiYiIiIiIqCNql0E8JycHAQEBKCwsxNChQ3H8+HFUVlYCALp27Ypbt25puEIiIiIiIiLqqNpdEK+oqMC0adOQnJwMLy8v3L17F8XFxQAAOzs73Lt3T8MVEhERERERUUfWroK4IAj417/+hTNnzsDGxgYVFRXIy8sDAFhYWCA7OxsGBgYarpKIiIiIiIg6snYVxNeuXYsffvgBhoaGsLa2xv379wEAJiYmyMnJYQgnIiIiIiIijWs3Qfzrr7/Ghg0bAADu7u7iFHRDQ0NkZ2fD1NRUk+URERERERERAWgnQfzUqVN45ZVXAADe3t5ITEwEAOjr6yM9PR1WVlaaLI+IiIiIiIhIpPNB/O7du5g+fTqqq6vh7u4uhnA9PT3cvXsXTk5OGq6QiIiIiIiI6P/odBDPy8vD008/jfz8fDg7OyusiB4fHw8vLy8NVkdERERERESkTGeDeGVlJaZPn46EhATY2toiKytLfO7EiRPo37+/BqsjIiIiIiIiUk0ng7ggCJg/fz7+/PNPmJmZoaCgQHzuwIEDGDNmjOaKIyIiIiIiIqqDTgbxjRs34ptvvoG+vj7Ky8vFx3fv3o0ZM2ZosDIiIiIiIiKiuulcEN+zZw/WrFkDAJDJZOLjYWFh4srpRERERERERNpKp4L4mTNn8K9//Uvp8eXLl2PFihUaqIiIiIiIiIiocXQmiCclJWHq1KmorKxUePzf//43Nm/erKGqiIiIiIiIiBpHJ4J4QUEBAgICkJubq/D4tGnT8Nlnn2moKiIiIiIiIqLG0/ogXlVVhZkzZ+LWrVsKj48ZMwY//vijhqoiIiIiIiIiahqtDuKCIGDBggX4/fffFR7v378/Tpw4oaGqiIiIiIiIiJpOq4P45s2blaaee3p64vLly5opiIiIiIiIiKiZtDaIR0ZG4q233lJ4rHPnzkhKStJQRURERERERETNp5VB/MKFC3jhhRcUHrOyssL9+/c1VBERERERERFRy9C6IH7v3j1MmTIFFRUV4mMmJibIz8+HgYGBBisjIiIiIiIiaj6tCuKFhYUICAjAgwcPxMcMDAyQk5PDEE5ERERERETtgtYE8ZqaGsyePRvXr18XH9PT00NqaiosLS01WBkRERERERFRy9GKIC4IAhYtWoTjx48rPP7333/DxcVFQ1URERERERERtTytCOIffvghPvnkE4XHoqOj0bdvXw1VRERERERERNQ6NB7EDx8+jGXLlik89vXXX2PcuHEaqoiIiIiIiIio9Wg0iMfFxWHu3LkQBEF8bNOmTUpblxERERERERG1FxoL4unp6Zg0aRLKy8vFx1577TWsXLlSUyURERERERERtTqNBPHi4mIEBAQgMzNTfGzq1KnYuXOnJsohIiIiIiIiajNtHsSlUinmzp2Lv//+W3xs6NChOHToUFuXQkRERERERNTm2jyIL126FMeOHRO/9/b2xtmzZ9u6DCIiIiIiIiKNaNMg/vHHH2Pbtm3i946OjkhISGjLEoiIiIiIiIg0qs2C+E8//YRFixaJ35ubmytcI05ERERERETUEbRJEL9y5QqmTJkifm9oaIi8vDwYGBi0xemJiIiIiIioAwoODoa/vz+8vb0RGRmp8FxcXBwCAwMxfvx4jB8/Hv7+/ti8ebPSa0RGRiqM8ff3R0xMTLPqavUgnpmZiREjRkAqlQIA9PT0kJ2dDRMTk9Y+NREREREREXVQgYGBCAwMRGxsLGbOnInAwEAxQAcGBiI8PBy7d+9GdHQ0oqOjsXLlSoSEhCA4OBgAIJFIMH78eOTn54tjYmNjMWjQIIwfP14p2DdGqwbx0tJSDB48GKWlpeJjSUlJsLW1bc3TEhERERERUQeWlJQEABg3bhyAh4uEA0B4eLjYBQ8PD4eNjY14zMyZMwEAERERSEpKwtixYxEWFoagoCCF1w4MDAQAhISENLm+VgviUqkU//jHP5CRkSE+dvbsWXh4eLTWKYmIiIiIiIgQHh4udrYBIDExEcDDaeZeXl5K4VrOy8sLAODv74/du3fDz89P7Rh52G+KVgvizz77LGJjY8XvDx48iKFDh7bW6YiIiIiIiIgAADExMWI3HHh4PTgA+Pn5ISwsTO1x8nAdFBSkMoTXHtMcrRLE161bh3379onfb9u2DdOnT2+NUxEREREREREpmD17tsL3ly5dAgCsXLlS7THysN7QceqCekO0eBDft28f1q9fL36/YsUKhW3LiIiIiIiIiFrTihUrxPtJSUmQSCQAoNAlf5R8ITcvLy+Fa8cfFR0dXe9r1adFg3hsbKzCJw/PPvtsnW1/IiIiIiIiotYkX93cz8+vRQK2PLCPHz++yTW1WBDPyMjAoEGDxO/HjBmD7777rqVenoiIiIiIiKjRGhqw5dPX5auiqyIP9TY2NprviJeXl8Pd3V38vlevXjhx4kRLvDQRERERERFRkzWkgx0XFydOX6/dYH7U3r17AQCzZs1qVk3NDuIymQz29vaQSqUAgM6dO+PGjRvNfVkiIiIiIiKiZqm9AFtdAVse1uuavi6RSMSOeO2t0SQSCSIiIhpVV7ODuI+PD8rLywEA5ubmePDgQXNfkoiIiIiIiKjZGhKwgYZNX5fvDObl5aWwYnpjQzgAGDb6iEfk5eU9fCFDQ7GVT0RERERERKRpLbkAm/y1Zs6cqfD43r17ERsb26i6WuQacT09PRQXF8PQsNm5noiIiIiIiKhFNPT6cLm6Aru88Tx48GDxsYiICKU9yxuiwcm5srISlZWV4veFhYXi/Zs3b6KqqgpVVVWNLoCIiIiIiIioIYqKigAo5lEAMDExgYmJicJjjb0+vL6ueWBgIGJiYsQp7nFxcYiOjsb+/fsbXL9cg4N4aGgo1q9fr/K5nj17NvrERERERERERE3h5uam8P3atWuxbt06hcdsbGxgY2ODoKCgOq8P9/Lygo2NjcICbKoEBQUhMTERISEhsLOzg5eXV5NCOADoCYIgNGTgox1xiUQCd3d3pKamwtraukknJ2pNRUVF6NatG9LS0mBlZaXpcoiU8GeUtB1/Rknb8WeUtB1/RlueIAjIy8uDnZ0d9PX/70prVR1xbdbgjri6N2Ztbc0fKtJqVlZW/BklrcafUdJ2/BklbcefUdJ2/BltWe2hEdwii7URERERERERUcMwiBMRERERERG1oSYHcRMTE6xdu1an5uFTx8KfUdJ2/BklbcefUdJ2/BklbcefUVKnwYu1EREREREREVHzcWo6ERERERERURtiECciIiIiIiJqQwziRERERERERG2IQZyIiIiIiIioDTGIExEREREREbUhBnEiIiIiIiKiNsQgTkRERERERNSGGMSJiIiIiIiI2hCDOBEREREREVEbYhAnIiIiIiIiakP/D0oIVkrTMQfEAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1200x900 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Plot the different consumption rules for the different periods\n",
    "\n",
    "mPlotMin = 0\n",
    "mLocCLabels = 9.6  # Defines horizontal limit of figure\n",
    "mPlotTop = 6.5     # Defines maximum m value where functions are plotted\n",
    "mPts = 1000        # Number of points at which functions are evaluated\n",
    "\n",
    "mBelwLabels = np.linspace(mPlotMin, mLocCLabels-0.1, mPts) # Range of m below loc of labels\n",
    "m_FullRange = np.linspace(mPlotMin, mPlotTop, mPts)        # Full plot range\n",
    "\n",
    "# c_Tm0  defines the last period consumption rule (c=m)\n",
    "T = -1  # Solution in the last period\n",
    "c_Tm0 = m_FullRange\n",
    "# c_Tm1 defines the second-to-last period consumption rule\n",
    "c_Tm1  = cFunc[T-1 ](mBelwLabels)\n",
    "c_Tm5  = cFunc[T-5 ](mBelwLabels) # c_Tm5  defines the T-5  period consumption rule\n",
    "c_Tm10 = cFunc[T-10](mBelwLabels) # c_Tm10 defines the T-10 period consumption rule\n",
    "c_Limt = cFunc[0   ](mBelwLabels) # limiting inﬁnite-horizon consumption rule\n",
    "\n",
    "plt.figure(figsize=(12, 9))\n",
    "plt.rcParams['font.size'], plt.rcParams['font.weight'] = fsmid, 'bold'\n",
    "\n",
    "xMin, xMax = 0, 11\n",
    "yMin, yMax = 0, 7\n",
    "plt.xlim(xMin, xMax)\n",
    "plt.ylim(yMin, yMax)\n",
    "\n",
    "plt.plot(mBelwLabels, c_Limt, color='black')\n",
    "plt.plot(mBelwLabels, c_Tm1, color='black')\n",
    "plt.plot(mBelwLabels, c_Tm5, color='black')\n",
    "plt.plot(mBelwLabels, c_Tm10, color='black')\n",
    "plt.plot(m_FullRange, c_Tm0, color='black')\n",
    "plt.text(yMax, yMax-1    , r'$c_{T   }(m) = 45$ degree line')\n",
    "plt.text(mLocCLabels, 5.3, r'$c_{T-1 }(m)$')\n",
    "plt.text(mLocCLabels, 2.6, r'$c_{T-5 }(m)$')\n",
    "plt.text(mLocCLabels, 2.1, r'$c_{T-10}(m)$')\n",
    "plt.text(mLocCLabels, 1.7, r'$c(m)       $')\n",
    "plt.arrow(6.9, 6.05, -0.6, 0, head_width=0.1, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.tick_params(labelbottom=False, labelleft=False, left='off',\n",
    "                right='off', bottom='off', top='off')\n",
    "plt.text(0, 7.05, \"$c$\", fontsize=fsbig)\n",
    "plt.text(xMax+0.1, 0, \"$m$\", fontsize=fsbig)\n",
    "\n",
    "# Save the figure\n",
    "makeFig('cFuncsConverge')  # Comment out if you want to run uninterrupted"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e7b8149",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Use the [interactive dashboard](#interactive-dashboard) to explore the effects of changes in patience, risk aversion, or risk"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e365e041",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Factors and Conditions\n",
    "\n",
    "### [The Finite Human Wealth Condition](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Human-Wealth)\n",
    "\n",
    "Human wealth for a perfect foresight consumer is the present discounted value of future noncapital income:\n",
    "\n",
    "\\begin{eqnarray}\\notag\n",
    "\\hLvl_{t} & = & \\Ex_{t}[\\pLvl_{t} + \\Rfree^{-1} \\pLvl_{t+1} + \\Rfree^{2} \\pLvl_{t+2} ... ] \\\\ \\notag\n",
    "      & = & \\pLvl_{t} \\left(1 + (\\PermGroFac/\\Rfree) + (\\PermGroFac/\\Rfree)^{2} ... \\right)\n",
    "\\end{eqnarray}\n",
    "\n",
    "which approaches infinity as the horizon extends if $\\PermGroFac/\\Rfree \\geq 1$.  We say that the 'Finite Human Wealth Condition' [(FHWC)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FHWC) holds if\n",
    "$0 \\leq (\\PermGroFac/\\Rfree) < 1$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4d69326",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Absolute Patience and the AIC](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AIC)\n",
    "\n",
    "The paper defines the Absolute Patience Factor [(APF)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#APFac) as being equal to the ratio $\\cLvl_{t+1}/\\cLvl_{t}$ for a perfect foresight consumer.  (The Old English character [Thorn](https://en.wikipedia.org/wiki/Thorn_(letter)) used for this object in the paper cannot reliably be rendered in Jupyter notebooks; it may appear as capital Phi):\n",
    "\n",
    "\\begin{equation}\n",
    "\\PatFac = (\\Rfree \\DiscFac)^{1/\\CRRA}\n",
    "\\end{equation}\n",
    "\n",
    "If $\\APFac = 1$, a perfect foresight consumer will spend at exactly the level of $\\cLvl$ that can be sustained perpetually (given their current and future resources).  If $\\APFac < 1$ (the consumer is 'absolutely impatient'; or, 'the absolute impatience condition holds'), the consumer is consuming more than the sustainable amount, so consumption will fall, and if the consumer is 'absolutely patient' with $\\APFac > 1$ consumption will grow over time.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e0b0313",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Growth Patience and the GICRaw](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GIC)\n",
    "\n",
    "For a [perfect foresight consumer](https://www.econ2.jhu.edu/people/ccarroll/public/lecturenotes/consumption/PerfForesightCRRA), whether the ratio $c$=__**c**__/__**p**__ is rising, constant, or falling depends on the relative growth rates of consumption and permanent income; that ratio is measured by the [Perfect Foresight Growth Patience Factor](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#PFGPF):\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\APFac_{\\PermGroFac} & = & \\APFac/\\PermGroFac\n",
    "\\end{eqnarray}\n",
    "and whether the $c$ is falling or rising over time depends on whether $\\APFac_{\\PermGroFac}$ is below or above 1.\n",
    "\n",
    "An analogous condition can be defined when there is uncertainty about permanent income.  Defining $\\tilde{\\PermGroFac} = (\\Ex[\\PermShk^{-1}])^{-1}\\PermGroFac$, the\n",
    "['Growth Impatience Condition'](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GIC) determines whether, _in expectation_, the stochastic value of $c$ is rising, constant, or falling over time:\n",
    "\n",
    "\\begin{eqnarray}\n",
    "  \\APFac/\\tilde{\\PermGroFac} & < & 1.\n",
    "\\end{eqnarray}\n",
    "\n",
    "### [The Finite Value of Autarky Condition (FVAC)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Autarky-Value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1dd54dd",
   "metadata": {},
   "source": [
    "The paper [shows](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Autarky-Value) that a consumer who planned to spend his permanent noncapital income $\\{ \\pLvl_{t}, \\pLvl_{t+1}, ...\\} $ in every period would have value defined by\n",
    "\n",
    "\\begin{equation*}\n",
    "\\vLvl_{t}^{\\text{autarky}} = \\uFunc(\\pLvl_{t})\\left(\\frac{1}{1-\\DiscFac \\PermGroFac^{1-\\CRRA} \\Ex[\\PermShk^{1-\\CRRA}]}\\right)\n",
    "\\end{equation*}\n",
    "\n",
    "and defines the ['Finite Value of Autarky Condition'](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Autarky-Value) as the requirement that the denominator be a positive finite number:\n",
    "\n",
    "\\begin{equation*}\n",
    "\\DiscFac \\PermGroFac^{1-\\CRRA} \\Ex[\\PermShk^{1-\\CRRA}] < 1\n",
    "\\end{equation*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e1d10d4",
   "metadata": {},
   "source": [
    "### [The Weak Return Impatience Condition (WRIC)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#WRIC)\n",
    "\n",
    "The [Return Impatience Condition](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#RIC) $\\APFac/\\Rfree < 1$ has long been understood to be required for the perfect foresight model to have a nondegenerate solution (a common special case is when $\\CRRA=1$; in this case $\\APFac = \\Rfree \\DiscFac$ so $\\APFac<1$ reduces to the familiar condition $\\DiscFac < \\Rfree$).\n",
    "\n",
    "If the RIC does not hold, the consumer is so patient that the optimal consumption function approaches zero as the horizon extends indefinitely.\n",
    "\n",
    "When the probability of unemployment is $\\UnempPrb$, the paper articulates an analogous (but weaker) return impatience condition:\n",
    "\n",
    "\\begin{eqnarray}\n",
    " \\UnempPrb^{1/\\CRRA} \\APFac/\\Rfree & < & 1\n",
    "\\end{eqnarray}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8ad2a5e",
   "metadata": {},
   "source": [
    "# Key Results\n",
    "\n",
    "## [Nondegenerate Solution Requires FVAC and WRIC](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Sufficient-Conditions-For-Nondegenerate-Solution)\n",
    "\n",
    "A main result of the paper is that the conditions required for the model to have a nondegenerate limiting solution ($0 < c(m) < \\infty$ for feasible $m$) are that the Finite Value of Autarky (FVAC) and Weak Return Impatience Condition (WRIC) hold."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eb0a439",
   "metadata": {},
   "source": [
    "## [Natural Borrowing Constraint limits to Artificial Borrowing Constraint](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#The-Liquidity-Constrained-Solution-as-a-Limit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7873be03",
   "metadata": {},
   "source": [
    "Defining $\\chi(\\UnempPrb)$ as the consumption function associated with any particular probability of a zero-income shock $\\UnempPrb,$ and defining $\\hat{\\chi}$ as the consumption function that would apply in the absence of the transitory zero-income shocks but in the presence of an 'artificial' borrowing constraint requiring $a \\geq 0$ (_a la_ Deaton (1991)), the paper shows that\n",
    "\n",
    "\\begin{eqnarray}\n",
    "\\lim_{\\UnempPrb \\downarrow 0}~\\chi(\\UnempPrb) & = & \\hat{\\chi}\n",
    "\\end{eqnarray}\n",
    "\n",
    "That is, as $\\UnempPrb$ approaches zero the problem with uncertainty becomes identical to the problem that instead has constraints.  (See [Precautionary Saving and Liquidity Constraints](https://econ-ark.github.io/LiqConstr) for a full treatment of the relationship between precautionary saving and liquidity constraints)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58daad3",
   "metadata": {},
   "source": [
    "## [$\\cFunc(m)$ can be Finite Even When Human Wealth Is Infinite](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#When-The-GICRaw-Fails)\n",
    "\n",
    "In the perfect foresight model, if $\\Rfree < \\PermGroFac$ the PDV of future labor income approaches infinity as the horizon extends and so the limiting consumption function is $c(m) = \\infty$ for all $m$.  Many models have no well-defined limiting solution when human wealth is infinite.\n",
    "\n",
    "The presence of uncertainty changes this: Even when limiting human wealth is infinite, the limiting consumption function is finite for all values of $m$.\n",
    "\n",
    "This is because uncertainty imposes a \"natural borrowing constraint\" that deters the consumer from borrowing against their unbounded (but uncertain) future labor income."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "575c8290",
   "metadata": {},
   "source": [
    "A [table](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Sufficient-Conditions-For-Nondegenerate-Solution) puts this result in the context of implications of other conditions and restrictions.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4eaa221",
   "metadata": {},
   "source": [
    "## [Unique and Stable Values of $\\mNrm$](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Unique-Stable-Points)\n",
    "\n",
    "Assuming that the **FVAC** and **WRIC** hold so that the problem has a nondegenerate solution, under more stringent conditions its dynamics can also be shown to exhibit certain kinds of stability.  Two particularly useful kinds of stability are existence of a 'target' value of market resources $\\Trg{\\mNrm}$ (`mNrmFacTrg` in the toolkit) and a 'pseudo-steady-state' value $\\Bal{\\mNrm}$ (`mBalLvl` in the toolkit).\n",
    "\n",
    "### [If the GIC-Nrm Holds, $\\exists$ a finite 'target' $\\mNrm$](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#onetarget)\n",
    "\n",
    "Section [Individual Target Wealth](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#onetarget) shows that, under parameter values for which the limiting consumption function exists, if the [GICMod](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICMod) holds then there will be a value $\\Trg{m}$ such that:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "\\Ex[m_{t+1}] & > & m_{t}~\\text{if $m_{t} < \\Trg{m}$} \\\\\n",
    "\\Ex[m_{t+1}] & < & m_{t}~\\text{if $m_{t} > \\Trg{m}$} \\\\\n",
    "\\Ex[m_{t+1}] & = & m_{t}~\\text{if $m_{t} = \\Trg{m}$}\n",
    "\\end{eqnarray*}\n",
    "\n",
    "[An equation](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#mTargImplicit) in the paper tells us that, for the expected normalized interest factor $\\bar{\\RNrm}=\\mathbb{E}[\\Rfree/(\\PermGroFac \\PermShk)]$, if $\\mNrm_{t}=\\Trg{m}$ then:\n",
    "\n",
    "\\begin{align}\n",
    "(\\Trg{\\mNrm}-\\cFunc(\\Trg{\\mNrm}))\\bar{\\RNrm}+1 & = \\Trg{\\mNrm}\n",
    "%\\\\ \\Trg{\\mNrm}(1-\\bar{\\RNrm}^{-1})+\\bar{\\RNrm}^{-1} & = \\Trg{\\cNrm}\n",
    "%\\\\ \\Trg{\\cNrm} & = \\Trg{\\mNrm} - (\\Trg{\\mNrm} - 1)\\bar{\\RNrm}^{-1}\n",
    "\\end{align}\n",
    "\n",
    "which can be solved numerically for the unique $\\Trg{\\mNrm}$ that satisfies it.\n",
    "\n",
    "### [If the GIC-Raw Holds, $\\exists$ a balanced growth 'pseudo-steady-state' $\\mNrm$](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#pseudo-steady-state)\n",
    "\n",
    "Section [Individual Balanced-Growth 'pseudo steady state'](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#pseudo-steady-state) shows that, under parameter values for which the limiting consumption function exists, if the **GIC** holds then there will be a value $\\Bal{m}$ such that:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}] & > & \\PermGroFac~\\text{if $m_{t} < \\Bal{m}$} \\\\\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}] & < & \\PermGroFac~\\text{if $m_{t} > \\Bal{m}$} \\\\\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}] & = & \\PermGroFac~\\text{if $m_{t} = \\Bal{m}$}\n",
    "\\end{eqnarray*}\n",
    "\n",
    "[An equation](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#balgrostableSolve) in the paper tells us that if $\\mNrm_{t}=\\Bal{m}$ then:\n",
    "\n",
    "\\begin{align}\n",
    "(\\Bal{\\mNrm}-\\cFunc(\\Bal{\\mNrm}))\\RNrm+1 & = \\Bal{\\mNrm}\n",
    "\\end{align}\n",
    "\n",
    "which can be solved numerically for the unique $\\Bal{\\mNrm}$ that satisfies it.\n",
    "\n",
    "\n",
    "### [Example With Finite Pseudo-Steady-State But Infinite Target Wealth](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICModFailsButGICRawHolds)\n",
    "\n",
    "[A figure](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICModFailsButGICRawHolds) depicts a solution when the **FVAC** [(Finite Value of Autarky Condition)](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FVAC) and [**WRIC**](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FVAC) hold (so that the model has a solution), the [**GIC**](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICRaw) holds, so the model has a pseudo-steady-state $\\Bal{\\mNrm}$, but the [**GIC-Nrm**](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICMod) fails, so the model does not have an individual target wealth ratio $\\Trg{\\mNrm}$ (or, rather, the target wealth ratio is infinity, as can be seen by the fact that the level of $\\cNrm$ is always below the level that would keep $\\Ex_{t}[\\Delta \\mNrm_{t+1}] = 0$).\n",
    "\n",
    "This example was constructed by quadrupling the variance of the permanent shocks from the baseline parameterization.  The extra precautionary saving induced by increased uncertainty is what pushes the agent into the region without a target wealth ratio."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e103f755",
   "metadata": {},
   "source": [
    "`# Create an example consumer instance where the GICMod fails but the GIC Holds:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c558fce3",
   "metadata": {
    "lines_to_next_cell": 0,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Because messaging_level is >= logging.INFO, infinite horizon conditions are reported below:\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ".\n"
     ]
    }
   ],
   "source": [
    "# GICModFailsButGICRawHolds Example\n",
    "\n",
    "base_params['cycles'] = 0  # revert to default of infinite horizon\n",
    "GICModFailsButGICRawHolds_params = dict(base_params)\n",
    "\n",
    "# Increase patience by increasing risk\n",
    "GICModFailsButGICRawHolds_params['PermShkStd'] = [0.2]\n",
    "\n",
    "# Create an agent with these parameters\n",
    "GICModFailsButGICRawHolds = \\\n",
    "    IndShockConsumerType(**GICModFailsButGICRawHolds_params,\n",
    "                         messaging_level=logging.CRITICAL  # If True, output suppressed\n",
    "                         )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aa44a31",
   "metadata": {},
   "source": [
    "`# Solve that consumer's problem:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "58431a1b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "........................................................................................................................\n",
      "Finished cycle # 000121 after    0.0080 seconds, solution distance = 1.440e+02\n",
      "Finished cycle # 000122 after    0.0165 seconds, solution distance = 4.039e-02\n",
      "Finished cycle # 000123 after    0.0251 seconds, solution distance = 3.797e-02\n",
      "Finished cycle # 000124 after    0.0336 seconds, solution distance = 3.576e-02\n",
      "Finished cycle # 000125 after    0.0423 seconds, solution distance = 3.372e-02\n",
      "Finished cycle # 000126 after    0.0517 seconds, solution distance = 3.181e-02\n",
      "Finished cycle # 000127 after    0.0607 seconds, solution distance = 3.003e-02\n",
      "Finished cycle # 000128 after    0.0698 seconds, solution distance = 2.836e-02\n",
      "Finished cycle # 000129 after    0.0951 seconds, solution distance = 2.679e-02\n",
      "Finished cycle # 000130 after    0.1044 seconds, solution distance = 2.533e-02\n",
      "Finished cycle # 000131 after    0.1131 seconds, solution distance = 2.395e-02\n",
      "Finished cycle # 000132 after    0.1223 seconds, solution distance = 2.266e-02\n",
      "Finished cycle # 000133 after    0.1310 seconds, solution distance = 2.144e-02\n",
      "Finished cycle # 000134 after    0.1398 seconds, solution distance = 2.030e-02\n",
      "Finished cycle # 000135 after    0.1487 seconds, solution distance = 1.922e-02\n",
      "Finished cycle # 000136 after    0.1578 seconds, solution distance = 1.821e-02\n",
      "Finished cycle # 000137 after    0.1670 seconds, solution distance = 1.726e-02\n",
      "Finished cycle # 000138 after    0.1756 seconds, solution distance = 1.636e-02\n",
      "Finished cycle # 000139 after    0.1844 seconds, solution distance = 1.551e-02\n",
      "Finished cycle # 000140 after    0.1933 seconds, solution distance = 1.471e-02\n",
      "Finished cycle # 000141 after    0.2017 seconds, solution distance = 1.395e-02\n",
      "Finished cycle # 000142 after    0.2104 seconds, solution distance = 1.324e-02\n",
      "Finished cycle # 000143 after    0.2191 seconds, solution distance = 1.256e-02\n",
      "Finished cycle # 000144 after    0.2280 seconds, solution distance = 1.192e-02\n",
      "Finished cycle # 000145 after    0.2368 seconds, solution distance = 1.132e-02\n",
      "Finished cycle # 000146 after    0.2458 seconds, solution distance = 1.075e-02\n",
      "Finished cycle # 000147 after    0.2546 seconds, solution distance = 1.021e-02\n",
      "Finished cycle # 000148 after    0.2640 seconds, solution distance = 9.700e-03\n",
      "Finished cycle # 000149 after    0.2736 seconds, solution distance = 9.217e-03\n",
      "Finished cycle # 000150 after    0.2823 seconds, solution distance = 8.759e-03\n",
      "Finished cycle # 000151 after    0.2910 seconds, solution distance = 8.326e-03\n",
      "Finished cycle # 000152 after    0.2996 seconds, solution distance = 7.915e-03\n",
      "Finished cycle # 000153 after    0.3085 seconds, solution distance = 7.525e-03\n",
      "Finished cycle # 000154 after    0.3173 seconds, solution distance = 7.156e-03\n",
      "Finished cycle # 000155 after    0.3260 seconds, solution distance = 6.805e-03\n",
      "Finished cycle # 000156 after    0.3345 seconds, solution distance = 6.473e-03\n",
      "Finished cycle # 000157 after    0.3433 seconds, solution distance = 6.158e-03\n",
      "Finished cycle # 000158 after    0.3517 seconds, solution distance = 5.859e-03\n",
      "Finished cycle # 000159 after    0.3606 seconds, solution distance = 5.575e-03\n",
      "Finished cycle # 000160 after    0.3692 seconds, solution distance = 5.305e-03\n",
      "Finished cycle # 000161 after    0.3778 seconds, solution distance = 5.049e-03\n",
      "Finished cycle # 000162 after    0.3863 seconds, solution distance = 4.806e-03\n",
      "Finished cycle # 000163 after    0.3948 seconds, solution distance = 4.574e-03\n",
      "Finished cycle # 000164 after    0.4033 seconds, solution distance = 4.355e-03\n",
      "Finished cycle # 000165 after    0.4121 seconds, solution distance = 4.146e-03\n",
      "Finished cycle # 000166 after    0.4204 seconds, solution distance = 3.948e-03\n",
      "Finished cycle # 000167 after    0.4289 seconds, solution distance = 3.759e-03\n",
      "Finished cycle # 000168 after    0.4375 seconds, solution distance = 3.580e-03\n",
      "Finished cycle # 000169 after    0.4460 seconds, solution distance = 3.409e-03\n",
      "Finished cycle # 000170 after    0.4550 seconds, solution distance = 3.247e-03\n",
      "Finished cycle # 000171 after    0.4636 seconds, solution distance = 3.092e-03\n",
      "Finished cycle # 000172 after    0.4725 seconds, solution distance = 2.945e-03\n",
      "Finished cycle # 000173 after    0.4817 seconds, solution distance = 2.806e-03\n",
      "Finished cycle # 000174 after    0.4907 seconds, solution distance = 2.673e-03\n",
      "Finished cycle # 000175 after    0.4997 seconds, solution distance = 2.546e-03\n",
      "Finished cycle # 000176 after    0.5085 seconds, solution distance = 2.426e-03\n",
      "Finished cycle # 000177 after    0.5171 seconds, solution distance = 2.311e-03\n",
      "Finished cycle # 000178 after    0.5256 seconds, solution distance = 2.202e-03\n",
      "Finished cycle # 000179 after    0.5341 seconds, solution distance = 2.098e-03\n",
      "Finished cycle # 000180 after    0.5425 seconds, solution distance = 1.999e-03\n",
      "Finished cycle # 000181 after    0.5517 seconds, solution distance = 1.905e-03\n",
      "Finished cycle # 000182 after    0.5602 seconds, solution distance = 1.815e-03\n",
      "Finished cycle # 000183 after    0.5688 seconds, solution distance = 1.729e-03\n",
      "Finished cycle # 000184 after    0.5772 seconds, solution distance = 1.648e-03\n",
      "Finished cycle # 000185 after    0.5856 seconds, solution distance = 1.570e-03\n",
      "Finished cycle # 000186 after    0.5940 seconds, solution distance = 1.496e-03\n",
      "Finished cycle # 000187 after    0.6027 seconds, solution distance = 1.426e-03\n",
      "Finished cycle # 000188 after    0.6112 seconds, solution distance = 1.359e-03\n",
      "Finished cycle # 000189 after    0.6197 seconds, solution distance = 1.295e-03\n",
      "Finished cycle # 000190 after    0.6281 seconds, solution distance = 1.234e-03\n",
      "Finished cycle # 000191 after    0.6366 seconds, solution distance = 1.176e-03\n",
      "Finished cycle # 000192 after    0.6453 seconds, solution distance = 1.120e-03\n",
      "Finished cycle # 000193 after    0.6538 seconds, solution distance = 1.067e-03\n",
      "Finished cycle # 000194 after    0.6628 seconds, solution distance = 1.017e-03\n",
      "Finished cycle # 000195 after    0.6719 seconds, solution distance = 9.691e-04\n",
      "Finished cycle # 000196 after    0.6809 seconds, solution distance = 9.234e-04\n",
      "Finished cycle # 000197 after    0.6897 seconds, solution distance = 8.798e-04\n",
      "Finished cycle # 000198 after    0.6993 seconds, solution distance = 8.382e-04\n",
      "Finished cycle # 000199 after    0.7080 seconds, solution distance = 7.986e-04\n",
      "Finished cycle # 000200 after    0.7170 seconds, solution distance = 7.608e-04\n",
      "Finished cycle # 000201 after    0.7256 seconds, solution distance = 7.248e-04\n",
      "Finished cycle # 000202 after    0.7341 seconds, solution distance = 6.904e-04\n",
      "Finished cycle # 000203 after    0.7428 seconds, solution distance = 6.577e-04\n",
      "Finished cycle # 000204 after    0.7511 seconds, solution distance = 6.265e-04\n",
      "Finished cycle # 000205 after    0.7597 seconds, solution distance = 5.967e-04\n",
      "Finished cycle # 000206 after    0.7682 seconds, solution distance = 5.683e-04\n",
      "Finished cycle # 000207 after    0.7767 seconds, solution distance = 5.412e-04\n",
      "Finished cycle # 000208 after    0.7850 seconds, solution distance = 5.153e-04\n",
      "Finished cycle # 000209 after    0.7937 seconds, solution distance = 4.907e-04\n",
      "Finished cycle # 000210 after    0.8021 seconds, solution distance = 4.672e-04\n",
      "Finished cycle # 000211 after    0.8107 seconds, solution distance = 4.448e-04\n",
      "Finished cycle # 000212 after    0.8193 seconds, solution distance = 4.234e-04\n",
      "Finished cycle # 000213 after    0.8278 seconds, solution distance = 4.031e-04\n",
      "Finished cycle # 000214 after    0.8363 seconds, solution distance = 3.836e-04\n",
      "Finished cycle # 000215 after    0.8449 seconds, solution distance = 3.651e-04\n",
      "Finished cycle # 000216 after    0.8533 seconds, solution distance = 3.474e-04\n",
      "Finished cycle # 000217 after    0.8619 seconds, solution distance = 3.305e-04\n",
      "Finished cycle # 000218 after    0.8707 seconds, solution distance = 3.144e-04\n",
      "Finished cycle # 000219 after    0.8796 seconds, solution distance = 2.991e-04\n",
      "Finished cycle # 000220 after    0.8890 seconds, solution distance = 2.845e-04\n",
      "Finished cycle # 000221 after    0.8988 seconds, solution distance = 2.705e-04\n",
      "Finished cycle # 000222 after    0.9083 seconds, solution distance = 2.572e-04\n",
      "Finished cycle # 000223 after    0.9173 seconds, solution distance = 2.445e-04\n",
      "Finished cycle # 000224 after    0.9255 seconds, solution distance = 2.324e-04\n",
      "Finished cycle # 000225 after    0.9339 seconds, solution distance = 2.208e-04\n",
      "Finished cycle # 000226 after    0.9424 seconds, solution distance = 2.098e-04\n",
      "Finished cycle # 000227 after    0.9511 seconds, solution distance = 1.993e-04\n",
      "Finished cycle # 000228 after    0.9598 seconds, solution distance = 1.893e-04\n",
      "Finished cycle # 000229 after    0.9686 seconds, solution distance = 1.798e-04\n",
      "Finished cycle # 000230 after    0.9771 seconds, solution distance = 1.707e-04\n",
      "Finished cycle # 000231 after    0.9862 seconds, solution distance = 1.620e-04\n",
      "Finished cycle # 000232 after    0.9949 seconds, solution distance = 1.537e-04\n",
      "Finished cycle # 000233 after    1.0034 seconds, solution distance = 1.458e-04\n",
      "Finished cycle # 000234 after    1.0119 seconds, solution distance = 1.382e-04\n",
      "Finished cycle # 000235 after    1.0203 seconds, solution distance = 1.311e-04\n",
      "Finished cycle # 000236 after    1.0289 seconds, solution distance = 1.242e-04\n",
      "Finished cycle # 000237 after    1.0374 seconds, solution distance = 1.177e-04\n",
      "Finished cycle # 000238 after    1.0458 seconds, solution distance = 1.115e-04\n",
      "Finished cycle # 000239 after    1.0543 seconds, solution distance = 1.055e-04\n",
      "Finished cycle # 000240 after    1.0628 seconds, solution distance = 9.988e-05\n",
      "Finished cycle # 000241 after    1.0713 seconds, solution distance = 9.449e-05\n",
      "Finished cycle # 000242 after    1.0801 seconds, solution distance = 8.935e-05\n",
      "Finished cycle # 000243 after    1.0885 seconds, solution distance = 8.445e-05\n",
      "Finished cycle # 000244 after    1.0971 seconds, solution distance = 7.978e-05\n",
      "Finished cycle # 000245 after    1.1064 seconds, solution distance = 7.533e-05\n",
      "Finished cycle # 000246 after    1.1151 seconds, solution distance = 7.109e-05\n",
      "Finished cycle # 000247 after    1.1242 seconds, solution distance = 6.705e-05\n",
      "Finished cycle # 000248 after    1.1327 seconds, solution distance = 6.320e-05\n",
      "Finished cycle # 000249 after    1.1409 seconds, solution distance = 5.953e-05\n",
      "Finished cycle # 000250 after    1.1498 seconds, solution distance = 5.604e-05\n",
      "Finished cycle # 000251 after    1.1608 seconds, solution distance = 5.271e-05\n",
      "Finished cycle # 000252 after    1.1699 seconds, solution distance = 4.954e-05\n",
      "Finished cycle # 000253 after    1.1783 seconds, solution distance = 4.652e-05\n",
      "Finished cycle # 000254 after    1.1871 seconds, solution distance = 4.365e-05\n",
      "Finished cycle # 000255 after    1.1961 seconds, solution distance = 4.091e-05\n",
      "Finished cycle # 000256 after    1.2043 seconds, solution distance = 3.831e-05\n",
      "Finished cycle # 000257 after    1.2128 seconds, solution distance = 3.583e-05\n",
      "Finished cycle # 000258 after    1.2218 seconds, solution distance = 3.361e-05\n",
      "Finished cycle # 000259 after    1.2302 seconds, solution distance = 3.151e-05\n",
      "Finished cycle # 000260 after    1.2386 seconds, solution distance = 2.950e-05\n",
      "Finished cycle # 000261 after    1.2471 seconds, solution distance = 2.759e-05\n",
      "Finished cycle # 000262 after    1.2553 seconds, solution distance = 2.580e-05\n",
      "Finished cycle # 000263 after    1.2639 seconds, solution distance = 2.418e-05\n",
      "Finished cycle # 000264 after    1.2723 seconds, solution distance = 2.264e-05\n",
      "Finished cycle # 000265 after    1.2806 seconds, solution distance = 2.117e-05\n",
      "Finished cycle # 000266 after    1.2895 seconds, solution distance = 1.977e-05\n",
      "Finished cycle # 000267 after    1.2980 seconds, solution distance = 1.851e-05\n",
      "Finished cycle # 000268 after    1.3230 seconds, solution distance = 1.732e-05\n",
      "Finished cycle # 000269 after    1.3333 seconds, solution distance = 1.619e-05\n",
      "Finished cycle # 000270 after    1.3420 seconds, solution distance = 1.511e-05\n",
      "Finished cycle # 000271 after    1.3505 seconds, solution distance = 1.413e-05\n",
      "Finished cycle # 000272 after    1.3592 seconds, solution distance = 1.322e-05\n",
      "Finished cycle # 000273 after    1.3683 seconds, solution distance = 1.235e-05\n",
      "Finished cycle # 000274 after    1.3771 seconds, solution distance = 1.152e-05\n",
      "Finished cycle # 000275 after    1.3858 seconds, solution distance = 1.077e-05\n",
      "Finished cycle # 000276 after    1.3943 seconds, solution distance = 1.007e-05\n",
      "Finished cycle # 000277 after    1.4029 seconds, solution distance = 9.396e-06\n",
      "\n",
      "distance_now < distance_original: True\n",
      ".............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "(quietly=False and messaging_level < logging.WARNING, so some model information is provided below):\n",
      "\n",
      "The model has the following parameter values:\n",
      "\n",
      "\tDiscFac: 0.96\n",
      "\tLivPrb: 1.0\n",
      "\tCRRA: 2.0\n",
      "\tRfree: 1.04\n",
      "\tPermGroFac: 1.03\n",
      "\tIncShkDstn: <HARK.distribution.DiscreteDistribution object at 0x108975750>\n",
      "\tPermShkDstn: <HARK.distribution.DiscreteDistribution object at 0x14a544cd0>\n",
      "\tTranShkDstn: <HARK.distribution.DiscreteDistribution object at 0x1089daad0>\n",
      "\tBoroCnstArt: None\n",
      "\tMaxKinks: None\n",
      "\tsolverType: HARK\n",
      "\tsolveMethod: EGM\n",
      "\teventTiming: EOP\n",
      "\thorizon: infinite\n",
      "\targs: ()\n",
      "\n",
      "The model's transition equations are:\n",
      "\n",
      "chosen_to_next_choice step:\n",
      "\tkNrm = aNrm\n",
      "\tRNrm = Rfree / (PermGroFac * PermShk)\n",
      "\tbNrm = kNrm * RNrm\n",
      "\tyNrm = TranShk\n",
      "\tmNrm = bNrm + yNrm\n",
      "\n",
      "choice_to_chosen step:\n",
      "\taNrm = mNrm - cNrm\n",
      "\n",
      "\n",
      "Because messaging_level is >= logging.INFO, infinite horizon conditions are reported below:\n",
      "\n",
      "\n",
      "The Absolute Patience Factor, APFac=0.99920 satisfies the Absolute Impatience Condition (AIC), APFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AIC\n",
      "\n",
      "    Because the APFac < 1,  the absolute amount of consumption is expected to fall over time.  \n",
      "\n",
      "\n",
      "The Finite Human Wealth Factor, FHWFac=0.99038 satisfies the Finite Human Wealth Condition (FHWC), FHWFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FHWC\n",
      "\n",
      "    Therefore, the limiting consumption function is not c(m)=Infinity.\n",
      "\n",
      "    Human wealth normalized by permanent income is 104.00000.\n",
      "\n",
      "\n",
      "The Return Patience Factor, RPFac=0.96077 satisfies the Return Impatience Condition (RIC), RPFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#RIC\n",
      "\n",
      "    Therefore, the limiting consumption function is not c(m)=0 for all m\n",
      "\n",
      "\n",
      "The uncertainty-Modified Growth Patience Factor GPFacMod, GPFacMod=1.00697 violates the Normalized Growth Impatience Condition (GICMod), GPFacMod < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICMod\n",
      "\n",
      "\n",
      "    Therefore, a target ratio of individual market resources to individual permanent income does not exist.\n",
      "\n",
      "\n",
      "The Szeidl Growth Patience Factor GPFacSdl=0.98839 satisfies the Szeidl Growth Impatience Condition (GICSdl), GPFacSdl < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICSdl\n",
      "\n",
      "    Therefore, invariant distributions of ratio variables like m exist.\n",
      "\n",
      "\n",
      "The Growth Patience Factor, GPF=0.97010 satisfies the Growth Impatience Condition (GICRaw), GPFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICRawDefn\n",
      "\n",
      "\n",
      "    Therefore, for a perfect foresight consumer, the ratio of individual wealth to permanent income is expected to fall indefinitely.    \n",
      "\n",
      "\n",
      "The Harmenberg Growth Patience Factor GPFacHrm=0.95220 satisfies the Harmenberg Growth Impatience Condition (GICHrm), GPFacHrm < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICHrm\n",
      "\n",
      "    Therefore, a target level of the individual market resources ratio m exists under the permanent-income-neutral measure.\n",
      "\n",
      "\n",
      "The Mortality Adjusted Growth Patience Factor, GPFacLiv=0.97010 satisfies the Mortality Adjusted Growth Impatience Condition (GICLiv):\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GPFacLivDefn\n",
      "\n",
      "    Therefore, a target level of the ratio of aggregate market resources to aggregate permanent income exists.    \n",
      "    \n",
      "\n",
      "The Modigliani Mortality Adjusted Growth Patience Factor, GPFacLivMod=0.97010 satisfies the Mortality Adjusted Growth Impatience Condition (GICLivMod):\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICLivModDefn\n",
      "\n",
      "    Therefore, a target level of the ratio of aggregate market resources to aggregate permanent income exists.    \n",
      "\n",
      "\n",
      "The Finite Value of Autarky Factor, VAFac=0.96000 satisfies the Finite Value of Autarky Condition, VAFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FVAC\n",
      "\n",
      "    Therefore, a nondegenerate solution exists if the RIC also holds. \n",
      "    \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "..............\n",
      "\n",
      "distance_now < distance_original: True\n"
     ]
    }
   ],
   "source": [
    "# Solve the model for these parameter values\n",
    "GICModFailsButGICRawHolds.tolerance = 0.0001  # Declare victory at ...\n",
    "# Suppress output during solution\n",
    "#GICModFailsButGICRawHolds.solve(quietly=False,messaging_level=logging.CRITICAL) \n",
    "GICModFailsButGICRawHolds.solve(messaging_level=logging.CRITICAL) \n",
    "\n",
    "# Because we are trying to solve a problem very close to the poised patience\n",
    "# values, we want to do it with extra precision to be sure we've gotten the\n",
    "# answer right.  We can retrieve the distance between the last two solutions:\n",
    "\n",
    "distance_original = GICModFailsButGICRawHolds.solution[0].distance_last\n",
    "\n",
    "# But high precision would have slowed things down if we used it from the start\n",
    "\n",
    "# Instead, we can take the solution obtained above, and continue it but with\n",
    "# parameters that will yield a more precise answer:\n",
    "\n",
    "# Solve with larger than normal range\n",
    "GICModFailsButGICRawHolds.aXtraMax = GICModFailsButGICRawHolds.aXtraMax * 10\n",
    "\n",
    "# Solve using four times as many gridpoints\n",
    "GICModFailsButGICRawHolds.aXtraCount = GICModFailsButGICRawHolds.aXtraCount * 4\n",
    "\n",
    "GICModFailsButGICRawHolds.update_assets_grid()\n",
    "\n",
    "# Solve to a 10 times tighter degree of error tolerance\n",
    "GICModFailsButGICRawHolds.tolerance = GICModFailsButGICRawHolds.tolerance/10\n",
    "\n",
    "# When the solver reaches its tolerance threshold, it changes the solver\n",
    "# attribute stge_kind to have 'iter_status' of 'finished'\n",
    "# If we want to continue the solution (having changed something, as above)\n",
    "# To continue the solution from where we left off, we just change the\n",
    "# 'iter_status' to 'iterator' and tell it to \".solve()\" again\n",
    "\n",
    "GICModFailsButGICRawHolds.solution[0].stge_kind['iter_status'] = 'iterator'\n",
    "# continue solving\n",
    "\n",
    "# Setting messaging_level to NOTSET prints all info including progress\n",
    "GICModFailsButGICRawHolds.solve(messaging_level=logging.NOTSET, quietly=False)\n",
    "\n",
    "# Test whether the new solution meets a tighter tolerance than before:\n",
    "distance_now = GICModFailsButGICRawHolds.solution[0].distance_last\n",
    "print('\\ndistance_now < distance_original: ' +\n",
    "      str(distance_now < distance_original))\n",
    "\n",
    "# Again increase the range\n",
    "GICModFailsButGICRawHolds.aXtraMax = GICModFailsButGICRawHolds.aXtraMax * 10\n",
    "\n",
    "# and gridpoints\n",
    "GICModFailsButGICRawHolds.aXtraCount = GICModFailsButGICRawHolds.aXtraCount * 2\n",
    "\n",
    "# construct grid with the extra gridpoints and expanded range\n",
    "GICModFailsButGICRawHolds.update_assets_grid()\n",
    "\n",
    "# and decrease error tolerance\n",
    "GICModFailsButGICRawHolds.tolerance = GICModFailsButGICRawHolds.tolerance/100\n",
    "\n",
    "# mark as not finished but ready to continue iterating\n",
    "GICModFailsButGICRawHolds.solution[0].stge_kind['iter_status'] = 'iterator'\n",
    "\n",
    "# continue solving\n",
    "GICModFailsButGICRawHolds.solve(messaging_level=logging.DEBUG, quietly=False)\n",
    "\n",
    "# Test whether the new solution meets a tighter tolerance than before:\n",
    "distance_now = GICModFailsButGICRawHolds.solution[0].distance_last\n",
    "print('\\ndistance_now < distance_original: ' +\n",
    "      str(distance_now < distance_original))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "51ab4076-6dee-4e70-a1b9-c5a0b9cd1402",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.11.0'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import HARK\n",
    "HARK.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8264351",
   "metadata": {},
   "source": [
    "`# Plot the results:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dfbdc00c",
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Saving figure GICModFailsButGICRawHolds in ./Figures\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA84AAAK3CAYAAABUTxblAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAACZpElEQVR4nOzdeVyVZf7/8fdhEQSBA66oKB7ABTEVtEXbFZualqkkm5n2UrJmqqlJspqWqcbBpn7T1DSBbbYbNEtN20CrLZMK5YYacFxzS1llX87vD77nHm7PAVHhHJbX8/E4D+E+133OdZ+jyPt8rsXicDgcAgAAAAAAbvl4uwMAAAAAAHRnBGcAAAAAANpBcAYAAAAAoB0EZwAAAAAA2kFwBgAAAACgHQRnAAAAAADaQXAGAAAAAKAdBGcAAAAAANpBcAYAAAAAoB0EZwAAAAAA2kFwBgAAAACgHQRnAAAAAADaQXAGAAAAAKAdBGcAAAAAANpBcAYAAAAAoB0EZwAAAAAA2kFwBgAAAACgHX7Hc3JmZqaysrJks9mMY+np6bJarcfbLwAAAAAAuoVjCs52u13JyclKTExUTk6OcTw3N1fz589XVlZWp3UQAAAAAABvsjgcDsfRnGC325WUlKTZs2e7BOTk5GTl5ubqKB8SAAAAAIBu66iDc0xMjEpKSrR161bTkOz8/HwjULeuQgMAAAAA0JMd1VDtpUuXym63a9GiRS7zmBMTE5WXl6fExMTO7B8AAAAAAF7V4YpzWVmZwsPDJUmlpaUsAAYAAAAA6BM6vB3Vm2++KamlskxoBgAAAAD0FR0Oznl5eZKkadOmdVlnAAAAAADobjocnEtKSiRJSUlJXdYZAAAAAAC6mw4H5+nTp0uSbDZbu+0yMzOPr0cAAAAAAHQjHQ7Os2fPltSyj3NbkpOTjxisAQAAAADoSY5qH+fU1FTl5uYqLy/PtEBYdna2MjIylJ6eznZUAAAAAIBe5aiCs9QyFDsrK0s2m01Wq1VlZWVKSkrSggULuqqPAAAAAAB4zVEHZwAAAAAA+pIOz3HuLHV1dXrggQdUV1fn6adGF+E97V14P3sX3s/ehfez9+E97V14P3sX3s/e5XjfT49XnCsqKhQWFqby8nKFhoZ68qnRRXhPexfez96F97N34f3sfXhPexfez96F97N3Od730+MVZwAAAAAAehKCMwAAAAAA7fDz9BM2NzdLksrLyz391OgiFRUVpj/Rs/F+9i68n70L72fvw3vau/B+9i68n72LM3868+jR8vgcZ7vdrpiYGE8+JQAAAAAAKi4uls1mO+rzPF5xHjhwoCRp586dTLIHAAAAAHS5iooKRUVFGXn0aHk8OFssFklSaGgowRkAAAAA4DHOPHq0WBwMAAAAAIB2EJwBAAAAAGgHwRkAAAAAgHYQnAEAAAAAaAfBGQAAAACAdhCcAQAAAABoB8EZAAAAAIB2EJwBAAAAAGgHwRkAAAAAgHYQnAEAAAAAaAfBGQAAAACAdvh5uwMAAABon8PhUENDg5qbm73dFQDwGB8fH/n7+8tisXi7KwRnAACA7qq6ulrl5eWqrKxUU1OTt7sDAB7n6+urkJAQhYWFKSgoyGv9IDgDAAB0Q5WVldq1a5f8/f1ltVoVHBwsHx+fblF5AYCu5nA41NzcrKqqKlVUVKisrEwjR45USEiIV/pDcAYAAOhmqqurtWvXLoWGhmr48OGEZQB9VnBwsAYPHqzdu3dr165dGj16tFcqzywOBgAA0M2Ul5fL39+f0AwAkiwWi4YPHy5/f3+Vl5d7pQ8EZwAAgG7E4XCosrJSoaGhhGYA+D8Wi0WhoaGqrKyUw+Hw+PMTnAEAALqRhoYGNTU1KTg42NtdAYBuJSgoSE1NTWpoaPD4cxOcAQAAuhHnllM+PvyaBgCt+fr6SpJXtubjJzIAAEA3xDBtADDz5s9FgjMAAAAAAO0gOAMAAAAA0A6CMwAAAAAA7SA4AwAAAADQDoIzAAAA0M0kJSXJYrEYt7KyMm93qddJTU01vcbZ2dne7hK6MYIzAAAA0A3l5OTI4XDI4XDIarUe1blLly4lbB9BRkaG8fomJiZ6uzvo5gjOAAAAgBuZmZmmiuSx3MLDwz3e7/z8fKWlpSktLc3jz91TRUREeLsL6OYIzgAAAIAbCxYsUGlpqXJyciRJpaWlxk1qqQg7v8/Ly1NWVpYWLFggSZo9e7aKi4u9UvVdsmSJpJbgT9W5b8jNzVVKSorxgUlqaqry8/O93a1exc/bHQAAAAC6K6vVqtmzZ8tqtaqkpEQ2m012u9047pSYmKjExETNnTtX6enpSklJUUpKisf7a7fbFRERoblz5yo7O1tLlixRenq6x/sBz0lLS1N+fr7xAY9TUlKSUlNTjQ9zcHyoOAMAAABH4UhVXKvV6hJiPCU9PV3p6elavHixJOY693a5ublaunSp279vWVlZVJ47EcEZAAAAOEodmRPrDK+e4gzIVqtViYmJRkU8MzPTo/2A56SlpbVZUbbZbJo9ezZz3TsJwRkAAADoBPn5+UpOTja+nzt3rkef//AFwZxDtJ1zntG75OfnKz8/X0lJSW22SUxMVG5uLqMOOgHBGQAAAOgEa9asUUlJiemYw+HwyHOXlZUZc7CdnPOuy8rKtHTpUo/0A56Tm5srSab3/HAxMTGmtjh2BGcAAACgE2RlZXntudtaBIyqc++1evVqSe0HZ+d9zrY4dqyqDQAA0MNVVVW1eZ+vr68CAwM71NbHx0f9+/c/prbV1dVtVlctFouCgoKOqW1NTY2am5td2gUHB7fZN2/IzMxUbm6uEhMTPf7cZWVlstvtbgPU7NmzlZiYqPz8fGVmZnZoheXs7Gzl5ORozZo1mjdvnhYtWiSpZcVuZxAvKSmR3W7X4sWLjSHpZWVlWrJkiTEs+PDz0bmcr3NH5tszVPv4EZwBAAB6uAEDBrR533nnnad3333X+H7IkCGqrq522/aMM87Qp59+anwfHR2tAwcOuG07bdo0UxUrPj5e27dvd9s2Pj5eGzduNL6fPn26CgoK3LYdPXq0tm3bZnx/+umna82aNS7tPDUEui3O4Gi325WRkaHs7GwtWrTIK0NiMzMz212IbPHixUpJSVF6evoRg7PdbldOTo4yMjKUm5ur5ORkJSYmym63Ky8vTxkZGUbbpUuXKiUlRTk5OYqIiNCSJUu0bNkyWa1WSTLNvyU8d77DpwW44wzVdru9q7vT6zFUGwAAADhKZWVliomJUXJysrKzs5Wenm5aGMyTVq9e3W6le+7cucb+09nZ2e0+Vnp6ussqzKmpqSouLjaFZknGqt3p6elasmSJsrKyjNAsyejT4ef1JpmZmbJYLJ1yO9oPXagiexYVZwAAgB7u0KFDbd7n6+tr+n7//v1ttvXxMddUWld+j9S2oKCg3eHXra1evbrDbT///HO3Q7W9zWq1qrS0VHa7Xbm5uUpPTzeFRk9ZunSpUlNTj9guPT1dKSkpSktLa3e179ZDvp37/9psNrfzp50VzzVr1mjr1q3H0v0eb8GCBR0a/o6er8uDc11dnerq6ozvKyoquvopAQAA+pSjme/bVW1bz0vuzLat51F3J84hsDabTQsWLNBll12mMWPGtLtQU1dYvXp1h4ZBz507V1ar1Qj6zmpxa2VlZaYQnpOTI0luQ7P0v2C9ePFitx8atA7e3mS325WSkqKPPvrIKx9udAd99brdOTyPBgQEKCAg4IjndflQ7SVLligsLMy4RUVFdfVTAgAAAB5ltVrbnWfsTkxMjBEuj0VmZmaHqs1OzgB8+FBsJ6vVaqpG5+bmymq1tjkM3Bms3YVw5/mSlJKS0m6/juZ1cC6E1hEpKSlKTU1Vamrqcb3O3ZUzDB/NXGdIUVFRpnza0RXnuzw4L168WOXl5cZt586dXf2UAAAAgMe1FSDdyc3NbXMl7I7Kyck5qudcsGCBrFar8vPzjzif1nl/e49/pGC9YsUKSdJll13W7mMczeuwZs2aI87TdsrKylJGRsZRfbjQkzhfs/bmOjs/ZKDi/D87d+405dOOfuDV5cE5ICBAoaGhphsAAADQ2yQmJiovL8/leEpKikvYy8nJUWJi4jEHmuzsbM2bN++oz3OGhLaGXzs5q8ltLXjmrOC2Faztdrvy8/OPeI3H+zr0ZdOnT5fUfsXZeZ+zLeSSTTsyTFtiVW0AAACgyzhXsj48GLY1z7ijVqxY0e4iX21ZtGiRrFarcnNz2x2+fKSKs7Oa3Fawdq6k3bra665SfLyvg7d15qraRzuc3Pm6tTd0vbi42NQWx47gDAAAAByljswrLSsrM4LltGnTlJubq9TUVKWkpCg/P1/5+flKTU3V0qVLj+q5nfsrHyvnKtDtze3Mz8+X1Wptcwj1kYK1MyS3XnHaGaY763XoDhYsWCCHw9Ept/a2FHMnMTFRNpvNGB3gTnZ2tmbPnk1FvxOwHRUAAABwFDoSQrKzszV//nxNmzZNJSUlslqtmj17tmbPnq3s7GxlZ2e3G3jak5GRoaysrGM6V2oZrr106VJlZ2e7nV/sDL3tzU3Oz8+XzWZzG6ydC3i1DtXZ2dnGImGd9Tqg5e9CcnKyysrKXP5e2u122e12Xt9OQnAGAAAA2lBWVqY1a9aorKzMWJk4IiJCZWVlys3N1bRp0yS1VKCd83qdldxly5a5fUznvN5j4RxifaSVqo/EarWqrKxMaWlpLiH8SPObj1RtdgY4Z6h2hjdnxbn18xzr64AWs2fP1qJFi5SSkmIKyM7RDhkZGV7fDqy3IDgDAAAAbhy+3VN4eLjp/iMNl3aG28MX4srNzT2m+cnOx3JWEjtDdna2S7XSOUS7vT7abLY2t7WSWkJxWlqa8fodHpql9l+HtLQ0tyt/l5WVqaSkxJhjfXifjqcS31Olp6crOztbqampxvtot9uVkZHB3OZORHAGAAAA3FiwYIFpjm5ncA5jPtY5yp4Ydpuent7uqtuzZ882Fp1qr427FcadjvQ6tPX8zor7okWL2n3+vmbu3LnH/GEMOobFwQAAAAAPcTfMub19eHsrXgf0NARnAAAAwENycnJcFs3qyArdvQ2vA3oagjMAAADgQc7FmpzDlfvq4k2eeh2cgZxgjuPBHGcAAADAQ5wLZmVmZkpSn52r64nXITU1VSUlJcaw8JSUFE2bNk1JSUmdPncdvR/BGQAAAPAQm83GvrryzOvgbiVv4FgRnAEAAAD0CNOmTeuzQ9vhXcxxBgAAALqh5ORkWSwWWSwWVpz+P849pjtDamqq8fq62zMaaI2KMwAAANDNtLcHMjpHRkYGw7nRYVScAQAAAABoB8EZAAAAAIB2EJwBAAAAAGgHwRkAAAAAgHYQnAEAAAAAaAfBGQAAAACAdhCcAQAAAABoB8EZAAAAAIB2EJwBAAAAAGgHwRkAAAAAgHYQnAEAAAAAaAfBGQAAAACAdhCcAQAAAABoB8EZAAAA6GaSkpJksViMW1lZmbe71KNkZmZ6uwvtSk1NNb2/2dnZ3u4SjoDgDAAAAHRDOTk5cjgccjgcslqt3u5Oj2G325WamurtbrQrIyPDeG8TExO93R10AMEZAAAAcCMzM9NUFTyWW3h4uLcvo8/JyMjQ3Llzvd2NDouIiPB2F45bcnKyYmJiFB4ebvr7HxMTo6SkJG93r1MQnAEAAAA3FixYoNLSUuXk5EiSSktLjZvUUhF2fp+Xl6esrCwtWLBAkjR79mwVFxczxNoLsrOzNW/ePG93o0/JyclRcXGxtm7dahzLy8tTcXGx8vLyvNizzkNwBgAAANpgtVo1e/ZsWa1WlZSUmP50HrdarUpMTNTcuXOVkZFhBOuUlBQv977vyc/PV0lJSY+qOPcmzn8PknrdEHSCMwAAAHAUjlRFtlqtRpUanpWRkaHLLrvM293o03rD0HN3/LzdAQAAAKCn6Ug4WLx4MVVnD3vzzTf10UcfebsbfU5ubq7y8/N18OBB2e12SVJaWpoGDhyoxMREzZ4928s9PH5UnAEAAIBOkJ+fr+TkZON7hgt7Vm5urqTeN0S4O8vNzVVSUpLy8/O1aNEipaeny2azSZLS09O1aNEilZWVKSkpqdtvEXYkVJwBAACATrBmzRqVlJSYjjkcDi/1pu/JyMgwFmdD10tNTVVmZqaKi4uNsOzO3LlzNXv2bCUlJSkjI6PHLhZGxRkAAADoBFlZWV3+HKmpqUpKSjJt/eOs5JWVlSk1NVUxMTHGVljJyclGJdYpOztbycnJCg8PV3h4uJKSkpSWltblfe9q2dnZbe7fzOvWuTIzM5WZmamMjIx2Q7OT1WpVVlaW8vPze+z0BYIzAAAAcJwyMzNdglZXSEpKks1mk91uNy1Slp+fr6SkJCUlJRnbZNlsNuXm5io5OVnZ2dmSWlb6XrFihdLT07V161alp6crPz9fS5cu7dH77WZmZspms7UZ4njdOo/dbjc+oDiaCr9zrnN2drbxuvYkBGcAAIAerqqqSlVVVaZhwfX19aqqqlJdXZ3bts3NzcaxhoYGVVVVqba29pjbVldXq6qqSk1NTcaxxsZGVVVVqaam5pjb1tTUqKqqSo2Njcax1ud5S0lJiex2u3Jzc5WSkqLU1FQtWrSoy593wYIFysrKMs2fLisrU0pKivLy8rRgwQLZbDZZrVYtXrzYaJOWlqa0tDRNnz5dWVlZSkxMlNVqNdpLLSGyJwYaqaXa31a1WeJ160zOa+1IpflwzvnnGRkZndonTyA4AwAA9HADBgzQgAEDdODAAePYo48+qgEDBuhXv/qVqe2QIUM0YMAA7dixwzj217/+VQMGDND1119vahsdHa0BAwZo06ZNxrEXX3xRAwYM0OWXX25qGx8frwEDBig/P984tmLFCg0YMEAXXnihqe306dM1YMAArVy50jj273//WwMGDHBZfff000/XgAED9OGHHxrHPv744yO+Jl2trKxMMTExRlUyPT3dtDCYJy1ZskQZGRnG/rlOrYONM+S7C/et261evbrL+tlVysrKlJube9Tzm3v665aZmSmLxdIpt6MZLVFcXCzp2BZhi4mJkSSXtQB6AhYHAwAAAI6S1WpVaWmpEazS09NdApinlJWVud3u5/D+zJs3z+35rds5txLqSTIzMzV79uyjfv17+uu2YMECryyG5gy/rT8k6yhn6O6Jez0TnAEAAHq4Q4cOSZKCgoKMY3feeaduu+02+fmZf93bv3+/JKl///7GsZtvvlnz58+Xr6+vqe22bdtc2l5zzTX6xS9+4dK2oKBADodDgYGBxrF58+bpZz/7mXx8zIMcV69e7dL2/PPP16FDh1zafv7552publZAQIBx7Oyzz27jlfAc5y/+NptNCxYs0GWXXaYxY8Yc0/DV49XRyl9P2KbJbrcrJSVFH330UYeD8IoVK9odpt2W3vS6edLcuXOVlpZ2TB8WOMP2sbxf3sZQbQAAgB4uODhYwcHBslgsxrF+/fopODjYFDhbt20dUP39/RUcHGwKskfbNigoSMHBwaZA7efnp+DgYFPwPtq2/fv3V3BwsOkDgMNDe3dw+NzYjoiJiTmmqt3hOhrWOyPUH02fy8rKOhyunPPEU1NTj+o1sdvtys/PP6bKa3d93bo7m82m9PR0STqqvZmdozNmz57dI/c4JzgDAAAAncDdsN+25Obmym63e6VCfayOts9r1qzp8KJZWVlZysjIOOpKZEZGRrcPYT3xvT6SRYsWacGCBUpNTe3whyPJyclKTExUTk5OF/euaxCcAQAAgE6QmJiovLw8l+MpKSkuATInJ8dYobmn6I59zszM7PbDfrvj69YZMjIylJOTo+TkZC1durTNdtnZ2UpKSlJqaqrbfx89BXOcAQAAgC5it9uVnZ3tEu6cQ1Z7ku7WZ+fQ5+7UJ3e66nXrzA8N8vLyjmku9+zZs1VcXKzc3FylpaVJ+t9CaWlpaRo4cKBsNttRzVnvrgjOAAAAwFHqyHY6ZWVlxhZV06ZNU25urrKyslRSUqL8/HxFREQoNTVVMTExHtkD+lh05z5nZGTosssu82of2uKJ181bq2q7M3v2bOPDgezsbNntdmMedG9BcAYAAACOQkcqZ9nZ2Zo/f76mTZumkpISWa1WI1xkZ2crOzu7R8z17M59fvPNN/XRRx95uxtudefXrav1xD2aO4LgDAAAALShrKxMa9asUVlZmbEFVUREhMrKypSbm6tp06ZJagkLzhWelyxZIklatmyZ28d0znk9Fvn5+SopKVFZWZlxzLlacUREhBITE40+H75oU25urmw2m6ZNmyar1Wo8Vut2zutyPlZn9LkrZGdnu/SxPbxunuN8jXvbgmgEZwAAAMCNw+eQhoeHm+53DsNuS0pKiiS5DFnNzc095pWg09LSlJubazqWn59vrFicl5cnu93utm/Oa3HOZ50/f77LFkm5ubnGnNzWVdL2+uyuT1JLgCopKdGKFStc7rPZbMrKyjryBbdhxYoVR/UadsfXrTdJTk52+TAhJibG+NCgJy8K5kRwBgAAANzoijmkzr2NjxS629KRIb+JiYlyOBxHbNfRMHOkPrc1lzU3N1f5+fldMhc6OztbxcXFHW7fHV+33qQvDEVnOyoAAADAQ5xVz9arLLcePtwddbc+Z2ZmKjExsdsPA+5urxuOD8EZAAAA8JCcnBxTkMrOzu72iyl1tz5nZWVp3rx5Xnv+jupurxuOD8EZAAAA8CBnpdQ5lLe7V04lz/XZGSzbCpjORbi6yzZMR9IT32u4xxxnAAAAwEPS0tKUmpqqzMxMSfL6Xsgd4Yk+p6amqqSkxBjenJKSomnTpikpKckUkjMzMzV79uwObQnmbT3xvUbbCM4AAACAh9hsth63kJIn+pyRkdHhdm0tRtbd9MT3Gm0jOAMAAADodNOmTevUocl2u112u71PbO+E7oc5zgAAAEA3lJycLIvFIovF0iNXY7ZarZ0+p7ejlenuLjU11Xhv3e2Bje7H4ujIZmWdqKKiQmFhYSovL1doaKgnnxoAAKDbq62t1datWzVmzBgFBgZ6uzsA0G0cz8/H482hVJwBAAAAAGgHwRkAAAAAgHYQnAEAAAAAaAfBGQAAAACAdhCcAQAAAABoB8EZAACgG/LwxicA0O158+ciwRkAAKAb8fFp+fWsubnZyz0BgO6lqalJ0v9+TnoSwRkAAKAb8ff3l6+vr6qqqrzdFQDoVqqrq+Xr6yt/f3+PP7dfVz9BXV2d6urqjO8rKiq6+ikBAAB6LIvFopCQEFVUVGjw4MGyWCze7hIAeJ3D4VBFRYVCQkKO6+fi4Xk0ICBAAQEBRzyvyyvOS5YsUVhYmHGLiorq6qcEAADo0cLCwtTQ0KDdu3cz1xlAn+dwOLR79241NDQoLCzsuB4rKirKlE+XLFnSofMsji7+aeyu4hwVFaXy8nKFhoZ25VMDAAD0WJWVldq1a5f8/f0VGhqqoKAg+fr6UoEG0Cc4HA41NTWpurpaFRUVamho0MiRIxUSEnJMj1dRUaGwsDDt3LnTlEM7WnHu8qHaHe0IAAAA/ickJESjR49WeXm5ysrKdPDgQW93CQA8ztfXVyEhIQoLC1NQUNBxP15oaOgxFXC7PDgDAADg2AQFBSkoKEjDhg1TQ0MDK20D6FN8fHzk7+/fLUbaEJwBAAC6OYvFon79+nm7GwDQZ7EdFQAAAAAA7SA4AwAAAADQDoIzAAAAAADtIDgDAAAAANAOgjMAAAAAAO0gOAMAAAAA0A6CMwAAAAAA7SA4AwAAAADQDoIzAAAAAADtIDgDAAAAANAOgjMAAAAAAO0gOAMAAAAA0A6CMwAAAAAA7SA4AwAAAADQDoIzAAAAAADtIDgDAAAAANAOgjMAAAAAAO0gOAMAAAAA0A6CMwAAAAAA7SA4AwAAAADQDoIzAAAAAADtIDgDAAAAANAOgjMAAAAAoFf7/vvvj+t8v07qBwAAAAAAHudwOLRnzx4VFRWZbn/+8581fPhwSdKKFSuO6zkIzgAAAACAbq25uVm7d+/WwIED1b9/f0nSq6++qvT0dBUXF6u6utrlnBtvvNEIzpMnTz6u5yc4AwAAAAC6hYMHD2rt2rUqLCw0VY+Li4tVU1OjTz75RGeeeaYkqa6uTuvXr5ck+fj4KDo6WrGxsYqNjVVcXJxiYmKMx73wwguPq18EZwAAAACARzQ1NWnHjh1GIC4sLNR1112nhIQESdLf//53LViwwO25vr6+2rNnj/H9nDlz9O677yo2NlbR0dHq169fl/Wb4AwAAAAA6DSNjY1qampSQECAJOnLL7/UkiVLVFRUJLvdroaGBlP7hIQEIziPGzdOY8eOVVxcnFE9dlaQR40aJX9/f+O8kSNHauTIkR65JoIzAAAAAOCoNDQ0aNu2baYh1c6vt23bpmeffVZXX321JKmmpkbvvvuucW6/fv0UExNjBOL4+HjjvtNPP11btmzx+PUcCcEZAAAAAOCirq7OFI5nzJihE088UZL08ccf6yc/+Umb5xYXFxtfT5kyRc8884wRlEeMGCFfX98u739nIjgDAAAAQB/lcDhksVgkSdu2bVN6erpRQd6xY4eam5uNtvfff78RnOPi4hQUFGQaTt36NmLECOO8QYMGKTU11bMX1skIzgAAAADQi1VXV6u4uNhln+OioiLNnz9f9957r6SW4dfPPPOM6dwBAwYYYXjChAnG8TFjxujQoUNG6O7tCM4AAAAA0MNVVVUZYTgyMlIzZsyQJBUVFSkuLq7N81rPJ46Ojtbdd99tLMwVFxenIUOGuA3HfSUwOxGcAQAAAKAHOXTokJ588knTglytt2m6+uqrjeA8atQo+fj4KCQkxBSInVXkcePGGef5+/vrkUce8fj19AQEZwAAAADoJsrLy02B2Hk7+eST9ac//UmS5Ofnp3vuuUcOh8N07sCBAxUbG6uYmBjjWL9+/XTgwAFZrdY+VyXuTARnAAAAAPCgkpISFRUVyeFw6KSTTpIk1dfXa+TIkfrxxx/dntN6FerAwED9+te/1sCBA03V4/DwcLfntnUcHUdwBgAAAIAu4HA49Oqrr7pUkEtKSiRJZ555pj755BNJLZXhfv36SZKGDh1qCsSxsbGmvY4l6YknnvDsxfRxBGcAAAAAOEoOh0M//vijaTh1YWGhIiIi9Ne//lVSywJaixYtMs0/doqMjNTgwYNNxz799FMNHTpUISEhHrkGdBzBGQAAAADccDgc2rdvnw4cOKCEhATj+DnnnKOvv/5alZWVLueMGjXKCM6SlJKSopqaGlP1OCYmRsHBwS7nxsbGds2F4LgRnAEAAAD0eV9//bUKCgpchlVXVVVpzJgxstvtRttDhw6psrJSFotFUVFRppWqD9/6iSHVvQPBGQAAAECv1tzcrB9++ME0pPrQoUN6+umnjTa/+c1v9M0337ic6+PjI19fXzU1NRkLdP31r39VQECAxowZo8DAQI9dB7yH4AwAAACgx2tqatLevXs1YsQI49iiRYv03nvvqbi4WLW1tab2fn5+euKJJ+Tv7y9JOv3002W1Wo3h1M4KcnR0tAICAkznTpkypcuvB90LwRkAAABAj7Fr1y5jSHXrYdV2u10Oh0M1NTVGZXjXrl3auHGjpJagPGbMGFMobmxsNILz0qVLvXZN6P4sjsN3ze5iFRUVCgsLU3l5uUJDQz351AAAAAC6uYaGBm3fvt0IxcXFxXrssceMMHz55ZdrxYoVbs/t16+fiouLNXLkSEnSN998o7KyMsXFxWnUqFHy86Nu2Fcdbw7lbw4AAAAAj6qvr5e/v78sFosk6fnnn1dWVpaKioq0detWNTU1mdrffvvtGjVqlCRp4sSJio+PdxlSHRsbq6ioKCNgS9JJJ53kuYtCr0ZwBgAAANDp6urqZLfbTfscO2/bt2/Xtm3bjMpwYWGhPvjgA+PcwMBA0/ZNrSvFv/vd7/S73/3O49eDvo3gDAAAAOCY1NTUmMLxtddeq4iICEnSfffd1+684cLCQiM4X3LJJYqJiTEqyJGRkfLx8fHINQAdQXAGAAAA0CGffPKJXn/9dSMo79y503T/iSeeqNNOO02SFBsbqwEDBpiGUrf+etiwYcZ506dP1/Tp0z16LcDRIDgDAAAAfdyhQ4dUXFxsWqXa+XVWVpZmzJghSdqyZYuWLVtmOjc0NNQIxMHBwcbxa6+9VjfccIMxjxnoyQjOAAAAQB9QUVFhBOJTTjlFUVFRkqTnnntON9xwQ5vnFRYWGsF55syZuu+++0yV44EDB7oNx6xgjd6Ev80AAABAL/P999/rzTffNFWP9+/fb9z/8ssv64orrpAkI0APHDjQFIidQ6snTJhgnDdp0iRNmjTJsxcDdAMEZwAAAKAHKSkpMQVi55DqtLQ0XXzxxZKk4uJitytPDxkyxGVI9emnn66SkhKFh4d77BqAnobgDAAAAHQjDodDBw8eVFFRkYYNG6bo6GhJ0hdffKELL7xQpaWlbs9bv369EZwTEhJ0zTXXuFSQQ0NDXc4LDAxUYGBgl10P0BsQnAEAAAAvOXjwoP7973+7VJDLy8slSQ8//LDuueceSdLgwYON0DxixAiXlaqTkpKMx42KitILL7zg+QsCeimCMwAAANAFHA6H9u7d67JS9XnnnadrrrlGkrRv3z7j68NFRUXJ19fX+N5ms2ndunWy2WymodYAuh7BGQAAADhGzc3N2rNnjxwOh0aOHClJ2rlzp84//3wVFRWpurra5ZyQkBAjLNtsNs2ePds0nDo2NlY2m039+/c3nefv78/CXICXEJwBAACAI6ivr9cXX3xhWoyrqKhIxcXFqqmp0fz585WZmSmpZXXqdevWSZJ8fHwUHR1tCsUnnXSS8biBgYHKycnxyjUB6DiCMwAAAPq8pqYm7dy50xSKY2NjtXDhQkktwXnWrFluz/X19TVVloOCgvSf//xHo0ePVnR0tPr16+eRawDQdQjOAAAA6BMaGxtVXl6ugQMHSpIaGhp0ySWXqLCwUHa7XQ0NDab2s2bNMoLzgAEDdOqppyo0NNS0IFdsbKxGjx4tf39/07nJycmeuSgAHkFwBgAAQK/SeiGu1l9v3bpVZ599tj788ENJLXOGV61apf3790uS+vXrJ5vN5naVaklauXKlx68FQPdAcAYAAECPUl9fr61btxqB2N/fXzfddJNx/ymnnKKDBw+6PXfHjh2m75955hmjijxy5EjTKtYA4GRxOBwOTz5hRUWFwsLCVF5e7nYDdgAAAKCpqckUYu+66y7l5+ersLBQO3bsUHNzs3FfbGysCgsLje9nzZqlH3/80WVIdVxcnIYPHy4fHx+PXgsA7zveHErFGQAAAF5RXV0tu91uVI5bD60ODg5WQUGB0fbjjz/W6tWrje+Dg4ONQDxhwgTT43700UceuwYAfQPBGQAAAF2mqqpKxcXFKioq0sGDBzV//nzjvtNPP115eXluz/P39zdVne+44w7V1NQYYXno0KGyWCweuQYAIDgDAACg07z44otauXKlUUHevXu3cV+/fv103XXXGWE4JiZGxcXFpuHUrW+th1TPmzfP49cCAE4EZwAAABxReXm5aUi1c1j1Dz/8oOLiYiPkvvvuu8rOzjadGxERYcwxrq6uVkhIiCTppZdeUr9+/agcA+j2ujw419XVqa6uzvi+oqKiq58SAAAAx6C0tNQIxZdffrkRaK+++mq99NJLbZ63e/dujRw5UpJ02WWXadKkSabKcUREhNvzAgICOv8iAKAdh+fRgICADv0s6vLgvGTJEj344INd/TQAAAA4Cp999pk++eQTU/W4pKTEuP/MM89UZGSkJGno0KHGn61XqHZ+PWTIEOO8lJQUz14IAByFqKgo0/f333+/HnjggSOe1+XbUbmrOEdFRbEdFQAAQBdwOBw6cOCAaYVq5+3f//63EXJ/+9vf6rHHHnM5PzIyUnFxcXr22WcVFxcnSSopKZGfnx+/uwHosZzbUe3cudP0s6zbVJw72hEAAAB0jMPh0L59+1RUVKSpU6cqODhYkvTYY4/p97//fZtT44qKiozgfMYZZ6i8vNxUPY6JiTEeq7W2hloDQE8TGhrKPs4AAAC9TWFhoT7//HOXhbkOHTokSfr666918sknS5L69++viooKWSwWRUVFuaxSPX78eONxL7jgAl1wwQVeuSYA6GkIzgAAAF7S3Nys3bt3uwyrfvDBB5WQkCBJ+uCDD3TLLbe4nOvj46NRo0apsrLSODZ37lydddZZGjNmjAIDAz12HQDQ2xGcAQAAulBTU5N27dql8PBwY3jgO++8o8WLF6u4uFi1tbUu51x66aVGcJ4yZYrOOeccl0W5oqOjXabDDRkyxLRQFwCgcxCcAQAAOkFpaanWrFnjUj0uLi5WfX293njjDc2bN09SS7V448aNkiRfX1+NGTPGtEr19OnTjcc97bTT9MEHH3jlmgAALQjOAAAAHdDY2Kht27aZ5hnPnTtXp556qiRp5cqVuuiii9ye6+/vrwMHDhjfn3zyyfrggw8UGxurUaNGyd/f3yPXAAA4NgRnAACA/9PQ0KCGhgYFBQVJktavX69FixapqKhI27ZtU2Njo6n9sGHDjOA8duxYTZgwwWWP47i4OEVFRcnX19c4b+DAgTrnnHM8d2EAgONCcAYAAH1KQ0ODiouLjapx62HV27dv1x/+8ActWrRIkmSxWEzDpAMDA02B+JRTTjHuGz9+vAoKCjx+PQCArkdwBgAAvU5tba3sdrsRjE844QQlJydLkgoKCjRlypQ2z926davxdUxMjJYtW2aE5eHDh8vHx6eruw8A6GYIzgAAoEdyOByyWCySpB9//FH33HOPUTnetWuXHA6H0TY1NdUIzrGxsQoJCVFMTIxpSLXzFhkZaZzXv39/3XDDDZ69MABAt0NwBgAA3VZVVZVpMa7Ww6p/9rOf6amnnpIkBQQEaNmyZaZzQ0NDjWB80kknGceDg4NVXl5uhG4AAI6E4AwAALyqoqJCxcXFKiwslNVq1Zw5cyRJ5eXlslqtbZ5XWFhofB0aGqo//OEPGjlypFE5HjRoUJvhmNAMAH2Hw+HQ/v37j+sxLI7W45g8oKKiQmFhYSovL1doaKgnnxoAAHhZU1OTlixZYqogt/5l5txzz9V7771nfD9o0CBJMi3I1frriIgIj18DAKB7cjgc2rdvnzZu3KiCggLTnyUlJZJ0zDmUijMAAOgUJSUlbodUx8bG6uWXX5Yk+fr66vHHH1dpaanp3MGDBysuLk4nnHCC6fi2bds0YMAAj10DAKD7czgc2rt3r0s4LigoMALy4SwWi46nZkxwBgAAHeJwOHTw4EEVFRWppqZGZ511lnFfTEyM7Ha72/MOD8m33nqr/Pz8jOpxTEyMwsLC3J5LaAaAvssZkFuHY+fXh//f4uTj46OYmBhNnDhR8fHxxp+RkZEaNmzYMfeF4AwAANxasWKFNmzYYFqcq6ysTJI0YcIE057F4eHhkqThw4e7DKkeN26c6XHvv/9+j10DAKD7czgc2rNnj9sKckcCcuuQPG7cOAUGBrq0r6ioOK4+EpwBAOhjnJ/gtw7ERUVFklrCstMf//hHfffddy7njxw5UqNGjTJtB/WPf/xDERERCg4O9sg1AAB6ntZzkA+/OT+YPZyPj49iY2NN1eP2AnJXITgDANALNTc3a8+ePdq9e7emT59uHL/sssv03nvvqaqqyuWc/v37q7m5WT4+PpKkSy65RCeddJKpgmyz2dS/f3+Xc6OiorruYgAAPc7+/fvdBuS25iA7A/LhQ6w9HZDbQnAGAKCHW7VqldauXWtakMs5Dzk4OFiVlZVGZbixsVFVVVXy8fHR6NGjXVarbh2cf/e733nzsgAAPcCBAwfcBuQDBw64bW+xWExDrJ237hKQ28J2VAAAdGNNTU3auXOnKRDv3LlTb7zxhhGGf/azn+lf//qXy7m+vr6Kjo7W6tWrjTnImzdvlo+Pj6Kjo9WvXz+PXgsAoOc6ePCgSzguKChoc39ki8WiMWPGuATk8ePHux251NWON4dScQYAwMsaGxu1Y8cOjRkzxgjDDz/8sF599VXZ7XbV19e7nPPkk09qyJAhkqSZM2eqoaHBqB47K8ijR4+Wv7+/6bzx48d3/QUBAHqs0tJStxXkffv2tXnO4QE5Pj5eEyZMUFBQkAd73rUIzgAAeMiuXbu0YcMG05DqwsJCbd26VY2Njfrxxx81aNAgSS17Im/evFmS1K9fP9lsNtOQ6tbV4jvvvFN33nmnV64JANAzlZeXuw3Ie/bsafOc0aNHu1SQJ0yY0CcWhiQ4AwDQSerr67Vt2zZTMH7ooYdktVolSY8++qj+8pe/uD03ICBAu3btMoLzddddp/POO0+xsbGKioqSr6+vpy4DANCLVFRUmPZAdt5++OGHNs+JiopyG5BDQkI82PPuheAMAMBRqKurk5+fnxFkV6xYoeeee05FRUXavn27mpubTe2vuuoqY1XrhIQETZo0yWVIdWxsrEaMGGEsyuVsm5CQ4LkLAwD0aIcOHXIbkHfu3NnmOSNGjHAJyPHx8axF5QbBGQCAw9TU1Mhut7usUl1UVKQdO3Zo9erVSkpKkiTt2bNHOTk5xrnBwcGmYBwREWHcN3/+fM2fP9/j1wMA6D2qqqpUUFDgEpK3b9/e5jmRkZFuA7JzRBSOjOAMAOiTqqurVVxcbITjefPmafTo0ZKkp59+Wr/97W/bPLe4uNgIzj/5yU8UFhZmBOVhw4YZC3wBAHCsqqurtWnTJpcK8rZt29o8Z9iwYcYeyK1vzp0VcOwIzgCAXsvhcBgh9ptvvtGyZcuMBbl2795tamuz2YzgHBcXp7CwMGMY9eHDqgcPHmycN378eFaqBgAcs5qaGm3evNklIG/dulVt7Rw8ZMgQtxXkgQMHerj3fQfBGQDQo1VUVJhWqG799dNPP61LLrlEkrR7924999xzpnPDw8ONMDx06FDj+Pnnn6/S0lIqxwCATlNbW6stW7a4BGS73e6yPobToEGDXALyxIkTjYUk4TkEZwBAt1dWVmaE4qlTpxoV3n/961/62c9+1uZ5hYWFxteJiYl64IEHTFXk1vOPW2u9SBcAAEejrq5O33//vUtALioqajMgR0REuA3IQ4YM8XDv0RaCMwCgW9m+fbtefPFFU/X44MGDxv2PPvqoEZyjo6MltQxZaz2U2vn12LFjjfNGjx6t+++/36PXAgDoverr69sMyE1NTW7PsVqtbgPy0KFDGeXUzRGcAQAe4XA4dODAAdMK1c5wfMMNN2jBggWSpIMHD+qBBx5wOT8yMlKxsbGmT98nTpyo8vJyts0AAHSZhoYGFRYWugTkwsJCNTY2uj0nNDTUbUCOjIwkIPdQBGcAQKdxOBzav3+/ioqKFBERoQkTJkiSNm7cqBkzZqiiosLtec59jqWWhbmuv/56U/U4JiZGAwYMcDnPz8+P0AwA6BRNTU2y2+3asGGDNm7caPy5ZcsWNTQ0uD0nJCTEbUAePnw4AbmXITgDAI5JZWWlsrKyXBblOnTokCTpV7/6lZ588klJ0vDhw43QHBUV5bJa9QknnGA8bkhIiJ599lnPXxAAoE9wOBzasWOHNmzYYArJmzZtUm1trdtzBgwY4Habp5EjRxKQ+wiCMwDARXNzs3bv3u0yrPqUU04x9jduaGjQ9ddf73KuxWLR6NGjFRISYhwLDw9XQUGBoqOj1b9/f49dBwCg73I4HNqzZ48RjJ0heePGjcaHvIcLDAxUfHy8EhISjHCckJCgqKgoFo7s4wjOANBHNTc3a9euXaqvr1dsbKykliryjBkzVFxcrJqaGpdzamtrjeAcERGhiy++WMOHDzdVj8eMGaOAgACXc53DtgEA6GwHDhwwVY+dX5eWlrpt7+/vr3HjxikhIcEIyQkJCRozZox8fX093Hv0BARnAOjlmpub9fHHH7vscWy321VXV6cLLrhAb7/9tqSWoWg7duxQTU2NfH19NWbMGNMq1VOmTDE99t///ncvXBEAoK8qLy83zT92huT9+/e7be/j46O4uDgjGDtDclxcnPz9/T3ce/RkBGcA6OEaGxu1fft201zjwYMH65577pHUMnT64osvdjsszd/f37RlhsVi0XvvvaehQ4dq9OjR/FIBAPCKqqoqbdq0yWUe8q5du9o8Z8yYMabqcUJCgsaNG6fAwEAP9hy9lcXhcDg8+YQVFRUKCwtj+xAAOAoNDQ06ePCghg0bZhybO3eu1q1bp61bt7psh5GQkKD169cb31966aVqaGgwVY9jY2MVFRUlPz8+QwUAeEddXZ02b97sMsR669ataiumjBw50gjHzj8nTJjgdvcFwOl4cyi/LQFAN1JYWKgtW7aYFuUqKirStm3blJCQoO+++85o+/3336uwsFBSy2ImMTExRiCOj483Pe5bb73lycsAAMCkoaFBRUVFLkOsi4qKTCOfWhsyZIgpHDsX67JarZ7tPCCCMwB4VG1trex2uxGIa2pqjCHVknTxxRdr48aNbs/dvXu3HA6Hse3Fn/70J/n7+ysuLk7Dhw9ntU8AgNc1NTVp69atLvOQN2/e3OZeyFar1WWRrokTJ2rw4MEe7j3QNoIzAHSy+vp69evXz/j+wQcf1Oeff66ioiLt3LnTNPQsJCREd999txGGp0yZIn9/f9Mq1c4qcmRkpGmvyDlz5njuogAAaMXhcGjnzp2mcLxx40YVFBS43ZVBkoKDg12GWCckJLj8/wZ0RwRnADgGVVVVKi4uNi3I5fy6urpaBw8eNH4JWLNmjT7++GPj3JCQECMMx8bGqqGhwQjar7zyileuBwAAdxwOh/bt2+eySNfGjRtVWVnp9pyAgADFx8e7hORRo0YxOgo9FsEZANpQWVlpBOLt27cb+xdLUkpKit5///02zz1w4IAxxOymm25SSkqKEZYHDRrEJ+sAgG7n4MGDLot0bdiwQSUlJW7b+/n5GXshtw7JMTEx7IWMXofgDAD/54033tAHH3xghOV9+/aZ7r/uuusUEREhSYqLi9M333xjGkrd+mtnO0k699xzPXodAAC0p6KiQhs3bnQJyXv37nXb3sfHRzExMS5DrOPi4kxTk4DejOAMoNcrLS11O6Ta+XVYWJgk6YsvvtDy5ctN5w4ePNgIxXV1dcbxP/3pT3riiSc8eh0AAByN6upqYy/k1iF5586dbZ4THR3tMsR6/Pjx6t+/vwd7Dhy95uZm1dTUqKGhwbTyenFxsfbv36+BAwce1+MTnAH0eA6HQyUlJUYQvvjiixUUFCRJuv322/X//t//a/PcoqIiJSUlSZIuvPBCRUZGmhbmcobqw/n7+3f+hQAAcAzq6ur0/fffuwyxttvtbe6FPHz4cJch1vHx8QoJCfFw79EbNDY2qrKyUs3NzaaA6hzqHx8fr0GDBklq2SXkvffeU0hIiObNm2e0feaZZ7Rp0yZdffXVSkxMlCQVFBTojjvu0KBBg/Tyyy8bba+77jp9+OGHeuyxx3T55ZdLktauXavExEQNHz5cP/zwg9F28eLFysrK0qOPPnpc10hwBtDjfP3113r//fdNVeOysjLj/m+//VZTpkyRJI0cOVJSyy8I7laqnjBhgnHenDlzWKkaANBtNTU1qbi42AjIztv333/f5l7IgwYNcrvVU3h4uId7j65SV1en8vJy+fr6mkLrqlWrVFlZqRNPPNH4QGTLli36+OOPNXz4cF100UVG24cfflg//PCDfvvb3yomJkaS9Nlnn+n3v/+9EhISTKPskpOT9d133ykrK0tnnnmmJOn999/XhRdeqBNPPFHffPON0Xb+/Pn673//q3/+85/G823ZskXz589XfHy8KTi/9dZbys3N1YknnmgE56qqKn3wwQcaNWqU6ZpLS0u1e/dulZeXG8cCAwMltWz92VpkZKRsNptRVDlWBGcA3YZz5c7Dh1IXFRXppZde0sSJEyW1DKl+6KGHXM4fOXKkYmNjTb88zJ8/X6mpqQoODvbYdQAAer/Kykrl5OSopKREERERSk5O7rRqrcPh0A8//KANGzZo/fr1RkAuKChwCQVOYWFhpvnHzq+HDBnSKX2Ce4cOHVJZWZn69+9vhFaHw6FPPvlEdXV1mjVrljEPfM2aNfryyy8VHx+v5ORk4zFuvfVWHTp0SEuXLjUeIysrS08++aRmzZql+++/32g7fvx47d27V6tWrdLYsWMlSc8//7xuuukmXXLJJXrrrbeMtpdeeql27dqlNWvWGKPrVq1apZtuuklz5swxBedXX31Vmzdv1uWXX24E55KSEn388cemqWqSVFZWpgMHDqiqqso45gyth7eNjo5WaWmpcb8kDR06VBdccIFGjx5tanv55ZfrpJNOUnx8vHHMZrNp+fLlLiMAly5dqvvuu88UqMeOHatDhw4pICDA1PaJJ57QE088oYqKCt188806VgRnAB7lcDi0Z88eFRYWKiEhwfgP4rnnntOtt95q+iHc2pYtW4zgPGPGDKWmppoqyG19ksiQMwBAZ6qqqtI999yjZcuWqbq62jgeFBSk+fPn65FHHjmqD2tLSkpcAvKGDRtMI6la69+/v+Lj4zVp0iRNnDjR+HPEiBF9bseG0tJSlZeXKywszKig19TUaOXKlWpoaNBPf/pTo+1HH32kb7/9VqeccopmzpwpqeXDjzvuuEO1tbVavny58fo9+eSTevXVV3XFFVfoV7/6laSW+eIjR45UbW2t9u/frwEDBkiSlixZoj/84Q+65ZZbTFXZWbNmSZL27t2roUOHSpJycnJ0991367rrrjMF5+eff16HDh3S3XffbfxetHfvXq1cuVKRkZGmay4vL1d5eblpr2xnUDx81MH48eMVHh4uP7//Rb4xY8bo0ksvNUbmOS1cuFClpaWmIDp9+nS99tprGjZsmKntK6+8osbGRlPwPfvss1VfX296Lkl6/fXXdbj4+Hi9/fbbLsevv/56l2MDBw7UVVdd5XI8Li7O5Zivr2+XFkoIzgC6zLZt25STk2NakKu4uNj4RaP1sB2r1aqqqir5+Pho9OjRplAcGxurk08+2XjcmTNnGv/pAQDgKVVVVTrrrLOUn5/vElKqq6v11FNP6auvvtInn3zi8gt8VVWVNm3aZArI69ev1549e9w+l6+vr8aOHatJkyYZVeRJkyZpzJgxXtnqyeFwmIL53r17VVFRoaFDhxrVwNLSUn355Zfy9/fXOeecY7T9+9//rs2bN+unP/2pJk+eLEnasWOH7rvvPgUHB+uvf/2r0fbuu+/Whx9+qEWLFhnDeIuKijR16lQFBQWZdry47bbb9NJLL2np0qW68847JbV8EHHOOefIz89PDQ0NRtu33npLf/vb33TfffcZv0M0Nzdr2bJlkqRnn33WqAzv2rVL33zzjel3jX79+qm0tFRSS1XVGZwDAgJc1j2xWCyaOnWqLBaLaY55QkKCLr/8cp144omm9vfcc4+am5tNC1qde+65ysrKcqnKfvzxx/L19TUdv/rqq3XNNde47JGdk5Ojw5166qk69dRTXY7fcsstLsdGjhypn//85y7Hx40b53LM19e3129BRnAGcEyampq0a9cul2HVv/nNb3TGGWdIahkOtGDBApdzfX19FR0dbfoPbfbs2dq8ebOio6NdhtgAANAd3HPPPW5Ds1NTU5Py8/N144036vzzzzcF5PYW6ho9erRLQB43bpwCAgLkcDjU3NxsCiXbt2/XoUOHFB0dbQT03bt365tvvpHVatVZZ51ltH3uuee0a9cuXXHFFcYQ3O+++06PPvqoRo0apSVLlhhtr7nmGuXl5ekvf/mL8RiffvqpzjnnHI0bN07r1q0z2v7yl7/Uxx9/rNdee80IV1u2bNEFF1yg6Ohobd261Wi7fPlyvf322xoyZIgRnCsrK7V8+XINGjTIFJy3bdum/Px80wcKfn5+OnTokMvrHhQU5DLaLCgoSFOmTFFAQICam5uNMHnyySfr0KFDxvM72z700EOmYcSSdOWVV2rmzJmmqqafn582bdqkwMBAU8D93e9+p/vuu0+Hy8/Pdzl2wQUX6IILLnA5ftddd7kccxYODtd6bRan3h5Yuw2Hh5WXlzskOcrLyz391ACOUkNDg6O4uNjx448/Gsc+++wzx4QJExz9+vVzSHK5Pf7440bbDRs2OM4991zHr3/9a8cTTzzheO+99xzff/+9o66uzhuXAwDAUWlsbDT+z6qoqHAEBQW5/b+vo7fBgwc7pkyZ4oiNjXVccskljq+//tr4nTg5Odkxbtw4x4YNG4znf/nllx0Wi8Xxk5/8xNSvuLg4hyTH559/bhzLyspySHKcdtpppraJiYkOSY7333/fOPb+++87JDmmTJlianvaaac5JDmysrKMYytXrnRIcsTFxZnaXnzxxY6wsDDHa6+9ZhzbtGmT48QTT3RcfPHFprZ/+ctfHNddd53jk08+MY4dPHjQkZ6e7nj66adNbfPy8hzvvfeeY9u2bcax+vp6R1FRkWPXrl0O4Fgdbw6l4gxA5eXl+vrrr132ON66dasaGhr0xBNPGEN4goKCtGnTJkktWzLZbDZjherY2FjTp9wTJ07Ue++955VrAgD0XM3Nzaqrq5OPj48xCqmxsVEbN25UXV2daajrt99+q40bN2rChAnGAkj19fV6+OGHVVtbq4cfftgYgvv6669rxYoVOu+884wRUQ6HQwkJCaqtrdWqVauMOaaPPPKI7r33Xt1www16+OGH9be//c00p/lIxo4dqx07dqi2tlbLli3ThRdeqCFDhujZZ5/V/PnzNWHCBNM0JOf/u5WVlcYxf39/ORwOlwWXBg4caAwbdho6dKhmzJihhIQE0/FLLrlEJ554okaMGGEcmzBhgh5//HGX+bOPPvqoDh06pEmTJhnHpk2bph07drjs4/z3v//d5ZrHjx9vWlHZ6de//rXLsYiICC1atMjluHM15db8/f2NajngLRaHo40xI12koqJCYWFhKi8vV2hoqCefGuiz6uvrtW3bNtMq1cnJycZwoW+++cb0n3drAQEBuvfee3XvvfdKapnD9eWXXyouLk5RUVEMDwKAXqa+vl61tbUKCAgwQmt1dbUKCgrkcDg0ffp0o+3nn3+uoqIinXzyycZKuD/++KMee+wx+fr66pFHHjHaPvHEE/rPf/6ja665RikpKZKkPXv26PTTT1dzc7OKi4uNtjfeeKMyMjL04IMPGsNgS0pKjFDb0NBgLEL029/+Vo899pjuvPNOLV261LgGZ99LS0uNobUPPPCAHnzwQS1cuFBPP/208Xz9+vVTQ0ODCgoKVFZWpg0bNmj58uX68ssvFRAQ4BJcO2LZsmUqKipSTU2N7rzzTmN7xIKCAn388ceKiYnRueeea7T/6quv1NjYqClTphi/I1dXV6uiokJBQUH83gwcp+PNoVScgV6irq5OtbW1xgId27ZtU2pqqgoLC7V9+3Y1Nzeb2vv4+BjBOTY2VgkJCab9jZ1fjxgxwrTYRFBQkGklSABA56mqqlJNTY1CQkJMwc85t7J1Ne7f//63fvjhB51zzjmKjo6W1FK1/Nvf/qZBgwZp8eLFRtt77rlHq1ev1l133aWzzz5bUkul9uKLL9awYcP03//+12h7ySWX6N1339Vzzz2n6667znjc6dOna+jQodq7d6/R9umnn9aKFSv0xBNPGMG5srJS6enpCg4ONgXn9evX67333jMtuOTr66uioiJJ5sWn3O3HGhgYqKFDhyowMNC0eu/48eOVnJxsmg/q7++vm2++WYGBgaZVfs8//3wNHz5ccXFxWrt2rTH/OCkpSdu2bTNtg+NUV1cni8Xicu1HEhERoT/+8Y8ux+Pj490+z4wZM1yOuZvDC8A7CM5AD9LY2KgtW7aYKsfOYdU7duzQb37zGz322GOSpODgYP3nP/8xzg0KCjKtUu38xUlqGfK1fv16j18PAHQnZWVlqqmp0aBBg4xVcvfu3astW7YoPDxcJ5xwgtH2tddeU0lJiS677DJjn9zVq1fr5ZdfVlxcnGlo6nXXXSe73a4nn3zSGAL77rvvav78+Zo2bZppW5aZM2dq7dq1+vDDDzVnzhxJ0tdff62f/vSnmjZtmlavXm20/eMf/6gvv/xSb731lhGcd+/erccff1zjxo0zBee8vDzl5OToiiuuMI45HA5t375djY2NptfBXWgNDg5WVFSUBg8ebGqbmJioQ4cOmbawiYiI0G9+8xuXwHf11Vfr1FNPNYX/8PBwffHFFy6LQj7yyCMuizYFBQW5Da433HCDbrjhBtMxi8Wip556Sk1NTbLb7S7bPX3//fdtLvA1fPhwY4Eu52Jd8fHxampq0rBhwzo0XDsoKMh4/wD0DgRnoJuprq5WcXGxEYxtNpsuvfRSSdKBAwdc5i61tmPHDuPrQYMG6cUXX5TNZlNsbKyGDRvW5/Z3BNAzOBwO7d+/X7W1tYqKijJGuWzdulVFRUUaMWKEUaFzOBx6+umnVVdXpxtvvNEIZx9++KH+8Y9/aMaMGaY9P88991xVVFQoOzvbmM+ZmZmpe+65Rz/72c+MrWikltE3Bw8eVEFBgbFy7dtvv63U1FRddNFF+uc//2m0vfvuu7V9+3adeOKJRnAuLCzUk08+qVmzZpmC86pVq7Rx40YdOHDAONbU1KQ9e/Zo//79ptfCGSBbh9awsDDZbDYNHz7c1Pa0007T4MGDjT1ipZbVmRctWuSy7+odd9yhK664wlTVHDdunFatWuWybdJLL72kV155xZgXLEkxMTGm/2OcFi1a5DJP1Wq16vHHH3dpe9ppp+m0004zHfP393e7veDR7sXqcDi0e/dul62eCgoKTK/l4f08PCAnJCQoIiKizeeZP3++Ecjb4uvrq/nz5xvbFQHoHQjOgBc0NTUZc4Orq6t1yy23GEH5hx9+MLX92c9+ZgTnoUOHasSIERo2bJjLsOrY2Fjjlzep5dP2q6++2nMXBaBHamxs1N69e9XQ0KAxY8YYxzdu3KgdO3YYP2ekliG4zz//vBobG3XHHXcYbV977TV99NFHuuCCC/Szn/1MUstcsp/+9Keqra3Vf//7X+Nn3u9+9zv95S9/0S233KKHHnpIUstQWGfQaz337IUXXtBDDz2km2++WU899ZSklp9tt956q5qamnT55Zcbwfm7775TRkaG6urqTMH566+/Vnl5uSorK43g3NDQoAMHDrgsrhQQECCLxWKazzpo0CCNHz/etLCSJJ133nk6ePCgMT1GkiZNmqR7773XtIWNJKWnp6uqqso0PPeMM87Qt99+azpfapkz7OfnZ1o/YubMmab5v06ttxFyGj16tNLT012Ou5tiExwcbJqv7NTdhwaXlJQY4bh1JbmsrMxt+8DAQMXHx7ts9zR8+PCj/kD5kUce0VdffdXmllS+vr5KTEw0DVEH0DsQnIEuUlFRoeLiYtMex86vZ86cqezsbEkt/6G/9tprqqmpMc61Wq3GL6utP523WCzatWuXx68FQOdpPY+ztrZWu3fvlsViMYXWVatWac+ePUpMTFRUVJSkliG4r776qoKCgnTzzTcbbf/yl79o9erVuv7663XmmWdKaql8XnHFFQoNDVVOTo7R9tprr9WKFSv0pz/9STfddJOklvUQ4uLiFBISooqKCqPtY489phdeeEFLliwx9hg9dOiQbrvtNvn4+Oj22283ruO///2vnn/+eQ0fPtwIzj4+Pvriiy8ktQRjZxhrbGxURUWFDh06ZDxXv379ZLFYFBAQoPr6euP4iBEjNGnSJJfq6bx582SxWEwV0VNPPVUPPPCApk6damr7/PPPy2KxmFYPnjdvns4880yFh4eb2m7fvl2+vr6mMHXJJZfokksu0eFaLyzlNGnSJNNqxE4//elPXY6FhYVpypQpLsfZx/5/nAuSHR6Qd+/e7ba9r6+v4uLiXAKyzWbrtIUsg4OD9cknn+iee+7RsmXLTMO2g4KCNH/+fD3yyCNHXTEH0P0RnIHjUFZWZoRif39/ozLc3NysoUOHtjk8zLkQitTyy+Wjjz4qq9VqVJHbGyYG4Ng0NzfLYrEYoaiyslK7d+9WQECAMT9Ukj7++GOVlJTojDPOMOZzbtmyRW+99ZYiIyN17bXXGm3vvfdeFRUVafHixZo8ebIk6YsvvtAtt9yisWPH6o033jDazpo1S5999pmys7ONcPn111/r7LPP1oQJE1RQUGC0veeee5Sbm6tXXnlFv/zlLyW1BOdFixZp1KhRpuD86aef6h//+IdmzpxpBOfGxkatWrXK5WdJY2OjampqTB/UBQYGyt/f3xRCJWnMmDFKSkoyjWQJCQnRz3/+cwUEBKi5udkII+eff74iIyNNQ2779++v7Oxs4/GdfvOb3+i6664zVkeWWn4ONjU1uVT/UlNTlZqaqsO9+uqrLsdmzpzpdsivu9A7aNAgDRo0yOV460Wk4DkNDQ0qLCx0CcjFxcVqa/OX0aNHm4ZXT5o0SePGjTPNie4qwcHB+vOf/6yHH35Y//nPf1RSUqKIiAjNmTOH4dlAL8b/EMBR+OMf/6iNGzca1eODBw8a902dOtUIzj4+PrLZbDpw4IBpKHXrodWttf4lGOhtHA6HGhoa5O/vbwSjgwcPas+ePQoNDTUtKvTPf/5T1dXVuvDCC41fQL/55hu9//77io+P12WXXWa0XbBggQ4cOKAnnnjCqMq+9dZbuv/++3XmmWcaQ3ullvmZdrtdq1ev1rRp04znuuqqqzRnzhx9+OGHRtubb75Zmzdv1qeffqozzjhDkrRp0ybdc889mjFjhik4f/jhh1qzZo2uvPJKIzjX1NTo22+/dRnG2dzcrKamJtMw4P79+ys4ONhlf9SJEyfq0KFDxhY6kjRkyBBdddVVLoszXXXVVZoxY4ZpS7moqCj961//cql6Pfroo3rooYdMoXXkyJGmKq/T7373O/3ud78zHRswYIBee+01l7Zz5sxxWQjJ19fX+JnY2pAhQ0xh3Ik1GHq/5uZm7dixwyUgb9682e3fQanlQ47DK8gTJ07sFlszDRgwwO0HMwB6J4Iz+jyHw6GDBw+ahlI7b2FhYaaVqZcvX67Nmzebzh82bJji4uKMX5qd8vLyPPLJN9CexsZG1dbWmqogu3fv1t69e40581LLUNp//OMfxvxQZ4j58MMP9fnnn2vmzJk677zzJLXsj/rLX/5StbW1evPNN43Q9+STT+qpp57SL37xC91///2SWv59+fn5qbm52XhOqWVxprvvvlvXXXednnvuOaNvV111lSorK1VUVGT0edWqVXrwwQd12WWXmYLzO++8o7179+r+++83gnNFRYU2btyo0aNHm14H52JTrUNrcHCwrFary3zOadOmafDgwabQOWbMGF1//fUuc1dvu+02HTx40FhISmr5EO399993GQb8+uuvq7m52VQFPvnkk01Dlp3+/Oc/uxwbNWqUli9f7nLcWb1ubcCAAbrwwgtdjh8+5BnoKgcPHtT69etNtw0bNrj9+y61/HtsHY6dXw8ZMoQPVQB0CwRn9AnOFVuLiopUWlqq888/37hv2rRpys/Pd3teWFiYaT7iwoULVV1dbVSPY2Ji2hyWRWju2xwOh2pra9XQ0GCqjBQXF+vAgQOKjo42QmRpaan+/e9/y9fXV7/4xS+Mtm+88Yby8vJ00UUX6dRTT5Uk7dmzRzfeeKP8/Pz01ltvGW0XL16sFStWaNGiRbrxxhslST/88INGjhwpPz8/NTQ0GG0feeQRPf3007rvvvv04IMPSmqZa/vzn/9cknT55Zcb8yw//vhjLV26VLfffrsRnH18fIw5+tXV1UZwLisr0/fff2+af+ich1pbW2sKrWFhYRo8eLBLaD399NNVW1trGjJ7wgknaOHChUpKSjK1ffjhh9XQ0GBaaficc85Rbm6uaZVhSVq5cqV8fX1NFdy25q6+/PLLLscmT56sZ5991uW4cxh1a4MGDdJPfvITl+OEVvRGtbW1KigocAnJe/bscdve399f48ePdwnIo0ePNj7gAoDuiOCMXumtt95SXl6eqXpcWVkpqWV/ydZDrJ2/YEdFRZmGVTvDcWu33HKL5y4Cx6yxsVFVVVVqbm42Vf02bNig0tJSTZw40aj67dq1Sx9++KGsVqtpWOlf//pXFRYW6rrrrjP2bl23bp3uuusuDR8+3BSirrrqKn3yySf6y1/+oosvvlhSS5X05JNPVnR0tLZu3Wq0vf322/X2228rMzNT8+fPl9RSAb7qqqs0aNAgU3B+55139Nprr2n48OFGcK6vr9fbb7/t8sFMSUmJtm7datruxtmmsbHRtJL7oEGDNGLECFNoDQwM1JlnnqnAwEDTEONTTz1VtbW1pkXq/Pz89Ne//lUBAQGmIcZXXnmlzjzzTJfVh7dv365+/fqZPkC46aabjMWpWvv3v//tcuyMM84whky3dv3117scGz58uMuWPRKhFThezc3N2rp1q0tALiwsbHNrpujoaGPBNOdt7NixpjnvANBTEJzRozQ3N2v37t2mQFxUVKSDBw/qk08+MdotW7bMNGdRaql8jRo1SrGxsaqtrTVCxQsvvKDQ0FCXOYY4NnV1daqsrJSvr68ptK5atUqHDh3SSSedZAyBdc4jjYqKMq06+/vf/1779u1TWlqaMf/1o48+0h//+EdNmTJFjz76qNH2rLPOUkFBgbF/qyT961//0ty5c3Xqqadq5cqVRturr75a+fn5ev/9942K4MaNG3XDDTdoypQppuC8YsUKrVy5UjNnzjSCc0VFhd5//32XD1QOHjyoXbt2qby83Djm/Pt1+AJxkZGRio6ONv19s1qtmjNnjsvQ3vPOO0/Dhw9XYmKicWzQoEHKzMx0Cc533nmnrrvuOtN84fDwcB08eFABAQGmSs6DDz5oVJqdAgICTP+GnC644AJdcMEFLsfdhd7o6GjTIltO7uazAui+fvzxR5eAvHHjRlVVVbltHxER4RKQu8s8ZADoLARndDvNzc3atWuXtm3bptNPP904vmDBAr3yyium1WBbKy8vN/bDvPDCCxUTE2NakGvMmDFut/k4fEhnT1ZVVaXy8nL179/fCGFNTU1auXKl6urqNGvWLGMI7KpVq/Tf//5XkyZN0llnnSWpZXjxLbfcotraWj322GPGLz2vv/66nnnmGf3kJz/R4sWLjeeLjY1VSUmJ8vPzjcD0zDPP6LbbbtPPf/5z0yJCF1xwgfbv369169YZ27V88cUXWrhwoc4//3xTcH7xxRe1detWXXnllUYQPHDggHJzc10qGyUlJdq/f7/pFzrn+9x6aLDUEuwqKytN1Y5hw4bppz/9qcuCbb/4xS906qmnaty4ccaxsWPH6oUXXnBZqfixxx7T73//e9N2QgkJCaqoqHD5O/fMM8/ocCNGjHD5oEdqGQZ8+FDg4OBgo1LdmrtF53x8fFihHUCbampq3A6z3rt3r9v2/fr1M/ZDbn07lv2QAaCnITjDq/Ly8rR69WrTwlzFxcVG4KmoqFBISIiklhVaa2pq5Ovrq+joaNMK1XFxcaaA4q4a1tVKS0tVUVEhq9VqBPjq6mp9+eWXam5u1jnnnGO0zc3N1bp16zRz5kyddNJJklrmh951111qbGw0DQP+85//rDfffFPXXHONFixYYLR1Vs5LS0uNIPjAAw/oT3/6k+68804tXbpUUktwdgbjkpISI1C/9957evDBB7Vw4ULjfovFooyMDDU0NOj+++83gvPu3bv1+eefm6qZzscrLS01VVWd70PrObWSNG7cOA0ePNi0l6bNZtPFF19srHLsdPPNN6uystI05Pbkk0/Wq6++6jIM9/XXX1dTU5MptP7kJz9RbW2ty/Y6recEO02ePNnt8GDnPOHWhgwZomuuucbl+Pjx412O+fr6Gn93AcCbmpqaZLfbXQJyUVGRmpub3Z5js9lcAnJcXBxbdnWi/Px82Ww209oLALovfvqhyzQ2NmrHjh0uK1W/8cYbxlDdzMxMZWZmupzr5+cnm82mH3/80QgfaWlpuuOOOzR69GiX+VH79u3Trl27NHToUKN9SUmJvv76awUGBmrWrFlG2+zsbBUVFen8889XQkKCJGnr1q166KGHFBoaalrNdtGiRfr44491zz33GHNXCwoKdPLJJ8tqtWrHjh1G25tuuklvvPGG/vznP+vWW2+VJO3du1dz5sxRUFCQqSL6xhtv6LnnntMjjzxiBOeGhgZlZGRIahlq7vz0ftu2bfr666+N/Vmllk/9nfO06+rqjNfDOSS3dVXW399f8fHxxr6rTpMmTdJll11mGgYstWxBY7FYTIuenX/++YqKijKFU0n6/PPP5efnZzo+f/58zZ8/3xSQnW0Pd/bZZ+vss892OX7HHXe4HBs9erTLSsmSFB8f73LMz8+PX+4A9En79+93O8y6urrabfuBAwcawfiEE04whlmzH/Gxs9vtys7O1oIFC9yG4tzcXKWnpys3N1cZGRnGh+IAujd+s8RRa25uNuZLNjQ06Msvv1R4eLjGjh2r/v3764knntATTzyh7du3u/0ke9GiRVq0aJFGjx6tU045RQUFBTpw4IDGjBmj2267TXFxcYqKitK1116riy++WH/961916qmnKjo6Wjk5OcYqnKtXrzYe89JLL9WXX36p7OxsY57qhg0bdP7552vcuHGmLaSeffZZffjhhxo+fLgRnEtLS/XCCy9oxIgRpuBst9uVl5dnWh3Uz89PlZWVLqt/9u/fX4GBgXI4HMax4OBgnXDCCS57qZ5yyimqq6szhb6QkBD9/ve/NwKuM3hee+21OvPMM01Dhvv376+NGzcqMDDQtMDTQw89pIcfftj0XBaLRRs3bnR5Hy699FK3e6wevm+r1FItbv38Ts7Xr7XDAzMAoPNVV1dr48aNLiF5//79btsHBga6HWY9bNgwhll3soiICKWlpSktLU1Wq1U2m00REREqKSmR3W5XWVmZ5s6dq+LiYtlsNm93F0AHdXlwrqurM80zrKio6Oqn7LWam5vV3NxsqqRt2bJFtbW1io+PN6qO33//vdauXauoqCidfPLJRtulS5eqsrJSt99+uzFc94MPPtALL7ygk046SbfffrvR9uyzz9aePXv09ttvKy4uTrt371Z6erqeeuopjRo1SuPGjVNhYaG2b99uVDe/+eYbnXjiiaqtrTVWEfbx8dGECROMIdWvv/66nn76aV166aUaPXq0rrnmGkVEROiiiy5SWFiY5syZY/ShsLBQ69atU0lJiXHM19dXtbW1LvOcQ0JCXBYhCQ8P17Rp01wWK5ozZ46GDx9u+s9q5MiRWrJkicviTGlpabr22mtNATE6Olrff/+9y+JMzz//vJ5//nnTsaFDh2rt2rU63PXXX++yInBgYKDb0Dp58mSXPaItFovbSiu//ABA79LU1KTi4mK3w6xbf1DrZLFYTMOsnVXk2NhYPtj0EKvVqtmzZys3N1eSNG/ePOP4tGnTXEZ6AfCsw/NoQECA23WQDtflwXnJkiUuq7f2NA6HQ/X19cZ+pFJLpXXz5s2qr6837S2an5+vTZs2aeLEiZoyZYqklsU30tPTVVtbq0ceecT4j+uVV17R3//+d11wwQW69tprJbVsNZOYmKi6ujrl5eUZYfDBBx/UAw88oJtvvllPPfWU8XwTJ05UU1OTfvjhB2Pu5z//+U+lpaXp6quvNgXnP/zhDyovL9eVV15pBES73a4333xT9fX1Ovfcc425xqtWrVJVVZWxhdOLL76ov/zlL5Jahg5v27bNeFyLxaKQkBCjupySkiI/Pz+9/vrrOuWUU/Tkk08abYODg7V3717T1jAJCQn605/+pJEjR5pe98cff1xVVVXG6yi1VGq3bdvmsvfr+++/7/K+TZo0yVSVdmr9AYHTkCFDdNddd7kcnz59usuxfv36uayqDADA8dq3b5/WrVtnCsgFBQVtLoo5ePBgt6tZHz7KCZ6XmJgou92ukpIS5eTkKCcnx9tdAvB/oqKiTN/ff//9euCBB454XpcH58WLF5uCSkVFhUtn29PY2Ggs8uMMrdXV1cbQ29af2n322WfaunWrTjnlFGNY6b59+/TEE0+oX79+phfk8ccf18cff6z58+froosukiTt2LFDs2fPlr+/v2lo6/XXX68XXnhBS5YsMcLVwYMHdcIJJ8hisaipqcmo9L344ot68sknde+99xqBr6mpyfjw4L777jNCn3MLndYLLvn5+RnPXVtbawRnZzX58FWCIyMj1djYqMbGRuNYdHS0Tj/9dI0dO9bU9uqrr1ZDQ4MxB/i9997T8uXLFR4ern/+85/65z//aWr/hz/8wQiIEydOVEJCgkaPHq24uDglJCQYVeTIyEjTsGWbzaY77rjD7TxVdx+iONsfzrm1UGv9+/d3O88VAICeoqqqyu0w6x9//NFt+8DAQCUkJLiE5N60K0RvExMTI6llEdSkpCQlJycTnoFuYufOnaaRqh2pNkseCM5tlb4vueQSPfDAAzr11FMltWyNc/nll2vUqFH69NNPjXbnnXeecnJy9PLLL+uKK66Q1BI4p0+frlGjRmn79u1G2yeeeEL/+Mc/9Le//c0IzqWlpcYQ3NbB+dtvv9W7775rWnDJx8dHhYWFLivxutuPNTAwUEOGDFFAQIAaGxuNYDt+/HjNmjXLNDw4MDBQCxcuVGBgoGko7YUXXqhRo0YZe8Q6+/Dxxx8rICDAtKDELbfcogULFrh8irxz507T9zU1NRo/frxuvfVWFRYWav78+caiXLt27dK7776ryMhISS0fYqxatco4NyQkxLRS9YUXXmiE7Isuusj4gAEAABxZY2OjioqKXAKy3W5vc5h1bGysS0COiYlhmHUP5JzfTHgGupfQ0NBj2mfea4uDffTRR6a9SJubm7V161aXOZrO0N06tAYHB2vEiBGm4b6SlJSUpNraWtOQ30GDBunWW2912Rbmuuuu01lnnaUTTzzRODZkyBCtXLnSJegvXbpUS5YsMQ0Ptlqt2rdvn8t13XTTTS5bIfn5+enpp592aXvyySebhlI7ObcGam3AgAHGCpeVlZUqLi42hlWff/75xr64f//7340PGNxxzj2WpFNPPVXLly83gvLgwYOZIwsAwFFyOBzau3evKRyvW7dOBQUFLiPFnIYMGWLMP3be4uPjXaYioWcqLi5WRESEJBGegV7C4nD3kWcXqqioUFhYmDIyMjRnzhyjMnvo0CFt3LhRAwYM0MSJE432VVVVslgsCgwMdFnFuDdzOBxGiF2/fr0ef/xxIygfHtiffPJJ/epXv5LUskDXueee67LHsfPrgQMHEo4BADhGhw4d0oYNG1yqyM4tAg8XFBSkiRMnulSRhwwZ4uGew5OSk5OVnJysRYsWGcfKysqUlJQkm81GeAa8wJlDy8vLj6ni7LXgfKwd7k1KS0uNYdSH73X84IMPauHChZKkr7/+2mW+76BBg4xA/Itf/EI/+clPJJkDNwAAODZNTU2y2+1at26dsWDXunXrVFxc7La9j4+P4uLiXAKyzWbrUx/8oyUgh4eHu91uivAMeM/x5lD2ce5CDodDJSUlRigeP368pk2bJkn66quvNHPmzDbPLSoqMr4eP368HnroIaN6HBMTY5r/3BqhGQCAo1NSUmIEY+dtw4YNqq6udtt+2LBhpnB8wgknaMKECerfv7+He47uKC0tTYmJiW73aLZarQzbBnooKs6daP/+/XrqqadMFeSysjLj/jvvvFNLly6VJO3du1eRkZGKjIx0GU7t/N45pxkAABy/hoYGbdmyxRSQ161bpx9++MFte+dq1s65yM4/Bw8e7OGeoyexWCzKy8trd79mZ+XZGaQBdD0qzh7gcDi0b98+01Bq5+2iiy7S7373O0ktq2c+9NBDLuePGDFCsbGxppW2hw4dqsrKSsIxAACdzLlYV+tw7NwTuaGhwe050dHROuGEE0y32NhYVrPGUetITap15TkpKYnwDPQABOf/43A4tGfPHhUVFSk4OFhJSUmSWvaBjo2N1aFDh9ye1zoMR0ZGauHChRozZoxRQbbZbG5XyLRYLIRmAACOU01NjbEncuugfODAAbftQ0JCXAJyQkJCrxsFh+6P8Az0LH1yqHZ9fb2WL19uWpiruLjYmMuUkpKiN998U1LLNlnBwcGqr6/XqFGjXFaqjo+PV2xsrFeuAwCAvsLhcGj79u0uw6wLCwvV3Nzs0t7Hx0djx441wrFzqPXo0aNZDwTdCsO2Ac9gqPZhmpubtWvXLtMq1YWFhRo3bpzS09MlSb6+vvrVr36l+vp607k+Pj6Kjo42bRHh4+OjgoICDR8+3GV/ZwAA0PkqKipcKsjr169XZWWl2/aDBg1yqSLHx8ezWBd6BGdgnjVrFpVnoBvrkcG5qalJO3bsUFVVlRISEiS1fBI9depUbd68WXV1dS7nOFezllqC89VXX63AwEDTglzR0dHq16+fy7ljxozpuosBAKCPampqUmFhoWm7p3Xr1mnbtm1u2/v7+ys+Pt4lJA8dOpQqMno0q9Wqjz76yAjPH330UZs7qADwjm4fnHNzc7V582ZT9Xjr1q1qaGjQiSeeqG+++UZSy5zh6upq1dXVyd/fXzabzTSsOj4+3vS4mZmZ3rgcAAD6pB9//NGlirxx40bV1ta6bT9y5EiXYdbjxo2Tv7+/h3sOeEbr8Dxr1izCM9DNeHWOc//+/bV161ZTKPb399fjjz9utI+JiZHdbnd5nICAAE2bNk1ffPGFcSw/P1/h4eGKioqSn1+3/0wAAIBep66uTps3b3aZi7x371637YOCgowtn1oH5YiICA/3HOg+nIvUEp6BznO8c5y9Fpyjo6O1c+dONTU1me4fPHiw9u/fb3y/cOFC7d2712VRrhEjRrBFBAAAXuJwOPTDDz+Y5iCvW7dOmzdvVmNjo9tzYmJiXIZZ22w2+fj4eLj3QPeXlJSksrIy5eXlEZ6BTtBjg7NTUFCQaZ5xbGysbrjhBuYqAQDQTVRVVWnjxo0uVeTS0lK37a1Wq8sw64SEBLZhBI4S4RnoPD12Ve333ntPkydPVmRkJCEZAIBuoLm5Wdu2bdPatWtNAbm4uFjuPmf39fXVuHHjXKrII0eO5P92oBMcvs8z4Rnwnj65jzMAAH3doUOHtH79eiMkr127tt0tn4YOHeoSkMePH6/AwEAP9xzoe5KTk2W32wnPwHHosRVnAADQ9RwOh7Zv3661a9cat/aqyP369dPEiRN1wgknaPLkyZo0aZImTZqkoUOHeqH3ACQpJydHycnJVJ4BLyI4AwDQS1RVVWnDhg2mKvK6detUUVHhtn1kZKQmT55shOTJkydr7NixbPkEdEOEZ8C7CM4AAPQwDodDO3bsMMKxMyAXFha6rSL7+/srPj7eCMfOoDx48GAv9B7AsSI8A95DcAYAoBurqalxW0UuKytz237o0KEuVeTx48dTRQZ6CcIz4B0sDgYAQDfgcDi0a9cuUxV57dq1KiwsVHNzs0t7Pz8/TZgwwQjHzrDMXGSgb0hOTpbNZlNGRoa3uwL0CCwOBgBAD1NbW6uNGzeahlmvXbu2zX2RBw8e7DLMesKECerXr5+Hew6gu8jJyfF2F4A+heAMAEAXcTgc2r17t0sV+fvvv1dTU5NLe19fX02YMME0zHry5MkaOnQo+yIDAOBFBGcAADpBXV2dCgoKXKrIBw8edNt+4MCBLsOs4+PjFRAQ4OGeAwCAIyE4AwBwFBwOh/bu3WsKx2vXrtXmzZvbrCKPGzfOZcGuyMhIqsgAAPQQBGcAANpQX1+vTZs2mYZZr1u3Tj/++KPb9uHh4S5V5IkTJyowMNDDPQcAAJ2J4AwAgKR9+/a5VJE3bdqkxsZGl7Y+Pj4aO3asSxV5xIgRVJEBdAuZmZmSpAULFpiOL126VDabTXPnzvVGt4Aei+AMAOhTGhsbVVhYqO+++07fffed1q5dq++++0779u1z295qtbos1hUfH6+goCAP9xwAOm7BggXKzMxUUlKS0tPTVVZWpiVLlig9PV2zZ8/2dveAHod9nAEAvVZlZaXWrVtnCsnr169XbW2tS1uLxaK4uDiXbZ+ioqKoIgPosex2u5KTk2W1WvXRRx/JarV6u0uAV7CPMwCgz3M4HNq5c6dRPXb+WVxc7LZ9cHCwEZCnTJmiyZMnKyEhQcHBwR7uOQB0LZvN1ubPQgAdR3AGAPQo9fX1xrZPrUNyaWmp2/YjR440ArIzJMfExMjHx8fDPQcAAD0VwRkA0G2VlJQYwdgZkgsKCtTQ0ODS1s/PT/Hx8S4heeDAgV7oOQAA6E0IzgAAr2tubpbdbncJyTt37nTb3mq1GsHYGZInTJiggIAAD/ccALwnOztbOTk5WrNmjebNm6dFixZJapnXnJ6eLqnlA0i73a7FixcbK2k7FworKyuTJJfzAbgiOAMAPKq6ulobNmwwDbVeu3atDh065La9zWYzheTJkydr1KhRLNgFoE+z2+3KyclRRkaGcnNzlZycrMTERNntduXl5SkjI8Nou3TpUqWkpCgnJ0cRERFasmSJli1bZiwUlp+fr6SkJEkiPANtIDgDALrM3r17TfOQ165dqy1btqi5udmlbUBAgCZNmmSqIp9wwgnswAAAbqSnpystLc10LDU1VXPnzjWFZknG9lPp6emyWq3Kysoy3Z+YmChJysjIIDgDbSA4AwCOW2Njo77//nuXodZt7Y08ePBgTZ061RSSx44dKz8//lsCgI6w2+2y2WySWirGUssIHecQ7dZKSkoktQzJ3rp1q+c6CfQi/IYCADgqFRUVWrdunSkkb9iwoc29kceNG+eyYNewYcMYag0Ax6isrEypqanG9zk5OZLkNjRL/wvWixcvdruPc+vgDcA9gjMAwC3n3siHD7Xu6N7IU6ZMUUJCgoKCgjzccwDo3axWq7HQlyTl5ubKarUaQ64P5wzWziHbh8vNzZUkpaSkdHJPgd6D4AwAUENDgzZt2qRvv/3WNNS6vb2RD1+wi72RAcDznKG3rVDsbNNesF6xYoUk6bLLLuv8DgK9BMEZAPqYyspKrVu3Tt9++60RlDds2KD6+nqXtuyNDADdm7OanJyc7PZ+5zDstoK13W5Xfn6+EhMT3Q7jBtCC4AwAvZhzVWtnQP72229VVFQkh8Ph0jYsLMwIxlOnTmVvZADoAY5UcXZWk9sK1s4VuFvPmc7OzjYNBQcgWRzufnvqQhUVFQoLC1N5eTlbjABAJ2lublZxcbERjp1Bee/evW7bjxgxwgjHzj/HjBnDgl0A0MNYLBZZrdY2p9YkJSUpPz9fxcXFbhf/iomJkd1uN32gmpycbFSygd7ieHMoFWcA6GHq6uq0ceNGUyV57dq1qqysdGnrXNX68JA8ePBgL/QcANCZsrOzJbU/Nzk/P182m81taC4rK5PdbjdVq7Ozs1kkDHCD4AwA3Vh5ebmxWJezklxQUKDGxkaXtoGBgZo0aZIpJE+aNEnBwcFe6DkAoKsdaX7zkYZxO+c0O0O13W5XTk6OMXwbwP8QnAGgG3A4HNq9e7dpLvJ3330nu93utn14eLimTp1qCsnjxo2Tnx8/1gGgr7BarbLZbO3OR7bZbEpLS2vz/pycHKWlpRlznAnNgHvMcQYAD2tqalJhYaFLSP7xxx/dth89erRpmPXUqVMVFRXFfGQAAIAOYo4zAHRjNTU12rBhgykkr1u3TtXV1S5tfX19NWHCBCMcT506VZMnT1ZERIQXeg4AAAAngjMAdJKSkhKXrZ82b96spqYml7ZBQUHG3sjOkDxx4kT179/fCz0HAABAewjOAHCUHA6HduzY4RKSd+zY4bb94MGDXeYjx8bGytfX18M9BwAAwLEgOANAO5qamvT9998rPz9f+fn5xgrXJSUlbtvHxMS4zEeOjIxkPjIAAEAPRnAGgP9TX1+vjRs3GiH522+/1dq1a93OR/b399fEiRNNIXny5MkKCwvzQs8BAADQlQjOAPqkqqoqrVu3zhSSN2zYoIaGBpe2wcHBRkBOTEzUlClTFB8fr4CAAC/0HAAAAJ5GcAbQ65WWluq7774zheQtW7aoubnZpW14eLgSExOVmJhoBGXmIwMAAPRtBGcAvcrevXv17bffmkLy1q1b3baNjIw0BeTExESNGjWK+cgAAAAwITgD6JEcDoe2b9/uEpL37Nnjtv2YMWNMIXnq1KkaNmyYh3sNAACAnojgDKDba2pqUmFhoRGSnX+Wlpa6tLVYLBo/frypijxlyhSFh4d7oecAAADoDQjOALqV+vp6FRQUmELyd999p6qqKpe2/v7+SkhIMIXkE044QcHBwV7oOQAAAHorgjMAr6murta6detMIXn9+vWqr693adu/f3/TytZTp07VxIkTWdkaAAAAXY7gDMAjysrK9N1335nmJG/evNntytZhYWGmKvLUqVM1btw4VrYGAACAVxCcAXS6kpIS5efnKy8vT3l5ecrPz1dxcbHbtkOGDHHZ/mnMmDGsbA0AAIBug+AM4LgcOHDACMfOoLxt2za3bUeNGuUSkiMjIwnJAAAA6NYIzgA6bP/+/S4heceOHW7b2mw2JSUlKSkpyQjLAwcO9HCPAQAAgONHcAbg1t69e01DrfPy8rRr1y63bWNjY42QnJSUpKlTp7L9EwAAAHoNgjMA7d692yUk796926WdxWLR2LFjlZiYaArJYWFhXug1AAAA4BkEZ6APcTgc+uGHH1yGW+/du9elrcVi0fjx442h1klJSZoyZYpCQ0O90HMAAADAewjOQC/lcDi0c+dOl0ry/v37Xdr6+PhowoQJLiF5wIABXug5AAAA0L0QnIFewOFwaPv27S4h+cCBAy5tfX19FR8fb1q4a/LkyQoODvZCzwEAAIDuj+AM9EC7d+/W6tWrtWbNGuPPgwcPurTz8/PTxIkTXUJy//79vdBrAAAAoGfq8uBcV1enuro64/uKioqufkqgV/nxxx+1Zs0aU0jes2ePSzt/f38lJCSYVreeNGmSAgMDvdBrAAAAoPs5PI8GBAQoICDgiOd1eXBesmSJHnzwwa5+GqBXKCsrU15enikkb9++3aWdj4+PJk6cqGnTpmn69OmaNm2aTjjhhA79owcAAAD6qqioKNP3999/vx544IEjnmdxOByOLuqTJPcV56ioKJWXl7M6L/q0Q4cO6dtvvzWF5MLCQrdtx40bZwrJU6ZMYU4yAAAA0EEVFRUKCwvTzp07TTm021ScO9oRoDerra3V2rVrjYC8Zs0abdq0Sc3NzS5tx4wZYwTkadOmKTExkX2SAQAAgE4QGhp6TAVcFgcDOllzc7M2bdqkb775Rt98841Wr16t9evXq7Gx0aXtiBEjjJA8ffp0JSUlaeDAgV7oNQAAAIC2EJyB47R3714jJDuDcmVlpUu7wYMHu4TkyMhIL/QYAAAAwNEgOANHobq6Wnl5efrmm2+0atUqffPNN9qxY4dLu6CgIE2bNk0nnXSSTjrpJE2fPl1RUVGyWCxe6DUAAACA40FwBtrQ3NyszZs3m6rJ69evV1NTk6mdxWLRxIkTjZB84oknauLEifLz458XAAAA0Bvwmz3wfyorK7Vq1Sp9+eWX+vLLL/Xf//7X7b7jkZGRRkg+6aSTNG3aNIWEhHihxwAAAAA8geCMPmvHjh366quvjKC8du1al1Wug4KClJSUZArKI0eOZMg1AAAA0IcQnNEnNDY2au3atfryyy+NsLxr1y6XdqNGjdLMmTM1c+ZMzZgxQ5MmTWLINQAAANDHkQjQK9XX12vNmjX69NNP9dlnn+nLL79UVVWVqY2vr6+mTJliCsojR470Uo8BAAAAdFcEZ/QK9fX1WrVqlT777DN9+umn+uqrr1RdXW1qExYWphkzZmjGjBmaOXOmTjzxRAUHB3upxwAAAAB6CoIzeqTGxkatXr1aH330kRGUa2pqTG0GDRqkM844w7glJCTIx8fHSz0GAAAA0FMRnNFjbN26Vf/5z3/0n//8Rx999JHKy8tN9w8ePFhnnHGGzjzzTJ1xxhmKj48nKAMAAAA4bgRndFuVlZX65JNP9OGHH+o///mPioqKTPeHh4dr1qxZOuuss3TmmWdqwoQJrHYNAAAAoNMRnNGtbN++Xe+8847eeecdffLJJ2poaDDu8/Pz0ymnnKI5c+Zozpw5SkpKkq+vrxd7CwAAAKAvIDjDqxwOh9asWaO3335b77zzjtauXWu6PzY2Vuecc47mzJmjM888U6GhoV7qKQAAAIC+iuAMj3M4HPr222/1xhtv6M0339T27duN+3x8fDRz5kxdeOGFuuCCCzRu3Dgv9hQAAAAACM7woIKCAr3++ut64403TPOVg4ODde655+qCCy7Qeeedp0GDBnmxlwAAAABgRnBGl6qoqNAbb7yh5557TqtWrTKOBwYG6vzzz9fll1+u8847T/379/diLwEAAACgbQRndIn//ve/ysjI0Jtvvqnq6mpJLYt7nXvuubr88st1wQUXKCQkxMu9BAAAAIAjIzij0zQ0NOitt97Sn//8Z33zzTfG8fHjx+v666/XlVdeqaFDh3qxhwAAAABw9AjOOG41NTXKyMjQY489pl27dkmS+vXrp5///OdasGCBTjnlFPZXBgAAANBjEZxxzKqrq5WRkaGlS5dq7969kqShQ4fqpptu0o033qghQ4Z4uYcAAAAAcPwIzjhqTU1NevHFF3XvvfcagTk6Olp33323rrrqKgUEBHi5hwAAAADQeQjOOCpffPGFbr31VuXn50tqCcz33nuvrrrqKvn7+3u5dwAAAADQ+QjO6JADBw7otttu06uvvipJCg0N1QMPPKCbb75Z/fr183LvAAAAAKDrEJxxRH//+9+1cOFC7d+/XxaLRfPnz9dDDz3EHGYAAAAAfQLBGW06dOiQFi5cqFdeeUWSNHHiRL3wwguaPn26l3sGAAAAAJ7j4+0OoHsqKCjQiSeeqFdeeUW+vr66++67lZeXR2gGAAAA0OdQcYaLrKwsXXPNNaqurtbw4cP1xhtv6LTTTvN2twAAAADAK6g4w+BwOPSnP/1Jl112maqrqzVr1ix9++23hGYAAAAAfRrBGZJa9ma+5ZZbdOedd0qSfv3rX+vDDz9kATAAAAAAfR5DtaGmpiZde+21evnll2WxWPTYY4/ptttuk8Vi8XbXAAAAAMDrCM59XFNTk6677jq9/PLL8vX11auvvqp58+Z5u1sAAAAA0G0QnPuw5uZm3XDDDXrppZfk6+urN954Q3PnzvV2twAAAACgW2GOcx92991368UXX5Svr69ef/11QjMAAAAAuEFw7qOWLVum9PR0SdJzzz2nlJQUL/cIAAAAALongnMf9OGHH2rhwoWSpPvuu09XX321l3sEAAAAAN0XwbmPKS4u1mWXXaampiZdeeWVeuCBB7zdJQAAAADo1gjOfUhtba1SUlJUUVGhU045RcuWLWPLKQAAAAA4AoJzH/Kb3/xG3377rQYOHKg333xTAQEB3u4SAAAAAHR7BOc+4vXXX9czzzwji8WiV199VSNHjvR2lwAAAACgRyA49wG7du0yFgO79957dc4553i5RwAAAADQcxCcezmHw6H58+ervLxcJ510ku677z5vdwkAAAAAehSCcy/3/PPP64MPPlBAQIBefPFF+fn5ebtLAAAAANCjEJx7sR07dug3v/mNJOmRRx7R+PHjvdwjAAAAAOh5CM692K9+9StVVlZqxowZuu2227zdHQAAAADokQjOvdQ777yjd955R/7+/nr22Wfl6+vr7S51WH5+vsrKyrzdDRfdtV8AAAAAuhbBuReqqanRLbfcIkm6/fbbNWHCBC/3qONyc3OVm5srq9Xq7a64SExM1Pz58wnPAAAAQB9DcO6F/vjHP2rbtm0aOXKk7r33Xm93p8PsdrsyMjK0aNEib3elTcuWLVNKSoq3uwEAAADAgwjOvUxxcbHS09MlSX/+8581YMAAL/eo41JSUrRs2TJvd6NdVqtVqampSk1N9XZXAAAAAHgIwbmXueuuu1RXV6fk5GRdcskl3u5Oh6WlpWnevHndcoj24ebOnas1a9YoPz/f210BAAAA4AEWh8Ph8OQTVlRUKCwsTOXl5QoNDfXkU/d6X3/9tWbMmCEfHx+tXbtWCQkJ3u5Sh5SVlWnMmDEqLS31dlc6LDc3V2lpacrLy/N2VwAAAAAcwfHmUCrOvYTD4dBvf/tbSdK1117bY0KzJC1ZskQLFizwdjeOyuzZs1VWVkbVGQAAAOgDCM69xD/+8Q999dVX6t+/vx588EFvd+eoZGZmat68ed7uxlGbO3euMjIyvN0NAAAAAF2M4NwLNDQ06K677pIk3XHHHRoxYoSXe9Rxubm5klq2eupp5s2bp8zMTG93AwAAAEAXIzj3Ai+99JIKCws1ePDgbr2Vkzs5OTmaPXu2t7txTJxhn+HaAAAAQO/m5+0O4Pg0NDTo4YcfltSyonZISIiXeyRlZ2drxYoVioiIkNVqVVlZmVJTU91WlXNzczs0TDs7O1s5OTlas2aN5s2bZ3xAYLfbje23SkpKZLfbtXjxYs2dO1dSy8JjS5YsUVlZmSS5nH+8EhMTlZub2yMr5gAAAAA6huDcwy1fvlzbtm3T0KFDdeONN3q7O0pNTdWaNWv00UcfmbaWWrp0qex2uxFonex2u2w2W7uPabfblZOTo4yMDOXm5io5OVmJiYmy2+3Ky8szzTNeunSpUlJSlJOTo4iICC1ZskTLli0z+pKfn6+kpCRJ6pTwbLPZtHr16uN+HAAAAADdF0O1e7D6+nqj2pyWlqagoCCv9ictLU2ZmZkuoVlqCakrVqxwOaesrOyIwTk9PV1paWmmY6mpqSouLnZZnMs57Ds9PV1LlixRVlaWqS/OynBnLepls9lkt9s75bEAAAAAdE9UnHuw5cuXa/v27Ro2bJjXq812u11Lly7VokWLXEKzJCUnJys3N1e5ublGuHUOn3bX/vDHdoZr53xim81mDNFuraSkRFLLkOytW7ce49V03MCBAwnOAAAAQC9HxbmHal1tvuuuu9S/f3+v9scZYtuar5yYmCir1WqqLjsDZ0RERJuP65wf7ZSTk2N6vsM5g/XixYvdBvLWwbszHCn0AwAAAOj5CM491IsvvqgdO3YoMjJSCxYs8HZ3tGbNGkltB9L09HSVlpaa7ndWh9tjtVpN86Jzc3NltVrbXIzLGazbWqnbuf1VSkpKu88bExPTodWyIyIijMo5AAAAgN6J4NwDNTQ06A9/+IOk7lFtlv5XyT2aCmx7lWZ3nKG3ve2rjhSsnfOsL7vssnYfoyOLlkkt4Z+qMwAAANC7EZx7oDfffFPbt2/XkCFDNH/+fG93R9LxDX3uSOVZ+l81OTk52e39zvDeVrC22+3Kz883ho239zxHauPUkcXNAAAAAPRsBOcexuFwaOnSpZKkW265pVtUm6X/rVbdkeHNTs7A2dGhzkeqODuryW0Fa+dK2q3nTGdnZ7t9nvaq2q0dPHjwqCvnAAAAAHoWgnMP8+GHH2rdunUaMGCAbrrpJm93x+BcFMwZbtvSOqg6K7odXZU6Pz/fZYGx1o4UrJ3P3XpOuDNM5+bmKjU1VSkpKcrPz1d+fr5SU1ONDyna0tEh3QAAAAB6Lraj6mGcq0kvWLBA4eHhXu7N/8ydO1ezZ8/WkiVLtGjRIrdtMjMzNW3aNNOxxMTEDgVnZ+htb25yfn6+bDab2yBbVlYmu91uCtXZ2dnGImGzZ8/W7NmzlZ2drezsbGNY+JHY7XZNnz69Q20BAAAA9ExUnHuQVatW6dNPP5Wfn59uu+02b3fHRVZWlqZNm6bk5GSX4dfOavDhi3bNnj1bq1evPuJjH2l+85Gqzc7qtjNU2+125eTkuKxI7pzf3FH5+fkdHtYNAAAAoGfq8opzXV2d6urqjO8rKiq6+il7Leew4V/+8peKiorycm9cWa1W5eTkKDMzU/Pnz1dERIQRWJOTk91um5WcnHzEraGcj22z2UxbUx3OZrMpLS2tzftzcnKUlpZmzHF2DtNuLTc3t93naM05n/togjYAAAAA7zk8jwYEBCggIOCI51kcDoejqzolSQ888IAefPBBl+Pl5eUKDQ3tyqfuVb7//nuNHz9eDodDGzZs0MSJE73dpU4THh6uvLw8r88VLisrU3h4uHJycjpURV66dKmKi4vdBnAAAAAA3UdFRYXCwsJcjt9///164IEHjnh+lwdndxXnqKgogvNRuvHGG5WRkaHzzz9f77zzjre706mcVWLn/G1vcc55bv1PoqysrM1tqWJiYpSVlUXFGQAAAOjmnMF5586dphza0Ypzl89xDggIUGhoqOmGo1NSUqKXXnpJkvTb3/7Wy73pfKmpqcrMzPR2N1wqzdnZ2W3uMe1c4ZvQDAAAAPQch2fTjoRmicXBeoRnn31WNTU1mjx5sk4//XRvd6fT2Ww2LViwoFuE59Z7S7e31VRaWpqWLVvmya4BAAAA8BKCczfX2Niop556SpJ06623ymKxeLlHXWPx4sXKyMhwWY3bk9LS0mS325WZmak333yzzW21cnNzqTYDAAAAfUiXz3E+nHNsOXOcO8Y573bw4MHasWOHAgMDvd2lLpOfn68lS5YoKyvL211pU1lZmVJSUjq8zzMAAAAA7zveHErFuZt74oknJLXMA+7NoVlq2dZp3rx5xrZb3VFaWhqraAMAAAB9DBXnbiw/P19JSUny8/PT9u3bNXz4cG93ySNyc3M1bdq0Nlez9pb8/HzZbLZu1y8AAAAA7TveHOrXBX1CJ3FWm1NSUvpMaJbUoT2UvYE5zQAAAEDfxFDtbmrfvn164403JLUsCgYAAAAA8A6Cczf1zDPPqL6+XieddJJOOukkb3cHAAAAAPosgnM3VF9fr7/97W+SqDYDAAAAgLcRnLuht956S/v27dPw4cM1d+5cb3cHAAAAAPo0gnM35Kw2L1iwQP7+/l7uDQAAAAD0bQTnbmbjxo1auXKlfH19dcMNN3i7OwAAAADQ5xGcu5mMjAxJ0oUXXqgRI0Z4uTcAAAAAAIJzN1JVVaXly5dLkhYuXOjl3gAAAAAAJIJzt/LGG2+ooqJCMTExmjVrlre7AwAAAAAQwblbcS4KlpqaKh8f3hoAAAAA6A5IZ93EmjVrlJeXp379+unaa6/1dncAAAAAAP+H4NxNPPPMM5KklJQUDRo0yMu9AQAAAAA4EZy7gbKyMr322muSWBQMAAAAALobgnM38PLLL6umpkYJCQmaMWOGt7sDAAAAAGiF4OxlDofDWBRs4cKFslgsXu4RAAAAAKA1grOXrVy5Ups2bVJwcLCuuOIKb3cHAAAAAHAYgrOXORcF++Uvf6nQ0FAv9wYAAAAAcDiCsxcdPHhQb731lqSWvZsBAAAAAN0PwdmLXn31VdXX12vq1KlKTEz0dncAAAAAAG4QnL3E4XDo2WeflSRdf/31Xu4NAAAAAKAtBGcvWbNmjdavX6/AwED94he/8HZ3AAAAAABtIDh7yXPPPSdJuvTSSxUeHu7l3gAAAAAA2kJw9oLq6mq9/vrrkhimDQAAAADdHcHZC7Kzs1VRUSGbzaYzzjjD290BAAAAALSD4OwFzkXBrrvuOvn48BYAAAAAQHdGavOw77//XitXrpSPj4+uueYab3cHAAAAAHAEBGcPe/755yVJ5557rkaMGOHl3gAAAAAAjoTg7EGNjY1avny5JBYFAwAAAICeguDsQe+995727t2rIUOG6Pzzz/d2dwAAAAAAHUBw9iDnomBXXXWV/P39vdwbAAAAAEBHEJw9ZM+ePXrvvfckMUwbAAAAAHoSgrOHLF++XE1NTZo5c6bGjx/v7e4AAAAAADqI4OwBDofDWE2bajMAAAAA9CwEZw9YuXKlCgsLNWDAAKWkpHi7OwAAAACAo0Bw9oDnnntOknT55ZdrwIABXu4NAAAAAOBoEJy7WHl5ubKysiQxTBsAAAAAeiKCcxdbsWKFampqFB8fr5NOOsnb3QEAAAAAHCWCcxdbvny5JOnaa6+VxWLxcm8AAAAAAEeL4NyFCgsL9dVXX8nHx0e//OUvvd0dAAAAAMAxIDh3IWe1+ZxzzlFkZKSXewMAAAAAOBYE5y7S3Nysl19+WZJ0zTXXeLczAAAAAIBjRnDuIp9++ql27Nghq9WqCy+80NvdAQAAAAAcI4JzF3nxxRclSfPmzVNgYKB3OwMAAAAAOGYE5y5QWVmpt956SxLDtAEAAACgpyM4d4G33npL1dXVGjt2LHs3AwAAAEAPR3DuAs5h2ldffTV7NwMAAABAD0dw7mRbt27VZ599JovFoiuvvNLb3QEAAAAAHCeCcydzbkE1a9YsRUVFebk3AAAAAIDjRXDuRA6HQ8uXL5fUMkwbAAAAANDzEZw70RdffCG73a6QkBBdfPHF3u4OAAAAAKATEJw7kbPanJKSouDgYC/3BgAAAADQGQjOnaS6ulpvvvmmJIZpAwAAAEBvQnDuJP/4xz9UWVkpm82mU0891dvdAQAAAAB0EoJzJ3EO077qqqvk48PLCgAAAAC9BQmvE+zatUu5ubmSWoIzAAAAAKD3IDh3gpdfflkOh0NnnHGGxowZ4+3uAAAAAAA6EcH5OLF3MwAAAAD0bgTn47Rq1Sr9//bu77fq+v4D+PNYsMLWH5CZbizV2TCzLY5sbGo0cYFQ3PwyFeRXW7bLzftdzHiluyL6HxAvp9DSThHmZAKLDrMluDUx7ELXrJuQGVxIacuUFaTne+FOBYelCOVzfjweSS8Op5/zecKbm2fer/P+vP3221m8eHE2bdpUdBwAAACuMcX5KlV2mzdu3JiWlpaC0wAAAHCtKc5XYWpqKv39/UkcCgYAAFCvFOer8PLLL+fUqVNZtmxZVq9eXXQcAAAA5oHifBV++ctfJkm2bduWpqamgtMAAAAwHxbM9w2mpqYyNTU183pycnK+b3ldnDp1Kr/+9a+TJD/60Y8KTgMAAMDlfLKPNjc3p7m5+bLXzfuO8/bt29PW1jbz09nZOd+3vC52796ds2fPZsWKFVmxYkXRcQAAALiMzs7Oi/rp9u3b53TdvO84P/744/nZz34283pycrIuyvOzzz6bJPnxj39ccBIAAADm4vjx42ltbZ15PZfd5uQ6FOe5bn3Xkr///e95/fXXUyqV0tfXV3QcAAAA5qC1tfWi4jxXDgf7DCq7zWvWrMmyZcsKTgMAAMB8UpyvULlcnjlN25g2AABA/VOcr9CRI0cyMjKSxYsX55FHHik6DgAAAPNMcb5ClTHtDRs25POf/3zBaQAAAJhvivMVOHfuXPr7+5N4djMAAECjUJyvwP79+3Py5Ml0dHSku7u76DgAAABcB4rzFagcCtbX15cFC+b9SV4AAABUAcV5jiYmJrJ3794kTtMGAABoJIrzHA0NDWVqairf+MY38q1vfavoOAAAAFwnivMcXfjs5lKpVHAaAAAArhfFeQ7eeeedvPbaaymVStm2bVvRcQAAALiOFOc5eO6555Ikq1atSmdnZ8FpAAAAuJ4U58sol8sXjWkDAADQWBTnyxgeHs5bb72Vm266KRs3biw6DgAAANeZ4nwZld3mhx9+OK2trQWnAQAA4HpTnGfx4YcfZteuXUmMaQMAADQqxXkWr7zySv71r3/l5ptvzv333190HAAAAAqgOM/i2WefTZL09PRk4cKFBacBAACgCIrzpzh9+nT27NmTxJg2AABAI1OcP8WePXty5syZ3H777fnud79bdBwAAAAKojh/iueeey5Jsm3btpRKpYLTAAAAUBTF+RLee++9HDhwIEnS19dXcBoAAACKpDhfwsDAQKanp3PXXXdl+fLlRccBAACgQIrzJVw4pg0AAEBjU5w/YWRkJEeOHElTU1O2bt1adBwAAAAKpjh/ws6dO5Mk3d3d6ejoKDgNAAAARVOcL1Aul41pAwAAcBHF+QJ/+tOfMjIykkWLFmX9+vVFxwEAAKAKKM4XqIxpP/TQQ2lpaSk4DQAAANVAcf6v8+fPp7+/P4kxbQAAAD6mOP/X7373u5w4cSJLly7N97///aLjAAAAUCUU5/+qHAq2ZcuW3HjjjQWnAQAAoFoozknOnDmT559/PokxbQAAAC6mOCfZt29fTp8+nVtvvTX33ntv0XEAAACoIopzPh7T7uvryw03+CcBAADgYw3fEsfGxvLyyy8n+ag4AwAAwIUavjgPDQ3l3LlzWbFiRe64446i4wAAAFBlGr44V8a0HQoGAADApTR0cT527Fh+//vfp1Qqpbe3t+g4AAAAVKGGLs67du1Kknzve99LZ2dnwWkAAACoRg1dnI1pAwAAcDkNW5yPHj2ao0ePZuHChdm0aVPRcQAAAKhSDVucK7vN//d//5clS5YUnAYAAIBq1ZDFeXp6Ojt37kxiTBsAAIDZNWRxfv3113P8+PG0tLTkhz/8YdFxAAAAqGINWZwru80bN27MokWLCk4DAABANWu44nz27NkMDg4mMaYNAADA5TVccd6/f3/GxsbypS99KatXry46DgAAAFWu4Ypz5TTtnp6eNDU1FZwGAACAatdQxXlycjJ79+5NkvT19RWcBgAAgFrQUMX5hRdeyH/+85/cfvvt+c53vlN0HAAAAGpAQxXnypj2tm3bUiqVCk4DAABALWiY4nzixIkcOnQoiTFtAAAA5q5hivPAwECmp6dz9913Z/ny5UXHAQAAoEY0THG+cEwbAAAA5qohivPIyEjeeOONNDU1ZcuWLUXHAQAAoIY0RHGu7DZ3d3eno6Oj4DQAAADUkrovzuVyOTt37kxiTBsAAIArV/fF+c9//nNGRkayaNGirF+/vug4AAAA1Ji6L86V3eYHH3wwLS0tBacBAACg1tR1cT5//nwGBgaSeHYzAAAAn01dF+fDhw/n3XffTXt7e37wgx8UHQcAAIAaVNfFuTKm/cgjj6S5ubngNAAAANSiui3OZ8+ezdDQUBJj2gAAAHx2dVucf/vb3+bUqVP54he/mFWrVhUdBwAAgBpVt8V5165dSZKtW7emqamp4DQAAADUqroszu+//35efPHFJElvb2/BaQAAAKhldVmc9+7dmw8++CBdXV256667io4DAABADVsw3zeYmprK1NTUzOvJycn5vuXMmHZvb29KpdK83w8AAIDq98k+2tzcPKcnMM37jvP27dvT1tY289PZ2Tmv9xsbG8v+/fuTGNMGAADgY52dnRf10+3bt8/pulK5XC7PZ7BL7Th3dnZmYmIira2t1/x+zzzzTH76059mxYoVefPNN6/55wMAAFBbJicn09bWluPHj1/UQ+e64zzvo9pzDXKtXDimDQAAABWtra2faQO3rg4He/fdd/Pqq68mSXp6eooNAwAAQF2oq+I8MDCQcrmce++9N1/5yleKjgMAAEAdqKvibEwbAACAa61uivPIyEjeeOON3HDDDdm8eXPRcQAAAKgTdVOc+/v7kyTd3d3p6OgoOA0AAAD1oi6Kc7lczs6dO5MY0wYAAODaqovi/Oabb+att95Kc3NzNmzYUHQcAAAA6khdFOfKoWDr1q1LW1tbwWkAAACoJzVfnKenp2e+32xMGwAAgGut5ovzH/7whxw7diwtLS1Zt25d0XEAAACoMzVfnCtj2hs2bMiiRYsKTgMAAEC9qenifO7cuezevTtJ0tfXV3AaAAAA6lFNF+dDhw7l5MmTufnmm7NmzZqi4wAAAFCHaro4V8a0N2/enAULFhScBgAAgHpUs8X5zJkzef7555MY0wYAAGD+1Gxxfumll/Lvf/87t9xyS+65556i4wAAAFCnarY4V8a0e3p6csMNNfvXAAAAoMrVZOOcmJjISy+9lMSYNgAAAPOrJovzCy+8kKmpqXz961/PihUrio4DAABAHavJ4rxz584kH+02l0qlgtMAAABQz2quOL/33ns5dOhQko++3wwAAADzqeaK8+DgYKanp3PnnXdm+fLlRccBAACgztVccb5wTBsAAADmW00V53/84x/54x//mFKplC1bthQdBwAAgAZQU8W5v78/SbJ69eosW7as4DQAAAA0gpoqzpUx7d7e3oKTAAAA0Chqpjj/5S9/ydGjR7Nw4cJs3Lix6DgAAAA0iJopzrt27UqSPPDAA1myZEnBaQAAAGgUNVGcy+XyzPebjWkDAABwPdVEcT5y5EhGR0ezePHiPPjgg0XHAQAAoIHURHGuHAq2fv36fO5znys4DQAAAI2k6ovz+fPns3v37iTGtAEAALj+qr44v/rqqzlx4kSWLl2a+++/v+g4AAAANJiqL86VMe1NmzblxhtvLDgNAAAAjaaqi/PU1FR+9atfJTGmDQAAQDGqujjv378/ExMT+fKXv5z77ruv6DgAAAA0oKouzpUx7a1bt6apqangNAAAADSiqi3Op0+fzr59+5IkfX19BacBAACgUVVtcX7xxRdz5syZfPWrX83KlSuLjgMAAECDqtrivGvXriQfHQpWKpUKTgMAAECjqsrifPLkybzyyitJnKYNAABAsaqyOA8NDeXDDz/Mt7/97Xzta18rOg4AAAANrCqL84Vj2gAAAFCkqivOx48fz+HDh5MkPT09BacBAACg0VVdcR4YGEi5XM59992Xzs7OouMAAADQ4KquOFfGtD27GQAAgGpQVcX57bffzvDwcBYsWJBNmzYVHQcAAACqqzhXdpvXrl2bL3zhCwWnAQAAgCoqzuVy2Zg2AAAAVadqivPw8HD++te/5qabbsrDDz9cdBwAAABIUkXFubLb/NBDD6WlpaXgNAAAAPCRqijO09PT6e/vT5L09vYWnAYAAAA+VhXF+fDhw/nnP/+Ztra2PPDAA0XHAQAAgBlVUZwrY9obN25Mc3NzwWkAAADgY4UX57Nnz2ZwcDCJMW0AAACqT+HF+cCBAxkbG0tHR0dWr15ddBwAAAC4SOHFuTKmvXXr1jQ1NRWcBgAAAC5WaHH+4IMPsmfPniTGtAEAAKhOhRbnffv25f33389tt92Wu+++u8goAAAAcEmFFufKmHZvb29KpVKRUQAAAOCSCivOp06dym9+85skxrQBAACoXoUV53379uXcuXP55je/mTvuuKOoGAAAADCrworz0NBQErvNAAAAVLfCivNrr72WJOnp6SkqAgAAAFxWoYeD3XPPPbntttuKjAAAAACzKrQ4G9MGAACg2hVWnEulUrZs2VLU7QEAAGBOCivOq1atSkdHR1G3BwAAgDlZMN83mJqaytTU1MzriYmJJMm6desyOTk537cHAACgwVW6Z6WPVjQ3N6e5ufmy15fK5XJ5XpL915NPPplf/OIX83kLAAAAuGJPPPFEnnzyycv+3rwX50/uOI+Pj+fWW2/NsWPH0tbWNp+35jqZnJxMZ2dnjh8/ntbW1qLjcJWsZ32xnvXFetYfa1pfrGd9sZ71ZWJiIrfcckveeeedtLe3z/z5XHec531U+9OCtLW1+Q9YZ1pbW61pHbGe9cV61hfrWX+saX2xnvXFetaX9vb2z7SehT6OCgAAAKqd4gwAAACzuO7Fubm5OU888cSc5sipDda0vljP+mI964v1rD/WtL5Yz/piPevL1a7nvB8OBgAAALXMqDYAAADMQnEGAACAWSjOAAAAMAvFGQAAAGahOAMAAMAsFGcAAACYxYKiAwAAAEDFo48+mrGxsYyOjmZwcDBdXV0ZHx/P9u3bMz4+PvPeU089le7u7iTJwYMHs2PHjixdujSjo6Npb2/PM888k/b29muSyXOcAQAAqApPP/10kuTnP/951q5dm7GxsQwODubRRx/Njh070tXVlSR57LHH8vTTT+fUqVMzhXrHjh0zn7NkyZJ0d3dncHDwmuSy4wwAAEBV2LFjR/72t78lScbGxjI8PJzNmzfn0KFDF+0e33nnnUmSNWvWpLu7+6LSnCRdXV05ePDgNcvlO84AAAAU7uDBg1m5cuXM69HR0SS55Mh15b0keeqpp/7ns8bHx69pNsUZAACAqvD4448nSYaHhzM+Pp7u7u6LynRFZVf600rz6OjozFj3tWBUGwAAgMJVDvpKMjNmvXnz5kv+7u7du//nmk9ee6n3Pis7zgAAAFSVAwcOJEm2bNnyP++Njo7O7EZfysDAQJJk69at1yyP4gwAAEBVOXjwYLq6ui75OKnKjvLatWsvee3Q0FC6urouOeL9WSnOAAAAVI3LjVpXdqM3bdr0P+8NDQ0l+ehZ0BWPPfbYVWdSnAEAAKgalWL8aTvKBw8eTHt7+yUP/6o8lqpSqkdHRzM8PHzVmRRnAAAAqsZsO84Xnrb9adeuXLlyplTv2LHDjjMAAAD1Y3x8PMPDw1m5cuVn+n5zV1fXTGm+XMm+Eh5HBQAAQFUYGxtLe3v7zPOcL6Wrq+uSp20nyeDgYH7yk59k8+bNWbp06czo9tUqlcvl8jX5JAAAAKhDRrUBAABgFoozAAAAzEJxBgAAgFkozgAAADALxRkAAABmoTgDAADALBRnAAAAmIXiDAAAALNQnAEAAGAWijMAAADMQnEGAACAWSjOAAAAMAvFGQAAAGahOAMAAMAsFGcAAACYxf8D2j9yW2+pMlYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Finite mBalLvl but infinite mNrmFacTrgNrm\n"
     ]
    }
   ],
   "source": [
    "# Plot https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICModFailsButGICRawHolds\n",
    "\n",
    "soln = GICModFailsButGICRawHolds.solution[0]  # Short alias for solution\n",
    "\n",
    "# Get objects that have been Built, parameters configured, and expectations \n",
    "Bilt, Pars, E_tp1_ = soln.Bilt, soln.Pars, soln.E_Next_\n",
    "\n",
    "# consumption function\n",
    "cFunc = Bilt.cFunc\n",
    "\n",
    "# Shortcuts to useful items\n",
    "RPFac = Bilt.RPFac\n",
    "G = Pars.PermGroFac\n",
    "\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCminDefn\n",
    "mpc_Min = 1.0-RPFac \n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#hNrmDefn\n",
    "h_inf = (1.0/(1.0-G/Rfree))\n",
    "\n",
    "# Perfect foresight consumption function (unused but convenient for explorations)\n",
    "def cFunc_Uncnst(m): return mpc_Min * m + (h_inf - 1) * mpc_Min\n",
    "\n",
    "# Initialize figure setup\n",
    "fig, ax = plt.subplots(figsize=(12, 8))\n",
    "\n",
    "[xMin, xMax] = [0.0, 8.0]\n",
    "yMin = 0.0\n",
    "yMax = E_tp1_.c_where_E_Next_m_tp1_minus_m_t_eq_0(xMax)*1.3\n",
    "\n",
    "mPltVals = np.linspace(xMin, xMax, mPts)\n",
    "\n",
    "if latexExists:\n",
    "    c_Stable_TrgNrm_txt = \"$\\Ex_{t}[\\Delta m_{t+1}] = 0$\"\n",
    "    c_Stable_BalLvl_txt = \"$\\Ex_{t}[{\\mathbf{m}}_{t+1}/{\\mathbf{m}}_{t}] = \\PermGroFac$\"\n",
    "    c_Stable_BalLog_txt = \"$\\Ex_{t}[\\log {\\mathbf{m}}_{t+1} - \\log {\\mathbf{m}}_{t}] = \\log \\PermGroFac$\"\n",
    "    c_Unconstrained_txt = r'$\\bar{\\cFunc}(\\mNrm)$'\n",
    "else:\n",
    "    c_Stable_TrgNrm_txt = \"$\\mathsf{E}_{t}[\\Delta m_{t+1}] = 0$\"\n",
    "    c_Stable_BalLvl_txt = \"$\\mathsf{E}_{t}[\\mathbf{m}_{t+1}/\\mathbf{m}_{t}] = \\Phi$\"\n",
    "    c_Stable_BalLog_txt = \"$\\mathsf{E}_{t}[\\log \\mathbf{m}_{t+1} - \\log \\mathbf{m}_{t}] = \\log \\Phi$\"\n",
    "    c_Unconstrained_txt = r'$\\bar{\\cFunc}(\\mNrm)$'\n",
    "\n",
    "cVals_Lmting_color = \"black\"\n",
    "c_Stable_BalLvl_color = \"black\"  # or \"blue\"\n",
    "c_Stable_BalLog_color = \"blue\"  # or \"blue\"\n",
    "c_Stable_TrgNrm_color = \"black\"  # or \"red\"\n",
    "c_Unconstrained_color = \"black\"  # or \"red\"\n",
    "\n",
    "cVals_Lmting = cFunc(mPltVals)\n",
    "c_Stable_TrgNrm = E_tp1_.c_where_E_Next_m_tp1_minus_m_t_eq_0(mPltVals)\n",
    "c_Stable_BalLvl = E_tp1_.c_where_E_Next_PermShk_tp1_times_m_tp1_minus_m_t_eq_0(mPltVals)\n",
    "c_Stable_BalLog = list(map(lambda mPltVal: soln.c_where_E_Next_mLog_tp1_minus_mLog_t_eq_0(mPltVal), mPltVals))\n",
    "c_Unconstrained = list(map(lambda mPltVal: cFunc_Uncnst(mPltVal), mPltVals))\n",
    "\n",
    "# To reduce clutter, results for PF soln and balanced-log-growth are omitted\n",
    "cVals_Lmting_lbl, = ax.plot(mPltVals, cVals_Lmting, color=cVals_Lmting_color)\n",
    "c_Stable_TrgNrm_lbl, = ax.plot(mPltVals, c_Stable_TrgNrm,\n",
    "                            color=c_Stable_TrgNrm_color, linestyle=\"dashed\", label=c_Stable_TrgNrm_txt)\n",
    "c_Stable_BalLvl_lbl, = ax.plot(mPltVals, c_Stable_BalLvl,\n",
    "                            color=c_Stable_BalLvl_color, linestyle=\"dotted\", label=c_Stable_BalLvl_txt)\n",
    "#c_Stable_BalLog_lbl, = ax.plot(mPltVals, c_Stable_BalLog,\n",
    "#                            color=c_Stable_BalLog_color, linestyle=\"dotted\", label=c_Stable_BalLog_txt)\n",
    "# c_Unconstrained_lbl, = ax.plot(mPltVals, c_Unconstrained,color=c_Unconstrained_color, linestyle=\"dashdot\", label=c_Unconstrained_txt)\n",
    "ax.set_xlim(xMin, xMax)\n",
    "ax.set_ylim(yMin, yMax)\n",
    "ax.set_xlabel(\"$\\mathit{m}$\", fontweight='bold', fontsize=fsmid, loc=\"right\")\n",
    "ax.set_ylabel(\"$\\mathit{c}$\", fontweight='bold', fontsize=fsmid, loc=\"top\", rotation=0)\n",
    "\n",
    "ax.tick_params(labelbottom=False, labelleft=False, left='off',\n",
    "               right='off', bottom='off', top='off')\n",
    "\n",
    "ax.legend(handles=[c_Stable_TrgNrm_lbl, c_Stable_BalLvl_lbl])\n",
    "#ax.legend(handles=[c_Stable_TrgNrm_lbl, c_Stable_BalLvl_lbl, c_Stable_BalLog_lbl])\n",
    "ax.legend(prop=dict(size=fsmid))\n",
    "\n",
    "mBalLvl = Bilt.mBalLvl\n",
    "cNrmFacBalLvl = c_Stable_BalNrm = cFunc(mBalLvl)\n",
    "\n",
    "ax.plot(mBalLvl, cNrmFacBalLvl, marker=\".\", markersize=15, color=\"black\")  # Dot at Bal point\n",
    "ax.text(1, 0.6, \"$\\mathrm{c}(m_{t})$\", fontsize=fsmid)  # label cFunc\n",
    "\n",
    "if latexExists:\n",
    "    ax.text(mBalLvl+0.02, cNrmFacBalLvl-0.10, r\"$\\nwarrow$\", fontsize=fsmid)\n",
    "    ax.text(mBalLvl+0.25, cNrmFacBalLvl-0.18, r\"$\\check{m}~$\", fontsize=fsmid)\n",
    "else:\n",
    "    ax.text(mBalLvl+0.02, cNrmFacBalLvl-0.10, r\"$\\nwarrow$\", fontsize=fsmid)\n",
    "    ax.text(mBalLvl+0.25, cNrmFacBalLvl-0.18, r\"$\\check{m}~$\", fontsize=fsmid)\n",
    "\n",
    "makeFig('GICModFailsButGICRawHolds')\n",
    "print('Finite mBalLvl but infinite mNrmFacTrgNrm')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "275b6019",
   "metadata": {},
   "source": [
    "In the [interactive dashboard](#interactive-dashboard), see what happens as changes in the time preference rate (or changes in risk $\\PermShkStd$) change the consumer from _normalized-growth-patient_ $(\\APFac > \\PermGroFac)$ to _normalized-growth-impatient_ ($\\APFac < \\PermGroFac$)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0faf2c15",
   "metadata": {},
   "source": [
    "As a foundation for the remaining figures, we define another instance of the class $\\texttt{IndShockConsumerType}$, which has the same parameter values as the instance $\\texttt{baseAgent}$ defined previously but is solved to convergence (our definition of an infinite horizon agent type) instead of only 100 periods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "421bc11f",
   "metadata": {},
   "source": [
    "`# Construct infinite horizon solution for consumer with baseline parameters:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e589f15f",
   "metadata": {
    "lines_to_next_cell": 2,
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Find the infinite horizon solution\n",
    "\n",
    "base_params['aXtraCount'] = base_params['aXtraCount'] * 20\n",
    "base_params['CubicBool'] = False\n",
    "base_params['cycles'] = 0  # Default for infinite horizon model\n",
    "\n",
    "baseAgent_Inf = IndShockConsumerType(\n",
    "    **base_params,\n",
    "    horizon='infinite',  # Infinite horizon\n",
    "    quietly=True, messaging_level=logging.CRITICAL)  # construct it silently"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5d14b30",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Expected Consumption Growth, and Permanent Income Growth](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AnalysisoftheConvergedConsumptionFunction)\n",
    "\n",
    "$\\renewcommand{\\PermShk}{\\pmb{\\Psi}}$\n",
    "The next figure, [Analysis of the Converged Consumption Function](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#cNrmTargetFig), shows expected growth factors for the levels of consumption $\\cLvl$ and market resources $\\mLvl$ as a function of the market resources ratio $\\mNrm$ for a consumer behaving according to the converged consumption rule, along with the growth factor for $\\mNrm$ itself, and the (constant) growth factors for consumption and expected permanent income, $\\APFac$ and $\\PermGroFac$.\n",
    "\n",
    "The growth factor for consumption can be computed without knowing the _level_ of the consumer's permanent income:\n",
    "\n",
    "\\begin{eqnarray*}\n",
    "\\Ex_{t}[\\cLvl_{t+1}/\\cLvl_{t}] & = & \\Ex_{t}\\left[\\frac{\\pLvl_{t+1}\\cFunc(m_{t+1})}{\\pLvl_{t}\\cFunc(m_{t})}\\right] \\\\\n",
    "% & = & \\Ex_{t}\\left[\\frac{\\PermGroFac \\PermShk_{t+1} \\pLvl_{t}}{\\pLvl_{t}}\\frac{\\cFunc(m_{t+1})}{\\cFunc(m_{t})}\\right] \\\\\n",
    "& = & \\left[\\frac{\\PermGroFac \\PermShk_{t+1} \\cFunc(m_{t+1})}{\\cFunc(m_{t})}\\right]\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd9b8db1",
   "metadata": {
    "tags": []
   },
   "source": [
    "and similarly the growth factor for the level of market resources is:\n",
    "\n",
    "\\begin{eqnarray*}\\renewcommand{\\PermShk}{\\pmb{\\Psi}}\n",
    "\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}]\n",
    "& = & \\Ex_{t}\\left[\\frac{\\PermGroFac \\PermShk_{t+1} \\mNrm_{t+1}} {\\mNrm_{t}} \\right]\n",
    "\\\\ & = & \\Ex_{t}\\left[\\frac{\\PermGroFac \\PermShk_{t+1} (\\aNrm_{t}\\Rfree/(\\PermGroFac \\PermShk_{t+1}))+\\PermGroFac \\PermShk_{t+1}\\TranShk_{t+1}}\n",
    "{\\mNrm_{t}}\\right]\n",
    "\\\\ & = & \\Ex_{t}\\left[\\frac{\\PermGroFac (\\aNrm_{t}\\RNrm+\\PermShk_{t+1}\\TranShk_{t+1})}\n",
    "{\\mNrm_{t}}\\right]\n",
    "\\\\ & = & \\PermGroFac \\left[\\frac{\\aNrm_{t}\\RNrm+1}{\\mNrm_{t}}\\right]\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "001f7b91",
   "metadata": {},
   "source": [
    "For the ratio $\\mNrm$ things are only slightly more complicated:\n",
    "\\begin{eqnarray*}\\renewcommand{\\PermShk}{\\pmb{\\Psi}}\n",
    "\\Ex_{t}[m_{t+1}]\n",
    "& = & \\Ex_{t}\\left[(m_{t}-c_{t})(\\Rfree/(\\PermShk_{t+1}\\PermGroFac)) +\\TranShk_{t+1}\\right]\\\\\n",
    "& = & a_{t}\\Rfree\\Ex_{t}\\left[(\\PermShk_{t+1}\\PermGroFac)^{-1}\\right] +1 \\\\\n",
    "\\Ex_{t}\\left[m_{t+1}/m_{t}\\right] & = & \\left(\\frac{a_{t}\\bar{\\RNrm}+1}{\\mNrm_{t}}\\right)\n",
    "\\end{eqnarray*}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb84d9c7",
   "metadata": {
    "tags": []
   },
   "source": [
    "<!-- The expectation of the growth in the log of $\\mLvl$ is a downward-adjusted value of the log of the growth factor:\n",
    "\\begin{eqnarray*}\n",
    "\\Ex_{t}[\\log(\\mLvl_{t+1}/\\mLvl_{t})]\n",
    "& = & \\Ex_{t}\\left[\\log \\PermGroFac \\PermShk_{t+1} \\mNrm_{t+1}\\right] - \\log \\mNrm_{t}\n",
    "\\\\ & = & \\Ex_{t}\\left[\\log \\PermGroFac \\left(\\PermShk_{t+1} (\\aNrm_{t}\\Rfree/(\\PermGroFac \\PermShk_{t+1}))+\\PermShk_{t+1}\\TranShk_{t+1}\\right)\\right]-\\log \\mNrm_{t}\n",
    "\\\\ & = & \\Ex_{t}\\left[\\log \\PermGroFac (\\aNrm_{t}\\RNrm+\\PermShk_{t+1}\\TranShk_{t+1}+1-1)\\right] - \\log \n",
    "{\\mNrm_{t}}\n",
    "\\\\ & = & \n",
    "\\log \\left(\\PermGroFac \n",
    "(\\aNrm_{t}\\RNrm+1)\\Ex_{t}\\left[\\left(\n",
    "1+\\frac{\\PermShk_{t+1}\\TranShk_{t+1}-1}{(\\aNrm_{t}\\RNrm+1)}\n",
    "\\right)\n",
    "\\right]\\right) - \\log {\\mNrm_{t}}\n",
    "\\\\ & = & \\log \\underbrace{\\PermGroFac \\left[\\frac{\\aNrm_{t}\\RNrm+1}{\\mNrm_{t}}\\right]}_{\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}]}+\n",
    "\\log \\Ex_{t}\\left[\\left(1+\n",
    "\\frac{\\PermShk_{t+1}\\TranShk_{t+1}-1}{(\\aNrm_{t}\\RNrm+1)}\n",
    "\\right)\n",
    "\\right]\n",
    "\\end{eqnarray*}\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97507f3f",
   "metadata": {},
   "source": [
    "`# Solve problem of consumer with baseline parameters:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "15419151",
   "metadata": {
    "pycharm": {
     "is_executing": true,
     "name": "#%%\n"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "............................................................................................................"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "(quietly=False and messaging_level < logging.WARNING, so some model information is provided below):\n",
      "\n",
      "The model has the following parameter values:\n",
      "\n",
      "\tDiscFac: 0.97\n",
      "\tLivPrb: 1.0\n",
      "\tCRRA: 2.0\n",
      "\tRfree: 1.04\n",
      "\tPermGroFac: 1.03\n",
      "\tIncShkDstn: <HARK.distribution.DiscreteDistribution object at 0x16882f460>\n",
      "\tPermShkDstn: <HARK.distribution.DiscreteDistribution object at 0x16896c280>\n",
      "\tTranShkDstn: <HARK.distribution.DiscreteDistribution object at 0x16887acb0>\n",
      "\tBoroCnstArt: None\n",
      "\tMaxKinks: None\n",
      "\tsolverType: HARK\n",
      "\tsolveMethod: EGM\n",
      "\teventTiming: EOP\n",
      "\thorizon: infinite\n",
      "\targs: ()\n",
      "\n",
      "The model's transition equations are:\n",
      "\n",
      "chosen_to_next_choice step:\n",
      "\tkNrm = aNrm\n",
      "\tRNrm = Rfree / (PermGroFac * PermShk)\n",
      "\tbNrm = kNrm * RNrm\n",
      "\tyNrm = TranShk\n",
      "\tmNrm = bNrm + yNrm\n",
      "\n",
      "choice_to_chosen step:\n",
      "\taNrm = mNrm - cNrm\n",
      "\n",
      "\n",
      "Because messaging_level is >= logging.INFO, infinite horizon conditions are reported below:\n",
      "\n",
      "\n",
      "The Absolute Patience Factor, APFac=1.00439 violates the Absolute Impatience Condition (AIC), APFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AIC\n",
      "\n",
      "The Finite Human Wealth Factor, FHWFac=0.99038 satisfies the Finite Human Wealth Condition (FHWC), FHWFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FHWC\n",
      "\n",
      "The Return Patience Factor, RPFac=0.96576 satisfies the Return Impatience Condition (RIC), RPFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#RIC\n",
      "\n",
      "The uncertainty-Modified Growth Patience Factor GPFacMod, GPFacMod=0.98429 satisfies the Modified Growth Impatience Condition (GICMod), GPFacMod < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICMod\n",
      "\n",
      "\n",
      "The Szeidl Growth Patience Factor GPFacSdl=0.97970 satisfies the Szeidl Growth Impatience Condition (GICSdl), GPFacSdl < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICSdl\n",
      "\n",
      "The Growth Patience Factor, GPF=0.97514 satisfies the Growth Impatience Condition (GICRaw), GPFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICRawDefn\n",
      "\n",
      "\n",
      "The Harmenberg Growth Patience Factor GPFacHrm=0.97060 satisfies the Harmenberg Growth Impatience Condition (GICHrm), GPFacHrm < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICHrm\n",
      "\n",
      "The Mortality Adjusted Growth Patience Factor, GPFacLiv=0.97514 satisfies the Mortality Adjusted Growth Impatience Condition (GICLiv):\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GPFacLivDefn\n",
      "\n",
      "The Modigliani Mortality Adjusted Growth Patience Factor, GPFacLivMod=0.97514 satisfies the Mortality Adjusted Growth Impatience Condition (GICLivMod):\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#GICLivModDefn\n",
      "\n",
      "The Finite Value of Autarky Factor, VAFac=0.97000 satisfies the Finite Value of Autarky Condition, VAFac < 1:\n",
      "    https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#FVAC\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "..\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'float' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[12], line 12\u001b[0m\n\u001b[1;32m      9\u001b[0m tweaked_tweaked_params \u001b[38;5;241m=\u001b[39m tweaked_params\n\u001b[1;32m     10\u001b[0m tweaked_tweaked_params[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPermShkStd\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0.2\u001b[39m \u001b[38;5;66;03m# Increase size of perm shk\u001b[39;00m\n\u001b[0;32m---> 12\u001b[0m baseAgent_Inf_Risky \u001b[38;5;241m=\u001b[39m \u001b[43mIndShockConsumerType\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     13\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtweaked_tweaked_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mquietly\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessaging_level\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlogging\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mCRITICAL\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# construct it silently\u001b[39;00m\n\u001b[1;32m     14\u001b[0m baseAgent_Inf_Risky\u001b[38;5;241m.\u001b[39msolve(    quietly\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, messaging_level\u001b[38;5;241m=\u001b[39mlogging\u001b[38;5;241m.\u001b[39mINFO)  \u001b[38;5;66;03m# Solve it with info\u001b[39;00m\n",
      "File \u001b[0;32m/Volumes/Data/Papers/BufferStockTheory/BufferStockTheory-Latest/src/econ-ark/HARK/ConsumptionSaving/ConsIndShockModel_AgentTypes.py:1094\u001b[0m, in \u001b[0;36mIndShockConsumerType.__init__\u001b[0;34m(self, messaging_level, quietly, solution_startfrom, solverType, solveMethod, eventTiming, solverName, **kwds)\u001b[0m\n\u001b[1;32m   1092\u001b[0m \u001b[38;5;66;03m# If precooked terminal stage not provided by user ...\u001b[39;00m\n\u001b[1;32m   1093\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msolution_startfrom\u001b[39m\u001b[38;5;124m'\u001b[39m):  \u001b[38;5;66;03m# .. then init the default\u001b[39;00m\n\u001b[0;32m-> 1094\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_agent_force_prepare_info_needed_to_begin_solving\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1096\u001b[0m \u001b[38;5;66;03m# - Default interpolation method is piecewise linear\u001b[39;00m\n\u001b[1;32m   1097\u001b[0m \u001b[38;5;66;03m# - Cubic is smoother, works if problem has no constraints\u001b[39;00m\n\u001b[1;32m   1098\u001b[0m \u001b[38;5;66;03m# - User may or may not want to create the value function\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1101\u001b[0m \u001b[38;5;66;03m# - 2. Cubic vs linear interpolation is not worth two different solvers\u001b[39;00m\n\u001b[1;32m   1102\u001b[0m \u001b[38;5;66;03m# -    * Cubic should be preserved as an option\u001b[39;00m\n\u001b[1;32m   1103\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mCubicBool \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvFuncBool:\n",
      "File \u001b[0;32m/Volumes/Data/Papers/BufferStockTheory/BufferStockTheory-Latest/src/econ-ark/HARK/ConsumptionSaving/ConsIndShockModel_AgentTypes.py:1158\u001b[0m, in \u001b[0;36mIndShockConsumerType._agent_force_prepare_info_needed_to_begin_solving\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1156\u001b[0m solve_par_vals_now \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m   1157\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msolve_par_vals\u001b[39m\u001b[38;5;124m'\u001b[39m):  \u001b[38;5;66;03m# We haven't set it up yet\u001b[39;00m\n\u001b[0;32m-> 1158\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupdate_income_process\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1159\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mupdate_assets_grid()\n\u001b[1;32m   1160\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:  \u001b[38;5;66;03m# it has been set up, so see if anything changed\u001b[39;00m\n",
      "File \u001b[0;32m/Volumes/Data/Papers/BufferStockTheory/BufferStockTheory-Latest/src/econ-ark/HARK/ConsumptionSaving/ConsIndShockModel_AgentTypes.py:1197\u001b[0m, in \u001b[0;36mIndShockConsumerType.update_income_process\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1181\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mupdate_income_process\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m   1182\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   1183\u001b[0m \u001b[38;5;124;03m    Updates agent's income shock specs based on its current attributes.\u001b[39;00m\n\u001b[1;32m   1184\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1191\u001b[0m \u001b[38;5;124;03m    none\u001b[39;00m\n\u001b[1;32m   1192\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m   1194\u001b[0m     (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mIncShkDstn,\n\u001b[1;32m   1195\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mPermShkDstn,\n\u001b[1;32m   1196\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mTranShkDstn,\n\u001b[0;32m-> 1197\u001b[0m      ) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconstruct_lognormal_income_process_unemployment\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1198\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_to_time_vary(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncShkDstn\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPermShkDstn\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTranShkDstn\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m   1199\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparameters\u001b[38;5;241m.\u001b[39mupdate({\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mIncShkDstn\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mIncShkDstn,\n\u001b[1;32m   1200\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPermShkDstn\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mPermShkDstn,\n\u001b[1;32m   1201\u001b[0m                             \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTranShkDstn\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mTranShkDstn})\n",
      "File \u001b[0;32m/Volumes/Data/Papers/BufferStockTheory/BufferStockTheory-Latest/src/econ-ark/HARK/ConsumptionSaving/ConsIndShockModel_AgentTypes.py:1372\u001b[0m, in \u001b[0;36mIndShockConsumerType.construct_lognormal_income_process_unemployment\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1368\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m UnempPrb \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m   1369\u001b[0m     TranShkDstn_t \u001b[38;5;241m=\u001b[39m add_discrete_outcome_constant_mean(\n\u001b[1;32m   1370\u001b[0m         TranShkDstn_t, p\u001b[38;5;241m=\u001b[39mUnempPrb, x\u001b[38;5;241m=\u001b[39mIncUnemp\n\u001b[1;32m   1371\u001b[0m     )\n\u001b[0;32m-> 1372\u001b[0m PermShkDstn_t \u001b[38;5;241m=\u001b[39m MeanOneLogNormal(sigma\u001b[38;5;241m=\u001b[39m\u001b[43mPermShkStd\u001b[49m\u001b[43m[\u001b[49m\u001b[43mt\u001b[49m\u001b[43m]\u001b[49m)\u001b[38;5;241m.\u001b[39mapprox(\n\u001b[1;32m   1373\u001b[0m     PermShkCount, tail_N\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m   1374\u001b[0m )\n\u001b[1;32m   1376\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnormalize_shocks\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[1;32m   1377\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnormalize_shocks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'float' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "# Solve baseline parameters agent\n",
    "tweaked_params = deepcopy(base_params)\n",
    "tweaked_params['DiscFac'] = 0.970  # Tweak to make figure clearer\n",
    "baseAgent_Inf = IndShockConsumerType(\n",
    "    **tweaked_params, quietly=True, messaging_level=logging.CRITICAL)  # construct it silently\n",
    "\n",
    "baseAgent_Inf.solve(\n",
    "    quietly=False, messaging_level=logging.INFO)  # Solve it with info\n",
    "tweaked_tweaked_params = tweaked_params\n",
    "tweaked_tweaked_params['PermShkStd'] = 0.2 # Increase size of perm shk\n",
    "\n",
    "baseAgent_Inf_Risky = IndShockConsumerType(\n",
    "    **tweaked_tweaked_params, quietly=True, messaging_level=logging.CRITICAL)  # construct it silently\n",
    "baseAgent_Inf_Risky.solve(    quietly=False, messaging_level=logging.INFO)  # Solve it with info\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b89cc4c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "baseAgent_Inf_Risky = IndShockConsumerType(\n",
    "    **tweaked_tweaked_params, quietly=True, messaging_level=logging.CRITICAL)  # construct it silently\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98360c1f",
   "metadata": {
    "tags": []
   },
   "source": [
    "`# Plot growth factors for various model elements at steady state:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "266094be",
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot growth rates\n",
    "\n",
    "soln = baseAgent_Inf.solution[0]\n",
    "\n",
    "# Built, parameters, expectations\n",
    "Bilt, Pars, E_Next_ = soln.Bilt, soln.Pars, soln.E_Next_\n",
    "\n",
    "# Retrieve parameters (makes code more readable)\n",
    "Rfree, DiscFac, CRRA, PermGroFac = \\\n",
    "    Pars.Rfree, Pars.DiscFac, Pars.CRRA, Pars.PermGroFac\n",
    "\n",
    "color_cons, color_mrktLev, color_mrktNrm, color_perm, color_mLogGroExp = \\\n",
    "    \"blue\", \"red\", \"green\", \"black\", \"orange\"\n",
    "\n",
    "mPlotMin, mCalcMax, mPlotMax = 1.0, 50, 1.8\n",
    "\n",
    "# Get steady state equilibrium and target values for m\n",
    "mBalLvl, mNrmFacTrg = Bilt.mBalLvl, Bilt.mTrgNrm\n",
    "\n",
    "pts_num = 200  # Plot this many points\n",
    "\n",
    "m_pts = np.linspace(mPlotMin, mPlotMax, pts_num)   # values of m for plot\n",
    "c_pts = soln.cFunc(m_pts)                   # values of c for plot\n",
    "a_pts = m_pts - c_pts                       # values of a\n",
    "\n",
    "# Get ingredients for calculating growth factors, then calculate them\n",
    "Ex_cLvl_tp1_Over_pLvl_t = [ \n",
    "    soln.E_Next_.cLvl_tp1_Over_pLvl_t_from_a_t(a) for a in a_pts]\n",
    "Ex_mLvl_tp1_Over_pLvl_t = [\n",
    "    soln.E_Next_.mLvl_tp1_Over_pLvl_t_from_a_t(a) for a in a_pts]\n",
    "Ex_mLog_tp1_minus_mLog_t_from_m_t = [\n",
    "    soln.E_Next_.mLog_tp1_minus_mLog_t_from_m_t(m) for m in m_pts]\n",
    "Ex_m_tp1_from_a_t = [\n",
    "    soln.E_Next_.m_tp1_from_a_t(a) for a in a_pts]\n",
    "\n",
    "Ex_cLvlGroFac = np.array(Ex_cLvl_tp1_Over_pLvl_t)/c_pts\n",
    "Ex_mLvlGroFac = np.array(Ex_mLvl_tp1_Over_pLvl_t)/m_pts\n",
    "Ex_mNrmGroFac = np.array(Ex_m_tp1_from_a_t)/m_pts\n",
    "# Exponentiated growth rate; not used but available for exploration\n",
    "Ex_mLogGroFac = np.exp(Ex_mLog_tp1_minus_mLog_t_from_m_t) \n",
    "\n",
    "# Absolute Patience Factor = lower bound of consumption growth factor\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#APF\n",
    "APFac = Bilt.APFac\n",
    "\n",
    "# Init figure and axes\n",
    "fig, ax = plt.subplots(figsize=(12, 8))\n",
    "plt.rcParams['font.size'], plt.rcParams['font.weight'] = fsmid, 'bold'\n",
    "\n",
    "# Plot the Absolute Patience Factor line\n",
    "ax.plot([0, mPlotMax], [APFac, APFac], color=color_cons)\n",
    "\n",
    "# Plot the Permanent Income Growth Factor line\n",
    "ax.plot([0, mPlotMax], [PermGroFac, PermGroFac]    , color=color_perm)\n",
    "\n",
    "# Plot the expected consumption growth factor\n",
    "ax.plot(m_pts, Ex_cLvlGroFac        , color=color_cons)\n",
    "\n",
    "# Plot expected growth for the level of market resources\n",
    "ax.plot(m_pts, Ex_mLvlGroFac        , color=color_mrktLev)\n",
    "\n",
    "# Plot expected growth for the market resources ratio\n",
    "ax.plot(m_pts, Ex_mNrmGroFac        , color=color_mrktNrm)\n",
    "\n",
    "# To reduce clutter, the exponentiated log growth is left out\n",
    "#ax.plot(m_pts, Ex_mLogGroExp        , color=color_mLogGroExp)\n",
    "\n",
    "# Axes limits\n",
    "GroFacMin, GroFacMax, xMin = 0.976, 1.06, 1.1\n",
    "\n",
    "ax.set_xlim(xMin, mPlotMax * 1.1)\n",
    "ax.set_ylim(GroFacMin, GroFacMax)\n",
    "\n",
    "Thorn = u\"\\u00DE\"\n",
    "\n",
    "# If latex installed on system, plotting can look better\n",
    "if latexExists:\n",
    "    mNrmFacTrg_lbl = r'$1.00 = \\Ex_{t}[\\mNrm_{t+1}/\\mNrm_{t}]:~ \\Trg{m} \\rightarrow~~$'\n",
    "    PermGro_lbl = r\"$\\PermGroFac$\"\n",
    "    cLvlGroFac_lbl = r\"$\\Ex_{t}[\\cLvl_{t+1}/\\cLvl_{t}]$\"\n",
    "    mNrmGroFac_lbl = r\"$\\Ex_{t}[\\mNrm_{t+1}/\\mNrm_{t}] ^{\\nearrow}$\"\n",
    "    mLvlGroFac_lbl = r\"$\\Ex_{t}[\\mLvl_{t+1}/\\mLvl_{t}]$\"\n",
    "    mBalLvl_lbl = r\"$\\check{\\mNrm}_{\\searrow}~$\"    \n",
    "    cLvlAPFac_lbl = r'$\\pmb{\\text{\\TH}} = (\\Rfree\\DiscFac)^{1/\\CRRA}$'\n",
    "else:\n",
    "    mNrmFacTrg_lbl = r'$\\mathsf{E}_{t}[m_{t+1}/m_{t}]:~ \\hat{m} \\rightarrow~~$'\n",
    "    PermGro_lbl = r\"$\\Phi$\"\n",
    "    cLvlGroFac_lbl = r\"$\\mathsf{E}_{t}[\\mathbf{c}_{t+1}/\\mathbf{c}_{t}]$\"\n",
    "    mNrmGroFac_lbl = r\"$\\mathsf{E}_{t}[m_{t+1}/m_{t}]^{\\nearrow}$\"\n",
    "    mLvlGroFac_lbl = r\"$\\mathsf{E}_{t}[\\mathbf{m}_{t+1}/\\mathbf{m}_{t}]$\"\n",
    "    mBalLvl_lbl = r\"$\\check{m}_{\\searrow}$\"    \n",
    "    cLvlAPFac_lbl = Thorn + r'$= (\\mathsf{R}\\beta)^{1/\\rho}$'\n",
    "\n",
    "\n",
    "if mNrmFacTrg:  # Do not try to plot it if it does not exist!\n",
    "    ax.text(mNrmFacTrg-0.01, 1.0-0.001, \n",
    "            mNrmFacTrg_lbl, ha='right')\n",
    "\n",
    "ax.plot(mBalLvl, G  , marker=\".\", markersize=12, color=\"black\")  # Dot at mBalLvl \n",
    "ax.plot(mNrmFacTrg, 1.0, marker=\".\", markersize=12, color=\"black\")  # Dot at mNrmFacTrg \n",
    "\n",
    "mLvlGroFac_lbl_xVal = mPlotMax\n",
    "mLvlGroFac_lbl_yVal = soln.E_Next_.mLvl_tp1_Over_mLvl_t(mLvlGroFac_lbl_xVal)\n",
    "\n",
    "mNrmGroFac_lbl_xVal = 0.92*mNrmFacTrg\n",
    "mNrmGroFac_lbl_yVal = soln.E_Next_.m_tp1_Over_m_t(mNrmGroFac_lbl_xVal)\n",
    "\n",
    "ax.text(mPlotMax+0.01, G-0.001,PermGro_lbl)\n",
    "ax.text(mPlotMax+0.01, Ex_cLvlGroFac[-1]  ,cLvlGroFac_lbl)\n",
    "ax.text(mPlotMax+0.01, APFac-0.001       ,cLvlAPFac_lbl)\n",
    "ax.text(mBalLvl-0.06, G+0.001,mBalLvl_lbl              ,va='bottom',ha='left')\n",
    "ax.text(mNrmGroFac_lbl_xVal-0.01, mNrmGroFac_lbl_yVal-0.003,mNrmGroFac_lbl,va='bottom',ha='right')\n",
    "ax.text(mLvlGroFac_lbl_xVal+0.01, mLvlGroFac_lbl_yVal+0.001,mLvlGroFac_lbl,va='top')\n",
    "\n",
    "# Ticks\n",
    "ax.tick_params(labelbottom=True, labelleft=True, left='off', right='on', bottom='on', top='off')\n",
    "plt.setp(ax.get_yticklabels(), fontsize=fssml)\n",
    "\n",
    "# Label the mNrmFacTrg with vertical lines\n",
    "plt.axvline(x=mNrmFacTrg,label='Individual Target', linestyle='dotted')\n",
    "plt.legend()\n",
    "ax.set_ylabel('Growth Factors')\n",
    "makeFig('cNrmTargetFig')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b00f13e4",
   "metadata": {
    "tags": []
   },
   "source": [
    "### [Consumption Function Bounds](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#AnalysisOfTheConvergedConsumptionFunction)\n",
    "[The next figure](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#cFuncBounds)\n",
    "illustrates theoretical bounds for the consumption function.\n",
    "\n",
    "We define two useful variables: the lower bound of $\\tilde{\\MPC}$ (marginal propensity to consume) and the limit of $h$ (Human wealth), along with some functions such as the limiting perfect foresight consumption function $\\bar{c}(m)$, the upper bound function $\\bar{\\bar c}(m)$, and the lower bound function $\\tilde{c}$(m)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d5c9978",
   "metadata": {
    "tags": []
   },
   "source": [
    "`# Define bounds for figure:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dfff6c1",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define mpc_Min, h_inf and PF consumption function, upper and lower bound of c function\n",
    "\n",
    "# construct and solve it silently\n",
    "baseAgent_Inf = IndShockConsumerType(**base_params, quietly=True, messaging_level=logging.CRITICAL)\n",
    "baseAgent_Inf.solve(quietly=True, messaging_level=logging.CRITICAL)  # Solve it with info\n",
    "soln = baseAgent_Inf.solution[0]\n",
    "\n",
    "UnempPrb = Pars.IncShkDstn.parameters['UnempPrb']\n",
    "\n",
    "# Return Patience Factor\n",
    "RPFacRaw = ((Rfree * DiscFac)**(1.0/CRRA)/Rfree)\n",
    "RPFac = baseAgent_Inf.solution[0].Bilt.RPFac\n",
    "\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCminDefn\n",
    "mpc_Min = 1.0-RPFac \n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCmaxDefn\n",
    "mpc_Max = 1.0 - (UnempPrb**(1/CRRA)) * RPFac\n",
    "# https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#hNrmDefn\n",
    "h_inf = (1.0/(1.0-PermGroFac/Rfree))\n",
    "\n",
    "def cFunc_Uncnst(m): return mpc_Min * m + (h_inf - 1) * mpc_Min\n",
    "def cFunc_TopBnd(m): return mpc_Max * m\n",
    "def cFunc_BotBnd(m): return mpc_Min * m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b80dd9f",
   "metadata": {},
   "source": [
    "`# Plot figure showing bounds`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7ab17a0",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "lines_to_next_cell": 2,
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Plot the consumption function and its bounds\n",
    "cMaxLabel = r'$\\overline{c}(m)= (m-1+h)\\tilde{\\kappa}$'\n",
    "cMinLabel = r'Lower Bound: $\\tilde{c}(m)= (1-\\pmb{\\text{\\TH}}_{\\mathsf{R}})\\tilde{\\kappa}m$'\n",
    "if not latexExists:\n",
    "    cMaxLabel = r'$\\bar{c}(m) = (m-1+h)\\kappa$'  # Use unicode kludge\n",
    "    cMinLabel = r'Lower Bound: c̲$(m)= (1-$'+Thorn+r'$_{\\mathsf{R}})m = \\kappa m$'\n",
    "#    cMinLabel = r'Lower Bound: c̲$(m)= (1-$'+   ''+r'$_{\\mathsf{R}})m = \\kappa m$'\n",
    "    cLvlAPFac_lbl = Thorn + r'$= (\\mathsf{R}\\beta)^{1/\\rho}$'\n",
    "#    cLvlAPFac_lbl = ' ' + r'$= (\\mathsf{R}\\beta)^{1/\\rho}$'\n",
    "\n",
    "    \n",
    "mPlotMin = 0.0\n",
    "mPlotMax = 25\n",
    "# mKnk is point where the two upper bounds meet\n",
    "mKnk = ((h_inf-1) * mpc_Min)/((1 - UnempPrb**(1.0/CRRA)*(Rfree*DiscFac)**(1.0/CRRA)/Rfree)-mpc_Min)\n",
    "mBelwKnkPts = 300\n",
    "mAbveKnkPts = 700\n",
    "mBelwKnk = np.linspace(mPlotMin, mKnk, mBelwKnkPts)\n",
    "mAbveKnk = np.linspace(mKnk, mPlotMax, mAbveKnkPts)\n",
    "mFullPts = np.linspace(mPlotMin, mPlotMax, mBelwKnkPts+mAbveKnkPts)\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "cTopMult = 1.12\n",
    "plt.plot(mFullPts, soln.cFunc(mFullPts), color=\"black\")\n",
    "plt.plot(mBelwKnk, cFunc_Uncnst(mBelwKnk), color=\"black\", linestyle=\"--\")\n",
    "plt.plot(mAbveKnk, cFunc_Uncnst(mAbveKnk), color=\"black\", linewidth=2.5)\n",
    "plt.plot(mBelwKnk, cFunc_TopBnd(mBelwKnk), color=\"black\", linewidth=2.5)\n",
    "plt.plot(mAbveKnk, cFunc_TopBnd(mAbveKnk), color=\"black\", linestyle=\"--\")\n",
    "plt.plot(mBelwKnk, cFunc_BotBnd(mBelwKnk), color=\"black\", linewidth=2.5)\n",
    "plt.plot(mAbveKnk, cFunc_BotBnd(mAbveKnk), color=\"black\", linewidth=2.5)\n",
    "plt.tick_params(labelbottom=False, labelleft=False, left='off',\n",
    "                right='off', bottom='off', top='off')\n",
    "plt.xlim(mPlotMin, mPlotMax)\n",
    "plt.ylim(mPlotMin, cTopMult*cFunc_Uncnst(mPlotMax))\n",
    "plt.text(mPlotMin, cTopMult*cFunc_Uncnst(mPlotMax)+0.05, \"$c$\", fontsize=22)\n",
    "plt.text(mPlotMax+0.1, mPlotMin, \"$m$\", fontsize=22)\n",
    "plt.text(2.5, 1, r'$c(m)$', fontsize=22, fontweight='bold')\n",
    "upper_upper_bound_m = 4.6\n",
    "\n",
    "if latexExists:\n",
    "    upper_upper_bound_m_lbl = r'$\\leftarrow \\overline{\\overline{c}}(m)= \\overline{\\MPC}m = (1-\\UnempPrb^{1/\\CRRA}\\pmb{\\text{\\TH}}_{\\mathsf{R}})m$'\n",
    "else:\n",
    "    upper_upper_bound_m_lbl = r'$\\overline{\\overline{c}}(m)= \\overline{\\kappa}m = (1-\\wp^{1/\\rho}$'+Thorn+r'$_{\\mathsf{R}})m$'\n",
    "#    upper_upper_bound_m_lbl = r'$\\overline{\\overline{c}}(m)= \\overline{\\kappa}m = (1-\\wp^{1/\\rho}$'+   ''+r'$_{\\mathsf{R}})m$'\n",
    "    \n",
    "plt.text(upper_upper_bound_m+0.6, cFunc_TopBnd(upper_upper_bound_m+0.5), \n",
    "             upper_upper_bound_m_lbl,\n",
    "             fontsize=22, fontweight='bold')\n",
    "\n",
    "upper_bound_m = 12\n",
    "upper_bound_m_lbl=r'Upper Bound $ = $ Min $[\\overline{\\overline{c}}(m),\\overline{c}(m)]$'\n",
    "plt.text(upper_bound_m, cFunc_Uncnst(upper_bound_m)-0.3, upper_bound_m_lbl, fontsize=22, fontweight='bold')\n",
    "plt.text(8, 0.9, cMinLabel, fontsize=22, fontweight='bold')\n",
    "lower_unc_bound_m = 1.7\n",
    "lower_unc_bound_c = cFunc_Uncnst(lower_unc_bound_m)-0.2\n",
    "plt.text(lower_unc_bound_m, lower_unc_bound_c-0.2, cMaxLabel, fontsize=22, fontweight='bold')\n",
    "plt.arrow(2.45, 1.05, -0.5, 0.02, head_width=0.05, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(lower_unc_bound_m, lower_unc_bound_c, -0.5, 0.1, head_width=0.05, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(upper_bound_m, cFunc_Uncnst(upper_bound_m)-0.2, -0.8, 0.05, head_width=0.1, width=0.015,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "unconst_m = 4.5\n",
    "plt.arrow(14, 0.70, 0.5, -0.1, head_width=0.05, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "\n",
    "makeFig('cFuncBounds')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86734840",
   "metadata": {},
   "source": [
    "### [Upper and Lower Limits of the Marginal Propensity to Consume](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#MPCLimits)\n",
    "\n",
    "The paper shows that as $m_{t}~\\uparrow~\\infty$ the consumption function in the presence of risk gets arbitrarily close to the perfect foresight consumption function.  Defining $\\tilde{κ}$\n",
    "as the perfect foresight model's MPC, this implies that $\\lim_{m_{t}~\\uparrow~\\infty} c^{\\prime}(m) = \\tilde{\\kappa}$.\n",
    "\n",
    "The paper also derives an analytical limit $\\bar{\\MPC}$ for the MPC as $m$ approaches 0., its bounding value.  Strict concavity of the consumption function implies that the consumption function will be everywhere below a function $\\bar{\\MPC}m$, and strictly declining everywhere.  The last figure plots the MPC between these two limits."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c09778",
   "metadata": {},
   "source": [
    "`# Make and plot figure showing the upper and lower limits of the MPC:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64eeb897",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "lines_to_next_cell": 2,
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The last figure shows the upper and lower limits of the MPC\n",
    "\n",
    "mPlotMin = 0\n",
    "mPlotMax = 8\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "# Set the plot range of m\n",
    "m = np.linspace(0.001, mPlotMax, mPts)\n",
    "\n",
    "# Use the HARK method derivative to get the derivative of cFunc, and which constitutes the MPC\n",
    "MPC = soln.cFunc.derivative(m)\n",
    "\n",
    "kappaDef = r'$\\tilde{\\kappa}\\equiv(1-\\pmb{\\text{\\TH}}_{\\mathsf{R}})$'\n",
    "if not latexExists:\n",
    "    kappaDef = r'κ̲$\\equiv(1-$'+Thorn+'$_{\\mathsf{R}})$'\n",
    "\n",
    "plt.plot(m, MPC, color='black')\n",
    "plt.plot([mPlotMin, mPlotMax], [mpc_Max, mpc_Max], color='black')\n",
    "plt.plot([mPlotMin, mPlotMax], [mpc_Min, mpc_Min], color='black')\n",
    "plt.xlim(mPlotMin, mPlotMax)\n",
    "plt.ylim(0, 1)  # MPC bounds are between 0 and 1\n",
    "\n",
    "if latexExists:\n",
    "    plt.text(1.5, 0.6, r'$\\MPC(m) \\equiv c^{\\prime}(m)$', fontsize=26, fontweight='bold')\n",
    "    plt.text(5, 0.87, r'$(1-\\UnempPrb^{1/\\CRRA}\\pmb{\\text{\\TH}}_{\\mathsf{R}})\\equiv \\overline{\\MPC}$',\n",
    "             fontsize=26, fontweight='bold')  # Use Thorn character\n",
    "else:\n",
    "    plt.text(1.5, 0.6, r'$\\kappa(m) \\equiv c^{\\prime}(m)$', fontsize=26, fontweight='bold')\n",
    "    plt.text(5, 0.87, r'$(1-\\wp^{1/\\rho}$'+Thorn+'$_{R})\\equiv \\bar{\\kappa}$',\n",
    "             fontsize=26, fontweight='bold')  # Use Phi instead of Thorn (alas)\n",
    "\n",
    "plt.text(0.5, 0.07, kappaDef, fontsize=26, fontweight='bold')\n",
    "plt.text(mPlotMax+0.05, mPlotMin, \"$m$\", fontsize=26)\n",
    "plt.arrow(1.45, 0.61, -0.4, mPlotMin, head_width=0.02, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(2.2, 0.07, 0.2, -0.01, head_width=0.02, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "plt.arrow(4.95, 0.895, -0.2, 0.03, head_width=0.02, width=0.001,\n",
    "          facecolor='black', length_includes_head='True')\n",
    "\n",
    "makeFig('MPCLimits')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43b5b93c",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "[Two tables in the paper](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#Factors-Defined-And-Compared) summarize the various definitions, and then articulate conditions required for the problem to have a nondegenerate solution.  Among the nondegenerate cases, the most interesting result is that if the Growth Impatience Condition holds there will be a target level of wealth."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cf64536",
   "metadata": {
    "heading_collapsed": "true",
    "tags": []
   },
   "source": [
    "### Appendix: Options for Interacting With This Notebook <a id='optionsForInstalling'></a>\n",
    "\n",
    "1. [View (static version)](https://nbviewer.org/github/econ-ark/BufferStockTheory/blob/master/BufferStockTheory.ipynb)\n",
    "1. [Launch Online Interactive Version](https://econ-ark.org/materials/bufferstocktheory?launch)\n",
    "1. For fast (local) execution, install [econ-ark](http://github.com/econ-ark) on your computer ([QUICK START GUIDE](https://github.com/econ-ark/HARK/blob/master/README.md)) then follow these instructions to retrieve the full contents of the `BufferStockTheory` [REMARK](https://github.com/econ-ark/BufferStockTheory):\n",
    "   1. At a command line, change the working directory to the one where you want to install\n",
    "       * On unix, if you install in the `/tmp` directory, the installation will disappear after a reboot:\n",
    "       * `cd /tmp`\n",
    "   1. `git clone https://github.com/econ-ark/BufferStockTheory`\n",
    "   1. `cd BufferStockTheory`\n",
    "   1. `jupyter lab BufferStockTheory.ipynb`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c32ea74",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Appendix: Perfect foresight agent failing both the FHWC and RIC\n",
    "\n",
    "An appendix shows the solution for the problem of a perfect foresight consumer whose parameters fail to satisfy both the FHWC and the RIC\n",
    "\n",
    "[Perfect Foresight Liquidity Constrained Solution](https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#ApndxLiqConstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "081ea8bd",
   "metadata": {
    "pycharm": {
     "is_executing": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "PFGICRawHoldsFHWCFailsRICFails_par = deepcopy(init_perfect_foresight)\n",
    "\n",
    "# Replace parameters.\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['Rfree'] = 0.98\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['DiscFac'] = 1.0\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['PermGroFac'] = [0.99]\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['CRRA'] = 2\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['BoroCnstArt'] = 0.0\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['T_cycle'] = 1  # No seasonal cycles\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['T_retire'] = 0\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['cycles'] = 400  # This many periods\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['MaxKinks'] = 400\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['quiet'] = False\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['BoroCnstArt'] = 0.0  # Borrowing constraint\n",
    "PFGICRawHoldsFHWCFailsRICFails_par['LivPrb'] = [1.0]\n",
    "\n",
    "# Create the agent\n",
    "HWRichButReturnPatientPFConstrainedAgent = \\\n",
    "    PerfForesightConsumerType(**PFGICRawHoldsFHWCFailsRICFails_par,\n",
    "                              quietly=True\n",
    "                              )\n",
    "# Solve and report on conditions\n",
    "this_agent = HWRichButReturnPatientPFConstrainedAgent\n",
    "this_agent.solve(quietly=False, messaging_level=logging.DEBUG)\n",
    "\n",
    "# Plot\n",
    "mPlotMin, mPlotMax = 1, 9.5\n",
    "plt.figure(figsize=(8, 4))\n",
    "m_grid = np.linspace(mPlotMin, mPlotMax, 500)\n",
    "plt.plot(m_grid-1, this_agent.solution[0].cFunc(m_grid), color=\"black\")\n",
    "plt.text(mPlotMax-1+0.05, 1, r\"$b$\", fontsize=26)\n",
    "plt.text(mPlotMin-1, 1.017, r\"$c$\", fontsize=26)\n",
    "plt.xlim(mPlotMin-1, mPlotMax-1)\n",
    "plt.ylim(mPlotMin, 1.016)\n",
    "\n",
    "makeFig('PFGICRawHoldsFHWCFailsRICFails')"
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "ExecuteTime,collapsed,tags,pycharm,jupyter,slideshow,jp-MarkdownHeadingCollapsed,heading_collapsed,-autoscroll",
   "cell_metadata_json": true,
   "encoding": "# -*- coding: utf-8 -*-",
   "formats": "ipynb,py:percent",
   "notebook_metadata_filter": "all,-widgets,-varInspector"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.10"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": false,
   "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
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}