diff --git a/irlc/ex04/pid_lunar.py b/irlc/ex04/pid_lunar.py
index 7af982d9bf3e50d575e9c275f6b8318977531e6d..d11111c406a7b8c89bff843daeeae2b77923ee69 100644
--- a/irlc/ex04/pid_lunar.py
+++ b/irlc/ex04/pid_lunar.py
@@ -21,7 +21,7 @@ from irlc.ex04.pid import PID
 from irlc import Agent
 from irlc.ex04 import speech
 from irlc import savepdf
-from gymnasium.envs.box2d.lunar_lander import FPS
+
 
 class ApolloLunarAgent(Agent):
     def __init__(self, env, dt, Kp_altitude=18, Kd_altitude=13, Kp_angle=-18, Kd_angle=-18):
@@ -132,5 +132,7 @@ def lunar_average_performance():
     print("Unsuccessfull landings: ", n_lost, "of 20")
 
 if __name__ == "__main__":
-    lunar_single_mission() 
-    lunar_average_performance() 
+    # from gymnasium.envs.box2d.lunar_lander import FPS
+    # lunar_single_mission() 
+    # lunar_average_performance() 
+    pass
diff --git a/irlc/ex05/direct.py b/irlc/ex05/direct.py
deleted file mode 100644
index 6272a0f491375ecfc8be36030451c7b4abc5b6de..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct.py
+++ /dev/null
@@ -1,369 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-"""
-References:
-  [Her24] Tue Herlau. Sequential decision making. (Freely available online), 2024.
-"""
-from irlc.ex03.control_model import ControlModel
-import numpy as np
-import sympy as sym
-import sys
-from scipy.optimize import Bounds, minimize
-from scipy.interpolate import interp1d
-from irlc.ex03.control_model import symv
-from irlc.ex04.discrete_control_model import sympy_modules_
-from irlc import Timer
-from tqdm import tqdm
-
-def bounds2fun(t0 : float, tF : float, bounds : Bounds):
-    """
-    Given start and end times [t0, tF] and a scipy Bounds object with upper/lower bounds on some variable x, i.e. so that:
-
-    > bounds.lb <= x <= bounds.ub
-
-    this function returns a new function f such that f(t0) equals bounds.lb and f(tF) = bounds.ub and
-    f(t) interpolates between the uppower/lower bounds linearly, i.e.
-
-    > bounds.lb <= f(t) <= bounds.ub
-
-    The function will return a numpy ``ndarray``.
-    """
-    return interp1d(np.asarray([t0, tF]), np.stack([np.reshape(b, (-1,)) for b in bounds], axis=1))
-
-def direct_solver(model, options):
-    """
-    Main direct solver method, see (Her24, Algorithm 21). Given a list of options of length S, the solver performers collocation
-    using the settings found in the dictionary options[i], and use the result of options[i] to initialize collocation on options[i+1].
-
-    This iterative refinement scheme is required to obtain good overall solutions.
-
-    :param model: A ContinuousTimeModel instance
-    :param options:  An options-structure. This is a list of dictionaries of options for each collocation iteration
-    :return: A list of solutions, one for each collocation step. The last will be the 'best' solution (highest N)
-
-    """
-    if isinstance(options, dict):
-        options = [options]
-    solutions = []  # re-use result of current solutions to initialize next with a higher value of N
-    for i, opt in enumerate(options):
-        optimizer_options = opt['optimizer_options']  # to be passed along to minimize()
-        if i == 0 or "guess" in opt:
-            # No solutions-function is given. Re-calculate by linearly interpreting bounds (see (Her24, Subsection 15.3.4))
-            guess = opt['guess']
-            guess['u'] = bounds2fun(guess['t0'],guess['tF'],guess['u']) if isinstance(guess['u'], list) else guess['u']
-            guess['x'] = bounds2fun(guess['t0'],guess['tF'],guess['x']) if isinstance(guess['x'], list) else guess['x']
-        else:
-            """ For an iterative solver ((Her24, Subsection 15.3.4)), initialize the guess at iteration i to be the solution at iteration i-1.
-            The guess consists of a guess for t0, tF (just numbers) as well as x, u (state/action trajectories),
-            the later two being functions. The format of the guess is just a dictionary (you have seen several examples)
-            i.e. 
-            
-            > guess = {'t0': (number), 'tF': (number), 'x': (function), 'u': (function)}
-            
-            and you can get the solution by using solutions[i - 1]['fun']. (insert a breakpoint and check the fields)
-            """
-            # TODO: 1 lines missing.
-            raise NotImplementedError("Define guess = {'t0': ..., ...} here.")
-        N = opt['N']
-        print(f"{i}> Collocation starting with grid-size N={N}")
-        sol = collocate(model, N=N, optimizer_options=optimizer_options, guess=guess, verbose=opt.get('verbose', False))
-        solutions.append(sol)
-
-    print("Was collocation success full at each iteration?")
-    for i, s in enumerate(solutions):
-        print(f"{i}> Success? {s['solver']['success']}")
-    return solutions
-
-def collocate(model : ControlModel, N=25, optimizer_options=None, guess : dict = None, verbose=True):
-    r"""
-    Performs collocation by discretizing the model using a grid-size of N and optimize to find the optimal solution.
-    The 'model' should be a ControlModel instance, optimizer_options contains options for the optimizer, and guess
-    is a dictionary used to initialize the optimizer containing keys::
-
-        guess = {'t0': Start time (float),
-                 'tF': Terminal time (float),
-                 'x': A *function* which takes time as input and return a guess for x(t),
-                 'u': A *function* which takes time as input and return a guess for u(t),
-                }
-
-    So for instance
-
-    .. code-block:: python
-
-        guess['x'](0.5)
-
-    will return the state :math:`\mathbf x(0.5)` as a numpy ndarray.
-
-    The overall structure of the optimization procedure is as follows:
-
-    #. Define the following variables. They will all be lists:
-        - ``z``: Variables to be optimized over. Each element ``z[k]`` is a symbolic variable. This will allow us to compute derivatives.
-        - ``z0``: A list of numbers representing the initial guess. Computed using 'guess' (above)
-        - ``z_lb``, ``z_ub``: Lists of numbers representting the upper/lower bounds on z. Use bound-methods in :class:`irlc.ex03.control_model.ControlModel` to get these.
-    #. Create a symbolic expression representing the cost-function J
-       This is defined using the symbolic variables similar to the toy-problem we saw last week. This allows us to compute derivatives of the cost
-    #. Create *symbolic* expressions representing all constraints
-       The lists ``Iineq`` and ``Ieq`` contains *lists* of constraints. The solver will ensure that for any i::
-
-            Ieq[i] == 0
-
-       and::
-
-            Iineq[i] <= 0
-
-       This allows us to just specify each element in 'eqC' and 'ineqC' as a single symbolic expression. Once more, we use symbolic expressions so
-       derivatives can be computed automatically. The most important constraints are in 'eqC', as these must include the collocation-constraints (see algorithm in notes)
-    #. Compile all symbolic expressions into a format useful for the optimizer
-       The optimizer accepts numpy functions, so we turn all symbolic expressions and derivatives into numpy (similar to the example last week).
-       It is then fed into the optimizer and, fingers crossed, the optimizer spits out a value 'z*', which represents the optimal values.
-
-    #. Unpack z:
-       The value 'z*' then has to be unpacked and turned into function u*(t) and x*(t) (as in the notes). These functions can then be put into the
-       solution-dictionary and used to initialize the next guess (or assuming we terminate, these are simply our solution).
-
-    :param model: A :class:`irlc.ex03.control_model.ControlModel` instance
-    :param N: The number of collocation knot points :math:`N`
-    :param optimizer_options: Options for the scipy optimizer. You can ignore this.
-    :param guess: A dictionary containing the initial guess. See the online documentation.
-    :param verbose: Whether to print out extra details during the run. Useful only for debugging.
-    :return: A dictionary containing the solution. It is compatible with the :python:`guess` datastructure .
-    """
-    timer = Timer(start=True)
-    cost = model.get_cost()
-    t0, tF = sym.symbols("t0"), sym.symbols("tF")
-    ts = t0 + np.linspace(0, 1, N) * (tF-t0)   # N points linearly spaced between [t0, tF] TODO: Convert this to a list.
-    xs, us = [], []
-    for i in range(N):
-        xs.append(list(symv("x_%i_" % i, model.state_size)))
-        us.append(list(symv("u_%i_" % i, model.action_size)))
-
-    ''' (1) Construct guess z0, all simple bounds [z_lb, z_ub] for the problem and collect all symbolic variables as z '''
-    # sb = model.simple_bounds()  # get simple inequality boundaries in problem (v_lb <= v <= v_ub)
-    z = []  # list of all *symbolic* variables in the problem
-    # These lists contain the guess z0 and lower/upper bounds (list-of-numbers): z_lb[k] <= z0[k] <= z_ub[k].
-    # They should be lists of *numbers*.
-    z0, z_lb, z_ub = [], [], []
-    ts_eval = sym.lambdify((t0, tF), ts.tolist(), modules='numpy')
-    for k in range(N):
-        x_low  = list(model.x0_bound().low if k == 0 else (model.xF_bound().low if k == N - 1 else model.x_bound().low))
-        x_high = list(model.x0_bound().high if k == 0 else (model.xF_bound().high if k == N - 1 else model.x_bound().high))
-        u_low, u_high = list(model.u_bound().low), list(model.u_bound().high)
-
-        tk = ts_eval(guess['t0'], guess['tF'])[k]
-        """ In these lines, update z, z0, z_lb, and z_ub with values corresponding to xs[k], us[k]. 
-        The values are all lists; i.e. z[j] (symbolic) has guess z0[j] (float) and bounds z_lb[j], z_ub[j] (floats) """
-        # TODO: 2 lines missing.
-        raise NotImplementedError("Updates for x_k, u_k")
-
-    """ Update z, z0, z_lb, and z_ub with bounds/guesses corresponding to t0 and tF (same format as above). """
-    #         z, z0, z_lb, z_ub = z+[t0], z0+[guess['t0']], z_lb+[model.bounds['t0_low']], z_ub+[model.bounds['t0_high']]
-    # TODO: 2 lines missing.
-    raise NotImplementedError("Updates for t0, tF")
-    assert len(z) == len(z0) == len(z_lb) == len(z_ub)
-    if verbose:
-        print(f"z={z}\nz0={np.asarray(z0).round(1).tolist()}\nz_lb={np.asarray(z_lb).round(1).tolist()}\nz_ub={np.asarray(z_ub).round(1).tolist()}") 
-    print(">>> Trapezoid collocation of problem") # problem in this section
-    fs, cs = [], []  # lists of symbolic variables corresponding to f_k and c_k, see (Her24, Algorithm 20).
-    for k in range(N):
-        """ Update both fs and cs; these are lists of symbolic expressions such that fs[k] corresponds to f_k and cs[k] to c_k in the slides. 
-        Use the functions env.sym_f and env.sym_c """
-        # fs.append( symbolic variable corresponding to f_k; see env.sym_f). similarly update cs.append(env.sym_c(...) ).
-        ## TODO: Half of each line of code in the following 2 lines have been replaced by garbage. Make it work and remove the error.
-        #----------------------------------------------------------------------------------------------------------------------------
-        # fs.append(model.sym_f(x=?????????????????????????
-        # cs.append(cost.sym_c(x=x????????????????????????
-        raise NotImplementedError("Compute f[k] and c[k] here (see slides) and add them to above lists")
-
-    J = cost.sym_cf(x0=xs[0], t0=t0, xF=xs[-1], tF=tF)  # terminal cost; you need to update this variable with all the cs[k]'s.
-    Ieq, Iineq = [], []  # all symbolic equality/inequality constraints are stored in these lists
-    for k in range(N - 1):
-        # Update cost function ((Her24, eq. (15.15))). Use the above defined symbolic expressions ts, hk and cs.
-        # TODO: 2 lines missing.
-        raise NotImplementedError("Update J here")
-        # Set up equality constraints. See (Her24, eq. (15.18)).
-        for j in range(model.state_size):
-            """Create all collocation equality-constraints here and add them to Ieq. I.e.  
-            
-            xs[k+1] - xs[k] = 0.5 h_k (f_{k+1} + f_k)
-            
-            Note we have to create these coordinate-wise which is why we loop over j. 
-            """
-            ## TODO: Half of each line of code in the following 1 lines have been replaced by garbage. Make it work and remove the error.
-            #----------------------------------------------------------------------------------------------------------------------------
-            # Ieq.append((xs[k+1][j] - xs[k][j])??????????????????????????????????
-            raise NotImplementedError("Update collocation constraints here")
-        """
-        To solve problems with dynamical path constriants like Brachiostone, update Iineq here to contain the 
-        inequality constraint model.sym_h(...) <= 0. For the other problems this can simply be left blank """
-        if hasattr(model, 'sym_h'):
-            # TODO: 1 lines missing.
-            raise NotImplementedError("Update symbolic path-dependent constraint h(x,u,t)<=0 here")
-
-    print(">>> Creating objective and derivative...")
-    timer.tic("Building symbolic objective")
-    J_fun = sym.lambdify([z], J, modules='numpy')  # create a python function from symbolic expression
-    # To compute the Jacobian, you can use sym.derive_by_array(J, z) to get the correct symbolic expression, then use sym.lamdify (as above) to get a numpy function.
-    ## TODO: Half of each line of code in the following 1 lines have been replaced by garbage. Make it work and remove the error.
-    #----------------------------------------------------------------------------------------------------------------------------
-    # J_jac = sym.lambdify([z], sym.deri???????????????????????????????????
-    raise NotImplementedError("Jacobian of J. See how this is computed for equality/inequality constratins for help.")
-    if verbose:
-        print(f"{Ieq=}\n{Iineq=}\n{J=}") 
-    timer.toc()
-    print(">>> Differentiating equality constraints..."), timer.tic("Differentiating equality constraints")
-    constraints = []
-    for eq in tqdm(Ieq, file=sys.stdout):  # don't write to error output.
-        constraints.append(constraint2dict(eq, z, type='eq'))
-    timer.toc()
-    print(">>> Differentiating inequality constraints"), timer.tic("Differentiating inequality constraints")
-    constraints += [constraint2dict(ineq, z, type='ineq') for ineq in Iineq]
-    timer.toc()
-
-    c_viol = sum(abs(np.minimum(z_ub - np.asarray(z0), 0))) + sum(abs(np.maximum(np.asarray(z_lb) - np.asarray(z0), 0)))
-    if c_viol > 0:  # check if: z_lb <= z0 <= z_ub. Violations only serious if large
-        print(f">>> Warning! Constraint violations found of total magnitude: {c_viol:4} before optimization")
-
-    print(">>> Running optimizer..."), timer.tic("Optimizing")
-    z_B = Bounds(z_lb, z_ub)
-    res = minimize(J_fun, x0=z0, method='SLSQP', jac=J_jac, constraints=constraints, options=optimizer_options, bounds=z_B) 
-    # Compute value of equality constraints to check violations
-    timer.toc()
-    eqC_fun = sym.lambdify([z], Ieq)
-    eqC_val_ = eqC_fun(res.x)
-    eqC_val = np.zeros((N - 1, model.state_size))
-
-    x_res = np.zeros((N, model.state_size))
-    u_res = np.zeros((N, model.action_size))
-    t0_res = res.x[-2]
-    tF_res = res.x[-1]
-
-    m = model.state_size + model.action_size
-    for k in range(N):
-        dx = res.x[k * m:(k + 1) * m]
-        if k < N - 1:
-            eqC_val[k, :] = eqC_val_[k * model.state_size:(k + 1) * model.state_size]
-        x_res[k, :] = dx[:model.state_size]
-        u_res[k, :] = dx[model.state_size:]
-
-    # Generate solution structure
-    ts_numpy = ts_eval(t0_res, tF_res)
-    # make linear interpolation similar to (Her24, eq. (15.22))
-    ufun = interp1d(ts_numpy, np.transpose(u_res), kind='linear')
-    # Evaluate function values fk points (useful for debugging but not much else):
-    f_eval = sym.lambdify((t0, tF, xs, us), fs)
-    fs_numpy = f_eval(t0_res, tF_res, x_res, u_res)
-    fs_numpy = np.asarray(fs_numpy)
-
-    r""" Interpolate to get x(t) as described in (Her24, eq. (15.26)). The function should accept both lists and numbers for t."""
-    x_fun = lambda t_new: np.stack([trapezoid_interpolant(ts_numpy, np.transpose(x_res), np.transpose(fs_numpy), t_new=t) for t in np.reshape(np.asarray(t_new), (-1,))], axis=1)
-
-    if verbose:
-        newt = np.linspace(ts_numpy[0], ts_numpy[-1], len(ts_numpy)-1)
-        print( x_fun(newt) ) 
-
-    sol = {
-        'grid': {'x': x_res, 'u': u_res, 'ts': ts_numpy, 'fs': fs_numpy},
-        'fun': {'x': x_fun, 'u': ufun, 'tF': tF_res, 't0': t0_res},
-        'solver': res,
-        'eqC_val': eqC_val,
-        'inputs': {'z': z, 'z0': z0, 'z_lb': z_lb, 'z_ub': z_ub},
-    }
-    print(timer.display())
-    return sol
-
-def trapezoid_interpolant(ts : list, xs : list, fs : list, t_new=None):
-    r"""
-    This function implements (Her24, eq. (15.26)) to evaluate :math:`\mathbf{x}(t)` at a point :math:`t =` ``t_new``.
-
-    The other inputs represent the output of the direct optimization procedure. I.e., ``ts`` is a list of length
-    :math:`N+1` corresponding to :math:`t_k`, ``xs`` is a list of :math:`\mathbf x_k`, and ``fs`` is a list corresponding
-    to :math:`\mathbf f_k`. To implement the method, you should first determine which :math:`k` the new time point ``t_new``
-    corresponds to, i.e. where :math:`t_k \leq t_\text{new} < t_{k+1}`.
-
-
-    :param ts: List of time points ``[.., t_k, ..]``
-    :param xs: List of numpy ndarrays ``[.., x_k, ...]``
-    :param fs: List of numpy ndarrays ``[.., f_k, ...]``
-    :param t_new: The time point we should evaluate the function in.
-    :return: The state evaluated at time ``t_new``, i.e. :math:`\mathbf x(t_\text{new})`.
-    """
-    # TODO: 3 lines missing.
-    raise NotImplementedError("Determine the time index k here so that ts[k] <= t_new < ts[k+1].")
-
-    ts = np.asarray(ts)
-    tau = t_new - ts[k]
-    hk = ts[k + 1] - ts[k]
-    r"""
-    Make interpolation here. Should be a numpy array of dimensions [xs.shape[0], len(I)]
-    What the code does is that for each t in ts, we work out which knot-point interval the code falls within. I.e. 
-    insert a breakpoint and make sure you understand what e.g. the code tau = t_new - ts[I] does.
-     
-    Given this information, we can recover the relevant (evaluated) knot-points as for instance 
-    fs[:,I] and those at the next time step as fs[:,I]. With this information, the problem is simply an 
-    implementation of  (Her24, eq. (15.26)), i.e. 
-
-    > x_interp = xs[:,I] + tau * fs[:,I] + (...)    
-    
-    """
-    ## TODO: Half of each line of code in the following 1 lines have been replaced by garbage. Make it work and remove the error.
-    #----------------------------------------------------------------------------------------------------------------------------
-    # x_interp = xs[:, k] + tau * fs[:, k] + (tau ????????????????????????????????????????????
-    raise NotImplementedError("Insert your solution and remove this error.")
-    return x_interp
-
-
-def constraint2dict(symb, all_vars, type='eq'):
-    ''' Turn constraints into a dict with type, fun, and jacobian field. '''
-    if type == "ineq": symb = -1 * symb  # To agree with sign convention in optimizer
-
-    f = sym.lambdify([all_vars], symb, modules=sympy_modules_)
-    # np.atan = np.arctan  # Monkeypatch numpy to contain atan. Passing "numpy" does not seem to fix this.
-    jac = sym.lambdify([all_vars], sym.derive_by_array(symb, all_vars), modules=sympy_modules_)
-    eq_cons = {'type': type,
-               'fun': f,
-               'jac': jac}
-    return eq_cons
-
-def get_opts(N, ftol=1e-6, guess=None, verbose=False): # helper function to instantiate options objet.
-    d = {'N': N,
-         'optimizer_options': {'maxiter': 1000,
-                               'ftol': ftol,
-                               'iprint': 1,
-                               'disp': True,
-                               'eps': 1.5e-8},  # 'eps': 1.4901161193847656e-08,
-         'verbose': verbose}
-    if guess:
-        d['guess'] = guess
-    return d
-
-def guess(model : ControlModel):
-    def mfin(z):
-        return [z_ if np.isfinite(z_) else 0 for z_ in z]
-    xL = mfin(model.x0_bound().low)
-    xU = mfin(model.xF_bound().high)
-    tF = 10 if not np.isfinite(model.tF_bound().high[0]) else model.tF_bound().high[0]
-    gs = {'t0': 0,
-          'tF': tF,
-          'x': [xL, xU],
-          'u': [mfin(model.u_bound().low), mfin(model.u_bound().high)]}
-    return gs
-
-
-def run_direct_small_problem():
-    from irlc.ex04.model_pendulum import SinCosPendulumModel
-    model = SinCosPendulumModel()
-    """
-    Test out implementation on a very small grid. The overall solution will be fairly bad, 
-    but we can print out the various symbolic expressions
-    
-    We use verbose=True to get debug-information.
-    """
-    print("Solving with a small grid, N=5")
-    options = [get_opts(N=5, ftol=1e-3, guess=guess(model), verbose=True)]
-    solutions = direct_solver(model, options)
-    return model, solutions
-
-
-if __name__ == "__main__":
-    from irlc.ex05.direct_plot import plot_solutions
-    model, solutions = run_direct_small_problem()
-    plot_solutions(model, solutions, animate=False, pdf="direct_pendulum_small")
diff --git a/irlc/ex05/direct_agent.py b/irlc/ex05/direct_agent.py
deleted file mode 100644
index e8cbca2f99735e27da5518d5f686194c82211f71..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct_agent.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-from irlc.ex05.direct import direct_solver, get_opts, guess
-from irlc.ex04.model_pendulum import SinCosPendulumModel
-from irlc.ex04.discrete_control_model import DiscreteControlModel
-from irlc.ex04.control_environment import ControlEnvironment
-from irlc import train
-from irlc import Agent
-import numpy as np
-import matplotlib.pyplot as plt
-from irlc import savepdf
-from irlc.ex05.direct_plot import plot_solutions
-
-class DirectAgent(Agent):
-    def __init__(self, env: ControlEnvironment, options=None):
-        cmod = env.discrete_model.continuous_model  # Get the continuous-time model for planning
-
-        if options is None:
-            options = [get_opts(N=10, ftol=1e-3, guess=guess(cmod), verbose=False),
-                       get_opts(N=60, ftol=1e-6, verbose=False)
-                       ]
-        solutions = direct_solver(cmod, options)
-
-        # The next 3 lines are for plotting purposes. You can ignore them.
-        self.x_grid = np.stack([env.discrete_model.phi_x(x) for x in solutions[-1]['grid']['x']])
-        self.u_grid = np.stack([env.discrete_model.phi_u(u) for u in solutions[-1]['grid']['u']])
-        self.ts_grid = np.stack(solutions[-1]['grid']['ts'])
-        # set self.ufun equal to the solution (policy) function. You can get it by looking at `solutions` computed above
-        self.solutions = solutions
-        # TODO: 1 lines missing.
-        raise NotImplementedError("set self.ufun = solutions[....][somethingsomething] (insert a breakpoint, it should be self-explanatory).")
-        super().__init__(env)
-
-    def pi(self, x, k, info=None): 
-        """ Return the action given x and t. As a hint, you will only use t, and self.ufun computed a few lines above"""
-        # TODO: 7 lines missing.
-        raise NotImplementedError("Implement function body")
-        return u
-
-def train_direct_agent(animate=True, plot=False):
-    from irlc.ex04.model_pendulum import PendulumModel
-    model = PendulumModel()
-    """
-    Test out implementation on a fairly small grid. Note this will work fairly terribly.
-    """
-    guess = {'t0': 0,
-             'tF': 4,
-             'x': [np.asarray([0, 0]), np.asarray([np.pi, 0])],
-             'u': [np.asarray([0]), np.asarray([0])]}
-
-    options = [get_opts(N=10, ftol=1e-3, guess=guess),
-               get_opts(N=20, ftol=1e-3),
-               get_opts(N=80, ftol=1e-6)
-               ]
-
-    dmod = DiscreteControlModel(model=model, dt=0.1) # Discretize the pendulum model. Used for creating the environment.
-    denv = ControlEnvironment(discrete_model=dmod, Tmax=4, render_mode='human' if animate else None)
-    agent = DirectAgent(denv, options=options)
-    denv.Tmax = agent.solutions[-1]['fun']['tF'] # Specify max runtime of the environment. Must be based on the Agent's solution.
-    stats, traj = train(denv, agent=agent, num_episodes=1, return_trajectory=True)
-
-    if plot:
-        from irlc import plot_trajectory
-        plot_trajectory(traj[0], env=denv)
-        savepdf("direct_agent_pendulum")
-        plt.show()
-
-    return stats, traj, agent
-
-if __name__ == "__main__":
-    stats, traj, agent = train_direct_agent(animate=True, plot=True)
-    print("Obtained cost", -stats[0]['Accumulated Reward'])
-
-    # Let's try to plot the state-vectors for the two models. They are not going to agree that well.
-    plt.plot(agent.ts_grid, agent.x_grid, 'r-', label="Direct solver prediction")
-    plt.plot(traj[0].time, traj[0].state, 'k-', label='Simulation')
-    plt.legend()
-    plt.show()
diff --git a/irlc/ex05/direct_brachistochrone.py b/irlc/ex05/direct_brachistochrone.py
deleted file mode 100644
index 2aaf14e8dc0257fe29f5c5beebaac14ef659b5cd..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct_brachistochrone.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-import numpy as np
-import matplotlib.pyplot as plt
-from irlc import savepdf
-from irlc.ex05.model_brachistochrone import ContiniouBrachistochrone
-from irlc.ex05.direct import direct_solver, get_opts, guess
-from irlc.ex05.direct_plot import plot_solutions
-
-def plot_brachistochrone_solutions(model, solutions, out=None):
-    plot_solutions(model, solutions, animate=False, pdf=out)
-    for index, sol in enumerate(solutions):
-        x_res = sol['grid']['x']
-        plt.figure(figsize=(5,5))
-        plt.plot( x_res[:,0], x_res[:,1])
-        xF = model.bounds['xF_low']
-        plt.plot([0, 0], [0, xF[1]], 'r-')
-        plt.plot([0, xF[0]], [xF[1], xF[1]], 'r-')
-        # plt.title("Curve in x/y plane")
-        plt.xlabel("$x$-position")
-        plt.ylabel("$y$-position")
-        if model.h is not None:
-            # add dynamical constraint.
-            xc = np.linspace(0, model.x_dist)
-            yc = -xc/2 - model.h
-            plt.plot(xc, yc, 'k-', linewidth=2)
-        plt.grid()
-        # plt.gca().invert_yaxis()
-        plt.gca().axis('equal')
-        if out:
-            savepdf(f"{out}_{index}")
-        plt.show()
-    pass
-
-def compute_unconstrained_solutions():
-    model = ContiniouBrachistochrone(h=None, x_dist=1)
-    options = [get_opts(N=10, ftol=1e-3, guess=guess(model)),
-               get_opts(N=30, ftol=1e-6)]
-    # solve without constraints
-    solutions = direct_solver(model, options)
-    return model, solutions
-
-def compute_constrained_solutions():
-    model_h = ContiniouBrachistochrone(h=0.1, x_dist=1)
-    options = [get_opts(N=10, ftol=1e-3, guess=guess(model_h)),
-               get_opts(N=30, ftol=1e-6)]
-    solutions_h = direct_solver(model_h, options)
-    return model_h, solutions_h
-
-if __name__ == "__main__":
-    """ 
-    For further information see:
-    http://www.hep.caltech.edu/~fcp/math/variationalCalculus/variationalCalculus.pdf
-    """
-    model, solutions = compute_unconstrained_solutions()
-    plot_brachistochrone_solutions(model, solutions[-1:], out="brachi")
-
-    # solve with dynamical (sloped planc) constraint at height of h.
-    model_h, solutions_h = compute_constrained_solutions()
-    plot_brachistochrone_solutions(model_h, solutions_h[-1:], out="brachi_h")
diff --git a/irlc/ex05/direct_cartpole_kelly.py b/irlc/ex05/direct_cartpole_kelly.py
deleted file mode 100644
index 759875afc3de34e9cf83b643a0e792c434f206de..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct_cartpole_kelly.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-"""
-References:
-  [Kel17] Matthew Kelly. An introduction to trajectory optimization: how to do your own direct collocation. SIAM Review, 59(4):849–904, 2017. (See kelly2017.pdf).
-"""
-from irlc.ex05.direct import guess
-from irlc.ex05.model_cartpole import CartpoleModel
-from irlc.ex03.control_cost import SymbolicQRCost
-from irlc.ex05.direct import direct_solver, get_opts
-import numpy as np
-from gymnasium.spaces import Box
-
-class KellyCartpoleModel(CartpoleModel):
-    """Completes the Cartpole swingup task in exactly 2 seconds.
-
-    The only changes to the original cartpole model is the inclusion of a new bound on ``tf_bound(self)``,
-    to limit the end-time to :math:`t_F = 2`, and an updated cost function so that :math:`Q=0` and :math:`R=I`.
-    """
-    def get_cost(self) -> SymbolicQRCost:
-        # TODO: 2 lines missing.
-        raise NotImplementedError("Construct and return a new cost-function here.")
-
-    def tF_bound(self) -> Box:
-        # TODO: 2 lines missing.
-        raise NotImplementedError("Implement the bound on tF here")
-
-def make_cartpole_kelly17():
-    """
-    Creates Cartpole problem. Details about the cost function can be found in (Kel17, Section 6)
-    and details about the physical parameters can be found in (Kel17, Appendix E, table 3).
-    """
-    # this will generate a different carpole environment with an emphasis on applying little force u.
-    duration = 2.0
-    maxForce = 20
-    model = KellyCartpoleModel(max_force=maxForce, mp=0.3, l=0.5, mc=1.0, dist=1)
-    guess2 = guess(model)
-    guess2['tF'] = duration # Our guess should match the constraints.
-    return model, guess2
-
-def compute_solutions():
-    model, guess = make_cartpole_kelly17()
-    options = [get_opts(N=10, ftol=1e-3, guess=guess),
-               get_opts(N=40, ftol=1e-6)]
-    solutions = direct_solver(model, options)
-    return model, solutions
-
-def direct_cartpole():
-    model, solutions = compute_solutions()
-    from irlc.ex05.direct_plot import plot_solutions
-    print("Did we succeed?", solutions[-1]['solver']['success'])
-    plot_solutions(model, solutions, animate=True, pdf="direct_cartpole_force")
-    model.close()
-
-if __name__ == "__main__":
-    direct_cartpole()
diff --git a/irlc/ex05/direct_cartpole_time.py b/irlc/ex05/direct_cartpole_time.py
deleted file mode 100644
index ccf63363f8cd7ba4ec00b8e7fe075a25673b7c11..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct_cartpole_time.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-from irlc.ex05.model_cartpole import CartpoleModel
-from irlc.ex05.direct import direct_solver, get_opts
-from irlc.ex05.direct_plot import plot_solutions
-from irlc.ex05.direct import guess
-
-def compute_solutions():
-    """
-    See: https://github.com/MatthewPeterKelly/OptimTraj/blob/master/demo/cartPole/MAIN_minTime.m
-    """
-    model = CartpoleModel(max_force=50, mp=0.5, mc=2.0, l=0.5)
-    guess2 = guess(model)
-    guess2['tF'] = 2
-    guess2['u'] = [[0], [0]]
-
-    options = [get_opts(N=8, ftol=1e-3, guess=guess2), # important.
-               get_opts(N=16, ftol=1e-6),              # This is a hard problem and we need gradual grid-refinement.
-               get_opts(N=32, ftol=1e-6),
-               get_opts(N=70, ftol=1e-6)
-               ]
-    solutions = direct_solver(model, options)
-    return model, solutions
-
-if __name__ == "__main__":
-    model, solutions = compute_solutions()
-    x_sim, u_sim, t_sim = plot_solutions(model, solutions[:], animate=True, pdf="direct_cartpole_mintime")
-    model.close()
-    print("Did we succeed?", solutions[-1]['solver']['success'])
diff --git a/irlc/ex05/direct_pendulum.py b/irlc/ex05/direct_pendulum.py
deleted file mode 100644
index 80ae5a76deca15aaddaa444d09542e9800a0f90e..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct_pendulum.py
+++ /dev/null
@@ -1,27 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-from irlc.ex05.direct import direct_solver, get_opts
-from irlc.ex04.model_pendulum import SinCosPendulumModel
-from irlc.ex05.direct_plot import plot_solutions
-import numpy as np
-
-def compute_pendulum_solutions():
-    model = SinCosPendulumModel()
-    """
-    Test out implementation on a fairly small grid. Note this will work fairly terribly.
-    """
-    guess = {'t0': 0,
-             'tF': 4,
-             'x': [np.asarray([0, 0]), np.asarray([np.pi, 0])],
-             'u': [np.asarray([0]), np.asarray([0])]}
-
-    options = [get_opts(N=10, ftol=1e-3, guess=guess),
-               get_opts(N=20, ftol=1e-3),
-               get_opts(N=80, ftol=1e-6)
-               ]
-
-    solutions = direct_solver(model, options)
-    return model, solutions
-
-if __name__ == "__main__":
-    model, solutions = compute_pendulum_solutions()
-    plot_solutions(model, solutions, animate=True, pdf="direct_pendulum_real")
diff --git a/irlc/ex05/direct_plot.py b/irlc/ex05/direct_plot.py
deleted file mode 100644
index 67a324ae8a79b9091e86f4ed7f194305fa8efd95..0000000000000000000000000000000000000000
--- a/irlc/ex05/direct_plot.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-import matplotlib.pyplot as plt
-import numpy as np
-from irlc.ex03.control_model import plot_trajectory
-from irlc import savepdf
-
-"""
-Helper function for plotting.
-"""
-def plot_solutions(model, solutions, animate=True, pdf=None, plot_defects=True, Ix=None, animate_repeats=1, animate_all=False, plot=True):
-
-    for k, sol in enumerate(solutions):
-        grd = sol['grid']
-        x_res = sol['grid']['x']
-        u_res = sol['grid']['u']
-        ts = sol['grid']['ts']
-        u_fun = lambda x, t: sol['fun']['u'](t)
-        N = len(ts)
-        if pdf is not None:
-            pdf_out = f"{pdf}_sol{N}"
-
-        x_sim, u_sim, t_sim = model.simulate(x0=grd['x'][0, :], u_fun=u_fun, t0=grd['ts'][0], tF=grd['ts'][-1], N_steps=1000)
-        if animate and (k == len(solutions)-1 or animate_all):
-            for _ in range(animate_repeats):
-                animate_rollout(model, x0=grd['x'][0, :], u_fun=u_fun, t0=grd['ts'][0], tF=grd['ts'][-1], N_steps=1000, fps=30)
-
-        eqC_val = sol['eqC_val']
-        labels = model.state_labels
-
-        if Ix is not None:
-            labels = [l for k, l in enumerate(labels) if k in Ix]
-            x_res = x_res[:,np.asarray(Ix)]
-            x_sim = x_sim[:,np.asarray(Ix)]
-
-        print("Initial State: " + ",".join(labels))
-        print(x_res[0])
-        print("Final State:")
-        print(x_res[-1])
-        if plot:
-            ax = plot_trajectory(x_res, ts, lt='ko-', labels=labels, legend="Direct state prediction $x(t)$")
-            plot_trajectory(x_sim, t_sim, lt='-', ax=ax, labels=labels, legend="RK4 exact simulation")
-            # plt.suptitle("State", fontsize=14, y=0.98)
-            # make_space_above(ax, topmargin=0.5)
-
-            if pdf is not None:
-                savepdf(pdf_out +"_x")
-            plt.show(block=False)
-            # print("plotting...")
-            plot_trajectory(u_res, ts, lt='ko-', labels=model.action_labels, legend="Direct action prediction $u(t)$")
-            # print("plotting... B")
-            # plt.suptitle("Action", fontsize=14, y=0.98)
-            # print("plotting... C")
-            # make_space_above(ax, topmargin=0.5)
-            # print("plotting... D")
-            if pdf is not None:
-                savepdf(pdf_out +"_u")
-            plt.show(block=False)
-            if plot_defects:
-                plot_trajectory(eqC_val, ts[:-1], lt='-', labels=labels)
-                plt.suptitle("Defects (equality constraint violations)")
-                if pdf is not None:
-                    savepdf(pdf_out +"_defects")
-                plt.show(block=False)
-    return x_sim, u_sim, t_sim
-
-
-def animate_rollout(model, x0, u_fun, t0, tF, N_steps = 1000, fps=10):
-    """ Helper function to animate a policy.  """
-
-    import time
-    # if sys.gettrace() is not None:
-    #     print("Not animating stuff in debugger as it crashes.")
-    #     return
-    y, _, tt = model.simulate(x0, u_fun, t0, tF, N_steps=N_steps)
-    secs = tF-t0
-    frames = int( np.ceil( secs * fps ) )
-    I = np.round( np.linspace(0, N_steps-1, frames)).astype(int)
-    y = y[I,:]
-
-    for i in range(frames):
-        model.render(x=y[i], render_mode="human")
-        time.sleep(1/fps)
diff --git a/irlc/ex05/model_brachistochrone.py b/irlc/ex05/model_brachistochrone.py
deleted file mode 100644
index dc2dd217853f076fdb13c43849eae989169c9311..0000000000000000000000000000000000000000
--- a/irlc/ex05/model_brachistochrone.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-"""
-The Brachistochrone problem. See
-https://apmonitor.com/wiki/index.php/Apps/BrachistochroneProblem
-and (Bet10)
-References:
-  [Bet10] John T Betts. Practical methods for optimal control and estimation using nonlinear programming. Volume 19. Siam, 2010.
-"""
-import sympy as sym
-import numpy as np
-from irlc.ex03.control_model import ControlModel
-from irlc.ex03.control_cost import SymbolicQRCost
-from gymnasium.spaces import Box
-
-class ContiniouBrachistochrone(ControlModel): 
-    state_labels= ["$x$", "$y$", "bead speed"]
-    action_labels = ['Tangent angle']
-
-    def __init__(self, g=9.82, h=None, x_dist=1): 
-        self.g = g
-        self.h = h
-        self.x_dist = x_dist # or x_B
-        super().__init__() 
-
-    def get_cost(self) -> SymbolicQRCost:
-        # TODO: 1 lines missing.
-        raise NotImplementedError("Instantiate cost=SymbolicQRCost(...) here corresponding to minimum time.")
-        return cost
-
-    def x0_bound(self) -> Box:
-        return Box(0, 0, shape=(self.state_size,))
-
-    def xF_bound(self) -> Box:
-        return Box(np.array([self.x_dist, -np.inf, -np.inf]), np.array([self.x_dist, np.inf, np.inf]))
-
-    def sym_f(self, x, u, t=None): 
-        # TODO: 3 lines missing.
-        raise NotImplementedError("Implement function body")
-        return xp
-
-    def sym_h(self, x, u, t):
-        r"""
-        Add a dynamical constraint of the form
-
-        .. math::
-
-            h(x, u, t) \leq 0
-        """
-        if self.h is None:
-            return []
-        else:
-            # compute a single dynamical constraint as in (Bet10, Example (4.10)) (Note y-axis is reversed in the example)
-            # TODO: 1 lines missing.
-            raise NotImplementedError("Insert your solution and remove this error.")
diff --git a/irlc/ex05/model_cartpole.py b/irlc/ex05/model_cartpole.py
deleted file mode 100644
index aea63db9a39f72c6dfde43b4da2d687f72194ff7..0000000000000000000000000000000000000000
--- a/irlc/ex05/model_cartpole.py
+++ /dev/null
@@ -1,173 +0,0 @@
-# This file may not be shared/redistributed without permission. Please read copyright notice in the git repo. If this file contains other copyright notices disregard this text.
-from irlc.ex04.discrete_control_cost import DiscreteQRCost
-import sympy as sym
-import numpy as np
-import gymnasium as gym
-from gymnasium.spaces import Box
-from irlc.ex03.control_model import ControlModel
-from irlc.ex03.control_cost import SymbolicQRCost
-from irlc.ex04.discrete_control_model import DiscreteControlModel
-from irlc.ex04.control_environment import ControlEnvironment
-
-class CartpoleModel(ControlModel):
-    state_labels = ["$x$", r"$\frac{dx}{dt}$", r"$\theta$", r"$\frac{d \theta}{dt}$"]
-    action_labels = ["Cart force $u$"]
-
-    def __init__(self, mc=2,
-                     mp=0.5,
-                     l=0.5,
-                     max_force=50, dist=1.0):
-        self.mc = mc
-        self.mp = mp
-        self.l = l
-        self.max_force = max_force
-        self.dist = dist
-        self.cp_render = {}
-        super().__init__()
-
-
-    def tF_bound(self) -> Box:
-        return Box(0.01, np.inf, shape=(1,))
-
-    def x_bound(self) -> Box:
-        return Box(np.asarray([-2 * self.dist, -np.inf, -2 * np.pi, -np.inf]), np.asarray([2 * self.dist, np.inf, 2 * np.pi, np.inf]))
-
-    def x0_bound(self) -> Box:
-        return Box(np.asarray([0, 0, np.pi, 0]), np.asarray([0, 0, np.pi, 0]))
-
-    def xF_bound(self) -> Box:
-        return Box(np.asarray([self.dist, 0, 0, 0]), np.asarray([self.dist, 0, 0, 0]))
-
-    def u_bound(self) -> Box:
-        return Box(np.asarray([-self.max_force]), np.asarray([self.max_force]))
-
-    def get_cost(self) -> SymbolicQRCost:
-        return SymbolicQRCost(R=np.eye(1) * 0, Q=np.eye(4) * 0, qc=1)  # just minimum time
-
-    def sym_f(self, x, u, t=None):
-        mp = self.mp
-        l = self.l
-        mc = self.mc
-        g = 9.81 # Gravity on earth.
-
-        x_dot = x[1]
-        theta = x[2]
-        sin_theta = sym.sin(theta)
-        cos_theta = sym.cos(theta)
-        theta_dot = x[3]
-        F = u[0]
-        # Define dynamics model as per Razvan V. Florian's
-        # "Correct equations for the dynamics of the cart-pole system".
-        # Friction is neglected.
-
-        # Eq. (23)
-        temp = (F + mp * l * theta_dot ** 2 * sin_theta) / (mc + mp)
-        numerator = g * sin_theta - cos_theta * temp
-        denominator = l * (4.0 / 3.0 - mp * cos_theta ** 2 / (mc + mp))
-        theta_dot_dot = numerator / denominator
-
-        # Eq. (24)
-        x_dot_dot = temp - mp * l * theta_dot_dot * cos_theta / (mc + mp)
-        xp = [x_dot,
-              x_dot_dot,
-              theta_dot,
-              theta_dot_dot]
-        return xp
-
-    def close(self):
-        for r in self.cp_render.values():
-            r.close()
-
-    def render(self, x, render_mode="human"):
-        if render_mode not in self.cp_render:
-            self.cp_render[render_mode] = gym.make("CartPole-v1", render_mode=render_mode)  # environment only used for rendering. Change to v1 in gym 0.26.
-            self.cp_render[render_mode].max_time_limit = 10000
-            self.cp_render[render_mode].reset()
-        self.cp_render[render_mode].unwrapped.state = np.asarray(x)  # environment is wrapped
-        return self.cp_render[render_mode].render()
-
-class SinCosCartpoleModel(CartpoleModel):
-    def phi_x(self, x):  
-        x, dx, theta, theta_dot = x[0], x[1], x[2], x[3]
-        return [x, dx, sym.sin(theta), sym.cos(theta), theta_dot]
-
-    def phi_x_inv(self, x):
-        x, dx, sin_theta, cos_theta, theta_dot = x[0], x[1], x[2], x[3], x[4]
-        theta = sym.atan2(sin_theta, cos_theta)  # Obtain angle theta from sin(theta),cos(theta)
-        return [x, dx, theta, theta_dot]
-
-    def phi_u(self, u):
-        return [sym.atanh(u[0] / self.max_force)]
-
-    def phi_u_inv(self, u):
-        return [sym.tanh(u[0]) * self.max_force] 
-
-def _cartpole_discrete_cost(model):
-    pole_length = model.continuous_model.l
-
-    state_size = model.state_size
-    Q = np.eye(state_size)
-    Q[0, 0] = 1.0
-    Q[1, 1] = Q[4, 4] = 0.
-    Q[0, 2] = Q[2, 0] = pole_length
-    Q[2, 2] = Q[3, 3] = pole_length ** 2
-
-    print("Warning: I altered the cost-matrix to prevent underflow. This is not great.")
-    R = np.array([[0.1]])
-    Q_terminal = 1 * Q
-
-    q = np.asarray([0,0,0,-1,0])
-    # Instantaneous control cost.
-    c3 = DiscreteQRCost(Q=Q*0, R=R * 0.1, q=1 * q, qN=q * 1)
-    c3 += c3.goal_seeking_cost(Q=Q, x_target=model.x_upright)
-    c3 += c3.goal_seeking_terminal_cost(QN=Q_terminal, xN_target=model.x_upright)
-    cost = c3
-    return cost
-
-class GymSinCosCartpoleModel(DiscreteControlModel): 
-    state_labels =  ['x', 'd_x', '$\sin(\\theta)$', '$\cos(\\theta)$', '$d\\theta/dt$']
-    action_labels = ['Torque $u$']
-
-    def __init__(self, dt=0.02, cost=None, transform_actions=True, **kwargs): 
-        model = SinCosCartpoleModel(**kwargs)
-        self.transform_actions = transform_actions
-        super().__init__(model=model, dt=dt, cost=cost) 
-        self.x_upright = np.asarray(self.phi_x(model.xF_bound().low ))
-        if cost is None:
-            cost = _cartpole_discrete_cost(self)
-        self.cost = cost
-
-    @property
-    def max_force(self):
-        return self.continuous_model.maxForce
-
-
-class GymSinCosCartpoleEnvironment(ControlEnvironment): 
-    def __init__(self, Tmax=5, transform_actions=True, supersample_trajectory=False, render_mode='human', **kwargs):
-        discrete_model = GymSinCosCartpoleModel(transform_actions=transform_actions, **kwargs)
-        self.observation_space = Box(low=-np.inf, high=np.inf, shape=(5,), dtype=float)
-        if transform_actions:
-            self.action_space = Box(low=-np.inf, high=np.inf, shape=(1,), dtype=float)
-        super().__init__(discrete_model, Tmax=Tmax,render_mode=render_mode, supersample_trajectory=supersample_trajectory) 
-
-
-class DiscreteCartpoleModel(DiscreteControlModel):
-    def __init__(self, dt=0.02, cost=None, **kwargs):
-        model = CartpoleModel(**kwargs)
-        super().__init__(model=model, dt=dt, cost=cost)
-
-
-class CartpoleEnvironment(ControlEnvironment):
-    def __init__(self, Tmax=5, supersample_trajectory=False, render_mode='human', **kwargs):
-        discrete_model = DiscreteCartpoleModel(**kwargs)
-        super().__init__(discrete_model, Tmax=Tmax, supersample_trajectory=supersample_trajectory, render_mode=render_mode)
-
-
-if __name__ == "__main__":
-    from irlc import train, VideoMonitor
-    from irlc import Agent
-    env = GymSinCosCartpoleEnvironment()
-    agent = Agent(env)
-    env = VideoMonitor(env)
-    stats, traj = train(env, agent, num_episodes=1, max_steps=100)
-    env.close()
diff --git a/irlc/project0/fruit_project_grade.py b/irlc/project0/fruit_project_grade.py
index 1207c3a31a045469dacb5ee27b1a91188c6ffc79..86b5aab732973cb2d4c41f24a5c6bd3dadd108e6 100644
--- a/irlc/project0/fruit_project_grade.py
+++ b/irlc/project0/fruit_project_grade.py
@@ -1,4 +1,4 @@
 # irlc/project0/fruit_project_tests.py
 ''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. '''
 import bz2, base64
-exec(bz2.decompress(base64.b64decode('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')))
\ No newline at end of file
+exec(bz2.decompress(base64.b64decode('QlpoOTFBWSZTWcS3PLwBhRZ/gH/3xVZ7/////////v////5hhrweffBm5mzzy6CbAACez09elAoABrQAoCQAtmmjtgAOgAKAADGsBPLRx9Z6+pNudHwVRIAABIAAegAAF2AFXXcyVVFDV4AAAdsAGicYAAAAAAAAAAADQAAAAAAEM72S7wAAAAAAAAAAAAAAAAAAA927d74AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8AAAbAAAAoBQfcABgCjTQCikAAHTAAAAAAAAAAAAAAAAAAaAAAADAAEABR07sAUUAAgAEAUBQAHdqAAAAAAAaAAAAAAAA0AAAAAAAAAAAAAABoAAAB83gAAAAAAAAAAAKAAAAAAAfW7AAAAAAAAAAAAaAAAAAAA63PAAAAAAAAAAAKAAAAAAAAAAAD7wAACwANClAFHoAAsABgBTuxQD72D2AAAosAAAAAAAAAABfWAAAAAAAAAAAPd3gAHgAfQGgFGgADAAbAAAA5777HcyB8i1ij0pvW6c+AN0ffW2+bFz2c+h92+2tZrUTWt3CuBxsodL0y26um2VqAkB5i0zWJbSa2xfTas97Pe2KQU7zrm4mltr0GqIbd4eh2J2ZVJLcSCiUQPmxL3rveZt4PT64+9ca9u9ayvDNVzkDY8OM0y9hbztddzVO28y22enW99PeGYbzt0vmSaPPd3O6fdrg3x90VXsxa9t153VV23nV7GT27dzDlWojMde9b3NFO2uuuUdGUkV05d2++e5T0O+3uanrrsyKWTBeZNneNN2wfVe4PXbm2pfcboSve6727u7cp3iSD72PczuzXc4Hfb7i73hzeq6JU2NXmDK7bli9ZrOuPPHXQlNCBAQJoAQCACaGgVP0000U8RPUeobFPITNJoabSbU0Gp5MgpSRTSg9J6gADQAAAAABiDCAAAACUxEJNEjRFGaTU9pGU9J5TyQemkPUaaAaHqA00aNA0A0ABJ6pSImk0iaapvU00RmoNPSNMmEyaNNGgAYIaBoxAxA0YIiiEJhAmICaACZBkGRoqfpkaJp6ak9TynoT8mmqDEeifqjBJqIhAgAmEACCMJoEwFT8qfqnqep+qPU09Mp6ZTQ0A0BtJ+zVv7V/o9ta/kViv5MQaZmJDv367V4SGLa2U2tEEkbBRM0KI22q8tq/0EWtrXW3hAyjRpJgEyZZI1sMiCQaZIAG2tUQ+ZK4UkIAUDA2sxCEcCB9+CI4MFFQA1iQfli/fwotCCKhv3Vs/76JLYqLF/zqlFRT6K/418rKxSCYTS1/ykoVCR/0bOMpr+Bsz/t60c/uvRs/j/iZ/CKxiYvTP416W+9zYhdf9YWkrXshiRfcqKkhIQkhxxe/+6des/4KxfYY155vzMo9aVuIEhGkSOosj+aN21elBfB3vvqxx3rJFU3+f+DhmeupQu20dNtGfRN338WVaitGltcj8otNMEpp4m81upOXqw+f+ekrpx20dPtz/rxS+Ff+eNuzw0zjGO7H/1LOuXW8MY9mymhc8+h1KHmgIqL29qj5Nf0wSQCAGCQmv2UqqqkIf2JIVdmtRotGxUljbYKjVotGKt/T2ukRspUTxbzBEiAqyAKGP+USor/CCChUgIpIoI7a7VadZuMRUZev03jJ0l6Q0B7Pf2Yxtrdldp8LObSuJDsTmk8qKqAygVYO0H7avNTyEEGIv+BbtNIahKomjTM0gYsed0kMyFof/fcf9OmaoEaZB/VsJbLif8v8o4WLJsnLpHT18KcKP8VLQdfoxBRs0CIYdZqJ31CnVyZdxfD5EiXscGPXyu+j17anlLQ9kdVBuhDSGNemBpFpW6ajbcpPbtTTC7H9gEUxC+ExCBkm3sjHbWNVApH0I+h+GJre94n5kRdOJMpMlyjuavI2IlsU79Kmcb726gr/3OY9pa6QnajN6GnH+hdc2Fyhn7uEf+ev/bof008I5Yc7fCvkqiL1nikf9PT/O1uDb2Y0DlVuP9U8Uj/KjBP57nKf7raeWVnM+7u2pSEx6Ib6fwdoLdn1++Pv/zdvcI1BvmEMZeq9DhnB+F/ZB+eE7IR2Jj82DlTKn24+7v2zrozSIzWZIO1xDo6/XA+lHtePhnECZ8a/G+X5BKzOx+VzRZfOQHu7xE1nIMBy0+YzF+FZ3y+xLQShKPDF8PxHGuBFXdWAWRky1kq/b8nUTX53A1kWqrc2L7vXOaNfmbhDZwhEsrj1L0aK1jptkReaqJd4+cmNPu9Tu7J8jpt0O2jR+T/59/u0r/s7AdqNh6N73p9UM9Eh/RgTLb8luX01PjGP+vw6bqdZ+B8vrpQk+a7bFKCPtRp4D0XJ2eFJGXhOMnrm7+H+zI7tKo/Ubbda0qLtUca0edMpMI7VUa3Fw7EzGMe+PBWRfpkataVgsVctjOzU168C3RVNhH6N3+421MUtV+6v20yPXHXXlyK47B8cdOWZQ3VETHDg/6upGmNa4qqByyQ4o69dXvxy2ikYmlfPFOzatrYfF39XLZj6c+M9mJltteqi3Irx35dl7bHEhcelG3zdqiwibxy7ng2q/bXOvKplbj9EuimnsywK+9ntv7MKcuVbEYZ/s2ilqV07YKLoIPUl99zO0pnMnT18MIr0360sUvxgm/AztxRUy46d+jULg+cBDG+HRnpBHBHblMLJIyfTERdC4vFCxixSklFpP63gpVh/GzW7H8K1pcnUfk1iFlae6d6tRKE7vkqxb4u674NK3TWfmaV2QaKzRXziTCY5rZMp+QrT1BfQ0fSfd9Kj6yn6vsKfMTXPBWW5keUT2kgiMo5R0yKwFTWdZlx4rdniCC5G27hcyBPW9tRTTMdJwhgNmZojS7BirhGdaqlcvitreFdou74d9L94whNVPX+y+tKhAudOorftVrmeyDeRuaF9fL/LZnVB0YKkKqQm/NV0c+N6wISQ6G2LgLiFtkKFJWwqQsi5TJMyVTDYrYo2JoypJeKoN0NXVitdzMKfc9oEmzzMEMSYkggQhQxh/g3+57IxWstqX/Kfp88vt513Tr+e8vOoBERhfDqFZHJdR8qV58hKWGxRcFxHRdmemZXGY6FflGNpiiqh0mFJruMQZF0y092QSSgY4ob9ccC0foHxxohDuZMAnpQ+LAtkMMO5O5knD8+36eTplXSA3QShNH5ehkVTMdO+sPuuLDiGPXw9Q2qDdNnLGHNMNR1/U1ZKxHQIZ8gTlyAO7DR2E5wvR5j58P7X4GdkntSDJUCvdOeDOzFHtLWrYqVmmCKlYZ709N3YuW4MFeEO0ujStcMs6How6uFsd0Q3oPYs7ma217M1ljX+LTKafhY4OTGM7FtArWQhEPy/RoSFB/uzgLH1k92RQ45++hIigr/9QgjnQ1qxQ3IJnuRIbkiVVVctHCGQUcH/zDvQ+Q8jXO4TBY7ByCBHgQHLBrVz6t3avGiVrACUDA8nEbuprVo/Ra1nM63PLnmuAY2qzam3KeNaYWrurVNc4bYRc6GOW2iT7iz3RfzmZfs9+eXGJ1mWbTGeT1FxqUheLPg7iH7tR48yAsey3HRdzM3WlTKR8kxJV5FCMzJtcZ5E8uL7Ydmz00CXxA0YLVNDkFo4Tgnh5ZyfZXltrWuSyNRNeExmOQu43uju3alOCPS8xzzN9c6oxd3dnyJINyHrfGGkLdBG+4nmCC15L1dcNFrMIzNE+MHa0OUghoPR7mVcA7zrL0FzM1WgW7y9SZpufsfEuIpkJCiCuzmEiScorQOInO6rw3XvmGth+bnaQaCDiG54LPperaaQb6lamdH+qr1yP3X/Nlg2JHL26ktS/fbXrcvMweHSm1c7YDnUNaV4X3oVNB01eylIEdTHxcttjVuKtlLhjw4RHU+OY5bzLWzrTrbijV+KaKA7i02J7eeEXpbi5sYJyVllS9J6ojWp4L4ubwfuXqa/7t9eDVgbbfx7BZAjy51d8so2kz1J5swQZrTU5kCLY8Gn8dP9qghZ/OO3uNP0DwJGhkzcyG/i6bjcarjzoHgxU45sWINkdyPaIOVdsDQj5aVYoZFF3S3GNt0e/eRNjAgk7x0uKZ5pvuKeWmuC+CL3Cz35K+9mNORxHjGWedFCgycjhJDlfVommpXBlw4behg7rGPlzixxM2bQWfz9YyYcsXC19HaxTWi0fdmtVqMzjFfxpAqQXb4EU6ODNAcrUPYS1BKRKpGxOotjSzazUhxai0g65Mx3e6mdinCvB88i38aHa1cP9nI8Dr5aPxOzOpLWc0IX4Eb8fKMHsO5d0VDN6FYs+kaD/bu5GGfexeKSc+vn1g3O3TtIMmwyWdiCkk/Igg24Dj4H4uSxDqfy4sZKeddC9mc8L0XHgOhIUd0xnJybDtRm2+kTkYomuC9SuOfnrTi3CuQ9M9uPsOD6m2DP1iOfIzIPKr3ryMHA24a5mBMKC5xck2SSAEJCCqalzTmTnKDQgzwVCic9+ufE5IobDhCJw7GOGp4sJBXfLbHx0evp3dbXzqQHU7MfCnA7Pg6VexWXP6c9C2LBMqzLmffLG9XNec9nt5+A5wTu45iih/Qh+Wn+trdbpusZj3cVW8g4yEzpQULmvHkO/rOdMYdYvGQSjD85oLi59UaLuw/ZXampnUpyfypKDwrjKYs4nd6zsuU8kUYzO0fPo6098F/bludIwX17mw4uz4zr+qhUvx3vmXx+zS9zLHWnK/wvYc5FedtbR0ufrbYwfxeHTByzIHDgLenu6EFtsceyTgaNmmXHsNaCfp+0xRRi7v1+r7sNbewbkPpmOkFV6ojhSKPu53yY83L0LLO2LVnOuUkUgEewupCtEemAgsSqpogky0vmUc43Z2PbD4DvN99NK5J5l4mVQXu/Tf0c0dnfX7IW622JD+yxSBHTGzvyLZibar1+3JJM39przz2y11t124hEBcXdcZagNOdqeNCIZGkj1O1oTJe9BOQjtqOVrA4Xx8fSCW77vYypJyiYOGsmrDq/ci/wV8nY35XtWaGMqjX0L0m8MVO/40rgBzXCvSYhA/3fZfCd3zb7a4FfEYTfSmHUU/31dEs2LVmzY9iu/CCobik09DlyM8jkujRKCMsIePu8tOXK8VOnfnxL1dvscygQ5t90dL66dX5R4GRybmyk4vkefHTnSLX4zXrAeXGdWf9WEIyJagfHZzia1fPWlzsO+hFC8YV0TzyOPKnpNex9Pm8+3rskX4Z58QcmTQ6EcijeaB9p3MO3n3uDWwvuLP+nXfO4X6Ea9ojKrVtJlM4eqq3jen48GvevhUs6Rlz5O4X111bwa+hmUuseFLjAddnhiZWzwpbDQ6yxH7ZehGtGF0Nmq/BrDBfPL1hgxUJV2IzouiCZcy82IGnA05J0VuPE2o72c16rCIyqxoU0bmlwFyxqzT3v3V5cfPPl6vxjtNSxvsb8NzYXcgtyuS7ede20Yml1cepX8sVkKPVXIKQyR22F/NB9C62M4eprWxrtj1Ytq0Pq/Utrb0yIRKMYERLDENYpQ6hUNMxfV5/Y0t3nDg+X1mhZJu9aGJ+XM7rdx5Q8IF5jnYhJqKVV+x3KVEEawxgJZN0y3OGOaby/IzjM5Z1OrgZZdhJZCLhkHPKDUdgzbFymZmSutZg2WBQ/Zfe06iJCHrmXqZ75ydth71KRtTOA5BTwKSf7U6abxgqbGQc6BW2ZgLdAo1HcSYSS83N0ESJJGc6WIvmXpeUgLFFhRVRBs3bun6rk6nq5cTBip2a9lhgxavZPWaWyu+tOa+kLIauLyGYUGfO+4thz2dJqzdH0Nx235sPk1JMpoYDggxHA5GhcIQrZH14vo2aggV+s5m5pW+eNhvnIMMiNbWnoSOctG1RgkORbK47ZGVjXeaviGrDvHS1R1EP4IB/fW+75Hch5PLrfA6BJVBxnSrA2iC0eDjtqbYICnYoKkrwRzJGsZFs55qmNex21takMVLHkkmaljag+tzssPoNRswglcDTiRwzZ9Sk2KJz3csHbgqfmkHQti8CXGOLrPgr32zuDiV3B0/POvHPVZ6mr1d+kzoup0OOQJJ2c00NCKcCgRzT4mLbdhoalOLnBsFh1NlHIdUKPnphnN9yuraVORplpJ5cx2422DIlkaZZk7ySwc0fgbfSdL8mWbnkZ4MxuZrKTidOeKJhG4oGh6xDw8RKJb7JlocF1dtE3IQSmRsTckkUoxPm5Ao9sQktLTHgNisokXirKnu7dkCxVY8ImkQceOdkk6aPC8dVhQRHKj13rnBmYQiTnxoTeWHPPaCNsBkvBZiMxSgSuIzttvknL27yhlh+8zrPLOHT1MuyJ+w5GmZdo0Fp0c7zk9S+Vi+71hx8UOVCqODuxknY6YBzM8ccZpItOd8bZN1oc86ZeXclqNOOLnboUOx6nHXaaxjhy25QuOZmmRlRyzb9C7DqWQM7sy6ao7LQO6rFKnAr4tAfRV+O+85Lv6SwcEF+PTuoUJTJNRHBGDAhGnZ1pqYRZNZ5FkS6oxHEThlEZK2oIQY0wcXKkv2bEtdj1Kah9Hx6XDncHDPocw0NWXknNDUxkIx0ftWqabWvq9q9M22LxiJIt5Z0vqXMXkus6ROlHzaIwWnTD7vbEq8azlQqtYlxVluFSEYwV1s2XIdsoxiyBLMKJoKlMYoPg1k2EK9xNixSLw2XHMfXsakHAtrdzemi7a3M1OhoDwimm45FKZ2B1g34TWvht6xiPm9d/GtnAzBewmY6GGlGg5hpkLNVlw61CCxqRWZjaL2JQNAZQWhF6o0alrBSzYOa3ZZ3tqQWOUtNZo1qOFKcaKbdOVTDXytJxw5rag+JmdNLKhKmlkVennVqogWV6m7HQ1MznHIP3eJJDot4IkHe2g6QaGU6knJGAKsUd1YuUjUcq5Vzob/a2r0udMt9C1e3R9KcKu4ids2N+cdTfK1Tr2NlFfqICbdlDe2ttM59U2GoUc4Fjmpo2QhdXOWb4MFo1EXZclUccsLnI5URQ8OhaS1sGqqiLMjKr4LFcjs3maHLBqjVZOxZ4ZNsRU94+yyw7A7O+HV7kjeJgoeJU+yA073lBqeEQkuWmnejF9jUk/FdF4FueprgHH6O3X5k64Oxk6x6y7eCPI6dEaFc+X1ddUa9+kriI3RxNJs2WlFw8ueCcOlVRV3D14RBXnTxOs0/5uGXHFOFO7hRz0OJbgIwRWvcc+rGWcat3t22NN8yLB6UMb6+bdaUGFwg1kwxcRuZ7j6kmzmcHExRx6kBkVdd3eYzCRCGQiwcyWtOS5SLlpmKA1TMJkfcP2i+o4lD5kew2Hx/ysfabsb1YDw+/Q7++38Sv3u/mzM/6vxc4X9tu3x99uu/WIqgyR/F9h93AchU4hZbd1PaCfqfvgz79ShGbg2EIbH5qPHkJ9OvPy26jE34O1PM4ZQkZV/A/tD+i9zClBRa/ueCZNTqNaOrTfiKkSO6hKUiqJc8WSLnYuiMVJJ1GpTRD77dWDG6qikEZAUhjmujnmpksmNNaxwPkr4e2rOustf3qkDzo+kdkPEU7ZJjyvfI+gq61+/11mlyOZ+oy/4VKfZ9/Dan03vGVeDe79b7RzjS5tcVOzsnk89U3b7e6NhHu3cnJ9MK0DmdP4+mVClfDg+Hd/qvlEmgtMvHJ+84ctpxjPw0geazQpbERyjrGu3hbnQ2zc5Za415/Vw2rr26vE6FzDiVYeikWq3pTKS33H4Agc+dN9FB9U3vQ4dQyM2Deh6+s/A735eY7eT/h4Uo/L3lZ1V424By6lSBdv8KfLpl+z09n0YMt/d06Ts/L4rnvKgytxXv7+ydbX8ce3fhyWvYu81qBmq6OF8nf6jkIqPKlKD0Vd1w60QlBYiJgFZN/CdBnGOLnXTSafSpUCkBGLaUN5KcKpmLD/ZSxxkoYhoYpCEzUZapIH7v76mkEzpsYC4oGS7GAsQu6liwVSipfWhw7eqwLZ7EKer/XU1Z1IEprS/FNFvcotU6y9v3b9d+K+18wusZ5Rr8e/+mD89Dx6zf6eHT0TpZVJ6Cz/jZQJ19dFsS6li2FCUV4mmLBUxKpmW7WhRawUS0RMNGCBRQIxtB5ZAwJ/n2QU/NXt+OAQUktyKqHAXUVViiSxFpf6HRaSvTK0sbceJ5+TWZpTHSEFoElrIVlsQi0fm44rHpQlJ/wsYIW+EwTTtbq2CvM+8YVZ+1ueYtcqpJJALBI0CHiBVr+6uPo34m5/1KKJzuXcTg7adZuSXI7eJImZmstGhaFWmhXR3uy4J/ky71Lg21bbWstut130hx0LaBD+9wRYj4Ae0o+89n/RNCzJUMs/QWsIvvfD8/vcv8hfcnI98+i635s6KO0Auh0wLsIEq/2b/xfrpwaSActw79c/UcDs+/5b1VEVUQlb9S1b7t+X19Ln4+PYl+ubpiIKRVVZJnWoA6UBqk6r20whfNluy9RXy/0xFoLV+/mtzl9xrl42uXd1yd25VO7MriVG3Crg02kpBjIbILC2Iwt+mqFsu7hFDOd59zL3lTF0Q3VCpyGMMhkxgLEr6/1jrrIaK6Z/swJt2UDGQoZi6wGRGEixaTVGt0ftOyejN6f9bfb9U69qGqXbK1s7IFYgZ8PNSiGNpt/L0v0/YzWo/+8O7pS5Xv+bLLVE8REeHLlxpjjBqhqUiCNl3bsd+YWKMix4O+NJwJnMslVwaSGgXPz2NIP2vDuxpp62Suoaby7n2prt3PaG/tu1511DYnvUeJnME8u3Pt6yU9/Tu/z+GS3XUY+KnNt48j0pq/fXer29ISnhsWHwJJEy740ajH7Aq6frBge69iPyd3+ujWP6YN1YRmUNx87u01k33axAm41GKiCyCzIZ2QQX/E80XcRpQzv6KMFXxPaTTMU6WsZHnSU0q4Vs702oVQkKrxsTjSmeVCgjsjFWnxfKwPSSp1tWmiYEUm8/vEMSUdsIpWCB4G/d5zwLvRrjPRy10rDQvmeWT6DQgZ0pmB4jbrOjIUYIbFqj75JcMZ9p0MQVRQ0CrQOjM0CKmXysw1yoMICOuXQ5VH3VXtmpgkm6LTRX9ZlS7YCojiDlqXpPeIcl5VDVsmiKNn/BpqcHSK0bA1vcW+uLFOb1LfYtbFnT5WjhECjq5LlIClmOhf1OBi9t2wak+eBO5XxEX2DUEfPzhl3HRnTA916XXgNE6QMRUrBaEzP3dBLEwZ8eJe5lHSwdMZbHl+Mf2UP9+50bbO6Prr5NOYkWEcjzL9jaZ3el5aajwqKeMwSmnuUNMmazhM/kYXohxXTeRrv50oI0TrGeZEkpzKKlZistQbWSiGVBxlNa+zOzV5d6b1d2TXmmVB3yeSXB+XANxHzSUPhuKCIV/GYv3mfO+pZpttQpLJIlpyQipG9StOBA9ytBWlw5u5DOI8SKd4vRYbHZWSR02MEI+0iCWRs+Is2Zf8Ph/P/TpY5b+UmmfCw6ksoV4/1Un/VNImFlATNlBNOrxyR3WcpxtC/PiCF5L5tcfZJxue+nwoTx9z9kzuTtKfnHflRUTk+EEl3yVSoqD/FezGdMU+uM3fKetO6rpmX7ytkgr9u0dq46eyKO+qx5HGsz+LRw7Jx52DJWHn0jXJ3oa4SaUHaUfqqj0yY0rEyofxc/FNwR1h8lt4cKdpy32fueHSMIdAJBZYhP+J5Obrg659C6M/dVyvuXsXbemw/p6fhr3sQduvIvxZeGh4H4+e/c3Iv3oh5uSZHkWI8KLo/WmZs5N08LqLUUrRVNd0Rcth4IRVNdauRDy7oSasrW3hSkp0tV9iLrxMzFpX3uOhdrsU2na/LlrtrjKzj8j1g5AtGtSpKkTf8ex15yQBZKRwcKuvr5TxVKs7ez29Naf6bNZKDmNEFhztyJ1r09l/Lwt64fNjuEd5l5Qzbd7kHbggoZO2ExFnGpw6ZHLWRVK3c1UyKqPPL54Lo+tP6P0zfGekzXQcbSIg0kyI0U/u99ak5xXSlFMvjb5+6lBN7UabBquvpW899PWxHaLPKxqFRn4RQElUGtMy7+XWV+kqxowg2SfA8XnlLl9eOm/G8svCvr5ZZZXKyrvRRpSsKtyGm6tdaLre4t03Yvjq/7L7bmNNabg8pkf3LeBZPvNku996af1+UU1fuXPm/lnt3xtwrC59bcHe1X/+I3PHFdJIS0e8KzpK3ONenC89e+OK14Z6yoV80Ja3eazalJ6UInJRCHtWFESrI9JfAhzn4Yvhx0s9l436KpVKv5JznKr1d53hsz4bV2yv774Ryycy62j783CiPdpr5Sd9s03tX3bxqSkWWLHijD/KNL9t57069epST5U7q7FN09MvT82hFaL719tzGs+N+m/Z7Z3WXLB4ekxSI7KmdfZ3PNH5tZ+EPk/GhXam8txRjD86vyU5i4w66bWO9TTgvRbKmNfjjnWvpndcih4lelDazyuJk9zqqYU88uEkj92XOndlSdb/ZzrHVV6ZU8OUffPjy2pkOgX2d8EpFuSglPEQPr8oaF4rqjzU9co5auwkTKu7ogT9/5InZ3cxqn0mnND1RPlWj+MRPGISFUWj6kOlOcG0Te+czL+F5Ze3DWUKvY5FZrKd4vxmRS3jBiKp/dNTzVOs+mlL/F4+CpebJTDnZso5THrO0VTMop47Xz8blTRF0budKUh0gSCl/Tzgqfk8m69e848b6u34A1XZiCep+0kG/L+FtjuMUe/Ep37LwjITVXr9uVQ3kSRDYgwkyEB6+zbnPZ9tool0JHCK91PDj+bNgsw3dIj+rQDMRInQxl0GHYPDjFJqmat/ti/Kr/bWkX1Ue3R7i+v/jexJQThhGKO+1SUkx9Ovc11oJuk5e6PPO2ZnoPfv4PCyX43kXD6fr8vyHOmNyD6OH3f5Sd97Pd+48vY2EXT+Gd/nTd+ThzVXjHadnP393197mnkU48ceS34cIOKrZ6NyTLi8fUmmndZgme65X2lPXwCltx/HUHscCnAr64v+Tm6zxkZ8nHvPBpF48Sxvi/mpvKk9OWmZRV2mYZaEDcrCfIV/YXx9n33Oy3JY8nHSZbJ065IgzeNrOmLKWPUvXJ5XtJ93ZFaevQvFAcdjkeHr12Ko4cXgTYjB689bGmT8V33g8574OeW1q8+G28lvcrPkXhPK5k78eNY6UsjcjODZykbXHY3oRS5uFS+0PYyE9CYOhgK1rrV+u2kk+WA2buobV42a/3U0yYZXC524bQpThxei/1eNjBnZ9dHL8oOMlSkw5zaCaIVr2IJbbh3yFEyZilmdtC2cLKCBDnTa9DY2j09lDXLIi67unZ3XQXM7Mid6EE+184X5OVzA6r12OHqZBy9WzN8Gubj5cDeaGufZ7vNW5U7PPGRr027z9p6oLcM/hu/NUG9h7RB8wg4cCrNCNzh2RTekHXu68O9g9b8OWFnnqTcvyaSrtipaH0OxQxCBx329j9uGDbWzU7tSAj07r4KCf1LNLdvlgc4e3lNTNGSK4cM0NCJbztwwUi9ezj7atocuXSTv+j6QTIGED/OnMPnuUwWfTTkZCH/EhSA6P6WT9OJ+ZPRvh82RFJzD4FGYceH8aP6szxa8cAe30nfFzJO8uOPbh9x6G4E+d4uF0ZwNwN/hi4d1wzNxyLfXnbcWI1j2FVJP2ZzWT+zKZosCgQ/0ifd/t4Pc0Krm/XhTPbUyNTEWwXyzjJxaCPm+eYKmLRpTXWX++1GqWqQkqvC0/lmLTWHq9MqPGKOm7GrU+WH6sVh2HSxEXTL661Xa5pXJ6ZUHwh3zGtKZ86XfP6bPw8BzBuLuyB90xpm4GEA91CFq8Ie3dsfpOO/lMZtHUD9AvvSB/wTeBAITNIv0p5DieGm4dBHNfEZMx1Q0jKQaz/1o7zijFaw55z3KLdnZXukoqw/nNtnr5+VspyyzmhM0RaSMl62yoXTmBPWS29SmV723jPFM1S1zNNayRN7PV8/fONE+Vs5eOXxvPu4ceXP9uudd9cTHjzXfeZViv3NQUVVjFCC5ohcxvwrqwqKXPwqoIf8PFM0gqSUl5ts0Xmp8t3GYoMmVKaRpItfhbaNQxSiuFVhbYIiAalm5VVgiN4cZTpaTSGbC5lJpVABlN66FtjHAlnZ1zU1BMdg7nzBEp1XPx8KsUfMmV/CdQHqA351OSZgQmG7+2kbD2W14Cl2N6UKe74CsGlzPIkNjMM/7/D5uRbMAE39rCBshm72biznqaFjULVIhmjsySoBgSIdA4iveaQ2P0pg5a8PN3inrqB5tzU2P27TESInj6xOws0EdjlE57lPFt4IG7kcxhSGzNY/r9DvTBZhCBHye0S27Zw9+Zsijcbks7fY7Ja7MlUikwGW7tA1Uy9rJyLPVU7EbgaB5HSFTiTaZ3UoIofLgZh61qMm4ax1bgGgwMVYFwNKpAhfrKHHlwNEQQ2Ysnb7c7o8MmtAYO3iUcFwhTK9M0aAsyZuH+B2tee1hxj1HMrh0DS2YcqJoxZyzQ5ue8q/Pbp+Gd7pEQYwHeGiYPX4F8BOijMeXfGESiEezrpHRGqFncZhrTUb6Ayz9+L4Eu/atpNT0jaFqVM5y1QJCFYrnJoHXvIbB17mMpZG5oZkt35swOaqxlQUSvFhqCNvDwmtWE+O0wYGSypQNHS5O3jNNARBwJ0DDRU2FAjhyewjUPvNzq3mzEnQ8tQwfnZjpoGv6jz7eYH5oqEBSOjZNqSGhigdsjcKc7BWvKtfNtCxT5uG3TixpoZhb/AxU5hsFQ/cHoaG3EbMZj9jd6/2keC/d9HsLH9i936rfvSga0zFv1jxmXi1tFdMtKFGa6qbBYFY8c59tAdYz79VKB9XPa9nvadcnLHhtt4W5TsZ6FFjI8iiCNL52KF3EohiwkZTw92YMIGvGVeHBoH2DuiBwiyMjIEiSAFWLJUW/3lbhr+03KqCjY0ao2tAm1+bdNGsRtRqijBYqsajRaNUla8ckrWNYqi9Na5oq+JdMbbFsf3e9ebdIijaNoxtSVqNaSxb33bEVVe24VjUlRtWQrYxbMtjZKKjUarG1FEa2jSbWNGkNUbYoMRo1jRoooiqI2xrGxsW1kja8a5sRQWKNor7+rtXjaCS0UGK0lXtba5awbUbZKjRqNRGo1jUaixrJrYtgLGZrGsWxtJrRVFRFo1FFFRRrd3SRoyajRrGLWJLERiLGVabUaDGsFYxrAWvfO25tkS2MTNGiigxrmuWxty25aooo1GLFGjRUaxaKjURYWY1JquVubBG2LYqixqNtG1FjGjZJIKAoKLJgJu3yjXedFkpizLx41xnspsHUjXhDeUMYA6hLJA4xOUxCWo8rBbBUaLJYooikKjFCJFRUpo20RYqS3qs3pXjJoJNG1G0Vg0mqwYIiSLYoiqLFa+lXKvTbltFqLFBqI0aKNajRbRrHSvS23itFoNeVSvGrxrRb21cqo2q7rtJRXNuVFUWKykaC0ajbHqzbqHWlcrFWxqK2NBQltkoiijWNjxuaNZ5dfGbxEEUhFAFAUl9JgqXN0QmRILDR1yDaoDWlLxdLYtRVpI1YqKMbXrazXl2r3K0pq2+LrXKVTJbEqszakhYwMl0JEC+Z9Ua4a5gVsEmTOxPLwTrmqQ/o57SgOX8Zqls/mxQCjwOXgdJ3Hic2Lw5Vo/mbo0OKVtzb7BdEchoeFn4BmvE+LnqPb+X6tvumF9bTw+rz7jGvK0+tsz75xtpXTlX5h1nlfyqU3c/M45CG+P8jt0K5KZGSOouF5h9RvXp6+PFvEuZzEHkBYv3X15kmGMEofwnGE0REwpiBkWtLWjBFFISEoiGkZUJTRhmmkaMURlIhKSKNBMEUEjCFRJN/pLiedt2hAZEYCmREmmEpJJmhADElNkAkmxmkpCNIgJI0gpQhDM7uTYS0NCu66lGIYpJTYmGjMsGSJoyyGQRI8dkiGbCzKUBmjBhDNJgIUZpjIF4t2TaJLMM2MllOdjNKlIaJENkhsSiWUQJkZkUSRQJJkimEI1ENNGIZGYDCymmAMygAQzMhy6FEZJiCAyIwkwmlMmZjMmUhJjzrmiUJogJRmrTxuEkQJGigCZSKWJMMgQxZCaZXLpLMkGJBCLNkApMmQpKZEkEhEgAQNAbxq1zNkmjaRGQEpMzITIpCYTxdGEkjYkxCIJQoUqCURokY2CmRUSZBENTMgCZomjKBiEEhSEhoN3cg2tJsIyiISQmiCZlcuwZozbl1CQhlGQSJmQRoZgQYkZkiRkIMRpRBiENJIYaPO6PFyCTBFpClEpCIGwRkIUxkSQmakJSkCNFEQxGMYiECTnS8cIQYGSRGKYlC865kmrTExmYtaEMYgRIYhkIJeLpoA00CTFFCMTDGWRJiaGKQiT5cEKTZGiMlKRCBlRlDEkFjGSUkZgkNGQZRJk0FnrtyMpRKCRSISUTa0mLKSEyShGCQyAYARJvXV2ZTSZTEGHdyDBKRJshlMksywaKAEiDTKTEmJu7cMkKJSIkSIQiRkGyVEwpSJGDEQjAxIYEYljGRkiUJBgkhvV3JGGwyIg0kEaEQphhkSIwkMksa8XNAmxkmYJLbREISUJKNiiEHdvUt4QiYmpkYkiBGYmREwRJMjCymtpk5riRsEjCwoYjDCLKBkabbTZlIWRIEmPG5jLM0MIyRELJGRYSaDu6kmEUfh0kskBhMkwnndJkTSaA0sJhBMQxQZA0xB66u13W6EQoUGEGk866iJKERLIRDDEkjSMwgTKZDBmFBMgEpNKGgttAKJFy40gjxyFiJ8qKYqIMERzF9vH0/Lfk01RERmmYwwiSUjIRgDJCI3110QgSlYpEELl2CImNX3dIGUgjMjCIRGNSyKMBZu7ijMTCaHjcmF3XFEiQDKUkiQkI0o2mtaUppCKIYyUxEJMNChgUpYl53ZISMZGEFMkl3dJmyUhRNzoMAo0YkjTCSQmOdIiX3XKNBGBjCSSaSlKEhjMowzFJCEkRSKRDTCmkgPTo0lEkqGwiIkk0YiYNMFMlIEMMTHpwxTGSSxhQJmJGld1djBMIlgYykpgoTG50mIpKGkYRIhlKKJQYWaImUxgTLJXd0EQ0ZMZQYJQjzt1BFNzqAmEyIRCBFRMmE0TzrrvO8IJSJJFGjKKMiRkAEvOt0sSZggCfvdyTEMzL13SyQxjKZEgkzKIwXrrhIlGkiRFLDfvNdiYDDpXavhXBSSDGudSlKRDMSlCBEmGYmZQkkZjDMoSbAr33QoBMYksiUoSCQxpM0SEpd1zSYgKBMYlGSkCMxEFiRRiRDAUyNGlglhIMIyhDQxFggQgsbJSUYGUQAIiSvjukkMaykxVpSTQKJmTMxMBoMiaRIFMGTMLGAkmkoDImmQooIiZlMJI0RjImJIaSJJFMw0xq0RawkYrFRBEVNTlK/IgQ5rqSTk/I+BzX8euWY3zpnRqchFQYxFFOmqVFRRFYgiIoxU/n7d57Wqr0fD1/rMPXjXEfA+ZutYi9YlMZEFLhDz6uwh7IXvPgHo7gDX/t7ufw+Q/Z7vjHzFPsRlwq8I5fn/kYWD5IppnAtnmJxBOs/QcKFc9pUscC1uXjlwKDbiAcSBAyYGSntxhWBEmX3zC4iA/LEU6EYR9AeGq+9B/ydkCcow2UMRXAZ951KzcslztdDe71q54aQ5Sxh/lRnFdtM2SPTjs7Z2a94ltkjar3PfDZtYzrGC+VTJhVaDRravYlsqqptpStTFtUjGeb5tTlaDR5bVHnW6mvGGuz0WLfD2wytUdluvF+kSpjivhDBV7aCapsJDKd4c2VbAjNrjlr7VDFWfUTZY1oKhqZCGNN2uAcSRANwBob5v0wppFDQMFctbERWGTUU0yrSgiASMKAySoYmYoWURLWiiTBBMyYxiAUWJMmIlKMzKWGZQYyFDCgzMogAIsZMZhmaMhRaZMAySiRsY0QsIiTRRCBP1OhGQIGSGEMREgNGkUyxiiZtaSACIgKUNJJjJRNlIikxpJKtCERsApkyZJJmJBzuXGMGiJJKQjAZQWIRmokJjCmQszEWSSZQiEgGlDFCIoyFMzYyQDRAQkKQpLKMZMhZRQoMkxjSUGDMzGEzElJiy/jtyWYNMiYMmmDBiizIEJNGCKZEAozEaQSGZMSEkykEzBkiRRGSSc5oMaZgySNIoFDEIKSgGZigQJBEmWAkzMZSFBjGNIZEbu4SSAMRCkAxSWA0UUxKUYRbzuEAkiINKJRJAMQwiRQBjTFMJhhEwZO7cYDJJYaRppaMKGhghJFIYkqZ53AmTJQgnOSWTaGZggzIy7uEoiNNJKMkGQCkAAiIE0TCDZJlMxT9l+jvMmKJqSKKTSECKKUKYoSITJ7cSKEkLbRhd12QkHvug0E7uxLCUDLDRKREhjChEN+O7CAjJAUSJjDE0gBNmGRpBq167kZKSUIyCBE0yiiEYkqYgDEBZGCQxAZM9dds0xAUTGYYFkZGRIKRokRSJIlEJBoiEyYkohRgCmgZeOed1ECEg3i6ZmGjGlDEZsEhhIyEWaQIMqMYogZMYpAKTZpkxVpMEYISREMjGZYQq0kQVJBKEREZMhEFJJTQTM153F53XnbiBieXdijARFMokUxKNI0TEJkSSZI0WZEkwoSCQyNmBF46ghplM0kzSaITQwBMyUUiiBpQQzAWYhARZk7uACkjIFzl53AJkHndSwyCCYZ44lCKggxMQUUZLIJNEkijCkTBGABhGDTIIhFlFiSLWjGzFGtokMyklIkZCO65oyCBFANk0kAwkRQyQQGFIyjBCQgTYGJJIFMTARGFMGbBBgAGKxJRnnV0GCihNGYmQiYpBBIl8ff4fV1339u9W+F65IhiIaEMZEEgCYSPnq6IkMEkoyUMhKJICgsE0u6rlI0SZJCaQsJDMz9/rpEvHNDIkxIEkykQZAhJogJid2ukyAAbDu4oubrSZlSowZPUfn28vXcMAmCZj7rtKNGMkhZKFSDYxCWAGJiMkZiTBZGgaLFgyVKITGRmSQpAoQSJECUSWShFJBNCIRGNDExJu7VwaQpqIqIJJmQEwgJExmMEM0YZITEAYYJgkkpCEiZEQGQGjMYaDMBsYShRNMhETBopMZSL7dxKJJkQyYyAiSGUUpSWCZSGmkSijG1oCYgGMUJGiMxImTTasUAjI0pkyzM0hsBJokSMigksSSIRkoTDIlExl67rDenMmChpiYogphAlIwgSkgGQgjDID4trrpljRSAuqcRiFSMkSZKRKQxkttJTGUAihSKNCkaXnXBEUyaRlAYvToQQ7ukQwCSRNJAFBUEaac7EFAmgZFSJTRkMoetdXMlhJnbrpDJphGJhRN29/j1Xl29eTBMkRQaUjIhmRQjZmlhQwPauyNSatNIo0xFGUyGmUgEU50N8NWugBkRNhUzLMkomI2IzDLEkAMSMxUmMNGEYoTLGRJFBFIlI0YYzI97un7deW3iqQYw2Ys3NSm5oZirzeoex17k0Dbg7xuCGOSJTWMDjc9TIzkdYydi4+cIfUSQkgglMSCJMCH9j9f8b9r/N4jBTu+ZcXT0/H5fMa7Z84zz6NxJ1h6Du67O/SVijqd5PQpPP4mUCa3e8I72h9w2CNCpO0NoNViByPFOtv5TIgKeB8U4Wk8JR++Gw7x49x3nu/dj0osHpqJZmS13PfTe3PW281am041LizLzoc9GP7NXZOTR9R2RnhhSap1Lr5QVNgNaYgdt7YiZaPXyb2bUV4nWXrVVUWZh7ho5XdZx3ddvcc3YHml0VpnGme6sbyiazMp3dZyQMhkGMbuWwdi2KTyktnpaq5glKDumS+V66Hbh7tfUjlBGgB4Q0aK+1v7NP3JkLrxs1EJ5BEmwxkeWb+G1O0ZwyeTeqHwHhj9s6pe5OO56AmhRIXKWbm2pipVew0JFuiqc4OyOiV2a0zRBxjE2tUvNFBaq3QxV22Jaqscp9V0c1o7tOaMp7GulYp28UanJZlWzejckIOY3zLUGXYUkO3u8+l5VCt6SblzJ2xDHUGZR1TjTj7C9xjO6cLNZQA8EOtQG7pJbozpozYbkxDSqV2LnYQSAPCrQttnUrtDuqUxE8fVzx8rys6y1XrFZlA6j09fXVVt8+tupfb3dgpiQ3U3e+ztXIAeFgTVm0kVRPl28Mq9P2UAPCrnxVVwmGkd+xntxZ8/lt7qzNg3TUpfNvRbkUwCIy7y3QtLaWbBCrN3tdHbhRpIxXdzpbGVlVWoi5qdbgtubXX1vaygdjkGWSM4WFeTYr+So7m9Kcrqp+A8JYRFy6+xsaYTuTGk7+tUHbEHaHXNYsv+0ecXNTPG/JPcx3mTKpXlXyvQ5N+pjWFYnbZrR2YM63YPNVeZLtoMnAWcmRZByrPOlBbVyrq9glTeW9fu07kf5c+7a1zax5+V9PhY5Pn+dhu/mtioY9Ls5QxbCfyitJFXQmlQwPtEOXZuY6pSdKOsqsBuwq5X0xYjdbwy1ozJtO83UoAdd4vrGYdXVdQnqbuShDG49+pFPPjkw4UDcgLuU8L3OjN2LZ0GtLcmv1bk5ctVs7U1Ycjdgg4OYwIIjk9hvDleuk6qDHmGWJKJ1mb40aTwkWys5jMU2wj1W0N7vTGzSlROxZzpuy0agrjT3Yg4Fcm2zPalHUyqp21VvcROytupeuK7yTClmugb08cucWDdJC0t6ULMnVC00U+NqzVx0hsnWH20MGUspazIaK+yMM/GnQqz9fygc9fwrYVtEUKBlK0RgIlUXWD5Xd9MF5lXSYZBqhJzrXtOsgViParN2JlSOER5Kw1a7LJu5sqqu7mbeuJjpVu2aBN5yrTmQU8rLt3i60cpSnpVQjq3FQpZlc0MxQcImabVakKpWhQLKOIV9m/F9vEaK8QT9Z+dS+JwbhwbUqbhwdRjrbXDltY1qr3Y7wjAg08mHTx7YjZ5WQxbRViumc+veiUZVjmJFlGCjOs1Qy+mLM7trtDrku66s5yp5DkGYbzHbxc8iV2VrfbkswnnzV0dT5fTZk7RU5T6sZm0VnzybGVVcHLqjmZa09J20sEh4V3PQR9s4g6s+2/hXiPgqZ1iH6uHXV3ViRGN4lAs58mQ9zGt11crtW7gITtbfSWHGKNDE5VYzpF3ld07jdBEXizHTQr1OXBWX01mq26euLkOlq70xku6QFPn5xbRIqOuJ2Ak8MKVovhj0dIwds5cx2LI6UC+1zdfb19FMF3WX1ae27mdhy7o1T5WencnyVZWPEq3JlOPfaNuxqykz20nfOhy0m3XqO0F1mYoJYIaqG9x6ChWq9vUlSKYXVblIKLSEEQmNQ6ZQILjoXSqjRGC6c1yZ11Nvkp14M67pLNVawYFX8929nazyaT7M2ZPjyFzbu51Qysrjgy30F91VKCtdcOzts7o4GjmrbyXKybVE7dmusT1U6bG8zAauHRmnTnXyrRRt87y+iTgrHxqhqE0+qlFd5nVllXwXa9S3LPdBlswdLb8B4axWH2mEXWl7Yatw4qEaINwHFUU72ZmXRMNqXS0TNQvHbJG1spntNTXtVe3ygrq3Rg2+9XMJlCVXLYLMelWDe5sGZXbrsQcnSpzuxQHBDm7CkbzAcC/LlEkWVxRFmnQ4nXHhN08s4mbjd8q37onWTPZyzbmZtale12XQu8bDCYpt32IwXL7cCfXuYCKVoVcjAfLnVVbNi9Nu0FBb7VSVjlVytUuq0K7QkGuiUsjmS9sMljurIKvaG7/bdK5T7K++e1kz7rpFYZsgm5avlRWm3pFN0Y5TvTs2nhPdlUcqjcprapThlkwAeEEuSxl7dS5W1pygcu7BnC0Ne2IZds5inFkaO6o2OFW5upxoquRMu73EZDKCDLFb1SxLWNWg3FqFCkWcqgoN2rsrabiMzUvU8q31vtm5UNT2d2ZZiWE9VZzkPZYwzbJPfl5SfL7NBNKCNd9V1aUvdmEddCskUzby3c3MqnjsRZei9tLcszSOjagmMZvPqfDSM6jdpkw3hxeuvIu6oju5GBdMTrV1lbpd9oq+kM46xcvaVdV2sS4Wlo303ne0Jc0TigRiur21LFVlVJeudt2/ahlAG9qzfDYzWki7tBuhgjRMFpYLo6qpjtfRVXsV31Yb8OToXuLcpjeUQqzhGWPuDfwV/NHton47lQLQB4P7FddrqjOKpU+HA9ZzUGNwJBWfqrpzf324j9c9IlQtamPn1aKoYax6317u7c48FLzqR0YCx26wB4GLSKq87p0tV1kaazPcqpJ7KruFW61PJrx4g31VZYa6djbGl1VCyDKDxemOPSL9QxUry0FR2oW6wvljcuxXb3aLvWyUCMt7Lck1VJ3TuqYwB4O7RNGJdqfW/Bu0luPhejZl1GlFdNVZLpW7w5Hu28mya53DqpB9VWUauj18NLYzau743ApiHGPByG11ZLWC97SXfJZ1CxevSHZ7NZra6Ze2dzRi90xXu5I1T5w5L0TNKeS7ZyPHW5VYqNZcjaPXAebd24l0MR8B4RTFqv2ADwnbUcu3mB3KvcNtCzl6RouU92zjQiXaytXB71Gir1b3C0xZt4Hco2Ox2Zm7pa1KS7bjpZWdq4b1pLblmpY6lUINbU1eJuCuMkhxq+zM0i3zjGLN0b27LtSxy3RD1cOxcaHSTbts1mYV1dmbuZrZonmeW22itv1Qpi6FYCHts5HW3KF28Olc9UUJFLJtPFIcdZCs6kwqyK+ah3BkZaM2ewRpZzpUTjGVWI7tU6CwwYl8q0gobdz7V2XW3MfxzXd9dpbZIdlELedHDspLqmXcKqx1pQv1dyGvc1jOoSYMLokzdvk7GvyiSe4uqu58APC8paCCQhcqjb0uyqiYZdo5ValvC4KdqUQhN3MFxYd4QYZJZORXi2jumorxw12VTnd0rOVXkvBdzEarA6AHhhNbrSq97O4Rt7xqVeK+qBLV0xNGl2C2KW17bxUXlpqWoa1i1lC7BunXjWDHnVjrC206u3C3k6PFeEBvtkb3odl3kb0Zb4W5u33V3xy97EzNNsW0L8etq38l6jB9SxWqyrmxWiJjNvUH1HKDTqj4kO3YuyZXgPAt877uwzMMJoLeIIKXF3lGB3Vae5Xl0aemKzeasdbr3qfTuMmXhzIKxVVLcPHOUsKpe2tcvpBVc5lBIA9bIJRwPc68YYBNUXpl1vFA5lrlkuAjNvndg1ZFzgud5eY8BEXVkmCqHdXaAPBeA8KnGtHVy9Y5g5BiWpR75GtZpquqN63XQjdVOqqYLSzNkvusnBfGo50ic14szqfFUWjci2at+zh99OXXVcqXO/jXWnR2zTumbEmqXcFgu+U3IVFmnOXmwUCqt8NltRe1g9OkvnWtcKF2bpKpRODjV33IlI9bQ3aDYOo1xF4qqrzcXWlNk4zZrayj6SGriel1doV49fUgdrxQ1VKF+zV7L9mbXCSkUYx1d+Hp207CrvjbeL5Xf1Z1E8M9t5UdQl7LzhQelbNFg1Y5w9dEjl2q110m+Msvc5XSL313tFyuvevK7hty7uDuwTMlDsJCLio2ekeoS80LyecOYq6QZyqVPaeYu7Jm6LPWOVp8s4YQrnSboKPOG0NeLmMoVdvnOXEO82zZtu6bnNANW3hBqZd3WWrei+kwrGbpri7fLLrsxYoeq5vTRentrq4RyhSkWpMyzBQXdK53fUDSjzeyZmVBmLVU2g7e1Y0MasJZG9aeZMCNUGo1eJnOFFm7wYg9qqsZvnU2uuA9cb53qEeXeGuY/N+4D43Y63vyFTKnyA01mnKJwAeG8dDlbsCJ276SwL3ncs7ovX1JSzKRBMvKBWWZdg72dl0rR40xIZd3Y2LaW1zycDxa6vdvrGzsgtnLeYrr9jcEqU6vKq5tKq+2WNenadjcjgr4Eb15C/66gPegnw+W93XYu/gB4ZYL7RW2DQx0zXdaWh2gxmZYU2La3jr7eNaHlNPtQtb7dk07jMXVhqVXOxSSuccNkh677cNBVQVVxS4a7nW9Ek4ycKtd+m82YMuiYZGGdhCv6VsW038XOt7Bb0Z2GPbu8GvYW020UGDK643bc1wWibLxuUgY646cN1VaYaVC6GY/TZJSCGXsozNy1Fbuzs8B4YVcOns57NFPsLqFkIVgl1WRjjVmdke4xmEa6b3VZrYdL7bypsZ0Hl1GS7isFncebVw9pFdFQkuVXLhvaXlEGZFl56V1dWc9Z7KrloWdEppW0+K6oN9iZ4dss1KBdK5dYeSDWZ18xq28rrD7c69q5wPe3U6pxIde8rJFPeHaFiIpfC1PuoZyhLqTjkHHfkzq7NlNTes5dbp5RdT2g0MzNoxZt1RLF9fssbuHBR4MYi1uVZbl9KqDKovFsRhzn1HVe9KgoZz5idvVd7M3Hc1y812qtRIw0+zHq0Re7CihBONmsozoKzXMtjqngcMuu9KbCq6pPG9N1EKnuSG7MvosyDA6qShTsPQtSWVTV5Yzrlp4zMr5d80fvlp+auH5P4TB0eechlrdK7jUmX1TqJuqlsM1c48lx9aUzLq/pZOZUp7R1I2a745u5RdYcGVXtoZg2aYcovSZdWS/rd3mdXqMndWJddEqUAPAjEbxaO15Bc0608dVxs+ZqJk4Ei6vdfBaJlVp5RWbl7jOHdNA7lbkx9aWS6SVNJa9XYaXgPDRvXGDYPUOXNkK5LHKqxZUaRhSiSoYjVquudWtCZ6r6Voyi47s7LjQNBAlXzvRRuxnYdxwqmwqONO9eIbtIw4R0TM3bQ160yGsjlw0LqR3iwz67zeD1rxrjocHfYQx0F3btTOxyuFu0sB6nSD49ZOl1V923vuNXU4vUF1t6JYA8Mza0Zs3JvdxdFsiWu6+qsQd9dtju1bDg3xQzogqmKPmEMeEWyNym1l8SlJrKkUnuE47VN0t3O2HNZvZeaaGLnLujTu7rPYSCb06bLMFLBhnW7lyJLAruIo38r5rgN2w6NFzCs+43rtPvLArlV3z5Slfdgw3nbOp7tXGuW5wznWm930vm7G3Onu07rCI7e6DDzzkDgZdgiXK6+upeR1eWnL41dZQgqXq7VWumoq927dAgDwxZmV19xZceJ9ROzb66lDWeqrjquccOcN3N3Q5lh0p16kSrLF2R1O6R5jF36feYi0fZdGz3ww61eVFF8JeTB2txkYdFVjJvMyj+UhF3w2V9uQdqpfjAwV4ah+DcPWnLAkT4E3u1YvDbaKu7+GOwpbPWhuYgaU8tw5j1onruZvZePO2ggud4O153Qna6i9zLa2E1Q3KNzNYx06oR1tQVOyjptaLmOhDfGs07J27MCzK2qlmqodHurErpcOyz6EL0ilwtlRm9Y3ekfaM6vVOcWbCWp3cOGhH2lRKs6u3pVcLCVQUwdmGLMajfO+6tcuUUnpKlb+fbV2m9gwuXuZkHN7m1Cg09TdkO4n887CVi1HIF2VJxHDdfdkdYRQuZJYMUpagl6sVjVcE7GrOYx1PPPU5a0U3KenZpJPEHqimd1Ar8jvrGrFfy6T45t/nZW7MnaD3BoINfX9YyHO2/t2FjDZeKZsGdnGTQ8neqnSvKvngyDLep+HgNPtZyS3mTaQ0vuonGMNIot1yXM2Iqv12APC6vTwyaDrT+dTq1Gu+c2JsPJDZqTsVW7vPpVC+bqloNF6b036tpjb11mb68TLEpO1YNK8vZIC63SZednVO5mp1BX0RJm0sQyuwc6ncM5k20pu927uDD2DsPLFw2FnjR5WtF1U66m75O4enBo5NwMyl7H2Xiyvb3UcrIC94R/NCNEZ93NXSIj+r6u1iYHdrjeO865Yhq84l1Rt1V0avOgdFjRXddDhvWw+vlq47eImuQqOp2lRmnMQ2xT5Z3WMrNvhcbOTXoeADwRIt8S9ChigXSCjtdZxO1kAHg5QVbqOQ8sP1zvsdr69a758O5jqZznpoJC91fZtv5bBvz+tVTyvhK55gYdVU8uykw67ZYp653VfhZ7MJrD0i40K3O1evb4999ut21W0Q02YUyQZJmTSImERMECJkYEIZiiQgIMJhIZDIQikMFImCTEhaAoSUiAUwQEyGGiBGiSCEo0SaIyERSBkjNAhsiUIBKYllElKaGTMQ1BkVaYxMGTBBFETImBmkMAUQDLRhBGFESJX59dGYgwImTClKGEDVpDLMxKSBDChEaWJgGjJlIqCmSJkKKbApfkrpKZExiGx+HZSDQzSYASgaBIJCDRTACxhMKbnJlGKQMbAQSImAiGYMREUajE0yQRSZE0SaDJEilJJJV2ygKo33OvA/MRm/L8pq8m5d61mLXK22RU2UJiy1l6NBzczFmCrsYbb1NbRS03s0xwvRiqyqzFEMUISl1TWJr8qzmRa+tmm60phvtGHa18etKVRJPO6nbI5fF1SVNxPFYzLyVrxsYrQkw4De6xW1QiyyLRQVqigwB4PNGLacsRamJaWyXmy0dzKwiawtdy7fljT2Xcom8kw0LLsKzLMNVuRnb3YQB4O7eiwhihbQpqCwa2HrY6CqStXE9tplWHNoGSlzu45gcs2KOTMl6sDPsMFU6ClXHLM2tc24fDLuTSKFRVm1lLMVtTENzMlzaesxVrip2yWLdWbeRtbA5IDSSo4xcVIDw/D4e8O0X292C8iGNGmOr2EbadoCqRIBR9FWo7KUEcmXMFkpDPjXmGt1e8PAnwHJCHp51KlVzxzdjs0zErppRbLrXZrHQVPL0TcOUKrG1ILbJKqGy1kjaQysrBcSR00JPCHdC0s+9PO2w51BmpQSw4U9fB+Qw4nbtlYz1RNqmQq23gvaWaq2iyFUvbhGXutA+po1i/WDg8pTWMdd25gqrsN7aBzakN2g1IbT8wajuQJM1I2vNRCwB4bRCfpdmjSy1Ray7t3aNqLQ5VHLhqvX8X163SvOPULpVW0K9eW0Nje5oZObuHEct2DFmXfo0lyQpDCiKx3BC6yruDoULrrzCrR1BbBrSYuLauLMZVWFu3W0hCluCsxUoLMg6oO1VHUODOXB8L3eul0hG9pTlriBQO5MaA0i8NKS/LQoVg0gUylVxyghKVlYILzb2UZetjZpbR33gLrcRLFLy94wZXtpO1pAy0Xma8MOwsysJsJeBwrzG635m6h02JnrGUnavVtZmCOxsa1Ma89g+qaXmZtpy6F3BXngqYMpt8oty1dLLKIOnRlzcebQUtV7JAbWt2xVZDRY0Ig6c2gpJtAyKsQd3QaGmjW29Fg3d7krd2PMDW7hLLbrN9lEmndK7QCNVc5NbW8mxDkb0nBppRWs1znNSTfAKHNJFa8yKDY7TxhRUWU5SE675G7uMtmlNNjWLt0bkrns2onZrBuoWfSPXp2IMLXorNrKlUugmXPVmLuobprWnHLqTSbrCYsVI1cvblyrxF4U7GYbwIu9qgcN6sVE1m3a0nCt03ab0UVQWZZF1CdLMmK0xdZviWsixiCIxYokVESQmYWbAzJBMWMkMyGaQyRmsWYlMmSVGWLMyCWUmSNBsSshKi/JwlAySmEsmEkkUDJmMRH5Lpq0aaX47iNMyMJgww0ChJkEZASMSaElJtMBkZRhCIIUlMgJjQLKRNCQkJiGIzSUiTBjFkRlBMRmEJBEspEyImGlIZFEhSQZoiJjBaff5+vt9Px8L8kl2c0IjUbFXsoJfqhFWnGeB7rswVeTLN0NzJPLTIbWF2rFmlWsAeD3ezNy0XhIUVg6cfuldTwd2V6zR5Z3N+gd6HFn5+szCe5V+EIPqgnFZeV9WXoOgqsoVuF1+Nm8b7equxJ0rB54Zx2ClFycu6uq7Mdipd+VCa0w9Vy97qIZ9CqyfihsFE3uCt+5xWtvc05oieT63TvcfVfLBU2nXPOQ55mpFZyhLeIFAJeLc4zGhWGYFhgjGpWgluijj3TfOnuIkEgkAkAmSmGTGJikxgk3fX2+r2CRsyNJVto0pp5PJsx4NI0aBuYK9VJg0QgfOum72e0l9qZodhVDKq7UWEitWOEQJB8eAHgc68dXnU51aYM1DR1RS8Y12bztU3KKwRBVEWIoMc6uuVZdLbg5xvFOvcvcwU1Z4DCSDCETem3ZzsNVSBAkhJ7KVQOnQskmnVyeoEn33z50kkwzKIKQAREEm0gT4irNk3fNCGp0dSwcooTqJW7t88d7Wy8FjDyqvdgVbSx0bWpd6+ot6hm5Xszm0auJU6mabykYu7jjFCtvVkqxoaTuJINo6NFVRodlutY3bop5TuYS6jgeq76N1ZtCiTl4N3GqyqfIKlK31UCNypt4hPV5o0RWNipQs2DVjTmvu3fZMW3EVXPLil0+23aANXrgmEJVQNyIurJq6r1sXNdZd7fS8Y5CtS436556unze/reXnl8e8gUZKgtJB9HPj1bzIJyqug5ZHWLRg7AN26EL3K+24zuNge8GD7u6xjp7fxs3Z4rKczOGwI5KrEt26DJHWgW+6nTovYGayNIQ6Sn8fZ88+fPn18ddMJJAjMZpnXlm3NLk4jBOnevpGqxFqiD5EkKuVF7x5eeRuUbDFUFUc1O7zwHhR04dGOoCFEkpomQ0NIkwbfl26RhAWEFCGWMWGFkmyURGybGWJjSCCRlJKSGZpDQqUpkkFGSoGQpgWYEJpQEjKSKYXOyKUiZMkjRRCzKRkjITuulNAKD8u3GikmgkApgyJCSAIZFmKUKNGmZVZKZEZERkM7uYsiYTCRGktDCyZEQYxEUoyYI++7kkkSETIlgWGKSGQSaRAwEYEGgyNFGQqNKRHpdmkUyhgZYmEZGSkGTMyVd8PFrsR2sXd3HNyafa1DEkKkISEqQoIqUw0wYJk+u4kJMRkYIyTZTIGbE+JMHuH1jCZO7Uw2kNyxNL+lbseE9eHlc6nTVhpHFHFd1fbmQms11ecDGhgsc6MEF+YOWnV/nfb3oav7pE1TauuDdD6lHruuqu6stdD3XmFJ1wroZJa2+284AeF8TLcwwIhHKdmnQJZT3MAsGuLurWVEIzdVrvUKe6SobxuUx3Vpv2TVzwg5WOuzNsLNmxhYm3yjgzShr6OiHJnE0DW5kJWVnvDwKhy60NZL6oXlIpTqHUuNts0eWi6QrN3oU67swO6ev0cG9K6hdXUmADw6gMdZx7sgec9o6Hu0aOHMulUF06OaFsRoQSoau7fLK3DV81CNDmjb6LOd83lZfqlUskD9uWEYhXXbvtSaNcuDrzC3s6CtmKqrKoNHYTQynbSoQUcupVoVSJp3nZlqYNLknLavhcmdVzKdCDZt3GdcOdfdRprKt6AQt4tl1nTdN9QrYLbSq7auxqGulwvswcMO7eV8ZpUmxzDTKd6ncDsYrzBgoXw2XJhpQ3n1u88cQUBCazac3CYSeIM3SEEYnQNQHjVUrx12zHihysJqADwQ3JWh6ypePyQjuWJmA5E6URlZguXvdU2USAPArDOlusQA8NkPWVIRfiJLS2qYfP0GQiUVevTXWb9XdlPAR2p0MLFDIMt1PQi69Txt0qDiKEy3U+Xz+OoVzWu7T3MvDi7H9U3RelXDe1uCyTpGJ4GPplXmt+Q7WFyLWEip8M073WI9ct7iPXM4jRUWs9K3rp3dPtdxR70L27wjpMUgq+WGsfKEy1uyElPHQOuwqiTOyqUG1cFZiTJHAqRp6uDu27yjUj9Re16VfK7Y64LuWGpVGlXlawtXmSouMIoN0uNfGYNgwQyKRocldO7+soFUe2g7KkdtRCnW7o2TTlPInDQzFlqreZe6YdxVsQqmrjZ2pfy30S2ltIy3GcWO7yXoA8LHOIjbkhmIJqjh57S84cXADwOzCRY6lz7Xt8b10+SdsbgCEqr1cuuI3SGZxpd6gdvuUiQR2uzUOdpqxghBNdS5GVo21VezLPHjxTl4iEFVct1kq92UIWbVrWWiI2zTOh8W8ldMimbkgupNONZi3KfQMG71ZD3Y+vLbLEBMt9U3YmMFVKXXRI24tVuEA4k2LyhcsJqt8B4Wbdi3tLbt6pSvLqWLpbVG2L+MOKaXWTPi7S65mN6cIU0Vtcad9f31E3R++7KzKTOaNdrrFEbceWbAHhBt3GgXW231s0t0ZWzhWUxM7Ft8WrHXEHViKbZy+6/o/nLZ+D+nvpFdbl2Fiw2TV2LpSKlhqwUSrRu5UsZm0nvsuTbv44R0lt1FVXsszBtaemPLePY7qdeW6Qz3C4CWxthU5Iwyct5A9WBI3zTxbWq4KNxkWpbYMCTV7UZL2NPJr6tout3z7DKevyo3ak6qzFLTktVt4bysBxLyetdLwr2wquo4sqtHDuduzo3S3nWqDJKHcueQ5T5qisrFQRtEd1GJ1KItMVR1mWMmbvUMSb5yspkAeBvPGbbqq3faVaha3EqSL21e3GTZzKbyj1uYKqwqx5pxtGqixtG2JL3GZ06eUUF8hQ1ptdz1qaXmIaQzV8J03dldClqjjMojWN2peZifyGS6Q43zsW3JXRJCq+H2321ehh1honAlNF1zFg4jircqnnujzcfJnNyq28vFNmjTJmYttHT2zYQUUqJWcL3Tu1OrbSo3Sw1mIBUpZqtadrCd1GS6ts9VHI+5CqvqDh3EHZLyju3i85u3M3RNWXCe6qVgrs1m6U5Z3Ztnyq9OKyGM2m49v3MbcRZYRD1jWDGiKtSsSZ3fTG1hwkDlGcrMJyyyWxTV/p/Hcr1YrpfbI0/z5vCpYykZfKyJ+fcttXWh9u6z1xK47ujuwo4rlULuhLcAHhgd4TlHlcmJWavZA5LWZdC+14rKP2/EZwl6pGwkL6+jFC1L2L9F5+IVM5V8gaeHrZ+pYg0STs7Fu+OWxnSo66IjL1CZk0mXVNubHmbrPDRnsDQXWgalitEISxi+zMJEmAZby7ZoZmC4JuB5W5Dm4d32WJVLBDKRvCgXjk7JJZp9RwcN7fSiK9w7s7ibN6hwgJKV6Mc2Vuatqk9maLI3tTGihBvlXrzuiG7Qpd1g9FeOxFVybuXTri8zjnKEc4ahkWXm0JQ2k757ob6dmvtuXZL10nMs0erG8GtzEZRG4FWF29DcWdejIsq4SWc52N7JJ2a5YqDLVGjVDMw9jFNbdbVQ0pUhNYtoKvWg6wVTvBmgVea5mOTdhLBV2u3uoyocDC48J6LM3aOG3TxPNyOCr7dEqi95Xdu65XZxc/XkyDeMWGY7nTk3g1uqmq2dN3yhyCrVi4MuGXWOzQ6pWaszYWtYm2jA95FggDw7N0jvYb6utWmRfVL0UFBVpSjEvSdl09rLdN5q6hwNFN8so4ct5lAgDwTJugwnkhpodNiTSNvrb7Ah1RU0uu2x1ADwtAkQae1Y4CW/yu7eN/fP1lBZvD61e55KGups79VG2pVXIPmJbUF70Lu3KyumLBxEurBQrqBx1wrJnY2K0Tmrw+VCWNVbqwjV0+q7++xwT4XR3Pjd6fuzsNoThxlJqFtRHhQm7m9fgPDUOtXXFdft311TtXe2KgtVE7rDAwpSs+Up3YUhrjQ6VXUsPC9os455tNR1ZCG1NvKpSiTAsvjQRY7ebb4t7a2laKlI168OZqsHJ61aqCwGtRQiEVJqz3TYIFc1wGu25d7FRmi6NmKJ7ELRsoJ2APDtpG3l1Oo9eXjudoxw2k3ZlXdoou1iPYON+x2qK4ms6vMbt81wNde1w26rt6UhOnMdhSVWOu1e0KNgDw2xtuW8tceNaicvntNC1Ib3bcrAa359e1zT4tSbO5NBzailncqnKdDLyzcor5O5k6U+gQ0GLRTFI9lUXebKYwXcMm31McLTVHdi3YJdimbwtFG7h7QjDqcrmLWvlhgsgnrAHg+YFa7thLsmVd3K2pColebVxVnc1nZyl7QodJzpI1wLviL9ulCCzGZzRqQ3fkxdea3SZV631QkCju9ywUoczAmZIecRVdk5Mbkysy6l29sTaJJF9TSWDoLL2/K1xuvSTXZF3TqvPxWXkq8Qs9bvetFCVanZnT0TyHMHb280ujXY5XDrG29QV+A8Kqg6QA8FMZMIsVDEkTl9bPDEJcWvKSUMg4TqYYoHIWd59u7mk80VVYQTPTJDq5cWaxpkW9sUmyJHIYBRvJq+E2C6m1l9omjidoxo1ovJl1J6+utvQey5K7EBfS9uLBRjXHBqMDYkyuvqZu0K68NM4jGgbcEqs6ly5vZtmtFpOqPdbuya7Y7homVWp661CNuzjlSzVSqZt03TuQyqu+gUu4Ng07FdYs6gpnQy1u0UiOC+uMTlekK5t3ZtuqoVPtKmDGDENvdo1sqxdmortpgM1Z1qw4bSZpVLdRbd08dU8v6YMS7c6y+scK7BDeYearuhAHhlI2ucyptWLBPkS+XGc+vKV7crpryh2SlR3UuDb1kpUaUIdTFd8cDncO270GLVmQOyCKWVb4Rx1u7aGu7hddlV58RY5+ge5eo5jdhEDbotprsExHKzpEXm7VVetNXu7ivdo1ycg1JnqaTuSjyebjzlsLyxl9a5tIddvoWKuVlEOjq6C5SAiGC060VR0HMw0JAwrGYtivNcehR7gx7ym2gzDNaqt31cMFws3YsLrlSlHaFWqRUUXSB412rs3TxP5a+kPDrCd+LAHgptOmzyQrJLP2KaD+NGkkEZgXGhBkNUYKyTN8fvplv5YFnZMltuV81m7XB4VfJ1TWBjJku2KF9bqz15ytPkwXhC1caV8APCqd37Li2sUqrLOJGUSb671NikJNK6uyRyze2ry5azFQ6tsaqbLbhf0hpSsPYXV/dtYVn2HErUzKMfFWkGcXXNwkioEJAzlam9kuZkHUs3clkZeKqUGnAoKirGLbMNscIyx9e7ZvcT2k+yZD88hL6seiWo+vrDwh4IfR2MvB0WKbcLqCZyZZyor9DR02rRKJUkGaelqC7wOzTKR3qusXY9tShaWHtzBBagxQUEUpal07wnHWEVugyqiX2+3zfXv68+fd3XunzIGESESASWSYm0WAmiKRDRiaZAZhpoZFSEUkbbTEyIjDII2EvyczKaZKUMEZEyYoxSMwmkIMUmQSYyjGlBjTYyRkolApmaZMkJMlENMIighQRGCCSlE0DFDFhGCRzkKGU/JdihRhQwygMCZkSwSllBKIBAKaZTQJMplhJRNFMpEsZSAEzMNNmkGYyRUoYTNJJH1lH0va+FrkQhDSrLdKvnNyYqwUCIEWqy/ysVtNVZGnQzA+TvTK4U6q+qI7htaDxZp0udAzKeZYadO7YzdDBSypmWcjT2URMxuPrDL0ncIXiurMllVVjenHuqyOzoqxKqivqTtM3EELKUad0XCnYhqm09SRq+3XW8SGjQ5bhy1TGxVDngPC6yG7WxRsjOPXZmJikQWyuogvXKKnYJdYqqopy6G+4vFaiQ3HeJX6xeacgd3qRvTKedQ6GTYTSwbgVcbJscUMlPHv6pfas1Ngh6ZpMPW/up125tYCtJLsnGEYHtPlRzT2iU6yZS91VmkHSaBebCTMB7CraRdLDStLKF5cRlMk1w4hV2JS3w7aXPrxqaeJFE+IIAIJILKEyZQNATEQ9fP1fVEEblXljlbcx04CjrXH08KMNArEK8SKBVBZQzdrLxkVZmoPnh6BSqOdUpOM8V4HLKwMUihioVMYXHp3W562O4b17aI0bN25y7sa5xEQRiooqiiDPEkgGxcdN3mvDba2YG7rQh1t+DFxg0GQSTSQPhBmzVNpdKrGhdJ6KrVbfq3NdLKCjM1e0Z1eTNFMSECSQgQkKGYmkRITCUMJ53vxR2w+sb2HLb1bVEFca1Xzvqh7N2ql4EVr2gB4U+PTKh3cFcmUaeYgcV8ZMdcrjvmaPVpMQR601HEq41siB3bQqxs50b5d3bXVlMZW2cuJxowZoqU27qu5SzBjsOVceQ8eNzK6rZBRiCd1YTrKOVi3cY1m3yqMXlI9QqsuGrWJDPc7eVEKD1ahtWqC7LmpDEEgs3UX3UCdq5QS6qa0fiQ5zqn1mohxhOc1vyy5R3u7qydjNFO87WMLGloUNsBZo4mjIug8SCYU0saTBBJkxBfXnqbRGc7UeSqPPDOomy82+SmLwQnOSFkoIYitPvUAcWC9O26OpZ0q7xJ7DR0gvyHFx1ljdTwF3MVSCycjDujl15knIYwkhFokHm+u9Xr7efb7Pj5mx3rWglfKZqqwTu1Wy0/OzxHxrLXiyLU2nSOrsVMLxJ2xZuybxMWcqGJ0vLAdxbnroPqmS9ZKkcqqgyXczYxeZwmunIS7fParOPSS063se5oNZcYfB9z8egql2OzBhStW4jlZUxBUqkoC3lksbrwvebcV2KByXk1RYZpxKuL3jdUdrV24IGlukO0IJfIiKI2/MreFJb3TMJJZt3HVbYzXLJAHhtHNNzG83y67l9e+M58U1rNatIrGGCcdVF0Vp32cD99gNxUeBPzCKkb5WKu97fhzPG10d7MyLE0GVHXTHM5zL1VqTcDra7tmW9y6eiziPRdiI7tOtJDJLd6wwYxg7H5I689WJrJkug5VFjSwicCG9O7heUebbFXrL1b3Cp3C3qqZduYoMUtVVb3HGMwwzD29efXvvb16+3zr40IEwmmGJExi+7pFKRCyIiMkmgmiRIogYzTQmpZpKFmiNENKLEMymkRMiskYAQBEJTRJkqWGYgxlDSJmSmjBmxJRT6u3MNKCTEEWKJKSjEyKApAkUQSiQoMbRIxJJBmNJimMpmhkZKQRRRMpQbGiNMMUTSMSgnjmbJKRIIUQgYxMK/HXELDQmXq0yj4kE+HvDPwAeB7W/r+lWpf4NdIZ2iXR44RmX1ZCVXBKPppntHLQ2r6RvONdtoGlpO7eCqQydTlR1imZZjmqge0V2naIrBcTtYc31JcTmYXi3DKuxup5dBUqzZntAlV2o9CeLuMvKPVtK85ZC+zJaV7Ovd1K5wyxBtntmUdp8CE6dOtHVrFnbQdDNVUm8XXd8w4w03qDl5mGq2gh2dVMS3QwHgFTcHBO6eCoqtX0GXMsYSa9CifI9zCrMB0XijU694ZlCujJO+y7669bxKTJSk0BSSZmAgkk+JHu1DPSHK5UKplXWYO6lH6BA1WJ81EUgvEVSVBeU4o1ZrbhVRCrMFVF2HcxPzdEOSvRsMAeD2qbVjMErKUtc6LFbuQXtbBoa9Lp0feIJBJ8SCCQCSPEjxAINeSwuXm16xYtKpaxVx6noxAX23aR3N1AEhpS5QZpI+gLzKvcBRNVRVajEyRkw3MxewWtry8SSCSSAQzAxBJmQkBLvPPAkE+DEoYOsoZvYhJjinrzmc6Efn18zM77hI7eArJC9qz9knZpGIcJUe35krBWZgqtWXwLFCOjkPCsedddhViuFCt5ipLnNjaqqykgWwhy1HjyvnDRBXdZFpZSy7tIZCkNlTJr4636lalLbPcDdNkwu+4AeGLHC+4Iyqtm9WZVwibr6d2UOqNTSLmowhXXaVLFUhm5k3kdBW6HTt3NxCpL7M5eh2t1js3LWQXt0DmnftygdxZxMvYrarqFLG7vxJBBAJ8fEEE+JBBBO1jG5RamBsfZwsyt4bk1rTJKmEmJIpnyOG+53DhBXlDWv22oO2pyQy5xPWGCU1dwJgDwqpmR5mG8qdumn3ZlZJ17kUmhLjsNkVZPifEkHxBJBBVWCCKxiqrHdtsbtddNsVjTZds1GZdKhI0pqxasgqQhICidKzrVbvqt5izn2W6w4DcMfYxeU5BA1aoUD6e9ZINdzmy+b1N5iM0NawJSDgNVVIQbSycjSrHDLlM4ceziAPA5Z7O5YE+BtyOXbcFHN3RRegvVjyHOqkaoaYEw61mMPdvmZ7lCVdZdYU7CDNZt3VqlaBvtJzWtdUhWJLZCd0PMRvsyLsbV8c7QMNXKirZlPfbfq0ieNGyKvr6TkeyXafVENViDRmVnXq8vZOqjV4dydiq0L8muu9XWxkxGpW1LrKO9dd0sV146G7xFYK1q7HS6aSHZqgIWhQWgdJ6tGyjomrcUDeH9TNzeznhXZuXu5RNacKoAeGmAx3HQZefOYfacpLktC4Ll7FoVnm5JsW0aoV1ntWVXR6xNBsl1XbYqmjsKdbRfeRuUCNctNYe3VK4XvQVVJgDwZcyTRvXOuuksx12TCN5vrtBX2HmQxRLWp1s2usM8YLsrLmKq68matmUhfeNlzlfmtCJm0csSxV4JnK+e9tTBTD7YRQ6J1gzSOpbMlQUUhZfDYeytRvK7qzBIaQ3O1YV+Uvnw6tXMfGFQ3FErrb2Eb9Bt7dO+2KSqusydLYey6tzZSrKGcYKzkchugwB4RZaB2cklWiuAHheQxZeq8QWl1mYhlZL3FUzSaMDGe3m849Z0OC7qxwx9uVL7lMlbm5MKFqCpOy3VTKurSxluPrthKLXd3zy2IrUrCFYbzrjRpMdNDjaoZ0Ue2LowpG1Q72RVSmClKrbdyteN4mh2UtNpzMy+zt2TR1W74AeHbrGYcqDKNyGFEcHTtvDo2VW3ak2mq7Lq4600N7rm3l3t9HeV2XnoZt9V7xB0rcjfIjr2M1S5VC3W06vjhwTSAPBU6PoarBNxQholq8m1d5tccslZA+HUnVZLy4Cst7LIom6S13jWtigg2i6PBTrOjNsGd7HK7qLp5nc5lDala6iodV7lbWZj57LJJiNHX1pA2kr6zYqhFSyW5Cnbsbd9kxvqdIXJVE5XOt5XbEusylVOFZLaodrlkXsUR3s06RhrZm3gV45tW9UwGUtvMmXcewVmCrWb0OUq6wMEHKbtVGzL3r6XVbtC6LF6awJSawwe293bGiaXMaBboH67FwE/HdW11/VguiC8iuYTTzQj0AzrlYpfViFZqxTLoqhLvRmHSHnDfAeFHuLPbGC8VzYrKKQNV1uLrZSMLRmCp9vB+u9+Vb8h9KWCovdN12dzXnXOQ04QltYqhnZYLwc9yDMhOdTZ3sozpNCdQ1EXlO+pio8WCJ/Y4N0axys3Ln3qn0o5mvPqrNIT5VMoX07AbwpOCsuaQ9I7UOk3smPHm3YvtwiFyjZREj1Y9zUULy20HUNaCgZyRwx3Qu8ma4JLJq3Q6Vps6m4IIIsk0GVAZJti9aa3OCaVmTUNqziWGrHJUNnteRUJt3dVWs9OfJOs59H3Zreb8qZ+3HuxMgY6dLEHA5b+psbdgnX6vr40R2123p25wg6z3IRk4bpVPvszUd00jHtaDB1iZVIfX1UXVaqtyrqvY5o05DuPUukTSRaHPrCgwcOG9IMu6tuKpedqpKbjNO81iFGq3byxBreu7KUE4igRXWqGDc5h3wdHulVI6u3VzLs5cEN27mVQzOfr64FEaV8vZt8XXNa5VzuuyVeAypmnLHCWCnGiaNDezBCa572VUKzs7LMuPrENEiG5Y2LRQJqTs7V5xsqltlB2hdIzUlrFzktDp9d51mnVx5ddRO9jD2dyY2rfXjw0MwNZkyZe0mJV6NpLdoirLN9h2zt3RvRbzEX6YF4w3k3Mobi1xkL6Z8z8yMeXUVOo/pV3RyiM+DqmllOCfBRZVrKmaG4/UurqO3jm6eT0wmhetKllXW2lp3TW9MWcW63LXM3wOb+PPj1+ROZ+fkh+/KKytHy75FJLa6usHYV2CS0r1HRY05MbVFHK1jnauy+qhdk7zvrt5RmuTRTvMVNBS8KTNRRR0VWJgpvEndL1pDNVYJRxrTePD2jbj7zBMyt5cQ9qHiruVArFkZZKWUqzY1Oli0SpZcj3uvBozBXauq+Luxj5LqqXFI3c6rfWNJlSqlaVtCWlje3fjizThhrKNPK2mGLlkmylgOpHXYA8NV68vuXQpnus9sI0KhJVg2brqKb3Mzo71sjSlhk190u9UaoVl8F1vSSkgjV6UKpMdebndlC0b9xydHe52vMKsIYtRocnVYja4i6RGpc08Odt8nHDd3uLGXlQ3oTKsjN2pLrLW7qFavZkF96LfxrcNnn1Cq3grNeiO1iZs3b+MoZosh2jlZLvIQY+rMwO7t5YTeYyunDbXddy1vFUJ1Xt7MdDRenXawOdJwNVmYJedJF2hUbd04fK8p0hFc2nrqrjpb23OKKSzRWGYMuMddnt3qom9ftu79dLbyhdA7VEwSsuWXE29MZGcWIHOtljK7B1CW9Nl3XX14B3LdafVl1yY7UDW0FOXDNzSoMVmZx6Pqe3VUrh6VUlTUDpm3VhIEvCcYkyWO2r6yONFdJm2ruuJNvXNpUQqvDJuZqvN1K960bSiurq4NPWfS2kNj6xTqlhQza11tVsC5N5VEwy6M1cdwkOLMsydYKh7K8dpudiPd02xK5HJ3OK5W36z6XKrKoYRxRws1VBCUw4RrZW502nSTq5glWFlq82bFlvypybeg0JRbrkGJiF0VUuthx08UxkzJsTsy99ljYRWVnHyEyqrcGqJwaqOVlCiY5mCWRtWnBv6+n0zEt8vomV9VNVX2Lejyt2niywxpYA8DLYqsoaH02a0NTvp24eI6YjINfZMhzGLKQWQ36VeW9mogHbm1NyKtC5Cmja01L5Z68EPdj8wjBogrMgCjdbhkQFHWlrpZfQsRMclpaOMmG3ldRzcOXV27LwQtLWaqcXz04c4+1Py2PL8B4I4i1N55XC5RlrdzJbdBI0modpWGcuA80uuFZbl3kOY+J6+YZybfrw0VHnGVZtTL28nK9XWghu2Kbs76sx15WOBkyBmKPoyKkD5qh02u8isRuq7ulDdAHhg4PdtXvJVizMtcDFU5GXheuWaI3lCdc6zqQ8PDelXG4fTMNUpCyx0fPezTZhmx6ka/U6Svtda9zlFGql38AstmpSyd21t5nrqrPIUOqp0pfPpiEDfdrTsVWGucaYyl9IeEbV5iWrWHYsRKi5ysuEsbL02trW6raztnPczruuUQ67zzQqmaj91gnuq/Yj0G24IGmb7q7LrJlHdWNaSVm5d5ufX1Ecgft0sOK9kyhi559ad4VtoHo9xCzHVVjro1zEeEdfBXJ25u5U2m3e2q9mDMWkbLDl5iPbsFzMvTiGcDlTdU5aOVP527wUjY+n1KpXqyew2lQ+z7aPWx12hicJ5abzmG1k1aXVLAcmXS6s5HFGQrXkhHWX4Dw441lW8vL2DXenLKMwcNVCtHFhpdWiTsveJuglQb93IIihcG+WzC8OTQ6tWrqtHTZBVXBNyiqJIzcx+3MqEK9EYOc6zhLzbdObUHSVze31rcp7kq0qC3FwrZe2rXoLqHPE9i26uOs2PaV5R9sl9IXgOgDwNCtKNaZuaKezAa7qLkbvugrOmmnlDLe757uzKerJuOe2zREEgT2ZMyO8mVnZktEHt1VnCVLrqPFOg/WYEFNW7WXw1dmkjb1bYxur6hlwx9x2pQO2hEKH1qtqttfSWvAeHS1XwpY6aC3MWzSEY8u9X1aVfbHBla6p1rfe6ucC6U606bg1FzWzTYgsXvbt3NfXenNpxu3HXqy4x3yr6D5k31b8+l5a7RKwbzVrYVd1tfY47tccob3cMxmuClHtyC7DFC3uJsZt7u4ar1w3mGgTOWdhwZne7qzxgu9g1CVxGEusmGdVirFIQmmMzXdWF6peTUYu6KlmXzWDZyoWWsXu5m8u6fdl4gWaTDRvHMq7rHy9jbCBGZGLzIh0NStVcMzb2mDvHuTSI66yn6oXWvN7vuXJx/fbLlFih17mfYhq7r052TfPLgoHe0RreTcGXplDdk18pldJWJ5dlpmsGZu7Bhc6eycDnG2KvN7tdui6iFAsvIeKvddsbSL7We6zvCoF0yZKUyDHO2lhfPN23XSm1KLj0Ye007at9ddFXV19QrZLGRYT2OSg2zpzN2tkOZSEd9HyQzhK3qsN3dYaIPDHCJnXKRtLL0GjlCaTRToIkc2L8cw4JWGzH6OC50y4suuDQe9WVcwzjV/fLMExA5sdF1dUXTPkT8htZSGylkCqqo5G5tU7NTEqy3cBw5j458ZtO9dbXz+sVw7XWZDRg4WahR8qhwedAk0zUy3TmEcvZrYs20WHcPXW3e6a8qWGa87oK3uzLB3feHhi8B4Ye1i94R7nVTyPSVfPLI2VtG1e9KedxdXt0GXd1212mX1dcxutOS0d0S2cvzCbmLM9asXymA5MwxlP2aNoowZvHLZXEy9sq7PSumIIVyzu4KtnCwVsxvaIzJbAHhFvIrau+YTMIvMMT7EC1LeELGqPHIsug9L3XFV9s5doeVh3oWW28GUJZvc/Pywy7v8CL+/M+z81dykzgaVVehXzlm5VHpOMHYILZeoh0nHjzZS3i7feq4sVTKrnHuL458JPq5Sd8aL9ZIWXW3a3MYId63ZsT4cdwGxtArC8M6W43cdHcUBcaVVM0u7q6CFquTK4SmUxmtRRdY2N9Oz5Ks5HhjWm18mbwJ6WoPjXVpOBC1KJpFEntW1kB6XQG5YGuz0YwQ4Zs3ud9QDHN9vaMzSDnPdZTgb7ObR0904AeHQt157eCuOiDU1Tue7OpGGu5+KbdCxpV9HrvMd29LbskOgbqcRrEtwVtTKnZvCfMLvvqHx+0jaeK9Q766tpV9VG8q1ULNiFX89qo3d3Rm3J8r2dHvJ+2FClsTfrqkOgIUVYC4LEhP0W9Bmbwd6ftHVYdK8uheDKMpw0Lvlyh00rMGOqOZgaW2m2T8qJex3y26PZc29+qxtznWNDbvNyPGHM69NMVK2cZZk7tZusqE6bVPU8QppBCuBVDjZvbbf1j7MmLdfyCgV7Tv6w9vanacRo9CWa6ZRkPewKhe1bJBPknBe3DXrMzIIKhvoMiCHdW9ePEoZLrUKpqYNtDjwxXE3puJMAeFWJpN4KNSSj0Y5KZp6+vN7rhHTnvBBWb6obTlUWy4kjNyAz3bSFN5p5l5vHsXXdd0OGqRc7NQ665zM93VuAbYJDdUF6Dd3MtlWc0zet21X0XeNqZ9Pgvqr7QcmmVrNLmtmhJJ/cxJe792Oe+5dwOWTZTxF4uU9ZayUNrq3JIkpgVs8MU3b9cHXQehHc7YnR5tULIL01uKju2SwVfNnMgu+GU5506Xi6nA8+QqLUKt9e9bt9QUF7x6jMUpXdMZQjvNO7tj3NBSJdxsdWUcJYoXKFU+CoM3m5jvxvA0F2/feeq8GZIfR6Mj+v7b43HFz4zqw2OWtYMU1ysTcubAb7nWhIZo6tbmsh5RG3WxBYbLs0Ka2Hs7s7mWrJcuDUNw5w59E6gK9uy4NvOO2cnZSVMLcYqg0dlVt0gKqsZzbdlXMSH6xSKj3Y9z45a+MF7Uyw7K7hiPpJid9b07Hx6sWu50zudNc4urvStiJiKqCqRERUEEkjxIJPiBem7ob2YzhQkCovnXWuBoO2lZiNUK6dOysF72WT3dpuuGXm9xxmbWaILeCRdbtXSRgllF0OafCxty3mHYqw121hOXXoxma1CXghPLXea6q232XlrURWY2isoYKY3mL0YzOrIe2UYOeZrvq8sRrpu3mK8zBiRrqd1COXUmxhfE0eM4G97LuU6tw6GxKprxcfJidyfn34xp4/QLcH2F4OpujBT3c3LJAHg2KsLz+a2hJI0c7KvqyF29bEp6tkqIN3y2Zg1QKspr2KYgrKt4CrVhwZzzRqV3WEILnQpmfSDnXZWfPH31TBZ7PPa9QfJVeUsXteKN20bGEXnqWUT6B0wkb6+6IQWAeNbiDC3u4Xi23tqXR8ObGg0yV5gjKQ01nPCxW0VlCSja8B4WrhfszuVOqusnY5h7WGSJMi+Vi/syfbu83e/VudL+mpnAnT1X29px7Ozt15jFbkd9VVkG7KrFR2xbnXV6ts9XBnFtc1ayrMS2hu5KDDu5YrVskVzXENu8YbeYJVTj15aHcwrSmWJk6Hm6QtW9ycdxC0bvlZ68GFKEHmLzcE1K7KHCVedV9pYQLruLhPWhSkOY7vnWIPsV2zWSyrx1CcOY7rjcSNiZBly2jElzy6hpaO1sgi8gjHM0kKHMbl2cShUVDdG1LG8KLKix3CDajMzr6tK7KWg96lUZBNvqlRk6Dp3lzuZFbjUp9UyhqaG8Ua2yD1dEHCI+WOmHpdbi6pqk+ObxOOi+j+su0eonplNa3FWbqns4yvHyYS7QsZ3YTZGvhwYH9viuJYQxiMDNts3AxPFNVEnv66Zk0EgBJmSFGIIKTDORLECqZREDCWCY5WCyTCEMkSyRjQExSMWSUySn7O7ELFIwyZMyKIpkjFFSE0IUgMKSTLDBMJJYSDJTRlNDEJEEkTJlhJlIhjVoNmEYAFCUMUGFGeu3CJmSIUszQlEYJNMURTYhkoiUkkAEhKQRIyiEYVJTQI/gdXAjEsIZFKGIyFbRIWmQSFD124JRYkZIMmYUkhJaJMJgzzuQaaREzMQWtElKRDYwKA0wFNPJ0mJoYkkMRiYEIRLSlWiKSAopKtJmSMYySBqURKAd240T126aRBaGCw2ZKSCJNMwjIkJmBCkYgkpIJGgxIjSMUQFAkpGNGRKRAgTzrs0gTNKEkZBFpMmIzADIwREDAkyYMhkGSzXp2DCSCMIwxkUiYlIMBAxiUgyKSRKhTQhGUNIISyQUGOdjK8a5FkMxEyiBkoyFWlIkGRIMTSyiSaZMmmIoQYSbztwpJlWjSBk2tCzIY2IhYUCiEDIyITBSMURmAgxIGExMmJMWZMmBkgEwkoRCaQwgpZGhESTJkNJRedckjIJGQgxkytoGSIiSSgh3cxEUEGiDMyITYxRCTAUySTEbKGjTE7zvJMoxhCKGE0k0CDJpYWZGRMliSjImRomoZImYEFEjUgaIpkGYhihKEYgTSEQgRpTGIoGmkWQQShIaQUCQQmMIyIhDRAZZojJ+Hz36r16iUmySo+O7EphpGYlIiMhSNMCRCJjK2mQJsfsXJJNYI1aWYiSRhBTMQJIMAzJkZMiYYpGkGiUSgvO6TLDCQBTGCIZIZkwyaEokUZEIkDCUlEZEiUlIlCJMgBRlTSzKIGRJiZEs2B81a64YBi/1uuKYmyRkYPO26giUJd3TEUIlXrrijMpDKME7txQmUk1aSIzZNTISJGhMJiBIJNEZMRpJZAxIipGYk2UJIRQgohAiBEttIylM87mFEAxJExpJCxopYQSUDQhRCBGGkEqQkjB553lAzxyajCEWWYzMmzKJCIhkUkIkxlGCKYQUdwbBuMcCS7ohgiwDJkia1SxwkZE2YiUYSIjRClNIaaZhJEjM2CBimSkQD5cJJiINBMKaKI8XSMyTKSSk99cIyZNAKE0sjBAiESwlNIiUpCSCaIxiSYRPddxpJiSQkZKIqWAYww3ruKgyNg1y5EgylBkzGopE0xMmaIkgMmSQ2GmMkNtoonOVGNGIlJIMQwxFEJge+7YsEoyaZPF0ksRSYpQIFMVEwwFedrsleddohc7u6SaGxqURmRjR43FJAO6uyZI0xkmGNgBKE5rkImZC7uwYjTYied2iWMkohmiIkJKIMaMw0GTRJBSSRADAKKkwAqJKYIgokEmTYAkJRZmQwJIXnXJGimKU2UihmZpKJSCR53ZMMWRoRSCNISRFKKZXOZJDAmAiQxFNiWSDxyTBCRJfq65IyzEMPd3TGLIxCEiKYzIgwGASBBITQklhlIJkjFCygSCSmiSBSmKIiUAGMi+JujFoa2mNEMYRSgmMmQohopmIowZSkyKpsZMzyujalG37e9XmvVhZTGFkJGQEgCEgZEVImJSUpknz1wkKTNEgaYCE0jSwTZJiBCDDAAEQmUphF+Xa4TAaakBmCEKIVJhNM0iK83dGmBKZk29/r+L5/PrW7Nuy7bXpVcz3V6k8rm2KZmgECHbCjFyFMi8TSZNEhSpoYAN5X57rXx76tbbe90L6WBEwAsVVVUYXp0M7+w0NO8reTr/7OPMOObjxrG3U4EtstD0euWx1Fk46bvIrPkREZmhto2msSSxv15qpL+F9V2+H6b32rkNIMSholk0SSmiSUzYZGT9ndGzRRBIkFmZCYJAhiRTMaMcuxGUI0ZCBYSRJiMIGRiIRhEBMpCGAQkmEFJEixoJgAICiQhhghraYLDYCkiSSFMpkxkzEoRA5dRMhUiMi52JjKMKYVaIfuLtEUKGZEiyiI0IJCEiUiIhMoyGRQilmmlAsipSiMiTI0JEgUVE0oRpCUqE87opmpjEFrQhSKZMkYESMsLu3MiCYQQQZmRG1pjSkQiIBhMRlExmAhojKGmRTDSMRpjIGMlGBSSItaSVtEKCpGIxkmhc7CDDRIQlKCwoSatEKDIYkhjzrmUh53SLEZApSGkCpZExTDFFQiAIUkpRDRoiMZhMIyMZRgTSUgEQIZiAJCZhMCLFjJTFMWCIkIEsGF+4rszLJNPSuq0RBRaRGYmZMSSIyhmRJkaBMmTRCSDZLMeddRqSZGCJokzFowGMICMkYykZMmTCk0oGiYYSiZMpkVKSUxJmGjQ2JQjIRlgikkjCQlMCEWtCmMESx6dRmSZJjMwxMFCIwYgBTKDJIoyrRiIyIEoiRkjKRc5hmaFeleeVwCEJJNWiUd3RMzNCJlmERKWG+3cohkyQSBMJMSGQEGZoSZgRDJCkUAExEZFARYkFIaAJRoFEjKSDBYaGKIAYUiCKel6eEucRMJJu67KREpEJk0WRVoRlPxm6ooiMygipHnds0zFjJGSRQAQyIgiiiyTBoTEmQwUmyiRNDZjRkB6VyEiUphgkSkpMSYaSbKaMKKBGRSJkUeOYkmFkYY2Td3UwMpsJKYliUiZJEIwUYl527YIJggeOS1poZEq0ovO5NImSGlINSSCkwwpDM0yaJYxJd3YUmRISSzYNSUaEJKGQgEpSSRkQyElHncQYpVoM0DAMEyITECZXiuZCUSUZmIi8XSMzYSSEUwUwmRsMookySggYUgpMyaGQyRBq0MDGmiRRkGZkZd3JMWUwSZUvOrkxKpu6r58YTrvbGckSMEEEUWKIomRiYYKMwRLEKDIUHz10ihpiSQRIEkgYpCzSSRPs4kjFGEyYEwyDQjSJoMhMTSBCElDLJYmMCSKaYiQljZljX5TdpEVaREzGiNWimTERQxJnnV68rqMfw+12ImzRJKBgIkjJGhoGMpIyGIoxMoaRMjKU0mCISyMxMQSWDDAZNQISIgwjKTQV53ZkphjBRDEu7qUSSlmgSUYwCRkKNIoxjTAmKU1zpNiGBUwCIEMsUxDBBJMiAJjGUDTQkSkSEkImylCQZTSpIlKRmMMyJAyFRAjNJSUSkyIGSUhmGjEFEelyJRso2mUYhVpFBCKSZNGY7umKEUpImEyJO640SGUihmSkGJApUBhCgJFJphRkIzJPO6KFGUZMaaLNed73nUSCUYiSFWmlDASLx0Gb11xjQv3VeedskmRkgpgyYEoQEq0ywKMliQxiFDSkyUojSRIUmRgjMRQhJCYzKCzQyyYMEoSFKaCMkBBZgkV73XakAU87gxKDEQUAxgEKxGmYZESC0xOXEIyaMJSYTEokA02UwhAykJiNJMGULNmDGiaSBZZkTREoKZYyJkwJJEyGCCZ5XZtU1lGFmxaa9W7CiZSI9VzGZMq4IpCJYDzgPL929a3vb+N9/jV9ybFGkIxEmCsiqCiJBYopBRTM8u30djj0envNZMrNPWTrMOOQmHnkmcZWT8kSw+wYZSWE127ib6jsMzMHfqt7axNJAy2waUoa61EjZTdrHbml4a/q7YNWAPCsBwkmtISF3UDRWHpINCq8znxSsjPZfY2/bmtOyJRyOzXccdGtGxBYlUoG4LuaXgeaN6kMhOISkNxEVLA2ji0G5a9mRB9QwHqgmvBdZdWKBZrlU26uKWDxdvGKwoxarnk9Z6suE8Tg7rPdQZGXzJKs318tTrKSqCZnUKmHMy0bItYLZWKmJ2VlradIdu7orvX191gjJV2CrIlTmyw2eUybaCIrxwiv5j41lRH6E5tx1ir68LG/Tu3qvixuXp1jU7gcu715qUSpTq11MdHqjWGvt+yWPnTlV9fzOZHcrn9LlKYlamVnbas3KylBu6O6Y4nzeFGqY1Jb2TJ7b7LlXS1KR3ey6Yxl2kMeQw3eYbWXmk0cRrMvHdEOqqM6sqdA7p9oujtu+z2Cze6461ktXRGS5GO1Drq8l5BuVEbRwQK76XHYpZqWSqIy3o43nK9F2ari5srxwIqVeZmPIew5QWW9vLqE3MCEk6UcynO+a7eaV5ofxvTkeyXgP2oas7qEZyrzZl2McTgwbYvujS5R9xsbYu2Z2tnWreXjTV66rFZr2qSF6ozV7FMDlIU9fTqYvZxvJwPHhq7WKa7sfb1cL4S3ga2+YVM7BifUxmwyqpXzZrT68poPao3btFt9J9WH1gfVNMCpNfS+yopUBT+lU8NsjWxVA1VX9tDZyyx1TlUezmBiwk8pESQ7uIXc03bxVAdo9jvJfBKrs+Rft7lgozRlVdVxyCjXO30Q0l4KNF3VU7tSPKFGqwJ5mcfaMvsF2mOt9hWcesvuRF9WEN7K7u0dnxm3tzeq3ym4D8APA8Fu3EacvXTrCmKm4xRZurrfZ1O7nMU5WTb9XN91ZaHK72FNGu3sihcslXdrZddRh7usVTHad2qw0zWXUqrMq4FdEkPbUYjaClqhkLl7mXQKsMFVVDKduyrq0Lu3lvJlro4269Q0Emq3aMxX1zBc40g3KRPPocvHWZix2dQThltxRK0EXlHfKzeXV2JkU9McWvsMvRSrNKrrU27oMX0d/QVjzzV7qQC+NZiw/A9cnlQuYxmDFL1+A8F7cMvA9RhpS9qo7pzMC8mLlRyXVn00ky7FzMyq2YIX3dyxptYbd+Oi9aku81hC0oEhrHGnFq3N47N7by10sMJCZHKZ3uXQmceNdVwXOSjZxmMTrqpFfFv0Jsag/HJNKFRbxxmYsG7E86rt2ne2MXpdOmMWSrUxUVj9hYlBXLudR5O0YBbTM0vb2qGQiblU5ZDJGEaaQ3TitC8owGKWE9ry6kFnG+QvhFjs0JszLq87pnG1lHkSYcNZwXWq0ZvcolRrMdQVlLafjKacwWaw0a7ZpPHa3DfF5UnR7Nx5SQgrO3Xg3Q1l4881u7DdKbwQbHXvCSJXU7lhy8SpC3m+SWZVm7thWGQytrlntGda6HbXRkOqKqbLb6EvsAsZ0KZ42qrA6FW88c3F19tc6XWadzOqzZBWYhhqtNG3LqlxcZunQIvfR6RiGUrck+6qTgz7+X4LfxXQqz+GtSyz99pb69kemoFSOhHG8yteOVm5zNY4E52wkjLF7Fh/NXx3NIi2arUqX8U62HN+XQ7X3Idtu+cp/CqQVx8R9KpN9JLSV9dEisqEtmnuy7ALFVOTMpYUS3y3e17gqMvZRUrTr5Z0XOJQruzgeVXXcMvJqrMvH4ik0HKPUPuu+wptZAgocGmO8IUk9iVFw/a8ie0JMGILAajKrU3f1ibovSx/JlN19o26+4uUgU9sgfVW1ypQp86zS0OSLvMx5fQ6q2u723OQzS2wcGwPKRqjVXcqVx8UHZzmG0MzakZmjdqyZdr8aLWqJ+7FY2vZPWPntoEF245hl0Ptic7bGPFtL6b2do4Q7H2C/qurzd6CzTcl0Y9vMPbvE4gjNVVWohDMsVLs1xXGHFvSq7W+8VlWdFy8LEitG7re7UHW9lLdua42rQep3phxzS+cwPLuZeHrl4Ky09YsvaOJQtcZSxW9QVADw23XgPDtD3uVK3WN+rj4E1g5tFmLRWWzaXdIoZNZyReW+0C/Z1kYPvdk/A/grSouqHHhv6rf1XefBEeHi6Wjqizc69GKz3PX1g6TH11fdK5AzTuG6HXO7j2zIy+DAHhziAuPk+vCXaVTFkuj5XokPBxg6NIvbvrQ26U09unRzoGgjLt6mq6UzZkfqFVu4yXuqpqK0aDHjejljs012eqZ3IYCHpWIxwbDdc/TLO+cq8JbSF2dVKa7AHhl1Z69l5qTbW8xl3VHlIa01XdT0jcdh1fGMFVmzuQbJubuYLFgnnm7hyVWVC+9w0voM68x4nzsnb1FA5FwOvT14CXcnPBCLpGryztyNdre26J3G1epUSTwWbh14dg0WXiIrqy5vNgTCa0RY7vJd7iOGaOSjFNM8g+1aNsogl9V+gmYFAt6WSZfVjM4b7KrDfJy8FpvyVqoFe083Um8LJCrsx2lNkBeWmemzl1ouLGqY4c7W90kOHcaonpm63mfsnuq/u7kz4/ZsYknOAolA3Mqwx11mWEeL1ZuzsVDul7HOEvJl5joZZJqUXco1ePjGcMFZj3erndY+F0CtuhwR3bO1xF1RKXbL3U8Vas9u1E+plKklLzWN3Zj1LJK0+xVmBMgjelZ1KVNzGd9bhzc9WP15qrO07opbOmdiqwbo8txdBdJS/VbmuzRIvfOg8WWcNWZcy3XKsV7eFB1lQ3e6cqunU80HCXjCwOlxwGNT2PhasZbtZiROU8jb2/SjHzUBV3xQSywS2nVPYHx0s2Er5DOCb72pjcEUzpsN6jg7snDdQe0IyT2+zLq8OTENN4jKqqNtaLmX1qEKlvb3327Krfl9tMRab3MFDujf1t/Fz7AXgRkSubu3d1nQQ1W2q2rnpQnPGtpjdqDHWyVhG1r7VbAwbHXdLPS4XXUMRqHBkWKdNG6qriG8qgVEFWm9isJmHdiBA1cMm3iOddQdm6sZpPqd6Jl3saMFm913ePE52HLsVVYZV3spOVAh4eBrHVQ4WTDDbjrdNZlRM4hLVRYgslN09HMiPgzV42MuPz3IK19XrRsyKi5dixXJ6dfbiw4QdHTVWZm49DmR6OKMmA89ys4hb12tHPFYo7i7jr3XTEuhUurAZSzYmsmLmrcDGUt2tyaeeChg4Y3KdI3ScI2/dqsLhYZjlYMz0oZdjPZbZGHSzxuqYvrVEjMzVnYczktqLrK6h2PLFcFzCtnsqdQwG0L2yjLpQAeFybsbr1soVeWT2/W6EO/JhBFVXX8Jzqhg+eNIneYTo5CJqV0V6TixVhLbuse6bwpcs5o117qz7mLu6JF7vLzNs4LoHbFfZrIa+3n316laEP06b9yM2dvKX16bYustHTSUahsOmp1iliB7WStwq9GVjV1bw7M1o76Ot2RUs7UKg03TWbjkBdZXchyfbm3hl6etmxd7ZtzXmbennu72ATa3LWZbu6IlQ3cz9/5PwdqvuRW/fmalaWj8rU7n6P310et1WesRobRq1nx2bKYXyFLR3cr3BtdoKuF1ewVuCq7BxT+XXv32XPicscrp6ZgsfHuV7pNzhvbSQOeQvHmkcdyc/lHlWi18MY4LrqZv2XS6hZF6oOhl5RqJVEqPYHhVNZNOEnQ51dY67M++0h/CX3w++53pGU77YAt256Tq3GTNE43QnO+y619bpRlGhuw67F57RtMaqqtsIirmXK9CH6gjxCrU6CrhKwubt2sqwa9S69embt64E1Vp9u43ui+CwWM1A0UFSjYdxXSQ3rrkMNrbm5CknirGI3yj1dbGarebEGGDFV5GJAc3novnup2jtzrHPFc+3Q7XVmnx4loIfbhbUvTc1VVjKOJAijt7SL0JV9zohMlmugLyYrkF3W2m7zsoPHmV1isqhMI5A3GE8UAHhNMyHBTAIPkN3BFudNWoSTb3JhdqnXsW4h1yetxdomecSuiq2y8mnOhQoZmdxmt7V6mwsaE2yqVcpuV1ZMnXnjuXxLDuXpqhfVmo/xAfcba3a4T6Thez6g7VK+fF1Wuu666KgWtM3I0TLiE0Dketdnab6whVnBeq9QcLuqaLEvCxKvgtaE3cvMrcYcjbrap9SyZYbWUZu+1zDhG9g7iRVb1s1e8NZtwV3XiWKadOXV6EXtFyXAqJ9Q01yZnBS5IuutPivM9WFQSpJJUkJIBBFGFLIpACQYliykoopNCvz7lZiSgCSKUGlD8+6SSk2AkmSoUIZIEzQftOMjZiTQTNJBMJphNmEmRjZNjIMEHjkmCJTNKZkyElDEYJggwkkQlMghmBCEgpEMCEYmQvTi8V0JhBQ1aKWlNMySINl51yMymKRMpIoGmjImwiQihiMYRSYkMRkCSIMENIUTSTGKIhpQRTDZkEpiRnd0xS0qKQKJpDEzJECSWVGmSMRlKgySaKDMSY2CmSjImKSLl2QCRFBRgEUZDIDJIXxK9c8+Pbdz1PVmTDBvHMubFnW97OPcy3rd66o1lmngi39GrealvZyGxDBDMytNu29rcWD99QbUpFUza2b2LMzsrnUZdDATjFLtqwkL3dt7fbfA6jlrfDYOu826qmuYXE8uLr1xbkCoTQuL3cVd6aKNQVRvRzyyNj65b0VnQ4xKlo7Xftnxej7OvraF11UT99f06/ivNmiTzLsb2s/BZuGqQ0Kb0zLyhW7M6bYXJkWQ7tcKJFXFhy7282SoNVskyi9UHbSveTVLmE8zzTSDCugzS28oiSwRXGqujYZ8Vd5kd2zK35DYVk+P1dn1XrGNx6NgK3Mc+6Nt0M0WrDemN1lXFQ6sdt9YGAvhXuFZFumhgljMM6YaQcmS/sr49y7rW/XLVStp63nn3vtfa9iEjFMaSNCSEeJIB8CCPEgkgrLGt57Ut4GeUk7oKbutTyhAroulLtPdWXYNrQgi9rxM1RK7dErnohKWWLnQ97fbuTbYyoDV1Lxa8TOt9SDB94g3lCgQRc6jFAwVxErokYRIhUGNLIUgIzZSNae00nMj26wV1c8HHkiSDw62KpeZINquNWi9PGb3MhldVLUE7+dRK/vfPr1piDYzREZkhDGJPjgICJJ8YiSTd/des4ptGgnXtxfK+V2E7ly8E1UMzb3b68RrbSDhmKIx9etvHRSUxuB1ZMzr11cRFUxj7OwXxve6Vko4wSKwYfKvWjSUqUqNU1eb2bxdvaNmd3bWHxFoi3zzrxCK7zMjyOt9nXTqi9snLvuVPMQKuHLW44qq7CRkuueaquorOkwbYOXMbyuuU46q6gPXI9OVd028d5ZvAbK0CLetq48qt3vBjdUNNWVtviZN5LBhCdh5Og6nXcDt+qMHOe4Pf2+Pl59fN9SYEmNIGhJMAEggnx26D0WFOVvYDWUhDfK82tvRKHAgjUBxp4SuubFAgkbPkDro117WlzMlRbeRkVdrOuWbJ8RRFS6XkH6bUZvO7XbY0zrprjXTQM4oRQREWRirFRfkF4EEkAj5SYgq0/TD27fzQgd0zaDpn1L+U/NCLwHhpNhMg+PyO/W4D4m/uvHt2W620JfGuASenzDQA8JQFpuifVYGZMzbzLupXGmhmJbiurG7VGtpnuyR0MHS/dNSda7exA3niNd0VjLGzatFSqMyO61fiW3F9Pvrhw3XDMrR8DnW7qriey9vDq3drphq2hmqnOwoGU3bDZVW+lW+xc6KqrTm3uJgwO73Z0TqoaHneUlxvJ7UM9czcgrJdy63YJltBRX6hjRFCmrByjmWR167WzhwwcOvEZqpHqXNDDvIG2FNDeB3CL9omZOnQ50MxZysXbE0jW27LWl7cyd3CFXRzljnicEW7RchM2yhZ4dmChcNVKkFCGzAezk+uqGwY1w6kn0ObKmZaoIYL9tZsbjqqkMFZxY0UoiaeYrbrdyFK61KEOfbxrQhu4Ur7TN7tMZxNbHTCbVti0igrEWJGMRFpEyGlJkGJYhTEaNrQmSmUYESLGjIaKZ46tphCKZqYySRBiZEsJDKU+ud0sQhKREmhQQxkoJAoEoooSU2DMaQUSSSRkJKSaFJBEUGiMU1aU5zRsEExUJASUSC0JQiSZpkkSSbJpgmZDJhEwzRgQszUkkySZAUYyKUYZEiEESnNxAwEAkgEHsNqkmVaGlV9Ge+sWai3b27GrSQcVU+5rszBlWYnifZ1VrpbiVde+eVUlnvOrtM0+Nar0Yso3tPMzG2oe27wR72oym9LEuZXmazVXI8qo07q7QF4J1OIabY0HRCNpbRzLvFk6AnM2ySTc42U3RFcrqIGs9UlhKPc2VaGCrmSxFmCaz4rYNKGBZWq0GxRWXzGd0q1p0LOeZCVtPXJKsP3dRXHcu6EKq8JPz+vpiypBytZOlGtwa4ML+rqtOxwqq7Jgrdsr50dwLerE4YJW8cdqnmAkgkk+B8SGCKRmZiBAU0oZRtM64/TfsverSr6QYIvDCDFVl4rgbMqMOiASYOrSc+q6ykpr+b0c4aWDUzybIbjEkYI3p8ynTb8ahvWLjaktTcj12M3rM6Lu2oDQZERWIsYiKKKE+PjuWKeu7uteKrv97rN5Ihrw4jg6o0hdEkoD4ogkjrqWSqqfNbJdqWMprhaOdlUhkfbnadNZdAMAgnx8ST4kEeIJRURBEVQVYIxilXe6922xitt2sC6UX0EfamaQeUlXXFU0ilMcdm8jbmpWtFTUMKpVztURq03Zx3lVJgjHMMo8mYL5Gt5qwhNr0N6wnYomz60a1dHUpDiNmEIkwdJdnRtKsioxteyKHQhMOVe1zz1+KLBPsyqdKVVWca26xB3sWd1lS91jmN1XVvHRv9hn33Ybz6M/DUw5s+crylHIG52ZUuiCahbGUe8FLKcC5usNvNnDLtc2K13d25OijvMl3VITcDuxdWm43m7OmbN7oHZNlXMCx1js7wiSTIBSTGZGPX153v29/dePn73z5d2HT1T4PLmB+oFLrcS8xaFymH4yJ8tzKu/JoHqEBS7Wy5nZdgSEF2Firf2rN+qohv32KXVgyrzmpnzWjfHwIPiSSQQQfE+8QSA8l491Fab0bi9N2qUygwQfELTQZDBLruaUlVlVQiU1sEdLstAPTYlxXELGcT6w5wNqqPsJHv30YkUUJZJmYRiZGQMy1opSSUyQQE2TISrRGaTIgzJqN+HQRNBEiUZIYxREb9PdkpYlkpEmmQ357folN54wUhmZBGU0LDUyRkyenBkgoASaRIlZpMgRABKITECEmKGBhRkSkxMjEr2uJSEkiYpAZLCatEpGAiWCZgAyCMwhEiWJAwY0CYwRSUIRSEmJ4uJIhKYMZEiU2KZFJExJmJN8ZdMwY0RDEQyhIZJMxTBFAJQYkEZsk0kTKipA0TSiQCjJJASEZQk/Hd+c78z0tNq/Z789Z0ty75oSEJAhHbdIQJMhQiEw0CRFBCBgkQJRKRMkUvy7vHIImQaCPxfn+f37z9Tet46eInh12tcPXs/Hpve1iMzS5yVN+yh0lhi6za1a7FTpHhozp3Gt29GnHWxX3SdtPLPEdhSWPe3qq65YYqyFZdLN64pnqvbe0n0zdTveaDlN7fId59l6xSvH2dyvhpIundoG3V0OaZHs49Mv3JN51VhXZkkGnOuZ0uPNvjeWSzeDuujhqzK3UqvMeCrWU5bIn7XVMrL7sUCZs+sOmeLZTbonajaKjhYpN/XV5bu7OWoiFjuKrGvWFA3BNVZtMnsXrWVJOQlVXZMhscGrdWLiYTO8lZV0idEIqQRVHtk5jRd3WKsla3jAHhtu0SZdehrxAHg+Me9mKtSwYLWZdo0rC9lbdTp16RRrrfW9Jp3fVJucd914/XKy73I9uqZHCjc0taHV7w3c7iNPdYZxz4q91h19W7ymfToFVZe9eXY4DezJZzLu8NJZq25BoR6zpN11OhBTwaAdpzDdp50DbpXvqfDlzZWA3dIp3OLFjrUvpouplzel4EDcPntxwrg2YmX/CP30Vtc1wRXUrqY5FMHQOifmVipYcqp1nIl14L7T0CnXVVV8npRrAr7O46KsyCsGdkG0VZ7lR09dW65cSHcZhrptPiKIw9FPYzOu+mkp7uXvGuceHJNnPOTXXShsWnGwTYnGzFQJ2+iBz3IWJKQrXG/HboOzHWT14DYysDOPap4YsC1PwHgskR0Q5RoHNt4aV5izqqn2Ugt3Bl4aZIoVODtuXQ4ixr/M+4uvvlMN1oKDCw41WT5qYgtuOhplrSR92cuzx5s4xKqkgrm32q8oYOLoZ33ZbXWR31evMH1ZXjUaxpiLSLJbCm1Wd1CpVYyLVffL6Vgr6HNby7CEEz0TZIb5W804c2DMlZAgkaIZp2YLyP1TBQuHA6ZWkNhPcPOxS1l/fSJPb75VRlKqPJ3TyhtbZI2OrG18tInrbG94v7M+upwreP0kWhGqpPbakPqzJG7s23sHzJrMratt5FoV4eGljuN3odxbd3hlHjLcsRDZXHOWbdg1eKhhs2EFZzHWtm5tLiRldq6yGKGcLZJnt5ZdqrEvNZvvN7Pm7+pfVsmJEpA1a7r0IysRrH7SIYD8r55aqVWnJu7mEnRfXcHZe3AqnlLBp4l1SuQ6lgduVd9d1MUGXoe1hWzrQyQP3J1ot03Q5g15gqixuZdV02qOEW4dcA6q2mLYlXfDdbLh9b+UH3wr7a+2DgjbQLxUnNLOWs+cVbcBmTd7GYkHpe1uVXXXX2TWeOPDFV7yxVTsbheQTmaWO/MmVS1y1F1WnmOVI3o5tK7ThX4uDu70WDKu1DTBfz4Xl2ll3RnxzOqFPDtouBUjU0hgwddfl7993NI5VRuyUSHDuU7dsVPXbOSkqeVZvGqbX2WHNO59LrtMDTly5wwNyaUGrqUCbNc6VFnnFdXV0s7PbMiQ59rwZXDrLV9tqtG4OdHsiuurNGWurJe88dWgi+bw3a4k0jNIkOZJvbZfBUeE6VkzN3NKG+2z10u4WrFQuQpW8wKk+Gk7oZuzdrIcvdlGaudHNZ5yNg9t23MEdG31U+rTblihlMOS8errvq81ap3OeXfGglOxVUsOdTVtDjVPbky7223T5Xl3jCSDlYnGzjcwVx7ja28umOfK5eYEMw4Oc4uuI1qlxKxbViw5z6SlVUKI17Va4uGCqyZtx3GtmffOX1Wyvoa7n9AZNuzZzF1J0Ofd3ChFBW0rp96add8bXVQ3ZFRd0xp3a3LXMUMQpPSlHR9LdZVxi7vsVQ8lmdeU5y140sxhm6PVxjy2xzc2eVrqk+vIZdn69XfCXdpTWjudcDraYt6KyBhxui3ipyp2iezbp1Tu9YhdO+3MtqqeF2R0SOd1hvo0SyDnLrr05qYUr2rIFF7I5tV+/DmDZqpqI3esTKS0CrQoE5dqqHvDvLpBVb9Fn2PDUrJPkq00MW5c/HPzEcxYbY+q1Zxm+RrMZlHVv1vpgzhsNdTZq8xqqGAhrNC2nHWrTqiD2t46KWipuNq9p4gbMuTpLEVG28+qj0lXGpINp3F14FtHRo2cazmeJ6qkeDzTqkUdNF88TWViB4pGU0eScql4FVLHA3bk1dpZDF9X0qxFU7C4brJV1xavzMFv1jxd7tuJOec8I09oD9spur9Jx61trOQrtSBwIE4UVZHB08CBpS+F1TalW0s1a+uZrsdhWajCLw3MpSk/UN1WoMxEu61ShlksJ7Y5yZjWTu2VIQsvUa2SSJTMKQWwAeHStFhp32bGKWfwod2CrO1h4eKpM1lXfyz7cU2N7dTKGkRmgz1dGYWwB4Pk8OtEzohT3YWHBMd3JZONbZzoBdZsEw5mW3KsPBqnKOZ7pWiUDO7wZ+V/Lvnj3uayXlVufAbWZe0rVzKNLbmu1WzNNGiUhd9VADw3Vo24FZoaUTXSdh7DRTG8c7lKOW9LR5XR5K0a6Te1jNO4V6q5nb45yUzefdajj7PVnZwy+e9Yvu7MzqI0ftq++rtX06Z9T35kAeGOPuwVVbTENs5uqMurMMS7dYshasEu9V4rI2GkXmYzFMFwE9x3jd3vQ7QQqoJlu8WGhih5Ti7E60kTdDuV12vRB/DBL7PmltWX3X8VDu50hOSVdFq51WkHNrN7mMPGkMwV2bUXs6qk3xfbeuypV0NTlri+YmbwOqYWNq4ZEfXiQ5C7xTqeuthTqi6L01z5oYsOzgbtHV3azd4spPK+FUKUlDtr6XadS6aEgINBUu1fYyUu2+3hL3IIg4keuZjjxDMPZeb31wVuCtWKl4P7mHe0Of1s9ies/cWMaWLBQ02dq60K3hx0ZZtE+tZbQ3btK9179xwq3VN9QWo8LoI+A8Nu3CsV832Tpe3Q1vC9vEDipVTohycRHdWz19kh7lg2dDnZSvOWJ5tca7RlA6DKOLDVdvjW7k3EMj4Os1MmPtvhhNabrLjFY32s2pdWWjlV6qx5cyn2jcVgsnbGDKq732PmdCZvJNt7gQSvrXdrwwuWDHh28ToW5Jz22bHYLGdOL0yuPGK9WUem5hJwO6ylzvKljNdW7ii+XDJS3WWHJ9Sv4FS4o6u3mQ4wsN3dQKgX0H2CuzmswTsypWZlbLxB1lCu1uPRppV6tmIUdvuBnaNNJqXZ53q6aLobhmC9GORbnGj3DEroug63t7qusuzWTTnaYq3SsNUILO3vLbO7sYW3C1Tj5w3ljM7cxnFwRVKdBDNDU1ns3LtKpr1VtViEyqFbkzTyr17t5SpUxQiOVZzplu2717N3lW3vNpQstbSF5EK6Vi3nJfcuzkq6pThGjduJM7rrcPKZkkNGAirjrNZWwZbVdc657NIwXvbvb3Bo+easqGrws4kDOlXdXlLLtGi6lADwt5d1npbyBXLOTdyYkKO6jMpPBW5QvBid1UUg/B+3w/eeHfL5d+lT/SlwX+QFXXbrX6YMI5m1MxM6NWnYUmK8qhvtzSNOPRul3wiVWlwutInXMWZn7dpG4aXBUCzfbMDkTn3yqTEIsRVzb3FgyEiqVc9fqzhNpQHsu61Fy3QqdX8XgvfcogB4dhZypPp0uyCdwI3B871y4tDdHHWihsrNfapwV1l717m4K/j2fWszeHblbQqm7rC3hya5PUtVrMrSfnztVeOr69tlA5mOsrSXcvevKwiK4i31LHZq9Vodd13blw8jmjju3nUhaAmR5WZlrd1tXf6a+F3frM6Azak9yo31V9qxB48R+dxc8p+vrwVLzFFBVHBRt8RDnVuy+daCOq8ZQKOJiytKrjBN6qoaTRq+NezcorTr7Il3Ccfb6168yt1Gjxrr5Q7oq1o3BzJ1SrgBqqo5w0pRUlOao5oOvpZrqVZqye1Cx1ZzusIiTdbwvq3OnTlmvEa1dQ7Oe73aa7co5e9ejsO05xuoiiyktt4xvRm8FZzuwb6dHnz6n1DE8EuhRPZ1+PoYMIhDomLHYppekw/Ch2zM3tyq++WMc/j0t26Gxl9928Qzd4Dm1V6FegDwckumXLFxB0EN9RZSo1pvHgu77FtXYkOIVaxKaOe1JmlCXfp37+N+LWGUMe1vfl3zV/kFbrlUCjPJfZT8Bh2x9QujuJCudRIXndZtac2bLGHYMsToL7mDljWmL5WSXSFwTqlgojcip2bXocGodvXflFlPKgrVo3dGfLtPZeeVidM+CeZUr7svSVEKx5TNZUskzllZnEYKI5KwNQ8M5ZrvN+Y8zV0DWJsQYbajgSZdLgo613pmwKkSmaiwFmKuMjiMsmytmiueMp0RnhytuhLrxJSQCMdcSQaQbReMSPHJhzGr36697VWvyXa2mSkRBhFNIRgYzQlMGJgjBmYhANJokIYIj9LdFGyQYYmkbGUNMTIkkwkChiCiMmlMxJmMhDQLMSZikI0BjIFg0ZIZ96+mebz3X3yWavyvN6FIWNiSCizQpRJJiGjNKMYzSQiMCRlEsmSTKQklhLNKZLMJGaRQIIYMxL26SYxRkEkhKARIyoSJmhMyEknlhF8f2/SX6fox+qJ/J2v7c3bDOJQNXVo4K5aEdF93YRB1veSQjyNu5W9mbedtJYUX3C5tw9hd5nZiutuW67rew+twna2s5oxxSVsvcw5W1j/etvY9H201ipHsX2YqV5OWvO4Cqu65HbG41LMJjKoESvqn03M0nIaVuTLHXJuhVcNJnAvqGkV2Taa7kzM4J6z1rBfJlOewqTuu5lb223XRY87hebyPTZ7isXCnWuJCwioVd93N6XsWjrVwGqxgly3Bi44drTmZiJPMtK40jnO4NmY+DoGZRo13uvOVaLGU1t2nchaERM2qBPQ8y9AQT7Le2hUYmbgSXDJE9coM1ImKMGO5LQKoab2VogNh3Z13a6RxrgwWaM5JSqLEYjFiCxJ8fEgkgg6D9ofbtlCl8QR8TcxXmc0hSvjfHt9h8Ti1C2wQadCWqPnXUWtrKCFVsf5BVLexvVAupEGEpD4KVtBZlXT0jNwncwNbchIfyvQQQST4ggEgg+IBIJIBIBBB8QQfEnS6ypNlOTHuZdnVEr8Szxvkm1g29YXjqw6QzK3J3a5StWrbO9ejWKIs5iD1lmmSdaA94USYwxZRmYzITYyIn0R8OqxNOOuOXaaN3JuXi49SsquKeulON3VnjuZBdEg0hrSL0bSAHhdK9vYuDzOvhhd98qLv3a1t6cv7Bo3Vk+1T1P2W1T8bTXDOEN5b2Tebc6kcMxmrkoxUC6d5zrBjt5OskAeHGwMv2TKXClk6rvN1t5LwxdIcNnszKEauMpOiwp2HWCcoa6VLbZImVainUVxresSF8tdJ2O7Sc+f30xmt6UeUUrpRiJ8UsxL7t0bZBEBIxlfk3SKgYYs+Pj7efH20/YLs6s0V9VU3eLru2OFUQYabqUcfh3C9d9VCmPI1Vuj1yKTppOvMhgroEfbaieO8XrL6kKIImaHxlh0tu/W9fGOHaYxh1uq0q9dtEYsViIrEBEVBD4GwsB1k23mX1SSupZ7aBPijykmUHfHNSPvYCdLNdTNY7yuK2SxLBIryujfpGI6oimAPDaUZdvOFBVqZWnYvwifADw+qp9hkS4U/kxSZ0+A8GtlXX23IdvHsSjxntyTszNVjEEat3YNF4MGC8d2dsdT3TdvKpWE/sbCz77LOy2SK6roTW6ZCsplz2B0PqdAaapxx5lbluMX2nhsRODEkFcwKbW6jnOnO3NcLYuJ9rb3QuKtrbV3loZRt7SY3gn0O0WGzSFt7iqy+VXl0yaoc2TXGkHG87sYgrsGi75ZwVc+y6RGizFg2BH3az2TuN48l8y+cvEeOgnnud7bVezVwVk6KuzMQo6y83rUwYwrmsTdd3eVJVdYuMQ27OGBjH1rO1b1h71VURK2lTVFgtGiMdd32hF/Xazu9FFmynfw6AQ7o1ccoL2FSMXllVd55fF8O688vXbtNZIRBkmQGCDIImFE0mSyAUwmJEJLAYRKGR9+uMJIJNEqEBNGDlXBD83QQJsUmFSUCaRKYkIkWZmREYzRvw5IkkzDIzFBpmTSJE0CMwttGJMFJsyCQyakSWJBpGSUJBBDUQkwmmmozRARa0wpgpgybISBmzCZKMFEyZvS6WtMzMRFYKCox4xmSXCSQNbHV47zffG9ycqOolcuG5mfo6KxrQbjoKlKMnqmhDQjLlIab9QzEx5VEwQsw1gGJVLhSdlXgFPcBobW756Exe5Sfp5LdwLZaNIZUOXJjxrMAWY7KsW5kh22tpGbKwt4JtQ5tZJMJT02cTmq5d4cJYuUMVCbBuqVi32g7dpU3qolRDEx+EVivauKntsWNSbtXbrMsXWSww7o2N2s27Hh6q3bujZrr0VhV2ruJTw0vx9NXobealaJFl2jDFRGMeNlXpUtwQwmqdUZD41fsIQem7oM6x4AasIvCqy6sOtWb08GeJGVe6L7LoQ+x5EsFeoYx1Xd0dvRadC2t3d29wUfAe9/Gfe+IHvU9djt6ykN2xV03a+MpAEKVOmqTBlzNsis1hYg6hOqaDaebGcwl4qFlopA7UFa63PLxE21pFw2KBsMFFgpCthOi6djLwpyoq1LJN12nuKslw0JrqwtL0aLyanVmERMQumjVWxhjOXdoZsBFbRig0aTiuBjG71HEDY2MXeAuFhh4rYA8K16LMp4U6JlDK1pbWwQ+auk1ceoK8KBeI+A8JCBLWCxdam8m6APXaNKanLMSp40SSGbK5s21UwUog0KgPlI1pNVDWtWUJGEFXUToax1Vkp2WyCES6ayvAeAtiRq4U7N0UxRiRs2RZwhj0Fr2rNyDRqFUhqtZYxRw4bFMWxnpMRryqKv4ftfh7vYF6oUqtv4quq4uSIcfh+HeO5neewQQeAFQG0UJAOUI8dS73kNH+/y792/LorwIKzt/7fKrbEgVq+X9+Tela1rV2lKXg4M1ggAJZcjL2Y4c2jsOFN+7PDhXObnPR2eGyKHXvJAkABozCRl+jc2vrW8+a+/evxvd2blRzK9E1Xa2uYZyyEzVTG3UbPOwmqBo2ow2c6NhsijCLQefjtvkN2QkhD8GQ2Uu2jPBlGdyRiA0lnGmuG4XHZsYBK2VmTQFGlrxtAQrTdVe/iL5/Fq694zm25K8IUoalSAkjeyhDRIaSta0S5c0DMIy4xlxc2lchgduYMm24NADQck0MjxHZdGDdo42tBjQtjAIlCQOhNA0lmA3yMMXuDUw2Zw8a7a5LCIrSG1JcRQY4kGA4tIbIl2ehq5cj1aHQOuBrqGxSkIbiq9cyqRwR2ixI1qnPGR0GFTO1c6hcKtCu56xVTxiAm0RADbXfqXGDstCG5mlehz3KHlBU6oKA83hxwyKAnniKcXGeGRFAzEdIIm0VJAUJEFkZFCwE1y0VQxDMdDtTVMYe+UAHpnBDpHGOUvEwAQwhFhNmTeCSSxnQZRj0NC7mUhRESow2uqBMyQ2SBNhUGwekAU5QAPRAAsBHMUSRAMwVDU4UsAEqbC98eoyGhxoHa8qHOa6atcRwZrvy0jEgYmhDDa0YsxqVgQzmPRd56q2zmdEhSENkQqcNJiJlgUyIlhpeGQSxI7VplfJiHOTIWX9mWPCcABu3BxDthYTMOQImSeCE7GQAOxkANz20FADEVQzFQOuAgOIg54CU3HAjVVNohrFBORpVV3u43R6jfnAWDSEbrEyYvMckJavduuO2t1SYacpuHflmoSPXnAF+igLMnSFQniknqLTTeeHR8uoPJEEIMVIjzqoJQNoO3XQMYqbRNWtSDyFDvgLIAqnmgJYq2KrYj7YNgKSIi+iKAmrABxK1Gqta9q1qNY2rc2Nos2AgNgiEiqMiKlgASCLrmdu/AG8cU6jShCaiiBHSJRXaKBFtVFWxVYxW+mtbc2te82dtGgoO6ANVYIb4usQRJETCMBAxAEDBAQ3Cb17IOB39/DFm/Uba3imysE7COgsR075aMUKNyEEeeiuo0CVXoSUogJWq6CicWetJ+FO3ENxXe3dGl4zjpwBYkiCBIQWAHggQabOnDme/0PdDZ4viddOxhGz0SzF4KKHdHV/mK1qNVbGo2qotbVjboiAhYKrIgj2wBbEVxEECxVEsFdEO8E1F6+9DTsnnt122QeqJp8+uVYb2wIa1xnzM6dMpTBbJ+l2gzONyt1y8nhJJISqkV2TwJdHWSkt47z37UWpIt1RZQYzbBdqPU/tGO8pwq82jvXsyBjU6rFYu7sSHkMFqTbfPuRGg5sorKFtG6qXml4FZpHSDwuly3NLGWb17klzuWDuxZVu+6tWw0hMlwGZlydWN+wUrgbiyGquVRFOl6wcVU5Qrj++uuFRU2R8/pWq1WZCfY7qgW2JQUi7fs2yb6UO5ZqPUqRHd2vgZl4Ly31kaZNlkXQikeLHeSLI1JK2XWoQphYgkdxVtJ06JpTTDjHEqoyazxLKq+bkgsQVKDEolPswhlFfGKB1QBJANmKCWICpY7bMs0ylU2m1+lVtvJW1iRbFZEFsEWywKRQxEMRFBogawB3OxQXDAXdEZCDx79F2DfBXPZ9PX8gd39s/TJHX8Rj92f1dM4/Rtf0Z4Q/0/pv5deU1zYW2WIn9U5EfoiyY09iKZkuibPDflfOGZrkB/D8rkpOwocXLZzf2H9/1/Qez4+71fH3prJD1IKjX/IeJnTarfDGVjp+2vTj8e2eXtEU7e07qhVH8gpENWKQd7lFQtpIXaYtPHOZD/8D/sG78o+iIaqT4zd4nFHsjOLD1e3txz/49t8tlge5JqwNWSb00dIrK+LseHvc0vjWa3HMOXIdB8U6BiU+bg6SQhJff9InkskYlaZS46o9kUTtSe8cTj8TEQm3Dw9xipIaOppBPwL4GvwR716QrnuzrNKJSMpTf3aX1y6Mt/1ta72gzzYs5L1mbKoHOTkJKLRCZLo92oz6Paa1tvcutsOZK7VdzJz3piimonV84/rlxUvFq79PhRuudcsfTWJo/5prBaNGWlO3zlLkq3y914/fUflamnZtayOjvwdWopl83Crpze7E5GZT4HOX/Sj7v1qiUVKrZO/Y4O/oo9pQ/2fsxILIn8SL/XAxaMlgEitkn9pSgZmTNAHIGSgEiK0gpYKWG16Y21zUWsaeOtUa38dsWpTC2CyYYFsIsgS2QgWN3TWQsAtkIsA9xv4h8vepgZ0Z08efdrLnCjfk2j3TgYIypm0iZqmteJ6X98q6Mm02vpQP5uMnFhm279DPB9ZGyzoPRx3R8UR0qdJ98XiKveHoVcijz64/9IpxGplf4J/rBfaNvAtrdGUY/JBI6MpExI9u3S1VNqwS6lRCmG58XNVnbN4zbQTNnnbFryXYrfUKUKf+AbmWnJ9qmfbJU9nf7+dxNsNZGakIbI478K8axPttrOLr3ZtowTiEGSK0OPfgorup1/ouatYfKxeM4JW5g8oqlTbl+BOKiWyY1uaHxd1KeoepzBl/Eb9+ieS/uL4DwO7r3jOr7VjmEvzvp+PvD/b5+Xf+z1gFG7U5398uUIMybjQYxMmcmV8HBJuMcfg1WZVKk049f1vlr/nX6Px/0jPt253N/I62eAyP1fKTe1/kJ+H/qfg+v8n6H+T+//E49R+f0818ezzGDqQsyDXr7aPQcxwZDl/fJylYw6bnkwoUeBzZz0YZ6NCHHP6f9jget/4owftaC4ZKlUUdw9DhR2wgMjyUPvZ7gqqU47aa5J24wTPI4S01SJP/jH6P3j6Nw5D1kfF4PVgOYn2/V+MnXi2wIqv36eu67ZB+830ewEPRCgolz8x8Pb7+73P0ZKKSfoKt1ID5kl24P89lRvo3yZaB7NpZtT+FRujDFfE6Hb21KBUOqqTwBBImYBIT+yT8aBUdgGg+8cOGGlLuP8roHqb1E+F5slPhj3u/7gdfd8dS1TJuJ/vCni1790tawIdHze0IIQkwCW3huX81Cw//vca9vyBYdD75OG/RWRGJ3FHa9ok/Q8nS4UaUeIx7kxl2DJzn3/a33M3X7A1pY0P7szvDmKkTENwvpCuc+E/0+w+pmdok7d8gVaWlKc2UhZwKnW2bSZTy+ch4hmQD5kRRkESIwGEgb/Kg+fbXnd5ObPKQ/l6TynxPKGcQQe2nfXMwfBBuIP5+g+52Cw3eEhCGSYZHYCPhCZeCSY0kzH/ML1n9ff5Cu557pvnnuO2hWcHiFsOx/1odx20/wnr1mip3nn0nYW+TTqhqYYkH0/T8Q82Z24436t0XQOhw3a37ffDH48QHaoJAjiTzlVBO77LL4RVH5Nh+Lr7KOhDM7Lmh+GPB7DB8xgvyq3Dfkv1fyN//HMTCQJNYqEP5mITIUjGU736w2BNWMPn46217zGMLPT36ORhEz6bqWRCBL86AcdVTBUOuOAiGJKGj2KMiqfgHNfpDEYQEIVxrYff7AKi6CczdUqqqy01CO0A+JZfAZOZuPyfQF0jIsjk+4q9M/A5zEygUyulKQ0P33zidXCHl/qKlCeMZb/z6Tr2bufL+Gk4MO23r9eQ+rTSIWvS0auGfj8XeP8nGFzeK7IV+2VrvKiPxPqtnzR0j/Kf+HK+3tCpQnKMLHd2gm5JEYnQfnC32uoqv4ynbhCSSD5ns0cpbNr1LDlj+iYykx+07m7WasqqfCT/4nll9L5+Mu+pP9Xp8+9vT+fGaF5u7uIHoGiujgIIVf8Mspf1rBJsO4uW46kfIekLumI7f0eNBb8beB0j8sH6Fx02a5/70sKG/o/dwYPJMef/dA3HkMeXPJKAIEyg8fj6Ug+alt0U5s/rfzvuGxwcSde9k/8v8w8Bv5Fvq7dOyvF/YvugOXPsdQ4dqr1MFZlWR4E3Qzb6+1A7w/1I0I+ZpIHcQpAxSsYEYSWUiZP82hSYSAeETc4Lq7HzYzDDLWP8/5lLTrPxQdQNN0KFpXhuMXz+n7gaCWUDIHwqw/1gc6TCr7alPG7+nHrfLfX48+sJPgRtMRP0Wymn+7f0r+f9NckJsOxxTUl/2WKx+jKbM/su9nE3z5YS2U/1pvyZZlSpj8n03pVlZWVv2VxJQoiuqUKehWSaIQtl+NShigZghf0vsrt2OPVSjkv0RpSp/QiZqFE//tlXU/F7qt6RdeUvWjmsPNXOEXFR6HP45GVsVxJnMQ/LeIr3J9P00iclZOiV91J3d86E8LJ9pskINkVSTPR+lKqF+RWw86XkpJGz1kNIijqqq6ytaLWs+SN8Ju1YYqJJaZW6SRGPTk+iM6x4u41lYkgX9K7tPeCv3PxxlDvW+T4rsuaKL4KlXslxTsvi+FFXzTpl1ciAlzXFiFLkLx83/spi74pOkOkLhR6WWSutVjdbbiOfDcGdalKM1HR5lNHW/lL2IZB/kP82lXV+dM6fND/M1FpijaVaca9/WpQFF/U6v7bff86GzZcM7QRTHCPwK49HVzTO57xXPZBfEjXlXaLXXlzi733u4hrSQuHnJPutq1qjCJRXajolpTJCh3EkcYdoE8+knDhXtRImSyvTFDde62ouF6EzMakGSrV6ZKsO+UFVtDMHnmEq9Tv45KzeO27fFZkXQoU4mhf9Mivy1v8nW0b/pU5f2eBWRq0GmJ8BKf5RNXmzqk7w6rWNVCEY5eBMgqD5Q6uuN3Uut7va+zt+y9dTSxWzdZy9JWX93XWubzNc81+FylVcY4YmC+2lxe6sLvd9FefZQpSiIfrPvjrUrE5S1o/TONMemwtZ00Uib9yX9DgU8sVaixM0aNi+Q2kV9EZi3g+3kH9xulH7bHaKXTTYkMQYp9GKtNqhpdQVLrAwtk1KKPm4bRRw910bmjsq8ZLMv46JRb6m9mtGj6Gr4xZ3nyekOSn5d3KJUdYpm5RC6OzPyQ+lFWudT51vpm+WeUe+E1cL95Wrv1LL8tpTJFVISQnzaBRw1mpud+CgRgoh491zcgYRYqqZf1NXQvCucTdrXBxoHB09MIV1L9/A2359t8Uv4OvPGepOi6FRuebvE0IF7sGUohwy2lukSlW93jVYwxEdk4XMrz0YW6HNN4j0d0No4/XL5cMt6hSH2uOMhJMhUHdOwk5iimTt04neVy5vvBRYKI1sb3hQoo4ISRVq+A5xPV4Km+mZQ9iY9+T/athFdKRBdJJ8gepQhnXsWy3trX56dF9Nv4LYl0e/KIJR+Kzzdqo6qyISWTxAj+1+Cvw0isO26KnltTzoFkE5u7uZL+KMQV3tvJWj1Rdc7XrShwQ+KarFBPaMk3yWtHJdOKkaRIYT6P0TOi6LvPGW9KPpmnDFn+x3N0XQ1havpF0+Ms6Fj29zt9ZlMxGVUyVU35I65P9Crw1uYX1cMVn14uZJCX0v6dtoDJbdvvgyWVc+eWBE3Jok0a+NBfjQYRLZQeDCmKdSa3t6DmzA0ZxTxZLYWwnyZDx49e/xTPa3zVVKlJnn31mtPk/Yn/pp7VJNvlBdZu/bR0vovE1pOsU7emKq0jDssvp+nb29fBUtdy3F/dYrdFc2vRpO+hbtXbDHt+Ux4w901jxcrnMU9un92zmKzWsHIg348Sg1YqSqnThHbL+mDBzrmbUzzrgpQZ2lRDO3sgeDnGS+FOahPxs0w4ZdjpN2L+7+PUu2qKGsdpB83Z2i5Wi+jtbw8edcV/d/rimdMK3l3+Hhf7+fj44KdipjMpptWyoukYf6KWVr6+WX+HnQvJsGqb2CcO72u0Htf53iT8X+qUmZys9ny36D0lXJFTjs8MDuzCi5n/D/p9WEzBHnulDpGSQbukn+vHP7nkfYfsX93F8Jqw2fMwXnHlEVUN7H1V4JV8vy41AOh+OWgxAtNEqRgISXGg1utYoy2BlD3/dJA5IDHnTqRKqX/ESgYDIBbEZKXV+124ScSHoPpIMDIVE3BTW8bgE0TIafM/2huEfnyAuFxuZT9GTVQLfO4p0TFUBRkzVHasQk0wlWxZgKtD8bsJncajdXWh8ZwDyATtsEN+iSKSE5DvDs+QOJ94evmnDxNw8u3xObbaHgarFQVMc9QKSBsHOfvAx8lQMoshgs59A1IfSRDeHbjsDebxe7oFI6g8y44Jc2YI94KkjIufyH8M2uMrZhaNvoJPDQ7tRV4o1cuVVVRQNwpqbY2tFE2X49DuJD7NNHoDXrH63v41h4DHQ69twYDp54moHIoT2UbtDyDuSHqAfRwydann7KTUkOLCtZg1HuF8Rq58S6gnaQ9hSF3kF6B0To5bhdgqoojHQ3+ibgYAtgyFBQfx3klTfN9E5wvbkqinJC9NITkVLB+rOYEnjyMYUsJEK9TwSm8Mr2RQ0Vcj4ZnnAg9APaWA6eAajQGoZZGTHgn3BqgIiFwSciUHibjuDJNTNSQ696etsPAKED5CAIGDNmTG4wguNkNwjZs9KjFArM1GUdgQHEZN47O3UOIYwNTnkwZNvLVqyQ+uxPI49hMU0ko/9CiUf49273O/zWtGZc+VGTJaxenEtvXLdM6QyCb4PkatwuZIUHvCj4yJwgSJ5Tq/abk9BEfL5pNo2zIc/Y62NrZoWMGKwUaNIwFET4AesDY8vMMkDAHQIaGqyZMmYk5IqxAeh58Tii2oitu8KGpvIGhEeq3fRqBGSaUpAgbjpYWhA9iBibY7GY+oKnqVDZRRk9X0T75p62I7LYHxjJDJDzUSGn7fVjO7/zuz/dxh2dHSF9qdKj1SQdD0FmTBR5nbUqTZxJeDuu2QMne+Zd+WMROeNU+HqALS2Q8u8T9UhBY1aTWNVXbT7+9/SuvmlptJSmDgfmz8P+L9x0datOui4A5ofWh97IDj8Hu/Xj0wPvdz9A9YUKFvZcGCBCxArIyDIMWSIIwFBZBOc03HyoPBVCD0B6pbWvtV9mpZEZGqYctuoIn7usMaSeIcEUK/GYBiCJhlLlIoauVKma7rjK79z/v+NfG/gWCURn0DUshIn8Co8Mc7SkCF2bSQQ55VDEB78pyBP6jrTdqbSUmosEx75tL/yD64MVNtwjZCfrXTovEB8CUCFmmLwqqIrIzUByYeXBrA5T7jn8kubOIL2cYXwcz5fF6TGSeEDEdmGS7n0tuLzcUpyKVnNsNWrqYPUedOpIKuUM9wgn8YuA70neRi+4ZcESM74agHRH9ghgSQKRYKotRkzK1uurq7V8/NV+ndIxSDIzcVp8ToSuM5IOqc0wnaIdNU8BICMNwkD+Ag9v5KuL4oT5ZqH/UyG23oIPAEnGLMHuLhZEQLCcyM6ZsHTM/TYbxQm/zGbphNIB/ocIdGZgfUSDgudc+iBkz6HxOsQ9q9qmYEnbIQUhaah3KfAds+Kwo4EPerAyyIk04WHYdOT9wiCdZ3BuP0qgIHiysyGjFWMHrE0CC+3r/gU2/imvvrDV8wQOsB/0CCPYMUi+sjYBYgQuNX0xOS9hZUsZHugOqbkOvjGRXibHux6M8EihhIiVYBiDAjrHMwHADRV/Jl8d0OxtpJGJGJ6kTDhtllCI0pEguqqel/VCiB94c7D1nsWDEBRjCCkBgJCCAb/Nfurs5kOmIpIpIye1hY4D4fz54BMwaB5UL3RpCRE9Ic8B2IWC2KSK9tPe0Jq10nmlWAZBeh4H10XiSZ/BqNQ+z22+NKMLBNgRBgvVgywQPDL0YHAymCKNBRsMoGC3WQfbMqDqsF5NOuzGbOZXDCqZ9kr7qEgIRSanL/YyFhtuhv4cVuDMJdMoZvTC6u0lKgmYhtxuKjadIVsWFbVVXyJShuuKhsQ3HuqsA+YDgAbeH+30FIl/OGXzwefkHUQAkS0DBzeifSEXoIfTAcifHCk/AqwOuEMFh4cvf7lPKenX0ZtxNef+U9js/rAvmB/KLLGRFsl5zN6sE0CkDCZio+cn6Bv4hMzU/m/9Y/y0/i/e39FGwf8GygkZUqbfy3ufAuNYaZKL5bsXDt0B27E3hIkUfpPf2wl+/FAsHgNBkkvBf01qf4Gao5p5S/iSIfpRsfwD6ye6McjUoQaCiT/hYVuef1flszFEE9IDkH3h8YUBDwh/YBN8AdSOiDF6GD85g7yH5KX/reGOQbAHd9/OB2E1DiwVg8qCUoKggpOiNWykSMSJA2IGPvOGcz7yde/Lu9BPaQNl0DX6+7HzfYGq+6PWonvn3TwN0CchJ37kTbA1V1QwWZeAkJvhl7TMRjrlEUkre4Uabjn8Kz72zKXrZrt0Jq503h/aIbHT0f2AE+iQWH2CNH58AhQgP35IMglBBXtN/4+A049pXRdhgwGvb+tncNPb+ZLuUoH+lSkW6UlGTVC99q8VvGqfvbU6kqb7/dRDkWYjMQqUSasMDYsDSkZFgPfJ5dBuNWbhRUKqpc1FGDObmm71+dfnQNPz3Vqbf1fMgeXGHj8Odh4TRC0mgMWBikKUEtlVDosDBipDBJZJY3DfY7w9oEmmYaCIixVCGNYbykqE4+7vPbC4w5HBOE8ZGTRPIgZVUIJ8mB+/EMHz6A/HvmDr3885+ieQdeZeRDeorBGdF2A3TGEKtRowgQVJkRjjA/whw+TqQP4xMBy6en6QezoNKLIQ6rmvuJVD4Q+E9l6jMgKRJ+VKGY++gt5jvSEcH2Bg7t332egZCptlGOaZMK5LLzMQMjAsZ+MSFQtebpBwpxffuokTSrTfihE9j+J0GeJkdBPtNgSkB1H5ZgIQGLE0sp3emmSJk1FTz2I/ygZXAaUA7w/7BkPmyf/fx3YWHQlQ5hbTeYXgcYAlr74ZYAX6/faUoWOX8NuldzVyUa0qSYlOtCBEHwhKICWSWfAMUGA+IXcIwAswcfkZjm8NV/JrYkb3I/KmhSjVuHeiZEq0FoIFiENkdfhOB7aNBlDZFB3RGIKcQiK4WQ3HFSBtKi4UMImmTMszxbrAlwFSpHSMrExiFvIFom3Q2hg0FsabQpTqsUARSKuMqWyRpidYtKYtYrpB3aIVIRjoaWYvq2sy5SFUyWmmtRlUqQltyNKrb8G9hpNF0sBwgIHAiEZcvFvVNVby01psMHFd22JYdWSIf+lqp4lNU7CE4Qdx8RiCF3OsHVYiwEVaB1RnzfQvHk/iNlghfm/Yfk/bR+dVE/IVcf36GL2YB+lkmBpkDKjpsJtGEZIRTYOPZe6caMokpUO7Be62dZsmxkhVJl8K5TYgaDHdPR3WQ3a/KGANwJkOAm4N8E0GDmJhKFHDR6j74VMSe3jN/ps+DPn0Xc02Q9zc2ElRgYabrynShTIh+AcCg/Lwcnt0M3j8NKEoPTnIJz5qMBUgzPfU+O4Sy0R1s7CM3BjewPQD4qUWlHBMSUoQkwwfG5zlMQKrYYCBCLYGBjgCUA9lExHAEBzAogWCFBRRe3MMEPY1xQqMPk6QNd/oCw0K9EID+WoSqdbRK7mYVpq8VajZbcGSEZDFJZbIS1sJaAS18ch+aP3divkJ2p6+bezmE6rBKDMD59B6wpEKgVGMLKxgxGmoYA9qLlNHvDupyOXoP7TJ3z0yurvr97q2zngDxZLZ7OFc95uYTOfaHHE0KqlSnwZg3pxooL0SFHmFfmk5HYdj3F2aUUzDzmaBl3KfAfmhTaB9BAfVxbPXEsfSAGQvsiFXk9Sns1QOR9oQM6f4P+/vOCcfZ44PQJgPYFUKCggWMU8+EqQuePlZvEPOQkGe0ZO52N5NbLPITuqUPWWywWyilaUDzaTWewwmCflIeWibyob8hFQyhJDNkEmQjIsVYrr2ru+jh6npMUmsfjnR4/sVrpVqmfi34M9byUGxat9iSOQtB+4Nkd2IRQjrY2q1iD9VbF6v0m76PRmzHpqk2t7rZ5nneTRtSIt0bREeOOiKzjIhcYMR3TwY1fO2Kq7J7kaxOjAWcX2FZk4InL4GakqixcuQXsZBUWNlsQOJrGdfhjGhokSrFR30rd7aP3JQ/BuI8o7XfYw8Hlnv21Ph60cPUDf6PZ1R37Do33ydrrPYMhBmnRv28BaK4aWJo6CzkxidaVRFeVVPpiFtFo8or+nmjnweb7vCwj0TFWvBk9vOoviHvw3ITrV5Pb3OMWwMYjvgza9e5NmcF0vJYbWKxJJB4bTu8yWyKmKFDXRWrbMwNdNQ4UmGlor0IZs2z4cr+JfBtCTAcFriQq86N6NGG2as8HxZ5rfjuwOB6yrsTWjzdBWi+zvZh2jcFvcPF08O0MumJu3rR37Uy9Vl1qGYPyIL9x0zZtIAwmZuKGsxezaQQZNM6lFD7laSVoZKC14sX4VzkoIRExVo1LWpwHNaZrKJuZ4MiMhUye7CaO2dGD3WemPgad0cirTGIpg86WCRVxVcLEHGMcKYK3UFGoCZo1Yw2fMrb2bYIquERWd6RWs04sHHlQxTgsbuM92B80JQsm3y+imRixmoRmnyerQNgiriCTWdKjiYUpmGIaEqxUQRZC0K7Fa7gmx+e7d8hy2c05q8tqXqHL0dH6W2lDVcclaAXd0OtHiEN6a2MsNmQ2ZhouSo3uzre6QStmg2Ij+N7Wlz1551eVuGpiQCVLuyr7eCyI0tZa61mla+vPPXJvFN9chDpw5ZnchZ8kelQTQJ9d+0p/ue3w9da76vj2qIVIyJIVtqmhZVpE+psg/CFG0f1s2Dq/f9/4oz9MVPB+k8M/S+93AuBWvZS2lohBX8peX863L6SJCmWMno2Sqgw5ru9kUYcTJ+EDQaSoVtFN5ycHoFxPWhkHiUhFyMlGJ7vPAZeoCs1WCNdwuOxg5x6SxNifhSK0Sag7YtEMFQhabzrbgk/7IL40q/t6phxG/j9M6Ubjq/qz05voXdqBa4dhxTGWjOSCFFiVXCHiXI3g4baVi7xcYq1izDjUZp6GZkNcFQay4VsIIEkUjuvILMVYDqg5Zo70aCHwNg3BfdJ+jnMCxbk/QLiCJIxKZQwtfWLkDTKhxIqTFT6ohSDGEEiAh3UTXJ08K27+e6YZhTaNvY2ItWNDK28sVnjyggQ2BYh2FGeKKaJSUcd4EK8uJol7zQrUztIOpH+Yv5jg4h4fMEn5BDQg8GN2M4eYfSq3x/ZId+uk2/OoRgiegsTnqjDu3YmjtHOMDleBqt1tcvAFXT3VI2ARAakhkHML3xUIEaauUFDPoisEy2M5pYTULShOhPTxxAoKebY1SOCm2U5qM6hBHxvLr4n+NfaYl/H+8O3EghcPKlWxV+K4kezVzqdEBPqWPuPvoesnjfDvvdT7DOorbST/dk3wxssI0oEia1CUQpBhCRNRyCcA7XVMDQ4DoBsmoQkCDEpxdh0F4ujQIMBISAHQKEe0gbx4LvTcHBUwbgHUCBoDqOgbjKpQyOAMBqFwFEx2tSnEo6huIQKu4IbxBkmBDdwC+nEhjKgebIDdKSWqCIxR0gB/Xw6qVejt/CVdADUdINOQug7n+4I6H1EDyQ9dDzHU81A2HcTvFP1RDHgpCYlpIpl83lfH9u/QvW7O8I5RgRjEkckUI5QOXUXFObE3W8CnQlFh9oJUq/r/tPhs+8aL7t8dmoWD0WfVgy/pp84bBS8+kh65tVgqdWWIgq8CohzqCyVZEDui4yCaSEIJWXE21Vqg/dd2l5tIM4y1EeJiWhZpwbkGHCxmR5B5FDMHOeeNwcApg94w8HfxOWtOuR7fGCg2bHJD+pkAMHggOOT0Gw2Q2hGSEmY3bkOJqnbwMGI7yCfVn9mFTyO85Bt0g0AVdPpN34uFes7zpLz9w8jQfVkyKf3hB4oQ3if+cRkF+p4i8wOZ/V9me19QdUTnOj6FkedkYUi1AVBAmeknidZ4mmmsNJrCaopIRYGex2qb3w3ZwQziQCuBC14xoGMla+3q9Ndp5Oua6k1SZmrpXYlxQkBSSVqA7j7J+/gahDZFP2XD9LTXVRcKNcBHh/V8QAWjbMwe5mRcRxOnZofpY4k80Z9K6wSQyyfcYUYVpp2Sq8ginAaOgxg+AVHod72D30eggSYJQw/QMMQ2ezJgUz7jj+Vnhsu+GhEhPNBYCMkAFCA5jkAzUGsN8AqDWEx537xe3Y9vyp4VByzdBFn2T7cLcHBGlcMd38d1Fpls3f2CXWXLsLwYzZUFVNpdh9uoUlWZGEIeAcPy9EEppNMoHMXVALOsyCqMc6gxcvVoDIsF3VVYjOM1t732RbUug8nYQQaBV5ADyT1J1NQgru2LHQQmo7iC7gNWpwX92BJvOe8TKas3EVN08K19pWw6NidmCmjSDBMwbcB3QT0fbti6r68EtAkKyVkjC2qHm3O+nF7OR3GRs1NZG4E6I/4iGGOKTDM3Rlk0M0pn59vfVTp2z7F9u96WsYxSUTFaFYqOOK4ixXIgNEVE2C0QfrZjL3ENId7HJ0/r6GLyvb1ur6IqLpaVNJJV2RBuJGVqw2yorlYcrK0j3wZ5hnHpiUjDxkDYLDtRs2Vuit3KTTt8m7Jt04MrNJJMGI7V1UrgwAhIIlNpfeudZgc6e9CAQJk1ycDSQsSBwZA0TZJSREWACURAK5YJ2vJ7k5n72FsoQKxJYXaEFkAkMsS4AasVkiBBMUcJBdovufFrggRNUBNOtcC4ctGwyh76yEWEUgqgyQRkgfdpvlETiIxorHx/2WGQ+gQo0M0WDIJBGdcaWbDKAcIBnGIiEsSHUX1khZ7QZYBjuzpmd0zCfgIsQBCLDoJExlJ7q8rn93hMHSJ1pIknYgQFIRjpDM/OWB9vUeDD+AhQnkz+AJFJhOcuV8+3x+fPx0BDKGYT/BnaExD0CfWm0QXDMNQTnA3G+1j8P+f9T1YstGb7zNtfvKOk1DmSBKUGkpCUpGnfWFKNhfYh2wkEPiACLqZWoe4rx/5tUZBQ+g+Dzx4bY+T7h9AH3PV6PR4Zvpp8+tXbmik3oVhSgul0ZMTt3Xc6c/R55Xi7SuVnWtx6dV+3eO9Nt6a0JpLnStribbm5Zdbtil3bchTW0syQli47udq6v/h45GupQxKSmKDCyqJbSWMKSowoPdnxM3a3Iis/O3Z/Iuvz00VO0PSb5WcHLfRU5kgbJSEFumWqvNiBhIapJ1IBb3DADEFFkRXSKhCILyNjcuBB0gLx78/4ddx7dT7V/SrH9Uf1/uz+y0Iug0A/RBxizp1LbsljbXirrFX/F1u0tOIJUgJrBCkCGm2eoB7/1fxOJ3ulPNfUYWAV9E/sh6z1gNipD7j/RWMQ+WRDr4pfsA7e/nY/WTNAHAgfJBFZnWwLIfmZLQPeB+sORU/hvPhjb2fS83w+iVhxRsQCk7Un5kCE0IkgdVRD6/c+WmIkSX1csnFhSnTyzfxsxdj0rHovHgkeSyrU1lqxiKPIgsxhCwYIbIey9GyvMLkhZoIkRjODR57jPBMyaMhQlpQkZuOnqxNQO/tL4f7RqMVYwQEi4HcJvKDULydPN2ZyIPHThCz/Ngc7MJk76lCtJ/Nh9X+rJfVbS/beln7/43vpnFTuTi4jSn+P2kVqikGjkCKrbIsxXBM4Lwj3Pf2E8y5OuB6jUrDiN7SB9MA9e7aOf6X46NMN0UDI62gjYzHG4ppRz3OxNCNJ7F1pWrsKrg4qlR2uJcwcwO/4HxZtA+k7QPe8+xs+mt8ZDTxpT9T+44fMZPpPx9kDcoJmiukulM4op1kQKGDBgHEAGwRqxgRiipRUnUMJ9QhsbSx3BiBetBgN1AgMTCkAWHDBS1GMljKZVNh1aeXK4z1Kh4MzCaAwRgxkkEQiUSugOI9kf3Y7ZKS/EqB9DBkZAbASzdqAq2IwYFvbcEIYlCwiNaRO3FHMXPs6tjBsh2u8OHVeLgT5O4XcnlysqXQNh4454VKk8/Vzy5kI9Yr7e2rT2Cs7WFdjRdAyCqRUg3DO5KKPYaGd50CBAgjIpEQZioE5o2eG5Dm7rlo7N3JSfVEji0oYL95lxFSQtrCFjWKFCCyTsCBLWSKKQPHWzFhXvJcMIxWKVgj17MELlVlDPUCSqKLOxB9yV0idtNHNz6rKQbGT2tkRCIelFCj+3mh+xqkoS1+0iyC4k0QeQ4MkAhzElEq3LWKmXLG1djuqBq65MZmoyVUVLut01ZNubpFAWgRCT1gySUMIB58eG3RxCFc6dH+W6KAiALPqNTBDJDUicJPth0FAw/Sv1TXeV9ySaZrdPj0TrruU153Rr2qWIauIa7H3T3l0yBv3z/hOyB1Joaqbxwe32vdYbQev1e766cTsJpK/VprZOM4xREiNJGpEVMyRLJZLQikb38zS6QSIjnMN8wKPT+sDUBJEZGMi5ogmR3BFZEIQ0ge695r6ujw+2aN8+rcpPQ/9PbFKD1sac5DV2NuZyah5/6O6GP7WNTJiTFuJvrk9pchD5Ayft+Pz8wLHAYZfvCn7Y6Y6KSCsO38F+k1ug6lkHQfq+LzGgNX+kDOmx3EJkNgmqCCoQv1nb4fd3eeoVeszlgBYWKVyTxIGD18eh2JE28IeHdEPunM/al2Acw/WaOljp87yepMHs+j6IiXEKj/MS8vCdpS/oEIRVg1TG9/ijzIsEkNtpW5vizSv1CpuRskmWP73X4RryCeZ4fG+N3qg5SvDQNTcmn1m5grSY23zmpiElj8JxpL6nWtYB2rUtpCjoaEmmhKqSYtN4vEaYTLIKtaY4Yc1lrQ00MQ0H1ySHrCdYD49gQoUe4D2i4A8/0f2amo/UvrQ6ni/Jo8Q4HMH8QbEBeOQ/DNhSQH98VbBQPgiGCAAmqQ4hFE7Pe4RUk/Yv9ZvDdpEkCdVV8PlPWHdqID78Hn5/walA1mX6j5UygfmMGhoZ9aPKMG8wcbkIMwdfdxq06GMYNsGqZiIvv2DDSuDxxBGy/1pA2Zu9pJ9cwcdmjBIfeVOpkgoQUh82BlJApFBQgfoSQ9MGZYnxp+wtkgsC9yp8MBQ2w1QqBEgfb7ie8957z3wxxEDxDxTfxjIHSVx3SFdjDIlH6pp8Mnlemniwo+s7FOcQeIliPGAGFR5B9Jtx4X44PynavP3eMNDIJf5bp5FpaHdxtXeC9zoL56VIV8nwYoHm/iqebGHjBFmghxTqs1UWav9xnd5MtcyNvC8HHGb8pSgIEN+uU2xrenRAwIVoQpiE5GQwLA0upFt17/HvF8D+Sd46AxngDD5NMC2HGQQ1ieYcuIkQYIJZBVDoxsFSR3lq20ALafUXGjmMf7y0TMEgcEpUzkfFgtJIPYHmU0nZF3VzxpsRYzywXoEOhiwAUIglDSRNozJkAbbFsSRUbZLWv3XbTZJSrKGliePI/CEBf2j/3INH0PswO4x6UhoqF8EQ6QA+6cSAczxyKHpFDmHXov8oKHhGWpK0SKlaRbaYy0qNplkJswTQTNf2779/Er+Xfegw9wfWr7SBCVekCmynIDU/9MU9YlXp85A+FgSLSSc+9DdskKm7s2F3nLJVtKCIz1WVpkag7wLIIxncmDGNkL4GLqbCUKGhBMeLGFgpU2qHCD/v2X3IVDzvpPu/LoeA/nltJucY6uQoeQoHzEQ+YiduY9O17jtTKdYCneJ73mOh8B0wp1BxBbMwgveAgbB4iYGjPRgoC9p9iyqJsnHAP1fb3cXPBJj9o59QgEhN3gBkVcbwB25m9eG0uKDYsISpSCkijhsZlKzGM3VNIkZC5PdQ4UVvjC5JAwbvboHJFkJuChNFTEQE1Mn2HRIUPh5NiEkjGBPeHZ2jQD2n4tyDiv8Vb8f2vdsUZNvvg5h+Y9oSMNJgbhycJaWVxCAR/ezE+MMUKdevf3N8alcI+eGx6GXZtf0efC71W2Q2OjwMuqasEkIX7DKZ2yjDxHFaIs32bZVNyUWkxGFssRDbFBVtFQQJCB/fHRBaT8OsRccJHZZvHVDHSpkB0x747Ok3IV+pt6YwtU9OvQoH/EL2wCLI39j5TVTN/oZjSoWPs0IcdZmsmC9cTz63UItauIiOMMxEAmQ+DIeswq/QyFVggUpFutQuVLixNKCzHfY/jWwoc73wBUZvYOfFAgQNv1zLINmD3kEJNiTT8Gcp26v8u+SCJEGIIIqiwSJEkBBCd/ea/7v3faGfj6/16//KHq0zjE65zBDoLnWdkuEMhZ0HpmZ17QO9BdkFAyYhiQ7vQ367aNAxWA8bKukiNUNCihVFLSjETgwyXRoJRmUAKBWtB+IsDZEhiqCGqSCNlDMaCDiqIoA0XzLXXd4rw9XJ3dMkSzrtYuF2axTu0XOK+F0gVE8fO8pZ5mveRTdr15sLpOqWxlW2FhaTdtriaywimIMJqARSiRFEEWIwmkkMhVnh/lAwMToORObvN1OEofD8Wuoh+//dvfciv3J7YriHqCPURgd6TtgpCIdYRYhada+YeboBGSd5oYAFXzH4DPfQK0CnbsdXluQ5A9566T3ij+BX2mDAjQMKQQH8fszoGk54sm475NmbqOy69Z7/8Mh54GpPhtkO1B8PD3SLzwlgzIltyDGIpBQ8WljMOGVVWMh88ViOYviyzZDJgMZWI7EAhDiRyMXmZGOLfxwRA4jtafJASMgRAR3EhLVO60AWfLHZYYM7prPieZ6jUPHjRGKOqtSZuHYHhXQaHsTed87O8PUBlB1wIV+93Bc6iZkId5QO/3vD6Z2ciTk8N5khgWyOaIQjxs8shjBc6cRIEBIAsVCKHpOUUdIg1g5YmThthBcKDdkWqhsr2LjfkO/e+E5dYlYlUPL4lFvtM0FiVBMqXL1KlYb2vWEhOh2fb2ING9mxrDG3pcB+PTnC6ZkEF7S2g+AJe+qRwe7UKhg3mxoXsCURMjATdUJOkWPgw918OYbTju4RlpwUUFVN30zWZDjPXJvqvnIfzlAyZuGmIK0aL3ow4gmf3Cg5npfb610udaYmQ+2SynRMQZPTCw4LhxyeSZXME1o/B9B3GD0Hns9+o5SHYnnh1CIwEYdvkHPlEF50KRVEqqpG6XLuohptJdKKLqty1c1o2Smti5O5MK52lqZFr7Jw5S1G+BJmeg7U9ZDUGPb2SNASLtBQIBFNXCYU4GDnRsDe8jjSY0MKZ4TnEM252kO1Hq1hMhundRqIRvUfTuGDYI6tj1xvZmJxDDL5vMKfXBOIjwHVXfsUGQ5HAgJUsk3qcCG6I9jueJU3TFZ+oR3N0cD3MQqB4wMQfE7CA9rsEbqAUShuiqf5JgYCGK2CrQMwQDbdSjSjCficNvkjb51zU067hZYW1c/Lbch2LGHe6KnUMsN1VwY6kN0DMGRejU9HsHPsOvbvv8RBQWJ3nNEQx04V1liwgFR5SPocenypjelyEkClA4JH2OCcVqrVCoVPAuYJ2ErKAzD8cK0Cwq9WhhrH9VaHgNpFo0qaLbNqoOM3rG5pmGfxiFGRrEskXLKmDFH1MlrjGMBUkM2eFqYYSFAkburqrWZVXiwXFMsgplSpiTBgoQTcVoWYkpg7zvFdbrrS8bybwvFcEE1lWpLVWhJajkjqCuHgUoVLRepEzVmjWVESlFgtDYI1aNVdBcyRJExCwVGLd3lghC+FVCDtsQ7dRIjdFJXboIVcLPUXZJdaXaapUMEFChgWMAtg3UogklpQgl3hl4i5KoUuZLCAqQ0kD9Jlkdrs+NfILu2brH8ee6mUvSK5x2IgqxFTz7IUIirpVTNMpoCGthhxITOaiyHNSZp8h0iSpxN8PgLQknmmDiO4jJwiFFcKnGJD45AIG5LYYaoN+a2uaMmvFvltW8nprW3l7y7vjNDZJFDKD1jsuoGVzkwuAg4KB0MDsGKjPjhYqXgbSCMIiF69Hlc/lJXpT2m8NWRjIsFBGFmZ2iSogtOxRVUfz1NcmdIFdrAiqMV88FE6Idp4Z6+yIxXUx8Vnb8sCTTlE4KluAz4CmBH1Gg436qG0i5iUiBrGsCnAqpgzQH16UA0ZoaDlIpCFjCEyjRhmhBMDKFHMMAXYViZCIGDTBWmGupdePJt1S8ambaTJMSjRUbRpMbGmltZaUWDYqmCCtLV5g0QIUAdDm6IeBKvn3ZtL8hfSzaVbeNWwatb5RN9QYR0dNfd7rPw05H/Q4A+7toEZuQHoHgyIiCcf09IcL4DJKlCAgMA5kJL6PXADGmByn9wdvp6exDUNGJH2L18CRVk64kYMkYVxO3rhTEPor6uR6vZgwNiepLL4yXQoJIHgMEYEgpEZ6GmQ9SfX26ThqFmZ+RZkmQs2VoTACUi20j8KbcQLOfjCj2g+R6CB5J6wjYUp44IUoeBUsiWBGAlxR1LjU0NHCWkqpSIt+eDNFDAYIjFjHMLAIgCS00tLWjayWjUlqMWHjJbq8nUs0pObd1aW7dq7FSVQFxngYMBZUNcXaMFjGmmCxRiogIIkZDMoN++dHS0RfRVTtHaBnosDsZu4ESHIeM9lwsPca0/I7MQnsYGPXUVDbNocdBX6BUhE4v5UxVreTP64tEsTPUf564JvFBEU0oNUFCYiZcT6C6s5eZpZfTTaTpR5vFAEi9DoidSaDWZNqgcDVgA/WQYsFn4hoc2HUecebaORDyx8M90nqnzHI+RggPvmPqUwyMVaCAy4t4oEkyDhuzBpDId8sJmENAP0Q7xgoAMNT7vFh4tbaZYKGZOdrKk1KXva++FQ8A3g7AL3xQ8BORyE0nj0Q5dSC/0H9Igew/G5DodrvIwSHMoCNYB2owUFREjEGJCWf1+qDMnYZh06zSRDM74WZ0XgqGDtdMDlKaSDEJ+CG8NDKofbFkVD2g5CASDygpRkspSahBjKRMQAtCilKFtGhYxISCgwtFk3DIQx1lQhQIiQhlgdouieRtgdVCB4wwEVd4J3QX3lDccKJAl3tUTEQAxaplTkGEPvxNwG+QQwGGCuyLczKCUzAhA1WOJRvyLy7gOvMYM2NSbyyzr4hBzVFMFAEIMPT0AcCDtFhipq7Z2ceZA3OquoaccFkqa+OCzAjBMRAX+SQvFS2XQVTJMMD2MOSa9+urJSbNPJqLmp3a9qxLwoCulFJIgjvQKFDsoMzE/RyGMwZiQyHPg3hoJtWeHQiBtSmtw3g8xE/zIZLKTI8EtCrCyBgDBQnUFPh9EkNQ1ANgi0JsOfZ3JvhIhIom4AfMRRXzEAUKBBQpAQy8oJDte346RKf+X7frf88H0pqw9H6m0tBlMlRRUwwhRMRkCSwDy9S+w6QC0KBaiH6enh6aBUiaB590RD2sRPhhCIuIoeJ++quYKZEMl95PL7xCLB4C7EJpJAqEItcqzhdfon7WvPm//7+nJkk0k2DIwIpXp1DIPuQKRNQ9ntSRgQHhTcrv4GhgQMBPofaoBwBPkXbke4fs+/gJBTMJD0ta0h6j4zP+EziEliM/I1LFWWFfslSF+B8/qsCk+G8qn9/SAejmVPcwyYk+1gpAos8TyPMoKqq1LPyXShTQS0Ji0UMKZqV17YT6TaxYptCGg7jP1/B4fYajC0LKnnAi/vZU0lbYcomM6WVihst2IZFQynPwJQTBuNSJobyCkLIbwNysHQyFycANzuhMjE1B83mybhm4Q0bU9jQ8fUQD0J3Ed4QKBBDHUfWBnrOjdvjr9IoDEQwdJ5EEh+IssQmOMK9yfD8oV+XE71Orasn5+BXuVG8+H0vIZ1p6KiVgwwyEgjIBVtsmxoeNls7TfddmLs5koN8B5oecU7hfORCPe+L5g7UH+gUwGp6QW+iEgjO1XfCKcKJmFs06yaw469Kfk/DqueCZWIP72c5o+c7qQhN36BxN0cOhXtbu3Iux4xBwSbnNLOQ/w53W5lmoJwOc7TnncXIoZBC4CQ9DpAmZCc5N2p/NFyG2s6sTBC5qKorbGo1lNtNlo2pStjWMo1rUhMVLM2w1FiTBGC/HQych696dVnkdeG660/jZZdI05iH/l6nv7KC0k7qUwQqOCdjqQ8xQ7Ujz6OEiMS6SE2pLDOHtE0tXy/hJDj09tYqKJMXFF/V/g1bo0ktf+FWqLeC7U2aVjrjv8dVPQkixios80yS+VOTAQMs+KIMoatt0WkiIarwjwjwuIVeObltLdOlt2IH+KvENH70mI4sQ1iK5g7RnB91y4Ytohi8l5tKFg1gEFhB6EWK0Rp5E/wPPPb29tnwkMQwEPQEywzLgDBKjJEEZQyIMUxAmJ8d3BGCXNvrEuolJWQkCYVyKGeSFGE3lAhFrBJqGPMietwwkyH2dGfYBkKYZ+RP+mj65jD4upBIkUij9ifTPCjDvSnwdco2WfvCippnPEkMtH9RUFkXe8lXpRUJ4ro0UEfJktLx70RJU6HyJ/XEEUAe+Tz+kuBkm3R1XIdK3zWKLDiMenpLrie8vEd2LIpOBJgO89XnhDoupLt+cuvpzKoqqGfa4Xo1luSJoURsMw1YUIqKCehoxUGpgsQaEou7IsEJAKJipipivF4d5gI2XvMoDBANrKl5nebtRtlrd2xrmNLroxBEgrLqWIWlCVbbJZebu4nOYBLruLqZCe9gMmWLSoZMKmcNMwammCarZAIpjqnBk0X2J/O2I33vizbqQnZd62EFlw1UWsl1pFBqhFUMRpBlJZZiXBRQVg2UucBkzDKrmg6QQLG6wEZQT615KmV4bLG9KDTEg4sxZQ0ePy13zKIZQQTbiFE2BDEZLPqE/aCQ/QMRhqH0QD9wgQN+wAefGePO51SU8D7Jp9XTDGoGjcm6hCA0CjHgNSGQxx/aSGQgWIkRhgrwFbFAmw0IonyJ1a8/g9T6EN+sgbhDgAHALCqBDIkhD+TFlFhTUwFlCVfkYmBMOLpU0oVigSiNl03BgoQEgZBCYpSD9Q46YucELB0DBcrbjGcI0U+scMewX20AxMUpItGB+I9id4BoPh86efvydCD3HsiIwnS9PSVbEFg1ncPs4+I8hTI8DcG/aHSw9w9gGezzxUFPxI/Cyw+VSie4qenfXccYU+faw+CjYpDaUgB57jO/ZwRy7bBSR4ROZoHWUPOSmEya8PbcCHOJR6gaQCKcK3WGJM25KwJaVpKQzQvGhcUKRBDFScQ3BRPn+etFsv3yYlJuegeHtODjdbkGRJwCA+vcey+RkuAxTln6oFtCsDqhlkYz0Bvw7dV7Iv2wr5Q5+WUPUrwIqDKw9CBzLFYtJ33XLqoxvoJrNKCxlJQli+LkOIPt+OuIvG2/2mXapn0sYiJCpg08k/YQO1/Goo0020nVNGCHHI60qx5GPuDtmsNRMcAH4hQd5657wQKD2EAn0AlueqzNhNJPkmPFIb9MBPThrdKlI3VEkhJEhEawGhBDcoCGSiBvVDR+ZEP9zCT1m/9e8Ci6xYcF+aKEGKMg++5KgQfVzoDqgSRMhYqpIAR0AC8xg/fN7wWKbooWEYgn3BE/qYc36L5bPOSevzvqxmGZfN1B4qqfm7PhDxOw6PAN719sgT8qSboHfDAl4EIigoDAWNtJa3nnUJM0E9bvMu/g3Sekkty7nnhW7Nu0uLNqV16LBohAbRAio8tBQ0UywMxGywZECRGxEoRtKtUgowgsGyHJ11nU7RrY2tYjOuqa27LjdCus1K6pldWiAoHmkIUAiQGMBgXPIPORIDAZAZFDzg+TIQg8Tr+Jr9EV7oRIOI+0qYxWJ5yl6Bx7CJ72es6yTJaWztxgOwPeRCQYKnV1QNkYQuEPy39Yn+vn6EXz7SfKyP0Q2hY/A9k13vB9f63bJLGkQiBO77rFHJhOvasTN5gz1z/t+Nb/H5bGZ8tLep7OeJdFOAOIzZwygfDjSu5Hi7h/CBmZ2Dr33qbqtCXGITb4pc001PVcONtqyGY+R7c9MlLKR8/BdT9bwdTenwaRta+3hcCMDs11rq6EDiZ1kdsFWYLUz/jLUZmMUGa0u+IFDaXOBVpKdhZGxNkGisJQW0bD2Mda55h1W8NpqqioNaNXdQUSFFUjACxEjxKNrlYASjTHRHAYm9glmtiQoCdGHcDVAQhvpltayQrCZtEYFZZL5nDolX6Yr8QaP0Y0tK59E12zg5Wro7pVl1BbqyzHWesutGhIxmnm/pD4feJK6sjS0+ciuRfThZ1jlfHzD3pE9z23Y1W1vzSQ0pttU0bvdTalsqaD8a9zbBHZ7s2KqgzdVqyzQ6fBdQ1tvUxu9ClQv8JI0fVfrV0qhC+4GCtMN+/A3is8FZ9S+9CBQv126djbzUemtZm9zZrIblL4I/L+ncNNnk2B31oWmvysj8/x50A/MyphH1erWoGOn1LKDqaM+sB4voNpfMdPb5UaR/LTUxmm7U0eFrzq1u9bTJZdEfhIfVyPrdjadVe7itMHRo4MoFFxFGyYxjgaSyEwiwaAiGZmC0cwkHKUgMEXBZMMNlEswvn7yxJczBwQI1+ZNq2CJ7KOJNKA4IVuRnweteNR3fw7WY7Iyqu3jMZD5uDw6FV1CgyRWTv6a3amKnUWTlFAIiUUhicp5e55a1K2KYElWrhSGcdwPEyILlq1EdbQo6MVai+j4VjbEzrtoWbNDERZneUtIi9YgQECAQt6zm0h2Q4sU7uuKqSuU23nL1pJerk7R1Ho4RdAsu9nz2lRQQoRRHAjmBK6ec/A/XEeWgaE2O8EiE35/qHApHsW8ezCrl+hj65p8n+3B4GwcTtynxdxT0zEPxR6vwUkkUoJDjqUd4dO8ivHkUblWDXAwl2KhMVYhtDHaENwcFRhBwxltD6Z4aGIYhULheKLLmiUCIkWIRIBnYxjQtQjDa1JEZjUC+ZlI5gbZM2sAWQtsmAmlgUltaSJkBjQaNDefG9ZWRDv7aYcUPF97d4kDeddeRKcdZgl3P2HWV1NQqcSEUU7qlGP0Yot9l3bKZSWMqqhH7sUI5xKI5IsRG7q4uUy3pdu7YrvLrkcxOpjdUOxhACA0K/qpXaLpxLBjSEJJ3AtW5B02PF96XNavSsSRjko/XxsqzIamKOIhdgRahbu6qKoKovuUXWXcKaKlU5WoYBmEnqvMsVY4uy3HLqA8XwPpic9sHePZ2yiOfB4RhER3x0SK5B1MMBSgqVXh6q4Kemzy0mro6XVyXIj6frjDe/CBJ0knJbYUAGxrNrIRZDr7BRPCjmLc2Jpig1BR6TzKCHaq+jq0pFnu88luhSUKxVjmtMEK0z/i2ph0NdMmj3aiQm3W94nGKwiNGpgws1kgncGPPTvxBjAgZDCnnQDERo7VDyN+MnuCbv1+Z2ybzuefU1hnjAdDE0D3KLBhmJwZD+gcmLHHA3HB1a2Q9yBiJ6IFPH3ynnO661pRDsNZ5UCPRlczGYfy5GrA2cmuBiTZ1Z9O/eb596t72QljFJFFBJ8ioLdh3XD1CYmIUREKEoaQpISVspUqmbWyfk6g0e7auzhDBVKsPwGMeNmY0xHxDWUb0olSQLeIWalNBYi8B1UEqppiEsuIjSh3JJbzubnU1vLubxreKrmgpuxu5IGBhAtmESRuVREiBoKdZQTfHngw56NwQksLyrPRXpDMJoh7/P1Th9NXa42cDmFeKq9aehtnRW6QM3Q4gR77XNhd8Xa8e7rMt1XPsk1clZCTNLCFITqPkOsOYRQ1DV1PychmWAQzgUCuYgVhPn8ivsATdqPkrDd0GXozdGIUhdHWmgs/Bn3WG6WGFS7MSYwrQNgXQ1IdobAcwYyMiuNmfnlnrh4kfaDzDwCMuc/oxmOd4BJ9VoXqGpOm9ksGeSPPKKKh6GxkD2/YCRBCw52a7emp+b8LMMQvIiUTSI6Y1KPfCQIqB0ivivDl7N1y7+yk0Kc2T0JcjpZ4o6Og53Hyq2+V/mwOPdPj5GlWWitDcdJLhoYVcpo9YliUDOXg6LjapVXoG/1sA7b0KxsACYoJizQ9DjBCJiMuvPQjZwmgygvaNYfz9DETSElU0BdLxVXzmQRPvmt7yG2EOPiG/AjveEow4wlEz+ZwqXJcoalrmksVMqLgRkUMC1lyw+ZkEjVsyEOa0Byt6GJYvSSExZAaaKuLGLy7td84TeqEOuiZW6XnWiTzWw3WqGb510aMrnq9i7wWgZ7DK2uhUL2GC9aguD8xiqkV4ykEMsqy56szpWaLhsFrbL7o9QlCoq2Ja5EjLyCfVIrSKnJK7yC0eBJIToVI4OOlWgxUOvD6uC14ZgcVTpgwMEEFeJidJcWRwF8yWMS06PDOV+vW38Om2mTEzbo8eq52U2YjCCqUgJYOklQIR2IqoOvh2NEDCzjFOCG9NyrpGxCSGSOFDGZQQOWwmnVHFVUa26swdK6YysSEYSsWKokLVugykK2lDSO5NzJttisl6S8WZmYyUMiMmzh8Ng6/4fX0g/qqhrgQtTPOOCUSCowiy1io/s1d1A890FBCBMES6/L02PYLb86xCtcaBVVbHo76N6MM4zDq1qylOd676Nnw3EeX6yvLm9ajfwj2IdFJnXaZzer4hM2jREiEY7QJaRibzcbVXORrgLpAkGITCRlFBaTsDGBEnIpTBYlAgYeicOYHZSKB0irrxYmm4tjXShcbqVenSh1UV3y3MJ3evp1lnXcfM63k2x677glQ2qQiFgyLuSGTQKBkRyGTLhCFVUqpgXgXTFRkoDxW5FlWu8p9anWTgxYIJn8Ej74iGZgoMiEsIfGGqpl5qi7r07O3hZx4hvBCbw32TcDCPGwtjEWDHgdWUEViKDLDTTN2CoimBTBjVzoOR2uQ0AgwdTQdUwUmRq7OOQZD1eX0HO9omjs9RzQekVkkA6+z+fcPTj7x6vf7Mmpbuhkh3MTsDUukLE6HmTUwRUr4qJAcB4CGiY8aSISJ+181d/VQzIQVkADVOBgwO80Ne3UNF7k73uBy7jY3myoakUCkFHbYnK7rgwWE5FbhpaSiMhC45dOgglUVMUG0AgEKU2d5rtXXbpqY2NgdLy7xJruMrAMGIuYltwySIBhHBQsQiYGhmghmDDGBBYzeRuxtrNg92cMhN4VKRKj4spq3sgOkJKDMFVQRdMtCoR6bstuASQ0eNFeDjo8oBICtduhUfUcoxVsX7NZXeOHH5hZnQYGG0kltrxsMtAw90Ko7DW31BJHxdMsFbmDbDFEblUI0F9SaRPx9X8r8dfiCq/WlKZJurHXHwe7NTGSrlUMQvwqhDAA4iTwVhakvpL3SJBYOTmLHh35MDN8nfgTOS4TZ0kh49Z3nA1OwUKMQPxxEaKWIiUnuRahuVADXdktM4MFqmRMn6aZTTM8zkUDXCI4FHlkOMb7PDsy6BpRd3D0dAqGg7aWiRMVAGq3Ge8dk2xfmxmoKyH2Hv8wszBYKWA37oDdIQxQuyasCRYw1WknLXTxiefP02YEczSi4LQYNAuUz1MWaNkuAN2IlDbIAnSE1VERJHKIqdAMS2US0oaiMC0zRVjERKIGDNgxAx1diC6EXaLKqWFwbFUdbcCISvI3nLh3B2/y6fSmimk67FlGTF0UKN/zeuGhMyzWxk1wYQeKnWEB7EVPIIJ3ZCnnPmAGTYNFBJ3JyYEnakk4EONTvVVV+zsKMCKJBRzJr7ZalOlGS58Uy6v5DjrZkd53VKqoGbpVFWHARAoohEO4hgDkIVPuLUp8Z3hfSG7q6szxvJkmZiGvxnJR3hBMKPVKYF9Opsb4XyD2KbpA7cG9MFCCMiggJFIM1SWh8z8pwz3SDHKbtQDh4lE0YgnQSCLsIWT+Keg6ycIfafxydfp91eS3EoZSqXfsKrlkbGinB7PeXiOY0mSi0HqxgcYhQrDYJUiqAkkC5jSJj1KgYikgtE0DRiFpjDnAGIkpSLmMy6kGjo6yjrIWXNU76XUeXV4bzeh8h6TYJkIkg0Fr6LcE6KVAL8ydBOQPkGRc8Z2IOAVLSQUNQGHzGWQ6QO3ohZry866bApCjz+o1LSENqY9lyTAe75gF4J2jPp+JAKncxR8ES5PGQJp6ENp0160A3Jp0gyE3kF9/Ndd9/Ly+K61dqYsUSZkY23xLlG3td3cze7NXrtf/2SWqEYwEc/BuIh4kXrY4CGgn0alIpuAiO7zjpqidBHkKGpOmobkT0RRgQkWH1FVHrkKefA4BP7t/EB9kgGVNA6kKD/xNXqtISQWEJSlg0tEhavaUeYRH9RAojsfUaK+7I/RZQ+W4H2+7WJ8WoKHBPr1r6fjZYcKMiXuFaorF1+HR0wZESW46LIvyVJ64v8iJDFnBJoMN76QO8A2cAfGEIxTBuFX0MUA9GNSAbX31AW5EmCrFgeEmJEN3f208Lvtuy5XNQjPx/un2TMQfKQJqDB1G1qRUqBV7F+SqF/phOvI9gJ2E3ey7E8StI+w5HvDsEWHd23pQ6AZAzN52yXsw9YXxOie79r7qPh1E0ADRv/S7bg9XHbkucu63d151XRGxRk1rGlpvlWW3XvdV2m2mQlxLUj8DnnHu49H7hICJukDbQr9npuHr+Pfiat9Z5U+ufiDQfnA5DEP0BACRB2PQe4nAOPAC99JHjRofcTiPG2ltPXCyRGMAwNgWJGhQanG+WTBAA19kf08SmE3vVE5xJseyjIMk8lKoF6IP6v0UflwGYb7lGySZzhEMTDA4QEkA5yOTD68XKZHC4G4YKCkFnPuPmFk23a0WfvGBpENiUmy4EQo8zwPoB3B1RD1T2hvd4e6G80UMBvaFPkJCBChEalRD1TaBoQRkF0bJ2Y6I/0eb+H8ma91qIUf00jCraYaUNZQnWzAedKSD4DzUegFQxGbpptV07DJVuJLKnQJcJ/cJi6gwQ9f3WHAN1V3naesOacfH1S1qRnpUcIbohiB76iCjCRgCDbC0VdNWuXjbXkv1KzAoWSAoTDCfKemtbJRD7rPXn7GtCNG5YNEze9/rh3BwHJV/dkFGkRg0q/OLmVqWcR9Qj7S0QwTZ2vjQpZ6ibGw7QfpNLBhBN3rk32iDgid07UIP3mrNMPhZCfVpcZ7wcdHEmIENAlxbC3S1YyUKldSoDexBobO5+Saho2SnbpKqXxdJU7MpUsDohkHZy6usyAcjATsHIdQEXl3g0Pguzoie8/ZDIp6oivfzR+mASBx15m8OMKjwMowiI1IBzd54cjcKOQ/UeoTcRXtOnq7fmwe3J97D7UXwJxKwLmu9ICJ/vZ+S6nxZuQfkfrDGDQ+yX7SbRN8XM1DqAohnJ7pDv+Q+aJYfH/p+/oTSPkYLHj6NQ2sYuvh7f+BfDOH+P9RjdZlvmMzUW7Fod/YO6M/704f+8ZOc55D/M+j5P5z/wLuSKcKEhiW55eA')))
\ No newline at end of file
diff --git a/irlc/project0/unitgrade_data/AdditionQuestion.pkl b/irlc/project0/unitgrade_data/AdditionQuestion.pkl
index 11c0af9d431d3f61b3f2af0fba319cf8b8bb1958..f250f2dcf96266bd015e4875eb687036cad1e28d 100644
Binary files a/irlc/project0/unitgrade_data/AdditionQuestion.pkl and b/irlc/project0/unitgrade_data/AdditionQuestion.pkl differ
diff --git a/irlc/project0/unitgrade_data/BasicClass.pkl b/irlc/project0/unitgrade_data/BasicClass.pkl
index 110aa845e0142c58c171373055b1d656633a26d1..dd2defb0c63747196732be8a0d06941802158b66 100644
Binary files a/irlc/project0/unitgrade_data/BasicClass.pkl and b/irlc/project0/unitgrade_data/BasicClass.pkl differ
diff --git a/irlc/project0/unitgrade_data/ClassUse.pkl b/irlc/project0/unitgrade_data/ClassUse.pkl
index 25c6e361e111f36205adfa0ef92620470f6a0198..90e7e6fca431299848db66df42c0b8d4c5e22f17 100644
Binary files a/irlc/project0/unitgrade_data/ClassUse.pkl and b/irlc/project0/unitgrade_data/ClassUse.pkl differ
diff --git a/irlc/project0/unitgrade_data/FruitsOrdered.pkl b/irlc/project0/unitgrade_data/FruitsOrdered.pkl
index b55dba6dd8f3b84b5a4bdd0a9f85ba60a0ce7f29..842a7213e6e1e1a175930003835f10bc834e0217 100644
Binary files a/irlc/project0/unitgrade_data/FruitsOrdered.pkl and b/irlc/project0/unitgrade_data/FruitsOrdered.pkl differ
diff --git a/irlc/project0/unitgrade_data/Inheritance.pkl b/irlc/project0/unitgrade_data/Inheritance.pkl
index 32072c814e584f70b67d9d0895c4d07be7286c27..11464ab9c4aecaabcb49eccab2b7f4b85a00dc5e 100644
Binary files a/irlc/project0/unitgrade_data/Inheritance.pkl and b/irlc/project0/unitgrade_data/Inheritance.pkl differ
diff --git a/irlc/project0/unitgrade_data/MeanOfDie.pkl b/irlc/project0/unitgrade_data/MeanOfDie.pkl
index 27877f6a8e70ffb0d0ad3cac120b703d81d980fd..129b3cf7f25b5a585ce9531242e1e9da9b2ef42c 100644
Binary files a/irlc/project0/unitgrade_data/MeanOfDie.pkl and b/irlc/project0/unitgrade_data/MeanOfDie.pkl differ
diff --git a/irlc/project0/unitgrade_data/MisterfyQuestion.pkl b/irlc/project0/unitgrade_data/MisterfyQuestion.pkl
index 2359530f1174d72bd344f9add58dd05e577704fb..79944a9d237eb9fb5095e3bbd395ca0dc698116e 100644
Binary files a/irlc/project0/unitgrade_data/MisterfyQuestion.pkl and b/irlc/project0/unitgrade_data/MisterfyQuestion.pkl differ
diff --git a/irlc/project0/unitgrade_data/token_fruit_project_grade.manifest b/irlc/project0/unitgrade_data/token_fruit_project_grade.manifest
deleted file mode 100644
index 6825d298af1b0b9974c4aa2ebd28852729ccae99..0000000000000000000000000000000000000000
--- a/irlc/project0/unitgrade_data/token_fruit_project_grade.manifest
+++ /dev/null
@@ -1,2 +0,0 @@
-
-/home/tuhe/Documents/iml/02450students/irlc/project0/FruitReport_handin_0_of_70.token 6e73bc769f3df623ec850a8d36f57395dd1e3e94d62eb5e3bcabccdcc5b5ed4690b2ac0ded0ef3148eb47a09d5b409225efdc038a022563d9bd42638bc9fd6f5
\ No newline at end of file
diff --git a/irlc/project1/Latex/figures/your_answer.pdf b/irlc/project1/Latex/figures/your_answer.pdf
index d8c092974e20aaaf1165958a53bdce3a2ebdbf8f..cfb8c071ad5174a198c4f29edac9fe9ebd054a5d 100644
Binary files a/irlc/project1/Latex/figures/your_answer.pdf and b/irlc/project1/Latex/figures/your_answer.pdf differ
diff --git a/irlc/project2/Latex/figures/your_answer.pdf b/irlc/project2/Latex/figures/your_answer.pdf
index d8c092974e20aaaf1165958a53bdce3a2ebdbf8f..cfb8c071ad5174a198c4f29edac9fe9ebd054a5d 100644
Binary files a/irlc/project2/Latex/figures/your_answer.pdf and b/irlc/project2/Latex/figures/your_answer.pdf differ
diff --git a/irlc/project3/Latex/figures/your_answer.pdf b/irlc/project3/Latex/figures/your_answer.pdf
index d8c092974e20aaaf1165958a53bdce3a2ebdbf8f..cfb8c071ad5174a198c4f29edac9fe9ebd054a5d 100644
Binary files a/irlc/project3/Latex/figures/your_answer.pdf and b/irlc/project3/Latex/figures/your_answer.pdf differ
diff --git a/irlc/tests/ex1_5_2.png b/irlc/tests/ex1_5_2.png
deleted file mode 100644
index 8e258db81b1e55b71339d1088bae770ec21f0ab6..0000000000000000000000000000000000000000
Binary files a/irlc/tests/ex1_5_2.png and /dev/null differ
diff --git a/irlc/tests/tests_week01.py b/irlc/tests/tests_week01.py
index 947739a8815cc82f2e080a8163df2018da5332a7..eaadc04747c7665dcb30b8c7c1f3a792600340e9 100644
--- a/irlc/tests/tests_week01.py
+++ b/irlc/tests/tests_week01.py
@@ -15,10 +15,10 @@ from irlc.ex01.bobs_friend import BobFriendEnvironment, AlwaysAction_u1, AlwaysA
 class Week1IML(UTestCase):
     def test_week0(self):
         print("Week 00")
-        # from irlc import ex0_4_3
-        # from irlc import ex0_4_4
-        # from irlc import ex0_5_1
-        # from irlc import ex0_5_2
+        from irlc import ex0_4_3
+        from irlc import ex0_4_4
+        from irlc import ex0_5_1
+        from irlc import ex0_5_2
 
         from irlc.ex00.fruit_homework import add
         self.assertEqual(add(1,1), 2)
@@ -116,15 +116,6 @@ class Problem4InventoryTrain(UTestCase):
         avg_reward_simplified_train = np.mean([simplified_train(env, agent) for i in range(1000)])
         self.assertLinf(avg_reward_simplified_train, tol=0.5)
 
-# class FrozenLakeTest(UTestCase):
-#     def test_frozen_lake(self):
-#         env = gym.make("FrozenLake-v1")
-#         agent = FrozenAgentDownRight(env)
-#         s = env.reset()
-#         for k in range(10):
-#             self.assertEqual(agent.pi(s, k), DOWN if k % 2 == 0 else RIGHT)
-
-
 class Week01Tests(Report): #240 total.
     title = "Tests for week 01"
     pack_imports = [irlc]
diff --git a/irlc/tests/tests_week06.py b/irlc/tests/tests_week06.py
index a72463838f7fba08f8db8d4bf789532d313e7e2d..bc5b485afaddba906b079c481d30133805fe58e1 100644
--- a/irlc/tests/tests_week06.py
+++ b/irlc/tests/tests_week06.py
@@ -9,125 +9,131 @@ from irlc.ex04.model_harmonic import HarmonicOscilatorEnvironment
 
 matrices = ['L', 'l', 'V', 'v', 'vc']
 
-class Problem3LQR(UTestCase):
-    title = "LQR, full check of implementation"
 
-    @classmethod
-    def setUpClass(cls):
-        # def init(self):
-        from irlc.ex06.dlqr_check import check_LQR
-        (cls.L, cls.l), (cls.V, cls.v, cls.vc) = check_LQR()
-        # self.M = list(zip(matrices, [L, l, V, v, vc]))
-
-    def chk_item(self, m_list):
-        self.assertIsInstance(m_list, list)
-        self.assertEqualC(len(m_list))
-        for m in m_list:
-            self.assertIsInstance(m, np.ndarray)
-            self.assertEqualC(m.shape)
-            self.assertL2(m, tol=1e-6)
-
-    def test_L(self):
-        self.chk_item(self.__class__.L)
-
-    def test_l(self):
-        self.chk_item(self.__class__.l)
-
-    def test_V(self):
-        self.chk_item(self.__class__.V)
-
-    def test_v(self):
-        self.chk_item(self.__class__.v)
-
-    def test_vc(self):
-        vc = self.__class__.vc
-        self.assertIsInstance(vc, list)
-        for d in vc:
-            self.assertL2(d, tol=1e-6)
-
-        self.chk_item(self.__class__.l)
-
-class Problem4LQRAgent(UTestCase):
-    def _mkagent(self, val=0.):
-        A = np.ones((2, 2))* (1+val)
-        A[1, 0] = 0
-        B = np.asarray([[0], [1]])
-        Q = np.eye(2) * (3+val)
-        R = np.ones((1, 1)) * 2
-        q = np.asarray([-1.1 + val, 0])
-        from irlc.ex06.lqr_agent import LQRAgent
-        env = LocomotiveEnvironment(render_mode=None, Tmax=5, slope=1)
-        agent = LQRAgent(env, A=A, B=B, Q=Q, R=R, q=q)
-        return agent
-
-    def test_policy_lqr_a(self):
-        agent = self._mkagent(0)
-        self.assertL2(agent.pi(np.asarray([1, 0]), k=0))
-        self.assertL2(agent.pi(np.asarray([1, 0]), k=5))
-
-    def test_policy_lqr_b(self):
-        agent = self._mkagent(0.2)
-        self.assertL2(agent.pi(np.asarray([1, 0]), k=0))
-        self.assertL2(agent.pi(np.asarray([1, 0]), k=5))
-
-class Problem5_6_Boeing(UTestCase):
-
-    def test_compute_A_B_d(self):
-        from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
-        model = BoeingEnvironment(Tmax=10).discrete_model.continuous_model
-        A, B, d = compute_A_B_d(model, dt=0.2)
-        self.assertL2(A)
-        self.assertL2(B)
-        self.assertL2(d)
-
-    def test_compute_Q_R_q(self):
-        from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
-        model = BoeingEnvironment(Tmax=10).discrete_model.continuous_model
-        Q, R, q = compute_Q_R_q(model, dt=0.2)
-        self.assertL2(Q)
-        self.assertL2(R)
-        self.assertL2(q)
-
-    def test_boing_path(self):
-        from irlc.ex06.boeing_lqr import boeing_simulation
-        stats, trajectories, env = boeing_simulation()
-        self.assertL2(trajectories[-1].state, tol=1e-6)
-
-
-class Problem7_8_PidLQR(UTestCase):
-    def test_constant_lqr_agent(self):
-        Delta = 0.06  # Time discretization constant
-        # Define a harmonic osscilator environment. Use .., render_mode='human' to see a visualization.
-        env = HarmonicOscilatorEnvironment(Tmax=8, dt=Delta, m=0.5, R=np.eye(1) * 8,
-                                           render_mode=None)  # set render_mode='human' to see the oscillator.
-        model = env.discrete_model.continuous_model  # Get the ControlModel corresponding to this environment.
-
-        from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
-        from irlc.ex06.lqr_pid import ConstantLQRAgent
-        A, B, d = compute_A_B_d(model, Delta)
-        Q, R, q = compute_Q_R_q(model, Delta)
-        x0, _ = env.reset()
-
-        # Run the LQR agent
-        lqr_agent = ConstantLQRAgent(env, A=A, B=B, d=d, Q=Q, R=R, q=q)
-        self.assertLinf(lqr_agent.pi(x0, k=0), tol=1e-3)
-        self.assertLinf(lqr_agent.pi(x0, k=10), tol=1e-3)
-
-
-    def test_KpKd(self):
-        Delta = 0.06  # Time discretization constant
-        # Define a harmonic osscilator environment. Use .., render_mode='human' to see a visualization.
-        env = HarmonicOscilatorEnvironment(Tmax=8, dt=Delta, m=0.5, R=np.eye(1) * 8,
-                                           render_mode=None)  # set render_mode='human' to see the oscillator.
-        model = env.discrete_model.continuous_model  # Get the ControlModel corresponding to this environment.
-        from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
-        from irlc.ex06.lqr_pid import ConstantLQRAgent, get_Kp_Kd
-        A, B, d = compute_A_B_d(model, Delta)
-        Q, R, q = compute_Q_R_q(model, Delta)
-        lqr_agent = ConstantLQRAgent(env, A=A, B=B, d=d, Q=Q, R=R, q=q)
-        Kp, Kd = get_Kp_Kd(lqr_agent.L[0])
-        self.assertAlmostEqualC(Kp, places=3)
-        self.assertAlmostEqualC(Kd, places=3)
+class Week6IML(UTestCase):
+    def test_week0(self):
+        from irlc.ex00.fruit_homework import add
+        self.assertEqual(add(1,1), 2)
+
+# class Problem3LQR(UTestCase):
+#     title = "LQR, full check of implementation"
+#
+#     @classmethod
+#     def setUpClass(cls):
+#         # def init(self):
+#         from irlc.ex06.dlqr_check import check_LQR
+#         (cls.L, cls.l), (cls.V, cls.v, cls.vc) = check_LQR()
+#         # self.M = list(zip(matrices, [L, l, V, v, vc]))
+#
+#     def chk_item(self, m_list):
+#         self.assertIsInstance(m_list, list)
+#         self.assertEqualC(len(m_list))
+#         for m in m_list:
+#             self.assertIsInstance(m, np.ndarray)
+#             self.assertEqualC(m.shape)
+#             self.assertL2(m, tol=1e-6)
+#
+#     def test_L(self):
+#         self.chk_item(self.__class__.L)
+#
+#     def test_l(self):
+#         self.chk_item(self.__class__.l)
+#
+#     def test_V(self):
+#         self.chk_item(self.__class__.V)
+#
+#     def test_v(self):
+#         self.chk_item(self.__class__.v)
+#
+#     def test_vc(self):
+#         vc = self.__class__.vc
+#         self.assertIsInstance(vc, list)
+#         for d in vc:
+#             self.assertL2(d, tol=1e-6)
+#
+#         self.chk_item(self.__class__.l)
+#
+# class Problem4LQRAgent(UTestCase):
+#     def _mkagent(self, val=0.):
+#         A = np.ones((2, 2))* (1+val)
+#         A[1, 0] = 0
+#         B = np.asarray([[0], [1]])
+#         Q = np.eye(2) * (3+val)
+#         R = np.ones((1, 1)) * 2
+#         q = np.asarray([-1.1 + val, 0])
+#         from irlc.ex06.lqr_agent import LQRAgent
+#         env = LocomotiveEnvironment(render_mode=None, Tmax=5, slope=1)
+#         agent = LQRAgent(env, A=A, B=B, Q=Q, R=R, q=q)
+#         return agent
+#
+#     def test_policy_lqr_a(self):
+#         agent = self._mkagent(0)
+#         self.assertL2(agent.pi(np.asarray([1, 0]), k=0))
+#         self.assertL2(agent.pi(np.asarray([1, 0]), k=5))
+#
+#     def test_policy_lqr_b(self):
+#         agent = self._mkagent(0.2)
+#         self.assertL2(agent.pi(np.asarray([1, 0]), k=0))
+#         self.assertL2(agent.pi(np.asarray([1, 0]), k=5))
+#
+# class Problem5_6_Boeing(UTestCase):
+#
+#     def test_compute_A_B_d(self):
+#         from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
+#         model = BoeingEnvironment(Tmax=10).discrete_model.continuous_model
+#         A, B, d = compute_A_B_d(model, dt=0.2)
+#         self.assertL2(A)
+#         self.assertL2(B)
+#         self.assertL2(d)
+#
+#     def test_compute_Q_R_q(self):
+#         from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
+#         model = BoeingEnvironment(Tmax=10).discrete_model.continuous_model
+#         Q, R, q = compute_Q_R_q(model, dt=0.2)
+#         self.assertL2(Q)
+#         self.assertL2(R)
+#         self.assertL2(q)
+#
+#     def test_boing_path(self):
+#         from irlc.ex06.boeing_lqr import boeing_simulation
+#         stats, trajectories, env = boeing_simulation()
+#         self.assertL2(trajectories[-1].state, tol=1e-6)
+#
+#
+# class Problem7_8_PidLQR(UTestCase):
+#     def test_constant_lqr_agent(self):
+#         Delta = 0.06  # Time discretization constant
+#         # Define a harmonic osscilator environment. Use .., render_mode='human' to see a visualization.
+#         env = HarmonicOscilatorEnvironment(Tmax=8, dt=Delta, m=0.5, R=np.eye(1) * 8,
+#                                            render_mode=None)  # set render_mode='human' to see the oscillator.
+#         model = env.discrete_model.continuous_model  # Get the ControlModel corresponding to this environment.
+#
+#         from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
+#         from irlc.ex06.lqr_pid import ConstantLQRAgent
+#         A, B, d = compute_A_B_d(model, Delta)
+#         Q, R, q = compute_Q_R_q(model, Delta)
+#         x0, _ = env.reset()
+#
+#         # Run the LQR agent
+#         lqr_agent = ConstantLQRAgent(env, A=A, B=B, d=d, Q=Q, R=R, q=q)
+#         self.assertLinf(lqr_agent.pi(x0, k=0), tol=1e-3)
+#         self.assertLinf(lqr_agent.pi(x0, k=10), tol=1e-3)
+#
+#
+#     def test_KpKd(self):
+#         Delta = 0.06  # Time discretization constant
+#         # Define a harmonic osscilator environment. Use .., render_mode='human' to see a visualization.
+#         env = HarmonicOscilatorEnvironment(Tmax=8, dt=Delta, m=0.5, R=np.eye(1) * 8,
+#                                            render_mode=None)  # set render_mode='human' to see the oscillator.
+#         model = env.discrete_model.continuous_model  # Get the ControlModel corresponding to this environment.
+#         from irlc.ex06.boeing_lqr import compute_A_B_d, compute_Q_R_q
+#         from irlc.ex06.lqr_pid import ConstantLQRAgent, get_Kp_Kd
+#         A, B, d = compute_A_B_d(model, Delta)
+#         Q, R, q = compute_Q_R_q(model, Delta)
+#         lqr_agent = ConstantLQRAgent(env, A=A, B=B, d=d, Q=Q, R=R, q=q)
+#         Kp, Kd = get_Kp_Kd(lqr_agent.L[0])
+#         self.assertAlmostEqualC(Kp, places=3)
+#         self.assertAlmostEqualC(Kd, places=3)
 
 
 
@@ -137,10 +143,11 @@ class Week06Tests(Report):
     pack_imports = [irlc]
     individual_imports = []
     questions = [
-        (Problem3LQR, 10),
-        (Problem4LQRAgent, 10),
-        (Problem5_6_Boeing, 10),
-        (Problem7_8_PidLQR, 10),
+        (Week6IML, 10),
+        # (Problem3LQR, 10),
+        # (Problem4LQRAgent, 10),
+        # (Problem5_6_Boeing, 10),
+        # (Problem7_8_PidLQR, 10),
                  ]
 if __name__ == '__main__':
     from unitgrade import evaluate_report_student
diff --git a/requirements_conda.txt b/requirements_conda.txt
index 2b402cf578db0e423773c3f874ce0d9e79d35232..db1332e9867076186c2673cfbe8666ef60bcf957 100644
--- a/requirements_conda.txt
+++ b/requirements_conda.txt
@@ -13,4 +13,5 @@ requests # Required when updating the local files (read stuff from gitlab).
 pyqt5
 pygame
 numpy<=1.26.4 # Version 2 has a problem with gymnasium
-
+importlib-resources
+dtuimldmtools
diff --git a/requirements_pip.txt b/requirements_pip.txt
index a375525d9963ced95672329d771550ff26c5d5ae..b279549d34df0700f46ea11fd4c21e7ca550debf 100644
--- a/requirements_pip.txt
+++ b/requirements_pip.txt
@@ -1,3 +1,4 @@
 # PyQt5>=5.15.9 # 5.15.8 has a problem with matplotlib; but newest version is 5.15.9
 unitgrade
 -e .
+