diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md index 6ca6f12a7..c1c21d369 100644 --- a/Documentation/CHANGELOG.md +++ b/Documentation/CHANGELOG.md @@ -21,6 +21,7 @@ Release Date: TBD * General control transitions based on decision rules in `FrameAgentType`. [#1117](https://github.com/econ-ark/HARK/pull/1117) * Adds `distr_of_function` tool to calculate the distribution of a function of a discrete random variable. [#1144](https://github.com/econ-ark/HARK/pull/1144) * Changes the `DiscreteDistribution` class to allow for arbitrary array-valued random variables. [#1146](https://github.com/econ-ark/HARK/pull/1146) +* Adds `IndShockRiskyAssetConsumerType` as agent which can invest savings all in safe asset, all in risky asset, a fixed share in risky asset, or optimize its portfolio. [#1107](https://github.com/econ-ark/HARK/issues/1107) * Updates all HARK models to allow for age-varying interest rates. [#1150](https://github.com/econ-ark/HARK/pull/1150) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index aae38d58c..66310b4c1 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -256,7 +256,8 @@ def def_utility_funcs(self): None """ self.u = lambda c: utility(c, gam=self.CRRA) # utility function - self.uP = lambda c: utilityP(c, gam=self.CRRA) # marginal utility function + # marginal utility function + self.uP = lambda c: utilityP(c, gam=self.CRRA) self.uPP = lambda c: utilityPP( c, gam=self.CRRA ) # marginal marginal utility function @@ -384,7 +385,8 @@ def make_cFunc_PF(self): # Add two attributes to enable calculation of steady state market resources. self.Ex_IncNext = 1.0 # Perfect foresight income of 1 - self.mNrmMinNow = mNrmNow[0] # Relabeling for compatibility with add_mNrmStE + # Relabeling for compatibility with add_mNrmStE + self.mNrmMinNow = mNrmNow[0] def add_mNrmTrg(self, solution): """ @@ -843,7 +845,8 @@ def m_nrm_next(self, shocks, a_nrm): Parameters ---------- shocks: [float] - Permanent and transitory income shock levels. a_nrm: float + Permanent and transitory income shock levels. + a_nrm: float Normalized market assets this period Returns @@ -1035,9 +1038,11 @@ def add_stable_points(self, solution): self.GICNrm = GICNrm if GICRaw: - solution = self.add_mNrmStE(solution) # find steady state m, if it exists + # find steady state m, if it exists + solution = self.add_mNrmStE(solution) if GICNrm: - solution = self.add_mNrmTrg(solution) # find target m, if it exists + # find target m, if it exists + solution = self.add_mNrmTrg(solution) return solution @@ -1075,10 +1080,9 @@ def solve(self): solution : ConsumerSolution The solution to the one period problem. """ - self.aNrmNow = np.asarray(self.aXtraGrid) + self.BoroCnstNat - aNrm = self.aNrmNow + aNrmNow = self.prepare_to_calc_EndOfPrdvP() EndOfPrdvP = self.calc_EndOfPrdvP() - solution = self.make_basic_solution(EndOfPrdvP, aNrm, self.make_linear_cFunc) + solution = self.make_basic_solution(EndOfPrdvP, aNrmNow, self.make_linear_cFunc) solution = self.add_MPC_and_human_wealth(solution) solution = self.add_stable_points(solution) @@ -1616,7 +1620,8 @@ def pre_solve(self): self.update_solution_terminal() # Solve the terminal period problem # Fill in BoroCnstArt and MaxKinks if they're not specified or are irrelevant. - if not hasattr(self, "BoroCnstArt"): # If no borrowing constraint specified... + # If no borrowing constraint specified... + if not hasattr(self, "BoroCnstArt"): self.BoroCnstArt = None # ...assume the user wanted none if not hasattr(self, "MaxKinks"): @@ -1740,7 +1745,8 @@ def sim_birth(self, which_agents): self.state_now["pLvl"][which_agents] = Lognormal( pLvlInitMeanNow, self.pLvlInitStd, seed=self.RNG.randint(0, 2**31 - 1) ).draw(N) - self.t_age[which_agents] = 0 # How many periods since each agent was born + # How many periods since each agent was born + self.t_age[which_agents] = 0 if not hasattr( self, "PerfMITShk" @@ -1838,13 +1844,15 @@ def transition(self): RfreeNow = self.get_Rfree() # Calculate new states: normalized market resources and permanent income level - pLvlNow = pLvlPrev * self.shocks["PermShk"] # Updated permanent income level + # Updated permanent income level + pLvlNow = pLvlPrev * self.shocks["PermShk"] # Updated aggregate permanent productivity level PlvlAggNow = self.state_prev["PlvlAgg"] * self.PermShkAggNow # "Effective" interest factor on normalized assets ReffNow = RfreeNow / self.shocks["PermShk"] bNrmNow = ReffNow * aNrmPrev # Bank balances before labor income - mNrmNow = bNrmNow + self.shocks["TranShk"] # Market resources after income + # Market resources after income + mNrmNow = bNrmNow + self.shocks["TranShk"] return pLvlNow, PlvlAggNow, bNrmNow, mNrmNow, None @@ -2065,25 +2073,28 @@ def check_conditions(self, verbose=None): # Make a dictionary to specify an idiosyncratic income shocks consumer init_idiosyncratic_shocks = dict( init_perfect_foresight, - **{ - # assets above grid parameters + **{ # assets above grid parameters "aXtraMin": 0.001, # Minimum end-of-period "assets above minimum" value "aXtraMax": 20, # Maximum end-of-period "assets above minimum" value - "aXtraNestFac": 3, # Exponential nesting factor when constructing "assets above minimum" grid + # Exponential nesting factor when constructing "assets above minimum" grid + "aXtraNestFac": 3, "aXtraCount": 48, # Number of points in the grid of "assets above minimum" "aXtraExtra": [ None ], # Some other value of "assets above minimum" to add to the grid, not used # Income process variables - "PermShkStd": [0.1], # Standard deviation of log permanent income shocks + # Standard deviation of log permanent income shocks + "PermShkStd": [0.1], "PermShkCount": 7, # Number of points in discrete approximation to permanent income shocks - "TranShkStd": [0.1], # Standard deviation of log transitory income shocks + # Standard deviation of log transitory income shocks + "TranShkStd": [0.1], "TranShkCount": 7, # Number of points in discrete approximation to transitory income shocks "UnempPrb": 0.05, # Probability of unemployment while working "UnempPrbRet": 0.005, # Probability of "unemployment" while retired "IncUnemp": 0.3, # Unemployment benefits replacement rate "IncUnempRet": 0.0, # "Unemployment" benefits when retired - "BoroCnstArt": 0.0, # Artificial borrowing constraint; imposed minimum level of end-of period assets + # Artificial borrowing constraint; imposed minimum level of end-of period assets + "BoroCnstArt": 0.0, "tax_rate": 0.0, # Flat income tax rate "T_retire": 0, # Period of retirement (0 --> no retirement) "vFuncBool": False, # Whether to calculate the value function during solution @@ -2242,8 +2253,10 @@ def get_shocks(self): N = np.sum(these) if N > 0: - IncShkDstnNow = self.IncShkDstn[t] # set current income distribution - PermGroFacNow = self.PermGroFac[t] # and permanent growth factor + # set current income distribution + IncShkDstnNow = self.IncShkDstn[t] + # and permanent growth factor + PermGroFacNow = self.PermGroFac[t] # Get random draws of income shocks from the discrete distribution IncShks = IncShkDstnNow.draw(N) @@ -2257,7 +2270,8 @@ def get_shocks(self): N = np.sum(newborn) if N > 0: these = newborn - IncShkDstnNow = self.IncShkDstn[0] # set current income distribution + # set current income distribution + IncShkDstnNow = self.IncShkDstn[0] PermGroFacNow = self.PermGroFac[0] # and permanent growth factor # Get random draws of income shocks from the discrete distribution @@ -2468,8 +2482,7 @@ def test(agent): False: "\nThe given parameter values violate the Mortality Adjusted Aggregate Growth Imatience Condition; the GPFAggLivPrb is: {0.GPFAggLivPrb}", } - verbose_messages = { - # (see {0.url}/#WRIC for more).', + verbose_messages = { # (see {0.url}/#WRIC for more).', True: " Therefore, a target level of the ratio of aggregate market resources to aggregate permanent income exists.\n", # (see {0.url}/#WRIC for more).' False: " Therefore, a target ratio of aggregate resources to aggregate permanent income may not exist.\n", @@ -2958,9 +2971,12 @@ def __init__( **{ "Rboro": 1.20, # Interest factor on assets when borrowing, a < 0 "Rsave": 1.02, # Interest factor on assets when saving, a > 0 - "BoroCnstArt": None, # kinked R is a bit silly if borrowing not allowed - "CubicBool": True, # kinked R is now compatible with linear cFunc and cubic cFunc - "aXtraCount": 48, # ...so need lots of extra gridpoints to make up for it + "BoroCnstArt": None, + # kinked R is a bit silly if borrowing not allowed + "CubicBool": True, + # kinked R is now compatible with linear cFunc and cubic cFunc + "aXtraCount": 48, + # ...so need lots of extra gridpoints to make up for it } ) del init_kinked_R["Rfree"] # get rid of constant interest factor diff --git a/HARK/ConsumptionSaving/ConsPortfolioModel.py b/HARK/ConsumptionSaving/ConsPortfolioModel.py index d27b76a0d..c5a4b5fe6 100644 --- a/HARK/ConsumptionSaving/ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/ConsPortfolioModel.py @@ -6,7 +6,6 @@ from copy import deepcopy import numpy as np -from scipy.optimize import minimize_scalar from HARK import ( MetricObject, @@ -173,6 +172,8 @@ def __init__(self, verbose=False, quiet=False, **kwds): params.update(kwds) kwds = params + self.PortfolioBool = True + # Initialize a basic consumer type RiskyAssetConsumerType.__init__(self, verbose=verbose, quiet=quiet, **kwds) @@ -244,82 +245,6 @@ def update_solution_terminal(self): dvdsFuncFxd=dvdsFuncFxd_terminal, ) - def update_ShareGrid(self): - """ - Creates the attribute ShareGrid as an evenly spaced grid on [0.,1.], using - the primitive parameter ShareCount. - - Parameters - ---------- - None - - Returns - ------- - None - """ - self.ShareGrid = np.linspace(0.0, 1.0, self.ShareCount) - self.add_to_time_inv("ShareGrid") - - def update_ShareLimit(self): - """ - Creates the attribute ShareLimit, representing the limiting lower bound of - risky portfolio share as mNrm goes to infinity. - - Parameters - ---------- - None - - Returns - ------- - None - """ - if "RiskyDstn" in self.time_vary: - self.ShareLimit = [] - for t in range(self.T_cycle): - RiskyDstn = self.RiskyDstn[t] - temp_f = lambda s: -((1.0 - self.CRRA) ** -1) * np.dot( - (self.Rfree + s * (RiskyDstn.X - self.Rfree)) ** (1.0 - self.CRRA), - RiskyDstn.pmf, - ) - SharePF = minimize_scalar(temp_f, bounds=(0.0, 1.0), method="bounded").x - self.ShareLimit.append(SharePF) - self.add_to_time_vary("ShareLimit") - - else: - RiskyDstn = self.RiskyDstn - temp_f = lambda s: -((1.0 - self.CRRA) ** -1) * np.dot( - (self.Rfree + s * (RiskyDstn.X - self.Rfree)) ** (1.0 - self.CRRA), - RiskyDstn.pmf, - ) - SharePF = minimize_scalar(temp_f, bounds=(0.0, 1.0), method="bounded").x - self.ShareLimit = SharePF - self.add_to_time_inv("ShareLimit") - - def get_Rfree(self): - """ - Calculates realized return factor for each agent, using the attributes Rfree, - RiskyNow, and ShareNow. This method is a bit of a misnomer, as the return - factor is not riskless, but would more accurately be labeled as Rport. However, - this method makes the portfolio model compatible with its parent class. - - Parameters - ---------- - None - - Returns - ------- - Rport : np.array - Array of size AgentCount with each simulated agent's realized portfolio - return factor. Will be used by get_states() to calculate mNrmNow, where it - will be mislabeled as "Rfree". - """ - Rport = ( - self.controls["Share"] * self.shocks["Risky"] - + (1.0 - self.controls["Share"]) * self.Rfree - ) - self.Rport = Rport - return Rport - def initialize_sim(self): """ Initialize the state of simulation attributes. Simply calls the same method @@ -1339,7 +1264,10 @@ def solve(self): # Adjust some of the existing parameters in the dictionary init_portfolio["aXtraMax"] = 100 # Make the grid of assets go much higher... init_portfolio["aXtraCount"] = 200 # ...and include many more gridpoints... -init_portfolio["aXtraNestFac"] = 1 # ...which aren't so clustered at the bottom -init_portfolio["BoroCnstArt"] = 0.0 # Artificial borrowing constraint must be turned on -init_portfolio["CRRA"] = 5.0 # Results are more interesting with higher risk aversion +# ...which aren't so clustered at the bottom +init_portfolio["aXtraNestFac"] = 1 +# Artificial borrowing constraint must be turned on +init_portfolio["BoroCnstArt"] = 0.0 +# Results are more interesting with higher risk aversion +init_portfolio["CRRA"] = 5.0 init_portfolio["DiscFac"] = 0.90 # And also lower patience diff --git a/HARK/ConsumptionSaving/ConsRiskyAssetModel.py b/HARK/ConsumptionSaving/ConsRiskyAssetModel.py index 5c84f91a2..c2f9168d7 100644 --- a/HARK/ConsumptionSaving/ConsRiskyAssetModel.py +++ b/HARK/ConsumptionSaving/ConsRiskyAssetModel.py @@ -5,24 +5,35 @@ simulation methods. It is meant as a container of methods for dealing with risky assets that will be useful to models what will inherit from it. """ -from copy import deepcopy +from dataclasses import dataclass import numpy as np +from scipy.optimize import minimize_scalar, root_scalar +from HARK import make_one_period_oo_solver from HARK.ConsumptionSaving.ConsIndShockModel import ( + ConsIndShockSolver, + ConsumerSolution, IndShockConsumerType, # PortfolioConsumerType inherits from it init_idiosyncratic_shocks, # Baseline dictionary to build on ) from HARK.distribution import ( - combine_indep_dstns, + DiscreteDistribution, IndexDistribution, Lognormal, Bernoulli, + calc_expectation, + combine_indep_dstns, +) +from HARK.interpolation import ( + LinearInterp, + MargValueFuncCRRA, + ValueFuncCRRA, + ConstantFunction, ) -from HARK.utilities import NullFunc -class RiskyAssetConsumerType(IndShockConsumerType): +class IndShockRiskyAssetConsumerType(IndShockConsumerType): """ A consumer type that has access to a risky asset for his savings. The risky asset has lognormal returns that are possibly correlated with his @@ -33,8 +44,8 @@ class RiskyAssetConsumerType(IndShockConsumerType): The meaning of "adjusting his portfolio" depends on the particular model. """ - time_inv_ = deepcopy(IndShockConsumerType.time_inv_) - + time_inv_ = IndShockConsumerType.time_inv_ + ["PortfolioBisect"] + time_vary_ = IndShockConsumerType.time_vary_ + ["Rfree"] shock_vars_ = IndShockConsumerType.shock_vars_ + ["Adjust", "Risky"] def __init__(self, verbose=False, quiet=False, **kwds): @@ -42,22 +53,48 @@ def __init__(self, verbose=False, quiet=False, **kwds): params.update(kwds) kwds = params + # Boolean determines whether agent will use portfolio + # optimization or only has access to risky asset + if not hasattr(self, "PortfolioBool"): + self.PortfolioBool = False + + if not hasattr(self, "PortfolioBisect"): + self.PortfolioBisect = False + # Initialize a basic consumer type IndShockConsumerType.__init__(self, verbose=verbose, quiet=quiet, **kwds) # These method must be overwritten by classes that inherit from # RiskyAssetConsumerType - self.solve_one_period = NullFunc() + if self.PortfolioBool: + solver = ConsPortfolioIndShkRiskyAssetSolver # optimize over shares + else: + solver = ConsIndShkRiskyAssetSolver # risky share of 1 + + self.solve_one_period = make_one_period_oo_solver(solver) def pre_solve(self): self.update_solution_terminal() + if self.PortfolioBool: + self.solution_terminal.ShareFunc = ConstantFunction(1.0) + def update(self): IndShockConsumerType.update(self) self.update_AdjustPrb() self.update_RiskyDstn() self.update_ShockDstn() + self.update_Rfree() + + if self.PortfolioBool: + self.update_ShareLimit() + self.update_ShareGrid() + + def update_Rfree(self): + + if isinstance(self.Rfree, (int, float)): + self.Rfree = [self.Rfree] * self.T_cycle def update_RiskyDstn(self): """ @@ -94,7 +131,7 @@ def update_RiskyDstn(self): self.RiskyDstn = IndexDistribution( Lognormal.from_mean_std, {"mean": self.RiskyAvg, "std": self.RiskyStd}, - seed=self.RNG.randint(0, 2 ** 31 - 1), + seed=self.RNG.randint(0, 2**31 - 1), ).approx(self.RiskyCount) self.add_to_time_vary("RiskyDstn") @@ -103,8 +140,7 @@ def update_RiskyDstn(self): # agent does *not* have age-varying beliefs about the risky asset (base case) else: self.RiskyDstn = Lognormal.from_mean_std( - self.RiskyAvg, - self.RiskyStd, + self.RiskyAvg, self.RiskyStd ).approx(self.RiskyCount) self.add_to_time_inv("RiskyDstn") @@ -160,6 +196,94 @@ def update_AdjustPrb(self): else: self.add_to_time_inv("AdjustPrb") + def update_ShareLimit(self): + """ + Creates the attribute ShareLimit, representing the limiting lower bound of + risky portfolio share as mNrm goes to infinity. + + Parameters + ---------- + None + + Returns + ------- + None + """ + if "RiskyDstn" in self.time_vary: + self.ShareLimit = [] + for t in range(self.T_cycle): + RiskyDstn = self.RiskyDstn[t] + + def temp_f(s): + return -((1.0 - self.CRRA) ** -1) * np.dot( + (self.Rfree[t] + s * (RiskyDstn.X - self.Rfree[t])) + ** (1.0 - self.CRRA), + RiskyDstn.pmf, + ) + + SharePF = minimize_scalar(temp_f, bounds=(0.0, 1.0), method="bounded").x + self.ShareLimit.append(SharePF) + self.add_to_time_vary("ShareLimit") + + else: + RiskyDstn = self.RiskyDstn + + def temp_f(s): + return -((1.0 - self.CRRA) ** -1) * np.dot( + (self.Rfree[0] + s * (RiskyDstn.X - self.Rfree[0])) + ** (1.0 - self.CRRA), + RiskyDstn.pmf, + ) + + SharePF = minimize_scalar(temp_f, bounds=(0.0, 1.0), method="bounded").x + self.ShareLimit = SharePF + self.add_to_time_inv("ShareLimit") + + def update_ShareGrid(self): + """ + Creates the attribute ShareGrid as an evenly spaced grid on [0.,1.], using + the primitive parameter ShareCount. + + Parameters + ---------- + None + + Returns + ------- + None + """ + self.ShareGrid = np.linspace(0.0, 1.0, self.ShareCount) + self.add_to_time_inv("ShareGrid") + + def get_Rfree(self): + """ + Calculates realized return factor for each agent, using the attributes Rfree, + RiskyNow, and ShareNow. This method is a bit of a misnomer, as the return + factor is not riskless, but would more accurately be labeled as Rport. However, + this method makes the portfolio model compatible with its parent class. + + Parameters + ---------- + None + + Returns + ------- + Rport : np.array + Array of size AgentCount with each simulated agent's realized portfolio + return factor. Will be used by get_states() to calculate mNrmNow, where it + will be mislabeled as "Rfree". + """ + + Rfree = np.array(self.Rfree) + RfreeNow = Rfree[self.t_cycle - 1] + + Rport = ( + self.controls["Share"] * self.shocks["Risky"] + + (1.0 - self.controls["Share"]) * RfreeNow + ) + self.Rport = Rport + return Rport + def get_Risky(self): """ Sets the attribute Risky as a single draw from a lognormal distribution. @@ -182,7 +306,7 @@ def get_Risky(self): RiskyStd = self.RiskyStd self.shocks["Risky"] = Lognormal.from_mean_std( - RiskyAvg, RiskyStd, seed=self.RNG.randint(0, 2 ** 31 - 1) + RiskyAvg, RiskyStd, seed=self.RNG.randint(0, 2**31 - 1) ).draw(1) def get_Adjust(self): @@ -200,7 +324,7 @@ def get_Adjust(self): None """ self.shocks["Adjust"] = IndexDistribution( - Bernoulli, {"p": self.AdjustPrb}, seed=self.RNG.randint(0, 2 ** 31 - 1) + Bernoulli, {"p": self.AdjustPrb}, seed=self.RNG.randint(0, 2**31 - 1) ).draw(self.t_cycle) def initialize_sim(self): @@ -239,9 +363,927 @@ def get_shocks(self): self.get_Adjust() -# %% Initial parameter sets +# This is to preserve compatibility with old name +RiskyAssetConsumerType = IndShockRiskyAssetConsumerType + + +class FixedPortfolioShareRiskyAssetConsumerType(IndShockRiskyAssetConsumerType): + time_vary_ = IndShockRiskyAssetConsumerType.time_vary_ + ["RiskyShareFixed"] + + def __init__(self, verbose=False, quiet=False, **kwds): + params = init_risky_share_fixed.copy() + params.update(kwds) + kwds = params + + # Initialize a basic consumer type + IndShockRiskyAssetConsumerType.__init__( + self, verbose=verbose, quiet=quiet, **kwds + ) + + self.solve_one_period = make_one_period_oo_solver( + ConsFixedPortfolioIndShkRiskyAssetSolver + ) + + +#################################################################################################### +#################################################################################################### + + +@dataclass +class ConsIndShkRiskyAssetSolver(ConsIndShockSolver): + """ + Solver for an agent that can save in an asset that has a risky return. + """ + + solution_next: ConsumerSolution + IncShkDstn: DiscreteDistribution + TranShkDstn: DiscreteDistribution + PermShkDstn: DiscreteDistribution + RiskyDstn: DiscreteDistribution + ShockDstn: DiscreteDistribution + LivPrb: float + DiscFac: float + CRRA: float + Rfree: float + PermGroFac: float + BoroCnstArt: float + aXtraGrid: np.array + vFuncBool: bool + CubicBool: bool + IndepDstnBool: bool + + def __post_init__(self): + self.def_utility_funcs() + + # Make sure the individual is liquidity constrained. Allowing a consumer to + # borrow *and* invest in an asset with unbounded (negative) returns is a bad mix. + if self.BoroCnstArt != 0.0: + raise ValueError("RiskyAssetConsumerType must have BoroCnstArt=0.0!") + + if self.CubicBool: + raise NotImplementedError( + "RiskyAssetConsumerType does not implement cubic interpolation yet!" + ) + + def set_and_update_values(self, solution_next, IncShkDstn, LivPrb, DiscFac): + """ + Unpacks some of the inputs (and calculates simple objects based on them), + storing the results in self for use by other methods. These include: + income shocks and probabilities, next period's marginal value function + (etc), the probability of getting the worst income shock next period, + the patience factor, human wealth, and the bounding MPCs. + + Parameters + ---------- + solution_next : ConsumerSolution + The solution to next period's one period problem. + IncShkDstn : distribution.DiscreteDistribution + A DiscreteDistribution with a pmf + and two point value arrays in X, order: + permanent shocks, transitory shocks. + LivPrb : float + Survival probability; likelihood of being alive at the beginning of + the succeeding period. + DiscFac : float + Intertemporal discount factor for future utility. + + Returns + ------- + None + """ + + super().set_and_update_values(solution_next, IncShkDstn, LivPrb, DiscFac) + + # Absolute Patience Factor for the model with risk free return is defined at + # https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#APFacDefn + + # The corresponding Absolute Patience Factor when the + # return factor is risky is defined implicitly in + # https://www.econ2.jhu.edu/people/ccarroll/public/LectureNotes/Consumption/CRRA-RateRisk/ + + def abs_pat_fac(shock): + return shock ** (1.0 - self.CRRA) + + self.AbsPatFac = ( + self.DiscFacEff * calc_expectation(self.RiskyDstn, abs_pat_fac) + ) ** (1.0 / self.CRRA) + + self.MPCminNow = 1.0 / (1.0 + self.AbsPatFac / solution_next.MPCmin) + + # overwrite human wealth function + + def h_nrm_now(shocks): + return ( + self.PermGroFac + / shocks[2] + * (shocks[0] * shocks[1] + solution_next.hNrm) + ) + + self.hNrmNow = calc_expectation(self.ShockDstn, h_nrm_now) + + self.MPCmaxNow = 1.0 / ( + 1.0 + + (self.WorstIncPrb ** (1.0 / self.CRRA)) + * self.AbsPatFac + / solution_next.MPCmax + ) + + # The above attempts to pin down the limiting consumption function for this model + # however it is not clear why it creates bugs, so for now we allow for a + # linear extrapolation beyond the last asset point -# %% Base risky asset dictionary + self.cFuncLimitIntercept = None + self.cFuncLimitSlope = None + + def def_BoroCnst(self, BoroCnstArt): + """ + Defines the constrained portion of the consumption function as cFuncNowCnst, + an attribute of self. Uses the artificial and natural borrowing constraints. + + Parameters + ---------- + BoroCnstArt : float or None + Borrowing constraint for the minimum allowable assets to end the + period with. If it is less than the natural borrowing constraint, + then it is irrelevant; BoroCnstArt=None indicates no artificial bor- + rowing constraint. + + Returns + ------- + none + """ + + # Calculate the minimum allowable value of money resources in this period + self.BoroCnstNat = ( + (self.solution_next.mNrmMin - self.TranShkDstn.X.min()) + * (self.PermGroFac * self.PermShkDstn.X.min()) + / self.RiskyDstn.X.max() + ) + + # Flag for whether the natural borrowing constraint is zero + self.zero_bound = self.BoroCnstNat == BoroCnstArt + + if BoroCnstArt is None: + self.mNrmMinNow = self.BoroCnstNat + else: + self.mNrmMinNow = np.max([self.BoroCnstNat, BoroCnstArt]) + if self.BoroCnstNat < self.mNrmMinNow: + self.MPCmaxEff = 1.0 # If actually constrained, MPC near limit is 1 + else: + self.MPCmaxEff = self.MPCmaxNow + + # Define the borrowing constraint (limiting consumption function) + self.cFuncNowCnst = LinearInterp( + np.array([self.mNrmMinNow, self.mNrmMinNow + 1]), np.array([0.0, 1.0]) + ) + + def prepare_to_calc_EndOfPrdvP(self): + """ + Prepare to calculate end-of-period marginal value by creating an array + of market resources that the agent could have next period, considering + the grid of end-of-period assets and the distribution of shocks he might + experience next period. + + Parameters + ---------- + none + + Returns + ------- + aNrmNow : np.array + A 1D array of end-of-period assets; also stored as attribute of self. + """ + + if self.zero_bound: + # if zero is BoroCnstNat, do not evaluate at 0.0 + aNrmNow = self.aXtraGrid + + if self.IndepDstnBool: + bNrmNext = np.append( + aNrmNow[0] * self.RiskyDstn.X.min(), + aNrmNow * self.RiskyDstn.X.max(), + ) + wNrmNext = np.append( + bNrmNext[0] / (self.PermGroFac * self.PermShkDstn.X.max()), + bNrmNext / (self.PermGroFac * self.PermShkDstn.X.min()), + ) + else: + # add zero to aNrmNow + aNrmNow = np.append(self.BoroCnstArt, self.aXtraGrid) + + if self.IndepDstnBool: + bNrmNext = aNrmNow * self.RiskyDstn.X.max() + wNrmNext = bNrmNext / (self.PermGroFac * self.PermShkDstn.X.min()) + + self.aNrmNow = aNrmNow + + if self.IndepDstnBool: + # these grids are only used if the distributions of income and + # risky asset are independent + self.bNrmNext = bNrmNext + self.wNrmNext = wNrmNext + + return self.aNrmNow + + def calc_ExpMargValueFunc(self, dstn, func, grid): + """ + Calculate Expected Marginal Value Function given a distribution, + a function, and a set of interpolation nodes. + """ + + vals = calc_expectation(dstn, func, grid) + nvrs = self.uPinv(vals) + nvrsFunc = LinearInterp(grid, nvrs) + margValueFunc = MargValueFuncCRRA(nvrsFunc, self.CRRA) + + return margValueFunc, vals + + def calc_preIncShkvPfunc(self, vPfuncNext): + """ + Calculate Expected Marginal Value Function before the + realization of income shocks. + """ + + # calculate expectation with respect to transitory shock + + def preTranShkvPfunc(tran_shk, w_nrm): + return vPfuncNext(w_nrm + tran_shk) + + self.preTranShkvPfunc, _ = self.calc_ExpMargValueFunc( + self.TranShkDstn, preTranShkvPfunc, self.wNrmNext + ) + + # calculate expectation with respect to permanent shock + + def prePermShkvPfunc(perm_shk, b_nrm): + shock = perm_shk * self.PermGroFac + return shock ** (-self.CRRA) * self.preTranShkvPfunc(b_nrm / shock) + + self.prePermShkvPfunc, _ = self.calc_ExpMargValueFunc( + self.PermShkDstn, prePermShkvPfunc, self.bNrmNext + ) + + preIncShkvPfunc = self.prePermShkvPfunc + + return preIncShkvPfunc + + def calc_preRiskyShkvPfunc(self, preIncShkvPfunc): + """ + Calculate Expected Marginal Value Function before + the realization of the risky return. + """ + + # calculate expectation with respect to risky shock + + def preRiskyShkvPfunc(risky_shk, a_nrm): + return self.DiscFacEff * risky_shk * preIncShkvPfunc(a_nrm * risky_shk) + + self.preRiskyShkvPfunc, EndOfPrdvP = self.calc_ExpMargValueFunc( + self.RiskyDstn, preRiskyShkvPfunc, self.aNrmNow + ) + + self.EndOfPrdvPfunc = self.preRiskyShkvPfunc + + return EndOfPrdvP + + def calc_EndOfPrdvP(self): + """ + Calculate end-of-period marginal value of assets at each point in aNrmNow. + Does so by taking a weighted sum of next period marginal values across + income shocks (in a preconstructed grid self.mNrmNext). + + Parameters + ---------- + none + + Returns + ------- + EndOfPrdvP : np.array + A 1D array of end-of-period marginal value of assets + """ + + if self.IndepDstnBool: + # if distributions are independent we can use iterated expectations + + preIncShkvPfunc = self.calc_preIncShkvPfunc(self.vPfuncNext) + + EndOfPrdvP = self.calc_preRiskyShkvPfunc(preIncShkvPfunc) + + else: + + def vP_next(shocks, a_nrm): + perm_shk = shocks[0] * self.PermGroFac + mNrm_next = a_nrm * shocks[2] / perm_shk + shocks[1] + return ( + self.DiscFacEff + * shocks[2] + * perm_shk ** (-self.CRRA) + * self.vPfuncNext(mNrm_next) + ) + + self.EndOfPrdvPfunc, EndOfPrdvP = self.calc_ExpMargValueFunc( + self.ShockDstn, vP_next, self.aNrmNow + ) + + return EndOfPrdvP + + def calc_ExpValueFunc(self, dstn, func, grid): + """ + Calculate Expected Value Function given distribution, + function, and interpolating nodes. + """ + + vals = calc_expectation(dstn, func, grid) + nvrs = self.uinv(vals) + nvrsFunc = LinearInterp(grid, nvrs) + valueFunc = ValueFuncCRRA(nvrsFunc, self.CRRA) + + return valueFunc, vals + + def calc_preIncShkvFunc(self, vFuncNext): + """ + Calculate Expected Value Function prior to realization + of income uncertainty. + """ + + def preTranShkvFunc(tran_shk, w_nrm): + return vFuncNext(w_nrm + tran_shk) + + self.preTranShkvFunc, _ = self.calc_ExpValueFunc( + self.TranShkDstn, preTranShkvFunc, self.wNrmNext + ) + + def prePermShkvFunc(perm_shk, b_nrm): + shock = perm_shk * self.PermGroFac + return shock ** (1.0 - self.CRRA) * self.preTranShkvFunc(b_nrm / shock) + + self.prePermShkvFunc, _ = self.calc_ExpValueFunc( + self.PermShkDstn, prePermShkvFunc, self.bNrmNext + ) + + preIncShkvFunc = self.prePermShkvFunc + + return preIncShkvFunc + + def calc_preRiskyShkvFunc(self, preIncShkvFunc): + """ + Calculate Expected Value Function prior to + realization of risky return. + """ + + def preRiskyShkvFunc(risky_shk, a_nrm): + return self.DiscFacEff * preIncShkvFunc(risky_shk * a_nrm) + + self.preRiskyShkvFunc, EndOfPrdv = self.calc_ExpValueFunc( + self.RiskyDstn, preRiskyShkvFunc, self.aNrmNow + ) + + self.EndOfPrdvFunc = self.preRiskyShkvFunc + + return EndOfPrdv + + def make_EndOfPrdvFunc(self, EndOfPrdvP): + """ + Construct the end-of-period value function for this period, storing it + as an attribute of self for use by other methods. + + Parameters + ---------- + EndOfPrdvP : np.array + Array of end-of-period marginal value of assets corresponding to the + asset values in self.aNrmNow. + + Returns + ------- + none + """ + + if self.IndepDstnBool: + + preIncShkvFunc = self.calc_preIncShkvFunc(self.vFuncNext) + + self.EndOfPrdv = self.calc_preRiskyShkvFunc(preIncShkvFunc) + + else: + + def v_next(shocks, a_nrm): + perm_shk = shocks[0] * self.PermGroFac + mNrm_next = a_nrm * shocks[2] / perm_shk + shocks[1] + return ( + self.DiscFacEff + * perm_shk ** (1.0 - self.CRRA) + * self.vFuncNext(mNrm_next) + ) + + self.EndOfPrdvFunc, self.EndOfPrdv = self.calc_ExpValueFunc( + self.ShockDstn, v_next, self.aNrmNow + ) + + +@dataclass +class ConsPortfolioIndShkRiskyAssetSolver(ConsIndShkRiskyAssetSolver): + ShareGrid: np.array + ShareLimit: float + PortfolioBisect: bool + + def __post_init__(self): + + super().__post_init__() + + if self.PortfolioBisect: + raise NotImplementedError( + "RiskyAssetConsumerType does not implement optimization by bisection yet!" + ) + + def set_and_update_values(self, solution_next, IncShkDstn, LivPrb, DiscFac): + """ + Unpacks some of the inputs (and calculates simple objects based on them), + storing the results in self for use by other methods. These include: + income shocks and probabilities, next period's marginal value function + (etc), the probability of getting the worst income shock next period, + the patience factor, human wealth, and the bounding MPCs. + + Parameters + ---------- + solution_next : ConsumerSolution + The solution to next period's one period problem. + IncShkDstn : distribution.DiscreteDistribution + A DiscreteDistribution with a pmf + and two point value arrays in X, order: + permanent shocks, transitory shocks. + LivPrb : float + Survival probability; likelihood of being alive at the beginning of + the succeeding period. + DiscFac : float + Intertemporal discount factor for future utility. + + Returns + ------- + None + """ + + super().set_and_update_values(solution_next, IncShkDstn, LivPrb, DiscFac) + + # Absolute Patience Factor for the model with risk free return is defined at + # https://econ-ark.github.io/BufferStockTheory/BufferStockTheory3.html#APFacDefn + + # The corresponding Absolute Patience Factor when the + # return factor is risky is defined implicitly in + # https://www.econ2.jhu.edu/people/ccarroll/public/LectureNotes/Consumption/CRRA-RateRisk/ + + def abs_pat_fac(shock): + r_port = self.Rfree + (shock - self.Rfree) * self.ShareLimit + return r_port ** (1.0 - self.CRRA) + + self.AbsPatFac = ( + self.DiscFacEff * calc_expectation(self.RiskyDstn, abs_pat_fac) + ) ** (1.0 / self.CRRA) + + self.MPCminNow = 1.0 / (1.0 + self.AbsPatFac / solution_next.MPCmin) + + self.MPCmaxNow = 1.0 / ( + 1.0 + + (self.WorstIncPrb ** (1.0 / self.CRRA)) + * self.AbsPatFac + / solution_next.MPCmax + ) + + # The above attempts to pin down the limiting consumption function for this model + # however it is not clear why it creates bugs, so for now we allow for a + # linear extrapolation beyond the last asset point + + self.cFuncLimitIntercept = None + self.cFuncLimitSlope = None + + def prepare_to_calc_EndOfPrdvP(self): + """ + Prepare to calculate end-of-period marginal value by creating an array + of market resources that the agent could have next period, considering + the grid of end-of-period assets and the distribution of shocks he might + experience next period. + + Parameters + ---------- + none + + Returns + ------- + aNrmNow : np.array + A 1D array of end-of-period assets; also stored as attribute of self. + """ + + super().prepare_to_calc_EndOfPrdvP() + + self.aNrmMat, self.shareMat = np.meshgrid( + self.aNrmNow, self.ShareGrid, indexing="ij" + ) + + return self.aNrmNow + + def optimize_share(self, EndOfPrddvds): + """ + Optimize the risky share of portfolio given End of Period + Marginal Value wrt a given risky share. Returns optimal share + and End of Period Marginal Value of Liquid Assets at the optimal share. + """ + + # For each value of aNrm, find the value of Share such that FOC-Share == 0. + crossing = np.logical_and( + EndOfPrddvds[:, 1:] <= 0.0, EndOfPrddvds[:, :-1] >= 0.0 + ) + share_idx = np.argmax(crossing, axis=1) + a_idx = np.arange(self.aNrmNow.size) + bot_s = self.ShareGrid[share_idx] + top_s = self.ShareGrid[share_idx + 1] + bot_f = EndOfPrddvds[a_idx, share_idx] + top_f = EndOfPrddvds[a_idx, share_idx + 1] + + alpha = 1.0 - top_f / (top_f - bot_f) + + risky_share_optimal = (1.0 - alpha) * bot_s + alpha * top_s + + # If agent wants to put more than 100% into risky asset, he is constrained + constrained_top = EndOfPrddvds[:, -1] > 0.0 + # Likewise if he wants to put less than 0% into risky asset + constrained_bot = EndOfPrddvds[:, 0] < 0.0 + + # For values of aNrm at which the agent wants to put + # more than 100% into risky asset, constrain them + risky_share_optimal[constrained_top] = 1.0 + risky_share_optimal[constrained_bot] = 0.0 + + if not self.zero_bound: + # aNrm=0, so there's no way to "optimize" the portfolio + risky_share_optimal[0] = 1.0 + + return risky_share_optimal + + def calc_preRiskyShkvPfunc(self, preIncShkvPfunc): + """ + Calculate Expected Marginal Value Function before + the realization of the risky return. + """ + + # Optimize portfolio share + + def endOfPrddvds(risky_shk, a_nrm, share): + r_diff = risky_shk - self.Rfree + r_port = self.Rfree + r_diff * share + b_nrm = a_nrm * r_port + return a_nrm * r_diff * preIncShkvPfunc(b_nrm) + + # optimize share by discrete interpolation + if True: + + EndOfPrddvds = calc_expectation( + self.RiskyDstn, endOfPrddvds, self.aNrmMat, self.shareMat + ) + + self.risky_share_optimal = self.optimize_share(EndOfPrddvds) + + # this hidden option was used to find optimal share via root finding + # but it is much slower and not particularly more accurate + else: + + def obj(share, a_nrm): + return calc_expectation(self.RiskyDstn, endOfPrddvds, a_nrm, share) + + risky_share_optimal = np.empty_like(self.aNrmNow) + + for ai in range(self.aNrmNow.size): + a_nrm = self.aNrmNow[ai] + if a_nrm == 0: + risky_share_optimal[ai] = 1.0 + else: + try: + sol = root_scalar( + obj, bracket=[self.ShareLimit, 1.0], args=(a_nrm,) + ) + + if sol.converged: + risky_share_optimal[ai] = sol.root + else: + risky_share_optimal[ai] = 1.0 + + except ValueError: + risky_share_optimal[ai] = 1.0 + + self.risky_share_optimal = risky_share_optimal + + def endOfPrddvda(risky_shk, a_nrm, share): + r_diff = risky_shk - self.Rfree + r_port = self.Rfree + r_diff * share + b_nrm = a_nrm * r_port + return r_port * preIncShkvPfunc(b_nrm) + + EndOfPrddvda = self.DiscFacEff * calc_expectation( + self.RiskyDstn, endOfPrddvda, self.aNrmNow, self.risky_share_optimal + ) + EndOfPrddvdaNvrs = self.uPinv(EndOfPrddvda) + EndOfPrddvdaNvrsFunc = LinearInterp(self.aNrmNow, EndOfPrddvdaNvrs) + EndOfPrddvdaFunc = MargValueFuncCRRA(EndOfPrddvdaNvrsFunc, self.CRRA) + + return EndOfPrddvda + + def calc_EndOfPrdvP(self): + """ + Calculate end-of-period marginal value of assets at each point in aNrmNow. + Does so by taking a weighted sum of next period marginal values across + income shocks (in a preconstructed grid self.mNrmNext). + + Parameters + ---------- + none + + Returns + ------- + EndOfPrdvP : np.array + A 1D array of end-of-period marginal value of assets + """ + + if self.IndepDstnBool: + + preIncShkvPfunc = self.calc_preIncShkvPfunc(self.vPfuncNext) + + EndOfPrdvP = self.calc_preRiskyShkvPfunc(preIncShkvPfunc) + + else: + + def endOfPrddvds(shocks, a_nrm, share): + r_diff = shocks[2] - self.Rfree + r_port = self.Rfree + r_diff * share + b_nrm = a_nrm * r_port + p_shk = self.PermGroFac * shocks[0] + m_nrm = b_nrm / p_shk + shocks[1] + + return r_diff * a_nrm * p_shk ** (-self.CRRA) * self.vPfuncNext(m_nrm) + + EndOfPrddvds = calc_expectation( + self.RiskyDstn, endOfPrddvds, self.aNrmMat, self.shareMat + ) + + self.risky_share_optimal = self.optimize_share(EndOfPrddvds) + + def endOfPrddvda(shocks, a_nrm, share): + r_diff = shocks[2] - self.Rfree + r_port = self.Rfree + r_diff * share + b_nrm = a_nrm * r_port + p_shk = self.PermGroFac * shocks[0] + m_nrm = b_nrm / p_shk + shocks[1] + + return r_port * p_shk ** (-self.CRRA) * self.vPfuncNext(m_nrm) + + EndOfPrddvda = self.DiscFacEff * calc_expectation( + self.RiskyDstn, endOfPrddvda, self.aNrmNow, self.risky_share_optimal + ) + + EndOfPrddvdaNvrs = self.uPinv(EndOfPrddvda) + EndOfPrddvdaNvrsFunc = LinearInterp(self.aNrmNow, EndOfPrddvdaNvrs) + self.EndOfPrddvdaFunc = MargValueFuncCRRA(EndOfPrddvdaNvrsFunc, self.CRRA) + + EndOfPrdvP = EndOfPrddvda + + return EndOfPrdvP + + def add_ShareFunc(self, solution): + """ + Construct the risky share function twice, once with respect + to End of Period which depends on Liquid assets, and another + with respect to Beginning of Period which depends on Cash on Hand. + """ + + if self.zero_bound: + # add zero back on agrid + self.EndOfPrdShareFunc = LinearInterp( + np.append(0.0, self.aNrmNow), + np.append(1.0, self.risky_share_optimal), + intercept_limit=self.ShareLimit, + slope_limit=0.0, + ) + else: + self.EndOfPrdShareFunc = LinearInterp( + self.aNrmNow, + self.risky_share_optimal, + intercept_limit=self.ShareLimit, + slope_limit=0.0, + ) + + self.ShareFunc = LinearInterp( + np.append(0.0, self.mNrmNow), + np.append(1.0, self.risky_share_optimal), + intercept_limit=self.ShareLimit, + slope_limit=0.0, + ) + + solution.EndOfPrdShareFunc = self.EndOfPrdShareFunc + solution.ShareFunc = self.ShareFunc + + return solution + + def solve(self): + solution = super().solve() + + solution = self.add_ShareFunc(solution) + + return solution + + +@dataclass +class ConsFixedPortfolioIndShkRiskyAssetSolver(ConsIndShockSolver): + solution_next: ConsumerSolution + IncShkDstn: DiscreteDistribution + TranShkDstn: DiscreteDistribution + PermShkDstn: DiscreteDistribution + RiskyDstn: DiscreteDistribution + ShockDstn: DiscreteDistribution + LivPrb: float + DiscFac: float + CRRA: float + Rfree: float + RiskyShareFixed: float + PermGroFac: float + BoroCnstArt: float + aXtraGrid: np.array + vFuncBool: bool + CubicBool: bool + IndepDstnBool: bool + + def __post_init__(self): + self.def_utility_funcs() + + def r_port(self, shock): + return self.Rfree + (shock - self.Rfree) * self.RiskyShareFixed + + def set_and_update_values(self, solution_next, IncShkDstn, LivPrb, DiscFac): + """ + Unpacks some of the inputs (and calculates simple objects based on them), + storing the results in self for use by other methods. These include: + income shocks and probabilities, next period's marginal value function + (etc), the probability of getting the worst income shock next period, + the patience factor, human wealth, and the bounding MPCs. + + Parameters + ---------- + solution_next : ConsumerSolution + The solution to next period's one period problem. + IncShkDstn : distribution.DiscreteDistribution + A DiscreteDistribution with a pmf + and two point value arrays in X, order: + permanent shocks, transitory shocks. + LivPrb : float + Survival probability; likelihood of being alive at the beginning of + the succeeding period. + DiscFac : float + Intertemporal discount factor for future utility. + + Returns + ------- + None + """ + + super().set_and_update_values(solution_next, IncShkDstn, LivPrb, DiscFac) + + # overwrite APFac + + def abs_pat_fac(shock): + return self.r_port(shock) ** (1.0 - self.CRRA) + + self.AbsPatFac = ( + self.DiscFacEff * calc_expectation(self.RiskyDstn, abs_pat_fac) + ) ** (1.0 / self.CRRA) + + self.MPCminNow = 1.0 / (1.0 + self.AbsPatFac / solution_next.MPCmin) + + # overwrite human wealth + + def h_nrm_now(shock): + r_port = self.r_port(shock) + return self.PermGroFac / r_port * (self.Ex_IncNext + solution_next.hNrm) + + self.hNrmNow = calc_expectation(self.RiskyDstn, h_nrm_now) + + self.MPCmaxNow = 1.0 / ( + 1.0 + + (self.WorstIncPrb ** (1.0 / self.CRRA)) + * self.AbsPatFac + / solution_next.MPCmax + ) + + # The above attempts to pin down the limiting consumption function for this model + # however it is not clear why it creates bugs, so for now we allow for a + # linear extrapolation beyond the last asset point + + self.cFuncLimitIntercept = None + self.cFuncLimitSlope = None + + def def_BoroCnst(self, BoroCnstArt): + """ + Defines the constrained portion of the consumption function as cFuncNowCnst, + an attribute of self. Uses the artificial and natural borrowing constraints. + + Parameters + ---------- + BoroCnstArt : float or None + Borrowing constraint for the minimum allowable assets to end the + period with. If it is less than the natural borrowing constraint, + then it is irrelevant; BoroCnstArt=None indicates no artificial bor- + rowing constraint. + + Returns + ------- + none + """ + + # in worst case scenario, debt gets highest return possible + self.RPortMax = ( + self.Rfree + (self.RiskyDstn.X.max() - self.Rfree) * self.RiskyShareFixed + ) + + # Calculate the minimum allowable value of money resources in this period + self.BoroCnstNat = ( + (self.solution_next.mNrmMin - self.TranShkDstn.X.min()) + * (self.PermGroFac * self.PermShkDstn.X.min()) + / self.RPortMax + ) + + if BoroCnstArt is None: + self.mNrmMinNow = self.BoroCnstNat + else: + self.mNrmMinNow = np.max([self.BoroCnstNat, BoroCnstArt]) + if self.BoroCnstNat < self.mNrmMinNow: + self.MPCmaxEff = 1.0 # If actually constrained, MPC near limit is 1 + else: + self.MPCmaxEff = self.MPCmaxNow + + # Define the borrowing constraint (limiting consumption function) + self.cFuncNowCnst = LinearInterp( + np.array([self.mNrmMinNow, self.mNrmMinNow + 1]), np.array([0.0, 1.0]) + ) + + def calc_EndOfPrdvP(self): + """ + Calculate end-of-period marginal value of assets at each point in aNrmNow. + Does so by taking a weighted sum of next period marginal values across + income shocks (in a preconstructed grid self.mNrmNext). + + Parameters + ---------- + none + + Returns + ------- + EndOfPrdvP : np.array + A 1D array of end-of-period marginal value of assets + """ + + def vp_next(shocks, a_nrm): + r_port = self.r_port(shocks[2]) + p_shk = self.PermGroFac * shocks[0] + m_nrm_next = a_nrm * r_port / p_shk + shocks[1] + return r_port * p_shk ** (-self.CRRA) * self.vPfuncNext(m_nrm_next) + + EndOfPrdvP = self.DiscFacEff * calc_expectation( + self.ShockDstn, vp_next, self.aNrmNow + ) + + return EndOfPrdvP + + def make_EndOfPrdvFunc(self, EndOfPrdvP): + """ + Construct the end-of-period value function for this period, storing it + as an attribute of self for use by other methods. + + Parameters + ---------- + EndOfPrdvP : np.array + Array of end-of-period marginal value of assets corresponding to the + asset values in self.aNrmNow. + + Returns + ------- + none + """ + + def v_next(shocks, a_nrm): + r_port = self.Rfree + (shocks[2] - self.Rfree) * self.RiskyShareFixed + m_nrm_next = r_port / (self.PermGroFac * shocks[0]) * a_nrm + shocks[1] + return shocks[0] ** (1.0 - self.CRRA) * self.vFuncNext(m_nrm_next) + + EndOfPrdv = ( + self.DiscFacEff + * self.PermGroFac ** (1.0 - self.CRRA) + * calc_expectation(self.ShockDstn, v_next, self.aNrmNow) + ) + # value transformed through inverse utility + EndOfPrdvNvrs = self.uinv(EndOfPrdv) + aNrm_temp = np.insert(self.aNrmNow, 0, self.BoroCnstNat) + EndOfPrdvNvrsFunc = LinearInterp(aNrm_temp, EndOfPrdvNvrs) + self.EndOfPrdvFunc = ValueFuncCRRA(EndOfPrdvNvrsFunc, self.CRRA) + + +# Initial parameter sets + +# Base risky asset dictionary risky_asset_parms = { # Risky return factor moments. Based on SP500 real returns from Shiller's @@ -257,3 +1299,8 @@ def get_shocks(self): # Make a dictionary to specify a risky asset consumer type init_risky_asset = init_idiosyncratic_shocks.copy() init_risky_asset.update(risky_asset_parms) +# Number of discrete points in the risky share approximation +init_risky_asset["ShareCount"] = 25 + +init_risky_share_fixed = init_risky_asset.copy() +init_risky_share_fixed["RiskyShareFixed"] = [0.0] diff --git a/HARK/ConsumptionSaving/tests/test_ConsPortfolioFrameModel.py b/HARK/ConsumptionSaving/tests/test_ConsPortfolioFrameModel.py index 465ae9752..37559d5a1 100644 --- a/HARK/ConsumptionSaving/tests/test_ConsPortfolioFrameModel.py +++ b/HARK/ConsumptionSaving/tests/test_ConsPortfolioFrameModel.py @@ -13,6 +13,7 @@ def setUp(self): self.pcct.solve() + class FramesTestCase(PortfolioConsumerTypeTestCase): def test_frames(self): @@ -22,85 +23,74 @@ def test_frames(self): self.assertFalse(cNrm_frame.aggregate) self.assertFalse(cNrm_frame.reward) - U_frame = cNrm_frame.children[('U',)] + U_frame = cNrm_frame.children[("U",)] self.assertTrue(U_frame.reward) - self.assertEqual(U_frame.target[0], 'U') + self.assertEqual(U_frame.target[0], "U") + class UnitsPortfolioConsumerTypeTestCase(PortfolioConsumerTypeTestCase): def test_simOnePeriod(self): self.pcct.T_sim = 30 self.pcct.AgentCount = 10 - self.pcct.track_vars += ['aNrm'] + self.pcct.track_vars += ["aNrm"] self.pcct.initialize_sim() - self.assertFalse( - np.any(self.pcct.shocks['Adjust']) - ) + self.assertFalse(np.any(self.pcct.shocks["Adjust"])) self.pcct.sim_one_period() - self.assertAlmostEqual( - self.pcct.shocks['PermShk'][0], - 0.9692322 - ) + self.assertAlmostEqual(self.pcct.shocks["PermShk"][0], 0.9692322) - self.assertAlmostEqual( - self.pcct.shocks['TranShk'][0], - 1.03172631 - ) + self.assertAlmostEqual(self.pcct.shocks["TranShk"][0], 1.03172631) - self.assertAlmostEqual( - self.pcct.shocks['Risky'][0], - 0.96358739 - ) + self.assertAlmostEqual(self.pcct.shocks["Risky"][0], 0.96358739) self.assertAlmostEqual( - self.pcct.state_now['pLvl'][0], - self.pcct.state_prev['pLvl'][0] * self.pcct.shocks['PermShk'][0] + self.pcct.state_now["pLvl"][0], + self.pcct.state_prev["pLvl"][0] * self.pcct.shocks["PermShk"][0], ) - self.assertTrue( - np.any(self.pcct.shocks['Adjust'][0]) - ) + self.assertTrue(np.any(self.pcct.shocks["Adjust"][0])) self.assertAlmostEqual( self.pcct.state_now["mNrm"][0], - self.pcct.state_prev["aNrm"][0] \ - * self.pcct.Rfree / self.pcct.shocks['PermShk'][0] \ - + self.pcct.shocks['TranShk'][0] \ + self.pcct.state_prev["aNrm"][0] + * self.pcct.Rfree[0] + / self.pcct.shocks["PermShk"][0] + + self.pcct.shocks["TranShk"][0], ) self.assertAlmostEqual( # todo: more flexible test self.pcct.controls["Share"][0], - 0.90256316 + 0.90256316, ) self.assertAlmostEqual( self.pcct.controls["cNrm"][0], - self.pcct.solution[0].cFuncAdj(self.pcct.state_now['mNrm'][0]) + self.pcct.solution[0].cFuncAdj(self.pcct.state_now["mNrm"][0]), ) self.assertAlmostEqual( - self.pcct.state_now['aNrm'][0], - self.pcct.state_now["mNrm"][0] - self.pcct.controls["cNrm"][0] + self.pcct.state_now["aNrm"][0], + self.pcct.state_now["mNrm"][0] - self.pcct.controls["cNrm"][0], ) -class SimulatePortfolioConsumerTypeTestCase(PortfolioConsumerTypeTestCase): +class SimulatePortfolioConsumerTypeTestCase(PortfolioConsumerTypeTestCase): def test_simulation(self): self.pcct.T_sim = 30 self.pcct.AgentCount = 10 self.pcct.track_vars += [ - 'mNrm', - 'cNrm', - 'Share', - 'aNrm', - 'Adjust', - 'PermShk', - 'TranShk', - 'bNrm' + "mNrm", + "cNrm", + "Share", + "aNrm", + "Adjust", + "PermShk", + "TranShk", + "bNrm", ] self.pcct.initialize_sim() @@ -108,52 +98,48 @@ def test_simulation(self): self.assertAlmostEqual( self.pcct.history["mNrm"][0][0], - self.pcct.history["bNrm"][0][0] \ - + self.pcct.history['TranShk'][0][0] + self.pcct.history["bNrm"][0][0] + self.pcct.history["TranShk"][0][0], ) self.assertAlmostEqual( - self.pcct.history['cNrm'][0][0], - self.pcct.solution[0].cFuncAdj(self.pcct.history['mNrm'][0][0]) + self.pcct.history["cNrm"][0][0], + self.pcct.solution[0].cFuncAdj(self.pcct.history["mNrm"][0][0]), ) self.assertAlmostEqual( - self.pcct.history['Share'][0][0], - self.pcct.solution[0].ShareFuncAdj(self.pcct.history['mNrm'][0][0]) + self.pcct.history["Share"][0][0], + self.pcct.solution[0].ShareFuncAdj(self.pcct.history["mNrm"][0][0]), ) self.assertAlmostEqual( - self.pcct.history['aNrm'][0][0], - self.pcct.history["mNrm"][0][0] - self.pcct.history["cNrm"][0][0] + self.pcct.history["aNrm"][0][0], + self.pcct.history["mNrm"][0][0] - self.pcct.history["cNrm"][0][0], ) - self.assertAlmostEqual( - self.pcct.history['Adjust'][0][0], 1.0 - ) + self.assertAlmostEqual(self.pcct.history["Adjust"][0][0], 1.0) # the next period self.assertAlmostEqual( self.pcct.history["mNrm"][1][0], - self.pcct.history["bNrm"][1][0] \ - + self.pcct.history['TranShk'][1][0] + self.pcct.history["bNrm"][1][0] + self.pcct.history["TranShk"][1][0], ) self.assertAlmostEqual( - self.pcct.history['cNrm'][1][0], - self.pcct.solution[0].cFuncAdj(self.pcct.history['mNrm'][1][0]) + self.pcct.history["cNrm"][1][0], + self.pcct.solution[0].cFuncAdj(self.pcct.history["mNrm"][1][0]), ) self.assertAlmostEqual( - self.pcct.history['Share'][1][0], - self.pcct.solution[0].ShareFuncAdj(self.pcct.history['mNrm'][1][0]) + self.pcct.history["Share"][1][0], + self.pcct.solution[0].ShareFuncAdj(self.pcct.history["mNrm"][1][0]), ) self.assertAlmostEqual( - self.pcct.history['aNrm'][1][0], - self.pcct.history["mNrm"][1][0] - self.pcct.history["cNrm"][1][0] + self.pcct.history["aNrm"][1][0], + self.pcct.history["mNrm"][1][0] - self.pcct.history["cNrm"][1][0], ) self.assertAlmostEqual( - self.pcct.history['aNrm'][15][0], - self.pcct.history["mNrm"][15][0] - self.pcct.history["cNrm"][15][0] + self.pcct.history["aNrm"][15][0], + self.pcct.history["mNrm"][15][0] - self.pcct.history["cNrm"][15][0], ) diff --git a/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py b/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py index 9053c8401..089d98452 100644 --- a/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py +++ b/HARK/ConsumptionSaving/tests/test_ConsPortfolioModel.py @@ -48,7 +48,7 @@ def test_sim_one_period(self): self.assertAlmostEqual(self.pcct.state_now["aNrm"][0], 7.257027956) - self.assertAlmostEqual(self.pcct.Rfree, 1.03) + self.assertAlmostEqual(self.pcct.Rfree[0], 1.03) self.assertAlmostEqual(self.pcct.state_now["PlvlAgg"], 1.0) diff --git a/examples/ConsPortfolioModel/example_ConsPortfolioModel.ipynb b/examples/ConsPortfolioModel/example_ConsPortfolioModel.ipynb index e5f08a333..c30051c60 100644 --- a/examples/ConsPortfolioModel/example_ConsPortfolioModel.ipynb +++ b/examples/ConsPortfolioModel/example_ConsPortfolioModel.ipynb @@ -20,7 +20,7 @@ " PortfolioConsumerType,\n", " init_portfolio,\n", ")\n", - "from HARK.utilities import plot_funcs" + "from HARK.utilities import plot_funcs\n" ] }, { @@ -33,7 +33,7 @@ "output_type": "stream", "text": [ "Now solving an example portfolio choice problem; this might take a moment...\n", - "Solving an infinite horizon portfolio choice problem took 10.72180986404419 seconds.\n" + "Solving an infinite horizon portfolio choice problem took 4.454003810882568 seconds.\n" ] } ], @@ -51,7 +51,7 @@ " \"Solving an infinite horizon portfolio choice problem took \"\n", " + str(t1 - t0)\n", " + \" seconds.\"\n", - ")" + ")\n" ] }, { @@ -68,7 +68,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -88,7 +88,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -118,7 +118,7 @@ " ],\n", " 0.0,\n", " 200.0,\n", - ")" + ")\n" ] }, { @@ -187,7 +187,7 @@ "MyType.track_vars = [\"cNrm\", \"Share\", \"aNrm\", \"t_age\"]\n", "MyType.T_sim = 100\n", "MyType.initialize_sim()\n", - "MyType.simulate()" + "MyType.simulate()\n" ] }, { @@ -215,7 +215,7 @@ "print(\"as market resources approach infinity, see\")\n", "print(\n", " \"http://www.econ2.jhu.edu/people/ccarroll/public/lecturenotes/AssetPricing/Portfolio-CRRA/\"\n", - ")" + ")\n" ] }, { @@ -231,7 +231,7 @@ "init_discrete_share = init_portfolio.copy()\n", "init_discrete_share[\"DiscreteShareBool\"] = True\n", "# Have to actually construct value function for this to work\n", - "init_discrete_share[\"vFuncBool\"] = True" + "init_discrete_share[\"vFuncBool\"] = True\n" ] }, { @@ -244,7 +244,7 @@ "output_type": "stream", "text": [ "Now solving a discrete choice portfolio problem; this might take a minute...\n", - "Solving an infinite horizon discrete portfolio choice problem took 21.6518394947052 seconds.\n" + "Solving an infinite horizon discrete portfolio choice problem took 9.10599970817566 seconds.\n" ] } ], @@ -266,7 +266,7 @@ " \"Solving an infinite horizon discrete portfolio choice problem took \"\n", " + str(t1 - t0)\n", " + \" seconds.\"\n", - ")" + ")\n" ] }, { @@ -283,7 +283,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -303,7 +303,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -330,7 +330,7 @@ " [DiscreteType.ShareFunc[0], lambda m: DiscreteType.ShareLimit * np.ones_like(m)],\n", " 0.0,\n", " 200.0,\n", - ")" + ")\n" ] }, { @@ -350,7 +350,7 @@ } ], "source": [ - "print(\"\\n\\n\\n\")" + "print(\"\\n\\n\\n\")\n" ] }, { @@ -363,7 +363,7 @@ "# Make another example type, but this one can only update their risky portfolio\n", "# share in any particular period with 15% probability.\n", "init_sticky_share = init_portfolio.copy()\n", - "init_sticky_share[\"AdjustPrb\"] = 0.15" + "init_sticky_share[\"AdjustPrb\"] = 0.15\n" ] }, { @@ -376,7 +376,7 @@ "output_type": "stream", "text": [ "Now solving a portfolio choice problem with \"sticky\" portfolio shares; this might take a moment...\n", - "Solving an infinite horizon sticky portfolio choice problem took 111.06221723556519 seconds.\n" + "Solving an infinite horizon sticky portfolio choice problem took 42.04501509666443 seconds.\n" ] } ], @@ -403,7 +403,7 @@ " \"Solving an infinite horizon sticky portfolio choice problem took \"\n", " + str(t1 - t0)\n", " + \" seconds.\"\n", - ")" + ")\n" ] }, { @@ -420,7 +420,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -436,7 +436,7 @@ "print(\n", " \"Consumption function over market resources when the agent can adjust his portfolio:\"\n", ")\n", - "plot_funcs(StickyType.cFuncAdj[0], 0.0, 50.0)" + "plot_funcs(StickyType.cFuncAdj[0], 0.0, 50.0)\n" ] }, { @@ -453,7 +453,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -474,7 +474,7 @@ " plt.plot(M, C)\n", "plt.xlim(0.0, 50.0)\n", "plt.ylim(0.0, None)\n", - "plt.show()" + "plt.show()\n" ] }, { @@ -492,7 +492,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAoTUlEQVR4nO3deXxcdb3/8dcnk31rmmbpknSjpbTQFkqorAKCQBHBq3KFq6AocrkP8bpcr3jV63K93uvyw4cbiiiIer3gAiqbIheBsljpRvfSlrTQtGmarknaps3y+f1xTso0TTLTJJOZZN7PR+cx55w5M+czJ9N5z/cs32PujoiISF8ykl2AiIikPoWFiIjEpLAQEZGYFBYiIhKTwkJERGJSWIiISEwJCwszu9fMdprZ6l4eNzP7rpltMrOVZjYvUbWIiMjAJLJlcR9wRR+PLwCmh7dbgB8msBYRERmAhIWFuy8E9vQxyzXAzz2wCCgxs3GJqkdERPovM4nLngBsjRqvC6fVd5/RzG4haH2QkVd8ZuaoihNa0EnlheRnR/pfqYjIMLd06dJd7l7e3+cnMyysh2k99j3i7ncDdwPMPWOe/+mZF+JaQGPzYa7+/gt86qpZfPD8Kf0uVERkuDOz1wby/GSGRR1QHTVeBWyP9aSsSAbjRuXFtYCxxbnkZ0fYuvdg/yoUEREguYfOPgzcGB4VdTaw392P2wQ1EGZG9eh8tu45NJgvKyKSdhLWsjCz+4GLgDIzqwO+CGQBuPtdwOPAlcAm4CBwUyLqqC7No04tCxGRAUlYWLj79TEed+AjiVp+l6rR+Syq3YO7Y9bTbhIREYllxJ/BXTU6j5bD7ew72JbsUkREhq0RHxbVpfkA2sktIjIAIz8sRodhoZ3cIiL9NuLDoqo0OMxWLQsRkf4b8WFRnJvFqLwsHRElIjIAIz4sIDh8VpuhRET6Ly3CoqokX5uhREQGIC3CIjgx7xCdnT12PSUiIjGkRVhMGlPAkfZOdjS1JrsUEZFhKS3CYmpZAQC1jQeSXImIyPCUHmFRXgjA5l0tSa5ERGR4SouwqCzOIT87wqtqWYiI9EtahIWZMaWsgNpdCgsRkf5Ii7CAYFNUbaM2Q4mI9Ef6hEVZAdv2HaK1rSPZpYiIDDvpExblBbjDa7t1cp6IyIlKn7AoC46I0qYoEZETlzZhcVJFAWawoUFhISJyotImLPKzM5lUms/6HU3JLkVEZNhJm7AAOGVsMa/saE52GSIiw05ahcWMsUVs3n2AQ0d0RJSIyIlIq7CYOa4Id9i4U60LEZETkVZhMWNsMQDr6xUWIiInIq3CYmJpPnlZEdZrv4WIyAlJq7CIZBgnVxbqiCgRkROUVmEBOiJKRKQ/0i4sZo4rYveBI+zYr6vmiYjEK+3CYnZVCQAr6vYltQ4RkeEk7cLi1PHFZGYYK7buS3YpIiLDRtqFRW5WhBlji1hZtz/ZpYiIDBtpFxYAc6tLWFG3j85OT3YpIiLDQlqGxelVJTS3trN5ty6zKiISj7QMiznVowBYqZ3cIiJxScuwmF5RRH52hBVbtd9CRCQeaRkWkQxj9oRRLHt9b7JLEREZFhIaFmZ2hZm9YmabzOwzPTw+ysweMbMVZrbGzG5KZD3R5k8pZfW2/bQcbh+qRYqIDFsJCwsziwB3AguAWcD1Zjar22wfAda6+1zgIuAOM8tOVE3R5k8ppdNh6WtqXYiIxJLIlsV8YJO717r7EeAB4Jpu8zhQZGYGFAJ7gCH5qX/mpNFkZhgvbd49FIsTERnWEhkWE4CtUeN14bRo3wdmAtuBVcDH3L2z+wuZ2S1mtsTMljQ2Ng5KcfnZmZw2YRQvbd4zKK8nIjKSJTIsrIdp3c+Cuxx4GRgPnA5838yKj3uS+93uXuPuNeXl5YNW4JumlLJi635a23SZVRGRviQyLOqA6qjxKoIWRLSbgIc8sAnYDJySwJqOMX9KKUc6Oln++r6hWqSIyLCUyLBYDEw3synhTuvrgIe7zfM6cAmAmVUCM4DaBNZ0jJrJpUQyjBdf3TVUixQRGZYSFhbu3g7cBjwBrAN+7e5rzOxWM7s1nO0rwLlmtgp4Crjd3Yfsm3tUXhZnVJfw7IbB2Q8iIjJSZSbyxd39ceDxbtPuihreDlyWyBpiuWhGOf/vzxvY1XKYssKcZJYiIpKy0vIM7mgXnlwBwHMb1boQEelN2ofFqeOLKSvM5plXFBYiIr1J+7DIyDDePL2chRsa6dD1LUREepT2YQFw4Yxy9h5sY/U29UIrItIThQVwwfRyMgyeXNuQ7FJERFKSwgIoLcjm7KljeHx1Pe7aFCUi0p3CIrRg9jhqGw+woaEl2aWIiKQchUXoilPHkmHw2Kr6ZJciIpJyFBah8qIc5k8p5Y8KCxGR4ygsolw5exwbd7awsaE52aWIiKQUhUWUrk1RD6/o3jmuiEh6U1hEqSjO5fzp5Ty0bBudOkFPROQohUU37z6zim37DrGoVpdbFRHporDo5rJZlRTlZvLbpXXJLkVEJGUoLLrJzYpw1ZzxPL66nqbWtmSXIyKSEhQWPbh+fjWtbZ08qNaFiAigsOjRnKoSzphYws//+pp2dIuIoLDo1QfOnczmXQdYqIsiiYgoLHqz4LRxlBXm8LMXtyS7FBGRpFNY9CI7M4P3vmkiz2xoZNNOdS4oIulNYdGHG86ZRE5mBnc9+2qySxERSSqFRR/KCnO47qyJ/H75Nur2Hkx2OSIiSaOwiOEfL5yKGdy9sDbZpYiIJI3CIoZxo/J417wqHli8lR37W5NdjohIUsQVFmY2ycwuDYfzzKwosWWllo9cPA135ztPbUh2KSIiSREzLMzsw8BvgR+Fk6qA3yewppRTXZrP+86exK8Wb2XTTl3rQkTSTzwti48A5wFNAO6+EahIZFGp6KNvmU5+dibf+NMryS5FRGTIxRMWh939SNeImWUCadcHRmlBNrdeOJU/r23gxVd3JbscEZEhFU9YPGtmnwXyzOytwG+ARxJbVmq6+YKpVJfm8YU/rOFIe2eyyxERGTLxhMXtQCOwCvhH4HHg84ksKlXlZkX40ttPZdPOFn76wuZklyMiMmQy+3rQzDKAle5+GvDjoSkptV0ys5JLZ1bynac28va54xlfkpfskkREEq7PloW7dwIrzGziENUzLHzx7bPodOdzv1uFe9rtvhGRNBTPZqhxwBoze8rMHu66JbqwVFZdms+nLz+Fp19p5FeLtya7HBGRhOtzM1ToywmvYhj6wLmTeXJtA195dC3nTSujujQ/2SWJiCRMzJaFuz/b0y2eFzezK8zsFTPbZGaf6WWei8zsZTNbY2ZxvW4qyMgwvnntHDLM+Oj9y3V0lIiMaPGcwX22mS02sxYzO2JmHWbWFMfzIsCdwAJgFnC9mc3qNk8J8APganc/Fbi2P28iWapG5/P1d8/h5a37+O8/rkt2OSIiCRPPPovvA9cDG4E84OZwWizzgU3uXhue1PcAcE23ef4BeMjdXwdw953xFp4qrpw9jg+cO5mfvrCFx1fVJ7scEZGEiKsjQXffBETcvcPdfwpcFMfTJgDRe3/rwmnRTgZGm9kzZrbUzG7s6YXM7BYzW2JmSxobU++a2J+9cianV5fw6d+uZGOD+o4SkZEnnrA4aGbZwMtm9g0z+wRQEMfzrIdp3Y8zzQTOBN4GXA78u5mdfNyT3O929xp3rykvL49j0UMrOzODO987j9ysCDfdt5jG5sPJLklEZFDFExY3hPPdBhwAqoF3xfG8unDeLlXA9h7m+ZO7H3D3XcBCYG4cr51yJpTkcc/7a9jVcpgP/3wJrW0dyS5JRGTQxHM01Gvu3uruTe7+ZXf/ZLhZKpbFwHQzmxK2TK4Dup+f8QfgAjPLNLN84E3AsN1TPLe6hG+/5wxW1O3jk79+mc5OnbAnIiNDPEdDnWdmT5rZBjOr7brFep67txO0Rp4gCIBfu/saM7vVzG4N51kH/AlYCbwE/MTdVw/kDSXbFaeN5bMLZvL4qh3820OrFBgiMiLEc1LePcAngKXACW1bcffHCToejJ52V7fxbwLfPJHXTXU3XzCFptY2vveXTWRkGF99x2lkZPS0C0dEZHiIJyz2u/sfE17JCGJmfPKtJ9PR6fzgmVeJZMB/XK3AEJHhq9ewMLN54eDTZvZN4CHg6GE+7r4swbUNa2bGv14+gw53fvRsLQcPd/D1d88hKxLX0coiIimlr5bFHd3Ga6KGHXjL4JczspgZn7niFAqzM7njyQ3sPnCEH7x3HgU58TToRERSR6/fWu5+8VAWMlKZGR+9ZDrlRTl89ner+IcfL+LeD5zFmMKcZJcmIhK3XreJmNnbzWxS1PgXzGxF2EX55CGpbgS5bv5EfnRDDet3NHP1919gzfb9yS5JRCRufW1A/yrB5VQxs6uA9wEfJDhX4keJL23keeusSn5z6zl0uvOuH77IH17eluySRETi0ldYuLsfDIffCdzj7kvd/SdA6vW5MUzMqSrh4dvOZ/aEUXzsgZf5z0fXqntzEUl5fYWFmVlheB3uS4Cnoh7LTWxZI1t5UQ6/vPlsbjxnEj95fjPvuPMFNqgDQhFJYX2FxbeBl4ElwDp3XwJgZmcA6ot7gLIzM/iPa07jxzfW0NDUylXfe557n9+sM75FJCWZe+9fTmY2AagAVrh7ZzhtHJDVdQ2KoVZTU+NLlixJxqITprH5MLc/uJK/rN/Jm6aU8tW/m820isJklyUiI4iZLXX3mthz9qzPM8TcfZu7L+8KinBafbKCYqQqL8rhnvfX8LV3zmZdfRMLvrOQbz25QT3XikjK0OnEKcLMuG7+RJ76l4t42+xxfPepjSz4znM8uyH1LvYkIulHYZFiyoty+PZ1Z/CLD83H3Xn/vS9xwz1/Y119zMuei4gkTJ/7LI7OZDYXuCAcfc7dVyS0qj6MxH0WvTnc3sEv/voa3/vLJppa27j2zCr+5bIZVBbrYDQROTEJ3WcRLuBjwC8JdnRXAP9jZh/t7wIlfjmZEW6+YCoL//Vibj5/Cr9fvp03f+NpvvzIGnbsb012eSKSRmK2LMxsJXCOux8IxwuAv7r7nCGo7zjp1LLo7vXdB/neXzby0PJtRMz4+7Oq+KeLpjGhJC/ZpYlIikt4ywIwjr3oUUc4TYbYxDH5fPPauTzzqYt415lV/GrxVi78xtN87IHlLH99b7LLE5ERLJ6+sn8K/M3MfheOv4Pg6nmSJNWl+fz3O2dz21um8eOFtfx2aR1/eHk7c6tL+MC5k7hy9jhyMiPJLlNERpB4d3DPA84naFEsdPfliS6sN+m8Gao3LYfbeWhZHfe9uIXaxgOUFebwnrOquPbMaiaXFSS7PBFJAQPdDNVrWJhZsbs3mVlpT4+7+57+LnQgFBa96+x0nt+0i5+9uIWnX9lJp8P8yaW8u6aKt80ep4suiaSxRIbFo+5+lZltJrgy3tGHCHqkndrfhQ6EwiI+O/a38tDyOn67pI7aXQfIz46w4LRxvH3uOM6bVqbLu4qkmYSFRapSWJwYd2fZ63v5zZI6HltZT/Phdkrys7h81liumjuOc6aOIVPBITLiJbJlMa+vJ7r7sv4udCAUFv13uL2D5zbs4rFV9Ty5toGWw+2UFmTz1pmVXDKzgvOnl5GfrU1VIiNRIsPi6T6e5+7+lv4udCAUFoOjta2DZzc08ujKep5Zv5Pmw+1kZ2Zw7kljuOSUCt4ys1Lnb4iMINoMJQPW1tHJ4s17eGr9Tp5a18CW3cEFEk8ZW8R508o4b9oY5k8ZQ6F2kIsMWwkPCzPLAv4JeHM46RngR+7e1t+FDoTCIvFqG1t4at1Ontmwk8Vb9nKkvZNIhjG3ahTnTSvjnKljOH1iiTZZiQwjQxEWPwGygJ+Fk24AOtz95v4udCAUFkOrta2DZa/t5YVXd/HCpt2srNtHp0Mkwzh1fDFnThpNzaRSaiaPVgeHIilsKMJihbvPjTVtqCgskquptY2lr+1l6Za9LN6yhxV1+2htC66NVV2aR82kUs6cNJrTq0s4ubKI7EwdaSWSCgYaFvFsR+gws5Pc/dVwgVM5tq8oSSPFuVlcPKOCi2dUAHCkvZO19U0s2bKHJVv28tzGXfxu+TYguM74zHHFzK0axewJo5hbXcJJ5YVEMtS1mMhwE0/L4hKC/qFqCU7ImwTc5O59HS2VMGpZpDZ3Z+ueQ6zcto+VdftZWbeP1duaaDncDkB+doRZ44qZNb6YmeOC24zKIvKy1ZeVSCIlrGVhZte6+28IQmI6MIMgLNa7++H+LlBGNjNj4ph8Jo7J56o544GgG5LaXS1heOxn9bb9PLRsGy2HXwMgw2BKWcHR8JgV3lcW52CmVohIKujrPItl7j6v636I6+qVWhYjQ2enU7f3EGvr97O2vpl19U2s3d7Etn2Hjs5TlJvJ9IpCTq4sYnplESdXBsMVRQoRkROVyJPyniRoeZwOPNf9cXe/ur8LHQiFxci2/1Ab6+ubWL+jmQ0NzWzc2cLGhmb2HnzjSO3i3Myj4TG9ooiTw+FyhYhIrxIZFtnAPOAXwHGHybr7s/1d6EAoLNKPu7Or5QgbG6IDpIUNO5vZFxUio/KymF5RyPTKovC+kGkVhYwtzlWISNpL2D4Ldz8CLDKzz3UPBjO7tr8LFDlRZkZ5UQ7lRTmcO63s6HR3p7HlMJsaWtjQ0MyGsBXyx9X13B8VIoU5mUyrKDwaINMriphWUciEkjwydGSWSFziORrquH0W8e7HMLMrgO8AEeAn7v61XuY7C1gEvMfdf9vXa6plIbG4O7sPHGFjQwubdgYtkU07W9i4s4XG5jeOzcjLinBSRcHR8OhqlVSPzlNPvDLiJPJoqAXAlcAEM/tu1EPFQHschUWAO4G3AnXAYjN72N3X9jDf14EnTrx8keOZGWWFOZQV5nDOSWOOeWzfwSNHg6Pr/m+1u4+eGwKQHclganlBGCBFzBhbxJyqUYwbpc1Zkr76OilvO7AEuBpYGjW9GfhEHK89H9jk7rUAZvYAcA2wttt8HwUeBM6Ks2aRfivJz6Zmcik1k4+9AGRzaxuvNh4IA6SZTQ3Bob6Praqnq/FdVpjN7AmjmF1VwpwJo5hdNUpdnEja6GufxQozWw1c5u4/622+PkwAtkaN1wFvip7BzCYAfwe8hT7CwsxuAW4BmDhxYj9KEelbUW4Wp1eXcHp1yTHTDx3p4JWGZlbV7WNF3X5W1e3n2Q0b6QwDpKIohzMmlnD21DGcPXUMMyqLtB9ERqQ+u/tw9w4zG2Nm2eEO7xPR0/+Y7jtIvg3cHi6nrzruBu6GYJ/FCdYh0m952ZGjIXJDOO3gkXbWbm86eob60tf38sSaBgBG52fxpiljOHtqKW8+uZyp5YXJK15kEMXTN9RrwAtm9jBwoGuiu38rxvPqgOqo8SqCTVvRaoAHwqAoA640s3Z3/30cdYkkRX525nGbsur2HmRR7R4W1e5mUe1u/rRmBwBTywu4dGYlV5w2ljOqS7TPQ4ateI6G+mJP0939yzGelwlsAC4BtgGLgX9w9zW9zH8f8KiOhpKRYOueg/xl/U7+b10Di2p309bhTCzN55rTx3PN6eOZVlGU7BIlzQzZlfLMrIjgcqotJ1DclQSbmiLAve7+VTO7leCF7uo2730oLGQEampt44nVO3h4xXZe2LSLToc5VaN417wqrp47ntEF2ckuUdLAUFzP4jSCs7i72ty7gBt7ayEkmsJChrOdza08sqKeB5fWsba+iayIcckplbz7zCounFFOls7vkAQZirB4EfhcV5fkZnYR8F/ufm5/FzoQCgsZKdZub+LBZXX8fvk2dh84QllhNlfPncDb5ozjjOoSHVUlg0pXyhMZ5to6Onn2lUYeXFbH/61roK3DqSjK4bJTK7n81LGcPXWMWhwyYENxpbxaM/t3gk1RAO8DNvd3gSJyrKxIBpfOquTSWZU0tbbx9Pqd/Gn1Dh5cuo3/WfQ6xbmZXDC9nAuml/Hmk8sZX5KX7JIlDcXTshgNfBk4P5y0EPiyu+9NcG09UstC0kVrWwcLNzTy5NoGFm5spKEp6NfqpPICLpheznnTyjhz0mhKtYNc4pDILspzgVuBacAqgqOZ2nqceQgpLCQduTsbd7awcEMjz23cxd8276a1rROAaRWFnDV5NDWTSjlrcinVpXk6n0OOk8iw+BXQRnDhowXAFnf/eH8XNFgUFiJBq2PVtv0s3rKHJVv2smTLHppag/49R+dncdqEUZw6flTQl9WEUQoQSeg+i1nuPjtcyD3AS/1diIgMrtysCGdNDloSEFymduPOFhZv2cPqbftZtW0/9zxfS1tH8GOwODeTmeOKj+mKfXqFri4o8esrLI5ucnL3dn2gRFJXRoYxY2zQnXqXw+0dbNjRwqowPDY0NPPIiu1HWyAQhMi0ikKmlhcysTSfiaX5VIf3ZYXZChI5qq+wmGtmTeGwAXnhuBGcyV2c8OpEpN9yMiPMrgq6Uu/i7jQ2Hz56LY+NO5vZ2NDCc1E70LvkZUWOhsf4klwqi3MZW5zL2FHh8KhcCnPiOaBSRoK+uiiPDGUhIpJ4ZkZFcS4VxbnHXKIWgv0gdXsPsXXPQV6Pum3dc5DFW/aw/9Dxx7cU5mRSWZxDRVEupYXZjCnIprSg6z6H0QVZjCnIobQgm9H5WboC4TCmnwUiAgT7QaZVFDKtoudu1Q8d6aChqZUdTa00NLVSv7+VHfuD4cbmw6zb3sTuA0d6DBUAsyBcinOzKMrNpDgvi+Lc7uNvDOdnRyjIySQvK0J+doT87EzysoNhnaQ49BQWIhKXvOwIk8sKmFxW0Od8bR2d7D14hD0Hjr3tbgmCpKm1jebWdpoOtbF9XyvrW5tpbm2nubXt6EWlYsmKWBgimeTnhGGSlUlOVgY5mRnkZEbIzswgO5JBTlZwnx09PTOYr+u+azgrkkFmRgaZESOSYWRlZBDJMDIjRmaGkZmRQSRiZGVYOD2DzHA4K5JBhjFi9/MMv7DYtRF++rZkVyEivcgCKsJbn7LDW7j303E6Hdo7OunodDrc6ewkvPdu99DpTken09nudBwJntvpTqc7fnQ42E/TdR/vldM6wtuJXvENgp26ZmAY4b/gSnBhiHRFSVemRM939PGu5x8zH1Hz2bHTOTakLOqBwYqu4RcWIjIiGUbEIJKZuN2lXYHUFSDRwXL0PpiRThyiQsaD0WPHj3nMw2lRw+FrdcVU12ltXaHVdZ7bG+NRlUbP2/VaR6f70VZY1/ix8x373MEw/MKibDrc9FiyqxCRYcgILq6Tlr44sDaG9hKJiEhMCgsREYlJYSEiIjEpLEREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiUliIiEhMCgsREYlJYSEiIjEpLEREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiUliIiEhMCgsREYlJYSEiIjElNCzM7Aoze8XMNpnZZ3p4/L1mtjK8vWhmcxNZj4iI9E/CwsLMIsCdwAJgFnC9mc3qNttm4EJ3nwN8Bbg7UfWIiEj/JbJlMR/Y5O617n4EeAC4JnoGd3/R3feGo4uAqgTWIyIi/ZTIsJgAbI0arwun9eZDwB97esDMbjGzJWa2pLGxcRBLFBGReCQyLKyHad7jjGYXE4TF7T097u53u3uNu9eUl5cPYokiIhKPzAS+dh1QHTVeBWzvPpOZzQF+Aixw990JrEdERPopkS2LxcB0M5tiZtnAdcDD0TOY2UTgIeAGd9+QwFpERGQAEtaycPd2M7sNeAKIAPe6+xozuzV8/C7gC8AY4AdmBtDu7jWJqklERPrH3HvcjZCyampqfMmSJckuQ0RkWDGzpQP5Ma4zuEVEJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiUliIiEhMCgsREYlJYSEiIjEpLEREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiUliIiEhMCgsREYlJYSEiIjEpLEREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiUliIiEhMCgsREYlJYSEiIjEpLEREJCaFhYiIxKSwEBGRmBQWIiISk8JCRERiUliIiEhMCgsREYlJYSEiIjEpLEREJCaFhYiIxKSwEBGRmBIaFmZ2hZm9YmabzOwzPTxuZvbd8PGVZjYvkfWIiEj/JCwszCwC3AksAGYB15vZrG6zLQCmh7dbgB8mqh4REem/RLYs5gOb3L3W3Y8ADwDXdJvnGuDnHlgElJjZuATWJCIi/ZCZwNeeAGyNGq8D3hTHPBOA+uiZzOwWgpYHwGEzWz24pSZEGbAr2UXEQXUOruFQ53CoEVTnYJsxkCcnMiysh2nej3lw97uBuwHMbIm71wy8vMRSnYNLdQ6e4VAjqM7BZmZLBvL8RG6GqgOqo8argO39mEdERJIskWGxGJhuZlPMLBu4Dni42zwPAzeGR0WdDex39/ruLyQiIsmVsM1Q7t5uZrcBTwAR4F53X2Nmt4aP3wU8DlwJbAIOAjfF8dJ3J6jkwaY6B5fqHDzDoUZQnYNtQHWa+3G7CERERI6hM7hFRCQmhYWIiMQ0rMIiVvchyWBm1Wb2tJmtM7M1ZvaxcPqXzGybmb0c3q5MgVq3mNmqsJ4l4bRSM3vSzDaG96OTXOOMqHX2spk1mdnHU2F9mtm9ZrYz+jyfvtafmf1b+Fl9xcwuT3Kd3zSz9WG3Or8zs5Jw+mQzOxS1Xu9Kcp29/p1TbH3+KqrGLWb2cjg9Keuzj++hwft8uvuwuBHsJH8VmApkAyuAWSlQ1zhgXjhcBGwg6N7kS8Cnkl1ft1q3AGXdpn0D+Ew4/Bng68mus9vffAcwKRXWJ/BmYB6wOtb6Cz8DK4AcYEr42Y0ksc7LgMxw+OtRdU6Oni8F1mePf+dUW5/dHr8D+EIy12cf30OD9vkcTi2LeLoPGXLuXu/uy8LhZmAdwVnow8U1wM/C4Z8B70heKce5BHjV3V9LdiEA7r4Q2NNtcm/r7xrgAXc/7O6bCY74m5+sOt39z+7eHo4uIjinKal6WZ+9San12cXMDPh74P6hqKU3fXwPDdrncziFRW9dg6QMM5sMnAH8LZx0W9jsvzfZm3dCDvzZzJaGXagAVHp4bkt4X5G06o53Hcf+J0y19Qm9r79U/rx+EPhj1PgUM1tuZs+a2QXJKipKT3/nVF2fFwAN7r4xalpS12e376FB+3wOp7CIq2uQZDGzQuBB4OPu3kTQg+5JwOkEfV3dkbzqjjrP3ecR9Pb7ETN7c7IL6o0FJ3JeDfwmnJSK67MvKfl5NbPPAe3AL8NJ9cBEdz8D+CTwv2ZWnKz66P3vnJLrE7ieY3/QJHV99vA91OusPUzrc30Op7BI2a5BzCyL4A/0S3d/CMDdG9y9w907gR8zRE3mvrj79vB+J/A7gpoaLOzpN7zfmbwKj7EAWObuDZCa6zPU2/pLuc+rmb0fuAp4r4cbrsPNELvD4aUE265PTlaNffydU3F9ZgLvBH7VNS2Z67On7yEG8fM5nMIinu5Dhly4zfIeYJ27fytqenRX638HJLWnXDMrMLOirmGCHZ6rCdbh+8PZ3g/8ITkVHueYX2yptj6j9Lb+HgauM7McM5tCcM2Wl5JQHxAcSQjcDlzt7gejppdbcO0ZzGwqQZ21yamyz79zSq3P0KXAenev65qQrPXZ2/cQg/n5HOq99gPc438lwV7+V4HPJbuesKbzCZpvK4GXw9uVwC+AVeH0h4FxSa5zKsHRDyuANV3rDxgDPAVsDO9LU2Cd5gO7gVFR05K+PgnCqx5oI/hl9qG+1h/wufCz+gqwIMl1biLYRt31Gb0rnPdd4edhBbAMeHuS6+z175xK6zOcfh9wa7d5k7I++/geGrTPp7r7EBGRmIbTZigREUkShYWIiMSksBARkZgUFiIiEpPCQkREYlJYSNzMzM3sjqjxT5nZl4a4hmfMrCYcfryr99QBvN5FZvZoL9PdzD4UNe2McNqnTnAZXzqR55jZZ/t4rKvn4JVhdxKTTqQWkf5SWMiJOAy808zK+vPk8IzXQePuV7r7vsF8zW5WAe+JGr+O4Pj5uPXzPfcaFqGL3X0O8Azw+X68/oB0nXQm6UVhISeineA6vp/o/oCZTTKzp8JfvE+Z2cRw+n1m9i0zexr4ejj+w7Dv/VozuzDsMG6dmd0X9Xo/NLMlYd/8X+6pmPBXdpmZ3WpvXD9gc7gszOwyM/urmS0zs9+E/eZ0XRdlvZk9T9BdQ29eB3LNrDI8Q/YKojrgM7MPm9liM1thZg+aWX5P77lbzR82sz+aWZ6Zvc/MXgrr/pGZRczsa0BeOO2X9O2vhJ2/hWcOPxjWs9jMzgunXxi1bpabWZEFvmlmq8NWynvCeY9pZZnZ983sA1Hr+gvhOrs2XIfLwvf+VDhPQfi3XBwu65pw+qlR73OlmU2P8b4kFQ3VWZC6Df8b0AIUE1wXYxTwKeBL4WOPAO8Phz8I/D4cvg94lLCv/HD8AYKOzK4BmoDZBD9clgKnh/OVhvcRgl/Qc8LxZ4CacHgLUdfnALKA54C3A2XAQqAgfOx24AtALsGZzNPDGn4NPNrDe70orPufgduA84CfEnW9BWBM1Pz/CXy0l/f8pXBd3UZwVnIOMDNcZ1nhPD8Abuxaz338DY6+Z+DbwC3h8P8C54fDEwm6fej6u5wXDhcCmQRnGT8ZrttKglAc1/Weo5b1feADUcv9dDhcHq7DKd3+Vv8FvC8cLiHobaEA+B5Bf1QQXIsmL9mfZd1O/DaomwVk5HP3JjP7OcGX6KGoh87hjV/pvyC46EqX37h7R9T4I+7uZraKoHvnVQBmtobg4jEvA39vQTfqmQRfZLMIujLoy3eAv7j7I2Z2VficF4JGAdkEv8RPATZ72KW0mf0PcEsvrwdBmPwqfN79wLlRj51mZv9J8MVYCDzRx3u+gaCriHe4e5uZXQKcCSwO68sj/k4cnzazynD+rs1QlwKzwtcCKLagL7AXgG+FrZSH3L3OzM4H7g/razCzZ4GzCIK7L10d5p0NLPTgOgi4e9e1Hi4Dro7aP5NLEFx/BT5nZlVhDdHdecswobCQ/vg2Qb83P+1jnuh+ZA50e+xweN8ZNdw1nmlBx2afAs5y973h5qncvgoKN5dMIvj1DkGr4Ul3v77bfKdzAl1bu/sOM2sD3gp8jGPD4j6CL/8V4fIvinqs+3teTdDtdhWwOazvZ+7+b/HWEuXi8PXvA/6DoCvsDOAcdz/Ubd6vmdljBP0ELTKzS+m5e2oINjNGb5ruvs673pPR8zo04F3u/kq36evM7G/A24AnzOxmd/9Lb29OUpP2WcgJC39J/pqg47cuLxLsAAZ4L/D8ABZRTPDFtD/8Bb2gr5nN7EyCcHmfB11bQ3A1uPPMbFo4T76ZnQysJ7g4zUnhfNcf94LH+wJwe7eWAgSXr6y3oGvo98Z4jeXAPwIPm9l4gk7d3m1mFWF9pfbGkU1t4Wv2KgyFjwM3mlkp8GfeCMquUMTMTnL3Ve7+dWAJQQtpIfCecB9JOcFlQ18CXiNoneSY2SiCKxX25K/AhWGoEy4fgpbVR8P9O5jZGeH9VKDW3b9LsBluTox1JSlILQvprzuI+nIi2Cx1r5n9K9AI3NTfFw5/qS8n6L2zlmBTSl9uA0oJNs8ALHH3m8Nf+/ebWU443+fdfUO4eesxM9tFEGqnxajnxV4e+neCq5G9RnDkVFGM13k+3ETzGEFL5fMEVy7MIOjR9CPha90NrDSzZe7eawi5e72Z3R8+75+BO81sJcH/64XArcDHzexioANYS7CD/gjBZsMVBC2ET7v7DgAz+zXB5r6NBAHX03Ibw3X4UFj7zvD9fIWg1bkyDIwtBNfPeA/wvrCFtoOgNSTDjHqdFRGRmLQZSkREYlJYiIhITAoLERGJSWEhIiIxKSxERCQmhYWIiMSksBARkZj+P/Tw7veMf40PAAAAAElFTkSuQmCC\n", + "image/png": "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", "text/plain": [ "
" ] @@ -513,7 +513,7 @@ " [StickyType.ShareFunc[0], lambda m: StickyType.ShareLimit * np.ones_like(m)],\n", " 0.0,\n", " 200.0,\n", - ")" + ")\n" ] }, { @@ -533,7 +533,7 @@ "init_age_varying_risk_perceptions[\"aXtraNestFac\"] = init_portfolio[\"aXtraNestFac\"]\n", "init_age_varying_risk_perceptions[\"BoroCnstArt\"] = init_portfolio[\"BoroCnstArt\"]\n", "init_age_varying_risk_perceptions[\"CRRA\"] = init_portfolio[\"CRRA\"]\n", - "init_age_varying_risk_perceptions[\"DiscFac\"] = init_portfolio[\"DiscFac\"]" + "init_age_varying_risk_perceptions[\"DiscFac\"] = init_portfolio[\"DiscFac\"]\n" ] }, { @@ -549,7 +549,7 @@ "init_age_varying_risk_perceptions[\"RiskyAvgTrue\"] = 1.08\n", "init_age_varying_risk_perceptions[\"RiskyStdTrue\"] = 0.20\n", "AgeVaryingRiskPercType = PortfolioConsumerType(**init_age_varying_risk_perceptions)\n", - "AgeVaryingRiskPercType.cycles = 1" + "AgeVaryingRiskPercType.cycles = 1\n" ] }, { @@ -561,7 +561,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Solving a 65 period portfolio choice problem with age-varying risk perceptions took 5.567425489425659 seconds.\n" + "Solving a 65 period portfolio choice problem with age-varying risk perceptions took 1.3649990558624268 seconds.\n" ] } ], @@ -585,7 +585,7 @@ " + \" period portfolio choice problem with age-varying risk perceptions took \"\n", " + str(t1 - t0)\n", " + \" seconds.\"\n", - ")" + ")\n" ] }, { @@ -602,7 +602,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -621,7 +621,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD4CAYAAAAAczaOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAADGkUlEQVR4nOzdd5wkR33//1dVdZy4Oe/l0+VTDigjIUQyGQwWJhhMxv4BxsbY2AaMbQw2wQhjcs5BJCEJJJSl0wWFyzlsvk0zO7Fj/f6YuSAZwxnk73Kin49HX3fP9O7W7M593l3VYYTWmkQikUj8fpDz3YBEIpFI/L+TFP1EIpH4PZIU/UQikfg9khT9RCKR+D2SFP1EIpH4PWLM1w/u6OjQixYtmq8fn0gkEqelzZs3T2mtO3/Tr5+3or9o0SI2bdo0Xz8+kUgkTktCiMO/zdcnwzuJRCLxeyQp+olEIvF7JCn6iUQi8XskKfqJRCLxeyQp+olEIvF75NcWfSHE54QQR4UQ2/6H54UQ4mNCiH1CiEeEEOc8/s1MJBKJxOPhVPb0vwA87Vc8/3RgeXN6LfCfv32zEolEIvF/4deep6+1vlMIsehXbPIc4Eu6cY/m+4UQLUKIXq312K/6vpOHRviPN70Fs3MLmYMVaj0mU2INtK2g7cBWnvzWd3LGivX/u1eTSCQSiV/p8RjT7weGTlofbj723wghXiuE2CSE2KRFDhU8i3jPLD1D5yP3+FxalmzoTNHpr+X7N37ycWhaIpFIJE72eBR98Use+6WfzKK1/pTW+jyt9XlClxBaY0UXs/uMl2Ial+O7ZZZUjuA7kkIw/Tg0LZFIJBInezyK/jAweNL6ADB6Kl+ohcCOewGwA4uSW0UHAbGrEbXK49C0RCKRSJzs8Sj6PwRe3jyL5yKg+OvG8xsanQEjMgFQOkPVqiPCOtKKcOrh49C0RCKRSJzs1x7IFUJ8HbgS6BBCDAN/D5gAWutPAjcCzwD2AVXgVaf+4wXINACxylJVdVRUR5ohdvl/9ToSiUQicQpO5eydl/6a5zXwpt/kh2sh8IwUUXCQwLCJIh9D1MEMsfxfdqggkUgkEr+Nebu1coNgzpggKG+iLM9GN4u+NgOMUM1v0xKJROIJaN5vw1BXjbN0QqnRQYQReURmhAwNgqA6z61LJBKJJ5b5LfpCEqnGAdtIhOggwox9PBtUaDFVnJzX5iUSicQTzbzv6ccqasyFh/ZjjNDHNzVEBsNTR+e5dYlEIvHEMu9FXwifvNmB1j7CNzGiCN8UyNjiyNTUfDcvkUgknlDmvejn3RaeNvBqBtxeROiiYvBMjY4NhguF+W5eIpFIPKHMe9F3rQwAKeUggxQqUvgShDYplkvz3LpEIpF4YpnHot+4IjekMaZvSQMRplCxoKoUhrCoVpNbMSQSicTjaf6KfvPaKy0bTUgpFxG4WDHUhIHCIgiSPf1EIpF4PM3zxVmghIFPiCltZJzCiSV1DJSCIEr29BOJROLxNO9j+hVZ5UvOHRStCBFbmEBdGChhQJxcnJVIJBKPp9+Bou8BUDJCZGwihKaOhZQKHSVFP5FIJB5P8170dRwDEEmBwEQrja8NhFSYYVL0E4lE4vE070U/bp69U5cRWisiFRPFCgyF6yX3V04kEonH07wXfXTj1M1ARAhpEBkaEWlQAsuvzXPjEolE4oll3ou+VBEXPelbkBlHGjaRjBAxCCkx/fp8Ny+RSCSeUOa96NtWDdP0sFqGEIaJjmNk1Cj6lu+h9S/9jPVEIpFI/AbmvejruNkEs4ZSJugIFUagIsxAUS3PzW8DE4lE4glk3ov+sUtzpVVCKQMdRxhRjLBCjMBieHJontuXSCQSTxzzXvR11Cj6yqwjlYQoxohiMEOUZ3Nw7Mg8tzCRSCSeOOb9hmsFWvln/o6ClUVIRRxozCgCM0aGDgenZ+aviYlEIvEEM29F/9jhWaE128SZ7LcXIw0gUpiRB2YEkcNoKbn/TiKRSDxe5n14R+nGFblllQEpILSRug5miAgdyvXkqtxEIpF4vMx70SdqFP2iyqGVhNBFxXW0GYB2iILkAq1EIpF4vMx70TciQGtKMouQIEMHFdeJDR8Rm+gwuUArkUgkHi/z/iEqCI2xq0gpSBNbATpwcXQJz9QIrSBOxvQTiUTi8TLve/pojXGkwuxUFuwAEbukdJmaqVHSTop+IpFIPI7mvei30riTZt2z0ZaPiG0yUZmqCVLamHHykYmJRCLxeJn3og8giPE9E23WEdokFVWpGRJpWljJ5+QmEonE42bei75G4uITeorYqiO0hR17eKZEKoOUN0fgB/PdzEQikXhCmPeiXxfwUnUbRuDjWSGgEPhUpIlSJrZXZWo8uRVDIpFIPB7mveh7SN5tfoUn+w9StWOkskEEVIWFlBLLr3NgeO98NzORSCSeEOa96AsEAdAbTjYO3iobEcfUtI1QAsOD/ZNj893MRCKReEL4nSj6VSnoiWeoWRJhWIhAUMNGKpC+w8FyctpmIpFIPB7mveinapqakHTFM9RNiTRMdAQ17SKlwPAzTHjRfDczkUgknhDm/YpcIQUPWJ20UKEsLYRS6FBSiy20FOBn8SN/3pqZSCQSTyTzvqevteA97SZH3TkqpBofpBJCEFqgBDLIIMOk6CcSicTj4ZSKvhDiaUKI3UKIfUKId/6S5/NCiB8JIR4WQmwXQrzqVBsQK4UdQNH0qMQuGAoiEIFG2zEqTmMkd9pMJBKJx8WvLfpCCAVcDzwdWA28VAix+jGbvQnYobU+E7gS+DchhHUqDdDCxAqgaviNoq8EBBIziMHyUZGNESVX5SYSicTj4VT29C8A9mmtD2itfeAbwHMes40GskIIAWSAGSA8lQZoAa4vKauIauQ2WhQ6WGFAbHsgTMx4lihMDuYmEonEb+tUin4/MHTS+nDzsZN9HFgFjAJbgT/XuvmRWCcRQrxWCLFJCLHp+GPE9PtZyiqmHloIBTpM4QQB2vLQmFhxgemRkf/1i0skEonEo51K0Re/5DH9mPVrgYeAPuAs4ONCiNx/+yKtP6W1Pk9rfd7xx2Kft3zdJ6pLDF+jrQBCh1xQJTKrxKZJyiuwb99Dp/qaEolEIvE/OJWiPwwMnrQ+QGOP/mSvAr6nG/YBB4GVp9IAAUTKomNEYfkhWAE6StEezBKaVYRh4vgl9k0O/drvlUgkEolf7VSK/kZguRBicfPg7EuAHz5mmyPA1QBCiG5gBXDgV35X0ehAaA2htDBqAifwwPYRkUtbPE3VijAME9PzOOQlZ/AkEonEb8v4dRtorUMhxJuBmwEFfE5rvV0I8frm858E3gd8QQixlcbO+19pradOpQECTWBY2FVBOvDQpoeOXVrjGSp2B1lloOoRw3reLylIJBKJ096vLfoAWusbgRsf89gnT1oeBZ76mzTAlCkq+QxuRZAKK0SWj9A2KT3EpNWFKUF4KQqR+k2+fSKRSCRO8juw+xwz3nU+6TpkoxKeHQE2QpapmyaGEohaK0aYfJBKIpFI/LbmreiLY+cEaUEptQRTL8DVBaoWgEUsa9RU4/bKys/jJGP6iUQi8Vubxz3941UfRYQSPVh6jqqtkYZDLHzK0kUqiePnSflFvEp9/pqbSCQSTwDzPrzj4SOJUWSxKFMzBcK0iKOQsk6BYWFFadLxBIe3bZ7v5iYSicRpbf5vrYxA4SNEDiUr1AwFhkUcakpRGq0MwMVhiv37H5m35iYSicQTwfyN6R+r+hpMWSMysihdoyRtpFJEoaAcZoitkFBZ2NE0B2oz89XcRCKReEL4HdjTB7++hcBwUaFHWbsIKYgCQTlIEzs1PFNh+WUOn9IJpolEIpH4n8z7gVzD8BDSpKaqqKBZ9E1JFChiTxE6JWLDQNYDhkRq/pqbSCQSTwC/A6dsgpQmvgxRYUQtclASdJDB8QMCcw7DNImrglqQXKCVSCQSv41539MHgVImoYwRfkw1dBBKgZehvV4kskpYAmQlQ7rm4VeT8/UTiUTiN/U7sKcvsByHSIToQBCHCqFA+lkGgqP4dg1Hgl1tp6Ve4uCWh+eryYlEInHam8cDuY2qLzTYjkuMh/ZNTD8CM0J5KQb8CSq2xJaCbL2dFn+CQ3s3/ZpvnEgkEon/ybyfsjmnW+hJD4CuI7w0jh+AG6JCl95wgqpjoQyFG7SSYpTD/sR8NTmRSCROe/M+vCPQBNIjb6SQQRon8NGWjxE5pMQUNctGGg6CHEpNMuLOV4sTiUTi9Pc7MbxTUz5Z5aKCNJmgRmz6KG0jZJGK4YBpU7McjKDIISM7b01OJBKJ09087ukfK/qasuVjSwMjSpGJKkSWBxgEqkZRZIkNk7plIqo+R8McQc2br2YnEonEaW3+9/TRVM0QW1qYoUsmLlJ1ApAWvgiYDVsIzBDPAL9qYFVDDtyf3IMnkUgkfhO/A3v6gooRYCsbI3ZxdJGqHaItGz/QzPoteO4sSgFlh+5SkQPb75uvZicSicRpbd7P3pH1kKJZw5IuUttYlKjaIAyHyBMU/Ry+M40rYnLldvq8I4zp0flqdiKRSJzW5n1PH6Bo+AhlooWNKcrULTAMg7AuqdRdQruAK2Naa220cJjhFj1fzU4kEonT2u/AmL4gVFA1YyJloOIKFWWglCTyTLL1KpFdxJWSlN+OaR7loN1CHMfz1vREIpE4Xc37nr4EQqUIlCBQCjOsU5ZplILYy7O0OkzoRFhmmtBoJ9RzDAcdDG/ZM19NTyQSidPWvI/pg8YXBpGUBEqiQo85ncJQEum1sNQfoeraKCtF2U1RrYBftth1573z1fREIpE4bc3bx5KIky7OCoUikhBKgQhDynEaYQiMIMeCYIQJJ4W2XKqWgT9n0F+aYiaanK+mJxKJxGlr3od3BIJASnwRoZUCP2oUfSVwggyt8QRlK01kKHwV4BRsVlT3Mdblz1fTE4lE4rQ17/feAU1sgE+AoSQ6gLrnELsRZuhiGjPMyBYqRgUHj665LjrEPg7mUniV+nw1P5FIJE5L8372Tp+YIRQCT9ZRUhL5BsqLiZ06QjuEZpnxejdVd4KM1LTUuzDtMfbFfWz7/p3z1vxEIpE4Hc37gVyhwdM2Oj2FKTTCT2P5EbFdI5YmHgFT9XZ8d4qMMrHiLqqqzESpg8N7Hpyv5icSicRpad7H9DWCIFQIZwZTgAzSuJ5HZFcITYO6D4V6ntiZJm1mKKfaKJQNumYL1FrG56v5iUQicVqa9+EdjURGktisYkqBDNJkgxq+WUGaNn5NUa3ZGG4Fy8ox5zr4syary/sY7omoV5LPzE0kEolTNe97+gCEgFHHEhIzTJEPCpScGMM08OqKpdVhvJREWy41EzomTZbHO9mbaePhr/5svl5CIpFInHbmb0+/Sevmh6EbdQwhsSKXTDxDxdGYUhFXLdbX9jCXShOYijieoX+2G9c9yJ76Eo7s3TXfLyGRSCROG/M+vAOCKLIwDB+hFEbskmaGmqWwBKhqGyu8wxTsLEVZJS188l4/RXuOmekWoq5kXD+RSCRO1e/A8I5AxwrD8JHKQsUuNkVqpoU0Ja7XRl80ylHRRckdJ2cYeE4/I3WLdbN7Ge+tMvzg7vl6GYlEInFamcfhnRNn78hIo40IrQy0sDBUmaLMIJQi7bdgmJOMeAP46VFazFaKmTa8WZOzqzvZ35Lj4W8l4/qJRCJxKubxPP0mLXBij7KVRiiDSJooyhR1FkwDI8rhWxXGq52I1DQpu52SY9M/Jlhg7WKrv5qynpuvl5FIJBKnlXkf09cInMijZGbQUhEYBkZYpxDl0aZCyxQlFTBba8FNzSHsNCFFlhxtI04NMTzdRzgwzNF9Q/P2UhKJROJ0cUpFXwjxNCHEbiHEPiHEO/+Hba4UQjwkhNguhLjjf9MIJ/apqBSxkgSGQoUBBT9P7NbxTJNqCFEVvLTEsxQynibvLWGXIVkztZdDvSEbPvXd/82PTCQSid9Lv7boCyEUcD3wdGA18FIhxOrHbNMCfAJ4ttZ6DfCiX/uTm+M7RwwLN/LwlEUsBYEUaD+i7KXQbgXPUHgVg6XlIWZSeWZFmawMKGUXMVlwuLjyMHvSg9SD6H/50hOJROL3z6ns6V8A7NNaH9Ba+8A3gOc8Zps/Ar6ntT4CoLU+euoNENhRjbq0CaUmloIwkBh1TWAXkJaJXza4oLKVcbObgjlFi5mnkO2hbUKy0tzKQ4V1hH1HGdqy7VR/bCKRSPxeOpWi3w+cPGA+3HzsZGcArUKI24UQm4UQL/9l30gI8VohxCYhxKbp6Znjj9tRnZpIERgVpCEJA0GqXiOwi1iGhLLLumA/Q/Eg9fxh2uxeyrZgxbBJlBqmMuUy3TfMfZ++4X/36hOJROL3zKkUffFLHtOPWTeAc4FnAtcC7xZCnPHfvkjrT2mtz9Nan9fR0d745hosXaNKulH0pST0FB1egZIb4gqNW25joRjmcG0hdnoKx+0giiYYLAyyyTG5dGoL+zp7UE6aKAj/d7+BRCKR+D1yKkV/GBg8aX0AGP0l29ykta5oraeAO4EzT7UJhq5TJUVkVDGERvgp2v0iJVfgSEVLrRVtTzFR6cTNzFK3FCqeopZaxmjR4erwAe6tXIg/MMZNH/6vU/uxiUQi8XvoVIr+RmC5EGKxEMICXgL88DHb/AC4TAhhCCFSwIXAzlNpgNCgdJ0aKSKz0rj1QpCmM5imZtsoyyTlt1AwPcIy+FnJpJyj1ZDMtCxn4RHBQvcRRie6mO47TG1v6X/z+hOJROL3yq8t+lrrEHgzcDONQv4trfV2IcTrhRCvb26zE7gJeAR4APiM1vpXH1UVJxYkHhWdIjaqmAJc3yWnj1IxHTAdhGhlUoFbqjLptjKtZmm3u5lNO6w9rNid8lk/sYN97f2IthSbfvTj3/gXkkgkEk9kp3Sevtb6Rq31GVrrpVrr9zcf+6TW+pMnbfNBrfVqrfVarfVHfv13PfHB6FIEVMIU2qhhCYkbpEipGYoiS2yYVJw0c57J6tI+DovF1HJHaLP7iKJRustLuddweWqwkXtrT6I8sIOd37n3N/ldJBKJxBPevN9aGUBKn2qYArNxe2U3SGMaRWaiVkITapZFtWJwqf8w++NlOJmjWKkOCEco5ldgjJhcYD7A6Fgnc4OTtLT08uAdv5jvl5VIJBK/c+a96EstEMKnFjqg6phSYkUZpFFmxmshSM3hGxCVFGeLfeyvLCGbP8qkKtGiNNMdqzh/j+ZgtsDasV1syp5FqavIg59JhngSiUTiseb/hmsIhAzxAhtp+ihlonSaWNaY9Vrw3UkcIyZVzNMnh6kVLaI8jMkCnU4/c2bI2pEOfuakeW50F3dNX0ptYBMd2QFu/c7X5uvlJRKJxO+ked/TF1qgZUAcCrShEcrCNx3iyKNUTxM5M6SkprPUQdkpI+Z8huxeZlKjdKUWEgcHKWfWEBw1udS+j2gkZLivFb/d5ND3NhPHj72kIJFIJH5/zeNdNk8sahEiwpjANECZ1E0bz1ekPJ8gNUdGGuTrHYyYgo7CNPtZhpkbxnY7kPERjnaeyfm7NQ+mfS6eepCfRk+nsOBuuvN9fOGff+n94RKJROL30vzv6SPQIoJA4xsKpMIzDOqeors2RTmlcEwXpdsZEwbn1razO15FLneUCVmkzchRyLZz0f4MP0hnean8OUMjvVQHffy2DHq7ZO+RQ/P9MhOJROJ3wrwXfbQgFhEijPFNE60UgSEI6pLu+jQV10bYKSpumpmqxRViK4dKC0i3zTGsZuh3lxEFB6i6q8gMSRa6D9M3NMQtxjVM9d9Db0sHt/39u4mSYZ5EIpGY/6IvEGgZQRDjK4tICgIJui7pDaYoWWki06ZsO9TnDM6Uu9GFkGG3g0lnhN78GRDvZWLgEp68TfDDrMtLglt56Oh61OJxqm0ZzGgJ//Xxv5nvl5pIJBLzbt6LPggiGSPCGE+ZhAoiGWFWDXrCcWZUHs/U1E0wi4qcOYGa9tjJGjItQ8zJgHQcMpVqZ+2RHHeYOV5o/wLnYJEfWs9mZvB2FrcN4N5V45aN9833i00kEol5Nb9FX8coBFFzTL+uLHwRYmifXC1DzjjKuNdD1Z3Glj69hQ7GTFhWPMIOzqatfZwhOU1/+gxifw+T7edy1vaIe9Mez63ezsapc9GLihxqKeFksxz8j39h7+j0vL7kRCKRmE/zWvQFGokgEBo78KiLFJ6sYomYXD2DY04zWe+g7h4lJWLaKz2MG4qzo90cKA2QapvliD3FktazEGIfEwuv4NkPmXy1tZ03Wz/E3VfgBuN5iMW/oLdzJcRn8YN/fzEzFX8+X3YikUjMm3kf3pFIPCHIBWWqpPHNCpaEjJdBGHPM1vKE7iRZpXDCHo5Iiyvlg+iZkJ1qOXH6EHUB6UgzR4jl9dFyOGK/W+AZlbt5eGotcwOSrW0Pc0a+k47Dl/CJf38FZS+5734ikfj9M8/DO5r+iZi6EOSjElVShGYFRwicIEdgVKnWHGSqQNrKU061c7Rscaa1E2umzkPiPDo7hjhgHGVRbh062sbwkmt53oMWn+vo5q3OD0ntLvBF/pSuZfcy2WpjZwMWb2njg9f/JTU/+VzdRCLx+2Xeh3dAUJeSfFhpFH2jgiUVSrRQEIKO2ixeWqGcHCXXJpw1qKkai2aO8FB8IV09IxyyJ1nUso7I38lEfgVLD9nMzkSM2Ed5dv12xo+0sLH1HKb772BB5zmUsmmW3X2Qf/7k+5LCn0gkfq/M+54+CIJYkImrVOI0sVnFkSZ1O0+prhiojlNMp4ktm6oZ0zWpGFeKi9hGcdpg2Ggnco5QjOt0mX2EwW5GFj6Z6zbYXN/Vx9+436H1wCTfCV5Cy7KDbMxv4ez29RTSZ7Lo7nt433++n2I1mNdfQyKRSPy/Mu9j+iCIIkGOCuUwjTaqWMqlZjnU6gYD3lFm7DwVI8CgQv9sNzNKcbnahpqss5GL6OoeZo8zzuqui1FiGyMDV7JuZ0xhJuAhu8Kr9Y9hT53PGa9ncOWdbM1MszbbSs1+CoMP3MIHrv8bxoq1+f5FJBKJxP+5eR/e0QJ0KMiJKtXQRVl1DMOlbllEVcVAOMG47mXOHSMrY1q8BRw2DdabW8lNVbhfXkVP7xEOyDHysgdVr1D3RxldcBWv3JDiQz39/Kn1Y/pHDrN9cjkbW85ELr6DUmsLCxwPKV7A4IN38fHr/4zNh2bm89eRSCQS/+fmd09fSkAQh4IsVWqhi2nWkYaNZ0iMqqRLTHKkPkA9PUpOmXjOAMM1m1Ej4mxvK0cLaQ7JdlK5IQ6po6zqvAhTPcjQ4mtZu83DHfb4WkuGj6S/QGZHgW9Er0QtnOFg191kO1eSN0eR6qUseHg7P/vyH/HN+/ejdXLLhkQi8cQ0r0VfmgYgIGrs6ddDB9PwQFn4StNWgow5wdFKJ6QmyVgtzGZaCadMKlJyrdqMOV5jg3wKCxYcYXdmgsWZ9fhzw9S9KUZWPJM/uzPDZ/NZBnmEZwe/wNhV4WPyr1m0+kE25h5gSc+lpOV+sF5K36YqI7e+iL/98s8o1pJx/kQi8cQzv3v6QqAFEDbG9P3AQJk+sVJoXaWtnMU0pyhV0qhUFeXmKduCRWMSX8NTrIdwxmvczeWk84eZjkaZjEqsaL8A09jIob6raRnVXLgD3jewhPe5X6NjZIiJ4QyfN1/H6jNv447sRtb0PgVX7aHU8hIW39lDduhN/MO//xsPHEyGexKJxBPL/I7pi0YTRCTIihoE4FuKWEmIy7TU8oRmGaPiUc1YRJZDpKdZONXFhKk4YhZZ6+2kNC3YyHkMDh5me36MVW0XUSscIPCHOHLOH/OaOww2e3VuTht8IfdJ0rtn2TB3Fj9xnsmKtbdxS/pBzux5Gnmxi+Hea1l/2/lYtc9zx5dew3u+t5lSPdnrTyQSTwzzvqcPIH3IUYEgxjNN6iLEJCTjtTBuShaWRymk08ypOmnqZP2FbFc2ByybF1v3kJuoc6f5IgYG93DIG6IceqzpuRRD3c8RexX1uJ233dPKBzraaYl28U7ru7Q+PMv3vOeyMbOW5Wtv45bUFtb3Po0eOczewfVcvOW5BEd207f3Ot7xoU9w07axZKw/kUic9uZ5T1+ghUDFkBYVRBhTN22qwsOVgGxjMjJYUhtiVPVTdEZpNU2K+UXMFGzsSPN0437UaJFHagOM4dLdM8QjrSOszF6IX5xEqb3su/gtrNk0w5oDMX+5eBUvi7/HZf5GOrYW+Fz8eg7ku1i27lZudDeytPsKlpoeB9oCBstvIHd7nqzxHxz4zp/y2k/ezLaR4nz+yhKJROK38jswvCMwQ3BVHYKYmmFTEx6OlNSdduaqJkuiUQ4Gi6jnDtNqdTKT7aB3VDJY93nYCrg03ow1VuNW8zqWLTvA7uphilGF8xc9k6h2JzNVwehZL+bPbzbZP1fkowPLud7+OAMze2jdOcdHxV9xIN/JyjNv56bURto7z+T8luXMGJuZ7Xkj1/70XIamD3B+9Y18+z//mr/81maGZ6vz+atLJBKJ38g8n7IpOFb0bVVFBJqyyFI3SrjKourkCcoGi8UYR6qD2JlpbLedqhmwaijNvpTJ3dkWXp25j/xojdvCC5gTZbp7RnmofZRBsRwzVLipTexvuww/yvH+27r4klHn5/lWvpP7MKmRYVp3VfiIeCf7sx2sP+fn/CJ9P6V8jqt6ngn+rWxf8iTOHXoZrbe0MObexrkH/ph/+dAHeNd3H06KfyKROK38DgzvgBmBKWoQxJTJElhzuCpL1UnRMgetxiizlTwqUyWwHeJwmK7KYh4wHbQXsDzcRMvcEYKpgFvNl3HGGTvZXzrMuFHkyhXXURjbiBBj7Lr0HXTsmOKND3fzNy0O+4w6P2n/COLwGG17qnxE/DWPpFZw3gW38nB2Mw9nprl68GX0imGGMmPM9P0FL7nlAsYeAdXxVS7d9TLe96EP8RffeoidY3Pz+atMJBKJUzLvRf/Ynr7AwwgCSmQJrRIpI0PNVHQVNMKZQpYCCtk0M6pCXnhUMkuZmbG55miVH2YzvN69le7hGjfHV1KmxKJFY9yX3Y9bdlnZ9yQi72ZmyyEHr3o7V9w0xtWHc7ylr49qOMxN7R8mPjhOx64KH4vfwi3WUznvgp8z3baJm9PbWdV9NRe0rsX3f8zWJefQHv0Zz//2Au4ejsl2fZGn7P1jPvUf/8TLP30Xt+2aSD6PN5FI/M6a97N3NAIrhLoQtIRlymTBrGCpNKGo01V0KZp1cnMFJuxOZsxJOuw2Jlv6WToEpDTfa+vkBeJ2/IlpqtMBN1mvY+GihyjUJ9jZfpQz81dALSCTu5fDwQBT572AV32nwIIJwesWr0D7B7il86NEh8cY2DHHV/wX8GXzzaxYdyf5xfdyg/sA5VyWpw++gm4OM21uZuuq13DeyEv4g2908/OJmLjn27x8+pXc/+W/41kf+AEf/fleRgvJ/XwSicTvlvnd05cCpMSMNJ6QtIQlSuSwrBrCdNHxHB3ldg6aJmtKBzisF1HPH6TD6adsx6wZSrMxa7NuuMgWM+RP3DsZGK7z4/BiJmKDM888wiZvD6WwzlPXvprpIw+RbdnLttxVlPvP4m++rXGP1nj10lWI+h7u7PgA5ugRBh8pcnP5XP7Z+gRm3xDnnX8HD2Y3c3tmL+t7nsalXVdg1G/kSH6ObWvexuX7n8MLvtbO7Yccdnf/gjcab2bgjrfw1n+9nld9bgM/fmSUqp98aEsikZh/8372jpYKs7mnnw3LlHQGy6qBaaHjOZy4gxEMVulD7POWks5PYKTaiMNRWusr2ahdXjrp8fneBbzB+BGl0SnUjMeP3L8mndlAJjvL3Z37sAoWT1r1fGaGfortTvDw8lfiuT28/1sG5lSNVy1bQyma5LaW99NT3E/XxmmGp3L8nbqeHe4A51/wU+h5gO+5GxjLaK5d8GrWZruJK9/kQLvBtnXv4vzhF/D6L3eyc2uOr7Yf4eLuj/Ha0Vex45v/wB+87+u85esPcsv2cbwwuYd/IpGYH/N/a2UlsUKoSUFeVJgLW7DsGoHUyLhK1e2iUjJZJY4wMteHky0wY/ikKDDTtpLMsEE6U2dXuco+WebNmdvpOFDh1togO9TFnHXWI4wWRtnRN8kCfzmLes+kOn0DmjkeOe+tBDLPv3zbxpyp8bIFgxywYm5w/oFnWQ/BA5PkRkM+GL+VL9t/TfeSLZx7wT3sSD/ID7MPkm5ZyrMWv4GltiSofIWD7bDl7L9gSenl/NVX+mj/WYb/9AR7+3/B23N/yR/teT2/+Nq/cvX7vs/bvvkQN24dS672TSQS/0/N/4FcZWKGMCcleSpUwjSWVaUsPDIGVFPdpAqSReoQuhwxm88wLmfotFqZaunn7P2aO9tsXrdd8+m+pbxG/hB/aoreSZ8vqLdQiYY499wxHihsZzJf4/zstaSNPLF3A55X4aGL3kkQpfjA1wwWT1u8qjPPvZ2D/FP9/Xyk6yfMPHyUZTtK3FJazd+Zn2Of08Z55/+E7iUb+JmziZ9ndzLYcT7PXvwGltiCsPQVRnIFHjj79dD6Dl51x7m8/EtpNu1u5f25ClHfDbw39We8cOcb2PCNf+YZ7/sGf/zZDXzhnoMcmU5O/0wkEv+35vcum0qAYZwo+qJCNbAxbY+yqJMSFmW3k/5pDc4EZrHOQbWY2cwhutyFeExxxlgvtzopri2V2OCV2SVqvL/tRsJdRUYqgpvS78ZN3U5fX4Wfi4ep4HPN0lcQVesofoTn1Xn4kncRmK2884tlLp/u4k1WhU+tvIxnFr7C3f3XI8aHaN8wBUcF74//ks84H0B1HeDSy36G6NzCDfYG7s4eYGH7hTxnyZs5w80Rl77GrLGFrcsuZef6f+Sssefx91/p5vLvpbhxpJX3dJXQvT/ivfl38Bejb6Dw0/fy5x/6FFd84Ge887uP8KOHR5kue/P550kkEk9Axnz+cKkESBMrOrGnrwPwchaeqNNq5plVDn2TcGCtZOnsYfbqM1iWvxd35lLi2a2U8+sIJ8bxF87xwodsPnTJGXxx/4/4hH8xLYdSfPuM1ayyrmLNGXdy/4ancHv7Lq4dW80frH8zNzz472S6fkyt/iy2nPsOztr9GV796QdZ+dI1fHRgO4+su4L379rI7emdfNB8PZ/cuJ6VC3Lcu3iQDalP8WLjZ1yx5HMsXtzBnj2r+X59mEVOH+vj9axpu4QjtV3smLybehhzsHM1R/rfQi6qc82OO7nuzs3s74UfL0/xyHKfM4y7uK56M+fXFTu3ruHWLet4f7SOlp5FXLKsg4uWtHPOghbaM/Z8/skSicRpTszXTcTOO+88/RfPuR7jwFaiqY+x99oKHeMX8d5Vb+I9PX+Pf+e1rDqq2Oa5LN//Je590RjF0Zfys4uv4O/LH6Bt658yMnQ7IrqAcvhvtF5Y5OKbM7zsOSZ/71dZrRdy2cTbaLuwF7/T4L3BG+gwOrjttrNY2r2Uyw8vhi6DGzZ/mHR7B8J8HlFgc27157h3fZepp57D287eTlu6jfcVPS4Y2ca+7qfxqrHncTTO07umnV1dJj12zAv4Lhf630axgH17lzE21k1/qoeVcz0sDNuZkzNsH7uL0ep+zMwC4ngF0lpGmzdO59D9dE4+xHhXlbuXRWxeJsjkYy6qVriwXqc/aGWTv4L7wpU8oFdhti/inAWtnLuwMS3vyiClmJe/YSKR+H9PCLFZa33eb/r187ynL9HSwIkN5kybpVQQfkRBtKKcWdLGUnR1gkzQxW45w9PlPr5TfBZRu8+QnKTPXcjeUHPuI+38x+WapywRvHpTjg8+Jcf39z7IX7XeySe2XkPpgna+0PZh3lT+Y5785C5uu03iLnO4YG8fz7vg7fxw88cwM9/CbXk+9wdXsf5FK2j/9j/xhaGlfPAZPq+2Jrlu/TX8+fZbucO5l69nX8m7H76AgbyLuaKF61texE/s5/IC/XXOWv5jlp/RxdCRVdxW6yWTzrE67Ofc7mdykaEYqu1m99ENzHm3MZteytTCM9m97Hm0htNctv9envvAdiJzhi0LM3xpcYadiyRL1R4urG7hj2t1eustbNq5knsfXs5X46WMWotYu6CDtf151vblWdufY0FbqnnhWyKRSDzavA/vxErhRJKiYdIiqwgvpkArreYcrtNKXNhF3e0hmNvHerkHWfDZ07uCbPYgZ5cvYPfUQ5RaziY1civTA9M86TuC766WfGTxOt51+Ev8KFxFebfNhrU5+nIf4QWlP+Oyy5/GXXfuQiwXnL+vl+ec+ef8dNenKIx8kZ7lf8jDQ/0svO4/WHzje3nnJ0o8+Ifn8U96I3euPJt3VmOuO/gxnt23hn8JXspXH1jCss403tIs/5Z7OQvs63iWuJHzB7/OgoUOhcIaHt41zsZUnkWpXpbSxTX9r8C3fA4VtnJg5j4q9VsoppcyPbASufhppKSgd2ora+55iJaf7OZoj8nGAcmHB3McHJAslvs5q/oIb/c81nia6dHFPHBoITdHS/lXvZQZu5+1fS2s7c+xtj/Pqt4cizvSmGr+T9ZKJBLz65SGd4QQTwM+CijgM1rrf/kftjsfuB/4Q631d37V9zzvvPP0u/7wvwj27aH7wL/zqesi3nokzfNb3sMfrL2FldsmuXLs+dw6dAOLi33csfQ7/EnnFC+MP826Sw7w1P33sf7gS9ly+LukuYq4/EEmr67w3EfOYHLc4w0vnOGzM1WWyx4uHH8Hy9b2s7nf4k25h7m4+F7gedx1Z4Y1C1Zw4f5+jBabuye/z/CRHSw579mM7FtMttVi3dEbce65gfCc1fz7lWU22aNcmT+Dvzy8m8HZIY52Pom/Lr2AWwt99Hek0EtzHMhL2kx4hrmFC2ufpk1PEserOXhwkLHRdhwzzXKjn4WzLXTpPL7lcai4nUMzD1Pwp3BzA0TxAhALkaqL1ugoubGHaZ3ZQ27uANNdiof7fLYPaHYNCrIZg3XVCqvrNVb7PgtDizGxmC1eP9ujQXbGCzgoBxnoaGN5d4YV3VmWd2dZ0ZNlQVsKlQwPJRKnjf/z4R0hhAKuB64BhoGNQogfaq13/JLtPgDcfKo/XCqBlgorEhQFtMoqVqAp0IbjHKQqAhzhU8oOsGRcs3tQsX5qL1v9M3lxy3cZltP0u4s5rDUX7u7i3WqSV/ceorKxnT/c3sLfntPGt/Zu5Rv93+Z52/6I9U4v13MmTu5tnDP371xx5fO54/Zd1Bf5XDqyhEtSz2bPWQvYsvEGepavIwifzL3WNay47mL6fvhP/OXWCsPPOZ9/WLaV57bZ/OGiZ/Ga3ffy2fpfMLLoat4/9zRu3NDPwlaH9NI8X82fzdeMT3JJaorL/W+wcuktLF+WoVJdxb69wzxit5O1MyxWPSwIl/JU9xwiM2IyHGLf+INM1B4gtmyK7gKmunsRfecjZQutepql449w7l27yM0dxMvE7OvNsKPL4qd9cKBH0GWXWFXdzNr63bzI9znDj6hW+9ixfwFbtvfzTb2AvXqAKdXJ4s4cSzrSLD42daZZ0pGmJWX9795NiUTid96pDO9cAOzTWh8AEEJ8A3gOsOMx270F+C5w/qn+cKkEWijMUDOHJk8F5ccURAeOU6YkamRllpLTxtK9intsm3PkXu4pXky9XTJhjvDkzHIOTm/laNdFnL3jR9y7qEz75c/hebf8jHv74F0rLuA/dv6Ef+xfwt9tfhJnXtrPv3MJ78xr1hY/zNVXP5PbbjtIqb3MNf56lk+to+/qM7jpzv/EdI4wsPqF7N6TZ/ypH2RN5R4GvvMFPtfXw13PGOTj8UN8t7+Tl6cu5OV77uUTtVuZHryIj3rP4kubFtNqGSxa1sq2zjbuct5Mn/VGrjS3cQ5fZt36B5Cym1JpBfv3DfGI1UrKTrHQ6qavmOPC7mdjSkXZnGOkuIeh2g5mK7dhOFnm3AVMd/RC91kI2UZWVsjNHeLyfTt41paDZMqjzHUq9vZk2dFpcVMXHO4SuCmD5cERllW38Ww/YLkfsCAUFMr97JvrZduubu6I+vic7uOA7sFJZZtBkGFJZ5qF7SkGW1MMtqVoTZnJcYNE4jR0KkW/Hxg6aX0YuPDkDYQQ/cDzgKv4FUVfCPFa4LUACxYsQEhJLBVGqJkjJKXLaC+iKLtwU1WKokrOamcmnqWj3M4WI+ZtcjdyymNb5zoG2w4ha+dgxsOM9jyfp225kU+sy/Pvmbs50H8x77tpB6950QifXXourzlwPYc7W/nCvYI1l/TxAS7l7a1pzpr9R6699sncfrviBnU/1yw9n459Ni+84K+4e+g77NvwWQbXXkSteiH31s9n4SsuYvGmz3HJZx7g0uWL+enTOvhksIUvD/Ty4uxlXLd/M++d+1v+unclP7afwT/tXkdth83qviwMpPlGZi1fMz/IKsfjMnk/6/XXWH/mFFK2U62u4NDBYXaVWxGuQV+miwG/jR5/BWf0nYdQUDIKDBd2M1x5hELl5yjLoZYeoJLuJlx0AVI9G6UscrpA6/Rertm+h8yGEdLVMbysZrTbYXcb/Kwj5rNdgpFu6DEEy4Ihlla2c1UQ8CdBwIIgBNXJcLGffVOd7Hy4nUd0F0d0N0d0F1gZBttSDLSmGGxzj4fBseW0Pa+HixKJxP/gVP5n/rLducceCPgI8Fda6+hX7f1prT8FfAoaY/pSCTQSFcTEQBxX0J7HTNxOOl1lzKix1GxHVyappAaxClMsM3fjTJbZsuJ8zmr/CgcnjrIgtYID4RhKrkRNbGcqt5/CGS8je/tW/m5DP+++ZITBgVW8a+xfmWv/B753D6y/tJ8PFs7mta0f4fLZt3L5FSt45OFLuWH4dp607lxW72nl0tRzmXryxfziri9gWFtZcOYfMLyvj+HeV7L8guvovfXjPO0/NvK0dSv52RU5Phs+yJc7XP5g6TN52dghXjT277wgnWF7x9P5aOESfv5AF1lDsnRxC8Uum0+lLgd5BWvdOhfIh1ijv83KVfciRIo4Xs7ERCcPHs7i2Rkc06bf7aSnnqcntZZV7oWgoGqWOVo9wtDkTqbrm/DiOm6um7LZw0y+FZ27Aqm6kNImIytkqqOsndjDRXsOkymPYEQl5roUo22KfXnNz1s1I+2C0W5QjsGiuMACb4yF9QrnBCELgoCFQYhQecZrPRyudLPrQAc7wg5uirsYpYNx3UounaI379Cbd+lrcejJO/TlXXrzDn0tLt05B8tIDiwnEv+vnUrRHwYGT1ofAEYfs815wDeaBb8DeIYQItRa3/CrvrFqDu+o5h0oi0rSpksMe/1Iq0JRVWlLL0aX76OUXcDykS3sHYxZP7uXDd7F2G1T7FMjXJtfz77xnzA8cDnP2rSTzz2thXfMfYF7rvx71t/817y2vZ93rZmko62ffyn8I7T/Ld+7W/Cki/v4FIMcbfsqzy+8idVrbqC///nct3kzQ339XBasov1QOy9+0t+w6ehN7L3vG7T1L6C1/6ns3pdj/6q3s+LKIp23/SfXfHwX1y5bzIar+/hE/BDfdzzOPutqXuTBU/f8kM9E36bWu5I73Kv50NB6RvZm6XAMFizIU+yw+FzqQlAXscQJOc84wErvFhb33EFPT4BS/dRqixkbG+GB0TSB7ZKyXHrcdrqCHB1BHxd3r8RAETghxXiSicJBxst7Kfj34mkfO91Gzemh4rQT9K5CDl4BIoNtRGSjWdzSKGcPH+DSXaOkqhM49Rm8nGCyy+JIi2JfXrGhFSZaBEe7IGVZ9OmQfv8g/bVHOC8IeE4Y0h+G9IYxvmxnstLJcKmdgwfbOBC0slm3M6o7GNHtzJGmI+PQ1+IcD4eunE1X1qEza9PVnFpTVnIdQiLxODqVor8RWC6EWAyMAC8B/ujkDbTWi48tCyG+APz41xV8AKEEWkikFyBixZyUdIoiQ75mxspRk7OkjLMRTFFuv5K1w4LNyx0uk1vZMH0BuwbWkm4bIvbPJidipnO9XLS3nS97U1SzhzDmdnLgyrdx9Q8+xHCuhzcvrPBJuvmX2feS7no3n7sr5soL+rhBW+zPfI4/i95PKv0pnnrtc7jrTpNv+eNcvP5cztgjOSd6MmuvuZI7H/ka+x/4DP0r12NlLmXb/gzm2ney7Joq3fd8kfP/6x6+2NHO0JPP4nNLh3mXGOEDy5bzrPRinjU5xLVD13OtkMwsvIjb5JP4xJEVjOzJ0GYpFi3IU2u3uCG1DN86A0e9mXOdIuv0gyyNb2TBwrtZuBCkHKBWG+Do0Ra2jKTxzRTSknRm2ugWLXSUUwykz2J16kmAIHJCShSYLA0xNr2XWW8zXlxFmQ4q3UXRaGM63ULknImQVyFkDkNq0rJCujZJ//RBlh45TKo2iVubwgyr1Fpgps1gPK84lIG78jETLYKJViikoUNa9OuAfv8IfbXtrA18rg4juqOQnjAiJRwKqpPJcjtjxTyH/TxDYZ6HdStHdSsTupVJWtDSpCNjNwPBpjNr05l1jodCZ9amK+fQmbGTnkMicQp+bdHXWodCiDfTOCtHAZ/TWm8XQry++fwnf9MfLpUgFgoA14eilHSIIsKLOJrpxnZK1MoRRugzl+3i3B2KbzsZ/l5t46PjFTb1XsSLur7HnslRFmXXs7XyIEODV/GCe7/Nx69q452lz3DDzMdIn/tSXvnN71D/4w5e11vik3KQd0/+A4OL/5L3PABXruli44Dgr8y/5W1td7N45kNcdvkZjI09hbseeYDdnV1cklpL+27BNR0vZ25tkds3fJlq+RH6zliPk7+YXftT7B58HYsv0fQduIX+7/yQd0tJcMnZ3LYOvupt46tGyKK1F/FM1cYzR3bxool/44UIioPncpfxJD4zvood+1qQwIruDLneNIeyOe5xrgB5JW2mZr01y0q2soif0z/4AIODMUp1EIYLKBZaGR612Eae2DaxDJOOVCvt5GirubRZy1jacyYKSWTF1I0qc/4Uk3PDTJX3UfSn8eMa0jAxst3UZQcVJ4/f3o/oXIOQLQjpYKqINBVcb5rW4ig9+w7j1qZw65PYXgFtSiptBjN5xXgGhlMZ9uVipnIwnRVM5UCaim5h0B0V6Q4m6a6XWRUEXBlFdIchXVFEaxRTN1spyA4my62MzbUwHOQY9tPs03mmdJ5pckzqPHOkyTom7WmLtrRFW9qmPW3RnmmsN+aPfsw21G/61k0kTlvzehuGD/zZlzmyeYSLbn4Lb3yj4p31KW4pvIJvrHo2r+j/Mv07a5w58mwOj97BjHE+Fz74Rd593TifK4/z9Nr1FK9YwMfln7L1vufwvOoV3DT0aaz0y3jSA+/n7a+u8vHyOENTV7Gv+jrOnLmJjj0/5xMvb2dD1xwf8lNcfuRB7h98DS/d92QWdWaJzmpjj4h4bmud55fehQqOkE49iw0bepmdrXHGwmWc7y3FPRQi8xYzbVPcvembVOZm6F66kkz7BYwf6iAKoKPXZmG4m/ytX4CZSWRbK5OXrOQnK8r82NgBQnBGdgFXyzxXj+/njPFdCMDLL2Fn5kJ+VFnN1yYGqWkLx5QM9mYxOhzG0pJxR4AU5BSss4ssF/sZ9B9gwL+PDGVAouQAvt9PoZBjfMKgWMgQRRZSStpTLXSoPPnAJVe2aAlcMtpFIohNjWfWmAunmSoOM1UcohTMUg2LaDSmncZKtSONFuI4R+BlQeQRMg8ihZSQUh5uVMKuTWPNjWPPjmDXZ3G8GWyvgBF5eDmHUovNTF4ylgkYcepMZ2JmMlDICGYy4NmCVmnRqQXtUUSnX6fDq9IRhXSEEZ1RTEcU0RFF2CgqRisF2coMOSbjHKNRjlE/zUTcCIdpnWNWZ5klQx2bjG0cD4TWlEWLa5JPmbS4Fi0pk5aUSd41aWk+15IyyTpmcl1DYl79tufpz2vR/+D/9xUObhzhSTe/mb94teKVcob9s8/mPxf+Edcs/QWXHNlC+97nY0wOs9e3WDV0gJ+uu5PLBma5Y+YVfHvtH/CGnv+ibZdm5cgzKU9s52DosvRogdH0jWy6SvOvQ9N8v/IGav4lnHX0R7Ttv52vvrSHH/WO8Q57EdftvJ3p/qt4wejLmIzSnHN+H7elI7ptg9en72PpzL9imW1E0TO4715FEMSsW7KKdbP9uKMxMmNS7CiyYfv3mT46TKa1nZ7ll1EqLKY4KTBtxWBPSPfIfTh3fAcReMj+XkbOHeRni0vc6O4lFtCf6uZSq5NL5ma44MjDpIMa2nCYbjuHh9VafjS3hJ9M9xFg4FqK/u40RqvDVFoy4gi01RjaGLQiVhpTLNG76PPupT/ahksdACm7iKJeyqU8U1MO09MutVoGkBhK0ermaVVZ8mGKXMWkxXPJ6RQKiRYQ2RF1WaUczDJbHmeqMEw5mKEcFoh1hDRMbLcVaeYRMksUZgiDFEJkQeYQMoMQCktFuKKGExSxK5NYs6OY5Ulsv4jtFbH8IkZYI7YNqnmHUtZgJqM5mgoZc+vMpPXxcCimoOKCK006hEFbLGiNQtoCj1avSksY0BY3eg2tUURbFNMaxyhhUVV5SjJLgRwzOsN0lGYiTDMRpprhkGVWZ5glw6zOUsZFCEHOaQRAIyROBMJj1/OuSc41yTkmWccgZankNNfEb+20Lvr/9vavsvf+ES65+U383csU1+aqZIoX857WP2XlukO8fParFLc+j7XFLPfPbKG7vpR68Fnuf3KNZ43186b8X7Js/SivK/4no1ufw5Or6/nJ2JfJZl7Gxfe+l795eY236ymsQ/3sMl+M75/H+rnbaH/wBu54yUquX7iHF+RX89dbb8Nw2/mX1Nv59JE+1i5sYW5Vjj064pIsvFx/hkzppzjOIkqla9j4gE8ca9YuXsXaSj/pwzHCkgQDsH3sTnbtuAchJb3L12On1zE11klQBzdjsKClRMeRu7HuuxER+MiOdqbOX8q9izx+kNtPUdYxpMFZmYVcEhk8aWqYleM7UYA2XKZaz+QRtZZbK4v4yXQvxdgFoLfNpa0zRZA1GbNh0hHQHOMesCKWGkUWcJjecCvd3ka6GEOiEcJGyj6CoJ1KJcvsjMXUlEGtliOOG6N/OTdD3sySEy7ZwCFTNcl6NlntYmGggdiO8VWdWlSm5M1QrBxltjRONZyjGs4R6gAQWKk8ptOCUjlinSYMXKIwhZAZEGmETCOEgRIxjvJx4iqWX8SqTmMWJrAqk1he8XhAqKgOUuBlHSpZg1JKUkhppt2QSdtnNhVTTEExLZhLQTENvilwhaIVg1YErVFMWxjSGtRp8aq0RRH5OG5MUWOei2NMFHUjR0XlKIsMRZ2hoF1mohRTocPR0KWo08zpFEWdYY5UY50UZVyUlOQc43gQ5FzjeCA01s1HPZ89ttx8PG0ZyUHtxOld9D/8l19j590jXHbLG/m3F1msHoi5YHYJbzD+nPwFEX/n/S3bHnghz62ezY+OfBon/Uou2PjXvPHNmlsOjXK+/0nmrlzIx8zXcWDTZVw9+xT2jP+cCQZYNFsgrP+A/3qh5Acjo3xz3znEnU+hVjmH1fpheu78NEeeupZ3nrWTpfkFfHBsjMVTB9mz6DpedvCpzEUWF57Ty72tUAOe31rjabV/w6k9iOsupzR3KRs3xoRhzOL+RaxTi+g8YCBCjey1mVBDbN52I8XZCZxMlp5l5xKzlMnhHDoSuBmD/tY67WObcO+9AVktgWkSrl3GvpVZft4zzZ32IRCCtJHirHQ/54SCc6ZHWDe+C1trNIJafhmH3VVs9BdzU6GfDdVeIhRCQFerS0ubQ5yzmHUlo5Ymthrj2CkJS606C+RRevVhOoOddASP0MUEkhgAKTuJ4y68egulcprZGUWxaFGvp9G6+X1sl7yVISfSZGObVN0iVVNkYoeMdjBobBebmsDw8ahS9gvMVacolCao+EVqUZl6VCbSjbO4TCeD6eSQRhYhMsRxijB0icNUIxRkCkQKIRRSaGwVYONhhRUsr4hRncUsTWFUprGCMpZfwgxKWH4ZqUMi26Ses6mlDcopwZyjmbVDpkyfghNScqHkQtkVlJ3Gct0CWyjywiCHJB9rcnFEPgzJBx55v3Y8HHJRTD6Ojq9nYg1IPCNDVWapyDQlMszpFLNxipkoxWToMBWlGoFBmjmdbs5TzJEmwEAKyDbDImufCI2ca5KxDbKOQcY2yByb2yfWs7ZJ2lZkHCM5lnGaO+3vshk36gvtscucLegX04TVkPG4FammKYVz6EhiROBHFULaGRiZ4JGU5MnBw/xwrJvbBp7KxT2b2VIe5MK2yzgy9k2Gul/BJRtup/fwLJ9tz/HqpQU+vesecv11dpSfRP1Zf8/Cn7yfL40s4m+fOstLWgz+rOcaXrrtK9yXu51PZd/Evz4Q05N3WHJ2F9+fdfiRfDcvbi9wRfU/cMzP8+SrFuL7l/HgllF+OHeIts421rQtZfFojs7ZLp7e+SdEZwoOzm3l4e0/I/Bux83m6Vp8JsJYxqHRPPvCizAuvZieLmivHSK383ZWfH0DK4G3tLdRWjXA3oUmd3VM83F3CO0IzCVLWJse4GyRYl25wJqJe/nj8g95OaAzLsWWVRw2l/JwMMidR7u5e18XdWwsoDVt0dbmYGQtqinFvVYfs84AmJeBAFPAQitgUBXoZ4zOaC8tcjudzjaWdRSbF20IpGxH63Z8P0+14lIomozNmtREmsB0OHZ5h2s55KwMGeWSiW1SgUU6ytLutDNor8fFRDY/yyc2NKEZ4tPoMVT8AqXKFIXaOPWwRDUq40UVdPMyEcNyMe0sPmlCmaasXGLHJZQZdLrzRDjIFEKYAJgqwhY+tq5hBhUMv0ymVqBlcpbl5RnMsIIZnJiMsILUMbGh8NOKesagmlKUXSg6moIdMm0phiyTigNlB6qOoJyGigM1G4SQ5KRJHoMcgmysycYlsuEs2cAjG9ToCQOWnxQS2Tg+PqW0JpQOdSNLXaapxilKdZdS1WVOu8xGDjORzXToMKFdytqlRIqydhu9DO1SxqVC4+9iKXk8GNK2QfbkoPilgdHY7thyxmmsp0yFkdzE77Qzr3v61//dt9j000M8+Rdv4kfP7WZ4neafDo+ybu4j1K/p43rxGvZvvpQrZ6/m4NgdjDPIytEDbOu/k6Pn1rlmvIfX2e/AvDDDh/Xr2fzAc3lO5XK2j9/CKF10+WmW7P8kb/0TxRenxmgPruMbu0ZI9yyhWr2KjlaDlbf/E044x03PH+SzfXs5M7+M94wNs/ToXgp9V/BX5Rdz89FWlnZnaF3Vxr1WiCElz26pcI33GTKVO1Aqg2Vewb59gxw4UEEIwbKBxZyhBug6ZKHqGpEyCDpDDs/tYOv22/C8Cqbt0LloNaazlMpcD+VCozClcwY9mQqtM7tI7bgd48iexh8rm6W+eiGHFrlsaC9we+oIZbPxIettVp41ThdrQlhTmmL10QN01ksIQAtJLbuIMWcpe1jIpno/dxY62O+3EjcLblvGorXFwcyY+ClFwRRMmJrINaA5pJCSmn4zoFfN0cVROuMh2oM9tIa76GAKg8aeuhA2UrQT6xYCP0Ot7lIumxQLgkrFxvPSRJHV3FaQslwyVoq0cEhpGzcySXkGTl2Rim3S2sbGRDSDJDY1kQrxhYcf16iGJar1IqXaDOXqDPWoSj2q4EVVYhq/H2XamHYWZaYQ0gXhoGOHOLYJQwu0A8JFSAch3MZy88wyU8VYIsDEw4pqGH4Z05tDVQsYpWkMbw4zrGEEVcywitGcpI7RAsKUje8a1F1FxZVUbCjZMUU7pGAGFK2IikNzEseXyw5ESqAQZIRBBkUOQUY3QyGKyIY+2cAnG9TJHA+NY4GhSTfXLUAj8FWaukpTk2lqIkWZFCXtMqcdCrHLbGQzE9rMRo3wqOBQ0U5j3lyu4uBhAgLbkI0AsBRpyyBlN+eWOv54YzJI24+Z/w/b24ZMjn38Cqf18M5//eN3uP+GA1xx559z/zMGuPXcKl/b/TBn1L9I+dJ+3pl6P8auLIvHryU7N8fW6hHaWM/CvR/m7a8KuW3/AS7zPs7wk1bwluxH6N5fIx66jMuqA/xo+Ou4uVdy1rYvsmnpLn52ueS7w6PMyg/yo723Q84mEk/DNNtZPfNzWh/4LuWL1/IPF40w6lR5SX41r991D7n6HIcXvIB3Tj6V+2fSLO/J0nZGC/e7MT5wRR6u4TYWFj+N0D6p1DrK5fVs22pTLAbYts2y7kUsjrrpGraQnkbYirBLM+EdYsf+u5meatzloq1/IdmOpcRxH4WpVoJ6IwQyeYPOdI383AHSe+/D2r0JgQYh0Av7mF3cwYFewabWAvekR/BU42/aYmY5w+lkuTZYXq+wfHaUZdNHSDX/5rFyqGQXctRawP64n61eFw+UO3ik1kENB2jU+7acTTZnY2UsAldRsgSThqZuy+PHDSTQacR0GTU6RZF2pmiNR2mJDpML9tPBUTKUjl/eLYSLEO3EcZ7Az1D3HKpVk1JJUi5JfD+F7zvHh5GUlKStFCnDwZU2rrZwYhM3MLA9AycwcLWJq21sjBMBYWgiIyIUPr6u40U16kGZqjdHuVagWi/ixzW8qIYXVwniEx9RqUwH006jjBTSaAQBuhEUUWQRBSZIGyEcEA5C2CBshGh0oA0ZY8oIkwBT1zGawWB4JVStGRq1OYzwWFjUmoFRQ0UeAogsgyBt46caoVG1BRVbUzFj5qyIOSNg1vCp2VBtTjVbHF+u2o3gMJBkpEEaRRpJRmvSWpOOItJRSDr0yQQe6dAnHcektSYTx43lWJPWjR5IKo4xgVgY+NLFUyk84VIXDlXhUtEOZe1Q1jZzcWMqhBaFyD4eHlUcytqlit2cNx4/tgOipHhUiBwPDUuRavYwXEvhmgqnuZyymsvHJuvENsfWHbOx3el+i/HTuuh/9gPf5+5v7+XyDe9iz+XdfOLCo9y6ZweXeR9m/zmrua7j25w/eYjawWu5uLSAnx75Asp9DZfd81f85as83hVOcvfc8/h09/MZOKPM3/C3bHzguTy7dikHJu9ij++Tcq/k8rvfzXuuCzkvXeetszAdf5z7pn7BaGkf+d6nUS4uYWFbhYU3/wsWdR561gr+dfF2Uk6W11v9vGjHL7C05sDAc/i76Wu4ZzpLd95hyap2trVIJnXMgK14Vvow51S/Qrq2ESEsXPcipqcXs2O7oFqNcByHxV0LGIza6RlzsarNwZJOkzlrlsPT29i77wH8oAZC0NqzgEz7EpD9lGbaqFcaxcR2Fe35mFw0SWZyL86e+zFH9zXKnKGIFw8wO5BnqFOwI1/hgdQYo24dhEAgGHA7WGbmWRzBonqFRcWjLJwZojUKjxdlP91PwR1gXPVyKOpkp9fOllILO+uNq2mPyTgGuayFnTYRrkHgKMomzJjg2QoMAc29Nkdous2QblWlXRRp0VPk4zEy4REy4RFamaGFwvEeA9A484c8cZwhCFJ4nkutZlGpGJTmJL5vEwQ2YWhzbEhJColrOaQMh5S0cbFxYhM7MrACieUpnMjAxsTRJjYmqllwtABtxEQqIhTB8aCoBWXqfolqrUi1XsKP6/hxDT+uE0R1Au0fb7M0TAwzhTJdpHIRshEGaJs4togiizg0TwSFPBYYDmAghEAIjaUiTEJMPMyojhFUUUEV5ZVR9RKqWkR5FYyohgqboRI152Ed2TxGEpuKwLUIXAPPUdQcSc2Ciq0pmzElK6JoBBTN4KTwENSsxrGMY/PQaPx+baFIC4OMUKS1JA2NYIhj0lGEGwWkooBU4JEKPVzdCIuU1rjNeSo+sexojQRC6eArF1+6+MKmLhxqONSxqGi7McUmpdhqTGFjuaZtqtjUsI8vV7Gpa6u5fKJnAmBI0QiMx4SC+5gwSVknwqKxnSRlGTiWwjEkttmYO83t7ePLEttorP9fHHg/rYv+Fz/8A27/6m4u2/lBJtakeMeF+9hy8BDX+X/D5lWXctHiPVxX/TIPb7yGl5Yu5obDH4P081i772c8uHwrB54keOuhMlcHH6J+RS/vst5LZr9B7fD5PC04k58c+Qyk/oCOuQkWDn+Jt71S8I/FadbVl+BX/5ER4xD37f0erQNrqFYuwXazrKhtpP32zyMW9PLDq7N8pXsfnW47r1ZdvHDn7VhxyGT/U/hE9Rq+MNqHYyrWL2+n0OPwiBGBEFyQgSvUFlaXv4AVjiClg22fy8z0IvbssZiba/xn7O/qZVGql965HLkxidSiUSQ7FHNyhqGZXezdvwHPrwKQ7egm27YAafTiee2UZ7No3QyClKItE5IPJ0kf3Y1z8CGskd2NHgFALou3oIup3hSHOmK2ZYs86E4y44bHi3LOTLPIamWRsFjoByyqzrGwOE5faYrsSe+T0MpTTg0yZfUySieHwzb21FrYXsmy32+lSJpj/8FStiKXtnBTJtJVxLaiZgrmFBQNiGwFtjzeBoBWFdOufNpllVYxR54ZWuIJstEIqXCInJ4mR5EU1ZNuDCWbAZFFx2mC0CXwbeqeSbWqqFYktbpJ4Dv/LSQALMPEMWwcZeNKCxsTOzaxQ4UdKCxfYcdGIySaQWGijvcoNBptaGIVE4qQEB9fe/hRjXpQoe6XqXmN0GgERnOK6oQnBYaQCsNKYZgu0mgEhhAOGps4NtGxRRQaaG0CNkJYjUARVjM4LIRo9r6ExlQRBiEmAUbsoaI6RlDD8CvIk8MjqGI8JjhUVEdFHlI3DrzFhiSyTULHxHcUviWp24KaqamamooZUTYiymZESTUCpG42g8MW1M0TAVK3wDM5/nd3hUFKKFwkKQQpDSkNro4bgRFFpKIQN/RJRT5uGJCK40cFihNr3GaIODrGjTVG86+sEYTKIZAuvrTxhYMnHOqiGRbYVLVNJbaak0k5NilFinJkUtcWdU5MnjZPrD/muWM9lsb7Sj4qDBxDYTfnJweF3QwKx2xue3y7E88f+5qrVnWfvkX/qx//ET//wk4uG/sc5bYKr7tyH784PMzH4tdzY/8zya0K+Bv/jdx154t4kXcJWyduZtrooJc+Fu68nte82uOWoSHeVnsHdy28kMWLCrxTv5sHNj6Xp9TOxy8dYPP0fVjZ17Bu22cY6t7Nx54d882RcWpcgFF6G0ZWcfver1Nhjlz3VZQKS2lvlSzd+22y228nOmMR37vS5ttt+2hzWnmJ1ceL9z9Ae2WGWvtabnafzgeG1jDmWQy2pxhY0sL+vOSI0phCcGEm5AL5CCsrXycd7AckrrOaen0ZQ0M5Dh6MAYFt2wy29dKnOuguZcgdlQjduAiLdknZmGOycoRDI1s5OnUQAKkULT2DpFoWgGjHq+Upz2TQNMbLlSHI5wRZVSFTG8c9ug9r/4PY00dOhEE6RdDfwVx3hok2ycGcz/bUDDtSs1SdE0UxZ6Tpt/IMCJu+KKbfq9BfmqF/boI+v4570vsoMlLU3B4KZjcTooORuJ1DYSt763n2VDKMxi2UcDmxZy7IpU0yaRPLNRGOIrIENUNSUZqC1ESWalyLcNKtFgyhaVMRrcqnRdTIiRJ5XSCjZ8jGR0lFY6SjMXLMkaOIhf+okJAyC6SJ4xRx7BKGFr5v4XsG9bqiWhXUapIwtAlCizCwiaITe4wCgW1aOIaNJU1s0QgDSxtYscKKFFYgMQOJFZvY2sDCwNLGL+ldaGIZEcmIUPsE2ieI6nhhDS+oUPMaoeGHdQLtEcSPno6d+dT4u9so00aZDkI6SNXsaWCitYWOTeLYJAoN4OTAOClEmj0OACU1hogwRIQixNDHAsRDBTVUUEP6FZRXQdbKKL/SeC5shIbRDI/GVEfGYfNYE0SOReSYBLbRDBKBZzYCom7G1ExNRUVUVURZBZSNEM/kpKmxrdcMEc9oLAcKEI3jIY4wcITCERIXgaNFMxiaIRFHOFGIE0U4kY8b+rhRiKPjRwdJ3AyTR62f6Kkcf/8Lg1A6hNIikDaBsPGFhdc4x6wZDiY1bVHTJrXYpBKbVLVFOTIoxwbV+DFBoy28Rp+PW/7ljadv0f/mp27kpk9t4/L6D4lKe/njZx/hWyPjbDNfxL8aL2Lq7Dyfiv+QBzc/g/PKl5ILfDZO3QnGi7nkznfw3pf4XNMasW68hZfGf4t3ZS/vEu+hdSRiYvf5PD++jLvHvsWMTiGda7j8/vfwrctrbDkv4OtHxnhIXIEVv5KFXjtH5B427P0h6Y5ehHkZfr2X7raQhQ99lcyBB4iWDnLrJRk+37MHaVo8M3cGLxw7wPrx3WA4DHVfzRerl/D5sQXESBZ1ZWhbkOVIi2JYaQRwZlpznnGQFf6t9FRvQRJjGG0otYa5YjdDQw5jYwACx3Hoa+2mS7bQXk7ROm3ihI0xfuEowlxMiRnGiwc5PLyVQnn8+O823dpJurUP0+4i1u3Uyllq5dTxA5OGKchnIS0rpLxpnNlhrLG9WEM7Mf25E4WxJYfX00qpzWW6RTKSDTiUqrDbnmUk4+ObJ0pom5Wjx8jQJSy6Y01P4NNVK9FdnqGrMkV3GB0/lgCN4wl1p5Oy2cGsbOUorYxGeQ57WQ56WfbXsxzVLRRJc/J/KcdUpFMGjmtiOgphKyJT4pmCqoKS1HiGRJsSLHn8IDSAJTR5FZGTAVlRJ0uFNBUyFEnFBVLxNKl4EjeeIkOJDGUylLAITnrnSoTIAGl07BLFLlFoE4Qmvm/ge4q6J6nXBL6vCEPrpMmEk16LIQ1sw8JWFrYwsI6FRtwMjbAxmYHEboaFeXyuUMgTPQ2h0UoTqZhIhEQEjeCIPfywhhfWqPvNHke91AiW2CeMPQLtE8aNKW6erosQzfBwkMpCKhspLRAmCAswG+GhDXRkEEcmjf3qxjaN8LAaZ001tz/WAxFoDBUfDxJD+6jYPxEUoYcMaii/ESayXkX61ePbyOjY9s2viXxkc/3YzoyWgsg2iWyD0FIEliSwJL4l8cxmD8TQ1E1NxWiESsWIqKiAutL4JvgGzbloLB9fbwRMYIAWJ4a8bKFwhMJGYiOaE9gabK1x4hhLxzhRjBU3QsaOA+wwwI587DhubKc11mPm9rEp1nT8feH0Lfrf+fxN/OT6R7jcuQf1yM/5w1fM8PFiRFav47qZVzF7RTcf4K3oI4sxpi7lsuJSvrPnQ1i5P2HN0K3Mtj/Cfz4j4Kd7d/IC7308smgNXYsC/lH9GQ9teTpLp1eyQvdx65EvIFJXYUZtXLrxn/nw8yTFpQFfHhrjF1zObOY5nD+5ADfl8PDM7ewZ20D7wGr88FwCr5OetpCBPT8iu+1WRGcbOy7u49MLDzCS9lic6uV5ZHjWwc10VgtEqQ72tF7Jt8pn8eWJBYQYDLan6OjPMtmi2G833pA5JTg/VWYdj7Cs9lNagu0IwDBakHIFpbkexsdTDA2J4wczW3Mt9KQ76CRPW9khN21gNS+gwpbEGU1VlZmtTzA+vZ/hsZ34Ua3xh5aSTGsnTrYLZTYOoPpelno5g25eaQpgWoJsKiYtKrj1aZy5UazJwxhj+3DKk8fHiQF0Sw6vK0+pzWG6RTKeCRlxahy2Sgw5VQqZxkHEY7KGS7eRoVvadGlJZxjS7tfoqJVor8425lFEWuvjwaOFwrfbqJmtlFULsyLPtM4xEWcYDTIMeWkO11NM6yzTOv+oHgSAbSpSroFlKwxbIS2FNiWhKfANQV1BWUJgSLQpwJSgThyHgMaxiJyKyEm/ERaiSooKKV3C1UWceAYnmsWJpxuP03yeCg515KPuRO4gRAqtXbR2iCKbMDQJAxM/MPA8Rb3eCI0wMglDi6gZGGFoHX8vQOPYhW2YWMrCkiaWOBYKClMbmLHCDOXx6VhYnFJ4yIhYRESEhDogjJsBEjVDJKji+VW8oNp8rhEagfZOrJ80bAUgDasRJIaNVDZCWgh5UohoEx0bzSBRRJFCYDaDxmyedmuCMJph0lg/FibQ6JUoETd7JY2eiYqDRkjEHjJsBIv0a82piqxXjvdKZOQj4wAVB81wCZBx87EoQMbBiV4yjeMlkWUQmYrQlISWJDQkviUIjEZgeIbGMzR1pakbMfVmz6UmI2pG/Kgw8Ztfc/J6cNI8krDtVdtP36L/g6/+jBs+/CCXd+/C+MGnefH/F/DXop1rZkLOn3gX9St6eH36G1xUO8CDm87jutLF3Dr6FfzcGeTlctbf9re89g3wtqBGemYRrw3ehndFD6+WX+D84gYe2vZ0nu2dx2z9EA+P34yZfTnZwjDrd36e914H2c6Iz4yMcH/qXO72ruZcYxkrC93EmZiNIzcyPLOL1r6VRPE5ePVuWvKCBYWNtN77TYzYo3TeGdyyJuR7HQcJDcm5mYVc44Vcc/gROr0ysd3C/rbLuNE/iy+PL2QqSpG2FUsG8tBuc8QVTNiAEHSagjPtEivEbhbW76DHvw9FjBAGprmQMBygWGxjdMRkctJE68YbPZ/JNW6qJnK0ei65gkm2biOPFb6UJHRDaqJMsT7NVHGIsaP7KNWnjp/vbjouqXwnVqoN1bynju+lqJddNNnjZ6MAuK4gbYe4VHH8AnZpAmv6CMbofuzyBEZYO1FyhSBuyeG3Zai22BRzisl0zHjK54hd4Yg1x2xKM5dqBOExjjRpN9K0S5t2FB0xtIchHUGdtnqZllqR1nqZluaVs+ZJ76tYWvh2K1WzjYrMMScyFHSG6TjNZJRiIkgx6jmM+S4FGs8VSROedMmKFODaBratMG2FMhXCbIRCqAS+EnhKUJON/4zabAw7NeaPDgyBJiNjsjIkLQPSeKRFjRQVXF0hpedwdQEnnsWOp0np0mOCo4o6tvcNgIHAReOgtUMcW8SR2QwIkyBQBIHC9yT1OgShQRSaRFFjCk9aPvnAt2WY2CeHhzAwtcLUCiOWmLHCiCRGKDBC2XicZrigGpNWmBjNCGmGiNLEMm5MIiLSESFBs2cREEQeQVjHD+v4fhUvqB1/LtQBkT6x3Jj7RHFwokdC4ziIMiykYSOViTweJicFBaoRKtogjg3iSBHH6qQgMZvv82OhYgAGNOcnn0IqhUbJGCViFDGKCEmIikOkDpoB4TcCJGwEjQzqCL+G9JphEx8LlAAZNUJJ/k/r+sRr1VKwZufO07fo/+Tbt/GdD2zisuUTmJ9+L699R5o/yPby9j2bWFb+FOYF3VzSe5iX1/+ZO+74A54VnEcgpnhw4i5ieR0XbfxHNlwac9OFATfs3c4LvX9gc886zDUu/ybfxNSe5UyNnM2LgyexZeYWDld3Yaf+lJ6xuxkYupH3XReSbTP4/PAhDg8M8oPJqzHo5+xgMcsqnYTZiAdHf86hqUfIdQ6i7LOplhdiWhb97jQdD91A7shmRDrF2HkL+enSErd0jqGl5OzsQq7y4dLhrSwpz4KQFNvWs1mdzXeLy7m5OEiEIusY9PVmke1242ZqFiAFKSlY7XgsU2MsiLbTW7+Ljmjv8VsnmMYigrCLcjnP1JTN+JjE9xunWZqGSVu2hRYzS4tOkfMcMnMmuXpjJBkACToj8EyPalxkrjbNTGmMyenDlOrTJ8aIhSCVa8PJtGPYLQiZJY7TBJ6DV3WJ41TzLJTm+K8C1wVXBTi6ih3MYVanMYsTmFPDGNPD2H4RIzpxaiRCEOczBPk09ZxNOWNQTMO0GzHheoxZVUbMCrPpRkCc3HsAyCqXVuXQIk1ataQl1rSGAS2hT6tfo8Wr0FqboyUKaY0a57A/9prU0EjjmXmqRo6KzFESGQpkmYnTTEcppkKXo4HNhGczGzcufprTKUqkHhUYAnBshWM3ehfKlEjjWCgIQikIFPjN0KgJ0Eajh6GNZmg8pqfhipisikiLgJTwcYWHS70RvLqCo8vYuoQTz2HFBRw9h0MNl+qJ7ag95pgGgAPN8NCxTRSfCIYwMJoBIvF9ge+LZlgYzamxHMfG8ceODV1JITGVgSkNLGk2AoRmSGCcCJJIYsSyGSYSEwODE4FioDC0PL6sThoa00KjZTNQRDNQiIh0MyC0Txj5jVCJPPyg3pxqRHFApBs9mCgOiXRIpJuPNZ+LdHB8pwhAKqMRKMpEyOZcGM1wORYMBhoF2kRrhdaNYNFxM2BOCpHHBsvx545/rxOvVaBRUjfCRkS8+vqnn75F/2c/voOv/cMGLjmzjv3Rt/Nvf7GEVJvJxx75BZd6H0WuW024UPM+74/YsvkPWCkvYn25l+/s+CBOy3UsZI5FD32aV76mznvrIX0zOZ5T+zuCCzs4O7WDt8oPsHnL02kvLuOacDW3jn+NKVEl5byCJYduoG3iPt57XYTR7vC1ob3Mdrts6ryEnbuXkDZ6WesPsrTcAWnBvtIWth+5C+lY5LvPpFJaQhR1kM0K+oMDtGz5AanJfYiWHOPr+/jFghI3dY1TswW9dhuXmK1cWpjigpEdZOOI2MpytOVMHmYlP51byM2Ffmo42KakvyuN1eJQyipGbBrnwwtBRsIKp85SOcJgtItOfwvd4Q4sGt1opVoRoh+v3kGplGF62mBqSuH7J4Y8sqkMrW6eFpUhGzpkaiapOUU2crBOvkDbFYR2hCdqVMIixdokM8VRZgqjVIO5R3XdlWnjZFqw3BaUlUPIxhk0YeDg1Szi0AWZelSPwTDBtZq3UNB1rLCMWS9iVmYw5o6iZscxS5NYfqnZezjxPtUphyibws861NMGlZSi5ELBjphxQiatOuNGlRk7oOzCnAuB+ehyl1EOOWWTEyY5ochp0biFQhiSC31yfo2cVyFXL5GLInLNC55ycfzfLmOPlItvZKirDDWZpiLSlESaudiloF1mI5fp0GUqtJkMHIqxyxxpSjpFicbVsicPSQnAthSWrTDNRnCIZi9CG5JINXocoYK6bEyx0RyWam6D+u/hodCkZUxKhqREgCsCUtRxqDev163ixCVsXcKOi40AoYpDHRuvOa8fn5sEjwkRC7DR2j5+wDiKTeLIIIwMwlAdD5LAF/iBbATHSSESRQZRfOwxgzhWnBwmhlSYysAQjVAxkCcFRDMk4sakYoEKG8uNIJEntqO5fqzH8phhLjgRLFo0w4WIxr8hsY6aPZGw0TOJgsbxkcgnCD2CoE4Q1I9vczxYjodMdPzxuDk/OWSEVM2QMRDSQEoTIRtB8cZPf/L0vQ2DnWp0zCMnC8DSsJUH4ikArmiZ4t6izx4/Q4ksi5dUOXhwnLNqfXRnFxNkdjPsXc6CiuZlO9r52PkRP5jZyrPkBn780MVsvvxs7o0v4YJV9/DAQ2kequV5cucLuWX8K8z43+TAoj/CFBHv+cr9vP8P6zxzwQq+NrKX9d7DtJy7lZnKOjbsXszmXDur1UJWyPWsWH4eU+YYjxy8jWr1HjJtvcSsZVdtIWLNW8lmNL3+AfJbb+Eld47yUkNRXrOArctMbm4b4bttNcSiQVa43ZwbGZxbPMr5E/dxbRyhXUUhv4rd1mru8ZZw0+4eRsMOQNLlmnR3pVA5i4Jr8ENzAfXUEpDPRAgYsGIWG3MMihF6wl10mpvpbj1AS2vA0mUghYtUPURRB7VajmLRYXhSUio1Tl/EFGCCYzvknSw5M00Wl2xgk6qbpKo5FkZdLEuvR6Sb/ylMQexoAuXj6SrVsESpNk2hfJTZwg6qwRx+XHvUG9ly01huDsPOIo00sUhT1WnKkUMY2PhhO8IZANdF9Jy09yzBsTS2irBl86rYsIrhzWFUiziFGdJHJumfm8YMA8ygjhF6jw4K2yLKpfAzNl7KpOZKqrag5GjmrIiC5TNr+AwbNQpW2Lwq1qbSbv+3wEhJi5xyGlfJCkVaC7LNi5kyUUgmLJIJj5Lxa2S9Kr14ZGRMxmgO9TSvkD3eNiEJjAy+kaWu0tSFS1WkqOBS0i6lyKboO8xGNrOhxVRgU4js5hWzLuXmxU4VXPyTBrsEYJkS01KYhjze6xDN4JhTJrPKIlQ5AinwJHjHeh5KNuaGQKtf3gNRaBwZkxIRrgixRYArfGx8nGY4WLqKravYuoypy1jHQoU6DpVTDBMTsNDaAm0SHxumaQZE1Bz/D0NJGEqqgSQIBGEomwGiGj2SWJ0UJifW49g4PlxqSIUhDZRUGEJhCIkSJ0JCHZvHEqVFYx5LVGwhI7sRMEicZg9FIVEnLRvN9ePf57HHU04OGnEiaGKi4wEBv/FHmDTeF/O5p3//fRv4r7fcwbmXtZB/33Vsef3lfLRjC/fv28NNXa/lnZPXcPSyTt7hfJtzgwe5/RcX8rz4IpTt8bPtn8fMvIaV7Kf3oa/wytfUeKN0edHENBeX/pmZBd2YK03+Wb8d52ieh3ZdyJX+evrrDjePf4mSnSVrv4Qzhr5H7+E7+LdnW2w9Q/GfE6MMkubmVavpy+4lqK1g9+4+yuVulqQHWDrbTn/Yhk5phrw9bDt0O5WwSK5zEMNZTmVuAEQ7ti3oMmdoOfIA+d13YvtFdCbF1Koetg5qft4xzv42Hy0ES9xuzhQua8tF1hw9wPJaCQuIzAxTmRXskUvYUBvgF8U+dkU9RCiUFHS1umRabHTWpGBLxs2YsHnbBAH0mDEDRpUeMU23PkJ7uJf2YBudeux470AIByk70XEbnp+lWnWZKxrMzkqqVZcgOHEfHdMwyTppMmbjlgnp2CYVWqTqBk5VkY5tnJNul4AAbUNkxoTSx9M1amHzatjqDIXSUSr1AvWogh/XHvX+MCynceM1O400UkiVAlzi2CaOnMbZML7dvF2C0zzd8NFXWlqWxj52CwVdxwyrmH4Zwyth1AqoSgFZnkVVixhRrXlR04mrYY/RpkGUdgjTjcCou40LnKo2VKyYkhkxZ4YUDZ+C8imaPjVLnHSFbGPs/+SCaQpFVlqkpUkGRQZBRkO2eYFTIzwaV8lm/RrpoNa4D0/z6thjc0vzqLZG0iRQaXyVxpMpatJtHh1wKONS0g7FyKEYN4JjOrAphCZVnMZ56jjUjs2xH3VREzRCxDIVhilRhkQaAqFO9CxiJYikIJIQSoEvwRcQKqC5nT7WCzl5WZ4IlGNhYosIR0TYhNgixCbAFj4WHpZunsyo65i6hkUVM65g6gqmrjZPjvROmvtYNL+2+fijj5UoGsFigrYaB5O1+ajhmShSRLEkCiVRJAkjQRgKwkA0nm9u99+mZo/lsVMjaASGVCdCpjlXKJRohoWWzfAQKC15yd+8+vTd0zeaXdfQTAEwMGdQa60z0jLAajXEXC0g52t2Zi/nrPo3se0zOZQpcO7RAWQsybbu40DtTLqqMW/eOcgnz5vmGXqOD2S/zeuPvIp6VzsfbH0X7+v+K5ZVWrnjiODpnMvVva/gtvEvUQ++yp7BP6KcauEdN9zAdy6zePWTOvnTgs/rHrybTyx9JeMDkkvPugk3buPIkaX8vNpLKtPGMtXHwlofzxx8HUEmZLS6j11D9+H5t5HKd2BaSxmv9TLUeiXi4qfRko1oC0bJHNrMJT9+gKv8GjqTprC0k729mg1tR/lIZ4VSTyuG6OAMu4M1mKwpF1k5dRNvqpf5C1MTOzal9CJGzQXsivrZdLSL+w90UtDdGBhYAtpyDum8hUybTLkWe6w+ivYA2Jc2/mMJ6DEj+lSVTlmgXR+lNRqiRe6jxdxOd36KwQXHQsFu3FwtzhOEGXzPpVq1KJUMRoqCeuDih27j9EgaXfCU7ZI2XVxlk6J5y4TQwPEMHD9LW9xGv30Glm08OiAsiIyYSAYE+Hhx85YJfolKrUC5MknN+//be+84S47y3P9b1eHkyZtmd7UraZUDSAIMQoggggATTbTB2GCwccDmGl/wdcTGxvcaJ66zifaPZBswQSaDwUhCAcVVWIUN2jg7O/HEDlX1+6Oqw5mdFfiCWQnNK/Wnq6ur+/T2OVNP9/s+z/sukeg+seofxw6xQNHAC2p4vlXDpqJCaio2dYK2+lblTSFaW2CkUgKMkntFQOBbYVMgFIGJ8XXk0ih08aIOQX+Zibkl1nUX8QZtBxoCPzV4SjmWR2FGSnQ9RNVCklpAVPOJKtIqYMMMPFKW/ZSFIGa3F9MLNb2KR7/SpN9o0qsMC5oAfCGpyZCGEzc1yuImrWloRT1doJ7G1NOYRjJgnD5bhKYuDXXPCpsauhA5laFTC4/UqzlRU42BtM/wfeFAIq7SNSFtl3KhrUKWVFgACRV6xq7LgDIgZKVLyw+kfSPxM0CRCE+QeILY81j2fLRXR5dAJREQC4OWJSCRBZCYDFCydYkw4GOoSgcsDlxCkVhwISIkxicmICY0A3wiAj3Ap09g+vimj28GhG6MZdEnhPk6sccS21QcxPikK/7VgRPa+Rjj54FmCzQ+SksHODJfvlc7qU/6N954I+9/6zfZdv4kW9/zRuKLzuYVF13NnwfbedKRfZx59J2c+4RpDk1K3hW/mM7y87jvni28bP6x7K/ex80PfBnC13BmsJ+tX/+//OrP+Jy+fpJ33309v6jfwmfTi4ku38jjgut5k3gXD9z9JA4c2c6z44topVW+eugDKAVi9FVU4vt4/A3vZ9+2iHc832OrDvmbY3vYVzmTt533a2wYXeTS5JOcyf0M+mewd+965o5NM1IZ41S5gVMWx1inR9BVwzFziN2Hb+Hw8r2kJLSmtuGF2+h312HYgBAVmjXNhDlK68gd1O+/kUbnINIo0k2TzG4f476plG8357h7os98C4SQbAnHOENU2BEnnNGeY8fiYbYlCQFghE+7uY0jwTb2mvXcFU1xc3uce5MpDjOJRuJ7gvFWhWrTpkyIXcqEhQCbWC0slLETnmaj32edXGaCOUb1DCPqIK10H2NmljHmqZExdQRSjgFjKGVz5EdxlX4/oNv16LQFURSSJDXrTiIT/XjUwio1v0JVVqgKmxYh1D6VxLdK2EhS1QFVrBJ2SAUrwQTDKtjERMRqYFWwSZd+tEy3t0SUdIjVgFhHJHrg8vtnJgiqdfyg6lInVBCeEyo5t4IxjvWSWDbM6krYIjwsBAReiY9Ogm9ifCdQ8pI+XmQBRA46eN0l5KBthUzpIBc0+ekAqYsArBECXbXgoSo+ScUjrnhEobBK1wB6gaYbaLp+SttPWfYS2n7i1LHFuEwZGwcF3xygJgLqMrAgIjzqCKoGasZQ01bMVNM23UItTamlEbU0oprGboy2widtXJoFq46tGZMH0DOFrBUxVYhllVhUiISdbvtZCgUd0jMBXR3S0QEd5bOsAjq6UMLa9Ath7hzqmwp91x8RDOk8pBQWWDyB59k3FelZcMkAw0iB9kBLgZZ2nQpIhSCRFKCSAYtkCFiMFDYMIY8HGoEhFIaKUARCE6KoiJSAlFCkDiwcSJjIgokZ4DOwazPg3U99x8M3kHvjjTfysT+4nsZYhQuufRdKp7zwWXfwxomLeeO3P8mV/nsIp7dy/alV3lX5M7bpRb7y5Yt41tjj2NoZ5Z9v/yPW73gm3eXzefwN76B3Wo03PHMvf5g0ePbsIZ7S/n32VzYSPWkDz+IqXs372X3n0zg6u4VnxBcynjb5xpGP0ovmEaOvAGl4zC3vwzf7+Isf9blvq8cvz7V5cXeZfxj5Mf70rJ9kvAWXmS/zI+qLbBQdut0dPLBvjPn5jVS8EbYE65lut5iOx6mLClEtYmawj92Hb2Guf4CUlOb4NEF1M9FgHWm6HiHH8DzBWHVAa3CYxuE7qe+/nUbvMJ5O0a06S1vHObgh4O6JPrfX5zkwoWnX7MS5ORjlFFFhW5KwtbvEtvZRtkUDNqWWV6JlSKe6iaPhZg6wgfuTKXb1R9jVH+WQmeQYoxgkgScYbVWo1HxkzSMNPXqhTZkwCCWmIqHi5T/imjSs82ImZZ9xscS4OUbLHKOpZqipQ4yYeUZYYoTl3J0EEilGMVgWUJpWSZKQOAoYRD79nqTXE8SJVcAmK1SwUkpqQQEUFeGUrk7QFKSSMPEIYumUr5aPHpbIhFBSwfpWzGQBw3LREzUgSiwXfRB16Ecd4rRfiJlKgqZhhkeAH1atoMmvIr2qEzRZX7QhcE9xASr1rCJWhI6LPixqKtMErZjJEHgan9QBSIKnI7yMd5708eIeMuohBx1Ev20BQ0X4maBJRYUIqixkEgJdDVyKBQck4TCQ9ANDP9D0pKLnpXT9lI6XMPCNVcE6dWwUWBAZuHUU2Ekzs0BIasKn5lIu2KUEKk68ZEElpaYSqiohTGOqKqHiAKWyQrRUdcKlrK/swkhlhVRWSWSVRIYuBUPm+LHP5X0TMjC+U8j69Jwqtqs82ipgQEBkglwVG7lUDJFT10ZD++07QgY2QoDvuTcYTyClQHrWLSaksJ4lUbyVaAlaCLTAusoEpMKQOkA59JrLHt6T/lV/fRvtuT6X9z5F9+qr+R9vHmFHZZI/u/6TvH/L7/PnB89m7vJ1vHL0EFcuvoldu15FqDZz5YFz2F2/k1t3f5Wg+Ro2tDRnffLXuOqVp/LxHcf48KEZxvxpnjjzFrqjI8Q/MsULzb/yEj7K/bsu4+jMaVwWncF2vZFvzX6Ow717qISXYWoXMn3wM5x9/1e5+lGGv7/C41yt+J25ozTjBn/V/Eneu+lZpOsbnFpb4iL1TS7W32A7+0iTUzlyZB2zRyfodsdZ15hkox5n3XKNDWqMuqiQVGMW0qMcOHY3M+29tJM5/LBGbXQa6a0nHoyj1CTCm0BKj2Y1pakWaSw9QOXQXdTn91Hvz+DpFNWs0d44wuyUzwNjKXc1ltk7FjMzBlEo8IXH5mCEaREwnaZsGnSZbs+zKeownaasT5UDhYBuZT3z/npmmGK/nmB3PMb9/RaH1ChHzRjHGCXFRwDNekCtHuBXPExFkgaSvi/oeIY4kJjQ9pffHOpSMyYTxuSAMdGhxTItM09TH6OuZqnp2VwF26BNgy6+S4tcVsFqXUOpGmliUyYMIs+qYAeCKJKkKnSCJidsWsFHrwQhVS8klIUKNgeMjDqYFhTC0BQ0wwCfEC/P/w+Oh+646EqkOWXQCpkGxGmfOBnkYqY4dTx0J3jK166dg4gQ+EEF6cRMQoYFgIjAgUhoxUzat3l5lF8Cj7J4yS+1S4FYafClLqVXSPFM7DjmNsWCTPp4Uc8pY7t4cW9IFVvmlA8pY43K306076ErPiq06tg0tHl7EgcSkVPH9n1N3yljs7QLA9/k6lcrYhLEXiFmyvt9Fzdw/z4fWVLJCipIqohCHWuMU8BqCyQ6paIUFZVacEkTqkYfBy6hWyrGEBhDxZD3hceBTYgSoU3HIIolJnRpGQqgGJiAvgks8Ohs8ehrn652TibjExHwN+98mD/pf/0ju7j3hhleeOZdzP75n/OBP3s6O/v3c9UdN3Lf9lfw9DuexfnP2MZMzfBH0UvwvWfyta9O8mMjlzPRr/IvO/+Y9Tsey8Ls47lk8DVGb/0sv/X6OvFklY/supkjo0/gmYd/lniyTnLJJM80/85Pivexb/fF7N9/Lhcl27lYn849S7dy2/yX8bxtyNazaXYPc+5dHyIRh/jIUwTfPE/wwk6fX1hcYJBM8sf65Xxj6mkcm6ySrquyvh5zATs5K/0m53M7oyh6vS0cOTLGwvw6er1RRiotNnkTrOs1mIqajJsmwhf0gy4LgyMcmd/NXO8gy/EceILayAb8cAqlxogHIyDHEXLcgkElscKe7lGqx/YSHt1DvT9LdTBn3UQjdbpTDebGPI6MaPY2euxt9Dg6JpgdsRRGD8l6v8EmGbJRw/o4Yl2/w/ruPOvShPVKsU4pqq5KVxSO0fYnmZfjzJoxjugx9scj7IlaHNVN5k2LeTPCAk1bvQuo11zKhIoHoUT7ksQXDHzoSpu50YTS8tQDu87+cBtSMyITmiKmJfouZcIydbNIXc9TU7PUzcKQkKlOjxr9UqZOAdSAGsbU8rTIVsgUkMSeU8EK4rjgoKcqyKmEaRrkQTfA0QYDQi8glE7IlClcjUegJb7ycgAJtFfw1M2K9Ur+uTRoaTAZiDjueVLincfK8s2jpE8Ud1eAR8FTt/TAZIgOKP0AzwuRfpiLmHIhEz4GCw420OiYL8pbASQrFbHl/uLtxJNOxERZHZs6xWuETONCIZsMEJFNtyDjfkkRWwKWbLukji0rZI0AHfhOJesVKlmnvk7ydAqGyDMWUDwLNH1PMZCKvqeJA5u7ZxhYxBC4JL4dk60zcaGHIBQeoZCESEIEoUvJEDIMEKE2VIxNyRC61AyhVoQqoaLT0lhKIGN40tuOPrwn/W9/fi/f+rfd/PhLJEd+8Y3c+vaX8geDT/JNvZlGb5mzD/4mT7p4E5+bFPzxyFWc0v0E133rRWwa38pT7z+NYxtn+cq172P9jp8m7k/x2OvegZzweO0LD/MjY9v4s9u/zu3rns+L97+MdLJGcskkF5vrebP4Y+Zmt7Lr7suYTtfx1OR8+tE81xz9FB0VEdaeigx3cMr+r7B93+fZNxXxvmd67N0Mr15a5rVLbaSu8tH0ybw7fTFmfJL+REh/IkSPhZwaLnGuvpkz1A3sYBfjRMTxNHNzo8zPjdBuT6HSBpOVUSZpMdGrM5k0mTBNfCGJw5i2nmeuc4hjiw/QTuZppwsYDNXmFH5lCiPGSKIGWo8g5ChCjiCFoB6mNEyHajRHZekwwewDVHqzVAfzVKJFCwqtOv3xGksjPseaViW7v9bnaCNlviWYb9lCHghBS1ZY71VZZyTrlWYyiRmPukz0lxhPEyaVZlzbouNV93uK/BG6/hjLcpRFWhzTFhhmkgYHkwbHdMuCBCMsmQYdqhinI65UPCoVn6DiIUMJgYcKrKgpklbUlHoCAsdJz1Io+EWunYrQNKQVNDVERF0MLCA4MVPNLDsV7EIOGJb0OKBC360HJYaHhxUzOR66DlE6dPxyjyTxSROPOJHEkSCOZYl7vjoHfTUxU+BAxBcOKEqqWD9TxSph12YVMMmOWZleQVoKoBEaJTSaAlBSnS0RSRoXCtlk4EAjIdVOzGQSlE5IHe/cipkKYJFeYAHFC0rc8pLKVfhgPAy+FTDpYRHT6kKlB1fKSmGQQuMJg8wVsgppUjyT5ipX6YBEOLCRSYRIBojE5fvRCdKB0lC7BDBSp4WSVqcI45LHSWHBJvDQvofyBcqXpL7Il8SzgBF7FnhiaYg9TSQ1sacZSM1AKmLP2LG+HZtmAONA5p9/586H96S/67ojfPn9d/LSX9zB3EueRfSmV/Pqxkd498an89Rr38ebN3+Y6+ZqzF06xaWtlFctvBRP/jj/8R8eL97wFCYPB3x57sMkXkJqXsLUmM+5//pLLD3hbN5w+S5e0DiV37vjG9w2+VxefPCVqNEK0ePWMa0O8Hb/fyEGgttvfQZmMM7TkvOZVmPsXPgmdy9dD/5WgvoVhDrk1D2fZvPhq7lri+afrvB4YCO8qN3hZxeXWa8UM94mPhY9gc+px3G/dwq1iTrLLY94zILAhsqAM8X9bE+/zQ5zN6ewl8CMMBhMsbDQYGmxSaczzmDQYqTSYlw2GY1rjA2qjOkGY6ZBgEcapvRos9ifYW7pIO14nk6ySC9dxkio1MfxK+PACEo1SZO6TTksWwjZRAhJ1VfURI9askzYO0awfJRg4RBhvEwYLVvFbNrDhD7xSI1eK6TdlCzUNLPVmCOVAXN1lRccX2pAp2Z9wzURMCFDJoTPhMaCQRwzEfcYGbQZVSkjruD4iCs+bt8kJLHfpO+36IombdFkyTRY0DWOpXWOqRpHk1peQ3bJ1ZBdMg3a1FEuROj7kkroKIWhl4uatC9IPemAA2JJzj83ngMMTzhuurQP9UJQEZaHXnVippqIqRJRpW8Vx/QITYeKbhOatlXIuizwFQbU8nbfcdKjvAbxMP+8gjZBrnC1giaPNPVIE0mSWkFTknqFoKkEICdSxwZekNMArZipoAL6xgKHZzIxk8TXAk8JCzKOLlhWx2b88rLAKQOXXMSU88sV2tj8PZkoKQcYFZMqCzKpilBaOfBQOYhkbW1K+/TwPoZETAXQ2DcTDwvWnlPKerlSFiPRxsNoaccIH/CKY/JtPz+HBSQPVozxnVpWopFCO8ApL6kFCJ3mACLSBKFiZGpBSDgQksaN0ynSKEQOPml+nkuvv+rhPekfuneRT/7JTfzoL11I9PoXUH/K5bzgnC/yilOeya997a/59oW/y49dfybPft4ZfCbp8f7mX1Ed7OS6bz2f0eYkzz54LmaDxz9/8w/Zet5lzB58LGdtWGLzx/4XD/zoxbzl/Fv58dZZvPX2L3Pvuiv50f0/Do0q7cdOURUD/pf/draxl733XcLhw2exTa3jycm5pGmfb81+htnBfrzwPPza5VTShNN2f4qNM9ezZ6PhQ08R3HkK/Mgg5ucXFzk/iukLgS9q3CrP56uDHVyvzuYOtlMdbxKPBHQaHnokQDZ9tgZLnMJeNqc7OYU9bGMvo/RJ0w10O6MsLFbodlv0eyMMBi3qQZNRr8GIqtIchLTSGiPGLiE+KlAMRI9OvMBid4al3iy9tE1ftemnbVKTEtZa+JVRq5o1TdKkhtE1kA1bdFw0QFTxJFQ9W0u2krQJB4sEnVn8pRnCaNnVkO24pQdSkIzU6I9U6NUl7SosVRTzlYRjwYDlis6LjbdrthRgp2ZTKoTCY0QEjDplbFZ0fCRNGIkHjMZ9RtKYlqsf2zS2olOrVMkpkdWiFKCo0aVOhyrLusaSrrCQVplPKyxqW/KvQ1FHtkPNVnuiRh/LLpJSEASyxEe3oibjQEJJq4jNuOhKnoB/7smhfqQgQFOVTtCEFTVVHYe84sAiNH1C0yU0PQLTJTRWyFTJx8RuHZWOK/PPbcZLyzwKi5wzGRVQORpg6pEqSZoKkkSgUkcRLOWnGRYyFcdn7Yxr7kvfCZrcUkqf4BlpQcNYvrnUwipmlSx46BRtP9/28n0+K8ZmqamllS/lYGOylAxO/aqzxb2lKLsonQFKOrS2bWWVsu58w+PcPtdvBVUSKf1cNWuBpwQaJQDCSAs+SNvWHtrIEqDIfPwwyNh9v/y+n354T/r9Tsz73vJNLn3xDiY/9nuohQXe/oYWg3TAR++7g3TyTB517+t54jnr+cxGyc+sj3nKzCup13+KL3xe8fSznsj2W6sc3TrD177xAU675Mc5tHsjF43ex/in/oxdL3o0v3X2Tl7Q3MHv3v5VFqYey3MOv55eOMbCOSPoiQpXqs/yE8E/stSd4p6dl6GiJo9LzuRctYWFaIZvzX6GdrKIV7kAv3opvtJs3/cFthz6Bot1xaeeAF99lGCdUvxEZ5nnd3ukQnLQE9QMbFYeD/inc2N0Ct9OtnObOY19YprqWI2k5dOpe+hmgGn6jFdTtogZNpi9bFT3s4mDTHOQKeYxaowoGqPTbrDcDhkMmkSDJoNBk1A2GPEbNEyFRhpSjwKaukrTVGmYKnVCjGeIZcRAd+nGSyz3jtGNFuilHfqqzUD1iJSdwG092SbCa4Cpo1QVldZcsfGVtWQloacsQU71LRBEy/i9RfzuPMFg2fbl9WOtotbTKaoaEDcqNp1CzaNXNbRDzXKQsuiqOfWqlMr/DZcCTH1BVXiuhqykgaCpscCgFK00oZFGNJOBFTy5Ck9Z8Y2aq+JUd7RCD0nq1YhllUjWCk46WeWmCm0dsqzcou0zfNdx0bN23/HSe8YV6HDlAKUU+DkXXSD8Ybqg9gTKc4wNz/LQzXcAkiEKoYBAOP55BigiJsypgDGhcRwU07eiNdPHNz3HZcl45UW76Isd97w8LkG6ZGZFpswAbYbBQSkPrSSpkiglUKkVNlngkG58Sbjk+OlDi5FDYimtPTxhhU2eyERNMl/nILJC3ORpgcyBRyKReAi3tsWMsuOzfZ6R+X7bX+6z441wZUiFxlAAkEYX6Ra0KgFRUqyVAxxUDiba6LxPl/pe8YE/fXhP+gAf/PWr2bRjjEcvfI75D/4jX3vv6/jbu9/Hf6y/kvHr38M7z/033n9Lhye+6Ay+0e3x3uZfIzrf4oF9b+DAgSVe0Xoq4VHFt/kau++/kelzX8uxA00uqd/OyFV/y94XPYb/edbNPHn0TN55x9WEtQ28Mfolvt7ZjL+tydIZLaYGM/xq+EdsFDMcOHgOh/acR4OAS6Pz2aImOTrYzy1zX2Y5WUCGZ+BXL0NSYf3sTZy674v4yTw3niG46jGaPZsMj+0kvGjQ5in9Pgd8nzvqTZaEYTKOOCdJ2KQCHvBP49Z4M7cnm7lXb+Ees5ludZygFTKoewzqHqbho+s+YQ02e8us5zCTah9T5hDrOGoLlDNDaEKSZIxBv0GnU6HXrxBHdaKoThzXSZM6zaBJQ1ap6YBaGlKNPeqmQt2E1ExI3VhFrfEMiaspO0g79OJlOr0FBqqbFxy3ANElMbFNlxs2XGnAKoVyNsQY1zeknLUFOzwJgeMmB9qVA4y7+FEHb7Dk6sf2S/VjbTUnPy2KcphAktQCW3i86tGvilzs1PUVHS9l2U+Kik05P71ER3QVnqIQfOFRFx51IakbSQ1ceT9NTSnqWtmqTVkFp5yLXvDTswIbK6s4ISuWky6qrhxg9nwe0DMVesZWbLJVm0LayhXasM/+jovutk2Yc9EHpTEDQqTvW2qg45+L0luGkQLjOOhKCJQHylEDcwHTCoHT6oInrMJWQig0oRM4hU7glIGM5ahYrnlIhG/cQh/fZKImS0MNSfBJnJDp+HaxvzgmMAqJ9e9b143v0jM7MMlVsdKqaTPQURKVkrt4tJFuXd625zAZ2Bh5gu1inDABnvCRQuIJBxKiBBjGAUYGLsaupUvpkLcRSDMMSBnQPO2dL3/4T/pX/fVtLB3t8bynDDjwc29Ev/t3ecXhd/D757+RF37m1zl62e/zuC+fzk899XT+Lhzw+k0hTzn8IsbHns1VV02xZdNmnn7wbLy6xxf3f4BOd5Gpba9m7lCFSxo7Gfns3zD/lAt504/czXRzHX9+6BCnLR3lE+Ov5S0Hn8S6qQYHdzRRLZ/HR9/k9dW/I0qrHNpzLscOn8aY9Hjs4DxO0euYiQ5y1/x/cnTwAGGwBRNeggxOpdF9gC0Hr2Hj0W+z1BB881zFf56nmB2Hx7cjrki7XN7vk6aCays1vj5WY6HWZNugx1n9LqclCacmCRVG2Se3sjPexD3pevaYjewzGzkk1iObNUzNZ1CVJDUPU/cxVQ9T9RivRGwQC0yaI4zqQ4ybY4wzxwRzTDDPmFnCMzXSpMEgqtPvVej1QuK4RuxEU7aUYJWq17DgQEhNB4SpFUpVCaiaMK8ta+vL+hjPkIokF0ZFaZe+Kw8Y677ty2rKKrtOdITwQzzHZy/qyFp3hFJWGFUGiaIwR7YvwCamTAmMy5nuygF6SR8v7lrhU9KzoqiS6Gm4+EbR1gEl0ZN0XHUxRCns+YquLCo4ZUU1hts2J3rGYY8DSANB6HlUHX2waoTNc+kKbNS0oqq1q+KUWI56qTpTzVVyyrdzXroeKrghsRWbLLiERCJ3GlmAcNTAng7oG5+e8umagKhUnamgE2Y89HAFT92OHxCQehWUFzr/unDc80yY5IKcohA6aQFaWrApxExl5SzDfcdtDwuiPGkIpCYU2iqosWKn7IHCN5ka1oJMATx2bUElzRev1F5t8TKtxAn2S6PxXUkZkblyjAWJLHitHWDYReRrpYQDKFGATw5Idv2zP/vPD/9J//rP7OaGf9/L695xCXsufyKTr389P7Hls5wzcQ7vvucm0JqfrPwZOw8t8yMvOJ2r5tt8YOPVmEN/QrPxNj73uYNcev7jOPemEeR0hat2/jVJGjO5/VUcO1jhURuPMvGRt6MvPIvfeMYxDtdi3iImeOm91zI/cRFvWHg1t0SbmDp1lH3bagQm4Ur1GV5c/VeW4nGOPnAmC4e30fIE5w92cGa6la5qs3vpZva0bwVCRHgmBOcivXFGF+9iy6HrmJy/k6U6XHcWXHNOyv2b4Nye4clRm8fHfc7px8z3K+zUFW6oh3xjssLyWMB2Izl10OXUQY/tScqWJGU6NQy8dTzARu5J1rEnneSwmeSgmeKQmWQ+mMSrh+iqRxRKEgcGVC1n3oQeY+GASdlm3Mwxpo/QcrVmy8soS9RNilF1kqRKHFcYDEKiQUCcWFBIkwppGuYlBD1Tp+pVqBJa5awObKnAVBKaoFQisBBKhcbHlzbJVEpK6koARqnltg/ijk2LO1QW0ImnTLGthbE89nJlJ4qiHFrb5FwZUIiM575aUQ7HCrF5xjSeSYoCHCpGlqo6ybhn6YYOMHJKoYrsMTmXvWB+eCoGoVABqKyaUyCIA+HAwRTg4mt6Xup46iKnECZeUcHJsjlKVZ0cvTDxAd9m5gyltFxyoGogNJqKowpWtCbUimpGE8yAQxec9AxMKmaYq15ZuWiDh9UJpCIkEYHLeGOfyzNx0yDjpOtCCDUwPjE+icmnZRKb9IDY2PZQvynaGX89xif1QpQMSL0ALQJEVtugBBJGCEvtFK66lmtrB0A2B1AZZMjPgXTK5aF+N1aUVLii+DwpLCB5nrGAJDU+ygGEGgYRk+K5f5ln3NopuTPKq0/KP1zxMOfpA+y+ZZbP/e3tvPjXLmHw629A+D4f+eXz+fi9H+drZ/0crat+lfuf/WGu+CS8/imn88FGzIXNGm+J30wcH2Vx4Re46aY9PPeSp7PpaoN3ap3P3vyXxMmAjWe+kiN7mpy+JWXrJ34TL5R84uWb+cjEPTy+uZ3f2XMHm3tLfGPiJbzp4NNQlTEqp49wcFOFUEc8K/0sL6z+G1Fc4eDMOSwf2IJWNc5knHP7ZzJiqhyM9vLA4u0c7t+P540ig7Mw/g6kHGe0s4f1R77NurnbQS9z11afG85MufVUQaflcVFP8cRokUuiiB2DhHSxwnyvyp60wq2e4L4RjyPjgiPjAtPy2WwEm6M+m6Mem1PFFieymlKGVE5whCkeSCfYm04wY8aZNaPMmjGOMsacHCepNqFiK/zEgUSHVmWbAQOBRIbQCiLGZI8RFnMRVZM2DTpOQNWl4cRUddOjbhRCh7aebBIQxwFR5FlVbWr7M9FUuZiHMDVCqoQipGICK4bSWb71ojBHuUhH4CiJAb4NDgqBFDgvqmWHJNrWmE3SiDjp55WclCvEkWrLfVd5sQ5LS8zT3UqbL0eKgsdORh00JVeC8XOOezamaHsUlMNy3vTs1V8gsZOApQK6whsqtnTCrGzgEGUwdtvpgxficFx2IxTGS9E+KN+CTJrzzq2aNvYsX33gaIOxbxyouApO3nD1ptQrACdrZ2vlA5lbybfK00AIAsc3D40hMLZsYKA1odYEWll+uksgFxhDgBniqQeuHZT6Quz2UJ/b9g1Id7+lCVAicxIVDqIYj9gERPhExiMyPgMdEBmPgcme5e00nBo75cal5/wEj9R4eTsbn+CTmBXj3Hm08EllgJK+BSjhkwh/OOmcAx0jnHJcCjQ27YgWsP+Xr3j4T/rdpYgPvPVqnvCi09my8+PMvf/96M+8l1d843X85mPfyss/+zuw8QLeKH+Lb9wzyxt+4gLeeWiW3zgl5IIDr6RW28bddz2PffsO84JHP5PJaxLklipfuu8DzB89yGmPeSkH7tnE+FTAeXe+n/DOa1l48oX85mPuZ6mqeU2wkZ/ZdS2VoMXHay/ht2cuI6g1qZ02wgMbQgJPc3F0LS+rfowpfZT9CztYPngKy4sbqPkVzos3cWa8lQDDoeh+9i/ey0x/D0oG+P7pEOxA+pupJ13G5u9k8thOxhfvoVOJ2LVFcvt2zd1bBEcnBWdEgsfGyzw6GvCoQURjUKGzPMJgPmCwAHOJx5Gqz8FGzGzLcGwUjo3AXEvQHZFM+B7r05T1UY/1acKGVLHBiawmlaKhAwZyglkzxmE1ysF0hGNmlEWsuGqBVr7uhKPoMES7EnCJLyAs6s+akqDK+JJakNL0bTnBBm3q2gqpGrSp5UU9+o4T38v7qiaiahS+FrYKVBqQplkRD5vrJlVBqQJUma5YFPOQpoLUVWyl2WAov7qnheW5D1EOy/nVSzTGnKLoOSqeAAzGMUJSk6J0TKKSXDClHF89zYJ0pijGkQ5tF/nUcwaIwD2BimE+O54FGAqqYZnDLnLaoGOKrMpvz8Y4cETa+cUYpDF4RhWcc7WCx64yLnqJNpjz2DMKYVLQEYf6i21QGE9Zlo1QKN+Q+uQ1ARLPWGDxCu56LA2J46sXQCPydg48JR576tlygqknSKXbdv1IF9uQAuGBkAIhwfMMHhaUfAyBNvhG20VrAgdOPhmYGAJDaXu4HThVbj52RdsvgVKAO96YImRsJDjukjE+RvioFcBy4e9c//Cf9AE+/PbraI5XeMZTJHtf9nI2vfMPeb3/YYwx/Mvk5Ygv/RYzL/xnnvxxzaWnT5FePMHX5jv802mLqPtex8TE07j+ukczM3OM513yDNZdneKtq3Fj54vcs/Matj/6chbnLiEZSM6dOMLkv/0fvFrIt567nT/fcgcT9XFel1R5ye7rkZVJPlv9UX7vyBPoh+Os3z7C/VMBqhWwPd7P0+WnuNS7mjiqcGTuNDpHpul0Jql5Tc5K1nFGsomWCTmm97F/cTczvX20kwVEuAFPbkcGpyDkBkbiBUYX7mFkYRejy3tAL7J7o2TnNs3ujbB7o8APJWfFKRckHc6JY86OY8ajOu1oHZ3OCP12ncFSQLqg8bsdjNel30iZb8DRWsx8w7DYFCw2YLEJiw3BoCmphoIJYxhPIiu2UlZcNaEUk1oz7koRhqZKap/3mdMNjqomc9qWGVymzrJpuHWdZRp0qNMNW/T9OiawCtzUE6gsN7ufgYTjw/uOieLbP8ZakNDwIupeRM30qGLFVKHp5dz3SomiuFpfxUTOjaHwtS7x1x3v3XHdj+O7P2gqXB9hAqQOHbiE9v0jY4bk+dVFiVbo2CQraIaW+17sL7Yt393DyQQwYAzGFIyPtEQ7zDjrGZ1QmSLn+jCwHL+dUxBxSlZAY33vNkV1xm+XOb89ow0KinbR56/YXkk19Eu8+Sy4CQKBtCx6hDZIoy0gOSARKnFglDjOukKY9EHXlt+e8dyV476feA0KpMK4ClxGaoxUKKnR0jhqLiTSoKQFp0TaJS3tL0DHgY0sgE2t3C+PbyuZHWfjH6nbNtKCVAZYV/3S7T8ck/43PnYPd33zEK/7kyex98pnEp6xg+t+9en83rW/x9899S+59F9/HhpTvOfs9/COz93D2190Pu9WHQzwdxtvZXnvbzE5eSXfvvHRHDhwiGdc8mROuTFECMGRTQf4+lf/iebkFBNbX8jM3iZjEz5nH7qK+rc+jd66iU9d0eCjG/cwVRnjp9MqL959IzUZcu3Is/jD2SdxR7qZTRsbLG2sMj8RUgkM56V38jTxKS6Qt9HptTi2sJX+3AaWltaDHGG7GufMeJKNeoxU9DkW7eXw0n5mBvvoqS4iXI8UW5H+NNLbSKBhrL2X0fldtDoHaHYOEAcD9q0X7JpO2b1RsHe9oNeEUxPNjnTAjiTOg8DNQYuldBNttZFusp7+oMlgySdpC/yoR5B0COM2YdJGmi5JGNGvpSxVDQuVhKWacZWmhF3XLa++VxOImqTqGUaMYSSNGU0TRpQVV426ilKjSuU8+poGjxrG1OmbBkumxoKusaBsbvcuVbrGFgDpGrdNLefQ92WVvt+g59VI/BDj2cyHyhPoUlGPvErUajx5F+gLPUXVT6jIhKoXURGR48L3clZJMERNTDieqrjK2qQERtmnNa3wtYKcKVJOhzsMHgWjxCvYIiVaYkFJtGwSMsAxAVIHliGiA8thNwWQeFpYIDEl+mFGVUSW+gpgKlMOpSn249KFCZOBD4AGbWmDyqRorXLaYc5lH6IXlumHGfUwLY432m6zYttoB0I25mOlbNbFobNLceCRgRJC4ihFIGQJmGQ+Nu8vgVrWFjk3Xq7ok2Q1f4W7H1IIpDH5vRHaApXQGqEVntGgU6RKbQ6iDIiMtttGOZAqtlfry0Ar65Ou/8lX/xAEcqHw67/wzRfhf+o9zP/jP7LtK1/k+d94NdPNaT44/VzEJ9+AftY7+YnbL+amBxb445+6hF89dITpasj/nbqa2b1/yMTE07jrzku55559POqcC3jc4VMwRwZwdpUv3fQ+5mf2s+3Cy+i0L6a76LN5E2y76Z+o7voWats0n39ijf9vy16qlTrP9yZ4xZ5bOC3qM9s6hw9HT+J9y4+h67VYN93i6GRAdzKkHhjO1bt4jPkyF4sb8dOEo/Nb6C5soL20nv5ghKoY41Q1zvZ0lHV6hEREzMeHWGgfZC46zEJ0BOX7CLkJKU9BeFNIbx2BVjR6hxhd3JsDQRDPMTcmeWBKs3ed5uAkHJwSzI/CtDaclkSclsZsTl0QOEmpRXWW0gmW00naaoq2Wk9HbaRnNpAkY4RpTDBYJOgvOS59jyDpunWPIO0hGJD6EUkwoFfRlk8fqpxH360IuiVOfbdqOfWqKhCBIAwsvbGhUsuZV5qG0TS1puH483VHfbQZF207MB6SiisEXiEylv/e0Y7SWEqla6mNlePojH3XPyCkL6tEskrfqzCQNWLPx/jSBvYceAznYV+FPVJip5QZKJ6nLZPEUwQyIfQSQmmDcqGI8B17xDJMYudhTofoiQVd8cHHeEbhG4Nv7BuNNBpPa6TWCF2wQHIA0WXmSIkPn1EOh4BnBTWxxCAR2vrKhfaRxgfjI7WHMD5SuXcY40CkDEBmmH4os3Y+ptSXUxZXH2/fhMqLAQ3CGECDMWA0RusCTLTlzJuMA49dm1I749WbUlsb5cYc315tvDE201H2BmUcUGlsDitjin4LaBKTv+PJEoAVbVHafvM//cEPx6QfD1Le95Zvct7l0zzuMQG7n/Mc1v3ym/jSU8f4w+v+kL+54q+57Ovvhj3/yfxrvsZz/79DeFLw1h+/kF+4/yCn1yv86fqbmd/927Sa59Lu/CT/+Y3b2bB+A0+feiy1m/vIVsihiX188z8/jPR9tpz7dOYOn0488Ni6UTG98xPUd/4HrJ/k1sev573bdjPTVDymNs1zlxZ4xuF7aeFzX+txfKzzKD7RvYCOP8bEhjoLYwHt8RDZ8DjDm+VMdSPnmes5k10kUcDC0kb6i5MsL2+g2xslpMEGPcapyoLAiKmxwDKL/QO0ezMsxbMsxbPEUiH9CWAaKdcjvCmEHKGSdmj0ZmgtH6ben6Hem6Han6FTi5gdg4PjKTNjgqNjMDMmWBiBlm/YrFJOSSM2pykbU8WGVLEuTWnEAVFSZzlt0k5adNQIPTVCV4/RUxN09SQpo44+WcUXktCAnyYWHOIOXtJ3HPrB8WvX1jJGe7EtsxjE9ANDN1CWRx9Q8Okdj77Mr89okKmPzYMeuEyRvuPCZzz6MnBoM0RnXG0dahDYJ2nwQQdoYzNXJnn2w+OpjLFjmKxGdYxZZby0S+IFNrWvDBjIkET69k1mBX0xpyU+CKNk5ZgMgKQ0+FLZLJpSEcjUUltlii9iApngC/vG4uVskiwUmVETs/7VKIsr+0pMFJPgGYOHxnMuG88BUubCEa4tDDmwDPPly1TFYS59DkJGYozI+/LtfL9tC21TMAgkGB9hJML4CG196EL7COPZbe0hjT8EUCIDHCPytiiBUXn/0HZ53HHHDrcxJQDLp2RjQcwYBAZjDGjNJX/6Q8DTz+zf/+Y2Zh9o85N/cCn7X/96onvv5ZQvXMWPff4VGGP4+FP/kurfPxVa09x+5b/y8g/cxuaxGr/8svN50+6DrAt8/vKUo3Tv+yWkrDA68ia++MUZ+v0+jz//MZy7ZwpmI+TmKne0r+G2W79EpdFkw+lPYmF2B8kgYHICth69mtFr/hWPlPlHbeOqc/p8YXoWHfo8MZjkWXNHuGz+EGNGsK/xKD4fX8in2mdxt9nKyEgNua7KbFOSjlUIaoKzvaPsUDdxmr6V07iPhuqz0J6i3x6j3xmn3Z5k0B+hRpMNusVG3WTCtJjUTWI0C+kcvd4hlqOjtJMFOukCA6ER/gjSTCHkBEKOI7wxPCrUkmWqvTka3WNUB3NUB/NUB3MIvchiM+LoiOHYiGbOJVaziyCtC0Y9zcY0ZoOyWTY3pIoppZhQirFEUkurqKRGT1XopSGdtEJPV+imIV1dpafq9NIGkW6CqBa8+jLH3q0FtrC1Z2zwTKbKUh6TQUGFVDFSZ+3IZV8sb9sxRsRokaK8mFQmFlR8Td8xUXL+vF/keY99m9o39Up0x6EMilbIJDwBvgUY4WEzR0pDgKZiVJ4BMXRBvtAYQgq2Sd6XjWG4zzfgGemYJnZiwng5S0hpKzhKTeBoitkSOJqjP9SfUR+HxpaOzeiQifFIZEgifGIZkMiAWAS2LXwiGRCJAOV5Q3TEgqY43IejQzK0D0eVpKA+lvZJaROleUIjszTPMrWFZ2SKJ1J8keC5bSlsNbMsqZqfr9Pj+ryhdmpByI07finv10hj3TTSuCRuRltnktYIU8QehHZ9GZgZ49IsiOOAqAAnUdq/Ys2D7HN0nl/8xX/84Zn0s+RrL/61S2gd3sn+n/kZNvz2b3HvU0/nZ774M7z2/Nfy5tEL4UMvgbOew7WX/Ck/9cGb2DZZ51dfcj5v3neIWBveeWqFbYd/jXbnDtZNPZ89ey7m5pvvZ2RkhEtPuZgtd1aglyK2hty9dAO33Pp5vCBgw2mXMBicQ3dpjLAi2VybY+rWT9PaeyNUQ45cOM3nti/y9S3LDCqSC8IJLm8vc9mxBzg7ToiDcW4NHsVVnTO5JjmD3WYTjVYVOVFhvuGhRgNMM2B90Od09rJN3cqp5h628AAN1afTnaLbaTHotej1Rul1x1DxCE3dYL2pM2kajJo6o6ZOqAPaqk03nqMfz9JOFuimi3TTZbpokA08RhBiBCGzpYWPTyXtUY2WqfYWqURLhPESlWiJSrwIeplOtcN8U7PQNENJ1bJ2UgW/ohkVinU6tcFfFwgedb79EWVo6Sr1pEagaiS6TqyrRKpKrAMiFRBpj4Hy6CvJQEn6StJXPgkCZSDFoIxAOxZLzq933Prj2nk2RtsWRiCFwDOOraKd+0MpPFXOpphRHlf0rci6OJRd0WVYtAE/hZYKJRRKpiQyIXXr2DfHpeLNgn6pPxzsK9Mfy0vWp10gL3dFSxDSIKWxGSY9bScsaUEnAAcqZgWrpGCcBDnjxLFSVrJPjJvvTcYskQ6YrH/cGAnaRyPzjJlG+y7XZeAojF7BRjdeQWt80P6CErlavxIeifBzymMibTsVPrFw+6Xn9nso6ZEKDyO9YUByzCkyUCqvy0B23BgKAFyxT5Szfgr7fdg+ZcFNaDyhXHI2jZQq3/aEwhcpQmirFRF2n4fOgezjV7z5h2fSj/spH3jb1Zx+0Tqe9ppz2PfqVxPv28fpn/scv3/bu/j4vR/nr674Ky4/eBd87n/CBS/lmgv+gJ/90C3UQo93vPxR/MXSAt9e7vGyDaP8pP9plg/+DZ5XY3T01dxwfZWDB48yNTnFxRNns/X+OqKnEOsCDom93HDbp+n3lxndsJX62Hksz29BpSPUaoINHGLs7q8yuu8GpFAs7djILacavrT+KPdtgqZf5SJR55KlWR6zfIxzohjtN7kvOJtrBtu5OjqVnfo05uUYzbEKSctnue6hWxYIRsKErXKGaX0f0/p+trCfaQ7SVAP6/Qm63SaDXp3+oMWg32TQbyGTUVqmxqRLutY0NtdOU1dQWtt8OvEC/XSJXrpML12mrzr0dERfSISo4ZmGzb6ZJVuTDYSo2SfRZEA16hBGHcKkTZC0CeOs3UHToR906FQjlms2gZpNpmYDwR2XWK1XBUILFHWpGDWKMRcAbmpdJFJz23XlUdcVarpGVdXxTANNHWVqKF1HmRClAxIdkGifVPsk2ifRHrH2ibUk1pLUkDNa8nwnObtFoYVBAVrbtQKUMWgjsIE+x0hZlR5ZTqIlV/RJN06CAx5pQLrAn9SWLimVdXN42v7xezpjnTg2yhD9MXXBvrSUiVEV7Swg6IKGhoyNkroCL8rSJWWKEopEurbUpFKReipnnKiMZSKtcnaYbSJKLJNh1kl2TNY2uWvaTYbSFEAlDMJNhp5wk6I0CIlLlWy5Qz4WiDywb4Qrtx2AecaNf5BtS40UiMzVYpyDxV2oMPb7MtmFa88+ZeMoNLhU0LjUC1iVRVp6l1BG5u8c2TtFsV+ijLdi/4pxphjvEkTbRXi2XrGQfOQdb/3vn/SFEFcCf+F+4e8xxvzRiv0/AbzVbXaANxpjbn2wc6426QN8/cO7uOuaw/zUHz0Rs/su9r7ilYy9/GWM/8ZbedW/v4pD3UN88MoPcsbOz8BX3g5nPZd7LvtTXvvhOzmyNOBNTz+D9ikN/ubAUUZ8j7ds9rlg4Z0sL15NJdxAGL6Am26qceTIPM1Gkwunz2b74VHqx4BAMpiMuG/2Ru6672o0itEN26g0zqSztAGl1hEEgqnKMqNH76C165s02w9gaiGzp45y+8aY66aWuHdakNZ8zpB1zhtEnLM0w3nRgDPihNgfZ4+3nZujzdwSb+Fucwr3mWlErY7XCuhXJVHdtzl3Gj7VmmGTXGCdOcA6/QAbOJIvo7qLipr0+g36vSpR1Cjy7UQNiMaomxqjukKTisuz44qV6wChIFUDYtUhStv0VYeB6tBPu0S6x0ANiIwgwiCoIkUNIbMka+V2iK8hSDWVdEAYFwHgPCic9vCTHlL1SPweiddj4PXoVTS9is1/c6KkanEIIjDIwBAEmqrUNF0AePUEajYgXNGCivYJTECgAwJTIVQVoIaigjY1NCGGCtpUMFSACoYqxoS2z9XH1SZAmxCtgzzoaUktpQDgyoUV7JUT9Kmc2WIwmKEgnwGUsTVltbG0SgPWZy0cOOVslYJ5MhwELLNbCpaKKI2xbJXCp5wzd4yxYKU1wmgLXtr6miXaAZh2fvqCYVKwUcrtDLgyhoousVWOb2uhQBiMAyyTZdIUjk6ZtYVCuVoBeb0A4WiXQqOkxghLt9QOpLI0EEPbTvykHGWy2C72Z33ZtnHeLXvDHL1S2PoFOdBhn/4p9QncVyEs0AlLBUJK+2Bgc+fZdQZgGdD99pv2/fdO+sKSa+8BngEcAG4AXmmMubM05lLgLmPMghDi2cDvGmN+5MHOe6JJf+5Qh4/+3vVc8uxtPP4FpzPzzj9i/oMfZOt738Pihdt4zedeg0bz3me9l9Pu/hJ8/m2w/jzaz/t7fv0bAz5722HO3zzCTz/9DN7fW+bG5R6n1kJ+dl2bcxb+jM7yDfj+KPXaFdx73zT37FoCYOvGzZzpb2F6f51KZMVH/VaPPfO3s2vvNcR6QFhv0ZzYgUqn6ffWIeQ4YQATcoHW3L3U997EyPJegrRLd9Mo+zf57BzrsmsqYt8GQa/psV3UOD1JOK0zz45Bn9OThC2JohNs4AE2cVeynnuS9ewxm9jjcu74jSqm5tGvSNKah6n5mJqHqHmMhz0mxTzj5jAT5iiTHGOSOSY5xriZo6E0Kq45UKjYVApxza2rqKSBiEeppnXqJqBmQmoux07VBFQJqZkAoUGkCqUHJC4bZ6z7RKpP5Nax7hPrhNgYEgPKyCJvjhxOtpYnXzOefWLTmiBJCVWCnw7yAuJZcrVywXD0ACUilByQyD6JFxH5kfXZ50HfUkDYtSNXu1UFtqC68AzSd7VnpSHwbNHqqi7y2ZRrsFb1cOk83wi3uLzyxgm9tI9v7FuBNgGKAGUCNKHdNqFtE6CzdBE2CoAhsEDj+i0IBRgq1pVFxbJksiBjKQCIKQX+DGCsr9lkbBZsINDSSZQFmFWZKRmQFZkihxkrugR2LqOkMTbFsGOqWGBy7RJY5f1CFGONzcdjHLgZcEBWZrCUZtbjGC3ZvuH9uFCpfeOCrKBMfs/ytZ2EhXsDE9j7Jw0OgGyfpWlqt8/e62xbkAGWKQGYUz+Y8mJc3/FjBdp+Z6WxRthzGEdiNULzjK9//L990n8CdhJ/ltv+dfv7Mu88wfhxYKcxZvODnfdEkz7AF96zk723HeNVv/8EaoFi78tfQXL0KKd+7KPsH1O89guvJdUpf/HUv+Ax7QX4xBsg6WGu+B0+W3sef/Dv93BkecCPXriJiy7ayIfay9zZHbC5EvCyiT6Xxh8jmfs0xqQ0m5fQ653LXXdWOXp0gBCCLVPTbPc3MH20QbMbIBCoEcO8PsLuwzdzYG4XqYkJa03qo9tRegOD/rhl18gq9SBhNJmhMXsP9SO7aHQPUx3ME41VmdlUY+94wj2tLocn4NCEYLklOUVW2JoqNvc7nBJ12ZKkbElTNipDX67nMFPsTcfZk05wyOXbOWimmJFTJLUmpuIRh4K04mEqHqYqMRUPqpJWNWZMLjNq5hkxxxhlkVGW3HqRMRZp6h7VVKPjgGgQFoXJXfqErG2SGiJt4icNQlWhYlxhcnybRoEsz47txwW6UAqT59AZ2Bqyeji3TqpjEpOQGE2qM3cLKORwIJhSAfFSMXFhBMKApw2e1gRK4SltKY2qKL83nGwty5sT4akETISWKUrEpDIlFTGpl5B4CYmniP1kqC5rFiSOfVFql2q2eu7JzjNOCWp971JaNaiQBl8afFEEfyvOl76yJmseCDYGXwh8hA0CY9t59kakCwxbIiRIUmHdEUUYU5KS+d5tyFPjo4yPNj4Klx7ZWGAq1g64tC32rrHFXzLGi8gkZqZgqBzHWDGrMF9KbZFRMkuTM3bSySdo48ANVq6124elbGKpm2AwJgM8C4TZdvZ+pd14k+13xwz36aKdH2v3u0+xoJXRNkt9FvyMcxmV9zMElgz1uXQMpbe9X/nQu/7bJ/2XAFcaY37Gbb8a+BFjzC+eYPxbgLOz8Sv2vQF4A8App5xyyb59+1b9zMWjPT7ye9ex/fwprvzZ80kOHmTvS16KbDQ45YMf5Oio4ee/8vPsX97PL1z0C/z0tmfjfeZX4N4vwvrz6D/t7fzlvq28/+q99GLFM8/dwAUXrOfrRHxzsUsoBFeMV3iSfwunLf8jqr8LkNTrj6LXPY29exvs368BwUijxebGejbGo6w7VqWVVhEI0oamzRyHFu7jwOzdLMXHMGiqrUnC2jRKTRAPRhHeBEKOEXjQEm3qnUNUj+2mtnyYWn+WWn8WfMXiuhqHJwQPNAYcbqXMjsKxUVvPdqQaskkLNsQRGwZdNqQJG5RiQ5qyQSlqusGynOCoHuVQ2uKItvl2Zs0os4wxa8ZYDMZYDkZRFd+Wb8tSKYRFzh0TSiphSrPSpyU7NFiiaZZp0ikVLS/adT2gohRBohCJIU2LlAlZUfIihUKITkPQVWRSQ6ZVZFq3bhc8AuPn+XTCLLdOqU9qy5TACV+MSjFZ6gNdKjJukqE0CEVZP1vLSRtIjX3atH586cqvZwXES6X5hlSmmaLUd09ookhloAxeFig2yoFOlk9nZXC4lM6g5JvHpBiRoEkt6GRrmZJKhZKJ9b3LlNRLiT2bziArp5fXbnWpCsosJFUGHxf4zfznwgUbpCTvl8LgeTZNQMY0yvLhrBb8DTIfO86ZJFxqYOGcTsKmfvAAkeUcEliKo7Dj3fO1zcbp1uDeEFxfsb8oiqgRKCFdOwt3Wp94Hvo0zieOtO3sWJP56oWldBpR2nbBarc+rs1wXx4X0Fmfo4MiLB3UyGKNzEFx5X9Zgcu8x5Tarv+5f/jq//ZJ/6XAs1ZM+o8zxvzSKmOfCvw1cJkxZu7BzvtgT/oAN31hH9d+8n6ueM05nP2ETfRv38kDr3sdstFg61/9JdHpm3n7tW/nS/u+xEXrL+LXH/s2zjl6L3zpt2FhL5xyKZ1L3sjfz5zJB67Zx/Ig5bR1DZ524SbmJgO+3O8xG6c0PcllI3CRvIMzup+g0r8JgMCfwnAOiwtT7NvnMz9vKyo1qnXW1yaY0i0mlqtM9hvUqWAkpNWEtl7k2PJ+jszfz1JyjH7aBimpNqaQwSQqHSNNW0g5gvBGQTSpeoq6WqLWOUKweJBqb55KtEA1WqASLaLChKXxkGMjMFOLOFbXLDSLtAoLTfAaPhNSMJGmTMQDJtKYCaUdqyZj1oBvWgxMi3nT4JhqMK8bLNJi0TRYoGVLFJoWi6JFOxxhyWsRBaEtYO5nuXbK6RTstgig5lvFa83vUxNt6mI41069lG+n5qRUNtlWSqBT/DTFSxWeUhjloVWAKpUPPD7vjo9RIUKHSBUgVAWpQjwdIFUF3/j4+Nbtwiq5dSgKbGT+a4zBaA1GgVGIzB2irYvDHOePX5FHZ0VaBA0oo50/HrRxwWMDyrkyFAJtBEaUlaEFTWe16kkCL3dZZEHiPIVBiUroAVJrF/TNxFupDRpngWHHRMp88Hl6AqNswjZStFDOh57mPnYllQMn62NXDpSUVKQiCw6rYTbSCrZSthQ+cOff9gBhnOemBFCiCAQjsQwZd0y2tqJsC1IejpHkArpZrhsf6ysvc+eFKKZh6dxLQhT7pAMyhESKbFzpWIHbb7e1cCAlitxKWVtnT/BZ1k9kAXT5mOI4k7WBV738iw8N944Q4kLgk8CzjTH3fKcP/k6TvtaGT/3ZzczsWeb5v/JopneMMbjrLva/8edRCwts+M3fYPTHfozP7vks77rhXSxGizzv9Ofxc+e9lq27vgTX/hUsPQCTO0gueCVf9C7n/TtTbty3AMAFm0c5+/Rx5sd8btQJM0kKwNl1n0eHxzhd3cTW3udopbsBkLKBEKfT667n2LEqhw9L+v0WIKlXakxURhk3DUb6FUZ7FcZ0gxohCEjChJ5us9Q/auvaJraubV+10WiC2hieP4Y2LVTaAJGxaZoI2cSTgc1DEy8SducIOscsgyZu52kVwrhNWhnQcXl2FiopC1XlGDW2RGHbtdOagKqg6htGtGYkjRhRKq9ZO+Lq12ZLRQdIYwujRLrGsq6xbGq0Td2WHXTrZVd+sE3dpljz6vS8Kl2vRtezClgCOZQ+wfjCFuPwhytA+Z4i9FJCGRF6MVXZpyoHVL2IqihKAx6fIqGoEBWYhMCk+Frju4nOUwpPa3ytkMq5no7Ls7NKDh6TURKlS4vgIVRgRT7Kt352HViVqg6Qbu2ZIC/5VzhcVi+QIU3mczYlENKFfz5zabj+fNGZj77wuRfB4aLikqFoa2MsUwmbnTTztet8bYaCx7Zf5MHl/0rQ2P5bSn504zSoxljRksm47/bf7GXbpfQGnjEIY7+7wreeBYr1qtsGe0+MKNYaG+A1ZCDm8u2QBYdNDmhZvV8lClDTju1kt01ehEZLUQR6JWhh8pcGS+s0LsDrgr9ZpNytc3BzlE8hCpCTWZ9jNv3eW/f8t0/6PjaQewVwEBvI/XFjzB2lMacAXwV+0hhzzXfzwd9p0gfod2I+/n++zaCT8Jyfv5DpHWOkc3Mc/B+/Su+666g/7nFs/J3fJt66nn+4/R/40J0fItEJT9n6FF511it5zNwB5I3vhQeuBQRseyLzW6/gC8mj+Oj9FW49YIO4E42Q87aNUZmqcagmuFOkDNx9mQ4FZ4VttrGP6fgm1kfXMMVR+wMWFQTTRPE62st15uY82u0q/X4LrQNCP2AkbNISNVpplUY/oJlWaDl6ZYiP8hSRGNBP27QHcyz3jtFXbXpp21Wq6pGYGL/SQnpNDA20qmGoIkR9BZumSiA8KjoijNv4UdtVn+rmTJo8tULaQ5o+SRARBxG90KZV6Dg2TZlF063gUi0IogqYUCADg+9pKkLT1CkNY1k0WToFm15hOKVCqEGaIGfEKBWS6gqprrjn/wp9Y8sM9l07IsiLf2TtSAREssLACxmIkL6sEHkhfa9K5FWIvcCWFMzogrnCVRQUwtK25+lcDBTIZGjty5Qw74ttYQ5RqFeDIWVqclw7wCYJ8xwl0zPaZbY0zhXkGDCOuikydow2oK1/24p6hFWmlhSoZYVqtqA90B7COBWqS4+Q9UnjWQWq9ou2caClXCoFk0UGivQHZT/8sN/dMVEykKIALeMm9lxZqlf44LXO/e3kAWft/OhZILlIcZD3OT+7dn5zXWrbfrGCBVX41O34zH8uSn3WeZIFlrOn6uF0CPa9IA8emzw0TJ6Hx4jSOrsXpTw9phQ4pgC6gimVBePtm1sRQC7EXy/893f+QCibzwH+HAvr7zPG/IEQ4ucAjDF/K4R4D/BjQOakT7/TRX03kz7A8lyfz7z7VtpzA5708jM497JpMIbFf/lXjr7rXehul5EffS5Tr389y5vH+Oiuj/LPu/6ZxWiRjY2NXLn9Sq6cuIBz9t2EvPOTMHu3PfHEafSmL+UO/xy+2DmVz+yrcKQdAVALPLZvaNKarNJv+cyEsF8am28FGPFge9hnk5hjvd7LZHwH69S9bOQwVQbuno2h1CRRNEK3G7K85NHrVYvyhWlI6IXU/SoNUaWuQ2pxQC0J8hKGGXMmwEdLRcyAQdqlFy/Tj5bz0oWRHpDoAbFbUjTaCywg5IWxKy4QuoJFI22/jyQw2MCn6uPFfVu+MGfS9PHTKE+p4KURvuojVITxUlIvtmIkL2LgxQxCkzNoojKbJhBD/VnQU/jCBTsNnjR4UuM7Vk0oDFUy4CgCnisDnBVT5FO3E5kVCmF8lCumok3g+rLgZFGIo6xYLVSs3nARD+MTC7+kXrX7IqdiXalqTZ1AKJUeiQhQUmKkPIFqVZRSLNi1dWVo52t3Ah5pBT6+VEiR4kuNJ1I8acU/vkhzZWsgbPoFz60zNWvGFi/SKgz3Z4pUz6jcbeQ5amb2BC4dhVM4larIJqpsAtNmaEITOpvgCtVpxosv0ic4PqTzgRsz7CMv/OtevmTbaDm0LVaOdWkWMNKJzbwyjBXBZFP2sps8kJyDG1lw2eTrrD9nULm+4bUZ2m/ycdqNyYLQWfDZvpFlYzPQe+4//OYPjzjrRDboJHzhPTs5cPcC2y6Y5LKXnMHYhjrp3Bxz730fCx/+MGYwoHbxxYy99KWET72Mr85/i8/v+TxXH7qaVKdMVCd4/KbHc+noWVzcnmPL3usR+6+DyD7tm8Z6eusezf7wNG5LtvCfyxv4ytEGvcRegxSwfrTKyFgV0bR8+nkf5nwwNc8OACY8xXqvz6RYYMLMMKYeYDTdxySzjDPPKIuEJEAFo0dJVcNWp+oHdHseUVSULbSLZc9UvSpVaStTVXVAJfWpKp/QlSwMcgaNnxca8YTBmJREx8SqzyDpEquBDXrqmMTEq7ZTNKmwQqXUQFaFyipiw7zilHDbRRWqkEzIJMAVoi5UsH6S4JkUTzl1q4rxdJQXBRGmUMVm+dk9nbogZ4oSCVqmpCIhdarXVCYusJmS+HqoyMew31gc3+8ejMm9FJlz3LUduybzJwsX7BQu0JmrWinypK/Mtb5afnXh6qCKUgCQfELzcnGQTWfshEB50RYrCDLGTtkYq1rNpu/EJR6watasz07nuQJWuIIfolCspsIpXoXtz9SuqZCobC09GzR1Y+y2R+r6U2n7V03NUFatSmPdOw7QCoGWBbPhxeChELmKNVO7qlzhmqtWhQ3d+m6fL7J26tStFgyLMK8NB5M9YVtd8dBTtU2MkLmUiqfv7AleZk/tpugr7x8ao1eOAeleR/JsptrSQe2kVKResOBn16//2Y/98E/6AEYbbvvaAb716d3oRHP2EzZy4RVbmZxuks7Ps/TJf2PxX/6FeO9eCAIaj30szac9DX3xeVwb7OOaI9/imkPXMD+YB2C8Ms75U+dzQW0DZ0YRp80fYOuRu/Dn7nMoC8avEY1uZ6GyhYNiE7uSddzaneCGxRYH1BgJfn59o42QRivAq/mkFY++L1j2DINAWApl6EFg/xgaQjEmB4yKDqMsucpUszT1TF6Vqk6XRl6hqotvfLSuopStTJXEPlHkkySWKZMvKrCFSJSPVgFGWX+8r+quTKGHrz0CnRUSsUyZle2AotiIjam5pxStMTpFKcuYGWLJ6KJQyPEsmiz3e5r7jpXzEWf+YoVzYwjJqsrXPOXtKoFN4Z7wyObu7LVY2NS3UChhDQiXBExo4/zF6ZC4qFDAZn7i1ImKijztGAXYIiFWSOT86MLy2zOhkHFBUOWKiGhhcpWsEZrUs+NTT9t+l7e9rHS1S6GGVWJ4n1nhQ87EPpknQjjVq/URr/QZ220pna/dKWKlC4hm21mANBMKBcYqXe23UqhgLQuGnKWSXUjeziYwnIPbgZ7JePbGA5wby54RnALW5qexMRYyMES6fZaCagHR1SQzckjhmrN7hF20+71l7B4tBEp4+RgtSsdIey2qND4bk/eJ4XNoKUvnskBp2Ukrj7FtJWSe1kG47yL38WMD2Ht++umPjEk/s+5SxI1X7eWuaw+jEs2m00c5/eL1nHbROprjFfo330z7K1+h89WvEe/ZA4A3OkrtoouoXngBc9NN7p7oc5M4wO3zO7l/8f6MWUsgA7a1tnJqZZKtxmN60GVTd5Hp9gzT8/upp9HQtSTVSTqVDcx7U8yYCfano+yL6uzr15hJmyzQYs6MsEQDg8T3BNWqjx96SFd5KvEFkSfoe+SVqEwgXb74othIxUtpyoSGGNCkS910qJgOVbNMaLpUGeSMmCoDqvTdumiHOrW5VBQ5+yVNfdLEcznfS4VEvkNBEbQPOnTBywChQoQKLHvGBS495BBDZriISDEmS6FbDmpmTz4m93EajFZObKRy3y/aMmry1LblVLdDgqPMN+wm5JV9AvsKbTKGtmXa2AexjIM9HOQ0ppQ6N6MdOqHRsLCoHNh8EFFRRl8pBz2xJO0hEVHuH17FV1x60iyArxASyaE2QPFUm+234qFCOLRy2+BEQyZTweaedbSwd0rnwVPHac9UssLYNTZoavvdWmpU3lcsdp+x32f5PDJrF3Vus8Lr9gHZ5Lc1x54soCpKtzwbB7la1jgwzBW32dqNsY1sXxaAdU/rWTvvd99JPqYUmMUeP5y/zuQAmcUGsjYI3vCW3Y+sST+zfifmzm8e4t4bZpg72AVgbEOd6TPHmN4xxrqtLerRLIObbqJ307fpf/sm+xbgTNbrhDt2IDdvorOuwey4ZF9zwK7qAjvNIfZHh0l1OvSZo0GLdUGTSREwaSSTKmUyiZjqt5nsLjDeX3SMF5tHxnPHGSSDYJSOP0ZbjLCMKyqiqiykFWaTKou6RtsxX5ZNnbZjwvSo0KdCInz8wMfLAMFVnFIZ/c09ipUZMCu3s7bwBIFUBL4i8FJCGVMRCYGxyYDDVQuLFO0wz+FYKupcCmp67ilaao1P5gN2tEGlS0FLY5kzJ0ihe/x2xqBZmX0wew0ucaFNEdDMFumeDslT6pbGDo1z8FPy7R4nICr5f1ftd8AF2SSdtYvAp/1xlAKdmf/XOOlO/pqfhR+xQAe5H3ho2x2j87bOz+M8wiVh0WpCpCwUml2GccpZA3kfdhI1Dviy/tI/x/bbgWblcfmY7BjhPgf3RC+Kcw0torgdOJeRnTIdSIr8Huegmd/z4m+48M+LwgefT6vl/dm+8vlMPr4AYFOcdxVQdv/CIYDO/PpDY3LAtec0LrRsMBZUyL4bwws+/1ePzEm/bAtHuuy9fY5D9yxw6N5F4oGV23iBZHK6wcR0g9F1NZotSa03Szi7B3bvIt59P8mBAySHD4NSQ+eUo6OIqXGS8Sbd0SpLTcF8JWUujJkN+sx4XQ57beaCiE4VkkAMHS8QNL2QERnSwmPECEa0pqVSGmlCPY2pJwPqSZ+a1nm+mLo21I2m5tZ1J/0XeMSyQizds7twTBcT0tUVOiako0O6OiRyU3aUFX3Ocr+vyPMeuxzxMQGJCIm8kETaXO+J9F0g0oKLEbbASP448t3mfM/9uAxnI3T7M19sFpzMfbXZNjZAKZ3f1gYoC19u4aMtlsxnO7xdluuk+f6yf1c6cqIkk8WvYFdQBCmLP+Qyw2LlvtIffLnPuZcymiKUfcKAoTQBuKCne4tglTYnGJP15z7h7JE3FyC5qW+17VI7kwXhGDzkT6FunMncN9JNkpl4KRMYFYKn/JxGHPcZK8dl26J8HJnbyP6NWeghn5ghRyX3d0iBSBST6pBlk7tr52ONKB9cOq74jHxizgCbIvBr8vM6CCwDu+sVGcDnn23c/6Z0DjP0Gc/9u19fm/TLprVh/lCXuQNtZg90OLa/zeKRHt2leGic50vqIyH10ZB6K6Dqp1R1F6+/iN9bQnYWkMuzyPkZxLFDiJkDyDg6waeCCQN0s46qBSRVnziURBVJP4BeoOkGiraXsuzHLHsJHS8h8k1J0u+UlD7EnpX3Z6rK2AdPSirCo4IgRFimCk6qrzUVbWvChjol1IqKUsfJ+FeKU1YWbC6KNZfFLMY++QpJVoACMlaFjzZW8aiN59Lj+sU6Cxy6AGORJrecEkC6tjxOMVleMr9q6vy5wxkI3THON5piMxIqJKnzpabZ5zkfaubTNULmClAtPAturp2rQYVXUop6rq/wyxoy0MtAjZIvwP1AStsm7xel/aW+oeNcRkqyhfzJL/fTY33xtp/CD0xpnR3ntu05XVByyAWh8+Okm0klOt8WQud+/+L82hWQd+csXa8UOt+fBUpxY+15lDsuGwsCNXS+4loz4C3fjwxUyfdjbHQAo/N++0fqnphz91kJGCg9iZM98WeAUjzBG9y58/MUk3x27nK72D/8hnfC44pXKaT7vOzNIruuX/6Jj3xPk77/nYc8vExKwdSWJlNbmpxV6k9iRfvYgKVjfZZn+3QXI7rLEb2lmKVjAw4tRUTdFGi6xaUOGnXL6eCHkiAU+B62IpFQlo3i8rnI1FIZvaSPjPuIuE9tMKC+2GNq0EMMuiVmSiHFL8vzRZ5K1wYQsx+L9gwqABVIlC/RnnBpbgXKk07paEiFIXbrRGpiqYmFJvVgUEqHWxRpFi5Xe9kvOpxdsNxfzjJYrDXay9SaUZnGXOTKcn81mf80zzQI+R+4XbsXAWNy/2b+MmGyrIOGEBdAdH/ghdYlDwc6Io79nIyQI0r7M21MPsZk3nVTGl/qM1kSrtJ26Z+HyVw67kk46yumlXw7m6q168unGyPztqHcdhRHivNnU51xfl9jCgTJjs+uIZvaNCvOUbre8jnJ3TTlfnvNaPJ+vQK1dOn6h85pxIpjytN0eQrHwQH524su7yulZMCN1aJ8bOlcws/7HdzYz84VscXYoc8o7aP0uSv3s1o7Hy/zsfZ2Hn/uXGnrrsmeI/v3r/K5WXCBj/C92A/dpH8iC0KPCefqOZGpRDPoJUS91C3Ht5NI5Usa2/UgLvoSo0mVwmXp/b5Y8WRW/DwzV0TmXsiUiDJTJjrZfU0r6joFoxAqhdQxT7R2hUDcz84lnxJZ262H9mdPVaX9x/eZ/Glr1T4MGTsq82+Wn6hW7Xfb2VSSJbmyf0w2u6MwuKAhLrCYbdtZuvCI6iLIZwzazf72PPbsWqw4ZsV++yBmgbXYpjim5ETOjsnORf6kX9RRpbRN9qDnPjc7R/4vL70pFCHn0pjSMcePN0Ofnd2jlceXr2v4+FX6jxsjin9TeXzxY863y+MKT34xxt2uoXGIVZv5vzcbX4YVhGXkZvd2yFbZFvl3kJ89P0/5MHNcnzn+fOUhx32Wyc9z3GFiRZ8oPvOzx3/Ef8keMZP+d2NeIGmMVmiMfm+ztTGGNNGoRKNSu+jUoFJt+12fSor+oSUxaK3RythFG4xba237jNL5timNGxpbPl4XbYzrM4C2n2XnfDvOGNy63MYe5+a5k+QVXLPv0sSK9fdkWbA4P6f78vPfgMk38s8z5TGlfaa0rzStrn7Olceu/NGd4DNXnHvVa1912Hd7zIl+/MP9Q/f+BNd2/PdjVm0Ob7zqBJ//3dnapP/fYEIIgtAjCL3vPPhhaln6WgsUrACIE/StaOd/56VtyzbJ/ka+y3GmeErOr4tSvy6Nx14D2fhs3CrnNaY8zhRz34rPG4r9rZgQjp+nzHF9xbYpto8bs8p588tbOWE+yHWUPuuE12FMMfRE13H8nJ6zf4a2y99j+dyl7ey7Hp7ni2NWfg9DH7xyTPnc5Y3Sha68luP/reVrKd2LFQ2z2vjj9q04+dB3NNxxwvOVv+cT4c1/wdYm/TX7fzKRC0iyd+c1W7M1+4HY//zeDpffeciardmardma/bDY2qS/Zmu2Zmv2CLK1SX/N1mzN1uwRZGuT/pqt2Zqt2SPI1ib9NVuzNVuzR5CtTfprtmZrtmaPIFub9NdszdZszR5Btjbpr9mardmaPYLspGXZFEK0gV0n5cP/azYFHDvZF/Fd2Np1fn/t4XCdD4drhLXr/H7bWcaY1v/rwSdTkbvre0kP+oMyIcSNa9f5/bO16/z+2cPhGmHtOr/fJoT4nnLSr7l31mzN1mzNHkG2Numv2Zqt2Zo9guxkTvp/fxI/+79ia9f5/bW16/z+2cPhGmHtOr/f9j1d50kL5K7Zmq3Zmq3ZD97W3DtrtmZrtmaPIFub9NdszdZszR5BdlImfSHElUKIXUKI+4QQbzsZ17DShBBbhRBfE0LcJYS4Qwjxy67/d4UQB4UQt7jlOQ+Ba90rhLjdXc+Nrm9CCPElIcS9bj1+kq/xrNI9u0UIsSyE+JWHwv0UQrxPCHFUCLGz1HfC+yeE+HX3W90lhHjWSb7OPxZC3C2EuE0I8UkhxJjr3y6E6Jfu69+e5Os84ff8ELufHytd414hxC2u/6TczweZh75/v09b7u0Ht2DrLN0PnAaEwK3AuT/o61jlujYBF7t2C7gHOBf4XeAtJ/v6VlzrXmBqRd//Ad7m2m8D/vfJvs4V3/kRYNtD4X4ClwMXAzu/0/1zv4FbsWXuT3W/Xe8kXuczAd+1/3fpOreXxz0E7ueq3/ND7X6u2P8nwG+fzPv5IPPQ9+33eTKe9B8H3GeM2W2MiYGPAi84CdcxZMaYw8aYm1y7DdwFbD65V/VfshcAH3TtDwIvPHmXcpxdAdxvjNl3si8EwBjzDWB+RfeJ7t8LgI8aYyJjzB7gPuxv+KRcpzHmi8aY1G1+C9jyg7iWB7MT3M8T2UPqfmYmhBDAy4CP/CCu5UT2IPPQ9+33eTIm/c3A/tL2AR5ik6sQYjtwEXCd6/pF9zr9vpPtNnFmgC8KIb4thHiD69tgjDkM9ocDrD9pV3e8vYLhP6aH2v2EE9+/h/Lv9bXA50rbpwohbhZCfF0I8aSTdVElW+17fqjezycBM8aYe0t9J/V+rpiHvm+/z5Mx6YtV+h4yvFEhRBP4OPArxphl4G+A04FHA4exr4An255ojLkYeDbwC0KIy0/2BZ3IhBAh8HzgX1zXQ/F+Ppg9JH+vQojfAFLgQ67rMHCKMeYi4H8AHxZCjJys6+PE3/ND8n4Cr2T4weSk3s9V5qETDl2l70Hv58mY9A8AW0vbW4BDJ+E6jjMhRIC90R8yxnwCwBgzY4xRxhgN/AM/oFfRBzNjzCG3Pgp8EntNM0KITQBuffTkXeGQPRu4yRgzAw/N++nsRPfvIfd7FUK8BvhR4CeMc+y61/s51/421rd75sm6xgf5nh+K99MHXgx8LOs7mfdztXmI7+Pv82RM+jcAZwghTnVPga8APn0SrmPInE/vvcBdxpg/LfVvKg17EbBz5bE/SBNCNIQQrayNDeztxN7D17hhrwE+dXKu8DgbeoJ6qN3Pkp3o/n0aeIUQoiKEOBU4A7j+JFwfYJlvwFuB5xtjeqX+dUIIz7VPw17n7pNzlQ/6PT+k7qezpwN3G2MOZB0n636eaB7i+/n7/EFHp92DyXOwUen7gd84GdewyjVdhn0tug24xS3PAf4JuN31fxrYdJKv8zRstP5W4I7s/gGTwFeAe9164iFwT+vAHDBa6jvp9xMLQoeBBPuk9LoHu3/Ab7jf6i7g2Sf5Ou/D+nCz3+jfurE/5n4PtwI3Ac87ydd5wu/5oXQ/Xf8HgJ9bMfak3M8HmYe+b7/PtTQMa7Zma7ZmjyBbU+Su2Zqt2Zo9gmxt0l+zNVuzNXsE2dqkv2ZrtmZr9giytUl/zdZszdbsEWRrk/6ardmardkjyNYm/TVbszVbs0eQrU36a7Zma7ZmjyD7/wGQPToZ5EC7QgAAAABJRU5ErkJggg==\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD4CAYAAAAAczaOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAADGkUlEQVR4nOzdd5wkR33//1dVdZy4Oe/l0+VTDigjIUQyGQwWJhhMxv4BxsbY2AaMbQw2wQhjcs5BJCEJJJSl0wWFyzlsvk0zO7Fj/f6YuSAZwxnk73Kin49HX3fP9O7W7M593l3VYYTWmkQikUj8fpDz3YBEIpFI/L+TFP1EIpH4PZIU/UQikfg9khT9RCKR+D2SFP1EIpH4PWLM1w/u6OjQixYtmq8fn0gkEqelzZs3T2mtO3/Tr5+3or9o0SI2bdo0Xz8+kUgkTktCiMO/zdcnwzuJRCLxeyQp+olEIvF7JCn6iUQi8XskKfqJRCLxeyQp+olEIvF75NcWfSHE54QQR4UQ2/6H54UQ4mNCiH1CiEeEEOc8/s1MJBKJxOPhVPb0vwA87Vc8/3RgeXN6LfCfv32zEolEIvF/4deep6+1vlMIsehXbPIc4Eu6cY/m+4UQLUKIXq312K/6vpOHRviPN70Fs3MLmYMVaj0mU2INtK2g7cBWnvzWd3LGivX/u1eTSCQSiV/p8RjT7weGTlofbj723wghXiuE2CSE2KRFDhU8i3jPLD1D5yP3+FxalmzoTNHpr+X7N37ycWhaIpFIJE72eBR98Use+6WfzKK1/pTW+jyt9XlClxBaY0UXs/uMl2Ial+O7ZZZUjuA7kkIw/Tg0LZFIJBInezyK/jAweNL6ADB6Kl+ohcCOewGwA4uSW0UHAbGrEbXK49C0RCKRSJzs8Sj6PwRe3jyL5yKg+OvG8xsanQEjMgFQOkPVqiPCOtKKcOrh49C0RCKRSJzs1x7IFUJ8HbgS6BBCDAN/D5gAWutPAjcCzwD2AVXgVaf+4wXINACxylJVdVRUR5ohdvl/9ToSiUQicQpO5eydl/6a5zXwpt/kh2sh8IwUUXCQwLCJIh9D1MEMsfxfdqggkUgkEr+Nebu1coNgzpggKG+iLM9GN4u+NgOMUM1v0xKJROIJaN5vw1BXjbN0QqnRQYQReURmhAwNgqA6z61LJBKJJ5b5LfpCEqnGAdtIhOggwox9PBtUaDFVnJzX5iUSicQTzbzv6ccqasyFh/ZjjNDHNzVEBsNTR+e5dYlEIvHEMu9FXwifvNmB1j7CNzGiCN8UyNjiyNTUfDcvkUgknlDmvejn3RaeNvBqBtxeROiiYvBMjY4NhguF+W5eIpFIPKHMe9F3rQwAKeUggxQqUvgShDYplkvz3LpEIpF4YpnHot+4IjekMaZvSQMRplCxoKoUhrCoVpNbMSQSicTjaf6KfvPaKy0bTUgpFxG4WDHUhIHCIgiSPf1EIpF4PM3zxVmghIFPiCltZJzCiSV1DJSCIEr29BOJROLxNO9j+hVZ5UvOHRStCBFbmEBdGChhQJxcnJVIJBKPp9+Bou8BUDJCZGwihKaOhZQKHSVFP5FIJB5P8170dRwDEEmBwEQrja8NhFSYYVL0E4lE4vE070U/bp69U5cRWisiFRPFCgyF6yX3V04kEonH07wXfXTj1M1ARAhpEBkaEWlQAsuvzXPjEolE4oll3ou+VBEXPelbkBlHGjaRjBAxCCkx/fp8Ny+RSCSeUOa96NtWDdP0sFqGEIaJjmNk1Cj6lu+h9S/9jPVEIpFI/AbmvejruNkEs4ZSJugIFUagIsxAUS3PzW8DE4lE4glk3ov+sUtzpVVCKQMdRxhRjLBCjMBieHJontuXSCQSTxzzXvR11Cj6yqwjlYQoxohiMEOUZ3Nw7Mg8tzCRSCSeOOb9hmsFWvln/o6ClUVIRRxozCgCM0aGDgenZ+aviYlEIvEEM29F/9jhWaE128SZ7LcXIw0gUpiRB2YEkcNoKbn/TiKRSDxe5n14R+nGFblllQEpILSRug5miAgdyvXkqtxEIpF4vMx70SdqFP2iyqGVhNBFxXW0GYB2iILkAq1EIpF4vMx70TciQGtKMouQIEMHFdeJDR8Rm+gwuUArkUgkHi/z/iEqCI2xq0gpSBNbATpwcXQJz9QIrSBOxvQTiUTi8TLve/pojXGkwuxUFuwAEbukdJmaqVHSTop+IpFIPI7mvei30riTZt2z0ZaPiG0yUZmqCVLamHHykYmJRCLxeJn3og8giPE9E23WEdokFVWpGRJpWljJ5+QmEonE42bei75G4uITeorYqiO0hR17eKZEKoOUN0fgB/PdzEQikXhCmPeiXxfwUnUbRuDjWSGgEPhUpIlSJrZXZWo8uRVDIpFIPB7mveh7SN5tfoUn+w9StWOkskEEVIWFlBLLr3NgeO98NzORSCSeEOa96AsEAdAbTjYO3iobEcfUtI1QAsOD/ZNj893MRCKReEL4nSj6VSnoiWeoWRJhWIhAUMNGKpC+w8FyctpmIpFIPB7mveinapqakHTFM9RNiTRMdAQ17SKlwPAzTHjRfDczkUgknhDm/YpcIQUPWJ20UKEsLYRS6FBSiy20FOBn8SN/3pqZSCQSTyTzvqevteA97SZH3TkqpBofpBJCEFqgBDLIIMOk6CcSicTj4ZSKvhDiaUKI3UKIfUKId/6S5/NCiB8JIR4WQmwXQrzqVBsQK4UdQNH0qMQuGAoiEIFG2zEqTmMkd9pMJBKJx8WvLfpCCAVcDzwdWA28VAix+jGbvQnYobU+E7gS+DchhHUqDdDCxAqgaviNoq8EBBIziMHyUZGNESVX5SYSicTj4VT29C8A9mmtD2itfeAbwHMes40GskIIAWSAGSA8lQZoAa4vKauIauQ2WhQ6WGFAbHsgTMx4lihMDuYmEonEb+tUin4/MHTS+nDzsZN9HFgFjAJbgT/XuvmRWCcRQrxWCLFJCLHp+GPE9PtZyiqmHloIBTpM4QQB2vLQmFhxgemRkf/1i0skEonEo51K0Re/5DH9mPVrgYeAPuAs4ONCiNx/+yKtP6W1Pk9rfd7xx2Kft3zdJ6pLDF+jrQBCh1xQJTKrxKZJyiuwb99Dp/qaEolEIvE/OJWiPwwMnrQ+QGOP/mSvAr6nG/YBB4GVp9IAAUTKomNEYfkhWAE6StEezBKaVYRh4vgl9k0O/drvlUgkEolf7VSK/kZguRBicfPg7EuAHz5mmyPA1QBCiG5gBXDgV35X0ehAaA2htDBqAifwwPYRkUtbPE3VijAME9PzOOQlZ/AkEonEb8v4dRtorUMhxJuBmwEFfE5rvV0I8frm858E3gd8QQixlcbO+19pradOpQECTWBY2FVBOvDQpoeOXVrjGSp2B1lloOoRw3reLylIJBKJ096vLfoAWusbgRsf89gnT1oeBZ76mzTAlCkq+QxuRZAKK0SWj9A2KT3EpNWFKUF4KQqR+k2+fSKRSCRO8juw+xwz3nU+6TpkoxKeHQE2QpapmyaGEohaK0aYfJBKIpFI/LbmreiLY+cEaUEptQRTL8DVBaoWgEUsa9RU4/bKys/jJGP6iUQi8Vubxz3941UfRYQSPVh6jqqtkYZDLHzK0kUqiePnSflFvEp9/pqbSCQSTwDzPrzj4SOJUWSxKFMzBcK0iKOQsk6BYWFFadLxBIe3bZ7v5iYSicRpbf5vrYxA4SNEDiUr1AwFhkUcakpRGq0MwMVhiv37H5m35iYSicQTwfyN6R+r+hpMWSMysihdoyRtpFJEoaAcZoitkFBZ2NE0B2oz89XcRCKReEL4HdjTB7++hcBwUaFHWbsIKYgCQTlIEzs1PFNh+WUOn9IJpolEIpH4n8z7gVzD8BDSpKaqqKBZ9E1JFChiTxE6JWLDQNYDhkRq/pqbSCQSTwC/A6dsgpQmvgxRYUQtclASdJDB8QMCcw7DNImrglqQXKCVSCQSv41539MHgVImoYwRfkw1dBBKgZehvV4kskpYAmQlQ7rm4VeT8/UTiUTiN/U7sKcvsByHSIToQBCHCqFA+lkGgqP4dg1Hgl1tp6Ve4uCWh+eryYlEInHam8cDuY2qLzTYjkuMh/ZNTD8CM0J5KQb8CSq2xJaCbL2dFn+CQ3s3/ZpvnEgkEon/ybyfsjmnW+hJD4CuI7w0jh+AG6JCl95wgqpjoQyFG7SSYpTD/sR8NTmRSCROe/M+vCPQBNIjb6SQQRon8NGWjxE5pMQUNctGGg6CHEpNMuLOV4sTiUTi9Pc7MbxTUz5Z5aKCNJmgRmz6KG0jZJGK4YBpU7McjKDIISM7b01OJBKJ09087ukfK/qasuVjSwMjSpGJKkSWBxgEqkZRZIkNk7plIqo+R8McQc2br2YnEonEaW3+9/TRVM0QW1qYoUsmLlJ1ApAWvgiYDVsIzBDPAL9qYFVDDtyf3IMnkUgkfhO/A3v6gooRYCsbI3ZxdJGqHaItGz/QzPoteO4sSgFlh+5SkQPb75uvZicSicRpbd7P3pH1kKJZw5IuUttYlKjaIAyHyBMU/Ry+M40rYnLldvq8I4zp0flqdiKRSJzW5n1PH6Bo+AhlooWNKcrULTAMg7AuqdRdQruAK2Naa220cJjhFj1fzU4kEonT2u/AmL4gVFA1YyJloOIKFWWglCTyTLL1KpFdxJWSlN+OaR7loN1CHMfz1vREIpE4Xc37nr4EQqUIlCBQCjOsU5ZplILYy7O0OkzoRFhmmtBoJ9RzDAcdDG/ZM19NTyQSidPWvI/pg8YXBpGUBEqiQo85ncJQEum1sNQfoeraKCtF2U1RrYBftth1573z1fREIpE4bc3bx5KIky7OCoUikhBKgQhDynEaYQiMIMeCYIQJJ4W2XKqWgT9n0F+aYiaanK+mJxKJxGlr3od3BIJASnwRoZUCP2oUfSVwggyt8QRlK01kKHwV4BRsVlT3Mdblz1fTE4lE4rQ17/feAU1sgE+AoSQ6gLrnELsRZuhiGjPMyBYqRgUHj665LjrEPg7mUniV+nw1P5FIJE5L8372Tp+YIRQCT9ZRUhL5BsqLiZ06QjuEZpnxejdVd4KM1LTUuzDtMfbFfWz7/p3z1vxEIpE4Hc37gVyhwdM2Oj2FKTTCT2P5EbFdI5YmHgFT9XZ8d4qMMrHiLqqqzESpg8N7Hpyv5icSicRpad7H9DWCIFQIZwZTgAzSuJ5HZFcITYO6D4V6ntiZJm1mKKfaKJQNumYL1FrG56v5iUQicVqa9+EdjURGktisYkqBDNJkgxq+WUGaNn5NUa3ZGG4Fy8ox5zr4syary/sY7omoV5LPzE0kEolTNe97+gCEgFHHEhIzTJEPCpScGMM08OqKpdVhvJREWy41EzomTZbHO9mbaePhr/5svl5CIpFInHbmb0+/Sevmh6EbdQwhsSKXTDxDxdGYUhFXLdbX9jCXShOYijieoX+2G9c9yJ76Eo7s3TXfLyGRSCROG/M+vAOCKLIwDB+hFEbskmaGmqWwBKhqGyu8wxTsLEVZJS188l4/RXuOmekWoq5kXD+RSCRO1e/A8I5AxwrD8JHKQsUuNkVqpoU0Ja7XRl80ylHRRckdJ2cYeE4/I3WLdbN7Ge+tMvzg7vl6GYlEInFamcfhnRNn78hIo40IrQy0sDBUmaLMIJQi7bdgmJOMeAP46VFazFaKmTa8WZOzqzvZ35Lj4W8l4/qJRCJxKubxPP0mLXBij7KVRiiDSJooyhR1FkwDI8rhWxXGq52I1DQpu52SY9M/Jlhg7WKrv5qynpuvl5FIJBKnlXkf09cInMijZGbQUhEYBkZYpxDl0aZCyxQlFTBba8FNzSHsNCFFlhxtI04NMTzdRzgwzNF9Q/P2UhKJROJ0cUpFXwjxNCHEbiHEPiHEO/+Hba4UQjwkhNguhLjjf9MIJ/apqBSxkgSGQoUBBT9P7NbxTJNqCFEVvLTEsxQynibvLWGXIVkztZdDvSEbPvXd/82PTCQSid9Lv7boCyEUcD3wdGA18FIhxOrHbNMCfAJ4ttZ6DfCiX/uTm+M7RwwLN/LwlEUsBYEUaD+i7KXQbgXPUHgVg6XlIWZSeWZFmawMKGUXMVlwuLjyMHvSg9SD6H/50hOJROL3z6ns6V8A7NNaH9Ba+8A3gOc8Zps/Ar6ntT4CoLU+euoNENhRjbq0CaUmloIwkBh1TWAXkJaJXza4oLKVcbObgjlFi5mnkO2hbUKy0tzKQ4V1hH1HGdqy7VR/bCKRSPxeOpWi3w+cPGA+3HzsZGcArUKI24UQm4UQL/9l30gI8VohxCYhxKbp6Znjj9tRnZpIERgVpCEJA0GqXiOwi1iGhLLLumA/Q/Eg9fxh2uxeyrZgxbBJlBqmMuUy3TfMfZ++4X/36hOJROL3zKkUffFLHtOPWTeAc4FnAtcC7xZCnPHfvkjrT2mtz9Nan9fR0d745hosXaNKulH0pST0FB1egZIb4gqNW25joRjmcG0hdnoKx+0giiYYLAyyyTG5dGoL+zp7UE6aKAj/d7+BRCKR+D1yKkV/GBg8aX0AGP0l29ykta5oraeAO4EzT7UJhq5TJUVkVDGERvgp2v0iJVfgSEVLrRVtTzFR6cTNzFK3FCqeopZaxmjR4erwAe6tXIg/MMZNH/6vU/uxiUQi8XvoVIr+RmC5EGKxEMICXgL88DHb/AC4TAhhCCFSwIXAzlNpgNCgdJ0aKSKz0rj1QpCmM5imZtsoyyTlt1AwPcIy+FnJpJyj1ZDMtCxn4RHBQvcRRie6mO47TG1v6X/z+hOJROL3yq8t+lrrEHgzcDONQv4trfV2IcTrhRCvb26zE7gJeAR4APiM1vpXH1UVJxYkHhWdIjaqmAJc3yWnj1IxHTAdhGhlUoFbqjLptjKtZmm3u5lNO6w9rNid8lk/sYN97f2IthSbfvTj3/gXkkgkEk9kp3Sevtb6Rq31GVrrpVrr9zcf+6TW+pMnbfNBrfVqrfVarfVHfv13PfHB6FIEVMIU2qhhCYkbpEipGYoiS2yYVJw0c57J6tI+DovF1HJHaLP7iKJRustLuddweWqwkXtrT6I8sIOd37n3N/ldJBKJxBPevN9aGUBKn2qYArNxe2U3SGMaRWaiVkITapZFtWJwqf8w++NlOJmjWKkOCEco5ldgjJhcYD7A6Fgnc4OTtLT08uAdv5jvl5VIJBK/c+a96EstEMKnFjqg6phSYkUZpFFmxmshSM3hGxCVFGeLfeyvLCGbP8qkKtGiNNMdqzh/j+ZgtsDasV1syp5FqavIg59JhngSiUTiseb/hmsIhAzxAhtp+ihlonSaWNaY9Vrw3UkcIyZVzNMnh6kVLaI8jMkCnU4/c2bI2pEOfuakeW50F3dNX0ptYBMd2QFu/c7X5uvlJRKJxO+ked/TF1qgZUAcCrShEcrCNx3iyKNUTxM5M6SkprPUQdkpI+Z8huxeZlKjdKUWEgcHKWfWEBw1udS+j2gkZLivFb/d5ND3NhPHj72kIJFIJH5/zeNdNk8sahEiwpjANECZ1E0bz1ekPJ8gNUdGGuTrHYyYgo7CNPtZhpkbxnY7kPERjnaeyfm7NQ+mfS6eepCfRk+nsOBuuvN9fOGff+n94RKJROL30vzv6SPQIoJA4xsKpMIzDOqeors2RTmlcEwXpdsZEwbn1razO15FLneUCVmkzchRyLZz0f4MP0hnean8OUMjvVQHffy2DHq7ZO+RQ/P9MhOJROJ3wrwXfbQgFhEijPFNE60UgSEI6pLu+jQV10bYKSpumpmqxRViK4dKC0i3zTGsZuh3lxEFB6i6q8gMSRa6D9M3NMQtxjVM9d9Db0sHt/39u4mSYZ5EIpGY/6IvEGgZQRDjK4tICgIJui7pDaYoWWki06ZsO9TnDM6Uu9GFkGG3g0lnhN78GRDvZWLgEp68TfDDrMtLglt56Oh61OJxqm0ZzGgJ//Xxv5nvl5pIJBLzbt6LPggiGSPCGE+ZhAoiGWFWDXrCcWZUHs/U1E0wi4qcOYGa9tjJGjItQ8zJgHQcMpVqZ+2RHHeYOV5o/wLnYJEfWs9mZvB2FrcN4N5V45aN9833i00kEol5Nb9FX8coBFFzTL+uLHwRYmifXC1DzjjKuNdD1Z3Glj69hQ7GTFhWPMIOzqatfZwhOU1/+gxifw+T7edy1vaIe9Mez63ezsapc9GLihxqKeFksxz8j39h7+j0vL7kRCKRmE/zWvQFGokgEBo78KiLFJ6sYomYXD2DY04zWe+g7h4lJWLaKz2MG4qzo90cKA2QapvliD3FktazEGIfEwuv4NkPmXy1tZ03Wz/E3VfgBuN5iMW/oLdzJcRn8YN/fzEzFX8+X3YikUjMm3kf3pFIPCHIBWWqpPHNCpaEjJdBGHPM1vKE7iRZpXDCHo5Iiyvlg+iZkJ1qOXH6EHUB6UgzR4jl9dFyOGK/W+AZlbt5eGotcwOSrW0Pc0a+k47Dl/CJf38FZS+5734ikfj9M8/DO5r+iZi6EOSjElVShGYFRwicIEdgVKnWHGSqQNrKU061c7Rscaa1E2umzkPiPDo7hjhgHGVRbh062sbwkmt53oMWn+vo5q3OD0ntLvBF/pSuZfcy2WpjZwMWb2njg9f/JTU/+VzdRCLx+2Xeh3dAUJeSfFhpFH2jgiUVSrRQEIKO2ixeWqGcHCXXJpw1qKkai2aO8FB8IV09IxyyJ1nUso7I38lEfgVLD9nMzkSM2Ed5dv12xo+0sLH1HKb772BB5zmUsmmW3X2Qf/7k+5LCn0gkfq/M+54+CIJYkImrVOI0sVnFkSZ1O0+prhiojlNMp4ktm6oZ0zWpGFeKi9hGcdpg2Ggnco5QjOt0mX2EwW5GFj6Z6zbYXN/Vx9+436H1wCTfCV5Cy7KDbMxv4ez29RTSZ7Lo7nt433++n2I1mNdfQyKRSPy/Mu9j+iCIIkGOCuUwjTaqWMqlZjnU6gYD3lFm7DwVI8CgQv9sNzNKcbnahpqss5GL6OoeZo8zzuqui1FiGyMDV7JuZ0xhJuAhu8Kr9Y9hT53PGa9ncOWdbM1MszbbSs1+CoMP3MIHrv8bxoq1+f5FJBKJxP+5eR/e0QJ0KMiJKtXQRVl1DMOlbllEVcVAOMG47mXOHSMrY1q8BRw2DdabW8lNVbhfXkVP7xEOyDHysgdVr1D3RxldcBWv3JDiQz39/Kn1Y/pHDrN9cjkbW85ELr6DUmsLCxwPKV7A4IN38fHr/4zNh2bm89eRSCQS/+fmd09fSkAQh4IsVWqhi2nWkYaNZ0iMqqRLTHKkPkA9PUpOmXjOAMM1m1Ej4mxvK0cLaQ7JdlK5IQ6po6zqvAhTPcjQ4mtZu83DHfb4WkuGj6S/QGZHgW9Er0QtnOFg191kO1eSN0eR6qUseHg7P/vyH/HN+/ejdXLLhkQi8cQ0r0VfmgYgIGrs6ddDB9PwQFn4StNWgow5wdFKJ6QmyVgtzGZaCadMKlJyrdqMOV5jg3wKCxYcYXdmgsWZ9fhzw9S9KUZWPJM/uzPDZ/NZBnmEZwe/wNhV4WPyr1m0+kE25h5gSc+lpOV+sF5K36YqI7e+iL/98s8o1pJx/kQi8cQzv3v6QqAFEDbG9P3AQJk+sVJoXaWtnMU0pyhV0qhUFeXmKduCRWMSX8NTrIdwxmvczeWk84eZjkaZjEqsaL8A09jIob6raRnVXLgD3jewhPe5X6NjZIiJ4QyfN1/H6jNv447sRtb0PgVX7aHU8hIW39lDduhN/MO//xsPHEyGexKJxBPL/I7pi0YTRCTIihoE4FuKWEmIy7TU8oRmGaPiUc1YRJZDpKdZONXFhKk4YhZZ6+2kNC3YyHkMDh5me36MVW0XUSscIPCHOHLOH/OaOww2e3VuTht8IfdJ0rtn2TB3Fj9xnsmKtbdxS/pBzux5Gnmxi+Hea1l/2/lYtc9zx5dew3u+t5lSPdnrTyQSTwzzvqcPIH3IUYEgxjNN6iLEJCTjtTBuShaWRymk08ypOmnqZP2FbFc2ByybF1v3kJuoc6f5IgYG93DIG6IceqzpuRRD3c8RexX1uJ233dPKBzraaYl28U7ru7Q+PMv3vOeyMbOW5Wtv45bUFtb3Po0eOczewfVcvOW5BEd207f3Ot7xoU9w07axZKw/kUic9uZ5T1+ghUDFkBYVRBhTN22qwsOVgGxjMjJYUhtiVPVTdEZpNU2K+UXMFGzsSPN0437UaJFHagOM4dLdM8QjrSOszF6IX5xEqb3su/gtrNk0w5oDMX+5eBUvi7/HZf5GOrYW+Fz8eg7ku1i27lZudDeytPsKlpoeB9oCBstvIHd7nqzxHxz4zp/y2k/ezLaR4nz+yhKJROK38jswvCMwQ3BVHYKYmmFTEx6OlNSdduaqJkuiUQ4Gi6jnDtNqdTKT7aB3VDJY93nYCrg03ow1VuNW8zqWLTvA7uphilGF8xc9k6h2JzNVwehZL+bPbzbZP1fkowPLud7+OAMze2jdOcdHxV9xIN/JyjNv56bURto7z+T8luXMGJuZ7Xkj1/70XIamD3B+9Y18+z//mr/81maGZ6vz+atLJBKJ38g8n7IpOFb0bVVFBJqyyFI3SrjKourkCcoGi8UYR6qD2JlpbLedqhmwaijNvpTJ3dkWXp25j/xojdvCC5gTZbp7RnmofZRBsRwzVLipTexvuww/yvH+27r4klHn5/lWvpP7MKmRYVp3VfiIeCf7sx2sP+fn/CJ9P6V8jqt6ngn+rWxf8iTOHXoZrbe0MObexrkH/ph/+dAHeNd3H06KfyKROK38DgzvgBmBKWoQxJTJElhzuCpL1UnRMgetxiizlTwqUyWwHeJwmK7KYh4wHbQXsDzcRMvcEYKpgFvNl3HGGTvZXzrMuFHkyhXXURjbiBBj7Lr0HXTsmOKND3fzNy0O+4w6P2n/COLwGG17qnxE/DWPpFZw3gW38nB2Mw9nprl68GX0imGGMmPM9P0FL7nlAsYeAdXxVS7d9TLe96EP8RffeoidY3Pz+atMJBKJUzLvRf/Ynr7AwwgCSmQJrRIpI0PNVHQVNMKZQpYCCtk0M6pCXnhUMkuZmbG55miVH2YzvN69le7hGjfHV1KmxKJFY9yX3Y9bdlnZ9yQi72ZmyyEHr3o7V9w0xtWHc7ylr49qOMxN7R8mPjhOx64KH4vfwi3WUznvgp8z3baJm9PbWdV9NRe0rsX3f8zWJefQHv0Zz//2Au4ejsl2fZGn7P1jPvUf/8TLP30Xt+2aSD6PN5FI/M6a97N3NAIrhLoQtIRlymTBrGCpNKGo01V0KZp1cnMFJuxOZsxJOuw2Jlv6WToEpDTfa+vkBeJ2/IlpqtMBN1mvY+GihyjUJ9jZfpQz81dALSCTu5fDwQBT572AV32nwIIJwesWr0D7B7il86NEh8cY2DHHV/wX8GXzzaxYdyf5xfdyg/sA5VyWpw++gm4OM21uZuuq13DeyEv4g2908/OJmLjn27x8+pXc/+W/41kf+AEf/fleRgvJ/XwSicTvlvnd05cCpMSMNJ6QtIQlSuSwrBrCdNHxHB3ldg6aJmtKBzisF1HPH6TD6adsx6wZSrMxa7NuuMgWM+RP3DsZGK7z4/BiJmKDM888wiZvD6WwzlPXvprpIw+RbdnLttxVlPvP4m++rXGP1nj10lWI+h7u7PgA5ugRBh8pcnP5XP7Z+gRm3xDnnX8HD2Y3c3tmL+t7nsalXVdg1G/kSH6ObWvexuX7n8MLvtbO7Yccdnf/gjcab2bgjrfw1n+9nld9bgM/fmSUqp98aEsikZh/8372jpYKs7mnnw3LlHQGy6qBaaHjOZy4gxEMVulD7POWks5PYKTaiMNRWusr2ahdXjrp8fneBbzB+BGl0SnUjMeP3L8mndlAJjvL3Z37sAoWT1r1fGaGfortTvDw8lfiuT28/1sG5lSNVy1bQyma5LaW99NT3E/XxmmGp3L8nbqeHe4A51/wU+h5gO+5GxjLaK5d8GrWZruJK9/kQLvBtnXv4vzhF/D6L3eyc2uOr7Yf4eLuj/Ha0Vex45v/wB+87+u85esPcsv2cbwwuYd/IpGYH/N/a2UlsUKoSUFeVJgLW7DsGoHUyLhK1e2iUjJZJY4wMteHky0wY/ikKDDTtpLMsEE6U2dXuco+WebNmdvpOFDh1togO9TFnHXWI4wWRtnRN8kCfzmLes+kOn0DmjkeOe+tBDLPv3zbxpyp8bIFgxywYm5w/oFnWQ/BA5PkRkM+GL+VL9t/TfeSLZx7wT3sSD/ID7MPkm5ZyrMWv4GltiSofIWD7bDl7L9gSenl/NVX+mj/WYb/9AR7+3/B23N/yR/teT2/+Nq/cvX7vs/bvvkQN24dS672TSQS/0/N/4FcZWKGMCcleSpUwjSWVaUsPDIGVFPdpAqSReoQuhwxm88wLmfotFqZaunn7P2aO9tsXrdd8+m+pbxG/hB/aoreSZ8vqLdQiYY499wxHihsZzJf4/zstaSNPLF3A55X4aGL3kkQpfjA1wwWT1u8qjPPvZ2D/FP9/Xyk6yfMPHyUZTtK3FJazd+Zn2Of08Z55/+E7iUb+JmziZ9ndzLYcT7PXvwGltiCsPQVRnIFHjj79dD6Dl51x7m8/EtpNu1u5f25ClHfDbw39We8cOcb2PCNf+YZ7/sGf/zZDXzhnoMcmU5O/0wkEv+35vcum0qAYZwo+qJCNbAxbY+yqJMSFmW3k/5pDc4EZrHOQbWY2cwhutyFeExxxlgvtzopri2V2OCV2SVqvL/tRsJdRUYqgpvS78ZN3U5fX4Wfi4ep4HPN0lcQVesofoTn1Xn4kncRmK2884tlLp/u4k1WhU+tvIxnFr7C3f3XI8aHaN8wBUcF74//ks84H0B1HeDSy36G6NzCDfYG7s4eYGH7hTxnyZs5w80Rl77GrLGFrcsuZef6f+Sssefx91/p5vLvpbhxpJX3dJXQvT/ivfl38Bejb6Dw0/fy5x/6FFd84Ge887uP8KOHR5kue/P550kkEk9Axnz+cKkESBMrOrGnrwPwchaeqNNq5plVDn2TcGCtZOnsYfbqM1iWvxd35lLi2a2U8+sIJ8bxF87xwodsPnTJGXxx/4/4hH8xLYdSfPuM1ayyrmLNGXdy/4ancHv7Lq4dW80frH8zNzz472S6fkyt/iy2nPsOztr9GV796QdZ+dI1fHRgO4+su4L379rI7emdfNB8PZ/cuJ6VC3Lcu3iQDalP8WLjZ1yx5HMsXtzBnj2r+X59mEVOH+vj9axpu4QjtV3smLybehhzsHM1R/rfQi6qc82OO7nuzs3s74UfL0/xyHKfM4y7uK56M+fXFTu3ruHWLet4f7SOlp5FXLKsg4uWtHPOghbaM/Z8/skSicRpTszXTcTOO+88/RfPuR7jwFaiqY+x99oKHeMX8d5Vb+I9PX+Pf+e1rDqq2Oa5LN//Je590RjF0Zfys4uv4O/LH6Bt658yMnQ7IrqAcvhvtF5Y5OKbM7zsOSZ/71dZrRdy2cTbaLuwF7/T4L3BG+gwOrjttrNY2r2Uyw8vhi6DGzZ/mHR7B8J8HlFgc27157h3fZepp57D287eTlu6jfcVPS4Y2ca+7qfxqrHncTTO07umnV1dJj12zAv4Lhf630axgH17lzE21k1/qoeVcz0sDNuZkzNsH7uL0ep+zMwC4ngF0lpGmzdO59D9dE4+xHhXlbuXRWxeJsjkYy6qVriwXqc/aGWTv4L7wpU8oFdhti/inAWtnLuwMS3vyiClmJe/YSKR+H9PCLFZa33eb/r187ynL9HSwIkN5kybpVQQfkRBtKKcWdLGUnR1gkzQxW45w9PlPr5TfBZRu8+QnKTPXcjeUHPuI+38x+WapywRvHpTjg8+Jcf39z7IX7XeySe2XkPpgna+0PZh3lT+Y5785C5uu03iLnO4YG8fz7vg7fxw88cwM9/CbXk+9wdXsf5FK2j/9j/xhaGlfPAZPq+2Jrlu/TX8+fZbucO5l69nX8m7H76AgbyLuaKF61texE/s5/IC/XXOWv5jlp/RxdCRVdxW6yWTzrE67Ofc7mdykaEYqu1m99ENzHm3MZteytTCM9m97Hm0htNctv9envvAdiJzhi0LM3xpcYadiyRL1R4urG7hj2t1eustbNq5knsfXs5X46WMWotYu6CDtf151vblWdufY0FbqnnhWyKRSDzavA/vxErhRJKiYdIiqwgvpkArreYcrtNKXNhF3e0hmNvHerkHWfDZ07uCbPYgZ5cvYPfUQ5RaziY1civTA9M86TuC766WfGTxOt51+Ev8KFxFebfNhrU5+nIf4QWlP+Oyy5/GXXfuQiwXnL+vl+ec+ef8dNenKIx8kZ7lf8jDQ/0svO4/WHzje3nnJ0o8+Ifn8U96I3euPJt3VmOuO/gxnt23hn8JXspXH1jCss403tIs/5Z7OQvs63iWuJHzB7/OgoUOhcIaHt41zsZUnkWpXpbSxTX9r8C3fA4VtnJg5j4q9VsoppcyPbASufhppKSgd2ora+55iJaf7OZoj8nGAcmHB3McHJAslvs5q/oIb/c81nia6dHFPHBoITdHS/lXvZQZu5+1fS2s7c+xtj/Pqt4cizvSmGr+T9ZKJBLz65SGd4QQTwM+CijgM1rrf/kftjsfuB/4Q631d37V9zzvvPP0u/7wvwj27aH7wL/zqesi3nokzfNb3sMfrL2FldsmuXLs+dw6dAOLi33csfQ7/EnnFC+MP826Sw7w1P33sf7gS9ly+LukuYq4/EEmr67w3EfOYHLc4w0vnOGzM1WWyx4uHH8Hy9b2s7nf4k25h7m4+F7gedx1Z4Y1C1Zw4f5+jBabuye/z/CRHSw579mM7FtMttVi3dEbce65gfCc1fz7lWU22aNcmT+Dvzy8m8HZIY52Pom/Lr2AWwt99Hek0EtzHMhL2kx4hrmFC2ufpk1PEserOXhwkLHRdhwzzXKjn4WzLXTpPL7lcai4nUMzD1Pwp3BzA0TxAhALkaqL1ugoubGHaZ3ZQ27uANNdiof7fLYPaHYNCrIZg3XVCqvrNVb7PgtDizGxmC1eP9ujQXbGCzgoBxnoaGN5d4YV3VmWd2dZ0ZNlQVsKlQwPJRKnjf/z4R0hhAKuB64BhoGNQogfaq13/JLtPgDcfKo/XCqBlgorEhQFtMoqVqAp0IbjHKQqAhzhU8oOsGRcs3tQsX5qL1v9M3lxy3cZltP0u4s5rDUX7u7i3WqSV/ceorKxnT/c3sLfntPGt/Zu5Rv93+Z52/6I9U4v13MmTu5tnDP371xx5fO54/Zd1Bf5XDqyhEtSz2bPWQvYsvEGepavIwifzL3WNay47mL6fvhP/OXWCsPPOZ9/WLaV57bZ/OGiZ/Ga3ffy2fpfMLLoat4/9zRu3NDPwlaH9NI8X82fzdeMT3JJaorL/W+wcuktLF+WoVJdxb69wzxit5O1MyxWPSwIl/JU9xwiM2IyHGLf+INM1B4gtmyK7gKmunsRfecjZQutepql449w7l27yM0dxMvE7OvNsKPL4qd9cKBH0GWXWFXdzNr63bzI9znDj6hW+9ixfwFbtvfzTb2AvXqAKdXJ4s4cSzrSLD42daZZ0pGmJWX9795NiUTid96pDO9cAOzTWh8AEEJ8A3gOsOMx270F+C5w/qn+cKkEWijMUDOHJk8F5ccURAeOU6YkamRllpLTxtK9intsm3PkXu4pXky9XTJhjvDkzHIOTm/laNdFnL3jR9y7qEz75c/hebf8jHv74F0rLuA/dv6Ef+xfwt9tfhJnXtrPv3MJ78xr1hY/zNVXP5PbbjtIqb3MNf56lk+to+/qM7jpzv/EdI4wsPqF7N6TZ/ypH2RN5R4GvvMFPtfXw13PGOTj8UN8t7+Tl6cu5OV77uUTtVuZHryIj3rP4kubFtNqGSxa1sq2zjbuct5Mn/VGrjS3cQ5fZt36B5Cym1JpBfv3DfGI1UrKTrHQ6qavmOPC7mdjSkXZnGOkuIeh2g5mK7dhOFnm3AVMd/RC91kI2UZWVsjNHeLyfTt41paDZMqjzHUq9vZk2dFpcVMXHO4SuCmD5cERllW38Ww/YLkfsCAUFMr97JvrZduubu6I+vic7uOA7sFJZZtBkGFJZ5qF7SkGW1MMtqVoTZnJcYNE4jR0KkW/Hxg6aX0YuPDkDYQQ/cDzgKv4FUVfCPFa4LUACxYsQEhJLBVGqJkjJKXLaC+iKLtwU1WKokrOamcmnqWj3M4WI+ZtcjdyymNb5zoG2w4ha+dgxsOM9jyfp225kU+sy/Pvmbs50H8x77tpB6950QifXXourzlwPYc7W/nCvYI1l/TxAS7l7a1pzpr9R6699sncfrviBnU/1yw9n459Ni+84K+4e+g77NvwWQbXXkSteiH31s9n4SsuYvGmz3HJZx7g0uWL+enTOvhksIUvD/Ty4uxlXLd/M++d+1v+unclP7afwT/tXkdth83qviwMpPlGZi1fMz/IKsfjMnk/6/XXWH/mFFK2U62u4NDBYXaVWxGuQV+miwG/jR5/BWf0nYdQUDIKDBd2M1x5hELl5yjLoZYeoJLuJlx0AVI9G6UscrpA6/Rertm+h8yGEdLVMbysZrTbYXcb/Kwj5rNdgpFu6DEEy4Ihlla2c1UQ8CdBwIIgBNXJcLGffVOd7Hy4nUd0F0d0N0d0F1gZBttSDLSmGGxzj4fBseW0Pa+HixKJxP/gVP5n/rLducceCPgI8Fda6+hX7f1prT8FfAoaY/pSCTQSFcTEQBxX0J7HTNxOOl1lzKix1GxHVyappAaxClMsM3fjTJbZsuJ8zmr/CgcnjrIgtYID4RhKrkRNbGcqt5/CGS8je/tW/m5DP+++ZITBgVW8a+xfmWv/B753D6y/tJ8PFs7mta0f4fLZt3L5FSt45OFLuWH4dp607lxW72nl0tRzmXryxfziri9gWFtZcOYfMLyvj+HeV7L8guvovfXjPO0/NvK0dSv52RU5Phs+yJc7XP5g6TN52dghXjT277wgnWF7x9P5aOESfv5AF1lDsnRxC8Uum0+lLgd5BWvdOhfIh1ijv83KVfciRIo4Xs7ERCcPHs7i2Rkc06bf7aSnnqcntZZV7oWgoGqWOVo9wtDkTqbrm/DiOm6um7LZw0y+FZ27Aqm6kNImIytkqqOsndjDRXsOkymPYEQl5roUo22KfXnNz1s1I+2C0W5QjsGiuMACb4yF9QrnBCELgoCFQYhQecZrPRyudLPrQAc7wg5uirsYpYNx3UounaI379Cbd+lrcejJO/TlXXrzDn0tLt05B8tIDiwnEv+vnUrRHwYGT1ofAEYfs815wDeaBb8DeIYQItRa3/CrvrFqDu+o5h0oi0rSpksMe/1Iq0JRVWlLL0aX76OUXcDykS3sHYxZP7uXDd7F2G1T7FMjXJtfz77xnzA8cDnP2rSTzz2thXfMfYF7rvx71t/817y2vZ93rZmko62ffyn8I7T/Ld+7W/Cki/v4FIMcbfsqzy+8idVrbqC///nct3kzQ339XBasov1QOy9+0t+w6ehN7L3vG7T1L6C1/6ns3pdj/6q3s+LKIp23/SfXfHwX1y5bzIar+/hE/BDfdzzOPutqXuTBU/f8kM9E36bWu5I73Kv50NB6RvZm6XAMFizIU+yw+FzqQlAXscQJOc84wErvFhb33EFPT4BS/dRqixkbG+GB0TSB7ZKyXHrcdrqCHB1BHxd3r8RAETghxXiSicJBxst7Kfj34mkfO91Gzemh4rQT9K5CDl4BIoNtRGSjWdzSKGcPH+DSXaOkqhM49Rm8nGCyy+JIi2JfXrGhFSZaBEe7IGVZ9OmQfv8g/bVHOC8IeE4Y0h+G9IYxvmxnstLJcKmdgwfbOBC0slm3M6o7GNHtzJGmI+PQ1+IcD4eunE1X1qEza9PVnFpTVnIdQiLxODqVor8RWC6EWAyMAC8B/ujkDbTWi48tCyG+APz41xV8AKEEWkikFyBixZyUdIoiQ75mxspRk7OkjLMRTFFuv5K1w4LNyx0uk1vZMH0BuwbWkm4bIvbPJidipnO9XLS3nS97U1SzhzDmdnLgyrdx9Q8+xHCuhzcvrPBJuvmX2feS7no3n7sr5soL+rhBW+zPfI4/i95PKv0pnnrtc7jrTpNv+eNcvP5cztgjOSd6MmuvuZI7H/ka+x/4DP0r12NlLmXb/gzm2ney7Joq3fd8kfP/6x6+2NHO0JPP4nNLh3mXGOEDy5bzrPRinjU5xLVD13OtkMwsvIjb5JP4xJEVjOzJ0GYpFi3IU2u3uCG1DN86A0e9mXOdIuv0gyyNb2TBwrtZuBCkHKBWG+Do0Ra2jKTxzRTSknRm2ugWLXSUUwykz2J16kmAIHJCShSYLA0xNr2XWW8zXlxFmQ4q3UXRaGM63ULknImQVyFkDkNq0rJCujZJ//RBlh45TKo2iVubwgyr1Fpgps1gPK84lIG78jETLYKJViikoUNa9OuAfv8IfbXtrA18rg4juqOQnjAiJRwKqpPJcjtjxTyH/TxDYZ6HdStHdSsTupVJWtDSpCNjNwPBpjNr05l1jodCZ9amK+fQmbGTnkMicQp+bdHXWodCiDfTOCtHAZ/TWm8XQry++fwnf9MfLpUgFgoA14eilHSIIsKLOJrpxnZK1MoRRugzl+3i3B2KbzsZ/l5t46PjFTb1XsSLur7HnslRFmXXs7XyIEODV/GCe7/Nx69q452lz3DDzMdIn/tSXvnN71D/4w5e11vik3KQd0/+A4OL/5L3PABXruli44Dgr8y/5W1td7N45kNcdvkZjI09hbseeYDdnV1cklpL+27BNR0vZ25tkds3fJlq+RH6zliPk7+YXftT7B58HYsv0fQduIX+7/yQd0tJcMnZ3LYOvupt46tGyKK1F/FM1cYzR3bxool/44UIioPncpfxJD4zvood+1qQwIruDLneNIeyOe5xrgB5JW2mZr01y0q2soif0z/4AIODMUp1EIYLKBZaGR612Eae2DaxDJOOVCvt5GirubRZy1jacyYKSWTF1I0qc/4Uk3PDTJX3UfSn8eMa0jAxst3UZQcVJ4/f3o/oXIOQLQjpYKqINBVcb5rW4ig9+w7j1qZw65PYXgFtSiptBjN5xXgGhlMZ9uVipnIwnRVM5UCaim5h0B0V6Q4m6a6XWRUEXBlFdIchXVFEaxRTN1spyA4my62MzbUwHOQY9tPs03mmdJ5pckzqPHOkyTom7WmLtrRFW9qmPW3RnmmsN+aPfsw21G/61k0kTlvzehuGD/zZlzmyeYSLbn4Lb3yj4p31KW4pvIJvrHo2r+j/Mv07a5w58mwOj97BjHE+Fz74Rd593TifK4/z9Nr1FK9YwMfln7L1vufwvOoV3DT0aaz0y3jSA+/n7a+u8vHyOENTV7Gv+jrOnLmJjj0/5xMvb2dD1xwf8lNcfuRB7h98DS/d92QWdWaJzmpjj4h4bmud55fehQqOkE49iw0bepmdrXHGwmWc7y3FPRQi8xYzbVPcvembVOZm6F66kkz7BYwf6iAKoKPXZmG4m/ytX4CZSWRbK5OXrOQnK8r82NgBQnBGdgFXyzxXj+/njPFdCMDLL2Fn5kJ+VFnN1yYGqWkLx5QM9mYxOhzG0pJxR4AU5BSss4ssF/sZ9B9gwL+PDGVAouQAvt9PoZBjfMKgWMgQRRZSStpTLXSoPPnAJVe2aAlcMtpFIohNjWfWmAunmSoOM1UcohTMUg2LaDSmncZKtSONFuI4R+BlQeQRMg8ihZSQUh5uVMKuTWPNjWPPjmDXZ3G8GWyvgBF5eDmHUovNTF4ylgkYcepMZ2JmMlDICGYy4NmCVmnRqQXtUUSnX6fDq9IRhXSEEZ1RTEcU0RFF2CgqRisF2coMOSbjHKNRjlE/zUTcCIdpnWNWZ5klQx2bjG0cD4TWlEWLa5JPmbS4Fi0pk5aUSd41aWk+15IyyTpmcl1DYl79tufpz2vR/+D/9xUObhzhSTe/mb94teKVcob9s8/mPxf+Edcs/QWXHNlC+97nY0wOs9e3WDV0gJ+uu5PLBma5Y+YVfHvtH/CGnv+ibZdm5cgzKU9s52DosvRogdH0jWy6SvOvQ9N8v/IGav4lnHX0R7Ttv52vvrSHH/WO8Q57EdftvJ3p/qt4wejLmIzSnHN+H7elI7ptg9en72PpzL9imW1E0TO4715FEMSsW7KKdbP9uKMxMmNS7CiyYfv3mT46TKa1nZ7ll1EqLKY4KTBtxWBPSPfIfTh3fAcReMj+XkbOHeRni0vc6O4lFtCf6uZSq5NL5ma44MjDpIMa2nCYbjuHh9VafjS3hJ9M9xFg4FqK/u40RqvDVFoy4gi01RjaGLQiVhpTLNG76PPupT/ahksdACm7iKJeyqU8U1MO09MutVoGkBhK0ermaVVZ8mGKXMWkxXPJ6RQKiRYQ2RF1WaUczDJbHmeqMEw5mKEcFoh1hDRMbLcVaeYRMksUZgiDFEJkQeYQMoMQCktFuKKGExSxK5NYs6OY5Ulsv4jtFbH8IkZYI7YNqnmHUtZgJqM5mgoZc+vMpPXxcCimoOKCK006hEFbLGiNQtoCj1avSksY0BY3eg2tUURbFNMaxyhhUVV5SjJLgRwzOsN0lGYiTDMRpprhkGVWZ5glw6zOUsZFCEHOaQRAIyROBMJj1/OuSc41yTkmWccgZankNNfEb+20Lvr/9vavsvf+ES65+U383csU1+aqZIoX857WP2XlukO8fParFLc+j7XFLPfPbKG7vpR68Fnuf3KNZ43186b8X7Js/SivK/4no1ufw5Or6/nJ2JfJZl7Gxfe+l795eY236ymsQ/3sMl+M75/H+rnbaH/wBu54yUquX7iHF+RX89dbb8Nw2/mX1Nv59JE+1i5sYW5Vjj064pIsvFx/hkzppzjOIkqla9j4gE8ca9YuXsXaSj/pwzHCkgQDsH3sTnbtuAchJb3L12On1zE11klQBzdjsKClRMeRu7HuuxER+MiOdqbOX8q9izx+kNtPUdYxpMFZmYVcEhk8aWqYleM7UYA2XKZaz+QRtZZbK4v4yXQvxdgFoLfNpa0zRZA1GbNh0hHQHOMesCKWGkUWcJjecCvd3ka6GEOiEcJGyj6CoJ1KJcvsjMXUlEGtliOOG6N/OTdD3sySEy7ZwCFTNcl6NlntYmGggdiO8VWdWlSm5M1QrBxltjRONZyjGs4R6gAQWKk8ptOCUjlinSYMXKIwhZAZEGmETCOEgRIxjvJx4iqWX8SqTmMWJrAqk1he8XhAqKgOUuBlHSpZg1JKUkhppt2QSdtnNhVTTEExLZhLQTENvilwhaIVg1YErVFMWxjSGtRp8aq0RRH5OG5MUWOei2NMFHUjR0XlKIsMRZ2hoF1mohRTocPR0KWo08zpFEWdYY5UY50UZVyUlOQc43gQ5FzjeCA01s1HPZ89ttx8PG0ZyUHtxOld9D/8l19j590jXHbLG/m3F1msHoi5YHYJbzD+nPwFEX/n/S3bHnghz62ezY+OfBon/Uou2PjXvPHNmlsOjXK+/0nmrlzIx8zXcWDTZVw9+xT2jP+cCQZYNFsgrP+A/3qh5Acjo3xz3znEnU+hVjmH1fpheu78NEeeupZ3nrWTpfkFfHBsjMVTB9mz6DpedvCpzEUWF57Ty72tUAOe31rjabV/w6k9iOsupzR3KRs3xoRhzOL+RaxTi+g8YCBCjey1mVBDbN52I8XZCZxMlp5l5xKzlMnhHDoSuBmD/tY67WObcO+9AVktgWkSrl3GvpVZft4zzZ32IRCCtJHirHQ/54SCc6ZHWDe+C1trNIJafhmH3VVs9BdzU6GfDdVeIhRCQFerS0ubQ5yzmHUlo5Ymthrj2CkJS606C+RRevVhOoOddASP0MUEkhgAKTuJ4y68egulcprZGUWxaFGvp9G6+X1sl7yVISfSZGObVN0iVVNkYoeMdjBobBebmsDw8ahS9gvMVacolCao+EVqUZl6VCbSjbO4TCeD6eSQRhYhMsRxijB0icNUIxRkCkQKIRRSaGwVYONhhRUsr4hRncUsTWFUprGCMpZfwgxKWH4ZqUMi26Ses6mlDcopwZyjmbVDpkyfghNScqHkQtkVlJ3Gct0CWyjywiCHJB9rcnFEPgzJBx55v3Y8HHJRTD6Ojq9nYg1IPCNDVWapyDQlMszpFLNxipkoxWToMBWlGoFBmjmdbs5TzJEmwEAKyDbDImufCI2ca5KxDbKOQcY2yByb2yfWs7ZJ2lZkHCM5lnGaO+3vshk36gvtscucLegX04TVkPG4FammKYVz6EhiROBHFULaGRiZ4JGU5MnBw/xwrJvbBp7KxT2b2VIe5MK2yzgy9k2Gul/BJRtup/fwLJ9tz/HqpQU+vesecv11dpSfRP1Zf8/Cn7yfL40s4m+fOstLWgz+rOcaXrrtK9yXu51PZd/Evz4Q05N3WHJ2F9+fdfiRfDcvbi9wRfU/cMzP8+SrFuL7l/HgllF+OHeIts421rQtZfFojs7ZLp7e+SdEZwoOzm3l4e0/I/Bux83m6Vp8JsJYxqHRPPvCizAuvZieLmivHSK383ZWfH0DK4G3tLdRWjXA3oUmd3VM83F3CO0IzCVLWJse4GyRYl25wJqJe/nj8g95OaAzLsWWVRw2l/JwMMidR7u5e18XdWwsoDVt0dbmYGQtqinFvVYfs84AmJeBAFPAQitgUBXoZ4zOaC8tcjudzjaWdRSbF20IpGxH63Z8P0+14lIomozNmtREmsB0OHZ5h2s55KwMGeWSiW1SgUU6ytLutDNor8fFRDY/yyc2NKEZ4tPoMVT8AqXKFIXaOPWwRDUq40UVdPMyEcNyMe0sPmlCmaasXGLHJZQZdLrzRDjIFEKYAJgqwhY+tq5hBhUMv0ymVqBlcpbl5RnMsIIZnJiMsILUMbGh8NOKesagmlKUXSg6moIdMm0phiyTigNlB6qOoJyGigM1G4SQ5KRJHoMcgmysycYlsuEs2cAjG9ToCQOWnxQS2Tg+PqW0JpQOdSNLXaapxilKdZdS1WVOu8xGDjORzXToMKFdytqlRIqydhu9DO1SxqVC4+9iKXk8GNK2QfbkoPilgdHY7thyxmmsp0yFkdzE77Qzr3v61//dt9j000M8+Rdv4kfP7WZ4neafDo+ybu4j1K/p43rxGvZvvpQrZ6/m4NgdjDPIytEDbOu/k6Pn1rlmvIfX2e/AvDDDh/Xr2fzAc3lO5XK2j9/CKF10+WmW7P8kb/0TxRenxmgPruMbu0ZI9yyhWr2KjlaDlbf/E044x03PH+SzfXs5M7+M94wNs/ToXgp9V/BX5Rdz89FWlnZnaF3Vxr1WiCElz26pcI33GTKVO1Aqg2Vewb59gxw4UEEIwbKBxZyhBug6ZKHqGpEyCDpDDs/tYOv22/C8Cqbt0LloNaazlMpcD+VCozClcwY9mQqtM7tI7bgd48iexh8rm6W+eiGHFrlsaC9we+oIZbPxIettVp41ThdrQlhTmmL10QN01ksIQAtJLbuIMWcpe1jIpno/dxY62O+3EjcLblvGorXFwcyY+ClFwRRMmJrINaA5pJCSmn4zoFfN0cVROuMh2oM9tIa76GAKg8aeuhA2UrQT6xYCP0Ot7lIumxQLgkrFxvPSRJHV3FaQslwyVoq0cEhpGzcySXkGTl2Rim3S2sbGRDSDJDY1kQrxhYcf16iGJar1IqXaDOXqDPWoSj2q4EVVYhq/H2XamHYWZaYQ0gXhoGOHOLYJQwu0A8JFSAch3MZy88wyU8VYIsDEw4pqGH4Z05tDVQsYpWkMbw4zrGEEVcywitGcpI7RAsKUje8a1F1FxZVUbCjZMUU7pGAGFK2IikNzEseXyw5ESqAQZIRBBkUOQUY3QyGKyIY+2cAnG9TJHA+NY4GhSTfXLUAj8FWaukpTk2lqIkWZFCXtMqcdCrHLbGQzE9rMRo3wqOBQ0U5j3lyu4uBhAgLbkI0AsBRpyyBlN+eWOv54YzJI24+Z/w/b24ZMjn38Cqf18M5//eN3uP+GA1xx559z/zMGuPXcKl/b/TBn1L9I+dJ+3pl6P8auLIvHryU7N8fW6hHaWM/CvR/m7a8KuW3/AS7zPs7wk1bwluxH6N5fIx66jMuqA/xo+Ou4uVdy1rYvsmnpLn52ueS7w6PMyg/yo723Q84mEk/DNNtZPfNzWh/4LuWL1/IPF40w6lR5SX41r991D7n6HIcXvIB3Tj6V+2fSLO/J0nZGC/e7MT5wRR6u4TYWFj+N0D6p1DrK5fVs22pTLAbYts2y7kUsjrrpGraQnkbYirBLM+EdYsf+u5meatzloq1/IdmOpcRxH4WpVoJ6IwQyeYPOdI383AHSe+/D2r0JgQYh0Av7mF3cwYFewabWAvekR/BU42/aYmY5w+lkuTZYXq+wfHaUZdNHSDX/5rFyqGQXctRawP64n61eFw+UO3ik1kENB2jU+7acTTZnY2UsAldRsgSThqZuy+PHDSTQacR0GTU6RZF2pmiNR2mJDpML9tPBUTKUjl/eLYSLEO3EcZ7Az1D3HKpVk1JJUi5JfD+F7zvHh5GUlKStFCnDwZU2rrZwYhM3MLA9AycwcLWJq21sjBMBYWgiIyIUPr6u40U16kGZqjdHuVagWi/ixzW8qIYXVwniEx9RqUwH006jjBTSaAQBuhEUUWQRBSZIGyEcEA5C2CBshGh0oA0ZY8oIkwBT1zGawWB4JVStGRq1OYzwWFjUmoFRQ0UeAogsgyBt46caoVG1BRVbUzFj5qyIOSNg1vCp2VBtTjVbHF+u2o3gMJBkpEEaRRpJRmvSWpOOItJRSDr0yQQe6dAnHcektSYTx43lWJPWjR5IKo4xgVgY+NLFUyk84VIXDlXhUtEOZe1Q1jZzcWMqhBaFyD4eHlUcytqlit2cNx4/tgOipHhUiBwPDUuRavYwXEvhmgqnuZyymsvHJuvENsfWHbOx3el+i/HTuuh/9gPf5+5v7+XyDe9iz+XdfOLCo9y6ZweXeR9m/zmrua7j25w/eYjawWu5uLSAnx75Asp9DZfd81f85as83hVOcvfc8/h09/MZOKPM3/C3bHzguTy7dikHJu9ij++Tcq/k8rvfzXuuCzkvXeetszAdf5z7pn7BaGkf+d6nUS4uYWFbhYU3/wsWdR561gr+dfF2Uk6W11v9vGjHL7C05sDAc/i76Wu4ZzpLd95hyap2trVIJnXMgK14Vvow51S/Qrq2ESEsXPcipqcXs2O7oFqNcByHxV0LGIza6RlzsarNwZJOkzlrlsPT29i77wH8oAZC0NqzgEz7EpD9lGbaqFcaxcR2Fe35mFw0SWZyL86e+zFH9zXKnKGIFw8wO5BnqFOwI1/hgdQYo24dhEAgGHA7WGbmWRzBonqFRcWjLJwZojUKjxdlP91PwR1gXPVyKOpkp9fOllILO+uNq2mPyTgGuayFnTYRrkHgKMomzJjg2QoMAc29Nkdous2QblWlXRRp0VPk4zEy4REy4RFamaGFwvEeA9A484c8cZwhCFJ4nkutZlGpGJTmJL5vEwQ2YWhzbEhJColrOaQMh5S0cbFxYhM7MrACieUpnMjAxsTRJjYmqllwtABtxEQqIhTB8aCoBWXqfolqrUi1XsKP6/hxDT+uE0R1Au0fb7M0TAwzhTJdpHIRshEGaJs4togiizg0TwSFPBYYDmAghEAIjaUiTEJMPMyojhFUUUEV5ZVR9RKqWkR5FYyohgqboRI152Ed2TxGEpuKwLUIXAPPUdQcSc2Ciq0pmzElK6JoBBTN4KTwENSsxrGMY/PQaPx+baFIC4OMUKS1JA2NYIhj0lGEGwWkooBU4JEKPVzdCIuU1rjNeSo+sexojQRC6eArF1+6+MKmLhxqONSxqGi7McUmpdhqTGFjuaZtqtjUsI8vV7Gpa6u5fKJnAmBI0QiMx4SC+5gwSVknwqKxnSRlGTiWwjEkttmYO83t7ePLEttorP9fHHg/rYv+Fz/8A27/6m4u2/lBJtakeMeF+9hy8BDX+X/D5lWXctHiPVxX/TIPb7yGl5Yu5obDH4P081i772c8uHwrB54keOuhMlcHH6J+RS/vst5LZr9B7fD5PC04k58c+Qyk/oCOuQkWDn+Jt71S8I/FadbVl+BX/5ER4xD37f0erQNrqFYuwXazrKhtpP32zyMW9PLDq7N8pXsfnW47r1ZdvHDn7VhxyGT/U/hE9Rq+MNqHYyrWL2+n0OPwiBGBEFyQgSvUFlaXv4AVjiClg22fy8z0IvbssZiba/xn7O/qZVGql965HLkxidSiUSQ7FHNyhqGZXezdvwHPrwKQ7egm27YAafTiee2UZ7No3QyClKItE5IPJ0kf3Y1z8CGskd2NHgFALou3oIup3hSHOmK2ZYs86E4y44bHi3LOTLPIamWRsFjoByyqzrGwOE5faYrsSe+T0MpTTg0yZfUySieHwzb21FrYXsmy32+lSJpj/8FStiKXtnBTJtJVxLaiZgrmFBQNiGwFtjzeBoBWFdOufNpllVYxR54ZWuIJstEIqXCInJ4mR5EU1ZNuDCWbAZFFx2mC0CXwbeqeSbWqqFYktbpJ4Dv/LSQALMPEMWwcZeNKCxsTOzaxQ4UdKCxfYcdGIySaQWGijvcoNBptaGIVE4qQEB9fe/hRjXpQoe6XqXmN0GgERnOK6oQnBYaQCsNKYZgu0mgEhhAOGps4NtGxRRQaaG0CNkJYjUARVjM4LIRo9r6ExlQRBiEmAUbsoaI6RlDD8CvIk8MjqGI8JjhUVEdFHlI3DrzFhiSyTULHxHcUviWp24KaqamamooZUTYiymZESTUCpG42g8MW1M0TAVK3wDM5/nd3hUFKKFwkKQQpDSkNro4bgRFFpKIQN/RJRT5uGJCK40cFihNr3GaIODrGjTVG86+sEYTKIZAuvrTxhYMnHOqiGRbYVLVNJbaak0k5NilFinJkUtcWdU5MnjZPrD/muWM9lsb7Sj4qDBxDYTfnJweF3QwKx2xue3y7E88f+5qrVnWfvkX/qx//ET//wk4uG/sc5bYKr7tyH784PMzH4tdzY/8zya0K+Bv/jdx154t4kXcJWyduZtrooJc+Fu68nte82uOWoSHeVnsHdy28kMWLCrxTv5sHNj6Xp9TOxy8dYPP0fVjZ17Bu22cY6t7Nx54d882RcWpcgFF6G0ZWcfver1Nhjlz3VZQKS2lvlSzd+22y228nOmMR37vS5ttt+2hzWnmJ1ceL9z9Ae2WGWvtabnafzgeG1jDmWQy2pxhY0sL+vOSI0phCcGEm5AL5CCsrXycd7AckrrOaen0ZQ0M5Dh6MAYFt2wy29dKnOuguZcgdlQjduAiLdknZmGOycoRDI1s5OnUQAKkULT2DpFoWgGjHq+Upz2TQNMbLlSHI5wRZVSFTG8c9ug9r/4PY00dOhEE6RdDfwVx3hok2ycGcz/bUDDtSs1SdE0UxZ6Tpt/IMCJu+KKbfq9BfmqF/boI+v4570vsoMlLU3B4KZjcTooORuJ1DYSt763n2VDKMxi2UcDmxZy7IpU0yaRPLNRGOIrIENUNSUZqC1ESWalyLcNKtFgyhaVMRrcqnRdTIiRJ5XSCjZ8jGR0lFY6SjMXLMkaOIhf+okJAyC6SJ4xRx7BKGFr5v4XsG9bqiWhXUapIwtAlCizCwiaITe4wCgW1aOIaNJU1s0QgDSxtYscKKFFYgMQOJFZvY2sDCwNLGL+ldaGIZEcmIUPsE2ieI6nhhDS+oUPMaoeGHdQLtEcSPno6d+dT4u9so00aZDkI6SNXsaWCitYWOTeLYJAoN4OTAOClEmj0OACU1hogwRIQixNDHAsRDBTVUUEP6FZRXQdbKKL/SeC5shIbRDI/GVEfGYfNYE0SOReSYBLbRDBKBZzYCom7G1ExNRUVUVURZBZSNEM/kpKmxrdcMEc9oLAcKEI3jIY4wcITCERIXgaNFMxiaIRFHOFGIE0U4kY8b+rhRiKPjRwdJ3AyTR62f6Kkcf/8Lg1A6hNIikDaBsPGFhdc4x6wZDiY1bVHTJrXYpBKbVLVFOTIoxwbV+DFBoy28Rp+PW/7ljadv0f/mp27kpk9t4/L6D4lKe/njZx/hWyPjbDNfxL8aL2Lq7Dyfiv+QBzc/g/PKl5ILfDZO3QnGi7nkznfw3pf4XNMasW68hZfGf4t3ZS/vEu+hdSRiYvf5PD++jLvHvsWMTiGda7j8/vfwrctrbDkv4OtHxnhIXIEVv5KFXjtH5B427P0h6Y5ehHkZfr2X7raQhQ99lcyBB4iWDnLrJRk+37MHaVo8M3cGLxw7wPrx3WA4DHVfzRerl/D5sQXESBZ1ZWhbkOVIi2JYaQRwZlpznnGQFf6t9FRvQRJjGG0otYa5YjdDQw5jYwACx3Hoa+2mS7bQXk7ROm3ihI0xfuEowlxMiRnGiwc5PLyVQnn8+O823dpJurUP0+4i1u3Uyllq5dTxA5OGKchnIS0rpLxpnNlhrLG9WEM7Mf25E4WxJYfX00qpzWW6RTKSDTiUqrDbnmUk4+ObJ0pom5Wjx8jQJSy6Y01P4NNVK9FdnqGrMkV3GB0/lgCN4wl1p5Oy2cGsbOUorYxGeQ57WQ56WfbXsxzVLRRJc/J/KcdUpFMGjmtiOgphKyJT4pmCqoKS1HiGRJsSLHn8IDSAJTR5FZGTAVlRJ0uFNBUyFEnFBVLxNKl4EjeeIkOJDGUylLAITnrnSoTIAGl07BLFLlFoE4Qmvm/ge4q6J6nXBL6vCEPrpMmEk16LIQ1sw8JWFrYwsI6FRtwMjbAxmYHEboaFeXyuUMgTPQ2h0UoTqZhIhEQEjeCIPfywhhfWqPvNHke91AiW2CeMPQLtE8aNKW6erosQzfBwkMpCKhspLRAmCAswG+GhDXRkEEcmjf3qxjaN8LAaZ001tz/WAxFoDBUfDxJD+6jYPxEUoYcMaii/ESayXkX61ePbyOjY9s2viXxkc/3YzoyWgsg2iWyD0FIEliSwJL4l8cxmD8TQ1E1NxWiESsWIqKiAutL4JvgGzbloLB9fbwRMYIAWJ4a8bKFwhMJGYiOaE9gabK1x4hhLxzhRjBU3QsaOA+wwwI587DhubKc11mPm9rEp1nT8feH0Lfrf+fxN/OT6R7jcuQf1yM/5w1fM8PFiRFav47qZVzF7RTcf4K3oI4sxpi7lsuJSvrPnQ1i5P2HN0K3Mtj/Cfz4j4Kd7d/IC7308smgNXYsC/lH9GQ9teTpLp1eyQvdx65EvIFJXYUZtXLrxn/nw8yTFpQFfHhrjF1zObOY5nD+5ADfl8PDM7ewZ20D7wGr88FwCr5OetpCBPT8iu+1WRGcbOy7u49MLDzCS9lic6uV5ZHjWwc10VgtEqQ72tF7Jt8pn8eWJBYQYDLan6OjPMtmi2G833pA5JTg/VWYdj7Cs9lNagu0IwDBakHIFpbkexsdTDA2J4wczW3Mt9KQ76CRPW9khN21gNS+gwpbEGU1VlZmtTzA+vZ/hsZ34Ua3xh5aSTGsnTrYLZTYOoPpelno5g25eaQpgWoJsKiYtKrj1aZy5UazJwxhj+3DKk8fHiQF0Sw6vK0+pzWG6RTKeCRlxahy2Sgw5VQqZxkHEY7KGS7eRoVvadGlJZxjS7tfoqJVor8425lFEWuvjwaOFwrfbqJmtlFULsyLPtM4xEWcYDTIMeWkO11NM6yzTOv+oHgSAbSpSroFlKwxbIS2FNiWhKfANQV1BWUJgSLQpwJSgThyHgMaxiJyKyEm/ERaiSooKKV3C1UWceAYnmsWJpxuP03yeCg515KPuRO4gRAqtXbR2iCKbMDQJAxM/MPA8Rb3eCI0wMglDi6gZGGFoHX8vQOPYhW2YWMrCkiaWOBYKClMbmLHCDOXx6VhYnFJ4yIhYRESEhDogjJsBEjVDJKji+VW8oNp8rhEagfZOrJ80bAUgDasRJIaNVDZCWgh5UohoEx0bzSBRRJFCYDaDxmyedmuCMJph0lg/FibQ6JUoETd7JY2eiYqDRkjEHjJsBIv0a82piqxXjvdKZOQj4wAVB81wCZBx87EoQMbBiV4yjeMlkWUQmYrQlISWJDQkviUIjEZgeIbGMzR1pakbMfVmz6UmI2pG/Kgw8Ztfc/J6cNI8krDtVdtP36L/g6/+jBs+/CCXd+/C+MGnefH/F/DXop1rZkLOn3gX9St6eH36G1xUO8CDm87jutLF3Dr6FfzcGeTlctbf9re89g3wtqBGemYRrw3ehndFD6+WX+D84gYe2vZ0nu2dx2z9EA+P34yZfTnZwjDrd36e914H2c6Iz4yMcH/qXO72ruZcYxkrC93EmZiNIzcyPLOL1r6VRPE5ePVuWvKCBYWNtN77TYzYo3TeGdyyJuR7HQcJDcm5mYVc44Vcc/gROr0ysd3C/rbLuNE/iy+PL2QqSpG2FUsG8tBuc8QVTNiAEHSagjPtEivEbhbW76DHvw9FjBAGprmQMBygWGxjdMRkctJE68YbPZ/JNW6qJnK0ei65gkm2biOPFb6UJHRDaqJMsT7NVHGIsaP7KNWnjp/vbjouqXwnVqoN1bynju+lqJddNNnjZ6MAuK4gbYe4VHH8AnZpAmv6CMbofuzyBEZYO1FyhSBuyeG3Zai22BRzisl0zHjK54hd4Yg1x2xKM5dqBOExjjRpN9K0S5t2FB0xtIchHUGdtnqZllqR1nqZluaVs+ZJ76tYWvh2K1WzjYrMMScyFHSG6TjNZJRiIkgx6jmM+S4FGs8VSROedMmKFODaBratMG2FMhXCbIRCqAS+EnhKUJON/4zabAw7NeaPDgyBJiNjsjIkLQPSeKRFjRQVXF0hpedwdQEnnsWOp0np0mOCo4o6tvcNgIHAReOgtUMcW8SR2QwIkyBQBIHC9yT1OgShQRSaRFFjCk9aPvnAt2WY2CeHhzAwtcLUCiOWmLHCiCRGKDBC2XicZrigGpNWmBjNCGmGiNLEMm5MIiLSESFBs2cREEQeQVjHD+v4fhUvqB1/LtQBkT6x3Jj7RHFwokdC4ziIMiykYSOViTweJicFBaoRKtogjg3iSBHH6qQgMZvv82OhYgAGNOcnn0IqhUbJGCViFDGKCEmIikOkDpoB4TcCJGwEjQzqCL+G9JphEx8LlAAZNUJJ/k/r+sRr1VKwZufO07fo/+Tbt/GdD2zisuUTmJ9+L699R5o/yPby9j2bWFb+FOYF3VzSe5iX1/+ZO+74A54VnEcgpnhw4i5ieR0XbfxHNlwac9OFATfs3c4LvX9gc886zDUu/ybfxNSe5UyNnM2LgyexZeYWDld3Yaf+lJ6xuxkYupH3XReSbTP4/PAhDg8M8oPJqzHo5+xgMcsqnYTZiAdHf86hqUfIdQ6i7LOplhdiWhb97jQdD91A7shmRDrF2HkL+enSErd0jqGl5OzsQq7y4dLhrSwpz4KQFNvWs1mdzXeLy7m5OEiEIusY9PVmke1242ZqFiAFKSlY7XgsU2MsiLbTW7+Ljmjv8VsnmMYigrCLcjnP1JTN+JjE9xunWZqGSVu2hRYzS4tOkfMcMnMmuXpjJBkACToj8EyPalxkrjbNTGmMyenDlOrTJ8aIhSCVa8PJtGPYLQiZJY7TBJ6DV3WJ41TzLJTm+K8C1wVXBTi6ih3MYVanMYsTmFPDGNPD2H4RIzpxaiRCEOczBPk09ZxNOWNQTMO0GzHheoxZVUbMCrPpRkCc3HsAyCqXVuXQIk1ataQl1rSGAS2hT6tfo8Wr0FqboyUKaY0a57A/9prU0EjjmXmqRo6KzFESGQpkmYnTTEcppkKXo4HNhGczGzcufprTKUqkHhUYAnBshWM3ehfKlEjjWCgIQikIFPjN0KgJ0Eajh6GNZmg8pqfhipisikiLgJTwcYWHS70RvLqCo8vYuoQTz2HFBRw9h0MNl+qJ7ag95pgGgAPN8NCxTRSfCIYwMJoBIvF9ge+LZlgYzamxHMfG8ceODV1JITGVgSkNLGk2AoRmSGCcCJJIYsSyGSYSEwODE4FioDC0PL6sThoa00KjZTNQRDNQiIh0MyC0Txj5jVCJPPyg3pxqRHFApBs9mCgOiXRIpJuPNZ+LdHB8pwhAKqMRKMpEyOZcGM1wORYMBhoF2kRrhdaNYNFxM2BOCpHHBsvx545/rxOvVaBRUjfCRkS8+vqnn75F/2c/voOv/cMGLjmzjv3Rt/Nvf7GEVJvJxx75BZd6H0WuW024UPM+74/YsvkPWCkvYn25l+/s+CBOy3UsZI5FD32aV76mznvrIX0zOZ5T+zuCCzs4O7WDt8oPsHnL02kvLuOacDW3jn+NKVEl5byCJYduoG3iPt57XYTR7vC1ob3Mdrts6ryEnbuXkDZ6WesPsrTcAWnBvtIWth+5C+lY5LvPpFJaQhR1kM0K+oMDtGz5AanJfYiWHOPr+/jFghI3dY1TswW9dhuXmK1cWpjigpEdZOOI2MpytOVMHmYlP51byM2Ffmo42KakvyuN1eJQyipGbBrnwwtBRsIKp85SOcJgtItOfwvd4Q4sGt1opVoRoh+v3kGplGF62mBqSuH7J4Y8sqkMrW6eFpUhGzpkaiapOUU2crBOvkDbFYR2hCdqVMIixdokM8VRZgqjVIO5R3XdlWnjZFqw3BaUlUPIxhk0YeDg1Szi0AWZelSPwTDBtZq3UNB1rLCMWS9iVmYw5o6iZscxS5NYfqnZezjxPtUphyibws861NMGlZSi5ELBjphxQiatOuNGlRk7oOzCnAuB+ehyl1EOOWWTEyY5ochp0biFQhiSC31yfo2cVyFXL5GLInLNC55ycfzfLmOPlItvZKirDDWZpiLSlESaudiloF1mI5fp0GUqtJkMHIqxyxxpSjpFicbVsicPSQnAthSWrTDNRnCIZi9CG5JINXocoYK6bEyx0RyWam6D+u/hodCkZUxKhqREgCsCUtRxqDev163ixCVsXcKOi40AoYpDHRuvOa8fn5sEjwkRC7DR2j5+wDiKTeLIIIwMwlAdD5LAF/iBbATHSSESRQZRfOwxgzhWnBwmhlSYysAQjVAxkCcFRDMk4sakYoEKG8uNIJEntqO5fqzH8phhLjgRLFo0w4WIxr8hsY6aPZGw0TOJgsbxkcgnCD2CoE4Q1I9vczxYjodMdPzxuDk/OWSEVM2QMRDSQEoTIRtB8cZPf/L0vQ2DnWp0zCMnC8DSsJUH4ikArmiZ4t6izx4/Q4ksi5dUOXhwnLNqfXRnFxNkdjPsXc6CiuZlO9r52PkRP5jZyrPkBn780MVsvvxs7o0v4YJV9/DAQ2kequV5cucLuWX8K8z43+TAoj/CFBHv+cr9vP8P6zxzwQq+NrKX9d7DtJy7lZnKOjbsXszmXDur1UJWyPWsWH4eU+YYjxy8jWr1HjJtvcSsZVdtIWLNW8lmNL3+AfJbb+Eld47yUkNRXrOArctMbm4b4bttNcSiQVa43ZwbGZxbPMr5E/dxbRyhXUUhv4rd1mru8ZZw0+4eRsMOQNLlmnR3pVA5i4Jr8ENzAfXUEpDPRAgYsGIWG3MMihF6wl10mpvpbj1AS2vA0mUghYtUPURRB7VajmLRYXhSUio1Tl/EFGCCYzvknSw5M00Wl2xgk6qbpKo5FkZdLEuvR6Sb/ylMQexoAuXj6SrVsESpNk2hfJTZwg6qwRx+XHvUG9ly01huDsPOIo00sUhT1WnKkUMY2PhhO8IZANdF9Jy09yzBsTS2irBl86rYsIrhzWFUiziFGdJHJumfm8YMA8ygjhF6jw4K2yLKpfAzNl7KpOZKqrag5GjmrIiC5TNr+AwbNQpW2Lwq1qbSbv+3wEhJi5xyGlfJCkVaC7LNi5kyUUgmLJIJj5Lxa2S9Kr14ZGRMxmgO9TSvkD3eNiEJjAy+kaWu0tSFS1WkqOBS0i6lyKboO8xGNrOhxVRgU4js5hWzLuXmxU4VXPyTBrsEYJkS01KYhjze6xDN4JhTJrPKIlQ5AinwJHjHeh5KNuaGQKtf3gNRaBwZkxIRrgixRYArfGx8nGY4WLqKravYuoypy1jHQoU6DpVTDBMTsNDaAm0SHxumaQZE1Bz/D0NJGEqqgSQIBGEomwGiGj2SWJ0UJifW49g4PlxqSIUhDZRUGEJhCIkSJ0JCHZvHEqVFYx5LVGwhI7sRMEicZg9FIVEnLRvN9ePf57HHU04OGnEiaGKi4wEBv/FHmDTeF/O5p3//fRv4r7fcwbmXtZB/33Vsef3lfLRjC/fv28NNXa/lnZPXcPSyTt7hfJtzgwe5/RcX8rz4IpTt8bPtn8fMvIaV7Kf3oa/wytfUeKN0edHENBeX/pmZBd2YK03+Wb8d52ieh3ZdyJX+evrrDjePf4mSnSVrv4Qzhr5H7+E7+LdnW2w9Q/GfE6MMkubmVavpy+4lqK1g9+4+yuVulqQHWDrbTn/Yhk5phrw9bDt0O5WwSK5zEMNZTmVuAEQ7ti3oMmdoOfIA+d13YvtFdCbF1Koetg5qft4xzv42Hy0ES9xuzhQua8tF1hw9wPJaCQuIzAxTmRXskUvYUBvgF8U+dkU9RCiUFHS1umRabHTWpGBLxs2YsHnbBAH0mDEDRpUeMU23PkJ7uJf2YBudeux470AIByk70XEbnp+lWnWZKxrMzkqqVZcgOHEfHdMwyTppMmbjlgnp2CYVWqTqBk5VkY5tnJNul4AAbUNkxoTSx9M1amHzatjqDIXSUSr1AvWogh/XHvX+MCynceM1O400UkiVAlzi2CaOnMbZML7dvF2C0zzd8NFXWlqWxj52CwVdxwyrmH4Zwyth1AqoSgFZnkVVixhRrXlR04mrYY/RpkGUdgjTjcCou40LnKo2VKyYkhkxZ4YUDZ+C8imaPjVLnHSFbGPs/+SCaQpFVlqkpUkGRQZBRkO2eYFTIzwaV8lm/RrpoNa4D0/z6thjc0vzqLZG0iRQaXyVxpMpatJtHh1wKONS0g7FyKEYN4JjOrAphCZVnMZ56jjUjs2xH3VREzRCxDIVhilRhkQaAqFO9CxiJYikIJIQSoEvwRcQKqC5nT7WCzl5WZ4IlGNhYosIR0TYhNgixCbAFj4WHpZunsyo65i6hkUVM65g6gqmrjZPjvROmvtYNL+2+fijj5UoGsFigrYaB5O1+ajhmShSRLEkCiVRJAkjQRgKwkA0nm9u99+mZo/lsVMjaASGVCdCpjlXKJRohoWWzfAQKC15yd+8+vTd0zeaXdfQTAEwMGdQa60z0jLAajXEXC0g52t2Zi/nrPo3se0zOZQpcO7RAWQsybbu40DtTLqqMW/eOcgnz5vmGXqOD2S/zeuPvIp6VzsfbH0X7+v+K5ZVWrnjiODpnMvVva/gtvEvUQ++yp7BP6KcauEdN9zAdy6zePWTOvnTgs/rHrybTyx9JeMDkkvPugk3buPIkaX8vNpLKtPGMtXHwlofzxx8HUEmZLS6j11D9+H5t5HKd2BaSxmv9TLUeiXi4qfRko1oC0bJHNrMJT9+gKv8GjqTprC0k729mg1tR/lIZ4VSTyuG6OAMu4M1mKwpF1k5dRNvqpf5C1MTOzal9CJGzQXsivrZdLSL+w90UtDdGBhYAtpyDum8hUybTLkWe6w+ivYA2Jc2/mMJ6DEj+lSVTlmgXR+lNRqiRe6jxdxOd36KwQXHQsFu3FwtzhOEGXzPpVq1KJUMRoqCeuDih27j9EgaXfCU7ZI2XVxlk6J5y4TQwPEMHD9LW9xGv30Glm08OiAsiIyYSAYE+Hhx85YJfolKrUC5MknN+//be+84S47y3P9b1eHkyZtmd7UraZUDSAIMQoggggATTbTB2GCwccDmGl/wdcTGxvcaJ66zifaPZBswQSaDwUhCAcVVWIUN2jg7O/HEDlX1+6Oqw5mdFfiCWQnNK/Wnq6ur+/T2OVNP9/s+z/sukeg+seofxw6xQNHAC2p4vlXDpqJCaio2dYK2+lblTSFaW2CkUgKMkntFQOBbYVMgFIGJ8XXk0ih08aIOQX+Zibkl1nUX8QZtBxoCPzV4SjmWR2FGSnQ9RNVCklpAVPOJKtIqYMMMPFKW/ZSFIGa3F9MLNb2KR7/SpN9o0qsMC5oAfCGpyZCGEzc1yuImrWloRT1doJ7G1NOYRjJgnD5bhKYuDXXPCpsauhA5laFTC4/UqzlRU42BtM/wfeFAIq7SNSFtl3KhrUKWVFgACRV6xq7LgDIgZKVLyw+kfSPxM0CRCE+QeILY81j2fLRXR5dAJREQC4OWJSCRBZCYDFCydYkw4GOoSgcsDlxCkVhwISIkxicmICY0A3wiAj3Ap09g+vimj28GhG6MZdEnhPk6sccS21QcxPikK/7VgRPa+Rjj54FmCzQ+SksHODJfvlc7qU/6N954I+9/6zfZdv4kW9/zRuKLzuYVF13NnwfbedKRfZx59J2c+4RpDk1K3hW/mM7y87jvni28bP6x7K/ex80PfBnC13BmsJ+tX/+//OrP+Jy+fpJ33309v6jfwmfTi4ku38jjgut5k3gXD9z9JA4c2c6z44topVW+eugDKAVi9FVU4vt4/A3vZ9+2iHc832OrDvmbY3vYVzmTt533a2wYXeTS5JOcyf0M+mewd+965o5NM1IZ41S5gVMWx1inR9BVwzFziN2Hb+Hw8r2kJLSmtuGF2+h312HYgBAVmjXNhDlK68gd1O+/kUbnINIo0k2TzG4f476plG8357h7os98C4SQbAnHOENU2BEnnNGeY8fiYbYlCQFghE+7uY0jwTb2mvXcFU1xc3uce5MpDjOJRuJ7gvFWhWrTpkyIXcqEhQCbWC0slLETnmaj32edXGaCOUb1DCPqIK10H2NmljHmqZExdQRSjgFjKGVz5EdxlX4/oNv16LQFURSSJDXrTiIT/XjUwio1v0JVVqgKmxYh1D6VxLdK2EhS1QFVrBJ2SAUrwQTDKtjERMRqYFWwSZd+tEy3t0SUdIjVgFhHJHrg8vtnJgiqdfyg6lInVBCeEyo5t4IxjvWSWDbM6krYIjwsBAReiY9Ogm9ifCdQ8pI+XmQBRA46eN0l5KBthUzpIBc0+ekAqYsArBECXbXgoSo+ScUjrnhEobBK1wB6gaYbaLp+SttPWfYS2n7i1LHFuEwZGwcF3xygJgLqMrAgIjzqCKoGasZQ01bMVNM23UItTamlEbU0oprGboy2widtXJoFq46tGZMH0DOFrBUxVYhllVhUiISdbvtZCgUd0jMBXR3S0QEd5bOsAjq6UMLa9Ath7hzqmwp91x8RDOk8pBQWWDyB59k3FelZcMkAw0iB9kBLgZZ2nQpIhSCRFKCSAYtkCFiMFDYMIY8HGoEhFIaKUARCE6KoiJSAlFCkDiwcSJjIgokZ4DOwazPg3U99x8M3kHvjjTfysT+4nsZYhQuufRdKp7zwWXfwxomLeeO3P8mV/nsIp7dy/alV3lX5M7bpRb7y5Yt41tjj2NoZ5Z9v/yPW73gm3eXzefwN76B3Wo03PHMvf5g0ePbsIZ7S/n32VzYSPWkDz+IqXs372X3n0zg6u4VnxBcynjb5xpGP0ovmEaOvAGl4zC3vwzf7+Isf9blvq8cvz7V5cXeZfxj5Mf70rJ9kvAWXmS/zI+qLbBQdut0dPLBvjPn5jVS8EbYE65lut5iOx6mLClEtYmawj92Hb2Guf4CUlOb4NEF1M9FgHWm6HiHH8DzBWHVAa3CYxuE7qe+/nUbvMJ5O0a06S1vHObgh4O6JPrfX5zkwoWnX7MS5ORjlFFFhW5KwtbvEtvZRtkUDNqWWV6JlSKe6iaPhZg6wgfuTKXb1R9jVH+WQmeQYoxgkgScYbVWo1HxkzSMNPXqhTZkwCCWmIqHi5T/imjSs82ImZZ9xscS4OUbLHKOpZqipQ4yYeUZYYoTl3J0EEilGMVgWUJpWSZKQOAoYRD79nqTXE8SJVcAmK1SwUkpqQQEUFeGUrk7QFKSSMPEIYumUr5aPHpbIhFBSwfpWzGQBw3LREzUgSiwXfRB16Ecd4rRfiJlKgqZhhkeAH1atoMmvIr2qEzRZX7QhcE9xASr1rCJWhI6LPixqKtMErZjJEHgan9QBSIKnI7yMd5708eIeMuohBx1Ev20BQ0X4maBJRYUIqixkEgJdDVyKBQck4TCQ9ANDP9D0pKLnpXT9lI6XMPCNVcE6dWwUWBAZuHUU2Ekzs0BIasKn5lIu2KUEKk68ZEElpaYSqiohTGOqKqHiAKWyQrRUdcKlrK/swkhlhVRWSWSVRIYuBUPm+LHP5X0TMjC+U8j69Jwqtqs82ipgQEBkglwVG7lUDJFT10ZD++07QgY2QoDvuTcYTyClQHrWLSaksJ4lUbyVaAlaCLTAusoEpMKQOkA59JrLHt6T/lV/fRvtuT6X9z5F9+qr+R9vHmFHZZI/u/6TvH/L7/PnB89m7vJ1vHL0EFcuvoldu15FqDZz5YFz2F2/k1t3f5Wg+Ro2tDRnffLXuOqVp/LxHcf48KEZxvxpnjjzFrqjI8Q/MsULzb/yEj7K/bsu4+jMaVwWncF2vZFvzX6Ow717qISXYWoXMn3wM5x9/1e5+lGGv7/C41yt+J25ozTjBn/V/Eneu+lZpOsbnFpb4iL1TS7W32A7+0iTUzlyZB2zRyfodsdZ15hkox5n3XKNDWqMuqiQVGMW0qMcOHY3M+29tJM5/LBGbXQa6a0nHoyj1CTCm0BKj2Y1pakWaSw9QOXQXdTn91Hvz+DpFNWs0d44wuyUzwNjKXc1ltk7FjMzBlEo8IXH5mCEaREwnaZsGnSZbs+zKeownaasT5UDhYBuZT3z/npmmGK/nmB3PMb9/RaH1ChHzRjHGCXFRwDNekCtHuBXPExFkgaSvi/oeIY4kJjQ9pffHOpSMyYTxuSAMdGhxTItM09TH6OuZqnp2VwF26BNgy6+S4tcVsFqXUOpGmliUyYMIs+qYAeCKJKkKnSCJidsWsFHrwQhVS8klIUKNgeMjDqYFhTC0BQ0wwCfEC/P/w+Oh+646EqkOWXQCpkGxGmfOBnkYqY4dTx0J3jK166dg4gQ+EEF6cRMQoYFgIjAgUhoxUzat3l5lF8Cj7J4yS+1S4FYafClLqVXSPFM7DjmNsWCTPp4Uc8pY7t4cW9IFVvmlA8pY43K306076ErPiq06tg0tHl7EgcSkVPH9n1N3yljs7QLA9/k6lcrYhLEXiFmyvt9Fzdw/z4fWVLJCipIqohCHWuMU8BqCyQ6paIUFZVacEkTqkYfBy6hWyrGEBhDxZD3hceBTYgSoU3HIIolJnRpGQqgGJiAvgks8Ohs8ehrn652TibjExHwN+98mD/pf/0ju7j3hhleeOZdzP75n/OBP3s6O/v3c9UdN3Lf9lfw9DuexfnP2MZMzfBH0UvwvWfyta9O8mMjlzPRr/IvO/+Y9Tsey8Ls47lk8DVGb/0sv/X6OvFklY/supkjo0/gmYd/lniyTnLJJM80/85Pivexb/fF7N9/Lhcl27lYn849S7dy2/yX8bxtyNazaXYPc+5dHyIRh/jIUwTfPE/wwk6fX1hcYJBM8sf65Xxj6mkcm6ySrquyvh5zATs5K/0m53M7oyh6vS0cOTLGwvw6er1RRiotNnkTrOs1mIqajJsmwhf0gy4LgyMcmd/NXO8gy/EceILayAb8cAqlxogHIyDHEXLcgkElscKe7lGqx/YSHt1DvT9LdTBn3UQjdbpTDebGPI6MaPY2euxt9Dg6JpgdsRRGD8l6v8EmGbJRw/o4Yl2/w/ruPOvShPVKsU4pqq5KVxSO0fYnmZfjzJoxjugx9scj7IlaHNVN5k2LeTPCAk1bvQuo11zKhIoHoUT7ksQXDHzoSpu50YTS8tQDu87+cBtSMyITmiKmJfouZcIydbNIXc9TU7PUzcKQkKlOjxr9UqZOAdSAGsbU8rTIVsgUkMSeU8EK4rjgoKcqyKmEaRrkQTfA0QYDQi8glE7IlClcjUegJb7ycgAJtFfw1M2K9Ur+uTRoaTAZiDjueVLincfK8s2jpE8Ud1eAR8FTt/TAZIgOKP0AzwuRfpiLmHIhEz4GCw420OiYL8pbASQrFbHl/uLtxJNOxERZHZs6xWuETONCIZsMEJFNtyDjfkkRWwKWbLukji0rZI0AHfhOJesVKlmnvk7ydAqGyDMWUDwLNH1PMZCKvqeJA5u7ZxhYxBC4JL4dk60zcaGHIBQeoZCESEIEoUvJEDIMEKE2VIxNyRC61AyhVoQqoaLT0lhKIGN40tuOPrwn/W9/fi/f+rfd/PhLJEd+8Y3c+vaX8geDT/JNvZlGb5mzD/4mT7p4E5+bFPzxyFWc0v0E133rRWwa38pT7z+NYxtn+cq172P9jp8m7k/x2OvegZzweO0LD/MjY9v4s9u/zu3rns+L97+MdLJGcskkF5vrebP4Y+Zmt7Lr7suYTtfx1OR8+tE81xz9FB0VEdaeigx3cMr+r7B93+fZNxXxvmd67N0Mr15a5rVLbaSu8tH0ybw7fTFmfJL+REh/IkSPhZwaLnGuvpkz1A3sYBfjRMTxNHNzo8zPjdBuT6HSBpOVUSZpMdGrM5k0mTBNfCGJw5i2nmeuc4hjiw/QTuZppwsYDNXmFH5lCiPGSKIGWo8g5ChCjiCFoB6mNEyHajRHZekwwewDVHqzVAfzVKJFCwqtOv3xGksjPseaViW7v9bnaCNlviWYb9lCHghBS1ZY71VZZyTrlWYyiRmPukz0lxhPEyaVZlzbouNV93uK/BG6/hjLcpRFWhzTFhhmkgYHkwbHdMuCBCMsmQYdqhinI65UPCoVn6DiIUMJgYcKrKgpklbUlHoCAsdJz1Io+EWunYrQNKQVNDVERF0MLCA4MVPNLDsV7EIOGJb0OKBC360HJYaHhxUzOR66DlE6dPxyjyTxSROPOJHEkSCOZYl7vjoHfTUxU+BAxBcOKEqqWD9TxSph12YVMMmOWZleQVoKoBEaJTSaAlBSnS0RSRoXCtlk4EAjIdVOzGQSlE5IHe/cipkKYJFeYAHFC0rc8pLKVfhgPAy+FTDpYRHT6kKlB1fKSmGQQuMJg8wVsgppUjyT5ipX6YBEOLCRSYRIBojE5fvRCdKB0lC7BDBSp4WSVqcI45LHSWHBJvDQvofyBcqXpL7Il8SzgBF7FnhiaYg9TSQ1sacZSM1AKmLP2LG+HZtmAONA5p9/586H96S/67ojfPn9d/LSX9zB3EueRfSmV/Pqxkd498an89Rr38ebN3+Y6+ZqzF06xaWtlFctvBRP/jj/8R8eL97wFCYPB3x57sMkXkJqXsLUmM+5//pLLD3hbN5w+S5e0DiV37vjG9w2+VxefPCVqNEK0ePWMa0O8Hb/fyEGgttvfQZmMM7TkvOZVmPsXPgmdy9dD/5WgvoVhDrk1D2fZvPhq7lri+afrvB4YCO8qN3hZxeXWa8UM94mPhY9gc+px3G/dwq1iTrLLY94zILAhsqAM8X9bE+/zQ5zN6ewl8CMMBhMsbDQYGmxSaczzmDQYqTSYlw2GY1rjA2qjOkGY6ZBgEcapvRos9ifYW7pIO14nk6ySC9dxkio1MfxK+PACEo1SZO6TTksWwjZRAhJ1VfURI9askzYO0awfJRg4RBhvEwYLVvFbNrDhD7xSI1eK6TdlCzUNLPVmCOVAXN1lRccX2pAp2Z9wzURMCFDJoTPhMaCQRwzEfcYGbQZVSkjruD4iCs+bt8kJLHfpO+36IombdFkyTRY0DWOpXWOqRpHk1peQ3bJ1ZBdMg3a1FEuROj7kkroKIWhl4uatC9IPemAA2JJzj83ngMMTzhuurQP9UJQEZaHXnVippqIqRJRpW8Vx/QITYeKbhOatlXIuizwFQbU8nbfcdKjvAbxMP+8gjZBrnC1giaPNPVIE0mSWkFTknqFoKkEICdSxwZekNMArZipoAL6xgKHZzIxk8TXAk8JCzKOLlhWx2b88rLAKQOXXMSU88sV2tj8PZkoKQcYFZMqCzKpilBaOfBQOYhkbW1K+/TwPoZETAXQ2DcTDwvWnlPKerlSFiPRxsNoaccIH/CKY/JtPz+HBSQPVozxnVpWopFCO8ApL6kFCJ3mACLSBKFiZGpBSDgQksaN0ynSKEQOPml+nkuvv+rhPekfuneRT/7JTfzoL11I9PoXUH/K5bzgnC/yilOeya997a/59oW/y49dfybPft4ZfCbp8f7mX1Ed7OS6bz2f0eYkzz54LmaDxz9/8w/Zet5lzB58LGdtWGLzx/4XD/zoxbzl/Fv58dZZvPX2L3Pvuiv50f0/Do0q7cdOURUD/pf/draxl733XcLhw2exTa3jycm5pGmfb81+htnBfrzwPPza5VTShNN2f4qNM9ezZ6PhQ08R3HkK/Mgg5ucXFzk/iukLgS9q3CrP56uDHVyvzuYOtlMdbxKPBHQaHnokQDZ9tgZLnMJeNqc7OYU9bGMvo/RJ0w10O6MsLFbodlv0eyMMBi3qQZNRr8GIqtIchLTSGiPGLiE+KlAMRI9OvMBid4al3iy9tE1ftemnbVKTEtZa+JVRq5o1TdKkhtE1kA1bdFw0QFTxJFQ9W0u2krQJB4sEnVn8pRnCaNnVkO24pQdSkIzU6I9U6NUl7SosVRTzlYRjwYDlis6LjbdrthRgp2ZTKoTCY0QEjDplbFZ0fCRNGIkHjMZ9RtKYlqsf2zS2olOrVMkpkdWiFKCo0aVOhyrLusaSrrCQVplPKyxqW/KvQ1FHtkPNVnuiRh/LLpJSEASyxEe3oibjQEJJq4jNuOhKnoB/7smhfqQgQFOVTtCEFTVVHYe84sAiNH1C0yU0PQLTJTRWyFTJx8RuHZWOK/PPbcZLyzwKi5wzGRVQORpg6pEqSZoKkkSgUkcRLOWnGRYyFcdn7Yxr7kvfCZrcUkqf4BlpQcNYvrnUwipmlSx46BRtP9/28n0+K8ZmqamllS/lYGOylAxO/aqzxb2lKLsonQFKOrS2bWWVsu58w+PcPtdvBVUSKf1cNWuBpwQaJQDCSAs+SNvWHtrIEqDIfPwwyNh9v/y+n354T/r9Tsz73vJNLn3xDiY/9nuohQXe/oYWg3TAR++7g3TyTB517+t54jnr+cxGyc+sj3nKzCup13+KL3xe8fSznsj2W6sc3TrD177xAU675Mc5tHsjF43ex/in/oxdL3o0v3X2Tl7Q3MHv3v5VFqYey3MOv55eOMbCOSPoiQpXqs/yE8E/stSd4p6dl6GiJo9LzuRctYWFaIZvzX6GdrKIV7kAv3opvtJs3/cFthz6Bot1xaeeAF99lGCdUvxEZ5nnd3ukQnLQE9QMbFYeD/inc2N0Ct9OtnObOY19YprqWI2k5dOpe+hmgGn6jFdTtogZNpi9bFT3s4mDTHOQKeYxaowoGqPTbrDcDhkMmkSDJoNBk1A2GPEbNEyFRhpSjwKaukrTVGmYKnVCjGeIZcRAd+nGSyz3jtGNFuilHfqqzUD1iJSdwG092SbCa4Cpo1QVldZcsfGVtWQloacsQU71LRBEy/i9RfzuPMFg2fbl9WOtotbTKaoaEDcqNp1CzaNXNbRDzXKQsuiqOfWqlMr/DZcCTH1BVXiuhqykgaCpscCgFK00oZFGNJOBFTy5Ck9Z8Y2aq+JUd7RCD0nq1YhllUjWCk46WeWmCm0dsqzcou0zfNdx0bN23/HSe8YV6HDlAKUU+DkXXSD8Ybqg9gTKc4wNz/LQzXcAkiEKoYBAOP55BigiJsypgDGhcRwU07eiNdPHNz3HZcl45UW76Isd97w8LkG6ZGZFpswAbYbBQSkPrSSpkiglUKkVNlngkG58Sbjk+OlDi5FDYimtPTxhhU2eyERNMl/nILJC3ORpgcyBRyKReAi3tsWMsuOzfZ6R+X7bX+6z441wZUiFxlAAkEYX6Ra0KgFRUqyVAxxUDiba6LxPl/pe8YE/fXhP+gAf/PWr2bRjjEcvfI75D/4jX3vv6/jbu9/Hf6y/kvHr38M7z/033n9Lhye+6Ay+0e3x3uZfIzrf4oF9b+DAgSVe0Xoq4VHFt/kau++/kelzX8uxA00uqd/OyFV/y94XPYb/edbNPHn0TN55x9WEtQ28Mfolvt7ZjL+tydIZLaYGM/xq+EdsFDMcOHgOh/acR4OAS6Pz2aImOTrYzy1zX2Y5WUCGZ+BXL0NSYf3sTZy674v4yTw3niG46jGaPZsMj+0kvGjQ5in9Pgd8nzvqTZaEYTKOOCdJ2KQCHvBP49Z4M7cnm7lXb+Ees5ludZygFTKoewzqHqbho+s+YQ02e8us5zCTah9T5hDrOGoLlDNDaEKSZIxBv0GnU6HXrxBHdaKoThzXSZM6zaBJQ1ap6YBaGlKNPeqmQt2E1ExI3VhFrfEMiaspO0g79OJlOr0FBqqbFxy3ANElMbFNlxs2XGnAKoVyNsQY1zeknLUFOzwJgeMmB9qVA4y7+FEHb7Dk6sf2S/VjbTUnPy2KcphAktQCW3i86tGvilzs1PUVHS9l2U+Kik05P71ER3QVnqIQfOFRFx51IakbSQ1ceT9NTSnqWtmqTVkFp5yLXvDTswIbK6s4ISuWky6qrhxg9nwe0DMVesZWbLJVm0LayhXasM/+jovutk2Yc9EHpTEDQqTvW2qg45+L0luGkQLjOOhKCJQHylEDcwHTCoHT6oInrMJWQig0oRM4hU7glIGM5ahYrnlIhG/cQh/fZKImS0MNSfBJnJDp+HaxvzgmMAqJ9e9b143v0jM7MMlVsdKqaTPQURKVkrt4tJFuXd625zAZ2Bh5gu1inDABnvCRQuIJBxKiBBjGAUYGLsaupUvpkLcRSDMMSBnQPO2dL3/4T/pX/fVtLB3t8bynDDjwc29Ev/t3ecXhd/D757+RF37m1zl62e/zuC+fzk899XT+Lhzw+k0hTzn8IsbHns1VV02xZdNmnn7wbLy6xxf3f4BOd5Gpba9m7lCFSxo7Gfns3zD/lAt504/czXRzHX9+6BCnLR3lE+Ov5S0Hn8S6qQYHdzRRLZ/HR9/k9dW/I0qrHNpzLscOn8aY9Hjs4DxO0euYiQ5y1/x/cnTwAGGwBRNeggxOpdF9gC0Hr2Hj0W+z1BB881zFf56nmB2Hx7cjrki7XN7vk6aCays1vj5WY6HWZNugx1n9LqclCacmCRVG2Se3sjPexD3pevaYjewzGzkk1iObNUzNZ1CVJDUPU/cxVQ9T9RivRGwQC0yaI4zqQ4ybY4wzxwRzTDDPmFnCMzXSpMEgqtPvVej1QuK4RuxEU7aUYJWq17DgQEhNB4SpFUpVCaiaMK8ta+vL+hjPkIokF0ZFaZe+Kw8Y677ty2rKKrtOdITwQzzHZy/qyFp3hFJWGFUGiaIwR7YvwCamTAmMy5nuygF6SR8v7lrhU9KzoqiS6Gm4+EbR1gEl0ZN0XHUxRCns+YquLCo4ZUU1hts2J3rGYY8DSANB6HlUHX2waoTNc+kKbNS0oqq1q+KUWI56qTpTzVVyyrdzXroeKrghsRWbLLiERCJ3GlmAcNTAng7oG5+e8umagKhUnamgE2Y89HAFT92OHxCQehWUFzr/unDc80yY5IKcohA6aQFaWrApxExl5SzDfcdtDwuiPGkIpCYU2iqosWKn7IHCN5ka1oJMATx2bUElzRev1F5t8TKtxAn2S6PxXUkZkblyjAWJLHitHWDYReRrpYQDKFGATw5Idv2zP/vPD/9J//rP7OaGf9/L695xCXsufyKTr389P7Hls5wzcQ7vvucm0JqfrPwZOw8t8yMvOJ2r5tt8YOPVmEN/QrPxNj73uYNcev7jOPemEeR0hat2/jVJGjO5/VUcO1jhURuPMvGRt6MvPIvfeMYxDtdi3iImeOm91zI/cRFvWHg1t0SbmDp1lH3bagQm4Ur1GV5c/VeW4nGOPnAmC4e30fIE5w92cGa6la5qs3vpZva0bwVCRHgmBOcivXFGF+9iy6HrmJy/k6U6XHcWXHNOyv2b4Nye4clRm8fHfc7px8z3K+zUFW6oh3xjssLyWMB2Izl10OXUQY/tScqWJGU6NQy8dTzARu5J1rEnneSwmeSgmeKQmWQ+mMSrh+iqRxRKEgcGVC1n3oQeY+GASdlm3Mwxpo/QcrVmy8soS9RNilF1kqRKHFcYDEKiQUCcWFBIkwppGuYlBD1Tp+pVqBJa5awObKnAVBKaoFQisBBKhcbHlzbJVEpK6koARqnltg/ijk2LO1QW0ImnTLGthbE89nJlJ4qiHFrb5FwZUIiM575aUQ7HCrF5xjSeSYoCHCpGlqo6ybhn6YYOMHJKoYrsMTmXvWB+eCoGoVABqKyaUyCIA+HAwRTg4mt6Xup46iKnECZeUcHJsjlKVZ0cvTDxAd9m5gyltFxyoGogNJqKowpWtCbUimpGE8yAQxec9AxMKmaYq15ZuWiDh9UJpCIkEYHLeGOfyzNx0yDjpOtCCDUwPjE+icmnZRKb9IDY2PZQvynaGX89xif1QpQMSL0ALQJEVtugBBJGCEvtFK66lmtrB0A2B1AZZMjPgXTK5aF+N1aUVLii+DwpLCB5nrGAJDU+ygGEGgYRk+K5f5ln3NopuTPKq0/KP1zxMOfpA+y+ZZbP/e3tvPjXLmHw629A+D4f+eXz+fi9H+drZ/0crat+lfuf/WGu+CS8/imn88FGzIXNGm+J30wcH2Vx4Re46aY9PPeSp7PpaoN3ap3P3vyXxMmAjWe+kiN7mpy+JWXrJ34TL5R84uWb+cjEPTy+uZ3f2XMHm3tLfGPiJbzp4NNQlTEqp49wcFOFUEc8K/0sL6z+G1Fc4eDMOSwf2IJWNc5knHP7ZzJiqhyM9vLA4u0c7t+P540ig7Mw/g6kHGe0s4f1R77NurnbQS9z11afG85MufVUQaflcVFP8cRokUuiiB2DhHSxwnyvyp60wq2e4L4RjyPjgiPjAtPy2WwEm6M+m6Mem1PFFieymlKGVE5whCkeSCfYm04wY8aZNaPMmjGOMsacHCepNqFiK/zEgUSHVmWbAQOBRIbQCiLGZI8RFnMRVZM2DTpOQNWl4cRUddOjbhRCh7aebBIQxwFR5FlVbWr7M9FUuZiHMDVCqoQipGICK4bSWb71ojBHuUhH4CiJAb4NDgqBFDgvqmWHJNrWmE3SiDjp55WclCvEkWrLfVd5sQ5LS8zT3UqbL0eKgsdORh00JVeC8XOOezamaHsUlMNy3vTs1V8gsZOApQK6whsqtnTCrGzgEGUwdtvpgxficFx2IxTGS9E+KN+CTJrzzq2aNvYsX33gaIOxbxyouApO3nD1ptQrACdrZ2vlA5lbybfK00AIAsc3D40hMLZsYKA1odYEWll+uksgFxhDgBniqQeuHZT6Quz2UJ/b9g1Id7+lCVAicxIVDqIYj9gERPhExiMyPgMdEBmPgcme5e00nBo75cal5/wEj9R4eTsbn+CTmBXj3Hm08EllgJK+BSjhkwh/OOmcAx0jnHJcCjQ27YgWsP+Xr3j4T/rdpYgPvPVqnvCi09my8+PMvf/96M+8l1d843X85mPfyss/+zuw8QLeKH+Lb9wzyxt+4gLeeWiW3zgl5IIDr6RW28bddz2PffsO84JHP5PJaxLklipfuu8DzB89yGmPeSkH7tnE+FTAeXe+n/DOa1l48oX85mPuZ6mqeU2wkZ/ZdS2VoMXHay/ht2cuI6g1qZ02wgMbQgJPc3F0LS+rfowpfZT9CztYPngKy4sbqPkVzos3cWa8lQDDoeh+9i/ey0x/D0oG+P7pEOxA+pupJ13G5u9k8thOxhfvoVOJ2LVFcvt2zd1bBEcnBWdEgsfGyzw6GvCoQURjUKGzPMJgPmCwAHOJx5Gqz8FGzGzLcGwUjo3AXEvQHZFM+B7r05T1UY/1acKGVLHBiawmlaKhAwZyglkzxmE1ysF0hGNmlEWsuGqBVr7uhKPoMES7EnCJLyAs6s+akqDK+JJakNL0bTnBBm3q2gqpGrSp5UU9+o4T38v7qiaiahS+FrYKVBqQplkRD5vrJlVBqQJUma5YFPOQpoLUVWyl2WAov7qnheW5D1EOy/nVSzTGnKLoOSqeAAzGMUJSk6J0TKKSXDClHF89zYJ0pijGkQ5tF/nUcwaIwD2BimE+O54FGAqqYZnDLnLaoGOKrMpvz8Y4cETa+cUYpDF4RhWcc7WCx64yLnqJNpjz2DMKYVLQEYf6i21QGE9Zlo1QKN+Q+uQ1ARLPWGDxCu56LA2J46sXQCPydg48JR576tlygqknSKXbdv1IF9uQAuGBkAIhwfMMHhaUfAyBNvhG20VrAgdOPhmYGAJDaXu4HThVbj52RdsvgVKAO96YImRsJDjukjE+RvioFcBy4e9c//Cf9AE+/PbraI5XeMZTJHtf9nI2vfMPeb3/YYwx/Mvk5Ygv/RYzL/xnnvxxzaWnT5FePMHX5jv802mLqPtex8TE07j+ukczM3OM513yDNZdneKtq3Fj54vcs/Matj/6chbnLiEZSM6dOMLkv/0fvFrIt567nT/fcgcT9XFel1R5ye7rkZVJPlv9UX7vyBPoh+Os3z7C/VMBqhWwPd7P0+WnuNS7mjiqcGTuNDpHpul0Jql5Tc5K1nFGsomWCTmm97F/cTczvX20kwVEuAFPbkcGpyDkBkbiBUYX7mFkYRejy3tAL7J7o2TnNs3ujbB7o8APJWfFKRckHc6JY86OY8ajOu1oHZ3OCP12ncFSQLqg8bsdjNel30iZb8DRWsx8w7DYFCw2YLEJiw3BoCmphoIJYxhPIiu2UlZcNaEUk1oz7koRhqZKap/3mdMNjqomc9qWGVymzrJpuHWdZRp0qNMNW/T9OiawCtzUE6gsN7ufgYTjw/uOieLbP8ZakNDwIupeRM30qGLFVKHp5dz3SomiuFpfxUTOjaHwtS7x1x3v3XHdj+O7P2gqXB9hAqQOHbiE9v0jY4bk+dVFiVbo2CQraIaW+17sL7Yt393DyQQwYAzGFIyPtEQ7zDjrGZ1QmSLn+jCwHL+dUxBxSlZAY33vNkV1xm+XOb89ow0KinbR56/YXkk19Eu8+Sy4CQKBtCx6hDZIoy0gOSARKnFglDjOukKY9EHXlt+e8dyV476feA0KpMK4ClxGaoxUKKnR0jhqLiTSoKQFp0TaJS3tL0DHgY0sgE2t3C+PbyuZHWfjH6nbNtKCVAZYV/3S7T8ck/43PnYPd33zEK/7kyex98pnEp6xg+t+9en83rW/x9899S+59F9/HhpTvOfs9/COz93D2190Pu9WHQzwdxtvZXnvbzE5eSXfvvHRHDhwiGdc8mROuTFECMGRTQf4+lf/iebkFBNbX8jM3iZjEz5nH7qK+rc+jd66iU9d0eCjG/cwVRnjp9MqL959IzUZcu3Is/jD2SdxR7qZTRsbLG2sMj8RUgkM56V38jTxKS6Qt9HptTi2sJX+3AaWltaDHGG7GufMeJKNeoxU9DkW7eXw0n5mBvvoqS4iXI8UW5H+NNLbSKBhrL2X0fldtDoHaHYOEAcD9q0X7JpO2b1RsHe9oNeEUxPNjnTAjiTOg8DNQYuldBNttZFusp7+oMlgySdpC/yoR5B0COM2YdJGmi5JGNGvpSxVDQuVhKWacZWmhF3XLa++VxOImqTqGUaMYSSNGU0TRpQVV426ilKjSuU8+poGjxrG1OmbBkumxoKusaBsbvcuVbrGFgDpGrdNLefQ92WVvt+g59VI/BDj2cyHyhPoUlGPvErUajx5F+gLPUXVT6jIhKoXURGR48L3clZJMERNTDieqrjK2qQERtmnNa3wtYKcKVJOhzsMHgWjxCvYIiVaYkFJtGwSMsAxAVIHliGiA8thNwWQeFpYIDEl+mFGVUSW+gpgKlMOpSn249KFCZOBD4AGbWmDyqRorXLaYc5lH6IXlumHGfUwLY432m6zYttoB0I25mOlbNbFobNLceCRgRJC4ihFIGQJmGQ+Nu8vgVrWFjk3Xq7ok2Q1f4W7H1IIpDH5vRHaApXQGqEVntGgU6RKbQ6iDIiMtttGOZAqtlfry0Ar65Ou/8lX/xAEcqHw67/wzRfhf+o9zP/jP7LtK1/k+d94NdPNaT44/VzEJ9+AftY7+YnbL+amBxb445+6hF89dITpasj/nbqa2b1/yMTE07jrzku55559POqcC3jc4VMwRwZwdpUv3fQ+5mf2s+3Cy+i0L6a76LN5E2y76Z+o7voWats0n39ijf9vy16qlTrP9yZ4xZ5bOC3qM9s6hw9HT+J9y4+h67VYN93i6GRAdzKkHhjO1bt4jPkyF4sb8dOEo/Nb6C5soL20nv5ghKoY41Q1zvZ0lHV6hEREzMeHWGgfZC46zEJ0BOX7CLkJKU9BeFNIbx2BVjR6hxhd3JsDQRDPMTcmeWBKs3ed5uAkHJwSzI/CtDaclkSclsZsTl0QOEmpRXWW0gmW00naaoq2Wk9HbaRnNpAkY4RpTDBYJOgvOS59jyDpunWPIO0hGJD6EUkwoFfRlk8fqpxH360IuiVOfbdqOfWqKhCBIAwsvbGhUsuZV5qG0TS1puH483VHfbQZF207MB6SiisEXiEylv/e0Y7SWEqla6mNlePojH3XPyCkL6tEskrfqzCQNWLPx/jSBvYceAznYV+FPVJip5QZKJ6nLZPEUwQyIfQSQmmDcqGI8B17xDJMYudhTofoiQVd8cHHeEbhG4Nv7BuNNBpPa6TWCF2wQHIA0WXmSIkPn1EOh4BnBTWxxCAR2vrKhfaRxgfjI7WHMD5SuXcY40CkDEBmmH4os3Y+ptSXUxZXH2/fhMqLAQ3CGECDMWA0RusCTLTlzJuMA49dm1I749WbUlsb5cYc315tvDE201H2BmUcUGlsDitjin4LaBKTv+PJEoAVbVHafvM//cEPx6QfD1Le95Zvct7l0zzuMQG7n/Mc1v3ym/jSU8f4w+v+kL+54q+57Ovvhj3/yfxrvsZz/79DeFLw1h+/kF+4/yCn1yv86fqbmd/927Sa59Lu/CT/+Y3b2bB+A0+feiy1m/vIVsihiX188z8/jPR9tpz7dOYOn0488Ni6UTG98xPUd/4HrJ/k1sev573bdjPTVDymNs1zlxZ4xuF7aeFzX+txfKzzKD7RvYCOP8bEhjoLYwHt8RDZ8DjDm+VMdSPnmes5k10kUcDC0kb6i5MsL2+g2xslpMEGPcapyoLAiKmxwDKL/QO0ezMsxbMsxbPEUiH9CWAaKdcjvCmEHKGSdmj0ZmgtH6ben6Hem6Han6FTi5gdg4PjKTNjgqNjMDMmWBiBlm/YrFJOSSM2pykbU8WGVLEuTWnEAVFSZzlt0k5adNQIPTVCV4/RUxN09SQpo44+WcUXktCAnyYWHOIOXtJ3HPrB8WvX1jJGe7EtsxjE9ANDN1CWRx9Q8Okdj77Mr89okKmPzYMeuEyRvuPCZzz6MnBoM0RnXG0dahDYJ2nwQQdoYzNXJnn2w+OpjLFjmKxGdYxZZby0S+IFNrWvDBjIkET69k1mBX0xpyU+CKNk5ZgMgKQ0+FLZLJpSEcjUUltlii9iApngC/vG4uVskiwUmVETs/7VKIsr+0pMFJPgGYOHxnMuG88BUubCEa4tDDmwDPPly1TFYS59DkJGYozI+/LtfL9tC21TMAgkGB9hJML4CG196EL7COPZbe0hjT8EUCIDHCPytiiBUXn/0HZ53HHHDrcxJQDLp2RjQcwYBAZjDGjNJX/6Q8DTz+zf/+Y2Zh9o85N/cCn7X/96onvv5ZQvXMWPff4VGGP4+FP/kurfPxVa09x+5b/y8g/cxuaxGr/8svN50+6DrAt8/vKUo3Tv+yWkrDA68ia++MUZ+v0+jz//MZy7ZwpmI+TmKne0r+G2W79EpdFkw+lPYmF2B8kgYHICth69mtFr/hWPlPlHbeOqc/p8YXoWHfo8MZjkWXNHuGz+EGNGsK/xKD4fX8in2mdxt9nKyEgNua7KbFOSjlUIaoKzvaPsUDdxmr6V07iPhuqz0J6i3x6j3xmn3Z5k0B+hRpMNusVG3WTCtJjUTWI0C+kcvd4hlqOjtJMFOukCA6ER/gjSTCHkBEKOI7wxPCrUkmWqvTka3WNUB3NUB/NUB3MIvchiM+LoiOHYiGbOJVaziyCtC0Y9zcY0ZoOyWTY3pIoppZhQirFEUkurqKRGT1XopSGdtEJPV+imIV1dpafq9NIGkW6CqBa8+jLH3q0FtrC1Z2zwTKbKUh6TQUGFVDFSZ+3IZV8sb9sxRsRokaK8mFQmFlR8Td8xUXL+vF/keY99m9o39Up0x6EMilbIJDwBvgUY4WEzR0pDgKZiVJ4BMXRBvtAYQgq2Sd6XjWG4zzfgGemYJnZiwng5S0hpKzhKTeBoitkSOJqjP9SfUR+HxpaOzeiQifFIZEgifGIZkMiAWAS2LXwiGRCJAOV5Q3TEgqY43IejQzK0D0eVpKA+lvZJaROleUIjszTPMrWFZ2SKJ1J8keC5bSlsNbMsqZqfr9Pj+ryhdmpByI07finv10hj3TTSuCRuRltnktYIU8QehHZ9GZgZ49IsiOOAqAAnUdq/Ys2D7HN0nl/8xX/84Zn0s+RrL/61S2gd3sn+n/kZNvz2b3HvU0/nZ774M7z2/Nfy5tEL4UMvgbOew7WX/Ck/9cGb2DZZ51dfcj5v3neIWBveeWqFbYd/jXbnDtZNPZ89ey7m5pvvZ2RkhEtPuZgtd1aglyK2hty9dAO33Pp5vCBgw2mXMBicQ3dpjLAi2VybY+rWT9PaeyNUQ45cOM3nti/y9S3LDCqSC8IJLm8vc9mxBzg7ToiDcW4NHsVVnTO5JjmD3WYTjVYVOVFhvuGhRgNMM2B90Od09rJN3cqp5h628AAN1afTnaLbaTHotej1Rul1x1DxCE3dYL2pM2kajJo6o6ZOqAPaqk03nqMfz9JOFuimi3TTZbpokA08RhBiBCGzpYWPTyXtUY2WqfYWqURLhPESlWiJSrwIeplOtcN8U7PQNENJ1bJ2UgW/ohkVinU6tcFfFwgedb79EWVo6Sr1pEagaiS6TqyrRKpKrAMiFRBpj4Hy6CvJQEn6StJXPgkCZSDFoIxAOxZLzq933Prj2nk2RtsWRiCFwDOOraKd+0MpPFXOpphRHlf0rci6OJRd0WVYtAE/hZYKJRRKpiQyIXXr2DfHpeLNgn6pPxzsK9Mfy0vWp10gL3dFSxDSIKWxGSY9bScsaUEnAAcqZgWrpGCcBDnjxLFSVrJPjJvvTcYskQ6YrH/cGAnaRyPzjJlG+y7XZeAojF7BRjdeQWt80P6CErlavxIeifBzymMibTsVPrFw+6Xn9nso6ZEKDyO9YUByzCkyUCqvy0B23BgKAFyxT5Szfgr7fdg+ZcFNaDyhXHI2jZQq3/aEwhcpQmirFRF2n4fOgezjV7z5h2fSj/spH3jb1Zx+0Tqe9ppz2PfqVxPv28fpn/scv3/bu/j4vR/nr674Ky4/eBd87n/CBS/lmgv+gJ/90C3UQo93vPxR/MXSAt9e7vGyDaP8pP9plg/+DZ5XY3T01dxwfZWDB48yNTnFxRNns/X+OqKnEOsCDom93HDbp+n3lxndsJX62Hksz29BpSPUaoINHGLs7q8yuu8GpFAs7djILacavrT+KPdtgqZf5SJR55KlWR6zfIxzohjtN7kvOJtrBtu5OjqVnfo05uUYzbEKSctnue6hWxYIRsKErXKGaX0f0/p+trCfaQ7SVAP6/Qm63SaDXp3+oMWg32TQbyGTUVqmxqRLutY0NtdOU1dQWtt8OvEC/XSJXrpML12mrzr0dERfSISo4ZmGzb6ZJVuTDYSo2SfRZEA16hBGHcKkTZC0CeOs3UHToR906FQjlms2gZpNpmYDwR2XWK1XBUILFHWpGDWKMRcAbmpdJFJz23XlUdcVarpGVdXxTANNHWVqKF1HmRClAxIdkGifVPsk2ifRHrH2ibUk1pLUkDNa8nwnObtFoYVBAVrbtQKUMWgjsIE+x0hZlR5ZTqIlV/RJN06CAx5pQLrAn9SWLimVdXN42v7xezpjnTg2yhD9MXXBvrSUiVEV7Swg6IKGhoyNkroCL8rSJWWKEopEurbUpFKReipnnKiMZSKtcnaYbSJKLJNh1kl2TNY2uWvaTYbSFEAlDMJNhp5wk6I0CIlLlWy5Qz4WiDywb4Qrtx2AecaNf5BtS40UiMzVYpyDxV2oMPb7MtmFa88+ZeMoNLhU0LjUC1iVRVp6l1BG5u8c2TtFsV+ijLdi/4pxphjvEkTbRXi2XrGQfOQdb/3vn/SFEFcCf+F+4e8xxvzRiv0/AbzVbXaANxpjbn2wc6426QN8/cO7uOuaw/zUHz0Rs/su9r7ilYy9/GWM/8ZbedW/v4pD3UN88MoPcsbOz8BX3g5nPZd7LvtTXvvhOzmyNOBNTz+D9ikN/ubAUUZ8j7ds9rlg4Z0sL15NJdxAGL6Am26qceTIPM1Gkwunz2b74VHqx4BAMpiMuG/2Ru6672o0itEN26g0zqSztAGl1hEEgqnKMqNH76C165s02w9gaiGzp45y+8aY66aWuHdakNZ8zpB1zhtEnLM0w3nRgDPihNgfZ4+3nZujzdwSb+Fucwr3mWlErY7XCuhXJVHdtzl3Gj7VmmGTXGCdOcA6/QAbOJIvo7qLipr0+g36vSpR1Cjy7UQNiMaomxqjukKTisuz44qV6wChIFUDYtUhStv0VYeB6tBPu0S6x0ANiIwgwiCoIkUNIbMka+V2iK8hSDWVdEAYFwHgPCic9vCTHlL1SPweiddj4PXoVTS9is1/c6KkanEIIjDIwBAEmqrUNF0AePUEajYgXNGCivYJTECgAwJTIVQVoIaigjY1NCGGCtpUMFSACoYqxoS2z9XH1SZAmxCtgzzoaUktpQDgyoUV7JUT9Kmc2WIwmKEgnwGUsTVltbG0SgPWZy0cOOVslYJ5MhwELLNbCpaKKI2xbJXCp5wzd4yxYKU1wmgLXtr6miXaAZh2fvqCYVKwUcrtDLgyhoousVWOb2uhQBiMAyyTZdIUjk6ZtYVCuVoBeb0A4WiXQqOkxghLt9QOpLI0EEPbTvykHGWy2C72Z33ZtnHeLXvDHL1S2PoFOdBhn/4p9QncVyEs0AlLBUJK+2Bgc+fZdQZgGdD99pv2/fdO+sKSa+8BngEcAG4AXmmMubM05lLgLmPMghDi2cDvGmN+5MHOe6JJf+5Qh4/+3vVc8uxtPP4FpzPzzj9i/oMfZOt738Pihdt4zedeg0bz3me9l9Pu/hJ8/m2w/jzaz/t7fv0bAz5722HO3zzCTz/9DN7fW+bG5R6n1kJ+dl2bcxb+jM7yDfj+KPXaFdx73zT37FoCYOvGzZzpb2F6f51KZMVH/VaPPfO3s2vvNcR6QFhv0ZzYgUqn6ffWIeQ4YQATcoHW3L3U997EyPJegrRLd9Mo+zf57BzrsmsqYt8GQa/psV3UOD1JOK0zz45Bn9OThC2JohNs4AE2cVeynnuS9ewxm9jjcu74jSqm5tGvSNKah6n5mJqHqHmMhz0mxTzj5jAT5iiTHGOSOSY5xriZo6E0Kq45UKjYVApxza2rqKSBiEeppnXqJqBmQmoux07VBFQJqZkAoUGkCqUHJC4bZ6z7RKpP5Nax7hPrhNgYEgPKyCJvjhxOtpYnXzOefWLTmiBJCVWCnw7yAuJZcrVywXD0ACUilByQyD6JFxH5kfXZ50HfUkDYtSNXu1UFtqC68AzSd7VnpSHwbNHqqi7y2ZRrsFb1cOk83wi3uLzyxgm9tI9v7FuBNgGKAGUCNKHdNqFtE6CzdBE2CoAhsEDj+i0IBRgq1pVFxbJksiBjKQCIKQX+DGCsr9lkbBZsINDSSZQFmFWZKRmQFZkihxkrugR2LqOkMTbFsGOqWGBy7RJY5f1CFGONzcdjHLgZcEBWZrCUZtbjGC3ZvuH9uFCpfeOCrKBMfs/ytZ2EhXsDE9j7Jw0OgGyfpWlqt8/e62xbkAGWKQGYUz+Y8mJc3/FjBdp+Z6WxRthzGEdiNULzjK9//L990n8CdhJ/ltv+dfv7Mu88wfhxYKcxZvODnfdEkz7AF96zk723HeNVv/8EaoFi78tfQXL0KKd+7KPsH1O89guvJdUpf/HUv+Ax7QX4xBsg6WGu+B0+W3sef/Dv93BkecCPXriJiy7ayIfay9zZHbC5EvCyiT6Xxh8jmfs0xqQ0m5fQ653LXXdWOXp0gBCCLVPTbPc3MH20QbMbIBCoEcO8PsLuwzdzYG4XqYkJa03qo9tRegOD/rhl18gq9SBhNJmhMXsP9SO7aHQPUx3ME41VmdlUY+94wj2tLocn4NCEYLklOUVW2JoqNvc7nBJ12ZKkbElTNipDX67nMFPsTcfZk05wyOXbOWimmJFTJLUmpuIRh4K04mEqHqYqMRUPqpJWNWZMLjNq5hkxxxhlkVGW3HqRMRZp6h7VVKPjgGgQFoXJXfqErG2SGiJt4icNQlWhYlxhcnybRoEsz47txwW6UAqT59AZ2Bqyeji3TqpjEpOQGE2qM3cLKORwIJhSAfFSMXFhBMKApw2e1gRK4SltKY2qKL83nGwty5sT4akETISWKUrEpDIlFTGpl5B4CYmniP1kqC5rFiSOfVFql2q2eu7JzjNOCWp971JaNaiQBl8afFEEfyvOl76yJmseCDYGXwh8hA0CY9t59kakCwxbIiRIUmHdEUUYU5KS+d5tyFPjo4yPNj4Klx7ZWGAq1g64tC32rrHFXzLGi8gkZqZgqBzHWDGrMF9KbZFRMkuTM3bSySdo48ANVq6124elbGKpm2AwJgM8C4TZdvZ+pd14k+13xwz36aKdH2v3u0+xoJXRNkt9FvyMcxmV9zMElgz1uXQMpbe9X/nQu/7bJ/2XAFcaY37Gbb8a+BFjzC+eYPxbgLOz8Sv2vQF4A8App5xyyb59+1b9zMWjPT7ye9ex/fwprvzZ80kOHmTvS16KbDQ45YMf5Oio4ee/8vPsX97PL1z0C/z0tmfjfeZX4N4vwvrz6D/t7fzlvq28/+q99GLFM8/dwAUXrOfrRHxzsUsoBFeMV3iSfwunLf8jqr8LkNTrj6LXPY29exvs368BwUijxebGejbGo6w7VqWVVhEI0oamzRyHFu7jwOzdLMXHMGiqrUnC2jRKTRAPRhHeBEKOEXjQEm3qnUNUj+2mtnyYWn+WWn8WfMXiuhqHJwQPNAYcbqXMjsKxUVvPdqQaskkLNsQRGwZdNqQJG5RiQ5qyQSlqusGynOCoHuVQ2uKItvl2Zs0os4wxa8ZYDMZYDkZRFd+Wb8tSKYRFzh0TSiphSrPSpyU7NFiiaZZp0ikVLS/adT2gohRBohCJIU2LlAlZUfIihUKITkPQVWRSQ6ZVZFq3bhc8AuPn+XTCLLdOqU9qy5TACV+MSjFZ6gNdKjJukqE0CEVZP1vLSRtIjX3atH586cqvZwXES6X5hlSmmaLUd09ookhloAxeFig2yoFOlk9nZXC4lM6g5JvHpBiRoEkt6GRrmZJKhZKJ9b3LlNRLiT2bziArp5fXbnWpCsosJFUGHxf4zfznwgUbpCTvl8LgeTZNQMY0yvLhrBb8DTIfO86ZJFxqYOGcTsKmfvAAkeUcEliKo7Dj3fO1zcbp1uDeEFxfsb8oiqgRKCFdOwt3Wp94Hvo0zieOtO3sWJP56oWldBpR2nbBarc+rs1wXx4X0Fmfo4MiLB3UyGKNzEFx5X9Zgcu8x5Tarv+5f/jq//ZJ/6XAs1ZM+o8zxvzSKmOfCvw1cJkxZu7BzvtgT/oAN31hH9d+8n6ueM05nP2ETfRv38kDr3sdstFg61/9JdHpm3n7tW/nS/u+xEXrL+LXH/s2zjl6L3zpt2FhL5xyKZ1L3sjfz5zJB67Zx/Ig5bR1DZ524SbmJgO+3O8xG6c0PcllI3CRvIMzup+g0r8JgMCfwnAOiwtT7NvnMz9vKyo1qnXW1yaY0i0mlqtM9hvUqWAkpNWEtl7k2PJ+jszfz1JyjH7aBimpNqaQwSQqHSNNW0g5gvBGQTSpeoq6WqLWOUKweJBqb55KtEA1WqASLaLChKXxkGMjMFOLOFbXLDSLtAoLTfAaPhNSMJGmTMQDJtKYCaUdqyZj1oBvWgxMi3nT4JhqMK8bLNJi0TRYoGVLFJoWi6JFOxxhyWsRBaEtYO5nuXbK6RTstgig5lvFa83vUxNt6mI41069lG+n5qRUNtlWSqBT/DTFSxWeUhjloVWAKpUPPD7vjo9RIUKHSBUgVAWpQjwdIFUF3/j4+Nbtwiq5dSgKbGT+a4zBaA1GgVGIzB2irYvDHOePX5FHZ0VaBA0oo50/HrRxwWMDyrkyFAJtBEaUlaEFTWe16kkCL3dZZEHiPIVBiUroAVJrF/TNxFupDRpngWHHRMp88Hl6AqNswjZStFDOh57mPnYllQMn62NXDpSUVKQiCw6rYTbSCrZSthQ+cOff9gBhnOemBFCiCAQjsQwZd0y2tqJsC1IejpHkArpZrhsf6ysvc+eFKKZh6dxLQhT7pAMyhESKbFzpWIHbb7e1cCAlitxKWVtnT/BZ1k9kAXT5mOI4k7WBV738iw8N944Q4kLgk8CzjTH3fKcP/k6TvtaGT/3ZzczsWeb5v/JopneMMbjrLva/8edRCwts+M3fYPTHfozP7vks77rhXSxGizzv9Ofxc+e9lq27vgTX/hUsPQCTO0gueCVf9C7n/TtTbty3AMAFm0c5+/Rx5sd8btQJM0kKwNl1n0eHxzhd3cTW3udopbsBkLKBEKfT667n2LEqhw9L+v0WIKlXakxURhk3DUb6FUZ7FcZ0gxohCEjChJ5us9Q/auvaJraubV+10WiC2hieP4Y2LVTaAJGxaZoI2cSTgc1DEy8SducIOscsgyZu52kVwrhNWhnQcXl2FiopC1XlGDW2RGHbtdOagKqg6htGtGYkjRhRKq9ZO+Lq12ZLRQdIYwujRLrGsq6xbGq0Td2WHXTrZVd+sE3dpljz6vS8Kl2vRtezClgCOZQ+wfjCFuPwhytA+Z4i9FJCGRF6MVXZpyoHVL2IqihKAx6fIqGoEBWYhMCk+Frju4nOUwpPa3ytkMq5no7Ls7NKDh6TURKlS4vgIVRgRT7Kt352HViVqg6Qbu2ZIC/5VzhcVi+QIU3mczYlENKFfz5zabj+fNGZj77wuRfB4aLikqFoa2MsUwmbnTTztet8bYaCx7Zf5MHl/0rQ2P5bSn504zSoxljRksm47/bf7GXbpfQGnjEIY7+7wreeBYr1qtsGe0+MKNYaG+A1ZCDm8u2QBYdNDmhZvV8lClDTju1kt01ehEZLUQR6JWhh8pcGS+s0LsDrgr9ZpNytc3BzlE8hCpCTWZ9jNv3eW/f8t0/6PjaQewVwEBvI/XFjzB2lMacAXwV+0hhzzXfzwd9p0gfod2I+/n++zaCT8Jyfv5DpHWOkc3Mc/B+/Su+666g/7nFs/J3fJt66nn+4/R/40J0fItEJT9n6FF511it5zNwB5I3vhQeuBQRseyLzW6/gC8mj+Oj9FW49YIO4E42Q87aNUZmqcagmuFOkDNx9mQ4FZ4VttrGP6fgm1kfXMMVR+wMWFQTTRPE62st15uY82u0q/X4LrQNCP2AkbNISNVpplUY/oJlWaDl6ZYiP8hSRGNBP27QHcyz3jtFXbXpp21Wq6pGYGL/SQnpNDA20qmGoIkR9BZumSiA8KjoijNv4UdtVn+rmTJo8tULaQ5o+SRARBxG90KZV6Dg2TZlF063gUi0IogqYUCADg+9pKkLT1CkNY1k0WToFm15hOKVCqEGaIGfEKBWS6gqprrjn/wp9Y8sM9l07IsiLf2TtSAREssLACxmIkL6sEHkhfa9K5FWIvcCWFMzogrnCVRQUwtK25+lcDBTIZGjty5Qw74ttYQ5RqFeDIWVqclw7wCYJ8xwl0zPaZbY0zhXkGDCOuikydow2oK1/24p6hFWmlhSoZYVqtqA90B7COBWqS4+Q9UnjWQWq9ou2caClXCoFk0UGivQHZT/8sN/dMVEykKIALeMm9lxZqlf44LXO/e3kAWft/OhZILlIcZD3OT+7dn5zXWrbfrGCBVX41O34zH8uSn3WeZIFlrOn6uF0CPa9IA8emzw0TJ6Hx4jSOrsXpTw9phQ4pgC6gimVBePtm1sRQC7EXy/893f+QCibzwH+HAvr7zPG/IEQ4ucAjDF/K4R4D/BjQOakT7/TRX03kz7A8lyfz7z7VtpzA5708jM497JpMIbFf/lXjr7rXehul5EffS5Tr389y5vH+Oiuj/LPu/6ZxWiRjY2NXLn9Sq6cuIBz9t2EvPOTMHu3PfHEafSmL+UO/xy+2DmVz+yrcKQdAVALPLZvaNKarNJv+cyEsF8am28FGPFge9hnk5hjvd7LZHwH69S9bOQwVQbuno2h1CRRNEK3G7K85NHrVYvyhWlI6IXU/SoNUaWuQ2pxQC0J8hKGGXMmwEdLRcyAQdqlFy/Tj5bz0oWRHpDoAbFbUjTaCywg5IWxKy4QuoJFI22/jyQw2MCn6uPFfVu+MGfS9PHTKE+p4KURvuojVITxUlIvtmIkL2LgxQxCkzNoojKbJhBD/VnQU/jCBTsNnjR4UuM7Vk0oDFUy4CgCnisDnBVT5FO3E5kVCmF8lCumok3g+rLgZFGIo6xYLVSs3nARD+MTC7+kXrX7IqdiXalqTZ1AKJUeiQhQUmKkPIFqVZRSLNi1dWVo52t3Ah5pBT6+VEiR4kuNJ1I8acU/vkhzZWsgbPoFz60zNWvGFi/SKgz3Z4pUz6jcbeQ5amb2BC4dhVM4larIJqpsAtNmaEITOpvgCtVpxosv0ic4PqTzgRsz7CMv/OtevmTbaDm0LVaOdWkWMNKJzbwyjBXBZFP2sps8kJyDG1lw2eTrrD9nULm+4bUZ2m/ycdqNyYLQWfDZvpFlYzPQe+4//OYPjzjrRDboJHzhPTs5cPcC2y6Y5LKXnMHYhjrp3Bxz730fCx/+MGYwoHbxxYy99KWET72Mr85/i8/v+TxXH7qaVKdMVCd4/KbHc+noWVzcnmPL3usR+6+DyD7tm8Z6eusezf7wNG5LtvCfyxv4ytEGvcRegxSwfrTKyFgV0bR8+nkf5nwwNc8OACY8xXqvz6RYYMLMMKYeYDTdxySzjDPPKIuEJEAFo0dJVcNWp+oHdHseUVSULbSLZc9UvSpVaStTVXVAJfWpKp/QlSwMcgaNnxca8YTBmJREx8SqzyDpEquBDXrqmMTEq7ZTNKmwQqXUQFaFyipiw7zilHDbRRWqkEzIJMAVoi5UsH6S4JkUTzl1q4rxdJQXBRGmUMVm+dk9nbogZ4oSCVqmpCIhdarXVCYusJmS+HqoyMew31gc3+8ejMm9FJlz3LUduybzJwsX7BQu0JmrWinypK/Mtb5afnXh6qCKUgCQfELzcnGQTWfshEB50RYrCDLGTtkYq1rNpu/EJR6watasz07nuQJWuIIfolCspsIpXoXtz9SuqZCobC09GzR1Y+y2R+r6U2n7V03NUFatSmPdOw7QCoGWBbPhxeChELmKNVO7qlzhmqtWhQ3d+m6fL7J26tStFgyLMK8NB5M9YVtd8dBTtU2MkLmUiqfv7AleZk/tpugr7x8ao1eOAeleR/JsptrSQe2kVKResOBn16//2Y/98E/6AEYbbvvaAb716d3oRHP2EzZy4RVbmZxuks7Ps/TJf2PxX/6FeO9eCAIaj30szac9DX3xeVwb7OOaI9/imkPXMD+YB2C8Ms75U+dzQW0DZ0YRp80fYOuRu/Dn7nMoC8avEY1uZ6GyhYNiE7uSddzaneCGxRYH1BgJfn59o42QRivAq/mkFY++L1j2DINAWApl6EFg/xgaQjEmB4yKDqMsucpUszT1TF6Vqk6XRl6hqotvfLSuopStTJXEPlHkkySWKZMvKrCFSJSPVgFGWX+8r+quTKGHrz0CnRUSsUyZle2AotiIjam5pxStMTpFKcuYGWLJ6KJQyPEsmiz3e5r7jpXzEWf+YoVzYwjJqsrXPOXtKoFN4Z7wyObu7LVY2NS3UChhDQiXBExo4/zF6ZC4qFDAZn7i1ImKijztGAXYIiFWSOT86MLy2zOhkHFBUOWKiGhhcpWsEZrUs+NTT9t+l7e9rHS1S6GGVWJ4n1nhQ87EPpknQjjVq/URr/QZ220pna/dKWKlC4hm21mANBMKBcYqXe23UqhgLQuGnKWSXUjeziYwnIPbgZ7JePbGA5wby54RnALW5qexMRYyMES6fZaCagHR1SQzckjhmrN7hF20+71l7B4tBEp4+RgtSsdIey2qND4bk/eJ4XNoKUvnskBp2Ukrj7FtJWSe1kG47yL38WMD2Ht++umPjEk/s+5SxI1X7eWuaw+jEs2m00c5/eL1nHbROprjFfo330z7K1+h89WvEe/ZA4A3OkrtoouoXngBc9NN7p7oc5M4wO3zO7l/8f6MWUsgA7a1tnJqZZKtxmN60GVTd5Hp9gzT8/upp9HQtSTVSTqVDcx7U8yYCfano+yL6uzr15hJmyzQYs6MsEQDg8T3BNWqjx96SFd5KvEFkSfoe+SVqEwgXb74othIxUtpyoSGGNCkS910qJgOVbNMaLpUGeSMmCoDqvTdumiHOrW5VBQ5+yVNfdLEcznfS4VEvkNBEbQPOnTBywChQoQKLHvGBS495BBDZriISDEmS6FbDmpmTz4m93EajFZObKRy3y/aMmry1LblVLdDgqPMN+wm5JV9AvsKbTKGtmXa2AexjIM9HOQ0ppQ6N6MdOqHRsLCoHNh8EFFRRl8pBz2xJO0hEVHuH17FV1x60iyArxASyaE2QPFUm+234qFCOLRy2+BEQyZTweaedbSwd0rnwVPHac9UssLYNTZoavvdWmpU3lcsdp+x32f5PDJrF3Vus8Lr9gHZ5Lc1x54soCpKtzwbB7la1jgwzBW32dqNsY1sXxaAdU/rWTvvd99JPqYUmMUeP5y/zuQAmcUGsjYI3vCW3Y+sST+zfifmzm8e4t4bZpg72AVgbEOd6TPHmN4xxrqtLerRLIObbqJ307fpf/sm+xbgTNbrhDt2IDdvorOuwey4ZF9zwK7qAjvNIfZHh0l1OvSZo0GLdUGTSREwaSSTKmUyiZjqt5nsLjDeX3SMF5tHxnPHGSSDYJSOP0ZbjLCMKyqiqiykFWaTKou6RtsxX5ZNnbZjwvSo0KdCInz8wMfLAMFVnFIZ/c09ipUZMCu3s7bwBIFUBL4i8FJCGVMRCYGxyYDDVQuLFO0wz+FYKupcCmp67ilaao1P5gN2tEGlS0FLY5kzJ0ihe/x2xqBZmX0wew0ucaFNEdDMFumeDslT6pbGDo1z8FPy7R4nICr5f1ftd8AF2SSdtYvAp/1xlAKdmf/XOOlO/pqfhR+xQAe5H3ho2x2j87bOz+M8wiVh0WpCpCwUml2GccpZA3kfdhI1Dviy/tI/x/bbgWblcfmY7BjhPgf3RC+Kcw0torgdOJeRnTIdSIr8Huegmd/z4m+48M+LwgefT6vl/dm+8vlMPr4AYFOcdxVQdv/CIYDO/PpDY3LAtec0LrRsMBZUyL4bwws+/1ePzEm/bAtHuuy9fY5D9yxw6N5F4oGV23iBZHK6wcR0g9F1NZotSa03Szi7B3bvIt59P8mBAySHD4NSQ+eUo6OIqXGS8Sbd0SpLTcF8JWUujJkN+sx4XQ57beaCiE4VkkAMHS8QNL2QERnSwmPECEa0pqVSGmlCPY2pJwPqSZ+a1nm+mLo21I2m5tZ1J/0XeMSyQizds7twTBcT0tUVOiako0O6OiRyU3aUFX3Ocr+vyPMeuxzxMQGJCIm8kETaXO+J9F0g0oKLEbbASP448t3mfM/9uAxnI3T7M19sFpzMfbXZNjZAKZ3f1gYoC19u4aMtlsxnO7xdluuk+f6yf1c6cqIkk8WvYFdQBCmLP+Qyw2LlvtIffLnPuZcymiKUfcKAoTQBuKCne4tglTYnGJP15z7h7JE3FyC5qW+17VI7kwXhGDzkT6FunMncN9JNkpl4KRMYFYKn/JxGHPcZK8dl26J8HJnbyP6NWeghn5ghRyX3d0iBSBST6pBlk7tr52ONKB9cOq74jHxizgCbIvBr8vM6CCwDu+sVGcDnn23c/6Z0DjP0Gc/9u19fm/TLprVh/lCXuQNtZg90OLa/zeKRHt2leGic50vqIyH10ZB6K6Dqp1R1F6+/iN9bQnYWkMuzyPkZxLFDiJkDyDg6waeCCQN0s46qBSRVnziURBVJP4BeoOkGiraXsuzHLHsJHS8h8k1J0u+UlD7EnpX3Z6rK2AdPSirCo4IgRFimCk6qrzUVbWvChjol1IqKUsfJ+FeKU1YWbC6KNZfFLMY++QpJVoACMlaFjzZW8aiN59Lj+sU6Cxy6AGORJrecEkC6tjxOMVleMr9q6vy5wxkI3THON5piMxIqJKnzpabZ5zkfaubTNULmClAtPAturp2rQYVXUop6rq/wyxoy0MtAjZIvwP1AStsm7xel/aW+oeNcRkqyhfzJL/fTY33xtp/CD0xpnR3ntu05XVByyAWh8+Okm0klOt8WQud+/+L82hWQd+csXa8UOt+fBUpxY+15lDsuGwsCNXS+4loz4C3fjwxUyfdjbHQAo/N++0fqnphz91kJGCg9iZM98WeAUjzBG9y58/MUk3x27nK72D/8hnfC44pXKaT7vOzNIruuX/6Jj3xPk77/nYc8vExKwdSWJlNbmpxV6k9iRfvYgKVjfZZn+3QXI7rLEb2lmKVjAw4tRUTdFGi6xaUOGnXL6eCHkiAU+B62IpFQlo3i8rnI1FIZvaSPjPuIuE9tMKC+2GNq0EMMuiVmSiHFL8vzRZ5K1wYQsx+L9gwqABVIlC/RnnBpbgXKk07paEiFIXbrRGpiqYmFJvVgUEqHWxRpFi5Xe9kvOpxdsNxfzjJYrDXay9SaUZnGXOTKcn81mf80zzQI+R+4XbsXAWNy/2b+MmGyrIOGEBdAdH/ghdYlDwc6Io79nIyQI0r7M21MPsZk3nVTGl/qM1kSrtJ26Z+HyVw67kk46yumlXw7m6q168unGyPztqHcdhRHivNnU51xfl9jCgTJjs+uIZvaNCvOUbre8jnJ3TTlfnvNaPJ+vQK1dOn6h85pxIpjytN0eQrHwQH524su7yulZMCN1aJ8bOlcws/7HdzYz84VscXYoc8o7aP0uSv3s1o7Hy/zsfZ2Hn/uXGnrrsmeI/v3r/K5WXCBj/C92A/dpH8iC0KPCefqOZGpRDPoJUS91C3Ht5NI5Usa2/UgLvoSo0mVwmXp/b5Y8WRW/DwzV0TmXsiUiDJTJjrZfU0r6joFoxAqhdQxT7R2hUDcz84lnxJZ262H9mdPVaX9x/eZ/Glr1T4MGTsq82+Wn6hW7Xfb2VSSJbmyf0w2u6MwuKAhLrCYbdtZuvCI6iLIZwzazf72PPbsWqw4ZsV++yBmgbXYpjim5ETOjsnORf6kX9RRpbRN9qDnPjc7R/4vL70pFCHn0pjSMcePN0Ofnd2jlceXr2v4+FX6jxsjin9TeXzxY863y+MKT34xxt2uoXGIVZv5vzcbX4YVhGXkZvd2yFbZFvl3kJ89P0/5MHNcnzn+fOUhx32Wyc9z3GFiRZ8oPvOzx3/Ef8keMZP+d2NeIGmMVmiMfm+ztTGGNNGoRKNSu+jUoFJt+12fSor+oSUxaK3RythFG4xba237jNL5timNGxpbPl4XbYzrM4C2n2XnfDvOGNy63MYe5+a5k+QVXLPv0sSK9fdkWbA4P6f78vPfgMk38s8z5TGlfaa0rzStrn7Olceu/NGd4DNXnHvVa1912Hd7zIl+/MP9Q/f+BNd2/PdjVm0Ob7zqBJ//3dnapP/fYEIIgtAjCL3vPPhhaln6WgsUrACIE/StaOd/56VtyzbJ/ka+y3GmeErOr4tSvy6Nx14D2fhs3CrnNaY8zhRz34rPG4r9rZgQjp+nzHF9xbYpto8bs8p588tbOWE+yHWUPuuE12FMMfRE13H8nJ6zf4a2y99j+dyl7ey7Hp7ni2NWfg9DH7xyTPnc5Y3Sha68luP/reVrKd2LFQ2z2vjj9q04+dB3NNxxwvOVv+cT4c1/wdYm/TX7fzKRC0iyd+c1W7M1+4HY//zeDpffeciardmardma/bDY2qS/Zmu2Zmv2CLK1SX/N1mzN1uwRZGuT/pqt2Zqt2SPI1ib9NVuzNVuzR5CtTfprtmZrtmaPIFub9NdszdZszR5Btjbpr9mardmaPYLspGXZFEK0gV0n5cP/azYFHDvZF/Fd2Np1fn/t4XCdD4drhLXr/H7bWcaY1v/rwSdTkbvre0kP+oMyIcSNa9f5/bO16/z+2cPhGmHtOr/fJoT4nnLSr7l31mzN1mzNHkG2Numv2Zqt2Zo9guxkTvp/fxI/+79ia9f5/bW16/z+2cPhGmHtOr/f9j1d50kL5K7Zmq3Zmq3ZD97W3DtrtmZrtmaPIFub9NdszdZszR5BdlImfSHElUKIXUKI+4QQbzsZ17DShBBbhRBfE0LcJYS4Qwjxy67/d4UQB4UQt7jlOQ+Ba90rhLjdXc+Nrm9CCPElIcS9bj1+kq/xrNI9u0UIsSyE+JWHwv0UQrxPCHFUCLGz1HfC+yeE+HX3W90lhHjWSb7OPxZC3C2EuE0I8UkhxJjr3y6E6Jfu69+e5Os84ff8ELufHytd414hxC2u/6TczweZh75/v09b7u0Ht2DrLN0PnAaEwK3AuT/o61jlujYBF7t2C7gHOBf4XeAtJ/v6VlzrXmBqRd//Ad7m2m8D/vfJvs4V3/kRYNtD4X4ClwMXAzu/0/1zv4FbsWXuT3W/Xe8kXuczAd+1/3fpOreXxz0E7ueq3/ND7X6u2P8nwG+fzPv5IPPQ9+33eTKe9B8H3GeM2W2MiYGPAi84CdcxZMaYw8aYm1y7DdwFbD65V/VfshcAH3TtDwIvPHmXcpxdAdxvjNl3si8EwBjzDWB+RfeJ7t8LgI8aYyJjzB7gPuxv+KRcpzHmi8aY1G1+C9jyg7iWB7MT3M8T2UPqfmYmhBDAy4CP/CCu5UT2IPPQ9+33eTIm/c3A/tL2AR5ik6sQYjtwEXCd6/pF9zr9vpPtNnFmgC8KIb4thHiD69tgjDkM9ocDrD9pV3e8vYLhP6aH2v2EE9+/h/Lv9bXA50rbpwohbhZCfF0I8aSTdVElW+17fqjezycBM8aYe0t9J/V+rpiHvm+/z5Mx6YtV+h4yvFEhRBP4OPArxphl4G+A04FHA4exr4An255ojLkYeDbwC0KIy0/2BZ3IhBAh8HzgX1zXQ/F+Ppg9JH+vQojfAFLgQ67rMHCKMeYi4H8AHxZCjJys6+PE3/ND8n4Cr2T4weSk3s9V5qETDl2l70Hv58mY9A8AW0vbW4BDJ+E6jjMhRIC90R8yxnwCwBgzY4xRxhgN/AM/oFfRBzNjzCG3Pgp8EntNM0KITQBuffTkXeGQPRu4yRgzAw/N++nsRPfvIfd7FUK8BvhR4CeMc+y61/s51/421rd75sm6xgf5nh+K99MHXgx8LOs7mfdztXmI7+Pv82RM+jcAZwghTnVPga8APn0SrmPInE/vvcBdxpg/LfVvKg17EbBz5bE/SBNCNIQQrayNDeztxN7D17hhrwE+dXKu8DgbeoJ6qN3Pkp3o/n0aeIUQoiKEOBU4A7j+JFwfYJlvwFuB5xtjeqX+dUIIz7VPw17n7pNzlQ/6PT+k7qezpwN3G2MOZB0n636eaB7i+/n7/EFHp92DyXOwUen7gd84GdewyjVdhn0tug24xS3PAf4JuN31fxrYdJKv8zRstP5W4I7s/gGTwFeAe9164iFwT+vAHDBa6jvp9xMLQoeBBPuk9LoHu3/Ab7jf6i7g2Sf5Ou/D+nCz3+jfurE/5n4PtwI3Ac87ydd5wu/5oXQ/Xf8HgJ9bMfak3M8HmYe+b7/PtTQMa7Zma7ZmjyBbU+Su2Zqt2Zo9gmxt0l+zNVuzNXsE2dqkv2ZrtmZr9giytUl/zdZszdbsEWRrk/6ardmardkjyNYm/TVbszVbs0eQrU36a7Zma7ZmjyD7/wGQPToZ5EC7QgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -637,7 +637,7 @@ "print(\"Consumption function over market resources in each lifecycle period:\")\n", "plot_funcs(AgeVaryingRiskPercType.cFunc, 0.0, 20.0)\n", "print(\"Risky asset share function over market resources in each lifecycle period:\")\n", - "plot_funcs(AgeVaryingRiskPercType.ShareFunc, 0.0, 200.0)" + "plot_funcs(AgeVaryingRiskPercType.ShareFunc, 0.0, 200.0)\n" ] }, { @@ -681,7 +681,7 @@ "\n", "# Create a function to compute the Merton-Samuelson limiting portfolio share.\n", "def RiskyShareMertSamLogNormal(RiskPrem, CRRA, RiskyVar):\n", - " return RiskPrem / (CRRA * RiskyVar)" + " return RiskPrem / (CRRA * RiskyVar)\n" ] }, { @@ -693,7 +693,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -705,7 +705,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEpCAYAAACDc9l6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABScUlEQVR4nO3dd3xUVfr48c8zJb0XaujSS6J0EQlfREAQK1ZwwYJ1f+va14qrrrqWdV3bWtldVxRxddXFhkpTVIr03kkCIZ30MnN+f9xJmIRUSAiZPO/Xa14wc88999y5k2fOnHvvc8QYg1JKqZbP1twNUEop1Tg0oCullI/QgK6UUj5CA7pSSvkIDehKKeUjNKArpZSP0IDeSojIayLyUD3K7RWRc05Gm46XWN4RkSwR+aUe5Y2InOb5f73eh+No01wRebyx663ntueIyLvNsW11atGA7iM8gbhQRPJE5JAnwISULzfG3GSMeewktSVRRNyetuSKyDYRmXUCdSVVefksYDwQZ4wZ1pD6TuR9EJHrRGSrZ59SReR/IhJ6PHWd6kRksecL07+526LqTwO6bznfGBMCJACnA39oxrakeNoSBtwLvCEi/RpSgYg4aljUBdhrjMk/wTY2pC1jgD8BVxpjQoG+wPwm2lZN+31SiEhXYDRggKnN2RbVMBrQfZAx5hDwFVZgByoPCYhIjIh8LiLZIpIpIstE5JjPgoj0EZE9InKFiGwUkfO9ljlFJF1EEqquV6UtxhjzCZAF9BMRfxF5QURSPI8XynuB5b1xEblXRA4B84AvgA6e3n6eiDwAvAmM9Dx/1LPuDSKy07M/n4pIh+raU3VopL7rAUOBFcaYXz37lWmM+YcxJterTKSn154rIj+LSA+v7fxVRA6IyBERWS0io72WzRGRBSLyrogcAWaKSLiIvCUiB0UkWUQeFxF7LW91gIh84Nn2GhGJ99R9t4h8VOU9+JuIvFBLXdcAPwFzgd9UWTdaRD7z7MdKT7uWey3vIyLfeN7PbSJyWS3bUY1MA7oPEpE4YBKws4YidwJJQCzQFrgfqzfmXccZwNfAb40x7wP/BKZ7FTkPOGiMWVtHW2wichEQAWwAHgBGYH3ZxAPDgAe9VmkHRGH1wq/x7EeKMSbE83gCuAkruIYYYx4Rkf8DngQuA9oD+4D3a2uXp20NWe9nYIKIPCoio2oYirgSeBSIxHrvn/BattKzz1HAe8CHIhLgtfwCYAHW+/Rv4B9AGXAa1q+tc4Hra9mdC4APver/REScwLvARBGJ8OyzA7gc+FctdV3jacO/Pfvc1mvZy0A+1nH6DV4BX0SCgW8822/jeT9eEZH+tWxLNSZjjD584AHsBfKAXKzg/C0Q4bV8LvC45/9/BP4LnFZDPY9iBfyxXq938NQd5nm+ALinhrYkAm4gG8gE1gJXeJbtAs7zKjsBa/ikfL0SIKBKXUlV6p8JLPd6/hbwZ6/nIUAp0NXz3JTva5X3odb1qtmvScBnnv3KA54H7F71vulV9jxgay3HKwuI9/x/DrDUa1lboBgI9HrtSuD7GuqaA/zk9dwGHARGe55/Adzg+f8UYHMt7TrL8x7EeJ5vBX7v+b/ds6y3V/nHy48F1hfFsir1/R14pLn/PlrLQ3vovuVCY43vJgJ9gJgayj2D1YP8WkR2i8h9VZbfBPxojPm+/AVjTArwA3CJp7c3CasHV5MUY0yEMSbKGJNgrF4+WF8M+7zK7fO8Vi7NGFNU205Wo1Kdxpg8IAPo2JjrGWO+MMacj9ULvgDri8W713zI6/8FWF8QAIjInSKyRURyRCQbCKfy8Tng9f8ugBM46BkWy8YKjG1q2ZeK9Y0xbqwv5PL39R8c/XU1ndp7578BvjbGpHuev8fRXngs4KjS1qrtHl7eZk+7r8bqzauTQAO6DzLGLMHqMT5bw/JcY8ydxpjuwPnAHSIyzqvITUBnEflLlVXLA8M0rCGP5ONoXgrWH365zp7XKppXtbkNrdPz0z8aqKt9x7WeMcZtjPkW+A4YUFfjPOPl92IN7UQaYyKAHEC8q/X6/wGsHnqM50sxwhgTZoypbeiik9f2bEAcR9/XT4BBIjIAq4de7RexiAR62jhGrCulDgG/B+I9Y/JpWMNAcdVt19PuJV5tjjDWsNjNtbRbNSIN6L7rBWB8dSctRWSKiJwmIgIcAVyeR7lcYCJwtog85fX6J8AZwO+wxtSPxzzgQRGJFZEY4GGscd6apALRIhJeS5n3gFkikuAZ2/4T8LMxZm8dban3eiJygVgnhyPFMgwYg3XysC6hWIEwDXCIyMNYV/9UyxhzEOv8xXMiEuY5D9FDrCttajJYRC72jJHfjvWF8JOnviKsIbL3gF+MMftrqONCrM9BP6zx/gSsq3mWAdcYY1zAf4A5IhIkIn2wxtvLfQ70EpEZYp00d4rIUBHpW0u7VSPSgO6jjDFpWEG3uptoegKLsMaBVwCvGGMWV1k/G+ta70ki8pjntULgI6Ab1h/28XgcWAWsxzpJusbzWk37sRXrS2C352f8MVeheHrLD3nadhDoAVxRV0MauF4WcAOwA+tL8F3gGWNMbcNO5b7CGsfejjXEU0TloYrqXAP4AZs9216AdeK2Jv/FGsPOAmYAFxtjSr2W/wMYSN3DLe8YY/YbYw6VP4CXgKs9Xxa3YQ0XHfLUNQ/rywNjXfFzLtZ7mOIp8zSg17KfJGKMTnCh6s/Tu+xljJleZ2F1yhCRzlgnONsZY440Yr1Pe+r8TZ2FVZPTHrqqNxGJAq4DXm/utqj684yp3wG8f6LB3HOd+SCvYafrgI8bo53qxDXrHWmq5RCRG7DG5f9ljFnazM1R9eQ50ZuKNdQzsRGqDMUaZukAHAaewxruUacAHXJRSikfoUMuSinlIzSg10BEvhCROk/0iFdq1kbcdldPvY6GtKWedY8WkW1ezxs1Xa6IbBKRxMaqr7G3L1YWwdpuoW9xROR+EXmzieo+7tS8IjLTO89LNctP+rGo+vn3Na02oHsCZr5YCZ6SReR58Up+ZIyZZIz5R3O2sVx921KfLxdjzDJjTO/GaJdUkwPcGNO/6iWQJ5P39k8kGHnWL/9izfN6POS1XETkaRHJ8Dz+7Lm2/6QyxvzJGONTX1JNpSGff6k+dfMprbWfFI03xuz0BMElwBbgjWZuU5MREYcxpqy529ECRdTwvs3GuhknHutOz2+A3cBrJ69pJ0Y/E76l1fbQvRljdmLlKUkof83756DnrsolYuXhSBeRD6qrR0TOEitF6gSx0ocO9FrWRqwJKGKrWc8uIs966t4NTK6yvM62iEj5lSfrPD3Jy8t7GHI0He07NfQ6horIZrEmNHhHPFkAq/vJXP4rQERmY+XpuMezvc88yyuGcKR+qXLvFJHDYqWJrXYSDBEZKyIbvJ4vEq+ZikRkuYhc6L19EZmIlUXyck/71nlV2UVEfhAr1ezXYt2xejx+AzxnjEnypEF4Diu/S7VEZISI/CjWDVLrxGtoSES6eY5rrljpZ18q/3VR3TGr8j7P8Spb/qtituc9Pygid3qtV12q3g5ipQ7OFCuV8A1Vml5tal5PffeJyC7Pss1iZdas0lT5m+fzulUqp5ioWvBasfLdZInIVyLSpYZyde1jnZ+7Ku/jXSKy3tPGD0QkQKyrg6qmbu4gIsNEZJVY6YNTReT5mvanWTR3drDmelA5A18frDsFf++1fDFwvef/87DSvtqAAOCsqvVgZQ08AAzzvP4K8LRXud8Bn9XQlpuwbvrohJX46XtPvY7jaYvX80SsW87L79YLpEr2Qqzsihu9tv0DR7MRzsQrq2E179vc8rJV6jvH8/8/Yt1+3gYrsdOPwGNV2vZHrERU52EltIqs5v0JAAqxklk5sO5ATMG6hC7Qsyy6mu3PAd6tUtdirIyPvTzrLgaequG4dPXsbzJWsqt38GQh9CzPAYZ7PR8C5NZQV0esxF/neY7deM/zWM/yFVjZG/2Bs7HSL7zr9V5VzThZ7X56tXkeEIx1d2halbKlWL8sbJ73YAnW5zUAq1OTBoyrUv5Sz3G6C9gDOD3Lp2FdwmjDulM1H2jv9fkpw8oH4/QszwGiqvlcX4iVMK6v5xg/iJUgrrbjUtM+1vW5q/r5/8WzD1FYv9JvquV9XwHM8Pw/BBjR3LHM+9Hae+hrRCQf6yAuxvpQV6cUK4lTB2NMkTGm6omeaVg325xnjCnvOf4DuEqOThwxg5pvu74MeMEYc8AYk4mVo7smdbWlKjdW+tJiY926X52XvLb9BFaq1sZwNfBHY8xhY6UieBTrfShX6lleaoxZiJWK4JjxTWPlIlmFFeiGYKUNWA6MwsqtvsMYk9GAdr1jjNnueT/m4/XLrIp0rIktugCDsb5AvG/1D8EKUOVygBCRasfRpwMLjTELjZXc6xvPPp0n1l2cQ4GHPMdpKVaa3hPxqDEm3xizAeuLyPuYrjDGfGKsrIwxWClz7/V8ntZiTSDifZxWG2MWGCuVwPNYgX8EgDHmQ2NMimefPsBKjeA9LeBhrM92qWf5Nqr8AvW4EXjSGLPFWENAfwISauql17GPdX3uqnrRsw+ZWO97Qi1lS4HTRCTGGJNnjKlPLp+TprUH9DOw/igvB4ZjfdtX5x6szHi/iHUVxbVVlt8OzPd8sAAwxvyM1VsZI1YSo9OAT2uovwOVc3vsq6FcfdpSVX3S0Vbddk2z9jRUXalyM0zl8dtKKWerWILVYzrb8//FWMmxxnieN0SNaW69ef5gVxljyowxqVh5TM4VkfLEWnlUTrIVBuQZT/etii7ANKmcWvYsrPwsHYAsU3lKvdo+A/VR2zH1XtYByDSVZ17aR+UUwjWm5hWRa0Rkrdc+DaByWuDkKu9HTZ+vLsBfverJxPqc15YCuaZ9rOtzV1W9Pg8e12H9utsq1oxNU2ope9K19oCOsczH+in1cA1lDhljbjDGdMDqSbwila8mmQZcKCK3V1m1PN3sDGBBLYH1IJXTkHaupb11teWYVWpZVq7qtsvTruYDQeULRKRqXuu66q4rVW5DVA3oS6g7oDf2XXPl9ZX3wDdhnRAtF+95rToHsO6yjfB6BBtjnsI6/pGecdty3p+BqsfBjjWUUJuajqn3fuB5PUoqT3bdmcophKtNzevpPb+B9UUXbay0wBupnBa4Y5VfLDV9Bg4AN1Z5fwKNMT8exz421ufumM+PMWaHMeZKrOGcp4EFVY5bs2r1Ad3LU8DsaoIWIjJNrGndwMpmZ6icbjYFGAf8PxG5xev1fwEXYQX12tLNzvesGycikUDVCSfq25ZUoHst26nJrZ5tR2GdSCw/6bsO6C9WetkArPFUb3Vtr6GpcmvzI9ZwzDCsFLCb8EyoANSUiiAV6CrVzJdaHyIyXER6i5W+Nhp4EVhsjCkfZvknVi75jmJlgbwT67xCdd4FzhfrhLndc+ItUUTijDH7sIZfHhURPxE5CytPfbntWCcmJ4s1rdyD1J3B8CGxUtz2B2Zx9JhWYow5gPXePulp0yCsXqj30FJNqXmDsT5/aZ73axbH5odvg/XZdorINKwx8oXVNOU14A+e9iLWnKrTjnMfG+tzd0zqZhGZLiKxnl8q2Z6XXdWt3Bw0oHt4hkuWAHdXs3go8LOI5GENm/zOGLOnyvr7sYL6veK5IsUYk4SVHtZg5ZSuyRtYKVbXecrXlpq2trbMAf7h+dnakMl538PKv73b83jc0/7tWCeYFmGNjVYdr38La+LnbBH5pJp6G5Qqtzae4Yg1wCZjTInn5RXAPmPM4RpW+9Dzb4aIrDmOzXYHvsQ6QbkRK5B5j0X/HWvMdYNn+f88r1XX/gNYsxzdjxUAD2B91sr/Bq/C+nLKBB7BqwPg+QK5BWtsOxmrx17X9dFLsE4yfgs8a4z5upayV2KdaEzBSrT1iGeMv1y1qXmNMZuxruxZgRX8BmKdVPf2M1a65nSs8zOXVne+wxjzMVaP932xrr7ZiDUr1vHsY6N87kz1qZsnAps8f39/xZpasaEzbDUZzeXSxETkbazp2B6ss7BSHiIyB+tqogalKRaRrhy9CsUnry9vDft4vFr7jUVNyvPBuxhr1nallGpSOuTSRMSa5Wcj1qw2e+oqr5RSJ0qHXJRSykdoD10ppXyEBnSllPIRzXZSNCYmxnTt2rW5Nq+UUi3S6tWr040x1d5Y1mwBvWvXrqxataq5Nq+UUi2SiNSYFkKHXJRSykdoQFdKKR+hAV0ppXyE3inq40pLS0lKSqKo6JRJN6GUqoeAgADi4uJwOp31XkcDuo9LSkoiNDSUrl27Uv28C0qpU40xhoyMDJKSkujWrVu916tzyEVE3hZrzseNNSwXEXlRrLkI14vIGQ1ot2piRUVFREdHazBXqgUREaKjoxv8y7o+Y+hzsVJG1mQSVnrMnlizoL/aoBaoJqfBXKmW53j+busccjHGLPVkDazJBcA/PdNM/SQiESLS3hhzsLZ6c7du4vsz+zastT6stoPnb/cjPDAGf0dApdf9unSh43PPYgsMbOrmHbfs7Gzee+89brnllroL1+H555/nzTffxOFwEBsby9tvv02XLrVNOalU69IYY+gdqTy3X5LntWMCuojMxurF0yM8gJzo5hzCb7ykZCfa/zXGYACn3UbVuG7cLvZLMWWSQoR/JF3DuhAb1AZxu8j9ZhHpf/87bW6//QRb0HSys7N55ZVXGiWgn3766axatYqgoCBeffVV7rnnHj74oNqJeJRqlRojolYXz6qNlsaY14HXAYYMGWIu/EzvFAXYl5HPxBeWMaRrJP+8dljl3nr6DvJfGc7HA8bzuskhOW8DcSFxTO83ndGB/mS89TbhU6fi3/14Zp5revfddx+7du0iISGB8ePH88wzzxx3XWPHjq34/4gRI3j33eOdzU4p39QYAT2JypO1xnH8EwG3Sl2ig7n/vD489N9NzPvlAFcN95ofOKYnwfFXMn39h1z525V8l7Odf276J0/98hQf9o3hqe8DOPTHx+j8ztt1jrk9+tkmNqccadS29+sQxiPn969x+VNPPcXGjRtZu3ZttctHjx5Nbm7uMa8/++yznHPOOTXW+9ZbbzFpUl0zlCnVujRGQP8UuE1E3seaEzGnrvFzdayrh3fhy02HeOJ/mxndM4ZOUUFHF465F9Z9gH3pc4yf+iLju4xnadJSbv32VnZfOY5ur3/Fkc//R/j5U5pvB47TsmW1TbVavXfffZdVq1axZMmSJmiRUi1XnQFdROYBiUCMiCRhTWDrBDDGvIY1g/d5WJO1FmDNvq0ayGYT/nxpPBP+spS7PlzHvBtGYLN5etwRnWHILFj5Foz6HUT34Oy4sxncdjAvBG7ktYEDSH36aUISx2APDa1xG7X1pJtLQ3voixYt4oknnmDJkiX4+9c18b1SrUt9rnK5so7lBri10VrUinWMCOThKf2456P1/GPFXmaN8rqhYPRdsOZfsPgpuOQNAGb2n8lvv/stu6+fRsffv0jaC3+l3UOn1lzUoaGh1Qbscg3pof/666/ceOONfPnll7Rp06YxmqeUT9FcLqeYaUPiGNs7lqe/3MrutLyjC0LbwvDZsOFDSN0MwNlxZ9M1rCtvlH5HxJVXkDVvHoUbNzVTy6sXHR3NqFGjGDBgAHffffcJ1XX33XeTl5fHtGnTSEhIYOrUqY3USqV8Q7PNKTpkyBCj+dCrl3qkiHP/spQescF8eNOZ2MuHXgoy4a/x0O1suOLfAMzfNp/HfnqMt8/8G+GzHsLZvj1d35+H2O0AbNmyhb599Xp/pVqi6v5+RWS1MWZIdeW1h34KahsWwKNT+7NmfzZvLNt9dEFQFIy8DbZ+DslrAJjaYyqR/pH8Y/8C2t57L0UbNpD94YfN1HKlVHPSgH6KuiChAxP7t+P5r7ezPdVrDHrEzRAYBd89DkCAI4Ar+lzBkqQlpI/uS9CQIaS//ArukpJmarlSqrloQD9FiQiPXzSAkAAHD33ilRctIAzO+j3s+hb2/gDA5b0vx8/mx7tb3iXmlpspS0sj57//baaWK6Waiwb0U1hMiD+3jj2Nn/dksnJv5tEFw26AkHbw3WNgDNGB0Uw9bSqf7vyUwoReBPTrR+abb2FcruZrvFLqpNOAfoq7clgnooL9eOm7nUdfdAbC2XfB/hWwZykAM/rNoMRdwvzt84m+4XpK9u0jd9G3zdRqpVRz0IB+igvyc3DdWd1Ysj2NDUk5RxecPsPqpS+1cqN0D+9OYlwi7299H+f/nY2zc2cy3nyzmVqtlGoOGtBbgBkjuxAa4ODl77176QHWXaN7l8H+nwC4pv81ZBVn8dne/xF97bUUbdiAu7i4mVptKc+22JgWLFiAiKCXvSpVmQb0FiAswMnMM7vy5aZDla94GfwbCIqp6KUPaTuE/tH9mbtpLsEXTMEeE4M7L6+GWk+Oxg7oubm5vPjiiwwfPrzR6lTKV2hAbyFmjepGkJ+dV7x76X7BMPJW2LkIklcjIsweNJsDuQf4KuU7oq65BlNcjLuwsNna7Z0+90TvFAV46KGHuOeeewgICKi7sFKtjE4S3UJEBftx9fDOvLV8D78f34su0cHWgqHXww9/haXPwZXvMbbTWHpH9ub19a8z4bJ/krLmV8rS0/Hr1Am+uA8ObWjchrUbCJOeqnFxY6bP/fXXXzlw4ABTpkzh2WefPaFmK+WLNKC3IDeM7s4/Vuzj1cW7eOqSQdaLAWHWzUaLn4RDG5F2A7gx/kbuWHwH32T+SJfgGFw5ObjbtDklf47VNzmX2+3m97//PXPnzm3aBinVgmlAb0HahAVw2ZA4Plh5gP83ricdIjxziQ6bDT++BMuehWlzGdd5HKdFnMbr61/nydOeABHKMjLwq6Un3Vzq20PPzc1l48aNJCYmAnDo0CGmTp3Kp59+ypAh1aa1UKrV0YDewtx4dg/e/+UAry/dzZypnvzmQVEw7HpY/gIkbscW24sb42/k7iV3U2RKsEe2xZWVhTs2FpvTeVLb21jpc8PDw0lPT694npiYyLPPPqvBXCkvp+KvcFWLTlFBXHh6R+b9sp+0XK9LEkfeBo4AWPYcAOM7j6d7eHdyS3JxxMYC4EpLO+ntbcz0uUqp2mlAb4FuTuxBicvNW8v3HH0xOAaGXGvlS8/cjd1m58ZBN1LmLiPPFGGPiKAsK6tZkna99957bNy48YQmiK5q8eLF2jtXqgoN6C1Qj9gQJg9sz79W7CUz3ytAn/lbsNlh2fMATOg6AYfNweHCwxW99LK09OqqVEr5AA3oLdTvxvWksNRV+e7RsPYweBasfQ/Sd2C32QlxhlBcVmz10iMjcWU3Ty9dKdX0NKC3UD3bhnLp4Dj+tWIfSVkFRxecfZc1lv7dYwAEOgLxs/uRVpiGIyYGgLJmGEtXSjU9Degt2O3n9EIEnv9m+9EXQ9rAmbfB5v9W3D0aGxhLUVkRuaYQR2Qkruxs7aUr5YM0oLdgHSICmXlmVz7+NZktB48cXTDyNgiKhkWPAhDuH46/w5/UglTs2ktXymdpQG/hbk7sQai/g2e+2nb0xYAwGH0X7FkCpUWICG2D2lLqKiXLlYsjMgpXlvbSlfI1GtBbuIggP25OPI3vth7m590ZRxcMuRbCO0FRNhhDiDOEIGcQ6YXp2GKiQKDs8OEmb19jZ1ucP38+/fr1o3///lx11VWNVq9SvkADug+YNaor7cICeOrLrRhjrBedATD2fnCVQFF2RS+9zF1GZtkRHNHR1lh6E2dibMyAvmPHDp588kl++OEHNm3axAsvvNAo9SrlKzSg+4AAp53bz+nJr/uz+WpT6tEFgy4HuxOOHATjJsgZRKhfKOmF6Uh0JGK3U5qaWnPFjaAx0+e+8cYb3HrrrURGRgLQpk2bxmiiUj5Dc7n4iEsHx/HGst0889VWzunbBofdZt1kFBABrmIoyOTpTW+xOWMzhWWFOG1OnG7BlJQgmwIQu/24ttsnqg/3Dru3xuWNmT53+3brap5Ro0bhcrmYM2cOEydOPK52K+WLNKD7CIfdxt0T+nDTu6tZsDqJK4Z1thY4A8Fph1yrl24TGw6bgzJ3GU5HAJR6gnpgYLO0u77JuQDKysrYsWMHixcvJikpidGjR7Nx40YiIiKaroFKtSAa0H3IhP5tOaNzBM9+vZ3Jg9oTGuDJrBjeEdK3c2/fayCsI6WuUnZk7yDML4x2rhBKk5JwxsXhaIbA2JAeelxcHCNGjMDpdNKtWzd69+7Njh07GDp06MlqrlKnNA3oPkREmDO1Pxe8/AN/XbSDB6f0sxb4BUNgFOSlQVA0TkcA0QHRpBemExUeiT0ggLLUVOxhYYitcU+rNFb6XIALL7yQefPmMXPmTNLT09m+fTvdu3dvjGYq5RP0pKiPGRQXweVDOjH3x73sPOwVSMM6gAjkpAAQExiDw+bgUH4qjrZtMaWluDIzG709jZk+d8KECURHR9OvXz/Gjh3LM888Q3R0dCO1VKmWTyouczvJhgwZYlatWtUs2/Z1GXnFjH12MYPiInhgVBh9+/a1FuSmQm4KRPWAgDCyi7JJzkumY0hHAg9lYwoL8e/ZE3HoDzelTgVbtmw5+vfrISKrjTHV5o6uVw9dRCaKyDYR2Ski91WzPFxEPhORdSKySURmHVfrVaOIDvHnznN7s3xnOoUlrqMLQmLB7g9HksG4CfcPJ9ARaKUEaNsG43KflJuNlFJNo86ALiJ24GVgEtAPuFJE+lUpdiuw2RgTDyQCz4mIXyO3VTXA1cM706ddKDmFpbjdnl9hYrNOkJYVQX46IkK74HaUucvIcOfiiIqkLDMTd1FR8zZeKXVc6tNDHwbsNMbsNsaUAO8DF1QpY4BQEREgBMgEyhq1papBHHYbj07tT5nbcDjPa6o6/zDwD4XcQ+AqJcgZRLh/OBlFGbhjPDcbHTxIcw3FKaWOX30CekfggNfzJM9r3l4C+gIpwAbgd8YYd9WKRGS2iKwSkVVpmu2vyQ3vHk2Qn5203GKKyzxDLyIQFgfGbY2nA22D2iIIqUVpONq2xZ2fj/vIkVpqVkqdiuoT0KWa16p23yYAa4EOQALwkoiEHbOSMa8bY4YYY4bEeqZEU00rPNCJAAeziyrneQmJhYJMKM7DaXcSExhDbkkuhcEObAEBlB46hHEf852slDqF1SegJwGdvJ7HYfXEvc0C/mMsO4E9QJ/GaaI6EXab0DbMnyNFpRwpLD26IKQd2P0gez8YN9GB0fjb/TmYfwh7O+syxrJ0nX9UqZakPgF9JdBTRLp5TnReAXxapcx+YByAiLQFegO7G7Oh6vjFhPgT6LSTnF1EmcvT67bZrfS6rmLIS8UmNtqHtKfUXUq65GMPD6csLQ13cXHtldehMbMt7t+/n7Fjx3L66aczaNAgFi5c2Cj1KuUr6gzoxpgy4DbgK2ALMN8Ys0lEbhKRmzzFHgPOFJENwLfAvcYY7d6dIkSEuMggXG7DwRyvK1gCwiAg0ro+vbSIYGcwEQERZBZm4o6NRERO+ARpYwb0xx9/nMsuu4xff/2V999/n1tuuaVR6lXKV9TrOnRjzEJjTC9jTA9jzBOe114zxrzm+X+KMeZcY8xAY8wAY8y7Tdlo1XCBfnZiQ/3JKight8hr6CW8o3U5Y84BMIa2QW2x2WykFB+2TpDm5eHKyTnu7TZm+lwR4YjnZG1OTg4dOnQ4ofqU8jV6S2Br8tLzONdvIgkrwFec7XaXQlkxOPzB5sThLqPIVcxeuz/2klJwGyQoEKnm/Lh/3z60u//+GjfZmOlz58yZw7nnnsvf/vY38vPzWbRoUT13XKnWQQN6ayLg77RRWOKipMyNv8PzA83mBCmDshLwc1jpdU0Zpe4S7H7+mMIiKClF/Br/XrGGJOcqT8x15513smLFCmbMmMHGjRuxNXJCMaVaKg3orUh5Tzo5u5CMvGI6xoYQ7O/5CJQWQdpW66ajqO4Uu0vYlb0LuzOE9vlOyjIy8OveHXtQUKO2qSE99Lfeeosvv/wSgJEjR1JUVER6errOXKSUhwb0VqhdWAC5haUkZRVyWpsQ7Daxrk0P62DleSnMxD8omjZBbUjNTyUsoj0BR5yUJidj69GjQSl2GzN9bufOnfn222+ZOXMmW7ZsoaioCL2fQamj9LdqK2S3CXFRQRSXuTiY4zVJdHCslTs9JxnKSogOiCbQGcihgsPY2rfFFBdT1sA7fBszfe5zzz3HG2+8QXx8PFdeeSVz587FyjahlALtobdaIf4OYkP9ScstJizASVig00oLENHFGnrJ2Y9E9aBjcEd25eziEEdoFxFBWVo69rAwbA2Ysu69995rlDb369ePH374oVHqUsoXaQ+9FWsbFkCA005SViGl5TccOfytoZfiXCjIwN/hT5ugNlZagKhgxGGnNClZ0wIodQrSgN6K2UToHBWEyxiSswqP3kAUFAN+IdZ4emlRxdBLSuEhpH1b3MVFDR56UUo1PQ3orVyA0067sACOFJWSVVBivSgCkV0Agey9CIaOIVaCzYPkYA+PoCw9HXdBYc0VK6VOOg3oipgQP0L8HaRkF1FU6kmza/eDiM5QWghHDuJv96ddcDvyS/PJjfRHHA5Kkg5gXK7aK1dKnTQa0BUiQqeoIGwi7M8owFU+w1FghDX8kn8Yio4Q4R9BqF8oqcVpmPaxmJISSlNTm7XtSqmjNKArAJx2G52jAikqc5GS7TWeHtYBHAGQvQ9xl9EhpAN2sZPszsQeHY0rMxNXLdeZK6VOHg3oqkJIgJO2YQFkFZSQVeBJ4GWzQ2RXcLsgex8OsdMxpCPFZcWkh7ityTCSkzGlpbXWrZRqehrQVSVtQv094+mFR8fTnYEQHmddyph3iBC/EGICY8gqzqaoTTjG5aIkOVnnIVWqmWlAV5VUjKfbhH0ZBbjKrzcPiobAKGty6aIjtAlqQ5AziJTSdKRtLO68vFpnOLLb7SQkJFQ8nnrqqUZpb1351kNCQir+f+aZZza4/vJ1GjOvu1JNRQO6OobTbqNLVBAlZW4OZHrG00WsXrojALL2Iq5S4kLiEBGSHEewhYVRlnoYV35+tXUGBgaydu3aisd9993XKG1tSKD98ccfG1x/+Toa0FVLoAFdVSvY30GHCOv69NQjnmnobHaI7AYYyNqD03Z0PD0j3Ib4OSlNSsKUldVrGytXrmTQoEEUFRWRn59P//792bhxIwAXXnghgwcPpn///rz++usV6/zzn/9k0KBBxMfHM2PGjAZNoFHeW9+7dy99+vTh+uuvZ8CAAVx99dUsWrSIUaNG0bNnT3755Zdj1qlrO9W1Nz8/n8mTJxMfH8+AAQP44IMPjllv2rRp3HbbbZx11ll06dKF5cuXc80119CrVy+uu+66Ot/D9evXs2fPnjrLqVbCGNMsj8GDBxvV9DZv3lzp+ZgxY+p8PPPMM8YYY9xutxkxarT543Mvm+z8YpOWlmaVGT3KjBk52IwZNcIYt9uk5qeajWkbTVbWIVOwcaMp2rPHuN3uStu12WwmPj6+4vH+++8bY4x54IEHzJ133mluueUW86c//amifEZGhjHGmIKCAtO/f3+Tnp5uNm7caHr16mXS0tIqyuzZs8f079+/xv0PDg4+5v979uwxdrvdrF+/3rhcLnPGGWeYWbNmGbfbbT755BNzwQUXVLtObduprr0LFiww119/fUWZ7OzsY9br3bu3ee6554wxxjz00EOmV69eJiUlxRQXF5uIiAhTVFRU4zaNMeann34yAwcONLt37670+sKFC01iYqJ58MEHzXfffWfOPvtsc8cdd9Ralzr1VP37NcYYYJWpIa5qci5VIxHB32HDz2HjQFYh4eI5SWpzWDceuUogP53Y4FgKywpJKc2ga9to3IfSKUtNxdmuXUVd5UMuVT388MMMHTqUgIAAXnzxxYrXX3zxRT7++GMADhw4wI4dO1i5ciWXXnopMTExAERFRVVMSddQ3bp1Y+DAgQD079+fcePGISIMHDiQvXv3Nri+6to7cOBA7rrrLu69916mTJnC6NGjK61TVFREdnY2t99+O2C9R9dddx3t27cHICgoCD+vSUXefffdas89HDx4kMsvv7zSL4tvv/2W77//nj//+c/85S9/YdGiRcybN4/NmzfTr1+/Bu+fahk0oLcyixcvbnD5UpebnYfzyCeQb779DqfdBsZA5m44koQ4A+gY0pHdObs5YHLoGmmlBrAFBmIPD6+1/szMTPLy8igtLaWoqIjg4GAWL17MokWLWLFiBUFBQSQmJlJUVIQxptHS5fr7+1f832azVTy32WyU1XPIqFxN7e3VqxerV69m4cKF/OEPf+Dcc8/l4Ycfrlhv06ZNnHHGGRUzLq1bt46bb74ZgKSkJDp06FBpf6dPn8706dMrbXv//v1MnTqVv/zlL5VeN54rjqKiosjLy8PlclX04pTv0jF0VSen3UbX6CDK3Ia9Gfm43Z6TpJFdrZOkmXtwuF10Du2My7hIDi7GFhRESXIy7sLa873Mnj2bxx57jKuvvpp7770XsCaAjoyMJCgoiK1bt/LTTz8BMG7cOObPn09GRgZgfRnUNYFGY6ltOzW1NyUlhaCgIKZPn85dd93FmjVrKq23YcMG4uPjK56vX7+eQYMGAVZwL/9/bbZt28Yrr7zCqFGjKr1+zjnnMG7cOLZs2VIxF+uqVavo379/g/ZbtSzaQ1f1EujnoHNUEHsz8jmQVUDnqCDEZoeobpC2HTJ2ERDbi7iQOA7kHiA9KpToQzZK9u/Hv0cPCgsLSUhIqKhv4sSJ9OvXD4fDwVVXXYXL5eLMM8/ku+++Y+LEibz22msMGjSI3r17M2LECMAaGnnggQcYM2YMdrud008/nblz51ZMoDFp0iSeeeaZJtl/74k6qm6npvZu2LCBu+++G5vNhtPp5NVXX61U54YNGxg2bBhgDb8UFhYSGRkJVA7utRk/fny1r0+aNIlJkyZVPF+6dOkxZc477zzefPNNOnToUOd2VMsgzfUTbMiQIWbVqlXNsu3WZMuWLfTt27fR6kvPKyYlu5CYEH86RHgmuSjOg4yd1mxH0T1IL8okNT+VtrYIgg9mYwsOxq9LF51dSKkGqu7vV0RWG2OGVFdeh1xUg8SE+BMT4k96XjFpuZ7LGf1DrMyMJXmQfYDogGgiAyJJdWdTGhth3XR0SJN4KdXUdMhFNVj78ABKXW4O5hTisAuRQX4QFAWuYsg9hNidtAttR4mrhKSyHLpGhFGWkY74++GIimru5ivls7SHrhpMROgUGUSwv4OkzEJyizyJuULaWSkC8lKx5afTKbQTfjY/9gfmI8FBlKYc1MyMSjUhDejquNhsQtfoIPydNvZlFJBfXOZJD9AJAsLhSDL2omw6h3UGEZLCypAAf0oOHKjzyhel1PHRgK6Om91mo1tMMA67sDc9n4KSsqOXM/qFQvZ+/EoK6RzamRLKOBgJYrdTsm8f7pKS5m6+Uj5HA7o6IU67je4xIdjtwp70fApLykBs1uWMziDI2kOQ5xr1QkpIi3aAMZTs3VfvnC9KqfrRgK5OmJ/DRveYYOwi7C4P6jY7RPUAhz8SEMbNs26gY0hHjlDE4XAbnUYMZ/K552I86Xk/++wz+vXrx4ABA3jggQcq1b9t2zYSExNJSEigb9++zJ49+5g27N27lwEDBhzz+sMPP8yiRYvqvS8pKSlceumlAKxdu5aFCxc25K2oVz1z5szh2WefPa56q5o7dy4pKSnNXseJ8D52q1at4v/9v//XZNuquq/XX389mzdvbrZ6Gl1NSV6a+qHJuU6O6pL7NJWi0jKzOSXHbErONgUlZdaLZcUmOCjQJAzoYwpyMkxmYaZ5dd6rpn//vmbi2WdbibxcLtO9e/eKBFNVE02de+655pNPPql4vn79+mO2XVfyrOPxzjvvmFtvvbXR63nkkUcqEqCdqDFjxpiVK1fWWa60tPSE66hvfQ3V2Meusfe1KeupS0OTc2kPXTUaf4ed7jHBiAh70vKtGY/sfiA2Jo09i/998A6Rdn++/+x7zr14Ii4/O+68PEqTkvDz8yMpKQmwEmd5O3jwIHFxcRXPy5Nq1cfMmTNZsGABAF27duX+++9n5MiRDBkyhDVr1jBhwgR69OjBa6+9BhztLZaUlPDwww/zwQcfkJCQcEzq2/POO4/169cDcPrpp/PHP/4RgIceeog333yzzno2b95MYmIi3bt3r5SU7Pnnn2fAgAEMGDCAF154oVKbyj377LPMmTOHBQsWsGrVKq6++moSEhIorHKyOTExkfvvv58xY8bw17/+ldWrVzNmzBgGDx7MhAkTOHjwYLV1dO3alXTPZCWrVq0iMTERsH5ZzJ49m3PPPZdrrrmGOXPmcO211x6zH/VJG7x69Wri4+MZOXIkL7/8csXrixcvZsqUKQAsWbKkYkKU008/vSL1wp///GcGDhxIfHx8RV79493XxMREVq1axaefflqxrd69e1d8Bv/4xz8ydOhQBgwYwOzZszHG1FoPwLx58xg4cCADBgyoSGcBVirmBx54gPj4eEaMGEFqU0ywXlOk934AE4FtwE7gvhrKJAJrgU3Akrrq1B76yVGf9Lkvv/yyMcaY/Pz8ape/8847xhhzNH2u16M6RSVlZlNKjtmUnGMKS8pMcHCwWbd6pblk8nhTuPsXEz9ooPlo4Ufm7PFnm4zkXSZv3TpzwcSJ5rTTTjumd26MMW+//bYJCwszEydONM8//7zJyso6pkxNvbzf/OY35sMPPzTGGNOlSxfzyiuvGGOMuf32283AgQPNkSNHzOHDh01sbOwx9dTWQ3/yySfNSy+9ZHJycsyQIUPMueeea4wxJjEx0WzdurXWeh555BEzcuRIU1RUZNLS0kxUVJQpKSkxq1atMgMGDDB5eXkmNzfX9OvXz6xZs+aYfXvmmWfMI488UnE8a+opjhkzxtx8883GGGNKSkrMyJEjzeHDh40xxrz//vtm1qxZ1dbRpUuXihTFK1eurDjOjzzyiDnjjDNMQUFBrftRn7TBAwcONIsXLzbGGHPXXXdV7N/3339vJk+ebIwxZsqUKWb58uXGGGNyc3NNaWmpWbhwoRk5cqTJz883xhxNW3y8+1rd+zdt2jTz0ksvVarfGGOmT59uPv3001rrSU5ONp06dTKHDx82paWlZuzYsebjjz82xhgDVKx/9913m8cee+yY96WqRu+hi4gdeBmYBPQDrhSRflXKRACvAFONMf2BaY3xZaNaJn9neU8ddqXlATDojCHsPZjBvP9+xXljhhHpCMTP7sdBv0Je/PhD+nTuzIuPPcb5559PWloav/zyC9OmWR+jWbNmsWXLFqZNm8bixYsZMWIExcXFx9W2qVOnAlYvf/jw4YSGhhIbG0tAQADZ2dn1rmf06NEsXbqU5cuXM3nyZPLy8igoKGDv3r307t27zvUnT56Mv78/MTExtGnThtTUVJYvX85FF11EcHAwISEhXHzxxSxbtuy49rPc5ZdfDljnITZu3Mj48eNJSEjg8ccfr/hF1BBTp04lMDCw1v0YOHAgixYt4t5772XZsmWEV8m4mZOTQ3Z2NmPGjAFgxowZ1W5r1KhR3HHHHbz44otkZ2fjcDhYtGgRs2bNIigoCLCySTbmvv75z38mMDCQW2+9FYDvv/+e4cOHM3DgQL777js2bdpU6/orV64kMTGR2NhYHA4HV199dUUeHT8/v4pfH4MHDz6uNM11qc+dosOAncaY3QAi8j5wAeB9BuAq4D/GmP0AxpjDjd1Q1ThqS58bFBRU6/KYmJh6p98NcNrpHhvMnvR83AZyi0qZesEF3PXYX1j80ZtkZKTgLw5iAmP4YtkS7p59I4n9BnD/b3/L5MmTGTZsWMUfKECHDh249tprufbaaxkwYAAbN25k8ODB9dzro7zT5FZNoduQtLlDhw5l1apVdO/enfHjx5Oens4bb7xR7zZ5b9tut1NWVlZjaluHw4G7fG5XrERe9RUcHAxYv8T79+/PihUr6lzHe3tVt1VeX7nq9qOutMGmnmmQ77vvPiZPnszChQsZMWIEixYtqnXd49lXb99++y0ffvhhRQAuKirilltuYdWqVXTq1Ik5c+bU+d7XdAwBnE5nRdvL36vGVp8x9I7AAa/nSZ7XvPUCIkVksYisFpFrGquBquXyd9jpERuCAHszCrj0yuk8/PDDDDxrsnVpY2k+bRxBnHH6Gcz99D8UhDi5aNQoesTF8d577zF58mQAvvzyS0pLrbtRDx06REZGBh07Vv0INr7aUub6+fnRqVMn5s+fz4gRIxg9ejTPPvvsMZNY1FWPt7PPPptPPvmEgoIC8vPz+fjjjxk9ejRt27bl8OHDZGRkUFxczOeff97gunv37k1aWlpFkCstLa3obVato2vXrqxevRqAjz76qM66q6orbXBERATh4eEsX74cgH//+9/V1rNr1y4GDhzIvffey5AhQ9i6dSvnnnsub7/9NgUFBYCVQvlE9rXcvn37uOWWW5g/f37FL5Dy4B0TE0NeXl7FuZja6hk+fDhLliwhPT0dl8vFvHnzKn6JnAz1CejVfR1W/RpyAIOBycAE4CER6XVMRSKzRWSViKxKS0trcGNVy+O02xCBQKcdV2AUM66/GRx+1oTT2JCMXTxx3z342/0ZNuE8Rl55BbEhIVx/1VVcddVVuN1uvv76awYMGEB8fDwTJkzgmWeeoZ3XbEjltm3bRlxcXMXjww8/PKG2jx07ls2bN1d7UhSoCLZBQUGMHj2apKSkagN6XfWUO+OMM5g5cybDhg1j+PDhXH/99Zx++uk4nU4efvhhhg8fzpQpU+jTp0/FOjNnzuSmm26q9qSoNz8/PxYsWMC9995LfHw8CQkJFRNgV63jkUce4Xe/+x2jR4/Gbrc35C0DjqYFTkhI4IknnuDBBx88psw777zDrbfeysiRIysN4Xh74YUXKo57YGAgkyZNYuLEiUydOpUhQ4aQkJBQ7eWfDdnXcnPnziUjI4OLLrqIhIQEzjvvPCIiIrjhhhsYOHAgF154IUOHDq0oX1M97du358knn2Ts2LHEx8dzxhlncMEFF9T6fn366aeVfsGciDrT54rISGCOMWaC5/kfAIwxT3qVuQ8IMMbM8Tx/C/jSGFPjX5Smzz05Gjt97vFyuQ37MvLJKy6jXXgAsSH+iNsFmbugtADCO3FY3KQVpNG20I/gnGLs4eE44+I07a5qtZoife5KoKeIdBMRP+AK4NMqZf4LjBYRh4gEAcOBLQ1uvfJZdpvQNSaYiEAnh3KKSM4uxG2zQ/Rp4B8KOQdo43LTLrgdqYEl5Ib74crJofTAgYqbj5RStaszoBtjyoDbgK+wgvR8Y8wmEblJRG7ylNkCfAmsB34B3jTGbGy6ZquWyCZCp6gg2oT6k5lfwt70fMoQiOoOgZGQe5DokkLiQjqSHlRGTrgT15EjlOzfj3G5mrv5Sp3y6pUP3RizEFhY5bXXqjx/Bmia+b+UzxAR2oUH4uewk5xdyK7D+XSLCcIvogvYHJCfRnhZMfaQOA6QjMvmICorj5I9e6xZj5zO5t4FpU5ZeqdoK1DXeZLmEBXsR7foYMrcbnYezie/xGWdKA2Pg+IjhOSk0CWkI7mBcDjKhru4mOI9e3Af5/XnSrU0x/N3qwHdxwUEBJCRkXFKBvWQAAenxYZgt8Hu9Hwy8ooxQTFWUi9XCUFZ++ge1J6SQCcpUWDKyijZswe355I1pXyVMYaMjAwCAgIatJ5OQefj4uLiSEpK4lS+TNTtNmQXlHBon5tgfzsRgU7EDeQfhr0HcQdGkuUq5kBpMZEFgiQnY4+MxFbD5W5K+YKAgIBKOYzqQwO6j3M6ncckuzoVud2GFxZt58VPdxIfF86r0wfTwdEePvwN7PuB0mE38liYH4u2fsJj/wulw85sYm65hZjbbkVs+kNTKdAhF3WKsNmEO87tzd9nDGZXWj5T/rac75MNXPNfGH4zzl/+zqM71nDLiFu555ICVg4OJf2VV0i+406d0k4pDw3o6pQyoX87Prl1FG1C/Zn1zkoe/2IHJeP/BBe9jiSvYfr3f+O1M+7grfMDeP8cf4589RX7ZlxDaaqmD1JKA7o65ZzWJoRPbh3FjBFdeHP5Hi559Uf2dJwC130Ndj+GfvJ7Pmjzf2yf2Ic/XyLk7dzGnosvJv/nX5q76Uo1Kw3o6pQU4LTz2IUD+PuMwezPLGDKi8v4+FAU3LgU+l9Iu6V/YW5GHp3POY97prtJsxewf9Ys0l9/Q+8sVa2WBnR1SpvQvx1f/G40/TuE8/sP1nHHf3dzZPJrMPUl/A+s4tGVH3PtiMu49zfCqr5O0p5/nqRbbsWVk9PcTVfqpNOArk55HSICmTd7BLef05NP1iYz4YVlLA2ZCLMXI8GxTFv0HO+0PZP/TO/MW+NtHFm2lN0XX0zhBs0+oVoXDeiqRbDbhNvP6cV/bhlFkJ+da97+hT8sLyF3xlcw5Dp6rvon85IPEn7BOB68WsjIT2PvFVeQ/sYbmgdGtRp1ps9tKpo+Vx2volIXf1m0nTeW7qZ9eCBPXzKIs2Qt/Pe3kJfKN4Mv4+nDa5nxWT7DtpQRNGwYHZ5+Cmf79s3ddKVO2Immz1XqlBLgtPOHSX1ZcPOZ+DttTH/rZ+5b14acWUth0GWMXzWPd0ts/HjtQF6ebCN77Sp2TZ3KkS++aO6mK9WktIeuWrSiUhd/+WY7by7fQ0Sgkwcm9+WiwF+Rz3+PKcjkw/jJ/PPAFm7+uIjuKS5CJ02i3UMP4vCaXFiplkR76MpnBTjt/OG8vnx221l0jg7ijvnruGpZLHuu+A5JuJLL1n7Kq6aYj27pzvtn28j++kt2nHceRxYuPCUTlil1IrSHrnyG222Yt3I/T3+xlaJSN9eP7sZtPVIJ+uou3Onbmd9rFAtSDzPzs0J6pLgJHvd/tH/kEZxt2jR305Wqt9p66BrQlc9Jyy3myYVb+M+vycSG+nPvOd24uHABtmXPcdgvgKe7n47/dzu5YpnBERhEh/vuJ/yiCzXJl2oRNKCrVunX/Vn88fPN/Lo/mwEdw3hidADx6x6DPUtY3O403ijz45JPcuibZHAmDCLu0T8S0Lt3czdbqVppQFetljGGT9el8PQXW0nJKWJS/7Y82nsvbVY8RkH2Pl7qFk/Kukyu+t5FSBFETL+atv/vd9hDQpq76UpVSwO6avUKS1y8sWw3ry7eRanLzdVD2nJ32HeE/PICu3HxQrs+nPbNYcatNRAVTtx9DxA2ebIOw6hTjgZ0pTxSjxTxt+928P4vB3DYhVuHhHFj2b9xbniPJWFRzCuL4fyFufQ4BPTtSZcHHyFo8ODmbrZSFTSgK1XFvox8nv9mO5+uSyHE38H9QwyX5szF7PiCf8e0Z+M+fy5aXEJ0LjjGnkWX+x7Er0uX5m62UhrQlarJloNHeParbXy79TDhgU7uH3iES7LeIj/5J96J6kjuepiywoWf20bIFdPoeNvvcERGNnezVSumAV2pOqxPyuZv3+3km82phPjbebjvIS7OfJP0jM28E9KR0J9cjF1vcAc4ibjmGjpcNxt7WFhzN1u1QhrQlaqnLQeP8PL3O/nfhoMEOGBOr/1clPseSVmb+betPXE/uRmxzVAa7E/krJl0nHUDtuDg5m62akU0oCvVQDsP5/HK4p38d20KYLiz6z5+Uzqf5OyNfGTa0OknGLzTUBwWQNSsmXSccZ1e6qhOCg3oSh2nlOxC/vHjXt77ZT+5RaXMareP25yfkJO9hv8URxO30kH8HkNJkB/BV06j6/W36hi7alIa0JU6QXnFZcxfeYC3f9hDUlYh50SkcF/Edzgyv+XjwlCi1vkzbLuh1M+OXDiBPrfeg7Nt2+ZutvJBGtCVaiQut+HrTYd4a/keVu3Loosjk0fa/kCf/P+xsNCGbAxm+GYDNqFozGD63nw3wQMHNXezlQ/RgK5UE9iccoT3ftnHx2uSoSSP30b+zMWykKX5OWTuCGXIRggsgZw+Hel07U10OO9CxOFo7marFk4DulJNKK+4jE9+Tebdn/ax7VAO4/0389uwJaQW/cq2faH0X2+nbTbkRQXif/lF9PvNb3FERDR3s1ULpQFdqZPAGMOa/dnM+2U/CzccJKzkMDeFLmew/TtWH3ITvsmfPgeg1CHkjh5E71m/JXromYhIczddtSAa0JU6yfKLy/hi4yE+Wp3Eyt2pnGNfw8zQZaTn7CBzVzD9twpBJZDVPgT/S85n0PTf4ozQq2NU3U44oIvIROCvgB140xjzVA3lhgI/AZcbYxbUVqcGdNVaHMgs4D9rklmw5gDFmSlc7PyB4QHLSU4qIHKrH90PQokDMof1pOtlv6HrORfoWLuq0QkFdBGxA9uB8UASsBK40hizuZpy3wBFwNsa0JWqzO02/Hogi8/WHWTh+hRi87dxid9S2pWu4chOGz222wkpgrwQO/ljTqfnlTfQYfBoHZJRlZxoQB8JzDHGTPA8/wOAMebJKuVuB0qBocDnGtCVqpnLbfhlTyafr0/hmw0HGFS0iv9zLsc/axfsdtJzj+B0QXobP8rGn8XAq28lpnu/5m62OgWcaEC/FJhojLne83wGMNwYc5tXmY7Ae8D/AW9RQ0AXkdnAbIDOnTsP3rdv3/HtkVI+pMzl5sddGfxv/UGWbd7PwKJVnGlbSujh/fjvctA92eqhp3QOxH7O2fS/dDaxGtxbrdoCen0G6qr7vVf1W+AF4F5jjKu2n4fGmNeB18Hqoddj20r5PIfdxtm9Yjm7Vywu90B+3X8mX2++nMUb99E15kdGuZYQfjCF4L2FdHj7K9Lf/ooNHf0oO3sIvafdQJd+I5p7F9QpolGGXERkD0cDfwxQAMw2xnxSU7065KJU7Ywx7Dycx9ebU1m8cR/BB39keNlS2qTuJ3Sf0OmQ9Sd3sK2dwuF96TZ1Bn1GTsZmtzdzy1VTOtEhFwfWSdFxQDLWSdGrjDGbaig/Fx1DV6rRHT5SxJLtaSzdlkr6jpUMzv+WLmlbiNjvokOKYANygoWM/jGEnTOBgedfS0Rk++ZutmpkjXHZ4nlYwyp2rCtYnhCRmwCMMa9VKTsXDehKNakyl5t1Sdks2ZbGxi2b6Ji8kJ7Za4g4mE/H/TaCiqHMBge6+uEe2pfuU6+l9+njsNu0997S6Y1FSvm49Lxilu1I4+fthziyYym9U7+m4+EDxB5w0SbTGppJD4fMnhEEDh9K78nX0rlbvF4S2QJpQFeqFTHGcCCzkB93pbN2+26cGz+mx6GfiTmcQ/tkCCq2yiW3EXJ6RhI2ciT9psymY7tezdtwVS8a0JVqxcpPrv6wI43d29YRtPlj4lI3E3son/YHwemyhmeS2wr5PSIJHzKUnpNm0rmz9uBPRRrQlVIVjDHszyxg5d4sdm36Ff9fP6RNymZi0vJpl2oFeICUaCGrazCBCX3pOu4yeidMxGHTlATNTQO6UqpWmfklrN6XxdaNG3CteZ+opA3EpuXS9qAhsMQqkxYGqZ38sPeKo93wMfQZew1R4e2at+GtkAZ0pVSDFJW62JCcw6bdSeSv+JDAXT8Qc+gw7VJdhOZbZUockNRWyO0USnD/3nQeM5XeZ0whwBHQvI33cRrQlVInLCOvmPX7s9j7yze41n5OaPJOotMLiE0DvzKrTFYwHGxvp6RLJNHxCfRInEbX00bp5ZKNSAO6UqrRlY/Fb9ixj/TlCzDbfiAi9RCxh0uIzj5aLjUC0to6KOscRdSgeHokTqNbjzM1yB8nDehKqZOizOVmT3o+WzduJvOHD7DvXkvY4XRi0kqJzD1arjzIl3SKInLgIE5LvITuPc/Sk671oAFdKdVsyq+L37phA2nL58PuXwlN9QT5I0fLpYXD4bZ2iuMiCR/Qn9PGXMJpfcdqkK9CA7pS6pRijOFwbjFb1q0jddl83LvWEnwojej0UqJyjpZLD4PUtnaKO4YT0q8Pvc6+gNMGTsRp92u+xjczDehKqRYhK7+ELRs3k7R0PmXbVxJ86DDRaZXH5NPD4HAbGwXtQwns1YueZ0+h3xkX4HT6N1u7TyYN6EqpFiuvuIzNm3eStPh9Srb+TODBg0SlFROTdbRMZigcamMjv10wfl27EJdwJvFnX0ZoeMfma3gT0YCulPIpbrdhz54D7PhmHrkbluOflEzk4UKissDmKVPkhNRoyI5xUNomnIBuPeg8bBzxwy4gIDC8Wdt/IjSgK6Vahay0DNZ/+x/S1i6B/XsIOZxDVKaL0IKjZXIDITUGcqP8cMWE4xfXmfb9hzJgxBSi2vRovsbXkwZ0pVSrZYwhadduti3+iCObfkaSDxCalk9UhrsirQFAqR3SIiAnQiiIDMAdG4l/px606RlPnzPG0b5DbzgFkpVpQFdKqSqMMRzet5ctyz4nY8svuJP3E5CRQ2hWCVHZpiJJGYBLICsUjoRBQaid4vBA3FER+LWNI7xTb9r3SuC03kMJCY1u8nZrQFdKqQYwLhfJm35l5y9fk7VnM2WHknFkHSEwp5iwIy7C88BWJXSW2OFIMOQHQ2GQjeJgB2UhAZiwMOwh4fhFxhAS256Itp2J7NiT9l36EhoS1eAUxbUFdL1iXymlqhC7nbhBQ4gbVG3cxJSVkbz1V/auXUrWvm0UHz4IWVnY8wrwzyshMttNcEoJIYUlwBEgqdL6bmC/QH4gFPpDiT+UOYRSp+Dys+Fy2nH72XH7OTB+fhh/fyQgAJt/YK3tbraAvm3bNhITE2stM2XKFO666y4AEhMTmTlzJjNnziQ9PZ1LL720zm1ULX/nnXdy/vnns23bNm688cY6169a/k9/+hNnnnkmP/74I/fff3+d61ct//e//53evXvz2Wef8dxzz9W5ftXyCxYsICYmhrlz5zJ37tw6169afvHixQA8++yzfP7553Wu711+xYoVfPTRRwD84Q9/YMWKFbWuGx0dXal8RkYGr7/+OgCzZ89m+/btta7fq1evSuWjo6N58sknAbjkkkvIyMiodf2RI0dWKj9y5MhKn6W66GdPP3vl5ev/2XMAYZU+exdfdBEDe3XjonFDyUzZx+8e+xvuslIoKwOXCzLciNtYDwNiYFR4MNfEROMshZt27uOi8HAuCo8gq6yM21OSa2279tCVUqqJiM1GaGwHEs69EoDouV/WuU73KVMY4elMBCcmEnvFFURNGEPO9k247nkY1m+peXs6hq6UUi1HbWPotupeVEop1fJoQFdKKR+hAV0ppXzEKXWVy2WXXcYtt9xCQUEB55133jHr1HWlwc0338zll1/OgQMHmDFjxjHL67rS4MEHH+Scc85h7dq13H777ccsr+tKgxdeeIGEhAQWLVrE448/fszyuq40+Ne//kWnTp344IMPePXVV49ZXteVBgsXLiQoKIhXXnmF+fPnH7O8tisNAgMD+eKLLwB47LHH+Pbbbystr3rlQNUrDeLi4nj33XcBuP3221m7dm2l5VWvHKh6pUFCQgIvvPACANOnTycpqfJlXlWvWql6pcG4ceN46KGHAJg0aRKFhYWVlle9aqUq/ezpZw9a5mfPm/bQlVLKR+hVLkop1YLoVS5KKdUKaEBXSikfoQFdKaV8hAZ0pZTyERrQlVLKR9QroIvIRBHZJiI7ReS+apZfLSLrPY8fRSS+8ZuqlFKqNnUGdBGxAy8Dk4B+wJUi0q9KsT3AGGPMIOAx4PXGbqhSSqna1aeHPgzYaYzZbYwpAd4HLvAuYIz50RiT5Xn6ExDXuM1USilVl/oE9I7AAa/nSZ7XanId8MWJNEoppVTD1SeXS3UT3lV7e6mIjMUK6GfVsHw2MBugc+fO9WyiUkqp+qhPDz0J6OT1PA5IqVpIRAYBbwIXGGOqnaPJGPO6MWaIMWZIbGzs8bRXKaVUDeoT0FcCPUWkm4j4AVcAn3oXEJHOwH+AGcaY2ifsU0op1STqHHIxxpSJyG3AV4AdeNsYs0lEbvIsfw14GIgGXhERgLKakscopZRqGpptUSmlWhDNtqiUUq2ABnSllPIRGtCVUspHaEBXSikfoQFdKaV8hAZ0pZTyERrQlVLKR2hAV0opH6EBXSmlfIQGdKWU8hEa0JVSykdoQFdKKR+hAV0ppXyEBnSllPIRGtCVUspHaEBXSikfoQFdKaV8hAZ0pZTyERrQlVLKR2hAV0opH6EBXSmlfIQGdKWU8hEa0JVSykdoQFdKKR+hAV0ppXyEBnSllPIRGtCVUspHaEBXSikfoQFdKaV8hAZ0pZTyERrQlVLKR2hAV0opH6EBXSmlfES9ArqITBSRbSKyU0Tuq2a5iMiLnuXrReSMxm+qUkqp2tQZ0EXEDrwMTAL6AVeKSL8qxSYBPT2P2cCrjdxOpZRSdahPD30YsNMYs9sYUwK8D1xQpcwFwD+N5ScgQkTaN3JblVJK1cJRjzIdgQNez5OA4fUo0xE46F1IRGZj9eABikVkY4Nae3KEAzmnWJ0NXb++5esqV9vyhi6LAdLr0aaTTY93/Zbr8W66Ohu6fs8alxhjan0A04A3vZ7PAP5Wpcz/gLO8nn8LDK6j3lV1bbs5HsDrp1qdDV2/vuXrKlfb8oYu0+Otx/tUePj68a7PkEsS0MnreRyQchxlWorPTsE6G7p+fcvXVa625ce77FSjx7t+y/V4N12djXa8xRPxayQiDmA7MA5IBlYCVxljNnmVmQzcBpyHNRzzojFmWB31rjLGDKnvHqiWTY9366LHu3nUOYZujCkTkduArwA78LYxZpOI3ORZ/hqwECuY7wQKgFn12Pbrx91q1RLp8W5d9Hg3gzp76EoppVoGvVNUKaV8hAZ0pZTyERrQlVLKR5wyAV1EgkXkHyLyhohc3dztUU1LRLqLyFsisqC526Kanohc6Pnb/q+InNvc7fFVTRrQReRtETlc9Y7QGpJ9XQwsMMbcAExtynapptGQ422sVBLXNU9LVWNo4PH+xPO3PRO4vBma2yo0dQ99LjDR+4Vakn3FcTR9gKuJ26Waxlzqf7xVyzeXhh/vBz3LVRNo0oBujFkKZFZ5uaZkX0lYQb3J26WaRgOPt2rhGnK8PSm2nwa+MMasOdltbS2aI3DWlMjrP8AlIvIqLetWYlW7ao+3iESLyGvA6SLyh+ZpmmoCNf19/xY4B7i0/KZE1fjqk22xsUk1rxljTD71u8NUtSw1He8MQP+wfU9Nx/tF4MWT3ZjWpjl66L6UyEvVTY9366LHuxk1R0BfCfQUkW4i4gdcAXzaDO1QJ4ce79ZFj3czaurLFucBK4DeIpIkItcZY8qwMjN+BWwB5ntnblQtlx7v1kWP96lHk3MppZSP0MsDlVLKR2hAV0opH6EBXSmlfIQGdKWU8hEa0JVSykdoQFdKKR+hAV0ppXyEBnTVIojIX0Tkdq/nX4nIm17PnxORO46j3jkicpfn/zNFpIPXsr0iElOPOk73bks9t/u+iPRsaHuVqo0GdNVS/AicCSAiNiAG6O+1/EzghxPcxkygQ12FqnE/8LcGrvMqcM9xbEupGmlAVy3FD3gCOlYg3wjkikikiPgDfYFfRWSwiCwRkdWeXnx7ABG5QURWisg6EflIRIK8KxeRS4EhwL9FZK2IBHoW/VZE1ojIBhHpU7VRIhIKDDLGrPM8n+OZSvFrTw//YhH5s2f9L0XE6Vl1GXCOiDRHxlPlozSgqxbBGJMClIlIZ6zAvgL4GRiJFYjXAwarp3ypMWYw8DbwhKeK/xhjhhpj4rFyjFxXpf4FwCrgamNMgjGm0LMo3RhzBlaP+q5qmjYE68vFWw9gMtZEHu8C3xtjBgKFntcxxriBnUD8cbwdSlVLeweqJSnvpZ8JPI81ccKZQA7WkExvYADwjYgA2IGDnnUHiMjjQAQQgpU8qj7+4/l3Nda8t1W1B9KqvPaFMaZURDZ42vCl5/UNQFevcoexhnhW17MtStVKA7pqScrH0Qdi9YoPAHcCR7B64wJsMsaMrGbducCFxph1IjITSKznNos9/7qo/u+lEAiobh1jjFtESs3RDHjuKnUEeNZXqlHokItqSX4ApgCZxhiXMSYTq8c9EmsIZhsQKyIjAUTEKSLlJ05DgYOeMeyra6g/11OuIbYApzVwnXK9AE0tqxqNBnTVkmzAurrlpyqv5Rhj0j2TEl8KPC0i64C1HD2R+hDWmPs3wNYa6p8LvFblpGitjDFbgXDPydF6E5G2QKEx5mCdhZWqJ82HrtQJEpHfA7nGmHpfi+5Z54gx5q2ma5lqbbSHrtSJe5WjY+31lQ38o/Gboloz7aErpZSP0B66Ukr5CA3oSinlIzSgK6WUj9CArpRSPkIDulJK+Yj/D3YlRQ98/OxcAAAAAElFTkSuQmCC\n", + "image/png": "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", "text/plain": [ "
" ] @@ -717,7 +717,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -742,8 +742,8 @@ " agent.solve()\n", "\n", " # Compute the analytical Merton-Samuelson limiting portfolio share\n", - " RiskyVar = agent.RiskyStd ** 2\n", - " RiskPrem = agent.RiskyAvg - agent.Rfree\n", + " RiskyVar = agent.RiskyStd**2\n", + " RiskPrem = agent.RiskyAvg - agent.Rfree[0]\n", " MS_limit = RiskyShareMertSamLogNormal(RiskPrem, agent.CRRA, RiskyVar)\n", "\n", " # Now compute the limiting share numerically, using the approximated\n", @@ -776,7 +776,7 @@ " plt.xlabel(\"Wealth (m)\")\n", "\n", " plt.ioff()\n", - " plt.draw()" + " plt.draw()\n" ] }, { @@ -816,7 +816,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.9.10" } }, "nbformat": 4, diff --git a/examples/ConsPortfolioModel/example_ConsPortfolioModel.py b/examples/ConsPortfolioModel/example_ConsPortfolioModel.py index 8f7a45b97..aaae0b245 100644 --- a/examples/ConsPortfolioModel/example_ConsPortfolioModel.py +++ b/examples/ConsPortfolioModel/example_ConsPortfolioModel.py @@ -15,6 +15,7 @@ ) from HARK.utilities import plot_funcs + # %% # Make and solve an example portfolio choice consumer type print("Now solving an example portfolio choice problem; this might take a moment...") @@ -31,6 +32,7 @@ + " seconds." ) + # %% # Plot the consumption and risky-share functions print("Consumption function over market resources:") @@ -52,6 +54,7 @@ 200.0, ) + # %% # Now simulate this consumer type MyType.track_vars = ["cNrm", "Share", "aNrm", "t_age"] @@ -59,6 +62,7 @@ MyType.initialize_sim() MyType.simulate() + # %% print("\n\n\n") print("For derivation of the numerical limiting portfolio share") @@ -67,6 +71,7 @@ "http://www.econ2.jhu.edu/people/ccarroll/public/lecturenotes/AssetPricing/Portfolio-CRRA/" ) + # %% "" # Make another example type, but this one optimizes risky portfolio share only @@ -77,6 +82,7 @@ # Have to actually construct value function for this to work init_discrete_share["vFuncBool"] = True + # %% # Make and solve a discrete portfolio choice consumer type print("Now solving a discrete choice portfolio problem; this might take a minute...") @@ -97,6 +103,7 @@ + " seconds." ) + # %% # Plot the consumption and risky-share functions print("Consumption function over market resources:") @@ -115,9 +122,11 @@ 200.0, ) + # %% print("\n\n\n") + # %% "" # Make another example type, but this one can only update their risky portfolio @@ -125,6 +134,7 @@ init_sticky_share = init_portfolio.copy() init_sticky_share["AdjustPrb"] = 0.15 + # %% # Make and solve a discrete portfolio choice consumer type print( @@ -150,6 +160,7 @@ + " seconds." ) + # %% # Plot the consumption and risky-share functions print( @@ -157,6 +168,7 @@ ) plot_funcs(StickyType.cFuncAdj[0], 0.0, 50.0) + # %% print( "Consumption function over market resources when the agent CAN'T adjust, by current share:" @@ -169,6 +181,7 @@ plt.ylim(0.0, None) plt.show() + # %% print("Risky asset share function over market resources (when possible to adjust):") print("Optimal (blue) versus Theoretical Limit (orange)") @@ -181,6 +194,7 @@ 200.0, ) + # %% "" # Make another example type, but this one has *age-varying* perceptions of risky asset returns. @@ -195,6 +209,7 @@ init_age_varying_risk_perceptions["CRRA"] = init_portfolio["CRRA"] init_age_varying_risk_perceptions["DiscFac"] = init_portfolio["DiscFac"] + # %% init_age_varying_risk_perceptions["RiskyAvg"] = [1.08] * init_lifecycle["T_cycle"] init_age_varying_risk_perceptions["RiskyStd"] = list( @@ -205,6 +220,7 @@ AgeVaryingRiskPercType = PortfolioConsumerType(**init_age_varying_risk_perceptions) AgeVaryingRiskPercType.cycles = 1 + # %% # Solve the agent type with age-varying risk perceptions # print('Now solving a portfolio choice problem with age-varying risk perceptions...') @@ -227,6 +243,7 @@ + " seconds." ) + # %% # Plot the consumption and risky-share functions print("Consumption function over market resources in each lifecycle period:") @@ -234,6 +251,7 @@ print("Risky asset share function over market resources in each lifecycle period:") plot_funcs(AgeVaryingRiskPercType.ShareFunc, 0.0, 200.0) + # %% [markdown] # The code below tests the mathematical limits of the model. @@ -269,6 +287,7 @@ def RiskyShareMertSamLogNormal(RiskPrem, CRRA, RiskyVar): return RiskPrem / (CRRA * RiskyVar) + # %% Calibration and solution for rcount in risky_count_grid: @@ -283,8 +302,8 @@ def RiskyShareMertSamLogNormal(RiskPrem, CRRA, RiskyVar): agent.solve() # Compute the analytical Merton-Samuelson limiting portfolio share - RiskyVar = agent.RiskyStd ** 2 - RiskPrem = agent.RiskyAvg - agent.Rfree + RiskyVar = agent.RiskyStd**2 + RiskPrem = agent.RiskyAvg - agent.Rfree[0] MS_limit = RiskyShareMertSamLogNormal(RiskPrem, agent.CRRA, RiskyVar) # Now compute the limiting share numerically, using the approximated @@ -319,6 +338,7 @@ def RiskyShareMertSamLogNormal(RiskPrem, CRRA, RiskyVar): plt.ioff() plt.draw() + # %% # %% diff --git a/examples/ConsPortfolioModel/example_ConsRiskyAssetModel.ipynb b/examples/ConsPortfolioModel/example_ConsRiskyAssetModel.ipynb new file mode 100644 index 000000000..11b391f57 --- /dev/null +++ b/examples/ConsPortfolioModel/example_ConsRiskyAssetModel.ipynb @@ -0,0 +1,1044 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "58437446", + "metadata": {}, + "source": [ + "# Example Implementations of `HARK.ConsumptionSaving.ConsRiskyAssetModel`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6b9b3abd", + "metadata": {}, + "outputs": [], + "source": [ + "from time import time\n", + "\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "from HARK.ConsumptionSaving.ConsPortfolioModel import (\n", + " init_portfolio,\n", + " PortfolioConsumerType,\n", + ")\n", + "from HARK.ConsumptionSaving.ConsRiskyAssetModel import (\n", + " RiskyAssetConsumerType,\n", + " FixedPortfolioShareRiskyAssetConsumerType,\n", + ")\n", + "from HARK.utilities import plot_funcs_der, plot_funcs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1fb52af2", + "metadata": {}, + "outputs": [], + "source": [ + "mystr = lambda number: \"{:.4f}\".format(number)\n" + ] + }, + { + "cell_type": "markdown", + "id": "9aecad69", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Idiosyncratic Income Shocks Consumer Type" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2f6a4e78", + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example consumer with idiosyncratic income shocks\n", + "# Sse init_portfolio parameters to compare to results of PortfolioConsumerType\n", + "IndShockExample = IndShockConsumerType(**init_portfolio)\n", + "IndShockExample.cycles = 0 # Make this type have an infinite horizon\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "59c23ceb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPFRaw = 0.975202 \n", + "GPFNrm = 0.984353 \n", + "GPFAggLivPrb = 0.955698 \n", + "Thorn = APF = 0.984954 \n", + "PermGroFacAdj = 1.000611 \n", + "uInvEpShkuInv = 0.977122 \n", + "VAF = 0.861822 \n", + "WRPF = 0.523140 \n", + "DiscFacGPFNrmMax = 0.973843 \n", + "DiscFacGPFAggLivPrbMax = 1.041223 \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a consumer with idiosyncratic shocks took 1.3176 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "IndShockExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with idiosyncratic shocks took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "IndShockExample.unpack(\"cFunc\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "15eb3021", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the infinite horizon consumer\n", + "print(\"Concave consumption function:\")\n", + "plot_funcs(IndShockExample.cFunc[0], 0.0, 5.0)\n", + "print(\"Marginal consumption function:\")\n", + "plot_funcs_der(IndShockExample.cFunc[0], 0.0, 5.0)\n" + ] + }, + { + "cell_type": "markdown", + "id": "d6648a65", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Risky Return Consumer Type" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d35df1d4", + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example consumer with risky returns to savings\n", + "# Use init_portfolio parameters to compare to results of PortfolioConsumerType\n", + "RiskyReturnExample = RiskyAssetConsumerType(**init_portfolio)\n", + "RiskyReturnExample.cycles = 0 # Make this type have an infinite horizon\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "85425d79", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a consumer with risky returns took 0.6570 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "RiskyReturnExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with risky returns took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "RiskyReturnExample.unpack(\"cFunc\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "778d3aec", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the risky asset consumer\n", + "print(\"Concave consumption function:\")\n", + "plot_funcs(RiskyReturnExample.cFunc[0], 0.0, 5.0)\n", + "print(\"Marginal consumption function:\")\n", + "plot_funcs_der(RiskyReturnExample.cFunc[0], 0.0, 5.0)\n" + ] + }, + { + "cell_type": "markdown", + "id": "ac9441b1", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Compare Idiosyncratic Income Shocks with Risky Return" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "fcce0156", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions for idiosyncratic shocks vs risky returns:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the consumption functions for the various agents in this notebook.\n", + "print(\"Consumption functions for idiosyncratic shocks vs risky returns:\")\n", + "plot_funcs(\n", + " [\n", + " IndShockExample.cFunc[0], # blue\n", + " RiskyReturnExample.cFunc[0], # orange\n", + " ],\n", + " 0.0,\n", + " 20.0,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "05cad628", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Risky Return Consumer Type with Portfolio Choice" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5b9b7475", + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example risky consumer with a portfolio choice\n", + "init_portfolio[\"PortfolioBool\"] = True\n", + "PortfolioChoiceExample = RiskyAssetConsumerType(**init_portfolio)\n", + "PortfolioChoiceExample.cycles = 0 # Make this type have an infinite horizon\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1bbf5743", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a consumer with risky returns and portfolio choice took 1.0100 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "PortfolioChoiceExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with risky returns and portfolio choice took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "PortfolioChoiceExample.unpack(\"cFunc\")\n", + "PortfolioChoiceExample.unpack(\"ShareFunc\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7985f73b", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the portfolio choice consumer\n", + "print(\"Concave consumption function:\")\n", + "plot_funcs(PortfolioChoiceExample.cFunc[0], 0.0, 5.0)\n", + "print(\"Marginal consumption function:\")\n", + "plot_funcs_der(PortfolioChoiceExample.cFunc[0], 0.0, 5.0)\n" + ] + }, + { + "cell_type": "markdown", + "id": "b40d1257", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Compare Income Shocks, Risky Return, and RR w/ Portfolio Choice" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "7867d7d7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions for idiosyncratic shocks vs risky returns vs portfolio choice:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the consumption functions for the various agents in this notebook.\n", + "print(\n", + " \"Consumption functions for idiosyncratic shocks vs risky returns vs portfolio choice:\"\n", + ")\n", + "plot_funcs(\n", + " [\n", + " IndShockExample.cFunc[0], # blue\n", + " RiskyReturnExample.cFunc[0], # orange\n", + " PortfolioChoiceExample.cFunc[0], # green\n", + " ],\n", + " 0.0,\n", + " 20.0,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "e1b7e574", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Portfolio Consumer Type" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5c2b0c00", + "metadata": {}, + "outputs": [], + "source": [ + "# Make and solve an example portfolio choice consumer\n", + "PortfolioTypeExample = PortfolioConsumerType()\n", + "PortfolioTypeExample.cycles = 0 # Make this type have an infinite horizon\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "07e6f360", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a consumer with portfolio choice took 4.4170 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "PortfolioTypeExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with portfolio choice took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "PortfolioTypeExample.unpack(\"cFuncAdj\")\n", + "PortfolioTypeExample.unpack(\"ShareFuncAdj\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f74f4c4f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the portfolio choice consumer\n", + "print(\"Concave consumption function:\")\n", + "plot_funcs(PortfolioTypeExample.cFuncAdj[0], 0.0, 5.0)\n", + "print(\"Marginal consumption function:\")\n", + "plot_funcs_der(PortfolioTypeExample.cFuncAdj[0], 0.0, 5.0)\n" + ] + }, + { + "cell_type": "markdown", + "id": "b6ea3494", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Compare RR w/ Portfolio Choice with Portfolio Choice Type" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "02217a1b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions for portfolio choice type vs risky asset with portfolio choice:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAD4CAYAAAAEhuazAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAhQklEQVR4nO3deXgc9YHm8e9Ph2/jS7LlQ/ct+cCyLMsXOCQQ7BAghMNAuDOGhFwTZnJMNsnsPLPZnZ2d7DCBwJKEASaAzWkg2FzGgI0jyfeh07Is2Tos+ZQtydbVv/1DDaNRJEu2u7v6eD/Po0etququ1z9KL62q6ipjrUVEREJLmNMBRETE91T+IiIhSOUvIhKCVP4iIiFI5S8iEoIinFpxVFSUTUhIcGr1IiIBafv27cestdGX+jqOlX9CQgLbtm1zavUiIgHJGFPjidfRbh8RkRCk8hcRCUEqfxGREKTyFxEJQSp/EZEQpPIXEQlBKn8RkRDk2Hn+IiIydCea6qnc/LLHXk/lLyLipxpqKqj59CXGVr9DRvs+8ozn7r+i8hcR8RPW5aKmfCcNBS8TVfs+qd2VTAUOhsWzNfZ+ouZ/Hf77Eo+sS+UvIuIgV7eL/bs+5sS215h+5AMSbD0JQHlEBgXJ32fGwltJTJlJoofXq/IXEfGxzs4OygvfoWXXWpKObSSdE3TacMpGzKEw+T6SltxK+rQEr2ZQ+YuI+MDZ1hZKP11LV/FbpDVvZiYtnLXDKBuTR03aV0hbeguzJl7yxTqHTOUvIuIlzSePUbHpFcLL3yajpZAc085pRlM+bjER2deTsfhG5o4e60g2lb+IiAcdazjEgU0vMbJqPRlndzLfdHOUCeyNWsHoOTeSnr+c+cOGOx1T5S8icqnqqko4tOUlJtS8Q1pHGVHGUmumsmPaSsbP+zppc5cRHR7udMz/QuUvInKBrMvFgeIijha9wpS690lyVTMdOBCeRFH8Kqbk30JCxjxmhPnvRRRU/iIiQ9Dd3U3Ftg2c2vEacU0fkmIbSbKG8mFZFCQ/QtyiW0lOzCDZ6aBDpPIXERlAR/s5Sv/8Nuf2vEHyiY/J5BQdNpzSkTnUpTxE8tJbyJwS63TMi6LyFxHppfVMM+Wfvk538Vukn97CHNNGmx1O2dh8ajK+StqSm5gzfpLTMS+Zyl9EQt6pY41UbHqZyP1/IrN1Gzmmk5OMpXzCMobNvJ70RV8lZ9QYp2N6lMpfRELSsYZDVG5aw+gDb5N5bjd5xkUjk9g9+QbGXP410vOuYX7kMKdjeo3KX0RCRkNNBdWb1zC+ej3pHSXkG8thM41t07/BpPk3kzJnKVP8+AwdT1L5i0hQO7R/D3Vb1hB16F1Su/e7r5KZQFH8XxGTfyvxGfOIDZHC703lLyJBxbpcHCzZSmPhy5+fgx8HVESkUZD0PWYsupXElFkev0pmoFH5i0jAsy4XFbs2cWLrK8w48gFJtp4Eaygbnk1h4t+SsPg20uJSnY7pV1T+IhKQuru6KN+2gdM7XiWhaQPpHKPLhlE64nIaUu4naeltZMXEOR3Tb6n8RSRgdHa0U1awnrbdr5N8/COyOEWHjaB0VC6H039A2tJbmTVpitMxA4LKX0T82rmzbZR9+iYde9eS1ryJWbT854euMr9K+tKvM+eyiU7HDDgqfxHxO61nminb/Bq25C0yTm/hcnOW04yi4rLFhM+8kcwlN5Azypnr4AcLlb+I+IXmU8ep+ORlwsveIrO1iHmmg5NcRsmkLzJi9tfIWHgducNHOB0zaKj8RcQxJ5rqqdz0EsP3/4nMszuYb7ppYiJ7Jl/PmMu/RsaCL5MXEel0zKCk8hcRn2qqq6Zq02rGVK0js30PecZSbyazY+ptTMj9Oqlzv8BkP7vxSTBS+YuI1x05XMnBT15kfPU6MjtLmAzUhM1ga+y9ROfdQtLMhUwLwU/ZOknlLyJeUV9dTs3m1UyoXkdGVxkxQFV4AgXxDzF14W3EZ+QQ73TIEDZo+RtjYoHngBjABTxlrX20zzIGeBRYAbQB91prd3g+roj4s7qqUg59+iKTataT1lXBNKAyPJmCxIeZvmglSamzSXI6pABDe+ffBTxird1hjBkLbDfGvG+tLem1zHIg1f21AHjC/V1Egtzhyn3Ufvoi0YfWk9J9gOnA/ohUCpK+R9yS20lJyiLF6ZDyFwYtf2ttA9DgfnzGGFMKTAd6l/8NwHPWWgsUGGPGG2Omup8rIkGmpnwX9VtWE137LindVcQC5RHpFKT8NXFLbic1IR1dSce/XdA+f2NMAjAXKOwzazpwuNfPte5p/6X8jTGrgFUAcXG65oZIIKku20HDlheZUvseSa5q4oGyyCwKkh4hcentpOvCaQFlyOVvjBkDvAr8wFp7uu/sfp5i/2KCtU8BTwHk5ub+xXwR8R/W5eJg2TYat6xhav27JLgOE/f5lTJ/ROLS28mYoT34gWpI5W+MiaSn+J+31r7WzyK1QO9b2M8A6i89noj4knW5OFBcSFPBGmbUv0eSrXNfGnkWhcnfIHnpSrKmJTgdUzxgKGf7GOAPQKm19tcDLPYm8B1jzGp6DvQ2a3+/SGCwLheVe7ZwrOglYhveI8U2kGgNZSPmUJRyny6NHKSG8s5/MXAXsNcYs8s97e+AOABr7ZPAOnpO86yk51TP+zyeVEQ85j9vfvIScUfeJ9U2kui+Fn596ipSrriN7MnTnY4pXjSUs3020/8+/d7LWOBhT4USEc9zdbso3/kRp7a+RELjB6RzlE4bTunIHOpTv03qlSuZFRXjdEzxEX3CVySIWZeLip2fcKJoDYmN75HJMTpsOKWjcqlN/z7pS29j9qTJTscUB6j8RYJMzz78TzlWuIa4I++Rbht7Ff5fk7ZsJXPGRzkdUxym8hcJAtbl4sC+QpoKVhPX8C6ptoGEz3bppH+3p/AnRDsdU/yIyl8kQFlrOViylcYtq5le/w4pto6Ez25gnvYgactuZ/Yk7cOX/qn8RQJMddkO6j99kWl160lyHSb+s9MyU+8n9co7mBU9zemIEgBU/iIBoKZiN3WbXyCmdj1Jrhr3J21nUZRyF8lX3kH2lNjBX0SkF5W/iJ86fKCY2k3PE314PSndVcQDpZHZFKX9mKQr7yRrqq6GLxdP5S/iR+qqSqnZ/ALRNetI7a7suVpmZCaFKX9L4tI7yNS1dMRDVP4iDquvqaDmkxeYVP02ad0VTAcqItIoSP0hiUvv0NUyxStU/iIOaKyrouqj55lw8E9kdJX13PEqIoWC5O8Tf8WdpMWnOx1RgpzKX8RHTjTVU/HRC4zdv5bMjn1MMdZ9i8PvErf0Dt3xSnxK5S/iRaebT1C28QWGl60l6+wO8k03NWEzKIpfxfQld5CSdrkKXxyh8hfxsLOtLZR88jJm76tktxaQZzppMNFsn34nkxfdSWJWHvFhYU7HlBCn8hfxgI72cxRvWkvXnlfIat7EPHOOY4xn15QbGZ+3krScq5iqwhc/ovIXuUjdXV2UFqyndfsa0k9uZC4tNDOa4klfYlTObWTmr2BBhH7FxD9pyxS5ANblonz7Rk4VrSb56PvM5CRtdjgl464gcs7NZC65kbzhI5yOKTIolb/IIHrua1tE05bnSTjyDhm2iXYbScmYBRyeeTOZV9xM7uixTscUuSAqf5EBHNq/h9pNf2R67dukuGpJsGGUjJxHXcb3yVh2O3PHT3I6oshFU/mL9NJUV82Bjc8QdfAtUrsrmWENZcNnUpR6L6nL7mS2rpgpQULlLyGv+dRxyj/8I6PKXiOrfTeTjWV/RCoFqT8k6cq7yNL1dCQIqfwlJLWfa6P449ewe9Yws+XP5JlO6kwMhXHfZMYVd5GaOgddUUeCmcpfQoaru5vSwndp2foCmSc/JIdWTnAZuybfwIT8b5A690qm61x8CREqfwlq1lqq9hXRtOU5EhveIZtjn5+aOSxnJVmLr2dB5DCnY4r4nMpfglJDTQUHP3qOqTVvkuyqId6GUTwql9qsH5H1hZXkjhnndEQRR6n8JWg0H2+k7MM/MrbiNbI69zEVKIvMpDD9p6RddTdzdKaOyOdU/hLQzrW1UPzRS4Tte5ns1kIWmG4OhU2nIP4h4q68h4ykLKcjivgllb8EnM8O3LYW/QeZJzcyz5zlGOPZGXMLkxZ+g+TZi4nTgVuR81L5S8A4tH8PdR8/Q3zdW2TbJlrtCEonLGPEvDvIXPgVXURN5ALot0X8WvOJJko/eJbxFa+S0VXKDGsoHjmXhuwfkvWFO8kdc5nTEUUCkspf/E5HezvFm17DtfMFZrVsId90URMWS2Hy90i66n5mTU90OqJIwFP5i1+wLheVez7l+KfPknb0XeZympNcxs4pNzFp8T0kz1qku1+JeJDKXxzVWFdF1YZ/J6Z6LamuQ8TbCPaNXczhubeTtfQmFgwb7nREkaCk8hefa2tppnjDC4woeYnsczuZYixlkVkUZf2c9C/eQ86EaKcjigS9QcvfGPM0cB3QZK2d2c/8ZcAbwEH3pNestf/gwYwSBKzLRUnhu7QWPEv2qY3MN+eoN5Mpir2f2C/cR0byLKcjioSUobzzfwZ4DHjuPMtsstZe55FEElQa66qoev93xNa8TrZtoMWOpGTiFxmz4C4y8q5hWli40xFFQtKg5W+t/cQYk+CDLBIk2s+1sW/jGiJ2P8/Ms9uYYiwlw2azLfu7ZH/xLubr9EwRx3lqn/9CY8xuoB74G2ttcX8LGWNWAasA4uLiPLRq8RcH9hZy9JPfk350PfM4QxMT2Rp7L3Ff+CuykrOdjicivXii/HcA8dbaFmPMCmAt9H8fDGvtU8BTALm5udYD6xaHNZ84Stn7TzOx4iVSuyuJteHsG7uE2ty7yVpyI5P1qVsRv3TJv5nW2tO9Hq8zxvzWGBNlrT12qa8t/qm7u5uSLX/iXNFzzDr9MQtMJ1XhCRSm/4iMq+8nJ2qq0xFFZBCXXP7GmBig0VprjTF5QBhw/JKTid+pry6nesPvSTz8OrM4ymlGs2fy9Uxccj8psxeTZIzTEUVkiIZyqueLwDIgyhhTC/wSiASw1j4J3Ax8yxjTBZwFVlprtUsnSHR2tLN348uE73yGWWe3EQM919aZ9WOyrrqDvJGjnY4oIhdhKGf73D7I/MfoORVUgkh9dTk17z9BSt1acjhJExMpir2fhKsfZFZ8utPxROQS6WicfK6zo529H64hYtezzDy7nRhg76g86ufdS/aVNzNZ97oVCRoqf6GuqpSaD54krX4tOZzqeZcf900Sr3mQObH9nrglIgFO5R+iOtrb2bfxRSJ2Psfs9u3EWMPe0fnud/lfZ3JEpNMRRcSLVP4hpq6qjEPvP05qw5vkcIojRFEQ9yBJ1zzE5TOSnI4nIj6i8g8B3d3d7Pv4FezWPzC7rahnX/7ohdTn3kv2FV8nRh/EEgk5+q0PYiePHaFs/W+Jr1rNHNvIccZTFHs/Sdd+R+/yRUKcyj/IWGup2PERzZ88yZxTG1hoOikZNosjl/+YWV+6k/xhI5yOKCJ+QOUfJM62trD33T8wvvg/SO/eT6sdwe7o65h81cNkZc13Op6I+BmVf4A7XLmP2vcfI6vxTfJopToslsKsvyP72r8i77KJTscTET+l8g9A1uVi76Y3cBU84T6AG8aesUsZuehBMvOvJUE3OheRQaj8A0hb62n2vP0UMWXPMNt1mOOMoyjuAVKWf5d50xKcjiciAUTlHwAaaiqofudRshpeJ59WKsOT2Tb3V8z68n3kjxjldDwRCUAqfz/Vc8Pz9zi3+XHmtGxmMpbdY69g1NKHSZ9/NUa7dkTkEqj8/Ux7+1l2r/8DE/Y+TXb3AZoZzbZpd5K4/PvkxOk6OyLiGSp/P9F84hjFb/0rKQefJ48TVIfFUjTz58y6dhX5uuG5iHiYyt9h9dXl1Kz7F2Y3vsEic459w+fSuOj/MHPp13TWjoh4jcrfIZW7N3Pqg19z+emNRGPYPe4qJl79CDNnLXQ6moiEAJW/D1mXiz0fv0r4nx9jZscuWuxItk9dScJ1j5A7I8XpeCISQlT+PtDZ0c6udb8nes+TzHEdoomJFCb/gKyvfo8F4yc5HU9EQpDK34vOnW1j11u/Ja70/zHfNnEwLJ5tc3/FnOUPMFkXWBMRB6n8vaCtpZk9bzxK0v5/J58TVESksXvhPzD7C7eRqIO4IuIHVP4e1HzqOCWv/zMZNX8knzMUD5vN0aX/Stbir+pDWSLiV1T+HnDy2BFKX/9fzKxdw0LTxp6ReTRd9WOy53/J6WgiIv1S+V+C5lPHKXnlV8w6/Dz5nGP32KWMu+YnzJ692OloIiLnpfK/CC1nTrH3lX8iq+ZZFtLKzjFLmfiVXzJXN00RkQCh8r8Aba2n2fXar8k88HsWcobdI/MZs/wXzNU7fREJMCr/Iejq7GTbG4+TtO9RFnGCfSNyOHb1z5kz7yqno4mIXBSV/3lYl4vdH73CuM3/SL6rhvLIDE588bfMzF/udDQRkUui8h/A/t1bOPf2T7m8Yxd1Joad+Y9y+TV365RNEQkKKv8+Th1rpOzFH5F37A1Om9EUZfyIuTc9wnR9IldEgojK383V3c3WtY+RuvefmW9b2DrlFjLv+J/kjY9yOpqIiMep/IGq4iI6Xv8eC7pKKYvMovmG/8uCmflOxxIR8ZqQLv/Ozg62/vGX5FY/RasZxfa5/0jOV7+NCQt3OpqIiFcNWv7GmKeB64Ama+3MfuYb4FFgBdAG3Gut3eHpoJ5WVbKNrlcfYlH3fnZetozEu59gXvQ0p2OJiPjEUE5deQa49jzzlwOp7q9VwBOXHst7rMtFwcu/Ztqaa4nubmRn/r8y95E3GK/iF5EQMug7f2vtJ8aYhPMscgPwnLXWAgXGmPHGmKnW2gZPhfSUM6dPUva7B8g/s4HiEXOJuf855k6JczqWiIjPeWKf/3TgcK+fa93T/qL8jTGr6PnrgLg435Zufc1+zj57Cznd1RQmfov53/hHwiJC+pCHiIQwT7Sf6Wea7W9Ba+1TwFMAubm5/S7jDWXbPyLqrXsYSzulVz3Ngitv8tWqRUT8kifKvxaI7fXzDKDeA6/rEbs/eYO0Dd/kVNh42m57jZkZ85yOJCLiOE9cq+BN4G7TIx9o9pf9/bs2vkr6hgc4EjGN4Q99SJyKX0QEGNqpni8Cy4AoY0wt8EsgEsBa+ySwjp7TPCvpOdXzPm+FvRC7P3mDzI8epC5iBpO+tZ5xUVOdjiQi4jeGcrbP7YPMt8DDHkvkAZV7C0je8CD14dOI+va7XDZpitORRET8StBdovJIbRVjX72DNjOSMQ+sVfGLiPQjqMq/o72dk8/ewRjbStvNq4menuR0JBERvxRU5b/t6R+Q2VlKxYJfkTBzgdNxRET8VtCU/84PVrOo8QWKom5i7ooHnI4jIuLXgqL8Tx1vYsbmn3AwPIE533zM6TgiIn4vKMq//LnvMsE247rhcYaPGO10HBERvxfw5b/v07dZ0PwO22fcTfLsJU7HEREJCAFd/l2dnYzc8DOOmGjm3Pk/nI4jIhIwArr8t679N5JdB2mY/1NGjBrjdBwRkYARsOV/trWFlOLfUBaZxeXX+sUVJUREAkbAlv/ON39DNCfhqv+GCQvYf4aIiCMCsjXPnTtLcvnvKBuWTUb+CqfjiIgEnIAs/z3vPcsUjtO16Idg+ruXjIiInE9Alv/Yvc9Sa6aSfcXXnI4iIhKQAq78K/f8mczOEupS7sCEhTsdR0QkIAVc+R//6LectcPIWPEtp6OIiASsgCr/s61nyD7+PsUTrmLchGin44iIBKyAKv99G9cwxpxlVN5dTkcREQloAVX+kcUv0cgkMhYsdzqKiEhAC5jyP9ZYx8y2rRycuoKwcB3oFRG5FAFT/pUfPkuEcTF16T1ORxERCXgBU/4TDrxOVXgi8VnznY4iIhLwAqL8D+3fS3pXBUcTb3Q6iohIUAiI8q/bshqAhCvvdDiJiEhwCIjyn3ToXSoi0pgSm+p0FBGRoOD35V9fXU5a935OxF3rdBQRkaDh9+V/aHPPLp+4Jbc7nEREJHj4ffmPr1nPgfBEpiVlOR1FRCRo+HX5N9VVk9FZytEZX3Y6iohIUPHr8q/a1LPLZ+rC2xxOIiISXPy6/MdWvU1NWCzxGTlORxERCSp+W/4nmurIaN9L/bSrnY4iIhJ0/Lb8Kze9RLixTM67xekoIiJBZ0jlb4y51hhTboypNMb8pJ/5y4wxzcaYXe6vX1xqMHPozxxjPEkz8y/1pUREpI+IwRYwxoQDjwNXA7XAVmPMm9bakj6LbrLWXuepYNFnSqgbmU5UmN/+cSIiErCG0qx5QKW1tspa2wGsBm7wZqjWM6eI7a7lbNQsb65GRCRkDaX8pwOHe/1c657W10JjzG5jzHpjTHZ/L2SMWWWM2WaM2Xb06NEBV3iopJBwYxkRnzuEeCIicqGGUv6mn2m2z887gHhr7RzgN8Da/l7IWvuUtTbXWpsbHT3wDdibD2wFYHrWwiHEExGRCzWU8q8FYnv9PAOo772Atfa0tbbF/XgdEGmMibrYUBFHdnGUCURPS7jYlxARkfMYSvlvBVKNMYnGmGHASuDN3gsYY2KMMcb9OM/9uscvNlR0Sxn1I9Mv9ukiIjKIQc/2sdZ2GWO+A7wLhANPW2uLjTEPuec/CdwMfMsY0wWcBVZaa/vuGhqSltMnie2upT56+cU8XUREhmDQ8ofPd+Ws6zPtyV6PHwMe80SgQyWFZBnLqIR5nng5ERHph9+dRH/6QBEA07MWOZxERCR4+V35RzTupomJRMXEOR1FRCRo+V35T24ppW5UhtMxRESCml+V/5nmE8S56jgXPdvpKCIiQc2vyv9QcQEAo+J1sFdExJv8qvzPVH12sFef7BUR8Sa/Kv+Ixj00MomomNjBFxYRkYvmV+U/paWUeh3sFRHxOr8p/9OnjhNr6zkXrcs4i4h4m9+U/6HiLQCMTpjvcBIRkeDnN+XfcnAbADOydbBXRMTb/Kb8Ixt3c4RoJk7u7z4xIiLiSX5T/lNaymgYrcs4i4j4gl+Uf/PJY8ywDbRHz3E6iohISPCL8j/sPtiryziLiPiGX5R/S1XPPXtjs3UZZxERX/CL8o9s2kMD0UyInup0FBGRkOAX5R/TWkrD6EynY4iIhAzHy7/5xFGm20baJ+uTvSIivuJ4+R/a13Owd0yiPtkrIuIrjpd/S3XPJ3vj9MleERGfcbz8hzftot5MYdykGKejiIiEDMfLP6a1nCOjdRlnERFfcrT8Tx07wjTbSPtkfbJXRMSXHC3/wyV/BmBsYq6TMUREQo6j5d9yUJ/sFRFxgqPlP7xpL7UmhnETo52MISISchwt/6mtpTTqYK+IiM85Vv7dXZ1M5SidU3SwV0TE1xwr/46zLQCM0cFeERGfc6z8XR1tgA72iog4wbHyN51t1JqpjJsQ5VQEEZGQ5Vj5R7raaRyjyziLiDhhSOVvjLnWGFNujKk0xvykn/nGGPNv7vl7jDE5g71mJJ10Tpl9MZlFROQSDVr+xphw4HFgOZAF3G6Myeqz2HIg1f21CnhiKCsfm5h3QWFFRMQzhvLOPw+otNZWWWs7gNXADX2WuQF4zvYoAMYbYwa9J2Nsdv4FBxYRkUs3lPKfDhzu9XOte9qFLoMxZpUxZpsxZtsZxnDZ+EkXmldERDxgKOVv+plmL2IZrLVPWWtzrbW5Y6elDiWfiIh4wVDKvxaI7fXzDKD+IpYRERE/MZTy3wqkGmMSjTHDgJXAm32WeRO4233WTz7QbK1t8HBWERHxkIjBFrDWdhljvgO8C4QDT1tri40xD7nnPwmsA1YAlUAbcJ/3IouIyKUatPwBrLXr6Cn43tOe7PXYAg97NpqIiHiL4/fwFRER31P5i4iEIJW/iEgIUvmLiIQg03Os1oEVG3MGKHdk5RcmCjjmdIghUE7PCoScgZARlNPT0q21Yy/1RYZ0to+XlFtr/f42XsaYbcrpOcrpOYGQEZTT04wx2zzxOtrtIyISglT+IiIhyMnyf8rBdV8I5fQs5fScQMgIyulpHsnp2AFfERFxjnb7iIiEIJW/iEgI8nr5e+Pm717IGGuM2WiMKTXGFBtjvt/PMsuMMc3GmF3ur1/4Oqc7R7UxZq87w1+c8uUn45nea5x2GWNOG2N+0GcZR8bTGPO0MabJGLOv17SJxpj3jTH73d8nDPDc827LXs74z8aYMvd/09eNMeMHeO55tw8f5Px7Y0xdr/+uKwZ4rk/G8jw51/TKWG2M2TXAc305nv32kNe2T2ut177ouQT0ASAJGAbsBrL6LLMCWE/P3cDygUJvZhog51Qgx/14LFDRT85lwJ98na2frNVA1HnmOz6e/WwDR4B4fxhP4AogB9jXa9r/Bn7ifvwT4J8G+Hecd1v2csZrgAj343/qL+NQtg8f5Px74G+GsE34ZCwHytln/r8Av/CD8ey3h7y1fXr7nb/Xbv7uSdbaBmvtDvfjM0Ap/dyDOEA4Pp59fBE4YK2tcTDD56y1nwAn+ky+AXjW/fhZ4MZ+njqUbdlrGa2171lru9w/FtBztzxHDTCWQ+GzsYTz5zTGGOBW4EVvrX+oztNDXtk+vV3+Hrv5u68YYxKAuUBhP7MXGmN2G2PWG2OyfZvscxZ4zxiz3Rizqp/5fjWe9Nz5baBfLH8YT4Ap1n3nOff3yf0s40/jej89f931Z7Dtwxe+49499fQAuyj8aSyXAo3W2v0DzHdkPPv0kFe2T2+Xv8du/u4LxpgxwKvAD6y1p/vM3kHPros5wG+AtT6O95nF1tocYDnwsDHmij7z/Wk8hwHXAy/3M9tfxnOo/GJcjTE/A7qA5wdYZLDtw9ueAJKBy4EGenap9OUXY+l2O+d/1+/z8RykhwZ8Wj/Tzjum3i7/gLn5uzEmkp4Bf95a+1rf+dba09baFvfjdUCkMSbKxzGx1ta7vzcBr9Pz515vfjGebsuBHdbaxr4z/GU83Ro/2zXm/t7UzzKOj6sx5h7gOuBO697R29cQtg+vstY2Wmu7rbUu4HcDrN/xsQQwxkQANwFrBlrG1+M5QA95Zfv0dvkHxM3f3fv9/gCUWmt/PcAyMe7lMMbk0TN2x32XEowxo40xYz97TM9BwH19FnN8PHsZ8F2VP4xnL28C97gf3wO80c8yQ9mWvcYYcy3wY+B6a23bAMsMZfvwqj7Hl742wPodHctevgSUWWtr+5vp6/E8Tw95Z/v0wRHsFfQctT4A/Mw97SHgIfdjAzzunr8XyPV2pn4yLqHnT6Q9wC7314o+Ob8DFNNzFL0AWORAziT3+ne7s/jleLpzjKKnzMf1mub4eNLzP6MGoJOed0sPAJOADcB+9/eJ7mWnAevOty37MGMlPft0P9s+n+ybcaDtw8c5/8O93e2hp3ymOjmWA+V0T3/ms+2x17JOjudAPeSV7VOXdxARCUH6hK+ISAhS+YuIhCCVv4hICFL5i4iEIJW/iEgIUvmLiIQglb+ISAj6/4Z25Jby7KJSAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the consumption functions for the various portfolio choice types.\n", + "print(\n", + " \"Consumption functions for portfolio choice type vs risky asset with portfolio choice:\"\n", + ")\n", + "plot_funcs(\n", + " [\n", + " PortfolioTypeExample.cFuncAdj[0], # blue\n", + " PortfolioChoiceExample.cFunc[0], # orange\n", + " ],\n", + " 0.0,\n", + " 20.0,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1aac4980", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Share functions for portfolio choice type vs risky asset with portfolio choice:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the share functions for the various portfolio choice types.\n", + "print(\"Share functions for portfolio choice type vs risky asset with portfolio choice:\")\n", + "plot_funcs(\n", + " [\n", + " PortfolioTypeExample.ShareFuncAdj[0], # blue\n", + " PortfolioChoiceExample.ShareFunc[0], # orange\n", + " ],\n", + " 0,\n", + " 200,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a74b71db", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Risky Return Given Fixed Portfolio Share" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "125b700a", + "metadata": {}, + "outputs": [], + "source": [ + "FixedShareExample = FixedPortfolioShareRiskyAssetConsumerType(\n", + " **init_portfolio\n", + ")\n", + "FixedShareExample.cycles = 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "05b2d26f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a consumer with fixed portfolio share took 5.0140 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "FixedShareExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with fixed portfolio share took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "FixedShareExample.unpack(\"cFunc\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "79b9e1ee", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the infinite horizon consumer\n", + "print(\"Concave consumption function:\")\n", + "plot_funcs(FixedShareExample.cFunc[0], 0.0, 5.0)\n", + "print(\"Marginal consumption function:\")\n", + "plot_funcs_der(FixedShareExample.cFunc[0], 0.0, 5.0)\n" + ] + }, + { + "cell_type": "markdown", + "id": "bb9d556f", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Compare Idiosyncratic Shock Type with Fixed Share at 0.0 Type" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "aebd5429", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions for idiosyncratic shocks vs fixed share at 0.0:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the consumption functions for the various idiosyncratic shocks\n", + "print(\"Consumption functions for idiosyncratic shocks vs fixed share at 0.0:\")\n", + "plot_funcs(\n", + " [\n", + " IndShockExample.cFunc[0], # blue\n", + " FixedShareExample.cFunc[0], # orange\n", + " ],\n", + " 0.0,\n", + " 20.0,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "67ea856c", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Fixed Share at 1.0 Type" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e6d724f5", + "metadata": {}, + "outputs": [], + "source": [ + "init_portfolio[\"RiskyShareFixed\"] = [1.0]\n", + "RiskyFixedExample = FixedPortfolioShareRiskyAssetConsumerType(\n", + " **init_portfolio\n", + ")\n", + "RiskyFixedExample.cycles = 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "bd5c721a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solving a consumer with share fixed at 1.0 took 4.1725 seconds.\n" + ] + } + ], + "source": [ + "start_time = time()\n", + "RiskyFixedExample.solve()\n", + "end_time = time()\n", + "print(\n", + " \"Solving a consumer with share fixed at 1.0 took \"\n", + " + mystr(end_time - start_time)\n", + " + \" seconds.\"\n", + ")\n", + "RiskyFixedExample.unpack(\"cFunc\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d8db09af", + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concave consumption function:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAgnElEQVR4nO3deXTU533v8fdXEmLVBkgI7QKEMfsiduPYabzFjh3HTWJiOzGxjZ3GTXrb2ya9t0na2+3kpk3bNIm5gInjxDFZ6ps4DontpF7AMWbfxGYhARICJKFdoG3m6R8zgIplNMBIv1k+r3N00Oj3Y+Zz5uCPfn7meX6POecQEZHYkuB1ABERCT+Vu4hIDFK5i4jEIJW7iEgMUrmLiMSgJK9eeOzYsa6oqMirlxcRiUrbt2+vd85l9neeZ+VeVFTEtm3bvHp5EZGoZGbHQjlPwzIiIjFI5S4iEoNU7iIiMUjlLiISg1TuIiIxSOUuIhKDVO4iIjHIs3nuIiISmtaObg6cbGV/TXPIf0flLiISQWpbOyiraWF/8KusppmjZ85e8fOo3EVEPOD3O443nKUsWOBlNS3sP9lCXWvnhXMKRo9gWk4q983NY1puKtNy0sj+emjPr3IXERlg3T4/5bVt7DvRfKHMD5xspa2zB4CkBGNS1ihuLMlkak4q03JSmZqTSuqwIVf9mip3EZEw6uj2cehUK2U1LeyraabsRDMHTrXS1eMHYERyItePT+Vjc3OZOj5wNV4ybhTDhiSGNYfKXUTkKrV39nDgZAv7TjSzrybwZ3ltGz3+wN7UqcOSmJ6bxsNLipiWEyjy4rEjSUywAc+mchcRCUHz2W7KaprZV9PMvhOBq/LK+nZcoMcZOyqZaTlp/MH1WUzPSWN6bhp5GcMxG/gi74vKXUTkEnWtnReGVM4Pr1Q1nLtwPCdtGNNy07hnVi7Tc1OZnptGVspQz4q8Lyp3EYlbzjlqmjsoCw6rBP5s5nTLxRkrRWNGMDMvnU8tKAwOraQyZtRQD1OHRuUuInHBOcexM2cvDKuU1TSz70QzjWe7AUgwmJg5iiUTxzItJ3A1fq0zVrykcheRmOOco6rhHHtONLH3RDN7qwNF3tIRmHo4JNGYPC6FW6dmMz03lWm5aVyfncrw5PDOWPGSyl1EoppzjurGc+w90cyeYInvPdFM87nAFfmQRGNKdip3zcphRm4a03PSmJw9iqFJsVPkfVG5i0jUcM5xoukce6sDBX7+q+nsxSK/LjuFD8/IZkZuOjNy46PI+6JyF5GIdP7DzkCRN7H3RAt7q5sujJEnJQSK/PZp2UzPTWNmXhrXZafEZZH3ReUuIp5zznGyuYO9JwLDKueHV860dwGQmNBrjDwvjZm5gSIP96rOWKJyF5FBV9vawZ6qZvZUN10YWqlvu1jkJVmj+OCULGbmBRYDXT8+VUV+hfotdzNbB9wF1Drnpvdx/AHgS8GHbcDnnHO7w5pSRKJWS0c3+6qb2V3dzO6qJvZUN1HT3AEEph+WZKVw03VZzMhNY0ZeGlNV5GERypX7M8C3gWff53gl8AHnXKOZ3QGsBhaGJ56IRJOObh8HTrYES7yZ3dVNHKlrv3C8cMwI5hWN5rN5aczKT2daTiojkjWAMBD6fVedc2+aWdFljv++18PNQF4YcolIhPP5He/WtrKnKlDiu6ubOHSqlW5f4GYrmSlDmZWXzkdn5zIzP52ZuWlkjEz2OHX8CPevzEeAX7/fQTNbCawEKCgoCPNLi8hAOb8oaHd1YFhld1Vgmf7ZLh8AKUOTmJmfxqPLJjAreFWenTosou61Em/CVu5mdjOBcr/h/c5xzq0mMGxDaWmpC9dri0h41bV2Bku8id3VgQ8+z09BTE5KYFpOKp8ozWdmsMiLx4wkYRBuYyuhC0u5m9lMYC1wh3PuTDieU0QGR0e3j30nmtlV1cTOqiZ2HW/iRFPgDogJBpPHpXDL1HHMyk9nVl46k8elkJyU4HFq6c81l7uZFQAvAA855w5feyQRGSjOOSrr29lV1RQo8+NNHDjZcmFzidz04cwuSOfhJUUXPvAcOVQfeEajUKZCPg/cBIw1s2rga8AQAOfcKuCrwBjgu8HxtR7nXOlABRaR0DWd7bpQ4ruqAh96nl+qPzI5kZl56Tx24wTm5KczuyCdrJRhHieWcAlltszyfo4/CjwatkQiclW6fX4OnmxlZ1Uju4JlXlEfmIZoBpOzUrhtajZzCgJFXpKVMijbvYk39P9bIlHqdEsH2481suNYI7uqAis9O4ObMI8dNZQ5BencNy+POfnpzMhLIyVK70suV0flLhIFzl+Vbz/WwI7jTWw/1njhQ8/kpARm5Kbx4KLCwFV5fjq56d7t3SmRQeUuEoEa27vYWdXI9mOBr91VzZzrDswpz04dxrzCDD57QzHzCjOYOj5Vs1fkPVTuIh7z+x1H6touFPn2441UBJfsJyYY03JS+eT8fOYVZjCvMIOc9OEeJ5ZooHIXGWRtnT3srmq6UOY7jzde2P4tY8QQ5hVm8Ifz8phbkMHMvDTde0Wuiv7ViAyw2pYOthxtYGtlA1uPNnLwVAt+d3EGy50zc5hbkM68wgyKx47UWLmEhcpdJIzOLxLaerSBLZWNbD3awPGGswAMH5LI3MJ0nvxgCfMKM5idn07acM1gkYGhche5Bj0+PwdOtl64Mt92rOHCphOjRyZTWpjBpxcXMr9oNFNzUhmSqA8+ZXCo3EWuQEe3j11VTWytbGDL0QZ2HGukPXhnxLyM4dxYksn84tHML8pgYuYoDbGIZ1TuIpfR0e1jx7FGNlec4e2KM+yqaqLb5zCD68alcO/cXOYXjWZB8WjGp2kWi0QOlbtILx3dPnYcb2RzRQObK86w63gTXT4/CQYz8tL57NJiFhSPprRwNGkjNF4ukUvlLnHt/DDL20fOsLniDDurmujqCZT59Nw0Hl5axOIJYygtytDyfYkqKneJK109fnYGr8zfrqhnx/FAmZvB9Jw0PrO4kEUTxjC/eDSpKnOJYip3iWnOOd6tbWPju/VsfLeOdyoaONftwwymjk/loUWFLA6WuaYlSixRuUvMqW3t4K3yeja+W89b5fWcbukEYMLYkXy8NI+lk8ayqHiMxswlpqncJeqd6/Kx5WgDGw/Xsam8noOnWoHAUv4lk8aybNJYbigZS17GCI+TigwelbtEHeccB0628vrhWja9W8+2o410+fwkJyZQWpTBX9x+HcsmZTItJ1WbNkvcUrlLVGjv7GFTeT2vH6rltYN1nGrpAGBKdgqfXlzIssmZLCgazfDkRI+TikQGlbtErMr6dv7zYC2vHaxlS2UDXT4/o4YmsaxkLDdPyeKmyZlkpWrPT5G+qNwlYvj8ju3HGnml7BS/PXCao2cCN9yalDWKzywp5OYpWZQWjtbGFCIhULmLpzq6fWx6t55X9p/idwdqOdPeRXJiAosnjmHF0mJuvi6LgjH6IFTkSvVb7ma2DrgLqHXOTe/juAH/BnwYOAs87JzbEe6gEjuaz3bzu4OneaXsNG8cruNct4+UoUncPCWLW6eN4wOTM7UaVOQahXLl/gzwbeDZ9zl+B1AS/FoIPBX8U+SClo5uXi07zUt7athUXk+3zzEudSj3zcvl1qnZLJowRsMtImHUb7k75940s6LLnHIP8KxzzgGbzSzdzMY7506GK6REp/bOHn574DQv7TnJG4fr6Orxk5s+nBVLi7ljejaz8tI1VVFkgIRjzD0XqOr1uDr4s/eUu5mtBFYCFBQUhOGlJdJ0dPt47WAtL+05ye8Onqaj28+41KE8sLCAu2bmMCdfhS4yGMJR7n39l+r6OtE5txpYDVBaWtrnORJ9nHPsqW7mZ9ureXF3Dc3nuhkzMpmPz8vnrpnjmV80WoUuMsjCUe7VQH6vx3lATRieVyJcbWsHP995gp9tr+bw6TaGJiVw27Rs7puXx9KJY0jSlnIinglHub8IPGlm6wl8kNqs8fbY1ePz89sDp/nJtmreOFyHz++YW5DOP9w7gztnjtedFUUiRChTIZ8HbgLGmlk18DVgCIBzbhWwgcA0yHICUyFXDFRY8U5tawfrt1Txo3eOc6qlg+zUYTx+4wTum5fHxMxRXscTkUuEMltmeT/HHfD5sCWSiOFcYMXos28f49f7TtLtc9w4OZO/++h0bp6SRaLG0UUillaoynt0dPv4+c4TfP/tYxw42ULKsCQeWlTEg4sKmKCrdJGooHKXC1o6uvnh5mOs23SU+rZOpmSn8A/3zuCjc3IYkax/KiLRRP/FCvVtnXzvrUqeffsYrR09LCsZy+dums3iCWMI3F1CRKKNyj2OVTeeZc2bFazfWkWXz88d07P53AcmMSMvzetoInKNVO5x6GTzOb71u3J+ui2wsPjeObk8cdNEzXoRiSEq9zhypq2T775+hB9sPoZzjgcWFvD4ByaSkz7c62giEmYq9zjQ0e1j7cYKnnr9COe6fdw3N48v/EEJ+aN1n3SRWKVyj2HOOX619yT/uOEgJ5rOcdu0cfz5bVOYlKXhF5FYp3KPUXurm/k/L5Wx9Wgj149P5Z8+PovFE8d4HUtEBonKPcbUtnbwjd8c4mc7qhk9Ipl//NgMPlGar9WkInFG5R4j/H7Hc1uO839/fZCOHh8rl03g8x+cRKq2qxOJSyr3GHDoVCt/+cIedhxvYsnEMfz9vTMoHjvS61gi4iGVexTr6vHz7dfK+e5r5aQMS+KfPz6Lj83N1apSEVG5R6v9NS38z5/uZv/JFu6dk8tX7prK6JHJXscSkQihco8yPT4/T71+hG/957ukDR/C6ofmceu0bK9jiUiEUblHkaqGs3xx/U52HG/iI7Ny+Ju7p+lqXUT6pHKPEr/cXcP/emEvAN9aPoe7Z+V4nEhEIpnKPcKd7erhr18s4yfbqplTkM637p+j2waISL9U7hHsaH07j/9gO4drW3ny5kl88UMlDElM8DqWiEQBlXuEeu1QLV98ficJCcb3VyzgxsmZXkcSkSiico8wzjm+81o5//zqYaZkp7L6oXkahhGRKxbS/+Ob2e1mdsjMys3sy30cTzOzX5rZbjMrM7MV4Y8a+zp7fHxh/S7+6ZXD3DMrhxc+t0TFLiJXpd8rdzNLBL4D3AJUA1vN7EXn3P5ep30e2O+c+4iZZQKHzOw551zXgKSOQc3nunn8B9vYXNHAl26fwhMfmKCVpiJy1UIZllkAlDvnKgDMbD1wD9C73B2QYoE2GgU0AD1hzhqzaprOseJ7W6mob+Pf7p/NPbNzvY4kIlEulHLPBap6Pa4GFl5yzreBF4EaIAX4pHPOf+kTmdlKYCVAQUHB1eSNOUfq2nhgzTu0d/bwzIoFLJ001utIIhIDQhlz72tswF3y+DZgF5ADzAa+bWap7/lLzq12zpU650ozMzX7o7y2jftXb6bH7+fHjy9WsYtI2IRS7tVAfq/HeQSu0HtbAbzgAsqBSmBKeCLGpvLaVpav2Yxz8Pxji5ia857fhSIiVy2Uct8KlJhZsZklA/cTGILp7TjwBwBmNg64DqgIZ9BY8u7pVu5f/Q7OwfqVCykZl+J1JBGJMf2OuTvneszsSeBlIBFY55wrM7MngsdXAX8LPGNmewkM43zJOVc/gLmjVkVdG8vXvINZ4Ipdm1WLyEAIaRGTc24DsOGSn63q9X0NcGt4o8We0y0dPPT0FpxzrF+5WMUuIgNGNyoZJM3nuvnMui00ne3imRULVOwiMqB0+4FB0NHt47Hvb+NIXRvfe3gBM/LSvI4kIjFO5T7AfH7HF57fydZjDfz78jncUKLpjiIy8DQsM8D+ccMBXtl/mq/eNZW7ZmqDDREZHCr3AfTcO8dYu6mSh5cUsWJpsddxRCSOqNwHyMZ36/jqL8q46bpM/urO672OIyJxRuU+AMprW/mj53YwKXMU/758DknaPUlEBplaJ8yaz3bz6Pe3MTQpkacfLiVl2BCvI4lIHFK5h5HP7/jC+p2caDrHqgfnkpehjTZExBuaChlG//TKId44XMff3zud0qLRXscRkTimK/cweWlPDU+9foTlCwp4YGGh13FEJM6p3MPgwMkW/vyne5hXmMFf3z3V6zgiIir3a9V8tpvHf7Cd1OFJPPXAXIYmJXodSUREY+7Xwu93/NlPd1HTdI4fP76YrNRhXkcSEQF05X5N/t+bFfz2QC3/+87rmVeY4XUcEZELVO5X6e0jZ/jGywe5c+Z4Hl5S5HUcEZH/RuV+FWpbOvjj53dSNHYkX79vJmZ97SEuIuIdjblfoR6fnyef30l7Zw8/emwho4bqLRSRyKNmukLffPUwWyob+JdPzmKyNrYWkQilYZkr8ObhOp564wj3z8/n3jl5XscREXlfKvcQ1bZ28Kc/2UVJ1ii+9pFpXscREbmskMrdzG43s0NmVm5mX36fc24ys11mVmZmb4Q3prd8fsf/+PEu2jp7+Pan5jI8WQuVRCSy9TvmbmaJwHeAW4BqYKuZveic29/rnHTgu8DtzrnjZpY1QHk98dTr5bxVfoav3zdD4+wiEhVCuXJfAJQ75yqcc13AeuCeS875FPCCc+44gHOuNrwxvbP1aAPffPUwd8/K4ROl+V7HEREJSSjlngtU9XpcHfxZb5OBDDN73cy2m9mn+3oiM1tpZtvMbFtdXd3VJR5Ezee6+eLzO8kfPYK/v3e65rOLSNQIpdz7ajR3yeMkYB5wJ3Ab8BUzm/yev+TcaudcqXOuNDMz84rDDrav/Hwfp1s7+bf752hHJRGJKqHMc68Geo9H5AE1fZxT75xrB9rN7E1gFnA4LCk98POdJ3hxdw1/dstkZuenex1HROSKhHLlvhUoMbNiM0sG7gdevOScXwDLzCzJzEYAC4ED4Y06eKoazvKVn++jtDCDP7p5ktdxRESuWL9X7s65HjN7EngZSATWOefKzOyJ4PFVzrkDZvYbYA/gB9Y65/YNZPCB4vM7/uwnu3HAv3xyNokJGmcXkegT0u0HnHMbgA2X/GzVJY+/AXwjfNG8seqNI2w52sA3PzGL/NHa4FpEopNWqPayu6qJf3n1MB+ZlcO9cy6dECQiEj1U7kHtnT38yY93kZUylL/7qKY9ikh0010hg/7uV/s5eqad5x9bRNpwTXsUkeimK3fg5bJTPL+lisdvnMiiCWO8jiMics3ivtzbOnv4yxf2Mj03lT+95T3rrkREolLcD8v8eGsVDe1dPP2ZUpKT4v53nYjEiLhusx6fn3WbKplflMGcggyv44iIhE1cl/vLZac50XSOR26Y4HUUEZGwittyd86xZmMFhWNGcMvUcV7HEREJq7gt9+3HGtlV1cQjNxTrFgMiEnPittzXbKwgbfgQ/nCeNroWkdgTl+V+tL6dV/af5sFFBYxIjvsJQyISg+Ky3Ne9VcmQhAQ+s7jI6ygiIgMi7sq96WwXP91Wzd2zc8hKHeZ1HBGRARF35f7cO8c51+3j0WXFXkcRERkwcVXunT0+nvn9UZaVjGVKdqrXcUREBkxclfsvd5+krrWTR5dp0ZKIxLa4KXfnHGs3VnDduBRuLBnrdRwRkQEVN+W+qbyeg6daeWRZsTbiEJGYFzflvmZjJZkpQ7lndo7XUUREBlxclPuhU628ebiOzywuZGhSotdxREQGXEjlbma3m9khMys3sy9f5rz5ZuYzsz8MX8Rrt3ZjBcOGJPDAwkKvo4iIDIp+y93MEoHvAHcAU4HlZjb1fc77OvByuENei9rWDn6xq4aPz8snY2Sy13FERAZFKFfuC4By51yFc64LWA/c08d5fwz8B1AbxnzX7AdvH6Pb7+ezN2jRkojEj1DKPReo6vW4OvizC8wsF7gXWHW5JzKzlWa2zcy21dXVXWnWK3auy8cPNx/jQ9ePo3jsyAF/PRGRSBFKufc1b9Bd8vhfgS8553yXeyLn3GrnXKlzrjQzMzPEiFfvZzuqaTzbzWNatCQicSaU+91WA/m9HucBNZecUwqsD84fHwt82Mx6nHM/D0fIq+H3O9ZtqmRWXhrzi7Q/qojEl1DKfStQYmbFwAngfuBTvU9wzl0Y0DazZ4CXvCx2gN8eOE1lfTv/vnyOFi2JSNzpt9ydcz1m9iSBWTCJwDrnXJmZPRE8ftlxdq+s3VhJbvpw7pie7XUUEZFBF9I2RM65DcCGS37WZ6k75x6+9ljXZndVE1uONvBXd15PUmJcrNMSEflvYrL51mysIGVoEp+cn9//ySIiMSjmyr268Sy/3neK5QsLSBk2xOs4IiKeiLlyf+atowA8vKTI0xwiIl6KqXJv6ehm/dYq7pwxnpz04V7HERHxTEyV+4+3VNHW2aNFSyIS92Km3Lt9fr73ViULi0czIy/N6zgiIp6KmXLfsPckNc0dumoXESFGyj2wP2olEzJH8sEpWV7HERHxXEyU+zuVDew90cwjNxSTkKBbDYiIxES5r91YweiRydw3N8/rKCIiESHqy72iro3fHqjlwUWFDBui/VFFRCAGyv3pTZUkJyXw0CLtjyoicl5Ul3tDexc/217NvbNzyUwZ6nUcEZGIEdXl/sPNx+js8fPoMu2PKiLSW9SWe0e3j2ffPspN12VSMi7F6zgiIhElasv9F7tOUN/WpUVLIiJ9iMpyP79o6frxqSyZOMbrOCIiEScqy/31w3W8W9vGY8uKtT+qiEgforLcn95YybjUodw1M8frKCIiESnqyn1/TQubyut5eEkxyUlRF19EZFBEXTuu3VTBiOREPrWgwOsoIiIRK6RyN7PbzeyQmZWb2Zf7OP6Ame0Jfv3ezGaFPyqcbungl7tr+ERpPmkjtD+qiMj76bfczSwR+A5wBzAVWG5mUy85rRL4gHNuJvC3wOpwBwV45vdH8fkdn12qRUsiIpcTypX7AqDcOVfhnOsC1gP39D7BOfd751xj8OFmIOy3Z2zv7OG5zce4bVo2BWNGhPvpRURiSijlngtU9XpcHfzZ+3kE+HVfB8xspZltM7NtdXV1oacEfrqtipaOHh7VoiURkX6FUu59TSR3fZ5odjOBcv9SX8edc6udc6XOudLMzMyQQ/r8jnVvHWVuQTrzCjNC/nsiIvEqlHKvBvJ7Pc4Dai49ycxmAmuBe5xzZ8ITL+DV/ac43nBWtxoQEQlRKOW+FSgxs2IzSwbuB17sfYKZFQAvAA855w6HO+SajZXkjx7OrdOyw/3UIiIxKam/E5xzPWb2JPAykAisc86VmdkTweOrgK8CY4DvBm8H0OOcKw1HwB3HG9l+rJGvfWQqidofVUQkJP2WO4BzbgOw4ZKfrer1/aPAo+GNFrB2YwWpw5L4RGl+/yeLiAgQ4StUqxrO8pt9p/jUwkJGDg3p95CIiBDh5f70pkoSzHh4SZHXUUREokrElnvz2W5+sq2Ku2flkJ02zOs4IiJRJWLL/UdbjnO2y6dFSyIiVyEiy72rx88zv69k6aQxTM1J9TqOiEjUichy/9XeGk63dOqqXUTkKkVcuTvnWPNmJSVZo7hpcui3KBARkYsirtzfPnKG/SdbeOQG7Y8qInK1Iq7c12ysYOyoZD4653I3nhQRkcuJqHIvr23ltUN1PLSoiGFDEr2OIyIStSKq3NdurGRoUgIPLtL+qCIi1yJiyr2utZMXdp7gvnl5jBk11Os4IiJRLWLK/Qebj9HV4+eRG7Q/qojItYqIcu/o9vHDzcf40PVZTMwc5XUcEZGoFxHl/sKOEzS0d2nRkohImHhe7n6/Y+2mCqbnprKweLTXcUREYoLn5f7aoVoq6tp5bNkELVoSEQkTz8t9zcYKxqcN48MzxnsdRUQkZnha7vtONLO5ooEVS4sYkuj57xkRkZjhaaOu2VjBqKFJ3L9Ai5ZERMLJs3Lv9vl5ac9JPjk/n9RhQ7yKISISk0IqdzO73cwOmVm5mX25j+NmZt8KHt9jZnP7e84zbV0ArFhadKWZRUSkH/2Wu5klAt8B7gCmAsvNbOolp90BlAS/VgJP9fe8Z9q7uGN6NnkZI644tIiIXF4oV+4LgHLnXIVzrgtYD9xzyTn3AM+6gM1AuplddvqL3zktWhIRGSChlHsuUNXrcXXwZ1d6Dma20sy2mdm24Ql+ZuenX2FcEREJRSjl3tfKIncV5+CcW+2cK3XOlU4anxFKPhERuQqhlHs1kN/rcR5QcxXniIjIIAml3LcCJWZWbGbJwP3Ai5ec8yLw6eCsmUVAs3PuZJiziohIiJL6O8E512NmTwIvA4nAOudcmZk9ETy+CtgAfBgoB84CKwYusoiI9Kffcgdwzm0gUOC9f7aq1/cO+Hx4o4mIyNXSDV1ERGKQyl1EJAap3EVEYpDKXUQkBlngs1APXtisFTjkyYtHnrFAvdchIoTei4v0Xlyk9+Ki65xzKf2dFNJsmQFyyDlX6uHrRwwz26b3IkDvxUV6Ly7Se3GRmW0L5TwNy4iIxCCVu4hIDPKy3Fd7+NqRRu/FRXovLtJ7cZHei4tCei88+0BVREQGjoZlRERikMpdRCQGeVLu/W24HS/MbJ2Z1ZrZPq+zeM3M8s3sNTM7YGZlZvZFrzN5xcyGmdkWM9sdfC/+xutMXjKzRDPbaWYveZ3Fa2Z21Mz2mtmu/qZEDvqYe3DD7cPALQQ2+dgKLHfO7R/UIBHAzG4E2gjsPzvd6zxeCu65O945t8PMUoDtwEfj9N+FASOdc21mNgTYBHwxuD9x3DGzPwVKgVTn3F1e5/GSmR0FSp1z/S7o8uLKPZQNt+OCc+5NoMHrHJHAOXfSObcj+H0rcIA+9uGNB8GN5tuCD4cEv+Jy5oOZ5QF3Amu9zhJtvCj3kDbTlvhlZkXAHOAdj6N4JjgUsQuoBV51zsXre/GvwF8Afo9zRAoHvGJm281s5eVO9KLcQ9pMW+KTmY0C/gP4E+dci9d5vOKc8znnZhPYj3iBmcXdsJ2Z3QXUOue2e50lgix1zs0F7gA+Hxza7ZMX5a7NtKVPwfHl/wCec8694HWeSOCcawJeB273NoknlgJ3B8eZ1wMfNLMfehvJW865muCftcD/JzDM3Scvyj2UDbclzgQ/RHwaOOCc+6bXebxkZplmlh78fjjwIeCgp6E84Jz7S+dcnnOuiEBP/Kdz7kGPY3nGzEYGJxtgZiOBW4H3nWk36OXunOsBzm+4fQD4iXOubLBzRAIzex54G7jOzKrN7BGvM3loKfAQgauzXcGvD3sdyiPjgdfMbA+Bi6FXnXNxPw1QGAdsMrPdwBbgV86537zfybr9gIhIDNIKVRGRGKRyFxGJQSp3EZEYpHIXEYlBKncRkRikchcRiUEqdxGRGPRfd2ruZNBNACgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Marginal consumption function:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the consumption function and MPC for the portfolio choice consumer\n", + "print(\"Concave consumption function:\")\n", + "plot_funcs(RiskyFixedExample.cFunc[0], 0.0, 5.0)\n", + "print(\"Marginal consumption function:\")\n", + "plot_funcs_der(RiskyFixedExample.cFunc[0], 0.0, 5.0)\n" + ] + }, + { + "cell_type": "markdown", + "id": "1d1a616a", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Compare Fixed Share at 1.0 Type with Risky Return Type" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "fd400df3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumption functions for risky asset vs fixed share at 1.0:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Compare the consumption functions for the various risky shocks\n", + "print(\"Consumption functions for risky asset vs fixed share at 1.0:\")\n", + "plot_funcs(\n", + " [\n", + " RiskyReturnExample.cFunc[0], # blue\n", + " RiskyFixedExample.cFunc[0], # orange\n", + " ],\n", + " 0.0,\n", + " 200.0,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdaa4b5b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "e142479391b55cd73c518fdaa8d77b25530b0ba1811d1048225bf54019104d93" + }, + "jupytext": { + "cell_metadata_filter": "-all", + "formats": "ipynb,auto:percent", + "main_language": "python", + "notebook_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/ConsPortfolioModel/example_ConsRiskyAssetModel.py b/examples/ConsPortfolioModel/example_ConsRiskyAssetModel.py new file mode 100644 index 000000000..3c7f2fcee --- /dev/null +++ b/examples/ConsPortfolioModel/example_ConsRiskyAssetModel.py @@ -0,0 +1,306 @@ +# %% [markdown] +# # Example Implementations of `HARK.ConsumptionSaving.ConsRiskyAssetModel` + +# %% +from time import time + +from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType +from HARK.ConsumptionSaving.ConsPortfolioModel import ( + init_portfolio, + PortfolioConsumerType, +) +from HARK.ConsumptionSaving.ConsRiskyAssetModel import ( + RiskyAssetConsumerType, + FixedPortfolioShareRiskyAssetConsumerType, +) +from HARK.utilities import plot_funcs_der, plot_funcs + + +# %% +mystr = lambda number: "{:.4f}".format(number) + + +# %% [markdown] +# ## Idiosyncratic Income Shocks Consumer Type + +# %% +# Make and solve an example consumer with idiosyncratic income shocks +# Sse init_portfolio parameters to compare to results of PortfolioConsumerType +IndShockExample = IndShockConsumerType(**init_portfolio) +IndShockExample.cycles = 0 # Make this type have an infinite horizon + + +# %% +start_time = time() +IndShockExample.solve() +end_time = time() +print( + "Solving a consumer with idiosyncratic shocks took " + + mystr(end_time - start_time) + + " seconds." +) +IndShockExample.unpack("cFunc") + + +# %% +# Plot the consumption function and MPC for the infinite horizon consumer +print("Concave consumption function:") +plot_funcs(IndShockExample.cFunc[0], 0.0, 5.0) +print("Marginal consumption function:") +plot_funcs_der(IndShockExample.cFunc[0], 0.0, 5.0) + + + +# %% [markdown] +# ## Risky Return Consumer Type + +# %% +# Make and solve an example consumer with risky returns to savings +# Use init_portfolio parameters to compare to results of PortfolioConsumerType +RiskyReturnExample = RiskyAssetConsumerType(**init_portfolio) +RiskyReturnExample.cycles = 0 # Make this type have an infinite horizon + + +# %% +start_time = time() +RiskyReturnExample.solve() +end_time = time() +print( + "Solving a consumer with risky returns took " + + mystr(end_time - start_time) + + " seconds." +) +RiskyReturnExample.unpack("cFunc") + + +# %% +# Plot the consumption function and MPC for the risky asset consumer +print("Concave consumption function:") +plot_funcs(RiskyReturnExample.cFunc[0], 0.0, 5.0) +print("Marginal consumption function:") +plot_funcs_der(RiskyReturnExample.cFunc[0], 0.0, 5.0) + + + +# %% [markdown] +# ## Compare Idiosyncratic Income Shocks with Risky Return + +# %% +# Compare the consumption functions for the various agents in this notebook. +print("Consumption functions for idiosyncratic shocks vs risky returns:") +plot_funcs( + [ + IndShockExample.cFunc[0], # blue + RiskyReturnExample.cFunc[0], # orange + ], + 0.0, + 20.0, +) + + +# %% [markdown] +# ## Risky Return Consumer Type with Portfolio Choice + +# %% +# Make and solve an example risky consumer with a portfolio choice +init_portfolio["PortfolioBool"] = True +PortfolioChoiceExample = RiskyAssetConsumerType(**init_portfolio) +PortfolioChoiceExample.cycles = 0 # Make this type have an infinite horizon + + +# %% +start_time = time() +PortfolioChoiceExample.solve() +end_time = time() +print( + "Solving a consumer with risky returns and portfolio choice took " + + mystr(end_time - start_time) + + " seconds." +) +PortfolioChoiceExample.unpack("cFunc") +PortfolioChoiceExample.unpack("ShareFunc") + + +# %% +# Plot the consumption function and MPC for the portfolio choice consumer +print("Concave consumption function:") +plot_funcs(PortfolioChoiceExample.cFunc[0], 0.0, 5.0) +print("Marginal consumption function:") +plot_funcs_der(PortfolioChoiceExample.cFunc[0], 0.0, 5.0) + + + +# %% [markdown] +# ## Compare Income Shocks, Risky Return, and RR w/ Portfolio Choice + +# %% +# Compare the consumption functions for the various agents in this notebook. +print( + "Consumption functions for idiosyncratic shocks vs risky returns vs portfolio choice:" +) +plot_funcs( + [ + IndShockExample.cFunc[0], # blue + RiskyReturnExample.cFunc[0], # orange + PortfolioChoiceExample.cFunc[0], # green + ], + 0.0, + 20.0, +) + + +# %% [markdown] +# ## Portfolio Consumer Type + +# %% +# Make and solve an example portfolio choice consumer +PortfolioTypeExample = PortfolioConsumerType() +PortfolioTypeExample.cycles = 0 # Make this type have an infinite horizon + + +# %% +start_time = time() +PortfolioTypeExample.solve() +end_time = time() +print( + "Solving a consumer with portfolio choice took " + + mystr(end_time - start_time) + + " seconds." +) +PortfolioTypeExample.unpack("cFuncAdj") +PortfolioTypeExample.unpack("ShareFuncAdj") + + +# %% +# Plot the consumption function and MPC for the portfolio choice consumer +print("Concave consumption function:") +plot_funcs(PortfolioTypeExample.cFuncAdj[0], 0.0, 5.0) +print("Marginal consumption function:") +plot_funcs_der(PortfolioTypeExample.cFuncAdj[0], 0.0, 5.0) + + +# %% [markdown] +# ## Compare RR w/ Portfolio Choice with Portfolio Choice Type + +# %% +# Compare the consumption functions for the various portfolio choice types. +print( + "Consumption functions for portfolio choice type vs risky asset with portfolio choice:" +) +plot_funcs( + [ + PortfolioTypeExample.cFuncAdj[0], # blue + PortfolioChoiceExample.cFunc[0], # orange + ], + 0.0, + 20.0, +) + + +# %% +# Compare the share functions for the various portfolio choice types. +print("Share functions for portfolio choice type vs risky asset with portfolio choice:") +plot_funcs( + [ + PortfolioTypeExample.ShareFuncAdj[0], # blue + PortfolioChoiceExample.ShareFunc[0], # orange + ], + 0, + 200, +) + + +# %% [markdown] +# ## Risky Return Given Fixed Portfolio Share + +# %% +FixedShareExample = FixedPortfolioShareRiskyAssetConsumerType( + **init_portfolio +) +FixedShareExample.cycles = 0 + + +# %% +start_time = time() +FixedShareExample.solve() +end_time = time() +print( + "Solving a consumer with fixed portfolio share took " + + mystr(end_time - start_time) + + " seconds." +) +FixedShareExample.unpack("cFunc") + + +# %% +# Plot the consumption function and MPC for the infinite horizon consumer +print("Concave consumption function:") +plot_funcs(FixedShareExample.cFunc[0], 0.0, 5.0) +print("Marginal consumption function:") +plot_funcs_der(FixedShareExample.cFunc[0], 0.0, 5.0) + + +# %% [markdown] +# ## Compare Idiosyncratic Shock Type with Fixed Share at 0.0 Type + +# %% +# Compare the consumption functions for the various idiosyncratic shocks +print("Consumption functions for idiosyncratic shocks vs fixed share at 0.0:") +plot_funcs( + [ + IndShockExample.cFunc[0], # blue + FixedShareExample.cFunc[0], # orange + ], + 0.0, + 20.0, +) + + +# %% [markdown] +# ## Fixed Share at 1.0 Type + +# %% +init_portfolio["RiskyShareFixed"] = [1.0] +RiskyFixedExample = FixedPortfolioShareRiskyAssetConsumerType( + **init_portfolio +) +RiskyFixedExample.cycles = 0 + + +# %% +start_time = time() +RiskyFixedExample.solve() +end_time = time() +print( + "Solving a consumer with share fixed at 1.0 took " + + mystr(end_time - start_time) + + " seconds." +) +RiskyFixedExample.unpack("cFunc") + + +# %% +# Plot the consumption function and MPC for the portfolio choice consumer +print("Concave consumption function:") +plot_funcs(RiskyFixedExample.cFunc[0], 0.0, 5.0) +print("Marginal consumption function:") +plot_funcs_der(RiskyFixedExample.cFunc[0], 0.0, 5.0) + + +# %% [markdown] +# ## Compare Fixed Share at 1.0 Type with Risky Return Type + +# %% +# Compare the consumption functions for the various risky shocks +print("Consumption functions for risky asset vs fixed share at 1.0:") +plot_funcs( + [ + RiskyReturnExample.cFunc[0], # blue + RiskyFixedExample.cFunc[0], # orange + ], + 0.0, + 200.0, +) + + +# %% diff --git a/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.ipynb b/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.ipynb index 143eb4889..c06b7abc4 100644 --- a/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.ipynb +++ b/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.ipynb @@ -20,7 +20,7 @@ " SequentialPortfolioConsumerType,\n", " init_portfolio,\n", ")\n", - "from HARK.utilities import plot_funcs" + "from HARK.utilities import plot_funcs\n" ] }, { @@ -33,7 +33,7 @@ "output_type": "stream", "text": [ "Now solving an example portfolio choice problem; this might take a moment...\n", - "Solving an infinite horizon portfolio choice problem took 6.892995834350586 seconds.\n" + "Solving an infinite horizon portfolio choice problem took 4.498995780944824 seconds.\n" ] } ], @@ -54,7 +54,7 @@ " \"Solving an infinite horizon portfolio choice problem took \"\n", " + str(t1 - t0)\n", " + \" seconds.\"\n", - ")" + ")\n" ] }, { @@ -71,7 +71,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -85,7 +85,7 @@ "source": [ "# Plot the consumption and risky-share functions\n", "print(\"Consumption function over market resources:\")\n", - "plot_funcs(MyType.cFunc[0], 0.0, 20.0)" + "plot_funcs(MyType.cFunc[0], 0.0, 20.0)\n" ] }, { @@ -103,7 +103,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAApDElEQVR4nO3deXxddZ3/8dcn92ZPbpIm6ZZ0hbZQhJZSWUQRZUTBhXFBQXFBEfEhbuj8dEadH/5mUWd+Oo7jNogIjo64MYqK4vKjwLC3QEtbKC1t6Za2adrs600+vz/OiXNJk9zbJDfnJnk/H4/7yD3nfM85n3tyc985557zPebuiIiIjCYv6gJERCT3KSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0spaWJjZLWZ22Mw2jzDdzOxrZrbDzDaZ2Zps1SIiIuOTzT2LW4HXjDL9EmBZ+LgW+FYWaxERkXHIWli4+33A0VGaXAZ83wMPA5VmNi9b9YiIyNjFI1x3HbA3ZXhfOK5haEMzu5Zg74PqYs5aXJk+43rK6ihMzJ6YSkVEprgNGzYccffasc4fZVjYMOOG7XvE3W8CbgJYdcbp/pu7fjHiQhvbeqi6/XUk57+YRR/48UTUKSIy5ZnZ8+OZP8qw2AcsSBmuBw6kmym/oJA59SeNOL1mwHnI57O0de+IbURE5MREeersncC7wrOizgVa3P24Q1AnKpZntBTOobR73IsSEZFQ1vYszOxHwIVAjZntA/43kA/g7t8G7gIuBXYAncDVE7Xu3tI6Kpr/CMkeiBdO1GJFRGasrIWFu1+ZZroDH8rGuq2iHprBW/Zj1UuzsQoRkRllWl7BXVy7GIDmg89FW4iIyDQxLcOiYu4SAI4d2BVxJSIi08O0DIu5C4KzpTobd0dbiIjINDEtw6KuppLDXslAs06fFRGZCNMyLPJjeTTGZpPfnvayDRERycC0DAuA9sK5lHcfjLoMEZFpYdqGRW/ZfKoHDoMP24OIiIicgGkbFla5gGJ6aTumvQsRkfGatmFRXL0IgMN7d0RciYjI1DdtwyIxN7hyu+Xg7mgLERGZBqZtWMxZcDIA3UfG1SuviIgwjcMiMWs2nRTiutZCRGTcpm1YYMaRvFoKO/ZFXYmIyJQ3fcMCaC6qp6pbYSEiMl7TOiy6yhcxr7+Bgf6BqEsREZnSpnVYMOskSqyHpkN7oq5ERGRKm9ZhUThnGQBNe7ZGXImIyNQ2rcNi1oJTAGg/8GzElYiITG3TOizmLVxGr8fpb9RV3CIi4zGtwyI/P5+G2FwKWnXHPBGR8ZjWYQHB6bMVXbowT0RkPKZ9WPQmljCvv4G+ZDLqUkREpqxpHxax2csptl4OPL896lJERKasaR8W5QtOB6Bp18aIKxERmbqmfVjMWbYagJ4DutZCRGSspn1YJCpraaSK+NFtUZciIjJlTfuwADhYsIjK9ueiLkNEZMqaEWHRnlhGXd8efKA/6lJERKakGREWeXNOpcR6aNijK7lFRMZiRoRF1eIzAGjY/kTElYiITE0zIiwWrFgLQNdenT4rIjIWMyIsihNV7LN5FDc9FXUpIiJT0owIC4BDpSuY16muykVExmLGhEVP7enM90O0HGuMuhQRkSlnxoRFyaI1ABzY+nDElYiITD1ZDQsze42ZbTOzHWb26WGmV5jZr8xso5ltMbOrs1VL3annANC+e0O2ViEiMm1lLSzMLAZ8A7gEWAlcaWYrhzT7ELDV3VcBFwJfNrOCbNRTM3s+DdSQd2hTNhYvIjKtZXPP4mxgh7vvdPde4HbgsiFtHCg3MwPKgKNAVm48YWYcLF1Bbdsz2Vi8iMi0ls2wqANSb1G3LxyX6uvAqcAB4Cngo+4+MHRBZnatma03s/WNjWP/grqv9gzqBw5w7OiRMS9DRGQmymZY2DDjfMjwq4EngfnAauDrZpY4bib3m9x9rbuvra2tHXNBZSefR545ezbeO+ZliIjMRNkMi33AgpTheoI9iFRXA3d4YAewCzglWwUtOuMC+t3oeu6BbK1CRGRaymZYPAYsM7Ml4ZfWVwB3DmmzB7gIwMzmACuAndkqqDRRxa74EsobdUaUiMiJyFpYuHsSuB64G3ga+Im7bzGz68zsurDZ3wEvMbOngD8Bn3L3rH6hcLhyNUt6nmYg2ZfN1YiITCvxbC7c3e8C7hoy7tspzw8AF2ezhqHyFp1HSdMd7Hr6EZac/tLJXLWIyJQ1Y67gHrRw1YUAHNp8X7SFiIhMITMuLOYvWs4hqya+75GoSxERmTJmXFgA7EucxdKOxxno121WRUQyMSPDYmDJy5lFK7uffizqUkREpoQZGRZ1Z10CQNPG30VciYjI1DAjw2L+gpPYbfUU7b0/6lJERKaEGRkWAA0153Fy1ya6uzqjLkVEJOfN2LAoOeUiiq2XZ9f/MepSRERy3owNi+VnX0Kvx2nf/NuoSxERyXkzNiyKyyt5png1Cw6vAx/aGa6IiKSasWEB0L7oVSzwA+zfvjHqUkREctqMDovFL3kLAHsf/nnElYiI5LYZHRbzF53M9tjJVO75Q9SliIjktBkdFgBH6y9ied8zHNq/K+pSRERy1owPi/nnv508c3bf+4OoSxERyVkzPiwWLF/N9rylzNo59CZ+IiIyaMaHBUDj4tezLPks+5/bHHUpIiI5SWEBnPTKdzPgxvP3fj/qUkREcpLCAphTfxLbCk9n4d5f4gO6x4WIyFAKi1D7aW+n3g/yzEN3pW8sIjLDKCxCp73qnbRQSvfD3426FBGRnKOwCJWUlLF19us4rfU+jh7aF3U5IiI5RWGRYt4rr6PA+tn2+5uiLkVEJKcoLFIsPmUNWwtOZ9HOH9Gf7Iu6HBGRnJFRWJjZIjP7i/B5sZmVZ7es6HSvvY75fpiNd98WdSkiIjkjbViY2fuBnwH/Ho6qB36RxZoiteqiK9ljdSQe/yY+MBB1OSIiOSGTPYsPAecDrQDuvh2Ync2iohSLxThw2jWc3P8cWx/8VdTliIjkhEzCosfdewcHzCwOTOtby61+7Qc4QiV+/1eiLkVEJCdkEhb3mtnfAMVm9irgp8C0/pe7qLiU55a9jxf1PMnWB38TdTkiIpHLJCw+BTQCTwEfAO4CPpvNonLBqjfewGFmEbvn73WPbhGZ8UYNCzPLA55y9++4++Xu/pbw+bT/9CwqKWPHKR9kRd9Wnlr3s6jLERGJ1Khh4e4DwEYzWzhJ9eSUtW/8CPttDqX3/72uuxCRGS2Tw1DzgC1m9iczu3Pwke3CckFBYRGHzvkblg7s5ok79GW3iMxc8QzafD7rVeSwMy9+F5sev5XlW/+VpsNXUT27LuqSREQmXdo9C3e/d7hHJgs3s9eY2TYz22Fmnx6hzYVm9qSZbTGzjJY7mSwvj4o3fYVi72bbD/8q6nJERCKRyRXc55rZY2bWbma9ZtZvZq0ZzBcDvgFcAqwErjSzlUPaVALfBN7g7qcBl4/lRWTbolPWsLHuCs5tvosn7teptCIy82TyncXXgSuB7UAxcE04Lp2zgR3uvjO8qO924LIhbd4O3OHuewDc/XCmhU+206/6AgfzZlP7/26gs70l6nJERCZVRh0JuvsOIObu/e7+PeDCDGarA/amDO8Lx6VaDlSZ2Toz22Bm7xpuQWZ2rZmtN7P1jY2NmZQ84QpLKmi5+KvU+0E233ZDJDWIiEQlk7DoNLMC4Ekz+ycz+zhQmsF8Nsy4oddnxIGzgNcCrwY+Z2bLj5vJ/SZ3X+vua2trazNYdXacet6lPFRzOWc3/own1/0isjpERCZbJmHxzrDd9UAHsAB4cwbz7QvbDqoHDgzT5nfu3uHuR4D7gFUZLDsyZ773X9ibV0f9uo9w6MDzUZcjIjIpMjkb6nl373b3Vnf/vLvfEB6WSucxYJmZLQn3TK4Ahl6f8UvgZWYWN7MS4Bzg6RN9EZOpqKQc3vp9Sr2LxluvItmni/VEZPrL5Gyo883sD2b2rJntHHykm8/dkwR7I3cTBMBP3H2LmV1nZteFbZ4GfgdsAh4Fbnb3zeN5QZNhwSlr2brmRl7Uu4lHv/fJqMsREck6S9fNk5k9A3wc2AD0D45396bslja8tWvX+vr166NY9XEe/dpVnH30Vzx25hd58WUfjLocEZERmdkGd1871vkz+c6ixd1/6+6H3b1p8DHWFU4nqz9wM1sKzmDV45/lqQd/G3U5IiJZM2JYmNkaM1sD3GNm/2xm5w2OC8fPeAWFRdR/8A4Oxuaw4PfXsHvbxqhLEhHJihEPQ5nZPaPM5+7+yuyUNLpcOgw1qGH30xTeejF95DPwnruYt/iUqEsSEXmB8R6GGrEjQXd/xVgXOtPMW3wqO970E2rveDMdt72ehvf8hnmLjrtcRERkyhrtMNTrzWxRyvDfmtnGsIvyxZNS3RRy8hnncfgvf0yZt9N/6+s5sPe5qEsSEZkwo33B/Q8Et1PFzF4HXAW8l+BaiX/PfmlTz7LVL+PwG35Ipbdgt7ya/Ts2RV2SiMiEGC0s3N07w+dvAr7r7hvc/WYguj43ctzJa15Jw2U/odB7KPnBa9m2YV3UJYmIjNtoYWFmVhbeh/si4E8p04qyW9bUtuzMC2h/x2/osmLq73wrG/54e9QliYiMy2hh8VXgSWA98LS7rwcwszOBhqxXNsUtXHYGhdf9kYPxes68/zoeue2v8YH+9DOKiOSgEcPC3W8BXg68D7g0ZdJB4Oos1zUtVM9ZyLwb1rE+cRHn7PomT/zfN9DacjTqskRETtioV3C7+353f8LdB1LGNQzerEjSKylN8OKP/5SHl/8VZ3Q8SPNXz+e5jfdHXZaIyAnJ6OZHMj6Wl8e5b/8sOy75IYXew8I7LuOR2/6G/mQy6tJERDKisJhEp5x7KYUffpiN5Rdwzq5vsP1LL2P/zq1RlyUiklZGYWFmq8zs+vCR0zcnynWV1bM564Y7eGzNl6jr3UX1bRfw8G2foa+3O+rSRERGlMn9LD4K/BCYHT5+YGYfznZh05nl5fHiN1xH5/sfYGvZuZy76+vs/+KLeeaRu6MuTURkWJncz2ITcJ67d4TDpcBD7n7GJNR3nFzsSHC8nvjDfzL3gc8xjyOsL38ldW/+R+YtPjXqskRkGpmM+1kYKTc9Cp/bWFcoxzvzVW8n8YkNPFz/Xk5r/W+qv3c+j377OpqPHIq6NBERILOw+B7wiJndaGY3Ag8D381qVTNQaXkl517zL7S8/xEer3wNZzXcTt6/reaBmz+h0BCRyKU9DAXBjZCAlxLsUdzn7k9ku7CRTMfDUMPZvfVRWn5zI6s6HqDDi9hcdznL//LTVM2uj7o0EZmCxnsYarSbHyXcvdXMZg033d0juRR5poTFoN1bH+XIb7/Ama330EecJ2pez/yLP8qiFaujLk1EppBshsWv3f11ZrYLSG1kBD3SLh3rSsdjpoXFoN3bNtL4uy+x6ujvKLB+nio6C85+P6ddcDl58RHvYSUiAmQxLHLVTA2LQUcP7WXbXV/npOd/wmyOcsDmsHvx21j2qmuonb8o/QJEZEbK5p7FmtFmdPfHx7rS8ZjpYTGot6eHJ//wA8o33cKpvZtJeh5bS9YysOrtrLzwbRQUlURdoojkkGyGxT2jzOfu/sqxrnQ8FBbH27d9I3vv+S5LD/yKORylhVKenvUXlK25nFPPfQ2xeH7UJYpIxHQYSv4s2dfH5gd+Rf/jP+TUlvspsR6OkmBnzSsoWvUmlp99CQWFhVGXKSIRyHpYmFk+8EHggnDUOuDf3b1vrCsdD4VFZro7Wtl6/x30b/4FK9sepNR6aPYynk2cR96Ki1l+3mUkqudEXaaITJLJCIubgXzgtnDUO4F+d79mrCsdD4XFievqaGfbg79kYMsvWdL8EFW00u/GjoJTaa57ObNWv5alp7+EWCwWdakikiWTERYb3X1VunGTRWExPgPJJNufvI+mJ39NTcO9LO/fAcBREuwqO5P+hS+lbs2rqTvpDDD16iIyXYw3LDI5Qb/fzE5y9+fCFS7lhX1FyRSSF4+zYu0rYW1wfsKRg3vZ8+id+HPrWNCyntlb74Wt/0AjVTxffhZ9C15C7WkvZ8kpZ2rPQ2QGy2TP4iKC/qF2ElyQtwi42t1HO1sqa7RnkT0+MMDe5zaz/4nfk7/3AZa0PU41zQC0eim7i1fSOecsEstewuJVL6OkfNiL+0UkB2Xz1NnL3f2nZrYEOACsIAiLZ9y9Z6wrHC+FxeTxgQEO7tpMw+b76H/+YWqaN7Gofw955vS7sTu2iKbESgbmrqLy5BezeOU5FJWURV22iAwjm2HxuLuvGfw55gonmMIiWi3Hmtj15Dq6dj5EWeMT1Hc/SxWtACQ9j72xhTQlTiE5ZxXli8+kfsVZVMyaHXHVIpLNsPgDwXcaq4H7h0539zeMdaXjobDILT4wQOOBXezf+hDdezZQcuQp6rufpZqWP7c5zCwOFp1EZ9Vy8uedTtWS1dQtO4PCotIIKxeZWbIZFgXAGuA/gONOk3X3e8e60vFQWOQ+HxigqeF5GrZvoGPPRuJHnqaqYwcLknspsCQQ7IUcyJtHU9FCuiuWEqtdTqL+FOYuOZ3K2vk6E0tkgmXtbCh37wUeNrPPDA0GM7t8rCuU6c/y8qipW0JN3RLgLX8e39fXy64dmzmy83H6G7ZQeGw7VV3PM7/hMQoOJuGpoF0rpRzMr6etdAl9lScRn72MRN0KZi9cQWVVdTQvSmSGy+RsqOO+s8j0ewwzew3wr0AMuNndvzhCuxcT3IHvbe7+s9GWqT2L6ac/meTgnu0c2b2ZzoZt2NHtlLbtZnbvHubwwtumHKWcxvg82orq6U0sJFa9mNI5JzGrfgVz6peqHyyREWRtz8LMLgEuBerM7GspkxJAMoPCYsA3gFcB+4DHzOxOd986TLsvAXefePkyHcTiceqWnkrd0lOPm9bR1szh3VtoObCd3sadcGw3xR17mdexldlt95J/oP/PeyR9HqMhr5bm/Dl0Fs+jv7yOvKoFFFcvpGLuEmrqllJaXjm5L05kmhjtorwDwHrgDcCGlPFtwMczWPbZwA533wlgZrcDlwFbh7T7MPBz4MUZ1iwzSGl5JUtOPx9OP/+4af3JPhr276Rp7zY6Dz1Hsmk3hW17KO0+yKKWx6hpvpvYvhfuObdQypHYbNoK59JTMg9P1JM/ayGltYtIzFlE9byFFBYWT9bLE5kyRvvOYqOZbQYudvfbRmo3ijpgb8rwPuCc1AZmVge8EXglo4SFmV0LXAuwcOHCMZQi01Esns+8RSuYt2jFsNOTvT0cPLiHYw076Ti8m76je7C2/RR1NJDobqCmcxOJIx3B5aYpjlHOsbxq2gtq6S6qpb9sLnmJeRRU1VFWs4DKOQupqp1PPL9gEl6lSG4YtbsPd+83s2ozKwi/8D4Rw53OMvQLkq8CnwrXM1odNwE3QfCdxQnWITNUvKCQuQuXMXfhshHbtLUcpenALloP7qTn6H76Wxuw9oMUdB2mrLeRuc3PUX3sGDF74duu341Gq6Q5Xk1HQS09xbMZKJlNXtls8ivmUFI1j7KaOipn11FaVsFo72+RqSCTvqGeBx4wszuBjsGR7v6VNPPtAxakDNcTHNpKtRa4PfxDqgEuNbOku/8ig7pExq28YhblFbPg1LNGbNOf7KPx8H6aD+2h48g+eo7tx1sbyOs4SGHXYcq7D7KwcwuVR9rIs+P/l+n0QprzKmmLVdFZUE1vUQ0DpbVhsMyluGoe5dXz/ydY8vKy+ZJFxiSTsDgQPvKA8hNY9mPAsrC7kP3AFcDbUxu4+5LB52Z2K/BrBYXkmlg8n9r5i6mdv3jUdsm+Xo4eaaClcT8dRxvoaW6gv/UQdDQS72qksKeJyu59VHQ+RWVTJsEyKwiW4llYaQ3xshoKErMprpxD+aw5VFTPo7hU3avI5EgbFu7+eQAzKw8GvT2TBbt70syuJzjLKQbc4u5bzOy6cPq3x162SO6J5xdQM28RNfMWpW2b7OvlaNNBmhv309l0gJ7mg/S3HcLbDxPvOkJRzxEqug+Q6NxKpbcSt4Fhl9PphbRYgvZYBZ35VfQVVJIsrobiavLKaoiX11JcOZuSyjlUVM8lUVVLnnoPljHI5DqLFxFcxT3YxegR4F3uviXLtQ1L11nITDPQ309bSxOtTQ20HztMd/Mh+tqO0N/eiHU2Ees+SkHPUYqTLZT1N1Mx0EqpdQ+7rH43WqyctrwKOmMJuvMrSBZU0F9YiRdXklcyi3jpLArKqylK1FBaUUtZVS3liSodHpviJuN+FjcBNwx2SW5mFwLfAV4y1pWKSObyYjEqZs0+oQ4ZuzvbaW46SPvRQ3Q1H6KntZFkWyPe2UReVxP53cco7Gsh0dNAaeezJLyNEhu5M+mk59FqZbRbeRgyCfoKKugvCELGimcRL5tFflk1RYlqSipqKEnMoryimoLCoonYDBKxTMKiNPXeFe6+zszUA5xIDisqKWNuycmw4OSM5+np7qSt+QgdxxrpbD1CT2sTve1NDHQehc6jWHcz8Z5mCvtaKOs9Qkn3Lsq9jXK6Rl1ulxfQbqV05pXSnVdGT7ycvvxykgUJBgoSUJTAiiuJl1SSX1pJYVkVReWzKE1UU1Yxi6LiUu3V5IBMwmKnmX2O4FAUwFXAruyVJCJRKCwqoXDuQmrmnti1TMneHtpammg/djgImZYj9HYco7+rhYGuZqy7lbzeFuK9beT3tVGUbKGqZz8l3kG5t1Ngo994s9djtFspHVZGd6yU7lgZvfFy+gvKGcgvwwvLsfARL04QLyknv6SSwpIERWVVFJclKE1UUVhUMp7NM+NlEhbvBT4P3BEO3wdcnbWKRGRKiRcUUlU7n6ra+Sc+szvdXR20tzTR0XqMrrYmetuP0ddxjGRnC97VAt3NWE8rsd42CvpaKehvJ9F1hOKODkq8ixK6hz2zbKhej9NhxXRZCd1WTE+slN5YCcn8MpLxMrygDC8ox4rKsKIE8aJy4sUVFJQmKCipoKikjMLSBMWlCYpLymfciQKj9Q1VBFwHnEzQ+84n3L1vsgoTkRnAjKKSMopKyjI6i2w4A/39tHe00tnWTFd7Cz0dzfR0tNDX2Rrs3XS34d1teG8beb3txHrbiCU7KEh2UJJspqhnP8XeGQTPKN/bDNXphXRZET1WRI8V05tXRF+smL5YCf3xEvrzS/B4CRSUQkEpVlhGXkEp8eIy4oVl5BeXk1+SoLC4jKKy3A+h0fYsbgP6CG58dAlwKvCxSahJRCRjebEYZYkqyhJV415WfzJJR3sznW3N9LQ309XRQl9nC32dbSS72/GeDgZ626G3A3o7yEt2ktfXSTzZSby/k/z+bkr7jlHoXRR6N8XefUIBBEEIdVsh3VZErxXSm1dMX14hybwikrEiBmLFDMSLGYgX4fklEC8OwqigmLyCUmIFJcQKS4gXlRIvKqWgqJSCovFfjzNaWKx099MBzOy7wKPjXpuISA6LxeMkKmtIVNZM2DIH+vvp6myjq6OV7o42ejrb6Otspa+7nWR3G8muIIC8px3v7cR627FkJ3nJLmLJbmL9XeQPdFOSbKagt5sC76HAeyiih2LvyegQ3EQYLSz+fMgpvMBuEsoREZle8mIxSssrs9M9vjt9vd10d7XT29lOb1c7vd0d9Ha1k+zuINnTSX9vBwM9HYz3wNBoYbHKzFrD5wYUh8NGcCV3YlxrFhGR8TEjv7CY/MJiqKxN0/hj41rVaF2U5+a3LCIiMul0pYuIiKSlsBARkbQyuSgvp+xu3c3Vv9M1gSIik0l7FiIiklbaLspzjbooFxE5cePtolx7FiIikpbCQkRE0lJYiIhIWgoLERFJS2EhIiJpKSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0lJYiIhIWgoLERFJS2EhIiJpKSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0lJYiIhIWlkNCzN7jZltM7MdZvbpYaa/w8w2hY8HzWxVNusREZGxyVpYmFkM+AZwCbASuNLMVg5ptgt4ubufAfwdcFO26hERkbHL5p7F2cAOd9/p7r3A7cBlqQ3c/UF3PxYOPgzUZ7EeEREZo2yGRR2wN2V4XzhuJO8DfjvcBDO71szWm9n6xsbGCSxRREQykc2wsGHG+bANzV5BEBafGm66u9/k7mvdfW1tbe0EligiIpmIZ3HZ+4AFKcP1wIGhjczsDOBm4BJ3b8piPSIiMkbZ3LN4DFhmZkvMrAC4ArgztYGZLQTuAN7p7s9msRYRERmHrO1ZuHvSzK4H7gZiwC3uvsXMrgunfxv4W6Aa+KaZASTdfW22ahIRkbEx92G/RshZa9eu9fXr10ddhojIlGJmG8bzz7iu4BYRkbQUFiIikpbCQkRE0lJYiIhIWgoLERFJS2EhIiJpKSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0lJYiIhIWgoLERFJS2EhIiJpKSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0lJYiIhIWgoLERFJS2EhIiJpKSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0lJYiIhIWgoLERFJS2EhIiJpKSxERCQthYWIiKSlsBARkbQUFiIikpbCQkRE0spqWJjZa8xsm5ntMLNPDzPdzOxr4fRNZrYmm/WIiMjYZC0szCwGfAO4BFgJXGlmK4c0uwRYFj6uBb6VrXpERGTssrlncTaww913unsvcDtw2ZA2lwHf98DDQKWZzctiTSIiMgbxLC67DtibMrwPOCeDNnVAQ2ojM7uWYM8DoMfMNk9sqVlRAxyJuogMqM6JNRXqnAo1guqcaCvGM3M2w8KGGedjaIO73wTcBGBm69197fjLyy7VObFU58SZCjWC6pxoZrZ+PPNn8zDUPmBBynA9cGAMbUREJGLZDIvHgGVmtsTMCoArgDuHtLkTeFd4VtS5QIu7NwxdkIiIRCtrh6HcPWlm1wN3AzHgFnffYmbXhdO/DdwFXArsADqBqzNY9E1ZKnmiqc6JpTonzlSoEVTnRBtXneZ+3FcEIiIiL6AruEVEJC2FhYiIpDWlwiJd9yFRMLMFZnaPmT1tZlvM7KPh+BvNbL+ZPRk+Ls2BWneb2VNhPevDcbPM7A9mtj38WRVxjStSttmTZtZqZh/Lhe1pZreY2eHU63xG235m9tfhe3Wbmb064jr/2cyeCbvV+S8zqwzHLzazrpTt+u2I6xzx95xj2/PHKTXuNrMnw/GRbM9RPocm7v3p7lPiQfAl+XPAUqAA2AiszIG65gFrwuflwLME3ZvcCHwy6vqG1LobqBky7p+AT4fPPw18Keo6h/zODwKLcmF7AhcAa4DN6bZf+B7YCBQCS8L3bizCOi8G4uHzL6XUuTi1XQ5sz2F/z7m2PYdM/zLwt1Fuz1E+hybs/TmV9iwy6T5k0rl7g7s/Hj5vA54muAp9qrgMuC18fhvwl9GVcpyLgOfc/fmoCwFw9/uAo0NGj7T9LgNud/ced99FcMbf2VHV6e6/d/dkOPgwwTVNkRphe44kp7bnIDMz4K3AjyajlpGM8jk0Ye/PqRQWI3UNkjPMbDFwJvBIOOr6cLf/lqgP74Qc+L2ZbQi7UAGY4+G1LeHP2ZFVd7wreOEfYa5tTxh5++Xy+/W9wG9ThpeY2RNmdq+ZvSyqolIM93vO1e35MuCQu29PGRfp9hzyOTRh78+pFBYZdQ0SFTMrA34OfMzdWwl60D0JWE3Q19WXo6vuz8539zUEvf1+yMwuiLqgkVhwIecbgJ+Go3Jxe44mJ9+vZvYZIAn8MBzVACx09zOBG4D/NLNEVPUx8u85J7cncCUv/Icm0u05zOfQiE2HGTfq9pxKYZGzXYOYWT7BL+iH7n4HgLsfcvd+dx8AvsMk7TKPxt0PhD8PA/9FUNMhC3v6DX8ejq7CF7gEeNzdD0Fubs/QSNsv596vZvZu4HXAOzw8cB0ehmgKn28gOHa9PKoaR/k95+L2jANvAn48OC7K7Tnc5xAT+P6cSmGRSfchky48Zvld4Gl3/0rK+NSu1t8IRNpTrpmVmln54HOCLzw3E2zDd4fN3g38MpoKj/OC/9hybXumGGn73QlcYWaFZraE4J4tj0ZQHxCcSQh8CniDu3emjK+14N4zmNlSgjp3RlPlqL/nnNqeob8AnnH3fYMjotqeI30OMZHvz8n+1n6c3/hfSvAt/3PAZ6KuJ6zppQS7b5uAJ8PHpcB/AE+F4+8E5kVc51KCsx82AlsGtx9QDfwJ2B7+nJUD27QEaAIqUsZFvj0JwqsB6CP4z+x9o20/4DPhe3UbcEnEde4gOEY9+B79dtj2zeH7YSPwOPD6iOsc8fecS9szHH8rcN2QtpFsz1E+hybs/anuPkREJK2pdBhKREQiorAQEZG0FBYiIpKWwkJERNJSWIiISFoKC8kKM3Mz+3LK8CfN7MZJrmGdma0Nn9812NPqOJZ3oZn9+gTG32xmK8e4rvlm9rMRpv35dQ0zrdbM+szsA2NZ7yj1rLYc6DlZoqOwkGzpAd5kZjVjmTm8OnbCuPul7t48kcvMYJ3XuPvWMc57wN3fMoZZLyfoKPDKsax3FKsJztuXGUphIdmSJLjn78eHTjCzRWb2p7CzuD+Z2cJw/K1m9hUzuwf4Ujj8rbCf/p1m9vKwc7mnzezWlOV9y8zWh/34f364Yiy450CNmV1n/3OvgV3hujCzi83sITN73Mx+GvaxM3gPlWfM7L8JunbI2JA9m6vN7Nmwc7nvmNnXU17zW1LmaQ9/Lrbw/glmVmxmt4fb68dA8SirvRL4BFBvZnXh/LFwPZstuJ/Jx8PxHzGzreFybw/HlYbb+DELOsO7LOwx4f8Abwu329vC38XgdnxisHcAmcYm6ypIPWbWA2gHEgT30KgAPgncGE77FfDu8Pl7gV+Ez28Ffk3Yr344fDtBp2eXAa3A6QT/5GwAVoftZoU/Y8A64IxweB2wNny+m5R7eQD5wP3A64Ea4D6gNJz2KeBvgSKCq56XhTX8BPj1MK/1whHGrwPWEtxrYA9QS3AvlgeAr6e8xrekbrfw52LC+yIQdEh3S/j8DIIgXjvM+hYA28Pn/wjcED4/C/hDSrvK8OcBoHDIuH8ErhocR9BjQinwnsGaU36H54fPywjvlaHH9H1oz0KyxoNeL78PfGTIpPOA/wyf/wdBVwWDfuru/SnDv/LgE+kpgq6gn/Kgk7ktBB+oAG81s8eBJ4DTCG7sks6/Av/P3X8FnBvO84AFdzx7N8ENl04Bdrn79rCGH2Sw3OGcA6xz90YP7sXy43QzDHHB4LrdfRNBlw7DuYIg0CAI2cFDUTuBpWb2b2EfUYO9kW4CfmhmVxEEEAR9hn063A7rCAJz4TDregD4ipl9hCBoksO0kWlEYSHZ9lWCPn9KR2mT2udMx5BpPeHPgZTng8PxsBO0TwIXufsZwG8IPuBGZGbvIQiDwUNWRvCf9+rwsdLd3zdMbeMx0nKShH+HYWdwBSc4f6orgfeY2W6CfpVWmdkydz8GrCL48P8QcHPY/rXANwj2PDaE3xMZ8OaUbbHQ3Z8+rhj3LwLXEBwSe9jMTsmgPpnCFBaSVe5+lOC/3feljH6Q4L9ggHcA/z2OVSQIAqbFzOYQdG0+IjM7iyBcrgr3UCD4Qvh8Mzs5bFNiZsuBZwhuZHNS2G6sXxo/AlxoZtUWdCN9ecq03QQf1hAcassfZv77CLYTZvYigkNRQ1/XCoLDaHXuvtjdFwNfIOhZtAbIc/efA58D1phZHrDA3e8B/hfBIacy4G7gw2FwYWZnhqtoI7hd5+D6Tgr38r4ErCfYC5NpbELPOBEZwZeB61OGPwLcYmZ/BTQCV491we6+0cyeIDgstZPg8MhorgdmAfeEn4fr3f2acG/jR2ZWGLb7rLs/a8EdBX9jZkcIQu1FIyz3IjPblzL850Bw9wYLTht+iKD30scJvl+B4J4NvzSzRwl6BR26ZwXBDYG+Z2aDPYoO15X0lQT3KEn1c4LDUXeG8w/+c/jX4fp/YGYVBHsT/+LuzWb2dwR7g5vCwNhNcA+Me/ifw1NfAF5qZq8A+oGtvPDOezINqddZkUkWBtNad78+XVuRXKHDUCIikpb2LEREJC3tWYiISFoKCxERSUthISIiaSksREQkLYWFiIik9f8B3wcRUiCiMfwAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] @@ -140,7 +140,7 @@ "\n", "# Note that the orange line lies right on top of the blue line and they are basically\n", "# indistinguishable. This is expected, as deciding saving and risky share simultaneously\n", - "# should give the same result as when doing it sequentially." + "# should give the same result as when doing it sequentially.\n" ] }, { @@ -168,7 +168,7 @@ "print(\"as market resources approach infinity, see\")\n", "print(\n", " \"http://www.econ2.jhu.edu/people/ccarroll/public/lecturenotes/AssetPricing/Portfolio-CRRA/\"\n", - ")" + ")\n" ] }, { @@ -188,7 +188,7 @@ } ], "source": [ - "print(\"\\n\\n\\n\")" + "print(\"\\n\\n\\n\")\n" ] }, { @@ -201,7 +201,7 @@ "# Make another example type, but this one can only update their risky portfolio\n", "# share in any particular period with 15% probability.\n", "init_sticky_share = init_portfolio.copy()\n", - "init_sticky_share[\"AdjustPrb\"] = 0.15" + "init_sticky_share[\"AdjustPrb\"] = 0.15\n" ] }, { @@ -214,7 +214,7 @@ "output_type": "stream", "text": [ "Now solving a portfolio choice problem with \"sticky\" portfolio shares; this might take a moment...\n", - "Solving an infinite horizon sticky portfolio choice problem took 66.25000286102295 seconds.\n" + "Solving an infinite horizon sticky portfolio choice problem took 41.3579957485199 seconds.\n" ] } ], @@ -244,7 +244,7 @@ " \"Solving an infinite horizon sticky portfolio choice problem took \"\n", " + str(t1 - t0)\n", " + \" seconds.\"\n", - ")" + ")\n" ] }, { @@ -261,7 +261,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -277,7 +277,7 @@ "print(\n", " \"Consumption function over market resources when the agent can adjust his portfolio:\"\n", ")\n", - "plot_funcs(StickyType.cFuncAdj[0], 0.0, 50.0)" + "plot_funcs(StickyType.cFuncAdj[0], 0.0, 50.0)\n" ] }, { @@ -294,7 +294,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD4CAYAAADiry33AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAyrUlEQVR4nO3dd3zUVb7/8deZyaT3Rnol9FADAUJHVIoiXvvad5e7u+79bXObd3fddde79erqoiIqAqKCSu+ChR4ghNB7CAkkpPcymXJ+fyRes4gygcAkk8/z8cgjM9/vd77zmRN8P76eOd9zlNYaIYQQrsvg7AKEEELcWBL0Qgjh4iTohRDCxUnQCyGEi5OgF0IIF+fmrDcODQ3VCQkJznp7IYTokvbv31+mtQ5rz2ucFvQJCQlkZWU56+2FEKJLUkqdb+9rpOtGCCFcnAS9EEK4OAl6IYRwcRL0Qgjh4iTohRDCxUnQCyGEi5OgF0IIFydBL4QQXYTVbr2m1znthikhhBCOqTZXs/z0clZlL76m10vQCyFEJ3Wm8gzvnniXg7tWMWlvE88dhVXXcB4JeiGE6ETs2s62C9t478gi2LqHafvhvgI7GDWB8Q1wtP3nlKAXQohOoLa5lpVnVrJm7yL67SzkyQMQUGfH6GsjZHA9AbeNo6TnD2DDuHafW4JeCCGcKK86j/eOv8uRrcuZsKeR353UGG3gHdlEcDqYbnuMU8a72ZTVSOWe+mt6D4eDXillBLKAi1rrGZftU8BLwDSgAXhca519TRUJIYSL01qzq3AX7x9aCFt2MnW/ZtYljTZpgpPrCRoRQVXab9l3KZXTm8uxWsoIj/dj0N1J8Hr73689V/Q/Ao4D/lfYNxVIaf1JB15r/S2EEKJVg6WBNWfXsC5zAX22nuexHPBt1BgDrIQNq8d78gTOBn2Xbcd9KV1Zi5t7OSkjemCO9+aj3BI+/ewaOuhxMOiVUjHAdOB54KdXOGQmsEhrrYFMpVSgUipSa110TVUJIYQLuVh3kSXH3+fI5qWMz6znl6c1CvCNbiSkHzRmfJfDjbdyMqeB5iYbwVF2hv9HMgcNFp7LLiDvaAOhvu78cGJPnv5L+9/f0Sv6fwK/APy+Zn80UNDm+YXWbf8W9Eqp2cBsgLi4uPbUKYQQXYrWmqziLJYeWIje9Dm3ZdmZVqbRnpqQPnX4p0WRn/g7NhUkU/RZHUa3enoOC8e7XwCrC8r4w7ZjNFnsDIsP4idTenH7gAg83Iw8fQ21XDXolVIzgBKt9X6l1ISvO+xKn/MrG7SeB8wDSEtL+8p+IYTo6sw2M+tz17Nh+3x6fXaWBw9pvM1gDLYSPqIWPXoqx9we5sRxE00FVgLCbaTPSibfH17Lucj+FefwNBm4a3A0j4yKp39UwHXX5MgVfQZwp1JqGuAJ+CulFmutH25zzAUgts3zGKDwuqsTQoguoqShhA+OL+XohncZs7uGH+VqlALfmEaC+youpf6AbZUZFOQ0YTAoEgcFEZkWxpayKv657zRldWYSQrz5zfS+3DsslgBvU4fVdtWg11r/Gvg1QOsV/dOXhTzAauCHSqkltHwJWy3980KI7uBI2RGW7J+Pde1mpmRZmVwJdi8I61eLaVAip8J+yKd5UdRnWfAN0oy4I5GGaE/eP1zI5mXZ2LVmUu9wHhkVz7iUMAyGK3WQXJ9rHkevlPoegNZ6LrCelqGVZ2gZXvlEh1QnhBCdkMVu4ZPzn7Dh8zdJ2HyMu49ovJrBEGalx8g6qgf+B1nWmeSdM6KLIK6fP+n3RbC3qYFf78nnzPY6Ar1NfGdsIg+nxxMb7H1D61UtA2VuvrS0NJ2VleWU9xZCiGtR1VTFRyc+4MiahYzcWcmgPI3dCH5xDfj29iQv/imOlgyiptKGl5+JvqMj8ekXyEcnLrE8+yJ1Ziup0QE8OiqeOwZF4WkytrsGpdR+rXVae14jd8YKIcRVnKk8w9Ks+TStWsfkrGYyqsDmAyGpNTT3HcJx78c5UxCC/aQmsqcvw++K4pynnX/tLWDX2ydxNxqYPjCSR0bFMyQ2kJZ7TG8eCXohhLgCu7az/cJ21n8yl+iNB5l+VONhAXrYCBvdTFHy/XzacAvlJUbcPY30HxtJdFoYG/LL+PunxyiqbiIqwJOf39ab+4fHEurr4bTPIkEvhBBt1FvqWXlyOYeWv0XajhIez9fY3MA3vhFTzzBOh32XbcU9sRZAaKwvE26PpiHSg3ezClj/9lmabXbG9Azl93f2Z3KfcNyMzl/fSYJeCCGAgtoCPtr3NjXLVjBxXxNDa8Dqpwgc1EhlUgb7DfdxqdwPY7GBlGHhpGREkllVy68yz3F4XTW+Hm48lB7HwyPj6Rnu6+yP828k6IUQ3dYXd6+u//g1QtZlMumoxt0K9kgb/gM9yIu8l721o2mqNBAQ7kXGPdH49Qnkg8MX+dn7+6hqsJAS7ssfZ/Zn1tAYfD06Z6R2zqqEEOIGMtvMbDizluxlrzPw8wLuywebm8IroQlrUm/O+D5EfkUMqlyROCiU/mOjyHOzMWd3Pp98chiDUtzarwePjkpgZFLwTf9ytb0k6IUQ3UZZYxnL9y2g7IMljN1bz4M10Oyv8B4CxdET2W+bTl2jJz42d4ZPjyJueDgbzpby9/WHyS2rJ9TXnacm9OSh9DiiAr2c/XEcJkEvhHB5x8qPsW7jHHxWbyPjqA13K1iiNW4DIzgfdCe76gZhr1PE9AlizPhoLD08WLw3n+Wv7qCh2caQuEBevH8Q01Ij8XBr/9h3Z5OgF0K4JJvdxmd5W9j7wRx6f3KGGQVgdVMYkw00xg7mhPssKhuC8bC5kTopkj4ZkWRV1PKbXbnszi3H3c3AnYOieGxUAqkx1z+xmDNJ0AshXEptcy2rs9/l4vsLGbW7ilk1YA4woIf5UxY2iVOW8VitboRH+zFpfAxBfQNYllPIzxfuoai6iehAL341tQ/3pcUS7OPu7I/TISTohRAuIb8mnzWb5mBctpFRRywMtUJDjImmQT3J9ZnGpaYkjDZFyogeDBgfQ5HRzhu78li7Lodmm52xKaH84c7+TO7bA+MNmFjMmSTohRBdltaafRf3sOODF4nbeJhJ+Rqrm8LSy4+yyHROqdtosnoT4O9FxoxoEtPC+SS3jNlrD3HwQjU+7kYeGBHLo6MSOt3Y944kQS+E6HLMNjMbDy0j953XGbqzhKnV0OBvpG54HMWBEzlvGYqyKxIGhpI6PgZDhCfv7ctnyb+2U17fTHKYD8/N7M+sIdH4eXbcvO+dlQS9EKLLKGssY+2W1zAvXc6Ig030skBVnC8VAweS6zGFGms4Xh5G0qbE0jcjkiNV9Ty/6xwfH7sEwC19W8a+Z/QM6fRj3zuSBL0QotM7XnqUz5b+L6Hr9pB+zo7VTVHdN5aSsJGc0xnYtInIeH9GToylR98gVh8u4reL9nKquGXe99njknl4ZBwxQTd23vfOSoJeCNEp2ew2tp/cxNGFL9Pv8/NMrILaAE+KR/SlxG8CpbaemNyg78hoBoyPpsZD8c7u83y4NofaJiv9o/z52z0DufMa5313JY4sDu4JbAM8Wo//SGv97GXHTABWAedaNy3XWj/XoZUKIbqFeks9G7a+ReXixaTtr2WSBUoTIigYOJR843jM2pegEBPjJiWSMrwHuwsq+emmY2w9VYqbQTEtNZLHRicwNO7mz/veWTlyRW8GJmmt65RSJmCHUmqD1jrzsuO2a61ndHyJQoju4EJNAVs+/AdeKz5l4BkrFqPiUv9UGkLSuaiHYFCaxEHBpE5MwCfWh2XZF/mvV3eQV95AuJ8HP74lhYdGxBHu7+nsj9LpOLI4uAbqWp+aWn+cs/6gEMKlaK3JOZ/J/gX/IOHjY6RXQHWgH+fSh1PmM4Zaew98vO0MnxBP/7ExXDQ388quPFYsvkijxcaw+CB+emtvbu8fgbub8+d976wc6qNXShmB/UBP4BWt9Z4rHDZKKXUQKASe1lofvcJ5ZgOzAeLi4q65aCFE12axW/gscwkXFrzBwD2ljDZDUWIyJ/sP55IxHRvuRMe5MXpKH2JTg/nsVCnf/iCbzNwKPNwMzBwcxaOjEhgQ3bWnJrhZ2rU4uFIqEFgB/JfW+kib7f6AvbV7ZxrwktY65ZvOJYuDC9H9VDVV8fHKF7EvXU3qiSasBhMFqcOpDRpJhU7G5Gajz4gwBtySAgEm3t+bz7uZ5ylsnZrgkVHx3J8WS5CLTE1wLW744uBa6yql1OfA7cCRNttr2jxer5R6VSkVqrUua8/5hRCu6VzJKXYs+DPha/eSWmKnMjCMkyNvp8JzJGbtR1CghXG3JNI7I5ZT5fX8z84zrD5YSLPVzujkEJ69sz+3uODUBDeLI6NuwgBLa8h7AbcAf73smAigWGutlVIjAANQfiMKFkJ0DVpr9h3ZxMm3XqLX1jyGNSrykwZwsM8oyg2pKCCpl4HUaYMJSw5g49Fifv/2Xvafr8Tb3ch9aTE8NiqBlB5+zv4oXZ4jV/SRwMLWfnoD8IHWeq1S6nsAWuu5wD3A95VSVqAReEC3p09ICOEymm3NfLJxLtXvvEv/QzWkGrw4O2AKtYEjqScCLw8zaaOD6H9rfxrc4P09Bbz7UTYltWbiQ7z57Yx+3DMshgAv15+a4GZpVx99R5I+eiFcS1lNMZ+/+xe8lm0h6YKV8sAYCvqOp9pjGDY8iAyvJ/W2/iSlJ3C4qIYFO8+x7nARFptmfK8wHh+dwPheYRike+Yb3fA+eiGEuNzpvGz2v/EXYj8+Qt86A3mJQ9k3bgy1hp64GSz07qtJvXMoftF+rDtUxNNzd3HwQjW+Hm58Kz2eR0fFkxTmujNHdgYS9EKIdtNak7nrAwrmz6XXnkv0MQRwqt8dHAtMp5lA/L1qyRjjQZ/bx1Jts7Eo8zzvvbOPsrovZ468e2gMvh4SQTeDtLIQwmGNzQ1s/eifNL+/jJ6nG7AE9+Tw8O9Q6zEQjSI+opLUqdHEpqWQXVDF06sOs/HIJWxaM6l3OI+NTmBsSqhMTXCTSdALIa6qtDyfHW8+T+DqncRUGsmLH8HuceNoMkTjYWhgUL9aBtw9Ho+wQNYcLOSpV3dy5GINfp5uPD46gUdGxRMf4uPsj9FtSdALIb7WyeM7OTL3b8R/foo4Fcrp3ndzMnUENrwJ8S5hVIaVlOm3UWa2Mi/zPO/vzaaivpmUcF/+dNcAZg2Jxke6Z5xO/gJCiH9jt9vZu2URxfPfIulgOaHBfTk89CkaPPpgwE5SRBGpUyOJGD6B/flV/Hh5S/eMXWtu6duDx0cnMDq5ey3s0dlJ0AshAGhsrGXH4r+hl64lsgiMsaPYPXY8FkMY3sYq0npfZMDdkzH2mMyag4UsmLOTo4U1+Hu68e0xiTwyMp7Y4O65sEdnJ0EvRDdXUnSWvXP/RPD6vQTaenAmeRZnk9OwK08ivM+TOrKc5DumU9KseDXzPO+//SkV9c306uHL87Naume83SVKOjP56wjRTZ0+8Bkn5v6D2J15+AemcqL//6PRMwUjzfQKP0vqrX0IG/0YWflV/L8VJ6R7pguToBeiG7Hb7WStfpPyhQuIPt2MIXo0maOfwGYIxtdYxsieR+l31yRUzJSvdM88mZHAo6MSpHumC5KgF6IbaKqvYdf8P2P8cD1eDeFUx0/jXEYaWrkT7XmS1LQKEu+cRYn245XM87y3+Mvumf+ZlcpdQ6Kke6YLk7+cEC6sLP8UWa/9iaCPszF6D+Rs4g9p9E7GjSb6BeeQOjmR4HFPkF3YyI/W5bHhcBE26Z5xORL0Qrigs3s2c3ruC4Rll2HvkcGBoc9hMwbib7zE0Lid9LljDCrladYdvsSC17M4dKH6/25uenRUAnEh0j3jSiTohXARdquVnBVvUrFwIf6X/KiJm8DZkcNAmYjxOMzA1JPE33E3ZV538+qefN5b/tn/zT3zx7sGcLfc3OSy5K8qRBdnrq1i75t/QX24CauxHwXxT9IQk4yRRgb47yR1TBjBk79FToUbP/3sHOsOf4rV3jL3zOMZCYzpKXPPuDoJeiG6qMr8M2S/8kd8PjlOXfBozvf7LTa3QPyMRYwJX0ef24ZhGPJrNpyo5O2FJzmQX/V/UwM/PjqBhFCZe6a7cGQpQU9gG+DRevxHWutnLztGAS8B04AG4HGtdXbHlyuEyM/8lFOv/QOfYxYqoydwYthDLd0z7jkM6nmR+GnTqejxPG/sK+Cd/91JcY2ZxFAffn9HP+5Ji5WpgbshR/7iZmCS1rpOKWUCdiilNmitM9scMxVIaf1JB15r/S2E6ADaZuPoircpfXsBhpo4CmPvonZYT4w0McDnU1KHGQm+5VGOWiP5xc48Vh38jGarnbEpofzl7oGyclM3d9Wgb137ta71qan15/L1B2cCi1qPzVRKBSqlIrXWRR1arRDdjLWulqw3/4pl2WfUeQ2jIObHWGKD8TFcIiNwKX3HJ2Mc9VO25NuZvyKPvefO4mVqWVj78dEJ9AyXhbWFg330rQuD7wd6Aq9orfdcdkg0UNDm+YXWbf8W9Eqp2cBsgLi4uGssWQjXV1dwjuxX/oTamk9p+Dgu9f0t2uBOpPtBhkSsIX7KJGp7/Z0FOaUsevUoF6saiQ704plpfbg/LY4Ab1lYW3zJoaDXWtuAwUqpQGCFUmqA1vpIm0Ou9P+EX1l1XGs9D5gHLYuDt79cIVzbpX3bOf7qP1CnPbkQM5HqQd9CYaaP12cM6l1CyOSHOOP/JL/dlc/y1btotNhITwzmtzP6MaVfD4zSPSOuoF3fymitq5RSnwO3A22D/gIQ2+Z5DFB43dUJ0Q1om42za5dQ8NYCmht6URDzLcwDQnE3lDHKZzH90nxxH/sdttZG8Pb2PLad2oG7m4GZg6J4PCOB/lEBzv4IopNzZNRNGGBpDXkv4Bbgr5cdthr4oVJqCS1fwlZL/7wQ38xWV8fhRS9T9dFWqnxGUhTxU+xGD4JMx5gYuITEsYNoGvoHPjhtY8F7eeSWFRDu58HPpvTiofQ4Qnw9nP0RRBfhyBV9JLCwtZ/eAHygtV6rlPoegNZ6LrCelqGVZ2gZXvnEDapXiC6vqegiB179Hxq3F1MSNp7yXr8ELCR47mBE5H7CJtzFhfjX+fP+UpbMOUZtk5VBsYG89MBgpg6IxN3N4OyPILoY1TJQ5uZLS0vTWVlZTnlvIZyh6vABDs75G+YzvlyMmkCDTyQGVc0gnw0MTi7Ga/yT7PMYzfxd+Xx87BJKKaYOiOCJjESGxQc5u3zRSSil9mut09rzGrlzQogbSNvtFG5Zy8k33qa+vjeFkQ9hTfHB0+0ck3xepteQQGwjv8ea8hjmbznH0cK9BHqbmD0umUdHxRMV6OXsjyBcgAS9EDeA3Wzm9PtvUbD0Uyq90ikJ+wGEKEI89zHOfxOR6SOoGPhX/nVSsXhxPmV1B0kJb5n7fdaQaLzcjc7+CMKFSNAL0YEsFRUcnvcCpZ9eoCR0HDXxPwAaSfJZR0boHvzH3MvxmIW8kFXF6rm5NNvsTOwdxhMZiYxNkcnFxI0hQS9EB2jIPUPOnP+l8pgHRZFjMSdNwmAoZpjvGwyNLcRtzGw+Mf6UtzIvkrnuCF4mI/cPj+XxjASSw3ydXb5wcRL0QlwjrTWVe3eR8+obVFUmUtxjJvYEdzxMx5ji+yopffxoHP59FpensGDzefIrDsvdq8IpJOiFaCdttXJx3QqOLVxPuXEoFSGPgqeFQJ+d3OqzmrAh6RT1+wt/PO3DB0sLqDMfJy0+iF/e3ofb+vfAzSjDI8XNJUEvhIPs9fWcXvwWZ9adoDQgg/rwR4Aa4vyWckvAdjxH3ENO5GL++0ATmxcWY1SK6QMjeTIjkUGxgc4uX3RjEvRCXIWlpIRDc1/hwr4misNGY4kagDJcYGDAvxgdkose+R3Wm37C63tKOfrpeQK9TfxgQjKPjEwgIsDT2eULIUEvxNdpPH2KfS/PpeRCKCVhGegoA24eR5jo9xF9YxR1ad9nbtUQFmy9SGntWXrK8EjRSUnQC9GG1prqzF3snfshZU29qQyaAeFmvHy3Ms17GRG9B3Ch7294Ji+S5asKMVtzGdcrjH/cm8g4GR4pOikJeiFo/YJ17Wpy3ttBqWcaDd53gmclIQFLuMNrE96DppIV9SY/P2Ji+4dleLgVcvfQGJ7MSCClhyzuITo3CXrRrdkbGji18B1ObCmgOHAE1uAZaJVPYtDL3OZ7EIY9whrPZby6v57Te6oJ9/Pg6Vt78VB6PME+7s4uXwiHSNCLbslaXk7OK/M5d9BKachQdGgymA4zNHgZIwMqqBs6m1caf8eCPWVUNhTTP8qfF+4bxIyBUTJ7pOhyJOhFt9KUm0vmvxZzsTCUqqBhEGLG4LOTWwI+pFePYC70/TY/Lx7Iqi0lWO1FTOnbg2+PSWREYrD0v4suS4JedAvV+7LZ9foqLpl70eAzBgKqcPdbxp0+qwhPHMaB2D/x4Okodm+swNu9jG+lx/P46AQSQn2cXboQ102CXrgsbbdzacMW9r6fSbH7QCzu49GGC/gHzeNuz8/w7DeDjQFv8sIhT3KP1xMZ0MCvpvbhwRFxBHjJ9ATCdTiylGAssAiIAOzAPK31S5cdMwFYBZxr3bRca/1ch1YqhIPszc2cfW8FOZvOUeY7GLvvGGwcIzZ8BTPcj9Oc+hDvsITXcixUN1oYFOPGyw8OYeqACEwyPYFwQY5c0VuBn2mts5VSfsB+pdRmrfWxy47brrWe0fElCuEYa20th+Yu5WR2AxX+/VB+gVg8skgN/YiJ3rWU9H2cP9Q8y9K9dVjtDdzWL4Jvj00kLT5I+t+FS7tq0Lcu8l3U+rhWKXUciAYuD3ohnMJcVMzeVz4gN8+XOt8klG8dNq9NjA1ezuDAAE4mPc5jFwezbUcd3u4NfCs9nicyEogPkf530T20q49eKZUADAH2XGH3KKXUQaAQeFprffQKr58NzAaIi4trd7FCtFV34iy7XltFQXUMTZ79UZ4l2P3fZ7rvWhIi+rCjxzNMOZ3AmR1NRAZY+fXUPjwg/e+iG3J4cXCllC+wFXhea738sn3+gF1rXaeUmga8pLVO+abzyeLg4lqV7cpm14LPKbKlYDX5gPUsxh4budvjcwISJrDS6x7+ejyEigYLqdEBfGdsItNSI6X/XbiEG7Y4uFLKBCwD3r085AG01jVtHq9XSr2qlArVWpe1pxghvo7WmgtrtpK5/CCl7n3QaiA242H8eqzmXrfD2JJn8pb9DeYe98JitzO5TzDfHSvj34UAx0bdKOAt4LjW+oWvOSYCKNZaa6XUCMAAlHdopaJbslssnFy8kQOfXaTSuxfKvTdmYybRkSu501hMWfJ9/KbmZ6w8pPA0GbhveAxPZiSSJMvzCfF/HLmizwAeAQ4rpXJatz0DxAForecC9wDfV0pZgUbgAe1on5AQV2BtaCTn9dUczWmizisWo3skTaYN9IlYxW0mGydiH+LholFk5WhCfT14+tZ4mX9GiK/hyKibHcA3/r+v1noOMKejihLdl7mskj2vrOH0OU+aPMMwGktp9PqAkaHrGOkTxM6wJ5iUN5D8g9Crhw9/uyeJmYOj8HCT+d+F+DpyZ6zoFGrPFbL7tQ3klYdiMcVgVHk0+q/kVv8t9AlKYZXP0wzJ7UntJRibEsof702S+d+FcJAEvXCq8kNn2Pnm51xsjMZuTMRgP0JTyMfM9NpNj7B0Fqg/cde5KAzKwJ2Do/jOmCT6Rfk7u2whuhQJeuEUhdsOsuu9LIp1HErHY7dlYYtazz2mY7hFTObFxhdYci4UP083vjsujidGJ8r6q0JcIwl6cdPY7XZy1+xh79qTVBrjMNgiseqtuMev4wFDIVUR0/l1+ffYdiaQ6EAvfjcjkfuGx+LrIf9Mhbge8l+QuOHsNjvH3tvK/s8LqTNF4mYPpMmwhuCEdTxsqOdk6Cy+VTSWk6d9SY0O4OUHk5g2IAI3ucFJiA4hQS9uGGuThZz5Wzi0v45GUwjudjfqDR8Q13MjDxsM7A74DyZdTKf0rBcTe4fx+3HJjEySG5yE6GgS9KLDNdU0kPX6Zo6f0DSb/PGwFlPju5p+iZ/ykDGANZ6PMOziUOw1nswaEs13xibKAttC3EAS9KLD1JdUkzl3M2fyPbG6+eHZfJKqgHdIT9jJfe7RLFTfY1DxQLw9PXlyfMsKTuH+8gWrEDeaBL24blXnS9n9+mfklfljV4F4mA9SGryFSQnZ3OmZwkvmn/Ddkn5EBfrwjHzBKsRNJ/+1iWtWeqKQXW9u52JNMBCEqXEfxbEfMy3hGKHeQ3i+5hk2VSXTLzKAfz6QJDNICuEkEvSi3S5m57F74R6Km0Iw2AMwNG2jPPFj7vLMxeCTwe/Kf8++6njGpoTyzrgkxvSUO1iFcCYJeuEQrTXnd54ic0kO5dYw3Cw+KMsmqpM+5h6PS5R7TeQnJd/hbF00MwZGsm5cEv2jApxdthACCXpxFVprzmw+yp6Vx6m2h2Bq9sBuW0l1yhbuN1Zy2v1WHi2dRGVDDx4YFcv8MYnEBHk7u2whRBsS9OKK7HbNibU57FufSx1BeDSBRS2luecn3GtoYo/hdv6jchLaJ4zHpiTwyMh4gmSKYCE6JQl68W9sNjtHlmWT/UkBDSoArwYzZrd3sPfeyr3Y2ainMa16AgHBofxoZhL3psXiaZIpgoXozCToBQBWi42DS/eSs72EJuWHd0MNjR4fQb8d3I+JD5rv4JaGcSRFhfP89GSmyhQFQnQZjiwlGAssAiIAOzBPa/3SZcco4CVgGtAAPK61zu74ckVHs5htHHgvk4O7K2g2+OBTV0qt72LcBmRyv/bl7cZ7mWgew4iekbwxPpmMniEygkaILsaRK3or8DOtdbZSyg/Yr5TarLU+1uaYqUBK60868Frrb9FJmRssZC/O5HBWDRaDF751Fyjz/xjPgVncrwN5te5hJlpHcduAGJaNTyY1RkbQCNFVObKUYBFQ1Pq4Vil1HIgG2gb9TGBR6zqxmUqpQKVUZOtrRSfSWNfM/kW7OZpTj9XgiV9tLqVBm/AfnMO99jBerHmCv5POrGFxbB6XRGKoj7NLFkJcp3b10SulEoAhwJ7LdkUDBW2eX2jd9m9Br5SaDcwGiIuLa2ep4no01jazb8Eujh1uxGbwwL/mJOdDNhEw5AizbFH8o+o/+atpOA+PSWBbhsxBI4QrcTjolVK+wDLgx1rrmst3X+El+isbtJ4HzANIS0v7yn7R8RpqzOxdsIvjR8zYlRsB1Uc5F7aJ4KHHmG6J44Wqp/in1zCemJLEiyPjCfAyObtkIUQHcyjolVImWkL+Xa318isccgGIbfM8Bii8/vLEtaqvNrP37V2cON6MHSMBVQc5G76J0GEnubU5mf+t/AmFgUP5zzuSeEOGSArh0hwZdaOAt4DjWusXvuaw1cAPlVJLaPkStlr6552jvqqJvQt2fxnwlQc422Mj4WmnmdjUixcrf059+BC+Pz2ZGQOjZJIxIboBR67oM4BHgMNKqZzWbc8AcQBa67nAelqGVp6hZXjlEx1eqfhG9VVN7FmQycnjZuwYCazYz5mIjwlPO01GYx9eqvwVxpihPDWxJ5P7hGMwyBBJIboLR0bd7ODKffBtj9HAUx1VlHBcfbWZvQsyOXHMjEYRULGfsxEbCR9+lhEN/fhX5TMEJQ/j1xN7MipJxsAL0R3JnbFdVENNM3sWZnLiSCN2jASVZ3EmYiOhw88ypH4Acyp/Q3zf4fzPxJ4Mjg10drlCCCeSoO9iGuua2btoL8cO1rcGfDZne2wgZEQuA+sG8FrV7+g7cAQvT+hJ7whZh1UIIUHfZTTVW9j3bhZH91djw42gihxyQ9cTOOIsfetSebP6WYYMS2fe+GTiQ+QmJyHElyToOzlzo5X9S7I5lFmBTbkTVHGEvJD1BAw/Te+6/syv+T3pI0bx9vgkIgO8nF2uEKITkqDvpCxmGweWHeTAtmKseBBUeYz8gPV4p50kub4/79T9noxRo1k0JokwPw9nlyuE6MQk6DsZq8XGodVH2b/5As14Elh5mkLftbgPO0FSfV8WN/6BCWPHsDgjgUBvWehDCHF1EvSdhM1m59imU+xZexaz3YuAqvPUeaylZvBh4pt6s7TpWSZNHM/iUfH4e8o0BUIIx0nQO5m2a05uO8fuj47RYPXGr+YSjYY1VA3MIcqczHLrs0yePIFF6fH4eMifSwjRfpIcTqK1Jm9/ITsW51DT5IVPXSVG2yLK++0jxhbHCvtvmDxlMgtGxOHlLvPQCCGunQS9E1w8UcaOt/ZSVuuJZ2Mdno1LKOm3iyQVwRr1SwKn3Mb8EXEy0ZgQokNI0N9EZRdq2D5vN4UlJtzNZnxrVlLYdys93QPJNPyUiMnTeV1mkhRCdDAJ+pugpryRnW/uJjdX42azEFSxntyULfRK9qCA7xMz+S7mDI/Fw00CXgjR8STob6Cmegt7FmdxNLsWpTXBZVvJjd9IQJKFcvujNE26jxdHxEnACyFuKAn6G8BmsXNg5WH2f1KIVZsIKcsiL2wNfmlV1NgeoGncw/w5PUG6aIQQN4UEfQfSds3Jrbns/PAETXYvAivPUOKzkoZhBTRaZ2HO+DZ/GJ0sAS+EuKkk6DvIhWMlfP7GXqobvfGtLcOgV1CTeoRG++34jJrDLzNS8HaX5hZC3HyOLCU4H5gBlGitB1xh/wRgFXCuddNyrfVzHVhjp1ZVXM/nr+7gYrEJD7MZ77qPqOq3E6txFD7DP+K/xvfHT+5kFUI4kSOXmAuAOcCibzhmu9Z6RodU1EWYGyzsensPxw81YrDbCSpfQ2HKJtwTe2McspDHJqfJXDRCiE7BkaUEtymlEm5CLV2C3Wbn8NpjZK7Px4o7wWV7uBi1EtsQf0x9/smDt4+X2SSFEJ1KR3Uaj1JKHQQKgae11kevdJBSajYwGyAuLq6D3vrmyc8p5NO3sqi3+BJQnU+510dUDanCGPtzZt55BzFB3s4uUQghvqIjgj4biNda1ymlpgErgZQrHai1ngfMA0hLS9Md8N43RXVJPZ/M2UpRiSeejU24m9+jqs9h7BH/yS13PU5KhL+zSxRCiK913UGvta5p83i9UupVpVSo1rrses/tbJZmG5kL93A4qw5lVwRWrKY85WPsEXcw7q45DE0IdXaJQghxVdcd9EqpCKBYa62VUiMAA1B+3ZU5kdaa09tz2freUZrxJagih5IeyyhN78WQqWsZNyARpZSzyxRCCIc4MrzyfWACEKqUugA8C5gAtNZzgXuA7yulrEAj8IDWust0y1yusrCWTf/8lPIaP3zqqrEa3qB0cAPJ415hWsYwjAYJeCFE1+LIqJsHr7J/Di3DL7s0a7ONHfN3cuxAEwabG37VH1LRew89hv+Gu6bOlDnhhRBdltyqCeRm5vHpghzM+BNYkU151AqMo2fyrXteJMzf09nlCSHEdenWQV9X2cimf2zkUnkAXg2NGNV8Kkb6MfX+NaTEhDu7PCGE6BDdMui1XbN/WRb7NpcA3vhXrqW8z16G3/UyGcOGOrs8IYToUN0u6MvzK1n7t03UWcPxqy2gNnAJnt96mKfu+Acmo8HZ5QkhRIfrNkFvt9nZOm8zxw+A0eaLZ+Ni6tM1Dz25jiB/H2eXJ4QQN0y3CPri08Ws/fsnNBki8K85QFXMejJ+8RIDen9lMk4hhHA5Lh30dpudjS8uJ++UH25WHzysb+Fz70gevnuL3PAkhOg2XDboS89eYtVfNmE2xuJXk019r0zuf/otAvwDnF2aEELcVC4X9Fpr1r/wPvkngjDYQ/BoXkDvnzxAevrTzi5NCCGcwqWCvqa0mg+feY8mY298Go5h75PNo796CzeTrPAkhOi+XCboP39vJSc/sWEzJuNVv5wRv7qPfqk/dHZZQgjhdF0+6O02O4t+9nfqG4fhYS3FM2IZjzz3CgZjl/9oQgjRIbp0Gl48l8+G51Zi9hiOd90+Bv5nb4aNe93ZZQkhRKfSZYN+85L3OLdJYTX1xdu6lgdefxYvXxlRI4QQl+uSQb/073+j8mQ/DMpKWPx27v3vF5xdkhBCdFpdKui11ix85r9pLBuHm7WSwfd6MHz6c84uSwghOrWrzuKllJqvlCpRSh35mv1KKfWyUuqMUuqQUuqGTP+oteat//oZ9RUTcW8uZNKPkhk+/e4b8VZCCOFSHJmucQFw+zfsnwqktP7MBl67/rKuUMQvfo7ZOgPPplPM+vNtJA8ZcSPeRgghXM5Vg15rvQ2o+IZDZgKLdItMIFApFdlRBQKsmPsC5sqJeDSe5/4XHyQ4KrojTy+EEC6tIyZgjwYK2jy/0LrtK5RSs5VSWUqprNLSUodOnrVjC2WZkShtYewPeuMbHHz9FQshRDfSEUF/pWkg9ZUO1FrP01qnaa3TwsLCrnri0tIiDs47jsU9hOSR5fROH329tQohRLfTEUF/AYht8zwGKOyA87Lmty/Q5N2fwMC93PLdb3fEKYUQotvpiKBfDTzaOvpmJFCttS663pOWFl/Eak7Ho/EsD/3tN9dfpRBCdFNXHUevlHofmACEKqUuAM8CJgCt9VxgPTANOAM0AE90RGFr//JPLB5T6RGX2xGnE0KIbuuqQa+1fvAq+zXwVIdVBDQ1NWKrSMVdFTHr5z/tyFMLIUS30xFdNx1u2Z//hNkrBq+wUxhNXermXSGE6HQ6XYpqu52mc9GY3Kq4+zdyNS+EENer013Rr3rlBZq8+2DyysE7QGajFEKI69Xpgr58nx2jtZHbn37c2aUIIYRL6FRBb25sxOLeF5P1EJGJSc4uRwghXEKnCvrPP1yMzc0HU0i9s0sRQgiX0amCvijrLAA9x92QmY6FEKJb6lSjbmzVQbi51TBi2h3OLkUIIVxGp7qitxsScLOew81kcnYpQgjhMjpN0Gdv20yzRxgGH8emLxZCCOGYThP0xzZsBSB0QIeuWSKEEN1epwl68yUTBlsz4x982NmlCCGES+k0Qa/tsbg3n8c/KMjZpQghhEvpFEFflHeGZo9YlOmis0sRQgiX0ymCfufSD9EGI96xMtpGCCE6WqcI+pqzLXfCDr/nTidXIoQQrsehoFdK3a6UOqmUOqOU+tUV9k9QSlUrpXJaf37XniJ0UwQeTRdJ7j+oPS8TQgjhAEeWEjQCrwBTaFkIfJ9SarXW+thlh27XWs9obwGN9fVY3BMxWXPa+1IhhBAOcOSKfgRwRmudq7VuBpYAMzuqgN2rl2Fz88IU0tBRpxRCCNGGI0EfDRS0eX6hddvlRimlDiqlNiil+l/pREqp2UqpLKVUVmlpyx2wxcdbFv8OSgpvV+FCCCEc40jQqyts05c9zwbitdaDgH8BK690Iq31PK11mtY6LSwsDICmsmYAeo8a5WDJQggh2sORoL8AxLZ5HgMUtj1Aa12jta5rfbweMCmlQh0pQDd6YrQ2kpQ6xMGShRBCtIcjQb8PSFFKJSql3IEHgNVtD1BKRSilVOvjEa3nLXekAG0Lws1SJjNWCiHEDXLVUTdaa6tS6ofAJsAIzNdaH1VKfa91/1zgHuD7Sikr0Ag8oLW+vHvniuyGEAz24mv+AEIIIb6ZQwuPtHbHrL9s29w2j+cAc9r75s1NTVjcQ/C0nmzvS4UQQjjIqXfGHtm1DW0wYfBpdmYZQgjh0pwa9OeycwDwjvBxZhlCCOHSnBr0dRerAIga0NuZZQghhEtzatDbao2g7QwaP8WZZQghhEtz6MvYG0Vb/HG3VeAXGOjMMoQQwqU59YpeE4zB5tBweyGEENfIuV03biEoQ4UzSxBCCJfntKBvNjdhNfmDp8xaKYQQN5LTgr6ptg4A94BOsciVEEK4LKelrNXccpNUUFKEs0oQQohuwWlBb7e1TIXTe/RoZ5UghBDdgvP6TewGjNYGesr0xEIIcUM5L+i1ETdLmdPeXgghugvnBb1yQ2kZQy+EEDea04JeKzeUqcZZby+EEN2G84IehcHX4qy3F0KIbsOhoFdK3a6UOqmUOqOU+tUV9iul1Mut+w8ppYY6cl6fCN/21iuEEKKdrhr0Sikj8AowFegHPKiU6nfZYVOBlNaf2cBrjrx5zIC+7SpWCCFE+zlyRT8COKO1ztVaNwNLgJmXHTMTWKRbZAKBSqnIbz6tZuD4SddQshBCiPZwZJriaKCgzfMLQLoDx0QDRW0PUkrNpuWKH8DsGxB4pF3Vuq5QQMaatpC2+JK0xZekLb7U7pWaHAl6dYVt+hqOQWs9D5gHoJTK0lqnOfD+Lk/a4kvSFl+StviStMWXlFJZ7X2NI103F4DYNs9jgMJrOEYIIYQTOBL0+4AUpVSiUsodeABYfdkxq4FHW0ffjASqtdZFl59ICCHEzXfVrhuttVUp9UNgE2AE5mutjyqlvte6fy6wHpgGnAEagCcceO9511y165G2+JK0xZekLb4kbfGldreF0vorXelCCCFciKz6IYQQLk6CXgghXJxTgv5qUyq4MqXUfKVUiVLqSJttwUqpzUqp062/g5xZ482glIpVSn2mlDqulDqqlPpR6/bu2BaeSqm9SqmDrW3xh9bt3a4tvqCUMiqlDiil1rY+75ZtoZTKU0odVkrlfDGs8lra4qYHvYNTKriyBcDtl237FfCJ1joF+KT1uauzAj/TWvcFRgJPtf476I5tYQYmaa0HAYOB21tHr3XHtvjCj4DjbZ5357aYqLUe3OY+gna3hTOu6B2ZUsFlaa23ARWXbZ4JLGx9vBC462bW5Axa6yKtdXbr41pa/qOOpnu2hdZa17U+NbX+aLphWwAopWKA6cCbbTZ3y7b4Gu1uC2cE/ddNl9Cd9fjivoPW3+FOruemUkolAEOAPXTTtmjtqsgBSoDNWutu2xbAP4FfAPY227prW2jgY6XU/tYpZOAa2sKRKRA6mkPTJYjuQSnlCywDfqy1rlHqSv88XJ/W2gYMVkoFAiuUUgOcXJJTKKVmACVa6/1KqQlOLqczyNBaFyqlwoHNSqkT13ISZ1zRy3QJX1X8xWyfrb9LnFzPTaGUMtES8u9qrZe3bu6WbfEFrXUV8Dkt3+N0x7bIAO5USuXR0q07SSm1mO7ZFmitC1t/lwAraOn6bndbOCPoHZlSobtZDTzW+vgxYJUTa7kpVMul+1vAca31C212dce2CGu9kkcp5QXcApygG7aF1vrXWusYrXUCLdnwqdb6YbphWyilfJRSfl88Bm4FjnANbeGUO2OVUtNo6Yf7YkqF5296EU6ilHofmEDLtKvFwLPASuADIA7IB+7VWl/+ha1LUUqNAbYDh/myL/YZWvrpu1tbDKTlSzUjLRdfH2itn1NKhdDN2qKt1q6bp7XWM7pjWyilkmi5ioeWbvb3tNbPX0tbyBQIQgjh4uTOWCGEcHES9EII4eIk6IUQwsVJ0AshhIuToBdCCBcnQS+EEC5Ogl4IIVzc/wcxJmpID0wQCAAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
" ] @@ -315,7 +315,7 @@ " plt.plot(M, C)\n", "plt.xlim(0.0, 50.0)\n", "plt.ylim(0.0, None)\n", - "plt.show()" + "plt.show()\n" ] }, { @@ -328,12 +328,12 @@ "output_type": "stream", "text": [ "Risky asset share function over market resources (when possible to adjust):\n", - "Optimal (blue) versus Theoretical Limit (orange)\n" + "Optimal (blue/orange) versus Theoretical Limit (green)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -362,7 +362,7 @@ " ],\n", " 0.0,\n", " 100.0,\n", - ")" + ")\n" ] }, { @@ -395,7 +395,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.9.10" } }, "nbformat": 4, diff --git a/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.py b/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.py index d718a2435..9b5a4a48f 100644 --- a/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.py +++ b/examples/ConsPortfolioModel/example_ConsSequentialPortfolioModel.py @@ -15,6 +15,7 @@ ) from HARK.utilities import plot_funcs + # %% # Make and solve an example portfolio choice consumer type print("Now solving an example portfolio choice problem; this might take a moment...") @@ -34,11 +35,13 @@ + " seconds." ) + # %% # Plot the consumption and risky-share functions print("Consumption function over market resources:") plot_funcs(MyType.cFunc[0], 0.0, 20.0) + # %% # Since we are using a discretization of the lognormal distribution, # the limit is numerically computed and slightly different from @@ -67,6 +70,7 @@ # indistinguishable. This is expected, as deciding saving and risky share simultaneously # should give the same result as when doing it sequentially. + # %% print("\n\n\n") print("For derivation of the numerical limiting portfolio share") @@ -75,9 +79,11 @@ "http://www.econ2.jhu.edu/people/ccarroll/public/lecturenotes/AssetPricing/Portfolio-CRRA/" ) + # %% print("\n\n\n") + # %% "" # Make another example type, but this one can only update their risky portfolio @@ -85,6 +91,7 @@ init_sticky_share = init_portfolio.copy() init_sticky_share["AdjustPrb"] = 0.15 + # %% # Make and solve a discrete portfolio choice consumer type print( @@ -113,6 +120,7 @@ + " seconds." ) + # %% # Plot the consumption and risky-share functions print( @@ -120,6 +128,7 @@ ) plot_funcs(StickyType.cFuncAdj[0], 0.0, 50.0) + # %% print( "Consumption function over market resources when the agent CAN'T adjust, by current share:" @@ -132,6 +141,7 @@ plt.ylim(0.0, None) plt.show() + # %% print("Risky asset share function over market resources (when possible to adjust):") print("Optimal (blue/orange) versus Theoretical Limit (green)") @@ -152,4 +162,5 @@ 100.0, ) + # %%