diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md
index 992a38d68..2cea78ca2 100644
--- a/Documentation/CHANGELOG.md
+++ b/Documentation/CHANGELOG.md
@@ -29,6 +29,7 @@ Release Date: TBD
 * Adds a wrapper for [`interpolation.py`](https://github.com/EconForge/interpolation.py) for fast multilinear interpolation. [#1151](https://github.com/econ-ark/HARK/pull/1151)
 * Adds support for the calculation of dreivatives in the `interpolation.py` wrappers. [#1157](https://github.com/econ-ark/HARK/pull/1157)
 * Adds class `DecayInterp` to `econforgeinterp.py`. It implements interpolators that "decay" to some limiting function when extrapolating. [#1165](https://github.com/econ-ark/HARK/pull/1165)
+* Add methods to non stochastically simulate an economy by computing transition matrices. Functions to compute transition matrices and ergodic distribution have been added [#1155](https://github.com/econ-ark/HARK/pull/1155).
 
 ### Minor Changes
 
diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py
index 7c4b0462d..35f221af4 100644
--- a/HARK/ConsumptionSaving/ConsIndShockModel.py
+++ b/HARK/ConsumptionSaving/ConsIndShockModel.py
@@ -13,6 +13,7 @@
 See HARK documentation for mathematical descriptions of the models being solved.
 """
 from copy import copy, deepcopy
+from scipy import sparse as sp
 
 import numpy as np
 from HARK import (
@@ -58,6 +59,11 @@
     CRRAutilityP_invP,
     CRRAutilityPP,
     construct_assets_grid,
+    make_grid_exp_mult,
+    jump_to_grid_2D,
+    jump_to_grid_1D,
+    gen_tran_matrix_1D,
+    gen_tran_matrix_2D,
 )
 from scipy.optimize import newton
 
@@ -2348,6 +2354,285 @@ def calc_bounding_values(self):
         self.MPCmin = MPCmin
         self.MPCmax = MPCmax
 
+
+  
+    def define_distribution_grid(self, dist_mGrid=None, dist_pGrid=None, m_density = 0, num_pointsM = None, timestonest = None,  num_pointsP = 55, max_p_fac = 30.0):
+        
+        '''
+        Defines the grid on which the distribution is defined. Stores the grid of market resources and permanent income as attributes of self.
+        Grid for normalized market resources and permanent income may be prespecified 
+        as dist_mGrid and dist_pGrid, respectively. If not then default grid is computed based off given parameters.
+        
+        Parameters
+        ----------
+        dist_mGrid : np.array
+                Prespecified grid for distribution over normalized market resources
+            
+        dist_pGrid : np.array
+                Prespecified grid for distribution over permanent income. 
+            
+        m_density: float
+                Density of normalized market resources grid. Default value is mdensity = 0.
+                Only affects grid of market resources if dist_mGrid=None.
+            
+        num_pointsM: float
+                Number of gridpoints for market resources grid.
+        
+        num_pointsP: float
+                 Number of gridpoints for permanent income. 
+                 This grid will be exponentiated by the function make_grid_exp_mult.
+                
+        max_p_fac : float
+                Factor that scales the maximum value of permanent income grid. 
+                Larger values increases the maximum value of permanent income grid.
+        
+        Returns
+        -------
+        None
+        '''  
+ 
+   
+        if not hasattr(self, "neutral_measure"): # If true Use Harmenberg 2021's Neutral Measure. For more information, see https://econ-ark.org/materials/harmenberg-aggregation?launch
+            self.neutral_measure = False
+            
+        if num_pointsM == None:
+            m_points = self.aXtraCount
+        else:
+            m_points = num_pointsM
+            
+        if not isinstance(timestonest,int):
+            timestonest = self.aXtraNestFac
+        else:
+            timestonest = timestonest
+          
+        if self.cycles == 0:
+            
+            if not hasattr(dist_mGrid,'__len__'):
+                
+                aXtra_Grid = make_grid_exp_mult(
+                        ming=self.aXtraMin, maxg=self.aXtraMax, ng = m_points, timestonest = timestonest) #Generate Market resources grid given density and number of points
+                
+                for i in range(m_density):
+                    axtra_shifted = np.delete(aXtra_Grid,-1) 
+                    axtra_shifted = np.insert(axtra_shifted, 0,1.00000000e-04)
+                    dist_betw_pts = aXtra_Grid - axtra_shifted
+                    dist_betw_pts_half = dist_betw_pts/2
+                    new_A_grid = axtra_shifted + dist_betw_pts_half
+                    aXtra_Grid = np.concatenate((aXtra_Grid,new_A_grid))
+                    aXtra_Grid = np.sort(aXtra_Grid)
+                    
+                self.dist_mGrid = aXtra_Grid
+            
+            else:
+                self.dist_mGrid = dist_mGrid #If grid of market resources prespecified then use as mgrid
+                
+            if not hasattr(dist_pGrid,'__len__'):
+                num_points = num_pointsP #Number of permanent income gridpoints
+                #Dist_pGrid is taken to cover most of the ergodic distribution
+                p_variance = self.PermShkStd[0]**2 #set variance of permanent income shocks
+                max_p = max_p_fac*(p_variance/(1-self.LivPrb[0]))**0.5 #Maximum Permanent income value
+                one_sided_grid = make_grid_exp_mult(1.05+1e-3, np.exp(max_p), num_points, 3)
+                self.dist_pGrid = np.append(np.append(1.0/np.fliplr([one_sided_grid])[0],np.ones(1)),one_sided_grid) #Compute permanent income grid
+            else:
+
+                self.dist_pGrid = dist_pGrid #If grid of permanent income prespecified then use it as pgrid
+                            
+            if self.neutral_measure == True: # If true Use Harmenberg 2021's Neutral Measure. For more information, see https://econ-ark.org/materials/harmenberg-aggregation?launch
+                
+                self.dist_pGrid = np.array([1])
+                
+        elif self.cycles > 1:
+            raise Exception('define_distribution_grid requires cycles = 0 or cycles = 1')
+        
+        elif self.T_cycle != 0:
+            if num_pointsM == None:
+                m_points = self.aXtraCount
+            else:
+                m_points = num_pointsM
+            
+            print(self.aXtraCount)
+            
+            if not hasattr(dist_mGrid,'__len__'):
+                aXtra_Grid = make_grid_exp_mult(
+                        ming=self.aXtraMin, maxg=self.aXtraMax, ng = m_points, timestonest = timestonest) #Generate Market resources grid given density and number of points
+                
+                for i in range(m_density):
+                    axtra_shifted = np.delete(aXtra_Grid,-1) 
+                    axtra_shifted = np.insert(axtra_shifted, 0,1.00000000e-04)
+                    dist_betw_pts = aXtra_Grid - axtra_shifted
+                    dist_betw_pts_half = dist_betw_pts/2
+                    new_A_grid = axtra_shifted + dist_betw_pts_half
+                    aXtra_Grid = np.concatenate((aXtra_Grid,new_A_grid))
+                    aXtra_Grid = np.sort(aXtra_Grid)
+                    
+                self.dist_mGrid =  aXtra_Grid
+            
+            else:
+                self.dist_mGrid = dist_mGrid #If grid of market resources prespecified then use as mgrid
+                    
+            if not hasattr(dist_pGrid,'__len__'):
+                
+                self.dist_pGrid = [] #list of grids of permanent income    
+                
+                for i in range(self.T_cycle):
+                    
+                    num_points = num_pointsP
+                    #Dist_pGrid is taken to cover most of the ergodic distribution
+                    p_variance = self.PermShkStd[i]**2 # set variance of permanent income shocks this period
+                    max_p = max_p_fac*(p_variance/(1-self.LivPrb[i]))**0.5 # Consider probability of staying alive this period
+                    one_sided_grid = make_grid_exp_mult(1.05+1e-3, np.exp(max_p), num_points, 2) 
+                    
+                    dist_pGrid = np.append(np.append(1.0/np.fliplr([one_sided_grid])[0],np.ones(1)),one_sided_grid) # Compute permanent income grid this period. Grid of permanent income may differ dependent on PermShkStd
+                    self.dist_pGrid.append(dist_pGrid)
+
+            else:
+                self.dist_pGrid = dist_pGrid #If grid of permanent income prespecified then use as pgrid
+                           
+            if self.neutral_measure == True: # If true Use Harmenberg 2021's Neutral Measure. For more information, see https://econ-ark.org/materials/harmenberg-aggregation?launch
+                
+                self.dist_pGrid = self.T_cycle*[np.array([1])]
+            
+                
+                
+    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. Each Income Shock Distribution should be a DiscreteDistribution Object (see Distribution.py)
+        Returns
+        -------
+        None
+        
+        ''' 
+        
+        
+        if self.cycles == 0:  # Infinite Horizon Problem
+            
+            if not hasattr(shk_dstn, 'pmv'):
+                shk_dstn = self.IncShkDstn
+            
+            dist_mGrid = self.dist_mGrid #Grid of market resources
+            dist_pGrid = self.dist_pGrid #Grid of permanent incomes
+            aNext = dist_mGrid - self.solution[0].cFunc(dist_mGrid)  #assets next period
+            
+            self.aPol_Grid = aNext # Steady State Asset Policy Grid
+            self.cPol_Grid = self.solution[0].cFunc(dist_mGrid) #Steady State Consumption Policy Grid
+            
+            # Obtain shock values and shock probabilities from income distribution
+            bNext = self.Rfree*aNext # Bank Balances next period (Interest rate * assets)
+            shk_prbs = shk_dstn[0].pmv  # Probability of shocks 
+            tran_shks = shk_dstn[0].atoms[1] # Transitory shocks
+            perm_shks = shk_dstn[0].atoms[0] # Permanent shocks
+            LivPrb = self.LivPrb[0] # Update probability of staying alive
+            
+            #New borns have this distribution (assumes start with no assets and permanent income=1)
+            NewBornDist = jump_to_grid_2D(tran_shks,np.ones_like(tran_shks),shk_prbs,dist_mGrid,dist_pGrid)
+            
+            
+            if len(dist_pGrid) == 1: 
+                NewBornDist = jump_to_grid_1D(np.ones_like(tran_shks),shk_prbs,dist_mGrid)
+                self.tran_matrix = gen_tran_matrix_1D(dist_mGrid,bNext, shk_prbs,perm_shks,tran_shks,LivPrb,NewBornDist) # Compute Transition Matrix given shocks and grids.
+                
+            else:
+                NewBornDist = jump_to_grid_2D( np.ones_like(tran_shks), np.ones_like(tran_shks),shk_prbs,dist_mGrid,dist_pGrid )
+                
+                # Generate Transition Matrix
+                self.tran_matrix = gen_tran_matrix_2D(dist_mGrid,dist_pGrid,bNext, shk_prbs,perm_shks,tran_shks,LivPrb,NewBornDist) # Compute Transition Matrix given shocks and grids.
+                
+            
+            
+        elif self.cycles > 1:
+            raise Exception('calc_transition_matrix requires cycles = 0 or cycles = 1')
+            
+        elif self.T_cycle!= 0 : # finite horizon problem
+            
+            if not hasattr(shk_dstn, 'pmv'):
+                shk_dstn = self.IncShkDstn
+            
+            self.cPol_Grid = [] # List of consumption policy grids for each period in T_cycle
+            self.aPol_Grid = [] # List of asset policy grids for each period in T_cycle
+            self.tran_matrix = [] # List of transition matrices
+            
+            dist_mGrid =  self.dist_mGrid
+            
+            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
+                
+                Cnow = self.solution[k].cFunc(dist_mGrid) #Consumption policy grid in period k
+                self.cPol_Grid.append(Cnow) #Add to list
+
+                aNext = dist_mGrid - Cnow # Asset policy grid in period k
+                self.aPol_Grid.append(aNext) # Add to list
+                
+                
+                if type(self.Rfree)==list:
+                    bNext = self.Rfree[k]*aNext
+                else:
+                    bNext = self.Rfree*aNext
+                    
+                #Obtain shocks and shock probabilities from income distribution this period
+                shk_prbs = shk_dstn[k].pmv  #Probability of shocks this period
+                tran_shks = shk_dstn[k].atoms[1] #Transitory shocks this period
+                perm_shks = shk_dstn[k].atoms[0] #Permanent shocks this period
+                LivPrb = self.LivPrb[k] # Update probability of staying alive this period
+                
+            
+                if len(dist_pGrid) == 1: 
+                                    
+                    #New borns have this distribution (assumes start with no assets and permanent income=1)
+                    NewBornDist = jump_to_grid_1D(np.ones_like(tran_shks),shk_prbs,dist_mGrid)
+                    TranMatrix_M = gen_tran_matrix_1D(dist_mGrid,bNext, shk_prbs,perm_shks,tran_shks,LivPrb,NewBornDist) # Compute Transition Matrix given shocks and grids.
+                    self.tran_matrix.append(TranMatrix_M)
+                    
+                else:
+                    
+                    NewBornDist = jump_to_grid_2D(np.ones_like(tran_shks),np.ones_like(tran_shks),shk_prbs,dist_mGrid,dist_pGrid)
+                    TranMatrix = gen_tran_matrix_2D(dist_mGrid,dist_pGrid,bNext, shk_prbs,perm_shks,tran_shks,LivPrb,NewBornDist) # Compute Transition Matrix given shocks and grids.
+                    self.tran_matrix.append(TranMatrix)         
+                
+                
+
+
+        
+    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 
+                    list with one transition matrix whose ergordic distribution is to be solved
+        Returns
+        -------
+        None
+        '''
+        
+        if not isinstance(transition_matrix, list):
+            transition_matrix = [self.tran_matrix]
+        
+        eigen, ergodic_distr = sp.linalg.eigs(transition_matrix[0], v0 =  np.ones(len(transition_matrix[0])) , k=1 , which='LM')  # Solve for ergodic distribution
+        ergodic_distr = ergodic_distr.real/np.sum(ergodic_distr.real)
+
+        self.vec_erg_dstn = ergodic_distr #distribution as a vector
+        self.erg_dstn = ergodic_distr.reshape((len(self.dist_mGrid),len(self.dist_pGrid))) # distribution reshaped into len(mgrid) by len(pgrid) array
+        
+    
     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/ConsumptionSaving/tests/test_IndShockConsumerType.py b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py
index fe78daf6d..963e943c2 100644
--- a/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py
+++ b/HARK/ConsumptionSaving/tests/test_IndShockConsumerType.py
@@ -771,3 +771,43 @@ def test_NewbornStatesAndShocks(self):
         self.assertTrue(
             np.all(agent.history["bNrm"][age == 1] == a_init_newborns / pshk_newborns)
         )
+        
+        
+#%% Test Transition Matrix Methods
+
+
+
+class test_Transition_Matrix_Methods(unittest.TestCase):
+    def test_calc_tran_matrix(self):
+        
+        example1 = IndShockConsumerType(**dict_harmenberg)
+        example1.cycles= 0
+        example1.solve()
+        
+        example1.define_distribution_grid()
+        p = example1.dist_pGrid # Grid of permanent income levels
+        
+        example1.calc_transition_matrix() 
+        c = example1.cPol_Grid # Normalized Consumption Policy Grid
+        asset = example1.aPol_Grid # Normalized Asset Policy Grid
+        
+        example1.calc_ergodic_dist()
+        vecDstn = example1.vec_erg_dstn # Distribution of market resources and permanent income as a vector (m*p)x1 vector where 
+        
+        
+        #Compute Aggregate Consumption and Aggregate Assets
+        gridc = np.zeros( (len(c),len(p)) )
+        grida = np.zeros( (len(asset),len(p)) )
+        
+        for j in range(len(p)):
+            gridc[:,j] = p[j]*c # unnormalized Consumption policy grid
+            grida[:,j] = p[j]*asset # unnormalized Asset policy grid
+            
+        AggC = np.dot(gridc.flatten(), vecDstn) #Aggregate Consumption
+        AggA = np.dot(grida.flatten(), vecDstn) #Aggregate Assets
+        
+        
+              
+        self.assertAlmostEqual(AggA[0],  1.1951311747835132, places =4) 
+        self.assertAlmostEqual(AggC[0], 1.0041701073134557, places = 4)
+
diff --git a/HARK/utilities.py b/HARK/utilities.py
index 01f5ab350..760b6e278 100644
--- a/HARK/utilities.py
+++ b/HARK/utilities.py
@@ -7,6 +7,7 @@
 import functools
 import pstats
 import warnings
+import numba
 
 import numpy as np  # Python's numeric library, abbreviated "np"
 
@@ -894,6 +895,252 @@ def epanechnikov_kernel(x, ref_x, h=1.0):
     return out
 
 
+
+@numba.njit            
+def jump_to_grid_1D(m_vals, probs ,Dist_mGrid ):
+    '''
+    Distributes values onto a predefined grid, maintaining the means.
+    
+    
+    Parameters
+    ----------
+    m_vals: np.array
+            Market resource values 
+
+    probs: np.array
+            Shock probabilities associated with combinations of m_vals. 
+            Can be thought of as the probability mass function  of (m_vals).
+    
+    dist_mGrid : np.array
+            Grid over normalized market resources
+
+    Returns
+    -------
+    probGrid.flatten(): np.array
+             Probabilities of each gridpoint on the combined grid of market resources
+  
+    ''' 
+
+    probGrid = np.zeros(len(Dist_mGrid))
+    mIndex = np.digitize(m_vals,Dist_mGrid) - 1
+    mIndex[m_vals <= Dist_mGrid[0]] = -1
+    mIndex[m_vals >= Dist_mGrid[-1]] = len(Dist_mGrid)-1
+    
+ 
+    for i in range(len(m_vals)):
+        if mIndex[i]==-1:
+            mlowerIndex = 0
+            mupperIndex = 0
+            mlowerWeight = 1.0
+            mupperWeight = 0.0
+        elif mIndex[i]==len(Dist_mGrid)-1:
+            mlowerIndex = -1
+            mupperIndex = -1
+            mlowerWeight = 1.0
+            mupperWeight = 0.0
+        else:
+            mlowerIndex = mIndex[i]
+            mupperIndex = mIndex[i]+1
+            mlowerWeight = (Dist_mGrid[mupperIndex]-m_vals[i])/(Dist_mGrid[mupperIndex]-Dist_mGrid[mlowerIndex])
+            mupperWeight = 1.0 - mlowerWeight
+            
+        probGrid[mlowerIndex] +=  probs[i]*mlowerWeight
+        probGrid[mupperIndex] +=  probs[i]*mupperWeight
+        
+    return probGrid.flatten()
+
+
+
+@numba.njit            
+def jump_to_grid_2D( m_vals, perm_vals, probs, dist_mGrid, dist_pGrid ):
+
+    '''
+    Distributes values onto a predefined grid, maintaining the means. m_vals and perm_vals are realizations of market resources and permanent income while 
+    dist_mGrid and dist_pGrid are the predefined grids of market resources and permanent income, respectively. That is, m_vals and perm_vals do not necesarily lie on their 
+    respective grids. Returns probabilities of each gridpoint on the combined grid of market resources and permanent income.
+    
+    
+    Parameters
+    ----------
+    m_vals: np.array
+            Market resource values 
+    
+    perm_vals: np.array
+            Permanent income values 
+    
+    probs: np.array
+            Shock probabilities associated with combinations of m_vals and perm_vals. 
+            Can be thought of as the probability mass function  of (m_vals, perm_vals).
+    
+    dist_mGrid : np.array
+            Grid over normalized market resources
+        
+    dist_pGrid : np.array
+            Grid over permanent income 
+    Returns
+    -------
+    probGrid.flatten(): np.array
+             Probabilities of each gridpoint on the combined grid of market resources and permanent income
+    '''
+    
+    probGrid = np.zeros((len(dist_mGrid),len(dist_pGrid)))
+    
+    #Maybe use np.searchsorted as opposed to np.digitize
+    mIndex = np.digitize(m_vals,dist_mGrid) - 1 # Array indicating in which bin each values of m_vals lies in relative to dist_mGrid. Bins lie between between point of Dist_mGrid. 
+    #For instance, if mval lies between dist_mGrid[4] and dist_mGrid[5] it is in bin 4 (would be 5 if 1 was not subtracted in the previous line). 
+    mIndex[m_vals <= dist_mGrid[0]] = -1 # if the value is less than the smallest value on dist_mGrid assign it an index of -1
+    mIndex[m_vals >= dist_mGrid[-1]] = len(dist_mGrid)-1 # if value if greater than largest value on dist_mGrid assign it an index of the length of the grid minus 1
+    
+    #the following three lines hold the same intuition as above
+    pIndex = np.digitize(perm_vals,dist_pGrid) - 1
+    pIndex[perm_vals <= dist_pGrid[0]] = -1
+    pIndex[perm_vals >= dist_pGrid[-1]] = len(dist_pGrid) - 1
+    
+    for i in range(len(m_vals)):
+        if mIndex[i]==-1: # if mval is below smallest gridpoint, then assign it a weight of 1.0 for lower weight. 
+            mlowerIndex = 0
+            mupperIndex = 0
+            mlowerWeight = 1.0
+            mupperWeight = 0.0
+        elif mIndex[i]==len(dist_mGrid)-1: # if mval is greater than maximum gridpoint, then assign the following weights
+            mlowerIndex = -1
+            mupperIndex = -1
+            mlowerWeight = 1.0
+            mupperWeight = 0.0
+        else: # Standard case where mval does not lie past any extremes
+        #identify which two points on the grid the mval is inbetween
+            mlowerIndex = mIndex[i] 
+            mupperIndex = mIndex[i]+1
+        #Assign weight to the indices that bound the m_vals point. Intuitively, an mval perfectly between two points on the mgrid will assign a weight of .5 to the gridpoint above and below
+            mlowerWeight = (dist_mGrid[mupperIndex]-m_vals[i])/(dist_mGrid[mupperIndex]-dist_mGrid[mlowerIndex]) #Metric to determine weight of gridpoint/index below. Intuitively, mvals that are close to gridpoint/index above are assigned a smaller mlowerweight.
+            mupperWeight = 1.0 - mlowerWeight # weight of gridpoint/ index above
+            
+        #Same logic as above except the weights here concern the permanent income grid
+        if pIndex[i]==-1: 
+            plowerIndex = 0
+            pupperIndex = 0
+            plowerWeight = 1.0
+            pupperWeight = 0.0
+        elif pIndex[i]==len(dist_pGrid)-1:
+            plowerIndex = -1
+            pupperIndex = -1
+            plowerWeight = 1.0
+            pupperWeight = 0.0
+        else:
+            plowerIndex = pIndex[i]
+            pupperIndex = pIndex[i]+1
+            plowerWeight = (dist_pGrid[pupperIndex]-perm_vals[i])/(dist_pGrid[pupperIndex]-dist_pGrid[plowerIndex])
+            pupperWeight = 1.0 - plowerWeight
+            
+        # Compute probabilities of each gridpoint on the combined market resources and permanent income grid by looping through each point on the combined market resources and permanent income grid, 
+        # assigning probabilities to each gridpoint based off the probabilities of the surrounding mvals and pvals and their respective weights placed on the gridpoint.
+        # Note* probs[i] is the probability of mval AND pval occurring
+        
+        
+        probGrid[mlowerIndex][plowerIndex] += probs[i]*mlowerWeight*plowerWeight # probability of gridpoint below mval and pval 
+        probGrid[mlowerIndex][pupperIndex] += probs[i]*mlowerWeight*pupperWeight # probability of gridpoint below mval and above pval
+        probGrid[mupperIndex][plowerIndex] +=  probs[i]*mupperWeight*plowerWeight # probability of gridpoint above mval and below pval
+        probGrid[mupperIndex][pupperIndex] +=  probs[i]*mupperWeight*pupperWeight # probability of gridpoint above mval and above pval
+
+    
+    return probGrid.flatten()
+
+
+
+@numba.njit(parallel=True)
+def gen_tran_matrix_1D(dist_mGrid, bNext, shk_prbs,perm_shks,tran_shks,LivPrb,NewBornDist):
+    
+    
+    """
+    Computes Transition Matrix across normalized market resources. 
+    This function is built to non-stochastic simulate the IndShockConsumerType.
+    This function is used exclusively when Harmenberg Neutral Measure is applied and/or if permanent income is not a state variable
+    For more information, see https://econ-ark.org/materials/harmenberg-aggregation?launch
+
+    Parameters
+    ----------
+    dist_mGrid : np.array
+        Grid over normalized market resources
+        
+    bNext : np.array
+        Grid over bank balances
+        
+    shk_prbs : np.array
+        Array of shock probabilities over combinations of permanent and transitory shocks
+        
+    perm_shks : np.array
+        Array of shocks to permanent income. Shocks should follow Harmenberg neutral measure
+        
+    tran_shks : np.array
+        Array of shocks to transitory 
+        
+    LivPrb : float
+        Probability of not dying
+        
+    NewBornDist : np.array
+        array representing distribution of newborns across grid of normalized market resources and grid of permanent income.
+        
+    Returns
+    -------
+    TranMatrix : np.array
+        Transition Matrix over normalized market resources grid.
+
+
+    """
+                 
+    TranMatrix = np.zeros((len(dist_mGrid),len(dist_mGrid))) 
+    for i in numba.prange(len(dist_mGrid)):
+        mNext_ij = bNext[i]/perm_shks + tran_shks  # Compute next period's market resources given todays bank balances bnext[i]
+        TranMatrix[:,i] = LivPrb*jump_to_grid_1D(mNext_ij, shk_prbs,dist_mGrid) + (1.0-LivPrb)*NewBornDist # this is the transition matrix if given you are unemployed today and unemployed tomorrow so you assume the unemployed consumption policy
+    return TranMatrix
+
+
+@numba.njit(parallel=True)
+def gen_tran_matrix_2D(dist_mGrid,dist_pGrid,bNext, shk_prbs,perm_shks,tran_shks,LivPrb,NewBornDist):
+    
+    """
+    Computes Transition Matrix over normalized market resources and permanent income. 
+    This function is built to non-stochastic simulate the IndShockConsumerType.
+
+    Parameters
+    ----------
+    dist_mGrid : np.array
+        Grid over normalized market resources
+        
+    dist_pGrid : np.array
+        Grid over permanent income 
+
+    bNext : np.array
+        Grid over bank balances
+        
+    shk_prbs : np.array
+        Array of shock probabilities over combinations of perm and tran shocks
+        
+    perm_shks : np.array
+        Array of shocks to permanent income
+        
+    tran_shks : np.array
+        Array of shocks to transitory income
+        
+    LivPrb : float
+        Probability of not dying
+        
+    NewBornDist : np.array
+         array representing distribution of newborns across grid of normalized market resources and grid of permanent income.
+
+    Returns
+    -------
+    TranMatrix : np.array
+        Transition Matrix over normalized market resources grid and permanent income grid
+    """
+    TranMatrix = np.zeros((len(dist_mGrid)*len(dist_pGrid),len(dist_mGrid)*len(dist_pGrid)))
+    for i in numba.prange(len(dist_mGrid)):
+        for j in numba.prange(len(dist_pGrid)):
+            mNext_ij = bNext[i]/perm_shks + tran_shks  # Compute next period's market resources given todays bank balances bnext[i]
+            pNext_ij = dist_pGrid[j]*perm_shks # Computes next period's permanent income level by applying permanent income shock
+            TranMatrix[:,i*len(dist_pGrid)+j] = LivPrb*jump_to_grid_2D(mNext_ij, pNext_ij, shk_prbs,dist_mGrid,dist_pGrid) + (1.0-LivPrb)*NewBornDist # this is the transition matrix if given you are unemployed today and unemployed tomorrow so you assume the unemployed consumption policy
+    return TranMatrix
+
 # ==============================================================================
 # ============== Some basic plotting tools  ====================================
 # ==============================================================================
diff --git a/examples/ConsIndShockModel/IndShockConsumerType_Transition_Matrix_Example.ipynb b/examples/ConsIndShockModel/IndShockConsumerType_Transition_Matrix_Example.ipynb
new file mode 100644
index 000000000..13ea48086
--- /dev/null
+++ b/examples/ConsIndShockModel/IndShockConsumerType_Transition_Matrix_Example.ipynb
@@ -0,0 +1,1255 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "54f0278c",
+   "metadata": {},
+   "source": [
+    "# Using Transition Matrix Methods under IndShockConsumerType \n",
+    "\n",
+    "By William Du (wdu9@jhu.edu)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52ce71ba",
+   "metadata": {},
+   "source": [
+    "This Jupyter Notebook demonstrates how to non-stochastically simulate an economy with transition matrices with functions under the IndShockConsumerType.\n",
+    "\n",
+    "The three key functions to non stochastically simulate are:\n",
+    "\n",
+    "##### define_distribution_grid\n",
+    "- computes the grid of normalized market resources and the grid permanent income storing each as attributes of self.\n",
+    "\n",
+    "###### calc_transition_matrix \n",
+    "- computes transition matrix (matrices), a grid of consumption policies, and a grid asset policies stored as attributes of self. If the problem has a finite horizon, this function stores lists of transition matrices, consumption policies and asset policies grid for each period as attributes of self.\n",
+    "\n",
+    "##### calc_ergodic_dist \n",
+    "- computes the ergodic distribution stored as attributes. The distribution is stored as a vector (self.vec_erg_dstn) and as a grid (self.erg_dstn)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ad742954",
+   "metadata": {},
+   "source": [
+    "## Set up Computational Environment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1f08d05f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n",
+    "\n",
+    "\n",
+    "import time\n",
+    "from copy import copy, deepcopy\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import time\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b7e817f",
+   "metadata": {},
+   "source": [
+    "## Set up the Dictionary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0dc82f9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\wdu\\AppData\\Local\\Temp\\ipykernel_18772\\4112512667.py:30: RuntimeWarning: divide by zero encountered in log\n",
+      "  \"aNrmInitMean\" :np.log(0.0),# Mean of log initial assets ,\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "Dict={\n",
+    "    # Parameters shared with the perfect foresight model\n",
+    "    \"CRRA\":2,                             # Coefficient of relative risk aversion\n",
+    "    \"Rfree\": 1.04**.25,                   # Interest factor on assets\n",
+    "    \"DiscFac\": 0.975,                     # Intertemporal discount factor\n",
+    "    \"LivPrb\" : [.99375],                  # Survival probability\n",
+    "    \"PermGroFac\" :[1.00],                 # Permanent income growth factor\n",
+    "\n",
+    "    # Parameters that specify the income distribution over the lifecycle\n",
+    "    \"PermShkStd\" :  [.06],                 # Standard deviation of log permanent shocks to income\n",
+    "    \"PermShkCount\" : 5,                    # Number of points in discrete approximation to permanent income shocks\n",
+    "    \"TranShkStd\" : [.2],                   # Standard deviation of log transitory shocks to income\n",
+    "    \"TranShkCount\" : 5,                    # Number of points in discrete approximation to transitory income shocks\n",
+    "    \"UnempPrb\" : 0.00,                     # Probability of unemployment while working\n",
+    "    \"IncUnemp\" :  .0,                      # Unemployment benefits replacement rate\n",
+    "    \"UnempPrbRet\" : 0.0000,                # Probability of \"unemployment\" while retired\n",
+    "    \"IncUnempRet\" : 0.0,                   # \"Unemployment\" benefits when retired\n",
+    "    \"T_retire\" : 0,                        # Period of retirement (0 --> no retirement)\n",
+    "    \"tax_rate\" : 0.0,                      # Flat income tax rate (legacy parameter, will be removed in future)\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\" : 98000,                 # Number of agents of this type\n",
+    "    \"T_sim\" : 1100,                       # Number of periods to simulate\n",
+    "    \"aNrmInitMean\" :np.log(0.0),# Mean of log initial assets , \n",
+    "    # The value of np.log(0.0) causes the code to ensure newborns have have exactly 1.0 in market resources.\n",
+    "    \n",
+    "    # Mean of log initial assets\n",
+    "    \"aNrmInitStd\"  : 0.0,                 # 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",
+    "    # Parameters for constructing the \"assets above minimum\" grid\n",
+    "    \"aXtraMin\" : 0.0001,                    # Minimum end-of-period \"assets above minimum\" value\n",
+    "    \"aXtraMax\" : 500,                       # Maximum end-of-period \"assets above minimum\" value\n",
+    "    \"aXtraCount\" : 90,                     # 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"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c91cd656",
+   "metadata": {},
+   "source": [
+    "## Create an Instance of IndShockConsumerType and Solve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fae48368",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "GPFRaw                 = 0.992274 \n",
+      "GPFNrm                 = 0.995482 \n",
+      "GPFAggLivPrb           = 0.986072 \n",
+      "Thorn = APF            = 0.992274 \n",
+      "PermGroFacAdj          = 0.996777 \n",
+      "uInvEpShkuInv          = 0.996777 \n",
+      "VAF                    = 0.965783 \n",
+      "WRPF                   = 0.000000 \n",
+      "DiscFacGPFNrmMax       = 0.983869 \n",
+      "DiscFacGPFAggLivPrbMax = 0.996471 \n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "example1 = IndShockConsumerType(**Dict)\n",
+    "example1.cycles = 0\n",
+    "example1.solve()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2e9b917",
+   "metadata": {},
+   "source": [
+    "# Simulation: Transition Matrix vs Monte Carlo"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "736c044f",
+   "metadata": {},
+   "source": [
+    "This section compares monte carlo methods against the transition matrix approach in computing aggregate consumption and aggregate assets."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c93e81d7",
+   "metadata": {},
+   "source": [
+    "## Method 1: Monte Carlo "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "749d88aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Simulation Parameters \n",
+    "\n",
+    "#Simulate\n",
+    "example1.track_vars = ['aLvl'] # Track level of assets\n",
+    "example1.initialize_sim()\n",
+    "example1.simulate() #Simulate with Monte Carlo\n",
+    "\n",
+    "#Compute Aggregate Consumption and Aggregate Assets\n",
+    "Monte_Carlo_Consumption = np.mean((example1.state_now['mNrm'] - example1.state_now['aNrm'])*example1.state_now['pLvl']) #Aggregate Consumption\n",
+    "Monte_Carlo_Assets = np.mean(example1.state_now['aNrm']*example1.state_now['pLvl']) #Aggregate Assets\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2507c98",
+   "metadata": {},
+   "source": [
+    "## Method 2: Transition Matrices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "74c568e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Seconds to calculate both the transition matrix and the steady state distribution 30.002366304397583\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "example1.define_distribution_grid(num_pointsP = 70,timestonest = 3)\n",
+    "p = example1.dist_pGrid # Grid of permanent income levels\n",
+    "\n",
+    "start = time.time()\n",
+    "\n",
+    "example1.calc_transition_matrix()\n",
+    "c = example1.cPol_Grid # Normalized Consumption Policy Grid\n",
+    "asset = example1.aPol_Grid # Normalized Asset Policy Grid\n",
+    "\n",
+    "example1.calc_ergodic_dist()\n",
+    "vecDstn = example1.vec_erg_dstn # Distribution of market resources and permanent income as a vector (m*p)x1 vector where \n",
+    "# m is the number of market resource gridpoints and p is the number of permanent income gridpoints\n",
+    "erg_dstn=example1.erg_dstn\n",
+    "\n",
+    "print('Seconds to calculate both the transition matrix and the steady state distribution', time.time() - start)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "cf241bb0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "#Compute Aggregate Consumption and Aggregate Assets\n",
+    "gridc = np.zeros( (len(c),len(p)) )\n",
+    "grida = np.zeros( (len(asset),len(p)) )\n",
+    "\n",
+    "for j in range(len(p)):\n",
+    "    gridc[:,j] = p[j]*c # unnormalized Consumption policy grid\n",
+    "    grida[:,j] = p[j]*asset # unnormalized Asset policy grid\n",
+    "    \n",
+    "AggC = np.dot(gridc.flatten(), vecDstn) #Aggregate Consumption\n",
+    "AggA = np.dot(grida.flatten(), vecDstn) #Aggregate Assets\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41339815",
+   "metadata": {},
+   "source": [
+    "### Comparing Steady State Outputs of Both Methods"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "4508692e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "TranMatrix Assets = [0.41757072]\n",
+      "Simulated Assets = 0.4130000603138478\n",
+      "TranMatrix Consumption = [1.00147553]\n",
+      "Simulated Consumption = 1.0035239330448291\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "print( 'TranMatrix Assets = ' + str(AggA) )\n",
+    "print('Simulated Assets = ' +str(Monte_Carlo_Assets) )\n",
+    "\n",
+    "print('TranMatrix Consumption = ' + str(AggC))\n",
+    "print('Simulated Consumption = ' +str(Monte_Carlo_Consumption))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e99ab28",
+   "metadata": {},
+   "source": [
+    "### Comparing Simulated Path of Aggregate Assets\n",
+    "\n",
+    "The following code plots the path of aggregate assets simulate from both Monte Carlo methods and transition matrix methods."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4caa59e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
+    "aLvls =[] # Time series of aggregate assets\n",
+    "\n",
+    "for i in range(example1.T_sim):\n",
+    "    aLvls.append(np.mean(example1.history['aLvl'][i])) #compute mean of aggregate assets across all agents for each period of the simulation\n",
+    "aLvls = np.array(aLvls)\n",
+    "\n",
+    "aLvl_tran_mat = []\n",
+    "dstn = vecDstn\n",
+    "for i in range(example1.T_sim-400):\n",
+    "\n",
+    "    A_val = np.dot(grida.flatten(),dstn) \n",
+    "    \n",
+    "    aLvl_tran_mat.append(A_val)\n",
+    "    dstn = np.dot( example1.tran_matrix,dstn)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ae083acc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.rcParams[\"figure.figsize\"] = (20,10)\n",
+    "plt.plot(aLvls[400:], label = 'Monte Carlo') # Plot time series path of aggregate assets using Monte Carlo simulation methods\n",
+    "plt.plot(aLvl_tran_mat , label = 'Transition matrix') # Plot time series path of aggregate assets computed using transition matrix\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.ylim([.37,.46])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86ff2025",
+   "metadata": {},
+   "source": [
+    "### Precision vs Accuracy\n",
+    "\n",
+    "Notice the mean level of aggregate assets differ between both simulation methods. The transition matrix plots a perfectly horizontal line as the initial distribution of agents across market resources and permanent is the unit eigenvector of the steady state transition matrix. Thus, as we take the produce of the transition matrix and the initial distribution, the new distribution does not change, implying the level of aggregate assets does not change. In contrast, the time series path simulated from Monte Carlo methods vacillates. This is because Monte Carlo methods are truly stochastic, randomly drawing shocks from a income distribution, while transition matrix methods are non-stochastic, the shock values are preset and the grid over market resources have is fixed. This contrast highlights the limitation of both methods, the monte carlo leads to a more accurate, yet less precise, level of aggregate assets while the transition matrix leads in precision but requires a larger number of gridpoints to be accurate. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a6e0f6e",
+   "metadata": {},
+   "source": [
+    "## Distribution of Normalized Market Resources"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "32250b58",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "num_pts = len(example1.dist_mGrid)\n",
+    "mdstn = np.zeros(num_pts) \n",
+    "\n",
+    "for i in range(num_pts):\n",
+    "    mdstn[i] = np.sum(example1.erg_dstn[i]) #distribution of normalized market resources\n",
+    "\n",
+    "h = np.histogram(example1.state_now['mNrm'],bins=example1.dist_mGrid)[0]/np.sum(np.histogram(example1.state_now['mNrm'],bins=example1.dist_mGrid)[0]) #Form Monte Carlo wealth data and put into histogram/bins\n",
+    "\n",
+    "\n",
+    "plt.plot(example1.dist_mGrid[:num_pts - 20],mdstn[:num_pts-20],label='Transition Matrix', linewidth = 3.0) # distribution using transition matrix method \n",
+    "plt.plot(example1.dist_mGrid[:num_pts-20-1],h[:num_pts-20-1] , label = 'Monte Carlo', linewidth = 3.0) #distribution using Monte Carlo\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.xlim([-.5,10])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b35fe81b",
+   "metadata": {},
+   "source": [
+    "## Distributions of Permanent Income "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f5c5a54f",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "dstn = example1.erg_dstn\n",
+    "\n",
+    "pdstn = np.zeros(len(dstn[0]))\n",
+    "for i in range(len(pdstn)):\n",
+    "    pdstn[i] = np.sum(dstn[:,i])\n",
+    "    \n",
+    "h = np.histogram(example1.state_now['pLvl'],bins=example1.dist_pGrid)[0]/np.sum(np.histogram(example1.state_now['pLvl'],bins=example1.dist_pGrid)[0]) #Form Monte Carlo wealth data and put into histogram/bins\n",
+    "plt.plot(example1.dist_pGrid[:-1],h,label='Monte Carlo', linewidth = 3.0) #distribution using Monte Carlo\n",
+    "plt.plot(example1.dist_pGrid,pdstn , label = 'transition matrix', linewidth = 3.0)\n",
+    "plt.ylabel('Probability')\n",
+    "plt.xlabel('Permanent Income')\n",
+    "plt.title('Distribution of Permanent Income')\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.xlim([-.1,4])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa0a10fd",
+   "metadata": {},
+   "source": [
+    "## Distribution of Wealth "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "3f93f08e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Compute all possible mLvl values given permanent income grid and normalized market resources grid\n",
+    "\n",
+    "mLvl_vals = []\n",
+    "\n",
+    "for m in example1.dist_mGrid:\n",
+    "        \n",
+    "    for p in example1.dist_pGrid:\n",
+    "        \n",
+    "        mLvl_vals.append(m*p)\n",
+    "\n",
+    "mLvl_vals = np.array(mLvl_vals)\n",
+    "\n",
+    "\n",
+    "\n",
+    "aLvl_vals = []\n",
+    "\n",
+    "for a in example1.aPol_Grid:\n",
+    "        \n",
+    "    for p in example1.dist_pGrid:\n",
+    "        \n",
+    "        aLvl_vals.append(a*p)\n",
+    "\n",
+    "aLvl_vals = np.array(aLvl_vals)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f591cffb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def jump_to_grid_fast(m_vals, probs ,Dist_mGrid ):\n",
+    "    \n",
+    "    '''\n",
+    "    Distributes values onto a predefined grid, maintaining the means.\n",
+    "    \n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    m_vals: np.array\n",
+    "            Market resource values \n",
+    "\n",
+    "    probs: np.array\n",
+    "            Shock probabilities associated with combinations of m_vals. \n",
+    "            Can be thought of as the probability mass function  of (m_vals).\n",
+    "    \n",
+    "    dist_mGrid : np.array\n",
+    "            Grid over normalized market resources\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    probGrid.flatten(): np.array\n",
+    "             Probabilities of each gridpoint on the combined grid of market resources\n",
+    "  \n",
+    "    ''' \n",
+    "\n",
+    "    probGrid = np.zeros(len(Dist_mGrid))\n",
+    "    mIndex = np.digitize(m_vals,Dist_mGrid) - 1\n",
+    "    mIndex[m_vals <= Dist_mGrid[0]] = -1\n",
+    "    mIndex[m_vals >= Dist_mGrid[-1]] = len(Dist_mGrid)-1\n",
+    "    \n",
+    " \n",
+    "    for i in range(len(m_vals)):\n",
+    "        if mIndex[i]==-1:\n",
+    "            mlowerIndex = 0\n",
+    "            mupperIndex = 0\n",
+    "            mlowerWeight = 1.0\n",
+    "            mupperWeight = 0.0\n",
+    "        elif mIndex[i]==len(Dist_mGrid)-1:\n",
+    "            mlowerIndex = -1\n",
+    "            mupperIndex = -1\n",
+    "            mlowerWeight = 1.0\n",
+    "            mupperWeight = 0.0\n",
+    "        else:\n",
+    "            mlowerIndex = mIndex[i]\n",
+    "            mupperIndex = mIndex[i]+1\n",
+    "            mlowerWeight = (Dist_mGrid[mupperIndex]-m_vals[i])/(Dist_mGrid[mupperIndex]-Dist_mGrid[mlowerIndex])\n",
+    "            mupperWeight = 1.0 - mlowerWeight\n",
+    "            \n",
+    "        probGrid[mlowerIndex] +=  probs[i]*mlowerWeight\n",
+    "        probGrid[mupperIndex] +=  probs[i]*mupperWeight\n",
+    "        \n",
+    "    return probGrid.flatten()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "9c6867ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "mLvl = example1.state_now['mNrm'] * example1.state_now['pLvl'] #market resources from Monte Carlo Simulations\n",
+    "pmf = jump_to_grid_fast(mLvl_vals, vecDstn, example1.dist_mGrid) # probabilities/distribution from transition matrix methods\n",
+    "h = np.histogram(mLvl,bins=example1.dist_mGrid)[0]/np.sum(np.histogram(mLvl,bins=example1.dist_mGrid)[0]) #Form Monte Carlo wealth data and put into histogram/bins\n",
+    "\n",
+    "plt.plot(example1.dist_mGrid[:num_pts-20-1],h[:num_pts-20-1] , label = 'Monte Carlo', linewidth = 3.0) #distribution using Monte Carlo\n",
+    "plt.plot(example1.dist_mGrid[:num_pts-20],pmf[:num_pts-20], label = 'transition Matrix', linewidth = 3.0)\n",
+    "plt.xlabel('Market Resources (Levels)')\n",
+    "plt.title('Distribution of Market Resources')\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.xlim([-.5,20])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11660f0b",
+   "metadata": {},
+   "source": [
+    "## Distribution of Liquid Assets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5d31a147",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABI0AAAJcCAYAAAB0elSEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB7PUlEQVR4nOzdd5hcV33/8feZ2SZpteq9WLIkW9VNcgFXOhhjm25CNySQBAgJEJyEgCEkPwIhJCQQMGB6bEoCMWAwNsYFcJNtWZIt2ZIlWb33snXO7487OzNbJK2k3Ttb3q/n2WfvOffce78zsojz8TnnhhgjkiRJkiRJUqlMuQuQJEmSJElS72NoJEmSJEmSpA4MjSRJkiRJktSBoZEkSZIkSZI6MDSSJEmSJElSB4ZGkiRJkiRJ6sDQSJIkARBC+EoI4e+76V5TQwgHQwjZfPueEMK7u+Pe+fv9MoTw9u663wk899MhhJ0hhK0neF13frcHQwinH+XcO0IIv+uO50iSJBkaSZI0AIQQ1oUQjoQQDoQQ9oYQ/hBCeG8IofDvAjHG98YY/6GL93rxscbEGNfHGGtjjC3dUPuNIYTvtbv/K2KM3z7Ve59gHVOBDwFzY4zjOzl/RQhhY2fXdvW77Yr897qmO+7VXgjhWyGE5hDChJ64f8lzDLckSeoDDI0kSRo4XhVjHAqcBnwG+Cjwje5+SAihorvv2UtMBXbFGLeXu5CeEEIYArwW2Ae8pczlSJKkXsDQSJKkASbGuC/GeBvwRuDtIYT5UJhl8un88egQws/zs5J2hxDuDyFkQgjfJQlPfpZfJvXXIYRpIYQYQnhXCGE9cHdJX2mANCOE8HAIYX8I4f9CCCPzz+owQ6d1NlMI4eXA3wJvzD/vifz5wnK3fF0fCyE8F0LYHkL4TghhWP5cax1vDyGszy8t+7ujfTchhGH563fk7/ex/P1fDNwJTMzX8a0T+c5Lv9t8+yMhhC0hhM0hhOvzNc5s/9ny7TazctqNHRVCuC3/nT4MzCgZF0IIX8h/J/tDCMta/6yP4rXAXuBTQJulfyGEC0IIi/P32RZC+Nd8f00I4XshhF35f1YeCSGMK/kuv5H/nJvyS/uyIYQ5wFeA5+W/y7358VeGEJ7Kz4bbFEL48Il8x5IkqfsZGkmSNEDFGB8GNgKXdnL6Q/lzY4BxJMFNjDG+FVhPMmupNsb42ZJrLgfmAC87yiPfBlwPTACagS92ocZfAf8E/CD/vLM7GfaO/M8LgNOBWuA/2425BDgTeBHw8Xxw0Zn/AIbl73N5vuZ3xhjvAl4BbM7X8Y7j1X40+SDsw8BLgFnAMZf6HceXgHqS7/T6/E+rlwKXAWeQfKY3ALuOca+3A7cAtwKzQwgLS879O/DvMcY6kmDqhyXXDAOmAKOA9wJH8ue+RfLnPBM4N1/Pu2OMK/LjHsh/l8Pz478BvCc/G24+cHdXvwRJktQzDI0kSRrYNgMjO+lvIgkiTosxNsUY748xxuPc68YY46EY45GjnP9ujHF5jPEQ8PfAG0J+o+xT9GbgX2OMa2KMB4G/Aa5rN8vpkzHGIzHGJ4AngA7hU76W64C/iTEeiDGuAz4PvLUbaiz1BuCbJd/FjSdzk3y9rwU+nv/elwOl+zw1AUOB2UCIMa6IMW45yr2mkoRu/x1j3Ab8hiQwK73XzBDC6BjjwRjjgyX9o4CZMcaWGOOjMcb9+dlGVwIfzNe2HfgCyfd7NE3A3BBCXYxxT4zxsRP7RiRJUnczNJIkaWCbBOzupP9zwGrg1yGENSGEG7pwrw0ncP45oBIY3aUqj21i/n6l964gmSHVqvRtZ4dJZiO1NzpfU/t7TeqGGktNpON3cTLGkHzOTu8VY7ybZMbVl4DtIYSbQgh1R7nXW4EVMcYl+fb3gT8KIVTm2+8imbG0Mr8E7ap8/3eBO4Bb80vtPpu/5jSS73JLftnaXuCrwNhjfJ7XkgRNz4UQ7g0hPO/4X4EkSepJhkaSJA1QIYTzSQKRDm+xys+0+VCM8XTgauCvQggvaj19lFsebybSlJLjqSQzS3YCh4DBJXVlSQKRrt53M0lIUXrvZmDbca5rb2e+pvb32nSC9zmeLXT8Lkq1+T6ADm9qy9tB8jmPeq8Y4xdjjAuBuSShz0eOcq+3AaeHELaGELYC/0oSol2Zv8+qGOObSEKffwZ+HEIYkp+F9skY41zg+cBV+XttABqA0THG4fmfuhjjvNbS2hcQY3wkxnhN/hk/pbgETpIklYmhkSRJA0wIoS4/U+RW4HsxxmWdjLkqhDAzhBBI3qbVAuTyp7eR7Plzot4SQpgbQhhMstnyj2OMLcAzQE0I4ZX5WSofA6pLrtsGTAshHO3fW24B/jKEMD2EUEtxD6TmEykuX8sPgX8MIQwNIZwG/BXwvRO5T35z6NKf0G7ID4F3lHwXn2h3fgnwmhDC4PyG1+86Rr3/C9yYHzuXkg2sQwjnhxAuzH+nh0j2Psq1v09+Rs8M4ALgnPzPfOC/yS9RCyG8JYQwJsaYI9ksGyAXQnhBCGFBPujbTxK65fLL4H4NfD7/z1smhDAjhHB5/tptwOQQQlX+/lUhhDeHEIbFGJvy9+pQqyRJSpehkSRJA8fPQggHSGaB/B3JbJJ3HmXsLOAu4CDwAPDlGONv8+f+H/Cx/LKjE3nD1XdJNkfeCtQAH4DkbW7AnwFfJ5nVc4hkE+5WP8r/3hVC6Gyfm5vz974PWEsSjrz/BOoq9f7889eQzMD67/z9u2oSyUbQpT8zSgfEGH8J/BvJRs+r6bjh8xeARpJg5dskS8WO5n0kS+22kny33yw5Vwd8DdhDsmxtF8myw/beDvxfjHFZjHFr6w/J5tdXheQtdy8HngwhHMz3X5ffu2o88GOSkGcFcC/JnwUkgVMV8FS+hh+T7JNF/jM/CWwNIezM970VWBdC2E+yUfabj/G5JUlSCsLx97SUJElSTwohRGBWjHF1uWuRJElq5UwjSZIkSZIkdWBoJEmSJEmSpA5cniZJkiRJkqQOnGkkSZIkSZKkDirKXUB7o0ePjtOmTSt3GZIkSZIkSf3Go48+ujPGOOZErul1odG0adNYvHhxucuQJEmSJEnqN0IIz53oNS5PkyRJkiRJUgeGRpIkSZIkSerA0EiSJEmSJEkd9Lo9jSRJkiRJUjqamprYuHEj9fX15S5F3aSmpobJkydTWVl5yvcyNJIkSZIkaYDauHEjQ4cOZdq0aYQQyl2OTlGMkV27drFx40amT59+yvdzeZokSZIkSQNUfX09o0aNMjDqJ0IIjBo1qttmjhkaSZIkSZI0gBkY9S/d+edpaCRJkiRJkqQODI0kSZIkSVLZhBB4y1veUmg3NzczZswYrrrqqpO63969e/nyl798wtcdPHiQ97znPcyYMYOFCxdyxRVX8NBDD53QPa644goWL158ws/urQyNJEmSJElS2QwZMoTly5dz5MgRAO68804mTZp00vc72dDo3e9+NyNHjmTVqlU8+uijfPOb32Tnzp1dvr6lpeWEn9nbGRpJkiRJkqSyuvLKK/nFL34BwC233MKb3vSmwrndu3dz7bXXctZZZ3HRRRexdOlSAG688Uauv/56rrjiCk4//XS++MUvAnDDDTfw7LPPcs455/CRj3wEgM997nOcf/75nHXWWXziE5/o8Pxnn32Whx56iE9/+tNkMklUMn36dF75ylcCcO2117Jw4ULmzZvHTTfdVLiutraWD33oQ5x99tk88MADbe55yy23sGDBAubPn89HP/rR7vqqUlVR7gIkSZIkSVL5TbvhFz1273WfeeUxz1933XV86lOf4qqrrmLp0qVcf/313H///QB84hOf4Nxzz+WnP/0pd999N29729tYsmQJACtXruS3v/0tBw4c4Mwzz+RP//RP+cxnPsPy5csLY37961+zatUqHn74YWKMXH311dx3331cdtllhec/+eSTnHPOOWSz2U7ru/nmmxk5ciRHjhzh/PPP57WvfS2jRo3i0KFDXHjhhXz+859vM37z5s189KMf5dFHH2XEiBG89KUv5ac//SnXXnvtyX2BZeJMI0mSJEmSVFZnnXUW69at45ZbbuHKK69sc+53v/sdb33rWwF44QtfyK5du9i/fz8Ar3zlK6murmb06NGMHTuWbdu2dbj3r3/9a379619z7rnnct5557Fy5UpWrVp1QvV98Ytf5Oyzz+aiiy5iw4YNheuz2Syvfe1rO4x/5JFHuOKKKxgzZgwVFRW8+c1v5r777juhZ/YGzjSSJEmSJElld/XVV/PhD3+Ye+65h127dnXpmurq6sJxNpulubm5w5gYI3/zN3/De97znqPeZ968eTzxxBO0tLR0mG10zz33cNddd/HAAw8wePBgrrjiCurr6wGoqak56uyk/sDQSJIkSZIkHXcJWU+7/vrrGT58OAsWLOCee+4p9F966aV8//vf5+///u+55557GD16NHV1dUe9z9ChQzlw4ECh/bKXvYy///u/581vfjO1tbVs2rSJyspKxo4dWxgzY8YMFi1axCc+8Qn+4R/+gRAC69at48knn6S5uZkRI0YwePBgVq5cyYMPPnjcz3LBBRfwgQ98gJ07dzJixAhuueUW3v/+95/cF1NGhkaSJEmSJKnsJk+ezAc+8IEO/a0bXp911lkMHjyYb3/728e8z6hRo7j44ouZP38+r3jFK/jc5z7HihUreN7zngckm1d/73vfaxMaAXz961/nQx/6EDNnzmTQoEGMHj2az33uc5x11ll85StfYc6cOZx55plcdNFFx/0sEyZM4DOf+QwveMELiDHyyle+kmuuueYEvo3eIcQYy11DG4sWLYqLFy8udxmSJEmSJPV7K1asYM6cOeUuQ92ssz/XEMKjMcZFJ3IfN8KWJEmSJElSB4ZGkiRJkiRJ6sDQSJIkSZIkSR0YGkmSJEmSJKkD357Wi/1i6Rae2LiXsUOrmTxiEBOHD2LS8EGMHFJFCKHc5UmSJEmSpH7M0KiXemTdbv78vx/r9FxNZYYzxw3lFQsm8MoFE5gycnDK1UmSJEmSpP7O5Wm91P2rdh7lTOR5LY8ybPN9fOaXK7n0s7/l1V/+PTf/bi3b9tenWqMkSZIkSadi7969fPnLX+7x5yxevJgPfOADANxzzz384Q9/KJz7yle+wne+851Tfsa6desIIfCxj32s0Ldz504qKyt53/ved8xr29fU3m233cZnPvOZU67xRDnTqJdauWV/4fiSmaOpqsiwee8R3rjnJt4ZfgbAexo/yB25C3h8/V4eX7+Xf/jFU5w/bSR/esUMXnDm2HKVLkmSJElSl7SGRn/2Z3/W4VxzczMVFd0TWyxatIhFixYBSUBTW1vL85//fADe+973dsszAKZPn84vfvELPv3pTwPwox/9iHnz5h33uvY1lWpububqq6/m6quv7rY6u8qZRr3Uiq3F0Ohvr5zDze84n189/+lCYATwvrr7qcgU9zaKER5eu5v3fOdRdh1sSLVeSZIkSZJO1A033MCzzz7LOeecw0c+8hHuueceLr30Uq6++mrmzp0LwLXXXsvChQuZN28eN910U+Ha2tpa/u7v/o6zzz6biy66iG3btgFJUDN//nzOPvtsLrvsMiAJZa666irWrVvHV77yFb7whS9wzjnncP/993PjjTfyL//yLwAsWbKEiy66iLPOOotXv/rV7NmzB4ArrriCj370o1xwwQWcccYZ3H///Z1+nsGDBzNnzhwWL14MwA9+8APe8IY3FM7/7Gc/48ILL+Tcc8/lxS9+Mdu2beu0pne84x28973v5cILL+Sv//qv+da3vlWYrXTNNdcUZkZ99atf5c1vfnO3/Xm050yjXuhAfRMbdh8BoCITmDF2CDz9S/jlX7cZt6BhCYv/8lx+ubaJny/dzAPP7iIXobElxyPr9vDy+ePLUb4kSZIkqS+6cVgP3ntfp92f+cxnWL58OUuWLAGScOexxx5j+fLlTJ8+HYCbb76ZkSNHcuTIEc4//3xe+9rXMmrUKA4dOsRFF13EP/7jP/LXf/3XfO1rX+NjH/sYn/rUp7jjjjuYNGkSe/fubfO8adOm8d73vpfa2lo+/OEPA/Cb3/ymcP5tb3sb//Ef/8Hll1/Oxz/+cT75yU/yb//2b0Ay4+fhhx/m9ttv55Of/CR33XVXp5/puuuu49Zbb2XcuHFks1kmTpzI5s2bAbjkkkt48MEHCSHw9a9/nc9+9rN8/vOf71DTN77xDTZu3Mgf/vAHstks3/rWtwr3v+mmm7j44ouZPn06n//853nwwQdP6I/iRDjTqBd6euuBwvHMsbVUb3sCfnw9xFzbgbGF4et/zZsumMr3330Rf3zp6YVTj6/fk1a5kiRJkiR1mwsuuKAQGAF88YtfLMwm2rBhA6tWrQKgqqqKq666CoCFCxeybt06AC6++GLe8Y538LWvfY2WlpYuP3ffvn3s3buXyy+/HIC3v/3t3HfffYXzr3nNazo8qzMvf/nLufPOO7n11lt54xvf2Obcxo0bednLXsaCBQv43Oc+x5NPPnnU+7z+9a8nm8126B83bhyf+tSneMELXsDnP/95Ro4c2eXPeKIMjXqhFSX7GT1/5EH47zdA0+GkY/hpcMlfFgc/9dPC4blTRxSOHzM0kiRJkiT1QUOGDCkc33PPPdx111088MADPPHEE5x77rnU1ycvgaqsrCSEZMuWbDZLc3MzkGxs/elPf5oNGzawcOFCdu3a1S11VVdXd3hWZ6qqqli4cCGf//zned3rXtfm3Pvf/37e9773sWzZMr761a8WPktnSr+H9pYtW8aoUaMKM5h6isvTeqEV+ZlGdRzk/Vv/CQ7vSE7UDIe3/A9UDoLffSHpW3MvHN4Ng0dy3mnDC/dYunEfjc05qirMBSVJkiRJXXCUJWQ9aejQoRw4cOCo5/ft28eIESMYPHgwK1eu7NJSrGeffZYLL7yQCy+8kF/+8pds2LChwzP379/f4bphw4YxYsQI7r//fi699FK++93vFmYdnagPfehDXH755R1mAe3bt49JkyYB8O1vf/u4NXXm4Ycf5pe//CWPP/44l19+OS996UvbzMzqTiYKvcmhXbD+ISas+TF/XXErP6j6NCMOr0vOZavgTbfA6FkwbDJMviDpjy2wItkce+zQGiaPGARAQ3OOlVu79g+cJEmSJEnlMGrUKC6++GLmz5/PRz7ykQ7nX/7yl9Pc3MycOXO44YYbuOiii457z4985CMsWLCA+fPn8/znP5+zzz67zflXvepV/OQnPylsOl3q29/+Nh/5yEc466yzWLJkCR//+MdP6nPNmzePt7/97R36b7zxRl7/+tezcOFCRo8e3aWaSjU0NPDHf/zH3HzzzUycOJHPf/7zXH/99cQYT6rO4wk9deOTtWjRoti6y/iAcWQvfPda2Pz40ce87maY/9pi+4EvwR1/mxzPeCG89ScAfOCWx7ntiWR62o2vmss7Lu6ZtFGSJEmS1PetWLGCOXPmlLsMdbPO/lxDCI/GGBedyH2cadQbPHHr0QOjkIGX/mPbwAhg7jXF49YlasC5U4cXuh9bv7d765QkSZIkSQOGexr1BhsfLhweGjKV3+6fyLNxAlVjZvGnb7kORs3oeE3rErWNDydL1Fb+HM57G+e5GbYkSZIkSeoGzjTqDTY+Ujj86Yx/4H1NH+ALza9n98xXdx4YtZp3bfH4yWR52pwJdVTnN7/euOcI2w8cfSd2SZIkSZJ627Y1OjXd+edpaFRuB7fD3vXJcbaa+w+MK5yaPb7u2Nd2skStqiLDWZOHFbofd4maJEmSJOkoampq2LVrl8FRPxFjZNeuXdTU1HTL/VyeVm4bSzb9nngOT247UmjOmXCc0GjYZJh8fjJTqWSJ2rlTR/DIumRp2mPr9/CyeeN7onJJkiRJUh83efJkNm7cyI4dO8pdirpJTU0NkydP7pZ7GRqVW8nStMbx57FhVRIaVWQCM8fWHv/6ea8u3uPJn+b3NRpeOP34c3u7r1ZJkiRJUr9SWVnJ9Om+dVudc3lauW0qzjTaMHhu4Xjm2FqqKrrwx1O6RG1tskStdDPspZv20tSS65ZSJUmSJEnSwGFoVE65Ftj0WKG5JM4qHB93aVqr1iVqALlmWPlzxtbVMGn4IADqm3Ks3HKg20qWJEmSJEkDg6FROe1YCY0Hk+Pa8Ty6d0jh1OzxQ7t+n7nXFo+f/CkA55YsUXts/Z6Tr1GSJEmSJA1IhkblVLoJ9uRFrNhanBHU5ZlGcNwlaoZGkiRJkiTpRBkalVPJJti5SYt4uiQ0mj3hBGYaDZ/SbonaLzjvNEMjSZIkSZJ08gyNyqlkptG2ugUcbmwBYHRtFWOH1pzYvdosUfsJcyfUFTbS3rD7CDsONJxqtZIkSZIkaQAxNCqX+v3JnkYAIcOy3LTCqRNamtaq3RK1qqZ9LJg0rND1uLONJEmSJEnSCTA0KoOlG/fyX//9IyAmHWPnsXxnrnD+hDbBbjV8CkxamBznmmHNPZzXZjPsvSddryRJkiRJGngMjcrgYz9dzsFnHyy0WyYtZMWW/YX2Sc00Apj5kuLx6rvcDFuSJEmSJJ00Q6MyWLvzEOdkVhfaX187kmUb9xXas8efbGj0ouLx6rvbzDRaunEvzS25jtdIkiRJkiR1wtAoZTFGDjc2c25JaPTDrRPYur8egIpMYObY2pO7+cTzoGZ4cnxgM+Pq1zJxWLKhdn1TjpUlb2eTJEmSJEk6FkOjlDW25JgYtzE6JMvR9sfBrIkTCudnjq0tvPXshGUr4PQriu3Vd3HuaS5RkyRJkiRJJ87QKGWHG1o4NzxbaDeMO4eqiopCe+7J7mfUauaLi8fP/qbtvkbPGRpJkiRJkqSuMTRK2aHGZs7NrCq0x8y+hB+853nMHFvLmKHVXH/J9FN7wIwXFo+f+wOLJlQVmo9v2Htq95YkSZIkSQNGxfGHqDsdaWxps58Rk8/nnCnDufMvLyMXIZsJp/aAYZNg7FzY/hS0NDK3aRlV2QyNLTme23WYnQcbGF1bfWrPkCRJkiRJ/Z4zjVJ2qLGFSWFHsWPcPABCCKceGLUqmW1UueZu5k8qLnl7fP3e7nmGJEmSJEnq1wyNUna4oZlqmosdVYO7/yHH2tfIzbAlSZIkSVIXGBql7HBjC1U0FTuyPbBUbOrzoGJQcrxrNRePPlQ49bihkSRJkiRJ6gJDo5QdamiiqnSmUUUPhEaVNTD90kLzvMZHC8dPbNhHc0uu+58pSZIkSZL6lS6FRiGEl4cQng4hrA4h3NDJ+eoQwg/y5x8KIUzL91eGEL4dQlgWQlgRQvibbq6/zznS0EAmRABayEIm2zMPmvGiwuGwTfcxYVhN8vymFlZuPdAzz5QkSZIkSf3GcUOjEEIW+BLwCmAu8KYQwtx2w94F7IkxzgS+APxzvv/1QHWMcQGwEHhPa6A0UNUfOVI4bslU9tyDSvc1Wnsf50+pLTSf2Li3554rSZIkSZL6ha7MNLoAWB1jXBNjbARuBa5pN+Ya4Nv54x8DLwohBCACQ0IIFcAgoBHY3y2V91FNDSWhUajquQeNmgHDpybHjQd4wZB1hVPPbj/U+TWSJEmSJEl5XQmNJgEbStob832djokxNgP7gFEkAdIhYAuwHviXGOPu9g8IIfxJCGFxCGHxjh072p/uVxoa6gvHuWwPzjQKoc1sowX1iwvHa3ce7LnnSpIkSZKkfqGnN8K+AGgBJgLTgQ+FEE5vPyjGeFOMcVGMcdGYMWN6uKTyaiyZaZTL9OBMI2izr9HkXX8oHK/d6UwjSZIkSZJ0bF0JjTYBU0rak/N9nY7JL0UbBuwC/gj4VYyxKca4Hfg9sOhUi+7LmhqLM41itgfenFZq+mWQqQCgZudyRrMPgA17jtDY7BvUJEmSJEnS0XUlNHoEmBVCmB5CqAKuA25rN+Y24O3549cBd8cYI8mStBcChBCGABcBK7uj8L6quSQ0ItvDM41q6mDKRYXm1UOTr74lF1m/+3DPPluSJEmSJPVpxw2N8nsUvQ+4A1gB/DDG+GQI4VMhhKvzw74BjAohrAb+Crgh3/8loDaE8CRJ+PTNGOPS7v4QfUlzyZ5GVPRwaAQw84WFwxdVLiscu0RNkiRJkiQdS0VXBsUYbwdub9f38ZLjeuD1nVx3sLP+gaylqaHY6OnlaZBshv2bTwFwTsNjBHJEMqzZcRAY1/PPlyRJkiRJfVJPb4StdlqaijONQmUKodG4BTAk2Vx8SMte5od1gDONJEmSJEnSsRkapSxXMtMoU1HT8w/MZNq8Re2yTLI6cI2hkSRJkiRJOgZDo5TlmoszjbJpzDQCmFkMjS7PPgE400iSJEmSJB2boVHKYulMo7RCoxkvBAIA54VVDOUwOw40cKC+KZ3nS5IkSZKkPsfQKEUxRmJzMTTKVqawPA1gyGiYcDYAFSHH8zPLAWcbSZIkSZKkozM0SlFDc45Kmgvt1JanAcx4QeHw/MzTgKGRJEmSJEk6OkOjFB1ubKGKkiVhFSmGRlMuLByel1kFwLM7DI0kSZIkSVLnDI1SdKihuW1olK1K7+GTzy8czgvrqKLJmUaSJEmSJOmoDI1SdKSphaqS5WmpzjQaMhpGng5AdWhmXljH2p0H03u+JEmSJEnqUwyNUnSooZmqUDrTKMXQCGDyBYXD8zKrWLvjEDHGdGuQJEmSJEl9gqFRipI9jUpnGqW4PA1g8qLC4bmZVRxqbGH7gYZjXCBJkiRJkgYqQ6MUHW5soZoyzjSa0namEcAaN8OWJEmSJEmdMDRK0eHG5vLONBo7DyqHADAx7GY8u9wMW5IkSZIkdcrQKEWHGlravT0t5ZlG2QqYdF6heW5mNWt2uBm2JEmSJEnqyNAoRYcbm6kKZXp7WqvJ5xcOz8uscqaRJEmSJEnqlKFRipKNsEtnGqW8PA0MjSRJkiRJUpcYGqXoUIc9jco702h+WMvW3ftoasmlX4ckSZIkSerVDI1SdLjDnkZlmGlUOwZGTAegOjRzRlzHht2H069DkiRJkiT1aoZGKTrc2FL+PY0AplxQOHSJmiRJkiRJ6oyhUYoONzZTXc63p7VyXyNJkiRJknQchkYpOtTY0m5PozIsT4M2odG5mVU8u8PQSJIkSZIktWVolKIjjc3t9jQq00yjcfNpyQ4CYFLYxd5t68pThyRJkiRJ6rUMjVJ0qP1G2OWaaZStoGncOYXmsF1LylOHJEmSJEnqtQyNUnS4sbntRtjlmmkEVE0rboZ9ev0KDjU0H2O0JEmSJEkaaAyNUnS4sf1Mo/KFRpmpFxaO3QxbkiRJkiS1Z2iUosPtN8LOlml5GsDk4kyjBWEta7fvKV8tkiRJkiSp1zE0SkmMkUPtN8Iu40wjasewp3oSANWhiUPrHi9fLZIkSZIkqdcxNEpJQ3MOYo6q0FLsLOdMI2DfqLMLx1VbFpexEkmSJEmS1NsYGqXkUENzx6VpIZSvIGizRG303qVlLESSJEmSJPU2hkYp6bifURmXpuXVnfH8wvHMhqeIMZaxGkmSJEmS1JsYGqWk45vTyrs0DWDEtHM5EpM6Joad7N66vswVSZIkSZKk3sLQKCXJJti9a6ZRqKji2cozCu1dK+8vYzWSJEmSJKk3MTRKyeGGFqpCyUyjbGX5iimxtW5B4bhl/SNlrESSJEmSJPUmhkYpOdx+plFF+WcaARwZd17huHbHY2WsRJIkSZIk9SaGRinpsKdRL1ieBlB52oWF4/GHVkBzYxmrkSRJkiRJvYWhUUoONTZT3cs2wgaYPGUa63NjAKiMTbB1WZkrkiRJkiRJvYGhUUqONLZQFXrXRtgA00YP4fE4q9BuWf9QGauRJEmSJEm9haFRSg41tFue1ktmGtVWV7Cqck6hXb/2wTJWI0mSJEmSegtDo5R02Ai7l8w0Atg98uzCcWbT4jJWIkmSJEmSegtDo5QcamzulTONAMKEs6iPlQAMOrwJDmwtc0WSJEmSJKncDI1Skrw9rXfONJo2ZhhL4+nFjg0Pl68YSZIkSZLUKxgapeRwQwtVoXSmUe8JjaaPHsLSXElotH1F+YqRJEmSJEm9gqFRSg512NOo9yxPO33MEJ6NE4sdu1aVrxhJkiRJktQrGBql5EhjC9X0zplGU0YOZi2TCu2WHc+UsRpJkiRJktQbGBql5FCHPY16z0yjymyGxmEzih27VkOM5StIkiRJkiSVnaFRSg53eHta75lpBDBizET2x8EAZJsO+QY1SZIkSZIGOEOjlBxubLcRdi96exrA9DG1rIkTih07XaImSZIkSdJAZmiUksMN7TbCrug9y9MAZo2r5dnS0MjNsCVJkiRJGtAMjVIQY+RwU0vb5Wm9bKbRzLG1rMmVvEFt5+ryFSNJkiRJksrO0CgF9U05YqRXzzSaOWZom+VpcaczjSRJkiRJGsgMjVJwqDEJi3rznkbDBleyZ/C0Qrt5h3saSZIkSZI0kBkapeBwQwsA1W1mGvWu0AigeuxMcjEAULF/AzTVl7kiSZIkSZJULoZGPay5JcfD63YDtNvTqHctTwM4bdxINsbRAAQi7F5T5ookSZIkSVK5VJS7gP7und96hPtX7QTa72nU+2YazRxby5o4kansSDp2rYJxc8tblCRJkiRJKgtnGvWg+qaWQmAEvX+mURIaFTfDZqf7GkmSJEmSNFAZGqWoKvSFmUa+QU2SJEmSJBkapartTKPeFxqNqa1mW+WUQrtpuzONJEmSJEkaqAyNUtR2T6PetzwthEAcfUahndm1GmIsY0WSJEmSJKlcDI1S1NtnGgGMHj+Vg7EGgIqmA3BoR5krkiRJkiRJ5WBolKK2exr1vplGADPHDW23Gbb7GkmSJEmSNBAZGqWoug/MNJrR/g1quwyNJEmSJEkaiAyNUtRmeVovfHsawKyxtazJTSx2ONNIkiRJkqQBydAoRW02ws72zuVpE4cNYmN2UqHduO3pMlYjSZIkSZLKxdAoRX1hplEmE2geMaPQzu14pozVSJIkSZKkcjE0SkmWFrKh9fX1ATIVZa3nWGrGn1k4rjq4EZoby1iNJEmSJEkqB0OjlHSYZRRC+Yo5jtPGj2ZjHA1AJrbAnrVlrkiSJEmSJKXN0Cglbfcz6p1L01rNHFvLmlzJG9TcDFuSJEmSpAHH0CglbWca9c5NsFvNHFvLmlgSGu0yNJIkSZIkaaAxNEpJdeg7M41OGzmY58LEQrtpm5thS5IkSZI00BgapaQvzTSqyGY4MnR6od2w7ekyViNJkiRJksrB0CglfWlPI4CKscU3qFXuWV3GSiRJkiRJUjkYGqVkSLal2OjlM40ARk6czuGYhFvVTfvg0K4yVyRJkiRJktJkaJSSNsvT+sBMo1nj6lgbxxc73AxbkiRJkqQBxdAoJVWhdE+j3h8adXiD2k5DI0mSJEmSBhJDo5S03dOo9y9Pmz56CGtj8Q1qzTt8g5okSZIkSQOJoVFK2r49rffPNKqpzLJvyGmF9uHNK8tYjSRJkiRJSpuhUUr62kwjAEbNKhyGXb5BTZIkSZKkgcTQKCV9baYRwJCJswvHgw89By1NxxgtSZIkSZL6E0OjlLR9e1rfmGk0dcI4tsSRAGRjC+x5rswVSZIkSZKktBgapaTN8rQ+MtNo1tha1uRK3qC2yzeoSZIkSZI0UBgapaSyzUyjvhEazRhby5pYDI1afIOaJEmSJEkDhqFRStrONOoby9NqqyvYWT210D7kG9QkSZIkSRowDI1SUhX63kwjgKYRMwrHzdudaSRJkiRJ0kBhaJSStm9P6xszjQCqx59ZOK7Zt6aMlUiSJEmSpDQZGqWkzfK0PjTTaOzkmTTESgAGN+2GI3vKXJEkSZIkSUqDoVFK2s406juh0Yxxw1gbxxc7dq4uXzGSJEmSJCk1hkYpaTvTqO8sT5s1tpZnS96gltvpvkaSJEmSJA0EhkYp6aszjUYMqWJLxZRC++CmFWWsRpIkSZIkpcXQKCVtQqM+NNMIoL5uevF469NlrESSJEmSJKXF0CglbZan9aGZRgDZsWcUjiv2PFvGSiRJkiRJUloMjVLSdqZR3wqNhk6aUzw+vAFyLWWsRpIkSZIkpcHQKCVVoXSmUd9anjZt0kR2xGEAVMZG2Lu+zBVJkiRJkqSeZmiUkr4802jm2FrWlLxBLe5cVcZqJEmSJElSGgyNUtJ2T6O+NdNoXF0168PkQvvg5qfKWI0kSZIkSUqDoVFK+vJMoxACB2qnFdqHNq0sXzGSJEmSJCkVhkYpaRMa9bG3pwHEUbOKDZenSZIkSZLU7xkapaTN8rRs31qeBjB4wpnF4wNry1iJJEmSJElKg6FRSvr6TKNxU8+gMWYBqGveBfX7y1yRJEmSJEnqSYZGKenrM41mjh/B2pI3qLHDfY0kSZIkSerPDI1S0tdnGk0aMYhnOK3QPrz+sTJWI0mSJEmSepqhUSoiVaF0plHfC42ymcC2IcV9jQ6uNTSSJEmSJKk/MzRKQSUtxUamAjJ982tvGrugcJzZtrSMlUiSJEmSpJ7WN9OLPqbN0rQ+OMuoVe1p5xaOhx9cDS1NxxgtSZIkSZL6MkOjFLTdz6jvbYLdasbUKWyMowGoiE1uhi1JkiRJUj9maJSCtm9O67szjWZPqOPJ3LRCO7f5ifIVI0mSJEmSelSXQqMQwstDCE+HEFaHEG7o5Hx1COEH+fMPhRCmlZw7K4TwQAjhyRDCshBCTTfW3ydUhf4x02jkkCqeq5pRaO93M2xJkiRJkvqt44ZGIYQs8CXgFcBc4E0hhLnthr0L2BNjnAl8Afjn/LUVwPeA98YY5wFXAANuI5z+MtMI4NDI+YXjls1LyleIJEmSJEnqUV2ZaXQBsDrGuCbG2AjcClzTbsw1wLfzxz8GXhRCCMBLgaUxxicAYoy7YowtDDDVbfY06tuhUeXkcwrHQ/esgFyufMVIkiRJkqQe05XQaBKwoaS9Md/X6ZgYYzOwDxgFnAHEEMIdIYTHQgh/3dkDQgh/EkJYHEJYvGPHjhP9DL1e25lGfXd5GsCUqaezM9YBUJU7DHvWlrkiSZIkSZLUE3p6I+wK4BLgzfnfrw4hvKj9oBjjTTHGRTHGRWPGjOnhktJX1Y9mGs2dOIyncqcVO7a4GbYkSZIkSf1RV0KjTcCUkvbkfF+nY/L7GA0DdpHMSrovxrgzxngYuB0471SL7muqQv+ZaTR99BBWhumFdv2Gx8tYjSRJkiRJ6ildCY0eAWaFEKaHEKqA64Db2o25DXh7/vh1wN0xxgjcASwIIQzOh0mXA091T+l9R3+aaVSRzbC7bk6hXb/e0EiSJEmSpP6o4ngDYozNIYT3kQRAWeDmGOOTIYRPAYtjjLcB3wC+G0JYDewmCZaIMe4JIfwrSfAUgdtjjL/ooc/Sa/WnPY0AwvizYHVyXL1zOcQIIZS3KEmSJEmS1K2OGxoBxBhvJ1laVtr38ZLjeuD1R7n2e8D3TqHGPq8/zTQCGHPaHA6sGsTQcIRBTXvgwBaom1jusiRJkiRJUjfq6Y2wBVSHktAo2/dDo9kTh7EiTi12bFlavmIkSZIkSVKPMDRKQZvlaRV9f3na3Al1PJmbVmi3bPYNapIkSZIk9TeGRiloszytH8w0Gj64io01swrtI+sfK2M1kiRJkiSpJxgapaC/zTQCaB67oHCc2ebyNEmSJEmS+htDoxT0t5lGAEMnz6chJvuoDz68GQ7vLnNFkiRJkiSpOxkapaAqlM406h+h0ZmTRvJMnFzs2LqsfMVIkiRJkqRuZ2iUgrYzjfrH8rQ57TbDZqtL1CRJkiRJ6k8MjVLQdk+j/jHTaNqowTwdTi+0GzYsKV8xkiRJkiSp2xkapaC6H840qshmODhybqHdsnlJ+YqRJEmSJEndztAoBf1xTyOA6klnkYsBgJp9a6DxcJkrkiRJkiRJ3cXQKAX98e1pADMnjWVNnABAhhxse7LMFUmSJEmSpO5iaJSCtnsa9Y/laQCzJ9TxZJxW7Nj6RNlqkSRJkiRJ3cvQKAX9dabRnPF1LC95g1pus29QkyRJkiSpvzA0SkGb0KgfzTQaNriSbYPPLLQbNz5exmokSZIkSVJ3MjRKQZuNsPvRTCMAxi8oHFbuWgEtTccYLEmSJEmS+gpDoxS0nWnUv0KjqZMnszGOBiCba4IdT5e5IkmSJEmS1B0MjVJQXboRdrb/LE8DmDOhjqdypxU7trqvkSRJkiRJ/YGhUQr680yjOROG8mTJZthsMTSSJEmSJKk/MDRKQVU/nml02qghPJM5vdBu2rSkfMVIkiRJkqRuY2iUgqrQf2caZTOBhjHFzbDD1mWQy5WxIkmSJEmS1B0MjVLQdqZR/wqNAMZNmsauOBSAiuaDsGdtmSuSJEmSJEmnytAoBRW0FBvZivIV0kPmTBzWdl8jN8OWJEmSJKnPMzRKQSCWNPrfVz57fB1PxWnFDjfDliRJkiSpz+t/CUYvlCkNjQhlq6OnzJ4wlOUlM41yW54oXzGSJEmSJKlbGBqloO1Mo/4XGtXVVLJr6JmFdm7zExDjMa6QJEmSJEm9naFRCkI/n2kEUDvhTA7GGgAqjuyEA1vLXJEkSZIkSToVhkYpaBMT9cOZRpBshr0iTi12uBm2JEmSJEl9mqFRKvr/TKM5E+ravkHNzbAlSZIkSerTDI1SkOnnb0+DfGhU+ga1rW6GLUmSJElSX9Y/E4xepr9vhA0wdeRgns3OKLRbNhsaSZIkSZLUlxkapWAgbISdyQSy42bTGLMAZPethyN7ylyVJEmSJEk6WYZGKRgIG2EDzJo4imfilGLH1mXlK0aSJEmSJJ0SQ6MUZEL/n2kEMGf8UDfDliRJkiSpnzA06nGxbbMfzzSaM6GO5aWbYW9xXyNJkiRJkvoqQ6MeFgZQaDR7Ql2bmUa5zY+XrxhJkiRJknRKDI16WDhGq7+pra7gwPA5NMfkH6uwazXU7y9zVZIkSZIk6WQYGvWwNjON+vEso1bTJ4wubIYdiLDVfY0kSZIkSeqLDI16WNvlaf0/NJozoY6luenFDpeoSZIkSZLUJxka9bA2MdEAmGk0Z0Idy+LpxY5Nj5WvGEmSJEmSdNIMjXpY2+Vp/f/rnjexjqW5YmgUnWkkSZIkSVKf1P9TjDIbaMvTJo8YxObq6TTGLABhz1o4sqfMVUmSJEmSpBNlaNTDBtpG2CEEZk0cxYp4WrFz85Ky1SNJkiRJkk6OoVEPG2gzjQDmTRzGMjfDliRJkiSpTzM06mEDbSNsyO9rVLoZ9mY3w5YkSZIkqa8xNOphA3emUWlotKRstUiSJEmSpJNjaNTDBtrb0wBmjBnC+uwU6mNl0rFvAxzcUd6iJEmSJEnSCRkYKUYZZQbYRtgAFdkMM8eP4KnSzbC3LClbPZIkSZIk6cQZGvW4gbc8DWDuxGE8kZtR7HAzbEmSJEmS+hRDox4Wjtro3+ZOrGv7BrVNboYtSZIkSVJfYmjUwwbiRtjQ2RvUnGkkSZIkSVJfYmjUw8IA3NMIYM74OtYxkUOxOuk4uBX2bylvUZIkSZIkqcsMjXpYZgC+PQ1gUFWWaWPqWB5Llqg520iSJEmSpD5j4KQYZRKO0erv5k2sY2nOJWqSJEmSJPVFhkY9bKAuT4MkNFpmaCRJkiRJUp9kaNTjBuZG2ADzJg5jaZvlaY9BjEe/QJIkSZIk9RqGRj2sTUw0AGcaPRfHsT8OTjoO74J9G8pblCRJkiRJ6hJDox4WBuhG2ADDB1cxcfgQluXcDFuSJEmSpL5mYKUYZZAZwMvTAOZOrGNpdF8jSZIkSZL6GkOjHjaQN8IGmDvBN6hJkiRJktQXGRr1sDDAZxrNm1jHsvYzjdwMW5IkSZKkXs/QqIe1mVw0AGcazZs0jI1xNLtjbdJRvw92rylvUZIkSZIk6bgMjXrcwJ5pNHFYDcMHV7HMJWqSJEmSJPUphkY9bKDvaRRCYN7EOp5wM2xJkiRJkvoUQ6MelhngoRHAvInD2s00WlK2WiRJkiRJUtcYGvWwgb4RNiSbYbd5g9qWJZBrKVs9kiRJkiTp+AyNelibmGjAzjSqYxsj2B6HJx2NB2HX6rLWJEmSJEmSjs3QqIc50wimj65lUGUFS3PTi53uayRJkiRJUq9maNTDBvpG2ADZTGD2hKEszc0odhoaSZIkSZLUqxka9bC2odHA/brnTqhjaXSmkSRJkiRJfcXATTFSEo7RGkjmTRzG8jabYS+FlubyFSRJkiRJko7J0KiHuTwtMW9iHTsZxqY4KuloPgI7Vpa3KEmSJEmSdFSGRj0pRioofbX8wA2Nzhw/lGwmsKx0tpFL1CRJkiRJ6rUMjXpSSwO3V/9tsT2AZxrVVGaZOabWN6hJkiRJktRHGBqlaQBvhA3JErWl0TeoSZIkSZLUFwzsFCN1A3emEcDciXUsK51ptG05NDeWryBJkiRJknRUhkZpGtiZEfMmDmMftTyXG5t0tDTC9ifLW5QkSZIkSeqUoVGqBnZqNHdiHQDLopthS5IkSZLU2xkapWkAb4QNMGxQJVNGDnIzbEmSJEmS+gBDo1QN7NAIYN6EYW6GLUmSJElSH2BolKYB/vY0SJaoLc9NK3ZsXwFNR8pWjyRJkiRJ6pwpRpoG+PI0gHkT6zjIYJ7NTUg6cs2wzc2wJUmSJEnqbQyNUmVoNG/iMACWlm6GvemxMlUjSZIkSZKOxtAoTc40YlxdNaOGVLEs5xvUJEmSJEnqzQyNUmVoFEJg7sQ6njA0kiRJkiSpVzM0SpMzjYBkidpT8TRaYv772Pk0NBwob1GSJEmSJKkNQ6M0+fY0INkM+wg1PBOnJB0xBxsXl7coSZIkSZLUhilGqpxpBEloBLA4d0axc8NDZapGkiRJkiR1xtAoTS5PA2DaqCEMqcq2DY3WP1i+giRJkiRJUgeGRqkyNALIZAJzJtTxaDyz2LlxMeRayleUJEmSJElqw9AoTc40Kpg7sY6NcTRb44iko/EAbHuyvEVJkiRJkqQCQyOVRbKvUXBfI0mSJEmSeilDozT59rSCeROHAfCo+xpJkiRJktQrmWKkyeVpBbPG1VKZDSzOlexr5EwjSZIkSZJ6DUOjVBkataquyDJr7FCeiqdxKFYnnfs2wL5N5S1MkiRJkiQBhkbpcqZRG/Mn1dFCliW5mcXODS5RkyRJkiSpNzA0SpWhUakFk5J9jRbH0n2NXKImSZIkSVJvYGiUJjfCbmPepE42w3amkSRJkiRJvYIpRppcntbGnPF1ZAI8nptFLua/m63LoeFgeQuTJEmSJEmGRukyNCo1qCrZDPsAg3k6Tkk6YwtsWlzewiRJkiRJkqFRqpxp1MG8SXUALC5dorbeJWqSJEmSJJWboVGqDI3amz8xvxm2oZEkSZIkSb2KoVGanGnUwfzWzbDjmcXOjYsh11KmiiRJkiRJEhgapcu3p3Uwd2IdIcDGOJqtcUTS2XgAtj1Z3sIkSZIkSRrgTDFUVrXVFUwfPQQIbZeobXiobDVJkiRJkiRDo3S5PK1TrfsaPeq+RpIkSZIk9RpdCo1CCC8PITwdQlgdQrihk/PVIYQf5M8/FEKY1u781BDCwRDCh7up7j7K0KgzCya1boZdsq+RM40kSZIkSSqr44ZGIYQs8CXgFcBc4E0hhLnthr0L2BNjnAl8Afjnduf/FfjlqZfbxznTqFPzJtUBsCJOpZ7qpHPfBti3qYxVSZIkSZI0sHVlptEFwOoY45oYYyNwK3BNuzHXAN/OH/8YeFEISUISQrgWWAu4s7EzjTo1L788rZkKHs/NKJ7Y4BI1SZIkSZLKpSuh0SRgQ0l7Y76v0zExxmZgHzAqhFALfBT45LEeEEL4kxDC4hDC4h07dnS19r7Ht6d1atigSqaOHAzAI232NXKJmiRJkiRJ5dLTKcaNwBdijAePNSjGeFOMcVGMcdGYMWN6uKQycnnaUbXua/Rom32NnGkkSZIkSVK5dCU02gRMKWlPzvd1OiaEUAEMA3YBFwKfDSGsAz4I/G0I4X2nVnJfZmh0NK37Gj2Wm0Wu9Xvauhwajpk3SpIkSZKkHtKV0OgRYFYIYXoIoQq4Drit3ZjbgLfnj18H3B0Tl8YYp8UYpwH/BvxTjPE/u6f0PsiZRkc1P7+v0QEGsz57WtIZW2DT4jJWJUmSJEnSwHXc0Ci/R9H7gDuAFcAPY4xPhhA+FUK4Oj/sGyR7GK0G/gq4oacK7tsMjY5mfn55GsAfmmYWT7ivkSRJkiRJZVHRlUExxtuB29v1fbzkuB54/XHuceNJ1Ne/uBH2UY0cUsWk4YPYtPcIDzefwR9V3ZWccF8jSZIkSZLKwhQjTS5PO6Z5E5N9jRbHkjeobXgEci1lqkiSJEmSpIHL0ChVhkbH0voGtY1xDPsrRiWdjQdg+1NlrEqSJEmSpIHJ0ChNzjQ6puK+RoHl2TnFE+tdoiZJkiRJUtoMjVJlaHQs8ybVFY7vPXJ68cQGN8OWJEmSJClthkZpMjM6prFDaxg7tBqAB5pmFU/4BjVJkiRJklJnaJQm3552XK37Gj0VT6M5Oyjp3Lce9m8uY1WSJEmSJA08phipcqrR8czLh0bNVLBxsPsaSZIkSZJULoZGaXIj7OOaP7G4r9Gj8YziCUMjSZIkSZJSZWiUKkOj41kweVjh+M4D04snNhgaSZIkSZKUJkOjNDnT6LjG19UwakgVAH9oOJ3YGrRtXQ4NB8tYmSRJkiRJA4uhUaoMjY4nhFDY12g/QzhQNzM5EVtg0+IyViZJkiRJ0sBiaJQm357WJaX7Gq2unl88sf6hMlQjSZIkSdLAZIqRJpendcmCScV9jR5qnlk84b5GkiRJkiSlxtAoVYZGXTG/JDT62Z7Tiic2PAK5ljJUJEmSJEnSwGNolCZnGnXJ5BGDGDaoEoCn6kfQMnhscqLxAGx/qoyVSZIkSZI0cBgapcrQqCtCCMyf1LqvUWDHiHOKJ9e7RE2SJEmSpDQYGqXJmUZdNn9icYnaU5Vziyc2uBm2JEmSJElpMDRKk29P67J5Jfsa3XukZDNs36AmSZIkSVIqTDHUK5W+Qe1XO0YTKwcnjX3rYf/mMlUlSZIkSdLAYWiUJpenddlpIwdTW10BwLbDORrHnVM8+dwfylOUJEmSJEkDiKFRqgyNuiqTCcydWFdob6hbWDy5+q4yVCRJkiRJ0sBiaJQmZxqdkNLNsB+uaBca5XJlqEiSJEmSpIHD0ChNboR9QhZMLs40unvfRBg8Omkc2gFblpSnKEmSJEmSBghTjFQ50+hElM40Wrr5AMx8cfHkqjvLUJEkSZIkSQOHoVGaXJ52Qk4fU8ugyiwA2w80sG/y5cWTqw2NJEmSJEnqSYZGqTI0OhHZdpthL61eWFzit3ExHNpVpsokSZIkSer/DI3S5EyjEza/JDRasjMDk8/PtyI8e3d5ipIkSZIkaQAwNEqVodGJmjepuK/Rsk37YOZLiidX/boMFUmSJEmSNDAYGqXJt6edsNLNsJ/cvB9mlYRGq++CXEsZqpIkSZIkqf8zxUiTy9NO2KxxtVRVJP+Ybtp7hN11s2HI2OTkkd2w+fEyVidJkiRJUv9laJQqQ6MTVZnNMGf80EJ7+eYDbWcbuURNkiRJkqQeYWiUJmcanZTSfY2Wb95naCRJkiRJUgoMjVJlaHQyFpSERk9u2g+nvwBCNunY/Dgc3F6myiRJkiRJ6r8MjdJkZnRSSjfDXrZpHwwaDlMuLA5Y/Zv0i5IkSZIkqZ8zNEqTb087KWeMr6UymyRu63cfZt/hpnZvUbuzTJVJkiRJktR/mWKkyqlGJ6O6IssZ44qbYT/Zfl+j1b+BluYyVCZJkiRJUv9laJQmN8I+aWdNLi5Re2DNLhg3H4ZOSDrq98KmxeUpTJIkSZKkfsrQKFWGRifrkpljCsf3PL0jCeDavEXNJWqSJEmSJHUnQ6M0OdPopF0yazTZTPL9Ldu0jx0HGmBmaWj06zJVJkmSJElS/2RolCY3wj5pwwZVsnDqiEL7vmd2wOlXQKYi6di6FA5sLU9xkiRJkiT1Q6YYqXKm0am4/MySJWrP7ICaOpj6vOKA1XeVoSpJkiRJkvonQ6M0uTztlFxREhrdv2oHLbnYbl8jl6hJkiRJktRdDI1SZWh0KuZOqGPs0GoA9h5uYsmGvTDrpcUBz94DLU1lqU2SJEmSpP7G0ChNzjQ6JSEELj+jONvo3qe3w5jZUDc56WjYBxseLlN1kiRJkiT1L4ZGqTI0OlVXnDm2cPzbp3ckQZxL1CRJkiRJ6naGRmny7Wmn7JJZo8lmkvBt2aZ97DjQ0HaJmpthS5IkSZLULUwx0uTytFM2bFAlC6eOKLTve2YHTL8MslVJx7blsG9TmaqTJEmSJKn/MDRSn3N5yVvU7nlmB1TXwmnPLw5YfWcZqpIkSZIkqX8xNEqTM426xRUlodH9q3bQkottl6itMjSSJEmSJOlUGRqlytCoO8ydUMfYodUA7D3cxJINe2FmyWbYa+6B5say1CZJkiRJUn9haJQmZxp1ixACl59RnG1079PbYfQsGH5a0tF4ENY/UKbqJEmSJEnqHwyN0uTb07rNFWeOLRzf88yOJJCbVTLbyH2NJEmSJEk6JaYYqXKmUXe5ZNZospnk+1y6cR87DjS4r5EkSZIkSd3I0ChNLk/rNsMGVXLe1OGF9n3P7IBpl0I22euIHSth7/ryFCdJkiRJUj9gaJQqQ6Pu1GGJWtVgmHZJcYCzjSRJkiRJOmmGRmlyplG3uuLM4mbY96/aQUsuukRNkiRJkqRuYmiUKkOj7jR3Qh1jhybL0fYebmLJhr1tN8Neey80N5SnOEmSJEmS+jhDozT59rRuFULg8jOKs43ufXo7jJoBI09POpoOw3O/L1N1kiRJkiT1baYYaXJ5WrfrsK8RuERNkiRJkqRuYGiUKkOj7nbJrNFkM8n3unTjPnYebICZJUvUDI0kSZIkSTophkZpcqZRtxs2qJLzpg4vtO97ZgdMuxgqBiUdu1bB7rXlKU6SJEmSpD7M0ChVhkY9oc0Stad3QOUgmH5ZccDqu8pQlSRJkiRJfZuhUZqcadQjrjizuBn2fat20JKLbd+ituxHZahKkiRJkqS+zdAoTYZGPWLuhDrGDq0GYO/hJpZs2AtzroZMRTJgw0OwdVn5CpQkSZIkqQ8yNEqVoVFPCCFw+RnF2Ub3Pr0dho5LgqNWj3yjDJVJkiRJktR3GRqlyZlGPabNvkbP7EgOzn93ccDSH0L9vpSrkiRJkiSp7zI0SpWhUU+5ZNZospnk+126cR87DzbAac+HMXOSAU2H4IkflLFCSZIkSZL6FkOjNDnTqMcMG1TJeVOHF9r3PbMj+b4vKJlt9MjXIcb0i5MkSZIkqQ8yNEpT8OvuSW2WqD2dX6J21huhqjY53vk0rPtdGSqTJEmSJKnvMcVIlTONelLpZtj3rdpBSy5C9VA4+7rioEe+XobKJEmSJEnqewyN0uTytB41b2IdY4dWA7D3cBNPbNybnFj0ruKglT+H/VvSL06SJEmSpD7G0ChVhkY9KYTQZrZRYYnauLlw2sXJca4ZHvt2GaqTJEmSJKlvMTRKkzONelzbfY22F0+cXzLb6NFvQUtTekVJkiRJktQHGRqlytCop10yazTZTPI9L924j50HG5ITs18FQ/KB0oEt8PTtZapQkiRJkqS+wdAoTb49rccNG1TJeVOHF9r3PZNfolZRBQvfXhzohtiSJEmSJB2TKUaaXJ6WirZL1HYUTyx8RzG4W3sf7Hg63cIkSZIkSepDDI1SZWiUhtLNsO9btYOWXEwawybDmVcWBy6+OeXKJEmSJEnqOwyN0mRmlIp5E+sYM7QagL2Hm3hi497iyfPfXTxe8t/QeCjd4iRJkiRJ6iMMjVJlapSGEAJXlMw2umdlyVvUpl8Oo2Ymxw37YdmPUq5OkiRJkqS+wdAoTW6EnZoXzC7ua/R/T2wm17pELZOBRe8qDnzk6xBjytVJkiRJktT7mWKkyY2wU/PC2WOpq6kA4Lldh3lw7a7iyXPeBBWDkuOty2DDw2WoUJIkSZKk3s3QKFWGRmmpqcxy7bmTCu0fPrKheHLQCFjwumL7ka+nWJkkSZIkSX2DoVGanGmUqjeeP6VwfPvyrew73FQ8Wboh9lM/hYM70itMkiRJkqQ+wNAoVYZGaZo3cRjzJ9UB0Nic4/+e2FQ8OfEcmLQoOW5phMe/m36BkiRJkiT1YoZGaXKmUereuKg42+gHpUvUoO1so8XfhFxLSlVJkiRJktT7GRqlybenpe7qcyZRXZF8709u3s/yTfuKJ+e9GgaNTI73rYdVd5ahQkmSJEmSeidTjFQ50yhtwwZVcuWCCYV2m9lGlTVw3luLbTfEliRJkiSpwNAoTS5PK4vSDbF/umQT9U0ly9AWvpNCmLf6Lti9Jt3iJEmSJEnqpQyNUmVoVA4XTh/JtFGDAThQ38wvl28pnhw5HWa9JN+Iyd5GkiRJkiTJ0ChVzjQqixACr+/qhtiPfxeajqRUmSRJkiRJvZehUaoMjcrldQsnk80k3/+Da3azbueh4smZL4bhU5PjI3vgyZ+UoUJJkiRJknoXQ6M0+fa0shlXV8MLzhxTaP9wcclso0wWFl1fbLshtiRJkiRJhkapcqJRWb2hZInajx/dSHNLrnjy3LdCtio53vQobHos5eokSZIkSepdDI1SZWpUTi+YPZYxQ6sB2H6ggXue3lE8OWQ0zHtNsb34GylXJ0mSJElS72JolCY3wi6rymyG1543udC+9VgbYi/7MRzenVJlkiRJkiT1PoZGqTI0Krc3nl9covbbp7ezfX998eTkRTDh7OS4uR4e/Va6xUmSJEmS1IsYGqXJmUZlN330EC6YPhKAllzkfx7bVDwZAlz43mL74a9BS1PKFUqSJEmS1DsYGqXJt6f1Cm8s2RD7h4s3EGMsnpz/WhiSf8vagc2w4raUq5MkSZIkqXcwxUiVM416gysXTGBodQUAa3ce4uG1JXsXVVTDoncV2w9+JeXqJEmSJEnqHQyN0uTytF5hUFWWq8+ZWGj/oP2G2Iuuh2xVcrzxYdj4aIrVSZIkSZLUOxgapcrQqLe47vyphePbl29hf33J3kVDxyXL1Fo99F8pViZJkiRJUu9gaJQmZxr1GvMn1TFnQh0A9U05bluyue2A0g2xn/wJ7G93XpIkSZKkfs7QKE1uhN1rhBB446LJhXaHJWoTz4Gpz0+Oc83wyDfSK06SJEmSpF7AFCNVzjTqTa49dxJVFclfgWWb9vHk5n1tB1xUMtto8c3QdCTF6iRJkiRJKi9DozS5PK1XGT64ipfPG19o/7D9bKMzXwnD8nsfHdkNy36UYnWSJEmSJJWXoVGqDI16mzeeP6Vw/NMlm6lvaimezFbABX9cbD/4FYgxxeokSZIkSSqfLoVGIYSXhxCeDiGsDiHc0Mn56hDCD/LnHwohTMv3vySE8GgIYVn+9wu7uf6+xZlGvc7zTh/FlJGDANh3pIk7ntzadsB5b4XKIcnx9idh7X0pVyhJkiRJUnkcNzQKIWSBLwGvAOYCbwohzG037F3AnhjjTOALwD/n+3cCr4oxLgDeDny3uwqXukMmE3jDwuJsow4bYg8aAee8qdh+6CspVSZJkiRJUnl1ZabRBcDqGOOaGGMjcCtwTbsx1wDfzh//GHhRCCHEGB+PMba+q/xJYFAIobo7Cu+TfHtar/S6RZPJ5CeB/eHZXazfdbjtgAtLNsR++pewe016xUmSJEmSVCZdSTEmAaXTLzbm+zodE2NsBvYBo9qNeS3wWIyxof0DQgh/EkJYHEJYvGPHjq7W3ve4PK1XmjBsEJefMabQ/uHidrONRs+CmS/JNyI8dFN6xUmSJEmSVCapTH0JIcwjWbL2ns7OxxhvijEuijEuGjNmTGdD+glDo96qdEPsHz+6kZZcuw2vL/rT4vHj34P6/SlVJkmSJElSeXQlNNoETClpT873dTomhFABDAN25duTgZ8Ab4sxPnuqBfdpzjTqtV44exyja6sA2Lq/nvueaTfjbcYLYfSZyXHjAVjy/ZQrlCRJkiQpXV0JjR4BZoUQpocQqoDrgNvajbmNZKNrgNcBd8cYYwhhOPAL4IYY4++7qeY+zNCot6qqyPCa8yYX2rc+sr7tgBDgwpKJcg99BXItKVUnSZIkSVL6jhsa5fcoeh9wB7AC+GGM8ckQwqdCCFfnh30DGBVCWA38FXBDvv99wEzg4yGEJfmfsd3+KfoKZxr1am9YVJxQd9eK7azc2m4J2tnXQc3w5HjPOnjmjtRqkyRJkiQpbV3a0yjGeHuM8YwY44wY4z/m+z4eY7wtf1wfY3x9jHFmjPGCGOOafP+nY4xDYoznlPxs77mP08v59rRebebYWi6dNRqAllzkxtueJMaSvY2qhsDCtxfbD/1XyhVKkiRJkpQeU4xUOdOot/v7q+aSzSR/Tg+u2c3Pl25pO+D8P4aQTY7X3gdbl6dcoSRJkiRJ6TA0SpPL03q9M8YN5e3Pm1Zo/9PtKzjc2FwcMHwKzHlVsf3QV9IrTpIkSZKkFBkapcrQqC/44EtmFd6ktmVfPV/67eq2Ay76s+Lx0h/CoZ0pVidJkiRJUjoMjdLkTKM+oa6mko++fHah/bX71rJu56HigCkXwMRzk+OWBnj0mylXKEmSJElSzzM0SpMbYfcZrz1vMudOHQ5AY0uOT/38qeLJENrONnr469DcmG6BkiRJkiT1MFOMVDnTqK/IZAKfvHpeYXLY3Su385sV24oD5l4LteOT44Nb4an/S71GSZIkSZJ6kqFRmlye1qecNXk4150/pdD+1M+for6pJWlUVMH57yoOfvDLEGPKFUqSJEmS1HMMjaRj+PBLz6SupgKA53Yd5hu/W1s8ufCdkK1Ojjc/BhsfKUOFkiRJkiT1DEOjNDnTqM8ZVVvNh156ZqH9n3evZvPeI0mjdgwseH1x8IP/lXJ1kiRJkiT1HEOjVBka9UVvvnAqs8cPBeBIUwv/ePuK4smL3ls8fur/YN/GlKuTJEmSJKlnGBqlyben9UkV2QyfvHpeof2LpVv4w7M7k8b4BTDt0uQ4tsAjXy9DhZIkSZIkdT9TjDS5PK3PuvD0UVx99sRC+5O3PUVTSy5pXPSnxYGLvwmNh1OuTpIkSZKk7mdolCpDo77sb6+cw+CqLABPbzvAdx94Ljlxxsth+GnJcf1eeOw75SlQkiRJkqRuZGiUJmca9Wnjh9Xw/hfOKrS/cNcz7DzYAJksXFiyt9FdN8K2p9IvUJIkSZKkbmRolCpDo77u+kumMX30EAAO1Dfz2V+tTE4sfAeMmZ0cNx+BH70dGg6Wp0hJkiRJkrqBoVGanGnU51VXZPn4q+YW2j9cvJHH1++BqsHw+m9D5eDkxM5n4OcfhBjLU6gkSZIkSafI0ChNvj2tX3jBmWN58ZxxhfaNtz1JLhdh7Gy46gvFgct+BI9+K/0CJUmSJEnqBqYYqXKmUX/x8avmUlWR/PV5YuM+fvTohuTE2dfBeW8rDvzlR2HLE2WoUJIkSZKkU2NolCaXp/UbU0cN5j2XnV5o//Ovnmbf4aak8YrPwrj5yXFLA/zoHVC/L/0iJUmSJEk6BYZGqTI06k/+7IqZTBxWA8DuQ4184a5nkhOVg5L9japqk/buNXDb+93fSJIkSZLUpxgapcmZRv3KoKosH7uquCn2dx5Yx4ot+5PG6Jlw9ReLg5/6P3j4ppQrlCRJkiTp5BkapcrQqL95xfzxPH/GKAByET5x25PE1hlF818L57+7OPiOv4NNj5ahSkmSJEmSTpyhUU9qvxzJmUb9TgiBG6+eRzaT/Nk+vHY3P1u6pTjgZf8EE85JjnNN8MN3wJE9qdcpSZIkSdKJMjTqUYZGA8EZ44byjudPK7T/+ZcrqW9qSRoV1fD6b0H1sKS9bz389M/c30iSJEmS1OsZGvUkg4EB4y9ePIuRQ6oA2LT3CDf/fm3x5MjpcO2Xiu2nb4cH/jPlCiVJkiRJOjGGRj3K0GigqKup5C9fPKvQ/vJvn2XHgYbigDmvgov+rNi+8xOw/qEUK5QkSZIk6cQYGvUkZxoNKG+6YCozx9YCcLChmS/c9UzbAS/+JExalBzHFvjxO+HQrpSrlCRJkiSpawyNepSh0UBSkc3wd1fOKbRvfXg9z2w7UDKgCl7/TagZnrT3b4Kf/AnkcukWKkmSJElSFxga9SRnGg04V5w5hktmjgYgF+Eff7Gi7YDhU+HVXy22V98Fv/9CihVKkiRJktQ1hkZSNwoh8HevnFN4Ud69z+zg3md2tB105svh4g8W23d/Gtb9LrUaJUmSJEnqCkMjqZvNmVDHGxdNKbT/8RdP0dzSbgnaC/8epj4vOY45+PH1cHB7ilVKkiRJknRshkZSD/irl57B4KosAM9sO8gPF29sOyBbAa+7GQaPStoHt8H/vBtyLSlXKkmSJElS5wyNpB4wdmgNf3r5jEL7X+98mgP1TW0H1U2E13wNyK9lW3sv3PvZ9IqUJEmSJOkYDI2kHvLuS09nwrAaAHYebOQr9z7bcdDMF8FlHym27/1nePpXKVUoSZIkSdLRGRpJPWRQVZa/fvmZhfbX7l/Lxj2HOw684gaYdmm+EeFH74D1D6ZSoyRJkiRJR2NoJPWga86exFmThwHQ2Jzjc3c83XFQJpvsbzR8atJuPgL//QbY9mSKlUqSJEmS1JahkdSDMpnA3105p9D+vyWbWbJhb8eBtWPhrT+FIWOSdv0++O5rYM+6NMqUJEmSJKkDQyOph114+ihePm98of3pnz9FjLHjwFEz4C3/A9V1SfvgVvjOtXBwezqFSpIkSZJUwtBISsENr5hNZTZ5S9ri5/bwy+VbOx844Wx40y2QrU7ae9bC916TzDySJEmSJClFhkZSCqaNHsLbnjet0P7ML1fS0NxylMGXJHschfxfz63L4JY/gqb6ni9UkiRJkqQ8QyMpJR944SyGD64EYP3uw3znD88dffCcq+BVXyy2n/sd/Ph6aGnu4SolSZIkSUoYGkkpGTa4kr940axC+4t3r2L3ocajX3DeW+HFnyy2n/4F/PwvoLP9kCRJkiRJ6maGRlKK3nzhaUwfPQSAA/XNfPE3q459wSUfhOe/v9h+/Htw1yd6rkBJkiRJkvIMjaQUVVVk+JtXzC60v/vgc6zefvDYF73kH+CcNxfbv/93+P0Xjz5ekiRJkqRuYGgkpewlc8dx0ekjAWjJRT7zyxXHviCEZH+jM68s9t359/D493uwSkmSJEnSQGdoJKUshMDHXjmXEJL2XSu284fVO499UbYieaPaaRcX+257P6y8vecKlSRJkiQNaIZGUhnMnzSM15w7udD+9C9W0JI7zgbXlYPgTbfA+AVJO7bAj94B637fc4VKkiRJkgYsQyOpTD7ysjOpqUz+Cj61ZT//89jG419UMwze8r8wYnrSbmmAW66DLUt7sFJJkiRJ0kBkaCSVyfhhNbznshmF9r/c8TSHGpqPf2HtWHjrT6B2XNJu2A/fey3sXtNDlUqSJEmSBiJDI6mM3nP56YwdWg3A9gMN3HRfF4OfkdOTGUfVw5L2oe3wnWvhwNaeKVSSJEmSNOAYGkllNLiqgg+/7MxC+6v3PctTm/d37eLx8+GPfgAVNUl773PJjKMje7u/UEmSJEnSgGNoJJXZa8+bzNwJdQDUN+W46j/u5+9+soxdBxuOf/Fpz4M3fAdCNmlvW57scdR4uAcrliRJkiQNBIZGUpllM4F/uHYeVRXJX8dchO8/tJ4rPncPX733WRqaW459gzNeBtd+udhe/wB865Vuji1JkiRJOiWGRlIvsPC0kfzsfZdw6azRhb4DDc38v1+u5CX/eh+/Wr6FGOPRb3D2dfCyfyq2Nz8GN10Ov/pbaDjQg5VLkiRJkvorQyOplzhz/FC+c/0F3PyORZw+Zkihf/3uw7z3e49x3U0PsnzTvqPf4Hl/Di/9NGSrknbMwYNfgi9dCCt+BscKnSRJkiRJasfQSOpFQgi8cPY47vjgZXziVXMZNqiycO6htbt51X/+jg//6Am27a/v/AbPfz/86R9g+mXFvv2b4AdvgVveBHvX9/AnkCRJkiT1F4ZGUi9Umc3wzounc+9HruCdF0+jIhOAZLLQjx/dyAv+5R7+4zerqG/qZL+j0bPgbbfBa74GQ8YU+5/5ZTLr6Pf/Di1NKX0SSZIkSVJfZWgk9WLDB1fxiVfN446/vIwXzR5b6D/c2MLn73yGF/7LPfzfkk0d9zsKAc56A7zvEVj4zmJ/02G48+Pw1cth/UMpfQpJkiRJUl9kaCT1ATPG1PKNd5zP9951IbPHDy30b95Xz1/cuoRXf/kPPLZ+T8cLB42AV/0bvOtOGDuv2L/9Sbj5pXDbB+Dw7p7/AJIkSZKkPsfQSOpDLpk1ml984FL+6dULGDWkqtC/ZMNeXvPlP/CBWx5n094jHS+ccgG8595ko+zKwcX+x74N/3k+PHGrG2VLkiRJktowNJL6mGwm8EcXTuW3H7mC91x+OlXZ4l/j257YzAvz+x01teTaXViZbJT95w/DmVcW+w/vhJ+8B779Kti5KqVPIUmSJEnq7QyNpD6qrqaSv3nFHO76q8u5csH4Qn9Dc47P3/kM137p9zy1eX/HC4dPgTfdAtf9N9RNLvavux/+6/lw9z9C01HeziZJkiRJGjAMjaQ+buqowXz5zQv54Xuex4JJwwr9T27ez9X/+Tv+7a5naGzOdbxw9ivhzx9KZh+FbNLX0gj3fRb+63nw7N0pfQJJkiRJUm9kaCT1ExdMH8lP//xi/vbK2VRXJH+1m3ORf7trFVf/5+9Yvmlfx4uqa5N9jt5zL0w+v9i/ew1899Xw43fBga0pfQJJkiRJUm9iaCT1I9lM4E8um8Htf3EpC08bUehfufUA13zp93z+10/T0NzS8cLxC+D6X8NVX4Ca4mwllv8Yvngu/PafoOFgCp9AkiRJktRbGBpJ/dCMMbX88D3P4++vmktNZfLXvCUX+Y+7V3P1f/yepRv3drwok4FF18P7FsOCNxT7mw7Dvf+chEePfANamtP5EJIkSZKksjI0kvqpbCbwrkum88u/uIzzpxVnHT297QCv/vIf+NwdKzufdVQ7Fl77NXjbbTBuQbH/0Hb4xV8l+x2tvB1iTOFTSJIkSZLKxdBI6uemjx7CD/7keXziVXMZVJlseN2Si3zpt89y1Rd/x5INezu/8PTLk72Orv0vqJtU7N/5DNz6JvjWK2HToz3/ASRJkiRJZWFoJA0AmUzgnRdP51cfvJQLp48s9K/afpDXfPn3/L9frqC+qZNZR5ksnPNH8P5H4UUfh6qhxXPP/R6+9kL40Tth99oUPoUkSZIkKU2GRtIActqoIdzyxxfxD9fMY3BVMusoF+Gr967hlV+8n8fW7+n8wspBcOmH4C+WwAXvgUxF8dyT/wv/eT786m/h8O6e/xCSJEmSpFQYGkkDTCYTeOvzpnHHBy/jeaePKvQ/u+MQr/uvP/BPtx9l1hHAkNFw5Wfhzx+GudcU+3NN8OCX4IvnwO//HZrqe/ZDSJIkSZJ6nKGRNEBNGTmY77/7Qj597XyGlMw6uum+NVz57/ezeN0xZg2NmgFv+A68606YcmGxv34f3PnxZObR0h9CLtfDn0KSJEmS1FMMjaQBLJMJvOWi07jjLy/jkpmjC/1rdh7i9V99gE/97CkONjQf/QZTLoDr74A3fBdGzij271sP//vH8LUrYM29PfcBJEmSJEk9xtBIEpNHDOa777qAz7xmAbXVyX5FMcLNv1/Lhf94Fzf8z1IeW7+HGGPHi0OAuVfDnz8EV/4LDC4ueWPLE/Cdq+H7r4ftK1L6NJIkSZKk7hA6/X8Cy2jRokVx8eLF5S6jW9Qf2E3N56cXO27cV75ipC7atPcIf/O/y7jvmR0dzp0xrpY3nj+VV587iZFDqjq/Qf1++P2/wQNfguaSvY1CBs55M7zg76BuQs8UL0mSJEnqVAjh0RjjohO6xtCo5xgaqa+KMfI/j23iK/c+y+rtBzucr8pmeMm8cVx3/hQunjGaTCZ0vMm+TfDbf4Il3wdK/nemYhCc8TKY8yqY9VKoqeu5DyJJkiRJAgyNeh1DI/V1MUYeW7+HHzyygZ89sYUjnbxVbfKIQbx+4RRev2gyE4cP6niTrcuTzbGf/U3Hc9kqmH45zLkKznwl1I7pgU8hSZIkSTI06mUMjdSfHKhv4udLt/CDRzawZMPeDudDgMvPGMN150/hhbPHUVXRbsu0Z++Gu25M9jnqVICpFyUzkGZfBSNO6+6PIEmSJEkDlqFRL2NopP5q5db9/OCRDfzk8U3sPdzU4fyoIVW8duFk3rBoCjPH1hZPxJhsiL3y57DiZ7B16dEfMn4BzH5VMgtp7NwklZIkSZIknRRDo17G0Ej9XX1TC3c+tY0fPLKB363e2emY86eN4A2LpvDKsyYwuKqi7ck962DlL2DFz2H9A7TZ+6jUiOnJDKQ5r4JJiyDjix8lSZIk6UQYGvUyhkYaSDbsPsyPFm/gh4s3snV/fYfztdUVXH3ORN64aApnTR5GaD9z6OAOePr2ZBbSmnugpbHzB9WOh9lXJkvYpl0KFUd5i5skSZIkqcDQqJcxNNJA1JKL3PfMDn7wyAbuWrGN5lzH/42ZOKyGF80Zx4vmjOV5M0ZRXZFtO6B+P6z6dRIgrboTGju+wQ2A6mHFN7HNfBFUDemBTyRJkiRJfZ+hUS9jaKSBbseBBv73sY38YPEG1uw41OmYwVVZLp01mhfNGccLZ49ldG112wFN9bD23mQPpKdvh8O7On9YRQ2cfgVMfR5MuRAmngOVnbzNTZIkSZIGIEOjXsbQSErEGFn83B5ufXgDdz61lf31zZ2OCwHOmTKcF88Zx4vnjOOMcbVtl7HlWmD9g0mAtPLnsG/D0R+aqYQJZyUB0pQLYPIFMGxSN38ySZIkSeobDI16GUMjqaOmlhyL1+3hNyu2cdeKbazbdfioYyePGMSL88vYLpw+iqqKkg2wY4QtT+TfxPZz2LHi+A+vm5wESK1B0vgFkK3shk8lSZIkSb2boVEvY2gkHVuMkWd3HOI3K7bxmxXbWfzcbjrZAglINtK+7IzRvGj2OF4weywjh7TbAHvXs/Dc72HDQ7DhYdj5zPELqBgEkxbClPOTIGnyBTBk1Kl/MEmSJEnqZQyNehlDI+nE7DnUyD3PbOeuFdu57+kdHGjofBlbJsB5U0fw4rnjePGcscwYU9vxbWyHd8PGR5IAacNDsOlRaDr6rKaCUTOT8Kh1RtKY2ZDJHP86SZIkSerFDI16GUMj6eQ1Nud4ZN1u7nxqG79ZuY0Nu48cdexpowbzotnjuOLMMcydWNdxM22AlmbYtjwJkTbmg6S9649fSPUwmLwoHyJdAJMWQU3dKXwySZIkSUqfoVEvY2gkdY8YI6u2H+Su/DK2x9bv4Vj/0zW6tpo5E4Yye/xQZo+v48zxQ5k5tpaaymzbgfu35AOk/M+WJdDSePyC6ibDmDNg9JkwJv8z+kyXtkmSJEnqtQyNehlDI6ln7DrYwG+f3sFdT23j/lU7ONTYctxrspnA6aOHMHtCXT5MGsrsCXVMHFZTXNrWVJ9srr3hoSRMWv8QHNre9cIGj2oXJJ2R/K6blLwaTpIkSZLKxNColzE0knpeQ3MLD67Zzd0rtrFk4z6e2XqAI03HD5FaDa2pKMxImp2fnXTGuKEMralM3tC297niTKQND8L2FZDrfK+lo6qqLQZIhd9nwohpkK04sXtJkiRJ0kkwNOplDI2k9LXkIut3H+bprftZseUAK7fuZ+XWAzy3qwubYJeYMnJQEiSVBErTRg0hG5th91rY+TTsWAk7nkmOd67q2kbbpbJVycbbbQKl2UlfZc2J3UuSJEmSjuFkQiP/E7ekfiWbCUwfPYTpo4fw8vkTCv2HGpp5ZtsBVm49wMotSZC0cusB9h1p6vQ+G3YfYcPuI9z51LZCX3VFhjPGDWXWuFpmjZ3LGeMu4Iz5Q5k0fBAZIuzbADufgR1P50Ol/E/93s6LbWmE7U8lP6VCBoaflgRJI0+HoeNh6ISSn/FQXXuqX5UkSZIkHZOhkaQBYUh1BedOHcG5U0cU+mKMbN1fz8ot+TBp635WbjnAszsO0pzrOAuzoTnHsk37WLap7azBQZVZZo6tzYdJp3PGuLM4Y3Y+TArAoR35AGllSaj0DBzY0nmxMQd71iY/R1M1FOomdB4oDZ2QnKsdDxVVJ/N1SZIkSZKhkaSBK4TAhGGDmDBsEC+YPbbQ39Dcwpodhwoh0or87KTtBxo6vc+RppZjh0lja5k1biJnjDuDWTOGMnnEIDKZAPX7isvbWoOkHSthz3PAcZYONx6AnQeSa45l8CgYOjEfJpUESoWAaSIMGQ2Z7LHvI0mSJGnAMTSSpHaqK7LMmVDHnAl1cG6xf/ehRp7ZdoBV2w7wzLaDrNp+gFXbDrLrUGOn9zlamFRTmWHm2FrOGDuUWeNGMmvsSzhj4WuKYVLTEdi1OgmS9m+C/VuSWUkHtuZ/b0mWtnXF4V3Jz7ZlRx8TslA7LgmR6koCpsGjk9Cp9WfIaBg0woBJkiRJGiAMjSSpi0YOqeKi00dx0emj2vTvOtjAqu0HWbXtAKu2H8wHS0cPk+qbcizftJ/lm/a36W8bJg1l1thLmTJjMMMHVzJsUCU1lfmwJkY4sicJjzoLlFrbB7clS92OJ7bAgc3Jz+bHjjM4wKDhbcOkwSPbtUflA6d8f80wCOH4dUiSJEnqVQyNJOkUjaqtZlRt9dHDpHyg9My2A6zefpCdB08sTGpVU5lh+KCqQog0fHAlIwaPZdjgSUn/2EqGn1bJsMGVSbsmMCLupaZ+B+HA1nwwtLUYKrUGTkd2n8CnzQdWR/Yks6G6IlMBg0YePWQaMrpjX+VggyZJkiSpzAyNJKmHHC1M2n2oMQmRWmcn5Ze6HS1MalXflGNrUz1b99efUB1V2QzDBlcxfNAshg+ey/DBVQwflARMwwdXMaIqx7jMXkbndjMit4uhTTsZ3LCDqoY9hCO7i0vcDu9KwqITlWuGQ9uTn66qqEnCo0EjoKoWqobkfzo7Htyuv5Nx2coTr1uSJEka4AyNJCllI4dUceHpo7jwGGHS6vxSt+0HGth7uIm9hxs7faNbVzS25NhxoIEdR9nIu63h+Z+ZANRWVzCkOkttdQW1tZXUjYSxlUcYmz3E6MwBRoWDDOcAw+J+hub2Mrh5H4Oa9lLdtJfKhj1k63eTaTx44kU31+f3c9p04td2JluVzF46Zrh0rP58u3CPwcmx+ztJkiSpHzM0kqRe4mhhEkCMkcONLew9kgRI+w43sfdIE3sON7L3cBP78v178/3J+Ub2HG6isbkL+xodxcGGZg42NLON9oFTBTAi/3NsVTQxKnOQiVWHmVh5mPEVhxiTPcio7EFGcYDh7Kcut5/a3L586LSHbK6LG313VUtj8lO/t3vvm62CykFJgNTmd1f7unCuosalepIkSSoLQyNJ6gNCCAyprmBIdQWThg86oWvrm1ryYVI+VDrcxL4jxYCpTbskgDrU2NIttTdSyZbcCLbUj+DRLq2siwyigZEcYHg4xGDqGRLqGUw9g0ND0qaB2kw9dZlGhmYaGJppYEhI+geFegbHempiPTXxCNW5I2Tpns/SQSGM2nf8safiZEKpihqoqE6CrcJP5XGOj3He4EqSJGnAMTSSpH6upjLL+GFZxg+rOaHrWnKRQ43NHGpo5mB9Mwca2h4frM+3Gzqea+1vbZ/YbKfAEWrYRA2b4pikq7OVeV3OgSJVNOfDpiR4GkI9g/K/S0OpITQwOLSOy7epZ0imgdr8+CHUU0MD1TSQ6bSwHtB0OPlhVzrP68zJhk1tjqu7OLYCMpXJJuqZinz7GD/HPW/oJUmSdDIMjSRJncpmAnU1ldTVVMKwU7tXY3OuGCSVBEoH24VLh9r3NzRT39SS/8lR39TCkXy761s8BRqppJFK9jK0GECdct4TqaaJahoZRCODQkPymwZqQvK7tb+G0nYjNSXnBpFv56+p6XCvplMttHu0zqrqq0ImHyK1hlHZYqDUelw4n20bOHX5fGf3zrdDBkI2f5wt9rVpH6s/c5R7tJ47gXsf9ZzBmiRJasvQSJLU46oqMlRVVDFiSFW33C/GSGNLrhAkFcOkHEcaWzr2NbWUhE9t+xvaX9vcQn1j2zGdCzRQRQNV7Ie2IVQ3TkAK5PKhU+eBVPvQaRCN1OT7K2mmimYqaaYyNBfaHftakna+r3A+/1MVemh5X5piru8HXz0sRyBHhhwZYsgmxyHTsY8MMQRyZAvnY8iQI0sMGSKBmA+nYv4cIf+bUDwOmXxQlSFmskAmCcAIhZAs5MeGQmBW7CdkCCXtkElqbD0OmeSYTPF88jtbOBcyGTKtY/PnM5ksIVt6Plv43To2U+gvCeJCKB4TSj5fKJ7rcEzb/g7XdXYPOt7vmNe1HndyXVfuYZgoSQNal0KjEMLLgX8HssDXY4yfaXe+GvgOsJBk7vwbY4zr8uf+BngXyUKCD8QY7+i26iVJA1IIgeqKLNUVWYYNquzRZ8UYaWjOFWY7HWlqoaklR1NLjpZcpKkl0tx6nIu05HL5vkhzLlf8nUv6Wq9rzsUO92jOJWM79B3lHvtykV2Fe7Qb21Ks+2TfvFfyLXQMkgqhU0vbc+1Cp6qjBlGtxy0dwq0qmsgSqaCZCnJkaaGCHBWhXZtmsuSooIVsyFFZ2qbYruwPoVcKkoinBWiBmJ/hltIKTPVuuSTdIkISChYW5wZyofVc8rswNoT82JJr8yFVcp8kYCRQGNN6HZT0hdZ7UAi0YknQFUv6i9eXBG0lzy1c02YMbc7R/vr2/YUALtOmJkIgdHZNyBA6uUf7vhDaXpsEowCZNudCu/Gh9H5taqJtvbT/Htufz7fz5489NhTGxtLrOzlf/D4p+d5Ln8UJjA2dXhc71NZubMk/Vx3r7PjZ4lG/n+OMzd8v+WPLH4dAyNcYCn9eJL8LpeT7Qib/sVrHZDp+rNa+0j/7wtfRep/WOor/bISSdulXFEj+mQmFepMaWusKHb7zNgdH+d5PcMxR/hns+pj2z+nKfTqrr4v9J3NNZ/8cHfVcGs8/MccNjUIIWeBLwEuAjcAjIYTbYoxPlQx7F7AnxjgzhHAd8M/AG0MIc4HrgHnAROCuEMIZMUb/7U2S1CeEEKipzFJTmS13KSetuSVHfXOuw1K/huaWktla+d8lfQ1NLZ1e19rXkO872Nz+vif/xr6ekfy/p6WhUhIsJeFTNrRQWdqmXbvN+dZAKt8OLZ3es9DOX5ufj0PrXJ1s/qf1OBPa97UdW/wdOxnbfky+L3TSR46Qv3fbsaZDOrpMPuYpKvlX+aP9o+M/UpLUL3RlptEFwOoY4xqAEMKtwDVAaWh0DXBj/vjHwH+GJJa8Brg1xtgArA0hrM7f74HuKV+SJB1PRTZDbTZDbXU6q9Lbz85qH0a19je0C5vqm3LUN7fQ3JIjk/+voZkQyOR/J//1MyTHIfkPue3bmZL/qpoJkMm0vS7T+h9a27XbXhcK9w7taiitKRBKajjG78J/DY/57yf/PZV8X23bxVbHscnvlhhp6aS/9Rkc5bqj1pDLJUv4Ygsh5gi5lny7mRBzkGtJflrHECGXP5e/hlwLMbYQczlyuVxy3JIj5lrIxeR34VyuhRhz+ee2QC5HrnCPHDEXifn+mH9Ga43FWpNzMeYglyPEluSDxVybnxhz+TqTn8IxOULJ+EByLjkfC+3WcclxJJPvT+bJ5IO81v58IJf8M9c6z6Y4N6d03k3Hc0k/7cZmSELYTu8TTuT+rXNHOt6/tb/92IxhoiQNeF35t8dJwIaS9kbgwqONiTE2hxD2AaPy/Q+2u3ZS+weEEP4E+BOAqVOndrX23q+qttwVSJKUuv4wO0s6nhgjLblIS4zkcvkgLxfJ5QrRHTEmxzHmA7uSsK61L7bpK7ZpN6a1u6XknqXhYpvntB63e8bR7hmPdc9czAd3SWgWc5FIjpBLAq5ITMI9ckn+RhKwxfx4WsfHmASkuVzyhNiStPP9yU+u5Df5kDAmgSLk64jkWu8VY6Ev5vtpvZbkWgr9LRBbQ9pc4Zmt10Lx+bQ/1+75hfu3jqH1yy5el9wv/13QGk4mzw/5c5Fc65ec/4MofU7+z6LkXhCL32PJM6HYzi/YKwSByXH7/uRcp2NjYWFa4Ty07Tta/7HHUvK8oz2389o7/zyl9+w49ug1tj7v+DWW9h9/bOvTks9SbCXnY+v4/N+rDveOsV1/6fmSzxeTzxdLntlmTGx7XSicKR3fep/i99W+pvZ1dPxzbv9n07Hdlfu0vd/Rz3V85gnU1S787vxzHq3uo4/pWOOJ3evknnlq13f2nXZFr9gIO8Z4E3ATwKJFi07uk/RC2YoKbjntk7x+/ae5Zfr/463lLkiSJEndIoRARTb0jn+ZlqQe0BpkR1oD185Db9r1xdLrKWabbULtkvOl1xOLz0ie17aGoz2zWNvxg/XC+HbJQ2wXqrQ/3/l3dOx7dD6m/flOrjnOPTqO6MpzgE+N6nDd8XTl/85tAqaUtCfn+zobszGEUEHycuZdXby236rMZnjTOz8IfNDASJIkSZLUZ7Qu0863ylmKyijThTGPALNCCNNDCFUkG1vf1m7MbcDb88evA+6OSVx2G3BdCKE6hDAdmAU83D2lS5IkSZIkqaccd6ZRfo+i9wF3AFng5hjjkyGETwGLY4y3Ad8Avpvf6Ho3SbBEftwPSTbNbgb+3DenSZIkSZIk9X6hs/Vz5bRo0aK4ePHicpchSZIkSZLUb4QQHo0xLjqRa7qyPE2SJEmSJEkDjKGRJEmSJEmSOjA0kiRJkiRJUgeGRpIkSZIkSerA0EiSJEmSJEkdGBpJkiRJkiSpA0MjSZIkSZIkdWBoJEmSJEmSpA4MjSRJkiRJktSBoZEkSZIkSZI6MDSSJEmSJElSB4ZGkiRJkiRJ6sDQSJIkSZIkSR0YGkmSJEmSJKkDQyNJkiRJkiR1YGgkSZIkSZKkDgyNJEmSJEmS1IGhkSRJkiRJkjowNJIkSZIkSVIHIcZY7hraCCHsAJ4rdx3dbDSws9xFSP2If6ek7uXfKan7+PdJ6l7+nZK6z5kxxqEnckFFT1VysmKMY8pdQ3cLISyOMS4qdx1Sf+HfKal7+XdK6j7+fZK6l3+npO4TQlh8ote4PE2SJEmSJEkdGBpJkiRJkiSpA0OjdNxU7gKkfsa/U1L38u+U1H38+yR1L/9OSd3nhP8+9bqNsCVJkiRJklR+zjSSJEmSJElSB4ZGkiRJkiRJ6sDQqIeFEF4eQng6hLA6hHBDueuR+rIQwpQQwm9DCE+FEJ4MIfxFuWuS+roQQjaE8HgI4eflrkXq60IIw0MIPw4hrAwhrAghPK/cNUl9VQjhL/P/vrc8hHBLCKGm3DVJfUkI4eYQwvYQwvKSvpEhhDtDCKvyv0cc7z6GRj0ohJAFvgS8ApgLvCmEMLe8VUl9WjPwoRjjXOAi4M/9OyWdsr8AVpS7CKmf+HfgVzHG2cDZ+HdLOikhhEnAB4BFMcb5QBa4rrxVSX3Ot4CXt+u7AfhNjHEW8Jt8+5gMjXrWBcDqGOOaGGMjcCtwTZlrkvqsGOOWGONj+eMDJP8yPqm8VUl9VwhhMvBK4OvlrkXq60IIw4DLgG8AxBgbY4x7y1qU1LdVAINCCBXAYGBzmeuR+pQY433A7nbd1wDfzh9/G7j2ePcxNOpZk4ANJe2N+P/gSt0ihDANOBd4qMylSH3ZvwF/DeTKXIfUH0wHdgDfzC/5/HoIYUi5i5L6ohjjJuBfgPXAFmBfjPHX5a1K6hfGxRi35I+3AuOOd4GhkaQ+J4RQC/wP8MEY4/5y1yP1RSGEq4DtMcZHy12L1E9UAOcB/xVjPBc4RBem/UvqKL/PyjUkYexEYEgI4S3lrUrqX2KMEYjHG2do1LM2AVNK2pPzfZJOUgihkiQw+n6M8X/LXY/Uh10MXB1CWEeyfPqFIYTvlbckqU/bCGyMMbbOgP0xSYgk6cS9GFgbY9wRY2wC/hd4fplrkvqDbSGECQD539uPd4GhUc96BJgVQpgeQqgi2bzttjLXJPVZIYRAslfEihjjv5a7HqkvizH+TYxxcoxxGsn/fbo7xuh/xZVOUoxxK7AhhHBmvutFwFNlLEnqy9YDF4UQBuf//e9FuLG81B1uA96eP3478H/Hu6CiR8sZ4GKMzSGE9wF3kOz4f3OM8ckylyX1ZRcDbwWWhRCW5Pv+NsZ4e/lKkiSp4P3A9/P/sXAN8M4y1yP1STHGh0IIPwYeI3l77uPATeWtSupbQgi3AFcAo0MIG4FPAJ8BfhhCeBfwHPCG494nWcYmSZIkSZIkFbk8TZIkSZIkSR0YGkmSJEmSJKkDQyNJkiRJkiR1YGgkSZIkSZKkDgyNJEmSJEmS1IGhkSRJSkUI4WAnfe8NIbztFO55ewhheCf9N4YQPnyM65aEEG492ece5Z7DQwh/dhLX/TiEcHr+eF0IYXR31lXynHeEEP7zGOcXhBC+1RPPliRJfZOhkSRJKpsY41dijN85heuvjDHuPZFrQghzgCxwaQhhyMk+uxPDgRMKjUII84BsjHFNN9ZxUmKMy4DJIYSp5a5FkiT1DoZGkiSpbEpnBIUQFoYQnsj/fC6EsDzf32aGTAjh5yGEK/LHhZk5IYS/CyE8E0L4HXDmMR77JuC7wK+Ba0ru+4EQwlMhhKWts5BCCJfnZyUtCSE8HkIYmu//SAjhkfzYT+Zv8RlgRn7s50IIE0II9+Xby0MIl3ZSy5uB/zvOdzQmhPA/+ec9EkK4OISQyX/24SXjVoUQxnU2vpN7vj5f0xMhhPtKTv0MuO5Y9UiSpIHD0EiSJPUW3wTeH2M8+0QvDCEsJAk7zgGuBM4/xvA3ArcCt5AESK1uAM6NMZ4FvDff92Hgz2OM5wCXAkdCCC8FZgEX5J+3MIRwWf76Z2OM58QYPwL8EXBH/tqzgSWd1HIx8OhxPt6/A1+IMZ4PvBb4eowxRxI2vTr/+S8EnosxbutsfCf3/Djwsvx3fXVJ/+L855QkSaKi3AVIkiTlZ8wMjzG2znr5LvCKE7jFpcBPYoyH8/e77SjPWQTsjDGuDyFsAm4OIYyMMe4GlgLfDyH8FPhp/pLfA/8aQvg+8L8xxo350OilwOP5MbUkIdL6do97JH//SuCnMcYlnZQ0AdhxnM/2YmBuCKG1XRdCqAV+QBL+fJMkMPvBccaX+j3wrfD/27t/0DqrMI7j318QbETNUHQwpAaaSigWQifBKO1chE5C0UGlg4vdig6iQwcVIYPQSdxc2kEXpbRUioFQpFiw/ulU2qEVFAqBBoJY+zi8J+T13tgIojeQ72e695xz3/O873R57nOem5wGPuuN/wo8sUk8kiRpm7DSSJIkbXV3+et3lh3/4lpHgNkkN4BrwKN01TgAh4CTwH7gUpIHqup94CgwDiwlmQUCvNcqiuaqaqaqPhncqCXAngdu0SVoNmr4vfoP7mcMeKa332RVrQAXgZkkjwGHWU/+/N36fmyvA28DU8C3SXa2qR0tJkmSJJNGkiRp9Foz6+Uk823opd70DWCu9fGZojsWNmgROJxkvPUdemFwQZIx4EVgX1VNV9U0XU+jI21uqqouAG8CE8DDSXZX1fdV9QFd5dAscBZ4ba16J8lkkseBO8Ajvf2eBH6pqo/pjojt3yDuq8DMJo/nHPBG77pzAFVVwOfAAnC1qm7fb/3As9hdVd9U1Tt0lU5Tbeop4IdN4pEkSduEx9MkSdL/5aEkN3vvFwbmX6U7zlV0iY81S8B14Ce6JMvlwQtX1eUkp4Dv6I5YXdpg/+eAW1X1c29sEdgLTAKfJpmgqyT6qKqWk5xIchC4B/wInKmq39o/sF1sR8BWgJer6lqSpdbA+wxd8uV4kt/bmo0qjb4EDgDne2NXktxrr08Dx4CTSa7QfXdbZL3n0ql2r6/0Pn+/9Ws+TLKn3etX7bkBHGwxSZIkke5HKkmSpK0jyTTwRVU9PepY/ktJxoELwLNV9ceIY3kQ+BqYr6q7o4xFkiRtDR5PkyRJGpGqWgXepat0GrVdwFsmjCRJ0horjSRJkiRJkjTESiNJkiRJkiQNMWkkSZIkSZKkISaNJEmSJEmSNMSkkSRJkiRJkoaYNJIkSZIkSdKQPwESAgd4/IKo/QAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "asset_Lvl = example1.state_now['aLvl']  #market resources from Monte Carlo Simulations\n",
+    "pmf = jump_to_grid_fast(aLvl_vals, vecDstn, example1.aPol_Grid) # probabilities/distribution from transition matrix methods\n",
+    "h = np.histogram(asset_Lvl,bins=example1.aPol_Grid)[0]/np.sum(np.histogram(asset_Lvl,bins=example1.aPol_Grid)[0]) #Form Monte Carlo wealth data and put into histogram/bins\n",
+    "\n",
+    "plt.plot(example1.aPol_Grid[:num_pts-10-1],h[:num_pts-10-1] , label = 'Monte Carlo', linewidth = 3.0) #distribution using Monte Carlo\n",
+    "plt.plot(example1.aPol_Grid[:num_pts-10],pmf[:num_pts-10], label = 'transition Matrix', linewidth = 3.0)\n",
+    "plt.xlabel('Liquid Assets (Levels)')\n",
+    "plt.title('Distribution of Liquids Assets')\n",
+    "plt.legend()\n",
+    "plt.xlim([-.5,10])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5405776d",
+   "metadata": {},
+   "source": [
+    "# Calculating the Path of Consumption given an Perfect foresight MIT shock\n",
+    "\n",
+    "This section details an experiment to exhibit how to the transition matrix method can be utilized to compute the paths of aggregate consumption and aggregate assets given a pertubation in a variable for one period. In particular, in this experiment, in period t=0, agents learn that there will be a shock in the interest rate in period t=10. Given this, the simulated paths of aggregate consumption and aggregate assets will be computed and plotted. \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f887786c",
+   "metadata": {},
+   "source": [
+    "### Compute Steady State Distribution\n",
+    "\n",
+    "We will want the simulation to begin at the economy's steady state. Therefore first we will compute the steady state distribution over market resources and permanent income. This will be the distribution for which the computed transition matrices will be applied/multiplied to. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "582ea2c9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "GPFRaw                 = 0.992274 \n",
+      "GPFNrm                 = 0.995482 \n",
+      "GPFAggLivPrb           = 0.986072 \n",
+      "Thorn = APF            = 0.992274 \n",
+      "PermGroFacAdj          = 0.996777 \n",
+      "uInvEpShkuInv          = 0.996777 \n",
+      "VAF                    = 0.965783 \n",
+      "WRPF                   = 0.000000 \n",
+      "DiscFacGPFNrmMax       = 0.983869 \n",
+      "DiscFacGPFAggLivPrbMax = 0.996471 \n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "ss = IndShockConsumerType(**Dict)\n",
+    "ss.cycles = 0\n",
+    "ss.solve()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95903c7c",
+   "metadata": {},
+   "source": [
+    "## Simulating With Harmenberg (2021) Method\n",
+    "\n",
+    "Harmenberg (2021) method may also be implemented when simulating with transition matrices. In the following cells, we compute the steady distribution using Harmenberg's method.\n",
+    "\n",
+    "For more information on Harmenberg's Method to dramatically improve simulation times see https://econ-ark.org/materials/harmenberg-aggregation?launch\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "68d37656",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Change the income process to use Neutral Measure\n",
+    "ss.neutral_measure = True \n",
+    "ss.update_income_process()\n",
+    "\n",
+    "ss.aXtraCount = 1000\n",
+    "ss.aXtraMax = 3000\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "357c1baf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Seconds to calculate both the transition matrix and the steady state distribution with Harmenberg 3.901898145675659\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Set up grid and calculate steady state transition Matrices\n",
+    "\n",
+    "start = time.time() \n",
+    "\n",
+    "ss.define_distribution_grid()\n",
+    "ss.calc_transition_matrix()\n",
+    "\n",
+    "c = ss.cPol_Grid # Normalized Consumption Policy grid\n",
+    "a = ss.aPol_Grid #Normalized Asset Policy grid\n",
+    "\n",
+    "ss.calc_ergodic_dist() #Calculate steady state distribution\n",
+    "vecDstn_fast = ss.vec_erg_dstn #Distribution as a vector (mx1) where m is the number of gridpoint on the market resources grid\n",
+    "\n",
+    "print('Seconds to calculate both the transition matrix and the steady state distribution with Harmenberg', time.time() - start)\n",
+    "\n",
+    "\n",
+    "AggA_fast =  np.dot(ss.aPol_Grid,vecDstn_fast)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef0fa769",
+   "metadata": {},
+   "source": [
+    "Computing the transition matrix and ergodic distribution with the harmenberg measure is significantly faster. (Note the number of gridpoints on the market resources grid is 1000 instead of 90."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "bfc3fe24",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "plt.plot(aLvls[100:], label = 'Monte Carlo', linewidth = 2.0) # Plot time series path of aggregate assets using Monte Carlo simulation methods\n",
+    "plt.plot(np.ones(example1.T_sim-100)*AggA , label = 'transition matrix', linewidth = 3.0) # Plot time series path of aggregate assets computed using transition matrix\n",
+    "plt.plot(np.ones(example1.T_sim-100)*AggA_fast , label = 'transition matrix _harmenberg', linewidth = 3.0) # Plot time series path of aggregate assets computed using transition matrix\n",
+    "plt.ylabel('Aggregate Assets')\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.rcParams[\"figure.figsize\"] = (20,10)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aab9b0af",
+   "metadata": {},
+   "source": [
+    "### Note* Increasing the number of gridpoints increases the accuracy of the transition matrix method"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "bb5383de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Agg_AVals = []\n",
+    "\n",
+    "mpoints = [100,150,200,500,3000]\n",
+    "for i in mpoints:\n",
+    "    \n",
+    "    ss.aXtraCount = i\n",
+    "    \n",
+    "    ss.define_distribution_grid()\n",
+    "    ss.calc_transition_matrix()\n",
+    "\n",
+    "    ss.calc_ergodic_dist() #Calculate steady state distribution\n",
+    "    vecDstn_fast = ss.vec_erg_dstn #Distribution as a vector (mx1) where m is the number of gridpoint on the market resources grid\n",
+    "    Asset_val = np.dot(ss.aPol_Grid,vecDstn_fast)\n",
+    "\n",
+    "    Agg_AVals.append(Asset_val)\n",
+    "    \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "90ff7aad",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJsAAAI/CAYAAADQqtjfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd7gkVbn11+548uQZZoYZhswQFQFBRLmYIypeBRXFyzUHDJ/3ghFFRa/KVUTFzCUoIgKiIEEl50FyHobJOZx8OlTV/v6o2lW7qqu6q/tUn3P69Po9zzxzOlXvrq6uqr1qvesVUkoQQgghhBBCCCGEEJIEqckeACGEEEIIIYQQQgiZPlBsIoQQQgghhBBCCCGJQbGJEEIIIYQQQgghhCQGxSZCCCGEEEIIIYQQkhgUmwghhBBCCCGEEEJIYlBsIoQQQgghhBBCCCGJkZnsAUwEc+fOlcuWLZvsYRBCCCGEEEIIIYRMGx588MHtUsp5wfvbQmxatmwZVqxYMdnDIIQQQgghhBBCCJk2CCHWhN3PMjpCCCGEEEIIIYQQkhgUmwghhBBCCCGEEEJIYlBsIoQQQgghhBBCCCGJQbGJEEIIIYQQQgghhCQGxSZCCCGEEEIIIYQQkhgUmwghhBBCCCGEEEJIYlBsIoQQQgghhBBCCCGJQbGJEEIIIYQQQgghhCQGxSZCCCGEEEIIIYQQkhgUmwghhBBCCCGEEEJIYlBsIoQQQgghhBBCCCGJQbGJEEIIIYQQQgghhCRGU8UmIcTrhRDPCCFWCiHOrPK8k4QQUghxhHN7jhDiFiHEsBDiAu15vUKIh7V/24UQP2zmZyCEEEIIIYQQQggh8ck0a8FCiDSAnwB4DYD1AB4QQlwrpXwy8LxeAGcAuE+7uwDgKwAOdv4BAKSUQwBepL32QQBXNekjEEIIIYQQQgghhJA6aaaz6SgAK6WUq6SUJQCXAzgx5HnnAPgubIEJACClHJFS3qnfF0QIsR+A+QDuSHTUhBBCCCGEEEIIIaRhmik2LQawTru93rnPRQhxOIAlUsrrGlj+yQD+IKWUjQ+REEIIIYQQQgghhCTJpAWECyFSAM4D8PkGF3EygN9XWf6HhRArhBArtm3b1uBbEEIIIYQQQgghhJB6aKbYtAHAEu327s59il7YeUy3CiFWAzgawLUqJLwaQojDAGSklA9GPUdK+Qsp5RFSyiPmzZvXyPgJIYQQQgghhBBCSJ00U2x6AMC+Qog9hRA52E6ka9WDUsoBKeVcKeUyKeUyAPcCeKuUckWMZZ+CKq4mQgghhBBCCCGEEDI5NK0bnZTSEEJ8EsCNANIAfiOlfEII8Q0AK6SU11Z7veN26gOQE0K8DcBrtU527wLwxmaNnRBCCCGEEEIIIYQ0RtPEJgCQUl4P4PrAfV+NeO7xgdvLqix3rwSGRwghhBBCCCGEEEISZtICwgkhhBBCCCGEEELI9KOpziaSHMvOvG6yh0AIIYQQQgghhJAEWP2dN032EJoKnU2EEEIIIYQQQgghJDHobGoRprvqSQghhBBCCCGEkOkBnU2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhBBCCCGEEEISg2ITIYQQQgghhBBCCEkMik2EEEIIIYQQQgghJDEoNhFCCCGEEEIIIYSQxKDYRAghhCTM47fcjEf/ccNkD4MQQgghhJBJITPZAyCEEEKmE1JK3HjhjwAABx//GqTS6UkeESGEEEIIIRMLnU2EEEJIglim6f5tGuVJHAkhhBBCCCGTA8UmQgghJEHMcsn72zAmcSSEEEIIIYRMDhSbCCGEkAQxyp6byaLYRAghhBBC2hCKTYQQQkiC6KVzdDYRQgghhJB2hGITIYQQkiBmSRObysxsIoQQQggh7QfFJkIIISRB6GwihBBCCCHtDsUmQgghJEH0zCZ2oyOEEEIIIe0IxSZCCCEkQUwGhBNCCCGEkDaHYhMhhBCSIGa55P1NsYkQQgghhLQhFJsIIYSQBDFZRkcIIYQQQtocik2EEEJIghiam4nOJkIIIYQQ0o5QbCKEEEISxO9sothECCGEEELaD4pNhBBCSILomU0Wy+imFFLKyR4CIYQQQkhbQLGJEEIISRCDzqYpyabnnsFPP/RePHPPHZM9FEIIIYSQaQ/FJkIIISRB9FBwvaSOTC7X//j7KAwN4q8//O5kD4UQQgghZNpDsYkQQghJELPkldHR2TR1ECkx2UMghBBCCGkbKDYRQgghCWKyG93URPCUhxBCCCFkomjqmZcQ4vVCiGeEECuFEGdWed5JQggphDjCuT1HCHGLEGJYCHFB4Lk5IcQvhBDPCiGeFkKc1MzPQAghhNSDntnEgPCpgxB0NhFCCCGETBSZZi1YCJEG8BMArwGwHsADQohrpZRPBp7XC+AMAPdpdxcAfAXAwc4/nS8B2Cql3E8IkQIwu0kfgRBCCKkbX2YTnU1ThlSKziZCCCGEkImimWdeRwFYKaVcJaUsAbgcwIkhzzsHwHdhC0wAACnliJTyTv0+jf8AcK7zPEtKuT3xkRNCCCENwsymqQmdTYQQQgghE0czxabFANZpt9c797kIIQ4HsERKeV2cBQohZjp/niOE+JcQ4o9CiAVJDJYQQghJAr+ziWV0UwY6mwghhBBCJoxJO/NySuDOA/D5Ol6WAbA7gLullIcDuAfA9yOW/2EhxAohxIpt27aNe7yEEEJIHPTMJjqbpg4soyOEEEIImTiaeea1AcAS7fbuzn2KXth5TLcKIVYDOBrAtSokPIIdAEYBXOXc/iOAw8OeKKX8hZTyCCnlEfPmzWvsExBCCCF1YvoCwik2TRVYRkcIIYQQMnE0U2x6AMC+Qog9hRA5ACcDuFY9KKUckFLOlVIuk1IuA3AvgLdKKVdELVBKKQH8BcDxzl2vAvBk1PMJIYSQicYss4xuKmIbqgkhhBBCyETQtG50UkpDCPFJADcCSAP4jZTyCSHENwCskFJeW+31jtupD0BOCPE2AK91Otn9N4BLhBA/BLANwAeb9RkIIYSQemE3uqmJYBkdIYQQQsiE0TSxCQCklNcDuD5w31cjnnt84PayiOetAfCKZEZICCGEJIsvs6lcRnF0BGa5jK4ZMydvUAQixTI6QgghhJCJoqliEyGEENJumOWS+7dlGLjgg+8GAJxxyVXI5HKTNay2h2V0hBBCCCETB8+8CCGEkATxZTaZXhldYWR4MoZDHFhGRwghhBAycfDMixBCCEkQXWwqFwru3+yGNrlw/RNCCCGETBwUmwghhJAEMYxwN5NlmpMxHOJAZxMhhBBCyMTBMy9CCCFtgx7e3Sz0zKaiT2xiZ7rJhGITIYQQQsjEwTMvQgghbcGmlc/g/FNPwn1XX9HU99HL6ArDdDZNFVhGRwghhBAycVBsIoQQ0hY8fdftkNLCnZdfDNNonsNJF5uKoyPu3xSbJheKTYQQQgghEwfFJkIIIW1B98xZ7t+rHnygae8TVapnGiyjm0xYRkcIIYQQMnHwzIsQQkhbYJS8LKVVD61o2vuYEWKTtKymvSepjRA85SGEEEIImSh45kUIIaQtMEpF9289xDtJLMuElOGiEp1Nk4tIsYyOEEIIIWSioNhECCEkFNMwIKWc7GEkRrnoiU3Nyk+yzGj3ErvRTSzb163Bn779VWxZtRIAnU2EEEIIIRMJz7wIIYRUMDo4gAv+49248cIfTfZQEkN3NllWs8SmaEFJCVGP33Izbr34l9NKyJuK3Hf1FVj9yL9w6VmfgbQsX0A41z0hhBBCSHOh2EQIIaSCZ++5E0axiCdu/ftkDyUx/M6m5uQnKcdUKp0JecwWom688Ed48Lo/Y9uaF5oyBmKju9eee+Ae32NRpY6EEEIIISQZKs+GCSGEtD0S08/5US4W3L+bVdKmBI5sRx7FEaPiMd1RZTHDqSkMbN2Mf11/LXasX+vet3nlsz43k2WYSOXSkzE8QgghhJC2gGITIYSQSqZhmZExIZlN9nIz2RyKYtS3Hk3TQGF42BtPk0LK253rfvx9bHr2ad99pmH4ugHaYmNugkdGCCGEENI+sIyOEEJIBboLRJ+ktzJlLbNJNjmzKZXOIJPzixnSNDHav8u9XSqMNWUM7c621ZXliXbYvS42TY9tmhBCCCFkqkKxiRBCSAXlgldyppeftTLGhGQ22ctNpVPonT3H95hpmhgZ6Hdvl0ZHmzKGdqd75syK+8xy2V9Gx86AhBBCCCFNhWITIYSQCoqjI97fY9NDFPF1o4soozPKZdx44Y/w/IP3N/QeekB475x5/scMA6ODA+5tOpuaQ9fMWRX3WUbZ59AzKTYRQgghhDQVik2EEEIq0MWm0uj0EEV83egiyuievO0fePyWm3HN/3yjoffwyujS6J0bEJssE6P9/e7t0tj0WK9TjVxHZ8V9wcwmyTI6QgghhJCmQrGJEEJIBUWtxKs0XZxNMQLCx+vi8pxN6RBnk4nRwX73NsWm5qCLigrT8JfR0dlECCGEENJc2I2OEEJIBaVpWEbnCwiPEJuy+Q73b8s0kUqn63oPXWzqCzib1j35GNY8+pB7m2V0zaEcsl5Nw4Cld6MzmhMQTwghhBBCbOhsIoQQUsF0czZZlgmzXHZvm1GZTVoY+vCunfW/j+5sCohNz9x9OwrDQ+7tMp1NTUEPt1eY5TKgd6NrUjdCQgghhBBiQ7GJEEJIBf7MptYXm4xSyXdbRogNuotreOf2ut9Hz2wKOpuqvRdJDtU9ca/Dj8TrP/5ZACqzSetGZ7CMjhBCCCGkmVBsIoQQUoEuhEwHZ5MRyPGJzGzSRLahHY2ITbZ7JpVKo3fO3KrPDSv3IuOn5Dib3vipL2DWwkUAbHHJV0ZHZxMhhBBCSFOh2EQIIaSC6ZbZFAyNtiK6kekursbEJsfZlMkgm+/A3KXLKp6z2z772e/FMrrEkZblOpuyHXmkM1kAgBEICGdmEyGEEEJIc6HYRAghxIdlmT4hZDqIIoYTDp7r7AIQ7Wyp5mwKdjQLQy03lbIPr6d+90c4+h3vdh9PZzJ49ekfBzA91utUwyiVACmRyeWRSqWRzth9UCzDgNQzm9iNjhBCCCGkqVBsIoQQ4iMogkyHzCblbMp1OWJTZBmdltmkiU07NqzDLz7+QfztJ+dVfR/lmEk5IkcqlUYml3cfT2dzyHV2AgBKhdZfr1MN1eEv22F3FUxnbWeTWS5D6mV0Ec42QgghhBCSDBSbCCGE+AiKS9OhjE5lNuUdZ5OMkdk03L8LgO1W+t2XPofRgX48dcctVd/Hczal3fuU8ATY4odyV9HZlDxKVMzmHbHJKaOrCAins4kQQgghpKlQbCKEEOJDF1yA6REQXi75nU1mDLGp7HzunevXucJQKp0JfZ1COaZSaU1s0oSnTDaHXIfjbKLYlDgqdD3nOJuU0GeXQHpupqjvnxBCCCGEJAPFJkIIIT5UwLJiOohN8Z1NWhc+R7gwSqXY7xMqNmW8v9PZDDL5PIRIwSgVI8v5SGOoTnQVZXSGv4wu6vsnhBBCCCHJQLGJEEKID5U7pEqRpoMDpxwjIFxK6evCp4QLwyi791mmAaNcrnit97gSm7TSOe3vTDYHIYQrhihBiyRD2c1sst1jadfZZPjC3U2W0RFCCCGENBWKTYQQQnwoISaTy9m3p4ELpOwIRyqc2zLNis5yQadR2RHZzIC4VM3ppbKAUmnv8Kq7nJTTRpXzTQfX2FTC/Z47AplNZTqbCCGEEEImEopNhBBCfFiGLZioLmqW1fqdu9wsn84uCGEf+vQMH8AroevsmwEIAaNcgmWaMI1y6LLCUF3OdGeTX2yyBbysI+QZpWiXFKkfVQKqXHlq3UvL8gmJzGwihBBCCGkuFJsIIYT4UBNx5WyaDi6QkuZsUq4jJQwpVDh4R3e364wpFcYqnE3F0TjOJi2zKa0HhGec++z/LYNiU5IEM5uEEG4pnVH2srcs00C5UMB9V1+BXZs3TvxACSGEEEKmORSbCCGE+HDL6JySr7B8o1ZDZSNl8x2u0BMU0UqOiJTr7HY7xpULhcoyuqrOprCAcC2/yXE2uV3SpoGQN5UIZjYBXumiHvRumRbuvvJ3uPPyi3HxFz41sYMkhBBCCGkDKDYRQgjxoQLC09Mps2nMK6NTQlAwJLro5CfluzpdsaI0NgbT8D+vXCUwPVRsSunOJnudKreNZTCoOklKgcwmAEhlwsQmA1tXr3LuL07gCAkhhBBC2gOKTYQQQnx4zianjG4aZDaV3MymTghHCAqKaEbRFh0y+Q43SLxcGKvIbKrf2VQZEK7cVeyKlixKOFJ5YwCQUWV0mqhkGQaEEBM7OEIIIYSQNoJiEyGEEB9eQPj0cTa5YlNHJ1IpJyA8IKKVHTEim8u7mT9hmU2lqs6msMwmvYzOFpvobGoO4WKfvc7179uyLIpNhBBCCCFNhGITIYQQH66zSYlN0yCzSZW+ZTs6XCGiwtmkuWJUZlMpLLOpqtjkdKNLRZXR+cWmYIkeGR9KUFKCIuCtax3LMACKTYQQQgghTaPyDIwQQkhb42Y2ZZWzaXqV0UWKTW4ZXR7ZslNGNzZaIQiVxmJ0o9MEDn8ZnRMQ7o6BYlOSWI7YJNKVpYs6pmnS2UQIIYQQ0kTobCKEEOJDCSBuZtN0KKNTAeEdXa7TKOjYKiuxKZdzM5tKhYKb2ZTJ5537YmQ26c6a0DI6+386m5JFhq3/EGeTtCg2EUIIIYQ0E4pNhBBCfCgnUyZnCyLWNAgIL8dxNjndyrL5vNvNTM9s6uzts++r5mxyBCyfsyldWUbnjoFiU6K4ziaf2BTibGIZHSGEEEJIU6HYRAghxIfrbJpGmU3KjRQ3synb0QXA342us0eJTVWcTYZy1ugB4VpJV4aZTc1EWpXrP9rZxFMgQgghhJBmwcwmQgghPpQIk85kbfeHlJCW5XOLtBJSSpQKBQB2NzpRy9mUy7llWKWxMRhlWxDq7HPEpmpldK6zKbwbnRLwVIe06dDpbyoR6mwKy2wyWEZHCCGEENJMKDYRQgjxobePT6VSsEwTlmUi3aJiU7lYAKREJpd3PpMtBAWzqMpaQLgSKMqFgitgxCqjC3M2ZcKcTfZ9dDYlS1g3ulSIs8k0yhSbCCGEEEKaCMUmQgghPtyOaukMUqm0LTaZZmj2TStQVq4mJ/Q7lbaFiGB5oCqjy+bykM59pcKY65JxnU3VyujCMpv0ki4nB0s9bjkleiQZlFDq60YXJjaVShSbCCGEEEKaCMUmQgghPnRnk0ingbLnGGlFlBMp64R+x8lsUgJTqTCGTM7uQqcym8rVyugcp5LfWaMFhGdUQLiT2cQyukQJczaFiaRGqcSAcEIIIYSQJkKxiRBCiA9TL6NTLiCzlcUmpxNdh+NsSimxyf+Z9DI6JUiVx8bcIOl8dzcAwChFu5FcZ5PurNEym9JOZlPadTaxjC5J3MymkFB2HaNcQjbfMWHjIoQQQghpN1ozgIMQQkjTkL7MJkeYaeGOdCrQ2y2jU0JPRBldJpdzhalyseB2o8t3OWJTuRT5Xp4rzBOYwoQP19lEsSlRvG50ekB45XU1o1T0OZuklBXPIYQQQgghjUOxiRBCiA/d2aTKyVq5a1pZ60QHeEJEMCDc60bnBYQbpRLMsi02KbHKjCU26c4mrYwuG3A2mRSbkiS0G12Is6lcKvkEplYuEyWEEEIImYpQbCKEEOJDau6cqHyjVsLLbLLFIuU0CuYl6WV0KqdJF5tcZ1O1MroQsUl3OSmXjRKbopxNxdFRbFm1suZnI368zCa9G2BYQHjZJzaq75gQQgghhCQDxSZCCCE+TLcbXdoVTVrZ+VFRRucIEVHOpkwuj4yTrWSUS64glOvoBISAZRqRZYWhYlOm0tmkBKiozKaL/+tTuPSsz2DdE4/G/ZgEWjc6zdmUyYYFhBfd7RxgOSMhhBBCSNJQbCKEEOLDmmaZTeWC7VhSgdCuWysisymb18SmUsnNbEpns65YFOWECRObVMA44LlsajmbBrdtAQCsfvSh2h+QuIR1o9OdZQqjXPK59dR3TAghhBBCkqGpYpMQ4vVCiGeEECuFEGdWed5JQggphDjCuT1HCHGLEGJYCHFB4Lm3Ost82Pk3v5mfgRBC2g1dMBHToIxOBXorASmqNNAto8sFxKayLjY5WU6RYpPnClMILYhaOW6U26lmZhODq+vCdTbpmVmhzqaSz1VGsYkQQgghJFkqL/clhBAiDeAnAF4DYD2AB4QQ10opnww8rxfAGQDu0+4uAPgKgIOdf0HeK6Vc0ZSBE0JIm+MJJpnIMO1WwiuPc8SmkNBzKaWvG51I2QKRXUbniE2ZDNK5HDACmKXwkHDLdJw1IW4a/b1VaHWt8i1KTfUR5mxKh2Q2GaWi39nEzCZCCCGEkERpprPpKAArpZSrpJQlAJcDODHkeecA+C5sgQkAIKUckVLeqd9HCCFkYnAFk0zaE2ZaOLNJdY9Lq7wk1QlOK6OzTAPSspBKp5HOZJBKpW3BSEqUxuzMp3SmMWeTjudsql5GV/EZjDIGtm6O9dx2JqwbnS78qe/FKJWZ2UQIIYQQ0kSaKTYtBrBOu73euc9FCHE4gCVSyuvqXPZvnRK6rwi9PoEQQsi4cQWTlFdG18oB4W4ZnRKb3IBw7zN5JXQ5975MzhaWiiMjAOxyrLSb2RTlbKrMbAKAJQcegp7ZczBj/m72stL1ldH95X+/g1996j+x4eknqz+/zVECot6NTnc2ZXI5N+Td1LoK0tlECCGEEJIsTSujq4WwE1PPA3BanS99r5Ryg1N+9ycApwK4OGT5HwbwYQBYunTp+AZLCCFthBJM0lo3upbObAqU0SkBTXe26J3oFJlcHqWxMUhpi1J6QLgRWUYXLjb9+1e/DSktVwRJxS2jc8Sm51fYlebP3X8XFh9wYNXXtDMyxNmki00ilUIml4NRLKJUGHXvp7OJEEIIISRZmuls2gBgiXZ7d+c+RS/sPKZbhRCrARwN4FoVEh6FlHKD8/8QgN/BLtcLe94vpJRHSCmPmDdvXsMfghBC2g09ZNntRtfCYpMZzGxKV+ZQGUWvE51CdzkBdhldOlejjC7EWQPYIeE+t00dIl7ZyZICgBkLFtZ8fjsT2o1OF5tEyhUMVXkkwIBwQgghhJCkaabY9ACAfYUQewohcgBOBnCtelBKOSClnCulXCalXAbgXgBvrRb8LYTICCHmOn9nAbwZwONN/AyEENJ2qNKudDrjOkT0fKNWozIgvFLo8cLBPbFJlcwBAIRAKp12hYrIMjrDEZsy4ZlNCjc3KobIsWPtGu8Gu9NVJbQbnU9sEu524Beb6GwihBBCCEmSppXRSSkNIcQnAdwIIA3gN1LKJ4QQ3wCwQkp5bbXXO26nPgA5IcTbALwWwBoANzpCUxrA3wH8slmfgRBC2hG3FCwzTcroggHh6jNpOVTlELFJdzalMxlbqHADwiPEpghnU5B0Ol5AuJQSW1ev8j5LRPkesanpbHLK6ABPYASY2UQIIYQQkjRNzWySUl4P4PrAfV+NeO7xgdvLIhb7kiTGRgghJBxXbEp5YlNrB4TbQoISilR3MquOMrq0k7GkxCg9XFrHcsQjXeAIw3M21RbxKDbFRwmIemZWOh0Um/KVr6OziRBCCCEkUSYtIJzUydkzJnsEhJA2wdrwYgA9SP3qeKS2LgMwG9Yl7wCu3tWU93tqYB5Wj8zC6xY+i1QT+osaqw8FMAOZy04Erh5EattSAHvA+sc3gUc/bD9neBaAg5Fee4e7v82uPwTATABAutQPnD0D6Q37A5gP4/L3A3/bVvFe1sjRALJIfW8vIB0tYKTHugEcDnPdgxH79+Ps/+7+MQaLXQBm2+P853eAxz9a9zpoF6xdRwHIQ/zoUCBrC4ip4ZkADgEAiKFNyIythm2c9oj6PgkhhBBCmsbZA5M9gqZCsYkQQogPS9qKTwoSQkjffc3g+o0HAACWde/C8hnJT/hNaZdUZYTjenE+k9Q+kxF4DgCkfX9L3+Pq+UEs5/6UqO4EU2OwUHu9mtp7GVYzoxZbH5VoJeBlW6nvTt2fSVXmXplN3L4JIYQQQtoRik2twjRXPQkhUwfrMx8GNm1E6tMPIPW7i4AH7oV812XAS1/WnDd895sBAOU3XQC8+vWJL974/MeB9WuR/sRdwNJlENf8Efj9/8F8+eeA95wGADDvug04/3tIH3wi8Nl7AACZ874N3He3/fecZcDZNyP9658BN10H8w3/C7zuTRXvZb3v7UC5jNSXtwCBbnY66Y3rgc9+FObs/YCzb6l8grNO5NGfgLHyWeDZp+zPcvjpwIc/OY61Mb2xPvReYHAAqS88C8ycBQBIPfMU8NUvAADErD2QWbQYeORf/te9+cdN2fYIIYQQQtoVXiIlhBDiw5fZpDq3TUQ3uiaZS1SYt9uNLiT0XAV1p51cJ/v5XraPyliqGRBuxuxG5+ZG1c4K0t9LD7UmlahsMaEFhPu60aWEL4tLYTAgnBBCCCEkUSg2EUII8WFqgokI6dzWaphOqHZGdaNzBDSpi02BEPGKvx2BQv0f1r1MSumJHaL64VUJILW60UFK33sxILw6Xjc6LSBcE5tSkQHhFJsIIYQQQpKEYhMhpKWQUmKkvzlB1QTYuXE9SqMjAGz3jduNzmy+s6mWQNMoSqDxnE32++huLeVsiXI2dfXN8D0e5mxSolA6k4EQ1W1accUmCel3NkU4qoJsXvksLj3rM9jolN+1C66zLO1tS77OgCIV6myqKfoRQgghhJC6oNhECGkp7vrDJbjwI6fimXvumOyhTDu2rFqJ3372oyiNjQGwy83cMroJEJuaV0anXEtKbFIlbHoZnRKKKt1MgCc2qWWEOYxKBXu95Tq7ao4pdhmd9JxZ9vvGK6O7+n++gS2rVuKqc8+O9fzpQmgZXVoroxMC6WyY2ERnEyGEEEJIklBsIoS0FPddfQUA4O4rLpvkkUw/Xnj4Qd/tVDrtTtonIrNJNEFtklK6Ak06ZwtJXmaTVxpohjibdFGic8ZM331hZXRFxxGW66otNlVzNkmtZFFKyydslWOW0Y0O9PvG1C5YrtjkldGlKsroQsQmZjYRQgghhCQKxSZCSEsiZetmCE1V9IwiwHE2qZIzszXXtxJzUumM69JySwMt03U3xXY25aLL6EqjowCAfGd3zXGpAHHLqBTx9HwsyzR94dXMbKqOEkX1MjpfQLgQyLKMjhBCCCGk6WRqP4UQQqYeE1LW1WakK8SmjE+YaTZ66VNSmG4nOu+zpZz32bp6Ff73PSfimHee4oo4+jrQRYkux9mkyujMENGn6IhNua7OmuPSy+iklL6MJ91FZotNehkdxaYopJSAlAD8+V++zKaIgHCW0RFCCCGEJAudTYSQlqSVu6NNVYJiU9qX2dSc9a0LK9IRCpLECwf3BAbVYW/bmhcAAPdc+XtXbMhEBYTPUAHhTmZTWBndmF2ylu+q7WwSQmjlfH5XjV5GVy4WXQHF/jzxMpu895nah/nnHrgHd11xWSLfvZ7XpIt3ld3o6GwihBBCCGk2dDYRQloSSbGp6YhUyhVmmpXZpJeR1QzLboAwx5ISeXS8TnJ6ZpP3d1ffTABaGV2I6OOV0dXObAJsx41lmrAM0/e+umuv7ISOBz9PbJoUup4U137/WwCApQcdgiUHHTquZbmd6AIOuWAZHTObCCGEEEKaz9S+5EkIIRGwjC55jFLlhFtN3Ju1vnVHSVh+0XhxnU1a2HcqFSY22eNI56KcTTPtx6s5m9wyunhiU1RIuL6uVYc79dx6xaap7mxS9G/dPO5lyJBwcMArWbQfFKHOM4pNhBBCCCHJ0hpnoYQQEoDOpuQJy61xM5uaJDbpbqZmuKcMN7NJE5syIWKTKqPzBYTrziYnINxxO5mhAeHxy+gAf26Tjr5tl8ZssSnf3WN/njrL6IIun6lKcWT8XfNUaa0eDg7AV1InLYmOnt7K11K8JoQQQghJlNY4CyWEEPgzfZpV1tXOhIVeK5dIszKy/M6m5Mvo3IDwms4mp4xOK53TnV5KrFLLCXOBFcccZ1PMMro4zqZyoeAssxNCpCAtq2a+kP56vWvj1tWr8KtP/yeeu//uWONrNvpvuDA8nNjyqgXNS8tCZ29fxf1mE0o4CSGEEELaGYpNhJCWwSh6ro7S2FhTAqXbmbDSMOUSSbob3Y71a/H8g/f7BCazCe4SLyBcE5vCMpuMSrGpVBiteF7aWU64s8nJbIpZRqecTUHxyOdscsroMrm8+xlqldIVRz2XkGkY7me76efnY2DLZlz7g2/HGl+z0X/Pwzt3xH7d0M7tePyWmyuceFFldDqWZaKjp6fyfgaEE0IIIYQkCgPCCSEtQ0kLS5aWhXKxgFxH7TbzJB5GiIDidaNLVgi66PMfBwCc+P++7N7XlIBw5zOlc9WdTSpvSQ/qXnbY4QDgC65WZXRhgk+jzqbg5/ZlNjlldJlsFplcDuViAUapWFXQCpaklcbG0NmbnXKCivpsADC0Y1vs11165mcwOtCPsaFBHPnWk9z7owLCdaRloaOn0tnUjG2PEEIIIaSdodhECGkZlCCgKAwPU2xKkLCQZFWS1Kwyup0b17t/W2by7+EFhHsikghxNo0ODgDwO5t6Z8/FJ35zOXKd3jaWzXcAAMrFQsUy6s1siiyjsyq70aWzOTewvB5nEwCUxkbR2dtX1fEzGZQK3joc2rE99utGB/oBABueeQpHavcrZ1M1scmyLN/3qahVmkgIIYQQQuqDZXSEkJYh2Aa+ODL+nBfiEVYapkrOJiJAuRnuEtMto/M6ywUDpAFgTIlNmrMJADq6e3xOqLxTglUI2fbcbnQhYkYYbkB4lcwmRSaXa6iMDvAcRCIlwp4+aei/56Gd2+sui00HRMM4ZXTSNH2B4YpmdEIkhBBCCGlnKDYRQqY8ahIadDYl0cGKeIRnNjnd6BJ0Nuliie6maoagZYQEf4eV0RWGhwD4s53CyObySGezMMtllAOd4UpjKrNpnM6mkPWQdsrogNod6YK/C1XeFyayTCZlzdlkFIuhAl41Uhm/OdstowsRE93nRGzHdDYRQgghhCQLxSZCyJTm4Zuux0//8z3YsX6tL7MJCHeXkMYJK6NrRmaT/r0VR72/m5EppIQZn7MpE11BHnQ2haHEpGKgg5rnbIoZEJ5x1m2VgHBFJqs5m0K+J53CqH9cSgSr1qVtMgj+nkfqCAkHKoPeLdfZVE1sCt+OmdlECCGEEJIsU+vMkxBCAvzj1z9FYXgIt13ya5THAplNU1xsuvuPl+HGC3/UMl3zQgPCVRldgt3odOdNQfs7yfdQlJ2OZ9m8JjZVKbPSHVBRdHTbpXRh2UhAA86mYEB4yHqwy+hUZlN9zibVJU+IqXXIrxCPh+t0NqX9oqGX2VSljI7OJkIIIYSQCWFqnXkSQkgEpmmiOBbMbJraZXT3XPl7PH7LzRjctmWyhxKLqgHhCTqbdDeTnrvVjNwctXxdAKpWZpXO1u6b4eY2aeKItCyvG13XeDObajibamY2+UXZqZvZ5A9Zr7uMLvA9KpGumrNJiU3BXC06mwghhBBCkoViEyGkJbBMw3WOKMI6gk1FapU9TRXCRAw3sylJsUkTCfW/gw6fRN5rVLmNvNK2YPmVTpwyug5HuNLFkVKhAEiJbL6jqrNGJ+U6m/zrNmxdp3PZ2GJT8HcyVcvogoH/KjcrLtHOpipldM66DXaxpLOJEEIIISRZptaZJyGERGAZpuvQyGTtSXewDGeqkqRQ00xMwxbFhEjhhA9+BIA3cY8KVm6EwqheRqc5m5qwnlSpW94pfQOqdyvLxCijy4eU0SmhpKOnN/bYVBmdZfjFyNAyumzOFcLCugbqqN9J96zZ9jiV2ISp5WwqjdWfwaaXpKYzEd3oqoiJ6jnZQK4WxSZCCCGEkGSh2EQIaQks00CpYE+au2fNAlDpjJhK6JPioHNlqmI6jpn3feeHePHr3wLAm7hXE5ueuedOvPDQitjvowdr64JNU8Sm0DK6cWY2hZTRKaFEPRYH5cwJbh9h6zqdzbljq+WUUyJs14yZ9vOd73WqldGVHGeiEo+LMcQmXRQKRqG53eiqBoTb63bu7ksDr6XYRAghhBCSJBSbCCEtgWmaKBfsYGQ1iQ5mvkwl9CDiZnRZawZKxNAFl1pldOVSEdf/+Hu4/oIfxH4fvyNIdzZNchmdEBWlWWHkuxxnkyaOuM6m7vhik+dsCnSjC1nXmWzWdV3V2p5U2VynI3x5Ip4nNjUjjL1elFjcO3ceAGAsRkC4UfTC0YNupDjd6NS6fdXpH8MBx74S7/zSN0OXRQghhBBCxkfts2pCCJkCWIbhihGqVGkql9HpLp1a3cOmCqobnXKaAFpAeIQ4US4UYJlmXWHtvqwjLV9oosroosSmTCYLIWq7fzq6u51lVwad11NG5zqb4pTR5bQyOqOGs8kpT+vo6XOeb1S8ziyVkeqIly3VLNQ4e+fOw65NG2I5m/SctmD5oRKSqjnXlCDVPXMW3vTpL7gCazPC6QkhhBBC2hk6mwghLYFlmq4YodwjU9nZpLt0agU6TxVUNzoVRA14beSjhCAlYEhpxRaLdGeTTjMcYK7YFKOMLk4JHaB3o6t0aOUbcjYFyujCAsLrKKMrK2dTb6+zPEds0l5XngICqPr99s6ZCyBeQLguNjXkbAqUKKZVmahp+EpfCSGEEELI+KDYRAhpCSzTcMUINaEvTWGxyfQ5m1pLbNI7srlldBGZTWbZ0P6O13UvygWVZAh58L18YlNEQHhcsUmJnbpDq6HMJifgOiiahK3rTDbrjq/WelaOP+WyUmKW/rqp4LZT4+xzyujiBISXq5TRxelGJ6V/3YpUyt3Gm+GsI4QQQghpVyg2EUJaAsu0XAFHTeinckC47tKZChP7OKgyunROE5tqOZu0zmhGjS5piihRIWlnk2kYKBcLECKFXEeHe3+ksykT09mkMptGQ8SmupxNTgZTIKsqbF3XU0ZXHPOLTer5hjG13Haus8kRm+ovows6m+z1FtZtUIjo0x1Vztgq2WqEEEIIIa0AxSZCSEtgmVpmU0uU0WnOppiOn8lESumV0fmcTdUzm/TPNl5nU9Jd+1QeVK6r01daFVVmFTegXImdelc9NyC8DmeTKqOLKgfzPTeXi+1s8sro7MwmtS36yuiKky+Aus6mOfMBNBIQHshsquJsUttxGO73wI50hBBCCCGJQbGJEDJl8Qs2JS+ziQHhiVIYGcYVXz8LgD3xDhNmLDOqjE4Tm2o4bhSlsYgyuoQn+14JnV8AEkKECk4j/btiLVeV5BW07CklPNUXEB5eRhfmbMrm8po4Fb2eTaMM0zAgUinkOjp9y9dfZ5RK2LlxA37+8dPw2D9vij3mJPECwu3MpuLwcGS5pqLRzKYwt5PCLaOjs4kQQgghMVj98IMYHeif7GFMeSg2EUKmLHpZVmlsrCKzaWo7m6ZWyVI1Hrnpeqx/6nEAlblFbmZTnDK6UjyxKcrplXRHMK8TXXfFY9U6ltVCBajrQlthZMh5r+aU0XV093hldFWcTUrAyXd2IaUCyEMCwo1SEbdd+msM79iOm35+fuwxJ4kqQ+zsm4FsRyektGoKyLojKygOVetGVy00nM4mQgghhMTl2XvvxJ/O/Rqu/PZXJ3soUx6KTYSQKYsu0kjLm4h2OM6ScrFQ0wkxWVgtFBBedMquALvrmY6b2RQZEF6/sykq/ymqVK9RvE50XRWPqZyeRggLlFad6ToTcDaFbdMdPb2xyuhU6WC2s1PrtBYeEG5MYimdZZma86zLLT8s1CilM6oEhFdzNlUro3NFOTqbCCGEEFKDx2+5GQCwbfWqSR7J1IdiEyFkyhKcVKtcnFQmg2zeDnzWy2omCyllRdt0s4UCwnVxwwyEfAslWERlNmmfM25mU9SkPunJflQZHeAXH6qFR4fhBkprTpjGnE2VywHC13W+p8cTm6qsJ+VsynV0IhUIFDd8LrTSpHZfK47aoli+qxupVBrdM2YCAIa2b6v6umpldNJZb2HdBquV0UVlZxFCCCGEbFr5DH724fdhxV+vBgDs2rRxkkfUOlBsIoRMWYLdzZTrIZ3JIOt0FytNcimdlBKXf+2/cdW5X/Pfrwk4Uz0gfHjnDvdvJVYoauXZNNKNLtLZlLD4oZxNHWFldJr4MHO3hXUtN5VR60R3NqnMpvhikxKDosrBdPJdXW5wezUHmSs2dXb6xmlZpn+bLJUmtWxMZVwpcW7+nnsDADY//2zV1+mls1ZgPVR1NlUpo2M3OjId2bJqJa753jno37xpsodCCCEti2mUcc3/nIPRgX7cdsmvUS4V0b+F+9W4UGwihExZzED5mRIPUum0G37cv3lyry6UiwVsfOZJrH7kXz5nRCs5m4Z37Yh8LF1D4DAb6EYXJXIkLX6o7SUXWkbniU2veO8HMW/ZXnjtRz8da7lBJ4xlmnb5mhDId1a+VxT1BISnUum6yuhynV1Iaw6s4GvKxWLiGVn1UBjxi3O77bMfAGDT889VfV25FF1GV60b3QHHvhIAsNfhR1Y8lqKziUxDLj/7v/H8ivtw3Y+/N9lDIYSQluWFh/xB4A/+9Rr370w+P/EDajEaD60ghJAmE+UISqU9Z9Mfzj4Tb/nsmdjv6JdP5NBc9AlqcXQEXX0zALRWQPjwjmixKees56gwdqORzCZH5Mh2dKKsBUJHhZA3ilrv2VzlyYDQxKae2XPw/u/GD8lOpdKAEJDSgrQst7Qr19FRNYg6SDoiK6giH0sI5/kxnE0F3dnkiShm2f8eRqmYeEZWPbhik+Ns2m1vW2zaUsvZpJfRRQSri5CA8OPecxqWHHgIlh58aMVjwWwrQqYDKt9sYOuWSR4JIYS0LmPDg77b9119hfu3USzCMs1xNZ2Z7tDZRAiZskSVZaUyaWQdZxMA3HXFZRM1pAp8HcmcTCmgdQLCpZS+MrogtcoV6+1GJ6V0hbhglzgzabHJGVsw9Bzwl9E1cpKgBArTNN3vut7Q8ShHTTAgXLn40ln7+UY5TmZTl09ECQpURqk0qWVj6reixKY5uy9BNt+Bga1bMDo4EPm6agHh1ZxNmWwW+xx5NHIhzrNgthUh04mkRXxCCGkn1MU65YwOVivoTXZIJRSbCCFTFjNCvEinM67jBgBmL1o8UUOqIJ7YNHXL6Aojwz5Rb7e99/U9rgexB0PQgfq70UktVyeX7/A9FgzKHi9K5MvkQsQmLSC8EbFJDwn3xKb6luMFhPsng8HbuU4lNsUpo3PEpi7P2RRWRmeUir73Cftum0nRcTblnTK6VCqNWQvt3/Hgtq2RrytrYlOUI6wedxkQ/T0QMh2YTAcjIYS0Oiofcsb83dA7d17F4yUnsoGEQ7GJEDJliXQ2pdO+IOuuvpkTNKJKdIFFb9vuE5umcED48I7tAIDZi3bH+879Id755W/5Hk+l08hkc4CUoaKZWWc3OlX6lE5n0Ddvvu+xpDOE1Hejys90dBdSQ2JTxstbalRsUmMIinTByaHrbIoVEO5kNnV0+bKlgtugUSpWzT9qNm6guta9L47oU9KuIFast4a/h/DsLEKmA5Zp1X4SIYSQUNT5UzqbxeL9DwRgdzGeMX8BAK+7LgmHYhMhZMoSVX6WymSwc9MG93a5Cc6huC4HXWAZG/Lqus0WyWwa2bUTANAzezYW7LUP8iFh2hmV21SsXM9Gnd3olKCUyqQxd+ky/2MJX4FXzrhMLkxs0sroUg2U0Wmd5JQjq94yumDQuCLS2ZSp7WxSv4VsPu/rshYUZsrFotsRzr49sV0dvYDwXvc+t3teFYdbUbuCGFVG17iziWITmX7QsUcIIY2jXNTpTBaL9l8OAJi3x57omT0XgP+8hFRCsYkQMmUxqzibhBOaDMAXMp0EY0ODuPCj78fff/WTms/1l9FpziajNcro1BUbPQMriBcSXrme6+1Gpwsz8/bY0//YRDqbxpnZlNLykDxHTTLlW8HMpmxHoIyuirPJ1K7ApbRcqeB3M7xzh09gSvo3VIviSKWzyStNjN4OiiPeSV2wjE46YmVYZlM1PIcZxSYy/WAZHSGknVnz2MP4w9fPxMDWzQ293juXzGD/Y47DHoe+GEe97d/di7N0NlWHYhMhZMoS5ZRJpzN48xn/5d6OCq9ulKfuvBVjgwN45Oa/1XyuPkEtjGiZTVZrBIRb7gQ9WnBRuU1qPQ9u24oxJ5+qfrHJK3Wau2QP32Oqu1tSqPWenrDMpjoDwiPKt6IzmxxRpMp6dsWmTMbnvlK/JSHsz71t7Wrf68qFiRVElTCb94lNjoBXRfQpaFcQLdP0bS9eZlOD2VkUm8h0ZILz2AghZCpx5Te/jPVPPo6bfv7jhl6vl9F19c3AO790DvY/5uXId9lNbpjZVB2KTYSQKUtUd7NUJo2lBx+Gk7/xPQBAeSxZV0a5DvHKn9mkiU1Ga5TRVWsXr8i6zqYCiqMj+OUn/wM/Pf0UAMEyuhiZTc56SWUymL14SeXjCZZ8qPFkspXOJv3zNtSNLoHMJlcMMoNB17Uym6JFEfVYOpv1cqW0gPCZCxcBAIa2b/O9btLK6MLEpiqCY/CkTt9eqnWjq0ZUV0BCWpl6y0kJIWQ6o1cf1INXRue/oJhzxCaW0VWHRyJCyJQluozO3uGr8q5SwiVA9SwvsoxOmwRHfY6pgGqLXW2CntPEppH+fvd+0yi7LWHV7Vqo9ZJOp0NFoCTbdLvW55D30Z1c1YS2KPQ8pKSDqYOBvsrZlInRjU4vHfTGaLr3982dF+rAmrzMpsoyOjMiO8kyTbsxgBDI5PL2fdo257r0GuwKSLGJTCfqFV0JIWQ6I9GYyzMqksEtoxuh2FQNHolI2yKlxHMP3IMhpxsXmXoo14w+eRSplJvXpCbhSU+U9QNHrQmoEeVsapGAcOUiqTZBz+RVQLh/Pfdv2exzNtWb2QQAp/3gZ3jL585CrtM+aEcJDY1gOus9k60so1POJKCxgHDXDePLbEqmfCsouB18/Gvs58fJbNKuwKXTXuC2+m4yuRx658ypeF09br4kUL8xvYzOHW9EdlfR6USX7+zyhDdt3SmRrl5Hh56/Rch0QS8nlSylI4S0Ow3GNOiOcR1VRlccY2ZTNUQ7HICOOOIIuWLFiskexrg45P8OmewhTDv23NiFVz48DwNdZVx9/MbJHg4J4cXPzMRhz89AIWuio2yfOBspC5e+fh0AIF9M4ZR/LEEha+Ly16xP7H1PeHAelm6xxY/fv3odirnoA9SyjV04/uF5AIBtM4q47lg7gPCA1b04+snZAAAzJXHJ69cmNr4k2XddD459bA6e3X0Ydx+6I/Q5r3hoLvba1I3bD9uOnX0lvO0OuxTr7y/Zin3X92APZ109vXQI9x68s+r7zRzK4m13LMKunhL+/IpN7v0n37w7Ospp/P5V61DMJ5Pb9Ma7F2B+fweuP3ozts72ZxK95v75WLzdFisved1amOn6joVvums3zBvI468v24SUJfDGe3fDllkF/O2YLbGX0TecwTtuX1yxD3rZo7Ox3/pe3H3wDqxdMIqCWh8SOO1vds7VRW9YA4jKZapt95+Hb8Xa3cbw/r8tRUoK3H7Ydrzikbl4YeEIOotp7Lazw/e6W1+8DasXNn7ClDIBmQJkyJjCeNc/FqOrmMEfTliPsQ5b5FHb2W2HbcMLiyvH0jOawTtvXYzhTgNpU6CzlPa9Xu0v/rVvPx7ddyD22I96YhYOXNOH+5bvxFN7DtV+AWk5MobAkq2dWDd/DEZm+p/3AnB/+wBw3TGbcOjKGXjwgH7099a+KEAIIdOF0663z5uC551xOe7hOdh7Yw9uP2w7Vi32Lkbvv6YHxzwxB88sGcI9h1Q/963GYx94rOHXTiWEEA9KKY8I3k9nE2lb9l1nX1GfMVpZYhOkeyyNXJk/l4kmbdknyqWsFgKsfQ1q0pA1k/1uugreFeFa37saIwDkteempP85YorOb1JKx6gyQCNjPyljCqS0z9s3mnFfD/jXRa33swKr1XJWWCquWhEDNZ4wIcnSPq/VwJfjjtcS7ndd79DVOkgHXqjWgZWSntAEAMIWLoHoda2+H/U89dmyhnf/cGeleyxjNL7eUxbwvpuW4m23LarjNf5xArW3gVzZ2R9kLPd1+u/M+x7q+z6bse2RqcU+63vwyofnYf+1vZM9lAlBWP7t+U33LMSSbV044cF5kzgqQgiZGmQMgaWbO5GOYWhW51tWyn9uoeYmOYPzw2rU1zqHTBrTRfWcSvz0jvdgDIMAqq/f0cEB/OxD70U6k8FnLrtmgkZHAODvv/4ZHnnhOuyz4ABsfeF5AEBfxww89oHrAdilAf9704lIWxYefu9DFeF9jXLhPe/HCOyrFJe89EIsPfgwtyNbkEf/cQNufvQCAMB8MQuPfeBGAMD9f74Sdzx1kfu8B09+wA3anko8dMNf8M8nfo53LT8Zv/jAx0Kfc8v//RL/WvdnnPXi/8Li/Q/E7+76PADgQ0tOxa70Oqzd9igA4C17vAkXfuALVd9v08pn8Lu7Po+D5h2Eb3/gJvf+n993GoaL2/H3k25C39z5iXy23z7yMewcXIcr335VRee7a7aeg+e33QcAeOQDj9RdenXF6rOwbtdj+O1rfgPLMvGn+76CoxYfje994JuxlzG0czt+cetp2K1jPh77wA3u/df/+Pt4asOt+NYrzsWBx/2b7zU/vuVdKI2N4t533+0L11b8ce0XsXbbo/j5636JPQ59kfv8/37R/8PtT/wWb9//Hcjk8nhow18AAEsPPhRrH38UX3nJl3D4G95S1zpQ9G/ehF/f8CHMGM369qX/+M2FkJaFV//nxytec/4//x3l8hjuOfVeNwD9xgt/hMc33IxzjvkGDjnhtRWvWfv4o/jjXV/EoUsOx/COHegvbMLfTrwOsxYuBgDcdulvsGLVVfjMEZ/FUSe+M/b47/jdRbj/hSvx2RedgZe+/V31fnzSAtx1xWW498nf4xP7fwjHvee0yR5O0ymOjuCCG95dcf8cq889RhFCSDvwg+vfDADYe8beeMw57/zrj/4Hz/zrdhz2mjfg1f/xiaqvv2brOXh+830471U/xL5HHuPev+qhB3D1w1/Hv80/Dhd84BvN+wAtDqU40pZIKTE2ZAtNKismiu1Oi3CGx048Klhb1UUDgfwmIXyd0hJ5T8PASP8u9/Y1/3MOLvvi56qMUctsGh1xszGC+S/l0sS2lo+LyrlJpaMPB0poKxcKvryg/s0bYegB4XEymwyVb+QXBmvl9TRCnIBwIVINdW1SmU2WaXgh6/VmNqXDg6ndDoEh43LDrCPWtfo+0tmMb5wq9D6dzaJntpfZNH/PfQAkn3smpcTDN/4Vj9x8vbuv1VHj1wXilJYxFUZx1A4Vz3f1aOvf216sGGH3YaRqdPnbtuYFdptpcaQTHp9kt8upTFROYFhTBkIIaQf06KBn7r4dAPDE7f+s+To38zIYEN7JbnRxoNhE2pLBbVvdv3tmza763Inu0kQ81Amz6vgAeJNnhQoJT6oj3Uj/LiCQZbdjfXTekm/SLyUMR1QKTphlg8GEzcbr4BXtCnMFvWLBNyHv37zR9/njdaNzAsIzfmGmVieyRqgWEK460FUT2aqhh0qbjXajCxFMRvp3Yc3jj9iPhwSX1woJ90Qc+3lKxFPh9dmOTrz49W/GUSe+E//xw5+7riJjPPs5UVl+pm//uzb5M/GklBVB8fbfqjtfREC4Eyre0d0d2kGuNGbvA3Jd1S8gBElXEbk2Pvs0Lv6vT+Hyr/13XcskUwv1G0uy2+VUplwMv7iRzlXuCwkhpC2QlefhcY4J0QHhTje6UQaEV6OpYpMQ4vVCiGeEECuFEGdWed5JQggphDjCuT1HCHGLEGJYCHFBxGuuFUI83qyxk+nNjg2eeFBrcht10jbd2bZ2Na79wbfx8I3XTdoY1MRZdzalAxP6rDNZTsrZNKq5muIQdEOo7SXYvn6qdrqK00kt54hNpULB1zltdHDQdZ8BgBHD2aTWV1DcqtUR7LF/3oSff/w07NocP8zfiDhBADz3i6hTIHJf77qSyp6zqc6udmHOpj+cfSYKjhMoTAhzxaaIdW0F3FxK0CoM266gXEcnsvkOHPee0zBr4WJk83kAyYvqukOtP/Cd6UKT0IQqtU6jnU222JTr6tLEprL2uOd8qodUiHClePqu2wB4DlfSmqj9ihLXpztR4nGWYhMhpE0Ja4oWPFcPQ51vVVzsduYmJTqbqtI0sUkIkQbwEwBvAHAggFOEEAeGPK8XwBkA7tPuLgD4CoD/F7HsdwAYTnrMpH3QhYlapT/6JKwdujcCtrvi4i98Es/dfzdWXHf1pI3DcIQM3akQFClybhldMs6mUp2iVVBgUeMITpgnS2yyLBPrn3w8sowvjlCiyuiMgLOpXBjz/T504SlyPM77BUXDWmLTTT8/H8M7tuP2S39b8z3c8bjOpkqxSYkV6SqOrmqkNVeS6bq16ltWKkQw2bVpg/d4iBCWrlHy5QpsrrNJiU22s0k5ARVZTUhsGG2/qBx8+vj0z6Q/FsxYq7UNKLHJLqOrXA/K+ZTv7q58cRXc71Jb1tDO7TANAwPb4ncXJFMXJTJNVdE/aaLL6Cg2EULak7A5nAxxOwVR52gVZXRdqoyOzqZqNNPZdBSAlVLKVVLKEoDLAZwY8rxzAHwXtsAEAJBSjkgp79TvUwghegB8DkD8FFZCAuglV7XEptKo99yoK+7TjaHt29y/J3MnWiuzCUhosqxhlOtzsgXLmZSQWSE2TdIV9RV/uRp/+PqZuP7874U+7pXRVcls6vBKFYMix+iA12I+TmZTlDBTy9WiiHNioFBiZTqsjE5lNjXsbFIZU0bjWUHOMqRlhU6Cq5bR1XI2ZfyZTWNDjtjUERSbxu8MtLQSUcsVm3QBze9sihKb0iFlhTphZXS6QKTEqI6u+sSmoLNpy6qV+MXHTsPV3/06BrdSbJoOqKvXca5iTweiLi6wjI4Q0q5IyxOb6ok9cB35QWdTRwcgBMrFQttcyGiEZopNiwGs026vd+5zEUIcDmCJlLKeOp1zAPwAAGVE0jDlgnciVitnpjDimejiTKanA/pV0ckMFC2rzKbOKplNarJcTMbZZNRZNhncJlQZXTB3ZrIORE/c9g8AwMoH7g193A0Ir+Zs6nBKrQqFCjHI72yqJyDc/34ZZxIUdUVeEdddaJmm7bIRIvSkQolr9QpECreMyzQ9t1adziYhhCuy/eT0UzA6OOB/PGRsmUzMzKZsILNpJNzZNGP+bgDsbKJGnZvSJzZVOkiCYpMVUd6oBMBaZXT5rvDMpoadTQGh89l77wQArHn0IQxo+X6kdVEOTtk2ZXThxzE6mwgh7Yt3jlNPY5jgeZW+DDU/KY5Rlohi0gLChRApAOcB+Hwdr3kRgL2llDXreoQQHxZCrBBCrNi2bVutp5M2wzdBrtFlrqiLTW3SkU6/KjqZar1ZsnfwuRiZTSoceLzUm9FVKTbZ21ZwUjNZwbS1xBQ1wa7m8MnllaBXqPobiJPZFBYMDejlkDUcNjEFEbd7SDbnywVSpNyA8CScTc46rDOzCfCC0ktjo1h5/z2+hgVjTumbTi1nUzCnys1sinA2Ldx3P3TPnIXBbVuw9YXn6x4/4Hftqe3cV0a3eaNPyIrKP0jHLqPrDs1ZKqjHu8eX2ZRxcqwAryw2G1hvpLVQjsp2ufocJdqH5dcRQkg74HM21XG+5p4bhOw/VcwHc5uiaabYtAHAEu327s59il4ABwO4VQixGsDRAK5VIeERHAPgCOf5dwLYTwhxa9gTpZS/kFIeIaU8Yt68eQ1/CDI9MQJujGpX9NvS2VSM7/xq6jhCy+gaFCnivqdzkt7R2xfr+cH1o8r5KpxNk9SNrtbVmzgB4dmIgPAg8brRhWc26aV6irHhIax9/NGGHDeGG5Qd7jZSJxoNi03KYWQarjssnal/WfpvbaR/l287mb1wccXzGy2jU0JNttPfqS2VSmOfI48BADx3/92QloUVf70aD93wF4w5QeW18DmbzMoyunJhzO3SqD9WkdlUJagbsAU5AMh1dmlldPaypJTuhYF8w93o7G0zm8tXPKezt7euZZKphRJB20Vsiiqjy7CMjhDSpugxDMGOyNVQ5yxhuZzMbapNM8WmBwDsK4TYUwiRA3AygGvVg1LKASnlXCnlMinlMgD3AnirlHJF1AKllD+TUi5ynv9yAM9KKY9v4meYMpSLBWxe+SxGB/oneyjTgmC+T7WcGL+zqU3EJt3ZFNGGfCLwMpv0MrraIsV4UJ89r5cbhThjvDGGO5sqMpsmyRVnm0ijcTObqpbR6QHh0b+BWJlNEbXvKoRcdx1e/pUv4I/nfBHP3X93zeVWvI8bDh4+uRLjdDa5AoVhjsvZpLN97Wp3Hb7jzLOxYK99Kt/XWW9GxPbk2r0DAeGKfGelQ2fpwYfa779uDTY8/SRuu+TX+Odvf44bL/xRrHHrE/ioIGbd9WYGQswVXoZVlLPJ/o3nujorgtLLxQKkZSGTz1cstxaucOiMMUygbReRYrqiRNz26UZnH8eCZbNh+XWEENIO6Bcu6zlfC55X6aj5ySX//Wk8eN2fxznC6UnTxCYppQHgkwBuBPAUgCuklE8IIb4hhHhrrdc77qXzAJwmhFgf1smunbjp5z/GZV/6HJ7/1/2TPZRpQbDNd7VJsl7KEqdMaDpQ9rkQJq90UK3vas4m1bq93qylKFQZnRI/AABS+twbOmrbUSf1XkB40Nk0OZMckYoWygAts6lKQLgSbIxSuer2ECuzKcJJlQ1xqO3cuB4A8PwKr1lpXJeT4dbYh0+u3DK6BgWiVMbL+fEym8YnNm1bu9p18+1+4MGhz0lnop1NUsqK8O3ges51Vrp+Mo6TxzIMjI14+7tNzz0Ta9x+Z5PpLkvHCNmnVIbEp53Hw38rYc4mtR7c8PA6w8EBzS3mCKlhLkmKTa2Nu122SUC4+r31zJrjuz/oKCWEkLZB6mV0dWQ2RVwgA/zzk1sv/uU4Bjd9aaznc0yklNcDuD5w31cjnnt84PayGsteDbsMry2Yu2QPAMD2NasndyDThOBkotoEujjc3mV0lmlAShmae9NslDslpzmbgifLSnwyE5oMqpP0fY56GWYv2h3P3neXu/xMyMFJlWt19PSiNDbmlmgGJ9uTNVmtVUYnY5TRqcm4US6Ffw4hAClrhnsDjWU2+cThOjObojJK0gllNpmG4f49XmfTrs0b3c8XOW63jK5yXXvrNu1+78FStWyIs8n9LKbp+w5HB/oxOtCPrhkzq47b52xyM5v8+0p9uVZEN7paHQmV2JTv7NKcTUpsckro6sxr0sehu6SCUGxqbaw2CwhXF016Zs92RXtg8sq5CSFkspGNik1VzifDLuARP5MWEE7qY94eewKwr3xvXb0K13zvHN8JBKmPYAh0NRGp0IZldMH1M1kTrVBnU1S79IS+G7eMrqsLb/ncWW5YcNTy1cS5o9vOdFElmkEn02RdUa+Z2aTK6NLR1x6U88Usl0J/A31z5yGVTsOIeNz3fq7QEL8cUhc/JYDB7Vux4q9XV83pUg6hqG6KShiqFoxejXSos2mc12+cE6FUOh3puHIdYCFOvjCrd1T3Rh1d5DECWS/b1q6uOWxfQLhVGRAO+MWmyMymWgHhytnU1eUJoE4TgYIWHl4vQeEqWGZdbUykNYgq75yuRDmbohy6hBAy3dH3f3HP/aSU7gWwsHO8Rs452o2mOptIcsxdugyAfeJ/6VmfgbQsGKUS3vmlcyZ3YC1KOTChjZog66GzQBs5mwKuCcs0xj+RrhMppRYQrmU2BZ1NNUKF60VN4pXAkk5nYKAY6ZxS20RHT4/z+ilWRlcrsymGsymTUxP7kisWdfb2uQHSsxYuhlEqYXSgH2NDQ76OakFMM1zccjObwpxNugAiJa74+lkY2LoFz6+4DzPm74aXn3wqemb7J1XK+RPlEBp3GZ0r0HjfayPOpqNPOhmrH/kXTMPAttWrAIRbtRXeeqoU5YIldPY4vTGls9nQ37HKQbMMs8Kdtn3tauxxyIuqfobwMjr/9m7qYlM53JLuCXiVvxXLMm3RUQhk8x0VpW+qjC7fPZ4yOjqbpivtFxBu/96C+8V2+fyEEBLE52zSzo2qVW+4Zf/pTOhz6m1I0o7Q2dQi9M6Zi3x3NwpDg+6Jfbu4bJpBcDIRlcVklIo+EUNNkqY7Fc6vSchtskwDkBKpdMYVfoBKcaBWu/R6MdzMJvs93WyeiHWgl9EB3rblrjPn4CQnq4yuRvmjKzZVcUCl0hlACFim6W4bemnVzAUL0el076vVwSyqjM5z7ISITQXN2SQlBrZuAQCsf+pxPHHb3/GP31xY8RolAkYFhLtiU4M5S3oZnduNrgGX1LHveh/e+63z3PUHVG9P7gWpV3E2aa/XBZ0wVxPghYjbziZ/sHosZ5OvjM45PpnRZXTqsXqcTaWxMfczCCFcx5pZLmNg62Y3K6ExZ5M//yls3XKS3tookbtdAsLVttw1Y5bvfr0bEyGEtBWa2KRfJIuTRRp1Xpajs6kmFJtaBCEE5i3d03ffnMVLJ2k0rU9FmVjEjkYvoQPaR+ALhm1PxkRLlcdkclmfYBJM7EkFSmDGi3LReM6m6mKWOhCp1uhKGFHPV5P2yZrk1KpLVxke1SzF9uTe/hyqzK2zzxNHZu7miU2FmmJTuJNKZTaFlTCFCVA6I7t2Vtxn1DhBUOulUWeT7sJxu9GNI3xXb0leXWyyt8uwdeKWp2mv19dzsDNV8Dl2ZpO9/c7bcy8AQP/mTTXH7nM2RZbRhQWEh3ejC9sfl7QSOsBf+vbP3/7cHWdDmU2acAXAzV3TUdl1pDWREY676Ypb9hHYl7CMjhDSrkhtBqGfo1RrMBRV9q9gGV1tKDa1EPOW+cUm5QQg9aMmaqrkIqo8riJIvF3K6AKlNM0Q2caGh6q6JrwyqIAzJXCyXCvnpV5cZ4cz+de7joWPM9zZ5IpNznJaOSAc8LKPSqP2pL+rb6b72KyFi9zPX9PZFBEOrTKbwsrDdKEibMIfFnpd62pUarwB4Vr5ppvZNA6xKau596qW0an1FCo2hZXReX9HOZt095466erqm2EvMySIPIgupEaV0enu0eiAcE/0CqK2u7wTxullNpWwc4OXX6iLdnFJB37jFblhyp1IV0jL4mY2tYmzKarLKAPCCSHtirTCxaZyKfqCZthFPB19H6tXYRAPik0txEGveJXvNm39jaNEJDVBNiLElKADKup5041yKZ7zazz86pOn4+IvfBI71q8NfdwLePZPHoNiQ7CTVD2UiwXceOGPsOaxh733DZbR1WjHrg5EHY6jQoklauLqiU2THxAeJtSYqqythsMnnfM7m7pmzHAfm7lgkevsGhsaqrocM0LcqprZVPRnNgUJE1Gith+FGKfYpJeexcm9qoUKogeiQ80BINvhOJtC1lNYQLgu6GQjuqbogq0SW5WoE0dg1yewnoMkWEZX6WyK6kYX1jGsqMroHGFRidCmUcYcp1srAJScoPB6UOtLCWJ62SaguRvbxBUzHbHaLLNJRjR+aJfPTwghQfRzYP3cJnjM14m6OKZQeZFA+1S/1AvFphZiwV77+JTVKKcFqY0rNjkCQdSEKmitbBtnU8A1ESW0jAdVFrP5+efCx6CV0ekE3QXpGplK1Xjg2j/h8VtuxpXf/LJ7X7CMrlY7dpXj5TmbAmV0uckto/OHN1d+htjOJiU2Od+b+rwAMGP+Aq+Mbri62BSV2ZSrltkUuK/itQ04m5RYVE/7W/8YPAHCE5saD9HXr4jFymyqIjbpHej0TKqoMrqwzCZVjmbE+F3peWRKTIzTja6is6SWgxXELaNzRDA9s0nfPl7y5rfXHG8Qtb6tQEB4tqMTr/7Pj7vCZLu4YqYjSuyfrOy8iSZKAGcZHSGkHZBSYqR/V+A+7XxYE4aCXXh1jJCLeDp7HX6kt3zLoqAfAsWmFuP9/3OB+zevsjaGlNIVFNSEKkqoCDp82kZsqnA2Ne9zByeciqgyuqA7Zzzd6HZt2lhxn5oUK2dTzcymiIBwtU0pZ81kTXJ8demlypIo5UqpJbqoz1F0yplmLliIGfMXYNH+ByKTy6HDDQgfqLoctd8KBnOr8rBSoYAnb/8n/njOF71x+0Rf6QpTilyIY8cLCA8/QRCO9Tlq+6uFXl7pCWjjKKPL1yc2PXvfXfjlJ0/H9nVr3Mdcx5Avs0kro4tyNmUqM5tUiXGc336osymwvevbXtSVQhEnINx1Nmlik+O2O/kb38OcxUtqjjdIZUC4/Rv+wPcuwGGveaMmxvGY26p4ZXTtIba4DtLAfp1iEyGkHfj7r36CCz9yKlY//KB3pzN9kFL6y+icc8ywZlG1LlzO2X0pPvzTi9wqgnaZJ9YDxaYWY/aixXjtRz4NwCt/IfVhlIqAlMhkc+4EL6o8biKyi6Yi5eDnbuIkK8qa6nXFqh5wGsxbqYeKbBZ4wkZFZlOEmOVlNqkyOkdscsapljNZv1erltjkfLe1wq3VgVY5TLL5PD74vxfi5LO/AwBaN7p4zqZ0VDe6whgev+VmrH380dDXS0tWZDSFOXaMqMwvB1U2ON6AcL0b3bjK6PSA8CqZTbrQNrhtC2656OfubbV/ykSU0UVmNqW9bbyRMjpdSPUCwgNldFr2U9TJW7qKizDobFKfyzAM9zcXFCHj4uY/Gf5udGqbrCaCkdYgSgSdrkQ5VttFbCOEtDeP/v0GAMADf73avU85m4LnGEaxiFUPPYAff+CdeOK2f/geq1VGB9gd49V56PCuHW1znIkLxaYWJOlA5HZDTUwyHR1eR6PIMro2DQh3Jlv6JDRJdHdSVOlRlFhQ4WxKjyOzKVCKNLh9q1sGlglmNtXoRlcZEK4ym+zlyEnKbKrpbHLDras7fNxudI6zKZXOIJ3JuldzvMymxrrReWJTocJRGCQomoS5smoGhDsnDg0HhLv74WScTfWW0SlUuSmgd3kLDwhX31EQX2ZTuf4yOstXqhmnjE6dvAW60WW80sSR/l1Y9+Rj7mNKbHIDwpWIWy55ZW/5BsWmgKCsnFJqm6zlbiRTH7X/bpdSSEvLbJqtuf3apYyQEEIAfwyDCggPnp+US0X849c/g2WauOGn/+t7zDCql9Ep1Dnybz7zEfzh7DPHPe7pBMWmFqSW04JUx5uY5CtaXlc8t83L6PJOm/GkXTlxhCEz0BVOERUQ3sjvQZXmAMCO9Wvxy0/8BwojwwCAbM6eaFbLbJJSugciLyDc3r5UztVkd6MzfXXpYWV08ZxNKjtLucGCV3k6epzMploB4SGCCODPbAobp0JCVnTiDFu3tQLClx50KJYddjgOeuWrQh+vRUorrUoiIDyrbefVA8IDgorTKQ0IF9gKw574t/y4fwtdpu4ObKyMLszZFEdsCg8ItywTF33uY7ji62dh3RO2w02Vb+acfVJGu1BQKqiMpcbEJv27NA3DXo9CuNuO0IRF0pq0m7NJ3ye948yzsXC/A+z76WwihLQRhnZRWTmbgnO5crHgXsgKEsfZBPjPuzY++1RDY52uUGxqQXiVdXx4JRednrMpQqioCAhvszK6fJeacFaunzWPPtzwDlVvbx81mTUinCnBMrpazqO443hBr+uGJxKlNbdFEMs0ASkhUil3XXkB4YFudJN0Rd2sEYLolVvUyGxynDfuJCZw4PXK6MKdTc/ccyceuPZPkcJMOpNFKp2BZZquiyUMaUlkA+1lwyZQnvASfoLQPXMWTvriN7Dni4+IfK9q6GHWSXejq8fZJHSxKaSMrnfOPAC2GDpv6bLQZeph5+5vv9PenuOV0enOJr9NXW03Yd3ogq5GbxyGK/que/JxAFoZXUdYZlPB91i9CCHcE8miEpvzHe669Y65nKi3Kmr/2y7OHneflEphxvwFeNUHPwqAmU2EkPZCj8uQllWR1wTYc73OPq/DcljXumrnZfbj4Rc2CdB46xwyaXhlQ+0hfCRNWWtt7+WuxMtsCguPm44okc1zN/h3zMXREVz5LbuD2+f/8Ne6l6/bWiOFvghnSqWzSXWSqv+70Q9Cenc1wDuwVHM2mdoYM7kchEjBKBV9AkRQpJloapfRqYDweJlN7u0KsckpoxuuFJuklPjrD+1sp4X77G+/PqRsL9fRgcLIMEYHo0PGLcuESAnffWETKMMNCG/OCYDuMDUjOuzVg6+MropdWxelgKDYVOkaO+w1b0Qmm8XyV5wQuUz3mOLrRtftLlNK6XsfnbHhIf/JnHKQOGPJdXbCKBV9+07LtaWHi026cKyuRFZmNtnrqFwqukJW0AVZD+lsFqYmcumB7Sk6m1oeyy2jaw+xJZjFp8qdZZuUERJCCAAUx/zZrJZphjibiu4+EgBG+nehZ9ZsAFoZXQ2xKdNgs5l2gGumBXFzLdrkCl3SqIlRNt9Ru4zOEV1ynZ0ojY21jcDnik0RZXSF4eFxLV/PSooSmyK7icmAs0kJhg05m7xxBAU1NblOaQ6WIHqHLJFKoXvmTAzv2omRXTs1sWlyy+hqBoRb8Vw5QdEmKIgocaI4MlIhTgzv3KGNwckDy1S+X6ajAxgZrnAU+sZrGLE6LEV1M0wKfbvLJFJGF8/ZVM29E3YFLt/VhcPfeGLV91bjlpblrvtsvgOpdNopEzRCBbDi6Ch+evopvvuCZXT5ri6MDvSHOpsiy+i0/Y3KWHB/a84+SX1GlbGWzXf4Thbrxf58Y97ytJI8keIxt9Wx2rSMTon6ap/ZLmIbIYQAQGl0xHfbMoyQMv+i62oGgF0b17tik1tGV+NiYkUVRpWLdO0Gy+hakHTacXLwKmtDuN20Ojtrik1efklP1edNJ6Rlua6ibIc9sQuWkI23JKzkK6OLcDY5wkg6mNlkBZxNWulN3ePQrngUAwckRTVnUzHgtuiZMxcAMLhjmyeWOeOfrPIFfZvVO4IpLLekqZazyf89BJ+fSqW9rl6B99mxfq37t8pBC3MB5WIEPFuaa8y9L2R7jBQrE0LvnGYmUUYXM7MpeEJT1EoOXbGpzitsQgh37Oq3mcnlajZQ2LF+TcV93qReOZtsEdKf2WQvL5UJuuUqy9WUE0ONS2V7ZVyxyXEiNZjX5L13xrc8fVtk6Xrro0SWdvkOg1l8rmBKsYkQ0kYE9/mmaVRUQhRGhn0X0Xdu3OA9v8EyunKgwVQ7Q7GpBVGOADMkQ4bUZnSgHwDQPWNmzcwm5WzqcMWm6S/wueVrOS1APbBj1sWnYFlbHPzOpvCJrBmzjC6VCR9jzTGUim6JDuAFEAep5pwqu84mW2zqdcSmLc+vRLlYQK6zyy3Pm7JldGpSUqOMTgWEK8IEjaybzxMUm9Z5Y3A7HVa+XzZG5o5pmhXCXbUyulonCI2i5xxFtRmvB39mU7QbK3ilTL8a5zqGGvjMSvxT3QZtsal6p0e9E54i2I0u32V/p2a5MiA8KKq5E2Ltt6wmx97+wF5PFc6m8YpNgeVldGcTxaaWxy3vbJMysmAWH8voCCHtRJTTWTUC0RkbHHBL6AGgf8sm9++4MQnB865SoHyvnaHY1IJUc1oQj6hSr5H+XQDsgODamU0BsakNyuiUwJbRMq2Ckyy9JKaRCVi8zCa/M2jJgYcAAPZ96ct8z0s3WFY6NjgYuB2eE1St253nbLIn1CqM+YWHVwAA5i7ZwxMlJi0gXBebKsvT3Mymmt3o/FlBQVeK/Rz7uwqWwe3YoDmbnMeiMptqYRlGxdX50IBw5Yxrltik7TuSdjbVM+biyAgKw8N46o5bXHderRa9Yaixq9+mT2yOcDaZYU65QBmdEmJ1AdIKyZayx+2EdGsnaUqYLge6UwbXURxXXDXU9jw25JXlueNKh+8HSeugvrt2CQh390mOgKuXyhJCyHQn2ExFYZfR+c9pRvp3+cQm/YK4aoASFv2gE7x4RrHJg5lNLQgt/bV57r67ce1538bR73g3jn33qb7HlNjUNXOWOwGKLqNTYbntU0anh+1G5RX5Jo6mUXfZTilGZpNbRue4PN7231/F5pXPYfcDD/I9L1XDfRFFsGvaiON4C5Kq8ntzS3sCzqY1jz4EwBGbJiHvxbJMbHl+JebvuZdPlK6e2VSjG12NgHDAc+cERS3d2aTEjLADdxx3imka8ZxNqjNbkzKbdCE2CWdTNmZAeJDi6Aj+/P1vYv1Tjzf0ekVQ+MnkcpHORkVYWaY6MVPuR9Wl0V9GF5XZ5AhehcryVrPkF5+DnzGOK64aKtxzwzNPAABmzF/gPiYYEN7yqO+uXToKuvukTCCzqU0+PyGkvcnm86GdjU3D8EUOmIaB/s0bAa1qIuyCer1NdKp1VW436GxqQVJVnBbE5s4/XAIAuPeqP1Q8NtLfDwDomTlbK6OrHhDudWZqB7HJyWvK5SPLaPxiUyPB3LUzm7yyGfs7ynV0YunBh1bs8L1udHWKTQEn0+hgv/v3ov0P9JZfxUmoSo6CzibFHN3ZNIFi0wN//hN+9+XP4+Zf/sR3f5jY5AkltSzCwYDwELHJEUzKmrOpXChg25oX3NtWlfeLuhKlYxmVYlPYum12ZlPKl9mUbDe6esesC00AkM7WP460JpSJVArpTCZGGV1Yd0PlbLLXv+ds0gPCo7rRVY5bnbAZZb9TLdh5LqkyuufuuxsAsNfhR3mPub9hTtRbFfXdSWm1hbsnOEFiGR0hpJ2ICue2TC8gXOWs7tq00fcc/Ry20SY6dDZ5UGxqQcLaQxM/1UShUc3ZlHGv3EdNpvxldEYbOJuUfTSTz0eWbBrlcZbRxXE2BcrooqjWLa4ag9u3+W6PDdji02s+9Em888vneMuvkpEWbMeunE2KuUuWauULE/d7ffjm6wEAT9z6d9/9oQHhMV05QQEk6IQBwjObnrnnDp+46L5+HJlNaswvefPbAUR1o5uYzCYzIWeTL7NpnC10G3Fz6UKPEr5qBYTrv2OFOjGz3MwmR2zSlmG6ZXSBbSrEXaey1Ay3jM4/NkUcobIa+ljS2Sz2OPgw9zadTa2NtCxfPl875DYFHauC3egIIW1E1JxAz2zqnT039DmhzqYa7v8KZ1PIeW+7UlNsEkJ0CyFSzt/7CSHeKoRoztk7iQUzm2pjhlxxV4wMeJlNbglW1GSqIiB8+otNo47jp6tvRhOdTfEDwmu1ro/KlaqFHgAIeM6mecv29JU0Vfu9qSsXeeVsmhsUm/ZwQ48nMtC/09leg1Qto6tlEc7FcTY5mU3agfrRf94YvryQ18fNbFITR/X8sAmUEXP7aRQ9nyrxzKYaAmstlPhZD3pZYzAXKWq/F2YTd51Nbje6EGdTRNe8UGeTKqMLOB2Dr42z7VQjo7nBFh9wkM8plZ7k3DUyPioy3trgQl3wIoKXHUixiRAy/Ynazz/69xvc8vyOnl6/SOS4oXzOJjNeE53gBTCW0XnEcTbdDqBDCLEYwE0ATgVwUTMHRarTaCByO2FEKNpSSozs2gnA6UZXYzKlJkj5nvYJCHczrWbMjCzZDMtfqYeSFhAeVf6mOl3VKilSE9R6v5v+gG22FOgs5y2/SmZTwNnUPXOW67x48evfYq/DSXA2qQ54QaoHhNfKbPILIGHOJi+zyds+dqyzw8EX7LWP//UNOpv0gHB1cA91NjU5IFw5doqjI64QOa7MpnxjmU3VxlYPfmeT/V3XykMLu3Knfiees6kys8mqkdmkUwyW0TljE6mUb8zjzWzSnU29s+f4HnOdTewA25IERcJ2KIcMTpBYRkcIaSeizlv+9bdrccfv/w+AfX7Y1TfTfUw5nfQmN+r8snYTHQaERxHHqy+klKNCiNMB/FRK+T9CiIebPC5SBddpwcymSKLEo+LICEzDQK6zE9mODmRqZDYZ7ehscoKy/d36gmKTviMeX2ZTdBmdf3IZhd5lR1pWZLvTILs222KTSKV8YkU+IDZV60bnBYTbE91UKo23fO5MlAsF7Hf0y53xqWDWqSA2RWc2iZoH0trOpmxIZpOa6OUCYkB4ZlO+4r4gekC4EkPCA8Lt76t5AeFZZPJ5GMUiiiP2VbLxZDbpr03V2IY7enpRGB6KfFwJPPWgZzYpwbTW/jHsyp36LrxudPb3HlZGFxTVhBBIpdO+34q6AmkEutEB9omiEvrGndmkjSW4/tyQf07UW5JgB7p2+B7VbygdCAhvh7wqQgipdgF6eMd2APbF7K4ZMzC0w47V6JkzB0M7tkWU0dHZ1ChxZmVCCHEMgPcCuM65r/HLt2TcNJpR005EiULKtdM9cxYArUwkYl2WS4GA8DYQm3RnU1TLb7+zqb4T9xcefhAP33idezuqHNQtm6nh8rAnqI4oFlPQkVKif7NdRjd3yR6+x3Jd4c6msGV7AeHea/Z68ZHY/5jj3HBCrwxv4k7yo9w85WJlxo4bbl3DIqyLNkKkQp8fVkanJnqZgJAUNsY47hRpWZozxgmHD5k8uttPrnlV3x2OKKE6G9Zyh1VDD7OsVerynm9+H8e+633Y/5jjQh9vqIwuxNlUu4wu2tnkik1dIWV0Ec4moHI7LI2OQVqWF/iu7Q901+N4M5v0saj9vTumBkt1ydQguO8Nik/TEbUPURdfPMGUYhMhZHpjWWYsYT2VyaCrb4Z7u2/ufADe3E8tC4jTjc5/YTMsq7RdiXNmfAaAswBcLaV8QgixF4BbmjssUo1aJ77SsrBl1cq2KPmKIkrA8IQUW2wKZjbt2rTBVxpS4Wxqg3WqC3JeGY3/c/szm+oTPa8692u+21FCXz0Bz577KN73M7xrB4xSEZ29fa7wCNgiSnDSqmc2SSlxy//9Eo84AdzFMb+zKYzUJOS9hDmYAKAcEAeklJ5LqIabJq2JNlEB1l4ZnX5VyF5+hTMq5HuNm7tjBDJ/qgaEj7MkrRr5QDbWeJxNPrQWvGHMWrgYR590sttJpWJcjZTRhWQ21SyjCxObVEB4RWZTCdL5XOp3GlaKqY8DsLuHjTkurnQ263Mu6tvQeDOb9GXluwLfa2ri3YkkOYLHqHb4HpUgr44/bhldG3x2Qkh7E7fkPZ3J+M75Dzzu3wD4y+hiO5sC57RFOptc4ohNC6SUb5VSfhcApJSrANzR3GGRarilTRGT/Idvvh6XnvUZ3PDTH07gqKYmwUmxahE+c7eFAOAq2sO7dmLH+nX4zWc+gov/61Pu8z1nU/uV0XXNmBkZvh1mMY1DOSQzKFJsMuKLBd5vIt5YVF7TzIWLfFcjcl2dFe1SdSfhjnVr8K/r/4y//+qnAIBywXE2dURP7idjohqWzQRUHvyUSCNEqmb5oe5sChMJAK/8SpXR6V2gguVsoWV4Ic6msDI4I5DHVDUgfJxh29WoKLcaR2aTTlz3QUdEuVyugTI6X/6Rs85qltFVyWxSv+tsLm+vFylhGgbu+N1F2LZ2NYDw33aYYKc6iFZsQ7qzKckyuoCzqdEmBGRqEPze2qKMLtCum93oCCHtQtyL4OlM1ndevGi/5QACziY3/66+XFNmNnnEEZvOinkfmSC8zKbwE6aHb/grAODpu26bsDFNVfTJiLQsPHHbPwAAy489HgAwa+EiAED/5k144eEVAICBLZvt50vpTmo7e/sAhIsl0w2fsymiZLPcYDe6gc2bKu6Lyh6rVmoTRA8yH9y+FTde+CPs2LAu8vmjg3bZU8/M2b5SnLDyI2+iafiyiACgOOo4m7pqO5sm8opylLNJlf0p4rZ0BfwW4SixKRsICLe0YMWgiBAmNGQ7KjObsiGuMVdIquZsKlWWXSVNRblVQmKT3qa96vv3hHcdTCqzaTxldK6zIpPxyh1NA/f/+UrvPcOcTSHrcMQRwINXDvVtqHuWP9S7XqqV0amQZXaAbU3aMSBcuvt2ZjYRQtqLuDEz6UwGL/v392L24iV419fO9dz5voDwxpxNwUqCdiZyFieEeAOANwJYLIQ4X3uoDwDPuCYRtw2zU9YTdGKoiRjxT0Y2Pvs0BrdtQe/ceVh68KEA7JyP3rnzMLR9G/o3+7uTmeUyICXSmYwbblwuTH+xyQ0InzHTN0nUabSMbuemDRX3Rbkm6imjU+LHc/ffg8dvuQlbVq3E2scfwYcu+E34sg1v2b5JZsgkPaV1opKB8iYvIDza2STqLKOzLBOFoSF0zZgZ6/k65VIRz9x9h/sdKlSgtApb1t9LH2M1fMHMUc6mrD+zSa91D5ZHhR24c/lKYSnf2YWxwQH/nc734DqbAkKelBKGEX/7aZRmOZuCYepRhDqbhGiopEwXEJXDrHYZXVhAuONs0gKKUxHd3MLL6EKcTc72rEQwhX4lsW/uvNAxxkXfToLr1esAy4l6KxL83trBoRbsMipSKbutt1M6HbeRBiGEtBpxxaZUJotF+x2AD573MwBw5tQpmIYByzSdhiXxutGls/5zF5bReVSzDGwEsALAWwE8qN0/BOCzzRwUqY5IpSBEClI63bcCP4AoV0M7ok8gdm5aDwBYcuAhvhOt2Yt2x9D2bdi+bo3vtcrFlMnn3awQyzRgGkYst00rYpTLKAwPQaRS6Ojt1SaJ3o57xV+uwhO3/d29HffE3TQMbF75LABb/Mh1dmJw29ZkMpuccf7j1z917xvctrXKWLwSPf0AESYa+TKbtKvClmW6k+2qmU2uKyLeerrmu9/ACw8/iPd950dYsOfesV6juPKbX8HGZ56suL+ztw+F4aEKccDtWBQja0if2Adbw7vPCWQ2uWV6AWdTOputEMmB8FKoakJelLPJMg1ASsdR1bx+FpVi0/j2C2/89Bew6sH7ccCxr4j3/iHOpmy+o6GJpL6eVIZBppazKbSMzv4uLMPL1VLHqHLJC6hftN9y9MyaXTmOkBBOJTZmgs4m7bfbN29+6Bjj4nc2+dcrnU2tTYUYPc3L6PTyZSG8fUEqlYJlmrAsE2mKTYSQaUrcbu3BcwohBDL5PMqFMRilInKdXV4FQI2A8IrmJgwId4k8M5ZSPgLgESHE75znLZVSPjNhIyNVSWXSMMsWTNOomEwFS33aGV2oGHNKpzq1zgMAMHvx7ljz6EPYtma1e5+0LNdGmc3lIYRANt+B0tgoysUC0pnw8pVWR89rSqXSXhaSs+Me3rkDt13qdwvFFlG+dw5WP2zr1i8/+VTMXrQ7rvjGFxMqo6vPvWJpy9ZFFFUu6V+2JxbprkGzXHbLiPJVBBEvIDyeK+IFZx09c/ftdYlNo4MDoUITYG/zuzZtQDGijC6Os6l3zhzku7uR6+zCaz/y6dDnqDI6tQ/yDtIp3/cY9Z2GZTZVE/LcbomBdTsR4eBAWBnd+CZwy499JZYf+8r4799VuR8KE/Hi4MtscsoZ07UymyLK6O7+4+8wsHWLu1wlBqsyznx3N04553uhy0xnKrdFtd0G87fKBU+86uge3z7ZHxAe5Wya3iLFdCUoLk3371HPa9L3ByKVAkwTlmWxpTQhZNoSt5lT2MXsTC6HcmEM5aIjNsUsowtWLwRjK9qZOGfGrwfwMIAbAEAI8SIhxLXNHBSpTbXcpqhw4OnMjg3rcNV3zsaWF5733a9PNlV78q6g2LRoCQB/SUipUMCO9WsBeFe5letCn+BMN0bdbn0zAfizkIBwwSTuFQQlNAHArIW7uwJRIgHhdbpXdNeUPoHtCXHspLVx6r+tcrHotjat1na9XmdTXHasX4u//+onbsbWU3fcGvnczt5eQAiUiwXfATFuJzrAdhh96ILf4j/P/xXm7bFn6HNUmZOb2aSJWfqBOkocDM1sqlISpk4UgpNJt1tdE8PBgYAoIUTNK19JEyawNCo26b8hVcbnZjZF/EbDMgkGtm7GPVf+zluu5mwqjNhlnFV/L5ropRxaqvwz2NFQbftJUC0gXDTpN0wmhoqA8Gn+PVqBvCaFYG4TIaQNiLuP7+jprbivInvUPY+tfp4sA+XaxZHhWGNoB+KITWcDOApAPwBIKR8GED7TIBOGntsURO8w1S785bxz8cJDK/DHc77oy9UJdTYF3CuzFy2uWF6pMIqHbvgLAOAAx2nguTamr9g0tGsHAK9Mys1scbazsJPUuI4dN29FCMzfcy+fa+rZ++7Cded/z1cCamoBw7WI8xwdfdm6jTa0rCetOZu08anSnlxnZ9WyJeV2qRYQbpRKGA3mEtXgqu+cjUdu/htu+On/AgBG+ndWfb4SEEqjnkAQt6WrIt/VVfW5rthU9JfRBZ1NmYjvKyyrqJqzzcts8m+D6nuKep+k0MWeiRaaAKAjLCC8Ma3Jn9nkiEHubzSkjM40jNB8wHVPPlaxXLVuiqP2yVeYg81drvZeal/tik2Bbi/qAkIS6L/hoFNR3weQ1qPdutEF85oU6ndIsYkQMp2Jm9nU2VspNnkXTZ3z2JhldMHjjLq4RuKJTWUpZXAWJEOfSSYM13FS5eQ3eBV4OqPyeYojI7j2B99279ev8o8N2ZtxUGzqm7egYnnb167Bqn89gEw2h0Nf/XoA3gRpOjubhndsB+A5fNwyJeVsChE3zbg5Jo4I+Ilf/R4d3T1elzejjL+cdy6evus2PPqPG73lOpPOYE11GGGCRDUBSB2IMtmsr8taqLNJy2zSS1RVyWG1TCHAK1Ezq/xW/3TuV/GzD70XQ876t19YXTVQ27ya3FdrDDC8cwdyXfY4dQef+j6TyjVS+xw1Fl3MiuVsCnG8VDvAqyv3wcmT64prtrNJc8AEA9AngrBA+0YvMvgzm2qX0UXlEQSFqXQ645ahFV1nU6WDTdE5w3Oezl2yh/26CGeT+5qAW7UR9HEH9x1ebtv0FimmKxViU0Qn3+mC3phBRzlYuR0TQqYzYecsMxbs5poHFB3d0c4mNw7CihcQrl/ESKXTMEpF12Xf7sQ5K31CCPEeAGkhxL5CiB8DuLvJ4yI1iGpJr5OpckI/3dDdTCsfuMe7XzupUlfBgxOTMIHh6TtvBQDsdfiRbtmdmghPa7Fpp3I2zQVQ2Y0q7CQ1zom7lNIVIPKO6KEmcPo2rDsV3MymON3oQoKZq4VeqwNRKu3PbArbFnyZTZqzSTmRanUOc68mR5zglwsFrH/ycQB2x0RFLYOKEj/VJNksRR/UBrdvc90aV3zjLFegiht8GJfIzKaQgPAwUul0hXsl0rUmhLsfDJbRmcrZlJ24Mro4IetJk8nlKj9jAplNGeVsqlJGV44ZfpnKZNwyNCU2VfvNHPuu9+HIE9+JD//0IsxcsND3uqjvs3vmrFhjqUa18nPlEOEkvTVpO2eT83sNZvGxjI4Q0g6EnbPMW7oMr//4Z3z3hZXRBR36cSsA9j/mOADA8pcf78avsJTOJo7Y9CkABwEoAvg9gEEAn2nimEgMUgHHiUI/iWj2RGtKIcPNdnqJV1QZXSabrZisPH33HQCAPQ8/0r2vLcroHLGpZ44tNqUD5SNhO/A4J+5KaFJd/QCtREdzRumigSsIxSiFCnU2VTkw6OHjmZwnfIR1WdNFMUP77l1nU1d1Z5MXEB6+ntY/9bj33Do6BAVL/oJXcjK5vOtyGRsccMc5sHULrvj6WfaYTK9bXBK4zib3ipAnZukH6mqlcZlARlPUAT6VSrvbUkVAuPv9TlxA+G777NfU94ozBmAcmU2aMyvXUbuMrlyIlw2ou9qUQ6mas2mPQ16EV7znNPTOmeuKXW5AeECkfO1HPo18dzde/7HPxBpLNap1cXWPt9NcpJiuBL+36S4aqs8bzDKM2l8SQsh0IixLVqRSdgdq7fwzrIzOneuVgo1uqp8nd8+chTMuvRpv+OTn3YiFwjDFJiCG2CSlHJVSfklKeSSAlwL4rpRy+s62WwQ1MQiWMOndptqpTbNq8xvEJza5zqbKjmO9jrjivs5Zd3u+6CXufepq/HQWm4JldKlAGU1oZlOM2mg3Q0crgwm6pgBvpy6l1DqKNZbZZJZLPseb/zEtIFwTJEKdTRGZTa7YVMvZ5Lx+y6qVePim6yseX/3oQ+7fajIOoKZDpXuWXyANTpYzuRwOf+NbAAD7HXNcaMc8TwxKJt8tWOuuB4Tr67maCJSrEJvCv/9UKuWFr1vhmU3pXJPFJq0b3IHH/VtT3ytyDIGQ8GS60QWdTSFiU5X9YNeMmTj2Xe/Dse8+FUJzoLliU43fjEK9f2lMldH5RapDTngtPvHry7Fgr31iLa8a1bq4uvuAmDkQZGoRFJeq5edNB2TERQTPCUqxiRAyfVHHav28Rp0v6lU/wfMnIMTZZMXv2pzJZiGE8MQmOpsAACJqMuY+QYjfAfgoABPAAwD6APxIShnet3gKcsQRR8gVK1ZM9jDGxVMHLPfdvn2/JRjuzOHlz6xDX0GbAOcyuHW5nXORMUy89onVEznMSeNvh+wFmaqcZHUVSzj+6XWwANxw2N4QUuL1j66qKFH61x4LsHmmf6fTO1bEcc+ud28/smQ+NszuxaFrt2L3XUNN+BSTz60HLMFoPodXPL0WPcUy+jvzuHu/3dE3WsDLn9uAXV153LPv7r7XHLJuK5bsrL4+Cpk0/nnQMuTLBl715BoAQDGTxj8OWoZc2UApax8Q9tzaj+Wbdvi+rzc8uqrmuFcs2w1bZ1Tm17zu0VVIh+zjHl88F2vnzsCB67dBAHhi93kAgDc88nzFtrGzuwP37rMYs4bHMHukgOcX2CLPkh0DWDdnBhb0D+Mla7ZEjm0on8UdByx1b7/iqbXo0Ure7t5nMfq77cn98g3b8dRiW/jce8su7L85OvT7wWULsGVGj/s5H95jvnsbADpKBl759Bps7evG3KFRPL5kPjZp2/gbH3keA5053LXfkoptvVFGclnctnyp+7sb6sjhjv2XoGeshKU7BvCks55njYzhmJUbQ5eh9m2KpdsHsHZuZSZP2rRw7LPrcbv2fortPZ24f+9FmD08hqOfD3+fJCilU/j7wXa/jNc+tgoZa+LjDO/ZZxF2dXviTc9YEa9o4Lt8auEcvDB/JgDgqOc3Yu7wGNbN6sVjS+dj8c5BHLZum+/56ncRRvD7uGufxRjo7nB/M2HLC+OZ3Wbj+QWzkCubKGXT2GP7AA7asL3m6xrhufmz8NxC2y34xkf8XU1fmDsDTy2ei2Xb+nHgxh1NeX/SPLb1duKBvRa5t49YtQnzh6ZvW+qRXAa3Ld8DXcUyjn96rXv/P5cvRSGXxfFPrkFXmcIpIWR6sqWvCw/uuRBZw0TZMWcs2jWEF63dipsOXgbDEY6Cx3oAeHjpfGyc1YvD1mzB4v5hPLDnbtjW113XceOBPRdiW19X7Ncsf/qpOj7d1EUI8aCU8ojg/XFCJg6UUg4KId4L4G8AzgTwIICWEZumIykno10GZsYlTXm1QsSXaUvER5XOA2pnkzXM0KfmQnKHugIZOGnnaqAxTderBFBwRJ8O50Q0JdV2Jnz/+19Xe32YzjpLa5NxtWxLW6bantW2m4o5ebci3BxGOoV0yHerPkdKSpS08qGwpQhtHZjad69eV0tgCC7TCHQI0m/rY4n6TAp9vY9lM7ACwdApKZGWwMIBxxWidWzLOd+vWkaqxkWHuKQch6Eai1qqgPS9R6rKhfVM4Kq7iBibgIRQ+8HAWlbrLt1k8SdnWnjx6s3IGeakCE2A973OHh6DJQQOWV9bxAlDaH0/1HcQ9htVGFXccJlAd0B1vFIneHHXlfr9q99I3P1BI+y5vR9GOoWF/ZVXIkWV9UCmPsH9Q/C8abqhjm/BfaeQ6vGJHhEhhEwc6lidMS13/qf2f7WO4+q8UZ3vWxH702pkHPdsOZ1M1UCrE0dsygohsgDeBuACKWVZCDE5Z9VtTFD1/NcXP4vB55/DHldcgYX77u/ev/rRh4BvfQUAYKVSOOCpJxsuq2gl/nbyW4GQUrr0ooVYfs2N2LZ2NfCFT6J3z72w/KobKp637bLfYu21f/Ldt+jkU7D8tI+4t7dc8mus/evVmPNfX8DyE9+Z+GeYbMaGh2CdfgpynV045MknAQA71q/DnZ//GLJ7743l196MtY8/gnvP+ZLvdfO/+mUsf/1bqi5brf/OvffG8mvsjnPlQgE3f+CdQHcX4NhVZ7znPVj+nx/H2PAQbjr9FGT7+mIp/o987b+Ap5+suH+Pv9+EWbstqrh/9QU/AO64Bbufey4sy8SzF54PIPzqwubnn8M9X/wscgcdhL699wX+YW8/6SOPBJ59CvNOOQXL/+OjkWPr37wJt5/xIff2Xn+60lf2c+cnTwe22c6ozpPfDdxyk70uTn1f1eU+ee7XgIcfBADMv/RivHD1HwCt7Xx60SJ3XQPApot+jnV/+4u97H33w/KrbsDGZ5/C3V/5AroOOwzL//L3yPeKy9jwEG45/RRg1kwsf/oGbFm1Enee9Rl0HXQQFr/2TXj8wh8BAHpffiyWX/+N0GWsvfBHGLj1H25p7MKPfARrrvpDxfMyfTOw798vwm2fOh2ZxfZnHRsaxFN33orZHR3AhedjxqtOwPL/9+Vxf65qLK/9lKbywo+/j2133oqDP/JxHPnWkxpezs4/XIJVznre989/xtwleyB975145H+/g57Xvw7LP/dF3/PT990FnHdu6LJmHnUUlv/F6wr66NfPxK4nH0fuFccBjz6E+aefjuXvOa3mmIb+fCWe+91Frvi84KMfwfJ3n9rgJ6zNIRH3l27+G5781U8w493vwvIPf6pp70+aQ+aBe4Dvf8u9vejH52O/lx47iSNqLtvXrsbtX/gkOvbZB8v/fJN7/91nfAhjmzdhrxtuwOxF4a5EQghpee66DQ+d/z307Lcfxta8AACYddI7sPyjZ+D6d7/ZfVroOf9Fv8C6v12LuV/6Epa/6UQ89vWzsOPJx7Dsot9i6cGHxXr7Db/+GTbddB1mf+2rWP6G6vOjdiCO2PRzAKsBPALgdiHEHrBDwskk4oYWBzObAvWhpmHEah3f6kiE658qmyAqHFyR7ahsud43d77vtsqSqZbtoXPTz8/HjvXr8O6vfyexbl/NROU16flVqUA2WGg3OrN2/oPK8NEzV1TOkt7NTtVGq0ylOOHgQHRYcWk03L6qcqJSmQwOeOkrMbR9O/bSwuB1vMwmw9exanSwH4DXXS+KYMB1MFvJt8yBXd4Yy9GBxYA/P2Zw+1YYgVydYCiuL6hQOTVidtmIixsQ7nxGPVhR/y6rdRh8zYc+iZef/H6sfexhPPrPG/GSN70d94aITUILnlYZLNf/+PtY/ci/vPdpckD4VGDGgt0AVObO1YsvsynYjS40IDw6synX6S9pVfs/9XvM5Sv3t2EEj13pSWp64XakjNF5k0w9ghlN0z8gPLxVt9sZlZlNZIK5/bLfomvGTBzx5rdP9lBIG6DOj3NaVqkIuLGDtxXeeWxlo5u4dLAbnY+aMzkp5fkAztfuWiOEmJwkVOISdfJbGPZn55jlUluITZHd6JyTyrEhu019lNi0xyEvxt1XXOa7r2+eX2xSE7C4Lb8f+6d9RXHnhvWYu2SPWK+ZTFSAelefl4+TDghC4WJTgwHhmojjLcsvNlUTJXSiwopLEd+V3o0uncngZf/+nshle13zTLc7BQCMDtjbVK2wYxEsm6siNo3090c+L4guJu1YvwZmoOwzGGasAs31ZSuhMCkxVHXANJxwdjcgPJXyd6OLCP0G7O2ie+YsLD/u37C8Suh2KpWq6K6kC02Af3ubrhz11ndiyYGHYPflB49rOfr34waEa50Yg+jbbZCgAKuWXXADwuOJTcHf/2Qdy7wg+uktUkxXpltA+NjQILauXoWlBx8W6lyPuojg7S9b+/OT1qJ/y2Y84FQOUGwiE4E6Z9HPRYLnuVEXI1WAeFijm7h0OF2CGRBuU7OYUAhxhhCiT9j8WgjxLwAnTMDYSBXcVsyBif7QDn94aq0J63RHnVQO77SDlrsD7eIVi/Y7ACd//X/wivd+0L2vb84833NcsanObnRxuqlNBVSnqFyX50pwHXSOaybopAPiXSUOE5uEEBXrRn1fuhgUh3LExLc0FuVsUp3uak9e1cS4XBjz/Z7UssO6vOkED3D6WKWUPqecTxCq6Wzy1vumlc9VdAwLCgSHvvr13rKV2FRHl4046J3HLNP0rgil077vMq5jrep7pVJuFz11pT4oTrSDsynb0YGlBx82bnea/p2o1r9Vu9FVczZFiE3qKl9ssSnw/QW70U0UrguzxUWKdiXYrdKyLFiWiTWPPoznH7wv8vgxVbn0rM/iym9+Gc/df3fo4+q8MHjsCe4vCZkIRvp31X4SIQkSx9kUNb/IOucZaq6nLsqm6zjHytPZ5CNOctV/SCkHAbwWwCwApwL4TlNHRWqS1iZ0OgNb/V2xwsof2gl1kjm0s7JELMjiAw7EzIVevk+FsymijG7H+nXYsWGd7z7f5GyKZ2aViwVIKVF0Slz0KwGes8kpo3MEjr55C7DfMcfZ98USmyrL6AAgFZhMmq7YFF8MAgBDm/i+7qNnYNmLXgKgdhldHDGrs8d2wxWGhtxWqDq5zurOpsoyOm8Zlmn4Tvz9ZXTVf7u60Lz1hecrXFzBq9f7HvUyvPvs7/jG4E5KEhKb7GV5Qrh3hT3lK9OK61irhtCcTWodBp1M6dz0F5uSQndIqN+pusJXGqt0CFYrJ853BcrolNiknE0xy+gqxMNJ+j5dZ1MMFyeZegSPUZZp4tl77sSV3/oyrvmfc3D/NX+cpJE1xqCT8bfayewLEnUlXt2m2EQmkmDFBSHNxnTFJu/8PHieG3Ue6l1g9pfR1edsssUmOpts4ohN6gz0jQAukVI+gfCmTWQCSbmlPf6T34Gtm323a7kjpivv/po9qVY7CTePaPacqq8T2qbdqZWTAfoOyBM2pJS46PMfw0Wf+5jvhFbPEJrKV8MHtm7GT09/D2675NcoORPBfJizyTTtsihnfS7cd3/M3X0pgMbL6IBKsUc5m5S4FbuMThNwDv6317iutKgyOqsOsSmTzyOdzcIolzAWctKUq+VsCopN2iQ9OGHX3Ui1XImmtl0ZpSKGtvu7kAVLbIUQmLfHXr5le2V0yXXMSDllg5Zpud+nSKV9V4WScPultNI8tV0GxczMJGX8tCL6tqeEJ5VbN7i9ssOd+s3lu7srHgv+JpRYowTUWqWniooyuklzNimxiZP0ViRMbNIvzA1s2Rx8SUsQdW4RdSVe7een8jkJmX6oiAbAPmcmpNmoC9b6uYa6nrbni48AABzwsleEvjbnvEbNH2REWXI1lLPJl5XaxohaP3whxG8BLAawJ4DDAKQB3CqlfEnzh5cMRxxxhFyxYsVkD2Nc/OSj//TdLg3/BVb5OWS734x0bj/3/kL/hYAcBUQekEXkek9FKjMvuLhphZQWiv0/9N2X63s/SoMXA0ijY9YZKA5eDmluRK7n35HKLolclll+AeXhqwEAHbM+F/qYyCxGruckABYAiWL/T5z3/CBS6Vn2mKwhFAd+6Y4llR5feG+zMEsrUR65FiKzO9KZJTAK9yDd8VJkO+1OPVIaKPbbkW0iNQfS2glAIpVbjlRqDozCnUjnj0S267iq72MUH4MxejPSuYOQ7X6de3+h/+eAHHFvp7J7I9dzIixjI0pDl0OkFyLfd0rNz1Ec+DWkNQCk+tAx4z9RHr0NZvFBZDqPQ6ajMvi7OPg7SHMzcr0nI5Wp7FYXxB2n87vSyfa8E+ns0sjXSllGsf/H7u1M5wnIdLzIfswaRnHgF6GvE+lFyPedHLnc4sD/QVo7nO9lR+hzgtuwlCaK/T8CIJCf+RlYpadRHv0bUtn9ket5U+R71UOh/6eALCA/42OwzE0oD1+DVGZPpDtegvLwlQCAdP7FyHbFj/4r7Dqv4j6Rmolc3/tQ7L8AQAYdsz7tbQcO6Y6jke182bg/UztgjN0Do3APAG+7kVI6v38T+ZmfhBCeeFce/SfM4sMQqT5Iy98zJNP1amTyh7q3S8PXwSo/496u9ZtRmKVVKI9c472u+y1I5/Zt5OONCzWOVGZP5HqZOdJqGMVHYIz+w72d6TwB0hqEWbTPC1PZvZDredskja5+1P4wlTsAue43VjxultegPPwnpDJLkev1OucWB38PaW6KfdwjJAmMwv0wxu4EAORnngEhpn7DHNLaGGP3wijcjXTHUTAL9wPwzjulVYBlrEYquzeEqLygreZF6rhQHLgI0tqJXN8HkEpXNywoLGMrSkOXQqTnIt/3/prP/8SF0yOdSAjxoJTyiOD9cS4vnw7gRQBWSSlHhRCzAZyW7PBI/ThOBOldoZKybAtNSEGkZkCaWwG0g+2/stxIQE2K7Ct8Ujrqcqq36pJSmT2Qzh0aKkgJ2DslaWxAaehySGsAQnhX2qW5E1Bik9TGJKfw1XDpuGekAemIKPpn0s2PuqAhkNLKA2N8PulshyKwyxEp+BoJOs+TaruOeVKS7TkRxthdyHS+3H6Z8xmkjHIHqTHHW75IdUKaIxVCk/1etdwzQSOo95t0txPRCcigC6vW1Wf7M4j07EixqWIkIu2MRwKwIKVdZihS8Zwm8VDbjOVt+yJlbzMVzxnv+6h1qzYi//YlRLxyLQLIkN+xEMI+llg77f1dWrtw4W67lW4jEbxPBLrAhJzghRL8/Qf3HxOF0LZp0npUHIMt79gHuMe+lkNGHSPU/cH9rLO/nMrnJGTaIS09zsBC3PMuQhpFnc8I37bm3JfqQDp3QPSL1Tm9e4xQ+8s6zlvVuYpshzl4beJ0o7MA/AsAhBB7A3gPgJMBHNTcoRGdoOr5twsewpN3PIMTPrA/Dj7efmz7ujX4v/8HzNxtAbpnzsaGp7fibZ87FEsOPGQyhjxhjPTvwoUf+YnvvtP/91X46em/AiDx8Z8ejx++70ewAHzsJ2+O0aHq1aH3bnnheVx65hUA4Ah5/pPUo0+chaNOtL+LLatW4tKz7Pv//czDsds++2Eq8tCNo/jnb4C5izuwYO85ePwW4N9OPRSHvsrb3s47+XzIwMnpQcctwezFS3DrxXfg0BMW4YTTqqvyD1y7C7dfBrzoNXvh+FO95/76jN+jf7NXmrZwnx6c/PUTsPrhB/Gnc/+IpQfOwzu/FFfxf5f714PXDeHWi+/GocfPxwkfrHz9RZ+/EjvWAyd/9RjMW7qs5pKv+PrNWPfk9tDH3vuNV2L2osWRr5WWhfNO8Rp6HvWWJTjmJHtM29a8gIv/67eYs3gedqxf63vd7IV5nPaD6M/+q09dhoGtwEHH7YnH/vmce//iAw7EhqefxMJ99sd7vlX5+vM/8DOUC2P40P++DPf/eSPuvwZ46YkHuWMaLz//2P9heOco3v/to7Hl+edw7XnXYu8XL8ARbzkKv/+K/fs54o374OUnx3+/H7y70tk0e1EPTv3uCfjhe3+MVNreR172xb9g8/Oe8PbqD74YB71yelwxaja3XboaK/5i/60fb6469za88PBOvOEjy7DPES917//rDx/AM/cAu++/G9Y96S+ze+unj3Jz0wDghp89iidufcq9fcpXj8XcGL+79U8+jj98/U/u7ZO+cAwWH3BgvR9t3Kx57GFc+c2rsHj/GXjXV7k9tRoPXjeIWy++xb39spP2wpZVFp5x8rXnLs7h/f/TOt+r2h/uedgcvO0LleNeuaIbf/7eNVh26Dy8/b+9x//w9Zuw/smNeNvnXoQlBx1a8TpCmsF15z+Ip++y//7P845182wIaRZ3/G4t7v8zcPTb9sWdl9uO7QOPXYDXfqT2fn7Tymfwuy9diXlLO/G+c0/ALz95GQa3Ae//1rGYMX+3WO8/sHUzfvWpi9A7J48PXdA6x5ZmEacb3SIhxGeFEA8AeMJ5TXRtB5kQVLCynpejMghmzN/NFVTMSe5Gd/cfL8NV3zm7qa12w7oiZXN5COdq9HD/TlimiY7evnG1Qq8Vartz4/rQMZlTOB9BBWgb5ZIb3hsM9w3L10ll0l6OiVH786mMoGxFZlM28DxbvDPq7EYXJNfl1FyHBBsD9QeQd/RGO+JqBYQHO2DomU3ueunoqMixqR0QbguAHT3a2ITAWz57Fl769nfjLZ8/K/R16jdglEoYG7RLzroC+WTjQeV8Scv0BSvq32VimU1ucHN4ZlNwWybRhHWcA+xmAAAwGMgDrJrZFNGNThE7sykQCF7rt9YsUhENOUhrEJbZpDIKAbjNMVqNqLxEL2PEv5/1MpvobCITh96NjvtQMhGoDEq9y27c/V6uwz5/UZlN7nlsKr4jz22UE3Fe1W5Eik1CiA8LIW4BcCuAObDL6TZJKb8upXxsgsZHIkiHTPRdsWneAjdY1TAm18J3z5W/xwsPrcCGp55o2nuEtS1OZ7PuJH9wq+1CqhUOXotsR/VwWp/YVNRCxKfwwVXtTI1S2etGFwz3zVTuYFOptDfRjyEkRnejywSe5wRXKzGowa5l6jOUxsbfjQ7wOtJVe6+46MHfKiA8m8v7ugACtcP91URDF5sy2Ry6Z87Cy08+Fb2zw3PCPLGpiNFBO2unq29mXZ+hGmrfZBqm140ulfJ918l0o0v7hDxpWRVicpgQQsKxIo4VM+bbYtPAtq2++w1nH5fvqrxKXdmNzv87U80WahEUg2uF8TcL98SxiRdNSPMITnClaaKoXYjQhadWwoz4zartNCjyqsmS5HZMJpDRgX7376jjDCFJEnaOH7ebrNcMqvGAcPW+UfvodqOas+kC5/H3SCm/LKV8FP50FTKJ6O3FFYPb7CvPffMXuF2YzCnSja4U4j5KijBnkxDC3TEMbnfEpjnjC+nunjkLexz6Yhz4ihNwyAmvrXh854Z1bqcNXWwKdgycSigxxiiX3BPuXHCiGOL+SWUyDTmbgmJTUOxRopRy9cR1HgVRk9Ki8/kGt2/Dn779Vax9/BFnzPWJTVHOJiFSbnv4uOjiqCvC5fMVE+m43eg6erzJfiaGiKO+A6NUdp1NnX3RYlq9CK1NvKUdpFMJd6NTQpP63woTm+hsis0hr3o9AOCgV/rLiJWzSe/eBXgdNzt64jib/KcacbZToFKUnCxnk+rqxYlSaxIUCS0r4GwaG23JLllRkycrYnLk7iuZ2UQmEDqbyEQTdo4fd9tT5xmqMiJqf1qNFMUmH9XO+BcC+HcAPxBC7AbgCgDjvxxNEkFt9HqJlldGtwA7nfyXWhPWZqKfvDVT9DJCnE2AN8EZdK7I94zT2ZRKpfHOL53j3l735GPo37zJvV0cGUFhZBidPb2+lvZT2tmkyuhKJc/ZFCyjC9nBptJppEMEzyg8salWGZ39PO+qRKNik32wKDsHi9su+TVWP/IvrH7kX/j8H/7qiVkxJ72dPeFiU66z020TH5fEnE1GpbMpzufxO5v6AQCdCZbRpbWSI89+nHK3F6D+7/Xok07BvX/6PV70ujfh4RuvA+D9vlOpFEzLgrQs122nYDZEfBbsuTc++dsrKgQd5Wwa3BYQm1QZXRxnU+B7ifu7C4pSk1ZGl1GWeJ44tiL6ZMEyTVim5Sudk5YFo1iM7bibKliGCdMwMLB1C2YtXOQei3RHqY66LS2KTWRiMI0yCsNDvtuENBt1kT/ViNjklPmXCwVIKT2naB1ldErkorhqE+lsklLukFJeKKV8JYBXAegHsEUI8ZQQ4tsTNUASTtjJrxKbZs7fDWmV2VQj96WZ6O/dzEwEXdjRccvotqkyuvE5m4IEXToAMOh8B6o8DZjamU2qlMD0ZTYFy+hCMpvSGYg6cky8Mjq/2BS8rb5LL1OpwcymgLOpGCiTqLeMrqM33Pkzq0oweBT+zCbP2RQUQ81SuerVdrXeO7p1sal2Jpk/s0mV0SWY2aQdZKVTI59Kp33lmGHbVDWOfdd78ZnLrsGCvby298pBpbZDaVmwApOoPMWmush3dVWIp33z5gOwjy/69qjcm2GlisF8u+D3HSyri0IXJdOZTMPi83hxLfFTeF9OolHnSUpMMkoF95ighM/gMWI8bHnhed+FqGZhmQb++sPv4ref/QhWrrhXu9+ZHAV+dyIV/5hNSBKMDQ35bnPbIxOBFXLBOm6VSSqdRiabg5QWjFLRzXoKOrSrod6X4qpNrDUnpVwvpfyBlPIIACcCaF5NFIlFsB5USumKTXoZXS13RDPRS8nGhgYn5H10lAqtyuh6xllGFyQbJjY5wpZe2he08I8ODmDr6lWJjqVRVBmdZZooDA8DCHM2hYlNKZ+DpRbxy+gcZ1OdzqMguUBmU1YrdZOWpYUHxnQ2RZTR6eJHXHQnnutsyufdciV3nNKqum69zCZPUImzvlRIe2lsFMXREYhUKlEHUCqsjC6V9gkMjYiIttjgvU5dpXdDby2zomtirsWcClORzt4+ZDs6URobRWFk2L1fiaZhpYpBwUq/IpjOZmO7AfXtebLymgAtIJzOppZEiYQzFywCAOzavMm9IKQuQhUj8v3qpVwo4NIzz8Cvz/iQe0xtFqZhYOUDdqelR/9+g3u/vt/VobOJTDTB3EyWFZGJQM0h9NK3eoTObKfmbjK9RjdxEdq+llmPMcUmHSnls1LKb8R5rhDi9UKIZ4QQK4UQZ1Z53klCCCmEOMK5PUcIcYsQYlgIcUHguTcIIR4RQjwhhLhQCBH/259GBMWkwsgwSmOjyHZ0orO3zwsIn8QyOl1waabYZEQ4m9ROZqBZzqaQrJ4Bp2OT7rYKZhr98hP/gUv++9PYsWFdouNpBP1EwDINiFRlBlGUs0mJB3GuFqjttMLZFHDiWKYByzI951HDYpO/5loXuS74j3e7Qk1sZ5MWEL778oPdv3fba5+6x/bCww/i/j9fCcDv+FLlSjpR5adSSvfAqU/268lsGtqxHYAtJgQ75o0HN8tLK6NLBbvRNfi96ssIy2wKnkwk+bnaFSEEZjjupkEtt8lzNnlC5Yd+8lt84teXVyxDvyJYjzvJLzZNTgkdoF2lnML5eyQatb+fs/sSALAv9kiJbEenK9aXEnJf667mB669MpFl6ugTF0Nzj5e199W7gOro+0pCJoLg74rOJjIRqDJ//UJzPdueulBZGhtrqIxOCOGV0sXItZ3uNO1M3BGBfgLgDQAOBHCKEOLAkOf1AjgDwH3a3QUAXwHw/0IW/S4p5WEADgYwD3auVNvhhfzaP6hBLa9JCOFO6iezjE4/6ZoMZ5NXRmevm54548tsCpINE5uUs0kbUzDTSH1nW55/LtHxNEJJ68gD2MJF0HUQltmU1gKf42RSRZXRpXOVZV9GqaQFhDdaRueITYUxSMvyfVfqM6fSmdgOi+6Zs9y/jz35VPfvBXvHczZ95Gf/h9d97DPu7Tt+dxG2rl7lCqWZXAdmzKsUm4yI36+6Mi1Eyic2xRFx1HNu/qWt4ydZQgfozQu0bnTp1LidTYDfieaJTV4ZHa/YN4c+tyOdvS+VUrqCul522zt7js9pp/B993UIjbowpXIUJgM6m1obdbI/e7EtNg07Qnu+q8sruU6ojE4Xgx77502JLFNHd4bo5xn6sVx93mDZR0orOSZkItDnAUD8jmCEjAe1b9RL+uvZ9tT5RqkwFpmBV4uUW0rHbb6Zl32PArBSSrlKSlkCcDnsErwg5wD4LrTSPCnliJTyToSU60kplWqRAZBDm3bI03NXAM9Ro9wRE1lGt/HZp7D+qccr7tdPhPSAwKSJymxyQ9SdCXvvOAPCg+iunO5ZswF4wpbvKmOUGFNnsHQzCFqcg3lNQJVudCEh9VGUI8voKpdtFIuug6DRjJZUKm0fZKREuVgIzdeqZ9I7c8FuOP79H8Lb/usrmLXbIvf+Oc7kpRY9s+dgQcAFZRmG7+pLmLMpypnohR+mfY6POOsruC6Sdj/qE3O17YuUP7MpCWeTeh+9NIRXTZuDEkLVRQ3TMOxA9nTGJyBHOcl8nQjr+O7119Xb9TFJUsxsamnckuPuHnTNmOnen+/qdsX6pHIldSFnbGgw8YmGGeFmCivdD16Jd51N3I7JBBEsT6XLo3Uojo7gtkt/gx1Ow6lWQnXLzeY7sN/RLwcAHHLC62K/PuuITeoihBCpup3yXkg4xaaaa07YvE8I8VXn9lIhxFExlr0YgF4ntN65T1/24QCWSCmvq2PMEELcCGArgCEAyfuUW4Cg2KRKYvrm2uUO6oS+mV3gAPsK9++/8gX84ewzK06qfGV0g81zNultVXX0E618V3fimR/65GfO4t0BaJlNehmddmKnX/Wst4tZEpQLBdx26W+w5YXnAVSeCORC8ld0kcC9TyujG083ukwuRGzSnE31BknrqPbrxbHR0Jal9bprXvKmE7H3S16K7pmz8LJ/fy9e//HP1tUKNfjZIYTmbMq7v12dqN+vd+U64xtDnCvWwXHs+eIjar6mHlyxSXMa6d0LASCdTkBsCmY2mSav2DeJGQFnk9pusx15CFH7BEy/IpipQ0DW95GTFQ5uv7eywzPssxXxArPTmLXQu1iQ6+pyjxPBCy+NEtwHrfjLVXjqzlsTWTbgd9epCRXgd5BEBYQzs4lMNMEyOpYitw63XfJrrPjLVbjsi5/z3d8K+w/P2ZTHmz79BZx23s+w/OXHx369uohbHLHFpnrCwRXuBfmICw6WaeLyr/0X/njOl+pedqsRZ+39FMAxAE5xbg/BLo8bF8I+Qz0PwOfrfa2U8nUAFgLIAzghYvkfFkKsEEKs2LZt27jGOhUJltG5QcNOnanrbCo19+RY/xEFT9ZKutjURGfTzojsI12FDnb6SgK9NEvZ8we2bbVLTPSrjM6J398u+AF++cnTtQFOvNh03zV/xIq/XIVLzzwDlmlW5F2FOZvCRBm7LEpN8msfeKLEprDuaeVS0d2u4mQQReHaYMfGQnf2jZZyAcAx7zwFB73yVXW9Jhgob5bLPmdTWNvtqDI6N3MqIHbFEf707+DIE9+JV7zvP2q+ph70LC89s0n/PTZeRheW2RTdjY4kg+pINxgoE87mO2KJ5qkk8rrGsS8YLylmL7Q0bgZgOoOZmjM139WN/DjK6KSUuO/qK/DCww9691l+s/2dl1+M63/8fd85wXjQj2X6/l4Xm2REQLjbjS6h/aRpGLju/O/h0X/cmMjyyPQjOC+gq6512LxqJQB/lcquzRtx/gf+Hff+qTKbcSrhnqN0dCCVTmPO4iV1XeBX5+OqKUo94eAKdYEsqvzeNA1sePpJbHjmybqX3WrEEZteKqX8BJySNinlLtjla7XYAECvMdnduU/RCzt36VYhxGoARwO4VoWE10JKWQDwZ4SX5kFK+Qsp5RFSyiPmzZsXZ5EtRdDZpBwQSmRSP5Qk2/mGodu4gzZ0/bFCEzObdqwPF5t0x0czxCa9HKln1hxksjmUC2MoFwsVmU1SSjx5xy1uVgQATEYRXf/mje7fwbwmILyzVFib8vqdTY6DJyAuhYlJ/symcYhNWke6sPajjRw8xkOwfM00yp6zKaJEyIwocYu6ch2nzEcfx7JDXzwuQS8MV4Q0TK9lbCrtP9A3uPH7AsJFSEA4u340hd459jF0aOcOAMDOjesBAN0zZ8eylvu60TX4mx6PODxelCuP2QutiZcdl8bsRbu79+c6u1w3byNldOufehx3Xn4xrjr3a957RQg5m1clk9EYlcNpFIu48ltfwdDO7e5xoCKzKWFn01N33oqn77oNN//ix4ksj0w/gueZ3Ie2DmERC/df80cYpSLuuuLSSRhRfLxOz411JM51OBchlLOpjnBwhdc1PiJ7NeKiwHQkjthUdsK+JQAIIeYBiHOkegDAvkKIPYUQOQAnA7hWPSilHJBSzpVSLpNSLgNwL4C3SilXRC1QCNEjhFjo/J0B8CYAT8cYy7QjKDYZgVbxSlwZdiYHzUIXVYLClj+zabgp1svS2CiGdmxDOpNBR2+f7zF9EqQHPCeFPmnP5HK+Vpl+Z5OFoR2V7rrJcGHo6ySsbCAfUmoYNslLa93F4lypUsp+cFlhbgWjWHR3zuMpo8t3Oc6m0bHQKwtGQlea4xIUlEzDqHB8vePMs3HICa/Fbk7weGRmk/N5goGFcQKMdcGvLySUfLy4IqRlQmrOJh8Nuvp0oSJYRictltE1C+XiVNujyujbfXlFz49Q/JlNDbraQkTviUKkUoAQkJKCZitiuRl3GZ8jdbR/l+vmLTVwYW5Iu3ikiNoHbXw2mVPVapP1NY8+hLv+cKm3343KbEpoG962elUiyyHTl4rMJpbRtQzqIrGOlK0Rk6zO7xsVm4LOpnoiMxSpGnMk92LsBF/4ngziiE3nA7gawHwhxLcA3Ang3FovklIaAD4J4EYATwG4Qkr5hBDiG0KIt9Z6veN2Og/AaUKI9U4nu27Y7qdHATwMO7fpwhifYdrhltE56q262qVcCn1znSvRISJHkuiiSvBkTX9MSguFcbqsdm3eiNt/d5GvJG/nBvsK+6xFu+OgV9gVlfsceQwA/4lWozucauhldJlczn2PcqHS2bQzxH01GZ0CdXEieBIAhGc2hZbRZTJ1hY2aEU6coNMJsB1xSZTRZZ0rE6XCaGg5WrBLSrMJrkdfGZ3ze97zxUfgtR/5tPs9RAX8u5OJwDLjnMjpB7behDs0Al5pnz8g3H+oiZPzE7psvRud8z7qf8v0B4Qf9ba2bFTaFFS5q9pneWLTIfGcTQ0GhPvGMInOJiGEtl1TbGo1PGdTBt0zZ+E1H/4UhEhh+XHHa51L67/4EDoZixByNj2XlNhU/byhNDoa6XwVCTubdmlOaULCCGY2Wc5FtlrbMZl8km4eM1FYlumeO1dkpcbEzWwabVxsStfKbHKOFRNdZTEZ1Dx7k1JeJoR4EMCrYBc/vE1K+VSchUsprwdwfeC+r0Y89/jA7WURiz0yzntPdzxnk32yo35YalLQM2cuAGBoxw5Yltk0m54uKAVt6MHJ/NjgIDp7eht+ryu/+WUMbtuKgS2b8ZbPngkA2OHkNc1evAQvP+UDWHLQIVhy0KEA/BbysCDq8eJ3NuWRc5TwyjI60x2nzkR0CgwitO1gXGV0Kc3ZFMNNo54T3GGHTTzHhoe8MrpxiE35Ti+zKWyME50dEKwXr1ZG59lvI2q9jXDHkBljIlwY9kpamxG67Ik/ZmTL2EbjyqoFhOvOptd99Awc+MrQOD/SABmt4YRRKmHTc88AABYfcKArss9auDjy9T6xqdEyuknMbALsrpymYTiCbmMnsGRyUPshdfJ/6Kteh/2POQ75ri48fuvfnefU77gIy8SMciyr38x4qTVJz3V2Re531e8wKbGpn2ITqUHQQW8aBn724fcCEPjURVdMzqBILFpVbNLPq+vtIKdQma/FYUdsamA5qpN31D47aj89HakpNgkhLpFSngqtXE27j0wSrtjkCBYq20WdkGdzeXT2zcDY4ABG+/ubklkE+K8GBg8q5UD4dCM2dR0VTquHqamTndmLFiOTzWLvl7zUfUzfyQTzcpKgwtnkiE2lijI6M7R16GQ4m2qW0cUNCM+kta5jMcro3JP92s4mu110gt3oRsMzmyYbs1x2Bdng1Re9FC0MtywksD7jdMsa6e+vd6h1kU571mEroowu39XT0LLDA8K9zCY1iVqw975tUQc/UXjdTcsY3L4VZrmMGQt2Q6dTuvzpS/5U8dvWET6xqbHf9GQ6mwBbqCiDmSOtSNj+Uh3rUpo4Xi+6s0laFkQqFVlmklRH3lrnDdKK3u/q+8ok2LWJYhOpjnLQd3T3oDAyjHKx6F7oNMrlxDMjSXKEOTdbgfHmNQFA1hGbxhcQXv2isZ4lON2JI6cdpN9w8pte0pzhkLiospuyymwKKTvySukqcwWSompmU8DZNN4yOm+53nsO79oFwA7oDqL/gMNEjfGiCwT+MroxnwhnWWZoiPlkl9GFi031BITHP0n3MjNiOJuGBlFwSiU7uhsTJQAvIFwvy5tKFEZGbBFSCMyYv5vvMT1kO4zglXpFnIDwpQcfBgCYt3RZvUOOhfqOLdNwa9LVgfotnz0TLz/5/Ziz+5LI11cjXUVskpbVVleKJhK3u2m57J7IqSt/gH08qnbC5AsIb3BykWqCC6++94+fUUemFq4TNFO5jXoXTeoXYIrORATwLvxFuYaktBLJO6l1LBsbHnKPG8EJUqqO0vda6Od+XTNmjnt5ZHqizjM7eu2qBl3AGO8FaNJc1L7M5w5qgcim8jjzmgCgo9ueC6mLBA2V0dXoYhuZaToNibxUKIQ4C8AXAXQKIQbh9Q8qAfjFBIyNVCGqG11aE0B658zDllUr0b91M3ZuXI+lhxyG3tlzEx2HX2zyxAvTMDA2NOR7blIHFl1sGh2wxaawAHDfBKfBut1q6KVPmWzeVcJLY6M+oc0yDAztrBT8JqeMTstsCvk+cnGdTem0576pcfIrpfRlZviWHSY2DQ5i1NnBd/XNqLrsarg22LHRSRH2wnjdR8/AjRf+CACw9vFHYJbLmL/n3hWfs1anP7csMfjdxJjMHHT8q9A9cxYW7ndAvcOPhfrdWaZZ0W1jv6NfPq5lhweEew47KdXJ0fQ/eE8k6ndqOGV0QH0Cvj7Jb7SMTpUpTxapGp1lyNQlyglq3+dlzNVLYVgTm0olZPMdVUvUpGWNO5+j1vZXGBpCz6zZACqdxElmNvVv2ewtt9G6aDLtKY3a58KdPX3oxyZfaVZxdIRCZQvQjMqQZqLmpdmILs9xyDsXukcH+wE01jHOvUBVs4xu+p+vRl7+lVKeK6XsBfA9KWWflLLX+TdHSnnWBI6RhFCR2aQmANqJfO9cW1i69f9+iRt++r/44zlfTrwG15/Z5IkXV537NTxz9+0AvKC1wsj4xCYleqgJJQCM9EeLTf4yuuTFpmygG52aDKkxKSzLqigpBBpzNo13oqOXZYXZ+kOdTRFXg+NeEdZDooMnpfqEtcPJ8xobHsLY4AAAoHMcYpMq8Rkd6J8yE8SD/+01eMmbTgQArHrwfgDAHoe+uOJ56RquMTNgv337f38NXTNm4i2fq71rTqXS2OvwI8eVn1Z1+Rm9jC7Zbhu+zCZnmSk6m5pOKp2296dSukJ6PfvU8TibXnX6xzFv6TIc8ZZ31PW6pKlliSdTlygnKOAXq+uloDUrUcf4asfDJBxFNZ1NQ4Net9LAxYgkM5t0hwrdfiSKSmeTJjaNc05AmsPg9q245nvfdG/7j/VT39rkik3juEDV4YpN43c2mVEXjdmNzkNKeZYQYpYQ4ighxCvUv4kYHInG7UZXKvk6O6T1tuZz7DK60YF+AMCujevxo1PfgVsv/mVi49CdTXrXibWPP+L+3eO4qcKcNPUQZomsJjY1vYwuIrNpeNdO3/Msw3AD63TqdTY9eN01+OF73451TzzawGhtTO1AP7xrR8XjsTOb9DK6Gie/6qpyWKaLXvapvsORXTvtk3gh0NHTeBld3/wFAIDBrVtglqfOBFGVAynRdI+DX1TxHFFDbJIBsWmvw4/ER39+CZYceEjSw60bvbwyaZtwrcwmK8z2TRJB7UPVfrwet6h/X1yf2PSi174R7//eBeNyOSaB5+TkxLrViHSCwruYIhsQTAojntikxBe1Xw+7UNKIoBWk1kWqsaHBSHFNCWvjPRcDvIkSkFzgOJl+qMwmdXFLFymDTYXI1OCuyy/B8yvudW+3mnOxXBh/ZpO6+K0urjVyDqvOGWp1o6PYBEAI8Z8AbgdwI4CvO/+f3dxhkVq4zhIp8aNT34H1T9qtqPWua8EcGMWD1/05sXFEOZt0VDj5eK9iZAIqtbQsV0gLs+I229nkz2zKuzu2kV1+Z5NplEOD9syQTjbVuPXiXwEAbrv0t1WfVxgZxoPXXVMhegF25opCjVNlGwHxM5vSWhldrZwgrw1z5Q41HSI27dq0AYDtTBqPvXSms/33b93sirHv+dYP8L5zfwgAeNm73tvwssdDsIyob968yufUKKMzQ8pCpsoJgTpw2p27knUa+Q/K9ufVS0Nkwk4q4qF+q2o/XlcZXQLd6CabNMvoWpagE1RHHWPi5N0FGdPK6JSzSe2DdHFUHWOTcABFXdyZt8eeAOzzMDWWYM6ZKp1+/NabMaa5shoah3ZsSkJEI9MTz9lkO819YtMYnU1TkaA703/MmxrnmdVIoowueKF7XM6mGgHh4y2tbgXizADOAHAkgDVSyn8D8GIA/c0cFIlHmICin8jPbjCEtx58mU3OQSX4w+pVYtM4r6blAir12PAQLNNEvrs7dF34rqZPQBmdymwKOoairt40OmlR4dFhSMvCb874MG69+Fd46G/XVjyuu6mG+20xqmuGdlIcuxtdxguCrvE5XEt/mGilTVi7nZwJV0Acp5Ohd+48CJHC0I7tbte3fFcPFuy1D8649Gocc9Ip41p+owSdHZmQA6IXsl09IHwqiiq6synpg6kuqAWFJd/70dmUOGq7Vd1Z6iqj08WmFu0+NJ6uZWRyiZPZ1JCzSRNsjBCx6dh3n4pX/+fHXUdVEg6gqInLe751nuumGnUc38ELPHsc8iIsPfgwFEdG8Pg/bxrXOPTfQVLd7cj0wiiXYZbLSKXTruAazGwiU49ZCxf5bvsvjLdQGd04nE35QHOiRi58ewHh4fvsYKbpdCbOGXlBSlkAACFEXkr5NID9mzssEoew0DZ9AjBrt0WR7aKTuhJV0oKw1YFDF6AAT0QY74FFn6SYRtk9oeqeUVlCB/h/wM0po/N2ZHpm0/BOv9gU1vUNQMP5WdUEhmfuvRNjQ3aN8Y4NlR3w9PdUzqauvpnuffG70aWRyeYgRMrnYAmjmjCib6/BUsjOvr7IZcYhncmgd+48QEoMbd9mv5+zDU1mu93gbzLsgKiHbIfhliZOcjv4MNxyoyotuJMg2CmFzqbm4jmbGhCbEuhGN9kws6l1ccvKqnaja0Rs0pxNJX9mk0ilcPQ73o3DXvPGRLvARZXRpdNpt1RJXUiqCAgXAksPeREAuOcJjaKLc40Ide3M9nVrsG3t6skeRtNR5765jk53/1lmZtOUJx2YLxlGOZFOmhNFEplNmWzWdyG4kQumqVrOJvf8ePpfHI3zCdcLIWYCuAbAzUKIPwNY08xBkXiEOpu0nUQqnUZfRCnd6MBAImNQtbEAsOnZp3Hbpb+pyCeaudtCAP42wY2g/2ALw8MYcRwwYXlNwAQEhPsym7QyukBAeJTIpkrapJSRglQY1VTwAa1DTEdIALRZ1sUmWxRTJYgilQoXPiK60QkhkO2w10FQYNRxryqHLEd34uU7u3w7d10Ea5SZCxb4boeNYaIJTrbDrL41D1JGCzibDMPN9WiG08gNH9cDwi06m5pFOpjZNMHd6CabWh0iydTFquKu9fZX9QkmplH2dZ0NOpv0fZArNiWR2RRyTBAiBZFKuRdo1IWksOOdcoeO142kv57OpvgY5TL+7/99Ahd/4ZMtNYFvBPWbyHZ0ur8zZjZNfSrEY62jtL7NTtXtN4nMJsALCQcaE4RqOZumcoVC0sQJCH+7lLJfSnk2gK8A+DWAtzV5XCQGYc6mdNZ/chHVLnpox7ZExqCfbAHAir9c5WUFCYH3fOsHmLnAEZvGeWDRy84Kw0Ous6krQmzyl9El37rTn9nkBYQra716z1pldH/94Xfx49PehV2bN8Z632qCiX7lNOwKqKHZYdVJqyqjy3d2heb+hHbwcU7aVelgKbAd+MZkRHcC0jPGUpkMOns8N9N4OtEpgrllU8FVoY9BpFLVSzsiTuLDMpumCnonPTcgvAk2YRXEqweEy4AARZJDuUNVV1E6m0irECezqV4hSHc1AZUB4brYJNxSvSTK6CqP62oipDqwek05wj6vJ86HIaXEppXPVL2AZL+H5myyrCk78ZxqbFuzyv17uu9LlNsvk8u5+0/dXV9iGd2UJGxfqC5U+8pnp+iFF7UvHk9mExAQmxo4h6150Vh1o2MZHSCEmK3+AXgMwJ1ohaLNNiDsZD9YLhY1IRjeUdmJrBHCTkiUPXvekj2wcJ/93dKs8ZbR6eLJ2NBg1U50gH/C2YwJji5gpTMZ5BzhRaFavUZZhVVnuGfvvRMA8PRdt8V632oquL7zDzspDQsq73LKEHMhJXRAZcioPgYlZupB8UGqCSO6OyKdybgnywDQNc4yOqBSbMpMAVeF7uzI5vOhAp8esh1GsBvdVMJzgJhNvXJTkdlkmW118J5o1IUMtR9vt4BwdeI4VU+wSTTV3LXe9zo+sUlNrMMEb28f1Syxyf4MFTkjIcdc4ewblSgW5Ok7b8XvvvR5XP2dr1cdR3BCGrU84mfTc8+4f9fKu2x1lLCUyeU0ZxMzm6Y6YftCVYmhz8OmqliaRGYT4K8OaSwg3D7XiTpncJ34U/A8PmniXP79F4BtAJ4F8Jzz92ohxL+EEC9p5uBIdUIzmwITgGPf9b7Q1ybnbKoUGQqO2KS6xyl1eLz12T6xaXgIQzu2A6hWRtdcZ1M6k8FJX/wG/v0r3wZQWR/cqT53xORMD+vWefL2f+KyL362ohxPUW2nZ9ZwNoXd5zqbusPFprBcIHWfyq2qJjZVExx0ETCVTqNnzhz3dhLOpq6ZM323p1oZXdTBsFYYcbUr9ZONN3a9G10TM5uEntnEMrpmofZfDWU2aZPeycxLGw90NrUu1dy1jeYpBUUfVTJkVSujSySzyd7+strFLVWmGvxthR27RQ1n09P33AEAWPfkY1XHEfwsSYSftwO62GRE5G9NF/xik3I26WV0FJumIuq3fcCxr3TPw9X+Tt/vTdVjoZqPjCezCfCL942ca7fyReOkiXNGfjOAN0op50op5wB4A4C/Avg4gJ82c3CkOplsmFPEf7Kx5KBDcfr5v6p43tDOZJ1NPXPmuvcpZ5OaSKsOZ+N2Nmk7ubHBQfRv2QTADkIPQ6+x1cu1kmTZYYdj6cGHAqgUDlSrV5XHFBRP1EmjQjgtRf/2k/Ow+fnncP81fwx9z2oTd702OGwHFyZw9c2dDwDodrKbKt4vJFRVnbDGcTa5eRkhJ74Zn9iUwZFvPcm9HZY5VS8dXdqVXiGmxE5dnwCEdaID/CHbYVTrrjTZpHxldMp9NFGZTQwIbxbpnBKblHgef5+qf/8tW0anfpN1ZvtMBLVKntqdavtLUUPYj16m//nlYGaT0MrolJuowcym5x64Bzf87IcwjbJ7HpTr1MQm53MFXYOhmU0p4RtnxeMi3r46+PnZpTEem5572v07KstlumC4ZXR59zzS72xiZtNURP2WF+y1j3uOrzrS6fOKqbr9JuZs0sQmMY5udGFzsZ0bN2Bg6xYA7RH7EOcTHi2lvFHdkFLeBOAYKeW9AJK3i5DYGCX/VRE7/6XyB9E3b17Ffao713gpOSLDSWeejXl77AkAGHPs5eqHnu/sAoRAaWx0XAGZuivnob9d63bzUAHkQfwB4c3fVIMqekeP39KuHESKKGdTrcerWS5rZzZVLnOPQ1+MV53+cbzy1NNDlxlW9qJ2ourqavWA8Oiryj5nUyaN3Q84CMe88z3onTMPS5YfHLnMuCihU405rGRtovE5myK2Sz1kOwz3Sn2IEDjZ6GUpzbQJB4N4dXGLzqbkUfsB16lZxz7VX0Y39QTSOLjb9RQrfbnrisv+P3vfHS9JUW9/auKdG/duzizLEnYlswQRgRUJCw8kg2DAtwomggIiT30kE09EfjwEEVFAUfGBKEoQUFAQBASUuMRdNueb79yZ6Z7+/dFd1VXV1T3dE+7M3Fvn8+HDztyenp6O9T11zvni+k+cjFWv/Lvem9KwYEpQxf0yXmbwu0zWsMymop0yobTRlUnI3HfNt/Dq449i+d//5pJNnLKJPltlIledUUXJeXUaRthnpFY2RUfRNFmBCagtkWMJvLIpzpRNuhtdo4PvIkyjLpTKpgZV5lHiv+LMpnbX7VFeQLhjo5Ou83x2GD/70jn4809vctbdeOP4aiPMqG89IeQSAL92Xp8GYCMhJA5AP13qiIKUv+OXoRGLxRGLJ4TB1EiFneHYNrAWkxlmqxgZpMom+0InsRjSmVbkhoeQH856SJgwsCyLscMTps/AltVuQ0QaQC5DDAivfjc6GXJmEx92DaiUTRLxIw3yeJKHH8gFseBCZpOKbJK+M5FMIZFMYs8jjvZdp3LA6rxHj3G+zMwmlUrrwFPOwIGnnOG7vihIczlUjZIVw2+Hn7IpXqI4aWhlk3N+mnxmUw1tdLJUmZBYQ5CKYw1UyUQLhHgEtSh/njatsonOUjaYguMf9/wKAPD03b/C3F33qPPWNB6KRROwLFvZqrgPuURQtOGsv7LJeV+w0VUns8nI59kEBD+5Rcl8mcgNstH5bUu5ZFPU/TceIe+zRrUhVQuCjS6hsNFlNdnUiGDdjmNx9rxmmU2Ce6LxyCarWMTGd98CAGR83Bph0dLGZTZVEhAuXfd9mzeJy42DjNEwVN0ZAGYD+B2AewHMcd6LAzi1ZlumURKGpCYJGsTLNrJqMdKMQW5pYWRXtl8kmwA3Dyg3XB7JZXKti99/sktEtHVP9PXlCsqmCGG25cKjbOoQbWB8+DWgPgZ8Rxee5OGJxSDpqslZPAzpQWBZFpPCUvDKHz+oBqy0eKQE29/u/BmedooeGezBVUKF4zfTWgn4HKpGUVSEUzYFh9Y2dGYT1+6VBXbXYDvlbBR6XWhVU23gDjppAVGmsqlJyaZSakONxkRQXhMgNhiItF5peSMgIJzlJFVIVKZaWljRx9vo4n42OmVAeHBmE0Ly9LIlsBLV+niBvM8bVRlSLfA2OqWySdvoGhK8sok21TGbJCD87eefQc/6deicMhVz37d7Retq4Wq2sgLCfcYMcqSMDggHYFnWFsuyzgVwkGVZe1uWda5lWZsty8pblvX2KGyjhg/knJxgskksDFRdycrbBrvlfTKdZuqh7OCA855LvqQyNqmRz2bL+h56g4snk8Lsbeckr0WQgeMuRqMo9wSES5lDcnc1o1AQBx+WxfYnIA7e+GNtBsj9eWVTPjuMt555inXNKZqmp2OMrMZSQalIcvYnDQjv37wRT/3mTuWAM6wKpxYyfEHZ1CBFLt8Rz48o5UO2VWA5WA34kOLzpvhBS7Uhh4HTWbbx4H+vBzydTiNcTzwB2CgKw6igXTmD7r8ajYdSz59ySUR5IoAW0cqA8DhVE0UnZPgJqERLC9tO/tlNf4Oc0aTMW2QNFdTbUm5mk7bRlYasJmvEYr2acMmmlDKzKa8DwhsSfFMfqmCmToxSubD1xvIn7a7eex11bMXjzh322Y/9e+O70ekONmaQJv5l+2gjjuOrjZJPFULIgYSQ1wC87rzegxCig8EbAFRVxGD5K0PkQrsaXTAKIyMwCwXE4gl75oIqm2hAOFdIh7FbBYFerPFkEu3dE9n79LuCPjNakFUqcsB1KiN2ezMKecHWZhQKGO53f0+em/Xhj3XQbBg/AOzbuAH3Xftt/P6ab9rrV+Q1URIwCEopviO1T0lkiayc4rfJb2aZojZkk5jZ1Ajgr0U/dUipjA+XxGmM38SDFVam6XbbqAEBJCsI6HUxHmaJ6gHZNhdF2cRfe41C+kaF3yylRmOjlAqUlKlsklVKzEZnVTeziZ+AAtz7nNiNzukO6+lG573WWGaTz3gxvI1OfF5rZVNpjD9lk7cbHT+Bxuc6ajQO+C5p9B7y2hOPY7ivV6irGvFZSFVDk+dsV/G6OiZNxl5LjwUA7Lj/gZE/7xcQLtet48FGF6ZS+QGAIwHcBwCWZf2bEHJwTbdKIxTkGdaggYxcGHjygspA/xbbd9o5ZQoIIW5m04BX2cSCpEfKUzaxh5Zz8W6/12KsePGfWLDf+30/M9oZAiQWQ2vXBAz39QIQJZiAV8ViFgoCAfTyX/6EFx74PXvNSy15y2TQbILq5r/m9Vec7/Me821rV/uuiyKI0JB/UyGf8/5OOrNcguyRVVfVAD/YbpRMCcFG59eNLhFsoys2so0uztvoqPqodjY6ObNJK5tqA7lwjdSNjjv+iaZVNvl3lmkI6JgyJUqpQN18vIiZTdLzSrbR8RmMMdaNLvoziM/XLBome57yEz2usql0QHjJzKaQ909ZdauVTaUhEysNey8JiY3vvo2uqdN9c1hdsinte/0VzeK4KLabCZSgJ3E3s+mVxx7GxnfebPjMJqamq1J0ypJPno2d338wpjoNsKIgzkVK8PCQTTXo1txoCPULLcuSK1JNRTcAPnLh1wT1TNAMgVwYFBQql6jo30zJpmn2dzAbXb/z2i2k6cCo3BbNvLIJAI694Ks48rPn4wOnfsz3M1G7y1QDH/rUZwHYBXerFAguK5+sYhH5rKteGu7rFfZPzk/ZFJTZFEA4UhVV+6TJ2OOIYwAAOx7wAd/lKYImOuXWoqqZOpbZVAdlE49qWUcrhRAQ7qds4kK2VaAPr0ZRa/GIc0oBV4FVA2WTMzNPiyNDK5tqCrnJQhRlE39MSpHOjQq/gaNGY4MR8z7nHSlhWfZfr/28oteBGxDun9lUzoQHtcEDdlcjpbKJdaMLHxDu97zVAeG1g0fZ1IDFelisfeN1/OLSC/DLb1zkuwxf+Md9Ji3rMU7XCIbFuRF40mbzqpViZlOh8Y4d7dIepYFJEAghmLXzQt/IiyD4BYRn+/vE5cbBmDXMqG81IeRAABYhJAngfDiWOo36Yt4ee+PzP/klrj3dlvkFPezlQsGsAtlEE/W7pkwFAGajM1houFuMUFJCzpkKC5bZ5BTqyZYW7Lrk8ODP1KEo2Pn9B6Fj0vdQGMkJ4dSAOp+HH0jK4JVNPAkVbKPz/81slimZxGGfOgfz91qMafMX+C5PEeDO9GQ+8YTOyOAgjEI+dGZTpZ16SkFlI6wHBGWTX2ZTicK2kQPCWfFmmDUNCKf3NDorSpV7WtlUG8jKpih2OJ5sbFYbHb1/NVo3OgqipU1KuM8fn4DwWHkWN1qQpTIZGPkcG/eoM5vKs+oBQI5TNpmmyaII+EzIWJSAcBJMNvGzS5Zl+ZJP8m/xy4DScOElmxqvWA+Lt597GgDQs26N7zIFoRudn7JJnzeNBnpt88omCkHZZDYeWWqW0cCkVogzlb+4n4YlsqkWyv9GQ5hR+WcBfAHALABrAezpvNZoAPADgaBOJ56A8Cp4xfs3bwTgVTZRiDY6+99lZzYVRGVTGNRrxmTmTgux3e57ega3yXQa+x1/CqbMm89a3v/i0gt81yNmNrn7Tb5x8Qh6cPOSZhKLYf7e+6JtQnfgb7HhzzbJZAlP6Nx6wdm4+bOfQNaxVZbqBjR9wU4htqV8NAzZxM02+2c2uSHbKoQl8OqBOJfNYLHCq3oP0+O/8g1MX7ATPnTW2QDcrkyUnNXd6GoDWR0bqRsdd/z9ZrgbHa6yqfEG2Br+MFk3uuCAcKtY9M0xUoHem+n9p8BsdF7rcCWZTYKNzjRYqHKGU07TZ6uXbPLed93MJjXZxG9j0BjKk9mklU0l4QkIb+LMpqC8VArRRuenbNJkU6OBqUFjcc89pdJudC//5WG8/dw/PO9vfm9FWSHcMli33AaY1PKz3mtlkwRCSBzA/7Ms68xR2h6NChDFRleNzCZZ2SR7ZJWZTRXa6KL4cOv9EJMHt8l0Cz740U/igx/9JG789BlsJtQPgrKJI+mMiJlNFPQhEfUmzA/Adz7wYEyaPYe9lm10PKEz4gxG1r+1HIC/jeEzP/wZtq1dg9m7vC/SdoUFITFYVrEmmVDlIFRmExeyrQKzJvrMFtYT9MHZs34dO4er+TDdYZ/9scM++7PX9N4y4nT40PkPtUHcY6MrbzDXrGSgnyS+YRDS/jTeUErZRAgBicVgFYsommZoa3KRKZvsJhSGFBDOTwSSCjKb+M5FRcNk9nrepk/PTf7ZEosnlKqkUplNfDFp5PO+3SNlJZNWNpWGfPybmbgecbpOB0HoRueb2aTPm0aD0I0uQNlUylL+/P2/w6Q522He7nsBAAa2bcHDN18PALjwrj8Ky97xlXMBABfceW9FHWsNJkyoTmZTJQgdED7eySbLskxCyHaEkJRlWY0hC9DwRZSA8KJpomiaFZ3kpZRNibTKRldeQHh5yqb6PsTkfcvvjzCzQrnhYSZj5zObggYofoVQITfCHvyV3IT/4/yvCK+9yiYvgbbNkVn7nWvt3ROFDoPVRiKVKpvkrAVCZTbFg210tIBqRJUIPc48WVrLhyntOEgHv81KZjQ6PAHhZcrUSaw5SRHdja45USqzCbDvT2axiGLRRDxUuoRLHKQp2eRMtKgym2KM4Klc2ZRjyia3AQldP0+U+U1ElMps4icijXwe6dY25XKezCYdEF4S8j43mphsyvaHVzYlUylfAqHe43QNL3iyiZ+cjicSUkC491lIa5Ytq1bi8Tt+AsAlloa2bVN+H39dGPlCRWSTyVk36w2mhjZlZZPcjW7sj1nD/MJ3AfydEPINQsiX6X+13jCN6kJot06zlQp5mIaBP//0R1jx4j8jr5MFhE+lyibxBsGrXlJ1sdE1Ftkkq4BKoWgaTBIaNiDcT/aeHehnjH/Um/DMnXZBpqMTC/Y9wPM3b2ZT3tkOd99vXbMKQP0sX43w0OHBnxd+6pB4iYwPeg40Yv6N6jjXUm1ElQU022Q8dPaoBzyTCRHPvYzTnTOcdbfxQDt96UDb5kKpbnT23+x7VlAUgWe9zrJJyUanymwiFdjo+Mwmo1BA3pmwy3QolE1ckeY3EUHJXl+yyeCVTf7qa/m36G50pSETcs1MXPMTpn72U8FGpzObGgaFEs1y3MYucUmJH9wQKJ8dxk8vOBt/++VtQp2SdSYCc1xDJGE93DlQaWi+UaaDoxZgOY/SdS5nNo0HZVOYUfk7AP7oLNvB/afRIIh6oiYc4sfI57Hm9Vfwrz/9EU/f86tI6yiaJob7ekFIDO0TbFWKPNPNW4SYja5MZZNRRvetenf6kIvusGTT3kuPYzkQNLcpdEC4oX5wZwcGXC9zRPIlmW7BZ2/+OY678GuKv0lZYM7gQuxYQcPd63NDbYSgQB5E0RLbswwXsq0CfXg1Ymcv1aCylmojSjZRBcB4CFusByrJbAKAs2+6HefdfndFs5b1BH3ONnOo73gELWSCVKCUoI5ikaQFWVq20akCwqmaqMLMptzQIGBZSLZkhOc460YnKJt8MqpoQLgfQcB1mArKOfQqmzRpUAqegPAmzWyyLAsD27aw136kJG+j8+9Gp8+b0cSLD/0B13/8JGVuEgWLaYjFxYxRabwvPwuXP/U39G5Yj+d+f7dQf21ZtRIAhO7bFMP9fRjq2cqts0KyqQoOjmpB1cHWNAqe/TAexqwlKxXLsq4YjQ3RKB+xWDzSDZsWDUY+j75NthUujCSWB09c0EGV3GqSt1hRZVOhRE6RH8pTNtV3pk1WWFACCQA+etX38PtrvoXhvl5hmfbuiVhy1tl498XnkM9mkRseQtuEbhg82VSusilX/k3Yj9BM+nSjMxSZYPVTNjVucetHwvAh2yoUyyBfRwsygbbo4A8J5361wQLCnc6O40GSXA/w914Si0Wf5EgmgQaYbSwX9FrrWb8OhZGRsloh1xI6skkNltkUMNlB71nRlE32+CLJJu9ydsi4ykbHlKrRxyR8x9phZ5yWbm0ViSXajY63vPhlVLH8KJ+JDCmzyQ8eskkHhJeEvM+blbjmx5OAnSmqmkw1+G50PuejzvoaXfzlZzez/6vcCoCobOKbSZXMHOP4ayPv/m3zeysxZ9FuLG+OX9dNnxEjoc1C+ddE0TRhFYsgJPr4pBZQBYSrOpA3wrbWGiVH5YSQPxBC7pP++zkh5HxCSGONtsYpSORBv002mIU8s8KFCfvjQR8iKnsehRAQXmlmk0HVMeGLlVk7LwTgZkqNNnhyhZCYYB+ZudNCHHDS6Z7PJJ1ZUpqTQPMZBGVTGZlNIwP9TPbMt0yuFHLBRVvdNhLZVK/jHwZ+xIjbvSjY6tCQZBNX1O10wEFY+oUv+7bPrgZkZZMmm2oDnqRuNLXgaIAOHNcufxW/+u+L67w1GmHBZumDlE0sWyO6jS4WT7DrwSjklcomUmZm0z//8Fss//tf2Wv6DE+3tgnKpXgEZRO10fkGhBshySYdEB4ZY6UbHa0bKPziMUQbnfp8bFbCrdkRFDfAZzbluexN+TjLx45XSxoFl4zcsmoFALdpEGDXKqp6pZJrgtYd8VSypmPOsKD1Kr+fVCpATTbZeBfAIIBbnP/6AQwA2Ml5rVFn0KT/GTvtEmp5Kr82CgUW8j0yPBRpIOR2h+PDjkWyiQb3Ai4pQW9WLzz4B/z6sq8IXdYAu2Bcs/xVj8S7HGXT+085A4f95+dw+pVXh/5MNcHfQNq6uz03lJa2ds9n0o5Kg+67/LBNzhVGxMwmPwm823lHfLBnBweYiqqamSl+mU1m3vvAqNcN9YhzzsP8vffFaVfU5zwIgp+yKeYTLEjBMpsaMCCc36a27trn81AbC8V4kCTXAwk+2L6JFUrlgi/kN7+3oo5b4of6D64bEfwsvR+osikK2cQUTPE4s5cUcjllZhP9biui+ufFP4kdmyjZlGptFa5BOuEYl8J8VSgdEK6VTbWCx0bXpPlvfIdEwH8SOUw3Op31VR8Eke8WRzaNcMdaPs5BRKEpKJvs52WWEzVYpqkkqCux0fHkZiPAjUPh9qHC3TMeJkjDVCoHWpa1L/f6D4SQ5yzL2pcQ8mqtNkwjPI445zzM2HFnLDr4Q6GWpzPURj6HPjpDYVn4/TXfwk77fwDvO+SwkuugUkc/ZVMy3SIqm6TMpsdus6Wcrz/5OHb/8FFsubsu/yq2rFqJ4y78L+y434Hc90UPfUum0tjzyGNCL19t8IPNjomTPX9XkU305pTKUGWTrdbgcxtgWb4tmuksbiqTEdRq2f5+DPX2AABauyZE/CX+SKRS+OAZZ+Gp/7sTZqHABheqB0a9VDidk6fghEsuq8t3l4LfAIwWP35KNaZsasCin1datk2oXZdBCtmipwPCawPeJh1vsND90UC9lJkalYF17gzsRucoj8rIbIrF40im0hiBY6WzHLKJ8JlN5QWEy/EGlGxqaW1jgfWAS/CrrHUyXLJJPWElKJsK/rEHsuVQkwalMVYym+Txna+yicZtpNO+159WNtUHQeS7yZFNQdd1EDHEuxtoIDZfk5imoVQfVXJNlFMn1hK0xuPrN0NFNmllEwCgnRAyl75w/k2rZP9pD41RQ0t7O/Y97qTQihWaYWPmC+jf4sph333+WTx04w9CKZxoe1yxjbtbgLR2dQnLJ7mZPx6yrJgGya389wvsvZ71a/HY7bd4vq/Rwd9I27q9RXdaQTYlW2yVRotjdaM3qazUvcCviwkdWMv2tuxAf02UTQCw30dOxr7HngjAnVlQzYiOhxtqWMxetCsAYM77dlf+nVrRLNPEmtdewYM3fF94YLkB4Y13PfBZIe2K877aSHmUTZpsqgX4/VzL7oKNika0rGqUhmujK92NLoq6m1lNYjGmbDLy+RKZTcHrH+7vw7Z1awDYhVwhNwISi+HQT3waAK9sahPus/R5wY+P/CcygpVN/LM72EYnfl7b6ErDY6NrUqJFjknwVza5mU1+E2M6WL4+CLofWhyRftDpH0e6rU25XJCNjq/1aL0yMuCSTUXTVJLv1bDRyZEu9UIinUYsnoBZKLAOgKpOgFGjcJoRYUblFwJ4khDyGCHkcQBPALiIENIG4PZabpxGbUCVTbnsMAa3bfX8ff1bb5ZcBw2N42e4+UyPTKdINqV8utH5DeD5Lme/uepr7uxkgzDWUaEieFraFWST87vp32iYnNwq02+QQmckZHtbbnioJsomCj6zwv6/ykanizWKU7/xbZx3+92sHbwMOlNtmgbuuuKreO2Jx/D03W7HSLfDX+PtU/44j0ab+3gyKXynJjVrg4kzZ+ODZ5yFCdNnYMf9Dyz9gTEGfV41J0wfazkPRgZFKP6psofE4myirZDLBWY2lVL/3PSZM/GzL30WQ7097Jnf2tnFSKQRltnUqiTVQ9noCM2PqjCzydONTiubSmHMKJuk7ZbjMChcG10asVhcec76ddzVqC3o/XD1ay/j1vM/g9Wvvcz+xmc2dc+YhU//763KdcgB4fx5wVvHaF3C2+iKhqEkm4wKbHSmIku4niCEsFqONrDh83cpxsPkXZhudA8QQnYEQAOB3rAsi+6t62q1YRrVBc8404FR74Z1gCL7Z8WLz7FwbT9QZVPCT9kkkU1yZhOF34AokXKVOYNb3RarjXITiQol2aRQNtH9QZVNdCbTSzapb8h0sCznZ+WGBjFUI2UT/33MRqcKCA/oBjTeQGKxwG5WRGHrGOzZxv7d0N3oBBtd7ckmQghSra2sENPKptqAEIL9PnIy9vvIyfXelLqgEa81jdLgCyc/xGLBBIxyvWz2P4YknWwpkdkUZKPjx2gDW7cwZXRrZ5fn2UkbiLDPOpa4aDY6v8ym4DBbCjlPUJNNpeEhm8aIsikfQtkE2ON32UaklU31Ab2n/OaKSwEAf771Jpz1/RsBuOQQzb/0ywaVz1/+fsFnPdF7BR8QXjRNEEX9WZGySTrfGgEtbe0Y7uvFyNAg2idO0jY6PxBCTgRwDIAdnP+OJoQcRgiZWuuN06geEopspa1rVyuXXfXKv0uuTxXYzV/gsrKJFtaF3IjYSpO72fAPYqrwkQdnzWSj46EKSlbZ6OjNnXaMGxkcRLFoMtKJFu++ZBN9SEhe6JGhIQz39gIAWidMiP4DSsAlm/y70TVimHWjgu4r/vznjygLCG9A8pUvsmqholOBV/KNh7BFjdFHPusWVElJOdoQaIDuO42IMMR8ed3oqF2OCwjPq5VNjMwKWD9vlY8nk66yaUK3hzjykE1OTlSkgHCrOgHhbH0R86jGI7w2utorm3rWr8Vff/FTz4RlJZDb06uUTVaxyGXopIT/C8vp86YukMfj6bZ2Vo9ZEkEftpMgP+4fEVRMCmWTn42ukoBwGu/SIDY6AEi3i7lNyoDwcUA2han+lgF4P4C/wK53DgXwPIDtCSFXWpb189ptnka1cOCpZ2L9W29g3+NOwupXXwIAbFu7RrksP6j2g5JsSvKZTROE5fmZv5yQPePeWHLDw+zfdLajZ8M6YT25YbELRrNApfBQDQZpUKlroxuwrXSWhZb2Dha67sf+0xkEPpwUAPo3b0TRNJDKtLJjUU0wGx3tRqe00Y39G2q1wDJESnWja0C1BSEE3TNmIjsw4FE41gppLiRcd6PTqAW6pk5n//a7LjUaD+GUTVR5FMFG54xRSDzOJscMzkYXNbOpf8tmd5sNg2UstnZ2CflMgN2NTtwY+j3u88AvByQos6lomgIJFSaziapVtLKpNOqhbPr1ZZdguK8X/Zs24tgvX1qVdcrjO5Wyic/PoZOfqskxvyYoGrVFLB4TCMih3m248TNn4shzzvPcM/3unR47ZY5XNrl1HlM2DXK1n2kgZnknBivLbGqsgHDAdbDQulelFh0PE6RhKpUEgIWWZW0EAELINAB3ANgfwN8AaLKpCdA5eSo+9YMfAQDWv/UGALAgylg8IQyywszuGSWUTa1SFg2JxZBMt6CQG2HZQYA9mHnzH0/i9ScfxwEnnu6+79y0tq5+T1hPz/q1JbetETFt/o6hlqODRTcgfIANOjOdXeyhrRqkWE6XOgCeLtg0m6utBqomwGujU2Y2NSAx0qhg3ZF88gyoV75R9+knr/khADJqlja++BoPD26N0cek2XNw2hVX467LLmkY+4ulsCFoiAiT2URC2NxkUHIlFo+zyZZCPseOCa8uDpPZNMCRTSZPNnVN8NznPcomeL9TFZHALyOTQ0ahgFf+8rD0XmllUyKZckg2TRqUgryPRiOziZ5Hm957t2rr9ASEK3JoVJYmlTNBK5vqg1g8gXVvLmev+zZuAAD8/ppvskBwSjIRQhBPJDzPPa+Nzj0vBFGBaaKQzwlES9E0GUkurCPgnlMKLN6lwWx0gEu0qZRN4yEgPEylMocSTQ42Oe9tI4Q0Z7rdOAdtYU1l25PnbodNK95hfw8zu0cVSbyaKR6gbAJsK10hN4LBHjeU3Mjn8YcffBeAyHrTm9aW1avYe4TEsPiYE0puWyPhszf/HCODg6G7ctGbewtno8tyQaF0BklV7LgWupjyJg4ArV21ydChN3c6eDJ1N7qKoOyOxBUSBlM2Nc4MDo/R3i6+U9p4eHBr1Aezd3kfCInBsoooFs2aB3sWRkYw2LsN3dNnKv/OkyO69bwarBtdQGZgnJFNETKbuG50vLJJmdkUK71+vjNw0TBYxmJr1wTPszPtUTapHvg+ZJOzLTJR+fwf78WTv75DeC9I2URJAjrhqJVNpVGUrItywHJNUUVemo7zki0ZFEayym50zNIkNBFSKZsag7gfDxBiGQjB5pVqAlLVwTMW95JNckMFMbPJredgWXjv3y96P6tgIGSLZhQYeW9dWm+kJbJJZzb543FCyB8JIZ8khHwSwH0A/up0o+ut6dZp1ATyhTh59lzhdZgBl6FI/Q/KbALc3KahHlHZRLHm9VfYv2l7yP7NNs95+Nnn4tw7/o+1jG8WtE3oxqTZc3z/vsPi/YXXXrJpQOpK43QpU8yIUZIwloiLAz+OpGirUYZOIkltdP7KJp3ZFB60MOKVTfysNR2kNirZNNrQmU0aowV6bY6GuunOr30ZPz3/bGyRFL4UPBmtrX1qFCMpm8LvwyIXouvayF2FD2/nJRFtdKYpKZukbZe7zaoUbn6iN1dlJW7L2jde8ywbGBBepMqmpLM+TTaVAt1HdAw+MjQoxEfU9LuryDbRyeZMhz1OlRv/AGrCIqFQYmtl0+iBV6CZhqFUpAFc8wPuHsZHNlDlk5yvxBMpfGYTADx9z6+E10XTVHb/rETtZyoIznqjxZPZND670YUZlX8BwM8A7On8d7tlWZ+zLGvIsqwlNdw2jRpBDk9rlfKEwnSHMBXFLv9QoRcYDyr97tvkCuVUXcsAl4SiksNUJlOTrKF64yMXfg1f/Nlv2OuJM2cDEAPCGdnU5ZJNqps0CyyNJ4SBHz8L2jYxnMIqKljrZ5bZZP+fZkwBuhtdFNDMLd8Q1wbObKoHeBud7kanUUu49+DaF0lb19jK3nVvvq78O78NUSxg4wl0v8i5RzzCZCrJsIpuMc2ef36ZTSECwgf8Mpu6vJlNNJCcbYuSbFI/O/wym2RrHhAuIJyOJ/X5Vxp0EpCeL+vfegM//vxZWLvcS/RVG30bN+DxO34ixFiUCzq+yzhxGX4B4YB4HaiUTVoRN3rgj5NpGL4TJky1yY3ZeSsvO+6SSkcICB8S83U3rXgHyXQLpsydx75Ddb+tRkB4I2c2USEFfw/XyiYAlo17LMv6kmVZXwKwkRDyw1HYNo0agVcgERLD+w7+EAA3xFpFZMhgXSZS7kXNKy9SLa2ez3RMmgwA2MZ1wTPyeU+Ytf1+Tvh/YgwSTYBdGKdbW/Gx71yHg07/BN536GEA7BtRPJGAkc+hf7Mtr890djFyz1DckOmsbDweF2Yt+UFke/ekmvwOTzc65/+8wi1oZllDBCHEd39ZlsUGCZrAs8Hb6MbDLJFG/RBz7sG17iSVz7qKB5VSGJCVTbpoU8G9VwZ0oyvHRscymzgbHZ/ZpAgID1L/8DY60zQ5RbM3s8kzHgrvogOJqTObVN1xw5BNVKWjlU2lwZRNXKGZzw7j99//1qgoJZ+//3d48IfXVrwew7E6UQW+KiC8WPQqm3iyiV4fjZJ/Nx7Aq2qKhuGrImIdNbnajBcW0DgO/hkFSJlNXCwKRaazk91niqahvN9WFBDOHDeNpGyi+buija6Fq8vGgxo/1C8khOxFCPkfQshKAFcCWF7iIxoNDN5G1z5xEibPnYdP/+9PcOZ3fgAg3OweCwiXbDw77n8gps3fEd0zvRkT7RNtsonO1trryaO1yzuQphekKmRwLGLa/AXY/4RTWaFMCGE3qTWvvQxAtNGplU10NiIhDCQFsmlircgmqRsdk1m7QfHjgb2vJvyIJDtY0QKJxTSx4oAqAQGtbNKoLVi+T42LpJ71bidW3+6j3DZEUeWMJ9BnUbW70bmZTVxAOKdsEgPCSweQD2zd4q7bKCDvdN5Nt7V5tl1WeatUTH7h8cxGJ/2d7+hJwZ+DMlxlU0J4reEPS1I2UWT7+wIti9XEey+9iH/96X4xUycioiib/AgLes3oYPnRA69EMoxC4IRJLB4X7mH8eJR2GZY7l/PrV92T4okEu5eZpqm831akbGrAejEtK5uoW4ery8ZDzqjvVA8hZCcAH3X+2wLgLgBEW+eaH7waqXPKVAB2W2c6OxHGHuAqm8SL+rgv/xcsyxK7ojjocIgO2gUPsG8OqtkzWSHTSDeP0UJLeweGenuw4Z23AEIwc6eFWPXKvwGob8hsBjceF210baOpbBIzm1o7XbJJZzZFg0wksS5C1ELXQFLheoO37WpSU6OWoCqTWhfX8nNSBZ5g0tknavQ6hEnn5Km+y7jKpgg2Oq49OK9sUgaEM2WTT3fRoolsfz97bZomK+RSLRlk47KySRwPqW10JcgmSYlUlMYMhZERbFrxDvLZYUE5ypbXAeGRQfeRKhJiNMm6P//0Jqx94zUcc97FZX2ejv/phKgqIJzv1kghZLwmkyiMZGGOgh1ZwwZPChYDbHSA14nAj99pV2uvsimYMI3FE9zz01DWiaq817BgdWkDjY1bnPqLBYQ7+4ivy8bDmDVoCng5gA8B+A/Lsg6yLOt/Aei7whgAL8GeufNC9m82uxcms4kGsSkCilU3EMC10fEwCgXlDUomm8ZiXlMp8JLX4y/+OqbNX+BaOJQB4XTwmxAGmqKyqbaZTUzZlBdnvgBt+YoK2TpBB286r8mLlnb3PNPKJo1agjVpqLGNbtu6tezfvmSTzmwqic2rVgAApmy3ve8yjAyKsA95UonaosrNbBoZGBCUAEXDYJN/qdZWz73ea6NTEEs+ZBMd58lkEz8OMw0D07ZfAMsqYt0bPnlhUti1ttGVhqtsqi/ZBNgKp3Lhkk32JI/q/uQG6KuVTTTEWSubRg9iQHgh0LIWi4vjKP4eRLuNy8qmINutvY6kS+wbpvJ+axYKeOvZp/DSow8FrksF1gGxkWx0bXJAuMpGN/Zro6BR+YkA1gN4jBByCyHkMABqFkGjqcDPLszbfS/2b1UHLD8wG10EBpna6HjYMxsGCInhmPO/gu4Ztv2u4Mlsapybx2iBPgjauydih33srnVuoaOy0VESIo6jPv8ltLR34OjzLkaam5UcLRsdvelnOnkbnSZHokAOhaXngyqcf7xDUDZpskmjhqD3sVpnjfQIyib1jLGQ2aSLNg8KIyPo2bAesXgcE2f5d4XlrR1hUeSVTdzzT6VsIk7h5qf+GXLCwCnyI1mYhYJNZCVTnpnvUAHhPqFNTCHrIZvcwtPI5TBr4fsAAGuWv6pcjyUHhOvzryRUmU0Uo73/eGVFVNDxHS2kC4r7k6W4Dvh6IZnSwfKjDYFsKpRQNkkESIwbb2Y6uwBCUMiNCOdtabIpwRRSRdNQ3m9No4D7vv9tPHLLDaxJQlhQEUQj1YtJp3MofYZTsonPyBvXyibLsn5nWdbpAHYB8BiACwBMJYTcRAg5YpS2T6MGyHFe7Zk7L2L/5jtglZqlogVvFLlixyQv0UHZ3kQ6jV0OPBgnXHIZAN6O1Xg3j9HChz/zRczddXecfuX32HvxgHDaIrPRJTBzp13w+Z/8Egs/cIgwEJVbJlcLso2OEiOZDj4gfOzfUKsJ2cdNj3mYwNvxhhYus0mfZxq1RJyz0b3+xGNY66P8qBR8YHQ4ZZNWlsjYvGolYFmYOGtO4FilLBsdUzDFkXC6rhr5HKCy0cWClVPDvb3Ca9o2PJ1p9TaLIISdg3svPQ4AsM8xxys2MNhGB2mMJ3cGnr7DjgDEjE0etMik+1Urm0qD7TPFeNYa5etX1X0QsI/jyn8977FI8aBjEFowq+5PlsJGx+fF6i6Gow8+U8kskdkkjz95Z0Iy3YJUi33P4615JW10iQRbr183Ov5cimrNpYR5ooGUTbJAgOYR89ffeBizlqxWLMsaAvBLAL8khHQDOAXAJQAervG2adQI03fYCQDQPXO2MACzBzVxdhOIBygEzHw5yiYF2eT4WOnDlypkejesx20Xfp51Yhur3eiCsGDx/liweH/hPbq/+VlICpObaQXcGUy5PWktEE8kkEinYeRyyA4OMOUbr2zStq9oKK1s0vuTItOhA8I1Rgf0uuvbuAEP3PB9AMC5t/9f1Yl8PrsiTGZTlHDr8YLN75W20AGlM5VUoPuexONs/FLI5UBa7PuPKrPJr3ga7hPb0Y8M2GRT0gnt5gu9RCrFnu1LzjobB330E0g6ZJcA3250apWVfI4lSihP5OxATRqUhtUgmU0AkG715nABwLO/vxtP/voOLPrgEiz94oXKZZiNjpFN3jGm0kaXdMcspc4vjerDk9kUYKOTx5/8eDORSiGVaUU+m0U+m0W6tQ29GzcIuXMU9nLDbB1xjmyKKY79yAC3Dh/C3A/MRpdqHNV/TCKbqAqQv/7Gw5g10i+0LKvHsqwfW5Z1WK02SKP2mDZ/AT5+9fU481veFqixuDtrG4RyrDzJdIugQADcGwsN2ORnfPgZtfGobFKBzSbkvN0/aLEh29VUy9YCk2bNBQBsXfWe261EyNIZ++x9NSEfR3rNsUG+ttExCMomfZ5p1BD0usxyg+LXn3is6t9jCmSTj42O70anizYP+jZvBABMnDErcDlmo4sQVuza6GKujS6XY9lLgo2uRGaTbKPLOsomSmDy4bwyUaEkmuBvo4v5BIQbkrIpVqKDns5sig6/bnRAHWx0re3K95/89R0AgNcC7mn0XKFWPEMxoanKLhMDwinZpEny0YKY2RRso5OVTXInQXpvymeHsW3dWtx63qeVHehSXJdLuxudQ7742OiGOcIq6jXBGko1lLLJIeOd8buhbXQa4wlT581XzmzQULhSA1d6UccjkkDd02cKr11lk0M2Kbzs9t8b5+ZRTySZdFXR/cMZKMtB3DN23AUA0DFpSk23bfKc7QAAW1a/x2bl+eNWrHGg7liD/ABylU06IFwGX3Dp7BCNWoJed7zN5OW/VF/ozVscwmU26WJfhtwxzQ9uaHYZZBPhAsLzPgHhTDnlp2zqFV7TSbiUM0YTrEhhVd5+NjqiJpt4G90HTvu4YHdRwduNTt93S6GoCAin95PRJutK2fAnzpzt+zc6Fkm3tgGEwDQMz/Gnr/nJHyEgXCviRh3RAsL9lU3JVJrdm/LZLDa886bvevhOlrFEUsgGVtmKh/t72b+jWsNZZlMDkU3093qVTdpGpzGOEVXZlIiorjjycxfgrWefglnI4x+/vYsx4UzZpLhJEBLT4dIOUi3uDV4GCwiX9tV+x5+MTEcnFuy7v+cz1cTkuZRsWsm60fFdIZI1yosaq5AfQIa20fmC74CZG/bPmtDQqBS0SMtzhP9Qb4/f4mWDn3U28nn86+EH8OJDf8Cp//1ttE3oBiBmNkXppDZeoAopViGWCDfuEdft2ujo+MXgutFRUgco3emXkk3tkyZjcOsWj7IplvDaj0puXwkbnaxCKDjP7JP+60rM22NvrH71pcBtlskmrWwqDUZEcsezY9IU9G5cP+qki4pooLEVANA9018NyBoEJZJIpFIwcjkY+bxgJVYF5fOxHcxGp8+bUQMfqVE0TU9OGw9PQHhctPLSY53LDrPnkQp+yiY7INxLsmT7+oRtjIJyGlfVGnxmk2VZnLJJd6PTGMcIG5RJH1RRvbGTZs/BASeeht0/vFR4nz54CCEewonPKBjvoDdunmxa/9Yb+MWlX8K6N5cD8JIUyVQaey89Fp2Tp9Z02ybPnQcA2LzqPS7YPYmTv/5NHPm5C9A1dVpNv3+swWOjk5RNMW2jUyI3PFTvTdAYw3CVTe49uBaFIl8MFvJ5/PnWG7Ft7Wo8d9897vcKmU2abJKhUhmpECthc1OhyAUg0zGLUVB3oys1rqI2uo5JdsdemtlEn/dCoeej/pahsrTw2yUX+TSHM9NhW99dZZN6PXJA+FggDQr5HP718AMY2LalJuvnz8fjv/LfOO6irzHlx6iTTQql+do3XmP/DtoekynXk55OxBTKbnSCsskhm2rc1VPDhayQzY/4R2zIdQQ/3kyk0+y8LWSzym6YAABCBNuvTTbRe21RGYrP23mjKE0Bri5tILIpFovbEw+WhaJpsGPAdwkfD8omTTZpCAhLNvEzG+VAvhnwsmJT8nBrC50LOvjkbXT3ff9b2PjuW8xrX68uZdRGt5Wz0cWTKWy3257Y9dAP12Wbmhn0oUzButHRgV5SK5tUyGtlk0YNQUlg3kZXi0LbL7OJV1QJ3ei0jckDFfGjQjnd6CgJE4vFhc+riuxSmU20G13HRJtsyg46NjqnIOHVyqXGQ0u/eCEyHZ044uxzlX8vldlE1+9mNqnJAIspm8ZO0PPTd/8Kf771Rvzy6xdh9asvVV0ly5+PO+yzH3bc9/1u8T3K169K2dS3aaP79wASiM9s5fPKeLiZZpyNjhv3J5myqfnPm2aBTBznFXEcFEE2Ojsg3FU2+alqE6mUUI/EJGVTqXtG1HtKI5JNgLvv6P0kkUoL20jiY5+K0dWKhgB30BQ821DpRe0NuXRfy4Og8diJzg80s4l/SBSk2Yp6seRtE7qRSKaQGx5CbsjJ4mog73SzwU/ZVNTKpkDkAlo2a2hUCtdG584Kl7KwPXTjD1DI5XDsl74a+nuKko2OvW+qCaaxUOxXG8zqRkqRTU4BFKHwtbhimtnwDEOd2RQrkdk0YFtHaMfe3JCtzkwputElS5BNiz64BAsPOtRfDc69bxWLjAgzJOt7KQKOFq6JMWSjW/v6qwCAwa1b8Jsr/wvTd9gRZ377B1Vbv5KILKEgqxVUyqah3m3u3wPyfEwus5V1YpTGoUplU1KR2RQhlF+jQkhqx6CJucDMJk7ZlM9mhW7APBLJlEg2St3oStWZkcmmBo2YiCUSQCHPmook0mmRhBsHNrrGOiIadUd4ZVNlQWyy/S6IUNLKJhduBwiXbGppa2eDU8Cb2TRaIITY/v1CngW/N9oMQzMhLgW902tOB4QHI69tdBo1BL3ueHVp0PPSKhbx6l//DMAu6MM8zyzLgiEEhPuQTdxg3SoWYVmWtpxzoPaO0MqmCJYeSkyRWExUNim+s5R6hR7fljaxQxi1WsQEZVPpybegc4AQAkJisCznfHHed8N1k853OgSZ4ty2z7UiQEhZeVeNCrmD34Z33qru+oOIyAbIbBrc5pJNQdeCwWW2Ulunn43OLyCcdaPTyqZRg6zADSJ7PDY6qUmBG+kx7HvtJ5JJ4d4VTyTZ/cI0jJJj2Kjnhlmh46ZWoL9z07tvAwC6p88Q6jRto6sQhJCjCCFvEELeJoT4TukRQk4ihFiEkMXO60mEkMcIIYOEkBu45VoJIfcTQpYTQl4lhHy3lts/HlGq3S1FpcomW3oebgClySYXbDaBK3RSXFcDoL43LnqsqMUkocmmskGk2Q6zYA8MGNmkQ/MFdE6xM8G6A7roaGhUClkSDwQPivkZ/7BtvoumKSQ8yy2rheXkz2kwhA0I98sxCgJvE6L3YrsrFw0Idwkfql5Z89oreOTHN0AGVYrwYbqA21SDX1c1nu+q3+va6OyxWCxgn/CdxoiPLU/DC5egdI8hIyobwEYnKJuCbHTc+J+O+Tw2OnaOqJVNLCBc37NGDVZRna2kuqd4lU28BTIt1CK8Km+nAw5i/06k0kzJBFAbHadsKnHPiNyNjo6NG6zuoGOGNctt5eT0BTuJyiZNNpUPQkgcwA8BLAWwCMBHCSGLFMt1ADgfwDPc2yMAvgHgIsWqr7EsaxcAewH4ACFkqWIZjTIRdpaKdaOr4KJOcOqmZEDopSabXCiVTTLZVEfFixxeGtfHrmzIsz6m3I2uwR6o9cap//0t7L30OBx5znn13hSNMQw6MMyHVDYVOLudGbKwklUFWSdAGgBGnE5lqu/VKgERYQPC45wNrpx1s3bepuFa93hCgfv+l/78kEcFQokeuWMr3zbcXVflhYmb2+SeL8xG54zLgsaCPNFWqtOehovAPK8akHWq4OYzvvl9AIChONcHe3iySW2jo7lkVNFHbZ3yOa3KSxNtdJpsGm34EcKqbt8lu9FRZdPwMLv2dz7wYCw562y23IQZM4V6JJ5ICPeLUvfbqGq/atSltQCNvFi73A7gn7FgZ2F8r210lWE/AG9blvUuABBCfg3gIwBek5a7CsDVAC6mb1iWNQTgSULIAn5By7KGATzm/DtPCHkBgJ7GriLCKpuq0WIynkwBDmkS1GFFZza5UAWE0xwnivoqm9LSa002lYtMZ5fw2rKKdrta54FaT1KxEdE1dbow0NHQqAXoDG+BI/yDLGxCu+mQZIYhFXp8EZjt928NPdpWnEZH2IBwUgZhQvc9ibsqbT4gXGWVoijkc4KywyoWQUjMM+mWlpRO9PsqRsw+TykZYVmW23jCOb+DSCQWjh6PaWVTBCjPjQC7YqVQKSnpuEJWNlmWhaGeHvbaj2ySXQ10zOeX2SSQFFrZVFf4dahU1Qze+4xLXJJYjFl88yNZIb+uvXsiPvWDH2GotwfTF+yER2/5IftcPJEQ8u2KyRIB4WPMRrd1zSoANtnEk8tVuac3OGppo5sFYDX3eo3zHgMhZG8AcyzLuj/qygkhEwAcC+DPFWyjhgR3hi6kja6Ci5onIoKynzRh4UIVEC7LnetprxKOFSE6ILwCtHdP8rxnFPKsYNWZTRoaow83IFzs5ONXbBcC7tV+CCKlaMgooLLR6YKfR3hlUxnd6IpugUUIYQUbHRupQqApBLUbHUulkp57elKhbIpXoTCRO9LxBALdbjfHSkE2sd/u2mIGtm4R7J4aXqjIT9euWAOySTp28WQS8SS1fIpkUnagXyCnqG1fhpzXSskmI6/uRuenbHLJpvBqQo3KoHpGqVRNgPc+Iz9bkorMJkpQT5w5G3MW7YZkKu3JbBIDwkvZ6MZWNzoASLe1oWvadFHZNA660dXtFxK7Pci1AC4s47MJAL8CcD1VTimWOZsQ8k9CyD83b95c2caOI4TPbBLb5JYDnojgZ/Q6Jk8Rl9NkE0MilQYhMZiFAitc5Id8LFFPZRN3TFNpHVZbAdq7J3re4497o83eaGiMB9DBMm9lBvyfmXwBHlbZRAfNKhtVtr+PKVK0jS4YbPY4rLIpCtlkikQWLaqo6jsoZ4k/J/jiXe4wWitlk2zdohYofkxGAkLNhU58zrree+lF3Hbh5yvetrpCYTtTWdHKXr2KbArZlKcceCYiEwk2bpCVTUOOerKlvcP5bDhlU7JEQLhANqkCwrWyadSgOpfjyaTyffk+Ix8nPtLDJZ+991m+0Y2d2URVoEbpbnQRn2dGg0ZM8C6ETHunMDkBlO6WOhZQy1+4FsAc7vVs5z2KDgC7AnicELISwAEA7qMh4SXwYwBvWZZ1nd8ClmX92LKsxZZlLZ4yZYrfYhoS+OyBIFRd2cSRTR+96ns4/DNf5JbTNjoKQojrlXZmzOWHvN9MxWiAP1ayvU8jGtomBpNN2kanoTH6oISAZybfZ2CcFzKbQtronOdruq3N8zfTMBjRpQPCSyCksonae+RnafCqxWwmpmwyvMom+fv5MGVKNsWTSY+aQJnZVBWyybFuUbJJMXkYNPHoKhliQlHav3lTxdvWaFAFaZeLYoDFshaqRHkcT0iMnet+ZFPnlKn23/3IJkMc+/sGhHOEJIVS2aTtl6MG1b6OJxJon+hV0cvWX1kVxSvaXFutwo4ndCNMsBrTNMySz6vIAeGsLm2ssTG/PfQaEBpIjINJ+VqSTc8B2JEQsj0hJAXgdAD30T9altVnWdZky7LmWZY1D8A/ABxnWdY/g1ZKCPkmgC4AF9Rsy8cxwjz4rGKxKu3XBWUTR1J0TJyM3Q470rNNGjaSUm6Tl2yq3/7ij2NQ6LtGaSiVTUbBzdZosNkbDY3xAL9nXjWVTUWnoEu1ZJSznjS3SS4mtSVFRNjMJkrq5YYGQ6/bkoppSv7T53FMCIEOstHZxyyRTHomEOTAcPv7Ki+kaHHj2ugo4cWRTc62qLKEhLyqEvu22ZEbHqrauiyFtYySdbVQJapsu7TYlckkmgvX5XR19bP8Gnlx/MHIJr/MJu63JrjJaRYQHiGUX6NCqMimZBLHfflSbLf7XkInObmOkM9PXtHmWia9tQevbIrLyiZpnbIiKUqOWbHI5eU1WKdmQdFHa6RxQDDxqNlTwrIsA8AXAfwJwOsAfmNZ1quEkCsJIceV+ryjdroWwFmEkDWEkEWEkNkAvga7u90LhJB/EUI+XavfMB7hSnoD2p5SZUU8UXIQF4QJM2ayf8tWOZ7ptbQ1QEAq7eQ2ObPbdFaSYmIdW78LajWtSKsI6symgnD9aWhojC78yHw/ssngiIWwyiPeKquykfduWIfVr76kM5tKgAbiliab2gEAIxGIhaIUgBz3ZDZ529tT8AQkT/TIeYvpVpWyqfJhu5zZ5NroktwyQQHhXF7VGCeb8tnhqq1LrWyqXcC6ZxxPAFWYPQDkhu3f2TqhG4C/okvuhptI2eNROSC8VDc6V9nUWOP7fHYYz/7+bvRvGXsqPbWyKYnJc7bDyV+7Ctvv5RqLPGST9KxJcF0IraJXxeauJyH8m7eNyplii//jBGl7w58b7JmZTDacUoifRKD7LdPRCQBocf4/1lHTasWyrAcAPCC9998+yx4qvZ7ns9rGOovGGGIhZllUkutysPP7D8LrTzxmryvtb7nSMlsRzEaXFZVNux12JHZ+/wcxd9c96rZtQmaTttFVhNauCZ73zEKBqR4aTSqsoTEe4Gcd9ysWBRtd2G50LBclgUQq5Qlevuc7lwEApu+wo/C+ttGJCBsQ3uKQTbnBMpRNzEZHM5vs5zGJ8ZlN4vcLmU1510YnK5tSKmVTFZTevplN3AQR3WYVgckyWmLxMa88l7PZKsHoZzaJ6yQgIIQgnkjANAwYRoGp0SmJlEynAUJgFYsoFk3P8ZXzvXjSgYdVFK8PQCKbmLKpvN891NuDbWtXY877di/r8354/I6f4OW/PIyX//wnLLv+lqquu95g2UyEsHwyfhw5bb7bAD4s2VTI55SWSXc9fEC4RDZJdebeR38Ez9z7G9/vDEKjdqIDxH1M91s8kcB5d9xdVyfKaGJsT0loREZQBxIKd2BSGdm03e57s38XffzhgCabZHgzm+wZpQ9+9JPYbrc968rqC5lNAQSiRmmoyCQxIFyTTRoao43RtNHZyiZ/heiGd94SXo9FFfCzv78bt134eYxEsLhRhLXRUbIpynfIobgsi0TVjS4mk02uCoQW+Ymk2I2OkJiQZUlRjaw+IiubuI547HsCVO5jVtmkyAKvqo2OnY9cOHAZ4fRh4RlXO2PDuCK3iT8Pqd1NVQfIyiZmp5Izm0oEhNNzrVxl0x1fORe/ufK/sOqVl8r6vB9Wv/YyAKB34/qqrrcRQJ8PfO3GE4CTZrkxyzLJ6p/Z5NroVKQ+T6bEEgmm3rQDwsVjn2nvwNk33oaZOy10limDbGrAeAkV2QTYNVIjkmO1wBh6SmhUA0xiG/AAqEYnOsB+qC355GcwfcFOAvEkI4pvdzwg2WJL6+XMpkbo2scPjnVmU/UhkE0N+FDV0Bjr8Ov26Us2lREQzg+c+fv6hOkzAj83FpVNT/zyNmxdswov/+XhyJ9lxX2Jbj/pdkfZNDQYuvsYVfwQqRsdhSoEmoI/J9wMnJRAJKUyGeXEUVWUTc7+oL+VTljxOZp8QLi8T3iySZ6Zr2b3tkZArtY2ujgl/mqgbJLvB5RsUnSko9lhsUSCnYeqkHD6GbqMv7LJGxqtVDaVec8a7usFAKx+rbpkU5QmAc0Gem3yExg82cEfqy2rVgqfzXR2Ca+pIs7I5TjiXZXZJCmbEpyyyTn2B5x0Oj71g5tBYjF0TJqM7hmz7GUi2egal2yKKbowjjfoqXENAa6yyX9QrGqTWy72Pvoj2PvojwQu02ie7noj1eJmNlmWxQVG1/8mxm9DkDVSozwYRsHN+BgnMyIaGo0Ev+vO7zlVjrLJ4NSLPNk0Zbvt0bvBf8Z9LJJNlUBlW1IhmUojnkzCLBRg5HOhVLmydUTuJKeySlGoM5uSwnK0EYhnW6swiePmBJnONjhjCO5cI7EYs9tYVhGEuNvGEwnyvi2a5phS3eaHq0c2jbaNTr7fUOpSFRLOd5mLM7LJX9UWZ2ST25VMtZxfV0b6u0cGB5AdHECmvSPCL3NhFatLbo5pssk5/wRlk3StklgMVrHoUXYdeOqZGO7vwx4fPkpYh8HZ6FQB4QLZmEiy88E0XGXTxFlzMHHmLO4zzv0pZAbhG08/iX/89tf2djXguNhP2TSeoJVNGgLczCb/i5xlDIzSRaMH0CJ4Gx3fNrkR5OyiRFQrmyrFmd+6FouPPRFzFu0GwC5MBrZtBQC0dXfXc9M0NMYl/GxMYWx0HqWBD3gbHe0SBUAIcFV+bgxPzJTT9SxsZhMgWulyw8N44IbvY9Ur/w6xbrEbHUVYsslgM/IpgchMZ8Rw8A996hxMm78Aex55TMnfUgqezKaCegIxzogQcTxocOoWWWk11rqL5apKNqkImNIdoMuFR0kZZKPjutyq/i6vUyab5IBw1bXHdzukn+/fvAk3Lvto2eP8aivCxjTZ5Cibkj42OgA48ZLLEIvHceTnLhDez7R34NgLLmGZsCQWY5+lLouSAeHc/aKQyzGCUr6HRCVg/3jdd5kSqxo242pDk01a2aQhgV7kQUGmo2XbmrFgZ6x/+w0sWHxATb+n2UAVQ0YuV1WVWTUgZjZpsqlSTF+wE6Yv2Am/v+ZbAOzBX9/GDQCArqnT67lpGhrjErKChcLP7s1bpoKyCXnwNroFi/fHK489isOWfQ7b7bZX4OfKDdttDpTOIhzu78N7/34BOx5wEBLJZOjMJsDuSDfU24Pc4CD+cc+v8foTj+H1Jx7DhXf90bOsVSzane4IYeuWO8nx1r3AzCauExxflMjh4HsddSz2OurYkr8jDDyZTVxIubBcPA4Yhn1uc3+jZFky3eIh8kzDQONpC8pHrbvRkRBNecr+PjkgPMhGx9mQApVNUjdcPxtdUZFPlW5txSEf+08kW1o8KpiRoUG0SlYt39/F3WvDEvhhISu0xhJYZpOC9KOYt+c+OO+Oe0KpE5OpNMxCgeU7KcmmBK9scte57o3X3GWkBgokoBNmKTSijU6TTZps0pBAbxbybMHAti1IplvQ0tbuOwtWbZz0tSux4e23MHfX6nabaHbQ/W4U8m7WQoPcwOTwO43qgHX+yOXQv3kjAKBryrR6bpKGxrhEzNdGp1YmiJlN4QbPBqds+vBnvoCDPvpJtHZ22d2h4nHfGd+xrGziu7v54bffuQwb330b+61+Dx8846zQNjpAVDatetlf0QTwpAEffivNzofNbOKIxTA2umqAkg6ezCZpHEG32zRFAomGQSfTac++VeX8NDNqExDutZb5dbOsBH7ktmujc8kkPrNJRUa566Rkk31u+AWEu93oxPNj8bEnAgD6Nm0Q3s8ND4Umm/hjkiujcUAYNCJpUSmo5TDt3OsA9e8Ma4NNpFLAEJCjZJMqIDwmkk2qSDdP3l0F1tJGtNHxaqt4gwgDRhv1991oNBRcZZN7kRdyI7jty5/D/131NQCjp2xKt7Zhu933bAh7WCOBn0ky896shXoimdbd6GqBpJPT1bN+HUzDQGvXBPaehobG6CFqN7p8Wd3oXKtKLBZnRVgsFkfHpMn+nxvDlvMwXVY3vvs2AGDFv18AED4gHABa2inZNCTklajIk6KikJYLpvCZTW7mYpCNrpqg2100DKx/6w0M9fQAAFqk3By/oq/AyKm057eNNbKpmsqm0c5skslteg3RgtxQdaMTMpsUNjp2b7LXUVrZpL72ZGVTlGwsvmtkdmAg9OeioFHG1NUEPSadU6ay9yrJ/qQNgQrONVJa2ZRUKoPlz1VyTTQiScjv47F4XoWBVjZpCGDd6LiHzHBfH/LZLAsmNUdJ2aShRoL56XllU2NY1vgbqapts0Z5oKHwW1a/BwDomqpVTRoa9YA8ME62ZFAYyYbrRheSbApq49w5eSr6Nm1Ufm4sd24NQxjJsKzwmU10tn/QycSjuO7ME7D42BNxyMf+010vDcTl23oHBISTWAwtbe2sSFYGhKeSQmGWqqWyySn0X3zoD3j1r39m78vKElfpLmU28comiQRUqWGaBRa8sgu5BXwlUNroYrUjm/zI7aDMpjiX2aT6PAvGd85VWkgbEjGl6kbHQ35/JIJCKTfkKpuyA/2hPxeEga1b8Pe7fs5eN8qYupqgSkZ+/FhJmD/dR1TZRBTHOi5lNqkUfJ7MpgrUfo1JNvE2urF3XoWBloxoCKAPgL/+4qf404+uB+BKrN3/j46ySUMNt/tHvuGOhZjZpJU31QLdl1tWrwSg85o0NOoFeXBO1ZzV7EbH1AOKgfOigz/k+7mgxh7NjnIUzlEym6iNbtUr//L87Z9/+K1yvXzWiKerE5/ZRAjO+dEdOO4iWx3OZzYZgrKJy2yqobKJ7g+eaAKA1q4JwmtfZRMjm1o8ipawhGqzoJrkGSU/RWWT2BmwmpADwokcEK7qRpdMMquwTCAJyznnKrUIyfc2VTc6HjLZFMWuyBNTI1Uimx699UbhemiUMXU1Qc8xfvxYCTnD4h2osqlkN7qE2monW5AryDFrxE6YvOo10YBk2GhAk00aAvgbwyuPPQzAHVgUTROmUeA6oI29m3EzIJ5yBgL5Ahfs2RjHQnejqw1oKLwOB9fQqC9kuxS1s4YKCJe7Q/mAqQwUA+ddlxyOZdf/RPm5MW2jC5HZxJZ1wsSjZDZRZdPW1atKLsvUHTF/ZZNcVCVSKUZoCZlNXDg3f27VVtmk3peZzk7htT/ZZG9/Ip1GLiuSBGOObCrTFlgsmvjNFZfikVtuYO9ZitDsWC2VTfI6WUC4Y5MTbHSuPS7uQyDx66Tnqt85UqoTZCVkk6BsGqyOja5fUovWyrmxbd1a9G/ZVJN1lwJVNvE2OhVBFBZJZ3I5H9SNjs8rSiSU3eLkbSAVdGjUyqbG0eEoKwAAvDRJREFUhCabNASobhZ88F+B74A2Bpn/ZoCrbMo1eED4+Lyp1gIpKZ+JHyxoaGiMHmQCKOUQwX4DY8EyFVrZ5AaEq+AhIpwishkDwp+++1e479pvKy0TlpAmG55soouWKnh5UCJouL+v5LIqi1BQZhMFVaiK54SrbCKEuMHLLbUkm9T7o7VzgvA65tMVio47kqk05izaDenWNva3ZrbRqVAuCdSzfh1Wv/YyXnr0Ibb/VDY6V8VRfVWiH1GmVDZxBLfKZueu082Ts//vDRsHOGWTj41O7t7IE0ilwIeCjwwOSPeJ8iArCWtBWhRGRvCzL52DW77wn6UXrgHofSvJER7ZwfKVYXS8H9iNTrLRyfdJ+321sqkctV8lGVS1gu5Gp8kmDQmqm0WBawVqaLKp7qAyTKNQcCX4DXIsktpGVxPI+zIjBblqaGiMDmSyKeEQwaFsdCEL1yAbHeAtjLqnz7DX34Sqkqf+70689cxTLI+Oh6AEK6OgjGKjS7fZhMlICKWEyiIUlNlE4ZJN7piKZTY5x5oWY6MREC6jtUvMbKJEQdFQ2+gS6TRSmVZ87pY7MWuXRc6yzXcOBqFcpRZPntAcMBX5Sc+T2mQ2+SmbSmQ2sYBwhbKJdaOTlU3isqWIXpmEKtdGZxWLVekY6CHwK+evPBjq663+SiOAdqPj701Dvb1lr4/msuaZjc57rOOCjS6pJqTkzKZKAsIbkGziO9iO16xjTTZpCJAvesuyhMFyITeiyaY6Q61sagwVkc5sqg3kWe5Ua+0KEQ0NDX+0TZwkvE4512a4gPBwqg9XZaAeOCe4ghAAJkxzyKYmy2zii1lVEcL/vZzCI0o3uihZGq6VSMwj4aEqvJItTvemHG+jE8Pg6XpqaqPz2R8ZOSCcEiGysinnKpsARw3jo3BpKigIzbDWVxnZAVch17vBtr9TpQZR2C/LCUMuBflYsOPFTVjKy9o2Oq/yiS0nnfvMciddn6WIXj7vDIhqoxPDxEeq0JEuJY2xyj3uQTC4ift6wD3/3H0/3NtT9vroeJ+eOyoVG69ksu8TCmWTjwW5vG50jZfZpJVNmmzSkCBf9EXT8NrodDe6uoIpm/iA8AbxKetudLUBLVIoajnrraGh4Y9Me4fQIp51blIom0yjIAyYwyub/DOb3HW5xSklCZots4lXEdHCt5DPYWDbFgAS2RTBUkGDkFWBzH6IMiPuqjY40kA+VsRr+2MTRQoCko6n6HqSNc1sUu+PpDRpVSqzKcnZu101zNiy0ZVLng33cWTTRruTs4qAqW1mk73tk2bPxcRZc3DM+V8BwHU09gkID1Y2SQHhTP0mK5u8uWY85Pej2OjkznWVWMEoZCteLY6HoHKtg+WZ/kYSi2HS7LkAgElztit7fX73C/E97lxPJJT3HtlaV1FAeIPUQjw02QQ0HgWoUVfIF30hlxMk34VcDqZWNtUVbDahoLvRjRek0rKyqc1nSQ0NjVqjc/JURpTQ7BFVQHieIxWAKJlNwTY6wCVSEqk0e27XYja+luDzkeiz7PYLP4++TRvxmR/+VCCAKlE2hclsUgXX+oEWQcQns4mQGCO8eFByRlQ2iRNG1HZSywmFsJ39Yj7nNp2A5J/3qhygsQCPFS0k+HO7zyGbVOdjJYV1KdBrZv7e++LgMz/F3g+00fGZTUHKJkY2JYT32XeHsLDu+5GT8cZTT6B/88ayA8JVr8sBDbmmqAXZlB92v8M0DMRS5YdzlwN2TAjBSf91Jf79yAPY66hjy16fXHeou9GJyiYoXBiyyo3Zd8sJCG9AGx1PNjVKM6fRhlY2aQiQL3o7o0md2TReL5p6I84rm6jKrFFsdJyaSVbjaJSPpBQQntY2Og2NuoEP6CcB+RIFiWwKm2fD56eUQkt7OxJch9JmwjCXYUKzi/qcrlBrl78mFMPRij8amB5F2RSBbGLd6Nz18tkkft9nh4DHYBoGIxTlY03zPWRbTzURhnwD3PGgTITQHE++CUhsLNjoFCiXPMv297J/9zpdZFXnI4mXbxkqBbrt8iSyKgDcUCmbCv6ZTW5AOO1cJ+4nVYi+jIPPOAtHfvZ8AOVlNlE7aDUITn5SHQDMGhD3NNsIKJ/ErAR8d86OSZNx0OmfQNuE7rLXJ7sXVMea73wZi8WRbGnBaZd/Fwv2fb/v5yhp5dfhNXCbGlDZJGQ2NYgwYLShySYNAR5lU15SNuU5G904vWjqDSbFb0BlkyAX1WRk1SA/1NNa2aShUTeIraNpQe6dheUVLIB39t8PvMqgFFra2oUcv2ZCVqFsoiiaplBElpNpY40i2cQro3xDkQlhz2pKrrn2Jfv9lna7K17rhAmhtycqVKorFfxsdCplU4IRFM1FeJZCuSTQcL9r7eqVlE0qG105hXUpqLLFgFLd6JLsXJYJJHudUkC400nMo2xShOirQCfOoqiTqAop09kpbHslKEjKplLHo5wOeDyhZhoF3Hv1Fbj3f66MvJ5ywWzFITLswsCrbPKuV7WbZi/cFbMXvs/9XDVtdA2ubGqUWm20oW10GgLkh5KRy+mA8AYD3e9iZlNjHAt+ECt3TNIoH/wsdzyR0NeehkYd0cWTTZGUTSEDwk03rLcUWto7mMKk2cgmviCXt90mm6oUEB4rTa6oWnIL21M0Pfk6AsHEj50Cvi+RSrFxVCrT6nmGH/nZ89G7cT06J0/1XUelUBEAque1X54Qy2waY8omFYFQfmZTL/t3/5bN9voDbXS1CwiXiVRVV8QiZ92l9x1DQeLI64zF4nY+mWUJ10hYC2u6zSZXoyibKLmUymQw3NdbHbIpwsTA4Lat+PlXz8deR/4HDjjp9NDfwSubjHwO777wHABbqdXi7IdaIoqtOAxkR4UqINyviyjf9MajbKqkG10DKps02aTJJg0J8kVfyOWEgHBDB4TXHYxsKhTYw6uRiJ3/vO5mGPn8uL2p1gJ8/pXOa9LQqC9m7cLPygaQTVIBEzogPISNbtclh+OVxx7B4mNPxNY1q5zvay6yibcaqZVN5QaE2/+n5IFfSDGPUsoms1BALB1n/7Y/4x4fnqwKKubi7Pmdd/5Pj7X9+anz5mPqvPklt7cS8N3Q5u+9L1q7JiizW/wsovQ848mmMAHhrzz+KAgheN8hh5W/8TWEivApuxsdR6RS1YzSRhegjKwUlECS88jo5BWv5uHvOfS8Vtl+2Tr5TozxOEzDQNEwWQ4R+60BNjoASLfZ45koZBPdhlSLPe6tBsEpTwwEKZte+vNDGO7rxd9/84tIZFOOI5v47+vfvGl0yCYWEB5O2VgKYQLCLajJJj4KQia/o3SjkwniKArV0UJMIJvGZ7xI4x0VjbrCo2zK55g/H9DKpkaAq2zKsRaw9IHdCOieMavemzDmwOdf6U50Ghr1xbT5C3D8V76BrinT8OJDfwSgtnnJBUzogPAQNrrDz/4iDjjxNHRNnc5yjppP2cTZ6Aoi2WQVi0KxG2mWm0TPbCoVEG4UCoz05zt3UYTJbAKAJKdMBtxjPZqTdzwZNnHWHBzysf9UL+djZ6HnWYKbBGFdGX3O8aJp4k83XQcADUs2qa7hspVNHJFqFgooFk21jS5eXRvdUG8P3n7uH9h1yeHsmvEom5wMSNrAwLIsN7MpkWDEZ5iAcPvfSZtsMg0A9nnsdqMroWxyxjO54WFYxWKoa5Uek1Rrxnc7o4JODMxetCvWvPZKoLKp3OY3+axL7slkU60JZiDa/TAMwgSE+ymbZLU+DxJB7Sdfs+XYG2uNeJyPF2k85dVoQJNNGgJU3egMuRudVjbVFXS/m/kCRpzZIB0YPbbBz6A3okxYQ2O8YYd99gfAD4wDlE3UZhK1G12AjS4Wi6Nr6nQAorW6mZAVbHSyssmoICDcBi14w2U2ifs6Fo8L3yl07lLYk/jimwQoqWg2k0s2OQ1XRnHyTrS7+weRx3y6QgUrm9TnuHAsObtVI0F1jpWjbLIsi+WRERKDZRVRGMmpbXQx//tHOd/7o3M+DsC21/oFhMvKpqJpApYFEoshFou73eoClE1Ch614HAVp+bDERiweRyKdZpEdYVT6jGxyfkelNjrLshjxdsIll+F/P3lK4HGXMzMty8Lz9/8OM3faBTN3Wuj7OV69xate+7dsKnfTo6FY5cymEAHhU7azSbSJs+YI7ye5+458L4hCwMrXbCPaeGmuGaCVTRoaABTd6KSAcCOf08qmOiMWj7OBcHbAHqynW2svwdVoDFTLb6+hoVE56DNTNTCms9fp1lbkhoZCdziiRaA8mPcDLfqbzUY3LAWE8wU337ENcImjKIiSUeKZXY/FAIFsynP/9iqb+EIrKIBbJgbdWILRm0TgCQBqRVLBL7yaKZu4wknV4Uz4jMETh8WGJJuqpWzKZ4dhGgaSLRkk02kM9/XCyOc4Asb97ZXk08igGUCArXCiJKFMAtBCnypt+LwmAIFkkykFhAMu0cr/BjdEv/RxTiSSMHK58MpPg2Y22eeuKlsqCoxCHrAsxJNJNpkbdDz4676Qz2HVy//CX39+KwDgwrv+6Pu5/LBro8sLyqaNZW97FFRf2VSabEq3tuLc2//PI07glU2y1TIKASsvU4uujpWD68hXwlY6VqGrFg0BSmUTb6MbcW10ozkTpyGCzo4O9/YAaCwbnUZtUSoDQUNDY/TgF6IMuAUFzeMIq2wa2LYVANAxcVKo5RNNGxDOk01isVnIjcA0RYIiLAgqt9HJnzHyCmUTX3DHRaWHH7xkU+l8rmpDIJvCKJu4gs6yLBRGFMqmeHhlUy06r1UDquK2nBb1VMGSbmtzieCREaXSLko+TSm88dTf2L8TqRTXOU48H1OOjY6S4ZQITCQo2eTfWVClbKLrF8nh6NdeeLJJUjZVaKOj+yHZkmHbaxWLvpYsfjuz/X3Ytm5tqO/hA8IFZdPmzZG3uRywzKaQ3ShLQc5s8jvWqZaM5xzk3Rjy/TIKAStfn42obCqnk+pYgyabNASU6kZn5LmAcE021Q103w/1OGSTDo0eN9DKJg2NxkFQNyn67KQdl8IMhPMjWYwMDiCeTCLT2RVqG5LJ5rTRDff1sH8bhYJQ3BYkpUOpwkNVGLKCN0RxJSub5PssnymlzGziPh/UxIHZ4J31MRXbKNor+N9G83uUy9FzmzsOpmHAsoqIJxLCeDFWIiBcsCGWGbpda/jZ6KLmwFBiMplKcZ3fRpRKOzp5VI5yTwYfQG0VTTezSVY2OSRN3jn36LGhx5D+X85RA6AksCjRyu+/SKrCEnlfnm1wzjGq0DILlZ1PjGxKp0EIKUl2FAWyqR9myPtubtiHbBolG10UAjAMPJlNESZC+dyrSgLCvcqmxru3WJYmm3TVoiHA041OstEVcjl2Y9WZTfUD3fd0MKCVTeMH1RooaGhoVI7AbnSysinE4HlgyxYAQOfkKaFnoBNNaKPLj2SRG3IzTIx8zks2STk/QeBnj+myVpF2XypdBJVSNpW00XG5HEGdpXhlUyGfQ25oCPFEApmOzpLbWC2EVjYpOqXRDE/Z4kltgH5kE09cNKbVxV+BEHV7qcIwnkwJ16ZKaecW1pUXpDzZXDRdsklWQ6dYQLhINtHzuWvqNADAmtde9uwTVV6ZqhOh33erEKaTobANzvZWT9mUFdbnkmc+Kj3u+4b7ekPb+ARl04h7r+7bPEpkk1VlsikdTtmkQlA2VxQCVr42gzKz6oW27on13oS6Q2c2aQhQKZvEgHDdja4RIO973aFs/GC8er41NBoRJMBG5yqb7MmAMEXRgDPL3TFpcuhtoLPERhORTZRUozDyeUHJZORGInWjEwpd53OVZDZtt9teePMfT7rrLxEQzlvqWtr9ySY3IDyHQccu2dY9qWrWljAQM5sCyCZFFk8h76hA5LyWRLA6pdKw99FAkJIlSkt11mHQR9lEFMqmMJ23SoG//otmkVM2yd3oaEC4fSzptUMJwznv2w2dU6aib9NGvPfSi5i35z7ueh3bkpDZpCDco117wXlfPCzLcm10meoEhMuB9zSHz48A5O9Tw/19SgWYCjmBbHI7040M9KNomjUf20U5JmFQibIpkUrho1ddo7yu/BoTqMCyweJxHP+V/8a8PfYOvQ2jhe7pM3Hsly9F56Qp9d6UukFPkWsIIBAHPIV8DgUuB8LI5RiLr5VN9QMfJppU+KE1xi60sklDo3HAAsIDutFFUTb1b7XzOzomTQ29Da5aponIpq1iTolNNnHKppERMQOmJNnEWb1ME5ZlRZrJl4ueRQcvwXEXfQ1Tttve3j6ebKJKkIQ6IDwdRtlUKDCyqT1kNle1QAQbXZCyyUsiUEWGrGoo2Y1OoXppNPgpm6La/gyuYzMf3h/Uja4aOVaCsqloMmWOV9kkdqOTu1/GYnHstuQIAMAb//i78NmgTowCOcx+a3hV4eC2rejbFByWzRRTsRiznlZKNlGFVzKsson7vuH+vtDfL2Y2iffqapCNpcCUntXKbJK70UUM/Z+50y6YNn+B5/2gHEQZdJn2iZOx/Z77jCppHwU77f8BTF+wU703o27QVYuGAJmhl5VN+ZERVyKc0i3Y6wU+30Fb6MYXxmvrVA2NRkTQwJh1o4uQ2TSwxSGbJoefBaX3hEIzkU3bbGUTyzDK50UbnRQYHlSMvfXMU/jZlz7rLmsabk4GIaEKELk5SjyRxI77vh+dU2xLkSqzKaYouIFSNjo3zJ2RTaNss4iFtNERRUA4Hf/xmStA6W50QkB4FfKJagE/q2aYLCGrWMRDN12Hl/78EIuaiCeTSDDV4YjaRift49effBx//82dkXOiAJFsLpom+z45symeTILEYk7Hx4InswkAumfOBgDkhgaFz7LMJkHV570HFhVh6H6gxNU937kMPzl3mZBtJKPIEWPxZDT7nR+8yqZgskNQNvX1CiSf33GzLAv5YVfNxGc2AaNzTVQ/s6l0N7pyoGpM4AdX2aTpjEaGPjoaAmTvcSEnZjbRLhuxeKIhW9eOF/BEX4sOBx8XWPqFL6NzyjQs+eRn6r0pGhoaDsIEhEfpRjew1c1sCgtaJDWjjW7CjJkAbDJHzGwaYUHAQPAs933XfhvDfb3stWkYkS0jfDAw4JJPLIso7yWbeIUxT1YFTQDRz9RT2QQS0kZHVXuCssk+pyMrm7gQZ7OMDm+jgUqUTe+99CJeffxRPPLjG1z1f0qtbFKSTc4+fuB/r8E/7vkVNr+3IvL282SzZZrsfiMrmwghjGTMj4woM8iSPh0uTc62xH4DtcFx+ykKsSGrCod6e3yWdDvnxZMJ1j0vbGaSHwoeZVMpssn9vmx/H1NG2Z9RnyuF3IgQFM3b6IDKOpa9/NjD+OXXL0R2cCBwOab0JPW30QUhSjc6StLJkwUajQV9dDQEJKSbfmEkKzxsRgb67eV0XlNdwc8oBHW+0Rg7WHTwh7Do4A/VezM0NDQ48APjN55+ApmOTszddQ8AbkFBM3zCFK39VNkUIbOJD51uFlBSrXvGTGxZtdIOCOeIisJITigio1iveFVHFFtFLJFwc26csRBve6OgxAlvo+PVI2GVTSMDdnE42mRTLGxmkzOhaHL7nk44ypNcLHdHUplYloV7v3s51r/1hvteoyqbpIyYWDxun0shSOKsMzYGxIBwdTc6jqjhOm/xSg6ePA0L0UZXZOuTlU2ATazkhoZQGMm65Cl3PvvdUygBrDr3+f3EfmuogHDRJRF0yYrKpmhd7PxAJwXosYoaEC4E6Ofznt8DAMO9vdJ3Vs9G9/CPrgcA/PvhB7DXUcdi86oVmLXzIs+9T6WsqwRyHVit9dL1hLGWFhXkp0bjQSubNARst/te2HXJ4dhh8QEAgBFJQkuZc0021Rd8XlaLttFpaGho1AU0IHy4rxd/vO5q/N9VX2NWCppvk2bKptKDZ1pktk3oDr0NvI2uHPtNPUAzm7pnzAIAFOTMJjkgPAJBUTQMIEInOgoxh8b+nGsPK2GjE5RNAWQTVTbl8/VTNvHbk/a3ZasUBtRWJf9GP2VTtr8PK/71vDCWbNTMJnm76Dg3jBKLJyPpv5OSsklV7LMGA8UiRgbdfRSk7vHdBt7OVTTZ/UbVES5FSTAuG41XNvmRTWplkyKzyYxuowsD/tqLl+iAGBZUrUe79LkB4T7KJu5YZwcHGAEL+BP+9Fpn3ynZ6KpxTZBYDP931ddw12WXCM0NKOizgcSqk2sUi8XFe2bVbXQRAsK106ahockmDQEkFsORnz0fex6+FACQ7e8X/s532dCoH/j9n9bKJg0NDY26gA6M+YIj298HQBUQXnoGns2yByhOVNsQiycAy6o4LHe04CqbbLLJzBeEbTfyOdGWU66yKcJsu6DWcP7NMqWEbnQKG10irLKJri+PwZ5tAICO7tElm3i1epDyixJo/L4fcc5zedzhEg7i+acqvhuVbJKtTJTElX+TCvw+pcRkPJnkOkWOqAPCOasir2bqd7pSht52y5K60ZmcsslL5rg2uqzSRscr8HgUVQHhca8CLoqNNSYpgYLOD0qMJRJJdo1WbqOj91xZ2VQ6s2lkcAC5oRBkU49ENo3ImU3lKZv4yYWWtjZsfPctAMDbz/3Duxwlm6pkowNEsroeNjqd2dQc0EdHQwl6A9m08h0AQIfUsjGuO9HVFTzZpG10GhoaGvUBHeTms24GR8/6dfZ7LCDcvkeHCQiXZ9nDws1YaQ4r3bBDyHVNsbvu2TY6/250UWwm5WQ2AbJSSVQ2CZY+g4Yk8+RUtIDwwZ4e9G5cDwBomzi6AeGyhccPTOFR5JVNDtkkKard/SSe43wHLopGJJv47oUUjBgMsb38dWfk3Y7NrrJphNkHVZlNvRvX496rr2Dv00YBYSGE4sOx0Rn+FiNKZuezro2OJ6Vc+6hso/MGhKtsZ8VieHuTrGwKuk/yYealQunDIu+x0cUDt4P/vpHBQUG1J+8vCo+yqUpkE0908SSSrHCN2jAhLPhIj2qpi1jTjUgB4ToVqJGhySYNJeROI7su+bDwWiub6ou4ttFpaGho1B10YJznlE09G2yyqSxlkzTLHhZ0gqiQHymxZGOAFq10ssQo5MXMplwudEC4Z92mEakbFgWfbUMLYPqsFcgEpgTxs9H5P5Npc483nvobhvt60TVtOjonTw29jdWArFbxg9tp0S2EaWEtK5viPsqmXFYMQgbCZZeNNlTFPlW1hckE4gk8t2Nzil3HhZFgGx0A9G921Uz9EckmT7YSp2xSk02cjU6pbLJ/e0G20VFlk+JaEbvRlR8QHmSLMzlllV9OWFR4lU32b/MjgPjzITc0hBEumNuP+PIom2QbXZlk01DvNvZv/rr2kE1lkO9hkEzVWdkUgdTUqB802aShhNDSkhDsuuQI4WLm5eMaow++UxFtzayhoaGhMbpgNjquqO7dYCtWaEFB821KKZuKRdOeGSfE01a6FJgSoUk60tFCgtp5jHzeY6MTAo8j2uissgLCvd3lEqrMJlqcC8u746PAzCbpuJ76jW9HyqypBsIqm0jcqzCgSgoaek/hFv6llU1RLJGjBdX5RY9VGHIsn3XJZkrIJZJJMU9NaaNTF8nUZhoWnsBpLthc9R00GN4OCFdlNqk7XFLCPKY4901FQHgYsikWQdnE2/iqpWzyI5v8tsPgyC3LKgqklB+RO7DNJoU6HSWnTDaVG5pPrbiARAxK5JVFM+yqqGoCROFB1QLCFV0w/eCq9zSd0cjQujMNJbqmTkP3jJkY2LIFu3/4KHROnoJEKsWsAlEHwhrVxeL/OAFTt9sepmli3h571XtzNDQ0NMYlaEHOF9U9G9ahaJqsUKMqkFIB4TRQPJluiVwUJFOja6Nb//Yb6Jg4uexwa0Y2tajJJgDIDbv7NEpAOOCqHaJlNiU8/1Z1o+M7Yqk+KxMxPPiJunRbGys+RxOhlU2KLmO5Yaps8iGbpGOYVyib5K5vjQDV+UWPfRhl08igSzbR/LZEKs0piNz9oLLRyRjYshmWZYW+D8jXvVUMVjbR6y4/kmVEBH8+q+4nlmUxS6FS2aQICA9jrZLJ1qD9zSx/yaQbSl8p2eTXjc7nnhP0fdRCKWPIUTZ1TpmK/s2bmMWaQlY2vfToQ9i2bg0O+fiywHOAD5IXlE1QK5uiNEwIA6qoJbFY1YisGBeaXwquglUrmxoZmmzSUCKRSuFTP7gZsCz2YEyk0i7ZpJVNdUUsHse8Pfep92ZoaGhojGswGx1HNvWuX4e+zRsB2HmH8UQChMRgWXY7cr8CjBakUfOaAM5GV2Vl05bV76Fr2nTBLtG/ZTN+9fWLMWvhIpx22XfLWi8tEgRlk2SH4bNQoqphaNEXxTYidqMTbXS8sskwvLYjXt0gxxDw4CfqWjsnhN62aiLsORJXKptoNzq1jU4+hurMpiax0UUgmygJZ//b/s0JLiCc7geZ/PS9F+RGMDI4gExHZ4itVwR5F4uBbeEpCcaTHomUqhtdjpFeVrHIagIVYVZUBISHstFJ9URwZpNC2VSxjY7ed+17ETvvfSYHAsmwEplNXVOmYQ1eUSibxPPvkVtuAADsuuRwTJ6zne/3DfXwNjq+G6E6s6lWyqZq2tjKCQgfbXWoRjRo3ZmGLwghwoOCHyRpZZOGhoaGxniHqk123+YN2LZ2NQBg4qzZABBqFp4WfkFkhR/44rBa2LpmNW6/6Au49bzPCAVg38b1sKwihnp7y1ovLVqZXZAQFE3Do87Ica3go6phaNEXZcY7plI2OQXtYE8PfnrB2Xjm3t8oO3LxIdJBBR1vO2nt6gq9bdVEWPUbs9EJmU2OjU7KbEr4BNQryaYyLUO1hNpGRwPCg8mm7EA/hnpchQkl5OLJFCNp6X6Ti/IgMoYnW0vBa3czA8OT+YBw2gUvw5GfJBbz3LPofpC721FLndA9klkGwyibIpBNJg0IT/qq6aKCkq80zN0974NtdAlFoyTVtWVZFrO70dgL+Xj55UOV+m2CjS7nn9lUTnfOMKC1YLXCwYHyMpu0sqmxockmjdDgB0nyTISGhoaGhsZ4g2pGN5/NYusakWyi1qrsQL/vupidowxlUy1sdLRb2lDPNjxz72/Y+8P99m8oN2eE2XticRBCWNGW40LWAWBkaMDzmbAwGNlUprJJ6kb3zj//gZ716/Dkr+9QZjZN3W57LNj3ALz/5I8GfgdfoGY66kU2RQsI51Vl9BjJyqakj7KOt0JSNGQ3OqnYJyTm2qkC7K+DPdtw46fPwPq332Dv5amyiQsIH3bsTqlMq/D5oKyZKCSKx0YnkE3eexRtLJMbHkTW6Qwpk58J6Z6i6kQHqJVAUVrSe2104QLCKRFshFCeBSHvKJuSsrLJ555D90PrhG7P31Td6EaGBmEWCkhlMr4WW94yxhNFpe5fvLKJDyr3KKecdZJYdZVN9LlTVWVTlG50OrOpKaCPjkZo0MEEoJVNGhoaGhoaqhldq1jE5vdWAAAmzpwDAGjtsguT4QA1UEEqeqKgFjY63i7ywgO/ZwXMcH+v/fcys3fkIphOZPFtvAEg29/v+UxY0AI5io2OV4BQIkmpXqA2Oq5IJrEYPnLR13HgKWcGfkcjKJu6Z8wCALR3TwxcLhYQEC6HoLMg7NyIUCyrbXSNRzbJ2xSLc8qeAGXTmtde9rw3wpRNSXZdUgVKulUmm7z3j1IB1SoobXQBAeEt7R32tg4MYMhRNrV1ieSJrJY0fcimmMJCGSkgXFJKhQsITzIieGSgHxvffbvk9/jBVTbZxCApYaOjJGBbt4JsUpD9pvNeMt2iVJkB4vnHk4x+iicKPrOJkoYAUJCy0mqW2eScI6SKZBNdV6iAcG7iQqNxockmjdDgB0m8t1tDQ0NDQ2M8wm+QveGdNwEAkxxlU+uECQCAYa4gkMG6IqWjT+a4KoTqkU38LH1ueAjLn/obALeoKdcORUkqOhtNxxZZbmYekDKbAr5LlddBC7woM/l8UU6L5LhirFNUdO8KizhHXrV21odsOvJz52OPI47BqZd9J3A5OSDcKhZdsqnVm9kUiydgFYuC/Sg/Iha9QIOSTdL5RWJxRqIEZfSofh8LCE+mPNeyR9kkFclT5+2AyXPmAYimbCpIipqiGRwQTrOgsoMDzEYnn48u2SQqm+LS+lS2J6rUCaN4ka/f4Mwml+jllYW/uPQCrPz3CyW/SwWX5LfJpnipgHBn+9onuGQtvR5UyibezuiXLcSTSgXuHl4qj2pgm9u1kFfNyudlOd05w4CSqVFI/VJwremlJzMoISUToBqNBU02aYSGzmzS0NDQ0NBw4Tej2rvBtqBNnGUrm9q6JgAAhvp6lMsDrvUhVYayKZmqvrJJLpzeeOoJAMBwn002lZp194M8Gz1p9lwAwOpXX/L/TABBEUt4SR/aPY6Q8MNcvgyjRVki6R3rsIK3DLKJn7TL1CkgvGPiZHx42eeYwskPtICkxEF+ZASWVUQy3aIsmlVWunyT2ujCKpsGtmz2vOd2o0t58tdkko5X/hx+9hfxse9eh2SLvR/DBJNT0AwgZv0zTc5iFKRs6mcEeKtzj6KQCeyiT2HvfifXjY5l6ZRhowvY37y6Sv7cO88/W/K7VJDty0QiWb3bYF//vI1u8tx59t9UyiaTKsxiocgmPs8piHC0LAuDWzmyiZvIkLtAuhla1c5sqn5AOL1nW1ax5DMmStdDjfpBk00aoSGQTTqzSUNDQ0NjnCMoKyKRSrMCLuOoBoJsdCwgvJzMpgwN/PUW9+XCdDq6zdhxZwBu7gxTNpVJGtAijhZ12++5GIDbsUn5mYBZbtUxKCezSQXaLY+HqbDRhUUj2OjCgil7nONMO67JeU0ULCScJ5ua1EZHYjGPskuFfgXZRAmCRDLlIZdkGx2PlvYOEEKYYseI0GWNqo/o+VosllI22WRTdqAfWRoQ7pPZVGA2Oue8l6xgcek8sSzLbgCAcGRvpG50XGaTfYy8of5RURgRbXRuZpNPaLezDW2OWhVwySaVjc4l/RK+Chz+uwo+ZNPLf3kYf7juarafswP9wr4a5mzH8nVXrJGyqRaZTYQQzsIbkmzSmU0NDX10NEJDtNFpZZOGhoaGxvhG0CA73dbGBvdU2UQtKyowO0cZ3ejSjj2noLD1lAtK2NC8qZxTwFAlRJhMDRXkInj7vRYLf1e1ew9SO6iIKFqkRZrJVxRiKrKp4BSUchetMBDIpjrZ6MKCBfU6x3nE6Q4oEygUrrLJDSfOZZvFRicFhMfibrezgIBwlbKJIp5KIhaPC+ScbKPj0eLkYIXpXCmDqo/o+SoEhCtUH1TZ1LdpI0zDQCqTYcQBhcdG56tsEjOm+LymMOSGfB0FkXs0PJwSVDxRVY7S0DQKKJoGYvE42+9uMLyPsokeF67hGyWeDMUx4+93MlFHwduE+euHDz9/+Obr8ebTT+Dtf/4DADDAqZoA8R6Zz2bFjnQsILzamU3V70YHuJMEpazaQSH4Go0DTTZphIbuRqehoaGhoeEiaJDNF+XUcjEURDbRoNoylE20iM1VU9lEg3AdooxaooZZZlN5NjrLFPNcJs6chc4pU9nf2xRdnoIIChURZbDMpsqKENWxoF2fKlU2ZRqcbCJSQDglm/w6aqmsnAWlsqmy7mG1gEycxgRlkz/p07/Vn2yi4fKZdpc89SPqAJcAouPrKDY6us+pBZeqkAiJKdV96bY2gVxtVVg6ZbLJ9MlsikvZVi7JFa7ElMmrIGWTIXWC5Am5KIHqFLyqiRJjbmZQcGYT7TQKcJZDVWYTZ/3zVTaZ4W101CI36OQ1tU+a7FnGsopCfl8xQmB7FFA1YzUDwgF1J0wVXCJPZzY1MjTZpBEauhudhoaGhoaGi6BBNm+ZoXa6rNPJTQWqSionsynV6tjohmuhbLJJkVx2GJZlcWRTuQHh3tnoCdOms3+rWooHfZeqyDSrZaNr8SpRaDFYzqQbT04GEQ+NAFp004JvwCFW2id6i1uAs9FxRa5a2VQeSVlLyMRpLMZnNqnPPatYxMAWu+D/7M0/x84HHiz8nYbB80q9IBsdvQYqs9E5CkfajTGhvj/FYnGmpAK8eU2AIrOJkSbiec+UTdRGF7HzmTcg3P93FzkbHSASl3I3yzDIS+HggJh7Bdi/Z+VLLzKylRJAOyw+AEeccx7O+v6NLFpEaaNz1hPn1FMyogSEW5a9LD33uqfPVP827tqjn4nSMCEMWGZTlUksN3Re2+jGAvTR0QgNndmkoaGhoaHhQpbv8wQC/28WEB4ms6mMbnSUFKlmZhMtnJItGSRSaVjFIvLZYabsqVZAOAB0TJrC/s0rm6gtKDdkd8MTrCF0XdJ7gFtsV1pcpQJUZuVmxOyw+ADM3HkROiZOKnezRgX0+FASgVrGeBUaD2r/LJTKbCqTpKwl5HOZxEt3oxvq60XRNJDp6ETbhG6P/ZUW4i1OPhKgttF99uaf49P/+xP2N1kpFAaUGKbXC81bC1JeZrjtUuWHeZRNzEYnK5scJZZD/Lhqk3AlpicgPCiziYVte6+9HNe9MixYOHiaJ5so0WF/16t/+wvu+dY38Kv/vhiWZbH344kEdvvQEZg0ey4jFk2FsoluM4nHfRU4fjY6pZXSud3RTnT+ZJN77TVTQDjAqSpLqCAp2VRte6BGdaF1ZxqhIXajSwUsqaGhoaGhMfYhF3OtXV2sG1WKt9GFyWxiXZGiK5vSlJSpAdmUSKWQymRg5HPo27SRkTtlB4QrlE0dnBWEJ5vaJ07GtrWrAQD3/7//AQDswilIij55OuUom1T5MiQWQzLdIhSAFOXGCXzkoq/5fl8jgRbGVNlELWOdHDHIIyF1o7MsS002lWF3qjXkczkWi7F8Hb+Cl56XnVOmAfCeD3ScLCqbvGo22TZK1xMps0my0VE1kp+yCXBte4CfsknKbPIJCHfthvY+jGrZkpVSoQLCFdfeSDlkk6Ipg0s22b9nxb+eB2Afb9YNL54Qrt+ktK940P0Sj3s76LFlrPA2OqpSop3oumeEUDYVHYYqQnfOMKhFQDjgChpUGVg8dGZTc0ArmzRCQ8hs0mSThoaGhsY4hzx7z7ez5y0zmY5OgBBkBwd8SRpa+ASpafyQaq2+sokSNnxXrd4N69jfrWLRozQKA1Wmi6Bs4grfDimPZMULz4nbWCLEtxoz+X4ZWuXmhBBCGp5oArjsmqKobOqYrCabaOFpOMScWSgoz/VGVDZ5bHScssnvHFv1yksAgFm7LALgVfzT17yCKBVgo6OIhyy0ebCAcGf9RiGMssklwSbOnO35u2yjM/0CwiVLW1QbXSJCZpPJMptUyqboNrogZRP9vfyVKgeUU8SDyCY+IDyMjS4XbKOjyiZK/k6YMUu5zvwITzZFy9EKi1oFhCcVllwVXLJJa2caGZps0giNJEcwJZOabNLQ0NDQGN+QZ1T5DmO8iiEWj9vkk2X5qo9ocZCoICA8r8jIKRcsjDeZZOvv2bBeWMayolvpWDEaStkkWs0Ge3uE136qE7rt1QjEVXWkiycSTUEYVQJZ4dFPbXQ+ZBNTNjkFYsGnUGzEbnRyEDEhMWUuEI9Vr/wLALDdbnsCUBAQLLOJuycEdKNjn2M2ujIym2hAeIFmNvkX4Wkus2neHnt7/p6UlGqUzJEz5eRudNEDwstQNil+VyXKppQys8nZDu46N3zIrkSAjY6uRxUQLudDAS5Zy38fD3rP3brGVtZN3W575W8TbHS0G12V71m1Cgin+1NF3vGwIlo2NeoDfXQ0QiPB5UhoZZOGhoaGxniHPHvPZ5/IhSWdPedtEjxokZFKlxEQnqmBsomz0VGVVq9ENpUT9uxaUTiyiSMw2ronuv+e0A3CWT+GerZJ368mLpiNqBpkkyIkfDx05KVqhaJpK9hKKpuk89v0KRQbkWxSKps4EmXju28LSpHc8BA2vP0WYvE4Zi98HwC3QAZssop+nrerpUKEwrNOa2V0o6MWXJrhFKQ4oTYsAJg4a47n77KNbqjXvvb46xOAx24YNR/Im9kUFBAudqPjUf3MJocU5wga00fZJO8rcZv9lU30c77KJhXZVLQw1NuDbH8f0q1t6Jg8RTj3KDa++7a7DTXqRjdp1hwkkilMmTuvquuVLbl+YGo7ndnU0NBkk0Zo6MwmDQ0NDQ0NF5n2DqmFuEs2yYWlqxTw5v8AXEB4GcqmdA1sdLRgjSdTjMzq3bhOWKZUa2oVVO2qeRsdH6KcyrQKs9ZDUuaVX+cqVqRVIaNEdTxkNcZYBAvpLZoYGRpEITeCVCbj20VPVsL42cAak2ySlE2xGCM01r/1Bn5x6QX4y89uZn/fumYVLKuIyXPnucHeHAGRSKUYSZHpDNeNjiLGyKYIyiYpINwo0Y0OALqmzQBgk4cqxQtTlzjrpkRvu5Qx5droqtWNLoSNTkH25oaHIls03W50LsEvB4TzcLvhqVVsRpCyKRb3KJtoLcWTnYaiGx1vV7asIjavWgkAmDRnOxBChJps0QeXAABe+9tfXBKLKZuqW/Z3TJqMz/3kThy27HNVXS+z0ZUgm3RmU3NAk00aocHfzFQsuoaGhoaGxnhCsqUF3Vxmhl9mE+BO2PjN1qrCaqNsB2Db6PhZ8uzgAF548A+sbXcUULIgkUxymU2SsqmMjnSWol01v68KnIIknkgIzeZGBvoFso6qBtq7J+LMb/8AC51CixXbNbLRyTkzYxFu8LPhdqKbPNXXiiOf334B141INsmkKa9soud836YN7O+UGOZVS3xmE6/+z/DKphA2ukQ5AeE0s8lZvxkis+ngM8/Cfh85GWd+61r1dkiZTUOOhdWrbBJtdNQ+GXZSWiZgwtjo6GeO+Ox5mL5gJ/b3/HA0G3FhhCrC3Ml02T7Kq4H8bXROzpZK2cRlXYVTNnm70fHXTNE0scUhm6bM3U5YDwDM32d/dEyagr5NG7H2jdfszxS9v6VaSLVkqm/Po+dewW02oDovLJ3Z1BSoKdlECDmKEPIGIeRtQshXA5Y7iRBiEUIWO68nEUIeI4QMEkJukJb9FiFkNSEk+shJoyIktbJJQ0NDQ0NDwNR589m/BRudR9lUwkYXsUjjEYvF2fppIQwAT/zyNjx22834/fe/GXmdYkC4XcQObtsqLFNO2DO1p8iFMJ3EmsC18k63tnkUBj3rXXUVbSuezLRi+g47smKOKgIiFVc+BZOcUQOMExsdUzYVkR3oBwBkOOWeDDnUl6o80m3iddCIZJNMmtrKJvtcojloPJFBCVHefhXnJmF5MrKlRDc6GfI5HAasG11GnaekQqajEx884yxPNzwK2Ro22ENtdMHKpkKWqoXCkeaySiioW6Gc2bTbkiNw5reuReeUqQCi5zZRYod3bnjIJu6+UPTphkdfKwPxTdqNLu75rfSeVyognL8HGoUCtqx6DwAwec48z/ZPnDkLO+73fgDA6ldfdtbvKJtizZEzJxPX9159Bf73kycjNywqd4s6s6kpULOjQwiJA/ghgKUAFgH4KCFkkWK5DgDnA3iGe3sEwDcAXKRY9R8A7Ff1DdYoCaEbnVY2aWhoaGhoCHkVLVzorkfZVMJGZ3AZSeVA7khXyI1g/ZvLAQBrXnsl8vqMvDOLn0r6dtGyylA28d2ZeJz9o9vxqR/cjI5Jk7HkrLMxd9c9sMtBh3g+v/6tN9x10eLPWRddJ92XtQoIHw82OrovLdPkFAT+5AUlXqhCj5KVvPoHcEN9GwkqGx0lUWggM29RpUUwHyzNX7cZrqMif08I02kyVkZmEwsIl5RTldiLvJlNjrJpgqhskgPCqTVNdd2oIBM3QSQbJV1khRANO4+a2+Suz90GOSBcyGzyUTYxglChRqOEeCye8BwPSqqIAeHezCb+72ahwOzMNGuLf6ZMmjMXM3bcGQCw/m37XmnVKLOpVpDPvRUv/hOmYWDt8leF5fg8LI3GRS3Puv0AvG1Z1ruWZeUB/BrARxTLXQXgatgEEwDAsqwhy7Ke5N/j/vYPy7LWy+9r1B46s0lDQ0NDQ0ME3zacz/7wzWzy6dLlkk1p5d9Lge9I9+9HHsT1nzgZvRtd608UpQQgKZt87D/lqFT8cjYy7R2YONO2JO699Dic8o1vCYpqihX/el6xrgTbVsAlA6pho+PVKxTjwkYXczObig7hElTUJSRlEy2UZQLENBqPbJJJ01jMq0LhA8KVyibunOicPJX9u7VrAhLJFDomTQlV7JdnoxO70VFUYi+iJCElmWhmk6yEovuJkjN51uEtJNkUwUbn2tjEY0MJvajKJhZmziljZGUTwAeE+2Q2BRCEjBBJ+AeE88o6/vlAzwF+vaZRYBMBlLykxyieSCAWi3Nk05uwLIsRptXObKoVQmc2MXugJpsaGbU862YBWM29XuO8x0AI2RvAHMuy7q/hdmhUCXw3Ok02aWhoaGhoALOcblQtbe2CciGyja5QmbIp7SgJ8tlhPPqTH9rr5AqXTSvfjbQ+ISDcR9lUFtlUZoFAi8B3/vkP/Pqyr2C4r9djq6HjFEoMRJnJ33G/AwEA03fYUfxeBbGUKCNXq9nAF93M+hiobFIHhLd2dgnqv4ZUNsmZTbGYkMEEAHnOwqMK8+dzmjq5jn3xRAKfv/WX+M//9+NQ2xJjNrooyiY/G135ZR7NouvdsA6mUUB2oB+ExASrsP0dUmaTowALk08FKLrRBdxTioaPssm510ZXNnktvZkOm2Tb8M5bdjA35zxj3eik748FWB/5gPBEOi0QgImUfY752egM5/fy1kKzUHDXKW3HZOc665wyDZnOLowM9KNv44bIHQLrDWajkydmJBcgsyiOA/K/mVG3s47Y9Oq1AC6s0frPJoT8kxDyz82bN9fiK8YddEC4hoaGhoaGiNbOLnz6f3+CT113s6Bs8g8I99rorGKRzWKX+3ylhWbOpyPdujeWB36+f/Mm3Hr+Z/DyXx4GwAWEp5Ie4oz+lrJsdEZ5ORvdM2Yx0mLt8tewdvlrrAijXbfoOIXmxkSZyX/fwR/CaZd9F6d841vC+6rw2xk77OR5b6yBJ5ssll/jvz/lQGl2PqdS+PjV12PpF75svx+BRBktyAHhJB73KAyNQt4lVBRkE3/d8mQTYBPNMnnlh3gZyqaCL9lUfhHeNXUaSCyG/i2b0b95EwA7k07OWmP23eEh+/8j0TKbogWEO8HnkrLI7cYZLSCcEd8ciTp/n/3Q2jUBm1a8g9WvviRc/y4B75PZpFI2UUIrEUcsFkfnFPfcUN1HVTY6Wdkkq0Ppehbsa2c1EUIwwwlO3/DuW6ybXbWDvGsF+V7iB7YfmoREG6+o5dFZC2AO93q28x5FB4BdATxOCFkJ4AAA99GQ8EphWdaPLctabFnW4ilTppT+gEZJ8Bez9sdqaGhoaGjY6Jo6Ha2dXUzdAXhn9oOsAQZnWSu3IHBtdGqyabBnq/J9inVvLUfvhvV453k7QtPMu9sk/BZCmLqhrIDwomh9C4tkOo1DP/kZ9too5IU8FMBtZFKOsonEYpi9aFevIkNxPGa/b7dI296MEJRNPjlbPOTMJl4ZR2IxIXC80SBvUywWUyoM6XlFCWPRRucSEDSwuhwkmCWrGja68sfq8UQCE6ZNBywLa5ysHDmvCbDJdgAY7rdD5Cu10RUDfjclXWTirtS9zw8qS28ylcaeRxwDAHj9yb8K9+OhHppbJVsJ/dVoReke1TV1OvsbJSj5+2jJgPB8wbPOj171PRx46pnY97iT2HITps0AAAxu3cLO72bJbAptozO9ZKFG46GWZ91zAHYkhGxPCEkBOB3AffSPlmX1WZY12bKseZZlzQPwDwDHWZb1zxpuk0YFSIZ8cGhoaGhoaIxH8MoCuYiSbUY8Kg0Ht7+bKgzUBVdhJHjWn82iO/9n+SjJFCsoAQCWxeW0RCebwoRNq5BIpzF31z3wvkMOY9sp2ygSrCOf/VurMeOtIv9mL9y14vU2OkQbXRiySbS+uEo9+1xhgdsN2Y1OstHF44ItjoJeWwUFoUItUYCY2RQVUW10vCpSHqdXOjFMrXRrl78GAGidMMGzTCrTingigcJIFoV8jqmLQgeESyqlQGVTgSqbZBudfe/zU3X6gd2LJLXWtPkLADgEPXf9D2zdAgBonzhZWD6YbHK70QG2YoyC3u9FG52rfPVTNrn2YXudU+fNx/tP+qjwzGl1QuqH+nqBJiOb5IBwCiL56MLclzTqj5qZHC3LMgghXwTwJwBxAD+1LOtVQsiVAP5pWdZ9QZ931E6dAFKEkOMBHGFZ1muEkP8BcAaAVkLIGgA/sSzr8lr9Dg0XrZ1dOGzZ55Hh2rhqaGhoaGho2EimW/DRq76nDPlO1JxscjObVKCKAz/QWXSzUIBlWW5AeCqJqfPmY8K0GejdaPdnYZ3KQqpUHrrxOphGAcecdzFnfYhWIFAVCbWsGAW36KLbI8+IV6O4UlnHMlKHtbEIPiA8TOZLQtr3rHMXJZuc9ZlmA9ropPOYlFI2KaxiPGnSMbl8R0VUGx3fWIDaSSkqJ5tmAgA2r1wBAEgpwvIJIch0dmFw21Zk+/tQGHEym0JOUMvbGEQ2+XWjo0R7zodo911fUW3ppcqlod4edExyiaWBrXYsS8ekScLyfAc7q1gU7jvsHpVQKJtoNzreRqcICJe70TH7cIA6lP6G4d4eFvDfPGRTcDMNinJVshqji5oeHcuyHgDwgPTef/sse6j0ep7Pcl8B8JXqbKFGVOx5xNH13gQNDQ0NDY2GxcydFirfT7IcCi/pQwuMcjvRAW5x50cqhVU29WxYhxs/c6Zd4BCCWDwBQgg+etX38MAN38cO++yHl/78JwDhlE1WsYhX//ooAOCIc871LfBKge4/vhiX7SQyQVCN4mrynLns30efdzGmzptf8TqbAdSaYnHKpqBQ9yRTlYk2OmoVokRIQyqbTG83OlV2GlM2OYQaTzbx1wJVlZSDeEDYtAoFdu9IeQjcSotwqmza9J7dXIBvFMTDJZv6mbKpXDeEKveIQm4IQFFNGx3gHr/hvl7huPZt2ggA6JgkkonEuU8WTQOmaSLB3Xdkcn3CNJdsipcICGc2OlnZFELRQ1VoQ329sIrNltmkVjbJcFWyzUGijVdoKlBDQ0NDQ0NDo8aghWmQskkOno22/mBlk+p7eVCyaXCbm+2USLkZUq1dE3Dy164CALzymE0ehVE28bPTRj4fqrOZCnT/URLAKOQ93alksq4aNrqd3/9BZAf6MWfRbqzb03gALeCKZjEUQdg2YQJACAa3bYFRKHjOaVcp1YCZTZxixjSMksomFoLNKX1oThOJxSoq6uMssymcAoxXRcrne6VFOMtocgKm/ZSXLLepr9fNbAppo5MRHBBOj5OU2dQabCH2A70XySQqzaQb7usVFGZ9mzYAANonisomwD7Pi6ZhZ05x93E570yV2RQpIDygGx2Ptq5u9husJrPRUYXqhrffxIp/Pc/ep0HnFGaZKlmN0YUmmzQ0NDQ0NDQ0agy3G51I+liWxdQAFSmbnOJusGeb8u/5UsomRZHn1xmPEREhAsILnNKqkBsJpZJRIaFQNskWlaSkvIjSjc4PJBbDXkcdW/F6mg1031lWkesgGKxs6p4+Ez3r12Lb2tVMlcEym2gGVAN2o2O5OskUTMNALO6jbMqKmU28sqltQjf+87qb0VKhxTK6jc5VNpFYzM4YcorySpVNspJJvr4o3JDwPqagjEI2nXTpFdi6djUev+MngYou38ymMpVNlk/wfTyRREt7B0YGBzDc18Pep135eGud+5kECvDeR4vSPaqTy2yiJDk9/yzLEtQ8qoBw20Yn5kCpwJRNvT2wqI2uCvfD0QA973rWr8Vvv3MZe18mqsvN/9MYXWiyCUB/fz82bdqEQoQ2oxoazYpkMompU6eis1Nnb2loaGiMFmhhKnfYuf///Q/eePoJAJVlNtH1D2zZrPx7oURmk6EaA0kzyRR0hly2Hym/l/u9hVzOt8ArBVqAxLluXX4twOXt1IgO3hpELXGlCMIp222PnvVrsfm9FVxmk2Oji7sZUI0Geh4lUinks8O+3ehyzEbn7UYHuLazShAUNq0CJSeozTQWi3P20sqKcPn3+ZHhTAnU3+cGhEew0c3bcx9MW7ATHr/jJyFtdHI3Ovu7ctlgQl2Ga3Hz3ifaJnRjZHAAA1vFLp6JZEpJKPodNzkgPNPegQ+c+jHEEglGFFISpWgajBgC3Hsyv07D8NqHVWjtnAAAyPb3u6R8k9wPE0n1eSZbcJl6MlG+Ilij9hj3ZFN/fz82btyIWbNmIZPJNI2fVUOjHFiWhWw2i7Vr1wKAJpw0NDQ0RglJn9BTSjQBFQaEO8Vdvx/ZlAsXEM5jZGhQuawbEB5C2cR9r5HLeUK9w2LSrDkAXKWMWch7AoNrkdk0nhGL28QFU5SUOGZT5s7Dm/94EpvfW8G6eMU9yqbGJZu233MfDPX2YNHBh4HEYsxWR1FgAeG0G503MLtSMGVTyMwmOe+NHjP670ogK5n8yKZMh002ZTmyKWpmEyVjAgPCnX1S7cwmothPrV0TsHXNKtaBjqJj8mRlrci6CEqkvYoYOuCk0wEAT9/zKwCujU7OKPILCGf2sYT/8Y0nEmjp6MTIQD+G+/rs39kkNa6fgk5uLjCwjXYH9NoaNRoH455s2rRpE2bNmoVWx++roTGWQQhBa2srZs2ahXXr1mmySUNDQ2OUwLrRcQojOfOoEhtdpcqmsLYdgMvfCaNskmx0rLNZyEL4o1d9Dyv//QLed+hhAPhudAZHXKltdM0yk9+ooHZJV9kUvD+nzNseALD5vRWYOGs2AM5GF2t8ZVPH5Kk46vNfYu9TWx2FR9lUZgh2EJhyL+T1SJWDlGjlc5qqTzapyfAMy2zqQyEX3UYHALESWVWWZfkGhKdbyySbiv6ZP7SbmyFNDrR3q4kNP2WTGWBBpd9LSXtKNrGwcdohlCMejXzeVpwSUjKrqK1rAkYG+jHUa1urm4V89zvPeGWTaRgY6ukBCNFkU4OjOc66GqJQKCBTZoidhkazIpPJaNuohoaGxiiCWlL44kVu1V0NZRNvw+BRMrMpwjOBFi2hAsIFsinn2wHKDzN3WogDTzmTFVbUlmUKAeGOjU7ObGqS4qpRQfe5WwQHH7PJc+YBALatXQ0jL9nopHyaRoLlE4AuX49uQLjaRlcNlGujo+c+T0BUO7PJ30Y3AQCQHSjPRge4yibbSua17/JqLfm6ZsqmMgPCVUHqfh0FWzrUmVyUJCxKirQg2zCzIzNlk/1sSLe1AQDMguFsp3vN0PtpUF4TRRvNbeppMrLJR9nEZzYN9WyDZRXRPqHbQz5qNBb00UHzyAo1NKoFfc5raGhojC6oSoDPMBru7xOWqSyzKbi4M3I5WMWib8ER1rYDRMvfkW10QWqCMKBKmf7Nm7DxnbfsdTmFXjIlFv/NUlw1Kqi9iNnoShwzGhQ9MjTkDQhnOV+jSzaZRqFkpotfVysP2ZQdhmVZnLKpfCWiH6IHhLvd6ADRElZpNzr5evIPCLdV8u++8Bx7L6qyicRijgXQRNE0PMdMbgbAg5JNOef4hB3jBhFBVNnk+S6f+6xfF8Gg7Y4x0t7eDvpsaGlrQ7a/T9mNjlo5wxCJrU5HusFmI5t8noP8vaN/q63g7Zg0ZVS2SaN8NMdZp6GhoaGhoaHRxHC70bnkS9ZDNlXQjS4oP8YpvuS8KB6RbHRMhRCNbCrkoyubZNBifNUr/8bmVSvt91hAuM5sqibiMtlUgrxIpNOIxeMw8jnkhofsdSRFEmQ0yaaX//IwrjvzBLz74nOBy7FzUiIE5I50+eFhW31iWUgkUzVpuc46lIVWNnkzmygqVTbJZJofCTBp9nZo754ofrYM1VcsQNXlZ6Gj7yVSaVjFoqcBQxCoUkZ1HClxKiPpc58tFRCuVjZR0l7MbEqmMyAkZneCNE3hXKCquqC8JgqqbBrcZoecN8tEs0xyUvD3DmoX75isyaZGh34Ka+DQQw/FySefHLjM4OAgCCG47bbbarINhBDccMMNkT6zadMmXH755Vi5cmVNtqkcXHXVVfjwhz+Mzs5OEEJ8t+3vf/879t9/f7S0tGD77bfH9ddf71kml8vhwgsvxNSpU9HW1oZjjjmmoX6rhoaGhkZ4qLrRZQf6hWUqstFl/LMnM073pKDcJhXZdOApZyqXjWSj48mmkRE3lLdMIiiuaElPi+p4MsmINUBnNlUKShBRQqPUMSOEIN1qW4CG+3oBuORg3DlGo5nZ9PDN9tjq4R95x1g8LB9lU1xho6PXkB/pUClYJplRUNrJZNBjQxsQ8Meo0symWDwhrM+PDE+3tuIzP/yZYD0r5/p2iTbvOVL06URH4XakC2+lCwoI91OK+r3vEmV+AeH+NjpLstEl0mlB4caTLGE60VFQZdOYsdFxAeG0EUbHpMmjsk0a5aM5zjqNmuLGG2/Ed77znbpuw9NPP41TTjkl0mc2bdqEK664oqEImJtvvhmGYWDJkiW+y7z99ts48sgjsf322+OBBx7AOeecgy9/+cv4yU9+Iix33nnn4bbbbsM111yDu+++G1u2bMHhhx+OkRIhrxoaGhoajQdVNzrZRpesyEanLn5j8QQrxIJymwypSDrsPz+H95/8UfU6I4Q9F0bc32vkc4HWlTBIqOwozroIIWw/A81TXDUq6H41QtroADdvhpJNiQboRlcq/4jZ6EplNmWHaxoODtj7mMRigGWFUoHJNjr+GIXJ9QkCIUSwzgWR4bF4HDsf+MGKvs+1onmJb0qG+5FN5YSE+5GMAJBI+ZBaPoqt0sqmIBudqGxKpFKIJ+3lDaOg3B/hMptssol2FSWkOe6HfhlMfEMK2iWwUyubGh46s2kcI5vNIpPJYNGiRfXeFBxwwAH13oSqYNWqVYjFYvjjH/+I++67T7nM9773PcycORO/+MUvkEgk8KEPfQirVq3CFVdcgWXLloEQgjVr1uDWW2/FT3/6U3ziE58AAOy+++7Yfvvt8Ytf/AKf/vSnR/NnaWhoaGhUCFqo8dlJXmVTBd3ofD4bTyZZYRxF2eQ3uwxwwbYliuGXHn0I//rTH9lrW9lEQ3nLG4LKahNALE4S6TQjBJqluGpUsIDwQriAcABIt7YDAIZ7ewG4VrQoOV/VRtEMJpssH0JAJn/z2SwXDl79vCaKeCIJI59D0TBKhh8HdaMjVbD5JdMtLPS71G/e/bCj8OKDf8DkufPK+q6gTnyUcPHbH+WEhBd9guEBIJFU/1Y/kpEqkWT7I71Hqsghb0A4RzYl1MomClUGlAw55LxZlJ5+dj/+3jGwZRMAbaNrBjTHWadREjfccAPmzJmDtrY2HH/88fjzn/8MQggef/xxtgwhBNdeey0uuOACTJkyBbvtthsAtY3unnvuwU477YRMJoODDz4Yy5cv93znvHnzcNFFF+Gqq67C9OnT0d7ejjPPPBN9feJM7YoVK3D88cejs7MTHR0dOPbYY/H2228Ly8g2OrpNv/zlL7FgwQJ0dnZi6dKlWLNmDQBg5cqVbPuXLFkCQgi7ORUKBVx00UWYO3cu0uk0Zs6ciRNOOAF55yZeS4S5kT/44IM48cQThdnZ008/HWvWrMErr7wCAHj44YcBACeeeCJbZtasWTjooIPw4IMPVnmrNTQ0NDRqDRKLMTKJFu/ezKbylU0kFlPmpBDiqp4CySZp9pwqUlSgxEGQjc7I5/HILTegd+N69p6d2eRvKwkDlbKBL7z4grhZiqtGRcyT2RSGbLKLfnqOxz3KpnBZRNVEKTVV0UdtJ1s289nhmtvo7O91VS2lENSNrhpduhKCsimYbJo8Zzucde1NOPlrV5X3XY6aiJ47PIKCtgExJDwsgvKU4j7KJr9Q+HhJG52/IpNuR4HL3+Iz/lTKvDDXohxyTmLNkdnkB550691gP1c6p0yr1+ZohIR+Co8B3HvvvTj33HNx3HHH4d5778Xuu++OZcuWKZf93ve+h/Xr1+PnP/+5MicIAF544QWcdtpp2GOPPfDb3/4Wxx57LE499VTlsr/61a/w6KOP4pZbbsG1116L+++/X1Dd5HI5HHbYYXj99ddxyy234LbbbsOKFStwyCGHYNu2bYG/65lnnsENN9yA73//+/jxj3+MF154AWeffTYAYMaMGbjzzjsBAD/84Q/x9NNP4+mnnwYAfOc738Gdd96Jq666Co888giuu+46dHV1MZm0CpZlwTCMkv9ViqGhIaxevRq77LKL8P7ChQsBgJF6y5cvx+zZs9He3u5ZTkX8aWhoaGg0PlhHOqdgrWZmE+DfAYqSUIUAG52sJlApiCjCdBaTfxtgF05FH8tSWMQVJBhfjPGhztpGVxnocabnRpj9SW10FPR4kToqm0rZ6CgBJhfw8vWYy2aZTSsoI61SUEI1DDEXFBBejfOfJ7DD3J8mzZrj28mtFIKVTU5mkw8JzsgmJ5g+DJjKUqEA81OK+mc2+XWjo+Hz4TObkqkUMh12zt7I4IDyPCjVYRHwKpua6X54wEleCzdVIBZyI+hZvw4kFsOkWXNGe9M0IkLb6MYAvv3tb+Poo4/GD3/4QwDAEUccgS1btuCmm27yLDtjxgzcddddgev77ne/i5122gm/+c1vQAjB0qVLkc/n8fWvf92zbDabxf33389Ikba2Nnz84x/H66+/joULF+JnP/sZVq1ahTfffBPz588HAOy///6YP38+br75Zlx66aW+29Hf34/7778f3d32Q2vDhg340pe+xOx/u+++OwBg0aJFgg3v2WefxRlnnIFPfvKT7D0/sozi9ttvx6c+9anAZQCECmsMQq8jK5/gdIigoL+xp6eH/V9ehi5Hl9HQ0NDQaC6kMhlkB/qRz2bR2jWhqt3oAHUhZllup7pCQKcmsyAWNHInLh7UnhOkbFKRTUYuF1jghYFquwacNtiAqMRopuKqEUFVJLQIDpXZ1CpOklGCIs5UHKVD5asNywr+TtaVTCKbZDVKITvMyCaq4KoFgkgXGXJmEx92XQ1lE0+6VHp/KgWqJFMqmwrBNrrWLrt7HLVvhgElPlUB4b6kVoludF4bnUNkKq6doMymTEcnAPs+aipsoGGUTa2dXba01aldmslW/IFTz0T/5o147W9/Ye9R0cCW1e/BsoqYNGtuxRM0GrWHJpsUmPfV++v6/Su/e0zoZQ3DwIsvvsiIJorjjjtOSTYdffTRJdf57LPP4vTTTxc8syeeeKKSbDr88MMF9c0JJ5wAy7Lw3HPPYeHChXj22Wex9957M6IJAGbPno0PfOADePLJJwO3Y99992UkDACWLbV27VosWLDA93N77rknbrrpJkybNg1HHXUUdtttt5LtPo899lg891xwa1wNDQ0NDY1KIFs9hvurq2wyfOzidDY+KCA8mo2OZo0EKJv6VcqmHCOAyrbRKbaLt0nxNrows/8a/nAzmyLY6GRlU0JSNpXIT6omYvFEqO/zs1PxY8dYPAHTMDDsREXUVtnkkHyhyCaxGx1PalQjsykRMiC8GuA7sMlwu9GpS9e2CRMBAEN94SdkrQAbnR+xlkz7ZDb5HDNGrgcom7yZTWm0OB1Es/39SmVTmMy7WDyOTEcnm9RoNvJd/o20ucTm91YAAKZst/2ob5NGdGiyqcmxZcsWmKaJKVPEgDT5NcW0aaW9rRs2bMDUqVOF9+TXfu+3traivb0d69fbXtr169crv3PatGl47733ArdDVvaknIdcqW5sX//61xGLxXDjjTfikksuwaxZs3DxxRfj/PPP9/3MxIkT0eXMitQS9DfJuVZUrUTJte7ubs8ydDmegNPQ0NDQaB7QArXgBO6ODIqEjJwRExVK5ZJleex7KnhsdAHbEguhUhke8D7DCrmcUoERBTIJNnvhrtj/BFe9zBeJk2Zri0UlIFJmEwlhfZQVP3KXtDAd1qqFeCIs2aRWn/BkU6q1FSMD/RjYZnfBSteQbAqTiUZR8HSjc49RXEFwRAVP3tYyFB1wr20VyWaWIJvanbHxUE9wRAePYmA3OvX9z1/Z5BcQXjqziZJevCUy02krm0YGB9SZTSGPbRunoC018d5okI81PV6abGouaLJJgSjKonpj8uTJiMfj2Lx5s/C+/JoizI1m+vTp2LRpk/Ce/Nrv/eHhYQwODmLGjBkAbNveq6++6vncxo0bMXHixJLbUg5aWlpw5ZVX4sorr8Rbb72FH/3oR7jggguw884746ijjlJ+ZrRsdG1tbZgzZ44nd4m+pllOu+yyC1avXo2hoSG0cbOEy5cv9+Q9aWhoaGg0B2imElU25bKi0qhS5QDtwiaDdaPz+TvgDSMO2hY3aySqsmmE2anKtdHxyqZUJoPTLv+u+HeuQJm6/Q5lfYeGDapgY93oyrDR0SKcJ1Asy6pp4bv5vRV44cH7As93Hox0CCjgUy0ZjAz0Y3DbVvt1DW10YTv3FU0T69+yx49t3faYmidxVQ0DooInb4OstdVAkLLJ7UanViu2OjlRQ73hlU3MRqdQ/Pj9Vr9geDcgvErd6JyQ+OxAv5KgjYfs5tk6oRtY/Z7wfc0C+XoscjY6AJiqyaamQHOddRoeJBIJ7LXXXvj9738vvH/fffeVvc59990X9913n0Cs/Pa3v1Uu+8gjj2BwcJC9vvfee0EIweLFiwHY+UzPP/88VqxYwZZZu3YtnnrqKRx00EFlbyMQTum044474pprrkE6ncZrr73muxy10ZX6rxpYunQp7r33XiGw/K677sKcOXOw6667ArBztwB7f1KsW7cOTzzxBJYuXVqV7dDQ0NDQGF2w9twO2VSI0DkpFJznNj+LbsFis/H5SMqmABtdrLSyyTezqVi6sA8Cv12qYnrAIQMAJ7NEo2zQ48y60YUoVltkG53T1YsQws7LUoHdlcCyLNzxlXPxymOPiO8HqIRYZpNMpnGEWNohigdHQdlE4uFUYO/88xkMbNmM7hkzMXuX9wEQg/fbJ06qfFu4Y15rsoISPLKll38v5kM2tTs2usFIyiZ1VhfgT7b7kU2xUt3oFIosRto7mWJGjiqbUsi0O5lN/f1KdV5YG3IbFxLebGSTTCzS6yE3ZIfAZ6QAdI3GhFY2jQFceumlOOmkk/DFL34Rxx13HP7+97/j/vvt3Kly2v5ecskl2H///XHqqadi2bJleOWVV3Drrbcql81kMjjmmGNw8cUXY/369bj44otxwgknsHyls846C1dffTWWLl2KK6+8EvF4HFdccQUmT56Mc845p/wfDWDu3LnIZDK4/fbb0dXVhWQyicWLF+OEE07APvvsg7322guZTAZ33303DMPAwQcf7LuuSZMmYdKkyh/Kf/3rX7F582Y8//zzAIAHH3wQU6ZMwaJFi9g+ufjii3HnnXfi4x//OD7zmc/gueeew80334ybbrqJzfTNnj0by5YtwwUXXADLsjBlyhRcfvnl2G677fCxj32s4u3U0NDQ0Bh9UGVTPpuFaRRgGgZILMYK4TCBwGGQbEkjN8R1aOPaaPtB/u7AgPAQygv/bnS28qUaAeGqwm/b2tVlrVfDCzcg3FZchLE+yplNCa5gpLa2olEAAsjMSvDeSy8q38+PjPiGelPrk/z7eO1V0iGXBraOgrIpJtqr/PDaE3Z48p5H/oebhcZdV1TtVAlG03rFlE2K7LlSNro2x0a3acU7+PVlX8HR516MzsnqSBEKRnwr7KF+ZLtfNzo/Gx3rRhcpIDzNutFlB/uRbm3zfjZk+Hsr1xmwnJqwnpAJNUo20XMhKFdQo3HQXGedhhInnngirr/+evzud7/D8ccfj+eeew7XXHMNAKDT8fxGweLFi/HrX/8aL774Io4//nj87ne/8+1gd/rpp2PJkiWMGFm6dKlATKXTaTz66KPYZZddsGzZMnzyk5/E3Llz8fjjj1dso2tpacEtt9yC559/Hocccgj23XdfAMCBBx6I3/3udzjjjDPwkY98BM8//zzuuecepraqJS677DKccsop+O53bVn/5z//eZxyyin4zW9+w5ZZsGABHnroIbz99ttYunQpbrzxRnz/+9/Hpz/9aWFd119/PT7xiU/gy1/+Mk466SRMnDgRDz/8MFp8ZlU0NDQ0NBobvLKJqowoAQWg7JbhFJPnzgMAzN11D/dNyx2UB5FZnoDwABudXCSpoFQ25XO+YcxhERO6bXmLjSl0H+y2Z1nr13BBj7NJbXRhyCauMI7FE4KaIh6QyVMtvPXsU8r3c8NDvp+hpIPH6qRQNtHMploGhIcJ4AdcOxF/vfP7u6MKyqbRBL2eZUsvECYg3L13rl3+Gv798P0wjQLWv/2G7360AjKbCCFKwqlUNzr+Ptq/ZRO7D4YLCOeUTVw3OnVAeBnKpmbPbHKOI90fYQk3jfpCH6UxgnPPPRfnnnsue/3Nb34TLS0t2Hnnndl7fnlDjz/+uOe9U045BaeccorwnurzhBBcfvnluPzyy323bf78+fjd734XuP3yulXbdOihh3qWO/PMM3HmmWcK71188cW4+OKLA7+vVlBttwoHHXQQnn322cBl0uk0rr32Wlx77bVV2DINDQ0NjXqDWm/yI1kWEp5qacWJX70cW1avwvQddqxo/Sd85b/x8mOPYO+jj8Nbz7hFN1MMKIo4wH4GR7LRhbD5jKgCwkdGAkN5o0JVcB193sX498MPYL/jT1F8QiMK6P6lSoIwNhyebEqkxHOo1HkYhJf+/BCWP/lXHH/JfyPloy4BgNyw2pqaHx4CoFa6UDtVkHKLkkvU6qRSm1QLpa6vwZ5t2LTyHfRt3AhCYpgwfSb7G99xshqE2GgSFPR8MfPe84MSlH73pXgiiUQyxfLFWrsm4B/3/Br/+O1dmDR7Lk75xrc8ZD6zT/oc93gi4b0v+tj43HPbvlaygwO45Qv/yf6uDAiXQvOpsimZTrtkU38/2rq8kxBhM5v439xsNjp5n7H9VCK/S6OxoMmmMYDNmzfjO9/5DpYsWYLW1lY88cQTuPrqq7Fs2TJkMv4PZA0NDQ0NDY3RA7PRDQ+z3KZUJoOZOy3EzJ0WVrz+zilT8YFTxQkYWBYblPspm1SZIIE2ujDKJlVAeD4XaF2JClUB1z19Jg79xKcVS2tEhUwIhgoI52x08jlNlQoqpUYpPPLjGwAA/37kQex77Im+y1F1iAw/EgoI6kbnnqMpaTxdU2VTiUy031/zTWx4+00AwITpMwQ70XBfb822q9Zg96kylE2AG2QP2Fa0bWtfBwBsXbMKbz3zFPY8UmwARZVNfiRjFHJGDgjv3bBO+LuK0JLvo3T7E6kUWhwb3cjggEs6EsLl8oUj61sFZVNzkU3ysabHK8y5oNE40EdpDCCVSmH58uW444470NfXhxkzZuD888/HVVddVe9N09DQ0NDQ0HBAC9RcdpgpEIJUGtVCUJcnv/dDBYRHzWwayYVSkYRFNQgrDX/IxyhMgds+cRLmvG93pFtbcdTnvyT8jdmkKrDRUWWRHwo+Ifj5gDB+1jFMLl45UY9MLqVrOJlbKhONEk0AMHHmbOFvw729Vd6YUcxscqy7RkBmU1jrVNE0WNdPe53e84YR3z4kahT1ZUwim2SiUEWMeDObHBtdMu0GhA/0M/KtpbUNI0ODwveVQmsTB4TLkwm0sRJ9XmllU3NAk01jAF1dXXjggQdG/XtXrlw56t+poaGhoaHRrKDqiEI2i7xjo/PrblQtWLBK2pdUxX+QfaaUzceyLEY2/ccFX0U8mcR93/8WiqbBCqpa2eg0qgd5/4Y5ZrFYHKf+97eVfytFeoYB7dzlB78Q/KDMJqZwkYrxHfbeD68+/igmzZ7rIZtSo2CjKxUQDgDdM2YJr+nvDyKLo2A0U36ClE1mCOvUB077OP5+188B2GTPCNctW9UB0e1GpyZhotxfXNWevZ254UHh78pcKCmzqcB1o0ukUki2ZFAYySI7OADAPucY2RQ2s4m30TV5ZpMlBYTHk5rGaAboo6ShoaGhoaGhMQpQKptqbXe3LLeluJ+yKWKGTikbnVHIwzQMxJNJ7Pz+gwDYeVUjQ4OsAKyGBaLZZuqbDR6yqUIlGW+jG+7rxfq338CE6TMxadac0OvwiR9l8FM+BdnoTJ/Q+gX7vR+nXf5dTNlue7z8l4eFv/l1tqsGYrHggPBkuoWRSn73j9YqtYUfzWssERAgH4Zs2v+EUzG4bSv+/cgDKJoGRoYGuM+ryKbgZgXRbHRiZlNuSCQ31QHhDqlYFDObaHOGTEcHCiNZDPX0ABDPubCZTZnOThASg2UVm+5+Ke8zej1oZVNzQZNNGhoaGhoaGhqjgBQfEE670dXYRmdZwYoBADAL0TJ0WDHso7xwMzXcYiDdZs/KZ/vt4PBqFD7VUEdp+EMuwis9Zny3sV9f/lX0rFuDRCqNz/345+EzkEoqm9RkU5CNzmI5YmJZRAjB7IW7AvDa6GqpSAxSDpqGwYimRDqN9x1ymHIdsr2uXOx/4ml469mnsP8Jp1VlfUEIUr6FyekhhDBCpmiaGBl0ySZVLl1JG10Zyia67R6ySRUQTrsOmtRGR8mmNAAg09GJ/s2bMNS7DYCYh6Yir5S/IRZHprMTw3297L7dLJDJpKJpolg0beKMxLSytUnQXGedhoaGhoaGhkaTQhUQnqxR0PDhn/kiAOCIc85ldgPDh1SKamtiNh8fZZMqXyXd1g7AtflUo1DQra9rC09AeIXHjCcT+jZuAGDn1Gxbtzb0Ovw6K1P42eiCzvFSChdAVBClMpmaEp1BAeHUDtjS0Ynzbr8bXVOnC38/6b+uxJz37Y4jzjnX89ly0D19Jr7407uw30dOrsr6guAqMMvPbKJ/Nwp5gfCRlU1WsWgz8YT4kqhRjrFH2STZNlUWtlhMvI/y3egAsI509NzlOyCqyCs/tDkqt6ZTNsVlZVPRtdDpe3/TQB8pDQ0NDQ0NDY1RQJoqm7jMplrZ6Hb/8FHY5aBDkGrJYP3bbwCovo3Oz+bDApe5YqGlTcy4qQrZ1GTFU7OhnMymINAC0cjnBKVJz4Z1mL7DjqHWEdQBEQggmwLOcddG538+pTlSuJad6IDggHCahZZp71ASGPP22Bvz9ti7utszStdZPNBGZ58viRJZVPQclbthyve+UqomQAzIn7vr7tjziP/w/15qEXXOa5qtFATXjkxtdG5mEwC0tHcIy4tkU/hrsXVCN7BqZdORTTKhVDQMdhz1REPzQB8pDQ0NDQ0NDY1RgGujG51udHTdpW105SmbStnoVMomtg4dEN7wkMmXSjsIUjJBzk/qiaBsKgaQTZZl+droVJk97HOm2kbHY8q8+ezfg9u2ltrMihAUEE4zz1ra2z1/a3YkAmx0YUkGuu+G+3vFz0v3vjBqNp7MPuUb6tB7irjUjS4XgWyi5zQl2eKOwivT2Sksz5NNUZQ9TNnUZAHh8vVYLJqunbJKAfgatUdzUZwaGhoaGhoaGk0K10ZXe2UTj1JdwKKSTSRWwkbnzO7zIbbpVolsqoqySZNNtYRc7FWqJKOkp1yI925YF3odQTY60zBgFYtK0qhSG11790TM2uV9obezErg2OhXZZOcQyaqXsYCg+1RY+xQlo4b7epWfpyjViQ6Idr7LHT/lzCb1+sX7KLUPJlL2uqiNjoLvLBfl/rlgv/djwrQZo3b+VgseZZNZdAk5rWxqGmiySQOHHnooTj452Is9ODgIQghuu+22mmwDIQQ33HBDpM9s2rQJl19+OVauXFmTbSoHV111FT784Q+js7MThBDltl1++eUghHj+e+ihh4TlcrkcLrzwQkydOhVtbW045phjGuq3amhoaGhEQyweRyKVhmUVWTFUy6BhikQyWNlkRLTRuQHharKJKZt4G52kxCAVdDabs2g3AMAuBx1S9jo0SsPbja46Njq5EO/xIZteefxRPHTjD0Q7WQDZRC10yZa0529BNjpGNpUgL4/90lcxe9Gu+PCnvxC4XKVgwdEKG93YJptsRY+hyGwqhuhGB7jHcLivT/q8RDY5+zbIWkYiZTaJAeEjw6XJJt6OXCya9nlICCNLM+0u2URIDN0zZrLXUTKbdtzvQCy7/hZM5dR5zQD5N1qmVjY1IzQtqIEbb7wRyTpftE8//TS23377SJ/ZtGkTrrjiChx66KGYN29ebTYsIm6++WYsWLAAS5YswX333ee7XFdXl4dcWrhwofD6vPPOw913340f/OAHmDJlCi6//HIcfvjhePnll9EyCsWJhoaGhkb1kcpkYORzrMNQqqW2+S8AZ6OrkrIpFpApA6hVCLwFBAjfuluFEy69HD3r1mLKdtHGDRrRIBfbUYpvFZiNzgnHT2UyyGez6F3vJZuMQgF/uuk6AMBuHzqSvR+kbDIcC10ylfYQWkE2OkY2lejw1TahG6dd9t3AZaoB16bqJXNdsmns2eiqo2ySbHSEAJblDQgPQTAGqZ5keALCnfMv3daGXQ/9sHr9LLOpyH5zIplidjfeRtc2caKQFTYeLMTysTZNwz0PKnh+aIwu9JEax8hms8hkMli0aFG9NwUHHHBAvTehKli1ahVisRj++Mc/BpJNiUQi8DevWbMGt956K37605/iE5/4BABg9913x/bbb49f/OIX+PSnP131bdfQ0NDQqD1o+CudeR9NG51KMQB4VR9d06Yrl6MgXJGkglu8u8PMljZZ2VR+sZRMpZtulr4ZIRfblSubRBtd19Tp6N24ASNDg8gODiDDqXVWvfIv5Tosyz7n+jdvwurXXsbCDx7KCANX2eSdkAu00YUIix5NkDA2uraxp2xKBAaEh1M2URKCkj1tXRMw1NujsNGVtk5GuUe54ff2PTY3bJ/jZ3zzWkycOUu9fi6zyc1rcu+ZvI2uc9IUJNKuYm882Mhk8tcyTe48GPu/f6xA2+jGCG644QbMmTMHbW1tOP744/HnP/8ZhBA8/vjjbBlCCK699lpccMEFmDJlCnbbzZahq2x099xzD3baaSdkMhkcfPDBWL58uec7582bh4suughXXXUVpk+fjvb2dpx55pnok6SrK1aswPHHH4/Ozk50dHTg2GOPxdtvvy0sI9vo6Db98pe/xIIFC9DZ2YmlS5dizZo1AICVK1ey7V+yZAmzogFAoVDARRddhLlz5yKdTmPmzJk44YQTkM+rB9nVRLU64zz88MMAgBNPPJG9N2vWLBx00EF48MEHq/IdGhoaGhqjD9rem8681zIgnMJVDKjVHabzfNz5/R/ESV+7Cmd+69rA9dECbdu6NSywWFifwkaX5rrRERJDMq0Vuo0OmXypPLNJJAISqRQLL5a7h735j7+zf/NkqFW0lU23nn82HrrxB1j+5F/Z3wojNtmUUJxbgcomozTxMJqISV3KeGSd6y3TMfbIpjDKprAB4RStTs5RUQ4Ipza6wIDw8OdDi0MMUTKQnuNyF04ePGlP78H0+QCIZFPH5ClIplyyqVHO1VpCJhaLxaJLNmkbXdNAk01jAPfeey/OPfdcHHfccbj33nux++67Y9myZcplv/e972H9+vX4+c9/juuvv165zAsvvIDTTjsNe+yxB37729/i2GOPxamnnqpc9le/+hUeffRR3HLLLbj22mtx//33C6qbXC6Hww47DK+//jpuueUW3HbbbVixYgUOOeQQbNu2LfB3PfPMM7jhhhvw/e9/Hz/+8Y/xwgsv4OyzzwYAzJgxA3feeScA4Ic//CGefvppPP300wCA73znO7jzzjtx1VVX4ZFHHsF1112Hrq4u1tpWBcuyYBhGyf+qhd7eXkyePBnJZBJ77bUXfvvb3wp/X758OWbPno12SSa9cOFCJfGnoaGhodEcoLPTtBgZFWVTCRsd7eCVymQwb/e9PMG0MmgRtmnFO/jJud7xBm3/zRcLvLKpa+q0ki3MNeoPuaCtJGcL8NroEqk0WhzSZGRQJJs2vP0m+zd/3lIbHT3Htq5Zxf5WyLs2OhmmUcBQb4/nfatYZGqpRmkNTwK6PY7lzCZKtJgKBWZoG510ztJQbVm9SVWZwTa68IQOvWdmB/phFYvIOZlNqVZ/sonv6il3ogPArg0A6Jg0WVA2RclsalbI+79omlxXQv38aBaM/TN1HODb3/42jj76aPzwhz8EABxxxBHYsmULbrrpJs+yM2bMwF133RW4vu9+97vYaaed8Jvf/AaEECxduhT5fB5f//rXPctms1ncf//9jBRpa2vDxz/+cbz++utYuHAhfvazn2HVqlV48803MX++LXnff//9MX/+fNx888249NJLfbejv78f999/P7q77QfFhg0b8KUvfYnZ/3bffXcAwKJFiwRL2rPPPoszzjgDn/zkJ9l7fmQZxe23345PfepTgcsAwVkBYbFgwQL8z//8D/baay8MDAzg5ptvxkknnYR77rmHKZl6enowYcIEz2e7u7vR0+MdLGloaGhoNAcSUiGcHAVlUyweBwiBZRVRNE3PID4/ko20LXxRnlME4aqUIryyaeKs2eE3XqNu8Hajq05mE1XDJVIpz3sUvOVTCLC3ROtmq6OMAgBjxN9G984/n8E7/3wGS846G3svPY69T9vOx+LxhmkNHwtDNrWN4cwmRZh72GBoj7LJIYH8bXRBAeFRMpsSSLe2ITc8hIFtW1E0TSRS6UBSXZ3Z5C7PB4R3TJqCJE82lcgXGwuQVWzFosmOYyKpKYxmgT5SKlzeVefv7yu9jAPDMPDiiy8yooniuOOOU5JNRx99dMl1Pvvsszj99NOFh+6JJ56oJJsOP/xwQX1zwgknwLIsPPfcc1i4cCGeffZZ7L333oxoAoDZs2fjAx/4AJ588snA7dh3330Z0QSAZUutXbsWCxYs8P3cnnvuiZtuugnTpk3DUUcdhd12263kAOLYY4/Fc889F7hMtfCxj33M890HHnggrrzySsE2p6GhoaEx9kAzmyhGQ9lECEEimYKRz8EsFDwFGbUfpUI2nyg142+adPaZCwjniuPumZpsagZUPbOJ5ukMu2QTVbNkB0Rlk8lFH9Dgb8BRgXB/44PnqUIvmU5j/xNOwzP33oVdlxyBVx57mC3z15//VCSbHIVUo+Q1Ae62qAL4qTqLJ9nGCui5YOQVNrqQLe9lgiLVaodqe8mm6iqbADvQOzc8hF6nu2I6wEIHiDY6Sq7yZBr/rGhpbxcmKsZDQLb8G4uGm9mklU3Ng7F/po5xbNmyBaZpYsqUKcL78muKadOmlVznhg0bMHXqVOE9+bXf+62trWhvb8f69esBAOvXr1d+57Rp0/Dee+8Fboes7Ek5N90RZ1Dsh69//euIxWK48cYbcckll2DWrFm4+OKLcf755/t+ZuLEiejqqg/JSAjBiSeeiEsuuQSmaSIej6O7u9uTfQXYiieegNPQ0NDQaC7ws9Oq17VCPJmAkc/BMApIQiSVoiqbSmX3UGVT3CcgfKImm5oCHhtdpZlN1EY3zNnonPPCq2xyCQca/A3YpMFgjxvDUORC6ulyiVQaHzjtY9jrqP9Az4Z1AtlE5x7Xv/0G7v9//4MPnPZxAI2lFKEkn6obHf3t7RMnjeo2jQaClE30HiUrQ2XI5BHNxPOQTcXSOV1RQ6gznV3o3bAem1a8AwBo6woer/MB4dQ6yGc28Wjt7JKUTWO/hA9SNumA8OaBPlIqRFAW1RuTJ09GPB7H5s2bhffl1xRhJMLTp0/Hpk2bhPfk137vDw8PY3BwEDNmzABg2/ZeffVVz+c2btyIiRMnltyWctDS0oIrr7wSV155Jd566y386Ec/wgUXXICdd94ZRx11lPIzo2mjU4EPOAeAXXbZBatXr8bQ0BDauJmR5cuXY5dddqnJNmhoaGho1B5CMUFIyeKpWgjKbeIVIWFASqhAmFqEt9G1ahtds0E+zhUrmyjZ5OSVJVNplj0kZzbxNrrCiKtsMg0Dg1u3sNdFjkRg53FLCwghaJvQjf4t4jiVELvA//OtP0Lfpo144H+vsX9bAyqb5IBwI5/HyEA/YvEEWjvr7MKoAeg9ypAa+liWhf4tdl3TOVk9+U0hk4apjK1sKvrY6IICwg/5+DJsfm8F3n/SR0NsPdgxWf/OWwCArhIT/LyNjqq54ilRsXP42edi/VtvYLvd9lR+dixDJpSKpunaKbWyqWkw9s/UMY5EIoG99toLv//974X377vvvrLXue++++K+++4TiBU5wJrikUcewSA3G3XvvfeCEILFixcDsPOZnn/+eaxYsYIts3btWjz11FM46KCDyt5GIJzSaccdd8Q111yDdDqN1157zXc5aqMr9V8tYFkW7rnnHuyxxx6IOw+9I444AoC9PynWrVuHJ554AkuXLq3JdmhoaGho1B58yGsylR61nJigTk+FqMomyV5lFUUFhtuNzi0WeEtI9/SZob5Ho76QyaWKM5uc4pGSkYlUipFN/37kQTx9968A2OMik7NS0fMTsEmDgZ6t7muTJ5uczCauG52nKHWuN9miFqXNfa3hFxBOVU1t3d0NE2ZeTVCiRVY2jQwOoDCSRSrTWtKaJueMJZmySQoIp5lNAed09/SZ+MwNP8WuSw4Ptf2ZDpts2vD2GwCArqnTA5dnx7lo+iqbdj/sSBz52fNAYjHhmKvyvMYaZGWTxQWEa2VT80AfqTGASy+9FCeddBK++MUv4rjjjsPf//533H///QDKY74vueQS7L///jj11FOxbNkyvPLKK7j11luVy2YyGRxzzDG4+OKLsX79elx88cU44YQTWL7SWWedhauvvhpLly7FlVdeiXg8jiuuuAKTJ0/GOeecU/6PBjB37lxkMhncfvvt6OrqQjKZxOLFi3HCCSdgn332wV577YVMJoO7774bhmHg4IMP9l3XpEmTMGlS5ZLkv/71r9i8eTOef/55AMCDDz6IKVOmYNGiRWyfHHLIITjppJOwyy67YGhoCLfccgueeeYZ/O53v2PrmT17NpYtW4YLLrgAlmVhypQpuPzyy7Hddtt5Mp80NDQ0NJoHvJJJFWRcs+8NsKhEzWySC3PDKAgdwGghJBcE/3HBV5HPDrMOURqNjbhMNlWqbJKIn0QqhYzTcSs70I+n/u9O7HzgweiaOo11iANkG11BUDaZhops4rJtpO+k5G5G6vYr/9Z6wi8gfNAh2dq7a+MMqDcSnPrSsix2rPo32+q0rilTS5LzXhudfU/zt9FVj7TLdNqB3mx7S5BNgrLJoN3owil2xgPZJD8/TJOz0elupk0DTTaNAZx44om4/vrrcfXVV+OnP/0pDj30UFxzzTU49dRT0dkZ3L5YhcWLF+PXv/41Lr30Uhx//PFYvHgx7rrrLuy3336eZU8//XR0dHRg2bJlGBwc9ASTp9NpPProo/jyl7+MZcuWwbIsHHroobjnnnsqttG1tLTglltuwRVXXIFDDjkEBefhdOCBB+Kuu+7C9773PRSLRSxatAj33HMPU1vVEpdddhn++te/stef//zn2fuXX345ALsb3XXXXYf169cjFoth7733xv333+9RLF1//fVoa2vDl7/8ZQwPD+OQQw7Br371K7SMYnGioaGhoVFd8Aqf0SSbgm10tItXeZlNZl4km1iIq6Qy2Pn9lSmaNUYXMqlYrcwmikQqjUx7h/CeWcgzlQdFISfZ6LZtFV5TGMwOyimbpO8kMZus4K15QGMpm/wCwunvHot5TYB9fsXiCRRNA6ZhMIK8b/NGAEDn1NK5s14bnaNsku57bje66h132vmOoqvE9gqZTXkaEK7ObJJhmkbphZoc8vNDK5uaE/pIjRGce+65OPfcc9nrb37zm2hpacHOO+/M3vPLG3r88cc9751yyik45ZRThPdUnyeE4PLLL2dEigrz588XVDsqyOtWbdOhhx7qWe7MM8/EmWeeKbx38cUX4+KLLw78vlpBtd0y/FRiMtLpNK699lpce+21FW6VhoaGhkajgFdd8EVxrRFko8uPeBUhQZDVA4ZEDrgB4Y1TwGtEB1+IExKr2PIpF4i8jY4in80K4eCAV9k0sI3LbDIVmU2CskkudezfMNTXI7xbTdKhUvgFhI91sgmw71NF04BZyDOyqX+TQzZNCc5rArwdzGhAuDezqXQ3uqjISDlaJW10Tn4YLIvlVCXCKpuMcaBskq5JPiB8PASkjxXoIzUGsHnzZnznO9/BkiVL0NraiieeeAJXX301li1bhswotFTW0NDQ0NDQCAc+k2O0OtEBXPiu0kYXLbNJVoHIShQWEK4LgqYGX4hXw27kVTal0CKpQfLZYU9AdGFE7EaX7e8XXrPlHLKJz0VTKZssy8JQr0w2Nc65Sokvyyezqb177JJNiWQShZGsQIr3MRtdCGWTdG9KOgHhfja6airahNB2QkqSY3ZzoBgsq+h2UgypbBqtrL96QlZSFk2TqWZ1QHjzoHHurBplI5VKYfny5bjjjjvQ19eHGTNm4Pzzz8dVV11V703T0NDQ0NDQ4CBkNjWIsilqZhMklbGRF9epCgjXaD4IyqYqFOXezKY0WqTspPxIVmGjc8mmomGgkOUCwzlCpqgoRL2ZTTHkhoY810Ejdfci49RGB7j3R/6Y046CYZRNMtnEbHQS2eQGhFcxs4kjTtsnTgqlUool4jALReSdc7pUFtHBZ34Kbzz9JHY56JDKNrZJYeRtQlmTTc0DPQoYA+jq6sIDDzww6t+7cuXKUf9ODQ0NDQ2NZoZgowupJKoGAsmmiJlNI0ODwmuPjc4nIFyjuZDizodq2I08Nrp0GulWsbuY0kYnKZtGBge41+6yRacrIk84yN9JCPGomuTP1Bt+AeFDvVTZNDYDwgEg3daGga2bkRseZu8NOIHwHZOmlPy8THBTAr1oGkLouBsQXr3jPmnudpi+w44o5HLY//hTSn8AdkdSs1Bg99RSZNO+x52EfY87qeJtbVZQ9WI8qZ8tzQJ9pDQ0NDQ0NDQ0RglCQHgdbHTBmU3hlE1T580XXstKFK1sGhtIc6qjaihAVDY62Q6Uz2aZeoFCzGwyMDLokp18Fo8q9NlDePqSTY1zrvqRTflhW/0iE3RjCS1t9jnHH2OqZEu3lf7dckB4PJFkoeNF02D3QbpvSRUzm5KpNM789g8ifSaRTgNDg+z38s8HDS8o8ayVTc2DxtGMamhoaGhoaGiMcdStG11SndlkFYucsikc+ZXp6MQXbv01Zu68CICq05PTnrqB1CIa0UELf6A2Nrqkk09z9LkXsffy2WGYeTkg3CWfckODgpLO5IKSWVYYRyDYHc74oHPCFEJd09wA52pkUlULMa5LGQ/3Oh27XYkpoZQbdsmmvJMplwqhvJQVePFkkhGOpkBMUhVcfY87nXCgar2wmU3jFa6NrnHIYY1gNM6dVUNDQ0NDQ0NjjCNRp250CVpwScSQkc8DloVEKh3JKtXS3s7yUGTbk+4YNDbAk03VsBt5u9HZ18LCgw7FB884C4BNLMi2TF7ZNNzXK/ytyNvoTHXoM09y8Ta6SbPmsPcb0UYnB4SzIP9RvG+MNpiyibPqFiJ0y/QqmxIu2cTdpyxqo6uisqkc0GsgR210+p4ZCK1saj5osklDQ0NDQ0NDY5SQSNYpINxRVMlkUyVqCRqAqzObxiZ4YlS2dJUDlY2OgqpW8tlhD3mZ5zKbZJh8QLijBJIVdfx5KJBNs+ey9xvJRkfJMjkgnCq8xjLZRC2CuaEhAI7yMu/tMuiHuHQc48mkm1fHK5sU+V71AP1NLLNJ2+gEHLbs89h1yRFo7ZoAAOxc0BMZzQNNNmloaGhoaGhojBLEgPBRJJtoZpOhLuTLKWDjjuXDzPtlNjWOWkQjOvg8Jb4DXLkIJJsylGxyu9HRc9LIiRlOPFSZTR7LH5c3VSwWMeyQTd0zZ0X9CaMCqrbhCT7LsiLbXZsRaUfZRJU+UZWX8rGPxROMmCiV71UPJFPURudkNmkbnYA9jzgaR372PHac6DUQptOfRmNAk00aGhoaGhoaGqMEMSB89DObPMomlodSibLJJ7NJWx2aHoTYpYKsXisH8vlALUQAkMq0AnCUTQ55mW6135MDw50NAyB1o1NkNgGuZYouP+iQTe3dk9j79DpoBKgCwk3DQNE0EYsnxvR11eJkNo04yqaoysu4FA5PCOEymxSWy7rb6OzngZvZNHaPbSVgZNOIVjY1GzTZpKGhoaGhoaExShADwkdPoZCQyKbejRtwxyXn4dW/PupsSznKJrpOyUanlU1jBlRxVA14yKY0TzY5yqaRLDtH01xmlIw2x1bDEzJ+oc9W0WL/NvMFpmxqm9DN3s9XQblVLVCyjCfJxoOqCfAqm6IqL3k7JL0/uapOV9nEMpvqHBCecH4XPb6y+k/DBn2WsIBwvZ+aBjW9wgghRxFC3iCEvE0I+WrAcicRQixCyGLn9SRCyGOEkEFCyA3SsvsQQl521nk9kXumakTGoYceipNPPjlwmcHBQRBCcNttt9VkGwghuOGGG0ovyGHTpk24/PLLsXLlyppsU1S88cYb+MIXvoCFCxeitbUV8+fPx/nnn4/e3l7Psq+99hoOO+wwtLb+//buPD6q8uz/+OfOZJts7IQlICB7AQsEARcIKktAMKBCqnWNaysFWUQqVSAo8rBoKYuIC1ipgAJKBRe0tT/UyGr7iILKI7sgUBAMCZDl/P6YhZnJJGSZZEjyfb9eeZFz5p4z9wxzMjPXXNd1R9GoUSOefPJJr74D4EiZfuaZZ2jSpAl2u51evXrx73//u2LujIiIlItgNQj3LaP7NmMjx/b+wLZ17zjmUoyVnny5Sj5yz6tBeFUVFshgU5hvg3B/PZsuNAgPd2Y2+RPlDBR5BRDcpVHet2NZF4JNuR6ZTV7Bpksqs6nganTuJtmlOE8rE3ewKcuZ2VTCzEvPBuGuv3khfleju7TK6FxsKqPzyxWAdZ2n6gdYeZTb/5QxxgbMB/oCB4Etxpi1lmV94zMuFhgFbPLYfRb4E9DB+eNpIXC/c/x6YADwXnnch+piwYIFhAU5QpyRkUHz5s1LdJ2jR48yZcoUkpKSaNasWflMrAQ2bNjAZ599xsMPP0ynTp344YcfmDRpEhkZGXzxxRfupWxPnjzJDTfcQPv27XnnnXf4v//7P8aOHUt+fj7Tpk1zH+/ZZ58lPT2dmTNn0rZtW+bMmcMNN9zAjh07aNCgQWHTEBGRS5hX6VAFfnB0fRN8bP8+rPx8wnwa0ZamfMPVzFYNwquuCHsUmRcfViyemU322DivrClXUCvnbLZHGV10oceKrlmLY1wonYMLDbV9AwiWle+5wdlfTmNMCPa4OPfu89lZJb9D5cTdIDzPT7CpCjcHB48yOmcPo5KW0bnKPuHC88Dmt2eTMwsu2GV0Pk3P1bPJP9fr5vksx3lqsymzqbIoz3cBVwK7Lcv6AcAYsxy4CfjGZ1w6MAMY79phWdYZ4FNjTEvPgcaYhkCcZVlfOLdfA1JQsKlUsrOzsdvttG/fPthToUePHsGeQpn95je/4fe//727oWZSUhIJCQn079+fjRs30rt3bwBeeOEFsrOzWb16NXFxcfTt25fTp08zefJkHnvsMeLi4jh79izPPvssEydO5JFHHgGgZ8+eNGvWjHnz5nkFpUREpPLw7tlUcSUxza7owudvLuP/tn7B/378foE+S579a4ortJAyOjUIrzoCGRD1fD5ce9vdXh/0I5w9m85lZV0oo7MXntnkKqPzylYp7HnnUUbnElWjhtftX5JldHl+yugq8G9GMET6ZDaVtIzOs+DFOL/kdWd1evzNcwUmCzSTr2C+/5+2cAVR/HGVj7qeF75ZknLpKs8yusbAAY/tg859bsaYLkATy7LWleCYB4s6ZnU1b948mjRpQnR0NCkpKXz88ccYY/jkk0/cY4wxzJkzh9GjR1OvXj06duwI+C+jW7VqFa1bt3aXb+3atavAbTZr1oxx48aRnp5OgwYNiImJ4fbbb+fUqVNe4/bs2UNKSgpxcXHExsYyePBgdu/e7TXGt4zONae//e1vtGzZkri4OJKTkzl40PHfv3fvXvf8+/TpgzHG/QKTk5PDuHHjaNq0KRERETRq1IihQ4dy/nzZm1sWpU6dOvhWdXbu3BmAH3/80b3vvffeo3///sR5fKOWmppKdnY2//rXvwD4/PPPOX36NMOHD3ePiY6OZvDgwbz3nmKrIiKVlec316HhFffBsX6zFvS85TYAjh/Y5y6n65I8hP4Pj6bnrbeV+Jju1egKaRB+KS0nL6UT6BUTr73tbrrddAsd+vT12u/Kcso69TOHv3e85ywqs8lVRpef69GzybWcfYj3xxvPcjTf61fkOVhc7gbhnj2b3OVk1aOM7uwZ38ymUtxv53ty2yVcRuf7/FNmk3++j1NVbpJf1QTtXYBx5DnOAe4up+M/ADwA0LRp0/K4iUvGmjVrGDlyJL/73e+46aab+PTTT0lLS/M7dubMmfTq1Yu//vWvfl98AbZv386IESMYOnQof/7zn9mxY4dX0MPTG2+8QcuWLVm8eDGHDx/mscce47777uPNN98E4Ny5c1x//fWEhYWxePFiQkNDeeqpp+jduzdfffUVtWvXLvR+bdq0iR9//JHZs2eTnZ3NqFGjeOCBB1i/fj0NGzZk2bJl3H777cyfP58uXbq4rzd9+nSWLVvGs88+S/PmzTly5Ajr168v0BPJk2VZRV7uElrCkoCMjAwAWrdu7d63a9currvuOq9xTZs2JSoqil27djF48GB27dqFzWajVatWXuPatWvHihUrSjQHERG5dHh9817BbSddJSp5ubnuAJE9No4OSTeU6njunk0Fgk0qo6sqAtkgHODKm/z3CPXMXNnz722O2y6iZ5MrE8/fCmO+vcK8yuhc13cGm8Ltdv+r3QWRv9Xocs455lhtMptcq9GdLX1Gl/ENNuVdeK64+3uFBLdBeIHMJjW+9ss3s02PU+VRnu8CDgFNPLYTnPtcYnH0Y/rE+cegAbDWGDPEsqytRRwzoYhjulmW9SLwIkBiYmLB/Nkq5JlnnmHgwIHMnz8fgH79+nH8+HEWLlxYYGzDhg0vGqx49tlnad26NStXrsQYQ3JyMufPn2fSpEkFxmZnZ7Nu3TpiYhwvDtHR0dxxxx3s3LmTdu3a8eqrr7J//36+++47WrRoAUD37t1p0aIFixYtYuLEiYXO4/Tp06xbt45atRxvCI4cOcKjjz7qLv/r1KkTAO3bt/cqw9u8eTO33XYbd911l3tfYcEyl6VLl3LPPfcUOQa8m0xeTFZWFhMmTKB379507drVvf/kyZPUrFmzwPhatWpx8uRJ95iYmBivJVxdY7Kysjh//jzh4fr2Q0SkMjMV/EEnxN27JM8dICrLm/bQ8MLK6BzHVmZT5RdeRClbIPk7F4rKbKrbxPFFst+eTT59eKwiMpti69Ql69TPJZ5veXIFQPL9ltFV7Z5NoRERhNhs5J4/R25OTpkyulyPY4if1ehcf6OCnSFTMLNJQRR/fINyVT3Dryopz3cBW4BWxpjmOAJCqYA7R9uyrFNAXde2MeYTYFwRgSYsyzpsjDltjOmBo0H4ncBfAj3xjks7BvqQJfLVXV8Ve2xubi5ffvmlO9DkMmTIEL/BpoEDB170mJs3byY1NdXrG9dhw4b5DTb17dvXHWgCGDp0KJZlsWXLFtq1a8fmzZvp0qWLO9AEkJCQwNVXX82nn35a5Dy6devmDjQB7t5Shw4domXLloVdjV//+tcsXLiQ+Ph4BgwYQMeOHS/67fHgwYPZsmVLkWNKwrIs0tLSOHr0KOvWFbdKVEREqoMr+g3ivwf2Ua9ZyRbGKCubM/iTn5frDhCVZfUj1wc139XoXKVNnitDSeUU6MymkogoIrMprl48AHmeZXS5xS+NcvV8GjhyHO/Pf46rR9xRhpkGlrtBuEeQzLUKV1Vfjc4YQ0R0DNmnT3E28xePVfhKkdHlk9nk2SA8EMH2QCiY2aQvkv3xDbIGurxXyk+5BZssy8o1xjwCfADYgFcsy/raGDMV2GpZ1tqirm+M2QvEAeHGmBSgn3Mlu98BSwA7jsbg1bqBzfHjx8nLy6NevXpe+323XeLj4y96zCNHjlC/fn2vfb7bhe2PiooiJiaGw4cPA3D48GG/txkfH8++ffuKnIdv9o8rk+es84WnMJMmTSIkJIQFCxYwYcIEGjduzPjx4xk1alSh16lduzY1atQo8rglMWHCBNasWcOGDRu8Am3gyE7y7WsFjmwmV3CtVq1aZGZmkpeX55XddPLkSaKiopTVJCJSid2Q9nBQbtf1ITwvL89dRleWb9ILX43O8aFOZXSVX9dBQ/nPhvfoNnhYud9Wj2Ej+GL1hez7wrKqbKGhHgEEf02fL54xGOUMNtVulMBtT88u7ZTLhes89WoQftZZRleaoEslU7tRYw6dPsWef2+90CC8FEG2AmV0l2RmU3iR2+Lgu2pfMIPgUjLl+i7Asqz1wHqffU8WMjbJZ7tZIeO24ii/KzclySwKtrp162Kz2Th27JjXft9tl+L0h2jQoAFHjx712ue7Xdj+rKwsMjMzadiwIeAo2/v6668LXO+nn34qsl9TWURGRjJ16lSmTp3K999/zwsvvMDo0aNp06YNAwYM8HudQJbRPffcc8yaNYvly5dz7bXXFri8bdu2BRquHzhwgKysLNq2besek5eXx+7du2nTpo173K5du9xjRERESsL1wSo/N4fcHMdbwDKV0V10NToFmyq7mvENGP36mgpppHz1iDuIrlmbj19xZOaHR9oxJqRAz6Ua9Rt49OHxyGxy9QorxvPOHhe4LxgDzVUG6NUgvJqU0QF0vK4/h3Z9w38+fI8mv3JUm5Tmfhvn4+j6G+fZ3yvPmY0ZGuTV33yDKFW9J1dpef3/G3NJNvYX/4LbFU3KLDQ0lM6dO/POO+947V+7tsjEsSJ169aNtWvXegVWVq9e7Xfshg0byMzMdG+vWbMGYwyJiYmAoz/Ttm3b2LNnj3vMoUOH+Pzzz7nmmmtKPUcoXqZTq1atmDVrFhEREXzzzTeFjnOV0V3s52KWLVvG2LFjmTNnTqF9opKTk/nggw/45Zdf3PtWrFiB3W6nd+/eAFx11VXExcW5G62DI5D397//neTk5IvOQ0RExJerrC3fI7OpbMGmizQID/JKTxIYFbliV2zdC5n5tvAwv8/PGvEN3IFMz9IoVyZQcZazj4qNu+iYYPHbINyd4VP1g02te15DRHQ0P/3wPccPOKogSnO/XV+vuwOTOZdeZlOYR9AkIjq6WgQTS8MzCBceGVnhi2tI6ekrpypg4sSJ3HzzzTzyyCMMGTKEzz77zN0nqDSrLEyYMIHu3bszfPhw0tLS2LFjBy+//LLfsXa7nUGDBjF+/HgOHz7M+PHjGTp0qLu/0t13382MGTNITk5m6tSp2Gw2pkyZQt26dXnwwQdLf6dxrOBmt9tZunQpNWrUICwsjMTERIYOHUrXrl3p3Lkzdrudt956i9zcXHr16lXoserUqUOdOnXKNJ9//etf3HPPPfTr148ePXrwxRdfuC9LSEggIcHR2/6hhx5i7ty5DBs2jAkTJvDDDz8wefJkxowZQ1yc481PZGQkjz/+OOnp6dSqVYu2bdsyZ84c8vPzGTlyZJnmKSIi1ZPrA3pebq67n0lZltp29RfZ++9tvL/gOQb87lHn8Z0NwrU8tZRQbB13O1dCw8KxhYUWWC2uduMm/kuj8vw3CPfH7iyjuxT5Bpu2/n01m9Y4ygurQzAiLDyCek2bc3DnDo7v3wuUriG0q+m8K6DkmYF5qfRs8sxsiq1dt4iR1ZtnsKmq9y2rapTZVAUMGzaMuXPn8vbbb5OSksKWLVuYNWsWgDt4URKJiYksX76cL7/8kpSUFN5+++1CV7BLTU2lT58+pKWlMXr0aJKTk70CUxEREXz00Ue0bduWtLQ07rrrLpo2bconn3xS5jK6yMhIFi9ezLZt2+jduzfdunUDHFlBb7/9Nrfddhs33XQT27ZtY9WqVe5sq/Lyz3/+k5ycHD744AN69uzp9fPSSy+5x9WqVYuPP/6YvLw8Bg8ezFNPPcWjjz7KlClTvI73+OOP88QTTzB9+nRuvPFGTp8+zYYNG4rVd0tERMSX54fYgGQ2eZSgfP2vj92/uzOb1CBcSiiu7oVeoLawcK/Mk4joaBq0bE33ocMvrKyYVzCzKaQ4PZsu4TI6V5AkPz+fs2cy+dfrr7gvqw7BJriQ4ZZ54r9A6crLXNkvkTGxAJzNvFBR4Ao8lSXYHgiemU0xdRRsKkyoV2aTgk2ViTKbqoiRI0d6ZbxMmzaNyMhIr34/hfUb+uSTTwrsu/XWW7n11lu99vm7vjGGyZMnM3ny5ELn1qJFC95+++0i5+97bH9zSkpKKjDu9ttv5/bbb/faN378eMaPH1/k7ZWHiz0Ontq3b88//vGPIscYY3jiiSd44oknAjA7ERGp7jyzQVzLwZeljMR35aTcnBxCw8LcpU0hahAuJRQRHe3+PS8nxysY2rn/je5V41zvB/Pz8rAsC2OMu8eRb6+wG0dP4N0//w82m82dCXVJ92zyaBC+67P/53VZeDUoowOIq+u90FFZGoTbnSWTWacvLM4TiGB7IHhnNpWtwqIq8wyyVodS0qpE7wKqgGPHjjF9+nT69OlDVFQUGzduZMaMGaSlpWFXt34RERHhwofw/LxcrDxnGV0ZGuT6ZgVk/3KK2Np13R/oi9OoWcSTZy+W6Fq1vFZLNB7lccYYQmyh5Oflkp+X6/zdVUbnndnUpue1tOp+FW//Tzp7vtwKlG0VxvLmmYH47efewabQavJB2zPDDUoZYHA+D1yBxexfTrsvulTK6DwztmJURlcoZTZVXnoXUAWEh4eza9cuXnvtNU6dOkXDhg0ZNWoU6enpwZ6aiIiIXCIuLBefh4Xl3FeWzCbv62adcgSb3B/6FWySUrj3+UWcOvoTdRo38Xp++jYqDwm1kZ+XS15uLsY4AgvGhLjL0LzGhtg4n51dvhMPEM/V6DJP/tfrMtf9rOpifTObSrManU9mk2ew6ZLJbPIoo4tVGV2hPP//w5VIUanoXUAVUKNGDdavX1/ht7t3794Kv00REREpHdeH9bzcHHcZXWh46XuW1IxvwFXDb+fzlcsAyD59igNf/y/nss4AF4JbIiVRq2FjajVsDHiXavoGm2yhoeSeO0debq47QFNUv6bzzuflpc4zs8k3QBbpUWZYlXmW0YXYQqkZ37DEx3AF5uzO/rXZpz2CTc5FDEKDvRqdyuiKxbO3VXXpW1ZV6F2AiIiISDVwoalynruxclmX/u5582/474H9fJuxkdPHjrJh8TyP21ODcCkbzx5OvuVxrudufm4u+c7ndlHZdOcqSWaTKzPLys/n/FnHnFOnzuTkjwdp3PZXwZxahfHMbGraoRMRUVElPoYJcWQ2RfkrozvvaBBuK0OwPRA8S5FjFGwqVKhWo6u0FGwSERERqQZsHj2b3D1LytCzycXVE+XEjwe99quMTsrKtZIYFGw4fyFTLxebu3Sz8ADn+eyscphh4BljMCEhWPn55J47B0CjVm1o3KZdkGdWcTz78jRu075Ux/BdjS77l9NY+fmYkBB3ZlNZg+1l5VnyGa1gU6G8yuiqSd+yqkLvAkRERESqAVemUV5e3oWeJQH4sOXKHPj5pyNe+z2bPYuUhj0mxv17SEjBMjpwZeo5gk2miGBTTK3anM38heiatcphpoEVYrOR5yx1DYuI9NuHqqpr0/NaDu7cQae+yaW6vquMzhYaSkRUNOeyznA26wz2mFjychyZnZdCo/ihE54i59xZ7B6BVfHmWW6onk2Vi4JNIiIiItWAezW63FxycxxlJGXp2eTiymz6+ciPZT6WiCevzCbfBuHO53Nebg75eY7nsW+pnacbRz/OxjeWcs2I35bDTAMrJMRGHo6AcHX9cD1o1GPk5+WWOiDuKqMDR9+mc1lnyD59GntMrPvvX7AbhAO06NIt2FO45HlmNqmMrnKpfmFyERERkWrowmp0uQHObHI04D119Cf3vm433VLm44pERl/IbDI2355NF57P+cUoo6uT0ISU8ZOo27RZ4CcaYJ73o7oGm4wxZfr75Llyn3tFutOngEtnNTopHu+eTSqjq0wUbBIRERGpBlyZILk5jtXojAkp8sN5cUXF1XQc97yjv0yr7lfR67a7y3xcEa/MJp8yOs+G91a+K9hUNYo2PMsBlclRMrUaJQBwWcdfu/e5g03OJuHunk0KNlUKniubejZVl0ufgk1CUlISt9xS9DeQmZmZGGNYsmRJuczBGMO8efMuPtDD0aNHmTx5Mnv37i2XOZWGMabAT48ePQqM++yzz+jevTuRkZE0b96cuXPnFhhz7tw5xo4dS/369YmOjmbQoEGX1H0VEZHKxdWzyRUUsoWFBaSvkquMziXcXvKVo0T8KapBuM2jjC4v1xVsqhofbTzLAatrZlNpjXhqOgMfGUu3m25277N7rEhnWZY7syk0yA3CpXi8XqfUCrBSqRrhfymTBQsWEBbkyH5GRgbNmzcv0XWOHj3KlClTSEpKolmzZuUzsVIYO3asV/AuNta74d/u3bvp378/N954I9OnT2fz5s2MGTOGqKgo7rvvPve4P/zhD7z11ls899xz1KtXj8mTJ9O3b1+++uorIpVCKiIiJWTz/bAeFpi3gXZnGZ2LPhxLoEQW0SDcndmU65HZFFL2TL1LgVcZnTKbSiS6Zi3aXdvHa5+rHPPsmUzych3NwUNsodWy8Xpl51keKZc+BZuqsezsbOx2O+3bl25J0UDyl/1TWTVr1qzI+zNz5kwaNWrE66+/TmhoKNdddx379+9nypQppKWlYYzh4MGDvPzyy7zyyivceeedAHTq1InmzZvz+uuvewWlREREiiMkxAbGgGUBgStHsMfEYkwIluVYPStCmU0SIN4Nwn17NjkCMqueeZJhf5ziHFMFg006n8rMb786ldBVSlrltHJRaLCKmDdvHk2aNCE6OpqUlBQ+/vhjjDF88skn7jHGGObMmcPo0aOpV68eHTt2BPyX0a1atYrWrVtjt9vp1asXu3btKnCbzZo1Y9y4caSnp9OgQQNiYmK4/fbbOXXqlNe4PXv2kJKSQlxcHLGxsQwePJjdu3d7jfEto3PN6W9/+xstW7YkLi6O5ORkDh48CMDevXvd8+/Tp4+7ZA0gJyeHcePG0bRpUyIiImjUqBFDhw7l/PnzpXx0A+u9995j2LBhhHp8w5yamsrBgwfZsWMHAB9++CEAw4YNc49p3Lgx11xzDe+9917FTlhERKoMm8eH2EB92DIhIUR6ZPHqw7EESlGr0Z3PzgYgN+c8333xmXNM1fge3TNDS5mCZRfiLJfLy80lz7USp4JNlVJlaPAvFyjYVAWsWbOGkSNHMmTIENasWUOnTp1IS0vzO3bmzJkcPnyYv/71r377BAFs376dESNGcMUVV7B69WoGDx7M8OHD/Y594403+Oijj1i8eDFz5sxh3bp1Xlk3586d4/rrr2fnzp0sXryYJUuWsGfPHnr37s2JEyeKvF+bNm1i3rx5zJ49mxdffJHt27fzwAMPANCwYUOWLVsGwPz588nIyCAjIwOA6dOns2zZMtLT09mwYQPPP/88NWrUIM+5Uok/lmWRm5t70Z/imDx5MqGhodStW5d7773X636eOXOGAwcO0LZtW6/rtGvXDsAd1Nu1axcJCQnEeKSPu8b5C/yJiIgUh+eHcVsAG61GefRt0odjCRTP1eh8S+R+9lj90HJm61WZnk3KbAooV5A9Py+PXGU2VUppc1/i5ifSiW9+ebCnIiVQNcL/1dwzzzzDwIEDmT9/PgD9+vXj+PHjLFy4sMDYhg0bsmLFiiKP9+yzz9K6dWtWrlyJMYbk5GTOnz/PpEmTCozNzs5m3bp17qBIdHQ0d9xxBzt37qRdu3a8+uqr7N+/n++++44WLVoA0L17d1q0aMGiRYuYOHFiofM4ffo069ato1atWgAcOXKERx991F3+16lTJwDat2/vVba2efNmbrvtNu666y73vsKCZS5Lly7lnnvuKXIMXHgzU5i77rqLwYMHU69ePbZu3Up6ejr/+c9/2Lx5MzabjZ9//hmAmjVrel3PdR9Pnjzp/td3jGuca4yIiEhJ2UJDyXH0B/fKsC2rqLga/Nf5uz4cS6CEhl8IiOY6VxBz6f3be/lg4fOOy845ntSmipTRxdSpy4kfHdn86tlUdq7+Xo5m8go2VUY14xtQM75BsKchJaRgkx8727YL6u2327Wz2GNzc3P58ssv3YEmlyFDhvgNNg0cOPCix9y8eTOpqaleNbHDhg3zG2zq27evV/bN0KFDsSyLLVu20K5dOzZv3kyXLl3cgSaAhIQErr76aj799NMi59GtWzd3EAZw95Y6dOgQLVu2LPR6v/71r1m4cCHx8fEMGDCAjh07XrS+d/DgwWzZsqXIMcXhuVpfr169aNeuHQMHDuTvf/87KSkpZT6+iIhIWXiu6GULD1xmk90rs0nBJgm881lZXtsdkm7gyO7v+M+G9eQ4V1isKg3CazVoxP6v/g0oUzAQ3D2b8vLIO+8qowvc3z8R8U/Bpkru+PHj5OXlUa9ePa/9vtsu8fHxFz3mkSNHqF+/vtc+3+3C9kdFRRETE8Phw4cBOHz4sN/bjI+PZ9++fUXOwzezJ9z5pvjs2bNFXm/SpEmEhISwYMECJkyYQOPGjRk/fjyjRo0q9Dq1a9emRo0ahV5eWgMGDCAmJobt27eTkpLivk++fa1c2Uqu4FqtWrUKjHGN8wzAiYiIlIRneY4tgMt+21VGJ+XsfHZWgX2uIELuubPO7SoSbGrYyP17mDKbyuxCZlOuezW6QP79ExH/FGzyoySZRcFWt25dbDYbx44d89rvu+1SnA7+DRo04OjRo177fLcL25+VlUVmZiYNGzYEHGV7X3/9dYHr/fTTT9SuXfuicymNyMhIpk6dytSpU/n+++954YUXGD16NG3atGHAgAF+rxOoMjpfrsfb9W90dDRNmjQp0HfJte3q5dS2bVsOHDjAmTNniI6O9hrn2+9JRESkuDx7NoUGMLMpKi7O/bsymySQugy8iZ2ffkKbq3oVuMwVRMhxldFVkcymmg0uBJsUvC07m82V2ZTr0bNJH4NFylvV6KJXjYWGhtK5c2feeecdr/1r164t9TG7devG2rVrvQIrq1ev9jt2w4YNZGZmurfXrFmDMYbExETA0Z9p27Zt7Nmzxz3m0KFDfP7551xzzTWlniMUL9OpVatWzJo1i4iICL755ptCx7nK6C72U1Lvv/8+mZmZdO3a1b0vOTmZNWvWeDUsX7FiBU2aNKFDhw6Ao+8WOB5Plx9//JGNGzeSnJxc4nmIiIjAhUwQ39/LyjOzKULBJgmgPnfdz8OL/urVhN7FlZ2S48xs8l2xrrLyzGxSsKnsXEHJc5mZ7PrsE0BldCIVQSHdKmDixIncfPPNPPLIIwwZMoTPPvuMdevWARASUvJ44oQJE+jevTvDhw8nLS2NHTt28PLLL/sda7fbGTRoEOPHj+fw4cOMHz+eoUOHuvsr3X333cyYMYPk5GSmTp2KzWZjypQp1K1blwcffLD0dxpo2rQpdrudpUuXUqNGDcLCwkhMTGTo0KF07dqVzp07Y7fbeeutt8jNzaVXr4LfiLnUqVOHOnXqlGk+L774Ilu3buWGG26gbt26bN++nWnTpnHllVcyaNAg97jx48ezbNky7rjjDu6//362bNnCokWLWLhwoTsDKiEhgbS0NEaPHo1lWdSrV4/Jkydz2WWX8dvf/rZM8xQRkerLq4wugA1ytRqdlCdTyPvZC2V0zp5NVSTYVKP+hRYUKvcqO9dqdN9t+uzCPjUIFyl3CjZVAcOGDWPu3LnMmDGDV155haSkJGbNmsXw4cOJ80hrL67ExESWL1/OxIkTSUlJITExkRUrVnDllVcWGJuamkpsbCxpaWlkZmYWaEweERHBRx99xJgxY0hLS8OyLJKSkli1alWZy+giIyNZvHgxU6ZMoXfv3uTk5GBZFldddRUrVqxg5syZ5Ofn0759e1atWuXOtiovl19+OUuXLmXVqlWcPn2aBg0acOedd5Kenu5+kQNo2bIl77//PmPGjCE5OZkGDRowe/Zs7rvvPq/jzZ07l+joaMaMGUNWVha9e/fmjTfeIDIyslzvh4iIVF2eDcID+c1+lBqESxC4AgbuBuFVJNjkGWCqKvcpmEL8ZHEq2CRS/kxJe9BURomJidbWrVv9XrZz507atQvu6nPlYdq0aTz99NOcOHECezl9w9isWTNuueUWZs2aVS7Hl/JVVZ/7IiJSuGVPjOHI7u8A6NCnL/0fKnzxjJI4fmAfS8f9nhBbKKOXrSlWj0iRstq27m0+ee0lomvW4szPJ2nT81puHD0h2NMKiO83f86hb3fS+/Z7Cs3skuL5fksGa2c97bWvdc9rGVxFnisiwWaM2WZZVoHMDmU2VQHHjh1j+vTp9OnTh6ioKDZu3MiMGTNIS0srt0CTiIiIVD6eDcLDIgKXKRtTqw7GhBBVs6YCTVJhLjQIr1o9mwBaXXkVra68KtjTqBJstoIfeUMD2LNORPzTWVYFhIeHs2vXLl577TVOnTpFw4YNGTVqFOnp6cGemoiIiFxCPMu6I6ICV+4WGRPD4LETscfEBuyYIhfj6tmUc7ZqldFJYPkroxOR8qczrwqoUaMG69evr/Db3bt3b4XfpoiIiJSe54euiKjogB67VbeeAT2eyMW4ehtZVj6gYJP4Z/PzvDhz6ueKn4hINaMCYBEREZFqwuYRbAoPcLBJpKLZfDJWFGwSf0L8rOiXeeK/QZiJSPWiYJOIiIhINRHiVUanYJNUbjafIIIJUbBJCvKX2aRgk0j5U7BJREREpJrwbBAeyJ5NIsHg24tHmU3ij7+eTf0eHBmEmYhUL+rZJCIiIlJNKLNJqhKV0Ulx+D5Phj7+FC06dwvSbESqD2U2iYiIiFQTnmVH4cpskkpOwSYpDt/nRWR0TJBmIlK9KNgkIiIiUk2EhCqzSaoOW5h3zyYFm8Qf395evtsiUj4UbBIRERGpJtSzSaoS36BBiBqEix++QUjfjDgRKR8KNglJSUnccsstRY7JzMzEGMOSJUvKZQ7GGObNm1ei6xw9epTJkyezd+/ecplTSR05coSbbrqJpk2bEhkZScOGDbn11lv5/vvvC4z97LPP6N69O5GRkTRv3py5c+cWGHPu3DnGjh1L/fr1iY6OZtCgQX7va3GOJSIiAoCV7/41NDwiiBMRKTs1CJfi8H2e+GbEiUj5ULBJWLBgAdOnTw/qHDIyMrj11ltLdJ2jR48yZcqUSybYlJWVRa1atUhPT+f999/nueee49tvv+W6667j559/do/bvXs3/fv3p3nz5qxfv54HH3yQMWPG8NJLL3kd7w9/+ANLlixh1qxZvPXWWxw/fpy+ffty9uzZEh9LREQEIPf8effvxpggzkSk7NSzSYrD93miYJNIxVAOYTWWnZ2N3W6nffv2wZ4KPXr0CPYUyqxFixYFMr+6du1K69at+cc//sGwYcMAmDlzJo0aNeL1118nNDSU6667jv379zNlyhTS0tIwxnDw4EFefvllXnnlFe68804AOnXqRPPmzXn99de57777in0sERERlxyPYJNIZadgkxRHgcwm9WwSqRDKbKoi5s2bR5MmTYiOjiYlJYWPP/4YYwyffPKJe4wxhjlz5jB69Gjq1atHx44dAf9ldKtWraJ169bY7XZ69erFrl27Ctxms2bNGDduHOnp6TRo0ICYmBhuv/12Tp065TVuz549pKSkEBcXR2xsLIMHD2b37t1eY3zL6Fxz+tvf/kbLli2Ji4sjOTmZgwcPArB37173/Pv06YMxxh1YycnJYdy4cTRt2pSIiAgaNWrE0KFDOR+EN9h16tQB8Lrt9957j2HDhhHq8cKXmprKwYMH2bFjBwAffvghgDtABdC4cWOuueYa3nvvvRIdS0RExCX33NmLDxKpJHyDCEY9m8QPm03BJpFgULCpClizZg0jR45kyJAhrFmzhk6dOpGWluZ37MyZMzl8+DB//etfC+3ts337dkaMGMEVV1zB6tWrGTx4MMOHD/c79o033uCjjz5i8eLFzJkzh3Xr1rmzbsDRd+j6669n586dLF68mCVLlrBnzx569+7NiRMnirxfmzZtYt68ecyePZsXX3yR7du388ADDwDQsGFDli1bBsD8+fPJyMggIyMDgOnTp7Ns2TLS09PZsGEDzz//PDVq1CAvL6/Q27Isi9zc3Iv+FEd+fj45OTns27ePUaNGcdlllzFo0CAAzpw5w4EDB2jbtq3Xddq1awfgDurt2rWLhIQEYmJiCoxzjSnusURERFxyz58L9hREAqZAg3BlNokfJiQEPLL9bWEq7hGpCDrTqoBnnnmGgQMHMn/+fAD69evH8ePHWbhwYYGxDRs2ZMWKFUUe79lnn6V169asXLkSYwzJycmcP3+eSZMmFRibnZ3NunXr3EGR6Oho7rjjDnbu3Em7du149dVX2b9/P9999x0tWrQAoHv37rRo0YJFixYxceLEQudx+vRp1q1bR61atQBHA+5HH33UXf7XqVMnANq3b+9Vhrd582Zuu+027rrrLve+woJlLkuXLuWee+4pcgw4glIX87vf/Y5FixYBjtK6DRs2EBsbC+Du3VSzZk2v67ju48mTJ93/+o5xjXONKe6xREREXHLOKdgkVYeCTVIcxhhsNht5zi+O1bNJpGIo2OTH/If+EdTb//0L1xV7bG5uLl9++aU70OQyZMgQv8GmgQMHXvSYmzdvJjU11avfz7Bhw/wGm/r27euVfTN06FAsy2LLli20a9eOzZs306VLF3egCSAhIYGrr76aTz/9tMh5dOvWzR04Ady9pQ4dOkTLli0Lvd6vf/1rFi5cSHx8PAMGDKBjx44X7V00ePBgtmzZUuSY4vrjH/9IWloa+/btY9asWfTr148vvviC+Pj4gBxfRESktHIVbJIqRD2bpNg8PguEqNxSpEIo2FTJHT9+nLy8POrVq+e133fbpTgBjyNHjlC/fn2vfb7bhe2PiooiJiaGw4cPA3D48GG/txkfH8++ffuKnIdvxk54eDiA12ps/kyaNImQkBAWLFjAhAkTaNy4MePHj2fUqFGFXqd27drUqFGjyOMWV9OmTWnatCndunWjX79+XHbZZcyfP5+pU6e675NvXytXFpIruFarVq0CY1zjXGOKeywRERGXzgOH8OELc+l0/YBgT0WkzEJCvYMGoc73iiK+rPyLVyeISGAp2ORHSTKLgq1u3brYbDaOHTvmtd9326U4q5M1aNCAo0ePeu3z3S5sf1ZWFpmZmTRs2BBwlO19/fXXBa73008/Ubt27YvOpTQiIyOZOnUqU6dO5fvvv+eFF15g9OjRtGnThgED/L+5DmQZnae4uDguv/xyfvjhB8BRZtikSZMC/ZRc267+S23btuXAgQOcOXOG6Ohor3GuMcU9loiIiEuHpL4ktP0VNeIbBHsqImUWEmLDhIRg5ecDEBkTG+QZyaVLwSaRiqYG4ZVcaGgonTt35p133vHav3bt2lIfs1u3bqxdu9YrsLJ69Wq/Yzds2EBmZqZ7e82aNRhjSExMBBz9mbZt28aePXvcYw4dOsTnn3/ONddcU+o5QvEynVq1asWsWbOIiIjgm2++KXScq4zuYj8ldfz4cb799luaN2/u3pecnMyaNWu8GpavWLGCJk2a0KFDB8DRdwscj6fLjz/+yMaNG0lOTi7RsURERFyMMdRq2FhlJFJlePbfiYyOKWKkVGcl/cJYRMpOmU1VwMSJE7n55pt55JFHGDJkCJ999hnr1q0DICSk5PHECRMm0L17d4YPH05aWho7duzg5Zdf9jvWbrczaNAgxo8fz+HDhxk/fjxDhw5191e6++67mTFjBsnJyUydOhWbzcaUKVOoW7cuDz74YOnvNI5yNbvdztKlS6lRowZhYWEkJiYydOhQunbtSufOnbHb7bz11lvk5ubSq1evQo9Vp04d6tSpU6b5zJ49mz179tCrVy/q16/Pnj17eO6554iIiPC6r+PHj2fZsmXccccd3H///WzZsoVFixaxcOFCd+ZZQkICaWlpjB49GsuyqFevHpMnT+ayyy7jt7/9bYmOJSIiIlJV2UJD3b3IFGySQinWJFLhFGyqAoYNG8bcuXOZMWMGr7zyCklJScyaNYvhw4cTFxdX4uMlJiayfPlyJk6cSEpKComJiaxYsYIrr7yywNjU1FRiY2NJS0sjMzOzQGPyiIgIPvroI8aMGUNaWhqWZZGUlMSqVavKXEYXGRnJ4sWLmTJlCr179yYnJwfLsrjqqqtYsWIFM2fOJD8/n/bt27Nq1Sp3tlV5ueKKK1i/fj0rVqzgl19+ISEhgaSkJJ588kkSEhLc41q2bMn777/PmDFjSE5OpkGDBsyePZv77rvP63hz584lOjqaMWPGkJWVRe/evXnjjTeIjIws8bFEREREqiLPFekiYhRsEv8sKz/YUxCpdkx1SClMTEy0tm7d6veynTt30q5duwqeUfmbNm0aTz/9NCdOnMBut5fLbTRr1oxbbrmFWbNmlcvxpXxV1ee+iIiIVB8vPHQnZ06eAODRN95Riaj4NXvEje7fx654N4gzEal6jDHbLMsqkNmhzKYq4NixY0yfPp0+ffoQFRXFxo0bmTFjBmlpaeUWaBIRERERCTZXCR1oSXsRkUuJgk1VQHh4OLt27eK1117j1KlTNGzYkFGjRpGenh7sqYmIiIiIlJscj2CTiIhcOhRsqgJq1KjB+vXrK/x29+7dW+G3KSIiIiLikp+XC4AxWmRbikEL6IhUGP1VFhERERGRSi0sMiLYU5BKQKs1i1Sccg02GWMGGGO+NcbsNsY8XsS4m40xljEm0WPfROf1vjXG9PfYP8oYs8MY87UxZnR5zl9ERERERC59YRGRFx8k1Z4y4EQqTrmdbcYYGzAfSAbaA78xxrT3My4WGAVs8tjXHkgFfgUMABYYY2zGmA7A/cCVwBXAjcaYluV1H0RERERE5NIXGqHMJrk4JTaJVJzyDO1eCey2LOsHy7LOA8uBm/yMSwdmAGc99t0ELLcs65xlWXuA3c7jtQM2WZaVZVlWLvAvYFg53gcREREREbnEKbNJikXRJpEKU57BpsbAAY/tg859bsaYLkATy7LWFfO6O4BrjTF1jDFRwECgSaAnLiIiIiIilUeYMpukGAwKNolUlKCtRmccBbNzgLuLex3LsnYaY2YAHwJngH8DeYUc/wHgAYCmTZuWcbYiIiIiInKpUmaTFEuIgk0iFaU8M5sO4Z11lODc5xILdAA+McbsBXoAa51Nwgu9rmVZL1uW1dWyrF7ASeA7fzduWdaLlmUlWpaVWK9evQDdpUvT5MmTMcbQqlUrv5e3atUKYwyTJ08ul9t/8cUXefvttwN6zHPnzjFr1iw6d+5MdHQ0UVFRdOvWjdmzZ5OdnR2Q22jWrBnjxo0LyLFEREREpOK1v7YPAF0GDgnyTKQyUGaTSMUpz8ymLUArY0xzHIGiVOA214WWZZ0C6rq2jTGfAOMsy9pqjMkG/maMmQM0AloBm53j6luWddQY0xRHv6Ye5XgfKo3IyEj27NnD1q1bSUx0L+rHli1b2Lt3L5GR5fdtz4svvkiHDh1ISUkJyPGys7Pp168fX331FaNHj+aaa64BICMjgxkzZhAaGsqoUaMCclsiIiIiUnn1/91orh5xB3H16gd7KlIZqGeTSIUpt2CTZVm5xphHgA8AG/CKZVlfG2OmAlsty1pbxHW/NsasBL4BcoHfW5blKpdbZYypA+Q49/9cXvehMomOjqZLly4sX77cK9i0fPlyrrvuOrZt2xbE2ZXMpEmT2L59O5s2baJDhw7u/TfccAO///3v2bVrV5mOn52djd1uL+s0RURERCTIQkJsCjRJsSnWJFJxyrOMDsuy1luW1dqyrMsty3raue9Jf4Emy7KSLMva6rH9tPN6bSzLes9j/7WWZbW3LOsKy7I+Ls/5VzapqamsXLkSy7IAsCyLlStXkpqa6nf8ypUr6dixIxERETRp0oQnnniC3Nxc9+VLlizBGMNXX31F3759iY6Opm3btqxevdo9JikpiW3btrF06VKMMRhjWLJkifvyl156iV/96ldERERw2WWX8T//8z9F3oesrCwWLVrEQw895BVocqlduzZXXXUVAIcPH+bee++lRYsW2O12WrduzaRJkzh//rx7/N69ezHGsGzZMu68805q1qzJ4MGDC739iz0mIiIiIiJSOTnaBotIRdDZVoUMGzaMn376iU8//RSAjRs3cuzYMYYNG1Zg7IcffsiIESPo0qUL77zzDiNHjmTWrFk88sgjBcbedtttDBkyhDVr1tCqVStSU1M5ePAgAAsWLKBt27YMHDiQjIwMMjIyGDRoEAAzZ87k4YcfJiUlhXfffZeHH36YP/3pT8ybN6/Q+7Bt2zbOnDnDgAEDLnp/jx8/Tu3atZkzZw7vv/8+48eP59VXX2XkyJEFxo4bN47Y2FjefPNN/vjHP/o9XkkeExERERERqRz6Pzza8e/vRgd1HiLVSdBWo5PAq1mzJgMGDGD58uVce+21LF++nAEDBlCjRo0CY5988kmSkpJYunQpgDu4M3HiRCZNmkRCQoJ77KOPPsq9994LQNeuXYmPj+fdd9/loYceon379kRHR1OvXj169LjQPuv06dNMmTKFSZMm8dRTTwHQt29fsrKymDZtGg8//DA2m63AvA4dcvSQL84Kgh07dmTWrFnu7auvvpro6Gjuvfde/vKXvxAeHu6+rEePHsyfP7/I45XkMRERERERkcqhQ9INtLumN7bQsGBPRaTaULDJj9kjbgzq7Y9d8W6pr5uamsro0aOZM2cOb731FnPnzi0wJi8vj+3bt/P888977R8xYgQTJkwgIyODW2+91b2/X79+7t/r1KlD/fr13ZlNhcnIyODMmTPceuutXmVo1113Henp6Rw8eJDLLrus0OubYhRUW5bFn//8Z1588UX27NnD2bNn3Zft37+fli1burdd2VaFKeljIiIiIiIilYcCTSIVS2V0VcyQIUPIzMzkiSee4MyZM377Ex0/fpycnBzi4+O99ru2T5w44bW/Zs2aXtvh4eFegR1/jh8/DsCvfvUrwsLC3D99+jiWpz1w4IDf6zVu3BhwBIsu5vnnn2fcuHEMHTqUd955h82bN7uzl3zn53tf/c23JI+JiIiIiIiIiPinzCY/ypJZFGzR0dHceOONPPfcc9x6661ER0cXGFO3bl3CwsI4evSo1/6ffvoJcDThLivXMd59912/gZ42bdr4vV5iYiLR0dF88MEH3HDDDUXexptvvsktt9zC008/7d73zTff+B17sUypinhMRERERERERKoDZTZVQQ8//DCDBw/moYce8nu5zWaja9euvPnmm177V65cSUhICD179izR7fnLdOrZsyd2u50ff/yRxMTEAj+xsbF+j2W323nwwQdZuHCh38DRzz//TEZGBgDZ2dlERER4Xb5s2bISzd0l0I+JiIiIiIiISHWlzKYqKCkpiaSkpCLHTJkyhf79+3PPPfeQmprKV199xZ/+9Cfuv//+EjfCbtu2LR988AEffPABderUoXnz5tSpU4fJkyczatQo9u3bR69evcjPz+e7777jn//8J2vWrCn0eNOmTWPz5s1cffXVPProo1x99dUAbNq0ib/85S88/vjj9OzZk759+zJ37ly6d+/O5ZdfzrJly9i9e3eJ5l5ej4mIiIiIiIhIdaVgUzXVr18/li9fzrRp01i2bBn169dn7NixTJkypcTHmjRpEvv372f48OGcPn2aV199lbvvvpvHHnuMRo0a8dxzzzF79mwiIyNp3bo1I0aMKPJ4drudjz76iL/85S+8/vrrPPvss4Cj/9Njjz3Ggw8+CDhWjzt27BiTJk0CYNiwYcydO9dvn6riCORjIiIiIiIiIlJdGcuygj2HcpeYmGht3brV72U7d+6kXbt2FTwjkeDTc19ERERERETKwhizzbKsRN/96tkkIiIiIiIiIiIBo2CTiIiIiIiIiIgEjIJNIiIiIiIiIiISMAo2iYiIiIiIiIhIwCjYJCIiIiIiIiIiAaNgE1AdVuQT8aTnvIiIiIiIiJSXah9sCgsLIzs7O9jTEKlQ2dnZhIWFBXsaIiIiIiIiUgVV+2BT/fr1OXToEFlZWcr2kCrPsiyysrI4dOgQ9evXD/Z0REREREREpAoKDfYEgi0uLg6AH3/8kZycnCDPRqT8hYWFER8f737ui4iIiIiIiARStQ82gSPgpA/eIiIiIiIiIiJlV+3L6EREREREREREJHAUbBIRERERERERkYBRsElERERERERERAJGwSYREREREREREQkYBZtERERERERERCRgFGwSEREREREREZGAMZZlBXsO5c4YcwzYF+x5BEBd4HiwJyFSSeh8ESkenSsixaNzRaR4dK6IFE9VOVcusyyrnu/OahFsqiqMMVsty0oM9jxEKgOdLyLFo3NFpHh0rogUj84VkeKp6ueKyuhERERERERERCRgFGwSEREREREREZGAUbCpcnkx2BMQqUR0vogUj84VkeLRuSJSPDpXRIqnSp8r6tkkIiIiIiIiIiIBo8wmEREREREREREJGAWbKgljzABjzLfGmN3GmMeDPR+RYDLGNDHG/NMY840x5mtjzCjn/trGmA3GmO+d/9Zy7jfGmLnO8+d/jTFdgnsPRCqWMcZmjPnSGPOuc7u5MWaT85xYYYwJd+6PcG7vdl7eLKgTF6lAxpiaxpi3jDG7jDE7jTE99boiUpAx5lHn+68dxpg3jDGRel0RcTDGvGKMOWqM2eGxr8SvJcaYu5zjvzfG3BWM+1JWCjZVAsYYGzAfSAbaA78xxrQP7qxEgioXGGtZVnugB/B75znxOPCxZVmtgI+d2+A4d1o5fx4AFlb8lEWCahSw02N7BvCcZVktgZNAmnN/GnDSuf855ziR6uLPwPuWZbUFrsBxzuh1RcSDMaYx8Acg0bKsDoANSEWvKyIuS4ABPvtK9FpijKkNPAV0B64EnnIFqCoTBZsqhyuB3ZZl/WBZ1nlgOXBTkOckEjSWZR22LGu78/dfcHwgaIzjvFjqHLYUSHH+fhPwmuXwBVDTGNOwYmctEhzGmARgEPCSc9sA1wFvOYf4niuuc+gt4HrneJEqzRhTA+gFvAxgWdZ5y7J+Rq8rIv6EAnZjTCgQBRxGrysiAFiW9f+AEz67S/pa0h/YYFnWCcuyTgIbKBjAuuQp2FQ5NAYOeGwfdO4Tqfac6didgU1AvGVZh50XHQHinb/rHJLq7HngMSDfuV0H+NmyrFzntuf54D5XnJefco4XqeqaA8eAV50lpy8ZY6LR64qIF8uyDgGzgP04gkyngG3odUWkKCV9LakSrzEKNolIpWWMiQFWAaMtyzrteZnlWGpTy21KtWaMuRE4alnWtmDPReQSFwp0ARZaltUZOMOFMgdArysiAM5SnptwBGgbAdFUwowLkWCpTq8lCjZVDoeAJh7bCc59ItWWMSYMR6BpmWVZq527f3KVMTj/Percr3NIqqurgSHGmL04SrCvw9GXpqaz/AG8zwf3ueK8vAbw34qcsEiQHAQOWpa1ybn9Fo7gk15XRLzdAOyxLOuYZVk5wGocrzV6XREpXElfS6rEa4yCTZXDFqCVc5WHcBxN+NYGeU4iQeOs9X8Z2GlZ1hyPi9YCrtUa7gLe8dh/p3PFhx7AKY9UVpEqy7KsiZZlJViW1QzHa8c/LMu6HfgncItzmO+54jqHbnGOrxbfvkn1ZlnWEeCAMaaNc9f1wDfodUXE136ghzEmyvl+zHWu6HVFpHAlfS35AOhnjKnlzCbs59xXqRid65WDMWYgjr4bNuAVy7KeDu6MRILHGHMNsBH4igt9aP6Io2/TSqApsA8YblnWCeeboXk40ryzgHssy9pa4RMXCSJjTBIwzrKsG40xLXBkOtUGvgR+a1nWOWNMJPBXHH3QTgCplmX9EKQpi1QoY8yvcTTSDwd+AO7B8cWsXldEPBhjpgAjcKwO/CVwH45+MnpdkWrPGPMGkATUBX7Csarc25TwtcQYcy+OzzcAT1uW9WoF3o2AULBJREREREREREQCRmV0IiIiIiIiIiISMAo2iYiIiIiIiIhIwCjYJCIiIiIiIiIiAaNgk4iIiIiIiIiIBIyCTSIiIiIiIiIiEjAKNomIiIiIiIiISMAo2CQiIiIiIiIiIgGjYJOIiIiIiIiIiATM/wdrnx+1djvJBgAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in range(len(Agg_AVals)):\n",
+    "    \n",
+    "    plt.plot(np.ones(example1.T_sim-100)*Agg_AVals[i], label = 'gridpoints = ' + str(mpoints[i]), linewidth = 2.0)\n",
+    "\n",
+    "plt.plot(aLvls[100:], label = 'Monte Carlo', linewidth = 2.0) # Plot time series path of aggregate assets using Monte Carlo simulation methods\n",
+    "plt.ylabel('Aggregate Assets')\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.rcParams[\"figure.figsize\"] = (20,10)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "617c21e3",
+   "metadata": {},
+   "source": [
+    "Note the Harmenberg method not only reduces the time of computation but also improves the accuracy of the simulated path of assets. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cc5e991",
+   "metadata": {},
+   "source": [
+    "### Monte Carlo Simulation with Harmenberg Trick"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "52420de0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{}"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "ss.AgentCount = 25000\n",
+    "ss.T_sim = 700\n",
+    "ss.initialize_sim()\n",
+    "ss.simulate()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a414078e",
+   "metadata": {},
+   "source": [
+    "## Solve an Agent who Anticipates a Change in the Real Interest Rate\n",
+    "\n",
+    "Now that we have the steady state distributions of which simulations will begin from, we will now solve an agent who anticipates a change in the real rate in period t=10. I first solve the agent's problem provide the consumption policies to be used to calculate the transition matrices of this economy. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "2b898628",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# We will solve a finite horizon problem that begins at the steady state computed above. \n",
+    "# Therefore parameters must be specified as lists, each item's index indicating the period of the horizon.\n",
+    "\n",
+    "params = deepcopy(Dict)\n",
+    "params['T_cycle']= 20\n",
+    "params['LivPrb']= params['T_cycle']*[ss.LivPrb[0]]\n",
+    "params['PermGroFac']=params['T_cycle']*[1]\n",
+    "params['PermShkStd'] = params['T_cycle']*[ss.PermShkStd[0]]\n",
+    "params['TranShkStd']= params['T_cycle']*[ss.TranShkStd[0]]\n",
+    "params['Rfree'] = params['T_cycle']*[ss.Rfree]\n",
+    "params['DiscFac'] = params['T_cycle']*[ss.DiscFac]\n",
+    "\n",
+    "FinHorizonAgent = IndShockConsumerType(**params)\n",
+    "FinHorizonAgent.cycles = 1\n",
+    "\n",
+    "FinHorizonAgent.del_from_time_inv('Rfree') #delete Rfree from time invariant list since it varies overtime\n",
+    "FinHorizonAgent.add_to_time_vary('Rfree')\n",
+    "\n",
+    "FinHorizonAgent.del_from_time_inv('DiscFac') #delete Rfree from time invariant list since it varies overtime\n",
+    "FinHorizonAgent.add_to_time_vary('DiscFac')\n",
+    "\n",
+    "FinHorizonAgent.IncShkDstn = params['T_cycle']*[ss.IncShkDstn[0]]\n",
+    "FinHorizonAgent.cFunc_terminal_ = deepcopy(ss.solution[0].cFunc) # Set Terminal Solution as Steady State Consumption Function\n",
+    "FinHorizonAgent.track_vars = ['cNrm','pLvl','aNrm'] \n",
+    "FinHorizonAgent.T_sim = params['T_cycle']\n",
+    "FinHorizonAgent.AgentCount = ss.AgentCount\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bff1e5d",
+   "metadata": {},
+   "source": [
+    "### Implement perturbation in Real Interest Rate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "16caa27d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "dx = -.05 # Change in the Interest Rate\n",
+    "i = 10 # Period in which the change in the interest rate occurs\n",
+    "\n",
+    "FinHorizonAgent.Rfree = (i)*[ss.Rfree] + [ss.Rfree + dx] + (params['T_cycle'] - i -1 )*[ss.Rfree] # Sequence of interest rates the agent faces\n",
+    "\n",
+    "#FinHorizonAgent.DiscFac = (i)*[ss.DiscFac] + [ss.DiscFac + dx] + (params['T_cycle'] - i -1 )*[ss.DiscFac] # Sequence of interest rates the agent faces\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbd4f108",
+   "metadata": {},
+   "source": [
+    "### Solve Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "2c19a5c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "FinHorizonAgent.solve()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bde0ca6d",
+   "metadata": {},
+   "source": [
+    "### Simulate with Monte Carlo with Harmenberg Trick"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "cd713927",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "seconds past : 0.6907346248626709\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "#Simulate with Monte Carlo\n",
+    "\n",
+    "FinHorizonAgent.PerfMITShk = True\n",
+    "\n",
+    "start = time.time()\n",
+    "\n",
+    "# Use Harmenberg Improvement for Monte Carlo\n",
+    "FinHorizonAgent.neutral_measure = True\n",
+    "FinHorizonAgent.update_income_process()\n",
+    "\n",
+    "FinHorizonAgent.initialize_sim()\n",
+    "\n",
+    "#Begin simulation at steady state distribution of permanent income and permanent income\n",
+    "FinHorizonAgent.state_now['aNrm'] = ss.state_now['aNrm']\n",
+    "FinHorizonAgent.state_now['pLvl'] = ss.state_now['pLvl']\n",
+    "FinHorizonAgent.state_now['mNrm'] = ss.state_now['mNrm']\n",
+    "\n",
+    "FinHorizonAgent.simulate()\n",
+    "\n",
+    "print('seconds past : ' + str(time.time()-start))\n",
+    "\n",
+    "#Compute path of aggregate consumption\n",
+    "clvl = []\n",
+    "alvl = []\n",
+    "for i in range(FinHorizonAgent.T_sim):\n",
+    "    \n",
+    "    #C = np.mean(FinHorizonAgent.history['pLvl'][i,:]*(FinHorizonAgent.history['cNrm'][i,:]  )) #Aggregate Consumption for period i\n",
+    "    \n",
+    "    C = np.mean((FinHorizonAgent.history['cNrm'][i,:]  )) #Aggregate Consumption for period i\n",
+    "\n",
+    "    clvl.append(C)\n",
+    "    \n",
+    "    #A = np.mean(FinHorizonAgent.history['pLvl'][i,:]*FinHorizonAgent.history['aNrm'][i,:]) #Aggregate Consumption for period i\n",
+    "    A = np.mean(FinHorizonAgent.history['aNrm'][i,:]) #Aggregate Consumption for period i\n",
+    "\n",
+    "    alvl.append(A)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05277961",
+   "metadata": {},
+   "source": [
+    "### Calculate Transition Matrices with Neutral Measure (Harmenberg 2021)\n",
+    "After the agent solves his problem, the consumption policies are stored in the solution attribute of self. calc_transition_matrix() will automatically call these attributes to compute the transition matrices.\n",
+    "\n",
+    "In the cell below we calculate the transition matrix while utilizing the neutral measure for speed efficiency."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "0b054e97",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "3000\n",
+      "Seconds to calc_transition_matrix 2.7020950317382812\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# Change Income Process to allow permanent income shocks to be drawn from neutral measure\n",
+    "FinHorizonAgent.aXtraCount = ss.aXtraCount\n",
+    "FinHorizonAgent.aXtraMax = ss.aXtraMax\n",
+    "\n",
+    "# Calculate Transition Matrices\n",
+    "FinHorizonAgent.define_distribution_grid() \n",
+    "\n",
+    "start = time.time()\n",
+    "FinHorizonAgent.calc_transition_matrix()\n",
+    "print('Seconds to calc_transition_matrix', time.time() - start)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0afef45d",
+   "metadata": {},
+   "source": [
+    "### Compute Path of Aggregate Consumption"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "b93cddbd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AggC_fast =[] # List of aggregate consumption for each period t \n",
+    "AggA_fast =[] # List of aggregate consumption for each period t \n",
+    "\n",
+    "dstn = vecDstn_fast # Initial distribution set as steady state distribution\n",
+    "\n",
+    "c_ = FinHorizonAgent.cPol_Grid # Consumption Policy Grid this period\n",
+    "a_ = FinHorizonAgent.aPol_Grid # asset policy grid\n",
+    "\n",
+    "c_.append(c)\n",
+    "a_.append(asset)\n",
+    "for i in range(20):\n",
+    "\n",
+    "    T_mat = FinHorizonAgent.tran_matrix[i]\n",
+    "    dstn = np.dot(T_mat,dstn)\n",
+    "\n",
+    "    C = np.dot( c_[i] , dstn )  # Compute Aggregate Consumption this period\n",
+    "    AggC_fast.append(C[0])\n",
+    "    \n",
+    "    A = np.dot( a_[i] , dstn )  # Compute Aggregate Assets this period\n",
+    "    AggA_fast.append(A[0])\n",
+    "\n",
+    "AggC_fast = np.array(AggC_fast)\n",
+    "AggC_fast = AggC_fast.T\n",
+    "\n",
+    "AggA_fast = np.array(AggA_fast)\n",
+    "AggA_fast = AggA_fast.T\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "edd797a5",
+   "metadata": {},
+   "source": [
+    "### Path of Aggregate Consumption given an anticipated interest rate shock at $t=10$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "67c68171",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "#plt.plot(AggC, label = 'without Harmenberg') #Without Neutral Measure\n",
+    "plt.plot(AggC_fast, label = ' Transition Matrices', linewidth = 3.0) #With Harmenberg Improvement\n",
+    "plt.plot(clvl, label = 'Monte Carlo', linewidth = 3.0) # Monte Carlo with Hamenberg Improvement\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.ylim([.95,1.08])\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "157a398f",
+   "metadata": {},
+   "source": [
+    "### Path of Aggregate Assets given an anticipated interest rate shock at $t=10$\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "00d8dc82",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(AggA_fast, label = ' Transition Matrices', linewidth = 3.0) #With Harmenberg Improvement\n",
+    "plt.plot(alvl, label = 'Monte Carlo', linewidth = 3.0)\n",
+    "plt.legend(prop={'size': 15})\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "646398b1",
+   "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.8.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}