diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py
index 958220fdf..d09d33db5 100644
--- a/HARK/ConsumptionSaving/ConsMarkovModel.py
+++ b/HARK/ConsumptionSaving/ConsMarkovModel.py
@@ -22,6 +22,19 @@
     MargValueFuncCRRA,
     ValueFuncCRRA,
 )
+
+
+import scipy.sparse as sp
+from HARK.utilities import(
+    
+    jump_to_grid_1D,
+    jump_to_grid_2D,
+    gen_tran_matrix_1D,
+    gen_tran_matrix_2D,
+    )
+
+from copy import deepcopy
+
 from HARK.rewards import (
     CRRAutility,
     CRRAutility_inv,
@@ -866,10 +879,22 @@ def check_markov_inputs(self):
         StateCount = self.MrkvArray[0].shape[0]
 
         # Check that arrays are the right shape
-        if not isinstance(self.Rfree, np.ndarray) or self.Rfree.shape != (StateCount,):
-            raise ValueError(
-                "Rfree not the right shape, it should an array of Rfree of all the states."
-            )
+        if isinstance(self.Rfree,list):
+        
+            for rfree_t in self.Rfree:
+                
+                # Check that arrays are the right shape
+                if not isinstance(rfree_t, np.ndarray) or rfree_t.shape != (StateCount,):
+                    raise ValueError(
+                        "Rfree not the right shape, it should an array of Rfree of all the states."
+                    )
+        else:
+            
+            # Check that arrays are the right shape
+            if not isinstance(self.Rfree, np.ndarray) or self.Rfree.shape != (StateCount,):
+                raise ValueError(
+                    "Rfree not the right shape, it should an array of Rfree of all the states."
+                )
 
         # Check that arrays in lists are the right shape
         for MrkvArray_t in self.MrkvArray:
@@ -1209,6 +1234,290 @@ def calc_bounding_values(self):
         """
         raise NotImplementedError()
 
+
+
+    def calc_transition_matrix(self, shk_dstn = None):
+            '''
+            Calculates how the distribution of agents across market resources 
+            transitions from one period to the next. If finite horizon problem, then calculates
+            a list of transition matrices, consumption and asset policy grids for each period of the problem. 
+            The transition matrix/matrices and consumption and asset policy grid(s) are stored as attributes of self.
+            
+            
+            Parameters
+            ----------
+                shk_dstn: list 
+                    list of income shock distributions
+
+            Returns
+            -------
+            None
+            
+            ''' 
+            
+            self.state_num = len(self.MrkvArray[0])
+
+            if self.cycles == 0: 
+            
+                markov_array = self.MrkvArray
+                
+                eigen, ss_dstn = sp.linalg.eigs(markov_array[0].T , k=1, which='LM')
+                
+                
+                ss_dstn = ss_dstn[:,0] / np.sum(ss_dstn[:,0]) # Steady state distribution of employed/unemployed 
+
+                states = len(ss_dstn)
+
+                
+               
+                if shk_dstn == None:
+                    shk_dstn = self.IncShkDstn[0]
+                
+                dist_mGrid = self.dist_mGrid #Grid of market resources
+                dist_pGrid = self.dist_pGrid #Grid of permanent incomes
+                
+                self.cPol_Grid = []
+                self.aPol_Grid  = []
+                
+                bNext = []
+                shk_prbs = []
+                tran_shks = []
+                perm_shks = []
+                
+                for i in range(states):
+                    c_next = self.solution[0].cFunc[i](dist_mGrid)
+                    self.cPol_Grid.append(c_next)
+                    
+                    a_next_i = dist_mGrid - c_next
+                    self.aPol_Grid .append(a_next_i)
+                    
+                    if type(self.Rfree) == list:
+                         b_next_i = self.Rfree[0][0] * a_next_i
+                    else:
+                         b_next_i = self.Rfree * a_next_i
+                         
+                    bNext.append(b_next_i)
+                    
+                    shk_prbs.append(shk_dstn[i].pmv)
+                    tran_shks.append(shk_dstn[i].atoms[1])
+                    perm_shks.append(shk_dstn[i].atoms[0])
+                    
+     
+
+                LivPrb = self.LivPrb[0][0] # Update probability of staying alive
+                
+                
+                if len(dist_pGrid) == 1: 
+                    
+                    self.tran_matrix = []
+
+                    for i in range(self.state_num):
+                        
+                        TranMatrix_i =  np.zeros( (len(dist_mGrid),len(dist_mGrid)) ) 
+
+                        for j in range(self.state_num):
+                            NewBornDist = jump_to_grid_1D(tran_shks[j],shk_prbs[j],dist_mGrid)
+
+                            TranMatrix_i +=  gen_tran_matrix_1D(dist_mGrid,bNext[i],self.MrkvArray[0][i][j]*shk_prbs[j],perm_shks[j],tran_shks[j], LivPrb,NewBornDist)
+                        self.tran_matrix.append(TranMatrix_i)
+                    
+                    self.prb_dstn = ss_dstn.real
+                    
+                    
+                else:
+                    
+                    self.tran_matrix = []
+
+                    for i in range(self.state_num):
+                        
+                        TranMatrix_i =  np.zeros( (len(dist_mGrid),len(dist_mGrid)) ) 
+
+                        for j in range(self.state_num):
+                            NewBornDist = jump_to_grid_2D(tran_shks[j],np.ones_like(tran_shks[i]),shk_prbs[j],dist_mGrid,dist_pGrid)
+
+                            TranMatrix_i +=  gen_tran_matrix_2D(dist_mGrid,dist_pGrid,bNext[i],self.MrkvArray[0][i][j]*shk_prbs[j],perm_shks[j],tran_shks[j], LivPrb,NewBornDist)
+                        self.tran_matrix.append(TranMatrix_i)
+                    
+                    self.prb_dstn = ss_dstn.real
+                    
+        
+            elif self.cycles > 1:
+                print('calc_transition_matrix requires cycles = 0 or cycles = 1')
+                
+            elif self.T_cycle!= 0:
+                
+                # for finite horizon, we can account for changing levels of prb_unemp because of endogenous job finding probability by imposing a list of these values, so for q'th period, the probability is slightly different
+                if shk_dstn == None:
+                    shk_dstn = self.IncShkDstn
+                
+                self.tran_matrix = []
+
+                dist_mGrid =  self.dist_mGrid
+                #print(len(dist_mGrid))
+
+                self.cPol_Grid = []
+                self.aPol_Grid  = []
+                self.prb_dstn = []
+                dstn_0 = self.dstn_0 
+                
+                for k in range(self.T_cycle):
+                
+                    if type(self.dist_pGrid) == list:
+                        dist_pGrid = self.dist_pGrid[k] #Permanent income grid this period
+                    else:
+                        dist_pGrid = self.dist_pGrid #If here then use prespecified permanent income grid
+                    
+                    bNext = []
+                    shk_prbs = []
+                    tran_shks = []
+                    perm_shks = []
+                    cPol_Grid_k = []
+                    aPol_Grid_k = []
+
+                    for i in range(self.state_num):
+                        
+                        c_next = self.solution[k].cFunc[i](dist_mGrid)
+                        cPol_Grid_k.append(c_next)
+                        
+                        a_next_i = dist_mGrid - c_next
+                        aPol_Grid_k.append(a_next_i)
+                        
+                        if type(self.Rfree)==list:
+                            b_next_i = self.Rfree[k][0]*a_next_i
+                            bNext.append(b_next_i)
+                        else:
+                            b_next_i = self.Rfree*a_next_i
+                            bNext.append(b_next_i)
+                            
+                            
+                        shk_prbs.append(shk_dstn[k][i].pmv)
+                        tran_shks.append(shk_dstn[k][i].atoms[1])
+                        perm_shks.append(shk_dstn[k][i].atoms[0])
+                        
+                    
+                    self.cPol_Grid.append(cPol_Grid_k)
+                    #print(len(cPol_Grid_k))
+
+                    self.aPol_Grid.append(aPol_Grid_k)
+
+            
+                    LivPrb = self.LivPrb[k][0] # Update probability of staying alive this period
+                    
+         
+                    if len(dist_pGrid) == 1: 
+                        
+                        dstn_0 = np.dot(self.MrkvArray[k].T, dstn_0) #transposed to have columns sum up to one , I think this is the distribution of employed vs unemployed
+                        
+                        tran_matrix_t = []
+
+                        for i in range(self.state_num):
+                            
+                            TranMatrix_i =  np.zeros( (len(dist_mGrid),len(dist_mGrid)) ) 
+
+                            for j in range(self.state_num):
+                                
+                                NewBornDist = jump_to_grid_1D(tran_shks[j],self.MrkvArray[k][i][j]*shk_prbs[j],dist_mGrid)
+
+                                TranMatrix_i +=  gen_tran_matrix_1D(dist_mGrid,bNext[i],self.MrkvArray[k][i][j]*shk_prbs[j],perm_shks[j],tran_shks[j], LivPrb,NewBornDist)
+                            tran_matrix_t.append(TranMatrix_i)
+                        
+                        self.tran_matrix.append(deepcopy(tran_matrix_t))
+                   
+                        self.prb_dstn.append(dstn_0)
+                        
+                  
+                    else:
+                        
+                        
+                        dstn_0 = np.dot(self.MrkvArray[k].T, dstn_0) #transposed to have columns sum up to one , I think this is the distribution of employed vs unemployed
+                        
+                        tran_matrix_t = []
+
+                        for i in range(self.state_num):
+                            
+                            TranMatrix_i =  np.zeros( (len(dist_mGrid),len(dist_mGrid)) ) 
+
+                            for j in range(self.state_num):
+                                
+                                NewBornDist = jump_to_grid_2D(tran_shks[j],np.ones_like(tran_shks[i]),self.MrkvArray[k][i][j]*shk_prbs[j],dist_mGrid,dist_pGrid)
+
+                                TranMatrix_i +=  gen_tran_matrix_2D(dist_mGrid,dist_pGrid,bNext[i],self.MrkvArray[k][i][j]*shk_prbs[j],perm_shks[j],tran_shks[j], LivPrb,NewBornDist)
+                            tran_matrix_t.append(TranMatrix_i)
+                        
+                        self.tran_matrix.append(deepcopy(tran_matrix_t))
+                   
+                        self.prb_dstn.append(dstn_0)
+                        
+                        
+                    
+                               
+                    
+
+        
+    def calc_ergodic_dist(self, transition_matrix = None):
+            
+            '''
+            Calculates the ergodic distribution across normalized market resources and
+            permanent income as the eigenvector associated with the eigenvalue 1.
+            The distribution is stored as attributes of self both as a vector and as a reshaped array with the ij'th element representing
+            the probability of being at the i'th point on the mGrid and the j'th
+            point on the pGrid.
+            
+            Parameters
+            ----------
+            transition_matrix: List 
+                        transition matrix whose ergordic distribution is to be solved
+
+            Returns
+            -------
+            None
+            '''
+            
+            
+            #if transition_matrix == None:
+                #transition_matrix = [self.tran_matrix]
+            self.vec_erg_dstns = []
+            for i in range(self.state_num):
+                
+                eigen_i, ergodic_distr_i = sp.linalg.eigs(self.tran_matrix[i] , k=1 , which='LM')  # Solve for ergodic distribution
+                ergodic_distr_i = ergodic_distr_i.real/np.sum(ergodic_distr_i.real)
+                
+                #erg_dstn = compute_erg_dstn(self.tran_matrix[i])
+                #self.ergodic_distrs.append(erg_dstn)
+
+                ergodic_distr_i = ergodic_distr_i.T[0]
+                self.vec_erg_dstns.append(ergodic_distr_i)
+                
+                
+            
+    def compute_steady_state(self,IncShkDstn_ntrl_msr):
+        
+           
+            
+
+        #solve the consumer's problem
+
+        self.solve()
+
+        self.define_distribution_grid(dist_pGrid = np.array([1]))
+        self.calc_transition_matrix(IncShkDstn_ntrl_msr)
+        self.calc_ergodic_dist()
+        
+        
+        C = 0
+        A = 0
+        for i in range(self.state_num):
+            
+            C += self.prb_dstn[i]*np.dot(self.cPol_Grid[i],self.vec_erg_dstns[i])
+            A += self.prb_dstn[i]*np.dot(self.aPol_Grid[i],self.vec_erg_dstns[i])
+
+
+        self.A_ss = A
+        self.C_ss = C
+        
+        return C , A 
+    
+    
     def make_euler_error_func(self, mMax=100, approx_inc_dstn=True):
         """
         Creates a "normalized Euler error" function for this instance, mapping
diff --git a/HARK/utilities.py b/HARK/utilities.py
index 28b9b616d..54d3efb56 100644
--- a/HARK/utilities.py
+++ b/HARK/utilities.py
@@ -760,6 +760,179 @@ def gen_tran_matrix_2D(
     return TranMatrix
 
 
+
+
+def Fake_News_JAC(a_ss,c_ss,a_t,c_t,tranmat_ss,tranmat_t,D_ss,dx,T):
+    
+    """
+    Computes Heterogenous Agent Jacobian Matrices using fake news algorithm following https://onlinelibrary.wiley.com/doi/abs/10.3982/ECTA17434
+
+    Parameters
+    ----------
+    a_ss : np.array
+          Steady State Consumption Policy Grid
+
+    c_ss : np.array
+          Steady State Asset Policy Grid
+
+    a_t : np.array
+        list of Asset Policy Grids given shock
+
+    c_t : np.array
+        list of Consumption Policy Grids given shock
+
+    tranmat_ss : np.array
+        steady state transition matrix
+
+    tranmat_t : list
+        list of transition matrices given shock
+        
+    dx : float
+        size of perturbation
+
+    T : int
+         Length of TxT Jacobian Matrix
+
+    Returns
+    -------
+    CJAC : np.array
+        Consumption Jacobian Matrix
+    AJAC : np.array
+        Asset Jacobian Matrix
+    """
+    
+    
+
+    # Fake News Algorithm begins below ( To find fake news algorithm See page 2388 of https://onlinelibrary.wiley.com/doi/abs/10.3982/ECTA17434  )
+
+    ##########
+    # STEP 1 # of fake news algorithm, As in the paper for Curly Y and Curly D. Here the policies are over assets and consumption so we denote them as curly C and curly D.
+    ##########
+
+    # Expectation vectors
+    exp_vecs_a_e = []
+    exp_vec_a_e = a_ss
+
+    exp_vecs_c_e = []
+    exp_vec_c_e = c_ss
+
+    for i in range(T):
+
+        exp_vecs_a_e.append(exp_vec_a_e)
+        exp_vec_a_e = np.dot( tranmat_ss.T, exp_vec_a_e )
+
+        exp_vecs_c_e.append(exp_vec_c_e)
+        exp_vec_c_e = np.dot( tranmat_ss.T, exp_vec_c_e )
+
+    # First expectation vector is the steady state policy
+    exp_vecs_a_e = np.array(exp_vecs_a_e)
+    exp_vecs_c_e = np.array(exp_vecs_c_e)
+
+
+    da0_s = [] # Deviation of asset policy from steady state policy
+    dc0_s = [] # Deviation of Consumption policy from steady state policy
+
+    for i in range(T):
+        da0_s.append( a_t[T - i ] - a_ss )
+        dc0_s.append( c_t[T  - i ] - c_ss )
+
+    # Turn expectation vectors into arrays
+    da0_s = np.array(da0_s)
+    dc0_s = np.array(dc0_s)
+
+
+
+    dA0_s = []
+    dC0_s = []
+    for i in range(T):
+        dA0_s.append( np.dot(da0_s[i], D_ss))
+        dC0_s.append( np.dot(dc0_s[i], D_ss))
+
+    dA0_s = np.array(dA0_s)
+    A_curl_s = dA0_s/dx   # This is equivalent to the curly Y scalar detailed in the first step of the algorithm
+
+    dC0_s = np.array(dC0_s)
+    C_curl_s = dC0_s/dx
+
+
+    dlambda0_s = []   # List of change in transition matrix relative to the steady state transition matrix
+    tranmat_t.append(tranmat_ss)  # List of computed transition matrices for each period
+    for i in range(T):
+        dlambda0_s.append( tranmat_t[T  - i ] - tranmat_ss )
+
+    dlambda0_s = np.array(dlambda0_s)
+
+    dD0_s = []
+
+    for i in range(T):
+        dD0_s.append( np.dot( dlambda0_s[i], D_ss )  )
+
+    dD0_s = np.array(dD0_s)
+    D_curl_s = dD0_s/dx
+
+    #########
+    # STEP3 # of the algorithm. In particular equation 26 of the published paper.
+    #########
+    
+    # Fake news matrices
+    Curl_F_A = np.zeros( ( T , T ) )
+    Curl_F_C = np.zeros( ( T , T ) )
+
+    # First row of Fake News Matrix
+    Curl_F_A[0] = A_curl_s
+    Curl_F_C[0] = C_curl_s
+    for i in range(T-1):
+        for j in range(T):
+
+            Curl_F_A[i+1][j] = np.dot(exp_vecs_a_e[i], D_curl_s[j])
+            Curl_F_C[i+1][j] = np.dot(exp_vecs_c_e[i], D_curl_s[j])
+
+    ########
+    # STEP4 #  of the algorithm
+    ########
+    
+    # Jacobian Matrices
+    J_A = np.zeros((T,T)) # Asset Jacobian
+    J_C = np.zeros((T,T)) # Consumption Jacobian
+
+    for t in range(T):
+        for s in range(T):
+            if (t ==0) or (s==0):
+                J_A[t][s] = Curl_F_A[t][s]
+                J_C[t][s] = Curl_F_C[t][s]
+            else:
+                J_A[t][s] = J_A[t-1][s-1] + Curl_F_A[t][s]
+                J_C[t][s] = J_C[t-1][s-1] + Curl_F_C[t][s]
+
+    # Zeroth Column of the Jacobian
+    dD_0_0 = np.dot(tranmat_t[-2] - tranmat_ss, D_ss)
+
+    D_curl_0_0 = dD_0_0/dx
+
+    c_first_col_without_0_0 = []
+    a_first_col_without_0_0 = []
+
+    for i in range(T ):
+
+        c_first_col_without_0_0.append(np.dot(exp_vecs_c_e[i],D_curl_0_0))
+        a_first_col_without_0_0.append(np.dot(exp_vecs_a_e[i],D_curl_0_0))
+
+    c_first_col_without_0_0 = np.array(c_first_col_without_0_0)
+    a_first_col_without_0_0 = np.array(a_first_col_without_0_0)
+
+    c_first_col_0 = np.zeros(T)
+    a_first_col_0 = np.zeros(T)
+
+    c_first_col_0 = c_first_col_without_0_0
+    a_first_col_0 = a_first_col_without_0_0
+
+    #Fill zeroth column of jacobian matrix
+    J_A.T[0] = a_first_col_0
+    J_C.T[0] = c_first_col_0
+
+    return J_C, J_A
+
+
 # ==============================================================================
 # ============== Some basic plotting tools  ====================================
 # ==============================================================================
diff --git a/examples/ConsMarkovModel/HANK_SAM.ipynb b/examples/ConsMarkovModel/HANK_SAM.ipynb
new file mode 100644
index 000000000..d87a37e0b
--- /dev/null
+++ b/examples/ConsMarkovModel/HANK_SAM.ipynb
@@ -0,0 +1,1241 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "244d8348",
+   "metadata": {},
+   "source": [
+    "# Solving a HANK and SAM model with HARK\n",
+    "\n",
+    "by William Du (wdu9@jhu.edu)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "798eb868",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
+    "from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType\n",
+    "import time\n",
+    "from copy import copy, deepcopy\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time\n",
+    "from scipy import sparse as sp\n",
+    "from HARK.distribution import DiscreteDistribution, MeanOneLogNormal,combine_indep_dstns,Lognormal, Uniform,DiscreteDistributionLabeled\n",
+    "from HARK.utilities import Fake_News_JAC\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a132977b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class HANK_SAM_Agent(MarkovConsumerType):\n",
+    "    \n",
+    "    def calc_jacobian(self,shk_param,T,ntrl_msr):\n",
+    "        \n",
+    "        params = deepcopy(self.__dict__[\"parameters\"])        \n",
+    "        params['T_cycle'] = T\n",
+    "        params['LivPrb'] = params['T_cycle']*self.LivPrb\n",
+    "        params['PermGroFac'] = params['T_cycle']*self.PermGroFac\n",
+    "        params['PermShkStd'] = params['T_cycle']*self.PermShkStd\n",
+    "        params['TranShkStd'] = params['T_cycle']*self.TranShkStd\n",
+    "        params['Rfree'] = params['T_cycle']*self.Rfree\n",
+    "        params['MrkvArray'] = params['T_cycle']*self.MrkvArray\n",
+    "        params['cycles'] = 1\n",
+    "        \n",
+    "        jac_agent = MarkovConsumerType(**params)\n",
+    "        jac_agent.cycles = 1\n",
+    "        jac_agent.del_from_time_inv('Rfree')\n",
+    "        jac_agent.add_to_time_vary('Rfree')\n",
+    "        jac_agent.IncShkDstn = params['T_cycle'] * self.IncShkDstn\n",
+    "\n",
+    "        jac_agent.solution_terminal.cFunc = deepcopy(self.solution[0].cFunc) \n",
+    "        jac_agent.solution_terminal.vFunc = deepcopy(self.solution[0].vFunc)\n",
+    "        jac_agent.solution_terminal.vPfunc = deepcopy(self.solution[0].vPfunc)\n",
+    "        jac_agent.solution_terminal.vPPfunc = deepcopy(self.solution[0].vPPfunc)\n",
+    "        jac_agent.dstn_0 = self.prb_dstn\n",
+    "        \n",
+    "        PermShkDstn = MeanOneLogNormal(self.PermShkStd[0],123)._approx_equiprobable(self.PermShkCount)\n",
+    "        PermShk_ntrl_msr = deepcopy(PermShkDstn)\n",
+    "        PermShk_ntrl_msr.pmv = PermShk_ntrl_msr.atoms[0]*PermShk_ntrl_msr.pmv[0]\n",
+    "        \n",
+    "        dx = .0001\n",
+    "        q = params['T_cycle'] - 1\n",
+    "        \n",
+    "        if shk_param =='job_find':\n",
+    "            \n",
+    "            MrkvArray_dx = np.array( [ [1 - self.job_sep*(1-(self.job_find + dx)) , self.job_find + dx] ,  #\" The sum of entries in each column in t should equal one. \"\n",
+    "\n",
+    "                                           [self.job_sep*(1- (self.job_find +dx) ), 1 -( self.job_find +dx) ] ]  ).T\n",
+    "\n",
+    "            eigen, ssdx_dstn = sp.linalg.eigs(MrkvArray_dx.T , k=1, which='LM') # transposed to have columns sum up to one\n",
+    "            ssdx_dstn = ssdx_dstn[:,0] / np.sum(ssdx_dstn[:,0])\n",
+    "\n",
+    "            jac_agent.MrkvArray = q*self.MrkvArray + [MrkvArray_dx] + (params['T_cycle'] - q  )*self.MrkvArray\n",
+    "\n",
+    "            ntrl_msr = params['T_cycle']*[IncShkDstn_ntrl_msr]\n",
+    "            \n",
+    "            \n",
+    "        elif shk_param =='wage':\n",
+    "            \n",
+    "            #employed Income shock distribution\n",
+    "            TranShkDstn_W = MeanOneLogNormal(self.TranShkStd[0],123)._approx_equiprobable(self.TranShkCount)\n",
+    "            TranShkDstn_W.atoms  = TranShkDstn_W.atoms*(self.wage+dx)*(1-(self.tau) )\n",
+    "            employed_IncShkDstnW1 = combine_indep_dstns(PermShkDstn,TranShkDstn_W)\n",
+    "            \n",
+    "            employed_IncShkDstnW = DiscreteDistributionLabeled.from_unlabeled(\n",
+    "                employed_IncShkDstnW1,\n",
+    "                name=\"Distribution of Shocks to Income\",\n",
+    "                var_names=[\"PermShk\", \"TranShk\"],\n",
+    "            )\n",
+    "            # Perturbed Neutral Measure\n",
+    "            IncShkDstn_ntrl_msr_eW = combine_indep_dstns(PermShk_ntrl_msr,TranShkDstn_W)\n",
+    "            IncShkDstn_ntrl_msr_W = [IncShkDstn_ntrl_msr_eW,IncShkDstn_ntrl_msr[1]]\n",
+    "            \n",
+    "            jac_agent.IncShkDstn = q*self.IncShkDstn + [ [employed_IncShkDstnW, self.IncShkDstn[0][1]] ]  + (params['T_cycle'] - q  )*self.IncShkDstn\n",
+    "            ntrl_msr = q*[IncShkDstn_ntrl_msr] + [IncShkDstn_ntrl_msr_W] + (params['T_cycle'] - q )*[IncShkDstn_ntrl_msr]\n",
+    "\n",
+    "            \n",
+    "        elif shk_param == 'tau':\n",
+    "            \n",
+    "            # Tau shock(tax rate)\n",
+    "            TranShkDstn_e_tau = MeanOneLogNormal(self.TranShkStd[0],123)._approx_equiprobable(self.TranShkCount)\n",
+    "            TranShkDstn_e_tau.atoms  = TranShkDstn_e_tau.atoms*(self.wage)*(1-(self.tau + dx) )\n",
+    "            employed_IncShkDstn_tau1 = combine_indep_dstns(PermShkDstn,TranShkDstn_e_tau)\n",
+    "\n",
+    "            employed_IncShkDstn_tau = DiscreteDistributionLabeled.from_unlabeled(\n",
+    "                employed_IncShkDstn_tau1,\n",
+    "                name=\"Distribution of Shocks to Income\",\n",
+    "                var_names=[\"PermShk\", \"TranShk\"],\n",
+    "            )\n",
+    "            # Perturbed Neutral Measure\n",
+    "            IncShkDstn_ntrl_msr_e_tau = combine_indep_dstns(PermShk_ntrl_msr,TranShkDstn_e_tau)\n",
+    "            IncShkDstn_ntrl_msr_tau = [IncShkDstn_ntrl_msr_e_tau,IncShkDstn_ntrl_msr[1]]\n",
+    "            \n",
+    "            jac_agent.IncShkDstn = q*self.IncShkDstn + [ [employed_IncShkDstn_tau, self.IncShkDstn[0][1] ] ]  + (params['T_cycle'] - q  )*self.IncShkDstn \n",
+    "            ntrl_msr = q*[IncShkDstn_ntrl_msr] + [IncShkDstn_ntrl_msr_tau] + (params['T_cycle'] - q )*[IncShkDstn_ntrl_msr]\n",
+    "\n",
+    "        elif shk_param == 'Rfree':\n",
+    "            \n",
+    "            jac_agent.Rfree = q*self.Rfree + [self.Rfree[0] + dx] + (params['T_cycle'] - q )*self.Rfree\n",
+    "            ntrl_msr = params['T_cycle']*[IncShkDstn_ntrl_msr]\n",
+    "\n",
+    "            \n",
+    "        jac_agent.solve()\n",
+    "        jac_agent.define_distribution_grid(dist_pGrid = params['T_cycle']*[np.array([1])])\n",
+    "        jac_agent.calc_transition_matrix(ntrl_msr) \n",
+    "        \n",
+    "        \n",
+    "        jac_agent.aPol_Grid.append(self.aPol_Grid)\n",
+    "        jac_agent.cPol_Grid.append(self.cPol_Grid)\n",
+    "\n",
+    "        \n",
+    "        a_t = []\n",
+    "        c_t = []\n",
+    "\n",
+    "        for i in range(jac_agent.state_num):\n",
+    "\n",
+    "            a_t_i = []\n",
+    "            c_t_i = []\n",
+    "\n",
+    "            for t in range(params['T_cycle'] + 1):\n",
+    "                a_t_i.append(jac_agent.aPol_Grid[t][i])\n",
+    "                c_t_i.append(jac_agent.cPol_Grid[t][i])\n",
+    "\n",
+    "            a_t.append(a_t_i)\n",
+    "            c_t.append(c_t_i)\n",
+    "\n",
+    "\n",
+    "        tran_mat = []\n",
+    "        for i in range(jac_agent.state_num):\n",
+    "            tran_mat_i = []\n",
+    "            for t in range(params['T_cycle']):\n",
+    "\n",
+    "                tran_mat_i.append(jac_agent.tran_matrix[t][i])\n",
+    "            tran_mat.append(tran_mat_i)\n",
+    "\n",
+    "        CJAC = np.zeros((T,T))\n",
+    "        AJAC = np.zeros((T,T))\n",
+    "\n",
+    "        for i in range(self.state_num):\n",
+    "            CJAC_i, AJAC_i = Fake_News_JAC(self.aPol_Grid[i],self.cPol_Grid[i],a_t[i],c_t[i],self.tran_matrix[i],tran_mat[i],self.vec_erg_dstns[i].T, dx, T) # Calculate Jacobian matrices with fake news algorithm\n",
+    "            \n",
+    "            CJAC += self.prb_dstn[i]*CJAC_i\n",
+    "            AJAC += self.prb_dstn[i]*AJAC_i\n",
+    "\n",
+    "            \n",
+    "        return CJAC, AJAC\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5c487b9",
+   "metadata": {},
+   "source": [
+    "# Steady State Parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "30144ed2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.657\n",
+      "markov array [[0.9657 0.657 ]\n",
+      " [0.0343 0.343 ]]\n",
+      "ss_dstn [0.95038334 0.04961666]\n",
+      "kappa/(wage*phi): 0.07180841725578556\n",
+      "kappa 0.05098397625160775\n",
+      "tau_ss 0.24426717203617027\n",
+      "Consumption Target: 0.7205806451612903\n",
+      "Asset Target: 4.526270936228729\n",
+      "Government bonds to GDP 3.939267138036165\n",
+      "Liquid Assets to output ratio 3.939267138036165\n",
+      " Aggregate Liquidity to annual output ratio 0.9848167845090412\n",
+      "Liquids Assets to after tax labor Income Ratio 6.30192813340863\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/Update_HARK_01_28_2023/lib/python3.9/site-packages/scipy/sparse/linalg/_eigen/arpack/arpack.py:1272: RuntimeWarning: k >= N - 1 for N * N square matrix. Attempting to use scipy.linalg.eig instead.\n",
+      "  warnings.warn(\"k >= N - 1 for N * N square matrix. \"\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "#Parameters\n",
+    "job_sep =.1\n",
+    "unemp_insurance = .5\n",
+    "vacancy_fil_rate = .71\n",
+    "phi = vacancy_fil_rate\n",
+    "job_find = .657\n",
+    "phi_ss = phi\n",
+    "Z_ss = 1.209\n",
+    "R = 1.02**.25 # as you raise the interest rate,  the target level of assets falls and so the discount factor falls and the AIC, this amplifies the mutliplier\n",
+    "r_ss = R - 1\n",
+    "\n",
+    "alpha = .6\n",
+    "chi = (vacancy_fil_rate/job_find**(alpha/(alpha -1)))**(-(alpha-1))\n",
+    "phi = job_find**(alpha/(alpha - 1))  * chi**(-1/(alpha-1)) #Making sure this is equal to vacancy fill rate\n",
+    "          \n",
+    "delta = ((R**4)*(1-(1/5)) )**(1/4) # or you can do delta = R*(1 -(1/20)), 20 quarters is 5 years\n",
+    "qb_ss = (1) / (R - delta)\n",
+    "print(job_find)\n",
+    "\n",
+    "\n",
+    "\n",
+    "markov_array = np.array( [ [1 - job_sep*(1-job_find) ,  job_find ] ,  #\" The sum of entries in each column in t should equal one. \"\n",
+    "                          \n",
+    "                \n",
+    "                          [ job_sep*(1-job_find) , 1- job_find] ]          )\n",
+    "\n",
+    "eigen, ss_dstn = sp.linalg.eigs(markov_array , k=1, which='LM')\n",
+    "\n",
+    "\n",
+    "print('markov array' , markov_array)\n",
+    "\n",
+    "\n",
+    "ss_dstn = ss_dstn[:,0] / np.sum(ss_dstn[:,0]) # Steady state distribution of employed/unemployed \n",
+    "\n",
+    "print('ss_dstn', ss_dstn)\n",
+    "\n",
+    "\n",
+    "#SS Labor\n",
+    "N_ss = 1 - (markov_array[1][0] / (markov_array[0][1] + markov_array[1][0])) # Note this happens to equal to the proportion of individuals who are employed\n",
+    "\n",
+    "\n",
+    "#SS vacancy\n",
+    "v_ss = N_ss*job_sep / phi\n",
+    "\n",
+    "\n",
+    "#MC \n",
+    "epsilon_p = 6 # Elasticity of substitution \n",
+    "\n",
+    "MC_ss = (epsilon_p - 1) /epsilon_p\n",
+    "Y_ss = Z_ss*N_ss\n",
+    "\n",
+    "wage_ss = 1.0\n",
+    "\n",
+    "kappa = (MC_ss*Z_ss - wage_ss) / ( (1/phi) - (1/R)*(1-job_sep)/phi )  \n",
+    "\n",
+    "\n",
+    "print( 'kappa/(wage*phi):', kappa/(wage_ss*phi) )\n",
+    "print( 'kappa', kappa )\n",
+    "\n",
+    "D_ss = Z_ss*N_ss* (1-MC_ss)\n",
+    "G_ss = Y_ss*.2 # 20 percent of output\n",
+    "\n",
+    "\n",
+    "A_ss = 4.526270936228729 # Aggregate Liquid Wealth to Quarterly Permanent Income \n",
+    "B_ss = A_ss/qb_ss\n",
+    "\n",
+    "#A_ss = qb_ss*B_ss + q_ss\n",
+    "\n",
+    "tau_ss = (G_ss  + unemp_insurance*(1-N_ss)  - ( 1 + delta*qb_ss - qb_ss)*B_ss )/(wage_ss*N_ss)\n",
+    "print('tau_ss' , tau_ss)\n",
+    "\n",
+    "# Steady State Consumption Target\n",
+    "C_ss = wage_ss*N_ss - G_ss \n",
+    "print( 'Consumption Target: ' + str(C_ss) )\n",
+    "\n",
+    "\n",
+    "# Steady State Asset Target \n",
+    "\n",
+    "print( 'Asset Target: ' +str(A_ss) )\n",
+    "\n",
+    "q_ss = D_ss/(R-1)\n",
+    "\n",
+    "print('Government bonds to GDP', qb_ss*B_ss / Y_ss)\n",
+    "print('Liquid Assets to output ratio', A_ss/(Y_ss))\n",
+    "\n",
+    "print(' Aggregate Liquidity to annual output ratio', A_ss/(4*Y_ss))\n",
+    "\n",
+    "print('Liquids Assets to after tax labor Income Ratio', A_ss/(wage_ss*N_ss*(1-tau_ss)))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1f983125",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "states = 2\n",
+    "\n",
+    "HANK_SAM_Dict = {\n",
+    "    # Parameters shared with the perfect foresight model\n",
+    "    \"CRRA\":2.0,                            # Coefficient of relative risk aversion\n",
+    "    \"Rfree\": [np.array([R]* states)],      # Interest factor on assets\n",
+    "    \"DiscFac\": .96,                  # Intertemporal discount factor\n",
+    "    \"LivPrb\" : [np.array([.99375]*states)],                # Survival probability\n",
+    "    \"PermGroFac\" : [np.array([1.00]*states)],               # 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",
+    "\n",
+    "    # Parameters for constructing the \"assets above minimum\" grid\n",
+    "    \"aXtraMin\" : 0.00001,                   # Minimum end-of-period \"assets above minimum\" value\n",
+    "    \"aXtraMax\" : 160000000,                     # Maximum end-of-period \"assets above minimum\" value\n",
+    "    \"aXtraCount\" : 200,                    # Number of points in the base grid of \"assets above minimum\"\n",
+    "    \"aXtraNestFac\" : 3,                    # Exponential nesting factor when constructing \"assets above minimum\" grid\n",
+    "    \"aXtraExtra\" : [None],                 # Additional values to add to aXtraGrid\n",
+    "\n",
+    "    # A few other parameters\n",
+    "    \"BoroCnstArt\" : 0.0,                   # Artificial borrowing constraint; imposed minimum level of end-of period assets\n",
+    "    \"vFuncBool\" : False,                   # Whether to calculate the value function during solution\n",
+    "    \"CubicBool\" : False,                   # Preference shocks currently only compatible with linear cFunc\n",
+    "    \"T_cycle\" : 1,                         # Number of periods in the cycle for this agent type\n",
+    "\n",
+    "    # Parameters only used in simulation\n",
+    "    \"AgentCount\" : 100000,                 # Number of agents of this type\n",
+    "    \"T_sim\" : 200,                         # Number of periods to simulate\n",
+    "    \"aNrmInitMean\" : np.log(.8)-(.5**2)/2, # Mean of log initial assets\n",
+    "    \"aNrmInitStd\"  : .5,                   # Standard deviation of log initial assets\n",
+    "    \"pLvlInitMean\" : 0.0,                  # Mean of log initial permanent income\n",
+    "    \"pLvlInitStd\"  : 0.0,                  # Standard deviation of log initial permanent income\n",
+    "    \"PermGroFacAgg\" : 1.0,                 # Aggregate permanent income growth factor\n",
+    "    \"T_age\" : None,                        # Age after which simulated agents are automatically killed\n",
+    "    \n",
+    "    # new parameters\n",
+    "     \"job_sep\"    : job_sep, \n",
+    "     \"job_find\"   : job_find, \n",
+    "     \n",
+    "    # markov array\n",
+    "    \"MrkvArray\"   :  [ np.array( [ [1 - job_sep*(1-job_find) , job_find ] ,  \n",
+    "                          \n",
+    "                               [ job_sep*(1-job_find) , 1- job_find] ]          ).T ],\n",
+    "    \n",
+    "        \n",
+    "    \"MrkvArray_real\"   :  [ np.array( [ [1 - job_sep*(1-job_find) , job_find ] ,  \n",
+    "                          \n",
+    "                               [ job_sep*(1-job_find) , 1- job_find] ]          ).T ],\n",
+    "    \n",
+    "    \"mMin\": 1e-5 ,\n",
+    "    \"mMax\": 1000000 , \n",
+    "    \"mCount\": 300 , \n",
+    "    \"mFac\": 3, \n",
+    "    \n",
+    "     }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "0c7a891a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "HANK_SAM_Dict['MrkvArray'] = [ np.array( [ [1 - HANK_SAM_Dict['job_sep']*(1-HANK_SAM_Dict['job_find']) , HANK_SAM_Dict['job_find'] ] ,  \n",
+    "                          \n",
+    "                               [ HANK_SAM_Dict['job_sep']*(1-HANK_SAM_Dict['job_find']) , 1- HANK_SAM_Dict['job_find']] ]          ).T ]\n",
+    "\n",
+    "\n",
+    "example = HANK_SAM_Agent(**HANK_SAM_Dict,verbose=True)\n",
+    "\n",
+    "example.cycles = 0\n",
+    "example.T_cycles = 1\n",
+    "example.wage = wage_ss\n",
+    "example.unemp_insurance = unemp_insurance\n",
+    "rfree = example.Rfree\n",
+    "example.tau = tau_ss\n",
+    "example.del_from_time_inv('Rfree')\n",
+    "example.add_to_time_vary('Rfree')\n",
+    "\n",
+    "#Income shock distributions for each markov state\n",
+    "\n",
+    "TranShkDstn_e = MeanOneLogNormal(example.TranShkStd[0],123)._approx_equiprobable(example.TranShkCount)\n",
+    "TranShkDstn_e.atoms  = TranShkDstn_e.atoms*example.wage*(1-example.tau)\n",
+    "\n",
+    "\n",
+    "TranShkDstn_u1 = MeanOneLogNormal(example.TranShkStd[0],123)._approx_equiprobable(example.TranShkCount)\n",
+    "TranShkDstn_u1.atoms  = TranShkDstn_u1.atoms*example.unemp_insurance\n",
+    "\n",
+    "PermShkDstn = MeanOneLogNormal(example.PermShkStd[0],123)._approx_equiprobable(example.PermShkCount)\n",
+    "PermShkDstn_u = deepcopy(PermShkDstn)\n",
+    "\n",
+    "#employed Income shock distribution\n",
+    "employed_IncShkDstn_1 = combine_indep_dstns(PermShkDstn,TranShkDstn_e)\n",
+    "\n",
+    "#unemployed Income shock distribution\n",
+    "unemployed_IncShkDstn_1 = combine_indep_dstns(PermShkDstn_u,TranShkDstn_u1)\n",
+    "\n",
+    "# Transform Distributions into Labeled Distributions\n",
+    "employed_IncShkDstn = DiscreteDistributionLabeled.from_unlabeled(\n",
+    "    employed_IncShkDstn_1,\n",
+    "    name=\"Distribution of Shocks to Income\",\n",
+    "    var_names=[\"PermShk\", \"TranShk\"],\n",
+    ")\n",
+    "\n",
+    "unemployed_IncShkDstn = DiscreteDistributionLabeled.from_unlabeled(\n",
+    "    unemployed_IncShkDstn_1,\n",
+    "    name=\"Distribution of Shocks to Income\",\n",
+    "    var_names=[\"PermShk\", \"TranShk\"],\n",
+    ")\n",
+    "\n",
+    "# Income Shock Distributions as attributes of the example Agent\n",
+    "example.IncShkDstn = [ [employed_IncShkDstn, unemployed_IncShkDstn] ]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa033b0a",
+   "metadata": {},
+   "source": [
+    "# Neutral Measure (Harmenberg 2021)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "689c0dc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PermShkDstn_u = MeanOneLogNormal(example.PermShkStd[0] ,123)._approx_equiprobable(example.PermShkCount)\n",
+    "\n",
+    "PermShk_ntrl_msr = deepcopy(PermShkDstn)\n",
+    "PermShk_ntrl_msr.pmv = PermShk_ntrl_msr.atoms[0]*PermShk_ntrl_msr.pmv[0]\n",
+    "IncShkDstn_ntrl_msr_e = combine_indep_dstns(PermShk_ntrl_msr,TranShkDstn_e)\n",
+    "\n",
+    "PermShk_ntrl_msr_u = deepcopy(PermShkDstn_u) #change permshkdstn to institute increase in variance or not\n",
+    "PermShk_ntrl_msr_u.pmv = PermShk_ntrl_msr_u.atoms[0]*PermShk_ntrl_msr_u.pmv[0]\n",
+    "IncShkDstn_ntrl_msr_u1 = combine_indep_dstns(PermShk_ntrl_msr_u,TranShkDstn_u1)\n",
+    "\n",
+    "IncShkDstn_ntrl_msr = [IncShkDstn_ntrl_msr_e,IncShkDstn_ntrl_msr_u1 ]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e1a459d",
+   "metadata": {},
+   "source": [
+    "# Specify Agents"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "bde70d10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BaselineType = deepcopy(example) \n",
+    "BaselineType.IncShkDstn = [ [employed_IncShkDstn, unemployed_IncShkDstn] ]\n",
+    "BaselineType.cycles = 0\n",
+    "BaselineType.mCount = 300\n",
+    "\n",
+    "\n",
+    "# Specify the distribution of the discount factor\n",
+    "num_types = 7 # number of types we want\n",
+    "\n",
+    "DiscFac_mean =  0.9786919599273968# center of beta distribution\n",
+    "DiscFac_spread =   0.024077275992363603 # spread of beta distribution\n",
+    "\n",
+    "\n",
+    "DiscFac_dstn = (\n",
+    "        Uniform(DiscFac_mean - DiscFac_spread, DiscFac_mean + DiscFac_spread)\n",
+    "        ._approx_equiprobable(num_types)\n",
+    "        .atoms.flatten()\n",
+    "    )\n",
+    "MyTypes = []  # initialize an empty list to hold our consumer types\n",
+    "for nn in range(num_types):\n",
+    "    # Now create the types, and append them to the list MyTypes\n",
+    "    NewType = deepcopy(BaselineType)\n",
+    "    NewType.DiscFac = DiscFac_dstn[nn]\n",
+    "    NewType.seed = nn  # give each consumer type a different RNG seed\n",
+    "    MyTypes.append(NewType)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7654317d",
+   "metadata": {},
+   "source": [
+    "# Solve for Jacobians"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e720837f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/Update_HARK_01_28_2023/lib/python3.9/site-packages/scipy/sparse/linalg/_eigen/arpack/arpack.py:1272: RuntimeWarning: k >= N - 1 for N * N square matrix. Attempting to use scipy.linalg.eig instead.\n",
+      "  warnings.warn(\"k >= N - 1 for N * N square matrix. \"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "time taken to solve jacobians 126.14053106307983\n"
+     ]
+    }
+   ],
+   "source": [
+    "start = time.time()\n",
+    "\n",
+    "CJAC_JF_list = []\n",
+    "AJAC_JF_list = []\n",
+    "\n",
+    "CJACR_list = []\n",
+    "AJACR_list = []\n",
+    "\n",
+    "CJACW_list = []\n",
+    "AJACW_list = []\n",
+    "\n",
+    "\n",
+    "CJAC_tau_list = []\n",
+    "AJAC_tau_list = []\n",
+    "\n",
+    "C_steady_state = 0\n",
+    "A_steady_state = 0\n",
+    "\n",
+    "for i in range(len(MyTypes)):\n",
+    "    \n",
+    "    HANK_SAM_Dict['DiscFac'] = DiscFac_dstn[i]\n",
+    "\n",
+    "    ThisType = HANK_SAM_Agent(**HANK_SAM_Dict,verbose=True)\n",
+    "    ThisType.cycles = 0\n",
+    "    ThisType.del_from_time_inv('Rfree')\n",
+    "    ThisType.add_to_time_vary('Rfree')\n",
+    "    ThisType.T_cycles = 1\n",
+    "    rfree = example.Rfree\n",
+    "    ThisType.wage = wage_ss\n",
+    "    ThisType.tau = tau_ss\n",
+    "    \n",
+    "    ThisType.IncShkDstn = [ [employed_IncShkDstn, unemployed_IncShkDstn] ]\n",
+    "    \n",
+    "    C_ss_thistype, A_ss_thistype = ThisType.compute_steady_state(IncShkDstn_ntrl_msr)\n",
+    "    C_steady_state += (1/num_types)*C_ss_thistype\n",
+    "    A_steady_state += (1/num_types)*A_ss_thistype\n",
+    "    \n",
+    "    \n",
+    "    T = 300\n",
+    "    CJAC_JF_this_type, AJAC_JF_this_type = ThisType.calc_jacobian('job_find',T,IncShkDstn_ntrl_msr)\n",
+    "    CJACW_this_type, AJACW_this_type = ThisType.calc_jacobian('wage',T,IncShkDstn_ntrl_msr)\n",
+    "    CJAC_tau_this_type, AJAC_tau_this_type = ThisType.calc_jacobian('tau',T,IncShkDstn_ntrl_msr)\n",
+    "    CJACR_this_type, AJACR_this_type = ThisType.calc_jacobian('Rfree',T,IncShkDstn_ntrl_msr)\n",
+    "    \n",
+    "\n",
+    "    CJAC_JF_list.append(CJAC_JF_this_type)\n",
+    "    AJAC_JF_list.append(AJAC_JF_this_type)\n",
+    "\n",
+    "    CJACR_list.append(CJACR_this_type)\n",
+    "    AJACR_list.append(AJACR_this_type)\n",
+    "\n",
+    "    CJACW_list.append(CJACW_this_type)\n",
+    "    AJACW_list.append(AJACW_this_type)\n",
+    "\n",
+    "    CJAC_tau_list.append(CJAC_tau_this_type)\n",
+    "    AJAC_tau_list.append(AJAC_tau_this_type)\n",
+    "    \n",
+    "print('time taken to solve jacobians' , time.time() - start)\n",
+    "\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "14d1892f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.7370690342123284\n",
+      "4.533165110492943\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(C_steady_state)\n",
+    "print(A_steady_state)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7e577c07",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_weighted_average(JAC_list):\n",
+    "    \n",
+    "    JAC = np.zeros_like(JAC_list[0])\n",
+    "    for i in range(len(JAC_list)):\n",
+    "        JAC += (1/num_types)*JAC_list[i]\n",
+    "        \n",
+    "    return JAC\n",
+    "\n",
+    "\n",
+    "CJAC_tau = compute_weighted_average(CJAC_tau_list)\n",
+    "AJAC_tau = compute_weighted_average(AJAC_tau_list)\n",
+    "\n",
+    "CJAC_JF = compute_weighted_average(CJAC_JF_list)\n",
+    "AJAC_JF = compute_weighted_average(AJAC_JF_list)\n",
+    "\n",
+    "CJACR = compute_weighted_average(CJACR_list)\n",
+    "AJACR = compute_weighted_average(AJACR_list)\n",
+    "\n",
+    "CJACW = compute_weighted_average(CJACW_list)\n",
+    "AJACW =  compute_weighted_average(AJACW_list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "42e7f5d8",
+   "metadata": {},
+   "source": [
+    "# Tax Jacobians"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "58b88cad",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(CJAC_tau.T[0])\n",
+    "plt.plot(CJAC_tau.T[30])\n",
+    "plt.plot(CJAC_tau.T[40])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f1d315ba",
+   "metadata": {},
+   "source": [
+    "# Job Finding Jacobians"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "05ce5e52",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(CJAC_JF.T[30])\n",
+    "plt.plot(CJAC_JF.T[50])\n",
+    "plt.plot(CJAC_JF.T[0])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4cfa96dc",
+   "metadata": {},
+   "source": [
+    "# Interest Rate Jacobians"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a6429781",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(CJACR.T[0])\n",
+    "plt.plot(CJACR.T[10])\n",
+    "plt.plot(CJACR.T[40])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "deceb7b6",
+   "metadata": {},
+   "source": [
+    "# Wage Jacobians"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "04c881b4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(CJACW.T[0])\n",
+    "plt.plot(CJACW.T[40])\n",
+    "plt.plot(CJACW.T[70])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d5db3fd",
+   "metadata": {},
+   "source": [
+    "# Solving for Impulse Responses"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "c8b63879",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sequence_jacobian.classes import JacobianDict, SteadyStateDict, UserProvidedSS\n",
+    "from sequence_jacobian import het, simple, create_model              # functions\n",
+    "from sequence_jacobian.blocks.block import Block\n",
+    "from sequence_jacobian.classes.result_dict import ResultDict\n",
+    "import sequence_jacobian as sj  # SSJ will allow us to define blocks, models, compute IRFs, etc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8b563b1b",
+   "metadata": {},
+   "source": [
+    "# Specify General Equilibrium Equations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "f8a0b878",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "slope of phillips curve 0.1\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\"\"\"\n",
+    "ndur =  .75\n",
+    "duration = 1/(1-ndur)\n",
+    "print(duration)\n",
+    "varphi = (epsilon_p - 1)*ndur / ( (1-ndur)*(1-example.DiscFac*ndur) )\n",
+    "\"\"\"\n",
+    "\n",
+    "varphi = 10*epsilon_p\n",
+    "print('slope of phillips curve', epsilon_p/varphi)\n",
+    "\n",
+    "rho_r =.0\n",
+    "phi_b = .1\n",
+    "phi_pi = 1.5\n",
+    "phi_y = .1\n",
+    "\n",
+    "pi_ss =0\n",
+    "\n",
+    "@sj.simple\n",
+    "def unemployment(N):\n",
+    "    \n",
+    "    U = 1 - N\n",
+    "    \n",
+    "    return U\n",
+    "\n",
+    "\n",
+    "LC_ss = MC_ss*Z_ss\n",
+    "@sj.solved(unknowns={'LC': (-0.1, 10.0)}, targets=['LC_resid'], solver=\"brentq\")\n",
+    "def labor_cost(LC,Z,phi,job_sep,r_ante):\n",
+    "    \n",
+    "    LC_resid = LC - (  ( wage_ss * (LC/LC_ss)**(epsilon_w)  + (kappa/phi) - (1/ (1 + r_ante))*(1-job_sep) *kappa/phi(+1) ))\n",
+    "\n",
+    "    return LC_resid\n",
+    "\n",
+    "@sj.simple\n",
+    "def marginal_cost(LC,Z):\n",
+    "    \n",
+    "    MC = LC/Z\n",
+    "    return MC\n",
+    "\n",
+    "\n",
+    "epsilon_w  = .45\n",
+    "@sj.simple\n",
+    "def wage_(LC):\n",
+    "    \n",
+    "    w = wage_ss * (LC/LC_ss)**(epsilon_w)\n",
+    "    \n",
+    "    return w\n",
+    "\n",
+    "@sj.solved(unknowns={'pi': (-0.1, 0.1)}, targets=['nkpc_resid'], solver=\"brentq\")\n",
+    "def Phillips_Curve(pi,MC,Y,r_ante):\n",
+    "    \n",
+    "    nkpc_resid = epsilon_p*MC - varphi*pi*(1+pi) + (1/ (1 + r_ante))*varphi*pi(+1)*(1+pi(+1))*(Y(+1)/Y)\n",
+    "    return nkpc_resid\n",
+    "\n",
+    "\n",
+    "@sj.solved(unknowns={'i': (0.0, 0.1)}, targets=['taylor_resid'], solver=\"brentq\")\n",
+    "def taylor(i,pi,Y,ev):\n",
+    "    taylor_resid = i - rho_r*i(-1) - (1-rho_r)*( phi_pi*pi + phi_y*Y ) - ev\n",
+    "    return taylor_resid\n",
+    "\n",
+    "\n",
+    "@sj.simple\n",
+    "def matching(eta):\n",
+    "    \n",
+    "    phi = eta**(alpha/(alpha - 1))  * chi**(-1/(alpha-1))\n",
+    "    return phi\n",
+    "    \n",
+    "\n",
+    "@sj.solved(unknowns={'N': (0.0, 1.0)}, targets=['labor_evo_resid'], solver=\"brentq\")\n",
+    "def labor_evo(N,eta,job_sep):\n",
+    "    \n",
+    "    e =( 1 - N + job_sep(-1)*N(-1))\n",
+    "\n",
+    "    labor_evo_resid  = N - ( job_sep*N(-1) + eta*e)\n",
+    "    \n",
+    "\n",
+    "    return labor_evo_resid\n",
+    "\n",
+    "\n",
+    "@sj.simple\n",
+    "def production(N,Z):\n",
+    "    Y  = Z*N\n",
+    "    return Y\n",
+    "\n",
+    "@sj.solved(unknowns={'B': (0.0, 4.0)}, targets=['fiscal_resid'], solver=\"brentq\")\n",
+    "def fiscal(B,N,qb,G,w):\n",
+    "    \n",
+    "    fiscal_resid = (1 + delta*qb)*B(-1) + G + unemp_insurance*(1-N) - qb*B - (tau_ss +phi_b*qb_ss*(B(-1)-B_ss)/Y_ss)*w*(N)\n",
+    "\n",
+    "    return fiscal_resid\n",
+    "\n",
+    "\n",
+    "@sj.simple\n",
+    "def fiscal_rule(B):\n",
+    "    \n",
+    "    tau = tau_ss + phi_b*qb_ss*(B-B_ss)/Y_ss\n",
+    "    \n",
+    "    return tau\n",
+    "\n",
+    "\n",
+    "@sj.simple\n",
+    "def ex_post_longbonds_rate(qb):\n",
+    "    \n",
+    "    r = (1 + delta * qb)/qb(-1) - 1\n",
+    "\n",
+    "    return r\n",
+    "\n",
+    "@sj.solved(unknowns={'qb': (0.1, 30.0)}, targets=['lbp_resid'], solver=\"brentq\")\n",
+    "def longbonds_price(qb, r_ante):\n",
+    "    lbp_resid = qb - (1 + delta * qb(+1) )/ (1 + r_ante)\n",
+    "    return lbp_resid\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "@sj.simple\n",
+    "def mkt_clearing( C ,w ,N , Y ,G,A,qb,B):\n",
+    "    \n",
+    "    goods_mkt = C  - w*N + G \n",
+    "    asset_mkt = A  - qb*B \n",
+    "\n",
+    "    return goods_mkt,asset_mkt\n",
+    "\n",
+    "@sj.simple\n",
+    "def fisher_clearing(r_ante,pi,i):\n",
+    "    \n",
+    "    fisher_resid = 1 + r_ante - ((1+i)/(1+pi)) \n",
+    "    \n",
+    "    return fisher_resid\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "82ee72db",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/anaconda3/envs/Update_HARK_01_28_2023/lib/python3.9/site-packages/sequence_jacobian/utilities/drawdag.py:98: UserWarning: \n",
+      "Attempted to use `drawdag` when the package `graphviz` has not yet been installed. \n",
+      "DAG visualization tools, i.e. drawdag, will not produce any figures unless this dependency has been installed. \n",
+      "If you want to install, try typing 'conda install -c conda-forge python-graphviz' at the terminal,\n",
+      "or see README for more instructions. Once installed, re-load sequence-jacobian to produce DAG figures.\n"
+     ]
+    }
+   ],
+   "source": [
+    "SteadyState_Dict = SteadyStateDict({ \"asset_mkt\":0.0,\n",
+    "                                         \"goods_mkt\":0.0,\n",
+    "                                    \"arg_fisher_resid\":0.0,\n",
+    "                                    \"lbp_resid\": 0.0,\n",
+    "                                    \"fiscal_resid\":0.0,\n",
+    "                                    \"labor_evo_resid\": 0.0,\n",
+    "                                    \"taylor_resid\": 0.0,\n",
+    "                                    \"nkpc_resid\": 0.0,\n",
+    "                                \n",
+    "                                    \"U\": (1-N_ss),\n",
+    "                                    \"MC\": MC_ss,\n",
+    "                                    \"C\": C_ss,\n",
+    "                                    \"r\": r_ss, \n",
+    "                                    \"r_ante\": r_ss,\n",
+    "                                    \"Y\": Y_ss,\n",
+    "                                    \"B\":B_ss, \n",
+    "                                    \"G\":G_ss, \n",
+    "                                    \"A\": A_ss, \n",
+    "                                    \"tau\": tau_ss,\n",
+    "                                    \"eta\": job_find,\n",
+    "                                    \"N\": N_ss,\n",
+    "                                    \"phi\": phi_ss,\n",
+    "                                    \"v\": v_ss,\n",
+    "                                    \"ev\": 0.0,\n",
+    "                                    \"Z\": Z_ss,\n",
+    "                                    \"job_sep\": job_sep,\n",
+    "                                    \"z\": 0.0,\n",
+    "                                    \"w\":wage_ss,\n",
+    "                                    \"pi\":pi_ss,\n",
+    "                                    \"i\": r_ss,\n",
+    "                                    \"qb\": qb_ss,\n",
+    "                                    'LC': LC_ss,\n",
+    "                             \n",
+    "                       })\n",
+    "\n",
+    "Jacobian_Dict = JacobianDict( { 'C' : {'eta' : CJAC_JF, \n",
+    "                                            'r': CJACR,\n",
+    "                                           'tau': CJAC_tau,\n",
+    "                                           'w': CJACW,\n",
+    "                                           } ,\n",
+    "                                    \n",
+    "                                    'A' : {'eta' : AJAC_JF, 'r': AJACR, \n",
+    "                                          'tau': AJAC_tau,\n",
+    "                                          'w': AJACW,\n",
+    "                                         } } )\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "HANK_SAM = create_model([Jacobian_Dict, \n",
+    "                          fiscal,\n",
+    "                          longbonds_price,\n",
+    "                          ex_post_longbonds_rate,\n",
+    "                          fiscal_rule,\n",
+    "                          wage_,\n",
+    "                          production,\n",
+    "                          labor_evo,\n",
+    "                          matching,\n",
+    "                          taylor,\n",
+    "                          Phillips_Curve,\n",
+    "                          marginal_cost,\n",
+    "                        labor_cost,\n",
+    "\n",
+    "                          unemployment,\n",
+    "                          fisher_clearing,mkt_clearing], name=\"HARK_HANK\")\n",
+    "\n",
+    "unknowns = ['eta', 'r_ante']\n",
+    "targets = ['goods_mkt', 'fisher_resid']\n",
+    "exogenous = ['ev','Z', 'job_sep']\n",
+    "\n",
+    "\n",
+    "sj.drawdag(HANK_SAM)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bba30167",
+   "metadata": {},
+   "source": [
+    "# Plotting Impulse Responses"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "75eb45f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def show_irfs(irfs_list, variables, labels=[\" \"], ylabel=r\"Percentage points (dev. from ss)\", T_plot=50, figsize=(18, 6)):\n",
+    "    if len(irfs_list) != len(labels):\n",
+    "        labels = [\" \"] * len(irfs_list)\n",
+    "    n_var = len(variables)\n",
+    "    fig, ax = plt.subplots(1, n_var, figsize=figsize, sharex=True)\n",
+    "    for i in range(n_var):\n",
+    "        # plot all irfs\n",
+    "        for j, irf in enumerate(irfs_list):\n",
+    "            ax[i].plot(100 * irf[variables[i]][:50], label=labels[j], linewidth = 3.0)\n",
+    "            ax[i].plot(np.zeros(50), color = 'k', linewidth = 1.0)\n",
+    "        ax[i].set_title(variables[i])\n",
+    "        ax[i].set_xlabel(r\"$t$\")\n",
+    "        if i==0:\n",
+    "            ax[i].set_ylabel(ylabel)\n",
+    "        ax[i].legend()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3094ebac",
+   "metadata": {},
+   "source": [
+    "# Monetary Policy Shock"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "7716b399",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "T = 300\n",
+    "\n",
+    "rho_ev = .85\n",
+    "dev = 0.00025 * rho_ev ** np.arange(T)\n",
+    "shocks_ev = {'ev': dev}\n",
+    "\n",
+    "irfs_ev = HANK_SAM.solve_impulse_linear(SteadyState_Dict, unknowns, targets, shocks_ev)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "ef001d89",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1800x600 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABdcAAAIjCAYAAADhtiLRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAADGFUlEQVR4nOzdd3hUddrG8XvS+4R0AoHQA9J7AMGChgV0UVRQFGQRXRds2GBlUWysBcW2L2vfXWVhUURsKGCl9yYdEkJ6Qsqkt5n3D2RwSIAMTDIp3891zQXnOb8zcyfZMnn4zXMMFovFIgAAAAAAAAAAUGMuzg4AAAAAAAAAAEBDQ3MdAAAAAAAAAAA70VwHAAAAAAAAAMBONNcBAAAAAAAAALATzXUAAAAAAAAAAOxEcx0AAAAAAAAAADvRXAcAAAAAAAAAwE401wEAAAAAAAAAsBPNdQAAAAAAAAAA7ERzHQBQ66Kjo3XnnXc6OwYAAAAAAIDD0FwHAAAAAACAw3z99dd66qmnnB0DAGqdwWKxWJwdAgDQuJWWlsrFxUXu7u7OjgIAAACglk2fPl1vvfWWaDkBaOzYuQ4AqHWenp401gEAAIA6VlhY6OwIANCo0VwHAFy0p556SgaDQQcOHNAtt9yigIAABQcH64EHHlBJSYl1HTPXAQAAgNp1+r35vn37dNttt6lZs2YaMmTIBa8rKyvTnDlz1KdPHxmNRvn6+uryyy/XDz/8YLMuISFBBoNBL7/8st5++221a9dOnp6e6tevn7Zs2WJdd+edd+qtt96SJBkMBuvjNLPZrAULFuiyyy6Tl5eXwsPDdc899ygnJ8dB3wkAqDtuzg4AAGj4brnlFkVHR2vevHnauHGjXn/9deXk5Ojf//63s6MBAAAATcrNN9+sDh066Pnnn6/RWBaTyaR3331Xt956q6ZOnar8/Hy99957iouL0+bNm9WzZ0+b9YsWLVJ+fr7uueceGQwGvfjii7rxxht17Ngxubu765577lFKSopWrVql//znP1Ve75577tGHH36oyZMn6/7771d8fLzefPNN7dixQ+vWreMTrwAaFJrrAIBL1qZNG33++eeSpGnTpikgIED/+Mc/9Mgjj6h79+5OTgcAAAA0HT169NCiRYtqvL5Zs2ZKSEiQh4eHtTZ16lTFxMTojTfe0HvvvWezPjExUYcPH1azZs0kSZ06ddIf//hHffvttxo9erRiY2PVsWNHrVq1SrfffrvNtWvXrtW7776rjz/+WLfddpu1fuWVV2rEiBFaunSpTR0A6jvGwgAALtm0adNsju+77z5J0tdff+2MOAAAAECT9ec//9mu9a6urtbGutlsVnZ2tioqKtS3b19t3769yvpx48ZZG+uSdPnll0uSjh07dsHXWrp0qYxGo6655hplZWVZH3369JGfn1+VUTQAUN+xcx0AcMk6dOhgc9yuXTu5uLgoISHBOYEAAACAJqpNmzZ2X/Ovf/1L8+fP14EDB1ReXn7e52rVqpXN8elGe01mph8+fFh5eXkKCwur9nxGRoY9sQHA6WiuAwAc7vc3LAIAAABQd7y9ve1a/9FHH+nOO+/UmDFj9OijjyosLEyurq6aN2+ejh49WmW9q6trtc9Tk/nuZrNZYWFh+vjjj6s9Hxoaald2AHA2musAgEt2+PBhm10tR44ckdlsVnR0tPNCAQAAALigTz75RG3bttWyZctsNsk8+eSTF/2c59ps065dO61evVqDBw+2+x8BAKA+YuY6AOCSvfXWWzbHb7zxhiTpD3/4gzPiAAAAAKih0zvRf7/zfNOmTdqwYcNFP6evr68kKTc316Z+yy23qLKyUs8880yVayoqKqqsB4D6jp3rAIBLFh8fr+uvv14jRozQhg0b9NFHH+m2225Tjx49nB0NAAAAwHmMHj1ay5Yt0w033KBRo0YpPj5eCxcuVJcuXVRQUHBRz9mnTx9J0v3336+4uDi5urpq/PjxGjZsmO655x7NmzdPO3fu1LXXXit3d3cdPnxYS5cu1WuvvaabbrrJkV8eANQqmusAgEu2ZMkSzZkzRzNnzpSbm5umT5+ul156ydmxAAAAAFzAnXfeqbS0NP3zn//Ut99+qy5duuijjz7S0qVL9eOPP17Uc95444267777tHjxYn300UeyWCwaP368JGnhwoXq06eP/vnPf+qvf/2r3NzcFB0drdtvv12DBw924FcGALXPYKnJHScAAKjGU089pblz5yozM1MhISHOjgMAAAAAAFBnmLkOAAAAAAAAAICdGAsDAAAAAADQyJSVlSk7O/u8a4xGo7y9vesoEQA0PjTXAQAAAAAAGpn169fryiuvPO+aDz74QHfeeWfdBAKARoiZ6wAAAAAAAI1MTk6Otm3bdt41l112mZo3b15HiQCg8aG5DgAAAAAAAACAnbihKQAAAAAAAAAAdmLmeh0wm81KSUmRv7+/DAaDs+MAAADAQSwWi/Lz8xUZGSkXF/atNCW8xwcAAGic7HmPT3O9DqSkpCgqKsrZMQAAAFBLTpw4oZYtWzo7BuoQ7/EBAAAat5q8x6e5Xgf8/f0lnfqBBAQEODkNAAAAHMVkMikqKsr6fg9NB+/xAQAAGid73uPTXK8Dpz8mGhAQwBtvAACARoixIE0P7/EBAAAat5q8x2cwJAAAAAAAAAAAdqK5DgAAAAAAAACAnWiuAwAAAAAAAABgJ2auAwAAAAAAAIADVFZWqry83NkxcAHu7u5ydXW95OehuQ4AAAAAAAAAl6igoEBJSUmyWCzOjoILMBgMatmypfz8/C7peWiuAwAAAAAAAMAlqKysVFJSknx8fBQaGiqDweDsSDgHi8WizMxMJSUlqUOHDpe0g53mOgAAAAAAAABcgvLyclksFoWGhsrb29vZcXABoaGhSkhIUHl5+SU117mhKQAAAAAAAAA4ADvWGwZH/ZxorgMAAAAAAAAAYCea6wAAAAAAAAAA2InmOgAAAAAAAADAKaKjo7VgwQLrscFg0PLly52Wxx401wEAAAAAAACgCbrzzjtlMBisj+DgYI0YMUK7d+92WqbU1FT94Q9/cNrr28PN2QEAAAAAAAAAoLEwmy3KKSpzaoZmPh5ycanZTTtHjBihDz74QJKUlpam2bNna/To0UpMTKzNiOcUERHhlNe9GDTXAQAAAAAAAMBBcorK1OfZ1U7NsG32cAX7edZoraenp7WhHRERoZkzZ+ryyy9XZmamQkND9fjjj+uzzz5TUlKSIiIiNGHCBM2ZM0fu7u6SpF27dunBBx/U1q1bZTAY1KFDB/3zn/9U3759JUlr167VrFmztHXrVoWEhOiGG27QvHnz5OvrW20eg8Ggzz77TGPGjFFCQoLatGmjTz/9VG+88YY2bdqkDh06aOHChYqNjbVeY+9rOEqDGwvz1ltvKTo6Wl5eXhowYIA2b9583vVLly5VTEyMvLy81K1bN3399dc25y0Wi+bMmaPmzZvL29tbw4cP1+HDh23WZGdna8KECQoICFBgYKCmTJmigoICh39tAAAAAAAAAOAsBQUF+uijj9S+fXsFBwdLkvz9/fXhhx9q3759eu211/TOO+/o1VdftV4zYcIEtWzZUlu2bNG2bds0c+ZMa+P96NGjGjFihMaOHavdu3dryZIlWrt2raZPn25XrieeeEKPPPKIdu7cqY4dO+rWW29VRUWFQ1/jYjSo5vqSJUs0Y8YMPfnkk9q+fbt69OihuLg4ZWRkVLt+/fr1uvXWWzVlyhTt2LFDY8aM0ZgxY7R3717rmhdffFGvv/66Fi5cqE2bNsnX11dxcXEqKSmxrpkwYYJ+/fVXrVq1Sl9++aV+/vln3X333bX+9QIAAACAJGUXlumnQ5l6Y81hPf3FPmfHAQAAjciXX34pPz8/+fn5yd/fXytWrNCSJUvk4nKqdTx79mwNGjRI0dHRuu666/TII4/of//7n/X6xMREDR8+XDExMerQoYNuvvlm9ejRQ5I0b948TZgwQQ8++KA6dOigQYMG6fXXX9e///1vm/7rhTzyyCMaNWqUOnbsqLlz5+r48eM6cuSIQ1/jYjSo5vorr7yiqVOnavLkyerSpYsWLlwoHx8fvf/++9Wuf+211zRixAg9+uij6ty5s5555hn17t1bb775pqRTu9YXLFig2bNn649//KO6d++uf//730pJSbHekXb//v1auXKl3n33XQ0YMEBDhgzRG2+8ocWLFyslJaWuvnQAAAAATdS24znq/cwqTXp/s+avOqR/b0hQSXmls2MBAIBG4sorr9TOnTu1c+dObd68WXFxcfrDH/6g48ePSzq14Xnw4MGKiIiQn5+fZs+ebTOPfcaMGbrrrrs0fPhw/f3vf9fRo0et53bt2qUPP/zQ2rz38/NTXFyczGaz4uPja5yxe/fu1r83b95ckqwbrh31GhejwcxcLysr07Zt2zRr1ixrzcXFRcOHD9eGDRuqvWbDhg2aMWOGTS0uLs7aOI+Pj1daWpqGDx9uPW80GjVgwABt2LBB48eP14YNGxQYGGidESRJw4cPl4uLizZt2qQbbrihyuuWlpaqtLTUemwymS7qa74URUVFOnDgQJ2/LgAAQH0QExMjHx8fZ8cAHKJThL8MBsliOXVcYbZof6pJvVo1c24wAABQrWY+Hto2e/iFF9Zyhpry9fVV+/btrcfvvvuujEaj3nnnHY0aNUoTJkzQ3LlzFRcXJ6PRqMWLF2v+/PnW9U899ZRuu+02ffXVV/rmm2/05JNPavHixbrhhhtUUFCge+65R/fff3+V123VqlWNM54eMyOdmskuSWazWZIc9hoXo8E017OyslRZWanw8HCbenh4+DmbyGlpadWuT0tLs54/XTvfmrCwMJvzbm5uCgoKsq4527x58zR37twafmW148CBA+rTp49TMwAAADjLtm3b1Lt3b2fHABzCz9NN7UL9dCTjzH2fdifl0VwHAKCecnEx1PhmovWRwWCQi4uLiouLtX79erVu3VpPPPGE9fzpHe2/17FjR3Xs2FEPPfSQbr31Vn3wwQe64YYb1Lt3b+3bt8+mee9odfEa59JgmusNyaxZs2x2zJtMJkVFRdVphpiYGG3btq1OXxMAAKC+iImJcXYEwKG6tzRWaa4DAAA4QmlpqXUTcU5Ojt58800VFBTouuuuk8lkUmJiohYvXqx+/frpq6++0meffWa9tri4WI8++qhuuukmtWnTRklJSdqyZYvGjh0rSXr88cc1cOBATZ8+XXfddZd8fX21b98+rVq1yjq6+1LVxWucS4NproeEhMjV1VXp6ek29fT0dEVERFR7TURExHnXn/4zPT3dOqvn9HHPnj2ta86+YWpFRYWys7PP+bqenp7y9HTuv075+PiwWwsAAABoJLq3MGrZ9mTr8Z7kXOeFAQAAjcrKlSutvVF/f3/FxMRo6dKluuKKKyRJDz30kKZPn67S0lKNGjVKf/vb3/TUU09JklxdXXXy5ElNnDhR6enpCgkJ0Y033mid6tG9e3f99NNPeuKJJ3T55ZfLYrGoXbt2GjdunMPy18VrnIvBYjk9ua/+GzBggPr376833nhD0qm5Oq1atdL06dM1c+bMKuvHjRunoqIiffHFF9baoEGD1L17dy1cuFAWi0WRkZF65JFH9PDDD0s6tcs8LCxMH374ocaPH6/9+/erS5cu2rp1q3XMynfffacRI0YoKSlJkZGRF8xtMplkNBqVl5engIAAR3wrAAAAUA/wPq/pquuf/fbEHN34j/XWYxeDtOepOPl6Npj9UgAANGolJSWKj49XmzZt5OXl5ew4uIDz/bzseZ/XoN6JzZgxQ5MmTVLfvn3Vv39/LViwQIWFhZo8ebIkaeLEiWrRooXmzZsnSXrggQc0bNgwzZ8/X6NGjdLixYu1detWvf3225JOzQ968MEH9eyzz6pDhw5q06aN/va3vykyMlJjxoyRJHXu3FkjRozQ1KlTtXDhQpWXl2v69OkaP358jRrrAAAAAHCpujQPkJuLQRXmU3ujzBbp1xST+rcJcnIyAACApqtBNdfHjRunzMxMzZkzR2lpaerZs6dWrlxpvSFpYmKiXFxcrOsHDRqkRYsWafbs2frrX/+qDh06aPny5eratat1zWOPPabCwkLdfffdys3N1ZAhQ7Ry5Uqbf7H4+OOPNX36dF199dVycXHR2LFj9frrr9fdFw4AAACgSfNyd1XHcH/tSzVZa7uTcmmuAwAAOFGDGgvTUPFxYQAAgMaJ93lNlzN+9jM/3a3FW05Yj6/vEanXb+1VJ68NAADOj7EwDYujxsK4nPcsAAAAAKBe6NbSaHO8OynXOUEAAAAgieY6AAAAADQIPVoG2hwnnCxSXlG5c8IAAIBqMSSkYXDUz4nmOgAAAAA0AB3D/eXhavsr3J7kPCelAQAAv+fq6ipJKisrc3IS1MTpn9Ppn9vFalA3NAUAAACApsrDzUWdIwO060SutbY7OVdDOoQ4LxQAAJAkubm5ycfHR5mZmXJ3d5eLC3ua6yuz2azMzEz5+PjIze3S2uM01wEAAACggejewmjbXD/BznUAAOoDg8Gg5s2bKz4+XsePH3d2HFyAi4uLWrVqJYPBcEnPQ3MdAAAAABqI7mfd1JSxMAAA1B8eHh7q0KEDo2EaAA8PD4d8uoDmOgAAAAA0EN3Puqlpcm6xsgpKFeLn6ZxAAADAhouLi7y8vJwdA3WE5joAAADqNYvFouLySpmKK2QqKZepuPy3P39/XCFTcbnyfjvXp1Uzzbi2k7OjAw7XPsxP3u6uKi6vtNb2JOXpypgwJ6YCAABommiuAwAAoNZZLBYVllUqt6hMeaeb4L/9afuoqHLeVFyuCrPFrtfzcnOtpa8EcC5XF4O6tgjQloQca203zXUAAACnoLkOAACAGjvdJM8pLFNuUblyisqUW1yuvKJTx7nF5cotKlde8Znzeb/V7G2QXwpTSXmdvRZQ17q1CDyruZ7rvDAAAABNGM11AACAJspisaigtELZhWXKLixTTlGZsgvLlVNYpuyiMuUWlSmn8LcGelG5sovKlFdUrrJKs7OjX5CpuMLZEYBa0yPK9qamu5PzZLFYZDAYnJQIAACgaaK5DgAA0EhUmi2/NcjLlFVQquzCMp0sKNPJwjJrwzy7oMy6JqeoTOWVdbeb3FH8Pd0U4O0uf69TfwZ4uSvA2+3Un7/VIozcRAqNV7cWts31zPxSpZlK1Nzo7aREAAAATRPNdQAAgHrq9M7yrIJTzfKTBaXKLChTVn6pThbaNs9PN8stDaBX7mKQjN7u1kfA7/5e3eP0+QAvd/l5ucnVhd25aNqig33l7+Wm/JIzn9DYnZRHcx0AAKCO0VwHAACoQxaLRfmlFcrML1VWfqkyC0qVmX/qkVVQqqyCMp387c+sglKVVtTfESxuLgYF+rgr0MdDzXzcZfT2OHXs7a5AH3cZfTysfw/87ZzRx11+Hm5yoUEOXDQXF4O6tTBq/dGT1trupFzFXRbhxFQAAABND811AAAAByivNCuroFQZplJl5JcqI7/E2jTPPKuJXh8b5h6uLgry9VCQr4ea+bqrmY/Hb49TzfMg31PN8dP1QF93+Xu6MeMZcJLuLQPPaq7nOTENAABA00RzHQAA4DzKK83KzC9VuqlE6aZSZeaf+jMjv0QZ+aXW2snC+jWSJcDLTcF+ngr+rWF+9qOZr4eCfM4c+3i40igHGpDuLW3nru/hpqYAAAB1juY6AABokiwWi0zFFUozlSjNVKL0vBKln/679c9To1rqQ9Pcx8NVIX6eCvbzUIifp0L8PBTs66kgXw8Fn/X3Zj4e8nBzcXZkQJL01ltv6aWXXlJaWpp69OihN954Q/379z/n+qVLl+pvf/ubEhIS1KFDB73wwgsaOXKk9fyyZcu0cOFCbdu2TdnZ2dqxY4d69uxp8xxXXHGFfvrpJ5vaPffco4ULF1qPExMTde+99+qHH36Qn5+fJk2apHnz5snNrWH8inR2cz23qFwnsovVKtjHSYkAAACanobxzhEAAMAOFotFOUXlSsktVlpeiVJNJUrLK1ZqXolSc081zlPzilVS7tzxLP6ebgr191SIv6dC/TwV6n9qp3nI7/4M/a2h7uPB2zY0PEuWLNGMGTO0cOFCDRgwQAsWLFBcXJwOHjyosLCwKuvXr1+vW2+9VfPmzdPo0aO1aNEijRkzRtu3b1fXrl0lSYWFhRoyZIhuueUWTZ069ZyvPXXqVD399NPWYx+fM03nyspKjRo1ShEREVq/fr1SU1M1ceJEubu76/nnn3fgd6D2tAj0VpCvh7ILy6y13cm5NNcBAADqkMFiqQ97sRo3k8kko9GovLw8BQQEODsOAAANnqmkXKm5JUrJLVZybrFS84qV8tvxqcZ5icqcNNfczcWgUH9Phfl7KtTfS6H+nmcevzXQw/w9FeLnKW8PV6dkhOPwPu/8BgwYoH79+unNN9+UJJnNZkVFRem+++7TzJkzq6wfN26cCgsL9eWXX1prAwcOVM+ePW12nUtSQkKC2rRpc86d6z179tSCBQuqzfXNN99o9OjRSklJUXh4uCRp4cKFevzxx5WZmSkPD48Lfm314Wc/6f3N+ulQpvX47qFt9deRnZ2SBQAAoLGw530eW6AAAEC9UlFpVpqpRMk5pxrnKbnFSsk71ThPyS1Wam6J8ksr6jyXh6uLQv09FR7gqTB/r1N/BnhZm+XhAV4K8/dUMx8Pubgw8xgoKyvTtm3bNGvWLGvNxcVFw4cP14YNG6q9ZsOGDZoxY4ZNLS4uTsuXL7f79T/++GN99NFHioiI0HXXXae//e1v1t3rGzZsULdu3ayN9dOvc++99+rXX39Vr169qjxfaWmpSktLrccmk8nuTI7Wo6XRprm+OynXeWEAAACaIJrrAACgTpVWVCo1t0RJOcVKzi1Sck6xknKKlZRbrOScUzvPK811+8G6YF8PhQd4KcJ4qmkeHuCliAAvhRu9FO5/qt7Mx50bBQJ2yMrKUmVlpU0DW5LCw8N14MCBaq9JS0urdn1aWppdr33bbbepdevWioyM1O7du/X444/r4MGDWrZs2Xlf5/S56sybN09z5861K0dt69Yy0OZ4b7JJZrOFf+ADAACoIzTXAQCAQ1VUmpWaV6ITOUVKyi7WiZwincgu0omcYiXlFCkjv+5uEOpikML8vdQ80EvNjV6KCPA+9afRy/pnmL8XN/8EGpm7777b+vdu3bqpefPmuvrqq3X06FG1a9fuop5z1qxZNrvqTSaToqKiLjnrpTj7pqYFpRU6llWo9mF+TkoEAADQtNBcBwAAdrFYLMouLFNidpESs39rnJ9uoucUKSW37naeh/h5qkWglyIDvRUZeKpxHhnobW2eh/p5ys2VxjngDCEhIXJ1dVV6erpNPT09XREREdVeExERYdf6mhowYIAk6ciRI2rXrp0iIiK0efPmKq9zOkN1PD095enpeUk5HC084NSnbdJNZ8bV7E7KpbkOAABQR2iuAwCAKioqzUrJLdHx7EIdP3mqgX78ZJG1oV5QBzPPvdxd1CLQWy2a+ahFoJeaG71/a6J7qcVvDXRPN24ICtRXHh4e6tOnj9asWaMxY8ZIOnVD0zVr1mj69OnVXhMbG6s1a9bowQcftNZWrVql2NjYS8qyc+dOSVLz5s2tr/Pcc88pIyNDYWFh1tcJCAhQly5dLum16lr3loFate/MP0jsTsrTjb1bOjERAABA00FzHQCAJqqswqzE7CIdP1mo+KxTTfSEk6f+TM4trvXd5/5ebmrZzEctAr3Vspn3mT9/+3uQrwczzoEGbsaMGZo0aZL69u2r/v37a8GCBSosLNTkyZMlSRMnTlSLFi00b948SdIDDzygYcOGaf78+Ro1apQWL16srVu36u2337Y+Z3Z2thITE5WSkiJJOnjwoKRTO84jIiJ09OhRLVq0SCNHjlRwcLB2796thx56SEOHDlX37t0lSddee626dOmiO+64Qy+++KLS0tI0e/ZsTZs2rd7tTr+Q7i2MZzXXc50XBgAAoImhuQ4AQCNWWlGpE9lFSsg61Tg/3TyPzypUSm6xarN/7uvhqqggH7Vs5qOoIG9FNfP57fhUAz3Ay732XhxAvTBu3DhlZmZqzpw5SktLU8+ePbVy5UrrzUMTExPl4nJmdNOgQYO0aNEizZ49W3/961/VoUMHLV++XF27drWuWbFihbU5L0njx4+XJD355JN66qmn5OHhodWrV1sb+VFRURo7dqxmz55tvcbV1VVffvml7r33XsXGxsrX11eTJk3S008/XdvfEofrHhVoc/xrikkVlWZGYgEAANQBg8VSV7cUa7pMJpOMRqPy8vIUEBDg7DgAgEbGbLYo1VSi+MxCxWcV6FhWoY5lntqNnpRTVGsNdDcXg1o281ZU0KmmedRZTfRmPu7sPEejx/u8pqu+/OyzC8vU+5lVNrVvHrhcnZvzn0cAAICLYc/7PHauAwDQQOQVl+tYZoGO/tZEj/+tiZ5wslAl5eZaeU1/Lze1DvZR6yBfRQX5qHWwj1oFnXpEBnrL1YXmOQA4U5Cvh1o281ZSTrG1tjspl+Y6AABAHaC5DgBAPXJ6F/qRjAIdzSjQ0czTj0Jl5pfWymuG+HmodbCvooN9FR3so9Yhvmr9WyPd6M3ucwCo73q0DDyruZ6ncf2cGAgAAKCJoLkOAIATlFWYdfxkoQ5nFOhw+pkm+rHMQhWXVzr89UL8PBUd7KPokN8a6MG+ahPiq1bBPsw+B4AGrltLo77ak2o93p2U58Q0AAAATQfNdQAAalFJeaXis0410Y+k559qpmcUKCGrUBUOHobu5+mmNiG+1kfbUF+1DfFTdIiP/GmgA0Cj1b2l0eb4QJpJpRWV8nRzdVIiAACApoHmOgAADlBWYdaxrAIdTMvXofR8HUov0JGMAh0/WejQG4q6uhjUOshHbUP91DbUtpEe6ufJCBcAaIK6trBtrpdXWnQgNV89ogKdEwgAAKCJoLkOAIAdKs0WJWYXWZvoB9PzdSgtX/EO3onu7+mmtmF+ahfqq3ahfmoX6qf2Yb5qFeQrDzcXh70OAKDhC/ByV9tQXx3LLLTWdifn0VwHAACoZTTXAQCohsViUWZBqQ6k5utAmkkHfmumH04vUGmF2WGvEx7gqQ5h/mof5qd2vzXT24f6KdSfXegAgJrr3sJo21w/kSsNbO28QAAAAE0AzXUAQJNXUl6pIxkF2p96qol+IM2kA6n5OllY5rDXaBHorfZhfuoQ5qcO4X5q/1tD3ejNLHQAwKXr3jJQy3emWI/3JHNTUwAAgNpGcx0A0GRYLBZl5pfq1xST9v3WSN+falJ8VqEqHTTSpUWgtzqG+6ljuL86hPurw2870v08+b9cAEDtOfumpofS81VUViEfD/7/BwAAoLbwTgsA0ChVmi2KzyrUryl52pdq0r4Uk/anmpRV4Jjd6CF+HuoY7q+O4f7qFOH/WzPdTwFe7EQHANS9yyKNcjHIehNts0Xal2JS3+gg5wYDAABoxGiuAwAavJLySu1PNVl3pO9LMelAmkkl5Zc+G93b3VWdIvwV89uj42+N9BA/TwckBwDAMbw9XNUx3F8H0vKttd1JeTTXAQAAahHNdQBAg1JYWqH9qSbtSc7T3mST9ibn6UhmgUPGurQO9vmtiR6gzs1P/dkqyEcuLtxYFABQ/3VrYTyruZ7rvDAAAABNAM11AEC9lV9Srl9TTjXQ9ybnaW+KSUczC2S5xD66r4erOjcPsD5imp/ajc5cdABAQ9Y9KlBLtyVZj3dzU1MAAIBaRRcBAFAvFJdV6teUPO1KytOepFztTsrTsazCS37e8ABPdWkeoC6RAbos0qguzdmNDgBonLq3sL2p6bHMQplKyrkfCAAAQC2huQ4AqHNlFWYdSDNpd1Kedv/WSD+Unq9LmexiMEhtQ3xPNdAjA6wNdWajAwCaipjm/nJ3Nai88sz/oe5NztOgdiFOTAUAANB40VwHANQqs9miY1kF2pGYq11JudqTlKf9qfkqq7z4m426uhjUIcxPl0Ua1a1FgLq2MKpz8wD5MtYFANCEebq5KiYiQHt+Nw5mdxLNdQAAgNpCFwIA4FAnC0q180SuzSO/pOKin8/d1aCO4f7qGmlU15ZGdY08NSfdy93VgakBAGgcurc02jTX9yQxdx0AAKC20FwHAFy00opK7UsxaUfimUZ6YnbRRT+fi0HqGO6v7i2N6t4yUN1bGtUpwl+ebjTSAQCoie4tjfp405njXUm5TssCAADQ2NFcBwDUWLqpRNuP52jb8RxtS8zRr8mmSxrv0ibE19pI79HSqMsijfL2oJEOAMDF6t4y0OY4KadY2YVlCvL1cE4gAACARozmOgCgWhWVZh1Iyz/VSP/tkZxbfNHPFx7gqZ5RgeoRFageLQPVtYVRRm93ByYGAAAdwvzk6eai0ooz//i9OylXV3QKc2IqAACAxonmOgBAkpRXXH5mV/rxHO08kavi8sqLei5vd1d1a2lUr6hA9YwKVM9WgWpu9HZwYgAAcDY3VxddFhmg7Ym51tqepDya6wAAALWA5joANFFpeSXanJCtLfHZ2pKQrYPp+bJYLu652of5qWdUoHq1OtVM7xTuLzdXF8cGBgAANdK9ZaBNc313Mjc1BQAAqA001wGgCbBYLDqaWagtvzXTNydkKynn4ka8+Hu6qWerQPVp3Ux9WjdT95aBjHcBAKAe6d7SaHO860SuLBaLDAaDkxIBAAA0TjTXAaARqjRbtD/VpI3HTmpzfLa2Hs9RdmHZRT1XmxBf9W51qpHeu3WgOoT5y9WFX84BAKivzr6paUZ+qZJzi9WymY9zAgEAADRSNNcBoBGoNFu0L+VUM31T/Eltis9WfkmF3c/j4eaini0D1fu3Xem9WwUq2M+zFhIDAIDa0i7UV8183JVTVG6tbUnIprkOAADgYDTXAaABqqg0a1+qSZuOZZ/anZ5wcc30AC839Y0OUr/oIPVv00xdWxjl6eZaC4kBAEBdMRgM6hsdpFX70q21LQk5uqFXSyemAgAAaHxorgNAA2A2W7Q/zaT1R05qw7GT2hKfrfxS+5vpEQFe6tcmSP2jm6lfmyB1DPOXCyNeAABodPpFN7Nprm9NyHZiGgAAgMaJ5joA1EMWi0WJ2UVad+Sk1h3J0oZjJy9qZnrbEF8NaHtqZ3q/6CC1bObNzcwAAGgC+kYH2RwfSi9QblGZAn08nJQIAACg8aG5DgD1RGZ+qdYfzdL6Iye19kiWknOL7X6OtqG+GtAmWAPbBmlg22CFB3jVQlIAAFDfdY00ytPNRaUVZmtt2/EcXd053ImpAAAAGhea6wDgJMVlldp47KR+OZyl9UezdCAt3+7naBvqq4Ftg0892gQpjGY6AADQbzcpjwrUpvgz42C2JNBcBwAAcCSa6wBQRywWiw6m5+vnQ5n6+VCWNsdnq6zSfOELf6d1sI8GtQvRoHbBGtA2SGH+NNMBAED1+kUH2TTXmbsOAADgWDTXAaAW5RSWae2RrFMN9cOZSjeV2nV9iJ+HBrUL0ZD2IRrUPlgtm/nUUlIAANDY9I1uZnO8OylPJeWV8nJ3dVIiAACAxoXmOgA4UKXZop0ncvXToUz9fChTu5JyZbHU/HpfD1cNbBusQe1DNLh9sDqF+3MDUgAAcFF6t24mg0HW9yJllWbtTspT/zZB578QAAAANUJzHQAuUV5xuX4+lKnvD2Tox4MZyikqr/G1ri4G9W4VqCHtQzWkQ7C6twyUu6tLLaYFAABNRYCXuzpHBGhfqsla25KQTXMdAADAQWiuA4CdLBaLjmUV6vv9GVpzIF1bEnJUaa759vQWgd4a2jFUwzqGaFD7EAV4uddiWgAA0JT1i25m01xn7joAAIDjNJjtkdnZ2ZowYYICAgIUGBioKVOmqKCg4LzXlJSUaNq0aQoODpafn5/Gjh2r9PR0mzWJiYkaNWqUfHx8FBYWpkcffVQVFRXW88uWLdM111yj0NBQBQQEKDY2Vt9++22tfI0A6q+yCrPWHs7S3C9+1ZUv/6ir5/+k577er43Hsi/YWPdyd9EVnUI1Z3QXrXl4mNY+fqXm3dhNI7o2p7EOAABqVd9o213qW4/nyGzHpgAAAACcW4PZuT5hwgSlpqZq1apVKi8v1+TJk3X33Xdr0aJF57zmoYce0ldffaWlS5fKaDRq+vTpuvHGG7Vu3TpJUmVlpUaNGqWIiAitX79eqampmjhxotzd3fX8889Lkn7++Wddc801ev755xUYGKgPPvhA1113nTZt2qRevXrVydcOwDnyisv1w4EMfftrmn45nKWC0ooLX/SbjuF+GtYxVMM6hqlvdDNuHAYAAJzi7Jua5pdU6FBGvmIiApyUCAAAoPEwWCz23GrPOfbv368uXbpoy5Yt6tu3ryRp5cqVGjlypJKSkhQZGVnlmry8PIWGhmrRokW66aabJEkHDhxQ586dtWHDBg0cOFDffPONRo8erZSUFIWHh0uSFi5cqMcff1yZmZny8PCoNs9ll12mcePGac6cOTXKbzKZZDQalZeXp4AA3sQC9VlGfolW7UvXyr1p2nD0pCpquLPLw81Fg9oF6+qYMF0ZE6aWzXxqOSkAoD7gfV7T1ZB+9kNe+F5JOcXW42fGdNUdA1s7MREAAED9Zc/7vAaxc33Dhg0KDAy0NtYlafjw4XJxcdGmTZt0ww03VLlm27ZtKi8v1/Dhw621mJgYtWrVytpc37Bhg7p162ZtrEtSXFyc7r33Xv3666/V7kw3m83Kz89XUNC5bwJUWlqq0tJS67HJZDrnWgDOl3iySN/+mqZvf03TtsQc1fSfHMP8PXV15zBdFROuwe2D5ePRIP4nFQAANDH9ooOUlJNsPd6akE1zHQAAwAEaRCcoLS1NYWFhNjU3NzcFBQUpLS3tnNd4eHgoMDDQph4eHm69Ji0tzaaxfvr86XPVefnll1VQUKBbbrnlnHnnzZunuXPnnvdrAuA8FotFB9PztXJvmr79NV37U2v+D2A9Whp1VUy4ru4cpssiA2QwGGoxKQAAwKXrG91Mn+34fXM9x4lpAAAAGg+nNtdnzpypF1544bxr9u/fX0dpLmzRokWaO3euPv/88yrN/t+bNWuWZsyYYT02mUyKioqqi4gAzuNQer6+2JWiL3enKj6rsEbXeLi6aEiHEMVdFq4rY8IU5u9VyykBAAAcq99ZNzVNzi1Wcm6xWgR6OykRAABA4+DU5vrDDz+sO++887xr2rZtq4iICGVkZNjUKyoqlJ2drYiIiGqvi4iIUFlZmXJzc212r6enp1uviYiI0ObNm22uS09Pt577vcWLF+uuu+7S0qVLbUbNVMfT01Oenp7nXQOgbiRkFerL3Sn6YleqDqbn1+gaXw9XXRkTphFdI3RFpzD5eTaID/kAAABUq32onwJ93JVbVG6tbU3IVoueLZyYCgAAoOFzascoNDRUoaGhF1wXGxur3Nxcbdu2TX369JEkff/99zKbzRowYEC11/Tp00fu7u5as2aNxo4dK0k6ePCgEhMTFRsba33e5557ThkZGdad6KtWrVJAQIC6dOlifa7//ve/+tOf/qTFixdr1KhRl/Q1A6h9KbnF+mp3qr7YnaLdSXk1uibI10PXdA5XXNdwDWoXIi9311pOCQAAUDdcXAzq27qZVu8/s2FpS0K2/khzHQAA4JI0iO2YnTt31ogRIzR16lQtXLhQ5eXlmj59usaPH6/IyEhJUnJysq6++mr9+9//Vv/+/WU0GjVlyhTNmDFDQUFBCggI0H333afY2FgNHDhQknTttdeqS5cuuuOOO/Tiiy8qLS1Ns2fP1rRp06w7zxctWqRJkybptdde04ABA6yz2L29vWU0Gp3zDQFQRWZ+qb7Zm6ovdqVoSw3niEYavRTXNUJxl0Wob+tmcnN1qeWUAAAAztE3Osimuc7cdQAAgEvXIJrrkvTxxx9r+vTpuvrqq+Xi4qKxY8fq9ddft54vLy/XwYMHVVRUZK29+uqr1rWlpaWKi4vTP/7xD+t5V1dXffnll7r33nsVGxsrX19fTZo0SU8//bR1zdtvv62KigpNmzZN06ZNs9YnTZqkDz/8sHa/aADnVVJeqW9/TdMn25K07kiWzJYLXxMR4KXR3ZtrdI9I9Whp5IakAACgSegX3czm+GB6vvKKymX0cXdSIgAAgIbPYLFYatCOwqUwmUwyGo3Ky8tTQECAs+MADZrFYtH2xFx9si1JX+5KUX5pxQWvCfb10MhuzXVdj0j1bd1MLi401AEAjsH7vKarof3sSysq1e2p71RWYbbWPrizn66MCXNiKgAAgPrHnvd5DWbnOoCmLTWvWMu2J+vTbUk6llV4wfUBXm76Q9fmGt2juWLbBjPyBQAANGmebq7q2TJQmxOyrbUtCdk01wEAAC4BzXUA9dbvx76sPZKlC33OxsfDVdd2Cdd1PSJ1eYdQebjRUAcAADitb3Qzm+Y6c9cBAAAuDc11APXOrhO5WrzlRI3GvhgM0pD2IbqpT0td2yVC3h6udZQSAACgYenXJkj68aj1eGdSrkorKuXpxvsnAACAi0FzHUC9UFxWqS92p+ijjce1OynvguvbhPjqpj4tdUOvFooM9K6DhAAAAA1b71bNZDDI+mnAsgqz9iTlqW90kHODAQAANFA01wE4VXxWoT7eeFxLtyUpr7j8vGv9Pd00ukdz3dSn5W+/HHJjUgAAgJoyerurU7i/DqTlW2tbEnJorgMAAFwkmusA6lxFpVnfH8jQfzYe1y+Hs867lrEvAAAAjtMvOsimub41IVtSO+cFAgAAaMC42x+AOpOZX6o3vz+soS/+oLv/s+28jfUWgd56+JqOWvf4VfrPlAH6Y88WNNYBAGiA3nrrLUVHR8vLy0sDBgzQ5s2bz7t+6dKliomJkZeXl7p166avv/7a5vyyZct07bXXKjg4WAaDQTt37rQ5n52drfvuu0+dOnWSt7e3WrVqpfvvv195ebZj5wwGQ5XH4sWLHfI112d9o5vZHG89niOz+QJ3jQcAAEC12LkOoNbtOpGrd9fGa+XeVJVXnv+Xt2EdQ3XHwNa6MiZMri6MfQEAoCFbsmSJZsyYoYULF2rAgAFasGCB4uLidPDgQYWFhVVZv379et16662aN2+eRo8erUWLFmnMmDHavn27unbtKkkqLCzUkCFDdMstt2jq1KlVniMlJUUpKSl6+eWX1aVLFx0/flx//vOflZKSok8++cRm7QcffKARI0ZYjwMDAx37DaiH+p01AiavuFxHMgvUMdzfSYkAAAAaLoPFYmGbQi0zmUwyGo3Ky8tTQECAs+MAdcJisejHQ5n6509HtfFY9nnXGr3ddUvflpowoLWiQ3zrKCEAAJeO93nnN2DAAPXr109vvvmmJMlsNisqKkr33XefZs6cWWX9uHHjVFhYqC+//NJaGzhwoHr27KmFCxfarE1ISFCbNm20Y8cO9ezZ87w5li5dqttvv12FhYVyczu1v8hgMOizzz7TmDFjLupra8g/+8F//17JucXW4+du6KoJA1o7MREAAED9Yc/7PMbCAHCo8kqzPtuRpD+89osmf7DlvI31Hi2Neumm7tr016v1xKguNNYBAGhEysrKtG3bNg0fPtxac3Fx0fDhw7Vhw4Zqr9mwYYPNekmKi4s75/qaOv2L0enG+mnTpk1TSEiI+vfvr/fff1/n23dUWloqk8lk82ioqoyGSchxUhIAAICGjbEwAByiqKxCizef0Htr4212Qp3N081F1/eI1O0DW6tHVGDdBQQAAHUqKytLlZWVCg8Pt6mHh4frwIED1V6TlpZW7fq0tLRLyvHMM8/o7rvvtqk//fTTuuqqq+Tj46PvvvtOf/nLX1RQUKD777+/2ueZN2+e5s6de9E56pN+0UH6fGeK9Xhz/Pk/ZQgAAIDq0VwHcEmyCkr17/UJ+vfG48otKj/nujB/T00e3Ea39o9SoI9HHSYEAABNlclk0qhRo9SlSxc99dRTNuf+9re/Wf/eq1cvFRYW6qWXXjpnc33WrFmaMWOGzXNHRUXVSu7advbc9eTcYqXkFisy0NtJiQAAABommusALkriySK988sx/W/rCZVWmM+5rm2or/48tJ3+2CtSnm6udZgQAAA4U0hIiFxdXZWenm5TT09PV0RERLXXRERE2LX+fPLz8zVixAj5+/vrs88+k7u7+3nXDxgwQM8884xKS0vl6elZ5bynp2e19YaoQ5ifArzcZCqpsNa2Hs/R9TTXAQAA7MLMdQB2Sc4t1mOf7NIVL/+g/2w8fs7Geu9WgXr7jj5a/dAw3dIvisY6AABNjIeHh/r06aM1a9ZYa2azWWvWrFFsbGy118TGxtqsl6RVq1adc/25mEwmXXvttfLw8NCKFSvk5eV1wWt27typZs2aNZoG+vm4uBjU96zd61sTGA0DAABgL3auA6iRzPxS/ePHI/p4Y6LKKs+9U3145zDdM6xdlY8bAwCApmfGjBmaNGmS+vbtq/79+2vBggUqLCzU5MmTJUkTJ05UixYtNG/ePEnSAw88oGHDhmn+/PkaNWqUFi9erK1bt+rtt9+2Pmd2drYSExOVknJqZvjBgwclndr1HhERYW2sFxUV6aOPPrK5+WhoaKhcXV31xRdfKD09XQMHDpSXl5dWrVql559/Xo888khdfnucqm90M31/IMN6vIWbmgIAANiN5jqA88orLtc7Px/T++viVVRWWe0ad1eD/tizhe4e2lYdw/3rOCEAAKivxo0bp8zMTM2ZM0dpaWnq2bOnVq5cab1paWJiolxcznyYdtCgQVq0aJFmz56tv/71r+rQoYOWL1+url27WtesWLHC2pyXpPHjx0uSnnzyST311FPavn27Nm3aJElq3769TZ74+HhFR0fL3d1db731lh566CFZLBa1b99er7zyiqZOnVpr34v65uyNEAfSTDKVlCvA6/zjcwAAAHCGwWKxWJwdorEzmUwyGo3Ky8tTQECAs+MANVJUVqEP1ydo4Y9HbeZx/p63u6smDGilKZe3UXMjMzoBAE0P7/Oarob+sy8pr1T3p76z+UTih5P76YpOYU5MBQAA4Hz2vM9j5zoAG6UVlVq8+YTe+P6IsgpKq13j4eqi2wa00rQr2yvUv/HPJQUAAGhsvNxd1SPKaDMOZktCNs11AAAAO9BcByBJqqg067MdyVqw+rCSc4urXeNikMb2bqkHhndQy2Y+dZwQAAAAjtQ3Ouis5jpz1wEAAOxBcx2A1h3J0lMrftXhjIJzrhnVrbkeuqaj2of51WEyAAAA1JZ+0c30f7873nUiV6UVlfJ0c3VaJgAAgIbErua62WzWTz/9pF9++UXHjx9XUVGRQkND1atXLw0fPlxRUVG1lRNALUjLK9GzX+3Tl7tTz7nmik6heuTaTurawliHyQAAAFDb+rSyvalpaYVZe5NN6tO6mZMSAQAANCwuNVlUXFysZ599VlFRURo5cqS++eYb5ebmytXVVUeOHNGTTz6pNm3aaOTIkdq4cWNtZwZwicoqzPrnT0d11fwfz9lY7xfdTP+7J1YfTu5PYx0AAKARMvq4q1O4v01ta0K2k9IAAAA0PDXaud6xY0fFxsbqnXfe0TXXXCN3d/cqa44fP65FixZp/PjxeuKJJzR16lSHhwVw6dYfydKcFb/qyDlGwHRpHqDHRnTSsI6hMhgMdZwOAAAAdalvdDMdTM+3Hm9JyNE9w5wYCAAAoAGpUXP9u+++U+fOnc+7pnXr1po1a5YeeeQRJSYmOiQcAMdJyyvRc1/v1xe7Uqo9H+jjrsfiYjSuX5RcXWiqAwAANAX9ooP08aYzv79tO54ts9kiF94PAgAAXFCNmusXaqz/nru7u9q1a3fRgQA4VnmlWR+uS9CC1YdUWFZZ5bzBII3vF6VH42IU5OvhhIQAAABwlr7RtvPVc4rKdSyrQO3D/M9xBQAAAE6r0cz131u5cqXWrl1rPX7rrbfUs2dP3XbbbcrJyXFoOACXZsPRkxr52i967uv91TbWu7Uwatm9gzTvxu401gEAAJqgls18FGn0sqltjuf3OgAAgJqwu7n+6KOPymQySZL27Nmjhx9+WCNHjlR8fLxmzJjh8IAA7JdXVK4ZS3bq1nc26nA1s9WN3u56dkxXLZ82WL1aNavmGQAAANBU9I0Osjnewk1NAQAAaqRGY2F+Lz4+Xl26dJEkffrppxo9erSef/55bd++XSNHjnR4QAD2WX80Sw//b5dS80qqPT+ub5QeG9FJwX6edZwMAAAA9VG/6GZa8bv78mw4elIWi4Wb2wMAAFyA3c11Dw8PFRUVSZJWr16tiRMnSpKCgoKsO9oB1L3Sikq9/O1Bvbs2XhZL1fOXRQbomTFd1Zud6gAAAPid2HYhNsdpphIdzSxU+zA/JyUCAABoGOxurg8ZMkQzZszQ4MGDtXnzZi1ZskSSdOjQIbVs2dLhAQFc2IE0kx5cvFMH0vKrnPP3ctNjI2J0W/9WcnVh9xEAAABstQv1VUSAl9JMZz75uO5IFs11AACAC7B75vqbb74pNzc3ffLJJ/q///s/tWjRQpL0zTffaMSIEQ4PCODczGaL3v3lmK5/Y121jfVB7YL13UNDdcfA1jTWAQAAUC2DwaDB7W13r689kuWkNAAAAA2H3TvXW7VqpS+//LJK/dVXX3VIIAA1k5JbrEeW7tL6oyernPNwc9FjcZ30p8Ft5EJTHQAAABdweYcQfbo9yXq88ehJVVSa5eZq934sAACAJsPud0rbt2/Xnj17rMeff/65xowZo7/+9a8qKytzaDgA1ft8Z7JGLPi52sZ6TIS/vpg+RHdd3pbGOgAAAGpkUPtgm+P80grtSspzUhoAAICGwe7m+j333KNDhw5Jko4dO6bx48fLx8dHS5cu1WOPPebwgADOyCsq1/3/3aEHFu+UqaTC5pzBIN0ztK0+nz5YnSL8nZQQAAAADVGYv5c6hdu+h1zHaBgAAIDzsru5fujQIfXs2VOStHTpUg0dOlSLFi3Shx9+qE8//dTR+QD8ZtOxk/rDaz9rxa6UKucijV5adNdAzRrZWZ5urk5IBwAAgIaOuesAAAD2sbu5brFYZDabJUmrV6/WyJEjJUlRUVHKyuLNF1Ab/rPxuCa8u0kpeSVVzo3pGalvHhyq2HbB1VwJAAAA1MyQDrbvJ3ck5qiwtOIcqwEAAGD3DU379u2rZ599VsOHD9dPP/2k//u//5MkxcfHKzw83OEBgaasvNKsp7/Yp/9sPF7lXICXm567oZuu6xHphGQAAABobPq3CZabi0EVZoskqbzSos0J2bqyU5iTkwEAANRPdu9cX7BggbZv367p06friSeeUPv27SVJn3zyiQYNGuTwgEBTlVNYponvba62sT64fbC+fWgojXUAAAA4jJ+nm3q1CrSprTvMp5MBAADOxe6d6927d9eePXuq1F966SW5ujLrGXCEw+n5uuvfW3X8ZFGVc9OvbK8Z13SUi4vBCckAAADQmA1uH6ItCTnWY+auAwAAnJvdO9fPxcvLS+7u7o56OqDJ+v5Aum74x/oqjXVPNxe9Nr6nHonrRGMdAAAAteLyDrY3NT2Qlq/M/FInpQEAAKjfHNZcB3BpLBaL/vnTUU3511YVnHXjqPAAT/3vnlj9sWcLJ6UDAABAU9C9ZaD8PG0/4Lz+KLvXAQAAqkNzHagHSsor9fD/dmneNwdksdie69HSqBXTh6hHVKBTsgEAAKDpcHd10cC2QTa1tcxdBwAAqBbNdcDJMvJLdOs7G7VsR3KVc3/sGakl98QqPMDLCckAAADQFA1ubzsaZt2RLFnO3gECAAAA+29oCsBx9ibnaeq/tyo1r8SmbjBIj8Z10r3D2slgYL46AAAA6s6Qs5rrKXklis8qVNtQPyclAgAAqJ/sbq5bLBZ98skn+uGHH5SRkSGz2WxzftmyZQ4LBzRm3/2apvsX71BJue1/h3w9XPXa+F4a3iXcSckAAADQlLUP81OYv6cyfncj03VHsmiuAwAAnMXusTAPPvig7rjjDsXHx8vPz09Go9HmAeDCvt6Tqr98vL1KY71lM28t+8tgGusAAABwGoPBUGX3+tojzF0HAAA4m9071//zn/9o2bJlGjlyZG3kARq9L3al6MElO1Vptp1bOaBNkP7v9j4K8vVwUjIAAADglCEdQmzuCbT+6ElVVJrl5sptuwAAAE6z+52R0WhU27ZtayML0Oh9vjNZDyzeUaWxfkvflvrPlAE01gEAAFAvnH1T0/ySCu1JznNSGgAAgPrJ7ub6U089pblz56q4uLg28gCN1qfbkvTQkp06q6+uibGt9cLY7vJwYxcQAAAA6ofwAC91CLOdsb6O0TAAAAA27O7m3XLLLcrJyVFYWJi6deum3r172zwAVPW/rSf0yCe7qjTW7xwUrbnXXyaDweCcYAAAAMA5nL17nbnrAAAAtuyeuT5p0iRt27ZNt99+u8LDw2kKAhfw382JmrVsT5X6lCFtNHtUZ/47BAAAgHppSPsQfbg+wXq8/Xiuisoq5ONh96+RAAAAjZLd74q++uorffvttxoyZEht5AEalY82Htfs5Xur1O8Z2lYz/xBDYx0AAAD11oC2QXJ1MVjvF1RWadaWhBwN6xjq5GQAAAD1g91jYaKiohQQEFAbWYBG5d8bEqptrP/linY01gEAAFDv+Xu5q2dUoE2NuesAAABn2N1cnz9/vh577DElJCTUQhygcXh/bbzmfP5rlfp9V7XXo3GdaKwDAACgQagyd/0wzXUAAIDT7B4Lc/vtt6uoqEjt2rWTj4+P3N3dbc5nZ2c7LBzQEL37yzE9+9X+KvUHh3fQg8M7OiERAAAAcHEu7xCi19ccth7vSzUpq6BUIX6eTkwFAABQP9jdXF+wYEEtxAAah4U/HdXfvzlQpf7wNR1139UdnJAIAAAAuHg9owLl6+GqwrJKa2390ZO6vkekE1MBAADUD3Y31ydNmlQbOYAG71/rE6ptrD8a10nTrmzvhEQAAADApXF3ddGAtsH6/kCGtbbucBbNdQAAAF1Ec12SKisrtXz5cu3ff2r0xWWXXabrr79erq6uDg0HNBQ/HszQ3C+qzlif9YcY3TOsnRMSAQAAAI4xuH2ITXN97ZEsWSwW7iMEAACaPLub60eOHNHIkSOVnJysTp06SZLmzZunqKgoffXVV2rXjkYimpbD6fm6b9EOmS229dmjOuuuy9s6JxQAAADgIEPOuqlpcm6xjp8sUnSIr5MSAQAA1A8u9l5w//33q127djpx4oS2b9+u7du3KzExUW3atNH9999fGxmBeutkQan+9K8tyi+tsKnff3UHGusAAABoFDqG+1W5genaI1lOSgMAAFB/2N1c/+mnn/Tiiy8qKCjIWgsODtbf//53/fTTTw4NB9RnpRWV+vNH23Qiu9imPqp7cz3IzUsBAADQSBgMBg1pH2xTW0dzHQAAwP7muqenp/Lz86vUCwoK5OHh4ZBQQH1nsVj012V7tSUhx6beo6VR82/uIRcX5k8CAACg8RjSIdTmeP3Rk6o8ey4iAABAE2N3c3306NG6++67tWnTJlksFlksFm3cuFF//vOfdf3119dGRqDeWfjTMX26Pcmm1tzopXcm9pWXOzf2BQAAQOMy+Kyd63nF5dqbnOekNAAAAPWD3c31119/Xe3atVNsbKy8vLzk5eWlwYMHq3379nrttddqI6MkKTs7WxMmTFBAQIACAwM1ZcoUFRQUnPeakpISTZs2TcHBwfLz89PYsWOVnp5usyYxMVGjRo2Sj4+PwsLC9Oijj6qioqLa51u3bp3c3NzUs2dPR31ZaIC+/TVNL357wKbm7e6qdyb2VViAl5NSAQAAALWnudFb7UJtb2DK3HUAANDUudmz2GKxyGQyafHixUpOTtb+/fslSZ07d1b79u1rJeBpEyZMUGpqqlatWqXy8nJNnjxZd999txYtWnTOax566CF99dVXWrp0qYxGo6ZPn64bb7xR69atkyRVVlZq1KhRioiI0Pr165WamqqJEyfK3d1dzz//vM1z5ebmauLEibr66qurNOjRdOxNztODi3fK8rtPwBoM0oLxPdW1hdF5wQAAAIBaNqR9iI5mFlqP1x3J0rQra/f3QAAAgPrMYLFYajwoz2w2y8vLS7/++qs6dKi7Gzbu379fXbp00ZYtW9S3b19J0sqVKzVy5EglJSUpMjKyyjV5eXkKDQ3VokWLdNNNN0mSDhw4oM6dO2vDhg0aOHCgvvnmG40ePVopKSkKDw+XJC1cuFCPP/64MjMzbWbIjx8/Xh06dJCrq6uWL1+unTt31ji/yWSS0WhUXl6eAgICLuE7AWfKMJXoj2+tU2peiU195h9i9Odh7ZyUCgAAOBPv85qupviz/+7XNN39n23WYw9XF+168lp5ezAWEQAANB72vM+zayyMi4uLOnTooJMnT15SQHtt2LBBgYGB1sa6JA0fPlwuLi7atGlTtdds27ZN5eXlGj58uLUWExOjVq1aacOGDdbn7datm7WxLklxcXEymUz69ddfrbUPPvhAx44d05NPPlmjvKWlpTKZTDYPNGwl5ZWa+u+tVRrrN/dpqXuGtnVSKgAAAKDuDGwXLBfDmeOySrO2Hs92XiAAAAAns3vm+t///nc9+uij2rt3b23kqVZaWprCwsJsam5ubgoKClJaWto5r/Hw8FBgYKBNPTw83HpNWlqaTWP99PnT5yTp8OHDmjlzpj766CO5udVsis68efNkNBqtj6ioqBpdh/rJYrHokaW7tCvJ9oZN/aOD9NwN3WQwGM5xJQAAANB4BHi5q0dUoE2NuesAAKAps7u5PnHiRG3evFk9evSQt7e3goKCbB72mDlzpgwGw3kfBw4cuPAT1ZLKykrddtttmjt3rjp27Fjj62bNmqW8vDzr48SJE7WYErVtwerD+nJ3qk2tVZCPFt7RRx5udv9XCAAAAGiwhrQPsTleR3MdAAA0YXbd0FSSFixY4LAXf/jhh3XnnXeed03btm0VERGhjIwMm3pFRYWys7MVERFR7XUREREqKytTbm6uze719PR06zURERHavHmzzXWnb1YaERGh/Px8bd26VTt27ND06dMlnZo7b7FY5Obmpu+++05XXXVVldf29PSUp6fneb8uNAwrdqXotTWHbWr+nm56b1JfBfl6nOMqAAAAoHEa0j5Eb3x/xHr8a4pJ2YVlvDcGAABNUo223c6YMUOFhafuCt+mTRtNmDBBkyZNqvZhj9DQUMXExJz34eHhodjYWOXm5mrbtjM3z/n+++9lNps1YMCAap+7T58+cnd315o1a6y1gwcPKjExUbGxsZKk2NhY7dmzx6Zxv2rVKgUEBKhLly4KCAjQnj17tHPnTuvjz3/+szp16qSdO3ee87XROPyakqdHlu6yqbkYpDcn9FaHcH8npQIAAGhY3nrrLUVHR8vLy0sDBgyosrnlbEuXLlVMTIy8vLzUrVs3ff311zbnly1bpmuvvVbBwcEyGAzauXNnlecoKSnRtGnTFBwcLD8/P40dO9a6iea0xMREjRo1Sj4+PgoLC9Ojjz6qioqKS/56G7terZrJ2/3MDUwtFmn9UXavAwCApqlGzfU33nhDBQUFkqQrr7xS2dl1e9Oazp07a8SIEZo6dao2b96sdevWafr06Ro/frwiIyMlScnJyYqJibG+WTcajZoyZYpmzJihH374Qdu2bdPkyZMVGxurgQMHSpKuvfZadenSRXfccYd27dqlb7/9VrNnz9a0adPk6ekpFxcXde3a1eYRFhYmLy8vde3aVb6+vnX6fUDdKSmv1Iwlu1RWYbapP3ndZRrWMdRJqQAAABqWJUuWaMaMGXryySe1fft29ejRQ3FxcVU+lXra+vXrdeutt2rKlCnasWOHxowZozFjxtjc76mwsFBDhgzRCy+8cM7Xfeihh/TFF19o6dKl+umnn5SSkqIbb7zRer6yslKjRo1SWVmZ1q9fr3/961/68MMPNWfOHMd98Y2Uh5uLBrS1HQf6w4FMJ6UBAABwrhqNhYmOjtbrr7+ua6+9VhaLRRs2bFCzZs2qXTt06FCHBjzt448/1vTp03X11VfLxcVFY8eO1euvv249X15eroMHD6qoqMhae/XVV61rS0tLFRcXp3/84x/W866urvryyy917733KjY2Vr6+vpo0aZKefvrpWvka0HC8suqQDqbn29TuGNhakwZFOycQAABAA/TKK69o6tSpmjx5siRp4cKF+uqrr/T+++9r5syZVda/9tprGjFihB599FFJ0jPPPKNVq1bpzTff1MKFCyVJd9xxhyQpISGh2tfMy8vTe++9p0WLFllHOH7wwQfq3LmzNm7cqIEDB+q7777Tvn37tHr1aoWHh6tnz5565pln9Pjjj+upp56Sh0fVESelpaUqLS21HptMpov/xjRwV3QM1Y8HzzTUfziYoUqzRa4uBiemAgAAqHsGi8ViudCi5cuX689//rMyMjJkMBh0rksMBoMqKysdHrKhM5lMMhqNysvLU0BAgLPj4AI2HTup8e9s1O//Y96leYCWTxvMDUwBAIAN3uedW1lZmXx8fPTJJ59ozJgx1vqkSZOUm5urzz//vMo1rVq10owZM/Tggw9aa08++aSWL1+uXbtsx/UlJCSoTZs22rFjh3r27Gmtf//997r66quVk5Njc++l1q1b68EHH9RDDz2kOXPmaMWKFTYjZeLj49W2bVtt375dvXr1qpLtqaee0ty5c6vUm+LP/kR2kS5/8Qeb2id/jlXf6KBzXAEAANBw2PMev0adwjFjxigtLU0mk0kWi0UHDx5UTk5OlUddj4sBHK2gtEIPL91l01j3cHXRq+N60lgHAACwQ1ZWliorKxUeHm5TDw8PV1paWrXXpKWl2bX+XM/h4eFh01g/+3nO9Tqnz1Vn1qxZysvLsz5OnDhR40yNTVSQj2IibO9BtHp/9aN+AAAAGrMajYU5zc/PTz/88IPatGkjNze7LgUahGe+2KeknGKb2iNxHdUpghuYAgAANGWenp7y9PR0dox64+rOYTqQdmaM4ur96Zr5hxgnJgIAAKh7dm/FHTZsGI11NEqr96VryVbbHUj9o4M0ZUhbJyUCAABouEJCQuTq6qr09HSbenp6uiIiIqq9JiIiwq7153qOsrIy5ebmnvN5zvU6p8/hwq7ubLvz/0hGgRKyCp2UBgAAwDmYcwFIOllQqpnLdtvUfD1cNf+WHtyYCQAA4CJ4eHioT58+WrNmjbVmNpu1Zs0axcbGVntNbGyszXpJWrVq1TnXV6dPnz5yd3e3eZ6DBw8qMTHR+jyxsbHas2ePMjLOjDJZtWqVAgIC1KVLlxq/VlPWs2WgQvxsb/y6en/6OVYDAAA0TmxBR5NnsVj0xGd7lVVQZlOfc10XRQX5OCkVAABAwzdjxgxNmjRJffv2Vf/+/bVgwQIVFhZq8uTJkqSJEyeqRYsWmjdvniTpgQce0LBhwzR//nyNGjVKixcv1tatW/X2229bnzM7O1uJiYlKSUmRdKpxLp3acR4RESGj0agpU6ZoxowZCgoKUkBAgO677z7FxsZq4MCBkqRrr71WXbp00R133KEXX3xRaWlpmj17tqZNm8bolxpycTHoqpgw/W9rkrW2Zn+G7rqcT30CAICmg53raPI+25Gslb/a3rhqeOcw3dI3ykmJAAAAGodx48bp5Zdf1pw5c9SzZ0/t3LlTK1eutN48NDExUampqdb1gwYN0qJFi/T222+rR48e+uSTT7R8+XJ17drVumbFihXq1auXRo0aJUkaP368evXqpYULF1rXvPrqqxo9erTGjh2roUOHKiIiQsuWLbOed3V11ZdffilXV1fFxsbq9ttv18SJE/X000/X9rekURl+1miYzQnZyisqd1IaAACAumewWCwWZ4do7Ewmk4xGo/Ly8hQQEODsOPidlNxixb36s/JLK6y1IF8PffvgUIX6s2sJAACcH+/zmi5+9lJRWYV6Pr1KZRVma+218T31x54tnJgKAADg0tjzPs9hO9f/8Y9/sNMDDYrZbNGjn+yyaaxL0nNjutJYBwAAAC7Ax8NNQ9qH2NRW7884x2oAAIDGx2HN9U8//VQffviho54OqHX/2pCgdUdO2tRu7NVCf+jW3EmJAAAAgIbl6s5hNsc/HsxQeaX5HKsBAAAaF7ub6ydOnKi2vmbNGh07duySAwF14UhGgf7+zQGbWnOjl568/jInJQIAAAAanqtjbOeu55dUaEt8tpPSAAAA1C27m+vR0dEaNmyY3nnnHeXk5NRGJqBWlVeaNeN/O1VaYbuj5uWbe8jo7e6kVAAAAEDDE2H0UrcWRpsao2EAAEBTYXdzfevWrerfv7+efvppNW/eXGPGjNEnn3yi0tLS2sgHONw/fjiq3Ul5NrU7B0Vr8FnzIgEAAABc2PDOtrvXV+9Pl8VicVIaAACAumN3c71Xr1566aWXlJiYqG+++UahoaG6++67FR4erj/96U+1kRFwmN1JuXr9+8M2tbahvnp8RIyTEgEAAAAN29lz1xOzi3Qko8BJaQAAAOrORd/Q1GAw6Morr9Q777yj1atXq02bNvrXv/7lyGyAQ5VWVOqhJTtVaT6zi8bVxaBXb+kpbw9XJyYDAAAAGq7LIgPU3OhlU1u1P91JaQAAAOrORTfXk5KS9OKLL6pnz57q37+//Pz89NZbbzkyG+BQ/15/XEczC21q069srx5Rgc4JBAAAADQCBoOhyu71NcxdBwAATYCbvRf885//1KJFi7Ru3TrFxMRowoQJ+vzzz9W6devayAc4RE5hmd44axxMtxZGTb+qvZMSAQAAAI3H8M7h+mhjovV4e2KOsgpKFeLn6cRUAAAAtcvunevPPvusBgwYoG3btmnv3r2aNWsWjXXUe6+tOSxTSYVN7ek/XiZ314v+8AYAAACA3wxsGyyf341atFikHw6wex0AADRudu9cT0xMlMFgqI0sQK04llmgjzYet6ld3yNSvVo1c1IiAAAAoHHxcnfV0A6hWvlrmrW2Zn+Gbu4b5cRUAAAAtcvubbsGg0G//PKLbr/9dsXGxio5OVmS9J///Edr1651eEDgUs375oAqfncTUw83Fz02opMTEwEAAACNz9lz138+nKmS8konpQEAAKh9djfXP/30U8XFxcnb21s7duxQaWmpJCkvL0/PP/+8wwMCl2LjsZNatS/dpvanwW3UspmPkxIBAAAAjdNVMWH6/Yeci8oqtfHYSecFAgAAqGUXNXN94cKFeuedd+Tu7m6tDx48WNu3b3doOOBSmM0WPfvVPptakK+H/nJlOyclAgAAABqvYD9P9T5r9OLq/ennWA0AANDw2d1cP3jwoIYOHVqlbjQalZub64hMgEN8tiNZe5NNNrWHrumoAC/3c1wBAAAA4FIM7xxuc7xmf4YsFss5VgMAADRsdjfXIyIidOTIkSr1tWvXqm3btg4JBVyq4rJKvfTtQZta+zA/3dqPGyoBAAAAtWX4WXPXU/NK9GuK6RyrAQAAGja7m+tTp07VAw88oE2bNslgMCglJUUff/yxHnnkEd177721kRGw27u/HFOaqcSm9teRMXJztfs/8gAAAABqqH2Yn1oF2d7faM3+DCelAQAAqF1u9l4wc+ZMmc1mXX311SoqKtLQoUPl6empRx55RPfdd19tZATskpFfov/76ahNbUj7EF3ZKewcVwAAAABwBIPBoOGdw/X+unhrbfX+dD0wvIMTUwEAANQOu7fxGgwGPfHEE8rOztbevXu1ceNGZWZm6plnnqmNfIDdXvnukIrKKq3HBoP015GdZTAYnJgKAAAAaBrOHg2zJzlPaXkl51gNAADQcF30jAwPDw916dJF/fv3l5+fnyMzARftQJpJ/9t6wqZ2c5+W6hIZ4KREAAAAQNPSr02Q/L1sPyS95kC6k9IAAADUnhqNhbnxxhtr/ITLli276DDApXruq/0yW84c+3i46uFrOzkvEAAAANDEuLu66IpOYfpiV4q1tmZ/hiYMaO3EVAAAAI5Xo53rRqPR+ggICNCaNWu0detW6/lt27ZpzZo1MhqNtRYUuJAfD2bol8NZNrV7hrZTeICXkxIBAAAATdPZo2HWHslSUVmFk9IAAADUjhrtXP/ggw+sf3/88cd1yy23aOHChXJ1dZUkVVZW6i9/+YsCAhi9AeeoqDTrua/229TCAzw1dWgbJyUCAAAAmq4rOobJ1cWgyt8+VlpWYdbaw1m69rIIJycDAABwHLtnrr///vt65JFHrI11SXJ1ddWMGTP0/vvvOzQcUFNLtp7Q4YwCm9oj13aSj0eN/v0IAAAAgAMZfdzVPzrIprZ6P3PXAQBA42J3c72iokIHDhyoUj9w4IDMZrNDQgH2yC8p16urDtnULosM0NjeLZ2UCAAAAMDVZ42G+f5Ahsy/v0ESAABAA2f3tt7JkydrypQpOnr0qPr37y9J2rRpk/7+979r8uTJDg8IXMjCn44qq6DMpvbEqM5ycTE4KREAAACAa7qE69nfjW7MKijTzqRc9W7VzImpAAAAHMfu5vrLL7+siIgIzZ8/X6mpqZKk5s2b69FHH9XDDz/s8IDA+STnFuvdX+JtasM7h2lQuxAnJQIAAAAgSa2DfdU+zE9Hfje+cc3+dJrrAACg0bB7LIyLi4see+wxJScnKzc3V7m5uUpOTtZjjz1mM4cdqAsvf3tQpRVnxhG5uRg0a2RnJyYCAAAAcNrwzuE2x2v2ZzgpCQAAgOPZ3Vz/vYCAAAUEBDgqC2CX4ycLtXxnsk1twoBWahfq56REAAAAAH5v+Flz1w+k5etEdpGT0gAAADhWjZrrI0aM0MaNGy+4Lj8/Xy+88ILeeuutSw4GXMh7a+Nl+d39kPw83fTA8I7OCwQAAADARq9WzRTk62FT+3J3qpPSAAAAOFaNZq7ffPPNGjt2rIxGo6677jr17dtXkZGR8vLyUk5Ojvbt26e1a9fq66+/1qhRo/TSSy/Vdm40cTmFZVq6NcmmdtuAVlXeuAMAAABwHlcXg+IuC9d/N5+w1r7YlaJ7r2jnxFQAAACOUaPm+pQpU3T77bdr6dKlWrJkid5++23l5eVJkgwGg7p06aK4uDht2bJFnTsz7xq17+NNx1VcXmk9dnMx6M5B0c4LBAAAAKBa1/WItGmu70s16UhGgdqHMc4RAAA0bDVqrkuSp6enbr/9dt1+++2SpLy8PBUXFys4OFju7u61FhA4W0l5pT5cf9ymNrp7c0UGejspEQAAAIBzGdAmWGH+nsrIL7XWvtiVooeuYaQjAABo2C76hqZGo1ERERE01lHnVuxMUVZBqU3trsvbOikNAAAAgPNxdTFoVPfmNrUvdqXI8vsbKAEAADRAF91cB5zBYrHonV+O2dQGtw9W1xZGJyUCAAAAcCHX9Yi0OT6WVahfU0xOSgMAAOAYNNfRoPx4KFOHMwpsauxaBwAAAOq3XlGBatnMdozjF7tSnJQGAADAMWiuo0F552fbXesdwvx0RcdQJ6UBAAAAUBMGg6HK7vUvd6fKbGY0DAAAaLhorqPB2Jucp/VHT9rUpl7eVgaDwUmJAAAAANTU9Wc115Nzi7U9McdJaQAAAC6d3c31EydOKCkpyXq8efNmPfjgg3r77bcdGgw427tnzVoP8fPUH3tFnmM1AAAAgPokJsJf7cP8bGqMhgEAAA2Z3c312267TT/88IMkKS0tTddcc402b96sJ554Qk8//bTDAwKSlJJbrC92p9rU7hzUWp5urk5KBAAAAMAeBoOhyu71r/akqqLS7KREAAAAl8bu5vrevXvVv39/SdL//vc/de3aVevXr9fHH3+sDz/80NH5AEnSh+sTVPm7eYze7q6aMKC1ExMBAAAAsNfZc9ezCsq08Vi2k9IAAABcGrub6+Xl5fL09JQkrV69Wtdff70kKSYmRqmpqee7FLgoppJyLdqUaFO7pW9LNfP1cFIiAAAAABejTYivurUw2tRW7Ep2UhoAAIBLY3dz/bLLLtPChQv1yy+/aNWqVRoxYoQkKSUlRcHBwQ4PCCzZfEIFpRXWY4NB+tOQNk5MBAAAAOBiXdejuc3xyr1pKq2odFIaAACAi2d3c/2FF17QP//5T11xxRW69dZb1aNHD0nSihUrrONiAEcprzTrg3XxNrURl0WodbCvkxIBAAAAuBSju9uOhjGVVOjnQ1lOSgMAAHDx3Oy94IorrlBWVpZMJpOaNWtmrd99993y9aXhCcf6ek+qUvJKbGp3Xd7WSWkAAAAAXKrIQG/1i26mLQk51tqKXSm6pku4E1MBAADYz+6d61dddZXy8/NtGuuSFBQUpHHjxjksGGCxWPTOL8dsan1aN1Of1s3OcQUAAACAhuD6s25sunpfuorKKs6xGgAAoH6yu7n+448/qqysrEq9pKREv/zyi0NCAZK04dhJ7U022dSmXs6sdQAAAKCh+0O35nJ1MViPi8srtXp/hhMTAQAA2K/GY2F2795t/fu+ffuUlpZmPa6srNTKlSvVokULx6ZDk/bOz7a71lsH++iaLhFOSgMAAADAUUL8PDWoXbB+OXxm1voXu1Kq7GgHAACoz2rcXO/Zs6cMBoMMBoOuuuqqKue9vb31xhtvODQcmq7D6fn64WCmTW3KkDY2u1sAAAAANFzX9Yi0aa7/dDBTecXlMnq7OzEVAABAzdW4uR4fHy+LxaK2bdtq8+bNCg0NtZ7z8PBQWFiYXF1dayUkmp53f4m3OQ70cddNfVo6KQ0AAAAAR4u7LEKzP9urskqzJKms0qxvf03TLX2jnJwMAACgZmrcXG/durUkyWw211oYQJIy8kv02Y5km9odA1vLx6PG/3EFAAAAUM8Zvd01rFOoVu1Lt9a+2JVCcx0AADQYF9WtPHz4sH744QdlZGRUabbPmTPHIcHQdP1nw3Hr7hVJ8nB10R2xrZ2YCAAAAEBtuL5HpE1zfd2RLGUVlCrEz9OJqQAAAGrGxd4L3nnnHXXu3Flz5szRJ598os8++8z6WL58eS1ERFNSVFah/2w8blO7oVcLhfl7OSkRAAAALsVbb72l6OhoeXl5acCAAdq8efN51y9dulQxMTHy8vJSt27d9PXXX9uct1gsmjNnjpo3by5vb28NHz5chw8ftp7/8ccfrfeKOvuxZcsWSVJCQkK15zdu3Oj4bwDO6+rOYfJ2PzNe1GyRvt6T6sREAAAANWd3c/3ZZ5/Vc889p7S0NO3cuVM7duywPrZv314bGdGEfLotSblF5Ta1uy5v46Q0AAAAuBRLlizRjBkz9OSTT2r79u3q0aOH4uLilJGRUe369evX69Zbb9WUKVO0Y8cOjRkzRmPGjNHevXuta1588UW9/vrrWrhwoTZt2iRfX1/FxcWppKREkjRo0CClpqbaPO666y61adNGffv2tXm91atX26zr06dP7X0zUC0fDzdd0yXcpvbFrhQnpQEAALCP3c31nJwc3XzzzbWRBU2cxWLRRxsTbWpXdgpVh3B/JyUCAADApXjllVc0depUTZ48WV26dNHChQvl4+Oj999/v9r1r732mkaMGKFHH31UnTt31jPPPKPevXvrzTfflHTq/eKCBQs0e/Zs/fGPf1T37t3173//WykpKdZP0Xp4eCgiIsL6CA4O1ueff67JkyfLYDDYvF5wcLDNWnd391r9fqB61/WItDnekpCj5NxiJ6UBAACoObub6zfffLO+++672shyXtnZ2ZowYYICAgIUGBioKVOmqKCg4LzXlJSUaNq0aQoODpafn5/Gjh2r9PR0mzWJiYkaNWqUfHx8FBYWpkcffVQVFRU2a0pLS/XEE0+odevW8vT0VHR09Dl/IcDF25dq0sH0fJvalCFtnZQGAAAAl6KsrEzbtm3T8OHDrTUXFxcNHz5cGzZsqPaaDRs22KyXpLi4OOv6+Ph4paWl2awxGo0aMGDAOZ9zxYoVOnnypCZPnlzl3PXXX6+wsDANGTJEK1asOO/XU1paKpPJZPOAYwztGKIAL9vbgX21m93rAACg/rP7hqbt27fX3/72N23cuFHdunWrsrvj/vvvd1i435swYYJSU1O1atUqlZeXa/Lkybr77ru1aNGic17z0EMP6auvvtLSpUtlNBo1ffp03XjjjVq3bp0kqbKyUqNGjVJERITWr1+v1NRUTZw4Ue7u7nr++eetz3PLLbcoPT1d7733ntq3b6/U1NQqN3LFpftse7LNcYtAbw1qF+ykNAAAALgUWVlZqqysVHi47ciP8PBwHThwoNpr0tLSql2flpZmPX+6dq41Z3vvvfcUFxenli1bWmt+fn6aP3++Bg8eLBcXF3366acaM2aMli9fruuvv77a55k3b57mzp17nq8YF8vTzVUjukbof1uTrLUVu1J099B2TkwFAABwYXY3199++235+fnpp59+0k8//WRzzmAw1Epzff/+/Vq5cqW2bNlinZP4xhtvaOTIkXr55ZcVGRlZ5Zq8vDy99957WrRoka666ipJ0gcffKDOnTtr48aNGjhwoL777jvt27dPq1evVnh4uHr27KlnnnlGjz/+uJ566il5eHho5cqV+umnn3Ts2DEFBQVJkqKjox3+NTZ1lWaLPj9rtuIfe0bKxcVwjisAAACA80tKStK3336r//3vfzb1kJAQzZgxw3rcr18/paSk6KWXXjpnc33WrFk215hMJkVFRdVO8Cbo+h4tbJrre5NNOpZZoLahfk5MBQAAcH52j4WJj48/5+PYsWO1kVEbNmxQYGCgzQ2Ihg8fLhcXF23atKnaa7Zt26by8nKbj4zGxMSoVatW1o+MbtiwQd26dbPZ+RIXFyeTyaRff/1V0qmPkfbt21cvvviiWrRooY4dO+qRRx5RcfG5ZwDykVH7rTuSpcz8UpvaDb1aOCkNAAAALlVISIhcXV2rjGVMT09XREREtddEREScd/3pP2v6nB988IGCg4PP2TD/vQEDBujIkSPnPO/p6amAgACbBxxnYNsghfh52NS+2JXqpDQAAAA1Y3dz3RnS0tIUFhZmU3Nzc1NQUNA5P/6ZlpYmDw8PBQYG2tTP/lhpdR8pPX1Oko4dO6a1a9dq7969+uyzz7RgwQJ98skn+stf/nLOvPPmzZPRaLQ+2NFyYZ/tsB0J07VFADcyBQAAaMA8PDzUp08frVmzxlozm81as2aNYmNjq70mNjbWZr0krVq1yrq+TZs2ioiIsFljMpm0adOmKs9psVj0wQcfWMc+XsjOnTvVvHnzGn99cCw3VxeN6mb7/V+xK1kWi8VJiQAAAC6sRmNhZsyYoWeeeUa+vr42H4WsziuvvFLjF585c6ZeeOGF867Zv39/jZ+vNpjNZhkMBn388ccyGo2STn2NN910k/7xj3/I29u7yjV8ZNQ+haUVWrnX9h9JbujV8hyrAQAA0FDMmDFDkyZNUt++fdW/f38tWLBAhYWF1puLTpw4US1atNC8efMkSQ888ICGDRum+fPna9SoUVq8eLG2bt2qt99+W9KpMZQPPvignn32WXXo0EFt2rTR3/72N0VGRmrMmDE2r/39998rPj5ed911V5Vc//rXv+Th4aFevXpJkpYtW6b3339f7777bi1+N3Ah1/WI1L82HLceH80s1P7UfHWJ5FMCAACgfqpRc33Hjh0qLy+3/v1cDAb75mM//PDDuvPOO8+7pm3btoqIiFBGRoZNvaKiQtnZ2ef9SGlZWZlyc3Ntdq+f/bHSzZs321x3+iOmp9c0b95cLVq0sDbWJalz586yWCxKSkpShw4dqry2p6enPD09z/t14Yzv9qWpuLzSeuzqYtD1ParO0QcAAEDDMm7cOGVmZmrOnDlKS0tTz549tXLlSuunRRMTE+XicubDtIMGDdKiRYs0e/Zs/fWvf1WHDh20fPlyde3a1brmscceU2Fhoe6++27l5uZqyJAhWrlypby8vGxe+7333tOgQYMUExNTbbZnnnlGx48fl5ubm2JiYrRkyRLddNNNtfBdQE31btVMLQK9lZx7ZgTnF7tTaK4DAIB6y2BpAJ+z279/v7p06aKtW7eqT58+kqTvvvtOI0aMUFJS0jlvaBoaGqr//ve/Gjt2rCTp4MGDiomJ0YYNGzRw4EB98803Gj16tFJTU61jZ95++209+uijysjIkKenp95++209+OCDysjIkJ/fqZvpfP7557rxxhtVUFBQ7c71s5lMJhmNRuXl5TGbsRp3vLdJvxzOsh5f0SlUH07u78REAAAANcP7vKaLn33tmPf1fv3z5zP38moR6K1fHrtSLi72beQCAAC4WPa8z7ukmetJSUlKSkq68MJL1LlzZ40YMUJTp07V5s2btW7dOk2fPl3jx4+3NtaTk5MVExNj3YluNBo1ZcoUzZgxQz/88IO2bdumyZMnKzY2VgMHDpQkXXvtterSpYvuuOMO7dq1S99++61mz56tadOmWXee33bbbQoODtbkyZO1b98+/fzzz3r00Uf1pz/9qUaNdZxfhqlE645k2dS4kSkAAADQNF131idYk3OLtf7oSSelAQAAOD+7m+tms1lPP/20jEajWrdurdatWyswMFDPPPOMzGZzbWSUJH388ceKiYnR1VdfrZEjR2rIkCHW2YuSVF5eroMHD6qoqMhae/XVVzV69GiNHTtWQ4cOVUREhJYtW2Y97+rqqi+//FKurq6KjY3V7bffrokTJ+rpp5+2rvHz89OqVauUm5urvn37asKECbruuuv0+uuv19rX2pSs2JUi8+8+O+Hr4apru1Q/6gcAAABA43ZZZIA6hfvb1P67JdFJaQAAAM7P7rEws2bN0nvvvae5c+dq8ODBkqS1a9fqqaee0tSpU/Xcc8/VStCGjI+MntvI137RvlST9Xhs75aaf0sPJyYCAACoOd7nNV387GvPB+viNfeLfdZjd1eDNs66WsF+3NcKAADUvlodC/Ovf/1L7777ru699151795d3bt311/+8he98847+vDDDy82M5qgg2n5No11SbqxNyNhAAAAgKbshl4t5Ol25lfV8kqLPt1e++NIAQAA7GV3cz07O1sxMTFV6jExMcrOznZIKDQNy3bYvkEOD/DUwLbBTkoDAAAAoD4I9PHQyG7NbWqLN5+QnR+6BgAAqHV2N9d79OihN998s0r9zTffVI8ejPNAzZjNFn2+I8WmNqZnC7m6GJyUCAAAAEB9cWv/VjbHx7IKtSmezVwAAKB+cbP3ghdffFGjRo3S6tWrFRsbK0nasGGDTpw4oa+//trhAdE4bTx2UmmmEpvaDYyEAQAAACCpX3QztQv11dHMQmvtv5sT+aQrAACoV+zeuT5s2DAdOnRIN9xwg3Jzc5Wbm6sbb7xRBw8e1OWXX14bGdEILduRbHPcuXmAYiK4ERQAAAAAyWAwVNm9/s3eNOUUljkpEQAAQFV271yXpMjISD333HOOzoImorisUt/sSbWp3dAr0klpAAAAANRHN/ZuqRdXHlRZpVmSVFZh1rIdyZoypI2TkwEAAJxyUc31nJwcvffee9q/f78kqUuXLpo8ebKCgoIcGg6N06r96Sosq7QeuxikP/ZkJAwAAACAM4J8PRTXNUJf7Dpzr6bFmxP1p8HRMhi4VxMAAHA+u8fC/Pzzz4qOjtbrr7+unJwc5eTk6PXXX1ebNm30888/10ZGNDKfbU+yOR7cPkThAV5OSgMAAACgvrq1X5TN8eGMAm07nuOkNAAAALbs3rk+bdo0jRs3Tv/3f/8nV1dXSVJlZaX+8pe/aNq0adqzZ4/DQ6LxyMwv1c+Hs2xqN/Ri1zoAAACAqga2DVZ0sI8SThZZa//dfEJ9o/nUNAAAcD67d64fOXJEDz/8sLWxLkmurq6aMWOGjhw54tBwaHy+2JWiSrPFeuzt7qq4yyKcmAgAAABAfeXiYtC4frY3Nv1qT4ryisudlAgAAOAMu5vrvXv3ts5a/739+/erR48eDgmFxmv5zmSb47jLwuXreVGj/wEAAAA0ATf1aSk3lzMz1kvKzfr8rN8rAAAAnMHurub999+vBx54QEeOHNHAgQMlSRs3btRbb72lv//979q9e7d1bffu3R2XFA3ekYwC7U7Ks6nd0Lulk9IAAAAAaAhC/T11TZdwfbM3zVpbtClRdwxszY1NAQCAU9ndXL/11lslSY899li15wwGgywWiwwGgyorKy89IRqNz3bY3sg01N9Tg9sFOykNAAAAgIbi1v6tbJrrB9LytSspTz2jAp0XCgAANHl2N9fj4+NrIwcaObPZouU7Umxq1/eIlJur3ZOJAAAAADQxQ9qHqGUzbyXlFFtr/92USHMdAAA4ld3N9datW9dGDjRyWxKylZxbbFO7oVcLJ6UBAAAA0JC4uBg0vl+UXv7ukLX2xe4UzR7dWf5e7k5MBgAAmjK2DaNOfLbD9oZDHcP9dFlkgJPSAAAAAGhobu4bJdff3di0qKxSK3alnOcKAACA2kVzHbWupLxSX+1Jtand0KslNx8CAAAAUGPhAV66KibMprZ48wknpQEAAKC5jjqwZn+G8ksqrMcGg/THnpFOTAQAAACgIbq1f5TN8Z7kPO1NznNSGgAA0NTRXEetO3skzMA2wYoM9HZSGgAAAAAN1bCOYWpu9LKp/XdzopPSAACApu6imuu5ubl69913NWvWLGVnZ0uStm/fruTk5AtciaYmu7BMPx7MsKnd0JsbmQIAAACwn6uLQbf0td29/vnOFBWWVpzjCgAAgNpjd3N99+7d6tixo1544QW9/PLLys3NlSQtW7ZMs2bNcnQ+NHBf7UlVhdliPfZ0c9EfukY4MREAAACAhuyWflH63X1NVVBaoa92p577AgAAgFpid3N9xowZuvPOO3X48GF5eZ35ON7IkSP1888/OzQcGr7V+9Jtjq/pEi5/L3cnpQEAAADQ0LUI9NawjqE2tf9uYTQMAACoe3Y317ds2aJ77rmnSr1FixZKS0tzSCg0DsVlldpw7KRN7Q9dmzspDQAAAIDG4tb+rWyOdyTm6kCayUlpAABAU2V3c93T01MmU9U3LYcOHVJoaGg1V6Cp2nAsS2UVZuuxq4tBQzqEODERAAAAgMbgqpgwhfl72tQWbz7hpDQAAKCpsru5fv311+vpp59WeXm5JMlgMCgxMVGPP/64xo4d6/CAaLh+OJBpc9yndTMZvRkJAwAAAODSuLm6VLmx6bLtSSopr3RSIgAA0BTZ3VyfP3++CgoKFBYWpuLiYg0bNkzt27eXv7+/nnvuudrIiAbIYrHoh4MZNrUrO4U5KQ0AAACAxmZcP9vmuqmkQl/v4camAACg7rjZe4HRaNSqVau0du1a7d69WwUFBerdu7eGDx9eG/nQQB3NLFBSTrFN7coYxgYBAAAAcIyoIB9d3iFEvxzOstb+teG4bujVQgaDwYnJAABAU2F3c/20IUOGaMiQIY7Mgkbk7JEwzY1e6hTu76Q0AAAAABqj2/q3smmu7zqRqy0JOerfJsiJqQAAQFNhd3P99ddfr7ZuMBjk5eWl9u3ba+jQoXJ1db3kcGi4zh4Jc0WnMHaPAAAAAHCoa7qEq0Wgt5Jzz3xq9u2fj9JcBwAAdcLu5vqrr76qzMxMFRUVqVmzZpKknJwc+fj4yM/PTxkZGWrbtq1++OEHRUVFXeDZ0Bjll5RrS0K2Te2KToyEAQAAAOBYbq4umjKkjZ7+cp+1tnp/ho5k5Kt9GJ+cBQAAtcvuG5o+//zz6tevnw4fPqyTJ0/q5MmTOnTokAYMGKDXXntNiYmJioiI0EMPPVQbedEArDtyUuWVFuuxu6tBg9uHODERAAAAgMZqXL8oGb3dbWrv/BzvpDQAAKApsbu5Pnv2bL366qtq166dtda+fXu9/PLLmjVrllq2bKkXX3xR69atc2hQNBw/njUSpn+bIPl5XvR4fwAAAAA4J19PN90+sJVN7bMdycrIL3FSIgAA0FTY3VxPTU1VRUVFlXpFRYXS0tIkSZGRkcrPz7/0dGhwLBZLlXnrV3YKc1IaAAAAAE3BpEHR8nA98+ttWaVZ/1qf4LxAAACgSbC7uX7llVfqnnvu0Y4dO6y1HTt26N5779VVV10lSdqzZ4/atGnjuJRoMPan5ivdVGpTu4LmOgAAAIBaFObvpRt6tbCpfbQxUYWlVTeGAQAAOIrdzfX33ntPQUFB6tOnjzw9PeXp6am+ffsqKChI7733niTJz89P8+fPd3hY1H9n71qPCvJWu1BfJ6UBAAAA0FRMHWq7wSuvuFxLtpxwUhoAANAU2D0IOyIiQqtWrdKBAwd06NAhSVKnTp3UqVMn65orr7zScQnRoJw9b/3KTmEyGAxOSgMAAACgqWgf5q/hncO0ev+Z30neWxuvibGt5eZq974yAACAC7rou0zGxMQoJibGkVnQwOUVlWvb8RybGvPWAQAAANSVu4e2s2muJ+cW66s9qfpjzxbnuQoAAODiXFRzPSkpSStWrFBiYqLKyspszr3yyisOCYaG5+fDmTJbzhx7urloYNtg5wUCAAAA0KT0i26mnlGB2nki11p7++djur5HJJ+oBQAADmd3c33NmjW6/vrr1bZtWx04cEBdu3ZVQkKCLBaLevfuXRsZ0UCcPW89tl2wvD1cnZQGAAAAQFNjMBh0z9C2uvfj7dbarykmrT96UoPbhzgxGQAAaIzsHjw3a9YsPfLII9qzZ4+8vLz06aef6sSJExo2bJhuvvnm2siIBsBstuing5k2NUbCAAAAAKhr114WoehgH5vaP38+5qQ0AACgMbO7ub5//35NnDhRkuTm5qbi4mL5+fnp6aef1gsvvODwgGgY9iTn6WSh7YggmusAAAAA6pqri0FTLm9rU/v5UKb2p5qclAgAADRWdjfXfX19rXPWmzdvrqNHj1rPZWVlOS4ZGpSzR8K0DfVVq7N2iwAAAABAXbipd0sF+XrY1N75hd3rAADAsexurg8cOFBr166VJI0cOVIPP/ywnnvuOf3pT3/SwIEDHR4QDcMPjIQBAAAAUE94e7jqjoGtbWordqYoNa/YSYkAAEBjZHdz/ZVXXtGAAQMkSXPnztXVV1+tJUuWKDo6Wu+9957DA6L+yyoo1e6kXJsazXUAAAAAzjQxtrU83c78ylthtuiDdQnOCwQAABodN3svaNv2zOw6X19fLVy40KGB0PD8fChTFsuZYx8PV/Vr08x5gQAAAAA0ecF+nrq5b0t9tDHRWlu0KVHTr2qvAC93JyYDAACNhd0719u2bauTJ09Wqefm5to03tF0nD0SZnD7EHm6uTopDQAAAACccteQtjIYzhwXlFbov5sSz30BAACAHexurickJKiysrJKvbS0VMnJyQ4JhYajotKsnw8xbx0AAABA/RMd4qsRl0XY1D5Yl6CyCrOTEgEAgMakxmNhVqxYYf37t99+K6PRaD2urKzUmjVrFB0d7dBwqP92nshVXnG5Te2KTqFOSgMAAAAAtu4e2lbf7E2zHqeZSrRiV4pu6tPSiakAAEBjUOPm+pgxYyRJBoNBkyZNsjnn7u6u6OhozZ8/36HhUP/9cDDD5jgmwl+Rgd5OSgMAAAAAtnq1aqb+0UHanJBtrb3z8zGN7d1Cht/PjAEAALBTjcfCmM1mmc1mtWrVShkZGdZjs9ms0tJSHTx4UKNHj67NrKiHfjhgOxLmCkbCAAAA4HfeeustRUdHy8vLSwMGDNDmzZvPu37p0qWKiYmRl5eXunXrpq+//trmvMVi0Zw5c9S8eXN5e3tr+PDhOnz4sM2a6OhoGQwGm8ff//53mzW7d+/W5ZdfLi8vL0VFRenFF190zBeMeunuobb3BzuYnq8fzxpvCQAAYC+7Z67Hx8crJCSkNrKggUnLK9G+VJNN7UpGwgAAAOA3S5Ys0YwZM/Tkk09q+/bt6tGjh+Li4pSRkVHt+vXr1+vWW2/VlClTtGPHDo0ZM0ZjxozR3r17rWtefPFFvf7661q4cKE2bdokX19fxcXFqaSkxOa5nn76aaWmplof9913n/WcyWTStddeq9atW2vbtm166aWX9NRTT+ntt9+unW8EnO6qmDC1C/W1qb3z8zEnpQEAAI2FwWKxWOy9aM2aNVqzZo11B/vvvf/++w4L11iYTCYZjUbl5eUpICDA2XEcZsmWRD3+6R7rsb+Xm7b/7Rq5u9r9bzYAAAANUmN9n+coAwYMUL9+/fTmm29KOvVp2KioKN13332aOXNmlfXjxo1TYWGhvvzyS2tt4MCB6tmzpxYuXCiLxaLIyEg9/PDDeuSRRyRJeXl5Cg8P14cffqjx48dLOrVz/cEHH9SDDz5Yba7/+7//0xNPPKG0tDR5eHhIkmbOnKnly5frwIEDNfra+Nk3PIs3J2rmsj02tS+mD1G3lsZzXAEAAJoie97n2d0FnTt3rq699lqtWbNGWVlZysnJsXmg6Th7JMzQDqE01gEAACBJKisr07Zt2zR8+HBrzcXFRcOHD9eGDRuqvWbDhg026yUpLi7Ouj4+Pl5paWk2a4xGowYMGFDlOf/+978rODhYvXr10ksvvaSKigqb1xk6dKi1sX76dQ4ePHjO32lKS0tlMplsHmhYxvRqoRA/T5vagtWHnJQGAAA0BjW+oelpCxcu1Icffqg77rijNvKggSirMGvtkSyb2hWMhAEAAMBvsrKyVFlZqfDwcJt6eHj4OXeHp6WlVbs+LS3Nev507VxrJOn+++9X7969FRQUpPXr12vWrFlKTU3VK6+8Yn2eNm3aVHmO0+eaNWtWJdu8efM0d+7cC37dqL+83F01eXC0Xvr2oLW25kCGtiZkq290kBOTAQCAhsrubcZlZWUaNGhQbWRBA7L1eLYKSitsasNorgMAAKAemDFjhq644gp1795df/7znzV//ny98cYbKi0tvejnnDVrlvLy8qyPEydOODAx6sqkQdEK9vWwqb347UFdxLRUAAAA+5vrd911lxYtWlQbWdCA/HjQdiRMtxZGhfl7OSkNAAAA6puQkBC5uroqPT3dpp6enq6IiIhqr4mIiDjv+v9v797jm6zPPo5/k7TpCZpSCj1wLFApiIAWKEWQIX1EQSfqNkAUVAbbHlAOnhVB9rAxz4pzoE7BbTAcm7LJFGWo6LCAFBBBQA6FAqUHKG1pS0/J/fxRCE1bkGjbu00/79crryTXfd/Jlf5Af7345fqdu/fmNaXK3u8VFRU6dOjQRd+n6ntUFxAQoNDQUI8bmp4WAX6aOqybR2xzWq7Wf5tzgSsAAAAuzOvieklJiZ5//nkNHTpU9957r2bNmuVxQ/PwyZ5sj+fDWLUOAACAKux2uxISErRu3Tp3zOVyad26dUpKSqr1mqSkJI/zJWnt2rXu82NjYxUVFeVxTkFBgTZt2nTB15Sk7du3y2q1qm3btu73+eyzz1ReXu7xPt27d6+1JQx8y/iBHdUuLMgj9syHe+VysXodAAB4x+ue6zt27FDfvn0lSTt37vQ4ZrFY6iQpNG5Hcou1L7vQI/aj+LYmZQMAAIDGatasWZo4caL69eunAQMG6MUXX1RRUZHuvvtuSdKECRPUrl07LViwQJI0ffp0DR06VM8995xGjRqlFStWaMuWLXrttdckVf6+MWPGDM2fP19xcXGKjY3VE088oZiYGI0ePVpS5WalmzZt0rBhw9SyZUulpKRo5syZuuOOO9yF89tvv13z5s3TpEmT9PDDD2vnzp166aWX9MILLzT8DwkNLsDPpunJcXro7zvcsV0ZBXp/53Hd2DvGxMwAAEBT43Vx/ZNPPqmPPNCEfFrtK5Otgv3Vp32YOckAAACg0RozZoxycnI0Z84cZWZmqm/fvlqzZo1789D09HRZree/TDto0CAtX75cs2fP1mOPPaa4uDitWrVKvXr1cp/z0EMPqaioSFOmTFFeXp4GDx6sNWvWKDCwskVhQECAVqxYoSeffFKlpaWKjY3VzJkzPb5l63A49NFHH2nq1KlKSEhQRESE5syZoylTpjTQTwZmu/XKdnp1/QEdyClyx5776FuNuDxK/javv+ANAACaKYvxPXdu2b9/vw4cOKBrrrlGQUFBMgyDlesXUFBQIIfDofz8fJ/ozThp6ZdaV6UtzOi+MXpx7JUmZgQAAGAOX5vn4dIx9k3fB18f16+WbfWILbj1Co0b0NGkjAAAQGPgzTzP63+SP3nypIYPH67LLrtMI0eO1PHjxyVJkyZN0v333//9MkaTUVLu1IYDJzxiw2gJAwAAAKCJub5XlHq3d3jEXvrPPpWUO03KCAAANDVeF9dnzpwpf39/paenKzg42B0fM2aM1qxZU6fJofH58lCuSspd7ucWi3RNHJuZAgAAAGhaLBaLHhoR7xHLLCjRn1MOm5QRAABoarwurn/00Ud66qmn1L59e494XFycDh9mEuLrthw65fG8d/swtQqxm5QNAAAAAHx/g+MiNKhra4/YHz7dr9Ml5SZlBAAAmhKvi+tFRUUeK9bPyc3NVUBAQJ0kVZvc3FyNHz9eoaGhCgsL06RJk1RYWHjRa0pKSjR16lS1bt1aLVq00G233aasrCyPc9LT0zVq1CgFBwerbdu2evDBB1VRUeFxzrJly9SnTx8FBwcrOjpa99xzj06ePFnnn7Ep2JruWVwf0LmVSZkAAAAAwA/34IjuHs9PFZfr9c/TTMoGAAA0JV4X14cMGaI//elP7ucWi0Uul0tPP/20hg0bVqfJVTV+/Hjt2rVLa9eu1erVq/XZZ59pypQpF71m5syZeu+997Ry5UqtX79eGRkZuvXWW93HnU6nRo0apbKyMn3xxRd66623tHTpUs2ZM8d9zoYNGzRhwgRNmjRJu3bt0sqVK7V582ZNnjy53j5rY+V0GdqWnucRS+hEcR0AAABA03Vlx1a6rmekR+yNzw/qZGGpSRkBAICmwmIYhuHNBTt37tTw4cN11VVX6eOPP9aPf/xj7dq1S7m5udqwYYO6du1a50nu3r1bPXv21Jdffql+/fpJktasWaORI0fq6NGjiomJqXFNfn6+2rRpo+XLl+snP/mJJGnPnj3q0aOHUlJSNHDgQH3wwQe68cYblZGRocjIysnU4sWL9fDDDysnJ0d2u13PPvusFi1apAMHDrhf++WXX9ZTTz2lo0ePXlL+3uww25jtPl6gG1763CO2+bHhahsaaFJGAAAA5vKVeR68x9j7lm+zTmvEi5+p6m/H91wdqzk39TQvKQAAYApv5nler1zv1auXvv32Ww0ePFg333yzioqKdOutt2rbtm31UliXpJSUFIWFhbkL65KUnJwsq9WqTZs21XpNamqqysvLlZyc7I7Fx8erY8eOSklJcb/uFVdc4S6sS9KIESNUUFCgXbt2SZKSkpJ05MgRvf/++zIMQ1lZWfr73/+ukSNHXjDf0tJSFRQUeNx8Qephz5YwHcKDKKwDAAAAaPIui2ypW65s5xH7y8bDOpZ3xqSMAABAU+D3fS5yOBx6/PHH6zqXC8rMzFTbtm09Yn5+fgoPD1dmZuYFr7Hb7QoLC/OIR0ZGuq/JzMz0KKyfO37umCRdffXVWrZsmcaMGaOSkhJVVFTopptu0iuvvHLBfBcsWKB58+Z59Rmbgq3ViusJHWkJAwAAAMA3zEy+TO99laFyZ+Xy9TKnSy/951s9/ZM+JmcGAAAaK69Xri9ZskQrV66sEV+5cqXeeustr17rkUcekcViuehtz5493qZYp7755htNnz5dc+bMUWpqqtasWaNDhw7pl7/85QWvefTRR5Wfn+++HTlypAEzrj+p1TYzpd86AAAAAF/RITxY4xM7ecT+nnpU+7MLTcoIAAA0dl6vXF+wYIFeffXVGvG2bdtqypQpmjhx4iW/1v3336+77rrroud06dJFUVFRys7O9ohXVFQoNzdXUVFRtV4XFRWlsrIy5eXleaxez8rKcl8TFRWlzZs3e1yXlZXlPiZVft6rr75aDz74oCSpd+/eCgkJ0ZAhQzR//nxFR0fXeO+AgAAFBARc9HM1NTmnS3X4ZLFH7CqK6wAAAAB8yNRh3fS3LUdUXOaUJLkM6fm1e/WH8QkmZwYAABojr1eup6enKzY2tka8U6dOSk9P9+q12rRpo/j4+Ive7Ha7kpKSlJeXp9TUVPe1H3/8sVwulxITE2t97YSEBPn7+2vdunXu2N69e5Wenq6kpCRJlf3Uv/76a4/C/dq1axUaGqqePSs3rikuLpbV6vljstlskiQv94Jt0rZWW7UeYrepe2RLk7IBAAAAgLrXpmWA7rna8/fd97/O1I6jeeYkBAAAGjWvi+tt27bVjh07asS/+uortW7duk6Sqq5Hjx66/vrrNXnyZG3evFkbNmzQtGnTNHbsWMXExEiSjh07pvj4ePdKdIfDoUmTJmnWrFn65JNPlJqaqrvvvltJSUkaOHCgJOm6665Tz549deedd+qrr77Shx9+qNmzZ2vq1Knulec33XST3nnnHS1atEgHDx7Uhg0bdN9992nAgAHu924Oqvdb79sxTH42r//4AAAAAECjNvmaLnIE+XvEnvlwr0nZAACAxszr6ui4ceN033336ZNPPpHT6ZTT6dTHH3+s6dOna+zYsfWRoyRp2bJlio+P1/DhwzVy5EgNHjxYr732mvt4eXm59u7dq+Li861LXnjhBd1444267bbbdM011ygqKkrvvPOO+7jNZtPq1atls9mUlJSkO+64QxMmTNCvf/1r9zl33XWXnn/+ef3+979Xr1699NOf/lTdu3f3eJ3mIJXNTAEAAAA0A44gf/3qR109Yp/vO6EvDpwwKSMAANBYWQwve5uUlZXpzjvv1MqVK+XnV9my3eVyacKECVq8eLHsdnu9JNqUFRQUyOFwKD8/X6GhoWan47XSCqeuePIjlVW43LGld/fXj7q3NTErAAAA8zX1eR6+P8bet50pc2roM58o+3SpO9a3Q5je/d9BslgsJmYGAADqmzfzPK9WrhuGoczMTC1dulR79+7VsmXL9M477+jAgQN68803Kaz7qF0ZBR6FdUm6kpXrAAAAAHxUkN2m+4bHecS2H8nTv77KMCkjAADQGPl5c7JhGOrWrZt27dqluLg4xcXFffdFaPKq91u/LLJFjR6EAAAAAOBLxvTvoNc/P6jDJ8+3Hp3/790aFt9WoYH8PgQAALxcuW61WhUXF6eTJ0/WVz5ohGr0W+/EqnUAAAAAvs3fZtVjI3t4xHJOl+o5NjcFAABneb2h6e9+9zs9+OCD2rlzZ33kg0bGMAxtqVZcv4qWMAAAAACaget6RuraeM+9pv688bC+PppvUkYAAKAx8bq4PmHCBG3evFl9+vRRUFCQwsPDPW7wLUdPnVFOlU18JFauAwAAAGgeLBaL5v34cgX6n//V2WVIs1d9LafLMDEzAADQGHjVc12SXnzxxXpIA43V1nTPVeutgv0VGxFiUjYAAAAA0LA6hAfr3mvj9EyVdjBfHc3X8s3punNgJxMzAwAAZvO6uD5x4sT6yAONVG391i0Wi0nZAAAAAEDD+/mQWP1j61EdzClyx55es0fXXx6lNi0DTMwMAACYyeu2MJJ04MABzZ49W+PGjVN2drYk6YMPPtCuXbvqNDmYr3px/SpawgAAAABoZgL8bJp/cy+P2OmSCi14f7dJGQEAgMbA6+L6+vXrdcUVV2jTpk165513VFhYKEn66quvNHfu3DpPEOYpKq3Q7uMFHrEENjMFAAAA0AwN6hah0X1jPGLvbDumlAMnTcoIAACYzevi+iOPPKL58+dr7dq1stvt7vi1116rjRs31mlyMNf2I3mqukePn9Wi3u3DTMsHAAAAAMz0+Kieahno2V31iX/uVFmFy6SMAACAmbwurn/99de65ZZbasTbtm2rEydO1ElSaByqt4S5PCZUQXabSdkAAAAAgLnatAzQQyO6e8T2Zxfq9c8PmpQRAAAwk9fF9bCwMB0/frxGfNu2bWrXrl2dJIXGoeZmpuEmZQIAAAAAjcPtiZ3Uu73DI/byx/t0JLfYpIwAAIBZvC6ujx07Vg8//LAyMzNlsVjkcrm0YcMGPfDAA5owYUJ95AgTuFyGtqZXL67Tbx0AAABA82azWjR/dC9ZLOdjJeUuzXtvl3lJAQAAU3hdXP/tb3+r+Ph4dejQQYWFherZs6euueYaDRo0SLNnz66PHGGC/TmFOl1S4RG7qlOYOckAAAAAQCPSu32Y7hzYySP2n93Z+mhXpkkZAQAAM3hdXLfb7Xr99dd18OBBrV69Wn/5y1+0Z88e/fnPf5bNRj9uX1G9JUy7sCBFO4JMygYAAAAAGpf7r+uuiBYBHrF5732j4rKKC1wBAAB8zSUX110ul5566ildffXV6t+/v1555RUNGzZMP/vZzxQXF1efOcIE1YvrV9ESBgAAAADcHEH+mj2qh0fsWN4ZvbRun0kZAQCAhnbJxfXf/OY3euyxx9SiRQu1a9dOL730kqZOnVqfucFEW6tvZtoxzJxEAAAAAKCRurlvjAZ1be0Re+PzNO3NPG1SRgAAoCFdcnH9T3/6k/7whz/oww8/1KpVq/Tee+9p2bJlcrlc9ZkfTJBbVKaDJ4o8Ygmdwk3KBgAAAAAaJ4vFol/f3Ev+tvO7m1a4DD2xaqcMwzAxMwAA0BAuubienp6ukSNHup8nJyfLYrEoIyOjXhKDeaqvWg/ytyk+uqVJ2QAAAABA49WtbQv94pquHrHNh3L1j63HTMoIAAA0lEsurldUVCgwMNAj5u/vr/Ly8jpPCuZKTfcsrvfp4JC/zeu9bwEAAACgWZg6rJvatwryiM3/9zfKKigxKSMAANAQ/C71RMMwdNdddykg4Pxu6CUlJfrlL3+pkJAQd+ydd96p2wzR4KpvZprAZqYAAAAAcEFBdpt+ffPlumfpFncsr7hc9//tK/3pngGyWi0XuRoAADRVl1xcnzhxYo3YHXfcUafJwHzlTpe+OpLnEaO4DgAAAAAXd218pEb1jta/dxx3x/67/4Te+G+aJl/TxcTMAABAfbnk4vqSJUvqMw80Et9kFKi0wnOT2is7UFwHAAAAgO/ym9G9lHrolDKrtIN5+sM9GtSttS6PcZiYGQAAqA800oaH6i1hurYJUasQu0nZAAAAAEDTERZs1/Nj+shSpQtMudPQfX/dpjNlTvMSAwAA9YLiOjxU38yUljAAAAAAcOkGdY3QL67p6hE7kFOk37z/jUkZAQCA+kJxHR62spkpAAAAAPwgs/7nMl3RzrMNzF82pmvtN1kmZQQAAOoDxXW4ZeSd0fH8Eo8YxXUAAAAA8I7dz6oXx/ZVkL/NI/7wP3You6DkAlcBAICmhuI63Kr3W3cE+atLRAuTsgEAAACApqtrmxaac1NPj1huUZnuX/mVXC7DpKwAAEBdorgOt+rF9as6hslqtVzgbAAAAADAxYzt30EjLo/0iH2+74SWfHHInIQAAECdorgOt61sZgoAAAAAdcZiseh3t/ZWZGiAR/ypD/bom4wCk7ICAAB1heI6JEnFZRXaVW1ydxXFdQAAAAD4QVqF2PX8z/rKUuVLwWVOl6av2KaScqd5iQEAgB+M4jokSTuO5stZpe+fzWpRn/Zh5iUEAAAAAD7i6m4RmjKki0dsX3ahfvv+bpMyAgAAdYHiOiTV7LfeI7qlQgL8TMoGAAAAAHzL/dd11+UxoR6xP6Uc1rrdWSZlBAAAfiiK65Akba1WXE/oSEsYAAAAAKgrdj+rXhp7pQL9PX8Nf+jvO5R9usSkrAAAwA9BcR0yDEOp1TYzpd86AAAAANStbm1b6Ikbe3rEThaV6cGVO+Sq0qYTAAA0DRTXoYMnipRXXO4RS6C4DgAAAAB17vYBHfU/PSM9Yuu/zdEb/00zKSMAAPB9UVxHjX7rkaEBahcWZFI2AAAAAOC7LBaLnrqtt9q2DPCIL/hgtz7dm21SVgAA4PuguI6a/dY7tZLFYjEpGwAAAADwbeEhdj33sz4eMZch3bt8m/ZnnzYpKwAA4C2K66ixcv0qNjMFAABAHXnllVfUuXNnBQYGKjExUZs3b77o+StXrlR8fLwCAwN1xRVX6P333/c4bhiG5syZo+joaAUFBSk5OVn79u1zHz906JAmTZqk2NhYBQUFqWvXrpo7d67Kyso8zrFYLDVuGzdurNsPD1zEkLg2mpl8mUfsdGmFJr21RaeKyi5wFQAAaEworjdzBSXl2pdd6BGj3zoAAADqwttvv61Zs2Zp7ty52rp1q/r06aMRI0YoO7v21hdffPGFxo0bp0mTJmnbtm0aPXq0Ro8erZ07d7rPefrpp7Vw4UItXrxYmzZtUkhIiEaMGKGSkhJJ0p49e+RyufTqq69q165deuGFF7R48WI99thjNd7vP//5j44fP+6+JSQk1M8PAriA+4Z30429oz1ih08W61fLUlVW4TIpKwAAcKkshmGwJXk9KygokMPhUH5+vkJDQ81Ox8P2I3ka/coG93Ob1aJvfj1CAX42E7MCAABoGhrzPK8xSExMVP/+/fX73/9ekuRyudShQwfde++9euSRR2qcP2bMGBUVFWn16tXu2MCBA9W3b18tXrxYhmEoJiZG999/vx544AFJUn5+viIjI7V06VKNHTu21jyeeeYZLVq0SAcPHpRUuXI9NjZW27ZtU9++fb/XZ2PsUVdKyp362asp2nE03yM+bkAH/faWK2jZCQBAA/NmnsfK9WYu7YTnqvUOrYIorAMAAOAHKysrU2pqqpKTk90xq9Wq5ORkpaSk1HpNSkqKx/mSNGLECPf5aWlpyszM9DjH4XAoMTHxgq8pVRbgw8PDa8R//OMfq23btho8eLD+9a9/XfTzlJaWqqCgwOMG1IVAf5ten9BPkaGeG5z+dfMRLdlwyJykAADAJaG43syl5RR5PI+NCDEpEwAAAPiSEydOyOl0KjIy0iMeGRmpzMzMWq/JzMy86Pnn7r15zf379+vll1/WL37xC3esRYsWeu6557Ry5Ur9+9//1uDBgzV69OiLFtgXLFggh8PhvnXo0OGC5wLeigwN1B8n9Fegv+ev6PP//Y0+3Vt7GyUAAGA+iuvN3METnsX1Lm1amJQJAAAAULeOHTum66+/Xj/96U81efJkdzwiIkKzZs1yt6353e9+pzvuuEPPPPPMBV/r0UcfVX5+vvt25MiRhvgIaEauaO/Qcz/t6xFzGdK9y7dpf/Zpc5ICAAAXRXG9mUs7wcp1AAAA1L2IiAjZbDZlZWV5xLOyshQVFVXrNVFRURc9/9z9pbxmRkaGhg0bpkGDBum11177znwTExO1f//+Cx4PCAhQaGioxw2oa6N6R2tm8mUesdOlFZr01hadKiozKSsAAHAhFNebMcMwahTXu1BcBwAAQB2w2+1KSEjQunXr3DGXy6V169YpKSmp1muSkpI8zpektWvXus+PjY1VVFSUxzkFBQXatGmTx2seO3ZMP/rRj5SQkKAlS5bIav3uX3u2b9+u6Ohorz4jUB/uG95NN/WJ8YgdPlmsX/4lVWUVLpOyAgAAtfEzOwGYJ6ugVMVlTo9YbBuK6wAAAKgbs2bN0sSJE9WvXz8NGDBAL774ooqKinT33XdLkiZMmKB27dppwYIFkqTp06dr6NCheu655zRq1CitWLFCW7Zsca88t1gsmjFjhubPn6+4uDjFxsbqiSeeUExMjEaPHi3pfGG9U6dOevbZZ5WTk+PO59zq9rfeekt2u11XXnmlJOmdd97Rm2++qT/+8Y8N9aMBLshiseiZn/RW+skifXU03x3flJaruf/aqd/ecoUsFouJGQIAgHMorjdjB08UejwP8rcpsmWgSdkAAADA14wZM0Y5OTmaM2eOMjMz1bdvX61Zs8a9IWl6errHqvJBgwZp+fLlmj17th577DHFxcVp1apV6tWrl/uchx56SEVFRZoyZYry8vI0ePBgrVmzRoGBlfPYtWvXav/+/dq/f7/at2/vkY9hGO7H//d//6fDhw/Lz89P8fHxevvtt/WTn/ykPn8cwCUL9LfptQn9dPPvNyizoMQd/+vmI4pr21L3DI41MTsAAHCOxag6w0S9KCgokMPhUH5+fqPqzbhs02E9/u5O9/Oe0aF6f/oQEzMCAABoWhrrPA/1j7FHQ/j6aL5++uoXKik/3w7GapHeuKu/hnVva2JmAAD4Lm/mefRcb8bScqptZkpLGAAAAABoNK5o79DzP+vrEXMZ0n3Lt+mbjAJzkgIAAG4U15uxg2xmCgAAAACN2sgrojXrfy7ziJ0urdAdb2zSt1mnTcoKAABIFNebtbRqxfVYiusAAAAA0Ojce2033dQnxiOWW1Sm21/fpP3ZhRe4CgAA1DeK681UudOl9NxijxjFdQAAAABofCwWi575SW8lxoZ7xE8Ulur21zfWWDgFAAAaBsX1ZupIbrGcLs+9bLtEtDApGwAAAADAxQT62/TmXf3Vr1Mrj3j26coCe/rJ4gtcCQAA6gvF9Waq+sqG1iF2OYL9TcoGAAAAAPBdQgL8tOTu/urbIcwjfjy/RONe36ijpyiwAwDQkCiuN1MHc+i3DgAAAABNTctAf711zwD1bu/wiB/LO6Nxr2/U8fwzJmUGAEDzQ3G9mTrIZqYAAAAA0CQ5gvz1p3sGqGd0qEf8SO4ZjXtto7IKSkzKDACA5oXiejOVdsJzR/kubei3DgAAAABNRViwXX/5eaK6R7b0iB86Waxxr29UzulSkzIDAKD5oLjeTFXvuc7KdQAAAABoWsJD7Fo2OVHd2nouljqYU6TbX9+ok4UU2AEAqE8U15uhwtIKZRV4TrK6tKG4DgAAAABNTUSLAC3/eaK6VFswtS+7UOP/uEmnispMygwAAN9Hcb0ZOlRt1brFInUMDzYpGwAAAADAD9E2NFDLJw9Up9aev9ftyTytO97YpPzicpMyAwDAt1Fcb4aqb2baLixIgf42k7IBAAAAAPxQUY7KAnv7VkEe8V0ZBbrjjU06QYsYAADqHMX1Zigtx7O4zmamAAAAAND0tQsL0l8nD1SMI9Aj/vWxfN3yhw3an11oUmYAAPimJlNcz83N1fjx4xUaGqqwsDBNmjRJhYUXnxiUlJRo6tSpat26tVq0aKHbbrtNWVlZHufcd999SkhIUEBAgPr27Vvr6+zYsUNDhgxRYGCgOnTooKeffrquPpYp0k54/tyq9+YDAAAAADRNHcKDtXzyQEWGBnjEj+Se0W2LvtCmgydNygwAAN/TZIrr48eP165du7R27VqtXr1an332maZMmXLRa2bOnKn33ntPK1eu1Pr165WRkaFbb721xnn33HOPxowZU+trFBQU6LrrrlOnTp2UmpqqZ555Rk8++aRee+21OvlcZqjeFiaW4joAAAAA+IzOESH66+SBahfm2SIm/0y57nxjs/65/ZhJmQEA4Fv8zE7gUuzevVtr1qzRl19+qX79+kmSXn75ZY0cOVLPPvusYmJialyTn5+vN954Q8uXL9e1114rSVqyZIl69OihjRs3auDAgZKkhQsXSpJycnK0Y8eOGq+zbNkylZWV6c0335Tdbtfll1+u7du36/nnn79gcb+0tFSlpef72RUUFPywH0AdMgyjRlsYiusAAAAA4Fu6tGmhd6cO0s/f2qIdR/Pd8TKnS9NXbNeR3GJNHdZNFovFxCwBAGjamsTK9ZSUFIWFhbkL65KUnJwsq9WqTZs21XpNamqqysvLlZyc7I7Fx8erY8eOSklJ8eq9r7nmGtntdndsxIgR2rt3r06dOlXrNQsWLJDD4XDfOnTocMnvV99OFJbpdGmFR4ziOgAAAAD4nrYtA7ViykAl94iscezZj77Vw//YoXKny4TMAADwDU2iuJ6Zmam2bdt6xPz8/BQeHq7MzMwLXmO32xUWFuYRj4yMvOA1F3qdyEjPici55xd6nUcffVT5+fnu25EjRy75/epbWrWWMHY/a42vCgIAAAAAfEOw3U+v3pmguwZ1rnHsb1uO6p6lX6qgpLzhEwMAwAeYWlx/5JFHZLFYLnrbs2ePmSl+LwEBAQoNDfW4NRbVNzONbR0iq5WvAQIAAACAr7JZLXryx5friRt7qnoXmM/3ndDPFqcoI++MOckBANCEmdpz/f7779ddd9110XO6dOmiqKgoZWdne8QrKiqUm5urqKioWq+LiopSWVmZ8vLyPFavZ2VlXfCaC71OVlaWR+zcc29ep7E4SL91AAAAAGiWJg2OVbuwIM14e5tKys+3g9mTeVqjX9mgN+/qr17tHCZmCABA02LqyvU2bdooPj7+oje73a6kpCTl5eUpNTXVfe3HH38sl8ulxMTEWl87ISFB/v7+WrdunTu2d+9epaenKykp6ZJzTEpK0meffaby8vNfk1u7dq26d++uVq1afY9Pba6D1drCxLahuA4AAAAAzcX1vaL018kD1TrE7hHPPl2qn72aoo/3ZF3gSgAAUF2T6Lneo0cPXX/99Zo8ebI2b96sDRs2aNq0aRo7dqxiYmIkSceOHVN8fLw2b94sSXI4HJo0aZJmzZqlTz75RKmpqbr77ruVlJSkgQMHul97//792r59uzIzM3XmzBlt375d27dvV1lZmSTp9ttvl91u16RJk7Rr1y69/fbbeumllzRr1qyG/0HUgeo911m5DgAAAADNy5UdW+nd/71aXaottiouc+rnb23RG/9Nk2EYJmUHAEDTYWpbGG8sW7ZM06ZN0/Dhw2W1WnXbbbdp4cKF7uPl5eXau3eviouL3bEXXnjBfW5paalGjBihP/zhDx6v+/Of/1zr1693P7/yyislSWlpaercubMcDoc++ugjTZ06VQkJCYqIiNCcOXM0ZcqUev7Edc/pMnT4pGdxvSsr1wEAAACg2enYOljv/GqQfvHnVG1Ky3XHXYb0f6u/UcqBk3rmJ73VqtoKdwAAcJ7F4J+j611BQYEcDofy8/NN3dz08MkiDX3mU4/Y1if+R+FMlgAAAL6XxjLPQ8Nj7OErSiucevjvO7Rqe0aNY9GOQL04pq8Su7Q2ITMAAMzhzTyvSbSFQd2o3m/dEeSvVsH+JmUDAAAAADBbgJ9NL4zpq/uu7Vbj2PH8Eo17faNe+s8+OV2sywMAoDqK681IWk7NfusWi8WkbAAAAAAAjYHFYtGs67pryd39a2x06jKkF/7zrW5/faMy80tMyhAAgMaJ4nozUn0z0+qb1wAAAAAAmq9h3dvqg+lDNKhrzTYwm9JydcNLn2nd7iwTMgMAoHGiuN6M1CiuR1BcBwAAAACc1zY0UH+elKgHR3SXzer5TedTxeWa9NYW/fq9b1Ra4TQpQwAAGg+K683IwZxCj+exES1MygQAAAAA0FjZrBZNHdZNb08ZqHZhQTWOv7khTbct+qLGAi4AAJobiuvNxJkypzKq9ceLZeU6AAAAAOAC+nUO1/v3DdGIyyNrHNt5rEA3Lvxc7247akJmAAA0DhTXm4lDJ2uuKOgcEWxCJgAAAACApsIR7K/FdyTo/0b3kt3Ps4RQVObUzLe/0pQ/bVFG3hmTMgQAwDwU15uJ6l/Xi3EEKtjuZ1I2AAAAAICmwmKx6M6BnfTPqVera5ua34D+6JssJT+/Xq9/dlDlTpcJGQIAYA6K681E9eJ6bC0TIgAAAAAALqRHdKjeu3ewftavfY1jxWVO/eb93brp5f8q9fApE7IDAKDhUVxvJg7U2MyU4joAAAAAwDvBdj89/ZM+ennclWodYq9xfE/mad226As9+s4O5RWXmZAhAAANh+J6M1Fj5XpEC5MyAQAAAAA0dTf1idG6+4dq3ICOtR7/6+YjGv7cev0j9agMw2jg7AAAaBgU15uJ6sX1LqxcBwAAAAD8AGHBdi249Qr941dJio9qWeP4yaIy3b/yK417faP2Z582IUMAAOoXxfVm4FRRmfKKyz1iXei5DgAAAACoAwmdwvXevYP1+MgeCrbbahzfeDBXN7z0uZ79cK9Kyp0mZAgAQP2guN4MHKy2at3fZlG7sCCTsgEAAAAA+Bp/m1WTr+mitbOG6rqekTWOlzsN/f6T/Up+fr3+nnpUThetYgAATR/F9WbgYLXNTDuGB8vPxtADAAAAAOpWu7AgvTahn/44oV+ti7qOnjqjB1Z+peteWK/VOzLkosgOAGjCqLA2A2xmCgAAAABoSMk9I7V21jX65dCu8rNaahw/kFOkacu3aeTCz7X2myw2PQUANEkU15uBGpuZ0m8dAAAAAFDPgu1+euSGeP37viEa0Dm81nP2ZJ7W5D9t0eg/fKHP9+VQZAcANCkU15uBGsX1CIrrAAAAAICG0T2qpd7+xUAtuau/Lo8JrfWcr47k6c43NmvMaxu1OS23gTMEAOD7obju41wuo5a2MBTXAQAAAAANx2KxaFh8W62+d7AW33GV4trW3q50c1qufvZqiu58Y5O+OpLXsEkCAOAlP7MTQP3KyD+j0gqXRyyWtjAAAAAAABNYLBZd3yta/9MzSqt3ZOiFtd/q0MniGud9vu+EPt93QkMva6O7r+6sa+LayFpL73YAAMxEcd3HVV+13iLAT21aBJiUDQAAAAAAks1q0c1922nkFdF6Z+tRLVy3X8fyztQ4b/23OVr/bY66RIRo4qDOui2hvVoEUMoAADQOtIXxcbVtZmqx8K/9AAAAAADz+dusGtO/oz5+YKh+ffPlatOy9sVgB08Uae6/dmngb9dp3nu7dKja77oAAJiB4rqPO5hDv3UAAAAAQOMW4GfThKTO+uzBYXp8ZA+Fh9hrPa+wtEJLNhzSsOc+1T1Lv9T6b3PkchkNnC0AAJX4LpWPO8hmpgAAAACAJiLIbtPka7rojoGdtGr7MS3dcEh7s07XOM8wpI/3ZOvjPdnq0iZEdw3qrFuvomUMAKBh8X8dH5d2otDjOcV1AAAAAEBjF2S3adyAjhrbv4M2HszV0i/StPabLNW2SP1gTpHm/HOXnlmzV6N6R+vmvu2UGBvOBqgAgHpHcd2HlVY4dfSU54YwXSJamJQNAAAAAADesVgsSuraWkldW+tIbrH+svGw/ro5XQUlFTXOPV1aoRVfHtGKL48oKjRQP+4bo5v7xqhndCh7jwEA6gXFdR+WfrJYRrV/1Y9tw8p1AAAAAEDT0yE8WI+O7KHpyXFatS1DS79I07dZhbWem1lQotc+O6jXPjuouLYtdHPfGN3ct506hAc3cNYAAF/GhqY+rHq/9bYtA+g/BwAAgAb1yiuvqHPnzgoMDFRiYqI2b9580fNXrlyp+Ph4BQYG6oorrtD777/vcdwwDM2ZM0fR0dEKCgpScnKy9u3b53FObm6uxo8fr9DQUIWFhWnSpEkqLPQswO3YsUNDhgxRYGCgOnTooKeffrpuPjCAehds99PtiR314YxrtPznibquZ6QutjB9X3ahnv3oWw15+hPdtugL/TnlkHKLyhouYQCAz6K47sMO5rCZKQAAAMzz9ttva9asWZo7d662bt2qPn36aMSIEcrOzq71/C+++ELjxo3TpEmTtG3bNo0ePVqjR4/Wzp073ec8/fTTWrhwoRYvXqxNmzYpJCREI0aMUElJifuc8ePHa9euXVq7dq1Wr16tzz77TFOmTHEfLygo0HXXXadOnTopNTVVzzzzjJ588km99tpr9ffDAFDnLBaLBnWL0GsT+mnDw9fqkRviFR/V8qLXpB4+pSf+uUsDfvMfTXxzs/6cckhHTxU3UMYAAF9jMYzqjUNQ1woKCuRwOJSfn6/Q0NAGe9+H/v6V/rblqPv5uAEdtODW3g32/gAAAL7OrHleU5GYmKj+/fvr97//vSTJ5XKpQ4cOuvfee/XII4/UOH/MmDEqKirS6tWr3bGBAweqb9++Wrx4sQzDUExMjO6//3498MADkqT8/HxFRkZq6dKlGjt2rHbv3q2ePXvqyy+/VL9+/SRJa9as0ciRI3X06FHFxMRo0aJFevzxx5WZmSm73S5JeuSRR7Rq1Srt2bPnkj4bYw80XnszT2vV9mP61/YMHcs7890XSIpr20LXxrfVj7q3Vb/OreRvYy0iADRX3szz6BHiw9JOsHIdAAAA5igrK1NqaqoeffRRd8xqtSo5OVkpKSm1XpOSkqJZs2Z5xEaMGKFVq1ZJktLS0pSZmank5GT3cYfDocTERKWkpGjs2LFKSUlRWFiYu7AuScnJybJardq0aZNuueUWpaSk6JprrnEX1s+9z1NPPaVTp06pVatWNXIrLS1VaWmp+3lBQYF3P5A6UFxcfMnFf6C5+5+20vBkh745btGne7P13/0ndLqWTVDP2Zkp7dwhLZQUYrfpyo6t1K9zK/XrFK5WIfYLXgcAaDjx8fEKDm5ce2dQXPdh1YvrXSJamJQJAAAAmpsTJ07I6XQqMjLSIx4ZGXnBAnFmZmat52dmZrqPn4td7Jy2bdt6HPfz81N4eLjHObGxsTVe49yx2orrCxYs0Lx58y78gRvAnj17lJCQYGoOQHNxQNLfzU4CAOAhNTVVV111ldlpeKC47qPyz5TrRKHnBi2xbVi5DgAAAHwfjz76qMeq+oKCAnXo0KFBc4iPj1dqamqDvifgi4rLKrQ5LVdbDuUq9fApFVxkRXt1/jaruke2VM+YluoZ41CP6FC1CKC0AgANIT4+3uwUauD/AD6q+qp1m9WiDq0a19cmAABo7pxOp8rLy81OA9/BZrPJz89PFovF7FSalIiICNlsNmVlZXnEs7KyFBUVVes1UVFRFz3/3H1WVpaio6M9zunbt6/7nOobplZUVCg3N9fjdWp7n6rvUV1AQIACAgIu+HkbQnBwcKNbrQU0VYMHVt47XYa2H8nTp3uz9fGebO3K+O6WT/tc0r6j0j+PlspiyVF8VKgGdG6lfp3D1b9zuKIcgfWcPQCgsaC47qPSThR6PO/QKkh2PzZkAQCgsSgsLNTRo0fF3vJNQ3BwsKKjoz16dOPi7Ha7EhIStG7dOo0ePVpS5Yam69at07Rp02q9JikpSevWrdOMGTPcsbVr1yopKUmSFBsbq6ioKK1bt85dTC8oKNCmTZv0q1/9yv0aeXl5Sk1NdbdQ+fjjj+VyuZSYmOg+5/HHH1d5ebn8/f3d79O9e/daW8IA8F02q0UJnVopoVMr3X9dd2UVlOjTvdn6ZE+O/rv/hApLL76q3TCk3ccLtPt4gd5KOSxJ6hAepP6dwtW7vePs6vaWahno3xAfBwDQwCiu+6i0nGr91tvQbx0AgMbC6XTq6NGjCg4OVps2bVgR3YgZhqGysjLl5OQoLS1NcXFxslpZsHCpZs2apYkTJ6pfv34aMGCAXnzxRRUVFenuu++WJE2YMEHt2rXTggULJEnTp0/X0KFD9dxzz2nUqFFasWKFtmzZotdee02SZLFYNGPGDM2fP19xcXGKjY3VE088oZiYGHcBv0ePHrr++us1efJkLV68WOXl5Zo2bZrGjh2rmJgYSdLtt9+uefPmadKkSXr44Ye1c+dOvfTSS3rhhRca/ocEoFGJDA3UmP4dNaZ/R5VVuLTlUK4+2Zutz/ed0N6s07qUfxM/kntGR3KP6Z1tx9yxTq2DdXlMqHpGh+ryGIcujwlVm5YBzAEAoImjuO6jDlZrCxMbQb91AAAai/LychmGoTZt2igoKMjsdPAdgoKC5O/vr8OHD6usrEyBgXzd/1KNGTNGOTk5mjNnjjIzM9W3b1+tWbPGvXloenq6xz9WDBo0SMuXL9fs2bP12GOPKS4uTqtWrVKvXr3c5zz00EMqKirSlClTlJeXp8GDB2vNmjUe47Js2TJNmzZNw4cPl9Vq1W233aaFCxe6jzscDn300UeaOnWqEhISFBERoTlz5mjKlCkN8FMB0FTY/awa1C1Cg7pFSJLyi8u1Nf2UNh+q7Nf+1ZF8lTldl/Rah08W6/DJYr3/daY7FtHCrp4xDvWMDlXPmFB1bROi2IgQBdsp1QBoXAzDUIXLUGmFS2VVb06nZ8zp+bjqsXKn5zmlVWLlznNxQ2VOl8rPnlf9musvj9LsG3ua/ePwYDH4LnK9KygokMPhUH5+vkJDQxvkPUe+9Lm+OX6+V9z80b10x8BODfLeAADg4kpKSpSWlqbY2FgKtU3EhcbMjHkeGgfGHkBJuVNfH8t3b4665fApnfZic9QLiQoNVJezhfYubVqoS0Tl4/atguRn49tTQHNTUaVIXVrhUmlFZUG7tPz847LqcadLpeXOGtede1xW5XmZs/KaqvdVX+/cOY2hgnxz3xi9NPbKen8fb+Z5/HOoDzIMo8aGpl1YuQ4AAAAAQJ0J9Lep/9lNTKXKzVG/zTqtLw/lavuRPH2TUaD92YWqcHlXkcosKFFmQYm+OHDSI+5vs6hjeLC6tGmhTuHBatcqSNGOILULC1JMWKDCQ+y0mQHqSfnZAndJ+bkCttPzebVjJVXOKa1yTmmFUyXniuLl1a6rpWheWuGS08v/hviy8kv8tlBDorjug7IKSnWm3OkRi21DcR0AAAAAgPpis1rUIzpUPaJDNaFyH2aVlDu1L6tQ3xzP166MAn2TUbn5aVGZ8+IvVotyp6EDOUU6UG2PtXMC/KxnC+1BinYEKiYsyP28bWiAIloEKCzIX1YrBXg0XU6XoZJyp7sgXfn4fNG6xF20rrwvqTh7bpVj5+9dHq9TW9H83D0F7sahrILiOhrAwROFHs+D/G2KCuUr5wAAoOnr3LmzZsyYoRkzZkiq3ODy3XffdW9mCQBAYxLob9MV7R26or3DHXO5DB3OLdaujHx9k1GgXWdXuGfkn/lBbRdKK1w6eKKoxh5sVdmsFoWH2BXRIkARLc7ft24R4BFzBPkrNMhfLQP8KMajBsMwVO40PFZXl1Yrcnus0L5I0frC91VXd58tnJc7vf4mCOqfn9Uiu5+18mazyt9mVcC551Vi9mox+9mYxzGbxTNm83yNyEZY36S47oOqt4SJjQjhq2EAAOAHu+uuu/TWW2+5n4eHh6t///56+umn1bt3b1NyOn78uFq1amXKewMA8H1YrRbFnu2jfmPvGHe8pNypQyeLlJZTWSA/mFOktBOFOniiSHnF5XXy3k6XoZzTpco5XXpJ51ssUssAP4UG+VcW3APP3gf5uZ+HBvkryG5TiN1PwXbb2ZufggPOPvavfOxPv/gf5NyGkuVOl8rPbvrosXnkpWwu6e6r7Tzbk/t8vLZ+3FVbmZxrYXIu3hj6bzd39rNF7AB/qwL8bLL7nX1+tlAd4Ger8ri2mM1d1K56XkC1Y3Zb5XvYqxTBA2znj9ua+T/AUVz3QQerfUWMljAAADReLpehU8VlpubQKth+yavSrr/+ei1ZskSSlJmZqdmzZ+vGG29Uenp6faZ4QVFRUaa8LwAAdS3Q36b4qFDFR9XcPO9UUdnZgnuh0k4U6VjeGWXknVFGXmV/9vpqWWEYUkFJhQpKKnT01Jkf9Fr+NouC7X4K9K9S2KtarKtS4KssGlYW7/xsFvlZLbJaK+9tVuvZ+8pb1cc2q0UWWWSxSOdmNpWPKwMWVX7rreoxl1FZuDYMyZBx9rnkMgwZOn/MZVQec7pccroqn1c4DTkNQy5XZeHbZRhyus7fKlyGKpwud1G8wmmowuU6Gz8bO3tO+dlj5U5DZRWuyiL62eJ4ubOymI7GxWKRAv1sCjxb3A7wtyrw7H2An1WB/pV/xgP9bWeL4DaPYvi5P/NVj1eef/71AqoUxKteZ7dZ+VZJI0Fx3QexmSkAAE3HqeIyJcz/j6k5pM5OVusWAZd0bkBAgLugHRUVpUceeURDhgxRTk6O2rRpo4cffljvvvuujh49qqioKI0fP15z5syRv7+/JOmrr77SjBkztGXLFlksFsXFxenVV19Vv379JEn//e9/9eijj2rLli2KiIjQLbfcogULFigkpPb5TNW2MIcOHVJsbKz+8Y9/6OWXX9amTZsUFxenxYsXKykpyX2Nt+8BAIDZWoXYlRBiV0Knmt/WqnC6lH26tLLYnl9ytuheeTuWV6Lj+WfqbOX7D1HuNJR/plz5P6xGD9RQtch9rlAd6G9zF7OrxgLPFqnPF8Frua5KIbxGvMr5flYLnSJAcd0X1dYWBgAAoK4VFhbqL3/5i7p166bWrVtLklq2bKmlS5cqJiZGX3/9tSZPnqyWLVvqoYcekiSNHz9eV155pRYtWiSbzabt27e7C+8HDhzQ9ddfr/nz5+vNN99UTk6Opk2bpmnTprlXy1+Kxx9/XM8++6zi4uL0+OOPa9y4cdq/f7/8/Pzq7D0AAGgs/GxWxZzduPRCyipcyi0q04nC0rO3Mp2s8rhq7GRRGZs34nuxWnTBYnRAlWJ21eJ2zfvKwnagv+e1Ne/PX+dvo8gN81Bc9zHlTpfSc4s9Yl3atDApGwAA4GtWr16tFi0q5xZFRUWKjo7W6tWrZbVW9lGdPXu2+9zOnTvrgQce0IoVK9zF9fT0dD344IOKj4+XJMXFxbnPX7BggcaPH+/erDQuLk4LFy7U0KFDtWjRIgUGXtoGRg888IBGjRolSZo3b54uv/xy7d+/X/Hx8XX2HgAANCV2P6uiHIGKcnz3/+cMw1BxmVP5Z8pVUFKu/OJyFZRUVD4/U34+fqZcBWcqVFBSrjNlThWXVehMmVNFZU6dKXPSxqSB2W3VNousupmkn1UBNqtHm5GL9ee2VyuO12hlUq2tybnzWcmN5ojiuo8pKXfqzoGddPBE5cYnR0+dUWxrVq4DAIC6MWzYMC1atEiSdOrUKf3hD3/QDTfcoM2bN6tTp056++23tXDhQh04cECFhYWqqKhQaOj53rGzZs3Sz3/+c/35z39WcnKyfvrTn6pr166SKlvG7NixQ8uWLXOfbxiGXC6X0tLS1KNHj0vKsermqtHR0ZKk7OxsxcfH19l7AADgqywWi0IC/BQS4KcYXXg1/Hcpd7pUfLboXny24F5UWqGSKhtunttE89zGm6VVNtQ8t0FnhdOzh7nTMOR0nn3scsl5tg/6ufPO9UmXdPZx5b3cPdR19lhlL3Wr5WyP9rO92K1nH1ur9Go/99hqlWxWq2yWs/dWyc9a2fu6aqzqMT+rRX42q/xtlsrnZ3vI1xaz+1nlbztbED973N+v2vOzhfPz9xbZbVaK2oBJKK77mJaB/nryx5e7n5eUOxXobzMxIwAAcDGtgu1KnZ1seg6XKiQkRN26dXM//+Mf/yiHw6HXX39do0aN0vjx4zVv3jyNGDFCDodDK1as0HPPPec+/8knn9Ttt9+uf//73/rggw80d+5crVixQrfccosKCwv1i1/8Qvfdd1+N9+3YseMl53iuzYwk9y+aLlfl6rm6eg8AAHBx/jarHEFWOYL8v/tkAGiiKK77OArrAAA0blar5ZI3E22MLBaLrFarzpw5oy+++EKdOnXS448/7j5++PDhGtdcdtlluuyyyzRz5kyNGzdOS5Ys0S233KKrrrpK33zzjUfxvq41xHsAAAAAaB6sZicAAACApqO0tFSZmZnKzMzU7t27de+996qwsFA33XST4uLilJ6erhUrVujAgQNauHCh3n33Xfe1Z86c0bRp0/Tpp5/q8OHD2rBhg7788kt3K5aHH35YX3zxhaZNm6bt27dr3759+uc//6lp06bVWf4N8R4AAAAAmgdWrgMAAOCSrVmzxt3HvGXLloqPj9fKlSv1ox/9SJI0c+ZMTZs2TaWlpRo1apSeeOIJPfnkk5Ikm82mkydPasKECcrKylJERIRuvfVWzZs3T1Jlr/T169fr8ccf15AhQ2QYhrp27aoxY8bUWf4N8R4AAAAAmgeLcW6XB9SbgoICORwO5efne2zoBQAAmqeSkhKlpaUpNjZWgYGBZqeDS3ChMWOe13wx9gAAAL7Jm3kebWEAAAAAAAAAAPASxXUAAAAAAAAAALxEcR0AAAAAAAAAAC9RXAcAAAAAAAAAwEsU1wEAAEzCvvJNB2MFAAAAoDqK6wAAAA3MZrNJksrKykzOBJequLhYkuTv729yJgAAAAAaCz+zEwAAAGhu/Pz8FBwcrJycHPn7+8tqZb1DY2UYhoqLi5Wdna2wsDD3P4wAAAAAAMV1AACABmaxWBQdHa20tDQdPnzY7HRwCcLCwhQVFWV2GgAAAAAaEYrrAAAAJrDb7YqLi6M1TBPg7+/PinUAAAAANVBcBwAAMInValVgYKDZaQAAAAAAvgcafAIAAAAAAAAA4CWK6wAAAAAAAAAAeIniOgAAAAAAAAAAXqLnegMwDEOSVFBQYHImAAAAqEvn5nfn5ntoPpjjAwAA+CZv5vgU1xvA6dOnJUkdOnQwORMAAADUh9OnT8vhcJidBhoQc3wAAADfdilzfIvBMpt653K5lJGRoZYtW8pisTTIexYUFKhDhw46cuSIQkNDG+Q9Uf8YV9/EuPoextQ3Ma6+py7G1DAMnT59WjExMbJa6bjYnDDHR11hXH0PY+qbGFffxLj6noae47NyvQFYrVa1b9/elPcODQ3lPw4+iHH1TYyr72FMfRPj6nt+6JiyYr15Yo6Pusa4+h7G1Dcxrr6JcfU9DTXHZ3kNAAAAAAAAAABeorgOAAAAAAAAAICXKK77qICAAM2dO1cBAQFmp4I6xLj6JsbV9zCmvolx9T2MKZoa/sz6JsbV9zCmvolx9U2Mq+9p6DFlQ1MAAAAAAAAAALzEynUAAAAAAAAAALxEcR0AAAAAAAAAAC9RXAcAAAAAAAAAwEsU1wEAAAAAAAAA8BLFdR/1yiuvqHPnzgoMDFRiYqI2b95sdkrwwmeffaabbrpJMTExslgsWrVqlcdxwzA0Z84cRUdHKygoSMnJydq3b585yeKSLFiwQP3791fLli3Vtm1bjR49Wnv37vU4p6SkRFOnTlXr1q3VokUL3XbbbcrKyjIpY3yXRYsWqXfv3goNDVVoaKiSkpL0wQcfuI8znr7hd7/7nSwWi2bMmOGOMbZNz5NPPimLxeJxi4+Pdx9nTNFUMMdv2pjj+x7m+L6HOX7zwBzfNzSWOT7FdR/09ttva9asWZo7d662bt2qPn36aMSIEcrOzjY7NVyioqIi9enTR6+88kqtx59++mktXLhQixcv1qZNmxQSEqIRI0aopKSkgTPFpVq/fr2mTp2qjRs3au3atSovL9d1112noqIi9zkzZ87Ue++9p5UrV2r9+vXKyMjQrbfeamLWuJj27dvrd7/7nVJTU7VlyxZde+21uvnmm7Vr1y5JjKcv+PLLL/Xqq6+qd+/eHnHGtmm6/PLLdfz4cfftv//9r/sYY4qmgDl+08cc3/cwx/c9zPF9H3N839Io5vgGfM6AAQOMqVOnup87nU4jJibGWLBggYlZ4fuSZLz77rvu5y6Xy4iKijKeeeYZdywvL88ICAgw/vrXv5qQIb6P7OxsQ5Kxfv16wzAqx9Df399YuXKl+5zdu3cbkoyUlBSz0oSXWrVqZfzxj39kPH3A6dOnjbi4OGPt2rXG0KFDjenTpxuGwd/Vpmru3LlGnz59aj3GmKKpYI7vW5jj+ybm+L6JOb7vYI7vWxrLHJ+V6z6mrKxMqampSk5OdsesVquSk5OVkpJiYmaoK2lpacrMzPQYY4fDocTERMa4CcnPz5ckhYeHS5JSU1NVXl7uMa7x8fHq2LEj49oEOJ1OrVixQkVFRUpKSmI8fcDUqVM1atQojzGU+LvalO3bt08xMTHq0qWLxo8fr/T0dEmMKZoG5vi+jzm+b2CO71uY4/se5vi+pzHM8f3q9NVguhMnTsjpdCoyMtIjHhkZqT179piUFepSZmamJNU6xueOoXFzuVyaMWOGrr76avXq1UtS5bja7XaFhYV5nMu4Nm5ff/21kpKSVFJSohYtWujdd99Vz549tX37dsazCVuxYoW2bt2qL7/8ssYx/q42TYmJiVq6dKm6d++u48ePa968eRoyZIh27tzJmKJJYI7v+5jjN33M8X0Hc3zfxBzf9zSWOT7FdQBoYFOnTtXOnTs9eoGhaerevbu2b9+u/Px8/f3vf9fEiRO1fv16s9PCD3DkyBFNnz5da9euVWBgoNnpoI7ccMMN7se9e/dWYmKiOnXqpL/97W8KCgoyMTMAgK9gju87mOP7Hub4vqmxzPFpC+NjIiIiZLPZaux+m5WVpaioKJOyQl06N46McdM0bdo0rV69Wp988onat2/vjkdFRamsrEx5eXke5zOujZvdble3bt2UkJCgBQsWqE+fPnrppZcYzyYsNTVV2dnZuuqqq+Tn5yc/Pz+tX79eCxculJ+fnyIjIxlbHxAWFqbLLrtM+/fv5+8rmgTm+L6POX7TxhzftzDH9z3M8ZsHs+b4FNd9jN1uV0JCgtatW+eOuVwurVu3TklJSSZmhroSGxurqKgojzEuKCjQpk2bGONGzDAMTZs2Te+++64+/vhjxcbGehxPSEiQv7+/x7ju3btX6enpjGsT4nK5VFpayng2YcOHD9fXX3+t7du3u2/9+vXT+PHj3Y8Z26avsLBQBw4cUHR0NH9f0SQwx/d9zPGbJub4zQNz/KaPOX7zYNYcn7YwPmjWrFmaOHGi+vXrpwEDBujFF19UUVGR7r77brNTwyUqLCzU/v373c/T0tK0fft2hYeHq2PHjpoxY4bmz5+vuLg4xcbG6oknnlBMTIxGjx5tXtK4qKlTp2r58uX65z//qZYtW7p7fDkcDgUFBcnhcGjSpEmaNWuWwsPDFRoaqnvvvVdJSUkaOHCgydmjNo8++qhuuOEGdezYUadPn9by5cv16aef6sMPP2Q8m7CWLVu6+6SeExISotatW7vjjG3T88ADD+imm25Sp06dlJGRoblz58pms2ncuHH8fUWTwRy/6WOO73uY4/se5vi+iTm+b2o0c3wDPunll182OnbsaNjtdmPAgAHGxo0bzU4JXvjkk08MSTVuEydONAzDMFwul/HEE08YkZGRRkBAgDF8+HBj79695iaNi6ptPCUZS5YscZ9z5swZ43//93+NVq1aGcHBwcYtt9xiHD9+3LykcVH33HOP0alTJ8Nutxtt2rQxhg8fbnz00Ufu44yn7xg6dKgxffp093PGtukZM2aMER0dbdjtdqNdu3bGmDFjjP3797uPM6ZoKpjjN23M8X0Pc3zfwxy/+WCO3/Q1ljm+xTAMo27L9QAAAAAAAAAA+DZ6rgMAAAAAAAAA4CWK6wAAAAAAAAAAeIniOgAAAAAAAAAAXqK4DgAAAAAAAACAlyiuAwAAAAAAAADgJYrrAAAAAAAAAAB4ieI6AAAAAAAAAABeorgOAAAAAAAAAICXKK4DAAAAAAAAAOAliusAgDo3c+ZM3XrrrWanAQAAAKAOML8HgNpRXAcA1LnNmzerX79+ZqcBAAAAoA4wvweA2lkMwzDMTgIA4BvKysoUEhKiiooKdywxMVEbN240MSsAAAAA3wfzewC4OD+zEwAA+A4/Pz9t2LBBiYmJ2r59uyIjIxUYGGh2WgAAAAC+B+b3AHBxFNcBAHXGarUqIyNDrVu3Vp8+fcxOBwAAAMAPwPweAC6OnusAgDq1bds2Jt4AAACAj2B+DwAXRnEdAFCntm/fzuQbAAAA8BHM7wHgwiiuAwDq1Ndff62+ffuanQYAAACAOsD8HgAujOI6AKBOuVwu7d27VxkZGcrPzzc7HQAAAAA/APN7ALgwiusAgDo1f/58LV26VO3atdP8+fPNTgcAAADAD8D8HgAuzGIYhmF2EgAAAAAAAAAANCWsXAcAAAAAAAAAwEsU1wEAAAAAAAAA8BLFdQAAAAAAAAAAvERxHQAAAAAAAAAAL1FcBwAAAAAAAADASxTXAQAAAAAAAADwEsV1AAAAAAAAAAC8RHEdAAAAAAAAAAAvUVwHAAAAAAAAAMBLFNcBAAAAAAAAAPASxXUAAAAAAAAAALz0/4+dIYn+n8CmAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "show_irfs([irfs_ev], ['C', 'U', 'Y', 'w'], labels=[\"Baseline\" ])\n",
+    "show_irfs([irfs_ev], [  'pi','r_ante'], labels=[\"Baseline\" ])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f878cdd",
+   "metadata": {},
+   "source": [
+    "# Productivity Shock"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "722679da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rho_Z = .9\n",
+    "dZ = -Z_ss*.001 * rho_Z ** np.arange(T)\n",
+    "\n",
+    "shocks_Z = {'Z': dZ}\n",
+    "irfs_Z = HANK_SAM.solve_impulse_linear(SteadyState_Dict, unknowns, targets, shocks_Z)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "2025f50c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1800x600 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "show_irfs([irfs_Z], ['C', 'U', 'Y', 'w'], labels=[\"Baseline\"])\n",
+    "show_irfs([irfs_Z], [  'pi','r_ante'], labels=[\"Baseline\" ])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0b76af8b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "86759ca2",
+   "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
+}