Repository: econ-ark/HARK

Issue:
Default's for MarkovConsumerType don't work.
**Describe the bug**
The default constructor for the income distributions for MarkovConsumerType don't create unique distributions for each state, leading HARK to throw an error.

**To Reproduce**
Run:

from HARK.ConsumptionSaving.ConsMarkovModel import MarkovConsumerType
MarkovExample = MarkovConsumerType()
MarkovExample.solve()

**Expected behavior**
The model should solve without issue.

Error message:
File ~\Desktop\Econ Ark Work\HARK\HARK\ConsumptionSaving\ConsMarkovModel.py:821, in MarkovConsumerType.check_markov_inputs(self)
      [819] for IncShkDstn_t in self.IncShkDstn:
      [820]     if not isinstance(IncShkDstn_t, list):
--> [821]         raise ValueError(
      [822]             "self.IncShkDstn is time varying and so must be a list"
      [823]             + "of lists of Distributions, one per Markov State. Found "
      [824]             + f"{self.IncShkDstn} instead"
      [825]         )
      [826]     elif len(IncShkDstn_t) != StateCount:
      [827]         raise ValueError(
      [828]             "List in IncShkDstn is not the right length, it should be length equal to number of states"
      [829]         )

ValueError: self.IncShkDstn is time varying and so must be a listof lists of Distributions, one per Markov State. Found <HARK.distribution.IndexDistribution object at 0x00000244DDBA7AD0> instead

Hints from issue comments:
@DominicWC: Markov Consumer Type also doesn't accept a time-varying Rfree like most other models do.@akshayshanker: Issue [https://github.com/econ-ark/HARK/pull/1484](https://github.com/econ-ark/HARK/pull/1484) is now closed and merged. @mnwhite @DominicWC,  I am closing this issue. 


Solution patch:
diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md
index bbc87c01..4584159f 100644
--- a/Documentation/CHANGELOG.md
+++ b/Documentation/CHANGELOG.md
@@ -26,9 +26,11 @@ Release Date: TBD
 - Fixes bug in `AgentPopulation` that caused discretization of distributions to not work. [1275](https://github.com/econ-ark/HARK/pull/1275)
 - Adds support for distributions, booleans, and callables as parameters in the `Parameters` class. [1387](https://github.com/econ-ark/HARK/pull/1387)
 - Removes a specific way of accounting for ``employment'' in the idiosyncratic-shocks income process. [1473](https://github.com/econ-ark/HARK/pull/1473)
+- Adds income process constructor for the discrete Markov state consumption-saving model. [1484](https://github.com/econ-ark/HARK/pull/1484)
 - Changes the behavior of make_lognormal_RiskyDstn so that the standard deviation represents the standard deviation of log(returns)
 - Adds detailed parameter and latex documentation to most models.
 - Add PermGroFac constructor that explicitly combines idiosyncratic and aggregate sources of growth. [1489](https://github.com/econ-ark/HARK/pull/1489)
+- Fixes typos in IdentityFunction interpolator class. [1492](https://github.com/econ-ark/HARK/pull/1492)
 
 ### 0.15.1
 
diff --git a/HARK/Calibration/Income/IncomeProcesses.py b/HARK/Calibration/Income/IncomeProcesses.py
index 5bfa22c9..6025869e 100644
--- a/HARK/Calibration/Income/IncomeProcesses.py
+++ b/HARK/Calibration/Income/IncomeProcesses.py
@@ -462,6 +462,189 @@ def construct_lognormal_income_process_unemployment(
     return IncShkDstn
 
 
+def construct_markov_lognormal_income_process_unemployment(
+    T_cycle,
+    PermShkStd,
+    PermShkCount,
+    TranShkStd,
+    TranShkCount,
+    T_retire,
+    UnempPrb,
+    IncUnemp,
+    UnempPrbRet,
+    IncUnempRet,
+    RNG,
+    neutral_measure=False,
+):
+    """
+    Generates a nested list of discrete approximations to the income process for each
+    life period, from end of life to beginning of life, for each discrete Markov
+    state in the problem. This function calls construct_lognormal_income_process_unemployment
+    for each Markov state, then rearranges the output. Permanent shocks are mean
+    one lognormally distributed with standard deviation PermShkStd[t] during the
+    working life, and degenerate at 1 in the retirement period.  Transitory shocks
+    are mean one lognormally distributed with a point mass at IncUnemp with
+    probability UnempPrb while working; they are mean one with a point mass at
+    IncUnempRet with probability UnempPrbRet.  Retirement occurs after t=T_retire
+    periods of working. The problem is specified as having T=T_cycle periods and
+    K discrete Markov states.
+
+    Parameters
+    ----------
+    PermShkStd : np.array
+        2D array of shape (T,K) of standard deviations of log permanent income
+        uncertainty during the agent's life.
+    PermShkCount : int
+        The number of approximation points to be used in the discrete approxima-
+        tion to the permanent income shock distribution.
+    TranShkStd : np.array
+        2D array of shape (T,K) standard deviations in log transitory income
+        uncertainty during the agent's life.
+    TranShkCount : int
+        The number of approximation points to be used in the discrete approxima-
+        tion to the permanent income shock distribution.
+    UnempPrb : np.array
+        1D or 2D array of the probability of becoming unemployed during the working
+        portion of the agent's life. If 1D, it should be size K, providing one
+        unemployment probability per discrete Markov state. If 2D, it should be
+        shape (T,K).
+    UnempPrbRet : np.array or None
+        The probability of not receiving typical retirement income when retired.
+        If not None, should be size K. Can be set to None when T_retire is 0.
+    T_retire : int
+        The index value for the final working period in the agent's life.
+        If T_retire <= 0 then there is no retirement.
+    IncUnemp : np.array
+        1D or 2D array of transitory income received when unemployed during the
+        working portion of the agent's life. If 1D, it should be size K, providing
+        one unemployment probability per discrete Markov state. If 2D, it should be
+        shape (T,K).
+    IncUnempRet : np.array or None
+        Transitory income received while "unemployed" when retired. If provided,
+        should be size K. Can be None when T_retire is 0.
+    T_cycle :  int
+        Total number of non-terminal periods in the consumer's sequence of periods.
+    RNG : np.random.RandomState
+        Random number generator for this type.
+    neutral_measure : bool
+        Indicator for whether the permanent-income-neutral measure should be used.
+
+    Returns
+    -------
+    IncShkDstn : [[distribution.Distribution]]
+        A list with T_cycle elements, each of which is a discrete approximation
+        to the income process in a period.
+    """
+    if T_retire > 0:
+        normal_length = T_retire
+        retire_length = T_cycle - T_retire
+    else:
+        normal_length = T_cycle
+        retire_length = 0
+
+    # Check dimensions of inputs
+    try:
+        PermShkStd_K = PermShkStd.shape[1]
+        TranShkStd_K = TranShkStd.shape[1]
+        if UnempPrb.ndim == 2:
+            UnempPrb_K = UnempPrb.shape[1]
+        else:
+            UnempPrb_K = UnempPrb.shape[0]
+        if IncUnemp.ndim == 2:
+            IncUnemp_K = IncUnemp.shape[1]
+        else:
+            IncUnemp_K = IncUnemp.shape[0]
+        K = PermShkStd_K
+        assert K == TranShkStd_K
+        assert K == TranShkStd_K
+        assert K == UnempPrb_K
+        assert K == IncUnemp_K
+    except:
+        raise Exception(
+            "The last dimension of PermShkStd, TranShkStd, IncUnemp,"
+            + " and UnempPrb must all be K, the number of discrete states."
+        )
+    try:
+        if T_retire > 0:
+            assert K == UnempPrbRet.size
+            assert K == IncUnempRet.size
+    except:
+        raise Exception(
+            "When T_retire is not zero, UnempPrbRet and IncUnempRet"
+            + " must be specified as arrays of size K, the number of "
+            + "discrete Markov states."
+        )
+    try:
+        D = UnempPrb.ndim
+        assert D == IncUnemp.ndim
+        if T_retire > 0:
+            assert D == UnempPrbRet.ndim
+            assert D == IncUnempRet.ndim
+    except:
+        raise Exception(
+            "If any of UnempPrb, IncUnemp, or UnempPrbRet, or IncUnempRet "
+            + "are 2D arrays, then they must *all* be 2D arrays."
+        )
+    try:
+        assert D == 1 or D == 2
+    except:
+        raise Exception(
+            "UnempPrb, IncUnemp, or UnempPrbRet, or IncUnempRet must "
+            + "all be 1D or 2D arrays."
+        )
+
+    # Prepare lists that don't vary by Markov state
+    PermShkCount_list = [PermShkCount] * normal_length + [1] * retire_length
+    TranShkCount_list = [TranShkCount] * normal_length + [1] * retire_length
+    neutral_measure_list = [neutral_measure] * len(PermShkCount_list)
+
+    # Loop through the Markov states, constructing the lifecycle income process for each one
+    IncShkDstn_by_Mrkv = []
+    for k in range(K):
+        if D == 1:  # Unemployment parameters don't vary by age other than retirement
+            if T_retire > 0:
+                UnempPrb_list = [UnempPrb[k]] * normal_length + [
+                    UnempPrbRet[k]
+                ] * retire_length
+                IncUnemp_list = [IncUnemp[k]] * normal_length + [
+                    IncUnempRet[k]
+                ] * retire_length
+            else:
+                UnempPrb_list = [UnempPrb[k]] * normal_length
+                IncUnemp_list = [IncUnemp[k]] * normal_length
+        else:  # Unemployment parameters vary by age
+            UnempPrb_list = UnempPrb[:, k].tolist()
+            IncUnemp_list = IncUnemp[:, k].tolist()
+
+        PermShkStd_k = PermShkStd[:, k].tolist()
+        TranShkStd_k = TranShkStd[:, k].tolist()
+
+        IncShkDstn_k = IndexDistribution(
+            engine=BufferStockIncShkDstn,
+            conditional={
+                "sigma_Perm": PermShkStd_k,
+                "sigma_Tran": TranShkStd_k,
+                "n_approx_Perm": PermShkCount_list,
+                "n_approx_Tran": TranShkCount_list,
+                "neutral_measure": neutral_measure_list,
+                "UnempPrb": UnempPrb_list,
+                "IncUnemp": IncUnemp_list,
+            },
+            RNG=RNG,
+            seed=RNG.integers(0, 2**31 - 1),
+        )
+        IncShkDstn_by_Mrkv.append(IncShkDstn_k)
+
+    # Rearrange the list that was just constructed, so that element [t][k] represents
+    # the income shock distribution in period t, Markov state k.
+    IncShkDstn = []
+    for t in range(T_cycle):
+        IncShkDstn_t = [IncShkDstn_by_Mrkv[k][t] for k in range(K)]
+        IncShkDstn.append(IncShkDstn_t)
+
+    return IncShkDstn
+
+
 def construct_HANK_lognormal_income_process_unemployment(
     T_cycle,
     PermShkStd,
@@ -613,6 +796,28 @@ def get_TranShkDstn_from_IncShkDstn(IncShkDstn, RNG):
     return TimeVaryingDiscreteDistribution(TranShkDstn, seed=RNG.integers(0, 2**31 - 1))
 
 
+def get_PermShkDstn_from_IncShkDstn_markov(IncShkDstn, RNG):
+    PermShkDstn = [
+        [
+            this.make_univariate(0, seed=RNG.integers(0, 2**31 - 1))
+            for this in IncShkDstn_t
+        ]
+        for IncShkDstn_t in IncShkDstn
+    ]
+    return PermShkDstn
+
+
+def get_TranShkDstn_from_IncShkDstn_markov(IncShkDstn, RNG):
+    TranShkDstn = [
+        [
+            this.make_univariate(1, seed=RNG.integers(0, 2**31 - 1))
+            for this in IncShkDstn_t
+        ]
+        for IncShkDstn_t in IncShkDstn
+    ]
+    return TranShkDstn
+
+
 def get_TranShkGrid_from_TranShkDstn(T_cycle, TranShkDstn):
     TranShkGrid = [TranShkDstn[t].atoms.flatten() for t in range(T_cycle)]
     return TranShkGrid
diff --git a/HARK/ConsumptionSaving/ConsMarkovModel.py b/HARK/ConsumptionSaving/ConsMarkovModel.py
index 30edbf41..b9fb3818 100644
--- a/HARK/ConsumptionSaving/ConsMarkovModel.py
+++ b/HARK/ConsumptionSaving/ConsMarkovModel.py
@@ -9,9 +9,9 @@ import numpy as np
 
 from HARK import AgentType, NullFunc
 from HARK.Calibration.Income.IncomeProcesses import (
-    construct_lognormal_income_process_unemployment,
-    get_PermShkDstn_from_IncShkDstn,
-    get_TranShkDstn_from_IncShkDstn,
+    construct_markov_lognormal_income_process_unemployment,
+    get_PermShkDstn_from_IncShkDstn_markov,
+    get_TranShkDstn_from_IncShkDstn_markov,
 )
 from HARK.ConsumptionSaving.ConsIndShockModel import (
     ConsumerSolution,
@@ -657,9 +657,9 @@ def solve_one_period_ConsMarkov(
 
 # Make a dictionary of constructors for the markov consumption-saving model
 markov_constructor_dict = {
-    "IncShkDstn": construct_lognormal_income_process_unemployment,
-    "PermShkDstn": get_PermShkDstn_from_IncShkDstn,
-    "TranShkDstn": get_TranShkDstn_from_IncShkDstn,
+    "IncShkDstn": construct_markov_lognormal_income_process_unemployment,
+    "PermShkDstn": get_PermShkDstn_from_IncShkDstn_markov,
+    "TranShkDstn": get_TranShkDstn_from_IncShkDstn_markov,
     "aXtraGrid": make_assets_grid,
     "MrkvArray": make_simple_binary_markov,
     "solution_terminal": make_markov_solution_terminal,
@@ -667,15 +667,21 @@ markov_constructor_dict = {
 
 # Default parameters to make IncShkDstn using construct_lognormal_income_process_unemployment
 default_IncShkDstn_params = {
-    "PermShkStd": [0.1],  # Standard deviation of log permanent income shocks
+    "PermShkStd": np.array(
+        [[0.1, 0.1]]
+    ),  # Standard deviation of log permanent income shocks
     "PermShkCount": 7,  # Number of points in discrete approximation to permanent income shocks
-    "TranShkStd": [0.1],  # Standard deviation of log transitory income shocks
+    "TranShkStd": np.array(
+        [[0.1, 0.1]]
+    ),  # Standard deviation of log transitory income shocks
     "TranShkCount": 7,  # Number of points in discrete approximation to transitory income shocks
-    "UnempPrb": 0.05,  # Probability of unemployment while working
-    "IncUnemp": 0.3,  # Unemployment benefits replacement rate while working
+    "UnempPrb": np.array([0.05, 0.05]),  # Probability of unemployment while working
+    "IncUnemp": np.array(
+        [0.3, 0.3]
+    ),  # Unemployment benefits replacement rate while working
     "T_retire": 0,  # Period of retirement (0 --> no retirement)
-    "UnempPrbRet": 0.005,  # Probability of "unemployment" while retired
-    "IncUnempRet": 0.0,  # "Unemployment" benefits when retired
+    "UnempPrbRet": None,  # Probability of "unemployment" while retired
+    "IncUnempRet": None,  # "Unemployment" benefits when retired
 }
 
 # Default parameters to make aXtraGrid using make_assets_grid
diff --git a/HARK/core.py b/HARK/core.py
index 9e35a4de..e23c056c 100644
--- a/HARK/core.py
+++ b/HARK/core.py
@@ -601,6 +601,12 @@ class Model:
                     else:
                         raise ValueError("No constructor found for " + key) from None
 
+                # If this constructor is None, do nothing and mark it as completed
+                if constructor is None:
+                    keys_complete[i] = True
+                    anything_accomplished_this_pass = True  # We did something!
+                    continue
+
                 # Get the names of arguments for this constructor and try to gather them
                 args_needed = get_arg_names(constructor)
                 has_no_default = {
diff --git a/HARK/interpolation.py b/HARK/interpolation.py
index 62b08b0e..ae69a8a1 100644
--- a/HARK/interpolation.py
+++ b/HARK/interpolation.py
@@ -611,9 +611,9 @@ class IdentityFunction(MetricObject):
         Returns the derivative of the function with respect to the first dimension.
         """
         if self.i_dim == 0:
-            return np.ones_like(*args[0])
+            return np.ones_like(args[0])
         else:
-            return np.zeros_like(*args[0])
+            return np.zeros_like(args[0])
 
     def derivativeX(self, *args):
         """
@@ -625,9 +625,9 @@ class IdentityFunction(MetricObject):
         else:
             j = 0
         if self.i_dim == j:
-            return np.ones_like(*args[0])
+            return np.ones_like(args[0])
         else:
-            return np.zeros_like(*args[0])
+            return np.zeros_like(args[0])
 
     def derivativeY(self, *args):
         """
@@ -639,9 +639,9 @@ class IdentityFunction(MetricObject):
         else:
             j = 1
         if self.i_dim == j:
-            return np.ones_like(*args[0])
+            return np.ones_like(args[0])
         else:
-            return np.zeros_like(*args[0])
+            return np.zeros_like(args[0])
 
     def derivativeZ(self, *args):
         """
@@ -653,9 +653,9 @@ class IdentityFunction(MetricObject):
         else:
             j = 2
         if self.i_dim == j:
-            return np.ones_like(*args[0])
+            return np.ones_like(args[0])
         else:
-            return np.zeros_like(*args[0])
+            return np.zeros_like(args[0])
 
     def derivativeW(self, *args):
         """
@@ -669,9 +669,9 @@ class IdentityFunction(MetricObject):
                 False
             ), "Derivative with respect to W can't be called when n_dims < 4!"
         if self.i_dim == j:
-            return np.ones_like(*args[0])
+            return np.ones_like(args[0])
         else:
-            return np.zeros_like(*args[0])
+            return np.zeros_like(args[0])
 
 
 class ConstantFunction(MetricObject):
@@ -4718,475 +4718,3 @@ class MargMargValueFuncCRRA(MetricObject):
             )
 
         return MPC * CRRAutilityPP(c, rho=self.CRRA)
-
-
-##############################################################################
-# Examples and tests
-##############################################################################
-
-
-def main():
-    print("Sorry, HARK.interpolation doesn't actually do much on its own.")
-    print("To see some examples of its interpolation methods in action, look at any")
-    print("of the model modules in /ConsumptionSavingModel.  In the future, running")
-    print("this module will show examples of each interpolation class.")
-
-    RNG = np.random.default_rng(123)
-
-    if False:
-        x = np.linspace(1, 20, 39)
-        y = np.log(x)
-        dydx = 1.0 / x
-        f = CubicInterp(x, y, dydx)
-        x_test = np.linspace(0, 30, 200)
-        y_test = f(x_test)
-        plt.plot(x_test, y_test)
-        plt.show()
-
-    if False:
-
-        def f(x, y):
-            return 3.0 * x**2.0 + x * y + 4.0 * y**2.0
-
-        def dfdx(x, y):
-            return 6.0 * x + y
-
-        def dfdy(x, y):
-            return x + 8.0 * y
-
-        y_list = np.linspace(0, 5, 100, dtype=float)
-        xInterpolators = []
-        xInterpolators_alt = []
-        for y in y_list:
-            this_x_list = np.sort(RNG.random(100) * 5.0)
-            this_interpolation = LinearInterp(
-                this_x_list, f(this_x_list, y * np.ones(this_x_list.size))
-            )
-            that_interpolation = CubicInterp(
-                this_x_list,
-                f(this_x_list, y * np.ones(this_x_list.size)),
-                dfdx(this_x_list, y * np.ones(this_x_list.size)),
-            )
-            xInterpolators.append(this_interpolation)
-            xInterpolators_alt.append(that_interpolation)
-        g = LinearInterpOnInterp1D(xInterpolators, y_list)
-        LinearInterpOnInterp1D(xInterpolators_alt, y_list)
-
-        rand_x = RNG.random(100) * 5.0
-        rand_y = RNG.random(100) * 5.0
-        z = (f(rand_x, rand_y) - g(rand_x, rand_y)) / f(rand_x, rand_y)
-        q = (dfdx(rand_x, rand_y) - g.derivativeX(rand_x, rand_y)) / dfdx(
-            rand_x, rand_y
-        )
-        r = (dfdy(rand_x, rand_y) - g.derivativeY(rand_x, rand_y)) / dfdy(
-            rand_x, rand_y
-        )
-        # print(z)
-        # print(q)
-        # print(r)
-
-        z = (f(rand_x, rand_y) - g(rand_x, rand_y)) / f(rand_x, rand_y)
-        q = (dfdx(rand_x, rand_y) - g.derivativeX(rand_x, rand_y)) / dfdx(
-            rand_x, rand_y
-        )
-        r = (dfdy(rand_x, rand_y) - g.derivativeY(rand_x, rand_y)) / dfdy(
-            rand_x, rand_y
-        )
-        print(z)
-        # print(q)
-        # print(r)
-
-    if False:
-
-        def f(x, y, z):
-            return 3.0 * x**2.0 + x * y + 4.0 * y**2.0 - 5 * z**2.0 + 1.5 * x * z
-
-        def dfdx(x, y, z):
-            return 6.0 * x + y + 1.5 * z
-
-        def dfdy(x, y, z):
-            return x + 8.0 * y
-
-        def dfdz(x, y, z):
-            return -10.0 * z + 1.5 * x
-
-        y_list = np.linspace(0, 5, 51, dtype=float)
-        z_list = np.linspace(0, 5, 51, dtype=float)
-        xInterpolators = []
-        for y in y_list:
-            temp = []
-            for z in z_list:
-                this_x_list = np.sort(RNG.random(100) * 5.0)
-                this_interpolation = LinearInterp(
-                    this_x_list,
-                    f(
-                        this_x_list,
-                        y * np.ones(this_x_list.size),
-                        z * np.ones(this_x_list.size),
-                    ),
-                )
-                temp.append(this_interpolation)
-            xInterpolators.append(deepcopy(temp))
-        g = BilinearInterpOnInterp1D(xInterpolators, y_list, z_list)
-
-        rand_x = RNG.random(1000) * 5.0
-        rand_y = RNG.random(1000) * 5.0
-        rand_z = RNG.random(1000) * 5.0
-        z = (f(rand_x, rand_y, rand_z) - g(rand_x, rand_y, rand_z)) / f(
-            rand_x, rand_y, rand_z
-        )
-        q = (
-            dfdx(rand_x, rand_y, rand_z) - g.derivativeX(rand_x, rand_y, rand_z)
-        ) / dfdx(rand_x, rand_y, rand_z)
-        r = (
-            dfdy(rand_x, rand_y, rand_z) - g.derivativeY(rand_x, rand_y, rand_z)
-        ) / dfdy(rand_x, rand_y, rand_z)
-        p = (
-            dfdz(rand_x, rand_y, rand_z) - g.derivativeZ(rand_x, rand_y, rand_z)
-        ) / dfdz(rand_x, rand_y, rand_z)
-        z.sort()
-
-    if False:
-
-        def f(w, x, y, z):
-            return (
-                4.0 * w * z
-                - 2.5 * w * x
-                + w * y
-                + 6.0 * x * y
-                - 10.0 * x * z
-                + 3.0 * y * z
-                - 7.0 * z
-                + 4.0 * x
-                + 2.0 * y
-                - 5.0 * w
-            )
-
-        def dfdw(w, x, y, z):
-            return 4.0 * z - 2.5 * x + y - 5.0
-
-        def dfdx(w, x, y, z):
-            return -2.5 * w + 6.0 * y - 10.0 * z + 4.0
-
-        def dfdy(w, x, y, z):
-            return w + 6.0 * x + 3.0 * z + 2.0
-
-        def dfdz(w, x, y, z):
-            return 4.0 * w - 10.0 * x + 3.0 * y - 7
-
-        x_list = np.linspace(0, 5, 16, dtype=float)
-        y_list = np.linspace(0, 5, 16, dtype=float)
-        z_list = np.linspace(0, 5, 16, dtype=float)
-        wInterpolators = []
-        for x in x_list:
-            temp = []
-            for y in y_list:
-                temptemp = []
-                for z in z_list:
-                    this_w_list = np.sort(RNG.random(16) * 5.0)
-                    this_interpolation = LinearInterp(
-                        this_w_list,
-                        f(
-                            this_w_list,
-                            x * np.ones(this_w_list.size),
-                            y * np.ones(this_w_list.size),
-                            z * np.ones(this_w_list.size),
-                        ),
-                    )
-                    temptemp.append(this_interpolation)
-                temp.append(deepcopy(temptemp))
-            wInterpolators.append(deepcopy(temp))
-        g = TrilinearInterpOnInterp1D(wInterpolators, x_list, y_list, z_list)
-
-        N = 20000
-        rand_w = RNG.random(N) * 5.0
-        rand_x = RNG.random(N) * 5.0
-        rand_y = RNG.random(N) * 5.0
-        rand_z = RNG.random(N) * 5.0
-        t_start = time()
-        z = (f(rand_w, rand_x, rand_y, rand_z) - g(rand_w, rand_x, rand_y, rand_z)) / f(
-            rand_w, rand_x, rand_y, rand_z
-        )
-        q = (
-            dfdw(rand_w, rand_x, rand_y, rand_z)
-            - g.derivativeW(rand_w, rand_x, rand_y, rand_z)
-        ) / dfdw(rand_w, rand_x, rand_y, rand_z)
-        r = (
-            dfdx(rand_w, rand_x, rand_y, rand_z)
-            - g.derivativeX(rand_w, rand_x, rand_y, rand_z)
-        ) / dfdx(rand_w, rand_x, rand_y, rand_z)
-        p = (
-            dfdy(rand_w, rand_x, rand_y, rand_z)
-            - g.derivativeY(rand_w, rand_x, rand_y, rand_z)
-        ) / dfdy(rand_w, rand_x, rand_y, rand_z)
-        (
-            dfdz(rand_w, rand_x, rand_y, rand_z)
-            - g.derivativeZ(rand_w, rand_x, rand_y, rand_z)
-        ) / dfdz(rand_w, rand_x, rand_y, rand_z)
-        t_end = time()
-
-        z.sort()
-        print(z)
-        print(t_end - t_start)
-
-    if False:
-
-        def f(x, y):
-            return 3.0 * x**2.0 + x * y + 4.0 * y**2.0
-
-        def dfdx(x, y):
-            return 6.0 * x + y
-
-        def dfdy(x, y):
-            return x + 8.0 * y
-
-        x_list = np.linspace(0, 5, 101, dtype=float)
-        y_list = np.linspace(0, 5, 101, dtype=float)
-        x_temp, y_temp = np.meshgrid(x_list, y_list, indexing="ij")
-        g = BilinearInterp(f(x_temp, y_temp), x_list, y_list)
-
-        rand_x = RNG.random(100) * 5.0
-        rand_y = RNG.random(100) * 5.0
-        z = (f(rand_x, rand_y) - g(rand_x, rand_y)) / f(rand_x, rand_y)
-        q = (f(x_temp, y_temp) - g(x_temp, y_temp)) / f(x_temp, y_temp)
-        # print(z)
-        # print(q)
-
-    if False:
-
-        def f(x, y, z):
-            return 3.0 * x**2.0 + x * y + 4.0 * y**2.0 - 5 * z**2.0 + 1.5 * x * z
-
-        def dfdx(x, y, z):
-            return 6.0 * x + y + 1.5 * z
-
-        def dfdy(x, y, z):
-            return x + 8.0 * y
-
-        def dfdz(x, y, z):
-            return -10.0 * z + 1.5 * x
-
-        x_list = np.linspace(0, 5, 11, dtype=float)
-        y_list = np.linspace(0, 5, 11, dtype=float)
-        z_list = np.linspace(0, 5, 101, dtype=float)
-        x_temp, y_temp, z_temp = np.meshgrid(x_list, y_list, z_list, indexing="ij")
-        g = TrilinearInterp(f(x_temp, y_temp, z_temp), x_list, y_list, z_list)
-
-        rand_x = RNG.random(1000) * 5.0
-        rand_y = RNG.random(1000) * 5.0
-        rand_z = RNG.random(1000) * 5.0
-        z = (f(rand_x, rand_y, rand_z) - g(rand_x, rand_y, rand_z)) / f(
-            rand_x, rand_y, rand_z
-        )
-        q = (
-            dfdx(rand_x, rand_y, rand_z) - g.derivativeX(rand_x, rand_y, rand_z)
-        ) / dfdx(rand_x, rand_y, rand_z)
-        r = (
-            dfdy(rand_x, rand_y, rand_z) - g.derivativeY(rand_x, rand_y, rand_z)
-        ) / dfdy(rand_x, rand_y, rand_z)
-        p = (
-            dfdz(rand_x, rand_y, rand_z) - g.derivativeZ(rand_x, rand_y, rand_z)
-        ) / dfdz(rand_x, rand_y, rand_z)
-        p.sort()
-        plt.plot(p)
-
-    if False:
-
-        def f(w, x, y, z):
-            return (
-                4.0 * w * z
-                - 2.5 * w * x
-                + w * y
-                + 6.0 * x * y
-                - 10.0 * x * z
-                + 3.0 * y * z
-                - 7.0 * z
-                + 4.0 * x
-                + 2.0 * y
-                - 5.0 * w
-            )
-
-        def dfdw(w, x, y, z):
-            return 4.0 * z - 2.5 * x + y - 5.0
-
-        def dfdx(w, x, y, z):
-            return -2.5 * w + 6.0 * y - 10.0 * z + 4.0
-
-        def dfdy(w, x, y, z):
-            return w + 6.0 * x + 3.0 * z + 2.0
-
-        def dfdz(w, x, y, z):
-            return 4.0 * w - 10.0 * x + 3.0 * y - 7
-
-        w_list = np.linspace(0, 5, 16, dtype=float)
-        x_list = np.linspace(0, 5, 16, dtype=float)
-        y_list = np.linspace(0, 5, 16, dtype=float)
-        z_list = np.linspace(0, 5, 16, dtype=float)
-        w_temp, x_temp, y_temp, z_temp = np.meshgrid(
-            w_list, x_list, y_list, z_list, indexing="ij"
-        )
-
-        def mySearch(trash, x):
-            return np.floor(x / 5 * 32).astype(int)
-
-        g = QuadlinearInterp(
-            f(w_temp, x_temp, y_temp, z_temp), w_list, x_list, y_list, z_list
-        )
-
-        N = 1000000
-        rand_w = RNG.random(N) * 5.0
-        rand_x = RNG.random(N) * 5.0
-        rand_y = RNG.random(N) * 5.0
-        rand_z = RNG.random(N) * 5.0
-        t_start = time()
-        z = (f(rand_w, rand_x, rand_y, rand_z) - g(rand_w, rand_x, rand_y, rand_z)) / f(
-            rand_w, rand_x, rand_y, rand_z
-        )
-        t_end = time()
-        # print(z)
-        print(t_end - t_start)
-
-    if False:
-
-        def f(x, y):
-            return 3.0 * x**2.0 + x * y + 4.0 * y**2.0
-
-        def dfdx(x, y):
-            return 6.0 * x + y
-
-        def dfdy(x, y):
-            return x + 8.0 * y
-
-        warp_factor = 0.01
-        x_list = np.linspace(0, 5, 71, dtype=float)
-        y_list = np.linspace(0, 5, 51, dtype=float)
-        x_temp, y_temp = np.meshgrid(x_list, y_list, indexing="ij")
-        x_adj = x_temp + warp_factor * (RNG.random(x_list.size, y_list.size) - 0.5)
-        y_adj = y_temp + warp_factor * (RNG.random(x_list.size, y_list.size) - 0.5)
-        g = Curvilinear2DInterp(f(x_adj, y_adj), x_adj, y_adj)
-
-        rand_x = RNG.random(1000) * 5.0
-        rand_y = RNG.random(1000) * 5.0
-        t_start = time()
-        z = (f(rand_x, rand_y) - g(rand_x, rand_y)) / f(rand_x, rand_y)
-        q = (dfdx(rand_x, rand_y) - g.derivativeX(rand_x, rand_y)) / dfdx(
-            rand_x, rand_y
-        )
-        r = (dfdy(rand_x, rand_y) - g.derivativeY(rand_x, rand_y)) / dfdy(
-            rand_x, rand_y
-        )
-        t_end = time()
-        z.sort()
-        q.sort()
-        r.sort()
-        # print(z)
-        print(t_end - t_start)
-
-    if False:
-
-        def f(x, y, z):
-            return 3.0 * x**2.0 + x * y + 4.0 * y**2.0 - 5 * z**2.0 + 1.5 * x * z
-
-        def dfdx(x, y, z):
-            return 6.0 * x + y + 1.5 * z
-
-        def dfdy(x, y, z):
-            return x + 8.0 * y
-
-        def dfdz(x, y, z):
-            return -10.0 * z + 1.5 * x
-
-        warp_factor = 0.01
-        x_list = np.linspace(0, 5, 11, dtype=float)
-        y_list = np.linspace(0, 5, 11, dtype=float)
-        z_list = np.linspace(0, 5, 101, dtype=float)
-        x_temp, y_temp = np.meshgrid(x_list, y_list, indexing="ij")
-        xyInterpolators = []
-        for j in range(z_list.size):
-            x_adj = x_temp + warp_factor * (RNG.random(x_list.size, y_list.size) - 0.5)
-            y_adj = y_temp + warp_factor * (RNG.random(x_list.size, y_list.size) - 0.5)
-            z_temp = z_list[j] * np.ones(x_adj.shape)
-            thisInterp = Curvilinear2DInterp(f(x_adj, y_adj, z_temp), x_adj, y_adj)
-            xyInterpolators.append(thisInterp)
-        g = LinearInterpOnInterp2D(xyInterpolators, z_list)
-
-        N = 1000
-        rand_x = RNG.random(N) * 5.0
-        rand_y = RNG.random(N) * 5.0
-        rand_z = RNG.random(N) * 5.0
-        z = (f(rand_x, rand_y, rand_z) - g(rand_x, rand_y, rand_z)) / f(
-            rand_x, rand_y, rand_z
-        )
-        p = (
-            dfdz(rand_x, rand_y, rand_z) - g.derivativeZ(rand_x, rand_y, rand_z)
-        ) / dfdz(rand_x, rand_y, rand_z)
-        p.sort()
-        plt.plot(p)
-
-    if False:
-
-        def f(w, x, y, z):
-            return (
-                4.0 * w * z
-                - 2.5 * w * x
-                + w * y
-                + 6.0 * x * y
-                - 10.0 * x * z
-                + 3.0 * y * z
-                - 7.0 * z
-                + 4.0 * x
-                + 2.0 * y
-                - 5.0 * w
-            )
-
-        def dfdw(w, x, y, z):
-            return 4.0 * z - 2.5 * x + y - 5.0
-
-        def dfdx(w, x, y, z):
-            return -2.5 * w + 6.0 * y - 10.0 * z + 4.0
-
-        def dfdy(w, x, y, z):
-            return w + 6.0 * x + 3.0 * z + 2.0
-
-        def dfdz(w, x, y, z):
-            return 4.0 * w - 10.0 * x + 3.0 * y - 7
-
-        warp_factor = 0.1
-        w_list = np.linspace(0, 5, 16, dtype=float)
-        x_list = np.linspace(0, 5, 16, dtype=float)
-        y_list = np.linspace(0, 5, 16, dtype=float)
-        z_list = np.linspace(0, 5, 16, dtype=float)
-        w_temp, x_temp = np.meshgrid(w_list, x_list, indexing="ij")
-        wxInterpolators = []
-        for i in range(y_list.size):
-            temp = []
-            for j in range(z_list.size):
-                w_adj = w_temp + warp_factor * (
-                    RNG.random(w_list.size, x_list.size) - 0.5
-                )
-                x_adj = x_temp + warp_factor * (
-                    RNG.random(w_list.size, x_list.size) - 0.5
-                )
-                y_temp = y_list[i] * np.ones(w_adj.shape)
-                z_temp = z_list[j] * np.ones(w_adj.shape)
-                thisInterp = Curvilinear2DInterp(
-                    f(w_adj, x_adj, y_temp, z_temp), w_adj, x_adj
-                )
-                temp.append(thisInterp)
-            wxInterpolators.append(temp)
-        g = BilinearInterpOnInterp2D(wxInterpolators, y_list, z_list)
-
-        N = 1000000
-        rand_w = RNG.random(N) * 5.0
-        rand_x = RNG.random(N) * 5.0
-        rand_y = RNG.random(N) * 5.0
-        rand_z = RNG.random(N) * 5.0
-
-        t_start = time()
-        z = (f(rand_w, rand_x, rand_y, rand_z) - g(rand_w, rand_x, rand_y, rand_z)) / f(
-            rand_w, rand_x, rand_y, rand_z
-        )
-        t_end = time()
-        z.sort()
-        print(z)
-        print(t_end - t_start)
diff --git a/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb b/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb
index f388077c..642cab5c 100644
--- a/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb
+++ b/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb
@@ -2,15 +2,8 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:31.723046Z",
-     "iopub.status.busy": "2024-07-11T15:27:31.722813Z",
-     "iopub.status.idle": "2024-07-11T15:27:32.481049Z",
-     "shell.execute_reply": "2024-07-11T15:27:32.480477Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "from copy import copy, deepcopy\n",
@@ -98,15 +91,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:32.483030Z",
-     "iopub.status.busy": "2024-07-11T15:27:32.482767Z",
-     "iopub.status.idle": "2024-07-11T15:27:32.486741Z",
-     "shell.execute_reply": "2024-07-11T15:27:32.486279Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Define the Markov transition matrix for serially correlated unemployment\n",
@@ -166,22 +152,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:32.488109Z",
-     "iopub.status.busy": "2024-07-11T15:27:32.487941Z",
-     "iopub.status.idle": "2024-07-11T15:27:32.494743Z",
-     "shell.execute_reply": "2024-07-11T15:27:32.494254Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Make a consumer with serially correlated unemployment, subject to boom and bust cycles\n",
     "init_serial_unemployment = copy(init_indshk_markov)\n",
     "init_serial_unemployment[\"MrkvArray\"] = [MrkvArray]\n",
-    "init_serial_unemployment[\"UnempPrb\"] = 0.0  # to make income distribution when employed\n",
+    "init_serial_unemployment[\"UnempPrb\"] = np.zeros(2)\n",
+    "# Income process is overwritten below to make income distribution when employed\n",
     "init_serial_unemployment[\"global_markov\"] = False\n",
+    "init_serial_unemployment[\"Rfree\"] = np.array([1.03, 1.03, 1.03, 1.03])\n",
+    "init_serial_unemployment[\"LivPrb\"] = [np.array([0.98, 0.98, 0.98, 0.98])]\n",
+    "init_serial_unemployment[\"PermGroFac\"] = [np.array([1.01, 1.01, 1.01, 1.01])]\n",
     "SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment)\n",
     "SerialUnemploymentExample.cycles = 0\n",
     "SerialUnemploymentExample.vFuncBool = False  # for easy toggling here"
@@ -189,15 +172,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:32.496369Z",
-     "iopub.status.busy": "2024-07-11T15:27:32.496131Z",
-     "iopub.status.idle": "2024-07-11T15:27:32.500052Z",
-     "shell.execute_reply": "2024-07-11T15:27:32.499597Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Replace the default (lognormal) income distribution with a custom one\n",
@@ -231,15 +207,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:32.501627Z",
-     "iopub.status.busy": "2024-07-11T15:27:32.501247Z",
-     "iopub.status.idle": "2024-07-11T15:27:32.503891Z",
-     "shell.execute_reply": "2024-07-11T15:27:32.503445Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Interest factor, permanent growth rates, and survival probabilities are constant arrays\n",
@@ -250,42 +219,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:32.505321Z",
-     "iopub.status.busy": "2024-07-11T15:27:32.505080Z",
-     "iopub.status.idle": "2024-07-11T15:27:32.951132Z",
-     "shell.execute_reply": "2024-07-11T15:27:32.950636Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "The calc_limiting_values method must be run before the calc_stable_points method.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Solving a Markov consumer with serially correlated unemployment took 0.1601 seconds.\n",
-      "Consumption functions for each discrete state:\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACH0klEQVR4nOzdZ3wUVdvH8d/upveeQAokBEIIJVTpTRBREWwo0nuX4m3vFTsgIr0oggUVERUQkF6khl6SQHrvfbNlnheDQR6CCmwCgev7+fBiTmZ2rtzPI/tn5pzraBRFURBCCCGEuIVpb3YBQgghhBD/RgKLEEIIIW55EliEEEIIccuTwCKEEEKIW54EFiGEEELc8iSwCCGEEOKWJ4FFCCGEELc8CSxCCCGEuOVZ3ewC/guz2UxKSgrOzs5oNJqbXY4QQggh/gNFUSgsLKR27dpotTf2jKRGBJaUlBQCAwNvdhlCCCGEuA6JiYkEBATc0GfUiMDi7OwMqL+wi4vLTa5GCCGEEP9FQUEBgYGBFd/jN6JGBJa/XgO5uLhIYBFCCCFqGEtM55BJt0IIIYS45UlgEUIIIcQtTwKLEEIIIW55EliEEEIIccuTwCKEEEKIW54EFiGEEELc8iSwCCGEEOKWJ4FFCCGEELc8CSxCCCGEuOVJYBFCCCHELU8CixBCCCFueRJYhBBCCHHLqxGbHwohhBCiZknILmHeptMW+7xresIyb948mjZtWrFrcrt27Vi/fv1Vz1++fDkajeayP3Z2djdctBBCCCFuTUcScpm48jBdP9rKyj8TLPa51/SEJSAggPfee4/69eujKApffPEFffv25ciRI0RERFR6jYuLC2fPnq04tsQW00IIIYS4dZjNCptPp7No53kOxOVWjLer50mihe5xTYGlT58+lx2/8847zJs3j3379l01sGg0Gvz8/K6/QiGEEELcksoMJr4/lMSSXRe4kFUMgLVOw4PN/BnVKZjS8hi+m2yZe133HBaTycTq1aspLi6mXbt2Vz2vqKiIOnXqYDabadGiBe++++5Vw81f9Ho9er2+4rigoOB6yxRCCCGEhWUV6VmxN54V++LJKS4HwNnOikFt6zC0XR0uFEcx+8Sz7IjdYbF7XnNgOX78OO3ataOsrAwnJyfWrFlDo0aNKj03LCyMpUuX0rRpU/Lz8/noo49o3749J0+eJCAg4Kr3mDFjBm+88ca1liaEEEKIKhSbWcTinRf48XASeqMZAH83e0Z2DObhln7sSt3C5B2vcCbnDABajeUWI2sURVGu5YLy8nISEhLIz8/n+++/Z/HixWzfvv2qoeXvDAYD4eHhDBgwgLfeeuuq51X2hCUwMJD8/HxcXFyupVwhhBBC3ABFUTgQl8vCHefZfDq9YrxpgCtjOofQsb4Ta8+vYcWpFaSXqD+3t7LnodCH6BvQl4iACIt8f19zYPn/evToQb169ViwYMF/Ov+xxx7DysqKr7/++j/fo6CgAFdXVwksQgghRDUxmsxsOJnGop0XOJqYVzHeI9yH0Z1CCPIp5+szX7P63GqKDEUAeNp5MjB8IP3D+uNq62rR7+8b7sNiNpsvexryT0wmE8ePH+e+++670dsKIYQQogoU6418dzCRJbsukJRbCoCNlZZHWgQwsmMwJqtkvjj5Met3rceoGAEIdg1mWMQw7g+5H1udbZXUdU2B5YUXXqB3794EBQVRWFjIqlWr2LZtGxs3bgRgyJAh+Pv7M2PGDADefPNN2rZtS2hoKHl5eXz44YfEx8czatQoy/8mQgghhLhuGQVlLN8Tx1f74ikoU4OIu4M1g9vVZXDbIGIKj/Dh0afZk7Kn4ppWvq0Y3ng4Hf07WnS+SmWuKbBkZGQwZMgQUlNTcXV1pWnTpmzcuJGePXsCkJCQgFZ7qeDc3FxGjx5NWloa7u7utGzZkj179vyn+S5CCCGEqHpn0wpZtPM8a6OSMZjUWSLBXo6M7BhM30hfdqRsYcK2ly6bSHtPnXsYGjGUxl6Nq63OG57DUh1kDosQQghhOYqisCc2m4U7zrP9XGbFeOu67ozqFEL7UGd+iv2RFadWkFqcClyaSDu40WACnK++0vfvbqk5LEIIIYSoGYwmM78eT2XRzvOcSFZ7nGk1cG9jP0Z1CiHI28Sq06t488dvKShXf+5h58GTDZ/k8bDHcbNzu2m1S2ARQgghbnPFeiPfHlAn0ibnqRNp7ay19G8VyMiOwZitMvji5Gx+3v4zBrMBgLoudRkSMYQH6z1YZRNpr4UEFiGEEOI2lVFYxvLdl0+k9XS0YWj7ugxqW4f44pN8fPQFtiVuQ0GdIdLMuxnDI4bTNbArOq3uJlZ/OQksQgghxG0mJqOIRTvOs+ZIMuUmtSNtsJcjozoF81Dz2uxN28GU7W8SlRlVcU3XwK6MaDyC5j7NLVNEVjRs/sgyn4UEFiGEEOK2cKkjbSybT2dUjLcIcmNM53p0DnPj1wvrePzXL4kriAPAWmvNg/UeZEjEEEJcQyxTSOJ+2D0bzvwKerNlPhMJLEIIIUSNZjIrbDyZxsId54m62JFWo4Ee4b6M7RxC/Vo6vj37Lff9uIrssmwAnG2ceTzscZ5s+CTeDt43XoTZDNEb1aCSsPfScHBP4Mcb/3wksAghhBA1Umm5ie8PJbJ41wXis0uASx1pR3UKxt6+gBWnFjFh9w+UGtWJtn6OfgxpNISH6z+Mo7XjjRdhLIfjq2HPp5Cp9mlBZ4Mp9GFyU4JIWLLuxu9xkQQWIYQQogbJLtLz5d54VuyLJ6e4HABXe2uGtKvDkHZ1ySo/z4KTb/J73O+YFBMAYe5hDGs8jF51e2Gttb7xIsoK4NBy2Pc5FKp9WrB1wVDvCXLO2JP34a+YS3ZgMplu/F4XSWARQgghaoC4rGIW7zrP6oNJ6I3q3JAAd3tGdQzmsVYBHM06wIt7P2Jf6r6Ka9rWasvwxsNpV6sdGo3mxosoTIN98+DgUtCrfVpwroU+6HGyDxST/9ZGMKjLom3DwnB6cgA88cSN3xcJLEIIIcQt7XBCLot2nGfDyTT+6k3fxN+VMZ1D6NHIk80JvzN04zOczT0LgE6jo1fdXgyLGEa4Z7hlisiKVuenHPsWTOpTHbwaUOL5MNnb4yla9F3FqQ5t2uA5ehSOHTtSWFhomfsjgUUIIYS45ZjNClvOZLBwRywH4nIrxruFeTOmcz2aBNryY/SPPLh2BWnFaYDaOv+R+o8wuNFgajvVtkwhf1/xc7FPixJwF0U2Pclef5jSI1+q52k0OPfsieeokdg3bWqZe/8/EliEEEKIW0SZwcRPR5JZtPM8sZnFAFjrNPSN9GdM5xA8XPSsPP0VT+//lsJy9emFh50HA8MH8njY47jaut54EVdZ8aOE9ia/tCXZa7ZTHrsUAI21Na4PPYTH8GHYBgff+L3/gQQWIYQQ4ibLLzHw1Z/xLNsdR1aRHgBnWyuebBvE8PbBlJDCFyc/Yl3susta5w+NGEqfen0s0zq/shU/WmtMYY+Qlx5CzsLfMGaoQUXr7Iz7E0/gMWQwVt4WWBb9H0hgEUIIIW6SxJwSluy6wHcHEykpV1fU1HK1Y2THYPq3CiCm4ATvHHqGbYnbKq6J9I5kWONhdAvshlajvfEiKlb8zIPCFHXM1gVjgwHkRDuT+9E6zIU7ALDy8cFj6FDcHu+Pzsnpxu99DSSwCCGEENXsRHI+C3ac57fjqZjM6tyQhn7OjO0SQu/GvuxO2cH4ra9wLPMYABo0dA3syvDGwy3XOr+yFT9OfpSHPEn2oTLy3/gNpVydYGsTEoLnyJG49HkArY2NZe5/jSSwCCGEENVAURS2n8tk4Y7z7InNrhjvGOrFmM4htAlxZt35dTz6yxfEF8QDYKO1oU+9PgyNGEqwq4XmiGRFq699jn5z2YqfUt9Hyd6RROGSb/lrOZJ9ZCSeo0fh1K0bGq0FnubcAAksQgghRBUqN5pZdzSFRTvPcyZNnSir02p4oGktRncKIchbw3dnv+PVH766rHX+E2FP8GT4k3jZe1mmkKRDsHsmnP6FSyt+2lDs0JvsDVGU7F9ecapTt254jhqJQ8uWlrm3BUhgEUIIIapAQZmBr/9MYNnuONIKygBwsNHxROsgRnSsi41tEV+dWsJ327+j2KCuCPqrdf4j9R/BwdrhxotQFIj9A3bNhLidl4ZD76XA0Jbsn7ajP7tIHbSywvWBB/AcOQLb+vVv/N4WJoFFCCGEsKCMgjKW7L7Aqn0JFOqNAHg72zK8Q10GtqlDtiGRhSfeY935dRjN6s9D3UIZ0XgE9wbfa5nW+WYTnPoJds2CNHUeDForzGGPkJfTkJylv2JIWagOOzjg1r8/HkOHYF2r1o3fu4pIYBFCCCEsICajiEU7zrPmSDLlJrV1fqiPE2M6hdC3eW3O5J7g1X3/Y2viVpSLr2Ra+LRgZJORdPLvZJnW+YYyOLoKdn8KuRfUMWsHTOFPkhvnTc6snzHlqk9adJ6eeAwejPuAJ9C5WqB/SxWTwCKEEELcgEPxuSzYHsum0+kVrfNb1XFnXJd6dAvzZnfqLsZufoVD6YcqrukW2I0RjUcQ6RNpmSLK8uHAEnXVT3GGOmbvgaHBIHJOWZP39lrMJeqOztaBgXiOGI7rQw+htbOzzP2rgQQWIYQQ4hqZzQpbz2awYPt59sflVIz3CPdlXJcQmgU5s+HCBh77dRnRudEAWGmteCDkAYZHDCfELcQyhRSmqTsmH1x2aWmySwD6kEFk/5lP/qtrL21G2LAhnqNH4dKrFxqrmvf1X/MqFkIIIW6ScqOZn4+msHBHLOfSiwC1dX6/SH/GdgmhtruONTFrePHHL0gtTgXAwcqBxxo8xqBGg/Bz9LNMIdmx6tLkqFWXliZ7h1Pq9xjZ2+MpXLSiYmmyQ6tWeI4ZjWMnC712ukkksAghhBD/okhv5Jv9CSzZdYHUfHXFj5OtFQPvCmJ4h2BsbUv5+swKvv7ja/L0eYC6x8+g8EH0D+tvmT1+AFKOqBNpT/8MijpPRgloQ4nLA2SvP0rx3sUVpzp1747nqFE4tLBQo7mbTAKLEEIIcRWZhXqW77nAir3xFJRdWvEzokMwT94VRJEpg2UnZ/Jj9I+UmdQgE+gcyLCIYTxY70HsrCwwR0RR4MJ2Naic33ppOPQeCjVdyP5pB2XH56uDOh2uD9yP56hRt+TS5BshgUUIIYT4fy5kFbNo53m+P5REuVF9khHi5ciYziH0a+5PfGEMMw6+woYLGzAp6h5A4R7hjGgygp5BPdFpdTdehNkEZ35Re6ikHFHHNDqU8IfJL2pK9soNlF+Yqw7b2eH26KN4Dh+Gtb//jd/7FiSBRQghhLjoaGIeC3bEsv5EWsWKn8hAN8Z1qUePcB+OZB5i2vYZ7EreVXFN21ptGdF4BG1rtbXMHBGjXm2bv+dTyI5Rx6zsMUcMIDc1kJy5P2NM3w2A1sUF94FP4jF4MFYeHjd+71uYBBYhhBB3tL/2+Jm/PZZ95y+t+One0IexnUNoVdeNbYnbGLrhaY5lqU3YtBotPev0ZHjj4UR4RlimkL92Td47F4rS1DE7N4yNhpAb7UTOe2sw528ALu6aPGwYbv37o3NytMz9b3ESWIQQQtyRDCYzvx5LZf722Io9fqy0Gh6MrM2YziGEeNvxy/lfeHvtMuIK4gB1M8J+of0YFjGMQJdAyxRSlAl/zoMDi9V+KgDOtTGEDSX7cBl5r65FKVPnx9jUqaMuTX7wwZu2a/LNIoFFCCHEHaWk3Mi3BxJZvPMCyXmlgLrHz4A2QYzoGIyrg4nvzn3HhB1fkVmaCVTRZoQ5F2DvZ3DkKzCqgQSvBuiDniR7Vyr5y1aCUZ3oaxcRgefo0Tj37IFGZ4H5MTWQBBYhhBB3hOwiPV/sjefLvXHklajN1DwdbRjeoS6D29alnDy+Oj2f785+R5FB7bHi4+DDkEZDeLTBozhaW+jVS9pxdcXPyR8rlibj35ISr4fJ/v0URZ8trDjVoV1bvEaPxqFduxrdQ8USJLAIIYS4rSVkl7B413m+O5hImUENCHU8HRjdKYRHWwaQXprEzKh3+Dn2ZwxmNcgEuwYzPGI4D4Q8gLXOApsRAsTvgZ2fQMymiiGl3t0U2/Uk++e9lBxQV/yg0eDcsyeeo0dh36SJZe59G5DAIoQQ4rZ0IjmfBTvO8+uxFMwXV/w08XdlXJd63NvYjzO5p3hx9zNsjt9csRlhpHckIxqPoEtgF7Qa7Y0XoSgQvQl2fgyJ+9QxjRalYT8KjG3IXv07+jOfquPW1rg+2AfPkSOxDbFQ6/7biAQWIYQQtw1FUdgdk8387bHsismqGO/cwJtxXUJoG+zBwfSDjN/8GntT91b8vEtAF0Y0HkEL3xaWKcRsglM/wc6ZkH5cHdPZYG48gPzcMLIXr8WQqAYVjYMD7v374zFsKNZ+FmrdfxuSwCKEEKLGM5rMrD+RxoIdsZxIVjcB1Gk1PNC0FmM6hxBey5ltidsYvH5JxdJknUZH7+DeDG88nAbuDSxUyMUeKrtnQc55dczGCVPjweQl+ZH9yQ+YMtVXQjo3N9wHD8Jj4EB0bm6Wuf9tTAKLEEKIGqvMYGL1oSQW7ThPQk4JAHbWWp5oHcTIjsH4uVmz/sJ6Xlq7lNj8WABsdbYVS5MDnAMsU0h5sdpDZc9nUJiijtm7Y4wYTu5Ze3Le+RFzvrpk2apWLTyHD8ft0UfQOjhY5v53gGsKLPPmzWPevHnExcUBEBERwauvvkrv3r2ves3q1at55ZVXiIuLo379+rz//vvcd999N1S0EEKIO1tBmYGv9sWzdFccWUV6ANwdrBnavi5D2tXF3tbEmug1fPHHF6QUqwHCydqJx8MeZ1CjQZZbmlySA/sXwZ/zofRi0znn2hjCh5ETZSD31TUoJWqQsqlbF88xY3B94H40d1gPFUu4psASEBDAe++9R/369VEUhS+++IK+ffty5MgRIiKu7PS3Z88eBgwYwIwZM3jggQdYtWoV/fr14/DhwzRu3Nhiv4QQQog7Q0ZhGUt3xbFyXzyFerVHib+bPaM7BdO/dSBGSvjmzHJWnl5JTpkaIDzsPBjcaDCPhz2Os42zZQopTFM70h5cCuXqEmjcgylvMJzsPVnkP7cSxaCuOLIND8dr7Bice/a8Y3uoWIJGUf7aLeH6eHh48OGHHzJy5Mgrfvb4449TXFzML7/8UjHWtm1bIiMjmT9//n++R0FBAa6uruTn5+Pi4nIj5QohhKiB4rOLWbjjPKv/thlhfR8nxnetR59mtckvz+HLU1/y3dnvKDYUA+Dv5M/wiOH0De1rmV2TQW32tudTOLISTOqTHXwbUxb0JNlbL1CwfgOY1M0Q7Vu0wGvcWBw7dbpje6hY8vv7uuewmEwmVq9eTXFxMe3atav0nL179zJ9+vTLxnr16sVPP/30j5+t1+vR6/UVxwUFBddbphBCiBrsZEo+87dfvjS5eZAbE7qGcndDH5KLkpix/23Wxqyl3FwOQKhbKCObjOTeuvdipbXQVM30U+quySd+gIu7MxN4F6W+j5K1/hhFsz+rONWxUye8xo7BoVUry9xbANcRWI4fP067du0oKyvDycmJNWvW0KhRo0rPTUtLw9fX97IxX19f0tLS/vEeM2bM4I033rjW0oQQQtwGFEXhzws5zNsWy/ZzmRXjXcO8Gd+lHm2CPTiXe47nd33MxriNmC92i23m3YxRTUbROaCzZXqoACQdVJu9nf31Un0h3SlxfYDsn3ZTvHemOqjR4HzPPXiOGY19JVMkxI275sASFhZGVFQU+fn5fP/99wwdOpTt27dfNbRcjxdeeOGyJzMFBQUEBlpokykhhBC3JLNZYfPpdOZtj+VIQh4AWg080LQ247rUo1FtFw6nH2bSH6+yI2lHxXUd/DswqvEoWvq2tMyrF0WB89tg1ydw4a/7aFDC+1Ck60r26k2UHv1IHdbpcO3TB88xo6XZWxW75sBiY2NDaGgoAC1btuTAgQPMnj2bBQsWXHGun58f6enpl42lp6fj9y+NcWxtbbG1tb3W0oQQQtRABpOZn6NSmL89lugMdQKrjZWW/q0CGN0phCAPB3Ym72To+iUczjgMgFajpWednoxsPJJwz3DLFGI2w9nf1K60Kep90FqhNH6cAn0LsleuQ39ODSoaGxvcHn0UjxEjsAnwt8z9xT+64Zd7ZrP5svkmf9euXTu2bNnC1KlTK8Y2bdp01TkvQggh7hyV7ZrsbGvFoHZ1GN6hLh6OVvwe9zvTdy/hXO45AKy11jxY70GGNx5OHZc6linEZFDnpuyaCZln1DEre8zNBpGf04DsBT9giN8KgNbREfcnB+AxZAhW3t6Wub/4T64psLzwwgv07t2boKAgCgsLWbVqFdu2bWPjxo0ADBkyBH9/f2bMmAHAlClT6NKlCx9//DH3338/33zzDQcPHmThwoX/dBshhBC3sbyScr7YE8/yPRfIvbhrspeTLSM7BjOwbRC21mbWxqxl2YllJBUlAeBg5UD/sP4MbjQYHwcfyxRiKIUjX8HuTyE/QR2zdcXcbDh5yb5kf/QdxnR17orOzQ2PoUNwf/JJdK6ulrm/uCbXFFgyMjIYMmQIqampuLq60rRpUzZu3EjPnj0BSEhIQKu9NNGpffv2rFq1ipdffpkXX3yR+vXr89NPP0kPFiGEuAOl5peyZOcFVu1PoKRcXWkT5OHA2C4hPNIiAKNSynfnVrDi1AqyStV9gNxs3RgYPpABDQfgamuhoFBWAAeXwN7PoThDHXP0xtRsFLlnbcl58ztMeXkAWPn44DlyBG6PPSZdaW+yG+7DUh2kD4sQQtRcsZlFLNgey5ojyRhM6ldOeC0Xxnetx32N/cgvz2Xl6ZV8c/YbCssLAfB18GVYxDAerv8wDtYWCgolObBvHuxfAGVqm3xcgzA2HklOVDm533yHuVjt4WIdFITnqJG49uuHVrrSXrdbog+LEEII8U+OJuYxb1ssG0+l8dc/je8K9mB813p0aeBNWnEaHxx8jzXRaygzlQEQ7BrMiMYjuD/4fqx11pYppDAd9n4GB5bAxaZyeDXAEDaC7L2Z5P1vOcrFuZi29evjOXYsLvf2QmMlX5G3Evm/hhBCCItRFIXdMdnM2x7D7pjsivGejXwZ16UeLeu4E5cfx6t7XuWX2F8wKmp7/QjPCEY1GUX3oO6W66GSl6h2pT38JRjVQIRfU/T1hpK9JZb8+Z+DUb2/XbOmeI0dh1PXLmi0Frq/sCgJLEIIIW6Yyayw8WQa87bFcjz54q7EWg0PRtZmfJd61Pd15mzOWf63/R1+j/sdBfWRy11+dzGyyUja1mprufb12bHqip+j34BZndRLQGvKggaRvf4YBbM/4a9HPo7t2+E5ZiwOd7W5Y9vn1xQSWIQQQlw3vdHET0eSWbD9POez1NctdtZanmgdxKhOwQS4O3A08yiTtixie9L2iuu6BnRlVNNRNPNuZrliMk6rXWlPfA8Xu99StxOlfv3JWvcnRR+9X3GqU/fueI0dg30zC95fVCkJLEIIIa5Zsd7I1/sTWLTzPOkF6vwPV3trhravy7D2dXF3sObPtD95beMi9qftB0CDhl51ezGqySjCPMIsV0xKFOz8CE6vuzRW/x5KPPqS9eMOineqrTbQaHC+txde48ZhF2bB+4tqIYFFCCHEf5ZfYuCLvXEs232ph4qviy2jO4XwRJsgHG10bEvcxuJtizmWdQwAK40Vfer1YUTjEdR1rWu5YhL+VINK9O8VQ0rDPpQ43UvWd5so2f+OOqjT4frAA3iOHSPt82swCSxCCCH+VUZBGUt2XeCrffEUX+yhUtfTgfFd69GvuT9WWvg9/ncWHV9EdG40ALY6Wx6u/zDDI4ZTy6mWZQpRFHV/nx0fQtxOdUyjRWn8KMVWXcn6+hdKoy4GFWtr3B56CM/Ro7CR/ehqPAksQgghrioxp4QFO2L57mAS5UZ1XkhDP2cmdgvlvia1MCtG1p1fy5LjS0goVLvFOlo78njY4wxuNBgvey/LFKIo6pOUHR9C0gF1TGuN0vQJCk13kbVyDfpTbwOgsbXF7bHH8Bw5AutaFgpK4qaTwCKEEOIK0emFzNsWy9qjKZjM6oqaFkFuTOoeSrcwH/QmPd+cXcXyk8tJK04DwNXWlUHhgyzbldZshtM/q69+0o6rY1Z2KJGDKShpSvaS1eijtwCgcXDAfcATeA4bJvv83IYksAghhKhwLCmPuVtj2HgyvWKsU30vJnYL5a5gD4oNxSw5sYQVp1aQU5YDgLe9N0MjhvJYg8cs15XWZFQ3JNz5MWSdVcesHVFaDCc/pz7Zc76hPF7d50fr7IzH4EG4Dx6Mlbu7Ze4vbjkSWIQQ4g6nKAp/Xshh7tYYdkZnVYzfG+HHhG71aBrgRm5ZLnOj5rLqzKqK9vn+Tv6MaDyCvqF9sdXZWqYYox6Ofq32UcmNU8fsXDG3GE1+am2yP1yFIeVH4OKGhMOGqhsSyrYttz0JLEIIcYdSFIWtZzOYuzWWQ/G5AOi0Gvr+rdlbRkkGHx74kNXnVlNqLAUgxDWEUU1GcW/wvVhrLdQ+31CqdqTdPRsKktUxB0/MLcaRF+dK9turMGaoGxXqvLzwHDEC98f7o3V0tMz9xS1PAosQQtxhTGaF346nMndrDGfS1KclNlZaHm8VyJjOIQR6OJBUmMSbe2fyU8xPGC52iw33CGd009HcHXS35drn6wvVPX72fgbFmeqYcy1MzceRe9aanFdXYcpRXz1Z+fnhOWoUbo8+gtbOzjL3FzWGBBYhhLhDlBvNrDmSxLxtscRllwDgaKNjULs6jOwYjI+zHbF5sby4cwm/XfgNk6IuX27h04LRTUfToXYHy7WvL8uHPxfCvrlQqj7dwS0IU+Q4co4ayHn+a8wFBQBYBwbiOWY0bn37opGdk+9YEliEEOI2V1Ju5Jv9iSzaeZ7UfHUTQDcHa0Z0CGZou7q4OlhzMvskM7YuZkvClop9fjrU7sCoJqNo5dfKcsWU5sK++bBvHujVPYfwDMXYdBw5B/LJfXoZ5mK1xb9NSAhe48bict99snOykMAihBC3q/xSAyv2xrF0dxw5xeXApa60A9oE4WhrRVRGFAv2LGBX8q6K6+4OupvRTUYT4RVhuWJKcmDvXPhzAVyctIt3QwyNx5KzO43cKZ+jlKlhyjYsDK/x43Du2RONTme5GkSNJoFFCCFuM5mFepbuvsCKvfEU6Y0ABHmoXWkfbuGPjU7LwfSDLDi6gD/T/gRAp9HRO7g3IxuPJNQ91HLFFGWq81P2LwKD+uQEnwgMjceSvS2BvMmzUcrVMGXXpAle48fj1K2r7JwsriCBRQghbhNJuSUs2nGebw4kor/YlTbM15kJ3epxf5Na6LQa9qTsYeGxhRzOOAyAldaKvvX6MrLxSAJdLNi+vjAd9nwKB5eCQZ0vg19TDI3GkPVHLPkTP0YxqJN57Vu0wGvCBBw7tJegIq5KAosQQtRwMRlFzN8ey09HkjFe7EobGejGpG6hdG/og0YD25O2s+DoAk5knwDARmvDQ/UfYmTjkZbb5wegIEVdmnxoORjVVzzUbkF5w9Fkbz5D3twP4WJQcWjdGq+JE3G4q40EFfGvJLAIIUQNdTIln7lbY1h/Ig1FzSl0DPViQrd6tAvxREFhc/wmFh5byNlctVusnc6Ox8IeY1jEMHwcfCxXTF4i7J6l9lIxqa94CGhDeYMRZG04Qf6nM8Covp5yaNsWrwnjcWzTxnL3F7c9CSxCCFHDHE7IZe4fMWw5k1Exdk8jXyZ0CyUy0A2T2cRvF35j0bFFxObHAuBg5cATDZ9gSKMheNp7Wq6Y3HjY9QkcWQkX+7UQ1J7y+sPJ+vUI+TPfAZO6PNqxfXu8Jk7AoWVLy91f3DEksAghRA3wV/v8z/6IYVeM2j5fq4E+zWozoWsoYX7OGMwG1kSvYcmJJcQXxAPgbO3Mk+FPMih8EG52bpYrKOe8us/P0W/ArD45oW4n9PWGkrXuAAUfvaFuXAg4duqE14TxODRvbrn7izuOBBYhhLiFKYrCjugsPvsjmgNxaoM1K62Gh1v4M75rKMFejpSbyvnu7HcsPbGU5CK1rb2brRuDGw1mQMMBONs4W66grGg1qBz7Di42lqNed/R1BpK1dh8F77/GX++nnLp2xWvCeOybNrXc/cUdSwKLEELcgsxmhc2n0/lsawzHktQGa3+1zx/bJYQAdwfKjGWsPL2SpSeWklGivh7ytPNkWMQw+of1t9zOyQAZZ2DnR+oOyor65IT691AWOICsNTspfPfVS0Hl7rvxGj8e+8YW7OMi7ngSWIQQ4hZS2T4/9tY6Bt4VxOjOIfi62FFiKGH5ieUsP7mc7LJsAHwcfBjReASP1H8EOysL7rOTdgJ2fAin1sLFDriE3UeZf3+yvt9G4VsvVZzq3LMnXhPGYxcebrn7C3GRBBYhhLgFGExm1kal8PnWGM5nqQ3WnG2tGNK+DiM6BOPpZEtheSGLjq3gy1NfkqfPA6C2Y21GNhlJv9B+2OgsuM9O6lHY/gGc+eXSWHgfSv0eJeu7zRRteVEd02hw7tULr/HjsQtrYLn7C/H/SGARQoibSG80sfpgEvO3x5KUWwr8bZ+f9nVxtbcmX5/P3KjFrDy9ksKLbe2DnIMY1WQUD9R7AGutteUKSomC7e/D2d8uDmggoh+l3g+R9c0Gira9cHFYg0vv3niNH4dt/fqWu78QVyGBRQghboLSchOr9iewcEcs6QV6ALycbBjdKYSBbevgZGtFdmk2sw6t4OszX1NiVLvFhriGMLrpaO6tey9WWgv+FZ56FLa9D2d/VY81Wmj8CKUefcj8+leKdzyvjmu1uDxwP17jxmEbEmK5+wvxLySwCCFENSosM7BiXzxLdl4g++KGhLVc7RjbOYQn2gRhZ60jsySTzw8sY/XZ1ZSZ1G6xYe5hjGk6hh51eqDVaC1XUKVB5VFK3B8ga+U6indfDCo6Ha59+uA5dgy2wcGWu78Q/5EEFiGEqAZ5JeUs2x3Hst0XKChT+5YEetgzoWsoD7fwx9ZKR3pxOjMPL+X7c99TblbDTIRnBGObjqVroIU3BEw9pr76qZijooEmj6lB5aufKd5zMahYWeHa90G8xozBpk4dy91fiGskgUUIIapQVpGexTsvsGJvHMXlat+Set6OTOwWyoPNamOl05JWnMaSg0v4IfoHDBe7xUZ6RzK22Vg61O5QDUHlUUo9+5K5Yu2lJypWVrg91A/PsWOxCQiw3P2FuE4SWIQQogqk5ZexYEcsX+9PoMyg9i1p6OfM5O71ubexHzqthrTiNBYfX8yP0T9WBJUWPi0YHzmeu/zusmxQSTsO2967PKg0foRS735kfrWO4p3PqsMVQWUcNgH+lru/EDdIAosQQlhQYk4J87bH8v3BJMpNalBpFujG5G6h3B3ug0ajIaUohcXHF7MmZg3Gi23tW/m2Ynyz8bT2a235oLL9fTi97uLAxaDi8xCZK9dRvP1iUNHpcO3XF69x47AJDLTc/YWwEAksQghhAbGZRXy+NZafopIxmdUGa22CPZjcPZSOoV5oNBqSi5JZdGwRa2PXVgSV1n6tK4KKRaWdgO3v/b+g8jClPg+TtfIXirY/ow7rdLj27YvXuLHYBAVZtgYhLEgCixBC3IDo9EI+2xrDuqMpXMwpdG7gzaRuobQJ9gAgsTCRxccX83PMzxgVNajc5XcX45qNo5VfK8sWlHbi4hOVny8OXAwqvo+QtepXirZeDCpaLa4PPojX+HEymVbUCBJYhBDiOpxJK2DOHzH8djz1ry106BHuw6Tu9YkMdAMgsSCRhccXsi52HaaLGwW2rdWW8c3G08K3hWULSj+pBpVTay8OaCDiIcpqPUrm1+sp2vI/dVirxbVPHzWo1K1r2RqEqEISWIQQ4hqcTMlnzpYYNpxMqxi7N8KPSd1DaezvCkBCQQILjy3kl/O/VASV9rXbM77ZeCJ9Ii1bUKVBpR9ltfuT+fVvFG2+FFRcHrgfr/HjpY+KqJGuKbDMmDGDH3/8kTNnzmBvb0/79u15//33CQsLu+o1y5cvZ/jw4ZeN2draUlZWdn0VCyHETXA8KZ/ZW6LZfDodAI0G7mtSi8ndQ2no5wJAfEE8C48t5Nfzv1YElQ7+HRjfbDzNvJtZtqD0UxeDyk+XxiIeUjcl/HoDhZue5q9CXe6/H68J46UzrajRrimwbN++nYkTJ9K6dWuMRiMvvvgi99xzD6dOncLR0fGq17m4uHD27NmKY4vOgBdCiCp0JCGXOX/E8MeZDAC0GujTrDaTuoVS39cZgAv5F1h4bCG/XfgNs6KuDOrk34nxzcbTxLuJZQvKOK0uT/57UGnUj7KAJ8j6diOFG/8WVO67Tw0q9epZtgYhboJrCiwbNmy47Hj58uX4+Phw6NAhOnfufNXrNBoNfn5+11ehEELcBIfic5i9JYYd5zIBNaj0i/RnYvdQ6nk7AXA+7zwLji1gQ9yGiqDSJaAL45qNo7FXY8sWlBUN22bAiR+Bi5NmGvVFH/Qkmd9spHDDdHVMo8Gl9714TZiAbWioZWsQ4ia6oTks+fn5AHh4ePzjeUVFRdSpUwez2UyLFi149913iYiIuOr5er0evV5fcVxQUHAjZQohxH/25/lsPv0jmt0x2QDotBoebu7PxG6h1PVSnyTH5sWy4KgaVJSL4aFrYFfGNRtHhOfV/267LjnnYfsHcOxbuBiKCH8Qfd2BZH37OwWvTeevWb/O996L98QJsnuyuC1pFOWv+e3Xxmw28+CDD5KXl8euXbuuet7evXuJjo6madOm5Ofn89FHH7Fjxw5OnjxJwFXaPb/++uu88cYbV4zn5+fj4uJyPeUKIcRVKYrC3vPZzN4czZ8XcgCw0mp4rFUA47uEEuTpAEB0bjQLji3g97jfK4JK98DujGs2jnDPcMsWlZcAOz6EIyvh4nwYwu5DHzKErG83U7B+/aWg0qsXXhMmYBfWwLI1CHGDCgoKcHV1tcj393UHlvHjx7N+/Xp27dp11eBRGYPBQHh4OAMGDOCtt96q9JzKnrAEBgZKYBFCWJSiKOyKyeLTLdEciMsFwFqnoX+rQMZ3rUeAuxpUYnJjmHd0Hr/H/15xbY+gHoxrNo4wj6svOrguBSmw82M49AVcbNdPaA/Kw0aS9f0O8tetA7P6pMW5Z0+8Jk3E7h8WPghxM1kysFzXK6FJkybxyy+/sGPHjmsKKwDW1tY0b96cmJiYq55ja2uLra3t9ZQmhBD/SlEUtp3L5NMt0RxJyAPAxkrLgNaBjO1Sj9pu9oA6R2X+0fmXvfrpWacnY5uOtXxQKUyH3bPgwBIwXfwHW3BnDBHjyFq7j7wZz4JJfdLidPfdeE+aiF24hZ/qCHELu6bAoigKkydPZs2aNWzbto3g61jLbzKZOH78OPfdd981XyuEEDdCURS2nM7g0z+iOZakzsGztdIy8K46jO0Sgq+LHaCu+pl/dD7rL6y/LKiMbzae+u4Wnh9SnK0Glf2LwFiqjgW1w9B0Itm/RZH30QsoBvVJi2PnTnhPfgr7Jhae0CtEDXBNgWXixImsWrWKtWvX4uzsTFqa2jjJ1dUVe3v1XyRDhgzB39+fGTNmAPDmm2/Stm1bQkNDycvL48MPPyQ+Pp5Ro0ZZ+FcRQojKmc0Kv59KZ84f0ZxMUSfx21vrGNyuDqM6BePjrAaVhIIE5h+dz68Xfq1Y9XN30N2Mbzbe8k9USnNhz2fw53woL1LH/FtibP4U2ZvPkDvyFZSLr8Yd2rbF+6mncGjR3LI1CFGDXFNgmTdvHgBdu3a9bHzZsmUMGzYMgISEBLRabcXPcnNzGT16NGlpabi7u9OyZUv27NlDo0aNbqxyIYT4F2azwoaTaXy6JZozaYUAONroGNK+LqM6BuPppL56TixMZMHRBZd1pu0a2JUJzSZYfjJtWQHsmwd754JefcqDX1NMraaSvT2OnDFvoZSUAGDfogXeTz2FY9u7LFuDEDXQdU+6rU6WnLQjhLj9mcwKvx1P5dMt0URnqE8vnGytGNa+LiM7BuPuaANAclEyC48tZG3M2oqg0jmgMxOaTSDCy8LLk/VFsH8h7PlUfboC4NMIU5tp5OxNJ+eLLzEXqbXaNWmiBpWOHaTRpqjRbvqkWyGEuBWZzQq//r+g4mxnxYgOwYzoEIyrgzUAqUWpLDy+kJ+if6rYPbmDfwcmNpto+c60hlJ1Iu2umVCSpY55NcB81zRyDhWSPfETzBd7Wtk2bIj3U5Nx6tZNgooQ/48EFiFEjWc2K/x2Qg0q59LVoOJiZ8XIjiEM71gXFzs1qKQVp7H4+GJ+iP4Bo1kNKlW2KaFRry5N3vkRFKn7D+EejLn90+QeKyd7ylxMOWrPF5t69fCePBnne3qi+dsrdSHEJRJYhBA1ltmssP5EGrO3nKsIKs52VozqGMKwDnVxtVeDSkZJBouPL+b7c99juNjb5K5adzExciLNfSw8kdVYDlFfwY6PoCBZHXMNwtx+Gnlnrcievghjptru37pOEN6TJuFy331odDrL1iHEbUYCixCixvlrMu3szdGcTVcn0zrbWTGyYzDDOwRXBJXMkkyWnFjC6rOrKTeXA9DKtxUTIyfSyq+VhYsywbHv1P1+8uLVMefaKO2nkhfvQtbzizCmpgJgXbs2XhMn4Nq3Lxor+WtYiP9C/ksRQtQYZrPCxpNpzP7bqp/KgkpWaRZLTyzlu7Pfob/YhK2FTwsmRk6kTa02li1KUeD0z7D1Xcg8o445+qC0n0p+qjdZry7GkJgIgJWPD17jx+H2yCNobGwsW4cQtzkJLEKIW57aRyWNWZv/FlRsrRjRMZgRHS8FlZyyHJadWMY3Z76hzFQGQKR3JBMiJ9C2VlvLTmRVFIjdAlvegtQodczODaX9FApy65L19mLKL1wAQOfpideY0bg9/jhaOzvL1SDEHUQCixDilnW1oDK8YzAj/7bqJ7csl+Unl/P1ma8pvdgttqlXUyZETqB97faWX3ETv0cNKgl71GMbJ5S7xlNkjCTz48Xozy4CQOfqiufoUbg/+SRaBwfL1iDEHUYCixDilqMoChtPpjN7SzSnU9XOtE62VozoUJeRHUMqgkpBeQFfnPyCr059RYlRbbYW4RnBhMgJdPLvZPmgkhIFf7wNMZvUY50ttBlNsV1XMuctpTRqJQBaJyc8hg/DY+hQdE5Olq1BiDuUBBYhxC1DUdQW+rM3R3Pqb0FleAe14Zubgzrvo9hQzMrTK1l+cjmF5eqTl3CPcCZGTqRzQGfLB5XMs7D1HTi1Vj3WWkHzQZR6PUjmolUU73kKAI2dHR6DB+E5ciQ6NzfL1iDEHU4CixDiplMUhU2n0pn1L0GlzFjGt2e/ZcnxJeTq1W6xoW6hTIqcRPeg7pYPKrlxsO19OPYNKGZAA00eQx80gMwv11C4aZJ6nrU17o89hue4sVj7+Fi2BiEEIIFFCHETKYrC5tMZzNp8rmJTQkcbHcM7BF/WQr/cVM4P0T+w6NgiMkvVHiZ1XOowodkEetXthU5r4R4mhWmw40O18dvFvi00fIDysJFkfbOR/JcnqZNutVpcH3wQr0kTsQkIsGwNQojLSGARQlQ7RVHYcjqDWVvOcSL5UlAZ1qEuozqGVAQVo9nIz7E/M//ofFKL1R4mtR1rM67ZOPrU64OV1sJ/hZXkqC309y+Ci5N3CemGodkksn7aTd7bU8Codsh1vucevJ+ajG1oqGVrEEJUSgKLEKLaKIrCH2cymLU5muPJ6v45jjY6hravy+hOl4KKyWxifdx65kXNI6EwAQAfex/GNB3Dw/UfxlpnbdnCygpg3+ew5zO4OCeGwLswtppGzqaT5Ax9BqVMXSbt2LEj3lOmYN+ksWVrEEL8IwksQogqpygKO6Oz+GTTOaIS8wBw+FtQ8bgYVBRFYXPCZuYemUtsfiwAHnYejGw8kv5h/bGzsnAPE0MpHFgMOz+BUnVfH3ybYGr3DDm7k8kZ+WrFDsr2zZvjPW0qjm0s3HhOCPGfSGARQlSpfeez+eT3c+yPUwOBvbUaVMZ0vjyo7EzeyWdHPuN0zmkAnG2cGdF4BE82fBIHawv3MDEZ4PCX6jyVQvVVE56hmDs8S+7RErLHv48pV53Ua9uwIT7TpuLYuQpWHwkh/jMJLEKIKnEoPpdPNp1ld0w2ADZWWga3rcO4LvXwdratOG9f6j7mHJnDscxjADhYOTAkYgiDGw3GxcbFskWZzXDyR7WXSq7ahRbXQJSOz5AXa0vW9PkY09LUeuvUwXvKUzjfe6/soCzELUACixDCok4k5/Px72fZevbijsQ6DU+0DmJit1D8XC+90jmScYQ5R+ZwIO0AAHY6OwaED2B4xHDc7dwtW9RfbfQ3vwFpajDC0Rul4/8oyKxF1svzKI9XNyy0qlUL74kTcO3XTzYmFOIWIv81CiEs4kxaATM3nWPjyXQAdFoNj7YIYPLdoQS4X3qlczLrJHOi5rA7eTcA1lpr+of1Z1STUXjZe1m+sKSDsPl1iNupHts4o7SfTFF5UzLfW4D+7Fm1Xg8PvMaNVff7sbW9+ucJIW4KCSxCiBsSm1nErM3R/HIsBUUBjQb6Rfoz5e761PVyrDjvXO455h6Zyx+JfwBgpbGiX/1+jG06Fj9HP8sXlnkO/ngTTq9Tj3U20Ho0Jc49yJi7hNLDywHQOjvjOXIEHoMHo3V0vPrnCSFuKgksQojrkpBdwuwt0aw5koRZUcfub1KLqT3qU9/X+dJ5BQl8FvUZGy5sQEFBq9HyQMgDjGs6jkCXQMsXlp8M22ZA1Eq1O61GC80GUBb4BJmLv6Fo60RA2ugLUdNIYBFCXJOUvFLm/BHD6oOJGC8mlR7hvkzv2YBGtS9Nks0oyWD+0fmsiV6DUVGbrfWq24sJzSYQ4hZi+cJKcmDXJ/DnQjDp1bGw+zFEjCVz5XryXxinzmXR6XB75BG8Jk7E2lfa6AtRU0hgEUL8JxkFZczdGsPX+xMpN5kB6NLAm+k9G9As0K3ivHx9PktOLGHV6VXoLwaHTv6deKrFUzT0aGj5wsqLYd882P0p6NVmdAS1x9j6abJ/OUDuu5NRDGp7fedevfCeMgXbkGDL1yGEqFISWIQQ/yi7SM/87bF8uTcevVENKu1CPHn6nga0qutRcV6JoYSVp1ey7MQyCg1qt9jmPs2Z0mIKLX1bWr4wkwEOfwHbP4AidaIvvo0xt3+e7F2J5Ax7HnNxMQAObdvi8/R07Js0sXwdQohqIYFFCFGp/BIDC3fGsmx3HCXlJgBa1nHn6Z4NaB96aTWPwWTg++jvWXB0Adllas+VBu4NmNJiCp38O1m+2VplvVTc6qB0fp7cU2ayJn6AKSsLANtG4fhMfxrHDu2l6ZsQNZwEFiHEZQrLDCzdFcfiXecpLFPnnjTxd2X6PQ3o2sC74ovfZDbx24XfmBs1l+SiZAACnAKY1HwSvYN7o9VYuNnaVXupPENBph+Zz83FkJgIgHVQEN5TnsKld29p+ibEbUICixACgJJyI1/siWfBjljyStQ5Hw39nJneswE9G/lWBBVFUdietJ3Zh2cTkxcDgJe9F+OajquajQnhqr1Uis0tyPhwHvpTajt/nZcX3hMn4Pboo2isq6AOIcRNI4FFiDtcmcHEyj8TmLcthqyicgDqeTsyrWcD7mtcC6320quUA2kHmH14NkczjwJVvN8PQHYsbHkDTq1Vjy/2Uil1v5eMz5dS8udyALSOjniOGonHkCHSS0WI25QEFiHuUOVGM98eTOSzP6JJL1BX8wR5ODC1R336Rvqj+1tQOZ19mtlHZld0p7XT2TEwfCDDGw/H1dbV8sUVZcL29+HQMjAbAQ00G4A+ZBCZS76j8PexAGisrXF/8kk8x43Fyt3C7fyFELcUCSxC3GEMJjM/Hk7i0y0xJOeVAuDvZs/k7qE80jIAa92lOR/xBfF8duQzNsRtANTutI80eISxTcfi7eBt+eLKi2HvXNg9G8qL1LH692BoNpmsbzeT9/JYMJlAo8G1b1+8J0/C2t/f8nUIIW45EliEuEOYzAo/H01m9uZo4rJLAPBxtmVS91Aebx2IrZWu4tz04nTmH1ObvpkUExo09A7uzaTISVXTndZkhCMr1A61fy1Rrt0cU/sXyN54kpwPnkLRq0+BnLp3x3vqFOwaNLB8HUKIW5YEFiFuc2azwvoTaczcfI6YDPWphaejDeO71mNQ2zrYWV8KKnlleSw9sZRVZy41fesc0Jmnmj9FmEeY5YtTFDj7mzqhNuucOuZWB6XLS+QeKyNr1OuY8vIAsG/ZEp+np+PQooXl6xBC3PIksAhxm1IUhc2nM/hk0zlOpxYA4GpvzdguIQxtVxdH20v/+ZcYSlhxagXLTy6nyKCGmhY+LZjSYgotfKsoICQegE2vQMJe9djeA6XzsxRm+ZPx7GcVS5Rt6tXD5+npOHXrJr1UhLiDSWAR4jajKArbz2Uyc9M5jiapreqdba0Y2SmYER2DcbG7tNy33FTO6nOrWXhsITllOUAVN30DyIpRV/6c/lk9trKDthMotutMxifzKDt+HACdtxfekyfj9vDDaKzkryoh7nTyt4AQt5G9sdl8/PtZDsbnAmBvrWN4h7qM6RyCm4NNxXmVNX0LdA5kUuQk7g2+1/JN3wCKMi6u/FmurvzRaCHySfRBT5Kx4CuKtk0AQOvggMeokXgOG4bWoQqWSgshaiQJLELcBg7F5/Dx7+fYE6u2xre10jK4bR3Gda2Hl5NtxXmKorA1cStzjsypaPrmbe/NuGbjeKj+Q1hrq6DZmr5IXfmz59O/rfzphSHyKbK+2UjeC2PUdvs6He6P98drwgSsvLz++TOFEHccCSxC1GDHkvL4ZNM5tp3NBMBap2FAmyAmdgvF18XusnMPpB1g1uFZHMtU29o72zgzsvFIngx/Ensre8sXZzLCkS9h23v/b+XPi2RvOU3OwMkoZWVqLT174j1tmuyiLIS4qmsKLDNmzODHH3/kzJkz2Nvb0759e95//33Cwv559cDq1at55ZVXiIuLo379+rz//vvcd999N1S4EHeyM2kFfPL7OX4/pQYBnVbDYy0DmNQ9lAD3y1+jnMo+xaeHP2V3yqWmb4MaDWJYxLCqafpW2cof97rqyp8T5WSNeQNTjjpfxr55c3yeeQaHFs0tX4cQ4rZyTYFl+/btTJw4kdatW2M0GnnxxRe55557OHXqFI5XaYe9Z88eBgwYwIwZM3jggQdYtWoV/fr14/DhwzRu3Ngiv4QQd4q4rGJmbj7Hz0dTUBTQaqBfc3+m3F2fOp6X/zd4If8Cnx35jN/jfweqoekbQPIh2PjSlSt/8uqQ+dynlMfHA2BTty7eT0/HuUcPWfkjhPhPNIqiKNd7cWZmJj4+Pmzfvp3OnTtXes7jjz9OcXExv/zyS8VY27ZtiYyMZP78+f/pPgUFBbi6upKfn4+Li8v1litEjZWSV8qcP6L57mASJrP6n+z9TWoxrWd9Qn2cLzs3rTiN+Ufn81PMTxVN3+4LuY+JzSZWTdM3gLxE2PImHP9OPbayh3YTKHHoSsbseZRGRQGg8/TEe9JE2ZxQiDuEJb+/b2gOS36+umTSw8Pjqufs3buX6dOnXzbWq1cvfvrpp6teo9fr0V/sagnqLyzEnSirSM/nW2P56s94yo1mALqFefP0PWE09r/8dU5eWR6Ljy/m6zNfU25WNzHsEtCFyc0nV03TNwB9IeyaBXs/A6M6H4VmA9DXG0bmopUUbrq454+9PZ7Dh+MxYgQ6J9mcUAhx7a47sJjNZqZOnUqHDh3+8dVOWloavr6+l435+vqSlpZ21WtmzJjBG2+8cb2lCVHj5ZcaWLTjPEt3X6Ck3ATAXcEePNMrjFZ1L/8HQomhhC9PfckXJ7+4rOnb1JZTae5TRXNDzCa1lf4f70BxhjpWpyPGNs+Q+f128l4epe75o9Xi9uijeE2aiLWPT9XUIoS4I1x3YJk4cSInTpxg165dlqwHgBdeeOGypzIFBQUEBlbRo2whbiEl5UaW7Y5jwfZYCsqMADQNcOWZXmF0DPW6bL5HZU3fwtzDmNJiCh39O1bd3JDYP2Djy5BxUj32CMHc5VVy92eTNfQZzEVqaHK6+258pk/Dtl69qqlDCHFHua7AMmnSJH755Rd27NhBQEDAP57r5+dHenr6ZWPp6en4+fld9RpbW1tsbW2v+nMhbjd6o4lVfyYwd2sMWUXq65wGvk5M7xlGrwjfy8KHyWzil/O/8HnU56QUpwBq07fJzSfTq26vqmn6BpBxRm2lH61O4sXODaXLcxRmB5IxfTaGZLUBnV1EBL7PP4dD69ZVU4cQ4o50TYFFURQmT57MmjVr2LZtG8HB/94zoV27dmzZsoWpU6dWjG3atIl27dpdc7FC3G6MJjM/HE5i9uZoUvLVOSBBHg5M61mfB5v5o9NeCiqKovBH4h/MOTyH2PxYAHzsfRjbbGzVNX0DKM5Sd1E+uAwUE2itoM0YSt3vI33WPEqPHAHAytcXn+nTcOnTB422ikKTEOKOdU2BZeLEiaxatYq1a9fi7OxcMQ/F1dUVe3u18dSQIUPw9/dnxowZAEyZMoUuXbrw8ccfc//99/PNN99w8OBBFi5caOFfRYiaw2xW+OV4KjM3neNCVjEAfi52PHV3fR5rFYC17vIv/ANpB5h1aBbHstSmby42LoxsMpIBDQdUTdM3AEMZ/Dkfdn4M+osT3xs+gKHxRDKWr6HglzHAxQm1o0biOXy4tNIXQlSZawos8+bNA6Br166XjS9btoxhw4YBkJCQgPZv/7pq3749q1at4uWXX+bFF1+kfv36/PTTT9KDRdyRFEVhy+kMPvr9LGfSCgHwcLRhQtd6DGpbBztr3WXnn805y+zDs9mZvBMAeyt7BoUPYljjYbjYVNESf0WBk2tg82uQl6CO+TXF1OlVsn8/Sc6MCSh6PWg0uD70EN5TpmDtKxNqhRBV64b6sFQX6cMibge7Y7L4cONZohLzAHUH5TGdQxjeMRgn28v/7ZBalMpnUZ+xLnYdCgo6jY5HGzxatU3fABIPwMYXIWm/euxcC6Xby+RFW5M55zNMWVkAOLRpg+/zz2HXqFHV1SKEqPFumT4sQoh/dyg+l482nmXveXVjQjtrLcM7BDP2/+2gDJX3Urmnzj1Mbj6Zuq51q67I3HjY8gac+EE9tnaADlMp1rYm/fXZ6M+pLfZt6tTB57lncerWTTrUCiGqlQQWIarIqZQCPv79LFvOqH1KrHUaBt5Vhwnd6uHjfPnGhKXGUlaeXsnS40spNKivilr7tWZai2k08W5SdUWWFcCuT2Dv52DSAxqIHIg+eDAZny+naPtyALSurnhPnID7E0+gsbH5x48UQoiqIIFFCAs7n1nEJ5vO8cuxVEDd7+fRlgE8dXf9KzYmNJqNrI1Zy+dRn5NRqgab+u71mdZiWtX2UvlrJ+U/3oES9TUPdTthbPs8Wd9tJfeli43frKzwGPgkXuPHo3Nzq5pahBDiP5DAIoSFJOWW8OmWaH44nFyx388DTWsxrWcD6nk7XXauoihsTdzK7MOzOZ9/HoBajrWY3Hwy9wXfh06ru+LzLSZ6M/z+EmSeUY89QzF3e53cPzPIGjwdc6H6hMfp7rvx+d/T2P6H9gVCCFHVJLAIcYMyCsv4fGssq/5MoNyk7vdzd0Mfpt/TgIjarlecfzj9MDMPzSQqMwoAV1tXxjQZw+MNH8dWV4UNE9NPwe8vQ+wW9djeHaXL8xTmBpExbRaGxEQAbMPD8X3uORzb3lV1tQghxDWSwCLEdcorKWfBjvMs3x1HqUHd76dtiAfP9GpIyzruV5wfmxfLrMOz2Ja4DQA7nR2DGw1meOPhONs4X3G+xRRlwNZ34fAXoJhBaw13jaXU8z7SZ86j9NAhAKy8vfGeNg3Xvg+i0VXhEx4hhLgOEliEuEZFeiPLdl1g4c7zFF7c76dZoBvP3BNGh1DPK+adpBWn8XnU56yNXYtZMaPVaHko9CEmRE7Ax6EK+5cYSmHf57BzJpSrr3kIfxBD00lkLPuBgp9HAaCxs8Nz5Eg8RwxH6yg7KQshbk0SWIT4j/RGEyv3qfv9ZBerS47DfJ35X68weoT7XBFU8vX5LDmxhFWnV6E36QG4O+hunmrxFCGuIVVXqKKoy5M3vw756mseajfH3PlVsn8/QfaAcShl6jYArv364T11Ctb/sLeXEELcCiSwCPEvzGaFtUeT+fj3cyTllgJQ19OBaT0b0KdpbbTay4OK3qTn69Nfs+j4IgrK1Zb2LXxaMK3lNCJ9Iqu22IQ/1cZvyQfVYxd/lO6vkh9tRcbo1zBlXmz81qoVPs8/j33jiKqtRwghLEQCixBXoSgK285l8v76MxVt9H2cbZnSoz79WwVesd+PyWxi3fl1zI2aS1qxus9WqFsoU1tMpXNA56pttJZzQX2icuon9djaETpNo1hzsfHbGXVFkHVQED7P/A/nHj2k8ZsQokaRwCJEJY4k5PLe+jP8eSEHUNvoj+taj+Ed6uJgc/l/NoqisCNpB7MOzyImLwYAXwdfJjWfRJ+QPlW7RLksH3Z8pG5SaCoHjRaaD0IfPISMz5dRtHUpAFpnZ7wmTMBj4JPS+E0IUSNJYBHib2Iyivho41k2nFSfkNhYaRnarg4Tuobi7njlF31URhQzD83kcMZhQN1FeXST0TzR8AnsrOyuON9iTEY4tAy2zYASteU/IV0x3vU8Wd9vJffFEWA0gk6H+4ABeE2cgJX7lSuXhBCippDAIgSQll/G7C3n+O5gEiazglYDD7cIYFrPBvi72V9x/vn883x6+FO2JKg9TWy0NgxsNJCRjUfiantl7xWLURSI/h1+fwWyzqpjXg1Qur1Bzv4MsgZPxVygzptx6tYNn2f+h21IFU7wFUKIaiKBRdzR8ksMzNsey7LdF9Ab1aZvPcJ9efbeMBr4XtkbJaMkg3lH57Emeg0mxYRWo6Vvvb5MiJyAn2MVr7RJO6F2qD2/TT128FQbv+UFkTF9Job4BABsw8Lwff45HNu1q9p6hBCiGklgEXekMoOJL/bE8fm2WPJLDQC0quPOc70b0rquxxXnF5UXsfTEUlacWkGZSV0S3DWwK1OaTyHUPbRqiy1Mh61vw+EVgAI6G2g7nlKv+8n4ZC4lBw4AoPPywmfqFFwfekgavwkhbjsSWMQdxWgy8+PhZGZuPkdqvho86vs48ey9DSvtpWI0G/nh3A98fvRzcsrUCbiR3pFMazmNFr4tqrbY8hLYOxd2zQRDsToW8RCGppPIXPYD+WuHg6KgsbXFY8RwPEeOQuckjd+EELcnCSzijqAoCptOpfPBxrPEZBQBUNvVjmk9G/BwiwB0/6+XiqIo7EzeyccHP67YnLCuS12mtpxK98DuVbsk2GyG46thyxtQkKyO+bfC3Pk1sn8/Rva7Y1BK1X4wLg/2wWfaNKxr1aq6eoQQ4hYggUXc9vZfyOH9DWc4FJ8LgKu9NZO6hTK4XR3srK98dXIm5wwfHfyIP1P/BMDN1o3xzcbzWNhjWGutq7bY+D1q47eUI+qxa6Da+O28NZmjX8GYkQGAfYsW+D7/HPZNm1ZtPUIIcYuQwCJuW2fTCvlgwxm2nFG/5O2stYzoEMzYLvVwtb8yeKQXpzPnyBx+jv0ZBQVrrTWDwgcxqukoXGxcqrbYnPOw6TU4/bN6bOMMnaZTrGtNxhuzKDt1CgDrgAB8/vc/nHvdI43fhBB3FAks4raTlFvCzE3R/HgkCUUBnVZD/1aBTO1RH1+XK3ujlBhKWH5yOctPLqfUqL5qubfuvUxpMYUA54CqLba8GHZ+DHvmXGr81mIo5fWGkP75Uoo2LwJA6+SE1/jxuA8ehFYavwkh7kASWMRtI7/EwGdbo/liTzzlJnWJ8n1N/Hj6njDqeTtdcb7JbOLn2J+Zc2QOmaWZADTzbsYzrZ+hmXezqi1WUeD0OvX1z18bFNbrjqndC2St3kLOC0MvNX57vD9ekyZh5XHl6iUhhLhTSGARNV650cxX++L59I9o8krUJcrtQjx5rndDIgPdKr1mb8pePjr4EedyzwHg7+TPtJbTuKdONbxqyYqB9c9CrNp0DtdAlB7vkHskn6yBT2HKzwfAsUtnfJ95BtvQKl42LYQQNYAEFlFjKYrCxpPpvLf+NHHZJYC6RPnF+8Pp2sC70uARmxfLxwc/ZmfyTgCcrZ0Z03QMT4Y/iY2uil+1/P/XPzob6DCFIqUN6c/MpDwuDgDb+vXxee45nDp2qNp6hBCiBpHAImqko4l5vPPrafbHqb1RvJxsmN4zjP6tArD6f7soA2SXZvN51Of8EP0DJsWElcaKxxs+ztimY3G3q+I9dhRFnUy74UUoSFLHQntS3nQa6fNWUrR1CgA6T0+8n3oKt0ceRmMl/2kKIcTfyd+KokZJyi3hw41nWRuVAqgrf0Z3CmFsl3o42V75/85lxjK+Ov0Vi48vpvhi87Xugd2Z1nIadV3rVn3BWTGw/hmI/UM9dg3C3P0tsnckkj1oAkp5OVhZ4TFkCF4TxqNzunKujRBCCAksooYoKDPw+dZYlu6+QLnRjEYDDzX355leYdRyvXJzQrNi5rcLv/Hp4U9JLU4FINwjnGdaP0Nrv9ZVX3B5Mez4SH39YzaAzgal/RSKjC1Jf/oTDEnqkxaHdm3xe/llbOvVq/qahBCiBpPAIm5pBpOZb/YnMHNzNDnF5YA6ofal+8Np7F/5rsiH0g/x0YGPOJF9AgBfB1+mtJjC/SH3o9Vc+brIoip7/VP/HsobP0Xa519RvH0lAFZ+fvg+/xzOvXpJPxUhhPgPJLCIW5KiKGw5ncG7609zPlN9lVPP25EX7wune8Mr9/wBiC+IZ+ahmWxJUFffOFg5MLLJSAY3Goy91ZVPYSwuKxp+ewbOb1WP3YIwd3uLrK3x5AyaiGIwgLU1nsOG4TVuLFpH2fdHCCH+Kwks4pZzIjmfd349zd7z2QB4ONowrUd9nmgThHUlE2qLyotYcGwBX53+CqPZiFaj5eH6DzMxciJe9l5VX7C+CHZ8qG5UaDaAzhalwxQKyyPJmPYJhhR1vo1jhw74vvQStiHBVV+TEELcZiSwiFtGSl4pH/1+ljVHklEUsLHSMrJjMOO71sPF7spW+mbFzM+xPzPr0Cyyy9Rw06F2B55u9TT13etXfcGKAqd+go0vXdqksP496COeIv2zLyne9RUAVrVr4fv88zj37Cmvf4QQ4jpJYBE3XZHeyPxtsSzaeR69Ue1Q2y+yNv/rFUaAu0Ol1xzPPM6M/TM4nnUcgDoudXi29bN0DuhcPUVnnlNX/5zfph67BWHu+iZZf1wg5z319Y/G2hqPkSPwGjsWrX01vJISQojbmAQWcdOYzQrfH07igw1nySrSA9Cmrgcv3R9Os6t0qM0qzWLWoVmsjV0LqPNUxjYby6DwQVXf+A2u/vqntCnp02ZiTFVXJDl27oTfiy9iU7du1dckhBB3AAks4qY4nJDLGz+f5GiS2oY+2MuR53s35J5GvpW+NjGYDKw8vZL5x+ZX9FN5sN6DTG0xFW8H76ovuLLXPw3uRd9wAumffUHxHvX1j7W/P74vvoBT9+7y+kcIISxIAouoVhkFZby34Qw/Hla/9J1srZhyd32Gtq+LjVXlS453Ju3kgwMfEFcQB0Bjz8Y8f9fzVb9B4V8yz8Fv/4ML29Vjtzrq65/NMWTPmAwGAxobGzxHjcJzzGi0dlfuCC2EEOLGSGAR1UJvNLF0Vxyf/RFNcbkJgMdaBvDMvWH4OFf+BR9fEM8HBz5gR9IOADzsPJjaYip9Q/tWfT8VuPj65wPY+/ml1z8dp1FYFE76lFkY09MBcOraFd8XX8AmKKjqaxJCiDuUBBZRpRRF4Y8zGbz1y6mKDQqbB7nxep+Iq85TKTYUs+DYAlacWoHRbMRKY8XA8IGMbTYWZxvn6igaTq5RX/8UqkuSadAbfdh40uYsp2TflwBYBwTg++KLOHfvVvU1CSHEHU4Ci6gysZlFvLnuFNvPZQLg7WzL8/c25KHm/mi1V87vMCtmfjn/CzMPzSSrNAuADv4deLb1s4S4hlRP0Vkx8Ov0y17/mLq8Sdbv58h5dxIYjWhsbfEcMxrPkSPl9Y8QQlSTaw4sO3bs4MMPP+TQoUOkpqayZs0a+vXrd9Xzt23bRrduV/4LNDU1FT8/v2u9vagBCsoMzNkSzbLdcRjNCtY6DSM7hjCpe2ilGxQCnMg6wYw/Z3As6xgAgc6BPNf6OToHdK6eyasmI+z9DLbNAGMZWNmhdJhKQX4YGU99gjFTDV1Od9+N7wvPYxMQUPU1CSGEqHDNgaW4uJhmzZoxYsQIHn744f983dmzZ3Fxcak49vHxudZbi1uc2azw/aEkPth4hqwidd+fuxv68PIDjQj2qrwNfVZpFp8e/pQ1MWsAdZnymKZjGNxocPUsUwZIPQY/T4LUo+pxSDfKwp8iffYySg5efP0TFITfSy/i1KVL9dQkhBDiMtccWHr37k3v3r2v+UY+Pj64ubld83WiZjgUn8sb605y7OIy5RBvR159oBFdwyoPpkazka/PfM3nUZ9TZCgCoE9IH6a2nIqPQzWFWUOZOql21yxQTGDnhqnL62RtTSPn/afAZEJjZ4fXuLF4DB+O1ta2euoSQghxhWqbwxIZGYler6dx48a8/vrrdOjQ4arn6vV69Hp9xXFBQUF1lCiuQ1aRnnd/O12xTNnZ1oopPeozpN3VlykfzTzK2/ve5kzOGQAiPCN4vs3zRPpEVlfZEL8Xfp4M2dHqcaO+FDo9RNoLn2JMSwPAuWdPfJ9/Dmt//+qrSwghRKWqPLDUqlWL+fPn06pVK/R6PYsXL6Zr1678+eeftGjRotJrZsyYwRtvvFHVpYkbYDYrrNqfwAcbzlBQZkSjubhMuVdDvJ0rfxKRr89n1uFZ/HDuBxQUXGxcmNpyKo/Uf6R6likD6Ath8xtwYJF67OSLscMbpK8+SMFvLwLq6h+/117DqVPH6qlJCCHEv9IoiqJc98Uazb9Ouq1Mly5dCAoKYsWKFZX+vLInLIGBgeTn5182D0bcHCeS83nppxMcTcwDoLG/C2/3a0LkVZYpK4rCz7E/88mhT8gpywGgb72+TG81HQ87j2qqGojeBOumQkGSWlfkIPL17cn4ZA6m/HzQavEYPgzvSZNk7x8hhLCAgoICXF1dLfL9fVOWNbdp04Zdu3Zd9ee2trbYynyBW05hmYFPNp3jiz1xmBW1S+3/7mnA4HZ10VWyTBkgJjeGt/98m0PphwAIdQvl5bYv09K3ZfUVXpwNG1+AY9+qx251KG/9CmlL1lO8520AbMPDqfXWW9g3jqi+uoQQQvxnNyWwREVFUatWrZtxa3EdFEXht+NpvPnLSdIL1CdfDzStxSsPNMLXpfI+JCWGEhYcW8CXJ7/EqBixt7JnXLNxDG40GGutdXUVDid/hN+ehZIs0GhRWo8jJ7kumRPfRSkrQ2Nri9ekiXgOG4bGuprqEkIIcc2uObAUFRURExNTcXzhwgWioqLw8PAgKCiIF154geTkZL78Ul0OOmvWLIKDg4mIiKCsrIzFixfzxx9/8Pvvv1vutxBVJj67mFfWnmTHxeZvdT0deLNvYzo3uPqGg1sTtvLe/vdIKVa7xHYL7MbzbZ6ntlPtaqkZgIIU+PVpOPubeuwdTlnjZ0id8w1lJ34CwKFNG2q9+YbsqCyEEDXANQeWgwcPXtYIbvr06QAMHTqU5cuXk5qaSkJCQsXPy8vLefrpp0lOTsbBwYGmTZuyefPmSpvJiVuH3mhiwfbzfLY1hnKjGRudlvFd6zG+az3srHWVXpNSlMKM/TPYlrgNgNqOtXnhrhfoGti12urGbIbDX8CmV0FfAFprzG2nknXMjuwJr4HJhNbZGd/nnsX1kUdkR2UhhKghbmjSbXWx5KQd8e92x2Txyk8nOJ9VDEDHUC/e7BtBiLdTpecbTAa+PPUlC44toNRYipXGiqERQxnTdAwO1g7VV3h2LKybAnE71WP/VhTXGU/ax4spj48HwLlXL3xfehFraVwohBBVrsZPuhW3pqwiPW/9coq1UeqrHG9nW155oBF9mta66pOIQ+mHeGvvW8TmxwLQyrcVL7d9mXpu9aqtbkxG2Pc5bH1Hbatv7YCp7bNkbMsh7+NXALDy8cHv1Vdw7tGj+uoSQghhMRJYhLrs+GgKr/98ktwSA1oNDG5bh6d7heFiV/lE1MLyQmYemsnqc6sB8LDz4OlWT9MnpE/1vmZJOw5rJ0FqlHoc0pUC5/6kv76gYv8ftycex+fpp9E5V8NOz0IIIaqEBJY7XHpBGS+tOc7m0xkAhNdy4f1HmtA0wO2q12xL3MZb+94io0S95pH6jzCt5TRcbV2roeKLjHrY8SHsmglmI9i5Ymj9AulrTlG4WV2qbFO3LrXefguHVq2qry4hhBBVQgLLHUpRFFYfSuKtX05RWGbEWqfhqe71Gde1Hta6yrvOZpdm897+99gQtwGAIOcgXm//Oq39Wldn6ZByBH4cC1lnAVDCHiDP0I2M5xdiLiwEKys8R43Ea/x42f9HCCFuExJY7kBJuSW88ONxdkZnAdAswJUPHm1GmF/lr0wUReGX87/w/oH3ydfno9PoGBIxhAnNJmBnVXkfliphNsGuT2Dbe+pTFUcf9M2fI+2LHZQc+BgAuyZNqPX2W9iFhVVfXUIIIaqcBJY7iNmssHJ/Au/9dprichM2Vlqe7tmAkR2DsbrKU5WUohTe3Pcmu5N3AxDmHsYbHd4gwrOaO8LmXIA1YyHxTwCUsAfJzm5J1vQ5KOXlaOzt8Zk6BfdBg9DoKl92LYQQouaSwHKHiM8u5rkfjrHvvLqXT6s67rz/aFPqXWWpslkx882Zb5h1eBalxlJstDaMjxzP0Iih1depFtRutVErYf1zUF4ENs6URfyPlGXb0J9ZAIBjx474vf46NgGyq7IQQtyuJLDc5kxmheV74vhw4xnKDGbsrXU8e28YQ/5h/5/zeed5bc9rRGVGAdDCpwWvt3+dYNfgaqwcdQ+gX6bA6XUAKAHtyC7uTubLS8FgQOfmhu+LL+DSp5pXJgkhhKh2ElhuYyl5pUz/LqriqUq7EE/ef6QpQZ6VN3MzmA0sPb6UBccWYDAbcLByYFrLafQP649WU/kroyoTvRnWToCidNBaUx4xiZTvz1J6ZBkATnffTa0338DK07N66xJCCHFTSGC5Ta07msJLa45TUGbE3lrHS/eH82SbILRXeapyNucsL+16ibO56sqbTv6deKXtK9RyquZNKstLYPNrsH8hAIpnA/JsnyD9nVUoJSVoHR3xfeklXB/qJ09VhBDiDiKB5TZTWGbgtbUn+fFIMqCuAJr1RHOCvRwrPd9kNrH85HLmRs3FYDbgZuvG822e577g+6o/EKREwY+jIescAIaGw0jdXEzxrsWAullh7RnvYu0vc1WEEOJOI4HlNnIwLodp30WRmFOKVgOTuoUy+e76V+2rkliQyEu7X+JIxhEAugZ25bV2r+Fl71WdZavLlXfPgq3vqsuVnfwo8BpF2swfMOXno7GxwXv6NDyGDEGjreZXU0IIIW4JElhuA0aTmTl/xDDnj2jMCgS42zPr8Uha1fWo9HxFUVh9bjUfHfyIUmMpjtaOPN/mefrW61v9T1Vy42DNOEjYC4Ap+H7SorwoWLwUALtGjaj9wfvYhoZWb11CCCFuKRJYarjU/FKmfBPF/gvqxNqHW/jzxoMROF9lD6D04nRe2/taRV+V1n6tebvD29R2ql1tNQPqcuWjX8Nvz0J5Idg4UxQwjtQlmzGmHwGdDq+xY/AaNw6NjU311iaEEOKWI4GlBttyOp3/rT5KbokBJ1sr3nmoMX0jK5/foSgK6y+s5+0/36awvBBbnS1TWkxhYPjA6l8BVJID66bA6Z8BMPu1ISOxObnvrgTApk4dan/wPvbNmlVvXUIIIW5ZElhqoHKjmfc3nGHJrgsANPZ34bMBLah7lYm1eWV5vP3n22yM2whAhGcE73Z8lxC3kGqruULMZvhpIhSlgdaK0jqjSPn6GOVxaq8V9yefxOd/T6N1qHzptRBCiDuTBJYaJj67mMlfH+FYUj4AwzvU5fneDbG1qrwd/Y6kHby25zWySrPQaXSMbTqWUU1HVW+3WgBjOWx5A/Z+BoDiXp/MwnvIfn8tmM1Y+fpS6513cOrYoXrrEkIIUSNIYKlB1h1N4YUfj1OkN+LmYM2HjzajZyPfSs8tM5bxwYEPWH1uNQAhriG82/FdIryqeQ8ggLxE+H44JB0AQB80gJR16ZSdXgOAywMP4PfKy+hcXau/NiGEEDWCBJYaQG808fYvp1mxLx6A1nXdmf1Ec2q72Vd6fnxBPE9ve5qzuWfRoGFQo0E81fyp6t1Z+S/nNqqbFpbmoti6kqMbQOasDSjl5ehcXfF7/TVceveu/rqEEELUKBJYbnFJuSVMXHmYoxdfAU3sVo9pPRpcdXfljXEbeW3PaxQbivGw82BGpxm0r92+OktWmYyw9W3YNRMAg3NTUg77U3JInWjr2LkTtd56G2tfn+qvTQghRI0jgeUWtvVMBlO/jSK/1ICbgzUzH4+kW1jlX/AGk4GPDn7EqjOrAHXDwg86f4CvY+WvjKpUQQp8PxIS9gBQ5NSPlO+jMeUeRWNvj+9zz+H2eH9prS+EEOI/k8ByCzKZFWZtPsecP2IAtb3+3IEtCHCvfOVMclEyz2x/huNZxwEY0XgEk5tPxkp7E/7PG7MFfhwDJVkoVs5kFN5Hzjc7AbAND8f/k4+xDa7mXZ+FEELUeBJYbjHZRXqmfBPFrpgsAAa3rcPLD4RfdRXQruRdPLfjOQrKC3CxceHdju/SJbBLdZasMptg+/uw/QNAody+ESn7fSk9qYYV94ED8Xn2GbS2ttVfmxBCiBpPAsst5EhCLuO/OkxaQRn21jree6TJPzaCW3x8MXOOzEFBoYlXEz7q8lH1d6wFKEyHH0fBhR0AFNjcR+r3sZgLz6J1dqbWO2/jcs891V+XEEKI24YEllvEdwcSefmnE5SbzIR4OzJ/UEsa+DpXem6xoZiXd73M5oTNADzW4DGeb/M8Nrqb0ML+wk74YSQUpWPWOpKR05PcDfsBsGvWFP+PP8YmIKD66xJCCHFbkcByk5Ubzbz1y6mKJcv3NPLl4/7NrroXUFx+HFO2TuF8/nmstda8dNdLPNLgkeosWWU2w66P1R2WFTPl1g1I2ueDPloNKx4jR+AzdSoa62puUCeEEOK2JIHlJsos1DNh5SEOxOUCML1nAyZ1C0WrrXz1zPbE7Ty/83mKDEX42Psws9tMmno3rc6SVcVZ6sTa2C0A5NODtB/iMJecR+fmRu3338Opy02YRyOEEOK2JYHlJolKzGPcikOkFZThbGvFrCciuTu88iXIZsXMgqML+Pzo54C6ZPnjrh/jZe9VnSWrEvbB6uFQmIIZe9LSu5K/9SgA9q1a4v/RR1j7+VV/XUIIIW5rElhugrVRyTzz/THKjWbqeTuycEgr6nk7VXpuUXkRL+x6gW2J2wAY0HAAz7R6BmvdTXjVcmAJrH8WzEb01CP5Ty/0F46CRoPX+HF4TZiAxkr+X0oIIYTlybdLNVIUhVmbo5m9JRqAHuG+zHz86vNVEgsTeeqPp4jJi8FGa8Mr7V6hX2i/aqz4ImO5GlQOLUNRIF/fgbQNKShliei8vfD/4AMc27Wr/rqEEELcMSSwVJMyg4lnvj/GuqMpAIztEsJzvRpedb7KwbSDTNs2jTx9Ht723nza/VMaezWuzpJVRZnw3RBI2IPZqCU1qSMF+9SGdo7t21P7g/ex8roJr6aEEELcUSSwVIPMQj1jVhzkSEIeVloN7z7UhP6tA696/o/RP/LWvrcwmo1EeEYwu9vsm9NiP/UofP0kFCRRXu5K0uH66ONiQKfD+6mn8Bw9Co228j2NhBBCCEuSwFLFzqQVMHL5QZLzSnFzsGbewJa0q+dZ6bkms4mPD33MilMrAOhVtxdvdXgLe6vKd2WuUse/h7WTwFhKUVFdkrfbYC5MQefpif/MT3Bs06b6axJCCHHHksBShbadzWDiysMUl5sI8XJkybDWBHs5VnpuYXkhz+54ll3JuwCYEDmBcU3HVf8GgWYT/PEW7JqJokB2ejMyt2eBUo5d06YEfDpbVgEJIYSodhJYqsiaI0k8s/oYRrNCuxBP5g1qgZtD5Z1oU4tSmbBlAjF5Mdjp7Hi749v0qturmisGyvLhh9EQvRGTQUNqdEsKj6lzbtweexTfV15Ba3MTuukKIYS440lgqQKLd57n7V9PA9AvsjYfPNoMG6vK53qczj7NxC0TySzNxNvemzl3zyHCM6I6y1VlxcDXT0B2NPpiB5IOh1KenILG2hrfV17GvX//6q9JCCGEuOiaZ0zu2LGDPn36ULt2bTQaDT/99NO/XrNt2zZatGiBra0toaGhLF++/DpKvfUpisKHG89UhJWRHYP5pH/kVcPKjqQdDN0wlMzSTELdQll538qbE1aiN8Gi7pAdTWF2beK2+FGenIWVry91VnwpYUUIIcRNd82Bpbi4mGbNmjF37tz/dP6FCxe4//776datG1FRUUydOpVRo0axcePGay72VqYoCu/8epq5W2MBePbeMF6+P/yqy5a/O/sdT/3xFKXGUtrWasuXvb+kllOt6iwZFAV2z4aVj6GU5pMR35CkTWAuKcO+VUuCf/ge+8jI6q1JCCGEqMQ1vxLq3bs3vXv3/s/nz58/n+DgYD7++GMAwsPD2bVrFzNnzqRXr5swT6MKmM0Kb6w7yRd71Q0M3+wbwZB2dSs/VzEz+/Bslp5YCkDfen15rd1r1d+51mSAdVMh6itM5RqSTzah+Gw2AO6DB+P77DOycaEQQohbRpXPYdm7dy89evS4bKxXr15MnTr1qtfo9Xr0en3FcUFBQVWVd8PMZoWXfjrB1/sT0Gjg3YeaMKBNUKXnGkwGXt79Mr9d+A24iSuByvLVZnDnt1GWb0PSoXoYMrLR2NpS6603cX3wweqtRwghhPgXVR5Y0tLS8PW9vOmZr68vBQUFlJaWYm9/ZY+RGTNm8MYbb1R1aTdMURRe/VkNK1oNfPBoMx5tGVDpuSWGEqZvn87u5N1Yaax4vf3r9A3tW80VA3mJsPIxyDxNQbIbKfvdUPT5WNeuTcBnc7Br1Kj6axJCCCH+xS3ZpvSFF14gPz+/4k9iYuLNLukKiqLw5i+n+Gqf+mTlk/6RVw0r+fp8xmwaw+7k3djp7Pi0+6c3J6ykRMHiu1EyTpN5zo/knQ4o+nIc27ej7g/fS1gRQghxy6ryJyx+fn6kp6dfNpaeno6Li0ulT1cAbG1tsbW1rerSrpuiKLy/4SzLdscB8P7DTenX3L/Sc9OL0xm3eRwxeTG42Lgw9+65RPpEVl+xfzm3EVYPx1xWTOrROhScMwDgMWwYPs/8D41OV/01CSGEEP9RlQeWdu3a8dtvv102tmnTJtrV4N19Z26OZv52dTXQ2/0aX3VfoLj8OMZsGkNqcSo+9j4s6LmAUPfQ6ixVdWAx/PYMxlJIOhBCaXIZWFnh9+orsmRZCCFEjXDNr4SKioqIiooiKioKUJctR0VFkZCQAKivc4YMGVJx/rhx4zh//jzPPvssZ86c4fPPP+e7775j2rRplvkNqtncrTF8uiUagFcfaMSgtnUqPe9szlmGbhhKanEqdVzq8OV9X1Z/WDGb4feX4denKcvVEre9LqXJZWhdXAhavEjCihBCiBrjmp+wHDx4kG7dulUcT58+HYChQ4eyfPlyUlNTK8ILQHBwML/++ivTpk1j9uzZBAQEsHjx4hq5pPnr/Ql8uPEsAM/3bsiIjsGVnncq+xRjNo0hX59PuEc483rMw9O+8g0Pq4yhFNaMhVNrKUq1JflPP8xlZVjXCSJw3nxsQyqvXQghhLgVaRRFUW52Ef+moKAAV1dX8vPzcXFxuSk1bD6VzpgVBzErMKlbKP/rFVbpeccyjzFu0zgKDYU09W7KvB7zcLGp5pqLs+DrAZC0n5wYF9IPOYOi4NCqFf5zPsXK3b166xFCCHFHsuT3t+wl9B8cTshl0teHMSvQv1UAT9/ToNLzjmQcYfzm8RQbimnh04K5d8/FycapeovNjYcVD6FkxZJ+zJvcM9aAgutDD1HrjdfRyOaFQgghaiAJLP8iNrOIkcsPUGYw0y3Mm3cealJpo7eojCjGbhpLqbGUNn5tmNN9Dg7WDtVbbPop+OphTDlpJO/3pzhRfXjm/fR0PEeNqv4GdUIIIYSFSGD5BznF5Qxbtp/cEgPNAlyZO7AF1ror5ymfyDrB+M3jKTWWcletu5jTfQ72VpUv2a4yifth5WMYsgtJ3OOPPtuMxs6O2h+8j8s991RvLUIIIYSFSWC5CoPJzMSVh0nMKSXIw4Elw1rjYHPl/1xncs4wdtNYigxFtPRteXPCSvRm+G4wZZnlJO6qhbHIjJW3NwHz5mHf+Cbs/iyEEEJYmASWq3jn19PsPZ+No42OxUNb4eV0ZSO72LxYxvw+hoLyApp5N2Pu3XOrP6wc/x7WjKU4VUvSHj/MejO29UMJXLgQ61rVvPuzEEIIUUUksFTi2wMJLN8TB8DMxyNp4Ot8xTmpRamM2TSGXH0uEZ4RzOsxD0drx+ot9M+FsP5ZChJsSfnTE8VkxqFVKwLmfobO1bV6axFCCCGqkASW/+dQfA4v/3QCgOk9G3BPhN8V5+SV5TF281gySjIIcQ1hfo/5ONtcGWqqjKLAthmw/X1yzjqSHuUKioLzPfdQ+8MP0N7C2xoIIYQQ10MCy99kFuoZ99VhDCaFeyP8mNTtys60JYYSJm6ZyIX8C/g6+LKg5wLc7Nyqr0izGdY/g7J/MRlHXcg5oy6bdh84EN8XX5A9gYQQQtyWJLBcZDYrPL36KJmFeur7OPFx/2ZotZcvAzaYDfxv+/84lnUMFxsXFvRcgJ/jlU9gqozJAGvGoRz9npT97hTEq/NlvKdPx3O0LFsWQghx+5LActGinefZcS4TO2stcwe2wNH28v9pFEXh9T2vszN5J3Y6O+bePZd6bvWqr0BjOXw/HNPxX0ne7UVxmg1YWVHr7bdw69ev+uoQQgghbgIJLMCRhNyKPYJe6xNR6STbmYdn8nPsz+g0Oj7q8hGRPpHVV6ChDL4bgvH4JhJ3eFOWY4XGwYGA2bNx6tSx+uoQQgghbpI7PrAU641M+SYKo1nh/qa1eKJ14BXn/Bj9I8tOLAPg9fav0yWwS/UVWF4M3zyJ4cQOErZ5U16gQ+fhQeCCBdg3aVx9dQghhBA30R0fWN5bf4aEnBL83eyZ8fCVbfcPpx/mrX1vATCh2QT6hfarvuL0hbDqccpP7CNhmw+GYi1WtWoRtGSJ7LYshBDijnJHB5bdMVms2BcPwIePNsXFzvqyn6cUpTBt2zSMZiP31LmHcc3GVV9xpXmw8lHKThwhYZs3pjItNnXqELRsKda1a1dfHUIIIcQt4I4NLEV6I89+fwyAwW3r0D7U67KflxhKmPzHZHLKcgj3COftjm9X3yqckhxY0Y/S46dI2OGNuVyDbcOGBC1ehJWX179fL4QQQtxm7tjA8tHGsyTnlRLoYc/zvRte9jNFUXhtz2ucyz2Hp50nn3b/tPpa7hdnwRcPUnwsmsRdXihGDfaRkQQumC/da4UQQtyx7sjAciI5ny/3xgEw46GmVyxh/ubsN2yI24CVxopZ3WZVX6+V4mz44kEKD8eSvMcTxazBsX17Aj6bg9bBoXpqEEIIIW5B2ptdQHUzmxVe/ukEZgX6NKtNx/qXv2I5kXWCDw58AMC0ltOqb/lySQ6s6Ev+gViSdrujmDU49+xJwPx5ElaEEELc8e64wPLtwUSiEvNwsrXi5fvDL/tZvj6fp7c9jdFspEdQDwY3Glw9RZXmwop+5O+LIWWfOygaXPv2xX/mJ2htbKqnBiGEEOIWdkcFlvxSAx9sOAPAtJ4N8HWxq/iZWTHz0q6XSClOIcApgDc7vFk9k2zL8mHFw+TtPkfKPjdQNLg99ii1ZryLxuqOfGMnhBBCXOGO+kacvz2W3BID9X2cGNquzmU/W3FqBduTtmOjteGTrp9Uz+7LZQXw1SPk7jxD2gE3QIPbgCfwe+UVNNo7KksKIYQQ/+iOCSwpeaUs3XUBgOd7N8RKdykQnMs9x+zDswF4rs1zhHuGV/oZFqUvhJWPkrv1JGmH3ABwHzQI35delE0MhRBCiP/njgksMzedQ2800ybYg+4NfSrGy03lvLjzRQxmA10CuvBYg8eqvpjyYljZn5wtJ0g/7AaAx9Ch+Dz/nIQVIYQQohJ3RGC5kFXMD4eTAHihd8PLQsHcqLmczT2Lu607r7d/veoDQ3kJrHqc7E1HyTii9lXxHDUS76eflrAihBBCXMUdEVjmbo3BrMDdDX1oHuReMX4k40jFpoavtXsNL/sq7iJrKIOvnyB7/WEyjl4MK+PG4j1lioQVIYQQ4h/c9oElMaeENUeSAZh8d/2K8XJTOa/teQ0FhQfrPcjdde6u2kJMBvh+ONnrD1aEFa9Jk/CaOEHCihBCCPEvbvvA8vm2GExmhc4NvIkMdKsYX3J8CRfyL+Bp58mzrZ+t2iLMZlg7kZx128iIUmvwmjwJ74kTq/a+QgghxG3itl47m1mo54dD6tOVp7qHVoyfzzvPouOLAHj+rudxta3CPXoUBTY8R+6adRUTbD3HjZWwIoQQQlyD2zqwrPwznnKTmeZBbrSq6wGoDeLe2PsGBrOBzgGd6VWnV9UWsfVd8r5dQdoBNRR5DB+O95QpVXtPIYQQ4jZz2wYWvdHEV/sSABjeIbhifG3MWg5nHMbeyp6X7nqpaueP7J1L/opPSd3vBmhwHzgQn2efkTkrQgghxDW6bQPLr8dSySrS4+diR+/G6m7LxYbiigZxE5pNoLZT7aor4PAKCha/WbE3kNtjj0lTOCGEEOI63baBZfmeOAAGt6uD9cWutkuOLyG7LJsg5yAGhg+supufXkfh/GdI3ntxI8N+/fB743Vpty+EEEJcp9vyG/RkSj7HkvKx1ml4onUgAClFKXxx8gsApreajrXOumpuHr+XojnjSN7lBmYNLvfdR6133pawIoQQQtyA2/JbdPVBtavtPY388HSyBWDWoVmUm8tp7dea7oHdq+bGmWcp/fRJknY4oZg1OPe4m9rvv4dGp6ua+wkhhBB3iNsusOiNJn6KUpcyP9YqAICjmUdZH7ceDRqeaVVFk14LUtHPeZjETdYoRi2O7e7C/5NP0FhX0ZMcIYQQ4g5y2wWWLaczyCsx4OdiR6f63gB8duQzAB6s92DV7MRcVoBh/sMk/FKOqVyHXUQ4AZ/NRWNjY/l7CSGEEHeg2y6wrDuaAkC/5v7otBoOpR9iX+o+rLRWjI8cb/kbGssxLhtAwveZGEussKkTSODiJWgdHS1/LyGEEOIOdV2BZe7cudStWxc7Ozvuuusu9u/ff9Vzly9fjkajueyPnZ3ddRf8T4r0Rv44kwFAn2a1APg86nMAHgp9CH8nf8ve0GzG/N04Er86Q3mBNVbeHgQtW46Vu/u/XyuEEEKI/+yaA8u3337L9OnTee211zh8+DDNmjWjV69eZGRkXPUaFxcXUlNTK/7Ex8ffUNFXs/lUOnqjmRAvRxrVcuFA2gH2p+3HWmvN6CajLX4/ZeOrJC3cSlm2DTpnB4KWfYF17Srs7SKEEELcoa45sHzyySeMHj2a4cOH06hRI+bPn4+DgwNLly696jUajQY/P7+KP76+vjdU9NX8ckx9HfRA01poNBqWnFgCwMP1H6aWUy2L3kvZt5CUmSsoTrNDY2tN4KIl2IaG/vuFQgghhLhm1xRYysvLOXToED169Lj0AVotPXr0YO/evVe9rqioiDp16hAYGEjfvn05efLkP95Hr9dTUFBw2Z9/U6w3suNcFgD3N63N2Zyz7E7ejVajZWjE0P/4G/43ypnfSH/nbQoSHECrIeCzz7GPjLToPYQQQghxyTUFlqysLEwm0xVPSHx9fUlLS6v0mrCwMJYuXcratWv56quvMJvNtG/fnqSkpKveZ8aMGbi6ulb8CQwM/NfadkZnUW4yE+ThQANfp4omcT3r9CTQ+d+v/89Sj5L92kRyo9VJtbU/+ACnTh0t9/lCCCGEuEKVrxJq164dQ4YMITIyki5duvDjjz/i7e3NggULrnrNCy+8QH5+fsWfxMTEf73PltPpAPQI9yWtOI31F9YDMDxiuGV+EYCCFPJef5zMo+qkYd8Xn8f1gQcs9/lCCCGEqJTVtZzs5eWFTqcjPT39svH09HT8/Pz+02dYW1vTvHlzYmJirnqOra0ttra2/7kuk1mpWB3UI9yHb86uwKgYaePXhgiviP/8Of9IX0Txew+RukM99BwxBI8hln3VJIQQQojKXdMTFhsbG1q2bMmWLVsqxsxmM1u2bKFdu3b/6TNMJhPHjx+nVi3LTYKNSswju7gcZzsrmgU5sSZ6DQBPhj9pmRuYTZTNG0jSujxQNLj07Ir3/56zzGcLIYQQ4l9d0xMWgOnTpzN06FBatWpFmzZtmDVrFsXFxQwfrr56GTJkCP7+/syYMQOAN998k7Zt2xIaGkpeXh4ffvgh8fHxjBo1ymK/xI5zmQB0buDNtqQt5Opz8XXwpUtAF4t8vmH1MyR+eQqzwQr7Jg2o9fFs2cxQCCGEqEbXHFgef/xxMjMzefXVV0lLSyMyMpINGzZUTMRNSEhA+7cv89zcXEaPHk1aWhru7u60bNmSPXv20KhRI4v9Ertj1NVBnet78d3Z2QA80uARrLTX/Otdwbzzc5JmrcVYYoNNbS8CF32BVlruCyGEENVKoyiKcrOL+DcFBQW4urqSn5+Pi4vLZT8rLDMQ+eYmTGaFFeMDmbBtIDqNjt8f/R0fB58buq9ybjNJ48ZQlGKLztmOuj/+jM1/WLEkhBBCiH/+/r5WNf69xv4LOZjMCnU9HdibsQGAboHdbjysZMWQ/uw4ilJs0VhpCVy4TMKKEEIIcZPU+MCy6+LroHb13Pnt/G8A9A3te2MfWpZPznOPknvGGoDaH7yPffPIG/tMIYQQQly3Gh9Y9sRkA+Drm0h2WTZutm50qN3h+j/QbKLgnf5k7C4DwGfqeFzuk14rQgghxM1UowNLXkk5Z9MLAYjX7wTg3rr3Yq2zvu7PLPtiGik/xgEa3Pv2xGPsZAtUKoQQQogbUaMDy+GEXACCva3YnboNgD71+lz35xm3LyFxznoUkxbHZqH4vvMJGo3GEqUKIYQQ4gbU6MByIE4NLLX9Yyg1llLHpQ5NvJpc12eZz+8j6aUZGEussPFxxn/RSjRWN74sWgghhBA3rkYHlkMXA4ve5hgAver2uq4nIkpBGmlThlGaZY3WTkfA8m/Q3eDyKyGEEEJYTo0NLHqjiaNJeaAp50LxIQB6BPW49g8yGch59mHyozWgAf+ZM7ENCbFssUIIIYS4ITU2sJxILkBvNOPmeYFys57ajrVp6NHwmj+ncOZoMrblAOA7dQxO3XpaulQhhBBC3KAaG1gOxashw937LADdg7pf8+sg/a+fkbJ8L6DBrVdb3MdMtXCVQgghhLCEGhtYDsblAiYKtUcB6FHn2l4HmaL3kfj6p5iNWhzq++L30UJZESSEEELcompkYFEUhcMJeegcLqA3F+Nh50Gkd+R/v74oi5SJIzAU6rB2tcZ/+fdorK+/d4sQQgghqlaNDCxpBWVkFemxdlZfB3UO6IxOq/tvF5tNZE17iKIEBY0O/D9fgJWnVxVWK4QQQogbVSMDy/GkfADsXWMA6OD/31vxF346kayd6v5DtZ6diH3LdpYvUAghhBAWVTMDS3I+Gqs8jLpUtBot7Wr9t9Ch37KclCVbAXC/tw2uQydVZZlCCCGEsJAaGViOJeVj5RgNQGPPxrjauv7rNaaE4yS9OAOzQYt9iAe+Hy6u6jKFEEIIYSE1LrAoisKJ5Hx0TueA//Y6SNEXkzp+IOX5WqycdAQslUm2QgghRE1S4wJLSn4Z2cWlWDmq81fa127/r9dkP/c4hbEGNFqFgE8/xcqvVlWXKYQQQggLqnGB5XhSHlr7JDS6UpxtnGns1fgfzy/68h0yN6jhxnfSIOzbd6+OMoUQQghhQTUvsCTnY+UQC0DbWm2x0l59R2XDiV2kfPwloMGtY33cJ7xcTVUKIYQQwpJqXGA5lpSPzuECAK18W131PKU4n+RJYzHptdj52eI755vqKlEIIYQQFlajAouiKJxMyUXnEAdAK7+rBBZFIWPKo5SmmdHaKPjP/wKtvUP1FSqEEEIIi6pRgSWrSE+e+TwarQFXGzdC3UIrPa9w4cvk7EoCoNZzE7Fp2Kw6yxRCCCGEhdWowHIuvQirv14H+bVEq7my/PLDm0n57HsAPHo2wWXg5GqtUQghhBCWV8MCSwE6h/NA5fNXzPmZJE95Sm0OF2CPz0crqrtEIYQQQlSBGhVYTqfmo7OPA6C1X+vLf6gopE9+jLJMBZ0t+C9cicbWtvqLFEIIIYTF1ajAcirrDBpdOQ46Z+q717/sZ/lzniNvfzqg8H/t3WtMVHcaBvBnuMyAUgYVnQEExHhhqzKsKOO067opk5LGbUT7gTUmpa2JqR0tSjdZ2m2lbTY7pEa32lKtcbemHypKE+xq2m4J6nTb4oUBVmmVqKGFrAyjZh1wlEuZdz8YjzuVbjp14JyB55ecBP7nf4aXeTiZN4dzSa34PWJn/kKdIomIiCjsIqph6eo/DwBYkJwbdP5Kv/souvb8HQAw5bd5SFi1VpX6iIiIaGREVMMCw+0rf5akLlSGAjd8+Hfp85DvdZiQOQFTnftUKo6IiIhGSkQ1LNHxHQAAy7S7lyl7N/8O/VeHEB0nSN31Ph9qSERENAZFVMMSFdsLHaKU5wf1vr8V//nntwCA1D+sR+zMeSpWR0RERCMlohoWADDFzUR8TDwGL/wLXdv+CgCY/JtZSFhdqnJlRERENFIirmGZPyUHMjiAy46nMNSvg2FaDKZu3692WURERDSCIq5hWZq+CNf++BRudvRBFyNI21GFqAkJapdFREREIyjiGpa8c9/iyuEmAIB53UoYfvlrlSsiIiKikRZRDYvx1kQM/OkdQHRIzJ0K48Y/q10SERERjYKf1bBUVVVhxowZiIuLg9VqxalTp/7v/JqaGmRnZyMuLg4LFizAxx9//LOKff4ffnx/A4hN1MH8zkHodLqf9TpEREQUWUJuWA4cOICysjJUVFSgqakJFosFhYWF8Hq9w87/6quvsHr1aqxduxbNzc0oKipCUVERWltbQy521qXvAZ0grfJ1RE82h7w9ERERRSadiEgoG1itVixevBhvv/02ACAQCCA9PR0bN25EeXn5PfOLi4vh9/tx5MgRZWzJkiXIzc3F7t27f9LP7OnpgdFoxKlZszFz9a8w5fW/hVIyERERqeDO57fP50NiYuJ9vVZIR1gGBgbgdrtht9vvvkBUFOx2OxoaGobdpqGhIWg+ABQWFv7ofADo7+9HT09P0AIAcTMmYPKWPaGUTERERGNASA3L1atXMTQ0BJPJFDRuMpng8XiG3cbj8YQ0HwCcTieMRqOypKenAwDS/rIXupiYUEomIiKiMUCTVwm9+OKL8Pl8ytLZ2QkAiMmYo3JlREREpIaQDlckJycjOjoa3d3dQePd3d0wm4c/CdZsNoc0HwAMBgMMBkMopREREdEYFtIRFr1ej7y8PNTX1ytjgUAA9fX1sNlsw25js9mC5gNAXV3dj84nIiIi+qGQTwgpKytDSUkJFi1ahPz8fLz55pvw+/14+umnAQBPPvkk0tLS4HQ6AQClpaVYtmwZtm3bhuXLl6O6uhqNjY3Ys4cnzxIREdFPE3LDUlxcjCtXrmDLli3weDzIzc3Fp59+qpxY29HRgaiouwduHnroIXzwwQd4+eWX8dJLL2H27Nk4dOgQ5s+fH77fgoiIiMa0kO/DooZwXsdNREREo0O1+7AQERERqYENCxEREWkeGxYiIiLSPDYsREREpHlsWIiIiEjz2LAQERGR5rFhISIiIs1jw0JERESax4aFiIiINC/kW/Or4c7NeHt6elSuhIiIiH6qO5/b4bipfkQ0LNeuXQMApKenq1wJERERheratWswGo339RoR0bBMnjwZwO0HK97vL0z3p6enB+np6ejs7ORznVTGLLSDWWgL89AOn8+HjIwM5XP8fkREw3Ln6c9Go5F/fBqRmJjILDSCWWgHs9AW5qEddz7H7+s1wlAHERER0Yhiw0JERESaFxENi8FgQEVFBQwGg9qljHvMQjuYhXYwC21hHtoRzix0Eo5rjYiIiIhGUEQcYSEiIqLxjQ0LERERaR4bFiIiItI8NixERESkeZpvWKqqqjBjxgzExcXBarXi1KlTapc0Lnz++ed4/PHHkZqaCp1Oh0OHDgWtFxFs2bIFKSkpiI+Ph91ux4ULF9QpdgxzOp1YvHgxHnjgAUybNg1FRUVoa2sLmtPX1weHw4EpU6YgISEBTzzxBLq7u1WqeGzbtWsXcnJylBuS2Ww2fPLJJ8p6ZqGOyspK6HQ6bNq0SRljFqPn1VdfhU6nC1qys7OV9eHKQtMNy4EDB1BWVoaKigo0NTXBYrGgsLAQXq9X7dLGPL/fD4vFgqqqqmHXv/HGG9i5cyd2796NkydPYuLEiSgsLERfX98oVzq2uVwuOBwOnDhxAnV1dRgcHMSjjz4Kv9+vzNm8eTMOHz6MmpoauFwuXL58GatWrVKx6rFr+vTpqKyshNvtRmNjIx555BGsWLECX3/9NQBmoYbTp0/j3XffRU5OTtA4sxhd8+bNQ1dXl7J88cUXyrqwZSEalp+fLw6HQ/l+aGhIUlNTxel0qljV+ANAamtrle8DgYCYzWbZunWrMnb9+nUxGAyyf/9+FSocP7xerwAQl8slIrff99jYWKmpqVHmnDt3TgBIQ0ODWmWOK5MmTZK9e/cyCxX09vbK7Nmzpa6uTpYtWyalpaUiwv1itFVUVIjFYhl2XTiz0OwRloGBAbjdbtjtdmUsKioKdrsdDQ0NKlZG7e3t8Hg8QdkYjUZYrVZmM8J8Ph+Auw8EdbvdGBwcDMoiOzsbGRkZzGKEDQ0Nobq6Gn6/HzabjVmowOFwYPny5UHvOcD9Qg0XLlxAamoqZs6ciTVr1qCjowNAeLPQ7MMPr169iqGhIZhMpqBxk8mE8+fPq1QVAYDH4wGAYbO5s47CLxAIYNOmTXj44Ycxf/58ALez0Ov1SEpKCprLLEbO2bNnYbPZ0NfXh4SEBNTW1uLBBx9ES0sLsxhF1dXVaGpqwunTp+9Zx/1idFmtVuzbtw9z585FV1cXXnvtNSxduhStra1hzUKzDQsRBXM4HGhtbQ363zCNvrlz56KlpQU+nw8ffvghSkpK4HK51C5rXOns7ERpaSnq6uoQFxendjnj3mOPPaZ8nZOTA6vViszMTBw8eBDx8fFh+zma/ZdQcnIyoqOj7zmTuLu7G2azWaWqCIDy/jOb0bNhwwYcOXIEx44dw/Tp05Vxs9mMgYEBXL9+PWg+sxg5er0es2bNQl5eHpxOJywWC3bs2MEsRpHb7YbX68XChQsRExODmJgYuFwu7Ny5EzExMTCZTMxCRUlJSZgzZw4uXrwY1v1Csw2LXq9HXl4e6uvrlbFAIID6+nrYbDYVK6OsrCyYzeagbHp6enDy5ElmE2Yigg0bNqC2thZHjx5FVlZW0Pq8vDzExsYGZdHW1oaOjg5mMUoCgQD6+/uZxSgqKCjA2bNn0dLSoiyLFi3CmjVrlK+ZhXpu3LiBS5cuISUlJbz7xX2cGDziqqurxWAwyL59++Sbb76RdevWSVJSkng8HrVLG/N6e3ulublZmpubBYBs375dmpub5bvvvhMRkcrKSklKSpKPPvpIzpw5IytWrJCsrCy5deuWypWPLevXrxej0SjHjx+Xrq4uZbl586Yy59lnn5WMjAw5evSoNDY2is1mE5vNpmLVY1d5ebm4XC5pb2+XM2fOSHl5ueh0Ovnss89EhFmo6X+vEhJhFqPphRdekOPHj0t7e7t8+eWXYrfbJTk5Wbxer4iELwtNNywiIm+99ZZkZGSIXq+X/Px8OXHihNoljQvHjh0TAPcsJSUlInL70uZXXnlFTCaTGAwGKSgokLa2NnWLHoOGywCAvPfee8qcW7duyXPPPSeTJk2SCRMmyMqVK6Wrq0u9osewZ555RjIzM0Wv18vUqVOloKBAaVZEmIWaftiwMIvRU1xcLCkpKaLX6yUtLU2Ki4vl4sWLyvpwZaETEQnDESAiIiKiEaPZc1iIiIiI7mDDQkRERJrHhoWIiIg0jw0LERERaR4bFiIiItI8NixERESkeWxYiIiISPPYsBAREZHmsWEhIiIizWPDQkRERJrHhoWIiIg0jw0LERERad5/AU6VyAy/WbwfAAAAAElFTkSuQmCC",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Solve the serial unemployment consumer's problem and display solution\n",
     "start_time = process_time()\n",
@@ -305,15 +241,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:32.952916Z",
-     "iopub.status.busy": "2024-07-11T15:27:32.952560Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.174749Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.174185Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Simulate some data; results stored in cHist, mNrm_hist, cNrm_hist, and Mrkv_hist\n",
@@ -337,15 +266,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.176759Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.176483Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.179195Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.178722Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Make a consumer who occasionally gets \"unemployment immunity\" for a fixed period\n",
@@ -356,15 +278,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.180645Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.180431Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.184495Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.184006Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "StateCount = ImmunityT + 1  # Total number of Markov states\n",
@@ -385,15 +300,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.185937Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.185707Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.188578Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.188134Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Make the Markov transition array.  MrkvArray[i,j] is the probability of transitioning\n",
@@ -413,15 +321,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.190198Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.189723Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.196479Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.196022Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "init_unemployment_immunity = copy(init_indshk_markov)\n",
@@ -442,50 +343,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.197916Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.197696Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.422573Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.422017Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "The calc_limiting_values method must be run before the calc_stable_points method.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Solving an \"unemployment immunity\" consumer took 0.1454 seconds.\n",
-      "Consumption functions for each discrete state:\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/mnt/c/Users/alujan/GitHub/alanlujan91/HARK/HARK/interpolation.py:2188: RuntimeWarning: All-NaN slice encountered\n",
-      "  y = self.compare(fx, axis=1)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Solve the unemployment immunity problem and display the consumption functions\n",
     "start_time = process_time()\n",
@@ -512,15 +372,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.424362Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.424094Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.426783Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.426289Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Make a consumer with serially correlated permanent income growth\n",
@@ -533,15 +386,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.428386Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.428064Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.431463Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.430939Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "IncomeDstnReg = DiscreteDistributionLabeled(\n",
@@ -556,15 +402,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.433208Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.432749Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.435478Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.434951Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Make the state transition array for this type: Persistence probability of remaining in the same state, equiprobable otherwise\n",
@@ -575,14 +414,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.436956Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.436724Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.444107Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.443535Z"
-    },
     "lines_to_next_cell": 2
    },
    "outputs": [],
@@ -615,42 +448,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.445698Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.445437Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.642321Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.641785Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "The calc_limiting_values method must be run before the calc_stable_points method.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Solving a serially correlated growth consumer took 0.1337 seconds.\n",
-      "Consumption functions for each discrete state:\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Solve the serially correlated permanent growth shock problem and display the consumption functions\n",
     "start_time = process_time()\n",
@@ -667,15 +467,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.643965Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.643712Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.648979Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.648525Z"
-    }
-   },
+   "execution_count": null,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Make a consumer with serially correlated interest factors\n",
@@ -690,42 +483,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:27:46.650470Z",
-     "iopub.status.busy": "2024-07-11T15:27:46.650246Z",
-     "iopub.status.idle": "2024-07-11T15:27:46.822371Z",
-     "shell.execute_reply": "2024-07-11T15:27:46.821851Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "The calc_limiting_values method must be run before the calc_stable_points method.\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Solving a serially correlated interest consumer took 0.1082 seconds.\n",
-      "Consumption functions for each discrete state:\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Solve the serially correlated interest rate problem and display the consumption functions\n",
     "start_time = process_time()\n",
@@ -769,7 +529,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.10.14"
   },
   "latex_envs": {
    "LaTeX_envs_menu_present": true,
diff --git a/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb b/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb
index 7e446ebe..f4ebca3d 100644
--- a/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb
+++ b/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb
@@ -10,14 +10,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:37.397658Z",
-     "iopub.status.busy": "2024-07-11T15:28:37.397488Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.138893Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.138246Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# An alternative, much longer way to solve the TBS model\n",
@@ -38,14 +31,7 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.140862Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.140575Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.143289Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.142819Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Define the model primitives\n",
@@ -61,14 +47,7 @@
   {
    "cell_type": "code",
    "execution_count": 3,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.144857Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.144604Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.147174Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.146723Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Define a dictionary to be used in case of simulation\n",
@@ -84,20 +63,13 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.148655Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.148424Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.153501Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.153035Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Solving a tractable consumption-savings model took 0.0018313999999999275 seconds.\n"
+      "Solving a tractable consumption-savings model took 0.0 seconds.\n"
      ]
     }
    ],
@@ -118,14 +90,7 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.155159Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.154710Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.452503Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.451910Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -150,12 +115,6 @@
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.454367Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.454005Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.615600Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.615039Z"
-    },
     "lines_to_next_cell": 2
    },
    "outputs": [],
@@ -172,22 +131,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.617489Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.617241Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.624528Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.624049Z"
-    }
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Now solve the same model using backward induction rather than the analytic method of TBS.\n",
     "# The TBS model is equivalent to a Markov model with two states, one of them absorbing (permanent unemployment).\n",
-    "MrkvArray = np.array(\n",
-    "    [[1.0 - base_primitives[\"UnempPrb\"], base_primitives[\"UnempPrb\"]], [0.0, 1.0]],\n",
-    ")  # Define the two state, absorbing unemployment Markov array\n",
     "init_consumer_objects = {\n",
     "    \"CRRA\": base_primitives[\"CRRA\"],\n",
     "    \"Rfree\": np.array(\n",
@@ -199,16 +148,18 @@
     "        ),\n",
     "    ],  # Unemployment-compensated permanent growth factor\n",
     "    \"BoroCnstArt\": None,  # Artificial borrowing constraint\n",
-    "    \"PermShkStd\": [0.0],  # Permanent shock standard deviation\n",
+    "    \"PermShkStd\": np.array([[0.0, 0.0]]),  # Permanent shock standard deviation\n",
     "    \"PermShkCount\": 1,  # Number of shocks in discrete permanent shock distribution\n",
-    "    \"TranShkStd\": [0.0],  # Transitory shock standard deviation\n",
+    "    \"TranShkStd\": np.array([[0.0, 0.0]]),  # Transitory shock standard deviation\n",
     "    \"TranShkCount\": 1,  # Number of shocks in discrete permanent shock distribution\n",
     "    \"T_cycle\": 1,  # Number of periods in cycle\n",
-    "    \"UnempPrb\": 0.0,  # Unemployment probability (not used, as the unemployment here is *permanent*, not transitory)\n",
-    "    \"UnempPrbRet\": 0.0,  # Unemployment probability when retired (irrelevant here)\n",
+    "    \"UnempPrb\": np.array(\n",
+    "        [[0.0, 0.0]]\n",
+    "    ),  # Unemployment probability (not used, as the unemployment here is *permanent*, not transitory)\n",
+    "    \"UnempPrbRet\": None,  # Unemployment probability when retired (irrelevant here)\n",
     "    \"T_retire\": 0,  # Age at retirement (turned off)\n",
-    "    \"IncUnemp\": 0.0,  # Income when unemployed (irrelevant)\n",
-    "    \"IncUnempRet\": 0.0,  # Income when unemployed and retired (irrelevant)\n",
+    "    \"IncUnemp\": np.array([[0.0, 0.0]]),  # Income when unemployed (irrelevant)\n",
+    "    \"IncUnempRet\": None,  # Income when unemployed and retired (irrelevant)\n",
     "    \"aXtraMin\": 0.001,  # Minimum value of assets above minimum in grid\n",
     "    \"aXtraMax\": ExampleType.mUpperBnd,  # Maximum value of assets above minimum in grid\n",
     "    \"aXtraCount\": 48,  # Number of points in assets grid\n",
@@ -220,22 +171,18 @@
     "    \"tax_rate\": 0.0,  # Tax rate on labor income (irrelevant)\n",
     "    \"vFuncBool\": False,  # Whether to calculate the value function\n",
     "    \"CubicBool\": True,  # Whether to use cubic splines (False --> linear splines)\n",
-    "    \"MrkvArray\": [MrkvArray],  # State transition probabilities\n",
+    "    \"Mrkv_p11\": [\n",
+    "        1.0 - base_primitives[\"UnempPrb\"]\n",
+    "    ],  # Define the two state, absorbing unemployment Markov array\n",
+    "    \"Mrkv_p22\": [1.0],  # Define the two state, absorbing unemployment Markov array\n",
     "}\n",
     "MarkovType = MarkovConsumerType(**init_consumer_objects)  # Make a basic consumer type"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.625993Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.625752Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.629449Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.628984Z"
-    }
-   },
+   "execution_count": 9,
+   "metadata": {},
    "outputs": [],
    "source": [
     "employed_income_dist = DiscreteDistributionLabeled(\n",
@@ -252,15 +199,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.630942Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.630695Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.633030Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.632580Z"
-    }
-   },
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [],
    "source": [
     "MarkovType.IncShkDstn = [\n",
@@ -271,15 +211,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.634478Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.634249Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.764369Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.763860Z"
-    }
-   },
+   "execution_count": 11,
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
@@ -299,21 +232,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-07-11T15:28:38.765970Z",
-     "iopub.status.busy": "2024-07-11T15:28:38.765719Z",
-     "iopub.status.idle": "2024-07-11T15:28:38.882997Z",
-     "shell.execute_reply": "2024-07-11T15:28:38.882470Z"
-    }
-   },
+   "execution_count": 12,
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Solving the same model \"the long way\" took 0.12803889999999996 seconds.\n"
+      "Solving the same model \"the long way\" took 0.28125 seconds.\n"
      ]
     },
     {
@@ -390,7 +316,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.10.14"
   },
   "latex_envs": {
    "LaTeX_envs_menu_present": true,


Test patch:
diff --git a/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py b/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py
index 7d549250..89f9cda9 100644
--- a/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py
+++ b/HARK/ConsumptionSaving/tests/test_ConsMarkovModel.py
@@ -1,5 +1,5 @@
 import unittest
-from copy import copy
+from copy import deepcopy
 
 import numpy as np
 
@@ -56,19 +56,19 @@ class test_ConsMarkovSolver(unittest.TestCase):
             ]
         )
 
-        init_serial_unemployment = copy(init_indshk_markov)
+        init_serial_unemployment = deepcopy(init_indshk_markov)
         init_serial_unemployment["MrkvArray"] = [MrkvArray]
-        init_serial_unemployment["UnempPrb"] = 0.0
-        # to make income distribution when employed
+        init_serial_unemployment["UnempPrb"] = np.zeros(2)
+        # Income process is overwritten below to make income distribution when employed
         init_serial_unemployment["global_markov"] = False
         init_serial_unemployment["Rfree"] = np.array([1.03, 1.03, 1.03, 1.03])
         init_serial_unemployment["LivPrb"] = [np.array([0.98, 0.98, 0.98, 0.98])]
         init_serial_unemployment["PermGroFac"] = [np.array([1.01, 1.01, 1.01, 1.01])]
+        init_serial_unemployment["constructors"]["MrkvArray"] = None
 
         self.model = MarkovConsumerType(**init_serial_unemployment)
         self.model.cycles = 0
         self.model.vFuncBool = False  # for easy toggling here
-        self.model.MrkvArray = [MrkvArray]
 
         # Replace the default (lognormal) income distribution with a custom one
         employed_income_dist = DiscreteDistributionLabeled(
@@ -224,3 +224,8 @@ class test_make_EndOfPrdvFuncCond(unittest.TestCase):
         self.assertAlmostEqual(
             Markov_vFuncBool_example.solution[0].vFunc[1](0.4), -4.12794
         )
+
+
+if __name__ == "__main__":
+    # Run all the tests
+    unittest.main()
diff --git a/HARK/ConsumptionSaving/tests/test_TractableBufferStockModel.py b/HARK/ConsumptionSaving/tests/test_TractableBufferStockModel.py
index cf9e6ead..a2c4e040 100644
--- a/HARK/ConsumptionSaving/tests/test_TractableBufferStockModel.py
+++ b/HARK/ConsumptionSaving/tests/test_TractableBufferStockModel.py
@@ -24,3 +24,8 @@ class testTractableBufferStock(unittest.TestCase):
             self.tct.history["mLvl"][15][0] - self.tct.history["cLvlNow"][15][0],
             self.tct.history["aLvl"][15][0],
         )
+
+
+if __name__ == "__main__":
+    # Run all the tests
+    unittest.main()
diff --git a/HARK/ConsumptionSaving/tests/test_modelInits.py b/HARK/ConsumptionSaving/tests/test_modelInits.py
index d4a55050..1e31caa8 100644
--- a/HARK/ConsumptionSaving/tests/test_modelInits.py
+++ b/HARK/ConsumptionSaving/tests/test_modelInits.py
@@ -88,10 +88,14 @@ class testInitialization(unittest.TestCase):
             # Make a consumer with serially correlated unemployment, subject to boom and bust cycles
             init_serial_unemployment = {}
             init_serial_unemployment["MrkvArray"] = [MrkvArray]
-            init_serial_unemployment["UnempPrb"] = (
-                0.0  # to make income distribution when employed
-            )
+            init_serial_unemployment["UnempPrb"] = np.zeros(2)
+            # Income process is overwritten below to make income distribution when employed
             init_serial_unemployment["global_markov"] = False
+            init_serial_unemployment["Rfree"] = np.array([1.03, 1.03, 1.03, 1.03])
+            init_serial_unemployment["LivPrb"] = [np.array([0.98, 0.98, 0.98, 0.98])]
+            init_serial_unemployment["PermGroFac"] = [
+                np.array([1.01, 1.01, 1.01, 1.01])
+            ]
             SerialUnemploymentExample = MarkovConsumerType(**init_serial_unemployment)
         except:
             self.fail(
diff --git a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py
index 97cfa708..9ebfb812 100644
--- a/HARK/ConsumptionSaving/tests/test_modelcomparisons.py
+++ b/HARK/ConsumptionSaving/tests/test_modelcomparisons.py
@@ -123,14 +123,14 @@ class Compare_TBS_and_Markov(unittest.TestCase):
             "Mrkv_p11": [1.0 - base_primitives["UnempPrb"]],
             "Mrkv_p22": [1.0],
             "BoroCnstArt": None,
-            "PermShkStd": [0.0],
+            "PermShkStd": np.array([[0.0, 0.0]]),
             "PermShkCount": 1,
-            "TranShkStd": [0.0],
+            "TranShkStd": np.array([[0.0, 0.0]]),
             "TranShkCount": 1,
-            "UnempPrb": 0.0,
+            "UnempPrb": np.array([[0.0, 0.0]]),  # This will be overwritten
             "UnempPrbRet": 0.0,
             "T_retire": 0,
-            "IncUnemp": 0.0,
+            "IncUnemp": np.array([[0.0, 0.0]]),  # This will be overwritten
             "IncUnempRet": 0.0,
             "aXtraMin": 0.001,
             "aXtraMax": TBSType.mUpperBnd,
@@ -149,6 +149,8 @@ class Compare_TBS_and_Markov(unittest.TestCase):
             "vFuncBool": False,
             "CubicBool": True,
             "T_cycle": 1,
+            "MrkvArray": [np.eye(2)],
+            # Will be overwritten, might prevent glitch in Ubuntu
         }
 
         MarkovType = MarkovConsumerType(**Markov_primitives)
diff --git a/HARK/tests/test_interpolation.py b/HARK/tests/test_interpolation.py
index 200b49d0..66df00b4 100644
--- a/HARK/tests/test_interpolation.py
+++ b/HARK/tests/test_interpolation.py
@@ -9,6 +9,7 @@ import numpy as np
 from HARK.interpolation import BilinearInterp
 from HARK.interpolation import CubicHermiteInterp as CubicInterp
 from HARK.interpolation import LinearInterp, QuadlinearInterp, TrilinearInterp
+from HARK.interpolation import IdentityFunction
 
 
 class testsLinearInterp(unittest.TestCase):
@@ -200,3 +201,45 @@ class testsQuadlinearInterp(unittest.TestCase):
             self.f_array, self.w_array, self.x_array, self.y_array_t, self.z_array
         )
         self.assertEqual(bilinear(1, 2, 1, 2), 6.0)
+
+
+class test_IdentityFunction(unittest.TestCase):
+    """
+    Tests evaluation and derivatives of IdentityFunction class.
+    """
+
+    def setUp(self):
+        self.IF1D = IdentityFunction()
+        self.IF2Da = IdentityFunction(i_dim=0, n_dims=2)
+        self.IF2Db = IdentityFunction(i_dim=1, n_dims=2)
+        self.IF3Da = IdentityFunction(i_dim=0, n_dims=3)
+        self.IF3Db = IdentityFunction(i_dim=2, n_dims=3)
+        self.X = 3 * np.ones(100)
+        self.Y = 4 * np.ones(100)
+        self.Z = 5 * np.ones(100)
+        self.zero = np.zeros(100)
+        self.one = np.ones(100)
+
+    def test_eval(self):
+        assert np.all(self.X == self.IF1D(self.X))
+        assert np.all(self.X == self.IF2Da(self.X, self.Y))
+        assert np.all(self.Y == self.IF2Db(self.X, self.Y))
+        assert np.all(self.X == self.IF3Da(self.X, self.Y, self.Z))
+        assert np.all(self.Z == self.IF3Db(self.X, self.Y, self.Z))
+
+    def test_der(self):
+        assert np.all(self.one == self.IF1D.derivative(self.X))
+
+        assert np.all(self.one == self.IF2Da.derivativeX(self.X, self.Y))
+        assert np.all(self.zero == self.IF2Da.derivativeY(self.X, self.Y))
+
+        assert np.all(self.zero == self.IF2Db.derivativeX(self.X, self.Y))
+        assert np.all(self.one == self.IF2Db.derivativeY(self.X, self.Y))
+
+        assert np.all(self.one == self.IF3Da.derivativeX(self.X, self.Y, self.Z))
+        assert np.all(self.zero == self.IF3Da.derivativeY(self.X, self.Y, self.Z))
+        assert np.all(self.zero == self.IF3Da.derivativeZ(self.X, self.Y, self.Z))
+
+        assert np.all(self.zero == self.IF3Db.derivativeX(self.X, self.Y, self.Z))
+        assert np.all(self.zero == self.IF3Db.derivativeY(self.X, self.Y, self.Z))
+        assert np.all(self.one == self.IF3Db.derivativeZ(self.X, self.Y, self.Z))