{ "cells": [ { "cell_type": "markdown", "id": "f5e7b1d0", "metadata": { "id": "f5e7b1d0" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "id": "7735eea6", "metadata": {}, "source": [ "# Uncertain Expansion Example Notebook" ] }, { "cell_type": "markdown", "id": "75201d8b", "metadata": {}, "source": [ "# 1 Preliminaries \n", "\n", "## 1.1 Model Setup\n", "The general structure for models to be solved using the expansion code can be written as:\n", "```{math}\n", ":label: triangle\n", "\\begin{align}\n", "X_{t+1} \\left( \\mathsf{q} \\right) = & \\hspace{.2cm} \\psi^x \\left[D_t \\left( \\mathsf{q} \\right), X_{t} \\left( \\mathsf{q} \\right), {\\sf q} W_{t+1}, {\\sf q} \\right], \\cr\n", "\\log G_{t+1} \\left( \\mathsf{q} \\right) - \\log G_t \\left( \\mathsf{q} \\right) = & \\hspace{.2cm} \\psi^g \\left[ D_t \\left( \\mathsf{q} \\right), X_{t} \\left( \\mathsf{q},\n", " \\right), {\\sf q} W_{t+1}, {\\sf q} \\right], \\cr\n", "{\\widehat C}_t \\left( \\mathsf{q} \\right) = & \\hspace{.2cm} \\kappa \\left[D_t \\left( \\mathsf{q} \\right), X_{t} \\left( \\mathsf{q} \\right) \\right] + {\\widehat G}_t \\left( \\mathsf{q} \\right).\n", "\\end{align}\n", "```\n", "In addition, there are a set of first-order conditions and co-state equations detailed in Chapter 8 of the book. These are compiled automatically by the code.\n", "\n", "\n", "## 1.2 Inputs\n", "\n", "The `Expansion Suite` uses the function `uncertain_expansion` to approximate a solution to the above system locally. The user must specify several sets of inputs. Define the relevant variables:\n", "\n", "```{list-table}\n", ":header-rows: 1\n", "\n", "* - Input\n", " - Description\n", " - Notation in text\n", "* - `control_variables`\n", " - Variables chosen by the decision-maker at time $t$\n", " - $D_t$\n", "* - `state_variables`\n", " - Variables that describe the current state of the system\n", " - $X_t$\n", "* - `shock_variables`\n", " - Variables representing different entries of the Brownian motion variable\n", " - $W_t$\n", "```\n", "The $t+1$ variables will be automatically created from this. For example, if a state variable is inputted as `Z_t`, an additional state variable `Z_tp1` will be automatically generated. \n", "We also need to define the equilibrium conditions:\n", "```{list-table}\n", ":header-rows: 1\n", "\n", "* - Input\n", " - Description\n", " - Notation in text\n", "* - `kappa`\n", " - Log share of capital not allocated to consumption\n", " - $\\kappa(X_t(q),D_t(q))$\n", "* - `growth`\n", " - Law of motion for $\\hat{G}_{t+1}-\\hat{G}_t$\n", " - $\\psi^g(D_t(q),X_t(q),qW_{t+1},q)$\n", "* - `state_equations`\n", " - Law of motion for state variables\n", " - $\\psi^x(D_t(q),X_t(q),qW_{t+1},q)$\n", "```\n", "The remaining equilibrium conditions will be automatically computed by the code. The user must also define a list of parameters and their corresponding values. This can be done by specifying pairs of inputs such as `beta = 0.99` or `gamma = 1.01` within the body of the function `create_args`. \n", "\n", "Note that the user must define the variables and parameters *before* defining the equations. Make sure that the **equations use the same expressions for variables and parameters** as previously defined by the user. \n", "\n", "The output is of class `ModelSolution`, which stores the coefficients for the linear-quadratic approximation for the jump and state variables; continuation values; consumption growth; and log change of measure, as well as the steady-state values of each variables. \n", "\n", "\n", "
" ] }, { "cell_type": "markdown", "id": "f92a0d85", "metadata": {}, "source": [ "# 2 Example\n", "We will now walk through the computation using the example above. Begin by installing the following libraries and downloading `RiskUncertaintyValue`, which contains the functions required to solve the model:" ] }, { "cell_type": "code", "execution_count": 23, "id": "f0d30383", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fatal: destination path 'RiskUncertaintyValue' already exists and is not an empty directory.\n" ] }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import os\n", "import sys\n", "import sympy as sp\n", "workdir = os.getcwd()\n", "!git clone https://github.com/lphansen/RiskUncertaintyValue \n", "workdir = os.getcwd() + '/RiskUncertaintyValue_automatic' \n", "sys.path.insert(0, workdir+'/src') \n", "import numpy as np\n", "import seaborn as sns\n", "import autograd.numpy as anp\n", "from scipy import optimize\n", "np.set_printoptions(suppress=True)\n", "np.set_printoptions(linewidth=200)\n", "from IPython.display import display, HTML\n", "from BY_example_sol import disp\n", "display(HTML(\"\"))\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", "import matplotlib.pyplot as plt\n", "from scipy.stats import norm\n", "\n", "from lin_quad import LinQuadVar\n", "from lin_quad_util import E, concat, next_period, cal_E_ww, lq_sum, N_tilde_measure, E_N_tp1, log_E_exp, kron_prod, distance\n", "from utilities import mat, vec, sym\n", "from uncertain_expansion import uncertain_expansion, generate_symbols_and_args, compile_equations, get_parameter_value\n", "from elasticity import exposure_elasticity, price_elasticity\n", "from plot import plot_exposure_elasticity, plot_price_elasticity\n", "np.set_printoptions(suppress=True)\n", "import pickle\n", "import pandas as pd\n", "from scipy.optimize import fsolve\n", "import sympy as sp" ] }, { "cell_type": "markdown", "id": "bd7ccfd2", "metadata": {}, "source": [ "## 2.1 Parameters\n", "Use the following function to define and set the values for your parameters." ] }, { "cell_type": "code", "execution_count": 24, "id": "bce0ecbf", "metadata": {}, "outputs": [], "source": [ "def create_args():\n", " # Define parameters here\n", " sigma_k1 = 0.92 * anp.sqrt(12)\n", " sigma_k2 = 0.4 * anp.sqrt(12)\n", " sigma_k3 = 0.0\n", " sigma_z1 = 0.0\n", " sigma_z2 = 5.7 * anp.sqrt(12)\n", " sigma_z3 = 0.0\n", " sigma_y1 = 0.0\n", " sigma_y2 = 0.0\n", " sigma_y3 = 0.00031 * anp.sqrt(12)\n", " \n", " # Base parameters\n", " delta = 0.01\n", " a = 0.0922\n", " epsilon = 1.0\n", " gamma = 8.0 #Do not change this name\n", " rho = 1.5 #Do not change this name\n", " beta = anp.exp(-epsilon * delta) #Do not change this name\n", " \n", " # Capital evolution parameters\n", " phi_1 = 1 / 8\n", " phi_2 = 8.0\n", " beta_k = 0.04\n", " alpha_k = 0.04\n", " \n", " # Other states\n", " beta_z = 0.056\n", " beta_2 = 0.194\n", " mu_2 = 6.3 * (10**(-6))\n", " \n", " # Return as a dictionary\n", " return locals()\n", "\n" ] }, { "cell_type": "markdown", "id": "34fc3cb5", "metadata": {}, "source": [ "## 2.2 Variables\n", "Define your variables as below. You may only have one growth variable and one perturbation variable. Apart from this, you may add more variables to the list as you wish." ] }, { "cell_type": "code", "execution_count": 25, "id": "7615f2d0", "metadata": {}, "outputs": [], "source": [ "# Define variable names\n", "control_variables = [\"imk_t\"]\n", "state_variables = [\"Z_t\", \"Y_t\"]\n", "growth_variables = [\"log_gk_t\"]\n", "perturbation_variable = [\"q_t\"]\n", "shock_variables = [\"W1_t\", \"W2_t\", \"W3_t\"]" ] }, { "cell_type": "markdown", "id": "2b4da5f2", "metadata": {}, "source": [ "The user does not need to change the following code, which creates symbols for the defined parameters and variables. " ] }, { "cell_type": "code", "execution_count": 26, "id": "152ab471", "metadata": {}, "outputs": [], "source": [ "parameter_names, args = generate_symbols_and_args(create_args)\n", "globals().update(parameter_names)\n", "variables = control_variables + state_variables + growth_variables + perturbation_variable + shock_variables\n", "variables_tp1 = [var + \"p1\" for var in variables]\n", "symbols = {var: sp.Symbol(var) for var in variables + variables_tp1}\n", "globals().update(symbols) " ] }, { "cell_type": "markdown", "id": "a701f77b", "metadata": {}, "source": [ "## 2.3 Define Equilibrium Conditions\n", "Ensure that you use the same names for your variables and parameters from before. You must have one output constraint and one capital growth equation, but you may add as many state equations as you wish. The first-order conditions and co-state equations will be automatically handled and do not need to be specified." ] }, { "cell_type": "code", "execution_count": 27, "id": "b4433e3b", "metadata": {}, "outputs": [], "source": [ "# Output constraint\n", "kappa = sp.log(a - imk_t)\n", "\n", "# Capital growth equation\n", "growth = epsilon * (phi_1 * sp.log(1. + phi_2 * imk_t) - alpha_k + beta_k * Z_t \\\n", " - q_t**2 * 0.5 * (sigma_k1**2 + sigma_k2**2 + sigma_k3**2) * sp.exp(Y_t)) \\\n", " + sp.sqrt(epsilon) * sp.exp(0.5 * Y_t) * (sigma_k1 * W1_tp1 + sigma_k2 * W2_tp1 + sigma_k3 * W3_tp1) \n", "\n", "# Technology growth equation\n", "technology_growth = Z_tp1 - Z_t + epsilon * beta_z * Z_t \\\n", " - sp.sqrt(epsilon) * sp.exp(0.5 * Y_t) * (sigma_z1 * W1_tp1 + sigma_z2 * W2_tp1 + sigma_z3 * W3_tp1)\n", "\n", "# Volatility growth equation\n", "volatility_growth = Y_tp1 - Y_t + epsilon * beta_2 * (1 - mu_2 * sp.exp(-Y_t)) \\\n", " + q_t**2 * 0.5 * (sigma_y1**2 + sigma_y2**2 + sigma_y3**2) * sp.exp(-Y_t) * epsilon \\\n", " - sp.exp(-0.5 * Y_t) * (sigma_y1 * W1_tp1 + sigma_y2 * W2_tp1 + sigma_y3 * W3_tp1) * sp.sqrt(epsilon)\n", "\n", "# State equations\n", "state_equations = [technology_growth, volatility_growth]\n" ] }, { "cell_type": "markdown", "id": "bd416d24", "metadata": {}, "source": [ "## 2.4 Code Settings\n", "You may additionally set the following:\n", "* **Initial guess** for steady-state variables. This must have the same length as the number of variables\n", "* **Recursive terms initialization**. These are initializations for terms like $\\log N_t^*$ and $\\hat{R}_t-\\hat{V}_t$, which may be loaded from a previous solution.\n", "* **Convergence tolerance**. How small the maximum error across the approximated terms must be before the algorithm is considered to have converged.\n", "* **Maximum iterations**. The maximum number of iterations for the algorithm can take.\n", "* **Save location**. Save the model solution to this location so that it can be accessed later." ] }, { "cell_type": "code", "execution_count": 28, "id": "c98abc6e", "metadata": {}, "outputs": [], "source": [ "initial_guess = np.concatenate([np.array([-2.1968994 , -4.123193 , anp.exp(-2.57692626)]),np.ones(3),np.array([0.01937842, 0. , -11.97496092])])\n", "savepath='output/res.pkl'\n", "savepath = None\n", "init_util = None\n", "iter_tol = 1e-5\n", "max_iter = 50\n", "\n", "#Code for loading pre-solution\n", "# with open(savepath,'rb') as f:\n", "# preload = pickle.load(f)\n", "# init_util = preload['util_sol']" ] }, { "cell_type": "markdown", "id": "d24a71a4", "metadata": {}, "source": [ "## 2.5 Run Code\n", "You are now ready to run the function `uncertain_expansion`. You do not need to change anything in the following code." ] }, { "cell_type": "code", "execution_count": 29, "id": "696cb7ad", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-beta*exp(rmv_t*(1 - rho)) - (1 - beta)*exp(log_cmk_t*(1 - rho))*exp(-vmk_t*(1 - rho)) + 1.0, log_cmk_t - log(a - imk_t), beta*epsilon*mg_tp1*phi_1*phi_2*exp(rmv_t*(1 - rho))/(imk_t*phi_2 + 1.0) - (1 - beta)*exp(log_cmk_t*(1 - rho))*exp(-vmk_t*(1 - rho))/(a - imk_t), beta*(beta_k*epsilon*mg_tp1 + m0_tp1*(beta_z*epsilon - 1))*exp(rmv_t*(1 - rho)) - m0_t, beta*(-0.5*sqrt(epsilon)*m0_tp1*(W1_tp1*sigma_z1 + W2_tp1*sigma_z2 + W3_tp1*sigma_z3)*exp(0.5*Y_t) + m1_tp1*(beta_2*epsilon*mu_2*exp(-Y_t) + 0.5*sqrt(epsilon)*(W1_tp1*sigma_y1 + W2_tp1*sigma_y2 + W3_tp1*sigma_y3)*exp(-0.5*Y_t) - 0.5*epsilon*q_t**2*(sigma_y1**2 + sigma_y2**2 + sigma_y3**2)*exp(-Y_t) - 1) + mg_tp1*(0.5*sqrt(epsilon)*(W1_tp1*sigma_k1 + W2_tp1*sigma_k2 + W3_tp1*sigma_k3)*exp(0.5*Y_t) - 0.5*epsilon*q_t**2*(sigma_k1**2 + sigma_k2**2 + sigma_k3**2)*exp(Y_t)))*exp(rmv_t*(1 - rho)) - m1_t, 1.0*beta*mg_tp1*exp(rmv_t*(1 - rho)) - mg_t + 1.0*(1 - beta)*exp(log_cmk_t*(1 - rho))*exp(-vmk_t*(1 - rho)), -sqrt(epsilon)*(W1_tp1*sigma_k1 + W2_tp1*sigma_k2 + W3_tp1*sigma_k3)*exp(0.5*Y_t) - epsilon*(Z_t*beta_k - alpha_k + phi_1*log(imk_t*phi_2 + 1.0) - 0.5*q_t**2*(sigma_k1**2 + sigma_k2**2 + sigma_k3**2)*exp(Y_t)) + log_gk_tp1, Z_t*beta_z*epsilon - Z_t + Z_tp1 - sqrt(epsilon)*(W1_tp1*sigma_z1 + W2_tp1*sigma_z2 + W3_tp1*sigma_z3)*exp(0.5*Y_t), -Y_t + Y_tp1 + beta_2*epsilon*(-mu_2*exp(-Y_t) + 1) - sqrt(epsilon)*(W1_tp1*sigma_y1 + W2_tp1*sigma_y2 + W3_tp1*sigma_y3)*exp(-0.5*Y_t) + 0.5*epsilon*q_t**2*(sigma_y1**2 + sigma_y2**2 + sigma_y3**2)*exp(-Y_t)]\n", "[rmv_t, vmk_t, log_cmk_t, imk_t, m0_t, m1_t, mg_t, log_gk_t, Z_t, Y_t, q_t, W1_t, W2_t, W3_t]\n", "Iteration 1: error = 0.150951282\n", "Iteration 2: error = 0.0749792416\n", "Iteration 3: error = 0.0436581537\n", "Iteration 4: error = 0.0203399368\n", "Iteration 5: error = 0.00917550775\n", "Iteration 6: error = 0.00411690549\n", "Iteration 7: error = 0.00184549174\n", "Iteration 8: error = 0.000827151037\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.\n", "Iteration 9: error = 0.000370719802\n", "Iteration 10: error = 0.000166151679\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.\n", "Iteration 11: error = 7.4466911e-05\n", "Iteration 12: error = 3.33750469e-05\n", "Iteration 13: error = 1.49582373e-05\n", "Iteration 14: error = 6.70407636e-06\n" ] } ], "source": [ "ModelSol = uncertain_expansion(control_variables, state_variables, shock_variables, variables, variables_tp1,\n", " kappa, growth, state_equations, initial_guess, parameter_names,\n", " args, approach = '1', init_util = init_util, iter_tol = iter_tol, max_iter = max_iter,savepath=savepath)" ] }, { "cell_type": "markdown", "id": "a9c651a6", "metadata": {}, "source": [ "## 2.6 Plot Elasticities" ] }, { "cell_type": "markdown", "id": "4ae75fe6", "metadata": {}, "source": [ "First, if you did not run the code above, you can load a pre-solved solution by specifying `save_path` as follows:" ] }, { "cell_type": "code", "execution_count": 10, "id": "f790bb90", "metadata": {}, "outputs": [], "source": [ "savepath='output/res.pkl'\n", "with open(savepath,'rb') as f:\n", " ModelSol = pickle.load(f)" ] }, { "cell_type": "markdown", "id": "c07fdccb", "metadata": {}, "source": [ "We use `plot_exposure_elasticity` to plot exposure elasticities.\n", "* `quantile` specifies the quantiles to be plotted\n", "* `T` specifies the number of periods (using the time-unit that you specified the parameters in)\n", "* (optional) The `ylim` parameters are for setting the upper limits for the y axes" ] }, { "cell_type": "code", "execution_count": 30, "id": "799f0580", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "quantile = [0.1,0.5,0.9]\n", "T = 40\n", "ylim1, ylim2 = 0.06, 0.06\n", "plot_exposure_elasticity(ModelSol,T,quantile,'year',ylim1, ylim2)" ] }, { "cell_type": "markdown", "id": "53fb286c", "metadata": {}, "source": [ "Similarly we can plot the price elasticities using `price_elasticity`." ] }, { "cell_type": "code", "execution_count": 9, "id": "01138d29", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABh0AAAL+CAYAAAC5adVJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADW0klEQVR4nOzdd3RUdf7/8deU9BBI6C30hN6LFBFQEEVZFwsIAiLCCovKKj+/YmMVXBREUVQQRVZFRFfFsoqICisoIL333jEQCOmZmfv7YzIDQxJIcieV5+OcOXfmzq3vzMDcz+t+7rUYhmEIAAAAAAAAAADAJGtRbwAAAAAAAAAAACgdCB0AAAAAAAAAAIBfEDoAAAAAAAAAAAC/IHQAAAAAAAAAAAB+QegAAAAAAAAAAAD8gtABAAAAAAAAAAD4BaEDAAAAAAAAAADwC0IHAAAAAAAAAADgF4QOAAAAAAAAAADALwgdABSa//f//p9iY2O1du3aLO8lJiaqadOmio2N1ezZs7Odv3fv3mrevLlSU1P15ZdfKjY2Vl9++aXPNKdPn1ZycrL39ZNPPqnY2FgdPXrUvztTSl24cEFnz57N1bSHDh0qkG24dLlHjx5VbGysnnzyyQJZV0l2+d9qxowZio2N1erVqwt0vYW1npzExsZq8ODBRbJuAADgi9/3xR+/72FGUR1zmLF69WrFxsZqxowZRbL+wYMHKzY2tkjWDRQnhA4ACk2nTp0kSevXr8/y3qpVq5SRkaGAgAAtX748y/tnzpzRgQMH1LZtWwUHB6tdu3aaMmWK2rVr553mq6++0s0335zrH9XwtWLFCvXq1Ut79uy56rTvvvuu+vTp49f1JyYmauDAgZo5c6Zfl1sa5eVvBQAAUFD4fV+88fseZmT3+enZs6emTJmievXqFeGWASgJ7EW9AQCuHVc6KPn1118VGhqqm266SYsWLVJiYqLCw8O9769Zs0aS1LlzZ0lSzZo1VbNmTZ9lrFq1yucsKOTNhg0bcn1A9+uvvyojI8Ov6z937pzWrVun6Ohovy63NMrL3woAAKCg8Pu+eOP3PczI7vPTsGFDNWzYsIi2CEBJQk8HAIWmcuXKqlu3rjZs2CDDMHzeW7Fihdq0aaNu3bopIyNDq1at8nnf02Xbc1ACAAAAoGjx+x4AAGSH0AFAoerYsaPOnTunffv2ecft27dPx44dU5cuXdSpUydZrVb9+uuvPvOtWbNGFStW9J5Vcfk1X3v06KGFCxdKkm688cYs13w/duyYHnvsMbVv314tW7bUgAED9Ntvv111ez3r+e6773TXXXepadOm6t27t9LS0iRJ+/fv12OPPaaOHTuqadOm6tWrl6ZPn67U1FSf5Rw5ckRjx45V9+7d1bRpU91www0aP368jh8/7p3Gc+3JL7/8Uq+99pq6dOmili1b6u6779aSJUuybFtaWpreeust9e7dW02bNlWHDh30yCOPaPfu3VmmjYuL0/PPP6/u3burefPm6tmzp6ZNm6bExERJ7utOvvnmm5KkIUOGqEePHjnWJDY2Vn/88Yf3+aXXY923b58ee+wxderUSU2bNtWNN96ol156SefPn79qnW+88UZJ0sKFC7O9Tuinn36q2267TU2bNtX111+vSZMmKSkpKcuyvv32W91zzz1q2bKlWrVqpUGDBumXX3654vov9d///lf9+vVTy5Ytdf311+uVV17Rf/7zH59t8vyt5s+frwceeEBNmzZV165dderUqVzVwTAMdenSRbfeeqvPuk+dOqXY2NgsB98XLlxQkyZN9Mwzz1z1bxUfH6/nnntOnTp1UvPmzXXHHXfov//9b672feXKlRo6dKg6duyoZs2a6ZZbbsn285yX9Zw8eVLPPPOMunbt6q3TM888o5MnT2aZ9uDBg/q///s/denSRS1atNCtt96q2bNnKz09PcdtzsjI0JgxYxQbG+utCwAAKDz8vuf3fU51Li6/73///XcNHz5c7du3V5s2bdS/f38tXrzYZxqn06mPPvpIf/nLX9S8eXO1bt1aQ4YM0f/+978s++Wp18svv6wbbrjB+xn64IMPsqz7448/Vr9+/dS6dWu1atVK99xzT5b7luR0D4Ds7k3Qo0cP/e1vf9Nvv/2mAQMGqEWLFurUqZNefPFFpaena/Xq1d7x3bt31yuvvOLTg+XJJ59U48aNdfjwYY0YMUKtWrXSddddp8cff9znPik5fX5yuqfDN998o/79+6tly5Zq2bKl+vfvr6+//jrb/fnuu+80a9Ys9ezZU02bNlWPHj30+uuvy+FwZP3jXSY33zsPp9Opd955x2c9M2bMyNKj5/LvXfv27fXQQw9p48aNWZaZmJioadOmqVevXmrevLl69OihCRMm6M8//7zidr///vuKjY3ViBEjvP/WAKUdl1cCUKg6deqkjz/+WOvXr1f9+vUluc+CkqTrr79ekZGRaty4sXecJCUkJGj37t26/fbbc1zuU089pblz52rt2rUaP368GjRo4PP+Qw89pLZt2+qxxx7T6dOn9cEHH+hvf/ubFi5cmGXa7DzzzDO66aabdNdddyk5OVlBQUHavHmz7r//foWHh2vQoEGKiorSxo0bNWvWLK1cuVIffvihgoKClJCQoCFDhsjlcunee+9V+fLltWfPHs2fP1+rV6/W999/r+DgYO+63nzzTSUlJWnw4MEKDQ3VZ599pjFjxuiFF15Q//79JUnp6el64IEHtHHjRv3lL3/R/fffr1OnTmnBggW655579P7776t169aS3A3Zd955p+Lj43X33XerYcOG2r59u9577z1t2LBBH3zwgR566CGVLVtWS5Ys0UMPPaRmzZrlWIspU6Zo1qxZ2r9/v6ZMmeLtLr127VoNHz5cNptN9957r6pXr66NGzfq3//+t3755RctWLBAUVFR2S6zXbt2Gj9+vCZPnqy2bdvqnnvuUb169bwHd4sXL9ayZcs0cOBAVaxYUUuWLNFHH32k+Ph4TZs2zbucqVOn6r333lPnzp312GOPKS0tTd99951GjRql8ePH6/7777/i3/m9997T1KlT1aRJE40dO1YXLlzQvHnzcpx+6tSpateunZ599lmdPHlSlStXznUdunfvrs8++0wnTpxQ1apVJcl7veO4uDjt2bPH+9lcvny5HA6HevbsKbvdfsW/1fjx4xUbG6u///3vSkpK0ocffqjHH39cZcuW1fXXX5/jvmzcuFEjR45Uo0aNNGrUKAUFBem3337TzJkzdfDgQU2fPj3P69m3b58GDRqkxMRE3XPPPWrQoIF2796t//znP/r55581f/581alTR5K0c+dODRw4UIZhaMCAAapVq5ZWrVqladOmadeuXT5/Zw+Hw6HHHntMS5Ys0RNPPKHhw4df8e8LAAD8j9/3/L7PTnH5ff+f//xHzz77rKpXr677779fZcuW1ZdffqlHHnlEEydO1D333COXy6UxY8bol19+UYcOHfT4448rKSlJCxcu1MiRI/Xkk09q2LBhPssdP368QkNDNXToUNntds2fP1//+te/FB4erjvvvFOS9O9//1uTJ09Wnz59dM899ygjI0MLFy7U+PHjlZqaqoEDB15x23Oyfft2jRkzRgMGDNAdd9yhb7/9Vh9++KEOHjyodevWqX///vrrX/+qb7/9Vu+++64iIiI0cuRI7/yGYWjo0KGqWrWqHnvsMR09elQff/yxVq1apS+++EJVqlTJ0+dn4sSJmjdvnpo0aaIxY8ZIkr777js98cQT2rJli5555hmf6V999VUZhqH+/fsrIiJCX375pd5++21ZLBY98sgjOa4nr9+7Dz74QJGRkRowYIDCwsL05Zdf6s0331RGRoYee+wxSVJKSoqGDh2qTZs26aabbtLgwYMVFxenTz/9VIMGDdIrr7yiW265RZKUnJyse+65R/v379ftt9+uYcOG6fDhw5o3b57WrFmjzz77zOcSch5z587Vyy+/rF69emnatGkKDAzMxV8ZKAUMAChECQkJRqNGjYz/+7//844bPny4ccMNN3hfv/rqq0ZMTIyxd+9ewzAM4+effzZiYmKMr776yjvNF198YcTExBhffPGFd9z//d//GTExMcaRI0eyjHvqqad8tuPzzz83YmJijBkzZlxxez3rueuuuwyXy+Ud73K5jD59+hg33HCDER8f7zPPZ599ZsTExBizZ882DMMwFi1aZMTExBjfffedz3Rz5841brvtNmPLli2GYRjGqlWrjJiYGKNZs2bGwYMHvdNduHDB6Natm9G6dWvjwoULhmEYxrvvvmvExMQY33//vc8yT58+bXTo0MG49dZbveOeeOIJIyYmxvj11199pp02bZoRExNjLF261DAMw3jjjTeMmJgYY9WqVVesiWEYxn333WfExMR4XzudTqNnz55G06ZNvX+3y+vx5JNPXnGZR44cMWJiYnw+G55xzZo1Mw4cOOAdn5GRYdx4441GkyZNjLS0NMMwDGPTpk1GTEyM8c9//tNnuenp6cbgwYONJk2aGCdOnMhx/SdPnjSaNm1q9OvXz7tMwzCMQ4cOGc2bN/epjedv1a1bNyMlJSVfdVi6dKkRExNjfPbZZ95pxo4da3Tr1s2IiYkxPvjgA+/4xx9/3GjVqpV3u7L7W3nGDRs2zHA6nd7xK1euzFX9n3/+eSMmJsaIi4vzGT927Fijf//+Wdadm/UMGTLEiImJMX7//XefZa5YscKIiYkx7rvvPu+4QYMGGU2aNDF27NjhM+1jjz1mxMTEGLt37zYMw/DOl5GRYYwZM8aIjY015s2bd8V9AwAABYff9xfx+95XUf++v3DhgtGyZUujV69e3jobhmGkpKQYN910k9G5c2fD4XAYCxcu9G7npZ+JCxcuGL179zYaN25sHDp0yDCMi5+fvn37+hwzHD9+3IiNjTX69+/vHdenTx/jlltu8dmmpKQk47bbbjOeffZZ77jLa+/h+fy88cYb3nHdu3fP8tk7e/as0ahRIyMmJsZYvHixz/Y3adLEuPfee73jPN+f4cOHGw6Hwzt+yZIlWf6mVzrm8Ixbs2aNERMTYwwdOtRIT0/3Tuf5G8XExBirV6/22Z/OnTsb58+f96lJmzZtjC5dumSpwaXy+r3r1KmTcebMGe9058+fN1q3bm10797dO+7NN980YmJijNdff91nmZ7vXdu2bY2EhATDMAzj9ddfN2JiYoxPPvnEZ9oFCxYYMTEx3mOSS/+ec+fONWJiYozHH3/cyMjIuOL+AaUNl1cCUKjKlCmjJk2aeG82l5aWpjVr1vhcTqZLly6S3Jd6kdxdry0Wi6nrvfbr18/ndcuWLSVJp0+fztX83bt3l8Vi8b7etWuX9uzZoxtuuEEul0tnz571Prp3766goCBvl2nPWeyzZs3SL7/84r0Z3v33369vv/1WTZs29VnXHXfcoVq1anlfh4eHa+DAgUpMTNTvv/8uyX3mSEREhDp06OCzbpvNpq5du2rv3r3at2+fDMPQzz//rIYNG2Y5y33EiBH66quv1KFDh1zV4Eq2b9+uQ4cOqW/fvqpXr57Pe3fddZdq1aqlxYsXy+l05mv5bdq0Ue3atb2v7Xa7mjZtqoyMDJ07d06SuyaSdOutt/rU5MKFC7r11luVkZGhpUuX5riOn376Senp6Ro+fLjP2SfR0dHq27dvtvN06tTJ52yavNShY8eOCg0N9Z7153K5tHLlSt1+++2qWrWq9/PvdDq1fPly3XDDDbk6K+aOO+6Q1Xrxv/fcftarVKkiSXr++ee1fv1679/qtdde04IFC7Ks+2rrOXv2rFavXq2OHTuqY8eOPvN27txZHTt21B9//KEzZ87o7NmzWrt2rbp27ZrlxnTjx4/Xt99+6/Od8PRw+PHHH/Xkk09q0KBBVysLAAAoIPy+5/d9fhTG7/vff/9dycnJuvfee33OQA8ODtbs2bM1f/58Wa1W/fDDD5KksWPH+nwmwsPD9dBDD8nhcGS5HNMtt9zi8/u4atWqqlChguLi4rzjqlSpogMHDmj69Oney4+Fhobq22+/1QsvvJDHil0UGBionj17el9HRkaqfPnyWcaHh4crKirKewnYS40ZM0Y2m837+qabblL9+vW1ZMmSLPdnuZJFixZ5lxcQEOAdHxAQ4O218P333/vM0717d0VERHhfh4aGql69ejpz5swV15XX71337t19euJERESobt26Pv9G/PDDDwoNDdXf/vY3n3krVqyoIUOGKCEhwdsbfcmSJSpXrpzuvvtun2n/+te/6j//+Y/+8pe/+Iz39HS56aabNGXKFNntXGwG1xY+8QAKXadOnTRr1izFxcVpx44dSk1N9R6ISO4DhrCwMK1evVr33Xef1q5dq9jYWFWoUCHf66xYsaLP66CgIEm64rXirzT/gQMHJEkLFizQggULsp3n2LFjkqQWLVpo1KhRmj17tkaNGqWAgAC1aNFCXbt21R133KHKlSv7zJfd9Tzr1q0rSTp8+LB3/SkpKVkacy9ff1RUlC5cuJDlQEFyHyA2atQox/nzwrNd2XVlt1gsql+/vg4dOqT4+Ph8/R2zm8fT2O/5G3r+Jvfdd1+Oy/H8TbLjmd9T60tlV7/stiuvdejcubNWrlwpl8ulrVu3Kj4+Xh07dtTJkyf1888/y+l0av369Tp37pzPAcSVXP5ZvbxOORk8eLDWrVunxYsXa/HixSpTpozatWunHj166LbbblNISEie1nP06FEZhuG9zMLlGjRooJUrV+ro0aOy2WwyDCPbOleoUCFLndevX+8NPFavXn3VbvUAAKBg8fue3/d5VRi/7z33KMiuVp5LfErufQ0PD/eehHOpmJgYn2VdafsDAwPlcrm8r5966imNHj1aM2fO1MyZM1W5cmV17txZvXr1Urdu3XwCjrwoV66cTwO/5G7kr1ChQpZl2u32bEMEz35dqk6dOtq7d6/i4+NzvGzW5a70Oclr7a4WYOX1e5fTZ+zSezocPnxYtWrV8v77caXtP3r0qGJiYnzCGs+2N2/ePMv8kydPltVq1bZt25ScnJztpZeA0ozQAUCh69ixo2bNmqWNGzdq7dq1stls6tSpk/f9gIAAdejQQX/88YeSk5O1fft2DR061NQ6Lz0jOz8u/2Hh+TE5aNAg3XTTTdnOc+mZDGPHjtWgQYO0bNky/fbbb/rjjz+0du1azZo1S3PnzvWemSUp27PZPT/APMt0Op2qVauW/vnPf+a4zQ0bNvTejCu/P2j9xVOv/F6/8vL6Z8dTo7fffjtLA7mH5+yY7HgObrLbxux+hErK89kql9fhxhtv1JIlS7RlyxatXLlSwcHBatOmjU6dOqWvv/5aW7du1dKlSxUQEKCuXbvmah35/ayHhITonXfe0d69e7V06VKtWrVKK1eu1C+//KJ3331Xn332mcqVK5fr9XgObnL67F1aC8/N1HL7OQ0ICNCUKVO0dOlSffPNN/rqq690xx135GpeAADgf/y+5/d9XhXG7/vc1sowjByn8WzD5fuZm89f3bp19f3332vdunX69ddftWrVKn399df68ssv1atXL58bRF9p3Ze7PHDwyO1nwmKxZHsc46lXbv42HlfqFWGmdjnJy/cuN/uRl7+9w+HI0/duyJAhiomJ0TPPPKMXX3xRkydPzvW8QGlA6ACg0LVu3VrBwcHaunWr/vjjDzVr1kxly5b1maZLly765ZdftGjRIjkcDp8zpYqDGjVqeJ9fekAluX+AL168WDVr1pQk/fnnn9qzZ4/atm2ru+++W3fffbcMw9A333yjJ554Qu+//77eeOMN7/wHDx7Msr79+/dLkrcLco0aNRQXF6f27dtn+cG4fv16paSkKDg4WEFBQQoNDfWeJXSpuLg4vfDCC+rTp49uvvnmfNXBw7Ove/bsyfKeYRjat2+fwsPDfbrR+pvnb1KpUqUsNzo7dOiQ9u/fr9DQ0Bzn95zttH///iy9HbKrX3byWodu3brJZrNp+fLl+uOPP9SmTRsFBgZ6P1MrV67U0qVL1bFjxwI/M+bAgQM6c+aM2rZtq/r162vEiBFKS0vTSy+9pPnz5+u///3vFc8yu9yVauEZb7FYVLlyZe9Ba3Z13rlzp2bPnq3+/ft7LxXQqlUr3XrrrerYsaN+++03vfjii+rYsWOWs5sAAEDh4Pc9v+8Lgtnf9575Dxw4kOXz9s0332jlypUaO3asoqOjtX//fp08eTJLb4e9e/dKkqpVq5anbXc4HNq9e7fsdrvatWundu3aSZLOnDmj0aNH68cff9Tu3bt9zpxPTU31uXTrn3/+mad15pZhGDpy5EiWHiAHDhxQVFRUlu/ulXhuOu75Plwqv7XLSV6/d7nd/sOHDystLS3LiWaez75n+2vUqKGDBw/K5XL5BCcZGRkaN26cOnbsqAEDBnjHP/3005Lcl5f68ssvdfPNN6tbt2752XWgROKeDgAKXWBgoNq0aaNVq1Zp586d2R5weMZ9+umn3rO/r8bzH39erkGZX02bNlX16tW1cOFCb5dSj08//VRjx47VF198IUn64osvNGzYMP3000/eaSwWi1q3bi0p6xkYX3zxhfc6ppKUkJCgefPmKTIy0nsAdPPNNyshIUHvv/++z7ynTp3SqFGj9Pjjj8tqtcpms6l79+7atm2b1qxZ4zPtf/7zHy1evNhbN8/w0i7BObl82saNG6tmzZr65ptvvNcrvXR/Dh8+rF69el1xmZ465Gb92endu7ckacaMGT5nBWVkZGj8+PF66KGHsr2eqUevXr1kt9s1b94871k+kvu6wN9++22utiGvdYiMjFTr1q31008/aePGjd7u9JUqVVKDBg305Zdfav/+/VkurZSXv1VuTZw4Uffff7+OHz/uHRcUFOS9NmpezniSpKioKLVv314rV670Xr/ZY+XKlVq9erXat2+vqKgoVahQQS1bttSvv/6a5QB63rx5+u6771SmTJks64iMjNSzzz6rhIQE7496AABQ+Ph9z+/77BT17/tOnTopJCREn332mVJSUrzj09PTNXv2bP3yyy8qX768N6CZPn26z2ctOTlZs2fPls1my7H3S06cTqcGDx6sxx9/3OdyPuXLl/cGTZ76VKpUSZK0detW73Qul0vffPNNntaZF++9957P6++//14HDx5Unz59vONy8/nx1O7NN9/0OYZyOBx68803faYxK6/fu9y4+eablZycrHfeecdn/JkzZzRv3jyFhYV5/+266aabFB8fn+XvsmjRIv3www9KTU3Ndh0vvPCCQkND9cwzz+j8+fN53kagpKKnA4Ai0bFjR73yyiuSlO1BSa1atVSjRg1t2rRJXbp0yfHyNpfyXLPxvffe0/XXX5/nH4Z5YbPZNGnSJP3tb39Tv379NGDAAEVHR2vLli364osvFB0drdGjR0uS7r77bi1YsEBPP/20Nm7cqAYNGig+Pl6fffaZAgICNHjwYJ9lJycne5dpsVj06aefKj4+Xq+99pq3a+eIESO0dOlSTZs2TVu2bNF1112nhIQELViwQAkJCXrllVe8Z8mMGzdOq1ev1gMPPKB7771X9erV05YtW/Tll1+qW7duuvHGG33q98knn+j06dNZboR1Kc+0b7zxhtq3b69OnTpp0qRJGjlypO6++27de++9qlGjhjZv3qyFCxeqevXqGjdu3BVrGhkZKZvNpj/++EOfffZZnm8s2LFjR9111136/PPPdc899+jWW29VYGCgvvnmG23evFkDBw7M9lqbHtWrV9eoUaM0Y8YM3XvvverTp4+Sk5M1f/58703Krtad1vO5yEsdbrzxRr300kuSfM+q69Spkz744ANZrVb16NHDZ568/K1ya9SoUfrjjz80cOBA3XPPPapYsaIOHTqk+fPnq2rVqrr11lvzvMwJEyZo4MCBGjFihPr376/69etr7969+vTTT1WuXDlNmDDBO+2zzz6rwYMH6+6779agQYNUtWpVrVq1SosWLdK9996rxo0bZ7uOW265Rd99952WLFmi//znP1lu7AYAAAoHv+/5fX+5ov59X65cOT355JOaMGGC+vXrp7/+9a8KCQnR119/rT179ui1116T3W7XX/7yF/3www9auHChjh8/rhtvvFEpKSlauHChDh48qHHjxnl7fuRWUFCQRo4cqVdffVWDBg3SrbfeqpCQEG3cuFFff/21unfv7u1pcOedd+rrr7/WP/7xDw0dOlQhISH67rvvfIIqf/vuu+8UHx+v66+/XgcOHNAnn3yi6OhoPfzww95pcvP56dChg/r3769PP/1U99xzjze0+O6777Rt2zYNHDjQ28vDrLx+73Jj+PDhWrp0qd566y3t3r1bHTt21NmzZ/Xpp58qISFBU6ZM8famGTlypH766SeNHz9ea9euVdOmTb21a9KkiU8vh0vVrFlT//jHP/Tiiy9q4sSJ3n8ngdKO0AFAkfA0rkZEROT4Q7FLly5asGBBrrte33vvvfrjjz/0xRdfaNWqVQV6UCK59+Gzzz7TzJkz9cUXX+jChQuqUqWKBg4cqL/97W/em9OVL19eH330kWbOnKmffvpJn3zyiUJDQ9WmTRu9+uqrWfZ/2LBhcjqdev/995Wenq4WLVropZde8umuGhYWpvnz52v27Nn64YcftHTpUkVERKhRo0Z6+eWXdd1113mnrVatmr744gu98cYb+v7773X+/HnVqFFDDz/8sB544AHvGSx9+vTRkiVLtGzZMq1cuVI9e/bMsbvyiBEjtHv3br333nvatGmTOnXqpOuuu06fffaZ3n77bX3xxRdKTExUtWrV9MADD+ihhx66atfr4OBgjRs3TrNnz9bEiRP1z3/+03s5ndyaNGmSWrZsqU8//VQzZsyQzWZT7dq1NWnSJN11111XnX/MmDGqUKGC5s2bp1deeUWRkZG68847lZaWprlz5+bqmrV5rYMndChXrpxPw3rnzp31wQcfqGXLlllugpbd38qsdu3a6d///rfeeecdzZ8/X+fOnVOFChV022236e9//3ueull71K9fX19++aXeeustLV68WJ9++qkqVqyou+66S6NGjfK5HFLTpk31+eef64033tCCBQuUmpqqWrVqacKECerfv/8V1zNhwgT98ccfmjx5sjp16qTq1avneVsBAIA5/L7n9/3lisPv+wEDBqhq1ap67733NHPmTNlsNjVq1Ejvv/++NwSx2Wx6++239cEHH+irr77SK6+8opCQEDVr1kxPP/10ru+tdjnPZ+aTTz7RzJkzlZycrOjoaD3yyCMaPny4d7oOHTpo2rRpmjNnjl5//XVFRESoV69eGj58uDdA8rd33nlH77zzjl5++WWVLVtW/fv318MPP+zzmz+3xxwvvPCCmjdvrgULFuiNN96QzWZTw4YN9corr+j222/32zbn9XuXG6GhoZo3b55mz56tRYsWadmyZSpTpozatGmjBx980OceEWXKlNGCBQv01ltv6aefftJXX32lqlWratCgQRo1apTPpbEud9999+n777/Xt99+q5tvvtkvx29AcWcxCqOfIgDgqlavXq0hQ4ZozJgxPmeYoHAkJyfL6XRmexmfZ599Vp999pl+/vlnn+v9AgAAADnh9z2KmyeffFILFy7kuAZAgeOeDgAA6OLNz9566y2f8RcuXNDSpUtVsWJFzqAHAAAAAAC4imJ7eaVff/1V06dP1759+xQVFaUBAwZo5MiRV72etuS+YU3//v0VGhqqjz76yOe9zZs3a8qUKdq2bZtCQ0PVt29f/eMf/8jVJTMAAKVX06ZNFRsbq1mzZuns2bNq2LChzp07py+//FJnzpzRtGnTcvV/EACg6HEsAQAAABSdYtnTYf369Ro9erTq1aunGTNmqG/fvnrttdc0a9asXM0/e/Zsbd26Ncv4w4cPa9iwYQoODtb06dM1fPhwzZs3Ty+88IK/dwEAUMLYbDb9+9//1uDBg7V8+XJNnDhR7733nmrUqKF///vf+bqRMgCg8HEsAQAAABStYnlPh+HDh+v8+fP6/PPPveOmTp2q+fPna+XKlVe8OcvOnTvVv39/lSlTRnXq1PE5O+m5557TsmXL9NNPP3nPRpo/f74mTpyon376ictmAAAAACUcxxIAAABA0Sp2PR3S09O1evVq9erVy2f8zTffrOTkZK1duzbHeTMyMvR///d/Gjx4sOrUqZPl/RUrVqhbt24+3Z979+4tl8ulFStW+G8nAAAAABQ6jiUAAACAolfsQocjR44oIyNDtWvX9hlfq1YtSdLBgwdznPfNN99URkaGHnnkkSzvpaam6tixY1kOIKKiohQeHn7F5QIAAAAo/jiWAAAAAIpesbuRdEJCgiQpPDzcZ3xYWJgkKTExMdv5Nm/erPfff18ff/xxtjdyy2m5nmXntFwAAAAAJQPHEgAAAEDRK3Y9HVwulyTJYrFk+77VmnWT09LS9OSTT2ro0KFq3rx5tvNd6dYVhmHkuL7cKIa3xQAAAACuORxLAAAAAEWv2PV0iIiIkJT1LKSkpCRJ2Z9dNH36dLlcLo0ePVoOh0PSxR/vDodDNptNZcqU8VnOpZKTk73v54fLZSghITnf85ths1kVERGihIQUOZ2uItmGkoz6mUP9zKF+5lA/86ihOdTPHOpnjpn6RUSEyGYrduce+QXHErnHd9Ac6mcO9TOPGppD/cyhfuZQP/OooTmFcSxR7EKH6Oho2Ww2HTp0yGe853X9+vWzzLN48WIdO3ZMrVq1yvJekyZNNHnyZPXr10+VK1fOstyzZ88qMTEx2+XmhcNRtB9wp9NV5NtQklE/c6ifOdTPHOpnHjU0h/qZQ/3MoX6+OJbIOz5D5lA/c6ifedTQHOpnDvUzh/qZRw3NKcj6FbvQISgoSG3bttWSJUs0fPhwb1flxYsXKyIiItsuzzNnzlR6errPuAkTJkiSnn/+edWoUUOS1LlzZy1btkzjx4/3Xqv1hx9+kM1m03XXXVeQuwUAAACggHEsAQAAABS9Yhc6SNKoUaM0bNgwPfroo7rzzju1YcMGzZkzR+PGjVNwcLASExO1d+9eRUdHKyoqSrGxsVmW4blZXLNmzbzjHnzwQX333Xd68MEHNWzYMB08eFCvvvqq+vfvr6pVqxba/gEAAAAoGBxLAAAAAEWrWF7MtWPHjpoxY4YOHDigv//97/r222/1xBNP6MEHH5Qkbdu2Tf3799eyZcvytNx69erp/fffV2pqqh555BHNnTtX999/v55++ukC2AsAAAAAhY1jCQAAAKBoWQzPXdKQb06nS2fPZr2pXGGw262KjAxTfHwS1zDLB+pnDvUzh/qZQ/3Mo4bmUD9zqJ85ZuoXFRVWam8kXRIV1bEE30FzqJ851M88amgO9TOH+plD/cyjhuYUxrEERxsAAAAAAAAAAMAviuU9HUozl8slp9Phx+VZlJpqU3p6mpxOOq3kVUmpn81ml9VKRggAAAAAAICcGYYhl8sll8tZ1JtSYEpKe15xlV39rFabrFarLBaLX9ZB6FBIDMNQQsJZpaQk+n3ZcXFWuVx0JcqvklK/kJBwRURE+e3LDwAAAAAAgNLBMAylpCQqMfF8qQ4cPEpKe15xlV39rFabwsPLKSQkzHT7I6FDIfEEDuHhkQoMDPJrw7HNZiHVM6G4188wDKWnpykxMV6SVLZs+SLeIgAAAAAAABQnnrbH4OAwBQeHymq1leoTV4t7e15xd2n93L1jnEpNTVZCwhllZKSZbn8kdCgELpfTGziEh0f4ffl2u5WbpphQEuoXGBgkSUpMjFeZMpFcagkAAAAAAACSPG2PSQoPL6fw8LJFvTmFoiS05xVn2dUvODhUiYkBSkw8rzJlyslqteV7+bRcFgKn092lydNwDOSH5/Pjz3uCAAAAAAAAoGRztz0aCgoKLupNQQkXGBgsyfC2Z+cXoUMhKs1dmlDw+PwAAAAAAAAgZ7QdwRx/tT8SOgB+YBhcQw4AAAAAAABAwShJ7Y+EDjBt1arfNXz4YN14Y2fdeedt+uijuXn6EuzcuUM33NBBJ04cL8CtLDgrVvxPkyZN8L5ev36tunRpq/Xr10qS5sx5R126tC2qzQMAAAAAAABKtMvbHz/44H3aH4tx+yM3koYpW7Zs0pNPPqYbb+ypESNGafPmjZo9+225XC4NHTr8qvPv2bNbTzwx1vR1worSggUf+7yOjW2oWbPmqk6dOkW0RQAAAAAAAEDpkF3746xZb8nhcNL+WEzbHwkdYMrcue+qQYMYPfvsREnSddd1ksPh0Lx5H2jAgEE53sAmIyNDn3/+qd57b2apu8lNWFi4mjZtVtSbAQAAAAAAAJR42bU/ulxO2h+Lcfsjl1dCvqWnp2vDhnXq2rWHz/ju3W9USkqyNm3amOO8K1f+prlz39WQIQ9o1KiHc73OhITzmjRpgm699Ub17t1dr78+TXPmvKO77rrdO82YMSM1ZsxIn/ku73IkSRs3rtdjj41Rz543qFu363T33X01Z847crlckqQTJ46rS5e2+uWXn/TMM0+oZ8+u6t27u156aaKSk5O969q4cb02blzvXX5267rc8uXLNHz4YPXo0Ul9+96s6dNfUUpKSq7rAAAAAAAAAJR2ObU/9uhxU4lqf+zdu/s11f5I6IB8O378mDIyMhQdHe0zvnr1mpKkI0cO5Thvo0aN9fnn32jo0OGy2Wy5Wp/L5dLjjz+sVat+0+jRD+vppydo27Yt+vzzT/O87Xv27Najj45SRERZTZr0kl5++TU1a9ZCc+e+q59++tFn2qlT/6UqVapp8uRXNGjQEH333Tf68MP3JUmPP/6kYmJiFRMTq1mz5io2tuFV1/3jjz9o/PhxqlWrtv71r1f0wAMjtHjx93ryycdL1A1hAAAAAAAAgIKUU/tjjRolq/3xhRcmX1Ptj1xeqQgZhqFkR7Lp5dgNqxwOl6llhNpDZbFY8jRPYuIF97yhYb7LCg2VJCUlJeU4b8WKlfK4he50cseO7ZoyZbo6deoiSWrTpp3uuqtvnpe1b98etWvXQc89N1GBgXY5HC61a9dBv/++XBs3rlOvXr2903bq1FljxoyVJLVt215r1qzW778v10MPjVGdOnW9+5+bLk2GYWjWrBnq0KGTnntuond8jRrRGjt2tFau/M27bwAAAAAAAIAZ/mp/NCs/bY9S6Wl/tFrd5/4Xl/bHrl275nl/8oLQoYgYhqHbFvbSmpOri3pTJEntq1ynb/+6OE9ffk83oJzmsVj825Fm06YNstvtuu66Tt5xoaFh6tKl6xW7EmWnd+8+6t27j9LS0nT06CEdPHhIu3fvlNPplMPh8Jm2SZPmPq8rVqykEydO5GsfDh8+pNOnT2nw4GE+62nZsrXCwsK0Zs1qQgcAAAAAAACYVpzaH/PT9iiVnvbHY8eO6ujRI8Wm/ZHQoRSzKO/pXnESHl5GUtZE0XO9sfDwcL+u78KFBJUtW9abDHpUqFAxz8tKS0vVa69N1eLF38vhcKhq1Wpq1qy5bDZ7li5GwcG+N5qxWq0yjPz1LDl//pwkadq0lzRt2ktZ3o+L+zNfywUAAAAAAAAuR/tj3tD+6B+EDkXEYrHo278u9s/llexFc3ml6tVryGaz6dixIz7jPa9r165japsuV7ZsOZ07d05Op9PnOmwJCed9prNYLHI6nT7jLr9JyvTp07Rs2c96/vnJ6tixowICgiRJt93W06/bfDnPP5SjRz+q1q3bZHm/TJmIAl0/AAAAAAAArg3+bH80K7+XV8qp/fHo0ZLV/tiuXQeFhIRIujbaHwkdipDFYlFYQNjVJ7wKu90qh8Vc6JAfQUFBatGilf73v6W6997B3n84li79WeHhZdS4cRO/rq9t2/aaN+/fWrbsF914o/vL6XA4tHr1Sp/pwsLCtHfvHp9xW7Zsuuz1RrVq1VZdu3bzhjY7d+7QuXPx3m5buWWz2bL8I5OTWrVqKzIySidOHFfDhoO948+cidMLLzynO+7op+rVa+Rp/QAAAAAAAEB2/NX+WFRyan/85ZefSlT7o0dxaX+sVSv6Ckswj9ABpgwdOlxjx47Ws88+qT59+mrr1s365JOPNGrUwwoKcncLSkpK1IEDB1S9eg1FRkbme11t27ZXx46dNWXKJJ07F69q1arriy8+1cmTJ1S5chXvdJ06Xa8VK37V669P0/XX36DNmzfqhx++81lWo0ZN9MsvS/TVV5+rbt162rVrlz74YI4sFotSU1MuX/UVhYeHa+vWLVq3bo0aNIi94rQ2m00jR47W1Kn/ks1mVefO1+vChUR98MF7On36tGJjG+Vp3QAAAAAAAEBpll3748cff1ii2h9r1aqjvXv3XDPtj4QOMKVNm3aaNGmK3n//HT311DhVqFBJo0c/qnvvvc87za5dO/XIIw/pqacm6NZbbze1vkmTXtasWW9p7tzZSktL10039VL37jdp+/at3mn69OmrY8eOatGi/+rrr79Uq1ZtNHHiSxo1arh3mocf/occDofefXemMjIyVLVqNQ0dOlwHDuzTb78tz3VyKEl33tlfO3fu0Lhxj2j8+AmqUKHCFae//fY7FBoapvnzP9Q33yxUSEiImjVroeeem6Rq1arnvSgAAAAAAABAKZVd++OYMWPVv/8g7zTFvf0xPT1D1apdO+2PFuPyu1Ygz5xOl86eTcrx/YyMdJ05c0Lly1dVQECg39fvj3s6lGQvvvhPbdiwTp9//m2+5i8p9Svoz1F+2O1WRUaGKT4+qUTUsLihfuZQP/OooTnUzxzqZ46Z+kVFhclms159QhSKqx1LFBS+g+ZQP3Oon3nU0BzqZw71M6cg6lcc24wKWmG355ltfyxucqrf1T5LuT2W4GgDAAAAAAAAAAD4BaEDAAAAAAAAAADwC+7pgBLv6af/WdSbAAAAAAAAAKCUov0xb+jpAAAAAAAAAAAA/ILQAQAAAAAAAAAA+AWhAwAAAAAAAAAA8AtCBwAAAAAAAAAA4BeEDgAAAAAAAAAAwC8IHQAAAAAAAAAAgF8QOgAAAAAAAAAAAL8gdAD8wDCMot4EAAAAAAAAAKVUSWp/JHSAaatW/a7hwwfrxhs76847b9NHH8296pfg0KGD6tKlbZbHwIF3FtJW+8+KFf/TpEkTvK/Xr1+rLl3aav36tZKkOXPeUZcubYtq8wAAAAAAAIAS7fL2xw8+eJ/2x2Lc/mgv6g1AybZlyyY9+eRjuvHGnhoxYpQ2b96o2bPflsvl0tChw3Ocb8+eXZKkN96YpcDAIO/4oKCgnGYpthYs+NjndWxsQ82aNVd16tQpoi0CAAAAAAAASofs2h9nzXpLDoeT9sdi2v5I6ABT5s59Vw0axOjZZydKkq67rpMcDofmzftAAwYMUlBQcLbz7dmzW1WrVlPr1sUngfOXsLBwNW3arKg3AwAAAAAAACjxsmt/dLmctD8W4/ZHLq+EfEtPT9eGDevUtWsPn/Hdu9+olJRkbdq0Mcd59+zZrfr1Y/K8zoSE85o0aYJuvfVG9e7dXa+/Pk1z5ryju+663TvNmDEjNWbMSJ/5Lu9yJEkbN67XY4+NUc+eN6hbt+t09919NWfOO3K5XJKkEyeOq0uXtvrll5/0zDNPqGfPrurdu7teemmikpOTvevauHG9Nm5c711+duu63PLlyzR8+GD16NFJffverOnTX1FKSkqe6wEAAAAAAACUVjm1P/bocVOJan/s3bv7NdX+SE+HomQYUuaHxxS7VXK4zC0jNFSyWPI0y/Hjx5SRkaHo6Gif8dWr15QkHTlySO3bX5ftvHv37lbt2nX0t78N0549uxQeXka33HKbRowYJbs9+4+ly+XS448/rBMnjmv06IdVtmw5ffTRv3XkyGGFhYXladv37NmtRx8dpe7db9KkSS/J4XBp8eLvNXfuu6pZs5Z69ertnXbq1H+pT5++mjz5Fe3YsU2zZ7+tcuUi9dBDY/T4409q4sRnJUmPPfak6tSpo127dl5x3T/++INeeOEZ9ep1i0aMGKWTJ4/rnXfe1oED+zV9+luy5PHvAAAAAAAAAGTLX+2PZuWj7VHKuf2xRo2S1f74wguTZRhGsWl/LGiEDkXFMFTutl4KWLO6qLdEkpTR/jqd+3Zxnr78iYkXJEmhob5fuNDQUElSUlJStvOdPXtGZ8+ekcVi0ahRD6ty5Spat26NPv74A50+fUoTJkzKdr6VK3/Tjh3bNWXKdHXq1EWS1KZNO911V99cb7PHvn171K5dBz333EQFBtrlcLjUrl0H/f77cm3cuM7nS9+pU2eNGTNWktS2bXutWbNav/++XA89NEZ16tT17n9uujQZhqFZs2aoQ4dOeu65id7xNWpEa+zY0Vq58jfvvgEAAAAAAAD5VozaH/PT9iiVnvZHq9V9waHi0v7YtWvXPO9PXhA6FKUSfka7pxtQTmfmWyzZX70rLCxMr732lqKja6ly5SqSpFat2iggIEDvvjtTQ4cOV+3aWW+CsmnTBtntdl13XSfvuNDQMHXp0vWKXYmy07t3H/Xu3UdpaWk6evSQDh48pN27d8rpdMrhcPhM26RJc5/XFStW0okTJ/K0Po/Dhw/p9OlTGjx4mM96WrZsrbCwMK1Zs5rQAQAAAAAAAP5B+2OxaH88duyojh49UmzaHwkdSiuLxZ3u+aF7k91ulaMILq8UHl5GUtZE0XO9sfDw8GznCwoKVrt2HbKM79Spi959d6a369PlLlxIUNmyZb3JoEeFChXztN2SlJaWqtdem6rFi7+Xw+FQ1arV1KxZc9lsdhmG4TNtcLDvzWisVqsMI3/1Pn/+nCRp2rSXNG3aS1nej4v7M1/LBQAAAAAAAHz4sf3RtHxeXon2x7wrDu2PhA5FyWKR8ngtsGz5454O+VC9eg3ZbDYdO3bEZ7zndXZfXEk6fPig1q9fq549eyss7OI/DGlpaZKksmXLZTtf2bLldO7cOTmdTtlsNu/4hITzPtNZLBY5nU6fcZffJGX69GlatuxnPf/8ZHXs2FEBAUGSpNtu65nT7vqF5x/K0aMfVevWbbK8X6ZMRIGuHwAAAAAAANcQf7U/FpGc2h+PHi1Z7Y/t2nVQSEiIpGuj/TH7/idALgQFBalFi1b63/+W+qRzS5f+rPDwMmrcuEm28/3555965ZWXtHTpzz7jf/55iUJDwxQb2yjb+dq2bS+n06lly37xjnM4HFq9eqXPdGFhYTp9+pTPuC1bNl32eqNatWqrrl27eb/wO3fu0Llz8d5uW7l16T9AV1OrVm1FRkbpxInjatiwsfdRsWIlzZz5pnbvvvJNYAAAAAAAAIBrRU7tj7/88hPtjzkoDu2P9HSAKUOHDtfYsaP17LNPqk+fvtq6dbM++eQjjRr1sIKC3N2CkpISdeDAAVWvXkORkZFq2bK1WrVqozfffE2pqSmqVau2fv/9N33++QKNHv2oIiKyT9vatm2vjh07a8qUSTp3Ll7VqlXXF198qpMnT3ivzSZJnTpdrxUrftXrr0/T9dffoM2bN+qHH77zWVajRk30yy9L9NVXn6tu3XratWuXPvhgjiwWi1JTUy5f9RWFh4dr69YtWrdujRo0iL3itDabTSNHjtbUqf+SzWZV587X68KFRH3wwXs6ffp0jv/gAQCAwuVySamp7kdKikWpqVJysiVznEUpKb7Dy8d75s1uGs8yq1Vz6eOPU0ryiWcAAABAgcuu/fHjjz8sUe2PtWrV0d69e66Z9kdCB5jSpk07TZo0Re+//46eemqcKlSopNGjH9W9997nnWbXrp165JGH9NRTE3TrrbfLZrNp8uRpev/9d/Tpp/N15kycqlWrof/3/55S375/veL6Jk16WbNmvaW5c2crLS1dN93US92736Tt27d6p+nTp6+OHTuqRYv+q6+//lKtWrXRxIkvadSo4d5pHn74H3I4HHr33ZnKyMhQ1arVNHTocB04sE+//bY8S/eoK7nzzv7auXOHxo17ROPHT1CFChWuOP3tt9+h0NAwzZ//ob75ZqFCQkLUrFkLPffcJFWrVj3X6wUA4FpkGPIGACkp7sb7lJSsry8dJifn/H5qqvv9S8MATzhQ0I4etSg+3qKwMOPqEwMAAADXqOzaH8eMGav+/Qd5pynu7Y/p6RmqVu3aaX+0GJfftQJ55nS6dPZsUo7vZ2Sk68yZEypfvqoCAgL9vn6/3Ei6BHvxxX9qw4Z1+vzzb/M1f0mpX0F/jvLDbrcqMjJM8fFJJaKGxQ31M4f6mUcNzaF+OcvIkLeh3zNMSnI/9wzT0qwyjCDFxaUrMVHe4CA5+WJQcGlgcGlwYBgFHwhcKjDQUEiIFBzsHoaEXHwdHCwFBfm+dj8uH3fxdVCQe5ratV2qXDl/P8XNfP6iosJks3GV1eLiascSBYV/w8yhfuZQP/OooTnUzxzqZ05B1K84thkVtMJuzzPb/ljc5FS/q32WcnssQU8HAACAa5TDoUtCAXcg4H7osuHF557gwDPOM687GHC/n56el1Ag/wdFgYGGQkMvhgCXDkNDpdBQI9v3QkLc7wUHu1+7h75hwqXDPFw+FQAAAACueYQOAAAAJYTDISUmShcuWJSYaFFiopSY6A4AEhMvhgHZjb90XFKS+3lBX0LIZjMUFuZu4A8NlcLCDO/z8HCpXDm77PaMzMb9i9N4nvuGBxeH7mkIAwAAAACgOCJ0QIn39NP/LOpNAAAgR06nlJTkDgoSEiy6cMHd4H/hgiUzPMgaInieXz6+oEICTzgQFmZkPuQzDA3NOs49Xt5hdsFCYKBkyWGT3d3K7YqPT6dbPgAAAIBijfbHvCF0AAAAyIZhuO8z4AkLEhKUGRq4XycmWuRwSKdPB+r8eenChYshwYULF6dNSvJ/UBAUZCg83B0AXDrM6bknLMg63h0SBAXlHA4AAAAAAJAXhA4AAKBUyshwN/yfP+8ZesKDrOM8IYHnkZjofu1w5KYlPiBX2xMQYCgiwlB4uFSmjJH5uBgEhIe7n5cp4/vcExC4x7vfC7w27g0HAAAAACiBCB0AAECxZBju3gPnzrnDgXPn3I+EBIvOnZPOn7d4H54A4cKFi+OTk/1z6r7V6g4HIiLcDf8REYYiIqSyZaWKFe0KDEz3BgeXhgmekCAiwv08KMgvmwMAAAAAQLFG6AAAAAqMYbjvZ3D+vEXx8e7Q4NLh+fO+oYI7UPCECZLLZT44CAszVLasJywwVLasLnl+MVDwPNzBwsVxYWHZX3ro4j0JMrgnAQAAAAAAmQgdAADAVRmGlJgonT3rDgvOnvUNEC6GCBbFx8vnvYwMc8FBUJA7HChXzh0YlC176WtPoCBviOAJGDyBQkDurn4EAAAAAAD8gNABAIBrTEaGvAGBwyEdOmRTXJzNGyjEx18MF86duxgwmAkPAgIMRUa6g4Jy5QxFRrrDg8hId0DgCRA8wcKlgUJIiB93HgAAAAAAFChCB8APDMOQJbtrbwBAAXO5pHPn3CHBmTNWnT1ryXxu8T6//PX585f/exWc6/UFB7uDgshIQ1FRngDBEybIJ1i49L3Q0OwvUQQAAAAAAK6uJLU/EjrAtFWrfte7787UwYP7Va5cpO64407dd9/9V/wSpKen6/33Z+vHHxfp3LlzqlWrlu69d7B69bqlELfcP1as+J+WLv1Zzz77giRp/fq1euSRh/TGG7PUunVbzZnzjubOfVcrVqwt4i0FUBI4HNKZM5Ysjz//zDruzBl3b4T83PfAYnGHBBUrWhQR4fQGCZ4w4dLhpY/QUP/vMwAAAAAAV3J5+2O/fndp4MChtD8W0/ZHQgeYsmXLJj355GO68caeGjFilDZv3qjZs9+Wy+XS0KHDc5xvwoSn9Pvvy3XvvYPVpk077dmzS1On/kvnzp3TPffcW4h7YN6CBR/7vI6NbahZs+aqTp06RbRFAIoTw3D3RIiLs+rPPy2Ki3MHCJ7ncXGXhghWxcfn76wFz6WKypd3hwWeR06vy5UzFBRkVWRkmOLjU7kRMgAAAACgWMqu/XHWrLfkcDhpfyym7Y+EDjBl7tx31aBBjJ59dqIk6brrOsnhcGjevA80YMAgBQVlvWTH7t07tXz5Mo0cOVpDhjwgSWrXroOCg0M0c+YbuuWW21SmTJlC3Av/CgsLV9OmzYp6MwAUIIdDiouz6PTpy0ME32DBEyo4HHkLEiwWdzBQoYI7JLj0UaFC1vGRkQY3SwYAAAAAlErZtT+6XE7aH4tx+yOhA/ItPT1dGzas0wMP/M1nfPfuN2r+/A+1adNGtW9/XZb5Dh48KEnq3Lmrz/iWLVsrJSVF69ev1Q03dM92nQkJ5/XGG6/q999XyOVy6ZZbblN4eLgWLfqvPv/8W0nSmDEjJUlvvjnbO9/lXY4kaePG9frww/e1Y8c2paSkqGLFSurdu4+GDRshq9WqEyeO6+67++qFF17SL7/8qNWrV8lms6lbtx565JHHFRoaqjFjRmrjxvWSpC5d2uqNN2ZJUpZ1XW758mX697/n6MCBfQoPL6MePXrqb3/7u0K4WypQZFwu982VT592P/780/Pc6jPOc5kjw8hbkFC2rDssqFjRlTn0DREuDRIiIw3ZbAW0owAAAAAAlBA5tT/26HGT5s37oMS0P27fvk2pqddO+yOhQxEyDCk52fxy7Hb3Wbdm5OcGn8ePH1NGRoaio6N9xlevXlOSdOTIoWy/9JGR5SRJJ04cV7169S9Z3tHM8ceyXZ/L5dLjjz+sEyeOa/Toh1W2bDl99NG/deTIYYWFheVp2/fs2a1HHx2l7t1v0qRJL8nhcGnx4u81d+67qlmzlnr16u2ddurUf6lPn76aPPkV7dixTbNnv61y5SL10ENj9PjjT2rixGclSY899qTq1KmjXbt2XnHdP/74g1544Rn16nWLRowYpZMnj+udd97WgQP7NX36WyXmhjBASZGeLp0+bdGpUxadPGnVqVMW7+tTp6w+YUJeeiTYbO6AoGJF98MTJHiChUvHlS9vKCioAHcSAAAAAIBs+Kv90az8tD1KObc/1qhRstofX3hhsgzDKDbtjwWN0KGIGIZ0222hWrOmeJzK2r69Q99+m5KnL39i4gVJUmio7xcuNPMuo0lJSdnO17JlG1WrVl2vv/6KgoOD1ahRY+3du0czZ86Q1WpVampqtvOtXPmbduzYrilTpqtTpy6SpDZt2umuu/rmfqMz7du3R+3addBzz01UYKBdDodL7dp10O+/L9fGjet8vvSdOnXWmDFjJUlt27bXmjWr9fvvy/XQQ2NUp05d7/7npkuTYRiaNWuGOnTopOeem+gdX6NGtMaOHa2VK3/z7huAK0tJkeLjpV27rDp+3JoZIriDhJMnLwYLZ89a87TcqCiXKlW6GCZUqmSoUiVX5tDwvhcVRW8EAAAAAEDxVZzaH/PT9iiVnvZHq9XdNlFc2h+7du16hSWYR+hQhCwWo6g3wRSXy33T0ZzOzLdYsm/oCwgI0KuvvqnJk1/Q2LGjJUnly1fQ2LHjNGHCUwoOznodNknatGmD7Ha7rruuk3dcaGiYunTpqvXr83Zn9t69+6h37z5KS0vT0aOHdPDgIe3evVNOp1OOy7qNNGnS3Od1xYqVdOLEiTytz+Pw4UM6ffqUBg8e5rOeli1bKywsTGvWrCZ0wDXP5ZL+/NOikyfdjxMnrNk8v/SGy1fvFhgQYKhyZfejUiWX97n74fKGCxUqGAoMLNj9AwAAAACgsND+WDzaH48dO6qjR48Um/ZHQodSymKRvv02xU+XV7LK4XCZWkZ+ujiFh7tvtnJ5opicuVPh4eE5zlujRk299da7io8/q/Pnz6tGjZo6ffqUXC6XIiLKZjvPhQsJKlu2rDcZ9KhQoWLeNlxSWlqqXnttqhYv/l4Oh0NVq1ZTs2bNZbPZZRi+/xhf/o+Q1WqVYeSv3ufPn5MkTZv2kqZNeynL+3Fxf+ZruUBJkZoqHT/uDg88wxMnLN4g4cQJdw+F3F7mKDhYqlLFlW2QcOnryEhD1rx1eAAAAAAAoETzZ/ujWfm9vBLtj3lXHNofCR2KkMUi5fFSYNnyxz0d8qN69Rqy2Ww6duyIz3jP69q162Q7X1paqpYt+0XNmrVQtWrVFRkZJUnatWuHJCkmpmG285UtW07nzp2T0+mU7ZJrmiQknPeZzmKxyOl0+oxLSUnxeT19+jQtW/aznn9+sjp27KiAAPfF1m+7recV99kszz+Uo0c/qtat22R5v0yZiAJdP1CQkpOlkyctOn7cqmPHfIMF92uLzpzJXcu/xeK+hFHVqoaqVnUHCJ7nVaoYqlLFUM2aUu3aYTp3LsV08AoAAAAAQGnkr/bHopJT++PRoyWr/bFduw7eGzhfC+2PhA7It6CgILVo0Ur/+99S3XvvYG83p6VLf1Z4eBk1btwk2/ns9gC99toU3XHHXXrooTGSJKfTqS+++Ew1atRU3br1sp2vbdv2mjfv31q27BfdeKP7y+lwOLR69Uqf6cLCwrR37x6fcVu2bLrs9Ua1atVWXbt28/YU2blzh86di/d228otm82W5R+ZnNSqVVuRkVE6ceK4GjYc7B1/5kycXnjhOd1xRz9Vr14jT+sHCoPD4Q4Ujh51BwjHjll19Kh76A4Wcn/vhJAQd4BQvbo7QKha1aWqVY3MMMH9vFIlQ/ar/A9lt1vzdZYEAAAAAAAoGXJqf/zll59KVPujR3Fpf6xVK/oKSzCP0AGmDB06XGPHjtazzz6pPn36auvWzfrkk480atTDCgpydwtKSkrUgQMHVL16DUVGRspms+mvf71bn302XxUrVlStWnX0xRefacuWTZo8eVqW7ksebdu2V8eOnTVlyiSdOxevatWq64svPtXJkydUuXIV73SdOl2vFSt+1euvT9P119+gzZs36ocfvvNZVqNGTfTLL0v01Vefq27detq1a5c++GCOLBaLUlNTLl/1FYWHh2vr1i1at26NGjSIveK0NptNI0eO1tSp/5LNZlXnztfrwoVEffDBezp9+rRiYxvlad2APxiGdP68vIGCb7Dgfn7ypEUu19Vb+ENDDVWr5soMFS4+r1bNpWrV3MNy5fLXpRIAAAAAAFx7smt//PjjD0tU+2OtWnW0d++ea6b9kdABprRp006TJk3R+++/o6eeGqcKFSpp9OhHde+993mn2bVrpx555CE99dQE3Xrr7ZKk4cP/JovFoo8//lAXLiSofv0YTZ36utq3v+6K65s06WXNmvWW5s6drbS0dN10Uy91736Ttm/f6p2mT5++OnbsqBYt+q++/vpLtWrVRhMnvqRRo4Z7p3n44X/I4XDo3XdnKiMjQ1WrVtPQocN14MA+/fbb8lwnh5J05539tXPnDo0b94jGj5+gChUqXHH622+/Q6GhYZo//0N9881ChYSEqFmzFnruuUmqVq16rtcL5JZhuG/MfOSIRUeOWDMf7udHj7pDhqSkq6cAAQGGqlUzVKOGS9Wru4fVqrl7LHh6LkREECgAAAAAAAD/ya79ccyYserff5B3muLe/pienqFq1a6d9keLcfldK5BnTqdLZ88m5fh+Rka6zpw5ofLlqyogINDv6/fHjaRLshdf/Kc2bFinzz//Nl/zl5T6FfTnKD/sdqsiI8MUH59UImpY3Pirfi6XdPp09qHCkSPuUCE19epJQIUK7jChenWXatTwHVav7r7HQnG6GTOfP/OooTnUzxzqZ46Z+kVFhclmK0b/oF/jrnYsUVD4DppD/cyhfuZRQ3OonznUz5yCqF9xbDMqaIXdnme2/bG4yal+V/ss5fZYgp4OAFDMGYZ07px0+LBVhw55HhYdPmzV4cPu3grp6VcOFSyWi70UatY0FB3tHlav7lLNmu4eC5n3MwIAAAAAAADyjdABAIqBtDTp6FGLDh2y6uBBa2bAYPEGDQkJVw4VrFb3PRRq1nT3TqhZ0+UNFjyXQQq8Nk52AAAAAAAAQBEidECJ9/TT/yzqTQBy5dw56cABd6hw4IA7TDh6VNq3L0QnTlhkGFcOFipVcqlWLXcvhVq13I/oaHfAULWqoYCAwtkPAAAAAACAawntj3lTbEOHX3/9VdOnT9e+ffsUFRWlAQMGaOTIkbLkcIfSlJQUzZgxQ4sWLdLZs2fVsGFD/f3vf1fXrl19puvcubPi4uKyzL9ixQpVrFixQPYFwLXBMNz3VnCHCu6hJ2A4eNCq+PicQgX3tfDCwi4NFIzMUMH9vGZNl0JDC29fAAAoyTiWAAAAAIpOsQwd1q9fr9GjR+uWW27R2LFjtW7dOr322mtyuVwaNWpUtvOMHz9ey5cv1+OPP67atWtr4cKFeuihh/Thhx+qbdu2kqS4uDjFxcVp/Pjxatmypc/85cqVK+C9AlAaGIZ06pRF+/dbtW+fVfv3W3XwoMUbLCQnX7m3QuXKLtWp41Lt2obq1TPUpEmgKlZMUfXqTpUvbyiHthAAAJBLHEsAAAAARatYhg5vvfWWGjZsqKlTp0qSunbtKofDodmzZ2vYsGEKDg72mf7w4cNatGiRJkyYoIEDB0qSrrvuOq1fv17z58/3Hihs375dktSzZ09Vr169EPcIQEkTHy9vqHBpwLBv35WDBavVUI0a7l4KdepcDBjq1HH3YAgLuzit3W5VZGSg4uNdcjiMQtgrAABKP44lAAAAgKJV7EKH9PR0rV69Wo888ojP+Jtvvlnvvfee1q5dqy5duvi8V6VKFX3++eeqU6eOd5zVapXdbld6erp33M6dOxUREVFkBwmGQaMi8o/Pj/8lJUn797svf7Rvn/WSkMGis2etOc5ntRqKjjZUr97FYMEdLrhv3BwUVIg7AQAAvErzsQQAAMDV0XYEc/zV/ljsQocjR44oIyNDtWvX9hlfq1YtSdLBgwezHCgEBgaqWbNmkiSXy6WTJ09q7ty5Onz4sJ599lnvdDt27FBERITGjBmjlStXyuVyqVu3bho/frwqVapUYPtks9kkSenpaQoMpDUS+ZOeniZJstmK3de2WPPcZ2HPHqv27LFq796Lw6NHcw4WJKlqVZfq1XOpbl33o1499yM62lBgYCHtAAAAyLXSeCwBAABwNe62R4vS0lIVEEDbI/IvPT1VksXbnp1fxa71MiEhQZIUHh7uMz4s85okiYmJV5z/nXfe0fTp0yVJd911l9q3b+99b8eOHTp16pTuuece3X///dq3b5/eeOMNDR48WAsXLlSoibu02u1Xary0KiysjBITz0mSAgODcryJXV5ZLJLLZZHLZYgT4fOuJNTPMAylp6cpMfGcwsLKKDCw+HxtbTarz7AopadL+/dfDBf27Ln4/MKFnL9vUVHuHgv167tUr56hunVdql/ffTmkSy+FdJEl82FecapfSUT9zKOG5lA/c6ifOdQve6XzWKJg8Bkyh/qZQ/3Mo4bmUD9zqJ85BVM/q8LCwpWYeE4OR4aCg0Nltdr81v5Y3JSE9rzi7PL6GYYhl8up1NRkpaYmZbY/BphaR/FpvczkcrkkKccvhdV65S9kjx491LZtW23dulUzZszQyZMnNWfOHEnS5MmTFRQUpMaNG0uS2rZtq/r162vgwIH66quvvNdwzSur1aLIyGxbJ73KlQvViRMndO7cOSUn52s1uIZZLFL58pGqWrVqsfwPIyIipNDWlZgo7dghbd/ufuzYIe3cKe3fLzmd2c9jtUr16kmxsVLDhhcfsbFShQoWSbbMR9EozPqVRtTPPGpoDvUzh/qZQ/18ldZjiYLEZ8gc6mcO9TOPGppD/cyhfub4u37lyoXq/PnzOnXqtBISzvh12bg22O121axZQ2XLljXd/ljsQoeIiAhJWc9CSkpKkpT1rKXLxcbGSpLatWunMmXK6Omnn9a6devUpk0btWrVKsv0bdq0UZkyZbRz5858b7PLZSgh4epJQkhIWQUFhcvhcMpf11iz2awKDw9WYmKqnE6XX5Z5LSkZ9bPIbrfJarXp3LnilVjZbFZFRIQoISHF7/VLSJB277Zq1y6rdu2yaOdO9/MjR3JuLAgPNxQT41KDBi41aGBkDl2qUyfn+yzEx/t1s/OkIOt3LaB+5lFDc6ifOdTPHDP1i4gIKbVnJpbmYwl/4ztoDvUzh/qZRw3NoX7mUD9zCrZ+AapYsZpcLpecTv+1PxY3JaM9r/jKWj/35ZSsVqsMw3LF9sfcHksUu9AhOjpaNptNhw4d8hnveV2/fv0s8xw5ckSrVq1S3759FXRJy6Ln2qwnT55UQkKCfvzxR7Vs2dJnGYZhKCMjQ5GRkaa22+HI7QfcIqvVf2W32awKDg5WSopThsGXLK9KSv1crotn7hVHTqcrD98BX+fPu8OF3btt2rnTmvncqmPHcv4HrEIFlxo2dHkDBs+wcmVDOQWxDke+Nq9QmKkfqJ8/UENzqJ851M8c6uer9B9L+B+fIXOonznUzzxqaA71M4f6mVOw9fNv+2NxU1La84qr7OpnGJLTachfQVWx+/QFBQWpbdu2WrJkiYYPH+7tyrF48WJFRESoefPmWeY5evSonnnmGQUHB+v222/3jl++fLkkqWHDhgoICNDzzz+vW265RVOmTPFO8/PPPys1NVUdOnQo4D0Drm2pqdKePVZt327Vzp027dhh1Y4dVp04kXO4ULmyO1CIjb34aNDApfLlS2dSDwAAzOFYAgAAACh6xS50kKRRo0Zp2LBhevTRR3XnnXdqw4YNmjNnjsaNG6fg4GAlJiZq7969io6OVlRUlNq3b68OHTpo4sSJSkhIUN26dbVq1SrNmTNH/fv3V7169SRJDz74oN5++22VL19eXbt21a5duzRjxgx169ZNnTp1KuK9BkoHl0s6eNCiHTvcwcLOne5wYf9+q5zO7LshVK3qDhc8vRfcQYNT5coV7rYDAICSj2MJAAAAoGhZDKN43uN7yZIleuONN3TgwAFVrlxZgwYN0gMPPCBJWr16tYYMGaLJkyerX79+ktzXbX3rrbe0ePFinT59WjVq1NCAAQM0ZMgQ7w3jXC6XPvnkE33yySc6fPiwypUrp9tuu02PPPKIgoOD872tTqdLZ88mmd/pfLDbrYqMDFN8fBJd2vKB+pkTH2/V4cNhWr06Tdu2Wb33XUhOzj5cKFfOUKNGTjVq5Mp8OBUb61LZsoW84cUEnz9zqJ951NAc6mcO9TPHTP2iosJK7T0dPDiWuDq+g+ZQP3Oon3nU0BzqZw71M4f6mUcNzSmMY4liGzqUJIQOJRf1yx2HQ9q/36qtW63ats2qrVtt2rbNqtOns/9HJijIfUNnT7DQqJFLjRtf+Z4L1yI+f+ZQP/OooTnUzxzqZw6hQ+lB6FAyUT9zqJ951NAc6mcO9TOH+plHDc0pjGOJYnl5JQBF58IFads2d6jgfrgvk5SamjUtsFgM1a9vUWysQ7GxTjVu7A4Z6tQxZLMVwcYDAAAAAAAAKFKEDsA1yjCkY8cs2rLFltl7wR0wHDqUfVoZGmqocWOXmjRxqmlT97BZM6lGjTDFx6eRLAMAAAAAAAAgdACuBYbhvrnzli02bdpk1ebNNm3ZYtXZs9kHDNWqudSkiUtNmzq9w9q1DVkvm9xu59IMAAAAAAAAAC4idABKGafTff+FzZvd4cLmzVZt2WJTQkLWyyPZ7e57LzRtejFgaNLEqaioIthwAAAAAAAAACUeoQNQgjkc0p49Vm3a5A4WPAFDcnLWgCEoyH15pGbNnGre3KXmzd03eA4KKoINBwAAAAAAAFAqEToAJYRhSAcOWLRhg8372LrVqpSUrAFDSIihJk3cwUKLFk41a+ZSbKxLAQFFsOEAAAAAAAAArhmEDkAxdeKEO2DYuNGq9ett2rTJpvPnswYM4eGGt/dCs2ZOtWjhUv36LtlsRbDRAAAAAAAAAK5phA5AMRAfL23caNPGjTZt2GDVxo02nTyZ9SbNQUGGmjZ1qVUrp1q2dKpVK5fq1XNlucEzAAAAAAAAABQFQgegkKWnS9u2WbVunU1r17ovk3TgQNbUwGo11LChJ2BwDxs2dCkwsAg2GgAAAAAAAABygdABKGAnTli0dq0tM2SwavNmm1JTs14mqU6diz0YWrZ0XyopLKwINhgAAAAAAAAA8onQAfCjtDRp8+aLvRjWrbPp2LGsvRgiIw21aeNUmzZOtW7tDhoiI4tggwEAAAAAAADAjwgdgHwyDOnYMXcvBk/AsGWLVenpvr0YrFZDjRu71KaNU23buh916xqyZO3sAAAAAAAAAAAlGqEDkEtOp7R9u1V//GHTH3/YtHq1TcePZ+3FUKGCS23bOtWmjXvYooVT4eFFsMEAAAAAAAAAUMgIHYAcJCVJGza4w4U//rBpzRqbEhN9uyfYbIaaNbvYi6FNG6dq1aIXAwAAAAAAAIBrE6EDkOn0aYu3B8OaNTZt3myVw+GbHoSHG2rXzqn27Z3q0MGpVq242TMAAAAAAAAAeBA64JpkGNKBAxatXm3Xhg3S8uUh2rcv66WSqlVzqUMHd8jQvr1TjRu7ZLMVwQYDAAAAAAAAQAlA6IBrgmFI+/ZZ9Pvvdv3+u02//27TyZOXhgxWWSyGGjZ0hwyeR40aRpFtMwAAAAAAAACUNIQOKJUMQ9q926rff7dp5Up3yHD6tG9PhsBAQ61bu9Sjh00tWqSqdesMlS1bRBsMAAAAAAAAAKUAoQNKBZdL2rnT6g0YVq60KS7ON2QICjLUpo1TnTq5H23aOFWmjFWRkWGKj3fK4SiijQcAAAAAAACAUoLQASWSYbhDhhUrbPrtN5tWrbLp7FnfkCEkxFDbthdDhlatnAoOLqINBgAAAAAAAIBrAKEDSozDhy1avtyu5cttWr7cpj//9A0ZQkMNtWvnGzIEBhbRxgIAAAAAAADANYjQAcVWXJxFK1a4A4Zff7Xr0KGsPRk6dHCqSxenOnZ0qGVLlwICimhjAQAAAAAAAACEDig+EhOllSvdAcPy5TZt327zed9mc9/4+frrHera1X1PhqCgItpYAAAAAAAAAEAWhA4oMunp0tq1Nv36q03Ll9u1YYNVDofFZ5rGjZ26/nqnunZ1qGNHp8LDi2hjAQAAAAAAAABXReiAQrV/v0VLl9q1bJldK1bYlJTkGzLUquVS164OXX+9U507O1WxolFEWwoAAAAAAAAAyCtCBxSoxERp+XK7li61aenSrPdlqFDBpa5d3b0Zrr/eoehoQgYAAAAAAAAAKKkIHeBXLpe0ZYtVS5e6g4Y1a2w+l0yy2w21b+9U9+5Ode/uUNOmLlmtV1ggAAAAAAAAAKDEIHSAaadOWbRsmbsnw6+/2hQX55si1K7tUvfuDnXv7lCXLtyXAQAAAAAAAABKK0IH5JnTKa1bZ9VPP9m1ZIld27bZfN4PCzN0/fUOdevm7s1Qpw6XTAIAAAAAAACAawGhA3IlPl5autQdMixdatPZs769GZo3d2b2ZnCqbVunAgOLaEMBAAAAAAAAAEWG0AHZMgxp506rliyx66efbPrjD5tcrov3Zihb1lD37g7ddJM7aKhYkd4MAAAAAAAAAHCtI3SAV0qK9Ntvtsygwa4jR3x7MzRs6NRNNznUs6dT7do5ZefTAwAAAAAAAAC4BM3G17hjxyxassR92aQVK2xKSbnYmyEoyFCXLp6gwaHoaHozAAAAAAAAAAByRuhwjTEMads2qxYtsuuHH+zassX3JtDVqrm8IUOXLk6FhRXRhgIAAAAAAAAAShxCh2uAwyGtXm3zBg2HD1+8bJLVaqhNG5d69nQHDY0bu2SxXGFhAAAAAAAAAADkgNChlEpKkpYts2vRIvelk+LjLyYJwcGGunVz6JZb3PdnqFCByyYBAAAAAAAAAMwjdChF4uIs+vFHmxYtCtD//mdTaurFoCEqyqWePZ265RaHbrjBwWWTAAAAAAAAAAB+R+hQwh04YNH770tffBGs1autcrkuBg3R0S7dcou7R0P79k7Z+WsDAAAAAAAAAAoQzdAl2Pff2zVsWLAMQ5LcN4Ru3tzdm6F3b+7PAAAAAAAAAAAoXIQOJVhIiKHy5aUWLaRevdLUs2eGatTg/gwAAAAAAAAAgKJB6FCCde/u1O7dyYqMDFN8vEMOB4EDAAAAAAAAAKDoWIt6AwAAAAAAAAAAQOlA6AAAAAAAAAAAAPyC0AEAAAAAAAAAAPgFoQMAAAAAAAAAAPALQgcAAAAAAAAAAOAXhA4AAAAAAAAAAMAvCB0AAAAAAAAAAIBfEDoAAAAAAAAAAAC/IHQAAAAAAAAAAAB+QegAAAAAAAAAAAD8gtABAAAAAAAAAAD4BaEDAAAAAAAAAADwC0IHAAAAAAAAAADgF4QOAAAAAAAAAADALwgdAAAAAAAAAACAXxA6AAAAAAAAAAAAvyB0AAAAAAAAAAAAfkHoAAAAAAAAAAAA/ILQAQAAAAAAAAAA+AWhAwAAAAAAAAAA8AtCBwAAAAAAAAAA4BeEDgAAAAAAAAAAwC8IHQAAAAAAAAAAgF8QOgAAAAAAAAAAAL8gdAAAAAAAAAAAAH5B6AAAAAAAAAAAAPyC0AEAAAAAAAAAAPgFoQMAAAAAAAAAAPALQgcAAAAAAAAAAOAXxTZ0+PXXX9WvXz+1aNFC3bt31zvvvCPDMHKcPiUlRVOmTFH37t3VokUL9e/fX7/++muW6TZv3qz77rtPrVq1UufOnfXyyy8rPT29IHcFAAAAQCHiWAIAAAAoOsUydFi/fr1Gjx6tevXqacaMGerbt69ee+01zZo1K8d5xo8fr08//VQjRozQzJkzFR0drYceekhr1671TnP48GENGzZMwcHBmj59uoYPH6558+bphRdeKIzdAgAAAFDAOJYAAAAAipa9qDcgO2+99ZYaNmyoqVOnSpK6du0qh8Oh2bNne3/oX+rw4cNatGiRJkyYoIEDB0qSrrvuOq1fv17z589X27ZtJUnvvfeewsLC9PbbbyswMFA33HCDgoODNXHiRI0aNUrVq1cv3B0FAAAA4FccSwAAAABFq9j1dEhPT9fq1avVq1cvn/E333yzkpOTfc428qhSpYo+//xz9e3b1zvOarXKbrf7dHdesWKFunXrpsDAQO+43r17y+VyacWKFQWwNwAAAAAKC8cSAAAAQNErdqHDkSNHlJGRodq1a/uMr1WrliTp4MGDWeYJDAxUs2bNFB4eLpfLpePHj+vFF1/U4cOHNWDAAElSamqqjh07pjp16vjMGxUVpfDw8GyXCwAAAKDk4FgCAAAAKHrF7vJKCQkJkqTw8HCf8WFhYZKkxMTEK87/zjvvaPr06ZKku+66S+3bt7/icj3Lvtpyr8ZuL5r8xmaz+gyRN9TPHOpnDvUzh/qZRw3NoX7mUD9zqF/2OJbIPT5D5lA/c6ifedTQHOpnDvUzh/qZRw3NKYz6FbvQweVySZIsFku271utVy5Gjx491LZtW23dulUzZszQyZMnNWfOHBmGkeM8hmHkuL7csFotiowMy/f8/hAREVKk6y/pqJ851M8c6mcO9TOPGppD/cyhfuZQP18cS+QdnyFzqJ851M88amgO9TOH+plD/cyjhuYUZP2KXegQEREhKetZSElJSZKyP7voUrGxsZKkdu3aqUyZMnr66ae1bt06NWrUyGc5l0pOTlaZMmXyvc0ul6GEhOR8z2+GzWZVRESIEhJS5HS6imQbSjLqZw71M4f6mUP9zKOG5lA/c6ifOWbqFxERUmrPCuNYIvf4DppD/cyhfuZRQ3OonznUzxzqZx41NKcwjiWKXegQHR0tm82mQ4cO+Yz3vK5fv36WeY4cOaJVq1apb9++CgoK8o5v1qyZJOnkyZNq06aNKleunGW5Z8+eVWJiYrbLzQuHo2g/4E6nq8i3oSSjfuZQP3OonznUzzxqaA71M4f6mUP9fHEskXd8hsyhfuZQP/OooTnUzxzqZw71M48amlOQ9St2pzgFBQWpbdu2WrJkiU835sWLFysiIkLNmzfPMs/Ro0f1zDPP6Mcff/QZv3z5cklSw4YNJUmdO3fWsmXLlJ6e7p3mhx9+kM1m03XXXVcQuwMAAACgkHAsAQAAABS9YtfTQZJGjRqlYcOG6dFHH9Wdd96pDRs2aM6cORo3bpyCg4OVmJiovXv3Kjo6WlFRUWrfvr06dOigiRMnKiEhQXXr1tWqVas0Z84c9e/fX/Xq1ZMkPfjgg/ruu+/04IMPatiwYTp48KBeffVV9e/fX1WrVi3ivQYAAABgFscSAAAAQNGyGFe6K1oRWrJkid544w0dOHBAlStX1qBBg/TAAw9IklavXq0hQ4Zo8uTJ6tevnyT3dVvfeustLV68WKdPn1aNGjU0YMAADRkyxOeGcWvXrtWUKVO0Y8cORUZG6i9/+YseffRR2e35z1+cTpfOns16fdfCYLdbFRkZpvj4JLoT5QP1M4f6mUP9zKF+5lFDc6ifOdTPHDP1i4oKK7X3dPDgWOLq+A6aQ/3MoX7mUUNzqJ851M8c6mceNTSnMI4lim3oUJIQOpRc1M8c6mcO9TOH+plHDc2hfuZQP3MIHUoPQoeSifqZQ/3Mo4bmUD9zqJ851M88amhOYRxLcLQBAAAAAAAAAAD8gtABAAAAAAAAAAD4BaEDAAAAAAAAAADwC0IHAAAAAAAAAADgF4QOAAAAAAAAAADALwgdAAAAAAAAAACAXxA6AAAAAAAAAAAAvyB0AAAAAAAAAAAAfkHoAAAAAAAAAAAA/ILQAQAAAAAAAAAA+AWhAwAAAAAAAAAA8AtCBwAAAAAAAAAA4BeEDgAAAAAAAAAAwC8IHQAAAAAAAAAAgF8QOgAAAAAAAAAAAL8gdAAAAAAAAAAAAH5B6AAAAAAAAAAAAPyC0AEAAAAAAAAAAPgFoQMAAAAAAAAAAPALQgcAAAAAAAAAAOAXhA4AAAAAAAAAAMAvCB0AAAAAAAAAAIBfEDoAAAAAAAAAAAC/IHQAAAAAAAAAAAB+QegAAAAAAAAAAAD8gtABAAAAAAAAAAD4BaEDAAAAAAAAAADwC0IHAAAAAAAAAADgF4QOAAAAAAAAAADALwgdAAAAAAAAAACAXxA6AAAAAAAAAAAAvyB0AAAAAAAAAAAAfkHoAAAAAAAAAAAA/ILQAQAAAAAAAAAA+AWhAwAAAAAAAAAA8AtCBwAAAAAAAAAA4BeEDgAAAAAAAAAAwC8IHQAAAAAAAAAAgF8QOgAAAAAAAAAAAL8gdAAAAAAAAAAAAH5B6AAAAAAAAAAAAPyC0AEAAAAAAAAAAPgFoQMAAAAAAAAAAPALQgcAAAAAAAAAAOAXhA4AAAAAAAAAAMAvCB0AAAAAAAAAAIBfEDoAAAAAAAAAAAC/IHQAAAAAAAAAAAB+QegAAAAAAAAAAAD8gtABAAAAAAAAAAD4BaEDAAAAAAAAAADwC0IHAAAAAAAAAADgF4QOAAAAAAAAAADALwgdAAAAAAAAAACAXxA6AAAAAAAAAAAAvyB0AAAAAAAAAAAAfkHoAAAAAAAAAAAA/ILQAQAAAAAAAAAA+AWhAwAAAAAAAAAA8AtCBwAAAAAAAAAA4BeEDgAAAAAAAAAAwC8IHQAAAAAAAAAAgF8QOgAAAAAAAAAAAL8gdAAAAAAAAAAAAH5B6AAAAAAAAAAAAPyC0AEAAAAAAAAAAPgFoQMAAAAAAAAAAPALQgcAAAAAAAAAAOAX9qLeAAAAAKBYMgwpPV2WjHQpzTNMkyUjI3OYLqVnZA7Ts3mdccXxrurVlTJytGTlPCAAAAAApQehAwAAAIqey+VukE9LdTfwp6fJkp4mpWYOsx2XJkt6upSeJsuloYB3XFrmMtOkjAz3/NmMU3p65jzpma8zp83IKPDdTr+xl5wNYgp8PQAAAABQWIpt6PDrr79q+vTp2rdvn6KiojRgwACNHDlSFosl2+nT09M1d+5cLVy4UCdPnlTlypV1++23a+TIkQoMDPRO17lzZ8XFxWWZf8WKFapYsWKB7Q8AAECx5TmjPy3V3aCflupulE9Nvex5miypKe6G/cz3lOZuyLekpUmeadMyl5Ga5m38t6RmTpvumTdNykhXOc/4QmjgN8uw2aTAQBkBgZnDAPcwKEgKCJQRGJA5DJQCAjKHmeMDgzLnC/DO76xbT876DYp6t0oljiUAAACAolMsQ4f169dr9OjRuuWWWzR27FitW7dOr732mlwul0aNGpXtPP/617/01VdfafTo0WrWrJm2bdumN998U8ePH9e//vUvSVJcXJzi4uI0fvx4tWzZ0mf+cuXKFfBeAQAA5ILL5W7gT01xN86nJEspl7xOTXG/Tkm+GAKkpnnfV1qqLCmZgYB3OZeGBSmypGROd2mgYBhFsrvZNwFLRlCQjMAgKShQRlCwuwHfMy4wUEZwsHsYGOR+z9P4nznOPW3gxWmCAt0N/z7LCbi4PE+YEBR0MUy4bBrZbIVaG+QPxxIAAABA0SqWocNbb72lhg0baurUqZKkrl27yuFwaPbs2Ro2bJiCg4N9pj937pwWLFigcePG6cEHH5QkdezYUZI0depUjRs3TlFRUdq+fbskqWfPnqpevXoh7hEAACjx0tPdDf0pKVJysmzpqZLdkP30WVkTk9zjU1Jk8TxSUzLHJbtDAM+8qZ5pkjNDhRR3o79nnrS0ot5TGcHB7ob+oCApOERGcJCMoGB3g3xw5vigYBlBgTKCQ9yN+cGecUGZ77vn8YYDQcFScFBmABAsW1iIIiqW0/lUpxz2wIsBg6eBP4cz0oGr4VgCAAAAKFrFLnRIT0/X6tWr9cgjj/iMv/nmm/Xee+9p7dq16tKli897Fy5c0IABA9SjRw+f8bVr15YkHTlyRFFRUdq5c6ciIiI4SAAAoLQxDPdZ/MlJsiQnZz7cQYAlOUlKTpYlKfv3LoYFme+lJMuS7H6t5OSLAYHDke2qyxTkbtnt7kb9kBAZISHuBv/gEClzaIRkvg4K8r5WZkO/kRkWuEMDd4igzOmNzOkVkvncEwgEBRdeg7/dKkWGyRWfJJfDVfDrwzWBYwkAAACg6BW70OHIkSPKyMjw/sj3qFWrliTp4MGDWQ4UatasqX/+859ZlrVkyRIFBAR4l7Vjxw5FRERozJgxWrlypVwul7p166bx48erUqVKBbE7AADgUi6Xu6E/KUmWpERZkpKkpGRZkhNlSUq++F5ysvt9b1iQdNnw4vvyBAWuwmm4Nmw2GaFhUkiwrOHhcgYGyRUSIiMk1B0GhIS6G/lDQ2WEhLgb/TPf94xXSEhmKOCe3hsGeEIFT5hgL3Y/1YBijWMJAAAAoOgVuyPZhIQESVJ4eLjP+LCwMElSYmJirpazePFiff311xoyZIjKli0ryX2gcOrUKd1zzz26//77tW/fPr3xxhsaPHiwFi5cqNDQ0Hxvt91uzfe8ZthsVp8h8ob6mUP9zKF+5lA/865aQ0/vgcQLsiQmypKYKCVekOVContcUpJ3KE+IkOgZegKFRJ+AwZKUVOD7ZQQFuUOB0FB3w39YmLvxPzTs4uvQUCnk4vvyhAIhIRfnCwl1Pw8JyVxeZrAQECBZLLLZrIqICFFSQoqcTvOBh0U539+gNOI7bA71yx7HErnHZ8gc6mcO9TOPGppD/cyhfuZQP/OooTmFUb9iFzq4Ms9StOTQrd9qvXoxfvjhB40bN07t2rXTuHHjvOMnT56soKAgNW7cWJLUtm1b1a9fXwMHDtRXX32lgQMH5mubrVaLIiPD8jWvv0REhBTp+ks66mcO9TOH+plD/S5jGFJyspSQIF244B5e/vzS1xcuKOLCBffryx+JiVIOlxQyzWKRwsMvPsLC8jb0PL/0EeoOCSx2e6E23vMZNIf6mUP9fHEskXd8hsyhfuZQP/OooTnUzxzqZw71M48amlOQ9St2oUNERISkrGchJWWeGXn5WUuXmzt3rqZMmaL27dvr7bffVmBgoPe9Vq1aZZm+TZs2KlOmjHbu3JnvbXa5DCUkJOd7fjM8Z1km+Oksy2sN9TOH+plD/cwpdfXLDAssCQmyXEjIHF6QJeG8e3jpc880nvGZz5WY6H5eAJcZMkJDZYSHywgvkzkMl8LcQ8M7DMscH+Ye5xlmhgTu1+5xCgnx/30DnJIupEkqnBsxl7rPYCGjfuaYqV9EREipPSuMY4nc4ztoDvUzh/qZRw3NoX7mUD9zqJ951NCcwjiWKHahQ3R0tGw2mw4dOuQz3vO6fv362c5nGIYmTZqkefPm6ZZbbtGUKVN8DhISEhL0448/qmXLlj7LMAxDGRkZioyMNLXdjiK+AaLT6SrybSjJqJ851M8c6mdOsaifYUgpKbImnHcHAgnnZUk4L2tCZnhw/rwsFxLc72c+tyQkuN+/cEmA4HT6b5MsFhllImSUKXMxLChTRkZ4GbnKuJ9bypRRSKXySrIFyhkSdjFQCAvzCReMsHDJZvPbtkmSnIYkw7/LLCLF4jNYglE/c6ifL44l8o7PkDnUzxzqZx41NIf6mUP9zKF+5lFDcwqyfsUudAgKClLbtm21ZMkSDR8+3Ns1evHixYqIiFDz5s2zne/VV1/VvHnzdP/99+vJJ5/M0qU6ICBAzz//vPcgwuPnn39WamqqOnToUHA7BQAo3i4NDc67H9aEc7KcO5f5PHN8wnlZM8dZEs7Lev5cZsCQIIufLkNkWK0yIiIyAwN3aOCKyAwPypR1DyMi3MFBeJmLwYL3dRm5wsu4LzV0lZ4EdrtVIZFhSo9P4ocagFKBYwkAAACg6BW70EGSRo0apWHDhunRRx/VnXfeqQ0bNmjOnDkaN26cgoODlZiYqL179yo6OlpRUVHasWOH3n33XTVt2lS33HKLNm3a5LO8+vXrKzw8XA8++KDefvttlS9fXl27dtWuXbs0Y8YMdevWTZ06dSqivQUA+EXm5Yms591hgfVcfGZocC4zKIiXNT7+kteZ02UGCJb0dPOb4AkMIsq5g4KICBkRZd0hgfd55uuyZd2BgSdgiIjIdVgAAMgZxxIAAABA0SqWoUPHjh01Y8YMvfHGG/r73/+uypUr64knntADDzwgSdq2bZuGDBmiyZMnq1+/fvrxxx9lGIa2bt2q/v37Z1nehx9+qA4dOujhhx9WhQoV9Mknn+jjjz9WuXLl1L9/fz3yyCOFvYsAgJy4XO7LDcXHyxp/1j08F3/J8Kys8fGynj8nXTiviLgzsmSGCZaMDFOrNmw2GWXdwYCrbDl3QFC2rFzlLnmeOTTKlZOrTObziAi5Isq6b2ZMYAAARYpjCQAAAKBoWQzDKB0XVC5CTqdLZ88mFcm67XarIiPDFM+lMfKF+plD/cy5JuqXkuIODs6ckTX+rPv52bOynj3jDg/OnpXlXGYPhPizF3snmLgRsmG3uwOBsuVklIt0BwZly7nHlfOMi7w4rmw5d3BQtqz73gXXUGhwTXwGCxD1M4f6mWOmflFRYaX2RtIlUVEdS/AdNIf6mUP9zKOG5lA/c6ifOdTPPGpoTmEcSxTLng4AgGIoNVXWM3HuwCDOPbSePeMNFCzxZ2U9kzmMzwwWUlLyvTojNFSuyCh3SBAZeXEYGSVXuUhZykcprEYVXQgIUUZ4WRmRkXKVLUdvAwAAAAAAgCJE6AAA1yKXy31vg7g4d2hw9oysZ+JkOXtGVk+g4Hl9xv2wJOfvLEzDbncHBVFRckWV9z43IqPcoUKUO0TwDj3hQXDwFZdrt1sVFhkmR3ySnJzZAAAAAAAAUCwQOgBAaWAYsiRekOXPP929EeLiZI1zP7fE/el+/mfcxddn4mRxOvO+GrtdrvIVZESVl6t8eXeIEJUZIkSVvxgiXPLcKBNBzwMAAAAAAIBrBKEDABRXTqf7/gd/nr7k8afPa8ul4UJaWp5X4SoTIaN8ebnKV5CrfPnMMKGCOzSocFm4UKECAQIAAAAAAACuiNABAAqTJ0g4dVL2M39KSecUdPCIgk6eyhIqWM6eyfMNlY3QMLkqVJSrYgV3eFChoozMoauCe5xRsaL7dVR5KSiogHYUAAAAAAAA1yJCBwDwh8REWU+fkvX0aVlPn7zk+SlZT528+DzuzyyXNQq9wmINi8V9uaKKlTIfFS95XklGBU+gUFGu8hWk0CstDQAAAAAAAChY+QodNm7cqJYtW/p5UwCgmMm8T4L15ElZT55whwcnT8p66kTm0P2wnTqVp5ssGxaLu/dB5cqyV6uqtKgKckZVyBIqGJUquYMEO/kwAKD04FgCAAAAKN3y1ZI1YMAA1a1bV/369VPfvn1VqVIlf28XABSspCTZTh6/GCh4hqdPep/nOUwIDZWrUmW5KldxDytVuuR15vNKleWqUFGy22W3WxUZGabk+CQ5HHm7jBIAACUVxxIAAABA6Zav0KFz585atWqVXnnlFU2fPl1dunRRv3791L17dwUEBPh7GwEg9wxDljNnZDtxTNYTx2U9cSJzeFy2E8fdwcLx47ImnM/1Il1lIuSqUkWuKlXdAULlKhdfV6osV+XKclaqIoWHF+COAQBQOnAsAQAAAJRu+Qod5syZo9OnT+urr77SV199pWXLlul///ufypYtq9tvv139+vVTo0aN/L2tAK51Tqf7JsvHjsp6/Jhsx466A4STx2XzhAsnT8iSnp6rxRmhYXJWrXoxTKhS1R0mZD53ZgYMCgsr4B0DAODawbEEAAAAULpZDMMwzC5k8+bN+vLLL7Vo0SKdP39eFotFsbGxuvPOO3XbbbcpMjLSH9tabDmdLp09m/tLsPiT5/Is8VyeJV+onzl+rZ/LJUtcnGzHM4OE40dlO3bskuExd6DgcORucRUqylmtulxVq8pVpZpcVau6X1epKldV92ujTIRksZjbbhP4/JlD/cyjhuZQP3Oonzlm6hcVFSabzVpAW5Z3HEsUzbEE30FzqJ851M88amgO9TOH+plD/cyjhuYUxrGEX0IHD4fDoVWrVun777/XV199JcMwZLfbddNNN2nQoEFq27atv1ZVrBA6lFzUz5w81S852d0z4chh9/DoYdmOHpX12FH36xPHc9VDwbDZ3MFBteqZoUI1uapVk6tqNTmrZoYMlatIgYF+2suCw+fPHOpnHjU0h/qZQ/3MKU2hgwfHEoWL76A51M8c6mceNTSH+plD/cyhfuZRQ3MK41giX5dXyk56erqWLVumxYsXa9myZXK5XLJarapSpYoWLVqkH374Qd26ddPUqVMVznXPgdLFMNy9FI4elvXoUffw2FHZjhxxD48elvXMmasvxmJx3yOhenW5qtWQs3p1uapWl6t6ZsBQvYZclSpLdr/90wUAAIoBjiUAAACA0sN0y93atWv1zTff6IcfftCFCxdkGIaio6P14IMPql+/fqpcubK2bdumF198UcuWLdOECRM0bdo0f2w7gMLiCRUOH5TtyGFZDx+S7fBh2Y8elo4dUbnDh2VJSbnqYlzhZeSqWVPOGjXlql5DzhrR7oCheg3vpY9KQg8FAADgHxxLAAAAAKVPvkKHQ4cO6euvv9Y333yjY8eOyTAMBQcH6/bbb9edd96pDh06+EzfpEkTzZw5Ux07dtSyZcv8sd0A/MkwZIk/K9vhQ+7LHx0+LNvhg5nPD8l25MqhgueuCM7KVeSqkRkq1KgpZ40actWIlrN6Dblq1pRRtlyh7A4AACi+OJYAAAAASrd8hQ4333yzLBaLDMNQ06ZNdeedd+r222+/YlfniIgIWa1WlStXLr/bCsCM1FTZjhyW7eB+WQ8dlM37OCTr4UOyJiVecXbDYnHfNyG6llw1o+WsGS3VqaOwxjE6X66i0itVlYKCCmlnAABAScWxBAAAAFC65St0KFu2rP7yl7/orrvuUkxMTK7mycjI0DvvvKNatWrlZ5UArsZzCaRDB9xhwkH30Op5fuL4VRfhrFzFHShE17oYLkTXkrNmtFw1ama59JHdblVYZJhc8UkSN+4BAAC5wLEEAAAAULrlK3T47bffZM/FjVxTU1N15MgRNWjQQIGBgercuXN+VgfAw+mU9fgx2Q7sl23/PvfwknDhar0VXGHhctWuI2et2nJ6hrVqyRVdW87qNaSQkELaEQAAcK3iWAIAAAAo3fIVOjRr1kx9+/bVyy+/fMXpnnjiCa1Zs0YrV67M18YB1ySnU9ajRy4LFjKfHzooS3p6jrMaFotc1apnhgm1LwYMtWrLWbuujKgoyWLJcX4AAICCxrEEAAAAULrlKnRwuS5eNsUwDBmGIZfL5TP+chcuXNCBAweUnJxsfiuB0sbplPXYUdn27c0MFjLDhQP73cFCRkaOsxqBge4QoU5d96N2Xblq15azVh33fRa4rwIAAChGOJYAAAAAri25Ch3uvfdebd682fvaYrHov//9r/773/9edd4mTZrkf+uAEs5y9ow7WNi3V/Z9e2Xbu0e2/e6gwZKWluN8RmCg+/JHderKWaeee1jXPXRVryHZbIW4FwAAAPnHsQQAAABwbclV6PD000/rnnvu8b62WCwyDOOK8wQFBalWrVr65z//aWoDgWIvNdXdQ2HfXtn27fEJF6xnz+Y4mzdYqFvfJ1Rw1qkrV7XqBAsAAKBU4FgCAAAAuLbkKnRo3ry5du7c6X3dsGFD9e3bV1OmTCmwDQOKG8vZM7Lt2SP7nl2y7d4l255dsu/ZI+uRQ7Jc4cDZWa26nPUayFmvnpz1G8hZr74c9RrIVTOaYAEAAJR6HEsAAAAA15Z83Uh68uTJqlmzpr+3BSh6huG+18LuXbLv3S3b7t2Z4cIuWePicpzNVSZCzvr1M8OF+nLWbyBH3fpy1q0nhYUV4g4AAAAUbxxLAAAAAKVbvkKHv/71r/7eDqBwOZ2yHdyvgD27pCMHFLppi6y7dsm+Z7csyUk5z1ajpjtQiImVs0GsnA1i5KgfI6NiRcliKcQdAAAAKJk4lgAAAABKt1yFDoMGDZLFYtErr7yiKlWqaNCgQblegcVi0bx58/K9gYApLpeshw7KvmunbLt2yL5ju/v53t0+N3IOumQWw25331+hQawcMTFy1o+RMyZWjnoNpPDwwt8HAACAEoxjCQAAAODakqvQYd26dbJYLEpJSfG+zi0LZ3+jMLhcsh49IvuuHbLt3Jk53CH7nl2yZH5uL2eEhMgZ21D2Zk2VUrue0uvFyNkgRs7adaSAgELeAQAAgNKJYwkAAADg2pKr0OHDDz+UJFWrVs3nNVAULHFxsu/YJvv2rbLt2C77zu2y7dola1JittMbQUFyNIiVM7ahHA0bydmwsRyxDeWKriV7oF2RkWFKjU+Sw+Eq5D0BAAAo/TiWAAAAAK4tuQod2rdvf8XXQIFIS3Pf0Hn7VvdlkbZvlW37NtlOn8p2ciMgQM76MXI0bChnbCM5YhvJ2bChnLXrSjZbIW88AAAAJI4lAAAAgGtNvm4kLUkOh0Pz58/X6dOnNW7cOO/4ZcuW6c0339Rf/vIXDR482C8biVLOMGQ9dlT2Hdtk2+7uwWDfvk22vXtkcTqzTm6xyFWrthyNm8rRqLEcjZvIGdtIzjp1uSwSAABACcCxBAAAAFB65St0SE1N1YgRI7R27VpFR0f7HCicOnVKW7du1bZt2/Tbb7/pzTfflN2e72wDpU16uvt+C1u3yL5lk+xbt8i+fZusCeezndxVrpwcjZvK2aixO2Ro3ESO2Ebc0BkAAKCE4lgCAAAAKN3y9Qv+ww8/1Jo1a9SuXTs98cQTPu/1799fbdu21QsvvKD//e9/ev/99zVy5Ei/bCxKFkvCedm3bb0YLmzZLNvunbJkZGSZ1rDb5WwQI0ejJu6QobE7ZHBVrSZxA0EAAIBSg2MJAAAAoHTLV+jw7bffqmLFinr33XcVHByc5f169epp5syZ6tmzp77++msOFEo7w5D15AmfcMG+dbNshw5mO7mrbDk5mjWXo0kzOZo2k6NJMzkbxEhBQYW73QAAACh0HEsAAAAApVu+QoejR4/q+uuvz/YgwSM0NFQtWrTQ8uXL871xKIYMQ9bDh2TfvFEBmzbKvmmD7Nu2yBoXl+3kzho13cFC0+buR7PmctWoSe8FAACAaxTHEgAAAEDplq/QISwsTPHx8VedLiUlRaGhoflZBYoDw5D1yGHZN21UwKYN7oBh80ZZs/nbGzabnDGx7t4LzVpk9mBoKiOqfBFsOAAAAIorjiUAAACA0i1foUPz5s31v//9Txs3blTLli2znWbnzp1as2aNOnToYGb7UFgMQ9ajR2TfuEEBmzdeDBjOns06aUCA+94LLVrJ0aKlHM1buG/uHBJSBBsOAACAkoRjCQAAAKB0y1foMGTIEC1dulQjRozQqFGj1L17d1WrVk2SdPLkSf366696++235XQ69cADD/h1g+Ef1lMnZV+/TvYN6xSwcX0uAoaWF0OGho25/wIAAADyhWMJAAAAoHTLV+hw3XXX6bHHHtNrr72mqVOnaurUqdlO99hjj6lz586mNhB+kJjo7r2wbq0CNqyTff1a2Y4fyzKZYbe7A4aWreRo3tIdMDRqQsAAAAAAv+FYAgAAACjd8hU6SNKIESPUsWNHLViwQGvWrNHp06fldDpVsWJFtWnTRoMGDVKLFi38ua3IDYdDtp07FLB+rbsXw/q1su3aKYvL5TOZYbXKGdtIGa3buHswtGxFwAAAAIBCwbEEAAAAUHrlO3SQpKZNm2rSpEn+2hbkg+XoUWnJJoX8+pus69YqYPNGWZKTs0znrF5DjlZtlNG6rRyt2yijeUspPPz/t3fn4XXWdd7431mapE0b2rKU0mkpUqGKLH1AECubLBVnQCkjKCBDgVGKC84zlXH9jYojI8xQdgXBbdDRR31kEbSAgIjziBRQRjYHZGlZW1pokzTNdn5/JA2NbSHNfdosfb2uK9c59/dezve8uRvyOZ9z7rP5JwwAAFFLAADAcFWo6cDAqrnxhjScelJSKqVurfHOMQ1p3+t/dTUXupsMnRO2H7B5AgAAAACwZehT0+Hss89ORUVFPvnJT2abbbbJ2Wef3ecHqKioyFe/+tV+T5ANK40aldI226RiypS07DkjrXvtnfb/tU86pr0xqawc6OkBAIBaAgAAtjB9ajpcf/31qaioyBlnnJFtttkm119/fZ8fQKGw6bQdcmheefSJjBtXn1XLm9Le3vn6OwEAwGaklgAAgC1Ln5oO5557bpJk22237bUMAADwWtQSAACwZelT0+GYY455zWUAAID1UUsAAMCWpV8X/v/0pz+dH/3oR6+73RVXXJE5c+b05yEAAIBhSC0BAADDW7+aDj/96U9zzz33vO52999/f+69997+PAQAADAMqSUAAGB469Pllb785S9nxYoVvcbuv//+nH322RvcZ+XKlbnzzjt7rt0KAABsedQSAACwZelT02GnnXbKOeec07NcUVGRRYsWZdGiRa+77wc/+MH+zw4AABjS1BIAALBl6VPT4QMf+EDq6+tTKpVSKpXymc98JjNmzMhxxx233u0rKipSU1OTqVOn5s1vfnNZJwwAAAwdagkAANiy9KnpUFlZmfe+9709yz/96U/zjne8I8ccc8ymmhcAADAMqCUAAGDL0qemw1/6j//4j3LPAwAA2AKoJQAAYHir7O+ObW1tueGGG/Lkk0/2jN1+++1597vfnRkzZuSUU07JI488Uo45AgAAw4haAgAAhq9+NR1WrFiRY445JmeffXYWLlyYJHnqqafysY99LH/+85+zatWq/Pa3v81JJ52UxYsXl3XCAADA0KWWAACA4a1fTYerr746jz32WPbcc8+86U1vSpL84Ac/SHt7e97znvdk4cKF+fznP5/GxsZceeWVZZ0wAAAwdKklAABgeOtX0+GXv/xlttlmm3z3u9/NbrvtliS59dZbU1FRkTPOOCOjR4/OiSeemOnTp+euu+4q64QBAIChSy0BAADDW7+aDosXL85ee+2VmpqaJF0fh160aFEmTpyYnXbaqWe7HXfcMUuWLCnPTAEAgCFPLQEAAMNbv5oOtbW1aW9v71n+9a9/nSR5+9vf3mu75cuX9xQTAAAAagkAABje+tV0mDp1av7whz9k1apVKZVKuf7661NRUZFDDjmkZ5snnngi9913X974xjeWbbIAAMDQppYAAIDhrV9NhyOPPDLLly/P7Nmz84EPfCAPPPBAtttuuxx44IFJkiuuuCInnnhiOjo6cswxx5R1wgAAwNCllgAAgOGtuj87nXLKKXn22Wfz3e9+N0my1VZb5fzzz8+IESOSJD/5yU+ybNmy/N3f/V2OP/748s0WAAAY0tQSAAAwvPWr6ZAkn/nMZzJnzpwsWbIku+yyS+rq6nrWfeITn8gb3vCGTJ8+vSyTBAAAhg+1BAAADF/9bjokycSJEzNx4sR1xt/97ncXOSwAADDMqSUAAGB4KtR06OjoyNKlS9Pa2tprvLOzM6tXr87SpUtz22235XOf+1yhSQIAAMOLWgIAAIanfjUdSqVSzjvvvPzgBz9IS0vL626vUAAAABK1BAAADHf9ajp8//vfz7e+9a0kSUNDQzo7O9PU1JSJEydmxYoVaWxsTJJMnjw5J554YvlmCwAADGlqCQAAGN4q+7PT9ddfn4qKilxwwQX53e9+l0996lNJku985ztZuHBhfvjDH2bKlClZunRpDj744HLOFwAAGMLUEgAAMLz1q+nw+OOPZ/r06T1f8jZjxoyUSqUsXLgwSbLnnnvm0ksvTUtLS6666qryzRYAABjS1BIAADC89avp0NLSkilTpvQsT506NdXV1XnkkUd6xnbZZZfsueee+cMf/lB8lgAAwLCglgAAgOGtX02HsWPHpqmpqWe5qqoqEydOzGOPPdZruwkTJuS5554rNkMAAGDYUEsAAMDw1q+mw5vf/Obcd999efnll3vG3vCGN+SPf/xj2tvbe8YWLVqUESNGFJ4kAAAwPKglAABgeOtX02H27Nlpbm7O8ccfn5///OdJkne+85155ZVX8rnPfS6PPvpoLr/88jz00EOZNm1avyZ25513Zvbs2dlzzz1zyCGH5IorrkipVNrg9q2trbniiivyrne9K3vttVdmzZqVSy+9NK2trb22e+CBB3LSSSdlxowZmTlzZr761a+usw0AALBpqCUAAGB461fT4V3veldOOumkPPXUU/nFL36RJDnmmGMyZcqUXHvttXnve9+bSy65JBUVFZk7d+5GH/++++7LmWeemZ133jmXXHJJjj766MyfPz9f//rXN7jPV77ylXzta1/L7Nmz87WvfS3ve9/7ctVVV+ULX/hCzzZPP/105syZk7q6ulx44YU57bTTcs011+RLX/rSRs8RAADYeGoJAAAY3qr7u+PnPve5HHPMMVmxYkWSpKamJt/73vdywQUX5Pe//33Gjx+fU045JW9/+9s3+tiXXXZZpk+fnvPPPz9JcuCBB6a9vT1XXnllzx/6a3v55Zfzgx/8IPPmzcvpp5+eJNl///2TJOeff37mzZuX8ePH56qrrkp9fX0uv/zy1NTU5KCDDkpdXV3OOeeczJ07N5MmTepvHAAAQB+pJQAAYPjq1ycd1thtt916/iBPkm233Tbnnntufv7zn+d73/teDj/88I0+Zmtra+6+++4cccQRvcZnzZqV5ubmLFy4cJ19Vq5cmfe///155zvf2Wt86tSpSbquB5skd911Vw4++ODU1NT0bPOud70rnZ2dueuuuzZ6rgAAQP+oJQAAYHgq1HTYFBYtWpS2traeP/LX2HHHHZMkTz755Dr7TJ48OV/4whfyhje8odf4LbfckhEjRmTq1KlpaWnJM888k5122qnXNuPHj8/o0aPXe1wAAGDoUEsAAMDA69PllU488cR+P0BFRUWuueaaPm+/5iPWo0eP7jVeX1+fJGlsbOzTcRYsWJDrrrsuJ598crbaaqu8+OKL6z3ummP39bgbUl09MP2bqqrKXrdsHPkVI79i5FeM/IqTYTHyK0Z+xQyl/NQSr28gaomhdA4NRvIrRn7FybAY+RUjv2LkV5wMi9kc+fWp6XDvvff2+wEqKio2avvOzs7X3K+y8vXD+MUvfpF58+blrW99a+bNm5ckKZVKG9y+VCpt9Dx7z6ki48bV93v/cmhoGDmgjz/Uya8Y+RUjv2LkV5wMi5FfMfIrZijkp5Z4bQNdSwyFc2gwk18x8itOhsXIrxj5FSO/4mRYzKbMr09Nh+9+97ubbAJ/qaGhIcm670JqampKsv53F63tW9/6Vs4777zsu+++PV/yliRjxozpdZy1NTc396zvj87OUlasaO73/kVUVVWmoWFkVqxYlY6OzgGZw1Amv2LkV4z8ipFfcTIsRn7FyK+YIvk1NIzcrO8KU0u8toGqJfwbLEZ+xcivOBkWI79i5FeM/IqTYTGbo5boU9Nh33333agHL2LKlCmpqqrKU0891Wt8zfK0adPWu1+pVMqXv/zlXHPNNTnyyCNz3nnn9fqSt1GjRmXChAnrHHfZsmVpbGzc4HH7qr19YE/wjo7OAZ/DUCa/YuRXjPyKkV9xMixGfsXIr5ihkJ9a4vUN5H/DoXAODWbyK0Z+xcmwGPkVI79i5FecDIvZlPkVfovTiy++mJtuuinf/OY3c+uttyZJ/vu//zttbW39Ol5tbW322Wef3HLLLb0+xrxgwYI0NDRkjz32WO9+F1xwQa655pqccsopmT9/fq8iYY2ZM2fmjjvuSGtra8/YL37xi1RVVeVtb3tbv+YLAAD0j1oCAACGnz590mF9Vq5cmXPOOSc33XRTOjo6kiRHHXVUDjvssHzlK1/J4sWLc8kll2Svvfba6GPPnTs3c+bMyVlnnZVjjz02999/f66++urMmzcvdXV1aWxszGOPPZYpU6Zk/Pjxefjhh/ONb3wjb3nLW3LkkUfmD3/4Q6/jTZs2LaNHj87pp5+eG2+8MaeffnrmzJmTJ598MhdccEGOP/74TJw4sb9RAAAAG0EtAQAAw1e/PumwatWq/N3f/V2uv/76bLXVVpk1a1avdxLV1tZmyZIlOfXUU7No0aKNPv7++++fSy65JE888UQ+8pGP5IYbbsjZZ5+d008/PUny4IMP5vjjj88dd9yRJLn55ptTKpXyxz/+Mccff/w6Pw8++GCSZOedd843v/nNtLS05OMf/3i+9a1v5ZRTTslnP/vZ/sQAAABsJLUEAAAMbxWltf/C76NLL700l156aY455pj88z//c+rq6jJ9+vQcffTROe+885Ik8+fPzxVXXJHjjjsuX/rSl8o+8cGko6Mzy5at+6Vym0N1dWXGjavP8uVNrmHWD/IrRn7FyK8Y+RUnw2LkV4z8iimS3/jx9Zv1i6T/klqit4GqJfwbLEZ+xcivOBkWI79i5FeM/IqTYTGbo5boV7Vx0003ZcKECTnnnHNSV1e33m0+8YlPZPLkybn77rv78xAAAMAwpJYAAIDhrV9Nh8WLF2fPPfdMdfWGvxKioqIi06dPz/PPP9/vyQEAAMOLWgIAAIa3fjUdRo4cmSVLlrzudi+++OIG370EAABsedQSAAAwvPWr6bD77rvnv//7v/Poo49ucJuHH344Dz74YPbYY49+Tw4AABhe1BIAADC89avpMGfOnLS3t+eMM87ILbfckpUrV/asa2try+23356PfOQj6ejoyIknnli2yQIAAEObWgIAAIa3DV9I9TXMnDkzZ511Vi666KJ8/OMfT9J13dUFCxbkxhtvTGdnZ0qlUk477bQcfPDB5ZwvAAAwhKklAABgeOtX0yFJ5s6dm7322itXX3117r333qxatSqrV69OdXV19tlnn/zd3/1dDjvssHLOFQAAGAbUEgAAMHz1u+mQJPvvv3/233//dHZ25uWXX05HR0fGjh2bESNGlGt+AADAMKSWAACA4alQ02GNysrKjB8/vhyHAgAAtiBqCQAAGF769UXSAAAAAAAAf0nTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACiLQk2Hxx9/PF/4whfy7ne/OzNmzMinPvWpJMk555yTa665JqVSqSyTBAAAhhe1BAAADE/V/d3xJz/5Sb74xS+mtbW1Z6yzszNJ8rvf/S7f//73c88992T+/PmprPSBCgAAoItaAgAAhq9+/QV/77335vOf/3zq6upy9tln52c/+1mv9WeddVYmTJiQm2++Oddff31ZJgoAAAx9agkAABje+tV0+MY3vpHKyspcddVVOfXUUzNt2rRe6w877LB85zvfSVVVVX74wx+WZaIAAMDQp5YAAIDhrV9Nh/vvvz8zZszIHnvsscFtdtxxx7z1rW/NU0891e/JAQAAw4taAgAAhrd+NR1WrVqVhoaG192utrY2TU1N/XkIAABgGFJLAADA8NavpsOkSZPy0EMPpaOjY4PbtLW15aGHHsoOO+zQ78kBAADDi1oCAACGt341HQ4//PA8//zz+bd/+7cNbnPBBRdkyZIlOfTQQ/s9OQAAYHhRSwAAwPBW3Z+d/v7v/z433XRTvv3tb+e3v/1t3vrWtyZJnnzyyVx00UX59a9/nQcffDATJkzIaaedVtYJAwAAQ5daAgAAhrd+NR3GjBmT//iP/8i8efNy77335uGHH06SPPDAA3nggQeSJG9+85tzwQUXZNy4ceWbLQAAMKSpJQAAYHjrV9MhSSZOnJjvfe97eeCBB/Lb3/42zz33XDo6OrLddtvlrW99a/bbb79yzhMAABgm1BIAADB89bvpsMZb3vKW7LHHHj3LjY2NKZVKRQ8LAAAMc2oJAAAYfvr1RdJJ8txzz+WjH/1oPvzhD/ca//Wvf539998/H/vYx7Js2bLCEwQAAIYXtQQAAAxf/Wo6vPDCC3nf+96XW2+9Nc8//3yvdTU1NRk7dmxuueWW/O3f/m1eeumlskwUAAAY+tQSAAAwvPWr6XD55Zdn6dKlOf300/OTn/yk17pDDz00d955Z04//fQ8++yzufTSS8syUQAAYOhTSwAAwPDWr6bD//t//y/Tpk3LvHnzUlNTs+5BKyszb968TJ06NbfffnvhSQIAAMODWgIAAIa3fl9eadq0aa+73S677JKlS5f25yEAAIBhSC0BAADDW7+aDltvvXUef/zx191u8eLFGTduXH8eAgAAGIbUEgAAMLz1q+nwjne8I4899li+//3vb3Cb66+/Pg899FDe/va393tyAADA8KKWAACA4a26PzudfvrpufHGG3POOefkzjvvzCGHHJKJEycm6fq49J133plbb701I0eOzBlnnFHWCQMAAEOXWgIAAIa3fjUdpkyZkksvvTT/9E//lDvuuCO/+tWveq0vlUrZeuut8+///u/ZaaedyjJRAABg6FNLAADA8NavpkOS7L///vnFL36RX/7yl/nd736XJUuWpL29Pdtuu2323nvvvPvd786oUaPKOVcAAGAYUEsAAMDw1e+mQ5KMGjUqRx11VI466qhyzQcAANgCqCUAAGB46tcXSQMAAAAAAPylPn3S4eCDD05FRUW++93vZvLkyTn44IP7/AAVFRW5/fbb+zs/AABgCFNLAADAlqVPTYfnn38+FRUVaW9v71nuq4qKiv7NDAAAGPLUEgAAsGXpU9Phl7/8ZZJkwoQJvZYBAABei1oCAAC2LH1qOkyaNKnX8h133JFdd901++yzzyaZFAAAMDyoJQAAYMvSp6bDX7r00kvT0NCQBQsWlHs+AADAMKaWAACA4a2yPzs1Nzdnl112KfdcAACAYU4tAQAAw1u/mg4HHnhg7r777jzzzDPlng8AADCMqSUAAGB469fllU4++eT8z//8T44++ugceuih2WWXXbLVVluloqJivdv/7d/+baFJAgAAw4NaAgAAhrd+NR0++MEPpqKiIqVSKddff/0GC4Q1FAoAAECilgAAgOGuX02H9773va9bHAAAAPwltQQAAAxv/Wo6/Ou//mu55wEAAGwB1BIAADC89euLpAEAAAAAAP5Snz/p0NHRke9///u5+eabs3Tp0uywww456qij8t73vncTTg8AABjq1BIAALDl6FPTobW1NaeddloWLlyYUqmUJHniiSfyX//1X7n99ttz0UUXbdJJAgAAQ5NaAgAAtix9ajr84Ac/yD333JMJEybk7//+7zN58uT86U9/ylVXXZWbb7451113Xd7znvds6rkCAABDjFoCAAC2LH1qOvziF79IXV1d/vM//zM77LBDkuSggw7KAQcckGOOOSY33nijQgEAAFiHWgIAALYsffoi6ccffzz77LNPT5GwxvTp07PbbrvlkUce2SSTAwAAhja1BAAAbFn61HRoamrKVltttd51f/VXf5WXX365nHMCAACGCbUEAABsWfrUdGhvb09VVdV6140YMSJtbW1lnRQAADA8qCUAAGDL0qemAwAAAAAAwOvRdAAAAAAAAMpC0wEAAAAAACiL6r5ueOutt+bQQw9dZ3z58uVJst51SVJRUZFbb721n9MDAACGOrUEAABsOfrcdGhubk5zc/MG1z/zzDPrHa+oqNj4WQEAAMOGWgIAALYcfWo6fPe7393U8wAAAIYhtQQAAGxZ+tR02HfffTf1PAAAgGFILQEAAFsWXyQNAAAAAACUhaYDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZaHpAAAAAAAAlMWgbTrceeedmT17dvbcc88ccsghueKKK1Iqlfq07x//+MfstttuWbx48TrrZs6cmV133XWdnyVLlpT7KQAAAANALQEAAAOneqAnsD733XdfzjzzzBx55JH5xCc+kXvvvTfz589PZ2dn5s6d+5r7PvLII/nwhz+c9vb2ddYtXbo0S5cuzac//enstddevdaNHTu2jM8AAAAYCGoJAAAYWIOy6XDZZZdl+vTpOf/885MkBx54YNrb23PllVdmzpw5qaurW2ef1tbWXHPNNbnooovWuz5JHnrooSTJ4YcfnkmTJm26JwAAAAwItQQAAAysQXd5pdbW1tx999054ogjeo3PmjUrzc3NWbhw4Xr3u/POO3PppZfmjDPOyLx589a7zSOPPJKGhgZFAgAADENqCQAAGHiDrumwaNGitLW1ZerUqb3Gd9xxxyTJk08+ud79dt9999x2222ZO3duqqqq1rvNww8/nIaGhnz0ox/N3nvvnRkzZuQf/uEf8uKLL5bzKQAAAANALQEAAANv0F1eacWKFUmS0aNH9xqvr69PkjQ2Nq53vwkTJrzusR9++OG88MILOe6443LKKafk8ccfz8UXX5wPfvCD+elPf5pRo0b1e97V1QPTv6mqqux1y8aRXzHyK0Z+xcivOBkWI79i5FeM/NZPLdF3zqFi5FeM/IqTYTHyK0Z+xcivOBkWsznyG3RNh87OziRJRUXFetdXVvY/jHPPPTe1tbV585vfnCTZZ599Mm3atJxwwgm59tprc8IJJ/TruJWVFRk3rr7f8yqHhoaRA/r4Q538ipFfMfIrRn7FybAY+RUjv2Lk15taYuM5h4qRXzHyK06GxcivGPkVI7/iZFjMpsxv0DUdGhoakqz7LqSmpqYk675raWPMmDFjnbG99947Y8aMySOPPNLv43Z2lrJiRXO/9y+iqqoyDQ0js2LFqnR0dA7IHIYy+RUjv2LkV4z8ipNhMfIrRn7FFMmvoWHksH1XmFqi7/wbLEZ+xcivOBkWI79i5FeM/IqTYTGbo5YYdE2HKVOmpKqqKk899VSv8TXL06ZN69dxV6xYkZtvvjl77bVXr2OUSqW0tbVl3Lhx/Z90kvb2gT3BOzo6B3wOQ5n8ipFfMfIrRn7FybAY+RUjv2Lk15taYuM5h4qRXzHyK06GxcivGPkVI7/iZFjMpsxv0L3Fqba2Nvvss09uueWWlEqlnvEFCxakoaEhe+yxR7+OO2LEiHzxi1/MlVde2Wv8l7/8ZVpaWrLffvsVmjcAADCw1BIAADDwBt0nHZJk7ty5mTNnTs4666wce+yxuf/++3P11Vdn3rx5qaurS2NjYx577LFMmTIl48eP79MxR44cmdNPPz2XX355tt566xx44IF59NFHc8kll+Tggw/O29/+9k38rAAAgE1NLQEAAANrUDYd9t9//1xyySW5+OKL85GPfCQTJkzI2WefnVNPPTVJ8uCDD+bkk0/Oueeem9mzZ/f5uB/72MeyzTbb5D//8z/zve99L2PHjs3xxx+fj3/845vqqQAAAJuRWgIAAAZWRWntzx3TLx0dnVm2rGlAHru6ujLjxtVn+fIm1zDrB/kVI79i5FeM/IqTYTHyK0Z+xRTJb/z4+mH7RdJD0UDVEv4NFiO/YuRXnAyLkV8x8itGfsXJsJjNUUuoNgAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKIvqgZ4AAAAMdqVSKR2ljnSUOtLe2Z7O7tuOUmfXeGd7921H97qOnu1f3bYjHaXOdHZ2pL3Unr8a/Vd5w9hpA/3UAAAAykrTAQCADeosdaa9s737py3tpfa0d3Z03e9sT3upPR2dHWvd79629Oo2HT3La+63p5TO1I6syiuNTWltb+sZb+989QX8rhfq1zzemvtdy52lju7t27u37+zZpqP7Rf2Ozo5ex+ka73389lJHTxOga/tXj7V2s6Cz1LlJ8r3npAeyY8PUTXJsAACAgaDpAABQBmveCd/W2Za2jta0db9I39b9097ZntaO1p6x9s72tda19dq+17qOtp4X8F8da+/Zr73nhfi1xjo7eh2rvecF/TWP0/5q0+Av1q95gX/NsTfVi+3DSUUqUlVZlaqKqlRVVHffr0x1ZXUqK7rGu+5Xdm/TtbzjVjtlu1ETBnr6AAAAZaXpAAAMOmtewG/taE1bZ2taO9rS2rE6rZ2taeto675tTWtnW/f61u4X+3svt3a2pr2jrWu7jtae/dt69ut6kb61s6sZ0Hv51SZBa/eL+V3L7T3bv/qYXT9bkhGVI1JdWZ3qyhGprqhKVWV113L3i+6v3q/u3rbrBfnqyjVj1amrrUk6KlOZqp71VZVVPftV97rfdbzKyspUdx+nsmLN47z6+Gte0K+qqOp1rK7x3o9RWVnVtW9PU+DVfdc8Tu91Vd3rqnrWVVVWpbLC16QBAACsoekAAFuwjs6ONLc1p3n1qqzubO16Yb9jdVZ3tPa67XrBv617bHVaO1qzumN1zwv8PT89x2hLa+fqnvG2zu7tO9q699twE6G1+/illAY6nsIqKyq7X3AfkRGV1RlRWdO1XLVm+dV1Xbdrbzui58X59a1bM1ZVWdWzXL3W9tVrjlGx7vqqtY6x5oX96p4mQlV3I6E61VXdt2vG1moqFFVdXZlx4+qzfHlT2tt9mgIAAGC40HQAgAHQ0dmRlo6WrO5oSWtHa1raW7K6Y3VWd6y5XZ3V7S1p6R57dZuu9S3tLd0v/K+1fceaF/lXp2VNo6DX/daex1hzv6PUMdBR9FlNZU1GVNWkpnJEaqpqM6JyRGqqul7EXzPedVuT6srq7nU1qaka0fNi/4iqET3HWdMEqKmqSXXliNR0vwjftdz1ovyIypqMqBrRfX9Ez341lTWpranJtuPGpnllWypKVb0aAiO65+Ud8AAAAGxpNB0A2GKVSqW0dbZldUdLVrW3pKV9VfcL+qu6ljtWdb/w35JV7at6XvRfe9vVHS1paV/dvW338ppGQHvXtq82Brq2Xd3RMigvxVORitRW1aamqjY13S/e11TV9Bqr7XVb27NN1/0R3dutaQrU9Nzv2a6ypmebEZVdxxmx1jZrNwV6jtfdRKioqBjoiHrpead+pXfqAwAAwBqaDgAMKqVSKas7VmdVe3NWta/qvm1Za3lVVrU1p7W0OhU1HVm64uU0tzanpbsRsKZZ0NK9T9ftqrR0dK1v6TlW13aD4UtyqyurU1NZm7rq2tRW1aW2qjZ11XWpqartut89Vltdl9qqmp5tun7qepoAtdVdjYDayq77azcGuo7X9YJ/Xfc+o2pGZsLW49K8sj1VpRGD8oV9AAAAYGjRdACgz9Y0BJrbm9Lc1tUEaG5r6rptb+4e6x5vb8qqtlWv3m9f1fXdAe1rbdPW3N0oWNWrqTBQ1/Kvq6pLXXVd6qpHvnq/qmu5tqo2I6tH9qyv7V4/smpk9wv8danraQx0bbumKVBb3b1urWOuaRDUVdWlunJg/ndcXV2ZcaPqU7naO/UBAACA8tB0ABiGWjta09TWmOa25jS1NXXdb29e71hXI6Cp121Te/OrzYS2pl7bbc5PBoyoHJGR1aO6XtyvHplR1aMysnpkRlaPysgRI9MwanSqO2u6X/DvagZ0NQZGZmR1XeqqXm0SjFyzrnu7Ncdcu6ngXf4AAAAAxWg6AAygUqmUVe2r8sqqlWlqa0xja2NPQ6CprSmNbSu7l5vS3NaYxrZX1ze2NqZpTZNgTTOhvWtde2f7Jp/7mnfzj6quz6gRo7oaAd0v7I8aUd/TJOi9bs1y9/01DYTqkRm51viahsGIqhEbfPye6+kv9y59AAAAgMFC0wFgI7V1tKWxbWVWtnb9dDUCVvY0DBq77ze2Nf7F/cY0dW+/ZqyprTEdpY5NNteayprUj6jPqBH1XbfVo1I/YnRGjRjVvdzVMOi5Xfv+etbVr9VgGKhLAgEAAAAweHnFCNgilEqltHS0ZEXrijS2rsiK1SuysqdxsCKNazUQVrau6L7f1TDo2q57rHVlWjpaNskcuz4V0NUcGD1iTOq779ePGJ3RNaO77levdX/E6IyqHpXRNaMzqvrVbdduKLzWJwUAAAAAoNw0HYBBr1Qqpam9KStWv5IVrSvyyupXsrL1lbzSvbymcbCydUV3U2FlVnTfX9nzszJtnW1lnVddVV13A2B0Ro8Yk9E1ozP6L+7X13QvdzcO1l631ciGTNpmu7Q3V6a2YmSqKqvKOj8AAAAA2Nw0HYBNrrPUmZXdzYJXVr+cV7obBq+sfrm7cfDKqw2F1leycvWKte53jZfrEkQVqcjomjEZM2JMGmobMnrEmIypGZMxNQ0ZUzMmo2u6GgRrlsesaRLUNGRMz7ZjMnrEmMKfIqiursy4hvos7/CdBAAAAAAMD5oOQJ+0dbTl5dUv55XVL2f56mV5ZfXLWdm2Iq1VzXlu+YtZtmp5Vqx+JS+vfjkr1m4qdDcUSikVnkNVRVW2qt0qY2oaslXt2DTUNGRMTUP37Zju263Wuj+m13JDbUPqR4xOZUVlGRIBAAAAAP6SpgNsQUqlUla2rsjy1cvzcsvyLGtZ1t1EWJ5XVr+cl1e/nJdblq/VXHh1vKmtsfDj11XVpaF2q4ytHZuGmq2yVW3XT0NN90/tVj3Nga1qtsqYmjXrG9JQu1VGVY9KRUVFGZIAAAAAADYFTQcYgtZ8x8HylmXdP8u7btc0E1Yvy8t/MbZ8ddd2RS9T1FCzVcbWjcvY2rEZVzc2247ZJqMqRmfMiDVNhLFdtzVr7o9NQ/dyXXVdmRIAAAAAAAYjTQcYYGs+ffBSy0tZ3rIsy1peyrLuZkLX/eVZ1r3upVUvZfnqZVm26qW0drb2+zFHVo/M2NpxGVs7LuPqxnXf72oQjKsbl61qx2Zs7dhXx+vGZlztuDTUbNXry46rqyszblx9li/3nQQAAAAAgKYDlF1rR2uWtbyUpauW5qVVS7Os5aW8tGppXuq+XdayrGd86aqlWb56Wdo72/v1WDWVNRk/cuuMqx2XcXXje5oIve7Xju8ZG1c7LmPrxmVk9cgyP2sAAAAAAE0HeF2tHa15adXSLF21JEtWLcnSVUuytHt56aolvRoIy1qWZWXrin49zqjqURlXNz7j67bOuLrx2bpufM/y+Lrx3c2F8a/erxuf+up633EAAAAAAAwamg5scUqlUpavXpYlzUuybPWSrHpmZZ5aujgvNL2Ypc2vNhPWNBdWtL6y0Y9RWVGZ8XVbZ5uR22R83dbZuud262zdvbx13TYZ3708rm68Tx8AAAAAAEOepgPDQmepM8tblufF5heyZNWLWdL8YvftkrWWl/SMb+zljKoqqrLNyG2z9chtss3IbbPNyG2y7VrL43saCV2Nha1qx6ayonITPVsAAAAAgMFJ04FBramtKS82v5AXml/IkuYX8kLT83mx+cW80Pz8WuMvZumqJekodWzUscfWjs22o7bLxIbtM3bE+Gxdt6ah0NVUWPu+JgIAAAAAwOvTdGCzW3N5o+ebns/zTc/lxeYXen5eaHohL656tbnQ2LZyo449rnZcth21XbYduV22G7Vdz/2u2217lrcZtW1qq2pTXV2ZcePqs3x5U9rbOzfRMwYAAAAA2DJoOlA2pVIpK1tXdDUTmp/L803P5fmm5/NC03N5vrmrwfBC0/N5ofn5rO5Y3efjjqweme1GTciEUdt33dZPyHYjJ2RC/fbZbtR22W7UhGw7crtsPXKb1FTVbMJnCAAAAADAa9F0oE/aOtryQvPzea7p2TzX+Gyea3o2zzY+m+ebnu3VUGhub+7zMcfXjc+EUdt3Nw/WNBW2691cGDUho0eMSUVFxSZ8dgAAAAAAlIOmA2lqa1qrkfBMnm96rut+07N5vrHrdknziyml1KfjbVU7NtuP2j4T6idm+/rts/2ortue5fqJ2W7UhNRW1W7iZwYAAAAAwOak6TDMtbS35NmmZ/Js4zN5ZuXiPNv4TBY3Ls6zjV33n216Nq+sfrlPxxpROSIT63fI9vUTs8PoHbJ9/Q6ZWL9DJtZPzPb1EzOhfvtMGLV9Ro0YtWmfFAAAAAAAg5KmwxD3QtMLeWjlc3n4uf/J068syrONi/NMY1eT4dnGxVm6ammfjlM/YnR2qN8hE0dPysS1mgo7dC9PrJ+UrUduncqKyk38jAAAAAAAGKo0HYawGx6/Nqcv+LvXvezRqOpR2WH0pOww+q8yafSk7DB6UiaN/qu1bnfImJqGzTRrAAAAAACGK02HIWxMTUO2HbVt6mvqM3HUDplY391EGLN2U2FSxtWO90XMAAAAAABscpoOQ9jBk9+ZR07/c8aNq8/y5U1pb+8c6CkBAAAAALAFc4F+AAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAymLQNh3uvPPOzJ49O3vuuWcOOeSQXHHFFSmVSn3a949//GN22223LF68eJ11DzzwQE466aTMmDEjM2fOzFe/+tW0traWe/oAAMAAUUsAAMDAGZRNh/vuuy9nnnlmdt5551xyySU5+uijM3/+/Hz9619/3X0feeSRfPjDH057e/s6655++unMmTMndXV1ufDCC3PaaaflmmuuyZe+9KVN8TQAAIDNTC0BAAADq3qgJ7A+l112WaZPn57zzz8/SXLggQemvb09V155Zc8f+n+ptbU111xzTS666KL1rk+Sq666KvX19bn88stTU1OTgw46KHV1dTnnnHMyd+7cTJo0aZM+LwAAYNNSSwAAwMAadJ90aG1tzd13350jjjii1/isWbPS3NychQsXrne/O++8M5deemnOOOOMzJs3b73b3HXXXTn44INTU1PTM/aud70rnZ2dueuuu8r3JAAAgM1OLQEAAANv0DUdFi1alLa2tkydOrXX+I477pgkefLJJ9e73+67757bbrstc+fOTVVV1TrrW1pa8swzz2SnnXbqNT5+/PiMHj16g8cFAACGBrUEAAAMvEF3eaUVK1YkSUaPHt1rvL6+PknS2Ni43v0mTJjQr+OuOfaGjttX1dUD07+pqqrsdcvGkV8x8itGfsXIrzgZFiO/YuRXjPzWTy3Rd86hYuRXjPyKk2Ex8itGfsXIrzgZFrM58ht0TYfOzs4kSUVFxXrXV1b2L4xSqfSa6zb0eH1RWVmRcePq+71/OTQ0jBzQxx/q5FeM/IqRXzHyK06GxcivGPkVI7/e1BIbzzlUjPyKkV9xMixGfsXIrxj5FSfDYjZlfoOu6dDQ0JBk3XchNTU1JVn/u4v6YsyYMb2Os7bm5uae9f3R2VnKihXN/d6/iKqqyjQ0jMyKFavS0dE5IHMYyuRXjPyKkV8x8itOhsXIrxj5FVMkv4aGkcP2XWFqib7zb7AY+RUjv+JkWIz8ipFfMfIrTobFbI5aYtA1HaZMmZKqqqo89dRTvcbXLE+bNq1fxx01alQmTJiwznGXLVuWxsbGfh93jfb2gT3BOzo6B3wOQ5n8ipFfMfIrRn7FybAY+RUjv2Lk15taYuM5h4qRXzHyK06GxcivGPkVI7/iZFjMpsxv0L3Fqba2Nvvss09uueWWXh9jXrBgQRoaGrLHHnv0+9gzZ87MHXfckdbW1p6xX/ziF6mqqsrb3va2QvMGAAAGlloCAAAG3qBrOiTJ3Llz84c//CFnnXVWfvWrX+XCCy/M1VdfnQ9/+MOpq6tLY2Njfv/732fZsmUbddzTTz89L730Uk4//fTcfvvt+da3vpVzzz03xx9/fCZOnLiJng0AALC5qCUAAGBgDcqmw/77759LLrkkTzzxRD7ykY/khhtuyNlnn53TTz89SfLggw/m+OOPzx133LFRx915553zzW9+My0tLfn4xz+eb33rWznllFPy2c9+dhM8CwAAYHNTSwAAwMCqKK39uWP6paOjM8uWrfulcptDdXVlxo2rz/LlTa5h1g/yK0Z+xcivGPkVJ8Ni5FeM/Iopkt/48fXD9oukh6KBqiX8GyxGfsXIrzgZFiO/YuRXjPyKk2Exm6OWUG0AAAAAAABlUT3QEwAAAGDzKpWSpqaun/b2gZ7N0FNdndTUyK+/5FecDIuRXzHyK0Z+xckwGTUqqagY6FlsmKYDAADAFqRUSo48si6/+12S1A/0dIY4+RUjv+JkWIz8ipFfMfIrbsvNcN9923PDDasGbePB5ZUAAAC2MIO1QAUAYOjzSQcAAIAtSEVFctNNLamt9QWM/eULLIuRX3EyLEZ+xcivGPkVJ0OXVwIAAGCQqahI6uuT1tYt91rIRVRXy68I+RUnw2LkV4z8ipFfcTIc/FxeCQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoi+qBngAAAACbWamUNDV1/bR3DvRshp7qyqQm8usv+RUnw2LkV4z8ipFfcTJMRo1KKioGehYbpOkAAACwJSmVMubII5Lf/TbjBnouQ5z8ipFfcTIsRn7FyK8Y+RW3JWfYtu/b8vINCwZt48HllQAAALY0g7RABQBg6PNJBwAAgC1JRUVW3nRzxtVWZPnyprRvqZclKKC6ujLjxtXLr5/kV5wMi5FfMfIrRn7FyTAurwQAAMAgU1GR1Ncnrdlyr4VcRHWl/IqQX3EyLEZ+xcivGPkVJ8NBz+WVAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAymLQNh3uvPPOzJ49O3vuuWcOOeSQXHHFFSmVSq+5z3XXXZe//uu/zh577JFZs2blRz/60TrbzJw5M7vuuus6P0uWLNlUTwUAANiM1BIAADBwqgd6Autz33335cwzz8yRRx6ZT3ziE7n33nszf/78dHZ2Zu7cuevd5+c//3n+6Z/+KSeffHIOOOCA3Hrrrfnc5z6X2traHH300UmSpUuXZunSpfn0pz+dvfbaq9f+Y8eO3cTPCgAA2NTUEgAAMLAGZdPhsssuy/Tp03P++ecnSQ488MC0t7fnyiuvzJw5c1JXV7fOPhdeeGFmzZqVz3zmM0mSAw44IK+88kouueSSnkLhoYceSpIcfvjhmTRp0mZ6NgAAwOailgAAgIE16C6v1NramrvvvjtHHHFEr/FZs2alubk5CxcuXGefxYsX58knn1zvPk8//XSeeOKJJMkjjzyShoYGRQIAAAxDagkAABh4g67psGjRorS1tWXq1Km9xnfcccckyZNPPrnOPo8//niSvO4+Dz/8cBoaGvLRj340e++9d2bMmJF/+Id/yIsvvljW5wAAAGx+agkAABh4g+7ySitWrEiSjB49utd4fX19kqSxsXGdfVauXNmnfR5++OG88MILOe6443LKKafk8ccfz8UXX5wPfvCD+elPf5pRo0b1e97V1QPTv6mqqux1y8aRXzHyK0Z+xcivOBkWI79i5FeM/NZPLdF3zqFi5FeM/IqTYTHyK0Z+xcivOBkWsznyG3RNh87OziRJRUXFetdXVq4bxob2KZVKvfY599xzU1tbmze/+c1Jkn322SfTpk3LCSeckGuvvTYnnHBCv+ZcWVmRcePq+7VvuTQ0jBzQxx/q5FeM/IqRXzHyK06GxcivGPkVI7/e1BIbzzlUjPyKkV9xMixGfsXIrxj5FSfDYjZlfoOu6dDQ0JBk3XchNTU1JVn3HUivtU9zc3OvfWbMmLHOvnvvvXfGjBmTRx55pN9z7uwsZcWK5n7vX0RVVWUaGkZmxYpV6ejoHJA5DGXyK0Z+xcivGPkVJ8Ni5FeM/Iopkl9Dw8hh+64wtUTf+TdYjPyKkV9xMixGfsXIrxj5FSfDYjZHLTHomg5TpkxJVVVVnnrqqV7ja5anTZu2zj477bRTzzZr3nn0l/usWLEiN998c/baa69exyiVSmlra8u4ceMKzbu9fWBP8I6OzgGfw1Amv2LkV4z8ipFfcTIsRn7FyK8Y+fWmlth4zqFi5FeM/IqTYTHyK0Z+xcivOBkWsynzG3Rvcaqtrc0+++yTW265pecjzUmyYMGCNDQ0ZI899lhnnx133DGTJ0/OggULeo0vWLAgU6dOzaRJkzJixIh88YtfzJVXXtlrm1/+8pdpaWnJfvvtt2meEAAAsFmoJQAAYOANuk86JMncuXMzZ86cnHXWWTn22GNz//335+qrr868efNSV1eXxsbGPPbYY5kyZUrGjx+fJDnzzDPz6U9/OmPHjs073/nO3Hbbbfn5z3+e+fPnJ0lGjhyZ008/PZdffnm23nrrHHjggXn00UdzySWX5OCDD87b3/72gXzKAABAGaglAABgYA3KpsP++++fSy65JBdffHE+8pGPZMKECTn77LNz6qmnJkkefPDBnHzyyTn33HMze/bsJMns2bPT2tqab37zm/nJT36SyZMn56tf/Wre/e539xz3Yx/7WLbZZpv853/+Z773ve9l7NixOf744/Pxj398QJ4nAABQXmoJAAAYWBWltT93TL90dHRm2bKmAXns6urKjBtXn+XLm1zDrB/kV4z8ipFfMfIrTobFyK8Y+RVTJL/x4+uH7RdJD0UDVUv4N1iM/IqRX3EyLEZ+xcivGPkVJ8NiNkctodoAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAykLTAQAAAAAAKAtNBwAAAAAAoCw0HQAAAAAAgLLQdAAAAAAAAMpC0wEAAAAAACgLTQcAAAAAAKAsNB0AAAAAAICy0HQAAAAAAADKQtMBAAAAAAAoC00HAAAAAACgLDQdAAAAAACAstB0AAAAAAAAyqJ6oCcAAADA5lUqldLU2pSmtqa0t3cO9HSGnOpSZWpaI79+kl9xMixGfsXIrxj5FSfDZFT1qFRUVAz0NDZI0wEAAGALUiqVcuSPj8jvnvvtQE8FAIB+2Hf7t+WGYxYM2saDyysBAABsYSoyOAtUAACGPp90AAAA2IJUVFTkpr+9ObWjK7L85S33sgRFVFdXZtzYevn1k/yKk2Ex8itGfsXIrzgZurwSAAAAg0xFRUXqa+rTOiJpr9gyi/Uiqqsr5VeA/IqTYTHyK0Z+xcivOBkOfi6vBAAAAAAAlIWmAwAAAAAAUBaaDgAAAAAAQFloOgAAAAAAAGWh6QAAAAAAAJSFpgMAAAAAAFAWmg4AAAAAAEBZaDoAAAAAAABloekAAAAAAACUhaYDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZaHpAAAAAAAAlIWmAwAAAAAAUBaaDgAAAAAAQFloOgAAAAAAAGWh6QAAAAAAAJSFpgMAAAAAAFAWmg4AAAAAAEBZaDoAAAAAAABloekAAAAAAACUhaYDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZaHpAAAAAAAAlIWmAwAAAAAAUBaaDgAAAAAAQFloOgAAAAAAAGWh6QAAAAAAAJSFpgMAAAAAAFAWmg4AAAAAAEBZaDoAAAAAAABloekAAAAAAACUhaYDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZaHpAAAAAAAAlIWmAwAAAAAAUBaaDgAAAAAAQFloOgAAAAAAAGWh6QAAAAAAAJSFpgMAAAAAAFAWmg4AAAAAAEBZaDoAAAAAAABloekAAAAAAACUhaYDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZTFomw533nlnZs+enT333DOHHHJIrrjiipRKpdfc57rrrstf//VfZ4899sisWbPyox/9aJ1tHnjggZx00kmZMWNGZs6cma9+9atpbW3dVE8DAADYzNQSAAAwcAZl0+G+++7LmWeemZ133jmXXHJJjj766MyfPz9f//rXN7jPz3/+8/zTP/1TZs6cmcsuuyxve9vb8rnPfS7XX399zzZPP/105syZk7q6ulx44YU57bTTcs011+RLX/rS5nhaAADAJqaWAACAgVU90BNYn8suuyzTp0/P+eefnyQ58MAD097eniuvvLLnD/2/dOGFF2bWrFn5zGc+kyQ54IAD8sorr/QUGkly1VVXpb6+Ppdffnlqampy0EEHpa6uLuecc07mzp2bSZMmbb4nCQAAlJ1aAgAABtag+6RDa2tr7r777hxxxBG9xmfNmpXm5uYsXLhwnX0WL16cJ598cr37PP3003niiSeSJHfddVcOPvjg1NTU9Gzzrne9K52dnbnrrrs2wbMBAAA2F7UEAAAMvEHXdFi0aFHa2toyderUXuM77rhjkuTJJ59cZ5/HH388SV5zn5aWljzzzDPZaaedem0zfvz4jB49er3HBQAAhg61BAAADLxBd3mlFStWJElGjx7da7y+vj5J0tjYuM4+K1eufN19NnTcNdut77h9VVlZkfHj6/u9fxEVFV23W201Mq/z3Xish/yKkV8x8itGfsXJsBj5FSO/YorkV1lZUf4JDRJqib7zb7AY+RUjv+JkWIz8ipFfMfIrTobFbI5aYtA1HTo7O5MkFRXrfwKVlet+OGND+5S6U6usrOy5vz6lUmmDj9cXFRUVqaoa2OJtfbnQd/IrRn7FyK8Y+RUnw2LkV4z8ipFfb2qJjeccKkZ+xcivOBkWI79i5FeM/IqTYTGbMr9B91+moaEhybrvQmpqakqy/ncXbWif5ubmnn3GjBnT6zh/ud2a9QAAwNCklgAAgIE36JoOU6ZMSVVVVZ566qle42uWp02bts4+a66t+lr7jBo1KhMmTFhnm2XLlqWxsXG9xwUAAIYOtQQAAAy8Qdd0qK2tzT777JNbbrml18eYFyxYkIaGhuyxxx7r7LPjjjtm8uTJWbBgQa/xBQsWZOrUqZk0aVKSZObMmbnjjjvS2tras80vfvGLVFVV5W1ve9smekYAAMDmoJYAAICBN+i+0yFJ5s6dmzlz5uSss87Ksccem/vvvz9XX3115s2bl7q6ujQ2Nuaxxx7LlClTMn78+CTJmWeemU9/+tMZO3Zs3vnOd+a2227Lz3/+88yfP7/nuKeffnpuvPHGnH766ZkzZ06efPLJXHDBBTn++OMzceLEgXq6AABAmaglAABgYFWUXutb0QbQLbfckosvvjhPPPFEJkyYkBNPPDGnnnpqkuTuu+/OySefnHPPPTezZ8/u2ecHP/hBvvnNb+a5557L5MmT86EPfSjvfe97ex134cKFOe+88/Lwww9n3Lhxec973pOzzjor1dWDsv8CAABsJLUEAAAMnEHbdAAAAAAAAIaWQfedDgAAAAAAwNCk6QAAAAAAAJSFpgMAAAAAAFAWmg4AAAAAAEBZaDoAAAAAAABloekAAAAAAACUhabDEHbnnXdm9uzZ2XPPPXPIIYfkiiuuSKlUGuhpDQmrVq3Km970puy66669fnbfffeBntqg99xzz2WfffbJ3Xff3Wv8z3/+cz70oQ9l7733zn777ZfPfOYzWbFixQDNcvDaUH7HHXfcOufjrrvumt///vcDM9FBpFQq5Yc//GGOOuqozJgxI4ceemj+5V/+JY2NjT3bOP82rC/5Of82rKOjI1deeWUOP/zw7LHHHjn66KNz3XXX9drG+bdhfcnP+dd3H/3oR/POd76z15jzj/5QR/SfOqL/1BHFqCM2njqiGHVEcWqJYtQS5bW5a4nqshyFze6+++7LmWeemSOPPDKf+MQncu+992b+/Pnp7OzM3LlzB3p6g96jjz6azs7OXHDBBZk0aVLPeGWlPtxreeaZZ3Laaadl5cqVvcZXrFiRU045Jdttt13OO++8vPTSSzn//PPz/PPP55vf/OYAzXbw2VB+nZ2d+dOf/pTTTjstRxxxRK91b3zjGzfnFAelq666KvPnz89pp52W/fffP0899VQuuuii/M///E++9a1vZeXKlc6/1/B6+ZVKJeffa7jgggvyne98Jx//+Mez++6751e/+lXOPvvsVFZW5qijjvL773W8Xn5+//Xdddddl1tuuaXX3y3OP/pDHVGMOqJ/1BHFqCP6Rx1RjDqiOLVEMWqJ8hmQWqLEkHTqqaeWjj322F5j5513XmmvvfYqrVq1aoBmNXR8//vfL+22226l1tbWgZ7KkNDR0VH68Y9/XNp3331L++67b2mXXXYp/fa3v+1Z//Wvf7205557ll566aWesTvuuKO0yy67lO65556BmPKg8nr5PfbYY6VddtmldPfddw/gLAenjo6O0j777FP6whe+0Gv8pptuKu2yyy6lBx54wPn3GvqSn/NvwxobG0t77LFH6bzzzus1ftJJJ5WOO+64Uqnk999r6Ut+zr++ef7550tvfetbSwceeGDpkEMO6Rl3/tEf6ohi1BEbRx1RjDqi/9QRxagjilNLFKOWKJ+BqiW8HWMIam1tzd13371OF2/WrFlpbm7OwoULB2hmQ8fDDz+cadOmZcSIEQM9lSHh0UcfzRe+8IW8973vzXnnnbfO+rvuuit77713xo8f3zN2wAEHpL6+PnfeeefmnOqg9Hr5PfLII0mS6dOnb+6pDXqNjY05+uij8zd/8ze9xnfaaackyaJFi5x/r6Ev+Tn/Nqy2tjY//OEPM2fOnF7jI0aMSGtraxK//15LX/Jz/vXN5z73ucycOTP7779/r3HnHxtLHVGcOmLjqCOKUUf0nzqiGHVEcWqJYtQS5TNQtYSmwxC0aNGitLW1ZerUqb3Gd9xxxyTJk08+ufknNcQ88sgjqayszJw5c7LXXntl3333zf/3//1/va5NyKsmTpyYW265JZ/+9KdTV1e3zvrHH3+854+PNSorK/NXf/VXzse8fn4PP/xwxowZk6985SvZb7/9svvuu+fv//7v8+c//3kAZju4NDQ05POf/3z23nvvXuM333xzkq6PTDr/Nqwv+Tn/Nqy6ujrTp0/PNttsk1KplCVLluSKK67If/3Xf+WEE05I4vffa+lLfs6/1/ejH/0oDz74YD7/+c+vs875x8ZSRxSnjtg46ohi1BH9p44oRh1RnFqiGLVEeQxkLaHpMASt+UKP0aNH9xqvr69PEn/wvo4113x78sknc/jhh+cb3/hGzjjjjPzsZz/Lhz70oXR2dg70FAedsWPHZvvtt9/g+hUrVvScf2urr693Pub183v44YezcuXKjBs3Lpdddlm+/OUv56mnnsqJJ56YF154YTPOdGi477778o1vfCOHHXZY3vjGNzr/NtJf5uf865sbbrgh73jHO3LBBRfkwAMPzLvf/e4kfv/11Ybyc/69tmeeeSbnnntu/vmf/7nXO5DWcP6xsdQRxagjNp46ohh1RHmpI4pRR/SfWqIYtUT/DHQt4Yukh6A1f8xWVFSsd70vMXttpVIpV1xxRbbZZpvsvPPOSZK3vvWt2WabbfLJT34yv/71r3PQQQcN8CyHnvWdj6VSaYPnKa+aN29ezjzzzJ53keyzzz75X//rf+XII4/Md7/73Xzyk58c4BkOHgsXLswZZ5yRKVOm5F/+5V96xp1/fbO+/Jx/fbPnnnvmmmuuyRNPPJGLL74473//+/PjH/84ifOvLzaUn/Nvw0qlUj7zmc/koIMOyqxZsza4nfOPjaGOKEYdsWn4PdZ//j/ad+qIYtQRxaglilFLbLzBUEtoOgxBDQ0NSdZ9J1JTU1OSdd+5RG9VVVXZb7/91hk/+OCDk3RdN1OxsHFGjx693i5oc3Pza74zhy5vetOb1hmbPHlydt55555rFJLceOON+dSnPpWddtopV199dcaOHZvE+ddXG8rP+dc3O+64Y3bccce89a1vzeTJk3PKKadkwYIFzr8+2lB+Rx999DrbOv+6fO9738ujjz6aG264Ie3t7Um6CoAkaW9vT2VlpfOPjaaOKEYdUX5+jxXj77i+UUcUo44oTi1RjFpi4w2GWsJbWYagKVOmpKqqKk899VSv8TXL06ZNG4hpDRkvvPBC/s//+T95/vnne423tLQkScaNGzcQ0xrSdtpppzz99NO9xjo7O7N48WLn4+toa2vL//2//ze///3v11nX0tLifOx21VVX5R//8R+z11575Xvf+1623XbbnnXOv9e3ofycf6/tpZdeyk9/+tO89NJLvcZ33333JMnzzz/v/HsNr5ffokWLnH+vYcGCBVm+fHne8Y53ZLfddstuu+2Wa6+9Ns8880x22223XHbZZc4/Npo6ohh1RPn5PdZ//o7rG3VEMeqI/lNLFKOWKGYw1BKaDkNQbW1t9tlnn9xyyy09Xaqk64RqaGjIHnvsMYCzG/xaW1vz+c9/Pj/84Q97jd90002prKxc54uSeH0zZ87MPffck2XLlvWM/frXv05TU1Nmzpw5gDMb/EaMGJFLLrkk559/fq/xBx98ME8//fR63023pfnBD36Q888/P+9617ty9dVXZ8yYMb3WO/9e22vl5/x7bc3NzfnUpz6VH/3oR73Gf/3rXydJdt11V+ffa3i9/N7ylrc4/17DF7/4xfz4xz/u9XPIIYdk2223zY9//OMcd9xxzj82mjqiGHVE+fk91n/+jnt96ohi1BHFqCWKUUsUMxhqCZdXGqLmzp2bOXPm5Kyzzsqxxx6b+++/P1dffXXmzZuXurq6gZ7eoDZ58uS85z3vyTe+8Y3U1NRkr732yr333puvf/3rOeGEE/KGN7xhoKc45Jxwwgm55pprMmfOnHz0ox/Nyy+/nPPPPz8HHnhgZsyYMdDTG/Q+8pGP5LOf/Ww+9alP5aijjsozzzyTiy++OLvuumuOOeaYgZ7egFqyZEnOPffcTJo0KSeddFIeeuihXuunTJni/HsNfcnP+bdhkydPznvf+95cdtllqayszO67754//vGP+drXvpZ3vOMdOfDAA7P77rs7/zagL/k5/zZsfX+PjB07NjU1NT3v8PL7j/5QR/SfOqL8/B4rxv9HN0wdUYw6oji1RDFqiWIGQy1RUVr7LS4MKbfccksuvvjiPPHEE5kwYUJOPPHEnHrqqQM9rSFh9erVueqqq3L99dfn2WefzYQJE3LcccfltNNOS1VV1UBPb1C7++67c/LJJ+e73/1ur87xn/70p3zlK1/J/fffn/r6+hx22GE5++yzXRv4L2wovxtvvDFXX311/vznP2fkyJE5/PDD87//9//uuV7mlurHP/5xPvvZz25w/bnnnpvZs2c7/zagr/k5/zastbU1V199da699to8++yz2XbbbXP00UfnzDPPTE1NTRK//15LX/Jz/vXdpz71qfzud7/Lbbfd1jPm/KM/1BH9p47oP3VEMeqIjaOOKEYdUR5qiWLUEuW1uWsJTQcAAAAAAKAsfKcDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZaHpAAAAAAAAlIWmAwAAAAAAUBaaDgAAAAAAQFloOgAAAAAAAGWh6QAAAAAAAJSFpgMAAAAAAFAWmg4AAAAAAEBZaDoAAAAAAABloekAAAAAAACUhaYDAAAAAABQFpoOAPTbD37wg+y6667Zb7/90tbWtt5tnnvuubzpTW/Km9/85rzwwgs947feems+9KEPZf/9989b3vKWHHDAAfnHf/zHPPjggxt8vBdffDHz58/P3/7t32bffffNbrvtln333Tfvf//7881vfjMtLS29tl+8eHF23XXXzJw5My+88EI+9KEPZY899si+++6bf/zHfyxPCAAAwEZTSwAMX5oOAPTb3/zN36Suri4vv/xyfvWrX613m+uuuy6dnZ2ZOXNmJkyYkPb29sybNy8f+chH8qtf/SoVFRXZdddd09ramp/97Gd53/vel2uuuWad4/z+97/PX//1X+frX/96/vSnP2W77bbLG9/4xnR2dub+++/PV7/61Zx22mnp6OhYZ9/W1tacdtpp+a//+q/svPPOqaioyKRJk8qeBwAA0DdqCYDhq3qgJwDA0DV69OgcccQRuf7663P99dfnsMMOW2eba6+9Nkkye/bsJMlFF12UG264Idtvv32+/OUv54ADDkiSdHR05Pvf/37+9V//NV/+8pez0047ZebMmT3rPvnJT2bFihU57LDD8pWvfCVbbbVVkqStrS3f+ta38u///u9ZuHBhfv3rX+fggw/uNYcVK1aksrIy1157baZNm5bW1ta0trZuolQAAIDXo5YAGL580gGAQo499tgkye23355XXnml17rf//73eeKJJzJ27Ngceuiheemll/Ltb387SXL55Zf3FAlJUlVVlQ9+8IM55ZRTUiqVcuGFF/ase+SRR/Lyyy+npqYmX/7yl3uKhCQZMWJEPvShD2Xy5MlJkj/96U/rnecJJ5yQadOmJUlqamoyevTows8dAADoP7UEwPCk6QBAIfvtt18mT56c1tbW/PznP++17qc//WmSro9O19TU5Fe/+lVaW1szbdq07Lbbbus93nve854kyQMPPJCXXnopSbLbbrvlnnvuyT333JNx48ats09ra2tP8bBq1ar1Hnfvvffu3xMEAAA2CbUEwPDk8koAFFJRUZFjjjkmF198ca677rq8//3vT5JehcOaj0P/z//8T5Lk+eefzwc+8IH1Hq9UKvXc//Of/5ytt966Z7muri5PPvlk/vjHP+bpp5/OokWL8thjj+XRRx/N6tWrkySdnZ3rPe62225b8JkCAADlpJYAGJ40HQAobPbs2bn00ktz3333ZdGiRZk8eXJuu+22vPLKK9l111173om0cuXKJEljY2Puu+++1z3uihUreu7/4Q9/yL/927/ld7/7Xa9txo0bl4MOOigPPfRQFi9evMFj1dXV9eepAQAAm5BaAmD40XQAoLCJEyfm7W9/e+66667ccMMNOfPMM3PdddclefWdSUkycuTIJMmsWbNy8cUX9/n4jz/+eE4++eS0tLRk2rRpOfbYYzN9+vTsvPPOmTBhQpLk/e9//2sWCgAAwOCjlgAYfjQdACiLY489NnfddVduueWWzJkzJ7/5zW8yYsSIHH300T3b7LTTTkle/Wj0+qxatSr//d//nYkTJ2aHHXZIVVVVvvOd76SlpSVveMMb8uMf/7in4FjbCy+8UP4nBQAAbHJqCYDhxRdJA1AWhx12WMaOHZuHHnooP/zhD7N69eocfPDBGT9+fM82Bx10UKqqqvLnP/85v/nNb9Z7nG9/+9v54Ac/mPe85z09X+T2zDPPJEl23nnn9RYJv/nNb/Lss88mSTo6Osr91AAAgE1ILQEwvGg6AFAWNTU1Oeqoo5IkF110UZLeH4dOkkmTJuV973tfkuR//+//ndtuu61nXWdnZ370ox/l0ksvTZKceOKJGT16dJJX39X0m9/8JgsXLuzZp729PT/72c/yD//wDz1jLS0t5X5qAADAJqSWABheKkqlUmmgJwHA8PDII4/kPe95T5Jkm222ya9+9atUV/e+kt/q1atz1lln5fbbb0+SbLfddpkwYUKeeeaZLFu2LEnXdVrnz5+fqqqqJMmzzz6b2bNnZ/ny5UmSqVOnpr6+PosXL84rr7ySUaNGZdddd83999+fww8/vKfYWLx4cQ499NAkyc0335wdd9xx04cAAABsNLUEwPDhkw4AlM306dMzffr0JMnRRx+9TpGQJLW1tfna176W+fPn54ADDkhbW1sefvjhdHR0ZL/99stXv/rVXHjhhT1FQpLssMMOuf766/OBD3wgU6dOzXPPPZcnnngi22yzTT74wQ/m+uuvzyc+8Ykkyd13353m5ubN8nwBAIDyUEsADB8+6QBA2bS3t+eggw7K0qVLc+ONN2batGkDPSUAAGAIUEsADB8+6QBA2dx2221ZunRpZsyYoUgAAAD6TC0BMHys+1k1ANgIf/7zn1NbW5snnngiX/ziF5Mkc+bMGeBZAQAAg51aAmB40nQAoJBvf/vb+eEPf9iz/I53vCOzZs0awBkBAABDgVoCYHhyeSUACtl9990zbty4NDQ0ZPbs2bnooosGekoAAMAQoJYAGJ58kTQAAAAAAFAWPukAAAAAAACUhaYDAAAAAABQFpoOAAAAAABAWWg6AAAAAAAAZaHpAAAAAAAAlIWmAwAAAAAAUBaaDgAAAAAAQFloOgAAAAAAAGWh6QAAAAAAAJTF/w9GFu483749aQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "quantile = [0.1,0.5,0.9]\n", "T = 40\n", "ylim1, ylim2 = 0.4, 0.4\n", "plot_price_elasticity(ModelSol,T,quantile,'year',ylim1, ylim2)" ] }, { "cell_type": "markdown", "id": "2e77d327", "metadata": {}, "source": [ "
\n", "
\n", "
\n", "\n", "# 3 Outputs\n", "\n", "## 3.1 List of Outputs \n", "\n", "We now examine the contents of `ModelSol`, which contains the attributes listed below. Each approximation is stored in a class `LinQuadVar`, which contains the coefficients for $X_{1,t}, X_{2,t}, X_{1,t}'X_{1,t}, W_{t+\\epsilon}, W_{t+\\epsilon}'W_{t+\\epsilon}, X_{1,t}'W_{t+\\epsilon}$ and the constant.\n", "\n", "\n", "```{list-table}\n", ":header-rows: 1\n", "\n", "* - Input\n", " - Type\n", " - Description\n", "* - `JXn_t`\n", " - *LinQuadVar*\n", " - Approximation of jump and state variables at time $t$. Replace `n` with `0,1,2` to get the zeroth, first and second-order contribution. Omit `n` to get the full approximation. The variables are indexed in the order specified in Section 2. \n", "* - `Jn_t`\n", " - *LinQuadVar*\n", " - Same as `JXn_t` but limited to jump variables.\n", "* - `Xn_tp1`\n", " - *LinQuadVar*\n", " - Same as `JXn_t` but limited to state variables.\n", "* - `JXn_t_tilde`\n", " - *LinQuadVar*\n", " - Same as `JXn_t` but using distorted measure. This variation is also available for `Jn_t` and `Xn_tp1`.\n", "* - `util_sol`\n", " - *dict*\n", " - Dictionary containing solutions of the continuation values, including $\\mu^0, \\Upsilon_0^2, \\Upsilon_1^2,$ and $\\Upsilon_2^2$ etc.\n", "* - `vmrn_tp1`\n", " - *LinQuadVar*\n", " - Approximation of continuation values $\\widehat{V}^1_{t+\\epsilon}-\\widehat{R}^1_t$ . Replace `n` with `0,1,2` to get the zeroth, first and second-order contribution. Omit `n` to get the full approximation. \n", "* - `gcn_tp1`\n", " - *LinQuadVar*\n", " - Approximation of consumption growth $\\widehat{C}_{t+\\epsilon}-\\widehat{C}_t$ . Replace `n` with `0,1,2` to get the zeroth, first and second-order contribution. Omit `n` to get the full approximation. \n", "* - `ss`\n", " - *dict*\n", " - Steady states for state and jump variables\n", "* - `log_N_tilde`\n", " - *LinQuadVar*\n", " - Approximation for the log change of measure\n", "```\n", "\n", "For example, we can obtain the coefficients for the first-order contribution of $\\log{C_t/K_t}$ in the following way, noting that `cmk_t` was listed as the first jump variable when we specified the equilibrum conditions.\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "9ab60024", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'x': array([[-0. , 0.17006158, -0. ]]),\n", " 'c': array([[-0.06496613]])}" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "## Log consumption over capital approximation results, shown in the LinQuadVar coefficients form\n", "ModelSol['JX1_t'][0].coeffs" ] }, { "cell_type": "markdown", "id": "4c7156db", "metadata": {}, "source": [ "We can also display the full second-order approximation of $\\log{C_t/K_t}$ using the `disp` function, which renders a `LinQuadVar` object in LATEX form." ] }, { "cell_type": "code", "execution_count": 18, "id": "68ad25a4", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{C_t}{K_t}=-3.731+\\begin{bmatrix}-6.673e-18&0.1744\\end{bmatrix}X_t^1+\\begin{bmatrix}-3.554e-18&0.08503\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}3.05e-34&2.407e-18\\\\-3.529e-62&-3.547e-18\\end{bmatrix}X^1_{t}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Log consumption over capital approximation results, shown in the Latex analytical form\n", "disp(ModelSol['JX_t'][0],'\\\\log\\\\frac{C_t}{K_t}') " ] }, { "cell_type": "markdown", "id": "a952413c", "metadata": {}, "source": [ "Another example:" ] }, { "cell_type": "code", "execution_count": 19, "id": "0a28d287", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{K_{t+\\epsilon}^2}{K_t^2}=3.89e-05+\\begin{bmatrix}8.154e-20&0.0002738\\end{bmatrix}X_t^1+\\begin{bmatrix}-6.525e-19&0.03714\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}-3.9e-35&-2.067e-19\\\\1.185e-63&-6.744e-21\\end{bmatrix}X^1_{t}+X^{1T}_{t}\\begin{bmatrix}0&0\\\\0&0\\end{bmatrix}W_{t+1}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Log capital growth process second order approximation results\n", "disp(ModelSol['X2_tp1'][0],'\\\\log\\\\frac{K_{t+\\epsilon}^2}{K_t^2}') " ] }, { "cell_type": "markdown", "id": "09047922", "metadata": {}, "source": [ "
\n", "\n", "## 3.2 Simulate Variables \n", "Given a series of shock processes, we can simulate the path of our state and jump variables using the `ModelSolution.simulate` method. Here, we simulate 400 periods of i.i.d standard multivariate normal shocks." ] }, { "cell_type": "code", "execution_count": null, "id": "db492e54", "metadata": {}, "outputs": [], "source": [ "Ws = np.random.multivariate_normal(np.zeros(n_W),np.eye(n_W),size = 400)\n", "JX_sim = ModelSol.simulate(Ws)" ] }, { "cell_type": "markdown", "id": "54b619f8", "metadata": {}, "source": [ "
\n", "
\n", "\n", "# 4 Using `LinQuadVar` in Computation \n", "\n", "In the previous section, we saw how to use `uncertain_expansion` to approximate variables and store their coefficients as `LinQuadVar` objects. In this section, we explore how to manipulate `LinQuadVar` objects for different uses.\n", "\n", "To aid our examples, we first extract the steady states for the state evolution processes from the previous model solution:\n", "\n", "See [src/lin_quad.py](https://github.com/lphansen/RiskUncertaintyValue/blob/main/src/lin_quad.py) for source code of `LinQuadVar` definition." ] }, { "cell_type": "code", "execution_count": 22, "id": "6c904c8c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ -3.66035793, 0.0664767 , 0.02039991, 0. , 1. , 0.01330655, 0. , -11.97496092])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ModelSol['ss']" ] }, { "cell_type": "code", "execution_count": 23, "id": "d7f9aeac", "metadata": {}, "outputs": [], "source": [ "n_J, n_X, n_W = ModelSol['var_shape']\n", "X0_tp1 = LinQuadVar({'c':np.array([[ModelSol['ss'][0]],[ModelSol['ss'][1]],[ModelSol['ss'][2]]])}, shape = (n_X, n_X, n_W))" ] }, { "cell_type": "markdown", "id": "4f7a05ea", "metadata": {}, "source": [ "## 4.1 `LinQuadVar` Operations \n", "We can sum multiple LinQuads together in two different ways. Here we demonstrate this with an example by summing the zeroth, first and second order contributions of our approximation for capital growth. " ] }, { "cell_type": "code", "execution_count": 24, "id": "6f22ab40", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{K_{t+\\epsilon}}{K_t}=-3.659+\\begin{bmatrix}-6.117e-19&0.03728\\end{bmatrix}X_t^1+\\begin{bmatrix}0.007999&0.003478\\end{bmatrix}W_{t+1}+\\begin{bmatrix}-3.262e-19&0.01857\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}-1.95e-35&-1.034e-19\\\\5.926e-64&-3.372e-21\\end{bmatrix}X^1_{t}+X^{1T}_{t}\\begin{bmatrix}0&0\\\\0&0\\end{bmatrix}W_{t+1}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gk_tp1 = X0_tp1[0] + ModelSol['X1_tp1'][0] + 0.5 * ModelSol['X2_tp1'][0] \n", "disp(gk_tp1,'\\\\log\\\\frac{K_{t+\\epsilon}}{K_t}') " ] }, { "cell_type": "markdown", "id": "bb5e6d0c", "metadata": {}, "source": [ "In the next example, we sum together the contributions for both capital growth and technology:" ] }, { "cell_type": "code", "execution_count": 25, "id": "79982125", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'xw': array([[ 0. , 0. , 0. , 0. , 0. , 0. , 0.00399962, 0.00173897, 0. ],\n", " [ 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.02478025, 0. ],\n", " [ 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , -0.21392032]]),\n", " 'c': array([[-3.65924752],\n", " [ 0.0664767 ],\n", " [-0.0711239 ]]),\n", " 'xx': array([[-0. , -0. , 0. , -0. , -0.00021926, 0. , -0. , -0. , 0. ],\n", " [ 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. ],\n", " [ 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0. , 0.097 ]]),\n", " 'x2': array([[-0. , 0.0185721, 0. ],\n", " [ 0. , 0.472 , 0. ],\n", " [ 0. , 0. , 0.403 ]]),\n", " 'x': array([[-0. , 0.03728112, 0.00008691],\n", " [ 0. , 0.944 , 0. ],\n", " [ 0. , 0. , 0.806 ]]),\n", " 'w': array([[0.00799924, 0.00347793, 0. ],\n", " [0. , 0.04956051, 0. ],\n", " [0. , 0. , 0.42784065]])}" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lq_sum([X0_tp1, ModelSol['X1_tp1'], 0.5 * ModelSol['X2_tp1']]).coeffs" ] }, { "cell_type": "markdown", "id": "1eb2e7e3", "metadata": {}, "source": [ "## 4.2 `LinQuadVar` Split and Concat \n", "`split` breaks multiple dimensional LinQuad into one-dimensional LinQuads, while `concat` does the inverse." ] }, { "cell_type": "code", "execution_count": 26, "id": "625e6e2f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gk_tp1, Z_tp1, Y_tp1 = ModelSol['X1_tp1'].split()\n", "concat([gk_tp1, Z_tp1, Y_tp1])" ] }, { "cell_type": "markdown", "id": "1e00f7f9", "metadata": {}, "source": [ "## 4.3 Evaluate a `LinQuadVar` \n", "We can evaluate a LinQuad at specific state $(X_{t},W_{t+\\epsilon})$ in time. As an example, we evaluate all 5 variables under steady state with a multivariate random normal shock." ] }, { "cell_type": "code", "execution_count": 27, "id": "f7d0893c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ -3.71818036],\n", " [ 0.06792475],\n", " [ 0.02041077],\n", " [ -0.00013651],\n", " [ 0.99999734],\n", " [ 0.01454234],\n", " [ 0.05682728],\n", " [-12.65749319]])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x1 = np.zeros([n_X ,1])\n", "x2 = np.zeros([n_X ,1])\n", "w = np.random.multivariate_normal(np.zeros(n_W),np.eye(n_W),size = 1).T\n", "ModelSol['JX_tp1'](*(x1,x2,w))" ] }, { "cell_type": "markdown", "id": "72f12124", "metadata": {}, "source": [ "## 4.4 Next period expression for `LinQuadVar` \n", "`ModelSol` allows us to express a jump variable $J_t$ as a function of $t$ state and shock variables. Suppose we would like to compute its next period expression $J_{t+\\epsilon}$ with shocks. The function `next_period` expresses $J_{t+\\epsilon}$ in terms of $t$ state variables and $t+\\epsilon$ shock variables. For example, we can express the $t+\\epsilon$ expression for the first-order contribution to consumption over capital as:" ] }, { "cell_type": "code", "execution_count": 28, "id": "30a0718d", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{C_{t+\\epsilon}^1}{K_{t+\\epsilon}^1}=-0.06497+\\begin{bmatrix}4.638e-36&0.1605\\end{bmatrix}X_t^1+\\begin{bmatrix}-5.686e-20&0.008428\\end{bmatrix}W_{t+1}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cmk1_tp1 = next_period(ModelSol['J1_t'][0], ModelSol['X1_tp1'])\n", "disp(cmk1_tp1, '\\\\log\\\\frac{C_{t+\\epsilon}^1}{K_{t+\\epsilon}^1}') " ] }, { "cell_type": "code", "execution_count": 29, "id": "094dcae3", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\log\\frac{C_{t+\\epsilon}^2}{K_{t+\\epsilon}^2}=-0.01163+\\begin{bmatrix}-1.148e-36&0.008267\\end{bmatrix}X_t^1+\\begin{bmatrix}6.969e-21&0.000434\\end{bmatrix}W_{t+1}+\\begin{bmatrix}4.638e-36&0.1605\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}2.772e-52&-1.495e-36\\\\2.869e-80&4.417e-36\\end{bmatrix}X^1_{t}+X^{1T}_{t}\\begin{bmatrix}-6.367e-54&7.374e-38\\\\1.97e-80&-1.722e-20\\end{bmatrix}W_{t+1}+W_{t+1}^{T}\\begin{bmatrix}3.903e-38&1.908e-21\\\\-2.416e-64&-2.812e-21\\end{bmatrix}W_{t+1}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "cmk2_tp1 = next_period(ModelSol['J2_t'][0], ModelSol['X1_tp1'], ModelSol['X2_tp1'])\n", "disp(cmk2_tp1, '\\\\log\\\\frac{C_{t+\\epsilon}^2}{K_{t+\\epsilon}^2}') " ] }, { "cell_type": "markdown", "id": "17a90814", "metadata": {}, "source": [ "## 4.6 Compute the Expectation of time $t+\\epsilon$ `LinQuadVar` \n", "\n", "Suppose the distribution of shocks has a constant mean and variance (not state dependent). Then, we can use the `E` function to compute the expectation of a time $t+\\epsilon$ `LinQuadVar` as follows:\n" ] }, { "cell_type": "code", "execution_count": 30, "id": "ec4a6591", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\mathbb{E}[\\log\\frac{C_{t+\\epsilon}^2}{K_{t+\\epsilon}^2}|\\mathfrak{F_t}]=-0.01175+\\begin{bmatrix}-1.164e-36&0.008402\\end{bmatrix}X_t^1+\\begin{bmatrix}4.638e-36&0.1605\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}2.772e-52&-1.495e-36\\\\2.869e-80&4.417e-36\\end{bmatrix}X^1_{t}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "E_w = ModelSol['util_sol']['μ_0']\n", "cov_w = np.eye(n_W)\n", "E_ww = cal_E_ww(E_w, cov_w)\n", "E_cmk2_tp1 = E(cmk2_tp1, E_w, E_ww)\n", "disp(E_cmk2_tp1, '\\mathbb{E}[\\\\log\\\\frac{C_{t+\\epsilon}^2}{K_{t+\\epsilon}^2}|\\mathfrak{F_t}]')" ] }, { "cell_type": "markdown", "id": "ae74e865", "metadata": {}, "source": [ "Suppose the distribution of shock has a state-dependent mean and variance (implied by $\\tilde{N}_{t+\\epsilon}$ shown in the notes), we can use `E_N_tp1` and `N_tilde_measure` to compute the expectation of time $t+\\epsilon$ `LinQuadVar`." ] }, { "cell_type": "code", "execution_count": 31, "id": "be1c3394", "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\mathbb{\\tilde{E}}[\\log\\frac{C_{t+\\epsilon}^2}{K_{t+\\epsilon}^2}|\\mathfrak{F_t}]=-0.01197+\\begin{bmatrix}-1.164e-36&0.008407\\end{bmatrix}X_t^1+\\begin{bmatrix}4.638e-36&0.1605\\end{bmatrix}X_t^2+X^{1T}_{t}\\begin{bmatrix}2.772e-52&-1.495e-36\\\\-2.749e-40&4.418e-36\\end{bmatrix}X^1_{t}$" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "N_cm = N_tilde_measure(ModelSol['util_sol']['log_N_tilde'],(1,n_X,n_W))\n", "E_cmk2_tp1_tilde = E_N_tp1(cmk2_tp1, N_cm)\n", "disp(E_cmk2_tp1_tilde, '\\mathbb{\\\\tilde{E}}[\\\\log\\\\frac{C_{t+\\epsilon}^2}{K_{t+\\epsilon}^2}|\\mathfrak{F_t}]')" ] } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "base", "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.12.5" } }, "nbformat": 4, "nbformat_minor": 5 }