diff --git a/.gitignore b/.gitignore index 8c1326262..636fd31af 100644 --- a/.gitignore +++ b/.gitignore @@ -299,6 +299,18 @@ uv.lock .cursorignore .cursorindexingignore +# Local simulation notes and scratch work +sims-about/** + +# AI tool config +.ragignore + +# Debug/scratch notebooks (keep locally, don't ship) +*_debug*.ipynb + +# Test scripts in example directories (real tests go in tests/) +examples/**/test_*.py + # Generated test artifacts test.jpg test.pdf diff --git a/HARK/ConsumptionSaving/ConsIndShockModel.py b/HARK/ConsumptionSaving/ConsIndShockModel.py index 2a4d87697..f8cc0a5a4 100644 --- a/HARK/ConsumptionSaving/ConsIndShockModel.py +++ b/HARK/ConsumptionSaving/ConsIndShockModel.py @@ -1330,6 +1330,56 @@ def initialize_sim(self): self.PermShkAggNow = self.PermGroFacAgg # This never changes during simulation self.state_now["PlvlAgg"] = 1.0 super().initialize_sim() + self._initialize_ergodic_ages() + + def _initialize_ergodic_ages(self): + """ + For infinite-horizon models with finite T_age, re-draw agent ages + from the ergodic (truncated geometric) distribution and scale pLvl + accordingly. + + Without this, all agents start at age 0 and die together every T_age + periods, creating a "cohort echo" that biases aggregates (e.g. ~1.25% + in E[pLvl] for HAFiscal's T_age=200, LivPrb=0.99375). + + In state_now (after sim_one_period), t_age ranges from 1 to T_age + because t_age is incremented at the end of each period. The ergodic + distribution is P(t_age=k) = C * L^(k-1) for k=1,...,T_age, with + C = (1-L)/(1-L^T_age). Agents at t_age=T_age will die immediately + in the first sim_one_period call, matching steady-state turnover. + + Skipped for lifecycle models (cycles != 0) where age-0 start is correct. + Controlled by attribute `init_ages_ergodic` (default True). + """ + if not getattr(self, "init_ages_ergodic", True): + return + if self.cycles != 0 or self.T_age is None: + return + + L = np.asarray(self.LivPrb[0]) + if L.ndim > 0: + L = float(L[0]) + else: + L = float(L) + + T = self.T_age + ages = np.arange(1, T + 1) # 1 to T_age (state_now convention) + if abs(L - 1.0) < 1e-14: + probs = np.ones(T) / T + else: + C = (1.0 - L) / (1.0 - L**T) + probs = C * L ** (ages - 1) + probs /= probs.sum() + + self.t_age = self.RNG.choice(ages, size=self.AgentCount, p=probs) + self.t_cycle = self.t_age % self.T_cycle + + G = np.asarray(self.PermGroFac[0]) + if G.ndim > 0: + G = float(G[0]) + else: + G = float(G) + self.state_now["pLvl"] *= G**self.t_age def sim_birth(self, which_agents): """ diff --git a/HARK/ConsumptionSaving/ConsNewKeynesianModel.py b/HARK/ConsumptionSaving/ConsNewKeynesianModel.py index 0fe7d87a5..f1672d784 100644 --- a/HARK/ConsumptionSaving/ConsNewKeynesianModel.py +++ b/HARK/ConsumptionSaving/ConsNewKeynesianModel.py @@ -131,6 +131,7 @@ class NewKeynesianConsumerType(IndShockConsumerType): default_ = { "params": init_newkeynesian, "solver": solve_one_period_ConsIndShock, + "model": "ConsIndShock.yaml", "track_vars": ["aNrm", "cNrm", "mNrm", "pLvl"], } diff --git a/HARK/core.py b/HARK/core.py index d3fb9a9ea..1c2e00b46 100644 --- a/HARK/core.py +++ b/HARK/core.py @@ -1548,13 +1548,21 @@ def initialize_sim(self): ] else: - warn( - "The option for reading shocks was activated but " - + "the model requires state " - + var_name - + ", not contained in " - + "newborn_init_history." + # Only warn for idiosyncratic states (per-agent arrays). + # Aggregate scalars (e.g. PlvlAgg) are not expected in + # newborn_init_history and are set elsewhere. + is_idio = ( + isinstance(self.state_now[var_name], np.ndarray) + and len(self.state_now[var_name]) == self.AgentCount ) + if is_idio: + warn( + "The option for reading shocks was activated but " + + "the model requires state " + + var_name + + ", not contained in " + + "newborn_init_history." + ) self.clear_history() diff --git a/HARK/distributions/base.py b/HARK/distributions/base.py index f12b8e5fa..f3eccb9d1 100644 --- a/HARK/distributions/base.py +++ b/HARK/distributions/base.py @@ -176,8 +176,9 @@ class MarkovProcess(Distribution): Parameters ---------- transition_matrix : np.array - An array of floats representing a probability mass for - each state transition. + Row-stochastic transition matrix: ``transition_matrix[i, j]`` is the + probability of moving to state *j* given the current state is *i*. + Each row must sum to 1. seed : int Seed for random number generator. diff --git a/HARK/simulator.py b/HARK/simulator.py index 6e49dba14..9a9112c81 100644 --- a/HARK/simulator.py +++ b/HARK/simulator.py @@ -10,7 +10,7 @@ from sympy.utilities.lambdify import lambdify from sympy import symbols, IndexedBase from typing import Callable -from HARK.utilities import NullFunc, make_exponential_grid +from HARK.utilities import NullFunc, make_exponential_grid, make_grid_exp_mult from HARK.distributions import Distribution from scipy.sparse import csr_matrix, csc_matrix from scipy.sparse.linalg import eigs @@ -649,7 +649,18 @@ def _build_input_grids(self, grid_specs, arrival_N): is_arrival = True except: is_arrival = False - if ("min" in spec) and ("max" in spec): + if "grid" in spec: + new_grid = np.asarray(spec["grid"], dtype=float) + is_cont = True + grid_orders[var] = 0.0 + elif "timestonest" in spec: + bot = spec["min"] + top = spec["max"] + N = spec["N"] + new_grid = make_grid_exp_mult(bot, top, N, spec["timestonest"]) + is_cont = True + grid_orders[var] = 0.0 + elif ("min" in spec) and ("max" in spec): Q = spec["order"] if "order" in spec else 1.0 bot = spec["min"] top = spec["max"] @@ -986,11 +997,14 @@ def make_transition_matrices(self, grid_specs, twist=None, norm=None): Parameters ---------- grid_specs : dict - Dictionary of dictionaries of grid specifications. For now, these have - at most a minimum value, a maximum value, a number of nodes, and a poly- - nomial order. They are equispaced if a min and max are specified, and - polynomially spaced with the specified order > 0 if provided. Otherwise, - they are set at 0,..,N if only N is provided. + Dictionary of dictionaries of grid specifications. Each entry can be: + - {"min", "max", "N"}: linearly spaced grid. + - {"min", "max", "N", "order"}: polynomially spaced (x^order). + - {"min", "max", "N", "timestonest"}: multi-exponential grid via + make_grid_exp_mult, matching HARK's legacy double-exponential + grids (e.g. timestonest=2). Requires non-negative bounds. + - {"grid": array}: explicit user-supplied grid array. + - {"N"}: discrete grid 0,..,N-1. twist : dict or None Mapping from end-of-period (continuation) variables to successor's arrival variables. When this is specified, additional output is created @@ -1504,10 +1518,14 @@ def make_transition_matrices( of all variables of interest. If any arrival variables are omitted, they will be given a default trivial grid with one node at 0. This should only be done if that arrival variable is closely tied to the - Harmenberg normalizing variable; see below. A grid specification must - include a number of gridpoints N, and should also include a min and - max if the variable is continuous. If the variable is discrete, the - grid values are assumed to be 0,..,N. + Harmenberg normalizing variable; see below. Each entry can be: + - {"min", "max", "N"}: linearly spaced grid. + - {"min", "max", "N", "order"}: polynomially spaced (x^order). + - {"min", "max", "N", "timestonest"}: multi-exponential grid via + make_grid_exp_mult, matching HARK's legacy double-exponential + grids (e.g. timestonest=2). Requires non-negative bounds. + - {"grid": array}: explicit user-supplied grid array. + - {"N"}: discrete grid 0,..,N-1. norm : str or None Name of the variable for which Harmenberg normalization should be applied, if any. This should be a variable that is directly drawn @@ -3660,15 +3678,20 @@ def aggregate_blobs_onto_polynomial_grid( grid of outcome values, based on their origin in the arrival state space. This version is for non-continuation variables, returning only the probability array mapping from arrival states to the outcome variable. + + When Q > 0, uses the polynomial inverse formula for O(1) index lookup. + When Q <= 0, uses binary search (searchsorted) for arbitrary grids. """ bot = grid[0] top = grid[-1] M = grid.size Mm1 = M - 1 N = pmv.size - scale = 1.0 / (top - bot) - order = 1.0 / Q diffs = grid[1:] - grid[:-1] + use_poly = Q > 0.0 + if use_poly: + scale = 1.0 / (top - bot) + order = 1.0 / Q probs = np.zeros((J, M)) @@ -3677,7 +3700,14 @@ def aggregate_blobs_onto_polynomial_grid( jj = origins[n] p = pmv[n] if (x > bot) and (x < top): - ii = int(np.floor(((x - bot) * scale) ** order * Mm1)) + if use_poly: + ii = int(np.floor(((x - bot) * scale) ** order * Mm1)) + else: + ii = np.searchsorted(grid, x) - 1 + if ii < 0: + ii = 0 + if ii >= Mm1: + ii = Mm1 - 1 temp = (x - grid[ii]) / diffs[ii] probs[jj, ii] += (1.0 - temp) * p probs[jj, ii + 1] += temp * p @@ -3698,15 +3728,20 @@ def aggregate_blobs_onto_polynomial_grid_alt( version is for continuation variables, returning the probability array mapping from arrival states to the outcome variable, the index in the outcome variable grid for each blob, and the alpha weighting between gridpoints. + + When Q > 0, uses the polynomial inverse formula for O(1) index lookup. + When Q <= 0, uses binary search (searchsorted) for arbitrary grids. """ bot = grid[0] top = grid[-1] M = grid.size Mm1 = M - 1 N = pmv.size - scale = 1.0 / (top - bot) - order = 1.0 / Q diffs = grid[1:] - grid[:-1] + use_poly = Q > 0.0 + if use_poly: + scale = 1.0 / (top - bot) + order = 1.0 / Q probs = np.zeros((J, M)) idx = np.empty(N, dtype=np.dtype(np.int32)) @@ -3717,7 +3752,14 @@ def aggregate_blobs_onto_polynomial_grid_alt( jj = origins[n] p = pmv[n] if (x > bot) and (x < top): - ii = int(np.floor(((x - bot) * scale) ** order * Mm1)) + if use_poly: + ii = int(np.floor(((x - bot) * scale) ** order * Mm1)) + else: + ii = np.searchsorted(grid, x) - 1 + if ii < 0: + ii = 0 + if ii >= Mm1: + ii = Mm1 - 1 temp = (x - grid[ii]) / diffs[ii] probs[jj, ii] += (1.0 - temp) * p probs[jj, ii + 1] += temp * p diff --git a/HARK/utilities.py b/HARK/utilities.py index 7d09b668c..08a1789ba 100644 --- a/HARK/utilities.py +++ b/HARK/utilities.py @@ -850,6 +850,84 @@ def gen_tran_matrix_2D( return TranMatrix +@numba.njit(parallel=True) +def gen_tran_matrix_1D_markov( + dist_mGrid, + aPol_Grid, + MrkvArray, + Rfree_arr, + PermGroFac_arr, + LivPrb_arr, + shk_prbs, + perm_shks, + tran_shks, + NewBornDist, +): # pragma: nocover + """ + Computes the block-structured transition matrix for a MarkovConsumerType + using the permanent-income-neutral measure (1D m-grid per Markov state). + + The state space is (m, j) flattened into a vector of length M*J, where + indices [j*M : (j+1)*M] correspond to Markov state j. The matrix is + column-stochastic: column src represents "starting in state src" and + rows represent "arriving in state dst". + + Parameters + ---------- + dist_mGrid : np.array, shape (M,) + Grid over normalized market resources (same for all Markov states). + aPol_Grid : np.array, shape (J, M) + End-of-period asset policy for each Markov state j evaluated on dist_mGrid. + MrkvArray : np.array, shape (J, J) + Row-stochastic Markov transition matrix. MrkvArray[j, jp] = P(jp | j). + Rfree_arr : np.array, shape (J,) + Risk-free interest factor for each Markov state. + PermGroFac_arr : np.array, shape (J,) + Permanent income growth factor for each Markov state. + LivPrb_arr : np.array, shape (J,) + Survival probability for each Markov state. + shk_prbs : np.array + Shock probabilities (neutral-measure weights). + perm_shks : np.array + Permanent shock values (neutral-measure adjusted). + tran_shks : np.array + Transitory shock values. + NewBornDist : np.array, shape (M*J,) + Distribution of newborns across the full (m, j) state space. + + Returns + ------- + TranMatrix : np.array, shape (M*J, M*J) + Column-stochastic transition matrix. + """ + J = MrkvArray.shape[0] + M = len(dist_mGrid) + N = M * J + TranMatrix = np.zeros((N, N)) + + for src in numba.prange(N): + j = src // M + i = src % M + LivPrb_j = LivPrb_arr[j] + + for jp in range(J): + markov_prob = MrkvArray[j, jp] + if markov_prob < 1e-15: + continue + + bNext_i = Rfree_arr[jp] * aPol_Grid[j, i] + mNext_shks = bNext_i / (perm_shks * PermGroFac_arr[jp]) + tran_shks + lottery_1d = jump_to_grid_1D(mNext_shks, shk_prbs, dist_mGrid) + + TranMatrix[jp * M : (jp + 1) * M, src] += ( + markov_prob * LivPrb_j * lottery_1d + ) + + TranMatrix[:, src] += (1.0 - LivPrb_j) * NewBornDist + + return TranMatrix + + # ============================================================================== # ============== Some basic plotting tools ==================================== # ============================================================================== diff --git a/docs/example_notebooks/Include_list.txt b/docs/example_notebooks/Include_list.txt index b64f549c1..89ac04870 100644 --- a/docs/example_notebooks/Include_list.txt +++ b/docs/example_notebooks/Include_list.txt @@ -42,4 +42,7 @@ examples/SequenceSpaceJacobians/KS-HARK-presentation.ipynb examples/SequenceSpaceJacobians/SSJ_explanation.ipynb examples/SequenceSpaceJacobians/SSJ-tutorial.ipynb examples/SequenceSpaceJacobians/SSJ-advanced-examples.ipynb -examples/SequenceSpaceJacobians/HANKFiscal_example.ipynb \ No newline at end of file +examples/SequenceSpaceJacobians/HANKFiscal_example.ipynb +examples/MonteCarlovsTransitionMatrix/PE_MarkovConsumerType.ipynb +examples/MonteCarlovsTransitionMatrix/GE_KrusellSmith.ipynb +examples/MonteCarlovsTransitionMatrix/Validation_and_SSJ.ipynb \ No newline at end of file diff --git a/docs/guides/index.rst b/docs/guides/index.rst index 0a843c83b..f5cb51735 100644 --- a/docs/guides/index.rst +++ b/docs/guides/index.rst @@ -8,6 +8,7 @@ Guides quick_start installation simulation + transition_matrix_methods krusell_smith migration_case_study diff --git a/docs/guides/transition_matrix_methods.md b/docs/guides/transition_matrix_methods.md new file mode 100644 index 000000000..f7c7981ab --- /dev/null +++ b/docs/guides/transition_matrix_methods.md @@ -0,0 +1,639 @@ +# Transition Matrix Methods: Converting Monte Carlo Simulations + +This guide explains how to adapt HARK code that uses Monte Carlo (MC) +simulation to use transition matrix (TM) methods instead, and when each +approach is appropriate. It covers single-state models +(`IndShockConsumerType` / `NewKeynesianConsumerType`), discrete Markov +models (`MarkovConsumerType`), and general-equilibrium aggregate-shock +models (`CobbDouglasMarkovEconomy` / Krusell-Smith). + +## When to Use Which Method + +| Criterion | Monte Carlo | Transition Matrix | +|-----------|-------------|-------------------| +| **Bias** | 0 (unbiased) | \(O(\Delta g)\) (grid discretization) | +| **Variance** | \(O(1/N)\) (sampling noise) | 0 (deterministic) | +| **Speed** | Slow for large N | Fast (matrix ops); ~100× for KS forward propagation | +| **Memory** | \(O(N)\) per variable | \(O(M^2)\) for TM of M grid points | +| **Best for** | Individual paths, percentiles, Gini, MSM estimation | Steady-state aggregates, SSJ Jacobians, impulse responses | +| **Not suited for** | Very precise aggregate moments (need huge N) | Path-level statistics requiring individual histories | + +**Rule of thumb:** If you need aggregate steady-state moments, ergodic +distributions, or linearized impulse responses (Jacobians), TM is faster +and more precise. If you need agent-level panel data, distributional +statistics beyond means, or path-level randomness, MC is the right tool. + +## Core Idea + +Both methods solve the same model — the difference is how they +propagate the *distribution* of agents forward in time. + +- **MC:** Track N agents through stochastic shocks. The distribution is an + empirical measure: \(\hat{\mu}_t^N = \frac{1}{N}\sum_{i=1}^N \delta_{x_t^{(i)}}\). +- **TM:** Discretize the state space onto a grid of M points. The + distribution is a probability vector \(\mathbf{p}_t \in \mathbb{R}^M\) + that evolves deterministically: \(\mathbf{p}_{t+1} = \boldsymbol{\Pi}\, \mathbf{p}_t\). + +The transition matrix \(\boldsymbol{\Pi}\) is built from the same policy +functions and shock distributions that MC uses for individual agents. +Each column of \(\boldsymbol{\Pi}\) describes, for an agent currently at +grid point \(i\), the probability of landing at each grid point \(j\) +next period — integrating over all possible shocks. + + +## The Lottery Method (How Grid Projection Works) + +When an agent at grid point \(g_i\) receives shocks and transitions to +next-period state \(x'\), the value \(x'\) will generally fall *between* +grid points. TM assigns probability to the two nearest grid points in a +mean-preserving way: + +If \(g_j \leq x' \leq g_{j+1}\): + +``` +ω = (x' - g_j) / (g_{j+1} - g_j) +Prob(land at g_{j+1}) = ω +Prob(land at g_j) = 1 - ω +``` + +This preserves the conditional mean (\(\mathbb{E}[g] = x'\)) while +introducing a small conditional variance reduction — the source of TM's +discretization bias. The bias shrinks as the grid becomes finer. + +In HARK, the lottery projection is implemented by: +- `jump_to_grid_1D(m_vals, probs, dist_mGrid)` — for 1D state spaces +- `jump_to_grid_2D(m_vals, perm_vals, probs, dist_mGrid, dist_pGrid)` — for 2D (m, p) + +Both are Numba-compiled and live in `HARK.utilities`. + + +## Conversion Workflow: Single-State Models + +This is the simplest case. Classes: `IndShockConsumerType` (via +`NewKeynesianConsumerType`). + +### Step 1: Solve the model (same as MC) + +```python +from HARK.ConsumptionSaving.ConsNewKeynesianModel import NewKeynesianConsumerType + +agent = NewKeynesianConsumerType() +agent.cycles = 0 +agent.solve() +``` + +### Step 2: Enable the neutral measure (Harmenberg trick) + +When `PermGroFac ≠ 1`, the full state space is 2D: (normalized market +resources *m*, permanent income level *p*). A 2D TM is expensive and +suffers from p-grid truncation errors (~30% on level aggregates). + +Harmenberg (2021) defines a *neutral measure* that reweights permanent +shock probabilities as \(q^*(\psi_k) = \psi_k \cdot q(\psi_k)\). Under +this measure, the chain on normalized *m* alone is Markov, collapsing +the grid back to 1D. Level aggregates recover via: + +\[ +\bar{C}_{\text{level}} = \mathbb{E}^*[c(m)] \times \overline{p} +\] + +where \(\overline{p}\) is computed analytically. + +```python +agent.neutral_measure = True +agent.construct("IncShkDstn", "TranShkDstn", "PermShkDstn") +``` + +**Critical:** The neutral measure must only be used for the TM +construction step, *never* for the Bellman equation / solver. Solve with +the true shock distribution first; then switch to the neutral measure +for distribution propagation. + +**Subtlety:** Under the neutral measure, \(\mathbb{E}^*[c(m)] \neq +\mathbb{E}[c(m)]\). The neutral-measure expectation computes the +level-weighted aggregate \(\mathbb{E}[c(m) \cdot p] / \mathbb{E}[p]\), +not the plain cross-sectional mean. The difference arises because +\(\text{cov}(c(m), p) < 0\). + +### Step 3: Define the distribution grid + +```python +agent.define_distribution_grid() +``` + +This builds a multi-exponentially-spaced grid over *m* (and *p* if not +using the neutral measure). Key parameters: + +| Parameter | Default source | Effect | +|-----------|---------------|--------| +| `mMin` | `agent.mMin` | Lower bound of m-grid | +| `mMax` | `agent.mMax` | Upper bound of m-grid | +| `mCount` | `agent.mCount` | Number of grid points | +| `mFac` | `agent.mFac` | Exponential nesting depth (0=exponential, -1=linear) | +| `m_density` | 0 | Midpoint-insertion passes for grid refinement | + +Or pass a custom grid directly: + +```python +import numpy as np +my_grid = np.linspace(0.001, 50.0, 500) +agent.define_distribution_grid(dist_mGrid=my_grid) +``` + +### Step 4: Build the transition matrix + +```python +agent.calc_transition_matrix() +``` + +This constructs `agent.tran_matrix` (an M×M or M\*P × M\*P matrix), +plus `agent.cPol_Grid` and `agent.aPol_Grid` (policy functions evaluated +on the grid). + +Under the hood, this calls `gen_tran_matrix_1D` (neutral measure / 1D) +or `gen_tran_matrix_2D` (full 2D), both Numba-parallelized. + +### Step 5: Find the ergodic distribution + +```python +agent.calc_ergodic_dist() +``` + +Finds the eigenvector of the TM with eigenvalue 1 using +`scipy.sparse.linalg.eigs`. Stored as `agent.vec_erg_dstn` (flat +vector) and `agent.erg_dstn` (reshaped array). + +### Step 6: Compute aggregates + +```python +C_ss = np.dot(agent.cPol_Grid, agent.vec_erg_dstn.flatten()) +A_ss = np.dot(agent.aPol_Grid, agent.vec_erg_dstn.flatten()) +``` + +Or use the all-in-one pipeline: + +```python +agent.compute_pe_steady_state() +print(agent.A_ss, agent.C_ss) +``` + +### Complete example: MC vs TM comparison + +```python +import numpy as np +from HARK.ConsumptionSaving.ConsNewKeynesianModel import NewKeynesianConsumerType + +agent = NewKeynesianConsumerType() +agent.cycles = 0 +agent.solve() + +# --- MC path --- +agent.T_sim = 1200 +agent.AgentCount = 50000 +agent.track_vars = ["aNrm", "cNrm", "pLvl"] +agent.initialize_sim() +agent.simulate() + +A_mc = np.mean(agent.history["aNrm"][400:] * agent.history["pLvl"][400:]) + +# --- TM path --- +agent.neutral_measure = True +agent.construct("IncShkDstn", "TranShkDstn", "PermShkDstn") +agent.define_distribution_grid() +agent.calc_transition_matrix() +agent.calc_ergodic_dist() + +A_tm = np.dot(agent.aPol_Grid, agent.vec_erg_dstn.flatten()) + +print(f"MC aggregate assets: {A_mc:.6f}") +print(f"TM aggregate assets: {A_tm:.6f}") +``` + + +## Conversion Workflow: Markov Models + +Classes: `MarkovConsumerType`. The state space is now (m, j) where j +indexes J discrete Markov states (e.g., employed/unemployed). + +### Key difference: block-structured TM + +The TM is (M\*J) × (M\*J), organized in J² blocks. Block (j→j') +encodes the probability that an agent in Markov state j at grid point +\(g_i\) ends up in Markov state j' at grid point \(g_k\), weighted by +the Markov transition probability `MrkvArray[j, j']`. + +Index mapping: state (m-index=i, Markov-index=j) maps to flat index +`j * M + i`. + +### The constructor override gotcha + +HARK's constructor system automatically rebuilds `MrkvArray` from +`Mrkv_p11` and `Mrkv_p22` via `make_simple_binary_markov()`, silently +overriding any `MrkvArray` you pass directly. Two workarounds: + +1. Pass the constructor's input parameters instead: + ```python + params["Mrkv_p11"] = 0.95 + params["Mrkv_p22"] = 0.95 + ``` + +2. Disable the constructor and pass `MrkvArray` directly: + ```python + params["constructors"]["MrkvArray"] = None + params["MrkvArray"] = [my_custom_matrix] + ``` + +**Diagnostic:** If MC simulation shows Markov state fractions that don't +match your intended matrix (e.g., 85.7% in state 0 instead of 50%), +the constructor has overridden your matrix. + +### Markov TM workflow + +```python +from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType + +agent = MarkovConsumerType() +agent.cycles = 0 +agent.solve() + +# Enable neutral measure +agent.neutral_measure = True +agent.construct("IncShkDstn", "TranShkDstn", "PermShkDstn") + +# Build grid and TM +agent.define_distribution_grid() +agent.calc_transition_matrix() +agent.calc_ergodic_dist() + +# Aggregates by Markov state +M = len(agent.dist_mGrid) +J = agent.MrkvArray[0].shape[0] +dstn = agent.vec_erg_dstn.flatten() + +for j in range(J): + dstn_j = dstn[j * M : (j + 1) * M] + C_j = np.dot(agent.cPol_Grid[j], dstn_j) + print(f"State {j}: C = {C_j:.6f}, mass = {dstn_j.sum():.4f}") +``` + +Or all at once: + +```python +A_ss, C_ss = agent.compute_pe_steady_state() +``` + +### Income parameters for Markov models + +Several income-related parameters must be arrays (one value per Markov +state) rather than scalars: + +- `Rfree`: list of J interest factors +- `PermGroFac`: list of J permanent income growth factors +- `LivPrb`: list of J survival probabilities +- `PermShkStd`, `TranShkStd`: arrays of shape (T_cycle, J) + +When building temporary finite-horizon agents (e.g., for Jacobians), +replicate these with `np.tile`. + + +## Conversion Workflow: General Equilibrium (Krusell-Smith) + +In Krusell-Smith and similar GE models, prices and aggregate variables +are *endogenous* — they depend on the distribution, which depends on +prices. The consumption function is 2D: `cFunc[j](m, M)` where M is +aggregate market resources. + +### TM-in-KS: Forward propagation with `make_history_tm()` + +The `CobbDouglasMarkovEconomy` class has a `make_history_tm()` method +that replaces MC forward propagation in the KS loop: + +```python +from HARK.ConsumptionSaving.ConsAggShockModel import ( + KrusellSmithType, KrusellSmithEconomy +) + +agent = KrusellSmithType() +agent.cycles = 0 +agent.AgentCount = 5000 + +economy = KrusellSmithEconomy(agents=[agent]) +economy.max_loops = 10 +economy.verbose = True + +# Standard MC-based KS solve +economy.solve() + +# After solving, generate TM-based aggregate history for comparison +M_tm, A_tm = economy.make_history_tm(num_pointsM=200, mMax=50.0) +``` + +Each period, `make_history_tm()`: +1. Evaluates the 2D policy `cFunc[j](m_grid, M_current)` at the current + aggregate state +2. Builds a 1D TM for that period +3. Propagates the distribution vector forward by one step +4. Computes aggregate M and A from the new distribution + +This is ~100× faster than MC for forward propagation (e.g., 2.5s vs +243s over 11,000 periods with 5,000 MC agents). + +### Fixing M to build a steady-state TM + +For diagnostic purposes, you can build a TM at a fixed aggregate state: + +```python +M_fixed = 10.5 # fixed aggregate market resources +for j in range(J): + c_j = cFunc[j](dist_mGrid, M_fixed * np.ones_like(dist_mGrid)) + a_j = dist_mGrid - c_j +``` + +A steady-state TM (fixed M) gives ~0.89 correlation with the MC +trajectory. The full `make_history_tm()` achieves ~0.997 correlation by +updating M each period. + + +## Sequence-Space Jacobians (SSJ) + +TM methods are a prerequisite for computing SSJ Jacobians (Auclert et al. +2021), which linearize heterogeneous-agent models around steady state. + +### For single-state models + +```python +agent = NewKeynesianConsumerType() +agent.compute_pe_steady_state() + +T = 300 +CJAC_Rfree, AJAC_Rfree = agent.calc_jacobian("Rfree", T) +``` + +### For Markov models + +```python +agent = MarkovConsumerType() +agent.compute_pe_steady_state() + +T = 300 +CJAC, AJAC = agent.calc_jacobian("Rfree", T) +``` + +The Jacobian computation: +1. Creates a temporary T-period finite-horizon agent +2. Perturbs the parameter at period T-1 by dx=0.0001 +3. Solves the perturbed agent +4. Builds per-period TMs and policies +5. Applies the Fake News decomposition: + \(J = F_0 + \sum_{s \geq 1} F_s \, \mathcal{D} \, \mathcal{P}^{s-1}\) + + +## Diagnostic Checklist + +Use these checks to validate TM results before trusting them. + +### 1. Column sums + +The TM should be column-stochastic (HARK convention for the TM itself, +distinct from the row-stochastic MrkvArray). Every column should sum to 1: + +```python +col_sums = agent.tran_matrix.sum(axis=0) +print(f"Column sums: min={col_sums.min():.10f}, max={col_sums.max():.10f}") +assert np.allclose(col_sums, 1.0, atol=1e-10) +``` + +**Diagnostic patterns:** +- Sums ≈ 0.5 and 1.5 → Markov indexing is transposed (row vs column + stochastic confusion) +- Sums < 1 everywhere → Missing death/rebirth contribution +- Sums slightly off → Numerical edge effects at grid boundaries + +### 2. Ergodic Markov fractions + +The marginal distribution over Markov states should match the analytical +stationary distribution: + +```python +M = len(agent.dist_mGrid) +J = agent.MrkvArray[0].shape[0] +dstn = agent.vec_erg_dstn.flatten() + +for j in range(J): + print(f"State {j} mass: {dstn[j*M:(j+1)*M].sum():.6f}") + +# Compare with analytical stationary distribution +pi = MarkovConsumerType._calc_markov_stationary(agent.MrkvArray[0]) +print(f"Analytical: {pi}") +``` + +### 3. MC vs TM aggregate comparison + +Run both methods and compare steady-state aggregates: + +```python +# TM aggregates +agent.compute_pe_steady_state() +A_tm, C_tm = agent.A_ss, agent.C_ss + +# MC aggregates (after long burn-in) +agent.neutral_measure = False +agent.construct("IncShkDstn", "TranShkDstn", "PermShkDstn") +agent.T_sim = 1200 +agent.AgentCount = 50000 +agent.initialize_sim() +agent.simulate() + +A_mc = np.mean(agent.history["aNrm"][400:] * agent.history["pLvl"][400:]) +print(f"TM: A={A_tm:.6f}, MC: A={A_mc:.6f}") +``` + +### 4. Boundary mass + +Check that negligible probability mass sits at the grid boundaries: + +```python +dstn = agent.vec_erg_dstn.flatten() +M = len(agent.dist_mGrid) +for j in range(J): + block = dstn[j*M:(j+1)*M] + print(f"State {j}: left edge = {block[0]:.2e}, right edge = {block[-1]:.2e}") +``` + +If significant mass is at the boundaries, extend the grid (`mMax`) or +increase resolution (`mCount`). + + +## Common Pitfalls + +### 1. PermShk includes PermGroFac + +In HARK's `get_shocks()`, the permanent shock stored in +`self.shocks["PermShk"]` is the *composite* of the raw idiosyncratic +shock and `PermGroFac`: + +```python +PermShkNow = IncShkDstn.atoms[0] * PermGroFacNow # composite +``` + +When building a TM by hand, you must replicate this: + +```python +mNext = Rfree[jp] * a / (raw_perm_shk * PermGroFac[jp]) + tran_shk +``` + +The `jp` index is the *target* (destination) Markov state, not the source +state — matching HARK's simulation timing where next-period prices +depend on where you end up. + +### 2. Row-stochastic MrkvArray vs column-stochastic TM + +HARK's `MrkvArray` is **row-stochastic**: `MrkvArray[i, j]` = P(go to +state j | in state i). Rows sum to 1. + +HARK's TM from `gen_tran_matrix_*` is **column-stochastic**: column `i` +gives the distribution of next-period states for an agent currently at +state `i`. Columns sum to 1. + +Mixing these conventions leads to incorrect TMs. When in doubt, check the +`MarkovProcess.draw()` method which reads `transition_matrix[s, :]` +(confirming row-stochastic for MrkvArray). + +### 3. Off-by-one in forward iteration + +When propagating distributions forward (e.g., for impulse responses), +compute aggregates *before* transitioning: + +```python +# CORRECT +for t in range(T): + C[t] = np.dot(c_policy[t], dstn) # aggregate FIRST + A[t] = np.dot(a_policy[t], dstn) + dstn = TM[t] @ dstn # THEN transition + +# WRONG (shifted by one period) +for t in range(T): + dstn = TM[t] @ dstn # transition FIRST + C[t] = np.dot(c_policy[t], dstn) # aggregate is one period late +``` + +### 4. Newborn transitory shock suppression + +HARK forces `TranShk = 1.0` for agents with `t_age = 0` when +`NewbornTransShk = False` (the default). This biases the first-period MC +distribution. Workaround after initialization: + +```python +agent.initialize_sim() +agent.t_age = np.ones(agent.AgentCount, dtype=int) +``` + +For TM construction, newborns are projected onto the grid via +`jump_to_grid_1D` starting at `m = 1.0` (normalized), which implicitly +handles this correctly. + +### 5. Grid convergence + +TM results depend on grid resolution. Always run a grid sweep: + +```python +for n_pts in [100, 200, 500, 1000, 2000]: + agent.define_distribution_grid(num_pointsM=n_pts) + agent.calc_transition_matrix() + agent.calc_ergodic_dist() + A = np.dot(agent.aPol_Grid, agent.vec_erg_dstn.flatten()) + print(f"M={n_pts}: A_ss = {A:.8f}") +``` + +Typically 200–500 grid points suffice for 4–6 digit accuracy. + + +## API Reference Summary + +### `NewKeynesianConsumerType` (single-state) + +| Method | Purpose | +|--------|---------| +| `define_distribution_grid(dist_mGrid, dist_pGrid, m_density, num_pointsM, num_pointsP, max_p_fac)` | Build m-grid (and p-grid if not neutral measure) | +| `calc_transition_matrix(shk_dstn)` | Build M×M (or M\*P × M\*P) TM | +| `calc_ergodic_dist(transition_matrix)` | Find stationary distribution via eigendecomposition | +| `compute_pe_steady_state()` | All-in-one: solve → neutral measure → grid → TM → ergodic → A_ss, C_ss | +| `calc_jacobian(shk_param, T)` | T×T SSJ Jacobians via Fake News Algorithm | + +### `MarkovConsumerType` (discrete Markov states) + +| Method | Purpose | +|--------|---------| +| `define_distribution_grid(dist_mGrid, num_pointsM, timestonest, m_density)` | Build 1D m-grid; state space is (m, j) with M\*J points | +| `calc_transition_matrix(shk_dstn)` | Build (M\*J) × (M\*J) block TM | +| `calc_ergodic_dist(transition_matrix)` | Ergodic distribution over full (m, j) space | +| `compute_pe_steady_state()` | Full pipeline for Markov models | +| `calc_jacobian(shk_param, T)` | SSJ Jacobians for Markov models | + +### `CobbDouglasMarkovEconomy` (KS general equilibrium) + +| Method | Purpose | +|--------|---------| +| `make_history_tm(num_pointsM, mMax)` | TM-based forward propagation in KS loop | + +### Low-level utilities (`HARK.utilities`) + +| Function | Purpose | +|----------|---------| +| `jump_to_grid_1D(m_vals, probs, dist_mGrid)` | Mean-preserving lottery onto 1D grid | +| `jump_to_grid_2D(m_vals, perm_vals, probs, dist_mGrid, dist_pGrid)` | Mean-preserving lottery onto 2D grid | +| `gen_tran_matrix_1D(dist_mGrid, bNext, shk_prbs, perm_shks, tran_shks, LivPrb, NewBornDist)` | 1D TM (single-state or neutral measure) | +| `gen_tran_matrix_2D(...)` | 2D TM for (m, p) state space | +| `gen_tran_matrix_1D_markov(dist_mGrid, aPol_Grid, MrkvArray, Rfree_arr, PermGroFac_arr, LivPrb_arr, shk_prbs, perm_shks, tran_shks, NewBornDist)` | Block TM for Markov models | +| `make_grid_exp_mult(ming, maxg, ng, timestonest)` | Multi-exponentially spaced grid | + + +## Learning Path + +The `examples/MonteCarlovsTransitionMatrix/` directory contains three +notebooks that build intuition step by step: + +| Notebook | What it teaches | +|----------|-----------------| +| `PE_MarkovConsumerType.ipynb` | Part 1: 4-state unemployment (1D grid). Part 2: PermGroFac ≠ 1 on 2D grid. Part 3: Harmenberg neutral measure collapses back to 1D. | +| `GE_KrusellSmith.ipynb` | Part 1: TM with endogenous aggregate state (KS). Part 2: `make_history_tm()` forward propagation in KS loop. | +| `Validation_and_SSJ.ipynb` | Part 1: Validates production `MarkovConsumerType` TM methods. Part 2: Sequence-space Jacobians via Fake News Algorithm. | + +Also see `examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb` +for MC vs TM head-to-head comparisons with MSE decomposition and +Harmenberg demonstrations. + + +## Minor prerequisite changes + +### `NewKeynesianConsumerType`: model YAML pointer + +`NewKeynesianConsumerType` was the only `IndShockConsumerType` subclass +missing a `"model"` key in its `default_` dict. This PR adds +`"model": "ConsIndShock.yaml"` (one line) so that `initialize_sym()` can +build an `AgentSimulator` — the same YAML-driven simulation backend that +every other HARK consumer type already supports. Without this, +`Transition_Matrix_Example.ipynb` (which uses `NewKeynesianConsumerType` +for its MC-vs-TM comparisons) would fail when calling the new +AgentSimulator API. + +The notebook uses `NewKeynesianConsumerType` rather than plain +`IndShockConsumerType` for consistency with the existing SSJ example +notebooks in the same directory, which frame the agent problem in +HANK/New Keynesian terms. The two classes share identical dynamics; +`NewKeynesianConsumerType` simply passes additional aggregate labor +income variables into the income process. + +## References + +- Harmenberg, K. (2021). "Aggregation with a permanent income neutral + measure." *Journal of Economic Dynamics and Control*. +- Auclert, A., Bardóczy, B., Rognlie, M., & Straub, L. (2021). "Using + the Sequence-Space Jacobian to Solve and Estimate Heterogeneous-Agent + Models." *Econometrica*. +- Young, E. R. (2010). "Solving the Incomplete Markets Model with + Aggregate Uncertainty using the Krusell-Smith Algorithm and Non-Stochastic + Simulations." *Journal of Economic Dynamics and Control*. +- Den Haan, W. J. (2010). "Comparison of Solutions to the Incomplete + Markets Model with Aggregate Uncertainty." *Journal of Economic Dynamics + and Control*. diff --git a/docs/reference/ConsumptionSaving/ConsAggIndMarkovModel.rst b/docs/reference/ConsumptionSaving/ConsAggIndMarkovModel.rst new file mode 100644 index 000000000..e0e2e4704 --- /dev/null +++ b/docs/reference/ConsumptionSaving/ConsAggIndMarkovModel.rst @@ -0,0 +1,7 @@ +ConsAggIndMarkovModel +--------------------- + +.. automodule:: HARK.ConsumptionSaving.ConsAggIndMarkovModel + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/reference/index.rst b/docs/reference/index.rst index 14635860f..da277f5e9 100644 --- a/docs/reference/index.rst +++ b/docs/reference/index.rst @@ -24,6 +24,7 @@ API Reference :caption: Models :maxdepth: 1 + ConsumptionSaving/ConsAggIndMarkovModel ConsumptionSaving/ConsAggShockModel ConsumptionSaving/ConsBequestModel ConsumptionSaving/ConsGenIncProcessModel diff --git a/examples/ConsAggShockModel/KrusellSmithType.ipynb b/examples/ConsAggShockModel/KrusellSmithType.ipynb index fa1e60082..a0f5758a7 100644 --- a/examples/ConsAggShockModel/KrusellSmithType.ipynb +++ b/examples/ConsAggShockModel/KrusellSmithType.ipynb @@ -134,7 +134,7 @@ "source": [ "## Default Parameters for Krusell-Smith Model\n", "\n", - "All of the default parameters for `KrusellSmithType` and `KrusellSmithEconomy` are taken directly from the original 1998 paper. The default parameters for the `AgentType` subclass are:\n", + "All of the default parameters for `KrusellSmithType` and `KrusellSmithEconomy` are taken directly from the original 1998 paper. The default parameters for `KrusellSmithType` agents are:\n", "\n", "| Parameter | Description | Code | Value |\n", "| :---: | --- | --- | --- |\n", diff --git a/examples/MonteCarlovsTransitionMatrix/GE_KrusellSmith.ipynb b/examples/MonteCarlovsTransitionMatrix/GE_KrusellSmith.ipynb new file mode 100644 index 000000000..9f2cba49b --- /dev/null +++ b/examples/MonteCarlovsTransitionMatrix/GE_KrusellSmith.ipynb @@ -0,0 +1,1224 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ffee754", + "metadata": {}, + "source": [ + "# General-Equilibrium MC vs TM: Krusell-Smith Economy\n", + "\n", + "This notebook extends the transition-matrix (TM) method to **general equilibrium**\n", + "using HARK's `CobbDouglasMarkovEconomy` (Krusell-Smith 1998).\n", + "\n", + "| Part | What it does |\n", + "|------|--------------|\n", + "| 1 | Solve KS economy, build per-state TMs, compare ergodic distributions and forward propagation |\n", + "| 2 | Use `make_history_tm()` inside the KS loop, compare MC vs TM aggregate trajectories, fit AFunc |\n", + "\n", + "**Aggregate economy** MC uses `econ.history[...]`. Per-agent YAML MC uses\n", + "`initialize_sym()` / `symulate()` / `hystory` (see `PE_MarkovConsumerType.ipynb`).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "26e423bd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:16.447523Z", + "iopub.status.busy": "2026-03-21T04:25:16.447389Z", + "iopub.status.idle": "2026-03-21T04:25:18.931857Z", + "shell.execute_reply": "2026-03-21T04:25:18.931439Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy.sparse.linalg as sp_linalg\n", + "from scipy import stats as sp_stats\n", + "\n", + "from HARK.ConsumptionSaving.ConsAggShockModel import (\n", + " AggShockMarkovConsumerType,\n", + " CobbDouglasMarkovEconomy,\n", + ")\n", + "from HARK.utilities import make_grid_exp_mult, jump_to_grid_1D\n", + "\n", + "COLOR_MC = \"tab:blue\"\n", + "COLOR_TM = \"tab:orange\"\n", + "BURNIN = 400\n", + "N_MC_BINS = 200" + ] + }, + { + "cell_type": "markdown", + "id": "32315d76", + "metadata": {}, + "source": [ + "---\n", + "# Part 1: TM with Aggregate Shocks\n" + ] + }, + { + "cell_type": "markdown", + "id": "6c4ca85d", + "metadata": {}, + "source": [ + "## 1. Solve the Krusell-Smith Economy\n", + "\n", + "We use HARK's built-in MC-based KS algorithm to solve a 2-state\n", + "Markov Cobb-Douglas economy.\n", + "\n", + "| State | PermGroFacAgg | Interpretation |\n", + "|-------|--------------|----------------|\n", + "| 0 | 0.98 | Recession |\n", + "| 1 | 1.02 | Expansion |\n", + "\n", + "\n", + "**Calibration.** Parameters use the HARK defaults for\n", + "`AggShockMarkovConsumerType` and `CobbDouglasMarkovEconomy`,\n", + "which follow Krusell and Smith (1998).\n", + "\n", + "**Note:** This takes ~4 minutes due to the KS outer loop." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6a74a3e8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:18.934350Z", + "iopub.status.busy": "2026-03-21T04:25:18.934197Z", + "iopub.status.idle": "2026-03-21T04:29:36.092762Z", + "shell.execute_reply": "2026-03-21T04:29:36.090192Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "intercept=[-0.48291641819876663, -0.6286768645335811], slope=[1.1228671690799255, 1.1975925224299755], r-sq=[0.9983566435141917, 0.9939995301868301]\n", + "intercept=[-0.3113689811002233, -0.3166362223917456], slope=[1.0475161827021602, 1.0423783867707261], r-sq=[0.9998795814756982, 0.9997235487802067]\n", + "intercept=[-0.3177282101913945, -0.36074676255000754], slope=[1.0600328671370267, 1.0716972339492288], r-sq=[0.9999472964649746, 0.9999330431328163]\n", + "intercept=[-0.3367660807440124, -0.3838533140845082], slope=[1.0664311088106262, 1.0798799983131717], r-sq=[0.9999431892865129, 0.999928788576322]\n", + "intercept=[-0.3336881186128562, -0.3789886356645595], slope=[1.0653641129930689, 1.0782096210498118], r-sq=[0.9999437881173598, 0.9999287671852368]\n", + "intercept=[-0.33431433435700303, -0.38001751642276127], slope=[1.0655782892719037, 1.0785611386674192], r-sq=[0.9999437446206533, 0.9999288287833767]\n", + "intercept=[-0.33417685892285004, -0.37979427432824475], slope=[1.0655314178214903, 1.0784848717846809], r-sq=[0.9999437569948211, 0.9999288208033832]\n", + "intercept=[-0.33420689039884083, -0.379842837443582], slope=[1.065541656505596, 1.078501460303492], r-sq=[0.9999437542501001, 0.9999288225499203]\n", + "\n", + "Solved in 257 seconds\n" + ] + } + ], + "source": [ + "consumer = AggShockMarkovConsumerType(cycles=0)\n", + "econ = CobbDouglasMarkovEconomy(agents=[consumer], verbose=True)\n", + "econ.make_AggShkHist()\n", + "econ.give_agent_params()\n", + "\n", + "t0 = time.time()\n", + "econ.solve()\n", + "elapsed = time.time() - t0\n", + "print(f\"\\nSolved in {elapsed:.0f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "bf0c0720", + "metadata": {}, + "source": [ + "## 2. Examine the Solution\n", + "\n", + "After convergence, we have:\n", + "\n", + "- **AFunc[z]**: Aggregate saving rule $\\log A = a_z + b_z \\log M$ for each Markov state\n", + "- **cFunc[z](m, M)**: Individual consumption function (2D!) for each state\n", + "- **Rfunc(K/L)**, **wFunc(K/L)**: Cobb-Douglas production functions\n", + "- **history**: Simulated trajectory of $M_t$, $A_t$, and $z_t$\n", + "**Simulation API.** The KS Monte Carlo run stores aggregate series in **`econ.history`**.\n", + "Per-agent YAML simulation uses **`initialize_sym()`** / **`symulate()`** and **`hystory`** instead; see `Transition_Matrix_Example.ipynb` and notebooks `02`–`04` here.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "86220aa5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:36.100932Z", + "iopub.status.busy": "2026-03-21T04:29:36.100682Z", + "iopub.status.idle": "2026-03-21T04:29:36.109660Z", + "shell.execute_reply": "2026-03-21T04:29:36.108601Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Economy History ===\n", + "M range: [8.98, 23.72], mean: 12.64\n", + "A range: [7.27, 20.82], mean: 10.63\n", + "\n", + "State 0 (Recession): mean M = 15.97, mean A = 13.47, count = 381/1200\n", + "State 1 (Expansion): mean M = 11.09, mean A = 9.30, count = 819/1200\n", + "\n", + "MrkvArray:\n", + "[[0.9 0.1 ]\n", + " [0.04 0.96]]\n", + "PermGroFacAgg: [0.98, 1.02]\n" + ] + } + ], + "source": [ + "M_hist = np.array(econ.history[\"MaggNow\"])\n", + "A_hist = np.array(econ.history[\"AaggNow\"])\n", + "Mrkv_hist = econ.MrkvNow_hist\n", + "\n", + "print(\"=== Economy History ===\")\n", + "print(f\"M range: [{M_hist.min():.2f}, {M_hist.max():.2f}], mean: {M_hist.mean():.2f}\")\n", + "print(f\"A range: [{A_hist.min():.2f}, {A_hist.max():.2f}], mean: {A_hist.mean():.2f}\")\n", + "print()\n", + "for j in [0, 1]:\n", + " mask = Mrkv_hist == j\n", + " label = \"Recession\" if j == 0 else \"Expansion\"\n", + " print(\n", + " f\"State {j} ({label}): mean M = {M_hist[mask].mean():.2f}, \"\n", + " f\"mean A = {A_hist[mask].mean():.2f}, count = {mask.sum()}/{len(Mrkv_hist)}\"\n", + " )\n", + "\n", + "print(f\"\\nMrkvArray:\\n{econ.MrkvArray}\")\n", + "print(f\"PermGroFacAgg: {econ.PermGroFacAgg}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "30f5ce0a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:36.115735Z", + "iopub.status.busy": "2026-03-21T04:29:36.115445Z", + "iopub.status.idle": "2026-03-21T04:29:36.484204Z", + "shell.execute_reply": "2026-03-21T04:29:36.483858Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAHqCAYAAACne3d+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hT1f8H8PfN7kjSvaAbaBllT9myl4Ige8tQtooDFQUXoqIoKuICxCLKFFFZgihL9hJkWTZtoXumGef3B7/mS+igI21a+n49Tx/IuSf3fu5J0p6bzz3nSEIIASIiIiIiIiIiIiIiokpA5ugAiIiIiIiIiIiIiIiIioqJDSIiIiIiIiIiIiIiqjSY2CAiIiIiIiIiIiIiokqDiQ0iIiIiIiIiIiIiIqo0mNggIiIiIiIiIiIiIqJKg4kNIiIiIiIiIiIiIiKqNJjYICIiIiIiIiIiIiKiSoOJDSIiIiIiIiIiIiIiqjSY2CAiIiIiIiIiIiIiokqDiQ0iIiIiIiIiIiIiIqo0mNggIiIiIiIiIiIiIqJKg4kNIqIKYNmyZZAkCYcOHXJ0KFSGQkJC0Lt3b0eHUaaqwjkSERERFSS3X3/p0iVHh1JpsM2qjjlz5kCSJNy+fdvRoRDRA4CJDaJK4rPPPoMkSWjRooWjQ3G4lStXYuHChXbf7+jRoyFJEnQ6HbKysvJsP3/+PCRJgiRJeP/99+1+fHt6++23sWHDhiLVvXTpkvW8JEmCTCaDh4cHevTogX379pVtoGR3d7+eb775Zr51hg0bBkmS4OrqWs7Rla+TJ09iwIABCA4OhkajQbVq1dClSxcsWrTIpl5xPi/5OX36NObMmcOLcSIiqtQuXryIiRMnIiwsDBqNBjqdDq1bt8ZHH32Ub9+4qtu7dy/mzJmD5ORkR4dilZsgyO/nxRdfdHR4FbLNiqq4sd/9WuzevTvPdiEEAgMDIUlShb8paMuWLdZzWbVqVZ7tOTk5CAsLgyRJaNiwYfkHWICiXAvY4z1Zmd/XRJUdExtElUR0dDRCQkJw4MABXLhwwdHhOFRZJTYAQKFQIDMzEz///HOebdHR0dBoNGVyXHsryRe1Q4YMwYoVK7B06VI89dRT2L9/Pzp27IiTJ0+WTZBUpjQaDb7//vs85RkZGfjpp58qzXu5pPbu3YumTZvi+PHjGD9+PD755BOMGzcOMpkMH330kU1deyQ25s6dy8QGERFVWr/88guioqLw448/ok+fPli0aBHmzZuHoKAgPPfcc5g+fbqjQ6xw9u7di7lz5+b5MnPEiBHIyspCcHCwYwID8Prrr2PFihU2P4MHD3ZYPLkqcpvdT0Gx349Go8HKlSvzlO/atQvXrl2DWq22U4Rl5/jx4wDunMvp06fzbF+yZAmuX78OAGjQoEG5xlaQol4LlPR1vfdYpd0HEZWMwtEBENH9xcTEYO/evVi3bh0mTpyI6OhovPbaaw6JxWQywWKxQKVSOeT4ZU2tVqN169b4/vvvMXDgQJttK1euRK9evbB27Vq7HS87O7vCtGXjxo0xfPhw6+O2bduiR48eWLx4MT777DMHRlY6mZmZcHZ2dnQY5a5nz55Yt24djh8/bnOB8dNPPyEnJwfdu3fHjh077Ha8itbOb731FvR6PQ4ePAg3NzebbfHx8Y4JioiIqAKKiYnB4MGDERwcjB07dsDf39+6bfLkybhw4QJ++eUXB0ZYucjlcsjlcofG0KNHDzRt2tShMRRHRWizstKzZ0+sXr0aH3/8MRSK/30Ft3LlSjRp0qRSTMl04sQJuLm5oWnTpjhz5ozNtvT0dLz55pvo2bMnNmzYUGESG7wWIKoaOGKDqBKIjo6Gu7s7evXqhQEDBiA6OjrfegkJCRgxYgR0Oh3c3NwwatQoHD9+HJIkYdmyZTZ1V69ejTp16kCj0aBevXpYv349Ro8ejZCQEGud3Clt3n//fSxcuBDh4eFQq9XWuzT+/fdfDBgwAB4eHtBoNGjatCk2btyYJ64TJ06gffv2cHJyQvXq1fHmm29i6dKleeZR/emnn9CrVy8EBARArVYjPDwcb7zxBsxms7VOhw4d8Msvv+Dy5cvW4bB3x2wwGPDaa6+hRo0aUKvVCAwMxPPPPw+DwVDk9h46dCh+++03mzsuDh48iPPnz2Po0KF56icmJmLmzJmIioqCq6srdDodevToYb2zJdcff/xhHb77yiuvoFq1anB2dkZqamq+cSQlJaF58+aoXr06zp49W+TzkyQJGRkZWL58ubWNRo8eXeTzz9W2bVsAd6YluFtycjJmzJiBwMBAqNVq1KhRA/Pnz4fFYrGpt2rVKjRp0gRarRY6nQ5RUVF57pT/77//8Pjjj8PDwwPOzs5o2bJlngvngubczW3PP/74w1rWoUMH1KtXD4cPH0a7du3g7OyMl156CcCdJNKcOXNQq1YtaDQa+Pv747HHHrM5P4vFgoULF6Ju3brQaDTw9fXFxIkTkZSUZHPsQ4cOoVu3bvDy8oKTkxNCQ0MxduzYIrft1q1b0bBhQ2g0GtSpUwfr1q2zaRNJkvDhhx/med7evXshSVK+IzHu1apVK4SGhua5Qyw6Ohrdu3eHh4dHnucU5TMIFN7O+Vm+fDkUCgWee+45a9nq1avRpEkTODk5wcvLC8OHD7fe6QUA77//PiRJwuXLl/Psb9asWVCpVHlel7tdvHgRdevWzXMhAwA+Pj7W/xf2ebl8+TImTZqEiIgIODk5wdPTE48//rjNe3HZsmV4/PHHAQAdO3a07uPu9+Vvv/2Gtm3bwsXFBVqtFr169cI///xTYOxERETl6d1330V6ejq+/vprm6RGrho1atiM2Dh69Ch69OgBnU4HV1dXdOrUCfv377d5Tu48+hcuXMDo0aPh5uYGvV6PMWPGIDMz06ZuWloaZsyYgZCQEKjVavj4+KBLly44cuQIAOS5Rrn3GPmVnTt3DsOHD4der4e3tzdmz54NIQSuXr2KRx99FDqdDn5+fliwYEG+z//3338xcOBA6HQ6eHp6Yvr06cjOzrapl9uvCQ0Ntf79v3TpUoF9V3u3W0mVpD2LGs/169fxxBNPWPuSoaGheOqpp5CTk1Nh26wo/b3CYr+fIUOGICEhAdu2bbOW5eTkYM2aNfleW+a249ixY+Hr6wu1Wo26devim2++KXbc9mqj48ePIyoqClFRUXlGbCxYsAAmkwndu3cHUPQRG7dv3y70M7Zz505IkoT169fnee7KlSshSVKh0yYX5Vrgfq+rPd4bRXktiajkOGKDqBKIjo7GY489BpVKhSFDhmDx4sU4ePAgmjVrZq1jsVjQp08fHDhwAE899RQiIyPx008/YdSoUXn298svv2DQoEGIiorCvHnzkJSUhCeeeALVqlXL9/hLly5FdnY2JkyYALVaDQ8PD/zzzz9o3bo1qlWrhhdffBEuLi748ccf0bdvX6xduxb9+vUDcOcPee6XfbNmzYKLiwu++uqrfIfcLlu2DK6urnjmmWfg6uqKHTt24NVXX0Vqairee+89AMDLL7+MlJQUXLt2zfrFb+46ARaLBY888gh2796NCRMmoHbt2jh58iQ+/PBDnDt3rshTzTz22GN48sknsW7dOuuX1StXrkRkZCQaN26cp/5///2HDRs24PHHH0doaCji4uKwZMkStG/fHqdPn0ZAQIBN/TfeeAMqlQozZ86EwWDId8TG7du30aVLFyQmJmLXrl0IDw8v8vmtWLEC48aNQ/PmzTFhwgQAQHh4eJHO/W65nTF3d3drWWZmJtq3b4/r169j4sSJCAoKwt69ezFr1izcvHnTOkXYtm3bMGTIEHTq1Anz588HAJw5cwZ79uyxXhjHxcXhoYceQmZmJqZNmwZPT08sX74cjzzyCNasWWN9DxVXQkICevTogcGDB2P48OHw9fWF2WxG79698fvvv2Pw4MGYPn060tLSsG3bNpw6dcraPhMnTsSyZcswZswYTJs2DTExMfjkk09w9OhR7NmzB0qlEvHx8ejatSu8vb3x4osvws3NDZcuXbJJThTm/PnzGDRoEJ588kmMGjUKS5cuxeOPP47NmzejS5cuCAsLQ+vWrREdHY2nn37a5rnR0dHQarV49NFHi3SsIUOG4LvvvsM777xjXaRv69atWLFiBTZv3pynflE+g4W1c36++OILPPnkk3jppZesa37ktnGzZs0wb948xMXF4aOPPsKePXtw9OhRuLm5YeDAgXj++efx448/2iREAODHH39E165dbd6b9woODsa+fftw6tQp1KtXr8B6hX1eDh48iL1792Lw4MGoXr06Ll26hMWLF6NDhw44ffo0nJ2d0a5dO0ybNg0ff/wxXnrpJdSuXRsArP+uWLECo0aNQrdu3TB//nxkZmZi8eLFaNOmDY4ePZrvFwtERETl6eeff0ZYWBgeeuih+9b9559/0LZtW+h0Ojz//PNQKpVYsmQJOnTogF27duVZD3DgwIEIDQ3FvHnzcOTIEXz11Vfw8fGx9g8B4Mknn8SaNWswZcoU1KlTBwkJCdi9ezfOnDmTb9+7KAYNGoTatWvjnXfewS+//II333wTHh4eWLJkCR5++GHMnz8f0dHRmDlzJpo1a4Z27drliTskJATz5s3D/v378fHHHyMpKQnffvstgDvXC+fOncP333+PDz/8EF5eXgAAb2/vcmu3wqSkpOQZCZAbY0kUJZ4bN26gefPmSE5OxoQJExAZGYnr169jzZo1yMzMrLBtVpT+XnFjv1tISAhatWqF77//Hj169ABw56aXlJQUDB48GB9//LFN/bi4OLRs2RKSJGHKlCnw9vbGb7/9hieeeAKpqamYMWNGkeO+V0naKCcnB2fPnsWECRNQr149fPLJJzCZTFAoFLh16xYWLFiAV1991XozUv369e/bJrmxFPYZ69ChAwIDAxEdHZ3nujA6Ohrh4eFo1apVgfsvyrXA/V7X0r43ivpaElEpCCKq0A4dOiQAiG3btgkhhLBYLKJ69epi+vTpNvXWrl0rAIiFCxday8xms3j44YcFALF06VJreVRUlKhevbpIS0uzlv3xxx8CgAgODraWxcTECABCp9OJ+Ph4m+N16tRJREVFiezsbGuZxWIRDz30kKhZs6a1bOrUqUKSJHH06FFrWUJCgvDw8BAARExMjLU8MzMzz/lPnDhRODs72xynV69eNnHmWrFihZDJZOKvv/6yKf/8888FALFnz548z7nbqFGjhIuLixBCiAEDBohOnToJIe60o5+fn5g7d661Td577z3r87Kzs4XZbLbZV0xMjFCr1eL111+3lu3cuVMAEGFhYXnOdenSpQKAOHjwoLh586aoW7euCAsLE5cuXSrR+bm4uIhRo0YVer53xwpAzJ07V9y6dUvExsaKv/76SzRr1kwAEKtXr7bWfeONN4SLi4s4d+6czT5efPFFIZfLxZUrV4QQQkyfPl3odDphMpkKPO6MGTMEAJvzSUtLE6GhoSIkJMTaprltc/d7RYj/tefOnTutZe3btxcAxOeff25T95tvvhEAxAcffJAnDovFIoQQ4q+//hIARHR0tM32zZs325SvX7/e+loVV3BwsAAg1q5day1LSUkR/v7+olGjRtayJUuWCADizJkz1rKcnBzh5eV139f17vfoqVOnbNr4008/Fa6uriIjI8Pm/Z6rqJ/Bgto59xx79eolhBDio48+EpIkiTfeeMPmPHx8fES9evVEVlaWtXzTpk0CgHj11VetZa1atRJNmjSx2f+BAwcEAPHtt98W2g5bt24VcrlcyOVy0apVK/H888+LLVu2iJycnDx1C/q85Nce+/bty3P81atX53kvCnHn/ezm5ibGjx9vUx4bGyv0en2eciIiovKWkpIiAIhHH320SPX79u0rVCqVuHjxorXsxo0bQqvVinbt2lnLXnvtNQFAjB071ub5/fr1E56enjZler1eTJ48ucBjjho1Kt++f+4x8iubMGGCtcxkMonq1asLSZLEO++8Yy1PSkoSTk5ONn2A3Oc/8sgjNvudNGmSACCOHz9uLXvvvffy7aPm13cti3bLT+6x8/vJVZL2LEo8I0eOFDKZLN8+cm5/uyK2WVH7ewXFXpC7r+8++eQTodVqrcd6/PHHRceOHYUQtn1nIYR44oknhL+/v7h9+7bN/gYPHiz0er11H0WNW4jStdHRo0cFALFkyRLx999/21yjTJs2TVSvXl1kZWWJnj17Cn9///u2S3E+Y7NmzRJqtVokJydby+Lj44VCoRCvvfZaoccp6rVAYa9rad8bRX0tiajkOBUVUQUXHR0NX19fdOzYEcCdaVMGDRqEVatW2UwPs3nzZiiVSowfP95aJpPJMHnyZJv93bhxAydPnsTIkSOtIx0AoH379oiKiso3hv79+9vcjZKYmIgdO3Zg4MCBSEtLw+3bt3H79m0kJCSgW7duOH/+vHVKmc2bN6NVq1Zo2LCh9fkeHh4YNmxYnuM4OTlZ/5+737Zt2yIzMxP//vvvfdtq9erVqF27NiIjI60x3b59Gw8//DCAO8NZi2ro0KH4448/EBsbix07diA2NrbAocJqtRoy2Z1fp2azGQkJCXB1dUVERIR1CP3dRo0aZXOud7t27Rrat28Po9GIP//802YBPXueX35ee+01eHt7w8/PD23btsWZM2ewYMECDBgwwCaGtm3bwt3d3SaGzp07w2w2488//wQAuLm5ISMjw2bI9b1+/fVXNG/eHG3atLGWubq6YsKECbh06VK+C9MVhVqtxpgxY2zK1q5dCy8vL0ydOjVP/dwh96tXr4Zer0eXLl1szq1JkyZwdXW1tm/ucOZNmzbBaDQWO76AgACbu450Oh1GjhyJo0ePIjY2FsCdO5g0Go3NtHNbtmzB7du3bdZBuZ+6deuifv361qmrVq5ciUcffbTAtTCK8xnMr53v9u6772L69OmYP38+XnnlFWv5oUOHEB8fj0mTJtksYN6rVy9ERkbaTEU2aNAgHD582Ga6sB9++AFqtfq+o1a6dOmCffv24ZFHHsHx48fx7rvvolu3bqhWrVq+U+bl5+72MBqNSEhIQI0aNeDm5pbvZ/te27ZtQ3JyMoYMGWLznpLL5WjRokWpP7NERESllTslqlarvW9ds9mMrVu3om/fvggLC7OW+/v7Y+jQodi9e3eeKVaffPJJm8dt27ZFQkKCTT03Nzf8/fffuHHjRmlOxca4ceOs/5fL5WjatCmEEHjiiSdsjhsREYH//vsvz/PvvYbK7UP++uuvxY6lrNqtMJ9++im2bdtm81Ma94vHYrFgw4YN6NOnT75re9w7xdX9lGeblba/VxQDBw5EVlYWNm3ahLS0NGzatCnfa0shBNauXYs+ffpACGHTf+zWrRtSUlKsMZUk7pK00YkTJwDcmWKqbt26kCQJZ86cwaVLl/D5559j7ty50Gg0OHHiRLHW1yjKZ2zkyJEwGAxYs2aNteyHH36AyWS67zWRo68FivNaElHJMbFBVIGZzWasWrUKHTt2RExMDC5cuIALFy6gRYsWiIuLw++//26te/nyZfj7++f5wrJGjRo2j3OHiN5bXlAZcGeuyLtduHABQgjMnj0b3t7eNj+5i5rnLsh1+fLlIh/rn3/+Qb9+/aDX66HT6eDt7W3tsKSkpOQb293Onz+Pf/75J09MtWrVsompKHr27AmtVosffvgB0dHRaNasWYHtY7FY8OGHH6JmzZpQq9Xw8vKCt7c3Tpw4kW/c97bn3UaMGIH4+Hjs2rUrz9Rg9jy//EyYMAHbtm3Dzz//jKeffhpZWVl51lY4f/48Nm/enCeGzp0728QwadIk1KpVCz169ED16tUxduzYPFMfXb58GREREXniyJ3CJ7+1FYqiWrVqeab3unjxIiIiImwW7LvX+fPnkZKSAh8fnzznl56ebj239u3bo3///pg7dy68vLzw6KOPYunSpUVex6VGjRp5Lu5yX8Pc6b/c3NzQp08fm/UxoqOjUa1aNWsiq6iGDh2K1atX48KFC9i7d2+BCTqgeJ/B/No5165du/DCCy/ghRdeyDONVO7rmt9rHxkZafO6P/7445DJZPjhhx8A3LlAWL16tXWu5ftp1qwZ1q1bh6SkJBw4cACzZs1CWloaBgwYUKTEWVZWFl599VXrejK5n+3k5OQi/04CgIcffjjPe2rr1q1cuJCIiBwu9+9pWlrafeveunULmZmZBfbfLBYLrl69alMeFBRk8zh3Gsm718l69913cerUKQQGBqJ58+aYM2dOvsmG4rj3uHq9HhqNJs90THq9Pt81u2rWrGnzODw8HDKZrEhrKtyrrNqtMM2bN0fnzp1tfkrjfvHcunULqamphU7/WRzl2Wal7e8VRe710sqVK7Fu3TqYzWabm8dy3bp1C8nJyfjiiy/y9B1zbyjK7T+WJO6StNHx48chk8lQr149uLi4IDQ0FKdPn8bs2bMRHh6OUaNGISkpCdeuXStWYqMon7HIyEg0a9bM5mav6OhotGzZssBr87s58lqgOK8lEZUc19ggqsB27NiBmzdvYtWqVVi1alWe7dHR0ejatWuZx3Hv6ILcRaJnzpyJbt265fuconQ07pacnIz27dtDp9Ph9ddfR3h4ODQaDY4cOYIXXnghz8LU+bFYLIiKisIHH3yQ7/bAwMAix6NWq/HYY49h+fLl+O+//zBnzpwC67799tuYPXs2xo4dizfeeAMeHh6QyWSYMWNGvnEXNFoDuDPP57fffouPPvoI8+bNs9lmz/PLT82aNa0XPb1794ZcLseLL76Ijh07Wu+8slgs6NKlC55//vl895H7Bb2Pjw+OHTuGLVu24LfffsNvv/2GpUuXYuTIkVi+fHmx4iroDq97ky65CmvfwlgsFvj4+Nh0nO+WO2pJkiSsWbMG+/fvx88//4wtW7Zg7NixWLBgAfbv328zEqo0Ro4cidWrV2Pv3r2IiorCxo0bMWnSJOvooKIaMmQIZs2ahfHjx8PT07PA3xnF/QwW1s5169ZFcnIyVqxYgYkTJxaazCtMQEAA2rZtix9//BEvvfQS9u/fjytXrhR5fulcKpUKzZo1Q7NmzVCrVi2MGTMGq1evtiZiCzJ16lQsXboUM2bMQKtWraDX6yFJEgYPHlzk30nAnXU2/Pz88mwvLNFGRERUHnQ6HQICAnDq1Kky2b9cLs+3XAhh/f/AgQPRtm1brF+/Hlu3bsV7772H+fPnY926dejRo0ex+4IFHbcosRSkuCMOSqs0sd6PvdrTXvHYS0ljLG1/r6iGDh2K8ePHIzY2Fj169Mh3Uevc4w0fPjzftTKB/61hUZK4S9JGJ06cQFhYGFxcXAAA9erVw7p163Ds2DGsWbMGcrkcx48ft4mtJAp6X44cORLTp0/HtWvXYDAYsH//fnzyySfF2rcjrgWK81oSUcnxipqoAouOjoaPjw8+/fTTPNvWrVuH9evX4/PPP4eTkxOCg4Oxc+dOZGZm2ozauHDhgs3zcqc2ure8oLL85A4HViqV9737Jzg4uEjH+uOPP5CQkIB169bZLN4XExOT57kFdXrCw8Nx/PhxdOrUyS4XH0OHDsU333wDmUyGwYMHF1hvzZo16NixI77++mub8uTk5GIv0jd16lTUqFEDr776KvR6PV588UXrtuKcnz3O/+WXX8aXX36JV155xTraIjw8HOnp6UW660ulUqFPnz7o06cPLBYLJk2ahCVLlmD27NmoUaMGgoODcfbs2TzPy53yKPe9mnsnUXJysk294ozoCA8Px99//w2j0QilUllgne3bt6N169ZFSo60bNkSLVu2xFtvvYWVK1di2LBhWLVqlc3UB/nJHfF092t07tw5ALBZSLp79+7w9vZGdHQ0WrRogczMTIwYMaIIZ2srKCgIrVu3xh9//IGnnnqqwC/Ti/MZvB8vLy+sWbMGbdq0QadOnbB7924EBAQA+N/revbs2TyjT86ePWsz/RpwZzqqSZMm4ezZs/jhhx/g7OyMPn36FDumXLlJups3b1rLCvq8rFmzBqNGjcKCBQusZdnZ2Xnei4X9TgLuJPpKe6ckERFRWenduze++OIL7Nu3r9DFeL29veHs7Fxg/00mk5X4Rht/f39MmjQJkyZNQnx8PBo3boy33noLPXr0gLu7e56/vUDJR/cWxfnz521uzLhw4QIsFotNX62o/e2ybLeSKIv29Pb2hk6nu2+CrCK2WWn7e0XVr18/TJw4Efv377eORr6Xt7c3tFotzGbzffuORY27tE6cOGEzdXC9evWwceNGtGjRwjq97t3TVRVVUT5jADB48GA888wz+P7775GVlQWlUolBgwaV+HzuvRYo7HUtzXujOK8lEZUcp6IiqqCysrKwbt069O7dGwMGDMjzM2XKFKSlpVnnh+zWrRuMRiO+/PJL6z4sFkuepEhAQADq1auHb7/9Funp6dbyXbt24eTJk0WKzcfHBx06dMCSJUtsvhzMdevWLev/u3Xrhn379uHYsWPWssTExDx3xefePXL33SI5OTn47LPP8uzfxcUl36GfAwcOxPXr123aIFdWVhYyMjLuf3J36dixI9544w188skn+d5tfXfs997lsnr1aus6I8U1e/ZszJw5E7NmzcLixYut5cU5PxcXl1J3at3c3DBx4kRs2bLF+voNHDgQ+/btw5YtW/LUT05OhslkAgAkJCTYbJPJZNY7UnKnbOrZsycOHDiAffv2WetlZGTgiy++QEhICOrUqQPgf18O567fAdy5o+yLL74o8rn0798ft2/fzvfuntzXbuDAgTCbzXjjjTfy1DGZTNb2TEpKyvN6564hU5TpqG7cuIH169dbH6empuLbb79Fw4YNbd5nCoUCQ4YMwY8//ohly5YhKiqqxHf1vPnmm3jttdfyXWMkV3E+g0VRvXp1bN++HVlZWejSpYv1PdG0aVP4+Pjg888/t2mv3377DWfOnEGvXr1s9tO/f3/I5XJ8//33WL16NXr37m29Y6wwO3fuzPfus9x5e++e2qCgz0t+n+1FixbluaMxN55799GtWzfodDq8/fbb+a7HcvfvSiIiIkd5/vnn4eLignHjxiEuLi7P9osXL+Kjjz6CXC5H165d8dNPP9lMFxMXF4eVK1eiTZs2RZoq8m5mszlPv97HxwcBAQHWfkJ4eDhSUlKsX54Cd76UvLs/ZW/3XkMtWrQIANCjRw9rWUF//+9VFu1WGmXRnjKZDH379sXPP/+MQ4cO5dme25+qiG1W2v5eUbm6umLx4sWYM2dOgTfpyOVy9O/fH2vXrs03SXR337GocZdGbGws4uPjba5BBgwYgNdee83mOvXEiRNQq9X5Th1WkKJ8xoA7N0z16NED3333HaKjo9G9e/ci3TxY1GuBwl7X0rw3ivNaElHJccQGUQW1ceNGpKWl4ZFHHsl3e8uWLa13cw8aNAh9+/ZF8+bN8eyzz+LChQuIjIzExo0bkZiYCMD2LoK3334bjz76KFq3bo0xY8YgKSkJn3zyCerVq2eT7CjMp59+ijZt2iAqKgrjx49HWFgY4uLisG/fPly7ds06HPX555/Hd999hy5dumDq1KlwcXHBV199haCgICQmJlrjeuihh+Du7o5Ro0Zh2rRpkCQJK1asyLcz0qRJE/zwww945pln0KxZM7i6uqJPnz4YMWIEfvzxRzz55JPYuXMnWrduDbPZjH///Rc//vgjtmzZku9idgWRyWQ2ix4XpHfv3nj99dcxZswYPPTQQzh58iSio6NtFrorrvfeew8pKSmYPHkytFothg8fXqzza9KkCbZv344PPvgAAQEBCA0NRYsWLYodx/Tp07Fw4UK88847WLVqFZ577jls3LgRvXv3xujRo9GkSRNkZGTg5MmTWLNmDS5dugQvLy+MGzcOiYmJePjhh1G9enVcvnwZixYtQsOGDa1raLz44ov4/vvv0aNHD0ybNg0eHh5Yvnw5YmJisHbtWuuUS3Xr1kXLli0xa9YsJCYmwsPDA6tWrbImUYpi5MiR+Pbbb/HMM8/gwIEDaNu2LTIyMrB9+3ZMmjQJjz76KNq3b4+JEydi3rx5OHbsGLp27QqlUonz589j9erV+OijjzBgwAAsX74cn332Gfr164fw8HCkpaXhyy+/hE6nQ8+ePe8bS61atfDEE0/g4MGD8PX1xTfffIO4uDgsXbo037g//vhj7Ny5s9jTL92tffv2aN++faF1ivMZLKoaNWpg69at6NChA7p164YdO3ZAp9Nh/vz5GDNmDNq3b48hQ4YgLi4OH330EUJCQvD000/b7MPHxwcdO3bEBx98gLS0tCLfoTV16lRkZmaiX79+iIyMRE5ODvbu3YsffvgBISEhNgufF/R56d27N1asWAG9Xo86depg37592L59Ozw9PW2O1bBhQ8jlcsyfPx8pKSlQq9V4+OGH4ePjg8WLF2PEiBFo3LgxBg8eDG9vb1y5cgW//PILWrduXeyh9ERERPYWHh6OlStXYtCgQahduzZGjhyJevXqWf92rl69GqNHjwZw52aJbdu2oU2bNpg0aRIUCgWWLFkCg8GAd999t9jHTktLQ/Xq1TFgwAA0aNAArq6u2L59Ow4ePGi9S3rw4MF44YUX0K9fP0ybNg2ZmZlYvHgxatWqVWaL78bExOCRRx5B9+7dsW/fPnz33XcYOnSozR3pTZo0AXBnlPPgwYOhVCoL/MLa3u1WGmXVnm+//Ta2bt2K9u3bY8KECahduzZu3ryJ1atXY/fu3XBzc6uQbVbU/l5BsRflhptcBU1JdLd33nkHO3fuRIsWLTB+/HjUqVMHiYmJOHLkCLZv3269vi9q3KWR3xRTjRo1QqNGjfLUq1u3brGmWS3KZyzXyJEjrWuS5HcTWn6Kei1Q2Ota2vdGUV9LIioFQUQVUp8+fYRGoxEZGRkF1hk9erRQKpXi9u3bQgghbt26JYYOHSq0Wq3Q6/Vi9OjRYs+ePQKAWLVqlc1zV61aJSIjI4VarRb16tUTGzduFP379xeRkZHWOjExMQKAeO+99/I9/sWLF8XIkSOFn5+fUCqVolq1aqJ3795izZo1NvWOHj0q2rZtK9RqtahevbqYN2+e+PjjjwUAERsba623Z88e0bJlS+Hk5CQCAgLE888/L7Zs2SIAiJ07d1rrpaeni6FDhwo3NzcBQAQHB1u35eTkiPnz54u6desKtVot3N3dRZMmTcTcuXNFSkpKoW0+atQo4eLiUmid/NokOztbPPvss8Lf3184OTmJ1q1bi3379on27duL9u3bW+vt3LlTABCrV6/Os9+lS5cKAOLgwYPWMrPZLIYMGSIUCoXYsGFDsc7v33//Fe3atRNOTk4CgBg1alSxzuluo0ePFnK5XFy4cEEIIURaWpqYNWuWqFGjhlCpVMLLy0s89NBD4v333xc5OTlCCCHWrFkjunbtKnx8fIRKpRJBQUFi4sSJ4ubNmzb7vnjxohgwYIBwc3MTGo1GNG/eXGzatClPDBcvXhSdO3cWarVa+Pr6ipdeekls27Ytz3ujffv2om7duvmeR2Zmpnj55ZdFaGioUCqVws/PTwwYMEBcvHjRpt4XX3whmjRpIpycnIRWqxVRUVHi+eefFzdu3BBCCHHkyBExZMgQERQUJNRqtfDx8RG9e/cWhw4dKrCNcwUHB4tevXqJLVu2iPr16wu1Wi0iIyPzfU/kqlu3rpDJZOLatWv33b8Q9389c+X3fi/qZ7Cwds49x7v9/fffQqvVinbt2onMzEwhhBA//PCDaNSokVCr1cLDw0MMGzaswHP88ssvBQCh1WpFVlbW/ZpACCHEb7/9JsaOHSsiIyOFq6urUKlUokaNGmLq1KkiLi7Opm5Bn5ekpCQxZswY4eXlJVxdXUW3bt3Ev//+K4KDg/N8pr788ksRFhYm5HJ5nvbauXOn6Natm9Dr9UKj0Yjw8HAxevToIr1niIiIysu5c+fE+PHjRUhIiFCpVEKr1YrWrVuLRYsWiezsbGu9I0eOiG7duglXV1fh7OwsOnbsKPbu3Wuzr9dee00AELdu3bIpz+3zxsTECCGEMBgM4rnnnhMNGjQQWq1WuLi4iAYNGojPPvvM5nlbt24V9erVEyqVSkRERIjvvvvOeoyiHLegfv69fZrc558+fVoMGDBAaLVa4e7uLqZMmZJvH+SNN94Q1apVEzKZzHpe955jWbRbQfK7pshPaduzoHguX74sRo4cKby9vYVarRZhYWFi8uTJwmAwWOtUtDYrTn8vv9gLUtTXIr++c1xcnJg8ebIIDAy0Xrd06tRJfPHFFyWKu6Rt9O677woA1uvA/JjNZuHk5CRGjx5d6HneG0tRP2NC3Pk94e7uLvR6fZlcCxT0utrjvVGU15KISk4SogKt9kREdrdhwwb069cPu3fvRuvWrQut27BhQ3h7e2Pbtm1lHteMGTOwZMkSpKenF7iIGRHduSvKw8MDv//+u6NDISIiInqgzZkzB3PnzsWtW7eKvVYeEZUNk8mEgIAA9OnTJ8+6lkRUtXGNDaIHSFZWls1js9mMRYsWQafToXHjxtZyo9GYZxqfP/74A8ePH0eHDh3KPK6EhASsWLECbdq0YVKDqBCHDh3CsWPHMHLkSEeHQkREREREVO42bNiAW7du8ZqIiPLgGhtED5CpU6ciKysLrVq1gsFgwLp167B37168/fbbcHJysta7fv06OnfujOHDhyMgIAD//vsvPv/8c/j5+eHJJ5+0e1ytWrVChw4dULt2bcTFxeHrr79GamoqZs+ebfdjET0ITp06hcOHD2PBggXw9/cv8roSRERERERED4K///4bJ06cwBtvvIFGjRrdd81AIqp6mNggeoA8/PDDWLBgATZt2oTs7GzUqFEDixYtwpQpU2zqubu7o0mTJvjqq69w69YtuLi4oFevXnjnnXfsuthYrp49e2LNmjX44osvIEkSGjdujK+//hrt2rWz+7GIHgRr1qzB66+/joiICHz//ffQaDSODomIiIiIiKjcLF68GN999x0aNmyIZcuWOTocIqqAuMYGERERERFVWn/++Sfee+89HD58GDdv3sT69evRt29f63YhBF577TV8+eWXSE5ORuvWrbF48WLUrFnTcUETEREREVGpcI0NIiIiIiKqtDIyMtCgQQN8+umn+W5/99138fHHH+Pzzz/H33//DRcXF3Tr1g3Z2dnlHCkREREREdkLR2wQEREREdEDQZIkmxEbQggEBATg2WefxcyZMwEAKSkp8PX1xbJlyzB48GAHRktERERERCVV5dbYsFgsuHHjBrRaLSRJcnQ4REREREQVlhACaWlpCAgIgExW+QZ7x8TEIDY2Fp07d7aW6fV6tGjRAvv27cs3sWEwGGAwGKyPLRYLEhMT4enpyesHIiIiIqL7KK9riCqX2Lhx4wYCAwMdHQYRERERUaVx9epVVK9e3dFhFFtsbCwAwNfX16bc19fXuu1e8+bNw9y5c8s8NiIiIiKiB1lZX0NUucSGVqsFcKdhdTqdg6MhIiIiIqq4UlNTERgYaO1DVwWzZs3CM888Y32ckpKCoKAgXj8QEVUQZrMZ586dQ3Z2NoKDg+Hh4eHokIiI6C7ldQ1R5RIbucPHdTodL0yIiIiIiIqgsk7B5OfnBwCIi4uDv7+/tTwuLg4NGzbM9zlqtRpqtTpPOa8fiIgqjiZNmiA1NZVJDSKiCqysryEq30S5RERERERERRAaGgo/Pz/8/vvv1rLU1FT8/fffaNWqlQMjIyKi4rJYLNb/KxQKJjWIiKq4Kjdig4iIiIiIHhzp6em4cOGC9XFMTAyOHTsGDw8PBAUFYcaMGXjzzTdRs2ZNhIaGYvbs2QgICEDfvn0dFzQRERVLRkYGLly4gJCQEOj1ekeHQ0REFQATG0REREREVGkdOnQIHTt2tD7OXR9j1KhRWLZsGZ5//nlkZGRgwoQJSE5ORps2bbB582ZoNBpHhUxERMV069YtmEwmxMfHM7FBREQAAEkIIRwdRHlKTU2FXq9HSkoK58glIiIihzKbzTAajY4Og6o4lUoFmSz/GWrZd2YbEBFVBEII3Lx5E76+vpDL5Y4OhygP9uupKlEqlYX+Li6v/nOFGrExb948rFu3Dv/++y+cnJzw0EMPYf78+YiIiMhTVwiBnj17YvPmzVi/fj2HkhMREVGlIYRAbGwskpOTHR0KEWQyGUJDQ6FSqRwdChERkZUQwrrwrCRJCAgIcHBERHmxX09VlZubG/z8/Mp8gfDCVKjExq5duzB58mQ0a9YMJpMJL730Erp27YrTp0/DxcXFpu7ChQsd2nBEREREJZV78ePj4wNnZ2f2achhLBYLbty4gZs3byIoKIjvRSIiqhCEELhw4QJ0Oh18fX0dHQ5Rgdivp6pGCIHMzEzEx8cDAPz9/R0WS4VKbGzevNnm8bJly+Dj44PDhw+jXbt21vJjx45hwYIFOHTokEMbj4iIiKi4zGaz9eLH09PT0eEQwdvbGzdu3IDJZIJSqXR0OEREREhKSkJqairS09Ph7u7OUYVUIbFfT1WVk5MTACA+Ph4+Pj4OmyKwQiU27pWSkgIA8PDwsJZlZmZi6NCh+PTTT+Hn5+eo0IiIiIhKJHfuXWdnZwdHQnRH7pdFZrOZiQ0iIqoQPDw8YDQaodFomNSgCov9eqrKct/3RqORiY17WSwWzJgxA61bt0a9evWs5U8//TQeeughPProo0Xaj8FggMFgsD5OTU21e6xERERExcVh6lRR8L1IREQVEaegosqCfSmqiirC+77CJjYmT56MU6dOYffu3dayjRs3YseOHTh69GiR9zNv3jzMnTu3LEIkIiIiIiIiIiI7SExMRGpqKoKDgyvEF2ZERFSxyRwdQH6mTJmCTZs2YefOnahevbq1fMeOHbh48SLc3NygUCigUNzJy/Tv3x8dOnTId1+zZs1CSkqK9efq1avlcQpEREREVMGEhIRg4cKFjg6DiIiI7mE0GnH58mUkJCTg9u3bjg6HiCq48uzXjxgxAm+//Xa5HMuRNm/ejIYNG8JisTg6lCKrUIkNIQSmTJmC9evXY8eOHQgNDbXZ/uKLL+LEiRM4duyY9QcAPvzwQyxdujTffarVauh0OpsfIiIiIiq+0aNHQ5IkSJIEpVKJ0NBQPP/888jOznZ0aEVy8OBBTJgwwdFhEBER0T2USiXCwsLg6ekJLy8vR4dD9MBjv75ojh8/jl9//RXTpk2zlnXo0AGSJOGdd97JU79Xr16QJAlz5swp8TGnTZuGJk2aQK1Wo2HDhvnWEULg/fffR61ataBWq1GtWjW89dZbhe43MTERw4YNg06ng5ubG5544gmkp6dbt3fv3h1KpRLR0dEljr28VaipqCZPnoyVK1fip59+glarRWxsLABAr9fDyckJfn5++S4YHhQUlCcJQkRERET21717dyxduhRGoxGHDx/GqFGjIEkS5s+f7+jQ7svb29vRIRAREVEB9Ho99Hq9o8MgqjLYr7+/RYsW4fHHH4erq6tNeWBgIJYtW4YXX3zRWnb9+nX8/vvv8Pf3L/Vxx44di7///hsnTpzId/v06dOxdetWvP/++4iKikJiYiISExML3eewYcNw8+ZNbNu2DUajEWPGjMGECROwcuVKa53Ro0fj448/xogRI0p9DuWhQo3YWLx4MVJSUtChQwf4+/tbf3744QdHh0ZEREREuDMa1s/PD4GBgejbty86d+6Mbdu2WbdbLBbMmzcPoaGhcHJyQoMGDbBmzRqbffzzzz/o3bs3dDodtFot2rZti4sXL1q3f/XVV6hduzY0Gg0iIyPx2WefWbfl5ORgypQp8Pf3h0ajQXBwMObNmwfgzp1Lc+bMQVBQENRqNQICAmzurrp3yPqVK1fw6KOPwtXVFTqdDgMHDkRcXJx1+5w5c9CwYUOsWLECISEh0Ov1GDx4MNLS0gpsn2XLlsHNzQ2bNm1CREQEnJ2dMWDAAGRmZmL58uUICQmBu7s7pk2bBrPZbH2ewWDAzJkzUa1aNbi4uKBFixb4448/rNsTEhIwZMgQVKtWDc7OzoiKisL3339vc+wOHTpg2rRpeP755+Hh4QE/P79S3S1GRERUlkwmEy5dugSTyeToUIiqJPbrC+/Xm81mrFmzBn369MmzrXfv3rh9+zb27NljLVu+fDm6du0KHx+fwpr9vj7++GNMnjwZYWFh+W4/c+YMFi9ejJ9++gmPPPIIQkND0aRJE3Tp0qXAfZ45cwabN2/GV199hRYtWqBNmzZYtGgRVq1ahRs3bljr9enTB4cOHbJ5DSuyCjViQwhRLs8hIiIiupclKwsJS5ch5/IluA8fDueoqPKPwWAocJskSZBUKrvWlanVJYjyf06dOoW9e/ciODjYWjZv3jx89913+Pzzz1GzZk38+eefGD58OLy9vdG+fXtcv34d7dq1Q4cOHbBjxw7odDrs2bPH+qVGdHQ0Xn31VXzyySdo1KgRjh49ivHjx8PFxQWjRo3Cxx9/jI0bN+LHH39EUFAQrl69al1Dbe3atfjwww+xatUq1K1bF7GxsTh+/Hi+sVssFuvFz65du2AymTB58mQMGjTIJqFw8eJFbNiwAZs2bUJSUhIGDhyId955p9Ch3pmZmfj444+xatUqpKWl4bHHHkO/fv3g5uaGX3/9Ff/99x/69++P1q1bY9CgQQDurDF3+vRprFq1CgEBAVi/fj26d++OkydPombNmsjOzkaTJk3wwgsvQKfT4ZdffsGIESMQHh6O5s2bW4+9fPlyPPPMM/j777+xb98+jB49Gq1bty70QoeIiMgRYmJikJqaCpPJhBo1ajg6HKIqjf36vE6cOIGUlBQ0bdo0zzaVSoVhw4Zh6dKlaN26NYA7Nzi9++67eW4sevLJJ/Hdd98V2v53Twl1Pz///DPCwsKwadMmdO/eHUIIdO7cGe+++y48PDzyfc6+ffvg5uZmcy6dO3eGTCbD33//jX79+gG4MyuSr68v/vrrL4SHhxc5JkepUIkNIiIiIkfJuXQJaVu2wHjrFmSurg5JbFyfPqPAbZp69eA9ZbL18Y3nnofIycm3rrpmTfg8+4z18c2XX4Eln85y4OeLix3jpk2b4OrqCpPJBIPBAJlMhk8++QTAnVEHb7/9NrZv345WrVoBAMLCwrB7924sWbIE7du3x6effgq9Xo9Vq1ZBqVQCAGrVqmXd/2uvvYYFCxbgscceAwCEhobi9OnTWLJkCUaNGoUrV66gZs2aaNOmDSRJsrn4unLlCvz8/NC5c2colUoEBQXZfOl/t99//x0nT55ETEwMAgMDAQDffvst6tati4MHD6JZs2YA7lwoLVu2DFqtFsCdxQN///33QhMbRqMRixcvtl4MDBgwACtWrEBcXBxcXV1Rp04ddOzYETt37sSgQYNw5coVLF26FFeuXEFAQAAAYObMmdi8eTOWLl2Kt99+G9WqVcPMmTOtx5g6dSq2bNmCH3/80eYc69evj9deew0AULNmTXzyySf4/fffmdggIqIKp3r16oiJiUH16tUdHQqRXfVZtBu30gq+CamseGvV+HlqmyLXZ7++8H795cuXIZfLCxyBMXbsWLRt2xYfffQRDh8+jJSUFPTu3TtPYuP111+36ceX1n///YfLly9j9erV+Pbbb2E2m/H0009jwIAB2LFjR77PiY2NzXMeCoUCHh4e1qUgcgUEBODy5ct2i7csMbFBREREBEAZGATnli1hOH8e2vbtHR1OhdWxY0csXrwYGRkZ+PDDD6FQKNC/f38AwIULF5CZmZnnS/ScnBw0atQIAHDs2DG0bdvWevFzt4yMDFy8eBFPPPEExo8fby03mUzWObdHjx6NLl26ICIiAt27d0fv3r3RtWtXAMDjjz+OhQsXIiwsDN27d0fPnj3Rp08fKBR5u7xnzpxBYGCg9eIHAOrUqQM3NzecOXPGegEUEhJivfgBAH9/f8THxxfaRs7OzjZ3OPn6+iIkJMRmbl5fX1/rfk6ePAmz2WxzIQjcuaD09PQEcGco/Ntvv40ff/wR169fR05ODgwGA5ydnW2eU79+fZvHRYmXiIjIEZycnFC7dm1IkuToUIjs6laaAbGpFX8RbvbrC+8nZ2VlQa1WF/g7qkGDBqhZsybWrFmDnTt3YsSIEfnG5+PjU+rpqe5msVhgMBjw7bffWq8fvv76azRp0gRnz55FREREqfbv5OSEzMxMe4Ra5pjYICIiIgIgd3WB36wX71+xDFX7aGGB2+7tUAe8926R6/q/9Wap4rqbi4uLdbqIb775Bg0aNMDXX3+NJ554wjqE+pdffkG1atVsnqf+/2mvnJycCtx37vO//PJLtGjRwmabXC4HADRu3BgxMTH47bffsH37dgwcOBCdO3fGmjVrEBgYiLNnz2L79u3Ytm0bJk2ahPfeew+7du3K94KrKO59niRJsFgsxX5OYftJT0+HXC7H4cOHreeZKzcZ8t577+Gjjz7CwoULERUVBRcXF8yYMQM594zaKUm8RERE5SUuLg56vR4ajQZA3j4L0YPAW1u66V7L67js1xfeT/by8kJmZiZycnKgumua37uNHTsWn376KU6fPo0DBw7kW8feU1H5+/tDoVDY3BRVu3ZtAHdGuuSX2PDz88uTxDGZTEhMTISfn59NeWJiYrktzl5aTGwQERERVRDFWfOirOoWh0wmw0svvYRnnnkGQ4cORZ06daBWq3HlyhW0L2DUS/369bF8+XIYjcY8Fxe+vr4ICAjAf//9h2HDhhV4XJ1Oh0GDBmHQoEEYMGAAunfvjsTERHh4eMDJyQl9+vRBnz59MHnyZERGRuLkyZNo3LixzT5q165tncc39+6u06dPIzk5GXXq1CllyxRPo0aNYDabER8fj7Zt2+ZbZ8+ePXj00UcxfPhwAHfu1Dp37ly5x0pERFRSCQkJuHbtGmJjY1G3bt1872wmehAUZzqoioL9+rwaNmxo3Vfu/+81dOhQzJw5Ew0aNCjwWPaeiqp169YwmUy4ePGidZT4uXPnAMBmOq+7tWrVCsnJyTh8+DCaNGkCANixYwcsFotN4ik7OxsXL160jsqp6PhXhIiIiIhK7PHHH8dzzz2HTz/9FDNnzsTMmTPx9NNPw2KxoE2bNkhJScGePXug0+kwatQoTJkyBYsWLcLgwYMxa9Ys6PV67N+/H82bN0dERATmzp2LadOmQa/Xo3v37jAYDDh06BCSkpLwzDPP4IMPPoC/vz8aNWoEmUyG1atXw8/PD25ubli2bBnMZjNatGgBZ2dnfPfdd3Bycsq3g9+5c2dERUVh2LBhWLhwIUwmEyZNmoT27dvnu0BgWapVqxaGDRuGkSNHYsGCBWjUqBFu3bqF33//HfXr10evXr2sw9z37t0Ld3d3fPDBB4iLi2Nig4iIKg2dTgdnZ2e4ubkxqUFUAbFfb8vb2xuNGzfG7t27C0xsuLu74+bNm4WOIinuVFQXLlxAeno6YmNjkZWVhWPHjgG4M72WSqVC586d0bhxY4wdOxYLFy6ExWLB5MmT0aVLF+sojgMHDmDkyJH4/fffUa1aNdSuXRvdu3fH+PHj8fnnn8NoNGLKlCkYPHiwdY0/ANi/fz/UarV1XZWKTuboAIiIiIio8lIoFJgyZQreffddZGRk4I033sDs2bMxb948awf6l19+QWhoKADA09MTO3bsQHp6Otq3b48mTZrgyy+/tF4MjBs3Dl999RWWLl2KqKgotG/fHsuWLbM+X6vV4t1330XTpk3RrFkzXLp0Cb/++itkMhnc3Nzw5ZdfonXr1qhfvz62b9+On3/+2bpOxd0kScJPP/0Ed3d3tGvXDp07d0ZYWBh++OGH8mu8uyxduhQjR47Es88+i4iICPTt2xcHDx5EUFAQAOCVV15B48aN0a1bN3To0AF+fn7o27evQ2IlIiIqCaVSiYiICPj7+zs6FCLKB/v1eY0bNw7R0dGF1nFzc4OLi0upj3X3MRs1aoQlS5bg3LlzaNSoERo1aoQbN24AuDO65ueff4aXlxfatWuHXr16oXbt2li1apV1H5mZmTh79iyMRqO1LDo6GpGRkejUqRN69uyJNm3a4IsvvrA59vfff49hw4blWcevopKEEMLRQZSn1NRU6PV6pKSkQKfTOTocIiIiqkBETg6Sf/4ZppuxcBv4OJR2XOQtV3Z2NmJiYhAaGmqdX5rIkQp7T7LvzDYgIiqNrKwsGI1G/v6kBxL79Q++rKwsRERE4Icffqg0oxhK6vbt24iIiMChQ4esyafCVIRrCI79IyIiIsKdpEbmsWNIXrcexuvXYU5IgO+rs7moJREREVEJ5OTk4Pz58zCZTKhRowaTG0RU6Tg5OeHbb7/F7du3HR1Kmbt06RI+++yzIiU1KgomNoiIiKjKs2RnI27ePBguX4GkUkKh10Om1To6LCIiIqJKS6FQwNXVFVlZWZVmWhMiont16NDB0SGUi6ZNm5b7WoOlxcQGERERVXnZp88g8/ARmNPT4T5wIFzbtYOyWgBHaxARERGVkEwmQ2hoKMxmMxcLJyIiu+NfFiIiIqrylNUC4NyiBWAywm1A/zJZW4OIiIjoQSeEsM6tDtxZ1JdJDSIiKgv860JERERVntLXF36zXgRkMkgymaPDISIiIqqUrly5gtu3byMgIAD+/v6ODoeIiB5gTGwQERERAZB4NyERERFRqahUKgB3FtwlIiIqS7yCJyIiIiIiIiKiUvP394e7uzs0Go2jQyEiogcc51ogIiIiIiIiIqISyczMhBDC+phJDSIiKg9MbBAREVGVZ/jvP6Tt2AlTUpKjQyEiIiKqNNLT0/Hvv//iv//+g8VicXQ4RERUhTCxQURERFWasFiQvGYNklauRMbevY4Oh8rBsmXL4Obm5ugwiIiIKj2j0QgAEEJAkiQHR0NEVU159uvPnj0LPz8/pKWllcvxHGnw4MFYsGCBo8O4LyY2iIiIqErLuX4DhvPnYcnOgsLHx9HhVGijR4+GJEl5frp37+7o0Ipl0KBBOHfunKPDICIiqvTc3d0RERGBsLAwJjaIKhH264tv1qxZmDp1KrRaLQDgjz/+gCRJcHd3R3Z2tk3dgwcPWtu0pP7880/06dMHAQEBkCQJGzZsyFNn3bp16Nq1Kzw9PSFJEo4dO3bf/f7zzz/o378/QkJCIEkSFi5cmKfOK6+8grfeegspKSkljr88MLFBREREVVrG3j0wJSVD4esHdY0ajg6nwuvevTtu3rxp8/P99987OqxicXJygg+TWERERCViMplgNputj11cXCCT8eslosqG/fqiu3LlCjZt2oTRo0fn2abVarF+/Xqbsq+//hpBQUGlOmZGRgYaNGiATz/9tNA6bdq0wfz584u838zMTISFheGdd96Bn59fvnXq1auH8PBwfPfdd8WOuzzxLw8RERFVWca4OKRt2QpLZgZU4eGQc3qi+1Kr1fDz87P5cXd3B3DnriWVSoW//vrLWv/dd9+Fj48P4uLiAAAdOnTAlClTMGXKFOj1enh5eWH27Nk2i46uWLECTZs2hVarhZ+fH4YOHYr4+Hjr9ty7o37//Xc0bdoUzs7OeOihh3D27FlrnePHj6Njx47QarXQ6XRo0qQJDh06BCD/IeuLFy9GeHg4VCoVIiIisGLFCpvtkiThq6++Qr9+/eDs7IyaNWti48aNhbZVSEgI3nzzTYwcORKurq4IDg7Gxo0bcevWLTz66KNwdXVF/fr1rXHl2r17N9q2bQsnJycEBgZi2rRpyMjIsGv7EBERlYTFYsHFixdx7tw56zRURFQ5sV9f9H79jz/+iAYNGqBatWp5to0aNQrffPON9XFWVhZWrVqFUaNGFbrP++nRowfefPNN9OvXr8A6I0aMwKuvvorOnTsXeb/NmjXDe++9h8GDB0OtVhdYr0+fPli1alWxYi5vTGwQERFRlZV1/DiMN29Ckivg+lArh0+hkG00F/iTY7LYva69dejQATNmzMCIESOQkpKCo0ePYvbs2fjqq6/g6+trrbd8+XIoFAocOHAAH330ET744AN89dVX1u1GoxFvvPEGjh8/jg0bNuDSpUv53h318ssvY8GCBTh06BAUCgXGjh1r3TZs2DBUr14dBw8exOHDh/Hiiy9CqVTmG/f69esxffp0PPvsszh16hQmTpyIMWPGYOfOnTb15s6di4EDB+LEiRPo2bMnhg0bhsTExELb5MMPP0Tr1q1x9OhR9OrVCyNGjMDIkSMxfPhwHDlyBOHh4Rg5cqT1AvDixYvo3r07+vfvjxMnTuCHH37A7t27MWXKFLu2DxERUUnk5OQgOzsbBoMBJpPJ0eEQURlhv97WX3/9haZNm+a7bcSIEfjrr79w5coVAMDatWsREhKCxo0b29S7cuUKXF1dC/15++23C4yhvDVv3hwHDhyAwWBwdCgFksTdabQqIDU1FXq9HikpKdDpdI4Oh4iIiBwo69Q/SFqzGqpq1eH5xFhI5TCNQnZ2NmJiYhAaGgqNRmOz7YllBwt8XlR1PWZ0rmV9/NR3h/MkMHLV8tPihe6R1sfTVx1FenbeLx++Ht2sWLGPHj0a3333XZ64X3rpJbz00ksA7nzh0aJFC9SqVQunTp1C69at8cUXX1jrdujQAfHx8fjnn3+siaQXX3wRGzduxOnTp/M97qFDh9CsWTOkpaXB1dUVf/zxBzp27Ijt27ejU6dOAIBff/0VvXr1QlZWFjQaDXQ6HRYtWpTvnVLLli3DjBkzkJycDABo3bo16tataxPnwIEDkZGRgV9++QXAnTu7XnnlFbzxxhsA7gz7dnV1xW+//VbgXMQhISFo27at9S6x2NhY+Pv7Y/bs2Xj99dcBAPv370erVq1w8+ZN+Pn5Ydy4cZDL5ViyZIl1P7t370b79u2RkZGRp+1L2j53K+w9yb4z24CI6F4GgwFGoxGurq6ODoXIoQrsQy1pD6THF/zEsuLqA0zcVaSq7NcXr1/fsGFD9O/fH7Nnz7aW5caelJSEMWPGoFGjRnj11Vfx8MMPo2/fvggKCkK/fv2sNzCZTCZcunQp/xfk/3l4eMDDwyNPuSRJWL9+Pfr27Zvv8y5duoTQ0FAcPXoUDRs2LPQYdwsJCcGMGTMwY8aMPNtOnDiBBg0a4NKlSwgODs6zvSJcQyjKbM9EREREFZgQAkpfH/g+/TRkrq7lktR4EHTs2BGLFy+2Kbu7861SqRAdHY369esjODgYH374YZ59tGzZ0mZ0TKtWrbBgwQKYzWbI5XIcPnwYc+bMwfHjx5GUlASL5U4C58qVK6hTp471efXr17f+39/fHwAQHx+PoKAgPPPMMxg3bhxWrFiBzp074/HHH0d4eHi+53TmzBlMmDDBpqx169b46KOPbMruPp6Liwt0Op3NUPr83P2c3LvboqKi8pTFx8fDz88Px48fx4kTJxAdHW2tI4SAxWJBTEwMateubZf2ISIiKo7cv9HAnelrCpu+hKjKS48H0m44Oor7Yr/+jqL06/O7OehuY8eOxfTp0zF8+HDs27cPq1evtpnGCwAUCgVqVKI1HZ2cnADcWZOjomJig4iIiKqk9N27kbZ5MzS1a8Nj+HBHhwMA+HRY4wK3ye6ZJuvDQQ2LXHd+//oF1Cw+FxeX+3bI9+7dCwBITExEYmIiXFxcirz/jIwMdOvWDd26dUN0dDS8vb1x5coVdOvWDTk5OTZ17x6CnntBlXuxNGfOHAwdOhS//PILfvvtN7z22mtYtWpVoXPU3s+9Q94lSbIeryjPyY2xsLjT09MxceJETJs2Lc++goKC7NY+RERERXX79m3cuHEDNWrUgLOzs6PDIar4XMt+MWt7HJf9+v+5X7/ey8sLSUlJBW7v0aMHJkyYgCeeeAJ9+vSBp6dnnjr3JnPyc/eIGUfLnZrL29vbwZEUjIkNIiIiqpJM12/AGBsHhZc3hBAOX18DADRKucPrltbFixfx9NNP48svv8QPP/yAUaNGYfv27ZDdNSLm77//tnnO/v37UbNmTcjlcvz7779ISEjAO++8g8DAQADIs7h2UdWqVQu1atXC008/jSFDhmDp0qX5XgDVrl0be/bssRnevmfPnvteeJSFxo0b4/Tp0wVeZJ48edJu7UNERHQ/QgjcunULRqMRKSkpTGwQFUURp4Oq6Niv/59GjRoVOL0WcGc0xsiRI/Huu+/it99+y7dOQEAAjh07Vuhx8puGylFOnTqF6tWrw8vLy9GhFIiJDSIiIqpyTElJyD53DpJKBde2bSpEUqOyMBgMiI2NtSlTKBTw8vKC2WzG8OHD0a1bN4wZMwbdu3dHVFQUFixYgOeee85a/8qVK3jmmWcwceJEHDlyBIsWLcKCBQsA3BmVoFKpsGjRIjz55JM4deqUdf7bosrKysJzzz2HAQMGIDQ0FNeuXcPBgwfRv3//fOs/99xzGDhwIBo1aoTOnTvj559/xrp167B9+/Zitk7pvfDCC2jZsiWmTJmCcePGwcXFBadPn8a2bdvwySef2KV9iIiIikqSJNSqVQu3b9+2WTCYiCo/9uuLrlu3bhg3bpzNtHz3euONN/Dcc8/lO1oDKP5UVOnp6bhw4YL1cUxMDI4dOwYPDw/r1LKJiYm4cuUKbty4M/XZ2bNnAQB+fn7w8/MDAIwcORLVqlXDvHnzANxZOyU3SZOTk4Pr16/j2LFjcHV1tYnvr7/+QteuXYscryMwsUFERERVjsjOhjAaIddpIctnOLXJbIHJIsp1pENlsXnzZuu8t7kiIiLw77//4q233sLly5exadMmAHfmx/3iiy8wZMgQdO3aFQ0aNABwp3OdlZWF5s2bQy6XY/r06da5cL29vbFs2TK89NJL+Pjjj9G4cWO8//77eOSRR4oco1wuR0JCAkaOHIm4uDh4eXnhsccew9y5c/Ot37dvX3z00Ud4//33MX36dISGhmLp0qXo0KFDCVqodOrXr49du3bh5ZdfRtu2bSGEQHh4OAYNGgTAPu1DRER0P3ePZpXL5UxqED2A2K8vuh49ekChUGD79u3o1q1bvnVUKpVdRzccOnQIHTt2tD5+5plnAACjRo3CsmXLAAAbN27EmDFjrHUGDx4MAHjttdcwZ84cAHeST3ePsrlx4wYaNWpkffz+++/j/fffR/v27fHHH38AuLMw+IYNG7B582a7nU9ZkETu0uxVRHmtyk5EREQVW/bZcxA5Bmjq1rVZODzbaMbXu2OQkG7AyFYhCPEq+jyyRTpudjZiYmIQGhpa6AJ0D6oOHTqgYcOGWLhwoaNDof9X2HuSfWe2ARFVPTk5OTh//jyqVasGNzc3R4dDVGGxX1+1+vWffvopNm7ciC1btjg6lDK3ePFirF+/Hlu3bi2wTkW4hpDdvwoRERHRg0cTUQsyF1dknzgBYTJZy9MNJlxNzMT15CzcSMlyYIRERERE5S8+Ph7Z2dm4fv06qti9sEREBZo4cSLatWuHtLQ0R4dS5pRKJRYtWuToMO6LU1ERERFRlWROTkbiihUwp6TAY9hQODdpAgDwdFHh8aaBSMnKQaNAdwdHSURERFS+qlWrBuDONDJch4yI6A6FQoGXX37Z0WGUi3Hjxjk6hCJhYoOIiIiqJEmlgszVFTCb7/ybWy5JaBLMhEZZyZ23lYiIiComSZJQvXp1R4dBRBUc+/XkaExsEBERUZUkc3aG18QJEFlZUHh7OzocIiIiIoe5evUqlEol/Pz8HB0KERFRkTCxQURERFWW3NUVuGu0BhEREVFVk5aWhvj4eACATqeDs7OzgyMiIiK6PyY2iIiIqMoxnD+PjL8PwLlxI2jq1HFIDBaLxSHHJboXF4YlIqratFotAgMDAYBJDSIiqjSY2CAiIqIqJ333HqTt2AFzakq5JzZUKhVkMhlu3LgBb29vqFQqLsxJDiOEwK1btyBJEpRKpaPDISIiB/Hx8XF0CERERMXCxAYRERFVOc6NG8GckgKXZs3K/dgymQyhoaG4efMmbty4Ue7HJ7pX7iKxcrnc0aEQEVE5ycjIwO3btxEUFMQbLIiIqFJiYoOIiIiqHKcGDeDUoIHDjq9SqRAUFASTyQSz2eywOIgAQKlUMqlBRFSFWCwWXLx4EUajEUqlEgEBAY4OiYiIqNiY2CAiIiJygNypfzj9DxEREZUnmUyG4OBgxMXFwdfX19HhEFEVERISghkzZmDGjBkA7lwPrV+/Hn379nVoXFR5yRwdwN3mzZuHZs2aQavVwsfHB3379sXZs2et2xMTEzF16lRERETAyckJQUFBmDZtGlJSUhwYNRERERERERFR5aHX61GrVi2O2CMivPPOO5AkyZpwyNWhQwdIkmTz8+STT9rU2bhxI2rVqoWIiAhs2rSpWMe9efMmevToUdrwqQqrUCM2du3ahcmTJ6NZs2YwmUx46aWX0LVrV5w+fRouLi64ceMGbty4gffffx916tTB5cuX8eSTT+LGjRtYs2aNo8MnIiIiIiIiIqpwLBYLrl+/Dn9/fygUFeqrICJyoIMHD2LJkiWoX79+vtvHjx+P119/3frY2dnZ+n+DwYDJkydj6dKlEEJg7Nix6Nq1K1QqVZGO7efnV7rgqcqrUCM2Nm/ejNGjR6Nu3bpo0KABli1bhitXruDw4cMAgHr16mHt2rXo06cPwsPD8fDDD+Ott97Czz//DJPJ5ODoiYiIiIiIiIgqnqtXryI+Ph7nz593dChEVEGkp6dj2LBh+PLLL+Hu7p5vHWdnZ/j5+Vl/dDqddZvBYIBcLkfDhg3RqFEjKBQKGAyGIh9fkiRs2LABAHDp0iVIkoR169ahY8eOcHZ2RoMGDbBv3z6b5+zevRtt27aFk5MTAgMDMW3aNGRkZBT/5OmBUKESG/fKnWLKw8Oj0Do6nY53HBARERERERER5cPX1xdqtRrVqlVzdChEVYLFYoHFYrEpE0LkW55bJoQocd2SmDx5Mnr16oXOnTsXWCc6OhpeXl6oV68eZs2ahczMTOs2nU6HMWPGwN/fHwEBAXjqqaeg1WpLFEuul19+GTNnzsSxY8dQq1YtDBkyxHoz+8WLF9G9e3f0798fJ06cwA8//IDdu3djypQppTomVV4VNhtgsVgwY8YMtG7dGvXq1cu3zu3bt/HGG29gwoQJBe7HYDDYZAtTU1PtHisRERFVHpaMDCRv2ADIZHDr2xcyJydHh0RERERUpjQaDerWrQtJkhwdClGVcPToUQBAgwYNrDdjx8bG4saNG/Dy8kJwcLC17vHjx2GxWFCvXj2o1WoAQHx8PK5duwYPDw+EhoZa6548eRImkwl16tSB0/9fxyQkJMDLy6tY8a1atQpHjhzBwYMHC6wzdOhQBAcHIyAgACdOnMALL7yAs2fPYt26ddY6r732GmbMmAGZTFbqpAYAzJw5E7169QIAzJ07F3Xr1sWFCxcQGRmJefPmYdiwYda1QGrWrImPP/4Y7du3x+LFi6HRaEp9fKpcKmxiY/LkyTh16hR2796d7/bU1FT06tULderUwZw5cwrcz7x58zB37twyipKIiIgqm5wrV5B58BAgk8G5SRNoatVydEhEREREdpeUlASNRmP98pNJDSIC7kxNN336dGzbtq3QZMDdN5JHRUXB398fnTp1wsWLFxEeHm7dptfr7Rbb3Wt9+Pv7A7iT5ImMjMTx48dx4sQJREdHW+vkjmyJiYlB7dq17RYHVQ4VMrExZcoUbNq0CX/++SeqV6+eZ3taWhq6d+8OrVaL9evXQ6lUFrivWbNm4ZlnnrE+Tk1NRWBgYJnETURERBWfKiQELm3aQJIAVVCQo8MhIiIisru0tDTExMRAJpOhdu3a1rvAiah8NGrUCAAgk/1vFQA/Pz/4+vrmqdugQQMAtslHHx8feHt756kbFRWVp66np2exYjt8+DDi4+PRuHFja5nZbMaff/6JTz75xLp2xr1atGgBALhw4YJNYsOe7v6ON/ccc6fjSk9Px8SJEzFt2rQ8zwvidV2VVKESG0IITJ06FevXr8cff/xhM9QqV2pqKrp16wa1Wo2NGzfed5iRWq3mH3AiIiKykjk5wX1Af0eHQURERFRmnJyc4OzsDLVaDZVK5ehwiKqcuxMauSRJynfklD3qFkenTp1w8uRJm7IxY8YgMjISL7zwQr5JDQA4duwYgP+NpChvjRs3xunTp1GjRg2HHJ8qngqV2Jg8eTJWrlyJn376CVqtFrGxsQDuDGlycnJCamoqunbtiszMTHz33XdITU21rpnh7e1d4AePiIiIiIiIiKiqUCgUqFWrVoFfjhJR1aXVavOsZ+zi4gJPT09r+cWLF7Fy5Ur07NkTnp6eOHHiBJ5++mm0a9fOZrqo8vTCCy+gZcuWmDJlCsaNGwcXFxecPn0a27ZtwyeffOKQmMixKlRiY/HixQCADh062JQvXboUo0ePxpEjR/D3338DQJ7sXExMDEJCQsojTCIiIiIiIiKiCsVoNCIrKws6nQ5A/nd2ExEVhUqlwvbt27Fw4UJkZGQgMDAQ/fv3xyuvvOKwmOrXr49du3bh5ZdfRtu2bSGEQHh4OAYNGuSwmMixJCGEcHQQ5Sk1NRV6vR4pKSnWP/ZERERERJQX+85sAyKqHMxmM86dO4esrCyEhobC3d3d0SERPfCys7MRExOD0NDQ+06VT/SgKez9X179Z6bviYiIiIiIiIgqMZlMBo1GA7lcDicnJ0eHQ0REVOYq1FRURERERERERERUPJIkISQkBEajkYuFExFRlcARG0RERACM168j4ZtvkLbzD1SxWRqrJJGT4+gQiIiIiEotPT3d+n9JkpjUICKiKoOJDSIiIgBZ//yD9N27kb5rF0R2tqPDoTKUum0bYt+Zj4y/DxRaz2S2MMlFREREFVZcXBzOnj2La9euOToUIiKicsfEBhERVXnCYoHp9m3InJzh1LgRJC789kAz/Psvcv77D4YLFwqs829sKt7+9QxWHbzC5AYRERFVSLl9FIWCs4wTEVHVw79+RERU5ZkTEpB96h8IsxlKLy9IkuTokKiMmBITYc7IgLJ6Nbi0aV1gvUu3M3E+Ph1Gs4DBZIFGKS/HKImIiIjuz8/PD1qtFi4uLo4OhahKs1gsjg6BqNxVhPc9ExtERFTlSRoNFD4+UPj4QF2zpqPDoTKUc+kSjNeuQebiCklecDeoeagHjGYLAj2cmdQgIiKiCsNgMEClUllvxGFSg8hxVCoVZDIZbty4AW9vb5vPJtGDSgiBnJwc3Lp1CzKZzKFrOzGxQUREVV76n3/CcPEC1DVrQe7l5ehwqAypa9WCtkNHyFxdoPTzLbCeh4sKfRoElGNkdwghkLJhA3IuXYLbY49BFRxc7jEQERFRxWQwGPDvv//CxcUFYWFhkMk4uziRI8lkMoSGhuLmzZu4ceOGo8MhKlfOzs4ICgpy6N8iJjaIiKjKkzm7QObsArmrq6NDoTImd3WF24D+jg6jQJaMTGQeOgxjbCycGjRgYoOIiIissrOzYTabkZOTwzXAiCoIlUqFoKAgmEwmmM1mR4dDVC7kcjkUCoXDRygxsUFERFWea7u2UNesCYWXp8P/MFPVlhPzH0yJiZDrdNBERTk6nCon+9w5WFJT4dSgASSl0tHhkJ2YzWbMmTMH3333HWJjYxEQEIDRo0fjlVde4e98IqpU9Ho9atWqBbVaDbmcU2USVRSSJEGpVELJ/iNRuWJig4iIqjxJLoeqejVHh0EEU1wcYLFA4eUFuV7v6HCqFFNSEpJWfg9zSgo8ADg3berokMhO5s+fj8WLF2P58uWoW7cuDh06hDFjxkCv12PatGmODo+IqFBCCFgsFmsiw5UjjImIiAAwsUFERERUYagiIqDt2gVOUVGQOXARtqpIplZD7uYGAEwqPWD27t2LRx99FL169QIAhISE4Pvvv8eBAwccHBkR0f1dvnwZmZmZqFGjhkMXaCUiIqpomNggIiIiqgDM6RlIXvk9zKkp0EREOjqcKkfm7AyviRNgyc6Gwt3d0eGQHT300EP44osvcO7cOdSqVQvHjx/H7t278cEHH+Rb32AwwGAwWB+npqaWV6hERDZycnKQmpoKo9GIrKwsJjaIiIjuwsQGERERVSlCiAo5r74wm2DJyIDIMUIYcxwdTpUkc3KCzMnJ0WGQnb344otITU1FZGQk5HI5zGYz3nrrLQwbNizf+vPmzcPcuXPLOUoiorxUKhUiIiKQmZkJPUcTEhER2ZA5OgAiIiKismRKSkL6rl3IuXoVKb/+ivh330X2mTOODisPw5l/YcnIgDKwOpwaNHB0OEQPjB9//BHR0dFYuXIljhw5guXLl+P999/H8uXL860/a9YspKSkWH+uXr1azhETUVVnsVis/1er1XDnSEIiIqI8OGKDiIiqPHN6OoTRyOlnHlDpu3Yh9ddfoapVCzDkwHD+PNS1a0NTu7ajQ7NhjL0Jc2oqFEYjUAFHlBBVVs899xxefPFFDB48GAAQFRWFy5cvY968eRg1alSe+mq1Gmq1urzDJCICAKSlpeHSpUsICwuDi4uLo8MhIiKqsJjYICKiKs2cnIzbS76AxZANz9GjoQoKcnRIZEeWrCxkHTsOU0IinD084NKsGQznL8CleXNHh5aHa/v2kLu5QR0WViGnyiKqrDIzMyGT2Q5Ul8vlNndEExFVFDdv3kROTg7i4+MRGhrq6HCIiIgqLCY2iIioSrNkZcGcngaRbYA5Lc3R4ZCdmeLjYc5Ih9zLC04NGsApKgpOUVGODitfCnd3aDt0cHQYRA+cPn364K233kJQUBDq1q2Lo0eP4oMPPsDYsWMdHRoRUR7h4eG4efMmAgICHB0KERFRhSYJIYSjgyhPqamp0Ov1SElJgU6nc3Q4RETkYEIIGM6ehcjOhiYqCpJc7uiQyI6EyYTUbduRvnMHhNEEp4YNoH/kEU47RnmY0zNgOHMayqBgKH19HB1OhfEg9J3T0tIwe/ZsrF+/HvHx8QgICMCQIUPw6quvQqVS3ff5D0IbEBERERGVl/LqP3PEBhERVWmSJEETGenoMKisyOXQREYg/Y8/kHX8OHKuXoUqMBDahx92dGRUwaTv3IHU3zZDHRkJn2lTHR0O2ZFWq8XChQuxcOFCR4dCRJSHxWLB+fPn4ePjw0XCiYiIiqFUiQ2j0YjY2FhkZmbC29sbHh4e9oqLiIiIqNTSd+5E6s6dkPv5wqlZU8hdXKEK4XzVlJdMq4Vcr4PCTe/oUIiIqAq5desW0tPTkZ2dDZ1OBzlHDxMRERVJsRMbaWlp+O6777Bq1SocOHAAOTk5EEJAkiRUr14dXbt2xYQJE9CsWbOyiJeIiIioyIzXrsN8MxYymQwypQoynRYKP19Hh0UVjCU7G4aYS5B7eMC1WzdHh0NERFWIj48PcnJy4O7uzqQGERFRMciKU/mDDz5ASEgIli5dis6dO2PDhg04duwYzp07h3379uG1116DyWRC165d0b17d5w/f76s4iYiIrIrIQT+OBuPb/ddQlxqtqPDITvRdusG92FD4RQVhZxr15C+8w8kfPkVLDk5jg7NhrBYkL57D9J27IDFYHB0OFWOKS4OhtOnkXP1KsyxsY4Oh4iIqhBJkhAYGAhXV1dHh0JERFSpFGvExsGDB/Hnn3+ibt26+W5v3rw5xo4di88//xxLly7FX3/9hZo1a9olUCIiorKUmWPGttNxuJKYCT+dBl3r+jk6JLIDpa8PlL4+sGRlwZyejow9e2BOToLIzgaKsGhweTFeu4aUnzdCZGdD4eUFp/r1HR1SlaKsVg3aLl0gsrOhZt+ViIjK2K1bt2A0GhEQEODoUIiIiCqtYiU2vv/++yLVU6vVePLJJ0sUEBERUXmzZGXBSa1GyzAP+Oo0qO2vc3RIZGcyJye4DxkCTWRtyD3cIdfd/zXONpqRYTDB01Vd5vEpPD2hDg2FJSsLyTpPfL87Bn46DbrX84NMJpX58as6SaGArmsXR4dBRERVQHZ2Nq5cuQIAcHZ2hpubm2MDIiIiqqRKtXg4ERFRZZf2119I/30HXB5qhT5duzo6HCpDMrUaLi1bFKmuyWzBV3/F4HpyJgY1C0LDQLcyjU0YjdA0aAh1eBj2Jkv46/x1+GjVaBHmUS6JFbpDCIHkTCNc1AqoFMWasZWIiKhINBoNgoKCkJWVxaQGERFRKZQ4sZGVlQUhBJydnQEAly9fxvr161GnTh105RdDRERUSRhjLiHnyhUouaA03cVoFkjIMCAxIwdJGWW/HkfKr78iY/duODdtitoDhuKhcE/46TVwd64402VVBUeuJGPN4asI9nTBhLZhHC1DRERlwtvb29EhEBERVXolTmw8+uijeOyxx/Dkk08iOTkZLVq0gFKpxO3bt/HBBx/gqaeesmecREREZULbpTMUfr7Q1K7t6FDIzixZWTDevAlV9eqQirmehpNKjhEtgxGbmo3GQe5lFOH/yN3cINfrIXdzg6dOg/Htwsv8mJRXQroBt9IMcFLKYbRYoJbJHR0SERE9AHJychAbG4vq1atDJuOIQCIiInsocWLjyJEj+PDDDwEAa9asga+vL44ePYq1a9fi1VdfZWKDiIgqBaW/P5T+/o4Og8pA8pq1yDp+DK7tO0Dfp3exnx/m7Yowb9cyiCwvXbducG7cGAovr3I5HuWvdQ0vOKsUCHDTQK1gUoOIiEpPCIGLFy8iMzMTQggEBwc7OiQiIqIHQolvFcjMzIRWqwUAbN26FY899hhkMhlatmyJy5cv2y1AIiIiopKw5Bhgup2AnMuXIIRwdDiFkuRyKP38ICm4/JkjmJKSkLFvH9RpyWhT06tUCa2sf/5B3HvvIfX33+0YIRERVVaSJKFatWrQaDTw5800REREdlPixEaNGjWwYcMGXL16FVu2bLGuqxEfHw+dTme3AImIiIhKQlO3LiSlEjlXr8LImy6oEKm//oqE5d8i+aeNpd6X4d9/kX3qH2QdOmyHyIiI6EGg0+lQp04dqIo5NSYREREVrMSJjVdffRUzZ85ESEgImjdvjlatWgG4M3qjUaNGdguQiIiIqLhyrl5F6k8bYU5MhMzJGZKzs6NDogpM7uEJhYcHlF6epd6XKiwMLq1aQduzhx0iIyKiyio2NhZGo9H6WJIkB0ZDRET04CnxfAcDBgxAmzZtcPPmTTRs2NBa3qlTJ/Tr188esRERERGViDkxERaDAcqwMLgPHQKlj4+jQ6IKTNulM5wbNyr1GiemW7eQ8vPPEDlGaJ2c7BQdERFVNrGxsbh+/Tpu376NOnXqcMFwIiKiMlCqv67nz5/HggUL0Lp1a1y/fh0AcPbsWdy+fdsuwREREVVmQghYMjIq/PoODyJNnTpwHzQIniNHQF2zpqPDoQrMnJyMhMWfI3nNWlgyM0u1LyEEcPcPERFVSW5ublCpVPD19WVSg4iIqIyU+C/s2rVr0a1bNzg5OeHIkSMwGAwAgJSUFLz99tt2C5CIiKisCCFgiIlBzqVLZbL/1N9+Q9x77yFjz54y2T8VTFIq4dKiOZyioirF1A+mxESYkpIcHUaVZIyNhSHmPxj++w+muLhS7Uvp4wOvcePgOe4JqGrUsFOERERU2Wg0GtSpUwfe3t6ODoWIiOiBVeLExptvvonPP/8cX375JZRKpbW8devWOHLkiF2CIyIiKkvGK1eQ8M03uP31N8i5etXu+8+JiUHO1WvIuXLF7vumB4fx5k3c/vQz3P70Mxjj4h0dTpWjDguDrndv6Hv1giokpFT7MsbGIvvMGchUqkqRUCMiIvvJyMhAVlaW9bFcLndgNERERA++Eq+xcfbsWbRr1y5PuV6vR3JycmliIiIiKh9yOSS5HID0///al/6RR6CJiIAmqr7d900FE0LAFH8LMhcXyF1dHB3OfVmysmDJygQkCSI76/5PILuSVCroHn7YLvtK27IFaX/+BZcWzeE1YYJd9klERBVfdnY2zp8/DwCoVasWnJ2dHRwRERHRg6/EiQ0/Pz9cuHABIffc2bZ7926EhYWVNi4iIqIyJ6lUcG7WDOqaNaEMCLD7/lWBgVAFBtp9v1S47H9OI+mHH6DwcIfXU09BptE4OqRCqUJD4TFiBCCTQRkU5OhwKB9CCJhu3oTczQ2yQr6sUgYFQ1U9Bqrg4HKMjoiIHE2hUMDJyQlCCGgqeL+DiIjoQVHixMb48eMxffp0fPPNN5AkCTdu3MC+ffswc+ZMzJ49254xEhER2ZUpKQlp27cj89BhmFNSoO3YAZpatex6DGE2I+vECcicnaGJiLDrvqlwlowMmJMSYcnIgCUzs8InNiRJgqZ2bUeHQYXIPHAQKT9tgKp6IDwnTsh3hJcwGiEg4NL6Ibh27OiAKImIyFEUCgVq1qwJi8XCxcKJiIjKSYn/4r744osYOnQoOnXqhPT0dLRr1w7jxo3DxIkTMXXq1BLtc968eWjWrBm0Wi18fHzQt29fnD171qZOdnY2Jk+eDE9PT7i6uqJ///6IK+VCj0REVHUIiwVpv+9Aym+bkXP58p3pijw87X6c7NOnkRS9EonR0TDy71S5cmrYAHI3d1gyMpB59Kijw6EHgCUrE5b0DJgz0gGzOd86hosXkfrzJqRt3Qbj5cvlHCEREZU3i8WCtLQ062OZTAaFosT3jhIREVExlTixIUkSXn75ZSQmJuLUqVPYv38/bt26hTfeeKPEwezatQuTJ0/G/v37sW3bNhiNRnTt2hUZGRnWOk8//TR+/vlnrF69Grt27cKNGzfw2GOPlfiYRERUtWT+/TdSd+6E8do1QCGHrns3aDvZZ379u8m1Wsi0Wsi1OsicnOy+fyqYpFJB6e8PmasLwAWcyQ5cWrWCx5jR8Bg+HJJKlW8dha8vVMFBUAUHQ+HtXc4REhFReRJC4NKlSzh37hwSEhIcHQ4REVGVVOrbCVQqFerUqWOPWLB582abx8uWLYOPjw8OHz6Mdu3aISUlBV9//TVWrlyJh/9/kcelS5eidu3a2L9/P1q2bGmXOIiI6MFlyTHCdOMGLOnpsDg5wXjjJqQymDJAFRIC72lTISlVlWIB6weFEAIpG36COT0dbo88ApeHHnJ0SPQAkKnVcG7UqNA6Cnd3eE+ZAgD5TlVFREQPFplMBkmSoCog4U1ERERlq8Tf5MybNw/ffPNNnvJvvvkG8+fPL1VQuVJSUgAAHh4eAIDDhw/DaDSic+fO1jqRkZEICgrCvn378t2HwWBAamqqzQ8REVVdzg0bQB0cBIWXFyAEss/+C9Pt22VyLIW7O5Ma5cySkYms48eQc/4chMkESaks8b7SDSZsPhWLQ5cSIYSwY5RUkQizGaaEBLu8xpJczqQGEVEVIEkSQkJCULt2bWi1WkeHQ0REVCWVOLGxZMkSREZG5imvW7cuPv/881IFBdyZr3LGjBlo3bo16tWrBwCIjY2FSqWCm5ubTV1fX1/Exsbmu5958+ZBr9dbfwIDA0sdGxERVV5yvR6eTzwBt8f6QVM7EnIXV4BfRD4w5K4u0HXvDl237nBq0KBU+zp6JQmrD13F2iPXkJxptFOEVNEk//QT4j/4EOk7dzo6FCIiquCysrJsHjtxulEiIiKHKfFUVLGxsfD3989T7u3tjZs3b5YqKACYPHkyTp06hd27d5dqP7NmzcIzzzxjfZyamsrkBhFRFecUFQVNvXowXr8OmVoNhbu7o0MiO3Jp2RKww+yU1d2dEerlAl+dBq6aslsM1JyWBuPVq1CFhnI9Fgcwx8XBdPt2mY3cIiKiB0NKSgouXLgAHx8fVK9eHRLX8SIiInKoEl+lBwYGYs+ePQgNDbUp37NnDwICAkoV1JQpU7Bp0yb8+eefqF69urXcz88POTk5SE5Othm1ERcXBz8/v3z3pVaroVarSxUPERE9eCRJguquvzEAkJZtxO7zt+HhokLzUI9SX7DmmCzYeTYeEoCOkT5Qyu2/lgeVnVAvF7zQIxJySYJMVnZfXiSvWYusY8fg2qED3Pr1LbPjUP70jz0GTf360JRyzTjjzZuQNBomSomIHlAGgwEAYDabmdQgIiKqAEqc2Bg/fjxmzJgBo9FoXcj7999/x/PPP49nn322RPsUQmDq1KlYv349/vjjjzxJkyZNmkCpVOL3339H//79AQBnz57FlStX0KpVq5KeChEREQDg2NVkrDl8Dd5aNWr6auHhUrrFIC/Ep+Pn4zcgk4AQLxfU8uUczJVNeSSjJLkcUMghKWy7ZUIIfnFSxiwZGcg8eBAyV1fI9foS78dw/jwSvl0BmbMTvJ96CvJ7pk0lIqLKz8fHBxqNhmtqEBERVRAlTmw899xzSEhIwKRJk5CTkwMA0Gg0eOGFFzBr1qwS7XPy5MlYuXIlfvrpJ2i1Wuu6GXq9Hk5OTtDr9XjiiSfwzDPPwMPDAzqdDlOnTkWrVq3QsqUd5pwgIqIqLcjDGWHeLvDTaaAt5dRDxrg4uF++ghruzpCrVPDTa+wUJT1o3Ab0h8tDraAMCrKW/Xz8Oo5fS0G/RtVQN6DkX7hT4bLPnkXq5s2QuWqhqVkTymrVSrQfiyEH5uRkmGJjYYyPx+l0CUmZOWge6gGNkmv4EBFVViaTCXK53HqjgU6nc3BERERElKvE39pIkoT58+dj9uzZOHPmDJycnFCzZs1STfu0ePFiAECHDh1sypcuXYrRo0cDAD788EPIZDL0798fBoMB3bp1w2effVbiYxIRUdUihACAfO+ED/Z0wQvdIyGXSaW6U15YLEhauRKmixcxumdP6B/uwTvvqUAyZ2eoa9SwPjZbBI5cTsbZuDTU9dcxsVGGVIGBUNeKgFyrhdzLCwAQn5qN+DQDIv20UMhlEEIg+8QJmFNS4Ny8OWSavElKTZ3aUHh5wnD+PK4fOIqVzrWRnGmESiFDyzDP8j4tIiKyA7PZjHPnzkGpVCIsLAxyORPVREREFUmJEhtGoxHdu3fH559/jpo1a6JZs2Z2CSb3y6bCaDQafPrpp/j000/tckwiIqo6hNGIpO9XwXT7NtwHD4IynzWhFPaYekiSINPpIddqodDqmNSgYpHLJPRtVA0X4tPRKtzL0eE80BTe3vCeOsX6Gc02mvHlX/8hLjUbA5sGoU1NL5gTE5G0Zi3Op5iQlSxD224t4aK+04UWQsAUHw+5Xg/nRo0AswWK6v7wM2mgksvgreU6b0RElVVWVhYMBgOMRqN15AYRERFVHCVKbCiVSpw4ccLesRAREZUpc0oKss+ehSkxATmXL+eb2LAHSZLgMXwYzAkJUPj5lckx6MHWINANDQLdHB1GlXB34lEmSVApZFDKZVDI75TLXF1h9q+Gn6FG4nUzVDEJeDjSFwCQdegQkjdsgCowEB7jxsG1Y0fIXF3xlFnAaLZYEyBERFT5uLq6olatWpAkqVQzUxAREVHZKPHV1vDhw/H111/jnXfesWc8REREZUbu6Ql9r54wJSVBU69emR5LplZDVkaJEyqYMTYWab/vgCokGK6tWzs6HKpkVAoZJrQNR2JmDoL0amTs3w9IMviOGYXwPZegSTfCR/u/qajM6ekwpaRC5poMyWKB7P8XlFUp7iRIiIio8rFYLJDJ7vwOd3FxcXA0REREVJASJzZMJhO++eYbbN++HU2aNMnzB/+DDz4odXBERET2JEkSXB56yNFhUBnKOn4Cab9vhyo4GM5NmuS7HgJRYfTOSuidlcg+ew7Ja9cCkgxe3l4Y37EWsoxmaDVKa13nFi2QsX8/LOnpyLlyxWatFCIiqnxiY2ORkJCAmjVrQqVSOTocIiIiKkSJExunTp1C48aNAQDnzp2zW0BERERlxXj9OjL27YM6IhJOUWU7YoMcQxMZAecmTaAOD4fEaSOoFBSeHlD4+AKSBLm7OxRyGbT3rMEjCQFhyIEpPh45V64ysUFEVImZzWbcunULOTk5SElJgbe3t6NDIiIiokKUOLGxc+dOe8ZBRERU5jL+PoCUnzdBc+EiNPXqclHvB5AqOBjekyc7OowiEyYTsk6cgMzZGZrISEeHQ3eRu7nBbfAgKLy8IHdyyreOzMUFup49kLFvP+Q6bTlHSERE9iSXyxEREYGkpCQmNYiIiCqBEic2Xn/99QK3SZKE2bNnl3TXREREZUIdUQuaunXg1KgRkxpUIWSfPo3E6JWQOTvDe8pkKH19HR1SlWJOT4cpPh6qoCBICttucfL6Dcg6egSuDz8MXefOhezEjIz9+5Gxdy/8Zr8CpzJev4eIiOxLCGHtF6pUKvjybzEREVGlUOLExvr1620eG41GxMTEQKFQIDw8nIkNIiKqcJzq1oVT3bplfhxjXBxSNvwEpZ8vdH36QJL9b/oai8EASaGAJJeXeRxU8cl1Osj1OsicXSBzdnZ0OFWKEAJJ366A4b//oOvVC9qOHWy2mxMSYEpKgjkpqdD9yPRusKSnw5KVhezz55nYICKqRAwGAy5cuICQkBAuFE5ERFTJlDixcfTo0TxlqampGD16NPr161eqoIiIiMpCzrXrEIZsqMLCynTEhuHceWQeOQyFtzdc2raFwsPjTvl/MUha9T0U3j7wHDUSEhelrPJUISHwmTYNklIJGb9QKV9CQJjNEGYThNmUZ7P+sX5watgA6lq1YIyNhcLDI9/PrFOd2vCaNhXGixfh0qhReURORER2cv36dWRnZ+PatWuIiIhwdDhERERUDCVObORHp9Nh7ty56NOnD0aMGGHPXRMREZWKMT4eCV99BZGTA49Ro6CJqFVmx9LUrQPXDh2g8PaG3N3dWm6KvQnjtesQBgMsmZmQM7FR4R2+nISzsaloH+GDam75r7NQWnI3tzLZLxVOksngPnwYTDdvQpXPot9KHx8ofXyQtmsX0jZvgaZ2bXiMtO3fmtMzIHN2gr5LF6BLl/IKnYiI7CQkJARyuRwBAQGODoWIiIiKya6JDQBISUlBSkqKvXdLRERUKpJMBkkuh5DLICnKdhoohYcHPIYMyVPu1LAh3LINUHh68MvsSsBiEdh0/AbOxqXBSSlHv8bVHR0S2ZnC3R2Ku5KP+bGkpsKckgJTcrJNecaBA0j55Rdo6tWDx+OPl2GURERUVmQyGYKDgx0dBhEREZVAiRMbH3/8sc1jIQRu3ryJFStWoEePHqUOjIiIyJ4UXl7wnDABwpgDZbVqZXYcIQTSduyA8fJl6Hr0gNLf37pN5uwM7cMdy+zYZF8ymYQWYZ7QqOSoHaBzdDjkIK4dH4bC1xeq4BCb8pzLl5F54CAM/56FtnVrKHm3LxFRhSeEwOXLl6HVauHp6enocIiIiKgUSpzY+PDDD20ey2QyeHt7Y9SoUZg1a1apAyMiIrI3pa9PmR/DkpGJjD//Qs61a1AFB9skNjL2/w3jtWtw7dAeCi+vMo+lqrEYDDCcvwBV9Wp2GxHTvZ4futfzs8u+qHKSVEo41a8PmUZjU+7UsCGUfn6AsCDnyhUmNoiIKoGkpCQkJCQgMTERWq0WKk4LSkREVGmVOLERExNjzziIiIgeCDIXZ7i0bQPl5SvQ1K5tLbdkZCB1828wXrsGubsbtJ06OTDKB1Pajh1IWb8ByoAA+M5+BTJ52U45Rg8+c1oaEr7+BiI7Gx6jR91JZPw/dY0a8Bo/DqakZGjq1XNglEREVFTu7u7IzMyEk5MTkxpERESVnN3X2CAiIqrMMnNMuJ2Wg2ruTpDLpGI/X5Ik6Dp3tj6OT8vGqespiPDVwqVBQ8j1eqjDw+0ZMv0/kWNEzpUrMN26hezjJ+DcuJGjQ6JKSpjNyDpxAubUNJji4mAxGGC6ddsmsSFJElweeijf51+IT8Oaw9dRy9cV/RpVgyQV/3cJERHZnyRJqF6da2YRERE9CEqV2EhOTsbXX3+NM2fOAADq1KmDJ554Anq93i7BERERlSchBJbtvYQLceno08AfHSN9S73PX0/exM5/49EizBOT+vUtfZBUINcO7ZGxfz9gNkNSKh0dTpEY/otBzuVLcG7UiAvKVyDZ//yDpOiVgJMG2ocfhtzFGTnBYdh+7Aa8tGq0DPMoNFlxPi4dp64nI8NgRM8of2iUHD1EROQoqampSE9PRwCnDCQiInqglDixcejQIXTr1g1OTk5o3rw5gDvrbrz99tvYunUrGjdubLcgiYiIyoMQQGaOGZlGM7KNFrvss5reCQF6J1R3c4LIyQGUSt69XQaEEJApFPB5biZERgaUleBuTGGxIHnNahjOX4AlMxP6Xr0cHVKVI8xmQCbL85mUabWQaV0hc3GBS8sWkGu1+PPcLaw/dg2+Wg0i/bRwdyl4CpMmIe5IN5gQ4uXCpAYRkQMZjUZcvHgRFosFSqUS3t7ejg6JiIiI7KTEiY2nn34ajzzyCL788ksoFHd2YzKZMG7cOMyYMQN//vmn3YIkIiIqDzKZhFGtQnAtKRO1/XV22WfnOr5oHuoJ1eULiHtvOVRhoXAfNAiSTGaX/dMdaX/sQsqPP0IdUQvekyZVjuSRJEEZGARLZqbNFEdUPnKuXEHSDz9C6ecL9yFDICn+1y1Wh4bCe9o0SEoV5K4uAIAQTxfU9NEiwM0JWk3hXWgfrQaPNw0s0/iJiOj+lEolAgMDkZSUBE9PT0eHQ0RERHZUqhEbdyc1AEChUOD5559H06ZN7RIcERGRvQizGab4eCi8vAqdpshbq4a3Vm2340qSBL2zEqnXriEnJgbCbIYwGiGp7XcMAgwnTyLr1CnkXL8ObadOcIqKcnRI9yVJEtwHDYQlM8v65fndbqcboFLIoNNUjmm1KpucK1dhuHAB5tRUmNPSoHB3t26z5ORA5ORA7uaGrBwzNEoZgjyd8UL3SEgSKkfijIiIAABeXl7w9PTk724iIqIHTIkTGzqdDleuXEFkZKRN+dWrV6HVaksdGBERkT2lbtmC9D//gnOzpnDv37/cj+/SrBlgEVBWqwYZkxp2p+vVE4b//oNMq4XCx8fR4RSZJJPlm9S4eCsd3+yOgYtagckda0DvxOSGvTk1qA996iNQeHnZrG8ihMCtb1fAdPEiTjbvir/gibY1vdG9nh9kMn4pRkRU0ZnNZsTGxsLf3x+y/x8hy6QGERHRg6fEiY1BgwbhiSeewPvvv4+HHnoIALBnzx4899xzGDJkiN0CJCIisgdzSgosqamwpKSU6XGEEDDFxkKu10Pm7Gwtl+l00D7csdIsal3ZqMPDUe29d++staEqeO2DyiI924QMgwkWIWAwmgEmNuxOrtVC37NnnvILcWk4cfgifBJv4kJYJi5LGlRzc3JAhEREVBKXLl1CcnIysrOzER4e7uhwiIiIqIyUOLHx/vvvQ5IkjBw5EiaTCcCd+SufeuopvPPOO3YLkIiIyB70PXtCHR4OdY0aZXqcrEOHkLx+A1TVq8NzwnhICgVETg4SVnwH8+3bcB86BKpAzr1fFiSlEg/K/Zj1qukx6qEQuKgV8NFpHB1OlRKbZsDuOu0QnJOMrp2aoEamBXUD9I4Oi4iIisjHxwcZGRnw4/pVRERED7QSJzZUKhU++ugjzJs3DxcvXgQAhIeHw/muu1OJiIgqCrleD5fmzcv8OOaMDFjS02FOSwMsljtlaWnIiYmBOTERu4/G4L9LRnSu7YsQr7xTEBEBgFwmoVGQ+/0rkt01DnKHoVMjeGnVqBPohjr51BFCIPvUPxA5Bjg1bAhJLi/3OImIKH9arRb16tWzTkNFRERED6YSJzaysrIghICzszOioqJw+fJlfPHFF6hTpw66du1qzxiJiIgqDZdWrSDX6aH084X0/1MiyT084PboI8hJSsKfaTqcPRMHDxcVExtEFZCLWoHOdXwLrWO8fgNJq1ZBGAyQNBo41a1bTtEREVF+EhMTodVqofz/KT+Z1CAiInrwlTix8eijj+Kxxx7Dk08+ieTkZLRo0QJKpRK3b9/GBx98gKeeesqecRIREZWKOS0NkCTIXV3L9DgytRrOjRvZlEmSBOdmzeAMoOPZeHhdT0GDQLcyjYOIyo5c6wq5uztEdjYUdy08TkRE5S8pKQkxMTFQqVSoXbs2FIoSf81BRERElUiJb2M4cuQI2rZtCwBYs2YNfH19cfnyZXz77bf4+OOP7RYgERFRaRnj4nHrk09w65NPYLp1q0yPZU5NhTE2FkKIfLe3j/DBlIdrIty7bBMsVYkQAhaDocz2n200w2i22H2/lpwcZPx9AIbz5+2+bypbcr0e3pOegvf0aVBWq+bocIiIqjRnZ2eo1Wro9XomNYiIiKqQEic2MjMzodVqAQBbt27FY489BplMhpYtW+Ly5ct2C5CIiKi0LGmpMCenwJKSAnNaetkdJyMDt7/4Erc+/QyGM2fK7DhkK23rVtx4+RUkb9xo931fS8rE+1vO4tOdF5BhMNl131lHjiBpZTQSV34Pc2qqXfdN92e6fRvZZ89BmM0ler7M2Rny/+8LExGR46jVakRGRiIwMNDRoRAREVE5KnFio0aNGtiwYQOuXr2KLVu2WNfViI+Ph06ns1uAREREpaUKC4PH0CFwHzIEqtCQMjuOMJkgsrIgsjJhycoqs+OQrcyDB5F54ACSVq1CzrXrdt13XKoBN1KycCM5C8lZRrvuW+7uDrm7BxSenpDUarvumwpnMRiQsGw5Er78EpkHDzo6HCIiKqacnBxkZmZaHysUCkiS5MCIiIiIqLyVeJzmq6++iqFDh+Lpp59Gp06d0KpVKwB3Rm80atToPs8mIiIqP5JMBqcGDcr8OHK9Hh6jRsKckgJN7dplfjy6w/Xhh2H4LwYKLy9IMvt+qVGvmg4DmwbCRa1AgF5j131rIiLgPX0aZE5OkDGxUb4kCZBJgEwGgF+EERFVJiaTCefPn0dOTg5q1KhhnUmCiIiIqhZJFDQJeBHExsbi5s2baNCgAWSyO4M/Dhw4AJ1Oh8jISLsFaU+pqanQ6/VISUnhyBIioirCnJ4B4/VrUAUHQ6ax75fTVDEYr18HZDIo/f0dHQpVEqakJJgTE6EKDYUkK/Eg5gce+85sA6KKxmw24+LFizAYDIiIiIBKpXJ0SPR/7N15fFT1vf/x1zln9plkJvu+B8K+IyKIKArigmtrXalWbGurVqrd7e/aa2tr79Xb23tbra3aVW1derW1bq0IKCqyiSJLgBBIQvZkssw+5/dHIBIJkExmMpPk83w8eEjOnDnnbUhmznw/5/v9CCGEEMcYruvnIXXWys7OJjs7u8+20047bUiBhBBCiGhrf/YZurduxXHWWbguvTRm59F1nXBHB6rD0WegtHe73Y6iaTE7/1g2Ehs4+/buJVhfj3XGDFSbLd5xxhxDSgqGlJRBPedgSzcHmruZXuAkyWKMUTIhhBAno2ka5eXlBAIBKWoIIYQQY9iQbk9bt24d1113HfPnz6empmdN69///vesX78+KuGEEEKIqFGUmK+93P3uezT8x3/S9pe/9G4Lh3Xee/41tnz332n8819O8mwxloQ9HlqffIqWP/5JejzEQai9nY5//hPvzp0Dfk44rPOHdw7w+Fv7eXN340n31XWdlz88zCNv7qW2TfrtCCFENHR1dfX+XVVVzLKMoxBCCDGmRVzYePbZZ1m2bBlWq5UtW7bg8/kAaG9v50c/+lHUAgohhBBD5bryStK/+CWSzj8/pucJ1B8mUFeH/+Ahjq70eKjVw6b3d9G47yD1O/cxhBUgxSiiGI0YMjMxpKejpab1u4+u67i9AfmZiYGu996j9amnaXvmWcJ+/4CeoyiQ5bSQaVXJ2roB9z//iR7ov6F8py/I2t0NrK9s4qNadzSjCyHEmFRbW8vOnTtpbDx5YVkIIYQQY0fES1Hdd999PPzww9xwww089dRTvdsXLFjAfffdF5VwQgghxFDowSDejz9Gc7mwVIwf2HN0nZ2HO7CZNIrS7IM6n2PRIjSnE3Npae/skDSHCXXeGRxOS2XG8tNiPmtEjAyKwUDa51cS7u5Gc7n63ef/ttby7v5mlk3KZvGEzOENOMoZc3MxFhRgKilGMQzsclhRFK4/vYjmrW4CT6yh9U0PxowMrNOmHbevw2zg7IpMDrR0MyVPejIIIcRQBYNBALmOEkIIIUSviAsbu3btYtGiRcdtdzqdtLW1DSWTEEIIERWeLVs4/N//TbipmdTrryflc1edsknwR7VuHn9rP1ajxu3njiMzaeDNxg0pKSQtXtxnm91sYNXFs9D1mRg0aVAsPqGYTGgnWRv8QHMXNa0eDslSRlFnnTwZc1kZisk0qMbhRk0lo6yImmCQYH09Xe++129hQ1EUzpuc3c8RhBBCRKKwsJCUlBSSkpLiHUUIIYQQCSLiEZbs7GwqKyuP275+/XpKS0uHFEoIIYSICpOZUG0dgdpa2l94gUBt3amfYlAxaSpGg4pxEAOe0DPbQw+Hj9uuqUpvUSMU1tl0oIUdsjzNmKYHg6dcYuryWfmsPKOYpZOzhinV6KeHQgTq6tADAVSLZVBFjaM0l4vk887DXFGBJgNsQggRM/5PLRUoRQ0hhBBCHCviGRurVq3ijjvu4LHHHkNRFGpra9mwYQN33XUX99xzTzQzCiGEEBGxTptK6uc/j/sfL2GbNh1DWuopnzM+K4mvLhmHxaCSYj/x3fSfFu7upuUPfyTs6Sb12msxpKf3u9+HNe38bsMBbEaNO84dT7Zz4DNCxOjQvWULDf/1M/RQiPQv3kLSmWf2u19Bqo2CVNswpxvd2l96idZnnkUBXBddSPKFF6LaBv89Tr7oIqwzZmDMzY1+SCGEEHg8Hnbt2kVqaioFBQWyBJUQQgghjhNxYeNb3/oW4XCYJUuW0N3dzaJFizCbzdx1113cdttt0cwohBBCRERRFNKuv47Ua64GRRnw3dl5LuugzxVsasK3txLd4yVQU3PCwkay1UiyxYDNbMBq0gZ9HtFXqL2d9r/9DdVux3nhhShGY7wjnZJn2wf4Pv6YsM9H65+exH7aaahmc7xjjQn+6mq8O3ZAdzeB6mqMBYXYT583qGP4Kivx7tyJdcZMVIsUJoUQIha6uroIhUJ0d3ej67oUNoQQQghxnIgKG4FAgPPPP5+HH36Yu+++m8rKSjo7O5k0aRIOhyPaGYUQQoghUbTYFxCMeXk4L7yQsMeLuaLihPuVpNtZfV4FRoOKwxzx/QXiCF9lJV1vb0B12LHNmYMpPz/ekU4pael5eLZuxV9djX3eaSgn6bMx3HRdh1BowA21RxrXpZfS9c67+CsrMWRlYcwb/IwL90sv0b1pMyG3m9RrrolBSiGEEOnp6RiNRux2O2oEywYKIYQQYvSL6FOr0Wjkgw8+AMBkMjFp0qSohFm7di0//elP2bRpE3V1dTz//PNceumlvY93dnbyrW99i7/+9a80NzdTUlLC7bffzpe+9KWonF8IIYSIlKJpOBYtGtC+g1niSpycuawM+7x5qEkOjFkjoxeFKTeX/P96qKcfi6IkzF2ouq7jfuEFPB9+hHPFCqxTp8Q7UtSZ8vIo+vWj+GtqMGZlodntgz6GefJkQh0dWMaPj0FCIYQYu8LhMMox74tOpzPOiYQQQgiRyCK+9eG6667jN7/5TTSz0NXVxfTp0/nf//3ffh9fvXo1L7/8Mn/4wx/4+OOP+drXvsZXv/pVXnjhhajmEEIIIcTIoLlcpN5wPa7LLhsRy1D5Dx7EW3WgZ1kNVU2YogYA4TCeHTvwVe7BX7U/3mliRjWbsZSWRlTUAEhesoSsb30L25w5UU4mYqmmpobrrruOtLQ0rFYrU6dO5f333493LCHEEbqus3//fvbs2UMoFIp3HCGEEEKMABGvMxAMBnnsscd4/fXXmT17NvZPfTh88MEHB33M5cuXs3z58hM+/vbbb7Ny5UoWL14MwC233MIjjzzCe++9x4oVKwZ9PiGEECJaurdsofONNdgXLMA+77R4xxkzPFu34t2zB8fChRhzcuId56T81dXU/uAH+D7eiXXaNHLv+3cMaWnxjtVL0TRcl16Kb99+7KfNjXechDYcy9uJ6GltbWXBggWcffbZ/OMf/yAjI4M9e/aQkpIS72hCiCO8Xi9utxtd1/F6vceNLwghhBBCfFrEhY0PP/yQWbNmAbB79+4+j8Xq7sMzzjiDF154gZtuuonc3FzWrFnD7t27eeihh2JyPiGEEGKgPNs+oHvrFhSLWQobw0QPh2l/6SV8u3ajmM24YnSTw6YDrbxf1cJZFRlMyE4e0rFCTc2EOzvx79tH4NChhCpsAFgmTsQycWK8YwgRVT/5yU8oKCjg8ccf791WUlISx0RCiE+zWq1UVFTg9/ulqCGEEEKIAYm4sPHGG29EM8eA/PznP+eWW24hPz8fg8GAqqo8+uijLDrJmuY+nw+fz9f7tdvtHo6oQgghxhjHmQtRzCZsM2fGO8qYoagqtjlzUExmLCdp2D5Ub+xqYOP+FixGbUiFDVNhIVnf+ibtf/87lvLykzaZjwfd78fz4YdoKSmYZdD3hFq6/JgMKg7z6GywPhq98MILLFu2jM985jO8+eab5OXlceutt7Jq1ap+95fPD0IMH13Xe2+MtNls2Gy2OCcSQgghxEgxoj6R/fznP+edd97hhRdeoKioiLVr1/KVr3yF3Nxczj333H6fc//993PvvfcOc1IhhBBjjbmsDHNZWbxjjDnJS5eSvHRpTM9x1vgMLAaVucWpQz6W4/TTcZx++oD3r3d7UYDMZMuQz30q3Zu30Pr0UxhS08j42h1oSUkxP+dIs6+xk8fe2o/dbOArZ5eTbDlxX5dgKMxHtW5S7SYKUmWgLp727dvHL3/5S1avXs13vvMdNm7cyO23347JZGLlypXH7S+fH4QYHm1tbdTU1FBeXo7ZbI53HCGEEEKMMIqu63q8Q/RHURSef/55Lr30UgA8Hg9Op5Pnn3+eCy+8sHe/m2++mUOHDvHyyy/3e5z+7rgqKCigvb2d5OShLSchhBAisfn27SdYfxjrjBmoVmu84wgxKAdbunnkzb0oCtx6djk5ztj+DHs++ojWp57GkJZG+pe+iGqJfTFlOOm6jm/XLlBUzOPHRbR06taDbTz+1n5sJo2vnTuerJMUnN7Z18yf3j1Amt3M6qXjSTpJESSRud1unE7niL52NplMzJkzh7fffrt32+23387GjRvZsGHDcfvL5wchYk/XdXbs2IHX6yUrK4v8/Px4RxJCCCFElAzXZ4gRM2MjEAgQCARQVbXPdk3TCIfDJ3ye2WyWuz+EEGIMCnu9tD75JwK1dbh8PpIWL453JCEGJRAK4w+FURWFQDD296FYJ0/GePttqDbbqCtqAPj376fld78HRSH9i7dgKiwc9DGm5jm5YX4xdrN20qIGgNWoYTFqWE0aRk096b4itnJycpg0aVKfbRMnTuTZZ5/td3/5/CBE7CmKwvjx46mvrycvLy/ecYQQQggxAiVUYaOzs5PKysrer/fv38/WrVtJTU2lsLCQs846i7vvvhur1UpRURFvvvkmv/vd73jwwQfjmFoIIUQiUgwGDBkZ6D4/htShLyEkxHArSbez6sxSFEWhMG14ljIyZGQMy3niQbVYUCxmFFVFMUdWuNFUhdlFKQPad1q+k/Sk8SRZDFiMWkTnE9GxYMECdu3a1Wfb7t27KSoqilMiIQSA0WiUmRpCCCGEiFjES1FVV1dTUFBw3DR+Xdc5ePAghRHcBbdmzRrOPvvs47avXLmSJ554gsOHD/Ptb3+bV199lZaWFoqKirjlllu48847B7ycwGiYTi+EEGJgwn4/4a4uDCkDG4gUYqzTdZ1d9R3YjIZhK6YMp2BzMyiKFDsHYTRcO2/cuJEzzjiDe++9l89+9rO89957rFq1il/96ldce+21p3z+aPgeCJEIQqEQlZWV5OXl4XA44h1HCCGEEDEyXNfPERc2NE2jrq6OzMzMPtubm5vJzMwkFApFJWC0yQcTIYQYXfRAgK6NGwm2tuI44wwpYggxBB/WtPP4W/uxmjTuWDKejCRZjmesGy3Xzn/729/49re/zZ49eygpKWH16tWsWrVqQM8dLd8DIeLt4MGDNDQ0YDabmTx5ckS9joQQQgiR+BK+x4au6/1eiHR2dmIZhesyCyGESDxhn4/6H/4I96uvojmdqBYLyUuWxDuWGEZ6KASqmvCDI6G2Njw7d2JIScE8bhyKmpg9F4ya2vvHoCb293SwArW1+PbswTJlCoa0tHjHEcPsoosu4qKLLop3DCHGtLy8PILBIFlZWQn/vi2EEEKIxDfowsbq1auBnmZf99xzDzbbJ8sUhEIh3n33XWbMmBG1gEIIIcSJhLu68B08SNjvRwuHMebkxCWHHgrRvWkTiqJgnT37lIPWlQ0dfFTjZlZRCgWpo2+5n+Hir66m9ek/Y8zKIuWaq1EMCdU6rJceDtP48/+h7R8voZktZNz5NVwrVsQ7Vr/GZzn46jnlWIwaKXZTvONEVdtf/4pny1aSliwh5XNXxTuOEEKMOaqqUlJSEu8YQgghhBglBj0CsGXLFqBnxsb27dsxmT750GsymZg+fTp33XVX9BIKIYQQJ2BITSX9C1+gc8PbOM48E+ukSVE57luVjby9t5mlk7KZXuA65f6+vXtp+8szoCpoqamYy8pOuv+L2+rYWNVCmyfAyjOKo5J5LPJXH8S3dy8ht5tQR0fiLkOmKIQDAQgECetegg2N8U50QoqikJ8yOottprw8AnWHMeRkxzuKEEKMGYcPH8ZgMJCenh7vKEIIIYQYZQZd2HjjjTcAuPHGG/nZz34m68wKIYSIK8fCBTgWLojqMd/d18KmqlYykywDKmwYUlMxZGaAoqINYHB9Sl4y7Z4AE7KTopB27LJOn4azYwWGtDQ0lyvecU5IURQy7/walooK0FScy5fHO9KYlHzxxTgWL0aVa1chhBgWHR0d1NTUAGC1WrHb7XFOJIQQQojRJOLm4SOVNP8TQghxKtsPtbPlYCtnlKVTnukY0HPCXi8A6gD7TIXCOtoo62EgRrau994jUFOD46yzMKSmxjuOSBBy7SzfAyGG4mhhIy8vL85JhBBCCDFchuv6eUidK9etW8d1113H/Pnzey9Yfv/737N+/fqohBNCCCFOxlddTeszz+D9+OPjHtNDIXyVlYTa2gZ93Kn5Tm6YXzzgogb0FDQGWtQApKghEkqoswv3Sy/h/vtLeLZujXccIYQQo0ReXp4UNYQQQggRExEXNp599lmWLVuG1Wply5Yt+Hw+ANrb2/nRj34UtYBCCCFEf0IdHdT/6Ec0/s//0vKnP3HsBERd12n905PU/eDfafr1r9EDgZhm0f1+ArW16KFQTM8j+tJ1Hd3vH5bzVDZ0UNnQGfNzxYtqs2KZOhXzhAmYpLGrEEKICHm9XmpraxljC0MIIYQQIg4iLmzcd999PPzwwzz66KMYjcbe7QsWLGDz5s1RCSeEEEKcSKjdDSioFgvG/AIU5ZMZEKHWVjrWrsV/4ADBusOxzdHRQe13vkvNN76B++VXYnou8Qk9FKL1j3+k/qf/gXf37piea39TF4+u3cev1+2jurk7pufq79zPbDrEnvqOmJ5HUVVSrriCzK+vxiyFjah5c1cDv3ijkn2No7coJoQQR4XDYfbs2UNdXR2HD8f2+ksIIYQQYtDNw4/atWsXixYtOm670+mkLYJlP4QQQojBMOblkv7FWwh7PNjnzu3zmGq3Y5s1E83lJPXaa1GOKcBHm2/PHrwff0yoq5NAzaGYnUf0pft8+PbuI1BziMChGizjx8fsXEZNxaCpqAoYtOFdQuyfH9fzz4/rqWvzMC4r9s3mjy0QiqEJhXX+tbOB3fUd5LoslGYMfGk7IYQYiVRVJTc3l8OHD5ORkRHvOEIIIYQY5SIubGRnZ1NZWUlxcXGf7evXr6e0tHSouYQQQoiTUhQF28yZvV83d/qwmQxYTRqq2Uz6qlXoweCg+l5EwlRSQtL556N7PLiuuCKm5xKfUG02XJdfRqCuDtuc2TE9V0GqjdvOGYeiQFZybH+ePm1qnpPaNg/TC5zDel4xdJqqcN6kLPJSrMwoSIl3HCGEGBZpaWmkpqZKoVwIIYQQMRdxYWPVqlXccccdPPbYYyiKQm1tLRs2bOCuu+7innvuiWZGIYQQ4qR21Lr5wzsHSHeYuPXscixGDcVgQDFE/DY3YIaUFDJv+2rMzyOOZ506FevUqcNyrmzn8BY0jppXmsZpJTJANFItHJfBwnFy1/KnBQIBDh8+THd3NxkZGaSmpsY7khAiQrqu09DQQEZGBqras9K1vGcJIYQQYjhEPOLzrW99i3A4zJIlS+ju7mbRokWYzWbuuusubrvttmhmFEIIIY4T6uzCv38fpqIi2jx+2j1+NBV8wTAWoxbveEL00oNBvB/vREtJwZSfN+jnywDR0AVbW2n/vxdQkxy4VqyI6fJ0on8dHR384Q9/4KmnnuK9997D7/ej6zqKopCfn8/SpUu55ZZbmPuppQWFEImtpqaG+vp62traGD9+vLxnCSGEEGLYRFzYUBSF7373u9x9991UVlbS2dnJpEmTcDhk/WAhhBCx5/7HS3SuW4dt1mzmXHc9mqKQ5jDhtEZnwFLXdUAGlROZHgqBqib8v5H7lVdpe+YZTCUlZK6+E02ulYadf98+ujduRHU4sM87PaICk4jcgw8+yA9/+EPKysq4+OKL+c53vkNubi5Wq5WWlhY+/PBD1q1bx9KlS5k3bx4///nPGTduXLxjCyEGwOVy0dzcTEZGRsK/HwshhBBidIm4sPHkk09y9dVXYzKZmDRpUp/H7r77bn76058OOZwQQghxIqrJhGoyo1rMmAwq80rTonbs9u4Av9tQhaIo3HBGEckWubs70Xh376bt2ecwl5fjuvKKhB1MCXu9dLzxL/zV1WguF4oms4niwTxuHPaFC9AcDozZWfGOM+Zs3LiRtWvXMnny5H4fP+2007jpppt4+OGHefzxx1m3bp0UNoQYIRwOB1OmTEGT9zchhBBCDLOICxtf/vKXcblcLF++vM/2O++8k6eeekoKG0IIIWIqeflyLFOnYczLjfqxa9o87KrvQAHq2rwkZ0thI9H4DxzAV1mJHgig+/0oZnO8I/VL0TRMRcUQCuG64nJUqzXekcYkLTmZ1KuvjneMMevJJ58c0H5ms5kvfelLMU4jhBiqjo4OzGYzJpMJQIoaQgghhIiLiAsbf/zjH7n66qv529/+xsKFCwG47bbbeO6553jjjTeiFlAIIYToj2IyYS4ticmxyzMdXDg1B1VVKM2wx+QcHd4AiqLgMMe+wfloZJszB90fwFSQj5qgRQ0AxWgk/Qs3EXK7MWTJTAExdt13333MmjWL2bNnkyW/C0KMWF1dXVRWVqJpGhUVFZgT+D1YCCGEEKOboh9dRDwCf/rTn/jqV7/Ka6+9xm9+8xv+7//+jzfeeIPx48dHM2NUud1unE4n7e3tJCcnxzuOEEKIGAh7PHh37sRUUIAhPT3ecY5T7/byqzf3gQJfOquMjCQZFBDxpQeD+Pbuw5CZwTtNQTbsa2bppGymF7jiHU3EWbSundVj+uFkZ2f3FjmO/jcvL3H7nsjnByE+4ff72bNnDyaTifLy8oRdClIIIYQQ8TNc189Duk30mmuuoa2tjQULFpCRkcGbb75JeXl5tLIJIYQQEWn/x8t0vPoq1smTSP/qVxPuQ7fbE6C124+igNsbkMKGiLuud96l/a/PY8zL450Jy9hU3U5mkmXUFDbcr72Gd/uHJF90IZYEvgFnNJs7dy51dXXceOONpKens3nzZp577jl+9KMfEQqFyMjIYNasWbz00kvxjiqEOAmTyURFRQWKoiTc9ZUQQgghxpZBFTZWr17d7/ajH0R+8Ytf9G578MEHh5ZM9BHq7KLjlZdR7XaSzj0XxSBLlwghxq5QZydtf/4LKAopn/0Mqv2T5aJC7e10vvEv/AcOYKmI/QBm54YN+D7+mKQlSzAVFQ3oOWUZDq49vQhVgdL02Cx1JcTgKaCoLJ2YRZbLxhnliTfbKRLBdjdtzzxDsLEJU1mZFDbi5N133+WJJ57gO9/5DnPnzuXBBx+krKwMn8/H1q1b2bx5M1u2bIl3TCFEP0KhED6fD5vNBoBBPosKIYQQIgEM6orkRB82ysvLcbvdvY/LnRvR59uzm441a1CtNiyTJ2MqKIh3JCGEiJvAoUN4tn8Aiop9wRl9BirDXV2oyU7MpSXYzzorpu9JejhM57/ewLd7N1pa+oALG6qqMLsoJWa5Rjs9HKbj1VcJNjeTfMEFGFLkezlU9vmnY8zKREtPJzMlhWnFafGOFDXe7dsJdXSgWq3DUuwUJ/b5z3+eK6+8kh/84AfMmjWLW2+9lXvuuYd58+Yxb968eMcTQvRD13X27t1LV1cXZWVlshybEEIIIRLGoAobR5uC+/1+li9fzsMPP8y4ceNiEkz0ZSouxjptGqrNLs1HhRBjnqmkhKSzzwFFwVRc3OcxQ04OaddeQ9jrwzp9WkxzKKqK46xFGNLTsE6dGtNzjUVhn4/m3/4W3esl5arPYczKBCDY1ETn2nUEW1owl5ZimD8/zklHPkXTMI/SazpTfh7WadMxZmVhLiuLd5wxz+Fw8MADD7Bq1SpWr15NeXk5P/7xj7nhhhviHU0I0Q9d13tvEtE0Lc5phBBCCCE+EdEcUpPJxAcffBDtLOIkDCkppK9aFe8YQgiREFSzGeeKi/t9TFEULJMmDVsWx8KFOBYuHLbzjSXul/5B2zPPoBpN2ObM6S1sGNLSsM87jUBT86gdjBfRYyouJuvrq0HTUFQ13nEEEAwG8fl8XH311dTX13PjjTdy0UUXkZqaGu9oQohPUVWV8vJyPB5P71JUQgghhBCJIOLFMa+77jp+85vf8OMf/ziaeYQQQgghehg0tJRUDKmpWCZO7N2saBrOSy4Z1ijbDrbxr50NLByXztzi4R181XUdiO1Sn57t2wm1tWM7bS6qefQ1s1eMxridezj+/UaCH//4x2zfvp3t27ezc+dOLBYL06ZN47TTTuOLX/wiTqcz3hGFEMfwer1YLBag5/VLihpCCCGESDQRFzaCwSCPPfYYr7/+OrNnz8Zu79v8VJqHCyGEGE4d3gD1bi/FaXYMWnTuyvb4Q1iM6gkHJMM+H55Nm9BSU7FMmBCVc4pPJC9Zgik/H1NBQdz7aGysauGdfc1oqjKshY1uf5An3q7C6w9xwxnFpDuiX3QINjfT+pe/EGptQzGZsM87LernGKsa3F5+984BnBYj188vwmIcu8u4fOc736G4uJiVK1dy9dVXM16auAuRsFpaWti/fz/5+flkyTLIQgghhEhQERc2PvzwQ2bNmgXA7t27+zw21u9IE0IIEVuB+np8eyqxTJ6EISUFXdf57dsH2FPfwcXTczh3UvaQz7FmVwOv76hn4bgMzp/S//E8W7bQ8uRTGNLSyLzza2hyx3FUqTYbtpkz4x0DgIXj0lFVhdMGWdTwH6rB/crLmEvLSDp78aDP29jhY099J95AiEOtnpgUNlSHA1N2DkGTGUNmRtSPH2/e3bsJ1tdjmzUL9VM34sRadUs3e+o7cJgNNHX6yE8Zu3c8n3nmmWzdupV7772X//iP/2DatGnMmjWr98+UKVNk/X4hEkR3dzfQ01tTCCGEECJRRVzYONpIXAghhBhOoc5ODv/7fQRqanB95kpSr7kGgGA4TDCsEwrrUTnP/qYuqpq7yHZagP4LG1pqKob0dAzp6ShWa1TOKz4R6uxEDwSOm62h6zrBxkYMKSnDtsTQhOxkJmQnD/p53o8+ouuttwgcPIR9/umoR5b1GKj8FBsXT8vBGwgzITtp0OcfCNVsJm3VzeiBAOooW2ok3N1N29N/JlBXhx4KkbR48bCef1JuMhdNzcVh0ch1ju3XiDfffBOAPXv2sGnTJjZv3szmzZv54x//SFtbG2azmalTp/Lee+/FOakQIj8/H4fDIUvECSGEECKhRVzYEEIIIeLBu3Mn/oMHCXu6Qet5G1MUhZXzi6lt91Ce6YjKeZZNzibHaWFSzok/1FvGjydz9Z0oZjOqyTSo43d4A+yu76Qsw47LNrjnjgWBhgYaH/ovFJOJtJu/gKmgoPex9r//nc7X/4ltzmxSr7sujilPzTJ5MvYFCzCXlg66qAGgqQrnTIz9MiCK0RjXPhSxophMGHJy0EMhDBnDPxvFZjJw8YzcYT9vIhs3bhzjxo3jc5/7XO+2/fv38/7777Nly5Y4JhNibAsGgxgMnwwPuFyu+IURQgghhBiAIRc2duzYQXV19XHTVFesWDHUQ4tP6fIFOdDcTWmGfUyv0SyEGLt0Xcf7wQc9fQBmzcJ56ScNpFPsJlLs0SsQ5Lqs5LpOfYe1lhTZXfQvbKtl7e5G5hancvOZpREdYzRz/+1vdG3ciJbiIuR2924PNjfT/txz+PdXobmc6Lqe0EtgmvLzSP/CF+IdY8xSDAbSVt5A2OdDc0Sn6Cmir6SkhJKSEj7zmc/EO4oQY1IgEGDXrl0kJSVRWFiY0O+rQgghhBBHRVzY2LdvH5dddhnbt29HURR0vWfpj6MXQaFQKDoJRa8/v3+Q96taObsigyvnFJz6CUIIMcoEGxvpfPNN9IAf28yZaObj+w3ouo7u8aBYrQn9wdxuMmAzadhMUqjuj5KUjKmwENO48XgKS9GCYUwGFT0YwpiTi6JpJJ23NKH/jUViUIxGtFE4G0UIIaKls7MTn8/Xs9RjMIhRXjOFEEIIMQJEXNi44447KCkp4Z///CclJSW89957NDc38/Wvf53/+I//iGZGAXg++gjP9r1gSgcZwxFCjFG+XbvRw2EMKalYp07pd5/Odevo/Ncb2M+YT/LSpTHNE+7qIuR2Y8jOHvQA+4XTcphZ6DrSw0N8muvCC7BNnsR21cVzr+2hKM3OqjNLMWZlkv7FW9B9Pkzl5fGOeUphnw/d50NLHnx/DiGEEGI4pKSkUFZWhsVikaKGEEIIIUaMiAsbGzZs4F//+hfp6emoqoqqqixcuJD777+f22+/XdbIjSJd12l/4UXO3l3J3PMuZuq0efGOJIQQcWGZUEHSOUswZGViKirqd59A1QH81dUYs2Pbl0APBGh+/AkCtbW4rrgc2+zZg3q+UVMpSrPHKN3Ip9psWCZNom1HPY0dPqxGjWA4jKZqmAoL4x1vQMJeL82PPkqwtZXUa6/FXFYW70gD0u4J8Md3DqCqCtedXoTDLC3ZhBBiNAqHw6iqCkhPDSGEEEKMPBF/Ug2FQiQdWVc8PT2d2tpaKioqKCoqYteuXVELKHqW97JOnwZA8bRy6a8hhBizDBkZpN34+ZPuk7T0PAw52VgmToxpFj0cJtTZSbiri3B3d0zPNZadUZaG1aiR67JgNoys97+wx0OwqZlQWxvB5uYRU9g41NrNR7VuVAVq2zyMz4qsj4wQg6WqKosXL+anP/0pswdZLBZCDE5NTQ2dnZ2Ul5ejaSPr/VUIIYQQAoZQ2JgyZQrbtm2jpKSEefPm8cADD2AymfjVr35Faak0QY025wUXkHz++ShH7qgRQgjRP2N2Nsbs7JifRzWbSbv+OgINDVgmT475+cYqu9nAwnHp8Y4REd3jwZCZgXniBKwzZsQ7zoCVZTg4f0o2qgLFMqtIDKPHHnuMqqoqvvKVr/DOO+/EO44Qo5bf76exsZFQKITb7SYlJSXekYQQQgghBk3Rj3b9HqRXXnmFrq4uLr/8ciorK7nooovYvXs3aWlpPP3005xzzjnRzhoVbrcbp9NJe3s7ybLetRBCCJFwQh0dtD71NKgqKVddheb4ZHA9UN+A96MPsVRUYMzLi2PKU2t79jnaX3gBy6RJZH7j7oRtdB5yu/F++CGm4mKMubnxjiMSjFw7y/dAjE7d3d10dnaSmZkZ7yhCCCGEGGWG6/o54hkby5Yt6/17eXk5O3fupKWlhZSUlIT94C6EEGJk03UdQiEUg6z5P5oFamrw7vgIFJVAbQ3a+PG9j3W88gqda9/ENvc00r94y7Dm2tvYiS8QZmJO0oCudQyZGRgLCrDOnJHQ10ada9bQ/tI/sFRUkPG1OxI6qxj53G43jz/+OIcPH6akpITp06czdepUbDZbvKMJMabYbDb5vRNCCCHEiDakkSGv18sHH3xAQ0MD4XC4z2MrVqwYUjAhhBDiWHo4TOvTT+OvOkDKlVdgHjfuuH26/UE0VRlxvRhEX6aSEpLOPRcUFXNxcZ/HjAX5GPPyMBYWDGumw+1efrNuH75gmJvPLGVizsnvOgk2N9P55pvoCpjLy4cpZWS01FQMaWkYMjNHZVEj7PWimEyynGeCuPzyy9m2bRtz587lxRdf7O3NV1ZWxvTp03n66afjnFCI0am7u5sDBw5QUlKCxWKJdxwhhBBCiCGLuLDx8ssvc/3119Pc3HzcY4qiEAqFhhRMCCGEOJbu9eLbvZvAwUP4Dx48rrBxsKWbx9/aj81k4EuLy3CYZVbHSKWazTgvvLDfxxyLF2ObOxfVPry9H4za0YKZgtlw6gFyPRgiHAiihELogWDsAw6BfcECLBMmoDmd8Y4SdZ6PPqLt2ecwl5WRcvXnpLiRADZs2MCaNWuYO3cuAD6fj+3bt7N161a2bdsW53RCjF4HDx6ku7ubmpoaysrK4h1HCCGEEGLIIh71ue222/jsZz/L97//fbKysqKZSQghhDiOarPhuvRSAnV12GbNOu7xpk4fDR0+bKYgbk9AChujlKIoaA7HsJ83zWHmq+eUEwjpZDtPfadroPoAut+PbcYMzOOPn100GK1dfrYcbKUsw0FRDJp5K4qCIX1kNmg/lUBtLYGDB1FUFT0YRDGZhj3Djlo3H9S0cXpJGsXp0ox92rRpGI5ZTtBsNjNnzhzmzJkTx1RCjH6lpaUcOnSIwsLCeEcRQgghhIiKiEd96uvrWb16tRQ1hBBCDBvr9OlYp0/v97HJuU6uPq0Qq0kjZwADzwMRDuvogKbGZnme3fUdeAMhpuQ6UWN0DhE9aQ7zgPYL+3y0/vkveD/+GFNe7pCXd/rXznpe3FbHpNxk7l5WMSqXi4oV+2mnoSgKxrw81DgUNQBe+rCO96ta8AfDUtgAHnjgAb7//e/zzDPPYDYP7HdKCDF0RqORkpKSeMcQQgghhIiaiOfjX3nllaxZsyaKUWDt2rVcfPHF5Ob2DAL89a9/PW6fjz/+mBUrVuB0OrHb7cydO5fq6uqo5hBCCDHymAwqC8rTmVWYEpWB325/kF+s2cuDr+2iocMbhYR91bV7ePyt/TzxVhUfH3ZH/fgifvz79hFqb0OxWjFPmDDk4+W4rOS4LOSnWGNS1NBDIfRg3+WyQmGdw+1egqHwCZ41MmhOJ0nnnotl4sS4ZZhTlMLUPCdT8kbfUl+RKC4uxu12M2nSJL7zne/wwgsvcPDgwXjHEmLU0XWd/fv309HREe8oQgghhBAxEfGMjf/5n//hM5/5DOvWrWPq1KkYjcY+j99+++2DPmZXVxfTp0/npptu4vLLLz/u8b1797Jw4UK+8IUvcO+995KcnMxHH300Jpqf6cEgaJrcpSmEEKegH+nxpGhDayDe1OFnX2MnnkCImlYPmUnRfa8xGzRsJgOaEsJukmWzRhNjfj62uaeBqmI/ff6Qjze/NI3JuU6SYrC8Wriri5bf/o6Q10PqdddhzMwE4B/b61izu5HTS1K5cs7wNmofbRZXZLK4IjPeMRLGFVdcQX19PWeddRZvv/02v/zlL3G73aSmpjJz5kxeffXVeEcUYlRoaGigpaWF9vZ2pk6dijbE6yIhhBBCiEQT8SfkJ598kldffRWLxcKaNWv6DLgrihJRYWP58uUsX778hI9/97vf5YILLuCBBx7o3TYWGp/5Dx6k9cknMWRkknrdtSifKiIJIYToEWxtpeX3v0dRFFJvuGFIzZDzU6xcOjMPbyDExJzk4x4Pud10b9yIMS8PSwR35afaTdx2pGdDRpIsxzKahNrbMZeVYpkyBc0x9KWHFEXBaY3Ne3+wuRnfgQPoXi/Bw4d7Cxst3X5au/y0dPtjcl4xdn344Yds2LCB6ccsK1hVVcWWLVv44IMP4phMiNElIyODrq4uUlNTpaghhBBCiFEp4sLGd7/7Xe69916+9a1voaoRr2g1YOFwmL///e984xvfYNmyZWzZsoWSkhK+/e1vc+mll57weT6fD5/P1/u1292z3EfY5yN8zPajFEXp01iyv32isq/fD7p+op37rAPt37cPb2Ul3tYOnn5pG6rVxtXzCkmyGI/bV/f70U90XEA9Zi3jeO2rmEy9hTA9EEAPn3iZi4j3DQZ779oe8r5GI8qRn/Go7msw9N5RPqh9+1kypM++moZypCnnoPYNh9EDgejvq+vo/hMPjA1qX1XtLexFdd/h+r2P0WvEYPYd7a8R/kOH8O3dB4qC/9AhzMfM6Bvsa4SqKiwan3Fk3yBhX9/fpa633qL12WcxFRWR9Y1voJrNg36NSNZ00Pr/2ZDXiAj2TZDXiPb/+z88W7bgWLIEVz8zUCM9bixeI7TMTJwrLkb3+TFPmND7+3lRRRrlTiPjspL65BpJrxF6OEznm28Sam0l+fzz0RwOuY5g8K8RJ/u5jMTcuXPp6urqs624uJji4mIuu+yyqJ5LiLFMVVVKS0vjHUMIIYQQImYiLmz4/X6uuuqqYSlqQM9U2s7OTn784x9z33338ZOf/ISXX36Zyy+/nDfeeIOzzjqr3+fdf//93Hvvvcdtr/3mt+jop4mkZcoUMr76lU/2u/sbJxzsMI8bR+bXV/d+Xffd7xHu7Ox3X1NREVnf/lbv14fvvZdQc0u/+xpyssn5f/+v92v3a68Tam4h0OKm+MMHe3I9acdhNqClpZL7wx/27tvwnw/iP3Cg3+OqDgd5//HT3q8bf/4/+Pbs6XdfxWQi/79/1vt1068exfvhh/3uC1Dw8C97/978xG/xbN58wn3zfvZfKEcGMFr/9Ce6Nrxzwn1zf/oAWlISAG3PPEPnm2tPuG/OD+/DkJYGQPv//R8dr71+wn2zv38PxtxcANz/eBn33/9+wn2zvvVNTMXFAHT861+0P/f8CffNuPNOLBXjAehcv562p54+4b7pX7kV69SpAHRv3EjLb393wn3TVt2MbfZsADxbt9L86K9PuG/qyhuwz+9Z+sS7YwdN//uLE+7r+txVJC1eDIBvTyWNDz10wn2dl19G8tKlAASqq6n/8U9OuG/yhRfivPgiAIJ1dRz+wb+fcN+k887FdcUVAIRaWqj77vdOuK/jrEWkXH01AOHOTmrv/sYJ97XPP53UlSuBnkGymju+dsJ9rbNmkX7Lqt6vT7ZvIr5G1N9/P8G6w/3uO9ZeIzrWrCHU0goKNP73z/vMJoz2a0Sos4NAbR3WadN6B8jlNSL6rxGOc5ewbeoiDrZ0c26OieCPT7LvMLxGBEJh6u74GidaGNJcXo6/oYGwz48xJ2fEvUbU3//j3teIAsAL1Bx5bKS9RoT9Pgxp6YQ6OjAXF+OvqpLrCAb/GlH70H+dcN9I3HHHHfzbv/0bf/7zn3G5XFE9thBjXWtrK8FgkIyMjHhHEUIIIYSIuYgLGytXruTpp5/mO9/5TjTznFD4yB12l1xyCXfeeScAM2bM4O233+bhhx8+YWHj29/+NqtXfzJo4Ha7KSgYWWtFK0YDxowMknSdzI6eu+ZsJplOLIQQn+b2hmjFQprNTFKMexJpjiTUcjvOiy7uvcNaRIeu6xAMgtGIL6jz6kf1HGztJkdPpiKOuTYdaOX/ttZwsdtLdnL/PVeCLS2EOzsxZGRgKisf5oTiWIrRhHXWTMJdXT0Fp6qqeEcSwJVXXgnAuHHjuOyyy5g3bx4zZ85kypQpmPq56UgIMTBer5f9+/ej6zomkwnnEJbjFEIIIYQYCRT9ZHP9T+L222/nd7/7HdOnT2fatGnHNQ9/8MEHhxZMUXj++ed7l5ny+/3Y7Xb+3//7f3zve5/c0f3Nb36T9evX89Zbbw3ouG63G6fTSWtDA8nJx6+ZLsvMxH5fWYrqyL6yzMzg902QZWbkNSK2+57o917XdUJNTajJyb3H+/S+//XqTt6vamXp5Cyun1984uPKa8Tg9x3G14j2//s/urdsJensxTjOPpu/fdRAVXM3l0xMxbnhTVAUHOed2+dnG2L/GvGX9w/y1y01TM20cPeyCX1mBB0V7uzE/coraA4HyRdccPJ/N3mNiGhfuY44su8wvUa0t7SQkplJe3t7v9fOg3XgwAG2bdvG1q1be/9bVVWFwWCgoqIiIftsHP38EK3vgRCxUltbi8fjobS0tN/3KCGEEEKI4TBc188Rz9jYvn07M2fOBHqaAB4rFhdRJpOJuXPnsmvXrj7bd+/eTVFR0aCPp5rNfT5En2y/wRxzwPsO4o60weyrmEwnXB4jIfc1GmOzr8HQ+6F81O2rab2DE1HdV1V7l/aI6r6KMqL2hRj+3strxOD3Peb3vnvzZtqeex5TQT5pN9983M+2YjSyaEoeZruV0yoyT/r9TojfZXmN6Nm3n9/PUHMzoZZmQi2tqEYjK2bkAeD9+GOa1q8DRcUyZTKW8eMHddyh7rtofAZWk8a4zCQ0S/8zNlSzmdRrrvnk2AP8dzv63AHvK68RPfvKdcTg9x3ka8Rgfi4HoqioiKKiIlasWNG7raOjg61btyZkUUOIkSQ3Nxdd16WoIYQQQogxIeLCxhtvvBHNHAB0dnZSWVnZ+/X+/fvZunUrqampFBYWcvfdd3PVVVexaNEizj77bF5++WVefPFF1qxZE/UsQgghEkuovZ1QWxtBhwM9FOp3YG52USqzi1LjkE5Ek/Oyy7BMmYpl8qQ+240FBT09BRQVU17esOfKSrZw0bTcYT+vGNnc3gB/ercaTVG4el4hDnPEl9+jVlJSEmeeeSZnnnlmvKMIMaIEg0GamprIysrqLWZIUUMIIYQQY0VCfbJ6//33Ofvss3u/PtobY+XKlTzxxBNcdtllPPzww9x///3cfvvtVFRU8Oyzz7Jw4cJ4RRZCCDFM7Kefjmq3Y8zJGdQd6LGgh8N0vPYaweZmkpcvx5CSEtc8o40xOxtjdvZx2zWHg7SbbopDIiEid7Clm+2H2lAVhbMqMhiflRTvSMOuurqawsLCAe9fU1NDXhyKl0KMJLqus3fvXjo7OwkEAiOuj6QQQgghxFAlVLfTxYsX96xz/ak/TzzxRO8+N910E3v27MHj8bB161YuueSS+AUWQggxLHRdx7N1K8HGJrQEKCKEmpvpfHMtnWvX4fv443jHEQlEDwYJtraetEeEGFvKMhwsnZTN0snZFKfZ4x0nLubOncsXv/hFNm7ceMJ92tvbefTRR5kyZQrPPvvsMKYTYmRSFIWMjAwMBgPp6enxjiOEEEIIMewSasaGEEII0Z9QczPtL7xIsLUVQ2oK9vnzh+W8+5u6eGNnA1Pzncwt/mSJKy01FdvcuQSbmzCPGxfx8Rs7fLxf1UJ5poNxY/Au7tFG13Van3wS7+49OC+6CPu806J27Jo2D25PgIqsJFQ1esuMhD0e/FVVmAoLUe1jc9A91ixGjUtmju3ZBzt27OCHP/wh5513HhaLhdmzZ5Obm4vFYqG1tZUdO3bw0UcfMWvWLB544AEuuOCCeEcWYkRITU3F5XKhqgl1v6IQQgghxLCQKyAhhBAJz3/gAP6DB1EUBdMgljMZqverWnhtx2H+sb2uzx34iqbhuuxS0m++GUNGRsTHf3N3A3989wDPbDokd/iPBrpOoL6eYGMjwaamqB223RPg0bX7+NXafWw91Ba14wK0//0lmh75FW1//Wuf7b5giKc3VvPbt6twewNRPacYe9LS0njwwQepq6vjf//3fxk3bhxNTU3s2bMHgGuvvZZNmzaxYcMGKWoIcQotLS2EQqHer6WoIYQQQoixSmZsjABhj4eQuwNDZoY0gxNCjEn+6mrQNIzFRRhyh6958/QCF7VtHmYUuGLy+lucZqck3c74rCR5fT8i5HbT/uLf0JIcJC9fjmI0xjvSgCmqSspVV+E/UI11+rSoHVdVwKApGDUFQxRna/RSFKDvcWvbvGzY24w3EGJavpOZhfFfAk6MfFarlZycHG6++WamTJkS7zhCjDhNTU0cOHAAm81GRUWFFDWEEEIIMaYNqbCxbt06HnnkEfbu3cszzzxDXl4ev//97ykpKZGG3lGiB4O0PP4E/toaXJdfjm3WrHhHEkKIYWc/YwGq2YyprGxYCwDjs5Ji2uh3TnEqU/KcmA0yMHGUb88eut5+G9VhxzprFqb8/HhHGhRTQQGmKDdwTbIY+fJZZXT6ghSm2qJ23FBbG4FDhzCkpJB03rl9HstzWVlQno4nEKIs0xG1cwrxla98ha9+9avHFTb27t1LZmYmSUmyLJ8QJ2K1WjEYDDidTilqCCGEEGLMi/hq6Nlnn2XZsmVYrVa2bNmCz+cDehr//ehHP4pawLFOD4UIut2E3G7CHR3xjiOEEHFhzMok+YILsFRUxDsKAHo4TKCmhvCR976hsBg1ma1xDHNZGfbT5mI77TSMWVnxjpMw0hxmitLsUf1ZCRw+jP/AAYLt7YTb2/s8ZjKofGZOATfMLybZMnJmzRxLDwTw7d1LqLMr3lHEMXbt2sXixYuP2/76669z9dVXD38gIUYQu93OpEmTyB3G2atCCCGEEIkq4sLGfffdx8MPP8yjjz6K8ZhlIhYsWMDmzZujEk6AajaTet21pN1wA7bTT6et28/be5to7Bj6YJoQQojIdK5dS8N//5zWPz0pvTGiTHO5SF25kpQrrki4ZajCYZ3XPjrMk+8doK3bH+84Q2YuLSX5wgtIvvACTMXF8Y4TdR1vrKHpl7+k9ckn4x1FHCM5OZnW1tbjtp955pm88847cUgkRGLzer34/Z+85xgT7L1RCCGEECJeIi5s7Nq1i0WLFh233el00tbWNpRM4lNM+fnY5sxBNZv5+wd1PLZ+P89uPhTvWEIIMWaFu7oId3URkpl0Y0pTl4/XPq7n9R0NfFTrjnecIVNMJpLPPZfkc85JuCJSNOihIHowBAFpfp5Izj//fP7jP/7juO2qqvYZvBVCgN/vZ8+ePezcuROPxxPvOEIIIYQQCSXiwkZ2djaVlZXHbV+/fj2lpaVDCiVOLMVmwmUzkWIbfQMQQggxEuh+P6GODowF+TgvvkiWkRoG3f4gb+xs4IM33qX16afx7d8flxypNhOzi1KYUeiiXPpOJLykc84hbdXNpFwjyxslkn//93/nzTff5IorrmD79u1Azx3pP/nJT5g2bVqc0wmReDRNQ9M0makhhBBCCPEpETcPX7VqFXfccQePPfYYiqJQW1vLhg0buOuuu7jnnnuimVEcY9mUbGYVpZDuMMU7ihBCjEmBujo8mzYT9nqO60sgYmPzgTaefK+acza8iM19AD0QwFxSMuw5DJrKVXMLh/28IjKq2Yx18uR4xxCfUlBQwDvvvMOXv/xlpk+fjtlsJhgM4nQ6efHFF+MdT4iEYjKZqKioIBQKYTBE/NFdCCGEEGJUivjq6Fvf+hbhcJglS5bQ3d3NokWLMJvN3HXXXdx2223RzDim6X4/3l27MGRmYszKQlMVsp2WeMcSQogxy5CTg23ePPTubkwyQ3FYZDvN5Lqs6FOnY+90YZ06Nd6RRoXO9W/R9c4Gks87D+v06f3u4/GHsBhVmZkkoqqoqIiXXnqJ6upqtm7ditFoZN68eaSmpsY7mhBxp+s6Xq8Xq9UKfDJjQwghhBBC9KXoQ+x66vf7qayspLOzk0mTJuFwJPbSDG63G6fTSXt7O8nJyfGOc0qd69bR9txzGHNzybjjDlSTzNQQQojR5HC7F7c3QHmGA1WVweMT8fhDGDUFgxbxKpriUxp+9jO6N20meelSUq+79rjH39vfwgvbapiR7+LKOQVxSDh6ePwh9jd1UZRmw24eWXddj7Rr51iQ74EYTtXV1TQ1NVFaWorL5Yp3HCGEEEKIQRuu6+eIP1lVV1dTUFCAyWRi0qRJxz1WWChLNUSDYjKjmC2oFovcLSmEEKOM2xvgkbV7ae8OcN38ImYVpsQ7UsKyqDqebdsIWq1YJk6Md5x+6eEw/qoDaM5kDGlp8Y5zSslLl2LMzsY+b16/j1e3dHGguRu7aWQNxCeiF7bVsHZ3E6eVpLLyjOJ4xxFCJChd1/H7/ei6zhDvPxRCCCGEGPUi/qRaUlJCXV0dmZmZfbY3NzdTUlJCKBQacjgB5okTSTGbMJeXo0jDOCHEGOXdtRvd78MyeTKKOnru2FcAVVFQVQVNitdAT3Eg3O1Bc9j7bPfu2EHrn/6EYrWR8dWvYMzKilPCE/Ns20br03/GkJJCxm1fRbXZ4h3ppCwTJ560SHTW+EwcZqM0So8SRen5I4QQJ6IoCmVlZXR0dMjsICGEEEKIU4i4sKHrer8zCDo7O7FYpAdENIQ9Hlp+/WuCra2kXnM1WoLeoSqEELEUqKuj5Q9/QPf5SPv8SiyfmiUYax/VttPWHWBOcQpmQ3TXuE6yGPnSWWV0eAOUpNtP/YRRTtd12v78F7w7d+JccTG2WbN6H9OSk1GTk1Ft9sQtGOg6hMM9d9lG+U5bbyDEB4fayXFaKEgdnv//jCQz50/JHpZzjXaXzMhjWr6LorQE/dkVQsRVIBDAeOQmNkVRpKghhBBCCDEAgy5srF69Gui54LrnnnuwHTO4EAqFePfdd5kxY0bUAo5lut9PuKur509nZ7zjCCFEXCgWC5rDTtigodqHd/C/pcvPH9+pprXbj6YqnF4a/eWFMpLMZCSZo37cEUnX8VcfIFBTQ6Curs9DpuJiMm+/HcVoHPafg4GyzpiBlpSE6nRGPeNblU38+f2DFKbauHvZBEyG0TNzaSywGDUm5shApRDieF1dXezevZucnByys6WYLIQQQggxUIMubGzZsgXouaty+/btmI5pZm0ymZg+fTp33XVX9BKOYZrTSer11xFqa8MyeTLQ831/b38LnkCIM8rSZWBDCDHqGVJSSP/yl9GDQQypqcN6bptJIzPZjKYqpDt63u8827bR8cYaHAvOwDZ37rDmGe0UVcV15ZX4qw5gnTmjz2OvfnSYbYfaWDE9j4rErGugqCrmceNicuwkixGn1YjLZkKTJvNCCDFquN1uwuEwHR0dZGVlSV9FIYQQQogBGnRh44033gDgxhtv5Gc/+5lMk40xU3Fxn68PtXr4y6ZDePxBnFYjM6XRrBBiDNDi9F5jMWp8eXEZvmCYZEvPEhHdW7bSvWkTiskohY0YMJeWYi4t7bMtHNbZsLeZXfUdlGc4qMhOilO6+JlbnEJRmg2n1Ri1wkawsRHFZEJzOqNyvEQT6uyEYBDN5Yp3FCGEOKGcnBxMJhMul0uKGkIIIYQQgxBxj43HH38cgB07dlBdXY3f7+/z+IoVK4aWTPQrxW4iz2Wl2x8kK1l6mQghRKyZDVqf3hqOBWegGLQ+/R9EbKmqwkXTcyirczC3ZHhn7SQKRVGi+r7v27ePlt/+DtVmJf1LX+q3uKHrOhurWmnr9rNwXDo2U8SXjcMu2NpK868eRff7Sf38SkwFBfGOJIQQvcLhMKr6ycz7tLToL3UphBBCCDHaRfwJdf/+/Vx66aVs374dRVF6GmVC710moVAoOglFHw6zga+eU04orGMxRreJrRBCiFMzjxsXs+WGxInNLkpldlH8ixr7m7r465YaxmU6uHBazoi9uzbc1U3Y093zd5+P/q4omjr9PLv5EC1dfhwWA2eUpQ9vyCHQu7sJdXSg+32EOzriHUcIIXqFw2EqKysxmUwUFRWN2PcRIYQQQoh4i7hBw+23305JSQkNDQ3YbDY++ugj1q5dy5w5c1izZk0UI4pPM2qqFDWEEEKIONhZ52bTgRbe2d+MLxiOd5yIWSZPIvX6G0i94XqMmZn97pNsNVCSbqc4zUa+yzbMCYcm0NAAuo5t5kzMFRXxjiOEEL26urro6OigtbUVn88X7zhCCCGEECNWxIWNDRs28IMf/ID09HRUVUVVVRYuXMj999/P7bffHs2MY5Z31y4aHvovOv71r3hHEUKIuPFs3UrDgw/R9e578Y4SE/VuL3969wAb9jbHO4oYgJmFKSybnM35k7NH9E0GiqpinToFc1nZCfcxGzRuObOUb5w/gcK0kVXY8Gzdhr+6mmBrG4oW/38nXdfZdKCVt/c2EQyN3ILYaPHjH/8YRVH42te+Fu8oYgxKSkqivLycsrIyLBZZWlgIIYQQIlIRL0UVCoVISupp3pmenk5tbS0VFRUUFRWxa9euqAUcy7wff4xn61bCXg+Os8+WacpCiDGpe+s2urduQbGYsc87Ld5xom5LdSsvba+jON3OzELXiB4sHwuynRaun18c7xjDRlUVVEbe9Ydj4QIUkwnbrJnxjgLAoVYPT71XjS8YIslsZGr+6GzYPhJs3LiRRx55hGnTpsU7ihhjdF3v/Tzn7KevkRBCCCGEGJyICxtTpkxh27ZtlJSUMG/ePB544AFMJhO/+tWvKC0tjWbGMcs2Zy5hjxfLhAopagghxizHmQtRzCZsM2bEOwoA+pEeUtG6C3x8VhIzC1Moz3RgNkQ8kVIIcYxE64WTbDWSmWTGGwyT5jDFO86Y1dnZybXXXsujjz7KfffdF+84Ygxpbm6mqamJsrIyDIaIP4ILIYQQQohjRHxV9b3vfY+uri4AfvCDH3DRRRdx5plnkpaWxtNPPx21gGOVHgjg2boFRVMT6oO5EEIMN3NZ2UmXyxlOwdZWWn7/BxRFIfWG69GicMdlaYaDry+VHgCjQaCmhmBjI5ZJk1BMMngtPuG0GrltyTjCuo7NJIOa8fKVr3yFCy+8kHPPPVcKG2LYhEIhDh06RDAYpKmpiezs7HhHEkIIIYQYFSL+ZLVs2bLev5eXl7Nz505aWlpISUmR2QVREKiro3PtWsLdHszjxmGbmRhLKQghxFgWbGjAX1UFikKwoSEqhQ0xOoS9Xpp//weChw/juuIKHGcujHckkWBkmbn4euqpp9i8eTMbN2485b4+n69PU2e32x3LaGKU0zSN8ePH09zcTFZWVrzjCCGEEEKMGlG9ZSw1NTWahxvTDNnZ2GbP7ilslJT0eexgSzdrdjUwKTeZ2UXyPRcjQ6C+AT3gx5iXJ8VPMaKEwzqHWj2kOkzYS0txrrgYRVEwfeq1WQyeHg6jqJ8svxVsbsb98ssYMjNJOvfchHyt0HWd13bUU9XcxUXTcsl1WYGepck0u42wzYZqj02j7aZOH82dfsozHWjq0L43HevW4fvoI5KWLsNcKj/LYnQ7ePAgd9xxB6+99tqAmjXff//93HvvvcOQTIwVVquV/Pz8eMcQQgghhBhVIi5srF69ut/tiqJgsVgoLy/nkksukWJHhFSTiZSrrur3sff2t/DS9jr2N3Uxq1BmyIjEF2xupvlXvyLs95G2ciXm8vJ4RxJiwN7Z38yzmw5RkGrji+VmCAYxT52GImtkD0n73/6GZ/uHOFdcjHXyZAC8Oz6m8821GDIzsM2ejSEBryG6/CHW7GrgYKuH4jR7b2FDD4WwzpyJ7Qwb1hjMsvQFQ/x63X7q2j1cNaeAM8rTIz6WHgrR9eab+PZUYsjNHXWFDV3X8e3aBYqKefw4uU4SbNq0iYaGBmbNmtW7LRQKsXbtWv7nf/4Hn8+HdkzfpG9/+9t9Puu43W4KCgqGNbMY2QKBAPv376ewsHBAxTQhhBBCCDF4EY/KbNmyhc2bNxMKhaio6FkbfPfu3WiaxoQJE/jFL37B17/+ddavX8+kSZOiFljA5Lxk9jenMiPfJR/WxcgQDqOHQxAKo4fC8U4jxKD4gmG8gRAef4j2F1/Et3UrSQ0NpF5zTbyjjVh6OIxn+3Z8u3bj3ze5t7BhHj8e29w5GLOy0Fyu+IY8AbtJY3FFJlXNXUzJ+2Qpsq4NG2h77nlM+XnYpk6BGPTYUBRQFWCIb/2KpuFYsgRjXj62GTOiES2h+Pfvp+V3vwdFIf2Lt2AqLIx3JAD21Hfw6o56ZhQ4WVCeEe84Y8qSJUvYvn17n2033ngjEyZM4Jvf/GafogaA2WzGbDYPZ0Qxyhw8eJCOjg6qqqqYMGFCvOMIIYQQQoxKERc2js7GePzxx0lOTgagvb2dm2++mYULF7Jq1SquueYa7rzzTl555ZWoBRYwITuZCdnJ8Y4hxIAZMjJI+8LN6D4vptLSeMcRYlAWlKWTajOR7bRgoRS9uSlhBkpHKkVVcZy5qKeH1GnzercbszJJX7UqjslOTVEUlk4+vvGrlpSElpzU03dFi34vBbNBY9WZpTR3+ijNcAz5eI7583HMnz+gfcNhHXWIS18NJ9ViQbGYUVQVxZw4d0pvrm5l3Z5GWrv8UtgYZklJSUyZMqXPNrvdTlpa2nHbhYiGwsJCwuGwzPQRQgghhIihiAsbP/3pT3nttdd6ixoATqeTf/u3f2Pp0qXccccdfP/732fp0qVRCSqEGLl0v7+nv0Z+vswyEiOOyaAyvcAFQGDePGxz5mDMzIxvqBHOu2MH7ldfwZCejuYcHYV66+zZGAsK0ZzJKDEobACk2k2k2qM/E+Rkdtd38Jf3DzI+K4krZ4+M13Bjbi4ZX/kKKEpCLWc2pziVdk+A6fmueEcRQsSYwWCgXJZeFUIIIYSIqYgLG+3t7TQ0NBy3zFRjYyNutxsAl8uF3+8fWkIhxIjnfvllOtetwzZ7Nimf+1y84wgREd/+/bT89neodhvpX/wiWvLoGJCPh5C7g7C7g7DRhB4IwChYf1xRFIxZo6/gta+xk511HXgDIS6enovFGJuiTbQZ0tLiHeE4ZRkOyqIw20ZEx5o1a+IdQYwytbW1OByOPjf+CSGEEEKI2BnSUlQ33XQT//mf/8ncuXMB2LhxI3fddReXXnopAO+99x7jx4+PSlAhxMgV9vkJ+3yEvb54RxEiYuHOLsJdXejhEGGPN6qFjbcqGznY4mHJxCwykkb/uu62WTNRTEa0lBS0pKR4xxEnMac4FY8/RGGafcQUNYQQYri1trZSV1eHoihMmTIFUwz6LAkhhBBCiL4iLmw88sgj3HnnnXzuc58jGAz2HMxgYOXKlTz00EMATJgwgV//+tfRSSqEGLGSly/HUjEePb8QXddHxFImQnyaZdJEUq+9BsVmi+qd+V2+IC9tP8zBlm5S7aZ++zeMNsHGRtoDOi8fDJHUfJBLZuZh1NR4xxL9SHeYuWxWfrxjCCFEQnO5XKSmpmK1WqWoIYQQQggxTCIubDgcDh599FEeeugh9u3bB0BpaSkOxydT7GfMmDHkgEKIkU9z2NnhzOevaw8yPb+DK+dII0Ux8iiahjUG72s2k8bsohRS7SbGZ43+2Qthr5fm3/+BLfXdrCs8A1duFvNK0yhItcU72oAFQ2F21LlJsZmGPbc3EMKoqWgjqJm3EEKMdoqiUFJSEu8YQgghhBBjSsSFjaMcDgfTpk2LRhYhxCh2oLmbqqZuLEZNZm2IAQv7fHS88iooCknLlqKOwrsgFUXh8jF0R7yiaWgOB6XtXZyeayWtPJ1s58jqsbHpQCt/fPcAaXYzq5eOJ8liHJbz7m3s5A/vHCAr2cJNC0owGWSWS3+633+f7vffx7F4MZYJE+IdRwgxSnV3d9PV1UVGRka8owghhBBCjElDKmysW7eORx55hL179/LMM8+Ql5fH73//e0pKSli4cGG0Mo5Jgfp6vNu3Y54wAVP+2BnwEqPXmeMysBo1yjMdUtQQA+bfv5+ON/4Fioq5YjwW6ds04ilGI2k3fh6X201FdvaIfD2wGLWePyYNg9pTXPBs/5BQezu2uXNQzbHpk1Lb5uFQSze+QIhufxCTYfQV+qKhc/16ujdtRnUkSWFDCBETwWCQPXv2EAwGURSF9PT0eEcSQgghhBhzIi5sPPvss1x//fVce+21bNmyBZ+vpylwe3s7P/rRj3jppZeiFnIs6nj9dTr+9Qa22bPJuPXLfR4Lh3Ve2l5HY6ePi6fnku4Y/Y1mxciXkWRm+dSceMcQI4wxPx/r1GmgKJjy8uKW4+M6N4fbvcwtScVhHvJkxzFPtdtR7fbjtuu6DuEwipbYTaqn5TtJc4wjyWLEatIItrTQ9pe/EGxrRTEasc87LSbnnV2Ugj8YJs1hxmUbvqJGQ4eXxg4fFVlJGEZALxTHWWehJiVjO21uvKMIIUYpg8FAZmYmra2tpKSkxDuOEEIIIcSYFPHozH333cfDDz/MDTfcwFNPPdW7fcGCBdx3331RCTeWGQsKMOXnYyopPu6x5i4/a/c00tjhozzTwZnjZPqzSGxhvx9gVC4jJGJLczhIu+nGuGbw+EM8+V41Na0ewrrOkolZcc0z0gVbWuh6+21M+fl9epbo4TCtTz9N4EA1riuvwFxeHr+Qp6AoCvkpn/TWUG02DFmZKCYjhhguSWIzGaLy86frOoHqatTkZAynGJDzBkL8Zt1+6to9fHZOIQvHJf5dybaZM7HNnBnvGEKIUS4nJ4esrCxUNfELvkIIIYQQo1HEV2G7du1i0aJFx213Op20tbVFdMy1a9dy8cUXk5ubi6Io/PWvfz3hvl/60pdQFIX/+q//iuhcic5x5plkfeNuks8//7jH0uwmFpSnc0ZZGhXZo7/RrBjZgs3NNP73z2n8758TbG2NdxwhBs1kUClIsTHR10jWB+8QbGmJd6QRrXvTJtqe/yttL7xI2Ovt3a57PPh27cZXWYm/ujqOCQdPtVhIX7WKzDvvxFya+M1jvdu20fTwIzT/+jeEu7tPuq+qKBg0BYOqYtBG3rJhiabdE6C2zdMzO0kIMaLouk5DQ0Of318pagghhBBCxE/EMzays7OprKykuLi4z/b169dTWloa0TG7urqYPn06N910E5dffvkJ93v++ed55513yM3Njeg8I4GiKCj9LNMBoKoKl8yI35IsQgxGsLmZYH09KBBqbj7l3cFCJBpNVfj8/ELq1z1N6L29dNlUnBdfHO9YI5a5uBjLuHGYystRjulFodrtOC9ZQaCuDtusWXFMODDVzd1UNXcxo9BFssWIYjKhDMOsNI8/RFOnjzyXFVWNrNCgB4NH/gTQwycfYDcZVG45s4zmLh/Faf1fl4iB6fQF+cUblbR7Alw/v4jJuc54RxJCDMKBAwdobm6mq6uLkpLEL2ILIYQQQox2ERc2Vq1axR133MFjjz2GoijU1tayYcMG7rrrLu65556Ijrl8+XKWL19+0n1qamq47bbbeOWVV7jwwgsjOo8QYviYy8pwXXEFACb5EChGKINBw14xHm8ogDE/P95xRjTzuHFkfuNuUJQ+jcMDDQ34K/diKi5Cc7niF3AAwmGdP757gD0NnVzWncfFM4bnRgtd13n87f1U1neyYkYuiysyIzqOdeZMVIcDzeVCc5y6WOG0GXHajBGdS3wiGArjCYTwBEJ4A6F4xxFCDJLT6aS1tZXU1NR4RxFCCCGEEAyhsPGtb32LcDjMkiVL6O7uZtGiRZjNZu666y5uu+22aGbsFQ6Huf7667n77ruZPHnygJ7j8/l6G5sDuN3umGQTQvRP0TTsp8+LdwwhhkRRFFxXXI5+0YWoFktMzhEMhdHUvoP9o5XSz9Idnq1baf/HPzAVFWGZOjVm3+doUBTIdlpo9wRITzKf+glRouvQ7QvR7Q/i8Uc+MK5oGpYJE6KYTAyEy2biCwtLaPcEZLaGECNQSkoKSUlJGAwRf4QWQgghhBBRFNFVWSAQ4Pzzz+fhhx/m7rvvprKyks7OTiZNmoTD4Yh2xl4/+clPMBgM3H777QN+zv3338+9994bs0zxUu/28vqOeorSbCyU5uFCCBFziqKgxGiwvaqpiz++e4DsZAs3nFGMURsba3a/X9XCu/tbOLsik7LycVinTME8ru8SVYlIURSuP70ItzdIyjDOZFBVhRvOKOJQq4dJOcnDdl4RPUWynJcQI4rb7cZut6NpGoAUNYQQQgghEkhEV2ZGo5EPPvgAAJPJxKRJk6Iaqj+bNm3iZz/7GZs3bx7U3azf/va3Wb16de/XbrebgoKCWEQcVluq23j5w8MUptmYVZSCzSQX2SKx6brO+sommjv9nDMxk2SLLGsixFEHW7vZ19hFpzdIpzdIij32vRoSwZrdjWzc34LDbGDSGSVkrr4z3pEGzKCppMbh3ykzyUJmUuLOZhEn5w+G2XnYTXayhcxk+XcUIpF1dHRQWVmJxWJh/PjxUtQQQgghhEgwEd8Set111/Gb3/wmmllOat26dTQ0NFBYWIjBYMBgMHDgwAG+/vWvH9fA/Fhms5nk5OQ+f0aDCdlJzCxyMa8kFatRi3ccIU6pqdPPi9tqeXFbLR8cbI93HCESyowCF5+Zk89ls/JxjaFeBmdXZHL2hEzmlY7s9cp9e/fS9Ktf0blhQ7yjxESnL8grHx1m04EWdP3kzcbFyb1V2cQjb+7lsbeqCITC8Y4jhDgJTdPQNA2LxdI7Y0MIIYQQQiSOiG87CQaDPPbYY7z++uvMnj0bu73v1PoHH3xwyOGOdf3113Puuef22bZs2TKuv/56brzxxqiea7h0vfseXRveJumcc7BOmzao5xan21l9XkWMkgkRfS6bkcm5TurdXorTbfGOI0RCSbIYOX9KTrxjDLvZRSnMLkqJd4yIdPuDvL6jAYdZY8aHW+hc/xbBllbsp58+6vqkbD7Qyp83HiQz2UxpumPMzCiKBZNBxWzUsBhVRtdPiRCjj81mY+LEiRgMhlH3ui6EEEIIMRpEXNj48MMPmTVrFgC7d+/u81ikF36dnZ1UVlb2fr1//362bt1KamoqhYWFpKWl9dnfaDSSnZ1NRcXIHODvfu9dujdtxpCaOujChhAjRaijA/+BasylJaw8oxhd1+XDoRgw786deD74APtpp2E6yey8WAuHdfY0dOKyGcmS5WMEsKPWzd+312I3Gygrn4jjrHasU6aOyte3/BQrxel2spMtOCyJvRRLqLOLjtdeQ3U4SDrnbJQEu8t6fmka+SlWUu0mDGOkl44QI0kwGCQUCmE+0uvJZJJCrhBCCCFEoor40+kbb7wRzRwAvP/++5x99tm9Xx/tjbFy5UqeeOKJqJ8v3pQzF/P3cA4mZxHX+ILYzT3/HLqu4ztSLDKPHz8qB0nE2NH2zLN4tm7BsWgRriuukJ9nMSgdr75K1/ub0P1+UuNY2Nhc3cqf3q0mxW7izvPG4zAn9uCuiL3CNBsVWUkkW41kTS3CMmtyvCPFTGmGg2+ePwGDqqCqif0a7tu1k45/vo5qd2CZOBFTfl68I/Whqoo0EBciQYXDYSorK/H5fIwbNw6bTWYYCyGEEEIksoQamVm8ePGg1m6uqqqKXZhh0JhVxMcZAeiChS3dTMzp6f/hr6qi5Xe/AyDt5psxl5T0+/wDzV3UtXuZUeDCIn02RIJSTEYwGFGMY6dvgIge66zZhH1+rFOmxDWHoigoCqgKsnxMFPmDYdbsakBV4KyKTIwj6A72zCQLd543Hoh8pupIYjKMjH8bU3Ex1kmTUZ3JGDIz4h1HCDGChEIhwuEwuq6jqiPjNU8IIYQQYiyLuLBxdDbFpymKgsVioby8nEsuuYTU1JHdEDSWStLtLK7IQFEUStI/uXtPtVpRLdbev/fHGwjx27erqGnzcNXcAs6ZkDUsmYUYLNfll2OfPx9Tfn68o4gRyLFwAY6FC+Idg1mFLlw2I06rsXd2nYiMHg5DMIhiMlHZ0MkL22pRFSgwhSi1KRhyckZMoSAeOXVdp7qlG6tRI3MYl0Xr9gdp7PCRn2JDS+BZG4a0NNJv/XK8Y5zUB4faqGv3Mr8sjWSLFP2FSBRGo5GKigp8Ph8Wiyw7KYQQQgiR6CIendmyZQubN28mFAr19rjYvXs3mqYxYcIEfvGLX/D1r3+d9evXM2nSpKgFHk0sRo0rZxcct92Ynd3zoVxRMJygMGRQFVLtZrr9IZxWWftVJC7VasVcWhrvGEIMiaIolGU44h1jxAv7/bT87veEmppIueZqctOzKctwYPR7sP7lDzR2dZJy9eewTh4ZyzqFwzpubwCn1ThsRY5d9R08vn4/VpOB25eMIzWCRt6BujqCTU1YKipQBrB+vK7rPPFWFZUNnayYkcviisxIogugyxfkL+8f5FCrB4OqsGSi3JgiRLz5fL7enhqapskSVEIIIYQQI0TEhY2jszEef/xxkpN7llBqb2/n5ptvZuHChaxatYprrrmGO++8k1deeSVqgccKw6capR/3uKZy85kldHiDpDuksCGEECNdly9IQ4ePwtTEviN+KMJuN/4DVYSaWwjU1uIqLOSOJeMItbfTvDlAyOdF9/niHXPA/rq1hvf2t3B+oZWFxS4MGbFf+igU1gnrEAqHCQ9i+c6jwj4fLb/7HYHDh3FdceWAZkTpOnQHQngCIbyBUCSxxREWo0ZJhgNNVclPkcFTIeKtoaGBQ4cOUVJSQkpKSrzjCCGEEEKIQYi4sPHTn/6U1157rbeoAeB0Ovm3f/s3li5dyh133MH3v/99li5dGpWg4ngWoya9NcSI4g2E+LCmnWynRQZ0hDiGrus88XYVlQ0dXDwtl3NG6V3cWloarksvJdTWhnXaNKCnmbKa4iL18ysJtbuxTJwQ55QDd6jVQ3tdI7z5TxpTzaTd+HlMRUUxPeeknGS+eFYpVpOBdId50M9XFAXlyJKXqmVgz1dVhZXziznU+kk/MBEZTVX4/PxiAuEwZoNcwwkRbx0dHei6jtfrjXcUIYQQQggxSBEXNtrb22loaDhumanGxkbcbjcALpcLv98/tIRCiBFNP3JHsaIobNjbzJ/fP0h+ipW7llXIoI4QR+g6+AIhvIEw/lA43nFiRlEUbLNn9/uYqaAAjl+dMaFdMTufSrOPghqVsMdDuLs75udUFIXyzKTIn28ykXbTTYTa2jDm5Q34eRlJZjKSBl9IEcdTVQWzKu9/QiSC0tJSWltbpS+kEEIIIcQINKSlqG666Sb+8z//k7lz5wKwceNG7rrrLi699FIA3nvvPcaPHx+VoKNVuyfArsMdlGXYSYvgzkshElmwsZGWP/0J1ZFE6rXXYDcbSLIYSLYY0UZIc2AhhoOqKtxwRjE1rR4qsiMftB6pfPv307nmTaxTJmM7ck0xEuS5rOQtnIIv+/OEfT7MR3qOJTrN4UBzSM+YePEHw2yvaSPVbqYk3R7vOEKMOaFQCE3rKS4qiiJFDSGEEEKIESriwsYjjzzCnXfeyec+9zmCwWDPwQwGVq5cyUMPPQTAhAkT+PWvfx2dpKPU3z6oZc2uRuYUpfDFs8oG9dxwWGdfUyfJFiOZyZYYJRQicv5Dh/BV7kW12Qg2NTG3OI+CVCsuqwmDpsY7nkhw4a4uOv75TxSbjaSzz0bRRvcdzukOc0RLC40Gns1b6HjjDQL19VjnzBm2RtzRYi4vj3cEMYK8f6CFP75TTbrDxF3LKkiyGOMdSYgxw+/3s3PnTjIyMsjJyYl3HCGEEEIIMQQRFzYcDgePPvooDz30EPv27QN6pvI6jrkDcMaMGUMOONolW47cwW795ENt13vv0fX2BpKWnIN16tQTPnfLwTb++O4BUmwm7jxvPA5zxP+cQsSEZcIEki9Yjmq1YszNRVEUcpzWeMcSI4R31y7cr76GardjmTABU35+vCPFlK7rVLd0YzVqY65YbZ0+jUBDA9ZpU0dcUSPY2Ih3xw7MFRUYs7PjHUeMAMkW45HrPyNGKfILMaza2toIBAK0tLSQmZnZO3NDCCGEEEKMPEMeCXc4HEw70gBUDE6gvp7z8q3MLBxPZtIng1jd775L96ZNGFJTTlrYUBQYWcM/YqxRrVacy5fHO4YYoUxFRVgmTURzJGHIyIh3nJjbVd/B4+v3YzUZuH3JOFLtpnhHGhatXX4+VlyMv/5GHCNsxoo3EOLtR58iedtG8s9eQPaXvhjvSGIEmJLn5M7zxmM3G7AYZVBViOGUmZmJqqokJydLUUMIIYQQYoSLuLCxevXqfrcrioLFYqG8vJxLLrlE1iw9Ad++fbT89rcoFgvZX/oSBoOt9zHH2eegpaRgP/30kx5jZoGr564/q0FmawghRh1DWhoZt94a7xjDJhyGsA6hcJiwrsc7zrA5uiTjaSWpg16SMd72NnayyWuiVLVjd6QxXPM1/MEwDR1ecpxWNHXwtzjowSBo2oibHTMQgfoGAjWHsEyciGpN3BmCY21WlhDxpB95Tz36mpeenh7POEIIIYQQIkoiHg3fsmULmzdvJhQKUXGkWebu3bvRNI0JEybwi1/8gq9//eusX7+eSZMmRS3waKF7vYS9PhRdYeP+FgKNQU4vTcNkULFOmYx1yuRTHkNRFMoy7PiC4WFILIQQIpYm5iTxxbNKsRi1MdVrI9VuIsVuIm0EzlApTLXhWnIunfPnUbB4+K51/vL+QTYdaOXciVlcMG1wa8R7d+2i7bnnMJeV4frMZwZc3AiEwrxf1YrdrDE1z5mQRRE9HKb1j3/Et28fyRdfhHPZsnhHEkIkgOrqakKhEMXFxaiqLP8mhBBCCDFaRFzYODob4/HHHyc5ORmA9vZ2br75ZhYuXMiqVau45ppruPPOO3nllVeiFni0ME+YQNrnV1IbUHluVyfd/jaSLAZmFLjwV1WhWiwYB9DQ7i/vH2J7TRuXzsxjdpHMjhGJr8HtpaHDR0V2kqwtLsQxFEWhPDMp3jGG3flTcphTnDoiCxtJFiOr4jDLpN0boNMXpMMXGPRz/QcO4Kvcix4Iovv9KOaBFdE+rGnnT+8ewGY28LVzxyVmvyRFQU1ORnU40OyOU+8vhBj1PB4Pzc3N6LpORkYGSUlj731WCCGEEGK0iriw8dOf/pTXXnutt6gB4HQ6+bd/+zeWLl3KHXfcwfe//32WLl0alaCjjaKqWCZOJNMXJOfwXrr9IbKSLfh276Hld79FMZvJuPVWDCeZKq3rOnsaOqhq7qa6uVsKGyLh+YIhfrN+PzVtHj47p4BF40d/3wQhRF+6rve5219TFbJkWZ5BuWpOAXOLU6nIHvwAnW3uXAiFMObnow6wqAGQZjeT5jBjN2sJu/yloiikXnctoZYWDNLIXQgBWK1WysvL8fv9UtQQQgghhBhlIv5k2t7eTkNDw3HLTDU2NuJ2uwFwuVz4/f6hJRzlHGYDXz1nHGFdx2LU8DYAKCiK2tMd/CQUReGzcwrY29jFnOKUYckrxGD49u7FX1WFddYsDCkpqIqC0aBiMqgyW0OIMciz/UPcf/871lkzST5y44Ou63xc14E3GGJ6viuinhFjTZqjp8gQCUNKCsnLlw/6eYVpNlafNw5QSLIYIzr3cFAtFtTc3HjHEEIkkGNvxBNCCCGEEKPHkJaiuummm/jP//xP5s6dC8DGjRu56667uPTSSwF47733GD9+fFSCjmYmwycDvOZx40hfdTOKxYIhLe2Uzx2XlcS4LLn7SCQePRym7dln8e3eTbi7G+fFF2PUVG5ZVEpLp5/CVFu8Iwohhplvzx68H38MCiSddx6KolDb7uV3G6rwBkLcfGYpU/Kc8Y45IoTDPc1w1WEsBL21t5m3K5u5YGoO88tOfY0iTuyDQ21UNnSyoDy9d8aS7vcT9njQnPI7IMRQdHZ2UlNTQ1lZGQZDYs4wE0IIIYQQQxfxld4jjzzCnXfeyec+9zmCwWDPwQwGVq5cyYMPPgjAhAkT+PWvfx2dpGOEoiiYiovjHUOIoVMUTCWlhLs9GPPyejcnW4wkJ/DdvkLEU7c/SE2rh8I0G2aDFu84UWc/fR4oYB4/vnc5KrtJI8liwGRQ5bVhgFq7/DzxdhWqAp9fUILTOjzft511Hext7KSyoUMKG0MQCus8v7mGXfUdaIrCJTPz0INBmh7/LftrmshfcSG5c6bFO6YQI5Ku61RVVeHz+aitraWwsDDekYQQQgghRIxEXNhwOBw8+uijPPTQQ+zbtw+A0tJSHI5PmjXOmDFjyAFHK13XIRhEMfYdjAgcPoy/uhrLpMloDnuc0gkxdIqi4LricvQLL0C1yewMIQbi6Y0H2VLdytkTMrlsZn6840SdMTcX12WX9dnmspm4fck4giGdlBHYQDwe6tq97G3sRFWgwe0dtsLGihm5jMtyMKtQlr8cClWBGYU9y66VZfZcN+t+P1sPd/BcVypZmw7zjWmTsJnkTnMhBktRFMrLy6mtrSU/f/S9jwohhBBCiE8M+RNTdXU1tbW1+P1+qqqqerevWLFiqIce1dwvvohn+3acF1+MdVrPXXm6rtP65JP49lSSfOGFOC+8YEDH6vAGMKgqVtPou7tXjGyKqqJIUUNESA+H0T0eVPvYKfKGwnrvn9EoUFeH7vdjLCzs00A8kXs2JKLyTAeXzshDVaEkffh+P8oyHJRlOE69ozgpRVG4ZEYeK6bn9v4eqDYbtiXnom05jJqZhT46XwKEGBYWi4XS0tJ4xxBCCCGEEDEWcWFj3759XHbZZWzfvh1FUXpmIEDvB7RQKBSdhKOQrut4P/4YX2Ulvv37sUydSr3bh8tmQEtJRXM5B7y+8sGWbn6zfj9Wk8aXF5fJMh4iYYTa2+l44w0M6enYFyzofW043O7lmU0HyU62cNmsfGkULPql6zptzzyDd8fHOFdcjG3WrHhHGhZXzS3g9NK0UTl4HGxspOnRR9H9ftI+/3nM5eXxjjRimQwq507KineMhBRsbES12RK+INruCfC3bbU4LAYunJqDQVM5/YyppJYVk2IzYTfLbA0hBiocDlNVVUVOTg5WqzXecYQQQgghxDBRT71L/+644w5KSkpoaGjAZrPx4YcfsnbtWubMmcOaNWuiGHH0URQF5yWXkPKZz2CfP5+1uxv5z1d38cd3qnFd/Tky7rgD+4IzBnSsli4/LV0+Wjp9dHqDMU4uxMB5PvwQ9z9exv3yy4RaW3u3767vYNOBVt6raqG12x/HhCKh6Tr+qioChw4RqK2Nd5phk2QxMiXPOXpn4OlH/8jt6CNVg9tLY4cv3jH65fnoIxr+++c0Pfprwr7EzHjU7voO1uxu5M1djdS1ewHQVIWJOclkOy1xTifEyFJbW0trayuVlZW9N9sJIYQQQojRL+LbwTZs2MC//vUv0tPTUVUVTdNYuHAh999/P7fffjtbtmyJZs5RxzJhApYJEwBw19bS1u2npTuAajKhZQ38LszJuclcM68Im0kjRz4IiwRiLi7GMnEixuwstOTk3u1T8pycOzGLzCQzabKevjgBRVVxXXkl/qoqrDNnxjuOiAJDRgbpq27uWYqqqCjecUQEDrV28/Cbe1EVhVsXlyfcAHy4o5NwZwdhkwnd7wezOd6RTqg8w8G8klSSLIY+38e1uxv4qLaD86dkD+syY0KMZNnZ2XR3d5OTk9NnmUMhhBBCCDG6RVzYCIVCJCUlAZCenk5tbS0VFRUUFRWxa9euqAUcC86emElGspmiNBuEw+iqOuCLcoOmcnppWowTCjF4xrw8Mr92x3HbU+0mrj1dBjXFqZlLSzGPsTWydV1nV30HqqIwLtMx6gZojLm58Y4ghsAXDOMPhlEVBV8w8ZYctc2aiWIyoqWkoB25Rk1UKXYTN5/Z9/UtFNb558cN7K7vIMdplsKGEANkMBgYP358vGMIIYQQQohhFnFhY8qUKWzbto2SkhLmzZvHAw88gMlk4le/+pU0axskh9nA6aVp+A8epOGRpzBkZJB63bUoRumXIYQQY8m+pi4eW78fBfjy4nKKZWBTRJEeDtPx+uuEWlpJWrYUQ0rKoJ5fmm7nCwtLURUoTLXFKGXkFJNpRPXjWbOrgbcqm1g+NYdZhSloqsKSiZlkO61MLxjcv40QY01zczMGgwHnAPsSCiGEEEKI0Sfiwsb3vvc9urq6APjBD37ARRddxJlnnklaWhpPP/101AKOJYGDB/Ht30eow02oowNDamq8IwkhRET0QABUFUUbpb0iYsRi1DAbembtmY0Rt8FKSOHubvxVVRgLi9AcUrAZqg9r2lm7p5H5pWnMLBzYIHiwqYnONW8SbGnBVFSIYf78QZ1TURTKMuzUtXsJhHRMhsSaURSoryfY2ISlYvyIuDlk04FWtte0U5BqY0a6Gc8H2zk9N4dFi8viHU2IhNbZ2UlVVRUAEyZMwG6X9xQhhBBCiLEo4sLGsmXLev9eXl7Ozp07aWlpISUlZdQtnTFcLNOm47y0A0NKCtog76IUItF4d+0iUFeHbc4cNIcj3nHEMAocPkzLH/6A5nCQesMNqLbEu7M7UeW5rNy2ZBwKChlJidsfIBLtL/2DrnXrsM2ZQ+r118U7zoj3zr5m3tzVSDCkD7iwYUhNxTpnNqGmJkxlkQ2e//2DOt7c3ci80lSumlsY0TFiIezz0fLEbwnU1+O64nIcCxbEO9IpLZ+SQ16KldNL0uh65x3ann0OY0EBWavvRDFJDyohTsRut5OWltb7dyGEEEIIMTZFXNjoT6rMMBgQXdcJHDyImpTUZxkIzWHHeUzBaKA8/hA1bd0UpNowG+TuaBF/YY+Htj//BX9NDYR1ks45u8/j/mCYNo+fDIdZCqGjUKCuDn91NZrdTqi1VQobg5SZlFgNmaNFURXQNNBG10yUeDm9NA1/MMz8soH32VIMBlIuv3xI5+30Ben0BenwBod0nGhTFAXFbEYxmVBHSFFgUm4yk3KTAeh2udBSU/ClpPPstsMkWU2cOykLTZX3SCE+TVEUiouL0XU93lGEEEIIIUQcDaqwUV1dTWHhwO/Oq6mpIS8vb9ChRjvv9u20PvU0mstFxlduRbXbqWzopK3bz/QCF8ZBDvr8+f2DbDrQwuKKTC6flR+j1EIMnGIyYczPR9fDGLOz+jym6zp/ePcAO+vcrJiex8Jx6XFKKWLFMmkSweWXsjtoxOpKR+afCYDkCy/EOm0aRrkuiIopeU5KM+wEw8M7sHfR9FwqspMoy0ismXiKyUTaTTcSamvDWFAQ7ziDZp05E1NREZtagry64SAOi4HJecnkp0hhWAiAQCBAW1sbGRkZvdvk5hghhBBCiLFtUCPoc+fO5Ytf/CIbN2484T7t7e08+uijTJkyhWeffXbIAUcjPRhEDwZ6/ug67d0Bfvv2fp54u4pNB1oHfbxgKEwwpBMMyV1LIjEomkbqDdeT9fWvY5k0qc9jug5NHT5auvy0dvnjlFDEkmo28w9LIX9qtvDSh4fjHUckCNVsxlxejmq1xjvKqNDeHeC//1nJg6/u5mBL97Cd12k1Mqc4lRR74s2K0JKTMRUWjsjBTkVRMKSlUZbjYmq+k+n5rlG3HJ0QkQqHw+zZs4fq6moOH5brCiGEEEII0WNQMzZ27NjBD3/4Q8477zwsFguzZ88mNzcXi8VCa2srO3bs4KOPPmLWrFk88MADXHDBBbHKPaJZZ8xAtdvRkpPRHA5M/hBOq4lQWCfZMvhml5+ZW8BpJWmUZcoasyJxKJqG0s+6x6qqcO3pRRxo6mJqvjMOycRwSHOYSLX3/BFCRJ/bG6Cly4cvGKatO0CBrAY6ooU9HnSfj3SXi9vOGRfvOEIkFFVVSUtLo76+nhTpQyiEEEIIIY5Q9AgWJ/V4PPz9739n/fr1HDhwAI/HQ3p6OjNnzmTZsmVMmTIlFlmjwu1243Q6aW9vJzk5Od5xenX5gnT7QxHdnRcMhdmwrxmAM8rSZT1mIUTcBUNhmrt6+qio8po0KB/WtLN2dyOnl6Uxa4BNocXYo+s622va8QbCzC5Kkff+EUjXdfY0dKL4vDif/xOhtjZSr70Wc3l5vKP1kajXzsNJvgeJIRQKoWnST1AIIYQQItEN1/VzRM3DrVYrV155JVdeeWW084xZdrMBuzmyXu57G7t4ZtMhALKSLYzPSopmNCEGLVBXR8drr2MsKSbpzDPjHUccQw8G8e7cheZyYcqPXa8DTVVo7PDR1OljUk5yREvDhH0+FIMBZYwNYryzr5k3dzcSCIWlsCFOSFEUpuW74h1DDMG+pi5+vW4f1u4OrqtrxOrtItTWFu9YQiSMlpYWUlJSeq8hpKghhBBCCJFAAh7oaoLuZuhugq7mT/7eVDssESIbSRdRp+s67X/9K769+3Bdfjnm0pIBPzcjyUx+Ss+a5RkOWY9ZxJ9n+3Y61qzBtK8Q+5w5/a6pf7jdi8mgylJFw8yzdSstTz1F0JVKwdduR3PEpgHw3sYufvt2FYoCX15cTkn64JbK8+3bT+tTT2LIyCRt5Q0oprHzc3J6aRr+UJj5pWnxjiLEcXRdZ+fhDnzBMNPynDIjawhMmopJUwknO7F+5rOkhLxYp02LdywhEsLhw4epqamhpaWFsrKyEdk7RwghhBBixNB18Lb1LU70Fi2a+y9gBLpOfDzf8PSBlsJGgtA9HjzbPsB/8CD+fXsHVdhItZv42rnjATBqg+oHL0RMWCZNwn7aXEylpSgWy3GPVzZ08pv1+7AZDXz1nPKEbEI7aplM/M1YwJ5AGp+r6WBuRWwKG3azhs2koSgKNtPg77AMHq4jcKgG3esj1NWFYQwVNqbkOZmSN7r6z+i6jm/3HhRVwVReLgNUUdLa5WfrwTZKM+wUpQ1Pn63adi+/fbsKXzDMFxaWjLqf1eFUkGrjtiXjUBTITPrkvfLDmnY+ONTG/LL0QReFhRgtLBYLqqqSlJQk7xlCCCGEEIMV9IOn5UhB4khRoqv5mL/3U7TQQ/FOPWhS2EgQusVK+/zFOCrqsc6YMejnS0FDJBJTfj7pX/rSCR/3BkL4gmFUJUQgFB7GZMI8eQoNM7w0tAWo6Q4zNwbn6N6yBcuePdw6ax6mnJyIClfWGTNweX0Y0lIxSKPQEc+/v4qW3/0WFIX0W27BVFgY70ijwr921vPitjom5SZz97KKYRn8sxk1HBYDxkCIJItcRg5VVnJPQUMPh1HUnmu5lz86zPtVLQTDuhQ2xJjlcrmYPHkypjF0Y4MQQgghRL90HfydJyhO9Fe0aAZfe0yihFHxGJx0ak7alWRaSKYx7KAh6KA2YKcxlEQLSdT7DMDdMclwLPlEGgfB1lZCTU09d7MfWSt2w95m/tKaTF5KFl9zpcY5oRCxNSknmS8sLMFq1MhMPn5Gh4gdTVO5evFEdtd3MKc4+gUDPRzG/Y9/4Nu1G6fZgqu8KKLjqDYbSeecHeV0Il5UswnFZEZRVRSzLJkYLTkuKzkuC/kp1gEVNUKdXfg+3oGxsAhjVmZE50yxm7jtnHGEwrosJRglnu3baf/b37DNmkXysmWcVpxCIBRmqsyGEWOMx+PBaDRiMPR8RJWihhBCCCFGpXAIPK2fWt6pCbpbPrUE1DHLPoV8MYkSUEx0aC7alGRa9SQaw0nUBx00hBy0kESLnkyL3lOsaNaTcWMnzKlvrg/r3THJ+2lRK2x4PB6s/ayjL/rS/X6aH3+cYF0drssuw37GGb2PKYDMtBZjgaoqTM6VAZt4sZsNbD3YRmVDJ6sWlWIzRa/GragqtrmnoVqsGMdXUNfuIcNhxiCzysY0Y14eGbd+GRQFQ3p6vOOMGvNL05ic6yTJPLDf4c43/oX75VcwV1SQcdtXI57h4bQaI3qeOF5rl5+96zfj/OhjFE0jedkyFo3PZNH4yApPQoxUXq+X3bt3YzAYGD9+PEajvM4IIYQQYoQIeE/Rk+JTRQtPKxCbHhSdahLtJNFMMk2howWKI8UJPemTv5NMs56EBzM9I9KRsxo1UmxGnDYTKTYjLpsRK34ejM7/0klFbTRr4cKFbNq0qc+2nTt3MmHChGidYlSbX5ZGZrKZDIcZk2HwA4D7Gjt5r6qFGQUuJmQnxyChEGI0CBw+TNWOQxxq1rFbTbR0+aNa2ABIPu9cks87l79tq+WNV3ZxWkkqV80d3NJDwaYmgs3NmMvKUAxja3JhKKzz5q4GPIEQSyZmYTEOvkdJIjJkZMQ7wqijKMqgigxqcjJachIGl3PUrVkfOHyYjn/+E1NJCY5jbhpJdC9sq2VLIIuzpp7J8osXxjuOEHGj6zqKoqCqKqoqN0MIIYQQIk6ONtHu/nR/ik8XLY5Z9ulkTbSHIIhGm9JTiGgMJ31SnNCTaaZnhsXRmRStehKtOAgOYajfpKm4bEZSbCacNmNPkcJqwmXv+e/RooXLZiLFZsJlM+K0Gvsds3C73SOjsPHiiy+yY8cOOjs7OXjwIAUFBb2PXXXVVWzbtm2opxhVFJOJtBtvJNjYiLmsrHe7piqMz0qK+Lhrdjfy6keHOdzulcKGGBEa3F72NHQyKSdZmocPk7DPR8tvf0f24cNcuOBizJMmkuuM3VJgbZ4A7Z4Abd2BQT0v7PfT/MRvCR6uw3X55X1mto0Fh1q7efGDOjyBELkuKzMLpceIiA7HmWdiqahASx3akpe6rtPS5cdpNSbMbCzPtg96ChtFRdhmz0YdIUuepdlNGHNyCJdOwTIxP95xhIgbq9XKhAkTUBQFTRsdBX0hhBBCJIBQ4PgZFCcrWnQ3QzgYkyhdWGjWk2nRHT1LPB0zk6K3UHHM393YiGQ2haYquKzG3iLF0WKEy2okxW7CaT12+9FChRGrURtxN8ANubAxZcoUDh48SFNTEzfccAPV1dXk5eWRk5Mz6CnEa9eu5ac//SmbNm2irq6O559/nksvvRSAQCDA9773PV566SX27duH0+nk3HPP5cc//jG5ublD/d8YVoaUlKg3w52e76S2tZuZBa6oHleIWHlm0yHeP9DKkgmZXHt6ZH0YxOAoqopitWKxmOlEY/3HDSgonDspKybnu2haDjlOC4WptsHlPJIVVev5M8ZkJJkZn+Wg2x8iP2Vw37tE5duzB89HH2GbMwdTvgzeRks4rPOPD+to6vRz8fTcU/a8UFQVY3b2kM+7bk8jf99+mKl5Tq5LkNdvy4QKbLNnYy4vRxlB6/Ivn5rDnOIUUm19M3sDIYBRM2NLiP7ouo7f78d8pBApPTWEEEIIcVK6Dv6u4xtm99eT4ujfY9VEW1do5WiB4pOZFEf/3qwn03qkR0WznkQrSfgY3LWOovQsA9xTpDD1LVRYTaTYjX2KFEdnWiSZDSOuQBGpQRc27rvvPmbNmsXs2bPJysqipKSEW2+9lSlTprBo0SIAampqOHDgAFOmTBnUsbu6upg+fTo33XQTl19+eZ/Huru72bx5M/fccw/Tp0+ntbWVO+64gxUrVvD+++8P9n9j1JmYk8yGvS28u7+FiTnJ0pBZxI2u63S9/TahlhYcixejJfU/Eyk9yUya3US6Y2TcVTsaKEYjaTfdSKitjcZd3RyubuOw2xuz8+k6bNjXzBu7Grh5YSnF6faB5TSZSLvpRoItLZiKi2OWL1HZTAa+dFbPjL7RcjHi/sfLdG/aRLiri9Rrr413nFGjqdPHml2NtHT5Kc90sKB8ePqXNHX6aezwUteeOIOQpqIiMr7ylXjHGDRvIMSzm2vwBEKsnF9MRpKZxg4fj67bh6YorFpUKk3axaik6zpVVVW43W7Ky8ux2wd2jSCEEEKIUSQcPrLs0zHLO/W35NOxPSqCsRnD8OlGmj/VLLunKNFToGj+VOGiHceAmmgflWQ2kHlkSadjZ0n0W7Q48liSxYimjo4xgVgZdGHj+9//fu9AS3Z2dm+RY9asWdTW1pKbm0teXh55eXmDDrN8+XKWL1/em4We6QAAmDtJREFU72NOp5PXXnutz7b/+Z//4bTTTqO6uprCwsGt3x4v/oMHaX/xb5hLS0hatixqg1bNnX72NXXS7Q9xqM0jhQ0RN6HmZtwv/YNgSzOGtLQTLiN0+cw8FldkkG6XwsZw0hwONIeDKxwepuS7mJoXuybunkCILm8QbzBMp29wUzk1lwvN5YpNsBHgUKuHtXsamZSTPOxLUem6jvvvf8d/4ADOFSswHbPEZKQsU6cS6uzAIn23oirNYWZ+WRpNnb4BLWfpP3QI3e/HVFIypOuPJROySHeYKRlgsVKcWGOHj8qGTryBEDVtHjKSzDR3+ah3e9EUhZYuvxQ2xKgUDofxer2EQiFCoVC84wghhBAiGoJ+8LT0X5DoXfqppe/f9dhcB7TrtmOaZX9SrDjaj6K3iHHkv90DbKJ9tFF2zqdmSfT2ozi2aHHk706rEWOCLOE72gy6sDF37lzq6uq48cYbSU9PZ/PmzTz33HP86Ec/IhQKkZGRwaxZs3jppZdikbeP9vZ2FEXBNYIGv7w7d9L9/vsEGxpwLFqEYovOMiN5LiuXzczD4w8xKUd6bIj40ZxOLBMnEGxoxFR04iVKDJpKZpIU4OIl12Ul12WN+TlWLijGGwjL69IgvbOvmb9tq2V/YxczClzDOnMj3NVN1XvbeLHFSEnyDj53bf6Q7xJJOnsxjrMW9SwxJqJGUxUunzWwpb0CDQ00//o36H4/qZ9fiWX8+IjP67QZOa0kFV8gHPExRI+CVBsrZuTiC4SYkN1TnBqXmcRVcwvQFIVSKR6JUUrTNMaPH09XVxfJyXKNIIQQQiQkf9cxRYpjl3jqp0gRw2Wfgrp6ZNZEf0WJT5ppH+1X0UrSKZtomzQVl72nMJF7pDDxSZHC1O9MihM1yhbxM+jCxrvvvssTTzzBd77zHebOncuDDz5IWVkZPp+PrVu3snnzZrZs2RKLrH14vV6++c1vcvXVV5/0Ytjn8+Hz+Xq/drvdMc92MtZp0wg2NGAqKkKNUlEDQFUVzhyXEbXjCREpxWgk9brr0HX9lIOxh1q7URSFvBgPsIv4mZAtgxWRmJSbzO56J5Nykod9OSrVbuPwjDPY+bGbdsXF+d1+0qKwZJwUNeJLUVUUTUPXNJQhNub1+EP8Yk0lrd1+Vs4vZtwAZouI/mmqwtkVmcdtO6NseJYVE2K4BYNBDIaej6CapklRQwghhBguxy379On+FM3HFzGCnphE8eimIw2yHccVJY421G4+prm2Gxv6CZZ90lSFFNsnvSYKTtAoO8Vm/KRoMUIbZYvjRdQ8/POf/zxXXnklP/jBD5g1axa33nor99xzD/PmzWPevHnRznicQCDAZz/7WXRd55e//OVJ973//vu59957Y55poIxZWbK+uBgTTvUGcbClm1+u2YuiwJcXl42aJskjSb3biwKydF0CKk13YDZovH+glUm5Tiqyh2/gWFEU5iw9gwPph9AUBbtZ7kgZDQzp6aTdsgo9EMAYwXKhx/IEQrR0+Wnr9tPS5Y9SQiHEaOd2u9m7dy9FRUWkpqbGO44QQggxsoUC/RQpmo9prP2p/3Y3D9uyT0ebZTf3LgHVt1eFh+PHII42yk6xHS1GGCk8RaNsl82IYww1yhbHi6iwAeBwOHjggQdYtWoVq1evpry8nB//+MfccMMN0cx3nKNFjQMHDvCvf/3rlHf5fPv/s3ff8XHUZ+LHPzPbm7apd8mSe8M2NsYUAw69BUICIQlJSIc7CPfLJbnfpV35kXKXu8tdQnpCLoWEEFIoTgi9GIwbtjHutnrX9l7m94dkYdmSrbLqz/v1kq3d/e7sd2dmZ0ffZ77P8/nPc9999w3cDgaDVOQgX7gQYnyymoamaWj0FZkWk6vZF+W7zx9BAT65sW7C01KJ0YmnMvijSfzRFP7o5A8ce2xGIokMhzvDlHusXLGkeNL7IEYuk9VQlbMHlA1FRTl5PY/NyPvOq8IfTU16DRghxMzV29tLNpslEAhIYEMIIYQ4VTIyREBiuCBFN8QnMu2Tvb8uRR49OPANBCcG16XoGSbtk8Okx3VKoezKQTMpTq9HIYWyxViMObABfVOJE4kEt912Gx0dHXzoQx/i2muvnbAT1RNBjUOHDvHss8/i9XrP+hyTyYTJNDeKEx/vjvDM/k6WlOaxrvbs60aIqVTltfGuNeUcbA/Ll9ckyUajxHbvxlBcTMpeQCqdRVEUUpnc5snXkknQ61FUlabeKC8d6mZRaR4rK1w5fZ3ZzG0z8oHzq+kOJaZsvelVBb1OQScfz2ntQHuIh7c1UV9k591rKibtaqVF06xuTiYUIhuN5ix4M9Uae6LsbPSxrNxJbYF9qrsjRE5UVVVhs9lG9DecEEIIMaNls331JiKn1qToOeW+HrT+mRbKBKV9imuGk1I9DQ5K9NJfs+KkWRUnp32yGnWn1ZpwWg1UnVQo+8TMCddJdSikULaYLKMObHz1q19lz5497Nmzh/3792M2m1m+fDlr167l4x//OE6nc8ydCYfDHD58eOD2sWPH2LVrFx6Ph5KSEt71rnexY8cOHnvsMTKZDO3t7QB4PB6MRuOYX3e22Nbg46l97TT7oqyt8chULDHt7W0J8sz+DnzRJJ+6pG6quzPrRV59Df8jj2AoL6Pyvvu4bFERu5p8BGKpnL1G8vhxeh/6NfqCArzvfx+vHu3h0Z3N7Gmxs6LcOeLjUiYcRjWbUfTjir/PaJmsxlP7OjjWHeG96yon9ZiuKAof3FBNRzBOtVeKF09nx7rD7G8PEktmuGFl2bDF7LKRCImjRzFWV6NzzK6aGNlIhO7vfZ9MIIDn9vdiXrhwqrs0bn/Z185T+zpY1+XhvssXTHV3hBizbDaL2l9jSVEUCgqkJqAQQogZKJPqK5Q9bE2KbrRoD1qkGy3SjRrrRRlh2qfR/pUX1KwDgYiTgxWnF9bO60/7ZMKo050ShHg7SFE9RKFst9VAnhTKFjPAqEeM/uEf/oHq6mruuOMObrvtNubPn5+zzmzbto1LLrlk4PaJFFJ33HEHX/7yl/njH/8IwMqVKwc979lnn2Xjxo0568dMtaLcSas/xvJRDB4KMZVKXWZKnRbK3JIGaTLo3C50Hg/6/AJUvZ6m3ijbG/yY9DqWl7ty8hrJlhZSjQ1koxEykQi1BTaSGY1mX4y32kIsLj37Vd6xPXvxP/IIxqoqPHd8YM4WnW7oiXKkK0xG00iks5N+Uukw900HHq9sIkHklVdQLVas69bK91OOra5y89d9HQTiKRp7o8wfppB34PHHibz0MtY1q/HkIG2oP5rk1aO9lLstLC0b+0UtuaClUmSjEbRYlGw0OqV9yZVKj4VIIs1bbUFa/DHKJF2gmIEymQwHDx7E6XRSWlo61d0RQggh3paMnhSk6B08qyLSTTbSQzrcBZFu1FgP+mTwrItUGH2QIqMpAzMoTtSf6D2paHav5uifbdFfRFvNw2axDErhdOJ/t9VIzYl6FFIoW8wRow5sXHjhhezatYuvfOUr/Nu//RvLly9n1apVAz9Lly5Fpxvb4MvGjRvRzpBs/0yPCagvclA/zICGENPRRfUFtPri9EaSBGIpnBYD4S1biL76Go7LLsWyfPlUd3FWsaxcibGqCtVuR9HpWFPtIRhPs35efs5ew7pyJVo8js7tQedyMc+UYllZHv5oinAiPaJlpDs7SLW3oxj0aKkUyhxJJ3iqdTUesppGudsyJVfKZLIae1oCWI26YQfLRyK+bx+BR3+ParNhrKzAIINbOWU16jEbdXSHkzT2DB/YUIzG/p/cfJ5ePdrLr7Y2UO21UVdon9KruXQuF9477iATDGJetGjK+pFLi0qczCuw0RlKcLA9JIENMSMFAgGi0SjJZJKCggIMhvEHy4UQQojTaBrE/f0pnganfsqGu0mFusmEu9Ai3ehiPegTPvSZM6d9UoGx5IVJaIa3Z0ycEpQ4tS5FwuRBZ3XjsplwnhSc6CuWbaDaZny7JoXViMtmwCGFsoUYZNSBjeeffx6AQ4cOsX37dnbs2MGOHTv4xS9+gd/vx2QysWzZMrZu3Zrzzoozy2Q1fru9ic5QgltWV1DsNE91lyaFlsmQOHAAndOJoaxsqrsjRqE9GGdnk49YKsPycherq9zEXt9GdOcO9PleCWzkmKIo6E+qgbSiwsWKHNdvUG02HJddNnDbZTXywQ01+KMplpeP7Kpu67p1KHo9htJS1Dka1IC+OhtXLyuZstd/szXAT18+hsWo495N8ynKG9t3iqGkBENFBTq7DZ3LldtOCmwmPTevKqctEOfc6uFrnOVdfTWW5SswlOUmsFTutlCSZ8ZpMaCfBn9cGauqproLOVXutlCTb6fJF2Pb8V4uWVg41V0SYtQ8Hg/ZbBaLxSJBDSGEECOXSb+d6ulEmqdIN8lQN8lgJ5lQF0T7Z1LEfZhSPnTDpH1SgfH8RRnULKelejq5iHYPDqI6F2mLB82aj8XqwNUfkHCfVIeiymrEbTPgPDGbwmJAL3UohBi3MScvr6+vp76+nltvvXXgvmPHjrFt2zZ27tyZk86J0emNJNne4KM73FdsdjoGNtI9PQDoc1g0MLZrF76HHkLnclPwt38z63KHz2YlTgsX1OUTTWWoL+orjmq/7FIi7nwya9ZMce9mv0xW47kDncRTGS5bVDRhV1yXOi10BhO0+mNUjaBeg85ux37xxRPSFzFyNpN+4MesH/u+YSgupvDee0BVUcY4o1Oc2TmVbs45SxvVaMRUW5Oz15xf5MBpNdLki/J6g4/186QYcC4pisLKChetgRiFYwwqCjEd5OfnblaoEEKIGSoZPSlI0UMy1Eki0Eki2Ekm1Be4UON9QQpz0oclc3raJ4W+AMV4ghQZTcGHo3/2xOmpnvxKHimjm7TFC1Yvqj0fh9WK23ZiFkVfUKLCOrhottShEGLq5LQqa01NDTU1Ndxyyy25XKwYoXy7kXcsLqI7nGBp6dTmux5Kqq2Nl7/3S17OOLn0xo2sX52bYtFvp9cwyqDZDGPUq7xrTcWg+wLl83jwCHA4ySfL4jKgM4GafVEe291GLJWhxGVhVaV7Ql7nlSPd/GZbE+VuK39/5QJM4xgkn2syWY1EOoPVOPlF1OcV2Pn0O+Zj1KvkjbPWhiJX6k6oeCrD68d78diMLJmk7/9sf3rQTFYb+F3k1sULClhcmofbNpZECOJk999/P7/73e/Yv38/FouF888/n6997WssWCCF2XOto6ODcDhMTU3NQNFwIYQQs4imQTwA0R7SoU6i/g7iga6TZlL09M+k6MWc9GFN+zFp8UGLMPb/jPeS1FPTPr2d6imPuMFFwuQmY/aCzYtiy8dk9+KymftnTvQFJipOKqZtlzRPQsw4kz9SIiaMoii8Y3HxVHdjWNl4nB0JE69rVvRHenIW2DAvXcqha9/HW8EMV0Q1aqw5WawYo2w0Snz/AYwV5egLCkb9/HAiRSieAkUhlEgjyTcmTqHDTJHDyP72EL5IcsJe58RJo8dmRC+DHCOWyWr85OVjNPREuXVtxaQNWJ8s3z53U4HNJNsbfPzi1Qa8dhN/f8VCnNaJDySZDTruvLCGrlCCBVLfa0IoiiLB/Rx5/vnnueuuuzj33HNJp9P8wz/8A5dffjn79u3DZjv7TEIxMqlUipaWFjRNw+fz4c3hDG0hhBATJJNGi/YQ8XcQ7e0gFujsC1L0F85WYr0YEv1BipQfezaAnr60T3ogr/8nF06kfTq5iHZQ5yRhcJEwesj0p3tSbfkY8gqw2Z24bKaBAtrl/f87LQZ0qgQohJgLJLAhJo2xuprzr76Anbt66dCMtAfiOUmXpWnwXFeW/e0hCvJ91OTLH6hTKfTc8wSffAJT/XwK/ubus17xkM5kaeyNUpRnxqpqFB/dx3sKdBjr5lEr23JCWYw65hXY2dUc4OXD3Vy6sHBCrlBZXeWmymvDYdbLCeYoJNNZ9rUG2dHoQ1Xgi9flTcr6S3d3E375ZYwVFVhXrZrw1xPjV+AwUeAwUegwYzZOXvCw0GGm0CED7xMplcmSymSnZNbWbLJ58+ZBt3/6059SWFjI9u3bueiii6aoV7OPwWCgvr6eYDAoQQ0hhJgi8WiYQE8bUd+JIEVX30yKSDdqvPekmRQ+HJkgeYRQAHv/T66cSPvk659J4SOPsN5FXO8iZfL0p3vKR7V5MeQVYs4rIM9h669NYaTMasBpNchsfyHEGclfSbNMOpPlYEeYwjzTtLvSVlEUypbMp7DtILFkhrZALCeBDVVVuHRRIQUOU84LIYvRU60WVKsNnX1kp0XPHujk8d1tLCh2cIc7gv83v6HMaqFg4V0yDXQSLC13sb3JT77dRCqjYdTnfp0rikKBY3odj2YCi1HHqko3hztDhOIp/NEk3kk4rkd37CDwhz9irKoiWlXH8VCaBcUOHGNMR6VpGmSzkipwAs0vcvD3Vy7EpNdh1E/urKjeSBKrUSe5hSdAPJXhBy8cpSeS5APrq6gtyOVww9wWCASAvuLWIrccDgcOqXcnhBDjls5k8UeTBIJ+Ir0dxPwdJIMdZEPdaNFu1GjP2zMp0j4cmQBOLYBNSTARl50kNP1AXYqg6iSidxEzuEgZPWQsXrJWLzp7PgZHAWZnEVanF7fdgstqYInViM2ok7/vhRA5J4GNWWbL0R4e3tZEmcs6kBt9OilzWbh5VTmxVIbFpbmZsJiNxznPqXFB3Tz5opwG7BdeiKmuHn2+d0TbI5nODvzoPB70Xm9fcET+KM65dFcXmVAYY031wLYpzjOjVxTebA2ws9HHulq5wnI6uWZ5CQa9SqGjL5XXZDDV1mJeuBBTfR2/3NPJK4e7OX9ePp+6ZGzpA4OPPUZs716c112PZemSHPdWnNAVStDQE2VVpXtSUlEB7GsN8vNXGyhwGPnkxropC25kwhES+9/CUFmJoXD2JDAMJ9K0BmL4Ikk6QwkJbORINpvl3nvvZcOGDSxdunTINolEgkQiMXA7GDy9iKnok0gkaGpqoqqqCoPUUxJCiNNomkYwnsYfTeKLJAkHevqDFJ2kQ90Q6ULtT/dkSvZiTflxZPw4CeIlSL6SGvmLjWI4JKRZ8JFHSHUS0TuJG9x9NSkGZlL0pXsyOwuxuItw5rlx24wsNEuaJyHE9CGBjVlGVRR0qoKqwnQc41dVhRKXhaff6sBm0nPeOAdRtXSa3h//hGRrK66bbsK66pwc9VSMlaLTYSwvG3H7yxYVUeGxUu62YrIZKbjnHna3h/n5Ky1sqMuXgfYcyYTDdP/oR2QDAdy33oplxQqgL0++22ZEA1zWiRs439McoMUfY/08L07LmQc+svE4WjyOzuWasP7MFG6bkfecWzGpr2mqq6PwM/8HRVFIP32QZl+Ml490c92KUio8oytipGWzxPbuJXHgIIklRySwMUGyWY1fbW3kUGeYUDzF9StPPwZnwhEUBdQc1hPwR5P4o0l0KiTS2SkLbISffYbg5j9jWrCAwr/9mynpw0TIt5t4z7mV+KNJVsqM1Jy566672Lt3Ly+99NKwbe6//36+8pWvTGKvZq7jx48TDodpaGigri439fOEEGI60jSNeCqLL5rEF00SiKbwRRJEAt0DhbO1SPdJhbN7sKb9ODIBPATxKEEWE8KoZM7+YqMcy8lqCkHFftJMCjdJk4eM2YNmy0fXn+7JlFeIzV2E3VOEy+GgcppdCCuEEKMlgY1Z5rxaL0X9aagMuun5JbW9wcfTb3XQ6o+xrsYzrlkWWiZDOhggHQhwtN2Pxx+j1GXJYW/FRDMbdCwpdZLOZgHQ2W3saOvgtWO9qKoigY1c0jS0rNZXmKafxajjUxvriKUyEzYjIJpM85ttjTT5YuhVhU2Li4Ztm43F6P7BD8j0+vDc/l5M9fUT0idxZieOy1cvK+VwZxibUT+mYLmiqjivv57k0aNY167LcS/FCYoClR4rkUSaYufp34Gpjk56fvJjFEXB+5GPoM9R7vvV1W5UVcFrM541YDmRVIcD1eFA73JOWR8myopyJ22B+MmHbTEOd999N4899hgvvPAC5eXlw7b7/Oc/z3333TdwOxgMUlExuUHmmaK6upqGhgYqKyunuitCCDFiqUwWf7Qv1auv/39/NIU/HCUR6iYT7iIb7kaJ9mBM9GJM9GJN+3FqAbyE8ChB6pUgbsLoleyZX2wMwzIZ1L4ghc75dpBiUOHsviCF1VOEw1OMJa8Al06Pa0xrQwghZi4JbMwyOlWhrnB6p/BZVpbH028ZCMVTdIUSFOaNPQOkajLhuf129h1o5hc9JszPHeZvL5sv+fxnkEQ6w49fOkZXKMH711dTk2/jwvkF6FSFNdWS+zpXdHY73g/fSTYUxFhbO+gxi1GHxThxV1qb9TrqCh3oVJVyz5kDj9l4nEyvj4zfT9rnQz7J8NrRHva3h7hkQSGV3tHNmBivukI7n7liIQDl7rG9tmXJEixLZKbGRFIUhfeuqyKSTJM3RC2UbDBAxucDRSUTCOYssGHS68Y98zIX7BddhHnBAnSzsFjxa8d6eWR7M5UeK5+6pE5SP4yRpmn8zd/8DY8++ijPPfccNTU1Z2xvMpkwmeQbaCRMJhPz58+f6m4IIeaobFYjGE/hj6bwnQhOxJL4In3BilAkSjLcDeEulGjfTApTshdbxj8QoPAoIWoJ4lWCOImgKsNcTTCO60bT6An316RIGj2k+2dSDApSuIqwuotQ7QXozC7cqop77C8phBBzggQ2xKTJhMOkGhtxFZThMBvoDic40BEaV2ADwFhRgdngJPjUQVqCEZp9UQlszCDheJrGnijdkSRt/hg1+TbmFzmYXzS9A3QzkaGoEIpOzz+vaRo9kSQOsx6TfnwBjuiOnaTa2rCdvx69u+9UXFUV3n9eFals9qzL17vduG+7jYzfj3XlynH1ZTbIZjU2721nf3sQh1k/6YENYNTpp8TU0KnKkEENAOO8ebjfcyuKqmCsqZ7cjk0CRVUxlJRMdTcmRCSRJpRIE4ynyGQ1CWyM0V133cUvf/lL/vCHP+BwOGhvbwfA6XRischM39Fqbm7G4/Fgtcr3gxAid+KpzECA4kSQYuD/SN/MinA4TDbShRrtQR/vxpT04SaIVwnh6f+/Ugmysv/3PCV6+gspjHskLKUYifXXpEibvX0zKez56O0FmJxFWFyF6B2FYPWCLR+9KQ+XosiMCiGEyDEJbMwymqbxxzdaOdoV4Z3nlFGdn7tc2uPl/+0jxHbuxHrRRVyycD3doQRLSnOTNmJBkYMSp5muUIBdTX7OqZRrG2YKj83IBfX5/OXNDjqCcTRNQ1EU4qkM6ayG3SSHqYm2o9HHw9v6rgj++MXzxjxwlo1GCfzpj6SamlEtZhyXXjrwmKoqmNSRBU3MC+TKzxNUVeGC+nycVgPLyqYmzc7+9iAvH+pmbY2XZeWzL9XPbBGIpnh0VzN2o54bzikblI5SUdUJq0F1qCPEse4Ia6o9k1bgfi7ZUJeP02KgxGXBKHmwx+yBBx4AYOPGjYPu/8lPfsIHP/jBye/QDNbZ2UlHRwfd3d0sW7YMnW5qausIIaavbFYjFE+fFqDwDaR+6v89kiAWCaFEu9HF+mdRKMH+ehQhvAQpVkIsOek+uxIf/GI5yoSZ1FlJGE8EKbyotnz0jgJMzkIMjkKw5YM1H2x9hbUNRhuG6VjUVAgh5hgZMZxlYqkMW4/10tgbZXFp3rQKbCgGPeh16PQ6rlqa2ysrFUVh44JCVEVh6RQN/omxURQFnarSE0mwvcHHlUtLSGWzfPe5I8SSGT58QY1cMT7B/NEUrf4Y0WSGaDKNY5irvs9GMZsxL1yIajZjrKoa9FirP8ZvtjVR4jTzrtUVctXxKFy2qIjLFg1fl2SivXSom6f2dRBJZiSwMY0d7AzxyuEe7CY962q9k3LczGQ1fvFaA68d7WHjgkI+c8VC1FF8to92hXlmfyfLy12srZHUg0MxG3SSljEHNClSkjNerxe/34/H45GghhBzQCJ90iyKyNs1KfoCFicHK/oKaaejAXSxHtz9gQiPEhxI+eRVgtT1F9E+EbgwK6m+F9L1/+RISu8gZfagWb0otgL0jnwMjkIUWz7YCgYCFH0BCy9GgwW5PEMIIWYeCWzMMlajnquWFtPQE+WcCtdUd2cQ1003YVu3DkNlJZqm0eKP4bYaseXoivzzar10hRI09ERYVubEbJA/tmaKlRUuOoLF1ORbsRh19PgSdIcTxFMZfNGkBDYm2OpKN7/b0UwgmmR7g4+NC05PVzUSiqrieve7IZtFOWWw43BnmDea/LT5TWxaVITXLuniRiqT1djTEsBq1E1JiraVFS62HOmmJ5IgEE3htE5dkWgxvPmFDs6v8+IwGSh2ji/F40ipCpj0KuFEhrfaQ7QGYqOqxfLarqP8ZV8PbYG4BDaEmCF0Oh319fUocqWyEDOKpmkE4+nTAxOnBStOqlURjWNIBvtnUZwITpxI+RSk/KT0Tx4liJsQJiXNRBTJS5ncaJb+tE6OAlRb/kmzKPIHUj5h7fvdoDfmajKHEEKIaWzOBjbiqQzGVOa0+1VFGTTVPz5Em1y0TaQzDHfxmKIwKA/9aNom01nWVHsGru47tU8nD/Yn01myZ7iCLedt9UaoqkHRq2w91stvtzdT4jTz8Ytq0emGTq9g0qsDfzilMlky2eH7cLQrzPMHuwBYVJLHvAL7sG1PXm46kyV9huUaderAFai5bGvQqQNXrY+mbSarkcpkBz2eamoi8MQTGGuqcV9xBYb+fWKotifTqwr6/nWfzWokJ6Ctpmkk0mduW+w0c8f51SQaG+l5/iXcS5fwznPKafZFKXWaB/ZjnaoMpFc523JH03ayPvfT5Rhx6udTr1Nw24wc7Ajz/IEuLqjLR69Tx/e5zw5+r8vKnFyxpJiiPBN2k37YdZE8fpzkC89jWboU27q1Z/3cj+YYMZrP/XQ6RrzZGuDHLx3FbNBx96V1FDpOH7Q+2zHiZCd/PkfSNt9uQq+qbD/eyxN7W3nnOeVnXW6ujxEjbTuXjxEmg8qt51YCnPa5jafSaPE4ivn0WgIjOUac7OTPfSqjcdvaSlLZLB6rCccpn+0zHSPSXV0Uv7iZpUkHa5e4Br3G2fow1s/9bD1GjLbtaI8RZ9ovxdwQCoXIZDK4XC4ACWoIMcWS6eyQMydOrUfhPykVlD+WQstmcBPqmy1xSsqnupOCFicedysh9Obhvy/GSlNUsmYP2PrqUijWMwQpbPlg8WDQzdmhKyGEEGcwZ78d/u43uzBaTh/4Xlbu5N5Nb+d3//Svd5EcZrBjfrGDz165cOD2Zx/ZTTieHrJtdb6NL1y7eOD2F36/l55wcsi2JS4z/3LjsoHb//zYPtr88SHbeu1Gvv6uFQO3v7Z5P8e6I0STaQw6FeNJAQO7Wc9/3fp2ju3/+OtBDraHhlyuUa/ywPtWD9z+znOH2dMcGLItwI8+eO7A7z986Sjbj/uGbfvt21cRTWVoDcR4o9nPjkY/pmHyRv/HrSsHiqE+9HoTz+3vHHa5X7xuMaur+mpr7Gjw8c2/HBy27T/duJQyV98Az+N72vjjrtZh2/7jtYup6U/p9de3Onh4W/OwbT9z5QIWFucB8MKhLn7xauOwbf/2snpW9M+qee1YLz9+6diwbT+xcR7n9gerdjT6+O5zRwY9nuruItZiJtUS5N6qNjYu7Rt43NsS4FtPHxp2ubefV8mlC/tS3BzsDPGNzQeGbXvLmnKu7E8h1tAb5V8e2zds2+tXlnLDyjIAWgNxvvj7vcO2vWJJMe8+twItm+XoQ7/jn9sd6F8L4Lc66QjG+fZzh6nNt6MAGxcW8v7z+lIchRJpPv3QrmGXe35dPndeUANAIp3lrl/sGLbt6mo3n9pYN3D7TG1nwzHieHfktHadoQS+aJJoMk0wnsZjM+b8GHHr2sqBtsMdI1Jtbfzft17E2dmBde25/GxLA68c7h52uaM5RnztXcvJ758p8rsdLfz5zfZh206nY4TdpCeSyLCrKUB7YO+g2gknnO0YcbIPX1DDhrp8YGTHiAvrC/DYjbzZGuDbzx7hqX2dDDWkNdwxIptMouh0g2bxjOUYAdATSfLZ3+4etu1cP0ak+wehawts3H/T8oH7v/idP9PS4UdfkI/ePXhmxEiPETD8eYQGHCfGzkb/wGNnO0Zkk0mS6TJQNI4dCHDFprdfZyTnESeCJnKMcAHjP4842anHiH97bNewbcXsl0gkOHLkCJlMhrq6OpxOSUkoRK5omkYokcYfOb1g9skpngbqUvTProgk+wLOetK4CeFVQniVwEDKpwolyMr+308ELjyGIC4iqEruU/NpqgGs3r40TyeCEraCQTUpTg5UKGYXOlXqRgkhhBi/ORvYmM2CsRQtvhh6vUJtvh39NMxlf06FC4dZT4svRjCeoiAHaWlsJj0f2tA3SPWb15vGvbyZRLE7aHekSSh69vck2DhF/dA0jUxvL9FdXWQXeFAtp18dPJxALE3Q5kQxGVAMBtKZvqJz0USGQkcKh0kmE08kt82AUadw7fJS3BOUaqgjGKepN0rqTFfRO/Owrz8P+4plckVov9oCOzevLueh1xsxTMEfgQZd30yAWDLD4c7wkEGN4WTCIVItrShGI8aqKhT5I3ZCtfpjBGKp0773M8Eg2ViMbDQG7ty/7lg+qWr/PkE2izKK7wohxOQyGo243W7i8TgOx+SnQxRipkims/hjQ82YOKVg9kn/+6OpQbPtTCRPSvnUl/6pUAmysP93b3+gwmPse9ypRCfkvWh6c/8silODEqcHKbB6UczOvimgQgghxCRTtDlWTS8YDOJ0Ouno7iUvL++0x2dDmpntDb38amsTbquBv7m0DvtJhYCnNBVVP5NeRdPgwS3HOdoZ5qbV5SwqOX1bnGg7mhQSgViKfW1BavJtuK3Dl/+abSkkUuks//PMIVoDcW5ZU8FF8wuGbXuyXKeiSjU30/XdB1CiMYrv/BCWlStHlGYmq8F/PX2Itu4QN8zPY92KWtqDcf7x0b20BWPcuLKMj140b06nmTlZrlNRnfCHXS281RbineeUsaLCldPPvVGn8u9PHeRwZ4irlxZzRf+V/UORNDN9Tv7cJ1IZusIJvFYjyhDB6pylospkCDz+OOnubpzXXYe5qHCgbTqdJX2GbTzUMSK69XV8v30YvdtDwd13ofYPikkqqvG3Hepz/8Bzh3l8dxvzCuz827tX4Oj//g8fPUbs4CEsy5ahLxxcQ2c8qahOtO0KxTncGWFxqQOnxXjGtoNoGi8c7KLJH+OGlWUDsyUkFdX0SkXV4/NTlO8hEAgMee48F5z4+2Eur4NsNosqwWkxB2iaRjiRPn3mxCnBilPrUYQTp8+4tBA/Kb3TyUW0365TcXJKKLsy9AzscTPYRhCkOKmgttEmgQohhBDjMlnnz3N2xobZoBtRcenRFKAeTduTBxFy2daoV1lX48VjM+G0GMgfIhf7yW1Hs9xctlUUuGN9NclMdsTrzaBTOVvTx3e38eyBTtZUe/jExfNGtFy9TmWkq3g6tNWpCjp1cGOzQccnNtbRHU5Qe1JtkaHaDkdVFczjbGssLiQxfz5aNIqhoi91jKIoZ93GiXSmb1BGVVFdbsxGPdX5di5dVMSjO5tp9cfRNAal4BnJcsfSFibucz9djhFDyWY1DrSHONQR4mhXmBUVrpx+7jVNI8+sx6BTMBn0Of3cj6XtdPgsj6btH95oZdvxXjYtKuLyJcVnbDuaz/2pbdP+XjLbt5Hp7UVZvhR96duvlaVvkNNmOvupw4ljhOncVZgtRnQuNyaPa8i2E/VZnovHiAvrC9jR6EevU2gLxAcCG/baGuy1NSNa7lg+93/Y1crORj+bFhdy29qqES+3MxTnodeb2N9/7PnXdy5Hpyqj6oMcI0bfdrTHiNHsl2J2yGaz+Hw+vF7vwH0S1BAzUSqT7S+CPUw9ikjqtPRPgViSVGboQLGJJPkEBmpQzD8RsFCCePX9QQolSH7/DAurkpiYN2bKO3NNilMDFwaZGSmEEGJ2mrOBjdlMVRXmF9k5w4V704KqKoSjabKahtWYm13RbTXishrx2IafrTFbuW1G3FP8vlWLBe+HPwSMrrCkSa/jzgtr6AolWFD0dpqDdywu6s8Xb8dskD+oxyNx6BDBP/8F84rlOC688LTHVVXhneeU8/T+DvIdJjRNy2kqKEVRuHhBAW+1Bdne0Mv6eV6cFkkvNlJdwQTd4QRd4Qn6A7mfzuvFvvFi0j09mBa+XfshnsrwveeP0BtJ8oHzq5lXcHqNqqEoRiPWVasmqrviFMvKnbxnTQWhRJpy9+QNYhQ4THhsRry20aWVdFuNFDstHOuJAArpbHbEA+5CiImhaRpHjx4lEAgQj8cpKyub6i4JgaZpRJIZfJGTgxCDZ0z4Tkn75I+kCA0xi+JkJ1I/eZUApUqIZSeCFvpgX12KgSBFX9DCNlGBCot75EEKqxf040/jLIQQQswGEtiYpf70Rt/Vk+9cVcbyctdUd2dI+1qD/GzLMewmA393+XwsYwhuJI8fx//7P2CaV0vetddyxdJiCvJMWAxqzgdmpzMtmSQcifFKawyvzcjqKveUvfexvm6hw0zhKTOMKjxWPrlxHuns3NmWEyW2ew/R17eSCYWwX3DBkOszq2kc7QrTHohTV2inxJnbgdFkOosGhBNpYsmMBDZG4V1ryllR4WJJ6cSmQFFUlbzLLz/t/kgizZGuMAc7wpQ4zcw7qZC2mD5Meh1ZTWPb8V5UBd5zbuWkvO6VS4rpjSTpCiWIJTNYjCOfkfWFaxezs9FHmdsyqtlnJ0u1taElEhiqquS7QohxUhSFvLw8QqGQFAoXEyKT1QjE+gMR/emd+v4/cz2K4WZRnMxIqj8IEaJGCeBR+4tqnyigfWJ2RX/qJ4cSm4B3qIDVM3TxbFvB6YELiwd0MiwjhBBCjIV8g85CmqbxRrOfAx0hDneGp0VgQ0unie3ciWK2YF66BEVR8EeT7G7244+mKcoz85ELa0Y9IBE/dIjY7t1k/H4cmzbRk1L4/c4W4qkMH76ghiWls/8PsmwiQe+PfswrnUl+m7+CPLeDKq+NAsfMupKnO5zgsd2tFDrMXLmkGFVVyGY1fvFaA8e6I7zn3EoWFEvRyrGyrllNNhLBvGTxsJ8zl9WAy2rEatSPKN3QaC0pdXLH+dVYjTqKncOnyROnK8oz47UZp2zQ1ms3sbgkjz0tAV481M2N55RRnOPAl8iNYDyNrz/IMFma/TH2tgRQFYU11Z5RHastRh3n1+WP+bXTXV10f/8HaKkk3g9+EFOdBN2EGK/CwkLcbjcGg1yAIM4slckOzJjojbyd5unE772RwYEKXzRJIJYatjbcqQyk8RCkXgn2BSnoD1IoATyE+mZTKG/PrsibkEAFfcGHQYGJgtMDFScCGVYPyOxDIYQQYlJIYGMWUpS+lDLLysKsn+c9+xMmQfytt+h96CFUi4WC/LswlJSwqtKN126mLeBn8942rlpWTLnbOqrlWlasIOP3Y6yoRLVY0GeTGPUqWU0b85WfM002GiXV0U6+L0HYuoCOlMKLBzu5aXXFVHdtVPa1Bnn+QBcFDhNrazzk203E0xkOdoRo7I3S2BuVwMY4GKuq8Hzg/WdsU+W18Z41FRzpDhNLZsgz53ZAQ6cqrKp053SZc4UvkuRHLx9DBe68oBandfIHmzYuKOTJve34oyn2tAQksDFNXVxfwNZjvTT7YjT1RqnwjO57dSxq8m2cX5ePAlR5R/96Oxp9tPnjbKjz4rKOLqWiNtLRMSHEGQWDQRwOx0AAXYIac088lRkUoOg9MVsi0vf7qcELXyR51lRPp9KTJv+UgERfXYqTgxZ9qZ/ylSB5SnRi3uxA6qeTCmYPBCvyB9+WGRVCCCHEtCXf0LPU0jLnhKcsGQ2dy4Xe7UaxWFHtfbnZzUYdd22s458f30cgluL1Y72jDmwYCgtx33LLwG2Pzcjdl9SRzGRznkZnutK73bhueTfLfD4Wtdt54Wgvj+9p59JFRaMeIBqvZFMT0Z07sSxdiqm2dlTPXVjsYF2tl+I8M57+fluNem5eXUGrP8a51TIgPhme3t/J68d7CURTvH999aifr2WzKGcoMJrOZOmJJCmwm1BVSRkzUu3BOA3dEVRFoSMUn5LAxvwiB+9aXc4bzf6Bz6iYhhQwG1Ri/QNUFZ6Jf0mrUc9711YSS2UwjbDwd7q7m/i+faRr6vjd9h6afFFMepVNi4tG9dqGwkLyP/oRtGQSQ9XQhcuFEGfm9/s5cuQIeXl5zJs3TwqFz3CaphFNZvpTPb1dj2Ig7dNJ6Z16I28HLGKpzKhfS0cGD6FBKZ4GCmj3p3s6EcDIV4M4iUzAOwbMzpNSP+UPnkFxarDC6gGdBO6EEEKI2UACG7NUVyjB/245js2k547zqzEbpnb2grGigoJ77kHR61EtbwcczpvnZUOdlz/vbeePb7Ry6cKicQ/Yee0mIok02aw2ZwZOLUuXAHDVoS5aQkm8diOJdHbS+xF+5hlCzzxLqrmZgk99alTPLcwz84mL5512/8oKFysrXDnqoTibmnwrzb1RCuyjT2WWOHwY/yOPYKyrw3XTTUOmTXpkRzOvH/dx2aJCrlpakosuzwl1hXZuWl2OAtTm26akD6qqsKTUyRtNfv6yr4NFpXlYx1AbSUyscreF951XRTyVZfEkXuDw/IEunnqrgwvrC7hyafFZ2wef3Ez4xRcwn7uWusWX4Y+lMOrG9p1tKC0d0/OEEH0URUFVVYxGowQ1phlN0wjG04NmSfhOCki8HbQ46fdoiuQY/w7QkcFN+JRaFIODFl4lRIEaxEMIJ6Ecv+N+JucpAQrv0MGKE49JoEIIIYSYk2REYpZq7I1ysCOE1ainK5SYlFQUZ6NzDJ1G6KL6QnY3BTDqVdqD478SeeuxXv6wq4VlZU5uXTs5hVOni/Pn5eMwG7AadRTlTX4NA9PCRSSbmzEvXpKzZcZTGV4/3ovHZpwTNVOm2tpqD1uP+Xi9wceqavdpBd3PJHHsGPGDh8gmEmjXXINiPv25PeHkwBWCYuQMOpVLFhROdTdIZzVSWY1kJktWMgBNS4qisKzMSXc4SVbT0DE5Af6j3REaeiKUuUY2W1JfXIy+sAhTSTELih28fryXp/d3ck6VG0eO0+AJIc7M6XSyaNEiTKaZVZ9tpslkNYKxVH9ap75gxInfB9WiOClI4Y+mSI/jC1cli4twf0Di9EBFvhqiUA2Rr4ZwawHsWgiVCfiCN+WdUpvilHRPJz9m9YJe9kUhhBBCnJ0ENmapxSV5LCzO481WP/vagtMisDGcdbUekpm+tEW1BeO/ErnFF6WpN4rdpEfTtCkrtjsVVFVBUeDFw91o9KWOmUy2dWuxrlmNosvdDKEdDT7+/c/7SaQ1vnT9Es6rnR51Y2YaLZMBTUPRn/mwH4ynafJFafFFqS2wcfu6kad2sa5ejRaPYygvRx0iqAFwwzmlpLNZbEYdqUwWg06uDB2pQDTF/vYgdYV2vGOYUZMLq6vc2Ew63FYj9gkoMC9y44WDXTy+p40lpU7uOL96Ul7zyqXFlLrMIw5AOzZdhnXNanROJ7bWIHazAbtZL8cEISZJMplEVVX0/ecF5mG+t8XQUpks/pPSOfmig4MRbxfPfntmhX8URbOHo/QHKjxKqD/V09tBikJdiCJ9mIL+IttOLYgtE0RlBLM3RjvBw+joq00xMIPi5N8LTrmdL4EKIYQQQkwIGZWYpSxGHf5YiteP+9jTEiSVznLtiumZqsGgU1lYnMcbTX5a/TGqvOMLbly8oBC72UBtgW1OBDW0dJpkUxOGwkJUm42/vtXJa0d7UJj8wAaQ06AGgNduJJ7WiCTSNPZEJLAxBtlIhN4Hf0YmGsXz/vdjKBr+yv95BXbKXBb2tgT47fZmNi4oHPkV2B4PzuuuO2ObYCzNwY4whzpCLC51nraPZiMRtEwGXd70qRE0XfxpdyvPHehkbY2Hj110etq2yaBTFfLtJpp6o7isBklFNU31RpL0hJN0hhJomkY2GOxLBWmbuDRmpS4LqUyWeCozoosKFEVB7+6rnbSszMm9m+qxm/RTnjpTiLkgnU5z6NAhAOrq6ub8TI1sViPQP5PCFzkRqOibRdEbSdDbP4Oi96Q0UKH46IpmD0/DSgKvEiB/INVTkBJdiFJDmEJdX6FttxYgL+vHlg6gcoZaGFlGH6QAMNiGr00xVPDCIIEwIYQQQkw9GZGYxdbXenlqXzuxZIbtDb5pG9gA+Mu+dp56s51zq73c+47541pWnllPZzDO7mY/t62tpHSEg7IzVeiFFwg9uRnT/Pl4P3In62o8NPZE0KkKmayGbobXGVlQnMeXrlvM8e4IF9QXTHV3ZqR0by+Jhga0eIx0e9sZAxuqqnDV0mL2tQZxmPR0hxIjDmyMRKnTgsWg42BHiH0tgUGBjUwgQPcPfoAWj+P54Acxlpfn7HVngzyzHr2qjHjgeCJksxo/23Kcw51hblhZytXLpu/3ylx22eIiCvPMVOfbSDU20vuzn6FYbeR/7KPDpoUcr45gnO+/cJRkOsudF9awsHjkwUlFUdApCgc7QiwucWIxSnBDiImUTqfJZrOzcmbzicLZJ4IQPZGhgxUn0kCdqFmRy/SKBtJ4CJKvBPEqAcqMEcqNYYp1YQrVvtkVTi2AI+PHmvKhz8aHXlCm/2dMnbCeOd3TQN2K/tuG2f33khBCCCFmJwlszGJXLC3GpFfZ1tDL5UvOXshzKpU6zYQSad5sC9AeiFPsHPtVQL5oiq3HenirLUgyneUzVyxAP4tTW2jJZN9PIgFAvt2EBmxv8HFerXdKZm3k2nm1XgocJrLjnb8/RxnKynDdcD3ZeALTokVnbb+hLp9wIsPOBh+ZHBdScFoNVHmsvHykm5+92sDaWu9A8DEbiZDx+9HiCTL+AEhgY5Bzqz08saeN5w90Uuoy867Vk19DSFHAYTZgN+mxmc5eByHy6qukmpqxX7IRfX7+xHdQAJBnNrCo2MHhrjDm7h7S/gBqMkU2Gp2wwIaqKOhVhayqoB9l8eFsVuPBLQ0c6Qxxw8oyrlpWMiF9FEL0MZvNLFiwgEwmg9FonOrunNGJ2RTd4QRd4URfgCJyUsCiv6B274mfaHLMhbOHcyL9U74apNIUpdIUpdQQpkgXokAJ4qZvNoU97ceS7MWQCp6+kPGWFtOZwF54SrDCe/rsihO/Gyduhp4QQgghxHQhgY1ZbuPCQso9FmLJLNmshjpNr95fVOKkNt9OIp2lLRAbV2Aj326kzG3lhUPdPLGnjXOrPWxaXJTD3k4vjo0bMZaVYSgvR1EUChwmylwWFAUKJjEPv5ZOE9myBVCwrT/vrLUcRuOtthDffvYQsWSGv79yIQtLRn4lsJZOk2puRl9YiGqdvrVmJpKiqtjOP3/k7RWFQCzJswc62d7Qy3+/9xxKXLlbd6ur3Tx/qAubUUdXKDEQ2NCXlOC+9Ta0RBzzooU5e73ZQq9T8UdT7GsN8e9/PoDTbOAdS3I7AJyNxUgcOoShvBy9x3Pa44qi8MHzq+mJJCnJO/NxOhuJENy8mVRzMzqPG8dll+W0r2J44USaL/xhL2+2BtlQ7eZz73kPBocdQ9HEfRcWOEzcdUkdyUyWcveZjxeaphHf+yaoCubFi1EUsBtVUhmNUCJX6V2EEKdKpVIYDH1B6akMaKQzWXojSbrDSbrDiYGfnnCSrnCi7/5Q3329keS4imcPrS/9U4UxTLUlSqUxQkl/oCL/RKAi48eW9mFK9GJI+FC0zImnQrz/ZzwU9fQZFKf9ftJto73v6gIhhBBCCDFAAhuzXHsgzo9fOkY8leXDF9SwtGxkRT0nW5nLwrvPrSCeyrC4dHy59RVF4drlJbx8pBstC7M9XbdqNmNZtmzgtsdm5J7L6okk07isZ7+iOlcSR47i//0fUBQwFBdhqq/P2bJ1qsKxngitvhjfefYw33j3Ckz6kW3Y4PPPs2XzFqJlVVzxyVtHdJW56EsZFUtn6OyK86+P7+c/3rMSgz43M5/Oq/XykQtq2NnkR+PtwQpFUbAsXZKT15iNChwmbltXwdGuEL3RFP/yxH4KnRZWlLty9hqhZ58ltPnPmObPJ/+uTw2ZokSvKjT1RukNJ1laljdsGhPFasWyYiU6lwtTXV3O+ijOLpPRiKcyJNNZwhkN06rVGHP0+T2TwjwzoXjqrBdSJI8cofcXv0BRVfI/9lGM1dWsrfXy4uFuHtnWTF2BnVVV7gnvrxBzSVtbGx0dHdTV1WG32yfsdULxFO2BOG2B+Nv/B2MDtztDCXzR5LiLaJ/KqNOotSaoNkeoNPbVpyjW9RXRdvWnfRoIVMR7UNKxvicm+n9ywZR3hiDFKQELixvUWf5HihBCCCHEBJPAxixn0qugKH1XQoVyddaee6qqUF/oYNvxXhp6ouNOn7S41MkXrl7Ez15t4I2mAOtq8+dUQdJXjnTz1L4Ozp+XP2m1VfSFBRgrKkABfUFua2HML7KzoTafx/e00RaIc6w7MuL87b3hBI9rBfT6TOQ3+Lho/vD1JcTbzq/LZ9PCQn6/q5W9rQG2HO3hovm52a6KohCMp9ndHCCd1VhR7pp1Ob4nyg0rywnFMnz72UOkM1kOd4RZUe7qS0enaajjLACrmM0oZhOKefjZGHtaAvzi1QasJj33bqqnxDl0Xm5FUXC988Zx9UeMjdNq4P9es5jXj/eyrMw5KUENgC1HevjTG62sqHDynnOHT5Wm2u3o7HZQlYGC5g6zgUA0RU8kydbjPRLYECKHNE0jEAiQyWSIRqPjCmwk01kae6Mc645wrDvMse4ITb0x2gIx2gNxIsmxFoUYTK8q5Nv01NiS1JijVBrDlBiCFCpBPJqPvIwPW6oXc6IHfawTJdqDkspAKicv30dnBFvhKUEJ79AzKqSgthBCCCHEpJPAxiznthlZXJLH0c4wrxzt5uIFBdN2APHFQ138bkczi0ry+IerF521n1o2S+ivfyXd00PelVeidw8eBElmNJLpLB2hBLFkZk4FNhp7YzT7YhzviUzaa+rdbgruvgsgp2mooG+A9O5L67Bb9FgMurOmOTlZ8WUbyevZykFflleP9nJBXcG0Tck2FplQiGBnN7bKCoyG3K13narwN5fNpz2YIBhL5Txf9YJiBwuLHZxTIUGN0br9vEoSmQy/3dbMQ683stil0v37P/Irnw3vkvncdfVyiocJNpyN46KLMM+bh76wcNjt4rEZMRtUmnojPP5GK7etrcJmltOJ6abSY+WRHc38dnszly8u4iMX1k74Z63FH6XFH8VpOfPMOENxcd/3haKgc/bNJJ1f5ODOC2rY2RRgbY13xK+ZjcdJNjRgrKiYs+kGhTgbRVGYP38+Pp8Pr3fkny9/NMneliB7WgLsbQ2wrzVIY290zPW3jDqVAoeJYrtKnTlElTFImd5PseLDo/lxZnzYUj2YEj3ool0okS7w5zI9nTJM+qdhZleYHJL+SQghhBBiGpORiDlgQbGD/W125hXYp/UAYpXXRk2+nQVFjhH1M9PbS/j550l392CsrMS+YcOgx1dVuekK9wU1Jutq1cmmaRrxPXvIxuJYV68aCChsWlxIezCOxagjmkxjNU7ORz3XAY2TOa1G7r6kns5QHPMotqfFbuWidQtp3dpINJkhmcliniVT/7VUim3f/znf7rKgFZXyxfeupz6HxeI9NiPvO6+Kn7/awBvNfi6oz93Mp+XlLpaWOmdVkGmyKIrC0jInv3i1EX9vjH1vNdPUleAlrYj0m90Elf382y0rMOhGf9xT9HqMVVVnbFPltWEy6NjbHGBfa4hgPM19ly8Y69sREySV0TjYHuZoZ5hndSo3r67AY5vYnPqXLizCaTYwr/DsV4PrXK7T7nvnqnJWVLpRR3GuEnj8cSIvvYx1zRo8t793NN0VYtbLZDLodH3f26qqnjGooWkax3uivHq0h1eP9rC9wUezLzbi17IYdJQ4zVTkqSy0+Kkz9lKu81Go9eLOdGNPdmGItqME26C7e9zvbYCq75tVYS8Ae9EpvxcM/rF6JP2TEEIIIcQsIoGNOeDcag9LSvOwTOGMheiOncQP7Md+4YUYy8uHbLOywsWxrjC+aJKuUIICx5lTqujcbqxrziXd3TVkPQeTXuVgR5hDHSHsJv2kpWSaTOnWVny//jXZeBzVahmotZHOaLQH4hzrCrOyws3qWZLSY/PeNp7d38m5NZ4zpjk51fnzvKQzWewmPcYxDPZOV5qm0RHLcihrI9qb4uHtTXz+qrPPdhoNBUikMxzqCBGIpjA7c3Mc0TSNp/a1s6PJz9VLS1hR4crJcueKNVUe7ji/imZfjOVryplvzfL0Vh+tSR3doTj+aJICx8SlxKhwWzEZdSgomObQbLiZxGLU8cENVfSEE2QyWY50hfHYTi8In0t2k55j3REe3t7MpYsKuXlV+agCbMd7onz/haOoCnxqYx0VnhHMwNBO/JPr4sJCzGzxeJwDBw5QXl4+bECjMxTnmbc62dIfzOgInjltrdmgsqDAzDnOGEusPuoMPZRqHbhT7RhCTSi+BmhtH3/nFV1fIMJe2P9TdNLtE78X9d02u0CdPed2QgghhBBi5CSwMQekM1n+d0sDzx3s5LyafD52US0W4+QNRGmaRvDPm0nsP4BqsQwb2OiNJNl6vJfOYJwFxQ4KHGeuhaDodGfN3+6yGMgz67HP0jQpqsOBzutFjcXRud8esCrKM1PtsbKzycfeFj/Ly51junp7uvFHU/hjKfzR0SVQNht07G8P0eKLotepbKjLn6AeTi7VaGTjB9/Ji08e5MWuNFsOd7P1eC/rRpHG5WxWVbnI26ansTfKU/vaed/66mHbauk0WjqNeob6DCd0h5P87NUGDrSFaOiO8J+3njOn0sWNl05VuOP8mrfvKDqPH62J84Xf7yWUSLOrKcA7Fk9cYOODG6o5v85Lmy9GVb5twl5HjM/62nxWVXVxsCNEqy8G1RP7ev5YkucOdLKj0ccrR7o53BHm81cvQjfCmVl6VUGvKigKI36O89prsCxb2lfjSQgxoLu7m3Q6TVdXFx6PZ+Cih8OdYf6yr52n9nWws9E/7PMdBo3LCkNc4Ohgqb6F8tQxbIGDKL5m6B1jHQ1VD/ZiyCsBRwnklfb97ygBx4nZFkX9hbVn/nmrEEIIIYSYWLNztFcM4o+leG5/Jzua/BxoD1GTb+X6lWWT9vqKomA77zxUixXzosXDtvPajNTm2zjaFWHrsfHXQlAUhdvXVfLasV7KXWPLNz/d6fLyKPjUp9DSGXT2twcXzQYdHruR/e0hGnqjLCjO47za3A12D0XLZskGg6hO54SlPLt2eSmlLgtFeSY0TRvx62Q1je5wgleO9LC/Pcy/vnMp51TOjlkseeWl3PMuF4d/uZPOUJxdjf6cBjZMeh0uq5EdjX6e3t/JlctKyLefPpsqm0jQ+9Ofku7pwfPe92Ksrj7jcl1WA4tL8ugIJLAYdWTHmK97LusOJ/jGk/vZ0eSjOM/Cxy+uZW2Nh5cPdxOMJUf1GRktk15HidPCb7c18+yBLu68sIa6wtylQRO5oaoK7zm3gqPdEc6tntjZGgAFdhMXLyhkf0eIeDLDm60BfNHkkMeMoVR4rHxq4zyiyQwlzpEF5lSzGfMCSYUmxKnKysrQ6/Xk5+fT4o/x2+3N/PGNVo52DV1/rcIY4pbCFi4yH6E+vher7y2UniT0jOJF7UXgqgRXVd//zjJwlPYHMkr7ZlpIwEIIIYQQQuSIBDbmAK/NyDXLS2j0RUmksrx0qJvLlxRP6tXRjksuwXHJJWdso6oK1V4bPeEEm99s58L6AtaNczD+aHeEP73Ritmg455N9RTlTdwVzFNluKvj5xXYKXCYsJv0Zy3kmgvBxx4j8vo2HJeefVuPx6M7W9jfHuTqpSXkWfQc6wqzqDSPTYuKKRxm+5r0OtZWe3j6rU66wnH2tARmTWADoNxt5eMX1bLlaA+rcpx2TFEU3nlOGW2BGCa9jtQwRcSzkQjJ5hYyPh+p9o6zBjYMOpW/u3wB4XiK4z1RNr/ZzlUGH+HnnsO2fj3WNWty+j5mo+PdEV460k1bIE6zL0btPhuXLSrk2YMdfO+Fozz9VgefuqSepWXOCXn9TFYjfdLPULRMBlR1Wtd3mu3qixw5rb1zJoqi8LGLalld5eQ/njpMVtN4syXAxQvOPAPzZPtagzxzoJPz53m5bsXkXYQhxGxwckA7kc7yekeW3zy+nZcOd6OdcpjOI8K7PYe50b6PuthuzKEGOFvpC6MdvPP6Ahfuqv4ARv/vzgowjiB9nBBCCCGEEDkyrQIbL7zwAt/4xjfYvn07bW1tPProo9x4440Dj2uaxpe+9CV+8IMf4Pf72bBhAw888AD1Q9RXEG9TFIX3ra+m3G3hf19txKBXiKcy0zLtyzmVbmoKbEQTGcKJ9LiXZzboMBtUzAZ1VtVWGInz6/L57/eew9ajvaQzE381fKqlhXR7O6n2HORWHkYkmaY9EKPFF+UnLx8jk9WIpzNYjTp6Iin+5tLhjwUbFxRypCtMJJFm4/zZkYrqZFcsLaa2wIaqKjm/Un95uYv5RXkcaA+y5WgPN606PZ2czu3G/a6byfj9WFYsH9Fy9aqChkKLL8Zf9nVwXvwNkltfB1UngY0RWFSSx1XLSvjrm+147SauWlpCsdOEL5LieHeE9kCc+iLHhAU2ivLMfPyieRzrCfdty1P2u/jBgwR+9yjGefNwvetmCW7MEYqisKrSy4qK7r5jbnJ03+XN/hit/hhNoyhaLITo+zvp2LFjJDWV374V4bc7Wk5J3amxQG3h/d4DXKbbRXFgF0o0A9FhFuith+JlULQYipZC4eK+WRhyLBdCCCGEENPEtApsRCIRVqxYwYc//GFuuumm0x7/+te/zre+9S0efPBBampq+MIXvsAVV1zBvn37MI8gp/tct74uH72qEE5mSKazxFMZTPrpdSVtkdPM569axGvHeqk8S9FQLZ0m1dyMvrAQ1Tp027pCO2uqPWw73suhzjBrayY+Fcd0cqA9zON72tjdHKC+aPGEBrOcN96IefFizEuWTNhrlDjN3HF+Ffc/sZ82fxzoy2iQymj8eW87F9UXDFuE2m0z8p5zK/nxy8f4zbYWPn5xLQ7zxM9kmSzHe6L86KVjKIrCJzfOo8r7dmqyVGsrsd17MC9aiLGqatTLVhQFm1FHeyDO0291UFdoZ1nZ4JRjiqJgWbFiVMvV61RuXFnKm60BGrsjNC5dynyjHsuq1aPu41xkM+n5x2sW8/mrFgF9NQmyWY1VlW58kRRuq4Hz67xEEmlspon5uj/aHearT+7HbtLzhWsXD/r8JRsaiB86RDaZREskUOR7es5QVYX3rqvkL2924LGenjpQ0zS0RGLIGYfXLCshEEvSHoyzq9HHylk0u06IiRQMBnl29zEe393G3qiDZP+feWV0cYdjK+/Sv4wndhxCQzxZZ4TSVVB5Xt9PxTqwzq1zZiGEEEIIMfNMq8DGVVddxVVXXTXkY5qm8Z//+Z/84z/+IzfccAMAP/vZzygqKuL3v/89t95662R2dUYy6XVsb/Lzu21NpDWo9Fh5//pqrl5WMtVdG8QXTfH6sV4Od4a57/L55A0z+Bx+4UWCTz6Jaf58vB+5c9gATWNvlGPdEd5sDcy5wEaF20I6o3G8J0Jzb5S6CUxHYigpwVAysfuSoihctbSUJl+MX77WhMui46L6Ajbv66AjGOf3O1uGDWxAX02CY90REqkMBzsKWZ3jtE1TyaBTMOhVslmNzClpgUJ/fZrQs89iXbuWgk9+YkzLX1Pt4bHdrbx8uJvucJIvX7+ERSV54+73udUe6grtbD/u44FGja9cfzMeKUY9KicXWVZVhY9fPI8L6wt4Yncb9/36DZaUOfnitYspd589RUiqrQ0tmcRQWTmioHezL0owliKT1chkB6cps65ejZZIYqwoH1FBeTG7dIYSbG/wsb89SFW+lRLn27Wugps3E926Fcfll2Nfv37Q81JZjVcO93C0O0IolpLAhhAjcLw7whf+sJ83DvvRsGAiyS2Gl/iQ/TXqYm9Air6fk3lqof4KqH8HVG0AgxynhRBCCCHEzDKtAhtncuzYMdrb29m0adPAfU6nk3Xr1rFly5ZhAxuJRIJEIjFwOxgMTnhfpytN02joidIZSpLIZPFFk8w/2jPuwEYsmcFsyN3MD7NBxWRQMRt06M9QPDybTKAlE2jx+BmXd82yEirc1jEXTt15vIfWYIINdfm4rMYxLWOqVOfbqPRaafHFONodmdDAxmRRVYVPXFzHB9ZXo2XBYtThMBvY1uBjTfWZB8CWljnx2ozsaQnw/IHOWRXYKHdb2VDn5QfPH+M/njrI565eRJmrbyDRWFuL8dgxTPV1Y17+wpI8vHYzx7qjNPuiHOsKs7DYMe7PvU6nclF9Aa8c6WF3s59Hdzbz6XdIIeDxKHdbCcbS7G0N0BmMk8po7G0JnDWwke7qovv7P0BLJfHecQemEaR5vHJpCTpVobk3yiPbm2nyxbhueSmqqqD3eHBee02u3paYYQrsJtLZLMe74zT2RgcFNpJHjpBsaCB57BicEtiwGHSUuCyE4imMOoVPP7STqnwbt6+rosAxsiLkQswVyXSW7z5/hP959jDJdJZqxceHdJu51fAiJi0Op2Z0qzwfFl0H86/oq5UhhBBCCCHEDDZjAhvt/Xn7i4qKBt1fVFQ08NhQ7r//fr7yla9MaN9mCkVR+MRFtUSTafY0+fHaTVy/cnyFOf+yu5nvv3ScUreVL1+/FI9t/AP/y8qcXLO8hK5ggkgig9U49G7q2LgRY1kZhrKyMw6uVnltHO2OsL89SInLjGEUtTb8bx3gx7/cyn6di1dXVnH54hLOqXJjn6C0LrlmNeq5cWUZOxt91Myyq+BP3i/u2FCDqqo09EbxRZK4T9oPNU0DTUNRVQw6lZUVbt5o8rOtoZdXDnezfp53WqVjGw0tmyXZ0IDe60WXl8e+liCNvijhRJruUGIgsGG/YAPWc9egGMf++bSb9NyzqZ5vPnWAIx1h7n/yLdoCMT60oRb1DAHIkbigvoBVb7bzRnOA4z1R/NHkjAsiTjd1hXbec24Fv93RTCqd5ZUj3VyxpHhk+/ooSvLk202UOC186+lDBKIpGn1RLqjLx2uXAei5rsJjpcJt5UhniN/taGFVpXvg+9d57bWY6udjWXl6+jqPzciXr1vCt589zK9fbySaymAzqKjAJzbWYdTPrXpZQgwnlcnyiR+/yP7jLazUWviI4Uk26Xagog0+jnvrYPmtsPwWcFdPVXeFEEIIIYTIuZkxOjsOn//857nvvvsGbgeDQSoqKqawR1NrfnEe/3PbKo51R/jTGy387yvHafFFuWJpMSb96OovpHt7ee3Rv3Is5sIXdnCsO5KTwIamwYuHutnfFkSnKrxziELFAKrZjGXZsrMu72h3mMfeaAX6ghwLikc+a0FpbsQQ6KXbaueR7S08s7+Lq5cWYzMbqPHaeMeSomEDL9OFUa+yry3Ewc4wX7hm8aBB/9miIxhnX1uAWDLDebXegfeYjUbp/fkvyEYieN53O/qCAjYuKODFQ53saQnwwHOHcduMOUmpNBWiW7fif/RRDGVlFHzyk1y5tITWQAxVUVFPGftTTeMfaF5V6eYjF9Ty+Ud20xFM8OCWBs6rzWdJmRMtlSJ5/Dj6khJ0dvuollvgMHHPO+bz7WcOA30pbCSwMT5GvcpHL5pHfZGDf/vzfg60hzjUGWb+GWZt6QsKyP/oR/pSUY2iFksqm8Ws1xE3ZLAZ9bT7YxLYEEDfLLktR7rpDMY51h0Z2P+M1dUYq6uHfV4qk2Vfa4BUOosOSGvw8PZmHGYDH7qgZqBdJhjE96tfgarDfdtt6OyzK4AvxHA0TeOzD+9CaXiVzxq2sFbZSwldbzcwWGHFbbDydihbJQW/hRBCCCHErDS9R2RPUlxcDEBHRwclJ+Xx7+joYOXKlcM+z2QyYcrBgN5sotf1pXl6/biP3c0B3mjxU+Aws36ed1TLyfT0cFX4MFHKKK0tYkHR6AYzh6OqCouK8wjGUsTTWULx1LiKPJfkWagpsBKIpnFaR7cc25o1fNifZPchPY3hNL5okodebyKVyZJvN5PvMLKhrmDMfZsM6UyWQx0h4qkMLxzs5IZzhg4UzWRlLguXLSykO5yk9qSZKemeHhJHjpCNRUm1tqIvKKDCY6XKa2PrsV52NQf43vNH+OrNyye0sPpE0VLpvp9kCjSNJWVO1s/L56GtTTz48nG+dvNydKOYoTQS59V6uXp5CU/sacNu0tMaiLOkzEno2ecI/nkz5vnz8X7sY6OeBTOvwM5Nq8tRYNA2FOOzotxFXZGD5t4Yu5v8ZwxsABhKS0f9GhfXF2J/p56fbTnOnpYAX/vzAb5xywqK8iRf+1x3yYJCmnqjZLIaTsvITzk9NiNXLSuh0mtjXr6Vn7/WQGcoziM7mrh0USFV3r5jRKqlhfj+/aCqpNta0Y0gfZoQs8HXNh/AuOcXfEP/a/yKi+ITQQ1HKaz7GKy6Q4p/CyGEEEKIWW/GzOevqamhuLiYp59+euC+YDDIa6+9xvpT8jOLsytzWVha6sRq1JHsH/BuD5y5VsWpjLW1LLr5Wq6/dBk9BgdP7+/MWf82LiigPRDnwVeO8/udLeNaltNqoNpjwxdN8pc3h09bNhS9282Sd13N7RfXs7o/BVU0mSGrgcOio2QGDNytqnRzbo2Hojwz2xt8PLqjmWf3d5JIZ6a6azmj16m4bSb2t4f4U//sHABDWRnOa6/Bee11mBa8Xbdhw7x8qjxWFDTeaPKzo8E3Fd0eN9t568j/yJ147/jAQJqpEqeZaDLNka4wj+5qGfXn+mzMBh2fu2oR979zGVVeG3/c2cwbTX7QspDNQiZ71mUMxaBTuWRBIRsXFKLPcTBmLnPbjKwod5HRNHY3B4incv+5N+pV1tV6KXCYUFUFo15B0zSS6bHtC2L2cFoNXFiXz84mH//vibc43Bke0fP0OpX3r6/mqzcv5/b11dyyuoJ8m4muUJLvvXCEbLYvz45x3jwc77icvMsvxziKWUZCzGQ/ffEgxS9/ga8afohHCVFLE0rxMrjph3Dvbrjg0xLUEEIIIYQQc8K0mrERDoc5fPjwwO1jx46xa9cuPB4PlZWV3HvvvfzLv/wL9fX11NTU8IUvfIHS0lJuvPHGqev0DKWqCndfWo/LauChbU1sfrOdFRUurnSOvJC4otNhO+882nY0c3B7M3q9yvUrSnNSr+B4T4TucIJwPEU8Nf7BsVRWI53p+xktRVF4/3nVrKvx8q2nD3G8O8I5lS4SaY3Hdrdx1yW2nF8VP1KZcITk4UMYa2rQOZ1DttHpVO6+tI7PPLyb5w508Zd97VgMej64oZo7zq8Z8jkzUWcoQUcwRiyVxqhXObfag8NswLvhgtNqQFy8oIBKr4X/+ushUJQZW5BWMRgwL1486L7l5S7mFdjZeqyH/3jqIHuaA3zmyoU5rQtj0Kno9Sq7m/30RlOEEhm+9a4LyK+sxFCam2OAyJ1VlW6OdIap9FoxTtCxSlUV7n3HAuYV2HnyzXbe+4NXWVPl4e+uWCAzN+a4p/Z38GZLgKwGmQzcd/l8agtGPsPTatRz16X19ESSPLGnnR0NPp56q53LFxejGo04r75qAnsvxPTy5Gt78D71ea7Qb3n7zvM+Be/4Z9BNqz/rhBBCCCGEmHDT6gx427ZtXHLJJQO3T9TGuOOOO/jpT3/K3//93xOJRPjYxz6G3+/nggsuYPPmzZjNMmgyFk6rgfoiBw6jnng6S2qMV1pvqMsnGEsSSWZp9kWp8AxOI5NNJont2InO48Y8f/6IlrmgOI+bV5Xx/MFueiKJ0wpCj9bli4s40hnBF03SE06MOv+7XqeyuNTJP92wFBTYdtzHV598i11NflZWurlo/tSkowo++QThF17EumoV3g99cNh2zb4YwXiS3kicZAaM+gxvtYXQNG3WDEJvXFDAc/s7eGZ/J3/Z206x08LCEgfvPKecy5cUD2qrKAq1BQ4+etE8fv16I68d66Gu0D4l60LTtIE+5YLDbGD9PC8vH+4mnEjRFogzEe/KYzVR5rKSSoexGHWEsyqlixZNwCuJ8VpR4SKWTPcHodI4LWNP7XcmHpuRw11hdjf5SWayaBq0B+IS2JjjNs4v4PVjvRzsCLG9oZen9nXw8YtHl7pSURTuvLCW1kCcA+1BfrutmeI8CysqXBPTaSGmoZ3bX8H9xN9jUOEI1cxXjqO77j9h1funumtCCCGEEEJMiWkV2Ni4cePAIN9QFEXhn/7pn/inf/qnSezV7LZ+npeDHSW8fKSbV470sKGuYNQFwG0mPVuO9LK72c+Ohl7++7ZVWE+6Ojy2Yye+X/0KndtN4b33oHO5zrpMu0nPBfWF7G4O0tQb5Zn9nVxQnz/mAbJQPENXOEEsmeZ4T3TMhW0L+1//3CoP84scxFMZRj8HJHdUswXVbEa1nHm9lDjNzMu30xVMktGyFOaZaPZH+d2OFm5aVTYrghvpjEZPOEkimSWjaTT7ogRiKZaXu4Z9TpMvypYjPbx+3MfyctcZ206EFl+MH750lOI8E3ecX5OzOh9XLC3mlcPdtAXjrKxwTUjN0MWlefz3e89hy+EeAvEUFoOkj5quosk0j+9po9kXw6hTiaXSPLGnjUgizeISJ5/cWDfq+kPDWVXpZvvxXvyxvplTW470sLTMiU6d+ccYMTbn1nh597kV/M8zhwlEk2w53M15td5RByXK3VYunl/AW61BGnujE5JWTYjp6sie15j3x5sxKSmOUoVXDaPe8RhUSTpeIYQQQggxd8lI1BznMBu4alkJNV47ZoMOo370g0+apqGqCtFkhiNdEXY0Dq5XoPO40bnd6L0eFItlxMudV2BjTbWHVn+Mn7x8jP/dcvyMga8zKXWZWV/rocRpRtO0gfzcZ6Ol02Tjp9coKMgz8bmrFnL+PC86hTH3a7zyrryCgrvvwvnOd56xXYnTwj9cs4jb1lXyrlXl2IwG9rUEeWRHE9HE7Bgc8tiMXLuilOtWlLC83IndrEdV+9Ka9UaSQz5neZmLYqcZi0FHRzAxqf31RRJ85rdv8NvtTfz8tUZeOtQ96mVomoaWOX37eW0m/vWdy1hcksfORh8PvnycN1sDOd9Pi/LMtAZivHCwiyf2jq5+jZg8Zr2OeQV2VAUeer2Bf31sH3/d18ErR3r40+5WdjX56I0kc7J/3HhOGb/++Pm8d10l/liKh7c3sbNxZtawEblz8fxCPrihmiKnhb1tQb77/GG6w6M/5jrMBrx2I8lMlqf3d5Ae40xTIWaS1uMHyHvkPeQpUUyksBrBc/dfUCSoIYQQQggh5jgJbAhq8214bAb2tgT48YvHRjzonzh6lMBjj2Hq7uDzVy3kwvn5LCx2kM5qgwbIzPPnU3jvPXg/+lFU08hnSuh1Kr5IgqNdYRp7IkSTbw/gauk0gSc343/kETLhyIiWpVMVXjjYxT0P7eQHLx456/vMJpP0/PjHdH7zmySOHTvt8fZAgu0Nfh7b3TYwcJ7NTm7BXMVgwFhVNaL16rGZuOuSOj51ST31BXZMepWecJKn3uoYdz+y0SiBJ54k9OxzQw60TwadqnDr2kr+/T3n8F+3nsP711ezqNhJRyBOY8/Q+0iZ28JHLqxlQbGDcDxFNpvlhYOdfOWPb/LUKAvNj9bPX23grbYAiVSWRDLD8e6z78cn01Ipeh/8GZ3/8R8km1tOezzPYqDUZaGxJ8LPthznP/96kOM90Vx1f4DXbsRpMZBnnlYTAMVJVFXhwvp8mnwxXjjYTXckiaqCxaCSZ9Hzpzdauf+Jt3j1aO+4X0tRFBwWA+9YVMSCIgc1+baczUQSM1eBw8QtqyuYV2hDy2rsavTzveePEEmkR7Wcdywu4sqlJWgaPLu/k63Hx7/PCjGd+brb6X7wDqz0XWRzQL+Awr99Fr2naop7JoQQQgghxNSTwIYAoDucoKk3yitHemjxx0b0nOATT+J/+LeEn32OSq+Nv71sPqVOMz975Tgf/ulW/nfL8YFUETqXC3UMtVBWVbmpyrfhshpo9sXY3x4CINXWRvjZZwk99xyJQwdHtCy31UgkmcEXSfL8wS46gqfPxDhZNhIh2dxMqrWVdMfpg/+VHmtf0WlNI6v1BTS+/+JRvr55/6gHqSeTxajj05fPZ3mFi1A8zaM7m3nlSDfR5OgGmE4WP3CA4JNPENy8mVRbWw57OzaVXhv3XDafhSUOoskM2xqGv2JcVRSOdoV5cEsDf/urnfzdb3bxyI4mfrezmTdbAhNyRfBrR3t4ZEczmUxfSqeaAhtHusN0BuMjHujLBAIkDh8ieeQoqabG0x5XFIVVle6+fT6WoiuUwGrM/QDzxgUFGHUKD21t5H9fOS7pYaap1kCcbFZDpyp4rQauW17GtcvLiMTTPLa7jVeOdHOgPcgLB7voPMuxcSQWlOTxrdvO4cvXL2FJaV4O3oGY6WwmPXdeUEul10oyk2VPc4BALDWqZZgNOt5zbgVVXhvRZJY/7Godc30wIaa7aCTI0QfeQ0rTc5BajihVFH78D1jsckwVQgghhBACplmNDTE1FEXhQxtqCCfSmPQqet3I0lGZlywm4/NhWtBXELwjGOevb3XS6o+BAruaAvijSW5ZU0FnKMHC4jyM+tHF0i6oLyDfbuKfHtvHnmY/X3tyP//n8vlYVRuO5ctRYlGM1dUjWtaF8wt433lV/HVfO93hJP/0pzf5yg1LB+pmnErncuG++WbSPh+WFStOe7zcbUGvKrx4qId/fmwf91xWz9ajPfRGkmS1LNcsL2NVpWta1q9wWY3cvq6Sn2WO0xaI8/XN+9k4v5B7NtWPqb/G8nJM9fNRbTb0+fkT0OPR06kKC0vy6AjGz7jf1RXaSaaz7G8PsqfZD4BBBzsa/Hxt834+elEtF9aPvzh8LJnhj2+0EIgm2d0cIJrMUO6x8NELa/nV1ka2HOmm1R+jymPjjg3VzCs4c3FdndeL89rrSPt9mJctH7JNqauvuG57MM7dl9RNSBFnfzTNruYAx3sitAbiLC13ck6lO+evI8ZnZYWLT1w8j/3tIZaV5XHN8lLeaPbz4uEuQCOTyfLk3jbSGY1Ni4v45Ma6cb+my2rEZR1dzSYxu51T4eLa5aW8eKiLSxYWUeIc/THJZTVyw8pSfvbKMXyRBP5okgKHFKgXs0s6leTg/9zCysxujlBFAgOWOx7GXVAy1V0TQgghhBBi2pDAhgBgQXEei0ryeO1oL4+90cpHL5p31uc4LrkE+0UXoej6rgKfV2DDazPSE0mQzmaJJNL88rUGXjnSi92s433nVXPx/NEPEC8odrBxQQFtgRi7Gnt5349eo9xt4c4LLuKdqypGvByDTuUjF9byZmuAFw520xNO8NS+Nm5aVYlliCvZFUUZMqDx9uN9sx/SmQxdoQT/u+U4BzuC9ERSHO4M09gb4+vvWjHqYuyT5cL6Al4+3M3rx30k01kU4PqVpdSeZUB9KPqCAgr+5m6AaRXIuXZ5CcvLnJS7rcO2KXGaWV/n5VhPhGw2jdduwmbS0+aPcbgrPK6ZLCc70B7kiT1tNPVG6QknMOl13LG+iiuWFPPKkR4OtYfZ2eijM5jgymXFZw1sKIqC7bx1Z2xT4bHyjVtWoFMVTPqJSQdUV2jngnov0USaSo+NMvfI6+iIyeMwG3jXmsHHy1WVbj5z+UIe291Gsz/CwfYQVpMeqfMtJoqiKNxxfjU3ry7HaTGM+fti06Iintzbxr6WIP/30T187V3LcVtHnupSiOlMy2bZ8Z0Psjb2KgDFWjudNz9KafWCKe6ZEEIIIYQQ04sENsQAg06lxR/j5cM9XLuilHy7CYPuzDMsTgQ1AEpdVv7tPSt5o8lPRzDOQ1sb6Qkn2NsaoNRpHnPeM0VRuPXcSl4+1E2bP04inSGWCvPozlYuW1xMntkw4mXpVYVFJXkc6ggRTmT41jOH+c5zR7l4QSH/9+pF2Ewj/0goisI9l80nnEix/biPzd0REqkMqqKQzmZp9sVo88cmNLCRCQRAUdDljT4tgaZBdziJXlUwmnUU5ZlRxxGUmE4BjRNMeh31RY4ztlEUhU9trKPMZaU9EOfcajdHusL85vUmYuks2477uKi+cMjg10hpmsbTb3Wwvy1EMJZEVVXme22src1Hr1O5cWUprx7pIRpKE0qkaeqJoNV6c7JOrcaJPczrVIXPXrmI966tothpnvDXE7mjKAo3nFPGxgWF/N3Du+gOJan02Lh+RdlUd03MYnqdOu6ZPHaTHo/ViD+eYttxH795vZmPX3z2CzKEmAle+uH/YanvRQCSmp7Gy3/A0uVSKFwIIYQQQohTyQiUGLBxfgFbjnQTiCT4t80HcNkM3LyqnMWlzhEvY16BfeBK82qvjX//8wFCyRRLyvJYW+MZc9/MBh1Ly12EEil6w0kS6SyaptHYE2FpmWvEy9HrVD520TwWFufxz4/t60ubBbx4sIv9q8pZXTW6FDp2sx6jTkerP0Yik6Uu386711bw7P4u4qkMB9pDLCkb+fobjVRHJz0//CEo4P3IRzAUFo7q+aqqcOcFtayscNEeiLGj0c8vXmvgc1ctQjfEJdvZrMaRrjBOi4HCPDPpTBZ/LEk6A0V5pmkZ2Bgph9nA+857uxDnefO86HUqv93WxCuHe3jHYj9ra7xjXv7BjhDPH+wmnkpj0Osod5n57FULqMm3AVBTYGdtjYfdzQEUBfa0Bjm3O0Jjb5SlZU7y7dP7SmSDTh3TTB8xPTitBlZVukllslw8v4ASl8y6EdObqir87ab5dIUSBOPpCUmzJ8RUeOVXX8Pd+hJHqaJKa6Jh3RdZveG6qe6WEEIIIYQQ05IENsSA+iIHVV47v29sZl97EIfZyJHOCH93+QKWlb89OB+IpuiOJKjx2lDPkLNkTbWH5RVOWnwxNi0qwmQY+xXvRr3Kxy6s5aZVZeRbjfzX04fY1xbkjabAqAIb0BckuaA+nzXVbnY0gE5RKHGZeelQF8V5JsrcVjRNI5LMYDPqzjpg/67V5Ww/7iMYT3L50mI+tKGWCreNX25t4LVjPZS6zJS6LKSzGr5oiqVleTlJC5SNhMmGQ4BCNhyB0cU1gL7C1YtL8/ju84dp7IngiyS5ZlkpKytdAKQzWY52h/nvpw/RG07ij6exGXV85or5/PnNDl4/7qPKa+VjF81j6QQFcKaCSa/j1jUVvH68l8aeKMe7I2MObGiaxhN72gjEktQVOrhiSTGLS/NYVfl2oC/fbuLT75hPqz/G0/s7MagKD29rZl9bgHcsLh4UdBFiItyypoJVVW4WlUhRWjEzlLksfOd9q2n1x6jwDJ9uUIiZYuefH2Td/vtpUUoI4ODA/I+x4eo7p7pbQgghhBBCTFsS2BADFEVhdZWbx99oIZKFYCzFgfYgW450sbjEQTCeJpnO8LXNB0hlsty2tpLz64YvFO21GblyaQldoQTn1Y6/oLTTasBp7Us7Na/QTqMvSigxtvoHVqOef7lxGY29UV4/1su3nj7EjkY/z+7v4DNXLiSSyPD47jYWlTj42EW1qOrwibSWlbv4+UfXcbQrQn1R31XrbpuBYCzFnuYAe1v8ZDUNfzRNfZGDD19Qw8YFfVGIaDKNP5qkOM9yxiDRUIw1Nbjfe3v/79VjWg8nXL+ijJcOddPii/KTl49Sf9hBPJ2hN5ykO5zgxUPdJFJZUMBiUPniH9+kO5QgHE8Tiqdo9kVnVWADwGjQcd3yUv7r6YP8/NVGKrw21teOLLgRT2Vo7I1S4bZi1CmEYim8dhNXLyvhzgtrh3xOYZ4Zu1nPb7c38UaTn1gqQzqr8fyBTlwWPZcvKTljEXQhxqPAYaLAMb1nBglxKrNBJ7PFxKywb8uTLH7l79ApGpW08lLJB7jg9v871d0SQgghhBBiWpPAhhjk2uUlJFIZHt7eRJsvji+e4pdbGznSHaY3kqIzGOdoVwSdqtAbTXKoI8R71lZiHmI2hqoqXL6keIL6Wcq8Qjt1hWMf0LCZ9CwqyaPFF8NkUAnGshzoCPG5376B1ainNRDnhUNdJDJZ7rls/hmX5bIaWVX1ds7wBcV52E16YskMhzrDZLOg0RfI+PNeCxa9Qm80xeY3O3irLcimRUX8n8sXjCq4oSgKlmVLx/r2Byl1Wbh6WQnffe4wT+3r4LmDXaQzWfSqitOix6RTQFMw6FTSmsbB9jCq0peCKJrM8LvtzexpCXDDyjLmn6WmxUxS4DART2boicR4dEcz66o9I9pGf9jVwl/fbEdRFbIaNPZGmF+Ux3UrSs/4PLNeh1Gvo8EXI5FMo6oqrf4YbzT72dbg45plpRTlmSlzW4ZMFyaEEEKImeXIm6/h+PO9mJQUAK87r2DDR/9rinslhBBCCCHE9CeBDTGIoii8a00F160s5bfbmvjBS0fxR1I8va+TaDJNRlPQKX2Fpw+0B3GY9FyysIhK7+SmgXBaDZw3wqvnz+ayRYVU5Z/Lt58+zDMHumgLJFBIoNMp6FWVpp4YmqaNqoaE3aTn+pVltAXjNPdEUPQKJr1KLJnldzubeWRHM2aDQqY/4PH68V5C8RTOcRZUHY/zar3875bjtAfipDLZvgF8LUM6q+eShcVcUJ+PQVX4yZbjHO4I4bEZmV/koLE3wtbjPo50RajNt82qwMaSUidXLyvhyTfb6QjEeXxPK+fPy8d7hpoXvkiSzXvb2d7QSzyVAQ0Meh2FDvNZgxGqqnD1smKeP9hFb1jBbFTxRZL0RlL8+vVGthzpZkFxHtctL6E6306e2UCRU3LLCyGEEDNRe9Nhog/fjZ8CNFT85jJW3vW/KGeYKSyEEEIIIYToI4ENMSSTXsdta6vIaBo/fOEoXZEEmgY6BSo9VvS6vgHXMpeFUtfMHlhVFIX6wjxuObeCrnCSN1uDZLJZqvNtXLOshMsWFY2pMPaNK8uYV2DnD7uayXeYmVdg4z+eOsjRzjCpLGSyGkadgs1sQKco7Gjys6jEwXP7u1AVhauXl2A3Td5HtCbfxoc21PCb7U0EIil0qkIymyWdzlLptXDz6nIALllUwLZjPgrzzFS4LXz859tp8cXJahp1hbMnqAF9tV3ev76ag51hdjf5+e+nD/HDF46CAhVuK0V5ZqLJDNevLCWWylDaX3RZQ0NFQVEUVFWhKM/EzavK8NjOHrhaXeXhK9cvwR9NsaDYwZ/3tvGL1xrxRRI09ETpDifZ1egjGE9TW2DnG7esYJ6kYhFCCCFmlEBPB4mf3EgxERopo1NXxKK7fovBKGkBhRBCCCGEGAkJbIhh9V09XsoTe9pJZzWqvTZcNiPvXlPBm61BDnaEOG+eF71udlxVtrrKw8cuhlQ6SyyVYVmZk+p825iXp6oKKypcrKhwDdy3uCSPX7zWyJHOEK3+ODqdQnGemd5wkl+92kCzL0pvNIXHZsSg66t58t/PHCaeSvPRC+ex/KRl5ZqiKLz73EquWV7KS4e78dqM7G72s+VID+6TBuQdZiOXLCoC+gpjX7u8FFVRuLC+YNbV2YC+2heLShy8drSbnkiCTBayGrzZEsSgV1AVhZcOd2NQoTrfztXLSsgzGVhZ6cKoV9GpKotL8rhuRdmIAmSKonBBfcHA7XkFdpaUO/nPpw5xuDNMOJEmGEuR1eBwZ4hHd7Twf65YMJGrQAghhBA5FI+Gaf3ujSzKNgEQUuy4Pr4Zm8M1tR0TQgghhBBiBlE0TdOmuhOTKRgM4nQ6CQQC5OXlTXV3ZoT97UHeaPKztsZLTf9AfziRpj0Qp9prnTWBjcmUzWq8eLibeDJNVoNvP3uYo11hEuksqtJX/+OKxcWkNI0n97SRzmqsLHPyww+uHSigPhniqQxHuyJUea3YJnH2yHSz7Xgv/+/xfRzpCpPKZlFRyWpZQCGraaQyfYdRs0HFbNBhN+m5fV0Vd5xfjS+awmkxYDGeXodmNP66r50n9rTzRpOvf5l6bCYDG+ry+dxVC8c0q0gIIYQ4Gzl3zu06SKeSbP/mzZwbexEVjW5cJD6wmbLaRTnqrRBCCCGEEFNrsv6GmLsjlWLEFhbnsbB48E5oN+nHVbh7rlNVhYvn912V3+yLYtSrqApYjX2D4hpwoCNIPJXFoKooZDnQGebe3+zkX29YSrHTMqpC42NlNuhYXDo3BzFOtrrKzeeuXsSzBzqxG/XctKqc7zx3mN3NAaKJNF3hBNCXXiyeyuK165hf7MBk0FHsHF9A44RNi4vZtLiYvc0BdjX7WFzqxB9NUptvl6CGEEIIMQNo2Sxbvv1R7LEeDlNNkdaJ/6ZfUidBDSGEEEIIIUZNAhtCTLEyl4Xz5+XjtBg4v9ZLvsPMozub2dcaQFUU1s/zkkVjy+FuXj/Wy3t/+BpXLy1ibU0+1fm2caXLEiOjKApra7ysrXm7YP0HN9SwrzWI06JHryrkmfR8dfMBmv1R1tV4uaAuf0L6srTcydLy2ZfySwghhJjtXv3pZ1npf4rDVJPSdDRc+h2Wr9gw1d0SQgghhBBiRpLAhhBTTFEUPrC+isbeKItL87Aa9XQEY+xtDQCwosLFlUuL+cdH97Cj0UdTT5T/fbWRR3a0UJNv55u3rqDUaZ3idzH3zCuwDyrarWka168sY09LgHeuKpMUbUIIIYQY8Npvv8n6xu8DsJAj7Fn9T6y9+Map7ZQQQgghhBAzmAQ2hJgGCvPMFOaZB26/a3UFbzQHiKcyrKx0UVtg584Lakg+11fzIpbK4oumoDvC8we6uG1t1RT2XkBfgOqWNeVcv7IUsyE36aeEEEIIMfNt/8vPWbHnX6E/c+Qb9Xdx3vUfn9pOCSGEEEIIMcNJYEOIaSjfYeKrNy2nJ5Kg2tuXamrjwiLmF+fx2O5WHtnWRDydpdxtRUHqK0wXiqJIUEMIIYQQA/a99hcsL3+Tw8o86jnGzuJbOO/2L051t4QQQgghhJjxJLAhxDTltBpwWg0Dt3WqQoXHys2rylEVBbtJz/wiBwtLHFPYSyGEEEIIMZTj+3dQ+ORHaFOKSaNnm/0S1n/0v6e6W0IIIYQQQswKEtgQYoYpzDPz8YvnTXU3hBBCCCHEMDpajmJ+6BbyCeAkwk7jGs79m5+h6mRmpxBCCCGEELkg1W2FEEIIIYQQIkcCvd2EfvhOiukGoEFXxeK7H8JoMp/lmUIIIYQQQoiRkhkbQgghhBBCCJED8ViEA9+5DaNmJYSNoGLH9dE/YM9zT3XXhBBCCCGEmFVkxoYQQgghhBBCjFMmnWbf/9yKO91FBh2NlKDd/jvyiyumumtCCCGEEELMOjJjQwghhBBCCCHGQctmef27H+W8yAtkUWjUSkje8F3K65ZOddeEEEIIIYSYlWTGhhBCCCGEEEKMw5YH/y/ndf8OgIymErzkX5i/6uIp7pUQQgghhBCzlwQ2hBBCCCGEEGKMtjzyX7ganqKbvjoau1b9C8s33jzFvRJCCCGEEGJ2k1RUQgghhBBCCDEGbzzzEJW7/4d2pYg2ijhY+wHOv+FTU90tIYQQQgghZj0JbAghhBBCCCHEKB3Y9gzzn/8bLEoSFTicfykXvO/LU90tIYQQQggh5gRJRSWEEEIIIYQQo9B4cBeFj30Ai5IEoNWxhA2f/A6KKn9eCSGEEEIIMRnkzFsIIYQQQgghRqir9Tj+X36MMHY0YK9pJUvv+iWqTjfVXRNCCCGEEGLOkFRUQgghhBBCCDECQX8PXT+8hRQmOsnHp7qo+dSjmMzWqe6aEEIIIYQQc4rM2BBCCCGEEELMet/+9reprq7GbDazbt06tm7dOqrnJ+JRmr7zThZnD1JDEwYlRelHfo3D6ZmgHgshhBBCCCGGI4ENIYQQQgghxKz261//mvvuu48vfelL7NixgxUrVnDFFVfQ2dk54mXs+/6HWZJ8AwCFLO73fp/80qqJ6rIQQgghhBDiDCSwIYQQQgghhJjVvvnNb/LRj36UD33oQyxevJjvfve7WK1WfvzjH494Ga7IMTKoRDUTndc+SEX9ignssRBCCCGEEOJMJLAhhBBCCCGEmLWSySTbt29n06ZNA/epqsqmTZvYsmXLiJfjx0mjVsqhi/+HBWsunYiuCiGEEEIIIUZozhUP1zQNgGAwOMU9EUIIIYQQYno7cc584hx6Juru7iaTyVBUVDTo/qKiIvbv339a+0QiQSKRGLgdCAT6HwhxZPEdrF1zpfwtIYQQQgghxDAm62+IORfYCIVCAFRUVExxT4QQQgghhJgZQqEQTqdzqrsxKe6//36+8pWvnHb/xv/YB3y2/0cIIYQQQghxJj09PRP6N8ScC2yUlpbS1NSEw+FAUZQp6UMwGKSiooKmpiby8vKmpA9idGSbzTyyzWYe2WYzj2yzmUe22cwz1dtM0zRCoRClpaWT/tq5kp+fj06no6OjY9D9HR0dFBcXn9b+85//PPfdd9/Abb/fT1VVFY2NjXMmuDMVpnpfnytkPU8OWc+TQ9bz5JD1PDlkPU8OWc+TIxAIUFlZicfjmdDXmXOBDVVVKS8vn+puAJCXlycfohlGttnMI9ts5pFtNvPINpt5ZJvNPFO5zWb6YL7RaGT16tU8/fTT3HjjjQBks1mefvpp7r777tPam0wmTCbTafc7nU753EwCOT5NDlnPk0PW8+SQ9Tw5ZD1PDlnPk0PW8+RQ1Ykt7z3nAhtCCCGEEEKIueW+++7jjjvuYM2aNaxdu5b//M//JBKJ8KEPfWiquyaEEEIIIYQYAwlsCCGEEEIIIWa197znPXR1dfHFL36R9vZ2Vq5cyebNm08rKC6EEEIIIYSYGSSwMQVMJhNf+tKXhpziLqYn2WYzj2yzmUe22cwj22zmkW0288g2y5277757yNRTZyPbYHLIep4csp4nh6znySHreXLIep4csp4nh6znyTFZ61nRNE2b0FcQQgghhBBCCCGEEEIIIYTIkYmt4CGEEEIIIYQQQgghhBBCCJFDEtgQQgghhBBCCCGEEEIIIcSMIYENIYQQQgghhBBCCCGEEELMGBLYmGTf/va3qa6uxmw2s27dOrZu3TrVXZqz7r//fs4991wcDgeFhYXceOONHDhwYFCbeDzOXXfdhdfrxW63c/PNN9PR0TGoTWNjI9dccw1Wq5XCwkI+85nPkE6nJ/OtzElf/epXURSFe++9d+A+2V7TU0tLC+973/vwer1YLBaWLVvGtm3bBh7XNI0vfvGLlJSUYLFY2LRpE4cOHRq0jN7eXm6//Xby8vJwuVzceeedhMPhyX4rc0Imk+ELX/gCNTU1WCwW5s2bxz//8z9zckku2WZT64UXXuC6666jtLQURVH4/e9/P+jxXG2f3bt3c+GFF2I2m6moqODrX//6RL+1WetM2yyVSvHZz36WZcuWYbPZKC0t5QMf+ACtra2DliHbbGKN9hz94YcfZuHChZjNZpYtW8YTTzwxST2dmUZy3n2qn/70pyiKMujHbDZPUo9npi9/+cunrbOFCxee8TmyL49edXX1aetZURTuuuuuIdvLvjwyuTi/GYqMwQyWi3OSU43l2DPbnW1//uAHP3jaOrvyyivPulzZnwc723oe6litKArf+MY3hl2m7M+D5Wrs9FRjPaafSgIbk+jXv/419913H1/60pfYsWMHK1as4IorrqCzs3OquzYnPf/889x11128+uqrPPXUU6RSKS6//HIikchAm09/+tP86U9/4uGHH+b555+ntbWVm266aeDxTCbDNddcQzKZ5JVXXuHBBx/kpz/9KV/84hen4i3NGa+//jrf+973WL58+aD7ZXtNPz6fjw0bNmAwGHjyySfZt28f//7v/47b7R5o8/Wvf51vfetbfPe73+W1117DZrNxxRVXEI/HB9rcfvvtvPnmmzz11FM89thjvPDCC3zsYx+birc0633ta1/jgQce4H/+53946623+NrXvsbXv/51/vu//3ugjWyzqRWJRFixYgXf/va3h3w8F9snGAxy+eWXU1VVxfbt2/nGN77Bl7/8Zb7//e9P+Pubjc60zaLRKDt27OALX/gCO3bs4He/+x0HDhzg+uuvH9ROttnEGe05+iuvvMJtt93GnXfeyc6dO7nxxhu58cYb2bt37yT3fOYYyXn3UPLy8mhraxv4aWhomKQez1xLliwZtM5eeumlYdvKvjw2r7/++qB1/NRTTwFwyy23DPsc2ZfPLhfnN6eSMZjT5eKcZCijOfbMBWfbnwGuvPLKQevsV7/61RmXKfvz6c62nk9ev21tbfz4xz9GURRuvvnmMy5X9ue35WLsdChjOaYPSROTZu3atdpdd901cDuTyWilpaXa/fffP4W9Eid0dnZqgPb8889rmqZpfr9fMxgM2sMPPzzQ5q233tIAbcuWLZqmadoTTzyhqaqqtbe3D7R54IEHtLy8PC2RSEzuG5gjQqGQVl9frz311FPaxRdfrN1zzz2apsn2mq4++9nPahdccMGwj2ezWa24uFj7xje+MXCf3+/XTCaT9qtf/UrTNE3bt2+fBmivv/76QJsnn3xSUxRFa2lpmbjOz1HXXHON9uEPf3jQfTfddJN2++23a5om22y6AbRHH3104Hauts93vvMdze12Dzo2fvazn9UWLFgwwe9o9jt1mw1l69atGqA1NDRomibbbKKN9hz93e9+t3bNNdcMum/dunXaxz/+8Qnt52xy6nn3UH7yk59oTqdz8jo1C3zpS1/SVqxYMeL2si/nxj333KPNmzdPy2azQz4u+/LojeX8ZigyBnNmYzknGcpojz1zzVDr+Y477tBuuOGGUS1H9uczG8n+fMMNN2iXXnrpGdvI/nxmYxk7PdVYj+lDkRkbkySZTLJ9+3Y2bdo0cJ+qqmzatIktW7ZMYc/ECYFAAACPxwPA9u3bSaVSg7bZwoULqaysHNhmW7ZsYdmyZRQVFQ20ueKKKwgGg7z55puT2Pu546677uKaa64ZtF1Attd09cc//pE1a9Zwyy23UFhYyDnnnMMPfvCDgcePHTtGe3v7oO3mdDpZt27doO3mcrlYs2bNQJtNmzahqiqvvfba5L2ZOeL888/n6aef5uDBgwC88cYbvPTSS1x11VWAbLPpLlfbZ8uWLVx00UUYjcaBNldccQUHDhzA5/NN0ruZuwKBAIqi4HK5ANlmE2ks5+hbtmw57TzkiiuukHP6UTj1vHs44XCYqqoqKioquOGGG+R8bQQOHTpEaWkptbW13H777TQ2Ng7bVvbl8Usmk/z85z/nwx/+MIqiDNtO9uXxGcn5zalkDCY3Tj0nGc5ojj2iz3PPPUdhYSELFizgk5/8JD09PcO2lf15/Do6Onj88ce58847z9pW9ufhjWXs9FRjOaYPRwIbk6S7u5tMJjNoQBWgqKiI9vb2KeqVOCGbzXLvvfeyYcMGli5dCkB7eztGo/G0L/CTt1l7e/uQ2/TEYyK3HnroIXbs2MH9999/2mOyvaano0eP8sADD1BfX8+f//xnPvnJT/K3f/u3PPjgg8Db6/1Mx8b29nYKCwsHPa7X6/F4PLLdJsDnPvc5br31VhYuXIjBYOCcc87h3nvv5fbbbwdkm013udo+crycOvF4nM9+9rPcdttt5OXlAbLNJtJYztGHW9eynkdmqPPuoSxYsIAf//jH/OEPf+DnP/852WyW888/n+bm5kns7cyybt06fvrTn7J582YeeOABjh07xoUXXkgoFBqyvezL4/f73/8ev9/PBz/4wWHbyL48fiM5vzmVjMGM31DnJEMZ7bFH9KWh+tnPfsbTTz/N1772NZ5//nmuuuoqMpnMkO1lfx6/Bx98EIfDcdYUSbI/D2+sY6enGssxfTj6UbUWYpa666672Lt375zOmzfdNTU1cc899/DUU09Jsb0ZJJvNsmbNGv7f//t/AJxzzjns3buX7373u9xxxx1T3DsxlN/85jf84he/4Je//CVLlixh165d3HvvvZSWlso2E2KCpVIp3v3ud6NpGg888MBUd0eICTHS8+7169ezfv36gdvnn38+ixYt4nvf+x7//M//PNHdnJFOzK4EWL58OevWraOqqorf/OY3I7pCVYzej370I6666ipKS0uHbSP7spiJRnNOIsee0bv11lsHfl+2bBnLly9n3rx5PPfcc1x22WVT2LPZ68c//jG33377WceTZH8e3nQcO5UZG5MkPz8fnU53WlX4jo4OiouLp6hXAuDuu+/mscce49lnn6W8vHzg/uLiYpLJJH6/f1D7k7dZcXHxkNv0xGMid7Zv305nZyerVq1Cr9ej1+t5/vnn+da3voVer6eoqEi21zRUUlLC4sWLB923aNGigamcJ9b7mY6NxcXFpxVES6fT9Pb2ynabAJ/5zGcGZm0sW7aM97///Xz6058emCkl22x6y9X2kePl5DsxgNDQ0MBTTz016MpI2WYTZyzn6MOta1nPZzfcefdInJhFePjw4Qnq3ezjcrmYP3/+sOtM9uXxaWho4K9//Ssf+chHRvU82ZdHbyTnN6eSMZixO9M5yUic7dgjTldbW0t+fv6w60z25/F58cUXOXDgwKiP1yD78wnjGTs91ViO6cORwMYkMRqNrF69mqeffnrgvmw2y9NPPz3o6g0xeTRN4+677+bRRx/lmWeeoaamZtDjq1evxmAwDNpmBw4coLGxcWCbrV+/nj179gwabDjxxX/qYK4Yn8suu4w9e/awa9eugZ81a9Zw++23D/wu22v62bBhAwcOHBh038GDB6mqqgKgpqaG4uLiQdstGAzy2muvDdpufr+f7du3D7R55plnyGazrFu3bhLexdwSjUZR1cGnBzqdjmw2C8g2m+5ytX3Wr1/PCy+8QCqVGmjz1FNPsWDBAtxu9yS9m7njxADCoUOH+Otf/4rX6x30uGyziTOWc/T169cPag9961rO6Yd3tvPukchkMuzZs4eSkpIJ6OHsFA6HOXLkyLDrTPbl8fnJT35CYWEh11xzzaieJ/vy6I3k/OZUMgYzNmc7JxmJsx17xOmam5vp6ekZdp3J/jw+P/rRj1i9ejUrVqwY9XPn+v6ci7HTU43lmH6mDopJ8tBDD2kmk0n76U9/qu3bt0/72Mc+prlcLq29vX2quzYnffKTn9ScTqf23HPPaW1tbQM/0Wh0oM0nPvEJrbKyUnvmmWe0bdu2aevXr9fWr18/8Hg6ndaWLl2qXX755dquXbu0zZs3awUFBdrnP//5qXhLc87FF1+s3XPPPQO3ZXtNP1u3btX0er32r//6r9qhQ4e0X/ziF5rVatV+/vOfD7T56le/qrlcLu0Pf/iDtnv3bu2GG27QampqtFgsNtDmyiuv1M455xzttdde01566SWtvr5eu+2226biLc16d9xxh1ZWVqY99thj2rFjx7Tf/e53Wn5+vvb3f//3A21km02tUCik7dy5U9u5c6cGaN/85je1nTt3ag0NDZqm5Wb7+P1+raioSHv/+9+v7d27V3vooYc0q9Wqfe9735v09zsbnGmbJZNJ7frrr9fKy8u1Xbt2DTonSSQSA8uQbTZxznaO/v73v1/73Oc+N9D+5Zdf1vR6vfZv//Zv2ltvvaV96Utf0gwGg7Znz56pegvT3kjOu09dz1/5yle0P//5z9qRI0e07du3a7feeqtmNpu1N998cyrewozwd3/3d9pzzz2nHTt2THv55Ze1TZs2afn5+VpnZ6emabIv51Imk9EqKyu1z372s6c9Jvvy2OTi/ObSS/9/e/cfFVWd/3H8hcgMA6j8VrQFC2SSRVnZNE1aUQqj4JiWx1z8gZlns5OuruDm+qPMo7J6OOuvwjQT96RrrfbD1tZfLJpZkcU6begxdWHZs0ura4oKJiT3+4dfZhkZmAEJQ5+PczjHuXPv+/2+nzsOw33P595hxurVq+2POQfTUGt8Jrl+nF2999yOmhrnixcvGpmZmcbHH39slJSUGPv27TPi4+ONXr16Gd9++609Bq9n11y9bxiGYVRUVBg+Pj5Gbm6u0xi8npvWGudODcMwrFar8dZbb9kfu/Oe7g4aG21s9erVRnh4uGEymYwBAwYYn3zyyc0u6bYlyenPxo0b7etcvnzZeOaZZ4yAgADDx8fHGDlypFFeXu4Qp7S01EhJSTEsFosRHBxszJo1y6ipqWnjvbk9Xd/Y4Hj9ML333ntGbGysYTabjbvvvttYt26dw/O1tbXG/Pnzja5duxpms9lISkoyjh8/7rDO2bNnjbFjxxp+fn5G586djUmTJhkXL15sy924bVy4cMH45S9/aYSHhxve3t7GXXfdZcydO9fhjxmO2c1VUFDg9PfXxIkTDcNoveNjs9mMhIQEw2w2Gz169DCys7PbahdvOU0ds5KSkkY/kxQUFNhjcMy+X019Rh8yZIj9/1edN99804iOjjZMJpPx4x//2Ni5c2cbV9y+uPO5+/pxnjFjhv2YdO3a1Xj44YeNoqKiti++HRkzZowRFhZmmEwmo0ePHsaYMWOMkydP2p/ntdx6du/ebUhq8PvVMHgtt1RrfL6JiIgwnn/+eYdlnINx1BqfSa4fZ1fvPbejpsa5qqrKSE5ONkJCQgwvLy8jIiLCmDJlSoMGBa9n11y9bxiGYbzyyiuGxWIxzp8/7zQGr+emtda50+u3cec93R0e/x8cAAAAAAAAAADgB497bAAAAAAAAAAAgHaDxgYAAAAAAAAAAGg3aGwAAAAAAAAAAIB2g8YGAAAAAAAAAABoN2hsAAAAAAAAAACAdoPGBgAAAAAAAAAAaDdobAAAAAAAAAAAgHaDxgYAAAAAAAAAAGg3aGwAAH4wMjIy9Oijj95QjP3798vDw0Pnz59vlZoAAAAAAADww0JjAwDQIhkZGfLw8JCHh4dMJpOioqL04osv6rvvvmtxzJUrVyovL6/1igQAAAAAAMAth8YGAKDFHnroIZWXl+vEiROaNWuWXnjhBS1fvrzZca5evara2lp16dJF/v7+rV8oAAAA0AbOnj2r0NBQlZaW2pclJiZqxowZNxT3+hjNjenO+q1RZ1vEvBE/tHpuJ0888YRycnJudhkAbiE0NgAALWY2m9WtWzdFRERo6tSpeuCBB7Rjxw5duXJFmZmZ6tGjh3x9fXXvvfdq//799u3y8vLk7++vHTt2KCYmRmazWWVlZQ0uRXXlyhVNnz5doaGh8vb2VkJCgg4fPuxQw/vvv6/o6GhZLBYNHTrU4Y9IAAAAoC0tXrxYI0aMUM+ePe3L3nrrLS1atKhV8zQ35vdRw+2K5kjLzJs3T4sXL1ZFRcXNLgXALYLGBgCg1VgsFlVXV+vZZ5/Vxx9/rK1bt+qLL77Q6NGj9dBDD+nEiRP2dauqqvTb3/5Wr776qoqLixUaGtog3uzZs7V9+3Zt2rRJRUVFioqK0vDhw/XNN99Ikv75z39q1KhRSktL05EjR/TUU0/pueeea7P9BQAAAOpUVVVpw4YNmjx5ssPywMBAderUqVVzNTfm91FDe1NdXX1b529MW9UVGxuryMhIvf76622SD8Ctj8YGAOCGGYahffv2affu3erbt682btyoP/7xj7r//vsVGRmpzMxMJSQkaOPGjfZtampq9PLLL+u+++6T1WqVj4+PQ8zKykrl5uZq+fLlSklJUUxMjNavXy+LxaINGzZIknJzcxUZGamcnBxZrValp6crIyOjLXcdAAAAt4DS0lJ5eHho+/bt+tnPfiaLxaL+/furrKxMBw8e1MCBA+Xj46OkpCSdP3/eaYz3339fZrNZAwcOdFju7DJS06dP1+zZsxUYGKhu3brphRdesD9fWVmpCRMmyM/PT2FhYU4v31M/5rp169S9e3fV1tY6rDNixAg9+eSTTmtwJ0fPnj21YsUKh2U/+clPHGrdtWuXEhIS5O/vr6CgIKWmpurUqVNOx6cxiYmJmjZtmmbMmKGAgAB17dpV69evV2VlpSZNmqROnTopKipKf/7zn5uVNzExUc8++6xmzJih4OBgDR8+vEHunTt3qkuXLtq8ebMkqba2VkuXLtWdd94pi8WiuLg4bdu2zb5+RkaGDhw4oJUrV9rvN9jYjHFn+V3Fl6Rt27apT58+slgsCgoK0gMPPKDKykpJ7s1od3XcGhuX2tpaLVu2TFFRUTKbzQoPD9fixYvtMVzV3lTdddLS0rR161an4wUAzUVjAwDQYn/605/k5+cnb29vpaSkaMyYMXr88cd19epVRUdHy8/Pz/5z4MABhz82TCaT+vbt22jsU6dOqaamRoMHD7Yv8/Ly0oABA3Ts2DFJ0rFjx3Tvvfc6bDdo0KBW3ksAAADc6mw2m6RrX5xZsmSJPvroI/3nP//RuHHjlJ2drTVr1qigoEA2m83hyzr1HTx4UD/96U/dyrdp0yb5+vqqsLBQy5Yt04svvqi9e/dKkrKysnTgwAG9++672rNnj/bv36+ioqJGY40ePVpnz55VQUGBfdk333yjXbt2KT093ek2zc3RmMrKSv3qV7/SZ599pvz8fHXo0EEjR45s0GRxZdOmTQoODtann36qadOmaerUqRo9erTuu+8+FRUVKTk5WePHj1dVVVWz8m7atEkmk0mHDh3S2rVrHZ7bsmWLxo4dq82bN9vHaenSpfr973+vtWvXqri4WDNnztS4ceN04MABSdLKlSs1aNAgTZkyReXl5SovL9ePfvSjJverfn5X8cvLyzV27Fg9+eSTOnbsmPbv369Ro0bJMAxJrme0N2e8rx+XOXPmKDs7W/Pnz9fRo0e1ZcsWde3a1b5NU7W7qrvOgAED9Omnn+rKlSvNqhcAnOl4swsAALRfQ4cOVW5urkwmk7p3766OHTvqjTfekKenpz7//HN5eno6rO/n52f/t8VikYeHR1uXDAAAADRw5MgRBQYG6o033lBQUJAkaciQIfrwww9VXFxsn13cv39/ff31105j/OMf/1D37t3dyte3b189//zzkqRevXppzZo1ys/P16BBg7Rhwwa9/vrrSkpKknTtJPQdd9zRaKyAgAClpKRoy5Yt9m22bdum4OBgDR06tMH6ly5danaOxjz22GMOj1977TWFhITo6NGjio2NdTtOXFyc5s2bJ+l/J9iDg4M1ZcoUSdKCBQuUm5urL774QgMHDnQ7b69evbRs2bIG+V566SXNnTtX7733noYMGSLp2myIJUuWaN++ffYvS91111368MMP9corr2jIkCHq0qWLTCaTfHx81K1bN5f7VT+/O/HLy8v13XffadSoUYqIiJAk9enTR9L/ZrTn5eUpJSVFkrR+/Xrt3btXGzZsUFZWlpuj3XBcLl68qJUrV2rNmjWaOHGiJCkyMlIJCQlu1Z6Zmdlo3fV1795d1dXV+vrrr+3rAUBL0dgAALSYr6+voqKiHJb169dPV69e1enTp3X//fe3OHZkZKT9W0R1H3pramp0+PBh+zT63r17a8eOHQ7bffLJJy3OCQAAgNuTzWbTyJEj7U0NSSorK9OYMWMcLplaVlamESNGOI1x+fJleXt7u5Xv+pnLYWFhOn36tE6dOqXq6mqHWcmBgYGyWq1NxktPT9eUKVP08ssvy2w2a/PmzXriiSfUoUPDC3W0NIczJ06c0IIFC1RYWKj//ve/9hkTZWVlzWps1B8PT09PBQUFOZwYr5s5cPr06WbldTaDZtu2bTp9+rQOHTqk/v3725efPHlSVVVVevDBBx3Wr66uVr9+/dzel/rq53cnflxcnJKSktSnTx8NHz5cycnJevzxxxUQEODWjPaW1CVdmwl/5coVe6Preq5qb6ru+iwWiyTZZ94AwI2gsQEAaFXR0dFKT0/XhAkTlJOTo379+unMmTPKz89X37599cgjj7gVx9fXV1OnTlVWVpYCAwMVHh6uZcuWqaqqyn5Dxqefflo5OTnKysrSU089pc8//1x5eXnf494BAADgVnTkyBHNmTPHYZnNZtPMmTPtj7/99lsdP35ccXFxTmMEBwfr3LlzbuXz8vJyeOzh4dHsyzfVl5aWJsMwtHPnTvXv318HDx7U7373uxbHk6QOHTo0uJRQTU1Ng7wRERFav369/T4fsbGxzb4htbPxqL+sbqZ33Ri5m9fX17dBrn79+qmoqEivvfaa7rnnHnvsS5cuSbp2340ePXo4bGM2m5u1P87yuxPf09NTe/fu1UcffaQ9e/Zo9erVmjt3rgoLC93O6c5xu35c6hoOjXFVe1N133nnnfZ16y6ZFRIS4vb+AEBjuMcGAKDVbdy4URMmTNCsWbNktVr16KOP6vDhwwoPD29WnOzsbD322GMaP3684uPjdfLkSe3evdv+zZ/w8HBt375d77zzjuLi4rR27VotWbLk+9glAAAA3KIuXLig0tJSh2/ll5SUqKKiwmHZ3/72NxmG4fQSO9K1E+ZHjx69oVoiIyPl5eXlcCL73Llz+uqrr5rcztvbW6NGjdLmzZv1hz/8QVarVfHx8TeUIyQkROXl5fbHFy5cUElJif3x2bNndfz4cc2bN09JSUnq3bu3242dG3GjeSMjI1VQUKB3331X06ZNsy+PiYmR2WxWWVmZoqKiHH7q30fDZDLp6tWrza7b3fgeHh4aPHiwFi5cqL/+9a8ymUx6++23HWa016mb0R4TE2Nf5uq4OdOrVy9ZLBbl5+e3uPbG6q7vyy+/1B133KHg4GD3Bw4AGsGMDQBAizQ1M8LLy0sLFy7UwoULnT6fkZGhjIwMlzG9vb21atUqrVq1qtFcqampSk1NdVg2adKkRtcHAAAA6rPZbPL09HS4hFHdPTfq3wfgyJEjioyMdLhvXH3Dhw/XnDlzdO7cuQaX4HGXn5+fJk+erKysLAUFBSk0NFRz5851ekmp66Wnpys1NVXFxcUaN27cDecYNmyY8vLylJaWJn9/fy1YsMDhHnoBAQEKCgrSunXrFBYWprKyMj333HMt2u/maI280dHRKigoUGJiojp27KgVK1aoU6dOyszM1MyZM1VbW6uEhARVVFTo0KFD6ty5s/3eEz179lRhYaFKS0vl5+enwMBAt46PO/ELCwuVn5+v5ORkhYaGqrCwUGfOnFHv3r3dmtEuuT5uznh7e+vXv/61Zs+eLZPJpMGDB+vMmTMqLi7W5MmTXdZ+9913N1p3fQcPHlRycnKzjhUANIbGBgAAAAAAuG3ZbDZZrVaH+2PYbLYG91Ww2WyNXoZKunaz5Pj4eL355pv6xS9+0eJ6li9frkuXLiktLU2dOnXSrFmzVFFR4XK7YcOGKTAwUMePH9fPf/7zG84xZ84clZSUKDU1VV26dNGiRYscvvnfoUMHbd26VdOnT1dsbKysVqtWrVqlxMTEFu23u1orr9Vq1V/+8hclJibK09NTOTk5WrRokUJCQrR06VL9/e9/l7+/v+Lj4/Wb3/zGvl1mZqYmTpyomJgYXb58WSUlJerZs6dbOV3F79y5sz744AOtWLFCFy5cUEREhHJycuw3C8/OzlZtba3Gjx+vixcv6p577nGY0S65Pm6NmT9/vjp27KgFCxbo3//+t8LCwvT000+7VburuqVrl3J75513tGvXLrfGCgBc8TCuv/AeAAAAAAAAmm3nzp3KysrSl19+6da3+IHbRW5urt5++23t2bPnZpcC4BbBjA0AAAAAAIBW8Mgjj+jEiRP617/+5XDfBOB25+XlpdWrV9/sMgDcQpixAQAAAAAAAAAA2g3mRQIAAAAAAAAAgHaDxgYAAAAAAAAAAGg3aGwAAAAAAAAAAIB2g8YGAAAAAAAAAABoN2hsAAAAAAAAAACAdoPGBgAAAAAAAAAAaDdobAAAAAAAAAAAgHaDxgYAAAAAAAAAAGg3aGwAAAAAAAAAAIB2g8YGAAAAAAAAAABoN/4P0zxjAGZ/iaoAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [agg_resources_and_cfunc]\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 5))\n", + "\n", + "# M history colored by Markov state\n", + "colors = np.where(Mrkv_hist == 0, \"C3\", \"C0\")\n", + "axes[0].scatter(range(len(M_hist)), M_hist, c=colors, s=1, alpha=0.5)\n", + "axes[0].set_xlabel(\"Period\")\n", + "axes[0].set_ylabel(\"$M_t$ (aggregate market resources)\")\n", + "axes[0].set_title(\"Aggregate Market Resources by Markov State\")\n", + "axes[0].axhline(\n", + " M_hist[Mrkv_hist == 0].mean(),\n", + " color=\"C3\",\n", + " ls=\"--\",\n", + " alpha=0.7,\n", + " label=\"Recession mean\",\n", + ")\n", + "axes[0].axhline(\n", + " M_hist[Mrkv_hist == 1].mean(),\n", + " color=\"C0\",\n", + " ls=\"--\",\n", + " alpha=0.7,\n", + " label=\"Expansion mean\",\n", + ")\n", + "axes[0].legend()\n", + "\n", + "# 2D consumption function slices\n", + "m_plot = np.linspace(0.01, 30, 200)\n", + "M_vals = [M_hist[Mrkv_hist == 0].mean(), M_hist[Mrkv_hist == 1].mean()]\n", + "for j in range(2):\n", + " label = \"Recession\" if j == 0 else \"Expansion\"\n", + " M_j = M_vals[j]\n", + " c_vals = consumer.solution[0].cFunc[j](m_plot, M_j * np.ones_like(m_plot))\n", + " axes[1].plot(m_plot, c_vals, label=f\"{label} (M={M_j:.1f})\", linewidth=2)\n", + "axes[1].plot(m_plot, m_plot, \":\", color=\"gray\", alpha=0.4, label=\"45° line\")\n", + "axes[1].set_xlabel(\"$m$ (individual market resources)\")\n", + "axes[1].set_ylabel(\"$c(m, M)$\")\n", + "axes[1].set_title(\"Consumption Function at Mean $M$ by State\")\n", + "axes[1].set_xlim([0, 20])\n", + "axes[1].set_ylim([0, 10])\n", + "axes[1].legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e6dc9b29", + "metadata": {}, + "source": [ + "## 3. Build Transition Matrices at the Steady State\n", + "\n", + "At a fixed aggregate state $(M, z)$, the individual transition is:\n", + "\n", + "$$m' = R \\cdot \\frac{a}{\\psi} + W \\cdot \\theta$$\n", + "\n", + "where:\n", + "- $c = c_z(m, M)$ → $a = m - c$\n", + "- $K = A_z(M)$ → capital from aggregate saving rule\n", + "- $R = R_{\\text{func}}(K)$, $W = W_{\\text{func}}(K)$ → Cobb-Douglas prices\n", + "- $(\\psi, \\theta)$ ~ idiosyncratic shock distribution for state $z$\n", + "\n", + "We build one TM per Markov state, evaluated at that state's\n", + "mean $M$ from the simulation history." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aee239fc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:36.486471Z", + "iopub.status.busy": "2026-03-21T04:29:36.486203Z", + "iopub.status.idle": "2026-03-21T04:29:36.488825Z", + "shell.execute_reply": "2026-03-21T04:29:36.488516Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m-grid: 200 points from 0.0010 to 50.0\n" + ] + } + ], + "source": [ + "mMin, mMax, mCount, mFac = 0.001, 50, 200, 3\n", + "dist_mGrid = make_grid_exp_mult(ming=mMin, maxg=mMax, ng=mCount, timestonest=mFac)\n", + "M_grid = len(dist_mGrid)\n", + "\n", + "print(f\"m-grid: {M_grid} points from {dist_mGrid[0]:.4f} to {dist_mGrid[-1]:.1f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "28a7356c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:36.490441Z", + "iopub.status.busy": "2026-03-21T04:29:36.490312Z", + "iopub.status.idle": "2026-03-21T04:29:37.426410Z", + "shell.execute_reply": "2026-03-21T04:29:37.426048Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "State 0 (Recession): M_ss=15.97, K=13.47, R=1.0431, W=1.6323\n", + " Col sums: min=1.00000000, max=1.00000000\n", + "State 1 (Expansion): M_ss=11.09, K=9.30, R=1.0614, W=1.4285\n", + " Col sums: min=1.00000000, max=1.00000000\n", + "\n", + "Transition matrices built in 0.9 seconds\n" + ] + } + ], + "source": [ + "t0 = time.time()\n", + "\n", + "J = 2\n", + "LivPrb = consumer.LivPrb[0]\n", + "\n", + "TranMatrices = []\n", + "cPols = []\n", + "aPols = []\n", + "R_vals = []\n", + "W_vals = []\n", + "\n", + "for j in range(J):\n", + " M_j = M_hist[Mrkv_hist == j].mean()\n", + " # Evaluate 2D consumption function at fixed M → 1D policy\n", + " c_j = consumer.solution[0].cFunc[j](dist_mGrid, M_j * np.ones(M_grid))\n", + " a_j = np.maximum(dist_mGrid - c_j, 0.0)\n", + " cPols.append(c_j)\n", + " aPols.append(a_j)\n", + "\n", + " # Cobb-Douglas prices: R and W from capital-to-labor ratio\n", + " # At steady state: A = aggregate assets from history\n", + " A_j = A_hist[Mrkv_hist == j].mean()\n", + " K_j = A_j\n", + " R_j = econ.Rfunc(K_j)\n", + " W_j = econ.wFunc(K_j)\n", + " R_vals.append(R_j)\n", + " W_vals.append(W_j)\n", + "\n", + " # Income shocks for this Markov state\n", + " dstn_j = consumer.IncShkDstn[0][j]\n", + " perm_shks = dstn_j.atoms[0]\n", + " tran_shks = dstn_j.atoms[1]\n", + " shk_prbs = dstn_j.pmv\n", + "\n", + " # Newborn distribution: a=0, receive transitory labor income W*θ\n", + " newborn_m = W_j * tran_shks\n", + " newborn_1d = jump_to_grid_1D(newborn_m, shk_prbs, dist_mGrid)\n", + "\n", + " # Build TM\n", + " TM_j = np.zeros((M_grid, M_grid))\n", + " for i in range(M_grid):\n", + " bNext = R_j * a_j[i]\n", + " mNext = bNext / perm_shks + W_j * tran_shks\n", + " lottery = jump_to_grid_1D(mNext, shk_prbs, dist_mGrid)\n", + " TM_j[:, i] = LivPrb * lottery + (1.0 - LivPrb) * newborn_1d\n", + "\n", + " TranMatrices.append(TM_j)\n", + "\n", + " col_sums = TM_j.sum(axis=0)\n", + " label = \"Recession\" if j == 0 else \"Expansion\"\n", + " print(f\"State {j} ({label}): M_ss={M_j:.2f}, K={K_j:.2f}, R={R_j:.4f}, W={W_j:.4f}\")\n", + " print(f\" Col sums: min={col_sums.min():.8f}, max={col_sums.max():.8f}\")\n", + "\n", + "tm_build_time = time.time() - t0\n", + "print(f\"\\nTransition matrices built in {tm_build_time:.1f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "9d17ab28", + "metadata": {}, + "source": [ + "## 4. Ergodic Distributions at Steady State\n", + "\n", + "For each Markov state, find the ergodic distribution of the TM.\n", + "Compare with the MC cross-section from the last period of the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "833a9e98", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:37.429284Z", + "iopub.status.busy": "2026-03-21T04:29:37.428997Z", + "iopub.status.idle": "2026-03-21T04:29:37.441811Z", + "shell.execute_reply": "2026-03-21T04:29:37.441410Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "State 0 (Recession):\n", + " TM mean assets (norm) = 8.4600\n", + " TM mean consumption = 1.8989\n", + "State 1 (Expansion):\n", + " TM mean assets (norm) = 7.2122\n", + " TM mean consumption = 1.7831\n", + "\n", + "Ergodic distributions computed in 0.0095 seconds\n" + ] + } + ], + "source": [ + "t0_erg = time.time()\n", + "\n", + "erg_dists = []\n", + "for j in range(J):\n", + " eigenvalues, eigenvectors = sp_linalg.eigs(\n", + " TranMatrices[j], k=1, which=\"LM\", v0=np.ones(M_grid)\n", + " )\n", + " erg_j = eigenvectors[:, 0].real\n", + " erg_j = erg_j / erg_j.sum()\n", + " erg_dists.append(erg_j)\n", + "\n", + " TM_A = np.dot(aPols[j], erg_j)\n", + " TM_C = np.dot(cPols[j], erg_j)\n", + " label = \"Recession\" if j == 0 else \"Expansion\"\n", + " print(f\"State {j} ({label}):\")\n", + " print(f\" TM mean assets (norm) = {TM_A:.4f}\")\n", + " print(f\" TM mean consumption = {TM_C:.4f}\")\n", + "erg_time = time.time() - t0_erg\n", + "print(f\"\\nErgodic distributions computed in {erg_time:.4f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f68d9036", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:37.444375Z", + "iopub.status.busy": "2026-03-21T04:29:37.444169Z", + "iopub.status.idle": "2026-03-21T04:29:37.447701Z", + "shell.execute_reply": "2026-03-21T04:29:37.447278Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Last period Markov state: 1 (Expansion)\n", + "MC mean m = 18.9503\n", + "MC mean a = 16.4317\n", + "MC mean c = 2.5185\n" + ] + } + ], + "source": [ + "# MC comparison: get cross-section from the last simulation\n", + "mc_mNrm = consumer.state_now[\"mNrm\"]\n", + "mc_aNrm = consumer.state_now[\"aNrm\"]\n", + "mc_cNrm = mc_mNrm - mc_aNrm\n", + "mc_Mrkv_now = int(Mrkv_hist[-1])\n", + "n_agents = consumer.AgentCount\n", + "\n", + "label = \"Recession\" if mc_Mrkv_now == 0 else \"Expansion\"\n", + "print(f\"Last period Markov state: {mc_Mrkv_now} ({label})\")\n", + "print(f\"MC mean m = {mc_mNrm.mean():.4f}\")\n", + "print(f\"MC mean a = {mc_aNrm.mean():.4f}\")\n", + "print(f\"MC mean c = {mc_cNrm.mean():.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a5bfdf5e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:37.449788Z", + "iopub.status.busy": "2026-03-21T04:29:37.449658Z", + "iopub.status.idle": "2026-03-21T04:29:37.639887Z", + "shell.execute_reply": "2026-03-21T04:29:37.639442Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [tm_vs_mc_distributions]\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n", + "\n", + "for j in range(J):\n", + " label = \"Recession\" if j == 0 else \"Expansion\"\n", + " color = \"C3\" if j == 0 else \"C0\"\n", + " axes[0].plot(\n", + " dist_mGrid, erg_dists[j], label=f\"TM ({label})\", linewidth=2, color=color\n", + " )\n", + "axes[0].set_xlabel(\"$m$ (normalized market resources)\")\n", + "axes[0].set_ylabel(\"Probability mass\")\n", + "axes[0].set_title(\"TM Ergodic Distributions by Markov State\")\n", + "axes[0].set_xlim([0, 30])\n", + "axes[0].legend()\n", + "\n", + "# Overlay MC histogram as proper density\n", + "j = mc_Mrkv_now\n", + "label = \"Recession\" if j == 0 else \"Expansion\"\n", + "\n", + "# TM ergodic distribution (convert mass → density for comparison)\n", + "bin_widths = np.diff(dist_mGrid)\n", + "erg_density = erg_dists[j][:-1] / bin_widths\n", + "axes[1].plot(\n", + " dist_mGrid[:-1],\n", + " erg_density,\n", + " label=f\"TM ({label}, {M_grid} pts)\",\n", + " linewidth=2,\n", + " color=COLOR_TM,\n", + ")\n", + "\n", + "# MC histogram → density\n", + "h, _ = np.histogram(mc_mNrm, bins=dist_mGrid)\n", + "h_density = h / (n_agents * bin_widths)\n", + "axes[1].plot(\n", + " dist_mGrid[:-1],\n", + " h_density,\n", + " label=f\"MC ({label}, {n_agents:,} agents)\",\n", + " alpha=0.7,\n", + " linewidth=1.5,\n", + " color=COLOR_MC,\n", + ")\n", + "axes[1].set_xlabel(\"$m$\")\n", + "axes[1].set_ylabel(\"Density\")\n", + "axes[1].set_title(f\"TM vs MC Distribution (last period = {label})\")\n", + "axes[1].set_xlim([0, 30])\n", + "axes[1].legend()\n", + "\n", + "plt.suptitle(\"Aggregate Shocks Model: Steady-State Distributions\", fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f967c25f", + "metadata": {}, + "source": [ + "## 5. Forward Propagation Through Aggregate Shocks\n", + "\n", + "The real power of TM in the KS context: propagate the distribution\n", + "forward through the **same sequence of Markov states** as the MC simulation,\n", + "and compare the implied aggregate trajectories.\n", + "\n", + "For each period $t$:\n", + "1. Use the TM for the current Markov state $z_t$\n", + "2. Propagate $\\pi_t \\to \\pi_{t+1}$\n", + "3. Compute $A_t^{TM} = \\sum_m a(m, M_t) \\cdot \\pi_t(m)$" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "32985f1c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:37.642247Z", + "iopub.status.busy": "2026-03-21T04:29:37.642103Z", + "iopub.status.idle": "2026-03-21T04:29:37.918179Z", + "shell.execute_reply": "2026-03-21T04:29:37.917691Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation(MC, TM): 0.8848\n", + "MC mean A: 8.9645\n", + "TM mean A: 7.6506\n" + ] + } + ], + "source": [ + "# [agg_assets_trajectory]\n", + "T_forward = min(200, len(Mrkv_hist))\n", + "\n", + "# Start from the ergodic distribution of the initial Markov state\n", + "j_init = int(Mrkv_hist[0])\n", + "dstn = erg_dists[j_init].copy()\n", + "\n", + "tm_A_ts = []\n", + "for t in range(T_forward):\n", + " j_t = int(Mrkv_hist[t])\n", + " A_t = np.dot(aPols[j_t], dstn)\n", + " tm_A_ts.append(A_t)\n", + " dstn = TranMatrices[j_t] @ dstn\n", + "\n", + "mc_A_ts = A_hist[:T_forward]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 5))\n", + "\n", + "axes[0].plot(\n", + " mc_A_ts,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + " alpha=0.7,\n", + " linewidth=0.8,\n", + " color=COLOR_MC,\n", + ")\n", + "axes[0].plot(\n", + " tm_A_ts,\n", + " label=f\"TM ({M_grid} grid pts)\",\n", + " linewidth=2,\n", + " color=COLOR_TM,\n", + ")\n", + "axes[0].set_xlabel(\"Period\")\n", + "axes[0].set_ylabel(\"Aggregate Assets $A_t$\")\n", + "axes[0].set_title(\"MC vs TM: Aggregate Assets Trajectory\")\n", + "axes[0].legend(fontsize=12)\n", + "\n", + "# Scatter: TM vs MC\n", + "axes[1].scatter(\n", + " mc_A_ts, tm_A_ts, s=5, alpha=0.5, c=Mrkv_hist[:T_forward], cmap=\"coolwarm\"\n", + ")\n", + "lims = [min(min(mc_A_ts), min(tm_A_ts)) * 0.95, max(max(mc_A_ts), max(tm_A_ts)) * 1.05]\n", + "axes[1].plot(lims, lims, \":\", color=\"gray\")\n", + "axes[1].set_xlabel(\"MC $A_t$\")\n", + "axes[1].set_ylabel(\"TM $A_t$\")\n", + "axes[1].set_title(\"MC vs TM: Point-by-Point\")\n", + "axes[1].set_xlim(lims)\n", + "axes[1].set_ylim(lims)\n", + "\n", + "plt.suptitle(\"Transition Matrix Tracks Aggregate Dynamics\", fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "corr = np.corrcoef(mc_A_ts, tm_A_ts)[0, 1]\n", + "print(f\"Correlation(MC, TM): {corr:.4f}\")\n", + "print(f\"MC mean A: {np.mean(mc_A_ts):.4f}\")\n", + "print(f\"TM mean A: {np.mean(tm_A_ts):.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5eabdf46", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:37.920247Z", + "iopub.status.busy": "2026-03-21T04:29:37.920139Z", + "iopub.status.idle": "2026-03-21T04:29:37.922520Z", + "shell.execute_reply": "2026-03-21T04:29:37.922185Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Timing Summary ===\n", + "TM build (2 matrices, 200 grid pts): 0.93s\n", + "Ergodic solve (2 states): 0.0095s\n", + "TM total: 0.94s\n" + ] + } + ], + "source": [ + "print(\"=== Timing Summary ===\")\n", + "print(f\"TM build (2 matrices, {M_grid} grid pts): {tm_build_time:.2f}s\")\n", + "print(f\"Ergodic solve (2 states): {erg_time:.4f}s\")\n", + "print(f\"TM total: {tm_build_time + erg_time:.2f}s\")" + ] + }, + { + "cell_type": "markdown", + "id": "dfd2a8a2", + "metadata": {}, + "source": [ + "## 6. Summary\n", + "\n", + "This notebook demonstrates the transition matrix method in the context of\n", + "the Krusell-Smith (1998) model with Markov aggregate states.\n", + "\n", + "### Key differences from partial equilibrium TM\n", + "\n", + "1. **2D policy function:** $c(m, M, z)$ depends on aggregate state $M$,\n", + " not just individual state $m$. At a fixed $M$, it reduces to a 1D policy.\n", + "\n", + "2. **Endogenous prices:** $R = R(K/L)$ and $W = W(K/L)$ where $K$ comes from\n", + " the aggregate saving rule — agents' savings determine the interest rate.\n", + "\n", + "3. **TM varies with aggregate state:** Each period's TM depends on the\n", + " current $(M_t, z_t)$ because policies and prices change.\n", + "\n", + "4. **The distribution IS the state:** In GE, the full cross-sectional\n", + " distribution matters for aggregates, not just its mean.\n", + "\n", + "### What TM buys you in Krusell-Smith\n", + "\n", + "- **Zero sampling noise** in distribution tracking → cleaner aggregate trajectories\n", + "- **Exact derivatives** (Jacobians) for sequence-space methods\n", + "- **Faster convergence** of the KS outer loop (less noise in regression)\n", + "\n", + "### Limitations of this prototype\n", + "\n", + "This notebook uses the TM at the **steady-state** M for each Markov state,\n", + "which is a simplification. A full TM-in-KS implementation would:\n", + "\n", + "1. Build TMs at **arbitrary M values** (not just the mean)\n", + "2. Recompute prices and policies at each M\n", + "3. Replace the MC simulation step entirely\n", + "4. Enable sequence-space Jacobian computation (as in Du's\n", + " `Transition_Matrix_Example.ipynb`)\n", + "\n", + "### Notebook progression\n", + "\n", + "| # | Notebook | New concept |\n", + "|---|----------|-------------|\n", + "| 1 | `markov-tm-prototype` | Hand-built TM for 2-state Markov |\n", + "| 2 | `serial-unemployment-tm` | Scaling to 4 states |\n", + "| 3 | `serial-growth-tm-2d` | 2D grid for PermGroFac ≠ 1 |\n", + "| 4 | `serial-growth-tm-harmenberg` | Harmenberg neutral measure |\n", + "| 5 | `tm-consolidation` | Validates hand-built = HARK built-in |\n", + "| 6 | **`agg-shock-markov-tm`** | **GE feedback, Krusell-Smith** |" + ] + }, + { + "cell_type": "markdown", + "id": "2d5b0c7e", + "metadata": {}, + "source": [ + "---\n", + "# Part 2: TM Inside the Krusell-Smith Loop\n", + "\n", + "This part uses `make_history_tm()` as an alternative to Monte Carlo simulation\n", + "inside the Krusell-Smith aggregate equilibrium iteration.\n" + ] + }, + { + "cell_type": "markdown", + "id": "488b6733", + "metadata": {}, + "source": [ + "## 1. Solve economy with standard MC-KS\n", + "\n", + "The calibration follows Krusell and Smith (1998, \"Income and Wealth Heterogeneity in the Macroeconomy\", *Journal of Political Economy*). The economy features a Cobb-Douglas production function with two aggregate Markov states (boom and recession) and idiosyncratic income shocks. HARK's default `CobbDouglasMarkovEconomy` parameters reproduce this canonical setup." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ac441f3b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:29:37.924497Z", + "iopub.status.busy": "2026-03-21T04:29:37.924369Z", + "iopub.status.idle": "2026-03-21T04:30:47.241916Z", + "shell.execute_reply": "2026-03-21T04:30:47.241534Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MrkvArray:\n", + "[[0.9 0.1 ]\n", + " [0.04 0.96]]\n", + "act_T = 1200\n", + "Markov state counts: [381, 819]\n", + "intercept=[-0.3342003494550243, -0.37983226022774325], slope=[1.0655394265348668, 1.0784978472319557], r-sq=[0.9999437548552532, 0.9999288221751607]\n", + "intercept=[-0.3342017740533874, -0.3798345638090846], slope=[1.0655399122174178, 1.0784986341088358], r-sq=[0.9999437547236097, 0.9999288222569891]\n", + "\n", + "MC-KS solved in 69.3 seconds\n", + "Converged AFunc intercepts: [-0.3342017740533874, -0.3798345638090846]\n", + "Converged AFunc slopes: [1.0655399122174178, 1.0784986341088358]\n" + ] + } + ], + "source": [ + "consumer = AggShockMarkovConsumerType()\n", + "consumer.cycles = 0\n", + "\n", + "econ = CobbDouglasMarkovEconomy(agents=[consumer], verbose=True)\n", + "econ.make_AggShkHist()\n", + "econ.give_agent_params()\n", + "\n", + "print(f\"MrkvArray:\\n{econ.MrkvArray}\")\n", + "print(f\"act_T = {econ.act_T}\")\n", + "J = econ.MrkvArray.shape[0]\n", + "print(f\"Markov state counts: {[np.sum(econ.MrkvNow_hist == j) for j in range(J)]}\")\n", + "\n", + "t0 = time.time()\n", + "econ.solve()\n", + "mc_time = time.time() - t0\n", + "print(f\"\\nMC-KS solved in {mc_time:.1f} seconds\")\n", + "print(f\"Converged AFunc intercepts: {econ.intercept_prev}\")\n", + "print(f\"Converged AFunc slopes: {econ.slope_prev}\")" + ] + }, + { + "cell_type": "markdown", + "id": "dc46ec9d", + "metadata": {}, + "source": [ + "## 2. Save MC history, then run TM forward propagation\n", + "**Note:** `econ.history[...]` is the aggregate KS recorder. Consumer-level YAML MC uses **`hystory`** after **`symulate()`** (`Transition_Matrix_Example.ipynb`; see also `02`–`04` in this folder).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "764dd396", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:30:47.243833Z", + "iopub.status.busy": "2026-03-21T04:30:47.243697Z", + "iopub.status.idle": "2026-03-21T04:30:47.283897Z", + "shell.execute_reply": "2026-03-21T04:30:47.283505Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TM forward propagation in 0.0 seconds\n", + " (MC-KS took 69.3 seconds total)\n" + ] + } + ], + "source": [ + "# Save MC history (make_history_tm will overwrite econ.history)\n", + "mc_M = np.array(econ.history[\"MaggNow\"]).copy()\n", + "mc_A = np.array(econ.history[\"AaggNow\"]).copy()\n", + "\n", + "t0 = time.time()\n", + "econ.make_history_tm(num_pointsM=200, mMax=50)\n", + "tm_time = time.time() - t0\n", + "print(f\"TM forward propagation in {tm_time:.1f} seconds\")\n", + "print(f\" (MC-KS took {mc_time:.1f} seconds total)\")\n", + "\n", + "tm_M = econ.history[\"MaggNow\"].copy()\n", + "tm_A = econ.history[\"AaggNow\"].copy()" + ] + }, + { + "cell_type": "markdown", + "id": "f7cb89b6", + "metadata": {}, + "source": [ + "## 3. Compare MC and TM aggregate trajectories" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "57bb1b4c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:30:47.286104Z", + "iopub.status.busy": "2026-03-21T04:30:47.285956Z", + "iopub.status.idle": "2026-03-21T04:30:47.291064Z", + "shell.execute_reply": "2026-03-21T04:30:47.290687Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC aggregate M: mean=13.7198, std=3.9894\n", + "TM aggregate M: mean=9.5907, std=0.3778\n", + " → TM/MC level difference: -30.1%\n", + "\n", + "MC aggregate A: mean=11.6146, std=3.6635\n", + "TM aggregate A: mean=7.7559, std=0.3459\n", + " → TM/MC level difference: -33.2%\n", + "\n", + "Correlation (M): 0.9457\n", + "Correlation (A): 0.9477\n" + ] + } + ], + "source": [ + "T = min(len(mc_M), len(tm_M))\n", + "mc_M_trim = mc_M[BURNIN:T]\n", + "mc_A_trim = mc_A[BURNIN:T]\n", + "tm_M_trim = tm_M[BURNIN:T]\n", + "tm_A_trim = tm_A[BURNIN:T]\n", + "\n", + "print(f\"MC aggregate M: mean={mc_M_trim.mean():.4f}, std={mc_M_trim.std():.4f}\")\n", + "print(f\"TM aggregate M: mean={tm_M_trim.mean():.4f}, std={tm_M_trim.std():.4f}\")\n", + "pct_diff_M = 100 * (tm_M_trim.mean() - mc_M_trim.mean()) / mc_M_trim.mean()\n", + "print(f\" → TM/MC level difference: {pct_diff_M:+.1f}%\")\n", + "print()\n", + "print(f\"MC aggregate A: mean={mc_A_trim.mean():.4f}, std={mc_A_trim.std():.4f}\")\n", + "print(f\"TM aggregate A: mean={tm_A_trim.mean():.4f}, std={tm_A_trim.std():.4f}\")\n", + "pct_diff_A = 100 * (tm_A_trim.mean() - mc_A_trim.mean()) / mc_A_trim.mean()\n", + "print(f\" → TM/MC level difference: {pct_diff_A:+.1f}%\")\n", + "\n", + "valid = (\n", + " np.isfinite(tm_M_trim) & np.isfinite(mc_M_trim) & (tm_M_trim > 0) & (mc_M_trim > 0)\n", + ")\n", + "if np.sum(valid) > 10:\n", + " corr_M = np.corrcoef(mc_M_trim[valid], tm_M_trim[valid])[0, 1]\n", + " corr_A = np.corrcoef(mc_A_trim[valid], tm_A_trim[valid])[0, 1]\n", + " print(f\"\\nCorrelation (M): {corr_M:.4f}\")\n", + " print(f\"Correlation (A): {corr_A:.4f}\")\n", + "else:\n", + " print(f\"\\nInsufficient valid data for correlation ({np.sum(valid)} valid points)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5bb88a33", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:30:47.293108Z", + "iopub.status.busy": "2026-03-21T04:30:47.292952Z", + "iopub.status.idle": "2026-03-21T04:30:47.481989Z", + "shell.execute_reply": "2026-03-21T04:30:47.481249Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [fig_mc_tm_trajectories]\n", + "n_agents = consumer.AgentCount\n", + "time_axis = np.arange(BURNIN, T)\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(12, 7), sharex=True)\n", + "\n", + "axes[0].plot(\n", + " time_axis, mc_M_trim, color=COLOR_MC, alpha=0.7, label=f\"MC (n={n_agents:,} agents)\"\n", + ")\n", + "axes[0].plot(\n", + " time_axis, tm_M_trim, color=COLOR_TM, alpha=0.7, label=f\"TM ({N_MC_BINS} grid pts)\"\n", + ")\n", + "axes[0].set_ylabel(\"Aggregate Market Resources (M)\")\n", + "axes[0].legend()\n", + "axes[0].grid(True, alpha=0.3)\n", + "axes[0].set_title(\"MC vs TM Aggregate Trajectories (post burn-in)\")\n", + "\n", + "axes[1].plot(\n", + " time_axis, mc_A_trim, color=COLOR_MC, alpha=0.7, label=f\"MC (n={n_agents:,} agents)\"\n", + ")\n", + "axes[1].plot(\n", + " time_axis, tm_A_trim, color=COLOR_TM, alpha=0.7, label=f\"TM ({N_MC_BINS} grid pts)\"\n", + ")\n", + "axes[1].set_ylabel(\"Aggregate Assets (A)\")\n", + "axes[1].set_xlabel(\"Period\")\n", + "axes[1].legend()\n", + "axes[1].grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1d76861d", + "metadata": {}, + "source": [ + "### Known Issue: ~22% MC/TM Level Mismatch\n", + "\n", + "The TM aggregate trajectories track the MC trajectories with very high correlation\n", + "(>0.99), but the TM **levels** are systematically ~22% lower than MC. Several\n", + "potential sources have been identified:\n", + "\n", + "1. **Distribution initialization**: `make_history_tm()` initializes agents on\n", + " a uniform grid over the asset space, while MC starts from the steady-state\n", + " distribution built up during `solve()`. This initial-condition difference\n", + " persists because the economy is hit by aggregate shocks each period that\n", + " prevent full convergence to ergodic distribution.\n", + "\n", + "2. **Neutral-measure aggregation**: The TM method aggregates in the\n", + " productivity-normalized space. Converting back to level requires\n", + " multiplying by `MeanPLvl`, but the TM does not track the permanent-income\n", + " distribution the same way MC does. If `MeanPLvl` is understated in the TM\n", + " path, aggregate levels will be biased down.\n", + "\n", + "3. **Insufficient MC burn-in**: The MC simulation discards `T_discard` initial\n", + " periods, but if the MC distribution has not fully converged by that point,\n", + " the MC mean itself may be biased (though likely upward, not downward).\n", + "\n", + "This discrepancy is documented as a known issue. A full resolution likely\n", + "requires aligning the TM initialization with the MC steady-state distribution\n", + "and verifying the permanent-income level aggregation formula." + ] + }, + { + "cell_type": "markdown", + "id": "bb05364f", + "metadata": {}, + "source": [ + "## 4. Fit AFunc from TM history" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5c5ffeb1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:30:47.484643Z", + "iopub.status.busy": "2026-03-21T04:30:47.484495Z", + "iopub.status.idle": "2026-03-21T04:30:47.489091Z", + "shell.execute_reply": "2026-03-21T04:30:47.488749Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AFunc comparison (MC-converged vs TM-fitted):\n", + "State MC intercept TM intercept MC slope TM slope TM R²\n", + "0 -0.334202 -0.452430 1.065540 1.106994 0.999766\n", + "1 -0.379835 -0.474102 1.078499 1.115256 0.999820\n" + ] + } + ], + "source": [ + "from scipy import stats as sp_stats\n", + "\n", + "logAagg_tm = np.log(np.maximum(tm_A_trim, 1e-10))\n", + "# Lag by 1 period: AFunc predicts log(A') from log(M) in the previous period\n", + "logMagg_tm = np.log(np.maximum(tm_M[BURNIN - 1 : T - 1], 1e-10))\n", + "MrkvHist_tm = econ.MrkvNow_hist[BURNIN - 1 : T - 1]\n", + "\n", + "StateCount = econ.MrkvArray.shape[0]\n", + "print(\"AFunc comparison (MC-converged vs TM-fitted):\")\n", + "print(\n", + " f\"{'State':<6} {'MC intercept':>14} {'TM intercept':>14} {'MC slope':>10} {'TM slope':>10} {'TM R²':>8}\"\n", + ")\n", + "for j in range(StateCount):\n", + " these = j == MrkvHist_tm\n", + " n = np.sum(these)\n", + " if n < 10:\n", + " print(f\"{j:<6} insufficient data (n={n})\")\n", + " continue\n", + " slope, intercept, r_value, _, _ = sp_stats.linregress(\n", + " logMagg_tm[these], logAagg_tm[these]\n", + " )\n", + " print(\n", + " f\"{j:<6} {econ.intercept_prev[j]:>14.6f} {intercept:>14.6f} \"\n", + " f\"{econ.slope_prev[j]:>10.6f} {slope:>10.6f} {r_value**2:>8.6f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b0b388b5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:30:47.491045Z", + "iopub.status.busy": "2026-03-21T04:30:47.490921Z", + "iopub.status.idle": "2026-03-21T04:30:47.675503Z", + "shell.execute_reply": "2026-03-21T04:30:47.675036Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [fig_afunc_scatter]\n", + "fig, axes = plt.subplots(1, StateCount, figsize=(6 * StateCount, 5), sharey=True)\n", + "if StateCount == 1:\n", + " axes = [axes]\n", + "\n", + "state_labels = {0: \"Recession\", 1: \"Boom\"}\n", + "for j in range(StateCount):\n", + " ax = axes[j]\n", + " these = j == MrkvHist_tm\n", + " if np.sum(these) < 10:\n", + " continue\n", + "\n", + " log_m = logMagg_tm[these]\n", + " log_a = logAagg_tm[these]\n", + "\n", + " ax.scatter(log_m, log_a, s=8, alpha=0.4, color=COLOR_TM, label=\"TM data\")\n", + "\n", + " m_range = np.linspace(log_m.min(), log_m.max(), 50)\n", + " ax.plot(\n", + " m_range,\n", + " econ.intercept_prev[j] + econ.slope_prev[j] * m_range,\n", + " color=COLOR_MC,\n", + " linewidth=2,\n", + " label=\"MC-converged AFunc\",\n", + " )\n", + "\n", + " slope, intercept, r_value, _, _ = sp_stats.linregress(log_m, log_a)\n", + " ax.plot(\n", + " m_range,\n", + " intercept + slope * m_range,\n", + " color=COLOR_TM,\n", + " linewidth=2,\n", + " linestyle=\"--\",\n", + " label=f\"TM-fitted (R²={r_value**2:.4f})\",\n", + " )\n", + "\n", + " ax.set_xlabel(\"log(M)\")\n", + " ax.set_ylabel(\"log(A')\")\n", + " ax.set_title(f\"State {j} ({state_labels.get(j, '')})\")\n", + " ax.legend(fontsize=9)\n", + " ax.grid(True, alpha=0.3)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "95a12ffd", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "The `make_history_tm()` method forward-propagates a distribution via\n", + "transition matrices as an alternative to Monte Carlo in the KS loop.\n", + "\n", + "Key properties:\n", + "- **Deterministic**: Zero sampling noise for given aggregate shock sequence.\n", + "- **Fast**: Building a 1D TM at each time step via numba is much faster\n", + " than simulating thousands of agents.\n", + "- **Compatible**: Produces the same `history` dict as `make_history()`.\n", + "\n", + "**Known limitation**: The TM and MC aggregate trajectories are highly\n", + "correlated (>0.99) but exhibit a persistent ~22% level mismatch, with TM\n", + "levels systematically lower. This likely stems from differences in\n", + "distribution initialization and/or the neutral-measure ↔ level aggregation.\n", + "See the investigation note above for details.\n" + ] + } + ], + "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.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/MonteCarlovsTransitionMatrix/PE_MarkovConsumerType.ipynb b/examples/MonteCarlovsTransitionMatrix/PE_MarkovConsumerType.ipynb new file mode 100644 index 000000000..d60cb10ea --- /dev/null +++ b/examples/MonteCarlovsTransitionMatrix/PE_MarkovConsumerType.ipynb @@ -0,0 +1,2881 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "09801c4c", + "metadata": {}, + "source": [ + "# Partial-Equilibrium MC vs TM for MarkovConsumerType\n", + "\n", + "This notebook compares **Monte Carlo** simulation (`initialize_sym()` / `symulate()` / `hystory`)\n", + "with **transition-matrix** (TM) methods for `MarkovConsumerType` models of\n", + "increasing complexity:\n", + "\n", + "| Part | Model | TM grid | Key challenge |\n", + "|------|-------|---------|---------------|\n", + "| 1 | 4-state serial unemployment | 1D over $m$ | Multiple discrete states |\n", + "| 2 | 5-state varying PermGroFac | 2D over $(m, p)$ | Non-degenerate $p$ distribution |\n", + "| 3 | Same model, Harmenberg measure | 1D over $m$ | Neutral measure collapses $p$ dimension |\n", + "\n", + "Each part sets up a model, runs MC, builds a TM, and compares aggregate\n", + "statistics, time-series paths, and cross-sectional distributions.\n", + "\n", + "See also: `examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb`\n", + "for the `NewKeynesianConsumerType` version of these comparisons.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "73a5d0ec", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:57.035444Z", + "iopub.status.busy": "2026-03-21T04:23:57.035341Z", + "iopub.status.idle": "2026-03-21T04:23:59.290500Z", + "shell.execute_reply": "2026-03-21T04:23:59.290025Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "from copy import copy\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.cm as cm\n", + "import numpy as np\n", + "import scipy.sparse.linalg as sp_linalg\n", + "\n", + "from HARK.ConsumptionSaving.ConsMarkovModel import (\n", + " MarkovConsumerType,\n", + " init_indshk_markov,\n", + ")\n", + "from HARK.Calibration.Income.IncomeProcesses import (\n", + " construct_lognormal_income_process_unemployment,\n", + ")\n", + "from HARK.distributions import DiscreteDistributionLabeled\n", + "from HARK.utilities import make_grid_exp_mult, jump_to_grid_1D, jump_to_grid_2D\n", + "\n", + "COLOR_MC = \"tab:blue\"\n", + "COLOR_TM = \"tab:orange\"\n", + "BURNIN = 400\n", + "N_MC_BINS = 200" + ] + }, + { + "cell_type": "markdown", + "id": "25c40dcc", + "metadata": {}, + "source": [ + "---\n", + "# Part 1: Serial Unemployment (4-State Markov, 1D Grid)\n" + ] + }, + { + "cell_type": "markdown", + "id": "1e67167f", + "metadata": {}, + "source": [ + "## 1. Model Setup\n", + "\n", + "We construct the 4×4 Markov transition matrix from economic primitives:\n", + "average unemployment spell length, unemployment rates in boom/bust, and\n", + "transition probabilities between macro states.\n", + "\n", + "**HARK convention:** `MrkvArray` is row-stochastic — `MrkvArray[i, j]`\n", + "= P(transition to state $j$ | currently in state $i$).\n", + "\n", + "**Calibration:** Starts from HARK's `init_indshk_markov` defaults, then\n", + "overrides with custom values chosen for illustration: `Rfree = 1.03`,\n", + "`LivPrb = 0.98`, `PermGroFac = 1.0` (all states identical). Income\n", + "distributions are degenerate: employed agents get $\\theta = 1$, unemployed\n", + "get $\\theta = 0$. The Markov transition matrix is built from labor-market\n", + "primitives (unemployment spell length, unemployment rates, business-cycle\n", + "transition probabilities) chosen for pedagogical clarity." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "309bb667", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:59.293129Z", + "iopub.status.busy": "2026-03-21T04:23:59.292968Z", + "iopub.status.idle": "2026-03-21T04:23:59.299368Z", + "shell.execute_reply": "2026-03-21T04:23:59.298908Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Markov transition matrix (row-stochastic):\n", + "[[0.9796 0.0104 0.0099 0.0001]\n", + " [0.198 0.792 0.002 0.008 ]\n", + " [0.0486 0.0014 0.9241 0.0259]\n", + " [0.01 0.04 0.19 0.76 ]]\n", + "Row sums: [1. 1. 1. 1.]\n", + "\n", + "Stationary distribution:\n", + " Emp-Boom : 0.7894\n", + " Unemp-Boom : 0.0440\n", + " Emp-Bust : 0.1488\n", + " Unemp-Bust : 0.0179\n" + ] + } + ], + "source": [ + "unemp_length = 5 # Average length of unemployment spell\n", + "urate_good = 0.05 # Unemployment rate in boom\n", + "urate_bad = 0.12 # Unemployment rate in bust\n", + "bust_prob = 0.01 # P(boom -> bust) per period\n", + "recession_length = 20 # Average length of bust\n", + "\n", + "p_reemploy = 1.0 / unemp_length\n", + "p_unemploy_good = p_reemploy * urate_good / (1 - urate_good)\n", + "p_unemploy_bad = p_reemploy * urate_bad / (1 - urate_bad)\n", + "boom_prob = 1.0 / recession_length\n", + "\n", + "# Row-stochastic: MrkvArray[i, j] = P(go to j | in i)\n", + "# States: 0=emp-boom, 1=unemp-boom, 2=emp-bust, 3=unemp-bust\n", + "MrkvArray = np.array(\n", + " [\n", + " [\n", + " (1 - p_unemploy_good) * (1 - bust_prob),\n", + " p_unemploy_good * (1 - bust_prob),\n", + " (1 - p_unemploy_good) * bust_prob,\n", + " p_unemploy_good * bust_prob,\n", + " ],\n", + " [\n", + " p_reemploy * (1 - bust_prob),\n", + " (1 - p_reemploy) * (1 - bust_prob),\n", + " p_reemploy * bust_prob,\n", + " (1 - p_reemploy) * bust_prob,\n", + " ],\n", + " [\n", + " (1 - p_unemploy_bad) * boom_prob,\n", + " p_unemploy_bad * boom_prob,\n", + " (1 - p_unemploy_bad) * (1 - boom_prob),\n", + " p_unemploy_bad * (1 - boom_prob),\n", + " ],\n", + " [\n", + " p_reemploy * boom_prob,\n", + " (1 - p_reemploy) * boom_prob,\n", + " p_reemploy * (1 - boom_prob),\n", + " (1 - p_reemploy) * (1 - boom_prob),\n", + " ],\n", + " ]\n", + ")\n", + "\n", + "J = 4\n", + "state_names = [\"Emp-Boom\", \"Unemp-Boom\", \"Emp-Bust\", \"Unemp-Bust\"]\n", + "\n", + "print(\"Markov transition matrix (row-stochastic):\")\n", + "print(np.array2string(MrkvArray, precision=4, suppress_small=True))\n", + "print(f\"Row sums: {MrkvArray.sum(axis=1)}\")\n", + "\n", + "# Stationary distribution\n", + "eigvals, eigvecs = np.linalg.eig(MrkvArray.T)\n", + "idx = np.argmin(np.abs(eigvals - 1.0))\n", + "markov_stationary = eigvecs[:, idx].real\n", + "markov_stationary = markov_stationary / markov_stationary.sum()\n", + "print(\"\\nStationary distribution:\")\n", + "for j in range(J):\n", + " print(f\" {state_names[j]:15s}: {markov_stationary[j]:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5a9baa7b", + "metadata": {}, + "source": [ + "## 2. Solve the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0960e2e9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:59.302155Z", + "iopub.status.busy": "2026-03-21T04:23:59.302006Z", + "iopub.status.idle": "2026-03-21T04:23:59.453876Z", + "shell.execute_reply": "2026-03-21T04:23:59.453536Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solved: 4 consumption functions\n" + ] + } + ], + "source": [ + "# Start from HARK's init_indshk_markov defaults, then customize for 4-state model\n", + "params = copy(init_indshk_markov)\n", + "params[\"cycles\"] = 0 # infinite horizon\n", + "params[\"AgentCount\"] = 100000\n", + "params[\"T_sim\"] = 1200\n", + "params[\"Rfree\"] = [np.array([1.03, 1.03, 1.03, 1.03])]\n", + "params[\"LivPrb\"] = [np.array([0.98, 0.98, 0.98, 0.98])]\n", + "params[\"PermGroFac\"] = [np.array([1.0, 1.0, 1.0, 1.0])] # 1D grid\n", + "params[\"MrkvPrbsInit\"] = markov_stationary\n", + "params[\"Mrkv_p11\"] = [0.5] # placeholder — will be overridden\n", + "params[\"Mrkv_p22\"] = [0.5]\n", + "params[\"UnempPrb\"] = np.zeros(2) # no extra unemployment on top of Markov\n", + "params[\"global_markov\"] = False\n", + "\n", + "agent = MarkovConsumerType(**params)\n", + "\n", + "# Override MrkvArray with our 4×4 matrix AFTER construction\n", + "agent.assign_parameters(MrkvArray=[MrkvArray])\n", + "\n", + "# Override income distributions: degenerate (deterministic given state)\n", + "employed_income = DiscreteDistributionLabeled(\n", + " pmv=np.ones(1),\n", + " atoms=np.array([[1.0], [1.0]]),\n", + " var_names=[\"PermShk\", \"TranShk\"],\n", + ")\n", + "unemployed_income = DiscreteDistributionLabeled(\n", + " pmv=np.ones(1),\n", + " atoms=np.array([[1.0], [0.0]]),\n", + " var_names=[\"PermShk\", \"TranShk\"],\n", + ")\n", + "agent.IncShkDstn = [\n", + " [\n", + " employed_income, # state 0: employed-boom\n", + " unemployed_income, # state 1: unemployed-boom\n", + " employed_income, # state 2: employed-bust\n", + " unemployed_income, # state 3: unemployed-bust\n", + " ]\n", + "]\n", + "\n", + "# Re-build terminal solution for 4 states (constructor made it for 2)\n", + "from HARK.ConsumptionSaving.ConsMarkovModel import make_markov_solution_terminal\n", + "\n", + "agent.solution_terminal = make_markov_solution_terminal(agent.CRRA, agent.MrkvArray)\n", + "\n", + "agent.solve()\n", + "print(f\"Solved: {len(agent.solution[0].cFunc)} consumption functions\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8708c2b1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:59.456626Z", + "iopub.status.busy": "2026-03-21T04:23:59.456333Z", + "iopub.status.idle": "2026-03-21T04:23:59.893526Z", + "shell.execute_reply": "2026-03-21T04:23:59.893141Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [consumption_functions_by_state]\n", + "m_plot = np.linspace(0.001, 20, 300)\n", + "\n", + "plt.figure(figsize=(12, 7))\n", + "colors = [\"#2ecc71\", \"#e74c3c\", \"#27ae60\", \"#c0392b\"]\n", + "styles = [\"-\", \"-\", \"--\", \"--\"]\n", + "for j in range(J):\n", + " c_vals = agent.solution[0].cFunc[j](m_plot)\n", + " plt.plot(\n", + " m_plot,\n", + " c_vals,\n", + " label=state_names[j],\n", + " linewidth=2,\n", + " color=colors[j],\n", + " linestyle=styles[j],\n", + " )\n", + "plt.plot(m_plot, m_plot, \":\", color=\"gray\", alpha=0.4, label=\"45° line\")\n", + "plt.xlabel(\"Market resources $m$\", fontsize=12)\n", + "plt.ylabel(\"Consumption $c$\", fontsize=12)\n", + "plt.title(\n", + " \"Consumption Functions by Markov State (4-State Serial Unemployment)\", fontsize=13\n", + ")\n", + "plt.legend(fontsize=11)\n", + "plt.xlim([0, 20])\n", + "plt.ylim([0, 10])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0ba580e0", + "metadata": {}, + "source": [ + "## 3. Monte Carlo Simulation\n", + "\n", + "We use the YAML-backed simulator: **`initialize_sym()`** then **`symulate()`**, with tracked series in **`hystory`** (the modern replacement for legacy `history`).\n", + "Same pattern as `examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3da072ab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:59.895321Z", + "iopub.status.busy": "2026-03-21T04:23:59.895190Z", + "iopub.status.idle": "2026-03-21T04:24:25.380207Z", + "shell.execute_reply": "2026-03-21T04:24:25.379429Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC simulation: 25.48s (100,000 agents, 1200 periods)\n", + "MC Aggregate Consumption = 0.969969\n", + "MC Aggregate Assets = 3.405530\n", + "\n", + "Emp-Boom : MC frac = 0.7898, stationary = 0.7894\n", + "Unemp-Boom : MC frac = 0.0438, stationary = 0.0440\n", + "Emp-Bust : MC frac = 0.1489, stationary = 0.1488\n", + "Unemp-Bust : MC frac = 0.0176, stationary = 0.0179\n" + ] + } + ], + "source": [ + "agent.track_vars = [\"aNrm\", \"cNrm\", \"mNrm\", \"pLvl\", \"Mrkv\"]\n", + "\n", + "t0_mc = time.time()\n", + "agent.initialize_sym()\n", + "agent.symulate()\n", + "mc_sim_time = time.time() - t0_mc\n", + "\n", + "n_agents = agent.AgentCount\n", + "HY = agent.hystory\n", + "t_last = -1\n", + "MC_C = np.mean(HY[\"mNrm\"][t_last] - HY[\"aNrm\"][t_last])\n", + "MC_A = np.mean(HY[\"aNrm\"][t_last])\n", + "\n", + "print(f\"MC simulation: {mc_sim_time:.2f}s ({n_agents:,} agents, {agent.T_sim} periods)\")\n", + "print(f\"MC Aggregate Consumption = {MC_C:.6f}\")\n", + "print(f\"MC Aggregate Assets = {MC_A:.6f}\")\n", + "print()\n", + "for j in range(J):\n", + " frac = np.mean(HY[\"Mrkv\"][t_last] == j)\n", + " print(\n", + " f\"{state_names[j]:15s}: MC frac = {frac:.4f}, \"\n", + " f\"stationary = {markov_stationary[j]:.4f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cc1fc39c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:25.384375Z", + "iopub.status.busy": "2026-03-21T04:24:25.384142Z", + "iopub.status.idle": "2026-03-21T04:24:25.770323Z", + "shell.execute_reply": "2026-03-21T04:24:25.769842Z" + } + }, + "outputs": [], + "source": [ + "mc_aLvls = np.array([np.mean(agent.hystory[\"aNrm\"][t]) for t in range(agent.T_sim)])" + ] + }, + { + "cell_type": "markdown", + "id": "ca0c69ce", + "metadata": {}, + "source": [ + "## 4. Transition Matrix Construction\n", + "\n", + "The joint state is $(m, j)$ with $j \\in \\{0,1,2,3\\}$ and $m$ on a\n", + "grid of $M$ points. Total TM size: $(4M)^2$.\n", + "\n", + "Since income distributions are degenerate (1 shock point per state),\n", + "each source grid point maps to at most 2 target grid points via the lottery.\n", + "This makes the TM very sparse." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d32b416c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:25.773599Z", + "iopub.status.busy": "2026-03-21T04:24:25.772501Z", + "iopub.status.idle": "2026-03-21T04:24:25.777355Z", + "shell.execute_reply": "2026-03-21T04:24:25.777002Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m-grid: 300 points from 0.0010 to 50.0\n", + "Markov states: 4\n", + "Total TM states: 1200\n" + ] + } + ], + "source": [ + "mMin = 0.001\n", + "mMax = 50\n", + "mCount = 300\n", + "mFac = 3\n", + "\n", + "dist_mGrid = make_grid_exp_mult(ming=mMin, maxg=mMax, ng=mCount, timestonest=mFac)\n", + "\n", + "M = len(dist_mGrid)\n", + "N_states = M * J\n", + "\n", + "print(f\"m-grid: {M} points from {dist_mGrid[0]:.4f} to {dist_mGrid[-1]:.1f}\")\n", + "print(f\"Markov states: {J}\")\n", + "print(f\"Total TM states: {N_states}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "140a2a1c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:25.779293Z", + "iopub.status.busy": "2026-03-21T04:24:25.779127Z", + "iopub.status.idle": "2026-03-21T04:24:26.711988Z", + "shell.execute_reply": "2026-03-21T04:24:26.711434Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transition matrix built in 0.92s\n", + "Shape: (1200, 1200)\n", + "Column sums: min=1.00000000, max=1.00000000\n", + "Non-zero entries: 16634 / 1440000 (1.16%)\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "\n", + "MrkvArr = agent.MrkvArray[0]\n", + "Rfree_arr = agent.Rfree[0]\n", + "LivPrb_arr = agent.LivPrb[0]\n", + "PermGroFac_arr = agent.PermGroFac[0]\n", + "IncShkDstn_list = agent.IncShkDstn[0]\n", + "\n", + "# Policy on grid\n", + "cPol = []\n", + "aPol = []\n", + "for j in range(J):\n", + " c_j = agent.solution[0].cFunc[j](dist_mGrid)\n", + " a_j = np.maximum(dist_mGrid - c_j, 0.0)\n", + " cPol.append(c_j)\n", + " aPol.append(a_j)\n", + "\n", + "# Newborn distribution\n", + "MrkvPrbsInit = markov_stationary\n", + "NewBornDist = np.zeros(N_states)\n", + "for jp in range(J):\n", + " shk_dstn = IncShkDstn_list[jp]\n", + " newborn_m = jump_to_grid_1D(shk_dstn.atoms[1], shk_dstn.pmv, dist_mGrid)\n", + " NewBornDist[jp * M : (jp + 1) * M] = MrkvPrbsInit[jp] * newborn_m\n", + "\n", + "# Build transition matrix\n", + "# MrkvArr[j, jp] = P(j -> jp) [row-stochastic]\n", + "TranMatrix = np.zeros((N_states, N_states))\n", + "\n", + "for j in range(J):\n", + " a_grid = aPol[j]\n", + " LivPrb_j = LivPrb_arr[j]\n", + "\n", + " for jp in range(J):\n", + " markov_prob = MrkvArr[j, jp]\n", + " if markov_prob < 1e-15:\n", + " continue\n", + "\n", + " Rfree_jp = Rfree_arr[jp]\n", + " PermGroFac_jp = PermGroFac_arr[jp]\n", + " shk_dstn = IncShkDstn_list[jp]\n", + " shk_prbs = shk_dstn.pmv\n", + " perm_shks = shk_dstn.atoms[0]\n", + " tran_shks = shk_dstn.atoms[1]\n", + " bNext = Rfree_jp * a_grid\n", + "\n", + " for i in range(M):\n", + " mNext = bNext[i] / (perm_shks * PermGroFac_jp) + tran_shks\n", + " lottery_weights = jump_to_grid_1D(mNext, shk_prbs, dist_mGrid)\n", + " src_idx = j * M + i\n", + " TranMatrix[jp * M : (jp + 1) * M, src_idx] += (\n", + " markov_prob * LivPrb_j * lottery_weights\n", + " )\n", + "\n", + " for i in range(M):\n", + " src_idx = j * M + i\n", + " TranMatrix[:, src_idx] += (1.0 - LivPrb_j) * NewBornDist\n", + "\n", + "tm_build_time = time.time() - start\n", + "print(f\"Transition matrix built in {tm_build_time:.2f}s\")\n", + "print(f\"Shape: {TranMatrix.shape}\")\n", + "col_sums = TranMatrix.sum(axis=0)\n", + "print(f\"Column sums: min={col_sums.min():.8f}, max={col_sums.max():.8f}\")\n", + "\n", + "nnz = np.count_nonzero(TranMatrix)\n", + "total = N_states * N_states\n", + "print(f\"Non-zero entries: {nnz} / {total} ({100 * nnz / total:.2f}%)\")" + ] + }, + { + "cell_type": "markdown", + "id": "86ccabff", + "metadata": {}, + "source": [ + "## 5. Ergodic Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f20d5723", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:26.714371Z", + "iopub.status.busy": "2026-03-21T04:24:26.714209Z", + "iopub.status.idle": "2026-03-21T04:24:26.746758Z", + "shell.execute_reply": "2026-03-21T04:24:26.746336Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ergodic distribution computed in 0.03s\n", + "\n", + "Emp-Boom : TM mass = 0.7894, stationary = 0.7894\n", + "Unemp-Boom : TM mass = 0.0440, stationary = 0.0440\n", + "Emp-Bust : TM mass = 0.1488, stationary = 0.1488\n", + "Unemp-Bust : TM mass = 0.0179, stationary = 0.0179\n", + "\n", + "--- Timing Summary ---\n", + "MC simulation: 25.48s (100,000 agents)\n", + "TM build + ergo: 0.95s (300 m-pts × 4 states)\n", + "Speedup: 26.8×\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "eigenvalues, eigenvectors = sp_linalg.eigs(\n", + " TranMatrix, k=1, which=\"LM\", v0=np.ones(N_states)\n", + ")\n", + "ergodic_dist = eigenvectors[:, 0].real\n", + "ergodic_dist = ergodic_dist / ergodic_dist.sum()\n", + "\n", + "tm_ergo_time = time.time() - start\n", + "print(f\"Ergodic distribution computed in {tm_ergo_time:.2f}s\")\n", + "print()\n", + "for j in range(J):\n", + " mass_j = ergodic_dist[j * M : (j + 1) * M].sum()\n", + " print(\n", + " f\"{state_names[j]:15s}: TM mass = {mass_j:.4f}, \"\n", + " f\"stationary = {markov_stationary[j]:.4f}\"\n", + " )\n", + "\n", + "tm_total_time = tm_build_time + tm_ergo_time\n", + "print(\"\\n--- Timing Summary ---\")\n", + "print(f\"MC simulation: {mc_sim_time:.2f}s ({n_agents:,} agents)\")\n", + "print(f\"TM build + ergo: {tm_total_time:.2f}s ({mCount} m-pts × {J} states)\")\n", + "print(f\"Speedup: {mc_sim_time / tm_total_time:.1f}×\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fefe2c24", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:26.749198Z", + "iopub.status.busy": "2026-03-21T04:24:26.749059Z", + "iopub.status.idle": "2026-03-21T04:24:26.752101Z", + "shell.execute_reply": "2026-03-21T04:24:26.751666Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TM Aggregate Consumption = 0.970207\n", + "TM Aggregate Assets = 3.408579\n" + ] + } + ], + "source": [ + "TM_C = sum(np.dot(cPol[j], ergodic_dist[j * M : (j + 1) * M]) for j in range(J))\n", + "TM_A = sum(np.dot(aPol[j], ergodic_dist[j * M : (j + 1) * M]) for j in range(J))\n", + "\n", + "print(f\"TM Aggregate Consumption = {TM_C:.6f}\")\n", + "print(f\"TM Aggregate Assets = {TM_A:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "97fb5cbd", + "metadata": {}, + "source": [ + "## 6. Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7d527fd5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:26.754485Z", + "iopub.status.busy": "2026-03-21T04:24:26.754372Z", + "iopub.status.idle": "2026-03-21T04:24:26.757196Z", + "shell.execute_reply": "2026-03-21T04:24:26.756646Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Aggregate Comparison ===\n", + " MC TM Diff\n", + "Consumption 0.969969 0.970207 -0.000237\n", + "Assets 3.405530 3.408579 -0.003049\n" + ] + } + ], + "source": [ + "print(\"=== Aggregate Comparison ===\")\n", + "print(f\"{'':20s} {'MC':>12s} {'TM':>12s} {'Diff':>12s}\")\n", + "print(f\"{'Consumption':20s} {MC_C:12.6f} {TM_C:12.6f} {MC_C - TM_C:12.6f}\")\n", + "print(f\"{'Assets':20s} {MC_A:12.6f} {TM_A:12.6f} {MC_A - TM_A:12.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "dafa1def", + "metadata": {}, + "source": [ + "### Time series comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cc407d13", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:26.759824Z", + "iopub.status.busy": "2026-03-21T04:24:26.759654Z", + "iopub.status.idle": "2026-03-21T04:24:26.950480Z", + "shell.execute_reply": "2026-03-21T04:24:26.949932Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [mc_vs_tm_asset_paths]\n", + "dstn = ergodic_dist.copy()\n", + "tm_aLvls = []\n", + "for t in range(agent.T_sim - BURNIN):\n", + " A_val = sum(np.dot(aPol[j], dstn[j * M : (j + 1) * M]) for j in range(J))\n", + " tm_aLvls.append(A_val)\n", + " dstn = TranMatrix @ dstn\n", + "\n", + "plt.figure(figsize=(16, 6))\n", + "plt.plot(\n", + " mc_aLvls[BURNIN:],\n", + " color=COLOR_MC,\n", + " alpha=0.7,\n", + " linewidth=0.8,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + ")\n", + "plt.plot(\n", + " tm_aLvls, color=COLOR_TM, linewidth=2.5, label=f\"TM ({mCount} m-pts × {J} states)\"\n", + ")\n", + "plt.xlabel(\"Period (after burn-in)\")\n", + "plt.ylabel(\"Aggregate Assets (normalized)\")\n", + "plt.title(\"MC vs TM: Aggregate Assets — Serial Unemployment Model\")\n", + "plt.legend(fontsize=12)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "77b11335", + "metadata": {}, + "source": [ + "### Distribution of $m$ by Markov state\n", + "\n", + "With degenerate income (unemployed get exactly 0), the unemployed distribution\n", + "should show a sharp spike near $m = 0$ — all their market resources come from\n", + "prior savings times $R$." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e9a4efa7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:26.953504Z", + "iopub.status.busy": "2026-03-21T04:24:26.953222Z", + "iopub.status.idle": "2026-03-21T04:24:27.780204Z", + "shell.execute_reply": "2026-03-21T04:24:27.779798Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAScCAYAAAAoOLYFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3QUVRvH8d+mB0ISWgglQACRXlWkSIeASFEEFJUqvipFmkiUqiKIoKBSbBSVIkWwg4BUaYIEEemEIhCKQEJNQnLfPzBrltSFJJsl3885e8jeuTPzzGbD2bvP3PtYjDFGAAAAAAAAAAAATsDF0QEAAAAAAAAAAACkF4kNAAAAAAAAAADgNEhsAAAAAAAAAAAAp0FiAwAAAAAAAAAAOA0SGwAAAAAAAAAAwGmQ2AAAAAAAAAAAAE6DxAYAAAAAAAAAAHAaJDYAAAAAAAAAAIDTILEBAAAAAAAAAACcBokNAAAAAAAAAADgNEhsAAAAAAAAAAAAp0FiAwAAAFZHjhyRxWJRt27dssW516xZI4vFolGjRmV5PKnF5UxiY2M1atQo3XPPPfL09JTFYtHSpUsdHVa2+N1mF7wWAAAAgH1IbAAAANxlEr6IT/zIlSuXihQpoiZNmmjEiBE6dOhQhp/XWb+cdda402vixIkaPXq0ihQposGDB2vkyJEqV66co8NymMR/H4GBgbpx40ay/fbs2WPtV7JkyawNMpu6cuWK3nrrLdWoUUM+Pj7y9PRUsWLF9NBDDyk0NNTm/5WM/Lu62/9GAQAAYD83RwcAAACAzFG6dGk9/fTTkqTo6GidOXNGW7du1RtvvKG33npLQ4YM0ZgxY2SxWKz7FC1aVHv27JGfn1+Wx+vIc6cmu8aVXt9//718fHy0YsUKeXh4ODqcbMPNzU2nT5/Wjz/+qDZt2iTZ/tlnn8nFhfvAEly6dEn16tXTH3/8oTJlyujpp59W/vz5de7cOW3dulXjxo1T6dKlVbp0aUeHCgAAgByAxAYAAMBdqkyZMsne4bxhwwY988wzGjt2rFxdXfXGG29Yt7m7uzvsbn5Hnjs12TWu9Dp58qTy589PUuMWderU0c6dOzVjxowkiY0bN27oyy+/VNOmTbV27VoHRZi9TJo0SX/88YeeffZZffzxxzYJUUkKDw9XdHS0g6IDAABATsMtSAAAADlMvXr1tGzZMnl6emr8+PE6fvy4dVtK9SQWL16sBg0aKCAgQF5eXipSpIiaNm2qxYsXS5JGjRqlRo0aSZJGjx5tswzWkSNHJNkuJ7Nx40Y1b95c/v7+1i9I06plsWHDBjVs2FB58uSRv7+/2rdvr4MHDybpN2vWLFksFs2aNSvJtluXtElP3KnFNXPmTNWqVUs+Pj7y8fFRrVq10jzvtm3b1KxZM+XJk0d+fn569NFHredKr/Scd9SoUbJYLAoPD9fRo0ftWlZp0aJFslgsmjRpkn7++Wc1atRIefLkUaFChfTyyy8rPj7e2q9u3bry8fFR8eLFNW7cOLuuI0Fav9uVK1fKYrHoxRdfTHb/Q4cOycXFRSEhIek+p7e3t5544gn98MMPOnPmjM2277//XqdPn1aPHj2S3TcmJkYffPCBQkJCFBQUJE9PTwUEBOixxx7Tjh07kvRP672fksjISDVo0EAuLi764IMPbLal5z2wfv16WSyWFK/jzJkzcnd3V926dVONQ5I2bdokSerdu3eycQcHB1sTgOn5u0rva5ieYyVYt26dWrdurQIFCsjT01P33HOPhg0bpqtXr6Z5fQAAAHAuzNgAAADIge6991517NhRX3zxhZYuXaq+ffum2HfatGl68cUXVbhwYT366KPKnz+/IiIitHXrVi1ZskTt27dXw4YNdeTIEc2ePVsNGjRQw4YNrfv7+/vbHG/jxo1666231KhRIz333HM6duxYmvFu3rxZY8eOVYsWLdS3b1/t3r1bS5Ys0fr167V582aVKlXqtl4He+K+Vb9+/fTBBx+oaNGi6tmzp6SbCaDu3btrx44dmjx5cpJ9fvvtN40fP16NGjXS//73P+3YsUNLly7Vrl279Oeff8rLyyvNmNN73oRrmTRpkiSpf//+6bouSdYvllevXq2RI0eqdevWql69uubMmaMJEyaoWLFiCg8P15w5c9S6dWvVqFFDX3zxhUJDQ1WxYkW1bt06zXMkSM/vtkmTJipdurTmzp2rCRMmKFeuXDbH+PTTT2WMUa9evdJ9Xknq0aOHPvroI33xxRcaNGiQtX3GjBnKly+f2rVrl+x+58+fV//+/fXQQw/p4YcfVt68eXX48GF9++23+umnn7Ru3Trdf//9Sfaz571/6tQptWjRQnv37tW8efPUqVMn67b0vgfq1aunkiVLavHixZo6dWqS99e8efN048YNPfPMM2m+Vvnz55ck7d+/X9WqVUu1b3r+rtL7Gqb3b3TatGnq3bu3/P391bp1awUEBGjbtm0aM2aMVq9erdWrVzNrCQAA4G5iAAAAcFcJDw83kkxISEiq/T777DMjyTzzzDNJ9u3atau1rUaNGsbDw8OcPn06yTHOnTtn/Xn16tVGkhk5cmSy50vYLsnMmDEjxbgTnzvxPtOnT7fpP336dCPJPPLIIzbtM2fONJLMzJkzU4whcYxpxZ1cXGvXrjWSTPny5c3Fixet7efPnzdly5Y1ksy6deuSvY758+fbHP+ZZ54xksy8efOSPX9i9p7XGGNKlChhSpQokeaxE3v44YeNJFOuXDlz5MgRa/vGjRuNJJMnTx5Tq1Ytm/fEkiVLjCTTp0+fdJ3D3t/t22+/bSSZWbNm2fSNjY01hQsXNgEBASYmJibN897691GpUiVTsWJF6/ZTp04ZNzc307dvX2OMMZ6enklev+vXr5u///47ybH//PNP4+PjY5o2bZritSb33r/1Pbhv3z5TsmRJkydPHrNixQqbvva+B4YNG2Ykma+++irJeWvWrGk8PDzMP//8k9xLZeObb76x/u4HDRpkli9fbvP3n9Y13cqe1zCtY+3evdu4ubmZqlWrJolp7NixRpKZMGFCmtcIAAAA58FSVAAAADlUkSJFJEnnzp1Ls6+7u7vc3d2TtCfcxW2PGjVqqHv37nbtU7Zs2SR34/fq1Uv33HOPfvjhB509e9buOO7E7NmzJd1cJidxUfG8efNq5MiRkpTsklT169e3ufNeknWZoN9++y3TzmuvHTt2yGKx6KuvvlKJEiWs7VWqVJF0swbFggULFBAQYN1WuXJlSVJUVJRd50rv77Z79+7y8PDQp59+atP3hx9+0KlTp9S1a9dk36Np6dGjh3bv3q0tW7ZIuvka37hxI8XlmyTJ09NTRYsWTdJesWJFNWrUSOvWrVNsbGyS7el57//222+qV6+erly5otWrV6tp06Y22+19DyTMxvjyyy9tjrNnzx5t375dDz/8sPLly5dqTJLUpk0bTZw4UcYYTZw4USEhISpQoIDKlCmjPn366MCBA2keI7HbfQ2T89FHH+nGjRv64IMPkvyfNGTIEBUsWFDz5s2zKz4AAABkbyQ2AAAAkKonnnhCV65cUaVKlfTyyy/rxx9/tPvL68SSW6InLXXr1pWLi+1HVxcXF9WtW1fGGO3cufO247kdCUs1JV4WJ0FCPYCwsLAk22rWrJmkrVixYpKkixcvZtp57XHmzBmdOnVKtWvXtiYyEvz999+SpJYtW6p48eI2244ePSpJNomQ9Ejv77ZgwYJ67LHHtGHDBu3du9faNyHR8eyzz9p13gRPP/203N3dNWPGDEk3a1dUr149zeWWwsLC1LlzZxUvXlweHh7Wug/fffedYmJikk0YpvXeX79+vRo3biwfHx/9+uuvyb5f7H0PlC1bVg888ICWLVtmE1NCoiM9y1AlGDhwoE6ePKkFCxaof//+qlevno4dO6YpU6aoSpUq+vbbb9N9rIQ47X0Nk7N582ZJ0vLlyzVq1Cibx+uvvy53d3eb9wwAAACcHzU2AAAAcqiTJ09KuvmFcWoGDx6s/Pnza9q0aZo4caImTJggNzc3tWrVSu+9956Cg4PtOm+hQoXsjjWlfRLaIyMj7T7mnYiKipKLi0uyr12hQoVksViSTf74+vomaXNzu/mRPC4uLtPOa4+EL8WbNGlyW9uqVq1q1/ns+d3+73//0/z58/Xpp59qwoQJOnnypH766Sc1aNBAZcuWteu8CQoWLKjWrVtr/vz56tChg/bt25ekUPetNm7cqMaNG0uSmjdvrnvuuUc+Pj6yWCxaunSpdu7cqejo6HRfa4IdO3bo8uXLat68eYp1Y27nPfDMM89o69at+uqrr9S7d28ZYzRnzhzlzZtXrVq1SjWmW+XJk0cdOnRQhw4dJN38/bz66quaOnWqevbsqRMnTqSrlsXtvobJOX/+vCRpzJgxdl0LAAAAnBczNgAAAHKoNWvWSEr7LnKLxaIePXrot99+09mzZ7VkyRI99thj+uabb/TII4+k6wv5W49nr9OnT6fannhJnoS7/2/cuJGkf0YlQHx9fRUfH5/sElhnzpyRMSbZJIYznDdhRkCNGjWSbPv9999T3JaQ2EhuW2rs+d02bNhQ5cqV0+eff66YmBjNnDlTcXFxdhcNv1XPnj0VFRWlbt26ycvLS0899VSq/ceMGaPo6GitXLlS3377rSZOnKjRo0dr1KhRCgwMTHG/tN77ffr0Uc+ePfX111+rc+fOyb6Hb+c98MQTT8jd3d06S2PdunU6evSoOnbsKE9Pz1RjSoufn58+/PBDlShRQufOndOuXbvStd/tvobJSbjeqKgoGWNSfAAAAODuQWIDAAAgB9q/f78WLFggT09PPfroo+neL3/+/GrXrp2++uorNW7cWH/99ZcOHjwoSXJ1dZWUvpkH9vr1118VHx9v0xYfH6+NGzfKYrHYzBLImzevJOnEiRNJjpPwpX1itxN39erVJf2XHEosoS2tpYxuR1acN7UExY4dO+Tq6prsrIwdO3bI39/f7hk89vxuJem5557T2bNntXTpUs2YMUN58+ZV+/bt7TrnrUJCQlS0aFGdOHFC7dq1s76HUnLo0CHly5dP9erVs2m/evWqNflzO1xcXPTJJ5+oV69eWrBggZ566qkkyY3beQ8UKFBALVq00ObNm3Xw4EFrguPpp5++7VgTs1gsyp07t01bWn9X9ryGaR2rVq1akv5bkgoAAAB3PxIbAAAAOcyvv/6qkJAQRUdHa+jQockW8E1szZo1Se52jo2NtS7/4uXlJUnWAsTHjx/P8Jj379+vTz75xKbtk08+0f79+9WqVSubZXlq1qwpi8Wi+fPn6/r169b2AwcOaPLkyUmOfTtxd+3aVZI0evRom2V/IiMjNXr0aJs+GSkrzhsWFqYCBQokqaEh3UxelCtXTt7e3jbt0dHR2rt3720lVez53Uo3r8/Ly0sDBgzQ4cOH9cwzz1jfg7fL1dVVS5cu1ZIlSzR27Ng0+5coUUIXLlzQ7t27rW1xcXEaPHjwHReyt1gs+uijj/S///1PCxYs0JNPPmmT3Ljd90BCLY1PP/1UCxcuVHBwsOrWrZvuuD766KMUC9wvXbpUe/bskb+/vypVqiQp7b8re17DtI714osvys3NTX379tWxY8eSbL948WKySU0AAAA4L2psAAAA3KUOHjyoUaNGSZJiYmJ05swZbd26Vbt27ZKrq6uGDRumkSNHpnmcdu3aydfXVw8++KBKlCih2NhYrVixQn/99Zcef/xxa7HocuXKqUiRIpo/f748PT1VrFgxWSwW9e3b12Y5odsREhKifv366ccff1TFihW1e/dufffddypQoECSZEWRIkX05JNPau7cuapZs6ZatGihM2fOaMmSJWrRooUWL15s0/924q5fv7769u2rDz74QJUqVVL79u1ljNHixYv1999/q1+/fqpfv/4dXbMjznv16lXt378/2Roax44d07lz59SyZcsk23bt2qUbN27YvQyVZN/vVrr5JXeHDh30xRdfSNIdL0OV4L777tN9992Xrr59+/bVzz//rHr16qljx47y8vLSmjVrdOLECTVs2DDZ2RT2sFgsmjZtmlxcXDRt2jQZYzR//ny5ubnd9nugdevW8vPz07vvvqvY2Fj169fPrmXhfvrpJz3//PMqU6aM6tatqyJFiujKlSvasWOH1q9fLxcXF02dOtW6tFVaf1f2vIZpHatSpUqaOnWqXnjhBd177716+OGHVbp0aV26dEmHDx/W2rVr1a1bN02fPv2Ofi8AAADIRgwAAADuKuHh4UaSzcPb29sULlzYNGrUyAwfPtwcPHgw1X27du1qbZs6dapp06aNKVGihPHy8jL58+c3DzzwgJk2bZqJiYmx2X/z5s2mQYMGJk+ePNZzh4eHG2OMWb16tZFkRo4cme5zJ95n/fr1pkGDBiZ37tzG19fXPProo+bAgQPJHuvq1aumX79+plChQsbT09NUqVLFzJkzJ8UYUos7ubgSzJgxw9x///0mV65cJleuXOb+++83M2bMSNIvtWtP7fgpSe95jTGmRIkSpkSJEuk67qZNm4wk88orryTZtnTpUiPJvPfee0m2ffLJJ0aS+eKLL9J9Dbf7uzXGmJUrVxpJ5sEHH0z3+RIkvN4hISHp6u/p6Zns67do0SJTo0YNkytXLlOgQAHTsWNHc+jQIdO1a1eb948xab/3U9oeHx9vevfubSSZxx57zObvzZ73QIJnn33W+v7et29fuq4/wd69e8348eNNs2bNTHBwsPHy8jJeXl6mdOnSpmvXrmbbtm1J9knt78oY+17DtI5ljDFbt241TzzxhClSpIhxd3c3BQoUMDVq1DBDhw41e/bsset6AQAAkL1ZjKGKGgAAAADnMWHCBL388sv67LPP1KNHD0eHAwAAACCLkdgAAAAA4DSuX7+ucuXKKSoqSn///bdy5crl6JAAAAAAZDFqbAAAAADI9jZs2KC1a9dq+fLlOnr0qMaOHUtSAwAAAMihSGwAAAAAyPZWrlyp0aNHq0CBAhowYIAGDx7s6JAAAAAAOAhLUQEAAAAAAAAAAKfh4ugAAAAAAAAAAAAA0ovEBgAAAAAAAAAAcBokNgAAAAAAAAAAgNMgsQEAAAAAAAAAAJwGiQ0AAAAAAAAAAOA0SGwAAAAAAAAAAACnQWIDAAAAAAAAAAA4DRIbAIAMcfnyZQUEBGjOnDmODgUONnToUNWqVcvRYQAAAMCJLViwQPny5dPly5cdHQocKDY2VkFBQZo6daqjQwGQzZDYAHBXmDVrliwWS4qPzZs3OzpEq1tjy507typUqKA333xTV69edXR4t23y5MnKkyePnnjiCUeHkq3Fx8dr/PjxCg4OlpeXl6pUqaJ58+ala9+GDRum+B53d3e36Xv9+nWNHTtWFSpUUK5cuVS0aFF16NBBu3fvTnLcFStWqF69esqVK5fy5s2rxx9/XEeOHEk1lkOHDsnLy0sWi0Xbtm2z2da/f3/t3LlT3377bbquCwAA4HaMGjVKFotF586dS3Z7pUqV1LBhw6wNKoslNw4KCAhQo0aN9NNPPzk6vNsWFxenkSNHqm/fvvLx8XF0ONnaiRMn1LFjR/n7+8vX11dt27bV4cOH073/xo0brWOBwMBA9evXL81k0pgxY2SxWFSpUqVU+128eFEBAQGyWCxatGhRku3R0dF65ZVXVKRIEXl7e6tWrVpasWKFTR93d3cNHDhQY8aM0fXr19N9XQDufm6ODgAAMtLrr7+u4ODgJO1lypRxQDQpa9asmbp06SLp5kyH9evXa/jw4dq5c6cWLlzo4OjsFxsbq8mTJ2vAgAFydXV1dDjZ2muvvaZx48apV69euv/++/XNN9+oc+fOslgsaSaFXnvtNT377LM2bVeuXNHzzz+v5s2b27Q/9dRT+vbbb9WrVy/VqFFDJ0+e1JQpU1S7dm3t2rVLJUqUkCR9//33atu2rWrUqKFx48YpKipKkydPVr169bRjxw4VLFgw2VgGDBggNzc3RUdHJ9kWGBiotm3basKECWrTpo09Lw8AAABuQ8I4yBij06dPa9asWXr44Yf13Xff6ZFHHnF0eHb77rvvtG/fPj333HOODiVbu3z5sho1aqTIyEi9+uqrcnd313vvvacGDRooLCxM+fPnT3X/sLAwNWnSROXLl9e7776rv//+WxMmTNCBAwdSTIz9/fffeuutt5Q7d+404xsxYkSqN+9169ZNixYtUv/+/XXPPfdY37erV69WvXr1rP26d++uoUOHau7cuerRo0ea5wWQQxgAuAvMnDnTSDK//fabo0NJkyTTu3fvJO2PP/64cXFxMdeuXXNAVHfm66+/NpLMwYMHHR1Ktvb3338bd3d3m99/fHy8eeihh0yxYsXMjRs37D7mF198YSSZOXPm2JxHkhk8eLBN319++cVIMu+++661rUKFCqZMmTImOjra2hYWFmZcXFzMwIEDkz3nsmXLjIeHhxk2bFiKf3eLFi0yFovFHDp0yO5rAgAASI+RI0caSebs2bPJbq9YsaJp0KBB1gaVxVIaB50/f964u7ubzp07OyiyO9OmTRtTr149R4eR7b399ttGktm6dau1bc+ePcbV1dWEhoamuX/Lli1N4cKFTWRkpLXtk08+MZLM8uXLk92nU6dOpnHjxqZBgwamYsWKKR57165dxs3Nzbz++utGklm4cKHN9i1bthhJ5p133rG2Xbt2zZQuXdrUrl07yfEeeeQR89BDD6V5TQByDpaiApCjHDlyRBaLRRMmTNCUKVNUqlQp5cqVS82bN9fx48dljNEbb7yhYsWKydvbW23bttX58+dtjlGyZEk98sgj+vnnn1WtWjV5eXmpQoUK+vrrr+8otsDAQFksFrm52U6mW7hwoWrWrClvb28VKFBATz/9tE6cOJFk/19++UUPPfSQcufOLX9/f7Vt21Z79uyx6ZMwXX///v16+umn5efnp4IFC2r48OEyxuj48eNq27atfH19FRgYqIkTJ6Yr9qVLl6pkyZIqXbq0TXu3bt3k4+OjY8eO6ZFHHpGPj4+KFi2qKVOmSJJ27dqlxo0bK3fu3CpRooTmzp1rs//58+c1ePBgVa5cWT4+PvL19VXLli21c+fOJDF88MEHqlixonU5pfvuu8/meJcuXVL//v1VsmRJeXp6KiAgQM2aNdPvv/+ermvMCN98841iY2P14osvWtssFoteeOEF/f3339q0aZPdx5w7d65y586ttm3bWtsuXbokSSpUqJBN38KFC0uSvL29Jd18ff/66y89+uij8vDwsParWrWqypcvr/nz5yc5X2xsrF566SW99NJLSX7fiTVt2lTSzWsGAADIDtasWSOLxaIFCxZozJgxKlasmLy8vNSkSRMdPHgwSf8tW7aoRYsW8vPzU65cudSgQQP9+uuvNn3u9PN1QkxfffWVXn31VQUGBip37txq06aNjh8/ftvX6u/vL29v7yRjiytXrmjQoEEKCgqSp6en7r33Xk2YMEHGGJt+N27c0BtvvKHSpUvL09NTJUuW1Kuvvppktm7C2GjNmjW677775O3trcqVK2vNmjWSpK+//lqVK1eWl5eXatasqR07dqQZ+/Xr17Vs2TLr58nELBaL+vTpo4ULF6pChQry9va2zkiWpI8++khlypSRl5eXGjZsmGR51fXr16tDhw4qXry4PD09FRQUpAEDBujatWs2/SIiItS9e3cVK1ZMnp6eKly4sNq2bWtzvG3btikkJEQFChSQt7e3goODs3w2waJFi3T//ffr/vvvt7aVK1dOTZo00YIFC1LdNyoqSitWrNDTTz8tX19fa3uXLl3k4+OT7P7r1q3TokWLNGnSpDRje+mll/Too4/qoYceSjF2V1dXm1k5Xl5e6tmzpzZt2pTk/d+sWTNt2LAhyfgcQM5FYgPAXSUyMlLnzp2zefzzzz9J+s2ZM0dTp05V3759NWjQIK1du1YdO3bUsGHDtGzZMr3yyit67rnn9N1332nw4MFJ9j9w4IA6deqkli1bauzYsXJzc1OHDh2SrAeakuvXr1vjO3r0qObOnavZs2erc+fONoOPWbNmqWPHjnJ1ddXYsWPVq1cvff3116pXr54uXrxo7bdy5UqFhITozJkzGjVqlAYOHKiNGzeqbt26ydZK6NSpk+Lj4zVu3DjVqlVLb775piZNmqRmzZqpaNGievvtt1WmTBkNHjxY69atS/N6Nm7cqBo1aiS7LS4uTi1btlRQUJDGjx+vkiVLqk+fPpo1a5ZatGih++67T2+//bby5MmjLl26KDw83Lrv4cOHtXTpUj3yyCN699139fLLL2vXrl1q0KCBTp48ae33ySefqF+/fqpQoYImTZqk0aNHq1q1atqyZYu1z/PPP69p06apffv2mjp1qgYPHixvb+8kyZ9bxcbGJnlPpfSIj49P9Vg7duxQ7ty5Vb58eZv2Bx54wLrdHmfPntWKFSvUrl07m6ngpUuXVrFixTRx4kR99913+vvvv7V161Y9//zzCg4Oti55lTAwTUh0JJYrVy6dPHlSERERNu2TJk3ShQsXNGzYsFRj8/PzU+nSpZMM/gEAABxt3LhxWrJkiQYPHqzQ0FBt3rxZTz31lE2fX375RfXr11dUVJRGjhypt956SxcvXlTjxo21devWJMe808/XY8aM0Q8//KBXXnlF/fr104oVK9S0adMkX7inJGEcdPbsWe3evVsvvPCCLl++rKefftraxxijNm3a6L333lOLFi307rvv6t5779XLL7+sgQMH2hzv2Wef1YgRI1SjRg3r0kZjx45NdunUgwcPqnPnzmrdurXGjh2rCxcuqHXr1pozZ44GDBigp59+WqNHj9ahQ4fUsWPHND8zb9++XTExMSmOL9avX69Bgwapa9euGjVqlPbs2aNHHnlEU6ZM0fvvv68XX3xRL7/8sjZt2pQk0bBw4UJdvXpVL7zwgj744AOFhITogw8+sC4TnKB9+/ZasmSJunfvrqlTp6pfv366dOmSjh07Jkk6c+aMmjdvriNHjmjo0KH64IMP9NRTT6WrtuPly5fTNbaIjIxM9Tjx8fH6448/dN999yXZ9sADD+jQoUPWG56Ss2vXLt24cSPJ/h4eHqpWrVqSsUlcXJz69u2rZ599VpUrV041toULF2rjxo0aP358in127NihsmXL2iRVEmKXbi6TlVjNmjVljNHGjRtTPTeAHMSR00UAIKMkTMFO7uHp6WntFx4ebiSZggULmosXL1rbQ0NDjSRTtWpVExsba21/8sknjYeHh7l+/bq1rUSJEkaSWbx4sbUtMjLSFC5c2FSvXj3NWFOKs127djbniYmJMQEBAaZSpUo2y1N9//33RpIZMWKEta1atWomICDA/PPPP9a2nTt3GhcXF9OlSxdrW8J0/eeee87aduPGDVOsWDFjsVjMuHHjrO0XLlww3t7epmvXrqleT2xsrLFYLGbQoEFJtnXt2tVIMm+99VaS41osFjN//nxr+969e40kM3LkSGvb9evXTVxcnM0xw8PDjaenp3n99detbW3btk11GrQxxvj5+SW7BFhaVq9eneLv7NZHeHh4qsdq1aqVKVWqVJL2K1euGElm6NChdsX2wQcfGEnmxx9/TLJty5YtpnTp0jbx1axZ05w6dcraJy4uzvj7+5smTZrY7Hvu3DmTO3duI8ls27bN2n7q1CmTJ08e89FHHxlj0l4Crnnz5qZ8+fJ2XRMAAEB62bsUVcLnuvLly9sswzl58mQjyezatcsYc3Op0HvuuceEhISY+Ph4a7+rV6+a4OBg06xZsyQx3O7n64SYihYtaqKioqztCxYsMJLM5MmTU30NUhoHeXp6mlmzZtn0Xbp0qZFk3nzzTZv2xx9/3FgsFuuysmFhYUaSefbZZ236DR482Egyv/zyi7UtYWy0ceNGa9vy5cuNJOPt7W2OHj1qbf/oo4+MJLN69epUr+nTTz+1+X0klnBtiT93Jxw3MDDQ5jVMGOMl7nv16tUkxxw7dqyxWCzWWC9cuJBkiaRbLVmy5LaXQk4YI6X1SGsZtbNnzxpJNuOiBFOmTDGSzN69e1Pcf+HChUaSWbduXZJtHTp0MIGBgTZtH374ofHz8zNnzpwxxpgUl6K6evWqKV68uHUprIT3+K1LUVWsWNE0btw4yf67d+82ksz06dNt2k+ePGkkmbfffjvFawKQs1A8HMBdZcqUKSpbtqxNW3LFrDt06CA/Pz/r81q1akmSnn76aZsZE7Vq1dK8efN04sQJlSpVytpepEgRPfroo9bnvr6+6tKli95++21FREQoMDAw1Tjbtm2rPn36SJKuXr2qzZs367333lPnzp21aNEiWSwWbdu2zToDw8vLy7pvq1atVK5cOf3www8aPXq0Tp06pbCwMA0ZMkT58uWz9qtSpYqaNWumH3/8Mcn5ExegdnV11X333ae///5bPXv2tLb7+/vr3nvv1eHDh1O9lvPnz8sYo7x586bYJ/H5Eo578OBBdezY0dp+7733yt/f3+Z8np6e1p/j4uJ08eJF+fj46N5777VZQsrf319///23fvvtN5tp2In5+/try5YtOnnypIoUKZLqNSVWtWrVdM/ESev3fu3aNZtrSpDw+03vHXkJ5s6dq4IFC6pZs2ZJtuXNm1fVqlVThw4d9OCDD+rgwYMaO3asdWaRl5eXXFxc9L///U9vv/22QkND1aNHD0VFRWnIkCGKiYlJEtMrr7yiUqVKJSlgnpK8efPaPQsFAAAgs3Xv3t1mGc6EpXIOHz6sSpUqKSwsTAcOHNCwYcOSzP5u0qSJvvjiC8XHx8vF5b9FMO7083WXLl2UJ08e6/PHH39chQsX1o8//qh+/fqleU2Jx0GnT5/Wl19+qWeffVZ58uTRY489Jkn68ccf5erqmuR4gwYN0qJFi/TTTz+pT58+1vHDrbM4Bg0apAkTJuiHH35Qo0aNrO0VKlRQ7dq1rc8TxlaNGzdW8eLFk7QfPnxYDRs2TPFaEl7zlMYXTZo0UcmSJZMct3379javYeLzJfRPPFP5ypUrunbtmurUqSNjjHbs2KHixYvL29tbHh4eWrNmjXr27JlsHP7+/pKk77//XlWrVpW7u3uK13OrIUOG2MykSUlq4yvpv8/ptzu+SGv/xPv+888/GjFihIYPH66CBQumGte4ceMUGxurV199Nc347Yk94fU4d+5cqscFkHOQ2ABwV3nggQeSnYp7q8QfsCVZkxxBQUHJtl+4cMGmvUyZMrJYLDZtCQOJI0eOqGDBgjp79qzN9nz58lkHUMWKFbNZM7ZNmzbKnz+/Bg8erO+//16tW7fW0aNHJd38wv9W5cqV04YNGyQp1X7ly5fX8uXLdeXKFZulipK7fi8vLxUoUCBJe3JLeSXH3LIubwIvL68kH379/PxUrFixJK+hn5+fzWsdHx+vyZMna+rUqQoPD1dcXJx1W/78+a0/v/LKK1q5cqUeeOABlSlTRs2bN1fnzp1Vt25da5/x48era9euCgoKUs2aNfXwww+rS5cuNgmr5OTNmzfZ9X1vh7e3d5J1iaWbS5MlbE+vw4cPa9OmTerTp0+StZMjIyP10EMP6eWXX9agQYOs7ffdd58aNmyomTNn6oUXXpAkvf766zp37pzGjx+vcePGSZKaN2+unj17avr06fLx8ZEkbd68WV988YVWrVplM4hPjTEmye8YAAAgKyX3WeTWz8IJX5gmfA49cOCAJKlr164pHjcyMtLmi+c7/Xx9zz33JIm7TJky1mVlL1++rMuXL1u3u7q62nzGvnUc9OSTT6p69erq06ePHnnkEXl4eOjo0aMqUqSIzZf/kqzLpCaMK44ePSoXFxeVKVPGpl9gYKD8/f2t/VK7din9Y6uUpDS+uJPzHTt2TCNGjNC3336bJI6EpZ88PT319ttva9CgQSpUqJAefPBBPfLII+rSpYv1RqYGDRqoffv2Gj16tN577z01bNhQ7dq1U+fOnZP9sj6xChUqqEKFCmldfpoSxg63O75Ia//E+w4bNkz58uVT3759U43pyJEjeueddzRlyhTrOCK189sTe8L7gfEFgATU2ACQIyU3iyO19pQ+VKfk+PHjKly4sM0jrbVAmzRpIknpqmlxp5K7ztu99nz58slisaQ4QLmT1/qtt97SwIEDVb9+fX355Zdavny5VqxYoYoVK9qszVu+fHnt27dP8+fPV7169bR48WLVq1dPI0eOtPbp2LGjDh8+rA8++EBFihTRO++8o4oVK+qnn35K9fpiYmIUERGRrkfixEtyChcurIiIiCSv6alTpyTJrpkkCYXRb10PWpIWL16s06dPq02bNjbtDRo0kK+vr03dCw8PD3366ac6efKk1q1bp3379mn58uWKjIy0GdAOGTJEDz30kIKDg3XkyBEdOXLEerfUqVOnrOsNJ3bhwoUkg3kAAICMktZd6VevXrWZ+Zwgrc+hCZ8z33nnHa1YsSLZx61f2mbk5+vkTJgwwWZskdIs5QQuLi5q1KiRTp06ZU3U2Cu9XyBn9Ngq4QamjB5fxMXFqVmzZtZaJkuXLtWKFSs0a9YsSbIZX/Tv31/79+/X2LFj5eXlpeHDh6t8+fLW2cgWi0WLFi2y3mh04sQJ9ejRQzVr1rRJQCUnMjIyXWOLtIpk58uXT56entaxRGLpGV8ULlzYpu+t+yfse+DAAX388cfq16+fTp48aR0LXL9+XbGxsTpy5Ig11hEjRqho0aLWwu1Hjhyx1uw7e/asjhw5Yn2dCxcubFfsCe8HxhcAEjBjAwBuw8GDB5Pcjb5//35JUsmSJeXv759k+aKqVaumeswbN25IkvWDcIkSJSRJ+/btU+PGjW367tu3z7o9cb9b7d27VwUKFLCZrZHR3NzcVLp0aZui3xll0aJFatSokT777DOb9osXLyb5QJs7d2516tRJnTp1UkxMjB577DGNGTNGoaGh1gFt4cKF9eKLL+rFF1/UmTNnVKNGDY0ZM0YtW7ZMMYaNGzfaTLVPTXh4uM20+FtVq1ZNn376qfbs2WNzl1ZCkfNq1aql6zzSzcRG6dKl9eCDDybZdvr0aUlKkmgxxiguLs76XkusUKFCKlSokHW/NWvWqFatWtZB+7Fjx3T06FEFBwcn2bdNmzby8/OzKWgv3Xw90nrfAwAA3K7En4NvvVv/6tWrOn78uJo3b273cUuXLi3p5nKzGTVzNy23Jh+MMTp48KCqVKki6eZSVfXq1bNuT89M3+TGFytXrtSlS5dsZm3s3bvXuj3h3/j4eB04cMA6m0O6+Rnz4sWL1n6ZpVy5cpJufpZMq0i1PXbt2qX9+/dr9uzZNsXCU1p2tnTp0ho0aJAGDRqkAwcOqFq1apo4caK+/PJLa58HH3xQDz74oMaMGaO5c+fqqaee0vz581NduvWll17S7Nmz04y3QYMGWrNmTYrbXVxcVLlyZW3bti3Jti1btqhUqVJJZuckVqlSJbm5uWnbtm02SwTHxMQoLCzM2nbixAnFx8erX79+yS6LFhwcrJdeekmTJk3SsWPHdPDgwWRnxb/44ouSbiYo/P39Va1aNa1evVpRUVE2BcRTGhsljDcTvycB5GwkNgDgNpw8eVJLliyxrlcbFRWlzz//XNWqVbNOT7Z3EPTdd99J+i8Bct999ykgIEDTp09Xjx49rFOaf/rpJ+3Zs0cjRoyQdPPL+mrVqmn27NkKDQ21rvf6559/6ueff07X+q13qnbt2ql+6L5drq6uSe7oWrhwoU6cOGEzNf6ff/6xWZrKw8NDFSpU0E8//aTY2Fi5u7vr8uXLNnVVAgICVKRIkWSnPyeWkTU22rZtqwEDBmjq1Kn68MMPJd0ctE6fPl1FixZVnTp1rH1PnTqlyMhIlS5dOsmavTt27NCePXs0fPjwZM+TsCza/PnzNWrUKGv7t99+qytXrqh69eqpxjlhwgSdOnVKH3zwgbXt448/1tWrV236/fLLL/rggw80YcIE6wA0QWRkpA4dOmRd8goAACCjNWnSRB4eHpo2bZoaN25ss1zmxx9/rBs3bqR6A0tKatasqdKlS2vChAnq3LlzktkZZ8+eTbPOgL0+//xzhYaGWr+IXrRokU6dOqVXXnlFklSqVKk0l1BNLDY2Vj///LM8PDysXwQ//PDD+vjjj/Xhhx8qNDTU2ve9996TxWKxvlYPP/ywXn31VU2aNEkfffSRtd+7774r6WbNv8xUs2ZNeXh4aNu2bUlmIN+JhBkdiccXxhhNnjzZpt/Vq1fl4uJiM9undOnSypMnj3XskPDlfOIb3RK+iE9rfJFRNTakm7VYhg4dqm3btlmXItu3b59++eUXDR482Kbv3r17lStXLutSXn5+fmratKm+/PJLDR8+3Pre++KLL3T58mV16NBB0s0EyJIlS5Kce9iwYbp06ZImT55sTQa++eabSWpg/Pnnnxo+fLiGDBmi2rVrW2+6e/zxxzVhwgR9/PHH1lijo6M1c+ZM1apVK0mycvv27bJYLDb1XADkbCQ2ANxVfvrpJ+sdR4nVqVPHroFAWsqWLauePXvqt99+U6FChTRjxgydPn1aM2fOTNf++/fvt97pk1A8fPbs2SpTpoyeeeYZSZK7u7vefvttde/eXQ0aNNCTTz6p06dPa/LkySpZsqQGDBhgPd4777yjli1bqnbt2urZs6euXbumDz74QH5+fjZfbGeWtm3b6osvvtD+/fuTFG+/E4888ohef/11de/eXXXq1NGuXbs0Z86cJL/L5s2bKzAwUHXr1lWhQoW0Z88effjhh2rVqpXy5MmjixcvqlixYnr88cdVtWpV+fj4aOXKlfrtt980ceLEVGPIyBobxYoVU//+/fXOO+8oNjZW999/v5YuXar169drzpw5NtPnQ0NDNXv27GRngcyZM0dS8stQSVLr1q1VsWJFvf766zp69Ki1ePiHH36owoUL2xSx/PLLL7V48WLVr1/f+rosWLBAzz77rNq3b2/tl9zdjgkzNBo0aJCkts3KlStljFHbtm3teo0AAADSKyAgQCNGjNCwYcNUv359tWnTRrly5dLGjRs1b948NW/eXK1bt7b7uC4uLvr000/VsmVLVaxYUd27d1fRokV14sQJrV69Wr6+vtabkjJKvnz5VK9ePXXv3l2nT5/WpEmTVKZMGfXq1Std+yceB505c0Zz587VgQMHNHToUOvd8K1bt1ajRo302muv6ciRI6patap+/vlnffPNN+rfv7/1y+mqVauqa9eu+vjjj3Xx4kU1aNBAW7du1ezZs9WuXbt0z2a+XV5eXmrevLlWrlyp119/PcOOW65cOZUuXVqDBw/WiRMn5Ovrq8WLFydZ8mr//v1q0qSJOnbsqAoVKsjNzU1LlizR6dOn9cQTT0iSZs+eralTp+rRRx9V6dKldenSJX3yySfy9fXVww8/nGocGVVjQ7o5C+KTTz5Rq1atNHjwYLm7u+vdd99VoUKFbGrtSTdnOtw6C2TMmDGqU6eOGjRooOeee05///23Jk6cqObNm6tFixaSbi791K5duyTnnjRpkiTZbEs8qyhBwo13999/v03fWrVqqUOHDgoNDdWZM2dUpkwZzZ49W0eOHEkyY1+6ObOmbt26Nje0AcjhDADcBWbOnGkkpfiYOXOmMcaY8PBwI8m88847NvuvXr3aSDILFy5M9ri//fabta1EiRKmVatWZvny5aZKlSrG09PTlCtXLsm+Kbk1NldXV1OsWDHz3HPPmdOnTyfp/9VXX5nq1asbT09Pky9fPvPUU0+Zv//+O0m/lStXmrp16xpvb2/j6+trWrdubf766y+bPiNHjjSSzNmzZ23au3btanLnzp3kmA0aNDAVK1ZM85qio6NNgQIFzBtvvHFHx014bRNcv37dDBo0yBQuXNh4e3ubunXrmk2bNpkGDRqYBg0aWPt99NFHpn79+iZ//vzG09PTlC5d2rz88ssmMjLSGt/LL79sqlatavLkyWNy585tqlataqZOnZrmtWW0uLg489Zbb5kSJUoYDw8PU7FiRfPll18m6de1a1cjyYSHhyfZv2jRoqZGjRqpnuf8+fNmwIABpmzZssbT09MUKFDAPPHEE+bw4cM2/bZs2WLq169v8ubNa7y8vEzVqlXN9OnTTXx8fJrXktzfR4JOnTqZevXqpXkMAACAO/Xll1+aBx980OTOndv62Xz06NHm+vXrNv1S+syfMEZIGDMk2LFjh3nsscesnzFLlChhOnbsaFatWmXtc6efrxNimjdvngkNDTUBAQHG29vbtGrVyhw9ejTNa09uHOTl5WWqVatmpk2bluQz3aVLl8yAAQNMkSJFjLu7u7nnnnvMO++8k6RfbGysGT16tAkODjbu7u4mKCjIhIaGJnlNb/38nkCS6d27t01bSmOx5Hz99dfGYrGYY8eO3fZxk/t9//XXX6Zp06bGx8fHFChQwPTq1cvs3LnT5vd/7tw507t3b1OuXDmTO3du4+fnZ2rVqmUWLFhgPc7vv/9unnzySVO8eHHj6elpAgICzCOPPGK2bduW5rVltOPHj5vHH3/c+Pr6Gh8fH/PII4+YAwcOJOknyWYMlWD9+vWmTp06xsvLyxQsWND07t3bREVFpXne9I4VU/q7M8aYa9eumcGDB5vAwEDj6elp7r//frNs2bIk/S5evGg8PDzMp59+mub5AOQcFmNuo2oVAORgJUuWVKVKlfT99987OpRs5Y033tDMmTN14MCBFAv3IWeIiIhQcHCw5s+fz4wNAACAVKxZs0aNGjXSwoUL9fjjjzs6nGwjLi5OFSpUUMeOHfXGG284Ohw42KRJkzR+/HgdOnQoXfVlAOQMLml3AQAgbQMGDNDly5c1f/58R4cCB5s0aZIqV65MUgMAAAC3xdXVVa+//rqmTJliLX6OnCk2Nlbvvvuuhg0bRlIDgA1qbAAAMoSPj4/OnDnj6DCQDYwbN87RIQAAAMDJderUSZ06dXJ0GHAwd3d3HTt2zNFhAMiGmLEBAAAAAAAAAACcBjU2AAAAAAAAAACA02DGBgAAAAAAAAAAcBo5rsZGfHy8Tp48qTx58shisTg6HAAAAMBpGGN06dIlFSlSRC4ud+89UowZAAAAgNuTVWOGHJfYOHnypIKCghwdBgAAAOC0jh8/rmLFijk6jEzDmAEAAAC4M5k9ZshxiY08efJIuvnC+vr6OjgaAAAAwHlERUUpKCjI+pn6bsWYAQAAALg9WTVmyHGJjYSp5L6+vgxSAAAAgNtwty/PxJgBAAAAuDOZPWa4exfGBQAAAAAAAAAAdx0SGwAAAAAAAAAAwGmQ2AAAAAAAAAAAAE4jx9XYAAAASE1cXJxiY2MdHQbgEO7u7nJ1dXV0GAAAANkaYwbkZNllzEBiAwAAQJIxRhEREbp48aKjQwEcyt/fX4GBgXd9gXAAAAB7MWYAbsoOYwYSGwAAAJJ1gBIQEKBcuXLxpS5yHGOMrl69qjNnzkiSChcu7OCIAAAAshfGDMjpstOYgcQGAADI8eLi4qwDlPz58zs6HMBhvL29JUlnzpxRQEBAtphiDgAAkB0wZgBuyi5jBoqHAwCAHC9hfdxcuXI5OBLA8RL+Dlg3GgAA4D+MGYD/ZIcxA4kNAACAfzGVHODvAAAAIDV8VgKyx98BiQ0AAAAAAAAAAOA0SGwAAAAAAAAAAACnQWIDAAAAadq3b58CAwN16dIlR4eS7T344INavHixo8MAAAAAsgzjhfRjvJAxSGwAAAA4KYvFkupj1KhROnLkiCwWi1xdXXXixAmb/U+dOiU3NzdZLBYdOXIk1XOFhoaqb9++ypMnj6SbA5dGjRqpUKFC8vLyUqlSpTRs2LAkxeMWLlyocuXKycvLS5UrV9aPP/5os90YoxEjRqhw4cLy9vZW06ZNdeDAgTt/cTLIqFGjVK1aNbv2GTZsmIYOHar4+PjMCQoAAABIB8YLmY/xguOQ2AAAAHBSp06dsj4mTZokX19fm7bBgwdb+xYtWlSff/65zf6zZ89W0aJF0zzPsWPH9P3336tbt27WNnd3d3Xp0kU///yz9u3bp0mTJumTTz7RyJEjrX02btyoJ598Uj179tSOHTvUrl07tWvXTn/++ae1z/jx4/X+++9r+vTp2rJli3Lnzq2QkBBdv379Dl4Zx2rZsqUuXbqkn376ydGh3JWmTZumKlWqyNfXV76+vqpdu7bNa339+nX17t1b+fPnl4+Pj9q3b6/Tp087MGIAAADHYLyQPTFeyBgkNgAAAJxUYGCg9eHn5yeLxWLT5uPjY+3btWtXzZw502b/mTNnqmvXrmmeZ8GCBapatarNoKZUqVLq3r27qlatqhIlSqhNmzZ66qmntH79emufyZMnq0WLFnr55ZdVvnx5vfHGG6pRo4Y+/PBDSTfvvpo0aZKGDRumtm3bqkqVKvr888918uRJLV26NMV4GjZsqL59+6p///7KmzevChUqpE8++URXrlxR9+7dlSdPHpUpUybNgcKsWbPk7++vpUuX6p577pGXl5dCQkJ0/Phx6/bRo0dr586d1rvaZs2aJWOMRo0apeLFi8vT01NFihRRv379rMd1dXXVww8/rPnz56f52sJ+xYoV07hx47R9+3Zt27ZNjRs3Vtu2bbV7925J0oABA/Tdd99p4cKFWrt2rU6ePKnHHnvMwVEDAABkPcYLjBfuZm6ODgAAACDb+qiBdPlM1p/XJ0D639oMPWSbNm00ffp0bdiwQfXq1dOGDRt04cIFtW7dWm+88Uaq+65fv1733Xdfqn0OHjyoZcuW2XyBvGnTJg0cONCmX0hIiHUQEh4eroiICDVt2tS63c/PT7Vq1dKmTZv0xBNPpHi+2bNna8iQIdq6dau++uorvfDCC1qyZIkeffRRvfrqq3rvvff0zDPP6NixY8qVK1eKx7l69arGjBmjzz//XB4eHnrxxRf1xBNP6Ndff1WnTp30559/atmyZVq5cqU1vsWLF+u9997T/PnzVbFiRUVERGjnzp02x33ggQc0bty4VF8z3J7WrVvbPB8zZoymTZumzZs3q1ixYvrss880d+5cNW7cWNLNAXn58uW1efNmPfjgg8keMzo6WtHR0dbnUVFRmXcBAADg7uKIMQPjBcYLILEBAACQostnpEsnHR1FhnB3d9fTTz+tGTNmqF69epoxY4aefvppubu7p7nv0aNHUxyo1KlTR7///ruio6P13HPP6fXXX7dui4iIUKFChWz6FypUSBEREdbtCW0p9UlJ1apVNWzYMEk31/MdN26cChQooF69ekmSRowYoWnTpumPP/5I8ctsSYqNjdWHH36oWrVqSbo5ACpfvry2bt2qBx54QD4+PnJzc1NgYKB1n2PHjikwMFBNmzaVu7u7ihcvrgceeMDmuEWKFNHx48cVHx8vFxcmSWeWuLg4LVy4UFeuXFHt2rW1fft2xcbG2gx+y5Urp+LFi2vTpk0pvhfGjh2r0aNHZ1XYAADgbnKXjBkYLySP8UL2xasGAACQEp8AKU+RrH/4BGTK5fTo0UMLFy5URESEFi5cqB49eqRrv2vXrsnLyyvZbV999ZV+//13zZ07Vz/88IMmTJiQkSGnqEqVKtafXV1dlT9/flWuXNnaljD4OXPm5t1zFStWlI+Pj3x8fNSyZUtrPzc3N91///3W5+XKlZO/v7/27NmT4rk7dOiga9euqVSpUurVq5eWLFmiGzdu2PTx9vZWfHy8zSwAZJxdu3bJx8dHnp6eev7557VkyRJVqFBBERER8vDwkL+/v03/tAa/oaGhioyMtD4SlhcAAABIkyPGDIwX0sR44e7n0Bkb69at0zvvvKPt27fr1KlTWrJkidq1a5eufX/99Vc1aNBAlSpVUlhYWKbGCQAAcqgMnt7taJUrV1a5cuX05JNPqnz58un+HFWgQAFduHAh2W1BQUGSpAoVKiguLk7PPfecBg0aJFdXVwUGBiYp2nz69Gnr3UwJ/54+fVqFCxe26VOtWrVUY7r1zjGLxWLTZrFYJEnx8fGSpB9//FGxsbGSbg4i7kRQUJD27dunlStXasWKFXrxxRf1zjvvaO3atdYYzp8/r9y5c9/xuZC8e++9V2FhYYqMjNSiRYvUtWtXrV17+3+vnp6e8vT0zMAIAQBAjnEXjRkYLzBecCYOnbFx5coVVa1aVVOmTLFrv4sXL6pLly5q0qRJJkUGAABwd+rRo4fWrFmT7ruvJKl69er666+/0uwXHx+v2NhY6+Cgdu3aWrVqlU2fFStWqHbt2pKk4OBgBQYG2vSJiorSli1brH0ySokSJVSmTBmVKVPGpqjhjRs3tG3bNuvzffv26eLFiypfvrwkycPDQ3FxcUmO5+3trdatW+v999/XmjVrtGnTJu3atcu6/c8//1T16tUz9BrwHw8PD5UpU0Y1a9bU2LFjVbVqVU2ePFmBgYGKiYnRxYsXbfonHiDb5fzhjAkYAADASTBeYLzgLBw6Y6Nly5Y2U3vS6/nnn1fnzp3l6upqLSaTEgoBAgAA/KdXr17q0KFDkqV6UhMSEqJnn31WcXFxcnV1lSTNmTNH7u7uqly5sjw9PbVt2zaFhoaqU6dO1ruQXnrpJTVo0EATJ05Uq1atNH/+fG3btk0ff/yxpJt3SfXv319vvvmm7rnnHgUHB2v48OEqUqRIumfx3il3d3f17dtX77//vtzc3NSnTx89+OCD1jVwS5YsqfDwcIWFhalYsWLKkyeP5s2bp7i4ONWqVUu5cuXSl19+KW9vb5UoUcJ63PXr16t58+ZZcg2QdRp/zZo15e7urlWrVql9+/aSbg4+jx07dnuD38tnMzhSAACA7I3xgi3GC9mX0xUPnzlzpg4fPqwvv/xSb775Zpr9KQQIpG7ulmPqXKu4o8MAAGQRNzc3FShQwK59WrZsKTc3N61cuVIhISHW47z99tvav3+/jDEqUaKE+vTpowEDBlj3q1OnjubOnathw4bp1Vdf1T333KOlS5eqUqVK1j5DhgzRlStX9Nxzz+nixYuqV6+eli1bluIavRktV65ceuWVV9S5c2edOHFCDz30kD777DPr9vbt2+vrr79Wo0aNdPHiRc2cOVP+/v4aN26cBg4cqLi4OFWuXFnfffed8ufPL0k6ceKENm7cqC+//DJLriGnCQ0NVcuWLVW8eHFdunRJc+fO1Zo1a7R8+XL5+fmpZ8+eGjhwoPLlyydfX1/17dtXtWvXTrUoJAAAAG5ivGCL8UL2ZTHGGEcHId3MwKVVY+PAgQOqV6+e1q9fr7Jly2rUqFFaunRpqmu9JTdjIygoSJGRkfL19c3AKwCcE4kNAJCuX7+u8PBwBQcHZ9kHZGczZcoUffvtt1q+fLmjQ8kws2bNUv/+/ZMsW3SnXnnlFV24cMF6p5mzSe3vISoqSn5+fg79LN2zZ0+tWrVKp06dkp+fn6pUqaJXXnlFzZo1k3Qz/kGDBmnevHmKjo5WSEiIpk6datdSVNbr3PWzfCs1y6xLAQAAToQxQ+oYL6Sfs48XpOwxZnCaGRtxcXHq3LmzRo8erbJly6Z7PwoBAgAA3Ln//e9/unjxoi5duqQ8efI4OpxsLSAgQAMHDnR0GHetxHfIJcfLy0tTpkyxu44fAAAAbh/jhfRjvJAxnCaxcenSJW3btk07duxQnz59JN1cS9cYIzc3N/38889q3Lixg6MEAAC4O7m5uem1115zdBhOYdCgQY4OAQAAAMhSjBfSj/FCxnBxdADp5evrq127diksLMz6eP7553XvvfcqLCxMtWrVcnSIAAAAcCLdunXL8GnlAAAAAO4OjBeyN4fO2Lh8+bIOHjxofZ5QQT5fvnwqXry4QkNDdeLECX3++edycXGxKRwj3Zy24+XllaQdAAAAAAAAAADcnRya2Ni2bZsaNWpkfZ6wtljXrl01a9YsnTp1SseOHXNUeAAAAAAAAAAAIJtxaGKjYcOGMsakuH3WrFmp7j9q1CiNGjUqY4MCAAAAAAAAAADZltPU2AAAAAAAAAAAACCxAQAAAAAAAAAAnAaJDQAAAAAAAAAA4DQcWmMDAAAgu5u75ViWnq9zreJZej57xMTEqEKFCvr8889Vp04dR4eD27Bs2TINHTpUv//+u1xcuMcJAAAgI2TlmIHxAjKTM40Xsnd0AAAASFW3bt1ksVj0/PPPJ9nWu3dvWSwWdevWzaY9IiJCffv2ValSpeTp6amgoCC1bt1aq1atSvVc06dPV3BwsM0gZcyYMapTp45y5colf3//ZPc7duyYWrVqpVy5cikgIEAvv/yybty4YdNnzZo1qlGjhjw9PVWmTBnNmjUrzWv/448/9NBDD8nLy0tBQUEaP358kj4LFy5UuXLl5OXlpcqVK+vHH3+02W6M0YgRI1S4cGF5e3uradOmOnDgQJrnzi4sFouWLl2a7v4tWrSQu7u75syZk3lBAQAAINtgvMB44W4dL5DYAJDldyMDADJWUFCQ5s+fr2vXrlnbrl+/rrlz56p4cds7uo4cOaKaNWvql19+0TvvvKNdu3Zp2bJlatSokXr37p3iOYwx+vDDD9WzZ0+b9piYGHXo0EEvvPBCsvvFxcWpVatWiomJ0caNGzV79mzNmjVLI0aMsPYJDw9Xq1at1KhRI4WFhal///569tlntXz58hTjiYqKUvPmzVWiRAlt375d77zzjkaNGqWPP/7Y2mfjxo168skn1bNnT+3YsUPt2rVTu3bt9Oeff1r7jB8/Xu+//76mT5+uLVu2KHfu3AoJCdH169dTPLez69atm95//31HhwEAAIAswniB8YI9nGW8QGIDAADAydWoUUNBQUH6+uuvrW1ff/21ihcvrurVq9v0ffHFF2WxWLR161a1b99eZcuWVcWKFTVw4EBt3rw5xXNs375dhw4dUqtWrWzaR48erQEDBqhy5crJ7vfzzz/rr7/+0pdffqlq1aqpZcuWeuONNzRlyhTFxMRI+u/OrokTJ6p8+fLq06ePHn/8cb333nspxjNnzhzFxMRoxowZqlixop544gn169dP7777rrXP5MmT1aJFC7388ssqX7683njjDdWoUUMffvihpJuDr0mTJmnYsGFq27atqlSpos8//1wnT55M9a6mZcuWqV69evL391f+/Pn1yCOP6NChQzZ9Nm7cqGrVqsnLy0v33Xefli5dKovForCwMGufP//8Uy1btpSPj48KFSqkZ555RufOnbNub9iwofr166chQ4YoX758CgwM1KhRo6zbS5YsKUl69NFHZbFYrM937typRo0aKU+ePPL19VXNmjW1bds2636tW7fWtm3bksSMZBjj6AgAAADuGOMFxgt343iBxAYAAMBdoEePHpo5c6b1+YwZM9S9e3ebPufPn9eyZcvUu3dv5c6dO8kxUpoaLknr169X2bJllSdPHrvi2rRpkypXrqxChQpZ20JCQhQVFaXdu3db+zRt2tRmv5CQEG3atCnV49avX18eHh42++zbt08XLlxI13HDw8MVERFh08fPz0+1atVK9dxXrlzRwIEDtW3bNq1atUouLi569NFHFR8fL+nm3WGtW7dW5cqV9fvvv+uNN97QK6+8YnOMixcvqnHjxqpevbq2bdumZcuW6fTp0+rYsaNNv9mzZyt37tzasmWLxo8fr9dff10rVqyQJP3222+SpJkzZ+rUqVPW50899ZSKFSum3377Tdu3b9fQoUPl7u5uPWbx4sVVqFAhrV+/PsVrBAAAwN2F8QLjhbttvEDxcAAAgLvA008/rdDQUB09elSS9Ouvv2r+/Plas2aNtc/BgwdljFG5cuXsPv7Ro0dVpEgRu/eLiIiwGaRIsj6PiIhItU9UVJSuXbsmb2/vZI8bHByc4nHz5s2b4nETnzfxfsn1SU779u1tns+YMUMFCxbUX3/9pUqVKmnu3LmyWCz65JNP5OXlpQoVKujEiRPq1auXdZ8PP/xQ1atX11tvvWVznKCgIO3fv19ly5aVJFWpUkUjR46UJN1zzz368MMPtWrVKjVr1kwFCxaUdHOAGRgYaD3OsWPH9PLLL1t/z/fcc0+SayhSpIj1vQIAAIC7H+MFxgsJ7pbxAjM2AAAA7gIFCxZUq1atNGvWLM2cOVOtWrVSgQIFbPqYO1hW59q1a/Ly8rrTMO8KBw4c0JNPPqlSpUrJ19fXOqX72LGbNav27dunKlWq2LxeDzzwgM0xdu7cqdWrV8vHx8f6SBhYJJ7yXaVKFZv9ChcurDNnzqQa38CBA/Xss8+qadOmGjduXLJTyL29vXX16tX0XzQAAACcGuOFrMN4IWuQ2AAAALhL9OjRQ7NmzdLs2bPVo0ePJNvvueceWSwW7d271+5jFyhQwDpl2x6BgYE6ffq0TVvC84S7hlLq4+vrm+zdV3d63MTbE++XXJ/ktG7dWufPn9cnn3yiLVu2aMuWLZJkXQM4PS5fvqzWrVsrLCzM5nHgwAHVr1/f2i/xlHBJslgs1insKRk1apR2796tVq1a6ZdfflGFChW0ZMkSmz7nz5+33sEFAACAnIHxAuMF6e4ZL5DYAAAAuEu0aNFCMTExio2NVUhISJLt+fLlU0hIiKZMmaIrV64k2X7x4sUUj129enXt3bvX7ru4ateurV27dtncNbRixQr5+vqqQoUK1j6rVq2y2W/FihWqXbt2qsddt26dYmNjbfa59957lTdv3nQdNzg4WIGBgTZ9oqKitGXLlhTP/c8//2jfvn0aNmyYmjRpovLlyycZwN17773atWuXoqOjrW0J69kmqFGjhnbv3q2SJUuqTJkyNo/k1jNOibu7u+Li4pK0ly1bVgMGDNDPP/+sxx57zGY95evXr+vQoUNJCkUCAADg7sZ4gfFCgrthvEBiAwAA4C7h6uqqPXv26K+//pKrq2uyfaZMmaK4uDg98MADWrx4sQ4cOKA9e/bo/fffT3Vg0KhRI12+fNlawC/BsWPHFBYWpmPHjikuLs56J9Hly5clSc2bN1eFChX0zDPPaOfOnVq+fLmGDRum3r17y9PTU5L0/PPP6/DhwxoyZIj27t2rqVOnasGCBRowYECK8XTu3FkeHh7q2bOndu/era+++kqTJ0/WwIEDrX1eeuklLVu2TBMnTtTevXs1atQobdu2TX369JF0826m/v37680339S3336rXbt2qUuXLipSpIjatWuX7Hnz5s2r/Pnz6+OPP9bBgwf1yy+/2JwzIbb4+Hg999xz2rNnj5YvX64JEyZYzylJvXv31vnz5/Xkk0/qt99+06FDh7R8+XJ179492YFHSkqWLKlVq1YpIiJCFy5c0LVr19SnTx+tWbNGR48e1a+//qrffvtN5cuXt+6zefNmeXp6pvr7BgAAwN2H8QLjhbtqvGBymMjISCPJREZGOjoUIFuYs/mombP5qKPDAACHunbtmvnrr7/MtWvXHB2K3bp27Wratm2b4va2bduarl272rSdPHnS9O7d25QoUcJ4eHiYokWLmjZt2pjVq1eneq6OHTuaoUOHJjm/pCSPxMc6cuSIadmypfH29jYFChQwgwYNMrGxsTbHWb16talWrZrx8PAwpUqVMjNnzrTZPnPmTHPrR9edO3eaevXqGU9PT1O0aFEzbty4JDEvWLDAlC1b1nh4eJiKFSuaH374wWZ7fHy8GT58uClUqJDx9PQ0TZo0Mfv27Uv1dVixYoUpX7688fT0NFWqVDFr1qwxksySJUusfX799VdTpUoV4+HhYWrWrGnmzp1rJJm9e/da++zfv988+uijxt/f33h7e5ty5cqZ/v37m/j4eGOMMQ0aNDAvvfSSzblv/X1+++23pkyZMsbNzc2UKFHCREdHmyeeeMIEBQUZDw8PU6RIEdOnTx+b9/Zzzz1n/ve//6V4fan9PeSUz9LW6/xjuaNDAQAA2YSzjhkYLzBeyOjxgjHZY8xgMeYOqsI4oaioKPn5+SkyMlK+vr6ODgdwuLlbbhYu6lyruIMjAQDHuX79usLDwxUcHEzBu1T88ccfatasmQ4dOiQfH58sPffIkSO1du1arVmzJkvPm1HmzJmj7t27KzIyMsV1gLPCuXPndO+992rbtm0KDg5Otk9qfw855bO09Tr/WC7fys0dHQ4AAMgGGDOkjfHC7XOm8YKUPcYMbpl2ZAAAANxVqlSporffflvh4eGqXLlylp77p59+0ocffpil57wTn3/+uUqVKqWiRYtq586deuWVV9SxY0eHDlIk6ciRI5o6dWqqgxQAAADgdjBeSD/GC3eOxAYAAADSrVu3bg4579atWx1y3tsVERGhESNGKCIiQoULF1aHDh00ZswYR4el++67T/fdd5+jwwAAAMBdivFC+jBeuHMkNgAAAIAMNmTIEA0ZMsTRYQAAAADIhhgv3DkXRwcAAAAAAAAAAACQXiQ2AAAA/hUfH+/oEACH4+8AAAAgZXxWArLH3wFLUQEAgBzPw8NDLi4uOnnypAoWLCgPDw9ZLBZHhwVkKWOMYmJidPbsWbm4uMjDw8PRIQEAAGQbjBmA7DVmILEBAAByPBcXFwUHB+vUqVM6efKko8MBHCpXrlwqXry4XFyY3A0AAJCAMQPwn+wwZiCxAQAAoJt3YBUvXlw3btxQXFyco8MBHMLV1VVubm7cfWhlHB0AAADIRhgzANlnzEBiAwAA4F8Wi0Xu7u5yd3d3dCgAAAAAsiHGDED2wPxyAAAAAAAAAADgNEhsAAAAAAAAAAAAp0FiAwAAAAAAAAAAOA0SGwAAAAAAAAAAwGmQ2AAAAAAAAAAAAE6DxAYAAAAAAAAAAHAaJDYAAAAAAAAAAIDTILEBAAAAAAAAAACcBokNAAAAAAAAAADgNEhsAAAAAAAAAAAAp0FiAwAAAAAAAAAAOA0SGwAAAAAAAAAAwGmQ2AAAAAAAAAAAAE6DxAYAAAAAAAAAAHAaJDYAAAAAIDnGODoCAAAAAMkgsQEAAAAAAAAAAJwGiQ0AAAAAAAAAAOA0SGwAAAAAAAAAAACnQWIDAAAAAAAAAAA4DRIbAAAAAAAAAADAaZDYAAAAAAAAAAAAToPEBgAAAAAAAAAAcBokNgAAAAAAAAAAgNMgsQEAAAAAAAAAAJwGiQ0AAAAAAAAAAOA0SGwAAAAAAAAAAACnQWIDAAAAAAAAAAA4DRIbAAAAAAAAAADAaZDYAAAAAAAAAAAAToPEBgAAAAAAAAAAcBokNgAAAAAAAAAAgNMgsQEAAAAAyTKODgAAAABAMhya2Fi3bp1at26tIkWKyGKxaOnSpan2//rrr9WsWTMVLFhQvr6+ql27tpYvX541wQIAAAAAAAAAAIdzaGLjypUrqlq1qqZMmZKu/uvWrVOzZs30448/avv27WrUqJFat26tHTt2ZHKkAAAAAAAAAAAgO3Bz5Mlbtmypli1bprv/pEmTbJ6/9dZb+uabb/Tdd9+pevXqye4THR2t6Oho6/OoqKjbihUAAAAAAAAAADieU9fYiI+P16VLl5QvX74U+4wdO1Z+fn7WR1BQUBZGCAAAAAAAAAAAMpJTJzYmTJigy5cvq2PHjin2CQ0NVWRkpPVx/PjxLIwQAAAAAAAAAABkJIcuRXUn5s6dq9GjR+ubb75RQEBAiv08PT3l6emZhZEBAAAAAAAAAIDM4pSJjfnz5+vZZ5/VwoUL1bRpU0eHAwAAAAAAAAAAsojTLUU1b948de/eXfPmzVOrVq0cHQ4AAACALDR27Fjdf//9ypMnjwICAtSuXTvt27fPpk/Dhg1lsVhsHs8//7yDIgYAAACQ0Rya2Lh8+bLCwsIUFhYmSQoPD1dYWJiOHTsm6WZ9jC5dulj7z507V126dNHEiRNVq1YtRUREKCIiQpGRkY4IHwAAAEAWW7t2rXr37q3NmzdrxYoVio2NVfPmzXXlyhWbfr169dKpU6esj/HjxzsoYgAAAAAZzaFLUW3btk2NGjWyPh84cKAkqWvXrpo1a5ZOnTplTXJI0scff6wbN26od+/e6t27t7U9oT8AAACAu9uyZctsns+aNUsBAQHavn276tevb23PlSuXAgMD03XM6OhoRUdHW59HRUVlTLAAAAAAMoVDExsNGzaUMSbF7bcmK9asWZO5AQEAAABwKgmzt/Ply2fTPmfOHH355ZcKDAxU69atNXz4cOXKlSvZY4wdO1ajR4/O9FgBAAAAZAynLB4OAAAAAPHx8erfv7/q1q2rSpUqWds7d+6sEiVKqEiRIvrjjz/0yiuvaN++ffr666+TPU5oaKh19rh0c8ZGUFBQpscPAAAA4PaQ2AAAAADglHr37q0///xTGzZssGl/7rnnrD9XrlxZhQsXVpMmTXTo0CGVLl06yXE8PT3l6emZ6fECAAAAyBgOLR4OAAAAALejT58++v7777V69WoVK1Ys1b61atWSJB08eDArQgMAAACQyZixAQAAAMBpGGPUt29fLVmyRGvWrFFwcHCa+4SFhUmSChcunMnRAQAAAMgKJDYAAAAAOI3evXtr7ty5+uabb5QnTx5FRERIkvz8/OTt7a1Dhw5p7ty5evjhh5U/f3798ccfGjBggOrXr68qVarYdzJjMuEKAAAAANwpEhsAAAAAnMa0adMkSQ0bNrRpnzlzprp16yYPDw+tXLlSkyZN0pUrVxQUFKT27dtr2LBhDogWAAAAQGYgsQEAAADAaZg0ZlEEBQVp7dq1WRQNAAAAAEegeDgAAAAAAAAAAHAaJDYAAAAAAAAAAIDTILEBAAAAAAAAAACcBokNAAAAAAAAAADgNEhsAAAAAAAAAAAAp0FiAwAAAAAAAAAAOA0SGwAAAAAAAAAAwGmQ2AByqrgb0o8v64E/R8k17rqjowEAAAAAAACAdHFzdAAAHOTQKmnrxyoj6XS++yWVdXREAAAAAAAAAJAmZmwAOdWVs9YfvaLPOzAQAAAAAAAAAEg/EhtAThUXY/3RYuIcGAgAAAAAAAAApB+JDSCniou1/uhibjgwEAAAAAAAAABIPxIbQE6VaMYGiQ0AAAAAAAAAzoLEBpBT3Yi2/miJJ7EBAACQlHF0AAAAAACSQWIDyKlslqKixgYAAAAAAAAA50BiA8ipbIqHM2MDAAAAAAAAgHMgsQHkVNTYAAAAAAAAAOCESGwAOVWipagsLEUFAAAAAAAAwEmQ2AByqsQzNigeDgAAAAAAAMBJkNgAcipmbAAAAAAAAABwQiQ2gJyKGhsAAAAAAAAAnBCJDSCnYikqAAAAAAAAAE6IxAaQU9ksRUViAwAAAAAAAIBzILEB5FQ2S1FRYwMAAAAAAACAcyCxAeRUcdHWH1mKCgAAAAAAAICzILEB5FQsRQUAAAAAAADACZHYAHIqm6WoSGwAAAAAAAAAcA4kNoCcKlFiw0KNDQAAAAAAAABOgsQGkFPZLEVFYgMAAAAAAACAcyCxAeRUiZeiong4AABAUsY4OgIAAAAAySCxAeRUiWZsUGMDAAAAAAAAgLMgsQHkVDY1NkhsAAAAAAAAAHAOJDaAnMpmKSpqbAAAAAAAAABwDiQ2gJyKpagAAAAAAAAAOCESG0BOZbMUFTM2AAAAAAAAADgHEhtATmTMLUtRxabSGQAAAAAAAACyDxIbQE4UZ5vIYMYGAAAAAAAAAGdBYgPIiRLN1pCosQEAAAAAAADAeZDYAHKiWxIbzNgAAAAAAAAA4CxIbAA50S1LUbmQ2AAAAAAAAADgJEhsADnRrTM2KB4OAAAAAAAAwEmQ2AByoiQ1NpixAQAAAAAAAMA5kNgAcqJblqKyyEjxJDcAAAAAAAAAZH8kNoCc6JYZG5Kk+BtZHwcAAAAAAAAA2InEBpATxSVTUyO5NgAAAAAAAADIZkhsADkRMzYAAADSwTg6AAAAAADJILEB5EQkNgAAAAAAAAA4KRIbQE6U3LJTJDYAAAAAAAAAOAESG0BOFBedTBs1NgAAAAAAAABkfw5NbKxbt06tW7dWkSJFZLFYtHTp0jT3WbNmjWrUqCFPT0+VKVNGs2bNyvQ4gbsOS1EBAAAAAAAAcFIOTWxcuXJFVatW1ZQpU9LVPzw8XK1atVKjRo0UFham/v3769lnn9Xy5cszOVLgLpPsUlRxWR8HAAAAAAAAANjJzZEnb9mypVq2bJnu/tOnT1dwcLAmTpwoSSpfvrw2bNig9957TyEhIcnuEx0drejo/5bdiYqKurOggbtBsjM2WIoKAAAAAAAAQPbnVDU2Nm3apKZNm9q0hYSEaNOmTSnuM3bsWPn5+VkfQUFBmR0mkP2xFBUAAAAAAAAAJ+VUiY2IiAgVKlTIpq1QoUKKiorStWvXkt0nNDRUkZGR1sfx48ezIlQge0tuKSqKhwMAAAAAAABwAg5diioreHp6ytPT09FhANlLsjM2qLEBAAAAAAAAIPtzqhkbgYGBOn36tE3b6dOn5evrK29vbwdFBTghamwAAAAAAAAAcFJOldioXbu2Vq1aZdO2YsUK1a5d20ERAU4quWWnqLEBAAAAAAAAwAk4NLFx+fJlhYWFKSwsTJIUHh6usLAwHTt2TNLN+hhdunSx9n/++ed1+PBhDRkyRHv37tXUqVO1YMECDRgwwBHhA84ruRkb1NgAAAAAAAAA4AQcmtjYtm2bqlevrurVq0uSBg4cqOrVq2vEiBGSpFOnTlmTHJIUHBysH374QStWrFDVqlU1ceJEffrppwoJCXFI/IDTosYGAAAAAAAAACfl0OLhDRs2lDEmxe2zZs1Kdp8dO3ZkYlRADnCDGhsAAAAAAAAAnJNT1dgAkEGSnbFBjQ0AAAAAAAAA2R+JDSAnong4AAAAAAAAACdFYgPIiZItHk5iAwAAwEYqy+YCAAAAcBwSG0BOxFJUAAAAAAAAAJwUiQ0gJ0p2KSqKhwMAAAAAAADI/khsADkRMzYAAAAAAAAAOCkSG0BORI0NAAAAAAAAAE6KxAaQEyW7FBWJDQAAAAAAAADZH4kNICdKdikqamwAAIDsb+zYsbr//vuVJ08eBQQEqF27dtq3b59Nn+vXr6t3797Knz+/fHx81L59e50+fdpBEQMAAADIaCQ2gJyIGhsAAMBJrV27Vr1799bmzZu1YsUKxcbGqnnz5rpy5Yq1z4ABA/Tdd99p4cKFWrt2rU6ePKnHHnvMgVEDAAAAyEhujg4AgAMktxQVNTYAAIATWLZsmc3zWbNmKSAgQNu3b1f9+vUVGRmpzz77THPnzlXjxo0lSTNnzlT58uW1efNmPfjgg0mOGR0drejoaOvzqKiozL0IAAAAAHeEGRtAThQXnbSNGRsAAMAJRUZGSpLy5csnSdq+fbtiY2PVtGlTa59y5cqpePHi2rRpU7LHGDt2rPz8/KyPoKCgzA8cAAAAwG0jsQHkRBQPBwAAd4H4+Hj1799fdevWVaVKlSRJERER8vDwkL+/v03fQoUKKSIiItnjhIaGKjIy0vo4fvx4ZocOAAAA4A6wFBWQE1FjAwAA3AV69+6tP//8Uxs2bLij43h6esrT0zODogIAAACQ2ZixAeREJDYAAICT69Onj77//nutXr1axYoVs7YHBgYqJiZGFy9etOl/+vRpBQYGZnGUAAAAADIDiQ0gJ0q2eHgybQAAANmMMUZ9+vTRkiVL9Msvvyg4ONhme82aNeXu7q5Vq1ZZ2/bt26djx46pdu3aWR0uAAAAgEzAUlRATvTvjI14i6tcTNzNNmZsAAAAJ9C7d2/NnTtX33zzjfLkyWOtm+Hn5ydvb2/5+fmpZ8+eGjhwoPLlyydfX1/17dtXtWvX1oMPPujg6AEAAABkBLtnbMycOVNXr17NjFgAZAVjrImNG67e/7WT2AAAAE5g2rRpioyMVMOGDVW4cGHr46uvvrL2ee+99/TII4+offv2ql+/vgIDA/X11187MGoAAAAAGcnuxMbQoUMVGBionj17auPGjZkRE4DMlCiBEefqlWw7AABAdmWMSfbRrVs3ax8vLy9NmTJF58+f15UrV/T111/fZn0Nk2FxAwAAAMg4dic2Tpw4odmzZ+vcuXNq2LChypUrp7fffts6BRxANpeocLjNjA1qbAAAAAAAAABwAnYnNtzc3PToo4/qm2++0fHjx9WrVy/NmTNHxYsXV5s2bfTNN98oPj4+M2IFkBFSSmwwYwMAAAAAAACAE7A7sZFYoUKFVK9ePdWuXVsuLi7atWuXunbtqtKlS2vNmjUZFCKADJVoZgaJDQAAAAAAAADO5rYSG6dPn9aECRNUsWJFNWzYUFFRUfr+++8VHh6uEydOqGPHjuratWtGxwogIySasUGNDQAAAAAAAADOxu7ERuvWrRUUFKRZs2apV69eOnHihObNm6emTZtKknLnzq1Bgwbp+PHjGR4sgAxwI/q/H5mxAQAAAAAAAMDJuNm7Q0BAgNauXavatWun2KdgwYIKDw+/o8AAZJKUlqKieDgAAAAAAAAAJ2D3jI0GDRqoRo0aSdpjYmL0+eefS5IsFotKlChx59EByHgpLkUV54BgAAAAAAAAAMA+dic2unfvrsjIyCTtly5dUvfu3TMkKACZyGbGRuLEBjM2AAAAAAAAAGR/dic2jDGyWCxJ2v/++2/5+fllSFAAMlHiGRsunopP+G+AGhsAAAAAAAAAnEC6a2xUr15dFotFFotFTZo0kZvbf7vGxcUpPDxcLVq0yJQgAWSgRImNeBd3GRc3KT5GiiOxAQAAAAAAACD7S3dio127dpKksLAwhYSEyMfHx7rNw8NDJUuWVPv27TM8QAAZLNFSVPEWd8VbXOUqMWMDAAAAAAAAgFNId2Jj5MiRkqSSJUuqU6dO8vLySmMPANnSrTM2LP/+N0CNDQAAAAAAAABOIN2JjQRdu3bNjDgAZJVbEhvx1sQGMzYAAAAAAAAAZH/pSmzky5dP+/fvV4ECBZQ3b95ki4cnOH/+fIYFByAT2CxF5aZ4l4TERpyDAgIAAAAAAACA9EtXYuO9995Tnjx5rD+nltgAkM0lmrER5+IhY3H99wlLUQEAAAAAAADI/tKV2Ei8/FS3bt0yKxYAWSEu2vrjzRob/yY2WIoKAAAAAAAAgBNwsXeH33//Xbt27bI+/+abb9SuXTu9+uqriomJSWVPANlC4qWoXNwV7+L+7xNmbAAAAAAAAADI/uxObPzvf//T/v37JUmHDx9Wp06dlCtXLi1cuFBDhgzJ8AABZLDExcMt7oq3ztigxgYAAAAAAACA7M/uxMb+/ftVrVo1SdLChQvVoEEDzZ07V7NmzdLixYszOj4AGS1xYsPFXcby74p01NgAAAAAAAAA4ATsTmwYYxQfHy9JWrlypR5++GFJUlBQkM6dO5ex0QHIeLcuRUWNDQAAAAAAAABOxO7Exn333ac333xTX3zxhdauXatWrVpJksLDw1WoUKEMDxBABrt1xobLvzM2TJxkjIOCAgAAAAAAAID0sTuxMWnSJP3+++/q06ePXnvtNZUpU0aStGjRItWpUyfDAwSQwZLU2HD7bxuzNgAAAAAAAABkc25pd7FVpUoV7dq1K0n7O++8I1dX1wwJCkAmSrIUlZvtNld3BwQFAAAAAAAAAOljd2IjQUxMjM6cOWOtt5GgePHidxwUgEyUaMZGnIu7jCVRQpIZGwAAAAAAAACyObsTG/v371fPnj21ceNGm3ZjjCwWi+Li4jIsOACZ4NalqFxYigoAAAAAAACA87A7sdG9e3e5ubnp+++/V+HChWWxWDIjLgCZ5ZalqJixAQAAAAAAAMCZ2J3YCAsL0/bt21WuXLnMiAdAZks8Y8PFQ/GWRDU1SGwAAAAAAAAAyOZc7N2hQoUKOnfuXGbEAiAr3Eic2HCTcUk0YyPRbA4AAAAAAAAAyI7sTmy8/fbbGjJkiNasWaN//vlHUVFRNg8A2dwtxcPjWYoKAAAAAAAAgBOxeymqpk2bSpKaNGli007xcMBJ3Fo83ELxcAAAAAAAAADOw+7ExurVqzMjDgBZJUnxcBIbAAAAAAAAAJyH3YmNBg0aZEYcALJKohkbxuKmeJdE/w1QYwMAACAR4+gAAAAAACTD7hobkrR+/Xo9/fTTqlOnjk6cOCFJ+uKLL7Rhw4YMDQ5AJvg3sRFncZcsFhmbGhssJQcAAAAAAAAge7M7sbF48WKFhITI29tbv//+u6KjoyVJkZGReuuttzI8QAAZ7N9ZGfEu7jf/tVmKihkbAAAAAAAAALI3uxMbb775pqZPn65PPvlE7u7u1va6devq999/z9DgAGSCf2dsJCQ2bGdsUGMDAAAAAAAAQPZmd2Jj3759ql+/fpJ2Pz8/Xbx4MSNiApCZbp2x4ULxcAAAAAAAAADOw+7ERmBgoA4ePJikfcOGDSpVqlSGBAUgEyXM2LAkzNhIXDycxAYAAAAAAACA7M3uxEavXr300ksvacuWLbJYLDp58qTmzJmjwYMH64UXXrA7gClTpqhkyZLy8vJSrVq1tHXr1lT7T5o0Sffee6+8vb0VFBSkAQMG6Pr163afF8ixblmKyrbGBokNAAAAAAAAANmbW9pdbA0dOlTx8fFq0qSJrl69qvr168vT01ODBw9W37597TrWV199pYEDB2r69OmqVauWJk2apJCQEO3bt08BAQFJ+s+dO1dDhw7VjBkzVKdOHe3fv1/dunWTxWLRu+++a++lADnTv0tRxbl4SJLibWpsUDwcAAAAAAAAQPZmd2LDYrHotdde08svv6yDBw/q8uXLqlChgnx8fOw++bvvvqtevXqpe/fukqTp06frhx9+0IwZMzR06NAk/Tdu3Ki6deuqc+fOkqSSJUvqySef1JYtW1I8R3R0tKKjo63Po6Ki7I4TuKvE3fx7sBYPp8YGAAAAAAAAACdi91JUkmSMUVRUlAoVKqQHHnjgtpIaMTEx2r59u5o2bfpfMC4uatq0qTZt2pTsPnXq1NH27duty1UdPnxYP/74ox5++OEUzzN27Fj5+flZH0FBQXbHCtw1jElSYyOeGhsAAAAAAAAAnIhdiY2IiAh16dJFefPmVaFChRQQEKC8efOqR48eOn36tF0nPnfunOLi4lSoUCGb9kKFCikiIiLZfTp37qzXX39d9erVk7u7u0qXLq2GDRvq1VdfTfE8oaGhioyMtD6OHz9uV5zAXSXRjIz4f2dqGJulqEhsAAAAAAAAAMje0r0UVVRUlOrUqaPLly+re/fuKleunIwx+uuvvzRv3jxt2LBBv//++23N3kivNWvW6K233tLUqVNVq1YtHTx4UC+99JLeeOMNDR8+PNl9PD095enpmWkxAU7l39kaUqLi4TZLUVFjAwAAAAAAAED2lu7ExuTJk+Xq6qrdu3erYMGCNtuGDRumunXr6v3330919kRiBQoUkKura5KZHqdPn1ZgYGCy+wwfPlzPPPOMnn32WUlS5cqVdeXKFT333HN67bXX5OJyWytrATlHMokNZmwAAAAAAAAAcCbpzgT88MMPevXVV5MkNSQpICBAoaGh+u6779J9Yg8PD9WsWVOrVq2ytsXHx2vVqlWqXbt2svtcvXo1SfLC1fXml7LGmHSfG8ix4v6bkRFHjQ0AAAAAAAAATijdiY39+/erTp06KW6vU6eO9u3bZ9fJBw4cqE8++USzZ8/Wnj179MILL+jKlSvq3r27JKlLly4KDQ219m/durWmTZum+fPnKzw8XCtWrNDw4cPVunVra4IDQCqSnbGReCkqEhsAAAAAAAAAsje7amz4+/unuN3f319RUVF2nbxTp046e/asRowYoYiICFWrVk3Lli2zFhQ/duyYzQyNYcOGyWKxaNiwYTpx4oQKFiyo1q1ba8yYMXadF8ix0qyxQWIDAAAAAAAAQPaW7sSGMSbVGhYWi+W2loPq06eP+vTpk+y2NWvW2Dx3c3PTyJEjNXLkSLvPA0A2S1HFW5eiSlxjg+LhAAAAVix3CwAAAGRLdiU2ypYtK4vFkuJ2ANlcmktRxWV1RAAAAAAAAABgl3QnNmbOnJmZcQDICjaJDY+b/9oUD2fGBgAAAAAAAIDsLd2Jja5du2ZmHACywo3/Ehtx1NgAAAAAAAAA4IRSLpoB4O6T7FJU1NgAAAAAAAAA4DxIbAA5STLFw20TG9TYAAAAAAAAAJC9kdgAcpJkZmwk/HtzOzM2AAAAAAAAAGRvJDaAnCS5xIbNjA1qbAAAAAAAAADI3uxObKxevToz4gCQFWyWorpZNNxYEhcPZ8YGAAAAAAAAgOzN7sRGixYtVLp0ab355ps6fvx4ZsQEILOkOWODGhsAAAAAAAAAsje7ExsnTpxQnz59tGjRIpUqVUohISFasGCBYmJi0t4ZgGMlW2Mj8YwNlqICAAAAAAAAkL3ZndgoUKCABgwYoLCwMG3ZskVly5bViy++qCJFiqhfv37auXNnZsQJICPYLEV1M7FhsxQVxcMBAAAAAAAAZHN3VDy8Ro0aCg0NVZ8+fXT58mXNmDFDNWvW1EMPPaTdu3dnVIwAMkqiGRtx1qWomLEBAAAAAAAAwHncVmIjNjZWixYt0sMPP6wSJUpo+fLl+vDDD3X69GkdPHhQJUqUUIcOHTI6VgB3KpmlqIxNjQ0SGwAAAAAAAACyN7e0u9jq27ev5s2bJ2OMnnnmGY0fP16VKlWybs+dO7cmTJigIkWKZGigADJA4qWoXDz+/ZcZGwAAAAAAAACch92Jjb/++ksffPCBHnvsMXl6eibbp0CBAlq9evUdB3fXM0b6YaB0dr/UboqUt6SjI8LdLi7a+uN/MzaosQEAAAAAAADAedi9FNXIkSPVoUOHJEmNGzduaN26dZIkNzc3NWjQIGMivJsdXCltmyEd3SAt6uHoaJATJF6KypJcjY24rI4IAAAgGzOODgAAAABAMuxObDRq1Ejnz59P0h4ZGalGjRplSFA5xrn9//18Yrvj4kDOYbMU1b8zNlwS19hgxgYAAAAAAACA7M3uxIYxRhaLJUn7P//8o9y5c2dIUDmG5bZqtwO3L9GMjbiExEbi/waosQEAAAAAAAAgm0t3jY3HHntMkmSxWNStWzebpaji4uL0xx9/qE6dOhkf4V0taYIIyFTJLEUli0VxFje5mhvU2AAAAAAAAACQ7aU7seHn5yfp5oyNPHnyyNvb27rNw8NDDz74oHr16pXxEd7NmLGBrJbMUlTSvwXEzQ1qbAAAAAAAAADI9tKd2Jg5c6YkqWTJkho8eDDLTmWEZJb0AjJV4hkbiRIb8S5uUrxYigoAAGR769at0zvvvKPt27fr1KlTWrJkidq1a2fd3q1bN82ePdtmn5CQEC1btiyLIwUAAACQWeyeMjBy5EiSGhmFGRvIainO2Pi3gDjFwwEAQDZ35coVVa1aVVOmTEmxT4sWLXTq1CnrY968eVkYIQAAAIDMlq4ZGzVq1NCqVauUN29eVa9ePdni4Ql+//33DAvurkdiA1ktuRobkuIt//5XwIwNAACQzbVs2VItW7ZMtY+np6cCAwPTfczo6GhFR0dbn0dFRd12fAAAAAAyX7oSG23btrUWC088zRt3iMQGsloKS1FZZ2zEkdgAAADOb82aNQoICFDevHnVuHFjvfnmm8qfP3+K/ceOHavRo0dnYYQAAAAA7kS6EhsjR45M9mfcIRIbyGopLEVl/ZkZGwAAwMm1aNFCjz32mIKDg3Xo0CG9+uqratmypTZt2iRXV9dk9wkNDdXAgQOtz6OiohQUFJRVIQMAAACwU7qLhyMTkNhAVrNZiuq/P39qbAAAgLvFE088Yf25cuXKqlKlikqXLq01a9aoSZMmye7j6elpnaEOAAAAIPtLV2Ijb968qdbVSOz8+fN3FFCOks7XFMgo56MuK5+kOIu7zfvvvxobcY4JDAAAIJOUKlVKBQoU0MGDB1NMbAAAAABwLulKbEyaNCmTw8ihmLGBLOby74yMxMtQ3XyeUGODGRsAAODu8vfff+uff/5R4cKFHR0KAAAAgAySrsRG165dMzuOnInEBrJYSokNY52xQY0NAACQvV2+fFkHDx60Pg8PD1dYWJjy5cunfPnyafTo0Wrfvr0CAwN16NAhDRkyRGXKlFFISIgDowYAAACQkdKV2IiKipKvr6/159Qk9EM6kNhAFnMxKczYsCY2YiVjWCYNAABkW9u2bVOjRo2szxOKfnft2lXTpk3TH3/8odmzZ+vixYsqUqSImjdvrjfeeIMaGgAAAMBdJN01Nk6dOqWAgAD5+/snW2/DGCOLxaK4ONboTze+PEYWs87YsNw6Y8M10ZN4KfFzAACAbKRhw4YyxqS4ffny5VkYDQAAAABHSFdi45dfflG+fPkkSatXr87UgHIWEhvIWinX2Ej0X0H8DcmFxAYAAAAAAACA7CldiY0GDRok+zPuEEtRIYu5/pvYiEtSYyNRIiMuVnJjqQYAAAClMjMEAAAAgOOkK7FxqwsXLuizzz7Tnj17JEkVKlRQ9+7drbM6kE4kNpDFrDU2LCnU2JAoIA4AAAAAAAAgW7P7m/V169apZMmSev/993XhwgVduHBB77//voKDg7Vu3brMiPHuRWIDWcmYFJeiMiQ2AAAAAAAAADgJu2ds9O7dW506ddK0adPk6npz+Zq4uDi9+OKL6t27t3bt2pXhQd61SGwgK8XHyaKbyymkWWMDAAAAAAAAALIpu79ZP3jwoAYNGmRNakiSq6urBg4cqIMHD2ZocHc9EhvISnEx1h+TJDZurbEBAAAAAAAAANmU3d+s16hRw1pbI7E9e/aoatWqGRJUjkFiA1kpLtr6I0tRAQAAAAAAAHBW6VqK6o8//rD+3K9fP7300ks6ePCgHnzwQUnS5s2bNWXKFI0bNy5zorxbWSyOjgA5SaKZGHG3Fg9nKSoAAAAAAAAATiJdiY1q1arJYrHIGGNtGzJkSJJ+nTt3VqdOnTIuOthl7pZj6lyruKPDQHaV6lJUJDYAAAAAAAAAOId0JTbCw8MzOw4AmS2VxIahxgYAAAAAAAAAJ5GuxEaJEiUyO46cKdEMGCDTJUpYxLMUFQAAAAAAAAAnla7ERnL++usvHTt2TDExMTbtbdq0ueOgAGSC9M7YiI/LqogAAAAAAAAAwG52JzYOHz6sRx99VLt27bKpu2H5txB2XBxfiqYfMzaQhdJdY4OlqAAAAAAAAABkXy727vDSSy8pODhYZ86cUa5cubR7926tW7dO9913n9asWZMJId7FWIoKWSnxUlRJZmywFBUAAAAAAAAA52D3jI1Nmzbpl19+UYECBeTi4iIXFxfVq1dPY8eOVb9+/bRjx47MiBPAnUo8Y+PWGhsUDwcAAAAAAADgJOyesREXF6c8efJIkgoUKKCTJ09KullgfN++fRkb3V2PGRvIQqnV2LApHs5ycgAAAAAAAACyL7tnbFSqVEk7d+5UcHCwatWqpfHjx8vDw0Mff/yxSpUqlRkx3r1YigpZKdFMjDhqbAAAAAAAAABwUnbP2Bg2bJji4+MlSa+//rrCw8P10EMP6ccff9T777+f4QEia8zdcszRISCzpboUFTU2AAAAAAAAADgHu2dshISEWH8uU6aM9u7dq/Pnzytv3ryyWCwZGtzdjxkbyDq/7jupuv/+nLR4ODU2AAAAAAAAADgHuxMbiR0/flySFBQUlCHBAMg8LomWmLo1sRFPjQ0AAAAAAAAATsLupahu3Lih4cOHy8/PTyVLllTJkiXl5+enYcOGKTaWO73tQo0NZKHUEhs2MzaosQEAAAAAAAAgG7N7xkbfvn319ddfa/z48apdu7YkadOmTRo1apT++ecfTZs2LcODvHuR2EDWcTWJEhtJamwkek6NDQAAAAAAAADZmN2Jjblz52r+/Plq2bKlta1KlSoKCgrSk08+SWIDyKYSz9iIu3XGhkviGRskNgAAAAAAAABkX3YvReXp6amSJUsmaQ8ODpaHh0dGxJRzsBQVslCqNTZsioeT2AAAAAAAAACQfdmd2OjTp4/eeOMNRUdHW9uio6M1ZswY9enTJ0ODg308o/+RdnwpXT7j6FCQDaWe2EhcPJzEBgAAAAAAAIDsK12Jjccee8z6CAsL0/fff69ixYqpadOmatq0qYoVK6bvvvtOO3futDuAKVOmqGTJkvLy8lKtWrW0devWVPtfvHhRvXv3VuHCheXp6amyZcvqxx9/tPu82UPGzthosL2v9E1vaU6HDD0u7g4uqdTYMDaJDYqHAwAAAAAAAMi+0lVjw8/Pz+Z5+/btbZ4HBQXd1sm/+uorDRw4UNOnT1etWrU0adIkhYSEaN++fQoICEjSPyYmRs2aNVNAQIAWLVqkokWL6ujRo/L397+t8ztcBi9FVSBy180fToVl6HFxd3BJNBMjyYwNF2ZsAAAAAAAAAHAO6UpszJw5M1NO/u6776pXr17q3r27JGn69On64YcfNGPGDA0dOjRJ/xkzZuj8+fPauHGj3N1vfjGbXL2PxKKjo22WzYqKisq4CwCcSGpLURlqbAAAAAAAAABwEnbX2Ehw9uxZbdiwQRs2bNDZs2ft3j8mJkbbt29X06ZN/wvGxUVNmzbVpk2bkt3n22+/Ve3atdW7d28VKlRIlSpV0ltvvaW4uLgUzzN27Fj5+flZH7c7uyRzUDwcWSe1paiosQEAAAAAAADAWdid2Lhy5Yp69OihwoULq379+qpfv76KFCminj176urVq+k+zrlz5xQXF6dChQrZtBcqVEgRERHJ7nP48GEtWrRIcXFx+vHHHzV8+HBNnDhRb775ZornCQ0NVWRkpPVx/PjxdMeY6TJ4KSogNYlnbMS5eNhss5mxQY0NAAAAAAAAANmY3YmNgQMHau3atfruu+908eJFXbx4Ud98843Wrl2rQYMGZUaMVvHx8QoICNDHH3+smjVrqlOnTnrttdc0ffr0FPfx9PSUr6+vzSPbcpJEx9wtxxwdAm6DR+wl689xrl4222yWpopPeQYUAAAAAAAAADhaumpsJLZ48WItWrRIDRs2tLY9/PDD8vb2VseOHTVt2rR0HadAgQJydXXV6dOnbdpPnz6twMDAZPcpXLiw3N3d5er6393l5cuXV0REhGJiYuTh4ZHsftnXLYkMYySLxTGh4K7nc+1vSVK8xVVXvWxnStnO2GApKgAAAAAAAADZl90zNq5evZpk+ShJCggIsGspKg8PD9WsWVOrVq2ytsXHx2vVqlWqXbt2svvUrVtXBw8eVHx8vLVt//79Kly4sBMmNZJhuFMemcQY+Vy9uQzbFa/CMi62OU2bGhtxLEUFAAAAAAAAIPuyO7FRu3ZtjRw5UtevX7e2Xbt2TaNHj04xIZGSgQMH6pNPPtHs2bO1Z88evfDCC7py5Yq6d+8uSerSpYtCQ0Ot/V944QWdP39eL730kvbv368ffvhBb731lnr37m3vZWQPty49ZeKT7wekIl1Lg127II8blyVJl3MVS7I53oUZGwAAAEk4yVKxAAAAQE5j91JUkyZNUosWLVSsWDFVrVpVkrRz5055eXlp+fLldh2rU6dOOnv2rEaMGKGIiAhVq1ZNy5Yts84IOXbsmFxc/su9BAUFafny5RowYICqVKmiokWL6qWXXtIrr7xi72VkT9Q2QGa5cMT6Y3KJDZN4xgaJDeD/7N13fFP1/sfxd7oXbZktZe89FKTiRQFBEFHACThAxHUFFXGg14HzouJW1J8DkKu4lXtdICAgCiJDEJFtoQi0zLaU7ub8/ghNkyZt0zbNScvr+XjkQXLyPed8cxr6yLeffD4fAAAAAAAA+LEKBza6deumnTt36oMPPtC2bdskSWPHjtU111yj8PDwCk9g8uTJmjx5stvnli9f7rKtb9+++uWXXyp8nhqhlmVszF+TrKsTm5s9DUjOgY1wNxkbBDYAAAAAAAAA1BAVCmzk5+erY8eO+vrrr3XTTTdV15xOHy6lqMjYQDU5nmS/6z5jw6EUFT02AAAAAAAAAPixCvXYCA4OduqtAS+rZRkb8CPllKKyBpCxAQAAAAAAAKBmqHDz8EmTJumZZ55RQQF//Ky6EhkbVgIbqCZOgY1mLk87ZWwQ2AAAAAAAAADgxyrcY2Pt2rVaunSpvv/+e3Xr1k2RkZFOz3/xxRdem1yt51KKisAGqsmpwEZucLTyg6NdnrZagh0eENgAAAAAAAAA4L8qHNiIjY3V5ZdfXh1zAT02UB0K86X0vyW5bxwuSVZ6bAAAAAAAAACoISoc2JgzZ051zOM0RcYGfCB9n/295a6/hiQZ9NgAAAAAAAAAUEN43GPDarXqmWee0T/+8Q+dddZZuv/++5WdnV2dc6v9SpaispKxgWpQTuNwqUTGBu9DAAAAAAAAAH7M48DGU089pX/961+KiopSkyZN9PLLL2vSpEnVObfTDxkbqA6OgY1SSlEZFseMDUpRAQAAAAAAAPBfHgc25s2bp9dff12LFi3SggUL9NVXX+mDDz6Q1cof4yuvZCkqvimPauBBxoYsFqkoa4NSVAAAAAAAAAD8mMeBjeTkZF100UX2x4MHD5bFYtGBAweqZWKnpaoEiUqWtQIkzV+TrOTdf9oflxrYkKTAYNu/hQQ2AAAAAAAAAPgvjwMbBQUFCgsLc9oWHBys/HzK1lSaSzCiCsGJWhjYmL8m2ewp1ApRWX9LsvXRyAqLL31gUQNxMjYAAAAAAAAA+LGg8ofYGIah66+/XqGhofZtOTk5uvXWWxUZGWnf9sUXX3h3hrWaF4MR9OeAO4ahqKx9kqSssHgZAcGlj7UHNghWAgAAAAAAAPBfHgc2xo8f77Lt2muv9epkTntVyroo2a/DsPVN8HPz1yTr6sTmZk+jVpq/Jlkh+RkKKciUJJ2IaFb2DmRsAAAAAAAAAKgBPA5szJkzpzrncXryaikqq+vjombQtRRBkfJFZf9tv19mfw2pOLBBjw0AAIBTal+5VwAAAKA28LjHBnygKhkbJfethT03UHFFZagkKTO8nMBGUfNwMjYAAAAAAAAA+DECG6aqxowNvl0GFTcOlzzJ2DiV4UOPDQAAAAAAAAB+zONSVKgGXs2yKHksmomfruavSbbfr1gpKjI2AAAAAAAAAPg/Mjb8ijd7bJCxgYpmbBQ1Dy+sxhkBAAAAAAAAQNUQ2DCVF4MP3mxEjlqjKLCRF1RH+cExZQ8OLGoeTikqAAAAAAAAAP6LwIaZvFmKiowNlGCx5isiJ0WSB9kakkPGBqWoAAAAAAAAAPgvAht+hR4bVTV/TbJTjwnH7aebyOwUBRi2slKeBTZO9dgwCgmMAQAAAAAAAPBbBDZM5c2MDUpRwVlU9j77/czwCmRsSGRtAAAAAAAAAPBbBDb8CqWo4D2OjcNPRDQrf4dAh8AGfTYAAAAAAAAA+CkCG2byao8NMjbgzDGwUaEeGxIZGwAAAAAAAAD8FoENU3kx+OCSsXF69thAsahsAhsAAAAAAAAAah8CG37Fm83DydgoS2lNxmuT6MwkSZLVEqissPjydyhqHi4R2AAAAAAAAADgtwhsmMmrpajI0ECxoPxMxWTuliSl1WkvwzFoUZqAwOL79NgAAAAAAAAA4KcIbPgVL/bYIGPjtFY/Y4ssp95PR2K7e7ZTIBkbAAAAAAAAAPwfgQ1/UqVKVPTYQLH6ab/b7x+N6ebZTvTYAAAAAAAAAFADENgwk0tWhRd7bHizMTlqnAYOgQ2PMzbosQEAAOCMLGgAAADALxHY8Cfe7LHBIuz0ZRiqn7ZZkpQXVEcnIlt4tp9jjw0CGwAAAAAAAAD8FIENU3kx+ODSY4NSVKeryOwDCs87KulUtobFw//mjj02aB4OAAAAAAAAwE8R2DCTN0tRuQQyyNiojPlrks2eQpXVT99sv3801sP+GlKJHhuFXpwRAACA9/z444+65JJLlJCQIIvFogULFjg9bxiGHnnkETVu3Fjh4eEaPHiwdu7cac5kAQAAAFQLAhv+xJvloyhFddpqUJnG4VKJwAYZGwAAwD+dPHlSPXr00KxZs9w+/+yzz+qVV17Rm2++qTVr1igyMlJDhw5VTk6Oj2cKAAAAoLoElT8E1YeMDXhf/co0DpdKBDbosQEAAPzTsGHDNGzYMLfPGYahl156SQ899JBGjhwpSZo3b57i4uK0YMECjRkzxu1+ubm5ys3NtT/OyMjw/sQBAAAAeA0ZG/6kSs3D6bEBSQV5qpexVZJ0IqK58kJiPd+XHhsAAKCGS0pKUkpKigYPHmzfFhMTo8TERK1evbrU/WbMmKGYmBj7rVmzZr6YLgAAAIBKIrBhpurssUEpKp/zi/4cqZsVaM2TJB2pSH8NiR4bAACgxktJSZEkxcXFOW2Pi4uzP+fOAw88oPT0dPtt37591TpPAAAAAFVDYMNU3gw+eDFIglL5RfCiLH+vt989WpEyVJIUEFh8nx4bAADgNBIaGqro6GinGwAAAAD/RWDDn1SpFBUZG5C0f5397pGYigY2HEpR0WMDAADUQPHx8ZKk1NRUp+2pqan25wAAAADUfAQ2zFStpajosVHdysreMC2z4++1kqTCgBClRXeo2L40DwcAADVcq1atFB8fr6VLl9q3ZWRkaM2aNerbt6+JMwMAAADgTUHlD0H1Kdnw24vNw3H6yTomHftLknQsupOsjhkYnnBqHk5gAwAA+KfMzEzt2rXL/jgpKUkbN25UvXr11Lx5c02ZMkVPPvmk2rVrp1atWunhhx9WQkKCRo0aZd6kAQAAAHgVgQ2/QikqVMF+x/4aFWwcLpXosUFgAwAA+Kd169Zp4MCB9sdTp06VJI0fP15z587Vfffdp5MnT+rmm29WWlqa+vXrp4ULFyosLMysKQMAAADwMgIbZioZfKhSMILm4d5WVE7q6sTmJs/EQ6fKUEnSkdgeFd/fqccGzcMBAIB/GjBggIwyPjdbLBY9/vjjevzxx304KwAAAAC+RI8Nv0KPDVTB38WNw4/GVCZjgx4bAAAAAAAAAPwfgQ1TeTGrwiVhg4yN00phvrRvjSQpO7SBToYnVPwY9NgAAAAAAAAAUAMQ2DCTN0tRuWRoENioCYrKXVXZgd+kvExJUmq9sySLpeLHoMcGAABACXymBgAAAPwRgQ2/4sUeG5Si8mteC2gUSVphv5tS/+zKHYMeGwAAAAAAAABqAAIbpqrGjA1KUfkFrwcwSpP0o/1uav0+lTsGPTYAAAAAAAAA1AAENvxKVQIbLk02qjQT1BwBhblSsq2/hmKb62RE08odiB4bAAAAAAAAAGoAAhtmcumxUZVjkbFxumqQtkkqzLU9aHVe5Q9Ejw0AAAAAAAAANQCBDVN5M/hAj43TVfzRNcUPWvWv/IEoRQUAAAAAAACgBiCw4Ve82GODUlSnjTjHwEbLcyt/IJqHAwAAAAAAAKgBCGyYyaUUlRd7bFCK6vSQe0L10/+w3W/QXopuXPljOWVsFFZtXgAAAAAAAABQTQhsmMqLDb/J2PB789cke2WMk72rFWCcCkJUpb+GJAU6BDYKydgAAAAAAAAA4J8IbPiTKmVZkLFxWkpaUXy/qoENemwAAAAAAAAAqAEIbJjJJfbgxYwNAhunh6Qfi++3PLfiGR+O6LEBAAAAAAAAoAbwi8DGrFmz1LJlS4WFhSkxMVG//vqrR/t99NFHslgsGjVqVPVO0Feq1GOj3A2o4VyCFlnHpJTNtvvx3aSIelU7AT02AAAAAAAAANQApgc2Pv74Y02dOlXTp0/Xhg0b1KNHDw0dOlSHDh0qc789e/bonnvu0bnnnuujmVYHLwYfyNg4/ez5Sfb3UKv+VT8ePTYAAAAAAAAA1ACmBzZeeOEF3XTTTZowYYI6d+6sN998UxEREZo9e3ap+xQWFuqaa67RY489ptatW5d5/NzcXGVkZDjd/IZL8MGbpahKNhNHbTB/TbI9c2PHL98UP+GNwAY9NgAAAAAAAADUAKYGNvLy8rR+/XoNHjzYvi0gIECDBw/W6tWrS93v8ccfV6NGjTRx4sRyzzFjxgzFxMTYb82aNfPK3KuFN5uHVyRI8uNMnbf+dulYUhXOD29yLDvltm+GYajx4Z8kSVZLkNSib9X6a0glemwQ2AAAAAAAAADgn0wNbBw5ckSFhYWKi4tz2h4XF6eUlBS3+/z0009699139fbbb3t0jgceeEDp6en22759+6o8b++pzowND4+Vsln64Uk1PbRc+uS6yp8fvnV4u+pk/y1JOlT3TCm0TpUP+flGh/9zBDYAAAAAAAAA+Kmg8of4jxMnTui6667T22+/rQYNGni0T2hoqEJDQ6t5Zl5SpebhlQySHNlZfL+oETX8347v7Hf3NxqgeC8c0moJdHhAYAMAAAAAAACAfzI1sNGgQQMFBgYqNTXVaXtqaqri413/VLt7927t2bNHl1xyiX2b1WrLVAgKCtL27dvVpk2b6p20N/lDjw2LpfLnhFfMX5OsqxObV2yn7Qvtd/c3GqBeXpiH1ULzcAAAACdVKhULAAAAoLqYWooqJCREvXr10tKlS+3brFarli5dqr59+7qM79ixozZv3qyNGzfabyNGjNDAgQO1ceNG/+6f4ZY3F0oljuXpIsxiev94lKK0nhmhucekfWskSemRrZUZ6Z33veEY2LAWeuWYAAAAAAAAAOBtppeimjp1qsaPH6/evXurT58+eumll3Ty5ElNmDBBkjRu3Dg1adJEM2bMUFhYmLp27eq0f2xsrCS5bK+RqlSKqmSGhqfHImOjpkk4vFJFP9/9jfpLKj0IUhHWAMfABhkbAAAAAAAAAPyT6YGN0aNH6/Dhw3rkkUeUkpKinj17auHChfaG4snJyQoIqKVZBV4tRVUyY8PTUlS19NrWYk0OrbDf399ogPcObAmQLdBl0GMDAAAAAAAAgN8yPbAhSZMnT9bkyZPdPrd8+fIy9507d673J+QzlSwf5fZQJXtseFqKioyNmqAoIyOgME+Nj/wsScoJjtWRuj28e6LAYKkwjx4bAAAAAAAAAPwWX9f3K9XYc6M0ZGzUKI2OrVNwYZYk6UCj82RYAr17gqBw278FOd49LgAAAAAAAAB4CX/VNpNL+ShvZmx4uiMZGzVJk8PL7ff3N+zv/ROE1rH9m3vC+8cGAAAAAAAAAC8gsFFb0GOj9jMMNU1dbrsfEKyDDc7x/jkIbAAAAAAAAADwc/xV21ReLD3lEsigx0ZtE3tihyJzDtoetOynguAo75+kKLCRlylZC71/fAAAAAAAAACoIgIbZvJmKapKNyInsFFTND20rPhBh4uq5yRFgQ3JFtwAAAAAAAAAAD9DYMOveLHHhqfH8rRkFcxlWNX67wW2u7JIHYZVz3kcAxs5GdVzDgAAAAAAAACoAgIbpvJm8/BK9tggsFEjxB1do6js/ZKklAZ9pdhm1XMix8AGfTYAAAAAAAAA+CECG37FixkbngZJDPoo1ARt931uv7+r6eXVd6LQ6OL7BDYAAAAAAAAA+CECG2byZo8NSlHVWqG5x9Q0dakkKSeknvbHDazGk5GxAQAAAAAAAMC/EdgwVVWahZdzLE+DJFYyNvxdqwNfKdAokCT91WSkrAHB1Xcyp8AGPTYAAAAAAAAA+B8CG37Fm6WoPO2xQWDDrxmG2uz7zP5wd7PLqvd8ZGwAAAAAAAAA8HMENszk1VJUJff1tBSVN7NG4HXJqxVzco8kKbVeb52IbFm95yOwAQAA4IDPygAAAIA/IrBhqkoGI9weilJUtdL69+x3d1dn0/AiNA8HAAAAAAAA4OcIbPiTKmVPlAxseFqKqoLNwwtydc7G+6SPruEP39UsOD9d+nOBJCk3OFrJ8RdU/0nDCGwAAAAAAAAA8G8ENsxU2fJRbo9VwQCFfb8KZmzsXKyWB7+Ttn0tbf26cueER9olfyIV5EiS9iRcLGtgaPWflObhAAAAAAAAAPwcgQ1/4s0eG54eq6IBkZw09/fhVYEFWeqY9B9JklUB2t7iGt+cmB4bAAAAAAAAAPwcgY3awiVAUU09NqwF7u/Dq9ru+1xh+cclScmNhyozsrlvTkxgAwAAAAAAAICfI7BhJm+WovJVj43CfPf34T0FueqUNNf+cEubm3x37pCo4vsENgAAAAAAAAD4IQIb/qRKpahKBCgqW4qqvP0cMzwqmu0Bz2ycr4jcQ7b7HYYrvU473507ILA4uEFgAwAAAAAAAIAfIrBhKm82D6/ksVwCG+VkcFCKqlpZrAXSzy8Vbzjvbt9PoqgcFc3DAQAAAAAAAPghAhv+xIyMjZJZF+UFK6z57u/DK1oc/E46vkeSdLB+X6lJL99Pwh7YIGMDAAAAAAAAgP8hsGEmf+yxUW5gg4yNalOYry6737I/9GlvDUeOgQ1rBXuwAAAAAAAAAEA1I7BhqqoEMkoequQfoD0tRVUyY6Ocvhn02Kg+6+Yo5uQeSdKhumfqUL3e5syjKLAhQ8o/ac4cAAAAAAAAAKAUBDb8SZVKUVXyWBXN2CjMd38fVZN9XFo+w/7wt473SBaLOXOxBzZEOSoAAAAAAAAAfofAhpmqEshwOVYlMzZcemyUl7FBKapq8eNzUvYx2/1uV+lobDfz5hIaXXyfwAYAAAAAAAAAP0Ngw1Ql+2KY0WOjxH702PC5qJPJ0pr/kyQVBIRKgx4xd0JkbAAAAAAAAADwYwQ2/EpVSlGVCGR4XIqqZMYGgQ1fO2P7C5LVVtZrW6vxUmwzcyfkFNjIMG8eAAAAAAAAAOAGgQ0zlQw+VKnHRmWbh1ewxwaBDa9qeGy9mqUutT2IitOfrSeaOyGJjA0AAIAi3iwdCwAAAMBrCGz4laoENioZJKHHhqm67Xy9+MHAB1UQFGHeZIoQ2AAAAAAAAADgxwhsmKoam4d7XIqqChkbhfmenQPu7flZ8cd+td2v11rqeY258ylC83AAAAAAAAAAfozAhpm8WYrKJUhSTT02Ch0zNsrJ7kDZVjxdfP+8e6XAIPPm4ojABgAAAAAAAAA/RmDDr5jRPJweG2ZoeGyDlPSjJOlERDOp21Umz8gBzcMBAAAAAAAA+DECG6byZvPwkscq2Uy8FNaSgY2K9NigFFVldd31hv3+H21u9p9sDYkeGwAAAAAAAAD8GoENM7kEMryYsVFdpajI2Ki65F/U+OgvkqQT4U21J+FikydUbP6aZAIbAAAAAAAAAPwagQ1/UqUeG5U8VpWahxPYqDDDkJY9ZX+4pc3NMgL8KFtDcg5s5FCKCgAAAAAAAIB/IbBhKm8GMiqZsVGy9BQZG9Vr+3f23hqKbaGkJv6TrWFHxgYAAAAAAAAAP0Zgw6+Y0GOjohkbhQ59NQhsVEhAYZ70/YPFGy54XEZAsHkTKk1gsBQUbrtPYAMAAAAAAACAnyGwYSaXYIQXe2x4XIqqZMZGec3DHZ6neXiFtN87Xzr2lyTpUN0zpc4jTZ5RGYqyNghsAAAAAAAAAPAzBDZM5cXm4ZU9VlV6bJQXBEGxzMPquvv/Tj2waH2n+yWLxdQplcke2KDHBgAAAAAAAAD/QmDDn5iRsWGtaGCDUlSVsuxJhRRk2u6fca2Ox3Qydz7lcczY8GZTewAAAAAAAACoIgIbZnL5g3EN6LHh+Hwhpag8sm+ttGGe7X5IHWnQI+bOxxNFgQ2jUMrPNncuAAAAAAAAAOCAwIY/8WbGhselqKrSY4NSVOUJKMyV/ntb8c+n/71SVCNzJ+WJ0Oji+/TZAAAAAAAAAOBHCGyYypslfkpmbHi6WwUzNgopRVUR3XfOko7skCQdjekinT3J5Bl5qChjQyKwAQAAAAAAAMCvENgwk0vwwZs9NjwsRVUy66JCzcMpRVWmfWvVMek92/3AEP3S7UkpMMjcOXnKKbBBA3EAAHC6otcYAAAA4I8IbPiTqqybKtuvoyo9NsjYKFVRCaoAnbq+A+5Xep225k6qIsjYAAAANdSjjz4qi8XidOvYsaPZ0wIAAADgRTXk6+O1VXU2D/dFYIMeG6Xp/NdsewkqJZwhnXOntO6AuZOqiDB6bAAAgJqrS5cuWrJkif1xUBDLHgAAAKA24RO+mSobjHB7rMo2Dy8Z2CivebhDYKOQUlRupf9tC2xIsloCFTDy9ZpTgqoIGRsAAKAGCwoKUnx8vMfjc3NzlZuba3+ckUEpTgAAAMCfUYrKr1SpFlWJh77osVGFUlTWQunP/6nhsQ2lPl8/7XepINf98/5syWMKsuZIknY2HyPFdTZ5QpUQSsYGAACouXbu3KmEhAS1bt1a11xzjZKTk8scP2PGDMXExNhvzZo189FMAQAAAFQGgQ1TebEZoUvz8GoqRVXopcDG1v9Jn1ynQWsmSMf+cn3+23s0dPU10kfXVP4cZti3Vtr8ie1+eF1tbvtPc+dTWU4ZG+nmzQMAAKCCEhMTNXfuXC1cuFBvvPGGkpKSdO655+rEidK/rPHAAw8oPT3dftu3b58PZwwAAACgompYfZxarkqlqCrbPLwKGRsybJkXAYGenctR6hZJsjXXTvlDqtfa+fmklaf+XVHxY5vFsEoLpxU/Hvig8owY8+ZTFZSiAgAANdSwYcPs97t3767ExES1aNFCn3zyiSZOnOh2n9DQUIWGhvpqigAAAACqiIwNM1U2GOH2WN7K2KhAjw13j4sc36uEQz+W3ofDscRUXmbpzxfm1ZheHi0OfiftXy9JSotqK/WaYPKMKmf+mmQCGwAAoNaIjY1V+/bttWvXLrOnAgAAAMBLCGyYyovNw33WY6NEkMHd+Pxs6a3+GrB+kvTrW+6PU5hXfD/XXWAjp/h+3smy5+Qn2iV/Yr+/odO9Na9huCMCGwAAoJbIzMzU7t271bhxY7OnAgAAAMBLCGz4FS9mbHhciqrEuLICG1ar63ncZVPs+1XKPm67v+hf7o/lmLGRm1H28zUhsHF8jxodP9UIvWEnpdTva+58qorm4QAAoIa65557tGLFCu3Zs0erVq3SpZdeqsDAQI0dO9bsqQEAAADwkhr8lfJaoGRQwZs9NjwuRVWBjI2SYyX3patCIss/r2PGhrtSVIU1LLCx+dPi+92vkiwW8+biDWRsAACAGurvv//W2LFjdfToUTVs2FD9+vXTL7/8ooYNG5o9NQAAAABeQmDDr5iRsVGyN0cZJazcBT3cbfMkqOKUsVEisGEYzqWo8v08sGEY0u/FZajU7Uppe1XKivmBoFApMMQWgHKXUQMAAOCnPvroI7OnAAAAAKCaUYrKVN7843clMzYq0mPDXdmpkj03JOdsjFKP5RjYKJERUHJ/f8/YOLhROrLDdr9FPym2manT8ZqirA0yNgAAAAAAAAD4Eb8IbMyaNUstW7ZUWFiYEhMT9euvv5Y69u2339a5556runXrqm7duho8eHCZ4/1aTStF5WnGhmPQQiqlOXgZpagcszUk/w9sOGZrdL/SvHl4G4ENAAAAAAAAAH7I9MDGxx9/rKlTp2r69OnasGGDevTooaFDh+rQoUNuxy9fvlxjx47VsmXLtHr1ajVr1kxDhgzR/v37fTzz6uDFwEZlS1GVGdjwsMdGQYmMi5NufpZlZWyU3N9dDw5/UVggbf7MdtcSLHUeafKEvIjABgAAAAAAAAA/ZHpg44UXXtBNN92kCRMmqHPnznrzzTcVERGh2bNnux3/wQcf6LbbblPPnj3VsWNHvfPOO7JarVq6dKnb8bm5ucrIyHC6+Q9vZmyU7JXhaSmqigQ23JWd8qAUVeZh1zGOwQuXwEYNythIWm4P3Oxv1F8Kr2vufLwpNNr2b2Gec08UAAAAAAAAADCRqYGNvLw8rV+/XoMHD7ZvCwgI0ODBg7V69WqPjpGVlaX8/HzVq1fP7fMzZsxQTEyM/dasmR/1P6hsloX7g5V4WEYT8LLGucvAsD/naSmqCmZsuJSiKvFH9Lys0udkojqZSdK399of70m42MTZeNf8NcnFGRsSWRsAAOD0VJUvHgEAAACoNqYGNo4cOaLCwkLFxcU5bY+Li1NKSopHx5g2bZoSEhKcgiOOHnjgAaWnp9tv+/btq/K8q403MzY8LkVVDT02SgYmMlPdjHHM2Civx4YflqL6a4WGrr5GOvaX7XHdVjrQ8Fxz5+RtToENf8p0AgAAAAAAAHA6CzJ7AlXx9NNP66OPPtLy5csVFhbmdkxoaKhCQ0N9PDNPefEbYJVuHl6BUlSFlczYcFeKqsweGyUzNvysFNX696Rvpiqk6LU36iJd/bGs22vZN/rI2AAAAAAAAADgh0wNbDRo0ECBgYFKTXX+Rn9qaqri4+PL3Pe5557T008/rSVLlqh79+7VOU0f8maPDQ9LUZUsPeWNjA1PSlEVlChFZRiSxXJqfz8NbFgL1XPb81LS3OJt7YZKV7x7KgiQ7LOpzF/jg3MV9diQpBwyNgAAAAAAAAD4B1NLUYWEhKhXr15Ojb+LGoH37du31P2effZZPfHEE1q4cKF69+7ti6lWj8pmWbg9VmVLUfmgx0amux4bjmMM5+CFPzYPz82UPr5WnR2CGttaXieN/dA5s6E2IWMDAAAAAAAAgB8yvRTV1KlTNX78ePXu3Vt9+vTRSy+9pJMnT2rChAmSpHHjxqlJkyaaMWOGJOmZZ57RI488ovnz56tly5b2XhxRUVGKiooy7XVUjjdLF1W2FFVFMjbyXbcVutnm0mOjnIwNyfaH89Ao98+Z3WMjfb/04WgpZbPtsSVQumimNlgvUMeAQHPnVp0cMzYIbAAAAAAAAADwE6YHNkaPHq3Dhw/rkUceUUpKinr27KmFCxfaG4onJycrIKA4seSNN95QXl6errjiCqfjTJ8+XY8++qgvp+59pmRslBhXZmDDTTaHu22elKIqOcYxeFEyYyM/q/Q5VbN66Vukt6dImbYAWl5QHYWMnSe1OV/yRTkoM9E8HAAAAAAAAIAfMj2wIUmTJ0/W5MmT3T63fPlyp8d79uyp/gn5iksgoyqBjZIZG37UY8Nd83B3GRulPWdGKSqrVe33fKCe21+SrKcCLXVb6vuuL+viNgN8Px8zUIoKAAAAAAAAgB/yi8AGTqlSxkZlS1FVoMeGu7JT7spTFZQIbOSftAUnQiJP7WN13a/MwIaPS1Ed3S39d5J6J68u3ta8rzT6A2X84Qf9PnyFwAYAAAAAAAAAP2Rq83BUY48Nj0tRVUfGRq7rNsc+GyUzOqQSpagqmbGRm6nGh39SUEHlS1clHPpRevNcyTGocdaN0rj/SpH1K33cGonABgAAAAAAAAA/RGDDTF4tRVUi88LTQ7lkbFRDjw2pRGDDTeAjt4weG46BjaO7pXmjpCWPul6/zyZo4Lp/6uzfH3Q9vic2zNN5G+6wZZhIOhHeVEv6vCsNf14KCq3cMWsymocDAAAAAAAA8EOUovInXi1FVR09NtyUnXJXnqpkKSpJyj5e9vOOzaldMjYcMjBWPCP9tUz6a5nie3eU1KL4ub22LIvGR362XQ+LxfU87qTvl1Y+L617tzjS13mkvm3yLxUGRXh2jNqIjA0AAAAAAAAAfoiMDb/ixYwNj0tRlRhXWE2lqAqyy37esRRVyefzMovn+fvH9s3NU793OH6elGf743twYbZzhkgpgvPTpa/ulF7uIa17t/iJs2+Trph7egc1pBKBjYzSxwEAAAAAAACADxHYMFNlG367P1jljuXSY8NNBob9OU8DG26Oke9QXqpkRoZUdikqo7B4nwYd7JvrpW0pHpOT5rzPsb9cz+EgqOCkzl97q7R+bvFrDgrX+k7TpAtnSAH811BwuGQJtN0nYwMAAAAAAACAn+Cvt37FjIyNEvu5649hf87DwIa7wIVTxoa7UlQOfzh3t39Rn42oRvZN9U5sKw6iZB1zHl9WYKMgV+dtuFP10/+wPQ6pI/WbKk3ZrO0try19v9ONxVKctUFgAwAAAAAAAICfILBhqqpkaJQ8lJd6bLjLtrCP9TRjw03goryMjbwyMjYcn3dsJC5J+zfY/s0uEdg4nuR6DEmyWqXPJyr+6Brb47BYaeL30uDpUlRD9/uYaP6aZFPPnWk5VY6LwAYAAAAAAAAAP0Fgw59UqXl4iUCGx6WoKpCxUZXARlUzNvJPNRB3DIBI0p6Vtn89zdhY8Yy09SvbaQLDpWs+leI6ux8L5QdF2u4Q2AAAAAAAAADgJwhsmMkl+ODFHhsel6IqmbFRVmDDTTaHuwwPt4GJ8npseFiKqmTGRlFgI/u483Z3gY3tC6UVT0uSrArQyjNekJr1cR0Hu/ygKNudguyys3kAAABqJS9mWAMAAADwGgIbpvJi83CXjA0PS1GVHFdQVmCj0LNtboMdjhkb5ZWiKuP5khkbyWts40uWojr6l9P1jM3YLn1xs/3xpvZ36GDDfq7n8QNmlp8qqaAoY0MiawMAAAAAAACAXwgyewJwVIXARsnG3p4ESaxugh8VLkXlLoujvIwNd6WoyuuxcdL2mnJLBDYKsqX9611LUeWm27I4DKu0fIYuXDenODul0yXa2uIG13PARV5QneIHuRlSRD3zJgMAAAAAAAAAIrBhLpeG31UIbLgEGDw4VskyVEXbrIVSQKDrc+4yMdwFO9xlXJSXseFJKaqCXPdzPrTVNWNDkg5ukr65Wzq2uzg1qVEXaeTr0qY01/FwkU/GBgAAAAAAAAA/Qykqv1KVjI0SQQdPgiSllasqrZeCx83D3exfXsZGnsMfzUsrVeXUX8NSfDcz1bXHhiT99IJ0bLft9IHh0sCHpBuXSGHRrmPhlr3HhkRgAwAAAAAAAIBfIGPDVF5sRlgywOBJjw13/TEkWzmq4DDPxpcsgSXZAxMFAWEKsp4KaDiWl3KbsZFpC8ZYLKVkbGQ5Bz/qt5WO7rTdP3FQynIT2Ej60X532VlvaUj/Ea5j/IQ/9dVwRI8NAAAAAAAAAP6GjA0zebUUlZsAQ7nnr6aMjVMZGXnBDv0Z8h1KUbkLXBiFxWNK67HhmLHRoF3x/ROp7ktRFanfVkdie5T+PEqVE+LQU+PARtPmAQAAAAAAAABFCGz4FV+XoiojY8Mdd43C3Zaisu2f79h42iljo5Tj551qDO42Y6NEKarY5rJaTiUcnThobx6eGxzjum+PMbZMEFTYgYbnySgq+7Xpw6oF3wAAAAAAAADACwhsmKpkxkYVDuUSYKhKj43SAhvuMjbcBFSKSlEFRcjeC8MxY8Ph+AWB4cXbi0odlZax4VgKKbSOskPr2+6fOGjvsZEVFqes0EbO+3a7yv3rQbmywuOVWr+P7cHxJGnfGnMnBAAAAAAAAOC0R2DDTC7ffvdmxoYnPTYqWorKTYZHyW0OwY/CgBAp+FTgosB983CnUke5GU7PWx3fniVLUYVEKbsogHHysD2YkhscqxORzYvHtegn1W3h/vXAI381GVn8YON88yYCAAAAAAAAACKw4V+q1GOjMqWoKpix4S7gUTKLw6GMlDUgWAo61YQ8P8vhOMVjckPqFm8vkbGR51hWKr9kYCNS2WENXaaTFxyjExEOgY0eY9y/Fnjs77hByi/KrNmywDn7BgAAAAAAAAB8jMCGqbzUr8AwKlmKqqI9Ntz10ygR7HDY1yljI98xY6M4sJFTMrDhUMoqNyS2+Lm8k8U9OKRTGRuugY3ckBglNRkhBUdKcV2lrpe5fy3wWEFQhPbFX2B7kJsubf/W3AkBAAAAAAAAOK0R2PArlQx0uCsRVaWMjdJKUbnrsVFim0Ngwyljo8B9jw2nUlQ5GU5BjzIDG6EOpagc5AXH6nC9XtJ9f0m3/iSFRLp/LagQ53JUH5o3EQAAAAAAAACnPQIbZioZfKhsKaqSZagkD3tseCFjo+QxnEpRlZ+xkevUY+OEUy+OwsDw4sCIS48N96Wo7MGQ4DDJYnH/OlBhh+r11smwxrYHu5dKJ1LNnRAAAAAAAACA0xaBDVN5qXm42wyLauix4TawUU4pqqLARGFucbNyhzHOPTbS3ZSyirA9yMuUcssvRZUXHO1+7n5i/ppkt/f9niVASU0utt03rNLmT8ydDwAAAAAAAIDTFoENf1LpjA03AQePSlGVlrHhpVJUluDijA2pOBvDqcdGGRkbAaFSSJTtQV6WZz02gmPdz92P1KiAhoOkJiOKH2z8sGrN7gEAAAAAAACgkghsmMnlD8NezNjwpBRVaX+YLi1jw915SgY2nEpROfTYkIqDFqVmbJxw2r8wMLS4R0ZepptSVK49Npz6csCrTkS21JHY7rYHh7ZIKZvNnRAAAEB144scAAAAgF8isOFPvJmx4UmQpMI9NtyMLyw9Y8NWSsohsJF/qoG4Y8ZGaP3i53MynDI2rAHBUljMqX2zpKwjxWNDomzZGQHBTqfPC45xP3d4hVMT8U00EQcAAAAAAADgewQ2TOWlb4C5bR5elR4bXipFFRAsBbkpRVXoWIqqZMaGY2AkVIpyyMo4tqf4fmiUrTl4ncZOp88lsFGtkuOHqtByKpi06SMpJ93cCQEAAAAAAAA47RDYMJPXSlG5y9jw5PwVzdjwpBSVY2CjtIyNskpRleixUSe++Pn0fbZ/A4KkwBDbfcfnRcZGdcsLiVFy4yG2B9nHpB9nmjshAAAAAAAAAKcdAhv+pNKlqCrbY6N4TEGAQwCiIqWoSp7bqRRVORkblgAVBoZLgaG2x7kZJQIbIc4ZG0WBn5BIW7aG5BzYCI2RERDkfu4mmr8mucY2DHfn93a32342kvTLm9LR3eZOCAAAAAAAAMBphcCGX/Fm8/CK9dgoLMqAkMoIbDhkZxSNLxnsKHRsHl5OxkZRQCMs2vZvboZr8/Ao54wMSVJIVPF9x8BGeKz7eftYbQpiuHMyoom2trre9sCaLy160NT5AAAAAAAAADi9ENgwU8ngg6+bhztkbBR6krHhGEAJCnN/7oIK9NgoCo6E1rH969I8PMSl1JSk0gMbEfXcz9sktTnA8WfricoKPZVNs+M7adfSWv16AQAAAAAAAPgPAht+xYuBjQo2D7eXFpJKD2zknZQkFQSGS4GnGkiXzBZxLEVlCS47YyOoRGAj94RzxoZLKapTQiKL7zs2Dw83P7BxuvxxvyAoQhs7TCnesOhfsrgNsAEAAAAAAACAdxHYMFUlAxkluS1FVbEeG4WBjhkbbo4n2QIPkvKDIovLSDlkWNj2LVmKKqL4OZeMjVPHCD1VisoolHLSig8VUFopKsfAhv9mbNR2exKG60hMd9uDw9vUbt8n5k4IAAAAAAAAwGmBwIY/8WbzcE+CJo49NjzJ2MjNkCTlBUUV97PITnMe41SKKqS4ZJXkkLFxKrBhz9iILh6Tech5/8gGkqXE27Qow0OSGnSQLIHF932stjUGrxBLgNZ3nmZ/2G3nLCnrmIkTAgAAAAAAAHA6ILBhJpdARmWbh1e2FJVj8/ByMjasVnvGRkFQlBRe17a9IFvKd8jacCxFFRAsBTv02CgKbBSW0jxckk4edtg/RAoIlCIbOs/FMWMjpol01Txp4INS4s3uX2c1KBnMOF2DG0dju0vdx0iSQvMzpO8fqnyADgAAAAAAAAA8QGDDVP7UPLycjI28TPsx84KipLDY4uccykc57uuSsVFQWsaGQwZG1tHiQxUFPkr22XAMbEhSp4ul/vdJYTGu80a1+7L+jcoPPBXA2viBtPYdcycEAAAAAAAAoFYjsFEbuCtF5UmPDWtpGRtuAhunsjUkKd8xY0OSso8X33dq/l0yYyPHds6iTBF7jw2HwIZDKSp7sKVkn42QKPevpxo5ZmScrtkZpckOi9PaLg8Xb/humvTXCvMmBAAAAAAAAKBWI7BhppIZGpXN2HDbPLyiGRuhZR/PJbARW/ycY58Np4yNYNeMDYfAh4JKNA+XnEpRWYvmFBXnPBcfBzYIZJRvT5NL9GerCbYHRqH06Xjp2F/mTgoAAAAAAABArURgw1Re6rHhjVJUgY6BDXcZGxn2u66BDYeMjZKlqEpmbBQ6BDYC3ZSicuyxUTSnOiUDGyVKUfkIAY6ybepwp/Y3PM/2IPu4NH+MlJNR9k4AAAAAAAAAUEEENmoDtxkbHpSiKjVjo5zARnAZpagcAxsWdxkbDsd2l7GRn+Uwp2DbnZKlqEK9n7FBM/CqMyyB+rnHM0qPbG3bcGS79PmNTiXPAAAAAAAAAKCqCGyYyVulqNxlbHhyKKceG+WUosopkbFRWvNwh8BFoacZG2EOgQ3H6QWU1jy8ektREdSovILgKK3o9Wrx+2PnIunrKVKhu6wiAAAAAAAAAKg4Aht+pbKBDTeBiIqWoio3Y8PD5uEOgQtrQIiHGRsOpagc2OdUp2Tz8MqVoioKWNAIvHplRjbX0u7PSZZA24YN86SPr5XyssreEQAAAAAAAAA8QGDDVN5qHu4uY8OTwIZDxkZFSlEFRXpWiiog2MMeG+4zNgoDTj1fzRkbBDe8L7V+onT52yq0BNk27PhOeu8S6eRRcycGAAAAAAAAoMYjsGEml+CDFzM2Ktpjo7xSVC4ZG7HFz2WnFd93KkVVssdGjlTgENgoL2OjaE5RJZuHV08pKgIc3jX/5Flaftabygs69fPav0569wLpWJK5EwMAAAAAAABQoxHY8CeVzthwF9jwoGGzQ48Na0CIJMup47nJ2CjZY6Mypajys52PHVh2YMNalLEREimFOIypQCkqghXmSq2fqCWJc4sbwB/bLb07REpeY+q8AAAAAAAAANRcBDZMVclARklWN0EMxyyK0jhkT1gtQcWloTzpsREaI3sgxCmwURxksQYESwEBxQEMl4yNskpRWWxzKlLHIWvDTWDD0wAGgQ7fS4vuoAW931N6ZGvbhpOHpNlDpYX/0sertps7OQAAAAAAAAA1DoENv+LFUlTZx8rPAMlMKR4e2sAhsOGuFFW6/W5eUJQtYBEWY9uQk+ZwzEO2fwOCi3tkBJ/K2igtYyMwSAqOcD5fZAPJYil+HOXQQLyUDA9H89ckE8TwI1nhCVp89jyp+TmnthjSL7N00crLpKQfTZ0bAAAAAAAAgJqFwIaZSgYevFGKynLqR2otcMqycCvjoP1udlgjKTD41PE8yNiQistRFWVsZKdJR059Az++W/Fcgk41EC/Ice6vEOaQqVEyWHHmeOfHvcbbAi9dLnXq70EAo+bIC4nRh51mSYMfswe16mT/bWsq/tWdUk56OUcAAAAAAAAAAAIbJquG5uGRjYrvO5aIcueEQ2AjtFHZGRv2HhsWFQSdyq4oCjBkp0lWq3RgQ/H4pmcV33fM2Nj2VfH21gMc5ppWfD+kjtR3kvP5u18l3Z8sXTm3zJfkDoEP/2EEBGl+8GX66h+fSc37Fj+xfq5yn++mjfMfKT8gBwAAAAAAAOC0RmDDn1Q6Y6Og+H5Uw+L72cfK3s8e2LAoO7R+cWDDsQ9GkaI/NofWKc7EsDcQN6TcDOnvdcXjHQMbRRkb2ceKyw7VbSU16uzwGhzOmXiLFFHP6fTz1yRr/obDZQYpCGDUHCciW0rXf6u1nf+l/EDb+yM0P109d7wsvdRN+vE5p4b1AAAAAAAAAFCEwIaZXAIZlc3YcAxsODTZziovsHGqx0ZkQxkBweWUojr1R2bHRt9hscX3s49Lf68tfty0V/H9+m1cj9fpYqceGrubjDx1zBh9FjKKIMVpYP7av7WzxVh9c+4CJSUMl7Xo11H2cemHJ2wBjuXPSBkHzJ0oAAAAAAAAAL9CYMNUXuqx4ViKyjGwUVYpKmthcWCjzqnG3GU2D3fI2Chiz9iQLRujKLARUd+WkVGk/7TiLI8iHS+x352/JlkbOt2rdZ3u1ze95ygvJKb0eYu+GrVNVniCVvd4Wt+c918lJVxS/F7JSZOW/1t6sYv0/uXSH1+4zyYCAACojfKzbeVeIen0WwOcTq8VAACgMghs1AZOpagcemyUlbFx8ohkFNru12ls+7e0jI3CfCk/y3bfseG3QxPv35d9Zg+k7I/sas/GmL8mWfOTY7W9+RinQ84/EOf0YT0/OEY7Wl6j9DrtnMedZguY09mJyJZa3ePf+urc/+qvJiOKMzgMq7RrifTZBOm59tI390h7fnYfgAMAAPAXBbnSiVRp2b+lHd9XbN99a6Vn20ivJ0o56eWPzz4uHdxU/EWpwnwp76TzGGuhtGyG9MXN0vbvXL9UlZ8trZipTR886Lpv0evZOF/a/JlrwMUwpJNHpbRkKfdE2Z/fDUM6utv2ee7obikvq/SxeVnS4R3Sgd9U//gm1U3fajuHw9ydzpV1TDrwm7T7B2nbt/ru++/Kz2J3nFdOuu1nlp/j2T6lYP0CAABQ/YLMnsBpzWulqErL2CjjQ7xD43BFFwU2QoqPZxi24MS+X6UljxaPLSVjo/uu1+33j8R2V5MSp/u93WQlHF6pOln79Hu7Sa4ZHMApJyJb6pfuT2lz29s0UsttC+j0U4vDnDRp7du2W2i01Lq/1PYCqe1gKabkuw4AAMDHcjOlbd9If3xm++O6Y8nY8V9Lrc4tfpyfY+s/1/xs22echQ/YPo9f8Li0ZLqUf1I6skP69S3pvHttwYSju6TkVbYvJrW9QNr3i7ThP9Km+bZj9r9fap4offlPKfuY/mh5vbqOfVIKCpVWvyateNo27vePpTPHS+fdI0U3kf5aJi1/Wvp7rXpI0sufSB0ulDpcJJ08LO1YZOunl3kq43vFs7aeejFNbF9C2fatdGiL/aVdGlJP2tZNyjwk5WVKweFScIRtfXHyiJS+z/m6hcXa5hEWbQuw5GfbMsZPFJckHVp0Z5WUE1xXYQmdpZBI9U/LlrYU2AIeGfudDjvs1HhFNJDiOkuRjaTgMCWlpqtVVL4tIJSdJmUflzXrmAKM4p9XQUCYghq2lZr0kuK72V5DQLAUGGT7NyDI9tqy02zX6HiSdOwvpacd1XmRLaXMXlJcV6llP+cvn5XGWigd2mr78llYjELyTth+5gGsmwAAANwhsOFPKt083CGwEenQPHzDPP2x74i6jry7OHhRxDGwUadEYEOSZjSTohOkI9ud93PosfHtyY4aEhCqIGtxeaCTYfFKanKxtpT4llJ+cB0tPOcj1TmZrGMxnQWU52REE83XNVLfsYo7+qta71+gVoeWSgWnvkGXmyFt/cp2k6SGnaSmvaWEM6QmZ0qNukhBIaWfAAAAoKpOHpVSfpe2fGELUhzfU/rYBbdJ/7hDWvuO1Kq/tH+9tH+dFNP81B/IT30pKXm182f1H56Udv1g+6N92t6y51MUuDil6+63pOc/leq1tp3P0Yb3bLfAENeM7ZOHpA3zbDd3jmx3XSc4CM87JiWtKHuujnLSbDcPheUfl/b+LEkuX6hyK+uI7edzSis3Q0qGD4KsOVLqH7ZbBcRIijm5Rzq0vHhjw05Ss7NswZ2AIFugKTRaCouxBTKSfpT+Wu6UnXOFJK2qK/WaICXeUlw+GAAAAJL8JLAxa9YszZw5UykpKerRo4deffVV9enTp9Txn376qR5++GHt2bNH7dq10zPPPKOLLrrIhzP2lkoGMkoqrXl4xn51zXhbenG2NOwZ6ViSLcsiY7+0fk7xuDrxUoFs30IqknfC7WJle2aYpFPp1dEd9M25C9Q++SM1OrZefzcaoG0tr1NhUITbaeYHR+tYbNeqvFKcjiwBSm1wtlIbnK1WPWKk7d9pzy8L1PjIKoXmO5RmOLzVdvvtP7bHgSFSXBepcQ/bYr5uK6luS6leK+fMIwAAUCtVdI1RLsOQDv1py5D47X3b5+WKSE+Wvr3Hdv/wNuftjhyDGkWSV1XsXI6yjzsFNayWIEmGAorK0pYMapShMCBEgVb3449Fd9KJiGYKyzum2BM7FZqfrkJLsAIj6iovN0tBhdmSYagwMFxHY7oorU57heUdVUROqiJyUhWVd1gqzJPVEqjCgDAVBIbpZHgTnYhspvygKBmWIAVY8xWZc0D10v5QWH6a0/nzguoopEl37bQmKDekrqyWIEXkpioq62/FZ++2BTfcyA+MUF5wtHJD6io3OFaFgaEKzj+hsLxjqnNyrwLkeZ8TQxYVBoTagiKOij6nVlT2cemnF2zZNt2uktoPtX2+rduKTA4AAHDaMz2w8fHHH2vq1Kl68803lZiYqJdeeklDhw7V9u3b1aiRa8ruqlWrNHbsWM2YMUMXX3yx5s+fr1GjRmnDhg3q2rUCfzQ/vF3KifLiK6mEkrVbs45Kf/7PVtM2/6Tt37ws2ze48rOkgjzbN7kK821j8zJt315Pc1gMOQY2ihiFxYsod6KbSseklXWG6dzgX5RnWBRSkClJOhnWWHsShisiJ0WR2Qe0s/lop11PRjTVbx3LODbgRfM3pUs6R+p5jixGoeqlb1HC4Z/U+PBPqpe+xXnhWZhnq7F84DfXA0XUl2Jb2DKcIupLEfVs/0Y2kMLrSUFhxWUGAk+VGggMliyB9v4xAACclk5kmj0Dj1R0jVGqbd9Iqb/YSkKl/CEVZFffpN04Ft1JUVn77J/NT0Q0V2Z4E8UdXaMAWVVoCdaOFmN1IrKFmhxaoYTDK2XIop0txmh300vVZffbapH2q5STppzgutre8lr92foGRWYfUIuDC5Vw+EeF5KcrI6q19jYeppT6fZUXEqOggiw1PrxS9dP/kEWG9jfsr8N1z5ARECQZVkVmH1RQ4UlFZh+UZNHJ8ASl12lbPHHDUFjeUeUGx9r2cdhe6mcpw6oAo1DWgODyL4xhKNCaq8DCXFlkVX5QVLn7heYdV1BBpkZ2qaevNh9SXnC08oKjZZSxX2BBluplbFWdk8kKMPIVYM1XgFEgi1GoAGuB8oMiTwVFYnUyvIkyw5vIGhCsyOwDGtk4Tfr7Vx3ZvMT1c6obucHRSq2fqNzgWIUUnFBIXpoaHVunQKPA9rl24/u2m2TL/IhtLoVE2m7Bp/4NiZBCok6VzQqyfXYNCDj1b+Cpf4NO3Q9w2HZqe8lt9vEBkk793CwWD+/L9tij+yq+X6VzAAAAv+CjNYPFMCpb/8g7EhMTddZZZ+m1116TJFmtVjVr1ky333677r//fpfxo0eP1smTJ/X111/bt5199tnq2bOn3nzzTZfxubm5ys0tLpWUnp6u5s2ba99dUYoOrV0fgAoVpMCpm6VXekkFZTThcxh/tG43NbrpC33yW4rTc2G5RxWal6aMqJYyLIHVNWXAawILshV7YqfqZWxV3YxtqpuxVdFZybJ4KzMKAAAoI9dQsxczlZaWppiYGLOnU6qKrjGqe81wIrypIrJTFKgCHYvuqJzgegrPTVVSwggVBEUq4fBKZUS10p+tJqjJ4R9VN2OrUuon6lD9PgrNS1PjI6uUHxihAw37yQgIUnB+hupmbFdGZCvlhDWwnyfoVOClIKg4E9tiFCo0L005IXXpc2eS4PwTisraL4u1QAEqVIA1VyEFJxWcn6lAa46O1emk47GdXNZd4TmH1Xbfp2qz70uFFNaMoCIAAIDP1gyGiXJzc43AwEDjyy+/dNo+btw4Y8SIEW73adasmfHiiy86bXvkkUeM7t27ux0/ffp0Q7aaT9y4cePGjRs3bty4cfPCbffu3d5YDlSLyqwxWDNw48aNGzdu3Lhx4+bdW3WvGUwtRXXkyBEVFhYqLs65fFJcXJy2bdvmdp+UlBS341NSUtyOf+CBBzR16lT747S0NLVo0ULJycl+/S2z2iAjI0PNmjXTvn37FB0dXf4OqBSus29wnX2Ha+0bXGff4Dr7DtfaN4oyGerVq2f2VEpVmTUGawZz8P/Wd7jWvsF19g2us+9wrX2D6+wbXGff8dWawfQeG9UtNDRUoaGhLttjYmJ4E/tIdHQ019oHuM6+wXX2Ha61b3CdfYPr7Dtca98IqGWNi1kzmIv/t77DtfYNrrNvcJ19h2vtG1xn3+A6+051rxlMXZE0aNBAgYGBSk1Nddqempqq+Ph4t/vEx8dXaDwAAACA00dl1hgAAAAAahZTAxshISHq1auXli5dat9mtVq1dOlS9e3b1+0+ffv2dRovSYsXLy51PAAAAIDTR2XWGAAAAABqFtNLUU2dOlXjx49X79691adPH7300ks6efKkJkyYIEkaN26cmjRpohkzZkiS7rzzTvXv31/PP/+8hg8fro8++kjr1q3TW2+95dH5QkNDNX36dLep5vAurrVvcJ19g+vsO1xr3+A6+wbX2Xe41r5RU65zeWuM8tSU11nTcZ19h2vtG1xn3+A6+w7X2je4zr7BdfYdX11ri2EYRrWewQOvvfaaZs6cqZSUFPXs2VOvvPKKEhMTJUkDBgxQy5YtNXfuXPv4Tz/9VA899JD27Nmjdu3a6dlnn9VFF11k0uwBAAAA+Juy1hgAAAAAaja/CGwAAAAAAAAAAAB4wtQeGwAAAAAAAAAAABVBYAMAAAAAAAAAANQYBDYAAAAAAAAAAECNQWADAAAAAAAAAADUGLUysDFr1iy1bNlSYWFhSkxM1K+//lrm+E8//VQdO3ZUWFiYunXrpm+//dZHM625ZsyYobPOOkt16tRRo0aNNGrUKG3fvr3MfebOnSuLxeJ0CwsL89GMa6ZHH33U5Zp17NixzH14P1dOy5YtXa61xWLRpEmT3I7n/eyZH3/8UZdccokSEhJksVi0YMECp+cNw9Ajjzyixo0bKzw8XIMHD9bOnTvLPW5Ff8/XdmVd5/z8fE2bNk3dunVTZGSkEhISNG7cOB04cKDMY1bm98/poLz39PXXX+9y3S688MJyj8t72ll519nd72uLxaKZM2eWekze0648+TyXk5OjSZMmqX79+oqKitLll1+u1NTUMo9b2d/tvsaaoXqxXvAd1gy+wXqherBe8B3WDL7BesF3WDNUP39fL9S6wMbHH3+sqVOnavr06dqwYYN69OihoUOH6tChQ27Hr1q1SmPHjtXEiRP122+/adSoURo1apT++OMPH8+8ZlmxYoUmTZqkX375RYsXL1Z+fr6GDBmikydPlrlfdHS0Dh48aL/t3bvXRzOuubp06eJ0zX766adSx/J+rry1a9c6XefFixdLkq688spS9+H9XL6TJ0+qR48emjVrltvnn332Wb3yyit68803tWbNGkVGRmro0KHKyckp9ZgV/T1/OijrOmdlZWnDhg16+OGHtWHDBn3xxRfavn27RowYUe5xK/L753RR3ntaki688EKn6/bhhx+WeUze067Ku86O1/fgwYOaPXu2LBaLLr/88jKPy3vamSef5+666y599dVX+vTTT7VixQodOHBAl112WZnHrczvdl9jzVD9WC/4FmuG6sd6oXqwXvAd1gy+wXrBd1gzVD+/Xy8YtUyfPn2MSZMm2R8XFhYaCQkJxowZM9yOv+qqq4zhw4c7bUtMTDRuueWWap1nbXPo0CFDkrFixYpSx8yZM8eIiYnx3aRqgenTpxs9evTweDzvZ++58847jTZt2hhWq9Xt87yfK06S8eWXX9ofW61WIz4+3pg5c6Z9W1pamhEaGmp8+OGHpR6nor/nTzclr7M7v/76qyHJ2Lt3b6ljKvr753Tk7lqPHz/eGDlyZIWOw3u6bJ68p0eOHGmcf/75ZY7hPV2+kp/n0tLSjODgYOPTTz+1j9m6dashyVi9erXbY1T2d7uvsWbwPdYL1Yc1gzlYL3gf6wXfYc3gG6wXfIc1g2/423qhVmVs5OXlaf369Ro8eLB9W0BAgAYPHqzVq1e73Wf16tVO4yVp6NChpY6He+np6ZKkevXqlTkuMzNTLVq0ULNmzTRy5Eht2bLFF9Or0Xbu3KmEhAS1bt1a11xzjZKTk0sdy/vZO/Ly8vT+++/rhhtukMViKXUc7+eqSUpKUkpKitN7NiYmRomJiaW+Zyvzex6u0tPTZbFYFBsbW+a4ivz+QbHly5erUaNG6tChg/75z3/q6NGjpY7lPV11qamp+uabbzRx4sRyx/KeLlvJz3Pr169Xfn6+0/uzY8eOat68eanvz8r8bvc11gzmYL1QvVgz+BbrBd9gvWAu1gzVh/WC77Fm8A5/Wy/UqsDGkSNHVFhYqLi4OKftcXFxSklJcbtPSkpKhcbDldVq1ZQpU/SPf/xDXbt2LXVchw4dNHv2bP33v//V+++/L6vVqnPOOUd///23D2dbsyQmJmru3LlauHCh3njjDSUlJencc8/ViRMn3I7n/ewdCxYsUFpamq6//vpSx/B+rrqi92VF3rOV+T0PZzk5OZo2bZrGjh2r6OjoUsdV9PcPbC688ELNmzdPS5cu1TPPPKMVK1Zo2LBhKiwsdDue93TVvffee6pTp0656c68p8vm7vNcSkqKQkJCXP6gUd5n66Ixnu7ja6wZfI/1QvVizeB7rBd8g/WCeVgzVB/WC+ZgzVB1/rheCKrQaMCNSZMm6Y8//ii35lzfvn3Vt29f++NzzjlHnTp10v/93//piSeeqO5p1kjDhg2z3+/evbsSExPVokULffLJJx5FmVE57777roYNG6aEhIRSx/B+Rk2Un5+vq666SoZh6I033ihzLL9/KmfMmDH2+926dVP37t3Vpk0bLV++XIMGDTJxZrXX7Nmzdc0115TbkJX3dNk8/TwHVAbrherF7zffY72A2ow1Q/VivWAO1gxV54/rhVqVsdGgQQMFBga6dF5PTU1VfHy8233i4+MrNB7OJk+erK+//lrLli1T06ZNK7RvcHCwzjjjDO3atauaZlf7xMbGqn379qVeM97PVbd3714tWbJEN954Y4X24/1ccUXvy4q8Zyvzex42RQuUvXv3avHixWV+88qd8n7/wL3WrVurQYMGpV433tNVs3LlSm3fvr3Cv7Ml3tOOSvs8Fx8fr7y8PKWlpTmNL++zddEYT/fxNdYMvsV6wfdYM1Qv1gu+w3rB91gz+B7rherHmqHq/HW9UKsCGyEhIerVq5eWLl1q32a1WrV06VKnb0o46tu3r9N4SVq8eHGp42FjGIYmT56sL7/8Uj/88INatWpV4WMUFhZq8+bNaty4cTXMsHbKzMzU7t27S71mvJ+rbs6cOWrUqJGGDx9eof14P1dcq1atFB8f7/SezcjI0Jo1a0p9z1bm9zyKFyg7d+7UkiVLVL9+/Qofo7zfP3Dv77//1tGjR0u9brynq+bdd99Vr1691KNHjwrvy3u6/M9zvXr1UnBwsNP7c/v27UpOTi71/VmZ3+2+xprBN1gvmIc1Q/ViveA7rBd8izWDOVgvVD/WDJXn9+uFCrUarwE++ugjIzQ01Jg7d67x559/GjfffLMRGxtrpKSkGIZhGNddd51x//3328f//PPPRlBQkPHcc88ZW7duNaZPn24EBwcbmzdvNusl1Aj//Oc/jZiYGGP58uXGwYMH7besrCz7mJLX+rHHHjMWLVpk7N6921i/fr0xZswYIywszNiyZYsZL6FGuPvuu43ly5cbSUlJxs8//2wMHjzYaNCggXHo0CHDMHg/e1thYaHRvHlzY9q0aS7P8X6unBMnThi//fab8dtvvxmSjBdeeMH47bffjL179xqGYRhPP/20ERsba/z3v/81fv/9d2PkyJFGq1atjOzsbPsxzj//fOPVV1+1Py7v9/zpqKzrnJeXZ4wYMcJo2rSpsXHjRqff2bm5ufZjlLzO5f3+OV2Vda1PnDhh3HPPPcbq1auNpKQkY8mSJcaZZ55ptGvXzsjJybEfg/d0+cr73WEYhpGenm5EREQYb7zxhttj8J4unyef52699VajefPmxg8//GCsW7fO6Nu3r9G3b1+n43To0MH44osv7I89+d1uNtYM1Y/1gu+wZvAd1gvex3rBd1gz+AbrBd9hzVD9/H29UOsCG4ZhGK+++qrRvHlzIyQkxOjTp4/xyy+/2J/r37+/MX78eKfxn3zyidG+fXsjJCTE6NKli/HNN9/4eMY1jyS3tzlz5tjHlLzWU6ZMsf9c4uLijIsuusjYsGGD7ydfg4wePdpo3LixERISYjRp0sQYPXq0sWvXLvvzvJ+9a9GiRYYkY/v27S7P8X6unGXLlrn9XVF0La1Wq/Hwww8bcXFxRmhoqDFo0CCX69+iRQtj+vTpTtvK+j1/OirrOiclJZX6O3vZsmX2Y5S8zuX9/jldlXWts7KyjCFDhhgNGzY0goODjRYtWhg33XSTy4KD93T5yvvdYRiG8X//939GeHi4kZaW5vYYvKfL58nnuezsbOO2224z6tata0RERBiXXnqpcfDgQZfjOO7jye92f8CaoXqxXvAd1gy+w3rB+1gv+A5rBt9gveA7rBmqn7+vFyynDg4AAAAAAAAAAOD3alWPDQAAAAAAAAAAULsR2AAAAAAAAAAAADUGgQ0AAAAAAAAAAFBjENgAAAAAAAAAAAA1BoENAAAAAAAAAABQYxDYAAAAAAAAAAAANQaBDQAAAAAAAAAAUGMQ2AAAAAAAAAAAADUGgQ0AAAAAAAAAAFBjENgAAAAAAAAAAAA1BoENAIBp9uzZI4vFos8//1znnXeewsPDddZZZyk5OVkrV67U2WefrYiICA0aNEhpaWlmTxcAAACAj7FmAAC4E2T2BAAAp69NmzZJkt544w39+9//VmRkpEaOHKlrr71WderU0WuvvabCwkINHz5cc+bM0V133WXyjAEAAAD4EmsGAIA7BDYAAKbZuHGj6tWrp48//lj169eXJPXv318//fSTtmzZooiICEnSWWedpZSUFDOnCgAAAMAErBkAAO5QigoAYJpNmzbp0ksvtS9QJCk5OVmjR4+2L1CKtrVq1cqMKQIAAAAwEWsGAIA7BDYAAKbZuHGjEhMTnbZt2rRJZ599tv1xTk6Otm/frh49evh6egAAAABMxpoBAOAOgQ0AgCkyMjK0Z88enXHGGfZtSUlJSk9Pd9q2efNmGYahbt26mTFNAAAAACZhzQAAKA2BDQCAKTZt2qTAwEB17drVvq2ofm6LFi2ctrVp00ZRUVFmTBMAAACASVgzAABKQ2ADAGCKTZs2qUOHDgoLC3Pa5vjNq6JtpJQDAAAApx/WDACA0lgMwzDMngQAAAAAAAAAAIAnyNgAAAAAAAAAAAA1BoENAAAAAAAAAABQYxDYAAAAAAAAAAAANQaBDQAAAAAAAAAAUGMQ2AAAAAAAAAAAADUGgQ0AAAAAAAAAAFBjENgAAAAAAAAAAAA1BoENAAAAAAAAAABQYxDYAAAAAAAAAAAANQaBDQAAAAAAAAAAUGMQ2AAAAAAAAAAAADUGgQ0AAAAAAAAAAFBjENgAAAAAAAAAAAA1BoENAAAAAAAAAABQYxDYAAAAAAAAAAAANQaBDQAAAAAAAAAAUGMQ2AAAAAAAAAAAADUGgQ0AQIVddNFFuummm8yeBkz2559/KigoSH/88YfZUwEAAEANtW/fPoWFhennn382eyow2f3336/ExESzpwGghiCwAaDWmjt3riwWS6m3X375xewp2pWcW2RkpDp37qwnn3xSWVlZ1XbeVatW6dFHH1VaWprH+/z888/6/vvvNW3atGqbV23xv//9T2eeeabCwsLUvHlzTZ8+XQUFBR7t+9RTT2nEiBGKi4uTxWLRo48+6tF+F1xwgSwWiyZPnuzyXHp6uu677z61a9dO4eHhatGihSZOnKjk5GSXsUuWLNHAgQPVoEEDxcbGqk+fPvrPf/7jNKZz584aPny4HnnkEY/mBgAAUN0effRRWSwWHTlyxO3zXbt21YABA3w7KR9ztw5q1KiRBg4cqO+++65az/36669r7ty5Fdrn8ccfV2Jiov7xj39Uz6RqidzcXE2bNk0JCQkKDw9XYmKiFi9e7PH++/fv11VXXaXY2FhFR0dr5MiR+uuvv1zGvfHGG7ryyivVvHlzWSwWXX/99W6PN2DAgFLX2sHBwU5jMzMzNWXKFDVt2lShoaHq1KmT3njjDZdjTpkyRZs2bdL//vc/j18XgNNXkNkTAIDq9vjjj6tVq1Yu29u2bWvCbEp3wQUXaNy4cZJsH/xWrlyphx9+WJs2bdKnn35aLedctWqVHnvsMV1//fWKjY31aJ+ZM2dq0KBBfnf9/M13332nUaNGacCAAXr11Ve1efNmPfnkkzp06JDbD/ElPfTQQ4qPj9cZZ5yhRYsWeXTOL774QqtXr3b7nNVq1QUXXKA///xTt912m9q3b69du3bp9ddf16JFi7R161bVqVNHki0gM2rUKPXt29f+x4FPPvlE48aN05EjR3TXXXfZj3vrrbfqoosu0u7du9WmTRuP5gkAAIDqV7QOMgxDqampmjt3ri666CJ99dVXuvjii6vlnK+//roaNGhQ6h/DSzp8+LDee+89vffee9Uyn9rk+uuv12effaYpU6aoXbt29p/nsmXL1K9fvzL3zczM1MCBA5Wenq5//etfCg4O1osvvqj+/ftr48aNql+/vn3sM888oxMnTqhPnz46ePBgqcd88MEHdeONNzptO3nypG699VYNGTLEvq2wsFBDhw7VunXrNGnSJLVr106LFi3SbbfdpuPHj+tf//qXfWx8fLxGjhyp5557TiNGjKjoJQJwujEAoJaaM2eOIclYu3at2VMplyRj0qRJLtuvuOIKIyAgwMjOzq6W886cOdOQZCQlJXk0PjU11QgKCjLeeeedaplPbdK5c2ejR48eRn5+vn3bgw8+aFgsFmPr1q3l7l/0Mzl8+LAhyZg+fXqZ47Ozs42WLVsajz/+uNv3088//2xIMl577TWn7bNnzzYkGV988YV92wUXXGAkJCQYOTk59m35+flGmzZtjO7duzvtn5eXZ9StW9d4+OGHy31NAAAA1W369OmGJOPw4cNun+/SpYvRv39/307Kx0pbBx07dswIDg42rr766mo7d0Wv7wsvvGCEh4cbJ06cqLY51QZr1qwxJBkzZ860b8vOzjbatGlj9O3bt9z9n3nmGUOS8euvv9q3bd261QgMDDQeeOABp7F79uwxrFarYRiGERkZaYwfP97jef7nP/8xJBkffPCBfdsnn3xiSDLeffddp7GXX365ERYWZqSmpjpt/+yzzwyLxWLs3r3b4/MCOD1RigrAaW/Pnj2yWCx67rnnNGvWLLVu3VoREREaMmSI9u3bJ8Mw9MQTT6hp06YKDw/XyJEjdezYMadjtGzZUhdffLG+//579ezZU2FhYercubO++OKLKs0tPj5eFotFQUHFCXYtW7Z0+w2oAQMGuKTVv/rqq+rSpYsiIiJUt25d9e7dW/Pnz5dkS9O/9957JUmtWrWypw3v2bOn1Pl88803Kigo0ODBg522F6W7//TTT7rjjjvUsGFDxcbG6pZbblFeXp7S0tI0btw41a1bV3Xr1tV9990nwzCcjvHcc8/pnHPOUf369RUeHq5evXrps88+c5nD4sWL1a9fP8XGxioqKkodOnRw+pZPea/bF/7880/9+eefuvnmm51+drfddpsMw3D7ukpq2bJlhc757LPPymq16p577nH7fEZGhiQpLi7OaXvjxo0lSeHh4U5j69atq9DQUPu2oKAgNWjQwGmcJAUHB2vAgAH673//W6H5AgAA+IPly5fbs1OfeuopNW3aVGFhYRo0aJB27drlMn7NmjW68MILFRMTo4iICPXv39+lN0RRxuuOHTt07bXXKiYmRg0bNtTDDz8swzC0b98+jRw5UtHR0YqPj9fzzz/vdk4ff/yx/vWvfyk+Pl6RkZEaMWKE9u3bV+nXGhsbq/DwcKfPp0XnWr58udPYojWSY1mplJQUTZgwwV5OqHHjxho5cqR9/dCyZUtt2bJFK1assK8tyiv7tWDBAiUmJioqKspp+4ABA9S1a1f9/vvv6t+/vyIiItS2bVv75+gVK1YoMTFR4eHh6tChg5YsWeK0/969e3XbbbepQ4cOCg8PV/369XXllVe6rHXy8/P12GOPqV27dgoLC1P9+vXVr18/pxJP5b1uX/jss88UGBiom2++2b4tLCxMEydO1OrVq8t9X3z22Wc666yzdNZZZ9m3dezYUYMGDdInn3ziNLZFixayWCyVmuf8+fMVGRmpkSNH2retXLlSkjRmzBinsWPGjFFOTo7LOqJorcn6AkB5KEUFoNZLT093qbFrsVic0m0l6YMPPlBeXp5uv/12HTt2TM8++6yuuuoqnX/++Vq+fLmmTZumXbt26dVXX9U999yj2bNnO+2/c+dOjR49WrfeeqvGjx+vOXPm6Morr9TChQt1wQUXlDvPnJwc+zxPnjypn3/+We+9956uvvpqp8WHp95++23dcccduuKKK3TnnXcqJydHv//+u9asWaOrr75al112mXbs2KEPP/xQL774oho0aCBJatiwYanHXLVqlerXr68WLVq4ff72229XfHy8HnvsMf3yyy966623FBsbq1WrVql58+b697//rW+//VYzZ85U165d7aW3JOnll1/WiBEjdM011ygvL08fffSRrrzySn399dcaPny4JGnLli26+OKL1b17dz3++OMKDQ3Vrl27nBaT5b3uspRWi7mkOnXqOP3Rv6TffvtNktS7d2+n7QkJCWratKn9eW9JTk7W008/rdmzZ7sEHor07t1bkZGRevjhh1WvXj116NBBu3bt0n333aezzjrLKVg1YMAAPfPMM3r44Yc1fvx4WSwWzZ8/X+vWrXNZ+EhSr1699N///lcZGRmKjo726msDAADwhaeffloBAQG65557lJ6ermeffVbXXHON1qxZYx/zww8/aNiwYerVq5emT5+ugIAAzZkzR+eff75WrlypPn36OB1z9OjR6tSpk55++ml98803evLJJ1WvXj393//9n84//3w988wz+uCDD3TPPfforLPO0nnnnee0/1NPPSWLxaJp06bp0KFDeumllzR48GBt3Lix1M98jorWQYZh6NChQ3r11VeVmZmpa6+9tlLX6PLLL9eWLVt0++23q2XLljp06JAWL16s5ORktWzZUi+99JJuv/12RUVF6cEHH5Tk+qUaR/n5+Vq7dq3++c9/un3++PHjuvjiizVmzBhdeeWVeuONNzRmzBh98MEHmjJlim699VZdffXVmjlzpq644grt27fPXlp17dq1WrVqlcaMGaOmTZtqz549euONNzRgwAD9+eefioiIkGQLQs2YMUM33nij+vTpo4yMDK1bt04bNmywr+HKe92lyc3N1YkTJzy6tkVrsdL89ttvat++vctn7aL33MaNG9WsWTO3+1qtVv3++++64YYbXJ7r06ePvv/+e504ccJ+7Srr8OHDWrx4sUaPHq3IyEj79tzcXAUGBiokJMRpfNHPYP369brpppvs22NiYtSmTRv9/PPPTiVwAcCFqfkiAFCNilKw3d1CQ0Pt45KSkgxJRsOGDY20tDT79gceeMCQ5FJOaOzYsUZISIhTmZ4WLVoYkozPP//cvi09Pd1o3LixccYZZ5Q719LmOWrUKKfzFJ3LXTpw//79ndK+R44caXTp0qXM81a0FFW/fv2MXr16uWwvutZDhw61py0bhmH07dvXsFgsxq233mrfVlBQYDRt2tQlRT0rK8vpcV5entG1a1fj/PPPt2978cUXyywtYBieve7SlPZzKHmbM2dOmccpuq7Jyckuz5111lnG2Wef7fGcPClFdcUVVxjnnHOO0+twV9rs66+/Nho3buz0WoYOHeqS+p+ZmWlcddVVhsVisY+LiIgwFixY4Pb88+fPNyQZa9as8fh1AQAAVIeKlqJatmyZIcno1KmTkZuba9/+8ssvG5KMzZs3G4ZhGFar1WjXrp3L592srCyjVatWxgUXXOAyh5tvvtm+regzsMViMZ5++mn79uPHjxvh4eFOn++L5tSkSRMjIyPDvr2opM/LL79c5jUobR0UGhpqzJ0712ls0bmWLVvmtL1ojVT0uff48eMupZDcqUgpql27dhmSjFdffdXluf79+xuSjPnz59u3bdu2zZBkBAQEGL/88ot9+6JFi1w+o5dcWxiGYaxevdqQZMybN8++rUePHsbw4cNLnaOnr9udstajJW/l6dKli9O6qMiWLVsMScabb75Z6r5F64nHH3/c5blZs2YZkoxt27a53bcipaheffVVQ5Lx7bffOm1//vnnDUnGypUrnbbff//9hiTj4osvdjnWkCFDjE6dOnl0XgCnLzI2ANR6s2bNUvv27Z22BQYGuoy78sorFRMTY3+cmJgoSbr22mudMiYSExP14Ycfav/+/WrdurV9e0JCgi699FL74+joaI0bN07PPPOMUlJSFB8fX+Y8R44cqcmTJ0uSsrKy9Msvv+jFF1/U1Vdfrc8++6zC6cCxsbH6+++/tXbtWqeU46o4evSomjRpUurzEydOdJpnYmKiVq9erYkTJ9q3BQYGqnfv3lq/fr3Tvo7fOjt+/LgKCwt17rnn6sMPP7RvL2pw/t///lcTJkxQQIBrRcWqvG7HlPOydOnSpczns7OzJcltVkdYWJi9LJQ3LFu2TJ9//rnTtwlL07BhQ51xxhmaPHmyunTpoo0bN+rZZ5/VhAkTnBrUh4aGqn379rriiit02WWXqbCwUG+99ZauvfZaLV68WGeffbbTcevWrSvJ84wXAAAAfzNhwgSnb5Sfe+65kqS//vpLXbt21caNG7Vz50499NBDOnr0qNO+gwYN0n/+8x9ZrVanz6eOjZWLPgP//fffTp+NY2Nj1aFDB/31118ucxo3bpzTt+ivuOIKNW7cWN9++63uuOOOcl+T4zooNTVV77//vm688UbVqVNHl112Wbn7OwoPD1dISIiWL1+uiRMn2j//VUXRdSztWFFRUU7lizp06KDY2Fg1adLEvlaTitdtjtfQcW2Rn5+vjIwMtW3bVrGxsdqwYYOuu+46Sbbrv2XLFu3cuVPt2rVzmUNVXvfQoUM9Xl+UJzs7u9S1RdHzZe0rlb42KW9/T82fP18NGzZ0qVZw9dVX6/HHH9cNN9ygWbNmqV27dvr+++/1+uuvl3ruunXrej3LHUDtQ2ADQK3Xp08fl5JA7jRv3tzpcVGQo2RKb9H248ePO21v27atS/ChaCGxZ88eNWzYUIcPH3Z6vl69evYFVNOmTZ3KAY0YMUL169fXPffco6+//lqXXHJJua/B0bRp07RkyRL16dNHbdu21ZAhQ3T11VfrH//4R4WOU5JRojeGo4pcw5LX7+uvv9aTTz6pjRs3Kjc3177d8ZqOHj1a77zzjm688Ubdf//9GjRokC677DJdccUV9kVkVV53yd4hlVW0kHJ8HUVycnI8Kh3giYKCAt1xxx267rrryg3i/PXXXxo4cKDmzZunyy+/XJItmFbUs+W7777TsGHDJEmTJ0/WL7/8og0bNtiv61VXXaUuXbrozjvvdAmiFL0nKluLFwAAwJfcfWYp+Tm26A/YRZ9Zd+7cKUkaP358qcdNT093+sO3u8/GYWFhLmWHYmJiXIIlklz+0G6xWNS2bVt7b4fMzExlZmbanw8MDHQqK1tyHTR27Fj7l1wuvvhil9JAZQkNDdUzzzyju+++W3FxcTr77LN18cUXa9y4ceV+gas8pa0vmjZt6vKziomJ8Wh9lp2drRkzZmjOnDnav3+/0znS09Pt9x9//HGNHDlS7du3V9euXXXhhRfquuuuU/fu3av8uhs3bmzvZ1dV4eHhpa4tip4va1+p9LVJeft74q+//tLq1as1efJklzLK8fHx+t///qfrrrtOQ4YMkWT7EuCrr76q8ePHu/RXkWzvCdYWAMpD83AAOMVdFkdZ28v6A787+/bts3+4LbqtWrWqzH0GDRokSfrxxx/t20r7gFdYWOj0uFOnTtq+fbs++ugj9evXT59//rn69eun6dOnV2jejurXr+8SkHBUkWvoeP1WrlypESNGKCwsTK+//rq+/fZbLV68WFdffbXTuPDwcP34449asmSJrrvuOv3+++8aPXq0LrjgAvvrr8rrTklJ8ehW3jeaihYwBw8edHnu4MGDSkhIKHcunpg3b562b9+uW265RXv27LHfJOnEiRPas2ePsrKyJNkavOfk5Ojiiy92OsaIESMkyd6nJC8vT++++66GDx/u9I3D4OBgDRs2TOvWrVNeXp7TMYreE+XVBgYAAKhu5X0DPSsryz7GUXmf+a1WqyRp5syZWrx4sdtbyT/Qujumt9YWkvTcc885rS3K+6JLQECABg4cqIMHD9oDNZ6uLSRpypQp2rFjh2bMmKGwsDA9/PDD6tSpU6W/WV/U87C09UVV1me33367nnrqKV111VX65JNP9P3332vx4sWqX7++/WcpSeedd552796t2bNnq2vXrnrnnXd05pln6p133rGPqezrzs7O9nh9UZ7GjRuXuraQVOb6ol69egoNDa30/p6YP3++JOmaa65x+/x5552nv/76S7/99pt++ukn7d+/354FXrK6gmR7T7C2AFAeMjYAwEt27drl8s2SHTt2SJJatmyp2NhYl1TkHj16lHnMgoICSXL6JlbdunWVlpbmMnbv3r1OpbEkKTIyUqNHj9bo0aOVl5enyy67TE899ZQeeOABhYWFVfhbMB07dtTnn39eoX088fnnnyssLEyLFi1ySpGeM2eOy9iAgAANGjRIgwYN0gsvvKB///vfevDBB7Vs2TJ7xkV5r7s0nn6jas6cObr++utLfb5nz56SpHXr1jk1kTxw4ID+/vtv3XzzzR6dpzzJycnKz893m40yb948zZs3T19++aVGjRql1NRUGYbhskjNz8+XVPxeO3r0qAoKCtwuZvPz82W1Wl2eS0pKUkBAgNtFCQAAgC+1aNFCkrR9+3aXb/ZnZWVp37599m+NV0SbNm0k2b5p7q0s3/IUBR+KGIahXbt22bMJxo0bp379+tmf9+Rb9yXXF0UZJiXXF3v37nW7f5s2bXT33Xfr7rvv1s6dO9WzZ089//zzev/99yVVLIO3efPmCg8PV1JSksf7eOqzzz7T+PHj9fzzz9u35eTkuF1H1atXTxMmTNCECROUmZmp8847T48++qhTKbHyXrc7H3/8sSZMmODRfMsLbPXs2VPLli1TRkaGUwPxokzqovWHOwEBAerWrZvWrVvn8tyaNWvUunXrKjcOnz9/vtq0aeNSstZRYGCg0zyXLFkiyX3WfFJSUrlrZQAgsAEAXnLgwAF9+eWX9nq1GRkZmjdvnnr27GlPU67oIuirr76S5BwAadOmjVauXKm8vDx7+vjXX3+tffv2OQU2jh49av8WlCSFhISoc+fO+u6775Sfn6+wsDBFRkZKcl3IlKZv375655139Ndff7kEUaoiMDBQFovF6Q/me/bs0YIFC5zGHTt2TPXq1XPaVvThuCi12pPXXRpv9djo0qWLOnbsqLfeeku33HKL/Vtlb7zxhiwWi6644gr72PT0dB08eFCNGzd26vHiiTFjxrhdxFx66aW66KKLdNNNN9lrDrdv316GYeiTTz5xCsoU9TA544wzJEmNGjVSbGysvvzySz3++OP291hmZqa++uordezY0WXRvH79enXp0qXC8wcAAPC2QYMGKSQkRG+88YbOP/98pwzUt956SwUFBfbymxXRq1cvtWnTRs8995yuvvpql+yMw4cPO5WB8oZ58+bpgQcesP/R+bPPPtPBgwc1bdo0SVLr1q0r9Jk8Pz9f33//vUJCQtSpUydJtkBQYGCgfvzxR40aNco+tqj/QZGsrCwFBAQ4fZZu06aN6tSp41TiKDIy0uO1RXBwsHr37u32D+5VFRgY6BIsePXVV12+oFNy7RAVFaW2bdtq3759kjx/3e54s8fGFVdcoeeee05vvfWW7rnnHkm29c+cOXOUmJjoFMRLTk5WVlaWOnbs6LT//fffr3Xr1tnLk23fvl0//PCD/XiV9dtvv2nr1q16+OGHPd7n8OHDeuaZZ9S9e3eXNXJ6erp2796tf/7zn1WaF4Daj8AGgFrvu+++07Zt21y2n3POOV7943z79u01ceJErV27VnFxcZo9e7ZSU1PdZh24s2PHDvs3foqah7/33ntq27atvbmdZGtC+Nlnn+nCCy/UVVddpd27d+v999+3f4usyJAhQxQfH69//OMfiouL09atW/Xaa69p+PDh9sVRr169JEkPPvigxowZo+DgYF1yySX2gEdJw4cPV1BQkJYsWeK1rIOi477wwgu68MILdfXVV+vQoUOaNWuW2rZtq99//90+7vHHH9ePP/6o4cOHq0WLFjp06JBef/11NW3a1P5tNU9ed2m8+e27mTNnasSIERoyZIjGjBmjP/74Q6+99ppuvPFG+0JSkr788ktNmDDBJQvkP//5j/bu3WsvJfXjjz/qySeflCRdd911atGihTp27Oi0YHHUqlUrp8Xp9ddfr+eee0633HKLfvvtN3Xp0kUbNmzQO++8oy5dutgb3wcGBuqee+7RQw89pLPPPlvjxo1TYWGh3n33Xf39998u30rLz8/XihUrdNttt3njsgEAAFRJo0aN9Mgjj+ihhx7SeeedpxEjRigiIkKrVq3Shx9+qCFDhlS4d51k+9b7O++8o2HDhqlLly6aMGGCmjRpov3792vZsmWKjo62fynJW+rVq6d+/fppwoQJSk1N1UsvvaS2bdvqpptu8mh/x3XQoUOHNH/+fO3cuVP333+//Vv/MTExuvLKK/Xqq6/KYrGoTZs2+vrrr3Xo0CGnY+3YsUODBg3SVVddpc6dOysoKEhffvmlUlNTnRp89+rVS2+88YaefPJJtW3bVo0aNdL5559f6hxHjhypBx980CUToaouvvhi/ec//1FMTIw6d+6s1atXa8mSJU5BDEnq3LmzBgwYoF69eqlevXpat26dPvvsM02ePLlCr9sdb/bYSExM1JVXXqkHHnhAhw4dUtu2bfXee+9pz549evfdd53Gjhs3TitWrHAK7Nx22216++23NXz4cN1zzz0KDg7WCy+8oLi4ON19991O+3/11VfatGmTJNtn/d9//92+DhkxYoQ9Y6jIBx98IKn0MlSS1L9/f/Xt21dt27ZVSkqK3nrrLWVmZurrr792Cj5KtkwOwzA0cuTICl4lAKcdAwBqqTlz5hiSSr3NmTPHMAzDSEpKMiQZM2fOdNp/2bJlhiTj008/dXvctWvX2re1aNHCGD58uLFo0SKje/fuRmhoqNGxY0eXfUtTcm6BgYFG06ZNjZtvvtlITU11Gf/8888bTZo0MUJDQ41//OMfxrp164z+/fsb/fv3t4/5v//7P+O8884z6tevb4SGhhpt2rQx7r33XiM9Pd3pWE888YTRpEkTIyAgwJBkJCUllTnXESNGGIMGDSr3mhiGYUyfPt2QZBw+fNhp+/jx443IyEinbe+++67Rrl07+7WbM2eOff8iS5cuNUaOHGkkJCQYISEhRkJCgjF27Fhjx44dFX7dvvDll18aPXv2NEJDQ42mTZsaDz30kJGXl+c0pujaFb0fi/Tv37/U9+6yZcvKPK8kY9KkSS7b//77b+OGG24wWrVqZYSEhBiNGzc2brrpJpefj2EYxgcffGD06dPHiI2NNcLDw43ExETjs88+cxn33XffGZKMnTt3ln9BAAAAfOT99983zj77bCMyMtL++fKxxx4zcnJynMaV9pm/aI1Q8jPab7/9Zlx22WX2z5otWrQwrrrqKmPp0qX2MRX5DGwYts99Xbp0cZnThx9+aDzwwANGo0aNjPDwcGP48OHG3r17y33t7tZBYWFhRs+ePY033njDsFqtTuMPHz5sXH755UZERIRRt25d45ZbbjH++OMPp9d/5MgRY9KkSUbHjh2NyMhIIyYmxkhMTDQ++eQTp2OlpKQYw4cPN+rUqWNIclqfuJOammoEBQUZ//nPf8q8JkWK1l0llfz8e/z4cWPChAlGgwYNjKioKGPo0KHGtm3bjBYtWhjjx4+3j3vyySedPvN27NjReOqpp+yf2T193b6QnZ1t3HPPPUZ8fLwRGhpqnHXWWcbChQtdxhWtI0rat2+fccUVVxjR0dFGVFSUcfHFF7v9DD9+/Phy19BFCgsLjSZNmhhnnnlmmXO/6667jNatWxuhoaFGw4YNjauvvtrYvXu327GjR482+vXrV+bxAMAwDMNiGJXoUAUAcNKyZUt17dpVX3/9tdlTqXYrV67UgAEDtG3bNrVr187s6cBko0aNksVi0Zdffmn2VAAAAGqF5cuXa+DAgfr000+dSpjWVhMnTtSOHTu0cuVKs6cCk6WkpKhVq1b66KOPyNgAUK6A8ocAAFDs3HPP1ZAhQ/Tss8+aPRWYbOvWrfr666/1xBNPmD0VAAAA1FDTp0/X2rVr9fPPP5s9FZjspZdeUrdu3QhqAPAIPTYAABX23XffmT0F+IFOnTqpoKDA7GkAAACgBmvevLlycnLMngb8wNNPP232FADUIGRsAAAAAAAAAACAGoMeGwAAAAAAAAAAoMYgYwMAAAAAAAAAANQYBDYAAAAAAAAAAECNcdo1D7darTpw4IDq1Kkji8Vi9nQAAACAGsMwDJ04cUIJCQkKCKi935FizQAAAABUjq/WDKddYOPAgQNq1qyZ2dMAAAAAaqx9+/apadOmZk+j2rBmAAAAAKqmutcMp11go06dOpJsFzY6Otrk2QAAAAA1R0ZGhpo1a2b/TF1bsWYAAAAAKsdXa4bTLrBRlEoeHR3NIgUAAACohNpenok1AwAAAFA11b1mqL2FcQEAAAAAAAAAQK1DYAMAAAAAAAAAANQYBDYAAAAAAAAAAECNcdr12AAAAChLYWGh8vPzzZ4GYIrg4GAFBgaaPQ0AAAC/xpoBpzN/WTMQ2AAAAJBkGIZSUlKUlpZm9lQAU8XGxio+Pr7WNwgHAACoKNYMgI0/rBkIbAAAAEj2BUqjRo0UERHBH3Vx2jEMQ1lZWTp06JAkqXHjxibPCAAAwL+wZsDpzp/WDAQ2AADAaa+wsNC+QKlfv77Z0wFMEx4eLkk6dOiQGjVq5Bcp5gAAAP6ANQNg4y9rBpqHAwCA015RfdyIiAiTZwKYr+j/AXWjAQAAirFmAIr5w5qBwAYAAMAppJID/D8AAAAoC5+VAP/4f0BgAwAAAAAAAAAA1BgENgAAAFCu7du3Kz4+XidOnDB7Kn7v7LPP1ueff272NAAAAACfYb3gOdYL3kFgAwAAoIayWCxl3h599FHt2bNHFotFgYGB2r9/v9P+Bw8eVFBQkCwWi/bs2VPmuR544AHdfvvtqlOnjiTbwmXgwIGKi4tTWFiYWrdurYceesilxuqnn36qjh07KiwsTN26ddO3337r9LxhGHrkkUfUuHFjhYeHa/Dgwdq5c2fVL46XPProo+rZs2eF9nnooYd0//33y2q1Vs+kAAAAAA+wXqh+rBfMQ2ADAACghjp48KD99tJLLyk6Otpp2z333GMf26RJE82bN89p//fee09NmjQp9zzJycn6+uuvdf3119u3BQcHa9y4cfr++++1fft2vfTSS3r77bc1ffp0+5hVq1Zp7Nixmjhxon777TeNGjVKo0aN0h9//GEf8+yzz+qVV17Rm2++qTVr1igyMlJDhw5VTk5OFa6MuYYNG6YTJ07ou+++M3sqAAAAOI2xXvBPrBe8g8AGAABADRUfH2+/xcTEyGKxOG2Lioqyjx0/frzmzJnjtP+cOXM0fvz4cs/zySefqEePHk6LmtatW2vChAnq0aOHWrRooREjRuiaa67RypUr7WNefvllXXjhhbr33nvVqVMnPfHEEzrzzDP12muvSbJ9++qll17SQw89pJEjR6p79+6aN2+eDhw4oAULFpQ6nwEDBuj222/XlClTVLduXcXFxentt9/WyZMnNWHCBNWpU0dt27Ytd6Ewd+5cxcbGasGCBWrXrp3CwsI0dOhQ7du3z/78Y489pk2bNtm/1TZ37lwZhqFHH31UzZs3V2hoqBISEnTHHXfYjxsYGKiLLrpIH330UbnXFgAAAKgurBdYL9RmQWZPAAAAwG/9X38p85DvzxvVSLplhVcPOWLECL355pv66aef1K9fP/300086fvy4LrnkEj3xxBNl7rty5Ur17t27zDG7du3SwoULddlll9m3rV69WlOnTnUaN3ToUPsiJCkpSSkpKRo8eLD9+ZiYGCUmJmr16tUaM2ZMqed77733dN999+nXX3/Vxx9/rH/+85/68ssvdemll+pf//qXXnzxRV133XVKTk5WREREqcfJysrSU089pXnz5ikkJES33XabxowZo59//lmjR4/WH3/8oYULF2rJkiX2+X3++ed68cUX9dFHH6lLly5KSUnRpk2bnI7bp08fPf3002VeMwAAANQCZqwZWC+wXgCBDQAAgFJlHpJOHDB7Fl4RHBysa6+9VrNnz1a/fv00e/ZsXXvttQoODi53371795a6UDnnnHO0YcMG5ebm6uabb9bjjz9ufy4lJUVxcXFO4+Pi4pSSkmJ/vmhbaWNK06NHDz300EOSbPV8n376aTVo0EA33XSTJOmRRx7RG2+8od9//11nn312qcfJz8/Xa6+9psTEREm2BVCnTp3066+/qk+fPoqKilJQUJDi4+Pt+yQnJys+Pl6DBw9WcHCwmjdvrj59+jgdNyEhQfv27ZPValVAAEnSAAAAtVYtWTOwXnCP9YL/4qoBAACUJqqRVCfB97eoRtXycm644QZ9+umnSklJ0aeffqobbrjBo/2ys7MVFhbm9rmPP/5YGzZs0Pz58/XNN9/oueee8+aUS9W9e3f7/cDAQNWvX1/dunWzbyta/Bw6ZPv2XJcuXRQVFaWoqCgNGzbMPi4oKEhnnXWW/XHHjh0VGxurrVu3lnruK6+8UtnZ2WrdurVuuukmffnllyooKHAaEx4eLqvVqtzc3Kq9UAAAAPg3M9YMrBfKxXqh9iNjAwAAoDReTu82W7du3dSxY0eNHTtWnTp1UteuXbVx48Zy92vQoIGOHz/u9rlmzZpJkjp37qzCwkLdfPPNuvvuuxUYGKj4+HilpqY6jU9NTbV/m6no39TUVDVu3NhpTM+ePcucU8lvjlksFqdtFotFkmS1WiVJ3377rfLz8yXZFhFV0axZM23fvl1LlizR4sWLddttt2nmzJlasWKFfQ7Hjh1TZGRklc8FAAAAP1eL1gysF1gv1CRkbJjNMKTCfLNnAQAAThM33HCDli9f7vG3ryTpjDPO0J9//lnuOKvVqvz8fPvioG/fvlq6dKnTmMWLF6tv376SpFatWik+Pt5pTEZGhtasWWMf4y0tWrRQ27Zt1bZtW6emhgUFBVq3bp398fbt25WWlqZOnTpJkkJCQlRYWOhyvPDwcF1yySV65ZVXtHz5cq1evVqbN2+2P//HH3/ojDPO8OprgAkK8syeAQAAgE+xXmC9UFOQsWEma6E0e6h0dLd07edSkzPNnhEAAKjlbrrpJl155ZWKjY31eJ+hQ4fqxhtvVGFhoQIDAyVJH3zwgYKDg9WtWzeFhoZq3bp1euCBBzR69Gj7t5DuvPNO9e/fX88//7yGDx+ujz76SOvWrdNbb70lyfYtqSlTpujJJ59Uu3bt1KpVKz388MNKSEjQqFGjvP3S3QoODtbtt9+uV155RUFBQZo8ebLOPvtsew3cli1bKikpSRs3blTTpk1Vp04dffjhhyosLFRiYqIiIiL0/vvvKzw8XC1atLAfd+XKlRoyZIhPXgOq0YHfpHoXmD0LAAAAn2G94Iz1gv8isGGmzZ9Jf6+13X//cmlakrnzAQAAtV5QUJAaNGhQoX2GDRumoKAgLVmyREOHDrUf55lnntGOHTtkGIZatGihyZMn66677rLvd84552j+/Pl66KGH9K9//Uvt2rXTggUL1LVrV/uY++67TydPntTNN9+stLQ09evXTwsXLiy1Rq+3RUREaNq0abr66qu1f/9+nXvuuXr33Xftz19++eX64osvNHDgQKWlpWnOnDmKjY3V008/ralTp6qwsFDdunXTV199pfr160uS9u/fr1WrVun999/3yWsAAAAAvIX1gjPWC/7LYhiGYfYkfCkjI0MxMTFKT09XdHS0uZNZ9Zr0/YPFjx9NN28uAACcxnJycpSUlKRWrVr57ANyTTNr1iz973//06JFi8yeitfMnTtXU6ZMUVpamlePO23aNB0/ftz+TbOapqz/D371Wboa2V/n5u8V3ZWMDQAAwJqhPKwXPFfT1wuSf6wZyNgw06kmNQAAAP7ulltuUVpamk6cOKE6deqYPR2/1qhRI02dOtXsaQAAAAA+w3rBc6wXvIPAhqkIbAAAgJohKChIDz74YPkDobvvvtvsKQAAAAA+xXrBc6wXvCPA7Amc1sjYAAAAMM3111/v9bRyAAAAALUD6wX/RmDDVAQ2AAAAAAAAAACoCAIbZiJjAwAAAAAAAACACiGwYSoCGwAAAAAAAAAAVASBDTORsQEAAAAAAAAAQIUQ2AAAAAAAAAAAADUGgQ0zkbEBAAAAAAAAAECFENgwFYENAABQc+Tl5alt27ZatWqV2VNBJS1cuFA9e/aU1Wo1eyoAAACoZVgv1Hw1ab1AYMNMZGwAAOD35q9J9umtoq6//npZLBbdeuutLs9NmjRJFotF119/vdP2lJQU3X777WrdurVCQ0PVrFkzXXLJJVq6dGmZ53rzzTfVqlUrnXPOOfZtTz31lM455xxFREQoNjbW7X7JyckaPny4IiIi1KhRI917770qKChwGrN8+XKdeeaZCg0NVdu2bTV37txyX/vvv/+uc889V2FhYWrWrJmeffZZlzGffvqpOnbsqLCwMHXr1k3ffvut0/OGYeiRRx5R48aNFR4ersGDB2vnzp3lnttfWCwWLViwwOPxF154oYKDg/XBBx9U36QAAABOM6wXbFgv+J/avF4gsGEqAhsAAKDqmjVrpo8++kjZ2dn2bTk5OZo/f76aN2/uNHbPnj3q1auXfvjhB82cOVObN2/WwoULNXDgQE2aNKnUcxiGoddee00TJ0502p6Xl6crr7xS//znP93uV1hYqOHDhysvL0+rVq3Se++9p7lz5+qRRx6xj0lKStLw4cM1cOBAbdy4UVOmTNGNN96oRYsWlTqfjIwMDRkyRC1atND69es1c+ZMPfroo3rrrbfsY1atWqWxY8dq4sSJ+u233zRq1CiNGjVKf/zxh33Ms88+q1deeUVvvvmm1qxZo8jISA0dOlQ5OTmlnrumu/766/XKK6+YPQ0AAAD4COsF1gsVUVPWCwQ2zETGBgAA8IIzzzxTzZo10xdffGHf9sUXX6h58+Y644wznMbedtttslgs+vXXX3X55Zerffv26tKli6ZOnapffvml1HOsX79eu3fv1vDhw522P/bYY7rrrrvUrVs3t/t9//33+vPPP/X++++rZ8+eGjZsmJ544gnNmjVLeXl5koq/2fX888+rU6dOmjx5sq644gq9+OKLpc7ngw8+UF5enmbPnq0uXbpozJgxuuOOO/TCCy/Yx7z88su68MILde+996pTp0564okndOaZZ+q1116TZFt8vfTSS3rooYc0cuRIde/eXfPmzdOBAwfK/FbTwoUL1a9fP8XGxqp+/fq6+OKLtXv3bqcxq1atUs+ePRUWFqbevXtrwYIFslgs2rhxo33MH3/8oWHDhikqKkpxcXG67rrrdOTIEfvzAwYM0B133KH77rtP9erVU3x8vB599FH78y1btpQkXXrppbJYLPbHmzZt0sCBA1WnTh1FR0erV69eWrdunX2/Sy65ROvWrXOZMwAAAGon1gusF2rjeoHAhqkIbAAAAO+44YYbNGfOHPvj2bNna8KECU5jjh07poULF2rSpEmKjIx0OUZpqeGStHLlSrVv31516tSp0LxWr16tbt26KS4uzr5t6NChysjI0JYtW+xjBg8e7LTf2qSpkQAAj+ZJREFU0KFDtXr16jKPe9555ykkJMRpn+3bt+v48eMeHTcpKUkpKSlOY2JiYpSYmFjmuU+ePKmpU6dq3bp1Wrp0qQICAnTppZfa69BmZGTokksuUbdu3bRhwwY98cQTmjZtmtMx0tLSdP755+uMM87QunXrtHDhQqWmpuqqq65yGvfee+8pMjJSa9as0bPPPqvHH39cixcvliStXbtWkjRnzhwdPHjQ/viaa65R06ZNtXbtWq1fv17333+/goOD7cds3ry54uLitHLlylJfI04xDLNnAAAA4BWsF1gv1Lb1QpDZEzitkbEBAAC85Nprr9UDDzygvXv3SpJ+/vlnffTRR1q+fLl9zK5du2QYhjp27Fjh4+/du1cJCQkV3i8lJcVpkSLJ/jglJaXMMRkZGcrOzlZ4eLjb47Zq1arU49atW7fU4zqe13E/d2Pcufzyy50ez549Ww0bNtSff/6prl27av78+bJYLHr77bcVFhamzp07a//+/brpppvs+7z22ms644wz9O9//9vpOM2aNdOOHTvUvn17SVL37t01ffp0SVK7du302muvaenSpbrgggvUsGFDSbYFZnx8vP04ycnJuvfee+0/53bt2rm8hoSEBPt7BQAAALUf6wXWC0Vqy3qBjA1TEdgAAADe0bBhQw0fPlxz587VnDlzNHz4cDVo0MBpjFGFb59nZ2crLCysqtOsFXbu3KmxY8eqdevWio6Otqd0Jyfbmjlu375d3bt3d7peffr0cTrGpk2btGzZMkVFRdlvRQsLx5Tv7t27O+3XuHFjHTp0qMz5TZ06VTfeeKMGDx6sp59+2m0KeXh4uLKysjx/0QAAAKjRWC/4DusF3yCwYSYyNgAAgBfdcMMNmjt3rt577z3dcMMNLs+3a9dOFotF27Ztq/CxGzRoYE/Zroj4+HilpqY6bSt6XPStodLGREdHu/32VVWP6/i8437uxrhzySWX6NixY3r77be1Zs0arVmzRpLsNYA9kZmZqUsuuUQbN250uu3cuVPnnXeefZxjSrgkWSwWewp7aR599FFt2bJFw4cP1w8//KDOnTvryy+/dBpz7Ngx+ze4AAAAcHpgvcB6Qao96wUCG6YisAEAALznwgsvVF5envLz8zV06FCX5+vVq6ehQ4dq1qxZOnnypMvzaWlppR77jDPO0LZt2yr8La6+fftq8+bNTt8aWrx4saKjo9W5c2f7mKVLlzrtt3jxYvXt27fM4/7444/Kz8932qdDhw6qW7euR8dt1aqV4uPjncZkZGRozZo1pZ776NGj2r59ux566CENGjRInTp1clnAdejQQZs3b1Zubq59W1E92yJnnnmmtmzZopYtW6pt27ZON3f1jEsTHByswsJCl+3t27fXXXfdpe+//16XXXaZUz3lnJwc7d6926VRJAAAAGo31gusF4rUhvUCgQ0zkbEBAAC8KDAwUFu3btWff/6pwMBAt2NmzZqlwsJC9enTR59//rl27typrVu36pVXXilzYTBw4EBlZmbaG/gVSU5O1saNG5WcnKzCwkL7N4kyMzMlSUOGDFHnzp113XXXadOmTVq0aJEeeughTZo0SaGhoZKkW2+9VX/99Zfuu+8+bdu2Ta+//ro++eQT3XXXXaXO5+qrr1ZISIgmTpyoLVu26OOPP9bLL7+sqVOn2sfceeedWrhwoZ5//nlt27ZNjz76qNatW6fJkydLsn2bacqUKXryySf1v//9T5s3b9a4ceOUkJCgUaNGuT1v3bp1Vb9+fb311lvatWuXfvjhB6dzFs3NarXq5ptv1tatW7Vo0SI999xz9nNK0qRJk3Ts2DGNHTtWa9eu1e7du7Vo0SJNmDDB7cKjNC1bttTSpUuVkpKi48ePKzs7W5MnT9by5cu1d+9e/fzzz1q7dq06depk3+eXX35RaGhomT9vAAAA1D6sF1gv1Kr1gnGaSU9PNyQZ6enpZk/FMH6bbxjTo4tvAADAFNnZ2caff/5pZGdnmz2VChs/frwxcuTIUp8fOXKkMX78eKdtBw4cMCZNmmS0aNHCCAkJMZo0aWKMGDHCWLZsWZnnuuqqq4z777/f5fySXG6Ox9qzZ48xbNgwIzw83GjQoIFx9913G/n5+U7HWbZsmdGzZ08jJCTEaN26tTFnzhyn5+fMmWOU/Oi6adMmo1+/fkZoaKjRpEkT4+mnn3aZ8yeffGK0b9/eCAkJMbp06WJ88803Ts9brVbj4YcfNuLi4ozQ0FBj0KBBxvbt28u8DosXLzY6depkhIaGGt27dzeWL19uSDK+/PJL+5iff/7Z6N69uxESEmL06tXLmD9/viHJ2LZtm33Mjh07jEsvvdSIjY01wsPDjY4dOxpTpkwxrFarYRiG0b9/f+POO+90OnfJn+f//vc/o23btkZQUJDRokULIzc31xgzZozRrFkzIyQkxEhISDAmT57s9N6++eabjVtuuaXU11fW/we/+ixdjeyv8/dFZk8FAAD4iZq6ZmC9wHrB2+sFw/CPNYPFMKrQFaYGysjIUExMjNLT0xUdHW3uZDZ9JH15S/HjR9PNmwsAAKexnJwcJSUlqVWrVjS8K8Pvv/+uCy64QLt371ZUVJRPzz19+nStWLFCy5cv9+l5veWDDz7QhAkTlJ6eXmodYF84cuSIOnTooHXr1qlVq1Zux5T1/8GvPktXI/vr/H2RorsNMXs6AADAD7BmKB/rhcqrSesFyT/WDEHVdmR4gFJUAACg5ujevbueeeYZJSUlqVu3bj4993fffafXXnvNp+esinnz5ql169Zq0qSJNm3apGnTpumqq64ydZEiSXv27NHrr79e5iIFAAAAqAzWC55jvVB1BDbMRI8NAABQw1x//fWmnPfXX3815byVlZKSokceeUQpKSlq3LixrrzySj311FNmT0u9e/dW7969zZ4GAAAAainWC55hvVB1BDZMRWADAACgNrrvvvt03333mT0NAAAAAH6I9ULVBZg9gdMaGRsAAABAhcyYMUNnnXWW6tSpo0aNGmnUqFHavn2705gBAwbIYrE43W699VaTZgwAAADA2whsAAAAnGIYhtlTAEzn7/8PVqxYoUmTJumXX37R4sWLlZ+fryFDhujkyZNO42666SYdPHjQfnv22WdNmjEAAKhN/P2zEuAL/vD/gFJUZiJjAwAAvxAcHCxJysrKMr1ZG2C2rKwsScX/L/zNwoULnR7PnTtXjRo10vr163XeeefZt0dERCg+Pt6jY+bm5io3N9f+OCMjwzuTBQAAtQZrBqCYP6wZCGyYisAGAAD+IDAwULGxsTp06JAk2x9ELXwBAacZwzCUlZWlQ4cOKTY2VoGBgWZPySPp6emSpHr16jlt/+CDD/T+++8rPj5el1xyiR5++GFFRES4PcaMGTP02GOPVftcAQBAzcWaAfCvNQOBDTPxyw8AAL9R9M3uooUKcLqKjY31ONPBbFarVVOmTNE//vEPde3a1b796quvVosWLZSQkKDff/9d06ZN0/bt2/XFF1+4Pc4DDzygqVOn2h9nZGSoWbNm1T5/AABQs7BmAGz8Yc1AYMNUBDYAAPAXlv9n787jo6rv/Y+/ZyYbSSAhhCQsYXVBVEBBYrTuVFyuW/21qG1BaumthdYWvVbaKtV6S9XWcm2p9FrXVtTautTlYjUCiiIqiCuCLBK2hDUJSSCTzJzfH5PMlslkZnJmzszk9Xw85sE5Z875zifjmEdOPvl8PjabBg0apJKSErW2tlodDmCJzMzMlKnUkKTZs2frk08+0cqVKwOOf+973/Nun3jiiRo0aJDOO+88bd68WaNHj+60TnZ2trKzs0O8gvW9gwEAQPLgngFInnsGEhtWomIDAICk43A4kuKHNADhzZkzRy+++KLeeOMNDR06NOy5FRUVkqRNmzaFTGwAAABEg3sGwHp2qwOQpEWLFmnEiBHKyclRRUWF3n333S7PPfvss2Wz2To9Lr744gRGbBYSGwAAAEA0DMPQnDlz9Oyzz+r111/XyJEju71m3bp1kqRBgwbFOToAAAAAiWB5xcZTTz2luXPnavHixaqoqNDChQs1depUbdiwQSUlJZ3Of+aZZ+R0Or37+/fv1/jx4/X1r389kWGbg4oNAAAAICqzZ8/WkiVL9Pzzz6tv376qqamRJBUUFKhPnz7avHmzlixZoosuukgDBgzQRx99pJ/85Cc688wzNW7cOIujBwAAAGAGyys27r33Xs2aNUszZ87U2LFjtXjxYuXm5uqhhx4KeX5RUZHKysq8j1dffVW5ubmpmdigYgMAAACIyv3336/6+nqdffbZGjRokPfx1FNPSZKysrL02muv6fzzz9eYMWN044036sorr9QLL7xgceQAAAAAzGJpxYbT6dSaNWs0b9487zG73a4pU6Zo1apVEa3x4IMP6qqrrlJeXl7I51taWtTS0uLdb2ho6FnQZqJiAwAAAIiKYYQf6F1eXq4VK1YkKBoAAAAAVrC0YmPfvn1yuVwqLS0NOF5aWuotKQ/n3Xff1SeffKLvfve7XZ6zYMECFRQUeB/l5eU9jts8JDYAAAAAAAAAAIiG5a2oeuLBBx/UiSeeqMmTJ3d5zrx581RfX+99bN++PYERdoOKDQAAAAAAAAAAomJpK6ri4mI5HA7V1tYGHK+trVVZWVnYa5uamvTkk0/qjjvuCHtedna2srOzexxrfJDYAAAAAAAAAAAgGpZWbGRlZWnixImqqqryHnO73aqqqlJlZWXYa59++mm1tLToW9/6VrzDjB8qNgAAAAAAAAAAiIqlFRuSNHfuXM2YMUOTJk3S5MmTtXDhQjU1NWnmzJmSpOnTp2vIkCFasGBBwHUPPvigLr/8cg0YMMCKsE1CYgMAAAAAAAAAgGhYntiYNm2a9u7dq9tuu001NTWaMGGCli5d6h0oXl1dLbs9sLBkw4YNWrlypf79739bEbJ5qNgAAAAAAAAAACAqlic2JGnOnDmaM2dOyOeWL1/e6dixxx4rwzDiHFUikNgAAAAAAAAAACAals7YAAAAAAAAAAAAiAaJDQAAAAAAAAAAkDJIbAAAAAAAAAAAgJRBYsNS6TAnBAAAAEhTaTHXDwAAAEg/JDYAAAAAAAAAAEDKILEBAAAAAAAAAABSBokNK1HaDgAAAAAAAABAVEhsAAAAAAAAAACAlEFiAwAAAAAAAAAApAwSG5aiFRUAAAAAAAAAANEgsQEAAAAAAAAAAFIGiQ0AAAAAAAAAAJAySGxYyaAVFQAAAAAAAAAA0SCxAQAAAAAAAAAAUgaJDQAAAAAAAAAAkDJIbFiKVlQAAAAAAAAAAESDxAYAAAAAAAAAAEgZJDYAAAAAAAAAAEDKILFhJYNWVAAAAAAAAAAARIPEBgAAAACExB8iAQAAAMmIxAYAAAAAAAAAAEgZJDYsxV+AAQAAAAAAAAAQDRIbAAAAAAAAAAAgZZDYAAAAAAAAAAAAKYPEhpUMWlEBAAAAAAAAABANEhsAAAAAAAAAACBlkNgAAAAAAAAAAAApg8QGAAAAAAAAAABIGSQ2LMWMDQAAAAAAAAAAokFiAwAAAAAAAAAApAwSG2lsyepqq0MAAAAAAAAAAMBUJDasZNCKCgAAAAAAAACAaJDYAAAAAAAAAAAAKYPEBgAAAAAAAAAASBkkNixFKyoAAAAAAAAAAKJBYgMAAAAAQmEmHgAAAJCUSGwAAAAAAAAAAICUQWLDSvwFGAAAAAAAAAAAUSGxAQAAAAAAAAAAUgaJDQAAAAAAAAAAkDJIbFiKVlQAAAAAAAAAAESDxAYAAAAAAAAAAEgZJDaSCcPEAQAAAAAAAAAIi8SGlYITGSQ2AAAAAAAAAAAIi8RGUiGxAQAAAAAAAABAOCQ2kgkVGwAAAAAAAAAAhEViw1LBrajc1oQBAAAAAAAAAECKILGRVKjYAAAAAAAAAAAgHBIbyYRWVAAAAAAAAAAAhEViw0rBiQxaUQEAAAAAAAAAEBaJjaRCxQYAAAAAAAAAAOFYnthYtGiRRowYoZycHFVUVOjdd98Ne35dXZ1mz56tQYMGKTs7W8ccc4xefvnlBEUbZ7SiAgAAAAAAAAAgrAwrX/ypp57S3LlztXjxYlVUVGjhwoWaOnWqNmzYoJKSkk7nO51OffWrX1VJSYn+8Y9/aMiQIdq2bZsKCwsTH3w80IoKAAAASCL84REAAACQjCxNbNx7772aNWuWZs6cKUlavHixXnrpJT300EO65ZZbOp3/0EMP6cCBA3r77beVmZkpSRoxYkQiQ44zbpwAAAAAAAAAAAjHslZUTqdTa9as0ZQpU3zB2O2aMmWKVq1aFfKaf/3rX6qsrNTs2bNVWlqqE044Qb/+9a/lcrm6fJ2WlhY1NDQEPJIWragAAAAAAAAAAAjLssTGvn375HK5VFpaGnC8tLRUNTU1Ia/ZsmWL/vGPf8jlcunll1/Wrbfeqt/97ne68847u3ydBQsWqKCgwPsoLy839eswFa2oAAAAAAAAAAAIy/Lh4dFwu90qKSnR//7v/2rixImaNm2afv7zn2vx4sVdXjNv3jzV19d7H9u3b09gxN2gQgMAAAAAAAAAgKhYNmOjuLhYDodDtbW1Acdra2tVVlYW8ppBgwYpMzNTDofDe+y4445TTU2NnE6nsrKyOl2TnZ2t7Oxsc4OPFxIdAAAAAAAAAACEZVnFRlZWliZOnKiqqirvMbfbraqqKlVWVoa85vTTT9emTZvkdvtaNm3cuFGDBg0KmdRIObSiAgAAAAAAAAAgLEtbUc2dO1cPPPCAHn30Ua1fv17XX3+9mpqaNHPmTEnS9OnTNW/ePO/5119/vQ4cOKAbbrhBGzdu1EsvvaRf//rXmj17tlVfQg8FV2hQsQEAAAAAAAAAQDiWtaKSpGnTpmnv3r267bbbVFNTowkTJmjp0qXegeLV1dWy2325l/Lycr3yyiv6yU9+onHjxmnIkCG64YYb9NOf/tSqL8FctKICAAAAAAAAACAsSxMbkjRnzhzNmTMn5HPLly/vdKyyslLvvPNOnKOyCK2oAAAAAAAAAAAIy9JWVL1epwoNKjYAAAAAAAAAAAiHxEYyoRUVAAAAAAAAAABhkdhIJrSiAgAAAAAAAAAgLBIblqIVFQAAAAAAAAAA0SCxkUxoRQUAAAAAAAAAQFgkNpIJragAAAAAAAAAAAiLxIaVOlVoULEBAAAAJA0qqgEAAICkRGIjmXDjBAAAAAAAAABAWCQ2kkkaJjaWrK62OgQAAACkkQULFuiUU05R3759VVJSossvv1wbNmwIOOfIkSOaPXu2BgwYoPz8fF155ZWqra21KGIAAAAAZiOxYan0S2QAAAAA8bRixQrNnj1b77zzjl599VW1trbq/PPPV1NTk/ecn/zkJ3rhhRf09NNPa8WKFdq1a5e+9rWvWRg1AAAAADNlWB0A/JHoAAAAAMJZunRpwP4jjzyikpISrVmzRmeeeabq6+v14IMPasmSJTr33HMlSQ8//LCOO+44vfPOOzr11FM7rdnS0qKWlhbvfkNDQ3y/CAAAAAA9QsUGAAAAgJRVX18vSSoqKpIkrVmzRq2trZoyZYr3nDFjxmjYsGFatWpVyDUWLFiggoIC76O8vDz+gQMAAACIGYkNK6XhTA0AAAAgUdxut3784x/r9NNP1wknnCBJqqmpUVZWlgoLCwPOLS0tVU1NTch15s2bp/r6eu9j+/bt8Q4dAAAAQA/QiiqZkOgAAAAAIjZ79mx98sknWrlyZY/Wyc7OVnZ2tklRAQAAAIg3KjYAAAAApJw5c+boxRdf1LJlyzR06FDv8bKyMjmdTtXV1QWcX1tbq7KysgRHCQAAACAeSGxYKrhCg4oNAAAAIBzDMDRnzhw9++yzev311zVy5MiA5ydOnKjMzExVVVV5j23YsEHV1dWqrKxMdLgAAAAA4oBWVAAAAABSxuzZs7VkyRI9//zz6tu3r3duRkFBgfr06aOCggJdd911mjt3roqKitSvXz/98Ic/VGVlpU499VSLowcAAABgBhIbyYQZGwAAAEBY999/vyTp7LPPDjj+8MMP69prr5Uk/f73v5fdbteVV16plpYWTZ06VX/6058SHCkAAACAeCGxAQAAACBlGBH8MVBOTo4WLVqkRYsWJSAiAAAAAInGjA0rUaEBAAAAAAAAAEBUSGwkFRIdAAAAAAAAAACEQ2IDAAAAAAAAAACkDBIblgqq0KA1FQAAAJBE+PkcAAAASEYkNgAAAAAAAAAAQMogsZFU+IswAAAAAAAAAADCIbFhJVpPAQAAAAAAAAAQFRIbyYREBwAAAAAAAAAAYZHYAAAAAAAAAAAAKYPEhqWo0AAAAAAAAAAAIBokNpIKiQ4AAAAAAAAAAMIhsQEAAAAAAAAAAFIGiQ0rBQ8LZ3g4AAAAAAAAAABhkdgAAAAAAAAAAAApg8RGUqFiAwAAAAAAAACAcEhsWIpEBgAAAAAAAAAA0SCxAQAAAAAAAAAAUgaJjWTC8HAAAAAAAAAAAMIisWElEhkAAAAAAAAAAESFxEZSIdEBAAAAJA3+EAkAAABISiQ2kHSWrK62OgQAAAAAAAAAQJIisWGpoL8A4y/CAAAAAAAAAAAIi8QGAAAAAAAAAABIGSQ2kgoVGwAAAAAAAAAAhENiAwAAAAAAAAAApAwSG1ZipgYAAAAAAAAAAFEhsZFMyHMAAAAAAAAAABAWiQ0AAAAAAAAAAJAySGwkFUo2AAAAAAAAAAAIh8QGAAAAAAAAAABIGSQ2kgnDxAEAAAAAAAAACIvEhpVIZAAAAAAAAAAAEJWkSGwsWrRII0aMUE5OjioqKvTuu+92ee4jjzwim80W8MjJyUlgtPFEogMAAAAAAAAAgHAsT2w89dRTmjt3rubPn6+1a9dq/Pjxmjp1qvbs2dPlNf369dPu3bu9j23btiUwYgAAAAAAAAAAYBXLExv33nuvZs2apZkzZ2rs2LFavHixcnNz9dBDD3V5jc1mU1lZmfdRWlqawIjNRIUGAAAAAAAAAADRiDqx8fDDD6u5udmUF3c6nVqzZo2mTJniC8hu15QpU7Rq1aour2tsbNTw4cNVXl6uyy67TJ9++mmX57a0tKihoSHgkbSYuQEAAAAkEX4+BwAAAJJR1ImNW265RWVlZbruuuv09ttv9+jF9+3bJ5fL1aniorS0VDU1NSGvOfbYY/XQQw/p+eef19/+9je53W6ddtpp2rFjR8jzFyxYoIKCAu+jvLy8RzEDAAAAAAAAAADrRJ3Y2Llzpx599FHt27dPZ599tsaMGaO77rqry0SE2SorKzV9+nRNmDBBZ511lp555hkNHDhQf/7zn0OeP2/ePNXX13sf27dvT0icEelUocFfhAEAAAAAAAAAEE7UiY2MjAxdccUVev7557V9+3bNmjVLjz/+uIYNG6ZLL71Uzz//vNxud0RrFRcXy+FwqLa2NuB4bW2tysrKIlojMzNTJ510kjZt2hTy+ezsbPXr1y/gAQAAAAAAAAAAUlOPhoeXlpbqK1/5iiorK2W32/Xxxx9rxowZGj16tJYvX97t9VlZWZo4caKqqqq8x9xut6qqqlRZWRlRDC6XSx9//LEGDRoU65eRPJixAQAAAAAAAABAWDElNmpra/Xb3/5Wxx9/vM4++2w1NDToxRdf1NatW7Vz50594xvf0IwZMyJaa+7cuXrggQf06KOPav369br++uvV1NSkmTNnSpKmT5+uefPmec+/44479O9//1tbtmzR2rVr9a1vfUvbtm3Td7/73Vi+FIuRyAAAAAAAAAAAIBoZ0V5wySWX6JVXXtExxxyjWbNmafr06SoqKvI+n5eXpxtvvFH33HNPROtNmzZNe/fu1W233aaamhpNmDBBS5cu9Q4Ur66ult3uy78cPHhQs2bNUk1Njfr376+JEyfq7bff1tixY6P9UgAAAAAAAAAAQIqJOrFRUlKiFStWhG0VNXDgQG3dujXiNefMmaM5c+aEfC64pdXvf/97/f73v4947dSSnBUcS1ZX65qKYVaHAQAAAAAAAABA9K2ozjrrLJ188smdjjudTj322GOSJJvNpuHDh/c8unTHTA0AAAAAAAAAAKISdWJj5syZqq+v73T80KFD3rkYiBGJDgAAAAAAAAAAwoo6sWEYhmw2W6fjO3bsUEFBgSlBAaloyepqq0MAAAAAAAAAgLQX8YyNk046STabTTabTeedd54yMnyXulwubd26VRdccEFcgkxfwRUaVGwAAAAAAAAAABBOxImNyy+/XJK0bt06TZ06Vfn5+d7nsrKyNGLECF155ZWmBwgAAAAAAAAAANAh4sTG/PnzJUkjRozQtGnTlJOTE7egei1mbAAAAAAAAAAAEFbEiY0OM2bMiEccAAAAAAAAAAAA3YoosVFUVKSNGzequLhY/fv3Dzk8vMOBAwdMCy7tUaEBAAAAAAAAAEBUIkps/P73v1ffvn292+ESG+gJEh0AAAAAAAAAAIQTUWLDv/3UtddeG69YAAAAAAAAAAAAwrJHe8HatWv18ccfe/eff/55XX755frZz34mp9NpanDpL6hCg9ZUAAAAAAAAAACEFXVi4z//8z+1ceNGSdKWLVs0bdo05ebm6umnn9bNN99seoBAsliyulpLVldbHQYAAAAAAAAA9GpRJzY2btyoCRMmSJKefvppnXXWWVqyZIkeeeQR/fOf/zQ7vl6Gig0AAAAAAAAAAMKJOrFhGIbcbrck6bXXXtNFF10kSSovL9e+ffvMjS7d0XoKAAAAAAAAAICoRJ3YmDRpku6880799a9/1YoVK3TxxRdLkrZu3arS0lLTAwQAAAAAAAAAAOgQdWJj4cKFWrt2rebMmaOf//znOuqooyRJ//jHP3TaaaeZHmCvQgUHAAAAAAAAAABhZUR7wbhx4/Txxx93On7PPffI4XCYElTvQSIDAAAAAAAAAIBoRJ3Y6OB0OrVnzx7vvI0Ow4YN63FQvReJDgAAAAAAAAAAwok6sbFx40Zdd911evvttwOOG4Yhm80ml8tlWnAAAAAAAAAAAAD+ok5szJw5UxkZGXrxxRc1aNAg2Wy2eMTVOwTP1GDGRtSWrK7WNRVUCcWC9w4AAAAAAABAKoo6sbFu3TqtWbNGY8aMiUc8AAAAAAAAAAAAXbJHe8HYsWO1b9++eMQCZmwAAAAAAAAAABBW1ImNu+66SzfffLOWL1+u/fv3q6GhIeCBaJDIAAAAAAAAAAAgGlG3opoyZYok6bzzzgs4zvBwAAAAAAAAAAAQb1EnNpYtWxaPOCBRwAEAAAAAAAAAQDeiTmycddZZ8YijdzLIZAAAAADJi5/XAQAAgGQU9YwNSXrzzTf1rW99S6eddpp27twpSfrrX/+qlStXmhpc78ONk9WWrK62OoS4SeevDQAAAAAAAEDvEXVi45///KemTp2qPn36aO3atWppaZEk1dfX69e//rXpAQIAAAAAAAAAAHSIOrFx5513avHixXrggQeUmZnpPX766adr7dq1pgaX/oIqNGhNBQAAAAAAAABAWFEnNjZs2KAzzzyz0/GCggLV1dWZEROQdmgDBQAAAAAAAADmiDqxUVZWpk2bNnU6vnLlSo0aNcqUoAAAAAAAAAAAAEKJOrExa9Ys3XDDDVq9erVsNpt27dqlxx9/XDfddJOuv/76eMSYvjq1nqIVFQAAAAAAAAAA4WREe8Ett9wit9ut8847T83NzTrzzDOVnZ2tm266ST/84Q/jESMAAAAAAAAAAICkGBIbNptNP//5z/Vf//Vf2rRpkxobGzV27Fjl5+fHI77eheHhAAAAAAAAAACEFXUrKkkyDEMNDQ0qLS3V5MmTSWoAaYIh5wAAINm98cYbuuSSSzR48GDZbDY999xzAc9fe+21stlsAY8LLrjAmmABAAAAxEVUiY2amhpNnz5d/fv3V2lpqUpKStS/f3995zvfUW1tbbxiTGPM2AAAAACi0dTUpPHjx2vRokVdnnPBBRdo9+7d3scTTzyRwAgBAAAAxFvEragaGhp02mmnqbGxUTNnztSYMWNkGIY+++wzPfHEE1q5cqXWrl1L9QYAAACAuLnwwgt14YUXhj0nOztbZWVlEa/Z0tKilpYW735DQ0PM8QEAAACIv4gTG//zP/8jh8OhTz/9VAMHDgx47he/+IVOP/103XffffrZz35mepC9BjM2AAAAgB5bvny5t7r83HPP1Z133qkBAwZ0ef6CBQt0++23JzBCAAAAAD0RcSuql156ST/72c86JTUkqaSkRPPmzdMLL7xganBpjzwGAAAAYKoLLrhAjz32mKqqqnTXXXdpxYoVuvDCC+Vyubq8Zt68eaqvr/c+tm/fnsCIAQAAAEQr4oqNjRs36rTTTuvy+dNOO0033XSTKUEBAAAAQCyuuuoq7/aJJ56ocePGafTo0Vq+fLnOO++8kNdkZ2crOzs7USECAAAA6KGIKzYaGhpUWFjY5fOFhYX0ou0xSjgAAAAAM40aNUrFxcXatGmT1aEAAAAAMEnEiQ3DMGS3d326zWaTwYyIKPF+AQAAAPG0Y8cO7d+/X4MGDYr+Yu5vAAAAgKQUcSsqwzB0zDHHyGazdfk8eige72HLISm7r/nrAgAAABZobGwMqL7YunWr1q1bp6KiIhUVFen222/XlVdeqbKyMm3evFk333yzjjrqKE2dOtXCqAEAAACYKeLExsMPPxzPOBAHp637qbT0Fek/7pUmXmt1OAAAAECPvf/++zrnnHO8+3PnzpUkzZgxQ/fff78++ugjPfroo6qrq9PgwYN1/vnn61e/+hUzNAAAAIA0EnFiY8aMGfGMo3fqVKFhYsWGs0kjdr/s2X7hBhIbAAAASAtnn3122GrxV155JYHRAAAAALBCxDM2kGJcTqsjAAAAAAAAAADAdCQ2komZMzbcbvPWAgAAAAAAAAAgSZDYsFQcB64brvitDQAAAAAAAACARUhspCs3iQ0AAAAAAAAAQPqJOrGxbNmyeMQBSaZWcFCxgThasrra6hAAAAAAAAAA9FJRJzYuuOACjR49Wnfeeae2b98ej5h6DzNnagSjYgMAAAAAAAAAkIaiTmzs3LlTc+bM0T/+8Q+NGjVKU6dO1d///nc5nc6Yg1i0aJFGjBihnJwcVVRU6N13343ouieffFI2m02XX355zK+dVMxMdFCxkTKStfohWeMCAAAAAAAA0LtFndgoLi7WT37yE61bt06rV6/WMcccox/84AcaPHiwfvSjH+nDDz+Mar2nnnpKc+fO1fz587V27VqNHz9eU6dO1Z49e8Je9+WXX+qmm27SGWecEe2X0DtQsQEAAAAAAAAASEM9Gh5+8skna968eZozZ44aGxv10EMPaeLEiTrjjDP06aefRrTGvffeq1mzZmnmzJkaO3asFi9erNzcXD300ENdXuNyufTNb35Tt99+u0aNGhV2/ZaWFjU0NAQ8kkdwhYaJFRvuNvPWAgAAAAAAAAAgScSU2GhtbdU//vEPXXTRRRo+fLheeeUV/fGPf1Rtba02bdqk4cOH6+tf/3q36zidTq1Zs0ZTpkzxBWS3a8qUKVq1alWX191xxx0qKSnRdddd1+1rLFiwQAUFBd5HeXl5ZF9kqiOxEWDJ6mpaKwEAAAAAAABAGsiI9oIf/vCHeuKJJ2QYhr797W/r7rvv1gknnOB9Pi8vT7/97W81ePDgbtfat2+fXC6XSktLA46Xlpbq888/D3nNypUr9eCDD2rdunURxTtv3jzNnTvXu9/Q0NA7khskNgAAAAAAAAAAaSjqxMZnn32mP/zhD/ra176m7OzskOcUFxdr2bJlPQ4u2KFDh/Ttb39bDzzwgIqLiyO6Jjs7u8s4LRc8LNzM4eHM2AAAAAAAAAAApKGoW1HNnz9fX//61zslC9ra2vTGG29IkjIyMnTWWWd1u1ZxcbEcDodqa2sDjtfW1qqsrKzT+Zs3b9aXX36pSy65RBkZGcrIyNBjjz2mf/3rX8rIyNDmzZuj/XLSFxUbMIF/+y5aeQEAgN7HxD88AgAAAGCaqBMb55xzjg4cONDpeH19vc4555yo1srKytLEiRNVVVXlPeZ2u1VVVaXKyspO548ZM0Yff/yx1q1b531ceumlOuecc7Ru3bo0aDHF8HAAAAAAAAAAAMKJuhWVYRiy2Wydju/fv195eXlRBzB37lzNmDFDkyZN0uTJk7Vw4UI1NTVp5syZkqTp06dryJAhWrBggXJycgLmeUhSYWGhJHU63uuR2AAAAAAAAAAApKGIExtf+9rXJEk2m03XXnttQCsql8uljz76SKeddlrUAUybNk179+7VbbfdppqaGk2YMEFLly71DhSvrq6W3R51YUmKiOeMDRIbAAAAAAAAAID0E3Fio6CgQJKnYqNv377q06eP97msrCydeuqpmjVrVkxBzJkzR3PmzAn53PLly8Ne+8gjj8T0mmnP7bY6AqSoJaurdU3FMNPOAwAAAAAAAAAzRZzYePjhhyVJI0aM0E033RRT2ykkEBUbvRpJBwAAAAAAAADpKuoeT/PnzyepYRYzW08FI7GRtpasrrY6BAAAAAAAAACwTEQVGyeffLKqqqrUv39/nXTSSSGHh3dYu3atacGhB0hsAAAAAAAAAADSUESJjcsuu8w7LPzyyy+PZzy9m6nDw13mrYVe46T192j0jmel1hulzCsjuqa7tle0xQIAAAAAAABgpogSG/Pnzw+5jZ6iFRWSyPoXdNyXj3m2X/ulxh5zQJ+NnmVtTAAAAAAAAAAQJOoZG4gnMys2SGwgCs0HpJduDDg0YeN9GrP1UYsCAgAAAAAAAIDQIqrY6N+/f9i5Gv4OHDjQo4BgEhIbiMYrP5caayVJjX2GKP/wTknSyZ//VlpdKlV8z8roAAAAAAAAAMArosTGwoUL4xxGLxU8U8PUGRskNhChL16VPlwiSXJm5OvVUx/VFVomLftvz/P/919SRpakc5mXAQAAAAAAAMByESU2ZsyYEe84YDaGhyMSRxqkF27w7q4d8186nFMqTf4vfVK9RydsfsDzxAs/VsnkB7VnwCkWBQoAAAAAAAAAHhHN2GhoaAjYDvdAkqBiA5F4bb7U4Gk7pVFna8vQKzzbNps+OvqHWj9ievuJhiZ/eofsrpaQyyxZXa0lq6sD9gEAAAAAAAAgHiJKbPTv31979uyRJBUWFqp///6dHh3HEY3g1lO0okLiFDZskN5/yLOTmSddcp/kP0vHZtMHY26Uhk6WJPVr+lLHb/mLBZECAAAAAAAAgE9Erahef/11FRUVSZKWLVsW14BgEhIb6EZx3Ye+nTPmSv2HSwqqtLDZpUv+R/rzGZK7TWM3/0Xa+x1JfRIZKgAAgDXMnIEHAAAAwDQRJTbOOuuskNswmanDw5mx0ZvEMtQ7p2W/b6f0hK5PLB0rnfYjaeW9chht0gs/lsbe70l6AAAAAAAAAECCRZTYCHbw4EE9+OCDWr9+vSRp7NixmjlzpreqAxGK51+AGSQ2EF6O0y+xkT8w/Mln3axDa59W3+btUvXbGt3vWW0uvzK+AQIAAAAAAABACFH/yfUbb7yhESNG6L777tPBgwd18OBB3XfffRo5cqTeeOONeMTYiyTnjI2M1kbJRWurdBNQsZFfGv7kzD569/hbvbsnff475bTsi1NkAAAAAAAAANC1qBMbs2fP1rRp07R161Y988wzeuaZZ7RlyxZdddVVmj17djxiRCzMSmxUv6OvvX6OtOgUqa3FnDWRFPr4JybyuqnYkFRbXKmtg/9DkpTVdkgnr78nXqEBAAAAAAAAQJeiTmxs2rRJN954oxwOh/eYw+HQ3LlztWnTJlODS39BFRrJOGPjr19ThvuIdGCL9MFfzVkTScHbiiqnQMrIjuiatWP+S+rTX5I0YvfL0u4Pu7kCAAAAAAAAAMwVdWLj5JNP9s7W8Ld+/XqNHz/elKBgArMqNlqbfNtHGsxZE0nB24oqryTia1qyi6Sz5/kOLP+NyVEBAAAAAAAAQHgRDQ//6KOPvNs/+tGPdMMNN2jTpk069dRTJUnvvPOOFi1apN/8hl9yJg0TZ2x42WzmrwlrOJuU6Wr2bHc3XyPYyTPUtOx3yjtSK214WUUDputAwfHmxwgAAAAAAAAAIUSU2JgwYYJsNpsMv1ZJN998c6fzrrnmGk2bNs286NJdp9ZTyTk8HGmocY9vO7/7+RoBMnP06ahZmvzZnZKkE79YpBWT/mRicAAAAAAAAADQtYgSG1u3bo13HDBbXBIbVGykjaa9vu0oWlF12DL0Ch2/5UHlHdmtIXvf1ICDH2p/f1rRAQAAAAAAAIi/iBIbw4cPj3cckJJzeLg/WlGlj4CKjegTG25Hlj456nuq+OR2SdK4TX/SslP+3KOQlqyu1jUVw3q0BgAAAAAAAID0F1FiI5TPPvtM1dXVcjqdAccvvfTSHgcFE9CKCuE01vq2Y0hsSNKWIZepYscjUt02Ddr3tgYeWCuJxAQAAAAAAACA+Io6sbFlyxZdccUV+vjjjwPmbtja/5rf5YpDpUDaSrUZG1RspI2gVlSxVEsY9kzprJul52dLkk7c9CdJl5sXIwAAAAAAAACEYI/2ghtuuEEjR47Unj17lJubq08//VRvvPGGJk2apOXLl8chRMQkHokNWlEl3JLV1fFZuIetqLzGXaVDueWSpLL9q6UvV8YvZgAAAAAAAABQDImNVatW6Y477lBxcbHsdrvsdru+8pWvaMGCBfrRj34UjxgRi3jM2ED6aDIpseHI0MdHXe/bX3F37GsBAAAAAAAAQASiTmy4XC717dtXklRcXKxdu3ZJ8gwY37Bhg7nRpbvgYeGmDg+nFRXC8K/YyBvYo6W2DbpQh3Lb21htXaGCQ5t6tB4AAAAAAAAAhBN1YuOEE07Qhx9+KEmqqKjQ3Xffrbfeekt33HGHRo0aZXqAiFFAYsOkhAStqNJHR2Ijp0DKyO7RUoY9QxuGX+PdP2bbkh6tBwAAAAAAAADhRJ3Y+MUvfiG32y1JuuOOO7R161adccYZevnll3XfffeZHmDvYmbFhl8rKrvDvHWRHjqGh+eXmrLcliGXqdWRK0kauetFZbbWR3Qd8zgAAAAAAAAARCsj2gumTp3q3T7qqKP0+eef68CBA+rfv79s/EV/8vBPbNjMSmzw3zctOJskZ6NnO68H8zX8tGXma8vQy3TstieU4Tqs0Tuek3SiKWsDAAAAAAAAgL+oKzb8bd++Xdu3b1dRURFJDTPEa8aGWRUb/DdOD/7zNfJ7Nl/D38ZhV3u3j9n2BAPsAQAAAAAAAMRF1ImNtrY23XrrrSooKNCIESM0YsQIFRQU6Be/+IVaW1vjESNi4Z/YsPUof4V009GGSjKtFZUkHcofKY0+z7Ps4Z3SxqWmrQ0AAAAAAAAAHaJuRfXDH/5QzzzzjO6++25VVlZKklatWqVf/vKX2r9/v+6//37Tg0xbnSo04lSxYVolCBUbacG/YiPPvIoNSVLF96XNVZ7t1X+WxlzsfapjnsY1FcPMfU0AAAAAAAAAvUrUiY0lS5boySef1IUXXug9Nm7cOJWXl+vqq68msZEsAtoAmZTYoBVVemis9W3nmzNjw+uoKTqUO0x9m6ulrSukPesl5Zn7GgAAAAAAAAB6tah7FGVnZ2vEiBGdjo8cOVJZWVlmxAQzULGBrvi3ojJpeLiX3a4Nw6/x7a/+s7nrAwAAAAAAAOj1ok5szJkzR7/61a/U0tLiPdbS0qL//u//1pw5c0wNLv0FJRziNTycig34CxgebnJiQ9KWIZep1ZHr2fnoKWW21pv+GgAAAAAAAAB6r4haUX3ta18L2H/ttdc0dOhQjR8/XpL04Ycfyul06rzzzjM/QsQmLhUbSAsRtKLqmIcRi7bMfG0ZepmO3faE1Nqs0Tuek3RizOsBAAAAAAAAgL+IEhsFBQUB+1deeWXAfnl5uXkR9WpmVmzEYcYG0kNAKyqTh4e32zjsak9iQ9KoHc9JujUurwMAAAAAAACg94kosfHwww/HO47eKZ6VFPGo2KAVVXpob0XVktlP2RnZcXmJQ/kjpfIKaftqFTZukmo/k5Qfl9cCAAAAAAAA0LtEPWOjw969e7Vy5UqtXLlSe/fu7f4CdC/ZZ2wgPbRXbBzJGhDT5eHaVAU8d8L/821/8o+YXgsAAAAAAAAAgkWd2GhqatJ3vvMdDRo0SGeeeabOPPNMDR48WNddd52am5vjESNiEZcZG1RspDxnk+RslCQdyY4tsRGx4y+XbO3fYj75p/dz2JP5HQAAAAAAAAAQdWJj7ty5WrFihV544QXV1dWprq5Ozz//vFasWKEbb7wxHjGmsXi2oorDjA1aUaW+9jZUUuwVGxHLL5FGnunZPviliuo/je/rAQAAAAAAAOgVok5s/POf/9SDDz6oCy+8UP369VO/fv100UUX6YEHHtA//kG7maQRj4qNeM4EQWL4DQ4/kl0c/9c74Urv5ojdL8f/9QAAAAAAAACkvagTG83NzSotLe10vKSkhFZUycSIQ8WG4TZnHVinsda7eTjeragk6bhL5LJlSJKG7X6FzxAAAEgt/GEPAAAAkJSiTmxUVlZq/vz5OnLkiPfY4cOHdfvtt6uystLU4NJe8I1S3IaHA+1iaEW1ZHV17HMx+vTX7oFfkSTltuzRwINrY1sHAAAAAAAAANplRHvBwoULdcEFF2jo0KEaP368JOnDDz9UTk6OXnnlFdMDRAwMo3NiwzB6PiODv7ZPfYluRSVp26ALNHTPcknSiF3/p71FkxLyugAAAAAAAADSU9SJjRNPPFFffPGFHn/8cX3++eeSpKuvvlrf/OY31adPH9MD7F3i2DKKxAakwIqNRLSikrSz5Bwpo4/UdljlNa/q/bG3JOR1AQAAAAAAAKSnqBIbra2tGjNmjF588UXNmjUrXjH1InHq2et2hThowmvRYzj1+c3YiLQVVU+1ZeRKx14gffqscloPqmz/akmjE/LaAAAAAAAAANJPVDM2MjMzA2ZrwGSmJQ5CrGPG2lRspD7/VlRZRYl73RP+n3dz+O7/S9zrAgAAAAAAAEg7UQ8Pnz17tu666y61tTGcOmmFTGKQ2IB8rahyCuV2ZPVsMHg0jpoiZ0a+JGlo7etSKwlSAAAAAAAAALGJesbGe++9p6qqKv373//WiSeeqLy8vIDnn3nmGdOCQ4y6mrHR84VNWAOW6khs5Jck9nUzc7Sj9FyN2vkvZbU1SptelY67JLExAAAAAAAAAEgLUVdsFBYW6sorr9TUqVM1ePBgFRQUBDxisWjRIo0YMUI5OTmqqKjQu+++2+W5zzzzjCZNmqTCwkLl5eVpwoQJ+utf/xrT61quU7Ihjq2oqNjo9RxtzVJrk2cnL8GJDUnbBl3k2/nknwl/fQAAAAAAAADpIeqKjYcfftjUAJ566inNnTtXixcvVkVFhRYuXKipU6dqw4YNKinp/MvXoqIi/fznP9eYMWOUlZWlF198UTNnzlRJSYmmTp1qamwpK1R1hikzNqjYSGU5zv2+nURXbEiqGTBZRzILldNaJ33xqtTWkvAYAAAAAAAAAKS+iCs23G637rrrLp1++uk65ZRTdMstt+jw4cM9DuDee+/VrFmzNHPmTI0dO1aLFy9Wbm6uHnrooZDnn3322briiit03HHHafTo0brhhhs0btw4rVy5MuT5LS0tamhoCHgkLbMSByErK6jY6O36tIRPbMRj1ob/moY9U7tKzvTsOBulL980/fUAAAAAAAAApL+IExv//d//rZ/97GfKz8/XkCFD9D//8z+aPXt2j17c6XRqzZo1mjJlii8gu11TpkzRqlWrur3eMAxVVVVpw4YNOvPMM0Oes2DBgoBWWeXl5T2K2VzxqoCgYgOd5fgnNvIGWhLDzpKzfTsblloSAwAAAAAAAIDUFnFi47HHHtOf/vQnvfLKK3ruuef0wgsv6PHHH5fbHftf8e/bt08ul0ulpaUBx0tLS1VTU9PldfX19crPz1dWVpYuvvhi/eEPf9BXv/rVkOfOmzdP9fX13sf27dtjjjf+zKrYiNOMDYaHpzSrW1FJ0u7i0+SyZUqSmj5+gWQZAAAAAAAAgKhFPGOjurpaF13kG/47ZcoU2Ww27dq1S0OHDo1LcF3p27ev1q1bp8bGRlVVVWnu3LkaNWqUzj777E7nZmdnKzs7O6HxWS9eFRu0okplARUb+aXSwcTH0JaRp9oBkzV431vKO1KjwkMbJA1PfCAAAAAAAAAAUlbEiY22tjbl5OQEHMvMzFRra2vML15cXCyHw6Ha2tqA47W1tSorK+vyOrvdrqOOOkqSNGHCBK1fv14LFiwImdhIasHJBtNmbMSpYoPERkrr07LPt5M30JLEhiTtKDlHg/e9JUkaWrtM0vnWBAIAAAAAAAAgJUWc2DAMQ9dee21A9cORI0f0/e9/X3l5ed5jzzzzTMQvnpWVpYkTJ6qqqkqXX365JM+Q8qqqKs2ZMyfiddxut1paWiI+P+2FSmwwY6PX81RHdOwMl3Y0WRLHrpKzpM/ulCQN2bPckhgAAAAAAAAApK6IExszZszodOxb3/pWjwOYO3euZsyYoUmTJmny5MlauHChmpqaNHPmTEnS9OnTNWTIEC1YsECSZxj4pEmTNHr0aLW0tOjll1/WX//6V91///09jiV9ULGBIG0tKqr/zLNdNFrKGyApvomNJaurQx5v7lMmlY2Taj7SgIbPpIZdUr/BcY0FAAAAAAAAQPqIOLHx8MMPxyWAadOmae/evbrttttUU1OjCRMmaOnSpd6B4tXV1bLbfTPOm5qa9IMf/EA7duxQnz59NGbMGP3tb3/TtGnT4hJffAUnG8xqRRUiAcGMjd5t94dyGO1t48orrI1Fko69SKr5yLO9cak06TvWxgMAAFLGG2+8oXvuuUdr1qzR7t279eyzz3qrvyVPpfn8+fP1wAMPqK6uTqeffrruv/9+HX300TG8GhXLAAAAQDKyd39K/M2ZM0fbtm1TS0uLVq9erYoK3y9ely9frkceecS7f+edd+qLL77Q4cOHdeDAAb399tspmtSIo3jN2ODGLnVtX+3bLp+c8JfvVL1x7IW+7Q3/l9hgAABASmtqatL48eO1aNGikM/ffffduu+++7R48WKtXr1aeXl5mjp1qo4cOZLgSAEAAADES8QVG0gA02ZYxGvGBhUbKcvixEYng8arObtEuS17pC0rJKc18z4AAEDqufDCC3XhhReGfM4wDC1cuFC/+MUvdNlll0mSHnvsMZWWluq5557TVVddlchQAQAAAMRJUlRs9FrxGsYdrwQEiY3UZBjS9nc929n9pIFjrI1Hkmw27Sw527PtapE2L7M0HAAAkB62bt2qmpoaTZkyxXusoKBAFRUVWrVqVZfXtbS0qKGhIeABAAAAIHmR2EgqZs3YiFfFBq2oUlLdNqmx1rM9dJJkd1gbT7sdpWf7dmhHBQAATFBTUyNJ3nl9HUpLS73PhbJgwQIVFBR4H+Xl5XGNEwAAAEDPkNhIS3GasUFiIzVtf8+3XV7Red6FRWqLJqvV0cezs3GpbIbL2oAAAECvNW/ePNXX13sf27dvtzokAAAAAGGQ2LBUvFpRmVSx4Q5qPUUrqtSUbPM12rkd2aopPs2z07xPA+o+tjYgAACQ8srKyiRJtbW1Acdra2u9z4WSnZ2tfv36BTwAAAAAJC8SG8nErIqIkAmIGNbutA4VGympPbFhyCYNmWRxMIF2dMzZkDRkT+g5G8lSYQIAAJLfyJEjVVZWpqqqKu+xhoYGrV69WpWVlRZGBgAAAMBMGVYHgHgwqWIjOLFBxUbqaWmUaj+RJNX1PUr9c/pJqjNt+Z4mHXYNPFOGbLLJ0NDa5eYEBQAA0lpjY6M2bdrk3d+6davWrVunoqIiDRs2TD/+8Y9155136uijj9bIkSN16623avDgwbr88sutCxoAAACAqUhsWKlTsiGOw8NjqtgImnnAjI3Us3ONNyG1r3CC+rcfTpYqiJbsIu0rHK+BdetU0LRFOrhN6j/c+3yyxAkAAJLH+++/r3POOce7P3fuXEnSjBkz9Mgjj+jmm29WU1OTvve976murk5f+cpXtHTpUuXk5FgVMgAAAACTkdhIR6EqK6jY6J22v+vd3Nd/go62MJSu7Br4FQ2sW+fZ2VwlTfqOpfEAAIDkdvbZZ8sI87OtzWbTHXfcoTvuuCOBUQEAAABIJGZsJJO4VkSQ2OiNdn6ywru9t3CCdYGEsXvgV3w7m6q6PhEAAAAAAAAARGLDYnFKZIRKkMSSlHAHtaJieHhqcbtVXPehZzu3WI255dbG04UD/Y6Tcgd4draskFyt1gYEAAAAAAAAIKmR2EgqZs3YoBUVJO3/QtmtDZ7t8grJZrM2nq7Y7NKo9j7ZzkPSjvesjQcAAAAAAABAUiOxkZbMGh4edA2JjdSyfbVvu/wU6+KIxFFTfNu0owIAAAAAAAAQBomNdBSyFVUsiY2gVlR0okotAYmNCuviiMToc33bm16zLg4AAAAAAAAASY/EhpU6VUSYlTkwq2KDVlSpyma4vJUPLluGNPgkiyPqRt9SHex7rGd794dS0z5r4wEAAJBM/PkcAAAAgJlIbKQjZmz0eqX7V0uHdkuSdg/8ipTZx+KIure7+LT2LUPavExLVldbGg8AAAAAAACA5ERiI6mYNTzcpIoNd1ArKnpRpYyRO1/0bm8dfImFkURu18Cv+HZoRwUAAAAAAACgCyQ2LBWvRIFZMzao2EhJziYNrfUkBpwZfbWz5CyLA+osVDXGvv4nSZl5np3Nrwd83qjeAAAAAAAAANCBxEYyMW3EhkkJCBIbqenzl5TpOixJqh50vtyObIsDiozbnimNPMOz07RHhYc2WhsQAAAAAAAAgKREYiMdharOMKVig1ZUKeHDJ72bqdKGyuuoKd7NwXtXWhgIAAAAAAAAgGRFYsNKccsTmDRjg4qN1HOoRtqyzLNdOEx7+59kbTzRGn2ud3PQvrctDAQAAAAAAABAsiKxkVTMGh4eIgHBjI3e4eN/+P47jZsm2VLsf/EBo6X+IyRJxQc/UEZbk7XxAAAAAAAAAEg6KfZbT0QkZA4jhsSG29WzNZxNGrfxPmn1/0b/2ojNR742VBp3lXVx9ER7OyqH0abS/e9aHAwAAAAAAACAZENiw1JBiQLTZlgkyYyNFXfrhM0PSP/3X9KWFdG/PqJT+5lU87EkaV/BiVLxURYHFKPR53k3B+17y8JAAAAAAAAAACQjEhvpKGQCwoLExlsLfdsbl0b/+oiOX7XGl0P+w8JAemjkGXLbMiQxZwMAAAAAAABAZyQ2kkqyzdgIakXVkxkbdkfs16Jbdner9GF7YsOeoW2DLrQ2oJ7I7usdet63ebvym6otDggAAAAAAABAMiGxYSXTWk91WjjCY90tY+LwcHtG7NeiW+U1r0mNtZ6dYy9SS1Z/awPqod3Fp3m3qdoAAAAAAAAA4I/ERjIxK9ERap2YKjaCr+lBfCQ24uroar+h4ZO/Z10gMVqyOrAqY3dxpXebAeIAAAAAAAAA/JHYSEchKytiSEq4zWxFRWIjbnZ/pJKDaz3bA4+TRnzF2nhMUNdvjJwZfSVJJQfe69lnDwAAAAAAAEBaIbFhqQS2ooqpYsPMVlTM2Iib9x7wbU/+rmSzWReLSQybQ7UDTpEk5bTWqfDQFxZHBAAAAAAAACBZkNhIKnFsRRXTjI3gig1aUSWdwwelj572bGf3k8ZdZW08JqotmuzdLt2/2sJIAABA7xWvP0QCAAAA0BMkNtJRqMoKyys2SGzExQePS22HPdvjr5ay862Nx0S1Ayq822XM2QAAAAAAAADQjsSGlYKTDWYNDw/5l2UkNtKO2y299xff/inftS6WOKjPH63DWUWSpJID70uuNosjAgAAAAAAAJAMSGyko1AJkliSJsHDw3uCxIb5NldJB7dKknYPqJQGHmNxQCaz2bRngKcdVaarSdq9ztp4AAAAAAAAACQFEhtJJdkqNoIrSnpQsQHzrV7s3dw4PH1ma/ir8Zuzoa0rrAsEAAAAAAAAQNIgsWGpOA0jDDljw4R1epLYiPRaw1BhwwbJ1Rr7a/UGezdIm17zbBcM066Ss6yNJ07852xo65vWBQIAAAAAAAAgaZDYSCZmzdgIuUwsFRtBrah6El+kba1e+bkueuv/SU9eE/tr9Qbv/Mm3fer3Zdgc1sUSR4255WrKKfPsVL8jtbVYGxAAAAAAAAAAy5HYSEsmzdgwtWIjwsTGluWefzcvi/210ly286D04ZOenay+0knftjageLLZVNs+Z0Nth6Ud73c6Zcnq6gQHBQAAAAAAAMBKJDbSUcgEhMWJjUgrNlzO9vPbYn+tNHdU9d+ltiOenZOnSzn9JHX+BX8q/sJ/yerqTnEHtqN6I8ERAQAAAAAAAEg2JDas1KmKwqxWVCZVbHRKRvQgvkgrNlwdrYaMyJMhvUlbi47Z9oRn22aXKv7T2ngSoNZvgPiej/5tYSQAAAAAAAAAkgGJjbQUKgGRKhUbraG34fHJP9XHud+zfdwlUv/h1saTAM19ytSQ6/k6B9R9JDmbLI4IAAAAAAAAgJVIbCQT04aHh0hAmDJjIwHDwztaUUm0owpmGNKqRb79yjlRL5GK7akkqXbAKZIkh9HmGSIOAAAAAAAAoNcisWEpkxIZnZZNgoqN4ERGxK2o/Ko03FRsBNi6Qqr9xLM9ZJJUPjn8+WmEORsAAAAAAAAAOpDYSCpmJTpMmrHRk4qNtpbA/VgqNlxUbHi5XdKr8337lbOti8UCe4om+Xa+fNO6QAAAAAAAAABYjsRGOgpZWWFCYiOaNVxBiY1IKjYMIzAhQisqn7WPSbvXSZIO9j1aOu5Sa+NJsCPZxVLJWM/Org+kI/XWBgQAAAAAAADAMiQ2rGTWTI1I1o3ltTq1k4qiFVWbM3A/kooNt0sByRNaUXk0H5Cqbvfuvj/2Z5Ijw8KALDLyTM+/hlsr/v28tbEAAAAAAAAAsAyJjWRiWqIjCWZsdKrYiOBaV3AyhIoNSdLrv5IOH/Rsn/h17fVvyxShVB0aHqAjsSGp9MBqCwMBAAC9Rrz+EAkAAABAj5DYSEdmVWz0aMZGDBUbwYkNZmyof/2n0vsPe3ay8qWv/sragKw0/HS5279lle4nsQEAAAAAAAD0ViQ2LBWcKDDpL8JMm7HRg1ZUsczYcAW1nurtrajcbp3y6a/l/W931k+lfoMsDclSfQp1sN8YSVL/Q194WnQBAAAAAAAA6HVIbPQWMVVsBF0T1YyNoMRGRBUbwdf08oqNDS+puP4jz3bxsdKp11sbTxLYWzTRu73itRcsjAQAAAAAAACAVUhsJBOzeviGXMeEVlTRrBHcViqiig1aUQV4+4++7fN/JTkyrYslCSxZXa09/X2JjYEH11oYDQAAAAAAAACrJEViY9GiRRoxYoRycnJUUVGhd999t8tzH3jgAZ1xxhnq37+/+vfvrylTpoQ9P6nFaxhhqMqKWF4ruMqiRxUbkQwPpxWV1473pe3veLYHHicdfX7El6bFoPAu7O1/kne75ACJDQAAAAAAAKA3sjyx8dRTT2nu3LmaP3++1q5dq/Hjx2vq1Knas2dPyPOXL1+uq6++WsuWLdOqVatUXl6u888/Xzt37kxw5PFgVqIjThUbUc3YMKFioze3onr7D77tytmSzWZdLEmkJbtI9XmjJElFDZ9JziaLIwIAAAAAAACQaJYnNu69917NmjVLM2fO1NixY7V48WLl5ubqoYceCnn+448/rh/84AeaMGGCxowZo7/85S9yu92qqqoKeX5LS4saGhoCHmkvVHVGLDmTTomNKK6NacZGcCuqXlqxcfBLaf2/JEmHswZI475hbTxJZk/RyZIku9Em7XjP4mgAAAAAAAAAJJqliQ2n06k1a9ZoypQp3mN2u11TpkzRqlWrIlqjublZra2tKioqCvn8ggULVFBQ4H2Ul5ebErs5EtiKKqaKjR60ooplEHgbFRuSpHcWe9/rjcOvljKyLQ4oueztf7JvZ1tk3ycAAAAAAAAApA9LExv79u2Ty+VSaWlpwPHS0lLV1NREtMZPf/pTDR48OCA54m/evHmqr6/3PrZv397juOPGtJkboSo2EtyKKjhJQSuqyByukz74q2c7o482DaNaI9ieIt8AcVW/bV0gAAAAAAAAACyRYXUAPfGb3/xGTz75pJYvX66cnJyQ52RnZys7u5f9xXvIJIYJiY1o1uhUsRFJYqM1/H5vsOYRydno2Z5wtVqy+lsaTjJq7jNYTTmDlHdkt7TjfdmO6YWfEwAAAAAAAKAXs7Rio7i4WA6HQ7W1tQHHa2trVVZWFvba3/72t/rNb36jf//73xo3blw8w4wf0yo0Oi1szmu5zazYiODa3l6xsWW5tOKu9h2bdOpsK6NJah1zNtTarKKG9dYGAwAAAAAAACChLE1sZGVlaeLEiQGDvzsGgVdWVnZ53d13361f/epXWrp0qSZNmpSIUFOLaTM2epDYiKlioxcnNr54VXr8G1Jrs2d/3DSp+ChrY0pi/nM2Sg6ssTASAAAAAAAAAIlmeSuquXPnasaMGZo0aZImT56shQsXqqmpSTNnzpQkTZ8+XUOGDNGCBQskSXfddZduu+02LVmyRCNGjPDO4sjPz1d+fr5lX4cpzKrgCLWOKTM2olijLSixEcuMjV7SimpI7evSKzdJ7vav99iLpUvv6/a6JaurJUnXVAyLZ3hJaU9/35yNgQfXWhgJAAAAAAAAgESzPLExbdo07d27V7fddptqamo0YcIELV261DtQvLq6Wna7r7Dk/vvvl9Pp1P/7f/8vYJ358+frl7/8ZSJDN0ECW1HFVLERlIyIqmIjuPqCio2Qdq7VGR/cKBntX+vYy6Ur/yI5Mi0NK9k15I/SkcxC5bTWeRIbbrdkt7QADQAAAAAAAECCWJ7YkKQ5c+Zozpw5IZ9bvnx5wP6XX34Z/4BSXagEhBkVG9EkR8yo2HD3goqNtxbK3pHUGDdNuuxPkiMp/rdMbjab9hadrPLa15Xd2qCXXl+mi6ecZ3VUAAAAAAAAABKAP3FOKnFsRRXL2sFVFj2q2IhkeHhQIsOV5hUbDbul9S96tvNKpEv/2OOkRkd7qt7Af87GwAO0owIAAPEQrwprAAAAAD1BYqO3SMUZG+neimrNI773ZeIMKSPL0nBSjf+cjZKDDBAHAAAAAAAAegsSG1YKThSYNjw8VHVELImNHsTnCkpsRDJjIzgZks6tqFytnsSGJLfNIU2caW08KehgvzFqdfSRJJUcWGPe/z8AAAAAAAAAkhqJjXQU6he8MVVs9KAVVVtQ9UVEFRu9qBXV+hekxhpJ0o6Sc6SCIRYHlHoMe4b2FU6QJOW27JHqtlkbEAAAAAAAAICEILGRVMz6i3OTZmx0akUVzYyNGCo2elMrqvf+4t38Ytg0CwNJbXuLfHM2tG2VdYEAAAAAAAAASBgSG5aKU+sc0yo2ghMZ0czYiKViIzixkaatqGo/k7a9JUmqzxup2gEVFgeUuvznbHS8pwAAAAAAAADSG4mNZJJsMzaCqyziXrERlMhI14qN9x7wbn4xbJpks1kYTGrbX3iiXLYMz041FRsAAAAAAABAb0BiIy3FqWKjJzM2IkpsBCVD0nHGxoEt0tq/erYz87R1yKXWxpPiXI4cHSg43rOzf5PUuEdLVldbGxQAAAAAAACAuCKxYSWzKjTitW6nxEYU6wYnKWIZHp6Orahevc33dZ36fbVm9o3oso5f1vNL+872FPm1owpRtcF7BgAAAAAAAKQXEhtJJY6tqBJescHw8E62vimtf8GznV8qfeUnMS/FL+t99gbM2XjbukAAAAAAAAAAJASJjbQUKomR4OHhwUmKWIaHB1dwBKxnSF+uVPHBdZHHZCGb4ZJe+ZnvwLm/kLIjq9ZAeHv7T/DtbH/XsjgAAAAAAAAAJAaJjWRiWgupOM3YiGadThUbEVR7RDM8vHqV9MjFOv+db0s1H0cWk4VG7vyXVPORZ6fsRGnCN60NKI20ZvZTfd4oz07Nx7IHt0EDAAAAAAAAkFYyrA4AcRCyZVQMiY1Q7aMMt2RzdH9tLBUbnZIhYRIbuz7wbe9435MsSFathzV+432+/akLJHv495BWU9HZV3iiCpq2SO5WFTWsl3S0JN5HAAAAAAAAIB1RsZFUzBomHs+KjQjnbJgxYyNcK6rWw77twwcji8kqW5arT8s+z/axF0sjz7A2njS0v3Ccd3tA3UcWRgIAAAAAAAAg3khsWMms1lOd1o34YDfr9KAVVUwzNqJoRdV2xLed7ImNTa/5tk/6lnVxpLF9fomN4vrkb00GAAAAAAAAIHYkNtKSWRUbXbSiioQZFRvhEhupUrFhGNIXr3q27ZnSyDO0ZHW1qS2SaLck1ecfpTZHH0lUbAAAAAAAAADpjsRGMjFteLhJMzZCxhPBOoYhBQ9wjiQhElyxEa4VVaIrNpoP6MSNf9SQ2te7PCWnZZ/0rx9K7/3Fd3D/Jqlum2d7eKWU3TfOgfZOhj1D+/uNlSTlH94lHaq1OCIAAAAAAAAA8cLwcEvFqxWVxTM2QiUkIqrYiGJ4eKt/YqOu+7V7atUfdeLmP8tty5DO+qpUMKTTKcdv/ou07XHPTsnxnkRGR7WGJB311fjH2YvtLxyn0oNrPDs735fGXGxtQAAAIPXFq3UsAAAAgB6hYiOpxHF4eCxrh0pGRJTYaOl8LKIZG1G0ompLcCuqvRskSXajTdq1NuQpAw+s8e2s+qPnX//5GkeT2Ign/zkb2vG+dYEAAAAAAAAAiCsSG+moJ0O/zVinzdn5WEQVG1G0ovKv2DhS1/3aPdW0z7dd80nn553NKmz8wrf/+Uue875c6bk8p1QaOCbOQfZu+wMSG+9ZFwgAAAAAAACAuCKxYaXgJIFpMzZCtaKKcOh3d9f01oqNZr/ERm2IxMbuD2UP+BoN6Z/Xed+L3QO/Itls8Y2xlzucU+JJIElq3b5GT7yz1eKIAAAAAAAAAMQDiY20ZFIrqlDJiEgSG22hEhvu7hM3nRIbEVZstDYH7sdD017fdu2nnZ/fuabzsb2fezd3FZ8R80svWV0d87W9TUfVRqarWf0aN1scDQAAAAAAAIB4ILGRVMyq2IhjK6pIdNVCqrt2VMEtrFwRVmxI8W1H5WqVjtT79g9ulVoOBZ6z02+mw4igJIY9QzUDKuIXH7z2FfjaURXXfWxhJAAAAAAAAADihcSGpcwaFh68rFkVGzG2tOqq0qK7dlRRtaIKqgqJZzuq5v2dj+1ZH7jfUbGRmSv9x0JJfm2nyk9VW2Z+vKKDH/85GwPqPrIwEgAAAAAAAADxQmIjLYVKSMSQ2AhVYRHRjI0Qw8O7Ws//ueDER9hWVEEVG/FMbPgPDu/gP2ejca9U194uavBJUvFR0nH/4Xv+6Cnxiw0BDhQcJ7fNIUkqJrEBAECv9Mtf/lI2my3gMWbMGKvDAgAAAGCiDKsDgJ94Dg+PaZ0YW1p11UIqXMVGqPZVYVtRBc3UiGvFRojERo1fYsN/vsaQkz3/nnurVL1aysiRJnxL+jQoEYO4cDn6qK7vMSpqWK+Cxs3KaG2kWgYAgF7o+OOP12uvvebdz8jgtgcAAABIJ/yEbyWzEhCd1o3jjI14VWyEuiZcK6poKzYMQ/nN26W2Mikjq/Pzb/9Beu9BlQ+fLWlW4HMhKzb8Boj7z9cYMsnz78BjpRs/l+yO9icYAJ4o+wrHqahhvWwyNKDhU9Uy3wQAgF4nIyNDZWVlVocBAAAAIE5oRZVU4pToiHXtUBUWPZqxEebakImNMK2ooqzYGPPlY7r0jYulh87vnOQxDGnZr6WDWzVh432dL+4qsdGxzg7/xMZE37Y3qYFEYs4GAAD44osvNHjwYI0aNUrf/OY3VV0d/o9MWlpa1NDQEPAAAAAAkLxIbKSjkEO/TarYiCRB0lULKbMqNgwj6sTG0dV/92zs+kBqrA188kid1NosSerbXC01Hwh83q8VVaujj2fDeUiq2ya53dKutZ4QsoulgqFh4+jOktVUdvTUvoITvdvM2QAAoPepqKjQI488oqVLl+r+++/X1q1bdcYZZ+jQoUNdXrNgwQIVFBR4H+Xl5QmMGAAAAEC0SGwkk3jOxoilYsPs4eFhZ2yEuKarBElwUkMKn9g4uM2TsOgQnLho2h+4v+uDoOd9iY09RZN8x2s/lQ5slo7US5L2F5wg2Wxdx4GEOJQ3XC2Z/SS1V2zEq+UbAABIShdeeKG+/vWva9y4cZo6dapefvll1dXV6e9//3uX18ybN0/19fXex/bt2xMYMQAAAIBokdiwVLx+4WpWxUaodXrQiipsxUaIa7paJ3i+hhQ+sbFledC5wYmNvYH77RUYXn4VGwHzGmo/DRgcvs+vBVJPULXRQza79rdXbfRxHlDe4V0WBwQAAKxUWFioY445Rps2berynOzsbPXr1y/gAQAAACB5kdhIKmZVbIRax6zh4ZG0oupqxoZJraiirdgITmx0qtgISmzsDK7Y8FV01Aw41Xf8i1elVYu8u/sLTug6BiSU/5wN2lEBANC7NTY2avPmzRo0aJDVoQAAAAAwCYmNdBRrQqLTNbG2ooqhYqOtJfRruUO8XjQVG263tHVF0LlRVmy0P9/qyFV936OkjPY5GzvelWraf2mekeOtEoD19hX6/lswQBwAgN7lpptu0ooVK/Tll1/q7bff1hVXXCGHw6Grr77a6tAAAAAAmITEhpXi1vs/jhUbkeiqhVS49bpMhoQ4HrJioy709bUfS81BMzSC9/1maEiSDu2WGvzaF7W3omrJ6i/D5pBKjgs8v/9I6Zq/qy0zP3QMSDj/JFNxPYkNAAB6kx07dujqq6/Wscceq2984xsaMGCA3nnnHQ0cODCG1ZjVBQAAACSjDKsDgB+z7ptCzsYwqxVVD4aHh52x0dU1bZKyA4+1RpHYCG5DJXXfikqSdq6V+g32DDBvrwY5klXkee7YizxVHRl9pDNvlCp/KGXmSHuZjZEsnFmFasgdrn7N29S/fr2nIigju/sLAQBAynvyySetDgEAAABAnJHYSEsmVWyESkRElNjwzcZos+cow92eiOhqZobUdWIjVCVHW4hWVC31ntd1BH2kQyU2gttWhUps7ForHfcfAW2rWjoSG2fcKI08UyoaJeXH8pd/SIT9hePUr3mbHEarVPOJNHSi1SEBAAAAAAAAMAGtqCwVnGwwa3i4WTM2Yh0e7ktSuBx+fyUfdnh4V62oQiRDQrWikqQj9YH7rUekbW97Nh15vuOdKjaCWlFJnoqNoOeOZPX3bNjt0rAKKX+glqz2VGl0/BtPiXiNdOI/Z0M73rMuEAAAAAAAAACmIrGRjkImH2JJbIRqaRVBxYbfXAyX3S+xEbYVVYjh4VLoxEaoVlRS50qM/Zu8SZBdJWf4nddFK6rMXB3OGuDZ3vWB5+tv9iU2WjoSG0gJ+wrH+XZIbAAAAAAAAABpg8RGMjFtmLhJMzZCJRWibEXV44qNkK2ofIkNt/9HODix4VfB0ZRTJmdG+3DvrmZs5A3UgYIT2q+tkw5sCWhT5Z2xgZRQ1/cYtdlzPDs73rU2GAAAAAAAAACmIbFhJdMSGcHrhko+xJLYCJVsiLIVVUDFRpikSNjh4UFafTM2jmQX+44HJzZaGnyXZOTLmVng2Wne7/e6bb4KjryB2l9wvO+5XR9ITb5zqdhILYY9UwcKxnp26qqlQ7XWBgQAAAAAAADAFCQ20lHITlQxJDZCJRuibUUVccVGFIkNv4qNwzklvuNhKjZaM/uqJauw/XidL8nin+TIG6j9wXMZwrSiMnvmBTM0zLevcLxvh6oNAAAAAAAAIC2Q2EgqcWxFFcvarlhbUcUyY8P/mqyQx738KjaawyY2fBUbzoy+asks9OwYbk9yQwpoNaW84va5DDbPfvWqwOHh2QO6jh9JaV9/v8TGdhIbAAAAAAAAQDogsWGpBLaiiuWlQrWiiqTyo6vERriKjTbf8PA2R45fDN1UbGRHWLGR4Vex4X9uQGJjoFoz+0ml7e2oaj6WDm71LUcrqpQTWLHBAHEAAAAAAAAgHZDYSCZmzdwIuU6UaxtGF62oIlinq1ZUYSs2fK/V5ugTci2vSCs2WnyJDWdmvpwdFRuSb4C4X0WG8gZ6/h12qudfwy19udK3HImNlHMku1iNfYZ4dnZ9ILV10fIMAAAAAAAAQMogsZGWQiQfok2adJWEiLoVlV9bqbAzNnzXBCQ2QrXDCqjYGOg77lehEbzfmtFXLR3DwyXfbI2gig1J0rBKv9dv/0V4Zq5c/nEhZeztP8Gz0XZEqv3Y0lgAAAAAAAAA9ByJDSt1SjYkUcVGqEqJSNfxT2wEtJUKkxTxq9gISCCEakXlV7FxJGxiw2/GRmZwK6qOio3AGRuSAhMbHXKLu4ocSS6gHRVzNgAAAAAAAICUR2IjHYWcsRFlYiPU0O6u1g7mjqViI4pWVAEVG34Jh+DERosvsdGa0VUrqhAVGwVDpMJhgWvlmZ/YWLK62vQ10RmJDQAAAAAAACC9kNhIJmbN2AhZVZHAxEZAKyr/io0YEhuhWlH5VWw4M/tKGe3nd9mKyqbWjHy1ZPm1ojocZsaG1LlqIw6JDSRGXd9jpMxczw4DxAEAAAAAAICUR2LDUmYlMoKXNWPGRleJjWhbUfW0YiP8jA2XPVvKaU9YdNWKKruvZLOrJdNv+Heoio3cAb7tjgHi3udIbKQqw54hDT7Zs1O/XWrYbW1AAAAAAAAAAHqExEY6CllVkciKDV+Swm3P9h2PsGLD1V0rKr+KDZcjJ0xio32//fmAGRsdw8Ob2ys2+hRJjgzf88NOC1wrb4CQwspP8W3voB0VAACIkGkV1QAAAADMZHliY9GiRRoxYoRycnJUUVGhd9/t+peOn376qa688kqNGDFCNptNCxcuTFygCRHHVlRRz9hwdvFEBOv4VVm0RZzY8CUwuq/YaPFd5l+x4TwU2LqqY8ZGdj/PbqZ/K6qDnn87WlH5t6GSpOJjpD5+FR5UbKS2oZN928zZAAAAAAAAAFKapYmNp556SnPnztX8+fO1du1ajR8/XlOnTtWePXtCnt/c3KxRo0bpN7/5jcrKyhIcbRzE6y/AQq4bbSuqEAkFKfoZGw6/GRuRtqLK6GbGRlt7xYbN4WkzlOOXsOhIZrS1+FpWtT/vcvSRHO2JluYDkrNZcjZ69oNnaNjtgXM2mLGR2ob6V2wwZwMAAAAAAABIZZYmNu69917NmjVLM2fO1NixY7V48WLl5ubqoYceCnn+KaeconvuuUdXXXWVsrOzQ56T0sxKdIRKPkRdsWFGKyqb3PZM3/FwFRttfomNgIHjoVpRtScsMtsTIP6JjY72Ux3zNSQpp197ODYpt8izffiArw2VFDpxMfpc33bxMV3HHsKS1dVasro6qmsQR/kDdSi33LO9a13A5w0AAAAAAABAarEsseF0OrVmzRpNmTLFF4zdrilTpmjVqlWmvU5LS4saGhoCHr2TSa2oIkmQdCQjHJkybH4fMdOGh7dXbGS0J0BCJjb85m34P9+nPbHRfEBq9BscHtyKSpImXquPjvqBdOHdgX/xHyX/BAfJDuvsKxzv2XC1SDUfWRsMAAAAAAAAgJhZltjYt2+fXC6XSktLA46XlpaqpqbGtNdZsGCBCgoKvI/y8nLT1jafWRUbJszY6LIVVQTrdFR7OLJkyOG3ZoTDwwNaUcVYsdHil9hon7EhyVex4WqR6rb5jodKbDgy9cnR10sV/+mp9kBK8yY2JOZsAAAAAAAAACnM8uHh8TZv3jzV19d7H9u3b7c6JD/xmrERql1UIltRtV9rz4i8YqNjHoakVkeu73jIio32c8NWbPi3ovJ7viOxIUl7N/i2maGR9gITG6utCwQAAAAAAABAj2RY9cLFxcVyOByqra0NOF5bW2vqYPDs7Oz0nMcRlgkVG121oookQdJVKyp3mKSIs6n9muzAgeOhEhut7a2oMiNtReVXsdHHL7Gxzz+xEaJiIwyzW0rRoir+6voeLWXmSa1NDBAHAAAAAAAAUphlFRtZWVmaOHGiqqqqvMfcbreqqqpUWVlpVVjWMm14eKh1Ym9F5bL55b+iqdhwZMmw+bWiClex4Wz0/JuVJ7f/6wVXjrhdvsRJRtetqN5Z/6XvWFcVG3vW+7ajTGzEguSFtQx7hjTkZM9Ow06pfqe1AQEAAAAAAACIiaWtqObOnasHHnhAjz76qNavX6/rr79eTU1NmjlzpiRp+vTpmjdvnvd8p9OpdevWad26dXI6ndq5c6fWrVunTZs2WfUl9IxZiYzOC/f8tfwSCm57lt86PWhFFW7GRkfFRlZ+YDLEHZTY6KjWkMJWbGS1HfIdy+6iYmPv577twuFdx4aU500qlU/2HdzBnA0AAAAAAAAgFVnWikqSpk2bpr179+q2225TTU2NJkyYoKVLl3oHildXV8tu9/1ifNeuXTrppJO8+7/97W/129/+VmeddZaWL1+e6PDjwKyKjQiSD93xSyi47FnKdDW3rx3l8PCIKzY6Eht5ctv9PpbByRC/WRy+io1C37H2xEZmq19iI6dAal8+oGKjw4RvSQVDuo4N6WOoX2Jj+3vS8VdYFwsAAAAAAACAmFia2JCkOXPmaM6cOSGfC05WjBgxQkbcqhzSSKj3KJEVG13O2OgiseF2Sa3tiZPs/PCtqGKp2PB/vk9QYqP4WOmiu7v4QpB2hp7i26ZiAwAAAAAAAEhJlraiQhDTkjYmzNgISGxk+i0TZSsqRVCx0ZHUkKSsPBn+iY3g4eEhKzY6JzYy2xp9x/xbUeUO8Ls+R/r6w1JWXqeQmIeRpvIGSEWjPdu7P5TaWqyNBwAAAAAAAEDUSGyko1DJh2iTJkGtqPwW6ua1Db+Kjaygio0ukiIdbagkKSs/qBVVUGIjZMWGX+Kio2KjtcF3zD/xMXiCNPA4T1Ljkvuk0uPDfz1IPx1zNlxOT3IDAAAAAAAAQEohsZFUzJqxYUbFhtO7GVUrKv9EhCMzshkbAYmNvMBrgltR+f+FfUfFRka2bztUxYZ/4sORKV3/tnTj59L4aeG/FqQn/3ZU22lHBQAAAAAAAKQaEhtWitu8EDNmbPgSFAEVG92t45+IcGTK7Z+kCK6+6OD0S0Jk5QXO2OjUiipExYbkq8rwDg/3rOmyZXqqM/zZ7VKf/pIibzlFa6o0Uu43QHzHe9bFAQAAAAAAACAmlg8PRxyYUbHh7mrGRneJDV+lh+xBFRtBw8M7kgXXlAVWbAS2ogoeHh5ixobkSWw01nQaHt6a2VcOmy18zOhdBh4nObI8n9U9n1kdDQAASGrx+kMkAAAAAD1BxUYyMauCI9Q6UVds+BIUrh61ovL7iEXUiio/cHi4K8qKDechydWmzPbEhjOjb/h40fs4MqTiYzzb+zczQBwAAAAAAABIMSQ2LJXAVlRRz9jwJRSimrHhX7ERPGOjy+HhUbSiCqjYCJHYkKSWBm8rqtbM/PDxoncaOMbzr+GS9m+yNhYAAAAAAAAAUSGxkVSSqGLDrwVUQMVGdzH6z9iwx1Kx0U0rKv+Kja4SGw07ZZcniULFBkIqOc63vWe9dXEAAAAAAAAAiBqJjXQUsqoi9lZUgTM2om1F1fWMDa8W/4qN/MBrXGFmbGQGzdjoUOcb9N2a0ZfB3+jMP7Gx93Pr4gAAAAAAAAAQNRIbVgquojBrxkaoJEbUMzZ8CYrAGRtRDA93ZMpQJBUb4VpRBV0TScVG3Xbf0pnxr9gIlzghqZKkOlpRSVRsAAAAAAAAACmGxEY6Cpl8iL0VVXQzNsK0ouqqYiOoFVXA8PDgVlRRV2wwYwMh9B/hS4yR2AAAAAAAAABSComNdBQq+RB1xYZ/K6oYExuOrMC2UhHN2MgPmrERODz8s+pa305XFRv1fomNBFRsIHUsWV3tqaKxO6TiYzwHD24NTJgBAAAAAAAASGokNixlVuupSNY1qRVVd+v4V1g4gis2ukiKBA8P96/YcAUmNhzuFt9OlxUbfq2oQgwPj7Y9FO2k0lTHnA3DLe3baG0sAAAAAAAAACJGYiMdharOiLZiI6AVlV+iIapWVBkRVmwEztgIHDge2Ioq21nnt+OXtOiqFRUVG+iK/5wNBogDAAAAAAAAKYPERjIxa3h4yORDtBUbvoSCy57tt0w0w8Oz5I56xkZ+UGIjsGKjX+MWz4bN4ZmT0CGn0Ld9+IBvaWZsoCslY33bzNkAAAAAAAAAUgaJDSuZlcjovHBEh8LqcsZGd62o/BIRjsyYZmzIZpPsme1x+FVsuF3q17TVs100SsrwS7j4V2z4aQ3RigqQJJVQsQEAAAAAAACkIhIbScWsig0TZmz4JSjcHUkGKYJWVP4VG5kyFEnFhqcVlcuWIWW0J1E62l/5J0oOfqmMjhkb/r+UlkInNmwONeSP7DJUZmf0cgXDpMxczzYVGwAAAAAAAEDKILGRlkyYsRHQisq/YiOaGRtBFRvdtKJqy8j1HXO0J1P8Ext7N/i2BwYnNvp1Xvesm3Ukuzh8vOi97HZp4LGe7YNfSs5mS8MBAAAAAAAAEBkSG8nEtBkbJlRsBLSi8qvY6G6dHrSianP4JTbs7df5J0r82wUFJzb821JJ2ls4XjrjpvCxAgOPa98wpH0bwp4KAAAAAAAAIDmQ2LBUnGZshEpsRJs08UtQRFexEdSKKpqKjYDEhieZ0nikxdcyKlxiQ1JD3gjv9tvjF0iOjPCx+lmyuprWVL2Rf0uzPczZAAAAAAAAAFJB5L/5RQoxo2LDVynhtkUzYyO4FZVf7ixUxYZheGdshGpFZQ9oRdX+i2ebXRpwVKel3jv+Fzqv8UW92vcyNeWWh4+zB8IlQEiOpBhvxYakvczZAAAAQcyqqAYAAABgKio2kopZrahCJB+inrHRXnnRKTkRTSuqrE4VG8G/+He4j6jj624N0YrKbrSv53ZLezd6tvuPlDJzOr107YAK6RuPam/RpPAxAh1K/BIbVGwAAAAAAAAAKYHEhpXi9RdgZszY6EhQODIlm81vmWhaUWUEJUU6X5vZ1uTdDqjYaG9FZetIbNRtk9oOe7ZDtKECYlIwVMrq69mmYgMAAAAAAABICbSiSiamJTpMmLHR0VLKnilD4ZMTIa/ruLabGRsZHckKSW2OPn5PeIaBZ7iOeF5zr99g55IxcW35RDup9Nfx3/iaimHSwGOlne9LddVSS6OUnW9xdAAAAAAAAADCoWIjHYVMPoRPbHT6ZX5H5YUjU5JfxYaMkIO2vfv+iQ1HVrczNjJczd7tgIqNolGeJdxO9W3a1u3gcCAWS1ZXBw4Q37eh65MBAAAAAAAAJAUSG5YKTjaYNWPDhIoNv1ZU0c3Y8E9sZARWe4Sq2PBPbDhyfQmSQRO8x4saPgtKbBzbXfRA5AYyZwMAAAAAAABIJSQ20pIJMzb8W1EFzNjoZp2gig3ZbFJHYiSoYsPucgbM2AgYHj54gnezqGG9tH21Z3lbhlR8TMRfBtAt/4qNPZ9ZFwcAAAAAAACAiDBjI5mYNWPDjIqNrlpRRTM8vH0AuGwOz3X+FRs1n+iKZRcqu7XBeyigFdWg8d7NobWvS83bJUn7CserNNNvFgfQU/4VG3up2AAAAAAAAACSHRUbVjJtWHjwutHP2OjEvxVVNMPDO65rv1aSZHd0vvbN3wUkNSRPKyqv/BI1Z5dIkvq2JzUkqaa4MqLwgYj1Gyxl9/Ns04oKAAAAAAAASHokNtKSGRUbXbSi6i5B4l+x4fCr2JACKzZ2r+t0aUDFhqQDBWM7nRMqsRFqmHlXQp0X6bVIUzabVNJetdGwQzrSEP58AAAAAAAAAJYisZFUzGpFZcLaHUPAHRmKrhWV34wNe3DFhl9iIyuv06UBMzYkHex3XOAJ2QU6UHB8+NcHYjHQb87G3g3WxQEAAAAAAACgWyQ2LGVyK6r9m6U37pHqQ1QgRFOx4Xb5EhiOLBm2Hrai6ri+o2LDMKSD2zpd2qliIzixMfIMGR3VHz0USZUGlRy9SIn/nI311sUBAAAAAAAAoFsMD08mPZ258bevSQe/9O66bQ7ZDb9kQqQ6VV34V2zE0IrK3v4x60h6NB+QWjq3+2lzdNOKavQ5Ujd5FSBaS1ZX6xr/ig3mbAAAAAAAAABJjYqNdOKX1JAkQ1HMxvDn9ktsODICZ2z0qBWVO2ScHdocOQH7h7NLdDiryHdg1DnhXxuIFRUbAAAAAAAAQMogsWGlTtUPPajYCFFJEdC2KdaKDUeWAj4m0SQ2HFmef4OHhx/cGvLSw9klgQdsNm0vO9+zPaxSKhoV/rWBWOWXSjmFnm0qNgAAAAAAAICkRiuqdOFs7HzMfzZGNEmToKqLgIqN7gRVe3jWaE9sHNqlc9/9rlTiS2C8N/ZnOiV7uzSsUi1Ov+qMdmvG3qKtQy7V1HPOkaKJA4iGzeap2qheJR3aJR2uk/oUWh0VAAAAAAAAgBCo2EgXR+o7HTIinY2xeZnGbHlEajnk2e+UnOimFVXddh2zbYnUsCt0Kyq/BEvZ/tXS+he8+3v7nyRd9kfppG+GDM2wObS/8EQpKzfk8+Ew/BtRCWhHRdUGAAAAAAAAkKyo2LBUULKhJ8PDj3Qexm1EUrHRuFda8g2d7HJKb7qlKb8MGgCeFbiOs0lnvT9HdneLNP7vUk6B9PfpmrRrrXRomfY0OlXid60kX8VGqJfvMzSSrw6Iv4F+iY0966Vhp1oXCwAAAAAAAIAuUbGRLkJVbPgnJLpKmmx/x5fIWPl7z7+uNt/z9kwFVGx88oyG7F2hQfvfkT54XDpUK+1a612rf8MGz3ZOgeToqNgIndg4ktlfbZn53XxhQIKUjPFtU7EBAAAAAAAAJC0qNpJKDyo2WkJUbCiCio22lhDHjvi2HRlBFRuHfNs1H0v9BgVcmulq8myMPNM3E6NhZ8iXbsz1VWvQNgqWC67YAAAAAAAAAJCUqNiwUk9aTwUL0YpKkVRsHKoJ3D98UHr3z779voMCZ3X4q/1E2rYq9HOjzvFttzaHPMVmuEJf24WO5Ee4JAgJEsRiyepqKX+glDvAc6D2U8kd3ecTAAAAAAAAQGKQ2EgmPZqxUdd5uUhmbBzaHbi/7gnpg79JkpwZ+dKk66SuEht7P5e+fDP0c6PPCXl4V/Hp3u2D/Y4LeY5EggIWGTLR82/zvoAh9wAAAAAAAACSB4mNdNFdK6qukiaNtYH7b/7Ou/nR0XOkvqVBCRI/Lqe057NOhw/1GSoVjfIdmPJLSdK2svP19vi7VJ83SoezivT5yOmh1wWsUvF93/abvzO3qgoAAAAAAACAKZixYangX5r2pGIjRGLD5l9pEWErquZ93s0dpedokqTWjLxuX95ly5TDaJUk1RRXqq//k1/5iXTyDL310SHJZtNLZzwnm+GSYefjhyQz+lxp0Hhp94dSzUfS5irpqClWRwUAAAAAAADADxUb6eJIfadDhs3htxNhK6oOWflqzvEMBm/qM8TXoqcLnxz1n1J7omLrkEs6n5Bb5BsmbrMFJDUiaTtFayokhM0mnXGjb//Ne62LBQAAAAAAAEBIJDbSRYhWVIGzMbpKbNSGPj5wTEAiQpVzunzp/QXH67PR35Vmv6sXv/Kc9vU/KaKQgaQ05hKp+BjP9ra3pOp3rI0HAAAAAAAAQAASG8mkR8PDQ7Wi6mbGRkuj5DwUer2SoMHex10qObIkSW32HDkzfM2mVp/wS091yIDRaug7OurQgaRit0un/9i3T9UGAAAAAAAAkFRIbFjJzMHEoVpRdfefN3hwuL/gxIYjQ5r+vGoGVOi943+utWNukgYcJV36R9X1GxNDwEASG/cNqaDcs/3FK1LNx9bGAwAAYBJavAIAACAdkNhIB4YhHdjc+XB3FRt+8zW2lZ0f+FxwYkOShp+m1yf/RVuHXq4t5V+TfrhGOvnbIUNasrrae9PEzRNSjiNTOu1Hvv2Vv7cuFgAAkD4+f0laOk9q3GtZCLmHa6SD2+K2fjx/9g+3diyva9Z63O8AAAAkXkb3pyDpHdgiNe/vdDggsRFqxsa6J7yb+wrHa3jNv737z+7oJ+UEnh78Azs/wCOtnfQtacVdUvM+6dNnpXN+Lg2g1RoAAIiC2y3VV0sr7pbKxkmv3iq5nFL9DmnaX2Nft80pyZAysrs+p3GvlJUnZeX6jn35lv7jja9Jb7ikGS9Iwys7XbZkdbWuqRjm9zW4pH0bpbYjWvpJjS6oPFnqW9r5msnl0q61qvjof6TNTumMuVL55MDFDUNqPqCqFa/rvOEZUp/+Up8iqU+hZHNI7jbJ2ehpmdva5LnGnuF5zp6hAXV7pa1fSvU7paa9krNRH+08pHHHHauhNW7p81LJZvecL8O3lrPJ85Aku2ct2TN0zPYGyT7Quy9HpiSbZLg0aketlFHg+frdLslweeKTzXNex/n2TA3f1SB9VibZ24/LaP/DMr9/bXYpI0fK7NP+yG3fz9VT6/bK5cjRNaeO8JzfelhqbfbEm91PysgK/3kAAADohUhsWCoo2RBra6od74U8bHe3+XbcLk87nS9elb5cKe39XGrYKckzM2NH6bmaOPYY6V8/1NaS83Q4pyS2WIB0kZUrVf5AqrpDMtzSW/8jXXqf1VEBAIBkt3eDJxGwcan0ybO+X9Drcd856//l+YV7dn7n6zvuCWw2z/Yn/5QO1Ujjr/L8snvNI9Lbf5TTlqmsi++W9m2Q+g2VJs7wJDr2fC49931p1wdS3kDpO694/v3wCem1XyrDfcSz/ut3St/8u/TRU9KmKqmuWjpcp/NthZJ9hlRyvPTFv6UP/iY17ZEkXSBJb0sqr5CGn+b5JX7rYZ1aXS29v1Ha+7m8fway8f90KHeYWjPyVJTZJrU2q61xvzLcR3SeJL0b/Vs7VZJWBR4bJ0mbpDMl6YPo1pskSZ+Ffu5USYqwG+npkvRhdK/tb1rHxqtZkqtVne4TM3OlnAK/R6EnqeJyeh5ul7a15Gn4UcdL/Ud4Wqpm5no+Dx3JlNwiKSvf87kCAABIA0mR2Fi0aJHuuece1dTUaPz48frDH/6gyZMnd3n+008/rVtvvVVffvmljj76aN1111266KKLEhixhQxDatwjHdwqbX1D2vy6VO376b4pp1R5RzyzM/o1+5WYb39HWvyVkEu+P/ZnasodqiWHh8p23ioZdvM/FlR3ICWd8l1p5UKppUFat0Q6+xap32CrowIAABGI9h4jJi2NnpawNZ9I21dLu9dJuyP8Dfe6x6XiYzx/fHRgs+cX1o17pM3LpLbDnmTFnk995//75wGXZ6lFev4HvgNvLZQKh8mofke2jl+MN+2V/nCy5xfazsbA19+2Uvp1559rilUtvXRj+Ni3r/Y82o3q4rS+zYH3AElx85nMXM7Qx1ubPQ+/VsLBhkvS7qXh13dkeSpkcgd4Eh25Re0VM/09Sbasvp5/s/t6PjPef/N91Sj29oqYrDxP9QsAAIBFLP/Z8qmnntLcuXO1ePFiVVRUaOHChZo6dao2bNigkpLOVQNvv/22rr76ai1YsED/8R//oSVLlujyyy/X2rVrdcIJJ1jwFZis5ZCnNL1uu1S/XZ+u/1TH59arZvd25R6uUT/nHs+NTght9mytO/ZGnf7hzX5HbQrVhqrN0UcH+h2nTeVf15eDL/YeD05q0FsWvVpOQXty417J3Sq9/Ufpgl9bHRUAAOhGtPcYYRmG548cDtV4qjE+e85TRdFT/3dz+OeP1Ee3XsNOqWGnQv49fnBSIxSbw/PX/d4KEw+XLUO7B35FzTmlshkuHX34Y0+VSAh7+p+sLwdfrMlDsnVg1d/Ut7laDneL2hx9lJWTrzrl6XD2QDXkj1JzTqlOGiht2latzNZDshmGhhXna1O9TW0ZuWpzeFpo2Qy3bIZLNsMlu+GSy56p5pwyTTphjJZtPSy7u019WvYos62p/Ty3bHJLklodue1r5ak1I1eSTTajTfaO9dxtfmu3yW60SYYhw+aQ2+ZQxeiBWrW1XobNLsOWIbfNLpuM9us859vdbbK7W2U32nTSkDx9VL1fstlkyCbJJsNma39dtxzuI8pwHdGY4kxt2b1PDpdn3+FuUYbrsIqzDe0/YqjN0af963crs61RWa2HlNXaoMy2Q8p0hb4XjIjLKTXWeB49ZpPyiqX8Uim/xFMVlJXvqXrObG+Blpnb+VhGjifBkpEd+G/Htj2DqhIAABARm2HE2v/IHBUVFTrllFP0xz/+UZLkdrtVXl6uH/7wh7rllls6nT9t2jQ1NTXpxRdf9B479dRTNWHCBC1evLjb12toaFBBQYHqH56mfrkW9yrdvFxqifKGJYy1x96ojSO+qav+PUky3NpWdr4Mm0Mjdv+fmrNLtL/wBJVPvEg6aoqWbLTzAyPgJ6CXtL/GvdLCE6S2I56bs6O/mtjAAABIIg3NThXMfEr19fXq16+f1eF0Kdp7jGDee4bbh6ufo8U378BCrY5ctWQVKv/wbqlgqDbnT9TAgx+oKXeIBtR9rKy2Q5Kkhtzh2jL0ctX1PVoVH9+mPs4Dcmb01bZBF2jj8KvVkDdCJ266X4P2viWH26kDBWO1cfg1OtDvOMlmV//6zzRo31vKPVKrw9kDtXXIpWruMyggltzDNSo8tFFue4Zc9hw5M/uqKWeQ2jI9rbWuqRjGHz3Fic3dqqzWQ7IbbXLZs+S2Z8qw2ZV7pFb5zTuU37xDuUdq5XC3yO52yuF2KqOtSdmt9cp21inbeVC5bfWSq8XqL6ULtvZkR7an3VZXCRDvv5me+SUAACBpJOqewdKKDafTqTVr1mjevHneY3a7XVOmTNGqVatCXrNq1SrNnTs34NjUqVP13HPPhTy/paVFLS2+H9rq6z2JhIaPXpKyU+sX+4ZsOpLZX4f7lMiZUaCyvg5JNu1paNbewgn6tOQK6fARNVzzf9Lm1/Wm+3QdyR4gx6ib5XJ4Bgt+Y0y5JKm5ebuFXwmQfBoaGrp4Jlsac5W05mGppUn64LlEhgUAQFJpaPH8TZTFfxsVViz3GF3eM9Ttj/meodWeq0x3sxr6lMvlyFFbRh+1ZPaX25Yhtz1DzsxCtWXkqM2eq8M5A+W2Z6rN0UfNOWVqzinRFcf10/OfHpBhc8iZ5bshzHI2qDUjN6DS2u5yqqjhM7Vm9FN9/kjvHzBtqnhBWa0Ncmb29f3y9/ARvTNkpjRkZmDAzZ5KjeaMcu0su8p33C2p6VDgqcrTvryTAq93GpLTc95fXv9UiJ8mZUrKlFyS5z+QW4c0QLW5A6Tc8d0vYBhyuI4ou7VB2c6D7ZUgzcpo8zwy25qU4W5WZluzHG1NGtXX0I4Djd5KF5vhVparUdkt+5XTckAOtXX/mhEzpJbDknpQmQIAACyVqHsGSxMb+/btk8vlUmlpacDx0tJSff755yGvqampCXl+TU3octoFCxbo9ttv73S8/PcRlGMnpQZJ20Icf0OSZ7DxrDBXh3sO6M34fwMAgMjt379fBQUFVocRUiz3GPG5Z+hIBnQxnbob1/bglQEAAACrxfuewfIZG/E2b968gAqPuro6DR8+XNXV1Ul7M5YuGhoaVF5eru3btyd1q4JUx/ucGLzPicN7nRi8z4nB+5w4vNeJUV9fr2HDhqmoqMjqUEzFPYM1+P82cXivE4P3OTF4nxOH9zoxeJ8Tg/c5cRJ1z2BpYqO4uFgOh0O1tbUBx2tra1VWVhbymrKysqjOz87OVnZ2dqfjBQUFfIgTpF+/frzXCcD7nBi8z4nDe50YvM+JwfucOLzXiWG3J29P+1juMbhnsBb/3yYO73Vi8D4nBu9z4vBeJwbvc2LwPidOvO8ZLL0jycrK0sSJE1VVVeU95na7VVVVpcrKypDXVFZWBpwvSa+++mqX5wMAAADoPWK5xwAAAACQWixvRTV37lzNmDFDkyZN0uTJk7Vw4UI1NTVp5kzPMLvp06dryJAhWrBggSTphhtu0FlnnaXf/e53uvjii/Xkk0/q/fff1//+7/9a+WUAAAAASBLd3WMAAAAASG2WJzamTZumvXv36rbbblNNTY0mTJigpUuXeof9VVdXB5StnHbaaVqyZIl+8Ytf6Gc/+5mOPvpoPffcczrhhBMier3s7GzNnz8/ZKk5zMV7nRi8z4nB+5w4vNeJwfucGLzPicN7nRip8j53d4/RnVT5OlMd73Pi8F4nBu9zYvA+Jw7vdWLwPicG73PiJOq9thmGYcT1FQAAAAAAAAAAAEySvFP/AAAAAAAAAAAAgpDYAAAAAAAAAAAAKYPEBgAAAAAAAAAASBkkNgAAAAAAAAAAQMpIy8TGokWLNGLECOXk5KiiokLvvvtu2POffvppjRkzRjk5OTrxxBP18ssvJyjS1LVgwQKdcsop6tu3r0pKSnT55Zdrw4YNYa955JFHZLPZAh45OTkJijg1/fKXv+z0no0ZMybsNXyeYzNixIhO77XNZtPs2bNDns/nOTJvvPGGLrnkEg0ePFg2m03PPfdcwPOGYei2227ToEGD1KdPH02ZMkVffPFFt+tG+30+3YV7n1tbW/XTn/5UJ554ovLy8jR48GBNnz5du3btCrtmLN9/eoPuPtPXXnttp/ftggsu6HZdPtOBunufQ32/ttlsuueee7pck890Z5H8PHfkyBHNnj1bAwYMUH5+vq688krV1taGXTfW7+2Jxj1DfHG/kDjcMyQG9wvxwf1C4nDPkBjcLyQO9wzxl+z3C2mX2Hjqqac0d+5czZ8/X2vXrtX48eM1depU7dmzJ+T5b7/9tq6++mpdd911+uCDD3T55Zfr8ssv1yeffJLgyFPLihUrNHv2bL3zzjt69dVX1draqvPPP19NTU1hr+vXr592797tfWzbti1BEaeu448/PuA9W7lyZZfn8nmO3XvvvRfwPr/66quSpK9//etdXsPnuXtNTU0aP368Fi1aFPL5u+++W/fdd58WL16s1atXKy8vT1OnTtWRI0e6XDPa7/O9Qbj3ubm5WWvXrtWtt96qtWvX6plnntGGDRt06aWXdrtuNN9/eovuPtOSdMEFFwS8b0888UTYNflMd9bd++z//u7evVsPPfSQbDabrrzyyrDr8pkOFMnPcz/5yU/0wgsv6Omnn9aKFSu0a9cufe1rXwu7bizf2xONe4b4434hsbhniD/uF+KD+4XE4Z4hMbhfSBzuGeIv6e8XjDQzefJkY/bs2d59l8tlDB482FiwYEHI87/xjW8YF198ccCxiooK4z//8z/jGme62bNnjyHJWLFiRZfnPPzww0ZBQUHigkoD8+fPN8aPHx/x+XyezXPDDTcYo0ePNtxud8jn+TxHT5Lx7LPPevfdbrdRVlZm3HPPPd5jdXV1RnZ2tvHEE090uU603+d7m+D3OZR3333XkGRs27aty3Oi/f7TG4V6r2fMmGFcdtllUa3DZzq8SD7Tl112mXHuueeGPYfPdPeCf56rq6szMjMzjaefftp7zvr16w1JxqpVq0KuEev39kTjniHxuF+IH+4ZrMH9gvm4X0gc7hkSg/uFxOGeITGS7X4hrSo2nE6n1qxZoylTpniP2e12TZkyRatWrQp5zapVqwLOl6SpU6d2eT5Cq6+vlyQVFRWFPa+xsVHDhw9XeXm5LrvsMn366aeJCC+lffHFFxo8eLBGjRqlb37zm6quru7yXD7P5nA6nfrb3/6m73znO7LZbF2ex+e5Z7Zu3aqampqAz2xBQYEqKiq6/MzG8n0endXX18tms6mwsDDsedF8/4HP8uXLVVJSomOPPVbXX3+99u/f3+W5fKZ7rra2Vi+99JKuu+66bs/lMx1e8M9za9asUWtra8Dnc8yYMRo2bFiXn89YvrcnGvcM1uB+Ib64Z0gs7hcSg/sFa3HPED/cLyQe9wzmSLb7hbRKbOzbt08ul0ulpaUBx0tLS1VTUxPympqamqjOR2dut1s//vGPdfrpp+uEE07o8rxjjz1WDz30kJ5//nn97W9/k9vt1mmnnaYdO3YkMNrUUlFRoUceeURLly7V/fffr61bt+qMM87QoUOHQp7P59kczz33nOrq6nTttdd2eQ6f557r+FxG85mN5fs8Ah05ckQ//elPdfXVV6tfv35dnhft9x94XHDBBXrsscdUVVWlu+66SytWrNCFF14ol8sV8nw+0z336KOPqm/fvt2WO/OZDi/Uz3M1NTXKysrq9AuN7n627jgn0msSjXuGxON+Ib64Z0g87hcSg/sF63DPED/cL1iDe4aeS8b7hYyozgZCmD17tj755JNue85VVlaqsrLSu3/aaafpuOOO05///Gf96le/ineYKenCCy/0bo8bN04VFRUaPny4/v73v0eUZUZsHnzwQV144YUaPHhwl+fweUYqam1t1Te+8Q0ZhqH7778/7Ll8/4nNVVdd5d0+8cQTNW7cOI0ePVrLly/XeeedZ2Fk6euhhx7SN7/5zW4HsvKZDi/Sn+eAWHC/EF98f0s87heQzrhniC/uF6zBPUPPJeP9QlpVbBQXF8vhcHSavF5bW6uysrKQ15SVlUV1PgLNmTNHL774opYtW6ahQ4dGdW1mZqZOOukkbdq0KU7RpZ/CwkIdc8wxXb5nfJ57btu2bXrttdf03e9+N6rr+DxHr+NzGc1nNpbv8/DouEHZtm2bXn311bB/eRVKd99/ENqoUaNUXFzc5fvGZ7pn3nzzTW3YsCHq79kSn2l/Xf08V1ZWJqfTqbq6uoDzu/vZuuOcSK9JNO4ZEov7hcTjniG+uF9IHO4XEo97hsTjfiH+uGfouWS9X0irxEZWVpYmTpyoqqoq7zG3262qqqqAv5TwV1lZGXC+JL366qtdng8PwzA0Z84cPfvss3r99dc1cuTIqNdwuVz6+OOPNWjQoDhEmJ4aGxu1efPmLt8zPs899/DDD6ukpEQXX3xxVNfxeY7eyJEjVVZWFvCZbWho0OrVq7v8zMbyfR6+G5QvvvhCr732mgYMGBD1Gt19/0FoO3bs0P79+7t83/hM98yDDz6oiRMnavz48VFfy2e6+5/nJk6cqMzMzIDP54YNG1RdXd3l5zOW7+2Jxj1DYnC/YB3uGeKL+4XE4X4hsbhnsAb3C/HHPUPskv5+IapR4yngySefNLKzs41HHnnE+Oyzz4zvfe97RmFhoVFTU2MYhmF8+9vfNm655Rbv+W+99ZaRkZFh/Pa3vzXWr19vzJ8/38jMzDQ+/vhjq76ElHD99dcbBQUFxvLly43du3d7H83Nzd5zgt/r22+/3XjllVeMzZs3G2vWrDGuuuoqIycnx/j000+t+BJSwo033mgsX77c2Lp1q/HWW28ZU6ZMMYqLi409e/YYhsHn2Wwul8sYNmyY8dOf/rTTc3yeY3Po0CHjgw8+MD744ANDknHvvfcaH3zwgbFt2zbDMAzjN7/5jVFYWGg8//zzxkcffWRcdtllxsiRI43Dhw971zj33HONP/zhD9797r7P90bh3men02lceumlxtChQ41169YFfM9uaWnxrhH8Pnf3/ae3CvdeHzp0yLjpppuMVatWGVu3bjVee+014+STTzaOPvpo48iRI941+Ex3r7vvHYZhGPX19UZubq5x//33h1yDz3T3Ivl57vvf/74xbNgw4/XXXzfef/99o7Ky0qisrAxY59hjjzWeeeYZ734k39utxj1D/HG/kDjcMyQO9wvm434hcbhnSAzuFxKHe4b4S/b7hbRLbBiGYfzhD38whg0bZmRlZRmTJ0823nnnHe9zZ511ljFjxoyA8//+978bxxxzjJGVlWUcf/zxxksvvZTgiFOPpJCPhx9+2HtO8Hv94x//2PvfpbS01LjooouMtWvXJj74FDJt2jRj0KBBRlZWljFkyBBj2rRpxqZNm7zP83k21yuvvGJIMjZs2NDpOT7PsVm2bFnI7xUd76Xb7TZuvfVWo7S01MjOzjbOO++8Tu//8OHDjfnz5wccC/d9vjcK9z5v3bq1y+/Zy5Yt864R/D539/2ntwr3Xjc3Nxvnn3++MXDgQCMzM9MYPny4MWvWrE43HHymu9fd9w7DMIw///nPRp8+fYy6urqQa/CZ7l4kP88dPnzY+MEPfmD079/fyM3NNa644gpj9+7dndbxvyaS7+3JgHuG+OJ+IXG4Z0gc7hfMx/1C4nDPkBjcLyQO9wzxl+z3C7b2xQEAAAAAAAAAAJJeWs3YAAAAAAAAAAAA6Y3EBgAAAAAAAAAASBkkNgAAAAAAAAAAQMogsQEAAAAAAAAAAFIGiQ0AAAAAAAAAAJAySGwAAAAAAAAAAICUQWIDAAAAAAAAAACkDBIbAAAAAAAAAAAgZZDYAAAAAAAAAAAAKYPEBgAAAAAAAAAASBkkNgAAAAAAAAAAQMogsQEAsMyXX34pm82mf/7znzrzzDPVp08fnXLKKaqurtabb76pU089Vbm5uTrvvPNUV1dndbgAAAAAEox7BgBAKBlWBwAA+P/t3CFOK2EYBdD7gmlKMe0CmgaBgRAEAccCKhoUhk2wia6gCbKafbCA/iEIFASFLaqmmadoXpOSPMWfCee4ueqzN3dmfq9SSpLk/v4+0+k0+/v7mUwmub29zcHBQWazWdbrdcbjcebzee7u7ipfDAAA/CSdAYBdDBsAVLNYLNLv9/Pw8JDBYJAkubq6yuPjY56fn9PtdpMk5+fn+fj4qHkqAABQgc4AwC5+RQVANaWUXF9fbwpKkry/v+fm5mZTUL6y0WhU40QAAKAinQGAXQwbAFSzWCxycXGxlZVScnl5uXlerVZ5eXnJ6enpT58HAABUpjMAsIthA4AqPj8/8/b2lrOzs032+vqa5XK5lT09PaVpmpycnNQ4EwAAqERnAOA7hg0AqiilZG9vL8fHx5vs6/+5w+FwKzs8PEyv16txJgAAUInOAMB3DBsAVFFKydHRUTqdzlb275tXX5lPygEA4PfRGQD4zp+maZraRwAAAAAAAPwPX2wAAAAAAACtYdgAAAAAAABaw7ABAAAAAAC0hmEDAAAAAABoDcMGAAAAAADQGoYNAAAAAACgNQwbAAAAAABAaxg2AAAAAACA1jBsAAAAAAAArWHYAAAAAAAAWsOwAQAAAAAAtMZfnjG73GK2cwgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [dist_normalized_market_resources_by_state]\n", + "fig, axes = plt.subplots(2, 2, figsize=(16, 12))\n", + "\n", + "midpoint_widths = np.zeros(M)\n", + "midpoint_widths[0] = dist_mGrid[1] - dist_mGrid[0]\n", + "midpoint_widths[-1] = dist_mGrid[-1] - dist_mGrid[-2]\n", + "midpoint_widths[1:-1] = 0.5 * (dist_mGrid[2:] - dist_mGrid[:-2])\n", + "\n", + "for j in range(J):\n", + " ax = axes[j // 2][j % 2]\n", + " p_j = ergodic_dist[j * M : (j + 1) * M]\n", + " mass_j = p_j.sum()\n", + " p_j_cond = p_j / mass_j if mass_j > 0 else p_j\n", + " tm_density = p_j_cond / midpoint_widths\n", + "\n", + " ax.plot(\n", + " dist_mGrid,\n", + " tm_density,\n", + " color=COLOR_TM,\n", + " linewidth=2,\n", + " label=f\"TM ({mCount} m-pts)\",\n", + " )\n", + "\n", + " in_state_j = HY[\"Mrkv\"][-1] == j\n", + " mc_m_j = HY[\"mNrm\"][-1][in_state_j]\n", + " if len(mc_m_j) > 0:\n", + " ax.hist(\n", + " mc_m_j,\n", + " bins=N_MC_BINS,\n", + " density=True,\n", + " alpha=0.4,\n", + " color=COLOR_MC,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + " )\n", + "\n", + " ax.set_title(f\"{state_names[j]} (mass = {mass_j:.4f})\", fontsize=12)\n", + " ax.set_xlabel(\"$m$\")\n", + " ax.set_xlim([0, 20])\n", + " ax.legend()\n", + "\n", + "axes[0][0].set_ylabel(\"Probability Density\")\n", + "axes[1][0].set_ylabel(\"Probability Density\")\n", + "plt.suptitle(\"Distribution of $m$ by Markov State\", fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "60faf994", + "metadata": {}, + "source": [ + "### Grid convergence" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8bb79d61", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:27.782259Z", + "iopub.status.busy": "2026-03-21T04:24:27.782113Z", + "iopub.status.idle": "2026-03-21T04:24:27.933573Z", + "shell.execute_reply": "2026-03-21T04:24:27.933177Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mCount= 50 TM Assets = 3.419640\n", + "mCount= 100 TM Assets = 3.411892\n", + "mCount= 200 TM Assets = 3.409265\n", + "mCount= 300 TM Assets = 3.408579\n", + "MC Assets = 3.405530\n" + ] + } + ], + "source": [ + "grid_sizes = [50, 100, 200, 300]\n", + "tm_assets_by_grid = []\n", + "\n", + "for mC in grid_sizes:\n", + " g = make_grid_exp_mult(ming=mMin, maxg=mMax, ng=mC, timestonest=mFac)\n", + " M_g = len(g)\n", + " N_g = M_g * J\n", + "\n", + " cP = [agent.solution[0].cFunc[j](g) for j in range(J)]\n", + " aP = [np.maximum(g - cP[j], 0.0) for j in range(J)]\n", + "\n", + " NBD = np.zeros(N_g)\n", + " for jp in range(J):\n", + " sd = IncShkDstn_list[jp]\n", + " nb_m = jump_to_grid_1D(sd.atoms[1], sd.pmv, g)\n", + " NBD[jp * M_g : (jp + 1) * M_g] = MrkvPrbsInit[jp] * nb_m\n", + "\n", + " TM_g = np.zeros((N_g, N_g))\n", + " for j in range(J):\n", + " a_g = aP[j]\n", + " LivPrb_j = LivPrb_arr[j]\n", + " for jp in range(J):\n", + " mp = MrkvArr[j, jp] # row-stochastic\n", + " if mp < 1e-15:\n", + " continue\n", + " Rfp = Rfree_arr[jp]\n", + " PGFp = PermGroFac_arr[jp]\n", + " sd = IncShkDstn_list[jp]\n", + " bN = Rfp * a_g\n", + " for i in range(M_g):\n", + " mN = bN[i] / (sd.atoms[0] * PGFp) + sd.atoms[1]\n", + " lw = jump_to_grid_1D(mN, sd.pmv, g)\n", + " TM_g[jp * M_g : (jp + 1) * M_g, j * M_g + i] += mp * LivPrb_j * lw\n", + " for i in range(M_g):\n", + " TM_g[:, j * M_g + i] += (1.0 - LivPrb_j) * NBD\n", + "\n", + " ev, evec = sp_linalg.eigs(TM_g, k=1, which=\"LM\", v0=np.ones(N_g))\n", + " ed = evec[:, 0].real\n", + " ed = ed / ed.sum()\n", + "\n", + " A_tm = sum(np.dot(aP[j], ed[j * M_g : (j + 1) * M_g]) for j in range(J))\n", + " tm_assets_by_grid.append(A_tm)\n", + " print(f\"mCount={mC:4d} TM Assets = {A_tm:.6f}\")\n", + "\n", + "print(f\"MC Assets = {MC_A:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3a0946e0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:27.936286Z", + "iopub.status.busy": "2026-03-21T04:24:27.936103Z", + "iopub.status.idle": "2026-03-21T04:24:28.045614Z", + "shell.execute_reply": "2026-03-21T04:24:28.045220Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [grid_convergence_assets]\n", + "import matplotlib.cm as cm\n", + "\n", + "orange_shades = cm.Oranges(np.linspace(0.3, 0.9, len(grid_sizes)))\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "for idx, mC in enumerate(grid_sizes):\n", + " plt.axhline(\n", + " y=tm_assets_by_grid[idx],\n", + " linestyle=\"--\",\n", + " alpha=0.8,\n", + " color=orange_shades[idx],\n", + " label=f\"TM ({mC} m-pts)\",\n", + " )\n", + "plt.axhline(y=MC_A, color=COLOR_MC, linewidth=2, label=f\"MC mean ({n_agents:,} agents)\")\n", + "plt.ylabel(\"Aggregate Assets\")\n", + "plt.title(\"Grid Convergence: Serial Unemployment Model\")\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c606b960", + "metadata": {}, + "source": [ + "## 7. Summary\n", + "\n", + "The same transition matrix code from the 2-state prototype works for the\n", + "4-state serial unemployment model with **no structural changes** — only\n", + "the parameters differ. Key observations:\n", + "\n", + "1. **Sparsity:** With degenerate income (1 shock point per state), each column\n", + " of the transition matrix has at most $2J$ non-zero entries (2 from the lottery\n", + " × $J$ possible target states). This makes the TM very sparse (~0.5% non-zero).\n", + "\n", + "2. **Unemployment distribution:** Unemployed agents accumulate at low $m$ values\n", + " because they receive zero income ($\\theta = 0$). Their distribution is\n", + " sharply peaked near $m = 0$, requiring a fine grid at the lower end.\n", + "\n", + "3. **Markov state masses:** The TM ergodic distribution's marginal over Markov\n", + " states matches the analytical stationary distribution of the 4×4 chain.\n", + "\n", + "4. **Generality of the TM code:** The loop structure\n", + " `for j in range(J): for jp in range(J): ...` handles any number of Markov\n", + " states and any state-dependent parameters without modification." + ] + }, + { + "cell_type": "markdown", + "id": "b7087bbf", + "metadata": {}, + "source": [ + "---\n", + "# Part 2: Varying PermGroFac on a 2D Grid (5-State Markov)\n", + "\n", + "This part tackles the key challenge that Part 1 avoided:\n", + "**PermGroFac != 1.0**. When permanent income growth differs across Markov\n", + "states, the distribution over permanent income levels $p$ is non-degenerate.\n", + "We must track the joint distribution over $(m, p)$, requiring a 2D transition matrix.\n" + ] + }, + { + "cell_type": "markdown", + "id": "894bb0d5", + "metadata": {}, + "source": [ + "## 1. Model Setup\n", + "\n", + "5 Markov states with persistence 0.5 and equal off-diagonal transitions.\n", + "All states share the same Rfree, LivPrb, and income process.\n", + "Only PermGroFac varies.\n", + "\n", + "**Calibration:** Starts from HARK's `init_indshk_markov` defaults with custom\n", + "overrides: `Rfree = 1.03`, `LivPrb = 0.98` (same in all states). Income\n", + "shocks use `PermShkStd = 0.1`, `TranShkStd = 0.1`, `UnempPrb = 0.05`.\n", + "The 5 Markov states differ only in `PermGroFac` (0.97 to 1.05) to illustrate\n", + "the 2D grid challenge. All parameters are chosen for pedagogical clarity." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "19940224", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:28.048290Z", + "iopub.status.busy": "2026-03-21T04:24:28.048010Z", + "iopub.status.idle": "2026-03-21T04:24:28.052650Z", + "shell.execute_reply": "2026-03-21T04:24:28.052200Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Markov transition matrix (row-stochastic):\n", + "[[0.5 0.125 0.125 0.125 0.125]\n", + " [0.125 0.5 0.125 0.125 0.125]\n", + " [0.125 0.125 0.5 0.125 0.125]\n", + " [0.125 0.125 0.125 0.5 0.125]\n", + " [0.125 0.125 0.125 0.125 0.5 ]]\n", + "Row sums: [1. 1. 1. 1. 1.]\n", + "Stationary distribution: [0.2 0.2 0.2 0.2 0.2]\n" + ] + } + ], + "source": [ + "J = 5\n", + "Persistence = 0.5\n", + "PermGroFac_vals = np.array([0.97, 0.99, 1.01, 1.03, 1.05])\n", + "state_names = [f\"PermGroFac={g:.2f}\" for g in PermGroFac_vals]\n", + "\n", + "# Row-stochastic Markov matrix: MrkvArray[i,j] = P(go to j | in i)\n", + "MrkvArray = np.zeros((J, J))\n", + "for j_from in range(J):\n", + " for j_to in range(J):\n", + " if j_from == j_to:\n", + " MrkvArray[j_from, j_to] = Persistence\n", + " else:\n", + " MrkvArray[j_from, j_to] = (1.0 - Persistence) / (J - 1)\n", + "\n", + "print(\"Markov transition matrix (row-stochastic):\")\n", + "print(np.array2string(MrkvArray, precision=3))\n", + "print(f\"Row sums: {MrkvArray.sum(axis=1)}\")\n", + "\n", + "eigvals, eigvecs = np.linalg.eig(MrkvArray.T)\n", + "idx = np.argmin(np.abs(eigvals - 1.0))\n", + "markov_stationary = eigvecs[:, idx].real\n", + "markov_stationary = markov_stationary / markov_stationary.sum()\n", + "print(f\"Stationary distribution: {markov_stationary}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f7f006ad", + "metadata": {}, + "source": [ + "## 2. Solve the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f7cc42f3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:28.054815Z", + "iopub.status.busy": "2026-03-21T04:24:28.054683Z", + "iopub.status.idle": "2026-03-21T04:24:28.060981Z", + "shell.execute_reply": "2026-03-21T04:24:28.060608Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Income shocks: 30 shock points\n", + "Perm shock range: [0.866, 1.146]\n", + "Tran shock range: [0.300, 1.188]\n" + ] + } + ], + "source": [ + "# Build income distribution: standard lognormal + unemployment, same for all states\n", + "from HARK.Calibration.Income.IncomeProcesses import (\n", + " construct_lognormal_income_process_unemployment,\n", + ")\n", + "\n", + "base_dstn_list = construct_lognormal_income_process_unemployment(\n", + " T_cycle=1,\n", + " PermShkStd=[0.1],\n", + " PermShkCount=5,\n", + " TranShkStd=[0.1],\n", + " TranShkCount=5,\n", + " T_retire=0,\n", + " UnempPrb=0.05,\n", + " IncUnemp=0.3,\n", + " UnempPrbRet=None,\n", + " IncUnempRet=None,\n", + " RNG=np.random.default_rng(0),\n", + ")\n", + "base_dstn = base_dstn_list[0]\n", + "\n", + "# Replicate for J states (same income process in all states)\n", + "IncShkDstn_J = [base_dstn] * J\n", + "\n", + "print(f\"Income shocks: {len(base_dstn.atoms[0])} shock points\")\n", + "print(\n", + " f\"Perm shock range: [{base_dstn.atoms[0].min():.3f}, {base_dstn.atoms[0].max():.3f}]\"\n", + ")\n", + "print(\n", + " f\"Tran shock range: [{base_dstn.atoms[1].min():.3f}, {base_dstn.atoms[1].max():.3f}]\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "20f1415f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:28.063163Z", + "iopub.status.busy": "2026-03-21T04:24:28.062805Z", + "iopub.status.idle": "2026-03-21T04:24:28.277356Z", + "shell.execute_reply": "2026-03-21T04:24:28.276982Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solved: 5 consumption functions\n", + "PermGroFac used: [0.97 0.99 1.01 1.03 1.05]\n" + ] + } + ], + "source": [ + "# Set up the Markov agent\n", + "params = copy(init_indshk_markov)\n", + "params[\"cycles\"] = 0\n", + "params[\"AgentCount\"] = 50000\n", + "params[\"T_sim\"] = 1200\n", + "params[\"Rfree\"] = [np.array(J * [1.03])]\n", + "params[\"LivPrb\"] = [np.array(J * [0.98])]\n", + "params[\"PermGroFac\"] = [PermGroFac_vals]\n", + "params[\"MrkvPrbsInit\"] = markov_stationary\n", + "params[\"Mrkv_p11\"] = [0.5] # placeholder, overridden below\n", + "params[\"Mrkv_p22\"] = [0.5]\n", + "params[\"global_markov\"] = False\n", + "\n", + "agent = MarkovConsumerType(**params)\n", + "agent.assign_parameters(MrkvArray=[MrkvArray])\n", + "agent.IncShkDstn = [IncShkDstn_J]\n", + "agent.solution_terminal = make_markov_solution_terminal(agent.CRRA, agent.MrkvArray)\n", + "\n", + "agent.solve()\n", + "print(f\"Solved: {len(agent.solution[0].cFunc)} consumption functions\")\n", + "print(f\"PermGroFac used: {agent.PermGroFac[0]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "818089b6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:28.279189Z", + "iopub.status.busy": "2026-03-21T04:24:28.279055Z", + "iopub.status.idle": "2026-03-21T04:24:28.384008Z", + "shell.execute_reply": "2026-03-21T04:24:28.383586Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [consumption_functions_by_state]\n", + "m_plot = np.linspace(0.01, 10, 200)\n", + "\n", + "plt.figure(figsize=(12, 7))\n", + "cmap = plt.cm.coolwarm\n", + "for j in range(J):\n", + " c_vals = agent.solution[0].cFunc[j](m_plot)\n", + " color = cmap(j / (J - 1))\n", + " plt.plot(m_plot, c_vals, label=state_names[j], linewidth=2, color=color)\n", + "plt.plot(m_plot, m_plot, \":\", color=\"gray\", alpha=0.4, label=\"45° line\")\n", + "plt.xlabel(\"Market resources $m$\", fontsize=12)\n", + "plt.ylabel(\"Consumption $c$\", fontsize=12)\n", + "plt.title(\"Consumption Functions by Permanent Growth State\", fontsize=13)\n", + "plt.legend(fontsize=10)\n", + "plt.xlim([0, 10])\n", + "plt.ylim([0, 5])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "75d656d2", + "metadata": {}, + "source": [ + "## 3. Monte Carlo Simulation\n", + "\n", + "YAML-backed Monte Carlo: **`initialize_sym()`** / **`symulate()`** / **`hystory`** (see `Transition_Matrix_Example.ipynb`).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0e4f0970", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:28.386451Z", + "iopub.status.busy": "2026-03-21T04:24:28.386169Z", + "iopub.status.idle": "2026-03-21T04:24:46.360671Z", + "shell.execute_reply": "2026-03-21T04:24:46.359768Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC simulation: 17.80s (50,000 agents, 1200 periods)\n", + "MC Aggregate Consumption (level) = 2.049154\n", + "MC Aggregate Assets (level) = 1.082107\n", + "MC Aggregate Consumption (norm) = 1.005128\n", + "MC Aggregate Assets (norm) = 0.545663\n", + "\n", + "PermGroFac=0.97 : MC frac = 0.2001, stat = 0.2000\n", + "PermGroFac=0.99 : MC frac = 0.2014, stat = 0.2000\n", + "PermGroFac=1.01 : MC frac = 0.2001, stat = 0.2000\n", + "PermGroFac=1.03 : MC frac = 0.2026, stat = 0.2000\n", + "PermGroFac=1.05 : MC frac = 0.1959, stat = 0.2000\n" + ] + } + ], + "source": [ + "agent.track_vars = [\"aNrm\", \"cNrm\", \"mNrm\", \"pLvl\", \"Mrkv\"]\n", + "\n", + "t0_mc = time.time()\n", + "agent.initialize_sym()\n", + "agent.symulate()\n", + "mc_sim_time = time.time() - t0_mc\n", + "n_agents = agent.AgentCount\n", + "\n", + "HY = agent.hystory\n", + "t_last = -1\n", + "mc_cNrm_last = HY[\"mNrm\"][t_last] - HY[\"aNrm\"][t_last]\n", + "MC_C = np.mean(mc_cNrm_last * HY[\"pLvl\"][t_last])\n", + "MC_A = np.mean(HY[\"aNrm\"][t_last] * HY[\"pLvl\"][t_last])\n", + "MC_C_nrm = np.mean(mc_cNrm_last)\n", + "MC_A_nrm = np.mean(HY[\"aNrm\"][t_last])\n", + "\n", + "print(f\"MC simulation: {mc_sim_time:.2f}s ({n_agents:,} agents, {agent.T_sim} periods)\")\n", + "print(f\"MC Aggregate Consumption (level) = {MC_C:.6f}\")\n", + "print(f\"MC Aggregate Assets (level) = {MC_A:.6f}\")\n", + "print(f\"MC Aggregate Consumption (norm) = {MC_C_nrm:.6f}\")\n", + "print(f\"MC Aggregate Assets (norm) = {MC_A_nrm:.6f}\")\n", + "print()\n", + "for j in range(J):\n", + " frac = np.mean(HY[\"Mrkv\"][t_last] == j)\n", + " print(\n", + " f\"{state_names[j]:20s}: MC frac = {frac:.4f}, stat = {markov_stationary[j]:.4f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "eb47ce78", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:46.365176Z", + "iopub.status.busy": "2026-03-21T04:24:46.364928Z", + "iopub.status.idle": "2026-03-21T04:24:46.601429Z", + "shell.execute_reply": "2026-03-21T04:24:46.600683Z" + } + }, + "outputs": [], + "source": [ + "mc_aLvls = np.array(\n", + " [\n", + " np.mean(agent.hystory[\"aNrm\"][t] * agent.hystory[\"pLvl\"][t])\n", + " for t in range(agent.T_sim)\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4963d6b1", + "metadata": {}, + "source": [ + "## 4. Transition Matrix with 2D Grid\n", + "\n", + "The state is now $(m, p, j)$ where $m$ is normalized market resources,\n", + "$p$ is the permanent income level, and $j$ is the Markov state.\n", + "\n", + "The grid has $M \\times P$ points for each Markov state, giving\n", + "$M \\times P \\times J$ total states. We use `jump_to_grid_2D` to\n", + "distribute probability mass in the $(m, p)$ plane.\n", + "\n", + "**Indexing:** State $(m_i, p_k, j)$ maps to index `j * (M * P) + i * P + k`." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "0f71af9f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:46.604624Z", + "iopub.status.busy": "2026-03-21T04:24:46.604375Z", + "iopub.status.idle": "2026-03-21T04:24:46.609626Z", + "shell.execute_reply": "2026-03-21T04:24:46.609125Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m-grid: 80 points from 0.0010 to 30.0\n", + "p-grid: 25 points from 0.10 to 5.00\n", + "Per-state grid: 80 × 25 = 2000\n", + "Total TM states: 10000 (5 states × 2000)\n", + "TM memory: 800.0 MB\n" + ] + } + ], + "source": [ + "mMin, mMax, mCount, mFac = 0.001, 30, 80, 3\n", + "pMin, pMax, pCount = 0.1, 5.0, 25\n", + "\n", + "dist_mGrid = make_grid_exp_mult(ming=mMin, maxg=mMax, ng=mCount, timestonest=mFac)\n", + "dist_pGrid = make_grid_exp_mult(ming=pMin, maxg=pMax, ng=pCount, timestonest=1)\n", + "\n", + "M = len(dist_mGrid)\n", + "P = len(dist_pGrid)\n", + "MP = M * P\n", + "N_states = MP * J\n", + "\n", + "print(f\"m-grid: {M} points from {dist_mGrid[0]:.4f} to {dist_mGrid[-1]:.1f}\")\n", + "print(f\"p-grid: {P} points from {dist_pGrid[0]:.2f} to {dist_pGrid[-1]:.2f}\")\n", + "print(f\"Per-state grid: {M} × {P} = {MP}\")\n", + "print(f\"Total TM states: {N_states} ({J} states × {MP})\")\n", + "print(f\"TM memory: {N_states**2 * 8 / 1e6:.1f} MB\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "73397ed0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:46.613003Z", + "iopub.status.busy": "2026-03-21T04:24:46.612321Z", + "iopub.status.idle": "2026-03-21T04:24:48.298133Z", + "shell.execute_reply": "2026-03-21T04:24:48.297664Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transition matrix built in 1.7s\n", + "Shape: (10000, 10000)\n", + "Column sums: min=1.00000000, max=1.00000000\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "\n", + "MrkvArr = agent.MrkvArray[0]\n", + "Rfree_arr = agent.Rfree[0]\n", + "LivPrb_arr = agent.LivPrb[0]\n", + "PermGroFac_arr = agent.PermGroFac[0]\n", + "IncShkDstn_list = agent.IncShkDstn[0]\n", + "\n", + "# Policy on m-grid (consumption function depends on m, not p)\n", + "cPol = []\n", + "aPol = []\n", + "for j in range(J):\n", + " c_j = agent.solution[0].cFunc[j](dist_mGrid)\n", + " a_j = np.maximum(dist_mGrid - c_j, 0.0)\n", + " cPol.append(c_j)\n", + " aPol.append(a_j)\n", + "\n", + "# Newborn distribution: a=0, p=1.0, Markov state from stationary\n", + "MrkvPrbsInit = markov_stationary\n", + "NewBornDist = np.zeros(N_states)\n", + "for jp in range(J):\n", + " shk_dstn = IncShkDstn_list[jp]\n", + " tran_shks = shk_dstn.atoms[1]\n", + " perm_shks = shk_dstn.atoms[0]\n", + " # Newborn: m = tran_shk, p = 1.0 (for all shock realizations)\n", + " newborn_2d = jump_to_grid_2D(\n", + " tran_shks, np.ones_like(tran_shks), shk_dstn.pmv, dist_mGrid, dist_pGrid\n", + " )\n", + " NewBornDist[jp * MP : (jp + 1) * MP] = MrkvPrbsInit[jp] * newborn_2d\n", + "\n", + "# Build transition matrix\n", + "TranMatrix = np.zeros((N_states, N_states))\n", + "\n", + "for j in range(J):\n", + " LivPrb_j = LivPrb_arr[j]\n", + "\n", + " for jp in range(J):\n", + " markov_prob = MrkvArr[j, jp] # row-stochastic\n", + " if markov_prob < 1e-15:\n", + " continue\n", + "\n", + " Rfree_jp = Rfree_arr[jp]\n", + " PermGroFac_jp = PermGroFac_arr[jp]\n", + " shk_dstn = IncShkDstn_list[jp]\n", + " shk_prbs = shk_dstn.pmv\n", + " perm_shks = shk_dstn.atoms[0]\n", + " tran_shks = shk_dstn.atoms[1]\n", + "\n", + " for i in range(M):\n", + " bNext_i = Rfree_jp * aPol[j][i]\n", + " mNext_shks = bNext_i / (perm_shks * PermGroFac_jp) + tran_shks\n", + "\n", + " for k in range(P):\n", + " pNext_shks = dist_pGrid[k] * perm_shks * PermGroFac_jp\n", + "\n", + " lottery_2d = jump_to_grid_2D(\n", + " mNext_shks, pNext_shks, shk_prbs, dist_mGrid, dist_pGrid\n", + " )\n", + "\n", + " src_idx = j * MP + i * P + k\n", + " TranMatrix[jp * MP : (jp + 1) * MP, src_idx] += (\n", + " markov_prob * LivPrb_j * lottery_2d\n", + " )\n", + "\n", + " # Death/rebirth\n", + " LivPrb_j = LivPrb_arr[j]\n", + " for i in range(M):\n", + " for k in range(P):\n", + " src_idx = j * MP + i * P + k\n", + " TranMatrix[:, src_idx] += (1.0 - LivPrb_j) * NewBornDist\n", + "\n", + "tm_build_time = time.time() - start\n", + "print(f\"Transition matrix built in {tm_build_time:.1f}s\")\n", + "print(f\"Shape: {TranMatrix.shape}\")\n", + "col_sums = TranMatrix.sum(axis=0)\n", + "print(f\"Column sums: min={col_sums.min():.8f}, max={col_sums.max():.8f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "874e2d12", + "metadata": {}, + "source": [ + "## 5. Ergodic Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d83bc821", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:48.300302Z", + "iopub.status.busy": "2026-03-21T04:24:48.300152Z", + "iopub.status.idle": "2026-03-21T04:24:48.817507Z", + "shell.execute_reply": "2026-03-21T04:24:48.816886Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ergodic distribution computed in 0.51s\n", + "\n", + "PermGroFac=0.97 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=0.99 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=1.01 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=1.03 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=1.05 : TM mass = 0.2000, stat = 0.2000\n", + "\n", + "--- Timing Summary ---\n", + "MC simulation: 17.80s (50,000 agents)\n", + "TM build + ergo: 2.17s (80×25×5 = 10000 states)\n", + "Speedup: 8.2×\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "eigenvalues, eigenvectors = sp_linalg.eigs(\n", + " TranMatrix, k=1, which=\"LM\", v0=np.ones(N_states)\n", + ")\n", + "ergodic_dist = eigenvectors[:, 0].real\n", + "ergodic_dist = ergodic_dist / ergodic_dist.sum()\n", + "\n", + "tm_ergo_time = time.time() - start\n", + "print(f\"Ergodic distribution computed in {tm_ergo_time:.2f}s\")\n", + "print()\n", + "for j in range(J):\n", + " mass_j = ergodic_dist[j * MP : (j + 1) * MP].sum()\n", + " print(\n", + " f\"{state_names[j]:20s}: TM mass = {mass_j:.4f}, stat = {markov_stationary[j]:.4f}\"\n", + " )\n", + "\n", + "tm_total_time = tm_build_time + tm_ergo_time\n", + "print(\"\\n--- Timing Summary ---\")\n", + "print(f\"MC simulation: {mc_sim_time:.2f}s ({n_agents:,} agents)\")\n", + "print(\n", + " f\"TM build + ergo: {tm_total_time:.2f}s ({mCount}×{pCount}×{J} = {N_states} states)\"\n", + ")\n", + "if tm_total_time > 0:\n", + " print(f\"Speedup: {mc_sim_time / tm_total_time:.1f}×\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "c7236f97", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:48.819888Z", + "iopub.status.busy": "2026-03-21T04:24:48.819577Z", + "iopub.status.idle": "2026-03-21T04:24:48.824484Z", + "shell.execute_reply": "2026-03-21T04:24:48.823734Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TM Aggregate Consumption (level) = 1.460660\n", + "TM Aggregate Assets (level) = 0.776380\n", + "TM Aggregate Consumption (norm) = 1.005394\n", + "TM Aggregate Assets (norm) = 0.548480\n" + ] + } + ], + "source": [ + "# Compute aggregates: vectorized over (m, p) using outer products\n", + "TM_C_lvl = 0.0\n", + "TM_A_lvl = 0.0\n", + "TM_C_nrm = 0.0\n", + "TM_A_nrm = 0.0\n", + "for j in range(J):\n", + " block = ergodic_dist[j * MP : (j + 1) * MP].reshape(M, P)\n", + " m_marginal = block.sum(axis=1) # sum over p\n", + " TM_C_nrm += np.dot(cPol[j], m_marginal)\n", + " TM_A_nrm += np.dot(aPol[j], m_marginal)\n", + " # Level: weight each (m,p) cell by p\n", + " TM_C_lvl += np.dot(cPol[j], block @ dist_pGrid)\n", + " TM_A_lvl += np.dot(aPol[j], block @ dist_pGrid)\n", + "\n", + "print(f\"TM Aggregate Consumption (level) = {TM_C_lvl:.6f}\")\n", + "print(f\"TM Aggregate Assets (level) = {TM_A_lvl:.6f}\")\n", + "print(f\"TM Aggregate Consumption (norm) = {TM_C_nrm:.6f}\")\n", + "print(f\"TM Aggregate Assets (norm) = {TM_A_nrm:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "9c12d46d", + "metadata": {}, + "source": [ + "## 6. Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b8dc96c0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:48.827428Z", + "iopub.status.busy": "2026-03-21T04:24:48.827123Z", + "iopub.status.idle": "2026-03-21T04:24:48.831382Z", + "shell.execute_reply": "2026-03-21T04:24:48.830869Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Level Aggregates ===\n", + " MC TM Diff\n", + "Consumption 2.049154 1.460660 0.588494\n", + "Assets 1.082107 0.776380 0.305727\n", + "\n", + "=== Normalized Aggregates ===\n", + " MC TM Diff\n", + "Consumption 1.005128 1.005394 -0.000265\n", + "Assets 0.545663 0.548480 -0.002818\n" + ] + } + ], + "source": [ + "print(\"=== Level Aggregates ===\")\n", + "print(f\"{'':20s} {'MC':>12s} {'TM':>12s} {'Diff':>12s}\")\n", + "print(f\"{'Consumption':20s} {MC_C:12.6f} {TM_C_lvl:12.6f} {MC_C - TM_C_lvl:12.6f}\")\n", + "print(f\"{'Assets':20s} {MC_A:12.6f} {TM_A_lvl:12.6f} {MC_A - TM_A_lvl:12.6f}\")\n", + "print()\n", + "print(\"=== Normalized Aggregates ===\")\n", + "print(f\"{'':20s} {'MC':>12s} {'TM':>12s} {'Diff':>12s}\")\n", + "print(\n", + " f\"{'Consumption':20s} {MC_C_nrm:12.6f} {TM_C_nrm:12.6f} {MC_C_nrm - TM_C_nrm:12.6f}\"\n", + ")\n", + "print(f\"{'Assets':20s} {MC_A_nrm:12.6f} {TM_A_nrm:12.6f} {MC_A_nrm - TM_A_nrm:12.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d5e6a8d7", + "metadata": {}, + "source": [ + "### Time series comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "4d3d9e2a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:48.833487Z", + "iopub.status.busy": "2026-03-21T04:24:48.833366Z", + "iopub.status.idle": "2026-03-21T04:24:52.557440Z", + "shell.execute_reply": "2026-03-21T04:24:52.556960Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [mc_vs_tm_asset_paths]\n", + "dstn = ergodic_dist.copy()\n", + "tm_aLvls = []\n", + "for t in range(agent.T_sim - BURNIN):\n", + " A_val = 0.0\n", + " for j in range(J):\n", + " block = dstn[j * MP : (j + 1) * MP].reshape(M, P)\n", + " A_val += np.dot(aPol[j], block @ dist_pGrid)\n", + " tm_aLvls.append(A_val)\n", + " dstn = TranMatrix @ dstn\n", + "\n", + "plt.figure(figsize=(16, 6))\n", + "plt.plot(\n", + " mc_aLvls[BURNIN:],\n", + " color=COLOR_MC,\n", + " alpha=0.7,\n", + " linewidth=0.8,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + ")\n", + "plt.plot(\n", + " tm_aLvls,\n", + " color=COLOR_TM,\n", + " linewidth=2.5,\n", + " label=f\"TM ({mCount}×{pCount}×{J} = {N_states} states)\",\n", + ")\n", + "plt.xlabel(\"Period (after burn-in)\")\n", + "plt.ylabel(\"Aggregate Assets (level)\")\n", + "plt.title(\"MC vs TM: Serial Permanent Income Growth (2D Grid)\")\n", + "plt.legend(fontsize=12)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "09de3f48", + "metadata": {}, + "source": [ + "### Marginal distributions\n", + "\n", + "Compare TM and MC marginal distributions over $m$ (integrating out $p$ and $j$)\n", + "and over $p$ (integrating out $m$ and $j$)." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "f7aae950", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:52.560594Z", + "iopub.status.busy": "2026-03-21T04:24:52.560390Z", + "iopub.status.idle": "2026-03-21T04:24:52.979178Z", + "shell.execute_reply": "2026-03-21T04:24:52.978799Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [marginal_distributions_m_and_p]\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n", + "\n", + "# --- Marginal over m ---\n", + "tm_m_marginal = np.zeros(M)\n", + "for j in range(J):\n", + " block = ergodic_dist[j * MP : (j + 1) * MP].reshape(M, P)\n", + " tm_m_marginal += block.sum(axis=1)\n", + "\n", + "# Convert to density using midpoint bin widths\n", + "m_widths = np.zeros(M)\n", + "m_widths[0] = dist_mGrid[1] - dist_mGrid[0]\n", + "m_widths[-1] = dist_mGrid[-1] - dist_mGrid[-2]\n", + "m_widths[1:-1] = 0.5 * (dist_mGrid[2:] - dist_mGrid[:-2])\n", + "\n", + "axes[0].plot(\n", + " dist_mGrid,\n", + " tm_m_marginal / m_widths,\n", + " color=COLOR_TM,\n", + " linewidth=2,\n", + " label=f\"TM ({mCount}×{pCount} grid)\",\n", + ")\n", + "axes[0].hist(\n", + " HY[\"mNrm\"][-1],\n", + " bins=N_MC_BINS,\n", + " density=True,\n", + " alpha=0.4,\n", + " color=COLOR_MC,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + ")\n", + "axes[0].set_xlabel(\"$m$ (normalized market resources)\")\n", + "axes[0].set_ylabel(\"Probability Density\")\n", + "axes[0].set_title(\"Marginal distribution of $m$\")\n", + "axes[0].set_xlim([0, 15])\n", + "axes[0].legend()\n", + "\n", + "# --- Marginal over p ---\n", + "tm_p_marginal = np.zeros(P)\n", + "for j in range(J):\n", + " block = ergodic_dist[j * MP : (j + 1) * MP].reshape(M, P)\n", + " tm_p_marginal += block.sum(axis=0)\n", + "\n", + "p_widths = np.zeros(P)\n", + "p_widths[0] = dist_pGrid[1] - dist_pGrid[0]\n", + "p_widths[-1] = dist_pGrid[-1] - dist_pGrid[-2]\n", + "p_widths[1:-1] = 0.5 * (dist_pGrid[2:] - dist_pGrid[:-2])\n", + "\n", + "axes[1].plot(\n", + " dist_pGrid,\n", + " tm_p_marginal / p_widths,\n", + " color=COLOR_TM,\n", + " linewidth=2,\n", + " label=f\"TM ({pCount} p-pts)\",\n", + ")\n", + "axes[1].hist(\n", + " HY[\"pLvl\"][-1],\n", + " bins=N_MC_BINS,\n", + " density=True,\n", + " alpha=0.4,\n", + " color=COLOR_MC,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + ")\n", + "axes[1].set_xlabel(\"$p$ (permanent income level)\")\n", + "axes[1].set_ylabel(\"Probability Density\")\n", + "axes[1].set_title(\"Marginal distribution of $p$\")\n", + "axes[1].legend()\n", + "\n", + "plt.suptitle(\"Marginal Distributions: TM vs MC\", fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b5e67a0e", + "metadata": {}, + "source": [ + "## 7. Summary\n", + "\n", + "This notebook demonstrates the transition matrix method with a **2D grid** over\n", + "$(m, p)$ — the key extension needed when PermGroFac $\\neq$ 1.0.\n", + "\n", + "Key differences from the 1D prototypes:\n", + "\n", + "1. **2D lottery:** `jump_to_grid_2D` distributes probability mass in the\n", + " $(m, p)$ plane, preserving conditional means in both dimensions.\n", + "\n", + "2. **Permanent income dynamics:** $p_{t+1} = p_t \\cdot \\psi \\cdot \\Gamma_{j'}$\n", + " where $\\Gamma_{j'}$ is the PermGroFac of the target Markov state. This\n", + " makes the $p$ distribution non-degenerate.\n", + "\n", + "3. **Level vs normalized aggregates:** With heterogeneous $p$, aggregates in\n", + " *level* terms ($C = \\sum c_i p_i$) differ from normalized terms ($\\bar{c} = \\sum c_i$).\n", + " Both are reported.\n", + "\n", + "4. **Memory scaling:** The TM has $(M \\times P \\times J)^2$ entries. With\n", + " $M=80, P=25, J=5$: 10,000 states and ~800 MB. For larger problems,\n", + " **Harmenberg's neutral measure** collapses the $p$ dimension to get back to\n", + " a 1D grid — that would be the natural next step.\n", + "\n", + "### Next steps\n", + "\n", + "- Implement Harmenberg's neutral measure to reduce back to a 1D grid\n", + "- Use sparse matrices for larger grids\n", + "- Tackle `AggShockMarkovConsumerType` (endogenous aggregate state)" + ] + }, + { + "cell_type": "markdown", + "id": "35f88b40", + "metadata": {}, + "source": [ + "---\n", + "# Part 3: Harmenberg's Neutral Measure (1D Grid, Same 5-State Model)\n", + "\n", + "Same model as Part 2, but using Harmenberg (2021)'s permanent-income-neutral\n", + "measure to collapse the 2D $(m,p)$ grid back to 1D over $m$ alone.\n", + "The idea: reweight the income shock distribution so that $p$ drops out of\n", + "the transition matrix, dramatically reducing computational cost while\n", + "preserving accuracy for normalized aggregates.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f42badd6", + "metadata": {}, + "source": [ + "## 1. Model Setup\n", + "\n", + "Identical to the 2D notebook: 5 Markov states with persistence 0.5,\n", + "same Rfree, LivPrb, income process — only PermGroFac varies." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "918242a4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:52.981705Z", + "iopub.status.busy": "2026-03-21T04:24:52.981449Z", + "iopub.status.idle": "2026-03-21T04:24:52.985766Z", + "shell.execute_reply": "2026-03-21T04:24:52.985382Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Markov transition matrix (row-stochastic):\n", + "[[0.5 0.125 0.125 0.125 0.125]\n", + " [0.125 0.5 0.125 0.125 0.125]\n", + " [0.125 0.125 0.5 0.125 0.125]\n", + " [0.125 0.125 0.125 0.5 0.125]\n", + " [0.125 0.125 0.125 0.125 0.5 ]]\n", + "Row sums: [1. 1. 1. 1. 1.]\n", + "Stationary distribution: [0.2 0.2 0.2 0.2 0.2]\n" + ] + } + ], + "source": [ + "J = 5\n", + "Persistence = 0.5\n", + "PermGroFac_vals = np.array([0.97, 0.99, 1.01, 1.03, 1.05])\n", + "state_names = [f\"PermGroFac={g:.2f}\" for g in PermGroFac_vals]\n", + "\n", + "MrkvArray = np.zeros((J, J))\n", + "for j_from in range(J):\n", + " for j_to in range(J):\n", + " if j_from == j_to:\n", + " MrkvArray[j_from, j_to] = Persistence\n", + " else:\n", + " MrkvArray[j_from, j_to] = (1.0 - Persistence) / (J - 1)\n", + "\n", + "print(\"Markov transition matrix (row-stochastic):\")\n", + "print(np.array2string(MrkvArray, precision=3))\n", + "print(f\"Row sums: {MrkvArray.sum(axis=1)}\")\n", + "\n", + "eigvals, eigvecs = np.linalg.eig(MrkvArray.T)\n", + "idx = np.argmin(np.abs(eigvals - 1.0))\n", + "markov_stationary = eigvecs[:, idx].real\n", + "markov_stationary = markov_stationary / markov_stationary.sum()\n", + "print(f\"Stationary distribution: {markov_stationary}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f7c8f870", + "metadata": {}, + "source": [ + "## 2. Solve the Model\n", + "\n", + "The solution is computed once; it does not depend on which measure we use\n", + "for the transition matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "c687f833", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:52.987650Z", + "iopub.status.busy": "2026-03-21T04:24:52.987526Z", + "iopub.status.idle": "2026-03-21T04:24:52.993169Z", + "shell.execute_reply": "2026-03-21T04:24:52.992818Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Standard income shocks: 30 shock points\n", + "Perm shock range: [0.8660, 1.1458]\n", + "Sum of pmv: 1.000000\n" + ] + } + ], + "source": [ + "# STANDARD income distribution (for solving the model and MC simulation)\n", + "std_dstn_list = construct_lognormal_income_process_unemployment(\n", + " T_cycle=1,\n", + " PermShkStd=[0.1],\n", + " PermShkCount=5,\n", + " TranShkStd=[0.1],\n", + " TranShkCount=5,\n", + " T_retire=0,\n", + " UnempPrb=0.05,\n", + " IncUnemp=0.3,\n", + " UnempPrbRet=None,\n", + " IncUnempRet=None,\n", + " RNG=np.random.default_rng(0),\n", + " neutral_measure=False,\n", + ")\n", + "std_dstn = std_dstn_list[0]\n", + "\n", + "IncShkDstn_J = [std_dstn] * J\n", + "\n", + "print(f\"Standard income shocks: {len(std_dstn.atoms[0])} shock points\")\n", + "print(\n", + " f\"Perm shock range: [{std_dstn.atoms[0].min():.4f}, {std_dstn.atoms[0].max():.4f}]\"\n", + ")\n", + "print(f\"Sum of pmv: {std_dstn.pmv.sum():.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "437ff8ed", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:52.994942Z", + "iopub.status.busy": "2026-03-21T04:24:52.994687Z", + "iopub.status.idle": "2026-03-21T04:24:53.212388Z", + "shell.execute_reply": "2026-03-21T04:24:53.212026Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solved: 5 consumption functions\n", + "PermGroFac used: [0.97 0.99 1.01 1.03 1.05]\n" + ] + } + ], + "source": [ + "params = copy(init_indshk_markov)\n", + "params[\"cycles\"] = 0\n", + "params[\"AgentCount\"] = 50000\n", + "params[\"T_sim\"] = 1200\n", + "params[\"Rfree\"] = [np.array(J * [1.03])]\n", + "params[\"LivPrb\"] = [np.array(J * [0.98])]\n", + "params[\"PermGroFac\"] = [PermGroFac_vals]\n", + "params[\"MrkvPrbsInit\"] = markov_stationary\n", + "params[\"Mrkv_p11\"] = [0.5]\n", + "params[\"Mrkv_p22\"] = [0.5]\n", + "params[\"global_markov\"] = False\n", + "\n", + "agent = MarkovConsumerType(**params)\n", + "agent.assign_parameters(MrkvArray=[MrkvArray])\n", + "agent.IncShkDstn = [IncShkDstn_J]\n", + "agent.solution_terminal = make_markov_solution_terminal(agent.CRRA, agent.MrkvArray)\n", + "\n", + "agent.solve()\n", + "print(f\"Solved: {len(agent.solution[0].cFunc)} consumption functions\")\n", + "print(f\"PermGroFac used: {agent.PermGroFac[0]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "4d077a26", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:53.214182Z", + "iopub.status.busy": "2026-03-21T04:24:53.214054Z", + "iopub.status.idle": "2026-03-21T04:24:53.336521Z", + "shell.execute_reply": "2026-03-21T04:24:53.336144Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [consumption_functions_by_state]\n", + "m_plot = np.linspace(0.01, 10, 200)\n", + "\n", + "plt.figure(figsize=(12, 7))\n", + "cmap = plt.cm.coolwarm\n", + "for j in range(J):\n", + " c_vals = agent.solution[0].cFunc[j](m_plot)\n", + " color = cmap(j / (J - 1))\n", + " plt.plot(m_plot, c_vals, label=state_names[j], linewidth=2, color=color)\n", + "plt.plot(m_plot, m_plot, \":\", color=\"gray\", alpha=0.4, label=\"45° line\")\n", + "plt.xlabel(\"Market resources $m$\", fontsize=12)\n", + "plt.ylabel(\"Consumption $c$\", fontsize=12)\n", + "plt.title(\"Consumption Functions by Permanent Growth State\", fontsize=13)\n", + "plt.legend(fontsize=10)\n", + "plt.xlim([0, 10])\n", + "plt.ylim([0, 5])\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9f40e74e", + "metadata": {}, + "source": [ + "## 3. Monte Carlo Simulation\n", + "\n", + "Same as the 2D notebook. We use the YAML simulator (**`initialize_sym()`** / **`symulate()`**) and read paths from **`hystory`**.\n", + "MC results ground-truth both normalized and level aggregates.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "1bf66565", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:24:53.338754Z", + "iopub.status.busy": "2026-03-21T04:24:53.338486Z", + "iopub.status.idle": "2026-03-21T04:25:11.107508Z", + "shell.execute_reply": "2026-03-21T04:25:11.106980Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MC simulation: 17.76s (50,000 agents, 1200 periods)\n", + "MC Aggregate Consumption (level) = 2.049154\n", + "MC Aggregate Assets (level) = 1.082107\n", + "MC Aggregate Consumption (norm) = 1.005128\n", + "MC Aggregate Assets (norm) = 0.545663\n", + "MC Mean Permanent Income = 2.042496\n", + "\n", + "PermGroFac=0.97 : MC frac = 0.2001, stat = 0.2000\n", + "PermGroFac=0.99 : MC frac = 0.2014, stat = 0.2000\n", + "PermGroFac=1.01 : MC frac = 0.2001, stat = 0.2000\n", + "PermGroFac=1.03 : MC frac = 0.2026, stat = 0.2000\n", + "PermGroFac=1.05 : MC frac = 0.1959, stat = 0.2000\n" + ] + } + ], + "source": [ + "agent.track_vars = [\"aNrm\", \"cNrm\", \"mNrm\", \"pLvl\", \"Mrkv\"]\n", + "\n", + "t0_mc = time.time()\n", + "agent.initialize_sym()\n", + "agent.symulate()\n", + "mc_sim_time = time.time() - t0_mc\n", + "n_agents = agent.AgentCount\n", + "print(f\"MC simulation: {mc_sim_time:.2f}s ({n_agents:,} agents, {agent.T_sim} periods)\")\n", + "\n", + "HY = agent.hystory\n", + "t_last = -1\n", + "mc_cNrm_last = HY[\"mNrm\"][t_last] - HY[\"aNrm\"][t_last]\n", + "MC_C_lvl = np.mean(mc_cNrm_last * HY[\"pLvl\"][t_last])\n", + "MC_A_lvl = np.mean(HY[\"aNrm\"][t_last] * HY[\"pLvl\"][t_last])\n", + "MC_C_nrm = np.mean(mc_cNrm_last)\n", + "MC_A_nrm = np.mean(HY[\"aNrm\"][t_last])\n", + "MC_MeanPLvl = np.mean(HY[\"pLvl\"][t_last])\n", + "\n", + "print(f\"MC Aggregate Consumption (level) = {MC_C_lvl:.6f}\")\n", + "print(f\"MC Aggregate Assets (level) = {MC_A_lvl:.6f}\")\n", + "print(f\"MC Aggregate Consumption (norm) = {MC_C_nrm:.6f}\")\n", + "print(f\"MC Aggregate Assets (norm) = {MC_A_nrm:.6f}\")\n", + "print(f\"MC Mean Permanent Income = {MC_MeanPLvl:.6f}\")\n", + "print()\n", + "for j in range(J):\n", + " frac = np.mean(HY[\"Mrkv\"][t_last] == j)\n", + " print(\n", + " f\"{state_names[j]:20s}: MC frac = {frac:.4f}, stat = {markov_stationary[j]:.4f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2487016a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.109847Z", + "iopub.status.busy": "2026-03-21T04:25:11.109716Z", + "iopub.status.idle": "2026-03-21T04:25:11.364279Z", + "shell.execute_reply": "2026-03-21T04:25:11.363838Z" + } + }, + "outputs": [], + "source": [ + "mc_aLvls = np.array(\n", + " [\n", + " np.mean(agent.hystory[\"aNrm\"][t] * agent.hystory[\"pLvl\"][t])\n", + " for t in range(agent.T_sim)\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5170bc2b", + "metadata": {}, + "source": [ + "## 4. Neutral-Measure Income Distribution\n", + "\n", + "The only change from the standard distribution: permanent shock probabilities\n", + "are reweighted by $\\psi_k$:\n", + "\n", + "$$P^*(\\psi_k) = \\psi_k \\cdot P(\\psi_k)$$\n", + "\n", + "This is done by passing `neutral_measure=True` to the income process constructor.\n", + "The shock **atoms** are unchanged; only the **probabilities** differ." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "119dd710", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.366427Z", + "iopub.status.busy": "2026-03-21T04:25:11.366278Z", + "iopub.status.idle": "2026-03-21T04:25:11.373934Z", + "shell.execute_reply": "2026-03-21T04:25:11.373630Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neutral-measure income shocks: 30 shock points\n", + "Sum of neutral pmv: 1.000000\n", + "\n", + "Standard vs neutral-measure probabilities:\n", + " Standard pmv[:5]: [0.01 0.038 0.038 0.038 0.038]\n", + " Neutral pmv[:5]: [0.00865966 0.03290673 0.03290673 0.03290673 0.03290673]\n", + "\n", + "Perm shock atoms (same): True\n", + "Tran shock atoms (same): True\n", + "\n", + "E*[1/ψ] = 1.000000 (should be ≈ 1.0)\n" + ] + } + ], + "source": [ + "neutral_dstn_list = construct_lognormal_income_process_unemployment(\n", + " T_cycle=1,\n", + " PermShkStd=[0.1],\n", + " PermShkCount=5,\n", + " TranShkStd=[0.1],\n", + " TranShkCount=5,\n", + " T_retire=0,\n", + " UnempPrb=0.05,\n", + " IncUnemp=0.3,\n", + " UnempPrbRet=None,\n", + " IncUnempRet=None,\n", + " RNG=np.random.default_rng(0),\n", + " neutral_measure=True,\n", + ")\n", + "neutral_dstn = neutral_dstn_list[0]\n", + "\n", + "print(f\"Neutral-measure income shocks: {len(neutral_dstn.atoms[0])} shock points\")\n", + "print(f\"Sum of neutral pmv: {neutral_dstn.pmv.sum():.6f}\")\n", + "print()\n", + "print(\"Standard vs neutral-measure probabilities:\")\n", + "print(f\" Standard pmv[:5]: {std_dstn.pmv[:5]}\")\n", + "print(f\" Neutral pmv[:5]: {neutral_dstn.pmv[:5]}\")\n", + "print()\n", + "print(\n", + " f\"Perm shock atoms (same): {(std_dstn.atoms[0] == neutral_dstn.atoms[0]).all()}\"\n", + ")\n", + "print(\n", + " f\"Tran shock atoms (same): {(std_dstn.atoms[1] == neutral_dstn.atoms[1]).all()}\"\n", + ")\n", + "print()\n", + "\n", + "# Verify neutral measure property: E*[1/psi] should be close to 1\n", + "perm_shks = neutral_dstn.atoms[0]\n", + "neutral_pmv = neutral_dstn.pmv\n", + "tran_shks = neutral_dstn.atoms[1]\n", + "\n", + "E_star_inv_psi = np.sum(neutral_pmv / perm_shks)\n", + "print(f\"E*[1/ψ] = {E_star_inv_psi:.6f} (should be ≈ 1.0)\")" + ] + }, + { + "cell_type": "markdown", + "id": "ce053334", + "metadata": {}, + "source": [ + "## 5. Transition Matrix — 1D Grid (Neutral Measure)\n", + "\n", + "Under the neutral measure, the state collapses to $(m, j)$.\n", + "The grid has $M \\times J$ total states — a dramatic reduction from\n", + "$M \\times P \\times J$ in the 2D approach.\n", + "\n", + "The transition for $m$ is:\n", + "\n", + "$$m_{t+1} = \\frac{R_{j'} \\cdot a_t}{\\psi \\cdot \\Gamma_{j'}} + \\theta$$\n", + "\n", + "where the expectation over $\\psi$ uses neutral-measure probabilities.\n", + "Note that PermGroFac $\\Gamma_{j'}$ is still present as a deterministic\n", + "constant — it doesn't cancel out." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "8a437c5b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.375678Z", + "iopub.status.busy": "2026-03-21T04:25:11.375531Z", + "iopub.status.idle": "2026-03-21T04:25:11.380046Z", + "shell.execute_reply": "2026-03-21T04:25:11.379713Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m-grid: 200 points from 0.0010 to 30.0\n", + "Total TM states: 1000 (5 Markov × 200 m-points)\n", + "TM memory: 8.00 MB\n", + "\n", + "Compare with 2D: 80 × 25 × 5 = 10,000 states → ~800 MB\n", + "Neutral measure: 1000 states → 8.00 MB\n", + "Reduction factor: 100×\n" + ] + } + ], + "source": [ + "mMin, mMax, mCount, mFac = 0.001, 30, 200, 3\n", + "dist_mGrid = make_grid_exp_mult(ming=mMin, maxg=mMax, ng=mCount, timestonest=mFac)\n", + "\n", + "M = len(dist_mGrid)\n", + "N_states = M * J\n", + "\n", + "print(f\"m-grid: {M} points from {dist_mGrid[0]:.4f} to {dist_mGrid[-1]:.1f}\")\n", + "print(f\"Total TM states: {N_states} ({J} Markov × {M} m-points)\")\n", + "print(f\"TM memory: {N_states**2 * 8 / 1e6:.2f} MB\")\n", + "print()\n", + "print(\"Compare with 2D: 80 × 25 × 5 = 10,000 states → ~800 MB\")\n", + "print(f\"Neutral measure: {N_states} states → {N_states**2 * 8 / 1e6:.2f} MB\")\n", + "print(f\"Reduction factor: {(80 * 25 * 5) ** 2 / N_states**2:.0f}×\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "325e7a00", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.381721Z", + "iopub.status.busy": "2026-03-21T04:25:11.381618Z", + "iopub.status.idle": "2026-03-21T04:25:11.452234Z", + "shell.execute_reply": "2026-03-21T04:25:11.451869Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Transition matrix built in 0.1s\n", + "Shape: (1000, 1000)\n", + "Column sums: min=1.00000000, max=1.00000000\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "\n", + "MrkvArr = agent.MrkvArray[0]\n", + "Rfree_arr = agent.Rfree[0]\n", + "LivPrb_arr = agent.LivPrb[0]\n", + "PermGroFac_arr = agent.PermGroFac[0]\n", + "\n", + "# Policy on m-grid\n", + "cPol = []\n", + "aPol = []\n", + "for j in range(J):\n", + " c_j = agent.solution[0].cFunc[j](dist_mGrid)\n", + " a_j = np.maximum(dist_mGrid - c_j, 0.0)\n", + " cPol.append(c_j)\n", + " aPol.append(a_j)\n", + "\n", + "# Neutral-measure shocks (same for all Markov states in this model)\n", + "shk_prbs = neutral_dstn.pmv\n", + "perm_shks = neutral_dstn.atoms[0]\n", + "tran_shks = neutral_dstn.atoms[1]\n", + "\n", + "# Newborn distribution under neutral measure: a=0, p=1, so m = θ\n", + "# Under neutral measure with p-grid=[1], newborns land on the m-grid\n", + "# via transitory shocks only\n", + "newborn_1d = jump_to_grid_1D(tran_shks, shk_prbs, dist_mGrid)\n", + "\n", + "NewBornDist = np.zeros(N_states)\n", + "for jp in range(J):\n", + " NewBornDist[jp * M : (jp + 1) * M] = markov_stationary[jp] * newborn_1d\n", + "\n", + "# Build transition matrix\n", + "TranMatrix = np.zeros((N_states, N_states))\n", + "\n", + "for j in range(J):\n", + " LivPrb_j = LivPrb_arr[j]\n", + "\n", + " for jp in range(J):\n", + " markov_prob = MrkvArr[j, jp]\n", + " if markov_prob < 1e-15:\n", + " continue\n", + "\n", + " Rfree_jp = Rfree_arr[jp]\n", + " PermGroFac_jp = PermGroFac_arr[jp]\n", + "\n", + " for i in range(M):\n", + " bNext_i = Rfree_jp * aPol[j][i]\n", + " # Key formula: divide by perm_shks * PermGroFac\n", + " mNext_shks = bNext_i / (perm_shks * PermGroFac_jp) + tran_shks\n", + "\n", + " lottery_1d = jump_to_grid_1D(mNext_shks, shk_prbs, dist_mGrid)\n", + "\n", + " src_idx = j * M + i\n", + " TranMatrix[jp * M : (jp + 1) * M, src_idx] += (\n", + " markov_prob * LivPrb_j * lottery_1d\n", + " )\n", + "\n", + " # Death/rebirth\n", + " for i in range(M):\n", + " src_idx = j * M + i\n", + " TranMatrix[:, src_idx] += (1.0 - LivPrb_j) * NewBornDist\n", + "\n", + "tm_build_time = time.time() - start\n", + "print(f\"Transition matrix built in {tm_build_time:.1f}s\")\n", + "print(f\"Shape: {TranMatrix.shape}\")\n", + "col_sums = TranMatrix.sum(axis=0)\n", + "print(f\"Column sums: min={col_sums.min():.8f}, max={col_sums.max():.8f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e2d3c6cd", + "metadata": {}, + "source": [ + "## 6. Ergodic Distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "4d5e4b48", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.454353Z", + "iopub.status.busy": "2026-03-21T04:25:11.454210Z", + "iopub.status.idle": "2026-03-21T04:25:11.463679Z", + "shell.execute_reply": "2026-03-21T04:25:11.463256Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ergodic distribution computed in 0.01s\n", + "\n", + "PermGroFac=0.97 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=0.99 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=1.01 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=1.03 : TM mass = 0.2000, stat = 0.2000\n", + "PermGroFac=1.05 : TM mass = 0.2000, stat = 0.2000\n", + "\n", + "--- Timing Summary ---\n", + "MC simulation: 17.76s (50,000 agents)\n", + "TM build + ergo: 0.07s (200 m-pts × 5 states, neutral measure)\n", + "Speedup: 249.9×\n" + ] + } + ], + "source": [ + "start = time.time()\n", + "eigenvalues, eigenvectors = sp_linalg.eigs(\n", + " TranMatrix, k=1, which=\"LM\", v0=np.ones(N_states)\n", + ")\n", + "ergodic_dist = eigenvectors[:, 0].real\n", + "ergodic_dist = ergodic_dist / ergodic_dist.sum()\n", + "\n", + "tm_ergo_time = time.time() - start\n", + "print(f\"Ergodic distribution computed in {tm_ergo_time:.2f}s\")\n", + "print()\n", + "for j in range(J):\n", + " mass_j = ergodic_dist[j * M : (j + 1) * M].sum()\n", + " print(\n", + " f\"{state_names[j]:20s}: TM mass = {mass_j:.4f}, stat = {markov_stationary[j]:.4f}\"\n", + " )\n", + "\n", + "tm_total_time = tm_build_time + tm_ergo_time\n", + "print(\"\\n--- Timing Summary ---\")\n", + "print(f\"MC simulation: {mc_sim_time:.2f}s ({n_agents:,} agents)\")\n", + "print(\n", + " f\"TM build + ergo: {tm_total_time:.2f}s ({mCount} m-pts × {J} states, neutral measure)\"\n", + ")\n", + "if tm_total_time > 0:\n", + " print(f\"Speedup: {mc_sim_time / tm_total_time:.1f}×\")" + ] + }, + { + "cell_type": "markdown", + "id": "72c65d85", + "metadata": {}, + "source": [ + "## 7. Aggregates: Normalized and Level\n", + "\n", + "**Normalized aggregates** (the direct output of the neutral measure):\n", + "\n", + "$$\\bar{c}_{\\text{TM}} = \\sum_{m,j} c_j(m) \\cdot \\pi^*(m,j)$$\n", + "\n", + "**Level aggregates** via the Harmenberg identity:\n", + "\n", + "$$C_{\\text{level}} = \\bar{c}_{\\text{TM}} \\times \\bar{p}$$\n", + "\n", + "where $\\bar{p}$ is the mean permanent income level. We compute\n", + "$\\bar{p}$ analytically from the steady-state condition:\n", + "\n", + "$$\\bar{p}^* = \\frac{1 - \\lambda}{1 - \\lambda \\cdot E[\\Gamma]}$$\n", + "\n", + "where $\\lambda =$ LivPrb and $E[\\Gamma] = \\sum_j \\pi(j) \\Gamma_j$." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "0220a180", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.465944Z", + "iopub.status.busy": "2026-03-21T04:25:11.465800Z", + "iopub.status.idle": "2026-03-21T04:25:11.469526Z", + "shell.execute_reply": "2026-03-21T04:25:11.469168Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Normalized Aggregates ===\n", + " MC TM Diff Pct\n", + "Consumption 1.005128 1.000429 0.004699 0.47%\n", + "Assets 0.545663 0.524908 0.020754 3.80%\n" + ] + } + ], + "source": [ + "# Normalized aggregates from TM\n", + "TM_C_nrm = 0.0\n", + "TM_A_nrm = 0.0\n", + "for j in range(J):\n", + " block = ergodic_dist[j * M : (j + 1) * M]\n", + " TM_C_nrm += np.dot(cPol[j], block)\n", + " TM_A_nrm += np.dot(aPol[j], block)\n", + "\n", + "print(\"=== Normalized Aggregates ===\")\n", + "print(f\"{'':20s} {'MC':>12s} {'TM':>12s} {'Diff':>12s} {'Pct':>8s}\")\n", + "diff_c = MC_C_nrm - TM_C_nrm\n", + "diff_a = MC_A_nrm - TM_A_nrm\n", + "pct_c = 100 * diff_c / MC_C_nrm if MC_C_nrm != 0 else 0\n", + "pct_a = 100 * diff_a / MC_A_nrm if MC_A_nrm != 0 else 0\n", + "print(\n", + " f\"{'Consumption':20s} {MC_C_nrm:12.6f} {TM_C_nrm:12.6f} {diff_c:12.6f} {pct_c:7.2f}%\"\n", + ")\n", + "print(f\"{'Assets':20s} {MC_A_nrm:12.6f} {TM_A_nrm:12.6f} {diff_a:12.6f} {pct_a:7.2f}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "e6d9d5c6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.471612Z", + "iopub.status.busy": "2026-03-21T04:25:11.471461Z", + "iopub.status.idle": "2026-03-21T04:25:11.476293Z", + "shell.execute_reply": "2026-03-21T04:25:11.475831Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "E[Γ] = Σ π(j) Γ_j = 1.0100\n", + "LivPrb = 0.98\n", + "Analytical MeanPLvl = (1-λ)/(1-λ·E[Γ]) = 1.9608\n", + "MC MeanPLvl = 2.0425\n", + "\n", + "=== Level Aggregates (using analytical MeanPLvl) ===\n", + " MC TM×p̄ Diff Pct\n", + "Consumption 2.049154 1.961626 0.087528 4.27%\n", + "Assets 1.082107 1.029232 0.052875 4.89%\n", + "\n", + "=== Level Aggregates (using MC MeanPLvl) ===\n", + " MC TM×p̄_MC Diff Pct\n", + "Consumption 2.049154 2.043373 0.005781 0.28%\n", + "Assets 1.082107 1.072123 0.009984 0.92%\n" + ] + } + ], + "source": [ + "# Analytical mean permanent income in steady state\n", + "LivPrb_scalar = agent.LivPrb[0][0]\n", + "E_Gamma = np.dot(markov_stationary, PermGroFac_vals)\n", + "\n", + "MeanPLvl_analytic = (1.0 - LivPrb_scalar) / (1.0 - LivPrb_scalar * E_Gamma)\n", + "\n", + "print(f\"E[Γ] = Σ π(j) Γ_j = {E_Gamma:.4f}\")\n", + "print(f\"LivPrb = {LivPrb_scalar}\")\n", + "print(f\"Analytical MeanPLvl = (1-λ)/(1-λ·E[Γ]) = {MeanPLvl_analytic:.4f}\")\n", + "print(f\"MC MeanPLvl = {MC_MeanPLvl:.4f}\")\n", + "\n", + "# Level aggregates: TM_nrm × MeanPLvl\n", + "TM_C_lvl_analytic = TM_C_nrm * MeanPLvl_analytic\n", + "TM_A_lvl_analytic = TM_A_nrm * MeanPLvl_analytic\n", + "\n", + "TM_C_lvl_mc = TM_C_nrm * MC_MeanPLvl\n", + "TM_A_lvl_mc = TM_A_nrm * MC_MeanPLvl\n", + "\n", + "print()\n", + "print(\"=== Level Aggregates (using analytical MeanPLvl) ===\")\n", + "print(f\"{'':20s} {'MC':>12s} {'TM×p̄':>12s} {'Diff':>12s} {'Pct':>8s}\")\n", + "diff_c = MC_C_lvl - TM_C_lvl_analytic\n", + "diff_a = MC_A_lvl - TM_A_lvl_analytic\n", + "pct_c = 100 * diff_c / MC_C_lvl if MC_C_lvl != 0 else 0\n", + "pct_a = 100 * diff_a / MC_A_lvl if MC_A_lvl != 0 else 0\n", + "print(\n", + " f\"{'Consumption':20s} {MC_C_lvl:12.6f} {TM_C_lvl_analytic:12.6f} {diff_c:12.6f} {pct_c:7.2f}%\"\n", + ")\n", + "print(\n", + " f\"{'Assets':20s} {MC_A_lvl:12.6f} {TM_A_lvl_analytic:12.6f} {diff_a:12.6f} {pct_a:7.2f}%\"\n", + ")\n", + "\n", + "print()\n", + "print(\"=== Level Aggregates (using MC MeanPLvl) ===\")\n", + "print(f\"{'':20s} {'MC':>12s} {'TM×p̄_MC':>12s} {'Diff':>12s} {'Pct':>8s}\")\n", + "diff_c = MC_C_lvl - TM_C_lvl_mc\n", + "diff_a = MC_A_lvl - TM_A_lvl_mc\n", + "pct_c = 100 * diff_c / MC_C_lvl if MC_C_lvl != 0 else 0\n", + "pct_a = 100 * diff_a / MC_A_lvl if MC_A_lvl != 0 else 0\n", + "print(\n", + " f\"{'Consumption':20s} {MC_C_lvl:12.6f} {TM_C_lvl_mc:12.6f} {diff_c:12.6f} {pct_c:7.2f}%\"\n", + ")\n", + "print(\n", + " f\"{'Assets':20s} {MC_A_lvl:12.6f} {TM_A_lvl_mc:12.6f} {diff_a:12.6f} {pct_a:7.2f}%\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3abf3148", + "metadata": {}, + "source": [ + "## 8. Time Series Comparison\n", + "\n", + "For the time series, we propagate the neutral-measure distribution forward.\n", + "The TM time series shows the *normalized* aggregate (which is a flat line\n", + "since the TM is deterministic), while MC shows sampling noise." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "1451f4f6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.478876Z", + "iopub.status.busy": "2026-03-21T04:25:11.478712Z", + "iopub.status.idle": "2026-03-21T04:25:11.721247Z", + "shell.execute_reply": "2026-03-21T04:25:11.720842Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [mc_vs_tm_harmenberg_time_series]\n", + "dstn = ergodic_dist.copy()\n", + "tm_aNrm_ts = []\n", + "tm_cNrm_ts = []\n", + "\n", + "T_forward = agent.T_sim - BURNIN\n", + "for t in range(T_forward):\n", + " A_nrm_t = 0.0\n", + " C_nrm_t = 0.0\n", + " for j in range(J):\n", + " block = dstn[j * M : (j + 1) * M]\n", + " A_nrm_t += np.dot(aPol[j], block)\n", + " C_nrm_t += np.dot(cPol[j], block)\n", + " tm_aNrm_ts.append(A_nrm_t)\n", + " tm_cNrm_ts.append(C_nrm_t)\n", + " dstn = TranMatrix @ dstn\n", + "\n", + "mc_aNrm_ts = np.array([np.mean(agent.hystory[\"aNrm\"][t]) for t in range(agent.T_sim)])\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 5))\n", + "\n", + "axes[0].plot(\n", + " mc_aNrm_ts[BURNIN:],\n", + " color=COLOR_MC,\n", + " alpha=0.7,\n", + " linewidth=0.8,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + ")\n", + "axes[0].plot(\n", + " tm_aNrm_ts,\n", + " color=COLOR_TM,\n", + " linewidth=2.5,\n", + " label=f\"TM neutral ({mCount} m-pts × {J} states)\",\n", + ")\n", + "axes[0].set_xlabel(\"Period (after burn-in)\")\n", + "axes[0].set_ylabel(\"Mean Normalized Assets\")\n", + "axes[0].set_title(\"Normalized Assets: MC vs TM\")\n", + "axes[0].legend(fontsize=10)\n", + "\n", + "axes[1].plot(\n", + " mc_aLvls[BURNIN:],\n", + " color=COLOR_MC,\n", + " alpha=0.7,\n", + " linewidth=0.8,\n", + " label=f\"MC level ({n_agents:,} agents)\",\n", + ")\n", + "axes[1].axhline(\n", + " TM_A_lvl_analytic,\n", + " color=COLOR_TM,\n", + " linewidth=2.5,\n", + " label=f\"TM × p̄_analytic = {TM_A_lvl_analytic:.3f}\",\n", + ")\n", + "axes[1].set_xlabel(\"Period (after burn-in)\")\n", + "axes[1].set_ylabel(\"Aggregate Assets (level)\")\n", + "axes[1].set_title(\"Level Assets: MC vs TM × MeanPLvl\")\n", + "axes[1].legend(fontsize=10)\n", + "\n", + "plt.suptitle(\"Harmenberg Neutral Measure: Time Series\", fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "86e8d662", + "metadata": {}, + "source": [ + "## 9. Distribution Comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "ce9178f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:25:11.723628Z", + "iopub.status.busy": "2026-03-21T04:25:11.723481Z", + "iopub.status.idle": "2026-03-21T04:25:12.137807Z", + "shell.execute_reply": "2026-03-21T04:25:12.137451Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjYAAAJRCAYAAADmno5VAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1QUZxcG8GdZOksvIlJFY0HBEltsgBoUuyZ2BUs+jS2xJpbYEiU2YoslGksUe+waWxRbNLYo9qBSVEBFpQtLme+PdUfW3aWJIPH5nbPH3Zl3Zt6ZHTwze+feVyIIggAiIiIiIiIiIiIiIqIyQKe0O0BERERERERERERERFRQDGwQEREREREREREREVGZwcAGERERERERERERERGVGQxsEBERERERERERERFRmcHABhERERERERERERERlRkMbBARERERERERERERUZnBwAYREREREREREREREZUZDGwQEREREREREREREVGZwcAGERERERERERERERGVGQxsEBEREdFbk0gk8Pb2Lu1uUDHy9vaGRCIp7W7QOxYYGAiJRILIyMgS33ZoaCgkEgmmTZumMt3V1RWurq4l3h+ladOmQSKRIDQ0tNT6QERERER5Y2CDiIiIKJfIyEhIJBK0bt1aaxvlj3FDhgwpwZ5RSVB+/xKJBH5+fhrbnDt3DhKJBIGBgSXat/f9x1blcTMwMMCzZ880tnnx4gWMjIzEtlQ8lOeG8iWVSmFhYYGPPvoIn3/+OdasWYPU1NRi367y76Wk/xbelraAChERERGVHQxsEBERERFpcPjwYRw7dqy0u1Gm6OrqQi6XIyQkROP8kJAQpKenQ1dXt4R79mHo2rUrpk6diu+++w4DBgxAjRo1EBoaigEDBqBq1aoag2JBQUG4desWKlSoUOL9rV+/Pm7duoXhw4eX+LbzMnz4cNy6dQv169cv7a4QERERkRa8oyAiIiIieoOrqyuio6PxzTff4Pz588wuKCB3d3cIgoA1a9Zg5MiRavNXr16NKlWqAADu3LlT0t37z/vss8/Qo0cPlWkZGRlYsGABJk6ciHbt2uGvv/6Cp6enOL98+fIoX758SXcVAGBsbIyqVauWyrbzYmNjAxsbm9LuBhERERHlgRkbRERERMXk0qVLGD58OGrUqAFzc3MYGRmhZs2a+PHHH5GZmanWXllHPiEhAcOHD4eTkxN0dXWxdu1alRIvt27dQrt27WBhYQFLS0v07NkT8fHxAICzZ8+iRYsWMDMzg6WlJQYNGqS15MzJkyfRvn172NjYwMDAAJUrV8bkyZORlpam0i53mZaLFy+iVatWMDU1hbm5OTp37pxnLf6HDx+iZ8+esLGxgbGxMRo3boyjR49qbCuXyxEcHIw6derAxMQEpqamaNq0Kfbs2aPWVjkOwP379zF//nxUr14dBgYGKiVwTpw4gWbNmsHExATW1tbo3r07Hjx4UKSxIqpUqYK+ffvi4sWL2Lp1a4GXS05OxtSpU+Hh4QEjIyNYWFjAz88Pp0+fVmub1zgCb/bZ29sb06dPBwD4+PiIJYdyL5/X+QQU/vwsqv79++PKlSu4fPmyyvSrV6/in3/+Qf/+/fNcfvfu3WjRogUsLS1haGiIGjVqYN68ecjOzlZpl5iYiNmzZ6N58+ZwcHCAvr4+HBwc0K9fP9y7d09tvenp6Zg/fz68vLxgbm4OExMTuLq6olu3brh69arYLq+SX2vXroVEIhGPKQC1v9XOnTvD2tpabdyKgu5XcTMwMMA333yDKVOmIDU1Fd9++63KfG1jbPz+++9o3rw57OzsYGhoCAcHB7Rs2RK///47AMWxcHNzAwCsW7dOpRSW8tjlPpZr165FnTp1YGxsLI7Hk19JqISEBAwePBj29vYwNDRE7dq1sWnTJrV2eY0T8ub3OW3aNPj4+AAApk+frtJv5fJ5nQN79+6Fj4+P+Dfk5eWF4OBgZGVlqbTLfV7cvXsXnTt3hqWlJUxMTNCyZUuVc04pPDwc/fv3h5ubGwwMDGBlZQUvLy98/fXXEARB4zEiIiIi+lAxY4OIiIiomKxcuRJ79+5Fs2bN4O/vj7S0NISGhmLChAm4cOGC+INgbhkZGfD19UVKSgo6dOgAXV1dlCtXTpwfERGBTz75BB9//DEGDRqEixcvYvPmzXjw4AF+/PFHfPrpp2jVqhX+97//ITQ0FL/++itycnKwevVqle0sW7YMw4YNg4WFBdq3bw87OztcvHgRM2fOxPHjx3H8+HHo6+urLHPhwgXMmTMHPj4+GDx4MP755x/s2rUL165dw/Xr12FoaKjS/sWLF2jcuDFsbW0xaNAgPH36FFu2bEHr1q2xfft2dOrUSWW/W7dujdDQUNSqVQsDBw5EZmYm9u/fj44dO2Lx4sUay9OMGDEC586dQ9u2bcX9ABRlo9q2bQupVIru3bvDwcEBx48fR5MmTWBpaVno7xIAZsyYgc2bN2Py5Mno0qUL9PT08mz//PlzNGvWDDdu3EDjxo0xZMgQJCUlYffu3fDx8cG2bdtUjkFhKAM4J06cQEBAgBjQsLCwUGmX1/lUlPOzKAICAjB58mSsWbMGderUEaf/+uuvkEql6NevH9asWaNx2QkTJuDHH39EhQoV0KVLF5ibm+PUqVMYN24c/v77b2zbtk1se+vWLUyZMgU+Pj7o3LkzTExMcPv2bWzcuBH79+/H5cuX4eLiotKvrVu3wtPTE/3794eBgQEePHiA48eP48KFC/Dy8nqr/b579y4aNmyImjVrIjAwEM+ePRP/pgqzX4AiSBUVFYWIiIhiG0R7zJgxmDNnDg4dOoTExESYm5trbbts2TIMHToU5cuXFwM1cXFxOH/+PHbu3ImuXbuiVq1a+Oqrr7Bw4UJ4eXmpnNtv9nnu3Lk4fvw4OnbsiE8//RRSqTTf/srlcrRs2RIpKSno27cvUlNTsXXrVvTq1Qvx8fEYMWJEkY6Dt7c3IiMjsW7dOjRv3lwMsgDqf09vCg4OxpgxY2BlZYVevXrBxMQEe/bswZgxY3Dq1Cns2LFDLYgaGRmJhg0bwsPDAwMGDMC9e/fE/xNu3bol/n3GxMSgfv36SE1NRdu2bdG9e3ekpqYiPDwcS5cuxbx581jCjYiIiCg3gYiIiIhEERERAgDB3d1dmDp1qsZXQECAAEAYPHiwyrJRUVFCVlaWyrScnBxhwIABAgDh9OnTKvNcXFwEAIKfn5+QlpamsR8AhAULFqisz9/fXwAgWFhYCLt27RLnyeVywdPTU9DV1RXi4uLE6Tdu3BB0dXUFLy8vIT4+XmU7QUFBAgBh3rx54rTjx4+L2968ebNK+759+woAhE2bNqlMV7bv1auXkJOTI06/evWqoK+vL9ja2qrs48SJEwUAwnfffafSPikpSfj4448FfX194dGjR+J05TF3dHQUoqKiVLadlZUluLi4CBKJRDh16pTKvH79+ol9Kwjlcffz8xMEQRDGjh0rABAWL14stjl79qwAQAgICFBZtlevXgIAYeXKlSrTHz9+LDg5OQm2trbCy5cvxekuLi6Ci4uLxn40b95crc9Tp04VAAjHjx/XuExe55MgFP781NSHvAAQqlSpIgiCILRr106wsrIS0tPTBUEQhPT0dMHKykpo3769IAiCUKVKFbV1Hz58WOx/SkqKSh+HDBkiABC2b98uTk9ISBCePXum1o9jx44JOjo6wqBBg1TaSiQSoW7dumrHICsrS3jx4oX4Oa/jvGbNGgGAsGbNGnFa7r/VKVOmqC1T2P0ShNffZUREhNr6NFH2+c2/yzc1bdpUACD8+eef4jTl31bubdWpU0fQ19cXHj9+rLaO3P+HKPf9zb+FN/tlYmIihIWFqc1X/l8zdepUlenK/W/WrJmQkZEhTn/w4IFgY2MjGBgYCA8fPsxzH97sQ+7vU9t281rm7t27gq6urmBnZydER0eL09PT04UmTZoIAITffvtN7dgAEH788UeV9U+ePFkAIAQFBYnTFi1apPb/vZKm85yIiIjoQ8dSVEREREQa3Lt3D9OnT9f4WrduncZlnJ2d1Z5ElkgkGDZsGABoLck0Z84cGBkZaZzn7u6uMlaBRCIRa+jXrl0bHTt2FOfp6enhs88+Q1ZWFm7evClOX7FiBbKysrB48WJYW1urrH/8+PGwtbXVWN6lWbNm6N69u8q0AQMGAFBkc7xJKpVi1qxZKk8se3p6om/fvnj69CkOHDgAAMjJycGyZcvg7u4uloJRMjU1xZQpUyCXy7Fjxw61bYwbNw7Ozs4q006fPo2oqCi0b98eTZo0UZn3ww8/FOjpcG0mTpwICwsLfP/990hJSdHaLj4+Hlu2bIGvry8GDRqkMs/Ozg7jxo3D06dPtZ4DxUnb+VTU87MoBgwYgOfPn2PXrl0AgF27duH58+fi+aPJkiVLAAC//PILTExMVPr4448/QiKRqJyn5ubmsLKyUluPj48PPDw8VPZHIpFAEAQYGhpCR0f1Fkgqleb7pH5B2NvbY9KkSWrTC7tfAPDnn3++kwG9HRwcAEAsZZcXPT09jVlKb/4fUhD/+9//ULNmzUIvN2vWLJVMMkdHR3z11VfIyMjA5s2bC72+t7Fx40ZkZWVhzJgxcHJyEqcbGBhg9uzZAKBSokzJzc0N48aNU5k2cOBAAJr/H9X0t6vpPCciIiL60DGXlYiIiEgDPz8/HDx4UOO80NBQsUZ7bnK5HEuWLMHmzZtx+/ZtpKSkqNRFj4mJUVvG0NAwzx/8PD091UqbKAf6rVWrllp75bzc2zp37hwA4NChQ/jzzz/VltHT08Pt27fVptetW1dtmqOjIwBF7fs3OTs7q5T+UWratCl+/fVX/PPPP+jatSvu3LmDFy9ewMHBQRw3IrenT58CgMY+1a9fX22aslb9m0ENAHBycoKzszMiIiLU5hWEpaUlvv32W3z77beYN2+e1rEALly4gOzsbGRkZGhsEx4eDkCxT+3atStSXwoir/OpKOdnUbVr1w52dnZYvXo1unfvjtWrV8POzi7PfT937hxMTEzUyqgpGRkZqZ0ToaGhWLBgAf7++2/Ex8erjHOQ+wdxMzMz+Pv748CBA6hTpw4+//xzeHt7o169evmWGCsoLy8vtXJuRd0vd3f3YulTUfXo0QPjx49HjRo10KtXL/j4+KBJkyYwMzMr0vo0/d3mR1dXF40aNVKb3rRpUwDAP//8U6S+FJVye7lLVyk1atQIhoaGuHLlitq8WrVqqQXTNP0/2r59e0yYMAHDhg3Dn3/+idatW6N58+aoWLFise0DERER0X8JAxtERERExeSzzz7D3r178dFHH6F79+6ws7ODnp4eEhISsHDhQmRkZKgtY2dnl+fA1pp+SFTWWc9rXu7BoJ8/fw4AmDlzZqH2J6/1axrwOPfYIJqmJyYmqvTnxo0buHHjhtbtaxoEXdM2kpKSAEAcb0PTMkUNbADAyJEjsWTJEsyfPx9Dhw7V2Ea5T2fOnMGZM2e0rkvbwO7FJa/zqSjnZ1Hp6emhT58+WLBgAf766y8cPXoUo0aNynOMgOfPnyMrK0tjsEsp9/Hbtm0bunfvDplMBj8/P7i6usLY2Fgc3DsqKkpl2W3btmHWrFnYuHGjmFlhZmaG/v37Y9asWTA2Nn6rfdZ2/hd2v94lZfDK1tY2z3Zjx46FtbU1li1bhvnz54vjO7Rt2xY//fSTOGh4QWk7NnmxsbFRCwjkXpfy/5OSovx/RtO+SCQSlCtXDo8ePVKbV9D/R11dXXHu3DlMmzYNBw4cwNatWwEAVatWxYwZM/D5558Xy34QERER/VcwsEFERERUDC5cuIC9e/fCz88P+/fvVyn5c+7cOSxcuFDjcnkFNYqL8oe1pKQkmJqavrPtPH78OM/pysGKlf3p2rUrtm/fXqhtaDpeyvU9efKkUP0qKCMjI0yfPh0DBw7E9OnT0bdvX619GDNmDObNm1eg9ero6EAul2ucV9QfbbWdT0U9P9/GwIEDERwcjG7duiEnJ0csv6ONmZkZJBJJgcokAcC0adNgaGiIS5cuoXLlyirzNJUpMjY2xg8//IAffvgBEREROH78OJYvX46FCxfi5cuXWLFiBQCIP6bnzv5Qyut70XbsC7tf70pKSgouXboEqVSqMqi7JhKJBAMGDMCAAQPw7NkznDp1Cps2bcLWrVsRHh6OsLCwQpV4K8r/c/Hx8cjJyVELbrz5/wlQ9O+sMJR/448fP1bLTBMEAY8fPy5yRotSjRo1sH37dmRmZuLSpUv4448/sGjRInTv3h0ODg5o3LjxW62fiIiI6L+EY2wQERERFYN79+4BANq2bav2g9+pU6dKo0uiBg0aAHhdkupdiY6OVntKHni9/7Vr1wYAVKtWDWZmZrh48aJKZklReXl5AYDGTImHDx8iOjr6rbcREBAADw8PrFy5Enfv3lWbX69ePUgkEpw9e7bA67S0tMSTJ0/UfoxNTU0VS1flpjyvNGXL5Kc0zs/q1aujQYMGePToERo2bIhq1arl2b5BgwZ49uyZxn3X5N69e6hWrZpaUCM2Nhb379/Pc1k3NzcMGDAAJ06cgEwmw549e8R5lpaWAKDx6fuilD8q7H69K/Pnz0daWhratGmjEhTIj7W1NTp16iSOIXPz5k3xb+Btzsn8ZGVlafx7evP/E6Dw31lR+q3cXmhoqNq8v//+G+np6RrLAxaFnp4eGjZsiOnTp2PRokUQBAH79u0rlnUTERER/VcwsEFERERUDJRP8J4+fVpl+o0bNxAUFFQaXRINHToUurq6GDFihMYf+RMSEoqlXn12djYmTpyoMm5DWFgY1q9fD1tbW/j7+wNQlGH58ssvERUVhbFjx2oMbly/fl1rBsabmjRpAmdnZ+zdu1fth9DvvvuuWH50VQ6MnpmZqXEMDXt7e3Tr1g1//fUX5s6dq3IMlP7++2+kpaWJn+vVq4fMzEyEhISI0wRBwIQJEzSWJlIOIPzgwYNC97+0zs/Vq1dj586d+PXXX/NtO3LkSAAQswTeFBcXh1u3bomfXVxccPfuXZWMnPT0dHz55Zdq59TTp09x/fp1tXW+ePECGRkZMDQ0FKfVq1cPAPDbb78hJydHnH727FmV76qgCrtfgCJoc/v27WIJ/GVkZGDOnDmYMWMGZDJZgb7v0NBQtXM4MzNTLLmmPF6WlpaQSCRFOicLYuLEiSpZTQ8fPsTChQthYGCAHj16iNOV39mbg3dv374dJ06cUFtvUf6WevXqBV1dXQQHB6uMRyOXy/HNN98AAAIDAwu8vjddunRJLHeVm/L8zn2OEhERERFLUREREREVi/r166N+/frYunUrYmNj0bBhQ0RHR2PPnj1o27ZtoUsuFacaNWpg6dKl+PLLL1GlShX4+/vD3d0dycnJuH//Pk6cOIHAwEAsX778rbbj6emJ06dPo169emjZsiWePn2KLVu2ICsrC7/88guMjIzEttOnT8fly5exaNEi7N+/H82aNYOdnR0ePXqEa9eu4erVqzh79qzWcTNyk0qlWL58OTp06ABfX190794d5cuXx4kTJ/Do0SN4eXkhLCzsrfYNADp06IAmTZqoBQeUli5dijt37mD8+PFYv349GjVqBAsLCzx48AAXL15EeHg4YmNjxbEchg8fjjVr1mDQoEE4cuQIbG1tcerUKSQkJMDLy0scFF3Jx8cHEokEEydOxI0bN2Bubg4LCwsMHz48376X1vlZvXp1VK9evUBtW7duje+++w7ff/89KlWqhNatW8PFxQXPnj3D3bt3cerUKfzwww9i5seIESMwYsQI1K5dG5999hmysrJw5MgRCIKgdvwePXqE2rVrw8vLC56enqhQoQKePXuG3bt3IzMzE2PHjhXbNmzYEI0bN8axY8fQqFEjNGvWDFFRUdi9ezfat2+PnTt3FuoYFHa/AKBFixaIiopCREQEXF1dC7yt7du3iwORp6SkICIiAidPnkR8fDycnJywYcMG1KhRI9/1dOrUCWZmZmjYsCFcXFyQmZmJI0eO4ObNm/jss8/EQJlMJkO9evVw8uRJ9O3bF5UrV4aOjg769u2rVq6psMqXL4/U1FR4enqiffv2SE1NxdatW/Hs2TMsWrQIFSpUENt27NgR7u7uWLt2LR48eIDatWvj1q1bOHbsmDhofG5Vq1aFg4MDNm/eDAMDAzg6OkIikWDEiBFas1nc3d0xe/ZsjBkzBp6enujWrRtMTEywd+9e3LlzBx07dkSfPn2KvL/r16/HihUr0KxZM7i7u8PMzAw3b97EgQMHYGVlhf79+xd53URERET/RQxsEBERERUDqVSKffv24dtvv8XBgwdx4cIFVK5cGfPmzUObNm1KNbABAF988QVq1aqF4OBgnDx5Env37oW5uTmcnZ0xatQoBAQEvPU2LC0tsX//fowdOxYrV65EWloaateujenTp6NVq1YqbQ0MDPDHH3/g119/xW+//Ybff/8dGRkZKFeuHKpXr44hQ4agZs2aBd52mzZtcPjwYUyZMgVbt26FkZERWrRogS1btsDf3/+ta98rzZ49W2udeysrK/z1119YsmQJtmzZgpCQEOTk5MDe3h5eXl747rvvYGNjI7avUaMGDh48iAkTJmD79u2QyWTw9/fHvHnz0K1bN7X1V69eHWvWrMH8+fOxePFiZGRkwMXFpUCBjff9/FSaMWMGmjVrhkWLFuHPP/9EQkICrK2t4ebmhmnTpqF3795i22HDhkFPTw+LFy/GypUrYWFhgbZt2yIoKEhtoGVXV1dMmzYNx44dw9GjR/Hs2TPY2NigTp06+Oqrr9C6dWuV9rt378bo0aOxb98+XLt2DV5eXti7dy9iYmIKHdgo7H69jd9//x2///47dHR0IJPJYGdnB29vb7Rt2xbdunUr8ADpQUFBOHjwIM6fP4+9e/fCxMQE7u7uWLZsmdpYKevXr8eoUaOwb98+JCYmQhAENGnS5K0DG/r6+jhy5Ai+/fZbrF+/HgkJCahatSoWL16Mnj17qrQ1MjISB6j/888/ce7cOTRs2BAnT57Evn371AIbUqkUO3bswDfffINNmzYhOTkZANCnT588y3SNHj0alSpVQnBwMDZs2AC5XI6PPvoI8+fPx8iRI99qzKSePXsiPT0dZ86cwfnz55GRkQFHR0d8+eWXGDduHJydnYu8biIiIqL/IomgKU+eiIiIiOg/IDk5GeXKlUPNmjXx999/l3Z3iIiIiIiIqBhwjA0iIiIiKvNSU1PFp66VsrOzMW7cOLx8+RKdOnUqnY4RERERERFRsWPGBhERERGVeVeuXEGTJk3g5+eHihUrIjk5GadOncLNmzfh4eGBv//+GyYmJqXdTSIiIiIiIioGDGwQERERUZn39OlTjB8/HidOnMDjx4+RlZUFZ2dndOrUCZMmTYKFhUVpd5GIiIiIiIiKCQMbRERERERERERERERUZnCMDSIiIiIiIiIiIiIiKjMY2CAiIiIiIiIiIiIiojKDgQ0iIiIiIiIiIiIiIiozGNggIiIiIiIiIiIiIqIyg4ENIiIiIiIiIiIiIiIqMxjYICIiIiIiIiIiIiKiMoOBDSIiIiIiIiIiIiIiKjMY2CAiIiIiIiIiIiIiojKDgQ0iIiIiIiIiIiIiIiozGNggIiIiIiIiIiIiIqIyg4ENIiIiIiIiIiIiIiIqMxjYICIiIiIiIiIiIiKiMoOBDSIiIiIiIiIiIiIiKjMY2CAiIiIiIiIiIiIiojKDgQ0iIiIiIiIiIiIiIiozGNggIiIiIiIiIiIiIqIyg4ENIiIiIiIiIiIiIiIqMxjYICIiIiIiIiIiIiKiMoOBDSIiIiIiIiIiIiIiKjMY2CAiKkaBgYFwdXUtkW25uroiMDBQ/Lx27VpIJBJcvHixRLbv7e0Nb2/vEtlWbiW9n6XhQ9hHIiIiIip5yuvMyMjIMrmdkuq/tm1NmzYNEokE8fHxpbL999GFCxfwySefwMTEBBKJBFeuXCntLhHRB4KBDSJ6r0kkkgK9QkNDERkZKX7+4YcfNK6vd+/ekEgkkMlk+W5bedGqfBkbG8PZ2Rnt27fHmjVrkJGRUSz7ePPmTUybNu29vGB9n/v2rgUGBkIikcDMzAwvX75Umx8eHi6eG/PmzSuFHpYMuVyOhQsXonbt2jAzM4OFhQU8PDzwv//9D7dv3xbb/fXXX5g2bRoSEhKKvK2lS5di7dq1b99pIiIiolKg/CFaIpHg9OnTavMFQYCTkxMkEgnatWtXCj18/+Q+ZhKJBIaGhnBwcICfnx8WLVqE5OTkYtlOcVyrvivvc9/yk5mZic8//xzPnz/HTz/9hPXr18PFxaW0u0VEHwjd0u4AEVFe1q9fr/L5t99+w5EjR9SmV6tWTfzx2dDQEJs2bcLkyZNV2qSmpmL37t0wNDQsVB+WLVsGmUyGjIwMPHr0CIcOHcKAAQOwYMEC7Nu3D05OTmLblStXIicnp1Drv3nzJqZPnw5vb+9CZXvcuXMHOjrvNj6dV98OHz78Trf9PtDV1UVaWhr27t2Lbt26qcwLCQmBoaEh0tPTS6l3JaNr1674448/0LNnT3zxxRfIzMzE7du3sW/fPnzyySeoWrUqAMUN2fTp0xEYGAgLC4sibWvp0qWwsbFRyUQiIiIiKmsMDQ2xceNGNGnSRGX6iRMn8PDhQxgYGJRSz4C+ffuiR48epdoHTWbMmAE3NzdkZmYiLi4OoaGh+PrrrxEcHIw9e/bA09MTQNH7X5Rr1ZI6Vtr69r5+V7ndu3cPUVFRWLlyJQYNGlTa3SGiDwwDG0T0XuvTp4/K53PnzuHIkSNq0wGIWQX+/v7YsWMHrl69Ci8vL3H+7t27IZfL0bp1axw7dqzAffjss89gY2Mjfp4yZQpCQkLQr18/fP755zh37pw4T09Pr8DrLQpBEJCeng4jI6NSv8DV19cv1e2XBAMDAzRu3BibNm1SC2xs3LgRbdu2xe+//15s20tPT3+vjuuFCxewb98+zJw5ExMnTlSZt2TJkjL5VBkRERHRu+bv749t27Zh0aJF0NV9/bPLxo0bUbdu3WItY5SamgoTE5MCt5dKpZBKpcW2/eLSpk0bfPzxx+LnCRMm4NixY2jXrh06dOiAW7duwcjIqET6rzympX2sSnv7BfHkyRMAKPKDTUREb4OlqIjoP6dRo0Zwc3PDxo0bVaaHhISgdevWsLKyeutt9O7dG4MGDcLff/+NI0eOiNM1jbGxefNm1K1bF6ampjAzM0PNmjWxcOFCAIrU688//xwA4OPjo1JaC1CMo9GuXTscOnQIH3/8MYyMjLBixQpxnqYn29PS0jB48GBYW1vDzMwM/fr1w4sXL1TaSCQSTJs2TW3Z3OvMr2+axth48uQJBg4ciHLlysHQ0BBeXl5Yt26dShtlybB58+bhl19+gbu7OwwMDFCvXj1cuHBB4/HWJL/9DAgIgI2NDTIzM9WW/fTTT1GlSpUCbadXr174448/VH7Ev3DhAsLDw9GrVy+19s+fP8fYsWNRs2ZNyGQymJmZoU2bNrh69apKu9DQUEgkEmzevBmTJ09GhQoVYGxsjKSkJI39ePHiBerXrw9HR0fcuXMHQP7HOzMzE1ZWVujfv7/a+pKSkmBoaIixY8dq3fd79+4BABo3bqw2TyqVwtraGoCibNu4ceMAAG5ubuK5ogw2rlmzBr6+vrCzs4OBgQGqV6+OZcuWqazP1dUVN27cwIkTJ8Tlc59fCQkJ+Prrr+Hk5AQDAwNUqlQJs2fPLnSGFBEREdG71rNnTzx79kzlPkEul2P79u0arx+joqIwdOhQVKlSBUZGRrC2tsbnn3+uVg5WWSr35s2b6NWrFywtLVWyQkJDQ/Hxxx/D0NAQ7u7uWLFihbiMUl7jRty9e1fMGjA3N0f//v2RlpZWpL4WB19fX3z33XeIiorChg0btPY/OTkZX3/9NVxdXWFgYAA7Ozu0atUKly9fFvdP27VqXsc0rzEu4uPj0a1bN5iZmcHa2hpfffWVSia3trEX3/w+8uqbtu3/888/aNOmDczMzCCTydCiRQuVh+1yb6cg36k2+W0nMDAQzZs3BwB8/vnnatfvmrRq1QqNGjXC2bNn4e3tDRMTE1SqVAkHDhwAABw4cAANGzaEiYkJatWqhUuXLhWor0T0YWLGBhH9J/Xs2RMbNmzAjz/+KA7udvjwYaxfvx4HDx4slm307dsXv/zyCw4fPoxWrVppbHPkyBH07NkTLVq0wOzZswEAt27dwpkzZ/DVV1+hWbNmGDlyJBYtWoSJEyeiWrVqACD+CyhKTvXs2RODBw/GF198ke8P8sOHD4eFhQWmTZuGO3fuYNmyZYiKihJ/SC+ogvQtt5cvX8Lb2xt3797F8OHD4ebmhm3btiEwMBAJCQn46quvVNpv3LgRycnJGDx4MCQSCebMmYMuXbrg/v37Bcp8yW8/+/bti99++w2HDh1SqWEcFxeHY8eOYerUqQU6Dl26dMGQIUOwY8cODBgwQOx71apVUadOHbX29+/fx65du/D555/Dzc0Njx8/xooVK9C8eXPcvHkTDg4OKu2///576OvrY+zYscjIyNCYsREfH49WrVrh+fPnOHHiBNzd3Qt0vPX09NC5c2fs2LEDK1asUFn3rl27kJGRgR49emjdd2V93JCQEDRu3FjlicM3j9G///6LTZs24aeffhIznGxtbQEoyrl5eHigQ4cO0NXVxd69ezF06FDk5ORg2LBhAIAFCxZgxIgRkMlkmDRpEgCgXLlyABRBrObNm+PRo0cYPHgwnJ2d8ddff2HChAmIjY3FggULtO4DERERUUlzdXVFo0aNsGnTJrRp0wYA8McffyAxMRE9evTAokWLVNpfuHABf/31F3r06AFHR0dERkZi2bJl8Pb2xs2bN2FsbKzS/vPPP0flypUxa9YsCIIAQPEjdOvWrVG+fHlMnz4d2dnZmDFjhng9VhDdunWDm5sbgoKCcPnyZaxatQp2dnbifUxR+vq2+vbti4kTJ+Lw4cP44osvNLYZMmQItm/fjuHDh6N69ep49uwZTp8+jVu3bqFOnTr5XqsCmo9pXrp16wZXV1cEBQXh3LlzWLRoEV68eIHffvutUPtXkL7lduPGDTRt2hRmZmYYP3489PT0sGLFCnh7e+PEiRNo0KCBWj/z+06Lup3BgwejQoUKmDVrFkaOHIl69eqJ1+/ahIWFwdraGt27d8fAgQPRuXNnzJo1C7169cLs2bMxd+5cfPHFF+jYsSNmzZqFAQMGqD0gRkQkEoiIypBhw4YJ2v7rioiIEAAIc+fOFa5fvy4AEE6dOiUIgiD8/PPPgkwmE1JTU4WAgADBxMQk321NnTpVACA8ffpU4/wXL14IAITOnTuL0wICAgQXFxfx81dffSWYmZkJWVlZWrezbds2AYBw/PhxtXkuLi4CAOHgwYMa5wUEBIif16xZIwAQ6tatK8jlcnH6nDlzBADC7t27xWkAhKlTp+a7zrz61rx5c6F58+bi5wULFggAhA0bNojT5HK50KhRI0EmkwlJSUmCILz+nqytrYXnz5+LbXfv3i0AEPbu3au2rdwKup/Z2dmCo6Oj0L17d5Xlg4ODBYlEIty/fz/P7eQ+Tz777DOhRYsW4nrt7e2F6dOnq5xzSunp6UJ2drbKuiIiIgQDAwNhxowZ4rTjx48LAISKFSsKaWlpGvfxwoULQmxsrODh4SFUrFhRiIyMFNsU9HgfOnRI43H19/cXKlasmOcxyMnJEZo3by4AEMqVKyf07NlT+Pnnn4WoqCi1tnPnzhUACBEREWrz3tw/QRAEPz8/te17eHionFNK33//vWBiYiL8+++/KtO//fZbQSqVCtHR0XnuBxEREVFJyH0Nt2TJEsHU1FS8Dvr8888FHx8fQRAU19xt27YVl9N0rXT27FkBgPDbb7+J05T3Jz179lRr3759e8HY2Fh49OiROC08PFzQ1dVVuX9S9jH3NZtyvQMGDFBZZ+fOnQVra2uVaQXtq6btaJL7mGljbm4u1K5dW+t6zc3NhWHDhuW5HW3Xqnkd07yOVYcOHVTaDh06VAAgXL16VRAE9fvCN5cvSN80bb9Tp06Cvr6+cO/ePXFaTEyMYGpqKjRr1kxtOwX5TjUp6HaU9zTbtm3Ld52PHz8W7ytiYmLE6YsWLRIACFWrVhUSExPF6aNHjxYkEomQnp6e77qJ6MPEUlRE9J/k4eEBT09PbNq0CYDiCfuOHTsW6xNEMpkMgCL1WRsLCwukpqaqpKEXlpubG/z8/Arc/n//+59KxsOXX34JXV1dMb33XTlw4ADs7e3Rs2dPcZqenh5GjhyJlJQUnDhxQqV99+7dYWlpKX5u2rQpAEXGQ0Hkt586Ojro3bs39uzZo/IdhYSE4JNPPoGbm1uB961Xr14IDQ0Vsz3i4uI0lhEAFONyKAd1z87OxrNnzyCTyVClShUxHT63gIAAGBkZaVzXw4cP0bx5c2RmZuLkyZNiBgVQ8OPt6+sLGxsbbNmyRWz34sULHDlyBN27d89zvyUSCQ4dOoQffvgBlpaW2LRpE4YNGwYXFxd07969wGNs5N6/xMRExMfHo3nz5rh//z4SExPzXX7btm1o2rQpLC0tER8fL75atmyJ7OxsnDx5skD9ICIiIiop3bp1w8uXL7Fv3z4kJydj3759Wq8fc18rZWZm4tmzZ6hUqRIsLCw0Xj8OGTJE5XN2djaOHj2KTp06qWQHV6pUScwYKYg319u0aVM8e/ZMpVRqYftaHGQyWb73XH///TdiYmKKvI039z0/yqxjpREjRgDAO73nys7OxuHDh9GpUydUrFhRnF6+fHn06tULp0+fVitrW5DvtDi2UxBhYWEAFGWyypcvL05X3lfPnTsXZmZm4nRzc3Po6OiI91ZERG/i/w5E9J/Vq1cvbNu2DXfv3sVff/2l9UaiqFJSUgAApqamWtsMHToUH330Edq0aQNHR0cMGDCg0KWwCvMDPABUrlxZ5bNMJkP58uXfSd3b3KKiolC5cmW1C09l6aqoqCiV6c7OziqflUGON8cD0aYg+9mvXz+8fPkSO3fuBKAo63Xp0iX07du3QNtQ8vf3h6mpKbZs2YKQkBDUq1cPlSpV0tg2JycHP/30EypXrgwDAwPY2NjA1tYWYWFhGn/Ez+v77du3L548eYITJ06gQoUKKvMKerx1dXXRtWtX7N69GxkZGQCAHTt2IDMzM9/ABqAI1EyaNAm3bt1CTEwMNm3ahIYNG2Lr1q0YPnx4vssDwJkzZ9CyZUuYmJjAwsICtra24mDkBQlshIeH4+DBg7C1tVV5tWzZEsDrQQuJiIiI3hfKa5WNGzdix44dyM7Oxmeffaax7cuXLzFlyhRxLDHl9WNCQkKBrh+fPHmCly9farw+1XbNqklBrs8L29fikJKSkuc915w5c3D9+nU4OTmhfv36mDZtWoEfllJ623sud3d36OjovNN7rqdPnyItLU1jaeJq1aohJycHDx48UJlelHuuomynIK5duwYA6NChg8r0O3fuwMjISK2887///gt3d/cClSkmog8TAxtE9J/Vs2dPxMfH44svvoC1tTU+/fTTYl3/9evXAeR9s2BnZ4crV65gz5496NChA44fP442bdogICCgwNvR9jT/u5CdnV1i25JKpRqnCwWoaVtQ1atXR926dcXBBjds2AB9fX1069atUOsxMDBAly5dsG7dOuzcuTPPINmsWbMwevRoNGvWDBs2bMChQ4dw5MgReHh4aBzoOq/vt0uXLkhISBAHmy+qHj16IDk5GX/88QcAYOvWrahatSq8vLwKtZ7y5cujR48eOHnyJCpXroytW7ciKysrz2Xu3buHFi1aID4+HsHBwdi/fz+OHDmCUaNGAUCBBv/OyclBq1atcOTIEY2vrl27Fmo/iIiIiEpCr1698Mcff2D58uVo06YNLCwsNLYbMWIEZs6ciW7dumHr1q04fPgwjhw5Amtr60JfP76NglyfF7avb+vhw4dITEzM856rW7duuH//PhYvXgwHBwfMnTsXHh4e4rVvQbztMX1zLENtYxuW5P0WUDL3XAUVFhaG8uXLq405ePXqVdSoUQMGBgZq0z09PUuyi0RUxnDwcCL6z3J2dkbjxo0RGhoqlikqTuvXrweAfMtE6evro3379mjfvj1ycnIwdOhQrFixAt999x0qVapUqAG9CyI8PBw+Pj7i55SUFMTGxsLf31+cZmlpqVZGSC6XIzY2VmVaYfrm4uKCsLAw5OTkqGQR3L59W5xfnAqyn4Aia2P06NGIjY3Fxo0b0bZtW5USWAXVq1cvrF69Gjo6OnkOuL19+3b4+Pjg119/VZmekJAgDgZYUCNGjEClSpUwZcoUmJub49tvvxXnFeZ4N2vWDOXLl8eWLVvQpEkTHDt2TByguyj09PTg6emJ8PBwxMfHw97eXuu5snfvXmRkZGDPnj0qT4wdP35cra22dbi7uyMlJUXM0CAiIiIqCzp37ozBgwfj3LlzKmVB37R9+3YEBARg/vz54rT09PQCl/20s7ODoaEh7t69qzZP07S38bZ9LayC3nOVL18eQ4cOxdChQ/HkyRPUqVMHM2fOFEtxvYt7rtxZHnfv3kVOTg5cXV0BaL7fAtSz2AvTN1tbWxgbG+POnTtq827fvg0dHR04OTkVbAdKYTthYWEaH6y6evUq2rZtqzItMzMTd+7cKfQDaUT0YWHGBhH9p/3www+YOnWqWPO0uGzcuBGrVq1Co0aN0KJFC63tnj17pvJZR0dHfOpEWRbIxMQEAIrtZuCXX35BZmam+HnZsmXIyspSqa/r7u6uNi7BL7/8ovYEUWH65u/vj7i4OJWbtqysLCxevBgymQzNmzcvyu5oVZD9BBSZOxKJBF999RXu37+PPn36FGl7Pj4++P7777FkyRLY29trbSeVStWegNq2bRsePXpUpO1+9913GDt2LCZMmIBly5aJ0wtzvHV0dPDZZ59h7969WL9+PbKysgpUhio8PBzR0dFq0xMSEnD27FlYWlrC1tYWgPZzRfmUWO5jkpiYiDVr1qit18TEROO51q1bN5w9exaHDh3S2Jf8skaIiIiISoNMJsOyZcswbdo0tG/fXms7TdePixcvLvDT/VKpFC1btsSuXbtUxpm4e/duobIWCrqtt+lrYRw7dgzff/893Nzc0Lt3b41tsrOz1Upg2dnZwcHBQbzfAor/nuvnn39W+bx48WIAEO9F3N3dkZiYKI4rAQCxsbFiidzcCto3qVSKTz/9FLt371YpefX48WNs3LgRTZo0URmjoqjexXays7Nx8+ZNtcBGfHw8YmNj1abfunULmZmZzNggojwxY4OI/tOaN2/+1j+ob9++HTKZDHK5HI8ePcKhQ4dw5swZeHl5Ydu2bXkuO2jQIDx//hy+vr5wdHREVFQUFi9ejFq1aoljIdSqVQtSqRSzZ89GYmIiDAwM4OvrCzs7uyL1Vy6Xo0WLFujWrRvu3LmDpUuXokmTJiq1TAcNGoQhQ4aga9euaNWqFa5evYpDhw6pZRQUpm//+9//sGLFCgQGBuLSpUtwdXXF9u3bcebMGSxYsCDPurjvaj8BxRNHrVu3xrZt22BhYaH2NFBB6ejoYPLkyfm2a9euHWbMmIH+/fvjk08+wbVr1xASEqIy8F5hzZ07F4mJiRg2bBhMTU3Rp0+fQh/v7t27Y/HixZg6dSpq1qwpnn95uXr1Knr16oU2bdqgadOmsLKywqNHj7Bu3TrExMRgwYIFYuCibt26AIBJkyahR48e0NPTQ/v27fHpp5+KWUuDBw9GSkoKVq5cCTs7O7UMobp162LZsmX44YcfUKlSJdjZ2cHX1xfjxo3Dnj170K5dOwQGBqJu3bpITU3FtWvXsH37dkRGRhY6G4aIiIioJBSkBG27du2wfv16mJubo3r16jh79iyOHj0Ka2vrAm9n2rRpOHz4MBo3bowvv/wS2dnZWLJkCWrUqIErV668xR4Uf181+eOPP3D79m1kZWXh8ePHOHbsGI4cOQIXFxfs2bMHhoaGGpdLTk6Go6MjPvvsM3h5eUEmk+Ho0aO4cOGCSlaJtmvVooqIiECHDh3QunVrnD17Fhs2bECvXr3EH+h79OiBb775Bp07d8bIkSORlpaGZcuW4aOPPlIbZL0wffvhhx9w5MgRNGnSBEOHDoWuri5WrFiBjIwMzJkzp8j78663Ex4ejvT0dLUAxtWrVwFAbboyIMTABhHlhYENIqJ8fPnllwAAQ0ND2NjYoFatWli9ejV69eqlVgf0TX369MEvv/yCpUuXIiEhAfb29ujevTumTZsmlg+yt7fH8uXLERQUhIEDByI7OxvHjx8vcmBjyZIlCAkJwZQpU5CZmYmePXti0aJFKinOX3zxBSIiIvDrr7/i4MGDaNq0KY4cOaKWfVKYvhkZGSE0NBTffvst1q1bh6SkJFSpUgVr1qxBYGBgkfblbfdTqV+/fti3bx+6deuW73f2tiZOnIjU1FRs3LgRW7ZsQZ06dbB//36VMlJFsXz5cqSkpKB///4wNTVFx44dC3W8P/nkEzg5OeHBgwcFytYAFCWsvv/+e/zxxx8IDg7G06dPYWpqitq1a2P27NkqY1vUq1cP33//PZYvX46DBw8iJycHERERqFKlCrZv347Jkydj7NixsLe3x5dffglbW1sMGDBAZXtTpkxBVFQU5syZg+TkZDRv3hy+vr4wNjbGiRMnMGvWLGzbtg2//fYbzMzM8NFHH2H69OkwNzd/q2NLREREVJoWLlwIqVSKkJAQpKeno3Hjxjh69Gi+5Zdyq1u3Lv744w+MHTsW3333HZycnDBjxgzcunVLLFX6vvRVkylTpgBQlPG1srJCzZo1sWDBAvHaVxtjY2MMHToUhw8fxo4dO5CTk4NKlSph6dKl4n0coP1atai2bNmCKVOm4Ntvv4Wuri6GDx+OuXPnivOtra2xc+dOjB49GuPHj4ebmxuCgoIQHh6uFtgoTN88PDxw6tQpTJgwAUFBQcjJyUGDBg2wYcMGNGjQoMj78663oxw4/M1AhbYAxrVr12BmZiaW9iIi0kQilMaIQURERCVo9+7d6NSpE06ePImmTZuWdneIiIiIiEpEp06dcOPGDYSHh5d2V4iIiIoVx9ggIqL/vJUrV6JixYpo0qRJaXeFiIiIiOidePnypcrn8PBwHDhwAN7e3qXTISIioneIpaiIiOg/a/PmzQgLC8P+/fuxcOFCjWWqiIiIiIj+CypWrIjAwEBUrFgRUVFRWLZsGfT19TF+/PjS7hoREVGxYykqIiL6z5JIJJDJZOjevTuWL18OXV3G84mIiIjov6l///44fvw44uLiYGBggEaNGmHWrFmoU6dOaXeNiIio2DGwQUREREREREREREREZQbH2CAiIiIiIiIiIiIiojKDgQ0iIiIiIiIiIiIiIiozWGxcg5ycHMTExMDU1JQDzRIRERERFZAgCEhOToaDgwN0dD7cZ6h4P0FEREREVHiFuZ9gYEODmJgYODk5lXY3iIiIiIjKpAcPHsDR0bG0u1FqeD9BRERERFR0BbmfYGBDA1NTUwCKA2hmZlbKvSEiIiIiKhuSkpLg5OQkXk9/qHg/QURERERUeIW5n2BgQwNluriZmRlvRIiIiIiICulDL7/E+wkiIiIioqIryP3Eh1v4loiIiIiIiIiIiIiIyhwGNoiIiIiIiIiIiIiIqMxgYIOIiIiIiIiIiIiIiMoMjrFBREREVMYJgoCsrCxkZ2eXdlfoAyCVSqGrq/vBj6NBREREH66cnBzI5fLS7gZRmaOnpwepVFos62Jgg4iIiKgMk8vliI2NRVpaWml3hT4gxsbGKF++PPT19Uu7K0REREQlSi6XIyIiAjk5OaXdFaIyycLCAvb29m/9oBQDG0RERERlVE5ODiIiIiCVSuHg4AB9fX0+RU/vlCAIkMvlePr0KSIiIlC5cmXo6LC6LREREX0YBEFAbGwspFIpnJyceB1EVAiCICAtLQ1PnjwBAJQvX/6t1sfABhEREVEZJZfLkZOTAycnJxgbG5d2d+gDYWRkBD09PURFRUEul8PQ0LC0u0RERERUIrKyspCWlgYHBwdefxMVgZGREQDgyZMnsLOze6uyVAwrEhEREZVxfFKMShrPOSIiIvoQKce0YzlOoqJTBgUzMzPfaj28IyEiIiIiIiIiIiIqIJZ/JSq64vr7YWCDiIiIiIiIiIiIiIjKDAY2iIiIiOid8/b2hoGBAWQyGaysrODt7Y1Lly6V2PbXrl2LBg0aQCaTwdraGrVr10ZQUBBSU1OLvM7c+6R8LV26tBh7nbddu3ahcuXKMDY2RpMmTXD79m2tbbOysjBp0iQ4OTnBzMwMnTt3FgftA4A2bdqo7IehoSF0dHQQHx9fErtCRERERFQqJBIJdu3alWebZ8+ewc7ODpGRkSXSp7KsR48emD9/folsi4ENIiIiIioRs2fPRkpKCmJiYlC7dm107NixUMsXtQbrN998gylTpmDSpEmIjY3Fs2fPEBISgri4ONy9e/ettqXcJ+Vr6NChRepjYd25cwe9e/fGTz/9hOfPn8PX1xcdO3ZEVlaWxvZz587F/v37ce7cOTx+/Bjm5ubo06ePOP+PP/5Q2Y8vvvgCLVu2hI2NTYnsDxERERG9GxKJJM/XtGnTEBkZCYlEAqlUikePHqksHxsbC11dXUgkkvfih31XV1csWLCgRLc5c+ZMdOzYEa6urgCAq1evomfPnnBycoKRkRGqVauGhQsXqi0XGhqKOnXqwMDAAJUqVcLatWvV2vz8889wdXWFoaEhGjRogPPnz7/jvSm4tWvXwsLColDLTJ48GTNnzkRiYuK76VQu70VgozBf4I4dO/Dxxx/DwsICJiYmqFWrFtavX6/SRhAETJkyBeXLl4eRkRFatmyJ8PDwd70bRERERKVKEAS8TM8usZcgCEXqp6GhIQYOHIhHjx4hKioKw4cPh7OzM+zs7NCvXz/xIlh5g7VmzRpUqlQJjo6OCA0NhYWFBZYuXYoKFSrA0tISCxYswO3bt9GgQQOYmZmhU6dOYibGvXv3MH/+fGzevBkdOnSAqakpAKB69epYuHAhvLy8ACgu2mvVqoWpU6fC3t4ePXr0gCAImD9/Ptzd3WFlZYXWrVvj/v37+e5fcHAwKleuDFNTU7i7u2PJkiUq88PDw9GhQwfY2trCysoKXbp0KfQx3LBhA3x8fNCuXTsYGhriu+++w5MnT3Dq1CmN7Xfu3ImRI0eiQoUKMDIywvTp03HkyBGNN6fp6ekICQnBwIEDC90vIiIiInq/xMbGiq8FCxbAzMxMZdrYsWPFthUqVMBvv/2msvy6detQoUKFku72W8nOzkZOTk6xrCstLQ2//vqryrXxpUuXYGdnhw0bNuDGjRuYNGkSJkyYoHLdHxERgbZt28LHxwdXrlzB119/jUGDBuHQoUNimy1btmD06NGYOnUqLl++DC8vL/j5+alkVpc1NWrUgLu7OzZs2PDOt1XqgY3CfoFWVlaYNGkSzp49i7CwMPTv3x/9+/dXOSnmzJmDRYsWYfny5fj7779hYmICPz8/pKenl9RuEREREZW49IwctPr8dIm90jOKdrOQlpaGVatWwcXFBePGjcPz588RFhaGiIgIZGZmYvjw4Srt9+zZg4sXLyIiIgIAkJycjMjISERERGDbtm0YO3Ysxo4di+3bt+PBgwe4e/cuVqxYAQA4evQoHBwc8Mknn+Tbr+vXr0NXVxfR0dFYv3491q9fj+DgYOzatQsxMTHw8PBA+/bttWZFKLm4uODYsWNISkrCqlWrMG7cOJw5cwYAkJqaipYtW6JGjRqIjIxEXFwcRowYIS7r6ekJCwsLrS+lsLAw1KpVS/ysp6eH6tWrIywsTGOfcnJyVAJRyhs9Te137twJHR0ddO7cOd9jRkRERETvN3t7e/Flbm4OiUSiMk0mk4ltAwICsGbNGpXl16xZg4CAgHy34+rqilmzZmHAgAEwNTWFs7MzfvnlF5U2Dx48QLdu3WBhYQErKyt07NhR5UEbb29vfP311yrLdOrUCYGBgeL8qKgojBo1Ssw4AV5nFuzZswfVq1eHgYEBoqOjceHCBbRq1Qo2NjYwNzdH8+bNcfny5UIcPeDAgQMwMDBAw4YNxWkDBgzAwoUL0bx5c1SsWBF9+vRB//79sWPHDrHN8uXL4ebmhvnz56NatWoYPnw4PvvsM/z0009im+DgYHzxxRfo378/qlevjuXLl8PY2BirV6/W2p/AwEB06tQJs2bNQrly5WBhYYEZM2YgKysL48aNg5WVFRwdHdW+xzeFhoZCIpFg//798PT0hKGhIRo2bIjr16+L8/v374/ExESV7B4AWLp0KSpXrgxDQ0OUK1cOn332mcq627dvj82bNxf4GBdVqQc2CvsFent7o3PnzqhWrRrc3d3x1VdfwdPTE6dPnwageFJxwYIFmDx5Mjp27AhPT0/89ttviImJybdeGhERERG9OxMmTICFhQUqVqyI27dvY926dfj999/x888/i9m4M2bMwJYtW5CdnS0uN3XqVFhYWMDY2FicNn36dOjr66Nly5awsrJC+/bt4eTkBHNzc/j7+4s3LPHx8XBwcFDpR6tWrcT15X6qytzcHJMmTYK+vj6MjY2xfv16jBw5EjVr1oShoSFmzZqFBw8eqGQXK/dJ+UpNTUXXrl3h5OQEiUQCHx8f+Pn5ITQ0FACwb98+6OnpYebMmTAxMYG+vj58fHzE9YWFhSEhIUHrSyklJUUtLdzCwgLJyckaj33btm2xcOFCREdHIyUlBVOmTIFEIkFSUpJa21WrVqFv377Q19fX8k0SERER0X9Rhw4d8OLFC/F31tOnT+PFixdo3759gZafP38+Pv74Y/zzzz8YOnQovvzyS9y5cweAotSrn58fTE1NcerUKZw5cwYymQytW7eGXC4v0Pp37NgBR0dHzJgxQ8w4UUpLS8Ps2bOxatUq3LhxA3Z2dkhOTkZAQABOnz6Nc+fOoXLlyvD399d6zazJqVOnULdu3XzbJSYmwsrKSvx89uxZtGzZUqWNn58fzp49CwCQy+W4dOmSShsdHR20bNlSbKPNsWPHEBMTg5MnTyI4OBhTp05Fu3btYGlpib///htDhgzB4MGD8fDhw3z7PW7cOMyfPx8XLlyAra0t2rdvj8zMTHzyySdqGT5jx47FxYsXMXLkSMyYMQN37tzBwYMH0axZM5V11q9fH+fPn0dGRka+238buu907flQfoETJkwQpxX0CwQUQYxjx47hzp07mD17NgBFmk9cXJzKSWFubo4GDRrg7Nmz6NGjh9p6MjIyVA60phs8IiIiovedoYEOjmxrUqLbK4ygoCCVJ7AuXLiAnJwcuLm5qbTT0dFBXFyc+NnZ2VllvqmpKYyMjMTPxsbGKFeunMrnlJQUAICNjQ1iYmJUlj9y5AgAxQMzubMvKlSoAB2d1/v08OFDsY4uABgYGMDBwUHlBuHNfQKAkJAQzJ8/H5GRkcjJyUFaWpq4j1FRUXB3dxefLisqmUymVrc2MTFRLLX1pgkTJiA5ORlNmzZFZmYmxowZg927d8Pa2lqlXUREBI4fP66xRjARERERabCiOZBSCqWDZHbA4BPFuko9PT306dMHq1evRpMmTbB69Wr06dMHenp6BVre399fHHPum2++wU8//YTjx4+jSpUq2LJlC3JycrBq1SrxWnjNmjWwsLBAaGgoPv3003zXb2VlBalUClNTU9jb26vMy8zMxNKlS8VSswDg6+ur0uaXX36BhYUFTpw4gXbt2hVon6KiotQelHrTX3/9hS1btmD//v3itLi4OJV7FAAoV64ckpKS8PLlS7x48QLZ2dka29y+fTvP7VlZWWHRokXQ0dFBlSpVMGfOHKSlpWHixIkAFNf+P/74I06fPq3xt/Dcpk6dilatWgFQlB1zdHTEzp070a1bN5UMH6Xo6GiYmJigXbt2MDU1hYuLC2rXrq2yTgcHB8jlcsTFxcHFxSXP7b+NUs3YiI+P1/oF5r6ZfVNiYiJkMhn09fXRtm1bLF68WPwClMsVZp1BQUEwNzcXX05OTm+zW0RERESlQiKRwMhQWmKvt/1x3snJCTo6OoiJiVHJSkhPT1ep45s72FBYLVq0wKNHj3Du3Ll82765HUdHR5XUeLlcjpiYGDg6OmpdR3R0NAICAjBnzhw8efIECQkJ8Pf3F8tAubi44N69e1rHJ/Hw8IBMJtP6UvL09MSVK1fEz5mZmbh58yZq1qypcb2GhoYIDg5GVFQUYmJi4O/vD7lcjgYNGqi0+/XXX1G/fn3UqFFD6z6WNSdPnkT79u3h4OAAiURSqCzuM2fOQFdXV6XsFxEREZGKlCdAckzJv95RMGXAgAHYtm0b4uLisG3bNgwYMKDAy3p6eorvlT+IK4cbuHr1Ku7evQtTU1Px2tbKygrp6em4d+/eW/dbX19fZfsA8PjxY3zxxReoXLkyzM3NYWZmhpSUFERHRxd4vS9fvoShoaHW+devX0fHjh0xderUAgVnioOHh4fKvUu5cuVU7gOkUimsra3FY9+mTRvxmHt4eKisq1GjRuJ7KysrVKlSBbdu3dK67VatWsHFxQUVK1ZE3759ERISgrS0NJU2yofQ3pxe3Eq9FFVRmJqa4sqVK7hw4QJmzpyJ0aNHi+n9RTFhwgQkJiaKrwcPHhRfZ/+jMpNSELV8I9Jjy+5gNkRERFS67O3t0alTJwwfPhzx8fEAFA+p7Ny5s9i2UalSJYwaNQo9evTA3r17kZKSAkEQ8O+//+b5IA0A9OnTB0uWLMHNmzeRkZGByZMno0KFCqhfv77WZZTrt7Ozg46ODg4cOIDDhw+L89u2bYuMjAxMmTIFqampkMvlOH78uDj/xo0bSElJ0frK3bdjx47hwIEDyMjIwMyZM2FjY6OWBq4UGxuLqKgoCIKA8PBwDBw4EKNHj1ZJl8/OzsbatWv/c4OGp6amwsvLCz///HOhlktISEC/fv3QokWLd9QzIiIi+k+Q2QGmDiX/ktm9k92pWbMmqlatip49e6JatWqFeuDlzcwOiUQiju2WkpKCunXr4sqVKyqvf//9F7169QKgeNDozQeAMjMzC7RtIyMjtQevAgICcOXKFSxcuBB//fUXrly5Amtr6wKXvgIUGeAvXrzQOO/mzZto0aIF/ve//2Hy5Mkq8+zt7fH48WOVaY8fP4aZmRmMjIxgY2MDqVSqsc2b2Shv0nSc8zr2q1atEo/3gQMH8lx3fkxNTXH58mVs2rQJ5cuXx5QpU+Dl5aVSNvf58+cAAFtb27faVn5KtRRVUb9AHR0dVKpUCQBQq1Yt3Lp1C0FBQfD29haXe/z4McqXL6+yTm1PWhkYGMDAwOAt9+bDkZ0hx8XOX+L5yfNIvHILnsu/L+0uERERURm1du1aTJ06FfXq1cOzZ89Qrlw5dO/evVgHrp43bx6qVauG6dOno3v37jA2NoaTkxMCAwPRv39/rcv169cPjx8/Rrt27fDixQvUr18fe/fuha6u9kvo6tWrY9KkSfD19UV2djY6dOiADh06iPNlMhmOHj2KUaNGiSW2fHx8VMbZKIgqVapgw4YN+Oqrr/Dw4UPUqVMHe/bsEft26tQptGnTRgyGREdHo1evXoiNjYWtrS0GDx6sUg4WAA4dOoSEhIR809XLmjZt2qBNmzaFXm7IkCHo1asXpFIpx+p7F57cAg5OAHR0Acd6QN1AwLRcvosRERG9d4q5HNT7YMCAARg6dCiWLVtWbOusU6cOtmzZAjs7O5iZmWlsY2trqzJuRnZ2Nq5fv65yrayvr68yHl9ezpw5g6VLl8Lf3x+AYvBy5QNVBVW7dm1s2LBBbfqNGzfg6+uLgIAAzJw5U21+o0aN1IIIR44cETMk9PX1UbduXfz555/o1KkTACAnJwd//vknhg8fXqg+5id3Nvybzp07J96XvHjxAv/++y+qVasm9lHTsdbV1UXLli3RsmVLcTzEY8eOoUuXLgAUWSyOjo6wsbEp1v1Q68c7XXs+iusLzMnJEcfIcHNzg729Pf78808xkJGUlIS///4bX375ZXHvwgdHEARc+98kPD+pGDQz6crNUu4RERERlQXasmtNTU0RHByM4OBgtXmurq5qT2x5e3urPA0EQKVcFABMmzZNbV0DBw7MMxMhMDAQgYGBKtMkEgnGjx+P8ePHa1xG2z7NmDEDM2bM0LqtKlWqvPWTUgDQuXNnrQGgpk2bqmR4NGjQIN8Uf39/f5VlPmRr1qzB/fv3sWHDBvzwww/5tueYfUVw7Afg/qtspbtHFO8HHCzdPhEREREA4IsvvsDnn38OCwuLYltn7969MXfuXHTs2BEzZsyAo6MjoqKisGPHDowfPx6Ojo7w9fXF6NGjsX//fri7uyM4OFjt2t/V1RUnT55Ejx49YGBgkOeP55UrV8b69evx8ccfIykpCePGjVMZq68g/Pz8MGHCBLx48QKWlpYAFD/c+/r6ws/PD6NHjxYzwaVSqZilMGTIECxZsgTjx4/HgAEDcOzYMWzdulVlHI7Ro0cjICAAH3/8MerXr48FCxYgNTU1z4evituMGTNgbW2NcuXKYdKkSbCxsRF/p3d1dUVKSgr+/PNPeHl5wdjYGMeOHcP9+/fRrFkzWFpa4sCBA8jJyUGVKlXEdZ46dapEynKVeimq0aNHY+XKlVi3bh1u3bqFL7/8UuUL7Nevn8rTZEFBQThy5Aju37+PW7duYf78+Vi/fj369OkDQHED+vXXX+OHH37Anj17cO3aNfTr1w8ODg7il0JFl3T5Bh5t3CN+TrlzX2uNaCIiIiKisiY8PBzffvstNmzYkGd2Tm4cs68IHl1W/fzgPJCZXjp9ISIiIhW6urqwsbEp8LVQQRgbG+PkyZNwdnZGly5dUK1aNQwcOBDp6eliBseAAQMQEBCAfv36oXnz5qhYsaJaZvOMGTMQGRkJd3f3fEsd/frrr3jx4gXq1KmDvn37YuTIkbCzK1wJr5o1a6JOnTrYunWrOG379u14+vQpNmzYgPLly4uvevXqiW3c3Nywf/9+HDlyBF5eXpg/fz5WrVoFPz8/sU337t0xb948TJkyBbVq1cKVK1dw8OBBtbGj36Uff/wRX331FerWrYu4uDjs3bsX+vr6AIBPPvkEQ4YMQffu3WFra4s5c+bAwsICO3bsgK+vL6pVq4bly5dj06ZN4tgd6enp2LVrF7744ot33neJ8B78Kr1kyRLMnTsXcXFxqFWrFhYtWiQOZOjt7Q1XV1esXbsWADB58mRs2bIFDx8+hJGREapWrYqvvvoK3bt3F9cnCAKmTp2KX375BQkJCWjSpAmWLl2Kjz76qED9SUpKgrm5ORITE7WmRn2oHv62E1cHfgurpvXw4uw/ELKy4Hs/FEZO5fNfmIiIiIpVeno6IiIi4ObmlueAdkTFTdu5975fR0skEuzcuVPrA0/Z2dlo2LAhBg4ciCFDhgBQZADt2rVLZbD2N2nK2HBycnpvj0OpS40H5rqrTx9yGrCvqT6diIjoPcHr7w/T/v37MW7cOFy/fl1l0O6yLDQ0FD4+Pnjx4kWxZuYsW7YMO3fuVBln8E15/R0V5n6iVEtRKQ0fPlxr6ak3U/x/+OGHfNPBJRJJviUAqGhS/o0AAMiqV0LG02dIvX0fKbfuMrBBRERERGVecnIyLl68iH/++Ue8P8nJyYEgCNDV1cXhw4fh6+urthzH7CukuDDN0x/fZGCDiIiI3jtt27ZFeHg4Hj16xMzcfOjp6WHx4sUlsq33IrBBZUdqeCQAQPaRG+RPlIGNe7D9tGnpdoyIiIiI6C2ZmZnh2rVrKtOWLl2KY8eOYfv27XBzcyulnv3HxOU6xh6dgRs7Fe+fcPw+IiIiej99/fXXpd2FMmHQoEElti0GNqhQUl9lbJh85Ap5/HMAQMrt+6XZJSIiIiIirVJSUnD37l3xc0REBK5cuQIrKys4OztjwoQJePToEX777Tfo6OigRo0aKsvb2dnB0NBQbTq9hdyBDc/uuQIbt0qnP0REREQfGG9v7zI/bjIDG1RgQk4OUu9GAQBMKrsh83kiACDl9r3S7BYRERERkVYXL15UGXRy9OjRAICAgACsXbsWsbGxiI6OLq3ufZiUgQ2pPuDeAtA3BeTJDGwQERERUYExsEEFlv4wDjnpGZDo6cHIxQFZickAgORbd/NZkoiIiIiodOT3NNratWvzXH7atGmYNm1a8XbqQ5b5Eoj/V/Hetiqgqw/YVQMengcSo4H0JMCQA64TERERUd7+G8O4U4lQjq9h7O4EHV1dyKpWBCQSZD5LQMbT56XbOSIiIiIiev89uQkIOYr39p4AgLuSXINwPr1TCp0iIiIiorKGgQ0qsJRX42vIKrsCAKTGRjBycVDMYzkqIiIiIiLKT9z11+/tawIAEmSVX0/jAOJEREREVAAMbFCBvR443A3ZcVFIWx8EE0drxTwOIE5ERER58Pb2hoGBAWQyGaysrODt7Y1Lly6V2PbXrl2LBg0aQCaTwdraGrVr10ZQUBBSU1OLvM7c+6R8LV26tBh7nbddu3ahcuXKMDY2RpMmTXD79m2tbbOysjBp0iQ4OTnBzMwMnTt3xpMnT8T5KSkpGDJkCMqXLw8LCwv0798faWlpJbEb9KFJfPD6vXUlxSTTSq+nMbBBRERERAXAwAYVmLIUlUllN2RePwshLQV6SAEApMc+yWNJIiIiImD27NlISUlBTEwMateujY4dOxZq+czMzCJt95tvvsGUKVMwadIkxMbG4tmzZwgJCUFcXBzu3tU8VlhBt6XcJ+Vr6NChRepjYd25cwe9e/fGTz/9hOfPn8PX1xcdO3ZEVlaWxvZz587F/v37ce7cOTx+/Bjm5ubo06ePOH/MmDG4f/8+bt68icjISMTExODrr78ukX2hD0xy3Ov3puUAAAmyXIGNp9oDdERERERESgxsUIGJgQ13J2RHKwb805cZAAAyHj8trW4RERHRK4IgIDOr5F55DcicF0NDQwwcOBCPHj1CVFQUhg8fDmdnZ9jZ2aFfv35ITEwEAERGRkIikWDNmjWoVKkSHB0dERoaCgsLCyxduhQVKlSApaUlFixYgNu3b6NBgwYwMzNDp06dxEyMe/fuYf78+di8eTM6dOgAU1NTAED16tWxcOFCeHl5AVBkdNSqVQtTp06Fvb09evToAUEQMH/+fLi7u8PKygqtW7fG/fv5Z6kGBwejcuXKMDU1hbu7O5YsWaIyPzw8HB06dICtrS2srKzQpUuXQh/DDRs2wMfHB+3atYOhoSG+++47PHnyBKdOndLYfufOnRg5ciQqVKgAIyMjTJ8+HUeOHEFkZKQ4/9tvv4WlpSUsLCwwceJErF+/Hi9fvix034jylPL49XvT8gCADH0rZOkYKqblDnwQERFRmSOXy1GpUiX89ddfpd0V0uDmzZtwdHR8q8z194VuaXeAygZBEPDygeImQ98wC8jMgMRIBn0rMwBAegFu8omIiOjdysoGFu8vue2NaAvoFeFqMi0tDatWrYKLiwvGjRsHXV1dhIWFQU9PD4MGDcLw4cOxfv16sf2ePXtw8eJF6Ovr4/z580hOTkZkZCQiIiJw8uRJtG7dGkePHsX27dthZmaGxo0bY8WKFRg9ejSOHj0KBwcHfPLJJ/n26/r16+jatSuio6ORlZWF9evXIzg4GAcPHkTlypUxadIktG/fHlevXoWurvYdd3FxwbFjx8RAjL+/P2rXro3GjRsjNTUVLVu2RO/evbFp0ybo6enhzJkz4rKenp6Ijo7Wuu6EhAQAQFhYGGrVqiVO19PTQ/Xq1REWFgYfHx+15XJyclQCUTk5OeJ6XF1dNc5PT09HeHg4PD098z12RAWWHKv4V0cXMLJSvJdIkG5gDdnLR0AKM8GJiKjs2fi39uu3d6FXA+dCtQ8MDMS6deswePBgLF++XGXesGHDsHTpUgQEBGDt2rXi9Li4OMycORP79+/Ho0ePYGdnh1q1auHrr79GixYttG5r+fLlcHNzU7n+dnV1RVRUlEq7oKAgfPvtt+LnsLAwDBs2DBcuXICtrS1GjBiB8ePH57lf0dHR+PLLL3H8+HHIZDIEBAQgKChI5Vo9NDQUo0ePxo0bN+Dk5ITJkycjMDBQZT0///wz5s6di7i4OHh5eWHx4sWoX79+ntt+X7i6uuLrr78ucLZ19erV0bBhQwQHB+O77757t517x5ixQQWS+TwBwquSDLopipsRqZsHDD+qCgCQP3lWan0jIiKismHChAmwsLBAxYoVcfv2baxbtw6///47fv75Z1hYWMDExAQzZszAli1bkJ2dLS43depUWFhYwNjYWJw2ffp06Ovro2XLlrCyskL79u3h5OQEc3Nz+Pv74/LlywCA+Ph4ODg4qPSjVatW4vpyZ1OYm5tj0qRJ0NfXh7GxMdavX4+RI0eiZs2aMDQ0xKxZs/DgwQOcP39ebZ+Ur9TUVHTt2hVOTk6QSCTw8fGBn58fQkNDAQD79u2Dnp4eZs6cCRMTE+jr66sEIsLCwpCQkKD1pZSSkgILCwuV/bKwsEBycrLGY9+2bVssXLgQ0dHRSElJwZQpUyCRSJCUlCTODwoKQnx8POLj4zFr1iwAEOcTFZvkVxkbsnKAzuvb0ZcGNq/ePAey5KXQMSIiov82JycnbN68WSUjNz09HRs3boSzs2qgJDIyEnXr1sWxY8cwd+5cXLt2DQcPHoSPjw+GDRumdRuCIGDJkiUYOHCg2rwZM2YgNjZWfI0YMUKcl5SUhE8//RQuLi64dOkS5s6di2nTpuGXX37Ruq3s7Gy0bdsWcrkcf/31F9atW4e1a9diypQpYpuIiAi0bdsWPj4+uHLlCr7++msMGjQIhw4dEtts2bIFo0ePxtSpU3H58mV4eXnBz89PZTy6/5r+/ftj2bJlWsvYlhXM2KACyYhVlJrSs7ZAzqNwAICuW3UY3H+umB+fUFpdIyIiold0pYosipLcXmEEBQWpPEl04cIF5OTkwM3NTaWdjo4O4uJel6N580bL1NQURkZG4mdjY2OUK1dO5XNKimIcMBsbG8TExKgsf+TIEQCKwb9zX8xXqFABOrl+aH348CFcXV3FzwYGBnBwcMDDhw+17hMAhISEYP78+YiMjEROTg7S0tLEfYyKioK7uzskEon6ASoEmUwmluxSSkxMFEttvWnChAlITk5G06ZNkZmZiTFjxmD37t2wtrYGACxYsABjxoyBl5cXdHV1MXbsWBw9elScT1QssrOA1FclbGXlVGalG+Q611KfAuYVSrBjRERE/3116tTBvXv3sGPHDvTu3RsAsGPHDjg7O6tdjw8dOhQSiQTnz5+HiYmJON3DwwMDBgzQuo1Lly7h3r17aNtW/abE1NQU9vb2GpcLCQmBXC7H6tWroa+vDw8PD1y5cgXBwcH43//+p3GZw4cP4+bNmzh69CjKlSuHWrVq4fvvv8c333yDadOmQV9fX8wemT9/PgCgWrVqOH36NH766Sf4+fkBUJSR/eKLL9C/f38AioyT/fv3Y/Xq1SoZJblduHABEydOxD///IPMzEzUqlULP/30E+rUqSO2uX37NgYNGoSLFy+iYsWKWLRoEVq1aoWdO3eiU6dOAIAHDx5gzJgxOHz4MHR0dNC0aVMsXLhQvAcJDAxEQkICmjRpgvnz50Mul6NHjx5YsGAB9PT04O3tjaioKIwaNQqjRo0CoAguKcv9nj59GnK5HK6urpg7dy78/f0BKB70ev78OU6cOJFn9s37jhkbVCAZj+MBAAY2FkB6KqBvCJ3ybjBwcgQAyF+klGLviIiICAAkEgn0dEvu9bY/zjs5OUFHRwcxMTEqWQnp6emoUOH1j5q5gw2F1aJFCzx69Ajnzp3Lt+2b23F0dBTHoAAU9YJjYmLg6OiodR3R0dEICAjAnDlz8OTJEyQkJMDf318s8+Ti4oJ79+5pHZ/Ew8MDMplM60vJ09MTV65cET9nZmbi5s2bqFmzpsb1GhoaIjg4GFFRUYiJiYG/vz/kcjkaNGgAALC0tMTq1avFcU8qVaoEe3t7VKlSJc9jRlQoqU8BvDr3TVV/2EjXt3n9Ifc4HERERFRsBgwYgDVr1oifV69eLf6gr/T8+XMcPHgQw4YNUwlqKL2ZNZzbqVOn8NFHH2l82ObHH3+EtbU1ateujblz56o8YHT27Fk0a9YM+vr64jQ/Pz/cuXMHL1680Lits2fPombNmioPOPn5+SEpKQk3btwQ27Rs2VJlOT8/P5w9exaA4vr+0qVLKm10dHTQsmVLsY0mycnJCAgIwOnTp3Hu3DlUrlwZ/v7+YvZ0dnY2OnXqBGNjY/z999/45ZdfMGnSJJV1ZGZmws/PD6ampjh16hTOnDkDmUyG1q1bQy5/nb16/Phx3Lt3D8ePHxezUpQlw3bs2AFHR0eVbBhAUV4sIyMDJ0+exLVr1zB79myVewl9fX3UqlVL6/h8ZQUDG1Qg6XGKJ6v0LRX/oUnLOUEilcLoVUQ3+6UcWS/TS61/REREVPbY29ujU6dOGD58OOLjFQ9RxMXFYefOncW2jUqVKmHUqFHo0aMH9u7di5SUFAiCgH///VclK0STPn36YMmSJbh58yYyMjIwefJkVKhQIc96u8r129nZQUdHBwcOHMDhw4fF+W3btkVGRgamTJmC1NRUyOVyHD9+XJx/48YNpKSkaH3l7tuxY8dw4MABZGRkYObMmbCxsUGzZs009is2NhZRUVEQBAHh4eEYOHAgRo8eDSsrxRgHERERePz4MQRBwD///INRo0Zh+vTpbxVUIlKjHF8DEDM2lDXJxVJUAMfZICIiekf69OmD06dPIyoqClFRUThz5gz69Omj0ubu3bsQBAFVq1Yt9PqjoqLUysACwMiRI7F582YcP34cgwcPxqxZs1TGz4iLi1MJUAAQP2u7Zi/IMtraJCUl4eXLl4iPj0d2drbGNnndK/j6+qJPnz6oWrUqqlWrhl9++QVpaWk4ceIEAEWG+L179/Dbb7/By8sLTZo0wcyZM1XWsWXLFuTk5GDVqlWoWbMmqlWrhjVr1iA6OlosYwsoHkBasmQJqlatinbt2qFt27b4888/AQBWVlaQSqViNowyIyY6OhqNGzdGzZo1UbFiRbRr107tPsHBwUFt3JOyhqWoqEAylIENmQEAQMe6PABAz9EJEqkEQrYA+cNH0K3sXmp9JCIiorJn7dq1mDp1KurVq4dnz56hXLly6N69Ozp37lxs25g3bx6qVauG6dOno3v37jA2NoaTkxMCAwPVnlDLrV+/fnj8+DHatWuHFy9eoH79+ti7d2+eA4dXr14dkyZNgq+vL7Kzs9GhQwd06NBBnC+TyXD06FGMGjVKLLHl4+OjccDvvFSpUgUbNmzAV199hYcPH6JOnTrYs2eP2LdTp06hTZs2YjAkOjoavXr1QmxsLGxtbTF48GBMmDBBXN/Vq1cxfPhwPH/+HI6Ojhg/fjwGDRpUqD4R5St3JoZpeZVZKqWomLFBRET0Ttja2qJt27ZYu3YtBEFA27ZtYWNjo9JGW2ZxQbx8+RKGhoZq00ePHi2+9/T0hL6+PgYPHoygoCAYGBgUeXul5fHjx5g8eTJCQ0Px5MkTZGdnIy0tDdHRigc27ty5AycnJ5XSW28+HHX16lXcvXtXLbslPT0d9+7dEz97eHhAKn1dA7h8+fK4du1anv0bOXIkvvzySxw+fBgtW7ZE165d4enpqdLGyMgIaWlphdvx9wwDG1QgGXGKpyj1jRUlJ5SBDR09feibGSHjRRrSIyNhzMAGERERaZD7qaPcTE1NERwcjODgYLV5rq6uajdW3t7eKoNoA1ApFwUA06ZNU1vXwIEDNQ5iqBQYGIjAwECVaRKJBOPHj1d5miw3bfs0Y8YMzJgxQ+u2qlSpggMHDmidX1CdO3fWGgBq2rSpSoZHgwYNVG6Q3tSpUyex1i/RO5Oc68lHU9UnI5mxQUREVDIGDBiA4cOHAwB+/vlntfmVK1eGRCLB7du3C71uGxubfH90BxTXpllZWYiMjESVKlVgb2+Px49VH2xQftY2Loe9vT3Onz+f5zLa1mtmZgYjIyNIpVJIpVKNbbRtFwACAgLw7NkzLFy4EC4uLjAwMECjRo1USkjlJyUlBXXr1kVISIjaPFtbW/G9np6eyjyJRIKcnJw81z1o0CD4+flh//79OHz4MIKCgjB//nyVAdufP38Od/ey/Tsuc8upQJQZG3r6ij8cHWt7ZGZm4uXLl9CzUNRoy4iKLrX+ERERERHRey53JobMXixDBQDpBhxjg4iIqCQox3BQjvHwJisrK/j5+eHnn39Gamqq2vw3HzLKrXbt2rh9+3a+WR9XrlyBjo4O7OzsAACNGjXCyZMnkZmZKbY5cuQIqlSpAktLS43raNSoEa5du4YnT56oLGNmZobq1auLbZRlm3K3adSoEQDFWBN169ZVaZOTk4M///xTbKPJmTNnMHLkSPj7+8PDwwMGBgZiaV1A8SDTgwcPVAImFy5cUFlHnTp1EB4eDjs7O1SqVEnlZW5urnXbb9LX10d2drbadCcnJwwZMgQ7duzAmDFjsHLlSpX5169fR+3atQu8nfcRAxtUIK9LUekBunpIkxriQXQ0YmNiIH0V2Eh/FFOaXSQiIiIiovdZ7jE28szYYGCDiIjoXZFKpbh16xZu3rypUuIot59//hnZ2dmoX78+fv/9d4SHh+PWrVtYtGhRnj/4+/j4ICUlRRy8G1AM4L1gwQJcvXoV9+/fR0hICEaNGoU+ffqIQYtevXpBX18fAwcOxI0bN7BlyxYsXLhQpYTVmz799FNUr14dffv2xdWrV3Ho0CFMnjwZw4YNE8tbDRkyBPfv38f48eNx+/ZtLF26FFu3bsWoUaPE9YwePRorV67EunXrcOvWLXz55ZdITU3Ns2Rt5cqVsX79ety6dQt///03evfuDSMjI3F+q1at4O7ujoCAAISFheHMmTOYPHkyAEXGBQD07t0bNjY26NixI06dOoWIiAiEhoZi5MiRePjwodZtv8nV1RUnT57Eo0ePxODK119/jUOHDiEiIgKXL1/G8ePHUa1aNXGZyMhIPHr0SG1g9bKGgQ0qEHHwcDND6Fja4WX664HCda0VUUR5LFPGiYiIiIhIi+TXAYud4apPFqbr5xpjI/VpSfWIiIjog2RmZgYzMzOt8ytWrIjLly/Dx8cHY8aMQY0aNdCqVSv8+eefWLZsmdblrK2t0blzZ5XySgYGBti8eTOaN28ODw8PzJw5E6NGjcIvv/witjE3N8fhw4cRERGBunXrYsyYMZgyZQr+97//iW1CQ0MhkUjEMrRSqRT79u2DVCpFo0aN0KdPH/Tr10+lJKybmxv279+PI0eOwMvLC/Pnz8eqVatUMlW6d++OefPmYcqUKahVqxauXLmCgwcPqg0ontuvv/6KFy9eoE6dOujbty9GjhwpZp8o+7Zr1y6kpKSgXr16GDRoECZNmgQA4hgkxsbGOHnyJJydndGlSxdUq1YNAwcORHp6ep7fzZtmzJiByMhIuLu7iyWssrOzMWzYMFSrVg2tW7fGRx99hKVLl4rLbNq0CZ9++ilcXFwKvJ33kUR4mxFh/qOSkpJgbm6OxMTEQp1I/2WHbOshKyEJ9SZ/CnNvXzx1rwd5RgaMjY3xYNwMPNlyDE7t6sJz58bS7ioREdEHIz09HREREXBzc9M4SB/Ru6Lt3ON1tAKPgxa/eAMx/wASHWz69BIEHdUhH3sdbwKkJwJWFYGR/5ROH4mIiPLA6+/8hYWFoVWrVrh37x5kMlmxrXfNmjWYNWsWbt68qTbuRFlw5swZNGnSBHfv3i3VsS3kcjkqV66MjRs3onHjxqXSh7z+jgpzHc3Bwylf2S/TkZWQBECRsSGxtoc8IwMAIDM1hdROkTYuf5ZQWl0kIiIiIqL3nTJjw8RWLagBAJCVUwQ2OHg4ERFRmeXp6YnZs2cjIiICNWvWLLb1HjhwALNmzSozQY2dO3dCJpOhcuXKuHv3Lr766is0bty41Afsjo6OxsSJE0stqFGcGNigfGU8VtRn09GVQtdIDzlmNkAmINHRgbGxMXTs7RXtnidDyM6GREt9PiIiIiIi+kDl5LweO0OmpbSDrBwQ/y8gTwEyUgCD4nvKk4iIiEpOYGBgsa9z27Ztxb7Odyk5ORnffPMNoqOjYWNjg5YtW2L+/Pml3S1xgPL/AgY2KF8ZcYrAhr65ISQSCTL1jIDMDBjo60NHRwf6DorARmZSOoTUREjMrEqzu0RERERE9L5JiwcExbgaj7LNNbcxsX39PvUJAxtERERUZvXr1w/9+vUr7W78p3HwcMpXhnLgcFMDxWeJ4rTRN1B8NqqgCGzIUzIgJL0ohR4SEREREdF7LdeA4CoDheeWO5OD5aiIiIiIKA8MbFC+xMCGuSGgI4U8KwcAYKCvDwAwLm8HAMhMyUBOalLpdJKIiIiIiN5fLxPEtxn6FprbyOxev1eWrSIiIiIi0oCBDcpXujKwYWYIGBhCnpmp+PwqY8O4vB0gASAAGU/iS6ubRERE9B7z9vaGgYEBZDIZrKys4O3tjUuXLpXY9teuXYsGDRpAJpPB2toatWvXRlBQEFJTU4u8ztz7pHwtXbq0GHut3fXr1+Hn5wcbGxtIJBIkJCTku8yKFSvg7OwMExMTtG3bFrGxseK848ePw8fHB+bm5rCwsHh3HacPV3qC+FauZ6a5DTM2iIiojBAEobS7QFRm5eTkFMt6OMYG5Uv++BkAQN/UENA3FE8+fX19ZGYJSMo0hq6pEbKSXiIjJg6shEtERESazJ49G19//TXS09MxYcIEdOzYEQ8fPizw8pmZmdDT0yv0dr/55hts2rQJS5YsgY+PD0xNTXHz5k2sWLECd+/ehZeXV5G3pdynkqanp4du3bphxIgRaN++fb7tjx07hm+++QaHDh1CjRo1MGLECPTu3RvHjh0DAJiYmGDAgAHo06cPxowZ8667Tx+il69L1sp1GdggIqKySU9PDxKJBE+fPoWtrS0kEklpd4mozBAEAXK5HE+fPlWM2/yqGlBRMbBB+ZI/TwAA6JnoA/qGivev/iM/eVPA1QgpvMxlyEp6iZexTBknIiKivBkaGmLgwIFYsGABoqKiMHfuXOzZswfp6elo3bo1Fi9eDHNzc0RGRsLNzQ2rV6/GzJkzkZycjC1btqBTp06YNWsWZs6cibS0NEydOhWtW7dGQEAAbt26BV9fX4SEhMDExAT37t3D/PnzcfLkSXzyySdiH6pXr46FCxeKn9euXYsFCxagY8eOWLFiBRo3bozt27cjODgYS5cuxYsXL1C/fn0sXboUFStWzHP/goODsWzZMsTFxcHOzg6jRo3C8OHDxfnh4eEYM2YMzp49i+zsbHh7e2PHjh2FOoZVqlRBlSpVEBkZWaD2a9asQZ8+fdCgQQMAQFBQEBwcHHD//n1UrFgR9evXR/369REaGlqofhAVWK5SVHJ9LYOHq5Siinu3/SEiIioCqVQKR0dHPHz4sMDXYUSkytjYGM7OztDRebtiUgxsUL7kzxRPV+maGEDQUwQ2dHUVp07UEwCQQGpuCjx4KrYlIiKikicIQommxUskkiI9pZaWloZVq1bBxcUF48aNg66uLsLCwqCnp4dBgwZh+PDhWL9+vdh+z549uHjxIvT19XH+/HkkJycjMjISEREROHnyJFq3bo2jR49i+/btMDMzQ+PGjbFixQqMHj0aR48ehYODg0pQQ5vr16+ja9euiI6ORlZWFtavX4/g4GAcPHgQlStXxqRJk9C+fXtcvXpVvBbSxMXFBceOHYOjoyNCQ0Ph7++P2rVro3HjxkhNTUXLli3Ru3dvbNq0CXp6ejhz5oy4rKenJ6Kjo7WuuyAlpzQJCwvDiBEjxM/lypWDvb09rl27lm+ghqhY5C5FpS1jw8T29fu05++2P0REREUkk8lQuXJlZL4q1U5EBSeVSqGrq1ss2U4MbFC+Mp8nAgD0TPQg6ClShKRSKV7KBSS8KkstyEwVbV9w8HAiIqLSIggCIiMiSmx7rm5uhbognTBhAqZNmwZDQ0PUqlUL69atg6+vL+Lj48VxHWbMmAEPDw+sXbtWXG7q1Klq4z5Mnz4d+vr6aNmyJaysrNC+fXs4OTkBAPz9/XH58mUAQHx8PBwcHFSWbdWqFS5cuAC5XI45c+aI2RTm5uaYNGmSmBa9fv16jBw5EjVr1gQAzJo1CytXrsT58+fFQIlyn5QePXqErl27ip99fHzg5+eH0NBQNG7cGPv27YOenh5mzpwpHjsfHx+xfVhYWIGPZ2GkpKSoHUMLCwskJye/k+0RqcldikrbGBtGFrnaJ7zT7hAREb0NqVQKqVRa2t0g+qBx8HDKV6ZYisoAObqKAcOlUiniciVn5Jgq0smzGNggIiIiLYKCgpCQkIC4uDgcPHgQxsbGyMnJgZubGywsLGBhYYF69epBR0cHcXGvy9A4OzurrMfU1BRGRkbiZ2NjY5QrV07lc0pKCgDAxsYGMTExKssfOXIECQkJqF+/PrKyssTpFSpUUEmHfvjwIVxdXcXPBgYGcHBwUBkXRLlPypeJiQlCQkJQp04dWFlZwcLCAgcOHEB8fDwAICoqCu7u7iVej1kmkyExMVFlWmJiIkxNTUu0H/QBy12KSk9LKSo9I0DX8FV7ZoITERERkXbM2KB8yV9lbOga6yNH91XGhq4u4uJft8k2tQQAZCamlHj/iIiISEEikcDVza1Et/c2nJycoKOjg5iYGBgbG6vNV9Ytfpvaqy1atMDQoUNx7tw5NGzYMM+2b27H0dFRpXayXC5HTEwMHB0dta4jOjoaAQEBOHjwILy9vaGrq4tOnTqJJcJcXFxw7949CIKg8fh5eHggKipK6/qVAZvC8vT0xJUrV8TPT548QWxsrJiNQvTOFSRjAwAMLRTjazCwQURERER5YMYG5Sn7ZTpyXqYDUAweLgY2pFLEvrrXcLcH5DIrAEBWclqp9JOIiIgUgQYdHZ0Se71tYMPe3h6dOnXC8OHDxYyGuLg47Ny5szgOBwCgUqVKGDVqFHr06IG9e/ciJSUFgiDg33//VckK0aRPnz5YsmQJbt68iYyMDEyePBkVKlRA/fr1tS6jXL+dnR10dHRw4MABHD58WJzftm1bZGRkYMqUKUhNTYVcLsfx48fF+Tdu3EBKSorWl5IgCEhPT0dGRgYAICMjA+np6VrHWOnfvz82bNiA8+fPIy0tDRMnTkTz5s3F8TVycnKQnp4OuVwOAEhPT0d6eno+R5eoEMQxNiTI1JNpb2dk+UZ7IiIiIiJ1DGxQnuTPEgAAEqkOpIa6yJLqAQCkOjqIU8zCx5UAuZkNACArOR2CkFMKPSUiIqKyaO3atWIJKjMzMzRt2hSXLl0q1m3MmzcP3333HaZPnw47OzvY2tqie/fuCAwMRP/+/bUu169fP4wYMQLt2rWDvb09rl69ir179+Y5cHj16tUxadIk+Pr6wtraGlu2bEGHDh3E+TKZDEePHsWlS5fg7OyM8uXL4+effy70PkVFRcHIyAhVq1YFoAgSGRkZidkeISEh8PDwENv7+voiKCgIXbp0ga2tLWJiYhASEiLOP3nyJIyMjODn54fExEQYGRmplPsiemvKUlSGZhAkedQkVwY2MtOArIx33i0iIiIiKpskgrbHuj5gSUlJMDc3R2JiIszM8kiT/gAkhd3GqbodoWduhMYz2yKxViuk2zjBzNoRv53Qh1QHGOYP/DF7D3SmjodZRWs0vnoUOobq5SSIiIioeKWnpyMiIgJubm4wNDQs7e7QB0TbucfraAUeBw1muwEvnwMWLtjYaJ/GJr0aOAObegJ3DigmjPkXMC2nsS0RERER/fcU5jqaGRuUJ7ly4HBjxaDh2bqKjI2nyYqnrGzNAF2pBMb2dgCArDQ5slKTS76jRERERET0fhIEIP3V4PXKjAwNNv4drTqf42wQERERkRYMbFCeMpUDh5soAho5uooAR+wLxalj/+q+w7y8haJ9qhxZaRxAnIiIiIiIXslIBoRsxXsji7zbMrBBRERERAXAwAblKfPVGBt6RorAhqBnAKlUikfPFYOFOlor2llVMAegyNjIZsYGEREREREp5Q5Q5JGxAQAwtHj9ngOIExEREZEWDGxQnuQvFBkbesbKjA196EiliH+VSe5gpfjXzlER2BCyBWTEPyvxfhIRERER0Xsqd4Aid+BCk9wZHczYICIiIiItGNigPGU+U9xM6JroQ5DqAlJdZGbrQgBgbgzIjBSZGyaWxpDoKcbdeBkXX1rdJSIiIiKi983LhNfvC1WKKkFrMyIiIiL6sDGwQXmSK0tRmegD+oYAgDS5IoBRwfp1u6iHadAxMVYsw4wNIiIiIiJSKkwpKmZsEBEREVEBMLBBecpUlqIyMYCgpxg4POGlamAjLS0LX00Kg2BkBADIfs4bECIiIiIieqUQpagO3pO//sDABhERERFpwcAG5UmZsaFrrC8GNp4lvwpsvBpfY/32B3j2Qo4sIxMAgJCYWOL9JCIiIiKi95RKKaq8MzbkemavP3DwcCIiIiLSgoENytPrjA195OjqAwBeZkphqAdYyoDYx+nYsuuBYrquohRVdkIycnJySqfDRERERET0flEpRWWRZ1O5nrnm5YiIiIiIcmFgg/KUqczYMNFH9qvARnqWLsxNAIlEghW/RUCeKcDaUh8pklelqJJSIJdnllaXiYiI6D3k7e0NAwMDyGQyWFlZwdvbG5cuXSqx7a9duxYNGjSATCaDtbU1ateujaCgIKSmphZ5nbn3SflaunRpMfZau+vXr8PPzw82NjaQSCRISEjId5kVK1bA2dkZJiYmaNu2LWJjY8V5a9asQZUqVWBubg4bGxt06dIF0dHR73AP6INSiFJUmXoyCJAoPnDwcCIiIiLSgoEN0koQBMif58rYkOoBADKypDA2AO5GpODoyScAgKljqyJZ8ipjIykNSanM2CAiIiJVs2fPRkpKCmJiYlC7dm107NixUMtnZhbtwYlvvvkGU6ZMwaRJkxAbG4tnz54hJCQEcXFxuHv37lttS7lPytfQoUOL1MfC0tPTQ7du3bB27doCtT927Bi++eYbbNu2DU+ePEG5cuXQu3dvcb6vry/OnDmDxMREPHz4EO7u7hgwYMA76j19cApRikqQSJGpK3u1HDM2iIiIiEgzBjZIq+yUVAivbur1jF+XosrIksJYH1gVEgkA8G1iizqelsgxU9ykZKWkIS0ju1T6TERERO8/Q0NDDBw4EI8ePUJUVBSGDx8OZ2dn2NnZoV+/fkh8NV5XZGQkJBIJ1qxZg0qVKsHR0RGhoaGwsLDA0qVLUaFCBVhaWmLBggW4ffs2GjRoADMzM3Tq1EnMxLh37x7mz5+PzZs3o0OHDjA1NQUAVK9eHQsXLoSXlxcARUZHrVq1MHXqVNjb26NHjx4QBAHz58+Hu7s7rKys0Lp1a9y/fz/f/QsODkblypVhamoKd3d3LFmyRGV+eHg4OnToAFtbW1hZWaFLly6FPoZVqlTBwIEDUaNGjQK1X7NmDfr06YMGDRrAxMQEQUFBOHHihLg/Li4usLGxAaB4uEVHRwfh4eGF7heRRoUoRQUAGcpyVAxsEBEREZEWDGyQVsqBw3X0dKGjL0WOrj4EAcjKkSAtLQOn/34GHR1gUG9XAICRveJmOCv5JeTyrFLqNRER0YdLEAQImfKSewlCkfqZlpaGVatWwcXFBePGjcPz588RFhaGiIgIZGZmYvjw4Srt9+zZg4sXLyIiIgIAkJycjMjISERERGDbtm0YO3Ysxo4di+3bt+PBgwe4e/cuVqxYAQA4evQoHBwc8Mknn+Tbr+vXr0NXVxfR0dFYv3491q9fj+DgYOzatQsxMTHw8PBA+/btkZWV93WOi4sLjh07hqSkJKxatQrjxo3DmTNnAACpqalo2bIlatSogcjISMTFxWHEiBHisp6enrCwsND6KqqwsDDUqlVL/FyuXDnY29vj2rVr4rTTp0/DwsICxsbGCA4OxqRJk4q8PSIVr0pR5UikgL4s3+ZyffPXy3HsPiIiIiLSQLe0O0Dvr8xXZah0ZYaQSCQQdPWRJUgBSBAbq3gKsnkjWzg7KkpQWbiUAwBkpcmR/TINgEUp9JqIiOgDlpWJtNXTS2xzxgOmAnr6BW4/YcIETJs2DYaGhqhVqxbWrVsHX19fxMfHiz/az5gxAx4eHiollqZOnar2o/706dOhr6+Pli1bwsrKCu3bt4eTkxMAwN/fH5cvXwYAxMfHw8HBQWXZVq1a4cKFC5DL5ZgzZ44YSDE3N8ekSZOgo6MDfX19rF+/HiNHjkTNmjUBALNmzcLKlStx/vx5MVCi3CelR48eoWvXruJnHx8f+Pn5ITQ0FI0bN8a+ffugp6eHmTNnQiKRiG2UwsLCCnw8CyMlJUXtGFpYWCA5OVn83KRJEyQkJCA+Ph6rVq1C9erV30lf6AOUngQAkOuawvDVeZ8Xua6Z4o2QA8iTAUPzvBcgIiIiog8OMzZIq6zkFACArrHiBwtBVw+Z2VIAQGqyHADg6mwstnf4yB4AkJmaCWSklWRXiYiIqAwICgpCQkIC4uLicPDgQRgbGyMnJwdubm5iRkK9evWgo6ODuLg4cTlnZ2eV9ZiamsLIyEj8bGxsjHLlyql8TklRXMfY2NggJiZGZfkjR44gISEB9evXV8m+qFChAnR0Xl8eP3z4EK6uruJnAwMDODg44OHDh2r7pHyZmJggJCQEderUgZWVFSwsLHDgwAHEx8cDAKKiouDu7i4GNUqKTCYTS3wpJSYmiqW5crOxscHAgQPRrl27txpcnUiUoQigZemaFKi5mLEBcABxIiIiItKIGRukVVay4kZWaqA4TXJ09ZGRpQhsJCWmAwCsLV8/penq4YBrUGRsCOkMbBAREZU4XT1FFkUJbu9tODk5QUdHBzExMTA2NlabHxkZCQAqwYbCatGiBYYOHYpz586hYcOGebZ9czuOjo5iHwBALpcjJiYGjo6OWtcRHR2NgIAAHDx4EN7e3tDV1UWnTp3Esl0uLi64d+8eBEHQGNzw8PBAVFSU1vUrAzaF5enpiStXroifnzx5gtjYWDEb5U2ZmZlITEzEkydP4ObmVqRtEokyXmdsFISYsQEoxtmwdHkXvSIiIiKiMowZG6TV68CGIpgh6OrjZabi/fPnLwEANtavAxu2rooxNjJTMyCkF+2mm4iIiIpOIpFAoqdfcq+3zDqwt7dHp06dMHz4cDGjIS4uDjt37iyOwwEAqFSpEkaNGoUePXpg7969SElJgSAI+Pfff1WyQjTp06cPlixZgps3byIjIwOTJ09GhQoVUL9+fa3LKNdvZ2cHHR0dHDhwAIcPHxbnt23bFhkZGZgyZQpSU1Mhl8tx/Phxcf6NGzeQkpKi9aUkCALS09ORkZEBAMjIyEB6errWcU/69++PDRs24Pz580hLS8PEiRPRvHlzVKxYEYBicPGHDx9CEATExcVh5MiR+Oijj1QyVoiKJCsDyFZke2cWMGMjQyVjgwOIExEREZE6BjZIKzGwoa84TQRdfaTJFYGNp08UGRk2VgZiez0rxQ2IkC1AmpJQgj0lIiKismrt2rViCSozMzM0bdoUly5dKtZtzJs3D9999x2mT58OOzs72Nraonv37ggMDET//v21LtevXz+MGDEC7dq1g729Pa5evYq9e/dCV1d70nP16tUxadIk+Pr6wtraGlu2bEGHDh3E+TKZDEePHsWlS5fg7OyM8uXL4+effy70PkVFRcHIyAhVq1YFoAgSGRkZidkeISEh8PDwENv7+voiKCgIXbp0ga2tLWJiYhASEiLOv3LlCho0aACZTIY6depAT08Pf/zxR4mXzKL/oFfjawBApl4BMzb0cgU2Xg08TkRERESUm0TQ9ljXBywpKQnm5uZITEyEmZlZ/gv8R93/aTVujZ8Nu3rOqB5QH0+a9cT15xUQHm+B3WtPITtLwK61DWFjrQhuCIKAP4w9IGRlo9LaKajSu3cp7wEREdF/W3p6OiIiIuDm5gZDQ8PS7g59QLSde7yOVuBxyOXZPWBxHQBAhENbuP1vIzb+HZ3nIhUf7ETD61MUH9r9BHw84F33koiIiIjeA4W5jmbGBmmlzNjQfTXGhqCrD3m2DvR1BWRnCdDRASwsXpeikkgk0DFRDOSpk8iUcSIiIiKiD15GrowNXVmBFpHr5x5jI6GYO0RERERE/wUMbJBWYikqQ10IOlJAR4qMLCn0dBRJPpbm+tCVqpYn0DFWPLEnSU1GZhaTgYiIiIiIPmgZyeLbggY2MvQ4xgYRERER5Y2BDdLq9eDhuhB0FZkZGVlS6CAbAGBtpa+2jK7MGAAgJKUgNSOnhHpKRERERKTZyZMn0b59ezg4OEAikWDXrl15tt+xYwdatWoFW1tbmJmZoVGjRjh06FDJdPa/KL0IGRt6uTM2GNggIiIiInUMbJBW2amKAcKlBrrIkeoBUAQ2crIUgQ0bS/XAhr654mYlJyUVyakMbBARERFR6UpNTYWXl1eBB2k/efIkWrVqhQMHDuDSpUvw8fFB+/bt8c8//7zjnv5HFSFjI1M31yDj8pTi7hERERER/QfolnYH6P31uhSVHgRdRWBDni2FTkY6AMD61aDhuRlYKm5CspNTEf88A052eiXUWyIiIiIidW3atEGbNm0K3H7BggUqn2fNmoXdu3dj7969qF27djH37gOgEtgwKdAiKu1yLU9EREREpMTABmmVe/DwHF195AgSZOVIkJMmBwDYaChFpWehSBvPSX2JF0nykussEREREdE7kJOTg+TkZFhZWZV2V8qmjETxbUEzNrKkxrmWZ2CDiIiIiNS9F6Wofv75Z7i6usLQ0BANGjTA+fPntbZduXIlmjZtCktLS1haWqJly5Zq7QMDAyGRSFRerVu3fte78Z/z5hgbWTk6ACRISc4AAFhrKEWla/4qYyP1JdLSs0usr0RERERE78K8efOQkpKCbt26aW2TkZGBpKQklRe9UoRSVIKOLqBnrLY8EREREZFSqQc2tmzZgtGjR2Pq1Km4fPkyvLy84OfnhydPnmhsHxoaip49e+L48eM4e/YsnJyc8Omnn+LRo0cq7Vq3bo3Y2FjxtWnTppLYnf+U7FRlKSpFYCMzWwoASExQlKKysdaQsWFpAQDISU1HVhbH2CAiIiKismvjxo2YPn06tm7dCjs7O63tgoKCYG5uLr6cnJxKsJfvuSIMHg4AMHg1zgYDG0RERESkQakHNoKDg/HFF1+gf//+qF69OpYvXw5jY2OsXr1aY/uQkP+zd+dRThf2/v9fny2ZlQFkc0EWl1rqAmpLwf1KC9pqXW6LW0Fqua2KeqVqpSpUq+IutbXS2oLL161qbxf1h1YqWitqi6LWjaIoyr4PsyT5bL8/MpNJmBmYDNmYeT7OybnJJ8kn76mcc5O8836/HtIFF1yg4cOH64ADDtBvf/tbBUGg+fPnZzwuGo1qwIABqUuvXr0K8ed0KZkTG45iXrKxsWFDoySpT6/WGRt2U2PDa0zICNzCFAoAAADk2KOPPqrvf//7+v3vf68xY8Zs97HTpk3Tli1bUpfPPvusQFXuAjoxsSEprbHB9AsAAABaK2pjI5FIaNGiRRkfFEzT1JgxY7Rw4cIOnaOhoUGu67baebtgwQL169dPX/jCF3T++edrw4YN7Z6D0fG2pYeHB3ZEjW5TY2N9g6R2MjZ695Qk+Y2uyo3GwhQKAAAA5NAjjzyiSZMm6ZFHHtE3vvGNHT4+Go2qR48eGRc0SWtMuE4nJzbCMMdFAQAAYFdX1MbG+vXr5fu++vfvn3G8f//+Wr16dYfO8eMf/1h77LFHRnNk3LhxeuCBBzR//nzdfPPNevHFF3XCCSfI99vOfGB0vLUwCOTXJRsYzRMbzY2NWMyTYUg9e7aRsdEj+QHEi7kqN+KFKxgAAJS0Y489VtFoVFVVVerdu7eOPfZYLVq0qGCvf99992nkyJGqqqrSbrvtphEjRmjmzJmqb1q92Rnpf1Pz5Ve/+lUOq27fv//9b40dO1Z9+vSRYRjavHnzDp/z61//WnvvvbcqKyv1jW98Q6tWrUrdd99998myrIy/5ZZbbsnjX1A4dXV1Wrx4sRYvXixJWrZsmRYvXqzly5dLSk5bTJgwIfX4hx9+WBMmTNDtt9+ukSNHavXq1Vq9erW2bNnS1umxIzs7sREGktuQ46IAAACwqyv6KqqdcdNNN+nRRx/V//3f/6msrCx1/IwzztDJJ5+sgw46SKeccoqeeuop/fOf/9SCBQvaPA+j4635DS3TFnZTeHjCS/5zceOeetU4si2j1fOc5vDwmKcKM6aGBq8wBQMAgJJ38803q66uTitXrtSIESP0rW99K6vnu27n1lz++Mc/1vTp03XVVVdp1apV2rBhgx566CGtXr1aS5cu3anXav6bmi8XXHBBp2rMluM4+s53vqP77ruvQ4//29/+ph//+Md6/PHHtXbtWvXv319nn312xmMOOuigjL/liiuuyEPlhfevf/1LI0aM0IgRIyRJU6dO1YgRIzR9+nRJ0qpVq1JNDkn6zW9+I8/zdOGFF2r33XdPXS655JKi1L/La87YsMsUmE6Hn/ZZg91yg5wNAAAAbKOojY0+ffrIsiytWbMm4/iaNWs0YMCA7T73tttu00033aTnnntOBx988HYfO3ToUPXp06fdD66MjrfWvIZKpiEzYimwHXmBKdMIFQShduvdOl9Dkuzq5K+wvEZX5UZMa9YztQEAQKGEYSivvqFgl7CT62HKysp03nnnacWKFfr00081ZcoU7b333urXr58mTJiQ+mX8J598IsMwNHfuXO27777aa6+9tGDBAvXs2VO/+tWvtOeee6pXr16aNWuWPvjgA40cOVI9evTQKaeckprE+Oijj3T77bfr0Ucf1cknn6zq6uSPMIYNG6af//znOuSQQyQlJxaGDx+uGTNmaMCAATrjjDMUhqFuv/127bPPPurdu7fGjRunjz/+eId/3x133KH99ttP1dXV2mefffTLX/4y4/7//Oc/Ovnkk9W3b1/17t1bp512Wtb/G37hC1/QeeedpwMPPLBDj587d67OOeccjRw5UpWVlZo5c6ZefPHFDv09u7pjjz1WYRi2ujQ3he67776MH0AtWLBgu49HlpqbEs0TGB2UMd1BYwMAAADbsHf8kPyJRCI67LDDNH/+fJ1yyimSlAoCnzJlSrvPu+WWW3TDDTfo2Wef1eGHH77D1/n888+1YcMG7b777rkqvctrCQ53ZBiGQjsiN2HKVCBJ6lXT9q+t7JqWVVRRP6Z1Gz0N2bswNQMA0N35DY16tueIgr3e2M1vyq6syPp5DQ0N+u1vf6tBgwbp8ssvl23bevvtt+U4jr7//e9rypQpevDBB1OP//Of/6x//etfikQiev3117V161Z98sknWrZsmV566SWNGzdOzz//vJ544gn16NFDRxxxhH79619r6tSpev7557XHHnto9OjRO6zr3//+t04//XQtX75cnufpwQcf1B133KF58+Zpv/3201VXXaWTTjpJb731lmy7/bfRgwYN0t/+9rdUI+bEE0/UiBEjdMQRR6i+vl5jxozR2WefrUceeUSO4+gf//hH6rkHH3xwxvTAtjqycqotb7/9ti666KLU7f79+2vAgAF65513NHToUEnShx9+qH79+qmyslInnHCCbrzxRvXs2bNTrwekxJtWeGXd2KhMOwcZiAAAAMhU9FVUU6dO1b333qv7779f77//vs4//3zV19dr0qRJkqQJEyZo2rRpqcfffPPNuuaaazRnzhwNHjw4tfO2rq5OUnKH7uWXX65XX31Vn3zyiebPn69vfetb2nfffTV27Nii/I27ovR8DUnJxkZgKgyaGhtt5GtIkt0j+csqv9GV4zdqw5a2c00AAED3M23aNPXs2VNDhw7VBx98oPvvv19PPvmk7r77bvXs2VOVlZW67rrr9Nhjj2Vko82YMUM9e/ZURUVLE+Xaa69VJBLRmDFj1Lt3b5100kkaOHCgampqdOKJJ+qNN96QlMx022OPPTLq+NrXvpY6X/o0RU1Nja666ipFIhFVVFTowQcf1MUXX6yDDjpIZWVluvHGG/XZZ5/p9ddfb/U3NV/q6+t1+umna+DAgTIMQ8cdd5zGjh2bmgh46qmn5DiObrjhBlVWVioSiei4445Lne/tt9/W5s2b2710Vl1dXasmRc+ePbV1a/KX8EcffbTeeecdrV69Wn/729+0ZMkSTZw4sdOvB0hKhn6nJjaym4pnYgMAAADbU9SJDUkaP3681q1bp+nTp2v16tUaPny45s2blwoUX758uUyzpf9yzz33KJFI6L//+78zzjNjxgz99Kc/lWVZevvtt3X//fdr8+bN2mOPPfT1r39dP/vZzxSNtr0+Ca15dU0TG2XJfyKBHZHnmwq85JcMvXu2M7HR1NgIg1B2bKs2J2hsAABQKFZFucZufrOgr5eNmTNn6n//939Tt//5z38qCAINGTIk43GmaWr16tWp23vvnTn+WV1drfLylteuqKhIvXdsvt38o5c+ffpo5cqVGc//61//Kim5osjzWvLA9txzz4z3nZ9//rkGDx6cuh2NRrXHHnvo888/b/dvkqSHHnpIt99+uz755BMFQaCGhobU3/jpp59qn332kWG0zirLp6qqqlbh11u2bEmt5mqe2pCkIUOG6K677tJBBx2khoaGjIYSkBW3IRn+LWU/sWGlT2zU5bAoAAAAdAVFb2xI0pQpU9pdPbVt4Pcnn3yy3XOVl5fr2WefzVFl3VfzKio7YklqmtjwTbmJZJBmuxMbVRWSYUhhqLB2qxqiQWEKBgAAMgyjU6uhimXgwIEyTVMrV65s88vz5vd96c2GbB1//PG64IIL9Oqrr+qrX/3qdh+77evstddeGe89E4mEVq5cqb322qvdcyxfvlwTJ07UvHnzdOyxx8q2bZ1yyimpPJJBgwbpo48+UhiGbTY3vvSlL+nTTz9t9/zNDZtsHXzwwVq8eHHq9tq1a7Vq1SoddNBBbT6++X+LzuaoAJJagsMlqawmq6cysQEAAIDtKfoqKpSmloyNplVUliM3MBWPJRsbvdtpbBimKbuiTJIU1G6V59PYAAAAbRswYIBOOeUUTZkyRevXr5ckrV69Wv/3f/+Xs9fYd999demll+qMM87QX/7yF9XV1SkMQy1ZsiRjKqQt55xzjn75y1/qvffeUzwe19VXX60999xTX/nKV9p9TvP5+/XrJ9M09cwzz+i5555L3f+Nb3xD8Xhc06dPV319vRKJhF544YXU/e+++67q6uravTQLw1CxWEzxeFySFI/HFYvF2m1ETJo0Sf/v//0/vf7662poaNBPfvITHXPMMalJjWeeeUarVq2SlJxUueSSSzRu3DhVVla2eT6gQ9IbEllObHgZGRs0NgAAAJCJxgbalJ6xERqGQsuW55tqbGhubLS9ikqS7OrkLy7DrXXyQhobAACgfffdd5969uypL3/5y+rRo4eOOuooLVq0KKevcdttt+maa67Rtddeq379+qlv374aP368zj333FSuW1smTJigiy66SN/85jc1YMAAvfXWW/rLX/6y3eDwYcOG6aqrrtJ//dd/abfddtNjjz2mk08+OXV/VVWVnn/+eS1atEh77723dt99d919991Z/02ffvqpysvLdcABB0hKNonKy8tT0x4PPfSQvvSlL6Ue/1//9V+aOXOmTjvtNPXt21crV67UQw89lLr/hRde0IgRI1RRUaFRo0Zp6NChGQHuQKekh35nHR6ePrFBeDgAAAAyGSHz5a3U1taqpqZGW7ZsUY8e2YXcdRUf3zlX719xk/odPlAHfP8orTv2HP3x30P0yfsr9MY/Ptbcnx+m/YZWtfncF4eNUd1/PtOwK0/W/3fg/+qC8XsWuHoAALqHWCymZcuWaciQISorKyt2OehG2vu3x/voJP53aPLR36QHT01eP+oyPVw1UWeN3FsPv7Z8h0/tt+GfGvP695I3jvhf6WvX5q9OAAAAlIRs3kczsYE2pcLDo45COyI/NCQZqtuaXHfQa3sTGz2Sv8YKttbLtvJeKgAAAIBSFNuZiQ1WUQEAAKB9NDbQppaMDUuBHZEfJP+pxGO+DEPqWdN2xoYk2T2SkxxBfaNsu3UoJgAAAIBuIL0hUZbd5Arh4QAAANgeGhtok980sWGXOQqdiLymxoabcFVT7ci22m9YOD17NJ2jQVFH7YZYAgAAAOjC0hoS//gsntVTmdgAAADA9tDYQJtaJjZsBXZUrt/U2Ij7211DJUl2zxpJkt+YUFXUV129n99iAQAAAJSetIZExgRGBzCxAQAAgO2hsYE2pTI2ymyFdqSlsZHw1Ktn+2uoJMnu1dTYiHmqtmLaXJvIb7EAAHRzTEei0Pg3hw5JtDQkPKsiq6cGZkS+YSdvxGu3/2AAAAB0O3Y2Dw6CQC+++KL+/ve/69NPP1VDQ4P69u2rESNGaMyYMRo4cGC+6kSBZUxsOBHFvWRjIxH31Ktn+Xaf6zRlbHiNrspNV5s2uxq4R37rBQCgO3Kc5BRlQ0ODysu3//+fgVxqaGiQ1PJvEGhTvC51NWO1VEcYhly7Spa7mYkNAAAAtNKhxkZjY6Nuv/123XPPPdq4caOGDx+uPfbYQ+Xl5Vq6dKn++Mc/avLkyfr617+u6dOn66tf/Wq+60ae+XXJD6tW1FZoR5VIm9jovaOJjR7VkiQv5ipqxLRxi5vfYgEA6KYsy1LPnj21du1aSVJFRYUMo/0cLGBnhWGohoYGrV27Vj179pRlWcUuCaUskd7YyG4VlSR5dqVEYwMAAABt6FBjY//999eoUaN077336mtf+1qbv8z69NNP9fDDD+uMM87QVVddpcmTJ+e8WBSOlxYeHtgReb6pMAw72NhIfmjxY64qw7g2biFjAwCAfBkwYIAkpZobQCH07Nkz9W8PaFfaxIZnJ1dRPfza8g4/PdUMobEBAACAbXSosfHcc8/pi1/84nYfM2jQIE2bNk2XXXaZli/v+JtVlKbUKqqy5CoqNzAVBoEk7TA83Klpntjw5IRxbakL8lssAADdmGEY2n333dWvXz+5LlOSyD/HcZjUQMdkhIdnuYoq/Tl+XPLikh3NVWUAAADYxXWosbGjpkY6x3G0zz77dLoglAa/ubERseXZEbmuKc/1JKnDExteo6tIEFdtPY0NAADyzbIsvmwGUFqaw8MNU75ZlvXTM9ZXxetobAAAACDF7MyT/v73v+ucc87RqFGjtGLFCknSgw8+qJdffjmnxaE4wjCU15yxUWYrdCLyAlOJWLKx0atm+xMbdnXyl1V+zJUdxlUfC/NbMAAAAIDS07yKKlItdSL/J2PKI16bo6IAAADQFWTd2HjyySc1duxYlZeX680331Q8HpckbdmyRTfeeGPOC0Th+Q2NUphsRlhljgI7Ktc3FYsl11v0rNnBxEbzKqpGV7afUGOCxgYAAADQ7TSHh0erO/X0zIkNcjYAAADQIuvGxvXXX6/Zs2fr3nvvzQgRP+KII/TGG2/ktDgUR3O+hgzJciyFdkSu3zKxUVO9/Q1mqfDwuCfDjSdPBAAAAKB7aZ7YiFZt/3HtoLEBAACA9mTd2Pjwww919NFHtzpeU1OjzZs356ImFJnfvIYqYsswDQVONLmKKu7Jtg2Vl29/f3dzeLhCKayrF+u+AQAAgG4m8CW36QdTkc42NtJXUdHYAAAAQIusGxsDBgzQ0qVLWx1/+eWXNXTo0JwUheJqntiworZCw5RMS65vyk146lFly9jBflyzLCrDTnYzgq11ciKGwpB1VAAAAEC30byGSmJiAwAAADmXdWNj8uTJuuSSS/Taa6/JMAytXLlSDz30kC677DKdf/75+agRBebVNTU2ymyFdkQyDLmBKTfuqUf19oPDJckwDFkVZZKkoL5B5WWWGmNBXmsGAAAAUELiLY2Nz+o7N8Lt2RUtNxI0NgAAANBi+2EJbbjyyisVBIGOP/54NTQ06Oijj1Y0GtVll12miy66KB81osBaJjYcBU4yKNzzTSUSnmp67LixIUl2Zbm82noF9Q2qHGhq85aEKsrL81YzAAAAgBKSNrGRsVIqC0xsAAAAoD1ZNTZ839c//vEPXXjhhbr88su1dOlS1dXVadiwYaqq6tx4MUpPKmMjmgwO9wNDoYzkKqrdOvZPxqpMNjHChpgqyk3V1nnaI28VAwAAACgp8Vw0NsjYAAAAQNuyamxYlqWvf/3rev/999WzZ08NGzYsX3WhiJonNuwyR4EdlR8mN5a5cU89ekQ6dI7mxkbQEFN5VNq61c1PsQAAAABKT9rqKM9iYgMAAAC5lXXGxoEHHqiPP/44H7WgRGSEhzsRuX5TY6MpPLwj7Krkh5egMaayqKHNtV5+igUAAABQenIysZHW2IjV7mxFAAAA6EKybmxcf/31uuyyy/TUU09p1apVqq2tzbhg1+fXJT+EWGW2AnubxkYHwsMlyUo1NuKKWIE2b6WxAQAAAHQbaRkbGSHgWXCt9PDwuvYfCAAAgG4n6/DwE088UZJ08sknyzCM1PEwDGUYhnzfz111KAovlbFhK0xrbCTiWYSHVyd/XRXEXEXNuGobjB08AwAAAECXkbY6KmPyIgte+qQHjQ0AAACkybqx8cILL+SjDpSQ9FVUgROV6yebEtmsorKaGht+wlM0jKmuIZqfYgEAAACUnvTGRiczNjyrPO18NDYAAADQIuvGxjHHHJOPOlBC0sPDQzsiLzAVBoF8L1CPjk5sNIWH+3FP0TCuhljHQscBAAAAdAGJ9IyNzq2iCk1bnlkmO4gxsQEAAIAMWTc2Xnrppe3ef/TRR3e6GJQGvy59YiPZ2HATyRVjNdUdnNhoytjw474iYUyNier8FAsAAACg9MTTMzY6N7EhJZsidiLGxAYAAAAyZN3YOPbYY1sdS8/aIGNj15eRsWElMzYScVeSOhweblclf5XlJzxVhnHF3TA/xQIAAAAoPekTG51cRSU1NUUSG6XE1h0/GAAAAN2Gme0TNm3alHFZu3at5s2bpy9/+ct67rnn8lEjCiyVsVFmK7QdeYGpRNyTpI5nbFS0rKKKBPFUTgcAAACAbiAtY2OnJjaamyJMbAAAACBN1hMbNTU1rY597WtfUyQS0dSpU7Vo0aKcFIbi8dJXUVm2vMCQm/AUjZiKRq0OnSM1sRH3ZIdx+UHeygUAAABQajIyNnZmYqMpnyNwJS8u2dGdrQwAAABdQNYTG+3p37+/Pvzww1ydDkXkZ6yicuT6ptyEp5oOBodLkpXW2DB9V5ZjKgxZRwUAAAB0CxkTG50LD5e2aYowtQEAAIAmWU9svP322xm3wzDUqlWrdNNNN2n48OG5qgtF1LyKyi5zFEtbRdWjg8HhkmRVNjc2fBmeq8pyS42xQBXlHZv4AAAAALALa25COBUKjc5/BshYY5XYKlXutpOFAQAAoCvIurExfPhwGYbR6tf3X/3qVzVnzpycFYbiCMOwJWOjaWLDC5ITGx0NDpdaVlEFCU+ml1BFhaXarS6NDQAAAKA7aF5FFanaqdNkBI8zsQEAAIAmWTc2li1blnHbNE317dtXZWVlOSsKxRM0xqQgGYhhltmSacnzTblxX32zmdhICw83fFcVZaZqt7oa0I9/JwAAAECX17yKKrpzjY2MNVYJGhsAAABIyrqxMWjQoFbHNm/eTGOji/Ca8jUkySwvlwxDblN4eI+q7Cc2/Lgnw3NVXm6qts7Leb0AAAAASkwYtjQhotU7daqMjA0aGwAAAGiSdXj4zTffrMceeyx1+zvf+Y569+6tPffcU2+99VZOi0PhNa+hMiOWFIkkjwWmEglPNT2ymNioSn4A8ZtWUZVHDdVupbEBAAAAdHleXAqa3vuzigoAAAB5kHVjY/bs2Ro4cKAk6a9//av++te/at68eTrhhBN0+eWX57xAFFZ6cHhoJRsZyVVUnqqzmdioTK6iCv1QYSymaNRQ7VY39wUDAAAAKC1uyxS4IpXtP64DWEUFAACAtmS9imr16tWpxsZTTz2l73znO/r617+uwYMHa+TIkTkvEIXl12UGh4eh5IfJVVTVlVlMbDQ1NiQpbGhU1JG2rGdiAwAAAOjyEvUt152K9h/XAZ6V9nwmNgAAANAk64mNXr166bPPPpMkzZs3T2PGjJEkhWEo3/dzWx0KztumseEFpiSjaWKj440NMxKREUlOeAT19bLNQLV1QT5KBgAAAFBKcjixkZmxsXWnzgUAAICuI+uJjdNOO01nnXWW9ttvP23YsEEnnHCCJOnNN9/Uvvvum/MCUVjNq6isMluhZcv1DUlSIpFdY0OS7IoyuQlXYX1MthmorjHMeb0AAAAASkz6yqidnNjIaGwwsQEAAIAmWTc27rzzTg0ePFifffaZbrnlFlVVJcPgVq1apQsuuCDnBaKw/IaYJMmK2Art5okNyU14qspiFZUkWZUVcjdvVdAYk20Fqo8xsQEAAAB0eYlcZmykT2zQ2AAAAEBS1o0Nx3F02WWXtTp+6aWX5qQgFJdf3yhJMiNWahWV5/oKgzDriQ2rMvnrLL8xLkeuYomclwsAAACg1ORyFRUZGwAAAGhD1o2NZu+9956WL1+uRCLz2+qTTz55p4tC8fiNycaGFbEVWLZc35SbSIZ+V1c5WZ3Lrk5+iPHjnqJhXHGywwEAAICuL5fh4UxsAAAAoA1ZNzY+/vhjnXrqqXrnnXdkGIbCMJmbYBjJLAYCxHdtLauoWiY2EnFPhiFVVlhZncuqSn6ICRK+IorJ9ctyXi8AAACAEpPW2Hh9RUzau/OnyszYIDwcAAAASWa2T7jkkks0ZMgQrV27VhUVFXr33Xf10ksv6fDDD9eCBQvyUCIKya9Pjo2bEUuhbcsLDLlxT5UVtkzTyOpcdvMqqrinSBiXH2T3fAAAAAC7oLRVVJ61kxMbVnnLDSY2AAAA0CTrxsbChQt13XXXqU+fPjJNU6Zp6sgjj9TMmTN18cUX56NGFFBGeLjlyPNNJRJu1vkaUsvEhp/w5IQJmbalWIyJHgAAAKBLS5vY8Ozy7TywAwyzJWeDjA0AAAA0ybqx4fu+qqurJUl9+vTRypUrJUmDBg3Shx9+mNvqUHB+Q+vwcDfuda6xUZH8EOPHPTlBXE7EVm0dQRsAAABAl5YxsbGTjQ2lraNiYgMAAABNsv62+sADD9Rbb72lIUOGaOTIkbrlllsUiUT0m9/8RkOHDs1HjSig5sZGc8aG25SxUV2ZfWPDrmpZRWUHCUWitrZsddWvTzSnNQMAAAAoIekTGzu5ikpqChCPr6OxAQAAgJSsJzauvvpqBUEgSbruuuu0bNkyHXXUUXrmmWd011135bxAFFbGKirblufvxMRGVfKXVX7ClxW4ikYt1TGxAQAAgAJ66aWXdNJJJ2mPPfaQYRj64x//uMPnLFiwQIceeqii0aj23Xdf3XfffXmvs0vJaGzkYGIjfRVVGO70+QAAALDry/rb6rFjx6au77vvvvrggw+0ceNG9erVS4ZBOPSurq1VVImEp+p+nZjYqGxZRWX6rirKLW2lsQEAAIACqq+v1yGHHKLvfe97Ou2003b4+GXLlukb3/iGfvjDH+qhhx7S/Pnz9f3vf1+77757xmchbEcOw8MlybObzhH6kheTnJ1vlgAAAGDXlv231U2WLl2qjz76SEcffbR69+6tkF/OdAl+ffMqKluhZcsNDLlxT1WVkazPZVW2rKIyPFflFaa21tPYAAAAQOGccMIJOuGEEzr8+NmzZ2vIkCG6/fbbJUlf/OIX9fLLL+vOO++ksdFRibTGxs6Gh0vyrMqWG/E6GhsAAADIfhXVhg0bdPzxx2v//ffXiSeeqFWrVkmSzjvvPP3oRz/KeYEorFYTG76pRNzt1Cqq9IwNw3dVXmayigoAAAAlbeHChRozZkzGsbFjx2rhwoXtPicej6u2tjbj0q2lZWHkJjw8beojsXWnzwcAAIBdX9aNjUsvvVSO42j58uWqqGh5gzl+/HjNmzcvp8Wh8PzG5owNS4HdtIoq7qm6ysn6XNtObFRETdXWuTmtFwAAAMil1atXq3///hnH+vfvr9raWjU2Nrb5nJkzZ6qmpiZ1GThwYCFKLV1pq6h8q2znT2dvM7EBAACAbi/rxsZzzz2nm2++WXvttVfG8f3220+ffvppzgpDcfh1yQ8hZsROZWy4CU9VlZ0JD082NoKEL8N35dihtjb4Oa0XAAAAKLZp06Zpy5Ytqctnn31W7JKKq3kVlV2u0LB2+nReemMjQWMDAAAAncjYqK+vz5jUaLZx40ZFo9GcFIXi8RtbVlHJtOT6pty417lVVGnh4YbnyjYDNTSSxQIAAIDSNWDAAK1Zsybj2Jo1a9SjRw+Vl7e9VikajfJZKJ1bL0mKGTs/rSFJ7rYZGwAAAOj2sp7YOOqoo/TAAw+kbhuGoSAIdMstt+i4447LaXEoPL8huYrKLC+TDENeYDStourExEbaKirTd2VbgZpODwAAAJSkUaNGaf78+RnH/vrXv2rUqFFFqmgXlEg2NnIRHJ48DxkbAAAAyJT1t9W33HKLjj/+eP3rX/9SIpHQFVdcoXfffVcbN27UP/7xj3zUiAIJEgmFXnJVlFlRriCUEolAYRjuXHh4IhkebpuBGl0mNgAAAFA4dXV1Wrp0aer2smXLtHjxYvXu3Vt77723pk2bphUrVqR+vPXDH/5Qv/zlL3XFFVfoe9/7nv72t7/p97//vZ5++uli/Qm7nqZVVJ7VetK/M8jYAAAAwLayntg48MADtWTJEh155JH61re+pfr6ep122ml68803tc8+++SjRhSInzZOYZRH5fnJ4HBJqu5MxsY24eGOFShOdjgAAAAK6F//+pdGjBihESNGSJKmTp2qESNGaPr06ZKkVatWafny5anHDxkyRE8//bT++te/6pBDDtHtt9+u3/72txo7dmxR6t/lhGEqPNyzcjSxYZGxAQAAgEzZf1stqaamRldddVWua0GR+fXJfA2ZhhSJygvSGhs7MbER+qHCeEy2GcolOxwAAAAFdOyxxyoM258avu+++9p8zptvvpnHqrowt1FS8n/vXDU20ic23v7ocx3MVjAAAIBuL+uJDUmKxWJ6/fXX9dRTT+nPf/5zxqUz7r77bg0ePFhlZWUaOXKkXn/99XYfe++99+qoo45Sr1691KtXL40ZM6bV48Mw1PTp07X77rurvLxcY8aM0X/+859O1dad+A3JxoYVsSTbkRuYchOeystM2Xb2/1SsypYPMkF9TLYZyPONnNULAAAAoMQ05WtIkp+zxkbLSivbb8zJOQEAALBry/pn+PPmzdOECRO0fv36VvcZhiHfz+4n+Y899pimTp2q2bNna+TIkZo1a5bGjh2rDz/8UP369Wv1+AULFujMM8/U6NGjVVZWpptvvllf//rX9e6772rPPfeUlMwBueuuu3T//fdryJAhuuaaazR27Fi99957Kisry/ZP7jaaV1FZEVuh5cjzDblxT1WdWEMlSWYkIsOxFbqegsZG2aYvw7QUTwSKRjrVUwMAAABQytyWxkZ6Q2JnpK+icrz67TwSAAAA3UXW3y5fdNFF+va3v61Vq1YpCIKMS7ZNDUm64447NHnyZE2aNEnDhg3T7NmzVVFRoTlz5rT5+IceekgXXHCBhg8frgMOOEC//e1vFQSB5s+fLyk5rTFr1ixdffXV+ta3vqWDDz5YDzzwgFauXKk//vGPWdfXnXj1yV24ZsRSaNmpVVSdbWxIkl2d/BASxDxFFJcTsVRX7+WkXgAAAAAlpik4XMrPKirbp7EBAACATjQ21qxZo6lTp6p///47/eKJREKLFi3SmDFjWgoyTY0ZM0YLFy7s0DkaGhrkuq569+4tSVq2bJlWr16dcc6amhqNHDmy3XPG43HV1tZmXLqjoDF9YsOWG5hKxF1VVuxEY6NHlSTJj7uKhnHZjqWtdSSIAwAAAF2S29LYyNUqKi9t8oOJDQAAAEidaGz893//txYsWJCTF1+/fr1832/VJOnfv79Wr17doXP8+Mc/1h577JFqZDQ/L5tzzpw5UzU1NanLwIEDs/1TuoTmjI3UxIafzNioqLA6fU67OtnY8Bo9OUrIidjaWsfEBgAAANAlJepSV3M2sWGlZWx4Ddt5JAAAALqLrH+K/8tf/lLf/va39fe//10HHXSQHMfJuP/iiy/OWXE7ctNNN+nRRx/VggULdio7Y9q0aZo6dWrqdm1tbbdsbnj1LeHhzauo3Linyt47P7HhxVw5QVw2q6gAAACArisPq6h8q1yBTJkK5LCKCgAAAOpEY+ORRx7Rc889p7KyMi1YsECGYaTuMwwjq8ZGnz59ZFmW1qxZk3F8zZo1GjBgwHafe9ttt+mmm27S888/r4MPPjh1vPl5a9as0e67755xzuHDh7d5rmg0qmg02uG6u6rmiQ0rYis0bXmBoUTcU+XOTGw0r6KKuYoE8aaJjURO6gUAAABQYtJWUXk5Cg+XYcizKxTx6mSzigoAAADqxCqqq666Stdee622bNmiTz75RMuWLUtdPv7446zOFYlEdNhhh6WCvyWlgsBHjRrV7vNuueUW/exnP9O8efN0+OGHZ9w3ZMgQDRgwIOOctbW1eu2117Z7Tkh+QzJjY9tVVDvT2HBSExue7DAhxzFZRQUAAAB0VYmWxkOuJjaS50o2SRxWUQEAAECdmNhIJBIaP368TDPrnkibpk6dqokTJ+rwww/XV77yFc2aNUv19fWaNGmSJGnChAnac889NXPmTEnSzTffrOnTp+vhhx/W4MGDU7kZVVVVqqqqkmEY+t///V9df/312m+//TRkyBBdc8012mOPPXTKKafkpOauKjWx4Vip8HDP9VVZuROrqKpbJjaswFUkamsrq6gAAACArsnN/SoqSXLtSilOeDgAAACSsv7GeuLEiXrsscf0k5/8JCcFjB8/XuvWrdP06dO1evVqDR8+XPPmzUuFfy9fvjyjiXLPPfcokUjov//7vzPOM2PGDP30pz+VJF1xxRWqr6/X//zP/2jz5s068sgjNW/evJ3K4egOUuHhUTs1seG5virLdyZjo1KS5DW6MjxXFWWGtm6hsQEAAAB0SXkID5ckz05+rrD9BikMpbSVyAAAAOh+sv7G2vd93XLLLXr22Wd18MEHtwoPv+OOO7IuYsqUKZoyZUqb9y1YsCDj9ieffLLD8xmGoeuuu07XXXdd1rV0Z82rqFLh4YmmxsbOZGzUVCfPHfNk+K7Ky0xtWkFjAwAAAOiSEnnI2FDTxIYkQ2Fy3VW0KmfnBgAAwK4n68bGO++8oxEjRkiS/v3vf2fcZ/CrmV2aX5/8EGI6lkLLSa6i8nxVVOz8KiovlpzYiDhSXYOfk3oBAAAAlJh8raKy0pokiToaGwAAAN1c1t9Yv/DCC/moAyUgNbERtRWatrzA2PmJjR7NGRvJiQ3bDlTfGOSkXgAAAHRNc+fO1fjx41VRkbtf/KNA8hUe3jSxIUmK10nVOTs1AAAAdkG5SQBHl+A3bhMe7hnyvUCVOzOx0SNzYsOxAjXGw5zUCwAAgK7pyiuv1IABA3TeeefplVdeKXY5yEaeGhtuemMjLccDAAAA3RONDaT49U3h4ZFkeHg8kTy+MxMbTvPERqMr03dlm4Hi7k6XCgAAgC5sxYoVuv/++7V+/Xode+yxOuCAA3TzzTdr9erVxS4NO5Kxiip3EzfetquoAAAA0K3R2EBKyyqq5MRGrGmyYqcmNlIZG15qYiNBdjgAAAC2w7ZtnXrqqfrTn/6kzz77TJMnT9ZDDz2kvffeWyeffLL+9Kc/KQhYb1qS0ic27DxNbMRpbAAAAHR3NDaQ4jc0TWw4lnzDUSKR/LC4cxkbyQ8gfsyV4ScbG35gyPdZRwUAAIAd69+/v4488kiNGjVKpmnqnXfe0cSJE7XPPvtowYIFxS4P22qa2AhlyDfLcnZaJjYAAACQjsYGUvz65IcQK2LLNRx5ri9JKi/bicZGTTLVz4u5kpuQbQayI7bqGxjbAAAAQPvWrFmj2267TV/60pd07LHHqra2Vk899ZSWLVumFStW6Dvf+Y4mTpxY7DKxraaJDc8qkwwjZ6dNn9h47YNPc3ZeAAAA7Jo6tGPoz3/+c4dPePLJJ3e6GBSXtzX5yyerzJariDzPV0W5JdPs/AeS5vBwhVLY2CjHDGQ7lrbWeepR7eSibAAAAHQxJ510kp599lntv//+mjx5siZMmKDevXun7q+srNSPfvQj3XrrrUWsEm1KJH8slct8DUny7JbzOX7Ddh4JAACA7qBDjY1TTjmlQyczDEO+7+9MPSgib2vTxEZ5mbzAkuf6qqrsfL6GJFkV5ZJpSkGgoK5BthXKidjaWsfEBgAAANrWr18/vfjiixo1alS7j+nbt6+WLVtWwKrQIW7zxEbu8jWkzIkNx6vfziMBAADQHXRoFVUQBB260NTYdYVhKL8u2dgwK8rkBqY8NzmxsTMMw5BdnfwQEtQlJzaciKWt9TQ2AAAA0LZjjjlGhx56aKvjiURCDzzwgKTk+8xBgwYVujTsSPPERg6DwyXJs1oaGzaNDQAAgG6PjA1IkoJYXGFTY8qsLJMXGPJcf6eCw5ulAsQb4rJNT47DxAYAAADaN2nSJG3ZsqXV8a1bt2rSpElFqAgdEviS1yhJ8vM5seHT2AAAAOjuOrVnqL6+Xi+++KKWL1+uRCKRcd/FF1+ck8JQWN7Wlg8HZkW5/MCU53mqrNi5VVSSZPeolrRaXsxVNIzLjlSrjokNAAAAtCMMQxltBE9//vnnqqmpKUJF6BC3JfvCzXHGhpuWsWF7ZGwAAAB0d1l/a/3mm2/qxBNPVENDg+rr69W7d2+tX79eFRUV6tevH42NXVRzY8OMWJLjyAsM+a6vihxMbDhNAeJ+zFMkjMuJ9FJdPR9GAAAAkGnEiBEyDEOGYej444+Xbbd8XPF9X8uWLdO4ceOKWCG2K9HyHj/XGRvpq6jI2AAAAEDWjY1LL71UJ510kmbPnq2amhq9+uqrchxH55xzji655JJ81IgCaG5s2GWOQtNOTmy4vqp65WJiI9nY8GKunDAu27FYRQUAAIBWTjnlFEnS4sWLNXbsWFVVVaXui0QiGjx4sE4//fQiVYcdclsaDvlcRUXGBgAAALL+1nrx4sX69a9/LdM0ZVmW4vG4hg4dqltuuUUTJ07Uaaedlo86kWd+XfLDgRW1FVq2vMCU5+UoY6OmOvkaMVdlYVxOxFJ9A40NAAAAZJoxY4YkafDgwRo/frzKysqKXBGykmhpOOQ6PDwwIwoMW2boyfGZ/gYAAOjusg4PdxxHppl8Wr9+/bR8+XJJUk1NjT777LPcVoeCaZ7YsMqaGxvJ8PCKXGRsVDdPbHiyfFdlUZOMDQAAALRr4sSJNDV2RRmrqHKbsSHDSOVskLEBAACArL+1HjFihP75z39qv/320zHHHKPp06dr/fr1evDBB3XggQfmo0YUQKqxkT6x4eZoYqM5Y6PRleG7Ki83tYlVVAAAAEjTu3dvLVmyRH369FGvXr3aDA9vtnHjxgJWhg5LW0WV64yN5DkrFXVr5fisogIAAOjusm5s3Hjjjdq6dask6YYbbtCECRN0/vnna7/99tOcOXNyXiAKIyNjw7LlN01sVJbv/MSG0yO5D9eLuTI8VxVlhrYysQEAAIA0d955p6qrq1PXt9fYQInKY3i41JKzQcYGAAAAsvrWOgxD9evXLzWZ0a9fP82bNy8vhaGwMic2nKaMjUAVuZjYaFpF5cc8Gb4rxwrVEAt2+rwAAADoOiZOnJi6fu655xavEHReIt8TG8lVVI7fKAWBZGa9WRkAAABdRFbvBMMw1L777kuWRhfk19VJasrYMC15gSHf9VWZi4yNHs0ZG8lVVLYVKJYId/q8AAAA6JreeOMNvfPOO6nbf/rTn3TKKafoJz/5iRKJRBErw3alr6Kyc5yxIaUyNiRJibqcnx8AAAC7jqwaG6Zpar/99tOGDRvyVQ+KZNuJDT8w5bqeqipz19jwm1ZROWagBJuoAAAA0I4f/OAHWrJkiSTp448/1vjx41VRUaHHH39cV1xxRZGrQ7vyvIrKa1pFlXwtGhsAAADdWdazuzfddJMuv/xy/fvf/85HPSiSbTM2PN+U7waqzkVjoya5K9mLeTJ9T44VpFZdAQAAANtasmSJhg8fLkl6/PHHdcwxx+jhhx/WfffdpyeffLK4xaF9bnpjIx8TG2mNjTiNDQAAgO4s62+tJ0yYoIaGBh1yyCGKRCIqL8/8Jc7GjRtzVhwKJ3Niw5YXGvI8X1VVOWhsVGdObNhmICdiq67eV88a9uICAAAgUxiGCoLkj2Cef/55ffOb35QkDRw4UOvXry9madietCmKfGZsJF9ra87PDwAAgF1H1t9a33nnnTIMIx+1oIi8uqbGRlmyseEHZrKxkYvw8OaMjcbm8PBATsRSXb2nnjXOTp8fAAAAXcvhhx+u66+/XmPGjNGLL76oe+65R5K0bNky9e/fv8jVoV3pq6jykrHBxAYAAACSsm5snHvuuXkoA8XWMrGRXEUViwdyLEORyM5PVDhp4eFyE7LNQLZjq66eoA0AAAC0NmvWLJ199tn64x//qKuuukr77ruvJOmJJ57Q6NGji1wd2uXmN2PDJWMDAAAATbJubFiWpVWrVqlfv34Zxzds2KB+/frJ9/2cFYfC8VMZG8mJjXgiVGWlnZPpHLtH0weQIFTY2CjHCpMTGw00NgAAANDawQcfrHfeeafV8VtvvVWWtfMTxciTRH3qat5XUTGxAQAA0K1l3dgIw7DN4/F4XJFIZKcLQnGkr6JyzYgSiUBVOQgOlySrskIyDCkMFdQ1tGRs1NHYAAAAQPsSiYTWrl2byttotvfeexepImxXnhsbmRMbZGwAAAB0Zx3+5vquu+6SJBmGod/+9reqqqpK3ef7vl566SUdcMABua8QBZEeHt5glslzfVXnqLFhmKbsqnJ5WxsU1DXIsQLZjsUqKgAAALRpyZIlOu+88/TKK69kHA/DUIZhMCVeqjJWUeU+Y8PLaGzUt/9AAAAAdHkd/ub6zjvvlJT8MDF79uyMEfBIJKLBgwdr9uzZua8QBZFqbJQ5cq2ofM9XZWXuxvzt6qpkY6O+MTWxsZXGBgAAANowadIk2batp556SrvvvntO1qOiAJqbDYalwHRyfnrXIjwcAAAASR1ubCxbtkySdNxxx+kPf/iDevXqlbeiUFhhEMivS/66yo7aShhReQk/Z6uoJMmqTv5iy2+IyTEDOZGI6upjOTs/AAAAuo7Fixdr0aJFTITvaponNiKVyVW0OebZaVMghIcDAAB0a1l/c/3CCy/kow4Ukd/QmLpuVJbLD225rq9eFblrbNjVydVlQSwh23BlO1WsogIAAECbhg0bpvXr1xe7DGSreWLDyf0aKkly0xsbcTI2AAAAurOsv7n+3ve+t93758yZ0+liUBzNa6hkSEZ5ubzAkOf6quqRw8ZGVXJs3I95iiouJ2KprpbGBgAAAFq7+eabdcUVV+jGG2/UQQcdJMfJXGvUo0ePIlWG7WpubETy09jw0ldRMbEBAADQrWX9zfWmTZsybruuq3//+9/avHmz/uu//itnhaFw0vM1wkhUfmAmGxtVuZzYaGpsxD05QUJOxCJjAwAAAG0aM2aMJOn444/POE54eIlLX0WVj9PbZGwAAAAgKetvrv/v//6v1bEgCHT++edrn332yUlRKCy/qbFhR22FdqRlYiOHq6isqpbGRtR3VVFmag2NDQAAALSB9be7IN+V/ETyupOfxoZnM7EBAACApJx8c22apqZOnapjjz1WV1xxRS5OiQLy6ponNpobG6Zc11NVZVnOXsOuagoPj3syPFfl5abq6vmlHQAAAFo75phjil0CstW8hkrK2yqqwHTkG46s0GViAwAAoJszc3Wijz76SJ7HL/B3RalVVFFbgR2R3zyxUWnl7DXSV1EZvquyqFTXwL8XAAAAtO3vf/+7zjnnHI0ePVorVqyQJD344IN6+eWXi1wZ2pQ+QRGtztvLpNZRJQgPBwAA6M6yntiYOnVqxu0wDLVq1So9/fTTmjhxYs4KQ+H49Y2Sko2N5omNZGMj96uovFhyYsMxA8USYc7ODwAAgK7jySef1He/+12dffbZeuONNxSPxyVJW7Zs0Y033qhnnnmmyBWilXhaoyGPjQ3PrpTczUxsAAAAdHNZf3P95ptvZtw2TVN9+/bV7bffru9973s5KwyF49UnQ/6sSHJiwwtMeYncNjZSq6gSyYkN2wrk+oY8P5RtGTl7HQAAAOz6rr/+es2ePVsTJkzQo48+mjp+xBFH6Prrry9iZWhXWmPjg02SBuTnZVomNmhsAAAAdGdZf3NNkF/X0zyxYUaszPDwnDY20lZRNU1sOBFbDQ2eelQ7OXsdAAAA7Po+/PBDHX300a2O19TUaPPmzYUvCDsWr01dda38hIdLaY0NL5YMLLf4LAEAANAddSpjw/M8Pf/88/r1r3+trVuTv8xZuXKl6ur41cyuyG+e2IjaCp2I/FR4eC5XUTVNbMRcmb4r2wrlOJa21pOzAQAAgEwDBgzQ0qVLWx1/+eWXNXTo0CJUhB1KWw3l2lV5exnPSgsmj5OzAQAA0F1l/c31p59+qnHjxmn58uWKx+P62te+purqat18882Kx+OaPXt2PupEHnlpGRuBHZEXN+R7virK8xQe7rlyypMTG3V1NDYAAACQafLkybrkkks0Z84cGYahlStXauHChbrssst0zTXXFLs8tCWtyZCaqsiDjHMn6qSK3nl7LQAAAJSurCc2LrnkEh1++OHatGmTysvLU8dPPfVUzZ8/P6fFoTBSExupVVSmIrZkmrnLvkhNbMT9VMaG7ViqY2IDAAAA27jyyit11lln6fjjj1ddXZ2OPvpoff/739cPfvADXXTRRVmf7+6779bgwYNVVlamkSNH6vXXX9/u42fNmqUvfOELKi8v18CBA3XppZcqFot19s/pHtIaG14+JzbSGxsEiAMAAHRbWU9s/P3vf9crr7yiSCSScXzw4MFasWJFzgpD4TRnbDSHh/uBoWiOV9Xalc2NDTcjY4PGBgAAALZlGIauuuoqXX755Vq6dKnq6uo0bNgwVVVl/4X5Y489pqlTp2r27NkaOXKkZs2apbFjx+rDDz9Uv379Wj3+4Ycf1pVXXqk5c+Zo9OjRWrJkic4991wZhqE77rgjF39e11SoiQ1rm4kNAAAAdEtZT2wEQSDf91sd//zzz1VdXZ2TolBYfkNTeHjUVmhH5PqWyqOdil9pV8YqKt+VYwWyI2RsAAAAoG1hGKq2tlb9+/fXV77ylU41NSTpjjvu0OTJkzVp0iQNGzZMs2fPVkVFhebMmdPm41955RUdccQROuusszR48GB9/etf15lnnrnDKY9uL1GYxoZnk7EBAACATjQ2vv71r2vWrFmp24ZhqK6uTjNmzNCJJ56Yy9pQIF5d5iqqhlig6hwGh0uSVdXU2Ih5kpeQzcQGAAAA2rB69WpNmDBBvXr1Uv/+/dWvXz/16tVL3/ve97RmzZqszpVIJLRo0SKNGTMmdcw0TY0ZM0YLFy5s8zmjR4/WokWLUo2Mjz/+WM8888x2P+vE43HV1tZmXLqdjImN/K2iyjg3ExsAAADdVtbfXt9+++0aO3ashg0bplgsprPOOkv/+c9/1KdPHz3yyCP5qBF55tfVS2peReWoMR6qMseNjeaJjTAIZcTicqxAjmOprs7N6esAAABg11VbW6vRo0errq5OkyZN0gEHHKAwDPXee+/pkUce0csvv6w33nijw9Mb69evl+/76t+/f8bx/v3764MPPmjzOWeddZbWr1+vI488UmEYyvM8/fCHP9RPfvKTdl9n5syZuvbaazv+h3ZFxQgPJ2MDAACg28r62+u99tpLb731lh599FG9/fbbqqur03nnnaezzz47I0wcu47mxoZZFpFv2orFAlXlemKjsuXfRtDQKNsMZEcc1dUTwggAAICkn//857IsS++++6769u2bcd/VV1+tI444Qnfdddd2mww7a8GCBbrxxhv1q1/9SiNHjtTSpUt1ySWX6Gc/+5muueaaNp8zbdo0TZ06NXW7trZWAwcOzFuNJSkjPDyPq6gsVlEBAACgE40NSbJtW+ecc06ua0GR+PXJVVRGeZlc35TnBtotx40N07ZllkUUxBIK6hpbJjYaWEUFAACApKefflo/+clPWjU1JKlfv36aNm2a7r333g43Nvr06SPLslqtsFqzZo0GDBjQ5nOuueYaffe739X3v/99SdJBBx2k+vp6/c///I+uuuoqmWbrbb7RaFTRaLRDNXVZadMTGQHfOZYxsZGgsQEAANBdderb6//85z964YUXtHbtWgVBkHHf9OnTc1IYCserbwoPryiTG5hyXV+V1VbOX8euqlAilkhNbDgRW3UbaGwAAAAgacmSJRo9enS7948ePVqXXXZZh88XiUR02GGHaf78+TrllFMkSUEQaP78+ZoyZUqbz2loaGjVvLCs5HvjMAw7/NrdTvP0hBVVYEXy9jKsogIAAIDUicbGvffeq/PPP199+vTRgAEDZBhG6j7DMGhs7IKaJzbMivLkxEbCy/kqKkmyKiuk9Zvl18fkmL7siKlNdTQ2AAAAkFRbW6uePXu2e3/Pnj2zDuaeOnWqJk6cqMMPP1xf+cpXNGvWLNXX12vSpEmSpAkTJmjPPffUzJkzJUknnXSS7rjjDo0YMSK1iuqaa67RSSedlGpwoA3xpv8u0eq8vkzGmivCwwEAALqtrL+9vv7663XDDTfoxz/+cT7qQRH4jXFJyYkNLzDlub6qKnLf2LB7JEMeg7grM/RVFrW1tZ7GBgAAAJLCMGxz1VMzwzCynpoYP3681q1bp+nTp2v16tUaPny45s2blwoUX758ecZrXn311TIMQ1dffbVWrFihvn376qSTTtINN9zQuT+qu2huMkQ7FuzeWW5GxgaNDQAAgO4q62+vN23apG9/+9v5qAVFEIZhqrHRkrHhq6oq9+PjdlXy11V+wpPpuSovM1RHYwMAAABNwjDU/vvvnzEVvu39nTFlypR2V08tWLAg47Zt25oxY4ZmzJjRqdfqtppXUeV5YsO10xonTGwAAAB0W1k3Nr797W/rueee0w9/+MN81IMCCxpjUtMHxOZVVK7r5mcVVXNjI+bJ9l2Vl5s0NgAAAJAyd+7cYpeAzvDikp9IXo/2yO9LZWRsZLeWDAAAAF1H1t9e77vvvrrmmmv06quv6qCDDpLjOBn3X3zxxTkrDvnXHBwuSUZZtGVioyIP4eHVTY2NuCfHcxV1QjXGAvl+KMtq+1d5AAAA6D4mTpxY7BLQGc3TGlL+MzascoUyZChkFRUAAEA3lnVj4ze/+Y2qqqr04osv6sUXX8y4zzAMGhu7mFRwuGNKkYjcwJTneqqqykPGRmVyH64f92T4rhwzkB2xVd/oqUeVs4NnAwAAAChJ6Y2NSH4zNmQY8qwKOX49q6gAAAC6say/vV62bFk+6kCR+E0TG1bUVmjayYmNRH7Cw63UxIYrw3dlW6GciKW6OhobAAAAwC6rgBMbkuTalcnGBhMbAAAA3ZZZ7AJQXM2NDTNiK7SspowNX5V5yNiwq1omNkwvIccM5Dg2ORsAAADArqzgjY3k5womNgAAALqvDjU2brrpJjU2Nu74gZJee+01Pf300ztVFArHa0iuorIitmTacgNLhgJFnNz3vJozNryYJ8Nz5ViB7IhFYwMAAADYlWU0NvIbHi6lBYgn6qQwzPvrAQAAoPR06Nvr9957T3vvvbcuuOAC/X//3/+ndevWpe7zPE9vv/22fvWrX2n06NEaP368qqvz/ysd5EbLKipLoZVcReXkPjc8+RrpGRteQnZqYsPPzwsCAABgl/TCCy8UuwRkI31yIprnjA1Jrt30GmEguQ15fz0AAACUng41Nh544AE9//zzcl1XZ511lgYMGKBIJKLq6mpFo1GNGDFCc+bM0YQJE/TBBx/o6KOPznfdyJFUYyNipxobETs/v3pKX0VleAk5VpDM2GBiAwAAAGnGjRunffbZR9dff70+++yzYpeDHYnXtlwvxCoqqyLttbe2/0AAAAB0WR3eN3TIIYfo3nvv1YYNG7Ro0SI9/vjjuvfee/Xss89qzZo1+te//qUf/vCHKisry6qAu+++W4MHD1ZZWZlGjhyp119/vd3Hvvvuuzr99NM1ePBgGYahWbNmtXrMT3/6UxmGkXE54IADsqqpO/Hq6iVJZsRSaFpyA1PRPOV426nwcE+m58o2A9kRMjYAAACQacWKFZoyZYqeeOIJDR06VGPHjtXvf/97JRKJYpeGthQ4YyO1ikoiQBwAAKCbyjpIwTRNDR8+XN/61rd0xhlnaMyYMerTp0+nXvyxxx7T1KlTNWPGDL3xxhs65JBDNHbsWK1du7bNxzc0NGjo0KG66aabNGDAgHbP+6UvfUmrVq1KXV5++eVO1dcdtKyiapnYKI/k57WsdiY2ttLYAAAAQJo+ffro0ksv1eLFi/Xaa69p//331wUXXKA99thDF198sd56661il4h06Y2NSCFWUaU1NhJMbAAAAHRHuU+IzsIdd9yhyZMna9KkSRo2bJhmz56tiooKzZkzp83Hf/nLX9att96qM844Q9FotN3z2ratAQMGpC6dbbx0B35D2ioq01IsFqq60s7La9lVTRMbMU9mc8YGExsAAADYjkMPPVTTpk3TlClTVFdXpzlz5uiwww7TUUcdpXfffbfY5UGSEmk5FwVobHgZq6iY2AAAAOiOitbYSCQSWrRokcaMGdNSjGlqzJgxWrhw4U6d+z//+Y/22GMPDR06VGeffbaWL1++3cfH43HV1tZmXLoLvz75IcSKWPIMR/G4r8qK/DQ2rKqWVVSG5zZNbNiqq6OxAQAAgEyu6+qJJ57QiSeeqEGDBunZZ5/VL3/5S61Zs0ZLly7VoEGD9O1vf7vYZULKDPB2yvP/chkTGzQ2AAAAuqOiNTbWr18v3/fVv3//jOP9+/fX6tWrO33ekSNH6r777tO8efN0zz33aNmyZTrqqKO0dWv7I8ozZ85UTU1N6jJw4MBOv/6u5NPZD+uz+56UJJlRW57hKBF3VVWVr4mNplVUieQqKiY2AAAA0JaLLrpIu+++u37wgx9o//3315tvvqmFCxfq+9//viorKzV48GDddttt+uCDD4pdKqSMxsZf3t+S95cjYwMAAAD5+Qa7iE444YTU9YMPPlgjR47UoEGD9Pvf/17nnXdem8+ZNm2apk6dmrpdW1vb5ZsbsRVr9O+Lrk3dtiKWEmFEbsJTVW8rL6+ZHh5uuPHkxEbU1ta1NDYAAADQ4r333tMvfvELnXbaae2uoO3Tp49eeOGFAleGNqU1NjyrLP8vl9bYeP3DT/WVg/P+kgAAACgxWU9szJ07Vw0NDTt+4A706dNHlmVpzZo1GcfXrFmz3WDwbPXs2VP777+/li5d2u5jotGoevTokXHp6uJr1mfctiK2XMORG/dUlaeMjebwcIVS2NAo2wwUYWIDAAAA25gxY4a+/e1vt2pqeJ6nl156SVIyV++YY44pRnnYViK9sVGAVVRWS2PD8erz/noAAAAoPVk3Nq688koNGDBA5513nl555ZVOv3AkEtFhhx2m+fPnp44FQaD58+dr1KhRnT7vturq6vTRRx9p9913z9k5uwJ3U+aIuO/6co2IEvlsbFSUS4YhSQoaGuWYgSIRi8YGAAAAMhx33HHauHFjq+NbtmzRcccdV4SKsF1uY+pqIRob6auobBobAAAA3VLWjY0VK1bo/vvv1/r163XsscfqgAMO0M0339ypXIypU6fq3nvv1f3336/3339f559/vurr6zVp0iRJ0oQJEzRt2rTU4xOJhBYvXqzFixcrkUhoxYoVWrx4ccY0xmWXXaYXX3xRn3zyiV555RWdeuqpsixLZ555Ztb1dWWJjZszblfv1VNu6CRXUeWpsWEYRkvORsyV4Xsqr6CxAQAAgExhGMpo+kFMug0bNqiysrKNZ6Co3KbmgmkrNJ38v1xaY8PxaWwAAAB0R1l/g23btk499VSdeuqpWrNmjf7f//t/uv/++3XNNddo3LhxOu+883TSSSfJNHfcMxk/frzWrVun6dOna/Xq1Ro+fLjmzZuXChRfvnx5xnlWrlypESNGpG7fdtttuu2223TMMcdowYIFkqTPP/9cZ555pjZs2KC+ffvqyCOP1Kuvvqq+fftm+6d2ae7G5MRGr1HDtfsBUfUeNkDLFFEinshbY0NKrqPyttYnczZ8VxVlpuobfAVBKNNs/eEVAAAA3cdpp50mKfmDmHPPPTdjFZXv+3r77bc1evToYpWH9jSvonIK03Ry7YrUddvb+TXJAAAA2PXs1DfY/fv315FHHqklS5ZoyZIleueddzRx4kT16tVLc+fO1bHHHrvDc0yZMkVTpkxp877mZkWzwYMHKwzD7Z7v0Ucf7Wj53VrzKqrKfQep32GOQik5sRGvz2tjw66uVHzVuuTEhpdQxA5l2ZYaGv28vi4AAABKX01NjaTkxEZ1dbXKy1vWGkUiEX31q1/V5MmTi1Ue2tO8isrJ/xoqSfLI2AAAAOj2OvVN8po1a/Tggw9q7ty5+vjjj3XKKafoqaee0pgxY1RfX6/rrrtOEydO1KeffprrepEjiQ2bJUlOzypJccm05YWmEnlcRSVJVtPqAD/uyfQSsq1ATlOAOI0NAACA7m3u3LmSkj9ouuyyy1g7VeIefm25zhq5d8sqqkjF9p+QI6yiAgAAQNbfJJ900kl69tlntf/++2vy5MmaMGGCevfunbq/srJSP/rRj3TrrbfmtFDkVvMqKsuvl2QrtGx5gSk3j+HhUnJiQ0o2NhwvkQwQj9raWu9pQN5eFQAAALuSGTNmFLsEZCM1sVGYxkZmeDirqAAAALqjrL/B7tevn1588UWNGjWq3cf07dtXy5Yt26nCkF+JdeslSebG5ZKGKrQs+YEp3/VUXpZ1pnyH2T2aGhsxT5H0iY06AsQBAAC6s0MPPVTz589Xr169NGLEiDbDw5u98cYbBawM2xX4khdLXi9QYyMwHflmRFaQkOPVFeQ1AQAAUFqybmwcc8wxOvTQQ1sdTyQSevTRRzVhwgQZhqFBgwblpEDkh7thkyTJroxIkkLTlhcYsq1wux8id5ZdXSVJ8mKuTM+VYwZyoslVVAAAAOi+vvWtb6XCwk855ZTiFoOOa57WkAqWsSFJrlXZ1NhgFRUAAEB3lHVjY9KkSRo3bpz69euXcXzr1q2aNGmSJkyYkLPikD/N4eFORVNjo2kVlWPl93XtHsnGhh/zZHgJ2dGWjA0AAAB0X+nrp1hFtQtx01ZBRQqXieLZFZK7iVVUAAAA3VTWO4fCsO1f9H/++eeqqanJSVHIv8TmWknpExuWPN9UeSS/r+v0aJnYMLbJ2AAAAACwi0lvbBRyYqMpZ4PwcAAAgO6pwxMbzXtuDcPQ8ccfL9tuearv+1q2bJnGjRuXlyKRW2EYyt2c3EXrVLZMbMTdMK/B4VLmxIbpuXIsJjYAAAAg9erVq8MrUTdu3JjnatBhifTGRmEyNiTJtZOfK6wgIXkJyc7zL7QAAABQUjr8LXbzntvFixdr7NixqqqqSt0XiUQ0ePBgnX766TkvELnn1zcodJONhNQqKtNWYyxQZUV+d1GlZ2wYXkJ2c8ZGXSyvrwsAAIDSNmvWrGKXgM5Iz9go4Cqq5okNSVJ8q2TvVrDXBgAAQPF1uLHRvOd28ODBGj9+vMrKyvJWFPLL3ZjM1zBsU2akqZFhWYrFfFUXaGLDa2xaRcXEBgAAACRNnDix2CWgM9yWVVDvrnOl3gV6Wbvlh3aK10qVNDYAAAC6k6y/xeYDx64vsbElOLx53D80bTU2hgVrbPgxV2bTxEYkGlXdVj+vrwsAAIDSVltbqx49eqSub0/z41AC0iY2PKuQGRvpjY2tBXtdAAAAlIYOfYvdu3dvLVmyRH369Nnh7lv23ZY+d9NmSZJd0bKHNrRsNcYD7d4j342N5Mi4F/NkpGVsbK1z8/q6AAAAKG29evXSqlWr1K9fP/Xs2bPNzxxhGMowDPk+P4opGYmWiQ3fKtxUP40NAACA7q1D32Lfeeedqq6uTl3vaKgfSlPzKiqn0kkdCy1bsUZPVQPy3NiobpnYSGVsRGzV1fPhFAAAoDv729/+pt69k3uMXnjhhSJXgw5zW8LDCzuxkZ6xsf0JHwAAAHQ9HfoWO3391LnnnpuvWlAgzY2N9IkN37DkuoGqqgqUsRHzZDZNbESiTGwAAAB0d8ccc0yb11GifFej3rpSWvl06hCrqAAAAFAoWX+L/cYbb8hxHB100EGSpD/96U+aO3euhg0bpp/+9KeKRCI7OAOKzd3curERer7chK+qyvz+90vP2JAbl234TauoCA8HAABAi02bNul3v/ud3n//fUnSsGHDNGnSpNRUB4rsjQc0JK2pIRWzscHEBgAAQHdjZvuEH/zgB1qyZIkk6eOPP9b48eNVUVGhxx9/XFdccUXOC0Tu+bGEJMlyrNQxw03I93xVVVjtPS0nnKbGhkIpiLuy5CsSMdQQC+T5YV5fGwAAALuGl156SYMHD9Zdd92lTZs2adOmTbrrrrs0ZMgQvfTSS8UuD5L06T9aHSJjAwAAAIWSdWNjyZIlGj58uCTp8ccf1zHHHKOHH35Y9913n5588slc14c8CN3k2ifDavnPb3gJua6vqsr8rqIyy8tkWMnmid/oyvQSss1QkYitOqY2AAAAIOnCCy/U+PHjtWzZMv3hD3/QH/7wB3388cc644wzdOGFFxa7PEiS03o6o2gZGzEmNgAAALqbrBsbYRgqCAJJ0vPPP68TTzxRkjRw4ECtX78+t9UhL4J4cmLDsAz5keSHjy2995FXgMaGYRhpORuujKacDSdia2s9ORsAAACQli5dqh/96EeyrJZpYsuyNHXqVC1durSIlSHFdFod8pjYAAAAQIFk3dg4/PDDdf311+vBBx/Uiy++qG984xuSpGXLlql///45LxC5F8RikiTTMrXhq6dq42EnamOv/QvS2JDSczY8GV5CthnIiZKzAQAAgKRDDz00la2R7v3339chhxxShIrQSmxLq0N+ISc2HBobAAAA3VnW32LPmjVLZ599tv74xz/qqquu0r777itJeuKJJzR69OicF4jcC+Lx5BXHVhgpkxsZIG+LJc/1VVmIxkZ1cmzciyVXUaUmNmhsAAAAdFtvv/126vrFF1+sSy65REuXLtVXv/pVSdKrr76qu+++WzfddFOxSkS6hg2tDnlWRcFenokNAACA7i3rb7EPPvhgvfPOO62O33rrrRmj4ihdzRMbhtMyPu4HhiwjkG0ZeX/99IkNx0vIMQNFmNgAAADo1oYPHy7DMBSGYerYFVdc0epxZ511lsaPH1/I0tCWho2tDhV2FVVaxkacjA0AAIDuptM/z08kElq7dm0qb6PZ3nvvvdNFIb/C5omNSEtjwwtMOfkf1pAk2TXVydeMuYp4rmwmNgAAALq9ZcuWFbsEZKPNiY3CraLyzTIFhiUz9GlsAAAAdENZf5W9ZMkSnXfeeXrllVcyjodhKMMw5Pt+zopDfjSvojKcSOqYFxiK2vmf1pAkJzWx0bSKymnO2CA8HAAAoLsaNGhQsUtAR4Vhm42NwIy08eA8MQy5dpWi7hZWUQEAAHRDWTc2Jk2aJNu29dRTT2n33XeXYRTmy3DkTipjI9LywcMPTJVFCvPf0q5ONja85vDwsuaJDRobAAAAaPHee+9p+fLlSiQSGcdPPvnkIlUESVKiXvLjrY8X+LMhjQ0AAIDuK+vGxuLFi7Vo0SIdcMAB+agHBRAkmhoIaY2NiOWrLFqY17d7JPfh+jFXhuemZWw0FqYAAAAAlLSPP/5Yp556qt55552M3I3mH1UxJV5kbUxrFEMqZyPGKioAAIDuxsz2CcOGDdP69evzUQsKJHSTjQ0jLVQjYgeqiGb9z6FTmsPDvUZPppcgYwMAAAAZLrnkEg0ZMkRr165VRUWF3n33Xb300ks6/PDDtWDBgmKXh5JpbCQ/V8iPS14bEyQAAADosrL+Jvvmm2/WFVdcoQULFmjDhg2qra3NuKD0BYlkA8FwbH26qUpeYOiD1dWqrLAK8vrNq6iSExsJOWZTxkY9jQ0AAABICxcu1HXXXac+ffrINE2ZpqkjjzxSM2fO1MUXX1zs8tCwsdWhWKR3wctINTYkKV5X8NcHAABA8WS9imrMmDGSpOOPPz7jOOHhu47Aa2ogOLYWr+yrxSv6qrHRVXVF1v8cOiU1sRFzZfgJOVagSMTWWiY2AAAAoOSqqerqaklSnz59tHLlSn3hC1/QoEGD9OGHHxa5uu7p4deW66yReydvNKRN8B/wTSlarQWV3yp4TalVVJIUr5Uqdyt4DQAAACiOrL/JfuGFF/JRBwoobJrYCC1HYZjcU+wl/MJNbPRomdgwPVe2SXg4AAAAWhx44IF66623NGTIEI0cOVK33HKLIpGIfvOb32jo0KHFLg/pq6i+dKp00H9r42vLC15G5sQG2wMAAAC6k6wbG8ccc0w+6kABNU9sBHZLeLjn+arsUeiJDS+5ispqWkXFxAYAAAAkXX311aqvr5ckXXfddfrmN7+po446Srvttpsee+yxIlfXfWRMaaRLb2xUFG9KIrOxsbVodQAAAKDwOvVN9t///nf9+te/1scff6zHH39ce+65px588EENGTJERx55ZK5rRI6FblNjw3JSxzzXV0V5cTI2mic26ht8+X4oyzIKUgcAAABK09ixY1PX9913X33wwQfauHGjevXqJcPgvWLR0dgAAABAkWUdHv7kk09q7NixKi8v1xtvvKF4PC5J2rJli2688cacF4jcC7xkDopvpU1suL4qCryKymv0ZHquHCuQaRqyHUt1BIgDAAAgzWeffabPPvtMvXv3pqlRKjIaG4UPDW+WmbFBYwMAAKA7ybqxcf3112v27Nm699575Tgtv/g/4ogj9MYbb+S0OORH2NTYyJzY8FRZoPBwJy1jQ74nW56ksClng8YGAABAd+d5nq655hrV1NRo8ODBGjx4sGpqanT11VfLdcllKzo31nLdqSheGWkTG//84JOi1QEAAIDCy/qb7A8//FBHH310q+M1NTXavHlzLmpCnjVPbIRO+sRGUMDw8OQvq8IgVOAGMv2EbDNsytlwJZUXpA4AAACUposuukh/+MMfdMstt2jUqFGSpIULF+qnP/2pNmzYoHvuuafIFXZzQVpzKe3HUoWW3thwvLqi1QEAAIDCy3piY8CAAVq6dGmr4y+//LKGDh2ak6KQX80TG2F6eHgBJzasygqpaY2AH3NT66giTGwAAABA0sMPP6z77rtPP/jBD3TwwQfr4IMP1g9+8AP97ne/08MPP5z1+e6++24NHjxYZWVlGjlypF5//fXtPn7z5s268MILtfvuuysajWr//ffXM88809k/p+vx096zm44efm15UcpwnfTGRn1RagAAAEBxZN3YmDx5si655BK99tprMgxDK1eu1EMPPaTLLrtM559/fj5qRI6lMjbMlkZGEIQFCw83TFN2dXJqw0sPEI/a2krGBgAAQLcXjUY1ePDgVseHDBmiSCTS+gnb8dhjj2nq1KmaMWOG3njjDR1yyCEaO3as1q5d2+bjE4mEvva1r+mTTz7RE088oQ8//FD33nuv9txzz878KV0TExsAAAAosqx/on/llVcqCAIdf/zxamho0NFHH61oNKrLLrtMF110UT5qRI6FXiBJctP6Wo5jF2xiQ0oGiHu1dfJjngwvIccMyNgAAACAJGnKlCn62c9+prlz5yoajUqS4vG4brjhBk2ZMiWrc91xxx2aPHmyJk2aJEmaPXu2nn76ac2ZM0dXXnllq8fPmTNHGzdu1CuvvJLKFGyrydKt+cnGRihDhlmYH0e1JT08nMYGAABA95L1N9mGYeiqq67S5ZdfrqVLl6qurk7Dhg1TVVXVjp+MkhD6yYmNhFp+XeVE7YJNbEjJxoaUnNgwvYRsK1AkSmMDAACguzrttNMybj///PPaa6+9dMghh0iS3nrrLSUSCR1//PEdPmcikdCiRYs0bdq01DHTNDVmzBgtXLiwzef8+c9/1qhRo3ThhRfqT3/6k/r27auzzjpLP/7xj2VZxfsSv6QEyffsgWGrmP+LMLEBAADQfXXqJ/phGKq2tlb9+/fXsGHDcl0T8qx5YsMzWv7z122qk2X1K1gNdnXyQ4gf8+R4btrEhruDZwIAAKArqqmpybh9+umnZ9weOHBg1udcv369fN9X//79M473799fH3zwQZvP+fjjj/W3v/1NZ599tp555hktXbpUF1xwgVzX1YwZM9p8TjweVzweT92ura3NutZdSnNjwyylxgYZGwAAAN1JVo2N1atX64orrtCf//xnbd26VZLUo0cPnXrqqZo5c2arDwwoPWEYKvRbGhvPPf5P9d+rl7as2SCpcOHv6RMbkaaJDSdqa2tdfAfPBAAAQFc0d+7cYpcgSQqCQP369dNvfvMbWZalww47TCtWrNCtt97abmNj5syZuvbaawtcaRE1r6IyCrfKts0yzKgCw5YZekxsAAAAdDMdfidaW1ur0aNHq66uTpMmTdIBBxygMAz13nvv6ZFHHtHLL7+sN954g5VUJS70WlY9+WZEdVsaVbelUXvvWV7QOpyapomNxuQqKschYwMAAACZ1q1bpw8//FCS9IUvfEF9+/bN6vl9+vSRZVlas2ZNxvE1a9ZowIABbT5n9913l+M4GWunvvjFL2r16tVKJBJthpdPmzZNU6dOTd2ura3t1ITJLqMpPDwwixccLkkyDLl2paLuFhobAAAA3Yy544ck/fznP5dlWXr33Xd155136gc/+IF++MMf6q677tK7776rMAx111135bNW5EDotjQO3LRfWBUyOFxqWUXlNYeHk7EBAACAJvX19fre976n3XffXUcffbSOPvpo7bHHHjrvvPPU0NDQ4fNEIhEddthhmj9/fupYEASaP3++Ro0a1eZzjjjiCC1dulRBEKSOLVmyRLvvvnubTQ1Jikaj6tGjR8alS/NbMjaKrXkdFauoAAAAupcONzaefvpp/eQnP2nzV1L9+vXTtGnT9Je//CWnxSH3gkRLhoVrtPzCqqKisNtxU6uoGhMyPVd2U8ZGLY0NAACAbm/q1Kl68cUX9Ze//EWbN2/W5s2b9ac//UkvvviifvSjH2V9rnvvvVf333+/3n//fZ1//vmqr6/XpEmTJEkTJkzICBc///zztXHjRl1yySVasmSJnn76ad1444268MILc/o37tJSExul1NhgYgMAAKA76fA70SVLlmj06NHt3j969GhddtllOSkK+ROkTWwk5EhKZloUemLD6VktSfIa3dTEBuHhAAAAkKQnn3xSTzzxhI499tjUsRNPPFHl5eX6zne+o3vuuafD5xo/frzWrVun6dOna/Xq1Ro+fLjmzZuXygdcvny5TLPl914DBw7Us88+q0svvVQHH3yw9txzT11yySX68Y9/nLO/b5eXytiw9PBry4taimtXSpKsICF5ccmOFrUeAAAAFEZWGRs9e/Zs9/6ePXuqtrY2FzUhj0K3qXFgGjKjaY2N8gJPbPSskSR5DcnGhm2yigoAAABJDQ0NqcZDun79+mW1iqrZlClTNGXKlDbvW7BgQatjo0aN0quvvpr163QbQemtopIkxbfS2AAAAOgmOryKKgzDjF8ybcswDIVhmJOikD/Nq6hMy1Q02rKKquATG72Se4e9hkQyPLxpYqO+wZfv8+8IAACgOxs1apRmzJihWCyWOtbY2Khrr7223WwMFJBfSquoKltuxPmhHQAAQHfR4XeiYRhq//33l2EY7d6P0tccHm5YhizHlmVKflD4jA2nV3Jiw21wZXiuHCuQ7VgyTEN19Z5qejg7OAMAAAC6qlmzZmncuHHaa6+9dMghh0iS3nrrLZWVlenZZ58tcnVoztgIS2Jio7rlRnxr8QoBAABAQXX4nejcuXPzWQcKpHliw7BMhYalnjURbdiUUGWhGxs9myY2GhOpjA1JikRsbdnq0tgAAADoxg466CD95z//0UMPPaQPPvhAknTmmWfq7LPPVnl5eZGr6+bCMG0VVfHfs2dMbMSY2AAAAOguOtzYmDhxYj7rQB41fr5a/zrtAg2+4Gz1OOSLkpKrqALDVO9ezY2NQq+ias7YSMj0XEUsP3k8YmtLrSvtWdByAAAAUCJc19UBBxygp556SpMnTy52OdhW0JKJVwqrqBJOj9T1l95ZqqOHHFXEagAAAFAoHc7YwK5rw4uvqfbNd7Xi4T8rcBOSmic2bA3cI/mLt/59Cxuyl8rYaHQlz5Vj+DIUyok2NTYAAADQLTmOk5GtgRLjt7xXL4Xw8ETaKirHZRUVAABAd0FjoxtoztUIEq6CWFySZNqmZJi69Af76qZrvqSvjOhd0JqaJzYUSl7MleElFLF8ORFbm2lsAAAAdGsXXnihbr75Znmet+MHo7CClvfqYQlMbLhOS2MjQmMDAACg2yj+O1HkXaqxEU8ojDdPbBgKDVu9ekZ05Ff6FLwmKxqRWV6moDEmr8GV6SXk2IEiTGwAAAB0e//85z81f/58PffcczrooINUWVmZcf8f/vCHIlUG+WmrqEphYiO9seHR2AAAAOguiv9OFHkXNDU2woSrIJG2isos7sCO06uH4o2xpgBxVxErSE5sbKGxAQAA0J317NlTp59+erHLQFvSJjZKIWPD3WYV1cOvLddZI/cuYkUAAAAohKzfib7wwgs67rjj8lEL8iRsGuEPXFdBvGkVlWXKMIrd2KhRfOVaeQ2JllVUUVtbahNFrQsAAADFNXfu3GKXgPYEpTax0RIeHvFqi1gJAAAACinrb7bHjRunffbZR9dff70+++yzfNSEHGtuZgSNMYVpExu2ZRSzLDk9kx9C3KZVVKmJDVZRAQAAdEtBEOjmm2/WEUccoS9/+cu68sor1djYWOyykC4tPDwsscYG4eEAAADdR9aNjRUrVmjKlCl64oknNHToUI0dO1a///3vlUjwK/tS5a9fk/y/dbWpJodhmzKL29eQ0yv5ISR9YoOMDQAAgO7rhhtu0E9+8hNVVVVpzz331M9//nNdeOGFxS6r23n4teXt35k+sVECq6gSdnp4OBMbAAAA3UXWjY0+ffro0ksv1eLFi/Xaa69p//331wUXXKA99thDF198sd5666181ImdEMRjyf/r+gqaw8NtS2bRJzZqJElegyvDc+U0TWxsqfV28EwAAAB0RQ888IB+9atf6dlnn9Uf//hH/eUvf9FDDz2kIAiKXRqapU1sBIZTxEKaarCi8s2IJMLDAQAAupOdClk49NBDNW3aNE2ZMkV1dXWaM2eODjvsMB111FF69913c1UjdlJzxkbo+Wnh4ZbsEggPl5ITG6aXUMROZmxsJmMDAACgW1q+fLlOPPHE1O0xY8bIMAytXLmyiFUhQ4mFh0stUxsRVlEBAAB0G536Ztt1XT3xxBM68cQTNWjQID377LP65S9/qTVr1mjp0qUaNGiQvv3tb+e6VnRS6CY/fASeryDWsorKsopZVTI8XEpmbBi+q4gVKBKxVVfvy/P4VR4AAEB343meysrKMo45jiPXZVVpyfBbpqtLIWNDkhJOsrHhMLEBAADQbWT9TvSiiy7SI488ojAM9d3vfle33HKLDjzwwNT9lZWVuu2227THHnvktFB0XpBontgIFDR9KDRsS7Zd5FVUNckPIF5jS8aGE03+k9yy1dNuvSLFLA8AAAAFFoahzj33XEWj0dSxWCymH/7wh6qsrEwd+8Mf/lCM8iBlTmwYRf6lVBPXTk6CR7w6GaFf5GoAAABQCFk3Nt577z394he/0GmnnZbxgSNdnz599MILL+x0ccgNv2n9VOgHLRMbliXHLvYqquaMjeQqKscKFGlubNS6NDYAAAC6mYkTJ7Y6ds455xShErTLL8FVVE5LgLjt1RWxEgAAABRK1u9EZ8yYodGjR8u2M5/qeZ5eeeUVHX300bJtW8ccc0yHznf33Xfr1ltv1erVq3XIIYfoF7/4hb7yla+0+dh3331X06dP16JFi/Tpp5/qzjvv1P/+7//u1Dm7Az/R8uHDq2uQlJzYcIr8OaQlY8NtmdhoKmpzLesGAAAAupu5c+cWuwTsSNrERqmsonLTGhvkbAAAAHQPWf9k/7jjjtPGjRtbHd+yZYuOO+64rM712GOPaerUqZoxY4beeOMNHXLIIRo7dqzWrl3b5uMbGho0dOhQ3XTTTRowYEBOztkdNIeHS5Jfn9bYsIo8sdEz2dhwG5pXUQUyTEO2Y2kLjQ0AAACg9KRlbAQl0thoDg+XaGwAAAB0F1l/sx2GoQyjdTbDhg0bMvbedsQdd9yhyZMna9KkSRo2bJhmz56tiooKzZkzp83Hf/nLX9att96qM844o901WNmeszsIvZY9s15DTFJyFVWkyJueWlZRuTLduGwrlGmEikRtbd5CYwMAAAAoCY2bdfCSX0jvPJGZsWE6RSyqRfoqKgLEAQAAuocO/8TmtNNOkyQZhtEq0M/3fb399tsaPXp0h184kUho0aJFmjZtWuqYaZoaM2aMFi5c2OHz5OKc8Xhc8Xg8dbu2trZTr1+qvERaY6N5FZVjySl2eHjzKqrGhIx4suHiWL4iUYeJDQAAAKBU/HW6Dvzofumj30jHXZ06XDoTGz1S1yNu1/osBwAAgLZ1+J1oTU3y1/VhGKq6ulrl5eWp+yKRiL761a9q8uTJHX7h9evXy/d99e/fP+N4//799cEHH3T4PLk458yZM3Xttdd26jV3BYGbtoqqaWJDtq1IiYSHK5SCugYpDBWxAkXKHDI2AAAAgFLxxv0t1z9+IXU1LJHwcDI2AAAAup8OvxNtDvIbPHiwLrvssqzXTpWyadOmaerUqanbtbW1GjhwYBEryq30VVR+Q6Ok5CoqxynuxIZVXiYzGlEQT8hvjKcCxCNlNhMbAAAAQCnyE6mrJTOx4aRNbHhMbAAAAHQHWb8TnTFjRk5euE+fPrIsS2vWrMk4vmbNmnaDwfN1zmg02m5mR1eQ0diob57YsBRxijuxISWnNuKr18ltytmIWIGiZY621DYWuzQAAAAA20pvbJTKxEZaeLjDxAYAAEC30KFvtg899FBt2rRJkjRixAgdeuih7V46KhKJ6LDDDtP8+fNTx4Ig0Pz58zVq1Kgs/4z8nbMrCP30VVRNDQPbll3kjA0pLWejISHDjSliJzM2CA8HAAAASpCfFh5eMhMbaauoCA8HAADoFjr0TvRb3/pWaqLhlFNOydmLT506VRMnTtThhx+ur3zlK5o1a5bq6+s1adIkSdKECRO05557aubMmZKS4eDvvfde6vqKFSu0ePFiVVVVad999+3QObujzFVUTSHppdLY6Nnc2HBlu3E5TRMbK1lFBQAAAJSetMZGWCqNDZuMDQAAgO6mQ+9E09dP5WoVlSSNHz9e69at0/Tp07V69WoNHz5c8+bNS4V/L1++XKbZMlSycuVKjRgxInX7tttu02233aZjjjlGCxYs6NA5uyU/rbERS2tsWKWxikpKTmxE3HhyYoOMDQAAAKA0leIqqrSJDYeJDQAAgG6h6O9Ep0yZoilTprR5X3OzotngwYMVhuFOnbM7CtyWxkYQa/ogYttySmhiw21IJDM2ooEiUUfxRKBYzFdZmVXkCgEAAACkZKyicopYSIvMiQ3CwwEAALqDDjU2evXqJcPo2JfgGzdu3KmCkHth+sRGY0tjoyRWUaUmNlwZblwRy1dZebkkaXOtqwE0NgAAAIDS4cdTV0tlYiOwovLMqOwgzsQGAABAN9Ghd6KzZs3KcxnIp9AP0m4kJ15C25ZllUJjoyljozEh040lMzbKI5KkLbWuBvQrK2Z5AAAAANJ5LauoSiVjQ5ISTg/Z8XVMbAAAAHQTHXonOnHixHzXgXxKb2w0s+wOT+HkU3p4uOnGFbECOdHkP8vN5GwAAAAApaUEMzYkybWrpfg6wsMBAAC6iQ69E62trVWPHj1S17en+XEoHaHntz5ol8Y+3OZVVG5DIrmKyvZlmqYs2yRAHAAAACg16auojNJZG5toChB3/AbJ9ySrdJouAAAAyL0OZ2ysWrVK/fr1U8+ePdv8pX8YhjIMQ77fxpfoKKowaD2xEZTIG/3UKqrm8HArWWu0zNHmLTQ2AAAAgFJVSquoXKclQFzxWqmid/GKAQAAQN516J3o3/72N/XunXxj+MILL+S1IORe6LVubIR2aXwIcXr3lCS59cmMDcsMZRqBImUOq6gAAACAEhaYpTEFLkkJu6Wx8edX39fJ/3VEEasBAABAvnXo2+1jjjmmzevYNYRtTdGUlRe+kDZEduspKdnYMNzkWHvEChQtc7SJiQ0AAACgZAUlNLGRcFpWIjseAeIAAABdXafeiW7atEm/+93v9P7770uShg0bpkmTJqWmOlBigrD1sfKKwtfRBme3XpIkv9GVEgkp8BW1/eTExubEDp4NAAAAoFhKqbHhpk1sECAOAADQ9ZnZPuGll17S4MGDddddd2nTpk3atGmT7rrrLg0ZMkQvvfRSPmrETgraCA/3S6Wx0avll1UtORu+IlGbiQ0AAACghIVm6TQ2EmkZGxGPxgYAAEBXl/U70QsvvFDjx4/XPffcI8uyJEm+7+uCCy7QhRdeqHfeeSfnRWLnhH7rjA1VVBa+kDaYti27Zw95m2tT66gidtMqqpVMbAAAAAClqpQmNhIZExusogIAAOjqsp7YWLp0qX70ox+lmhqSZFmWpk6dqqVLl+a0OORGW42NsLw0MjakzJwN040pajWtomJiAwAAAMi7h19b3qnnBSU0seGmTWw4rKICAADo8rJubBx66KGpbI1077//vg455JCcFIXcCrfJ2DBsU75TVqRqWov07ilJ8uqbVlHZviJRR/UNvuKJNqZNAAAAABRdSU1spIWHRwgPBwAA6PI69E707bffTl2/+OKLdckll2jp0qX66le/Kkl69dVXdffdd+umm27KT5XotDAMW4WH22WOgjDrnlbeOH2SAeJufVwRN65IWaCyckeStHlLQv37lk4TBgAAAEBSKU1sJOy0xgarqAAAALq8Dr0THT58uAzDSH5J3uSKK65o9bizzjpL48ePz1112Gmh23qdk1Vmy89+WCdvmic23Lpkxka0yld5RXJV1qYtLo0NAAAAoASFhlPsElLikZrU9ai7pYiVAAAAoBA61NhYtmxZvutAnoSe3+qYXe6oUdEiVNO2loyNeHIVVVPGhiRt2kyAOAAAAFCKSmsVVc/U9Uhic9HqAAAAQGF06J3ooEGD8l0H8iRwvVbH7DJHCbN0piCcbcLDI3Yg20n+0yRAHAAAACiioP3Mu1JaReXaVQoMW2boMbEBAADQDXT6neh7772n5cuXK5HI/EX9ySefvNNFIXeCROuJB6vMVsKIFKGatqWHhxtNExuGacp2LG2isQEAAAAUT9D2+/FApmSUznpbGYbiTg+VJzYqysQGAABAl5d1Y+Pjjz/WqaeeqnfeeScjd8MwDEmS77defYTiCdtobNhljuJGqU5sxBW1fUmhImUOq6gAAACAYvLbbmyEJTSt0Szh9FR5YqMi7uZilwIAAIA8y/onNpdccomGDBmitWvXqqKiQu+++65eeuklHX744VqwYEEeSsTO8OPxVses8ogCWUWopm2R3XpJamlsmIZkm6GiUZtVVAAAAEAxtTexUUL5Gs3ikZ6SJMdvlLzWn4MAAADQdWTd2Fi4cKGuu+469enTR6ZpyjRNHXnkkZo5c6YuvvjifNSInRDGW088mJWlM60hSU7TKiq3Pi7DTX4AidjJAHFWUQEAAABFFLQ9kR8apfNDqWZxp6blRsPG4hUCAACAvMu6seH7vqqrqyVJffr00cqVKyUlA8Y//PDD3FaHnRYk2pjYqCxXEBpFqKZtkaZVVF59QkaiUQpDRa3mxgarqAAAAICiaWcVVWA6BS5kxxJNExuSpEYaGwAAAF1Z1vPDBx54oN566y0NGTJEI0eO1C233KJIJKLf/OY3Gjp0aD5qRCd5W+u05Y33Wh03K8vl+aXX2AiDUEGjK8N3FbF9RcscbVrNxAYAAABQNLvSKiqnZ8sNJjYAAAC6tKzfjV599dWqr6+XJF133XX65je/qaOOOkq77babHnvssZwXiM5b/L0rteaPf2113KqqUCllvFsV5TLLogpicbn1cZmJmKJWoGi5o81bEgrDMBVODwAAAKCA2p3YKMXGRssqqr+/vURHDTmqiNUAAAAgn7J+Nzp27NjU9X333VcffPCBNm7cqF69evHlc4mpe+eDNo+b1ZXygqy3kOVVpE8vxT5fnQwQT8QUsXyVlUeUcEM1NPqqrCi9D04AAABAlxd4bR4OS3BiI30VVSSxuWh1AAAAIP926tvtzz77TJ999pl69+5NU6MEuRs2tH1HZVXJ/feKpALEEzITjYrYviqqopKkTZtZRwUAAAAURXsTGyXY2EhfRRV1txSvEAAAAORd1o0Nz/N0zTXXqKamRoMHD9bgwYNVU1Ojq6++Wq7LF9DFFAaB4q88I2/Zu5Ikr751cLgkhdXVsktrYENOWoC4mWhU1A5UUZlsbGyuJUAcAAAAKIp2JjZKchVVpGUVVdTdXLxCAAAAkHdZf7190UUX6Te/+Y1uueUWvfnmm3rzzTd1yy236He/+50uvvjifNSIDnKXLNZ7V/9Sn910s/zGmAK3JUjDMFsmNMKqHrLMEpvYaGpsNGdsRCxf0XJHEhMbAAAA2Dl33323Bg8erLKyMo0cOVKvv/56h5736KOPyjAMnXLKKfktsJS119gowYmNRNrEBquoAAAAuras340+/PDDevTRR3XCCSekjh188MEaOHCgzjzzTN1zzz05LRAdt+r/5mvl3z/Syr9/pAEzMkevzYglP5b8UOJX1siyilFh+5z0VVRusrFhRxwZhqFNW2hsAAAAoHMee+wxTZ06VbNnz9bIkSM1a9YsjR07Vh9++KH69evX7vM++eQTXXbZZTrqqG4eQN3OKqqwJCc2eqaus4oKAACga8t6YiMajWrw4MGtjg8ZMkSRSCQXNaGTGtdvTl13N2zKuC8Mwpb7qnqX3CqqlomNllVUkhQtd7RpM6uoAAAA0Dl33HGHJk+erEmTJmnYsGGaPXu2KioqNGfOnHaf4/u+zj77bF177bUaOnRoAastQUHbjQ3fcApcyI4lnLRVVExsAAAAdGlZf709ZcoU/exnP1M83pLfEI/HdcMNN2jKlCk5LQ7Z8dOuu+vXZ9xXOaCHnOqoyvtWKR6tVtQOVUqc3r0kpWdsJP+asooIExsAAADolEQioUWLFmnMmDGpY6ZpasyYMVq4cGG7z7vuuuvUr18/nXfeeR16nXg8rtra2oxLl9HOxEbC6VHgQnYsMB25VqUkKULGBgAAQJfWofnh0047LeP2888/r7322kuHHHKIJOmtt95SIpHQ8ccfn/sK0WHxoGW/lLtuQ8Z9ZsTWqOtOlExDbxgVKnOCQpe3XdtmbDhWIEOhysoj2rSFiQ0AAABkb/369fJ9X/3798843r9/f33wwQdtPufll1/W7373Oy1evLjDrzNz5kxde+21O1Nq6WonYyORtvaplMQjPeU01iuaYBUVAABAV9ahxkZNTU3G7dNPPz3j9sCBA3NXETotNFsaG4n1GzPuM2xLppO8v94vV8QurfBwZ5tVVJLkWIHKKiLavDlWxMoAAADQXWzdulXf/e53de+996pPnz4dft60adM0derU1O3a2tqu8xmpnYmNuFPT5vFiizs1qmpcoYi7RQoCySyxHbwAAADIiQ41NubOnZvvOpADsbTPHO6GbRobVksjY3PM0e49S6uxEWkOD69LyHTjUhAoavvJVVQbtxa3OAAAAOyS+vTpI8uytGbNmozja9as0YABA1o9/qOPPtInn3yik046KXUsCJKTzrZt68MPP9Q+++zT6nnRaFTRaDTH1ZeI9iY2SrSx0TxJYiqQ4luk8l7FLQgAAAB50emfr6xbt04vv/yyXn75Za1bty6XNaGTQqNlYiO+NjNjQ05UgR2RH63UlgZDTolNbKSvopIk040pYvmsogIAAECnRSIRHXbYYZo/f37qWBAEmj9/vkaNGtXq8QcccIDeeecdLV68OHU5+eSTddxxx2nx4sVdZwojG+00Nkp5YiOlYWP7DwQAAMAurUMTG+nq6+t10UUX6YEHHkj9esmyLE2YMEG/+MUvVFFRkfMi0TFh2ph1bNU2zSbb0rqjzpAMQ1te8hWNRApc3fZF+iR/SRUkfAWunwoQL6uIaPMWV54XyLYZIwcAAEB2pk6dqokTJ+rwww/XV77yFc2aNUv19fWaNGmSJGnChAnac889NXPmTJWVlenAAw/MeH7Pnj0lqdXxbqO98PASzthIadxUtDoAAACQX1l/Uzx16lS9+OKL+stf/qLNmzdr8+bN+tOf/qQXX3xRP/rRj/JRIzrIsNImNtZt8+skw5AsWzItbal1tdcepdWAsmuqU/UnczZiijRlbIShtH4jUxsAAADI3vjx43Xbbbdp+vTpGj58uBYvXqx58+alAsWXL1+uVatWFbnK0mT5jdLyV9q8r1QnNhJOz5YbTGwAAAB0WVlPbDz55JN64okndOyxx6aOnXjiiSovL9d3vvMd3XPPPbmsD1kJU9cSG7Zk3BO4fup6XZ2n/n1LawewYZqK9Out+Kp1SmyNyUzEFLV9VVQlGzDrN8Y1oF9ZkasEAADArmjKlCmaMmVKm/ctWLBgu8+97777cl9QqQp86Z0ntOeauBR+V8e//n1p89ttPrRUMzYyGi6NNDYAAAC6qqwbGw0NDalfN6Xr16+fGhoaclIUOsfwW5oX7jaB2368ZYQ8YhsyzdLK2JCkaP++ycZGbUyRRKOiVb4iZY4kad0GJjYAAACAvPr3k9L//Y+OkaQD91afdpoaUulObGSsomJiAwAAoMvKehXVqFGjNGPGDMVisdSxxsZGXXvttW0G8KFwjLRgP3dLfcZ9QdzV+2t66e2Vu6lvL2vbp5aE6IA+kqREbUxmolHljifTNOVEbK3bEC9ydQAAAEAX99w1LdcX3Lzdh5ZqxkbGKiomNgAAALqsrCc2Zs2apXHjxmmvvfbSIYccIkl66623VFZWpmeffTbnBaLjjKYwd0kKEl7GfWHC04frkgHdew8ozcmaaL/0xkZM5U5yAqWsIqL1NDYAAACA/DLTPh7uoCngW6W5JpaJDQAAgO4h68bGEPdzWAAAS3lJREFUQQcdpP/85z966KGH9MEHH0iSzjzzTJ199tkqLy/PeYHIQtoqqm0FiZZVVPvuXZofQlomNuKpiQ1JKiuPsIoKAAAAyDczbaC/cVPx6tgJZGwAAAB0D1k1NlzX1QEHHKCnnnpKkydPzldNyEIYBgrWfC6zz+6S57X7uCDu6YU/vSnfDzThjoMKWGHHRfs3NTa2xmS6MUUsX1KosooIq6gAAACAfDPSGxubi1bGzoinraJavXqlBhSvFAAAAORRVhkbjuNkZGug+OJv/0tLLpqq2j8/JqWtotpW4HrqEfW1dz9Lu/WOFLDCjosO6CupaRVVvFGGIUWsoGkVFRMbAAAAQF4ZaVl8/q75wyLPrlRgJH+/F0lsKXI1AAAAyJesw8MvvPBC3XzzzfK2Mx2Awnnv2tn6+I/v6LUf3LGDVVSe7v/l4brnluEyDKOAFXZcRni4G5PCUGWOp2i5o3Ub4grDsMgVAgAAAF2Yae34MaXOMFLrqKLu5uLWAgAAgLzJOmPjn//8p+bPn6/nnntOBx10kCorKzPu/8Mf/pCz4rBj6/7xjiTJ3VyvcJvGhmEZ6n/43lr92qfae+ww2VZpNjSapVZR1cZkBL4M31WZ7ausIqp4ItDWek89qpwiVwkAAAB0UUYXaGxIikd6qTyxQdHEZikMpRL9YRcAAAA6L+vGRs+ePXX66afnoxZ0RnozY5vGhhmxtf9Zh2mPo/dR9IAhBS4se82NDT/myU94MhONKrM9VVUnV2et35CgsQEAAADkSwcnNnwj64+RBRWL9JYk2UFMStRJ0eoiVwQAAIBcy/od6dy5c/NRBzopY0ojyGxsWI6l14Z8Vwf3/4eeM7+mMwpcW7bsmmqZ0YiCeEKJ2rjMRExljq+KyjJJ0roNcQ0dVLmDswAAAADoFKNjm4rfHzopz4XsnFh0t5YbdWtpbAAAAHRBHW5sBEGgW2+9VX/+85+VSCR0/PHHa8aMGSovL89nfdiB0EsLDG81sWHp34n99bb9RXmJ0s9EMQxD0QF91fjpimTORqJRZbavSFlyYmPd+l0zwBAAAADYJexoYuOQM/VebZne3ed/ClNPJ7VqbOy2T/GKAQAAQF50ODz8hhtu0E9+8hNVVVVpzz331M9//nNdeOGF+awNHRAGaY2N9OuSrKgtv+k/see1HyxeSlI5G1tjTRMbnkzbku1YWreBxgYAAACQNzvK2DjqMi0+YKp8q6ww9XRSLJLW2KhfW7xCAAAAkDcdbmw88MAD+tWvfqVnn31Wf/zjH/WXv/xFDz30kIJtvkxHYYXpDQtv24kNR+++8qG2bKxXz2B9gSvrnOiAlgBxM96gCif5N5VXRrVuQ6KYpQEAAABd244mNjqYwVFsjdE+LTfqaGwAAAB0RR1eRbV8+XKdeOKJqdtjxoyRYRhauXKl9tprr7wUhw4IwtTVcNtVVFFHl0/eSw2Nng7+4h6FrqxTUhMbtTFZ8QaVOckVWuWVUa1nYgMAAADInx1NbFiOpNL/YVurVVQAAADocjrc2PA8T2VlmSPHjuPIdd2cF4VO2mZ6xog62q1XRAfsGy1SQdmLDugrScnw8Hi9opYvKVRFVVTrNtYVtzgAAACgK9vhxIYjqfR/bMQqKgAAgK6vw42NMAx17rnnKhpt+ZI8Fovphz/8oSorK1PH/vCHP+S2QnRcq/BwR1WVHf5PXBKi/ZIfQhJbY7Ji9TIMKWIFKq+MatVHG4pcHQAAANCFGTvYVGztIo2NtFVUn3/2iV56bbnOGrl3ESsCAABArnX4W++JEye2OnbOOefktBjspFYTGxGVRTsco1ISWiY2YjLj9ZKkMsdTRVVUm7e4SriBIs6u9TcBAAAApcwIm34gtaPGhrlr/GgqFumVul4W31jESgAAAJAvHX5nOnfu3HzWgVzYNsg9GpVhGMWppZPSMzZMz5XhJVRm+6qoSq5B27Axod37l23vFAAAAAA6aul8nTb/XOmz43fcuLCcgpS0s0LTUczppTJ3k8oSTH0DAAB0Rfz0vSvZZhWVortOtkaz6IBkY8PdGlcYhjJj9SqzPVX1SDYz1hEgDgAAAOTO/ztNUbdWevf/pPVLtv9Yc9dobEgtAeJl8fVSGBa5GgAAAOQajY0uJPS3ndiIFKeQndA8sRG4vvyYJyveoDLHV7Q8+bfQ2AAAAADyxG3c/v07ChcvIc2NDTuIy/bqi1wNAAAAco3GRleyzSqqMLrrrWyyKspl96iS1LSOKlavMtuXaZmKlDk0NgAAAIB82dEa211ozW0sslvqejnrqAAAALocGhtdyLYTG2Fk12tsSJk5G1a8XpVRT5JUURnVqjWxYpYGAAAAdEuf9zu22CVkpXliQ2paRwUAAIAuhcZGVxJkZmwEZeVFKmTnZASIx+pV4ST/rvKqqFasorEBAAAA5EVbWRTHXS1d+E/9/dBZBS9nZzRG0hsbTGwAAAB0NSXR2Lj77rs1ePBglZWVaeTIkXr99de3+/jHH39cBxxwgMrKynTQQQfpmWeeybj/3HPPlWEYGZdx48bl808oinDbDx5B5u1wV21sNAWIx5smNqJ2cmKjvDKqFat3sPcXAAAAQOf4idbHIhVS3/0VGrtOvoYkxaJ9UtfLWEUFAADQ5RS9sfHYY49p6tSpmjFjht544w0dcsghGjt2rNauXdvm41955RWdeeaZOu+88/Tmm2/qlFNO0SmnnKJ///vfGY8bN26cVq1albo88sgjhfhzCspvTJteMA2FfubERhjdNRsbZXv0lyQlNjfKitXLMX0ZClVRFdXqNTH5fhu/JAMAAACwc9pqbDgVqasPv7a8gMXsnPRVVOWsogIAAOhyit7YuOOOOzR58mRNmjRJw4YN0+zZs1VRUaE5c+a0+fif//znGjdunC6//HJ98Ytf1M9+9jMdeuih+uUvf5nxuGg0qgEDBqQuvXr1KsSfU1BefX3qumEa0jYZGyqv0K6ofNCekqTYxnqZ8QYZhlTueKqsLpPrhQSIAwAAAPngtbH2NVJZ+DpyID08nIkNAACArqeojY1EIqFFixZpzJgxqWOmaWrMmDFauHBhm89ZuHBhxuMlaezYsa0ev2DBAvXr109f+MIXdP7552vDhq73ZjZRW5dxOwy2bWzsmh9Cygc3NTY2NMj0EjI8VxURTz1qkmHoK1lHBQAAAOReGLQ+5uyaU+CN6auoyNgAAADocora2Fi/fr1831f//v0zjvfv31+rV69u8zmrV6/e4ePHjRunBx54QPPnz9fNN9+sF198USeccIL8bVY1NYvH46qtrc247AoSWxtabgShtE1jw6isKnBFuVG+d/PERvLvM+P1qoy4Kq+KShIB4gAAAEChOLvmFHg80kuhDEk0NgAAALoiu9gF5MMZZ5yRun7QQQfp4IMP1j777KMFCxbo+OOPb/X4mTNn6tprry1kiTnx/7d35/FRlWf/x7+zZ98hC7IJCCLIIossFVooPFZR6iNFqsIP6WZFQRQVK6B1QWmt+yPFPrY+rRSta6sVpRFwY98EBWQPW8KeSSbbZOb8/ggMmZBAgGROZubzfr3ycs49J+dc50wwc+Wa+7rLC0+1ojL8howarahsieFZ2Ig7MWPDW1wuX3mlbGUexTkqZXM4ZLGIBcQBAACAUAnTVlSG1a5yZ6piKo7SigoAACACmTpjIyMjQzabTQUFBUHjBQUFysrKqvV7srKyzml/Sbr44ouVkZGhbdu21fr8tGnTVFhYGPjas2fPOV6JOcqLarSiqgyekeJMSgplOA3GkZIke3KipKpZG9Yyj+KdlbJYLIqJczFjAwAAAAiVMG1FJUllzjRJJ2ZsGIbJ0QAAAKAhmVrYcDqduuKKK5SbmxsY8/v9ys3NVb9+/Wr9nn79+gXtL0kLFy6sc39J2rt3r44cOaLs7Oxan3e5XEpKSgr6CgfeouCZC0ZFZdB2bFpyKMNpUHHVFhC3lXuUGOOVJMUmuLS/gBkbAAAAwAXz196qN4gjPGdsSFKZq2oBcbu/XCoPj3bDAAAAqB9TCxuSNGXKFL3yyit67bXXtGnTJt1+++3yeDwaP368JGns2LGaNm1aYP9JkyZpwYIFevrpp7V582Y9/PDDWrVqlSZOnChJKi4u1tSpU7Vs2TLt2rVLubm5uv7669W+fXsNHz7clGtsLBUeT9C23xtc2IhvlhLCaBpW0ALiJ1pRSVJcPDM2AAAAgAZRWX72fZzhucaGFLyAuIoPmRcIAAAAGpzpa2yMHj1ahw4d0owZM5Sfn6/u3btrwYIFgQXC8/LyZLWeqr/0799f8+bN00MPPaQHH3xQHTp00HvvvacuXbpIkmw2m77++mu99tprOn78uHJycjRs2DA9+uijcrlcplxjY6ksLgnartmKKjkzJYTRNKzYGjM2HDafbBa/4hJc2rujUu4ir5ISHSZHCQAAAIQxXz0KG2G6eLgklTnTT214DkoZ7c0LBgAAAA3K9MKGJE2cODEw46KmxYsXnzY2atQojRo1qtb9Y2Nj9fHHHzdkeE2WrzR45oLfe6qwkXppphITnaEOqcHEtjpZ2CiRrayqgBPnrFR6s6qp8PsOlFLYAAAAAC5EZcXZ9wnnwobrVGHj87Xf6Hut+5sYDQAAABqS6a2ocP58JcFrTZwsbMQ8Nl3rHvlQdpvFjLAaRFygFZVHtvJiyTAU56hUStqJwkY+7agAAACAC1JZj/fU9vD9sFRZtVZUseWHNW95nonRAAAAoCFR2AhjRlmNGRuVfkmSPSFBo4cmmBFSgznViqpElkqvLN5yxTm9csVXtRPbd4AFxAEAAIAL4qvHjI0w5onJCjyOK8s3MRIAAAA0NAobYcwoq9ET129Iklwuq9ITw3e2hnRqxoa3qFy+ikrZS92Kd1bKanfIZrcyYwMAAAC4UPVZPDyMlVQrbMRT2AAAAIgoFDbCWM0ZGydZ7E1i6ZQLYk9Jkj2patZJ2dES2UrcSnR5JUnxSbHan8+MDQAAAOCC1Gfx8DBWEpMZeBxXSmEDAAAgklDYCGNGRe1Tx62O8C9sWCyWoHZUthK3ElyVkqSEpFjtZ8YGAAAAcGEifMaG3+ZSqTNNkhRXdsDkaAAAANCQKGyEMcNbe2HDEgGFDUmKbZ0j6cQC4qVFinF4JRlKSIrVwcPlKi/3mRsgAAAAEM4ivLAhnWpHFVt2SBZ/pcnRAAAAoKFQ2AhjFq+31nGr3RniSBpHXOuLJJ2YsVHqls1iyGHzKzUjTpK0e2+JmeEBAAAA4S3CFw+XpJLYqsKGVX7Flh82ORoAAAA0FAobYcyoqL2wYXFGyoyNE62ojnhkLymSJMU5KpWWES9J2r7bY1psAAAAQNiLohkbkhTHAuIAAAARg8JGOKtzxkaEFDbanFpjw+otk8VbrninV7HxMZKkHbsobAAAAADn7SyFDb8l/PMKT0x24HF8KetsAAAARAoKG+GsrsKGM1JaUZ0qbEiSrbRI8c5KyWaXzW5lxgYAAABwIXxnK2zYQhRI4znZikpixgYAAEAkobARxow6ChsOpyPEkTSOuPatJUled5m8JRWylbiVElfVBzghKVY7KWwAAAAA5+8sMzaMCJixQSsqAACAyBT+71Sjmbey1mGrIzIKG46kBMVclKWyvfkqyS+SrbRIKWknChvJsdq30yN3sVdJCZFxvQAAAEBIna0VldWuecvzQhRM4wgqbNCKCgAAIGIwYyOMGZV1FDZiIucP/Qmd2kmSSvLdspe4FevwyiJDWTmJklhnAwAAADhvUdCKqtSVEbiOeGZsAAAARAwKG2GszlZUMZGxxoYkJVxaVdjw5LtlK3XLajEU7/SqWWaCJLHOBgAAAHC+KivO+PT6jpNDE0cjMqx2lbqaSZLiygrCfgYKAAAAqlDYCGd1tqKKnA5jp2ZsFMleWiRJSoqpUEJSrCRmbAAAAADn7UwzNq57UTtbXBe6WBrRyXZUMRVHZfOVmRwNAAAAGgKFjTBmVPpqHXfERs6MjcTO7SVVzdiwlpdIPq+SYipkdVRd4w5mbAAAAADnp441NvZnDJB63iojAlpRSVJJbPUFxAtMjAQAAAANhcJGGKtrjQ2HM3IKGydbUZUfLZGvvFL20iIluSpUaVhld9i0Y7dHhmGYHCUAAAAQhuoobBiWyJkBLkmemOzA4zjW2QAAAIgIFDbCmOGtmrFhsZ96GS1Wi+yOyHlZnempcjZLkySVFBTJVuJWSmxVL+D05onylPhUcOjMix4CAAAAqEUdraj8lsjJJySpJCYz8DiulMIGAABAJIisd6xRxjixxobNeeoTVRabRQ57ZEwZPynh0lPtqGwlhYp1VMpm8avNxamSpO2sswEAAIAzeOmll9SmTRvFxMSob9++WrFiRZ37vvLKK/re976n1NRUpaamaujQoWfcP6zVsXh4pLSgOim4FRWFDQAAgEhAYSOM+X1+SZLVWS3xsFjkiKAZG9KpdlQl+W45io/JYpESXV41z06SxDobAAAAqNsbb7yhKVOmaObMmVqzZo26deum4cOH6+DBg7Xuv3jxYo0ZM0aLFi3S0qVL1bJlSw0bNkz79u0LceQhUFn7QtpGhM3Y8MScKmzElx0wMRIAAAA0lMh6xxplTraisrocgTGLzSqr1WJWSI0ioVNVYcOTXyRH0RFJUlJMhWIS4yQxYwMAAAB1+8Mf/qCf//znGj9+vDp37qw5c+YoLi5Or776aq37v/766/r1r3+t7t27q1OnTvrTn/4kv9+v3NzcEEceAr4ombFRfY0NWlEBAABEBAobYcxfWVXYsFUvbFgtskbYq5rYuaoVVUm+WzZPoSyVFUqKqZDPYpfdYdPmbUUmRwgAAICmqKKiQqtXr9bQoUMDY1arVUOHDtXSpUvrdYySkhJ5vV6lpaXVuU95ebncbnfQV1iIksJGuTNVlVaXJCmurMDkaAAAANAQIuxP4NHFOFHYsLicgTGL1SKLJdJmbFwsSSo95JHf65O96IhS4yokWZScnqC9+0t17HjtSRkAAACi1+HDh+Xz+ZSZmRk0npmZqfz8+n1y//7771dOTk5QcaSmWbNmKTk5OfDVsmXLC4o7ZOosbERYmmixqOREO6r40n2SYZgcEAAAAC5UhL1jjS7+yhNrbMRUn7EReS+pK7u57MmJkmGo5GCxHO4jSnJVJWHt2ld9cm7DpjD5VBwAAADCxpNPPqn58+fr3XffVUxMTJ37TZs2TYWFhYGvPXv2hDDKCxAli4dLUnF8VbHJ4SuVimhHBQAAEO4i76/gUcLw+SR/1SeNLC5XYNxii7yX1GKxKOHSE+2oCtyyFx2Rw+aT0+ZTTstkSdKGTYVmhggAAIAmKCMjQzabTQUFwe2HCgoKlJWVVcd3Vfn973+vJ598Up988okuv/zyM+7rcrmUlJQU9BUWomXGhiR3fJtTG0e2at7yPNNiAQAAwIWLvHesUaKytPTURrVWVIqwhcNPOrnORvHeQjlPLCCeFlemmISqBcSZsQEAAICanE6nrrjiiqCFv08uBN6vX786v2/27Nl69NFHtWDBAvXq1SsUoZrD56112G+xhziQxueObxt4vGLVChMjAQAAQEOgsBGmvMUlgcdBMzYisBWVJKX06ipJcu8+KqvnuOTzKjWuXBWGTXaHTVu2Fam8wm9ukAAAAGhypkyZoldeeUWvvfaaNm3apNtvv10ej0fjx4+XJI0dO1bTpk0L7P/UU09p+vTpevXVV9WmTRvl5+crPz9fxcXFZl1C4/GV1zociTM2iuJbBx4neXaZFwgAAAAaROR9FCdKlBZ6Tm0EtaKKzBkbKX27SZKKdh+T/IYcRUfVLD5Rm2TRRa2TtWvbUW3eWqRulyWbHCkAAACaktGjR+vQoUOaMWOG8vPz1b17dy1YsCCwoHheXp6s1T4c9PLLL6uiokI33nhj0HFmzpyphx9+OJShN766WlEp8tbYqN6KKpHCBgAAQNijsNGADL9fBz9cpJQre8jVLK1Rz3WysGGxWyX7qZcxUmdsJF7WQbb4OPk8JfLku2V3H1FKyyxZZOiSjhnate2oNmwqpLABAACA00ycOFETJ06s9bnFixcHbe/atavxA2oq6mhFFYkzNkpdzeW1xcrhK1WSZ7fZ4QAAAOACRd47VhPt/MNcrbrh11o64L8b/VwVxVVrbFjtVsl26hNVlghdY8Nisyml94l2VLuOylF8RFaLoaSYCjXLSpTEOhsAAADAOamsqxVV5M3YkMWiohOzNuJL98nqr72oAwAAgPBAYaMB5f3xdUmSZ+f+Rj9XeVHVjA2r3SbZqk28sUXuS5rSt7skyb3ziJzFRyVVLSBuOGIlSRs3FcowDLPCAwAAAMJLnTM2IrCwoVPtqKyGTwkle8wNBgAAABckcv8KbgJvYegWFPSWlEmSLDUKG5HaikqSUk+ss+HedVTWoqOSr1JpceUqq7QqNT1OhUWVyttbanKUAAAAQJioa42NCGxFJSkwY0NinQ0AAIBwF5nvWE3iLSoL2bn8pScLG1bJfupljOTCRkqfqsJGSb5bvpIKOY8XqFlC1X3o0j1LkrRhU6Fp8QEAAABhxRdFragUvIB4EoUNAACAsBa5fwU3gVHpD9m5fCUn1thwBM/YcDZLClkMoebKzFBsmxaSIRXlHZXz6D7F2CvltPmUdVHVYu0r1x0zOUoAAAAgDPh9klF7/uKP2MJG68BjChsAAADhjcJGmPKVVX26ymK3By0entghy6yQQiI1sM7GUbmOHpBUtc6GnLGyWC1avuaovN7QFZgAAACAsFRHGyopcmdsBLei2m1eIAAAALhgFDbClL/s1Bob1mrtp+I65JgVUkicbEfl3nVU9qIjslSUqnlCuXyGRa0vTlWxx6f139KOCgAAADijytrbUEmRu8ZGpT1eJa7mkpixAQAAEO4i8x1rFDDKT8zYcNjkLTjVfukrR2+zQgqJlJMzNnYfk2EYch49oKzkqrZcl3fPliR9ueKIWeEBAAAA4cHnrfOpSJ2xIUlFJ9pRxVQclUppYwsAABCuKGyEibIDB+V1Fwe2jYpTrahc3XsFxl9enBjy2EIpqfulssa45C0qk2d/oVxH9ynWXi6nzaekjGRJ0hfLj8gwDJMjBQAAAJqwOhYOlyK7sFF9AfGPP/vSvEAAAABwQexn3wVmKc3br42Tfqvir79VSV6BnOkp6nT7cB3bUaiKwx5JksVhV497x2hRsV9/2dZcP73+IpOjblw2l1MZQ/vr4AeLdPjr/WrV7oAshqHsJI92H0tUfIJDBwrKtDOvRBe3jjc7XAAAAKBpOuMaG5H7+bfqhQ3aUQEAAIQvChtNVKWnRBsn/VYHP1gUGKs4clxfP/ZG0H4Wu03OhDgN//3P9QOvXw5H5CYhJ2VdN7SqsLHhgNpcXSxbiVutU+O0+1iS+lzZQov+s0tfrjhCYQMAAACoyxlaUfll07zleSEMJnSqLyCeVLzDvEAAAABwQSL/r+BhqODDRfqkeZ+gokadHI5qD6Pj5Wx+zfcli0XFecdUdqxEzqP7lBpbKrvVr4vaNpPEOhsAAADAGUXh4uGSdDzxksDjVPfmiC3gAAAARLrIfccapiqLirVq5K9kVJz6BJXNZZfNZVfP+4covUt20P6GKybUIZrO1Txdqf16SJKOfL1fMUf3y2KRMhNKVKoYOWMc+maLW8eO1z29HgAAAIhqUbp4eElMpkqdaZKktMJvJNbmAwAACEsUNpqY46s3njbW64Ghav/aI8ofM00x/ztXrX5xtSTJ4nKqbNgNoQ6xSci8bogk6fCG/XIc3itLRanaZnjkNyzqdWVLGYb06ZeHTI4SAAAAaKLOuMZG5BY2ZLHoaPJlkqQY73HFl+43OSAAAACcDwobTYhhGDr66RdBY1m3Dpd3wFAdaDNAi7a10AebWuqPF92jghkvqPzv/5RvSJQWNkZUFTaObz0sX0m5Yg9sU3pciawWQxe1z5QkvfPBfvn9fAILAAAAOI0vOltRSdLRpM6Bx2mF35gYCQAAAM4Xi4c3ERVHjmn5jybIvabqjXWr4Z2UcGlrFd86UX/f2V5bv9ynwwe+1YG8Ixp5dY7cjnZq0yJHvS+N4E9TnUHCJW2VcGk7FW/ariPf5Cs9Y6tKWnVRZmKpDrjjlH1RsnbvLdTKdcfUt2ea2eECAAAATUuUtqKSFJixIUlp7m9NjAQAAADnK7I/ihNG8l55I1DUkKS49jly3nC9Nh/L0pZ1e1R6sEAxKtVNIy/Svb/uoMk/b6cf9HQpMdZiYtTmOjlr4/DX+2X3HJfDfUids9ySpP6D2kqS3vrXPtPiAwAAAJqsM7aiiuw0MaiwwYwNAACAsBTZ71jDyNEvVwUe2+JdOvbfd+jNQ9/X2k1+7dh0QCOvztFfX+qtiRPamRhl05I96keSpMPr9qnsqEcx+79TorNECc4K2eITZXdYtXTVUeXtKzE5UgAAAKCeju2SKjyNf57KultR+S2RPbG/NKa5SlzNJEnpLCAOAAAQlihsNBBfZeV5fZ/h96tw5TodXbJMktTz3u+ry9uPK89oqaWffKuVn25Uh9YuDb2qeUOGGxGSu1+q9O9fKcPv195FWxVbsFPyedU5q1CVfosGD7lYkvT2B8zaAAAAQBj49n3puW7Si72lyrpnVDSIM7aiivw08diJdTaclUXSsZ2atzzP5IgAAABwLiL/HWuI+CrOL/HY8fSf9EX/0fKVemWLdSihZaqONuusvOPxOnSgUG/8sY/+56keSoiP7E9Nna929/5MknTgq12qdHsUk79T2UlFctkrld4qSza7Vf/OLVCx5/wKTwAAAEDIvDm26r/ufdK2/zTuuc7Yiiqy19iQpCPV2lFp/zrT4gAAAMD5obDRQCrKzv0P536vVzv+8Gpgu+01nXWow1X6aGOm1n61Sz0uS1RaqrMhw4w4GT8cqMSuHeUrr9T+z7crcdd6WXyV6pzlltdvVe+BbVVa6tNf5u82O1QAAACg/myNnAf46m5FFQ0zNqqvs/Ht6s9MjAQAAADnI/LfsYZIZWnwJ57q05rq4IeLVXH4mCSp0/grZXtopt45Pliffbhev/5JmqZP6dQosUYSi8USmLWxb8kOGe7jitvzrVqluGW3+nVRhxy5Yh168597tWVbkcnRAgAAAPXkSmzc45+xFVXkz9g4mtw58JgFxAEAAMIPhY0G4q1R2KgsP3NrqkpPibY+8owkqdUPOyrp+qHaeLSFNq0/oM6XJKlvzzSlpjBboz6yR12t2FY5qnCX6sCXOxW/62tZKzzq2fKY/IZFQ3/UUX6/NPul71TpY2FAAAAAhINGft9arRVVzcXCo6GwUebKkCcmU5KU5v5WMvwmRwQAAIBzQWGjgXjLymts1/0JKEn69q6H5d64XVanTenXD9SimGv17oeHtH/7AY0f07oxQ404VodD7ab+XJK084NvVF5wTAk71ionsVBpcWWKSUtVZnaitmwr1tv/YiFxAAAANEFGjUKG39e456u2OHmlLSY4lChJE48GFhAvVqJnNwuIAwAAhJHoeMcaApVlNVpRldY9Y+PoF6u052//lCRdetcwfdftp3rznb0ae02yPvr7AHW+JKlRY41ErX5xk9IG9pKvzKstr69SzJ7NshcdUd/WB2W1GBp8bVfZHTb96fWd2rO/xOxwAQAAgGCVZcHb/nNfw++cVJuxUXOGRrkzpXHP3UQcSbk88DjzyAoTIwEAAMC5orDRQCq9wYlHRS0zNvx+v7bM/IOWDRsn+Q1l9mmtkhsn6IvNcbrp6jT9YGCzUIUbcSxWqy7/0yzZ4mJ1/LtD2v/ZNqV8/alifMXq0eKovIZdQ0Z0UWmZX1NmbNDhI3UvlggAAACEXM01L4xGnrFRrbDhic05Nd7meypM7NC4524iDmQMCDzOOfyFiZEAAADgXFHYaCCV5TVaUVUEJyaGz6dvxt2hbU/8UYa3Ummds5R9z83661fp+q8eVt14bQtZLJZQhhxx4tu1UqdZUyVJO97fqNLte5Wy4VNdlHhcrVOLFJ+WrD6D2ulAQZmmzNwgd/GZ24UBAAAAIVOzkOFv5DUfqhU2Nre5VfubDdS3bcdrfsfnGve8TcixpI4qdaZLkjKPLJfVd+Z1EgEAANB0UNhoIP7y4D+S+6q1pirLP6Qv+/1YefM/lSRdPLKrWvz+Hr1bNkR92km9uqWEMtSI1vpXY5T+/Svlr6jU+uc/U8XGzUr8bpm6tzik1qluXdShhS7v3Uo7dnt03yMbVVLayJ+EAwAAAOqjZiEjhK2oChMu1uJeL2tdpynyWx2Ne96mxGLVgWZVszYcvlI1O77W5IAAAABQXxQ2Goi/IjjxqKzwqvjrtSpas0Ibxk9W4dotkkXq8Ivva/W45/XEZx3VuZVLP/5RTh1HxPmwWK3qOf85JfW4TN7icq17/jP5li1T0qYv1CO7QG3TCtW+Wxv1HnSJvtni1s/uXq3vtheZHTYAAACiXc1CRghbUfmtzsY9VxN2IGNg4HH2oS9NjAQAAADnwm52AJGisiJ42rJn5RptmTZLvvITCYpFajfzVv0zY5S6Jdk159GOJkQZHZxpKbry4z9r+Y8mqHDVBq1/fokuualYqe4j6tFtqFJiM+WwNVNCUoy+WrhJv7x3rX417mKNuq6FrFbagQEAAMAEp7WiauDCxuFt0vHd0vE8qey4lLf81KmiaZZGDQcy+smQRRYZyq62zsa85Xn6ad9WJkYGAACAM6Gw0UD83uBWVEf/Mu9UUUNS5uBL9VHL23T7jc0VH8dtb2yO1GT1XfBnrbj25zq+bK2+fXWZ0lfsVvtbDqpTr4HKanep1sc3V3JGb21et1f/89pOLVxyUGN/0koD+6ZT4AAAAEBoNdaMDcOQVsyVFjwgGbWv2+G3RG9ho8KZoiPJXZVR+LVSi7ZK7v2at6mR24ABAADggjWJVlQvvfSS2rRpo5iYGPXt21crVqw44/7/+Mc/1KlTJ8XExKhr167697//HfS8YRiaMWOGsrOzFRsbq6FDh2rr1q2NeQmntaIq/mZn4HFMRrzKxv5SP/1ROkWNEHIkJ+rK//yfOjx0hywOu45sPKBVM/+l/N/+j1LemaNB1iX6YbvduuaHqRrx014yElL1+IvbNe7OVfrgkwM6Xsji4gAAAAiRmjM0GmLGxqHvdOi5wdJH99VZ1JAkn8114ecKYyfX2ZAkbcs1LxAAAADUm+mFjTfeeENTpkzRzJkztWbNGnXr1k3Dhw/XwYMHa93/q6++0pgxYzRhwgStXbtWI0eO1MiRI7Vx48bAPrNnz9bzzz+vOXPmaPny5YqPj9fw4cNVVlbWaNdRc8aG4atKHNo9dpvSfv8b+Tr0VWZGdCcMZrC5nLpk5l363sr3lHJld/nKK7X/s+1a8/A/te0XT8jx6APq+eUzGp2eq19eXa5f/fISXd7/Yr37WYluu+8b3TFtvea9s0frvylUSQmf3AIAAEAjaejCRoVH+utINTu+LjBUGN9WX7f/tdRrguSIrxrseI3KXBkXdq4wtz+jemHjP+YFAgAAgHqzGIZhmBlA37591bt3b7344ouSJL/fr5YtW+rOO+/UAw88cNr+o0ePlsfj0QcffBAYu/LKK9W9e3fNmTNHhmEoJydH99xzj+69915JUmFhoTIzM/WXv/xFN91001ljcrvdSk5OVmFhoZKSkup1HSvnvq2DdzwYNJbRr728T/+fBvZOr9cx0LgMv19HFi3T7jnzVPCv3EDxSZJsLrviWyQrNitZrtbZsrfMUWVGtkrTWuhIXAsdqohTQZFN7jK7Yp02JcTZ1CzVoZzmDqWlOBQfZ1digl3xcXbFxlhlsdDKCgAARJ/zeR8dic7rPhzaIr3U59T2yJel7j89vwD8Pulfd0lr/1a1nXaxdPXvNO/oJZJUtXaEt0xvL9ui//5eN81bnnd+54kQFsOnG3KvksvrllzJmj8oV36bizU2AAAAQuxc3keb2hepoqJCq1ev1rRp0wJjVqtVQ4cO1dKlS2v9nqVLl2rKlClBY8OHD9d7770nSdq5c6fy8/M1dOjQwPPJycnq27evli5dWq/CxknLxk5SvMNZr32Nw4clSc6kGNlv/5ksJR65h4/SDylqNBkWq1UZQ/orY0h/le0v0IG3F+jIf77QkS9WqdJdIveOI3LvOCJ9teO07023SM1ddtmcdtlcdlldDlljnLLGOOW22+S2WnXAapVOftlsJ/5rlSxV/7WcfM4i6UQ50bBYVDVQPVBLLY8tQf+pdd9aL7rmsas/tMio47lIVf0SjWi4YAAAQszjrTA7hPBVc42Nmtvn4pOHAkUNn8Uu281vSentpGoFjHlrDkrO1PM/RwQxLDbtaz5YF+/7p1ReqFb5C7WrxbVmhwUAAIAzMLWwcfjwYfl8PmVmZgaNZ2ZmavPmzbV+T35+fq375+fnB54/OVbXPjWVl5ervLw8sO12uyVJhR98Lq/Fdg5XJDnSkzT4sTvP6XsQejE5mWp75zi1vXOcDL9fRd9sVdE336l4/UYVbdis0r35qjh8XBVHi+T3+iRD8pVVyldGOyoAAIC6lDTUgtfRqKFaUW3LlZb9T9UhLDat6DJT/dLbXWBwkW/7RTdUFTYktdvzFoUNAACAJo6VrCXNmjVLjzzyyGnjyUN713vGhiTJapHrupENFxhCwmK1KqlrRyV17SjdNCLoOcMw5Cv2qLK4RJXuInmPHVfl8eOqPF4or7tQFceKVFleIb/XK7/XJ5/XK5+3Ur6KSvkrK2VU+mT4DMnvk+Hzy/D7ZTGMUzMlTnaCM4xTkyv81edRGNJpzeKM4KGaz9foLmcJ2sUI+k9d3xPsfGc2mNrlDgAAmMDhrZA+3m52GOGp5gyN8ykSGYa05KnA5qrOD2rnRSPVr8Zu1VtPRXsbqpMOpfZUYXxbJXt2KvPYaiUW75REKyoAAICmytTCRkZGhmw2mwoKCoLGCwoKlJWVVev3ZGVlnXH/k/8tKChQdnZ20D7du3ev9ZjTpk0Lam/ldrvVsmVLXfnmH6O6NzAki8Uie2KC7IkJUnZzs8MBAABo0txut5Q83+wwwpPhD94+nxkbq/5X2rO86nGzS7Wt5Y0XHle0sFi0veV/q+fm30uS2u19R/OWt2WdDQAAgCbKaubJnU6nrrjiCuXm5gbG/H6/cnNz1a9fzc8VVenXr1/Q/pK0cOHCwP5t27ZVVlZW0D5ut1vLly+v85gul0tJSUlBXwAAAAAQMqetsXGOhY2N70gf3nNq+4ePVK31hnrb2eI6+SwOSdLFe9+X1ceaMQAAAE2V6a2opkyZonHjxqlXr17q06ePnn32WXk8Ho0fP16SNHbsWLVo0UKzZs2SJE2aNEmDBg3S008/rWuuuUbz58/XqlWrNHfuXElVn7CfPHmyHnvsMXXo0EFt27bV9OnTlZOTo5EjR5p1mQAAAABQt5qFjHNpReUtq1ow/KS+t0uXDA8sFk67qfopd6ZqT9ZQtTnwkWK8x3TRwU81b3lVa2JmbgAAADQtphc2Ro8erUOHDmnGjBnKz89X9+7dtWDBgsDi33l5ebJaT33SqH///po3b54eeughPfjgg+rQoYPee+89denSJbDPfffdJ4/Ho1/84hc6fvy4Bg4cqAULFigmJibk1wcAAAAAZ1WzkHEuMzYWPyG590mS9mcM0OLU2/XTBgwtmmxv+d9qc+AjSdIlu/+uvKzhOrUYHgAAAJoKi2GccdXgqOR2u5WcnKzCwkLaUgEAAAD1xPvoKud1H7Z/Kv31x6e2fzBduures3/f2r9J798hSfJZ7Fow4B8qTGx/HlFDkmT4de3n1yvJs0uS9FmPZ7U3awgzNgAAAELgXN5H03QVAAAAAMzmr7F4eM3FxGvjPiB99EBgc33HyRQ1LpTFqnWXTA5s9tj8e9baAAAAaIIobAAAAACA2c518XDDkD5+UKookiRtbzFSm9uMbaTgosvezB8oP62PJCmxdK867v5b4DnWKwEAAGgaKGwAAAAAgNlOW2Ojsvb9Tlr6ovTNO5KkMkeK1na6h7UgGorFojWX3if/iXS5y7a5UvFBk4MCAABAdRQ2AAAAAMBsNQsZNQsd1e38TPr0scDm6s7TVOFMaZy4otTxpI7a3vIGSZLD55E+uk/zlu02OSoAAACcRGEDAAAAAMxWs/VUba2ofF7pg7ul10ZIlWWSpC2tf6rdOT8KQYDR5+sOE1VhT6za+OZdddk2x9yAAAAAEEBhAwAAAADMdrbCRslR6fVR0qpXT43l9NDXHSY2fmxRqtyVrmVdH5WhqhZfl2/7H7XZ94HJUQEAAECisAEAAAAA5qvZeqr69tGd0txB0o5FkiSfxaE1ne6Vxi+Q15EYwiCjz96sIVrbcUpgu++GGfrPv99iEXEAAACT2c0OAAAAAACiXs01Nvw+adWfpaM7pF1fSMer/pBe5kjR5z2f06G0ntq8hgWtQ2Fz23FKLNmtDnveks3w6gcrf1lVWOrzAAu2AwAAmITCBgAAAACYrWbrqbxl0spXgoY8MVlaeOVfVRKbFcLAIItFqzo/qLiyArU49LmsRqV6bXpSenubNOI5yZVgdoQAAABRh1ZUAAAAAGC2mjM2CjactsuG9r+mqGESw+rQZz2f17dtx58a3PiW9GIvafkfNf+rrZJEiyoAAIAQobABAAAAIKK99NJLatOmjWJiYtS3b1+tWLHijPv/4x//UKdOnRQTE6OuXbvq3//+d+MHafjP+PThlMu1s8WIxo8DdTKsdq3rNEWf9XhGXlt81WDRAemj+3Tdkh9p3bwZSvDsobgBAAAQAhQ2AAAAAESsN954Q1OmTNHMmTO1Zs0adevWTcOHD9fBg7WvT/HVV19pzJgxmjBhgtauXauRI0dq5MiR2rhxY+MGWrMVVXXXPqPcPn+SYaWTcFOwN2uoFgx4Q3syhwTG4soPqvt3z+m6z36kq7+4URv+ep/03cdSUQGFDgAAgEZgMQzDMDuIpsbtdis5OVmFhYVKSkoyOxwAAAAgLDTF99F9+/ZV79699eKLL0qS/H6/WrZsqTvvvFMPPPDAafuPHj1aHo9HH3zwQWDsyiuvVPfu3TVnzpx6nfO87sNXL0qf/Oa04eVdZmp7yxvrdwyEXIp7s7pum6OWBbl17lPiai53fBtltbpESmklJbeQ4tKrvmLTJFei5IiR7LGSzcGC5AAAIGqdy/toPvIDAAAAICJVVFRo9erVmjZtWmDMarVq6NChWrp0aa3fs3TpUk2ZMiVobPjw4XrvvffOPYB3fiHFOeu37+FtQZsFab21r9lV2n7RDed+XoTM8aRO+rzns0rw5Kll/kK1LMhVRmHw+ihx5QcVV35QOnrmFmiSJItNcsRK9hjJEVdV8LDaJYv11JfVpkOeSjVLjJWstqDxwGPVKI7UWiw5j33q3O9s+5zncQAAQHQpqaj3rhQ2anFyEovb7TY5EgAAACB8nHz/3FQmhR8+fFg+n0+ZmZlB45mZmdq8eXOt35Ofn1/r/vn5+XWep7y8XOXl5YHtwsJCSZL76w8l17n/8fbz7r/XgWYDqjZKPOf8/Qi9EqXqYNZPtDrrJ4orLVDG8a+VWrRZqe7NSnF/J6evuJ5HqpTKiiQVnXEvlyR3wYVGDQAA0LS4y6vyiPrkExQ2anHkyBFJUsuWLU2OBAAAAAg/RUVFSk5ONjuMkJk1a5YeeeSR08ZbPlPfP2bX9MsLCwgAAAAIY/XJJyhs1CItLU2SlJeXF1UJWVPhdrvVsmVL7dmzp8n0Zo42vAbm4v6bi/tvLu6/+XgNzBXu998wDBUVFSknJ8fsUCRJGRkZstlsKigI/mh7QUGBsrKyav2erKysc9pfkqZNmxbUvur48eNq3bo1+YRJwv3fUSTgNTAX999c3H9zcf/Nx2tgrnC//+eST1DYqIXVapUkJScnh+UPQKRISkri/puM18Bc3H9zcf/Nxf03H6+BucL5/jelP+Q7nU5dccUVys3N1ciRIyVVLR6em5uriRMn1vo9/fr1U25uriZPnhwYW7hwofr161fneVwul1wu12nj5BPmCud/R5GC18Bc3H9zcf/Nxf03H6+BucL5/tc3n6CwAQAAACBiTZkyRePGjVOvXr3Up08fPfvss/J4PBo/frwkaezYsWrRooVmzZolSZo0aZIGDRqkp59+Wtdcc43mz5+vVatWae7cuWZeBgAAAIBqKGwAAAAAiFijR4/WoUOHNGPGDOXn56t79+5asGBBYIHwvLy8wIxtSerfv7/mzZunhx56SA8++KA6dOig9957T126dDHrEgAAAADUQGGjFi6XSzNnzqx1OjkaH/fffLwG5uL+m4v7by7uv/l4DczF/W8cEydOrLP11OLFi08bGzVqlEaNGnXe5+N1NBf333y8Bubi/puL+28u7r/5eA3MFU3332IYhmF2EAAAAAAAAAAAAPVhPfsuAAAAAAAAAAAATQOFDQAAAAAAAAAAEDYobAAAAAAAAAAAgLBBYaMWL730ktq0aaOYmBj17dtXK1asMDukqDBr1iz17t1biYmJat68uUaOHKktW7aYHVbUevLJJ2WxWDR58mSzQ4ka+/bt0y233KL09HTFxsaqa9euWrVqldlhRQ2fz6fp06erbdu2io2NVbt27fToo4+Kpagax2effaYRI0YoJydHFotF7733XtDzhmFoxowZys7OVmxsrIYOHaqtW7eaE2wEOtP993q9uv/++9W1a1fFx8crJydHY8eO1f79+80LOAKd7d9Adb/61a9ksVj07LPPhiw+XBjyCXOQTzQt5BOhRz5hLvKJ0CKfMBf5hPnIJyhsnOaNN97QlClTNHPmTK1Zs0bdunXT8OHDdfDgQbNDi3hLlizRHXfcoWXLlmnhwoXyer0aNmyYPB6P2aFFnZUrV+qPf/yjLr/8crNDiRrHjh3TgAED5HA49NFHH+nbb7/V008/rdTUVLNDixpPPfWUXn75Zb344ovatGmTnnrqKc2ePVsvvPCC2aFFJI/Ho27duumll16q9fnZs2fr+eef15w5c7R8+XLFx8dr+PDhKisrC3GkkelM97+kpERr1qzR9OnTtWbNGr3zzjvasmWLrrvuOhMijVxn+zdw0rvvvqtly5YpJycnRJHhQpFPmId8oukgnwg98gnzkU+EFvmEucgnzEc+IclAkD59+hh33HFHYNvn8xk5OTnGrFmzTIwqOh08eNCQZCxZssTsUKJKUVGR0aFDB2PhwoXGoEGDjEmTJpkdUlS4//77jYEDB5odRlS75pprjNtuuy1o7IYbbjBuvvlmkyKKHpKMd999N7Dt9/uNrKws43e/+11g7Pjx44bL5TL+/ve/mxBhZKt5/2uzYsUKQ5Kxe/fu0AQVZep6Dfbu3Wu0aNHC2Lhxo9G6dWvjmWeeCXlsOHfkE00H+YQ5yCfMQT5hPvIJ85BPmIt8wnzRmk8wY6OaiooKrV69WkOHDg2MWa1WDR06VEuXLjUxsuhUWFgoSUpLSzM5kuhyxx136Jprrgn6d4DG989//lO9evXSqFGj1Lx5c/Xo0UOvvPKK2WFFlf79+ys3N1ffffedJGn9+vX64osvdPXVV5scWfTZuXOn8vPzg/4/lJycrL59+/L72CSFhYWyWCxKSUkxO5So4ff7deutt2rq1Km67LLLzA4H9UQ+0bSQT5iDfMIc5BPmI59oOsgnmh7yidCLhnzCbnYATcnhw4fl8/mUmZkZNJ6ZmanNmzebFFV08vv9mjx5sgYMGKAuXbqYHU7UmD9/vtasWaOVK1eaHUrU2bFjh15++WVNmTJFDz74oFauXKm77rpLTqdT48aNMzu8qPDAAw/I7XarU6dOstls8vl8evzxx3XzzTebHVrUyc/Pl6Rafx+ffA6hU1ZWpvvvv19jxoxRUlKS2eFEjaeeekp2u1133XWX2aHgHJBPNB3kE+YgnzAP+YT5yCeaDvKJpoV8whzRkE9Q2ECTdMcdd2jjxo364osvzA4lauzZs0eTJk3SwoULFRMTY3Y4Ucfv96tXr1564oknJEk9evTQxo0bNWfOHBKREHnzzTf1+uuva968ebrsssu0bt06TZ48WTk5ObwGiFper1c/+clPZBiGXn75ZbPDiRqrV6/Wc889pzVr1shisZgdDhCWyCdCj3zCXOQT5iOfAE5HPmGOaMknaEVVTUZGhmw2mwoKCoLGCwoKlJWVZVJU0WfixIn64IMPtGjRIl100UVmhxM1Vq9erYMHD6pnz56y2+2y2+1asmSJnn/+edntdvl8PrNDjGjZ2dnq3Llz0Nill16qvLw8kyKKPlOnTtUDDzygm266SV27dtWtt96qu+++W7NmzTI7tKhz8ncuv4/NdTIJ2b17txYuXMinq0Lo888/18GDB9WqVavA7+Tdu3frnnvuUZs2bcwOD2dAPtE0kE+Yg3zCXOQT5iOfaDrIJ5oG8gnzREs+QWGjGqfTqSuuuEK5ubmBMb/fr9zcXPXr18/EyKKDYRiaOHGi3n33XX366adq27at2SFFlSFDhmjDhg1at25d4KtXr166+eabtW7dOtlsNrNDjGgDBgzQli1bgsa+++47tW7d2qSIok9JSYms1uBfizabTX6/36SIolfbtm2VlZUV9PvY7XZr+fLl/D4OkZNJyNatW/Wf//xH6enpZocUVW699VZ9/fXXQb+Tc3JyNHXqVH388cdmh4czIJ8wF/mEucgnzEU+YT7yiaaDfMJ85BPmipZ8glZUNUyZMkXjxo1Tr1691KdPHz377LPyeDwaP3682aFFvDvuuEPz5s3T+++/r8TExEDfw+TkZMXGxpocXeRLTEw8rf9wfHy80tPT6UscAnfffbf69++vJ554Qj/5yU+0YsUKzZ07V3PnzjU7tKgxYsQIPf7442rVqpUuu+wyrV27Vn/4wx902223mR1aRCouLta2bdsC2zt37tS6deuUlpamVq1aafLkyXrsscfUoUMHtW3bVtOnT1dOTo5GjhxpXtAR5Ez3Pzs7WzfeeKPWrFmjDz74QD6fL/A7OS0tTU6n06ywI8rZ/g3UTP4cDoeysrLUsWPHUIeKc0Q+YR7yCXORT5iLfMJ85BOhRT5hLvIJ85FPSDJwmhdeeMFo1aqV4XQ6jT59+hjLli0zO6SoIKnWrz//+c9mhxa1Bg0aZEyaNMnsMKLGv/71L6NLly6Gy+UyOnXqZMydO9fskKKK2+02Jk2aZLRq1cqIiYkxLr74YuM3v/mNUV5ebnZoEWnRokW1/j9/3LhxhmEYht/vN6ZPn25kZmYaLpfLGDJkiLFlyxZzg44gZ7r/O3furPN38qJFi8wOPWKc7d9ATa1btzaeeeaZkMaI80c+YQ7yiaaHfCK0yCfMRT4RWuQT5iKfMB/5hGFYDMMwGrJQAgAAAAAAAAAA0FhYYwMAAAAAAAAAAIQNChsAAAAAAAAAACBsUNgAAAAAAAAAAABhg8IGAAAAAAAAAAAIGxQ2AAAAAAAAAABA2KCwAQAAAAAAAAAAwgaFDQAAAAAAAAAAEDYobAAAAAAAAAAAgLBBYQMAAAAAAAAAAIQNChsAAAAAAAAAACBsUNgAgHN05MgRNW/eXLt27TI7lAsyePBgTZ48uc7txj6f2ZpaPNHkpptu0tNPP212GAAAAKYgn2iY85mtqcUTTcgnAEiS3ewAACDcPP7447r++uvVpk0bs0NpUO+8844cDofZYYSVwYMHq3v37nr22WfNDiWsPPTQQ7rqqqv0s5/9TMnJyWaHAwAAEFLkEziJfOL8kE8AkJixAQDnpKSkRP/7v/+rCRMmNPq5KioqGv0c1aWlpSkxMTGk5zRLqO9tUzt/XUIVV5cuXdSuXTv97W9/C8n5AAAAmgryichg9vt5s89fF/IJAKFEYQNA1Ni1a5csFovefvttXXXVVYqNjVXv3r2Vl5enzz//XFdeeaXi4uI0ZMgQHT9+vNZj/Pvf/5bL5dKVV14ZND548GDddddduu+++5SWlqasrCw9/PDDQfuUl5frrrvuUvPmzRUTE6OBAwdq5cqVQceYOHGiJk+erIyMDA0fPjwwfuedd2ry5MlKTU1VZmamXnnlFXk8Ho0fP16JiYlq3769Pvroo8CxFixYoIEDByolJUXp6em69tprtX379jPen+pTqU/eq5pfgwcPliT5/X7NmjVLbdu2VWxsrLp166a33norcCyPx6OxY8cqISFB2dnZ9Z4m3FjXWte9re7DDz9UcnKyXn/99Xpd4//7f/9PS5Ys0XPPPRe4P3W1E6jt/Gc7viS99dZb6tq1q2JjY5Wenq6hQ4fK4/FIOvvPkyS1adPmtE9/de/ePfCzWdd98fv9mj17ttq3by+Xy6VWrVrp8ccfDxzjbLGfKe6TRowYofnz59d6vwAAAJoi8gnyCfIJ8gkATQeFDQBRY/369ZKkl19+WU888YS++uorFRQU6JZbbtGTTz6pF198UYsWLdL69ev15z//udZjfP7557riiitqfe61115TfHy8li9frtmzZ+u3v/2tFi5cGHj+vvvu09tvv63XXntNa9asUfv27TV8+HAdPXo06BhOp1Nffvml5syZEzSekZGhFStW6M4779Ttt9+uUaNGqX///lqzZo2GDRumW2+9VSUlJZKqEoEpU6Zo1apVys3NldVq1Y9//GP5/f563auWLVvqwIEDga+1a9cqPT1dV111lSRp1qxZ+r//+z/NmTNH33zzje6++27dcsstWrJkiSRp6tSpWrJkid5//3198sknWrx4sdasWVOvczfWtdZ1byVp3rx5GjNmjF5//XXdfPPN9brG5557Tv369dPPf/7zwH1q2bLlGa+r+vnPdvwDBw5ozJgxuu2227Rp0yYtXrxYN9xwgwzDkFS/n6f63u+a92XatGl68sknNX36dH377beaN2+eMjMzA99zptjPFvdJffr00YoVK1ReXn5O8QIAAJiFfIJ8gnzi7HFJ5BMAQsQAgCjx8MMPG2lpacbhw4cDY7fccovRpk0bw+PxBMb+67/+y7jvvvtqPcb1119v3HbbbaeNDxo0yBg4cGDQWO/evY3777/fMAzDKC4uNhwOh/H6668Hnq+oqDBycnKM2bNnB47Ro0ePsx67srLSiI+PN2699dbA2IEDBwxJxtKlS2uN+9ChQ4YkY8OGDUHHnTRpUp3bJ5WWlhp9+/Y1rr32WsPn8xllZWVGXFyc8dVXXwXtN2HCBGPMmDFGUVGR4XQ6jTfffDPw3JEjR4zY2Nhajx+qa615b09e74svvmgkJycbixcvDjx3tmuseYyzqXn++hx/9erVhiRj165dpx2vPj9PhmEYrVu3Np555pmg7+3WrZsxc+bMWuMyDMNwu92Gy+UyXnnllVqv5Wyxnynu6tavX1+v/QAAAJoK8gnyiZrnIp8gnwBgHhYPBxA11q9frx//+MdKT08PjOXl5Wn06NGKi4sLGrv++utrPUZpaaliYmJqfe7yyy8P2s7OztbBgwclSdu3b5fX69WAAQMCzzscDvXp00ebNm0KjNX16a3qx7bZbEpPT1fXrl0DYyc//XLyfFu3btWMGTO0fPlyHT58OPBpo7y8PHXp0qXWc9TltttuU1FRkRYuXCir1apt27appKREP/zhD4P2q6ioUI8ePbR9+3ZVVFSob9++gefS0tLUsWPHep2vsa61tnv71ltv6eDBg/ryyy/Vu3fvwPjZrvF8VD9/fY7frVs3DRkyRF27dtXw4cM1bNgw3XjjjUpNTa33z9O5xiVJmzZtUnl5uYYMGVLr/meL/UxxVxcbGytJgU/KAQAANHXkE+QTNZFPkE8AMA+FDQBRY926dZo2bVrQ2Pr163X33XcHtsvKyrRlyxZ169at1mNkZGTo2LFjtT7ncDiCti0WS72nap8UHx9f72NXH7NYLJIUON+IESPUunVrvfLKK8rJyZHf71eXLl3OeTG3xx57TB9//LFWrFgRWAiwuLhYUlUP2RYtWgTt73K5znnqck2Nda213dsePXpozZo1evXVV9WrV6/Asc92jeej+vnrc3ybzaaFCxfqq6++0ieffKIXXnhBv/nNb7R8+fJ6n9NqtZ42Zdvr9dYZl3QqQajL2WI/U9xt27YN7Hvy56RZs2b1vh4AAAAzkU+QT9REPkE+AcA8rLEBICq43W7t2rUr6NMxO3fuVGFhYdDYhg0bZBhG0Cd6quvRo4e+/fbbcz5/u3btAn1HT/J6vVq5cqU6d+58zsc7kyNHjmjLli166KGHNGTIEF166aV1Jk9n8vbbb+u3v/2t3nzzTbVr1y4w3rlzZ7lcLuXl5al9+/ZBXy1btlS7du3kcDiC3jAfO3ZM3333XYNcX3UXeq3t2rXTokWL9P777+vOO+8MjJ/tGk9yOp3y+XznHHd9j2+xWDRgwAA98sgjWrt2rZxOp9599916/zw1a9ZMBw4cCGy73W7t3LnzjLF16NBBsbGxys3NPe/Y64q7uo0bN+qiiy5SRkZG/W8cAACAScgnyCdqQz5xOvIJAKHCjA0AUWH9+vWy2WxBU4nXrVuntLQ0tW7dOmisXbt2SkhIqPU4w4cP17Rp03Ts2LHTpsKeSXx8vG6//XZNnTpVaWlpatWqlWbPnq2SkhJNmDDh/C+sFqmpqUpPT9fcuXOVnZ2tvLw8PfDAA+d0jI0bN2rs2LG6//77ddlllyk/P19S1RvvtLQ03Xvvvbr77rvl9/s1cOBAFRYW6ssvv1RSUpLGjRunCRMmaOrUqUpPT1fz5s31m9/8RlZrw9fSG+JaL7nkEi1atEiDBw+W3W7Xs88+q8TExLNeoyS1adNGy5cv165du5SQkKC0tLR6XWd9jr98+XLl5uZq2LBhat68uZYvX65Dhw7p0ksvrffP0w9+8AP95S9/0YgRI5SSkqIZM2bIZrOdMbaYmBjdf//9uu++++R0OjVgwAAdOnRI33zzjSZMmHDW2Dt16lRn3NV9/vnnGjZs2Dm9VgAAAGYhnyCfqAv5RDDyCQChQmEDQFRYv369OnbsGNTPdv369af1N12/fn2d08YlqWvXrurZs6fefPNN/fKXvzynGJ588kn5/X7deuutKioqUq9evfTxxx+fU0JTH1arVfPnz9ddd92lLl26qGPHjnr++ec1ePDgeh9j1apVKikp0WOPPabHHnssMD5o0CAtXrxYjz76qJo1a6ZZs2Zpx44dSklJUc+ePfXggw9Kkn73u9+puLhYI0aMUGJiou655x4VFhY26HVKDXOtktSxY0d9+umnGjx4sGw2m55++umzXqMk3XvvvRo3bpw6d+6s0tJS7dy5U23atKnXOc92/KSkJH322Wd69tln5Xa71bp1az399NO6+uqrJdXv52natGnauXOnrr32WiUnJ+vRRx896yesJGn69Omy2+2aMWOG9u/fr+zsbP3qV7+qV+xni1uqatHw3nvvacGCBfW6VwAAAGYjnyCfOBPyiWDkEwBCwWLUbJYHADijDz/8UFOnTtXGjRsb5VNDQKR7+eWX9e677+qTTz4xOxQAAICQI58ALgz5BACJGRsAcM6uueYabd26Vfv27QvqXwqgfhwOh1544QWzwwAAADAF+QRwYcgnAEjM2AAAAAAAAAAAAGGEOY8AAAAAAAAAACBsUNgAAAAAAAAAAABhg8IGAAAAAAAAAAAIGxQ2AAAAAAAAAABA2KCwAQAAAAAAAAAAwgaFDQAAAAAAAAAAEDYobAAAAAAAAAAAgLBBYQMAAAAAAAAAAIQNChsAAAAAAAAAACBsUNgAAAAAAAAAAABh4/8DGKDMLcYkcDUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [harmenberg_neutral_measure_distributions]\n", + "fig, axes = plt.subplots(1, 2, figsize=(16, 6))\n", + "\n", + "# Midpoint bin widths for converting mass to density\n", + "m_widths = np.zeros(M)\n", + "m_widths[0] = dist_mGrid[1] - dist_mGrid[0]\n", + "m_widths[-1] = dist_mGrid[-1] - dist_mGrid[-2]\n", + "m_widths[1:-1] = 0.5 * (dist_mGrid[2:] - dist_mGrid[:-2])\n", + "\n", + "# Per-state distributions (density under neutral measure)\n", + "for j in range(J):\n", + " block = ergodic_dist[j * M : (j + 1) * M]\n", + " density_j = block / m_widths\n", + " color = plt.cm.coolwarm(j / (J - 1))\n", + " axes[0].plot(\n", + " dist_mGrid, density_j, label=state_names[j], color=color, linewidth=1.5\n", + " )\n", + "axes[0].set_xlabel(\"$m$ (normalized market resources)\")\n", + "axes[0].set_ylabel(\"Probability Density (neutral measure)\")\n", + "axes[0].set_title(\"TM Distribution by Markov State\")\n", + "axes[0].set_xlim([0, 15])\n", + "axes[0].legend(fontsize=9)\n", + "\n", + "# Aggregate m-distribution: TM vs MC (density)\n", + "tm_m_marginal = np.zeros(M)\n", + "for j in range(J):\n", + " tm_m_marginal += ergodic_dist[j * M : (j + 1) * M]\n", + "\n", + "axes[1].plot(\n", + " dist_mGrid,\n", + " tm_m_marginal / m_widths,\n", + " color=COLOR_TM,\n", + " linewidth=2,\n", + " label=f\"TM neutral ({mCount} m-pts)\",\n", + ")\n", + "axes[1].hist(\n", + " HY[\"mNrm\"][-1],\n", + " bins=N_MC_BINS,\n", + " density=True,\n", + " alpha=0.4,\n", + " color=COLOR_MC,\n", + " label=f\"MC ({n_agents:,} agents)\",\n", + ")\n", + "axes[1].set_xlabel(\"$m$ (normalized market resources)\")\n", + "axes[1].set_ylabel(\"Probability Density\")\n", + "axes[1].set_title(\"Marginal Distribution of $m$\")\n", + "axes[1].set_xlim([0, 15])\n", + "axes[1].legend()\n", + "\n", + "plt.suptitle(\"Harmenberg Neutral Measure: Distributions\", fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6c446c80", + "metadata": {}, + "source": [ + "## 10. Summary: Neutral Measure vs 2D Grid\n", + "\n", + "| Feature | 2D Grid | Neutral Measure |\n", + "|---------|---------|-----------------|\n", + "| Grid dimensions | $m \\times p \\times J$ | $m \\times J$ |\n", + "| States (this model) | 10,000 | 400 (with 200 m-pts) |\n", + "| Memory | ~800 MB | ~1.3 MB |\n", + "| Normalized aggregates | ✓ accurate | ✓ accurate |\n", + "| Level aggregates | ✗ ~30% error (p-grid truncation) | ✓ accurate via $\\bar{c} \\times \\bar{p}$ |\n", + "| Build time | ~minutes | ~seconds |\n", + "\n", + "**Key insight:** The 2D grid's failure for level aggregates was caused by the\n", + "$p$-grid being too narrow to capture the long right tail. The neutral measure\n", + "avoids this entirely by never discretizing $p$ — it computes $\\bar{p}$\n", + "analytically instead.\n", + "\n", + "### The Harmenberg recipe\n", + "\n", + "1. **Reweight permanent shocks:** $P^*(\\psi_k) = \\psi_k \\cdot P(\\psi_k)$\n", + "2. **Build 1D TM** using $m_{t+1} = R \\cdot a / (\\psi \\cdot \\Gamma_{j'}) + \\theta$ with neutral-measure probabilities\n", + "3. **Find ergodic distribution** $\\pi^*(m, j)$\n", + "4. **Normalized aggregates:** $\\bar{c} = E^*[c(m)]$ — read directly from the distribution\n", + "5. **Level aggregates:** multiply by $\\bar{p} = (1-\\lambda) / (1 - \\lambda E[\\Gamma])$\n", + "\n", + "### Next steps\n", + "\n", + "- Apply neutral measure to `AggShockMarkovConsumerType` (endogenous aggregate state)\n", + "- Extend to `NewKeynesianConsumerType` for GE applications\n", + "- Compare convergence rates: 1D neutral vs 2D grid as grid density increases" + ] + } + ], + "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.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/MonteCarlovsTransitionMatrix/Validation_and_SSJ.ipynb b/examples/MonteCarlovsTransitionMatrix/Validation_and_SSJ.ipynb new file mode 100644 index 000000000..3735a89b4 --- /dev/null +++ b/examples/MonteCarlovsTransitionMatrix/Validation_and_SSJ.ipynb @@ -0,0 +1,686 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "797dcc56", + "metadata": {}, + "source": [ + "# TM Validation and Sequence-Space Jacobians\n", + "\n", + "This notebook covers two topics that extend the MC-vs-TM comparison:\n", + "\n", + "| Part | What it does |\n", + "|------|--------------|\n", + "| 1 | Validate TM methods (`define_distribution_grid`, `calc_transition_matrix`, `calc_ergodic_dist`, `compute_pe_steady_state`) |\n", + "| 2 | Compute sequence-space Jacobians via the Fake News Algorithm (Auclert et al. 2021) |\n", + "\n", + "Both parts use `MarkovConsumerType` with a symmetric 2-state Markov chain.\n", + "Neither part runs Monte Carlo — for MC comparisons, see `PE_MarkovConsumerType.ipynb`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8e86d59c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:10.242048Z", + "iopub.status.busy": "2026-03-21T04:23:10.241879Z", + "iopub.status.idle": "2026-03-21T04:23:50.605904Z", + "shell.execute_reply": "2026-03-21T04:23:50.605385Z" + } + }, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import numpy as np\n", + "from copy import deepcopy\n", + "\n", + "from HARK.ConsumptionSaving.ConsMarkovModel import (\n", + " MarkovConsumerType,\n", + " init_indshk_markov,\n", + ")\n", + "\n", + "COLOR_MC = \"tab:blue\"\n", + "COLOR_TM = \"tab:orange\"" + ] + }, + { + "cell_type": "markdown", + "id": "a0f73088", + "metadata": {}, + "source": [ + "---\n", + "# Part 1: Validating MarkovConsumerType TM Methods\n", + "\n", + "We verify these methods produce correct results by:\n", + "1. Checking column sums = 1 for a 2-state Markov model\n", + "2. Comparing `compute_pe_steady_state()` results with hand-built TM code\n", + "3. Verifying ergodic Markov state fractions match the analytical stationary distribution\n" + ] + }, + { + "cell_type": "markdown", + "id": "234b08b4", + "metadata": {}, + "source": [ + "## 1. Create a 2-state symmetric Markov agent\n", + "\n", + "Calibration is based on the default `init_indshk_markov` parameter dictionary\n", + "from `ConsMarkovModel`, which extends the standard incomplete-markets\n", + "consumption-saving setup with a symmetric 2-state Markov chain\n", + "(p11 = p22 = 0.9). State-dependent parameters (Rfree, LivPrb, PermGroFac)\n", + "are set identical across states so the only variation comes from the Markov\n", + "transition itself—an intentional simplification for validation purposes." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2953e1de", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:50.608920Z", + "iopub.status.busy": "2026-03-21T04:23:50.608757Z", + "iopub.status.idle": "2026-03-21T04:23:50.617959Z", + "shell.execute_reply": "2026-03-21T04:23:50.617621Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MrkvArray: [[0.9 0.1]\n", + " [0.1 0.9]]\n" + ] + } + ], + "source": [ + "params = deepcopy(init_indshk_markov)\n", + "params[\"Mrkv_p11\"] = [0.9]\n", + "params[\"Mrkv_p22\"] = [0.9]\n", + "params[\"Rfree\"] = [np.array([1.03, 1.03])]\n", + "params[\"LivPrb\"] = [np.array([0.98, 0.98])]\n", + "params[\"PermGroFac\"] = [np.array([1.0, 1.0])]\n", + "params[\"cycles\"] = 0\n", + "\n", + "agent = MarkovConsumerType(**params)\n", + "print(\"MrkvArray:\", agent.MrkvArray[0])" + ] + }, + { + "cell_type": "markdown", + "id": "2e35b18a", + "metadata": {}, + "source": [ + "## 2. Compute PE steady state using the new method" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0d9b3e3d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:50.619985Z", + "iopub.status.busy": "2026-03-21T04:23:50.619851Z", + "iopub.status.idle": "2026-03-21T04:23:52.938136Z", + "shell.execute_reply": "2026-03-21T04:23:52.937283Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_ss = 0.835777\n", + "C_ss = 1.007856\n" + ] + } + ], + "source": [ + "A_ss, C_ss = agent.compute_pe_steady_state()\n", + "print(f\"A_ss = {A_ss:.6f}\")\n", + "print(f\"C_ss = {C_ss:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6ecc229a", + "metadata": {}, + "source": [ + "## 3. Validate transition matrix column sums" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9a3cd2bd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:52.941003Z", + "iopub.status.busy": "2026-03-21T04:23:52.940822Z", + "iopub.status.idle": "2026-03-21T04:23:52.944673Z", + "shell.execute_reply": "2026-03-21T04:23:52.944296Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Column sums: min=1.000000000000, max=1.000000000000\n", + "PASS: All column sums equal 1.0\n" + ] + } + ], + "source": [ + "col_sums = agent.tran_matrix.sum(axis=0)\n", + "print(f\"Column sums: min={col_sums.min():.12f}, max={col_sums.max():.12f}\")\n", + "assert np.allclose(col_sums, 1.0, atol=1e-10), \"Column sums are not 1.0!\"\n", + "print(\"PASS: All column sums equal 1.0\")" + ] + }, + { + "cell_type": "markdown", + "id": "c261905e", + "metadata": {}, + "source": [ + "## 4. Validate ergodic Markov state fractions" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a4a1528a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:52.946893Z", + "iopub.status.busy": "2026-03-21T04:23:52.946748Z", + "iopub.status.idle": "2026-03-21T04:23:52.950577Z", + "shell.execute_reply": "2026-03-21T04:23:52.949974Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ergodic state fractions: [0.5000000000000001, 0.49999999999999983]\n", + "Expected (symmetric p11=p22=0.9): [0.5, 0.5]\n", + "PASS: Ergodic Markov fractions match analytical values\n" + ] + } + ], + "source": [ + "M = len(agent.dist_mGrid) # number of grid points in the asset distribution\n", + "J = agent.MrkvArray[0].shape[0] # number of Markov states\n", + "\n", + "# vec_erg_dstn is a single vector of length M*J, stacked [state0, state1, ...].\n", + "# Sum each state's block to get the marginal probability of being in that state.\n", + "pi_by_state = [np.sum(agent.vec_erg_dstn[j * M : (j + 1) * M]) for j in range(J)]\n", + "print(f\"Ergodic state fractions: {pi_by_state}\")\n", + "print(\"Expected (symmetric p11=p22=0.9): [0.5, 0.5]\")\n", + "assert abs(pi_by_state[0] - 0.5) < 0.01, \"State 0 fraction should be ~0.5\"\n", + "assert abs(pi_by_state[1] - 0.5) < 0.01, \"State 1 fraction should be ~0.5\"\n", + "print(\"PASS: Ergodic Markov fractions match analytical values\")" + ] + }, + { + "cell_type": "markdown", + "id": "f2581fb2", + "metadata": {}, + "source": [ + "## 5. Compare with hand-built TM" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a407e535", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:52.953483Z", + "iopub.status.busy": "2026-03-21T04:23:52.953318Z", + "iopub.status.idle": "2026-03-21T04:23:52.961041Z", + "shell.execute_reply": "2026-03-21T04:23:52.960617Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Max element-wise difference between method TM and hand-built TM: 0.0\n", + "PASS: Method TM matches hand-built TM exactly\n" + ] + } + ], + "source": [ + "from HARK.utilities import gen_tran_matrix_1D_markov, jump_to_grid_1D\n", + "\n", + "# Rebuild the TM by hand using the same ingredients the method uses internally,\n", + "# so any difference would indicate a bug in the method's assembly logic.\n", + "dist_mGrid = agent.dist_mGrid\n", + "MrkvArr = agent.MrkvArray[0]\n", + "Rfree_arr = np.asarray(agent.Rfree[0], dtype=np.float64)\n", + "PermGroFac_arr = np.asarray(agent.PermGroFac[0], dtype=np.float64)\n", + "LivPrb_arr = np.asarray(agent.LivPrb[0], dtype=np.float64)\n", + "\n", + "# aPol_Grid is stored per-state; stack into (J, M) array for the utility function\n", + "aPol_2d = np.array([agent.aPol_Grid[j] for j in range(J)])\n", + "\n", + "# Unpack the joint income-shock distribution for period 0, state 0\n", + "# (all states share the same shock distribution in this symmetric calibration)\n", + "shk_prbs = agent.IncShkDstn[0][0].pmv\n", + "perm_shks = agent.IncShkDstn[0][0].atoms[0]\n", + "tran_shks = agent.IncShkDstn[0][0].atoms[1]\n", + "\n", + "# Newborn distribution: agents who die are replaced at m = 1 (normalized),\n", + "# spread across the asset grid according to transitory-shock realizations\n", + "newborn_1d = jump_to_grid_1D(np.ones_like(tran_shks), shk_prbs, dist_mGrid)\n", + "markov_stationary = MarkovConsumerType._calc_markov_stationary(MrkvArr)\n", + "NewBornDist = np.zeros(M * J)\n", + "for jp in range(J):\n", + " # Weight each state's newborn mass by the Markov stationary probability\n", + " NewBornDist[jp * M : (jp + 1) * M] = markov_stationary[jp] * newborn_1d\n", + "\n", + "hand_tm = gen_tran_matrix_1D_markov(\n", + " dist_mGrid,\n", + " aPol_2d,\n", + " MrkvArr,\n", + " Rfree_arr,\n", + " PermGroFac_arr,\n", + " LivPrb_arr,\n", + " shk_prbs,\n", + " perm_shks,\n", + " tran_shks,\n", + " NewBornDist,\n", + ")\n", + "\n", + "max_diff = np.max(np.abs(hand_tm - agent.tran_matrix))\n", + "print(f\"Max element-wise difference between method TM and hand-built TM: {max_diff}\")\n", + "assert max_diff < 1e-14, f\"TMs should be identical, got diff={max_diff}\"\n", + "print(\"PASS: Method TM matches hand-built TM exactly\")" + ] + }, + { + "cell_type": "markdown", + "id": "6a6e02d1", + "metadata": {}, + "source": [ + "## 6. Summary" + ] + }, + { + "cell_type": "markdown", + "id": "aa9a323c", + "metadata": {}, + "source": [ + "All validations passed:\n", + "\n", + "| Check | Result |\n", + "|-------|--------|\n", + "| Column sums = 1.0 | PASS |\n", + "| Ergodic Markov fractions match analytical | PASS |\n", + "| `compute_pe_steady_state()` returns finite positive values | PASS |\n", + "| Method TM = hand-built TM | PASS |\n", + "\n", + "The new `MarkovConsumerType` TM methods are validated and ready for use.\n" + ] + }, + { + "cell_type": "markdown", + "id": "ddd477f0", + "metadata": {}, + "source": [ + "---\n", + "# Part 2: Sequence-Space Jacobians for MarkovConsumerType\n", + "\n", + "We compute impulse response functions (IRFs) via the Fake News Algorithm\n", + "(Auclert et al. 2021) applied to the Markov consumption-saving model.\n" + ] + }, + { + "cell_type": "markdown", + "id": "1e51133d", + "metadata": {}, + "source": [ + "## 1. Set up and solve the steady state\n", + "\n", + "Calibration follows `init_indshk_markov` from `ConsMarkovModel`, which\n", + "extends the baseline `IndShockConsumerType` calibration with a symmetric\n", + "two-state Markov chain (p11 = p22 = 0.9). Interest rates, survival\n", + "probabilities, and permanent income growth are set equal across states so\n", + "the Markov structure is active but states are symmetric — isolating the\n", + "effect of the transition-matrix machinery from state-dependent economics." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ab39a6d4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:52.963776Z", + "iopub.status.busy": "2026-03-21T04:23:52.963639Z", + "iopub.status.idle": "2026-03-21T04:23:53.154055Z", + "shell.execute_reply": "2026-03-21T04:23:53.153626Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Steady state: A_ss = 0.835777, C_ss = 1.007856\n", + "TM column sums: min=1.000000000000, max=1.000000000000\n" + ] + } + ], + "source": [ + "params = deepcopy(init_indshk_markov)\n", + "params[\"Mrkv_p11\"] = [0.9]\n", + "params[\"Mrkv_p22\"] = [0.9]\n", + "# Symmetric across Markov states — no state-dependent economics\n", + "params[\"Rfree\"] = [np.array([1.03, 1.03])]\n", + "params[\"LivPrb\"] = [np.array([0.98, 0.98])]\n", + "params[\"PermGroFac\"] = [np.array([1.0, 1.0])]\n", + "params[\"cycles\"] = 0 # infinite-horizon\n", + "\n", + "agent = MarkovConsumerType(**params)\n", + "# Solves the model, builds the TM, and finds the ergodic distribution\n", + "A_ss, C_ss = agent.compute_pe_steady_state()\n", + "print(f\"Steady state: A_ss = {A_ss:.6f}, C_ss = {C_ss:.6f}\")\n", + "\n", + "# Column sums of 1.0 confirm the TM is a valid probability matrix\n", + "col_sums = agent.tran_matrix.sum(axis=0)\n", + "print(f\"TM column sums: min={col_sums.min():.12f}, max={col_sums.max():.12f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d181cb17", + "metadata": {}, + "source": [ + "## 2. Compute Jacobians via Fake News Algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "96e585f8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:53.157056Z", + "iopub.status.busy": "2026-03-21T04:23:53.156706Z", + "iopub.status.idle": "2026-03-21T04:23:53.835302Z", + "shell.execute_reply": "2026-03-21T04:23:53.834437Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jacobians computed in 0.7 seconds\n", + "AJAC shape: (50, 50)\n", + "IRF of A to Rfree shock (first 10 periods):\n", + " t= 0: dA/dR = 1.0131\n", + " t= 1: dA/dR = 0.9033\n", + " t= 2: dA/dR = 0.8077\n", + " t= 3: dA/dR = 0.7239\n", + " t= 4: dA/dR = 0.6500\n", + " t= 5: dA/dR = 0.5845\n", + " t= 6: dA/dR = 0.5264\n", + " t= 7: dA/dR = 0.4747\n", + " t= 8: dA/dR = 0.4285\n", + " t= 9: dA/dR = 0.3871\n" + ] + } + ], + "source": [ + "T = 50 # Jacobian horizon: 50 periods\n", + "\n", + "t0 = time.time()\n", + "# Fake News Algorithm (Auclert et al. 2021): decomposes the Jacobian into\n", + "# curly-D, curly-P, and fake-news matrix components for efficiency.\n", + "CJAC, AJAC = agent.calc_jacobian(\"Rfree\", T)\n", + "jac_time = time.time() - t0\n", + "print(f\"Jacobians computed in {jac_time:.1f} seconds\")\n", + "\n", + "# Column s of AJAC gives the IRF of aggregate A to a one-period\n", + "# Rfree shock at date s. Column 0 = MIT shock at t=0.\n", + "print(f\"AJAC shape: {AJAC.shape}\")\n", + "print(\"IRF of A to Rfree shock (first 10 periods):\")\n", + "for t in range(min(10, T)):\n", + " print(f\" t={t:2d}: dA/dR = {AJAC[t, 0]:>10.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b0b2a000", + "metadata": {}, + "source": [ + "## 3. Verify with finite-difference TM propagation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "24ba86b9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:53.839054Z", + "iopub.status.busy": "2026-03-21T04:23:53.838701Z", + "iopub.status.idle": "2026-03-21T04:23:53.854883Z", + "shell.execute_reply": "2026-03-21T04:23:53.854405Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finite-difference vs Jacobian (first column):\n", + " t AJAC[:,0] FD dA/dR Diff\n", + " 0 1.0131 0.7251 0.287984\n", + " 1 0.9033 0.6495 0.253735\n", + " 2 0.8077 0.5829 0.224749\n", + " 3 0.7239 0.5240 0.199826\n", + " 4 0.6500 0.4718 0.178187\n", + " 5 0.5845 0.4253 0.159273\n", + " 6 0.5264 0.3838 0.142656\n", + " 7 0.4747 0.3467 0.127998\n", + " 8 0.4285 0.3134 0.115023\n", + " 9 0.3871 0.2836 0.103504\n", + " 10 0.3501 0.2568 0.093251\n", + " 11 0.3168 0.2327 0.084105\n", + " 12 0.2870 0.2110 0.075931\n", + " 13 0.2601 0.1915 0.068612\n", + " 14 0.2358 0.1738 0.062049\n" + ] + } + ], + "source": [ + "dx = 0.0001\n", + "base_Rfree = agent.Rfree[0].copy()\n", + "\n", + "# Build a perturbed agent with Rfree shifted by dx in both Markov states.\n", + "# Re-solve and rebuild TM so the perturbed transition matrix reflects the\n", + "# new Rfree's effect on savings policy and thus on the distribution dynamics.\n", + "agent_pert = deepcopy(agent)\n", + "agent_pert.Rfree = [base_Rfree + dx]\n", + "agent_pert.neutral_measure = True\n", + "agent_pert.construct(\"IncShkDstn\", \"TranShkDstn\", \"PermShkDstn\")\n", + "agent_pert.define_distribution_grid(dist_mGrid=agent.dist_mGrid)\n", + "agent_pert.calc_transition_matrix()\n", + "\n", + "D_ss = agent.vec_erg_dstn.flatten()\n", + "M = len(agent.dist_mGrid)\n", + "J = 2\n", + "\n", + "c_ss_flat = np.concatenate(agent.cPol_Grid)\n", + "a_ss_flat = np.concatenate(agent.aPol_Grid)\n", + "\n", + "# FD IRF: apply the perturbed TM at t=0, then revert to the SS TM.\n", + "# NOTE: this loop transitions the distribution BEFORE computing aggregates,\n", + "# i.e. A_fd[t] = a' @ (TM @ dstn). If the Jacobian uses\n", + "# compute-then-transition ordering, this introduces an off-by-one shift.\n", + "dstn = D_ss.copy()\n", + "A_fd = np.zeros(T)\n", + "for t in range(T):\n", + " tm = agent_pert.tran_matrix if t == 0 else agent.tran_matrix\n", + " dstn = tm @ dstn\n", + " A_fd[t] = np.dot(a_ss_flat, dstn)\n", + "\n", + "dA_fd = (A_fd - A_ss) / dx\n", + "\n", + "print(\"Finite-difference vs Jacobian (first column):\")\n", + "print(f\"{'t':>3s} {'AJAC[:,0]':>12s} {'FD dA/dR':>12s} {'Diff':>12s}\")\n", + "for t in range(min(15, T)):\n", + " print(f\"{t:3d} {AJAC[t, 0]:12.4f} {dA_fd[t]:12.4f} {AJAC[t, 0] - dA_fd[t]:12.6f}\")\n", + "\n", + "# Restore original Rfree\n", + "agent.Rfree = [base_Rfree]" + ] + }, + { + "cell_type": "markdown", + "id": "23b40d3a", + "metadata": {}, + "source": [ + "### Known issue: ~28% Jacobian vs finite-difference disagreement\n", + "\n", + "The Jacobian column and the FD derivative disagree by roughly 28% at every\n", + "horizon — the ratio `AJAC[t,0] / dA_fd[t]` is nearly constant (~1.40).\n", + "A *constant multiplicative* discrepancy rules out simple numerical noise and\n", + "points to a systematic timing or normalisation mismatch.\n", + "\n", + "**Likely causes (in order of probability):**\n", + "\n", + "1. **Off-by-one / transition-then-compute vs compute-then-transition.**\n", + " The FD loop above transitions the distribution *before* computing\n", + " aggregates: `dstn = TM @ dstn; A = a' @ dstn`. If `calc_jacobian`\n", + " uses the opposite convention (compute aggregates from the *current*\n", + " distribution, *then* transition), the FD IRF is effectively shifted\n", + " forward by one period relative to the Jacobian. \n", + " This is the same class of bug identified as **Fix #6** in the\n", + " `Transition_Matrix_Example` notebook.\n", + "\n", + "2. **Perturbed-agent setup.** The FD agent perturbs `Rfree` and rebuilds\n", + " the transition matrix, but uses the *steady-state* policy grids\n", + " (`a_ss_flat`, `c_ss_flat`) to compute aggregates. A fully consistent\n", + " FD check would also use the *perturbed* policy grids — the mismatch\n", + " means the FD derivative captures only the \"distribution channel\" of the\n", + " Rfree shock and misses the \"policy channel.\"\n", + "\n", + "3. **Incorrect order of operations in the FD loop.** Related to (1), the\n", + " loop applies the perturbed TM at `t == 0` and then the SS TM for\n", + " `t >= 1`, but the aggregate is always computed *after* the transition.\n", + " This means `A_fd[0]` already reflects one full transition step, which\n", + " may not align with the Jacobian's definition of the period-0 response.\n", + "\n", + "Resolving this is tracked as a **Tier 1B** investigation item." + ] + }, + { + "cell_type": "markdown", + "id": "b0e93ee8", + "metadata": {}, + "source": [ + "## 4. IRF plot description" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "df0945d9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-21T04:23:53.857794Z", + "iopub.status.busy": "2026-03-21T04:23:53.857597Z", + "iopub.status.idle": "2026-03-21T04:23:53.861015Z", + "shell.execute_reply": "2026-03-21T04:23:53.860583Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Asset IRF: peak at t=0, peak value = 1.0131\n", + "Consumption IRF: peak at t=0, peak value = 0.1385\n", + "Asset IRF sign at t=0: positive\n", + "Consumption IRF sign at t=0: positive\n", + "Half-life of |asset IRF|: ~7 periods\n" + ] + } + ], + "source": [ + "# Characterize the IRF shape\n", + "irf_A = AJAC[:, 0]\n", + "irf_C = CJAC[:, 0]\n", + "\n", + "print(\n", + " f\"Asset IRF: peak at t={np.argmax(np.abs(irf_A))}, peak value = {irf_A[np.argmax(np.abs(irf_A))]:.4f}\"\n", + ")\n", + "print(\n", + " f\"Consumption IRF: peak at t={np.argmax(np.abs(irf_C))}, peak value = {irf_C[np.argmax(np.abs(irf_C))]:.4f}\"\n", + ")\n", + "print(f\"Asset IRF sign at t=0: {'positive' if irf_A[0] > 0 else 'negative'}\")\n", + "print(f\"Consumption IRF sign at t=0: {'positive' if irf_C[0] > 0 else 'negative'}\")\n", + "print(\n", + " f\"Half-life of |asset IRF|: ~{np.argmax(np.abs(irf_A) < np.abs(irf_A).max() / 2)} periods\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "df8f88d7", + "metadata": {}, + "source": [ + "## 5. Summary\n", + "\n", + "The `calc_jacobian` method on `MarkovConsumerType` implements the\n", + "Fake News Algorithm for Markov models:\n", + "\n", + "- **Speed**: Computing a 50×50 Jacobian takes only seconds.\n", + "- **Block structure**: The (M×J) × (M×J) transition matrices correctly\n", + " handle cross-state transitions in the Markov model.\n", + "- **Open issue**: The Jacobian and finite-difference IRFs disagree by\n", + " ~28% at every horizon. The discrepancy is multiplicatively constant,\n", + " suggesting a systematic timing or normalisation mismatch (see the\n", + " \"Known issue\" cell above). This must be resolved before the Jacobian\n", + " can be considered fully validated.\n", + "\n", + "This enables sequence-space analysis of heterogeneous-agent models with\n", + "discrete Markov states — a key building block for HANK models with\n", + "state-dependent dynamics.\n" + ] + } + ], + "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.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/SequenceSpaceJacobians/KS-HARK-presentation.ipynb b/examples/SequenceSpaceJacobians/KS-HARK-presentation.ipynb index 4818fd0e2..8423e8200 100644 --- a/examples/SequenceSpaceJacobians/KS-HARK-presentation.ipynb +++ b/examples/SequenceSpaceJacobians/KS-HARK-presentation.ipynb @@ -25,7 +25,12 @@ "from sequence_jacobian import create_model, simple # functions\n", "from sequence_jacobian.classes import JacobianDict, SteadyStateDict\n", "\n", - "from HARK.ConsumptionSaving.ConsNewKeynesianModel import NewKeynesianConsumerType" + "from copy import deepcopy\n", + "\n", + "from HARK.ConsumptionSaving.ConsNewKeynesianModel import (\n", + " NewKeynesianConsumerType,\n", + " init_newkeynesian,\n", + ")" ] }, { @@ -112,7 +117,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ " message: The solution converged.\n", @@ -173,7 +177,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "--------------------------------------+------------\n", @@ -223,43 +226,30 @@ "w_ss = calibration[\"w_ss\"]\n", "r_ss = calibration[\"r_ss\"]\n", "\n", - "HANK_Dict = {\n", - " # Individual agent 'preferences' (shared with perfect foresight model)\n", - " \"CRRA\": calibration[\"eis\"], # Coefficient of relative risk aversion\n", - " \"DiscFac\": 0.98, # Intertemporal discount factor\n", - " \"LivPrb\": [0.99375], # Survival probability\n", - " # Individual lifcycle income process parameters\n", - " \"PermGroFac\": [1.00], # Permanent income growth factor\n", - " \"PermShkStd\": [0.06], # Standard deviation of log permanent shocks to income\n", - " \"PermShkCount\": 5, # Number of points in discrete approximation to permanent income shocks\n", - " \"TranShkStd\": [0.2], # Standard deviation of log transitory shocks to income\n", - " \"TranShkCount\": 5, # Number of points in discrete approximation to transitory income shocks\n", - " # Parameters related to unemployment and retirement\n", - " \"UnempPrb\": 0.0, # Probability of unemployment while working\n", - " \"IncUnemp\": 0.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.0, # Period of retirement (0 --> no retirement)\n", - " # Aggregates affecting the agent's decision\n", - " \"Rfree\": [(1 + r_ss)], # Interest factor for assets faced by agents\n", - " \"wage\": [w_ss], # Wage rate faced by agents\n", - " \"tax_rate\": [\n", - " 0\n", - " ], # set to 0.0 because we are going to assume that labor here is actually after tax income\n", - " \"labor\": [L_ss], # Aggregate (mean) labor supply\n", - " # Parameters for constructing \"assets above minimum\" grid\n", - " \"aXtraMin\": 0.0001, # Minimum end-of-period \"assets above minimum\" value\n", - " \"aXtraMax\": 2000, # Maximum end-of-period \"assets above minimum\" value\n", - " \"aXtraCount\": 200, # Number of points in the base grid of \"assets above minimum\"\n", - " # Exponential nesting factor when constructing \"assets above minimum\" grid\n", - " \"aXtraNestFac\": 3,\n", - " \"aXtraExtra\": None, # Additional values to add to aXtraGrid\n", - " # Transition matrix simulation parameters\n", - " \"mCount\": 200,\n", - " \"mMax\": 2000,\n", - " \"mMin\": 0.0001,\n", - " \"mFac\": 3,\n", - "}" + "HANK_Dict = deepcopy(init_newkeynesian)\n", + "HANK_Dict.update(\n", + " {\n", + " # Preferences (CRRA=1 matches KS 1998)\n", + " \"CRRA\": calibration[\"eis\"],\n", + " \"DiscFac\": 0.98,\n", + " \"LivPrb\": [0.99375],\n", + " # Income process — simplified: no unemployment (KS 1998 has 4–10%)\n", + " \"UnempPrb\": 0.0,\n", + " \"IncUnemp\": 0.0,\n", + " \"PermShkStd\": [0.06],\n", + " \"TranShkStd\": [0.2],\n", + " # Equilibrium prices from calibration\n", + " \"Rfree\": [(1 + r_ss)],\n", + " \"wage\": [w_ss],\n", + " \"labor\": [L_ss],\n", + " # Wider grid for KS wealth distribution\n", + " \"aXtraMin\": 0.0001,\n", + " \"aXtraMax\": 2000,\n", + " \"aXtraCount\": 200,\n", + " \"mMin\": 0.0001,\n", + " \"mMax\": 2000,\n", + " }\n", + ")" ] }, { @@ -295,7 +285,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Steady state agent asset supply for beta = 0.98 is: 0.231\n" @@ -324,7 +313,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Time taken to solve for steady state 12.110 secs.\n" @@ -384,7 +372,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Final goods clearing: 0.019151809710783327\n", @@ -424,7 +411,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Time taken to compute wage Jacobians: 4.183 seconds\n" @@ -452,7 +438,6 @@ "
" ] }, - "metadata": {}, "output_type": "display_data" } ], @@ -477,7 +462,6 @@ "metadata": {}, "outputs": [ { - "name": "stdout", "output_type": "stream", "text": [ "Time taken to compute return factor Jacobians: 4.376 seconds\n" @@ -515,7 +499,6 @@ "
" ] }, - "metadata": {}, "output_type": "display_data" } ], @@ -694,7 +677,6 @@ "
" ] }, - "metadata": {}, "output_type": "display_data" } ], @@ -735,7 +717,6 @@ "
" ] }, - "metadata": {}, "output_type": "display_data" } ], diff --git a/examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb b/examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb index ca222d403..6d8770739 100644 --- a/examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb +++ b/examples/SequenceSpaceJacobians/Transition_Matrix_Example.ipynb @@ -46,13 +46,20 @@ " ([Auclert, Bardóczy, Rognlie, and Straub, 2021](https://doi.org/10.3982/ECTA17434))\n", " — and compare TM and MC performance.\n", "\n", - "The three key HARK methods used throughout are:\n", + "The three key HARK **legacy** methods used throughout are:\n", "\n", "- `define_distribution_grid()` — constructs the discretised state-space grid\n", "- `calc_transition_matrix()` — builds the Markov transition matrix from\n", " the solved policy functions\n", "- `calc_ergodic_dist()` — finds the stationary distribution (left\n", - " eigenvector associated with eigenvalue 1)" + " eigenvector associated with eigenvalue 1)\n", + "\n", + "Throughout each section, companion cells marked **\"New API\"** demonstrate\n", + "the equivalent workflow using HARK's new general-purpose `AgentSimulator`\n", + "(accessed via `initialize_sym()` / `_simulator`), which replaces the above\n", + "methods with a model-file-driven approach. See the\n", + "[Appendix](#Appendix:-Legacy-to-New-API-Migration-Guide) for a full mapping\n", + "table." ] }, { @@ -65,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 1, "id": "1f08d05f", "metadata": { "execution": { @@ -79,7 +86,15 @@ }, "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" + ] + } + ], "source": [ "import gc\n", "import time\n", @@ -277,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, "id": "0dc82f9b", "metadata": { "execution": { @@ -312,7 +327,7 @@ " \"UnempPrbRet\": 0.0005,\n", " # --- Simulation ---\n", " \"AgentCount\": 200000,\n", - " \"T_sim\": 1100,\n", + " \"T_sim\": 2000,\n", " \"pLogInitStd\": 0.4, # initial pLvl dispersion (cstwMPC life-cycle, SCF young households)\n", " \"pLogInitMean\": -0.5 * 0.4**2, # Jensen correction so E[pLvl] = 1.0\n", " \"pLvlInitCount\": 25, # discretization of newborn pLvl (default 15 is adequate but 25 is smoother)\n", @@ -376,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "fae48368", "metadata": { "execution": { @@ -429,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "id": "749d88aa", "metadata": { "execution": { @@ -506,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "74c568e6", "metadata": { "execution": { @@ -527,9 +542,9 @@ "text": [ "Grid: 100 m-points × 221 p-points = 22100 states\n", " define_distribution_grid : 0.00s\n", - " calc_transition_matrix : 3.95s\n", - " calc_ergodic_dist : 9.38s\n", - " Total : 13.33s\n" + " calc_transition_matrix : 3.05s\n", + " calc_ergodic_dist : 9.04s\n", + " Total : 12.09s\n" ] } ], @@ -567,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "id": "cf241bb0", "metadata": { "execution": { @@ -604,7 +619,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "id": "4508692e", "metadata": { "execution": { @@ -624,9 +639,9 @@ "output_type": "stream", "text": [ "TranMatrix Assets = [3.02317438]\n", - "Simulated Assets = 2.983934193698284\n", + "Simulated Assets = 2.99749135938871\n", "TranMatrix Consumption = [1.03017046]\n", - "Simulated Consumption = 1.0289881756626327\n" + "Simulated Consumption = 1.031205994813632\n" ] } ], @@ -638,6 +653,107 @@ "print(\"Simulated Consumption = \" + str(Monte_Carlo_Consumption))" ] }, + { + "cell_type": "markdown", + "id": "a0e0ad3c", + "metadata": {}, + "source": [ + "### New API: Transition matrices via `AgentSimulator`\n", + "\n", + "HARK's new simulation system provides a general-purpose `AgentSimulator` class\n", + "(in `HARK.simulator`) that can build transition matrices directly from a\n", + "model specification file, without relying on hand-coded methods like\n", + "`define_distribution_grid()` and `calc_transition_matrix()`.\n", + "\n", + "The workflow is:\n", + "1. `agent.initialize_sym()` — parses the YAML model file and creates an\n", + " `AgentSimulator` in `agent._simulator`\n", + "2. `agent._simulator.make_transition_matrices(grid_specs)` — builds the\n", + " transition matrix from the solved policy functions\n", + "3. `agent._simulator.find_steady_state()` — computes the ergodic distribution\n", + "4. `agent._simulator.get_long_run_average(var)` — returns a population average\n", + "\n", + "The `grid_specs` dictionary replaces the old `define_distribution_grid()`\n", + "parameters. Each key names a model variable and maps to a dict with `min`,\n", + "`max`, `N`, and optionally `order` (for polynomial spacing)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "35598797", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== New AgentSimulator API (2D grid, no Harmenberg) ===\n", + " make_transition_matrices : 6.92s\n", + " find_steady_state : 5.35s\n", + " Total : 12.27s\n", + "\n", + " AgentSimulator Assets = 3.772259\n", + " Legacy TM Assets = 3.023174\n", + " AgentSimulator Cons = 1.050668\n", + " Legacy TM Cons = 1.030170\n", + "\n", + "NOTE: Differences are expected — the two systems use different grid\n", + "construction methods (uniform vs exponential spacing). The 2D case\n", + "is particularly sensitive to grid design. The Harmenberg 1D case\n", + "below provides a fairer comparison.\n" + ] + } + ], + "source": [ + "t0_new = time.time()\n", + "\n", + "# The new simulator only knows variables from the YAML model file.\n", + "# Save and restore legacy track_vars around the initialize_sym() call.\n", + "_saved_track_vars = example1.track_vars[:]\n", + "example1.track_vars = [\"cNrm\", \"aNrm\", \"mNrm\", \"pLvl\"]\n", + "example1.initialize_sym()\n", + "example1.track_vars = _saved_track_vars\n", + "X = example1._simulator\n", + "\n", + "n_m_2d = len(example1.dist_mGrid)\n", + "n_p_2d = len(example1.dist_pGrid)\n", + "\n", + "# Use the legacy double-exponential grids via the \"grid\" key so the two\n", + "# systems share the same state-space discretisation. The polynomial grids\n", + "# produced by make_exponential_grid (order=2-3) lack resolution near the\n", + "# borrowing constraint (mNrm ≈ 1), which matters for the density spike.\n", + "grid_specs_2d = {\n", + " \"kNrm\": {\"grid\": example1.dist_mGrid},\n", + " \"pLvlPrev\": {\"grid\": example1.dist_pGrid},\n", + " \"mNrm\": {\"grid\": example1.dist_mGrid},\n", + " \"cNrm\": {\"min\": 0.0, \"max\": 5.0, \"N\": n_m_2d, \"order\": 3},\n", + " \"aNrm\": {\"grid\": example1.dist_mGrid},\n", + "}\n", + "X.make_transition_matrices(grid_specs_2d)\n", + "t1_new = time.time()\n", + "\n", + "X.find_steady_state()\n", + "t2_new = time.time()\n", + "\n", + "AggA_new = X.get_long_run_average(\"aNrm\")\n", + "AggC_new = X.get_long_run_average(\"cNrm\")\n", + "\n", + "print(\"=== New AgentSimulator API (2D grid, no Harmenberg) ===\")\n", + "print(f\" make_transition_matrices : {t1_new - t0_new:6.2f}s\")\n", + "print(f\" find_steady_state : {t2_new - t1_new:6.2f}s\")\n", + "print(f\" Total : {t2_new - t0_new:6.2f}s\")\n", + "print()\n", + "print(f\" AgentSimulator Assets = {AggA_new:.6f}\")\n", + "print(f\" Legacy TM Assets = {float(np.asarray(AggA).flat[0]):.6f}\")\n", + "print(f\" AgentSimulator Cons = {AggC_new:.6f}\")\n", + "print(f\" Legacy TM Cons = {float(np.asarray(AggC).flat[0]):.6f}\")\n", + "print()\n", + "print(\"NOTE: Both systems now share the same double-exponential grids,\")\n", + "print(\"so remaining differences reflect the transition-matrix construction\")\n", + "print(\"method itself (legacy column-stochastic vs new row-stochastic).\")" + ] + }, { "cell_type": "markdown", "id": "5e99ab28", @@ -655,7 +771,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "4caa59e3", "metadata": { "execution": { @@ -674,7 +790,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "MC aggregate assets: mean = 2.988310, std = 0.006986, SE = 0.000016\n" + "MC aggregate assets: mean = 2.989454, std = 0.011324, SE = 0.000025\n" ] } ], @@ -698,7 +814,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "id": "ae083acc", "metadata": { "execution": { @@ -715,7 +831,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -752,6 +868,7 @@ ")\n", "plt.ylabel(\"Aggregate Assets\")\n", "plt.xlabel(\"Period (after burn-in)\")\n", + "plt.ylim(top=3.04)\n", "plt.legend()\n", "plt.title(\"MC vs Transition Matrix: Aggregate Asset Paths\")\n", "plt.tight_layout()\n", @@ -780,7 +897,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "a98e8760", "metadata": { "execution": { @@ -799,10 +916,10 @@ "output_type": "stream", "text": [ "MSE decomposition (aggregate assets):\n", - " MC — Bias² = 0 (by construction), Variance = 4.88e-05, MSE = 4.88e-05\n", - " TM — Bias² = 1.22e-03 (bias = 0.034865), Variance = 0, MSE = 1.22e-03\n", + " MC — Bias² = 0 (by construction), Variance = 1.28e-04, MSE = 1.28e-04\n", + " TM — Bias² = 1.14e-03 (bias = 0.033721), Variance = 0, MSE = 1.14e-03\n", "\n", - " → MC has lower MSE here (4.88e-05 < 1.22e-03).\n", + " → MC has lower MSE here (1.28e-04 < 1.14e-03).\n", " Increasing TM grid points would reduce TM bias (see Harmenberg section below).\n" ] } @@ -831,6 +948,62 @@ " print(\" Increasing MC agent count would reduce MC variance.\")" ] }, + { + "cell_type": "markdown", + "id": "0d12cb65", + "metadata": {}, + "source": [ + "### New API: Monte Carlo via `symulate()`\n", + "\n", + "The new simulation system replaces `initialize_sim()` / `simulate()` with\n", + "`initialize_sym()` / `symulate()`. Results are stored in the `hystory`\n", + "attribute (note the spelling) rather than `history`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "90ba3dcb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== New symulate() MC simulation ===\n", + " Time: 62.78s (200,000 agents, 2000 periods)\n", + " Mean assets (post burn-in): 2.983166\n", + " Legacy MC mean assets: 2.997491\n" + ] + } + ], + "source": [ + "example1_new = NewKeynesianConsumerType(**Dict)\n", + "example1_new.solve()\n", + "example1_new.track_vars = [\"cNrm\", \"aNrm\", \"mNrm\", \"pLvl\"]\n", + "example1_new.T_sim = 2000\n", + "example1_new.AgentCount = 200000\n", + "\n", + "t0_mc_new = time.time()\n", + "example1_new.initialize_sym()\n", + "example1_new.symulate()\n", + "t1_mc_new = time.time()\n", + "\n", + "aLvls_new = np.array(\n", + " [\n", + " np.mean(example1_new.hystory[\"aNrm\"][i] * example1_new.hystory[\"pLvl\"][i])\n", + " for i in range(example1_new.T_sim)\n", + " ]\n", + ")\n", + "\n", + "print(\"=== New symulate() MC simulation ===\")\n", + "print(\n", + " f\" Time: {t1_mc_new - t0_mc_new:.2f}s ({example1_new.AgentCount:,} agents, {example1_new.T_sim} periods)\"\n", + ")\n", + "print(f\" Mean assets (post burn-in): {np.mean(aLvls_new[BURNIN:]):.6f}\")\n", + "print(f\" Legacy MC mean assets: {Monte_Carlo_Assets:.6f}\")" + ] + }, { "cell_type": "markdown", "id": "5a6e0f6e", @@ -849,7 +1022,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "32250b58", "metadata": { "execution": { @@ -866,9 +1039,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -919,7 +1092,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "f5c5a54f", "metadata": { "execution": { @@ -936,9 +1109,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -992,7 +1165,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "3f93f08e", "metadata": { "execution": { @@ -1011,7 +1184,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "id": "f591cffb", "metadata": { "execution": { @@ -1028,7 +1201,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "id": "9c6867ee", "metadata": { "execution": { @@ -1045,9 +1218,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1102,7 +1275,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "id": "5d31a147", "metadata": { "execution": { @@ -1125,9 +1298,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1182,6 +1355,109 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "ae7baf58", + "metadata": {}, + "source": [ + "### New API: Extracting distributions from `AgentSimulator`\n", + "\n", + "The new API stores the ergodic distribution as a flat vector in\n", + "`_simulator.steady_state_dstn`, with state grid points in\n", + "`_simulator.state_grids[0]`. Outcome distributions are obtained via the\n", + "projection matrices in `_simulator.outcome_arrays` and corresponding grids\n", + "in `_simulator.outcome_grids`.\n", + "\n", + "The cell below extracts the marginal distribution of normalized market\n", + "resources from the new API and compares it to the legacy result." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f8f040cd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean mNrm — Legacy TM: 4.7762, AgentSimulator: 4.8229\n" + ] + } + ], + "source": [ + "# [dist_new_api_market_resources] Distribution of mNrm via AgentSimulator\n", + "# The steady-state distribution over the (kNrm, pLvlPrev) arrival state space\n", + "# is stored as a flat vector. To get the marginal over mNrm (an outcome\n", + "# variable), multiply the state distribution by the outcome projection matrix.\n", + "\n", + "ss_dstn_2d = X.steady_state_dstn\n", + "mNrm_proj = X.outcome_arrays[0][\"mNrm\"]\n", + "mNrm_grid_new = X.outcome_grids[0][\"mNrm\"]\n", + "\n", + "# Marginal PMF of mNrm from the new API\n", + "mNrm_pmf_new = np.dot(ss_dstn_2d, mNrm_proj)\n", + "\n", + "# Convert PMF to density (divide by bin widths) — matching the approach in\n", + "# [dist_normalized_market_resources] — so the two grids are visually comparable.\n", + "m_mids_new = 0.5 * (mNrm_grid_new[:-1] + mNrm_grid_new[1:])\n", + "m_bin_edges_new = np.concatenate([[mNrm_grid_new[0]], m_mids_new, [mNrm_grid_new[-1]]])\n", + "new_density = mNrm_pmf_new / np.diff(m_bin_edges_new)\n", + "\n", + "# Legacy marginal — same density conversion as cell [dist_normalized_market_resources]\n", + "m_grid_old = example1.dist_mGrid\n", + "mdstn_old = example1.erg_dstn.sum(axis=1)\n", + "m_mids_old = 0.5 * (m_grid_old[:-1] + m_grid_old[1:])\n", + "m_bin_edges_old = np.concatenate([[m_grid_old[0]], m_mids_old, [m_grid_old[-1]]])\n", + "old_density = mdstn_old / np.diff(m_bin_edges_old)\n", + "\n", + "plt.figure(figsize=(14, 6))\n", + "plt.plot(\n", + " m_grid_old,\n", + " old_density,\n", + " label=\"Legacy TM (erg_dstn marginal)\",\n", + " color=COLOR_TM,\n", + " linewidth=2,\n", + ")\n", + "plt.plot(\n", + " mNrm_grid_new,\n", + " new_density,\n", + " \"--\",\n", + " label=\"AgentSimulator (outcome projection)\",\n", + " color=\"tab:green\",\n", + " linewidth=2,\n", + ")\n", + "plt.ylabel(\"Probability Density\")\n", + "plt.xlabel(\"Normalized Market Resources\")\n", + "plt.title(\"Marginal Distribution of mNrm: Legacy TM vs AgentSimulator\")\n", + "plt.legend()\n", + "plt.xlim([0, 10])\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Quantitative comparison\n", + "mean_m_old = np.dot(mdstn_old, m_grid_old)\n", + "mean_m_new = np.dot(mNrm_pmf_new, mNrm_grid_new)\n", + "print(f\"Mean mNrm — Legacy TM: {mean_m_old:.4f}, AgentSimulator: {mean_m_new:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "89509ac7", + "metadata": {}, + "source": [] + }, { "cell_type": "markdown", "id": "5405776d", @@ -1277,7 +1553,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "582ea2c9", "metadata": { "execution": { @@ -1323,7 +1599,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "68d37656", "metadata": { "execution": { @@ -1357,7 +1633,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "357c1baf", "metadata": { "execution": { @@ -1378,9 +1654,9 @@ "text": [ "With Harmenberg neutral measure (1000 m-points, 1D grid):\n", " define_distribution_grid : 0.00s\n", - " calc_transition_matrix : 2.42s\n", - " calc_ergodic_dist : 0.02s\n", - " Total : 2.44s\n" + " calc_transition_matrix : 1.98s\n", + " calc_ergodic_dist : 0.01s\n", + " Total : 1.99s\n" ] } ], @@ -1422,7 +1698,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "id": "bfc3fe24", "metadata": { "execution": { @@ -1439,7 +1715,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1488,7 +1764,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "id": "bb5383de", "metadata": { "execution": { @@ -1531,7 +1807,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "id": "90ff7aad", "metadata": { "execution": { @@ -1548,7 +1824,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1589,7 +1865,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "id": "a71eeaa5", "metadata": { "execution": { @@ -1622,6 +1898,76 @@ " print(\" OK: tail is well-resolved.\")" ] }, + { + "cell_type": "markdown", + "id": "ca820c58", + "metadata": {}, + "source": [ + "### New API: Harmenberg via `norm=\"PermShk\"`\n", + "\n", + "In the new `AgentSimulator`, the Harmenberg neutral measure is activated by\n", + "passing `norm=\"PermShk\"` to `make_transition_matrices()`. This replaces the\n", + "legacy pattern of setting `neutral_measure = True` and calling\n", + "`update_income_process()`. The permanent income dimension is automatically\n", + "collapsed, so the grid specification only needs to include `kNrm` (the\n", + "arrival variable) and any outcome variables of interest." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "1fbca016", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== New AgentSimulator API (Harmenberg, 1D grid) ===\n", + " make_transition_matrices : 0.03s\n", + " find_steady_state : 0.02s\n", + " Total : 0.04s\n", + "\n", + " AgentSimulator Assets = 2.606360\n", + " Legacy Harmenberg = 2.986742\n", + " AgentSimulator Cons = 1.020488\n" + ] + } + ], + "source": [ + "t0_harm_new = time.time()\n", + "\n", + "_saved_track_vars_ss = ss.track_vars[:]\n", + "ss.track_vars = [\"cNrm\", \"aNrm\", \"mNrm\", \"pLvl\"]\n", + "ss.initialize_sym()\n", + "ss.track_vars = _saved_track_vars_ss\n", + "X_harm = ss._simulator\n", + "\n", + "n_m_harm_new = ss.mCount\n", + "grid_specs_harm = {\n", + " \"kNrm\": {\"grid\": ss.dist_mGrid},\n", + " \"cNrm\": {\"min\": 0.0, \"max\": 5.0, \"N\": n_m_harm_new, \"order\": 3},\n", + " \"aNrm\": {\"grid\": ss.dist_mGrid},\n", + "}\n", + "X_harm.make_transition_matrices(grid_specs_harm, norm=\"PermShk\")\n", + "t1_harm_new = time.time()\n", + "\n", + "X_harm.find_steady_state()\n", + "t2_harm_new = time.time()\n", + "\n", + "AggA_harm_new = X_harm.get_long_run_average(\"aNrm\")\n", + "AggC_harm_new = X_harm.get_long_run_average(\"cNrm\")\n", + "\n", + "print(\"=== New AgentSimulator API (Harmenberg, 1D grid) ===\")\n", + "print(f\" make_transition_matrices : {t1_harm_new - t0_harm_new:6.2f}s\")\n", + "print(f\" find_steady_state : {t2_harm_new - t1_harm_new:6.2f}s\")\n", + "print(f\" Total : {t2_harm_new - t0_harm_new:6.2f}s\")\n", + "print()\n", + "print(f\" AgentSimulator Assets = {AggA_harm_new:.6f}\")\n", + "print(f\" Legacy Harmenberg = {float(np.asarray(AggA_fast).flat[0]):.6f}\")\n", + "print(f\" AgentSimulator Cons = {AggC_harm_new:.6f}\")" + ] + }, { "cell_type": "markdown", "id": "41a60d94", @@ -1672,7 +2018,7 @@ "outputs": [], "source": [ "ss.AgentCount = 200000\n", - "ss.T_sim = 1100\n", + "ss.T_sim = 2000\n", "ss.initialize_sim()\n", "ss.simulate()" ] @@ -1768,7 +2114,15 @@ }, "lines_to_next_cell": 2 }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R_ss = 1.016352, dx = -0.01, R at t=100: 1.006352\n" + ] + } + ], "source": [ "# Interest-rate path is set by create_finite_horizon_agent:\n", "# R_ss in all periods except shock_t, where R_ss + dx applies.\n", @@ -1810,7 +2164,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "FinHorizonAgent.solve: 0.12s (200 periods)\n" + "FinHorizonAgent.solve: 0.11s (200 periods)\n" ] } ], @@ -1852,7 +2206,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "MC simulation: 15.27s (400,000 agents, 200 periods)\n" + "MC simulation: 13.23s (400,000 agents, 200 periods)\n" ] } ], @@ -1895,6 +2249,63 @@ " alvl.append(np.mean(FinHorizonAgent.history[\"aNrm\"][i, :]))" ] }, + { + "cell_type": "markdown", + "id": "9679106a", + "metadata": {}, + "source": [ + "### New API: Finite-horizon MC via `symulate()`\n", + "\n", + "The new simulation system handles finite-horizon (lifecycle) agents\n", + "automatically when `cycles > 0`. Unlike the legacy system, there is no\n", + "need for the `PerfMITShk` flag — the simulator reads the period-specific\n", + "policy functions directly from the solution sequence." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "7fd1a3f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New symulate() MC: 17.24s (200,000 agents, 200 periods)\n" + ] + } + ], + "source": [ + "FinHorizonAgent_new = create_finite_horizon_agent(\n", + " ss, Dict, T_cycle, shock_t, dx, orig_IncShkDstn\n", + ")\n", + "FinHorizonAgent_new.solve(presolve=False)\n", + "FinHorizonAgent_new.track_vars = [\"cNrm\", \"pLvl\", \"aNrm\"]\n", + "FinHorizonAgent_new.T_sim = T_cycle\n", + "FinHorizonAgent_new.AgentCount = 200000\n", + "\n", + "_t = time.time()\n", + "FinHorizonAgent_new.initialize_sym(stop_dead=False)\n", + "FinHorizonAgent_new.symulate()\n", + "timings[\"fin_mc_new\"] = time.time() - _t\n", + "\n", + "AggC_mc_new = np.array(\n", + " [\n", + " np.dot(\n", + " FinHorizonAgent_new.hystory[\"cNrm\"][i],\n", + " FinHorizonAgent_new.hystory[\"pLvl\"][i],\n", + " )\n", + " / FinHorizonAgent_new.AgentCount\n", + " for i in range(T_cycle)\n", + " ]\n", + ")\n", + "\n", + "print(\n", + " f\"New symulate() MC: {timings['fin_mc_new']:.2f}s ({FinHorizonAgent_new.AgentCount:,} agents, {T_cycle} periods)\"\n", + ")" + ] + }, { "cell_type": "markdown", "id": "05277961", @@ -1952,7 +2363,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "id": "0b054e97", "metadata": { "execution": { @@ -1971,8 +2382,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "calc_transition_matrix: 0.78s (200 matrices)\n", - "Sparse conversion: 1.38s\n", + "calc_transition_matrix: 0.99s (200 matrices)\n", + "Sparse conversion: 2.19s\n", " 1526 MB -> 98.0 MB (16x reduction)\n" ] } @@ -2033,7 +2444,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "id": "b93cddbd", "metadata": { "execution": { @@ -2089,6 +2500,68 @@ "print(f\"Forward propagation: {timings['fwd_prop']:.2f}s ({T_cycle} periods)\")" ] }, + { + "cell_type": "markdown", + "id": "a7d53711", + "metadata": {}, + "source": [ + "### New API: Forward propagation via `simulate_cohort_by_grids()`\n", + "\n", + "The new `AgentSimulator` provides `simulate_cohort_by_grids()` as a\n", + "one-call replacement for the manual loop that multiplies transition matrices\n", + "by the state distribution. It takes the outcome variable names and an\n", + "optional initial distribution, and stores the resulting time series of\n", + "averages in `_simulator.history_avg`." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "a685a0d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New AgentSimulator forward propagation: 7.28s (200 periods)\n", + " Max |C_old - C_new|: 1.31e-02\n", + " Max |A_old - A_new|: 3.80e-01\n" + ] + } + ], + "source": [ + "_t = time.time()\n", + "\n", + "_saved_tv_fin = FinHorizonAgent.track_vars[:]\n", + "FinHorizonAgent.track_vars = [\"cNrm\", \"aNrm\", \"mNrm\", \"pLvl\"]\n", + "FinHorizonAgent.initialize_sym()\n", + "FinHorizonAgent.track_vars = _saved_tv_fin\n", + "X_fin = FinHorizonAgent._simulator\n", + "X_fin.make_transition_matrices(grid_specs_harm, norm=\"PermShk\")\n", + "\n", + "X_fin.simulate_cohort_by_grids(\n", + " [\"cNrm\", \"aNrm\"],\n", + " T_max=T_cycle,\n", + " calc_avg=True,\n", + " from_dstn=X_harm.steady_state_dstn,\n", + ")\n", + "timings[\"fin_tm_new\"] = time.time() - _t\n", + "\n", + "AggC_new_path = X_fin.history_avg[\"cNrm\"]\n", + "AggA_new_path = X_fin.history_avg[\"aNrm\"]\n", + "\n", + "print(\n", + " f\"New AgentSimulator forward propagation: {timings['fin_tm_new']:.2f}s ({T_cycle} periods)\"\n", + ")\n", + "print(\n", + " f\" Max |C_old - C_new|: {np.max(np.abs(np.array(AggC_fast) - AggC_new_path)):.2e}\"\n", + ")\n", + "print(\n", + " f\" Max |A_old - A_new|: {np.max(np.abs(np.array(AggA_fast) - AggA_new_path)):.2e}\"\n", + ")" + ] + }, { "cell_type": "markdown", "id": "edd797a5", @@ -2099,7 +2572,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 37, "id": "67c68171", "metadata": { "execution": { @@ -2116,7 +2589,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2169,7 +2642,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 38, "id": "00d8dc82", "metadata": { "execution": { @@ -2186,7 +2659,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2273,7 +2746,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 39, "id": "f661481a", "metadata": { "jupyter": { @@ -2283,7 +2756,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2333,7 +2806,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 40, "id": "630fe464", "metadata": { "jupyter": { @@ -2343,7 +2816,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2431,7 +2904,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 41, "id": "3b9abb28", "metadata": { "jupyter": { @@ -2448,12 +2921,12 @@ "============================================================\n", " SS model solve.................................... 0.00s\n", " SS transition matrix (1000 m-pts)................. 0.00s\n", - " Finite-horizon solve (200 periods)................ 0.12s\n", - " MC simulation (400,000 agents).................... 15.27s\n", - " Finite-horizon TMs (200 matrices)................. 0.78s\n", - " Dense -> sparse conversion........................ 1.38s\n", + " Finite-horizon solve (200 periods)................ 0.11s\n", + " MC simulation (400,000 agents).................... 13.23s\n", + " Finite-horizon TMs (200 matrices)................. 0.99s\n", + " Dense -> sparse conversion........................ 2.19s\n", " TM forward propagation (200 periods).............. 0.01s\n", - " TOTAL............................................. 17.56s\n" + " TOTAL............................................. 16.54s\n" ] } ], @@ -2555,6 +3028,45 @@ "metadata": {}, "source": [] }, + { + "cell_type": "markdown", + "id": "9aec2900", + "metadata": {}, + "source": [ + "## Appendix: Legacy-to-New API Migration Guide\n", + "\n", + "Throughout this notebook, the \"New API\" cells demonstrated the `AgentSimulator`\n", + "equivalents of the legacy transition-matrix methods. The table below\n", + "summarises the mapping.\n", + "\n", + "| Legacy method | New `AgentSimulator` equivalent |\n", + "|---|---|\n", + "| `define_distribution_grid()` | `grid_specs` dict passed to `make_transition_matrices()` |\n", + "| `calc_transition_matrix()` | `_simulator.make_transition_matrices(grid_specs)` |\n", + "| `calc_ergodic_dist()` | `_simulator.find_steady_state()` |\n", + "| `neutral_measure=True` + `update_income_process()` | `norm=\"PermShk\"` arg to `make_transition_matrices()` |\n", + "| `initialize_sim()` + `simulate()` | `initialize_sym()` + `symulate()` |\n", + "| `history` dict | `hystory` dict |\n", + "| `tran_matrix` | `_simulator.trans_arrays` |\n", + "| `vec_erg_dstn` | `_simulator.steady_state_dstn` |\n", + "| `cPol_Grid` / `aPol_Grid` | `_simulator.outcome_arrays` + `outcome_grids` |\n", + "| Manual forward-prop loop | `_simulator.simulate_cohort_by_grids()` |\n", + "| `calc_jacobian()` | `make_basic_SSJ()` (via `HARK.SSJutils`) |\n", + "\n", + "**Key advantages of the new system:**\n", + "\n", + "- **General-purpose:** Works with any `AgentType` that has a YAML model file,\n", + " not just `NewKeynesianConsumerType`.\n", + "- **Declarative grids:** Grid specifications are plain dictionaries rather than\n", + " method arguments, making them easier to modify and pass around.\n", + "- **Harmenberg built in:** The neutral measure is a single argument (`norm`)\n", + " rather than requiring manual income-process manipulation.\n", + "- **One-call forward propagation:** `simulate_cohort_by_grids()` replaces\n", + " hand-written matrix-vector loops.\n", + "- **Model introspection:** `_simulator.describe()` shows the full parsed model\n", + " structure, including variable roles and dynamics." + ] + }, { "cell_type": "markdown", "id": "8d5f9740", @@ -2607,7 +3119,7 @@ "formats": "ipynb,py:percent" }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" },