From 36d7cbfe880ff9e042c1b711badd6f932dfc4341 Mon Sep 17 00:00:00 2001 From: William Du Date: Sun, 19 Mar 2023 19:51:19 -0400 Subject: [PATCH 01/12] add reshuffling method --- HARK/ConsumptionSaving/ConsIndShockModel.py | 162 +++++++++++++++----- 1 file changed, 125 insertions(+), 37 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index ba9b67bee..a6aa9473c 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1789,9 +1789,20 @@ def sim_death(self): # they die. # See: https://github.com/econ-ark/HARK/pull/981 - DeathShks = Uniform(seed=self.RNG.integers(0, 2**31 - 1)).draw( - N=self.AgentCount - ) + if self.reshuffle ==True: + + DeathShks_dstn = Uniform(seed=self.RNG.integers(0, 2**31 - 1))._approx_equiprobable( + N=self.AgentCount + ) + + DeathShks = DeathShks_dstn.draw( + N=self.AgentCount, exact_match = self.reshuffle + ) + else: + + DeathShks = Uniform(seed=self.RNG.integers(0, 2**31 - 1)).draw( + N=self.AgentCount + ) which_agents = DeathShks < DiePrb if self.T_age is not None: # Kill agents that have lived for too many periods too_old = self.t_age >= self.T_age @@ -2106,6 +2117,7 @@ def check_conditions(self, verbose=None): # Use permanent income neutral measure (see Harmenberg 2021) during simulations when True. # Whether Newborns have transitory shock. The default is False. "NewbornTransShk": False, + "reshuffle": False, # Whether to use reshuffling method for Monte Carlo Simulation } ) @@ -2248,46 +2260,122 @@ def get_shocks(self): PermShkNow = np.zeros(self.AgentCount) # Initialize shock arrays TranShkNow = np.zeros(self.AgentCount) newborn = self.t_age == 0 - for t in range(self.T_cycle): - these = t == self.t_cycle - - # temporary, see #1022 - if self.cycles == 1: - t = t - 1 - - N = np.sum(these) + + + if self.reshuffle == False: + + for t in range(self.T_cycle): + these = t == self.t_cycle + + # temporary, see #1022 + if self.cycles == 1: + t = t - 1 + + N = np.sum(these) + if N > 0: + # 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) + + PermShkNow[these] = ( + IncShks[0, :] * PermGroFacNow + ) # permanent "shock" includes expected growth + TranShkNow[these] = IncShks[1, :] + + # That procedure used the *last* period in the sequence for newborns, but that's not right + # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. + N = np.sum(newborn) if N > 0: + these = newborn # set current income distribution - IncShkDstnNow = self.IncShkDstn[t] - # and permanent growth factor - PermGroFacNow = self.PermGroFac[t] + IncShkDstnNow = self.IncShkDstn[0] + PermGroFacNow = self.PermGroFac[0] # and permanent growth factor + # Get random draws of income shocks from the discrete distribution - IncShks = IncShkDstnNow.draw(N) - + EventDraws = IncShkDstnNow.draw_events(N) PermShkNow[these] = ( - IncShks[0, :] * PermGroFacNow + IncShkDstnNow.atoms[0][EventDraws] * PermGroFacNow ) # permanent "shock" includes expected growth - TranShkNow[these] = IncShks[1, :] - - # That procedure used the *last* period in the sequence for newborns, but that's not right - # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. - N = np.sum(newborn) - if N > 0: - these = newborn - # 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 - EventDraws = IncShkDstnNow.draw_events(N) - PermShkNow[these] = ( - IncShkDstnNow.atoms[0][EventDraws] * PermGroFacNow + TranShkNow[these] = IncShkDstnNow.atoms[1][EventDraws] + # PermShkNow[newborn] = 1.0 + # Whether Newborns have transitory shock. The default is False. + if not NewbornTransShk: + TranShkNow[newborn] = 1.0 + else: + + not_newborn = self.t_age != 0 + + def get_mult_fac(prb): + i = 0 + while isinstance(prb,float): + prb = prb*10 + i += 1 + if (abs(prb - round(prb)))<(1e-10): + break + + return i + + if self.UnempPrb>0: + potential_fac = 1/self.UnempPrb + else: + potential_fac = 1.0 + + if (potential_fac).is_integer() ==True: + fac = potential_fac + else: + i_1 = get_mult_fac(self.UnempPrb) + fac = 10**i_1 + + def check_and_convert_to_int(val): + + if abs(round(val) - val) < 1e-6: + return abs(round(val)) + + lcm = (self.PermShkCount * self.TranShkCount) * fac # minimum multiple for both the newborns and and oldborns individuals + + Min_AgentCount = check_and_convert_to_int(lcm/(1-self.LivPrb[0])) # total number of agents + #if ((self.AgentCount * (1-self.LivPrb[0]) / lcm).is_integer() == False) or ((self.AgentCount * (self.LivPrb[0]) / lcm).is_integer() == False) : + if (self.AgentCount/Min_AgentCount).is_integer() == False: + raise Exception("AgentCount must be a multiple ", Min_AgentCount) + + for t in range(self.T_cycle): + these = t == self.t_cycle + + # temporary, see #1022 + if self.cycles == 1: + t = t - 1 + + not_newborn_and_t = np.logical_and(not_newborn, these) + + N = np.sum(not_newborn_and_t) + + if N > 0: + # 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 , exact_match = self.reshuffle) + + PermShkNow[not_newborn_and_t] = ( + IncShks[0, :] * PermGroFacNow + ) # permanent "shock" includes expected growth + TranShkNow[not_newborn_and_t] = IncShks[1, :] + + # That procedure used the *last* period in the sequence for newborns, but that's not right + # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. + N = np.sum(newborn) + + IncShks_newborn = IncShkDstnNow.draw(N , exact_match = self.reshuffle) + + PermShkNow[newborn] = ( + IncShks_newborn[0, :] * PermGroFacNow ) # permanent "shock" includes expected growth - TranShkNow[these] = IncShkDstnNow.atoms[1][EventDraws] - # PermShkNow[newborn] = 1.0 - # Whether Newborns have transitory shock. The default is False. - if not NewbornTransShk: - TranShkNow[newborn] = 1.0 + TranShkNow[newborn] = IncShks_newborn[1, :] + # Store the shocks in self self.EmpNow = np.ones(self.AgentCount, dtype=bool) From cc8aeabc94400936ff3dc62d9c9157a95e9e5846 Mon Sep 17 00:00:00 2001 From: William Du Date: Sun, 19 Mar 2023 20:11:10 -0400 Subject: [PATCH 02/12] move reshuffle boolean to perfforesight dict --- HARK/ConsumptionSaving/ConsIndShockModel.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index a6aa9473c..41072e69b 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1558,6 +1558,8 @@ def prepare_to_calc_EndOfPrdvP(self): "T_cycle": 1, # Number of periods in the cycle for this agent type "PerfMITShk": False, # Do Perfect Foresight MIT Shock: Forces Newborns to follow solution path of the agent he/she replaced when True + "reshuffle": False, # Whether to use reshuffling method for Monte Carlo Simulation + } @@ -2117,7 +2119,6 @@ def check_conditions(self, verbose=None): # Use permanent income neutral measure (see Harmenberg 2021) during simulations when True. # Whether Newborns have transitory shock. The default is False. "NewbornTransShk": False, - "reshuffle": False, # Whether to use reshuffling method for Monte Carlo Simulation } ) From 5662be68ceb2cee94c82d49480b863c8fe48e394 Mon Sep 17 00:00:00 2001 From: William Du Date: Wed, 31 May 2023 00:00:19 -0500 Subject: [PATCH 03/12] update get_shocks --- HARK/ConsumptionSaving/ConsIndShockModel.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 42a3bdd77..081ebad28 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2331,11 +2331,20 @@ def check_and_convert_to_int(val): lcm = (self.PermShkCount * self.TranShkCount) * fac # minimum multiple for both the newborns and and oldborns individuals - Min_AgentCount = check_and_convert_to_int(lcm/(1-self.LivPrb[0])) # total number of agents - #if ((self.AgentCount * (1-self.LivPrb[0]) / lcm).is_integer() == False) or ((self.AgentCount * (self.LivPrb[0]) / lcm).is_integer() == False) : - if (self.AgentCount/Min_AgentCount).is_integer() == False: - raise Exception("AgentCount must be a multiple ", Min_AgentCount) + + + if (self.AgentCount/lcm).is_integer() == False: # check if Agentcount is appropriate to implement reshuffling + raise Exception("AgentCount must be a multiple of " + str( lcm)) + + + if self.perf_reshuffle == True: # when true, permanent and transitory shocks are evenly distributed across newborns, and non newborns. + Min_AgentCount = check_and_convert_to_int(lcm/(1-self.LivPrb[0])) # total number of agents + if (self.AgentCount/Min_AgentCount).is_integer() == False: # check if Agentcount is appropriate to implement perfect reshuffling + raise Exception("AgentCount must be a multiple of" +str(Min_AgentCount)) + + + for t in range(self.T_cycle): these = t == self.t_cycle From f11b22bded37baf9523414ebbc37fb9217145b74 Mon Sep 17 00:00:00 2001 From: William Du Date: Wed, 31 May 2023 00:12:52 -0500 Subject: [PATCH 04/12] add example of Reshuffling and update distribution.py file --- HARK/ConsumptionSaving/ConsIndShockModel.py | 167 ++-- HARK/distribution.py | 33 +- ...hockConsumerType_Reshuffling_Example.ipynb | 778 ++++++++++++++++++ 3 files changed, 874 insertions(+), 104 deletions(-) create mode 100644 examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 081ebad28..09a4fbdf2 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2235,6 +2235,7 @@ def reset_rng(self): dstn.reset() def get_shocks(self): + """ Gets permanent and transitory income shocks for this period. Samples from IncShkDstn for each period in the cycle. @@ -2248,144 +2249,114 @@ def get_shocks(self): ------- None """ + NewbornTransShk = ( self.NewbornTransShk ) # Whether Newborns have transitory shock. The default is False. PermShkNow = np.zeros(self.AgentCount) # Initialize shock arrays TranShkNow = np.zeros(self.AgentCount) + newborn = self.t_age == 0 + if self.reshuffle ==True: # when true permanent, transitory, and unemployment shocks are perfectly distributed across population - if self.reshuffle == False: - - for t in range(self.T_cycle): - these = t == self.t_cycle - - # temporary, see #1022 - if self.cycles == 1: - t = t - 1 - - N = np.sum(these) - if N > 0: - # 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) - - PermShkNow[these] = ( - IncShks[0, :] * PermGroFacNow - ) # permanent "shock" includes expected growth - TranShkNow[these] = IncShks[1, :] - - # That procedure used the *last* period in the sequence for newborns, but that's not right - # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. - N = np.sum(newborn) - if N > 0: - these = newborn - # 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 - EventDraws = IncShkDstnNow.draw_events(N) - PermShkNow[these] = ( - IncShkDstnNow.atoms[0][EventDraws] * PermGroFacNow - ) # permanent "shock" includes expected growth - TranShkNow[these] = IncShkDstnNow.atoms[1][EventDraws] - # PermShkNow[newborn] = 1.0 - # Whether Newborns have transitory shock. The default is False. - if not NewbornTransShk: - TranShkNow[newborn] = 1.0 - else: - - not_newborn = self.t_age != 0 - def get_mult_fac(prb): i = 0 while isinstance(prb,float): prb = prb*10 i += 1 - if (abs(prb - round(prb)))<(1e-10): + if ( abs(prb - round(prb)) )<(1e-10): break - return i if self.UnempPrb>0: + potential_fac = 1/self.UnempPrb - else: - potential_fac = 1.0 - if (potential_fac).is_integer() ==True: - fac = potential_fac + if (potential_fac).is_integer() ==True: + fac = potential_fac + else: + i_1 = get_mult_fac(self.UnempPrb) + fac = 10**i_1 else: - i_1 = get_mult_fac(self.UnempPrb) - fac = 10**i_1 - - def check_and_convert_to_int(val): - - if abs(round(val) - val) < 1e-6: - return abs(round(val)) + fac = 1.0 + lcm = (self.PermShkCount * self.TranShkCount) * fac # minimum multiple for both the newborns and and oldborns individuals - - - if (self.AgentCount/lcm).is_integer() == False: # check if Agentcount is appropriate to implement reshuffling raise Exception("AgentCount must be a multiple of " + str( lcm)) - + + def check_and_convert_to_int(val): + + if abs(round(val) - val) < 1e-6: + return abs(round(val)) + if self.perf_reshuffle == True: # when true, permanent and transitory shocks are evenly distributed across newborns, and non newborns. Min_AgentCount = check_and_convert_to_int(lcm/(1-self.LivPrb[0])) # total number of agents if (self.AgentCount/Min_AgentCount).is_integer() == False: # check if Agentcount is appropriate to implement perfect reshuffling raise Exception("AgentCount must be a multiple of" +str(Min_AgentCount)) + for t in range(self.T_cycle): + these = t == self.t_cycle + + # temporary, see #1022 + if self.cycles == 1: + t = t - 1 + + + if self.reshuffle ==True: + not_newborn = self.t_age != 0 + these = np.logical_and(not_newborn, these) - + N = np.sum(these) - for t in range(self.T_cycle): - these = t == self.t_cycle - - # temporary, see #1022 - if self.cycles == 1: - t = t - 1 - - not_newborn_and_t = np.logical_and(not_newborn, these) - - N = np.sum(not_newborn_and_t) - - if N > 0: - # 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 , exact_match = self.reshuffle) - - PermShkNow[not_newborn_and_t] = ( - IncShks[0, :] * PermGroFacNow - ) # permanent "shock" includes expected growth - TranShkNow[not_newborn_and_t] = IncShks[1, :] - - # That procedure used the *last* period in the sequence for newborns, but that's not right - # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. - N = np.sum(newborn) + if N > 0: + # 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 , exact_match = self.reshuffle) - IncShks_newborn = IncShkDstnNow.draw(N , exact_match = self.reshuffle) - - PermShkNow[newborn] = ( - IncShks_newborn[0, :] * PermGroFacNow + PermShkNow[these] = ( + IncShks[0, :] * PermGroFacNow + ) # permanent "shock" includes expected growth + TranShkNow[these] = IncShks[1, :] + + # That procedure used the *last* period in the sequence for newborns, but that's not right + # Redraw shocks for newborns, using the *first* period in the sequence. Approximation. + N = np.sum(newborn) + if N > 0: + these = newborn + # 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 + EventDraws = IncShkDstnNow.draw_events(N,exact_match = self.reshuffle) + #EventDraws = IncShkDstnNow.draw(N,exact_match = self.reshuffle) + + PermShkNow[these] = ( + IncShkDstnNow.atoms[0][EventDraws] * PermGroFacNow ) # permanent "shock" includes expected growth - TranShkNow[newborn] = IncShks_newborn[1, :] - - + TranShkNow[these] = IncShkDstnNow.atoms[1][EventDraws] + + + # PermShkNow[newborn] = 1.0 + # Whether Newborns have transitory shock. The default is False. + if not NewbornTransShk: + TranShkNow[newborn] = 1.0 + + # Store the shocks in self self.EmpNow = np.ones(self.AgentCount, dtype=bool) self.EmpNow[TranShkNow == self.IncUnemp] = False self.shocks["PermShk"] = PermShkNow self.shocks["TranShk"] = TranShkNow + def calc_bounding_values(self): """ diff --git a/HARK/distribution.py b/HARK/distribution.py index 37be02226..f8270be8e 100644 --- a/HARK/distribution.py +++ b/HARK/distribution.py @@ -814,18 +814,39 @@ def dim(self) -> int: """ return self.atoms.shape[:-1] - def draw_events(self, N: int) -> np.ndarray: + def draw_events(self, N: int, + exact_match: bool = False): """ Draws N 'events' from the distribution PMF. These events are indices into atoms. """ - # Generate a cumulative distribution - base_draws = self._rng.uniform(size=N) - cum_dist = np.cumsum(self.pmv) + + if exact_match == True : + + events = np.arange(self.pmv.size) # just a list of integers + cutoffs = np.round(np.cumsum(self.pmv) * N).astype( + int + ) # cutoff points between discrete outcomes + top = 0 - # Convert the basic uniform draws into discrete draws - indices = cum_dist.searchsorted(base_draws) + # Make a list of event indices that closely matches the discrete distribution + event_list = [] + for j in range(events.size): + bot = top + top = cutoffs[j] + event_list += (top - bot) * [events[j]] + + # Randomly permute the event indices + indices = self._rng.permutation(event_list) + + else: + # Generate a cumulative distribution + base_draws = self._rng.uniform(size=N) + cum_dist = np.cumsum(self.pmv) + # Convert the basic uniform draws into discrete draws + indices = cum_dist.searchsorted(base_draws) + return indices def draw( diff --git a/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb b/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb new file mode 100644 index 000000000..ccdee2752 --- /dev/null +++ b/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb @@ -0,0 +1,778 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "21d31398", + "metadata": {}, + "source": [ + "# Reshuffling" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "56cb20cf", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "import time\n", + "from copy import copy, deepcopy\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import time\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7a03edd3", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "Dict = {\n", + " \n", + " # Parameters shared with the perfect foresight model\n", + " \"Rfree\": 1.04**.25, # Interest factor on assets\n", + " \"LivPrb\" : [.99375], # Survival probability\n", + " \"PermGroFac\" :[1.00], # Permanent income growth factor\n", + "\n", + " # Parameters that specify the income distribution over the lifecycle\n", + " \"PermShkStd\" : [.06], # Standard deviation of log permanent shocks to income\n", + " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", + " \"TranShkStd\" : [.2], # Standard deviation of log transitory shocks to income\n", + " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", + " \"UnempPrb\" : 0.1, # Probability of unemployment while working\n", + "\n", + "\n", + " # Parameters only used in simulation\n", + " \"T_sim\" : 3000, # Number of periods to simulate\n", + " #\"aNrmInitMean\" : np.log(0.0),,#np.log(0.0),# Mean of log initial assets , \n", + " \"aNrmInitMean\": -6.0, # Mean of log initial assets\n", + " \"aNrmInitStd\": 1.0, # Standard deviation of log initial assets\n", + "\n", + " \"reshuffle\": True,\n", + " \n", + " }\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9546bfbf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPFRaw = 0.984611 \n", + "GPFNrm = 0.987928 \n", + "GPFAggLivPrb = 0.978457 \n", + "Thorn = APF = 0.984611 \n", + "PermGroFacAdj = 0.996642 \n", + "uInvEpShkuInv = 0.996642 \n", + "VAF = 0.950797 \n", + "WRPF = 0.307358 \n", + "DiscFacGPFNrmMax = 0.983604 \n", + "DiscFacGPFAggLivPrbMax = 0.996471 \n", + "GPFRaw = 0.984611 \n", + "GPFNrm = 0.987928 \n", + "GPFAggLivPrb = 0.978457 \n", + "Thorn = APF = 0.984611 \n", + "PermGroFacAdj = 0.996642 \n", + "uInvEpShkuInv = 0.996642 \n", + "VAF = 0.950797 \n", + "WRPF = 0.307358 \n", + "DiscFacGPFNrmMax = 0.983604 \n", + "DiscFacGPFAggLivPrbMax = 0.996471 \n" + ] + } + ], + "source": [ + "Dict_no_reshuffle = deepcopy(Dict)\n", + "Dict_no_reshuffle['reshuffle'] = False\n", + "example1 = IndShockConsumerType(**Dict)\n", + "example1.cycles = 0\n", + "\n", + "example1_no_reshuffle = IndShockConsumerType(**Dict_no_reshuffle)\n", + "example1_no_reshuffle.cycles = 0\n", + "example1_no_reshuffle.reshuffle = False\n", + "example1.solve()\n", + "example1_no_reshuffle.solve()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "543f9f0b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "490\n" + ] + } + ], + "source": [ + "def get_mult_fac(prb):\n", + " i = 0\n", + " while isinstance(prb,float):\n", + " prb = prb*10\n", + " i += 1\n", + " if (abs(prb - round(prb)))<(1e-10):\n", + " break\n", + " \n", + " return i\n", + "if example1.UnempPrb>0:\n", + " \n", + " potential_fac = 1/example1.UnempPrb\n", + "else:\n", + " potential_fac = 1.0\n", + " \n", + "if (potential_fac).is_integer() ==True:\n", + " fac = potential_fac\n", + "else:\n", + " i_1 = get_mult_fac(example1.UnempPrb)\n", + " fac = 10**i_1\n", + "\n", + "def check_and_convert_to_int(val):\n", + "\n", + " if abs(round(val) - val) < 1e-6:\n", + " return abs(round(val))\n", + " \n", + "lcm = (example1.PermShkCount * example1.TranShkCount) * fac # minimum multiple for both the newborns and and oldborns individuals\n", + "\n", + "lcm = int(lcm) \n", + "#AgentCount = check_and_convert_to_int(lcm/(1-example1.LivPrb[0])) # total number of agents\n", + "AgentCount = lcm \n", + "print(AgentCount)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c55c7454", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "\n", + "# Simulation Parameters \n", + "#Simulate\n", + "example1.AgentCount = AgentCount \n", + "example1.track_vars = ['aLvl','cNrm', 'TranShk' , 'pLvl'] # Track level of assets\n", + "example1.initialize_sim()\n", + "example1.simulate() #Simulate with Monte Carlo\n", + "\n", + "#Compute Aggregate Consumption and Aggregate Assets\n", + "Monte_Carlo_Consumption = np.mean((example1.state_now['mNrm'] - example1.state_now['aNrm'])*example1.state_now['pLvl']) #Aggregate Consumption\n", + "Monte_Carlo_Assets = np.mean(example1.state_now['aNrm']*example1.state_now['pLvl']) #Aggregate Assets\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "18ed8b7e", + "metadata": {}, + "outputs": [], + "source": [ + "Agg_A = []\n", + "Agg_C = []\n", + "for t in range(example1.T_sim):\n", + " A = np.mean(example1.history['aLvl'][t])\n", + " C = np.mean(example1.history['cNrm'][t]*example1.history['pLvl'][t])\n", + "\n", + " Agg_A.append(A)\n", + " Agg_C.append(C)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b8cebea8", + "metadata": {}, + "outputs": [], + "source": [ + "example1_no_reshuffle.AgentCount = AgentCount\n", + "example1_no_reshuffle.track_vars = ['aLvl', 'pLvl', 'cNrm', 'TranShk'] # Track level of assets\n", + "example1_no_reshuffle.initialize_sim()\n", + "example1_no_reshuffle.simulate() #Simulate with Monte Carlo\n", + "\n", + "Agg_A_no_reshuffle = []\n", + "Agg_C_no_reshuffle = []\n", + "\n", + "for t in range(example1_no_reshuffle.T_sim):\n", + " A_no_reshuffle = np.mean(example1_no_reshuffle.history['aLvl'][t])\n", + " C_no_reshuffle = np.mean(example1_no_reshuffle.history['cNrm'][t]*example1_no_reshuffle.history['pLvl'][t])\n", + "\n", + " Agg_A_no_reshuffle.append(A_no_reshuffle)\n", + " Agg_C_no_reshuffle.append(C_no_reshuffle)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7bb3032f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8679193636831609\n", + "0.8403488536650551\n" + ] + } + ], + "source": [ + "print(np.mean(Agg_A_no_reshuffle[100:]))\n", + "print(np.mean(Agg_A[100:]))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "23a2e5f3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Agg_A_no_reshuffle[100:], label = 'no reshuffle')\n", + "plt.plot(Agg_A[100:], label = 'reshuffle')\n", + "plt.ylim(0.3,1.5)\n", + "plt.title('Aggregate Assets')\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cd3211b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "standard deviation no reshuffle 0.04556813587082014\n", + "standard deviation with reshuffle 0.029672050986557147\n", + "ratio of no reshuffle to reshuffle 1.5357258549961605\n" + ] + } + ], + "source": [ + "print('standard deviation no reshuffle', np.std(Agg_A_no_reshuffle[100:]))\n", + "print('standard deviation with reshuffle' , np.std(Agg_A[100:]))\n", + "\n", + "print('ratio of no reshuffle to reshuffle', np.std(Agg_A_no_reshuffle[100:]) /np.std(Agg_A[100:]) )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bd4bb67b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "variance no reshuffle 0.002076455006741525\n", + "variance with reshuffle 0.0008804306097488469\n", + "ratio of no reshuffle to reshuffle 2.358453901703688\n" + ] + } + ], + "source": [ + "print('variance no reshuffle', np.var(Agg_A_no_reshuffle[100:]))\n", + "print('variance with reshuffle' , np.var(Agg_A[100:]))\n", + "\n", + "print('ratio of no reshuffle to reshuffle', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A[100:]) )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0a842c88", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.8, 1.5)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Agg_C_no_reshuffle[100:], label = 'no reshuffle')\n", + "plt.plot(Agg_C[100:], label = 'reshuffle')\n", + "plt.legend()\n", + "plt.title('Aggregate Consumption')\n", + "plt.ylim(.8,1.5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2c95c620", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "variance no reshuffle 0.0017096714891795739\n", + "variance with reshuffle 0.0008049080312952917\n", + "ratio of no reshuffle to reshuffle 2.124058181440057\n" + ] + } + ], + "source": [ + "print('variance no reshuffle', np.var(Agg_C_no_reshuffle[100:]))\n", + "print('variance with reshuffle' , np.var(Agg_C[100:]))\n", + "\n", + "print('ratio of no reshuffle to reshuffle', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C[100:]) )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "03f8bca1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPFRaw = 0.984611 \n", + "GPFNrm = 0.987928 \n", + "GPFAggLivPrb = 0.978457 \n", + "Thorn = APF = 0.984611 \n", + "PermGroFacAdj = 0.996642 \n", + "uInvEpShkuInv = 0.996642 \n", + "VAF = 0.950797 \n", + "WRPF = 0.307358 \n", + "DiscFacGPFNrmMax = 0.983604 \n", + "DiscFacGPFAggLivPrbMax = 0.996471 \n" + ] + } + ], + "source": [ + "Dict_no_reshuffle = deepcopy(Dict)\n", + "Dict_no_reshuffle['reshuffle'] = False\n", + "example_Harmenberg = IndShockConsumerType(**Dict_no_reshuffle)\n", + "example_Harmenberg.cycles = 0\n", + "example_Harmenberg.solve()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0bfd6974", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'aNrm': array([[0.18673842, 0.18778001, 0.18685129, ..., 0.18853899, 0.18923216,\n", + " 0.18652782],\n", + " [0.34263865, 0.66416561, 0.39870003, ..., 0.48273589, 0.40043953,\n", + " 0.230585 ],\n", + " [0.2405698 , 0.54966661, 0.49386995, ..., 0.866921 , 0.50311378,\n", + " 0.25621483],\n", + " ...,\n", + " [1.53373023, 1.19626029, 1.18471462, ..., 0.19904123, 0.98339864,\n", + " 1.28378556],\n", + " [1.48583188, 0.54857026, 1.06135142, ..., 0.65820269, 1.24243646,\n", + " 1.30799762],\n", + " [1.41333291, 0.69574559, 0.78154583, ..., 0.7872597 , 1.08866033,\n", + " 1.41226944]]),\n", + " 'cNrm': array([[0.81423508, 0.81496014, 0.81431365, ..., 0.81548847, 0.81597099,\n", + " 0.81408848],\n", + " [0.89880926, 0.98981798, 0.9189574 , ..., 0.94403789, 0.91951362,\n", + " 0.84163622],\n", + " [0.84773803, 0.96191564, 0.94723374, ..., 1.03181722, 0.94979898,\n", + " 0.85653362],\n", + " ...,\n", + " [1.12826238, 1.0845442 , 1.08288642, ..., 0.82235953, 1.05230395,\n", + " 1.09664729],\n", + " [1.1224348 , 0.96163028, 1.06458907, ..., 0.98839975, 1.09117436,\n", + " 1.09984293],\n", + " [1.11361419, 0.99670634, 1.01496732, ..., 1.01610223, 1.06889287,\n", + " 1.1134848 ]]),\n", + " 'TranShk': array([[1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1. ],\n", + " [1.0566636 , 1.45468013, 1.13748907, ..., 1.24020774, 1.13748907,\n", + " 0.90063839],\n", + " [0.77312209, 0.77312209, 1.0566636 , ..., 1.45468013, 1.0566636 ,\n", + " 0.90063839],\n", + " ...,\n", + " [1.45468013, 1.45468013, 0.90063839, ..., 0.3 , 0.98164342,\n", + " 0.98164342],\n", + " [1.0566636 , 0.3 , 0.90063839, ..., 1.45468013, 1.24020774,\n", + " 1.13748907],\n", + " [1.0566636 , 1.13748907, 0.77312209, ..., 1.13748907, 0.90063839,\n", + " 1.13748907]]),\n", + " 'pLvl': array([[0.97640255, 1.0205327 , 0.95146509, ..., 0.97640255, 1.04731162,\n", + " 1.0978124 ],\n", + " [0.99645073, 0.97100124, 0.99648045, ..., 0.99645073, 1.09686163,\n", + " 1.20519206],\n", + " [1.09391597, 0.88191643, 1.04362556, ..., 1.09391597, 1.11938317,\n", + " 1.32307479],\n", + " ...,\n", + " [0.24299502, 1.05691422, 0.73409196, ..., 0.29862456, 0.87099003,\n", + " 1.02037148],\n", + " [0.24256272, 1.0550339 , 0.71676926, ..., 0.31275297, 0.79108078,\n", + " 1.04132247],\n", + " [0.24754319, 1.05315694, 0.75068078, ..., 0.31219656, 0.7896734 ,\n", + " 0.99078198]])}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "example_Harmenberg.neutral_measure = True\n", + "example_Harmenberg.AgentCount = AgentCount\n", + "example_Harmenberg.track_vars = ['aNrm','cNrm', 'TranShk' , 'pLvl'] # Track level of assets\n", + "example_Harmenberg.initialize_sim()\n", + "example_Harmenberg.simulate() #Simulate with Monte Carlo" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "38917348", + "metadata": {}, + "outputs": [], + "source": [ + "Agg_A_Harmenberg = []\n", + "Agg_C_Harmenberg = []\n", + "\n", + "for t in range(example1_no_reshuffle.T_sim):\n", + " A_Harm = np.mean(example_Harmenberg.history['aNrm'][t])\n", + " C_Harm = np.mean(example_Harmenberg.history['cNrm'][t])\n", + "\n", + " Agg_A_Harmenberg.append(A_Harm)\n", + " Agg_C_Harmenberg.append(C_Harm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6c5c04b8", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "example_Harmenberg_reshuffle = IndShockConsumerType(**Dict, verbose = False)\n", + "example_Harmenberg_reshuffle.cycles = 0\n", + "example_Harmenberg_reshuffle.solve()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "99228789", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'aNrm': array([[0.18667494, 0.1877387 , 0.18675973, ..., 0.18871716, 0.18970184,\n", + " 0.18652782],\n", + " [0.230669 , 0.29718104, 0.33358091, ..., 0.50083041, 0. ,\n", + " 0. ],\n", + " [0.70153531, 0.48645491, 0. , ..., 0.09061339, 0.17534169,\n", + " 0.17534169],\n", + " ...,\n", + " [1.42161167, 1.06740389, 0.82704187, ..., 1.77040745, 1.32524052,\n", + " 0.01727425],\n", + " [1.26022032, 0.98527749, 1.05449411, ..., 2.14127641, 1.57985465,\n", + " 0.23079142],\n", + " [1.28590661, 0.75932705, 0.90545731, ..., 2.31008148, 1.75454486,\n", + " 0.69650608]]),\n", + " 'cNrm': array([[0.81419089, 0.81493138, 0.81424991, ..., 0.81561249, 0.81629793,\n", + " 0.81408848],\n", + " [0.84168756, 0.87863288, 0.89487884, ..., 0.94920467, 0.49191247,\n", + " 0.49291813],\n", + " [0.99796922, 0.94510537, 0.60685372, ..., 0.74095135, 0.80630174,\n", + " 0.80630174],\n", + " ...,\n", + " [1.11462143, 1.06554292, 1.02400388, ..., 1.1551859 , 1.10211875,\n", + " 0.66911915],\n", + " [1.09353702, 1.05260005, 1.06350837, ..., 1.19245531, 1.13383698,\n", + " 0.84176237],\n", + " [1.09692724, 1.01055416, 1.03864051, ..., 1.20821035, 1.15340871,\n", + " 0.99687222]]),\n", + " 'TranShk': array([[1. , 1. , 1. , ..., 1. , 1. ,\n", + " 1. ],\n", + " [0.90063839, 0.98164342, 1.0566636 , ..., 1.24020774, 0.3 ,\n", + " 0.3 ],\n", + " [1.45468013, 1.13748907, 0.3 , ..., 0.3 , 0.98164342,\n", + " 0.98164342],\n", + " ...,\n", + " [0.90063839, 0.98164342, 1.45468013, ..., 1.0566636 , 1.45468013,\n", + " 0.3 ],\n", + " [0.77312209, 0.98164342, 1.24020774, ..., 1.45468013, 1.24020774,\n", + " 1.0566636 ],\n", + " [0.98164342, 0.77312209, 0.90063839, ..., 1.13748907, 1.45468013,\n", + " 1.45468013]]),\n", + " 'pLvl': array([[1.0978124 , 1.04731162, 1.0978124 , ..., 0.90825469, 0.90825469,\n", + " 1.0978124 ],\n", + " [1.20519206, 1.02259774, 1.20519206, ..., 0.82492659, 0.90663886,\n", + " 1.07190683],\n", + " [1.14669818, 1.04359443, 1.32307479, ..., 0.78488885, 0.823459 ,\n", + " 1.09391597],\n", + " ...,\n", + " [0.65773998, 0.99370883, 0.77608912, ..., 0.8372588 , 1.55721043,\n", + " 1.04073149],\n", + " [0.59739542, 1.01411236, 0.7384217 , ..., 0.79662252, 1.41434368,\n", + " 1.14252793],\n", + " [0.5425872 , 1.01230819, 0.75358349, ..., 0.72353615, 1.55268403,\n", + " 1.11556719]])}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "example_Harmenberg_reshuffle.neutral_measure = True\n", + "example_Harmenberg_reshuffle.AgentCount = AgentCount\n", + "example_Harmenberg_reshuffle.track_vars = ['aNrm','cNrm', 'TranShk' , 'pLvl'] # Track level of assets\n", + "example_Harmenberg_reshuffle.initialize_sim()\n", + "example_Harmenberg_reshuffle.simulate() #Simulate with Monte Carlo" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "8d54d37b", + "metadata": {}, + "outputs": [], + "source": [ + "Agg_A_Harmenberg_reshuffle = []\n", + "Agg_C_Harmenberg_reshuffle = []\n", + "\n", + "for t in range(example1_no_reshuffle.T_sim):\n", + " A_Harm_reshuffle = np.mean(example_Harmenberg_reshuffle.history['aNrm'][t])\n", + " C_Harm_reshuffle = np.mean(example_Harmenberg_reshuffle.history['cNrm'][t])\n", + "\n", + " Agg_A_Harmenberg_reshuffle.append(A_Harm_reshuffle)\n", + " Agg_C_Harmenberg_reshuffle.append(C_Harm_reshuffle)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5d301624", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.2, 1.5)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Agg_A_no_reshuffle[100:], label = 'no reshuffle')\n", + "plt.plot(Agg_A[100:], label = 'reshuffle')\n", + "plt.plot(Agg_A_Harmenberg[100:], label = 'Harmenberg')\n", + "plt.plot(Agg_A_Harmenberg_reshuffle[100:], label = 'Harmenberg + reshuffle' )\n", + "plt.legend()\n", + "plt.title('Aggregate Saving')\n", + "plt.ylim(.2,1.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "50d52003", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ratio of no reshuffle to reshuffle 2.358453901703688\n", + "ratio of no reshuffle to Harmenberg 4.80016490376663\n", + "ratio of no reshuffle to Harmenberg + reshuffle 72.31928923323491\n" + ] + } + ], + "source": [ + "#print('variance no reshuffle', np.var(Agg_A_no_reshuffle[100:]))\n", + "#print('variance with reshuffle' , np.var(Agg_A[100:]))\n", + "#print('variance with Harmenberg' , np.var(Agg_A_Harmenberg[100:]))\n", + "#print('variance with Harmenberg + reshuffle' , np.var(Agg_A_Harmenberg_reshuffle[100:]))\n", + "\n", + "print('ratio of no reshuffle to reshuffle', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A[100:]) )\n", + "print('ratio of no reshuffle to Harmenberg', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A_Harmenberg[100:]) )\n", + "print('ratio of no reshuffle to Harmenberg + reshuffle', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A_Harmenberg_reshuffle[100:]) )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "4d165fcb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.8, 1.5)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(Agg_C_no_reshuffle[100:], label = 'no reshuffle')\n", + "plt.plot(Agg_C[100:], label = 'reshuffle')\n", + "plt.plot(Agg_C_Harmenberg[100:], label = 'Harmenberg')\n", + "plt.plot(Agg_C_Harmenberg_reshuffle[100:], label = 'Harmenberg + reshuffle')\n", + "plt.legend()\n", + "plt.title('Aggregate Consumption')\n", + "plt.ylim(.8,1.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "74b9e365", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "variance no reshuffle 0.0017096714891795739\n", + "variance with reshuffle 0.0008049080312952917\n", + "variance with Harmenberg 2.6170617445114956e-05\n", + "variance with Harmenberg + reshuffle 2.9387754075726773e-06\n", + "ratio of no reshuffle to reshuffle 2.124058181440057\n", + "ratio of no reshuffle to Harmenberg 65.32790037396323\n", + "ratio of no reshuffle to Harmenberg + reshuffle 581.7632353850753\n" + ] + } + ], + "source": [ + "print('variance no reshuffle', np.var(Agg_C_no_reshuffle[100:]))\n", + "print('variance with reshuffle' , np.var(Agg_C[100:]))\n", + "print('variance with Harmenberg' , np.var(Agg_C_Harmenberg[100:]))\n", + "print('variance with Harmenberg + reshuffle' , np.var(Agg_C_Harmenberg_reshuffle[100:]))\n", + "\n", + "print('ratio of no reshuffle to reshuffle', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C[100:]) )\n", + "print('ratio of no reshuffle to Harmenberg', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C_Harmenberg[100:]) )\n", + "print('ratio of no reshuffle to Harmenberg + reshuffle', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C_Harmenberg_reshuffle[100:]) )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37027297", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 8c498c6ab609a7a00e9b3cadd4358081013232cf Mon Sep 17 00:00:00 2001 From: William Du Date: Wed, 31 May 2023 00:45:45 -0500 Subject: [PATCH 05/12] fix bug --- HARK/ConsumptionSaving/ConsIndShockModel.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 09a4fbdf2..c4e086b21 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1557,7 +1557,7 @@ def prepare_to_calc_EndOfPrdvP(self): "PerfMITShk": False, # Do Perfect Foresight MIT Shock: Forces Newborns to follow solution path of the agent he/she replaced when True "reshuffle": False, # Whether to use reshuffling method for Monte Carlo Simulation - + "perf_reshuffle": False, #reshuffle must be set to true to use this. Whether to have reshuffling method be perfectly across both newborns and nonnewborns. } @@ -2293,7 +2293,7 @@ def check_and_convert_to_int(val): if abs(round(val) - val) < 1e-6: return abs(round(val)) - if self.perf_reshuffle == True: # when true, permanent and transitory shocks are evenly distributed across newborns, and non newborns. + if self.perf_reshuffle == True: # when true, permanent and transitory shocks are evenly distributed across both newborns and non newborns. Min_AgentCount = check_and_convert_to_int(lcm/(1-self.LivPrb[0])) # total number of agents if (self.AgentCount/Min_AgentCount).is_integer() == False: # check if Agentcount is appropriate to implement perfect reshuffling raise Exception("AgentCount must be a multiple of" +str(Min_AgentCount)) @@ -2331,8 +2331,7 @@ def check_and_convert_to_int(val): if N > 0: these = newborn # set current income distribution - IncShkDstnNow= self.IncShkDstn[0] - + IncShkDstnNow = self.IncShkDstn[0] PermGroFacNow = self.PermGroFac[0] # and permanent growth factor # Get random draws of income shocks from the discrete distribution @@ -2345,7 +2344,7 @@ def check_and_convert_to_int(val): TranShkNow[these] = IncShkDstnNow.atoms[1][EventDraws] - # PermShkNow[newborn] = 1.0 + # PermShkNow[newborn] = 1.0 # Whether Newborns have transitory shock. The default is False. if not NewbornTransShk: TranShkNow[newborn] = 1.0 From 511b611d7aef7f1b064a98c5743a90090e831ae2 Mon Sep 17 00:00:00 2001 From: William Du Date: Thu, 1 Jun 2023 03:23:47 -0500 Subject: [PATCH 06/12] add test for reshuffling method --- .../tests/test_IndShockConsumerType.py | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index 92923bd1d..d7f58fc44 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -922,3 +922,32 @@ def test_calc_jacobian(self): self.assertAlmostEqual(CJAC_Perm.T[30][29], -0.06120, places=HARK_PRECISION) self.assertAlmostEqual(CJAC_Perm.T[30][30], 0.05307, places=HARK_PRECISION) self.assertAlmostEqual(CJAC_Perm.T[30][31], 0.04674, places=HARK_PRECISION) + +#%% Test Reshuffling Monte Carlo Simulation Methods + + +class test_reshuffling_methods(unittest.TestCase): + def test_reshuffling(self): + + dict_harmenberg['UnempPrb'] = .1 + dict_harmenberg['T_sim'] = 500 + dict_harmenberg['reshuffle'] = True + Agent = IndShockConsumerType(**dict_harmenberg) + Agent.solve() + + Agent.neutral_measure = True + Agent.update_income_process() + + Agent.initialize_sim() + Agent.simulate() + + Agg_A = [] + for t in range(Agent.T_sim): + A = np.mean(Agent.history['aNrm'][t]) + + Agg_A.append(A) + + Agg_A = np.array(Agg_A) + + + self.assertAlmostEqual(np.var(Agg_A[100:]),2.338245625592009e-06, places=HARK_PRECISION) From 1d931a8e4358457166355905a0ada3dbec3115ff Mon Sep 17 00:00:00 2001 From: William Du Date: Thu, 1 Jun 2023 03:32:38 -0500 Subject: [PATCH 07/12] fix bug in tests --- HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py | 1 + 1 file changed, 1 insertion(+) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index d7f58fc44..cebf9ed75 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -933,6 +933,7 @@ def test_reshuffling(self): dict_harmenberg['T_sim'] = 500 dict_harmenberg['reshuffle'] = True Agent = IndShockConsumerType(**dict_harmenberg) + Agent.track_vars = ['aNrm'] Agent.solve() Agent.neutral_measure = True From b065a8222388113ed74cfbcda93bb87b1fc01d8f Mon Sep 17 00:00:00 2001 From: William Du Date: Thu, 1 Jun 2023 21:51:11 -0500 Subject: [PATCH 08/12] add test for perf_reshuffle --- .../tests/test_IndShockConsumerType.py | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index cebf9ed75..cda14edae 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -952,3 +952,32 @@ def test_reshuffling(self): self.assertAlmostEqual(np.var(Agg_A[100:]),2.338245625592009e-06, places=HARK_PRECISION) + + def test_perf_reshuffling(self): + + dict_harmenberg['UnempPrb'] = .1 + dict_harmenberg['T_sim'] = 500 + dict_harmenberg['reshuffle'] = True + dict_harmenberg['perf_reshuffle'] = True + Agent = IndShockConsumerType(**dict_harmenberg) + Agent.track_vars = ['aNrm'] + Agent.solve() + + Agent.AgentCount = 40000 + + + Agent.initialize_sim() + Agent.simulate() + + Agg_A = [] + for t in range(Agent.T_sim): + A = np.mean(Agent.history['aNrm'][t]) + + Agg_A.append(A) + + Agg_A = np.array(Agg_A) + + + self.assertAlmostEqual(np.var(Agg_A[100:]),3.144866247778965e-08, places=HARK_PRECISION) + + From 7c0a445f61ef1275e02b9a9a3d0fa387e94044fa Mon Sep 17 00:00:00 2001 From: William Du Date: Fri, 2 Jun 2023 01:54:21 -0500 Subject: [PATCH 09/12] fix bug in tests --- HARK/ConsumptionSaving/ConsIndShockModel.py | 6 +++--- HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py | 4 +++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index c4e086b21..38ac6deb5 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -2293,10 +2293,10 @@ def check_and_convert_to_int(val): if abs(round(val) - val) < 1e-6: return abs(round(val)) - if self.perf_reshuffle == True: # when true, permanent and transitory shocks are evenly distributed across both newborns and non newborns. + if self.perf_reshuffle == True:# when true, permanent and transitory shocks are evenly distributed across both newborns and non newborns. Min_AgentCount = check_and_convert_to_int(lcm/(1-self.LivPrb[0])) # total number of agents if (self.AgentCount/Min_AgentCount).is_integer() == False: # check if Agentcount is appropriate to implement perfect reshuffling - raise Exception("AgentCount must be a multiple of" +str(Min_AgentCount)) + raise Exception("AgentCount must be a multiple of " +str(Min_AgentCount)) for t in range(self.T_cycle): these = t == self.t_cycle @@ -2306,7 +2306,7 @@ def check_and_convert_to_int(val): t = t - 1 - if self.reshuffle ==True: + if self.reshuffle == True: not_newborn = self.t_age != 0 these = np.logical_and(not_newborn, these) diff --git a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py index cda14edae..138486499 100644 --- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py +++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py @@ -939,6 +939,7 @@ def test_reshuffling(self): Agent.neutral_measure = True Agent.update_income_process() + Agent.perf_reshuffle = False Agent.initialize_sim() Agent.simulate() @@ -958,11 +959,12 @@ def test_perf_reshuffling(self): dict_harmenberg['UnempPrb'] = .1 dict_harmenberg['T_sim'] = 500 dict_harmenberg['reshuffle'] = True - dict_harmenberg['perf_reshuffle'] = True + Agent = IndShockConsumerType(**dict_harmenberg) Agent.track_vars = ['aNrm'] Agent.solve() + Agent.perf_reshuffle = True Agent.AgentCount = 40000 From 845f8542c843b30bc5dd4ca5b92d2b3c1b920ed9 Mon Sep 17 00:00:00 2001 From: William Du Date: Sun, 4 Jun 2023 15:04:50 -0500 Subject: [PATCH 10/12] update change log --- Documentation/CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md index e4e57967c..266012ba2 100644 --- a/Documentation/CHANGELOG.md +++ b/Documentation/CHANGELOG.md @@ -15,6 +15,7 @@ Release Date: TBD ### Major Changes - Adds `HARK.core.AgentPopulation` class to represent a population of agents with ex-ante heterogeneous parametrizations as distributions. [#1237](https://github.com/econ-ark/HARK/pull/1237) +- Adds methods to improve efficiency of Monte Carlo simulations. [#1244] (https://github.com/econ-ark/HARK/pull/1244) ### Minor Changes From a262763bc3d5f57eaeec9d589071f22fdccbeb93 Mon Sep 17 00:00:00 2001 From: William Du Date: Mon, 5 Jun 2023 01:10:57 -0500 Subject: [PATCH 11/12] update reshuffling example notebook --- ...hockConsumerType_Reshuffling_Example.ipynb | 557 +++++------------- 1 file changed, 157 insertions(+), 400 deletions(-) diff --git a/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb b/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb index ccdee2752..e29bf7561 100644 --- a/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb +++ b/examples/ConsIndShockModel/IndShockConsumerType_Reshuffling_Example.ipynb @@ -1,13 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "id": "21d31398", - "metadata": {}, - "source": [ - "# Reshuffling" - ] - }, { "cell_type": "code", "execution_count": 1, @@ -18,6 +10,7 @@ "\n", "\n", "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", + "#from ConsIndShockModel import IndShockConsumerType\n", "import time\n", "from copy import copy, deepcopy\n", "import numpy as np\n", @@ -27,6 +20,14 @@ "\n" ] }, + { + "cell_type": "markdown", + "id": "21d31398", + "metadata": {}, + "source": [ + "# The Reshuffling method for Monte Carlo simulations" + ] + }, { "cell_type": "code", "execution_count": 2, @@ -45,19 +46,13 @@ "\n", " # Parameters that specify the income distribution over the lifecycle\n", " \"PermShkStd\" : [.06], # Standard deviation of log permanent shocks to income\n", - " \"PermShkCount\" : 7, # Number of points in discrete approximation to permanent income shocks\n", " \"TranShkStd\" : [.2], # Standard deviation of log transitory shocks to income\n", - " \"TranShkCount\" : 7, # Number of points in discrete approximation to transitory income shocks\n", " \"UnempPrb\" : 0.1, # Probability of unemployment while working\n", "\n", - "\n", " # Parameters only used in simulation\n", - " \"T_sim\" : 3000, # Number of periods to simulate\n", - " #\"aNrmInitMean\" : np.log(0.0),,#np.log(0.0),# Mean of log initial assets , \n", + " \"T_sim\" : 500, # Number of periods to simulate\n", " \"aNrmInitMean\": -6.0, # Mean of log initial assets\n", " \"aNrmInitStd\": 1.0, # Standard deviation of log initial assets\n", - "\n", - " \"reshuffle\": True,\n", " \n", " }\n", "\n" @@ -68,45 +63,22 @@ "execution_count": 3, "id": "9546bfbf", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPFRaw = 0.984611 \n", - "GPFNrm = 0.987928 \n", - "GPFAggLivPrb = 0.978457 \n", - "Thorn = APF = 0.984611 \n", - "PermGroFacAdj = 0.996642 \n", - "uInvEpShkuInv = 0.996642 \n", - "VAF = 0.950797 \n", - "WRPF = 0.307358 \n", - "DiscFacGPFNrmMax = 0.983604 \n", - "DiscFacGPFAggLivPrbMax = 0.996471 \n", - "GPFRaw = 0.984611 \n", - "GPFNrm = 0.987928 \n", - "GPFAggLivPrb = 0.978457 \n", - "Thorn = APF = 0.984611 \n", - "PermGroFacAdj = 0.996642 \n", - "uInvEpShkuInv = 0.996642 \n", - "VAF = 0.950797 \n", - "WRPF = 0.307358 \n", - "DiscFacGPFNrmMax = 0.983604 \n", - "DiscFacGPFAggLivPrbMax = 0.996471 \n" - ] - } - ], + "outputs": [], "source": [ - "Dict_no_reshuffle = deepcopy(Dict)\n", - "Dict_no_reshuffle['reshuffle'] = False\n", - "example1 = IndShockConsumerType(**Dict)\n", - "example1.cycles = 0\n", + "# Generate Baseline Agent\n", + "Agent = IndShockConsumerType(**Dict, verbose = False)\n", + "Agent.cycles = 0\n", + "Agent.solve()\n", "\n", - "example1_no_reshuffle = IndShockConsumerType(**Dict_no_reshuffle)\n", - "example1_no_reshuffle.cycles = 0\n", - "example1_no_reshuffle.reshuffle = False\n", - "example1.solve()\n", - "example1_no_reshuffle.solve()" + "# Generate Agent with Reshuffling method activated\n", + "Dict_w_reshuffle = deepcopy(Dict)\n", + "Dict_w_reshuffle['reshuffle'] = True # allow reshuffling for Monte Carlo Simulations\n", + "\n", + "Agent_w_Reshuffling = IndShockConsumerType(**Dict_w_reshuffle, verbose = False)\n", + "Agent_w_Reshuffling.cycles = 0\n", + "Agent_w_Reshuffling.solve()\n", + "\n", + "\n" ] }, { @@ -124,99 +96,42 @@ } ], "source": [ - "def get_mult_fac(prb):\n", - " i = 0\n", - " while isinstance(prb,float):\n", - " prb = prb*10\n", - " i += 1\n", - " if (abs(prb - round(prb)))<(1e-10):\n", - " break\n", - " \n", - " return i\n", - "if example1.UnempPrb>0:\n", - " \n", - " potential_fac = 1/example1.UnempPrb\n", - "else:\n", - " potential_fac = 1.0\n", - " \n", - "if (potential_fac).is_integer() ==True:\n", - " fac = potential_fac\n", - "else:\n", - " i_1 = get_mult_fac(example1.UnempPrb)\n", - " fac = 10**i_1\n", - "\n", - "def check_and_convert_to_int(val):\n", - "\n", - " if abs(round(val) - val) < 1e-6:\n", - " return abs(round(val))\n", - " \n", - "lcm = (example1.PermShkCount * example1.TranShkCount) * fac # minimum multiple for both the newborns and and oldborns individuals\n", + "# least common multiple for number of agents needed to allow reshuffling method to work\n", + "lcm = (Agent_w_Reshuffling.PermShkCount * Agent_w_Reshuffling.TranShkCount) * 10 # number of permanent shocks x number of transitory shocks x 1/UnempPrb\n", "\n", "lcm = int(lcm) \n", - "#AgentCount = check_and_convert_to_int(lcm/(1-example1.LivPrb[0])) # total number of agents\n", "AgentCount = lcm \n", "print(AgentCount)\n", "\n" ] }, { - "cell_type": "code", - "execution_count": 5, - "id": "c55c7454", - "metadata": { - "scrolled": false - }, - "outputs": [], - "source": [ - "\n", - "# Simulation Parameters \n", - "#Simulate\n", - "example1.AgentCount = AgentCount \n", - "example1.track_vars = ['aLvl','cNrm', 'TranShk' , 'pLvl'] # Track level of assets\n", - "example1.initialize_sim()\n", - "example1.simulate() #Simulate with Monte Carlo\n", - "\n", - "#Compute Aggregate Consumption and Aggregate Assets\n", - "Monte_Carlo_Consumption = np.mean((example1.state_now['mNrm'] - example1.state_now['aNrm'])*example1.state_now['pLvl']) #Aggregate Consumption\n", - "Monte_Carlo_Assets = np.mean(example1.state_now['aNrm']*example1.state_now['pLvl']) #Aggregate Assets\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "18ed8b7e", + "cell_type": "markdown", + "id": "bc397650", "metadata": {}, - "outputs": [], "source": [ - "Agg_A = []\n", - "Agg_C = []\n", - "for t in range(example1.T_sim):\n", - " A = np.mean(example1.history['aLvl'][t])\n", - " C = np.mean(example1.history['cNrm'][t]*example1.history['pLvl'][t])\n", - "\n", - " Agg_A.append(A)\n", - " Agg_C.append(C)\n" + "## Simulate time series for aggregate savings and aggregate consumption" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "b8cebea8", "metadata": {}, "outputs": [], "source": [ - "example1_no_reshuffle.AgentCount = AgentCount\n", - "example1_no_reshuffle.track_vars = ['aLvl', 'pLvl', 'cNrm', 'TranShk'] # Track level of assets\n", - "example1_no_reshuffle.initialize_sim()\n", - "example1_no_reshuffle.simulate() #Simulate with Monte Carlo\n", + "Agent.AgentCount = AgentCount\n", + "Agent.track_vars = ['aLvl', 'pLvl', 'cNrm'] # Track level of assets\n", + "Agent.initialize_sim()\n", + "Agent.simulate() #Simulate with Monte Carlo\n", "\n", + "# compute time series of aggregate consumption and aggregate assets\n", "Agg_A_no_reshuffle = []\n", "Agg_C_no_reshuffle = []\n", "\n", - "for t in range(example1_no_reshuffle.T_sim):\n", - " A_no_reshuffle = np.mean(example1_no_reshuffle.history['aLvl'][t])\n", - " C_no_reshuffle = np.mean(example1_no_reshuffle.history['cNrm'][t]*example1_no_reshuffle.history['pLvl'][t])\n", + "for t in range(Agent.T_sim):\n", + " A_no_reshuffle = np.mean(Agent.history['aLvl'][t])\n", + " C_no_reshuffle = np.mean(Agent.history['cNrm'][t]*Agent.history['pLvl'][t])\n", "\n", " Agg_A_no_reshuffle.append(A_no_reshuffle)\n", " Agg_C_no_reshuffle.append(C_no_reshuffle)\n" @@ -224,43 +139,50 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "7bb3032f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.8679193636831609\n", - "0.8403488536650551\n" - ] - } - ], + "execution_count": 6, + "id": "c55c7454", + "metadata": { + "scrolled": false + }, + "outputs": [], "source": [ - "print(np.mean(Agg_A_no_reshuffle[100:]))\n", - "print(np.mean(Agg_A[100:]))" + "\n", + "#Simulate agent with reshuffling activated\n", + "Agent_w_Reshuffling.AgentCount = AgentCount \n", + "Agent_w_Reshuffling.track_vars = ['aLvl','cNrm' , 'pLvl'] # Track level of assets, permanent income, and normalized consumption\n", + "Agent_w_Reshuffling.initialize_sim()\n", + "Agent_w_Reshuffling.simulate() #Simulate with Monte Carlo\n", + "\n", + "# compute time series of aggregate consumption and aggregate assets\n", + "Agg_A = []\n", + "Agg_C = []\n", + "for t in range(Agent_w_Reshuffling.T_sim):\n", + " A = np.mean(Agent_w_Reshuffling.history['aLvl'][t])\n", + " C = np.mean(Agent_w_Reshuffling.history['cNrm'][t]*Agent_w_Reshuffling.history['pLvl'][t])\n", + "\n", + " Agg_A.append(A)\n", + " Agg_C.append(C)\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "23a2e5f3", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 9, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -279,30 +201,7 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "cd3211b8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "standard deviation no reshuffle 0.04556813587082014\n", - "standard deviation with reshuffle 0.029672050986557147\n", - "ratio of no reshuffle to reshuffle 1.5357258549961605\n" - ] - } - ], - "source": [ - "print('standard deviation no reshuffle', np.std(Agg_A_no_reshuffle[100:]))\n", - "print('standard deviation with reshuffle' , np.std(Agg_A[100:]))\n", - "\n", - "print('ratio of no reshuffle to reshuffle', np.std(Agg_A_no_reshuffle[100:]) /np.std(Agg_A[100:]) )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "id": "bd4bb67b", "metadata": {}, "outputs": [ @@ -310,9 +209,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "variance no reshuffle 0.002076455006741525\n", - "variance with reshuffle 0.0008804306097488469\n", - "ratio of no reshuffle to reshuffle 2.358453901703688\n" + "variance no reshuffle 0.0017933131401455986\n", + "variance with reshuffle 0.00043926585028530613\n", + "ratio of no reshuffle to reshuffle 4.082523462683998\n" ] } ], @@ -325,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "0a842c88", "metadata": {}, "outputs": [ @@ -335,13 +234,13 @@ "(0.8, 1.5)" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -360,7 +259,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "id": "2c95c620", "metadata": {}, "outputs": [ @@ -368,139 +267,61 @@ "name": "stdout", "output_type": "stream", "text": [ - "variance no reshuffle 0.0017096714891795739\n", - "variance with reshuffle 0.0008049080312952917\n", - "ratio of no reshuffle to reshuffle 2.124058181440057\n" + "variance no reshuffle 0.0010157191656484672\n", + "variance with reshuffle 0.000154210138968546\n", + "ratio of no reshuffle to reshuffle 6.586591338560701\n" ] } ], "source": [ "print('variance no reshuffle', np.var(Agg_C_no_reshuffle[100:]))\n", "print('variance with reshuffle' , np.var(Agg_C[100:]))\n", - "\n", "print('ratio of no reshuffle to reshuffle', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C[100:]) )\n" ] }, { - "cell_type": "code", - "execution_count": 14, - "id": "03f8bca1", + "cell_type": "markdown", + "id": "fd3f2aaa", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "GPFRaw = 0.984611 \n", - "GPFNrm = 0.987928 \n", - "GPFAggLivPrb = 0.978457 \n", - "Thorn = APF = 0.984611 \n", - "PermGroFacAdj = 0.996642 \n", - "uInvEpShkuInv = 0.996642 \n", - "VAF = 0.950797 \n", - "WRPF = 0.307358 \n", - "DiscFacGPFNrmMax = 0.983604 \n", - "DiscFacGPFAggLivPrbMax = 0.996471 \n" - ] - } - ], "source": [ - "Dict_no_reshuffle = deepcopy(Dict)\n", - "Dict_no_reshuffle['reshuffle'] = False\n", - "example_Harmenberg = IndShockConsumerType(**Dict_no_reshuffle)\n", - "example_Harmenberg.cycles = 0\n", - "example_Harmenberg.solve()\n" + "# Reshuffling and Harmenberg" ] }, { "cell_type": "code", - "execution_count": 15, - "id": "0bfd6974", + "execution_count": 11, + "id": "03f8bca1", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'aNrm': array([[0.18673842, 0.18778001, 0.18685129, ..., 0.18853899, 0.18923216,\n", - " 0.18652782],\n", - " [0.34263865, 0.66416561, 0.39870003, ..., 0.48273589, 0.40043953,\n", - " 0.230585 ],\n", - " [0.2405698 , 0.54966661, 0.49386995, ..., 0.866921 , 0.50311378,\n", - " 0.25621483],\n", - " ...,\n", - " [1.53373023, 1.19626029, 1.18471462, ..., 0.19904123, 0.98339864,\n", - " 1.28378556],\n", - " [1.48583188, 0.54857026, 1.06135142, ..., 0.65820269, 1.24243646,\n", - " 1.30799762],\n", - " [1.41333291, 0.69574559, 0.78154583, ..., 0.7872597 , 1.08866033,\n", - " 1.41226944]]),\n", - " 'cNrm': array([[0.81423508, 0.81496014, 0.81431365, ..., 0.81548847, 0.81597099,\n", - " 0.81408848],\n", - " [0.89880926, 0.98981798, 0.9189574 , ..., 0.94403789, 0.91951362,\n", - " 0.84163622],\n", - " [0.84773803, 0.96191564, 0.94723374, ..., 1.03181722, 0.94979898,\n", - " 0.85653362],\n", - " ...,\n", - " [1.12826238, 1.0845442 , 1.08288642, ..., 0.82235953, 1.05230395,\n", - " 1.09664729],\n", - " [1.1224348 , 0.96163028, 1.06458907, ..., 0.98839975, 1.09117436,\n", - " 1.09984293],\n", - " [1.11361419, 0.99670634, 1.01496732, ..., 1.01610223, 1.06889287,\n", - " 1.1134848 ]]),\n", - " 'TranShk': array([[1. , 1. , 1. , ..., 1. , 1. ,\n", - " 1. ],\n", - " [1.0566636 , 1.45468013, 1.13748907, ..., 1.24020774, 1.13748907,\n", - " 0.90063839],\n", - " [0.77312209, 0.77312209, 1.0566636 , ..., 1.45468013, 1.0566636 ,\n", - " 0.90063839],\n", - " ...,\n", - " [1.45468013, 1.45468013, 0.90063839, ..., 0.3 , 0.98164342,\n", - " 0.98164342],\n", - " [1.0566636 , 0.3 , 0.90063839, ..., 1.45468013, 1.24020774,\n", - " 1.13748907],\n", - " [1.0566636 , 1.13748907, 0.77312209, ..., 1.13748907, 0.90063839,\n", - " 1.13748907]]),\n", - " 'pLvl': array([[0.97640255, 1.0205327 , 0.95146509, ..., 0.97640255, 1.04731162,\n", - " 1.0978124 ],\n", - " [0.99645073, 0.97100124, 0.99648045, ..., 0.99645073, 1.09686163,\n", - " 1.20519206],\n", - " [1.09391597, 0.88191643, 1.04362556, ..., 1.09391597, 1.11938317,\n", - " 1.32307479],\n", - " ...,\n", - " [0.24299502, 1.05691422, 0.73409196, ..., 0.29862456, 0.87099003,\n", - " 1.02037148],\n", - " [0.24256272, 1.0550339 , 0.71676926, ..., 0.31275297, 0.79108078,\n", - " 1.04132247],\n", - " [0.24754319, 1.05315694, 0.75068078, ..., 0.31219656, 0.7896734 ,\n", - " 0.99078198]])}" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "example_Harmenberg.neutral_measure = True\n", - "example_Harmenberg.AgentCount = AgentCount\n", - "example_Harmenberg.track_vars = ['aNrm','cNrm', 'TranShk' , 'pLvl'] # Track level of assets\n", - "example_Harmenberg.initialize_sim()\n", - "example_Harmenberg.simulate() #Simulate with Monte Carlo" + "# Create agent with Harmenberg method activated for simulations\n", + "Agent_w_Harmenberg = IndShockConsumerType(**Dict, verbose = False)\n", + "Agent_w_Harmenberg.cycles = 0\n", + "Agent_w_Harmenberg.solve()\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "38917348", + "execution_count": 12, + "id": "0bfd6974", "metadata": {}, "outputs": [], "source": [ + "Agent_w_Harmenberg.neutral_measure = True\n", + "Agent_w_Harmenberg.AgentCount = AgentCount\n", + "Agent_w_Harmenberg.track_vars = ['aNrm','cNrm'] # Track level of assets\n", + "Agent_w_Harmenberg.initialize_sim()\n", + "Agent_w_Harmenberg.simulate() #Simulate with Monte Carlo\n", + "\n", + "# Compute aggregate consumption and aggregate savings\n", + "# note for harmenberg, we aggregate over normalized values \n", "Agg_A_Harmenberg = []\n", "Agg_C_Harmenberg = []\n", "\n", - "for t in range(example1_no_reshuffle.T_sim):\n", - " A_Harm = np.mean(example_Harmenberg.history['aNrm'][t])\n", - " C_Harm = np.mean(example_Harmenberg.history['cNrm'][t])\n", + "for t in range(Agent.T_sim):\n", + " A_Harm = np.mean(Agent_w_Harmenberg.history['aNrm'][t])\n", + " C_Harm = np.mean(Agent_w_Harmenberg.history['cNrm'][t])\n", "\n", " Agg_A_Harmenberg.append(A_Harm)\n", " Agg_C_Harmenberg.append(C_Harm)\n" @@ -508,130 +329,78 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "id": "6c5c04b8", "metadata": {}, "outputs": [], "source": [ "\n", - "example_Harmenberg_reshuffle = IndShockConsumerType(**Dict, verbose = False)\n", - "example_Harmenberg_reshuffle.cycles = 0\n", - "example_Harmenberg_reshuffle.solve()\n" + "# Create agent with both harmenberg and reshuffling activated for Monte Carlo simulations\n", + "Agent_w_Harmenberg_reshuffle = IndShockConsumerType(**Dict_w_reshuffle, verbose = False)\n", + "Agent_w_Harmenberg_reshuffle.cycles = 0\n", + "Agent_w_Harmenberg_reshuffle.solve()" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "id": "99228789", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'aNrm': array([[0.18667494, 0.1877387 , 0.18675973, ..., 0.18871716, 0.18970184,\n", - " 0.18652782],\n", - " [0.230669 , 0.29718104, 0.33358091, ..., 0.50083041, 0. ,\n", - " 0. ],\n", - " [0.70153531, 0.48645491, 0. , ..., 0.09061339, 0.17534169,\n", - " 0.17534169],\n", - " ...,\n", - " [1.42161167, 1.06740389, 0.82704187, ..., 1.77040745, 1.32524052,\n", - " 0.01727425],\n", - " [1.26022032, 0.98527749, 1.05449411, ..., 2.14127641, 1.57985465,\n", - " 0.23079142],\n", - " [1.28590661, 0.75932705, 0.90545731, ..., 2.31008148, 1.75454486,\n", - " 0.69650608]]),\n", - " 'cNrm': array([[0.81419089, 0.81493138, 0.81424991, ..., 0.81561249, 0.81629793,\n", - " 0.81408848],\n", - " [0.84168756, 0.87863288, 0.89487884, ..., 0.94920467, 0.49191247,\n", - " 0.49291813],\n", - " [0.99796922, 0.94510537, 0.60685372, ..., 0.74095135, 0.80630174,\n", - " 0.80630174],\n", - " ...,\n", - " [1.11462143, 1.06554292, 1.02400388, ..., 1.1551859 , 1.10211875,\n", - " 0.66911915],\n", - " [1.09353702, 1.05260005, 1.06350837, ..., 1.19245531, 1.13383698,\n", - " 0.84176237],\n", - " [1.09692724, 1.01055416, 1.03864051, ..., 1.20821035, 1.15340871,\n", - " 0.99687222]]),\n", - " 'TranShk': array([[1. , 1. , 1. , ..., 1. , 1. ,\n", - " 1. ],\n", - " [0.90063839, 0.98164342, 1.0566636 , ..., 1.24020774, 0.3 ,\n", - " 0.3 ],\n", - " [1.45468013, 1.13748907, 0.3 , ..., 0.3 , 0.98164342,\n", - " 0.98164342],\n", - " ...,\n", - " [0.90063839, 0.98164342, 1.45468013, ..., 1.0566636 , 1.45468013,\n", - " 0.3 ],\n", - " [0.77312209, 0.98164342, 1.24020774, ..., 1.45468013, 1.24020774,\n", - " 1.0566636 ],\n", - " [0.98164342, 0.77312209, 0.90063839, ..., 1.13748907, 1.45468013,\n", - " 1.45468013]]),\n", - " 'pLvl': array([[1.0978124 , 1.04731162, 1.0978124 , ..., 0.90825469, 0.90825469,\n", - " 1.0978124 ],\n", - " [1.20519206, 1.02259774, 1.20519206, ..., 0.82492659, 0.90663886,\n", - " 1.07190683],\n", - " [1.14669818, 1.04359443, 1.32307479, ..., 0.78488885, 0.823459 ,\n", - " 1.09391597],\n", - " ...,\n", - " [0.65773998, 0.99370883, 0.77608912, ..., 0.8372588 , 1.55721043,\n", - " 1.04073149],\n", - " [0.59739542, 1.01411236, 0.7384217 , ..., 0.79662252, 1.41434368,\n", - " 1.14252793],\n", - " [0.5425872 , 1.01230819, 0.75358349, ..., 0.72353615, 1.55268403,\n", - " 1.11556719]])}" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "example_Harmenberg_reshuffle.neutral_measure = True\n", - "example_Harmenberg_reshuffle.AgentCount = AgentCount\n", - "example_Harmenberg_reshuffle.track_vars = ['aNrm','cNrm', 'TranShk' , 'pLvl'] # Track level of assets\n", - "example_Harmenberg_reshuffle.initialize_sim()\n", - "example_Harmenberg_reshuffle.simulate() #Simulate with Monte Carlo" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "8d54d37b", - "metadata": {}, "outputs": [], "source": [ + "Agent_w_Harmenberg_reshuffle.neutral_measure = True # allow the use of neutral measure (allow for Harmenberg Method when simulating)\n", + "Agent_w_Harmenberg_reshuffle.AgentCount = AgentCount\n", + "Agent_w_Harmenberg_reshuffle.track_vars = ['aNrm','cNrm'] # Track level of assets\n", + "Agent_w_Harmenberg_reshuffle.initialize_sim()\n", + "Agent_w_Harmenberg_reshuffle.simulate() #Simulate with Monte Carlo\n", + "\n", + "# Compute Aggregates\n", "Agg_A_Harmenberg_reshuffle = []\n", "Agg_C_Harmenberg_reshuffle = []\n", "\n", - "for t in range(example1_no_reshuffle.T_sim):\n", - " A_Harm_reshuffle = np.mean(example_Harmenberg_reshuffle.history['aNrm'][t])\n", - " C_Harm_reshuffle = np.mean(example_Harmenberg_reshuffle.history['cNrm'][t])\n", + "for t in range(Agent.T_sim):\n", + " A_Harm_reshuffle = np.mean(Agent_w_Harmenberg_reshuffle.history['aNrm'][t])\n", + " C_Harm_reshuffle = np.mean(Agent_w_Harmenberg_reshuffle.history['cNrm'][t])\n", "\n", " Agg_A_Harmenberg_reshuffle.append(A_Harm_reshuffle)\n", " Agg_C_Harmenberg_reshuffle.append(C_Harm_reshuffle)" ] }, + { + "cell_type": "markdown", + "id": "d57aa60a", + "metadata": {}, + "source": [ + "# Comparing reshuffling, harmenberg, and standard Monte Carlo Simulations" + ] + }, + { + "cell_type": "markdown", + "id": "8c8e08ff", + "metadata": {}, + "source": [ + "## Aggregate Savings" + ] + }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "id": "5d301624", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(0.2, 1.5)" + "(0.5, 1.3)" ] }, - "execution_count": 20, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi4AAAGzCAYAAAAIWpzfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC17ElEQVR4nOydeZzN1f/Hn59778zc2ccwGIydkMFYkihLNISihVBRlpRIpdAmKb6FNipKP0sRkiUhu2TftyxZxmD2fZ+7fT6/P+7Mvfcz984mjOE8H495zL2fz/mcz7mf5ZzXeZ/3eR9JURQFgUAgEAgEgnKApqwLIBAIBAKBQFBShHARCAQCgUBQbhDCRSAQCAQCQblBCBeBQCAQCATlBiFcBAKBQCAQlBuEcBEIBAKBQFBuEMJFIBAIBAJBuUEIF4FAIBAIBOUGIVwEAoFAIBCUG4RwEQgEghvA5cuXkSSJBQsWlHVRBII7GiFcBIJbyLfffoskSbRt27asi1LmLFmyhC+//PKm5L127Vo6duxI5cqV8fLyom7duvTr148///zzppxPIBDcOiSxVpFAcOto37490dHRXL58mfPnz1O/fv2yLlKZ0atXL06dOsXly5dvaL4zZszgrbfeomPHjjz++ON4eXlx4cIFtmzZQvPmzW+aRURRFAwGA25ubmi12ptyDoFAALqyLoBAcLcQERHBnj17WLlyJS+99BKLFy9m0qRJZVIWs9mMLMu4u7uXyflvFmazmSlTptCtWzc2bdrktD8+Pv6mnVuSJPR6/U3LXyAQWBFDRQLBLWLx4sVUqFCBnj178tRTT7F48WKX6ZKSknjuuefw8/MjICCAwYMHc/z4cZf+E7/++itNmjRBr9fTtGlTVq1axZAhQ6hdu7YtTb7vxYwZM/jyyy+pV68eHh4enD59GoCzZ8/y1FNPERgYiF6vp3Xr1vz+++9O5Tpx4gQdO3bE09OTGjVq8PHHHzN//nwkSVJZTdasWUPPnj2pVq0aHh4e1KtXjylTpmCxWGxpOnXqxLp164iMjESSJCRJUpXZYDAwadIk6tevj4eHByEhIbz99tsYDIYir3FiYiLp6em0b9/e5f7KlSvbPhuNRj744ANatWqFv78/3t7ePPjgg2zfvt2WxmQyERgYyAsvvOCUV3p6Onq9nnHjxqmus+M9GjJkCD4+PkRFRdGnTx98fHwICgpi3LhxqusBpbvvAsHdjLC4CAS3iMWLF/PEE0/g7u7OgAED+O677zh48CBt2rSxpZFlmd69e3PgwAFefvllGjVqxJo1axg8eLBTfuvWraN///6EhoYybdo0UlJSGDp0KNWrV3d5/vnz55Obm8uIESPw8PAgMDCQf/75h/bt21O9enUmTJiAt7c3y5cvp0+fPvz222/07dsXgKioKDp37owkSUycOBFvb2/mzZuHh4eH03kWLFiAj48Pb7zxBj4+Pmzbto0PPviA9PR0pk+fDsC7775LWloa165d44svvgDAx8fHdg0ee+wxdu3axYgRI2jcuDEnT57kiy++4N9//2X16tWFXuPKlSvj6enJ2rVrGT16NIGBgYWmTU9PZ968eQwYMIDhw4eTkZHBjz/+SHh4OAcOHKBFixa4ubnRt29fVq5cydy5c1UWqtWrV2MwGHjmmWcKPQeAxWIhPDyctm3bMmPGDLZs2cLMmTOpV68eL7/8su03l/S+CwR3PYpAILjpHDp0SAGUzZs3K4qiKLIsKzVq1FBee+01VbrffvtNAZQvv/zSts1isShdunRRAGX+/Pm27aGhoUqNGjWUjIwM27YdO3YogFKrVi3btoiICAVQ/Pz8lPj4eNX5Hn74YSU0NFTJzc21bZNlWXnggQeUBg0a2LaNHj1akSRJOXr0qG1bUlKSEhgYqABKRESEbXt2drbT73/ppZcULy8v1Xl69uypKmc+P/30k6LRaJS///5btX3OnDkKoOzevdvpGEc++OADBVC8vb2VHj16KJ988oly+PBhp3Rms1kxGAyqbSkpKUqVKlWUF1980bZt48aNCqCsXbtWlfbRRx9V6tata/uef50d79HgwYMVQPnoo49Ux4aFhSmtWrWyfS/NfRcI7nbEUJFAcAtYvHgxVapUoXPnzoDVH6J///4sXbpUNWTw559/4ubmxvDhw23bNBoNo0aNUuUXHR3NyZMnef75522WCoCOHTsSGhrqsgxPPvkkQUFBtu/Jycls27aNfv36kZGRQWJiIomJiSQlJREeHs758+eJioqylatdu3a0aNHCdnxgYCCDBg1yOo+np6ftc36+Dz74INnZ2Zw9e7bYa/Xrr7/SuHFjGjVqZCtTYmIiXbp0AVAN5bhi8uTJLFmyhLCwMDZu3Mi7775Lq1ataNmyJWfOnLGl02q1NguKLMskJydjNptp3bo1R44csaXr0qULlSpVYtmyZbZtKSkpbN68mf79+xf7ewBGjhyp+v7ggw9y6dIl2/eS3neBQCB8XASCm47FYmHp0qV07tyZiIgILly4wIULF2jbti1xcXFs3brVljYyMpLg4GC8vLxUeRScfRQZGelye2HbAOrUqaP6fuHCBRRF4f333ycoKEj1l+80nO/MGhkZWeJz/fPPP/Tt2xd/f3/8/PwICgri2WefBSAtLc1l2Rw5f/48//zzj1OZGjZsqCpTUQwYMIC///6blJQUNm3axMCBAzl69Ci9e/cmNzfXlm7hwoU0a9YMvV5PxYoVCQoKYt26dapy6nQ6nnzySdasWWPzsVm5ciUmk6lEwkWv16sEI0CFChVISUmxfS/pfRcIBMLHRSC46Wzbto2YmBiWLl3K0qVLnfYvXryYRx555KaXw9ESAlYrA8C4ceMIDw93eUxpG87U1FQ6duyIn58fH330EfXq1UOv13PkyBHGjx9vO2dRyLJMaGgon3/+ucv9ISEhJS6Pn58f3bp1o1u3bri5ubFw4UL2799Px44d+fnnnxkyZAh9+vThrbfeonLlymi1WqZNm8bFixdV+TzzzDPMnTuXDRs20KdPH5YvX06jRo1o3rx5sWUQU6MFghuLEC4CwU1m8eLFVK5cmW+++cZp38qVK1m1ahVz5szB09OTWrVqsX37drKzs1W97wsXLqiOq1WrlsvthW1zRd26dQFwc3Oja9euRaatVatWic61Y8cOkpKSWLlyJQ899JBte0REhNOxkiS5PFe9evU4fvw4Dz/8cKFprofWrVuzcOFCYmJiAFixYgV169Zl5cqVqvO4mqL+0EMPERwczLJly+jQoQPbtm3j3XffvWFlK+l9FwgEYqhIILip5OTksHLlSnr16sVTTz3l9Pfqq6+SkZFhm34cHh6OyWTihx9+sOUhy7KT6KlWrRpNmzZl0aJFZGZm2rb/9ddfnDx5skRlq1y5Mp06dWLu3Lm2xtyRhIQE2+fw8HD27t3LsWPHbNuSk5OdpnTnWxcUh7iWRqORb7/91il/b29vl0NH/fr1IyoqSnUN8snJySErK6vQ35Sdnc3evXtd7tuwYQMA99xzT6Fl3b9/v8vjNRoNTz31FGvXruWnn37CbDaX2L+lJJT0vgsEAmFxEQhuKr///jsZGRk89thjLvfff//9BAUFsXjxYvr370+fPn247777ePPNN7lw4QKNGjXi999/Jzk5GVBbKaZOncrjjz9O+/bteeGFF0hJSWH27Nk0bdpUJWaK4ptvvqFDhw6EhoYyfPhw6tatS1xcHHv37uXatWscP34cgLfffpuff/6Zbt26MXr0aNt06Jo1a5KcnGwr1wMPPECFChUYPHgwY8aMQZIkfvrpJ5U4yKdVq1YsW7aMN954gzZt2uDj40Pv3r157rnnWL58OSNHjmT79u20b98ei8XC2bNnWb58ORs3bqR169Yuf092djYPPPAA999/P927dyckJITU1FRWr17N33//TZ8+fQgLCwOskXtXrlxJ37596dmzJxEREcyZM4cmTZq4vH79+/dn1qxZTJo0idDQUBo3blyia1wSSnPfBYK7nrKd1CQQ3Nn07t1b0ev1SlZWVqFphgwZori5uSmJiYmKoihKQkKCMnDgQMXX11fx9/dXhgwZouzevVsBlKVLl6qOXbp0qdKoUSPFw8NDadq0qfL7778rTz75pNKoUSNbmvxputOnT3d5/osXLyrPP/+8UrVqVcXNzU2pXr260qtXL2XFihWqdEePHlUefPBBxcPDQ6lRo4Yybdo05euvv1YAJTY21pZu9+7dyv333694enoq1apVU95++23blOLt27fb0mVmZioDBw5UAgICnKZwG41G5dNPP1XuvfdexcPDQ6lQoYLSqlUrZfLkyUpaWlqh19JkMik//PCD0qdPH6VWrVqKh4eH4uXlpYSFhSnTp09XTX+WZVmZOnWqLV1YWJjyxx9/KIMHD3Y5TVuWZSUkJEQBlI8//thpf2HTob29vZ3STpo0SSlY/ZbmvgsEdzNirSKBoBywevVq+vbty65duwqNCptPixYtCAoKYvPmzTe9XGPHjmXu3LlkZmYKJ9SbQGnuu0BwtyB8XASC24ycnBzVd4vFwqxZs/Dz86Nly5a27SaTCbPZrEq7Y8cOjh8/TqdOnW56uZKSkvjpp5/o0KGDEC03gJLed4Hgbkf4uAgEtxmjR48mJyeHdu3aYTAYWLlyJXv27GHq1KmqKc1RUVF07dqVZ599lmrVqnH27FnmzJlD1apVnQKe3QjatWtHp06daNy4MXFxcfz444+kp6fz/vvv3/Bz3Y2U9L4LBHc7YqhIILjNWLJkCTNnzuTChQvk5uZSv359Xn75ZV599VVVurS0NEaMGMHu3btJSEjA29ubhx9+mP/973/Uq1fvhpfrnXfeYcWKFVy7dg1JkmjZsiWTJk0qdiq1oGSU9L4LBHc7QrgIBAKBQCAoNwgfF4FAIBAIBOUGIVwEAoFAIBCUG8qFc64sy0RHR+Pr6ysCMQkEAoFAUE5QFIWMjAyqVauGRnNjbCXlQrhER0eXamE1gUAgEAgEtw9Xr16lRo0aNySvciFcfH19AesP9/PzK+PSCAQCgUAgKAnp6emEhITY2vEbQbkQLvnDQ35+fkK4CAQCgUBQzriRbh7COVcgEAgEAkG5QQgXgUAgEAgE5QYhXAQCgUAgEJQbyoWPi0AgEFwviqJgNpuxWCxlXRSB4I5Dq9Wi0+luaagSIVwEAsEdi9FoJCYmhuzs7LIuikBwx+Ll5UVwcDDu7u635HxCuAgEgjsSWZaJiIhAq9VSrVo13N3dRQBLgeAGoigKRqORhIQEIiIiaNCgwQ0LMlcUQrgIBII7EqPRiCzLhISE4OXlVdbFEQjuSDw9PXFzcyMyMhKj0Yher7/p5xTOuQKB4I7mVvQABYK7mVv9jok3WiAQCAQCQblBCBeBQCAQCATlBiFcBAKBQHDdSJLE6tWr/3M+33//PSEhIWg0Gr788kuX2z788ENatGjxn88lKN8I4SIQCASCMiU9PZ1XX32V8ePHExUVxYgRI1xuEwhAzCoSCASCuxaTyYSbm1tZF4MrV65gMpno2bMnwcHBAJw6dcppm0AAwuIiEAjuIhRFIdtoLpM/RVFKXM5OnToxZswY3n77bQIDA6latSoffvihKs2VK1d4/PHH8fHxwc/Pj379+hEXF1donpcvX0aSJJYtW0bHjh3R6/UsXrwYgHnz5tG4cWP0ej2NGjXi22+/tR1nNBp59dVXCQ4ORq/XU6tWLaZNm6bKOzExkb59++Ll5UWDBg34/fffbfsWLFhAQECAKv3q1attMXUWLFhAaGgoAHXr1kWSJJfbLl++7PJ3FVV2wZ2JsLgIBIK7hhyThSYfbCyTc5/+KBwv95JXuQsXLuSNN95g//797N27lyFDhtC+fXu6deuGLMs20fLXX39hNpsZNWoU/fv3Z8eOHUXmO2HCBGbOnElYWJhNvHzwwQfMnj2bsLAwjh49yvDhw/H29mbw4MF8/fXX/P777yxfvpyaNWty9epVrl69qspz8uTJfPbZZ0yfPp1Zs2YxaNAgIiMjCQwMLPZ39u/fn5CQELp27cqBAwcICQnB19fXaVtQUJDTscWVXXBnIoSLQCAQ3IY0a9aMSZMmAdCgQQNmz57N1q1b6datG1u3buXkyZNEREQQEhICwKJFi7j33ns5ePAgbdq0KTTfsWPH8sQTT9i+T5o0iZkzZ9q21alTh9OnTzN37lwGDx7MlStXaNCgAR06dECSJGrVquWU55AhQxgwYAAAU6dO5euvv+bAgQN079692N/p6elJxYoVAQgKCqJq1aoALrcVpLiyC+5MhHARCAR3DZ5uWk5/FF5m5y4NzZo1U30PDg4mPj4egDNnzhASEmITLQBNmjQhICCAM2fOFClcWrdubfuclZXFxYsXGTp0KMOHD7dtN5vN+Pv7A1ZR0q1bN+655x66d+9Or169eOSRRwotq7e3N35+fray3ixKUnbBnYkQLgKB4K5BkqRSDdeUJQWdZiVJQpbl/5yvt7e37XNmZiYAP/zwA23btlWl02qtQqtly5ZERESwYcMGtmzZQr9+/ejatSsrVqwoUVk1Go2Tf4/JZPrPv6MkZRfcmZSPN1ggEAgENho3bmzzNcm3upw+fZrU1FSaNGlS4nyqVKlCtWrVuHTpEoMGDSo0nZ+fH/3796d///489dRTdO/eneTk5BL5sAQFBZGRkUFWVpZNNB07dqzEZfyvZRfceQjhIhAIBOWMrl27EhoayqBBg/jyyy8xm8288sordOzYUTUUVBImT57MmDFj8Pf3p3v37hgMBg4dOkRKSgpvvPEGn3/+OcHBwYSFhaHRaPj111+pWrWq00yhwmjbti1eXl688847jBkzhv3797NgwYLS/+jrKLvgzkRMhxYIBIJyhiRJrFmzhgoVKvDQQw/RtWtX6taty7Jly0qd17Bhw5g3bx7z588nNDSUjh07smDBAurUqQOAr68vn332Ga1bt6ZNmzZcvnyZ9evXl3hhvcDAQH7++WfWr19PaGgov/zyi9PU7uuluLIL7kwkpTTBBYCdO3cyffp0Dh8+TExMDKtWraJPnz4lOnb37t107NiRpk2blspUmJ6ejr+/P2lpafj5+ZWmuAKB4C4lNzeXiIgI6tSpg16vL+viCAR3LEW9azej/S61xSUrK4vmzZvzzTfflOq41NRUnn/+eR5++OHSnlIgEAgEAoEAuA4flx49etCjR49Sn2jkyJEMHDgQrVZ7QxbkEggEAoFAcPdxS3xc5s+fz6VLl2zBlIrDYDCQnp6u+hMIBAKBQCC46cLl/PnzTJgwgZ9//hmdrmQGnmnTpuHv72/7cwyyJBAIBAKB4O7lpgoXi8XCwIEDmTx5Mg0bNizxcRMnTiQtLc32V3BdDIFAIBAIBHcnNzWOS0ZGBocOHeLo0aO8+uqrAMiyjKIo6HQ6Nm3aRJcuXZyO8/DwwMPD42YWTSAQCAQCQTnkpgoXPz8/Tp48qdr27bffsm3bNlasWCHm2gsEAoFAICgVpRYumZmZXLhwwfY9IiKCY8eOERgYSM2aNZk4cSJRUVEsWrQIjUZD06ZNVcdXrlwZvV7vtF0gEAgEAoGgOEotXA4dOkTnzp1t3/PDKg8ePJgFCxYQExPDlStXblwJBQKBQCAQCPIotXNup06dUBTF6S9/7YkFCxawY8eOQo//8MMPb8gCWwKBQCAoGUOGDClxhPOiOHv2LPfffz96vZ4WLVq43Hb58mUkSRL1vOCmIRZZFAgEAkGJmDRpEt7e3pw7dw4fHx+X2zIyMsq4lII7HbHIokAgENzmGI3Gsi4CABcvXqRDhw7UqlWLihUrFrpNILiZCOEiEAjuHhQFjFll81eK9Ww7derEq6++ytixY6lUqRLh4eGcOnWKHj164OPjQ5UqVXjuuedITEy0HbNixQpCQ0Px9PSkYsWKdO3alaysLFW+M2bMIDg4mIoVKzJq1ChMJpNtnyRJTsuxBAQE2NwAJEni8OHDfPTRR0iSxIcffuhymyuKK7tAUBrEUJFAILh7MGXD1Gplc+53osHdu8TJFy5cyMsvv8zu3btJTU2lS5cuDBs2jC+++IKcnBzGjx9Pv3792LZtGzExMQwYMIDPPvuMvn37kpGRwd9//43iIJa2b99OcHAw27dv58KFC/Tv358WLVowfPjwEpUnJiaGrl270r17d8aNG4ePjw8jR4502lZQkBRXdoGgtAjhIhAIBLchDRo04LPPPgPg448/JiwsjKlTp9r2/9///R8hISH8+++/ZGZmYjabeeKJJ6hVqxYAoaGhqvwqVKjA7Nmz0Wq1NGrUiJ49e7J169YSC5eqVaui0+nw8fGhatWqAPj4+DhtKyhcZs+eXWTZSxNVXSAAIVwEAsHdhJuX1fJRVucuBa1atbJ9Pn78ONu3b7c5xDpy8eJFHnnkER5++GFCQ0MJDw/nkUce4amnnqJChQq2dPfeey9ardb2PTg42ClA6M2guLIL4SIoLUK4CASCuwdJKtVwTVni7W0vZ2ZmJr179+bTTz91ShccHIxWq2Xz5s3s2bOHTZs2MWvWLN599132799vi1Du5uamOk6SJGRZVn1XCvjhOPrAXC/FlV0gKC1CuAgEAsFtTsuWLfntt9+oXbs2Op3raluSJNq3b0/79u354IMPqFWrFqtWrbIFCS2OoKAgYmJibN/Pnz9Pdnb2LSm7QFAaxKwigUAguM0ZNWoUycnJDBgwgIMHD3Lx4kU2btzICy+8gMViYf/+/UydOpVDhw5x5coVVq5cSUJCAo0bNy7xObp06cLs2bM5evQohw4dYuTIkU5WmptRdoGgtAjhIhAIBLc51apVY/fu3VgsFh555BFCQ0MZO3YsAQEBaDQa/Pz82LlzJ48++igNGzbkvffeY+bMmfTo0aPE55g5cyYhISE8+OCDDBw4kHHjxuHlVTq/nOspu0BQWiSl4KDmbUh6ejr+/v6kpaXh5+dX1sURCATlgNzcXCIiIqhTpw56vb6siyMQ3LEU9a7djPZbyF2BQCAQCATlBiFcBAKBQCAQlBuEcBEIBAKBQFBuEMJFIBAIBAJBuUEIF4FAIBAIBOUGIVwEAoFAIBCUG4RwEQgEAoFAUG4QwkUgEAgEAkG5QQgXgUAgEAgE5QYhXAQCgUBwS/jwww9p0aJFWRdDUM4RwkUgEAhuM4YMGUKfPn2ctu/YsQNJkkhNTb3lZRIIbheEcBEIBIK7BKPRWNZFuCmYTKayLoLgFiKEi0AguGtQFIVsU3aZ/N3o9WyTkpIYMGAA1atXx8vLi9DQUH755RdVmk6dOvHqq68yduxYKlWqRHh4uM1qs3HjRsLCwvD09KRLly7Ex8ezYcMGGjdujJ+fHwMHDiQ7O9uWlyzLTJs2jTp16uDp6Unz5s1ZsWKFbX9+vlu3bqV169Z4eXnxwAMPcO7cOaeyz507l5CQELy8vOjXrx9paWmq/fPmzaNx48bo9XoaNWrEt99+a9t3+fJlJEli2bJldOzYEb1ez+LFizGbzYwZM4aAgAAqVqzI+PHjGTx4sEvLlaB8oyvrAggEAsGtIsecQ9slbcvk3PsH7sfLzeuG5Zebm0urVq0YP348fn5+rFu3jueee4569epx33332dItXLiQl19+md27dwMQExMDWP1NZs+ebRMP/fr1w8PDgyVLlpCZmUnfvn2ZNWsW48ePB2DatGn8/PPPzJkzhwYNGrBz506effZZgoKC6Nixo+187777LjNnziQoKIiRI0fy4osv2s4NcOHCBZYvX87atWtJT09n6NChvPLKKyxevBiAxYsX88EHHzB79mzCwsI4evQow4cPx9vbm8GDB9vymTBhAjNnziQsLAy9Xs+nn37K4sWLmT9/Po0bN+arr75i9erVdO7c+YZdc8HtgRAuAoFAcBvyxx9/4OPjo9pmsVhsn6tXr864ceNs30ePHs3GjRtZvny5Srg0aNCAzz77zPY9X7h8/PHHtG/fHoChQ4cyceJELl68SN26dQF46qmn2L59O+PHj8dgMDB16lS2bNlCu3btAKhbty67du1i7ty5KuHyySef2L5PmDCBnj17kpubi16vB6yCa9GiRVSvXh2AWbNm0bNnT2bOnEnVqlWZNGkSM2fO5IknngCgTp06nD59mrlz56qEy9ixY21p8vOZOHEiffv2BWD27NmsX7++FFdcUF4QwkUgENw1eOo82T9wf5mduzR07tyZ7777TrVt//79PPvss4BVxEydOpXly5cTFRWF0WjEYDDg5aW26rRq1cpl/s2aNbN9rlKlCl5eXjbRkr/twIEDgNVKkp2dTbdu3VR5GI1GwsLCCs03ODgYgPj4eGrWrAlAzZo1baIFoF27dsiyzLlz5/D19eXixYsMHTqU4cOH29KYzWb8/f1V52ndurXtc1paGnFxcSrBptVqadWqFbIsu/z9gvKLEC4CgeCuQZKkGzpcczPx9vamfv36qm3Xrl2zfZ4+fTpfffUVX375JaGhoXh7ezN27FgnB1xvb2+X+bu5udk+S5Kk+p6/Lb/Rz8zMBGDdunUq0QHg4eFRZL5AicVD/nl++OEH2rZVD+lptVrV98J+l+DORwgXgUAgKIfs3r2bxx9/3GaBkWWZf//9lyZNmtzwczVp0gQPDw+uXLmiGha6Hq5cuUJ0dDTVqlUDYN++fWg0Gu655x6qVKlCtWrVuHTpEoMGDSpxnv7+/lSpUoWDBw/y0EMPAVaL1JEjR0TcmDsQIVwEAoGgHNKgQQNWrFjBnj17qFChAp9//jlxcXE3Rbj4+voybtw4Xn/9dWRZpkOHDqSlpbF79278/PxUvifFodfrGTx4MDNmzCA9PZ0xY8bQr18/qlatCsDkyZMZM2YM/v7+dO/eHYPBwKFDh0hJSeGNN94oNN/Ro0czbdo06tevT6NGjZg1axYpKSk2q4/gzkEIF4FAICiHvPfee1y6dInw8HC8vLwYMWIEffr0cZpafKOYMmUKQUFBTJs2jUuXLhEQEEDLli155513SpVP/fr1eeKJJ3j00UdJTk6mV69equnOw4YNw8vLi+nTp/PWW2/h7e1NaGgoY8eOLTLf8ePHExsby/PPP49Wq2XEiBGEh4c7DTEJyj+ScqODC9wE0tPT8ff3Jy0tDT8/v7IujkAgKAfk5uYSERFBnTp1bDNaBHcPsizTuHFj+vXrx5QpU8q6OHc0Rb1rN6P9FhYXgUAgEJR7IiMj2bRpEx07dsRgMDB79mwiIiIYOHBgWRdNcIMRkXMFAoFAUO7RaDQsWLCANm3a0L59e06ePMmWLVto3LhxWRdNcIMRFheBQCAQlHtCQkJUEXoFdy7C4iIQCAQCgaDcIISLQCAQCASCcoMQLgKBQCAQCMoNQrgIBAKBQCAoNwjhIhAIBAKBoNwghItAIBAIBIJygxAuAoFAILhlfPjhh2Lhw2LYsWMHkiSRmpr6n/JRFIURI0YQGBiIJEkcO3bM5bZOnToVu6TC7YQQLgKBQHCbMWTIEPr06eO0/UY1aIK7gz///JMFCxbwxx9/EBMTQ9OmTV1uK28I4SIQCAR3EUajsayLcFMwmUw3JJ8FCxbQqVOn6z7eYrEgy/INKct/5eLFiwQHB/PAAw9QtWpVdDqdy23lDSFcBALBXYOiKMjZ2WXydzPWs01KSmLAgAFUr14dLy8vQkND+eWXX1RpOnXqxKuvvsrYsWOpVKkS4eHhNsvNxo0bCQsLw9PTky5duhAfH8+GDRto3Lgxfn5+DBw4kOzsbFtesiwzbdo06tSpg6enJ82bN2fFihW2/fn5bt26ldatW+Pl5cUDDzzAuXPnnMo+d+5cQkJC8PLyol+/fk6rWs+bN4/GjRuj1+tp1KiRagXpy5cvI0kSy5Yto2PHjuj1ehYvXozZbGbMmDEEBARQsWJFxo8fz+DBg11ar24UCxYsICAggN9//50mTZrg4eHBlStXMBgMjBs3jurVq+Pt7U3btm3ZsWOH7bjIyEh69+5NhQoV8Pb25t5772X9+vWqvA8fPlzodXRllRs7dqxNdA0ZMoTRo0dz5coVJEmidu3aLre5oriylzXlT2oJBALBdaLk5HCuZasyOfc9Rw4jeXnd0Dxzc3Np1aoV48ePx8/Pj3Xr1vHcc89Rr1497rvvPlu6hQsX8vLLL9tC4sfExABWf5PZs2fbxEO/fv3w8PBgyZIlZGZm0rdvX2bNmsX48eMBmDZtGj///DNz5syhQYMG7Ny5k2effZagoCA6duxoO9+7777LzJkzCQoKYuTIkbz44ouqcPwXLlxg+fLlrF27lvT0dIYOHcorr7zC4sWLAVi8eDEffPABs2fPJiwsjKNHjzJ8+HC8vb0ZPHiwLZ8JEyYwc+ZMwsLC0Ov1fPrppyxevJj58+fTuHFjvvrqK1avXk3nzp1v6HUvSHZ2Np9++inz5s2jYsWKVK5cmVdffZXTp0+zdOlSqlWrxqpVq+jevTsnT56kQYMGjBo1CqPRyM6dO/H29ub06dP4+Pio8i3uOhbFV199Rb169fj+++85ePAgWq0Wd3d3p22uKK7sZY5SSv766y+lV69eSnBwsAIoq1atKjL9b7/9pnTt2lWpVKmS4uvrq9x///3Kn3/+WapzpqWlKYCSlpZW2uIKBIK7lJycHOX06dNKTk6ObZslK0s5fU+jMvmzZGWVuOyDBw9WtFqt4u3trfrT6/UKoKSkpBR6bM+ePZU333zT9r1jx45KWFiYKs327dsVQNmyZYtt27Rp0xRAuXjxom3bSy+9pISHhyuKoii5ubmKl5eXsmfPHlVeQ4cOVQYMGFBovuvWrVMA232YNGmSotVqlWvXrtnSbNiwQdFoNEpMTIyiKIpSr149ZcmSJarzTJkyRWnXrp2iKIoSERGhAMqXX36pSlOlShVl+vTptu9ms1mpWbOm8vjjjxd6vQoyf/58pWPHjqVKDyjHjh2zbYuMjFS0Wq0SFRWlSvvwww8rEydOVBRFUUJDQ5UPP/zQZZ4luY6DBw92+l2vvfaaquxffPGFUqtWLVUaV9s6duyovPbaayUue0FcvWv53Iz2u9QWl6ysLJo3b86LL77IE088UWz6nTt30q1bN6ZOnUpAQADz58+nd+/e7N+/n7CwsNKeXiAQCK4bydOTe44cLrNzl4bOnTvz3Xffqbbt37+fZ5991vbdYrEwdepUli9fTlRUFEajEYPBgFcBy06rVq6tTM2aNbN9rlKlCl5eXtStW1e17cCBA4DVSpKdnU23bt1UeRiNRqe63DHf4OBgAOLj46lZsyYANWvWpHr16rY07dq1Q5Zlzp07h6+vLxcvXmTo0KEMHz7clsZsNuPv7686T+vWrW2f09LSiIuLU1matFotrVq1KtLn5MqVKzRp0kR1HpPJpLJ+vPPOO7zzzjuF5uHu7q76zSdPnsRisdCwYUNVOoPBQMWKFQEYM2YML7/8Mps2baJr1648+eSTqjyg+Ot4MyhJ2cuaUguXHj160KNHjxKn//LLL1Xfp06dypo1a1i7dq0QLgKB4JYiSdINH665WXh7e1O/fn3VtmvXrqm+T58+na+++oovv/yS0NBQvL29GTt2rJMDrre3t8tzuLm52T5LkqT6nr8tv9HPzMwEYN26dSrRAeDh4VFkvkCJHVbzz/PDDz/Qtm1b1b6CQxuF/a7SUK1aNY4dO2b7vnLlSn777TfbsBVAYGBgkXl4enrafidYf4NWq+Xw4cNOZc4XRMOGDSM8PJx169axadMmpk2bxsyZMxk9erQtbVHXUaPROPlN3QgH5ZKUvay55T4usiyTkZFR5INgMBgwGAy27+np6beiaAKBQFCu2L17N48//rjNCiPLMv/++6/KgnCjcHQ8dfRnuR6uXLlCdHQ01apVA2Dfvn1oNBruueceqlSpQrVq1bh06RKDBg0qcZ7+/v5UqVKFgwcP8tBDDwFWi9SRI0eKjBuj0+lUArFy5cp4eno6icbSEBYWhsViIT4+ngcffLDQdCEhIYwcOZKRI0cyceJEfvjhB5VwKYqgoCBOnTql2nbs2DEn8Xmzyl6W3HLhMmPGDDIzM+nXr1+haaZNm8bkyZNvYakEAoGg/NGgQQNWrFjBnj17qFChAp9//jlxcXE3Rbj4+voybtw4Xn/9dWRZpkOHDqSlpbF79278/PxUTrPFodfrGTx4MDNmzCA9PZ0xY8bQr18/qlatCsDkyZMZM2YM/v7+dO/eHYPBwKFDh0hJSeGNN94oNN/Ro0czbdo06tevT6NGjZg1axYpKSkqa8itoGHDhgwaNIjnn3/e5jyckJDA1q1badasGT179mTs2LH06NGDhg0bkpKSwvbt22ncuHGJz9GlSxemT5/OokWLaNeuHT///DOnTp36zyMZJSl7WXNLhcuSJUuYPHkya9asoXLlyoWmmzhxourhTE9PJyQk5FYUUSAQCMoN7733HpcuXSI8PBwvLy9GjBhBnz59nKYW3yimTJlCUFAQ06ZN49KlSwQEBNCyZcsi/T9cUb9+fZ544gkeffRRkpOT6dWrl2q687Bhw/Dy8mL69Om89dZbeHt7ExoaWmx01/HjxxMbG8vzzz+PVqtlxIgRhIeHFzp75mYyf/58Pv74Y958802ioqKoVKkS999/P7169QKs1qBRo0Zx7do1/Pz86N69O1988UWJ8w8PD+f999/n7bffJjc3lxdffJHnn3+ekydP3vSylzWSUnCQrDQHSxKrVq0q0Rz5pUuX8uKLL/Lrr7+WWrGlp6fj7+9PWloafn5+11lagUBwN5Gbm0tERAR16tRBr9eXdXEEZYAsyzRu3Jh+/foxZcqUsi7OHUtR79rNaL9vicXll19+4cUXX2Tp0qW3hZlJIBAIBHcekZGRbNq0iY4dO2IwGJg9ezYREREMHDiwrIsmuIGUWrhkZmZy4cIF2/eIiAiOHTtGYGAgNWvWZOLEiURFRbFo0SLAOjw0ePBgvvrqK9q2bUtsbCxg9cIuOLVNIBAIBILrRaPRsGDBAsaNG4eiKDRt2pQtW7aUyndEcPtTauFy6NAhVRTCfF+UwYMHs2DBAmJiYrhy5Ypt//fff4/ZbGbUqFGMGjXKtj0/vUAgEAgEN4KQkJASR5YVlF9KLVw6depU5JobBcXI7bS+gUAgEAgEgvKNWGRRIBDc0fyH+QcCgaAE3Op3TAgXgUBwR5IfiMtxdWOBQHDjyX/H/mvwu5IiVocWCAR3JFqtloCAAOLj4wHw8vK65YHIBII7GUVRyM7OJj4+noCAgFsWL0cIF4FAcMeSH4k1X7wIBIIbT0BAgO1duxUI4SIQCO5YJEkiODiYypUr35AF6AQCgRo3N7dbHplYCBeBQHDHo9VqyyTsu0AguPEI51yBQCAQCATlBiFcBAKBQCAQlBuEcBEIBAKBQFBuEMJFIBAIBAJBuUEIF4FAIBAIBOUGIVwEAoFAIBCUG4RwEQgEAoFAUG4QwkUgEAgEAkG5QQgXgUAgEAgE5QYhXAQCgUAgEJQbhHARCAQCgUBQbhDCRSAQCAQCQblBCBeBQCAQCATlBiFcBAKBQCAQlBuEcBEIBAKBQFBuEMJFIBAIBAJBuUEIF4FAIBAIBOUGIVwEAoFAIBCUG4RwEQgEAoFAUG4QwkUgEAgEAkG5QQgXgUAgEAgE5QYhXAQCgUAgEJQbhHARCAQCgUBQbhDCRSAQCAQCQblBCBeBQCAQCATlBiFcBAKBQCAQlBuEcBEIBAKBQFBuEMJFIBAIBAJBuUEIF4FAIBAIBOUGIVwEAoFAIBCUG4RwEQgEAoFAUG4QwkUgEAgEAkG5QQgXgUAgEAgE5QYhXAQCgUAgEJQbhHARCAQCgUBQbhDCRSAQCAQCQblBCBfBHUuO0cKJa6koilLWRREIBALBDUIIF8Edy8B5+3hs9m5+PXytrIsiEAgEghuEEC5lRK7JwjfbL3A2Nr2si3LHcvRKKgDLDl4t24IIBKUkOcvI9rPxWGRhLRQICiKESxnx095Ipm88R/cv/y7rotzxSGVdAIGglPT8+m9eWHCQJQeulHVRBILbjlILl507d9K7d2+qVauGJEmsXr262GN27NhBy5Yt8fDwoH79+ixYsOA6inpncexaalkXQSAQ3KbEpOUCsOmf2P+cl8ki88m60+z8N+E/5yUQ3A6UWrhkZWXRvHlzvvnmmxKlj4iIoGfPnnTu3Jljx44xduxYhg0bxsaNG0td2DuJ6NScsi7CXcOhyJSyLoJAcF1I0n+3Fy7eF8kPf0fw/P8duAElEgjKHl1pD+jRowc9evQocfo5c+ZQp04dZs6cCUDjxo3ZtWsXX3zxBeHh4aU9/R1DcpaxrItwV2GRFbQaMWgkKF/ciEf2fHzmf89EILiNuOk+Lnv37qVr166qbeHh4ezdu7fQYwwGA+np6aq/Ow35Npmia5EVzsVm3HFThuUCTo0mi1xGJREIrp8bIbXFsy+407jpwiU2NpYqVaqotlWpUoX09HRyclwPl0ybNg1/f3/bX0hIyM0u5i1Hvk3qkkm/nyL8y53M3XmprItyw9hwMobmkzeptpnF7AxBOURzA4aK3HWFV/NbTsdxIT7jP59DILiV3JaziiZOnEhaWprt7+rVO286642yuFxMyORaSvZ1H//zPuushf9tOHtDynM78PLiI2QYzKptJrN8x1mVBHc+N0C3oNO4ruYPXU5m2KJDdP18538/iUBwC7npwqVq1arExcWptsXFxeHn54enp6fLYzw8PPDz81P93WncCOGSkWvi4Zl/0eHT7U5DIwI1vWfvot/cvUK8CMoVJXHOPRebQe0J69h8Oq7YtI4cuJx8vcUSCMqUmy5c2rVrx9atW1XbNm/eTLt27W72qW9rboTOSMy0O/gmZ99ezr5ZBSweZc21lBwOXk4hPff2KpdAUBQlcc4N/9JqMRm+6FCxaR2F+097I6+7XAJBWVJq4ZKZmcmxY8c4duwYYJ3ufOzYMa5csQ45TJw4keeff96WfuTIkVy6dIm3336bs2fP8u2337J8+XJef/31G/MLyik3wkJicXCUWbzPdaCq2LRcZmw8R0zarZt+Peevi9w7aSMbC4lBsfTAFdpN28qZmFvvdC0sLmWEosC6N2H/92VdknKFdIPDJzpWO/mxYgSC8kaphcuhQ4cICwsjLCwMgDfeeIOwsDA++OADAGJiYmwiBqBOnTqsW7eOzZs307x5c2bOnMm8efPu6qnQcGOGinKMduHyxZZ/nfYvP3SV+6dtZfb2C7ww/2Cx+UXdoNgy+f4y43874XL/hJUniUnLLRO/GuGka2flkWss2B1xa04WfRQOzoMNb4FsuTXnvAO4ET4ujoglBAR3AqWO49KpU6cie62uouJ26tSJo0ePlvZUdzQ3ov7IMRXdALy9wi4czsYWP3Pgg9Wn+HFIm/9crnx8PIp+vK63Ur6anE16rol7q/mX+lgxNdSKoii8sfw4AN3urUr1ANf+ZjcMrZv9c3Yy+ATd3PPdIei0xfctJclq0Cpqfz75wiWzwFCuoig3JNidQHAruC1nFd0N3BCLSxHC5Wpy6WcaHblyYyPMFidcrvcSPPjZdnp+vYuEDEOpjzWZRY8TwGSxX4fsW+GP5HizFSEeS4pbCZxctKUQHBZFITo1h6aT1JHLhSVSUJ4QwqWMcKzHDebrM53nGAs/LstY+sYoJdtUonS5JgufbzrHnouJRabz1RctXK7HbO1oMbmSnM3MTedYcyyqxMcbhcUFUF/HW9LTlh2eR0UMFRXFOQfrqKtozwXfm+JivTj6yeQYLfxxItopjbBECsoTQriUEY6Vz0drT19XHkUJntL0wvIZcF/NYtPIskKj9//k620XGPjD/iLTerkXLVzMJYjCZzTLnIpKsw1PZjjMCjoQkcysbRd4bekx27bcYobPRAVtxfE63JKlEBz9WoTFpUg2nIqxfS44VPTDzkvUe2c9/efaI48XEqbFJZ1n7HDp8Gs0i3siKD8I4VJGOA4VLd5vdWY+dDmZXeeLtmIAJGQY+Cc6rUiLy/X0omtUKN7P4WqBYHeXE7N4es4etp+Nd0rrVsz4fEmiB49ddpRes3bx4y6rE+mS/fYpnPsuJTmlL06YFGXlORebwUOfbefXQ3dewMOCOFqebolng8riIhrJonC0oOy+YK8PMg1mPll/BoD9EfYYLI5CxNVsRce6JtNg5p/oNKc0whIpKE8I4VJGFPRxMVlknpqzl2d/3E9SZtG+G20+2ULPr3cxYeXJQtO40i3FTQV2bNT3XEhk1OIjJBYoS0GnvnG/Hufg5RReWOA8a6k4v8KSWFzWn7ROqf4+b0mCGZvss6cuJTovHlfc4FNRY/kfrzvNleRs3lrhejbUnYSjj4vlVkwRLyhcDvwAWz68fkenOxgvd63t8xUHX7V5f6uX5YhPt05ndnzXDS4sJwXrmtXHXA0VifsgKD8I4VJGeOi0qu97L9qtB9e7crRjb8tVz+vNX4+rvhc8T7bRwheb/+XEtVQGztvPupMxtP/fNpV4KVgxFhQ2vx+3V4rFxaAojY+LKyGWa3JRSReTp6UIsXQ3TRU1OdzHWxJ12VG47P8e1o+DXV/AuQ03/9x3CKkFfNA+WPMPoLaYrXbh71USUSKGigTlCSFcyoiC1gbHIY4jV1JIyTKiKArn4zJK3LA4WhNc9aJXHrFXakmZBlpO2azaP+evi3y19TyPzd5t22Ywy3SevsP2vWAFV3BIaswv9mnvxY29l2YmgysR5GqorDjxYS6iEvfTuxW6707D8XnLt2rdVBwdcvd9Y/+cXnLH6rsFx85BvSBvPt90ju3n4p2GcyLzrDGO2ye6sMIaivH7AuH7JShfCOFSRhRsQB17ReN/O0m3L3by3V8X6fbFTiav/adEeW47a1+rpLAGOn+46FBkyac+Oy5YWJqeWXF+Nv/V4pLtYuZUccMeRZ1Tp7Wf5E6PsOvYOLoKXnhDkWX4+UnX+3JTb+65yxF/noph6YErKqFxMSGLr7dZA0haCrzTVfw8sMhKsRaV3BLMWrycmHV9hRYIygAhXMoARVGcrA0jfz6s+p6YaeCzP88BsLCEa4o4BpkrLE5MfqyW65l1BC4sLg6fCzb2xU3TLJ3FxRnHw/OtUsW5zRQlbBz33OlxLW56D/vKPpjVGi5sgegjhafb9vHNLcd/5JvtFxgy/8ANu15nY9Pp8Ok2Hpu9yxap+mpyNu2mbWXkz0eYsPIk607GuDzWVODh7lC/Ut7MQgs6/4NIblaH3YIW2qKc+PP5J/rWL78hEFwvQriUATfLl8JRjBTW8KbnWK0UWu11CpcCFfglh57a9nPqmUXFnaE0Vo1irTd5eTkKk4re7k7pihQkDruKGlK6E7jpzpjze0DSeaulZdP7RadNdb3O1u3A9I3n2HEugT9P/bfhtLQ8/5SRPx3mWkoOJ66lMXqJVdA9+Nl21bpBFxNcWz8ch3rBWo/kmmTcA3fhWe03vOt8DahDBoBrX7CCFBeFWyC4nRDCpZRcTc7m6Tl7/lNFFnkdUW1LgkZT9LRIsIum0lpcvtpyHih6qGisQzwVKNnKtqWhqEUZLTaLi/W/p5uWw+93c05XRIOtOCgXkyyz5lgUj3zxFxcTnGcvlXduusXFccrzlT1Fp81KuLlluQH8l+u19ng0zT/axOeb/1WtB3bsaup/LtOlhEx0vtY4UJLWKn7Sc9VOvEUNFXVsaF16obj4RwLB7YQQLqXkw9//4eDlFKehndLw+aaS+RRUIo37NSUPTjd94zmb30dhlgWTRSYly8jyUsYq+WLLv1hkpUjhkl6gp+dqqOh6fUcSMg30+OrvQvfnC5eDl5MLTQPq63IxIZO0HNfRgs0WhdeWHuPfuEzeWHbMaX95n4VxW8Xt8PAr6xIUy38J0vfuKqvD7Ndbz+PtsAyGrjSR41wwY9O/PDVnL5JWbaEpKLIKs7h89Pi9tK0bCEB8uuGO9+sS3DkI4VJKkq5zqrIjqTkly+MPj3dY6v4xnTX2mTrFVS4rDl8DCh+OmvLHaV76+TB/nFCPozcJLr7x+OXAFS66iJ1SGKk5JicHWsdylaaadC0UFNwrbUbne9wmSPIXDizM9J1//vNxGTw88y8edRBDjmUzO1T+V1NyVGlqT1hHw/c2cD6u+IUrb1eyDTexhx1fylW/pdu/GirOX6soHAMxOk5pvmERi7XqVd0LDgMWZk3RaTR4ulnDMvz5Tyzvrzl1Y8ojENxkbv8a4zbD7Tp9QxwprJdfkKqS1ZH2Ce0u2zaLrIBkQut1EbAw/almqmPyx7cLEy7RabkciHC2ShS3ICLArvOJzP3rUrHp8tl2Np4mH2xURdW9kcHOtF4X8QjaimeNX0psAcmfhj59o9XxOSo1xyYGHSt8UyHXz9FxstsXOxm/4kSxAQPBKjjXXlzLueRzJSrnzSYmLaf4RKXO9AR8+wB82/bG513GFCcyziSdISU3BYPZwuHIFNX7pyukzrjeNcqcUefvbHGxnkfrdQHJ3T4s5+WutQkXgJ/3qX2Nzsam02XGDtYejyY2K5bQhaF8dvCz/1zac8nneH7D8xyKPfSf87pbOZ10mt6rerM1cmtZF6VMEMLlFhOfnsupqNJ58FfVpNo+H7ycgj74N7xq/YBH5Q3o3dSB7HR5FWx+xRla3d+6QzIj6ZxDfefj4VG8Feh6O52Ojf2NdEzWuNsFWJoLK5aiKEhatYUo//ybTtunjudPDXas8M2FhMSPc3CiBFh26CqvLT3GyWtpjF9xgrh09f58dkXt4p1d7/DU2qdc7rfIt9bHoCQzTUrN9qkQX7Kp+ypuwyGKy4lZPPO9w3pARTz8p5NO0++PfoT/Fs4by47z5Hd7mLXtvG2/45BQJR8P2+cb9ioo6rIVHAbMMpiR3BPwqjUPn3ozbdsr+rg71R+OvL3iBJcSsxj9y1G+PfYtAD+d/uk/F/e17a9xNP4oL2x84T/nVZ6xyArDFh7itaVHi7WkK4rC7G3n2Xo6Bo78xPjtb3A5/TJjd4y9NYW9zRDCpZT819kY900tuULOlCT2eOoJyhMuey4kMuCHfbj5HwPAveIu3HXqW6gtIFzyHXa9as/Cp8E0NB7OTsXuQRs4pnk1z4pTOAUjd5YUx+Nu6Iwqjd3SkZrtKFzMeFRdRdslbfFp+DFarwv2PS7On53XiDsKl8Lus6ue964LifSevYtlh64yc5Nri8q5lMItLVsit9BmcRu2Xrl1vacjV1KQtJlFitlSc91OtrePcFEUheNXUxky/wD7LtmFcVEWl3zLQY45xybSf/w7wpafo8Xl5jjBOtYBMpsdRPn2s/Gk55rR6FLtSSTruxLgWbRwOXHN/mzkWlwL8ushKcd5jTFXvPP3O7y27bU71vfm37gMtpyJY82xaJXTNrIFEv5VCfod5xKYself9i+eDL+/Snb6NXv6zR/cwlLfHgjhUkosspLnDPffX6bihp3GVgnipaqV+cPf2vAPnn/AOY8CFWp+zzC/gc63wGj11spM5+s8ju1R6S/r/8quwq/LaH1OI2kzOFCM42thOHZWVcLlP15C98Cdts9ZRoNNeLgFHMG9wn5yzNbKwKPKH67Pn39sXoA9R7GSZXAObgeFm/3zibiOQF6v73gdk2xi7PaxpT72etl+Lh6fhh/j02AatStr2Xomjpd+OnTdy00AmCSJH/z9OOXuPA3dBBQ6mHcbNUyD5u3n8W92czlJPfNPV4RwiU6yW1HyhaC7ToOiKDzz/T4iHfLKcvD5qh5Q/KKmJcNeNreAg3y3w94Bmbk5TzAr9qjQksZ6j89mbuNytt1/zhkFjXscYEG+joUx0wxpnE85T0K2WtC6a52fj4IYLUbWXlrLtqvbuJZ5rdj0N4zIPXBi+S05VYpDZ8vWuTvzB3wUCN+0gcMLbPuvJGfjQzbvuP0CgJujhXb3V7eiuLcVQriUkkzNWXwaTsGj6mrA2oO6PiuCwju9QopMsd9TD8BKX2vF6MoKsCRiuuq7ySLzy4Er7LloXVVWK0kg2StLRS48rL0iO1coOv8jeIUswqv2t9dtLXGs8ksS2G3PxUTeWXWSLIMZD11Rj6g9518OXWL2NqtlRdKpnWa1+ljyVZKr87+x/Bi1J6zjsEM04T7f2pc9cBReFbyKqnQVDl52HZG4uHWbbj0O1iWSGLrwEBv/iePTDSVwrJVl67DQuT9Vm5dpcvg6MIAB1auqtidrNDxcszovVq3slNVOTz1bY/cXebp0Yzp7ovZgkS2sOxHDoHn7nNbIulHsuejaGqApQrgkZ9ifKa2nNVhkUpaRyKRs1SrOoNZorhZELAkD7qup3uAwVKQPXqXaFZXvWC45nEuysPzV2ny0/wO+OfO2y3OYzBa86nyNd70v8Kozi8g0exDMklhAUnJT6LC0A0/8/gRdfu2C0WJvpEuycr3ZYW2rGZtP3jqry/wesHK41V/rJmOyKGj015C0mTarL8uftyfY9J71v2yhycUfmOE217bLXJLqJD0GYu1LQNxJlishXEpJuoe19+5eYT/ZRjOtpmym16xdxRzljEfldXz+70C0Ps7TnSW3ZJXYMBfxou9P2Mjgh7xsvhyrjkYxceVJFuVF29VqJDR6h8BVSuENr6TNwbv+NNwcLBk6nzMAaNztDXKzGv7F/LrCcYwvcykxy6WD4sAf9rNk/xWmbzynWim3IIps7+luPH2VNfkLzCkuHmvJeh5LnlXGV6/gWWMhbhX2uBQbhb3jhTkB6/wP4d1gChrPSLXZN//0/2FWSklJzzXx077IYp2FD11ORudnr9DSsu3PWnRJnHa/DIW/PoVf+gNgkk1sjdzKp1rXvlsHPPWkaLUc9tSrrC4mYFTVyow98hnPLdhiv38FeHnLy7y05SUWn1nMqCVH2H0hiQ+KmwGTeN4a+C4r0bYpJTeFEwk3vkGSNPaHxbPGEtvnYYuKdj7NMpiZVMqZPG3rBNLpnqACBXC2Dm49E4fRLNsbRCyq9EaKXvLj671r0eqtw15afSxnU+yC1lFUFMaZ5DOq7z+c/KHYYxwxyfbh5W0Z45l2YFqpjv/PFBXt+QZxMfU03nVm413/f3YLr+OaXsZM3l11krjNX9Dm4my6aw/admUXnIlndBEb7PNGMKcDJF1EURSGbx7Oc+ufu+X+dDcDIVxKi2w37+65kESW0cKZmPRSOzu6V7SKnZr1rX4Nkx+7lz9Gd0Cjv4pP/c/wrGl/0SUF6kxcV2heKxPG4F3f+mI7hv0Hq3B5rn0l23fF7FPgaIfeoj4GjVsa+irr7Xst3rbPGnfr7CDH6Z0lIV+rXEzI5JvtF1T7/jwVy45z8fT5ZrfT9OLj11KdIti66zSMe6QhAJLk4HMjmWzDZIriLHY0ebMpPlx7mgvxGZg9j6PzPYO+6u8l+AV20VFYIDLPaivQ6LLxrP4L0a6ESwGLS2JOItcyrCbw2r71SlCG4nln5UneX32q0AYzv8f1xvLjeFZfatue7fDsKgqcjk5n3t+XVA7KqgTpatP9yM0ji3QSdMzFsckzOoi5w4ZPea1AAMN88sXGsnPLbNsuxBczLf/7zrDna1jzqm3TY6sfY9D6QRyMPVjEgXlosvGovBZJZxVjrgI6Gi1GXt36Kn8lfecyi+LKmGOysHBvJJJbEm4VdoFUvA9Zgyo+TkPMkkYtJHT+Bxn912A+/HOL3arjYHGZ+mRjNA4Ow76NJ+DbeAIaj2gyck1MW3+GY/FqQaWxVLB9dhQVhVHQj2VPlD0IoVzcuhwuzvHL2V+KPea/kpKVYK8NN09ymUZW5BtmuTiban0OJY2ZbKORUVtH8VlggCrN4v1XOLvvT6djMxzq4DSNBEeLcJqOOoLBYmB/zH6OJRxjwT8LbkTxyxQhXIogI9dElxk7+Git3SoiO/TmD19JxLPmD3hUWc3P+1yvJ3Qq8RQvb3mZi6muHV/ddDInPnyEwQ/UxsdDh3vFHQDovOz5+clysW4Aksa1cNJqJBrXcKwoClQaLnprKhysGvk+MIWtg1QY+VaV/nP3Oa279N7qUwyZf5BjV1OdgvqlZpuc1mf59+MevNqlAZV9PcChwpY0Rps5383fedzeI2iT7XPvWbuxyIU1p84kZho4djUVWVYwmE14VPkdna/zKrzWgpiKjbK6OXIznZd3psfKHiTmJHI5w/5sXG+lmG0022LzHL2S6lT+FnMG8eDPj2GWzcRnFHC0lOzPjqwoPPr133y87ozrZ9qstubsjd7LgVhn3ytH0h0ayctu9qFKR+FiHc4rmnSj3aJTbFwVo1UEp1/bZ7umqYZUAHZH7S7sKBu+93yEe8Xd+DSYijc53LN/IlzcpkrTa1Uv/rr2F1kWu/VCNlQqmFWxeNf9HH3VP3CvVLxztodOi7Zg4LoCgsez2m9oPaNYHf2pQxr7PW5Z0w+Ni9g5XrW+p9esXfx4dBWH4tT31OzQSy+Jo+47u95Rfb+ScYVMo1XI5ViKt+q5suqsOr/KRcrrJ82Qxh+X/iDHnMPmyM08tKILUyvmCTQ3L2uabBP7LiWhKAoHYw/SfFFzmi1qxrYr21TP4/VQOcZu2f437SQ7r+3kJ38/Trq7c9zDbhnPLqaKjtLpYM/swhOsHIYx3T6z88sjX15vkW8bhHApgl8PXeNSYhb/tzvCts1Na+/Nn87cgM77Iu6B+0jOdu3UOGDdAHZF7WL0ttEu98dkxeCnt1bmOq2kGpLJp0JeQ6j1jMCj8h9O+4tCq5HINDn0/CR1oyppXS8/oPGIxbfxBNwr2gO0mbNrA84No2sUJF0qIGPIi9zpyi/BcV2Vq8nqCi0iMavQNYPctBokB9HlGbLQtsRAwUii1o32tDkmi0qAStri/SX6fLObRXsvcy79EO6Be/CssRhX3sUaXZZqdV/bORwsLm/seMP2+Uic2iRdkt5sPv8k/cPnhz4n05hJu2mOjaqZr3ZuJzvP/Dxj41ksnidIky+zP+qE88yWAsIlH5ch6S3qazVi84hiy/lJpUDb5ydrBLPdy2q1NJZy+Mzx2hQlXDZHbmZ6YAAH9B60r+LLpwc/Ve33dvMu5EjXjNatplrECvipr2p7TJbzYoiKUnQ8JI3+Cl51vlLN4MvvdOi8i57VB+Ch0xRwyFecLC62cznMGMt3yAWrpUgrOVslJW0u13KP41njF3TeEep9DjP4SjoryJFUQyqT9litGCUZajJZnN+DD/bc2Nkzk/dOZuLfE5m8dzJfHJwBwFI/XwAi7+3JkD+H8OiCTxm8+gOWHz3FixtftB372vbXGLdjnMt8I9Ii+CfpH8yymZXnVxKZXqADkJ0MCeeonGR/97NM9rpvYPWqPFutKrF5bY2iKfqZytJorEL91yGw8V3rxgIdINPslkXmQW46uLjmtyvFRx27i8gyWRu8/Irt+LVUpzQWh5cu02wXGb7FBHC7mlF8iH2dRkMtk5FrevV2bd4z6FHlD7Serv0ArMgU1KJajYTBsbGR1I2WvqrrXoxXrTnOG4vwjymIe6UteARtJTemD7nm8BId4yoMvaMz7Sud7EMqQb4epDn0NDVuqbbGzJJVH02AWhDofM4juSWimPJ6xI69VE0uWIpvzBbtjSSssf1aan3OYMls4pQuNjsWqALApxuGIysyqT6ue+LRmdGq7znmnBLNugB45o9nAGuDnpbTFK3XJfTVliFps5gXYeZg7GB+7jeO2IwM22jXLweuIhWItOo45CbLIOlS0eqjSM2pxIhFh+gRWpW+YTWsCcwlc4rNliRk4IyH829Z6OdL5+wcjAW0h3f9/wE9C83T0cGzsGj56cZ0qzD092ORvzUa9OIzi9l5yb7Mxu8Xf2d4s+FOxxY2VflihYsoeZdQURSrv9LxpbQ3we4Cvu4Fr21BvGrOQ9Ia8ar1Axln/qfaV7uiN6cvWz9rfU7jHnCA3JinUCx5w7vaLNYmvUGG/hGgQd4JixABDu+6xs1eVxllY6HO4lq96xk8juI+zeB6Cv3Z5LO4adyoF+B66HNT5KYSiRaAhJzrm8FYGjZHbgZg3aV1BGEXcgrwQfJBjpiSwfsw7t4w65SzSN0bs5eNlzcSXttev2Wbsnls9WMADA8dbvPtOTnYwUL7TVvIikfrZx+2zzI6PzdX3KxtSo7OX+WilFNAtCdptZCVAv/k1eWPfAwmdX4mh2PaVs0LEJkcAR6+VpEzoz4EN4eXdlIeEBaXPFJyU+iyvAt91vTBLJtRFIVNSVPwbTwBfXDe9DhFwcdkv2RGi/0lrFZBLVxMFlOJxIojZlmmvsZ5pdxDXu7og5cXI1pA53fMaVs6J5lz3C5CHHteADpf17NIFJcNeX4Ezotovc+q4qi0rROoSukRZDV764NXlziqbX6sDHcXPjT733mYt7s3sn3P0m9yGh6z+ffk9UDDKoep9vvUn2Gbrup4HQpeE43+CpKbc69SksBksZ/TK2SRy9+RP/srLSuOn+P3sSThAOsj1rtMm2XOQq+xL7fQYWkHl0MZBR3qHBuAn8/8DIBnyP+hcUuz9cBPZK4GIMdst6qtPxGvum8Aks5uoZIVBe960/EM+YldMZvZdDqO15cddzix9dgINx1XdIWL9RSthm41q/NicBWnfb55w3RpGnWvX+OWyuS9k9VC24GSWFwKC5B21WD3a7mcftlpv6IodP/SdaX9Z6VMduY5Fj/8/ZN0+ekFlFUvOTUOoLZMuELSOjxrBUSHn6f9enqFLELnexaPyutsaX0bTiHVfJXVkT+Sb+376PF7ijiZ/ZlpUcveGzLJJpdDRWCdRVgcZsVZfGSbsnl67dP0WdPHpbUknyyDfXhFV6DfnJKbwtzjc7mYepnB64cWmsf1TM12haN4S3H4TaOqBFlFiwNpynlcMe4vtdVl0Wl7nTD/n/nOB/yzCrKsvoJaB6PIP3FxTknz75BkMWEGJgZVZJmvD2kFVPtvvgXqalMORKuHy1XDshot5KTCt+3gy2ZwZo11R8xxygtCuORxOf0y2eZsYrNiuZZxjRyTCZ2P9WF1CzjCD4f+gP1zeEixNipeuQpZDkMw2aZcvvnrCF9ss1aQI7eM5NGVj6rOUdxqsPGGi+zw9nK5zy2g+ArFs7pz/IHTyueq7xqPvJ6DpugVqhWLc4wJSZMfgfMHvGouwLuuPe/XuzbgQ90CRmtXOh2Xq3X90hckP1ZGtQC90778xekOxh7k3b/eJlbnfB6Q0XpdtM2werze4/So00OVQuudN2Va4+jY6+Ar456Ad51v8amvnmYOVmGVYU5UbXMVwC3HaACzkYy5D7kooxqzbMZSoCEYuWWkqvJfdX4V7X5px4EYq9/Bt8e+5YFfHnDKq7AhA39fB6dnyYJH0Gb1cQ7DhWZZsQlCx2FCewID2ZLEYzWq0TOkWqG/K0vSkFmIWSTfSPFhpUCnfSv+XUHrn1sXmq+UF0itMOFSmDWgIKm5qWQYM9gauZWvt5+m1cdbuJyUjc7vKJ4hzg3Oq1Urc9LDnQT9eRLkQzSrU5PTLqxJpQlOVHDYVyNJeFbajVsFuyOrpMtkdJf66HzUEYl1/kfQuMfzR5zVKd+VBUWS8suiEGOxRwEevmk4KbmuZxVpPYoPIuhKmDhe96Lirvx44nvbZ0Uxw/q34fBCAN7d9S6zj83mzU3TncR1Pok5iXRZ3oVp+62/+1j8MfZE26/Xin9XMGLTiCL9T8yymWGbhqlWg3ecufm3l+v4OoEeFVxuB9gfs58l/6zg7wh7XecksJIvWYdzXJzzngznjo0ub7hHsuSyxduLP3y8+bhSIN1qVlely5U04FXRviEnGcwFLS72z2bZDGlXrWlMWRB182dQ3Wju+qGixJxEDsUdwltnV60JOQm4EaBK9/XJ9xkeFYOhgheP7ZN5drvMJz0vkZC3VND5hHhWJIwCoH/abpcOi32+ye9Ju+4xDN44sNTl985RyNaDUkJ/AfcKB5ENVdBX/YPcmL6FJ9S48NmRzLj52itQjZu1spr+VDOCTFHcr9uEQYLvdWpTcYZ+A1B4D0rSZqDzPY0upw3bzsZxOTkVfbWVmDMbY05vDihczYig39InivxtbhX2oq+61vbdQ+eBj1uBWVR5vi2OjXX+UImkS1GFRC/Iv3GZJLhfBocsNfoYLJnq6eHZZgPLD8xkSsXih3yiM6ORFechihRDCpW9rHFP8sf2h24ayk89fuK749ZZLJ1OyLyyzvosPd3fubeU/0S4eWRBbv5vNePmXyCtg3CrGejFxbxbr9VHo/WMQDYGWceQNBow57KpEHHtyEJ/30L3SYpCnFbLOZcNv53EnERW/LtCtc2r9ndkX34FjRRg27bs7DIW/LOA8NrhtuHe4sg0ZfLe7vc4HHcYQ0JXjFldAfCsvqzQY372U/+mFAd/N61FwcsAGV4GdL4nMGc2BkWHzvcEaMyY01o55eceuI8ZyVd4B/DNVjgbcwJd0ElVpdyxYWXe7HYP6yO8iHc8tsJepEqbOZOaCoBep7cFXCyIzu8YqcZ41bZ5J+cV+juLI9/ydSz+GGmGNDqGdCQn9pht/9nEwpd9mH92se2zRQL5wFxr77nVYP6O+huNrJAZ/RdUcF2fzT81n6TcJJacXcKE+ybw3IbnANjebzuVPCsxee9kANZfWs8zjZ5xmcfB2IPsjyk6dpArkg2FTyEftmmY0zYnMekwNX+evx9fOcwgytBeBtSCKV/2m7VZrCxoVXEg0k0H2Q4Wmz2zoVY729ckjYbTDkEhTbLJanHJ55j9nqAo17+2yy3krhcuz294nqsZV7EYgtDmTaBJNaTiiXoqoyJZwJyDUfLmhe3WxuLddZfp18x6CX86ugfPPDeALSd/dnkuSZuB1utf3AKOUj1RYfAWmc0t80P0l35u/QOnZcausZZl+Bgtad4FHzh176/VeZmn/5aJDVzDueoSG1qvxE3jgUl2Filaj3inbdbe+hbVJg8dPN06hCt5Cym2rl0TdwpOXSzasKev9is6n3/R50bz4gINXnW+RauPxc3/GDmSGY/K6+m3rugGSTb74FbAzK3X6gs1K7tXtA8LSJKJuqlRxDZ2ntWhlc146S4j5VYi3T2AbJMBx+ZW53MaZHcURYOU5/icY8plyuUlTnm5Yn3EeiS01I5VCI1U2NxCItdDIiXXLlwcya+oX9hkocdh+/3tlbiYdXVdX+fI5FRsQ/gaF2Z8yYLGMxI33xPk0ke1y6v2XDxkUH74Fmn4drAYeD+oonMeBfjdt+C0ezubfLzZ5FO0T1GuOZfPDnzGhsvqaM4atzR8GkzjeORQoD0Z8VFs/OkjoupL/Hjqx2LLlU+WKYvDcdZZbDrfUxgTuxZ7jFsBY4p/psKIP2UONJRoclWhwz8K7wzWElljCebMe9B6n7c9ExkZTVUz9PLprd3HzPQQvppjIaIqvP+cVtVwHIk/QujCUGpUqoljlaT1VFs1qvtU50KqOtSAxWCN9+IYsyef6Kxop20lJcecg6zItmdxzeNryM2y1xfpSfYh8paVW3IkXv1eehgVpi60cDFYIitEh6+fVTjrDQovbJbpfFJhZl8N+xs5P89RGfZyOw4dJv3yC9n7TuHdUiHLU1K994qiMPvYbOoH1KdHnR4qS8uN4NWt9in3PQ/IDN4q83kfDcfqKlg8JJpfkklZuoyEhlVpiDV+0VcFpj2fdCHirR6LMluqRLHX09kKVMlsIVGnJUWrJUarJdhiQQGWnPmJGmn/siewAj2yshhRtTI5DtZPs2yG3FTXPybiL6jbqbSX4JZz1wuXfD+UfBOp1qJwaf2veHUZo0qXb3atc8Z14+A4ZDD9oj2ug5tJoWYCNI1UaHj1ExrGmHn3eS3P/CXTIkKhRYQCn1h9HUrLY/vsL+fLf8j8r78WH3MKXSL/YWOtNhjcrGXVyArzvrLgk9frrhun8MAZBb9siajH6rEr7Yyr7J1/o8OYeaOrCk/uklnV4DTE10VnzqbQkW3Fw2UcDGumBnQ+VsfJXP1+oK9qaqxntV+dDqmeqNDphMyqBzRk662VvEaXCTp7zV47VqF6+Gj6A3tHaImuaE3nLSehz0oi397inaOwfInVge6PVF8WOYwsdYvczxtH7ecf1+EVLgZbK9l7I2VSfCSiKx7AvcIBUBSqJEN8BYjLdfZTcoVvtsKPX1lwnI793DZr4/XT6Z9oWqmpU6/Rzaxw/1lFJVoAasc5X98AJQX2zSFCXopGo/DkboXzutOcqGl9LrsfVqgVr7C48zpSqlivz16js3+NQQPG2GPMOzSTjp7VqW80csGhB6dYPHiu8g/ERz5ZrCBxRfNLMlVTYGNLydZot/ulXZGOnO4VdzJjQzg9X3+Ct/K29ZugLXFv0XGmnWyw+uFYw9uDJCs0jILLVcCkg44nFY7VlVhboNf7/lILNROgzXn7tR+8ReajQVp0Puq1qXz8t6GPD8XVAEjDKAV3C9wTBcv/Z+G5N7UY3K2/I9+Kci3T9TPlblIw6iA1O5kX7n3B5ldRKU2hYnIWhYXAS869fufXb459Q3RmNFqLQuOrCiM2DOWVmlbh1/4fmWbTvuZ7Lxjxmo4uNbtw9d/D9Dwos/Y+DRYtPLVLJiQRQhIVrp2sTP3HYrGcPcuiz+31y5urZIa+JvHD1xaSfeGtF7VkeUpsvWrtOIVdkNm/+AvqxCo8t01GjvyWLGD+TvjlIQ1h06Zwhik0OnOaM8lnWLVzLv3+lkkbH4hH1lUe2yezro1ErwMKgRkKC7ppUCSJRlcVKqYr7G4iFfss6cwKHib461rekilGhcFbrXXyG6tl0rxhzEta3l0mE8uHzOzZknm+VmdaN7OCpIDRTSL8kEyLS/BtL4UML/s5zZKEB0b25A1dNbimkOILif7WNDoUm3hJ0FmFyycVK7DMzxcM58HflyUuLJ8m2QS56iFVgwQeCuDh55T+duSuFi6W3Fwm/2TG4CaR4Qk/d9Fw378KD236m6x9OfTVywRk2huJnG5uPLTTdSTXygEy6UBwksLAv2T+r5uGbA/4aaajJcX6UPc6INMg2mF8NTOD9NiLeBoUPlxsoU4c/NxZw9q2EookISkKXY4pvPSnzDc9NfzVTIOXUaamw3B0y0sKflkKrxxeQMuYKGpmxDG7VXcAHt+r2ESLIy0uKSReOsKIA+5saKXhoVMybc8pvDtYq3qB3CQ9JiUXvSWb11daOFlLYtgm628JS/gBvv0Yz07TeLQQn4eKqRAzdRp1UytxKcA6PusWuFMV6C4fD7MBSVHsQ1/50/ocKpEvfrBe07bnLHzyjJa4ChJVkxWCkxWO15X4eKGF+g5hQR49KDOvu/W+ffbnn9RM/JPR9azH/W+B/f70OpbBzjAtEvDpfAugFk0zdn3LqyH38tFPZgIzrabuF8dqydFLPHxc4aUNMksf0nCxW8kWG7SKFmcGbrfwYfXVBMxdyXHPPxgXa+G+fxUy9bi8jwAd/lH4prd6m0EDqZsmoqlVgyaRCv3/loFdvBui5ZNF9nM/9I+F/uO1KBoJFGtlnN9w5rPA3485pxey+7JCmKeJC1XtwqWuJZN74/5gfEISw7Ua9nl6olMU2xi+b7bVMrGnkcTra2QsEvzdVGJFew0J/vDmShm9CeL9NRytbz2m7Ukjr6yT+b679Xl3QmOi41vqodVnt8v83EVLpTSFl9bL/Nla4nAD+7EeRutwTotLCtcqrEZrUbBoJVsEZu96XwDw6CFrA7Q9VMLgBt2PKByrI/G/fhrczNZro7Uoqvcvn9rxCrVjFTyNcKam9bdIssLiRVtxs2zlQ38Np2tZy1QlRcGQrqVthFp0tryosLex60az1XmZ8StcWRHjCXrTl5zQZ/j58FG+/fYfIJ2P7jvF0eoSGtl6TU7Vlvi7qfP11BkbYHZ39kUzJnWwBcvM52rGVb4++jWPHFMYtknmRO04pj3xC7jDa79byxaQDc0uyTR6uCGz5ljQKNDygoWqqc4lz0l0J+PH/3Panv9+VEqHubMsPPuWlg7/KCT6S0z8VQYW8KnTUTBgp/365Bw9SlpVAy9tkGl2WSHuw8l4Xr3Gs0YZBQ2DdljTHmio0DRS5sk91nvR7LKEXzb82kFDlh5MWkj2c7gnisL7v1hoEA0fPKvlQnWJygXcq/yzYOR6e1l8Lcc4le2J+wV3pm6y4JsDrw/XMnSzbPu9cQEweqRVgC/08+XRo3sJPW2hdrxClbxrN+BtLWEXFR44K7G5i4VEHy05koQ5V8MKb2dLp2euwsIvrNdy+pMa3vrtFGc4RZWW3gTUzWJRoC8/egTwWVo87TwKH+K9nZCUcrCAQXp6Ov7+/qSlpeHnd+MU4ZlGjVXfL1eG2i5GSBxJ8VOokG59gHPd4PlxVu1nSg/Fze8ky6fZe4m/PKRRvUSFcejBKrT+29mrvLR83kfDG6vt54vxDuD9oRnM+1rdQMoSaIq46//UhM/7asnwhE7m+tSKqcQJ4968ysKZRv2jkSQYaqyBdy5sbybhZoaqqRCcrDBupf24BD9/JrZ9gSmHviQ4BdI94dWXteR6SNSLVpi20FrWL/poGLxFJjDTmt93Pa3Co2K6wnffqH/P0Ne0TP/RQmAmHKov0fqC848b9bKW2nEKb+WVZVEXDevuk1j2P3VeKd5QoQjjV7KXjkCHiFB7G0kYddDxlEOve1g7Jv++l4rpEBcA9WNhf0OJsyES/U4Z+fIhdzL1Ep/8VPjwYK4b6IsJq7ChlcTyBzXM/9Kez8C3tJh1Ek0vy9RKVugdnMTI4Mrcd05W3YfiSPCD5Q9qOFJfon60Ql2dgaeWutlmQgx+Q0uOh0TFNIWamHjY8CiDs/6P14Iq4XdCT614hXnh1gbyyd0yvQ4635OoQOtzNvNHa/kXd9Kwpp2Gp/+28PQue/p+E63vmHeOQucTChmeIBkCeWVLolOeg97SMv5XayPleGzlFIXZc9TXe3djia/6aGm3rx6vb7daSI7Uk6ieZG8kXPHmMOvQ3ug/ir6ebw7TkqmHubMLzH6rAUFpUDHD9XGRQfDWMHWfMjhJoXacwutrSj+jZnWbQAz61DzhamXMS1piA+0NsWfuvdRMOEXfPTJ6k8JHA7UEpUHNA09x8JEVto5DaISMWStxNgQmLrNajfM5Ulei5aXbrzlJDG1ApZNFTxC4UBVVZycfWQKjDnQW0OVdvhXtJfY01vD5POt9PVFb4uNnNDS/pPDu8sLvz4GGEvf9W/z1mfa0hqP1re+OY3uSz7ZmEl1OWPPZ0U7m207uzDmRTOB6X3LcJA41kJj3iIbeB2SqpIJ3DoXel4C6WfR4yo9P/89C5XRoMGsOPh07FlvG0nAz2m8hXP4jexpLrL1Pw8Vq1t7q8v8V3hjdDOICwNMAfjmwuYVEt2OF3875XTVsaG01gf74hRnfG7RSffB9KcgWibjDAdedx/NvaFWm4oJMe1pD5xMK959z/n07QiU6nfxvj/F3j2p4eb3rSmf1/RJ99pU8/0WPVOf5TUVPXXfkVE1rz35/SC1e2XG5xMdMGWg1bxes3F56VWtrLONb5fJpmDcz513fcxnvj1NPEiCmAvxTS6LrMYVcD4WtPTow5OIGEk6W7v08UwMa57lrbG/sTa5XttMw2Cf9NVwIllQCrTQcri/RyoWYBdja3GotKy2xAbi0HhQk3dP6bpaEE7Ulm+DKZ+19Ej910fDpfKsl9kZxorbE0XoSg7fKrLlfolpSBdqcL3z46HB9ieqJSol+c0nZ0sL6/BQk2QcCi1nRoSDXKsLfTTUM+OvGTJUuLd89qkGjwEsb/vv5k31g0rNaKqYrfLik6PwiQ2Te6e/G53/kUuVs4QvolpR6mzbiXrNm8QlLgRAuN1i4/D50FA12bys23cKHNTxwWqaBcwwiG0m+hfeg8isfXDQy/5Upz2ioHQfPbS/+hek3QYuEhCJBj4MyL2wpm5f8duStF7VM/z/nhvHDgVbTfq04xeX+/4pJC4PetvauM09PZf0a16v1FiR/yBCsfg4/zyhd2eZ219DrlAfVr5WwVS0GrY8FS2bhC2LeTAq7d7eC4WO0DPtT5nIVqxNmo5LrVSdGjNby/ayS/Y4fwjXsbWR1Ci6NJe1W4EqAuaLfBK1TR++FsVZfFhSFh04pnKshkeUB/1fIsGo+A97WYtHa69fSdjZuBNEVoFoKbA6T2NVEw+TFN/aZjAyCWi6GJ0sqoktCozOnb/iCsDej/b6r47jsDK3Cd49qeOWVwivcYaOC+au5H/PCi66UCxMtAGdC7I5eVxwCqE55xvnyL+ssUfsR1z4S3z2q4VTeuLlJCzU7JzJLE81TbsVHMz36wv0gWUULwIY2Gga8rSXSeeJKiTnQ8OZMmzuTNzsrzQsuBLtO8+pILa8PL76hbHSi+KBK3/bUkORiaPeVV7Q2f4TIKhJpDrOAL7ZvhPEGtNMfDbBn0k57mm19XK+8/X13DQPf0vLWi1qraAm1X3ujm8SyB0v2Kl+qCp/007A1TMOycWGsvc+ez7/VYP89Rd/TTOcQOwAlFi27G0tMHKwlwjku3XXRf4KWyCoS7z/7329GwfexuGsBkOYtMfNJLb910LD8IQ3H6kiYXBTljzYSnz1Z+D0a+JaWVB+JHx8p2X3c3FJDppfEgXs0DBujZeBbWpuJ/+Tzw+k3UWcbJsvnaF2JD27AdSrIpjD1dfp4gJZPn9Jg0oJb23SGjbGfc3MLyVYWJInlHey/d+SoPNECIEnsDNUQV0Ei00vik/7WdDnucKqWxMYwiVm9rduWPqTBkrfw5IC3tTz/hpYlna3/Jw+w57+3UfH3M90TfumoIaGE7evW5vY8q+XNls7whDMh9jRpBaIHJPvAG8O07HbwY/qkn4bFnYq+9x885/relUS0LOqiITfPIPN/3TT8MMx5HHpZT79bsor9jeCuds69IP3DxebWh2VFe4nH9iu8NkJLYAZ88pOFXU0k7tNGEoOWf4I92N1Koe1RifEvahm4Qy7U/LzsQY1qPDnOISbB+89peW2NzN7GEifraHj5FYnnt8msvl+DWQse/iY8o030m6hDUhR8cqD1eYUqqQo7mklszyvvYxmZfJJoxFuGChVzOIfdTLjwYQ0Zntbj/r5XwtAkgO/6fcW0X9qrymnRSrw11PoIvH05jfkBfnzznbWX4GheP/RsV07GbmNnUwmtbHUu/vteDdl6qB1nUQ0lfPWYxuagJ7vLrGuh5acuGnQWGL5RpvMJ+zV793ktT/+tHiePa5XLpG7eNqH38DGZ+jHqHuUP4RriXcR52N/QOr67u4nVBP1e98+Q3N1peGA/yyc+zc+1o4itAO1PK6phob2NJAzuEhtaSXga4Xw1iSP1JJL8CziodrX/tpxeD/Lsg+dpfknhapCEWQtP75IJP2L/LS++piXTS+LjhWYa5s3i1Fc0kpvkbjvveYdYUkvcp3JZp6P/68G4WayNYlCqQrUkq9MxkkRkFauIKshvHTQk+lVi1LqinbTW3qfheD3rMxSfm8i5RwK4VimNeH/4p7Z1uy61Jj/+eAlPh1nymR7wTW8NhxtomDPLXKwp//XhWqIqSfhmK7y6VuZaJfizlYYkP5A1EuNf0DJrjoUqqaA0qIF0Xj2995ueGkatc7YkRFew+mdVTbUOH+Y7cZ+rYU/zbzXIqWam+SF19SZ7yGgMGk7Ullj5gKQyw698wPo+jn9BYuJyC1/00XKmpsSmi9Gs8vDFdMqLzWEal5adN+Nz+cy3PqdqX+NUbWd/mgMNJRZ1tTY6m8MUuh21PiOJfla/nj2NJatjNLCxlYZ990i8/4uFms4uPIDVH8OR9LwwCCFzrRGy/T7vZNv3c2cNz26XWd9aYkE3LR7Gwq0QHzyrpW6MQsuLSpEWk72NJNqdte/f1FLDI0etv3fD/dZthxtoePYtiROXM/ky3cS0p4Mw6uBsiER7rzS+a2UV6GvbSlwN0nC4voRZ5yKInqxD0Zg5XldDv4nODXtBR2OLVsKS177nekicqWm3hOxtJLHrXokGUQrRFSVeWSdzsarVl2virzKxATAmzzF21QMaJi02c2/eZK7+47VUyISPf7JQJVfGp3ouireFtfd14OHj6s5RnLkVSMdslqePBmjxyYXJiy1W6/vD1gIu6KpBo8hsaWF99o7Xg2cz01EOqR1sP31KQ2wFiRwPqyh2K8KQ02+ijtAImb57FI7Wk9jTxDrxxOgmsSNU4sXUdP6s5g94Ure5xTZMOnKUFm2V0s8ILCvu6qGirt/0IM6n8CiPAE+lZ7DCz7k77p2j8PEiC55G2N1EovcB62WUJXhmvJb7zyq8sVrGoIOhYzUY3UrWk+qRmcVnCUmE1il6nPGdxGQGZNhbj20nWhB82tpo2WaIOHDsuWO0WdRctWaFI7sir7HGx5u6Umf+PbGfrx5yR9ZInIi4wvIKlfnYRTTbfIJSFb75zsKlKjDhRR1uJoV9Z6I5FqRjqEPIdzeTwuK8IY3vHtXYRFjYBdnm+Pv+ixLnqth7FpKiMGWRBbMWjrz+CJuubSXXw/obPk5IIvSkhGG/Hxtb5vVWHX6f4/ogB2MPqhZJqx1rvV9ZekgIKGEvQ1EIToaYQPikxVi6rhnHcl8fZuatKOvovZ/sAyNHWxvO/Jkgvz0g8U61aGZcqcaexnl+UXmMTEljVGoaSRoNnWrVcD53IVhyg9HqrWOYlQ11+Ol0TdL+tMajGfWylk8WWgjIm/u9tbnEvHB777RP/T4MbDSQfn/0U+VZM/oBvM27babudW0kFna135MqyQqz5lr3TRysZex6M1USrHnKWoU53bXsyBvGUhQNudcGoa/2K5JW7VQVlKrw46UE6oxby5kJ38Bha9DGuT00bG0u0TRS4YNf1OJl1MtaEvxBb8T2HOQzeIuFsIsKHz+jpZ0mmz89vTDpJPrskXk4xkDHFgk8qQ8hsrK1IteZFZpcUeh0UuGHcA05eufn4MDlq2gVhc416pDuZsHDqPD6DiM1LmiZ2VdLRLDElkvptDV8i2/jCapjQxIUPA3wbw17vh5GhT993uHppOkk+joPGz/Z4El+O/+b7fubv1lom+fQadLC+oF1+T0wUjXrL5+Tg0/Chgmw/ztV/aGapQd0OCXjk2ttyH842wp9XC4jatYgNtS+gnqLM360ORrCiFkfEfHY4wCsahZCTEgUO5ppeHOlhbbnFDa0kpj/iJbKKQoWDTTR5fK3t3X6rocscyjSWr86ludkxJVi67d87r3cjQOWprYZXwANKzTk35R/izhKTUCmQtUUq2iyoSi0uqDwb3WJDC+Jtjm5NDAa+dnf3r4M32Cx+QzmW6/0BoX9kdfQ5AX1mWAaxuDf7LMj19e+n2+b9cXr3nfRmRX8sgvMRiqGdVej+TjnJfY2XEvfPTJJvrAz1N521IlV8mY8OjO7l0aV1hX/i09kQuVKtmvQ8oJCVCWJuAoSlTwrsb3f9hKXtaTcjPb7rrW4KIqC4pulitFmTG6He+BeVTo/2bnXF2ixkOyp5fWXdGgUBVmSWNFZti5+lVdBtKmcxg/hfiT4U2LRAvB2cuHRGfMJz8ziiUx1l/fYk/XITIknMczktJrop/GJaDVaqpkt1iiLLnBXFJ5Pz4Benckwb0HWWB9uCXAzZQF24dI1K5stDtFTEwIkRr2stQ0jmNwk3H0t6BW1adPkJjHgbS11Y+CCg6XhaH0Nrw+3WnOuVFa/5Iok8d5ga5lfqd6IAx6VWHfkW6pYLLTJNRBbX8vjXZxDxxekTdU2qu+Xq16HSVSSiMmLvWYwpOGlKDyXnmETLjl6iX4TrcLN5GbP/3ADDf3HW3vV70Uoth6XIx1yrL4mgS6et3wWRcdSwSJzxsOdt/MqH8cFEluZTlEt4C+iZ85l2rGPSQiQGPGa9dplnPkfI6qNwqK1i/DXWr5GJU/nxR/HadcwploQf7aUCElU+L2t+vmNC5ToN0GLlwGy9RIre1t4+f+s5zn5RDY76tuHu8xpLTBn3guol6MwpbXg/5L2U7tCLigKvp9MY/z7Czl6/x60PpcBOFVbYtgYieWJ0VRKlWjdLNj2fuU6x3JjYVctC/PiyEkZCqa8HvzqBzQ8EJ+FlAXulYwY3awHm3USJ+pKnKhb6CXHTVHQAZUM3qS7pWNwl+jbMJ62j9jHAjR5lYhi0avE2dUg52fM4C5RacBA0hfOBtTjy+v6rmP5OfV1mvOohrb/WhuqPY0lTjb3JSPJnm8Fjwqk5Ed0lWXY/x0FKRhVe5eDlaJ60Br8ZqVy6aOvcBzR+Jt3+DsMxjRsyEuvapEUiMkNxaOyVSR/96iGPY0UDjew5p1vAfXNtD+/Pi5iN7XPLp1P1f/xf2xV2vKOwzanaNgOGOK74x+wk1x3e2TsVB+J1IKHSJKt7ABPZWTSPStbJVyWdNLQJiWXpiEZBJkDSdDpqKC12EQLwP/c5tGu93j+t2MJn7d5jON+Vqu2MakDVNxFcinbaU9FZpOlLb6sZdUD9vvka5HJ0Gq4XAWuBIEu15fkIW+y7/RMwiIzifenSNHiLcu8nJJGQ6PjUicSRxyuQWJOIok5iS7rhNuNu9bHRZIkVtUfwi9R9jlwDxidvep9ZYU3CogJ2eJDkNnaW+qXZ/XI0ah7+8PT09ncUsOxPLN8iKn4JcP1aKjkYoVkgEmJ1kX/emZmMSMhyRosyAGDcpl3h+j4orlzhMXuWdnwoT9eRTSK7rZ4KVqnVU8Kfm9odI60mxAg2XqsC6Ot0x+UKs5rzli0EudrSE6VaVQlSSVaemSq5yTX1/kxqPEgJGMWvbKyaZNr9espK3Nh9wDrjDRXo86OogXg/pwcapnNzIq1+i59Gp9IE4OBKmZ7jzv/d0jA4uhYAiRngRlmMFLbbKZHlr1SNiTZpy7mL15476GRql5+PvoCxtVKnpUgwnk9osYG6/39v3AtkwfpSPF1IfIkyRb8L9FfovEz0TR+JpqsQPUzlhtnXSnXcXVhgAdr3I+7W/7VU6hUvQq7qzdDQR1BNN1borpswcPPXGxAMH+HBTB3GuzDoo0MRjrnNZhfxtnHX9wUheqmop3l8+9CtkP8AK8C11HKu3uGuMJXti6IG+oZIIer9aGmX030OrVlM8tT4vxL/vzykIYFXa1LLrQLtoZzr6iviIfOQcFF2uOt+BZSjzjyQ0wcfrICmyehKIXPSEnxlUj2k1QLr2brJfY20WB0eNYnJCVzSG8vj49D9NpOWdlUNZv5OK8eCzIXPt6xO/Iqz6Wl838xcXgpCr21+1T7C0bizcctqQ1Nk6sRnF74GlqF4ZZ3T43J9jXAsjwldj1qxrdGLvNi4+mZmcXcWOeh2I7uSQx++FObaAn212OIf9QpnSOPy5401zs7ennKCq7sCf55kdUVSeLtF7WMemQImvvbs7WFB58+rWX+I+qa6NeoGIId6pfHqndjcHqGrY4ojIi0iCL33y7ctcIFwE9joKnRSMfsHAItFr7O3eLUuPvJMkPS1D2jVDcDq6JiWHMtmrpGtSB5MDuH7ZHXGGkca9tW2Wzm0/gktAUu95IodeCAXIc1jH67FkOzhDq0kwYwPT6RJzOy+P1aNFMSksDducfhlnyx0N+Zf1Z9IeHvNYpib4B9g9E6VcxqgixFe8u3NFgbKc8SPF5+heRV0WH7T9GxrDp/Cr+Z9zr1KCtZLPjIMv4WC69GVifr0lgGNxnCnK5zCmZZYh6o9gD97+nPr72do/YCyCZ/fF0sNOfmcN3CHYRXE4ORtVExdMqzqjyalc2y6DgWxtjnt9ZyaECbGYwsj4x0XbiG1tC+7ycm0zHFG21aM9su77webkGBAtCshr9dnAL3uYVA7ElY2EuV7snIe6hazP0tiOPKs053XHY9xNjt3iCq+eeJbEVBnydiFEvhQ5LFsTQ6Fl+LTL/0DOTkBzGlh5JzbRBTrrnZronjb1sYHcfXcWpH+CCzmXsNzs7u9ybWRVG0vJxidejKf++9ZRlN3ntrSmujWv9LKxXiCJtyGT+L3TLzbFo67jEnAJyEC0C4IYZV7TVkeUqYZQv/e+h/TLhvAmv6rOHzjp9TybMSUztMhRX29cB+jC167vSOyGvcnyf+2f0lehfrZeVjiO+GOasuprSWReY5KD2TeIcVwz0cLC6z4hNZfzXa1jGbFu1iLbQ8/GSFt5NTbZ2TknIk/TdWenzIm5mlb3zdFIUvTE9iiHuMnOinbdtPBTzLO1W/p67JzP8SkqjjQuj+z22e7RkA8HTTAhqyrwwhMKsiU+PVzkrNAhry1sDN/NRvM33r91Xtc/XuAjybbm+DZI2EQeNLoI87ltyqTmkfys6hkdGkitXVpJa13nA1guBIdZ/qRe6/XbirhQsG68MwKy6BzVei8FUU1l1Tr+HhJ8tIwPBUBw9UScZfVqhrMnOlwNBLI6ORGHNNNsptmBafSC2TidlxCYQajXzpo14tOLSA5aKbW56Jrkoox3PacTDxRe7xvI/uWdlIQB2T2dpPa/+a009xK4Gr0lG960bBsUGjQTceysmhjtFEr7zGt1WBCqSRoXjrEYBfxRbFpll/LZplUc7zzP0dXrAWeRYADM4rvroBW69EsfVqFAFGD069O5hxbd6kffX2Tmlfa6m+bhW1DV2WaXyb8bzX9l0CDHaz9sftP3ZIoUCuc1kecxArjpWu4mLlXoDqZgt/RV5jw9UoKhSoUIItFr5x0bujsVVo9MvIpHuSP2/rllM7rxF9NMt6fgnom6EeSvR006ru8+Crh2FOB6fsP5StK0ffl1PyID81HHp2RQU2dMRgMThYUOwHWXJqF3rM+qvRfBmXwNEI5/D39xoM1DBb2HnlGu8lpZBiqURu1CDMGaG8a3pRlXZWbAITkpIJNRrxLCDmJbAF2XOkrnsImec+5JW8euDruAQezcxiUXQcgZL1Wg/rUIdfhjxmO6Yw4cvhBVQx2a249Y0muLQDPvTH49RqVdINV6PwcFhXRodEoD6QQY0H4e/hT2hQKNue3kbver3BYb2gBgU6VP3TM2wWqeomMxULPG/h9ZyHW9vWsW4zJj1MzpURoLiReX68bf8XcQnsirzGs2nptnfYwyHfgrLN0aazI/dh1b5WFe9zOr8jHyUk2T7fH3w/i3osomnFpi7TdlBKL1ymmwbyleVJAMzpzZBNvshmb4K8+pLtXvzQyQI3ewzffBFuyWpEx6hm9M7Kpo/D+/hu6Ej8PfyRJAl3rd3CWN9otNlaqjk0DXNi43kmvYA3vKLF10NHZuxT6Cxqa1lcotXyl+vQoWhT+UEAPItpJwI8Aorcf7twlwsXa+Mjgc1AXXCoJl+h9krPxhUHCoiBb4xP85jxY0Cied0X+eNaDI3zKpGK55ba0oXlWhuGCUnJ1DaaeD05hQ/1easqN3sar37f07ZBMC90qO98UhfrSbiXQLgUhm3I9qG3QZLwUGBNVAzT8iqLELOZFddi8JBl7vGrS6MKrhv8giTeO6LYNP6yQiOjsxAalJZB25xcXkpxEf2sAF6KgocCFiS83At32xoWOoyGentc/Mo61z1IT50nbJ2Mdl4X27autQoswmew94BWXIthZlwC7ybahxodRUwTF0Nr+fgGt6ZGIWbzhwqKh8dmQ5PHbV97afcxVLeBZdGxrLsarbqOHzmUxTerCt892woPh2ekuJ7X7LgElkTF8lpyaqFpfoqOpVdmFu8m2c/VwsFaIWXaVwlXzOo5odW8q2Gz5TmUy5R6Hz6Jzispg/U5fDg7Bx0FOhLAfTnW8+rycs3GPmSRi9ohplNODoPyGoKCFbmXrFAvy+qjE+QgyHIlPTgMp9Qym/k0IYmGeUPA9aQoOt1TmZp+dqdTD60HiuxiCGbXF3g7XP8Ah89RCadsnz9KSLI9G5MSk6hktvBBTefhKEmyxj1Bk3cuDz8n0eAlK8yPiadHjok5LgTxsITPVN8n6+bzeD214O5+b1X6tWhG5sU3mRmXwMPZOfjLMuOTU1mS9Sxjja/Q3SGugI/D7zIo6vcyUqmMIf4RAIK9ajLs3olYsmuREzWA2rnOC5T2dewUVG1DWOUwfun1Cx5a585YSSd8V7k4yPY5TXaoUxU3si68S9b59/F088DHx9nCPcestlQ+pLVPBPB0t5fAF2vnx7F+9nEQB0Ob2q1kFfLanp1vdUbjIDra5+Q6/yZFi5tWg2LxIeXfD1W7DmU9wrPGiSRr7M+9RYYuhhmFdKHseGhdOI/dhtzlwqWI4Ct5nL5/Dv0N79Mt+3uX+y0FngTZ4oOCBn9PNyo//hG0GW7b52gGnB9jrTwGpWeyNiqGF9My8DuR10PTutOzWTA/DW1LYICLuB6eFZw2FVy5tjS45fd4u7xr21bwAb/HZOJA5DWW91mF7pnFlASNVwX0huLXvsiV1I1a74wsfBWFebHxvJpaiHDpNNFpU7sQPViK9llw19grukoODsavt3rd9tnLzQt2fUEli0zvjCyeMEp4Hy1QmTpYf+4xmXgkOwc3rDMmTkZcIdJSg5xLr5Ib04f3kj6jo+FzhhjfplHufNIV63n3Wprg9txvlJiwZ8HDF55fo9rspSjUNDv/7jXXonk2LZ0FlRoQ6O2Ol4N1wZXjpCOeikKo0Ui7HLUzZYM8EdbIYKSFwci0hCSCHMR+c4ORSYlJjExJg6v92flWZwCyI0diTOqAIb4b/e/pT+eanV1YXBQelE6zN2MVbTOKrppGFRC0Lzs8Jz0M03B8grMpvDL2KnAd0iUfdpmnkBP1DAuj7L38XMk6rPWz2WopyFA8mWl6yrZ/ftNTdGhQiSDPINu2Cnrn99R2Xoe6oJrDvXOUk45Wk6cysth2NYp7jhVixclNhfzVkt+6wDr/Qard7opCA5OJz0aepbaLZ8U/276ic4BFZrBuM89EW8VMjQrW3965URCfPtUMxRjEI9k5tit8Vg7hZ0s3VssdaJpur68edHh2HjbOVJ1vo9wGY1IXMi++SZj2I64muJMd+TLm9Oaufx/W4dFm3o3w3XSABX+dZue/CeQW4ju45lo0HYpxBN6imUanrGzqG42Ys13PcnLXaRgTHspl2e6PYlS0nJWd0/vkLd3q6WaXGeHagwBkOazO7KUPsH12fEYOelrrppoVvXD3L3pmoaJocNfl5+ks1XbJoSga+302yTKXFLXvj+RCxmg1ZRNEsrTc3cIlp/gZPD5+NdmvNMaiFKj88oZrLAVuvmyyKve/x3fGQ6eF7tPAyzoVpYHJxDuJyXwbG190r0Dr0EvzrGAXKo16QVAjaNwbKtRRHVLkUFHI/UWdzerTUrVZkWkAroaOQSNpwMvZdNray/lFaxzsS+KV0UWfF1C0HipHshJZj7yDnDbVidkAUypaZ1cUQtuKjyEbKmFI7MKbHfqixY1aPveo/BE8ddaKWgKmJiYxOSoS1o9zyMX1UJEjPYzTMBtqYEq9n0QCiVSqskNuQS4ePGacwg/mRxljGgVuXkXmoyK/ofcr2Th0XZOZ8cmpNDy9BBSF2g7j88U56eVT0DKzMiqWtVej+SmmcB+KpzKyGJWahowOH72OkR3rIRsrY4jvhTHpYd67/z3rc+Rocdn3Hcc9hvOOzioQW5nVjvLrgoapvmuBlrl2i1S+5WSUcQxnlFqqtDmK2uHXES9FUQ3JZUi+6D28Mae3wMtiPy4nT7i8Z34R3o6gmfFHVsv24ciaFa29ckmS2Fz/BdZW6Y6vzgupQBXbL89XQasSLnaLm2PnxqPAeyABpF7FifNb4Furwy6eFUDnQfirX6mSqHwnOqqnbQPUMFt4Jj2DChYLv0Rbh300l7bC7q/4ql8oU/uG8nSrEKfjAOKVAHsZZT1rr0bzXmIyzzn4BmYq9g7Dm8aRWPJqQMUYxLIDsUxcabdYAGTf/zoF6ZeRyeJTmxiQ+SuZm//H8/93ACTXdUVdk5l2DhbLlwux3H4dn8jKqFiycR3DxEOnobK/F+vaLaWt+Xv6GiYz2DSBBJw7lO55q7znCwotFppprMNW6xxWTfdxECtOFo7GVotws2qurY753F83yEG4FI/ZYr9OM+IS6KcP4fH6jxdxxO3N3S1csqxOUwnd52CpEuoyiZ+HHwfetfaysi6/jGwMIPvqEOj2Ebx+mscLzH5RzFbh4pWvurVuKuvAgIxMHizOf8C7QDjb147DG2fhmcXwyj5w94IXNkDvr+EdayWjK2p+TQ/r+OuzadbGdnSYCzHhajnzhj1gnH1xslr18tZ2cvfmhVR1w/1yh8kAPO1uD3UrSRKK2Y/Mf98n4+xHWLLs804DLRYW580+0ru7qczKppLMVHYvIlhSdiGRu4CXOoRyn9unTOrwBvUq1GZLv00sf2wRZtneqLtpCp9hAaBxy3BaFt6R43JdlCJerctKMJ+YnyWBCqAtOiLBg3m9xs4hVstFaraReIqf/u3E6TXoHawLjsLlzSSrgH/RwWpxWG4AqC0zg2Ot17y22ezSibB9rrqxNKPFTSsxoUcj9k18mP6tQ1g/5kF7AkeLy58T8Jeyaayx+q+8kJaBMekhZkZZ35UFsXWgQm1V/p/GJ/FYRibLHXykslxYV+pWLdzyAQWH5PTkd45zHPJ68F5rD7tlzQrgFYiigBcOvl/5B8kyVTdPpva+7+HSdgbeY/WvCfcPY0F0HBPyrnWGQw/cURw6ipUGrqwJdTs5b1v8JGTkXQM/awfCzU39DLs3Hwhjjlm/6FxboN5NSmHnlSj10OXmD2iVuomBbWuiyYsNVQn1sx+r2J9HBevz0T8jk7UWu7DLdgincE4pPk6RUtvZ/8qRe6XLVKTwdxCgpYOf2TPpGapZfPlIeX85hVjl8sXBqB4t2fnhUxxVGrBXvheDi1lYWqzXzS0vTtJ4nd01YLTDkKveoa51jFRbER2ETwNgXOtxDGo8iKUu/P8A/tc3DHdtyZtvU55V9G9LU8Kzc3j/wamUgxBuhXJ3CxffYKhQh6Dg2miDXPtt+Lv7UdlXz5TH70XOqUXWxQlYMhvl7axO+IMfqNLLRqvo0Dk+VMYilht2RcEetd4f/PIEga3XHQytBltFjNa96KGiAGul+1ZyKms6zGR46HDV7upmi+uppu7e6mGpwLq2MrxeSz3Wfl/wfezot4P3H18KrV+EoZtt+xSLNyjumLPsPg+/RcVwb96wg4TCkw7Oax1K4hhao03h+zILtwZ4umuZ/8J9DGpbC4zZVNoxA68r+1QWF6mQ+yVZrJWbMbW11TRfgKwnF9PL8DGPG6cUX35H3roI/RdDz5lOuz6NT+TjhCTrrBGgxUebuW/GPqd0xfLrYJUvhaNvx+D0DNZfjWKsQ69UzrOGVJBlTKmtMKW2pG0xYf2jCOKMbO+Vy2hwy3sPqvrr+fSpZjSp5iiQnX1c8tErCob4R3nEaLWGjH2kiZMlrarFwieJyTYfMoCrilr0X5r6KEvG9ITqrcnWVyVKqcgM09MkKH7E1bPPHumbkYkkawgyPGPzL8hysBJ0b1GPX0e246ehbW3bohUHy+OeWXB4IRgdnChz03jr/hEseXQJ0yKO0MpgsDmomh3eN8c379n0dO4xGBlbWDwnczFxUDxcD83qq7eCwDwrbSHCpVBSLqu+vu3QIAPEYa8jgrT2d2eSaTDH5bp8ZuqP0WGK72XFeSZMQdx0RXce2mrOclj/Mh5FzIZqajTyY0wcf16NIlCW2Xw1mg/z/PbeSlJfXwOuz+eh07r8fFlxXovELU+4VPCyWupG6NbZ9o1IS+f3a9EcjrgCOtcWQHfvIAiwvj/+Hv5MuG8C9zo82+/fZ49mUzOw+CF4R8x5HZAhpvGMrr4MqrVgRDO1D+KMjjNKlWdZcncLl6d+hNeOQa12UK+LyyTeHtaX/PEw1+Z5t8a9Vd97Ng3h2Afd1Ikyiw7D7pxpKaeEvna86OEVr0AYtALNkz9St94jTutReMsyXHaO50HIfVaL0dDN8MQPUNM+5CT1+db2WZcX8K6iZ0Ukr0Do9YX12AIYkzsyPDWNL+MSVE7QkmzkmfRMPkpI4pOEJGvcmeIo0PtW4Uq47JsDX7eEVIcZKVs+tE6v/qkvLXQODWriOZfZ/hEdwaC0DKbIFshOck7QsDunlLo4ewgVg3cl62yhNsOcdvkqCo9nZuHj7qPqIXUxFFLJ6B1M2M36q3aFmM28m5jM9PhEVQklIMSsHvTUOnhb5MY8TW5MP0wliFf5qHEah+UG7LA0x4jOJlxckv8cqobh7HhiF7D31a0IRTRS+VxU7O9pkK+H1Uqg0cCwLSQMO0x7wyxmW/rSxvAd59pOs6WdnJhM8wt98JEa2ISLYy9co/ehTe1AvD3s1yADL+abw+0nXztGPfPNYka341NCv+mAm5s6vpKukPfVX1ZYER3L0AIhGGycXgNpRazk6O566NFx9gqOn98qPIyCjbPrVOKyn+4v1e5rin3YtrrWPsSXjg+PGz/mW8vjgERY7hza5s4mk+KHR7UuhIujlcNLslpTuufNpGtRyNTp+3IN1o4Z1uf8ycwstl+5xnPpBa+v63e2sOGYbPdAlALD9aGaCN7X/UTD7KM8pS1wjeo8TR2TGVeS5YFq1tgxLzR9weW58mlQsZHts0bS4OFQth5VxqIoEjlXn7Ntk/Mc4hv4N8GcV99a0JIiWYVmTb+anHj+BL3r9mbag9MIr+3wLN/m3N3CxZHmA6C7dUjl0ZjqKLKOnGvP2sxxep3r3mbBWA1Bvh4EeBV4PAtR2IXiIpZDkfhVw61xMeOVDbpBqN2ZcMmjdmdTL0WBZs/Y0474yzoU1jrP4z3kPmimDgvvSFFDKytGtqN5jbzGVNFxJm4IDzs6zflWw9xtKlogLrULp3ymcryx64ZMRVFOZL8MzDufQ+Pw53hIvghfhsL6t6zbYo7Zdrf4YyJfBHfj16gY2PuNy2xrms1MSE6hX9oauLLXab9WU0rB4oKXjGPZLzfioNwQpYZa/BkdxN4lpRpnZRc+B13eh4feglf2Q7Uwp93P5EUILZIqoSrzP8CgtjVZ6Deci3Iwe0OnwJM/gofzOL+ChieNkxliehuQirkmefsSXYdvbyLZY9m4abBb/EqIo5MkkkStSo6zQyQsigKSxlaSg5bmeHvoyC9yrmMzUyB2UqC3dV9EQevBeXvYfIyZsDNvtk6B36ip6DBbsP/P0HE8Lmni4r3+oon12baYYNsn6n0OQ6h+7nYxrnecfeMwLIp3JWg70vW584n/B2Y2gvVvQ/Ilp93LLfYgiLv0nZz2z3/Bah1NwY+4Eg5zarXOdYqH5Dx09nZyKhOSkvmqQDyetZbC/foqWWSVTDEobjzcqDLfP+fsV1JQuOx8qzP/N6Q1pz/qjjRsK/T83LZvrvsXDNVt4MWLY5jhNld1XI2nP7MO47Ua4nSOLzp9wfzw+fS/p7/TPhvNnqFppabUD6hvC/VQ2c9+T5fvqErmuSl5Uaqt5ES+hDHlPl69dwqjfzlq2370Sgp9vtnN4chkJEli6oNT6VVXPUvqdue6hMs333xD7dq10ev1tG3blgMHDhSZ/ssvv+See+7B09OTkJAQXn/9dXJzSzAccCvRaOH+kSSPi2dZ6mgyz03GnNHU9uDmj1sCDGxr9ygvkRd2Oxc+Jc2egffirVNcbwBuBWYa/RV5DR0S79//vsv0oUF2nx4vWbYKm3yqtbA6Hxfjf5FPvjOrK1rXDmRsV/sw3Aa5LTGOjeLDH6BrOYj7jd/xP/MzvP7ic7To/z4nG78JwA5L3iyDsGehk2Pgb1wG4gPAYoAP/WFyABxZ5Lz/wPdgNsLV/fZtmXF03fOjdUrxqVLM9HFAVwLh8vUAZzHhyCsvv05/4wc8bfwQ43O/w8OT4KW/iU3Lpe83e1RpZVevb2Bd6PIeVG4Ebs73JUVXiY0hr8GHDv4Bnd6x+kqNPgJjT8HIv21mb4Dt4zrxSd9Qvh7Vn5jndtG272irCJ4QCcHqWSCNg/MbyxKIuGIi4TbUOKwjVrUZPDod6qunpS83d6QwirsfbWoHgsNMq/xp0z2aWocB3LQO73YBJ+pFL95Hq1oVeKFTE3Wmfzg4lcafdj6pbzWo2xmtY2+9cW/o/A5McOF4+8jHztsAfugCB+fZhZGtnHbh0imkk+2zyuJS0Lm+20euz+FIZiwcmAtfq5/fxwxTVP5cpzytIiVdsT573z/XigfrX0cIecf4Ot0KH3r1l2UGpWc6LZURpQSxX25UyFFqPCQT8wa3pkMD53IWfIJqVvSiS6O8GUbeFaHNUNvkiyLxCoTXT0Hvr5x3uXnRumrrPIf1AgzbCq1egO7TcNO48dtjv/Hdw/YgnOMecXBxKDDlXDZWwRD7BGsOZxGTZm9vs4wWjl1N5cnvnDtf5YVSC5dly5bxxhtvMGnSJI4cOULz5s0JDw8nPt71cMiSJUuYMGECkyZN4syZM/z4448sW7aMd955x2X6skZvm4Nv/Z9vjnMcXnnrkXtsnzUOlzAn6hma1XDuheLt4sF287SONbd8ztpgOOLjHAq6ONwK9IQC/Wtx9Mmt9LuncEvJkw2epKLZwkup6VZ/n1KS34vrUL1oR7qCWBwfu1rtrDMxPniaYx88YouBUPuxCTwmfc3iejOsjepjs6FiPXVGE6/B+0nWxtbBiVjF76Nd+lCQqY5aTPMBpfoNNjq8kfc72pfI4vJY86LDkd/r4AOSZdbCg29AcDOmbTjD6Ri1Q/QZxcUUzhC7D4arGUsV7htA+NC8huqNM9DnO+gw1jrEULGedYxdknDH3rutU8naGPp7udGhQSWbkyaSpG5ggPH/3969x0VVJ/wD/8wMzAAiN4HhIhfxrogkKuGtWkfRSlNzH1JXjVxN01bDTMkLWpu4uevjPmVatmbP/rZ0s7Sezdg1lFp3KZNE0xTzUqgreAvwymXm+/vjyDCHOTMwCMKRz/v1mtdLz5wzc+bLmZnPfK8juqLeig87vTvodudLs/ftNYqCuwO/kofKF6qexm8q5uBn4Y0JFYtl9wW2dd6Xw9vgJoU8AO9WScHdx8MNqQOjsX5SH8SF2XQArxUCY8N98eGsAegQ4uRL+Zu37bcNmQ9M2YFhMdJMpsGeNn1yPHyA4bVqUBzVZv7nWyBvs/12mxoX25pQWY1Lz7FSP7Txm6T/u9rn5bZet97GISF/TxbqIjGs/FUMKV+LgDZ6DO8ZAp1WY5dR/2+O48+MD2cNACpsmnLa1t0nprZ8S0fkWez7LR63KDf5azQaxWbNqnosnaDYbKz8JPXbz1b7vsCotVLwgdREZPtdpNPan/PWGfdjSJea5rufLjuvYT10tgQLPjiIC2UtrDLBCZeDy5o1azB9+nSkpqaiR48e2LBhA7y8vLBp0ybF/f/9739j4MCBmDhxIqKjozF8+HBMmDChzlqa5iKrXoa8qvBgxnB8lT4U/m1qfr0Im9E8ix4YjTHx9Zwy2XYhxHYdpV/AY9+S+pMYHC8i5kgbmw+mt8wBUt8db/shw7aWD1iOz+9/BRGDFwFRA5zuq+S9R97DtNhpWNTffnilLXOtuTL+UHm7U2T8JGtflbYe7rImtraeeny4ZDLemtpP+lLVaKQP3P5PA+NufyFoNFKtkF8E4B0MPK3QTwdQHgFUWmtV8LPfOH0NDiU+DTy5E5jwvl3fIUf++EQ82hrc8Odp9v2A3HQ18zP0eXkXSm9KAeLKdftJ7H5bOQnFHccDT/1dun6Wl8qvHYUaF9gOv/QJA+InKn5xnVLofKio1i/ddm0abwKrNPdt0j8c9Pmqbnb4xDIAN+f9gFxLT9n9OoW/R3WNUBfj7XIaNB/Hx3yKl6qmAJDCjJtOi5G9QuF+zqZGztHfVqmMnQmNBwA8GvMo1pvW46+j5IsqIn5i/R+r7D/22xycj7dt7aTOTeqHFvu48uMqTDVQ25W2XREeYsSAjvIfZQLAD6I9StDWes1KM8TKv2rC/T3xm6GdFR87IcofsK3FjR2vuJ8zldDhf6rGYnXlf+HPVTW1dOMsmbL5dwDgTM9ZAJRr6LSN0PyL5xRq3hrJlev2fXsSY9rhf5/qj07B0t/8ZoXjvmE3K8wY/fq/8EHeWSyqNSS9JXMpuFRUVCAvLw8mU82FoNVqYTKZkJurXO00YMAA5OXlWYPKqVOnsHPnTjz8sONFqMrLy1FWVia73S0ajUb2a8D2Defr6Y4QX/mHqJ/BD8OihmF41HBMGxBb/wv9+kX7bb1TFDu11odvQs0MjJH/qf8F6NZzLPDAggb9Gujs3xnzEuahrd55D3dLrRqP7ZbBSI/5EHhMuS9JNXed/NcFtDrg4VeBuF8qHxDcXXn7GYWQ/M9aI3guK9TYxP8KaF/H38OrHRA9UN4ptg6PxYfj0PLhGNxZ+QuioqomDOw4IHXEVKrN+Rk+OD3wVVmnaRmdQt+qenRwBYA1Vb/E5qrhWN+xjjWfbGpcPN11iA2vqTEa56BDu8tqdYLE438C/KNR/Mi7aGtww+rxcfAy2DdrTh0Qbbdtw6/64MkB0dj05O1RaVotbrSLtc4r8syDCjNVO+Nqf7RwqR+FVqPFoPBBaOdZqzbWKwCYbXO9unsAySut83vIKCyBYTva7dy1mk68UT5R9vsq6TAEWHACmOW8GSGgjR5Z84bA6CN//d4KfwcAdsHFXafBrAc6Ku4rnfAAqbl67JuAVosCS91DqK198iB1Qr0FA9aZx2C/bc2LzgOvmcfJDms/Sqr9V/rh0cXo2ugdRb5Nt/6Ps3kkq2uQCoodT7Ta75XPrf8+efGaw/1amvp1Yrjt0qVLMJvNMBrlTRlGoxHHjh1TPGbixIm4dOkSBg0aBCEEqqqqMHPmTKdNRZmZmVixYoUrp9aobL8kDO7Os51Go8GaB9c43QeA1NTxyRypg9bV88D9s+70NGWiwvqhDTTQmasQMFa59qu5KH3p3tC3a1jVqTNaB5fzewpB58Tn9ttq84sAxqwDPn0e+GajtG3E76SOvtUUOhHWR31rZ25WmvFh3lnkFCgEXdTRj0OpPJR+pSvY+ptkfHKwF555yMmXCyBV4188CgD46sWhstfVWLNEaNrUao7pNR7oNR5xAA4mCGi1GlhqfYL/7dlBiA23D5NR7dpg+Wh5zYxtsA7zs/kijhoI/PQv5yfnygSC3R6t3zUf1FUKZ5YqaTqCpNnSbXk9wnH3mrWSblXVVP37KnSklnnifak/2Njb/SeMPaQazLP7gE/n2+9fKT127ZfjaBSZu5sWttPeuOu01jV9FGk0sr432jqupgWVM7D60dXA/j8BkNcYZln6Q0QegCYyCfMMnfHbT4/Kn8rBEHKNBrg/ph79V5pR7R+FtvS6uq+1a+U281e5MC9Mc3MpuDRETk4OVq5ciTfeeAOJiYk4ceIE5s6di5dffhlLlyp3HE1PT0daWpr1/2VlZYiIUJ61sSnYvhldmeTHqT6TpapZd09pqQEPhQnf7oCHmwf+MWEvzBYzPJ1MNd4cfD0VJmtqjCrY2ho7CFX3F0icWRNcbCe+GzjP4aHeBjfrh0Kgtx6XrlVgTLzz/i1KVn2m/IOgmpuz61MpVDkbSmujR5hPrTlXHBj9P1KH1Pufsfs7+3nVEeoeewP4+Jma/3v6K85mrXXSHFNdw6nVahAf4Yf8MyUAgK4h9f+lbDvMXFaev9wM7N8kdQx3xJWmot5P1L1PtV6uN48AkPpE3HbL7EKfhW4PSzdboXGO56CqklKIdYVvAP07BODwuZpm2XF9amoaavcVMbgw6ysAuMHxUh47zAPwgflBrAaAp7/E53nfo3BvzbVbDj00T2UBAKYJgcGdg2A+MBu6r2/X+Cp8brw1OQHDe9azb01AjOJoKwBApOtN8K6o/cPlvV/X9HFzZWZdpcdqyVwKLoGBgdDpdCguls+TUVxcjJAQ5T/y0qVLMXnyZPz619IcFb169cL169cxY8YMLF68GFqFzkUGgwEGQ/Mt9hQZUPMryukXg6uq51ho5NBSzXb4Y0sS194PHQLbIMjbgOsVVTjynzKM71OPqt+GmJMHrE8CzI4XNqy36l/TtiO23DyAJRelESO1RtTYmpQYiTe/lD7MJiZGYVh3Y72/TJ8eEmM9ti7Oa1wUgkOnofbb7oRfpF2H2dcn3odteWfxm18o92Gwum9STXBxbyPrf3PKEoIY7e0O1PUMB7bfP658CHcP9YFGA4TUavaAdzDwoPP+W6hdG6Rkwlap9utOy/7RtcDf5jm+f8kFWX+lm3VNVlcfPg7CtlkKLrbF/Odp/dF1SZb1/ytsarbKbtUEj2+XDnNY4/j/bCb4s3VKhKED7OdnGlP+kryTemhv9BrSFfqv9siaXKtpNBrpfThyJdDnV3YDIYb3MOLIf8ocNuMqat9fObg8sgboMqL+j9MAM4Z0RNaRIjzep71s9Cbgeg3KPVvjotfrkZCQgOzsbIwZMwYAYLFYkJ2djTlz5igec+PGDbtwors9zLClTjncxuCG/UtMqvpDtmR6Ny0+T3sAGkiLfRWV3kJUOydT9t+JwE7AuLeAD56s3/5B3a1NHXaqOzTa9l+xVErz8oTFKx4S194Xh86WYkRsCN7fV4iyW1UY0jkQvZRGmzmQ/nB3/HT5BrKOFNW5r9OaK9s+LqlZQNk55b4SjezRuDA8Gudi7VJIrNQ0s3cNLvj0gqXEZqSGWXkhvdpsv6jq2xQHAF56NxxZkdyw97t3iNTPydnIkq6N9OXVNxU4tUeahE5JrU7WSovoucw3Qgro5w/Ktyv8TQxu0hIPlbfXxWnroVzjFtDGvu9VTFAb7J7/oMPTKOj3MoZ+K59r5C+WYcgX9n2SjD4eyFtiwod5Z7H8/5x0jDX2sNv05uQEWISLNcIjV0k1sfETgbdtwmm/aY6PaSRBbQ345wvKk6e6ej0XXrkBIYRL753m4vI7NS0tDRs3bsS7776Lo0ePYtasWbh+/TpSU6VZ/6ZMmYL09Jq1eUaNGoX169djy5YtOH36NHbt2oWlS5di1KhR1gDTEgV6GxSbOKhhdFoNtFoNDG66pgst1RzN76LkISfD8qtryGzns6mjJmfrjCTsnv8A7ov0R86Ch7Bj9kD0jXZ9baHzToYmPv1AzURsTmsWbD+A2nWSmh8aOPS16WmkSdjGvoXgp3egg8ZmjZbKesykDODqLcfNCXXx0tcxy68jOjdp/bB5DoZ217Hulcse3yQtD1EtUHmpEgB4ZdAraOfRzrpcRINotcD0HODJmunrEZ4AzJZGXNX+6bn9GWlyNFe/+8797Lx2aOB9vWSLZQqvdhi3eIvD/dt6uGN83wjEBLbBkwqdtB3RaOqaNFGBpz/w6Bqpma6t683BTaX238BL7/z7tvRmJb46dcXpPi2Fy31cUlJScPHiRSxbtgxFRUWIj49HVlaWtcNuYWGhrIZlyZIl0Gg0WLJkCc6dO4egoCCMGjUKr7zyiqOnILozjkZ6RA0ErpwGrtp0UHU29FNpIUcnzUOAtBZSTJAUnALa6BV/XdbHwdt9NZS00de8bZ02Zdr2T6g1QWGLo9FII2h6S7OHWqC1LlqHyvo1eZTdql/NTKPzDnZ8n6WRz0nnBnR7ROq42iZYWtbhwP8qrgAfFxSHPf+1585/QWu10nvHtAII7Cw9vwOx4b74bO5gBNcxh061YT2M2PV9MR5PcN50bHDX4uGKTIzW/hvPzV8KjVc7eBqklcc3fHFSMZx4G9yw+/kH63UejSb5FWBbKnD/M3Xv28Rs+6uPvS8cY+4Lx9RNzqch8fFs8m6vjaJBZzlnzhyHTUM5OTnyJ3BzQ0ZGBjIyMhryVESuUwoubh5A6k6pc+p/364iHjhXPi3+4PnS6rvv3m5OsZmFFM9+Ky02pzCN/t3WxdgWkQFeKLtVCaOPky8I20kF6zkLcrOpNWtovuiIfprb0+RXKa9DU1uQtwElNyqtE+bddb6RQGmhfNtDi5X3vRMajXTtVlOYRr5m10aq9tdopIkKaxnSJQiv7T4h62xbM3ty3f47JR57jl3AL7o5CX8AuoX44OEHByHYbxgQUDO0+/nhXTCshxG9FEaQNYvYcdJQ7gZMItrYbLtieOp1MFvs+/zU5uOgea+laeGfZkQNEBYvVaF7G6Up03/YBSTeXgnVN1wKIcVHpP4eth/sATFSn4VqtjUu7Traz9zbhD6bOxjztuTL5mCYlBiJ6+VVGNbDiAe6BEFAwEvv5C0c2Al44r0GzTx618SOBw5vq5mB+LYPojLQ78wk6T/17Gi99ol4LN1xGLNcnYulsVTa1HDN3AsczwIG/KZ5zuUu6RcdgI+eGSAb0KAkqK0BF6/aB1BvgxtG1TGbdLUFyfZT+LvptNKEdS1JC3m/nbVpfnPTauDrWXftL4MLUXPRuUv9DjRaKZjU7khbO4SMXC0tuBiXIu9k6eqsqI2oe6gP/v7cEEQvqulb8EJyN/jeHmLsWUd7tZWTav0WYdxGYPjLdqNXStxDsLryv/CM28doM6x+czr1DPPFR7f7WDQL26a5kF7SrRXoE1l3cGij10F5JiJqKj/fqAn8Wo0Gvdv7oltIWxwrcjwhnbeHOiIBh83QvUmrq38PwcQZwJg3pMBjsKnmrs8CmneRWtqfXaLVKg651Wo0WGceg7jyt9UTAKpcmDellakeaUR3z+/H1/THc9Nq4KbT4uM5NcF+ZKx9zVCTzK/VBBhciGzpvaQJx3o8BvjVc5r0u0QNwxQbS/Xw8eqp+EndKuuzWCE1KlOPmn421YHEdkLVB7rIBybYLtfR0t2DP+GI7lAdayhR0/v1YGl9otofri3amA3AjpnSAoYkM9fUGYu3H8b4OkYPUdOoXlNKo9Hg34t+gfIqCw6dLZHts6M5m1ldxOBCRC2OwU2H2Q81UyfbhoqfAHR/FHCw9k1rNrF/JJJi2jX9HE4ks25iH+wpuIBJ99fMLhzmJ/XdC6o1ZL1RZ4lvYuo5U6JWaOVYqX/HqnEq6efR2jG0KNJoNIgJ8lZNH4p7xSNxofj9L3vD4Gbf5OpoJW81UO+ZE7UCExMjMTo+TNUfMkTUMlUvTJrYwfXZvZsTPw2JWjiGFiJqCm9M6oO/7j+DX93fsgYi1IWfiERERK1QmJ+n3arSasA+LkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoMLkRERKQaDC5ERESkGgwuREREpBoNCi7r1q1DdHQ0PDw8kJiYiH379jndv6SkBLNnz0ZoaCgMBgO6dOmCnTt3NuiEiYiIqPVyc/WArVu3Ii0tDRs2bEBiYiLWrl2L5ORkFBQUIDg42G7/iooKDBs2DMHBwdi2bRvCw8Px008/wc/PrzHOn4iIiFoRjRBCuHJAYmIi+vXrh9dffx0AYLFYEBERgWeffRaLFi2y23/Dhg1YvXo1jh07Bnd39wadZFlZGXx9fVFaWgofH58GPQYRERHdXU3x/e1SU1FFRQXy8vJgMplqHkCrhclkQm5uruIxn3zyCZKSkjB79mwYjUbExsZi5cqVMJvNDp+nvLwcZWVlshsRERGRS8Hl0qVLMJvNMBqNsu1GoxFFRUWKx5w6dQrbtm2D2WzGzp07sXTpUvzhD3/Ab3/7W4fPk5mZCV9fX+stIiLCldMkIiKie1STjyqyWCwIDg7GW2+9hYSEBKSkpGDx4sXYsGGDw2PS09NRWlpqvZ05c6apT5OIiIhUwKXOuYGBgdDpdCguLpZtLy4uRkhIiOIxoaGhcHd3h06ns27r3r07ioqKUFFRAb1eb3eMwWCAwWBw5dSIiIioFXCpxkWv1yMhIQHZ2dnWbRaLBdnZ2UhKSlI8ZuDAgThx4gQsFot12/HjxxEaGqoYWoiIiIgccbmpKC0tDRs3bsS7776Lo0ePYtasWbh+/TpSU1MBAFOmTEF6erp1/1mzZuHKlSuYO3cujh8/jk8//RQrV67E7NmzG+9VEBERUavg8jwuKSkpuHjxIpYtW4aioiLEx8cjKyvL2mG3sLAQWm1NHoqIiMDf//53PPfcc4iLi0N4eDjmzp2LhQsXNt6rICIiolbB5XlcmgPncSEiIlKfZp/HhYiIiKg5MbgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqMLgQERGRajC4EBERkWowuBAREZFqNCi4rFu3DtHR0fDw8EBiYiL27dtXr+O2bNkCjUaDMWPGNORpiYiIqJVzObhs3boVaWlpyMjIwLfffovevXsjOTkZFy5ccHrcjz/+iOeffx6DBw9u8MkSERFR6+ZycFmzZg2mT5+O1NRU9OjRAxs2bICXlxc2bdrk8Biz2YxJkyZhxYoViImJqfM5ysvLUVZWJrsRERERuRRcKioqkJeXB5PJVPMAWi1MJhNyc3MdHvfSSy8hODgY06ZNq9fzZGZmwtfX13qLiIhw5TSJiIjoHuVScLl06RLMZjOMRqNsu9FoRFFRkeIxe/fuxZ/+9Cds3Lix3s+Tnp6O0tJS6+3MmTOunCYRERHdo9ya8sGvXr2KyZMnY+PGjQgMDKz3cQaDAQaDoQnPjIiIiNTIpeASGBgInU6H4uJi2fbi4mKEhITY7X/y5En8+OOPGDVqlHWbxWKRntjNDQUFBejYsWNDzpuIiIhaIZeaivR6PRISEpCdnW3dZrFYkJ2djaSkJLv9u3Xrhu+++w75+fnW2+jRo/HQQw8hPz+ffVeIiIjIJS43FaWlpWHq1Kno27cv+vfvj7Vr1+L69etITU0FAEyZMgXh4eHIzMyEh4cHYmNjZcf7+fkBgN12IiIiorq4HFxSUlJw8eJFLFu2DEVFRYiPj0dWVpa1w25hYSG0Wk7IS0RERI1PI4QQzX0SdSkrK4Ovry9KS0vh4+PT3KdDRERE9dAU39+sGiEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVgcCEiIiLVYHAhIiIi1WBwISIiItVoUHBZt24doqOj4eHhgcTEROzbt8/hvhs3bsTgwYPh7+8Pf39/mEwmp/sTEREROeJycNm6dSvS0tKQkZGBb7/9Fr1790ZycjIuXLiguH9OTg4mTJiAPXv2IDc3FxERERg+fDjOnTt3xydPRERErYtGCCFcOSAxMRH9+vXD66+/DgCwWCyIiIjAs88+i0WLFtV5vNlshr+/P15//XVMmTKlXs9ZVlYGX19flJaWwsfHx5XTJSIiombSFN/fbq7sXFFRgby8PKSnp1u3abVamEwm5Obm1usxbty4gcrKSgQEBDjcp7y8HOXl5db/l5aWApAKgIiIiNSh+nvbxToSp1wKLpcuXYLZbIbRaJRtNxqNOHbsWL0eY+HChQgLC4PJZHK4T2ZmJlasWGG3PSIiwpXTJSIiohbg6tWr8PX1bZTHcim43KlVq1Zhy5YtyMnJgYeHh8P90tPTkZaWZv2/xWLBlStX0K5dO2g0mkY7n7KyMkRERODMmTNsgnIBy61hWG4Nw3JzHcusYVhuDeOs3IQQuHr1KsLCwhrt+VwKLoGBgdDpdCguLpZtLy4uRkhIiNNjf//732PVqlX4/PPPERcX53Rfg8EAg8Eg2+bn5+fKqbrEx8eHF2kDsNwahuXWMCw317HMGobl1jCOyq2xalqquTSqSK/XIyEhAdnZ2dZtFosF2dnZSEpKcnjcq6++ipdffhlZWVno27dvw8+WiIiIWjWXm4rS0tIwdepU9O3bF/3798fatWtx/fp1pKamAgCmTJmC8PBwZGZmAgB+97vfYdmyZXjvvfcQHR2NoqIiAIC3tze8vb0b8aUQERHRvc7l4JKSkoKLFy9i2bJlKCoqQnx8PLKysqwddgsLC6HV1lTkrF+/HhUVFRg/frzscTIyMrB8+fI7O/s7ZDAYkJGRYdcsRc6x3BqG5dYwLDfXscwahuXWMHe73Fyex4WIiIiouXCtIiIiIlINBhciIiJSDQYXIiIiUg0GFyIiIlINBhciIiJSjVYdXNatW4fo6Gh4eHggMTER+/bta+5TajbLly+HRqOR3bp162a9/9atW5g9ezbatWsHb29vPP7443YzKBcWFuKRRx6Bl5cXgoODsWDBAlRVVd3tl9KkvvzyS4waNQphYWHQaDTYsWOH7H4hBJYtW4bQ0FB4enrCZDLhhx9+kO1z5coVTJo0CT4+PvDz88O0adNw7do12T6HDh3C4MGD4eHhgYiICLz66qtN/dKaVF3l9uSTT9pdfyNGjJDt09rKLTMzE/369UPbtm0RHByMMWPGoKCgQLZPY70vc3Jy0KdPHxgMBnTq1AmbN29u6pfXZOpTbg8++KDd9TZz5kzZPq2p3NavX4+4uDjrzLdJSUn47LPPrPe3uOtMtFJbtmwRer1ebNq0SRw5ckRMnz5d+Pn5ieLi4uY+tWaRkZEhevbsKc6fP2+9Xbx40Xr/zJkzRUREhMjOzhb79+8X999/vxgwYID1/qqqKhEbGytMJpM4cOCA2LlzpwgMDBTp6enN8XKazM6dO8XixYvFRx99JACI7du3y+5ftWqV8PX1FTt27BAHDx4Uo0ePFh06dBA3b9607jNixAjRu3dv8dVXX4l//vOfolOnTmLChAnW+0tLS4XRaBSTJk0Shw8fFu+//77w9PQUb7755t16mY2urnKbOnWqGDFihOz6u3Llimyf1lZuycnJ4p133hGHDx8W+fn54uGHHxaRkZHi2rVr1n0a43156tQp4eXlJdLS0sT3338vXnvtNaHT6URWVtZdfb2NpT7l9sADD4jp06fLrrfS0lLr/a2t3D755BPx6aefiuPHj4uCggLx4osvCnd3d3H48GEhRMu7zlptcOnfv7+YPXu29f9ms1mEhYWJzMzMZjyr5pORkSF69+6teF9JSYlwd3cXH3zwgXXb0aNHBQCRm5srhJC+mLRarSgqKrLus379euHj4yPKy8ub9NybS+0vYIvFIkJCQsTq1aut20pKSoTBYBDvv/++EEKI77//XgAQ33zzjXWfzz77TGg0GnHu3DkhhBBvvPGG8Pf3l5XbwoULRdeuXZv4Fd0djoLLY4895vAYlpsQFy5cEADEF198IYRovPflCy+8IHr27Cl7rpSUFJGcnNzUL+muqF1uQkjBZe7cuQ6PYbkJ4e/vL95+++0WeZ21yqaiiooK5OXlwWQyWbdptVqYTCbk5uY245k1rx9++AFhYWGIiYnBpEmTUFhYCADIy8tDZWWlrLy6deuGyMhIa3nl5uaiV69e1hmUASA5ORllZWU4cuTI3X0hzeT06dMoKiqSlZOvry8SExNl5eTn5ydbs8tkMkGr1eLrr7+27jNkyBDo9XrrPsnJySgoKMDPP/98l17N3ZeTk4Pg4GB07doVs2bNwuXLl633sdyA0tJSAEBAQACAxntf5ubmyh6jep975bOwdrlV+8tf/oLAwEDExsYiPT0dN27csN7XmsvNbDZjy5YtuH79OpKSklrkdebylP/3gkuXLsFsNssKGQCMRiOOHTvWTGfVvBITE7F582Z07doV58+fx4oVKzB48GAcPnwYRUVF0Ov1dit0G41G69pTRUVFiuVZfV9rUP06lcrBtpyCg4Nl97u5uSEgIEC2T4cOHeweo/o+f3//Jjn/5jRixAiMGzcOHTp0wMmTJ/Hiiy9i5MiRyM3NhU6na/XlZrFYMG/ePAwcOBCxsbEA0GjvS0f7lJWV4ebNm/D09GyKl3RXKJUbAEycOBFRUVEICwvDoUOHsHDhQhQUFOCjjz4C0DrL7bvvvkNSUhJu3boFb29vbN++HT169EB+fn6Lu85aZXAheyNHjrT+Oy4uDomJiYiKisJf//pX1b0BSX2eeOIJ67979eqFuLg4dOzYETk5ORg6dGgznlnLMHv2bBw+fBh79+5t7lNRFUflNmPGDOu/e/XqhdDQUAwdOhQnT55Ex44d7/Zptghdu3ZFfn4+SktLsW3bNkydOhVffPFFc5+WolbZVBQYGAidTmfXK7q4uBghISHNdFYti5+fH7p06YITJ04gJCQEFRUVKCkpke1jW14hISGK5Vl9X2tQ/TqdXVchISG4cOGC7P6qqipcuXKFZWkjJiYGgYGBOHHiBIDWXW5z5szB3/72N+zZswft27e3bm+s96WjfXx8fFT9o8VRuSlJTEwEANn11trKTa/Xo1OnTkhISEBmZiZ69+6NP/7xjy3yOmuVwUWv1yMhIQHZ2dnWbRaLBdnZ2UhKSmrGM2s5rl27hpMnTyI0NBQJCQlwd3eXlVdBQQEKCwut5ZWUlITvvvtO9uWya9cu+Pj4oEePHnf9/JtDhw4dEBISIiunsrIyfP3117JyKikpQV5ennWf3bt3w2KxWD88k5KS8OWXX6KystK6z65du9C1a1dVN3e44uzZs7h8+TJCQ0MBtM5yE0Jgzpw52L59O3bv3m3XDNZY78ukpCTZY1Tvo9bPwrrKTUl+fj4AyK631lZutVksFpSXl7fM68z1vsb3hi1btgiDwSA2b94svv/+ezFjxgzh5+cn6xXdmsyfP1/k5OSI06dPi3/961/CZDKJwMBAceHCBSGENBwuMjJS7N69W+zfv18kJSWJpKQk6/HVw+GGDx8u8vPzRVZWlggKCrrnhkNfvXpVHDhwQBw4cEAAEGvWrBEHDhwQP/30kxBCGg7t5+cnPv74Y3Ho0CHx2GOPKQ6Hvu+++8TXX38t9u7dKzp37iwb1ltSUiKMRqOYPHmyOHz4sNiyZYvw8vJS7bBeIZyX29WrV8Xzzz8vcnNzxenTp8Xnn38u+vTpIzp37ixu3bplfYzWVm6zZs0Svr6+IicnRzZs98aNG9Z9GuN9WT1MdcGCBeLo0aNi3bp1qh3WK0Td5XbixAnx0ksvif3794vTp0+Ljz/+WMTExIghQ4ZYH6O1lduiRYvEF198IU6fPi0OHTokFi1aJDQajfjHP/4hhGh511mrDS5CCPHaa6+JyMhIodfrRf/+/cVXX33V3KfUbFJSUkRoaKjQ6/UiPDxcpKSkiBMnTljvv3nzpnjmmWeEv7+/8PLyEmPHjhXnz5+XPcaPP/4oRo4cKTw9PUVgYKCYP3++qKysvNsvpUnt2bNHALC7TZ06VQghDYleunSpMBqNwmAwiKFDh4qCggLZY1y+fFlMmDBBeHt7Cx8fH5GamiquXr0q2+fgwYNi0KBBwmAwiPDwcLFq1aq79RKbhLNyu3Hjhhg+fLgICgoS7u7uIioqSkyfPt3uR0RrKzel8gIg3nnnHes+jfW+3LNnj4iPjxd6vV7ExMTInkNt6iq3wsJCMWTIEBEQECAMBoPo1KmTWLBggWweFyFaV7k99dRTIioqSuj1ehEUFCSGDh1qDS1CtLzrTCOEEK7X0xARERHdfa2yjwsRERGpE4MLERERqQaDCxEREakGgwsRERGpBoMLERERqQaDCxEREakGgwsRERGpBoMLERERqQaDCxEREakGgwsRERGpBoMLERERqcb/BwBJ61OS477mAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -647,12 +416,12 @@ "plt.plot(Agg_A_Harmenberg_reshuffle[100:], label = 'Harmenberg + reshuffle' )\n", "plt.legend()\n", "plt.title('Aggregate Saving')\n", - "plt.ylim(.2,1.5)" + "plt.ylim(.5,1.3)" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 16, "id": "50d52003", "metadata": {}, "outputs": [ @@ -660,42 +429,46 @@ "name": "stdout", "output_type": "stream", "text": [ - "ratio of no reshuffle to reshuffle 2.358453901703688\n", - "ratio of no reshuffle to Harmenberg 4.80016490376663\n", - "ratio of no reshuffle to Harmenberg + reshuffle 72.31928923323491\n" + "ratio of no reshuffle to reshuffle 4.082523462683998\n", + "ratio of no reshuffle to Harmenberg 3.366920192737571\n", + "ratio of no reshuffle to Harmenberg + reshuffle 52.49980623927158\n" ] } ], "source": [ - "#print('variance no reshuffle', np.var(Agg_A_no_reshuffle[100:]))\n", - "#print('variance with reshuffle' , np.var(Agg_A[100:]))\n", - "#print('variance with Harmenberg' , np.var(Agg_A_Harmenberg[100:]))\n", - "#print('variance with Harmenberg + reshuffle' , np.var(Agg_A_Harmenberg_reshuffle[100:]))\n", "\n", "print('ratio of no reshuffle to reshuffle', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A[100:]) )\n", "print('ratio of no reshuffle to Harmenberg', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A_Harmenberg[100:]) )\n", "print('ratio of no reshuffle to Harmenberg + reshuffle', np.var(Agg_A_no_reshuffle[100:]) /np.var(Agg_A_Harmenberg_reshuffle[100:]) )\n" ] }, + { + "cell_type": "markdown", + "id": "ce314cc1", + "metadata": {}, + "source": [ + "## Aggregate Consumption" + ] + }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 19, "id": "4d165fcb", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(0.8, 1.5)" + "(0.8, 1.3)" ] }, - "execution_count": 22, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi4AAAGzCAYAAAAIWpzfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAADBNElEQVR4nOzdeXwM9xvA8c/s5r4lIgnivoIgzqpbnVW/oi2lWlqqWkdVD/SiFy3Vaumh1VKlhyqqpXWronUVjfsKcUQS5D42x87vj0323hwkIjzv18vL7uzszHcnuzPPfI/nq6iqqiKEEEIIUQ5oyroAQgghhBBFJYGLEEIIIcoNCVyEEEIIUW5I4CKEEEKIckMCFyGEEEKUGxK4CCGEEKLckMBFCCGEEOWGBC5CCCGEKDckcBFCCCFEuSGBixBClEOKojBt2rSyLoYQN50ELuKO9+mnn6IoCm3atCnropS57777jjlz5pTa9rdu3cqAAQMIDg7GxcWFSpUq0bdvX1asWFFq+yzP1q5dK8GJEFYUmatI3OnatWvHpUuXOHv2LCdPnqROnTplXaQyc99993Ho0CHOnj1b4tueOnUqb775JnXr1mXw4MFUr16dq1evsnbtWrZu3crSpUsZMmRIie+3PBs7diyffPIJ9k7TmZmZODk54eTkVAYlE6LsyDde3NGioqLYuXMnK1as4KmnnmLp0qVMnTq1TMqSk5ODXq/HxcWlTPZfmpYvX86bb77Jgw8+yHfffYezs7PxtRdffJF169aRnZ1dhiUsf9zc3Mq6CEKUDVWIO9hbb72lVqhQQdXpdOrTTz+t1q1b1+56V65cUYcOHap6e3urvr6+6mOPPaYeOHBABdSFCxdarLts2TI1LCxMdXV1VRs1aqSuWLFCHTZsmFq9enXjOlFRUSqgzpo1S/3www/VWrVqqRqNRt2/f7+qqqp69OhR9YEHHlArVKigurq6qi1atFB/+eUXm3IdPHhQ7dixo+rm5qZWqVJFfeutt9Svv/5aBdSoqCjjeqtWrVLvvfdeNSQkRHVxcVFr1aqlvvnmm2pOTo5xnU6dOqmAxT/zMmdmZqqvv/66Wrt2bdXFxUWtWrWq+uKLL6qZmZmFHucGDRqo/v7+anJycqHrqqqqxsbGqk888YRaqVIl1dXVVW3SpIm6aNEii3XMj+H8+fPVWrVqqS4uLmrLli3V3bt3W6wbExOjDh8+XK1SpYrq4uKiBgcHq//73/8sjhGgTp061aYs1atXV4cNG2Z8vnDhQhVQ//rrL3XcuHFqxYoVVV9fX3XUqFGqTqdTExIS1EcffVT18/NT/fz81BdffFHV6/V2y/3BBx+o1apVU93c3NSOHTuqkZGRxvWGDRtm8/cwP2XbK++///6r9urVS/X29lY9PT3Vrl27qn///bfFOvnl3759u/rcc8+pFStWVD08PNR+/fqpcXFxhf1phChzUuMi7mhLly5lwIABuLi4MHjwYD777DP27NlDq1atjOvo9Xr69u3L7t27efrpp2nQoAG//PILw4YNs9nemjVrGDRoEOHh4cyYMYOEhARGjBhBlSpV7O5/4cKFZGZmMmrUKFxdXfH39+fw4cO0a9eOKlWqMHnyZDw9PVm2bBn9+vXj559/pn///gBcvHiRLl26oCgKU6ZMwdPTkwULFuDq6mqzn0WLFuHl5cXEiRPx8vJi8+bNvP766yQnJzNr1iwAXnnlFZKSkrhw4QIffvghAF5eXsZj8L///Y/t27czatQowsLCiIyM5MMPP+TEiROsWrXK4TE+efIkx44d44knnsDb27vQv0lGRgadO3fm1KlTjB07lpo1a/LTTz8xfPhwEhMTefbZZy3W/+6770hJSeGpp55CURRmzpzJgAEDOHPmjLFm54EHHuDw4cOMGzeOGjVqEBcXx4YNG4iOjqZGjRqFlsmecePGERwczBtvvME///zDF198gZ+fHzt37qRatWpMnz6dtWvXMmvWLBo3bsxjjz1m8f7FixeTkpLCmDFjyMzM5KOPPqJr165ERkYSFBTEU089xaVLl9iwYQPffvttoeU5fPgwHTp0wMfHh5deeglnZ2fmz59P586d+fPPP236cI0bN44KFSowdepUzp49y5w5cxg7diw//vjjdR0PIW6aso6chCgre/fuVQF1w4YNqqqqql6vV6tWrao+++yzFuv9/PPPKqDOmTPHuCw3N1ft2rWrTY1LeHi4WrVqVTUlJcW4bOvWrTa1F/l33T4+PjZ3uffcc48aHh5uUZOh1+vVu+++26JGaNy4caqiKMZaGlVV1atXr6r+/v42NS7p6ek2n/+pp55SPTw8LPbTp08fi3Lm+/bbb1WNRqP+9ddfFss///xzFVB37Nhh8558v/zyiwqoH374ocN1zM2ZM0cF1CVLlhiXZWVlqW3btlW9vLyMtTb5xzAgIEC9du2azf5+/fVXVVVVNSEhwVjDURCKWePSs2dPi5qUtm3bqoqiqKNHjzYuy8nJUatWrap26tTJuCy/3O7u7uqFCxeMy3ft2qUC6nPPPWdcNmbMGNXRadq6vP369VNdXFzU06dPG5ddunRJ9fb2Vjt27GhT/m7dulmU/7nnnlO1Wq2amJho/wAJcYuQUUXijrV06VKCgoLo0qULYBheOmjQIH744Qdyc3ON6/3xxx84Ozvz5JNPGpdpNBrGjBljsb1Lly4RGRnJY489ZqypAOjUqRPh4eF2y/DAAw8QGBhofH7t2jU2b97MwIEDSUlJ4cqVK1y5coWrV6/Ss2dPTp48ycWLF43latu2Lc2aNTO+39/fn0ceecRmP+7u7sbH+dvt0KED6enpHDt2rNBj9dNPPxEWFkaDBg2MZbpy5Qpdu3YFYMuWLQ7fm5ycDFCk2hYwjKQJDg5m8ODBxmXOzs6MHz+e1NRU/vzzT4v1Bw0aRIUKFYzPO3ToAMCZM2cAw2d3cXFh69atJCQkFKkMRTFixAgURTE+b9OmDaqqMmLECOMyrVZLy5YtjWUx169fP4uauNatW9OmTRvWrl1b7LLk5uayfv16+vXrR61atYzLQ0JCGDJkCNu3bzf+HfKNGjXKovwdOnQgNzeXc+fOFXv/QtxMEriIO1Jubi4//PADXbp0ISoqilOnTnHq1CnatGlDbGwsmzZtMq577tw5QkJC8PDwsNiG9eij/BO+vVFJjkYq1axZ0+L5qVOnUFWV1157jcDAQIt/+Z2G4+LijPsr6r4OHz5M//798fX1xcfHh8DAQIYOHQpAUlKS3bKZO3nyJIcPH7YpU7169SzKZI+Pjw9gCJiK4ty5c9StWxeNxvL0FBYWZnzdXLVq1Sye5wcx+UGKq6sr7733Hr///jtBQUF07NiRmTNncvny5SKVxxHr/fr6+gIQGhpqs9xewFS3bl2bZfXq1buuEV3x8fGkp6dTv359m9fCwsLQ6/WcP3/eYnlhx02IW5X0cRF3pM2bNxMTE8MPP/zADz/8YPP60qVL6dGjR6mXw7wmBAx9SQBeeOEFevbsafc9xR2unZiYSKdOnfDx8eHNN9+kdu3auLm58e+//zJp0iTjPgui1+sJDw/ngw8+sPu69cXaXIMGDQCIjIwsVrmLSqvV2l2umg0hnjBhAn379mXVqlWsW7eO1157jRkzZrB582YiIiIK3L557VtR9mtvuXoLZp0oynET4lYkgYu4Iy1dupRKlSrxySef2Ly2YsUKVq5cyeeff467uzvVq1dny5YtpKenW9S6nDp1yuJ91atXt7vc0TJ78qv5nZ2d6datW4HrVq9evUj72rp1K1evXmXFihV07NjRuDwqKsrmveZNB+Zq167NwYMHueeeexyu40i9evWoX78+v/zyCx999JFFM5o91atX57///kOv11vUuuQ3aeUf5+KqXbs2zz//PM8//zwnT56kWbNmzJ49myVLlgCGGofExESL92RlZRETE3Nd+yvMyZMnbZadOHHCorNwUY91YGAgHh4eHD9+3Oa1Y8eOodFoCgwuhShPpKlI3HEyMjJYsWIF9913Hw8++KDNv7Fjx5KSksLq1asB6NmzJ9nZ2Xz55ZfGbej1epugp3LlyjRu3JjFixeTmppqXP7nn38WubahUqVKdO7cmfnz59u9YMbHxxsf9+zZk7///psDBw4Yl127do2lS5davCf/ztr8TjorK4tPP/3UZvuenp52m44GDhzIxYsXLY5BvoyMDNLS0gr8XG+88QZXr15l5MiR5OTk2Ly+fv16fvvtNwDuvfdeLl++bDG6JScnh7lz5+Ll5UWnTp0K3Je19PR0MjMzLZbVrl0bb29vdDqdxbJt27ZZrPfFF184rHG5UatWrTL2VwLYvXs3u3btonfv3sZlnp6eADYBlTWtVkuPHj345ZdfLJqaYmNj+e6772jfvr2xyU6I8k5qXMQdZ/Xq1aSkpPC///3P7ut33XUXgYGBLF26lEGDBtGvXz9at27N888/z6lTp2jQoAGrV6/m2rVrgOVd8fTp07n//vtp164djz/+OAkJCcybN4/GjRtbBDMF+eSTT2jfvj3h4eE8+eST1KpVi9jYWP7++28uXLjAwYMHAXjppZdYsmQJ3bt3Z9y4ccbh0NWqVePatWvGct19991UqFCBYcOGMX78eBRF4dtvv7XbJNCiRQt+/PFHJk6cSKtWrfDy8qJv3748+uijLFu2jNGjR7NlyxbatWtHbm4ux44dY9myZaxbt46WLVs6/EyDBg0iMjKSd955h/3791tkzv3jjz/YtGkT3333HWDoNDp//nyGDx/Ovn37qFGjBsuXL2fHjh3MmTOnyJ188504cYJ77rmHgQMH0rBhQ5ycnFi5ciWxsbE8/PDDxvVGjhzJ6NGjeeCBB+jevTsHDx5k3bp1VKxYsVj7K6o6derQvn17nn76aXQ6HXPmzCEgIICXXnrJuE6LFi0AGD9+PD179kSr1VqU2dzbb7/Nhg0baN++Pc888wxOTk7Mnz8fnU7HzJkzS+UzCFEmynBEkxBlom/fvqqbm5ualpbmcJ3hw4erzs7O6pUrV1RVVdX4+Hh1yJAhxgR0w4cPV3fs2KEC6g8//GDx3h9++EFt0KCB6urqqjZu3FhdvXq1+sADD6gNGjQwrmOehMye06dPq4899pgaHBysOjs7q1WqVFHvu+8+dfny5Rbr7d+/X+3QoYPq6uqqVq1aVZ0xY4b68ccfq4B6+fJl43o7duxQ77rrLtXd3V2tXLmy+tJLL6nr1q1TAXXLli3G9VJTU9UhQ4aofn5+NkO4s7Ky1Pfee09t1KiR6urqqlaoUEFt0aKF+sYbb6hJSUmFHndVVdVNmzap999/v1qpUiXVyclJDQwMVPv27WuTXC82NlZ9/PHH1YoVK6ouLi5qeHi4TaK/go4hZkOFr1y5oo4ZM0Zt0KCB6unpqfr6+qpt2rRRly1bZvGe3NxcddKkScaEbD179lRPnTrlcDj0nj17LN4/depUFVDj4+Mtlg8bNkz19PS0W+7Zs2eroaGhqqurq9qhQwf14MGDFu/NyclRx40bpwYGBqqKohQpAV3Pnj1VLy8v1cPDQ+3SpYu6c+dOi3UclX/Lli023wchbkUyV5EQ12nVqlX079+f7du3065duwLXbdasGYGBgWzYsKHUyzVhwgTmz59Pamqqww6YouycPXuWmjVrMmvWLF544YWyLo4Q5Y70cRGiCDIyMiye5+bmMnfuXHx8fGjevLlxeXZ2tk0fjq1bt3Lw4EE6d+5c6uW6evUq3377Le3bt5egRQhxW5I+LkIUwbhx48jIyKBt27bodDpWrFjBzp07mT59usWQ5osXL9KtWzeGDh1K5cqVOXbsGJ9//jnBwcGMHj26xMvVtm1bOnfuTFhYGLGxsXz11VckJyfz2muvlfi+hBDiViCBixBF0LVrV2bPns1vv/1GZmYmderUYe7cuYwdO9ZivQoVKtCiRQsWLFhAfHw8np6e9OnTh3fffZeAgIASL9e9997L8uXL+eKLL1AUhebNm/PVV19ZDHsWQojbSbH7uGzbto1Zs2axb98+YmJiWLlyJf369XO4/tatW40p1c3FxMQQHBxc7AILIYQQ4s5V7D4uaWlpNG3a1G7iroIcP36cmJgY479KlSoVd9dCCCGEuMMVu6mod+/eFgmSiqpSpUr4+fkV+31CCCGEEPluWh+XZs2aodPpaNy4MdOmTStw+KhOp7PIaKnX67l27RoBAQHFTjcuhBBCiLKhqiopKSlUrlzZZuLU61XqgUtISAiff/45LVu2RKfTsWDBAjp37syuXbsshpGamzFjBm+88UZpF00IIYQQN8H58+epWrVqiWzrhhLQKYpSaOdcezp16kS1atX49ttv7b5uXeOSlJREtWrVOH/+vMy3IYQQQpQTycnJhIaGkpiYiK+vb4lss0yGQ7du3Zrt27c7fN3V1RVXV1eb5T4+PhK4CCGEEOVMSXbzKJPMuQcOHCAkJKQsdi2EEEKIcqzYNS6pqamcOnXK+DwqKooDBw7g7+9PtWrVmDJlChcvXmTx4sUAzJkzh5o1a9KoUSMyMzNZsGABmzdvZv369SX3KYQQQghxRyh24LJ3716LhHITJ04EYNiwYSxatIiYmBiio6ONr2dlZfH8889z8eJFPDw8aNKkCRs3brSblE4IIYQQoiDlYnbo5ORkfH19SUpKkj4uQohiy83NJTs7u6yLIcRtR6vV4uTk5LAPS2lcv2WuIiHEbS01NZULFy5QDu7RhCiXPDw8CAkJwcXF5absTwIXIcRtKzc3lwsXLuDh4UFgYKAksBSiBKmqSlZWFvHx8URFRVG3bt0SSzJXEAlchBC3rezsbFRVJTAwEHd397IujhC3HXd3d5ydnTl37hxZWVm4ubmV+j7LZDi0EELcTFLTIkTpuRm1LBb7u6l7E0IIIYS4ARK4CCGEEKLckMBFCCHEdVMUhVWrVt3wdr744gtCQ0PRaDTMmTPH7rJp06bRrFmzG96XKN8kcBFCCFGmkpOTGTt2LJMmTeLixYuMGjXK7jIhQEYVCSHEHSs7OxtnZ+eyLgbR0dFkZ2fTp08f4zx2hw4dslkmBEiNixDiDqKqKulZOWXyrzgJ8Dp37sz48eN56aWX8Pf3Jzg4mGnTplmsEx0dzf3334+Xlxc+Pj4MHDiQ2NhYh9s8e/YsiqLw448/0qlTJ9zc3Fi6dCkACxYsICwsDDc3Nxo0aMCnn35qfF9WVhZjx44lJCQENzc3qlevzowZMyy2feXKFfr374+Hhwd169Zl9erVxtcWLVqEn5+fxfqrVq0yjvRatGgR4eHhANSqVQtFUewuO3v2rN3PVVDZxe1JalyEEHeMjOxcGr6+rkz2feTNnni4FP2U+8033zBx4kR27drF33//zfDhw2nXrh3du3dHr9cbg5Y///yTnJwcxowZw6BBg9i6dWuB2508eTKzZ88mIiLCGLy8/vrrzJs3j4iICPbv38+TTz6Jp6cnw4YN4+OPP2b16tUsW7aMatWqcf78ec6fP2+xzTfeeIOZM2cya9Ys5s6dyyOPPMK5c+fw9/cv9HMOGjSI0NBQunXrxu7duwkNDcXb29tmWWBgoM17Cyu7uD1J4CKEELegJk2aMHXqVADq1q3LvHnz2LRpE927d2fTpk1ERkYSFRVFaGgoAIsXL6ZRo0bs2bOHVq1aOdzuhAkTGDBggPH51KlTmT17tnFZzZo1OXLkCPPnz2fYsGFER0dTt25d2rdvj6IoVK9e3Wabw4cPZ/DgwQBMnz6djz/+mN27d9OrV69CP6e7uzsBAQEABAYGEhwcDGB3mbXCyi5uTxK4CCHuGO7OWo682bPM9l0cTZo0sXgeEhJCXFwcAEePHiU0NNQYtAA0bNgQPz8/jh49WmDg0rJlS+PjtLQ0Tp8+zYgRI3jyySeNy3NycvD19QUMQUn37t2pX78+vXr14r777qNHjx4Oy+rp6YmPj4+xrKWlKGUXtycJXIQQdwxFUYrVXFOWrDvNKoqCXq+/4e16enoaH6empgLw5Zdf0qZNG4v1tFpDoNW8eXOioqL4/fff2bhxIwMHDqRbt24sX768SGXVaDQ2/XtKYqbuopRd3J7Kxy9YCCGEUVhYmLGvSX6ty5EjR0hMTKRhw4ZF3k5QUBCVK1fmzJkzPPLIIw7X8/HxYdCgQQwaNIgHH3yQXr16ce3atSL1YQkMDCQlJYW0tDRj0HTgwIEil/FGyy5uPxK4CCFEOdOtWzfCw8N55JFHmDNnDjk5OTzzzDN06tTJoimoKN544w3Gjx+Pr68vvXr1QqfTsXfvXhISEpg4cSIffPABISEhREREoNFo+OmnnwgODrYZKeRImzZt8PDw4OWXX2b8+PHs2rWLRYsWFf9DX0fZxe1JhkMLIUQ5oygKv/zyCxUqVKBjx45069aNWrVq8eOPPxZ7WyNHjmTBggUsXLiQ8PBwOnXqxKJFi6hZsyYA3t7ezJw5k5YtW9KqVSvOnj3L2rVrizyxnr+/P0uWLGHt2rWEh4fz/fff2wztvl6FlV3cnhS1OMkFykhycjK+vr4kJSXh4+NT1sURQpQTmZmZREVFUbNmTdzc3Mq6OELclgr6nZXG9VtqXIQQQghRbkjgIoQQQohyQwIXIYQQQpQbErgIIYQQotyQwEUIIYQQ5YYELkIIIYQoNyRwEUIIIUS5IYGLEEIIIcoNCVyEEEIIUW5I4CKEELe54cOH069fvxvezrFjx7jrrrtwc3OjWbNmdpedPXsWRVFKZCJFIeyRSRaFEEIUydSpU/H09OT48eN4eXnZXZaSklLGpRS3O6lxEUKIW1xWVlZZFwGA06dP0759e6pXr05AQIDDZUKUJglchBB3DlWFrLSy+VeM+Ww7d+7M2LFjmTBhAhUrVqRnz54cOnSI3r174+XlRVBQEI8++ihXrlwxvmf58uWEh4fj7u5OQEAA3bp1Iy0tzWK777//PiEhIQQEBDBmzBiys7ONrymKwqpVqyzW9/PzY9GiRcbX9+3bx5tvvomiKEybNs3uMnsKK7sQxSFNRUKIO0d2OkyvXDb7fvkSuHgWefVvvvmGp59+mh07dpCYmEjXrl0ZOXIkH374IRkZGUyaNImBAweyefNmYmJiGDx4MDNnzqR///6kpKTw119/oZoFS1u2bCEkJIQtW7Zw6tQpBg0aRLNmzXjyySeLVJ6YmBi6detGr169eOGFF/Dy8mL06NE2y6wDksLKLkRxSeAihBC3oLp16zJz5kwA3n77bSIiIpg+fbrx9a+//prQ0FBOnDhBamoqOTk5DBgwgOrVqwMQHh5usb0KFSowb948tFotDRo0oE+fPmzatKnIgUtwcDBOTk54eXkRHBwMgJeXl80y68Bl3rx5BZa9Xr16xTwy4k4ngYsQ4s7h7GGo+SirfRdDixYtjI8PHjzIli1bjB1izZ0+fZoePXpwzz33EB4eTs+ePenRowcPPvggFSpUMK7XqFEjtFqt8XlISAiRkZHX8UGKp7CyS+AiiksCFyHEnUNRitVcU5Y8PU3lTE1NpW/fvrz33ns264WEhKDVatmwYQM7d+5k/fr1zJ07l1deeYVdu3ZRs2ZNAJydnS3epygKer3e4rlq1Q/HvA/M9Sqs7EIUlwQuQghxi2vevDk///wzNWrUwMnJ/mlbURTatWtHu3bteP3116levTorV65k4sSJRdpHYGAgMTExxucnT54kPT39ppRdiOKQUUVCCHGLGzNmDNeuXWPw4MHs2bOH06dPs27dOh5//HFyc3PZtWsX06dPZ+/evURHR7NixQri4+MJCwsr8j66du3KvHnz2L9/P3v37mX06NE2tTSlUXYhiksCFyGEuMVVrlyZHTt2kJubS48ePQgPD2fChAn4+fmh0Wjw8fFh27Zt3HvvvdSrV49XX32V2bNn07t37yLvY/bs2YSGhtKhQweGDBnCCy+8gIdH8frlXE/ZhSguRbVu1LwFJScn4+vrS1JSEj4+PmVdHCFEOZGZmUlUVBQ1a9bEzc2trIsjxG2poN9ZaVy/JdwVQgghRLkhgYsQQgghyg0JXIQQQghRbhQ7cNm2bRt9+/alcuXKdue2KMiOHTtwcnIyTocuhBBCCFEcxQ5c0tLSaNq0KZ988kmx3peYmMhjjz3GPffcU9xdCiGEEEIA15GArnfv3sUaYpdv9OjRDBkyBK1WW2gtjU6nQ6fTGZ8nJycXe39CCCGEuP3clD4uCxcu5MyZM0ydOrVI68+YMQNfX1/jv9DQ0FIuoRBCCCHKg1IPXE6ePMnkyZNZsmRJkdM9T5kyhaSkJOO/8+fPl3IphRBCCFEelOrEEbm5uQwZMoQ33nijWDOAurq64urqWoolE0IIIUR5VKo1LikpKezdu5exY8fi5OSEk5MTb775JgcPHsTJyYnNmzeX5u6FEELcQqZNmyajSsUNK9UaFx8fHyIjIy2Wffrpp2zevJnly5cbp1sXQghhMnz4cBITE20GMmzdupUuXbqQkJCAn59fmZRNiLJW7MAlNTWVU6dOGZ9HRUVx4MAB/P39qVatGlOmTOHixYssXrwYjUZD48aNLd5fqVIl3NzcbJYLIYQoXVlZWbi4uJR1MUpcdnZ2icxkLcqHYjcV7d27l4iICCIiIgCYOHEiERERvP766wDExMQQHR1dsqUUQogSoKoq6dnpZfKvpOezvXr1KoMHD6ZKlSp4eHgQHh7O999/b7FO586dGTt2LBMmTKBixYr07NmTrVu3oigK69atIyIiAnd3d7p27UpcXBy///47YWFh+Pj4MGTIENLT043b0uv1zJgxg5o1a+Lu7k7Tpk1Zvny58fX87W7atImWLVvi4eHB3XffzfHjx23KPn/+fEJDQ/Hw8GDgwIEkJSVZvL5gwQLCwsJwc3OjQYMGfPrpp8bXzp49i6Io/Pjjj3Tq1Ak3NzeWLl1KTk4O48ePx8/Pj4CAACZNmsSwYcPo169fCR1xcasodo1L586dC/wBLlq0qMD3T5s2jWnTphV3t0IIccMycjJo812bMtn3riG78HD2KLHtZWZm0qJFCyZNmoSPjw9r1qzh0UcfpXbt2rRu3dq43jfffMPTTz/Njh07AMPNJRjOxfPmzTMGDwMHDsTV1ZXvvvuO1NRU+vfvz9y5c5k0aRJgSFOxZMkSPv/8c+rWrcu2bdsYOnQogYGBdOrUybi/V155hdmzZxMYGMjo0aN54oknjPsGOHXqFMuWLePXX38lOTmZESNG8Mwzz7B06VIAli5dyuuvv868efOIiIhg//79PPnkk3h6ejJs2DDjdiZPnszs2bOJiIjAzc2N9957j6VLl7Jw4ULCwsL46KOPWLVqFV26dCmxYy5uDaXax0UIIcT1+e233/Dy8rJYlpuba3xcpUoVXnjhBePzcePGsW7dOpYtW2YRuNStW5eZM2can+cHLm+//Tbt2rUDYMSIEUyZMoXTp09Tq1YtAB588EG2bNnCpEmT0Ol0TJ8+nY0bN9K2bVsAatWqxfbt25k/f75F4PLOO+8Yn0+ePJk+ffqQmZmJm5sbYAi4Fi9eTJUqVQCYO3cuffr0Yfbs2QQHBzN16lRmz57NgAEDAKhZsyZHjhxh/vz5FoHLhAkTjOvkb2fKlCn0798fgHnz5rF27dpiHHFRXkjgIoS4Y7g7ubNryK4y23dxdOnShc8++8xi2a5duxg6dChgCGKmT5/OsmXLuHjxIllZWeh0Ojw8LGt1WrRoYXf7TZo0MT4OCgrCw8PDGLTkL9u9ezdgqCVJT0+ne/fuFtvIysoydhuwt92QkBAA4uLiqFatGgDVqlUzBi0Abdu2Ra/Xc/z4cby9vTl9+jQjRozgySefNK6Tk5ODr6+vxX5atmxpfJyUlERsbKxFwKbVamnRogV6vd7u5xfllwQuQog7hqIoJdpcU5o8PT2pU6eOxbILFy4YH8+aNYuPPvqIOXPmEB4ejqenJxMmTCArK8tmO/aYd2ZVFMWmc6uiKMaLfmpqKgBr1qyxCDoAm5xb1tsFihw85O/nyy+/pE0byyY9rVZr8dzR5xK3PwlchBCiHNqxYwf333+/sQZGr9dz4sQJGjZsWOL7atiwIa6urkRHR1s0C12P6OhoLl26ROXKlQH4559/0Gg01K9fn6CgICpXrsyZM2d45JFHirxNX19fgoKC2LNnDx07dgQMNVL//vuv5I25DUngIoQQ5VDdunVZvnw5O3fupEKFCnzwwQfExsaWSuDi7e3NCy+8wHPPPYder6d9+/YkJSWxY8cOfHx8LPqeFMbNzY1hw4bx/vvvk5yczPjx4xk4cCDBwcEAvPHGG4wfPx5fX1969eqFTqdj7969JCQkMHHiRIfbHTduHDNmzKBOnTo0aNCAuXPnkpCQYKz1EbcPCVyEEKIcevXVVzlz5gw9e/bEw8ODUaNG0a9fP5uhxSXlrbfeIjAwkBkzZnDmzBn8/Pxo3rw5L7/8crG2U6dOHQYMGMC9997LtWvXuO+++yyGO48cORIPDw9mzZrFiy++iKenJ+Hh4UyYMKHA7U6aNInLly/z2GOPodVqGTVqFD179rRpYhLln6KWdHKBUpCcnIyvry9JSUn4+PiUdXGEEOVEZmYmUVFR1KxZ0ziqRdwZ9Ho9YWFhDBw4kLfeequsi3NbK+h3VhrXb6lxEUIIUe6dO3eO9evX06lTJ3Q6HfPmzSMqKoohQ4aUddFECSvVSRaFEEKIm0Gj0bBo0SJatWpFu3btiIyMZOPGjYSFhZV10UQJkxoXIYQQ5V5oaKhFhl5x+5IaFyGEEEKUGxK4CCGEEKLckMBFCCGEEOWGBC5CCCGEKDckcBFCCCFEuSGBixBCCCHKDQlchBBC3DTTpk2TiQ8LsXXrVhRFITEx8Ya2o6oqo0aNwt/fH0VROHDggN1lnTt3LnRKhVuJBC5CCHGLGT58OP369bNZXlIXNHFn+OOPP1i0aBG//fYbMTExNG7c2O6y8kYCFyGEuINkZWWVdRFKRXZ2dolsZ9GiRXTu3Pm635+bm4tery+Rstyo06dPExISwt13301wcDBOTk52l5U3ErgIIe4YqqqiT08vk3+lMZ/t1atXGTx4MFWqVMHDw4Pw8HC+//57i3U6d+7M2LFjmTBhAhUrVqRnz57Gmpt169YRERGBu7s7Xbt2JS4ujt9//52wsDB8fHwYMmQI6enpxm3p9XpmzJhBzZo1cXd3p2nTpixfvtz4ev52N23aRMuWLfHw8ODuu+/m+PHjNmWfP38+oaGheHh4MHDgQJtZrRcsWEBYWBhubm40aNDAYgbps2fPoigKP/74I506dcLNzY2lS5eSk5PD+PHj8fPzIyAggEmTJjFs2DC7tVclZdGiRfj5+bF69WoaNmyIq6sr0dHR6HQ6XnjhBapUqYKnpydt2rRh69atxvedO3eOvn37UqFCBTw9PWnUqBFr16612Pa+ffscHkd7tXITJkwwBl3Dhw9n3LhxREdHoygKNWrUsLvMnsLKXtbKX6glhBDXSc3I4HjzFmWy7/r/7kPx8CjRbWZmZtKiRQsmTZqEj48Pa9as4dFHH6V27dq0bt3auN4333zD008/bUyJHxMTAxj6m8ybN88YPAwcOBBXV1e+++47UlNT6d+/P3PnzmXSpEkAzJgxgyVLlvD5559Tt25dtm3bxtChQwkMDKRTp07G/b3yyivMnj2bwMBARo8ezRNPPGGRjv/UqVMsW7aMX3/9leTkZEaMGMEzzzzD0qVLAVi6dCmvv/468+bNIyIigv379/Pkk0/i6enJsGHDjNuZPHkys2fPJiIiAjc3N9577z2WLl3KwoULCQsL46OPPmLVqlV06dKlRI+7tfT0dN577z0WLFhAQEAAlSpVYuzYsRw5coQffviBypUrs3LlSnr16kVkZCR169ZlzJgxZGVlsW3bNjw9PTly5AheXl4W2y3sOBbko48+onbt2nzxxRfs2bMHrVaLi4uLzTJ7Cit7WZPARQghbkG//fabzYUsNzfX4nmVKlV44YUXjM/HjRvHunXrWLZsmUXgUrduXWbOnGl8nh+4vP3227Rr1w6AESNGMGXKFE6fPk2tWrUAePDBB9myZQuTJk1Cp9Mxffp0Nm7cSNu2bQGoVasW27dvZ/78+RaByzvvvGN8PnnyZPr06UNmZiZubm6AIeBavHgxVapUAWDu3Ln06dOH2bNnExwczNSpU5k9ezYDBgwAoGbNmhw5coT58+dbBC4TJkwwrpO/nSlTptC/f38A5s2bZ1OLURqys7P59NNPadq0KQDR0dEsXLiQ6OhoKleuDMALL7zAH3/8wcKFC5k+fTrR0dE88MADhIeHAxiPubnCjmNBfH198fb2RqvVEhwcbFxub5m5opS9rEngIoS4Yyju7tT/d1+Z7bs4unTpwmeffWaxbNeuXQwdOtT4PDc3l+nTp7Ns2TIuXrxIVlYWOp0OD6uanRYt7NcyNWnSxPg4KCgIDw8PiwtoUFAQu3fvBgy1JOnp6XTv3t1iG1lZWURERDjcbkhICABxcXFUq1YNgGrVqhmDFoC2bdui1+s5fvw43t7enD59mhEjRvDkk08a18nJycHX19diPy1btjQ+TkpKIjY21iJg02q1tGjRosA+J9HR0TRs2NBiP9nZ2RZB48svv8zLL7/scBsuLi4WnzkyMpLc3Fzq1atnsZ5OpyMgIACA8ePH8/TTT7N+/Xq6devGAw88YLENKPw4loailL2sSeAihLhjKIpS4s01pcXT05M6depYLLtw4YLF81mzZvHRRx8xZ84cwsPD8fT0ZMKECTYdcD09Pe3uw9nZ2fhYURSL5/nL8i/6qampAKxZs8Yi6ABwdXUtcLtAkTus5u/nyy+/pE2bNhavWTdtOPpcxVG5cmUOHDhgfL5ixQp+/vlnY7MVgL+/f4HbcHd3N35OMHwGrVbLvn37bMqcHxCNHDmSnj17smbNGtavX8+MGTOYPXs248aNM65b0HHUaDQ2/aZKooNyUcpe1iRwEUKIcmrHjh3cf//9xloYvV7PiRMnLGoQSop5x1PzZqHrER0dzaVLl4xNEf/88w8ajYb69esTFBRE5cqVOXPmDI888kiRt+nr60tQUBB79uyhY8eOgKFG6t9//y0wb4yTk5NFgFipUiXc3d1tgsbiiIiIIDc3l7i4ODp06OBwvdDQUEaPHs3o0aOZMmUKX375pUXgUpDAwEAOHTpksezAgQM2wWdplb0sSeAihBDlVN26dVm+fDk7d+6kQoUKfPDBB8TGxpZK4OLt7c0LL7zAc889h16vp3379iQlJbFjxw58fHws+p4Uxs3NjWHDhvH++++TnJzM+PHjGThwoLHfxRtvvMH48ePx9fWlV69e6HQ69u7dS0JCAhMnTnS43XHjxjFjxgzq1KlDgwYNmDt3LgkJCRa1ITdDvXr1eOSRR3jssceMnYfj4+PZtGkTTZo0oU+fPkyYMIHevXtTr149EhIS2LJlC2FhYUXeR9euXZk1axaLFy+mbdu2LFmyhEOHDtk025VG2cuaBC5CCFFOvfrqq5w5c4aePXvi4eHBqFGj6Nevn83Q4pLy1ltvERgYyIwZMzhz5gx+fn40b968wP4f9tSpU4cBAwZw7733cu3aNe677z6L4c4jR47Ew8ODWbNm8eKLL+Lp6Ul4eHih2V0nTZrE5cuXeeyxx9BqtYwaNYqePXs6HD1TmhYuXMjbb7/N888/z8WLF6lYsSJ33XUX9913H2CoDRozZgwXLlzAx8eHXr168eGHHxZ5+z179uS1117jpZdeIjMzkyeeeILHHnuMyMjIUi97WVPU0kguUMKSk5Px9fUlKSkJHx+fsi6OEKKcyMzMJCoqipo1axZpJIa4vej1esLCwhg4cCBvvfVWWRfntlXQ76w0rt9S4yKEEOK2cO7cOdavX0+nTp3Q6XTMmzePqKgohgwZUtZFEyVIMucKIYS4LWg0GhYtWkSrVq1o164dkZGRbNy4sVh9R8StT2pchBBC3BZCQ0OLnFlWlF9S4yKEEEKIckMCFyHEba8cjEEQoty62b8vCVyEELet/GGw1plkhRAlJ38G8RtNfldU0sdFCHHbcnJywsPDg/j4eJydndFo5F5NiJKiqirp6enExcXh5+d30/LlSOAihLhtKYpCSEgIUVFRnDt3rqyLI8Rtyc/Pz+Fs06VBAhchxG3NxcWFunXrSnOREKXA2dn5pmcmlsBFCHHb02g0kjlXiNuENPgKIYQQotyQwEUIIYQQ5YYELkIIIYQoN4oduGzbto2+fftSuXJlFEVh1apVBa6/fft22rVrR0BAAO7u7jRo0KBYU3cLIYQQQuQrdufctLQ0mjZtyhNPPMGAAQMKXd/T05OxY8fSpEkTPD092b59O0899RSenp6MGjXqugothBBCiDuTot5Arl5FUVi5ciX9+vUr1vsGDBiAp6cn3377bZHWT05OxtfXl6SkJHx8fK6jpEIIIYS42Urj+n3T+7js37+fnTt30qlTJ4fr6HQ6kpOTLf4JIYQQQty0wKVq1aq4urrSsmVLxowZw8iRIx2uO2PGDHx9fY3/QkNDb1YxhRBCCHELu2mBy19//cXevXv5/PPPmTNnDt9//73DdadMmUJSUpLx3/nz529WMYUQQghxC7tpmXNr1qwJQHh4OLGxsUybNo3BgwfbXdfV1RVXV9ebVTQhhBBClBNlksdFr9ej0+nKYtdCCCGEKMeKXeOSmprKqVOnjM+joqI4cOAA/v7+VKtWjSlTpnDx4kUWL14MwCeffEK1atVo0KABYMgD8/777zN+/PgS+ghCCCGEuFMUO3DZu3cvXbp0MT6fOHEiAMOGDWPRokXExMQQHR1tfF2v1zNlyhSioqJwcnKidu3avPfeezz11FMlUHwhhBBC3EluKI/LzSJ5XIQQQojy57bI4yKEEEIIcb0kcBFCCCFEuSGBixBCCCHKDQlchBBCCFFuSOAihBBCiHJDAhchhBBClBsSuAghhBCi3JDARQghhBDlhgQuQgghhCg3JHARQgghRLkhgYsQQgghyg0JXIQQQghRbkjgIoQQQohyQwIXIYQQQpQbErgIIYQQotyQwEUIIYQQ5YYELkIIIYQoNyRwEUIIIUS5IYGLEEIIIcoNCVyEEEIIUW5I4CKEEEKIckMCFyGEEEKUGxK4CCGEEKLckMBFCCGEEOWGBC5CCCGEKDckcBFCCCFEuSGBixBCCCHKDQlchBBCCFFuSOAihBBCiHJDAhchhBBClBsSuAghhBCi3JDARQghhBDlhgQuQgghhCg3JHARQgghRLkhgYsQQgghyg0JXIQQQghRbkjgIoQQQohyQwIXIYQQQpQbErgIIYQQotyQwEUIIYQQ5YYELkIIIYQoNyRwEUIIIUS5UezAZdu2bfTt25fKlSujKAqrVq0qcP0VK1bQvXt3AgMD8fHxoW3btqxbt+56yyuEEEKIO1ixA5e0tDSaNm3KJ598UqT1t23bRvfu3Vm7di379u2jS5cu9O3bl/379xe7sEIIIYS4symqqqrX/WZFYeXKlfTr169Y72vUqBGDBg3i9ddfL9L6ycnJ+Pr6kpSUhI+Pz3WUVAghhBA3W2lcv51KZCvFoNfrSUlJwd/f3+E6Op0OnU5nfJ6cnHwziiaEEEKIW9xN75z7/vvvk5qaysCBAx2uM2PGDHx9fY3/QkNDb2IJhRBCCHGruqmBy3fffccbb7zBsmXLqFSpksP1pkyZQlJSkvHf+fPnb2IphRBCCHGrumlNRT/88AMjR47kp59+olu3bgWu6+rqiqur600qmRBCCCHKi5tS4/L999/z+OOP8/3339OnT5+bsUshhBBC3IaKXeOSmprKqVOnjM+joqI4cOAA/v7+VKtWjSlTpnDx4kUWL14MGJqHhg0bxkcffUSbNm24fPkyAO7u7vj6+pbQxxBCCCHEnaDYNS579+4lIiKCiIgIACZOnEhERIRxaHNMTAzR0dHG9b/44gtycnIYM2YMISEhxn/PPvtsCX0EIYQQQtwpbiiPy80ieVyEEEKI8qc0rt8yV5EQQgghyg0JXIQQQghRbkjgIoQQQohyQwIXIYQQQpQbErgIIYQQotyQwEUIIYQQ5YYELkIIIYQoNyRwEUIIIUS5IYGLEEIIIcoNCVyEEEIIUW5I4CKEEEKIckMCFyGEEEKUGxK4CCGEEKLckMBFCCGEEOWGBC5CCCGEKDckcBFCCCFEuSGBixBCCCHKDQlchBBCCFFuSOAihBBCiHJDAhchhBBClBsSuAghhBCi3JDARQghhBDlhgQuQgghhCg3JHARQgghRLkhgYsQQgghyg0JXIQQQghRbkjgchs7FZfKB+uPk5SRXdZFEUIIIUqEU1kXQJSeez/+i6wcPbHJOt57sElZF0cIIYS4YVLjchvLytEDsC86oYxLIoQQQpQMCVzuAE4apayLIIQoI1k5ej5Yf5x9566VdVGEKBESuNwBnLXyZxbiTrX477N8vPkUD3z2d1kXRYgSIVe0O4CT1n6NS1xyJmO/+5ddZ67e5BIJIW6WE7EpNsvikjP5YXc0GVm5ZVAiIW6MBC53AK1iP3B5ZdUhfvsvhkFf/HOTSySEuFkUbH//D3/5D5NXRDLj96NlUCIhbowELmVEVVW+/ecc/96EjrO5qmp3edSVtFLftxCibOnNfv/X0rLQ61XOxBt++38culxWxRLiuslw6DKy8Wgcr606BMDZd/uU+Pb1etPJKjtXX+g6QojbU6JZHqeM7FyupWUZn6fpcsqiSELcEKlxKSNHLiWX6vaz9aZgJSfXfoCid1ATI4S4fVTz97B4bt5ynCZ9XEQ5JIFLGXFUC1Jy2zcFJVmOalzM4pYZa49yKTGjVMtkLjY586btS4g7ma+7s/Fxbq7Kgr+iyrA0Qtw4CVzKiMYst0ppXMRzzIKVM/Fp/Hki3mad6Gvpxsfzt53hiUV7Srwc9ny69RRtpm/ii22nb8r+hLiT5SeiBMjR6/l+d3QZlkaIGyeByy3gwc93lvg2s62ah4Z9vdv4+FRcKj0+/NPmPccu2w6bLA0z/zgOwPS1x27K/oS4k+lyTM1BqVZ9WrSSnFKUQxK4lBHVrH/J+Wsl30STo3fcFPX8Twc5EZta4vu8lb356xEe/GynzYlbiNudeY1LYrrlhKud6gXe7OIIccMkcCkjuaU8osdRh1yABLNRBXeKr3dEsfdcAj/tPV/WRRHiptKZBS6/Hrxk8drmY3H8IwkoRTkjgUsZcZRbpaQU1Pm3pKuHr6bqSj0QKynpMopC3GHMa1x+2nfB5vWHJQGlKGeKHbhs27aNvn37UrlyZRRFYdWqVQWuHxMTw5AhQ6hXrx4ajYYJEyZcZ1FvL9k5lhd6tYQDGes+LoZlhhOYg0S61yXyQhIt3t5I7ZfX0nbGJs6bdfi9FcQmZ/LXSVPHZMldI+405jUuQtwOih24pKWl0bRpUz755JMira/T6QgMDOTVV1+ladOmxS7g7cq8wxzAXyevlNi2v/3nHBuO2GbE3HvWkKW3JOtblvxzzvg4JimT6WsdpxBPzsxm9vrjJbj3wnWatYVHvzJ1TJa4RdxpJHARt5tiZ87t3bs3vXv3LvL6NWrU4KOPPgLg66+/Lu7ubltZVieTA+cT6VgCHeW2HDNl5LXm4mSIUx1du51KoAkpKSPb4Wtv/nqE5XaqqktTZrblcS7tJjohbjXWN0lClHe3ZB8XnU5HcnKyxb/bjfVdkKMZnIvr8QJysbjmBy4Ort3miaqKSrUKgwrqQ7Ln7LVib/9G2GsWcjThpBBlJepKGv+bt53fI2OMyy4lZvDJllM2HenTs3LYfvIKmdlFD0asb5KEKO9uycBlxowZ+Pr6Gv+FhoaWdZFKnPXJZOYfx687EV1cciZ/HIoptINsfgZdR+tdTctCVVWyc/XsPG3/5KiqKo8v3M2jX+1CVVWW7bWsQSlouHH2TT6BZtgpf0kFiEKUlNdWHeK/C0k8vfRf47IhX/7DrHXHeeGngxbrTv45kqFf7eKr7UXPfluUpqKS7mMnRGm6JQOXKVOmkJSUZPx3/vztN4TVXvVtm+mbrmtbvT/6i9FL/uXbv88WuN6rKw9RY/Iai4y51nZHXeOzracZ8uUuOszcYhOIpOhy2HI8nr9OXmHDkVib9xc043RWAUO0S0PkxaSbuj8hroe9G5azVw2/Ueu+b6vzhjPPWle0vmLJmdkcOJ9Y6HoSt4jy5JYMXFxdXfHx8bH4d7spyQ5zV/Oqk3/9L8bmtYYhpmN3JKbwJrfLyZks2nkWgPgUHaO/3WfxunmtySir16Dg/DTFqd6+UXq9aneYp4wqErca8/QEr66KtJiuo6CWzUNFCMw/3njS7vIJ3epaPJcJV0V5cksGLneC/Kaiksypsu9cgs0yN+fi/Yl1OXqLHDDbT12xef163aystfvOJdD0zfV2X5PTcxlLjoGfR8LlyLIuyS1DMYtOlvwTzW9mNyAFnR8uJBSeeuBknP0M2a1r+Fs8l3helCfFDlxSU1M5cOAABw4cACAqKooDBw4QHW2YuGvKlCk89thjFu/JXz81NZX4+HgOHDjAkSNHbrz05Vh+AODlajmwq6RrBJy0xfsTv7T8P1IyHQcY5aG9fOKyAw4/g9xYlrHV4yDyJ/iya1mX5JZh/RM1b9qxrsHMHxkIMPa7/YVuu04lL7vLPazPO/LDEOVIsYdD7927ly5duhifT5w4EYBhw4axaNEiYmJijEFMvoiICOPjffv28d1331G9enXOnj17ncUu//JrXLzdnCyGEH/7zzkeaVOtyAHH1F/sD33O51xIZ9Qqfu5cTCz6XElFGVr5457zPNy6WqHrldYAH00BG7YeBSVusui85rvcO2/aCUesv6/5TbVgulG4mJjB19ujrGZ6Lvy7bH1jZNqn5XMJXER5UuzApXPnzgXeUS9atMhmWVnfgd+K8gMA6xPL1NWHUVWV4e1qFmk73/x9rsDXnTQa7qrlzz9nbIcidwsL4tNHmnMiNoXFf5+1GSFkt9zZhde4TF4RSa/Gwfh5uBS4XkEBxo0oqIOwVImXMdXs+/PrBOj5Drh4lllxbgVKIb+Dc1fT6DRrq83y7g2DCt12poMbDb0KI9vXZEHe6CT5XYjyRPq4lJH8xGj28p5sP1Vyk545axXmDWlu97WnO9fGxUlD4yq+eLgULYYtah+XIV/uKnSdMhmYLEF0GTM7/vsWwvY5ZVaSW0VB3dx83JzsBi1Q8Hxk+fJvNPo1q2yxXFVVXurVwPhcalxEeSKBSxlIz8rhct4QyORM20yzxe1QWxAnjcaYeM5aBQ9TwjkPF22RtlfULJxFGcFUFrng5PR8E8QegQXd4fQW29dUq4ttQtHzkdyuCqp5TC6gv1mRApe836u71Y2JVqNYBEzWfxYhbmUSuJSBLcdMk/7ZCyqKmsE2pwgnrhRdNm7O9oOSWoGmjnvuDtaxVpSmoqIq6Vmqi8L6xjJXrzLw87959Ktd5WaG61ta/HH45j64sBu+7Wf7eo5VzpI74E4/KSObJxbtsciMa+5EbMp1bbcoGXHzf6/BPm4Wy8Or+FoETDIVhihPJHApA+ZDjF3sBC4BngX3DcmXpiu89mPHqatFmoOoorerw9fiUkwXm+sdDm2vn1NppN8vbFSWdefc+BQdu89e46+TV+jz8V8yr8uNuHIKPmkN6Q6aOleMsrPw9r9g/rT3PJuPxVlkxs2XmZ1b4Ci+ghQloWN+Hxc/D2c+HGSY5PbdAeEoioLG7LwgTUWiPJHA5Sa7kqrj+92mUVeKvZ4eRbygf/bn6SKtZ6/zX4e6FS2eVyigI+1nW037SdXZNm19+khz3nsgvMAypNnpy1OUURHFlVVILZT1Ls0DlWOXU1jwV5Qkqbtex9c4fi0rHf770Xb5HdBGcSXVNILKuuP49QYtULQpNDLyfnduzhr6R1Qlasa9FiP+8mMXCVxEeSKBy02WmG45DLSKn7vNOh9vOsmes9fIztWzcEcUp8ySSP0bncCAT3fw68FLfF6EwGXWg03sLq/kbVl1bB7bVPRyYfsk05D3rBw9upxctp+8QmyyzmZb94aHMKhVNR5u5XhOKXsnRl2OvlhDsYvi7TUF5weyLob17NGz1h3nlVWSHO26aApo4tQ56PN0B1wwzVMSbD9paiaOS86k1Tsbjc97FGGUkLmiBBsJ6YYbjfwRftY3MfnNRXfAn0HcRiRwucmczfKzPNWplsOOuA99/jdTVx/mjV+PMO57U6KpBz/byb/RiRbLCtLSKkNmPuvOuOanM39PFwLNmo5SMnNY+k80Q7/axQcbTjjcl8aqSWp/dAJxKZmcu5rGj7vtzzf10UbH27seS/6JLvB166Yie01D3+8+T4qdTtOiEFo7gUtaXrPRL2McvOn2v2I6aUy/cfNaxhHf7LVYr1tY8QKXY5dT2HTUNF9Yrl5l87FYrqaabi6uphkeV/SyX6OaH7hIjYsoTyRwucnMT1w5uSqv921EZV83pvVtaDN/yA95TUpHY5J5+Iu/ydWrRcq38PK9pmGOjvqRWHeMNb8T0ygKrk6mwKailytL/rGfL6ZZqJ/xsfVcRP0/3UnbGZvpNGsr76w9avf9OTd54kXr6+TyffZz1/yw+zw5uXoOXUySTrtFlW2n9uzCbsP/pzbavgZ3xK2+eS5J8++S9SSg19NBdsQ3e0nT5ZCVo+eHPdE8sWgvvT/6i+0nr/DniXjOXzP8TRw1Bec3rR67fH0dhIUoC8VOQCdujPmFOlevUrOiJzun3ANY9iUBy/4Y/5y5xiMLbCcNtKdukLfxscZBaGoTuJg9zg9G2tT0Z1fUNXzdnUmxmmdoSu8G+Hu6cI/ZXeKKfy/a7Kewi35p9HPJt25CRyp6udDqnY3GY2l9Z7nYQQI/varyztqjLNxxltGdajO5dwO76wkzmQ4m/SvognzRtsPq7ca8A35BI+kcpee3plEszw1Ld51j+tpjxudxKTqGfmWZR8m/kA7/jy/cw9l3+xRp/0KUNalxuckSzPq4WI+0sTfCyJy97Lf5XupVnwbB3qwZ395iOLWjE6WT1VQANSqaspe+3CcMgMZVfAFIz86x6ULs5+HMQy1DCz0hFqa0hmHWrOhJ/WBvArxc2ftqdzrWCwQsr6EFDUP1dnNm4Y6zAEXqS1QepWRm879525m32f4MwsWWaCcIzM4AfQEjtZIvwPk9JbP/W9DGI7EWQUVCWhYnYlN44LOdNuu2quHPgy2q2t1Ot7BKxsfWv2nz7Tvi41a0FAtClAcSuNxkk3/+z/jY+qJ9/lrhs7068kznOvwxoSONKvviYlY37bCpyGp5nUpefDWsJb+ObW88yXnm9YM5GZtKYoZln4/CgqyiKqnpIC4kpPOOWcfcV+4NMz7293ShYYiPYX9m7+nx4TaH25u/7fYMVsx9ue0M/11I4v31JdTPyDpHC8C/34C+kP5CUVtLZv+3oJGLLfuxfLz5FD0+3GZ3JneAx9vVAKB9HctRf2O61DE+vp6pMqz7nwlRnkngcpOdvWoKTno0DLZ47Xov4gsea2nx3Lw2xdEJy15ul3vCggiv6mt8np9tc/OxOJtkV87FnHXakZLqPzJ84R6+/MuUhdXVqtNz/sct6iE+d/X6g8jy4uPNp0p2g0d/tV0WdwzSHdcUAqB1nEPoTtG5vqFGsFFlX/a80o1vnmhtMRrJw8XJWGvYo1Gw3W2I28vVVB2/HLhYcG6p5BhY8zzE2e9DeLuSPi5lKP9ElM+tiGn3zfVuHEw3q2GU5kFJfs3K0LuqWYy4uT+iSqHb9nR1XB67+WeuQxGS/xaJ+ZBxsA2s8m9S8/u4WA9LFzfgciQcWW3/tdTL8GFD03O/6rZNSk53duDyfPd6jO5c2/g8f0Rftll/OHdnLW/f35gDFxKpF+TFrwcvFXn7S0e2KbnCipvm0a92cyQm2bKPXdoVcHY3TUz6Qd7ygz/Ay7Z9DG9XUuNyk/Uq4G6paVW/Ym/P3gzM5lXJ+TUub93fmH2vduPUO73597Xu1A4svCNgQdMAlFTflPrBReuQWFw2gYtVoNX7o78snt9vNQldQbYci6P/pzs4HZ9a+MrlxN6zhdSKFOTz9rBtZtHWfewX22XaG+sndasqaiLDZtX8Cq3BdHPRUC3Ag/81rWzRFFyYAE8X2lk1O4nyIX++t5//zRv5mJEIs2rD9Mqw/lVINeUEIuv2ORcVhQQuN5lf3sSGL/SoZ/Na78bFrwL2tFNLYx645HfkUxSFAC9XnLSaIneoLWjGaK8CamOKI8TXNgFfSbA+uSvGpiLDxSQmybI/RoNgnyJv+/FFe9gfnchzPx64oTKWJfP8HwBfbDtT+jt18YIKNWyXO7nZLisPcgvOeltYFud81vMI2eNp9lss6naheE26W47FFXldcfPEp+hAVfln+wbTwp1zIcN+P6k7gQQuN1l+U4W9NPyKovD+Q02LtT2t1nY75qMObqRPnkcBwUlJ3cXd6IidpIxs4pJtO4U6O9nPU+PoHrhSAXM1Ods5xgD/XUiyu+9bXWJ6lk3ys/VHYh2sXYiCRgxZc69giCCfOwz9PrdcXt4cWQ3vhtrv15PHeub3/g6aZz1dC2+xN1+nbiVvu+tseaGzzff4cjG+n48vun1Hd5U35hPoupJF9txWNNw+3nIlXTFy72Q6yFxdTkngcpPlfx8dDVN2NBzSEXujhsyHPt7IDMwedpqKvh3RmqgZ91okqLsRFxIyij2aKjkzm1NxKWTn6mn6xnpaT99ks45tU5GBXlX51k4yPetMwuacHCXDAV7/5XDRCn0L+TpvmHeJ0Bdjrp38AMW3KlRtZVpuL+PurW7Zo5CdDj8OdbhKnNX0GI5mfXf03Xt3QDj+ni6sHtvOYrlWoxA1416b9WtW9CQuxXZKjoJ8+kjzYq1/29PnmrI9l6FMs8EQnTUHcb52Eh/F6jwZb9YhN6iAueL++sAQZB9eWcKlLDsSuNxEscmZxvbKguKJgS0tg5dnzDruWbM3OsjXw5m5gyP49JHmNxRg2GsqctFq7NYW3YhhX+8u1vq9PtxGtw+28fdpxycYx01F8NqqQxavebk62YxCMuesVTh/LZ0Ri/aw64zlPv84fNlhVuFb1bW04l3cCpRwtujregSYHles43i924T5rOoAPg4DF/s1Lg+3rsa+V7vRxE7fN0VROP52r0LLUNiNS0GTq96Rlj4Es2pBbNnekJhnIXfT2GkaVDQFTKNhZdMbhv9/GVsCJbs1SOBSTPEpOlbuv2BRlVcQVVWN/So+MMuXUVAuBus7s+d71He47tC21e0u79u0MveGhxSpjI7YaypyLaDD7kwHEzoW5ozVjLn2XE7KNB7HS3n9U4ozsiK/c651U9GI9jXZOLFTgQGes1ZDh5lb2HQsjkFf2GYvnr3+eJHLcSsoStNEkf34qOPXWo6wfO5VyfJ5cP5d4q2V9r+kZge3npDUUWf3gnIiFXST4Oqkddj8lM/ejY3lvi1f33o8zjij9B3pdF7t7b5vyrQY5n8DL1c73w/rWdWzi1BrrZRMLfmtQAKXYmr1zkae+/EgdV75vdB1c/Uq/T/dyWNf70ZV1YLH45uxbubQahS+GmbK1TKqo2FyxkWPt7KZ5bkk2avCLmhEQ2ll51wbGcNdMzbx8krLmpL8mW/tCbRq688//3+3y3ISxnvDQwj2dcO1gItHYRf6gspxKyqx78zlQ3ClgKCtUX/L5wHWtSz51WAlU5yS8O0/56j18lqLZIbXK9aqf0nUlZIf+WFvdnlz1r8Da9bnmuEL95TrTuclZt/CMt29+bUiJ7sI5xdHgUui2eS2JVxTXpYkcClFp+NTOXA+kb9OXiE7V8XdLBDYdNRxD357d2b3hAWx99Vu/DetBy/fG8ahaT3pXL+SnXeXHA9nO01FBWbMLZ0rUH7Tzve7o8k2q+n654z9pqJ3B4TjZnUMHd145gdi1uuDoTYGILoIfXCsJ5i8laXrbPulOOp/UaDP2xX8usbqmDpbXWSNJ9JbJ3LJ/66ZJzO8XtY1F+Yj2R5oXry+bI483bk2g1tX49sRre2+HuJbcJBqb9TRH4cvl0jZyrXcks/zlJ2rZ/vJK6RnFd4vbNV+U22yU24RalNSYuw3bx37zezJrfM7u1ESuJQi8z4YWbl6Dl009exOtXPxyGceGFf0crV4nF+r4VRCmWsLYrepqIDApTTmS1y5/wJX00wnkRZvmYYEOjqGLarbjlJxVOXu7WYIzqw/l7uzloEtQ4tczpsynLiEpJqdOFvX9Acgo7iBV9qVwtexrpq2GfZcju8ACxkJFX01nflm34mFw1tZ9HF5rntd7mlQiVf7hNl7e5F5ujoxY0A4Heoaklm2yft75iusj1thw6X1erXIzeKlYcbao3y1/caDyGKzN2z/Bn286SRDv9rF+O8PFLruvC2mrNZe2Jl13Z7P7rZdlmtWW5NTQN+2gz/Cpf1F288tQAKXUnTwfKLxsS4712Ia+6K2a5fUXD7Xw1mrYc6gZtxd29SpsqDAxbyojav40LiKD+89UEBv9yJ47seDFs+TMwu+W3msbXWL2bELkx+cmZ/AO9StyIpn7i7WfEwfbCih+X5ugnSdIUhpX6ciHz8cAUBWjp5XV0VyNKYIwyZ1qYZEWIWxrnFxlK+lDL/j5qynnzgVl2q/Ji0ny/KCYEevj0zzYLWqUYEuDSpZNLNWreDBV8NbMbJDrRsrtJVagZ4Wzwub1bywpqYHPt9Jtw/+tKjpvFmirqQxf9sZ3vrtSJGb2W+I+dD+hLMl/r38Oi8A23i08NQD5jOFeylFDFzs2fCa6bF1osfof2D1eDj0M6wcBV90vv793GQSuNyAnacKvuusbfbly7Sa66egrLTmSmv25KLqF1GFR9qYOgAXdDHXm5X117HtWT2mPYNaVeP3ZzvYXd98xttzV00ddFVV5fy19OsK2rpbTX+Qz16FS5CPKxU9XW1e/2xoC8JCfBzmb3Fk37kbyD57E6Xl1VR1rFfRooloyT/RzFpXhI7GCQ7ugFuOgME/mp5bH3TrwOUWaypafdAyZXq3D/5k8JdWnbFTLsPbgYVmKk03aybKzDb89vU34bdsHoAffbOXcYZ3R9wLSAOQlaNnf3QiZ6+ml0mWaPOg0XpoeanIshokEHvI/nrXqTg10lFmAxbMa1zO6W+ge0CtzpbPv+5pmAR1+ROmZYUE5LcKCVxuwKurCv5ip5jVDrR7d7PFa/b6VNhTUiMcboR5/5CiBi6KohinG7A3JDPIx5U3729sfH7ZrP1/+tqjdJi5hYftjOApjKOcK/ZGV2x+vrOxjN5mHYvz74yLOwP2A5/9Xaz1y0paXlORh4uTTQ3a5qJkT3U0OuG+D8DD33K9xg+YnluPKjJ2zi377zjA+Wu2d7b7oxMtgurrGW2S//13K6HcRwV5unNtfN2dGdG+ZoFBSVEU1Jx9M6SZ7f+m9CGz7uD6efsS3bzqIEC3N9FshHqUKhhS+nvn1bjMyB5Mp6w5Be9Elwr6vJtk68lNzWtAHaUxKE5SuzIkgUshrO/6zdPlVzTrsZ+SmW0zg3JBdym5esdVr+Y3qgUNP75ZzJuuijNPSj57Q78VFCqbVVObB3L5HSN3RRW/BsN6eGc+e2355vv093Rh9kNNmTs4whiwuGrL/tiXtEuJGaw7bKiq9nJ1QqNRcCsgh41dagEXEfOTo0YLHV8yPbceVVRORjl0mrWVi4kZhgvC1um2K5wvOA9R/jlkYo961AvyYlrfhgWufyNCfN3Z92o3Xrvvxvexar+pBion9+YHl4fMmtZ1OTehqcq6xgUMuVKulUz/NfNLSUpmNidjU3jz1yO0eHuD4fuV79IBlru+yQ63ZwFTjUsqdpr1zBM5AsyoApumGR5vfsvyNfOmsC0z7BfS3jG4BUngUoCrqTrumrGJqb+YalayzX5A7fPS3j+y4B/Cp60n4s31Fu8vaAbiegX0w+hiNlro86Etil3ukmZeWVFQp2BHVeEFpZKoHuABQE7eXceN5pBwVONiL3Cxrgl6oEVV+jY1TbZYWI2LdX8Cu/R62zufMvTu78eMj/OHuxe12dIou4A08hqzkWiKFgLrQ9dX0XV9g6taR9NEFO+iWFr9LQrqp7TnyCn4fpD9F7/qzqGLScaameirlnfu+QFykI8b65/rxPB2NUumwA4Ut+P+xO6286Yt+eccb/5mGhJucWG9Sab9atp/qfdxuXIK5trJIrx/Cax6pkR2YX567PbBn3T/cBtf74giMT2bz7aaOuPyzf8s3ueZF7ikqIbAZWjWFNOLoXZm/t7xkWFn8Vbf5/SrpnNRroOmNwlcyr/1R2KJTdbxzd+mzKjmE5zpVZWD5xPZccoweigtK5c3fj1M9NV0Fu6IYs9Z+5NgDWoZyvh76jrcb1iIDxsnduLg1B52R8iUquwMQ+dDMwUlyzPnqBLJXlNRz0aGvij5Uxbk6g2J+gZ94bi5pVuY/f4r5hyNkriemqLCApd7Gti2N9tU+64cBTNrwsV/i73/kpadq2e1WdI+r7z8NAUFLkcuJROTZHXRyikgcFGsalwUBTq+SPONDWjx9kZeXhlJUkZ+O3rxm4qW7TlP46nr2HYivvCVS0glEui3vj2cXO9wnfvmbqfTrK2sjYyh46wtFq/NGHBjHdRLm71zkXUz+L5zZTuhny67lGtc1r/i+LWY/0pkF+b9Fa2TExprtC7+C7oki9e8FMPvLR1DH7Ht+nD2Vx+B3rsy3G01f1G+tyvBue2Wy87tMJyLcrMdp//PlsCl3DO/4Obk6lFV1SJwydWr3P/JDov3LNxxlo6ztvDGr44TWE39X8NCk5rVqeSFb9pZOLzqusp+XVLj4L0aNvOvNA31AwqfsNFRjYt1MDHzwSZM7m0YBpp/jNOyclh98BL/XUiyeX++iGp+BReAApqKzJa/2LM+217sUui2CkuX/qSdESGL/z5ruSDyJ8P/Oz82/J94HjZOg+SiZ/29UXvOXuPXg5eoa5U00SPvO+jh4Lt4ISGdez/+i7YzLPtnFTis0rrGBUNTSVpeTdp3u6J5ZWVk3uuG4/v97mhqTF5jMQrPkZd+/g9djv6mTgjYRXugyOvam7uqVqCXnTXLl7Sb3N/Fulat1JuKCrqxcC6ZhI32+rLkM6Z8OPiDxfLH2lRFi+G3k2N2ue5//B7qXX2f89neUPseOzsrIA/NW3ZqPt38DP9LjUv5Z37ZyszRk6NXLW4Os6+z3bfInfTmtYSfhsGxNde1n2L7fZLhbvrkOkPNS55Ab1d2Tu7Kgak9Cny7o6ORnysF4Pnu9RjYMtTYcfBa3g/28YV7ePaHAwVu39G8KuYjY4rSVHRXrQCq5TVRXa8hbapRyceN/a91Z+1406gpi4DVXiC36mnY/iEsHXhD+y/IvnMJdP/gT7afNIx6e+jzvxn3vW2OhoC8/lrm/bbMHb5kGhpt0deroBoX88DFybDdTKu75YMXEi1yg2w+ZuhzY30TUJD8GrqbIU11cOGyzgwMXEm1DOoahviURpFuumLn+XFEnwt/zYYt02FOE4f9g6zzIpV6U5GugDQAjobxF1NByQA35M/Ovnu+xfKHmlZES96oNKvLdY4ePtlyCgZbBjs2mj1SeOEC8tIbSOBS/pmfFzOzc23uAgrqYGvOOiuppqA7eV0q/LvYMsHXH1Mcr1+izD6wVYKxyn7uhab0d9Tk4Gk2iVz3RpbNPebJ5QpT0cv+BXb2Q02Njx3VkpgHNI62Uxz5fZ0qeLpQs6JlXxddTq7hy7PEbERN1F+G/8/m/R8becNlsJaRlcsLPx3kgc92cjIulaFf7Spw/fzO0Y6Oh/lIrDTzvkcFNhWZd4hyR1VVVuy/YLHK+WsZ1Hnldy4lGS7yynUOhz53tQgZRUuA6ihRXlvDpHVZnpXtvw6seMZOUrByqMSaao7+CpvehD/fg8Rz8P3DkJsDC7oZAvo835o1z8NNqHEx/07X7grVzP5uJTTHj70424mCa7LqB7pRM8DwO821c7n+Yc9523xJ1gIdz3UHQM8Z4JJ3DisngUsJzrZ2+zEfDrjj1BU61Qu0eP33Q0VLjb3w8VYM+HRn0Xb63UBDW2ToUtOyxJs0+7B5p8vzu8Cv6JljAXo1DqZ7wyBaWvXL0WgUJnavR0xSBvWLkRzO3NzBEQ6r3IMLSWtuvU6Qz/XdQfl7uhhriMxPpNZDirefvMI9tb1ME7YBpF+Bfz431EjoS6fa/cONJ1i+zzJIcJR1tJK3qzHIc5Tu37xmOzE9y9gnxm7W3P/Ny3uT6bNdSFVp//Zah+W9lJRJZY1lzWZ2rt5hP6UEqyD3QkIGNSoWoYN0IS4lZvBnAX1mPBTbQC03sBFabd5xK+DvWdS0B7e666pxyc40zGLsZBYYW+cA0qXC3AhIjIYLe6D9cwBm/aDyVivtPi7m7n3f0LQbnXfOdi84F465NF0OHi5a40jMa2lZKBg+z2WruasmOi1jpPZ37s96C31F+8GFy6/PGJu5rWtcjJRC6h+8Cugb+OIZ8AwwpCqo0x2CGjte9xZyRwcuielZXEnV4e/pyve7o9l6PI5Fj7c29j8x71X/7A8H+GWM5dwsFxKK1tO+ur8HtSp6FmkWZM7lVZefL34OkxuWada/5DoSETnnZvJl8C9Q+36b1wrqjFyYz4c2p1djw0zX3z3ZhiAfN8Z+t9+Y5bUokzs2C/Xj9fsaUqWC+3VfTIJ93IyBi/nQd+satEtJmZBupx/IH5NA6wqF3GVdr7N2vl9v/Wa/r5WXWfOdeVp4807M5jWMSRnZVM2PRw+vsNzY6O2mmZ7NvjcvrCo4m7C9epb5f55mbFf735WraZbHtKRGF/X5+C+LiTJ7NgoyDhkHcMe037W5rUlV3el+/ywqaPP2ry/bpF3Z+mze+ecdWge35t5a95bKPoqdRyU3Bz5saMjW+twRMNZ4WtVe5eoMQYsV60Cp1JuKqt1tCFQaP2hoNun6GuxbZHitiBfzi4kZtHt3Mz0aBvHFYy3JztXT3GyKEmvjnVYB8LLTUt7VvG1YqGgt0w2c+MN4xPSqo8ClkM6HWgfnx6DGhqAFIPzBgrdxi7mjm4peWv4f3T7YxprIGGatO86eswl8v9v2R5Rv9JJ917WfAC9XmlQtetReFtKz0y0Dl1WjCx72ak2XCtNDDHcqC+x0FrsBYWb9BO6uXZHagV682icMjdtFXIN/JkeTwP+aVqZbWBBVKxiaJ6bvms7iw4sttvNE+5r0bBRcrH3PfKAJYOgsPbi1qQaqh1WT16ReptTq11Kz4JptTcceN1eOuZTODNqqqhYr701YsOmYms8CnpWrNwZlOWZVLqmZOaY8ENbVycFmo2bM5ni5mFzUZkDTflYdcNxp2bqqPauEAhfr2b27Wo0W8zbLXPpc9jO8lPMU2T7VQWP4WyoOApc/JtjPGF3S1p5Zy88nf2bSX5NKbR9FqnHJyYKTGw3fj5RLhuG3KTGmLMMbp8HGqajAcRdnMu1dcHN0RNrpoF/qTUX5yeea5A1596wIPd4xPNYXLWj6Me/asT6vv0pyRtEC2i7ag8YgXLVOy29mQMtqVkscNLHW6W56XKmR44EA9XsXqXy3ojs6cMnv7PnVX6aOYG+vOQrYnyPIOLuroqOouSd+G2fIvjjtf414qlMt1j/XsVhlNJ76zYKKrNws1p1dR5LO9gd+PVadWkWb79rwm95qewUM/7Rhbxr4ItTaFGWoqL1+KwrgWXMuLhX2cP/qXnw4qAkLhrVEURQir0Ty/bHvmbV3FgfiDhSh8I4NbBXKjsld2fBcR4a0qc47/Rvz4aCm9GtWxWK9R+4ynVSupulgsWUuhnithidCgngo2N/4zTm0Yy27ryPJnj27o67ZVK9bqxfkRbewSgxuHcqb9zcyLh/ZoZZFM+h/FxJ57OvdrD5gSkDmHb0JZlSFyOU2qdAtRlK5esGLp2FytN1MtOby+46Y/3VPxdkmbTwQd4DhfwznVJLldAQ3WuOSmJ5lkbEZDBOZ+pl1Aq+qxPOi8zIA9ocMRIfhtRy9arrTVVUUbSpoDDUzlbxdOftuHxqYBYel6dfTv97wNvIDdEu5OPv/hcbtIvujE1l5ciU/n/jZ8UbeDoSlDxjynigajrg4c9zZ2fB9UVVjH5b1Hu48WCWE5yvZGd0yvxOzNxj+zi4VN+Be7QtQcko3ubKqQswBw2NXU1P2lfS8mtEiNu3mWI0aKs7gjfzATF/AiL1BrWsYHyvOV/Cs+xYuAZtsVxz4DTz+O4w/ACM3Wt6Qmms/scjlu9Xc0YGLn4fhjumsnU5+1umuvUlnofN79Hb9A696b+IW8lOh2//+ybuMc4X4ebgwpXdYgYnnAPTAH54enHR2ZqOHO21qhPKrl4dF7/slR5fwwp8v0HlZZ2LTCp+wCwqerPG1HYaJuKZ4a5jr58sWj7wMjdkZ5OhzeG3Ha6w86WDcfz7ru/BpvoZhdzvnFfi2wa2r8c0TrQEIVWIZo12FD5bbshe4VPJxtXielmN6T3KWaYTAo78/ytbzW4s1AuVa5jWuZZoCiip+7iiKglaj8Eib6vSPqGrTPOTj5mzMVmqvw3G8WRbeFI2hO2rjDYMZPn8LObl6jl07RnSy49q+wpyILThVt0aBdRM6smBYK2YMaEKAl6vxmPh7uvDNE60JyjumD37+N9tOxLPxqCn9f8OtTxruSn8eYbNtmyHAnhXBzbqGMScv4DcxBS4F/22G/TGcfbH7mLbHMmdFUQOX6KvpJKRlkZmTyaErh1BVlUU7omj25gbeXmPZlBbg6ULXBpV4sEVV0GTwqHad8bW/z5uCHPOhrddy9XjVexvv+lNRnK/d9ITAuy6bOmGvObOG+HT7/XX+iPqDj//92O5voU+TEJt0B06++3ELWoNnzblo3C7w+s7Xmfb3NDJyCmkiP7KKjDNbGVQlhAerhnDgp8Gob5qmgljsawjotuWfZ8zFHzX+XV0DN+HkeQYn70OlNmebLlcHcUdNC1xN/ei+3ZKXv+XwiiJNompdxqI0bx12ceGskxNTdbNIWj2WxLwrst1Pa9aXxbXS72ic0nGtZKcpysUTqt8N/jXBxcNihKhRpUaG18qpOzpwsR4Nkk9VVc5esQxmXndaTBftQWoErEbR5OLsV3BCsZ9Gt6Wt2azK9qRbz40BbPFw58VKFRlQNYTnggLJURReDqxo6vUNfLjPcOeSo8+h2/JuBe4D4FLqJTr82IHZe2cXuu4XFXwZH2S4+05TYOv5raw6tYrXd75ObkFVpq4OArL1rxSaYCx/9Mpql9d40XkZrzt/a/G6vcClRkXLk96Rq6YLkPWJddzmcXxz2HKOGVVVmbZzGu/ved/iRJ6dm02nHzvR6cdOZBejn8/ltMv8nfglivMVuxmT9Wb1Cu2qh9KkZjX6VwnmZdevuJQay0O/PkSflX2KvD9r5n1W7DFUEJjKcD7lPE0WNyH8m3DS8pJOuToYpv+80zKH230z+1EA4lN0XEi5wNWMq4aLATD87hrG9TxqfYxnnZmgWB6bTEXhcJWduFYy1RpY57vQ57X5p+dYBmfZOfa/V6qq8uvpXzmTdIa4lEw6ztpCy3c20P+X/gxeM5h+v/QzZmX97b8Yi/eGhXjjrNXwcIdsvOq+zZZKplqndNUVwyVFT65eJTEjh1RFoVsNU22Ve5XvURyNQnJAVVWHwUZR+LuZgoLJf02m609dCf8mnL8vmZI55upzeXHbi3wZ+SUH4w/abMPT1YlDb/Q0LVCycK+83PjUvbJpyG2avSRlVr/xhDWmIPPRQB9+9zB1iLfbRIThyP7h6YFeew3zS7dbyM/8l/y73ffciJ0Xd9JmaRu+PWvoQB6n1ZLrVwMwBMUDtH8Z112/eRP/Rscxa88s9sfZphYA22kR7DVvtapRgd6aXfztOpZ4rYaHqwTTN7Qy96g76XJtKz1DK/N2QAW6hVbmqlVqh1UXt+HkY/jbKZpi9Ksy77xbu6vh/xbDi/7+W9AdHbgEORiNcjo+lQPnE9B6nsQlYCug8pCTYZr6HIsfnemLebdFkKISk/gnj//xOFFJtn0dsvXZhH8TTpvv2thU80a62m/jVLMMQU7mmT9tXtOrevSq47vPLee3kKRLYtHhRQ7XsXZFq+Gu/W/z3NbnjMuMwcH+JbB6nKGWJTHa0Aasz+E3Tw/Ca1ZjpZcnJ52dmefnS7qiFFrVmp+Zt4JiaCZ4ULvN4nWtnRPdt0csg5sn1z+JXtWz9sxaixN2vtn7ZlsEKJfTLvPzyZ/55sg3XE4zjQ5Lykqy+7gwE7dOZNfVX/Gq8z5X00wn9j/d3fjd04NoZ9vA4pSLC+l+hmatfD+d+ImP/v2o0Bqi/KA3IyeDXH2u4SKuZOHkcwDFJR7FKdG0spIDmgyLbS6IXGB8nP8dbBBsG3x2dV3PYJfVNsv/9KlAr9Cn+cYlDEWbStcVLem9ojedl3Wm5ZKW6FW9sRO04nwNrWscGqc044k334uBASR4xeISYMrh8ukWQ/rzHH0Onx741OEx0DmocZm5ZyYvb3+Z+1fdz8nYVFyDVuNWcyYXUg0jrs4kOZ57JsDTmUupl1h0eBGKJpfDvqaMsV21+/CoOQfvsJd5fscIPt1xkLY1LEfead3PF1jjkp6dzmcHPuNUginF+8LDC+n6U1dGrhtprC2MTYtl0aFFHL16lPBvwvlg3wcAJOmSjIFhvrp+9jszj9owyviegb+Z8galZBkCwPkH5zNy3UgmbJnAuE3jiEo5ztKRhhTyzr4HLLalcTWNJMuwdwefm00OpqAkxWqky6RKFdmQV8OS4SBlwWovT16sVJEjylQUJ1OQqmiy+euaKb9JbFosu2MMNdB/nv+TufvncjntMqtOrSKroMRrVqb9PY1cNZeZx75hUmAA91Srwkv/TAPgdHwCCwO07HVzJQf4xeVVFh39nMVHFvPY74+hV/UcjD/I2jOGoGfMbx/w/cXnQJuGs98/bL+wHV22Hq3HSRRn07F7v10un7l8RLxbKm8FmALOC05OZCsKOo2GH328iXNyYpmPqfYnTqvltWMLca/yPZALiukm8tO/zZr0e71n+0HvHg+BDXi5SVfC9af4ptvz0GpkkY/TreiOHlXk5SBjaFyKjiupWXhU+woArVMC5F3DfvAxndy96k0jO6k5IblD+OKxljSeug6UbPpUmskrBw0/vCfWPUHvmr15oO4D1ParTXRytPGEAvDy9pfpW7uv8Xmmg6FtTXY+Bw5GVA/8dSDHE44zs+NMete07HCVnp1ucZEas2kMn9zziWl/Vjk5XLNU9Aos8LXtTLzsxDLCA8PZs24i8/18uWfuCganpELTIeBbhSl5bdavB5qCuPkVfFkeH0n9YDvzgORx0ioozlfJBvK7rjr77UKfbRjGct/qt5nadiq9avYyvsdeELY5enOBHRTb/9CeV9q8QqvgVhZ3jUlZSYQQkpfh1bTc+tjku5Bygd4rDMf5297f0qxSMyKvmPKyJCmRXHDSMrByCCmFTDVwVavlWIzp4vjm328C0K16NxoFGPqhxKXHsfDQQtqEtGFf7D6cNc58Gfklr7d9nXd3vUsD/wb08n8H16A1uFQwNRtkxvYh+1oHPGp+hNY1nru+m8W6B9bh5+bHipOmkUGRVyJ5mIeNnQq17lE4+28n62on9tTcTBeqEhllasb6xM+Xzyt4A2vwqGH/c+28tJNjaXvwDvvaYrl75Z+pGeLLoTN+ZANbPU3V1U7ekeizKzB7AzzTpRYrTq7gs4OfOTx25vOG6VU9qdmp+Lj4sOToEuPylec+w8Xf9odTkQSuUAGUbFBNHab3Z3xJz58346lxwyVbJctZIUmj4StfH7YrfmjdDMfoROJhTnAY90yVu4+p/FNfIc3dcEEO9nVj5cmVvL7zdZ5t/iwjw0eiqiqKojB3/1yWHF3C14e+Zs9QQ/bf/BrUXZd38fzW5/myx5eM2jDKIsBaeGghHap04Il1T1Ddpzq/9f+NY9cM804l6ApOx//DsR84kWBq6jiRcIK7Kt/FvAOWzbhbL2zl4KOG5hHFyXFCttNJpwn1sUqVcOUEI0IqccbZmd/PX+KKndq7iUGBREZFk252jlPJ6+PUbCgbYgzNcnolE6+6tpNZ/hf/H00CmxhrmV9o+QLv730fgC/++wKAmNQYnm72tMOym/N28SYmzVDjttbLUKO9/tx63tv9nuE75OfMz36GTvivXLlGZLwpg3TTxabcUX9d/IttV39D6wbe9QwTGz69aRUdvSfjUd1wDUk5+i4Keqr/fB8Aj1S2HCQQZ+d4mecPOm7Wqd/ZfydaN1Pag0+OTMU4m5Kdmu8EJydODPiYX9cbgpX3T//EkLun4FyO6y3u6MAlP5OhRtXjkZ1JduAB9IoT86fup0OwC+T1G3Xy30Visgb1lBtVvFWu+MCUZbnsrqfnRJW/Sfb4G3fngzRrspvT2SvYpqp5v0iFKxlX+PbItyw7voxXW0zmq9XTuFQJUMApFyqkQlRSFEEeQZxOPMVSXwdNLqqKUy40ilYJSoD1zRW0emh1QuVw9WPgofDStpfoXrE9MZMm49O7N75972Pu/rlcybhi3Eb9L7dw4s3O6Ny1VHn2eRZUPETtSyrV4lW2NVb48MtcVGDs07Y5U7ycvdhxei2jQww/5oqRLnTMyaWy+h36Zo4j+PdWDeLrh/4wZWc0k5KVwsmkg3jVmcWktIp8EHeFwy4uuIWspMkZPTG+LsRn5/Dithd5cduL1PGrw6XLJxm2Sc/uegr76pp+fObBg1OOSo6TgnOOSq4G9BqF5KxkY2CzsKepM/Gjax8l1LMKs79zJlHNgPsMHS93XtrJv3H/EpMaw0P1H+K+WoaTTu8VvXHOVul0SGXt1iGMbqMhOAMyXCDJE+rEnWeOc0W67IHfWhsCQUe34d/5eqM/cxlNXqzX4qSeLCd4f8/7LOy1kOzYWL7Y9gaHj/zJkhpLjH/HCqlwevpUAppoOJ55kL93r8OzliFocc9UyXQFt6A1ZF9rh9bV0AyRnpPOi7+PZcRdY4k4pSfdzVCmBj+tJOOTkTxydwWW/nMJjxrziTilp9uB//g8SEOKh4JOASedwrUoDy5U8EZppaIWkEjxQsoF9qV9jVOOSq99KumukOIBe+ppiFK+xrM2vJqkEh6lElnT8Dd0r7LEeJw6/PAOjf0b4pqlonPJ6wujqjx9cAXnvYP4I8KNzXHbGa6+g4JivJA4KZantHUXlhmPWf62q8eqzMx4kdcYxPGIzeTEdSbobDjnvEM4mWG4OE1alEpIAowbraV99ap5W7PNXzN+tZ4Wp1VanlB4b6Dh4hPg6cJ7m14DN/jo349oFNCIl7e/zCNhj7D9omH+mMzcTP48/yedQjsZt+WcozJo2nYOPt+QxFEa8LE8vrO+fJwAP/A6F0Xk6als2fcT/9ZWqJMAabUUrnlDpguoioJLtkq3/Sppnc+Qrc/GTaeS6WrY3px/51g0L5mbvH0SVT3iuOZsvx+LoldJPXmcmAr1mXdgHo+EPUIDz1okfjmFw8Gu6DRwZJ8/f/m7Qd612SVbZcFHuWxqpvBpC1+uOml5+M9cBuxUuVDbl8rNktF2mEjC8g14ZqgM3aLnz3ANx0JNn7/JGT1fvjuYnN6mwQ35QYu5Tw9+yopTK5jXdR71/Q25UX7ed4EQH1dqL/8Kp5Bg/IcOJTsmhgpu9ueB+yHyW9CCcy74p0BsBYV3KvpD7lWbdX1TVf489Ct4mMr60LZcWpxWeevhGeQ38DurJ1ErnCBdp+ChqlSNV2l8TiUgRWVZew2/u3tafEcB0t2CgSRerBjAOk8Pal9SORtk+F0rqsqjG/WcDVLYFp5KiqLgraroNR4k/Lwct3ZtmXZ8Du2qtOObw99wKvGURbnn7JvDi61eBAzXn08OfMKoJqOoV8F2ws1bkaLerLzZNyA5ORlfX1+SkpLw8SnZnvo1J/3KVxtnEJKWQJwvvPuQlg8WGKrh3ntQg0861I5R6bHfdJh+6Kjh4W2W1dT7Fz/HBwc/JssZ3vw2l/p5TeM/363wwE7bQ3yiMlz1UWh7zPDa3maepOWk83tLDY9tyuVALQ0nq4B/Moz7Tc8Vb6ho1sSfq8Deegptjpu2/dm9Gvp4t6Xaj4Zq99gn72PJlbUcDVWoHqfy2g+2VeuHGrjT+JjhJHWgpkKzKMP23hmooet/Kr+10pDtBFWvqNwdfBefu+8iwwVGr9XT4YhhXY2THn2OhhkPafDQwd1HVXbVV7jqA+kuCopbLnMPJOFc/xmcXPToknO44qVn784VtDuq8vPdCvUvwLsDNew+fYGV6X6cj/eg17+G7V8IgFce0zJlWS6nKyvkaOD+XWbNPn4w4Skt3ferXKgIXQ6qdDysonMC1xxI8oA5/TQ0iVJxzYZmp1UO1FY4XE3hWKhCaLzKtO9Mx2ZBDw0j1xueX/SHKtcg2R2CW3ck/c9tnKgM9eyMMEx3gV/baBj0l/0mjN9bKITGw45GCrvz/nYZLpDjBE+s01PBquvAvy18iTiYimLWyS//M9nzYT8Nz60y7Ds6EBI9FXS5ASy4P4EasSrV4+DhP/VsC1foHGn/Z//Ko1oG7DRcjAH+aqRwrpLC0C2Wn+nvBgqnKitsDVdIye9upCiERavUiFWpmKzSd7ftPhb00HAmWCHeF76ca/hcrw/V8sB2PU3Pqvxyl8I/9TW45ED7w3q6/KeyqZnCoeoKblkwZo2hHIeqK+yvpfBoXrmigqBmLOypq/BzOw3vLjJse35vDcHXVO45aPjb/1dDMX42gI/+p2HUH3rc81oYjlWBGnHglteFYEMzhc1NNdS6rPLQdj1+aYZtnqiiMHuBZZ+vCwGGm5HgRNPf6r2HNCR4KbQ/rCdHqxi/G+89qGFfXQ0HB+7mf3NbMW51LtWs4qJ9tRWynCFXAxcDFIffK3NnK8HLw7Q8ullP732Wx/+qNwTknUNOhcArw7QEJEPNyyq1Lqs8sNNw/O//RyXBE77tqmHATj3bG2nQOcOwTXrSXcAjy/Bd39pE4feWGuZ+nmv8Tixvr7E4LluaKHT5z1SOM8FQyzpvp6ISNGUyX/35HveZzfrw+lAtsX5Q67LKpOWmzx4VBL+31ND1gJ4GeefZLK3hO1/HbNu51SujPPo076w/gRK4g1fXGGqwXJo3I+vfAwDM76WhaZTK5QpwqrJCUCI8ulnPyRCom9f9aXZ/DbsaaHDKUXHPggbnVbr8pxLjj/E7/mMHDT+316CoKj++67gv4NZm0PmA/de2hCss6KkhIAWqXFUZsdmJjAoZhJ7WcqwKxs96KgQiayj0/9uw74FTnHhMrcWg/1JIW2vqs/VhPw1OuYa/S3ACdPlPz+kQhVYnVNodNf1NPhxTmdabY1jXxYefxpd8/rDSuH7f0YFLxskTnO1rmyxNCFF8R6tC2IXC1xNC3JrCjh0tfKViKo3rd7EbubZt20bfvn2pXLkyiqKwatWqQt+zdetWmjdvjqurK3Xq1GHRokXXUdSSt3fGS2VdBCFuGxK0CFG+5VwrmbxSpa3YgUtaWhpNmzblk08+KXxlICoqij59+tClSxcOHDjAhAkTGDlyJOvWrSv8zaUs9+Tpsi6CEEIIcUuIfHtyWRehSIoduPTu3Zu3336b/v1tp3S35/PPP6dmzZrMnj2bsLAwxo4dy4MPPsiHH35Y+JtLWe3X3zE+3lVf4bkntaRajZDe1drQXrmvjsKocY7nuNldz9SpKt4Hvumv54hVx3s9hvbIxV0tD/uh6goHayjGwdXL2msYOMWJn9obtvlXI9O2Xxuq5f3B8NUAUwvfyPFaHnnRVLbTwbCuuUKsHxyqpvBHc9P7592nYdBkLQOnODHpcS3jRmv5sqeGgzUM63zcV8PCbpblSxh0D7vq2++IebaSoQ01X3QgxPqZXv+vhuX7NjSzfL6svYalnTUWnzHfmlYKrzyqJcrBHGFf9tQQPPV1i2VThmnJyjsU2sBAQr9awI77a9m8N9kq99WLT2j5pY1lGX7soGHsaC2ThmuJz6vhzNHAm4M1vDNIw7intAycbDh+rz6q5UIApJnlxTsVYujjNLu/5fE8UNO0n131FAZN0vJtF9M6Q140/F1Gj9HycV8Nm5oqnAs07PeLXhpmPmDoTzTpccPfMf/fIy9ouVLd1Lk71Q3GPO34O5vh5Xj6gVMhsOJuUznN/6YAc/uayvuPg+/GjjDL5Uke8FM7hdy8xcmVTGWrZlYLu6GZQnrecUwswhyKY0dr+amdYlOOn+9W+KSPht9a2Zbv39oKl/0sl/3UXuGpsaYyJbuD6qrHq22icdn0gRr+qWGbn+mXui34fkI4R0IhzmxAXmR1y30/8ayWT/poSMj7XOkuMOlxLecCDb+F50fanoOs5Wrg2VFannlGy946hu/XpQrgP2wYbo0aWaw78wHT3+mSv2H/A6c48eH9lt/JpP+1Z9AkLRNHanljiOXv8Z/6Cj90LPhSsaWJaf33HtTw+ATDcdR4uBBbWc9vQ2wzwm5spvDwJC3rIkzvveoNOndTf5ZD1RTeHqRhxLOG35m5n9ob+ortCFN490ENK9sqjHlay1c9NAx9QcugyVqb72Bh1jVXmD7Q9rMeqqeSZTWUxdk7h03/q8Kk4ba/sZcf01r8zu3ZEKHwzDOGY/7eg6Z9XvAKZFl72zLE+xiOrfn3yx7za5G59REKH/bTsDVcYeYDGnbVM/Qd0zkZ+mdta6QQ/+R9BW/8FnFDfVwURWHlypX069fP4TodO3akefPmzJkzx7hs4cKFTJgwgaQk+3kydDodOp3pi56cnExoaGipdM49uH8TL255lpgAhbuCOrPv/FmqXYlC5wyVElXqB6bxYEIqD9QIBkWhyhWVp9fksrSLlojTeu497MpzQ7OJ91NYNsPQa3L+/TDdI4a7qlWl9QmVmn61aL36FAu7a4wjKDpG6tHqYUtT0xfUTaeS5QwfEsizGkNPPQWFerpsOm9SOBWisClCw96z0WhU0OaAXq/g5KLyo7cXi9QKhF5R+TvM8kvfuWpn3unwDn1X9rXICGvu65hYfvHwxOuup7i490tyo9zw9sri3cad2dzqYZ7b9Cztjqi4ZcORagpXK6iouQpZzoYfSfOTejocVvmyl4b3M2oT/FsCHi8+T6/Lr+KeqdLtoGHIaKVElanfG05MZyvBS09ojT3pXbMMI6fyh5Xmc9epbPwnHo9KWRz3dmL+1Uo0O6Myt6+G/SMOcf7yCb7++2POJUSREODC+y3ewN3dl8oB1Y3buHLsIAf+XM7q4yuIDlQ4Xdk0UkUFm1E/+UNhzSmqilsWZLgqtAluwwutXuChXx+yOZYdIvXcu1fPB/21xPsZtjHpckvuqtKWw43u5YX1n+IauA5Fa5lzokdCOpOTrjGrYgV+97K9YkcOM4yaSs9Op813hnwbjzV8jMVHDHMy+eQqbI8+x34XV+ZkBHImRCHJU6FCisq9e/X03qMSWwECk2B1Gw1+99zD4EvVWdI0hbTvlxFZQ0PPU+2ocPoYHw6+SpIH/PheLhf9YeIoLXUuwqs/5vJdJw0HKvYn238VmS6Q7qbQ02MJs+4P49+lH5P6+Vd82kfD6RCFZ9bo+ae+gneFIDS1qvNHxl4CklWqJjsz1dWf2gn7YOB8NE0HMfiLf9iX9BOuldbjm6bS+KzKPw0UsnMDaBDfiSfW/8TZSgpd/1M5UFNh+sOWFwxFrxKcAD3264mo7MOEhqbezq0zMvkgLp5L3xkm69xTV2HWg1oyY/oRmnGKjOBIUvNGhlTJzuGyRkuuVjEOA9f1+pG3t33MqqDzpEWNpXJCFs1yV/LUvvOEVEsn7sOjhIV402SxIXW+X6qKVwZcCFTQ6FU6HlI5EqoQV0GxKK/qYMRZQLJKqhvoXBSaBjblSMwBsrUQ7l6HRW0/JtZPwUnjRI+fe1h8P1RVRc3KYuC6RzieYEidHxatUilRZXu4Qq7Zvu46qmfiKj1+Dw9CP/EJepknQFRVfm0wh2pN7qbpT4bvWsCFWnz27Ql2hinM6aelRVZlWq8/z9pWhk6gM74x3OQ9PEmLPm/EWeRj/8HSvN/IIz+BovDqiLeoeXEjnzx0lWwnBe90lWd/0bOlicKORhoOnoom5YI7Hj0G0ORaLE5epqHczU7rydHC4eoKqp3jNrn1ZBIyE5j/nynvi0emahxBFxqn8uAOPT901JCjhcbnDCPeYvwVaseohgBMUehyUE/INZWTTdoxsd144v/szvigQBZ8loVPooagFon4103n0r3f0H5lBm/tmk8mfvjq0jntU435rdviU/1Dmp0xjCp0yYG9dRU8dFDvosq/tRWbUXnumSqaq+9zOTkX77DJVEpQGbZJT4o7LOipIcfJcv33q76Lfsp7bGh7Fa8MaHFKz5KuWo6FKiiqilMOZFudw36870cG/TbI5rjl++SeT+hYtXjT0hSmNPq4lPpw6MuXLxMUZHnLHBQURHJyMhkZGbi726Z9njFjBm+88UZpFw2AphH3cJ9uKiuivuK5Vk8z/vQ+TleeCRhOOvddyaIm2caTy8WKCq8Oc+LphCTqvfE1B1IuEL/PkJF2fi8NdWJU3nG7hIeqsjP6Alv83eny7C5cXnBhx67pRJ40zPWR0KUpc7vOZVjyWSp5VOLeFfeS6aqw4kIMdas3wFurIyUrhY5VOzLv33U820nP5rycF675oaYTaPIyTLqoKhcCFS4E2v6YZ3WahZuTG00Cm7D1/Fa7x6GJTkerTB20ngxrZ5DppeCiqiiRy3AJ64aqUdje2LDtOt7VaXj5KBvNcnD8W1fDv3UhwM2fDk/9AhPyMmx+9yoZbgq/5tVmXPGBreEK5ysqrGmtWJy0dS6KcR7eNhmZ7HI33Houj4vBp5ohKGyUnUVmPR0fNnWnVYYhz0pocD2m9jfkpMjPl2GtYoOmdGvQFJcL3RmzaYxxub2T32t3vcZb/7xlsaxdlXb8felvMlwNQZeT1on6FeozrtlY5prlw6iSncNf4U78FW4KHsdHjGdokycB2L0rmuyEdmQntKOK61GSaxky+g5NSubFxEQ0wMvp3rzz9F6af2s/942Hswef3PMJSbokKnlUMgYu4bp0FKBJlo4jtUCXd2JM8FboPONr9sX8x4f/fYxGNQwP3ztwFq5aV8bps1lfqxWjglrievB3vNcvY6qXYQjwwCmmU8TJqjD8OS3Dk1PYf7kal7M74eKzDd2VTuRU0aO4uODatxfDNaYsxR/2NwQXdfx8WXn/Qv74JpyrPgpulYOom+YGqaYhoC5OGrKutUfreZIkzyh25N31Z0QPJr1CIyY/bph2YlkHlWtZLQHLSU9VjUJMAHzTTUuvXE/Imzriv6hoY0aMa/5ZZF5zMdYQjOtah8yM1nx79mXjdnqkpbPQz/IE6xrWmCktllPp7wPMPprABXfQMYJ5PQ0ZNLwreaIoClsGbqH78u7kVnBnyv3vMmbTGPQaha1mNRJBHkF4ad04nXLOYh+7huxix6UdTNw6katmQ6EX9lxI8yWG78L0XnNw8a1GfmVuzxo9WXfW1OyuKAqKqys1fWsaA5ej1RTa+iQTl+XOUbMElw8EXCPs4XQYPwzV1Z8WGZnsc3djdLYrrfp8So0Qw1QcYf5hHL12lAtqOx4aeDeaWobkj0poZXjlfjx2f8QJJ2fOVwSfKjXQa8w6OykKDDVl4AXYEdaBJZWa4O30KgApHgpvPeSN4mRIqqjRgm/1DDi+FF/t51zL2I0+yx/3Kss4UFuDk+JExyrt+POCZTLOKa2n0MSnD79dtZxPKT9oAThfSTF+JyOjoglvaphjbEBKJiuamqq6tjTVoKoaJoePpnGLcKb88w7ro18koJNK5hUXvKsYzj367Ez0qg+vtH7RYp/oIDl6DLtDV/JFwkGeDqmU91nhgXad6JIUzfu6sxZvqRhYjbVP9eLNX4+wM7E7FytsYNaDWtyd3Hmq8RN8csDUPWNOlznU8riLLl3By+ciSpW5rGxnlh9HUcg2q1AN8w9jWV/HGbDzeTiVj2kAbskMNFOmTCEpKcn47/z586W6v/GhtdgaH0fD+Ch6121t8Zp/rh57FerPJCbRrXo3iwvvpggNbnel4KkYggkvVaVvWjpey0fi8uOjTGv5Emv6r+HVNq+yqNciAtwDaBHUglDvUCKHRRIZNp662dng4sHSe5fyWMPHmHb3NEi/Sru8i7RWVSGsr0153AqoOHPJm3G0oLlwXFWg7VjDk+rtcFNV05fjV8s5Yj64Zy5TdZZzBVXNzubfBzezdZDpZOKqNa0zOMkwDlPVKHx6n5Zf79Lgq+r55HIc1lpmZPJ2vClnQmCu5fDCWXFXefnKNWbH2ebVsBe0mAt0N6Vn3zpwq911IipF8H6n93mh5Qs0CWxCBdcKzO40m7fbvW1cZ0TjEShZqYxKSmb5hRhqZ2XxQWw8f1y4xJvxV6mTlYXfuQfIuDiI4Y2GG9+XqjOl6s7WBRMZFU1kVDSTriUaj/dl/zY4a5wZ1nCYcd0Pm06ASwdAr4eki3Ss2pG+tfvSOqiVcR193kd3Avaeu0BkVDR/VurF1oFbuSvkLh5oNAgUBb3GcIHN//s4a5zpU6sPQZ5B+K1/Fi16eqYaLvq9U021Fs/6NmVZzGWeSUzikXZh6OJ6kRY1jqz4nsYJ5oI9TYm1shNNgVfDgIYWx9hiOoW8766zVgOqCxnRT5Fy7C10cT1JPzeKqjoXLsZcIryiIbHS6KwENqSbsvku77uc/x77jx/6/GDcV1CSjtmx8fx4McYiAX/1Llep0SOeqJqGAPT+Bp155q6uFmVrkWkn8aCzBx7OHtxd3TQLuHmCsPzpEiq6V2T/o/vZOWQnHat2pHt100y9QR5BjG02lt+6f81DZy3Txs/qNAsPZw+6VevGuIhxFsudtc5sGbiFjQ9upIZvDduy2TG5tWVfBW+9Sp+8v2UDjxCWVu5Dz7S8KUeWPICSfIlFl+OIjIpmzIWTtK5omvx0Ua9F/HDfD2gyG5Oa1ZgcnaHW6r5a9/FMs2dYduky065do9K9V9DPftX4Pq1iv5kyMzsXVCfSo4cbl2XEPAhA+zTLJiW/3ByyrnQjJ7k5GRcfpoZ3XX7p9wvTO0xnRocZNK9k+o49WHcQ983dzlfbTdnKK6XZz1czLe/8os377lUIfJCMC4MB0Gf5k3LsbVKPvUnjSobcU716/481uh64uOvxCc00ZtFPTHY8R5g+sxp3u71D+8xMXrtiqunuG9iCRwf9Qh2/OtStYMp6fD7FcJ17vW9DBkY0Ni7/Z8g/jG462mLbge6BeLoajm9qquVklZmx95Jy7E1ebmMKxu+pdo/x8TNNn8ERD+fyEbiUeo1LcHAwsbGWEwHGxsbi4+Njt7YFwNXVFVdXV7uvlYov805cPwxh3OCf2H1Wx5G8/VfNNtzpz70cz7jgQMv36VK5t1p3i0RIjyfZyTh5Im+ejf9+pFrLx6nmYz09eZ78rK3OHtT0rWlMEISaS7+UVHKBbunpENba5q0Vch3nDtDkpaf8sseX3PPTPbjq9eg0dmLWHnkX5vvnwY6PYN8iw+7NVtlx73J8fGvCExtglSmT7crhB3B2smycd9I4cXflu0nITOAlDy+ePrqSjnnJvF66mkC3tHRCcnPZHxXNTP8KfJ+XfG9hXjAzNCkZV1XF3Soo89XrDRl7AS7ugyotHH52a2EBYYyPGE+wZzAB7gE0DGhoMc8RQDWfasYTytCwoWTps3B3cue+WvfRrFIz3LRuBHoEwid3QfxR6gOrLpoSSPRPTSM98S5eyTEEFXVfWc/b/RrTL6IK09ceM66XaTckhqpXDHOkPNviWbqGtCV843ScV+XN5Fr7Hji9CYYsg3o9UY6sMr7PXujqv+sL6D0LAF9XX77p9Q2p2alUdLczM6/e1Ldg6pVrdErPoGt6hrHZ6m6PqjTIMgQcT3RpyON9/FmyK5rXVh0yzi9U0b0ii3ot4qHP9qHPrELWtfaMvi+Bp5o8BcCQBkP47th3TGgxAXbmZ9U1vHdy7/psPJp3rlCdybrahRCuss1tHPGqD67dDnHow3rclZmJBnCL7UL7ZsHGRGONKjYyNqddmFqbHoptEjWNs4q7fza/XowhQaul2v5lENwYF10jslwP0zktnY4ZmbwfG0+9bLPgKm+usIYhpg4GFsfbKnlYvhDPEOPjjQ9tNDyIXI6T2Zv/OXsez0cNAY6iKIxqMoq5++dabMfu3wtD9lcb8ccJOG45t4+7qmdQcip1s7NpknkeL9WUYZlrp+GTVpbb+HkkPLwUMFzMGgU0wlV7gaycHNLPjaJG5QSOnqjPiwcPMtPNl36pec3+VdvROrg1uy/vZmrbqXbLnJWX8Tg3rQEpx97G0F6mJe30c8zRPmexrpNqSlqUk9yMd+8aSzUfw9/gvlr38UfUH8bXY/Jm+s5Oao5byCoABqZeY55Vq+usuCv0ygvavriQTrJLOtdqhpOT4kvK0XDM7+er+xsu5B3rVuSIncvl4u3HgcoA9AkPYU2k5dxX9YK8IQr6p6TiqdfTOjMTWviiUTT81PcnFBSafdvMZruDGwzm0JVDdAntgiYvSnqqyVPGJjAXrYsp87velfsqzuCK8y8kXerG7muG5KGD6t9PsEcw8Rnx9KvTz7jt0U1H4+fmx/RdttmJ3Z3sX5NvNaUeuLRt25a1a9daLNuwYQNt27Yt7V0XTp9rU5vg8v1DvOfkRN/QyvRJTaN+3smrc0YG+4bu4/ktz9Hyv18MK79fl0DPQMhLwNgmIxPHXSEBR1OW52SBkwuk5U20ZifqdQHTxVpje8ELsZqJ1E2vJzM/OPm8HYzcRKVL/xnb7Fd7efJKXmr+e1PTwMXbdOL1rwV9TYGL+WfyCTRcJPCtYlzmpHHCzcl+j8LPu30OgLLzYyoc/tkidbzx/cDAlFS+9/WmTYbpbnfStUS727TwZVeYVvQ5hQCezGu2Abi/9v0cuXqERgGNeLPdmzhpnCxqirQaLe4aw49ZURRCvc16XMc7znlwWK1h8fzVVYf48i/LOXJ02J+XyivjEuhzcf73W5r/PhnM56Y5nTeN/V+zoV5POGFqJgguwmy0zStF2M/imxoPZ02Tynnn1RYCfNtrMRfTLtHwvNks0M6GGbPzJ8jMMZsYsVlgc/SZhkBOr6vMS61Mx3tS60kMazSMyl6VYWde9uK8wLRGgG2/nlYaQ3NHoJIMn7XnbrPakDaJPrT1f9T2s+RkUVWxrY0z562qeOfkwBZDsP73hGNkfByGb97n6JluFvQ4uUFeraW7i+nXYF7j4ihwGdVkFAfjD9KrhinIJ/miRdDjqaqQfhW8KhmXDao/iP1x++kS2qXAzzGm2RhOXDvBA/UeMC38vAPk6niygi9f+hku8le1WpyAuzPs1CbZc+w3m0VZ+XND6T3ISK7Agu2Gpq6ezrXopt1vnLhvQY8FxKbHWtS+mTP/rqCaLkH6rCCe1rzAG07fEKoxnAud9JbnTOsJODVm0wekZBqCHGdVw+oLl4h0daVvehreV7z4T6nM6PQzJGk1NNWZ+pY1zk7FI0fH/f/GA75YN0J4501eqigKAb7eWE1cjyum4PaTR5qzZvIai9f9rx0wlAnok1/D5Wr4mzhpDNue2GIiH+z7gDfvftP4Pncndz7o/IHFtrpV72YRuLg7m3UkT6rM0+1nMmCzaXoLjaKhSzXb74+iKAxuMJj2VdrzzMZnOJt81vhaeWkqKnbgkpqayqlTpvTBUVFRHDhwAH9/f6pVq8aUKVO4ePEiixcb2t1Hjx7NvHnzeOmll3jiiSfYvHkzy5YtY82aNY52cfOc2miYMNBKjZwc0wW2+5sQfxzC/oeL1oW598yD7XnvyU6HxHO0cqvEIVcXPowtZIbXrBT46XFoMhDq580pdPRX+PFR6PcZ/J3XVyLmQMHb0doGLua1EvMvx3HMxZkP/fMiqrgjsHIUVKhhXOd/qWnGwMU/N9dQNgdaZ2TSLFNH3SzLzqRf9fiKt3e9zet3ve7gnWZNNy2fgCOrIS3OMDGjlTrZ2Ww5dwFfs7v+YsnRgVPxa+kG1R9EHb86hAWE2b97LWh/BdBjexE7d9VyNnCdgxoXAKL+hN+ec/x6fqDo4sn8mDhWensysbBA79J++KIzaF3hNasmuk/bGC6edjQLiqAZEXDuP5v958/cfTVVx9RfDvHXqSuciTed3QO9Lf8mGkVjCFrA5kJvbxZwC1bfGwWVa2m2k+ol7fsJXyBH1fByzghmDu0EPw4tcNMuaZdw0avgXRlSrNIie1S0KOuglqH8uPe8VQ2X/aZaX1dfltxrdY5JibVd+/J/UMc00/urd71qvYZdFd0rsrTPUtOCtKuWgW6ee1NtZ6IvVNwxCKxv/Ozmsx3HJpv24U7e36BGB8Dwm3cUtIBt8GFus745m7Oac6LiS7ikXsBJtZwF2fq9TQObsuX8FgDiUw1lClKuUTM7h5p5teVDUlIZQl4HX6us0x6K4T0Z2J47Jnavh5PZXGPZGtvaiPzApZq//Qv+yBNP2S50sxwWNLzRcO6rdZ+hFrcA+U3+AC4aF4tm8UAvV15bdajA91sL9Q7l1/6/EpsWa5z/ydEN6K2m2H1c9u7dS0REBBEREQBMnDiRiIgIXn/dcPGKiYkhOtp0gqlZsyZr1qxhw4YNNG3alNmzZ7NgwQJ69uxpd/s3VWYhd+qtR8Fdz0C/T6F+3h2TnbuqBZfj+Cv6At75wYPGGR63Mw375rfh8Ar4/mHTsh+HAiqsMmvDrFjIfBEaJxieV4vlbbgIuJtd8H1zc3k4OZXx1xJZH52XJ/ror7DTsvr5vbgrtMzI5PEkB0FLl1cAw93CtzGxvH7VcjK31iGtWd1vNS2DWxZcXjBM/vXkJrjfTv6f6u0BqKjX49yoaMPsLez4GN6uBKe3FPutWo2W1iGtixe0AKTEFPjyqtx2hW5idKc6jl88tangN+efYFy9uDszk1nxV6lQWND3RWfD/3YubI6CFgvmM5Dn1ebl17j8G53IN3+fswhaABY9btUEYX/DgP3+Sf6K48n+vJQMvt8dbZr1Ov0azO+E7++GNnwnRc+y3C4Q1pfj+qoOtwNAct7f09V2ji7c/SyevtCzPi5aDf2amW2zqIMzky7CP5/Y1sym2rnpObYGvrwHrpyyfc2RLaYUDxXMZs+uk51tb+2CfdqG/7d33/FNlfsfwD9p2qQtpYuWLjooo8hqoUApyFAqZSOgVkCWAoKgIAiyUbyK4/64qNd5HVwXcB2AVxHFSkG0siyjjF72krasDlqajjy/P07G2UlKOtJ+369XX03POUlOTpOc73me7/N9wOuKVOJlOvnDw75uhkp7Lk5MJ+l3m2/C3W7WOciMouM87q5xmNppKjaP3Iwjl7jvc184HqSViVo/H+3dEk8NEM667S3zuJEa7gLAHHS/P8GObmtR4KLRaGwGLQAQ6m0NBn31XPJ4gDd38ZNXVIYmuup1oAR6BUKv1cPL3Qs+HjLv/3rI4cClf//+3JA70Y+5Gu66deuQkZEhuU9WVhYMBgNOnz6NyZMnO2HXncBNtWMHGPKabOuG5GHAG+kz5O/AimtAdC/1O32QAlzcJ1xmbhHpIr46FH2hXzkExPTmukjmc90V/BaX4CojvBnDtMIihMnlvvSeCyy5giGP7sbHuflorpQf03cB0IqXuOgbIb+dI7xkkuWikqy3x3zEBWVBcfY/5vbl3O8ts+9s3xxReFlx1fKKySiTuYLj+33RvViYGoehhhflNzC3vilx1wFHvgIMyi1lqswnj8py4PKfytsN4U1kx6TvE1utJC0C1JqeTfdVOekHaZQvLtxRhfPXS7Et25Rf9ONSxdbKOP5IFznmQFTuilPUdRvcVI//vTgYK0fwa6bYGbj8g0tSHnarBHGGckwpMAVmJdIkdWwYB1zeD3w3177HvrQf2P+h5c+ht0rQ3mDA4sRn7Lu/nD3WYcWeHtLTRRAK0dXNFFjpbBfdOZlXjLIK+cDl14XWbg1maj0NunEAn+lWIzaIe+zKKuFx9nL3wpyuc+CrbYE127lWFR/ITxCpxmjHqfBf1zpJlk1y3w7A+jkY2CEUX0y1fp9VhJsC9xDefXkt347w9vDGxmEbsW7QOvjquMDlnnZc9+IP2bnoGGGjwIsCDzcP7ErbhZ1pO6G1dU6sJxr17NCWZFhnmfQd0LKP9e9pO4B/KfRRX9oHfJgiXHbzHPdb/Mae8A3wKb8lQvol6Q4u6axco1EORMwiEgGdt+xszQIaDTDoFWviXvxY9e3t4c0LXGL6cK1abe7jTl53DeOu5GN6A81aA9dyuCuvKml3AFqncF19fHIJxzWlUGak27PngfxjSCqIwqfrDynedfmw9gj3565Oj7KWOGaMRnu384rbyzqxlWtFk9N9KrDvA+nyyCTgoikps/I2d6LZMgs4ojJMsoc1P0XQ4mJiUDgJmendVf4nlhYW5ZN+Myi3uJhLAcz8/E9oYMRZzy8Ut91S1Qsjtb8rrkeRKRCVazXwUGg+57cQOVgOy5sxfPUXb0bAEpVu5htnuBYZHxtX5euExcMCjUZs/CsPuGs8gKfk72PLTev7sqmnB8oqhK11I7W8WRHtuNiY+sl+xXV6fmCkFQb+564VA3DDqu+O4fun+kBsU9YlTNf+Fx3dzuG7qp4290PsEpNPfubLZfIjlDpqzmDhMGsrekSA9T3kBtN38T1LuLxAD2/uoqOaxKPz+J+/Axduije3m6uMJjKrl8Oha83tAutt8T9u1l7l+5mS0AQ8vIEo0QcmoqvDiaMAgKZhwr9b3WsdqgxA0gJjMqikFCNuiYKxx7bL76tZ77ncl8TTR6XbAcIvcqUvcEd4BVhvP7gOaD+Ce46UlcLRQUNeA+KGAA99In2MgJbA6H9JlysMv6wRV2QCEy9/ILoXerZSP8F4aK3/v18X3oOCOK5A15VmSdhVJb2qkyXT+mFhGkUk0ZSXd1BhuipVC1okzykNUv44q97FpNOqfcXYrmoaoLmluE4L6/4sc/9ccTsAeM59rvoTXTvJ/ZZrcbkl0xoCQLj/dzhXrVxXkVnRZeDNrkCZchCHSgMXjMrhX0WHdJTfBgAWXeRy7fiM1i6me+Kk72t+V94P54GPeEOR5YjzvPj4yaZMKzy5e4NLKj76l/wxiMrPwBKP9RihzcQo78Oy26iz/V68BfmusDc8/om+ba3HpnlT7j3UBLeh/cvUmqlrAoTFA0Ft5B6i2u5tZ03oPnSxwKmPXZ817sDFkuOiAR76VLguWOXqoeMDwr+j7waWXlHuVnpY+UpQllxznZ5XEKvSzpEB/tFApHTotCDiv+95YFke4KeQA8APchzNA5F9PC9gxD+5LogmKlc5fhHA2PXWJGa+6TuEAZCZphbfzuackPtWAcPfAKb+YlmlU2tlgHX0AwBEBnqj1/jlwNxs/Jb4BtZUSivx2uOCMRh7Wz0FzMzkWp5MeUMCBl4Q8GZX4Ogm9QcNvkv4d1iCZBONjS98N1sJtwDXWnFxH/DvEWivOSdY5aOSr6DhBS6PuUtzyjqUfYi/PxgPAHh3Qjfke6m0MJpH0dzK54LiFrzcnKsn5O9zBy0uFiPf5n7LdRXxGYrkW/kA4OJe4CWFbtw5h01F4L7hLgJm/gbc94L8tp6+QMcxomX+lpvLh7XHHFHeh5+5yF/keMz8/E+s+u4YVm4RJonuyMlH/9d2YO9Z9Qn8PHmBi1HU4tIEKt95B9djUPY8y58tvZzckm5Szkumv6qxfneJR7B56bTIXHwvjno+Zl1oRzdadQzsID8fimWodANFgQvA5XK0SQEmmopatRmofB9AGqCMfl99+3ZD1dfbg99kX2FHH+6ETcD0DPl1oqsZ2eGxZvwWl2qM2pHVdYLw9djiz6t7M/UXLmiR2+fa7J+9bWqW9QoEEicBLaytReLuET8v4fvldrlMa4l/JIy6JjjIWuOZCOlIN7mggW9h5eM4FvsoEGJqSh7GG0qZbjpR8ZPRywqBLyerPiamirriOozigs6ZmZZF0/sK54F6pKdCjSI5/K6iD1OAszuxVb9EsElTmVosZuauonBIhz4XMm+88FBPPJDIBeRJsc3Q/Kl0YNyXwEKVVoGKUm7U39SfLYnv6KQQTAoCZTsCl0pRl2fXidYh0OKuohvCofMAgHd6AfzCfWYbHxG0jGDCJu7CYMjfgQDTtBetBwDtR3K3eaUMMHaj8LHEn/HrJy1dsk09PfD0fcKBA4+4c0nkgYXWWkj/zhR2e075eB/OXS/FQ+9lQsldYb7w0LqhZ2wg2oU2hZdW2LpnToKVdWyL4M8wY57ChvKWV0yWLEuI8pcse3m0tTX0dpX1+0enEQ1VunEWYR+KBizUUFdMU08PPJgovejUALiD2XzqPQpcAGuWd2w/YMUNrriX6v14zZUtegi/CJQ88HH19tGMnxvSxEZft1cA173Evw+fsVJ+uRx+07k44KktU7YBoz/g/jctVLL2a7OryBK4SFt+xN0j3jrhflUqDAfVmk7k+doQYA6vKyq4HdBbPUfhhDFSmCjrxrvi+tWUYGtrFJ3eF1iaB/hFAVG9pCNsNBou6Ayx9rOH+Qu7VkZ1cSSBWylgth4ftURLLYx4TPs9fvcUVXaueABp5SsEzegAuP9V24Hc50KSAG/Se4719szfuJP/4Fdt7789JwlTXSQAXOvloJetn2VxV1GesCiiRb7McnEXUuw93IWB0sVBQEvr7Vb3AGmfC1oMJT4bI7s4voU1GfSizka+nIoHEltYRuOsn9YTW5/qA8353wTb+GrkW95e2nocB6+KClSWqHdXiX1aZa1unD6/H9Y8FI/hncMk241JbIH/mvJnfjCKWrJLea1JWxcARaJkcF3N5ZD4eEpbV4oNlbj7FeEoy492n8VT67NQWaWel+YKGnfgEtyWSxAN5H2Q3bTqLRAAl7tiZh4mbUvH0UDnh21vJ5fTYTZxC9CyLzDqXeFycZN+yvPCv0e9D7Tl7acjScn8hFdntbg4yi8C6PygtEWl5yzh32612DxqCVz8JavEw3r5ffeAdEinmflQM8a4BO3hrwNNmgOj3gM6jObyrhS6HW9DjxJ+S474PVxVCRTnQpWhiMtjevIAMNm+OkviIM3TQ4vIQAerb4qOhzusr0PphAVwLS7LPYS5LTPK5+KNqtE4waIkLV0CXSfJL+cH+96B3Mlf6QJAcIztCFzyeXlkT2dz3QfmFpdbudbaQJUGoFwht6dUprtFnNtiz/fXoJe57wV3PZcUz78gUMp3M/H39oAGRoxpZUSBjuuqeOVyZ8l2V4sN+F+e7VFvf38wHpGmOigajYbrXhR9pz3j/iWCIUw+XfXfY3h/1xkcuiqf71XI7A0WuOPl6+mOVsE+GN21hezQfA+tG16sGI+nymfjlcqx2FzFGzn62WiuoCkAnJLLK6yZriKAO85yLhfcFhz/Vd8dw7eH/sJPxxxrkaqPGnZHmC19F3A/jmoSBDz6IzdCI2mm/fcb/R5weIP6NrH91dfJrX90G9fUfOJ7rllX3LQdn8b9vNGVK+8tl/dij5AOtrepTUmPA3/w6sLYWUfCKczBn9523k+56ApHPKTTzM30ZWkpspU4mTvBmr9Eg+OAor9k72uAhzA5j980HZXMVflVKTIo4MCoBw9R4OLlocXOZ+7BT8dy0amFv/qd+V1F/tFAAdfF0EJzFcXMGwZ4INg8HLrXU8DvbwjuHqqRnsS3ma6EF6TGqc9bxc8Z44uwoyaR9QVYb9rT4sIvp24OeL15eV7v97e2qCjVcrJVb0ft+4Ovp8r3ll8LYPpO4P1+squ/e/JulG5ZgLZ7rF2a51lzyXbdX/xZskxs9WiFZPT73xaMyGzvdh7/5/EuJlYsBmMMuUVl+Og3rmWFX72Wb3L5s9ikF047sMfYDkluwpyl/3swHgFNPCxJtWpy0QzfGrmAZXnFo7jfPFLtryxumpQ+8+TvKFcfyEnUEuB/OprLTTvAc7NUZpSmi2ncgcudiOopHUXkDNWJzL38uZ+753I/Sp74g7s6ExVAsmnGbu5qvfldtretTeLkXg9PrlhXkEphN2epMLUEKPRdv/pAZyz8ihvdcMsg7Jobr5AHYu7qEVQHFZ98FYMzDTrxmu7RNBS4awRw/FtuNJB5Pi4nE9dx8dJp4eamwaCO0qZ2KV4dF94Ivwz9fABAioHromEe3tAMfIE72Wa8zJUSyD+Gie7CK9vZ5dbJCcXdcxLBcdxQ/FPpXDBv5h+pfB/J7jvY4rLHNGIninelzg8S+d1A10yVXmP7A2cyrMsrlFugAFiTfe+UuHW16Argy/1PWwR4A+esQcttpsNNCANBe/Ircv42yDI5pYRM4n5f7RGggutqLedV8TVXv+UzarSYNWEs4NYW2GAt46DR+0Ic54yRyRGxRzFEn/3054HwBOmGoZ1r9KJK/P3C5yVTlE7pwsmVNO6uoroWI61HAG0NxpLuOseDFgAI7cTVWqlvxJn6Z3cB/0yUb053NnOCtMIX0kPdrCfAwCbWk9OR5waiVbD81Ze5xUX1Oz+iGzesUsajvVsKFySM435f3GOthdPMucMxxcTdYqrMJ/7bNwGDNP9mopYLTDTmA+IbDox4g2tBkvEXa2a5bTNw0Wi4IfcDeNNVtHI0uKvmqCJbU3rwRSZx3YRmRlG3iPh5xaUUqkucz7amnfx2AIrEJ3AALRdvldlSSDFokXt+ABWM276yiqHCdPL1RQlGaKVJv24e3khpHyJ5nB7toq1/hHcB0mQS4VWsTUtQ3+Crx4R/LzgNzPhVflsnGd8zWnGdzlR6obTcGtyUlDuQ41hPUeBSl2TqYhAHBbSULss9Il3mTMYqayBgx2yqE3pG49lB7bBuSnc09VTOu7B0FamdBLXuwOO7kD8vF23KPsGnlSmYWj4fr47pLBhOCkB+CGZIh+rVFlLRM9aaA+JdnbLjl+SLkllaVMQ5HAqjx/hl2+WuNGXxW010DjbnO9LiIgg4RK1o/OBJLKgtN+Te8jiik465oCDAVWd1VhFGtRF6VcJ9KGKOtxIPbC8/jNf6/NLPiYeGO4Z7z17Hff/YCQBI0ypM82HuFhUfL37gPj0DuGu4PbtrMbiTcA4mQ9epwg1u8y6awrsA3s1Q0/q1DcbP8/piRHw4ercWPp+h0ojb5VXo/jdrt92r23JqfJ9qGgUutY3/gRRfPXWRmemWqJueAaSuFi5zVkXk8lLpFe3BL4BVvGRNlSbg1x9OQFq3SDzSMxoz+7dC/zhpHgCfbFeRgksFZaiAO5ZXPgpDq1Q81F2mi0Ou21HphNQkmKuSXA0TesZYbtuqYSNgrnyc4+CEqzL1ej6pvA/HeDNye9vb8sN/LP6IIvvubL1pq8WFH0yLyym0Uzl5enhz3VfmObzEFzsf8eZ8m6YyMshR4veORmvtzjN3eZkUKxRmUzPrHhvduQrv0ye136DjF13RAlyCqRsvYLyi4X2++i3ifosLNd41jMtrHPp/Du8zIM0n0Q9TKPYIAFPTbSdKO0nr5k3xxtgu+OyxJMFyQ6URPx/PEybuNwAUuNQ2ft8x/0vo8V+r/WFq1Lz8pUXq1Mqn2yvvKPBSGPD9fOHyzaKkRpXZVEcmROCVBzpLEliVmNNFDl4swNsZ6hPrFd22dtSPiA+X30iu0rF5ZNHQNcLlz5wEes6Qbm+HIZ1CsXlWb2Q/7+DEqfYWUhSTGfa+tlI4ZNdmV5FZm4FcLlD/xUALRxJzITwpnfxJfpvCy1zhP36iq7meillT4VW8gLllzzxiTq2UwR2UkpfwCQbGfMjVmgG4AOCVaG5akl+F31PVaXHxsvX/8fIHWku7p+d7fIVmmmLMd/8SgHCG9ZtBvP9ff1Pg0rKv8AH0vsC9y7hpMapBkvCt1sJVB/P+iPevvNKIJ9dnCZa1C3VCIdE6RoFLbeP3QfNbBsI6191wY1cnrmtja9ivPd4xJVDu/1C9/okT50fiV5m11ZxbxKu+O6arQnKhVub9ZB6V0l3UF38HV4YajQYJkf6OV+tUCfpUycxdJc6zsHlitOyDHkj71HqicwjvmP32hnT1jTPcpIqrRbVtUl8S/u2pMMIJsP5fzMHaj0uATCcl4NrS6QFpkPXHu5ICnXI5LrZEBdpxn0e+UlzlbqqazB8633rkQu5G9N3W46ZvCszmdUU6YXSPuciiXOG3+kY8ohHgqupeu2Vw6QJ1FLjUtgc/BnxCuRod5uZfh4ZgEgm9DxA/zvp3xkvK21bHO7253+U2RnTcIa3M1ZISc4tLaocQ5bL6clNQOKM1ylnUKtiq+d+Pgj+3Dc1EpWiApN2By53g/78KLkjXn5Sp5wHInzwf3yXt8gSs9Zf4NYp+XGz/Pt4pcW2kPe9IlhXZXS+F8+vCe6T5WEoU61oxeMKAZaY6PpV+0dC16ALMOwFM3Czc1IfXheRoHpOMv93fCedeHorXHpRPkgfAFSatI/ygUO47ZP/5m+j2t5/xigvnulDgUttCOwHP5HA1Ono/xWW1q1xZEDuNeoer+GpmvIPEZ3FZ9cKLXALptZr9oLuJApeC28r1FgpNgYuvSrKvbKVjH163ROIU7re4kF9tqW410QDeKIoe0xESIh1J4+1RG5UeeP8vg8zkf1mfSpcpXaSExQPJTwiXzTlsbYWVa9kr5FVnHbZWdU+rrblM7SZRF99lZm3xbMILGJW6JCLtaW0xaz8SmLVPdtVM928tt929TRWsfcOkAbunHzB5K/DYz8rzyd0Jc5cWfyj6JIWZ22vBj3P7YmQC132sdvHz7s7TiuvqO6rjUpfc9Q5ntRMV/KHkZQXKFU9tkZtUr/AScG63cJnSXFDVJD43lRiqAIXuaHNFzDA/le4WceDSsq+wqvLgV7l5efgTCtZHI98S/h3/MHDuVy43ZfCr6KLR4IWRHbB8i7Xia1OZMuhOpzSq6Oyv3KzbcqPbuj2q/phzj3ATPQbGCt+/4qTcvf8STgQrU8HZKXyCuRmj+bldx4UnZXPxuXvbNceNknIcNBVC3PpUHxQbKhH/vEL+j70CpMN9NWCCxFyMek/9MWJ639k+qHn4c+DGWaB5OyC6F/e9LpdfVku8dFpL0TlDpXpS7n8P/YX+ccGqox3rI2pxIQ1HBe9K0FYtl/JSYN+HwqtWADi0AXhXZmZlY6W1m8U/Clh+jRvu6ETiEQslMoWlyiqqMOXjvdhykKugGxGgMqKDf3V53yruKpA/XYW7jvuirYmrUGcSzyuUMJ6by+mhTyzBw4TkGMQ0s17J+3vXwmsS5wWZc6G+nAz8qdDFoTRho5l/FJckLA66jwonEsTWZ4CveXMR2TEsv9o6pwkHDohyjCoikvBQtxb4aHJ3wXvYzU0DPy8PfPJoD/UA2xaZqTw0AGI1pirSPqFc0FBX3PXW5w9sydUbqmPm/8N/9l9S3e7J9Vno+6rCkPJ6jAIX0nAMfMF6+5aN+TheCgO+nwf8owOQ/Q23zGgENj0uv31VhbV/PHFyjZzsxf3+twyVOJV/CwW8Et0PvPs7duRY81RUi3jxk73bODjipz7TaLi5nESBw6YnuKvqsT2i1Mv915T37wH2fQCUSmertqj2yB+ZRMpbvCT0WPny/E7hppUfsj15K7AsH/+aNQyvPsDle6y6vwOCfHRYNdLaxdS3bTCSY++gnonM8HcNGIZq93J/3HJCMn4D48jb/2ap/JQJ9Rl1FZGGo9MDwO5/AHnZ3Nw8/ObhkmvckNX290tn2P1qCjfXiJ/KKIGrx4GDpiqbupoZTigewnvkUiFe3HocPnp3y1Dj7MvCXArVuinueq5ryFhZt1ekjgrtDBRf4Vq45HIsFAQ00eHcy0NrcMdkhCVYK+HeOC0dPi/YViWZ05bk2cDOl5XX1/Q8XXKBekC0ZCRku1Bf7FuaIgkc72j8ikbDBS+87jK3O3vEBi+mWc1N6lgfUOBCGpZW93CBy3VR4tkXacDl/VySrVw1y6zP1HNifnvdeluuIq0TtAwSPu63h7im8FuGSlQZmWReIADQ2yr4pjZ3VX3QfzGQYRpNs/gycOEPbg6w4ivAjheBPs/U7f7ZMm0H8O/hwPndytvo/YBHvhbmpDiq50zlwGXYP6r/uPbyCpAu85GvPyPX2vV0Slv8evIqJiXHVO/53dwFXVQhGt5M0SPerN5jNmDdYmT+Xw0IdRWRhsU8F5NBNBPyZVMth/0fCsukm3UcI53HKbQzN1eMWA3N9Cr+wj9y2Vo/5usDlwTzjZg5VKm2Pur3LDA/B1hZwB3XNinc76A2wIPrgNCOdb2H6tzc1IMWAJi5G4jsrl6vxRYvf651R07XydV/XHtpNFyrD58D86pFNfPGvqUpeHJANefKEuXV+IA3DYS5SB6xkKup9NUM+Tm+XJGLf+sRImLOQ8n6lJt0kTFpOfazO6X3y8sGLh8QLou5G0h5TrqtvuYqT34xTSZQArAjJx+/nbouWV6tuYHqE42GqxxbFzkpzhLeVX29v/xs4A6bojBxoROLIKpytLKwiDPzjlq7mRJzfet/Ebi64C5TrbuZT8MpcEqBC2lY+N0421cA7/bhuomUJJmGeV6QzjALTz8gROaKP7jm8kV6tQqSXe7loRUk6Zo5XK2WON/wtbXzPLom1iqw7YZxNU5qo5vIrP39tfdc9qpuLaBGYG6KtXVLowGMvAu4IaLJIu2ZH60+oW890rB48L7I/jLN0ZGnMFv0I18D188oP5ZfpHzrSg0Pdwzw9pBk+u8+dQ16mWqjtVKvhKgL7ay8zslD5hHUhutWY6z2WlrMNBquXsqmx4F7l9fucytpKi0+SDgz+7fC2p9PAgASIv0RFeiNNs19EBHghYRIf2w9Yh2NtXHfRYxLclLLYC2gFhfSsDhS0lvnI81rEWDcl/UTvJwY8eSENaBf22DJsvxiA9bv5crKP9w9Em+M7YKVw9sj3L+GR5MQ2zQaoPs06XKfUGCQykigO3m+2g5azOIfBp45BfRRGT1VExInyy+PSKzV3XAl/FIJgd46eGjd8NPTfbFuSg9MFCVJ/35aZQh/PUSBC2lYHBnxo2vCFYxSYh5+2bwdV9F0zIfKX6BOtGK4+hBgH707RsSHY0pvlX0ntWvIa0Acbyj2+K+4qT2ietbdPtUUn+Daz0nq8wyXKyTuroquwYq4DcDrDyegY4QvnhvBfaeY84w8PbQYzptVvrLKtbqKKHAhDYtaICKhUZ+ROzDWets/iqsTUwtT1QfYqPrqQ91D9Y9GIxzu3Kx13e1LQ+QfyV08PPRvoPcc6/Io+WR2whmZEIHvnuwjOz/U6tGdLLdLZEYs1mf0DUgaFr8W3Nw7l+QnZrPQ+3H5AjfPCZffNQJInsXNVxQjU/q/FtgafXFH5dNJ7dDfwdBnos43wnq7Bkf4NXT8CTHNs827CmpxIQ3P/e+or+89F1h4mmtt4be4tLoXePDfXPN+LXQJVVdUYMOuiumyKkqtt+mEWnO6TAD6LQIe31XXe+LS+BdIhy4VovNzP+K3U66R60KBC2l4bOW5uOutJcz5k9OFdKi7pEeRrOX3caMC0hIk63y9qKG0Xiovsd6u9pxExCadN3DP4jubQoEAEA4EKCqrxE2Zkgv1Uf34libEmcSBS0Qi8NRBIMTUp9txjHVdE94Inog7K7DlTAFNdHh2UDvEhQqv3H093WX7q0k9wG9xIcQFdIwQdmk2cZG6UK6xl4Q4wkMUuMT04ZJ2p6UDpTcAX17tBzc34LGfgQu/c0W96hkPrbU598HEFlg2tD18PZ0/MzVxgnIKXIhr0WmFgw1cpaCla+wlIY4Qz6FSZprzx10vDFrMIrtzP/Xc7Yoq+NkYcUTqUEWJ7W0IqUfctcKBAK5yUURdRaRheugT6+1S6Rw/rqKswmi5HdSA5hppkKjFhbgYJprHLSbINbqhKXAhDVP7kUDHB7jb4lltXchdYdY+6Bn9WtXhnhCbwlRK/xNSD03oGWO5/Xi/WEG13fpMw8QhVz1UVFQEPz8/FBYWwteX6iMQOxmrgJKr3OzDLo4x5tTZdUkNKCsEfnuDK1TY/K663htC7DL7iz+x40Q+0uf3R2gN1IiqifM3BS6EEEJII8UYg6HSCE+ZSVydoSbO39RVRAghhDRSGo2mxoKWmkKBCyGEEEJcBgUuhBBCCHEZFLgQQgghxGVQ4EIIIYQQl1GtwOWtt95CTEwMPD09kZSUhL179ypuW1FRgVWrVqFVq1bw9PREfHw8tm3bVu0dJoQQQkjj5XDgsnHjRsybNw8rV67En3/+ifj4eKSmpiI/P192+2XLluG9997Dm2++iWPHjmHGjBkYNWoUsrKy7njnCSGEENK4OFzHJSkpCd27d8c///lPAIDRaERkZCSefPJJLFq0SLJ9eHg4li5dilmzZlmWjRkzBl5eXvjss89kn8NgMMBgMFj+LioqQmRkJNVxIYQQQlxInddxKS8vx4EDB5CSkmJ9ADc3pKSkIDMzU/Y+BoMBnp7CanxeXl7YvXu34vOsXr0afn5+lp/IyEhHdpMQQgghDZRDgcu1a9dQVVWFkJAQwfKQkBDk5ubK3ic1NRVr1qzByZMnYTQasX37dnzzzTe4cuWK4vMsXrwYhYWFlp+LFy86spuEEEIIaaBqfFTR66+/jjZt2qBdu3bQ6XSYPXs2pkyZAjc35afW6/Xw9fUV/BBCCCGEOBS4BAUFQavVIi8vT7A8Ly8PoaHyE9kFBwdj8+bNKCkpwfnz53HixAn4+PggNja2+ntNCCGEkEbJocBFp9MhMTER6enplmVGoxHp6elITk5Wva+npyciIiJQWVmJr7/+GiNHjqzeHhNCCCGk0XJ39A7z5s3DpEmT0K1bN/To0QNr165FSUkJpkyZAgCYOHEiIiIisHr1agDAnj17cPnyZSQkJODy5ct47rnnYDQasXDhQue+EkIIIYQ0eA4HLmlpabh69SpWrFiB3NxcJCQkYNu2bZaE3QsXLgjyV8rKyrBs2TKcOXMGPj4+GDJkCD799FP4+/s77UUQQgghpHFwuI5LXaiJceCEEEIIqVl1XseFEEIIIaQuUeBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlUOBCCCGEEJdBgQshhBBCXAYFLoQQQghxGRS4EEIIIcRlVCtweeuttxATEwNPT08kJSVh7969qtuvXbsWcXFx8PLyQmRkJJ5++mmUlZVVa4cJIYQQ0ng5HLhs3LgR8+bNw8qVK/Hnn38iPj4eqampyM/Pl93+iy++wKJFi7By5UocP34cH374ITZu3IglS5bc8c4TQgghpHFxOHBZs2YNpk2bhilTpqB9+/Z499134e3tjY8++kh2+99//x29e/fGuHHjEBMTg4EDB2Ls2LE2W2kIIYQQQsTcHdm4vLwcBw4cwOLFiy3L3NzckJKSgszMTNn79OrVC5999hn27t2LHj164MyZM9i6dSsmTJig+DwGgwEGg8Hyd2FhIQCgqKjIkd0lhBBCSB0yn7cZY057TIcCl2vXrqGqqgohISGC5SEhIThx4oTsfcaNG4dr167h7rvvBmMMlZWVmDFjhmpX0erVq/H8889LlkdGRjqyu4QQQgipB4qLi+Hn5+eUx3IocKmOjIwMvPTSS3j77beRlJSEU6dOYc6cOXjhhRewfPly2fssXrwY8+bNs/xtNBpx48YNNGvWDBqNxmn7VlRUhMjISFy8eBG+vr5Oe9yGjo5b9dBxqx46bo6jY1Y9dNyqR+24McZQXFyM8PBwpz2fQ4FLUFAQtFot8vLyBMvz8vIQGhoqe5/ly5djwoQJmDp1KgCgU6dOKCkpwfTp07F06VK4uUnTbPR6PfR6vWCZv7+/I7vqEF9fX3qTVgMdt+qh41Y9dNwcR8eseui4VY/ScXNWS4uZQ8m5Op0OiYmJSE9PtywzGo1IT09HcnKy7H1KS0slwYlWqwXg3D4vQgghhDR8DncVzZs3D5MmTUK3bt3Qo0cPrF27FiUlJZgyZQoAYOLEiYiIiMDq1asBAMOHD8eaNWvQpUsXS1fR8uXLMXz4cEsAQwghhBBiD4cDl7S0NFy9ehUrVqxAbm4uEhISsG3bNkvC7oULFwQtLMuWLYNGo8GyZctw+fJlBAcHY/jw4XjxxRed9yqqSa/XY+XKlZJuKaKOjlv10HGrHjpujqNjVj103Kqnto+bhlF/DSGEEEJcBM1VRAghhBCXQYELIYQQQlwGBS6EEEIIcRkUuBBCCCHEZVDgQgghhBCX0agDl7feegsxMTHw9PREUlJSo56x+rnnnoNGoxH8tGvXzrK+rKwMs2bNQrNmzeDj44MxY8ZIKihfuHABQ4cOhbe3N5o3b44FCxagsrKytl9Kjdq1axeGDx+O8PBwaDQabN68WbCeMYYVK1YgLCwMXl5eSElJwcmTJwXb3LhxA+PHj4evry/8/f3x2GOP4datW4JtDh8+jD59+sDT0xORkZF49dVXa/ql1Shbx23y5MmS99+gQYME2zS247Z69Wp0794dTZs2RfPmzXH//fcjJydHsI2zPpcZGRno2rUr9Ho9WrdujXXr1tX0y6sx9hy3/v37S95vM2bMEGzT2I7bO++8g86dO1uq3yYnJ+OHH36wrK9X7zXWSG3YsIHpdDr20UcfsaNHj7Jp06Yxf39/lpeXV9e7VidWrlzJOnTowK5cuWL5uXr1qmX9jBkzWGRkJEtPT2f79+9nPXv2ZL169bKsr6ysZB07dmQpKSksKyuLbd26lQUFBbHFixfXxcupMVu3bmVLly5l33zzDQPANm3aJFj/8ssvMz8/P7Z582Z26NAhNmLECNayZUt2+/ZtyzaDBg1i8fHx7I8//mC//vora926NRs7dqxlfWFhIQsJCWHjx49n2dnZbP369czLy4u99957tfUync7WcZs0aRIbNGiQ4P1348YNwTaN7bilpqayjz/+mGVnZ7ODBw+yIUOGsKioKHbr1i3LNs74XJ45c4Z5e3uzefPmsWPHjrE333yTabVatm3btlp9vc5iz3Hr168fmzZtmuD9VlhYaFnfGI/bt99+y77//nv2v//9j+Xk5LAlS5YwDw8Plp2dzRirX++1Rhu49OjRg82aNcvyd1VVFQsPD2erV6+uw72qOytXrmTx8fGy6woKCpiHhwf78ssvLcuOHz/OALDMzEzGGHdicnNzY7m5uZZt3nnnHebr68sMBkON7ntdEZ+AjUYjCw0NZa+99pplWUFBAdPr9Wz9+vWMMcaOHTvGALB9+/ZZtvnhhx+YRqNhly9fZowx9vbbb7OAgADBcXv22WdZXFxcDb+i2qEUuIwcOVLxPnTcGMvPz2cA2M6dOxljzvtcLly4kHXo0EHwXGlpaSw1NbWmX1KtEB83xrjAZc6cOYr3oePGCQgIYB988EG9e681yq6i8vJyHDhwACkpKZZlbm5uSElJQWZmZh3uWd06efIkwsPDERsbi/Hjx+PChQsAgAMHDqCiokJwvNq1a4eoqCjL8crMzESnTp0sFZQBIDU1FUVFRTh69GjtvpA6cvbsWeTm5gqOk5+fH5KSkgTHyd/fH926dbNsk5KSAjc3N+zZs8eyTd++faHT6SzbpKamIicnBzdv3qylV1P7MjIy0Lx5c8TFxWHmzJm4fv26ZR0dN6CwsBAAEBgYCMB5n8vMzEzBY5i3aSjfheLjZvb5558jKCgIHTt2xOLFi1FaWmpZ19iPW1VVFTZs2ICSkhIkJyfXu/eawyX/G4Jr166hqqpKcIABICQkBCdOnKijvapbSUlJWLduHeLi4nDlyhU8//zz6NOnD7Kzs5GbmwudTieZoTskJAS5ubkAgNzcXNnjaV7XGJhfp9xx4B+n5s2bC9a7u7sjMDBQsE3Lli0lj2FeFxAQUCP7X5cGDRqE0aNHo2XLljh9+jSWLFmCwYMHIzMzE1qtttEfN6PRiLlz56J3797o2LEjADjtc6m0TVFREW7fvg0vL6+aeEm1Qu64AcC4ceMQHR2N8PBwHD58GM8++yxycnLwzTffAGi8x+3IkSNITk5GWVkZfHx8sGnTJrRv3x4HDx6sV++1Rhm4EKnBgwdbbnfu3BlJSUmIjo7Gf/7zH5f8ABLX8vDDD1tud+rUCZ07d0arVq2QkZGBAQMG1OGe1Q+zZs1CdnY2du/eXde74lKUjtv06dMttzt16oSwsDAMGDAAp0+fRqtWrWp7N+uNuLg4HDx4EIWFhfjqq68wadIk7Ny5s653S6JRdhUFBQVBq9VKMqLz8vIQGhpaR3tVv/j7+6Nt27Y4deoUQkNDUV5ejoKCAsE2/OMVGhoqezzN6xoD8+tUe1+FhoYiPz9fsL6yshI3btygY8kTGxuLoKAgnDp1CkDjPm6zZ8/Gd999hx07dqBFixaW5c76XCpt4+vr69IXLUrHTU5SUhIACN5vjfG46XQ6tG7dGomJiVi9ejXi4+Px+uuv17v3WqMMXHQ6HRITE5Genm5ZZjQakZ6ejuTk5Drcs/rj1q1bOH36NMLCwpCYmAgPDw/B8crJycGFCxcsxys5ORlHjhwRnFy2b98OX19ftG/fvtb3vy60bNkSoaGhguNUVFSEPXv2CI5TQUEBDhw4YNnml19+gdFotHx5JicnY9euXaioqLBss337dsTFxbl0d4cjLl26hOvXryMsLAxA4zxujDHMnj0bmzZtwi+//CLpBnPW5zI5OVnwGOZtXPW70NZxk3Pw4EEAELzfGttxk2M0GmEwGOrfe616ucaub8OGDUyv17N169axY8eOsenTpzN/f39BRnRjMn/+fJaRkcHOnj3LfvvtN5aSksKCgoJYfn4+Y4wbChcVFcV++eUXtn//fpacnMySk5Mt9zcPhRs4cCA7ePAg27ZtGwsODm5ww6GLi4tZVlYWy8rKYgDYmjVrWFZWFjt//jxjjBsO7e/vz7Zs2cIOHz7MRo4cKTscukuXLmzPnj1s9+7drE2bNoJhvQUFBSwkJIRNmDCBZWdnsw0bNjBvb2+XHdbLmPpxKy4uZs888wzLzMxkZ8+eZT///DPr2rUra9OmDSsrK7M8RmM7bjNnzmR+fn4sIyNDMGy3tLTUso0zPpfmIaoLFixgx48fZ2+99ZZLD+u1ddxOnTrFVq1axfbv38/Onj3LtmzZwmJjY1nfvn0tj9EYj9uiRYvYzp072dmzZ9nhw4fZokWLmEajYT/99BNjrH691xpt4MIYY2+++SaLiopiOp2O9ejRg/3xxx91vUt1Ji0tjYWFhTGdTsciIiJYWloaO3XqlGX97du32RNPPMECAgKYt7c3GzVqFLty5YrgMc6dO8cGDx7MvLy8WFBQEJs/fz6rqKio7ZdSo3bs2MEASH4mTZrEGOOGRC9fvpyFhIQwvV7PBgwYwHJycgSPcf36dTZ27Fjm4+PDfH192ZQpU1hxcbFgm0OHDrG7776b6fV6FhERwV5++eXaeok1Qu24lZaWsoEDB7Lg4GDm4eHBoqOj2bRp0yQXEY3tuMkdLwDs448/tmzjrM/ljh07WEJCAtPpdCw2NlbwHK7G1nG7cOEC69u3LwsMDGR6vZ61bt2aLViwQFDHhbHGd9weffRRFh0dzXQ6HQsODmYDBgywBC2M1a/3moYxxhxroyGEEEIIqRuNMseFEEIIIa6JAhdCCCGEuAwKXAghhBDiMihwIYQQQojLoMCFEEIIIS6DAhdCCCGEuAwKXAghhBDiMihwIYQQQojLoMCFEEIIIS6DAhdCCCGEuAwKXAghhBDiMv4fuvnS92Y0b7sAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -711,12 +484,12 @@ "plt.plot(Agg_C_Harmenberg_reshuffle[100:], label = 'Harmenberg + reshuffle')\n", "plt.legend()\n", "plt.title('Aggregate Consumption')\n", - "plt.ylim(.8,1.5)" + "plt.ylim(.8,1.3)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 18, "id": "74b9e365", "metadata": {}, "outputs": [ @@ -724,34 +497,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "variance no reshuffle 0.0017096714891795739\n", - "variance with reshuffle 0.0008049080312952917\n", - "variance with Harmenberg 2.6170617445114956e-05\n", - "variance with Harmenberg + reshuffle 2.9387754075726773e-06\n", - "ratio of no reshuffle to reshuffle 2.124058181440057\n", - "ratio of no reshuffle to Harmenberg 65.32790037396323\n", - "ratio of no reshuffle to Harmenberg + reshuffle 581.7632353850753\n" + "ratio of no reshuffle to reshuffle 6.586591338560701\n", + "ratio of no reshuffle to Harmenberg 34.59977718880339\n", + "ratio of no reshuffle to Harmenberg + reshuffle 342.8666899720768\n" ] } ], "source": [ - "print('variance no reshuffle', np.var(Agg_C_no_reshuffle[100:]))\n", - "print('variance with reshuffle' , np.var(Agg_C[100:]))\n", - "print('variance with Harmenberg' , np.var(Agg_C_Harmenberg[100:]))\n", - "print('variance with Harmenberg + reshuffle' , np.var(Agg_C_Harmenberg_reshuffle[100:]))\n", "\n", "print('ratio of no reshuffle to reshuffle', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C[100:]) )\n", "print('ratio of no reshuffle to Harmenberg', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C_Harmenberg[100:]) )\n", "print('ratio of no reshuffle to Harmenberg + reshuffle', np.var(Agg_C_no_reshuffle[100:]) /np.var(Agg_C_Harmenberg_reshuffle[100:]) )\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "37027297", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 2fd2b735f64b3284c85f6b92665dfa1aa74519e2 Mon Sep 17 00:00:00 2001 From: William Du Date: Mon, 5 Jun 2023 01:51:36 -0500 Subject: [PATCH 12/12] update distribution.py file to accomodate reshuffling --- HARK/distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/HARK/distribution.py b/HARK/distribution.py index f8270be8e..57b87bcae 100644 --- a/HARK/distribution.py +++ b/HARK/distribution.py @@ -815,7 +815,7 @@ def dim(self) -> int: return self.atoms.shape[:-1] def draw_events(self, N: int, - exact_match: bool = False): + exact_match: bool = False) -> np.ndarray: """ Draws N 'events' from the distribution PMF. These events are indices into atoms.