From b0b612165666c0faa98aa7610ea1ce2f341b5650 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 11 Mar 2023 13:39:34 -0800 Subject: [PATCH 01/14] add pytest --skipslow --- control/tests/conftest.py | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/control/tests/conftest.py b/control/tests/conftest.py index 662e2cd32..bbc1a689c 100644 --- a/control/tests/conftest.py +++ b/control/tests/conftest.py @@ -119,3 +119,27 @@ def mplcleanup(): mpl.units.registry.clear() mpl.units.registry.update(save) mpl.pyplot.close("all") + + +# +# Functionality to skip slow tests using --skipslow +# +# See https://docs.pytest.org/en/latest/example/simple.html +# #control-skipping-of-tests-according-to-command-line-option +# +def pytest_addoption(parser): + parser.addoption( + "--skipslow", action="store_true", default=False, + help="skip slow tests") + + +def pytest_configure(config): + config.addinivalue_line("markers", "slow: mark test as slow to run") + + +def pytest_collection_modifyitems(config, items): + if config.getoption("--skipslow"): + skip_slow = pytest.mark.skip(reason="skipping slow tests") + for item in items: + if "slow" in item.keywords: + item.add_marker(skip_slow) From 823dfbc6ed1de5659b43beb3144da0df84cc7567 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 11 Mar 2023 13:51:16 -0800 Subject: [PATCH 02/14] mark selected optimal, rlocus tests as slow --- control/tests/optimal_test.py | 2 ++ control/tests/rlocus_test.py | 1 + 2 files changed, 3 insertions(+) diff --git a/control/tests/optimal_test.py b/control/tests/optimal_test.py index e0ab392bb..be7cbf2db 100644 --- a/control/tests/optimal_test.py +++ b/control/tests/optimal_test.py @@ -160,6 +160,7 @@ def test_discrete_lqr(): assert np.any(np.abs(res1.inputs - res2.inputs) > 0.1) +@pytest.mark.slow def test_mpc_iosystem_aircraft(): # model of an aircraft discretized with 0.2s sampling time # Source: https://www.mpt3.org/UI/RegulationProblem @@ -652,6 +653,7 @@ def final_point_eval(x, u): res = optctrl.compute_trajectory(x0, squeeze=True, return_x=True) +@pytest.mark.slow @pytest.mark.parametrize( "method, npts, initial_guess, fail", [ ('shooting', 3, None, 'xfail'), # doesn't converge diff --git a/control/tests/rlocus_test.py b/control/tests/rlocus_test.py index a25928e27..e61f0c8fe 100644 --- a/control/tests/rlocus_test.py +++ b/control/tests/rlocus_test.py @@ -64,6 +64,7 @@ def test_without_gains(self, sys): roots, kvect = root_locus(sys, plot=False) self.check_cl_poles(sys, roots, kvect) + @pytest.mark.slow @pytest.mark.parametrize('grid', [None, True, False]) def test_root_locus_plot_grid(self, sys, grid): rlist, klist = root_locus(sys, grid=grid) From cf4510911f570b5638d2fc909603238bbd8af5c6 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 5 Mar 2023 21:05:11 -0800 Subject: [PATCH 03/14] initial implementation of optimal estimation problem --- control/optimal.py | 827 ++++++++++++++++++++++++++++++++- control/stochsys.py | 4 +- control/tests/kwargs_test.py | 8 +- control/tests/optimal_test.py | 17 +- control/tests/stochsys_test.py | 178 +++++++ doc/conf.py | 5 +- doc/optimal.rst | 169 ++++++- 7 files changed, 1177 insertions(+), 31 deletions(-) diff --git a/control/optimal.py b/control/optimal.py index 9a8218a91..12e0d43ba 100644 --- a/control/optimal.py +++ b/control/optimal.py @@ -137,8 +137,8 @@ class OptimalControlProblem(): """ def __init__( - self, sys, timepts, integral_cost, trajectory_constraints=[], - terminal_cost=None, terminal_constraints=[], initial_guess=None, + self, sys, timepts, integral_cost, trajectory_constraints=None, + terminal_cost=None, terminal_constraints=None, initial_guess=None, trajectory_method=None, basis=None, log=False, kwargs_check=True, **kwargs): """Set up an optimal control problem.""" @@ -941,7 +941,7 @@ def __init__( # Compute the input for a nonlinear, (constrained) optimal control problem def solve_ocp( sys, timepts, X0, cost, trajectory_constraints=None, terminal_cost=None, - terminal_constraints=[], initial_guess=None, basis=None, squeeze=None, + terminal_constraints=None, initial_guess=None, basis=None, squeeze=None, transpose=None, return_states=True, print_summary=True, log=False, **kwargs): @@ -1081,8 +1081,8 @@ def solve_ocp( # Create a model predictive controller for an optimal control problem def create_mpc_iosystem( - sys, timepts, cost, constraints=[], terminal_cost=None, - terminal_constraints=[], log=False, **kwargs): + sys, timepts, cost, constraints=None, terminal_cost=None, + terminal_constraints=None, log=False, **kwargs): """Create a model predictive I/O control system This function creates an input/output system that implements a model @@ -1141,6 +1141,730 @@ def create_mpc_iosystem( return ocp.create_mpc_iosystem(**kwargs) +# +# Optimal (moving horizon) estimation problem +# + +class OptimalEstimationProblem(): + """Description of a finite horizon, optimal estimation problem. + + The `OptimalEstimationProblem` class holds all of the information + required to specify an optimal estimation problem: the system dynamics, + cost function (negative of the log likelihood), and constraints. + + Parameters + ---------- + sys : InputOutputSystem + I/O system for which the optimal input will be computed. + timepts: 1D array + Set up time points at which the inputs and outputs are given. + integral_cost : callable + Function that returns the integral cost given the estimated state, + system inputs, and output error. Called as integral_cost(xhat, u, + v, w) where xhat is the estimated state, u is the appplied input to + the system, v is the estimated disturbance input, and w is the + difference between the measured and the estimated output. + trajectory_constraints : list of constraints, optional + List of constraints that should hold at each point in the time + vector. Each element of the list should be an object of type + :class:`~scipy.optimize.LinearConstraint` with arguments `(A, lb, + ub)` or :class:`~scipy.optimize.NonlinearConstraint` with arguments + `(fun, lb, ub)`. The constraints will be applied at each time point + along the trajectory. + terminal_cost : callable, optional + Function that returns the terminal cost given the initial estimated + state and expected value. Called as terminal_cost(xhat, x0). + + Returns + ------- + oep : OptimalEstimationProblem + Optimal estimation problem object, to be used in computing optimal + estimates. + + Other Parameters + ---------------- + terminal_constraints : list of constraints, optional + List of constraints that should hold at the terminal point in time, + in the same form as `trajectory_constraints`. + solve_ivp_method : str, optional + Set the method used by :func:`scipy.integrate.solve_ivp`. + solve_ivp_kwargs : str, optional + Pass additional keywords to :func:`scipy.integrate.solve_ivp`. + minimize_method : str, optional + Set the method used by :func:`scipy.optimize.minimize`. + minimize_options : str, optional + Set the options keyword used by :func:`scipy.optimize.minimize`. + minimize_kwargs : str, optional + Pass additional keywords to :func:`scipy.optimize.minimize`. + + Notes + ----- + To describe an optimal estimation problem we need an input/output + system, a set of time points, measured inputs and outputs, a cost + function, and (optionally) a set of constraints on the state and/or + inputs along the trajectory (and at the terminal time). This class + sets up an optimization over the initial state and disturbances at each + point in time, using the integral and terminal costs as well as the + trajectory constraints. The `compute_estimate` method solves the + underling optimization problem using :func:`scipy.optimize.minimize`. + + The `_cost_function` method computes the "cost" (negative of the log + likelihood) of the estimated trajectory generated by the proposed + initial estimated state, the disturbances and noise, and the measured + output. It does this by calling a user-defined function for the + integral_cost given the current estimated states, inputs, and measured + outputs at each point along the trajectory and then adding the value of + a user-defined terminal cost at the initial point in the trajectory. + + The `_constraint_function` method evaluates the constraint functions + along the trajectory generated by the proposed estimate and + disturbances. As in the case of the cost function, the constraints are + evaluated at the estimated state, inputs, and measured outputs along + each point on the trajectory. This information is compared against the + constraint upper and lower bounds. The constraint function is + processed in the class initializer, so that it only needs to be + computed once. + + The default values for ``minimize_method``, ``minimize_options``, + ``minimize_kwargs``, ``solve_ivp_method``, and ``solve_ivp_options`` can + be set using config.defaults['optimal.']. + + """ + def __init__( + self, sys, timepts, integral_cost, terminal_cost=None, + trajectory_constraints=None, **kwargs): + """Set up an optimal control problem.""" + # Save the basic information for use later + self.system = sys + self.timepts = timepts + self.integral_cost = integral_cost + self.terminal_cost = terminal_cost + + # Process keyword arguments + self.minimize_kwargs = {} + self.minimize_kwargs['method'] = kwargs.pop( + 'minimize_method', config.defaults['optimal.minimize_method']) + self.minimize_kwargs['options'] = kwargs.pop( + 'minimize_options', config.defaults['optimal.minimize_options']) + self.minimize_kwargs.update(kwargs.pop( + 'minimize_kwargs', config.defaults['optimal.minimize_kwargs'])) + + # Make sure there were no extraneous keywords + if kwargs: + raise TypeError("unrecognized keyword(s): ", str(kwargs)) + + self.trajectory_constraints = _process_constraints( + trajectory_constraints, "trajectory") + + # + # Compute and store constraints + # + # While the constraints are evaluated during the execution of the + # SciPy optimization method itself, we go ahead and pre-compute the + # `scipy.optimize.NonlinearConstraint` function that will be passed to + # the optimizer on initialization, since it doesn't change. This is + # mainly a matter of computing the lower and upper bound vectors, + # which we need to "stack" to account for the evaluation at each + # trajectory time point plus any terminal constraints (in a way that + # is consistent with the `_constraint_function` that is used at + # evaluation time. + # + # TODO: when using the collocation method, linear constraints on the + # states and inputs can potentially maintain their linear structure + # rather than being converted to nonlinear constraints. + # + constraint_lb, constraint_ub, eqconst_value = [], [], [] + + # Go through each time point and stack the bounds + for t in self.timepts: + for type, fun, lb, ub in self.trajectory_constraints: + if np.all(lb == ub): + # Equality constraint + eqconst_value.append(lb) + else: + # Inequality constraint + constraint_lb.append(lb) + constraint_ub.append(ub) + + # Turn constraint vectors into 1D arrays + self.constraint_lb = np.hstack(constraint_lb) if constraint_lb else [] + self.constraint_ub = np.hstack(constraint_ub) if constraint_ub else [] + self.eqconst_value = np.hstack(eqconst_value) if eqconst_value else [] + + # Create the constraints (inequality and equality) + # TODO: keep track of linear vs nonlinear + self.constraints = [] + + if len(self.constraint_lb) != 0: + self.constraints.append(sp.optimize.NonlinearConstraint( + self._constraint_function, self.constraint_lb, + self.constraint_ub)) + + if len(self.eqconst_value) != 0: + self.constraints.append(sp.optimize.NonlinearConstraint( + self._eqconst_function, self.eqconst_value, + self.eqconst_value)) + + # Add the collocation constraints + colloc_zeros = np.zeros(sys.nstates * (self.timepts.size - 1)) + self.colloc_vals = np.zeros((sys.nstates, self.timepts.size - 1)) + self.constraints.append(sp.optimize.NonlinearConstraint( + self._collocation_constraint, colloc_zeros, colloc_zeros)) + + # Initialize run-time statistics + self._reset_statistics() + + # + # Cost function + # + # We are given the estimated states, applied inputs, and measured + # outputs at each time point and we use a zero-order hold approximation + # to compute the integral cost plus the terminal (initial) cost: + # + # cost = sum_{k=1}^{N-1} integral_cost(xhat[k], u[k], v[k], w[k]) * dt + # + terminal_cost(xhat[0], x0) + # + def _cost_function(self, xvec): + # Compute the estimated states and disturbance inputs + xhat, u, v, w = self._compute_states_inputs(xvec) + + # Trajectory cost + if ct.isctime(self.system): + # Evaluate the costs + costs = np.array([self.integral_cost( + xhat[:, i], u[:, i], v[:, i], w[:, i]) for + i in range(self.timepts.size)]) + + # Compute the time intervals and integrate the cost (trapezoidal) + cost = 0.5 * (costs[:-1] + costs[1:]) @ np.diff(self.timepts) + + else: + # Sum the integral cost over the time (second) indices + # cost += self.integral_cost(xhat[:, i], u[:, i], v[:, i], w[:, i]) + # TODO: make sure last point is properly accounted for + cost = sum(map( + self.integral_cost, np.transpose(xhat[:, :-1]), + np.transpose(u[:, :-1]), np.transpose(v[:, :-1]), + np.transpose(w[:, :-1]))) + + # Terminal cost + if self.terminal_cost is not None and self.x0 is not None: + cost += self.terminal_cost(xhat[:, 0], self.x0) + + # Update statistics + self.cost_evaluations += 1 + + # Return the total cost for this input sequence + return cost + + # + # Constraints + # + # We are given the constraints along the trajectory and the terminal + # constraints, which each take inputs [xhat, u, v, w] and evaluate the + # constraint. How we handle these depends on the type of constraint: + # + # * For linear constraints (LinearConstraint), a combined (hstack'd) + # vector of the estimate state and inputs is multiplied by the + # polytope A matrix for comparison against the upper and lower + # bounds. + # + # * For nonlinear constraints (NonlinearConstraint), a user-specific + # constraint function having the form + # + # constraint_fun(xhat, u, v, w) + # + # is called at each point along the trajectory and compared against the + # upper and lower bounds. + # + # * If the upper and lower bound for the constraint are identical, then + # we separate out the evaluation into two different constraints, which + # allows the SciPy optimizers to be more efficient (and stops them + # from generating a warning about mixed constraints). This is handled + # through the use of the `_eqconst_function` and `eqconst_value` + # members. + # + # In both cases, the constraint is specified at a single point, but we + # extend this to apply to each point in the trajectory. This means + # that for N time points with m trajectory constraints and p terminal + # constraints we need to compute N*m + p constraints, each of which + # holds at a specific point in time, and implements the original + # constraint. + # + def _constraint_function(self, xvec): + # Compute the estimated states and disturbance inputs + xhat, u, v, w = self._compute_states_inputs(xvec) + + # + # Evaluate the constraint function along the trajectory + # + # TODO: vectorize + value = [] + for i, t in enumerate(self.timepts): + for ctype, fun, lb, ub in self.trajectory_constraints: + if np.all(lb == ub): + # Skip equality constraints + continue + elif ctype == opt.LinearConstraint: + # `fun` is the A matrix associated with the polytope... + value.append(fun @ np.hstack( + [xhat[:, i], u[:, i], v[:, i], w[:, i]])) + elif ctype == opt.NonlinearConstraint: + value.append(fun(xhat[:, i], u[:, i], v[:, i], w[:, i])) + else: # pragma: no cover + # Checked above => we should never get here + raise TypeError(f"unknown constraint type {ctype}") + + # Update statistics + self.constraint_evaluations += 1 + + # Return the value of the constraint function + return np.hstack(value) + + def _eqconst_function(self, xvec): + # Compute the estimated states and disturbance inputs + xhat, u, v, w = self._compute_states_inputs(xvec) + + # Evaluate the constraint function along the trajectory + # TODO: vectorize + value = [] + for i, t in enumerate(self.timepts): + for ctype, fun, lb, ub in self.trajectory_constraints: + if np.any(lb != ub): + # Skip inequality constraints + continue + elif ctype == opt.LinearConstraint: + # `fun` is the A matrix associated with the polytope... + value.append(fun @ np.hstack( + [xhat[:, i], u[:, i], v[:, i], w[:, i]])) + elif ctype == opt.NonlinearConstraint: + value.append(fun(xhat[:, i], u[:, i], v[:, i], w[:, i])) + else: # pragma: no cover + # Checked above => we should never get here + raise TypeError(f"unknown constraint type {ctype}") + + # Update statistics + self.eqconst_evaluations += 1 + + # Return the value of the constraint function + return np.hstack(value) + + def _collocation_constraint(self, xvec): + # Compute the estimated states and disturbance inputs + xhat, u, v, w = self._compute_states_inputs(xvec) + inputs = np.vstack([u, v]) + + if self.system.isctime(): + # Compute the collocation constraints + # TODO: vectorize + fk = self.system._rhs( + self.timepts[0], xhat[:, 0], inputs[:, 0]) + for i, t in enumerate(self.timepts[:-1]): + # From M. Kelly, SIAM Review (2017), equation (3.2), i = k+1 + # x[k+1] - x[k] = 0.5 hk (f(x[k+1], u[k+1] + f(x[k], u[k])) + fkp1 = self.system._rhs(t, xhat[:, i+1], inputs[:, i+1]) + self.colloc_vals[:, i] = xhat[:, i+1] - xhat[:, i] - \ + 0.5 * (self.timepts[i+1] - self.timepts[i]) * (fkp1 + fk) + fk = fkp1 + else: + # TODO: vectorize + for i, t in enumerate(self.timepts[:-1]): + # x[k+1] = f(x[k], u[k], v[k]) + self.colloc_vals[:, i] = xhat[:, i+1] - \ + self.system._rhs(t, xhat[:, i], inputs[:, i]) + + # Return the value of the constraint function + return self.colloc_vals.reshape(-1) + + # + # Initial guess processing + # + # TODO: Not implemented + # + def _process_initial_guess(self, initial_guess): + if initial_guess is None: + return np.zeros( + (self.system.nstates + self.ndisturbances) * self.timepts.size) + else: + # TODO: add dimension check + return np.hstack([ + initial_guess[0].reshape(-1), # estimated states + initial_guess[1].reshape(-1)]) # disturbances + + # + # Compute the states and inputs from the optimization parameter vector + # and the internally stored inputs and measured outputs. + # + # The optimization parameter vector has elements (xhat[0], ..., + # xhat[N-1], v[0], ..., v[N-2]) where N is the number of time + # points. The system inputs u and measured outputs y are locally + # stored in self.u and self.y when compute_estimate() is called. + # + def _compute_states_inputs(self, xvec): + # Extract the state estimate and disturbances + xhat = xvec[:self.system.nstates * self.timepts.size].reshape( + self.system.nstates, -1) + v = xvec[self.system.nstates * self.timepts.size:].reshape( + self.ndisturbances, -1) + + # Compute the estimated output + yhat = np.vstack([ + self.system._out(self.timepts[i], xhat[:, i], + np.hstack([self.u[:, i], v[:, i]])) + for i in range(self.timepts.size)]).T + + return xhat, self.u, v, self.y - yhat + + # + # Optimization statistics + # + # To allow some insight into where time is being spent, we keep track + # of the number of times that various functions are called and (TODO) + # how long we spent inside each function. + # + def _reset_statistics(self): + """Reset counters for keeping track of statistics""" + self.cost_evaluations, self.cost_process_time = 0, 0 + self.constraint_evaluations, self.constraint_process_time = 0, 0 + self.eqconst_evaluations, self.eqconst_process_time = 0, 0 + + def _print_statistics(self, reset=True): + """Print out summary statistics from last run""" + print("Summary statistics:") + print("* Cost function calls:", self.cost_evaluations) + if self.constraint_evaluations: + print("* Constraint calls:", self.constraint_evaluations) + if self.eqconst_evaluations: + print("* Eqconst calls:", self.eqconst_evaluations) + if reset: + self._reset_statistics() + + # + # Optimal estimate computations + # + + # Compute the optimal trajectory from the current state + def compute_estimate( + self, Y, U, X0=None, initial_guess=None, + squeeze=None, print_summary=True): + """Compute the optimal input at state x + + Parameters + ---------- + Y, U : 2D array + Measured outputs and applied inputs at each time point. + X0 : 1D array + Expected initial value of the state. + initial_guess : 2-tuple of 2D arrays + A 2-tuple consisting of the estimated states and disturbance + values to use as a guess for the optimal estimated trajectory. + squeeze : bool, optional + If True and if the system has a single disturbance input and + single measured output, return the system input and output as a + 1D array rather than a 2D array. If False, return the system + output as a 2D array even if the system is SISO. Default value + set by config.defaults['control.squeeze_time_response']. + print_summary : bool, optional + If `True` (default), print a short summary of the computation. + + Returns + ------- + res : OptimalEstimationResult + Bundle object with the results of the optimal estimation problem. + res.success: bool + Boolean flag indicating whether the optimization was successful. + res.time : array + Time values of the input (same as self.timepts). + res.inputs : array + Estimated disturbance inputs for the system trajectory. + res.states : array + Time evolution of the estimated state vector. + res.outputs: array + Estimated measurement noise for the system trajectory. + + """ + # Store the inputs and outputs (for use in _constraint_function) + self.u = np.atleast_1d(U).reshape(-1, self.timepts.size) + self.y = np.atleast_1d(Y).reshape(-1, self.timepts.size) + self.x0 = X0 + + # Figure out the number of disturbances + self.ndisturbances = self.system.ninputs - self.u.shape[0] + assert self.ndisturbances > 0 + + # Process the initial guess + initial_guess = self._process_initial_guess(initial_guess) + + # Call ScipPy optimizer + res = sp.optimize.minimize( + self._cost_function, initial_guess, + constraints=self.constraints, **self.minimize_kwargs) + + # Process and return the results + return OptimalEstimationResult( + self, res, squeeze=squeeze, print_summary=print_summary) + + + # + # Create an input/output system implementing an moving horizon estimator + # + # This function creates an input/output system that has internal state + # xhat, u, v, y for all previous time points. When the system update + # function is called, + def create_mhe_iosystem( + self, nd, output_labels='xhat[{i}]', sensor_labels=None): + """Create an I/O system implementing an MPC controller + + This function creates an input/output system that implements a + moving horizon estimator for a an optimal estimation problem. The + I/O system takes the system measurements and applied inputs as as + inputs and outputs the estimated state. + + Parameters + ---------- + sys : InputOutputSystem + I/O system for which the estimator will be computed. + + nd : int + Number of inputs that are disturbance (versus control) inputs. + The current implementation assumes that the inputs to `sys` are + the control inputs followed by `nd` disturbance inputs. + + Returns + ------- + estim : InputOutputSystem + An I/O system taking the measured output and applied input for + the model system and returning the estimated state of the + system, as determined by solving the optimal estimation problem. + + """ + # Check to make sure we are in discrete time + if self.system.dt == 0: + raise ct.ControlNotImplemented( + "MHE for continuous time systems not implemented") + + # Figure out the labels to use + if isinstance(output_labels, str): + # Generate labels using the argument as a format string + output_labels = [output_labels.format(i=i) + for i in range(self.system.nstates)] + + sensor_labels = 'y[{i}]' if sensor_labels is None else sensor_labels + if isinstance(sensor_labels, str): + # Generate labels using the argument as a format string + sensor_labels = [sensor_labels.format(i=i) + for i in range(self.system.noutputs - nd)] + + nstates = (self.system.nstates + self.system.ninputs + + self.system.noutputs) * self.timepts.size + + # Utility function to extract elements from MHE state vector + def _xvec_next(xvec, off, size): + len_ = size * self.timepts.size + return (off + len_, + xvec[off:off + len_].reshape(-1, self.timepts.size)) + + # Update function for the estimator + def _mhe_update(t, xvec, uvec, params={}): + # Inputs are the measurements and inputs + y = uvec[:self.system.noutputs].reshape(-1, 1) + u = uvec[self.system.noutputs:].reshape(-1, 1) + + # Estimator state = [xhat, v, Y, U] + off, xhat = _xvec_next(xvec, 0, self.system.nstates) + off, U = _xvec_next(xvec, off, self.system.ninputs - nd) + off, V = _xvec_next(xvec, off, nd) + off, Y = _xvec_next(xvec, off, self.system.noutputs) + + # Shift the states and add the new measurements and inputs + # TODO: look for Numpy shift() operator + xhat = np.hstack([xhat[:, 1:], xhat[:, -1:]]) + U = np.hstack([U[:, 1:], u]) + V = np.hstack([V[:, 1:], V[:, -1:]]) + Y = np.hstack([Y[:, 1:], y]) + + # Compute the new states and disturbances + est = self.compute_estimate( + Y, U, X0=xhat[:, 0], initial_guess=(xhat, V), + print_summary=False) + + # Restack the new state + return np.hstack([ + est.states.reshape(-1), U.reshape(-1), + est.inputs.reshape(-1), Y.reshape(-1)]) + + # Ouput function + def _mhe_output(t, xvec, uvec, params={}): + # Get the states and inputs + off, xhat = _xvec_next(xvec, 0, self.system.nstates) + off, u_v = _xvec_next(xvec, off, self.system.ninputs) + + # Compute the estimate at the next time point + return self.system._rhs(t, xhat[:, -1], u_v[:, -1]) + + return ct.NonlinearIOSystem( + _mhe_update, _mhe_output, states=nstates, + inputs=sensor_labels + self.system.input_labels, + outputs=output_labels, dt=self.system.dt) + + +# Optimal estimation result +class OptimalEstimationResult(sp.optimize.OptimizeResult): + """Result from solving an optimal estimationproblem. + + This class is a subclass of :class:`scipy.optimize.OptimizeResult` with + additional attributes associated with solving optimal estimation + problems. + + Attributes + ---------- + states : ndarray + Estimated state trajectory. + inputs : ndarray + The disturbances associated with the estimated state trajectory. + outputs : + The error between measured outputs and estiamted outputs. + success : bool + Whether or not the optimizer exited successful. + problem : OptimalControlProblem + Optimal control problem that generated this solution. + cost : float + Final cost of the return solution. + system_simulations, {cost, constraint, eqconst}_evaluations : int + Number of system simulations and evaluations of the cost function, + (inequality) constraint function, and equality constraint function + performed during the optimzation. + {cost, constraint, eqconst}_process_time : float + If logging was enabled, the amount of time spent evaluating the cost + and constraint functions. + + """ + def __init__( + self, oep, res, return_states=True, print_summary=False, + transpose=None, squeeze=None): + """Create a OptimalControlResult object""" + + # Copy all of the fields we were sent by sp.optimize.minimize() + for key, val in res.items(): + setattr(self, key, val) + + # Remember the optimal control problem that we solved + self.problem = oep + + # Parse the optimization variables into states and inputs + xhat, u, v, w = oep._compute_states_inputs(res.x) + + # See if we got an answer + if not res.success: + warnings.warn( + "unable to solve optimal control problem\n" + "scipy.optimize.minimize returned " + res.message, UserWarning) + + # Save the final cost + self.cost = res.fun + + # Optionally print summary information + if print_summary: + oep._print_statistics() + print("* Final cost:", self.cost) + + # Process data as a time response (with "outputs" = inputs) + response = ct.TimeResponseData( + oep.timepts, w, xhat, v, issiso=oep.system.issiso(), + squeeze=squeeze) + + self.time = response.time + self.inputs = response.inputs + self.states = response.states + self.outputs = response.outputs + + +# Compute the moving horizon estimate for a nonlinear system +def solve_oep( + sys, timepts, Y, U, trajectory_cost, X0=None, + trajectory_constraints=None, initial_guess=None, + squeeze=None, print_summary=True, **kwargs): + + """Compute the solution to a moving horizon estimation problem + + Parameters + ---------- + sys : InputOutputSystem + I/O system for which the optimal input will be computed. + + timepts : 1D array_like + List of times at which the optimal input should be computed. + + Y, U: 2D array_like + Values of the outputs and inputs at each time point. + + trajectory_cost : callable + Function that returns the cost given the current state + and input. Called as `cost(y, u, x0)`. + + X0: 1D array_like, optional + Mean value of the initial condition (defaults to 0). + + trajectory_constraints : list of tuples, optional + List of constraints that should hold at each point in the time vector. + See :func:`solve_ocp` for more information. + + initial_guess : 2D array_like, optional + Initial guess for the state estimate at each time point. + + print_summary : bool, optional + If `True` (default), print a short summary of the computation. + + squeeze : bool, optional + If True and if the system has a single output, return the system + output as a 1D array rather than a 2D array. If False, return the + system output as a 2D array even if the system is SISO. Default value + set by config.defaults['control.squeeze_time_response']. + + Returns + ------- + res : TimeResponseData + Bundle object with the estimated state and noise values. + + res.success : bool + Boolean flag indicating whether the optimization was successful. + + res.time : array + Time values of the input. + + res.inputs : array + Disturbance values corresponding to the estimated state. If the + system is SISO and squeeze is not True, the array is 1D (indexed by + time). If the system is not SISO or squeeze is False, the array is + 2D (indexed by the output number and time). + + res.states : array + Estimated state vector over the given time points. + + res.outputs : array + Noise values corresponding to the estimated state. If the system + is SISO and squeeze is not True, the array is 1D (indexed by time). + If the system is not SISO or squeeze is False, the array is 2D + (indexed by the output number and time). + + Notes + ----- + Additional keyword parameters can be used to fine tune the behavior of + the underlying optimization and integration functions. See + :func:`OptimalControlProblem` for more information. + + """ + # Set up the optimal control problem + oep = OptimalEstimationProblem( + sys, timepts, trajectory_cost, + trajectory_constraints=trajectory_constraints, **kwargs) + + # Solve for the optimal input from the current state + return oep.compute_estimate( + Y, U, X0=X0, initial_guess=initial_guess, + squeeze=squeeze, print_summary=print_summary) + + # # Functions to create cost functions (quadratic cost function) # @@ -1202,6 +1926,53 @@ def quadratic_cost(sys, Q, R, x0=0, u0=0): return lambda x, u: ((x-x0) @ Q @ (x-x0) + (u-u0) @ R @ (u-u0)).item() +def gaussian_likelihood_cost(sys, Rv, Rw=None): + """Create cost function for Gaussian likelihoods + + Returns a quadratic cost function that can be used for an optimal + estimation problem. The cost function is of the form + + cost = v^T R_v^{-1} v + w^T R_w^{-1} w + + Parameters + ---------- + sys : InputOutputSystem + I/O system for which the cost function is being defined. + Rv : 2D array_like + Covariance matrix for input (or state) disturbances. + Rw : 2D array_like + Covariance matrix for sensor noise. + + Returns + ------- + cost_fun : callable + Function that can be used to evaluate the cost for a given + disturbance and sensor noise. The call signature of the function + is cost_fun(v, w). + + """ + # Process the input arguments + if Rv is not None: + Rv = np.atleast_2d(Rv) + + if Rw is not None: + Rw = np.atleast_2d(Rw) + if Rw.size == 1: # allow scalar weights + Rw = np.eye(sys.noutputs) * Rw.item() + elif Rw.shape != (sys.noutputs, sys.noutputs): + raise ValueError("Rw matrix is the wrong shape") + + if Rv is None: + return lambda xhat, u, v, w: (w @ np.linalg.inv(Rw) @ w).item() + + if Rw is None: + return lambda xhat, u, v, w: (v @ np.linalg.inv(Rv) @ v).item() + + # Received both Rv and Rw matrices + return lambda xhat, u, v, w: \ + (v @ np.linalg.inv(Rv) @ v + w @ np.linalg.inv(Rw) @ w).item() + + # # Functions to create constraints: either polytopes (A x <= b) or ranges # (lb # <= x <= ub). @@ -1253,7 +2024,7 @@ def state_poly_constraint(sys, A, b): def state_range_constraint(sys, lb, ub): - """Create state constraint from polytope + """Create state constraint from range Creates a linear constraint on the system state that bounds the range of the individual states to be between `lb` and `ub`. The upper and lower @@ -1450,6 +2221,46 @@ def _evaluate_output_range_constraint(x, u): # Return a nonlinear constraint object based on the polynomial return (opt.NonlinearConstraint, _evaluate_output_range_constraint, lb, ub) +# +# Create a constraint on the disturbance input +# + +def disturbance_range_constraint(sys, lb, ub): + """Create constraint for bounded disturbances + + This function computes a constraint that puts a bound on the size of + input disturbances. The output of this function can be passed as a + trajectory constraint for optimal estimation problems. + + Parameters + ---------- + sys : InputOutputSystem + I/O system for which the constraint is being defined. + lb : 1D array + Lower bound for each of the disturbancs. + ub : 1D array + Upper bound for each of the disturbances. + + Returns + ------- + constraint : tuple + A tuple consisting of the constraint type and parameter values. + + """ + # Convert bounds to lists and make sure they are the right dimension + lb = np.atleast_1d(lb).reshape(-1) + ub = np.atleast_1d(ub).reshape(-1) + if lb.shape != ub.shape: + raise ValueError("upper and lower bound shapes must match") + ndisturbances = lb.size + + # Generate a linear constraint on the input disturbances + xvec_len = sys.nstates + sys.ninputs + sys.noutputs + A = np.zeros((ndisturbances, xvec_len)) + A[:, sys.nstates + sys.ninputs - ndisturbances:-sys.noutputs] = \ + np.eye(ndisturbances) + return opt.LinearConstraint(A, lb, ub) + # # Utility functions # @@ -1466,7 +2277,9 @@ def _evaluate_output_range_constraint(x, u): # first element. # def _process_constraints(clist, name): - if isinstance( + if clist is None: + clist = [] + elif isinstance( clist, (tuple, opt.LinearConstraint, opt.NonlinearConstraint)): clist = [clist] elif not isinstance(clist, list): diff --git a/control/stochsys.py b/control/stochsys.py index 000c1b6ab..fede887f3 100644 --- a/control/stochsys.py +++ b/control/stochsys.py @@ -354,8 +354,8 @@ def create_estimator_iosystem( Disturbance matrix describing how the disturbances enters the dynamics. Defaults to sys.B. C : ndarray, optional - If the system has all full states output, define the measured values - to be used by the estimator. Otherwise, use the system output as the + If the system has full state output, define the measured values to + be used by the estimator. Otherwise, use the system output as the measured values. {state, covariance, sensor, output}_labels : str or list of str, optional Set the name of the signals to use for the internal state, covariance, diff --git a/control/tests/kwargs_test.py b/control/tests/kwargs_test.py index fe4e67aaa..be701b177 100644 --- a/control/tests/kwargs_test.py +++ b/control/tests/kwargs_test.py @@ -196,6 +196,7 @@ def test_matplotlib_kwargs(function, nsysargs, moreargs, kwargs, mplcleanup): flatsys_test.TestFlatSys.test_solve_flat_ocp_errors, 'optimal.create_mpc_iosystem': optimal_test.test_mpc_iosystem_rename, 'optimal.solve_ocp': optimal_test.test_ocp_argument_errors, + 'optimal.solve_oep': optimal_test.test_oep_argument_errors, 'FrequencyResponseData.__init__': frd_test.TestFRD.test_unrecognized_keyword, 'InputOutputSystem.__init__': test_unrecognized_kwargs, @@ -217,7 +218,9 @@ def test_matplotlib_kwargs(function, nsysargs, moreargs, kwargs, mplcleanup): 'optimal.OptimalControlProblem.compute_trajectory': optimal_test.test_ocp_argument_errors, 'optimal.OptimalControlProblem.create_mpc_iosystem': - optimal_test.test_mpc_iosystem_rename, + optimal_test.test_ocp_argument_errors, + 'optimal.OptimalEstimationProblem.__init__': + optimal_test.test_oep_argument_errors, } # @@ -234,9 +237,6 @@ def test_matplotlib_kwargs(function, nsysargs, moreargs, kwargs, mplcleanup): control.freqplot._add_arrows_to_line2D, # RMM, 18 Nov 2022 control.namedio._process_dt_keyword, # RMM, 13 Nov 2022 control.namedio._process_namedio_keywords, # RMM, 18 Nov 2022 - control.optimal.OptimalControlProblem.__init__, # RMM, 18 Nov 2022 - control.optimal.solve_ocp, # RMM, 18 Nov 2022 - control.optimal.create_mpc_iosystem, # RMM, 18 Nov 2022 } @pytest.mark.parametrize("module", [control, control.flatsys]) diff --git a/control/tests/optimal_test.py b/control/tests/optimal_test.py index be7cbf2db..cbfa4e649 100644 --- a/control/tests/optimal_test.py +++ b/control/tests/optimal_test.py @@ -529,7 +529,7 @@ def test_ocp_argument_errors(): with pytest.raises(TypeError, match="unrecognized keyword"): ocp = opt.OptimalControlProblem(sys, time, cost, constraints) ocp.compute_trajectory(x0, unknown=None) - + # Unrecognized trajectory constraint type constraints = [(None, np.eye(3), [0, 0, 0], [0, 0, 0])] with pytest.raises(TypeError, match="unknown trajectory constraint type"): @@ -771,3 +771,18 @@ def vehicle_output(t, x, u, params): np.testing.assert_almost_equal(y[:,-1], xf, decimal=1) else: np.testing.assert_almost_equal(y[:,-1], xf, decimal=1) + + +def test_oep_argument_errors(): + sys = ct.rss(4, 2, 2) + timepts = np.linspace(0, 1, 10) + Y = np.zeros((2, timepts.size)) + U = np.zeros_like(timepts) + cost = opt.gaussian_likelihood_cost(sys, np.eye(1), np.eye(2)) + + # Unrecognized arguments + with pytest.raises(TypeError, match="unrecognized keyword"): + res = opt.solve_oep(sys, timepts, Y, U, cost, unknown=True) + + with pytest.raises(TypeError, match="unrecognized keyword"): + oep = opt.OptimalEstimationProblem(sys, timepts, cost, unknown=True) diff --git a/control/tests/stochsys_test.py b/control/tests/stochsys_test.py index 75e5a510c..4366f4f15 100644 --- a/control/tests/stochsys_test.py +++ b/control/tests/stochsys_test.py @@ -6,6 +6,7 @@ from control.tests.conftest import asmatarrayout import control as ct +import control.optimal as opt from control import lqe, dlqe, rss, drss, tf, ss, ControlArgument, slycot_check from math import log, pi @@ -317,3 +318,180 @@ def test_correlation(): with pytest.raises(ValueError, match="Time values must be equally"): T = np.logspace(0, 2, T.size) tau, Rtau = ct.correlation(T, V) + +@pytest.mark.parametrize('dt', [0, 1]) +def test_oep(dt): + # Define the system to test, with additional input + csys = ct.ss( + [[-0.5, 1, 0, 0], [0, -1, 1, 0], [0, 0, -2, 1], [0, 0, 0, -3]], # A + [[0, 0.1], [0, 0.1], [0, 0.1], [1, 0.1]], # B + [[1, 0, 0, 0], [0, 0, 1, 0]], # C + 0, dt=0) + dsys = ct.c2d(csys, dt) + sys = csys if dt == 0 else dsys + + # Create disturbances and noise (fixed, to avoid random errors) + Rv = 0.1 * np.eye(1) # scalar disturbance + Rw = 0.01 * np.eye(sys.noutputs) + timepts = np.arange(0, 10.1, 1) + V = np.array( + [0 if t % 2 == 1 else 1 if t % 4 == 0 else -1 for t in timepts] + ).reshape(1, -1) * 0.1 + W = np.vstack([np.sin(2*timepts), np.cos(3*timepts)]) * 1e-3 + + # Generate system data + U = np.sin(timepts) + + # No disturbances + res0 = ct.input_output_response(sys, timepts, [U, V*0]) + Y0 = res0.outputs + + # With disturbances and noise + res1 = ct.input_output_response(sys, timepts, [U, V]) + Y1 = res1.outputs + W + + # + # Internal testing to make sure all our functions are OK + # + + # Set up optimal estimation function using Gaussian likelihoods for cost + traj_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw) + init_cost = lambda xhat, x: (xhat - x) @ (xhat - x) + oep = opt.OptimalEstimationProblem( + sys, timepts, traj_cost, terminal_cost=init_cost) + + # _cost_function + oep.compute_estimate(res0.outputs, U, X0=0) + assert oep._cost_function(np.hstack( + [res0.states.reshape(-1), V.reshape(-1) * 0])) == 0 + assert oep._cost_function(np.hstack( + [res0.states.reshape(-1), V.reshape(-1)])) != 0 + if sys.isdtime(): + # Collocation contstraint should be satisified for discrete time + np.testing.assert_allclose(oep._collocation_constraint( + np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])), 0) + + # _compute_states_inputs: states and inputs with no noise + oep.compute_estimate(Y0, U) + xhat, u, v, w = oep._compute_states_inputs( + np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])) + np.testing.assert_allclose(xhat, res0.states) + np.testing.assert_allclose(u, U.reshape(1, -1)) + np.testing.assert_allclose(v, 0) + np.testing.assert_allclose(w, 0) + + # _compute_states_inputs: states and inputs with no noise + oep.compute_estimate(Y1, U) + xhat, u, v, w = oep._compute_states_inputs( + np.hstack([res1.states.reshape(-1), V.reshape(-1)])) + np.testing.assert_allclose(xhat, res1.states) + np.testing.assert_allclose(u, U.reshape(1, -1)) + np.testing.assert_allclose(v, V) + np.testing.assert_allclose(w, W) + + # + # oep.compute_estimate testing + # + + # Noise free and disturbance free + nonoise_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw/1e6) + oep0 = opt.OptimalEstimationProblem( + sys, timepts, nonoise_cost, terminal_cost=init_cost) + est0 = oep0.compute_estimate(Y0, U) + if sys.isdtime(): + # Full state estimate should be near perfect + np.testing.assert_allclose( + est0.states[:, -1], res0.states[:, -1], atol=1e-3, rtol=1e-3) + np.testing.assert_allclose(est0.inputs, 0, atol=1e-2, rtol=1e-3) + np.testing.assert_allclose(est0.outputs, 0, atol=1e-2, rtol=1e-3) + else: + # Estimate at end of trajectory should be very close + assert est0.success + np.testing.assert_allclose( + est0.states[:, -1], res0.states[:, -1], atol=1e-2, rtol=1e-2) + + # Noise free, but with disturbances and good initial guess + oep1 = opt.OptimalEstimationProblem( + sys, timepts, nonoise_cost, terminal_cost=init_cost) + est1 = oep1.compute_estimate( + res1.outputs, U, initial_guess=(res1.states, V), X0=0) + np.testing.assert_allclose( + est1.states[:, -1], res1.states[:, -1], atol=1e-2, rtol=1e-2) + if sys.isdtime(): + # For discrete time, estimated disturbance and noise should be close + np.testing.assert_allclose( + est1.inputs[:-1], V[:-1], atol=1e-2, rtol=1e-2) + np.testing.assert_allclose(est1.outputs, 0, atol=1e-2, rtol=1e-2) + + # Noise and disturbances (the standard case) + est2 = oep.compute_estimate(Y1, U) # back to original OEP + assert est2.success + np.testing.assert_allclose( + est2.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) + + # + # Disturbance constraints + # + + V3 = np.clip(V, 0.5, 1) + traj_constraint = opt.disturbance_range_constraint(sys, 0.5, 1) + oep3 = opt.OptimalEstimationProblem( + sys, timepts, traj_cost, terminal_cost=init_cost, + trajectory_constraints=traj_constraint) + + res3 = ct.input_output_response(sys, timepts, [U, V3]) + Y3 = res3.outputs + W + + # Make sure the constraint screws up the estimation problem + with pytest.raises(AssertionError): + est3 = oep.compute_estimate(Y3, U) + np.testing.assert_allclose( + est3.states[:, -1], res3.states[:, -1], atol=1e-1, rtol=1e-2) + + # Make sure estimation is correct with constraint in place + est3 = oep3.compute_estimate(Y3, U) + assert est3.success + np.testing.assert_allclose( + est3.states[:, -1], res3.states[:, -1], atol=1e-1, rtol=1e-2) + + +def test_mhe(): + # Define the system to test, with additional input + csys = ct.ss( + [[-0.5, 1, 0, 0], [0, -1, 1, 0], [0, 0, -2, 1], [0, 0, 0, -3]], # A + [[0, 0.1], [0, 0.1], [0, 0.1], [1, 0.1]], # B + [[1, 0, 0, 0], [0, 0, 1, 0]], # C + 0, dt=0) + dt = 0.1 + sys = ct.c2d(csys, dt) + + # Create disturbances and noise (fixed, to avoid random errors) + Rv = 0.1 * np.eye(1) # scalar disturbance + Rw = 1e-6 * np.eye(sys.noutputs) + P0 = 0.1 * np.eye(sys.nstates) + + timepts = np.arange(0, 10*dt, dt) + mhe_timepts = np.arange(0, 5*dt, dt) + V = np.array( + [0 if i % 2 == 1 else 1 if i % 4 == 0 else -1 + for i, t in enumerate(timepts)]).reshape(1, -1) * 0.1 + W = np.sin(timepts / dt) * 1e-3 + + # Create a moving horizon estimator + traj_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw) + init_cost = lambda xhat, x: (xhat - x) @ P0 @ (xhat - x) + oep = opt.OptimalEstimationProblem( + sys, mhe_timepts, traj_cost, terminal_cost=init_cost) + mhe = oep.create_mhe_iosystem(1) + + # Generate system data + U = 10 * np.sin(timepts / (4*dt)) + inputs = np.vstack([U, V]) + resp = ct.input_output_response(sys, timepts, inputs) + + # Run the estimator + estp = ct.input_output_response( + mhe, timepts, [resp.outputs, resp.inputs[0:1]]) + + # Make sure the estimated state is close to the actual state + np.testing.assert_allclose(estp.outputs, resp.states, atol=1e-2, rtol=1e-4) diff --git a/doc/conf.py b/doc/conf.py index e2e420104..02b55820b 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -127,7 +127,10 @@ # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -# html_static_path = ['_static'] + +html_static_path = ['_static'] +def setup(app): + app.add_css_file('css/custom.css') # Custom sidebar templates, must be a dictionary that maps document names # to template names. diff --git a/doc/optimal.rst b/doc/optimal.rst index 807b9b9c6..0e9dd3aa5 100644 --- a/doc/optimal.rst +++ b/doc/optimal.rst @@ -1,22 +1,22 @@ .. _optimal-module: -*************** -Optimal control -*************** +************************** +Optimization-based control +************************** .. automodule:: control.optimal :no-members: :no-inherited-members: :no-special-members: -Problem setup -============= +Optimal control problem setup +============================= Consider the *optimal control problem*: .. math:: - \min_{u(\cdot)} + \min_{u(\cdot)} \int_0^T L(x,u)\, dt + V \bigl( x(T) \bigr) subject to the constraint @@ -44,7 +44,7 @@ denoted :math:`x_\text{f}`, be specified. We can do this by requiring that :math:`x(T) = x_\text{f}` or by using a more general form of constraint: .. math:: - + \psi_i(x(T)) = 0, \qquad i = 1, \dots, q. The fully constrained case is obtained by setting :math:`q = n` and defining @@ -56,7 +56,7 @@ Finally, we may wish to consider optimizations in which either the state or the inputs are constrained by a set of nonlinear functions of the form .. math:: - + \text{lb}_i \leq g_i(x, u) \leq \text{ub}_i, \qquad i = 1, \dots, k. where :math:`\text{lb}_i` and :math:`\text{ub}_i` represent lower and upper @@ -91,15 +91,119 @@ extending our horizon by an additional :math:`\Delta T` units of time. This approach can be shown to generate stabilizing control laws under suitable conditions (see, for example, the FBS2e supplement on `Optimization-Based Control `_. - + +Optimal estimation problem setup +================================ + +Consider a nonlinear system with discrete time dynamics of the form + +.. math:: + :label: eq_fusion_nlsys-oep + + X[k+1] = f(X[k], u[k], V[k]), \qquad Y[k] = h(X[k]) + W[k], + +where :math:`X[k] \in \mathbb{R}^n`, :math:`u[k] \in \mathbb{R}^m`, and +:math:`Y[k] \in \mathbb{R}^p`, and :math:`V[k] \in \mathbb{R}^q` and +:math:`W[k] \in \mathbb{R}^p` represent random processes that are not +necessarily Gaussian white noise processes. The estimation problem that we +wish to solve is to find the estimate :math:`\hat x[\cdot]` that matches +the measured outputs :math:`y[\cdot]` with "likely" disturbances and +noise. + +For a fixed horizon of length :math:`N`, this problem can be formulated as +an optimization problem where we define the likelihood of a given estimate +(and the resulting noise and disturbances predicted by the model) as a cost +function. Suppose we model the likelihood using a conditional probability +density function :math:`p(x[0], \dots, x[N] \mid y[0], \dots, y[N-1])`. +Then we can pose the state estimation problem as + +.. math:: + :label: eq_fusion_oep + + \hat x[0], \dots, \hat x[N] = + \arg \max_{\hat x[0], \dots, \hat x[N]} + p(\hat x[0], \dots, \hat x[N] \mid y[0], \dots, y[N-1]) + +subject to the constraints given by equation :eq:`eq_fusion_nlsys-oep`. +The result of this optimization gives us the estimated state for the +previous :math:`N` steps in time, including the "current" time +:math:`x[N]`. The basic idea is thus to compute the state estimate that is +most consistent with our model and penalize the noise and disturbances +according to how likely the are (based on a some sort of stochastic system +model for each). + +Given a solution to this fixed horizon, optimal estimation problem, we can +create an estimator for the state over all times by applying repeatedly +applying the optimization problem :eq:`eq_fusion_oep` over a moving +horizon. At each time :math:`k`, we take the measurements for the last +:math:`N` time steps along with the previously estimated state at the start +of the horizon, :math:`x[k-N]` and reapply the optimization in equation +:eq:`eq_fusion_oep`. This approach is known as a \define{moving horizon +estimator} (MHE). + +The formulation for the moving horizon estimation problem is very general +and various situations can be captured using the conditional probability +function :math:`p(x[0], \dots, x[N] \mid y[0], \dots, y[N-1]`. We start by +noting that if the disturbances are independent of the underlying states of +the system, we can write the conditional probability as + +.. math:: + + p \bigl(x[0], \dots, x[N] \mid y[0], \dots, y[N-1]\bigr) = + p_{X[0]}(x[0])\, \prod_{k=0}^{N-1} p_V\bigl(y[k] - h(x[k])\bigr)\, + p\bigl(x[k+1] \mid x[k]\bigr). + +This expression can be further simplified by taking the log of the +expression and maximizing the function + +.. math:: + :label: eq_fusion_log-likelihood + + \log p_{X[0]}(x[0]) + \sum_{k=0}^{N-1} \log + p_W \bigl(y[k] - h(x[k])\bigr) + \log p_V(v[k]). + +The first term represents the likelihood of the initial state, the +second term captures the likelihood of the noise signal, and the final +term captures the likelihood of the disturbances. + +If we return to the case where :math:`V` and :math:`W` are modeled as +Gaussian processes, then it can be shown that maximizing equation +:eq:`eq_fusion_log-likelihood` is equivalent to solving the optimization +problem given by + +.. math:: + :label: eq_fusion_oep-gaussian + + \min_{x[0], \{v[0], \dots, v[N-1]\}} + \|x[0] - \bar x[0]\|_{P_0^{-1}} + \sum_{k=0}^{N-1} + \|y[k] - h(x_k)\|_{R_W^{-1}}^2 + + \|v[k] \|_{R_V^{-1}}^2, + +where :math:`P_0`, :math:`R_V`, and :math:`R_W` are the covariances of the +initial state, disturbances, and measurement noise. + +Note that while the optimization is carried out only over the estimated +initial state :math:`\hat x[0]`, the entire history of estimated states can +be reconstructed using the system dynamics: + +.. math:: + + \hat x[k+1] = f(\hat x[k], u[k], v[k]), \quad k = 0, \dots, N-1. + +In particular, we can obtain the estimated state at the end of the moving +horizon window, corresponding to the current time, and we can thus +implement an estimator by repeatedly solving the optimization of a window +of length :math:`N` backwards in time. + Module usage ============ -The optimal control module provides a means of computing optimal -trajectories for nonlinear systems and implementing optimization-based -controllers, including model predictive control. It follows the basic -problem setup described above, but carries out all computations in *discrete -time* (so that integrals become sums) and over a *finite horizon*. To local +The optimization-based control module provides a means of computing +optimal trajectories for nonlinear systems and implementing +optimization-based controllers, including model predictive control and +moving horizon estimation. It follows the basic problem setups +described above, but carries out all computations in *discrete time* +(so that integrals become sums) and over a *finite horizon*. To local the optimal control modules, import `control.optimal`: import control.optimal as obc @@ -163,7 +267,8 @@ In addition, the results from :func:`scipy.optimize.minimize` are also available. To simplify the specification of cost functions and constraints, the -:mod:`~control.ios` module defines a number of utility functions: +:mod:`~control.ios` module defines a number of utility functions for +optimal control problems: .. autosummary:: @@ -175,6 +280,33 @@ To simplify the specification of cost functions and constraints, the ~control.optimal.state_poly_constraint ~control.optimal.state_range_constraint +The optimization-based control module also implements functions for solving +optimal estimation problems. The +:class:`~control.optimal.OptimalEstimationProblem` class is used to define +an optimal estimation problem over a finite horizon:: + + oep = OptimalEstimationProblem(sys, timepts, cost[, constraints]) + +Given noisy measurements :math:`y` and control inputs :math:`u`, an +estimate of the states over the time points can be computed using the +:func:`~control.optimal.OptimalEstimationProblem.compute_estimate` method:: + + estim = oep.compute_optimal(Y, U[, X0=x0, initial_guess=(xhat, v)]) + xhat, v, w = estim.states, estim.inputs, estim.outputs + +For discrete time systems, the +:func:`~control.optimal.OptimalEstimationProblem.compute_estimate` method +can be used to generate an input/output system that implements a moving +horizon estimator. + +Several functions are available to help set up standard optimal estimation +problems: + +.. autosummary:: + + ~control.optimal.gaussian_likelihood_cost + ~control.optimal.disturbance_range_constraint + Example ======= @@ -329,15 +461,20 @@ Module classes and functions ~control.optimal.OptimalControlProblem ~control.optimal.OptimalControlResult + ~control.optimal.OptimalEstimationProblem + ~control.optimal.OptimalEstimationResult .. autosummary:: :toctree: generated/ - ~control.optimal.solve_ocp ~control.optimal.create_mpc_iosystem + ~control.optimal.disturbance_range_constraint + ~control.optimal.gaussian_likelihood_cost ~control.optimal.input_poly_constraint ~control.optimal.input_range_constraint ~control.optimal.output_poly_constraint ~control.optimal.output_range_constraint + ~control.optimal.quadratic_cost + ~control.optimal.solve_ocp ~control.optimal.state_poly_constraint ~control.optimal.state_range_constraint From bd7ba6debf030b4b15e89883e515e45a52ee7398 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 5 Mar 2023 22:29:06 -0800 Subject: [PATCH 04/14] updated documentation + Jupyter notebook --- .gitignore | 1 + control/optimal.py | 8 +- control/stochsys.py | 11 +- doc/.gitignore | 1 + doc/examples.rst | 1 + doc/mhe-pvtol.ipynb | 1 + doc/pvtol.py | 1 + examples/mhe-pvtol.ipynb | 679 +++++++++++++++++++++++++++++++++ examples/pvtol-outputfbk.ipynb | 26 +- examples/pvtol.py | 58 ++- 10 files changed, 737 insertions(+), 50 deletions(-) create mode 120000 doc/mhe-pvtol.ipynb create mode 120000 doc/pvtol.py create mode 100644 examples/mhe-pvtol.ipynb diff --git a/.gitignore b/.gitignore index 3ac21ae97..1b10a3585 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ *.pyc +__pycache__/ build/ dist/ htmlcov/ diff --git a/control/optimal.py b/control/optimal.py index 12e0d43ba..db238724b 100644 --- a/control/optimal.py +++ b/control/optimal.py @@ -1479,8 +1479,6 @@ def _collocation_constraint(self, xvec): # # Initial guess processing # - # TODO: Not implemented - # def _process_initial_guess(self, initial_guess): if initial_guess is None: return np.zeros( @@ -1542,8 +1540,6 @@ def _print_statistics(self, reset=True): # # Optimal estimate computations # - - # Compute the optimal trajectory from the current state def compute_estimate( self, Y, U, X0=None, initial_guess=None, squeeze=None, print_summary=True): @@ -1611,6 +1607,10 @@ def compute_estimate( # This function creates an input/output system that has internal state # xhat, u, v, y for all previous time points. When the system update # function is called, + # + # TODO: change input arguments to use control_indices, similar to + # create_statefbk_iosystem. + # def create_mhe_iosystem( self, nd, output_labels='xhat[{i}]', sensor_labels=None): """Create an I/O system implementing an MPC controller diff --git a/control/stochsys.py b/control/stochsys.py index fede887f3..5ff4bb2bd 100644 --- a/control/stochsys.py +++ b/control/stochsys.py @@ -307,6 +307,11 @@ def dlqe(*args, **kwargs): # Function to create an estimator +# +# TODO: add `control_indices` keyword to match create_mhe_iosystem (?) +# TODO: change name to create_kalmanestimaor_iosystem (?) +# TODO: create predictor/corrector, UKF, and other variants (?) +# def create_estimator_iosystem( sys, QN, RN, P0=None, G=None, C=None, state_labels='xhat[{i}]', output_labels='xhat[{i}]', @@ -317,15 +322,15 @@ def create_estimator_iosystem( continuous time state estimator of the form .. math:: - + d \hat{x}/dt &= A \hat{x} + B u - L (C \hat{x} - y) \\ dP/dt &= A P + P A^T + F Q_N F^T - P C^T R_N^{-1} C P \\ - L &= P C^T R_N^{-1} + L &= P C^T R_N^{-1} or a discrete time state estimator of the form .. math:: - + \hat{x}[k+1] &= A \hat{x}[k] + B u[k] - L (C \hat{x}[k] - y[k]) \\ P[k+1] &= A P A^T + F Q_N F^T - A P C^T R_e^{-1} C P A \\ L &= A P C^T R_e^{-1} diff --git a/doc/.gitignore b/doc/.gitignore index d948f64d2..38303de2b 100644 --- a/doc/.gitignore +++ b/doc/.gitignore @@ -1 +1,2 @@ *.fig.bak +_static/ diff --git a/doc/examples.rst b/doc/examples.rst index 0f23576bd..a7ddfacde 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -45,6 +45,7 @@ using running examples in FBS2e. cruise describing_functions kincar-fusion + mhe-pvtol mpc_aircraft steering pvtol-lqr-nested diff --git a/doc/mhe-pvtol.ipynb b/doc/mhe-pvtol.ipynb new file mode 120000 index 000000000..1efa2b5c9 --- /dev/null +++ b/doc/mhe-pvtol.ipynb @@ -0,0 +1 @@ +../examples/mhe-pvtol.ipynb \ No newline at end of file diff --git a/doc/pvtol.py b/doc/pvtol.py new file mode 120000 index 000000000..76dd7bdc0 --- /dev/null +++ b/doc/pvtol.py @@ -0,0 +1 @@ +../examples/pvtol.py \ No newline at end of file diff --git a/examples/mhe-pvtol.ipynb b/examples/mhe-pvtol.ipynb new file mode 100644 index 000000000..2295fc094 --- /dev/null +++ b/examples/mhe-pvtol.ipynb @@ -0,0 +1,679 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "baba5fab", + "metadata": {}, + "source": [ + "# Moving Horizon Estimation\n", + "\n", + "Richard M. Murray, 24 Feb 2023\n", + "\n", + "In this notebook we illustrate the implementation of moving horizon estimation (MHE)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "36715c5f", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import scipy as sp\n", + "import matplotlib.pyplot as plt\n", + "import control as ct\n", + "\n", + "import control.optimal as opt\n", + "import control.flatsys as fs" + ] + }, + { + "cell_type": "markdown", + "id": "d72a155b", + "metadata": {}, + "source": [ + "## System Description\n", + "\n", + "The dynamics of the system\n", + "with disturbances on the $x$ and $y$ variables is given by\n", + "\n", + "$$\n", + " \\begin{aligned}\n", + " m \\ddot x &= F_1 \\cos\\theta - F_2 \\sin\\theta - c \\dot x + d_x, \\\\\n", + " m \\ddot y &= F_1 \\sin\\theta + F_2 \\cos\\theta - c \\dot y - m g + d_y, \\\\\n", + " J \\ddot \\theta &= r F_1.\n", + " \\end{aligned}\n", + "$$\n", + "\n", + "The measured values of the system are the position and orientation,\n", + "with added noise $n_x$, $n_y$, and $n_\\theta$:\n", + "\n", + "$$\n", + " \\vec y = \\begin{bmatrix} x \\\\ y \\\\ \\theta \\end{bmatrix} + \n", + " \\begin{bmatrix} n_x \\\\ n_y \\\\ n_z \\end{bmatrix}.\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08919988", + "metadata": {}, + "outputs": [], + "source": [ + "# pvtol = nominal system (no disturbances or noise)\n", + "# noisy_pvtol = pvtol w/ process disturbances and sensor noise\n", + "from pvtol import pvtol, pvtol_noisy, plot_results\n", + "import pvtol as pvt\n", + "\n", + "# Find the equiblirum point corresponding to the origin\n", + "xe, ue = ct.find_eqpt(\n", + " pvtol, np.zeros(pvtol.nstates),\n", + " np.zeros(pvtol.ninputs), [0, 0, 0, 0, 0, 0],\n", + " iu=range(2, pvtol.ninputs), iy=[0, 1])\n", + "\n", + "# Initial condition = 2 meters right, 1 meter up\n", + "x0, u0 = ct.find_eqpt(\n", + " pvtol, np.zeros(pvtol.nstates),\n", + " np.zeros(pvtol.ninputs), np.array([2, 1, 0, 0, 0, 0]),\n", + " iu=range(2, pvtol.ninputs), iy=[0, 1])\n", + "\n", + "# Extract the linearization for use in LQR design\n", + "pvtol_lin = pvtol.linearize(xe, ue)\n", + "A, B = pvtol_lin.A, pvtol_lin.B\n", + "\n", + "print(pvtol, \"\\n\")\n", + "print(pvtol_noisy)" + ] + }, + { + "cell_type": "markdown", + "id": "5771ab93", + "metadata": {}, + "source": [ + "### Control Design" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2e88938", + "metadata": {}, + "outputs": [], + "source": [ + "#\n", + "# LQR design w/ physically motivated weighting\n", + "#\n", + "# Shoot for 10 cm error in x, 10 cm error in y. Try to keep the angle\n", + "# less than 5 degrees in making the adjustments. Penalize side forces\n", + "# due to loss in efficiency.\n", + "#\n", + "\n", + "Qx = np.diag([100, 10, (180/np.pi) / 5, 0, 0, 0])\n", + "Qu = np.diag([10, 1])\n", + "K, _, _ = ct.lqr(A, B, Qx, Qu)\n", + "\n", + "# Compute the full state feedback solution\n", + "lqr_ctrl, _ = ct.create_statefbk_iosystem(pvtol, K)\n", + "\n", + "# Define the closed loop system that will be used to generate trajectories\n", + "lqr_clsys = ct.interconnect(\n", + " [pvtol_noisy, lqr_ctrl],\n", + " inplist = lqr_ctrl.input_labels[0:pvtol.ninputs + pvtol.nstates] + \\\n", + " pvtol_noisy.input_labels[pvtol.ninputs:],\n", + " inputs = lqr_ctrl.input_labels[0:pvtol.ninputs + pvtol.nstates] + \\\n", + " pvtol_noisy.input_labels[pvtol.ninputs:],\n", + " outlist = pvtol.output_labels + lqr_ctrl.output_labels,\n", + " outputs = pvtol.output_labels + lqr_ctrl.output_labels\n", + ")\n", + "print(lqr_clsys)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "78853391", + "metadata": {}, + "outputs": [], + "source": [ + "# Disturbance and noise intensities\n", + "Qv = np.diag([1e-2, 1e-2])\n", + "Qw = np.array([[1e-4, 0, 1e-5], [0, 1e-4, 1e-5], [1e-5, 1e-5, 1e-4]])\n", + "\n", + "# Initial state covariance\n", + "P0 = np.eye(pvtol.nstates)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c590fd88", + "metadata": {}, + "outputs": [], + "source": [ + "# Create the time vector for the simulation\n", + "Tf = 6\n", + "timepts = np.linspace(0, Tf, 20)\n", + "\n", + "# Create representative process disturbance and sensor noise vectors\n", + "# np.random.seed(117) # avoid figures changing from run to run\n", + "V = ct.white_noise(timepts, Qv)\n", + "# V = np.clip(V0, -0.1, 0.1) # Hold for later\n", + "W = ct.white_noise(timepts, Qw)\n", + "# plt.plot(timepts, V0[0], 'b--', label=\"V[0]\")\n", + "plt.plot(timepts, V[0], label=\"V[0]\")\n", + "plt.plot(timepts, W[0], label=\"W[0]\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c35fd695", + "metadata": {}, + "outputs": [], + "source": [ + "# Desired trajectory\n", + "xd, ud = xe, ue\n", + "# xd = np.vstack([\n", + "# np.sin(2 * np.pi * timepts / timepts[-1]), \n", + "# np.zeros((5, timepts.size))])\n", + "# ud = np.outer(ue, np.ones_like(timepts))\n", + "\n", + "# Run a simulation with full state feedback (no noise) to generate a trajectory\n", + "uvec = [xd, ud, V, W*0]\n", + "lqr_resp = ct.input_output_response(lqr_clsys, timepts, uvec, x0)\n", + "U = lqr_resp.outputs[6:8] # controller input signals\n", + "Y = lqr_resp.outputs[0:3] + W # noisy output signals (noise in pvtol_noisy)\n", + "\n", + "# Compare to the no noise case\n", + "uvec = [xd, ud, V*0, W*0]\n", + "lqr0_resp = ct.input_output_response(lqr_clsys, timepts, uvec, x0)\n", + "lqr0_fine = ct.input_output_response(lqr_clsys, timepts, uvec, x0, \n", + " t_eval=np.linspace(timepts[0], timepts[-1], 100))\n", + "U0 = lqr0_resp.outputs[6:8]\n", + "Y0 = lqr0_resp.outputs[0:3]\n", + "\n", + "# Compare the results\n", + "# plt.plot(Y0[0], Y0[1], 'k--', linewidth=2, label=\"No disturbances\")\n", + "plt.plot(lqr0_fine.states[0], lqr0_fine.states[1], 'r-', label=\"Actual\")\n", + "plt.plot(Y[0], Y[1], 'b-', label=\"Noisy\")\n", + "\n", + "plt.xlabel('$x$ [m]')\n", + "plt.ylabel('$y$ [m]')\n", + "plt.axis('equal')\n", + "plt.legend(frameon=False)\n", + "\n", + "plt.figure()\n", + "plot_results(timepts, lqr_resp.states, lqr_resp.outputs[6:8]);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7f1dec6", + "metadata": {}, + "outputs": [], + "source": [ + "# Utility functions for making plots\n", + "def plot_state_comparison(\n", + " timepts, est_states, act_states=None, estimated_label='$\\\\hat x_{i}$', actual_label='$x_{i}$',\n", + " start=0):\n", + " for i in range(sys.nstates):\n", + " plt.subplot(2, 3, i+1)\n", + " if act_states is not None:\n", + " plt.plot(timepts[start:], act_states[i, start:], 'r--', \n", + " label=actual_label.format(i=i))\n", + " plt.plot(timepts[start:], est_states[i, start:], 'b', \n", + " label=estimated_label.format(i=i))\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " \n", + "# Define a function to plot out all of the relevant signals\n", + "def plot_estimator_response(timepts, estimated, U, V, Y, W, start=0):\n", + " # Plot the input signal and disturbance\n", + " for i in [0, 1]:\n", + " # Input signal (the same across all)\n", + " plt.subplot(4, 3, i+1)\n", + " plt.plot(timepts[start:], U[i, start:], 'k')\n", + " plt.ylabel(f'U[{i}]')\n", + "\n", + " # Plot the estimated disturbance signal\n", + " plt.subplot(4, 3, 4+i)\n", + " plt.plot(timepts[start:], estimated.inputs[i, start:], 'b-', label=\"est\")\n", + " plt.plot(timepts[start:], V[i, start:], 'k', label=\"actual\")\n", + " plt.ylabel(f'V[{i}]')\n", + "\n", + " plt.subplot(4, 3, 6)\n", + " plt.plot(0, 0, 'b', label=\"estimated\")\n", + " plt.plot(0, 0, 'k', label=\"actual\")\n", + " plt.plot(0, 0, 'r', label=\"measured\")\n", + " plt.legend(frameon=False)\n", + " plt.grid(False)\n", + " plt.axis('off')\n", + " \n", + " # Plot the output (measured and estimated) \n", + " for i in [0, 1, 2]:\n", + " plt.subplot(4, 3, 7+i)\n", + " plt.plot(timepts[start:], Y[i, start:], 'r', label=\"measured\")\n", + " plt.plot(timepts[start:], estimated.states[i, start:], 'b', label=\"measured\")\n", + " plt.plot(timepts[start:], Y[i, start:] - W[i, start:], 'k', label=\"actual\")\n", + " plt.ylabel(f'Y[{i}]')\n", + " \n", + " for i in [0, 1, 2]:\n", + " plt.subplot(4, 3, 10+i)\n", + " plt.plot(timepts[start:], estimated.outputs[i, start:], 'b', label=\"estimated\")\n", + " plt.plot(timepts[start:], W[i, start:], 'k', label=\"actual\")\n", + " plt.ylabel(f'W[{i}]')\n", + " plt.xlabel('Time [s]')\n", + "\n", + " plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "73dd9be3", + "metadata": {}, + "source": [ + "## State Estimation" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a1f32da", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a new system with only x, y, theta as outputs\n", + "# TODO: add this to pvtol.py?\n", + "sys = ct.NonlinearIOSystem(\n", + " pvt._noisy_update, lambda t, x, u, params: x[0:3], name=\"pvtol_noisy\",\n", + " states = [f'x{i}' for i in range(6)],\n", + " inputs = ['F1', 'F2'] + ['Dx', 'Dy'],\n", + " outputs = ['x', 'y', 'theta']\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a0679f4", + "metadata": {}, + "outputs": [], + "source": [ + "# Standard Kalman filter\n", + "linsys = sys.linearize(xe, [ue, V[:, 0] * 0])\n", + "# print(linsys)\n", + "B = linsys.B[:, 0:2]\n", + "G = linsys.B[:, 2:4]\n", + "linsys = ct.ss(\n", + " linsys.A, B, linsys.C, 0,\n", + " states=sys.state_labels, inputs=sys.input_labels[0:2], outputs=sys.output_labels)\n", + "# print(linsys)\n", + "\n", + "estim = ct.create_estimator_iosystem(linsys, Qv, Qw, G=G, P0=P0)\n", + "print(estim)\n", + "print(f'{xe=}, {P0=}')\n", + "\n", + "kf_resp = ct.input_output_response(\n", + " estim, timepts, [Y, U], X0 = [xe, P0.reshape(-1)])\n", + "plot_state_comparison(timepts, kf_resp.outputs, lqr_resp.states)" + ] + }, + { + "cell_type": "markdown", + "id": "654dde1b", + "metadata": {}, + "source": [ + "### Extended Kalman filter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f83a335", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the disturbance input and measured output matrices\n", + "F = np.array([[0, 0], [0, 0], [0, 0], [1/pvtol.params['m'], 0], [0, 1/pvtol.params['m']], [0, 0]])\n", + "C = np.eye(3, 6)\n", + "\n", + "Qwinv = np.linalg.inv(Qw)\n", + "\n", + "# Estimator update law\n", + "def estimator_update(t, x, u, params):\n", + " # Extract the states of the estimator\n", + " xhat = x[0:pvtol.nstates]\n", + " P = x[pvtol.nstates:].reshape(pvtol.nstates, pvtol.nstates)\n", + "\n", + " # Extract the inputs to the estimator\n", + " y = u[0:3] # just grab the first three outputs\n", + " u = u[6:8] # get the inputs that were applied as well\n", + "\n", + " # Compute the linearization at the current state\n", + " A = pvtol.A(xhat, u) # A matrix depends on current state\n", + " # A = pvtol.A(xe, ue) # Fixed A matrix (for testing/comparison)\n", + " \n", + " # Compute the optimal \"gain\n", + " L = P @ C.T @ Qwinv\n", + "\n", + " # Update the state estimate\n", + " xhatdot = pvtol.updfcn(t, xhat, u, params) - L @ (C @ xhat - y)\n", + "\n", + " # Update the covariance\n", + " Pdot = A @ P + P @ A.T - P @ C.T @ Qwinv @ C @ P + F @ Qv @ F.T\n", + "\n", + " # Return the derivative\n", + " return np.hstack([xhatdot, Pdot.reshape(-1)])\n", + "\n", + "def estimator_output(t, x, u, params):\n", + " # Return the estimator states\n", + " return x[0:pvtol.nstates]\n", + "\n", + "ekf = ct.NonlinearIOSystem(\n", + " estimator_update, estimator_output,\n", + " states=pvtol.nstates + pvtol.nstates**2,\n", + " inputs= pvtol_noisy.output_labels \\\n", + " + pvtol_noisy.input_labels[0:pvtol.ninputs],\n", + " outputs=[f'xh{i}' for i in range(pvtol.nstates)]\n", + ")\n", + "print(ekf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a4caf69b", + "metadata": {}, + "outputs": [], + "source": [ + "ekf_resp = ct.input_output_response(\n", + " ekf, timepts, [lqr_resp.states, lqr_resp.outputs[6:8]],\n", + " X0=[xe, P0.reshape(-1)])\n", + "plot_state_comparison(timepts, ekf_resp.outputs, lqr_resp.states)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1074908c", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the optimal estimation problem\n", + "traj_cost = opt.gaussian_likelihood_cost(sys, Qv, Qw)\n", + "init_cost = lambda xhat, x: (xhat - x) @ P0 @ (xhat - x)\n", + "oep = opt.OptimalEstimationProblem(\n", + " sys, timepts, traj_cost, terminal_cost=init_cost)\n", + "\n", + "# Compute the estimate from the noisy signals\n", + "est = oep.compute_estimate(Y, U, X0=lqr_resp.states[:, 0])\n", + "plot_state_comparison(timepts, est.states, lqr_resp.states)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c6981b9", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot the response of the estimator\n", + "plot_estimator_response(timepts, est, U, V, Y, W)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25b8aa85", + "metadata": {}, + "outputs": [], + "source": [ + "# Noise free and disturbance free => estimation should be near perfect\n", + "noisefree_cost = opt.gaussian_likelihood_cost(sys, Qv, Qw*1e-6)\n", + "oep0 = opt.OptimalEstimationProblem(\n", + " sys, timepts, noisefree_cost, terminal_cost=init_cost)\n", + "est0 = oep0.compute_estimate(Y0, U0, X0=lqr0_resp.states[:, 0],\n", + " initial_guess=(lqr0_resp.states, V * 0))\n", + "plot_state_comparison(\n", + " timepts, est0.states, lqr0_resp.states, estimated_label='$\\\\bar x_{i}$')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a76821f", + "metadata": {}, + "outputs": [], + "source": [ + "plot_estimator_response(timepts, est0, U0, V*0, Y0, W*0)" + ] + }, + { + "cell_type": "markdown", + "id": "6b9031cf", + "metadata": {}, + "source": [ + "### Bounded disturbances\n", + "\n", + "Another thing that the MHE can handled is input distributions that are bounded. We implement that here by carrying out the optimal estimation problem with constraints." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "93482470", + "metadata": {}, + "outputs": [], + "source": [ + "V_clipped = np.clip(V, -0.05, 0.05) \n", + "\n", + "plt.plot(timepts, V[0], label=\"V[0]\")\n", + "plt.plot(timepts, V_clipped[0], label=\"V[0] clipped\")\n", + "plt.plot(timepts, W[0], label=\"W[0]\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56e186f1", + "metadata": {}, + "outputs": [], + "source": [ + "uvec = [xe, ue, V_clipped, W]\n", + "clipped_resp = ct.input_output_response(lqr_clsys, timepts, uvec, x0)\n", + "U_clipped = clipped_resp.outputs[6:8] # controller input signals\n", + "Y_clipped = clipped_resp.outputs[0:3] + W # noisy output signals\n", + "\n", + "traj_constraint = opt.disturbance_range_constraint(\n", + " sys, [-0.05, -0.05], [0.05, 0.05])\n", + "oep_clipped = opt.OptimalEstimationProblem(\n", + " sys, timepts, traj_cost, terminal_cost=init_cost,\n", + " trajectory_constraints=traj_constraint)\n", + "\n", + "est_clipped = oep_clipped.compute_estimate(\n", + " Y_clipped, U_clipped, X0=lqr0_resp.states[:, 0])\n", + "plot_state_comparison(timepts, est_clipped.states, lqr_resp.states)\n", + "plt.suptitle(\"MHE with constraints\")\n", + "plt.tight_layout()\n", + "\n", + "plt.figure()\n", + "ekf_unclipped = ct.input_output_response(\n", + " ekf, timepts, [clipped_resp.states, clipped_resp.outputs[6:8]],\n", + " X0=[xe, P0.reshape(-1)])\n", + "\n", + "plot_state_comparison(timepts, ekf_unclipped.outputs, lqr_resp.states)\n", + "plt.suptitle(\"EKF w/out constraints\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "108c341a", + "metadata": {}, + "outputs": [], + "source": [ + "plot_estimator_response(timepts, est_clipped, U, V_clipped, Y, W)" + ] + }, + { + "cell_type": "markdown", + "id": "430117ce", + "metadata": {}, + "source": [ + "## Moving Horizon Estimation (MHE)\n", + "\n", + "We can now move to implementation of a moving horizon estimator, using our fixed horizon optimal estimator." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "121d67ba", + "metadata": {}, + "outputs": [], + "source": [ + "# Use a shorter horizon\n", + "mhe_timepts = timepts[0:5]\n", + "oep = opt.OptimalEstimationProblem(\n", + " sys, mhe_timepts, traj_cost, terminal_cost=init_cost)\n", + "\n", + "try:\n", + " mhe = oep.create_mhe_iosystem(2)\n", + " \n", + " est_mhe = ct.input_output_response(\n", + " mhe, timepts, [Y, U], X0=resp.states[:, 0], \n", + " params={'verbose': True}\n", + " )\n", + " plot_state_comparison(timepts, est_mhe.states, lqr_resp.states)\n", + "except:\n", + " print(\"MHE for continuous time systems not implemented\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1914ad96", + "metadata": {}, + "outputs": [], + "source": [ + "# Create discrete time version of PVTOL\n", + "Ts = 0.1\n", + "print(f\"Sample time: {Ts=}\")\n", + "dsys = ct.NonlinearIOSystem(\n", + " lambda t, x, u, params: x + Ts * sys.updfcn(t, x, u, params),\n", + " sys.outfcn, dt=Ts, states=sys.state_labels,\n", + " inputs=sys.input_labels, outputs=sys.output_labels,\n", + ")\n", + "print(dsys)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11162130", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a new list of time points\n", + "timepts = np.arange(0, Tf, Ts)\n", + "\n", + "# Create representative process disturbance and sensor noise vectors\n", + "# np.random.seed(117) # avoid figures changing from run to run\n", + "V = ct.white_noise(timepts, Qv)\n", + "# V = np.clip(V0, -0.1, 0.1) # Hold for later\n", + "W = ct.white_noise(timepts, Qw, dt=Ts)\n", + "# plt.plot(timepts, V0[0], 'b--', label=\"V[0]\")\n", + "plt.plot(timepts, V[0], label=\"V[0]\")\n", + "plt.plot(timepts, W[0], label=\"W[0]\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8a6a693", + "metadata": {}, + "outputs": [], + "source": [ + "# Generate a new trajectory over the longer time vector\n", + "uvec = [xd, ud, V, W*0]\n", + "lqr_resp = ct.input_output_response(lqr_clsys, timepts, uvec, x0)\n", + "U = lqr_resp.outputs[6:8] # controller input signals\n", + "Y = lqr_resp.outputs[0:3] + W # noisy output signals" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d683767f", + "metadata": {}, + "outputs": [], + "source": [ + "mhe_timepts = timepts[0:10]\n", + "oep = opt.OptimalEstimationProblem(\n", + " dsys, mhe_timepts, traj_cost, terminal_cost=init_cost)\n", + "mhe = oep.create_mhe_iosystem(2)\n", + " \n", + "mhe_resp = ct.input_output_response(\n", + " mhe, timepts, [Y, U], X0=x0, \n", + " params={'verbose': True}\n", + ")\n", + "plot_state_comparison(timepts, mhe_resp.states, lqr_resp.states)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bfc68072", + "metadata": {}, + "outputs": [], + "source": [ + "# Resimulate starting at the origin and moving to the \"initial\" condition\n", + "uvec = [x0, ue, V, W*0]\n", + "lqr_resp = ct.input_output_response(lqr_clsys, timepts, uvec, xe)\n", + "U = lqr_resp.outputs[6:8] # controller input signals\n", + "Y = lqr_resp.outputs[0:3] + W # noisy output signals" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "49213d04", + "metadata": {}, + "outputs": [], + "source": [ + "mhe_timepts = timepts[0:8]\n", + "oep = opt.OptimalEstimationProblem(\n", + " dsys, mhe_timepts, traj_cost, terminal_cost=init_cost)\n", + "mhe = oep.create_mhe_iosystem(2)\n", + " \n", + "mhe_resp = ct.input_output_response(\n", + " mhe, timepts, [Y, U],\n", + " params={'verbose': True}\n", + ")\n", + "plot_state_comparison(timepts, mhe_resp.outputs, lqr_resp.states)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "650a559a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/pvtol-outputfbk.ipynb b/examples/pvtol-outputfbk.ipynb index 8656ed241..7d8bc8529 100644 --- a/examples/pvtol-outputfbk.ipynb +++ b/examples/pvtol-outputfbk.ipynb @@ -76,7 +76,7 @@ "Outputs (6): x0, x1, x2, x3, x4, x5, \n", "States (6): x0, x1, x2, x3, x4, x5, \n", "\n", - "Object: noisy_pvtol\n", + "Object: pvtol_noisy\n", "Inputs (7): F1, F2, Dx, Dy, Nx, Ny, Nth, \n", "Outputs (6): x0, x1, x2, x3, x4, x5, \n", "States (6): x0, x1, x2, x3, x4, x5, \n" @@ -85,8 +85,8 @@ ], "source": [ "# pvtol = nominal system (no disturbances or noise)\n", - "# noisy_pvtol = pvtol w/ process disturbances and sensor noise\n", - "from pvtol import pvtol, noisy_pvtol, plot_results\n", + "# pvtol_noisy = pvtol w/ process disturbances and sensor noise\n", + "from pvtol import pvtol, pvtol_noisy, plot_results\n", "\n", "# Find the equiblirum point corresponding to the origin\n", "xe, ue = ct.find_eqpt(\n", @@ -104,7 +104,7 @@ "A, B = pvtol_lin.A, pvtol_lin.B\n", "\n", "print(pvtol, \"\\n\")\n", - "print(noisy_pvtol)" + "print(pvtol_noisy)" ] }, { @@ -192,8 +192,8 @@ "estimator = ct.NonlinearIOSystem(\n", " estimator_update, lambda t, x, u, params: x[0:pvtol.nstates],\n", " states=pvtol.nstates + pvtol.nstates**2,\n", - " inputs= noisy_pvtol.state_labels[0:3] \\\n", - " + noisy_pvtol.input_labels[0:pvtol.ninputs],\n", + " inputs= pvtol_noisy.state_labels[0:3] \\\n", + " + pvtol_noisy.input_labels[0:pvtol.ninputs],\n", " outputs=[f'xh{i}' for i in range(pvtol.nstates)],\n", ")\n", "print(estimator)" @@ -241,7 +241,7 @@ "Object: xh5\n", "Inputs (13): xd[0], xd[1], xd[2], xd[3], xd[4], xd[5], ud[0], ud[1], Dx, Dy, Nx, Ny, Nth, \n", "Outputs (14): x0, x1, x2, x3, x4, x5, F1, F2, xh0, xh1, xh2, xh3, xh4, xh5, \n", - "States (48): noisy_pvtol_x0, noisy_pvtol_x1, noisy_pvtol_x2, noisy_pvtol_x3, noisy_pvtol_x4, noisy_pvtol_x5, sys[3]_x[0], sys[3]_x[1], sys[3]_x[2], sys[3]_x[3], sys[3]_x[4], sys[3]_x[5], sys[3]_x[6], sys[3]_x[7], sys[3]_x[8], sys[3]_x[9], sys[3]_x[10], sys[3]_x[11], sys[3]_x[12], sys[3]_x[13], sys[3]_x[14], sys[3]_x[15], sys[3]_x[16], sys[3]_x[17], sys[3]_x[18], sys[3]_x[19], sys[3]_x[20], sys[3]_x[21], sys[3]_x[22], sys[3]_x[23], sys[3]_x[24], sys[3]_x[25], sys[3]_x[26], sys[3]_x[27], sys[3]_x[28], sys[3]_x[29], sys[3]_x[30], sys[3]_x[31], sys[3]_x[32], sys[3]_x[33], sys[3]_x[34], sys[3]_x[35], sys[3]_x[36], sys[3]_x[37], sys[3]_x[38], sys[3]_x[39], sys[3]_x[40], sys[3]_x[41], \n" + "States (48): pvtol_noisy_x0, pvtol_noisy_x1, pvtol_noisy_x2, pvtol_noisy_x3, pvtol_noisy_x4, pvtol_noisy_x5, sys[3]_x[0], sys[3]_x[1], sys[3]_x[2], sys[3]_x[3], sys[3]_x[4], sys[3]_x[5], sys[3]_x[6], sys[3]_x[7], sys[3]_x[8], sys[3]_x[9], sys[3]_x[10], sys[3]_x[11], sys[3]_x[12], sys[3]_x[13], sys[3]_x[14], sys[3]_x[15], sys[3]_x[16], sys[3]_x[17], sys[3]_x[18], sys[3]_x[19], sys[3]_x[20], sys[3]_x[21], sys[3]_x[22], sys[3]_x[23], sys[3]_x[24], sys[3]_x[25], sys[3]_x[26], sys[3]_x[27], sys[3]_x[28], sys[3]_x[29], sys[3]_x[30], sys[3]_x[31], sys[3]_x[32], sys[3]_x[33], sys[3]_x[34], sys[3]_x[35], sys[3]_x[36], sys[3]_x[37], sys[3]_x[38], sys[3]_x[39], sys[3]_x[40], sys[3]_x[41], \n" ] } ], @@ -269,11 +269,11 @@ "# Reconstruct the control system with the noisy version of the process\n", "# Create a closed loop system around the controller\n", "clsys = ct.interconnect(\n", - " [noisy_pvtol, statefbk, estimator],\n", + " [pvtol_noisy, statefbk, estimator],\n", " inplist = statefbk.input_labels[0:pvtol.ninputs + pvtol.nstates] + \\\n", - " noisy_pvtol.input_labels[pvtol.ninputs:],\n", + " pvtol_noisy.input_labels[pvtol.ninputs:],\n", " inputs = statefbk.input_labels[0:pvtol.ninputs + pvtol.nstates] + \\\n", - " noisy_pvtol.input_labels[pvtol.ninputs:],\n", + " pvtol_noisy.input_labels[pvtol.ninputs:],\n", " outlist = pvtol.output_labels + statefbk.output_labels + estimator.output_labels,\n", " outputs = pvtol.output_labels + statefbk.output_labels + estimator.output_labels\n", ")\n", @@ -449,11 +449,11 @@ "lqr_ctrl, _ = ct.create_statefbk_iosystem(pvtol, K)\n", "\n", "lqr_clsys = ct.interconnect(\n", - " [noisy_pvtol, lqr_ctrl],\n", + " [pvtol_noisy, lqr_ctrl],\n", " inplist = lqr_ctrl.input_labels[0:pvtol.ninputs + pvtol.nstates] + \\\n", - " noisy_pvtol.input_labels[pvtol.ninputs:],\n", + " pvtol_noisy.input_labels[pvtol.ninputs:],\n", " inputs = lqr_ctrl.input_labels[0:pvtol.ninputs + pvtol.nstates] + \\\n", - " noisy_pvtol.input_labels[pvtol.ninputs:],\n", + " pvtol_noisy.input_labels[pvtol.ninputs:],\n", " outlist = pvtol.output_labels + lqr_ctrl.output_labels,\n", " outputs = pvtol.output_labels + lqr_ctrl.output_labels\n", ")\n", diff --git a/examples/pvtol.py b/examples/pvtol.py index 277d0faa1..4f92f12fa 100644 --- a/examples/pvtol.py +++ b/examples/pvtol.py @@ -14,8 +14,10 @@ from math import sin, cos from warnings import warn +__all__ = ['pvtol', 'pvtol_windy', 'pvtol_noisy'] + # PVTOL dynamics -def pvtol_update(t, x, u, params): +def _pvtol_update(t, x, u, params): # Get the parameter values m = params.get('m', 4.) # mass of aircraft J = params.get('J', 0.0475) # inertia around pitch axis @@ -38,11 +40,11 @@ def pvtol_update(t, x, u, params): return np.array([xdot, ydot, thetadot, xddot, yddot, thddot]) -def pvtol_output(t, x, u, params): +def _pvtol_output(t, x, u, params): return x # PVTOL flat system mappings -def pvtol_flat_forward(states, inputs, params={}): +def _pvtol_flat_forward(states, inputs, params={}): # Get the parameter values m = params.get('m', 4.) # mass of aircraft J = params.get('J', 0.0475) # inertia around pitch axis @@ -102,7 +104,7 @@ def pvtol_flat_forward(states, inputs, params={}): return zflag -def pvtol_flat_reverse(zflag, params={}): +def _pvtol_flat_reverse(zflag, params={}): # Get the parameter values m = params.get('m', 4.) # mass of aircraft J = params.get('J', 0.0475) # inertia around pitch axis @@ -110,10 +112,6 @@ def pvtol_flat_reverse(zflag, params={}): g = params.get('g', 9.8) # gravitational constant c = params.get('c', 0.05) # damping factor (estimated) - # Create a vector to store the state and inputs - x = np.zeros(6) - u = np.zeros(2) - # Given the flat variables, solve for the state theta = np.arctan2(-zflag[0][2], zflag[1][2] + g) x = zflag[0][0] + (J / (m * r)) * sin(theta) @@ -132,11 +130,8 @@ def pvtol_flat_reverse(zflag, params={}): + (J / (m * r)) * thdot**2) F1 = (J / r) * \ (zflag[0][4] * cos(theta) + zflag[1][4] * sin(theta) -# - 2 * (zflag[0][3] * sin(theta) - zflag[1][3] * cos(theta)) * thdot \ - 2 * zflag[0][3] * sin(theta) * thdot \ + 2 * zflag[1][3] * cos(theta) * thdot \ -# - (zflag[0][2] * cos(theta) -# + (zflag[1][2] + g) * sin(theta)) * thdot**2) \ - zflag[0][2] * cos(theta) * thdot**2 - (zflag[1][2] + g) * sin(theta) * thdot**2) \ / (zflag[0][2] * sin(theta) - (zflag[1][2] + g) * cos(theta)) @@ -144,8 +139,8 @@ def pvtol_flat_reverse(zflag, params={}): return np.array([x, y, theta, xdot, ydot, thdot]), np.array([F1, F2]) pvtol = fs.FlatSystem( - pvtol_flat_forward, pvtol_flat_reverse, name='pvtol', - updfcn=pvtol_update, outfcn=pvtol_output, + _pvtol_flat_forward, _pvtol_flat_reverse, name='pvtol', + updfcn=_pvtol_update, outfcn=_pvtol_output, states = [f'x{i}' for i in range(6)], inputs = ['F1', 'F2'], outputs = [f'x{i}' for i in range(6)], @@ -162,13 +157,13 @@ def pvtol_flat_reverse(zflag, params={}): # PVTOL dynamics with wind # -def windy_update(t, x, u, params): +def _windy_update(t, x, u, params): # Get the input vector F1, F2, d = u # Get the system response from the original dynamics xdot, ydot, thetadot, xddot, yddot, thddot = \ - pvtol_update(t, x, u[0:2], params) + _pvtol_update(t, x, u[0:2], params) # Now add the wind term m = params.get('m', 4.) # mass of aircraft @@ -176,8 +171,8 @@ def windy_update(t, x, u, params): return np.array([xdot, ydot, thetadot, xddot, yddot, thddot]) -windy_pvtol = ct.NonlinearIOSystem( - windy_update, pvtol_output, name="windy_pvtol", +pvtol_windy = ct.NonlinearIOSystem( + _windy_update, _pvtol_output, name="pvtol_windy", states = [f'x{i}' for i in range(6)], inputs = ['F1', 'F2', 'd'], outputs = [f'x{i}' for i in range(6)] @@ -187,13 +182,17 @@ def windy_update(t, x, u, params): # PVTOL dynamics with noise and disturbances # -def noisy_update(t, x, u, params): +def _noisy_update(t, x, u, params): # Get the inputs - F1, F2, Dx, Dy, Nx, Ny, Nth = u + F1, F2, Dx, Dy = u[:4] + if u.shape[0] > 4: + Nx, Ny, Nth = u[4:] + else: + Nx, Ny, Nth = 0, 0, 0 # Get the system response from the original dynamics xdot, ydot, thetadot, xddot, yddot, thddot = \ - pvtol_update(t, x, u[0:2], params) + _pvtol_update(t, x, u[0:2], params) # Get the parameter values we need m = params.get('m', 4.) # mass of aircraft @@ -205,26 +204,26 @@ def noisy_update(t, x, u, params): return np.array([xdot, ydot, thetadot, xddot, yddot, thddot]) -def noisy_output(t, x, u, params): +def _noisy_output(t, x, u, params): F1, F2, dx, Dy, Nx, Ny, Nth = u return x + np.array([Nx, Ny, Nth, 0, 0, 0]) -noisy_pvtol = ct.NonlinearIOSystem( - noisy_update, noisy_output, name="noisy_pvtol", +pvtol_noisy = ct.NonlinearIOSystem( + _noisy_update, _noisy_output, name="pvtol_noisy", states = [f'x{i}' for i in range(6)], inputs = ['F1', 'F2'] + ['Dx', 'Dy'] + ['Nx', 'Ny', 'Nth'], outputs = pvtol.state_labels ) -# Add the linearitizations to the dynamics as additional methods -def noisy_pvtol_A(x, u, params={}): +# Add the linearitizations to the dynamics as an additional method +def pvtol_noisy_A(x, u, params={}): # Get the parameter values we need m = params.get('m', 4.) # mass of aircraft J = params.get('J', 0.0475) # inertia around pitch axis c = params.get('c', 0.05) # damping factor (estimated) # Get the angle and compute sine and cosine - theta = x[[2]] + theta = x[2] cth, sth = cos(theta), sin(theta) # Return the linearized dynamics matrix @@ -236,7 +235,7 @@ def noisy_pvtol_A(x, u, params={}): [0, 0, ( u[0] * cth - u[1] * sth)/m, 0, -c/m, 0], [0, 0, 0, 0, 0, 0] ]) -pvtol.A = noisy_pvtol_A +pvtol.A = pvtol_noisy_A # Plot the trajectory in xy coordinates def plot_results(t, x, u): @@ -302,8 +301,8 @@ def _pvtol_check_flat(test_points=None, verbose=False): for x, u in test_points: x, u = np.array(x), np.array(u) - flag = pvtol_flat_forward(x, u) - xc, uc = pvtol_flat_reverse(flag) + flag = _pvtol_flat_forward(x, u) + xc, uc = _pvtol_flat_reverse(flag) print(f'({x}, {u}): ', end='') if verbose: print(f'\n flag: {flag}') @@ -312,4 +311,3 @@ def _pvtol_check_flat(test_points=None, verbose=False): print("OK") else: print("ERR") - From 83751277a06f5518347042deda76a2f986698468 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 11 Mar 2023 07:05:44 -0800 Subject: [PATCH 05/14] add standard _process_indices function --- control/namedio.py | 20 +++++++++++++++ control/statefbk.py | 61 ++++++++++++++++++++------------------------- 2 files changed, 47 insertions(+), 34 deletions(-) diff --git a/control/namedio.py b/control/namedio.py index a94d1a9f5..902751919 100644 --- a/control/namedio.py +++ b/control/namedio.py @@ -584,3 +584,23 @@ def _process_signal_list(signals, prefix='s'): else: raise TypeError("Can't parse signal list %s" % str(signals)) + + +# Utility function to process signal indices +def _process_indices(arg, name, labels, default=None): + arg = default if arg is None else arg + if arg is None: + return None; + + if isinstance(arg, int): + return range(arg) + elif isinstance(arg, slice): + return arg + elif isinstance(arg, list): + arg=arg.copy() + for i, idx in enumerate(arg): + if isinstance(idx, str): + arg[i] = labels.index(arg[i]) + return arg + else: + raise ValueError(f"invalid argument for {name}_indices") diff --git a/control/statefbk.py b/control/statefbk.py index c76a4e31a..02bbad3ec 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -48,7 +48,7 @@ from .mateqn import care, dare, _check_shape from .statesp import StateSpace, _ssmatrix, _convert_to_statespace from .lti import LTI -from .namedio import isdtime, isctime +from .namedio import isdtime, isctime, _process_indices from .iosys import InputOutputSystem, NonlinearIOSystem, LinearIOSystem, \ interconnect, ss from .exception import ControlSlycot, ControlArgument, ControlDimension, \ @@ -668,14 +668,16 @@ def create_statefbk_iosystem( If an estimator is provided, use the states of the estimator as the system inputs for the controller. - gainsched_indices : list of int or str, optional + gainsched_indices : int, slice, or list of int or str, optional If a gain scheduled controller is specified, specify the indices of the controller input to use for scheduling the gain. The input to the controller is the desired state xd, the desired input ud, and the system state x (or state estimate xhat, if an estimator is - given). The indices can either be specified as integer offsets into - the input vector or as strings matching the signal names of the - input vector. The default is to use the desire state xd. + given). If value is an integer `q`, the first `q` values of the + [xd, ud, x] vector are used. Otherwise, the value should be a + slice or a list of indices. The list of indices can be specified + as either integer offsets or as signal names. The default is to + use the desire state xd. gainsched_method : str, optional The method to use for gain scheduling. Possible values are 'linear' @@ -714,19 +716,21 @@ def create_statefbk_iosystem( Other Parameters ---------------- - control_indices : list of int or str, optional + control_indices : int, slice, or list of int or str, optional Specify the indices of the system inputs that should be determined - by the state feedback controller. If not specified, defaults to - the first `m` system inputs, where `m` is determined by the shape - of the gain matrix, with the remaining inputs remaining as inputs - to the overall closed loop system. - - state_indices : list of int or str, optional - Specify the indices of the system (or estimator) outputs that - should be used by the state feedback controller. If not specified, - defaults to the first `n` system/estimator outputs, where `n` is - determined by the shape of the gain matrix, with the remaining - outputs remaining as outputs to the overall closed loop system. + by the state feedback controller. If value is an integer `m`, the + first `m` system inputs are used. Otherwise, the value should be a + slice or a list of indices. The list of indices can be specified + as either integer offsets or as system input signal names. If not + specified, defaults to the system inputs. + + state_indices : int, slice, or list of int or str, optional + Specify the indices of the system (or estimator) outputs that should + be used by the state feedback controller. If value is an integer + `n`, the first `n` system states are used. Otherwise, the value + should be a slice or a list of indices. The list of indices can be + specified as either integer offsets or as estimator/system output + signal names. If not specified, defaults to the system states. inputs, outputs : str, or list of str, optional List of strings that name the individual signals of the transformed @@ -755,11 +759,8 @@ def create_statefbk_iosystem( raise TypeError("unrecognized keywords: ", str(kwargs)) # Figure out what inputs to the system to use - control_indices = range(sys.ninputs) if control_indices is None \ - else list(control_indices) - for i, idx in enumerate(control_indices): - if isinstance(idx, str): - control_indices[i] = sys.input_labels.index(control_indices[i]) + control_indices = _process_indices( + control_indices, 'control', sys.input_labels, sys.ninputs) sys_ninputs = len(control_indices) # Decide what system is going to pass the states to the controller @@ -767,11 +768,8 @@ def create_statefbk_iosystem( estimator = sys # Figure out what outputs (states) from the system/estimator to use - state_indices = range(sys.nstates) if state_indices is None \ - else list(state_indices) - for i, idx in enumerate(state_indices): - if isinstance(idx, str): - state_indices[i] = estimator.state_labels.index(state_indices[i]) + state_indices = _process_indices( + state_indices, 'state', estimator.state_labels, sys.nstates) sys_nstates = len(state_indices) # Make sure the system/estimator states are proper dimension @@ -858,8 +856,8 @@ def create_statefbk_iosystem( # Process gainscheduling variables, if present if gainsched: # Create a copy of the scheduling variable indices (default = xd) - gainsched_indices = range(sys_nstates) if gainsched_indices is None \ - else list(gainsched_indices) + gainsched_indices = _process_indices( + gainsched_indices, 'gainsched', inputs, sys_nstates) # If points is a 1D list, convert to 2D if points.ndim == 1: @@ -871,11 +869,6 @@ def create_statefbk_iosystem( "length of gainsched_indices must match dimension of" " scheduling variables") - # Process scheduling variables - for i, idx in enumerate(gainsched_indices): - if isinstance(idx, str): - gainsched_indices[i] = inputs.index(gainsched_indices[i]) - # Create interpolating function if points.shape[1] < 2: _interp = sp.interpolate.interp1d( From e165dd5d7d76d995eda401d8f1d0b05ead6090b4 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 11 Mar 2023 13:52:59 -0800 Subject: [PATCH 06/14] add {control, disturbance}_indices to create_estimator_iosystem --- control/namedio.py | 45 ++++++++++--- control/stochsys.py | 113 +++++++++++++++++++++++++++------ control/tests/stochsys_test.py | 61 ++++++++++++++++++ 3 files changed, 189 insertions(+), 30 deletions(-) diff --git a/control/namedio.py b/control/namedio.py index 902751919..d9c2581c9 100644 --- a/control/namedio.py +++ b/control/namedio.py @@ -22,8 +22,8 @@ 'namedio.sampled_system_name_prefix': '', 'namedio.sampled_system_name_suffix': '$sampled' } - - + + class NamedIOSystem(object): def __init__( self, name=None, inputs=None, outputs=None, states=None, **kwargs): @@ -586,21 +586,46 @@ def _process_signal_list(signals, prefix='s'): raise TypeError("Can't parse signal list %s" % str(signals)) +# # Utility function to process signal indices -def _process_indices(arg, name, labels, default=None): - arg = default if arg is None else arg - if arg is None: - return None; +# +# Signal indices can be specified in one of four ways: +# +# 1. As a positive integer 'm', in which case we return a list +# corresponding to the first 'm' elements of a range of a given length +# +# 2. As a negative integer '-m', in which case we return a list +# corresponding to the last 'm' elements of a range of a given length +# +# 3. As a slice, in which case we return the a list corresponding to the +# indices specified by the slice of a range of a given length +# +# 4. As a list of ints or strings specifying specific indices. Strings are +# compared to a list of labels to determine the index. +# +def _process_indices(arg, name, labels, length): + # Default is to return indices up to a certain length + arg = length if arg is None else arg if isinstance(arg, int): - return range(arg) + # Return the start or end of the list of possible indices + return list(range(arg)) if arg > 0 else list(range(length))[arg:] + elif isinstance(arg, slice): - return arg + # Return the indices referenced by the slice + return list(range(length))[arg] + elif isinstance(arg, list): + # Make sure the length is OK + if len(arg) > length: + raise ValueError( + f"{name}_indices list is too long; max length = {length}") + + # Return the list, replacing strings with corresponding indices arg=arg.copy() for i, idx in enumerate(arg): if isinstance(idx, str): arg[i] = labels.index(arg[i]) return arg - else: - raise ValueError(f"invalid argument for {name}_indices") + + raise ValueError(f"invalid argument for {name}_indices") diff --git a/control/stochsys.py b/control/stochsys.py index 5ff4bb2bd..33d4b641f 100644 --- a/control/stochsys.py +++ b/control/stochsys.py @@ -22,7 +22,7 @@ from .iosys import InputOutputSystem, LinearIOSystem, NonlinearIOSystem from .lti import LTI -from .namedio import isctime, isdtime +from .namedio import isctime, isdtime, _process_indices from .mateqn import care, dare, _check_shape from .statesp import StateSpace, _ssmatrix from .exception import ControlArgument, ControlNotImplemented @@ -314,6 +314,7 @@ def dlqe(*args, **kwargs): # def create_estimator_iosystem( sys, QN, RN, P0=None, G=None, C=None, + control_indices=None, disturbance_indices=None, state_labels='xhat[{i}]', output_labels='xhat[{i}]', covariance_labels='P[{i},{j}]', sensor_labels=None): r"""Create an I/O system implementing a linear quadratic estimator @@ -347,9 +348,10 @@ def create_estimator_iosystem( Parameters ---------- - sys : InputOutputSystem - The I/O system that represents the process dynamics. If no estimator - is given, the output of this system should represent the full state. + sys : LinearIOSystem + The linear I/O system that represents the process dynamics. If no + estimator is given, the output of this system should represent the + full state. QN, RN : ndarray Process and sensor noise covariance matrices. P0 : ndarray, optional @@ -362,14 +364,6 @@ def create_estimator_iosystem( If the system has full state output, define the measured values to be used by the estimator. Otherwise, use the system output as the measured values. - {state, covariance, sensor, output}_labels : str or list of str, optional - Set the name of the signals to use for the internal state, covariance, - sensors, and outputs (state estimate). If a single string is - specified, it should be a format string using the variable `i` as an - index (or `i` and `j` for covariance). Otherwise, a list of - strings matching the size of the respective signal should be used. - Default is ``'xhat[{i}]'`` for state and output labels, ``'y[{i}]'`` - for output labels and ``'P[{i},{j}]'`` for covariance labels. Returns ------- @@ -378,6 +372,47 @@ def create_estimator_iosystem( the system output y and input u and generates the estimated state xhat. + Other Parameters + ---------------- + control_indices : int, slice, or list of int or string, optional + Specify the indices in the system input vector that correspond to + the control inputs. These inputs will be used as known control + inputs for the estimator. If value is an integer `m`, the first `m` + system inputs are used. Otherwise, the value should be a slice or + a list of indices. The list of indices can be specified as either + integer offsets or as system input signal names. If not specified, + defaults to the system inputs. + disturbance_indices : int, list of int, or slice, optional + Specify the indices in the system input vector that correspond to + the unknown disturbances. These inputs are assumed to be white + noise with noise intensity QN. If value is an integer `m`, the + last `m` system inputs are used. Otherwise, the value should be a + slice or a list of indices. The list of indices can be specified + as either integer offsets or as system input signal names. If not + specified, the disturbances are assumed to be added to the system + inputs. + state_labels : str or list of str, optional + Set the names of the internal state estimate variables. If a + single string is specified, it should be a format string using the + variable `i` as an index. Otherwise, a list of strings matching + the number of system states should be used. Default is "xhat[{i}]". + covariance_labels : str or list of str, optional + Set the name of the the covariance state variables. If a single + string is specified, it should be a format string using the + variables `i` and `j` as indices. Otherwise, a list of strings + matching the size of the covariance matrix should be used. Default + is "P[{i},{j}]". + sensor_labels : str or list of str, optional + Set the name of the sensor signals (estimator inputs). If + specified, it should be a format string using the variable `i` as + an index. Otherwise, a list of strings matching the size of the + measured system outputs should be used. Default is "y[{i}]". + output_labels : str or list of str, optional + Set the name of the estimator outputs (state estimate). If a + single string is specified, it should be a format string using the + variable `i` as an index. Otherwise, a list of strings matching + the size of the system state should be used. Default is "xhat[{i}]". + Notes ----- This function can be used with the ``create_statefbk_iosystem()`` function @@ -403,11 +438,45 @@ def create_estimator_iosystem( if not isinstance(sys, LinearIOSystem): raise ControlArgument("Input system must be a linear I/O system") - # Extract the matrices that we need for easy reference - A, B = sys.A, sys.B + # Set the state matrix for later use + A = sys.A + + # Set the disturbance matrices (indices take priority over G) + ctrl_idx = _process_indices( + control_indices, 'control', sys.input_labels, sys.ninputs) + + if disturbance_indices is None and control_indices is not None: + # Disturbance indices are the complement of control indices + dist_idx = [i for i in range(sys.ninputs) if i not in ctrl_idx] + if G is not None: + warn("'control_indices' and 'G' both specified; ignoring 'G'") + G = sys.B[:, dist_idx] + + elif disturbance_indices is not None: + if G is not None: + warn("'disturbance_indices' and 'G' both specified; ignoring 'G'") + + # If passed an integer, count from the end of the input vector + arg = -disturbance_indices if isinstance(disturbance_indices, int) \ + else disturbance_indices - # Set the disturbance and output matrices - G = sys.B if G is None else G + dist_idx = _process_indices( + arg, 'disturbance', sys.input_labels, sys.ninputs) + G = sys.B[:, dist_idx] + + # Set control indices to complement disturbance indices, if needed + if control_indices is None: + ctrl_idx = [i for i in range(sys.ninputs) if i not in dist_idx] + + elif G is None: + G = sys.B + + # Set the input and direct matrices + B = sys.B[:, ctrl_idx] + if not np.allclose(sys.D, 0): + raise NotImplemented("nonzero 'D' matrix not yet implemented") + + # Set the output matrices if C is not None: # Make sure that we have the full system output if not np.array_equal(sys.C, np.eye(sys.nstates)): @@ -425,7 +494,7 @@ def create_estimator_iosystem( # Initialize the covariance matrix if P0 is None: # Initalize P0 to the steady state value - L0, P0, _ = lqe(A, G, C, QN, RN) + _, P0, _ = lqe(A, G, C, QN, RN) # Figure out the labels to use if isinstance(state_labels, str): @@ -447,6 +516,10 @@ def create_estimator_iosystem( # Generate the list of labels using the argument as a format string sensor_labels = [sensor_labels.format(i=i) for i in range(C.shape[0])] + # Set the input labels based on the system input + # TODO: allow these to be overriden + input_labels = [sys.input_labels[i] for i in ctrl_idx] + if isctime(sys): # Create an I/O system for the state feedback gains # Note: reshape vectors into column vectors for legacy np.matrix @@ -470,7 +543,7 @@ def _estim_update(t, x, u, params): L = P @ C.T @ R_inv # Update the state estimate - dxhat = A @ xhat + B @ u # prediction + dxhat = A @ xhat + B @ u # prediction if correct: dxhat -= L @ (C @ xhat - y) # correction @@ -500,7 +573,7 @@ def _estim_update(t, x, u, params): L = A @ P @ C.T @ Reps_inv # Update the state estimate - dxhat = A @ xhat + B @ u # prediction + dxhat = A @ xhat + B @ u # prediction if correct: dxhat -= L @ (C @ xhat - y) # correction @@ -518,7 +591,7 @@ def _estim_output(t, x, u, params): # Define the estimator system return NonlinearIOSystem( _estim_update, _estim_output, states=state_labels + covariance_labels, - inputs=sensor_labels + sys.input_labels, outputs=output_labels, + inputs=sensor_labels + input_labels, outputs=output_labels, dt=sys.dt) diff --git a/control/tests/stochsys_test.py b/control/tests/stochsys_test.py index 4366f4f15..f34f4dedb 100644 --- a/control/tests/stochsys_test.py +++ b/control/tests/stochsys_test.py @@ -319,6 +319,7 @@ def test_correlation(): T = np.logspace(0, 2, T.size) tau, Rtau = ct.correlation(T, V) +@pytest.mark.slow @pytest.mark.parametrize('dt', [0, 1]) def test_oep(dt): # Define the system to test, with additional input @@ -455,6 +456,7 @@ def test_oep(dt): est3.states[:, -1], res3.states[:, -1], atol=1e-1, rtol=1e-2) +@pytest.mark.slow def test_mhe(): # Define the system to test, with additional input csys = ct.ss( @@ -495,3 +497,62 @@ def test_mhe(): # Make sure the estimated state is close to the actual state np.testing.assert_allclose(estp.outputs, resp.states, atol=1e-2, rtol=1e-4) + +@pytest.mark.parametrize("ctrl_indices, dist_indices", [ + (slice(0, 3), None), + (3, None), + (None, 2), + ([0, 1, 4], None), + (['u[0]', 'u[1]', 'u[4]'], None), + (['u[0]', 'u[1]', 'u[4]'], ['u[1]', 'u[3]']), + (slice(0, 3), slice(3, 5)) +]) +def test_indices(ctrl_indices, dist_indices): + # Define a system with inputs (0:3), disturbances (3:5), and noise (5, 7) + ninputs = 3 + nstates = ninputs + 1 + ndisturbances = 2 + noutputs = 2 + nnoises = 0 + # TODO: remove strictly proper + sys = ct.rss(nstates, noutputs, ninputs + ndisturbances + nnoises, strictly_proper=True) + + # Create a system whose state we want to estimate + if ctrl_indices is not None: + ctrl_idx = ct.namedio._process_indices( + ctrl_indices, 'control', sys.input_labels, sys.ninputs) + else: + arg = -dist_indices if isinstance(dist_indices, int) else dist_indices + dist_idx = ct.namedio._process_indices( + arg, 'disturbance', sys.input_labels, sys.ninputs) + ctrl_idx = [i for i in range(sys.ninputs) if i not in dist_idx] + sysm = ct.ss(sys.A, sys.B[:, ctrl_idx], sys.C, sys.D[:, ctrl_idx]) + + # Set the simulation time based on the slowest system pole + from math import log + T = 10 / min(-sys.poles().real) + + # Generate a system response with no disturbances + timepts = np.linspace(0, T, 50) + U = np.vstack([np.sin(timepts + i) for i in range(ninputs)]) + resp = ct.input_output_response( + sysm, timepts, U, np.zeros(nstates), + solve_ivp_kwargs={'method': 'RK45', 'max_step': 0.01, + 'atol': 1, 'rtol': 1}) + Y = resp.outputs + + # Create an estimator + QN = np.eye(ndisturbances) + RN = np.eye(noutputs) + P0 = np.eye(nstates) + estim = ct.create_estimator_iosystem( + sys, QN, RN, control_indices=ctrl_indices, + disturbance_indices=dist_indices) + + # Run estimator (no prediction + same solve_ivp params => should be exact) + resp_estim = ct.input_output_response( + estim, timepts, [Y, U], [np.zeros(nstates), P0], + solve_ivp_kwargs={'method': 'RK45', 'max_step': 0.01, + 'atol': 1, 'rtol': 1}, + params={'correct': False}) + np.testing.assert_allclose(resp.states, resp_estim.outputs, rtol=1e-2) From 1c1ce0c1b38c2255e7a5c1233225a4e28db96681 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 12 Mar 2023 17:15:26 -0700 Subject: [PATCH 07/14] implement {control, disturbance}_indices in oep --- control/namedio.py | 39 +++++- control/optimal.py | 246 +++++++++++++++++++++------------ control/stochsys.py | 42 ++---- control/tests/kwargs_test.py | 2 + control/tests/optimal_test.py | 5 + control/tests/stochsys_test.py | 23 ++- examples/mhe-pvtol.ipynb | 10 +- 7 files changed, 242 insertions(+), 125 deletions(-) diff --git a/control/namedio.py b/control/namedio.py index d9c2581c9..df7d519fd 100644 --- a/control/namedio.py +++ b/control/namedio.py @@ -587,7 +587,7 @@ def _process_signal_list(signals, prefix='s'): # -# Utility function to process signal indices +# Utility functions to process signal indices # # Signal indices can be specified in one of four ways: # @@ -629,3 +629,40 @@ def _process_indices(arg, name, labels, length): return arg raise ValueError(f"invalid argument for {name}_indices") + +# +# Process control and disturbance indices +# +# For systems with inputs and disturbances, the control_indices and +# disturbance_indices keywords are used to specify which is which. If only +# one is given, the other is assumed to be the remaining indices in the +# system input. If neither is given, the disturbance inputs are assumed to +# be the same as the control inputs. +# +def _process_control_disturbance_indices( + sys, control_indices, disturbance_indices): + + if control_indices is None and disturbance_indices is None: + # Disturbances enter in the same place as the controls + dist_idx = ctrl_idx = list(range(sys.ninputs)) + + elif control_indices is not None: + # Process the control indices + ctrl_idx = _process_indices( + control_indices, 'control', sys.input_labels, sys.ninputs) + + # Disturbance indices are the complement of control indices + dist_idx = [i for i in range(sys.ninputs) if i not in ctrl_idx] + + else: # disturbance_indices is not None + # If passed an integer, count from the end of the input vector + arg = -disturbance_indices if isinstance(disturbance_indices, int) \ + else disturbance_indices + + dist_idx = _process_indices( + arg, 'disturbance', sys.input_labels, sys.ninputs) + + # Set control indices to complement disturbance indices + ctrl_idx = [i for i in range(sys.ninputs) if i not in dist_idx] + + return ctrl_idx, dist_idx diff --git a/control/optimal.py b/control/optimal.py index db238724b..f19fd91f7 100644 --- a/control/optimal.py +++ b/control/optimal.py @@ -18,6 +18,7 @@ from . import config from .exception import ControlNotImplemented +from .namedio import _process_indices, _process_control_disturbance_indices # Define module default parameter values _optimal_trajectory_methods = {'shooting', 'collocation'} @@ -1174,6 +1175,22 @@ class OptimalEstimationProblem(): terminal_cost : callable, optional Function that returns the terminal cost given the initial estimated state and expected value. Called as terminal_cost(xhat, x0). + control_indices : int, slice, or list of int or string, optional + Specify the indices in the system input vector that correspond to + the control inputs. These inputs will be used as known control + inputs for the estimate. If value is an integer `m`, the first `m` + system inputs are used. Otherwise, the value should be a slice or + a list of indices. The list of indices can be specified as either + integer offsets or as system input signal names. If not specified, + defaults to the complement of the disturbance indices (see also + notes below). + disturbance_indices : int, list of int, or slice, optional + Specify the indices in the system input vector that correspond to + the input disturbances. If value is an integer `m`, the last `m` + system inputs are used. Otherwise, the value should be a slice or + a list of indices, as describedf for `control_indices`. If not + specified, defaults to the complement of the control indicies (see + also notes below). Returns ------- @@ -1201,29 +1218,36 @@ class OptimalEstimationProblem(): ----- To describe an optimal estimation problem we need an input/output system, a set of time points, measured inputs and outputs, a cost - function, and (optionally) a set of constraints on the state and/or - inputs along the trajectory (and at the terminal time). This class - sets up an optimization over the initial state and disturbances at each - point in time, using the integral and terminal costs as well as the - trajectory constraints. The `compute_estimate` method solves the - underling optimization problem using :func:`scipy.optimize.minimize`. - - The `_cost_function` method computes the "cost" (negative of the log - likelihood) of the estimated trajectory generated by the proposed - initial estimated state, the disturbances and noise, and the measured - output. It does this by calling a user-defined function for the - integral_cost given the current estimated states, inputs, and measured - outputs at each point along the trajectory and then adding the value of - a user-defined terminal cost at the initial point in the trajectory. - - The `_constraint_function` method evaluates the constraint functions - along the trajectory generated by the proposed estimate and - disturbances. As in the case of the cost function, the constraints are - evaluated at the estimated state, inputs, and measured outputs along - each point on the trajectory. This information is compared against the - constraint upper and lower bounds. The constraint function is - processed in the class initializer, so that it only needs to be - computed once. + function, and (optionally) a set of constraints on the state + and/or inputs along the trajectory (and at the terminal time). + This class sets up an optimization over the state and disturbances + at each point in time, using the integral and terminal costs as + well as the trajectory constraints. The + :func:`~control.optimal.OptimalEstimationProblem.compute_estimate` + method solves the underling optimization problem using + :func:`scipy.optimize.minimize`. + + The control input and disturbance indices can be specified using the + `control_indices` and `disturbance_indices` keywords. If only one is + given, the other is assumed to be the remaining indices in the system + input. If neither is given, the disturbance inputs are assumed to be + the same as the control inputs. + + The "cost" (e.g. negative of the log likelihood) of the estimated + trajectory generated by the estimated state, the disturbances and + noise, and the measured output. It does this by calling a user-defined + function for the integral_cost given the current estimated states, + inputs, and measured outputs at each point along the trajectory and + then adding the value of a user-defined terminal cost at the initial + point in the trajectory. + + The constraint functions are evaluated at each point on the trajectory + generated by the proposed estimate and disturbances. As in the case of + the cost function, the constraints are evaluated at the estimated + state, inputs, and measured outputs along each point on the trajectory. + This information is compared against the constraint upper and lower + bounds. The constraint function is processed in the class initializer, + so that it only needs to be computed once. The default values for ``minimize_method``, ``minimize_options``, ``minimize_kwargs``, ``solve_ivp_method``, and ``solve_ivp_options`` can @@ -1232,7 +1256,8 @@ class OptimalEstimationProblem(): """ def __init__( self, sys, timepts, integral_cost, terminal_cost=None, - trajectory_constraints=None, **kwargs): + trajectory_constraints=None, control_indices=None, + disturbance_indices=None, **kwargs): """Set up an optimal control problem.""" # Save the basic information for use later self.system = sys @@ -1249,6 +1274,12 @@ def __init__( self.minimize_kwargs.update(kwargs.pop( 'minimize_kwargs', config.defaults['optimal.minimize_kwargs'])) + # Save input and disturbance indices (and create input array) + self.control_indices = control_indices + self.disturbance_indices = disturbance_indices + self.ctrl_idx, self.dist_idx = None, None + self.inputs = np.zeros((sys.ninputs, len(timepts))) + # Make sure there were no extraneous keywords if kwargs: raise TypeError("unrecognized keyword(s): ", str(kwargs)) @@ -1341,7 +1372,6 @@ def _cost_function(self, xvec): else: # Sum the integral cost over the time (second) indices # cost += self.integral_cost(xhat[:, i], u[:, i], v[:, i], w[:, i]) - # TODO: make sure last point is properly accounted for cost = sum(map( self.integral_cost, np.transpose(xhat[:, :-1]), np.transpose(u[:, :-1]), np.transpose(v[:, :-1]), @@ -1452,17 +1482,21 @@ def _eqconst_function(self, xvec): def _collocation_constraint(self, xvec): # Compute the estimated states and disturbance inputs xhat, u, v, w = self._compute_states_inputs(xvec) - inputs = np.vstack([u, v]) + + # Create the input vector for the system + self.inputs.fill(0.) + self.inputs[self.ctrl_idx, :] = u + self.inputs[self.dist_idx, :] += v if self.system.isctime(): # Compute the collocation constraints # TODO: vectorize fk = self.system._rhs( - self.timepts[0], xhat[:, 0], inputs[:, 0]) + self.timepts[0], xhat[:, 0], self.inputs[:, 0]) for i, t in enumerate(self.timepts[:-1]): # From M. Kelly, SIAM Review (2017), equation (3.2), i = k+1 # x[k+1] - x[k] = 0.5 hk (f(x[k+1], u[k+1] + f(x[k], u[k])) - fkp1 = self.system._rhs(t, xhat[:, i+1], inputs[:, i+1]) + fkp1 = self.system._rhs(t, xhat[:, i+1], self.inputs[:, i+1]) self.colloc_vals[:, i] = xhat[:, i+1] - xhat[:, i] - \ 0.5 * (self.timepts[i+1] - self.timepts[i]) * (fkp1 + fk) fk = fkp1 @@ -1471,7 +1505,7 @@ def _collocation_constraint(self, xvec): for i, t in enumerate(self.timepts[:-1]): # x[k+1] = f(x[k], u[k], v[k]) self.colloc_vals[:, i] = xhat[:, i+1] - \ - self.system._rhs(t, xhat[:, i], inputs[:, i]) + self.system._rhs(t, xhat[:, i], self.inputs[:, i]) # Return the value of the constraint function return self.colloc_vals.reshape(-1) @@ -1484,7 +1518,18 @@ def _process_initial_guess(self, initial_guess): return np.zeros( (self.system.nstates + self.ndisturbances) * self.timepts.size) else: - # TODO: add dimension check + if initial_guess[0].shape != \ + (self.system.nstates, self.timepts.size): + raise ValueError( + "initial guess for state estimate must have shape " + f"{self.system.nstates} x {self.timepts.size}") + + elif initial_guess[1].shape != \ + (self.ndisturbances, self.timepts.size): + raise ValueError( + "initial guess for disturbances must have shape " + f"{self.ndisturbances} x {self.timepts.size}") + return np.hstack([ initial_guess[0].reshape(-1), # estimated states initial_guess[1].reshape(-1)]) # disturbances @@ -1505,10 +1550,13 @@ def _compute_states_inputs(self, xvec): v = xvec[self.system.nstates * self.timepts.size:].reshape( self.ndisturbances, -1) + # Create the input vector for the system + self.inputs[self.ctrl_idx, :] = self.u + self.inputs[self.dist_idx, :] = v + # Compute the estimated output yhat = np.vstack([ - self.system._out(self.timepts[i], xhat[:, i], - np.hstack([self.u[:, i], v[:, i]])) + self.system._out(self.timepts[i], xhat[:, i], self.inputs[:, i]) for i in range(self.timepts.size)]).T return xhat, self.u, v, self.y - yhat @@ -1547,8 +1595,10 @@ def compute_estimate( Parameters ---------- - Y, U : 2D array - Measured outputs and applied inputs at each time point. + Y : 2D array + Measured outputs at each time point. + U : 2D array + Applied inputs at each time point. X0 : 1D array Expected initial value of the state. initial_guess : 2-tuple of 2D arrays @@ -1585,8 +1635,26 @@ def compute_estimate( self.x0 = X0 # Figure out the number of disturbances - self.ndisturbances = self.system.ninputs - self.u.shape[0] - assert self.ndisturbances > 0 + if self.disturbance_indices is None and self.control_indices is None: + self.ctrl_idx, self.dist_idx = \ + _process_control_disturbance_indices( + self.system, None, self.system.ninputs - self.u.shape[0]) + elif self.ctrl_idx is None or self.dist_idx is None: + self.ctrl_idx, self.dist_idx = \ + _process_control_disturbance_indices( + self.system, self.control_indices, + self.disturbance_indices) + self.ndisturbances = len(self.dist_idx) + + # Make sure the dimensions of the inputs are OK + if self.u.shape[0] != len(self.ctrl_idx): + raise ValueError( + "input vector is incorrect shape; " + f"should be {len(self.ctrl_idx)} x {self.timepts.size}") + if self.y.shape[0] != self.system.noutputs: + raise ValueError( + "measurements vector is incorrect shape; " + f"should be {self.system.noutputs} x {self.timepts.size}") # Process the initial guess initial_guess = self._process_initial_guess(initial_guess) @@ -1608,11 +1676,9 @@ def compute_estimate( # xhat, u, v, y for all previous time points. When the system update # function is called, # - # TODO: change input arguments to use control_indices, similar to - # create_statefbk_iosystem. + # TODO: change output_labels to output_fmtstr and use output instead # - def create_mhe_iosystem( - self, nd, output_labels='xhat[{i}]', sensor_labels=None): + def create_mhe_iosystem(self, output_labels=None, **kwargs): """Create an I/O system implementing an MPC controller This function creates an input/output system that implements a @@ -1622,13 +1688,12 @@ def create_mhe_iosystem( Parameters ---------- - sys : InputOutputSystem - I/O system for which the estimator will be computed. - - nd : int - Number of inputs that are disturbance (versus control) inputs. - The current implementation assumes that the inputs to `sys` are - the control inputs followed by `nd` disturbance inputs. + output_labels : str, optional + Set the name of the estimator outputs (state estimate). If a + single string is specified, it should be a format string using + the variable `i` as an index. Otherwise, a list of strings + matching the size of the system state should be used. Default + is "xhat[{i}]". Returns ------- @@ -1637,23 +1702,36 @@ def create_mhe_iosystem( the model system and returning the estimated state of the system, as determined by solving the optimal estimation problem. + Notes + ----- + The labels for the input signals for the system are determined + based on the signal names for the system model used in the optimal + estimation problem. The system name and signal names can be + overridden using the `name`, `input`, and `output` keywords, as + described in :func:`~control.InputOutputSystem`. + """ # Check to make sure we are in discrete time if self.system.dt == 0: raise ct.ControlNotImplemented( "MHE for continuous time systems not implemented") + # Figure out the location of the disturbances + self.ctrl_idx, self.dist_idx = \ + _process_control_disturbance_indices( + self.system, self.control_indices, self.disturbance_indices) + # Figure out the labels to use + # TODO: allow overwrite via kwargs + change parameter name if isinstance(output_labels, str): # Generate labels using the argument as a format string output_labels = [output_labels.format(i=i) for i in range(self.system.nstates)] - sensor_labels = 'y[{i}]' if sensor_labels is None else sensor_labels - if isinstance(sensor_labels, str): - # Generate labels using the argument as a format string - sensor_labels = [sensor_labels.format(i=i) - for i in range(self.system.noutputs - nd)] + # TODO: allow overwrite via kwargs + sensor_labels = [self.system.output_labels [i] + for i in range(self.system.noutputs)] + input_labels = [self.system.input_labels[i] for i in self.ctrl_idx] nstates = (self.system.nstates + self.system.ninputs + self.system.noutputs) * self.timepts.size @@ -1672,8 +1750,8 @@ def _mhe_update(t, xvec, uvec, params={}): # Estimator state = [xhat, v, Y, U] off, xhat = _xvec_next(xvec, 0, self.system.nstates) - off, U = _xvec_next(xvec, off, self.system.ninputs - nd) - off, V = _xvec_next(xvec, off, nd) + off, U = _xvec_next(xvec, off, len(self.ctrl_idx)) + off, V = _xvec_next(xvec, off, len(self.dist_idx)) off, Y = _xvec_next(xvec, off, self.system.noutputs) # Shift the states and add the new measurements and inputs @@ -1693,7 +1771,7 @@ def _mhe_update(t, xvec, uvec, params={}): est.states.reshape(-1), U.reshape(-1), est.inputs.reshape(-1), Y.reshape(-1)]) - # Ouput function + # Output function def _mhe_output(t, xvec, uvec, params={}): # Get the states and inputs off, xhat = _xvec_next(xvec, 0, self.system.nstates) @@ -1704,8 +1782,8 @@ def _mhe_output(t, xvec, uvec, params={}): return ct.NonlinearIOSystem( _mhe_update, _mhe_output, states=nstates, - inputs=sensor_labels + self.system.input_labels, - outputs=output_labels, dt=self.system.dt) + inputs=sensor_labels + input_labels, + outputs=output_labels, dt=self.system.dt, **kwargs) # Optimal estimation result @@ -1791,30 +1869,30 @@ def solve_oep( ---------- sys : InputOutputSystem I/O system for which the optimal input will be computed. - timepts : 1D array_like List of times at which the optimal input should be computed. - Y, U: 2D array_like Values of the outputs and inputs at each time point. - trajectory_cost : callable Function that returns the cost given the current state and input. Called as `cost(y, u, x0)`. - X0: 1D array_like, optional Mean value of the initial condition (defaults to 0). - trajectory_constraints : list of tuples, optional List of constraints that should hold at each point in the time vector. See :func:`solve_ocp` for more information. - + control_indices : int, slice, or list of int or string, optional + Specify the indices in the system input vector that correspond to + the control inputs. For more information on possible values, see + :func:`~control.optimal.OptimalEstimationProblem` + disturbance_indices : int, list of int, or slice, optional + Specify the indices in the system input vector that correspond to + the input disturbances. For more information on possible values, see + :func:`~control.optimal.OptimalEstimationProblem` initial_guess : 2D array_like, optional Initial guess for the state estimate at each time point. - print_summary : bool, optional If `True` (default), print a short summary of the computation. - squeeze : bool, optional If True and if the system has a single output, return the system output as a 1D array rather than a 2D array. If False, return the @@ -1826,32 +1904,28 @@ def solve_oep( res : TimeResponseData Bundle object with the estimated state and noise values. - res.success : bool - Boolean flag indicating whether the optimization was successful. - - res.time : array - Time values of the input. - - res.inputs : array - Disturbance values corresponding to the estimated state. If the - system is SISO and squeeze is not True, the array is 1D (indexed by - time). If the system is not SISO or squeeze is False, the array is - 2D (indexed by the output number and time). - - res.states : array - Estimated state vector over the given time points. - - res.outputs : array - Noise values corresponding to the estimated state. If the system - is SISO and squeeze is not True, the array is 1D (indexed by time). - If the system is not SISO or squeeze is False, the array is 2D - (indexed by the output number and time). + res.success : bool + Boolean flag indicating whether the optimization was successful. + res.time : array + Time values of the input. + res.inputs : array + Disturbance values corresponding to the estimated state. If + the system is SISO and squeeze is not True, the array is 1D + (indexed by time). If the system is not SISO or squeeze is + False, the array is 2D (indexed by the output number and time). + res.states : array + Estimated state vector over the given time points. + res.outputs : array + Noise values corresponding to the estimated state. If the + system is SISO and squeeze is not True, the array is 1D + (indexed by time). If the system is not SISO or squeeze is + False, the array is 2D (indexed by the output number and time). Notes ----- Additional keyword parameters can be used to fine tune the behavior of the underlying optimization and integration functions. See - :func:`OptimalControlProblem` for more information. + :func:`~control.optimal.OptimalControlProblem` for more information. """ # Set up the optimal control problem diff --git a/control/stochsys.py b/control/stochsys.py index 33d4b641f..fd361da9c 100644 --- a/control/stochsys.py +++ b/control/stochsys.py @@ -22,7 +22,8 @@ from .iosys import InputOutputSystem, LinearIOSystem, NonlinearIOSystem from .lti import LTI -from .namedio import isctime, isdtime, _process_indices +from .namedio import isctime, isdtime +from .namedio import _process_indices, _process_control_disturbance_indices from .mateqn import care, dare, _check_shape from .statesp import StateSpace, _ssmatrix from .exception import ControlArgument, ControlNotImplemented @@ -308,9 +309,8 @@ def dlqe(*args, **kwargs): # Function to create an estimator # -# TODO: add `control_indices` keyword to match create_mhe_iosystem (?) -# TODO: change name to create_kalmanestimaor_iosystem (?) # TODO: create predictor/corrector, UKF, and other variants (?) +# TODO: change *_labels to *_fmtstr and use signal keywords instead # def create_estimator_iosystem( sys, QN, RN, P0=None, G=None, C=None, @@ -441,35 +441,9 @@ def create_estimator_iosystem( # Set the state matrix for later use A = sys.A - # Set the disturbance matrices (indices take priority over G) - ctrl_idx = _process_indices( - control_indices, 'control', sys.input_labels, sys.ninputs) - - if disturbance_indices is None and control_indices is not None: - # Disturbance indices are the complement of control indices - dist_idx = [i for i in range(sys.ninputs) if i not in ctrl_idx] - if G is not None: - warn("'control_indices' and 'G' both specified; ignoring 'G'") - G = sys.B[:, dist_idx] - - elif disturbance_indices is not None: - if G is not None: - warn("'disturbance_indices' and 'G' both specified; ignoring 'G'") - - # If passed an integer, count from the end of the input vector - arg = -disturbance_indices if isinstance(disturbance_indices, int) \ - else disturbance_indices - - dist_idx = _process_indices( - arg, 'disturbance', sys.input_labels, sys.ninputs) - G = sys.B[:, dist_idx] - - # Set control indices to complement disturbance indices, if needed - if control_indices is None: - ctrl_idx = [i for i in range(sys.ninputs) if i not in dist_idx] - - elif G is None: - G = sys.B + # Determine the control and disturbance indices + ctrl_idx, dist_idx = _process_control_disturbance_indices( + sys, control_indices, disturbance_indices) # Set the input and direct matrices B = sys.B[:, ctrl_idx] @@ -491,6 +465,10 @@ def create_estimator_iosystem( if sensor_labels is None: sensor_labels = sys.output_labels + # Generate the disturbance matrix (G) + if G is None: + G = sys.B if len(dist_idx) == 0 else sys.B[:, dist_idx] + # Initialize the covariance matrix if P0 is None: # Initalize P0 to the steady state value diff --git a/control/tests/kwargs_test.py b/control/tests/kwargs_test.py index be701b177..7b423c474 100644 --- a/control/tests/kwargs_test.py +++ b/control/tests/kwargs_test.py @@ -221,6 +221,8 @@ def test_matplotlib_kwargs(function, nsysargs, moreargs, kwargs, mplcleanup): optimal_test.test_ocp_argument_errors, 'optimal.OptimalEstimationProblem.__init__': optimal_test.test_oep_argument_errors, + 'optimal.OptimalEstimationProblem.create_mhe_iosystem': + optimal_test.test_oep_argument_errors, } # diff --git a/control/tests/optimal_test.py b/control/tests/optimal_test.py index cbfa4e649..3aebe417f 100644 --- a/control/tests/optimal_test.py +++ b/control/tests/optimal_test.py @@ -786,3 +786,8 @@ def test_oep_argument_errors(): with pytest.raises(TypeError, match="unrecognized keyword"): oep = opt.OptimalEstimationProblem(sys, timepts, cost, unknown=True) + + with pytest.raises(TypeError, match="unrecognized keyword"): + sys = ct.rss(4, 2, 2, dt=True) + oep = opt.OptimalEstimationProblem(sys, timepts, cost) + oep.create_mhe_iosystem(unknown=True) diff --git a/control/tests/stochsys_test.py b/control/tests/stochsys_test.py index f34f4dedb..fbbd66631 100644 --- a/control/tests/stochsys_test.py +++ b/control/tests/stochsys_test.py @@ -430,6 +430,24 @@ def test_oep(dt): np.testing.assert_allclose( est2.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) + # Change around the inputs and disturbances + sys2 = ct.ss(sys.A, sys.B[:, ::-1], sys.C, sys.D[::-1], sys.dt) + oep2a = opt.OptimalEstimationProblem( + sys2, timepts, traj_cost, terminal_cost=init_cost, + control_indices=[1]) + est2a = oep2a.compute_estimate( + Y1, U, initial_guess=(est2.states, est2.inputs)) + np.testing.assert_allclose( + est2a.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) + + oep2b = opt.OptimalEstimationProblem( + sys2, timepts, traj_cost, terminal_cost=init_cost, + disturbance_indices=[0]) + est2b = oep2b.compute_estimate( + Y1, U, initial_guess=(est2.states, est2.inputs)) + np.testing.assert_allclose( + est2b.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) + # # Disturbance constraints # @@ -483,8 +501,9 @@ def test_mhe(): traj_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw) init_cost = lambda xhat, x: (xhat - x) @ P0 @ (xhat - x) oep = opt.OptimalEstimationProblem( - sys, mhe_timepts, traj_cost, terminal_cost=init_cost) - mhe = oep.create_mhe_iosystem(1) + sys, mhe_timepts, traj_cost, terminal_cost=init_cost, + disturbance_indices=1) + mhe = oep.create_mhe_iosystem() # Generate system data U = 10 * np.sin(timepts / (4*dt)) diff --git a/examples/mhe-pvtol.ipynb b/examples/mhe-pvtol.ipynb index 2295fc094..d9109c94b 100644 --- a/examples/mhe-pvtol.ipynb +++ b/examples/mhe-pvtol.ipynb @@ -617,8 +617,9 @@ "source": [ "mhe_timepts = timepts[0:10]\n", "oep = opt.OptimalEstimationProblem(\n", - " dsys, mhe_timepts, traj_cost, terminal_cost=init_cost)\n", - "mhe = oep.create_mhe_iosystem(2)\n", + " dsys, mhe_timepts, traj_cost, terminal_cost=init_cost,\n", + " disturbance_indices=slice(2, 4))\n", + "mhe = oep.create_mhe_iosystem()\n", " \n", "mhe_resp = ct.input_output_response(\n", " mhe, timepts, [Y, U], X0=x0, \n", @@ -650,8 +651,9 @@ "source": [ "mhe_timepts = timepts[0:8]\n", "oep = opt.OptimalEstimationProblem(\n", - " dsys, mhe_timepts, traj_cost, terminal_cost=init_cost)\n", - "mhe = oep.create_mhe_iosystem(2)\n", + " dsys, mhe_timepts, traj_cost, terminal_cost=init_cost,\n", + " disturbance_indices=slice(2, 4))\n", + "mhe = oep.create_mhe_iosystem()\n", " \n", "mhe_resp = ct.input_output_response(\n", " mhe, timepts, [Y, U],\n", From ebedf193fd9c6f9b026d3e2eff9e54bb15f51321 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 12 Mar 2023 22:53:51 -0700 Subject: [PATCH 08/14] regularize *_labels processing across create_*_iosystem --- control/config.py | 23 ++++++++ control/iosys.py | 2 +- control/namedio.py | 18 +++++++ control/optimal.py | 78 ++++++++++++++++++--------- control/statefbk.py | 26 ++++----- control/stochsys.py | 99 +++++++++++++++++++++------------- control/tests/kwargs_test.py | 3 +- control/tests/optimal_test.py | 5 ++ control/tests/stochsys_test.py | 4 ++ 9 files changed, 175 insertions(+), 83 deletions(-) diff --git a/control/config.py b/control/config.py index 37763a6b8..3efd1f7c0 100644 --- a/control/config.py +++ b/control/config.py @@ -10,6 +10,7 @@ import collections import warnings +from .exception import ControlArgument __all__ = ['defaults', 'set_defaults', 'reset_defaults', 'use_matlab_defaults', 'use_fbs_defaults', @@ -310,3 +311,25 @@ def use_legacy_defaults(version): set_defaults('nyquist', mirror_style='-') return (major, minor, patch) + + +# +# Utility function for processing legacy keywords +# +# Use this function to handle a legacy keyword that has been renamed. This +# function pops the old keyword off of the kwargs dictionary and issues a +# warning. if both the old and new keyword are present, a ControlArgument +# exception is raised. +# +def _process_legacy_keyword(kwargs, oldkey, newkey, newval): + if kwargs.get(oldkey) is not None: + warnings.warn( + f"keyworld '{oldkey}' is deprecated; use '{newkey}'", + DeprecationWarning) + if newval is not None: + raise ControlArgument( + f"duplicate keywords '{oldkey}' and '{newkey}'") + else: + return kwargs.pop(oldkey) + else: + return newval diff --git a/control/iosys.py b/control/iosys.py index 6b0f6cfaa..a804a7f59 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -82,7 +82,7 @@ class for a set of subclasses that are used to implement specific System name (used for specifying signals). If unspecified, a generic name is generated with a unique integer id. params : dict, optional - Parameter values for the systems. Passed to the evaluation functions + Parameter values for the system. Passed to the evaluation functions for the system as default values, overriding internal defaults. Attributes diff --git a/control/namedio.py b/control/namedio.py index df7d519fd..8f61514fe 100644 --- a/control/namedio.py +++ b/control/namedio.py @@ -666,3 +666,21 @@ def _process_control_disturbance_indices( ctrl_idx = [i for i in range(sys.ninputs) if i not in dist_idx] return ctrl_idx, dist_idx + + +# Process labels +def _process_labels(labels, name, default): + if isinstance(labels, str): + labels = [labels.format(i=i) for i in range(len(default))] + + if labels is None: + labels = default + elif isinstance(labels, list): + if len(labels) != len(default): + raise ValueError( + f"incorrect length of {name}_labels: {len(labels)}" + f" instead of {len(default)}") + else: + raise ValueError(f"{name}_labels should be a string or a list") + + return labels diff --git a/control/optimal.py b/control/optimal.py index f19fd91f7..88f17ae39 100644 --- a/control/optimal.py +++ b/control/optimal.py @@ -18,7 +18,9 @@ from . import config from .exception import ControlNotImplemented -from .namedio import _process_indices, _process_control_disturbance_indices +from .namedio import _process_indices, _process_labels, \ + _process_control_disturbance_indices + # Define module default parameter values _optimal_trajectory_methods = {'shooting', 'collocation'} @@ -859,11 +861,11 @@ def _output(t, x, u, params={}): return res.inputs[:, 0] # Define signal names, if they are not already given - if not kwargs.get('inputs'): + if kwargs.get('inputs') is None: kwargs['inputs'] = self.system.state_labels - if not kwargs.get('outputs'): + if kwargs.get('outputs') is None: kwargs['outputs'] = self.system.input_labels - if not kwargs.get('states'): + if kwargs.get('states') is None: kwargs['states'] = self.system.ninputs * \ (self.timepts.size if self.basis is None else self.basis.N) @@ -1125,6 +1127,15 @@ def create_mpc_iosystem( returning the current input to be applied that minimizes the cost function while satisfying the constraints. + Other Parameters + ---------------- + inputs, outputs, states : int or list of str, optional + Set the names of the inputs, outputs, and states, as described in + :func:`~control.InputOutputSystem`. + name : string, optional + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. + Notes ----- Additional keyword parameters can be used to fine tune the behavior of @@ -1676,9 +1687,9 @@ def compute_estimate( # xhat, u, v, y for all previous time points. When the system update # function is called, # - # TODO: change output_labels to output_fmtstr and use output instead - # - def create_mhe_iosystem(self, output_labels=None, **kwargs): + def create_mhe_iosystem( + self, estimate_labels=None, measurement_labels=None, + control_labels=None, inputs=None, outputs=None, **kwargs): """Create an I/O system implementing an MPC controller This function creates an input/output system that implements a @@ -1688,12 +1699,24 @@ def create_mhe_iosystem(self, output_labels=None, **kwargs): Parameters ---------- - output_labels : str, optional - Set the name of the estimator outputs (state estimate). If a - single string is specified, it should be a format string using - the variable `i` as an index. Otherwise, a list of strings - matching the size of the system state should be used. Default - is "xhat[{i}]". + estimate_labels : str or list of str, optional + Set the name of the signals to use for the estimated state + (estimator outputs). If a single string is specified, it + should be a format string using the variable ``i`` as an index. + Otherwise, a list of strings matching the size of the estimated + state should be used. Default is "xhat[{i}]". These settings + can also be overriden using the `outputs` keyword. + measurement_labels, control_labels : str or list of str, optional + Set the name of the measurement and control signal names + (estimator inputs). If a single string is specified, it should + be a format string using the variable ``i`` as an index. + Otherwise, a list of strings matching the size of the system + inputs and outputs should be used. Default is the signal names + for the system outputs and control inputs. These settings can + also be overriden using the `inputs` keyword. + **kwargs, optional + Additional keyword arguments to set system, input, and output + signal names; see :func:`~control.InputOutputSystem`. Returns ------- @@ -1721,20 +1744,24 @@ def create_mhe_iosystem(self, output_labels=None, **kwargs): _process_control_disturbance_indices( self.system, self.control_indices, self.disturbance_indices) - # Figure out the labels to use - # TODO: allow overwrite via kwargs + change parameter name - if isinstance(output_labels, str): - # Generate labels using the argument as a format string - output_labels = [output_labels.format(i=i) - for i in range(self.system.nstates)] + # Figure out the signal labels to use + estimate_labels = _process_labels( + estimate_labels, 'estimate', + [f'xhat[{i}]' for i in range(self.system.nstates)]) + outputs = estimate_labels if outputs is None else outputs - # TODO: allow overwrite via kwargs - sensor_labels = [self.system.output_labels [i] - for i in range(self.system.noutputs)] - input_labels = [self.system.input_labels[i] for i in self.ctrl_idx] + measurement_labels = _process_labels( + measurement_labels, 'measurement', self.system.output_labels) + control_labels = _process_labels( + control_labels, 'control', + [self.system.input_labels[i] for i in self.ctrl_idx]) + inputs = measurement_labels + control_labels if inputs is None \ + else inputs nstates = (self.system.nstates + self.system.ninputs + self.system.noutputs) * self.timepts.size + if kwargs.get('states'): + raise ValueError("user-specified state signal names not allowed") # Utility function to extract elements from MHE state vector def _xvec_next(xvec, off, size): @@ -1781,9 +1808,8 @@ def _mhe_output(t, xvec, uvec, params={}): return self.system._rhs(t, xhat[:, -1], u_v[:, -1]) return ct.NonlinearIOSystem( - _mhe_update, _mhe_output, states=nstates, - inputs=sensor_labels + input_labels, - outputs=output_labels, dt=self.system.dt, **kwargs) + _mhe_update, _mhe_output, dt=self.system.dt, + states=nstates, inputs=inputs, outputs=outputs, **kwargs) # Optimal estimation result diff --git a/control/statefbk.py b/control/statefbk.py index 02bbad3ec..61321d265 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -48,11 +48,12 @@ from .mateqn import care, dare, _check_shape from .statesp import StateSpace, _ssmatrix, _convert_to_statespace from .lti import LTI -from .namedio import isdtime, isctime, _process_indices +from .namedio import isdtime, isctime, _process_indices, _process_labels from .iosys import InputOutputSystem, NonlinearIOSystem, LinearIOSystem, \ interconnect, ss from .exception import ControlSlycot, ControlArgument, ControlDimension, \ ControlNotImplemented +from .config import _process_legacy_keyword # Make sure we have access to the right slycot routines try: @@ -602,7 +603,7 @@ def dlqr(*args, **kwargs): # Function to create an I/O sytems representing a state feedback controller def create_statefbk_iosystem( sys, gain, integral_action=None, estimator=None, controller_type=None, - xd_labels='xd[{i}]', ud_labels='ud[{i}]', gainsched_indices=None, + xd_labels=None, ud_labels=None, gainsched_indices=None, gainsched_method='linear', control_indices=None, state_indices=None, name=None, inputs=None, outputs=None, states=None, **kwargs): """Create an I/O system using a (full) state feedback controller @@ -747,14 +748,8 @@ def create_statefbk_iosystem( raise ControlArgument("Input system must be I/O system") # Process (legacy) keywords - if kwargs.get('type') is not None: - warnings.warn( - "keyword 'type' is deprecated; use 'controller_type'", - DeprecationWarning) - if controller_type is not None: - raise ControlArgument( - "duplicate keywords 'type` and 'controller_type'") - controller_type = kwargs.pop('type') + controller_type = _process_legacy_keyword( + kwargs, 'type', 'controller_type', controller_type) if kwargs: raise TypeError("unrecognized keywords: ", str(kwargs)) @@ -837,13 +832,10 @@ def create_statefbk_iosystem( raise ControlArgument(f"unknown controller_type '{controller_type}'") # Figure out the labels to use - if isinstance(xd_labels, str): - # Generate the list of labels using the argument as a format string - xd_labels = [xd_labels.format(i=i) for i in range(sys_nstates)] - - if isinstance(ud_labels, str): - # Generate the list of labels using the argument as a format string - ud_labels = [ud_labels.format(i=i) for i in range(sys_ninputs)] + xd_labels = _process_labels( + xd_labels, 'xd', ['xd[{i}]'.format(i=i) for i in range(sys_nstates)]) + ud_labels = _process_labels( + ud_labels, 'ud', ['ud[{i}]'.format(i=i) for i in range(sys_ninputs)]) # Create the signal and system names if inputs is None: diff --git a/control/stochsys.py b/control/stochsys.py index fd361da9c..1a3ba2cb7 100644 --- a/control/stochsys.py +++ b/control/stochsys.py @@ -23,10 +23,12 @@ from .iosys import InputOutputSystem, LinearIOSystem, NonlinearIOSystem from .lti import LTI from .namedio import isctime, isdtime -from .namedio import _process_indices, _process_control_disturbance_indices +from .namedio import _process_indices, _process_labels, \ + _process_control_disturbance_indices from .mateqn import care, dare, _check_shape from .statesp import StateSpace, _ssmatrix from .exception import ControlArgument, ControlNotImplemented +from .config import _process_legacy_keyword __all__ = ['lqe', 'dlqe', 'create_estimator_iosystem', 'white_noise', 'correlation'] @@ -315,8 +317,9 @@ def dlqe(*args, **kwargs): def create_estimator_iosystem( sys, QN, RN, P0=None, G=None, C=None, control_indices=None, disturbance_indices=None, - state_labels='xhat[{i}]', output_labels='xhat[{i}]', - covariance_labels='P[{i},{j}]', sensor_labels=None): + estimate_labels='xhat[{i}]', covariance_labels='P[{i},{j}]', + measurement_labels=None, control_labels=None, + inputs=None, outputs=None, states=None, **kwargs): r"""Create an I/O system implementing a linear quadratic estimator This function creates an input/output system that implements a @@ -391,10 +394,10 @@ def create_estimator_iosystem( as either integer offsets or as system input signal names. If not specified, the disturbances are assumed to be added to the system inputs. - state_labels : str or list of str, optional - Set the names of the internal state estimate variables. If a - single string is specified, it should be a format string using the - variable `i` as an index. Otherwise, a list of strings matching + estimate_labels : str or list of str, optional + Set the names of the state estimate variables (estimator outputs). + If a single string is specified, it should be a format string using + the variable `i` as an index. Otherwise, a list of strings matching the number of system states should be used. Default is "xhat[{i}]". covariance_labels : str or list of str, optional Set the name of the the covariance state variables. If a single @@ -402,16 +405,20 @@ def create_estimator_iosystem( variables `i` and `j` as indices. Otherwise, a list of strings matching the size of the covariance matrix should be used. Default is "P[{i},{j}]". - sensor_labels : str or list of str, optional - Set the name of the sensor signals (estimator inputs). If - specified, it should be a format string using the variable `i` as - an index. Otherwise, a list of strings matching the size of the - measured system outputs should be used. Default is "y[{i}]". - output_labels : str or list of str, optional - Set the name of the estimator outputs (state estimate). If a - single string is specified, it should be a format string using the - variable `i` as an index. Otherwise, a list of strings matching - the size of the system state should be used. Default is "xhat[{i}]". + measurement_labels, control_labels : str or list of str, optional + Set the name of the measurement and control signal names (estimator + inputs). If a single string is specified, it should be a format + string using the variable ``i`` as an index. Otherwise, a list of + strings matching the size of the system inputs and outputs should + be used. Default is the signal names for the system outputs and + control inputs. These settings can also be overriden using the + `inputs` keyword. + inputs, outputs, states : int or list of str, optional + Set the names of the inputs, outputs, and states, as described in + :func:`~control.InputOutputSystem`. + name : string, optional + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. Notes ----- @@ -438,6 +445,21 @@ def create_estimator_iosystem( if not isinstance(sys, LinearIOSystem): raise ControlArgument("Input system must be a linear I/O system") + # Process legacy keywords + estimate_labels = _process_legacy_keyword( + kwargs, 'output_labels', 'estimate_labels', estimate_labels) + measurement_labels = _process_legacy_keyword( + kwargs, 'sensor_labels', 'measurement_labels', measurement_labels) + + # Separate state_labels no longer supported => special processing required + if kwargs.get('state_labels'): + if estimate_labels is None: + estimate_labels = _process_legacy_keyword( + kwargs, 'state_labels', estimate_labels) + else: + warnings.warn( + "deprecated 'state_labels' ignored; use 'state' instead") + # Set the state matrix for later use A = sys.A @@ -462,8 +484,6 @@ def create_estimator_iosystem( else: # Use the system outputs as the sensor outputs C = sys.C - if sensor_labels is None: - sensor_labels = sys.output_labels # Generate the disturbance matrix (G) if G is None: @@ -475,28 +495,32 @@ def create_estimator_iosystem( _, P0, _ = lqe(A, G, C, QN, RN) # Figure out the labels to use - if isinstance(state_labels, str): - # Generate the list of labels using the argument as a format string - state_labels = [state_labels.format(i=i) for i in range(sys.nstates)] + estimate_labels = _process_labels( + estimate_labels, 'estimate', + [f'xhat[{i}]' for i in range(sys.nstates)]) + outputs = estimate_labels if outputs is None else outputs + + if C is None: + # System outputs are the input to the estimator + measurement_labels = _process_labels( + measurement_labels, 'measurement', sys.output_labels) + else: + # Generate labels corresponding to measured values from C + measurement_labels = _process_labels( + measurement_labels, 'measurement', + [f'y[{i}]' for i in range(C.shape[0])]) + control_labels = _process_labels( + control_labels, 'control', + [sys.input_labels[i] for i in ctrl_idx]) + inputs = measurement_labels + control_labels if inputs is None \ + else inputs if isinstance(covariance_labels, str): # Generate the list of labels using the argument as a format string covariance_labels = [ covariance_labels.format(i=i, j=j) \ for i in range(sys.nstates) for j in range(sys.nstates)] - - if isinstance(output_labels, str): - # Generate the list of labels using the argument as a format string - output_labels = [output_labels.format(i=i) for i in range(sys.nstates)] - - sensor_labels = 'y[{i}]' if sensor_labels is None else sensor_labels - if isinstance(sensor_labels, str): - # Generate the list of labels using the argument as a format string - sensor_labels = [sensor_labels.format(i=i) for i in range(C.shape[0])] - - # Set the input labels based on the system input - # TODO: allow these to be overriden - input_labels = [sys.input_labels[i] for i in ctrl_idx] + states = estimate_labels + covariance_labels if states is None else states if isctime(sys): # Create an I/O system for the state feedback gains @@ -568,9 +592,8 @@ def _estim_output(t, x, u, params): # Define the estimator system return NonlinearIOSystem( - _estim_update, _estim_output, states=state_labels + covariance_labels, - inputs=sensor_labels + input_labels, outputs=output_labels, - dt=sys.dt) + _estim_update, _estim_output, dt=sys.dt, + states=states, inputs=inputs, outputs=outputs, **kwargs) def white_noise(T, Q, dt=0): diff --git a/control/tests/kwargs_test.py b/control/tests/kwargs_test.py index 7b423c474..f94009549 100644 --- a/control/tests/kwargs_test.py +++ b/control/tests/kwargs_test.py @@ -24,9 +24,9 @@ import control.tests.interconnect_test as interconnect_test import control.tests.optimal_test as optimal_test import control.tests.statefbk_test as statefbk_test +import control.tests.stochsys_test as stochsys_test import control.tests.trdata_test as trdata_test - @pytest.mark.parametrize("module, prefix", [ (control, ""), (control.flatsys, "flatsys."), (control.optimal, "optimal.") ]) @@ -161,6 +161,7 @@ def test_matplotlib_kwargs(function, nsysargs, moreargs, kwargs, mplcleanup): kwarg_unittest = { 'bode': test_matplotlib_kwargs, 'bode_plot': test_matplotlib_kwargs, + 'create_estimator_iosystem': stochsys_test.test_estimator_errors, 'create_statefbk_iosystem': statefbk_test.TestStatefbk.test_statefbk_errors, 'describing_function_plot': test_matplotlib_kwargs, 'dlqe': test_unrecognized_kwargs, diff --git a/control/tests/optimal_test.py b/control/tests/optimal_test.py index 3aebe417f..50dfa3bb2 100644 --- a/control/tests/optimal_test.py +++ b/control/tests/optimal_test.py @@ -791,3 +791,8 @@ def test_oep_argument_errors(): sys = ct.rss(4, 2, 2, dt=True) oep = opt.OptimalEstimationProblem(sys, timepts, cost) oep.create_mhe_iosystem(unknown=True) + + # Incorrect number of signals + with pytest.raises(ValueError, match="incorrect length"): + oep = opt.OptimalEstimationProblem(sys, timepts, cost) + mhe = oep.create_mhe_iosystem(estimate_labels=['x1', 'x2', 'x3']) diff --git a/control/tests/stochsys_test.py b/control/tests/stochsys_test.py index fbbd66631..5a782d88a 100644 --- a/control/tests/stochsys_test.py +++ b/control/tests/stochsys_test.py @@ -230,6 +230,9 @@ def test_estimator_errors(): QN = np.eye(sys.ninputs) RN = np.eye(sys.noutputs) + with pytest.raises(TypeError, match="unrecognized keyword"): + estim = ct.create_estimator_iosystem(sys, QN, RN, unknown=True) + with pytest.raises(ct.ControlArgument, match=".* system must be a linear"): sys_tf = ct.tf([1], [1, 1], dt=True) estim = ct.create_estimator_iosystem(sys_tf, QN, RN) @@ -517,6 +520,7 @@ def test_mhe(): # Make sure the estimated state is close to the actual state np.testing.assert_allclose(estp.outputs, resp.states, atol=1e-2, rtol=1e-4) +@pytest.mark.slow @pytest.mark.parametrize("ctrl_indices, dist_indices", [ (slice(0, 3), None), (3, None), From df4508c39021da0a82c8ce50da067cafcc844303 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Mon, 13 Mar 2023 22:39:21 -0700 Subject: [PATCH 09/14] updated docstrings and docs, trim slow unit tests --- control/optimal.py | 85 ++++++++++++------------ control/statefbk.py | 63 +++++++++--------- control/stochsys.py | 26 ++++---- control/tests/optimal_test.py | 1 + control/tests/stochsys_test.py | 118 ++++++++++++++++----------------- doc/optimal.rst | 23 ++++--- 6 files changed, 159 insertions(+), 157 deletions(-) diff --git a/control/optimal.py b/control/optimal.py index 88f17ae39..ffd2828fd 100644 --- a/control/optimal.py +++ b/control/optimal.py @@ -1038,7 +1038,7 @@ def solve_ocp( Notes ----- - Additional keyword parameters can be used to fine tune the behavior of + Additional keyword parameters can be used to fine-tune the behavior of the underlying optimization and integration functions. See :func:`OptimalControlProblem` for more information. @@ -1138,7 +1138,7 @@ def create_mpc_iosystem( Notes ----- - Additional keyword parameters can be used to fine tune the behavior of + Additional keyword parameters can be used to fine-tune the behavior of the underlying optimization and integrations functions. See :func:`OptimalControlProblem` for more information. @@ -1189,15 +1189,15 @@ class OptimalEstimationProblem(): control_indices : int, slice, or list of int or string, optional Specify the indices in the system input vector that correspond to the control inputs. These inputs will be used as known control - inputs for the estimate. If value is an integer `m`, the first `m` - system inputs are used. Otherwise, the value should be a slice or - a list of indices. The list of indices can be specified as either - integer offsets or as system input signal names. If not specified, - defaults to the complement of the disturbance indices (see also - notes below). + inputs for the estimator. If value is an integer `m`, the first + `m` system inputs are used. Otherwise, the value should be a slice + or a list of indices. The list of indices can be specified as + either integer offsets or as system input signal names. If not + specified, defaults to the complement of the disturbance indices + (see also notes below). disturbance_indices : int, list of int, or slice, optional Specify the indices in the system input vector that correspond to - the input disturbances. If value is an integer `m`, the last `m` + the process disturbances. If value is an integer `m`, the last `m` system inputs are used. Otherwise, the value should be a slice or a list of indices, as describedf for `control_indices`. If not specified, defaults to the complement of the control indicies (see @@ -1227,14 +1227,13 @@ class OptimalEstimationProblem(): Notes ----- - To describe an optimal estimation problem we need an input/output - system, a set of time points, measured inputs and outputs, a cost - function, and (optionally) a set of constraints on the state - and/or inputs along the trajectory (and at the terminal time). - This class sets up an optimization over the state and disturbances - at each point in time, using the integral and terminal costs as - well as the trajectory constraints. The - :func:`~control.optimal.OptimalEstimationProblem.compute_estimate` + To describe an optimal estimation problem we need an input/output system, + a set of time points, applied inputs and measured outputs, a cost + function, and (optionally) a set of constraints on the state and/or inputs + along the trajectory (and at the terminal time). This class sets up an + optimization over the state and disturbances at each point in time, using + the integral and terminal costs as well as the trajectory constraints. + The :func:`~control.optimal.OptimalEstimationProblem.compute_estimate` method solves the underling optimization problem using :func:`scipy.optimize.minimize`. @@ -1245,12 +1244,11 @@ class OptimalEstimationProblem(): the same as the control inputs. The "cost" (e.g. negative of the log likelihood) of the estimated - trajectory generated by the estimated state, the disturbances and - noise, and the measured output. It does this by calling a user-defined - function for the integral_cost given the current estimated states, - inputs, and measured outputs at each point along the trajectory and - then adding the value of a user-defined terminal cost at the initial - point in the trajectory. + trajectory is computed using the estimated state, the disturbances and + noise, and the measured output. This is done by calling a user-defined + function for the integral_cost along the trajectory and then adding the + value of a user-defined terminal cost at the initial point in the + trajectory. The constraint functions are evaluated at each point on the trajectory generated by the proposed estimate and disturbances. As in the case of @@ -1261,8 +1259,8 @@ class OptimalEstimationProblem(): so that it only needs to be computed once. The default values for ``minimize_method``, ``minimize_options``, - ``minimize_kwargs``, ``solve_ivp_method``, and ``solve_ivp_options`` can - be set using config.defaults['optimal.']. + ``minimize_kwargs``, ``solve_ivp_method``, and ``solve_ivp_options`` + can be set using config.defaults['optimal.']. """ def __init__( @@ -1628,7 +1626,7 @@ def compute_estimate( ------- res : OptimalEstimationResult Bundle object with the results of the optimal estimation problem. - res.success: bool + res.success : bool Boolean flag indicating whether the optimization was successful. res.time : array Time values of the input (same as self.timepts). @@ -1929,27 +1927,26 @@ def solve_oep( ------- res : TimeResponseData Bundle object with the estimated state and noise values. - - res.success : bool - Boolean flag indicating whether the optimization was successful. - res.time : array - Time values of the input. - res.inputs : array - Disturbance values corresponding to the estimated state. If - the system is SISO and squeeze is not True, the array is 1D - (indexed by time). If the system is not SISO or squeeze is - False, the array is 2D (indexed by the output number and time). - res.states : array - Estimated state vector over the given time points. - res.outputs : array - Noise values corresponding to the estimated state. If the - system is SISO and squeeze is not True, the array is 1D - (indexed by time). If the system is not SISO or squeeze is - False, the array is 2D (indexed by the output number and time). + res.success : bool + Boolean flag indicating whether the optimization was successful. + res.time : array + Time values of the input. + res.inputs : array + Disturbance values corresponding to the estimated state. If the + system is SISO and squeeze is not True, the array is 1D (indexed by + time). If the system is not SISO or squeeze is False, the array is + 2D (indexed by the output number and time). + res.states : array + Estimated state vector over the given time points. + res.outputs : array + Noise values corresponding to the estimated state. If the system + is SISO and squeeze is not True, the array is 1D (indexed by time). + If the system is not SISO or squeeze is False, the array is 2D + (indexed by the output number and time). Notes ----- - Additional keyword parameters can be used to fine tune the behavior of + Additional keyword parameters can be used to fine-tune the behavior of the underlying optimization and integration functions. See :func:`~control.optimal.OptimalControlProblem` for more information. diff --git a/control/statefbk.py b/control/statefbk.py index 61321d265..779e53555 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -341,11 +341,11 @@ def lqr(*args, **kwargs): integral_action : ndarray, optional If this keyword is specified, the controller includes integral action in addition to state feedback. The value of the - `integral_action`` keyword should be an ndarray that will be + `integral_action` keyword should be an ndarray that will be multiplied by the current state to generate the error for the internal integrator states of the control law. The number of outputs that are to be integrated must match the number of - additional rows and columns in the ``Q`` matrix. + additional rows and columns in the `Q` matrix. method : str, optional Set the method used for computing the result. Current methods are 'slycot' and 'scipy'. If set to None (default), try 'slycot' first @@ -491,11 +491,11 @@ def dlqr(*args, **kwargs): integral_action : ndarray, optional If this keyword is specified, the controller includes integral action in addition to state feedback. The value of the - `integral_action`` keyword should be an ndarray that will be + `integral_action` keyword should be an ndarray that will be multiplied by the current state to generate the error for the internal integrator states of the control law. The number of outputs that are to be integrated must match the number of - additional rows and columns in the ``Q`` matrix. + additional rows and columns in the `Q` matrix. method : str, optional Set the method used for computing the result. Current methods are 'slycot' and 'scipy'. If set to None (default), try 'slycot' first @@ -617,9 +617,9 @@ def create_statefbk_iosystem( ctrl, clsys = ct.create_statefbk_iosystem(sys, K) - where ``sys`` is the process dynamics and ``K`` is the state (+ integral) + where `sys` is the process dynamics and `K` is the state (+ integral) feedback gain (eg, from LQR). The function returns the controller - ``ctrl`` and the closed loop systems ``clsys``, both as I/O systems. + `ctrl` and the closed loop systems `clsys`, both as I/O systems. A gain scheduled controller can also be created, by passing a list of gains and a corresponding list of values of a set of scheduling @@ -636,32 +636,32 @@ def create_statefbk_iosystem( is given, the output of this system should represent the full state. gain : ndarray or tuple - If a array is give, it represents the state feedback gain (K). + If an array is given, it represents the state feedback gain (K). This matrix defines the gains to be applied to the system. If - ``integral_action`` is None, then the dimensions of this array + `integral_action` is None, then the dimensions of this array should be (sys.ninputs, sys.nstates). If `integral action` is set to a matrix or a function, then additional columns represent the gains of the integral states of the controller. If a tuple is given, then it specifies a gain schedule. The tuple - should be of the form ``(gains, points)`` where gains is a list of + should be of the form `(gains, points)` where gains is a list of gains :math:`K_j` and points is a list of values :math:`\\mu_j` at which the gains are computed. The `gainsched_indices` parameter should be used to specify the scheduling variables. xd_labels, ud_labels : str or list of str, optional - Set the name of the signals to use for the desired state and inputs. - If a single string is specified, it should be a format string using - the variable ``i`` as an index. Otherwise, a list of strings - matching the size of xd and ud, respectively, should be used. - Default is ``'xd[{i}]'`` for xd_labels and ``'ud[{i}]'`` for - ud_labels. These settings can also be overriden using the `inputs` - keyword. + Set the name of the signals to use for the desired state and + inputs. If a single string is specified, it should be a + format string using the variable `i` as an index. Otherwise, + a list of strings matching the size of xd and ud, + respectively, should be used. Default is "xd[{i}]" for + xd_labels and "ud[{i}]" for ud_labels. These settings can + also be overriden using the `inputs` keyword. integral_action : ndarray, optional If this keyword is specified, the controller can include integral action in addition to state feedback. The value of the - `integral_action`` keyword should be an ndarray that will be + `integral_action` keyword should be an ndarray that will be multiplied by the current and desired state to generate the error for the internal integrator states of the control law. @@ -678,7 +678,7 @@ def create_statefbk_iosystem( [xd, ud, x] vector are used. Otherwise, the value should be a slice or a list of indices. The list of indices can be specified as either integer offsets or as signal names. The default is to - use the desire state xd. + use the desired state xd. gainsched_method : str, optional The method to use for gain scheduling. Possible values are 'linear' @@ -691,28 +691,29 @@ def create_statefbk_iosystem( Set the type of controller to create. The default for a linear gain is a linear controller implementing the LQR regulator. If the type is 'nonlinear', a :class:NonlinearIOSystem is created instead, with - the gain ``K`` as a parameter (allowing modifications of the gain at + the gain `K` as a parameter (allowing modifications of the gain at runtime). If the gain parameter is a tuple, then a nonlinear, gain-scheduled controller is created. Returns ------- ctrl : InputOutputSystem - Input/output system representing the controller. This system takes - as inputs the desired state ``xd``, the desired input ``ud``, and - either the system state ``x`` or the estimated state ``xhat``. It - outputs the controller action u according to the formula :math:`u = - u_d - K(x - x_d)`. If the keyword ``integral_action`` is specified, - then an additional set of integrators is included in the control - system (with the gain matrix ``K`` having the integral gains - appended after the state gains). If a gain scheduled controller is - specified, the gain (proportional and integral) are evaluated using - the scheduling variables specified by ``gainsched_indices``. + Input/output system representing the controller. This system + takes as inputs the desired state `xd`, the desired input + `ud`, and either the system state `x` or the estimated state + `xhat`. It outputs the controller action `u` according to the + formula :math:`u = u_d - K(x - x_d)`. If the keyword + `integral_action` is specified, then an additional set of + integrators is included in the control system (with the gain + matrix `K` having the integral gains appended after the state + gains). If a gain scheduled controller is specified, the gain + (proportional and integral) are evaluated using the scheduling + variables specified by `gainsched_indices`. clsys : InputOutputSystem Input/output system representing the closed loop system. This - systems takes as inputs the desired trajectory ``(xd, ud)`` and - outputs the system state ``x`` and the applied input ``u`` + systems takes as inputs the desired trajectory `(xd, ud)` and + outputs the system state `x` and the applied input `u` (vertically stacked). Other Parameters diff --git a/control/stochsys.py b/control/stochsys.py index 1a3ba2cb7..ff9f756ae 100644 --- a/control/stochsys.py +++ b/control/stochsys.py @@ -312,7 +312,6 @@ def dlqe(*args, **kwargs): # Function to create an estimator # # TODO: create predictor/corrector, UKF, and other variants (?) -# TODO: change *_labels to *_fmtstr and use signal keywords instead # def create_estimator_iosystem( sys, QN, RN, P0=None, G=None, C=None, @@ -344,19 +343,17 @@ def create_estimator_iosystem( estim = ct.create_estimator_iosystem(sys, QN, RN) where `sys` is the process dynamics and `QN` and `RN` are the covariance - of the disturbance noise and sensor noise. The function returns the - estimator `estim` as I/O system with a parameter `correct` that can + of the disturbance noise and measurement noise. The function returns + the estimator `estim` as I/O system with a parameter `correct` that can be used to turn off the correction term in the estimation (for forward predictions). Parameters ---------- sys : LinearIOSystem - The linear I/O system that represents the process dynamics. If no - estimator is given, the output of this system should represent the - full state. + The linear I/O system that represents the process dynamics. QN, RN : ndarray - Process and sensor noise covariance matrices. + Disturbance and measurement noise covariance matrices. P0 : ndarray, optional Initial covariance matrix. If not specified, defaults to the steady state covariance. @@ -409,13 +406,13 @@ def create_estimator_iosystem( Set the name of the measurement and control signal names (estimator inputs). If a single string is specified, it should be a format string using the variable ``i`` as an index. Otherwise, a list of - strings matching the size of the system inputs and outputs should - be used. Default is the signal names for the system outputs and - control inputs. These settings can also be overriden using the + strings matching the size of the system inputs and outputs should be + used. Default is the signal names for the system measurements and + known control inputs. These settings can also be overriden using the `inputs` keyword. inputs, outputs, states : int or list of str, optional Set the names of the inputs, outputs, and states, as described in - :func:`~control.InputOutputSystem`. + :func:`~control.InputOutputSystem`. Overrides signal labels. name : string, optional System name (used for specifying signals). If unspecified, a generic name is generated with a unique integer id. @@ -434,7 +431,7 @@ def create_estimator_iosystem( resp = ct.input_output_response(est, T, [Y, U], [X0, P0]) If desired, the ``correct`` parameter can be set to ``False`` to allow - prediction with no additional sensor information:: + prediction with no additional measurement information:: resp = ct.input_output_response( est, T, 0, [X0, P0], param={'correct': False) @@ -458,7 +455,8 @@ def create_estimator_iosystem( kwargs, 'state_labels', estimate_labels) else: warnings.warn( - "deprecated 'state_labels' ignored; use 'state' instead") + "deprecated 'state_labels' ignored; use 'states' instead") + kwargs.pop('state_labels') # Set the state matrix for later use A = sys.A @@ -482,7 +480,7 @@ def create_estimator_iosystem( if C.shape[0] != RN.shape[0]: raise ValueError("System output is the wrong size for C") else: - # Use the system outputs as the sensor outputs + # Use the system outputs as the measurements C = sys.C # Generate the disturbance matrix (G) diff --git a/control/tests/optimal_test.py b/control/tests/optimal_test.py index 50dfa3bb2..340f59391 100644 --- a/control/tests/optimal_test.py +++ b/control/tests/optimal_test.py @@ -551,6 +551,7 @@ def test_ocp_argument_errors(): sys, time, x0, cost, solve_ivp_kwargs={'eps': 0.1}) +@pytest.mark.slow @pytest.mark.parametrize("basis", [ flat.PolyFamily(4), flat.PolyFamily(6), flat.BezierFamily(4), flat.BSplineFamily([0, 4, 8], 6) diff --git a/control/tests/stochsys_test.py b/control/tests/stochsys_test.py index 5a782d88a..1ae0827a5 100644 --- a/control/tests/stochsys_test.py +++ b/control/tests/stochsys_test.py @@ -326,6 +326,7 @@ def test_correlation(): @pytest.mark.parametrize('dt', [0, 1]) def test_oep(dt): # Define the system to test, with additional input + # Use fixed system to avoid random errors (was csys = ct.rss(4, 2, 5)) csys = ct.ss( [[-0.5, 1, 0, 0], [0, -1, 1, 0], [0, 0, -2, 1], [0, 0, 0, -3]], # A [[0, 0.1], [0, 0.1], [0, 0.1], [1, 0.1]], # B @@ -344,7 +345,7 @@ def test_oep(dt): W = np.vstack([np.sin(2*timepts), np.cos(3*timepts)]) * 1e-3 # Generate system data - U = np.sin(timepts) + U = np.sin(timepts).reshape(1, -1) # No disturbances res0 = ct.input_output_response(sys, timepts, [U, V*0]) @@ -354,44 +355,44 @@ def test_oep(dt): res1 = ct.input_output_response(sys, timepts, [U, V]) Y1 = res1.outputs + W - # - # Internal testing to make sure all our functions are OK - # - # Set up optimal estimation function using Gaussian likelihoods for cost traj_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw) init_cost = lambda xhat, x: (xhat - x) @ (xhat - x) oep = opt.OptimalEstimationProblem( sys, timepts, traj_cost, terminal_cost=init_cost) - # _cost_function - oep.compute_estimate(res0.outputs, U, X0=0) - assert oep._cost_function(np.hstack( - [res0.states.reshape(-1), V.reshape(-1) * 0])) == 0 - assert oep._cost_function(np.hstack( - [res0.states.reshape(-1), V.reshape(-1)])) != 0 - if sys.isdtime(): - # Collocation contstraint should be satisified for discrete time - np.testing.assert_allclose(oep._collocation_constraint( - np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])), 0) - - # _compute_states_inputs: states and inputs with no noise - oep.compute_estimate(Y0, U) - xhat, u, v, w = oep._compute_states_inputs( - np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])) - np.testing.assert_allclose(xhat, res0.states) - np.testing.assert_allclose(u, U.reshape(1, -1)) - np.testing.assert_allclose(v, 0) - np.testing.assert_allclose(w, 0) - - # _compute_states_inputs: states and inputs with no noise - oep.compute_estimate(Y1, U) - xhat, u, v, w = oep._compute_states_inputs( - np.hstack([res1.states.reshape(-1), V.reshape(-1)])) - np.testing.assert_allclose(xhat, res1.states) - np.testing.assert_allclose(u, U.reshape(1, -1)) - np.testing.assert_allclose(v, V) - np.testing.assert_allclose(w, W) + # + # Internal testing to make sure all our functions are OK (developers) + # + if False: + # _cost_function + oep.compute_estimate(Y0, U, X0=0) + assert oep._cost_function(np.hstack( + [res0.states.reshape(-1), V.reshape(-1) * 0])) == 0 + assert oep._cost_function(np.hstack( + [res0.states.reshape(-1), V.reshape(-1)])) != 0 + if sys.isdtime(): + # Collocation contstraint should be satisified for discrete time + np.testing.assert_allclose(oep._collocation_constraint( + np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])), 0) + + # _compute_states_inputs: states and inputs with no noise + # oep.compute_estimate(Y0, U) + xhat, u, v, w = oep._compute_states_inputs( + np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])) + np.testing.assert_allclose(xhat, res0.states) + np.testing.assert_allclose(u, U.reshape(1, -1)) + np.testing.assert_allclose(v, 0) + np.testing.assert_allclose(w, 0) + + # _compute_states_inputs: states and inputs with no noise + oep.compute_estimate(Y1, U) + xhat, u, v, w = oep._compute_states_inputs( + np.hstack([res1.states.reshape(-1), V.reshape(-1)])) + np.testing.assert_allclose(xhat, res1.states) + np.testing.assert_allclose(u, U.reshape(1, -1)) + np.testing.assert_allclose(v, V) + np.testing.assert_allclose(w, W) # # oep.compute_estimate testing @@ -415,17 +416,18 @@ def test_oep(dt): est0.states[:, -1], res0.states[:, -1], atol=1e-2, rtol=1e-2) # Noise free, but with disturbances and good initial guess - oep1 = opt.OptimalEstimationProblem( - sys, timepts, nonoise_cost, terminal_cost=init_cost) - est1 = oep1.compute_estimate( - res1.outputs, U, initial_guess=(res1.states, V), X0=0) - np.testing.assert_allclose( - est1.states[:, -1], res1.states[:, -1], atol=1e-2, rtol=1e-2) - if sys.isdtime(): - # For discrete time, estimated disturbance and noise should be close + if False: + oep1 = opt.OptimalEstimationProblem( + sys, timepts, nonoise_cost, terminal_cost=init_cost) + est1 = oep1.compute_estimate( + res1.outputs, U, initial_guess=(res1.states, V), X0=0) np.testing.assert_allclose( - est1.inputs[:-1], V[:-1], atol=1e-2, rtol=1e-2) - np.testing.assert_allclose(est1.outputs, 0, atol=1e-2, rtol=1e-2) + est1.states[:, -1], res1.states[:, -1], atol=1e-2, rtol=1e-2) + if sys.isdtime(): + # For discrete time, estimated disturbance and noise should be close + np.testing.assert_allclose( + est1.inputs[:-1], V[:-1], atol=1e-2, rtol=1e-2) + np.testing.assert_allclose(est1.outputs, 0, atol=1e-2, rtol=1e-2) # Noise and disturbances (the standard case) est2 = oep.compute_estimate(Y1, U) # back to original OEP @@ -531,19 +533,17 @@ def test_mhe(): (slice(0, 3), slice(3, 5)) ]) def test_indices(ctrl_indices, dist_indices): - # Define a system with inputs (0:3), disturbances (3:5), and noise (5, 7) - ninputs = 3 - nstates = ninputs + 1 - ndisturbances = 2 - noutputs = 2 - nnoises = 0 - # TODO: remove strictly proper - sys = ct.rss(nstates, noutputs, ninputs + ndisturbances + nnoises, strictly_proper=True) + # Define a system with inputs (0:3), disturbances (3:5), and no noise + sys = ct.ss( + [[-1, 1, 0, 0], [0, -2, 1, 0], [0, 0, -3, 1], [0, 0, 0, -4]], + [[0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 1, 0, .1, 0], [0, 0, 1, 0, .1]], + [[1, 0, 0, 0], [0, 1, 0, 0]], 0) # Create a system whose state we want to estimate if ctrl_indices is not None: ctrl_idx = ct.namedio._process_indices( ctrl_indices, 'control', sys.input_labels, sys.ninputs) + dist_idx = [i for i in range(sys.ninputs) if i not in ctrl_idx] else: arg = -dist_indices if isinstance(dist_indices, int) else dist_indices dist_idx = ct.namedio._process_indices( @@ -553,28 +553,28 @@ def test_indices(ctrl_indices, dist_indices): # Set the simulation time based on the slowest system pole from math import log - T = 10 / min(-sys.poles().real) + T = 10 # Generate a system response with no disturbances - timepts = np.linspace(0, T, 50) - U = np.vstack([np.sin(timepts + i) for i in range(ninputs)]) + timepts = np.linspace(0, T, 20) + U = np.vstack([np.sin(timepts + i) for i in range(len(ctrl_idx))]) resp = ct.input_output_response( - sysm, timepts, U, np.zeros(nstates), + sysm, timepts, U, np.zeros(sys.nstates), solve_ivp_kwargs={'method': 'RK45', 'max_step': 0.01, 'atol': 1, 'rtol': 1}) Y = resp.outputs # Create an estimator - QN = np.eye(ndisturbances) - RN = np.eye(noutputs) - P0 = np.eye(nstates) + QN = np.eye(len(dist_idx)) + RN = np.eye(sys.noutputs) + P0 = np.eye(sys.nstates) estim = ct.create_estimator_iosystem( sys, QN, RN, control_indices=ctrl_indices, disturbance_indices=dist_indices) # Run estimator (no prediction + same solve_ivp params => should be exact) resp_estim = ct.input_output_response( - estim, timepts, [Y, U], [np.zeros(nstates), P0], + estim, timepts, [Y, U], [np.zeros(sys.nstates), P0], solve_ivp_kwargs={'method': 'RK45', 'max_step': 0.01, 'atol': 1, 'rtol': 1}, params={'correct': False}) diff --git a/doc/optimal.rst b/doc/optimal.rst index 0e9dd3aa5..f5ee5d466 100644 --- a/doc/optimal.rst +++ b/doc/optimal.rst @@ -132,12 +132,12 @@ most consistent with our model and penalize the noise and disturbances according to how likely the are (based on a some sort of stochastic system model for each). -Given a solution to this fixed horizon, optimal estimation problem, we can -create an estimator for the state over all times by applying repeatedly -applying the optimization problem :eq:`eq_fusion_oep` over a moving -horizon. At each time :math:`k`, we take the measurements for the last -:math:`N` time steps along with the previously estimated state at the start -of the horizon, :math:`x[k-N]` and reapply the optimization in equation +Given a solution to this fixed-horizon optimal estimation problem, we can +create an estimator for the state over all times by repeatedly applying the +optimization problem :eq:`eq_fusion_oep` over a moving horizon. At each +time :math:`k`, we take the measurements for the last :math:`N` time steps +along with the previously estimated state at the start of the horizon, +:math:`x[k-N]` and reapply the optimization in equation :eq:`eq_fusion_oep`. This approach is known as a \define{moving horizon estimator} (MHE). @@ -295,9 +295,9 @@ estimate of the states over the time points can be computed using the xhat, v, w = estim.states, estim.inputs, estim.outputs For discrete time systems, the -:func:`~control.optimal.OptimalEstimationProblem.compute_estimate` method -can be used to generate an input/output system that implements a moving -horizon estimator. +:func:`~control.optimal.OptimalEstimationProblem.create_mhe_iosystem` +method can be used to generate an input/output system that implements a +moving horizon estimator. Several functions are available to help set up standard optimal estimation problems: @@ -406,6 +406,11 @@ yields .. image:: steering-optimal.png + +An example showing the use of the optimal estimation problem and moving +horizon estimation (MHE) is given in the :doc:`mhe-pvtol Jupyter +notebook `. + Optimization Tips ================= From 039b22d29031c17b5a3dc7ae957b78fbd68519e5 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Thu, 23 Mar 2023 21:55:40 -0700 Subject: [PATCH 10/14] remove pytest --skipslow; use pytest -m "not slow" instead --- control/tests/conftest.py | 21 +-------------------- 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/control/tests/conftest.py b/control/tests/conftest.py index bbc1a689c..b63db3e11 100644 --- a/control/tests/conftest.py +++ b/control/tests/conftest.py @@ -121,25 +121,6 @@ def mplcleanup(): mpl.pyplot.close("all") -# -# Functionality to skip slow tests using --skipslow -# -# See https://docs.pytest.org/en/latest/example/simple.html -# #control-skipping-of-tests-according-to-command-line-option -# -def pytest_addoption(parser): - parser.addoption( - "--skipslow", action="store_true", default=False, - help="skip slow tests") - - +# Allow pytest.mark.slow to mark slow tests (skip with pytest -m "not slow") def pytest_configure(config): config.addinivalue_line("markers", "slow: mark test as slow to run") - - -def pytest_collection_modifyitems(config, items): - if config.getoption("--skipslow"): - skip_slow = pytest.mark.skip(reason="skipping slow tests") - for item in items: - if "slow" in item.keywords: - item.add_marker(skip_slow) From 9373f8e2eb8018f4c1fd925f341990f007f1da43 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 25 Mar 2023 13:03:11 -0700 Subject: [PATCH 11/14] fix dtime integral cost calculation; trim unit tests for speed --- control/optimal.py | 5 +- control/tests/stochsys_test.py | 133 ++++++++------------------------- 2 files changed, 31 insertions(+), 107 deletions(-) diff --git a/control/optimal.py b/control/optimal.py index ffd2828fd..bac5ba55c 100644 --- a/control/optimal.py +++ b/control/optimal.py @@ -1381,10 +1381,7 @@ def _cost_function(self, xvec): else: # Sum the integral cost over the time (second) indices # cost += self.integral_cost(xhat[:, i], u[:, i], v[:, i], w[:, i]) - cost = sum(map( - self.integral_cost, np.transpose(xhat[:, :-1]), - np.transpose(u[:, :-1]), np.transpose(v[:, :-1]), - np.transpose(w[:, :-1]))) + cost = sum(map(self.integral_cost, xhat.T, u.T, v.T, w.T)) # Terminal cost if self.terminal_cost is not None and self.x0 is not None: diff --git a/control/tests/stochsys_test.py b/control/tests/stochsys_test.py index 1ae0827a5..b2d90e2ab 100644 --- a/control/tests/stochsys_test.py +++ b/control/tests/stochsys_test.py @@ -323,7 +323,7 @@ def test_correlation(): tau, Rtau = ct.correlation(T, V) @pytest.mark.slow -@pytest.mark.parametrize('dt', [0, 1]) +@pytest.mark.parametrize('dt', [0, 0.2]) def test_oep(dt): # Define the system to test, with additional input # Use fixed system to avoid random errors (was csys = ct.rss(4, 2, 5)) @@ -336,104 +336,42 @@ def test_oep(dt): sys = csys if dt == 0 else dsys # Create disturbances and noise (fixed, to avoid random errors) - Rv = 0.1 * np.eye(1) # scalar disturbance - Rw = 0.01 * np.eye(sys.noutputs) - timepts = np.arange(0, 10.1, 1) + dist_mag = 1e-1 # disturbance magnitude + meas_mag = 1e-3 # measurement noise magnitude + Rv = dist_mag**2 * np.eye(1) # scalar disturbance + Rw = meas_mag**2 * np.eye(sys.noutputs) + timepts = np.arange(0, 1, 0.2) V = np.array( - [0 if t % 2 == 1 else 1 if t % 4 == 0 else -1 for t in timepts] - ).reshape(1, -1) * 0.1 - W = np.vstack([np.sin(2*timepts), np.cos(3*timepts)]) * 1e-3 + [0 if i % 2 == 1 else 1 if i % 4 == 0 else -1 + for i in range(timepts.size)] + ).reshape(1, -1) * dist_mag / 10 + W = np.vstack([ + np.sin(10*timepts/timepts[-1]), np.cos(15*timepts)/timepts[-1] + ]) * meas_mag / 10 # Generate system data U = np.sin(timepts).reshape(1, -1) - # No disturbances - res0 = ct.input_output_response(sys, timepts, [U, V*0]) - Y0 = res0.outputs - # With disturbances and noise - res1 = ct.input_output_response(sys, timepts, [U, V]) - Y1 = res1.outputs + W + res = ct.input_output_response(sys, timepts, [U, V]) + Y = res.outputs + W # Set up optimal estimation function using Gaussian likelihoods for cost traj_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw) init_cost = lambda xhat, x: (xhat - x) @ (xhat - x) - oep = opt.OptimalEstimationProblem( + oep1 = opt.OptimalEstimationProblem( sys, timepts, traj_cost, terminal_cost=init_cost) - # - # Internal testing to make sure all our functions are OK (developers) - # - if False: - # _cost_function - oep.compute_estimate(Y0, U, X0=0) - assert oep._cost_function(np.hstack( - [res0.states.reshape(-1), V.reshape(-1) * 0])) == 0 - assert oep._cost_function(np.hstack( - [res0.states.reshape(-1), V.reshape(-1)])) != 0 - if sys.isdtime(): - # Collocation contstraint should be satisified for discrete time - np.testing.assert_allclose(oep._collocation_constraint( - np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])), 0) - - # _compute_states_inputs: states and inputs with no noise - # oep.compute_estimate(Y0, U) - xhat, u, v, w = oep._compute_states_inputs( - np.hstack([res0.states.reshape(-1), V.reshape(-1) * 0])) - np.testing.assert_allclose(xhat, res0.states) - np.testing.assert_allclose(u, U.reshape(1, -1)) - np.testing.assert_allclose(v, 0) - np.testing.assert_allclose(w, 0) - - # _compute_states_inputs: states and inputs with no noise - oep.compute_estimate(Y1, U) - xhat, u, v, w = oep._compute_states_inputs( - np.hstack([res1.states.reshape(-1), V.reshape(-1)])) - np.testing.assert_allclose(xhat, res1.states) - np.testing.assert_allclose(u, U.reshape(1, -1)) - np.testing.assert_allclose(v, V) - np.testing.assert_allclose(w, W) - - # - # oep.compute_estimate testing - # - - # Noise free and disturbance free - nonoise_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw/1e6) - oep0 = opt.OptimalEstimationProblem( - sys, timepts, nonoise_cost, terminal_cost=init_cost) - est0 = oep0.compute_estimate(Y0, U) - if sys.isdtime(): - # Full state estimate should be near perfect - np.testing.assert_allclose( - est0.states[:, -1], res0.states[:, -1], atol=1e-3, rtol=1e-3) - np.testing.assert_allclose(est0.inputs, 0, atol=1e-2, rtol=1e-3) - np.testing.assert_allclose(est0.outputs, 0, atol=1e-2, rtol=1e-3) - else: - # Estimate at end of trajectory should be very close - assert est0.success - np.testing.assert_allclose( - est0.states[:, -1], res0.states[:, -1], atol=1e-2, rtol=1e-2) - - # Noise free, but with disturbances and good initial guess - if False: - oep1 = opt.OptimalEstimationProblem( - sys, timepts, nonoise_cost, terminal_cost=init_cost) - est1 = oep1.compute_estimate( - res1.outputs, U, initial_guess=(res1.states, V), X0=0) - np.testing.assert_allclose( - est1.states[:, -1], res1.states[:, -1], atol=1e-2, rtol=1e-2) - if sys.isdtime(): - # For discrete time, estimated disturbance and noise should be close - np.testing.assert_allclose( - est1.inputs[:-1], V[:-1], atol=1e-2, rtol=1e-2) - np.testing.assert_allclose(est1.outputs, 0, atol=1e-2, rtol=1e-2) - - # Noise and disturbances (the standard case) - est2 = oep.compute_estimate(Y1, U) # back to original OEP - assert est2.success + # Compute the optimal estimate + est1 = oep1.compute_estimate(Y, U) + assert est1.success np.testing.assert_allclose( - est2.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) + est1.states[:, -1], res.states[:, -1], atol=meas_mag, rtol=meas_mag) + + # Recompute using initial guess (should be pretty fast) + est2 = oep1.compute_estimate( + Y, U, initial_guess=(est1.states, est1.inputs)) + assert est2.success # Change around the inputs and disturbances sys2 = ct.ss(sys.A, sys.B[:, ::-1], sys.C, sys.D[::-1], sys.dt) @@ -441,22 +379,17 @@ def test_oep(dt): sys2, timepts, traj_cost, terminal_cost=init_cost, control_indices=[1]) est2a = oep2a.compute_estimate( - Y1, U, initial_guess=(est2.states, est2.inputs)) - np.testing.assert_allclose( - est2a.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) + Y, U, initial_guess=(est1.states, est1.inputs)) + np.testing.assert_allclose(est2a.states, est2.states) oep2b = opt.OptimalEstimationProblem( sys2, timepts, traj_cost, terminal_cost=init_cost, disturbance_indices=[0]) est2b = oep2b.compute_estimate( - Y1, U, initial_guess=(est2.states, est2.inputs)) - np.testing.assert_allclose( - est2b.states[:, -1], res1.states[:, -1], atol=1e-1, rtol=1e-2) - - # - # Disturbance constraints - # + Y, U, initial_guess=(est1.states, est1.inputs)) + np.testing.assert_allclose(est2b.states, est2.states) + # Add disturbance constraints V3 = np.clip(V, 0.5, 1) traj_constraint = opt.disturbance_range_constraint(sys, 0.5, 1) oep3 = opt.OptimalEstimationProblem( @@ -466,17 +399,11 @@ def test_oep(dt): res3 = ct.input_output_response(sys, timepts, [U, V3]) Y3 = res3.outputs + W - # Make sure the constraint screws up the estimation problem - with pytest.raises(AssertionError): - est3 = oep.compute_estimate(Y3, U) - np.testing.assert_allclose( - est3.states[:, -1], res3.states[:, -1], atol=1e-1, rtol=1e-2) - # Make sure estimation is correct with constraint in place est3 = oep3.compute_estimate(Y3, U) assert est3.success np.testing.assert_allclose( - est3.states[:, -1], res3.states[:, -1], atol=1e-1, rtol=1e-2) + est3.states[:, -1], res3.states[:, -1], atol=meas_mag, rtol=meas_mag) @pytest.mark.slow From 2a42fe86e8b21071c1b422159080bf796b809228 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sun, 26 Mar 2023 09:52:36 -0700 Subject: [PATCH 12/14] add benchmarks for optimal estimation --- benchmarks/optestim_bench.py | 87 ++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 benchmarks/optestim_bench.py diff --git a/benchmarks/optestim_bench.py b/benchmarks/optestim_bench.py new file mode 100644 index 000000000..fdc4dc824 --- /dev/null +++ b/benchmarks/optestim_bench.py @@ -0,0 +1,87 @@ +# optestim_bench.py - benchmarks for optimal/moving horizon estimation +# RMM, 14 Mar 2023 +# +# This benchmark tests the timing for the optimal estimation routines and +# is intended to be used for helping tune the performance of the functions +# used for optimization-based estimation. + +import numpy as np +import math +import control as ct +import control.optimal as opt + +minimizer_table = { + 'default': (None, {}), + 'trust': ('trust-constr', {}), + 'trust_bigstep': ('trust-constr', {'finite_diff_rel_step': 0.01}), + 'SLSQP': ('SLSQP', {}), + 'SLSQP_bigstep': ('SLSQP', {'eps': 0.01}), + 'COBYLA': ('COBYLA', {}), +} + +# Table to turn on and off process disturbances and measurement noise +noise_table = { + 'noisy': (1e-1, 1e-3), + 'nodist': (0, 1e-3), + 'nomeas': (1e-1, 0), + 'clean': (0, 0) +} + + +# Assess performance as a function of optimization and integration methods +def time_oep_minimizer_methods(minimizer_name, noise_name, initial_guess): + # Use fixed system to avoid randome errors (was csys = ct.rss(4, 2, 5)) + csys = ct.ss( + [[-0.5, 1, 0, 0], [0, -1, 1, 0], [0, 0, -2, 1], [0, 0, 0, -3]], # A + [[0, 0.1], [0, 0.1], [0, 0.1], [1, 0.1]], # B + [[1, 0, 0, 0], [0, 0, 1, 0]], # C + 0, dt=0) + # dsys = ct.c2d(csys, dt) + # sys = csys if dt == 0 else dsys + sys = csys + + # Decide on process disturbances and measurement noise + dist_mag, meas_mag = noise_table[noise_name] + + # Create disturbances and noise (fixed, to avoid random errors) + Rv = 0.1 * np.eye(1) # scalar disturbance + Rw = 0.01 * np.eye(sys.noutputs) + timepts = np.arange(0, 10.1, 1) + V = np.array( + [0 if t % 2 == 1 else 1 if t % 4 == 0 else -1 for t in timepts] + ).reshape(1, -1) * dist_mag + W = np.vstack([np.sin(2*timepts), np.cos(3*timepts)]) * meas_mag + + # Generate system data + U = np.sin(timepts).reshape(1, -1) + res = ct.input_output_response(sys, timepts, [U, V]) + Y = res.outputs + W + + # Decide on the initial guess to use + if initial_guess == 'xhat': + initial_guess = (res.states, V*0) + elif initial_guess == 'both': + initial_guess = (res.states, V) + else: + initial_guess = None + + + # Set up optimal estimation function using Gaussian likelihoods for cost + traj_cost = opt.gaussian_likelihood_cost(sys, Rv, Rw) + init_cost = lambda xhat, x: (xhat - x) @ (xhat - x) + oep = opt.OptimalEstimationProblem( + sys, timepts, traj_cost, terminal_cost=init_cost) + + # Noise and disturbances (the standard case) + est = oep.compute_estimate(Y, U, initial_guess=initial_guess) + assert est.success + np.testing.assert_allclose( + est.states[:, -1], res.states[:, -1], atol=1e-1, rtol=1e-2) + + +# Parameterize the test against different choices of integrator and minimizer +time_oep_minimizer_methods.param_names = ['minimizer', 'noise', 'initial'] +time_oep_minimizer_methods.params = ( + ['default', 'trust', 'SLSQP', 'COBYLA'], + ['noisy', 'nodist', 'nomeas', 'clean'], + ['none', 'xhat', 'both']) From 1599f44079f26e2a4e346799a5b271dc3e012ea4 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Thu, 30 Mar 2023 21:31:57 -0700 Subject: [PATCH 13/14] Update doc/optimal.rst Co-authored-by: Sawyer Fuller <58706249+sawyerbfuller@users.noreply.github.com> --- doc/optimal.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/optimal.rst b/doc/optimal.rst index f5ee5d466..f4f25ad4a 100644 --- a/doc/optimal.rst +++ b/doc/optimal.rst @@ -129,7 +129,7 @@ The result of this optimization gives us the estimated state for the previous :math:`N` steps in time, including the "current" time :math:`x[N]`. The basic idea is thus to compute the state estimate that is most consistent with our model and penalize the noise and disturbances -according to how likely the are (based on a some sort of stochastic system +according to how likely the are (based on the given stochastic system model for each). Given a solution to this fixed-horizon optimal estimation problem, we can From a3293236528cbb4b533b2b4e243e52f24571060c Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Fri, 31 Mar 2023 12:31:45 -0700 Subject: [PATCH 14/14] add executed mhe-pvtol.ipynb to fix doctest failure --- examples/mhe-pvtol.ipynb | 424 ++++++++++++++++++++++++++++++++++----- 1 file changed, 371 insertions(+), 53 deletions(-) diff --git a/examples/mhe-pvtol.ipynb b/examples/mhe-pvtol.ipynb index d9109c94b..14d29e142 100644 --- a/examples/mhe-pvtol.ipynb +++ b/examples/mhe-pvtol.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "36715c5f", "metadata": {}, "outputs": [], @@ -57,10 +57,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "08919988", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": pvtol\n", + "Inputs (2): ['F1', 'F2']\n", + "Outputs (6): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']\n", + "States (6): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']\n", + "\n", + "Update: \n", + "Output: \n", + "\n", + "Forward: \n", + "Reverse: \n", + "\n", + ": pvtol_noisy\n", + "Inputs (7): ['F1', 'F2', 'Dx', 'Dy', 'Nx', 'Ny', 'Nth']\n", + "Outputs (6): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']\n", + "States (6): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']\n", + "\n", + "Update: \n", + "Output: \n" + ] + } + ], "source": [ "# pvtol = nominal system (no disturbances or noise)\n", "# noisy_pvtol = pvtol w/ process disturbances and sensor noise\n", @@ -97,10 +122,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "d2e88938", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": sys[4]\n", + "Inputs (13): ['xd[0]', 'xd[1]', 'xd[2]', 'xd[3]', 'xd[4]', 'xd[5]', 'ud[0]', 'ud[1]', 'Dx', 'Dy', 'Nx', 'Ny', 'Nth']\n", + "Outputs (8): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5', 'F1', 'F2']\n", + "States (6): ['pvtol_noisy_x0', 'pvtol_noisy_x1', 'pvtol_noisy_x2', 'pvtol_noisy_x3', 'pvtol_noisy_x4', 'pvtol_noisy_x5']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/murray/src/python-control/murrayrm/control/statefbk.py:784: UserWarning: cannot verify system output is system state\n", + " warnings.warn(\"cannot verify system output is system state\")\n" + ] + } + ], "source": [ "#\n", "# LQR design w/ physically motivated weighting\n", @@ -132,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "78853391", "metadata": {}, "outputs": [], @@ -147,10 +191,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "c590fd88", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGdCAYAAADaPpOnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAACI20lEQVR4nO29eXhb5bX9v45mj/I8xXbszIEMhIQkToAQCCZMBVpmGqAFbvlSLoXctpfhDrS3Jb2/ttyUtkChDC1ToWUobSEhlCSEjGQwCUnI7NixLc+WB1nz+f3x6j2SZ0k+R+dI2p/n0QORZfuNI0vr7L322oIoiiIIgiAIgiDiBJ3aByAIgiAIgogEEi8EQRAEQcQVJF4IgiAIgogrSLwQBEEQBBFXkHghCIIgCCKuIPFCEARBEERcQeKFIAiCIIi4gsQLQRAEQRBxhUHtA8iN3+9HY2MjMjIyIAiC2schCIIgCCIMRFFET08PSkpKoNONXltJOPHS2NiIsrIytY9BEARBEEQU1NfXo7S0dNTHJJx4ycjIAMD+8pmZmSqfhiAIgiCIcOju7kZZWZn0Pj4aCSdeeKsoMzOTxAtBEARBxBnhWD7IsEsQBEEQRFxB4oUgCIIgiLiCxAtBEARBEHFFwnleCIIgCEIJRFGE1+uFz+dT+yhxi16vh8FgGHeUCYkXgiAIghgDt9uNpqYmOBwOtY8S96SmpqK4uBgmkynqr0HihSAIgiBGwe/349SpU9Dr9SgpKYHJZKIQ1CgQRRFutxutra04deoUpk6dOmYY3UiQeCEIgiCIUXC73fD7/SgrK0Nqaqrax4lrUlJSYDQacfr0abjdblgslqi+Dhl2CYIgCCIMoq0SEAOR4+dI/xIEQRAEQcQVJF4IgiAIgogrSLwQBEEQRBKyadMmCIIAQRBw7bXXRvS5F110kfS5NTU1ipxvNEi8EARBEESCcfXVV2PFihXDfmz79u0QBAF79+4FABw5cgQvv/zygMc8/fTTqKyshMViwfz587Fly5YBH3/nnXewa9cuRc4eDiReNILPL+L3W05iz+kOtY9CEARBxDl33XUXPvnkE5w+fXrIx1588UWcc845OPfccwEABQUFyMrKkj7+5ptv4sEHH8Rjjz2Gffv24YILLsDll1+Ouro66TE5OTnIz89X/O8xEiReNMJnx9vwk38cxk2/24G3dterfRyCIAhiBERRhMPtVeUmimJYZ7zqqqtQUFAwpKLicDjw5ptv4q677hrxc5988kncdddduPvuuzFz5kysXbsWZWVleOaZZ8bzY5MVynnRCHXtfQAAr1/ED/+yH2c6+/HQiqkUhEQQBKEx+j0+nPVf61X53od+fBlSTWO/dRsMBtx+++14+eWX8V//9V/Se8mf//xnuN1u3Hbbbfjiiy+GfJ7b7caePXvw8MMPD7i/uroa27Ztk+cvIQNUedEITXYnAKAokwX2PPXPY/i3P38Bt9ev5rEIgiCIOOXb3/42amtrsWnTJum+F198EV//+teRnZ097Oe0tbXB5/OhsLBwwP2FhYWw2WxKHjciqPKiEWwB8XLHkgpkpRrxH+99iXf2NsBmd+LZVfORaTGqfEKCIAgCAFKMehz68WWqfe9wmTFjBpYsWYIXX3wRy5cvx4kTJ7BlyxZ89NFHY37u4Kq/KIqa6gRQ5UUj8MpLSZYFtywsx+/vWIA0kx7bTrTjhme2o7GrX+UTEgRBEAB7Y081GVS5RSog7rrrLrz99tvo7u7GSy+9hIkTJ+KSSy4Z8fF5eXnQ6/VDqiwtLS1DqjFqEhPxMtbIVSjvvPMOLr30UuTn5yMzMxNVVVVYv16d3mIssXUPbBstn16AN79ThYIMM4409+Da327Flw12NY9IEARBxBk33ngj9Ho9Xn/9dfzhD3/At771rVEFkMlkwvz587Fhw4YB92/YsAFLlixR+rhho7h4CWfkKpRPP/0Ul156KT744APs2bMHy5cvx9VXX419+/YpfVTVEEURTXZWWSm2pkj3z5pgxbvfXYpphelo6XHhpt9tx8YjLWodkyAIgogz0tPTcdNNN+HRRx9FY2Mj7rzzzjE/Z/Xq1fj973+PF198EYcPH8ZDDz2Euro63HvvvcofOEwUFy+RjlytXbsWP/zhD3Heeedh6tSpeOKJJzB16lT87W9/U/qoqtHl8MDpYcbcgkzzgI9NyErBn+9dgiWTc9Hn9uHuP+zGG7uGF34EQRAEMZi77roLnZ2dWLFiBcrLy8d8/E033YS1a9fixz/+Mc455xx8+umn+OCDDzBx4sQYnDY8FBUvfOSqurp6wP2RjFz5/X709PQgJydHiSNqAu53yU0zwTKMGcuaYsTL31qIr587AT6/iEfeOYCfr/8q7Hl/giAIInmpqqqCKIoRWTDuu+8+1NbWwuVyYc+ePbjwwgsVPGHkKCpe5Bi5+uUvf4m+vj7ceOONw37c5XKhu7t7wC3esHWzllGR1TLiY0wGHX55w1w8cMlUAMBvN57AQ2/WwOX1xeSMBEEQRGJSWlqKW265JaLPufzyy3H22WcrdKKxicmodLQjV2+88QYef/xx/PWvf0VBQcGwj1mzZg1+9KMfyXJOteCVl1C/y3AIgoDVl05DaVYKHn33AN6raYSt24nffXMBrKk0Sk0QBEGEz6JFi3Ds2DEAzBsTCb///e/R388uvMNpRcmNopWX8Yxc8fjit956a8TlUgDwyCOPwG63S7f6+viL1rdJ4mXkyksoN55XhhfvPA/pZgN2nOzAN57dhjOdDiWPSBAEQSQYKSkpmDJlCqZMmYKioqKIPnfChAnS55pMJoVOODKKipdoR67eeOMN3HnnnXj99ddx5ZVXjvo9zGYzMjMzB9ziDSldN0zxAgAXTsvHW9+pQlGmBcdbenHd09tw4AyNUhMEQRCJj+LTRmONXD3yyCO4/fbbpce/8cYbuP322/HLX/4Sixcvhs1mg81mg92euG/MwTHp8MULAJxVkol3v7sEM4oy0Nrjwk3PbcfGr2iUmiAIgkhsFBcvY41cNTU1Dch8+d3vfgev14vvfve7KC4ulm7f+973lD6qakRTeeEUW1Pw1r1VOH9KHhxuH+76w+d4befQFegEQRAEkSgIYoLN23Z3d8NqtcJut8dFC0kURZz93+vhcPuw8fsXoTIvLaqv4/H58cg7B/CXPWcAAP/vosn4QfV06HTa2UVBEAQRjzidTpw6dUpKiifGx0g/z0jev2m3kcp0O71wuNm4c6Rto1CMeh1+fv0cPLRiGgDgmU0n8D0apSYIgiASEBIvKsMnjbJTjcMG1EWCIAj43oqp+MUNc2HQCfjbF41Y9ftd6HK45TgqQRAEQWgCEi8qw826RWNkvETC9fNL8fK3FiLDbMCu2g58/ZltqO+gUWqCIAhibARBgCAIyMrKiujzHn/8celz165dq8jZOCReVKYpwoyXcDl/ah7+/P+qUGy14GRrH657eiu+qO+S9XsQBEEQ2uXZZ59FRkYGvF6vdF9vby+MRiMuuOCCAY/dsmULBEHA0aNHAQAvvfSS9P+czZs3Y/78+bBYLJg0aRKeffbZAR///ve/j6amJpSWlir0NwpC4kVlxjNpNBYzijLx7n1LMbM4E229btz83A7KgiEIgkgSli9fjt7eXuzevVu6b8uWLSgqKsLnn38OhyNYkd+0aRNKSkowbRrzTWZlZQ1Itj916hSuuOIKXHDBBdi3bx8effRRPPDAA3j77belx6Snp6OoqAh6/fgsEOFA4kVlbDzjJVMZB3uR1YK3vrMYCyty0O/x4e29ZxT5PgRBEEmDKALuPnVuEQwIT58+HSUlJdi0aZN036ZNm3DNNddg8uTJAxYkb9q0CcuXLx/xaz377LMoLy/H2rVrMXPmTNx999349re/jV/84hdR/QjHS0x2GxEjI7WNsuTzvAwmw2LE1XOLsau2A41d/Yp9H4IgiKTA4wCeKFHnez/aCJjCj9S46KKLsHHjRjz88MMAgI0bN+KHP/wh/H4/Nm7ciBUrVsDtdmP79u349a9/PeLX2b59O6qrqwfcd9lll+GFF16Ax+OB0Rjb/XpUeVGZSPcaRUtJQBw1kHghCIJIGi666CJs3boVXq8XPT092LdvHy688EIsW7ZMqsjs2LED/f39o1ZebDbbkJ2EhYWF8Hq9aGtrU/KvMCxUeVEZm4Kel1AmZJN4IQiCkAVjKquAqPW9I2D58uXo6+vD559/js7OTkybNg0FBQVYtmwZVq1ahb6+PmzatAnl5eWYNGnSqF9LEAaGnvKM28H3xwISLyrS4/Sgx8Vc4EUKeV44EwKVly6HB30uL9LM9E9PEAQRFYIQUetGTaZMmYLS0lJs3LgRnZ2dWLZsGQCgqKgIlZWV2Lp1KzZu3IiLL7541K9TVFQEm8024L6WlhYYDAbk5uYqdv6RoLaRivCqS6bFoLiYyLAYkWlh34N8LwRBEMnD8uXLsWnTJmzatAkXXXSRdP+yZcuwfv167NixY9SWEQBUVVVhw4YNA+776KOPsGDBgpj7XQASL6oSzHhRzqwbCve9nCHxQhAEkTQsX74cn332GWpqaqTKC8DEy/PPPw+n0zmmeLn33ntx+vRprF69GocPH8aLL76IF154Ad///veVPv6wkHhREcmsmxWbRV+lAd8LVV4IgiCSh+XLl6O/vx9TpkwZYLpdtmwZenp6MHnyZJSVlY36NSorK/HBBx9g06ZNOOecc/A///M/eOqpp/CNb3xD6eMPCxkfVESpdN2R4L6Xhk4SLwRBEMlCRUWFZK4NpbS0dNj7R2LZsmXYu3evnEeLGqq8qIitO7DXKDO2bSOaOCIIgiBG45Zbbok45v+JJ55Aeno66urqFDpVEKq8qEjMKy/UNiIIgiDG4NixYwAQccz/vffeixtvvBEAkJ+fL/u5QiHxoiJNXbHJeOFQ24ggCIIYiylTpkT1eTk5OcjJyZH5NMNDbSMVaeJ7jWIsXmzdTnh8/ph8T4IgCIKQGxIvKtHn8qLbyQLqlNxrFEpeuhkmvQ5+EWjudsbkexIEQSQKkZhbiZGR4+dI4kUlbAHxkGE2ID1Gabc6nYCSwFg2tY4IgiDCg4ewORwOlU+SGPCf43jC7cjzohKx2mk0mJKsFNS2O2jiiCAIIkz0ej2ysrLQ0tICAEhNTVVln0+8I4oiHA4HWlpakJWVFbEhOBQSLyrRpJJ44b4XmjgiCIIIn6KiIgCQBAwRPVlZWdLPM1pIvKhEU1dszboc2i5NEAQROYIgoLi4GAUFBfB4PGofJ24xGo3jqrhwSLyoRFM3r7zExqzLkfYbkeeFCBOfX4ROUGftPUFoDb1eL8ubLzE+yLCrEtzzUhLjyksppewSEdDr8uKC//0EN/1uBxxur9rHIQiCAEDiRTVU87yEpOzS2B8xFocau9Fod2JXbQd+8Of99JwhCEITkHhRCZsUUBfbthEXS06PHx197ph+byL+aOgKjob+40ATnvrncRVPQxAEwSDxogJOjw+dDmb4inXlxWzQoyDDDIBaR8TYNPIVFpnsefp/Hx/Fhwea1DwSQRAEiRc14C2jVJMemZbYe6ZpQSMRLlzg3nheGe5cUgEAWP3WFzjYaFfxVARBJDskXlSA7zQqslpUmeCgiSMiXHgSc2lWCv7jypm4YGoe+j0+/Msf96Ct16Xy6QiCSFZIvKgAnzSKdcYLhyaOiHDh1bmSrBQY9Dr85pZzUZmXhoauftz7yh64vD6VT0gQRDJC4kUFmiTxEluzLofaRkQ4iKIYIl6Y0LamGvH87QuQYTFg9+lO/Od7X9IEEkEQMYfEiwqoXXmZQJUXIgy6+73oc7PKSknI5vMpBen49S3zoBOAt3afwYtba1U6IUEQyQqJFxVQK+OFw9+IaLM0MRpnAmPSeekmWIwDE0Uvml6AR6+YCQD46T8OYfPR1pifjyCI5IXEiwo02dXZa8ThbaNOh4dSU4kR4WPSoVWXUO46vxLXzy+FXwTuf30vTrT2xvJ4BEEkMSReVIC3jYoy1fG8ZFqMyAiMaJPvhRgJye8ygjdLEAT89LpZmD8xGz1OL+7+w27YHbSwjiAI5SHxEmOcHh/aA8m2alVegKDvhcaliZEInTQaCbNBj2e/OR8lVgtOtfXh/jf2wuvzx+qIBEEkKSReYkxLN8vGsBh1yEo1qnYOLl54a4AgBnMmIF54m3Ek8jPMeO72BUgx6rHlWBt++sHhWByPIIgkhsRLjGkK2WmkRkAdh78hhe6uIYhQeOVlQtbYFcJZE6z45Y1zAQAvba3Fm5/XKXo2giCSGxIvMcbWPXBXjFrQxBExFuG0jUK5YnYxHlwxFQDwH+99ic9rOxQ7G0EQyQ2JlxjD2zRq+l0AahsRo+P2+tHSw1qc4YoXAHjg4qm4YnYRPD4R976yB2c6qbJHEIT8kHiJMbaQvUZqEmwbUeWFGIrN7oQoAmaDDrlpprA/T6cT8Isb5uKs4ky097lx9x92o89F4/gEEcq+uk588/c7cbyF4gWihcRLjGlSOV2Xwysvtm4nTYcQQ2iQ/C6Re7NSTQY8f8cC5KWb8JWtB6vfqoHfTysECILzxAeH8dnxNry1u17to8QtJF5iDPe8qLXXiJOfboZJr4PPL6K5h7YDEwOJ1O8ymAlZKfjdqvkw6XVYf7AZaz8+KufxCCJuOd3eh89rOwFQztZ4iIl4efrpp1FZWQmLxYL58+djy5YtIz62qakJt956K6ZPnw6dTocHH3wwFkeMGWqvBuDodAKKA1MkZNolBjN4IWM0zJ+Yg59eNwsA8NQnx/H3/Y2ynI0g4pm39zZI/0/iJXoUFy9vvvkmHnzwQTz22GPYt28fLrjgAlx++eWoqxt+lNLlciE/Px+PPfYY5s6dq/TxYorb60dbL6tyqN02AoLJqTQuTQwm2DZKHdfXuWFBGe4+vxIA8P0/f4EvG+zjPhtBxCt+v4i395yR/swvZonIUVy8PPnkk7jrrrtw9913Y+bMmVi7di3KysrwzDPPDPv4iooK/OpXv8Ltt98Oq9Wq9PFiSnM3M0Ga9DrkRGCCVArJtEuVF2IQDTJUXjiPXDETy6blw+nx454/7kZLD71gE8nJzlMdaOjqh0nP3nqbyXMYNYqKF7fbjT179qC6unrA/dXV1di2bZuS31qTSBkvVouqAXUcbtptoHFpYhCNIYbd8aLXCXjqlnmYlJ+GJrsT33llD5we37i/LkHEG2/vZVWXa+eVwKgX4BdBnsMoUVS8tLW1wefzobCwcMD9hYWFsNlssnwPl8uF7u7uATetohW/CycoXqjyQgQRRTHYNhpjNUC4WFOMeOGO85BpMWBfXRceffcARJEmkIjkweH24sMDTQCA6+eXSUMb5HuJjpgYdgdXGURRlK3ysGbNGlitVulWVlYmy9dVAp7xUqIV8SK1jcjzQgTpdHjg9LBStpxCuzIvDb+97VzodQLe2duA57eclO1rE4TWWfelDX1uH8pzUnFeRbbkeyTxEh2Kipe8vDzo9fohVZaWlpYh1ZhoeeSRR2C326Vbfb125+aDlRd1x6Q5oSm7dBVMcPiLaX6GGWaDXtavfcHUfPznlTMBAGs+/Aobv2qR9esThFbhLaNvnFsKQRAo5XycKCpeTCYT5s+fjw0bNgy4f8OGDViyZIks38NsNiMzM3PATavYNBJQx+Gj0v0eHzodHpVPQ2iFhnFmvIzFHUsqcMvCMogi8MAb+3C8pUeR70MQWqGxqx/bTrQDAL5+7gQAwddfvqyXiAzF20arV6/G73//e7z44os4fPgwHnroIdTV1eHee+8FwCont99++4DPqampQU1NDXp7e9Ha2oqamhocOnRI6aMqTqPGPC9mgx75GWYANHFEBOHPhVKFxIsgCPjR12ZhYWUOelxe3PWH3ehyuBX5XgShBd7d1wBRBBZV5qAsh8UPlGSR52U8GJT+BjfddBPa29vx4x//GE1NTZg1axY++OADTJw4EQALpRuc+TJv3jzp//fs2YPXX38dEydORG1trdLHVRTuedFK5QVgraPWHhcauvoxuzSxRtOJ6JAjoG4sTAYdnrntXFzz26043e7A2o+P4fGvna3Y9yMItRDFYLbLN+aXSveXWKltNB4UFy8AcN999+G+++4b9mMvv/zykPsS0X/h8QW39Gql8gIw025NfRdNHBESjXZl20ac3HQzfnDZdHzvTzUUXkckLPvqu3CyrQ8pRj2umF0s3S9VXqhtFBW02yhGtPa4IIqAUS8gL82s9nEkpHFpahsRAXjuj9LiBQAm56cDAGrb+xT/XgShBrzqsnJWEdLNwXoB97x0OTzod1PuUaSQeIkRfNKoMNMCnU79gDrOBOq7EoPgQlaOgLqxqMhLAwC09brR7STTOJFYOD0+/O0LttPrG+eWDvhYpsWIjICYoepL5JB4iRFamzTiUFAdEYrT45P2b8VCvKSbDchLZ5XI2jaqvhCJxT8Pt6Db6UWx1YKqyblDPs6rL3TxGDkkXmIEH4fTSsYLp4TECxECF9kpRj2yUo0x+Z6VeWz64hSJFyLB4Nku182bAP0wFXf++ttEpt2IIfESI5q0WnkJpOx29Lmp70oMmDSK1f6tilzWOqpto6RnInFo6XFi89FWAAOnjELhKwLo4jFySLzECH5FW5SpLfFiTQn2XekXiDgj7TRKjdn35L4XMu0SicRf9zXC5xdxTlmWZEwfDF8VQ0F1kUPiJUY02ZXPzogWah0RnOA26dg9TysD4oXaRkSiIIpicB3ACFUXIDSojtpGkULiJUbYNLbXKBTeOtKyaWzjVy3YebJd7WMkPFLbKIbPU6ltRJUXIkE42NiNr2w9MOl1+NqckhEfJxl2qfISMSReYoDPL6I5EFCnNc8LoP2sl5YeJ+7+427c/Yfd8PsTL8BQS/ArQC5oY0FFwLDb5fDQmgAiIeBVl0vPKoR1FON7aFRFIoazKgmJlxjQ1uuCzy9CrxOksVAtofW20eGmHvj8InpcXnT1UxaIkii9lHE4Uk0GFGay3wtqHRHxjsfnx/s1gWyX+RNGfSxPW3d6/Oii5bgRQeIlBvBSfGGGedhxObXhV9larbwcaw5uHW4NVLAI+RFFURIvsch4CYVaR0SisOlIK9r73MhLN+PCqfmjPtZs0EsXtFq9eNQqJF5igE1j26QHo/WguiM2Ei+xoL3PDbfXD0FgSdCxZFI+N+3SuDQR3/B1ANeeUwKDfuy3WD7EweM0iPAg8RIDghkv2jPrAkHxYut2wuvzq3yaoRxt6ZX+n6e/EvLDK2+FGRaYDLF9aQhmvVDlhYhfOvvc+OdXzQBGnzIKJbhdWpsXj1qFxEsMsHVrM6COU5BhhlEvDDAWawW/X6S2UYwIDaiLNZT1QiQCf9vfCI9PxFnFmZhZnBnW59DEUXSQeIkBTRpvG+l0glQV0pr6b+jqhyMk+beVKi+KoYZZlyNlvbT2xdXUhcPtpQkpQoK3jMKtugChE0fUNooEEi8xwBZQ1FptGwHBq22tmXaPhlRdAKCNKi+KIY1JqyBeynNSIQhAj8uL9r74EAOiKOJrv9mKZT/fBIfbq/ZxCJU53tKDL87YYdAJuOackbNdBsPfF5o0duGodUi8xAD+pqDVygsATMhiWRtaM+0ebWZ+F6OeTWlR5UU5GrqYWTaWGS8ci1Ev9f7jxffS2uvC8ZZe2Ps9ON1ORuNk5y97GgAAF03PjygSgwy70UHiRWH8fhHNGve8ACHj0poTL6zyMq8sGwB5XpSEi+xYpuuGUhFn26WPhxjJua+NSE58fhHv7gu0jM4Nv2UEBNu0tm4nfBTCGTYkXhSmrc8Fr1+ETmDGWK1SqtGUXS5elkzJBUDTRkrSqKLnBYi/rJdQ8dJC4iWp2Xq8Dc3dLlhTjLh4ZkFEn5uXboZBxwYmWnroeRQuJF4Uhme8FGRYwpr5Vwstpuz6/KL0BnH+lDwALItEi+Pc8Y7T45O8Jmp4XoCgabc2TrJeQsVLczeJ6mSGrwP42twSmA36iD5XrxMkS4HWBia0jHbfTRMErU8acUKXM2pl2qOuwwGX1w+zQYe5ZVnQCYAoAh1xYuiMJ7hoTTcbkJliUOUMvPISL22jY82h4oWumJOVbqcH6760AQCuj2DKKJRg1gs9j8KFxIvC2Oza97sAwfM53D7N7NjgybpTC9Nh1OuQk8babmTalZ/QjBdBUGeFRWjWi1YE9Ggcb6XKCwF8sL8JLq8fUwrSMafUGtXX4KZdqryED4kXheHBQ1qvvFiM2tuxwcPpphVkAADyA54hMu3Kj9p+F4CNS+sEJqC1/m9sd3gGnJG8CskLbxl949zSqIV/ceD3jiaOwofEi8LES+UF0N7E0REuXoqYeMlLNwEA2nqpbSQ3DXzSSEXxYjLopOeg1ltHx1sH5g9R2yg5Od3eh89rO6ETgOvmjb5BejS06DnUOiReFCboedFuQB1HaxNH3FMwrTAdAFVelIT/m6tl1uVU5rF/a61PHHGz7oyAsG7tcZGRPAl5ey/Ldlk6JW9c1fUSK8960cZrbzxA4kVheOWlJA4qL1LKrgbUv8fnx8k2Ll6obaQ0vG2kunjJ5Vkv2p444uJl8aRc6HUC/CLiJhmYkAe/X8Q7gZZRtEZdTgmtCIgYEi8KIoqiJF607nkBQndsqC9eatv64PGJSDPppXPlBzw5lPUiP9ybpWbbCAgx7Wq8bXQsIF6mFqZLz0tqHSUXu2o7cKazH+lmA6rPKhrX1+LTRh19bjg9vjEeTQAkXhSlo88Nt88PQWA5L1pnQrZ2VgRwv8vUwgzJBEeVF2Xw+0U08b1GKqwGCIWLF817Xrh4KchAYSYXL/S8TCb4EsYrZxcjxRRZtstgMlMMSAt8DS1cPMYDJF4UhPtd8tLNMBm0/6PW0nLGo4P8LkCw8kKj0vLS1uuC2+eHTgAKVU6BrgxJ2fVrNCrd4fbiTOB3ZEpBOgoy2e8NVV6SB4fbiw8ONAGIbIP0SAiCQBNHEaL9d9Q4pimOJo0AoDSwnLFdA6XLo4GMF+53AYC8DGobKQGvtBVlqp8CXZqdAoNOgMvr1+y+oJOtrCqUm2ZCTppJqrzQioDkYf1BG/rcPpTnpOK8imxZviZNHEUGiRcFsdmDbwrxQGaKAelmlq6q9i/Q0Zah4oVXXrocHri81BeWi0YNjElzDHodynKYiNaq74W3jCYXsKpgYQavvJCoThbeDmyQ/vq5E2QLdZQmjsi0GxYkXhSEV1608KYQDoIgaKJ15PT4pDeu6UVB8WJNMcKgYy8U7ZT1IhsNXWyyR22/C6eCTxxpdFz6WEBYT+HiJXBxotVKESEvjV392HqiDUDkG6RHo0RqG1HlJRxIvChIPE0acSZooHR5srUPfhHItBgGbOLW6QQpBZhaR/KhpcoLoP2Jo6BZNyBerOR5SSbe3dcAUQQWVeZIVUI54PYCtave8QKJFwWJN88LMHBBo1ocDUwaTS/KGFKSpYkj+WnQwGqAUCqliSNtZr3wMelg5SXgeaHnZMIjimJwHYAMRt1QSsiwGxEkXhSkKc48L0CIaUzFttHRkDHpwfAVASRe5CMYUKeN52lFyMTRuOmqB05vA3zyLBt1e/043c5E1dTAzi3ueenoc5MXK8Gpqe/CydY+pBj1uGJ2saxfuyQkZyseFpOqjUHtAyQqoiiGVF60cUUbDrxtdEYLlZdhxEs+TRzJToMkXuQrgY8HXnmpa3fA5xeh10VgiBRFwLYf+OoD4Mg/ANsBdr+1DKi6Hzh3FWBKi/psp9v74POLSDcbpIpLVqoRJr0Obp8frT0ulGZr4+dIyM9fAtkuK2cVScMNcsEr9A63D939XlhTjbJ+/USDxItCsIkYtuuk0KpudkYklGqibRRMLx0MtY3kpc/lRZeDVSVKNFJ5KclKkcRAY1f/2L4Cnweo/Qw48gFw5EPAXh/8mKADTBnsvnX/Dmz+GbDwX4CF3wHSciM+27GQSSPe0hQEAQWZZpzp7EdzN4mXRMXp8eFvXzQCkNeoy7EY9chNM6G9z42Grn4SL2NA4kUhggF1JpgN40tfjCX86ttmd0Z+1SsDDrcXdR2sLD9c5SWPgupkhbc2MywGZFi08WKp1wkoz03F8ZZe1Lb3DS9enN3A8Q2swnJsA+CyBz9mSAGmXAJMvwKYdhmrtNS8Dmz7NdB5Ctj8v8DWp1gVpuq7QHZF2GcbbNblFGZacKazn7JeEph/Hm5Bt9OLYqsFVZPDFL6iCPR3Ar0tQK8N6Glm/+1tAVw9wIT5wOSLgawyAEBxlgXtfW402ftxVkmmgn+b+IfEi0LYugN+lzgy6wKssmHQCfD6RTR3O2Nu4uRvDrlpJuSmD61YSW2jHhqVloMGvhZAI2ZdTkVuGhMvbX24YGo+u9PeEKiufACc2gL4Q3wsqXnA9JXAjKuASRcBxkF/n/PuAubfCRx+H/hsLdBUA+x6Dvj8BeDs64Cl3wOK54x5rsFmXQ5vIdG4dOLCjbrXzZsAvegDuluDQqTHBvQ2B//b2xwQKs2Ab5QLrb1/YP/NnQpMvhiXGcpwEiW0IiAMSLwoBK+8FGVq601hLPQ6AcVZFtR39KOxqz/m4uXIMMm6odCKAHnhxmytiZfKvFQAIvrq9wPuPwNf/Z0JjlByp7DqyowrgdLzAN0YFU6dngmVs64FTm0Gtv4KOPEJ8OVf2G3yxcDSB4HKC4ERgsdGq7wAFFSXMPh9wImNQMdJoNeG/o5G3HHyEL5v6sK0LxzAjjYAEZhqLVlAeiGQUQikF7H/6ozA6a3Amd1A+zGg/Rj+FcB3zHrYts0FPFey52TxOYCOZmsGQ+JFIXhKYjyNSXMmZKWgvqMfDV39WBDj782vbKcN43cBQlYEkOdFFho1NiYNnxeo246vt/4Jq0zrUX6oFTjEPygwkTLjCmD6lUD+tOi+hyCw6syki4CmL1gL6eA7TMic+AQomcdEzMyrBwgin1/EydaRKi/s95zaRnGOzwPsfwvY8kug44R0dwqAZVw/8KKIoAPSCoKCJL0AyCgKiJTAf/nNOMr7QH8XULsFOPEJur9cj0xnA8p79gKf7AU++R8gJYc9VydfDExeDljl99vEIyReFKIpDgPqOPyN7IwK49JS5aVohMpLQLz0uLzod/vGvc012dGEeHH1Aif+GfCvrAf6OzETAHSAG0aYpnH/ykr2RiEnxXOB618ALvlPYNtvgH2vAo37gD/fAeRMApb8KzD3VsBowZlOB1xeP0wG3RBTrrRZuofES1zidQM1rwGf/R/QdZrdl5INVFwAZBThpf39ONSTgpWL5+KSBXOYOEnNHbvaFw4pWUwoz7wam8sa8fM/rcOq/BO4p6QWOPUp0N/BxPXBd9jj86YHhMzFQMXScU3PxTMkXhSCe17isfJSmqXexNGx5tHbRhlmA8wGHVxeP9p6XbImXCYjwYA6FZ6nbgfw2ZNMNHhDnmsp2XBUrMBDX0zAdszF3puuVX5hZHYFcOUvgIseZl6YXc+xlsHfHwI2rgEW34vazK8BACbnpw8xstN+ozjF4wT2/hHYuhboZvuKkJbPROuCbwPmDBxstONHn34Gk16Hxy65BEg1KXackqwU1ImFeNldgXtuvphVghr2BKuCDXuAtiPstvMZQG8CyhYFxUzRnKRpMZF4UYh4zHjh8JTdWMdUdzs9aAz83KYVDC9eBIGtCGjo6kcriZdxw/+NS2O510gUga/+Aax7BLDXsfuyK1graMYVQNliWAQ9Nh1YB5fXjzOd/dLKAMVJywOWPwoseYBVYbb/ho1Z//PHqNL/Ao8alqMu+84hn1YgeV6o8hIXuPuA3S8B255iploAyChmxu1z7wBMwdcVvoRxxVkFyFJQuADBi4jm7sC0p94IlC9mt+WPssmlU58yIXP8E/b7U7uF3f75I1YNmrQ8KGYy5Q3S0xIxkWhPP/00KisrYbFYMH/+fGzZsmXUx2/evBnz58+HxWLBpEmT8Oyzz8bimLIhiqK01ygeKy9qpeweC+S7FGaaR804iLusF5+HTSFoLDXT5w8+T2PWNmo/Abx2PfDmbeyFN7MUuOEPwAM1wMongIrzAb0BOp0gJe2qsqDRnA4svhd4YB9w3XNAwdkw+Rz4F8M/8KNTtwDv3Qe0fCU9nLeNepxeONze2J+XCA9XD7DlSWDtHOCjx5hwsZYBV/6SPQcX/78BwsXj8+OvNUy8KJHtMpiCDAv0gWnPYYM4U7KBs64Brv4V8OB+4F/3Alf8grVVTemAo52Zz/96H/DkDOCZ84F//hio28H8ZAmE4pWXN998Ew8++CCefvppLF26FL/73e9w+eWX49ChQygvLx/y+FOnTuGKK67APffcg1dffRVbt27Ffffdh/z8fHzjG99Q+riy0O30wuFmMeHx6HmZMCimWq6V72NxdIyWEUfKetGyePH7gfqdwIE/AwffZX3ryguB6p+GNZIbC1p7XPD6RRh0AgoyFH6euh3MBLntKcDnZpMWS/4VuPD7I/bsK/JScaS5hy1onK7s8UZEbwTm3gTMuRE//r9fobrrT1isO8z8ETWvAdMuB6ruQ3r5EqSa9HC4fWjudqEyj4ramqK/C9j5O2DH04Czi92XXQFc8G/AnJsBw/AVlc1HWtHe50ZeuhkXTstX/Jh6nYCiTAsautjAROFoq2UEAcidzG4L72EXSWc+D1Rl/sm8W80H2G3LL9nE05QVwNRqloOUlqf430dJFP8Ne/LJJ3HXXXfh7rvvBgCsXbsW69evxzPPPIM1a9YMefyzzz6L8vJyrF27FgAwc+ZM7N69G7/4xS/iRrzw4K/sVCMsxvgzlPKr8D63D/Z+j+KlUk644kXTKwKaDwEH3gIOvB1siXBOfQr87kJg3jeBi/+Dmf5UhLeMiqwW5cIIRZGNOa97JJh8O/li4PL/D8ibOuqnamm7tAjgLftMvOj+T3x6azrKDz8PHP47cPRD4OiHEFJy8KTpHLzrnYPW9tnSigNCZframWDZ9Rzg6mb35U5lonnW9YB+9LdAnu1y7TklMCrtuwpQbGXipanLCQy9vh8ZvRGYuITdLv4P9nc//jFw7CP2X2dXMBYAAlC6gAmZqZcCRXPjziujqHhxu93Ys2cPHn744QH3V1dXY9u2bcN+zvbt21FdXT3gvssuuwwvvPACPB4PjEZtpICORnDSKP78LgCLqc5LN6Gt140znf0xFy/DJeuGorm2UVc9e0E48Beg+cvg/aYMNkUw5wZ2lffJT4Av3wb2vQJ8+Q5w/kPAkvuHBqrFCMW3SbcdBz78IZskAlh5/rIn2M8kjGpepdQ2Un+7dHO3C70uL7syPusCYM4y9vfb/mvg4HtAfwdW4hOsNH0C35u/ZaOt0y9nt8wStY+ffPS2sETlz18APAHxW3AWEy1nXRvWlFCXw41/Hm4BIP8G6dEoyUoBTneOf2AiLZdVDefexFpGDbuZkDn2Edv5deZzdtv4UzbOPeVSJmQmLwcsVnn+MgqiqHhpa2uDz+dDYeHA8cbCwkLYbLZhP8dmsw37eK/Xi7a2NhQXDzQguVwuuFzBN7Hu7m6ZTh898ex34UzISkFbrxuNXf2YNSE2T+TRdhqFkq+FzdKODuDQe0ywnN4avF9nZFczc25go72hwuT6F4FF97IqRMNuYONPgD0vAyv+m10FxvjKJ7hNWmbx4u4LtIh+zVpEehNrEV3wbxGNdWqp8nKshQnribmpMBkC/055U5j34IpfAvU7sPGvf0Bl+2ZUoJmtLji+AfjHahYyNv0KJmSKZocl3Igo6W5kuT17Xg5OsBXNAZb9kBnCI/gd+9sXjXD7/DirOBMzi2MX1V8cMO022mX0HOoNQePvJf/Ffk7HNjAhc3IT8/7UvMpuOgNQXsWEzNRqIH+GJp+zMWnMDvZMjOWjGO7xw90PAGvWrMGPfvQjGU4pH03RiBevi4Uj5VQCE5eq/mSZkJ2CL87YYzZx1NnnlsTIVK22jdwO1ibY/2dWhg2Np594PhMsZ13DTHUjUbYQuPtjVoH5+HHWSnnnHmDHM6wqMbFK8b8Gp1HuMWlRZPH76x4Fulm5HZMvCbSIpkT85SYFxMuZTgfcgXwVteDJulPyhxHWegNQcT62T83Ft5quwcPzBdxbdIQtiTzzOUsGbqoBNj3Bqk+8IjPx/BG9FkSEdNWxtQ/7XmGCGQAmLGCiZWp1VK+nf9kbMOrGsOoCDPQcKkZmCTD/DnbzuoG6bUEx03Y0OMG04b8Aa3lQyFReoJlcGUXFS15eHvR6/ZAqS0tLy5DqCqeoqGjYxxsMBuTmDl2G9cgjj2D16tXSn7u7u1FWVibD6aPHZo8w48X2JfDud4Ith6I5wOL7gFnfUO3FrcQa24kj3jKakJUy5qp5qW0UC/Hi8wKnNjHB8tXfAXdv8GNFs4HZN7B/p0hSLwUBmH09i7Xf8TSbfmjcC7y0kpW0VzzORKzCBFcDyDBu3nYc+PAHzCwIsDfplWvYrqEohXh+hhlpJj363D7UdzoweTjhECOktQCjVAULMswABBz0lgAXXAlcsJq1L46uZ0LmxCdMrPIcGVMGMHUFq8pMWQGk5sTob5NAtJ9gwXJfvAH4A9M05UuAZT9gI8NRPPdEUcRf9pzBF/VdMOgEXHNObNt+PF6DXwQrjsEUTJy+7KdAx6mgkKndwrx7u19gN72ZTQROu4wJmpxJsTnjcMdW8oubTCbMnz8fGzZswHXXXSfdv2HDBlxzzTXDfk5VVRX+9re/Dbjvo48+woIFC4b1u5jNZpjNQxf4qUnYnhe/j+VIfPITdrWQks1Ck2z7gffuBT7+b+C8e1hYUlqYW0xlItZZL5LfZYRk3VBCp40UmYYSRRYGtf8tlmrZ1xr8WFY5EyyzbwQKZozv+xhTWCtl3ir2HNj3CmtFHfmAtZcu/L6ivWdZAurcfcCnv2AtIr8n0CJ6INAiGp8oEgQBE3PTcKipG7VtfaqKl5EWMoZSOFzWS3oB21597irA0w+c3Awc+QdwZB3Q18Im0Q6+Cwh6ZrTk7aUYiNe4xOdlr491O4Daz1glVPSzj1UuY5WWivOj/vKn2vrwH+8dwNbj7QCAr80tkV5vYgX/fVRtOWNOJbDoX9jN7WAC5thHwNGPmJA58U92+xDA94+x57gKKN42Wr16NVatWoUFCxagqqoKzz33HOrq6nDvvfcCYJWThoYG/PGPfwQA3HvvvfjNb36D1atX45577sH27dvxwgsv4I033lD6qLIRluel8zTw3v8L+iWmXwFc/RQzku15Cdj1PNDTxHwRW34BzLmJVWPG+4YZJmGXLj1O4ORG4NBf2Xknns+uJiN0r4frdwGC4sXp8aPP7RuzUhM2bceYYDnwZ6DzVPD+1Fy20G/2jaztI7dYSi8AvvYUsPBfWPbEyU1spLjmNRZMde6dY05FRMO4PC+iyP7N1z8WbBFNuRS4/H/Z6KZMVOYx8XJKZd/LCWkh48jieljxEooxhW2+nr6SjdI37g1syf4QaDkULNWvfwTInxloL13Bqno+F2ste13sQsfrDPmzi5X+vc6BH5P+3z3w86XHudgbf+5kVu0tngsUnq2agXxYXD1scWHdDqBuO/t/z6DnwtRq4MIfsN/NaL+N14fnNp/Erzceh9vrh9mgwwOXTMU9F8S+ssCr3m29bjg9PnUnVk2prMoy7TLgChFoPRI0/XocqgkXIAbi5aabbkJ7ezt+/OMfo6mpCbNmzcIHH3yAiRMnAgCamppQVxccKa2srMQHH3yAhx56CL/97W9RUlKCp556Km7GpIEx9hqJIlDzOvDhvwPuHhYstHINu/rmb4oX/BtQ9a/sKnz7b1m/fO8f2G3yJUDVfey/CvpipKC64cSLp595Pg79lV1BunuCHzu5iQmutHxWCp+ygo3GjlESPxLmpBEApJkNUjuhtccVvXjp72Qviqe3snPbDgQ/ZkxlLY/ZNzD3vT4GU25Fs4BV77EXho/+g/We//FvwM7nWDl36qWyfasepwfdTlZmj3jaqPUoaxGd3MT+bC0HLv8Ze6OV+TlZkceqN2qKl44+N9r7mI9iUv7I/f6iEPEyZkVQp2OjqqULmIGy4xRwdB0TM7VbgdbD7PbZk7L+XYalNiQ0VNCx3TnFcwKCZg5rj47m45KTHhsTKVys2A4EKyscSxYznpYtCoz5zh7Xt9x5sh2PvnsAJ1rZc+yCqXn4n2tmxS7VeRBZqUakGPXo9/hgsztVO8cQBIFdPBfMAJY+wDoHKhITw+59992H++67b9iPvfzyy0PuW7ZsGfbu3avwqZShx+lBr4u9KRQNDhjqawP+9j3mnQCAssXAdc8OXyI2mIA5N7I3z7odwI7fskh1XrLLm87SIOferMiVEo+Ll9S/6GRvqof+ysqHoVc/GSXMqJo7mb2hndzEWi1fvMFugg6YMD8wircCKJ43oCojiuKYO40Gk5dhRl+7A229rvAzNXqamTHtdODWfBAD1trrDEwUzr6BxdSrYUwTBHaVM/liNjGx8Qm2x+S169nZqn8CFJ417m/TGNh6npVqRFq44s/VC3z6cyao/R7W/176PTbyPc4W0UjwlN1aNVJ2A3C/y4SsFKSaRv5ZFWQGK4LdTi+sKREI3pxK9vu8+P8xUX38n0zIHPuYXRwYLKwlZzCzm97M7jOYAv9vHvQxU+BzxviY6GciqWk/a8f0tQaF0/43g+fLKmeVmaK5QWGTUTQ+sSqKTKCHipXO2qGPyypn0y/li9l/86bLMpnX2efGmg8P463drHKYl27Cf151Fr42tyRmwZzDIQgCirMsONnah0Z7DFdjRIocSynHAcVAygxvGWVaDAPfFI6sA97/V9bn1hlZO2Dp98Z+AggCm0CZWMWuznY9B+x9hb2h/f1BFv284NssYVHG0DNrihH5JjcWe3fD+6dXgdMbBy7Ps5YxwXLWtUyY8BeThfewMnX9Dmb6Ov4xK4nzTIFNTwCpeSzhccqlwOSL0epPQ6fDA0EY3VMQSn66GafbHaOPS3fVBYTKVvbf9uNDH5M7NRjsNGWFdlIn9Ub2s5x9PfOU7PwdE63PbmS7V5Y/BqRHn/gpTRqFk0UkiqwKuP6x4PK6qdXAyp/J2iIajkppXFq9rJdwzLoAy0eyphhh7/egpdsZmXgJJSWb/bvPvp797GP1RiqKrPJh28/ETFMN+/+uuuDtcIgfMS0/2G7igia7cmRh4XUBTV+EiJUdLHk6FEHHWldcrJQtBqwTZP5rinhnbwN++sFhdAQqarcsLMfDK2eMupYklkzISmHipYt2ZY0EiReZaRq8K8bVy3wMe15mf86fAXz9OfYLHyk5lazFdNEjzNy581n2grLlF8DWX7Gpl6r7ovvaHKcdOLIOwqG/YqvuI5hMHuBE4GPZFQHBcg1Qcu7IL6oGE4vCr7wQqP4fwH6GXUke3wCc2AQ42thV3f43AQhIyZ2DBw2TcSR9MSxhivkhQXWiyMQJFyqntwUTXSUEoHBWUKxMXKJqzzYsUrJZy+i8u4AN/81Gkfe8xPJlLvw3YNH/A4yRG255O7DMamRvWH1t7N+lr43tR+lrDd7XWRtsqWWVAyv/l/kxYvCmyq86G+39qvX/ecbLsGPSgyjMNMPe70Fzt2vMkf+wiGUFQBDYIr/MYlb94/R3sn9/Xp1p+oJVTPpag5VgjimDtXG4mEnNAep3MaHSuJf5bUIxpLDWGRcrpecBFuUyVU629uKxd7/E9pPMkDu9MAM/vW4WFlRoa9KL+yWb1DLtxgEkXmTGFup3qdvJRqC5+bPqfuDi/4zqzWYAlkyg6rvAwu+wyYXtT7NKx/4/sdvE85mImbYyvNKeo4OZBg/9lY1zBvJLTABO+ovQP/VqnL1iFXsxiubF1FoazBTwedjOH16Vaf4SGe1f4EHDF4DzHeDnPwtWZUbZv5GfZsBM4TTKju0BzhxnYiV0KghgbaCSeUyklC8ByhfFrncvNzmTgJteYX6I9Y+yq+KPHwc+fxG49HHg7K+zfxuvO0SEtLGI8L7WQcKkDVe0NuJqcxustQ7gl2F8f70ZOP9B1iKKoaEzN82EDLMBPS4v6jocYbcV5STcygvATLtHm3sTa7t0SnbwYoTjdrCKatMXwUpN80HW4qrbxm7DkZoXbP+UVzGREwM/mcvrwzObTuDpjSfg9vlhMerwvUum4e4LKmMW+x8J/OJX1qC6BIPEi8w02Z0wwos7+v8IvPQa6ylnlgLXPTPwl18O9IZgJaRhDxMxh94DTn/GbtmVbOR23m2AedCLfl87894c+itwanMwIwFgPeWzr8VTTWfhyf0GPFA4FWcXy7QZT29ko4wV5wOX/gjobsTbb70My+mNuMR0CJb+Djbtc+DPAASg5JxgbLWgkyorj57cCou5BwgZCoLBwq7ceFWl9DzNBCrJRsVS4J6NbH/Sxz9io4t/+TYLhvM4gvtbxiAHACQdKrCJqrQ89uaSlhv4b8ifyxZFlmUjE4IgoCIvDQca7DjV1qeqeAmnpckXXDb3JJB4GQ5TatBwzPF5WUUmVND0d7AqLRcsuZNjHsC5/UQ7HnvvAE4GDLkXTsvHT66ZhfJcZXxacsDbudQ2GhkSLzLjaz6Ed03/hVktteyOOTez8dGULGW/8YT5wPUvAPYfA58/D+x+iVV81v07M32eu4qNW5/5nAmW2s8AMcQtXnB2UAgFxrENm44D+4/gjMJJj6+5l2GvZy5+/fVZuDqnIVCV2cBK1Y372O3T/2/Ap1kA9IoWnEqdjdlLLmepxCXzmCkx0dHpmFF75tXAtt8AW9cCvSHBjoI+KEYkATJQmPz3P23Y2iTgh19fiur5M1U3340GFy9qrAnodXmlVvCU/LGFU2HAtNscq4AxLaE3MDN54VkAblH7NOjoc+On/zgsLVfMzzDjv646C1fNKVbVkBsOfEVAE1VeRoTEi1z4/cDOZ3H/sf+CSeeBy2iF+dqngLOvje05rBNYQuuFP2CTPjueYV6Q7b9ht1CK5gQFyzAbfnn+h5Ipu2zSKFCWL84GiiayqsmK/2ZejOMfs9uJjQHz8lJg4hLs8M3AbX/vw6z8HPz1guhDqeIaUxpw0b8D593N/o1Tc5hosWSNOY3x8d8+QYPYj7zCCZoWLgBQGbhCVmPiiOe75GeYwzJz8niE5m6NLA1NQkRRxJ/3nMGaDw5LgwC3LSrHDy6bEb2JOsZIbSOqvIwIiRc5sJ9hgXOnPoUJwCbfXFiuewaLzz5bvTOZ0tib2vxvsyrGjqdZumfJvIBg+dqY0c4TYtB3bbI70ePywqATMClvUFk+owiY9012AwZMXljqu+DDVu1sllaTtNyIEpi9Pj9sAU+G7EsZFYCbdtXIejk22k6jYUiatpFGOd7Si8fePYCdp9gU04yiDDzx9dk4tzy+vG68bdTr8qLb6UGmJT5EVywh8TIeRJF5M/7xfcBlB4yp+B/PrXjBsxwfF5erfTqGThdMSPT7I8pH4CsCmrqc8PlF6HXyl1r5WoCKvLSxF++FlHrzApul23rdyqwISGCae1zw+UUY9QLyYxx9Hg1qjktHYtYFgm2jFqq8xBSnx4enN53AM5uOw+MTYTHq8NCKafj2+do05I5FikmP7FQjOh0eNHb1I7OIxMtgSLxEi6ODrbs/+C7784T5cFz5NF54is0Vj7nXSA0iDHYqyLDAoBPg9Yto6XFKC8Pk5GgEybqh8BUBbp8f3f1ezeQzxAM846XYmgKdAoJUbrh4sXU70e/2IcUUuzbXcT4mHWb+EF8R0NLjhN8vxsXPN97ZerwN//Hel1Jlbvn0fPz4mlkoy9GuITcciq0p6HR40NTlxIwi5cbH45X4k6Ra4PjHwNNVwYVqyx8Dvv0RmoxsGiPDbJBv346K6HWC1MNXaklYJDuNQrEY9ci0sJ9xay+V6COhUY6FjDEkK9WErIA4jbXv5XiEbSOeP+Txieh0uBU7FwG097qw+s0a3Pb7nTjV1oeCDDOevu1cvHjneXEvXIAxVrQQJF4iwu1gLaJXv8GmO3KnAndvYJtM9QY0dY2y0yhO4Z6IMwqZdqOtvABsRQAAtJDvJSIapIWM8fMCL60JiKHvxenxoa6DtaqmhCmujXqd1NIk065yOD0+XPPbrXhnXwMEAbi9aiI+/rdluGK29ieJwqWEJo5GJf7LA7Gi7Rjwxs3BiPmF/wKs+NGAnS78SZaI4kUJ9e/3h0waRSFe8tPNONnah7ZeusKNBD49NiFOKi8Aax3V1HfhZAzFy6m2PvhFtuojEm9QQYYFbb1uNHc7cVYJlfuV4O/7m3Cmsx8FGWY8d/sCnFOWpfaRZIcmjkaHKi/hkl7I0kszioFvvgNc8fMhy+h4um5xIomXbP4LJL94OdPZj36PDya9DhVRBEYNWRFAhEWwbaRBX9YIqFF5CQ2ni+RqPjgure03HZfXhw2HmuHyqrsdOBpe3XEaAHDHkoqEFC5A8H1EqZZ9vEOVl3CxZAK3vAFklrA8jWFo6ubiJX7eFMZCyawX3jKalJ8GQxQTAdy0S+IlMviVXFyJl7zYZ73wMempBZFVBaWgOo23jV7Zfho/+cdh3LqoHE9cN1vt44TNlw121NR3wagXcNN5ZWofRzFiEVURz1DlJRKKZo0oXIDErLwoaRo7wv0uRdFFvvPKS1uvtt8ktIQoikHPS3b8iJdKKeslduPSJyJYCxBKvGS9HGxkqyTe3nNG2q4cD7y2k1VdVs4qli5gEpHiwGuvzc4m14iBkHiRkSZ7Ahp2s4OVF1GU9xfoWEC8RLuvhtpGkdPt9KLXxfZYlcRRhZAH1bX1utDj9MTke0ptowgn4aRxaY23jeoDZmSX148/fV6n8mnCo9vpwXv7GgEA31ykkSwthSjMMEMnsMk1ukAbCokXGeGG3URsG/W5feju947x6Mg4EjDrRi1e0qnyEim8f56TZoppXsp4ybQYkZvGpnhOtytfffH6/DjZFtmYNCde2kZ8kgpgLSSPz6/iacLj3b0N6Pf4MK0wHQsrR66CJwIGvU4Swo3JuCtrDEi8yES/24cuB7siTKTKi8Wol940znTJ96bh9flxopWLl8jeHDhUeYmceMt4CSWWawLqOhzw+ESkGPURr1DgbzhaNuz2u31SxECGxYAmuxMfHWxW+VSjI4qiZNS9bdHEhBmJHg0y7Y4MiReZ4LtiUk3B8LREIbR1JBenOxxwe/2wGHUoy44ub4SLl/Y+N/WEwySY8RJ/1cFYThxxs+7kgrSIU3ILMoMVQa9GqxlnOtmFSIbFgDuXVAAAXt52SsUTjc2uUx041tKLFKMe1507Qe3jxITguDSJl8GQeJGJYMvIknBXBBMU+AXifpepBRlRR6jnBCpCPj+lmYZLQxyOSXMqAxNHp2IwcRRpsm4oeWlm6HUC/CI0m0HEW0Zl2an45uKJMOgEfF7biS8b7CqfbGRe3cl8OdfOK0maRYX897SJ2kZDIPEiE8FJo/h7UxgLJSaOjtjG53cBWJopFzCt5HsJCz4mHY+Vl8rA1vFYVF5OtEQfnqjTCSjI4L4Xbb7pcPFSnpOKwkwLrphdDAB4eVutiqcamdYeF9Z92QSAtYyShRJqG40IiReZSMRJI44SKbtHW/ikUXR+F04+Zb1ERDwG1HGCWS/KG3altlEUlRcAKNC476W+gz0PygPhkHcurQAAvF/TqEkD/Fu76+HxiTinLAuzJljVPk7MKJayXrT5PFITEi8yEdo2SjQkz4uMMdVHbQHxEmXGCycvg1VetPiCq0WCqwHiULwEPC8dfW7Y+5Ubl/b7RclMHmnGC6eQV140KqqltlFggeG8sizMLbXC7fPjjZ3aGpv2+UW8HjjTNxcnT9UFUKZlnyiQeJEJWzJUXmQy7Lq9fmliZDxtI4AqL5Hg8fml4LR4rLykmQ1SO0bJ1lGjvR8Otw9GvYCJUaytALSf9VIf0jYCAEEQpOrLKzu0NTa9+WgLGrr6YU0x4qo5xWofJ6bwi+HWHldcrnFQEhIvMtGUgOm6HC5e2npdcHrG/wt0qq0PXr+IdLNB6ulGC60ICB+b3QlRBEwGnTT+Hm/wcWkl1wRws25FbhqMUaytAEKzXrQnXkRRHOB54VwxmyXWtvS48OGXNrWON4RXd7Cqy/XzS2Exxk82kRzkpJlgNrDnYLOdXuNCIfEiE4ls2M1KNSI1EGgmh+ud7zSaWhjZwrvhCK4I0OZUh5aQ/C5WS9QTXmpTGWgdnWxVXrxMHYcfi3tebBoMqmvrdaPf44MgDMz7MRv0+OZillr78lZtjE3Xdziw8UgLAOC2BE/UHQ5BEILj0rTjaAAkXmTA6fGhPbAbJBErL4IgyNo64uJl+jhbRgAF1UVCPO40GkwsKy/RjElzijTcNqoPZLwUZ1pgNgysZNy6qBxGvYC9dV34or5LhdMN5I1ddRBFYOmUXEwax79HPMMFJvleBkLiRQZaAldXFqMO1pTEzB8IjkuPf9IjWHkZv3ihtlH4BCsv8SteeNaLkp6X41JAXfRvllpO2a0fZNYNpSDDgqvmlAAA/qDy2LTb68dbu+sBAN9MovHowfBqPmW9DITEiww0huw0SrSAOo6cE0dHAzuN5Ky80LTR2PB/u3g063JCVwTIvSgUYH4QPiY9tSD65yf3vHQ6PJozWta1D/W7hMITd/+2vxEtKm7GXnfQhrZeNwoyzFhxVqFq51AbJXK2EgESLzIgTRplJl7LiCNX28jp8eF0O580Gn8ZmIuXDodbs1HsWqExAdpGE3OYeOl2etHpkH9cuq2XjWELAjApPy3qr2NNMcIUMFq2aMz3MpxZN5S5ZVmYV54Fjy84oqwGfI/RzQvLozZOJwJ8qKGJxMsAkvcZISOJPGnEmSBT2+h4Sy/8IjMBc+ExHrJTTdAJgCiy/A9iZOJ5rxEnxaSXfs+UWNDIW0blOanjmmwRBEGqvqhZvRiOwRkvw8GrL6/uqIPbG/uLgqPNPdh1qgN6nYBbFpbF/PtrieB+I209j9SGxIsM2HjbKA439YYLv1of7y/QMZ6sW5AhS4tNrxOQm87fJLR1haslRFGM63TdUJRc0Hg88Pwcj1mXU5jBfS/ael6O5nnhXDG7GIWZZrT1uvDBgaZYHU3itUDV5ZIZBQk5wRkJkmGXpo0GQOJFBoKrARL3l2yCtCCsf1wbnKWdRkXyTQ5IQXXkexkRe78HDjfzXsR7hVDJiSNp0mgcZl0ON+3aNGS0dHv9aAqYiEdqGwFsbxg3yb4UY+Nun8uLd/Y2AEi+RN3h4OKtx+lFj1O5ZOl4g8SLDNgCLwbFCex5Kchgm3I9PnFcFQ6+TXq8ybqh5HHTLlVeRuRMwKuUl26O+6CvSSGmXbk5poB4adZQ26ihqx+iCKQY9chLHz2o8JZF5TDpdfiivgv76jpjdELg/S8a0ePyYmJuKs6fkhez76tV0swGaYqVJo6CkHiRAd5KScTVAByDXicZksfjej+igHihysvYSGbdBGhtxk/lJdDO1FDbKNSsO1bbNi/djKvnsrHpWG2bFkVRMuretqg8bsMU5aaYtksPgcTLOHF7/dKYbryX48ciOC4d3S9Qn8srVQBkFS8UVDcmieJ3AUKzXhyyjkvb+z1SVVHWyouGsl7CMeuGwo27/9jfFJO/R019Fw42dsNk0OGG+clt1A1lApl2h0DiZZzwX2iTXoecON0XEy7jHZfmJfm8dLOsPyte/qYVASPTaI//jBdOWU4qdALQ6/LK+m/Oqy5FmRZkWMYfNlmgwf1GQbNueM+D2aVWLJiYDa9flEy0SsL3GF01uxjZCf56Ggl8GKSJTLsSJF7GCfe7FFktCRtQxxnvuPRRqWUkb8x3sPKinTcJrcEFZzyPSXPMBr0kwuRsHZ2QsWUEhG6W1k5FcKyAuuH41tJKAMBrO+sUDdzrcrjx9/2NAIDbyKg7AAqqGwqJl3GSDBkvnPGOSx+1ye93AUI8L9Q2GpGGBGobAUAlN+3KuKDxeKsy4qXH5UWfyyvL1xwvfK9RJOKl+uxCFFstaO9z4+9fKDc2/Zc9Z+Dy+jGzOBPnlmcp9n3iEb7So4naRhIkXsaJlPGSBOKlZJxto6OBK1vZxQttlh6TxgQIqAuFZ72ckrHywifh5BIv6WYD0gLb2LXQOhJFMarKi1Gvk0aWX95Wq8haBr9fxGuBNN9vLi5P+Cp2pNBm6aGQeBknyZDxwpkQUrqM5gWMV16my5jxAgTFi71fe3tktIDL65OMqCUJMG0EhEwcyTguLXflBQAKrdoJqrP3e9ATqACVZocvXgDgloXlMBl0ONBgx14Fxqa3nWjHqbY+pJsNuPacCbJ//XiHXxw32Z3jytlKJEi8jBNexkuGygsXL70uL7qdkZXB7f0eyR80ZRwL74bDmmKEUc+u1LRYfTnYaMcP//KFam0tHpJmMSaOqZxPHMmV9dLv9kmTcFPlFC+BlF0trAjgk0YFGWakmCLL+slJM+Hac9jY9Etba+U+mjQefd28CUgzG2T/+vEO81Sy6dZ2WoMCgMTLuGkKMewmOikmvfTmF2nriJfki60WKXBJLgRBQF66doPqnt54Am/tPoPfbjyuyvcP9bskSjmet41Ot8szLn2itReiCGSnGqV1E3JQqKGJo0jHpAdz5xJm3P3wS5usUy82uxMbDjcDoETdkTDqdSgIVJhp4ohB4mWcJJPnBRjYOoqEo82sJD9VZr8LR8tZLycD1YH1B22qlHy5wTpR/C4AewPW6wT0e3yytGROBFpGU2WuCgazXtR/Xo61TXoszirJxKLKHPj8wSA5OfjT53Xw+UWcV5GN6UXKvD4kAsEFjSReAIXFS2dnJ1atWgWr1Qqr1YpVq1ahq6tr1M955513cNlllyEvLw+CIKCmpkbJI44Lj88veQmSZXnYhCh/gfiY9HSZx6Q5eRpN2RVFEacDptImuxNfnOmK+RmkgLoEeo4a9TqUBqbf5GgdHQuI68kytowAoEBDQXX1Hex5EG3lBQC+tbQCAPD6zjo4PeP3l3l9fvxpVz0AqrqMBf/9paA6hqLi5dZbb0VNTQ3WrVuHdevWoaamBqtWrRr1c/r6+rB06VL87Gc/U/JostDa44IoAka9gNwE8RKMRbQpu1y8KFZ50WjbqLXXJS1EBIB1X9pifgYp4yU7ccQLEByXliPrRc61AKFoaUVA/TgrLwCwYmYhJmSloNPhwftfNI77TB8fboGt24ncNBNWzioa99dLZGhFwEAUc0YdPnwY69atw44dO7Bo0SIAwPPPP4+qqiocOXIE06dPH/bzuLipra1V6miywSeNCjMtSbODI9px6WDlReG2kcYqL6fbBwb6rTtow8OXz4ip94SPVyZKxguH+V5aZZk4OtYSENeyi5fAZmkNVF7G2zYC2I6zVVUT8bMPv8LLW2txw/zScT2XX9vJ2k83LCiD2RDfC0OVhv/+amE54+82n8CsCVYsrMyBUa+O+0Sx77p9+3ZYrVZJuADA4sWLYbVasW3bNqW+bUxpSjK/CxCd56W91yVNAcl9ZcsJrgjQlnjhb6znlmfBbNDhdLsDh5t6YnqGoGE3sZ6nlTJtl/b4/JLIlPv5WRTSNlIiHyVcvD6/9DwIdzXASNx8XhksRh0ONXXj89rox6ZPtfVhy7E2CAJbwkiMDv/9VTvrpcnejzUffoVVL+wcUFWONYqJF5vNhoKCgiH3FxQUwGaTr3TucrnQ3d094BYrbEmU8cIpjaJtxM26ZTkpio1B5gdGUrVm2OVvimeVZOLCafkAgHVfKpdSOhhRFKUyc2lW9FfcWkSu7dKn2/vg9YtIM+llvxDhFUGX14/ufvVSdpvsTvj8Ikx6nTS+HS1ZqSZcN49lsby09VTUX+f1QNVl2bT8cflwkgWtGHa3Hm8HAMyeYJV9cjQSIhYvjz/+OARBGPW2e/duABi2nCiKoqwl8zVr1kiGYKvVirKy2G0iTabVABz+C9Ta4wrbsMdL8tNknuQIRavTRjwBtiI3DZcHevofxtD30tHnhtPjhyAAhVb5RoC1QGXIuPR4pri4WXdKQbrs7TyLUY+sVPYC36xi1gv3u5TmpMjS4uZj0+sP2qLat+P0+PDnPWcAAN9cREbdcOBDIS09Lnh8ftXOse14GwBgyZQ81c4ARCFe7r//fhw+fHjU26xZs1BUVITm5uYhn9/a2orCwkJZDg8AjzzyCOx2u3Srr6+X7WuPhS0JxUt2qhEpRtabtoXZez3CdxopOAap1c3SfNJoYm4aLplZCINOwLGWXskgqjR8MiE/3ZxwnoKSLAuMegEur1/KW4oG/m8h96QRh1c61Jw4ksPvEsr0ogwsmZwLvwi8sj3ysel/7G9Cl8ODCVkpWD5jaIWeGEpumgkmgw6iGP5rr9yIooitJ5h4WTo5zsRLXl4eZsyYMerNYrGgqqoKdrsdu3btkj53586dsNvtWLJkiWx/AbPZjMzMzAG3WJGMnhdBECKeOOJXtnJvkw6FV156XV443NpYgieKIk63sTeNyrxUWFOM0tXK+oOxqb4k2kLGUAx6ndRuGM+CxmMtymS8cAqkoDr1qoJyixcAuHNJBQCW09Ifoffh1UDL6JaFZdAnybDDeNHphAFrAtTgRGsfmrtdMBl0WFCRrcoZOIp5XmbOnImVK1finnvuwY4dO7Bjxw7cc889uOqqqwZMGs2YMQPvvvuu9OeOjg7U1NTg0KFDAIAjR46gpqZGVp+MXCSj5wWIbOJIFEUcaVZmm3Qo6WYDLEb2dG7r0Ub1paPPjR6XF4IQ3CUTbB3FxvfCxUuijUlzKmVY0KjUmDSnUANZL0qIl0tmFqI0OwVdDg/+WtMQ9ucdbLRjX10XDDoBN54XuzZ/IhDMelHH97ItUHWZX54Ni1HdSq6iM06vvfYaZs+ejerqalRXV2POnDl45ZVXBjzmyJEjsNvt0p/ff/99zJs3D1deeSUA4Oabb8a8efPw7LPPKnnUiPH5RTRLAXXJU3kBIps4au1xwd7vgU4AJucrV3kJXRGglXHp2oBZt8SaIv2iV59VCJ0AfNnQLfkQlCTRtkkPZrwLGn1+MSRdVynxov6KAMnzEuFCxtHQ6wTcUVUBILJt06/uYNujL5tVhIJxmoeTjWKVJ462BvwuS6fkqvL9Q1F0A1ZOTg5effXVUR8z+Al/55134s4771TwVPLQ2uOCzy9Crwu+aSYLkUwc8apLRW6a4ko9P8OMM539mjHtBv0uwTeM3HQzFlbmYMfJDqw/aMPdF0xS9AzBdN3EfJMYr3hp6OyHy+uHyaBTbOKlKEErLwBw44IyPLnhKL6y9WDHyQ5UTR79Ta3HGazSkFE3cqJNOJcDn1/EjpMdANQ36wK02yhquN+lMMOcdD1bnjcQTtsouNNIuaoLR6uVl4mB1gZn5dmxmzpqTGDPCzD+ttHxViauJ+WlKfZ7XKDyfqMepwedDg+A8We8DMaaasQ35oc/Nv3uvgY43D5MKUjH4kk5sp4lGeATR00qrAg41NgNe78HGWYD5kywxvz7D4bES5RIk0YJ+qYwGhMCeSHhlC6P2pRN1g2Fm3a1siLgtDQmPfBqd+WsYgDAntOdil+NJ7rnpSKP/WzrOxzwRjE+GjomrRTc89KiUuWF7zTKSTMhwyJ/LgdvHX18uHnUVqgoBhc63raoPGE2nMcS6cJRhcoLnzJaNCkHBpVSdUNR/wRxSpNk1k3Mcvxo8DfCpi7nmPkaR1uU3WkUSr7WKi9twTHpUIqsFswrzwKg7NSR0+OTRscT1fNSYk2ByaCDxydGtbBOabMuELLfqMelylZx3jJSqi02tTADF0zNY2PTo2yb/ry2E0ebe5Fi1OPr55YqcpZER80VAdzvskTlEWkOiZco4btKijOTT7zwVpnb5x9VKIiiKF3ZxmLVfZ7Ggup424hXB0LhU0dKLmrkL3CpJr2qSZhKotMJUmUrmtbR8VZlx6QB1s4UBMDrF9HhiP0knBwLGcdCGpveVTdiVAGvunxtbknCPh+Vhg+H2Ps96HPFLhLC5fXh81rmd1mqAb8LQOIlariXIBkrLwa9TjIhnhnF99Jod6LX5YVBJwSW6CmLtFlaA5WXLocb9n7mM5iYM/TvvvJs1jraeaoDHX3KvKGF+l0SuUTPn1uRmnZFUcTxGLSNjHodctPUmziSKi8Ktg6XTy/AxNxUdDu9eHff0LHptl6XFA/wzcVk1I2WDIsRGRY2Z9MUw4mjfXVdcHr8yEs3K5rXFQkkXqIkmK6bmOX4sQjH9c79LpPy02AyKP9U09KKAF51Kcq0IMU0dMqqPDcVZxVnwucXseGQMtUXbqhO1JYRJ9oFjS09LvS4vNAJw1fH5ETNcWmlJo1C0ekE3M7HprcOHZt+a3c9PD4Rc0utmF2qvtkznuFZLw0xNO1KKwEm52rmQojES5Qks+cFCM84drQ5dn4XYGDlRc0NvsDwY9KDUXrXUSKn64YS7YJG3tKsyE1TfHVCkYoTR/WdyosXALhhQSnSTHoca+mVlvcBbMT29Z0s2+U2qrqMG/7a2xRD0+7WE+zfUwv5LhwSL1Hg94vSFRR/IiUb0oqAUdpGPOMlFpNGAJCXwfYbOT1+9MawHzwctYG1AKO1yy6fzcTL1uNt6HZ6ZD9DMKAusZ+j0baNjgfM5ErtNAqlQKWsF79fxJnAtJHSm5szLUZcP58ZcV/eFhyb/vRoK8509iPTYsDVc0oUPUMywCdcG2Nk2u11efFFfRcA7Zh1ARIvUdHW54LXL0InBK/2kw1pXHoU9R+LnUahpJoMSDezfrDarSOp8jJKO2JKQQamFKTD4xPxyeEW2c/AR9kTvfLC20b1nf0RbdvlZl0l/S6cQpX2GzX3OOH2+WEI2YujJLcHjLv//KpF+h3gRt3r55cN20IlIiPWQXW7TrXD6xdRnpOquACOBBIvUcD9LgUZFk3Mu6vBWMsZ/X4Rx1qU32k0GK1sl66VMl5GNyoHA+vk33WULJ6XwkwzUox6+PxiRCsXuLhWai1AKGplvdTxFRVZKTF5rZqcn45l0/IhisAft5/GmU4HPjnChPlti8sV//7JQHA5Y2zEC28BaqllBJB4iQqeJ5Gsfhcg2IoYqW1U3+mA08Ni1wfnnCiJVky7wXTd0a9UVgZ8L5uPtsq6DdvvF6WycqJXXgRBkH7OkfheTqhReemJsXiJgVl3MHcurQAAvPV5PX6/5RREkRk9ldxtlkyUSJWX2DyXtJbvwiHxEgW2gOJNtoWMofBfoB6Xd1i/xpHApNGU/PSYrk8Iihf19sjY+z3S+PNYwu3skkyU5aTA6fFj05FW2c7Q3ueG2+uHTkgOkR2cOAqv8tLZ55aqc7F4U+ULCGPdNqpXOKBuOJZNzcekvDT0uLx4eVstABqPlpPQzdJKDya09brwVeC1fMkYe6tiDYmXKGjqpspLqsmAnDTWohmu+nKsJbZ+F06eNHGkXtuIl+rz0s2SB2ckBEHA5YF1AXIG1vF+eGGmBcYkaG1GuqCR+10mZKUgbYx/IzngbaO2XldEvpzxUh/43Yxl5UWnE3BHwPsCAAUZZlx6VmHMvn+iU2hloYcur1+xjCjO9sCU0YyiDORqzN+Z+K9qCsA9LyVJmvHCGW1BI6+8TItBsm4o0ooAFdtGvHVRGWZ2CG8dffJVC1xenyxnSJYxaQ5f0Bhu24ivBYjFpBEA5KaZYNAJEMXYhiiq0TYCgG/ML5WE+83nlSWFgI4VZoNeukhTek3AtsA+I62k6oZCz6goSPaMF47keh/GOMYzXqYpGLs+HFLbSMWU3WDGS3hen3NKs1CYaUavy4vPjrXJcoZE3yY9mIoIg+piadYFWDWiICP2E0dqiZd0swGPf+1srJhZiDuXVsb0eycD/Pda6QWNWjXrAiReoiKYrpvs4oW9IA6uvHh8fpxsZW8isdhpFEqeBlYESDuNxjDrcnQ6IWTqSJ7WUbDykhzPUZ6Q29jVH1b1KpZj0pxYZ730u31SBbIsJ/Yi9vr5pfj9HQuk9jIhHyV84khB8VLf4UBdhwN6nYCFlSRe4h6/X5TES7JXXvgb45lBv0Cn2/vg9vmRYtTHfExXC9NGkVZeAGBlwPfy8eFmWTwRXFCWJknlJT/gL/KLCGtc+jhPf46heJG2S8dIvPBk3QyLgRYhJhglMQiq4y2juaXWMb17akDiJUI6HG64fX4IQnCCIFkpzR4+LOloSDidLoaTRkBws7SaKwJOhZGuO5iFlTnITTOhy+HBzpMd4z5DsgTUcQRBkKovY00c9bm80ot+LCsvhTFeERC6TVor+2gIeeBVfyWD6oItI+35XQASLxHDqy556eaYLBvUMiO1jbhZN1Y7jULhIXUenyhtdY4lvS6v1LIqD7NtBAB6nSBNZMgRWMczIJJFvADhrwng+S556SZkpcaupVEY47aRWn4XQnlKFE7ZFUUR2wKTRlrLd+Ek97tvFDRJk0bJXXUBgm2jlh7XAJ8BT9aN1U6jUMwGvVQiV6N1xFtGOWmmiEv1fOpo/cFm+PzRV4363T5phDKZxIuU9TLGxBE368ay6gJAMuzaSLwQ44T/Xis1bXS0uRdtvS5YjDqcOzFLke8xXki8RAgPqEt2vwvA3qAtRvYUsoX8EgUrL+okavLqizriJbxk3eFYMjkPGRYD2npd2FvXGfUZuFk3w5xcXodwKy9qmHWB4GtGS4zbRlraR0PIA794bu52wqtAbhBP1T2vIkfxjevRQuIlQpqkSaPkuaIdCUEQJEMubx25vD5p2ibWk0YcNcelpYyXKFYimAw6XDoz0Do6EP3UUbKNSXPCDaoLjknH9vkptY1ilP5cR+IlYclLN8OoF+AXgWYFLtK4WVerLSOAxEvEUMbLQPgbJJ84OtnaB59fRIbZgKJMdX5G+QEjtSqVlzZeeYlun9NlUuvIFrXhuDHJxqQ5vG3UaHei3z3yuHQsdxqFUhh4XnY5PHB65AkjHAlRFFHfEft0XSI26HSC9B4k97i01+eXhga0mO/CIfESIU2012gAfOKIV16kcLqiDNUmHNTcLC1tkw4zXXcwy6blI9WkR0NXP/afsUf1NZK18pKdakSmhY10nu4Yvvri8vokX1KsxUtmigHmgMlfaWHd1utGv8cHQUj8reLJCk94lzuobn+DHT0uLzItBpxdYpX1a8sJiZcIkTJeVKoqaI0Jg1zvknhRwazLUTPrJeh5ia7yYjHqsXx6AQBg3cHoWke8CjYhO7netARBkKovI7WOTrX1wS+y7BNuoI0VgiDEbOKIt4xKrClJPxWZqChl2t0W8LtUTc6N6VLdSKFndQSIokiel0EMjqkOzXhRC2m/UYw9L/1unzRJEm667nDwqaN1X0bXOuJCMhmvuCvG2C7NdxpNKUhXpTLIg+qUznoJmnWT7zmQLPC2sNzj0nxEWqv5LhwSLxHQ5fDA5WXO7kKrtjZsqsWEIeJFvTFpjhRUF+PKC29VWFOM48oPWT6jACaDDqfa+nAk8POMhGTMeOGMNXEU651Gg+ErApQel5bMutnkd0lU+AU0/32XA6fHh92n2aSjls26AImXiGiSAupMmh0fizW8NdHU5YTD7ZVeNNUIqOOoVXmpbYtsp9FIpJsNuHAqe+GIdOrI7xclX1YyVl7GynpRa0yaw9vNSq8IoIyXxGdwy14O9pzuhNvrR2GmGZPzo2t9xwoSLxHQRBkvQyjMtEAnAG6fHztOtkMUWf4LN82qAfcytPe6xhX2FinR7DQaCb7raF2Eixpbe13w+EToQ7YYJxNjjUufaFFXvATbRjESL+MU0oR2KQ60jfj7khzwfJelk/M0v1KCxEsESGPSmcl3RTsSRr1Oupr85KsWAKwkr+YTPyfNBEEA/CLQ6YjdxJG0TTpv/OLl0pmFMOgEHGnuwclAtSAcePuuKNMCgz75fr15vk5Ljwt9Lu+Aj3lDtp3HOuOFE6v9Rmco4yXh4W3hTodn1GiASNjKVwJo3O8CkHiJCJtk1qXKSyi8dbTxq1YA6oXTcQx6HXJSY5+yyysv420bAYA11YiqySxjIZKpo2TNeOFYU43ISWP/9rWDWkf1nf1w+/ywGHWqtdT4Mlclg+pcXh+aApUdahslLpkWo7TtuVGG6ou934MDZ7oAaDvfhUPiJQIooG54Bpt21fS7cPLSYz8uPd4x6cGETh2FSzJPGnG4eKwdNHF0LGB+npQX+23nHN42UnJFQENnP0QRSDXpkZumXvuWUB45t0vvPNkOvwhMykuLi2laEi8RYOtO7qvakRg81aLmpBGHZ720xci06/T4pKsfOSovAFB9VhEEAdh/xo4zncOP/g6GhwUm46QRR/K9DKq8cLOuWju3gOC0Ua/Li95BbS25CJ000rpvgRgfUtaLDBNH0hbpOKi6ACReIoI8L8MzOAxNzYwXTqyD6uo7HBBFtgwxR6ar3fwMM86ryAHANk2HQ0MSj0lzuO/l1CDTrpTxkq/e8zPdbJBK/UqZdmkhY/LAL6TlSNkNNevGAyRewkQURfK8jEBoi6IgwzyujBO5iPVmaW7WnZgn79Xu5VLrqCmsx1PbaOSJIy5e1Ky8AMpPHNGYdPLAVwSMd+KopduJYy29EARIXjutQ+IlTLr7vXAEHN3keRlI6BulmmsBQol120jOMelQLjubiZfdpzvREobJk7eukm01QChS1kuIeBFFcUC6rpoUSlkvyjw3gwsZk/c5kCwUS1kv4xPCvGV0dkmmJi4+w4HES5ikmvV4//6l+P3tC2AxUkBdKKFvlFoTL7EKqquVcdIolJKsFMwty4Iojt066nN50eXwAEju6iCvvLT3udHtZD+PRrsTDrcPBp0gu8CMFKX3G1HGS/IgrQgYZ+Ul3lpGAImXsDHqdZhTmoUVZxWqfRTNkWoyIDvVCEAbfhcg9tNGfNKoQoE3Rt46Wj/G1BFvGWVaDMiwGGU/R7yQbjZI//68dcSrLhV5aTCqnH9ToOB+I1EUJc8LtY0SH6lt1OWMag8awJ4z2+Io34VD4oWQhTmlWdAJwIKAwVRtgm2j2ITUSZUXGQLqBsPFy/aT7ejsG/nv09BFk0acyjz2xn1qkHhR06zLKVQw66XL4UFPYIqplPYaJTzcwtDv8UlV10g53e5AQ1c/jHoB51Vky3k8RSHxQsjCs9+cj80/WK66n4DD9xt19Lnh8fkV/V5ur18aUZ6oQKl+Ym4aZhZnwucXseHwyK0jLl5Kk9jvwgkuaGRViOMtLONFbbMuEOp5kV+88JZRQYaZ2ttJgMWol4YTom0dbT3BWkbzyrORajLIdjalIfFCyEKKSa+p0czsVBP0gSCyjlGqFXJwptMBfyAUjIsmuVl59tiBdY1UeZEYnPWiFbMuEJw2UmKzdH0ntYySjZJxmna3HWcto3jyuwAkXogERacTpHRRpX0vtSGTRkqFgl0+m4mXz461occ5fHm4kTJeJEInjkRRxLGAeJmshbZRyH6jaH0KI0Fj0skHN+dHMy7t94vYFqi8xEs4HYfEC5GwxCqojrcm5J40CmVqQTom5afB7fNLCzAHQ56XIJUhlZf2Pje6HB4IgjbECzfsur1+2Puj8ymMBAXUJR8lg9azRMJhWzc6HR6kmvSYW5ol88mUhcQLkbBIE0cKj0srlfESiiAIIYF1w7eOuO8mmQPqONzz0uXwYHdtJwDmBUoxqe8DMRv00nSe3BNHdSReko7QiaNI4S2jhZU5MBniSw4oetrOzk6sWrUKVqsVVqsVq1atQldX14iP93g8+Pd//3fMnj0baWlpKCkpwe23347GxkYlj0kkKDGrvLQrX3kBgJVnFwMANh1pRX8gMJHj84uSh4LEC/NgFQXaMx8HTM5TC7SRQQQol/VCbaPko5hnvURReeFm3XjzuwAKi5dbb70VNTU1WLduHdatW4eamhqsWrVqxMc7HA7s3bsX//mf/4m9e/finXfewdGjR/G1r31NyWMSCUqsxMtpBcekQ5k1IROl2Sno9/iw+ejA1lFLjxM+vwiDTpD+3slORWBcmrfZtGDW5RQoIF68Pr/keyLxkjxIyxntkT2X3F4/dp3qABB/fhcAUGwu6vDhw1i3bh127NiBRYsWAQCef/55VFVV4ciRI5g+ffqQz7FardiwYcOA+379619j4cKFqKurQ3l5uVLHJRIQ3jZSckWAx+fHmU6+TVpZ8SIIAlaeXYTff3YK6760YeWsYulj/KqrOMsiTVklO5V5adhxskOaNtNCxgunMCAwW2QU1k12JmBNBh0KSMAmDbxtZOtm//7h/v5/caYLDrcPOWkmzCzKVPKIiqBY5WX79u2wWq2ScAGAxYsXw2q1Ytu2bWF/HbvdDkEQkJWVpcApiUQmFpWXxq5+eP0iLMbYvGHwqaN/Hm6ByxtsHXEBxV/IiKFicooGMl44vG1ki/BqeTQkv0t2CnQkYJOG/AwzDDoBPr8Y1v4zDl8JUDUpNy6fL4qJF5vNhoKCgiH3FxQUwGYbPeac43Q68fDDD+PWW29FZubwytDlcqG7u3vAjSCAkM3SClZepG3SOWkxeQGYV5aNggwzelxeyWwHBMekye8SZHAbT0tto0Kr/G0j8rskJ3qdIInhSHwv/PUjHltGQBTi5fHHH4cgCKPedu/eDQDDZl6IohhWFobH48HNN98Mv9+Pp59+esTHrVmzRjIEW61WlJWVRfpXIhIUXglpU7DywnfnKJGsOxw6nSBtmv7wyybpfgqoG0pliHgpzDQjU0P7nnjbqFnG5yZNGiUvEyIMqnO4vdhXz6bw4tGsC0Thebn//vtx8803j/qYiooK7N+/H83NQ6PMW1tbUVg4+nJDj8eDG2+8EadOncInn3wyYtUFAB555BGsXr1a+nN3dzcJGAIAkJ/Orka6nV44PT5F4tKV3Gk0EpfPKsIrO05jw6FmeH1+GPQ6SbxMoNUAEuU5qRAEQBS1VXUBlFkRQJWX5IVPHIUbVPd5bSc8PhETslJiduElNxGLl7y8POTlja3UqqqqYLfbsWvXLixcuBAAsHPnTtjtdixZsmTEz+PC5dixY9i4cSNyc0cvaZnNZpjNZE4jhpKZYoBJr4Pb50dbr0uRRXV8m3QsXwAWVuYgO9WITocHu051YMmUPAqoGwaLUY8Sawoauvo1ZdYFQsRLjwt+vyhLy5EC6pKXSFcEbAv4XZZMzlUsFVxpFPO8zJw5EytXrsQ999yDHTt2YMeOHbjnnntw1VVXDZg0mjFjBt59910AgNfrxfXXX4/du3fjtddeg8/ng81mg81mg9sdm+3AROIgCILke1Fqu7RUeVF40igUg16H6rN464j5x7h4mRC4AiMYk/LZv8u0Iu1kvADMjyUILJ+nXabdW/VUeUlaSqyReV6kfJcp8dkyAhTOeXnttdcwe/ZsVFdXo7q6GnPmzMErr7wy4DFHjhyB3W4HAJw5cwbvv/8+zpw5g3POOQfFxcXSLZIJJYLgKDlx5POL0htGrEuvKwNpu+sP2mDv96DH6QVAlZfBfL96Ou4+vxJfm1ui9lEGYNDrpFF+OUy73U4POh1s1QBVXpIPqfISRtuoy+HGwUY22LJkcnyadQEFc14AICcnB6+++uqojwldTFZRUSH7ojIiuVEy66Wxqx8eH8vViPWI8pIpucgwG9DS48I/9jPjbnaqMa5W2seCuWVZmFuWpfYxhqUw04zWHheau52YNcE6rq/FRXRumgnpZnoOJBvFEawI2H6iHaLI9qXxsMR4JL6WGRBEhChZeeF+l/Kc1JjnJJgNelwyk0URvLj1FACqusQbRSHbpccLFy+lVHVJSvi0UXufG06Pb9THJkLLCCDxQiQ4SoqXoN9FnTcMnrB7vKUXAImXeEPOFQE0aZTcZKYYkBpYOjrWmgAp3yWOW0YAiRciwVGybRTMeImdWTeUZdPykRIy/k0BdfFFYQafOJJTvNBzIBkRBAHFYZh2m+z9ONnWB50ALJpE4oUgNIuylZfYbJMeiRSTHhdNz5f+TOIlvijM5IZdOdpG7A2LKi/JS3BcemTxsjVQdZldmgVrinZCG6OBxAuR0EjiRYHKC98mrVblBQhOHQHUNoo3CmVsG1HGC8GHBkbLeuH5LkvjvGUEkHghEhypbSRz5cXvF3G6g1de1BMvF88ogEnPfo0pXTe+KJCp8uLzi9JiTqq8JC/84mWklF1RFBPGrAsoPCpNEGrDKy99bh/6XF6kyTRGaut2wu31w6ATUKJiMFyGxYifXDcLR209mFs6vnFbIrbwykt7nwsenx9GfXTXks3dTrh97LlYTFvFkxa+IqBhhLbRidY+NHe7YDLoMH9idiyPpggkXoiEJs2kR4pRj36PD229LtnEC580Ks9JhSHKNx25uHEB7fKKR3JSTTDqBXh8Ilp7XFG3/bhZd0J2CvQxHtkntMMEqfIyfNtoW6DqsmBitiJ73mINtY2IhEYQBORl8BUB8rWO1NhpRCQWOp2Agozx+15oLQABYMC00XBhr1uPJ07LCCDxQiQB+enyTxzVasCsS8Q/cvheyKxLAEHPi8PtQ3e/d8DHfH4R208kRr4Lh8QLkfDkKSFe2tQNqCMSAzmyXiigjgDYFvWcNFZlHrzj6GCjHd1OLzLMBswe5yoKrUDihUh4guPS8m2WltpGeVR5IaInmPUyfvFSlk3iJdnhwwODs154vsuiSTmqe/TkIjH+FgQxCnIH1YmiGLIagMQLET0FMuw3qqOAOiIAnzZrHGTa5WbdJZMTw+8CkHghkgC520YtPS44PX7odQKl2hLjYrxBdQ63VzKik3ghJgyTsuvy+vB5bQeAxDHrAiReiCSAV17kmjbifpcJWSkwGehXiIieonGKFx5Ol2kxwJoa33HvxPjhE0dNIeJl7+kuOD1+5KWbMa0wXa2jyQ698hIJj9xtI+53qSC/CzFOxrvfqC7wXCwn4ziB0P1GQTEcbBnlQhASJweIxAuR8OSHbJYeLv8gUoJ+F3rDIMYH97zY+z1wenwRfz5NGhGhSIbdkGmjYL5LYoxIc0i8EAkP97y4vH70uLxjPHpsggF1VHkhxkemxQCLkb0Mt0RRfaFJIyIUbti12Z3w+UX0OD344owdQGKZdQESL0QSkGLSIyOwFkCO1tEpynghZEIQhKBpN4qsFwqoI0IpyDBDrxPg9Yto63Vh16kO+PwiynNSE+45QuKFSAryMuTZLi2KIk5Tui4hI4XjWBFAbSMiFINeh8LAa11DV7+U75JoLSOAxAuRJEgrAsY5cdTW60af2wdBAMpyaEyaGD98RYBthIV6IyGKIuo7SbwQA+Gm3aYuZ0Lmu3BIvBBJgVwTR7zqUmJNgdkQ/5tZCfXh49ItET43W3tZ3pBOQNQbqYnEozjwXDjQYMdXth4AibPPKBQSL0RSkJcuz2bpWmlMmq50CXmINqiO+12KrZQ3RAThE0fv7WsAAMwoykBuoPKcSNAznkgK5K680FoAQi4KotxvJE0aUfuSCKGETxwFnk+JlKobCokXIimQa0WAVHkh8ULIBK+8RDoqXddOO42IoQxuISaiWRcg8UIkCcEVAePbLB2cNKI3DEIeom0b0aQRMRx8RQAAGHQCFlaSeCGIuEWOtpEoisGMF1oNQMhEQeC52ef2oTeCEEU+aZRo+R3E+AhdFju3LAvpgYyrRIPEC5EU5IWsCPD7o1sR0OnwoMfJ3lzoapeQizSzQQpRjGRcup4qL8QwZKUapdTmpQk4ZcQh8UIkBbmBaSOvX4S93xPV1+A7jYqtFliMNCZNyEehlftewhMvTo9PMmRS5YUIRRAETC/KBABcNKNA5dMoR2LWkwhiEGaDHlmpRnQ5PGjtdSE7zRTx1yC/C6EUhZlmHG/pDXtFQENXP0QRSDXpkRvFc5lIbJ66+RzUd/Tj3PJstY+iGFR5IZIGqXUUpe+lto0mjQhlCK4ICO+5GWrWFQRBsXMR8cnE3DScPzUxR6Q5JF6IpGG8KwKkjBcy6xIyUxDhxNEZWshIJDkkXoikYbwTR8GMF3rDIOSlMBBUF27WC41JE8kOiRciaciTqfJC26QJuYk064XEC5HskHghkobxVF7sDg86HWxKiQy7hNzwyostbPHC0nVpNQCRrJB4IZKG8YgXPiZdkGFGqomG9Ah5CV0RIIqj5xCJokgZL0TSQ+KFSBqCm6UjXxFQSwsZCQXhwtrt86PLMXoOUafDIyXxlmaTeCGSExIvRNIwnsrL6YBZl1pGhBKYDXrkBPJaxsp64VWXwkwzhSUSSQuJFyJp4OKlo88FX4QrAmppTJpQGL7jaKysFzLrEgSJFyKJyEk1QRAAvwh09EXWOqLKC6E04U4c1VHGC0GQeCGSB4NeJ0WpR9o6Ok2eF0Jhglkv4bWNysjvQiQxJF6IpCKarJcep0cy+VLlhVAKXnkZa1ya2kYEQeKFSDK47yWS/Ua8ZZSXbkKGxajIuQgi2DYK0/NCQppIYki8EElFNPuNailZl4gBwayXkSsvHp8fTXb2caq8EMmMouKls7MTq1atgtVqhdVqxapVq9DV1TXq5zz++OOYMWMG0tLSkJ2djRUrVmDnzp1KHpNIIvKiGJcmsy4RC7jnZbTKS1OXEz6/CLNBJwlxgkhGFBUvt956K2pqarBu3TqsW7cONTU1WLVq1aifM23aNPzmN7/BgQMH8Nlnn6GiogLV1dVobW1V8qhEksBf8Nsiqby0kVmXUB5eeWntHXmUn7eMSrNToNMJMTsbQWgNxXLODx8+jHXr1mHHjh1YtGgRAOD5559HVVUVjhw5gunTpw/7ebfeeuuAPz/55JN44YUXsH//flxyySVKHZdIEqIJqqPKCxELctNM0AmAzy+ivc+FggzLkMeQWZcgGIpVXrZv3w6r1SoJFwBYvHgxrFYrtm3bFtbXcLvdeO6552C1WjF37lyljkokEXnRVF5oTJqIAQa9Tnp+tozQOiLxQhAMxSovNpsNBQUFQ+4vKCiAzWYb9XP//ve/4+abb4bD4UBxcTE2bNiAvLy8YR/rcrngcgV/0bu7u8d3cCKhibTy4nB70RJ4LIkXQmkKMy1o6XHBZndi1gTrkI/XU0AdQQCIovLy+OOPQxCEUW+7d+8GAAjC0J6sKIrD3h/K8uXLUVNTg23btmHlypW48cYb0dLSMuxj16xZIxmCrVYrysrKIv0rEUkEFy+dDg88Pv+Yj69tY28W2alGWFNpTJpQFmlceoT9RvWdVHkhCCCKysv999+Pm2++edTHVFRUYP/+/Whubh7ysdbWVhQWFo76+WlpaZgyZQqmTJmCxYsXY+rUqXjhhRfwyCOPDHnsI488gtWrV0t/7u7uJgFDjEhWihF6ncB8Bb1uFFmH+gpCOU1j0kQMGWviiDJeCIIRsXjJy8sbsYUTSlVVFex2O3bt2oWFCxcCAHbu3Am73Y4lS5ZE9D1FURzQGgrFbDbDbKaRQSI8dDoBeekmNHe70NrjGlO81AbMuhX0ZkHEgNGyXuz9HnQ5PABoNQBBKGbYnTlzJlauXIl77rkHO3bswI4dO3DPPffgqquuGjBpNGPGDLz77rsAgL6+Pjz66KPYsWMHTp8+jb179+Luu+/GmTNncMMNNyh1VCLJkHwvvaPHsANUeSFiS7DyMvS5yf0uuWkmpJkVsysSRFygaM7La6+9htmzZ6O6uhrV1dWYM2cOXnnllQGPOXLkCOx2OwBAr9fjq6++wje+8Q1MmzYNV111FVpbW7FlyxacffbZSh6VSCKkiaOesTdLS5NGeXSlSyhPwSgrAsisSxBBFJXvOTk5ePXVV0d9jCgGw5gsFgveeecdJY9EEBGtCAhmvFDlhVCewkC2S8swhl0y6xJEENptRCQd4Y5LOz0+aY8MjUkTsYC3jdp63XB7B07DUcYLQQQh8UIkHXlhVl74m0WmxYBsGpMmYkBOmglGPYuSGPz8rOvoB0DihSAAEi9EEhJu5eUU32mUlzZmNhFByIEgCNJagMGmXe55Kc1Jifm5CEJrkHghko6gYXd08UKTRoQa8NZR6Li0zy/iDHleCEKCxAuRdARHpUcXL5TxQqhB4TATR7ZuJzw+EQadgGIrVV4IgsQLkXRw8dLj9MLp8Y34OKq8EGoQFC/ByovUMspOgV5HLUyCIPFCJB2ZFgNMevbUH227NN9rRJUXIpYUDLMioI4yXghiACReiKRDEIQxTbsurw+NdjbdQZUXIpYUjVJ5IfFCEAwSL0RSkjeGeKnv6IcoAmkmPfLSTbE8GpHkDNc2oowXghgIiRciKckPCJK23uFXBJxupzFpQh2G229E4oUgBkLihUhKxmobSRkv1DIiYgzfb9Tt9KLfzQzl9SReCGIAJF6IpCS432j4zdLBnUb0ZkHElgyzASlGPQC248jh9koVQvK8EASDxAuRlHDPy0ibpaVt0lR5IWKMIAghrSMX6gNrAawpRlhTaE0FQQAkXogkZazN0lR5IdSkIMS0GxyTpnA6guAY1D4AQajBaJ4Xt9cvRbFX5FHlhYg9oePS3DBOfheCCELihUhKpP1Gw1ReGrr64RcBi1GHgoDIIYhYEjpx5PGJAMjvQhChkHghkhJeeXG4fehzeZFmDv4qhPpdaEyaUIPQ/Ua9Li8AqrwQRCjkeSGSkrSQiY7BraPTNCZNqEyo54XGpAliKCReiKSFV18Gt474NumJefRmQahDYUawbUQBdQQxFBIvRNIykmmXxqQJteFto9MdDri8fugEoCSLpo0IgkPihUha+M6iwePSNCZNqA0XLyLz6qLYmgKjnl6uCYJDvw1E0iK1jUIqL16fX/IYUOWFUIsUkx6ZlqCJnFpGBDEQEi9E0pKfzq5uQysvjV1OeP0iTAadlLVBEGpQGPL8I/FCEAMh8UIkLXkZgbZRyIoA7neZmJMKnY7GpAn1GCBeqIVJEAMg8UIkLcOtCDjNxQu1jAiVKcgMBiSWZpNZlyBCIfFCJC3DeV74mHQFXekSKkNtI4IYGRIvRNKSF1J5EQNjHbU8oI52GhEqUxiymoLEC0EMhMQLkbTwyovb60e3k0WwU8YLoRV45SXNpEdOmknl0xCEtiDxQiQtFqMeGYFx1NYeF3x+EfUd/QAo44VQnxnFmRAEYG5ZFu3YIohB0GJGIqnJTzejx+lFW68LFqMObp8fRr1AaaaE6lTmpeGfq5dJFUKCIIKQeCGSmrwMM0629UmVFwAoy0mFnsakCQ0wKT9d7SMQhCYh8UIkNaH7jbqdHgDkdyEIgtA6JF6IpIZnvbT1uuANVF7I70IQBKFtSLwQSU1o5cXeT5UXgiCIeIDEC5HUhG6Wbuxik0aU8UIQBKFtaFSaSGp45aWl24XTlK5LEAQRF1DlhUhq+Gbp4y29cPv8MOgETKAxaYIgCE1DlRciqeGbpd0+PwC2AM+gp18LgiAILUOv0kRSk5s2MACMtkkTBEFoHxIvRFJjMuiQnWqU/kx+F4IgCO1D4oVIevh2aYAqLwRBEPEAiRci6QndHVORR5UXgiAIrUPihUh6BogXqrwQBEFoHhIvRNLD20Y6ASjNpsoLQRCE1lFUvHR2dmLVqlWwWq2wWq1YtWoVurq6wv7873znOxAEAWvXrlXsjATBKy8TslNgMpCeJwiC0DqKvlLfeuutqKmpwbp167Bu3TrU1NRg1apVYX3ue++9h507d6KkpETJIxIEygLVlmkFGSqfhCAIgggHxRJ2Dx8+jHXr1mHHjh1YtGgRAOD5559HVVUVjhw5gunTp4/4uQ0NDbj//vuxfv16XHnllUodkSAAAJeeVYj/uXYWLpiSp/ZRCIIgiDBQrPKyfft2WK1WSbgAwOLFi2G1WrFt27YRP8/v92PVqlX4wQ9+gLPPPlup4xGEhMmgw6rFE2khI0EQRJygWOXFZrOhoKBgyP0FBQWw2Wwjft7//u//wmAw4IEHHgjr+7hcLrhcLunP3d3dkR+WIAiCIIi4IeLKy+OPPw5BEEa97d69GwAgCMKQzxdFcdj7AWDPnj341a9+hZdffnnExwxmzZo1kiHYarWirKws0r8SQRAEQRBxhCCKohjJJ7S1taGtrW3Ux1RUVOD111/H6tWrh0wXZWVl4f/+7//wrW99a8jnrV27FqtXr4ZOF9RUPp8POp0OZWVlqK2tHfI5w1VeysrKYLfbkZmZGclfjSAIgiAIleju7obVag3r/TvitlFeXh7y8sY2NlZVVcFut2PXrl1YuHAhAGDnzp2w2+1YsmTJsJ+zatUqrFixYsB9l112GVatWjWs2AEAs9kMs9k87McIgiAIgkg8FPO8zJw5EytXrsQ999yD3/3udwCAf/mXf8FVV101YNJoxowZWLNmDa677jrk5uYiNzd3wNcxGo0oKioadTqJIAiCIIjkQdGcl9deew2zZ89GdXU1qqurMWfOHLzyyisDHnPkyBHY7XYlj0EQBEEQRAIRsedF60TSMyMIgiAIQhtE8v5NWegEQRAEQcQVJF4IgiAIgogrSLwQBEEQBBFXkHghCIIgCCKuIPFCEARBEERcQeKFIAiCIIi4QrGQOrXgk9+0oJEgCIIg4gf+vh1OgkvCiZeenh4AoAWNBEEQBBGH9PT0wGq1jvqYhAup8/v9aGxsREZGRtibqcOFL32sr6+nALwxoJ9V+NDPKnzoZxUZ9PMKH/pZhY9SPytRFNHT04OSkpIBC5qHI+EqLzqdDqWlpYp+j8zMTHpyhwn9rMKHflbhQz+ryKCfV/jQzyp8lPhZjVVx4ZBhlyAIgiCIuILEC0EQBEEQcQWJlwgwm8347//+b5jNZrWPonnoZxU+9LMKH/pZRQb9vMKHflbho4WfVcIZdgmCIAiCSGyo8kIQBEEQRFxB4oUgCIIgiLiCxAtBEARBEHEFiReCIAiCIOIKEi9h8vTTT6OyshIWiwXz58/Hli1b1D6SJvn0009x9dVXo6SkBIIg4L333lP7SJplzZo1OO+885CRkYGCggJce+21OHLkiNrH0iTPPPMM5syZI4ViVVVV4cMPP1T7WHHBmjVrIAgCHnzwQbWPojkef/xxCIIw4FZUVKT2sTRLQ0MDvvnNbyI3Nxepqak455xzsGfPHlXOQuIlDN588008+OCDeOyxx7Bv3z5ccMEFuPzyy1FXV6f20TRHX18f5s6di9/85jdqH0XzbN68Gd/97nexY8cObNiwAV6vF9XV1ejr61P7aJqjtLQUP/vZz7B7927s3r0bF198Ma655hocPHhQ7aNpms8//xzPPfcc5syZo/ZRNMvZZ5+NpqYm6XbgwAG1j6RJOjs7sXTpUhiNRnz44Yc4dOgQfvnLXyIrK0uV89CodBgsWrQI5557Lp555hnpvpkzZ+Laa6/FmjVrVDyZthEEAe+++y6uvfZatY8SF7S2tqKgoACbN2/GhRdeqPZxNE9OTg5+/vOf46677lL7KJqkt7cX5557Lp5++mn85Cc/wTnnnIO1a9eqfSxN8fjjj+O9995DTU2N2kfRPA8//DC2bt2qma4DVV7GwO12Y8+ePaiurh5wf3V1NbZt26bSqYhExG63A2BvysTI+Hw+/OlPf0JfXx+qqqrUPo5m+e53v4srr7wSK1asUPsomubYsWMoKSlBZWUlbr75Zpw8eVLtI2mS999/HwsWLMANN9yAgoICzJs3D88//7xq5yHxMgZtbW3w+XwoLCwccH9hYSFsNptKpyISDVEUsXr1apx//vmYNWuW2sfRJAcOHEB6ejrMZjPuvfdevPvuuzjrrLPUPpYm+dOf/oS9e/dSZXgMFi1ahD/+8Y9Yv349nn/+edhsNixZsgTt7e1qH01znDx5Es888wymTp2K9evX495778UDDzyAP/7xj6qcJ+G2SiuFIAgD/iyK4pD7CCJa7r//fuzfvx+fffaZ2kfRLNOnT0dNTQ26urrw9ttv44477sDmzZtJwAyivr4e3/ve9/DRRx/BYrGofRxNc/nll0v/P3v2bFRVVWHy5Mn4wx/+gNWrV6t4Mu3h9/uxYMECPPHEEwCAefPm4eDBg3jmmWdw++23x/w8VHkZg7y8POj1+iFVlpaWliHVGIKIhn/913/F+++/j40bN6K0tFTt42gWk8mEKVOmYMGCBVizZg3mzp2LX/3qV2ofS3Ps2bMHLS0tmD9/PgwGAwwGAzZv3oynnnoKBoMBPp9P7SNqlrS0NMyePRvHjh1T+yiao7i4eMiFwsyZM1UbXCHxMgYmkwnz58/Hhg0bBty/YcMGLFmyRKVTEYmAKIq4//778c477+CTTz5BZWWl2keKK0RRhMvlUvsYmuOSSy7BgQMHUFNTI90WLFiA2267DTU1NdDr9WofUbO4XC4cPnwYxcXFah9FcyxdunRIlMPRo0cxceJEVc5DbaMwWL16NVatWoUFCxagqqoKzz33HOrq6nDvvfeqfTTN0dvbi+PHj0t/PnXqFGpqapCTk4Py8nIVT6Y9vvvd7+L111/HX//6V2RkZEjVPavVipSUFJVPpy0effRRXH755SgrK0NPTw/+9Kc/YdOmTVi3bp3aR9McGRkZQ3xTaWlpyM3NJT/VIL7//e/j6quvRnl5OVpaWvCTn/wE3d3duOOOO9Q+muZ46KGHsGTJEjzxxBO48cYbsWvXLjz33HN47rnn1DmQSITFb3/7W3HixImiyWQSzz33XHHz5s1qH0mTbNy4UQQw5HbHHXeofTTNMdzPCYD40ksvqX00zfHtb39b+v3Lz88XL7nkEvGjjz5S+1hxw7Jly8Tvfe97ah9Dc9x0001icXGxaDQaxZKSEvHrX/+6ePDgQbWPpVn+9re/ibNmzRLNZrM4Y8YM8bnnnlPtLJTzQhAEQRBEXEGeF4IgCIIg4goSLwRBEARBxBUkXgiCIAiCiCtIvBAEQRAEEVeQeCEIgiAIIq4g8UIQBEEQRFxB4oUgCIIgiLiCxAtBEARBEHEFiReCIAiCIOIKEi8EQRAEQcQVJF4IgiAIgogrSLwQBEEQBBFX/P9HbShoTCO+QQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Create the time vector for the simulation\n", "Tf = 6\n", @@ -169,10 +224,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "c35fd695", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Desired trajectory\n", "xd, ud = xe, ue\n", @@ -211,7 +296,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "a7f1dec6", "metadata": {}, "outputs": [], @@ -281,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "5a1f32da", "metadata": {}, "outputs": [], @@ -298,10 +383,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "3a0679f4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": sys[7]\n", + "Inputs (5): ['y[0]', 'y[1]', 'y[2]', 'F1', 'F2']\n", + "Outputs (6): ['xhat[0]', 'xhat[1]', 'xhat[2]', 'xhat[3]', 'xhat[4]', 'xhat[5]']\n", + "States (42): ['xhat[0]', 'xhat[1]', 'xhat[2]', 'xhat[3]', 'xhat[4]', 'xhat[5]', 'P[0,0]', 'P[0,1]', 'P[0,2]', 'P[0,3]', 'P[0,4]', 'P[0,5]', 'P[1,0]', 'P[1,1]', 'P[1,2]', 'P[1,3]', 'P[1,4]', 'P[1,5]', 'P[2,0]', 'P[2,1]', 'P[2,2]', 'P[2,3]', 'P[2,4]', 'P[2,5]', 'P[3,0]', 'P[3,1]', 'P[3,2]', 'P[3,3]', 'P[3,4]', 'P[3,5]', 'P[4,0]', 'P[4,1]', 'P[4,2]', 'P[4,3]', 'P[4,4]', 'P[4,5]', 'P[5,0]', 'P[5,1]', 'P[5,2]', 'P[5,3]', 'P[5,4]', 'P[5,5]']\n", + "\n", + "Update: ._estim_update at 0x165cf9240>\n", + "Output: ._estim_output at 0x165cf8040>\n", + "xe=array([ 0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,\n", + " -1.766654e-27, 0.000000e+00]), P0=array([[1., 0., 0., 0., 0., 0.],\n", + " [0., 1., 0., 0., 0., 0.],\n", + " [0., 0., 1., 0., 0., 0.],\n", + " [0., 0., 0., 1., 0., 0.],\n", + " [0., 0., 0., 0., 1., 0.],\n", + " [0., 0., 0., 0., 0., 1.]])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Standard Kalman filter\n", "linsys = sys.linearize(xe, [ue, V[:, 0] * 0])\n", @@ -332,10 +448,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "1f83a335", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": sys[8]\n", + "Inputs (8): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5', 'F1', 'F2']\n", + "Outputs (6): ['xh0', 'xh1', 'xh2', 'xh3', 'xh4', 'xh5']\n", + "States (42): ['x[0]', 'x[1]', 'x[2]', 'x[3]', 'x[4]', 'x[5]', 'x[6]', 'x[7]', 'x[8]', 'x[9]', 'x[10]', 'x[11]', 'x[12]', 'x[13]', 'x[14]', 'x[15]', 'x[16]', 'x[17]', 'x[18]', 'x[19]', 'x[20]', 'x[21]', 'x[22]', 'x[23]', 'x[24]', 'x[25]', 'x[26]', 'x[27]', 'x[28]', 'x[29]', 'x[30]', 'x[31]', 'x[32]', 'x[33]', 'x[34]', 'x[35]', 'x[36]', 'x[37]', 'x[38]', 'x[39]', 'x[40]', 'x[41]']\n", + "\n", + "Update: \n", + "Output: \n" + ] + } + ], "source": [ "# Define the disturbance input and measured output matrices\n", "F = np.array([[0, 0], [0, 0], [0, 0], [1/pvtol.params['m'], 0], [0, 1/pvtol.params['m']], [0, 0]])\n", @@ -385,10 +515,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "a4caf69b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ekf_resp = ct.input_output_response(\n", " ekf, timepts, [lqr_resp.states, lqr_resp.outputs[6:8]],\n", @@ -398,10 +539,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "1074908c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary statistics:\n", + "* Cost function calls: 5859\n", + "* Final cost: 376.36233549481494\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Define the optimal estimation problem\n", "traj_cost = opt.gaussian_likelihood_cost(sys, Qv, Qw)\n", @@ -416,10 +577,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "0c6981b9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot the response of the estimator\n", "plot_estimator_response(timepts, est, U, V, Y, W)" @@ -427,10 +599,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "25b8aa85", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary statistics:\n", + "* Cost function calls: 9464\n", + "* Final cost: 212754409.97292745\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Noise free and disturbance free => estimation should be near perfect\n", "noisefree_cost = opt.gaussian_likelihood_cost(sys, Qv, Qw*1e-6)\n", @@ -444,10 +636,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "7a76821f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAACiG0lEQVR4nOzdd1hT5xcH8G/C3iAgQ1BxIYoTHODWiuKoq3XWrdVqW9Gq1dpfHXXUOmpt1arVinZonbV10oo4cBVFrbhFQQERVELYJO/vj2sCAQIJJLlJOJ/nuQ/h5o5DksM9ee993ytgjDEQQgghhBCDJ+Q7AEIIIYQQohlU2BFCCCGEGAkq7AghhBBCjAQVdoQQQgghRoIKO0IIIYQQI0GFHSGEEEKIkaDCjhBCCCHESFBhRwghhBBiJEz5DqC6kEqlSEpKgp2dHQQCAd/hEDUxxpCZmQlPT08IhfR9SNcofwwf5RAhukGFnY4kJSXB29ub7zBIFSUmJsLLy4vvMKodyh/jQTlEiHZRYacjdnZ2ALh/avb29jxHQ9QlEong7e0tfx+JblH+GD7KIUJ0gwo7HZGdPrK3t4e9vT3u37+PyZMnw9TUFH///TfP0RFV0WlAfpTMH137/vvvcfXqVaxatQrOzs46378xoRwiRLvoQgeeCIVCREVFITo6mu9QCCnTihUrIBAIEBYWBgAoKCjAp59+imbNmsHGxgaenp4YM2YMkpKSyt3Ojh07IBAISk25ubk6+Cuq7uDBg/joo4/w008/oXPnznj27BnfIRFCiFJU2PHE1dUVAJCTk4OsrCyeoyFE0ZUrV7BlyxY0b95cPi87OxtXr17F//73P1y9ehUHDhzAvXv38Pbbb1e4PXt7eyQnJytMlpaW2vwTNOLJkyeYMGECAMDc3BxxcXHo0KEDHjx4wHNkhBBSNirseGJnZwdzc3MAwIsXL3iOhpAiYrEYo0aNwtatW+Hk5CSf7+DggIiICAwdOhS+vr5o3749vvvuO8TExCAhIaHcbQoEAri7uytM+q6goAAjRozA69ev0a5dO9y6dQsNGzbEkydP0LFjR1y/fp3vEAkhpBQq7HgiEAjkrXZU2BF9Mn36dPTt2xdvvfVWhctmZGRAIBDA0dGx3OXEYjHq1KkDLy8v9OvXD9euXdNQtNqzcOFCXLhwAQ4ODvjtt9/QoEEDnD17Fi1btsTz58/RpUsXnD9/nu8wCSFEARV2PKpZsyYAKuyI/ti9ezeuXr2KFStWVLhsbm4u5s2bh5EjR5bboaFx48bYsWMHDh8+jN9++w2Wlpbo0KED7t+/r3SdvLw8iEQihUmXIiIi8NVXXwEAtm7dCh8fHwCAm5sbIiMj0bFjR2RkZKBnz574559/dBobIYSUhwo7HlGLHdEniYmJmDFjBn7++ecKr38rKCjA8OHDIZVKsXHjxnKXbd++Pd577z20aNECnTp1wu+//45GjRrhu+++U7rOihUr4ODgIJ90OYZdSkoK3nvvPTDGMGXKFLz77rsKzzs6OuLEiRPo06cPcnJyMGTIENy+fVtn8RFCSHmosFPBokWLSvXo08Q1QlTYEX0SExOD1NRUBAQEwNTUFKampoiKisL69ethamoKiUQCgCvqhg4divj4eERERKg9/IhQKESbNm3KbbGbP38+MjIy5FNiYmKV/jZVSaVSjBkzBqmpqWjWrBm++eabMpeztrbGgQMH5C13/fr1Q1pamk5iJISQ8tA4dipq2rSpwnhzJiYmVd4mFXZEn/To0QM3b95UmDd+/Hg0btwYn376KUxMTORF3f379xEZGVmpMd0YY4iNjUWzZs2ULmNhYQELCwu1t11VO3bsQEREBKytrbFnzx5YWVkpXdbCwgIHDx5Eu3bt8OjRIwwePBgRERG8xE0IITJU2KnI1NRU4z35ZIVdamqqRrdLSGXY2dnB399fYZ6NjQ2cnZ3h7++PwsJCvPPOO7h69Sr++usvSCQSpKSkAABq1Kgh7+U9ZswY1KpVS36d3uLFi9G+fXs0bNgQIpEI69evR2xsLDZs2KDbP7ACYrEYCxYsAAAsWbIEfn5+Fa7j4uKCP//8E0FBQTh79iymTJmCn376iQbhJYTwhk7Fquj+/fvw9PSEj48Phg8fjkePHlV5m9RiRwzJ06dPcfjwYTx9+hQtW7aEh4eHfCo+0HZCQgKSk5Plv79+/Rrvv/8+/Pz8EBISgmfPnuHMmTNo27YtH3+GUl9//TVSUlJQv359fPjhhyqv16RJE/z+++8wMTFBeHg4vv76ay1GSQgh5RMwxhjfQei7Y8eOITs7G40aNcLz58+xdOlS3LlzB7du3VJ6KiovLw95eXny32X3SczIyJBfk3To0CEMGjQIbdu2xaVLl3Tyt5DKEYlEcHBwUHj/iO5o+/V/+vQpGjVqhJycHOzbtw9DhgxRexsbN27E9OnTAQD79+/H4MGDNR2mQaMcIkQ3qMVOBaGhoRgyZAiaNWuGt956C0eOHAEAhIeHK11HlV591GJHiH5YsGABcnJy0LFjx0oXZNOmTcNHH30EABg1ahQiIyM1GSIhhKiECrtKsLGxQbNmzarcq4/GsSOEfzExMdi5cycAYO3atVW6Pm7t2rV4++23kZubi/79+9O9oAkhOkeFXSXk5eXh9u3b8PDwULqMhYUF7O3tFaaSZC12YrHYYG6ITogxYYzhk08+AQCMHDkSbdq0qdL2TE1NsWfPHvTs2RNZWVkIDQ1FTEyMJkIlhBCVUGGngtmzZyMqKgrx8fG4dOkS3nnnHYhEIowdO7ZK23VwcICZmRkAarUjhA+HDx9GVFQULC0tVbrbhiosLS1x6NAhdO7cGSKRCCEhIfjvv/80sm1CCKkIFXYqePr0KUaMGAFfX18MHjwY5ubmuHjxIurUqVOl7QoEAri4uACgwo4QXcvPz8ecOXMAADNnzkTt2rU1tm1ra2v89ddfaNu2LV6+fIm33noLd+/e1dj2CSFEGRrHTgW7d+/W2rZdXV2RnJxMhR0hOlRYWIj58+fj/v37qFmzJubNm6fxfdjZ2eH48ePo3r07YmNj0aNHD0RFRaF+/foa3xchhMhQix3PaJBiQnTrzp076NChA9auXQsAWL58udaG33BycsLJkyfh5+eHZ8+eoWvXrnj48KFW9kUIIQAVdryjIU8I0Q2pVIp169ahVatWuHz5MhwcHBAeHo4JEyZodb+urq44deoUGjdujKdPn6Jr16548OCBVvdJCKm+qLDjGRV2hGjf48eP0b17d8ycORO5ubnyDg1jxozRye2/3N3dERkZCT8/P3lxV95wSYQQUllU2PGMxrIjRLvy8/PRpUsXREVFwcbGBj/88AOOHz8OLy8vncYhK+6aNGkiPy1LxR0hRNOosOMZtdgRol1xcXFISEiAvb09bty4gSlTpuikla4sbm5uOHXqFJo0aYKkpCR07dqVessSQjTKKHvF1qhRQ63lBQIBrl69WuXhSyqDCjtSWYb0OefTtWvXAACtW7dGvXr1eI6GK+4iIyPRvXt33Lp1C8HBwdi7dy+6d+/Od2iEECNglIXd69evsW7dOjg4OFS4LGMM06ZNg0Qi0UFkpVFhRyrLkD7nfIqNjQUAtGrVit9AiqlZsyYiIyPRr18/XL58GSEhIVi/fj2mTZvGd2iEEEPHjJBAIGDPnz9XeXlbW1v28OFDLUbEWEZGBgPAMjIyFObfvn2bAWAODg5a3T+pGmXvH5+0/Tlfvnw5A8BmzJghnyeVStnChQuZh4cHs7S0ZF26dGH//fdfhdvat28f8/PzY+bm5szPz48dOHBA5TgYq9rr36lTJwaA7dy5U+11tS0nJ4e99957DAADwKZOncry8/P5Dksr9DGHCDFGRnmNnVQqlXdKUEVmZiZvp2hkLXYZGRnIz8/nJQZimLT5Ob9y5Qq2bNmC5s2bK8z/+uuvsXbtWnz//fe4cuUK3N3d0bNnT2RmZird1oULFzBs2DCMHj0a169fx+jRozF06FBcunRJ5dgrSyqVylvsWrZsqfX9qcvS0hI7d+7EypUrIRAI8MMPP6Bnz55IS0vjOzRCiIEyysLOkDg5OcHExAQAnY4l+kEsFmPUqFHYunUrnJyc5PMZY1i3bh0WLFiAwYMHw9/fH+Hh4cjOzsavv/6qdHvr1q1Dz549MX/+fDRu3Bjz589Hjx49sG7dOq3/LfHx8cjMzISFhQUaN26s9f1VhkAgwNy5c3H48GHY2toiKioKgYGBOHXqFN+hEUIMkFEXdowxREREYPHixfjggw8wbdo0LF68GH///TcYY3yHBwAQCoVwdnYGQIUd0bxXr15h586daq0zffp09O3bF2+99ZbC/Pj4eKSkpCAkJEQ+z8LCAl26dEF0dLTS7V24cEFhHQDo1atXuevk5eVBJBIpTJUha63z9/eHmZlZpbahK/369cPFixdRr149PHnyBD169MDUqVMr/bcTQqonoy3snj17htatWyM0NBQHDx7Eo0eP8ODBAxw8eBC9e/dGYGAgnj17xneYAKgDBdGehIQEjB8/XuXld+/ejatXr2LFihWlnktJSQHA9eoszs3NTf5cWVJSUtReZ8WKFXBwcJBP3t7eKv8Nxcl6xOpTx4nyNG3aFNeuXcMHH3wAANi8eTP8/f1x/PhxniMjhBgKoy3spk2bhho1aiAxMRGxsbE4ceIETp48idjYWCQmJsLR0RHTp0/nO0wANEgxqbySrVolp/KufSspMTERM2bMwM8//wxLS0uly5UcA44xVuG4cOquM3/+fGRkZMinxMREFf6C0mSFnT5eX6eMvb09Nm7ciMjISNSrVw+JiYkIDQ3F+PHj6Z7ShJAKGW1h988//2Dt2rXw8PAo9ZyHhwdWr16Nv//+m4fISqMWO1JZjo6OcHJyUjp17txZ5W3FxMQgNTUVAQEBMDU1hampKaKiorB+/XqYmprKW91KtrSlpqaWapErzt3dXe11LCwsYG9vrzBVhj4OdaKqrl274saNGwgLC4NAIMCOHTvg4+ODefPmUecKQohSRlvYWVlZ4eXLl0qff/XqFaysrHQYkXJU2JHKsrOzw4oVK3Dq1Kkypy1btqi8rR49euDmzZuIjY2VT4GBgRg1ahRiY2NRr149uLu7IyIiQr5Ofn4+oqKiEBwcrHS7QUFBCusAwMmTJ8tdRxNSU1ORlJQEgUBQqnevobCxscE333yDc+fOoU2bNsjOzsbKlSvh4+ODzz//vNz/cYSQ6skoBygGgOHDh2Ps2LFYu3YtevbsKR/ENSMjAxEREfjkk08wcuRInqPkUGFHKqt169YAgC5dupT5vKOjo8odhezs7ODv768wz8bGBs7OzvL5YWFhWL58ORo2bIiGDRti+fLlsLa2VsilMWPGoFatWvLr9GbMmIHOnTtj5cqVGDBgAP744w/8/fffOHfunNp/rzpkrXUNGzaEra2tVvelbcHBwbh06RKOHDmCL774AteuXcOyZcvw3XffYerUqRg3bhz8/Pz4DpMQogeMtsVuzZo16Nu3L0aNGoUaNWrAysoKVlZWqFGjBkaNGoW+ffti1apVfIcJgAo7UnkjR44s93o4d3d3LFy4UGP7mzt3LsLCwjBt2jR5B6STJ0/Czs5OvkxCQgKSk5PlvwcHB2P37t346aef0Lx5c+zYsQN79uxBu3btNBZXWQyt40RFBAIB+vXrh5iYGBw4cADNmjWDSCTC119/jSZNmqBt27b4/vvvkZ6ezneohBAeCZi+jPuhJSKRCDExMfJrfNzd3REQEFDpa3aqEoeDgwMyMjJK7Xvv3r0YOnQoOnbsiLNnz+o0LqKa8t4/on2Vef1HjBiB3bt3Y8WKFZg3b56WI9Q9qVSKw4cP46effsLRo0dRWFgIADAzM0NoaCh69uyJbt26oUmTJhV2btEFyiFCdMNoT8XK2Nvbo1u3bnyHUS5Zix31eCNEc4ytxa4koVCIgQMHYuDAgUhNTcVvv/2G8PBwXLt2DYcPH8bhw4cBcL3uu3btim7duqFly5bw8/NT6f7ChBDDZJQtduvXr8f7779f7imq4n744QeMGjVK4XSSppX3bfXWrVvw9/eHk5MTXQytp/SxtUEfP+faou7rLxaLYW9vD8ZYmePoGbObN2/i8OHDiIyMxPnz55Gbm1tqGQ8PDzRu3Bh+fn7w8fFBzZo14erqipo1a6JmzZpwdnaGpaUlhELVr9YpKChATk6OfLK2tla45Z0+5hAhxsgoCzsTExOkpKTIW8IqYm9vL+/1py3l/VN78eKF/B9gfn6+3o+QXx3p40FJHz/n2qLu63/hwgUEBwfDw8MDSUlJOohQP+Xl5eHy5cuIjIzEuXPnEBcXp9bA7GZmZrCwsIClpSUsLCwgEAggkUgglUrlP2UFnexUsMz06dPx/fffy3/XxxwixBgZ5alYxhh69OgBU1PV/rycnBwtR1S+GjVqQCAQgDGG9PR0uLu78xoPMQyG9jnXJUMcmFgbLCws0KlTJ3Tq1Ek+TyQS4c6dO7h9+zZu376Np0+f4sWLF0hNTZX/LCgoAMC1whUUFEAsFqu1XysrK7Va+wghmmOUhZ26vQAHDBiAGjVqaCmaipmYmMDZ2RlpaWl48eIFFXZEJYb2OdclQx6YWNvs7e3Rtm1btG3btsznGWMQi8XIzc1FXl6ewk+A+38lFArlP83MzOSjDlhZWcHS0lIvOmsQUl1RYacnXF1d5YUdIaowxM+5rlCLXeUJBALY2dkZ5LWYhBAjHsdO9o2y5OTk5IT27dvjwIEDfIeogMayI5VhaJ9zXSgsLMTNmzcBUIsdIaT6McoWOwA4cOBAmacDXr9+jcuXL+O9995DeHg43n33XR6iK62yhZ1YLMatW7dw48YN3LhxAzdv3kRKSgrWrVuH3r17ayNUokcM7XOuC3fu3EFeXh7s7OwMsqMIIYRUhdEWdgMHDlT63NixY9GkSROsXr1abw546hZ2jDEMGTIEBw8eLPP5QYMG4ciRI+jevbvGYiT6x9A+57ogOw3bokULuoCfEFLtVNv/eiEhIbh37x7fYcipO0jx+fPn5UWdu7s7QkJCMHv2bISHh+Ptt99Gbm4u3n77bURHR2stZqL/9O1zrgvUcYIQUp0ZbYtdRXJyclQe2FUX1G2x27JlCwBgwoQJ2LZtm8Jzw4YNw9tvv42TJ08iNDQUp06dQkBAgGYDJgZB3z7nukAdJwgh1Vm1bbHbunWr2t/oN27cCB8fH1haWiIgIECj93WVDVCsSmH38uVL/P777wCAKVOmlHrewsICBw8eROfOnSESiRASEiK/mJxUL5X5nBsyxhi12BFCqjWjbbGbNWtWmfMzMjLw77//4uHDh2oVZnv27EFYWBg2btyIDh06YPPmzQgNDUVcXBxq165d5XjVabHbtWsX8vLy0LJlS7Rp06bMZaytrfHXX3+hZ8+euHTpEnr27ImoqCj4+vpWOVaiPzT5Od+0aRM2bdqEx48fAwCaNm2KL774AqGhoQCgdGyyr7/+GnPmzCnzuR07dmD8+PGl5murJTEhIQGvXr2CqakpmjRpovHtE0KIvjPawk52OqYke3t79O7dG9OmTUOdOnVU3t7atWsxceJETJo0CQCwbt06nDhxAps2bcKKFSuqHK+qhR1jDJs3bwYAvP/+++UOBGpnZ4djx46he/fuiI2NRYcOHfDzzz9XqbesRCLB3bt3ERMTIy8crKysYGtrCxsbG9ja2sLW1haurq7w9PRErVq14OnpCVdXV5iYmFR6v6Rsmvyce3l54auvvkKDBg0AAOHh4RgwYACuXbuGpk2bIjk5WWH5Y8eOYeLEiRgyZEi527W3t8fdu3cV5mnr9LCsta5p06awsLDQyj4IIUSfGW1hFxkZqbFt5efnIyYmBvPmzVOYHxISorRzQl5eHvLy8uS/i0SicvchK+zS09MhkUiUFkHnz5/H7du3YW1tjZEjR1YYu5OTk/xau5iYGISGhmLBggVYtGiRyreievToEX766SdERUXh6tWryMrKUmm94mR317CxsYG1tbX8p5WVFaRSKQoLCxWm/Px85OfnIy8vT/6zoKBAfn/K4veqBLjWpOKTUCgs86esEC75syz79u1TuBWTPtLk57x///4Kvy9btgybNm3CxYsX0bRp01J3RPnjjz/QrVu3CocUEQgEOrubyt9//w0ACAwM1Mn+CCFE3xhtYadJaWlpkEgkcHNzU5jv5uaGlJSUMtdZsWIFFi9erPI+nJ2dAXAtci9fvlR6Y3dZa92IESPg4OCg0rZdXV1x7tw5fPLJJ9i4cSOWLVuG8+fP49dff4WHh0eZ6+Tn5+PQoUPYunWr/GApY21tjVatWiEwMBB+fn4oKChAVlYWxGIxsrKykJmZiefPnyMpKQlJSUl4/vw5JBKJyj1+9YXsfpnVkUQiwd69e5GVlYWgoKBSzz9//hxHjhxBeHh4hdsSi8WoU6cOJBIJWrZsiS+//FIr179JpVLs378fADfcDyGEVEdU2KmhZOsOY0xpi8/8+fMVrn8SiUTw9vZWum0zMzM4OTnh1atXePHiRZmF3cuXL7F3714A3GlYdVhaWmLDhg3o1KkTJk+ejNOnT6NVq1ZYv349HB0dkZGRAZFIBJFIhMePH+PXX39FWlqa/O8OCQnB8OHD0aZNGzRu3Fit06qFhYV4/vw50tLSkJOTg6ysLGRnZyM7Oxs5OTny+02amprC1NQUJiYmMDc3h7m5OSwsLOQ/zczM5HdWEAqF8gng3ovik1QqLfVY1rrHGFNYR9l7WLduXbVeY2Nw8+ZNBAUFITc3F7a2tjh48GCZ16qFh4fDzs4OgwcPLnd7jRs3xo4dO9CsWTOIRCJ8++236NChA65fv46GDRsqXU/dFm8AiI6ORnJyMuzt7fHWW29VuDwhhBgjKuxU4OLiAhMTk1Ktc6mpqaVa8WQsLCzUvsbH1dVVXtiVZefOnRV2mqjI8OHD0apVK7z77ru4efMmhg0bpnRZT09PTJgwARMnTqxSkWNqaopatWqhVq1ald4G0Q1fX1/Exsbi9evX2L9/P8aOHYuoqKhSxd327dsxatSoCq+Va9++Pdq3by//vUOHDmjdujW+++47rF+/Xul66rZ4A9ypcwAYMGAAXV9HCKm2qLBTgbm5OQICAhAREaFwiiciIgIDBgzQ2H5cXV1x7969Mk9ZqtNpoiK+vr64ePEiPv30Uxw7dgy2trawt7eHg4MD7O3t4ejoiN69eyM0NFTl6/CIcTA3N5d3nggMDMSVK1fw7bffyj97AHD27FncvXsXe/bsUXv7QqEQbdq0wf3798tdTt0W7+KnYd955x214yKEEGNBR20VzZo1C6NHj0ZgYCCCgoKwZcsWJCQkYOrUqRrbR3lj2Z07dw537tyBtbU1Ro0aVeV9WVtb47vvvqvydohxY4wpnBIFgG3btiEgIAAtWrSo1PZiY2PRrFmzcpdTt8X70qVLePr0Kezs7BASEqJ2XIQQYiyosFPRsGHDkJ6ejiVLliA5ORn+/v44evSoWkOmVKS8IU+Kd5qwt7fX2D4Jkfnss88QGhoKb29vZGZmYvfu3Th9+jSOHz8uX0YkEmHv3r1Ys2ZNmdsYM2YMatWqJR8CaPHixWjfvj0aNmwIkUiE9evXIzY2Fhs2bNBo7LLTsP379692d9oghJDiqLBTw7Rp0zBt2jStbV9ZYZeeni4/cJV1pwlCNOH58+cYPXo0kpOT4eDggObNm+P48ePo2bOnfJndu3eDMYYRI0aUuY2EhAR5hxYAeP36Nd5//32kpKTAwcEBrVq1wpkzZ9C2bVuNxc0Yk+cHnYYlhFR3VNjpEWWF3dKlS+WdJmh8LqItJe85XJb333+/3B7Zp0+fVvj9m2++wTfffFPV0Mp15coVJCQkwMbGpkqDbxNCiDGotveK1UdlFXZnzpzBt99+CwBYvnx5lTpNEGKMZEMA9evXD1ZWVjxHQwgh/KLCTo+ULOyysrIwfvx4MMYwceJE+T07CSGc4qdh3333XZ6jIYQQ/lFhp0dKFnbz58/Ho0eP4O3trfRidUKqs5iYGDx+/BjW1tb0xYcQQkCFnV6RFXZpaWk4deqUfDiSbdu2qXz7MEKqE1lrXd++fWFtbc1zNIQQwj8q7PSIi4sLAO4+nbKx6qZMmaLQK5EQwmGMya+vo96whBDCocJOj1hYWMhb5lJSUlCnTh2sWrWK56gI0U+xsbF49OgRrKys0KdPH77DIYQQvUCFnZ6RnY4FuPtx2tnZ8RgNIfpL1loXGhoKW1tbnqMhhBD9QIWdnvHy8gIATJ8+Hd27d+c5GkL0U/HTsNQblhBCitAAxXpm9erVOHnyJGbMmMF3KIToLYlEghkzZuDQoUPo27cv3+EQQojeEDDGGN9BVAcikQgODg7IyMige70aIHr/+EWvv+Gj95AQ3aAWOx2R1c8ikYjnSEhlyN43+h7ED8ofw0c5RIhuUGGnI5mZmQAAb29vniMhVZGZmUljCvKA8sd4UA4Rol10KlZHpFIpkpKSYGdnJ7/fq0gkgre3NxITE+nUhIZo6zVljCEzMxOenp4QCqnPka5R/uiGNl9TyiFCdINa7HREKBTKe7yWZG9vTwcmDdPGa0qtDPyh/NEtbb2mlEOEaB99bSKEEEIIMRJU2BFCCCGEGAkq7HhkYWGBhQsXwsLCgu9QjAa9ptUHvdeaR68pIYaPOk8QQgghhBgJarEjhBBCCDESVNgRQgghhBgJKuwIIYQQQowEFXaEEEIIIUaCCjuebNy4ET4+PrC0tERAQADOnj3Ld0gGbdGiRRAIBAqTu7s732ERLaIc0hzKH0KMBxV2PNizZw/CwsKwYMECXLt2DZ06dUJoaCgSEhL4Ds2gNW3aFMnJyfLp5s2bfIdEtIRySPMofwgxDlTY8WDt2rWYOHEiJk2aBD8/P6xbtw7e3t7YtGkT36EZNFNTU7i7u8snV1dXvkMiWkI5pHmUP4QYByrsdCw/Px8xMTEICQlRmB8SEoLo6GieojIO9+/fh6enJ3x8fDB8+HA8evSI75CIFlAOaQflDyHGgQo7HUtLS4NEIoGbm5vCfDc3N6SkpPAUleFr164ddu7ciRMnTmDr1q1ISUlBcHAw0tPT+Q6NaBjlkOZR/hBiPEz5DqC6EggECr8zxkrNI6oLDQ2VP27WrBmCgoJQv359hIeHY9asWTxGRrSFckhzKH8IMR7UYqdjLi4uMDExKdWykJqaWqoFglSejY0NmjVrhvv37/MdCtEwyiHto/whxHBRYadj5ubmCAgIQEREhML8iIgIBAcH8xSV8cnLy8Pt27fh4eHBdyhEwyiHtI/yhxDDRadieTBr1iyMHj0agYGBCAoKwpYtW5CQkICpU6fyHZrBmj17Nvr374/atWsjNTUVS5cuhUgkwtixY/kOjWgB5ZBmUf4QYjyosOPBsGHDkJ6ejiVLliA5ORn+/v44evQo6tSpw3doBuvp06cYMWIE0tLS4Orqivbt2+PixYv0mhopyiHNovwhxHgIGGOM7yAIIYQQQkjV0TV2hBBCCCFGggo7QgghhBAjQYUdIYQQQoiRoMKOEEIIIcRIUGFHCCGEEGIkqLAjhBBCCDESVNgRQgghhBgJKuwIIYQQQowEFXaEEEIIIUaCCjtCCCGEECNBhR0hhBBCiJGgwo4QQgghxEhQYUcIIYQQYiSosCOEEEIIMRJU2BFCCCGEGAkq7AghhBBCjAQVdoQQQgghRsKU7wCqC6lUiqSkJNjZ2UEgEPAdDlETYwyZmZnw9PSEUEjfh3SN8sfwUQ4RohtU2OlIUlISvL29+Q6DVFFiYiK8vLz4DkOvnDlzBqtWrUJMTAySk5Nx8OBBDBw4UP48YwyLFy/Gli1b8OrVK7Rr1w4bNmxA06ZNVd4H5Y/xoBwiRLuosNMROzs7ANw/NXt7exQWAsnJgFgM+PnxHBypkEgkgre3t/x9JEWysrLQokULjB8/HkOGDCn1/Ndff421a9dix44daNSoEZYuXYqePXvi7t27Kr+eJfMHAF68AFJTgbp1ARsbjf05REsohwjRDSrsdER2+sje3h729vaIjQVatQLc3bkCjxgGOg1YWmhoKEJDQ8t8jjGGdevWYcGCBRg8eDAAIDw8HG5ubvj1118xZcoUlfZRMn8AICAAePAAOHMG6NRJA38I0QnKIUK0iy504ImrK/fzxQtAKuU3FkK0JT4+HikpKQgJCZHPs7CwQJcuXRAdHa10vby8PIhEIoWppJo1uZ+pqRoPmxBCDBYVdjyRFXYSCfD6Na+hEKI1KSkpAAA3NzeF+W5ubvLnyrJixQo4ODjIp7Kur5PlEBV2hBBShAo7npibAw4O3GM6MBFjV/L0G2Os3FNy8+fPR0ZGhnxKTEwstYysxe7FC42GSgghBo0KOx4VPx1LiDFyd3cHgFKtc6mpqaVa8YqzsLCQX09X/Lq64qjFjhBCSqPCjkfU4kCMnY+PD9zd3RERESGfl5+fj6ioKAQHB1dp25Q/hBBSGvWK5RG1OBBjIBaL8eDBA/nv8fHxiI2NRY0aNVC7dm2EhYVh+fLlaNiwIRo2bIjly5fD2toaI0eOrNJ+qfMEIYSURoUdj6jFgRiDf//9F926dZP/PmvWLADA2LFjsWPHDsydOxc5OTmYNm2afIDikydPVnk8M7qUgRBCSqPCjkd0YCLGoGvXrmCMKX1eIBBg0aJFWLRokUb3Sy12hBBSGl1jxyM6FUtI5cnyJz2dGzaIEEIIFXa8olOxhFSeiwv3UyoFXr7kNxZCiG6NGzdO4Z7UhkBXMVNhxyNqsSOk8szMACcn7jF9OSLEOD1+/BgCgQCxsbEK87/99lvs2LFD6/s3xAKSCjse0TV2hFQNXWdHSPXk4OAAR0dHvsPQS1TY8Uh2UEpLo/vFElIZ9OWIEMPAGMPXX3+NevXqwcrKCi1atMC+ffsAAK9evcKoUaPg6uoKKysrNGzYED/99BMAbixMAGjVqhUEAgG6du0KoHRLWteuXfHRRx8hLCwMTk5OcHNzw5YtW5CVlYXx48fDzs4O9evXx7Fjx+TrSCQSTJw4ET4+PrCysoKvry++/fZb+fOLFi1CeHg4/vjjDwgEAggEApw+fRoA8OzZMwwbNgxOTk5wdnbGgAED8PjxY4Vtz5o1C46OjnB2dsbcuXPL7WSmSVTYAThz5gz69+8PT09PCAQCHDp0SOF5xhgWLVoET09PWFlZoWvXrrh161aV9yu7RkgiAV69qvLmCKl2qMWOVHeMAVlZup/UrVE+//xz/PTTT9i0aRNu3bqFmTNn4r333kNUVBT+97//IS4uDseOHcPt27exadMmuLw5QF6+fBkA8PfffyM5ORkHDhxQuo/w8HC4uLjg8uXL+Oijj/DBBx/g3XffRXBwMK5evYpevXph9OjRyM7OBgBIpVJ4eXnh999/R1xcHL744gt89tln+P333wEAs2fPxtChQ9G7d28kJycjOTkZwcHByM7ORrdu3WBra4szZ87g3LlzsLW1Re/evZGfnw8AWLNmDbZv345t27bh3LlzePnyJQ4ePKju21s5jLCjR4+yBQsWsP379zMA7ODBgwrPf/XVV8zOzo7t37+f3bx5kw0bNox5eHgwkUik8j4yMjIYAJaRkaEw38GBMYCx27c18IcQrVH2/hHdUPb6T5nC5c/ChfzERVRHOaQdYjGXA7qexGJ1YhQzS0tLFh0drTB/4sSJbMSIEax///5s/PjxZa4bHx/PALBr164pzB87diwbMGCA/PcuXbqwjh07yn8vLCxkNjY2bPTo0fJ5ycnJDAC7cOGC0linTZvGhgwZonQ/jDG2bds25uvry6RSqXxeXl4es7KyYidOnGCMMebh4cG++uor+fMFBQXMy8ur1La0gcaxAxAaGorQ0NAyn2OMYd26dViwYAEGDx4MgPtW4Obmhl9//RVTpkyp0r5r1gQyMrhTSY0bV2lThFQ71GJHiP6Li4tDbm4uevbsqTA/Pz8frVq1wqJFizBkyBBcvXoVISEhGDhwYKVuOdi8eXP5YxMTEzg7O6NZs2byebL7U6cW+4fxww8/4Mcff8STJ0+Qk5OD/Px8tGzZstz9xMTE4MGDB6UGWc/NzcXDhw+RkZGB5ORkBAUFyZ8zNTVFYGCgTk7HUmFXgfj4eKSkpCAkJEQ+z8LCAl26dEF0dLTSwi4vLw95eXny30UiUZnLuboC9+/TgYmQyqDCjlR31taAWMzPflUlfXMR+ZEjR1CrVi2F5ywsLODt7Y0nT57gyJEj+Pvvv9GjRw9Mnz4dq1evVismMzMzhd8FAoHCPIFAoBDP77//jpkzZ2LNmjUICgqCnZ0dVq1ahUuXLlX49wQEBOCXX34p9Zyr7MJfHlFhV4GUlBQARZW+jJubG548eaJ0vRUrVmDx4sUVbp/GsiOk8qjzBKnuBALAxobvKMrXpEkTWFhYICEhAV26dClzGVdXV4wbNw7jxo1Dp06dMGfOHKxevRrm5uYAuM4Imnb27FkEBwdj2rRp8nkPHz5UWMbc3LzUvlu3bo09e/agZs2asLe3L3PbHh4euHjxIjp37gwAKCwsRExMDFq3bq3hv6I0KuxUJKv0ZRhjpeYVN3/+fPk9MwGuxc7b27vUclUZy44xoLCQG8+LkOqIWuwI0X92dnaYPXs2Zs6cCalUio4dO0IkEiE6Ohq2trZ4+PAhAgIC0LRpU+Tl5eGvv/6Cn58fAKBmzZqwsrLC8ePH4eXlBUtLSzg4OGgkrgYNGmDnzp04ceIEfHx8sGvXLly5ckXeExcA6tatixMnTuDu3btwdnaGg4MDRo0ahVWrVmHAgAFYsmQJvLy8kJCQgAMHDmDOnDnw8vLCjBkz8NVXX6Fhw4bw8/PD2rVr8fr1a43EXRHqFVsBd3d3AEUtdzKpqamlWvGKs7CwgL29vcJUlsq2ODAGBAcDTZoASs7yEmL0qMWOEMPw5Zdf4osvvsCKFSvg5+eHXr164c8//4SPjw/Mzc0xf/58NG/eHJ07d4aJiQl2794NgLs2bf369di8eTM8PT0xYMAAjcU0depUDB48GMOGDUO7du2Qnp6u0HoHAJMnT4avry8CAwPh6uqK8+fPw9raGmfOnEHt2rUxePBg+Pn5YcKECcjJyZEf6z/55BOMGTMG48aNk5/mHTRokMZiL4+A6eJKPiVu3Lih9jpNmjSBqan2GhoFAgEOHjwoHx+HMQZPT0/MnDkTc+fOBcBd8FmzZk2sXLlS5c4TIpEIDg4OyMjIUCjyvv0WCAsDhg0D3nyOVfLyJeDszD1etw6YMUP1dYn6lL1/hkQf801Vyl7/1FRA9v2qoADQVqgpKdw9aZs21c72qwNjyCFCDAGv/7FbtmwJgUCgci8RoVCIe/fuoV69ehqNQywW48GDB/Lf4+PjERsbixo1aqB27doICwvD8uXL0bBhQzRs2BDLly+HtbU1Ro4cWeV9V/ZUbEJC0ePvvgM+/BAwMalyOMSI6Uu+aZKzM3eNEWNc4VVOI3qVDBgAxMYCN28CjRppZx+EEKIJvH8Vv3Tpkkq9SBhj8Pf310oM//77L7p16yb/XXZt3NixY7Fjxw7MnTsXOTk5mDZtGl69eoV27drh5MmTpbo6V0ZlTyUV77fx8CFw9CjQv3+VwyFGTh/yTZNMTLjiLi1NsfVOkwoLgZgYbiDxkyepsCOE6DdeC7suXbqgQYMGKt/vrXPnzrCystJ4HF27di23FUMgEGDRokVYtGiRxvdd2V6xxVvsAO6ULhV2pDz6km+a5urKFXbaus7u2TOuqAOAqCiudZwQQvQVr50nIiMj1bqJ79GjR+Hh4aG9gHggazxR936xsha7IUMAoRD45x/uNBEhyhhrvmm7Z2yx2z/izBn1b6VECCG6RL1ieVbZ+8XKWuw6dQJkHW3Wr9dsbIQYAm33jC1+2UNqKnDnjnb2QwghmqAXhd3Tp0+xYMECdOvWDX5+fmjSpAm6deuGBQsWIDExke/wtMrcHJA1oqjT4iA72NSuzfWqBYCff+Za/giprMTEREyYMIHvMNSiyxY7gGu1I4QQfcV7YXfu3Dn4+fnh4MGDaNGiBcaMGYP33nsPLVq0wKFDh9C0aVOcP3+e7zC1qjItDrIWuzp1gA4dgNatgdxcYOtWzcdHqo+XL18iPDyc7zDUUtnrVI8dA/r1A54+LX85WWEn6ysVFaXefgghRJd47xU7c+ZMTJo0Cd98843S58PCwnDlyhUdR6Y7NWty94tV9cCUl8eNqwVwLXYCATeO3dixwIYNwOzZdDcKUrbDhw+X+/yjR490FInmVGbIoCdPuLEjMzOBXbuA+fPLXxYA3n0X2L6dK+wY4/KOEEL0De+F3X///Yeff/5Z6fNTpkzBDz/8oMOIdE/dA5Ps7LSVVdEgxcOGAXPncj34DhzgfiekpIEDB1Y4ll15t8rTR+q22EmlwPjxXFEHAPfulb+8rMVu2DCuCExKAh49AurXr1S4hBCiVbyfivXw8EB0dLTS5y9cuGAQPfOqQt1TscVPw8qOwRYWwNSp3ON16zQaHjEiHh4e2L9/P6RSaZnT1atX+Q5Rbep+Mfr+eyAysuj3+/eVLyuRFOWbnx/Qti33mE7HEmIcxo0bJ7/TlLHgvcVu9uzZmDp1KmJiYtCzZ0+4ublBIBAgJSUFERER+PHHH7HOyCsVdVscinecKG7qVGDFCuDiRWDkSMDLi9u2bAoOBuhOPtVbQEAArl69qvQfmTp3ptAX6nSeuHsX+PRT7vHEicC2beUXdsnJ3ADFpqaApyfQpQtw/jxX2BlYHxNCDNaiRYtw6NAhxMbG8h2KQeC9sJs2bRqcnZ3xzTffYPPmzZC8GQnUxMQEAQEB2LlzJ4YOHcpzlNqlbotD8Ra74tzdgVGjgJ9+An77rfR6QUFAOY2jpBqYM2cOsrKylD7foEEDRBZvzjIAsvx5/RrIz+d6mpelsBAYM4brZNSzJ7B2LVfYpaYCGRmAg0PpdWSnYb29ubtcdOkCLF9OPWMJIfqL91OxADBs2DBcvHgR2dnZePbsGZ49e4bs7GxcvHjR6Is6QP1Tscpa7ADuDhTh4VzL3cyZwHvvASEh3CDGFy5U3AOQGLdOnTqhd+/eSp+3sbFBly5dtLLvjRs3wsfHB5aWlggICMDZs2c1st0aNbjPN1D+cD8rVwKXL3MF3LZtXOu17BZkylrtZIVd3brcz6AgrsB7/Lj03V8ArmPTmDHAxx8DBQWV+GMIMVLHjx9Hx44d4ejoCGdnZ/Tr1w8PHz6UP//06VMMHz4cNWrUgI2NDQIDA3Hp0iXs2LEDixcvxvXr1yEQCCAQCLBjxw48fvwYAoFAoRXv9evXEAgEOH36NABAIpFg4sSJ8PHxgZWVFXx9ffHtt9/q+C/XPd5b7IozMzMz+uvpyqLuOFzKWuwAbkiGMWNKzw8O5gq7Y8eAyZMrFychlbVnzx6EhYVh48aN6NChAzZv3ozQ0FDExcWhdlnfUNQgFHIDfaemcl+OPD1LLxMbCyxezD1ev55rgQO4+74+f84VdoGBpdcrWdjZ2QEBAVyBGBUFjB6tuPz69VwHC4CL55dfuEJQW5KTuQLVxqb85dLSgB9/5G472LRp+cvevQv8+ScwblzRAOrKJCVxHbbatFErbKJBjDFkZ2frfL/W1tZqdbTKysrCrFmz0KxZM2RlZeGLL77AoEGDEBsbi+zsbHTp0gW1atXC4cOH4e7ujqtXr0IqlWLYsGH477//cPz4cfz9998AAAcHBzx//rzCfUqlUnh5eeH333+Hi4sLoqOj8f7778PDw8O4G40YjwYNGsQyMjJUXn7kyJHs+fPnWoxIezIyMhiAMv/e2FjGAMZq1lRtWw0acMufPq36/r/8kltn0CDV1yFFynv/DAWf+da2bVs2depUhXmNGzdm8+bNU2n9il5/f3/u833yZOnnpFLGWrTgnh84kPtdZsIEbv7ixWXvd9Ik7vlFi4rmzZnDzZs0SXHZ588Zs7fnnpNN48czJpGo9CeqJSODsRkzGBMKGfPwYOzcOeXLxsUxVq8eF4+NDWNHjihf9uTJor/Bx4exmzeVL3vgAGN2dtyykyczlpVVUcyGn0P6SCwWMwA6n8RicZXiTk1NZQDYzZs32ebNm5mdnR1LT08vc9mFCxeyFi1aKMyLj49nANi1a9fk8169esUAsMjISKX7nTZtGhsyZIj897Fjx7IBAwZU4S/RP7y22P3xxx94oeL5R8YY/vzzT3z55ZeoKWviMhIl7xcrLOcEuVRaNNxJWS12yoSGAv/7HxARUf51SMR48ZVv+fn5iImJwbx58xTmh4SElNsjvqL4irdS1KjB/UxMBEpeQvjoEXD9OveZX7sWKN64IcuhuLjS6wGA7EyRh0fR87KesZGRiut89hkgEgEtWnBjSY4dy13vamEBrFpVetw7sZhrQX/2jMv9ly+B9HRucnQEBg/mBlAu3uGJMWD/fq4DiKzBIjm56Nq/adMU9/PPP1yrokjEjW2ZlcVtc+3a0i334eHcKWSJhGtljI8H2rfn/oY+fYqWk0iAJUuANWuK5m3dCpw7B+zcyfUellG3VYcYr4cPH+J///sfLl68iLS0NEjf3Bw9ISEBsbGxaNWqFWrIElmDfvjhB/z444948uQJcnJykJ+fj5YtW2p8P/qE18KOMYZGjRrxGYJaNm7ciFWrViE5ORlNmzbFunXr0KlTpypvV3a6Qyrl/rmXd/rjxQvuOh6hEKhVS/V9tGrFXU/0/Dn3D7h796rFTAwPX/mWlpYGiUQCN9kFbW+4ubkhRTbSdgl5eXnIy8uT/y4SiRSez87Ohq2tban1Jk7kprLk5wP16pX93J493KTMlCncVNzDh0AZIeD6dcVTtD/8wE3qOn5c9WUlEq7Yk/X4LYvsmj/GuOtvZ84sf3sAVwiqesbq9u3Sp2TFYjFsKjpPTKrE2toaYrGYl/2qo3///vD29sbWrVvh6ekJqVQKf39/5Ofnw8rKSu39C9+0gLBivfgLSlzY+vvvv2PmzJlYs2YNgoKCYGdnh1WrVuHSpUtq78+Q8FrYRUZG4urVq2jdurXK69RSp5rRIG1eIyS7X+zr11zhVl5hJ+s44emp3t0lhEKgd2/uW/mxY1Uv7LKygIULudYDW1suZlfXop8hIdytzjSloIC7ZkmVt7+ggDt4UaukIr7zrWTLDWNMaWvOihUrsFh2URwhRCmBQKD3xXN6ejpu376NzZs3yxtDzp07J3++efPm+PHHH/Hy5csyW+3Mzc3lI2bIuL451ZWcnIxWrVoBQKnhUM6ePYvg4GBMmzZNPq94hw2jxeNpYMYYYwKBgLVu3Zpt3LiRvX79mu9wlNL0NUJSqZSJxWL51KCBmAFidvy4WGF+yWnXLm65du3KX66sKTycW7dxY/XXLT79+aeY1anDbau8KThYzA4eFLPMzNLbePVKzI4dE7OvvxazixeV70skErNt28Ssdm1umyEhYvbPP2Uv+/ixmM2dK2b29mJmaSlm06aJ2b17ZS/74oWYff+9mHXsKGYDBojZH39w+yq+jLTYxVjGcn0QH/mWl5fHTExM2IEDBxTmf/zxx6xz585lrpObm8syMjLkU2JiYrn58/nn3Odj7NjS73WPHtxz335b+rnU1KLP65Mnis/dv8/NFwrF7PVrxeemT+eemzRJzPbt4x6bmYnZzZul97FsmWJemJiI2cCBXB6V/MwVnzIzxSw6WsxmzBAzT09u3R49xOz69bKXj4gQM3d3xX0tWVJ2/m3bxsUrW87UVMw2by57u2vXcq+BbFkfn7JzViQSs8WLi5bt0EHMJBLjyyGiPolEwpydndl7773H7t+/z/755x/Wpk0bBoAdPHiQ5eXlsUaNGrFOnTqxc+fOsYcPH7J9+/ax6Ohoxhhjv/zyC7OxsWHXrl1jL168YLm5uYwxxtq3b886derEbt26xaKioljbtm0VrrFbt24ds7e3Z8ePH2d3795ln3/+ObO3t1e4Xs8Yr7HjvbCLjo5mkyZNYvb29szKyoqNGjWKnTp1iu+wFGjjwMTXBa80Ve7iYGM5KPGVb23btmUffPCBwjw/Pz+NdZ744QfuIv6S/5+lUsZcXbnnLl0qe9teXtzzb44hcufPc/Pr1Cm9zoED3HO+vtwEcJ0qlFm1irFWrRhbupSxpCTlyykjkTD28qVix4+ypKQw1qsXY05OXIzliYpirEYNbtmKPgJ//81Y3bqMvfMOY69elb/s+fPcsv/8ozjfWHKIVE5ERATz8/NjFhYWrHnz5uz06dPywo4xxh4/fsyGDBnC7O3tmbW1NQsMDGSX3iRtbm4uGzJkCHN0dGQA2E8//cQYYywuLo61b9+eWVlZsZYtW7KTJ08qFHa5ubls3LhxzMHBgTk6OrIPPviAzZs3jwo7XcnOzmY7duxgXbp0YUKhkNWrV48tXbqUJSYm8h0ae/bsGQPAzp8/rzB/2bJlrFGjRmWus3DhwjKLBSrsDGe6dMn4CjsZXefb7t27mZmZGdu2bRuLi4tjYWFhzMbGhj1+/Fil9St6/ffv54qroCDF+YmJ3HwTE8ays8vedvfu3DLh4Yrzf/mFm1/Wd7cXLxR7v7q6MqZPJxxU7YmbmclNmpaXV3qeseUQIfpKLwYoBgArKyuMHTsWp0+fxr179zBixAhs3rwZPj4+6FO8SxaP1LlGaP78+cjIyJBPibKurG/ILniVTePHiwGI8dlnYoX5Jae+fbnl1q4tfzll06JF3PqhoeUv9/y5GOHhYgwaJIaVFbcOIEaDBmKcOKH6/p48EWP+fDEcHbn1mzUTY84cMf75R4yMDG6Ze/fEmDdPjJo1i/YDiGFqKsYHH4gRH6+4zbg4MSZPFsPMrGjZ4GAxDh0SIzNTcdnjx8Xo3l1xux06iPHLL2K8fq34937/vRgtWhQtl5qq3sXBhkTX+TZs2DCsW7cOS5YsQcuWLXHmzBkcPXoUddTp2l0OZbflk936tkkTQNn12Q0bcj9LDlIsu55VNoZdcS4ugL9/0e9LlpR95wq+lNezvjhb27I7gFQVXd9KCI/4riyVyczMZD/88AOrUaMGEwqFvMZSmVOxJVX0bXXBAu6b//Tp5W+nVStuub/+Umm3pVy7xq1vbc3Ym8sUFCQlMTZ0KGNWVootEnXrcmN95eRUbr85OYylpZW/TH4+Y3v2MNa/Pze+2MOH5S//7BljmzYxdvZsxfu/dIk7HVZsyKMySaXcsjNnMlZYWDTf2Fsb9CnfylLR63/nDvc5tbdXnL9oETd/zBjl2169mltm6FDF+e+/z83/4ouy15s+nXve35+xggI1/phqythziBB9oVd3ngCAqKgobN++Hfv374eJiQmGDh2KicrGL9ARc3NzBAQEICIiAoMGDZLPj4iIwIABAzSyD1VvK1be7cRU0aIFNyZXcjJ3v8uePYuey8/nxs66eJH7vV494N13gXfe4Ubbr8pwVJaW3FQeMzNuaAVVh1fw9ASmTlVt2bZti8YfK49AoPqyxkAf860yZC12IhE3HJCFBfe7rMWuvI7AshFgSrbYye46oaxRcc4cbiy62bMBU737T0oIqa704t9RYmIiduzYgR07diA+Ph7BwcH47rvvMHToUL3pxj1r1iyMHj0agYGBCAoKwpYtW5CQkICpqlYWFVDltmJiMTfOHaDe4MTFCQTcYMXbtwNHjyoWdvPnc0WdoyM3JEq7dlUr5oh+MoR8U5ejI1dcFRZyX468vLj5qhR2xU/FMlb0mS/vVCzA5eCOHVUMnBBCNIz3wq5nz56IjIyEq6srxowZgwkTJsDX15fvsEoZNmwY0tPTsWTJEiQnJ8Pf31+j1wip0mInu0zPwUFxNHp19enDFXbHjgHffMPN++MPbjR6gBtpvn37ym+f6C9DyTd1CQRcDiUnc1+OvLy4XHr6lHu+RQvl69arx12TJhZzA3i7u3MFXkWFHSGE6CPeCzsrKyvs378f/fr1g4k275atAdOmTVMY6FCTVCnsZAeaqtaSb73FtW7cvcuNni8Ucrc/AoBZs4CBA6u2faK/DCnf1CUr7GQ5dO0a97Nhw/K/CJmbc8Xbo0fAvXtcYff8OZCby+WGrPWPEEIMAe+F3eHDh/kOQS/ITsWWd7/YhATuZxVvdAEHB+6uEFFRXEvdb78BGRlcK91XX1Vt20S/GXO+lbycQZXTsDING3KF3f37QOfORdfXeXpSD09CiGHRm+FOqruS94sti6Za7ICim3rPnw/8+y93E/U9e9S7TRkh+qTkkCeyFrs3dxsqV8khT+g0LCHEUFFhpyfMzAAnJ+6xsg4UmmqxA7gOFADXExYAdu7UzHYJ4YvscobKttgB3KlYoKjFjgo7QoihocJOj1R0nV1Vhzopzt+/aDtz5wJ9+1Z9m4TwqXiLXUYG8OAB97sqLXYlhzypaKgTQghRx+nTpyEQCPD69Wut74v3a+xIEVdXrsVAWWEna7HTxMFGIOBOvV65ovpYcITos+Itdtevc4+9vYsucyiPrMXuwQPucgg6FUsIMVRU2OmR8sayKywsGrpBU6dM27enYU2I8SjeYqfOaViA+7Jkasr1hH32jE7FEkJKY4xBIpHAVM9HJKdTsXqkvFOxycmARMJdi+fhodu4CDEExVvs1C3sTE2B+vW5x/fu0alYQjSta9eu+OijjxAWFgYnJye4ublhy5YtyMrKwvjx42FnZ4f69evj2LFj8nXi4uLQp08f2Nraws3NDaNHj0ZaWpr8+ePHj6Njx45wdHSEs7Mz+vXrh4cPH8qfz8/Px4cffggPDw9YWlqibt26WLFiBQDg8ePHEAgEiI2NlS//+vVrCAQCnD59GkDR6dMTJ04gMDAQFhYWOHv2LBhj+Prrr1GvXj1YWVmhRYsW2Ldvn8Lfe/ToUTRq1AhWVlbo1q0bHsv+qegAFXZ6pLzCTnYa1stL9Rt8E1KdFG+xU6dHrIzsdGx0NJCTwz2mDkVE7zEGZGXpfmJM7VDDw8Ph4uKCy5cv46OPPsIHH3yAd999F8HBwbh69Sp69eqF0aNHIzs7G8nJyejSpQtatmyJf//9F8ePH8fz588xtNg9J7OysjBr1ixcuXIF//zzD4RCIQYNGgSpVAoAWL9+PQ4fPozff/8dd+/exc8//4y6lWiGnzt3LlasWIHbt2+jefPm+Pzzz/HTTz9h06ZNuHXrFmbOnIn33nsPUVFRALi7+wwePBh9+vRBbGwsJk2ahHnz5qm930rj+2a11YUqN8D+9lvupuLvvlv6uV9+4Z7r2lWLQRKl6Abm/FLl9X/9mssRgDGhkPv59Knq+5g5k1unUyfup6enBgIncpRDWiIWF33wdTmJxWqF2aVLF9axY0f574WFhczGxoaNHj1aPi85OZkBYBcuXGD/+9//WEhIiMI2EhMTGQB29+7dMveRmprKALCbN28yxhj76KOPWPfu3ZlUKi21bHx8PAPArl27Jp/36tUrBoBFRkYyxhiLjIxkANihQ4eKvdxiZmlpyaKjoxW2N3HiRDZixAjGGGPz589nfn5+Cvv99NNPGQD26tWrcl4lzaC2Hz2iSosdtSAQUjZ7+6LBhKVSrgXP01P19WUtdhcucD/pNCwhmtW8eXP5YxMTEzg7O6NZs2byeW5ubgCA1NRUxMTEIDIyEra2tvKpcePGACA/3frw4UOMHDkS9erVg729PXx8fAAACW8OmOPGjUNsbCx8fX3x8ccf4+TJk5WKOzAwUP44Li4Oubm56Nmzp0JsO3fulMd1+/ZttG/fHoJiN1sPCgqq1L4rQ7+vAKxmSo7DVZwmBycmxBjJ7hf77Bn3e6tW3DxVyYY8KSzkflLHCWIQrK25Gx3zsV81mZUYAV8gECjMkxVCUqkUUqkU/fv3x8qVK0ttx+PNheb9+/eHt7c3tm7dCk9PT0ilUvj7+yP/zQCtrVu3Rnx8PI4dO4a///4bQ4cOxVtvvYV9+/ZB+OaaJlbslHJBQUGZcdvY2Mgfy07zHjlyBLVq1VJYzsLCotQ2+UCFnR4pOXJ+cdRiR0jFatYsKuxU7TghI2uxk6HCjhgEgQAoVngYi9atW2P//v2oW7dumb1Q09PTcfv2bWzevBmdOnUCAJw7d67Ucvb29hg2bBiGDRuGd955B71798bLly/h+qYlJTk5Ga3eXIxbvCOFMk2aNIGFhQUSEhLQpUsXpcscOnRIYd7Fixcr3LamUGGnR2QtdunpXA/Y4vdo1+TgxIQYK9mXI0C9jhMA1zHJ0pIb8gSg1nFC+DR9+nRs3boVI0aMwJw5c+Di4oIHDx5g9+7d2Lp1K5ycnODs7IwtW7bAw8MDCQkJpToofPPNN/Dw8EDLli0hFAqxd+9euLu7w9HREUKhEO3bt8dXX32FunXrIi0tDZ9//nmFcdnZ2WH27NmYOXMmpFIpOnbsCJFIhOjoaNja2mLs2LGYOnUq1qxZg1mzZmHKlCmIiYnBjh07tPRKlVbtr7FbtmwZgoODYW1tDUdHxzKXSUhIQP/+/WFjYwMXFxd8/PHH8qZeTVJ2v1jG6FQsIaqQfTkC1G+xEwqBBg2KfqcWO0L44+npifPnz0MikaBXr17w9/fHjBkz4ODgAKFQCKFQiN27dyMmJgb+/v6YOXMmVq1apbANW1tbrFy5EoGBgWjTpg0eP36Mo0ePyk/Dbt++HQUFBQgMDMSMGTOwdOlSlWL78ssv8cUXX2DFihXw8/NDr1698Oeff8qv8atduzb279+PP//8Ey1atMAPP/yA5cuXa/YFKoeA8X0ymGcLFy6Eo6Mjnj59im3btpW63YdEIkHLli3h6uqKNWvWID09HWPHjsXgwYPx3XffqbwfkUgEBwcHZGRkwN7eXulyNWoAr14Bt24BTZpw81694uYDXC/zSlzaQKpI1fePaIeqr/8nnwBr1wIODlzeqHONHQAMHgwcPMg9vnMH8PWtQtBEAeUQIbpR7U/FLl68GACUNpOePHkScXFxSExMhOebLnZr1qzBuHHjsGzZMo3/g3J15Q5IW7YA3btzLQiZmUXPUVFHiHKyFruWLdUv6gDF6+zosgdCiCGq9qdiK3LhwgX4+/vLizoA6NWrF/Ly8hATE6N0vby8PIhEIoVJFbLTP99+CwwYADRtWnTbLzrQEFK+fv0Af3/ggw8qt76sZ6ybG2Blpbm4CCFEV6p9i11FUlJS5GPryDg5OcHc3BwpKSlK11uxYoW8NVAdGzcC27dzNyN/8AC4f7+oxU6Hw+AQYpD8/YGbNyu/flAQ19LXrp3mYiKEEF0yyha7RYsWQSAQlDv9+++/Km9PUMY5HcZYmfNl5s+fj4yMDPmUmJio0r7q1weWLQP27AFiYoCMDOD5cyA2lrt2iBCiPU2aAPHxXP4RQoghMsoWuw8//BDDhw8vdxlV7xfn7u6OS5cuKcx79eoVCgoKSrXkFWdhYSEfrBAoGrBQ1VOyxVlaAj4+3P0rZfewJLole9+qeV8j3lQlf9Tl5ATk53MT0RzKIUJ0wygLOxcXF7jIxg6poqCgICxbtgzJycny0a5PnjwJCwsLBAQEqLydzDfnU729vTUSF+FHZmYmHBwc+A6j2qH8MR6UQ4Rol1EWdupISEjAy5cvkZCQAIlEIh95ukGDBrC1tUVISAiaNGmC0aNHY9WqVXj58iVmz56NyZMnq9Uj1tPTE4mJibCzs5OfwhWJRPD29kZiYiJ1/9cQbb2mjDFkZmYqdKIhukP5oxvafE0phwjRjWo/jt24ceMQHh5ean5kZCS6du0KgCv+pk2bhlOnTsHKygojR47E6tWrFU61VgaN66R59JpWH/Reax69poQYvmpf2PGJ/olqHr2m1Qe915pHrykhhs8oe8USQgghhFRHVNjxyMLCAgsXLqzyKV1ShF7T6oPea82j15QQw0enYgkhhBBCjAS12BFCCCGEGAkq7AghhBBCjAQVdoQQQgghRoIKO0IIIYQQI0GFHU82btwIHx8fWFpaIiAgAGfPnuU7JIO2aNEiCAQChcnd3Z3vsIgWUQ5pDuUPIcaDCjse7NmzB2FhYViwYAGuXbuGTp06ITQ0FAkJCXyHZtCaNm2K5ORk+XTz5k2+QyJaQjmkeZQ/hBgHKux4sHbtWkycOBGTJk2Cn58f1q1bB29vb2zatInv0Ayaqakp3N3d5ZOrqyvfIREtoRzSPMofQowDFXY6lp+fj5iYGISEhCjMDwkJQXR0NE9RGYf79+/D09MTPj4+GD58OB49esR3SEQLKIe0g/KHEONAhZ2OpaWlQSKRwM3NTWG+m5sbUlJSeIrK8LVr1w47d+7EiRMnsHXrVqSkpCA4OBjp6el8h0Y0jHJI8yh/CDEepnwHUF0JBAKF3xljpeYR1YWGhsofN2vWDEFBQahfvz7Cw8Mxa9YsHiMj2kI5pDmUP4QYD2qx0zEXFxeYmJiUallITU0t1QJBKs/GxgbNmjXD/fv3+Q6FaBjlkPZR/hBiuKiw0zFzc3MEBAQgIiJCYX5ERASCg4N5isr45OXl4fbt2/Dw8OA7FKJhlEPaR/lDiOGiU7E8mDVrFkaPHo3AwEAEBQVhy5YtSEhIwNSpU/kOzWDNnj0b/fv3R+3atZGamoqlS5dCJBJh7NixfIdGtIBySLMofwgxHlTY8WDYsGFIT0/HkiVLkJycDH9/fxw9ehR16tThOzSD9fTpU4wYMQJpaWlwdXVF+/btcfHiRXpNjRTlkGZR/hBiPASMMcZ3EIQQQgghpOroGjtCCCGEECNBhR0hhBBCiJGgwo4QQgghxEhQYUcIIYQQYiSosCOEEEIIMRJU2BFCCCGEGAkq7AghhBBCjAQVdoQQQgghRoIKO0IIIYQQI0GFHSGEEEKIkaDCjhBCCCHESFBhRwghhBBiJKiwI4QQQggxElTYEUIIIYQYCSrsCCGEEEKMBBV2hBBCCCFGggo7QgghhBAjYcp3ANWFVCpFUlIS7OzsIBAI+A6HqIkxhszMTHh6ekIopO9Dukb5Y/goh/hD+WP41MofRiq0fPlyFhgYyGxtbZmrqysbMGAAu3PnjlrbSExMZABoMvApMTFRS58y4xYVFcX69evHPDw8GAB28OBBtdan/DGeiXKIsQ0bNrC6desyCwsL1rp1a3bmzBmly0ZGRpb5Ot6+fVvl/VH+GM+kSv5Qi50KoqKiMH36dLRp0waFhYVYsGABQkJCEBcXBxsbG5W2YWdnBwBITEyEvb29NsMlWiASieDt7S1/H4l6srKy0KJFC4wfPx5DhgxRe33KH8NHOcTZs2cPwsLCsHHjRnTo0AGbN29GaGgo4uLiULt2baXr3b17V+Gz7+rqqvI+KX8Mnzr5I2CMMR3EZFRevHiBmjVrIioqCp07d1ZpHZFIBAcHB2RkZMDe3h6MAZMmAd27A0OGAJaWWg6aVEnJ949UnkAgwMGDBzFw4ECV1ynr9d+zB7h8GVi6FLCy0lKwRGMohzjt2rVD69atsWnTJvk8Pz8/DBw4ECtWrCi1/OnTp9GtWze8evUKjo6OldqnOq/9n//7H2wcHdH9k08qtS+iHeq8h3ShQyVkZGQAAGrUqKF0mby8PIhEIoWpuMijadi+3Q3vvdcTTrZhCG3xNQ5/fwyFublajZ0QYyASARPHbMHatevRvMlTXLrEd0SEVCw/Px8xMTEICQlRmB8SEoLo6Ohy123VqhU8PDzQo0cPREZGlrtsRccfZVJu3MDApUsRMns2zm3cqNI6RP9QYacmxhhmzZqFjh07wt/fX+lyK1asgIODg3zy9vZWeD737l8AUgH8jVzJtzh+41MM+KgPzK0c0MSmDp7/9592/xBC9FhFByY7WykcJHMAzMCDx3XQvn0I+rVcihePnvITMCEqSEtLg0QigZubm8J8Nzc3pKSklLmOh4cHtmzZgv379+PAgQPw9fVFjx49cObMGaX7qej4o8ytEycgBSABMPLjj/Hy4UNV/zSiR6iwU9OHH36IGzdu4Lfffit3ufnz5yMjI0M+JSYmKjzfY9Jg/LtrF7aMGYf+dbvA2bQZAFsw5ON2dgI+GvqFFv8KQvRbRQemwtxcfDrgLQTYOACQAojAkev/g1v9+njLrTEe/PMPL3ETooqSPVMZY0p7q/r6+mLy5Mlo3bo1goKCsHHjRvTt2xerV69Wuv2Kjj/K3LlyRf44USLBpE6dwKRSldYl+oMKOzV89NFHOHz4MCIjI+Hl5VXushYWFrC3t1eYFJ63t0fAe+9hcvhPOBx/GmkFN5D45BXa+nDXWBy+fY5Oy5Jqq6IDk5m1NT7evx//il/jwT//YESzYTBBQzDk45/Uu+jSezjyxWKeoiekbC4uLjAxMSnVOpeamlqqFa887du3x/3795U+X9HxR5m7d+8CAHo5O8MMwMHkZGwaOVLluIh+oMJOBYwxfPjhhzhw4ABOnToFHx8frezHq7Ypdh2eBsAZeXiB7bPXaGU/hOg7dQ5M9bt3x683diMp5Q56tD0NwBVJhWn4vA8dkIh+MTc3R0BAACIiIhTmR0REIDg4WOXtXLt2DR4eHpoOD3eecpcyDO3fH1+/6dw0a88e3Ni3T+P7ItpDhZ0Kpk+fjp9//hm//vor7OzskJKSgpSUFOTk5Gh8X4387VHXvh8AYNWOQxrfPiF8EIvFiI2NRWxsLAAgPj4esbGxSEhI0Ng+aroJcfJCF/i6LwQArDl7Ag/+OaWx7ROiCbNmzcKPP/6I7du34/bt25g5cyYSEhIwdepUAFxr9ZgxY+TLr1u3DocOHcL9+/dx69YtzJ8/H/v378eHH36o8djuvOkY2Lh9e8zYvx/9atZEHoBho0YhKzVV4/sjWqLyCIfVGJQMFPjTTz+pvI2MjAwGgGVkZFS47HcL/nmzDxMWfzGmCpETTVHn/SOlKRtkdezYsSqtr87rfztOwgToxgCwZraNmFQiqWL0RBMoh4ps2LCB1alTh5mbm7PWrVuzqKgo+XNjx45lXbp0kf++cuVKVr9+fWZpacmcnJxYx44d2ZEjR9Tanyqvvfj5c3lept27xxhj7MWdO8xTKGQA2MRGjdT7I4lGqZM/NI6djqgzBk1hIWBj3h757BKGNRuB3Td+1VGURBkag4tf6r7+s8Zfwjc7OgPIx+ZJn+D9rcovNCe6QTnEH1Ve+2u//YbWI0fCVSBAarEOE6fXrUP3mTPB3jzuMmOGjqImxdE4dgbO1BTo3ZI7HfvHf1GQFhbyHBEhhmXllnZws/kYADDjx214/eQJzxERot/uvBlHz7fEnQ26hoXh3Te90i8eP67zuIj6qLDTU19v/wCAA3JZEnbO/57vcAgxKGZmwIG/vgDQCLl4jVGdx1S4DiHV2Z0bNwAAns4+KDl8XeM3HQYfPX6s46hIZVBhp6d8Wzqjjl0oAOCrzXt5joYQwxPc1Q7Dui4GABxNOItTG3bwGxAheuxOfDwA4MCTkWjQgLvV5dWr3HP1fX0BAA+fP+crPKIGKuz02MypowEAdzOvIPHaLZ6jIcTwbD8yHLam7wJgGDpjEV3WQIgSd168AAAUSpsCAA4cAAICgNBQQGzLDcXyKDOTt/iI6qiw02PTl/eBmaAlgALMn7CK73AIMTjW1sDOrcsBOCBd8gTr3/+S75AI0TvSwkLczi0AAFhaNMTx48CoUYBQCBw/Dkz/phcAIKGwEAXZ2XyGSlRAhZ0eMzUFevn3BQAcuB5Jt3YhpBIGjWuAxs7DAQBLdv5GeURICdeOXUIBJADMsWhhHfTqBfz8M3DvHjB5MmBq6gbAChIACRcv8hwtqQgVdnpu5bbpAGyQwxLwy/+28B0OIQZpy0+zAVjjleQ+Nod9y3c4hOiVeV9w19dZCmpj1mwL+fz69YEtW4A5c4QA6gEAHl66xEeIRA1U2Om5Jm084G3DNYN/tZFu60JIZXTq3wANHQcAAP73w06eoyFEf0RGAn/HpgEAglxMYGZWepnmzQFZYffo5k3dBUcqhQo7AzB2QE8AwL3Xd3iOhBDDtWnjLABmSCuIxY4FO/gOhxDe5eUB3J3M7gIAgho6l7lc8cLuwf0HOomNVB4VdgZg9Ky+AAQowDPcj6ZvS4RURo8Rgahn1xsAMG/1jzxHQwj/Vq7krqMzF3DHlcbNmpW5XKNGgImAG8vuv4Q0ncVHKocKOwPQKMAbZmgIAPjt+6M8R0OI4drwzUwAQjzPP489X//JdziE8Ob+fWD5cu6xNa4BABoHBZW5rKkpUNvNAwBw9xUNeaLvqLAzEN523ACRf5+9xnMkhBiu3hO7obZ1FwDAJ4s28BwNIfz54gvuVGz3Lml4zbghTHx79FC6fPMmXItdckEm9SzXc6Z8B6BpIpFI7XUM4YbU7Zs0xaNLf+JWyj2+QyFGzFjzp7j1Sz/EwFmReJYTgQMbzmLw9E58h0T0kLHnwqZNgIsL0M3rOE5FAZ5CIey9vJQu375rY/xxSoA85CHt7l24+vnpMFqiDqMr7BwdHSEQCFReXiAQ4N69e6hXr54Wo6q6Ae92xq+XvsLLwrvIz86FubUl3yERI2Ss+VPcgJmDUWt+WzzLu4ywT7+lwo6UydhzwdER+O47YOf7ZwAAvhUUpa3b2QGoBeApHkVHU2Gnx4yusAOAffv2oUaNGhUuxxhDnz59dBBR1Q2Y1hOYbQ9AhL82HcXgTwbzHRIxUsaYPyWt+nQyRi65jMSsw/hzx3X0H9eC75CIHqoOuXDnv/8AAI1r1Sp3uaKesU9x598baDdR66GRSjK6wq5OnTro3LkznJ3L7rZdUr169WBW1sA9esbCyhSOpk3wuvAiDu09S4Ud0QpjzZ+SRiyehJkr1uF5wS18+NEq9B/3M98hET1TXXLhzuPHAIDGvr7lLufmBlgIayNPClyMeYKxOoiNVI7RdZ6Ij49XOREB4L///oO3t7cWI9KcJu5c4l2Mu81zJMRYGXP+lLRq1mQAQIJ4Lw5sjeU3GKJ3qksu3H35EgDQODCw3OUEAsDToSYA4L8nNOSJPjO6ws6Y9ejYCgDwJJM6UBBSVe8t/wjuZk0B5OOjsK/5DocQnSvMzcX9vDwAgG/nzhUu71vbEwAQ//qlVuMiVWO0hV1WVha2bt2K8ePHIzQ0FH369MH48ePx448/Iisri+/wKmXkx30BAPmIx6MYGv2b8OP58+dYsmQJ32FUmUAoxLefTQMAJGXvw2/rr/AcEdFXT58+hVgsLjW/oKAAZ86c4SEizYg/exYFAKwAeLdrV+HyAa24IU/S8qnFTp8ZZWEXFxeHRo0aYe7cuXj16hVq164NLy8vvHr1CnPmzIGvry/i4uL4DlNtjYMawAxcYv367RGeoyHVVUpKChYvXsx3GBoxdNE01LJoBqAAM+etBmN8R0T0SXJyMtq2bYs6derA0dERY8eOVSjwXr58iW7duvEYYdXceVOU+lpZQWha8SX3Xfpwd6bIQxpyXr3WSkwvbt/G319/jcLcXK1svzowus4TADB9+nR07twZ4eHhMDc3V3guPz8f48aNw/Tp0xEZGclThJXnZdsI8eJ4RERdxed8B0OM0o0bN8p9/u7duzqKRDc2LPoYA+dPxvOcA9i5+iLGzmnPd0hET8ybNw8mJia4dOkSXr9+jfnz56Nr166IiIiAk5MTAK5HrKG6c/UqAKCxq6tKyweH1gdgByAT/x65iE7v9dZoPFmpqejYogXuFRSgweef43/jxmHk+vUwtaThvdTCjJCVlRW7deuW0udv3rzJrKysdBgRYxkZGQwAy8jIqNJ2hgXMZACYs1l7DUVGVKGp988QCAQCJhQKmUAgKDXJ5guFQp3GpO3Xv45lSwaAuVgMYVKpVnZR7RliDnl6erJLly7Jf8/NzWUDBgxgLVu2ZOnp6SwlJUXnuVAZyl77iY0aMQBsYZcuKm/LQuDHALAv31uj4SgZm9y4MQOgMDUwM2Phkyezgpwcje/PkKiTP0Z5KtbJyQn3799X+vyDBw/k37YMzcAhHQEA6QVxKMwv5DkaYoycnZ2xdetWxMfHl5oePXqEv/76i+8QNW7TsjAAQFreQWxdepbfYIjeyMjIUDhWWFhYYN++fahbty66deuG1NRUHqOrujvJyQCAxtwgdSpxseB6xsZcT9BoLIfmz8fWO3cACAAcBrASgAseFBRg7NatqGlTB9tmrdXoPo2VURZ2kydPxtixY7F69Wpcv34dKSkpeP78Oa5fv47Vq1djwoQJmDJlCt9hVsrAj/qAu9RVhCNb/uY7HGKEAgICkJSUhDp16pQ51apVy6BPP5UldNZY1LNuDUCK+UvX0rV2BAA3Nl3JSxNMTU2xd+9e1KtXD/369avUdjdu3AgfHx9YWloiICAAZ8+W/2UiKioKAQEBsLS0RL169fDDDz9Uar8l3XlzvWDjDh1UXqduDRcAwN2nKRqJAQCSY2MxaeXKN7/Nhr9/f/ToMRd2do8gK/BeSVMx6Zs5GOD/IQoL6F615dJ+AyI/vvrqK+bh4SE/bSQ7heTh4cFWrlyp83g0eRrCwaQ1A8DGBM3TQGREFYZ4GqmyDhw4wHbt2qX0+ZcvX7IdO3boMCLdvP5/b/zlzekfIVv/2Smt7ae6MsQcmjt3LgsJCSnzuYKCAvb222+rfSp29+7dzMzMjG3dupXFxcWxGTNmMBsbG/bkyZMyl3/06BGztrZmM2bMYHFxcWzr1q3MzMyM7du3T+V9lvXav7hzR366M+vFC5W3NaXThwwAszftrvI65ZEUFLAQZ+c3sbRkNjY57NGjN89JGLt1i7FN37xgntaD5fHWtBzMbl0znM+RJqiTPwLGjPu7aXx8PFJSuG8W7u7u8PHx4SUOkUgEBwcHZGRkVPlG0cG1RuBC0m40cuiPu68PayhCUh5Nvn9Efbp6/X1t2+Be1r9wNOuPl3mHocatQkkFDDGHCgsLkZ2drTReiUSCp0+fok6dOipvs127dmjdujU2bdokn+fn54eBAwdixYoVpZb/9NNPcfjwYdy+XTQw/dSpU3H9+nVcuHBBpX2W9dqf37QJHadNQ20TEzwpVP2ynvA5azBu9WwI4If8gjio0Jm2XN8OHoywgwcBWAK4im3b/DBhQunlpBIpRrb5EHuubQYghRBBWP75z5izuB6ElTz3KC0sRNrdu3j5NAXPHj1HUsIrpCS/xsuXWbC2sYZjDXs4uTrB2d0Zzp4ucKvrBvcGHrCwNq944xqmTv4YZa/Y4nx8fHgr5rSlW1ALXNi/G49FNFAxIZq0Zd1cdJ08FK8LjmDX6miMmRPMd0iER6ampuUeRE1MTNQq6vLz8xETE4N58+YpzA8JCUF0dHSZ61y4cAEhISEK83r16oVt27ahoKCgzNuY5eXlIe/NwMMAVxSUdOfSJQBAY0dHleMHgODerYDVAEM87t6Roql/5a/ourl/Pz49ePDNb2swYIAfxo8ve1mhiRC7r25E6GwfTFyzBBJcwLyl3bDz110YO6Uz+vQBmjZFuV/GHsY8wr4Nf+JU1GX89+wuUvLuQYrMSkRuCyFsYQJbmAqsIBQIIYAJhAIhhAIhTARCMMbAIAVjEu4npGBMCikkb+bJ5kveXNrCtbGxN/1GzIV2EEvuVCI2GN+p2JkzZzKxWKzy8vPmzWPp6elajIijydMQN0/FvvkUCNjj/55pIDpSEUM8jVQZ1SF/KlLHshUDwLxthml9X9WJoeWQNnLh2bNnDAA7f/68wvxly5axRo0alblOw4YN2bJlyxTmnT9/ngFgSUlJZa6zcOHCUr1LS772swMDGQD2cYsWKvx1RfKzshhgwgCwjcv/U2vdkttpZmn5Jra+zNVVwp4/V23duCNHmauJc7G/rQ4DxjEnmy1sxNu32c6djC37LJ4N6bSTNXOfxZzN+zAT1CvzNeEmWwbUYkL4MnNBALMRBjMrYSAzgx8TojYToAYDzMpZX/OTAE4Kf3O1PhVrYmKClJQUuKo4Lo+9vT1iY2NRr149rcal6dMQZgIvFOIZlk34AZ9tM8yOIIbEEE8jVUZ1yZ/y/Pa/jRi5dDoAS5zafw3dBjfW6v6qC0PLIW3kQlJSEmrVqoXo6GgEBQXJ5y9btgy7du3CnTulW2gaNWqE8ePHY/78+fJ558+fR8eOHZGcnAx3d/dS65TVYuft7a3w2qfdvYtbx4/DpW5dNB0wQKW/Uf63Cmsik73A6F77sPP4ELXWlTmxbBl6f/45gBoA4vDHH254+23V138VH49RQd1x4nkCpCjZmcIJwKsy1zODD9yt/dDcpym6h3RAyOiecPe2hqMjKjytnJkmQtL9JKTEp+J54gu8SH6FV+ki5OUVoKCgEAUFEuTnS5BfIIFAIISJqQlMTGSTKUxMTWBmZgZTMxOYmprCzNwMQhMhTEyEEAiEEAgFEL45r2xpbYH3lw6S77tan4pljKFRo0YQqHhxjKHeXszLuhEeZz/DyVMx+IzvYIjRqC75U57hi6fiwxXr8VJyFzOmrsaNwT/yHRLhgTZywcXFRV4wFpeamgo3N7cy13F3dy9zeVNTUzg7O5e5joWFBSwsLMqPxdcXXXx9K4y5LJ5WTrib/QI34p5Uan0AOPTbvjePhmDCBPWKOgBw8vHB0ZR4iFNScH7bNkT8cQR/3XyEe7mpYG+KOkdhTdSxqwN/n0Zo2z4A/Sf1hU9Ao0rHbOdiD18Xe/gG6feXPaMr7H766SckJCSgdu3aKq+jLKH0WZtGfngcG4n/nhnXXQAIv6pL/pRHIBTi0+HD8OkvS3DzxX7cifkSjQM8+A6L6Jg2csHc3BwBAQGIiIjAoEFFrTEREREYoKTVLCgoCH/++afCvJMnTyIwMLDM6+t0oaGLI+4mAI9TKzfkCZNKsf/2IwBADbue+Oabysdi6+6OXgsWoNeCBVgNQPT0Ke6fPo2GXbvC3sur8hs2ZGqeFjcIDg4ObOfOnXyHoUDT15fsWrjrzbl4Z5afJ9HINolyhnZ9UFVUh/ypSGFeHrMSeDMArFuDMJ3s09gZYg5pIxdkw51s27aNxcXFsbCwMGZjY8MeP37MGOOu1Rs9erR8edlwJzNnzmRxcXFs27ZtGhnupCoW9uj35vgzir1+rf76t/744836Fmxu2EuNxGTsqv2dJ5YvX47p06djyJAhSE9P5zscrRg8420AFgDSsf+7f/gOhxiR6pA/FTExN8fEroMBAKcf7EVakriCNYgx0kYuDBs2DOvWrcOSJUvQsmVLnDlzBkePHpX3rk1OTkZCQtFdHXx8fHD06FGcPn0aLVu2xJdffon169djyJDKXdumCU2bN3zz6BFu3lR//d3rt7151B3jpxjmXaD0mg4KTV48evSIdevWjbm5ubE//viD73C08m21phnXq6mX7wyNbZOUzRBbG6qiOuRPRbLSXzETuDIAbHi7L3S2X2NlqDmkb7lQGZp+7WN+/vlNi1tNtnGj+uvXt+R6qHo7rtBIPNWBOu+h0V1jJ+Pj44NTp07h+++/x5AhQ+Dn5wfTEl1erl69ylN0mtGlSWvsvf4vLj78l+9QiJGpDvlTEesajhjo3w/7//sJ+y7txo6c/8HCymj/ZRIlKBdKq9ex45tHqYi5+Ar4QPVWt5cPH+Jh7mMAwJhRvTUfHDG+zhPFPXnyBPv370eNGjUwYMCAUslo6N7/sD/2Tt6CjMIYJD18Cc/6NfgOiRgRTefPxo0bsWrVKiQnJ6Np06ZYt24dOnXqpKFoteP7fQtxoPFeFOIeFozcgNUHZ/AdEuGBsR9L1OVYpw5sYQEx8nDuzAMAbVRed+eiDQCkAPwx7bOWWoqwmtNBCyIvtmzZwuzs7NigQYNYamoq3+Fo5TSEVCJhpnBjANhnwzdobLukNEM9jVRZms4fde+PWRKfr3/HWu8wAMxGGMCkUp3v3mgYag7p27GkMrTx2re0sn9zOvYge9PvQyXNHTswAKyO/RSNxVIdVPvOE71798ann36K77//HgcOHFB5gElDIxAK0dixFQDgj4izPEdDjIU28mft2rWYOHEiJk2aBD8/P6xbtw7e3t4K98vUV5t2fgbAHFnSGCybuJXvcIgOVZdjSWX4uji8efQIhw6ptk5BTi7+e/0fAGBE/85aiYsARlnYSSQS3LhxA2PGjOE7FK0b0L09AOBuegyM6x4ihC+azh/Z/TFL3u+yvPtj5uXlQSQSKUx88e/eCq1duWuBlu5Yh7zsfN5iIbpVnY4l6qonHyPuIeS3e63AzkW/QIoMADUwe81gbYVW7RllYRcREQGvajIw4bQvxwAQohD38c9vMXyHQ4yApvMnLS0NEomk1OCtbm5upUbUl1mxYgUcHBzkk7e3t8biqYy9R1dBAHvksTi833MRr7Hou+T7SVj34VYc+eEE36FUWXU6lqirfiPZHRzu4+xZ4MWLitfZvJMbmqu2dRs4u1lqL7hqzigLu+rEs4kPHE2aAAA2r93PczSEKFfy1kyMMaW3a5o/fz4yMjLkU2Jioi5CVKpeYCO83XQEAODn6O1IeVi5EfeNTXZGNnYt/h3DA2aioX0oLIUN4dnICzM3vI+Fi7bzHR7RosA+fQAAApyFVJqDEjfHKEUiAa6lcI0P73Rtr+3wqrXq3bXHSLT3aYnjD/7Dmf+u8B0KIaVU5v6YqtzrUtd2nf4aNVyPoRAJGN7jU5x+HM53SDpXmF+Ig98ewc/hJ3Dhfixe5N8AUPoeqSaoBWsLapExZs3feQfeJiZIlOQCiMTBg30wYYLy5Xevv4RC3ANggjlrxuoqzGqJWuyMwLixvQAAqXlXkJGey3M0hCgqfn/M4iIiIhAcHMxTVOqzc7HHx/2mAgCinuzF1WPVY/zIpHtJmNn3S9S16QlzCw8MnTsQh29twov8CwCyIIATXMyC0NF7NP43bA1uRP6HQvYUZ55Uv8K3OhEIhejXuPGb3/5ERASQmal8+e/XHwYAuJs1hntjH+0HWI1RYWcEhswZCiEcAWRg6xf7+A6HkFJmzZqFH3/8Edu3b8ft27cxc+ZMJCQkYOrUqXyHppZVhz6FrbA1gByMGP4Z3+Fozd2L9zCh03y4WXRCLd96WHf0CzzJ/hsMaQBs4GoejP5NpmH3ykPIz0vFi/xonE3YiSW7Z6FZ16Z8h090pN+77wIATPAH8vIYjh8ve7ncXODKk8sAgIGtm+sqvGqLCjsjYGphjro2LQEAvx86xW8whJShovtjGgqhiRBrPv0UAHBPFIF9K3/nOSLNeZ3yGjNCl6CmRQc0DmqCn859hdT8cwDyYIa6aOcxAt/N2I7M9BSk5p3H4VsbMGzuAJia0xU91VX3GTNgDUCCZACxSnvH7v35BSTsDADgw89G6iy+6krAGA2SoQsikQgODg7IyMiAvb29xrf/0Vtz8f0/q2AhaIFcaazGt1/dafv9I+XTt9ff26YPnmYfg7NpS7zIi4FAaJjfkaUSKX787Fes27IXt1+fBlA0rIylwA9Bddvj47B38fb0XhCaVO1v1Lf3sDrR5ms/0MMDf6SkAFgMe/sv8OIFYG5e9Pzr10CjurvxImMEHIUueFnw3GDzhU/qvIf06hqJ6V9wPfby2A38+/d9nqMhxLjt3L4EgCXSC2OxaOhivsNR25MbTzC4xcewMm2EKV+Pxu3XhwGIYIJa6OA1Gie2n0KONA6nHm3HwI9Dq1zUEePVvxd3jbeZ4BBEIuBUsZNGjAETJgAvMriW7WFN6lBRpwP0ChuJxp1bwUbYEADDxqV7+A6HEKPWbVggWrtzX6aW7F+FQ6t+5Tki1exZeQh+jv1Rt0UTHLzxHfLxEIA16tn2xuopPyA37zHOJe5EyPhufIdKDETfWbMAAAXsGoBkhdOx338PHDwYB4Cb+fGyL3QfYDVEhZ0Rae3JXZT695VLPEdCiPE7EbMetiYdAOTgnbkf4fKB03yHVKbsjGzMCF0Me5OWGD5vEO5k/AUgGxaChhgeMBPP7t7Hw8xj+OSHKXS9HFGbe/PmaGtj8+a3I/jjD27MupgYYPZsAFgJABjk4YEmb7/NV5jVChV2ati4cSN8fHxgaWmJgIAAnD2rX/dnHTmkOwDgafYV5OVKeY6GEOPm4mmLmMt7YS7whwQv0fmdMXgcc5vvsOQexjxCqO9k2DvWx/rji5ApvQ7AFLWt38J3M7Yju+AOfvt3LTwbefIdKjFw/dq1AwCYCg7i+XPg5Elg6FAgP/8xBPgZADB/xQo+Q6xWqLBT0Z49exAWFoYFCxbg2rVr6NSpE0JDQ5GQkMB3aHJjF70HwBoMz7FrxZFKb+ffQ6ex4aPv8XHP+ejXeAJauQ6El1VXNLDrjaGtZ2DHF3sgShNrLnBCDFSj1h6I2P8rhPBGHktEq3ZDkJGUymtMR344gaY1BqBBoD+O3/sREqRAABd0rTsO1/+5hidZEfhw3Xi6bo5oTP/33wcAMPYPgBy8+y7w6BFgZ/YlGKR4q0YNtBlLgxLrCvWKVVG7du3QunVrbNq0ST7Pz88PAwcOxAoVvonoqkeYl2V7PMu7BCezPnjy4g/YOah+auVmxBW8PXAWHmefU2Fpc1gLG8PHsRGaN6iPjp2bo++4rqjTtPLf/vOycvHiSSpePH2JrIxsMCmDVMogkUjBpNzH1MLKHOaW5jC3NIO5/LFp0WMrbjI1N1V64GJSKaSSogngegcyBoV51g7W8lNT1KOPX/r++v+2+h+MnDMUwEt4W7bDw5enYWaluzsvFOYXYum49fh+3+9ILyi6FMNS4IfRnQdj9d65sHfl93XT9/fQmGn7tWdSKeqYmyNRIgFwBEAfmJikwFRSC3mQ4p/Vq9H9k080vt/qRJ33kC6oUEF+fj5iYmIwb948hfkhISGIjo4uc528vDzk5eXJfxeJRGUup2mrPx2PEUti8KrgKAJ8puBO2jZU1AmpICcXEzrNwC8xv4AhC4AJTFEf1ibOcLKsgZr2TvBydUb669eIS76H9II7YHiFbOkN3Hp5A7cuA79dBqavBkzgBSezOrA1t4Op0AQmQhOYCoUwNTGFRCpBVl4WsguykSPJQr40G4UsCxJkgyEbgH7dNWP1lB/wyQ9T+A6DGIARs3sg4dF3mLdpIhJzL6GFeyjO3fgFNepo9zRn4q0EzBixEn/dPIICPHkzVwh3i074dNJ7+PjbCdQyR7ROdheKTbduwURwCBLWB128PsKpJ1K0s7FBt5kz+Q6xemGkQs+ePWMA2Pnz5xXmL1u2jDVq1KjMdRYuXMgAlJoyMjK0Hu/8vmHy/b3VeH65y+776hdmJ2wkX95K2Ir9tOTPcteRFErY6Z8j2cchn7M2bkOYq1k7ZgK3Mv/eyk1CBlgywIoBNgywZYDdm8maAeZvltHU/sqeVk/5Qf43Z2Rk6Oz9I6UZyus/tdda+WfTFG5s0dDFTCqRaHQfBXkF7JvpW1h9215v8kH2mXVggW7D2Jk90Rrdn6YYyntojHTx2h9dvJgBYC5Ca7Zy0TNm/+ZzeWh++ccgohp13kM6FauCpKQk1KpVC9HR0QgKCpLPX7ZsGXbt2oU7d+6UWqesFjtvb2+dnYZ4p+lw7I/bA0CIaaFrseHoDIXnLx04i/cnLcWNVxHg8s8RA1pMxe7oL2FpXbmG3MexD3FsVxTOn/0PoqxsFBQUokAiRUGhBIWSQggEAjja2qGGoz2ca9jD1c0Jrm5OqFnLCc7ujnD1ckHNOi5wqGmvUiuDVCJFrjgXhfmFyM/JR35uPgpyC5CfW4DCgkL5MjJMyiAQCiA0EUIgFEIoFEJoIpTvS2giAAAIBNwyrrVdYGnLnU6j00j8MqTXf97wrVi1ZwWkiAcAeFq0w4HfVqPdoI5V2u6ZPRfwxadbcP7JPyhEony+uaAhBge8jXV75sKtXs0q7UObDOk9NDa6eO1zX7+Gs5MTsgG86+WFvU+foqmFBW6IxRCa0snBqlLrPdR6mWkE8vLymImJCTtw4IDC/I8//ph17txZpW3o+tuqVCJhrZ3fevNN3op9N3svY4yxvzYdZw3sejLARP5N38OqL7t45JZO4jJU1NrAL0N7/Z89SGeBHhMYYCbPwZ71x7LD3x9hBXkFqm3jXjJbOPJb1rrmMGYpaFyiRdmO+Tr0Zz/M3cUkhZptEdQWQ3sPjYmuXvsB7u4Kn9NdU6dqdX/VCbXYaUG7du0QEBCAjRs3yuc1adIEAwYM0KvOE8XlZ2WjrnMXJOf9CwFc4G7ZAsm5p8DlHOBo2hHzJn+AuRtGQiDQSUgGi1ob+GWor//+9X9j/KzPkCm5UmyuPZxMm6Cxmy86tW8Fc3MzJCen4UXaK7wUifBKLEJCxiNkSm4CKCi2ngA1TNtgWJfeWLL9I7jUdtHxX1M1hvoeGgNdvfbbxo3DpPBwAEBdU1Pcz8yEqaXuOhEZM2qx04Ldu3czMzMztm3bNhYXF8fCwsKYjY0Ne/z4sUrr8/Vt9UX8M2Yj9FX4FuVu0YX9+PlencZh6Ki1gV+G/PoXFkjYxC5fMHuTNiWuiat4MkUt1tihD5vRexGLO2vYreqG/B4aOl299snXr8s/uxuHD9fqvqobdd5DOvGtomHDhiE9PR1LlixBcnIy/P39cfToUdSpU4fv0MrlUtcTl/7Zg+4hk2BvYY/VS2dgwAwa/ZsQXTExFeLH04vxIxYjV5yLwxuP4c/9Z3H5zn9IzHwEIUxgaWIHW3Nb2FnYwcnWDvW9PTHho7fRcWhHurcmMRjuzZvjs+Bg3E9IwPhiQ4MR3aJTsTpCpyEMG71//KLX3/DRe8gfeu0NH41jp4dk9bOuxrMjmiV73+h7ED8ofwwf5RB/KH8Mnzr5Q4WdjmRmZgIAvL29eY6EVEVmZiYcHBz4DqPaofwxHpRDukf5YzxUyR86FasjUqkUSUlJsLOzg+BNF1TZ2HaJiYnUPK4h2npNGWPIzMyEp6cnhHTNk85R/uiGNl9TyiH+lJU/AOWQNujDMYha7HREKBTCy8urzOfs7e0pqTRMG68ptTLwh/JHt7T1mlIO8aO8/AEoh7SBz2MQfW0ihBBCCDESVNgRQgghhBgJKux4ZGFhgYULF8LCwoLvUIwGvabVB73XmkevafVC77fm6cNrSp0nCCGEEEKMBLXYEUIIIYQYCSrsCCGEEEKMBBV2hBBCCCFGggo7QgghhBAjQYUdTzZu3AgfHx9YWloiICAAZ8+e5Tskg7Zo0SIIBAKFyd3dne+wiBZRDmkO5U/1Q/mjOfqWP1TY8WDPnj0ICwvDggULcO3aNXTq1AmhoaFISEjgOzSD1rRpUyQnJ8unmzdv8h0S0RLKIc2j/Kk+KH80T5/yhwo7HqxduxYTJ07EpEmT4Ofnh3Xr1sHb2xubNm3iOzSDZmpqCnd3d/nk6urKd0hESyiHNI/yp/qg/NE8fcofKux0LD8/HzExMQgJCVGYHxISgujoaJ6iMg7379+Hp6cnfHx8MHz4cDx69IjvkIgWUA5pB+VP9UD5ox36lD9U2OlYWloaJBIJ3NzcFOa7ubkhJSWFp6gMX7t27bBz506cOHECW7duRUpKCoKDg5Gens53aETDKIc0j/Kn+qD80Tx9yx9TXvZKIBAIFH5njJWaR1QXGhoqf9ysWTMEBQWhfv36CA8Px6xZs3iMjGgL5ZDmUP5UP5Q/mqNv+UMtdjrm4uICExOTUt+MUlNTS32DIpVnY2ODZs2a4f79+3yHQjSMckj7KH+MF+WP9vGdP1TY6Zi5uTkCAgIQERGhMD8iIgLBwcE8RWV88vLycPv2bXh4ePAdCtEwyiHto/wxXpQ/2sd3/tCpWB7MmjULo0ePRmBgIIKCgrBlyxYkJCRg6tSpfIdmsGbPno3+/fujdu3aSE1NxdKlSyESiTB27Fi+QyNaQDmkWZQ/1Qvlj2bpW/5QYceDYcOGIT09HUuWLEFycjL8/f1x9OhR1KlTh+/QDNbTp08xYsQIpKWlwdXVFe3bt8fFixfpNTVSlEOaRflTvVD+aJa+5Y+AMcZ42TMhhBBCCNEousaOEEIIIcRIUGFHCCGEEGIkqLAjhBBCCDESVNgRQgghhBgJKuwIIYQQQowEFXaEEEIIIUaCCjtCCCGEECNBhR0hhBBCiJGgwo4QQgghxEhQYUcIIYQQYiSosCOEEEIIMRJU2BFCCCGEGAkq7AghhBBCjAQVdoQQQgghRoIKO0IIIYQQI0GFHSGEEEKIkaDCjhBCCCHESJjyHUB1IZVKkZSUBDs7OwgEAr7DIWpijCEzMxOenp4QCun7kK5R/hg+yiH+UP4YPnXyhwo7HUlKSoK3tzffYZAqSkxMhJeXF99hVDuUP8aDckj3KH+Mhyr5Q4WdjtjZ2QHg3hR7e3ueoyHqEolE8Pb2lr+PRLcofwwf5RB/KH8Mnzr5Q4Wdjsiav+3t7ctNrPBwbtq1C6hVS1fREVXRaQx+qJo/jx4Bo0YB8+YBAwboKjqiDsoh3VM1fxgDxowB7O2B778H6K3SP6rkD13ooGe+/x6IjASWLeM7EkIMz759wMWLwLRpQF4e39EQYlgePwZ+/hnYuBE4e5bvaEhlUWGnZ1JTuZ8//VT0mBCiGlnOJCUBv/7KbyyEGJrix5zVq/mLg1QNFXZ65sUL7mduLrB+Pb+xEGJoZPkDAKtWAVIpf7EQYmiK58+ffwJ37/IXC6k8Kuz0SFYWkJNT9PuGDUBmJn/xEGJoih+Ybt8GjhzhLxZCDE3x/AGAtWv5iYNUDRV2ekSWVJaWQKNGwOvXwJYtvIZEiEGR5ZC/P/dz1Sr+YiHE0Mjyp2FD7ufOnXRJkCGiwk6PyBLI1RWYM4d7/M03QH4+fzERYkhkObRkCWBmxl0AfuECvzERYihk+dO/P9CmDXdJ0MaN/MZE1EeFnR6RfVtydQVGjwY8PIBnz4BffuE3LkIMhSyHWrTgcgigVjtCVFX8GDR7Nvd4wwbFS4SI/qPCTo8UTyoLC2DmTO73r7+mi8AJqUjxa1SLH5gOHaKLwAlRhewYVLMmMHgwUKcOkJbGnZIlhoMKOz1SPKkAYMoUwMEBuHOH66FECFFOlj8WFoCtLeDnB7z9Njfo6po1/MZGiCEo3rhgagqEhXG/r11LjQuGhAo7PVI8qQBu9O8PPuAer1zJHaAIIWUrnj+ywdnnzuV+hocDKSn8xEWIoSh5DJo4kWtcuHcP+Osv/uIi6qHCTo+UTCoAmDGDa4G4cAE4d46fuAgxBGXlT4cOQHAw1wGJxoUkpHwlc8jOjjtzBFCrtyGhwk6PlHVgcncHxo7lHm/YoPuYCDEUZeUPUNRqt3Ej9TAnRJnsbG4CFHPo44+507JnzgAxMfzERtRDhZ0eUXZgGjWK+0ktdoQopyx/+vcHatQAMjKAGzd0HxchhkCWP+bmXEudTK1awIAB3ONjx3QfF1EfFXZ6pPg4dsUFBAAmJtzQJ8+e6T4uQgxByc5HMkIh0LYt9/jSJd3GRIihKOsaVZnOnbmfFy/qNiZSOVTY6RFlLQ42NkUj6V++rNuYCDEUyvIHKCrsKH8IKVt5+dO+Pffz4kXqxGcIqLDTEzk53DhcQPkHJmpxIKRsylq8AaBdO+4n5Q8hZZPlT8kWbwBo2ZLrxJeeDjx8qNOwSCVQYacnZN+WzMy4YU5Kkh2YqMWBkLKp0mJ39y7w6pXuYiLEUJSXP+bmQOvW3GM6Hav/qLDTE+Vd3wAUHZiuXAEkEt3FRYihKO/A5OIC1K/PPb5yRXcxEWIoyssfQPF0LNFvVNjpCWUXfss0acJdaycWc3eiIIQoqujARKdjCVGOCjvjYarqgusrMbrn+PHjYVe83zRRqqKkMjEBAgOBqCjuwNS0adX3efMmN4RKixZcM7ulZdW3ScpG+aNdubnclx5AeQ61bQv8+qvmCruMDGD7dqBePW4gZBcXzWyXVA7lWNWoWthdv86Nd2dtXfV9yjpilHWWilSeyoVdWFgYvLy8YGJiotLyiYmJ6NevHyWNiipKKoBrcYiK4q6zmzChavtLSwO6d+d+Aty1fS1acPto354bt4jeOs2h/NGu4teoOjiUvUzx61QZq/rBZOJEYP/+ot8bNwY6dgQ6dQJ69QLc3Kq2faIeyrGqqegY5O0NeHgAycnA1avcZ70qnj7lcuXZM8DZmftiJPvZsCEwZw43/iSpBKYigUDAnj9/rurizNbWlj18+FDl5VW1YcMGVrduXWZhYcFat27Nzpw5U+7yp0+fZq1bt2YWFhbMx8eHbdq0qdQy+/btY35+fszc3Jz5+fmxAwcOVHm/JWVkZDAALCMjo8znP/2UMYCxGTOUb2PfPm6Zli3V2nWZxozhtlWzJjdxh7qiydOTsV9/ZUwqrfq+jEFF719FKH+0mz8xMdzn1sND+TZychgzM+OWe/RIrd2X8scf3HZMTBhr0qR0/lhbM7ZkCWPZ2VXbjzGpag5VRF9yjDH+8kwZVV77evW4z+65c8q3M2gQt8yqVSrvukwSCWM9epTOm+KTlxdjp09XbT/GRJ38UbmwW7RoEcvKylI5iOXLl7NXr16pvLwqdu/ezczMzNjWrVtZXFwcmzFjBrOxsWFPnjwpc/lHjx4xa2trNmPGDBYXF8e2bt3KzMzM2L59++TLREdHMxMTE7Z8+XJ2+/Zttnz5cmZqasouXrxY6f2WpaI3ZcIE7sO8dKnybSQmFh1M1HgrSjlxgtuOQMDYhQtc8RYfz9ju3YzNnMmYj09RcnXtyth//1V+X8aiqgclyh/t5s/x49zntUWL8rfTpg233G+/qbzrUkQi7qADMDZvHjcvLY2xw4cZmzuX++Ily5/atRn7/Xf6gsSY9gs7fcgxxvjLs/Ko8trb2XGf2bt3lW9n5UpumcGDVdqtUqtXF30BOn+esatXGTt5ksvL9esZa9So6Bj1+eeM5edXbX/GQCuFnT5o27Ytmzp1qsK8xo0bs3my/64lzJ07lzVu3Fhh3pQpU1j79u3lvw8dOpT17t1bYZlevXqx4cOHV3q/ZanoTenfn/sgb96sfBtSKdciATB29qzKu1YgFjNWty63jY8/LnuZnBzGvvySMSurokJy1izGtPT/2CBo+6CkC8acP7t2cZ/Vt94qfzsffsgtFxam8q5L+fhjbhv16pXdIieVcl+SvL2LCrxOnbiDV3VmDDmkCr7yrDwVvfa5uUWf1ZcvlW8nKqqoZbyyX1ZiYxkzNy//eJeZWdTYATDWvj1jWmpcNRjq5I/K19iVJJFIkJaWBoFAAGdnZ5Wva6is/Px8xMTEYN68eQrzQ0JCEB0dXeY6Fy5cQEhIiMK8Xr16Ydu2bSgoKICZmRkuXLiAmTNnllpm3bp1ld6vKhhjyJbdcRlASgr3086uaKDisgQEAH/9xd2QuVUr9ff72WfA48fc/f/mz1e+r5kzgSFDgE8/Bf78E1i7FggPBz76CHj//bLH2iuPRAIkJXGDWz56VPTz6VOut6+jIzc5OXE/ray4DiPFJ1NTroOHpSX3vOyxRMLd3L2ggPspeyyVcs8xVvS4rKnkSOqy30eNskbdusZxVa+x58/Tp9xPJ6fy86dFC+5ndHT5yynz77+A7Br9b77hPldlbadfP+4a1m+/BdasAc6e5ToovfMOMG8edz2eunJyuLy5fx948AC4d69osNgaNbjrk5yducf29tyt1IRC7lpC2WMLCy53rK25n1ZW3Py8PG7Kzy/6KZVykyx/ZJNEAhQWFuWPVMrFIMsb2c+mTYG+fa0hqEZXxvOVZ5VRPIdkt6o0MeGuU1WWG35+3OclOZn7/Hl5qbfPnBxg+HDu89W3LzByZNn7Egi4POvShTvmXLzI5e6sWdw66u5XKuWOe0lJ3HXlxSexmBunr+Rkbc1NNjZFP83Ni45FxY9NZR1XZDlSWFg0FT/mFM8noOgktOyxpSUweXLl8kftwu7gwYNYvXo1/v33XxQWFnIbMTVFYGAg5syZg4EDB6odhCrS0tIgkUjgVuKKZDc3N6TIqqISUlJSyly+sLAQaWlp8PDwULqMbJuV2S8A5OXlIS8vT/67SCRSeD47Oxu2tral1hs5UukmFSxYwE2V9ewZdyGsOtLTgUWLuKk6aNlSjLp1bXS2v9u3b6Nv37549OiRxrddXfJn715uqsjly0AZq6tFdmN0dezbx03VhVgsho2N7nIIAK5fv44///wTNWrUwNChQ+FSrLuySCRCWFgYtm/frpV985VnJVWUP0DZOSSRqN5prjJfToo7ckS9DnpiMbBkCTdVF6NGVS5/1BrHbvPmzRg+fDiaN2+OPXv24Ny5czh79iz27NmD5s2bY/jw4di6davaQaijZPXKGCu3oi1r+ZLzVdmmuvtdsWIFHBwc5JO3t7fSZYl+0nWvxvz8fDx58kSr+6D8Icbs5MmTaNu2LXbv3o2VK1fCz88PkZGR8udzcnIQHh6u9Tj4yjMZyp/qTa0Wu1WrVmHjxo2YOHFiqecGDhyINm3aYNmyZZg8ebLGApRxcXGBiYlJqW8oqamppb7JyLi7u5e5vKmpKZydnctdRrbNyuwXAObPn49Zs2bJfxeJRArJZW1tDfGbgbfy8rhTKACQkFB+F2+RCPD05B4/fKh68bF2LfDFF9ypqpgY5QMhV0QiAf74A/j6a+C//0o/X7Mm11xfvz5QuzbXZF67Njd5eHDN1obCWhMDNRVT/PNQlhey8Qa0wJjzBwCGDgWOHuVOfZbx70nBgAHAP/9wOfH+++UvKxMfD7Rpw42Xt3kzMGqUauuV5fp1YPlyrsWiJAsL7hRm48Zc7nh6cpdN1KrFPXZ2NqwxvzSdQxVZtGgRZs+ejWXLloExhtWrV+Ptt9/G3r170bt3b63vn688K6mi/AEUc+i334DJk4GuXblLfcojW7ZdOy6PVPHiBbd8aiowdSqwerVq65Xl0SNuPMpffgESE8text6ey6OWLbmpRQvA15c7zWxIKps/ahV2z549Q8dyBq8JDg5GUlJSpQKpiLm5OQICAhAREYFBgwbJ50dERGCAknMiQUFB+PPPPxXmnTx5EoGBgTB78w4HBQUhIiJC4fqFkydPIjg4uNL7BQALCwtYWFgofV4gEMibWF+/5uaZmnL/wIXltKPa2HB3oYiLA27d4gZHrUh8PHcgAbjrgnx8Kl6nPKNHcwe2v/4CTp/mtufvz03ljcNX3X377bdo2bIl7JVcoFi8UNE0Y84foOj+r15eXI6Up0MH7oAUG1vxsgB3vcucOVxR1707d1CrSnEVHMzlztWrwI8/cqejZAeghg25/wOkcm7duoVdu3YB4D4jc+bMgZeXF9555x389ttvaCu7N6OW8JVnJVWUP4BiDmVmcvPc3SvOiS5duJ+xsVyhZG5e/vIAd51caipXbK1dy13bWVnNmgErVgDLlnHXrj59yh13ZJOLCw22r1av2ICAADZr1iylz8+aNYsFBASos0m1yLqRb9u2jcXFxbGwsDBmY2PDHj9+zBhjbN68eWz06NHy5WXdyGfOnMni4uLYtm3bSnUjP3/+PDMxMWFfffUVu337Nvvqq6+UDtegbL+qKK9Hy7Vr3GWT7u6qbWvcOG75zz9XbfmhQ7nlu3WjYRcqSxM9+nx9fdmuXbuUPn/t2jUmFAorvf2KGGv+MMZYgwbcZ1yV4fH++otb1tdXtX3Lljc3Z+zePZVDJiXoolesq6sr+/fff0vN3717N7O2tmabNm3Sao7J9sVHnpWnotd+/nzuM/7RRxVvSyplrEYNbvnLlyte/s4dxoRCbvkLF1QKl5RBa8OdnD59mtnY2LAmTZqwsLAwtmLFCvbVV1+xsLAw1rRpU2Zra6v2wKPq2rBhA6tTpw4zNzdnrVu3ZlFRUfLnxo4dy7p06VIq5latWjFzc3NWt27dMgd+3Lt3L/P19WVmZmascePGbP/+/WrtVxXlvSmyceWaNVNtW5s2ccv37FnxsufPF40HdP26WiGTYjRxUBo5ciQLK2ecjdjYWCYQCCq9fVUYY/4wxpiDA/c5v3274m2lpqo2tANj3PhZvr7csnPmqBUyKUEXhV3Pnj3ZKiWj5/7666/MzMxM64UdY/zlmTIVvfaTJnGf8SVLVNtenz7c8uvXV7zssGHcsv37qxwuKYNWx7GLj49nc+fOZZ07d2aNGjVijRo1Yp07d2affvopi4+Pr0y81UJ5b8rPP3Mf/O7dVduWbJR9R0duBG9lpFLG2rXjlp04sZKBE8aYZg5KycnJarVSkSLlvf55eUWFWnq6atuTjbJ/4kT5y61fzy3n6srY69eVCJzI6aKwO3DgQLlfnn799VfWtWtXre1fX1X02g8YwH3Oy6gny7RkCbf8yJHlLxcbW5SbsbHqxUwUaXUcu7p162LlypVVPwdM5FS5T2xxzZpx1xC8fs2NaeXrW/Zye/ZwNzy3sQG+/FIjoZIqcHd35zsEoyS737GJCTcGoirateMuwr50CSgxhJjcq1dFQ/ssWaL8HrREfwwaNEjh2raSRowYgREjRugwIsOg7jGofXvu58WL5S/3v/9xP4cNKxpDkmifWsOdEO1QN6nMzLjBTgHuwFSW3FxuIFSAG2RY3THrCDEUsvxxcSm/41Fx7dpxPy9fVr7MkiXAy5fcBd+TJlUtRkL0mSyHVB0toW1brgPRo0dcp4iyXLzIDW4vFAKLF2smTqIalQu7GjVqIE321VgFtWvX1vqYXMZC3cIOqPjA9O23wJMnXC/bTz6pWnyk6ih/tEd2YFEnf2SdIy9dKn3nEYAbVf/777nHa9dST1VDQDlWeermkIMDN6wVoLxx4fPPuZ9jxyo/q0S0Q+V/V69fv8axY8fgoOL5iPT0dEhk98og5apMYVf8wFTW9mTDmyxfzt0OhfCL8kd7KpM/rVpxLd8vXnC3Gio5BNCcOdwtgPr0UX6qlugXyrHKyc8HMjK4x+rkUPv23LBb0dFA//6Kz0VGckMKmZlx46cS3VLre+jYsWO1FUe1VpUWu2vXgPfe4+6716sXN7jxokXcQMatW3PPEf1A+aMdlckfS0vump9//wXefZe7L3Lfvtz1q5GRwOHD3DV7a9ZoJ2aiHZRj6it+jaqTk+rrtW8PbN/ODVZ/9y7w8cdFY9zJbnf5/vtA3boaDZeoQOXCTiqV4v79+2jYsKE246mWKnNgqluXGwn/yhVuBO5ffuGuZQgKKrqgde1a1a85ItpF+aM9lckfgBtk+99/uTuxxMQAn33GDXAsOzU7bVrV74dJdIdyrHJk+ePsrN7x4p13gP37gRMngIMHualZM6BHD+DCBW4Q4qrcz5xUnlqHfV9fX3h7e2Ps2LHYsWMHXZ+gIbLrG9S5zZdAwDWBnznDdY7w9wekUuD8ee62XwMHFn17IvqB8kc7KlvYhYVxp2E3bgT69eMORE+fAs+ecS0XCxdqOlKibZRj6qts/jg5AcePc7eWnDqVu+Tn5k1g3Tru+Q8/pE57fFHrVGxUVBSioqJw+vRpTJ8+Hbm5uahduza6d++Obt26oVu3bqhVq5a2YjVKBQVFtxRTN7FMTYFOnbjpq6+4zhJHjwJ37gDz52s8VFJFlD/aUdkDEwDUqQN88AE35eRwt8iLigJ69y66fzMxHJRj6qtK/gBcr/FNm7jrubdv574omZhwDQ6EHwLGyuoTVrGCggJcuHABp0+fxunTp3Hx4kXk5eWhQYMGuHv3rqbjNHgikQgODg7IyMhQuFdocjJ3c2+hkCvy6NSpflL2/lUW5Y96ynv9O3UCzp0Dfv+du16O6CdN51BFKMeKlPfar18PzJjB5c7vv/MUIKmQOvlT6U78ZmZm6Ny5M9q0aYOgoCCcOHECW7duxYMHDyq7yWqpstc3EMNG+aM56o7BRaoHyjHV/L+9e49p6m7jAP7tC6IIUm5KQRQJTmawU3EJ6CKX7B1i4tSYZYqEaaaL/uEthkWJ20A3r9vQZBc3d9EtMYuLweRdtujIBFFBRNQNN+dgoqiUoYBAcFy0z/uHoZMVpVdOe/r9JCfaHz2nT0/55jw9/Hpq7xk7cj1WN3adnZ0oLS1FUVERiouLUVFRgejoaCQnJ2Pv3r1I5sQuqzBUnoX5cTxmiB7FjFmHb4zUx6rGLjk5GRUVFYiJiUFSUhJWr16N5ORkhIWFOas+1eNByXMwP453//7Db4cAmCFixmzBY5D6WNXYlZaWIjw8HKmpqUhJSUFSUhJCQ0OdVZtHYKg8B/PjeL3X4NJoHl7DkTwbM2Y9W765hVybVbO67t69i3379mH48OHYuXMnRo8eDb1ej1WrVuHw4cO43dulkMXY2HkO5sfxHp2j6uWlbC2kPGbMejwGqY9VZ+z8/PyQnp6O9PR0AEB7eztOnTqFoqIi7Nq1C5mZmXjqqadw6dIlpxSrRgyV52B+HI/5oUcxY9ZjhtTHrs9h+vn5ITg4GMHBwQgKCoK3tzcuX77sqNo8Ak+Dey7mx348KNGTMGNPxjmq6mTVGTuj0Yhz586huLgYRUVFOH36NDo6OjB69Gikpqbio48+QmpqqrNqVSV+IslzMD+Ox8aOHsWMWaep6eG/Gg0vyK0mVjV2gYGB6OjoQHh4OFJSUpCfn4/U1FTExMQ4qz7V44HJczA/jsf80KOYMev05ic4mHNU1cSqxu7dd99FamoqJkyY4Kx6PA4PTJ6D+XE8nvGmRzFj1uHxR52sauxWrFjhrDo80oMHnN/gSZgfx+OBiR7FjFmHb4zUiV9ipaCmJqD3m3o5v4HIemzsiGzH/KgTGzsFPTq/wdvmb+0l8lw8MBHZjvlRJzZ2CmKoiOzDywUR2Y75USc2dgpiqIhs9+DBP5drYIaIrMeTC+rExk5BDBWR7ZqbOUeVyB48BqkTGzsFMVREtuvNT1AQMGSIsrUQuSMeg9SJjZ2C+FFzItvxoERkH2ZIndjYKYihIrId3xgR2c5o/GeOKjOkLmzsFMTGjsh2zA+R7ZqbHzZ3AOeoqg0bOwXxwERkO+aHyHaco6pebOwUxAMTke2YHyLbMT/qxcZOIUYjcOfOw/8zWETW43UgiWzH/KiX2zR2LS0tyMrKglarhVarRVZWFu7evfvEdUQEeXl5iIiIgK+vL1JSUvDrr7+aft7c3IzVq1cjNjYWw4cPx9ixY7FmzRq0trb22c64ceOg0Wj6LBs3brTr+Tw6vyE01K5NEQ1IbfkBeMaBXI+1Oevp6cGGDRug1+vh5+eHiIgIvPLKK6ivr+9zv5SUFLMMLVq0yK5amR/1cpvGbvHixbh48SKOHj2Ko0eP4uLFi8jKynriOrt27UJ+fj4+/PBDVFRUQKfT4YUXXkB7ezsAoL6+HvX19XjvvfdQVVWFAwcO4OjRo1i2bJnZtrZs2QKDwWBa3njjDbueT2+otFrAx8euTRENSG35AXhgItdjbc7u3buH8+fP480338T58+dRUFCAP/74A3PnzjW772uvvdYnQ59++qldtTI/KiZu4LfffhMAcubMGdNYWVmZAJDff/+933WMRqPodDrZsWOHaayzs1O0Wq188sknj32sb7/9Vnx8fKSnp8c0FhUVJbt377brObS2tgoAaW1tFRERg0Fk+3aRd96xa7M0SP79+rkTNeZHRGTfPpGcHJHr1+3aNA0Sd86QJWzJWX/Onj0rAOT6I7/YycnJsnbtWptr62/fl5SI5OWJ/O9/Nm+WBpE1+XGLM3ZlZWXQarVISEgwjSUmJkKr1aK0tLTfdWpra9HQ0IC0tDTT2NChQ5GcnPzYdQCgtbUVAQEB8Pb27jO+c+dOhISEYMqUKdi6dSu6u7vtek46HbBxI7Bpk12bIRqQGvMDAK+9BmzbBowda/emiOxmS87609raCo1Gg8DAwD7jBw8eRGhoKOLi4pCdnW06c26rmTOB3FzgxRft2gy5IO+B76K8hoYGjOrnCoqjRo1CQ0PDY9cBgLCwsD7jYWFhuH79er/rNDU14e2338aKFSv6jK9duxbx8fEICgrC2bNnkZOTg9raWnz++eePrbmrqwtdXV2m273zjtra2h67Drmu3tdNer+c1I0wP+QK3DlDlrAlZ//W2dmJjRs3YvHixQgICDCNZ2ZmIjo6GjqdDpcuXUJOTg5+/vlnFBYW9rsd5kd9rMqPs08fPklubq4AeOJSUVEhW7dulQkTJpitP378eNm+fXu/2z59+rQAkPr6+j7jy5cvl1mzZpndv7W1VRISEiQ9PV26u7ufWPfhw4cFgNy5c8eu58bF/ZYbN2488XdjMDE/XNxxcaUMWcKZOXtUd3e3zJs3T6ZOnTrgn9vOnTsnAKSystLmmrm452JJfhQ9Y7dq1aoBP9kzbtw4/PLLL/jrr7/Mfnb79m2zMwq9dDodgIfvosLDw03jjY2NZuu0t7cjPT0d/v7+OHLkCIYMcLXGxMREAEBNTQ1CHnPJ7pycHKxfv95022g0orm5GSEhIdBoNAAeduBjxozBjRs3+rw7I9s5a5+KCNrb2xEREeGwbdqL+WF+HM2Z+9QVM2QJZ+asV09PD15++WXU1tbi+PHjA+77+Ph4DBkyBNXV1YiPjzf7uSX5AZghZ3CJY9CArZ8L6J2UWl5ebho7c+aMAANP/t65c6dprKury2zyd2trqyQmJkpycrJ0dHRYVM93330nQN/JrbZQ+2RiJXCfmmN+yFLcp7azJWciD8/UzZ8/X+Li4qSxsdGix6qqqhIAcuLECbtq5uvteK6wT92isRMRSU9Pl2eeeUbKysqkrKxM9Hq9zJkzp899YmNjpaCgwHR7x44dotVqpaCgQKqqqiQjI0PCw8Olra1NRETa2tokISFB9Hq91NTUiMFgMC33798XEZHS0lLJz8+XCxcuyNWrV+XQoUMSEREhc+fOtfs5ucIvgNpwn/aP+SFLcJ/ax9qc9fT0yNy5cyUyMlIuXrzYJ0NdXV0iIlJTUyObN2+WiooKqa2tle+//16efvppmTp1qilntuLr7XiusE/dprFramqSzMxMGTFihIwYMUIyMzOlpaWlz30AyP79+023jUaj5Obmik6nk6FDh0pSUpJUVVWZfl5UVPTYv2PX1taKiEhlZaUkJCSIVquVYcOGSWxsrOTm5lp8duJJXOEXQG24T/vH/JAluE/tY23OamtrH5uhoqIiERGpq6uTpKQkCQ4OFh8fH4mJiZE1a9ZIU1OT3fXy9XY8V9inGhGVfkTJDXR1dWH79u3IycnB0KFDlS5HFbhPPQdfa8fjPvUsfL0dzxX2KRs7IiIiIpVwiwsUExEREdHA2NgRERERqQQbOyIiIiKVYGOnkI8//hjR0dEYNmwYpk2bhpMnTypdklvLy8uDRqPps/ReZJfUiRlyHObH8zA/juNq+WFjp4BDhw5h3bp12LRpEy5cuICZM2di9uzZqKurU7o0txYXFweDwWBaqqqqlC6JnIQZcjzmx3MwP47nSvlhY6eA/Px8LFu2DMuXL8fEiROxZ88ejBkzBnv37lW6NLfm7e0NnU5nWkaOHKl0SeQkzJDjMT+eg/lxPFfKDxu7Qdbd3Y3KykqkpaX1GU9LS0NpaalCValDdXU1IiIiEB0djUWLFuHq1atKl0ROwAw5B/PjGZgf53Cl/LCxG2R37tzBgwcPzL4UOiwsDA0NDQpV5f4SEhLw9ddf49ixY/jss8/Q0NCAGTNmoKmpSenSyMGYIcdjfjwH8+N4rpYfb0UelaDRaPrcFhGzMbLc7NmzTf/X6/WYPn06YmJi8NVXX2H9+vUKVkbOwgw5DvPjeZgfx3G1/PCM3SALDQ2Fl5eX2TujxsZGs3dQZDs/Pz/o9XpUV1crXQo5GDPkfMyPejE/zqd0ftjYDTIfHx9MmzYNhYWFfcYLCwsxY8YMhapSn66uLly+fBnh4eFKl0IOxgw5H/OjXsyP8ymdH/4pVgHr169HVlYWnn32WUyfPh379u1DXV0dVq5cqXRpbis7Oxsvvvgixo4di8bGRrzzzjtoa2vDkiVLlC6NnIAZcizmx7MwP47lavlhY6eAhQsXoqmpCVu2bIHBYMCkSZPwww8/ICoqSunS3NbNmzeRkZGBO3fuYOTIkUhMTMSZM2e4T1WKGXIs5sezMD+O5Wr50YiIKPLIRERERORQnGNHREREpBJs7IiIiIhUgo0dERERkUqwsSMiIiJSCTZ2RERERCrBxo6IiIhIJdjYEREREakEGzsiIiIilWBj5+Hy8vIwZcqUQX/c4uJiaDQaaDQazJ8/36J18vLyTOvs2bPHqfURWYL5IbId8+McbOxUrPeX8HHL0qVLkZ2djZ9++kmxGq9cuYIDBw5YdN/s7GwYDAZERkY6tygiMD9E9mB+lMPvilUxg8Fg+v+hQ4fw1ltv4cqVK6YxX19f+Pv7w9/fX4nyAACjRo1CYGCgRfftrdXLy8u5RRGB+SGyB/OjHJ6xUzGdTmdatFotNBqN2di/T4UvXboU8+fPx7Zt2xAWFobAwEBs3rwZ9+/fx+uvv47g4GBERkbiyy+/7PNYt27dwsKFCxEUFISQkBDMmzcP165ds7rmw4cPQ6/Xw9fXFyEhIfjvf/+Ljo4OO/cEkfWYHyLbMT/KYWNHZo4fP476+nqUlJQgPz8feXl5mDNnDoKCglBeXo6VK1di5cqVuHHjBgDg3r17SE1Nhb+/P0pKSnDq1Cn4+/sjPT0d3d3dFj+uwWBARkYGXn31VVy+fBnFxcVYsGABRMRZT5XI4ZgfItsxPw4g5BH2798vWq3WbDw3N1cmT55sur1kyRKJioqSBw8emMZiY2Nl5syZptv3798XPz8/+eabb0RE5IsvvpDY2FgxGo2m+3R1dYmvr68cO3as33qKiooEgLS0tJjGKisrBYBcu3btic8lKipKdu/e/cT7EDkS80NkO+ZncHGOHZmJi4vDf/7zz8ncsLAwTJo0yXTby8sLISEhaGxsBABUVlaipqYGI0aM6LOdzs5O/PnnnxY/7uTJk/H8889Dr9dj1qxZSEtLw0svvYSgoCA7nxHR4GF+iGzH/NiPjR2ZGTJkSJ/bGo2m3zGj0QgAMBqNmDZtGg4ePGi2rZEjR1r8uF5eXigsLERpaSl+/PFHfPDBB9i0aRPKy8sRHR1twzMhGnzMD5HtmB/7cY4d2S0+Ph7V1dUYNWoUxo8f32fRarVWbUuj0eC5557D5s2bceHCBfj4+ODIkSNOqpxIecwPke2YH3Ns7MhumZmZCA0Nxbx583Dy5EnU1tbixIkTWLt2LW7evGnxdsrLy7Ft2zacO3cOdXV1KCgowO3btzFx4kQnVk+kLOaHyHbMjzn+KZbsNnz4cJSUlGDDhg1YsGAB2tvbMXr0aDz//PMICAiweDsBAQEoKSnBnj170NbWhqioKLz//vuYPXu2E6snUhbzQ2Q75secRsQdP8tL7q64uBipqaloaWmx+AKRvcaNG4d169Zh3bp1TqmNyNUxP0S2U3t++KdYUlRkZCQyMjIsuu+2bdvg7++Puro6J1dF5B6YHyLbqTU/PGNHivj7779x69YtAA+/qkWn0w24TnNzM5qbmwE8/LSTtRNjidSC+SGyndrzw8aOiIiISCX4p1giIiIilWBjR0RERKQSbOyIiIiIVIKNHREREZFKsLEjIiIiUgk2dkREREQqwcaOiIiISCXY2BERERGpBBs7IiIiIpX4P2+1YRr33EQLAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_estimator_response(timepts, est0, U0, V*0, Y0, W*0)" ] @@ -464,10 +667,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "93482470", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "V_clipped = np.clip(V, -0.05, 0.05) \n", "\n", @@ -479,10 +693,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "56e186f1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary statistics:\n", + "* Cost function calls: 4222\n", + "* Constraint calls: 4410\n", + "* Final cost: 522.06154910988\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "uvec = [xe, ue, V_clipped, W]\n", "clipped_resp = ct.input_output_response(lqr_clsys, timepts, uvec, x0)\n", @@ -513,10 +758,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "108c341a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_estimator_response(timepts, est_clipped, U, V_clipped, Y, W)" ] @@ -533,10 +789,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "121d67ba", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MHE for continuous time systems not implemented\n" + ] + } + ], "source": [ "# Use a shorter horizon\n", "mhe_timepts = timepts[0:5]\n", @@ -557,10 +821,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "1914ad96", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample time: Ts=0.1\n", + ": sys[9]\n", + "Inputs (4): ['F1', 'F2', 'Dx', 'Dy']\n", + "Outputs (3): ['x', 'y', 'theta']\n", + "States (6): ['x0', 'x1', 'x2', 'x3', 'x4', 'x5']\n", + "\n", + "Update: at 0x1662e3490>\n", + "Output: at 0x165cf9c60>\n" + ] + } + ], "source": [ "# Create discrete time version of PVTOL\n", "Ts = 0.1\n", @@ -575,10 +854,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "11162130", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Create a new list of time points\n", "timepts = np.arange(0, Tf, Ts)\n", @@ -596,7 +886,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "c8a6a693", "metadata": {}, "outputs": [], @@ -610,10 +900,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "d683767f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAADEdElEQVR4nOydeVxU9frHP8MOyiIiCCqKqbilIm6Ya5ampqXltbrXtNIyMzMyr2gb3bz8ullXu6XmkmaWWbm1mEsp7hvuivsGKoi4sCgM2/f3x8NhZmAGZjln1uf9es3rzJw5y3dgvnM+51lVQggBhmEYhmEYxuFxs/UAGIZhGIZhGHlgYccwDMMwDOMksLBjGIZhGIZxEljYMQzDMAzDOAks7BiGYRiGYZwEFnYMwzAMwzBOAgs7hmEYhmEYJ4GFHcMwDMMwjJPgYesByE1ZWRmuX78Of39/qFQqWw+HcRKEEMjLy0NERATc3Jz7fojnEKMErjKHeP4wSmDK/HE6YXf9+nU0atTI1sNgnJT09HQ0bNjQ1sNQFJ5DjJI4+xzi+cMoiTHzx+mEnb+/PwD68AEBATYeDeMs5ObmolGjRhXfL2eG5xCjBK4yh3j+MEpgyvxxOmEnmb4DAgJ4UjGy4wquFZ5DjJI4+xzi+cMoiTHzx3kDHRiGYRiXJSkpCZ07d4a/vz9CQ0Px5JNP4syZMzXut23bNsTGxsLHxwdNmzbF/PnzrTBahpEPFnYMwzCM07Ft2za89tpr2Lt3LzZv3oySkhL0798f9+7dM7jPpUuXMGjQIPTs2ROHDx/G9OnTMWnSJKxatcqKI2cYy3A6VyzDMAzDbNiwQef1kiVLEBoaioMHD6JXr15695k/fz4iIyMxe/ZsAECrVq2QkpKCWbNm4amnnlJ6yAwjCyzsmArKyspQVFRk62HYDC8vL6cuw8AoT2lpKYqLi209DJvg6ekJd3d3Ww/DIDk5OQCA4OBgg9vs2bMH/fv311k3YMAALF68GMXFxfD09FR0jK6OK1+D5Jw/LOxkorQUSEsDoqJsPRLzKCoqwqVLl1BWVmbrodgMNzc3REVFwcvLy9ZDAUAxQqtXr8bp06fh6+uL7t274+OPP0Z0dHS1+23btg3x8fE4efIkIiIiMHXqVIwfP95KozafK1eABg0ADwf8VRJCIDMzE3fv3rX1UGxKUFAQ6tevb3cJEkIIxMfHo0ePHmjbtq3B7TIzMxEWFqazLiwsDCUlJcjOzkZ4eHiVfdRqNdRqdcXr3Nxc+QZuAnfvAsXFQL16Njm9xfA1SL7544A/ofbJjBnAxx8DiYnAe+/ZejSmIYRARkYG3N3d0ahRI5e0WklFRTMyMhAZGWkXFyYpRqhz584oKSnBjBkz0L9/f6SmpqJWrVp695FihMaNG4fly5dj165dmDBhAurVq2fXrqSUFKBzZ6BrV+CvvwADH89ukURdaGgo/Pz87OL7Y02EELh//z6ysrIAQK8AsiUTJ07EsWPHsHPnzhq3rfy/E0LoXS+RlJSExMREywdpAUIAHTsCN24Av/0G9O1r0+GYjKtfg2SfP0JB/v3vf4tOnTqJ2rVri3r16oknnnhCnD59usb9kpOTRceOHYW3t7eIiooS8+bNM/qcOTk5AoDIycmxZOgmM3iwEDS9hFi82KqntpiioiKRmpoq7t69a+uh2JS7d++K1NRUUVRUVOU9W32vtMnKyhIAxLZt2wxuM3XqVNGyZUudda+88oro1q2b0eexxWddskQzfx5/XIjiYqud2mJKSkpEamqqyM7OtvVQbE52drZITU0VJSUlVd6z1RyaOHGiaNiwobh48WKN2/bs2VNMmjRJZ93q1auFh4eH3t8FIYQoLCwUOTk5FY/09HSrf867dzXzx9dXiK1brXZqWeBrECHX/FFUFrtSVlJ+vub5yy8DleJ27ZrS0lIAsBsXpK2QPr/097A3LIkRSklJMRj7pVarkZubq/OwNtqn/O03YNIkqw/BbKS/q5+fn41HYnukv4E9xBkKITBx4kSsXr0aW7ZsQZQRcTJxcXHYvHmzzrpNmzahU6dOBuPrvL29K2rW2ap23a1bmucFBcDgwcCxY1YfhtnwNYiQa/4oKuw2bNiAMWPGoE2bNmjfvj2WLFmCtLQ0HDx40OA+2llJrVq1wtixY/Hiiy9i1qxZSg7VYiRh17Ilxds9/zxw86Ztx2QqruY+qow9f34hU4yQPpKSkhAYGFjxsEU7JEnYRUcDKhUwbx5Q6fpq99jz98da2NPf4LXXXsPy5cvx/fffw9/fH5mZmcjMzERBQUHFNgkJCXj++ecrXo8fPx5XrlxBfHw8Tp06ha+//hqLFy/GlClTbPERjEYSdvXrAw8/DNy/D/zrX7YdkznY0/fHFsj1+a3qyFbK4mAsO3cCa99JwfUZXwKvv06mtbFjgeXLyYptAXl5tPzf/4AHHyRR99prFh2SYSqQYoRWrFhR47amxgglJCQgJyen4pGenm75gE2k/KcBjz9OUxMA3niDgsEZxhzmzZuHnJwc9OnTB+Hh4RWPlStXVmyTkZGBtLS0itdRUVFYv349kpOT0aFDB/zrX//C559/btfxqYCusJszh56vWgWcP2+7MTG2w2rJE3JZHCoHFZqSkTRtGrBrVyeswr8xHGs0byxeDGzZQmYCb28TPxkhWezq1gWWLgW6dAF++gn48Ufgb38z65AMAwB4/fXX8csvv2D79u01Nn+uX78+MjMzddZlZWXBw8MDdevW1buPt7c3vM383suFNG0DAkjYff89cOoUMHcuCTyGMRVhxM360qVLq6zr3bs3Dh06pMCIlEMSdnXrAm3bAoMGAevXA599RnOIcS2sZrFTyuJgihtJKqNQ0rMvkJBAtuo33gDc3IAlS4A+fciGbQaSsKtdm7KTZsyg16+9phs/xDDGYq0YIXtAW9jVqQPMnEmv33/f8UIaGMbaSMJOcoZNnUrLJUuA8kRLxoWwirCTLA5bt26V3eJgihtJEnalr74O/PvfwDvvALNnU6bDY49RrRJfX5M/nxC6wg4gYRcdDWRnA59/bvIhGSNZsWIFfHx8cO3atYp1Y8eORbt27Spc/46KK8UIaQs7AHjpJaBDB3LRLlhgs2G5BM48h1wFbYsdAPTqReWDCguBL7+03bhcAXucP4oKO2tYHEzJSKqw2JVUeuPRR8lu3b8/RW6bSEEBINVU9PenpZcXWRsA4NNPNTFEjLw888wziI6ORlJSEgAgMTERGzduxB9//IHAwEAbj84yXClGSBJ20r/M3V3jgv32W4tDYJlqcOY55CpUFnYqFTB5Mj3/+WebDMllsMv5I2cNlsq8+uqrIjAwUCQnJ4uMjIyKx/379yu2mTZtmhg1alTF64sXLwo/Pz/x5ptvitTUVLF48WLh6ekpfv75Z6POWV2tF6nW3Ndf13CQsjKjziVx44amhlBpqWZ9SYkQrVvT+g8+MOmQVqWgoECkpqaKgoIC3Tfy8w0/TNlW6/9d7bZm8uuvvwpvb28xc+ZMUadOHXHixAmd91q0aCGaNWsmFi5caN7fQdhHHTtrYYvP2q4dzZNNmzTrcnOpJhcgxN69VhuKyVT3vXGGOfTkk0+KoKAg8dRTT9V4HJ5Dtvmczz5L8+SzzzTrsrOFUKlo/bVrVhuKWTjrNSgtLU307t1btGrVSjz44IPixx9/NO/vIEz7Xikq7ADofSxZsqRim9GjR4vevXvr7JecnCxiYmKEl5eXaNKkiWwFip94gr7kCxYY2PnOHSFmzBCiVy+TxN2FC3TcWrWqvvfjj/ReQIAQt28bfUirYvDLJKlVfY9Bg3S39fMzvG2l/68ICdG/nQVI35fk5OSKdcXFxaJ58+bi6tWrIjc3VzRr1kzcunXL9L+DcJ2LkhC2+axNmugXcH//O62fMMFqQzGZaoWdg88hIYTYsmWL+OWXX1jYGYktPmf//vTv/+Yb3fWdOtH6ZcusNhSzcNZr0PXr18Xhw4eFEELcuHFDNGjQQORXIyDlmj+Ku2L1PcaMGVOxzdKlS5GcnKyzn5SVpFarcenSJdn6XEr9dau4YrWZMwfYvh344w+jj1s5vk6bp56i8ie5ucCyZcaPlTGejRs34vTp0ygtLdXJqN6/fz/atGmDBg0awN/fH4MGDcLGjRttOFLGEFKoQuVICil88IcfAK3kd0ZmDM0hAOjbty/8pRgTxi6p7IqVeOQRWjpaTUhHw9D8CQ8PR4cOHQAAoaGhCA4Oxu3btxUfj0s1ZDMYYycRFER17QCqt2AkUg07fb99bm4UCA4AWqFRjkF+vuFH5U4gWVmGt60ski9f1r+dGRw6dAgjRozAV199hQEDBuDdd9+teO/69eto0KBBxeuGDRvqBLgy9oEQVZMnJPr1AyIigNu3KQzW4XDwOcQ4BoaE3aOP0vLPPx00TtWJ5k9KSgrKysqsUgDeanXs7IGKrNjqOkYNHUqZsn/9RTPBiGSK6ix2ADBiBPDmm8CePUBaGhAZadKwbYcpndiV2rYaLl++jMGDB2PatGkYNWoUWrdujc6dO+PgwYOIjY3VW8fK1Sub2yMFBZo5WVnYubsD//gH8J//kNVu2DDrj88iHHwOMY6BIWHXvTvg4wNkZFBdyNatrT82i3CS+XPr1i08//zzWLRokSznrQm22FUmLo5mQmYmzQQjqEnYRURQ+jlABYsZy7l9+zYGDhyIoUOHYvr06QCA2NhYDBkyBDPKiwg2aNBAx0J39erVKgWuGdsjWetUKv1z6PHHabl9u4NaHewUY+YQY/8UFWm8RpWFnY8P0LMnPWd3rLwYO3/UajWGDRuGhIQEdO/e3Spjc0mLXbXCzscHeOghstj99ZdRtziSsKsuDGXkSGDbNnLH2nlJMYcgODgYp/QI73Xr1lU879KlC06cOIFr164hICAA69evx3vvvWfNYTJGoO2G1WdQ7dyZygdlZgIXLgDNmll3fM6KMXOIsX+kkC03N4omqsyjj5Ko+/NP7uIiJ8bMHymn4OGHH8aoUaOsNja22OmjXz9a/vWXUceV7pYMWewASqJwcwNSUrh/n7Xw8PDAp59+ir59+yImJgZvv/22wbZajO0wFF8n4eND4g6gfs+MdRkwYABGjBiB9evXo2HDhjhw4ICth8RoIblh69Sha0xlpASK5OQawpAY2dm1axdWrlyJtWvXokOHDujQoQOOHz+u+HnZYqePfv2AJk2ABx4w6rg1uWIBIDQUePhhumv68Ueg3HLLKMzQoUMxdOhQWw+DqYaahB1A7qRdu4AdOwCtpHrGCnAmuX1jKL5Oon17wM+PrlPnz1NHJMY69OjRA2VS9wIr4lIWO6PKnQBkHrh0iVpGGIExwg4Ann6aliZUUmEYp8dQqRNtevSg5Y4dyo+HYRyJmoSdmxvQti09P3bMOmNibItLCTujLXYmZk4aE2MHkMUOAPbvp0xAhmGMs9g99BBNy3PngBs3rDMuhnEEahJ2ANCuHS2PHlV+PIztcUlhZ3ScQUkJcOZMjZsZE2MHUNB3eDhlMe3bZ+QYGMbJMUbYBQVRoW+A4+wYRhtjhF379rRki51r4JLCrkaLHUAFDENCgC5daqyxYKwrVqUCevem59u2GTEGhnEBJGFXU79sdscyTFVMsdixsHMNWNgZokED8pfm5pLIqwZjhR3Awo5hKmOMxQ7Q1ONiix3DaDBG2EnW7itXNDGtjPPCws4Qnp6aGnY13OYYG2MHaITdnj3c+5JhAOOFnWSxO3IEKCxUdEgM4zAYI+zq1AGkTlZstXN+XErYGZ0VK2FkxKmxMXYA0LIlUK8eXZi4HBTDGC/sGjQAgoMpRtbIpjAM4/QYI+wAdse6Ei4l7Eyy2AGaiNMahJ0prliVStNejN2xDGO8sFOpNC4lK9T4ZBiHwFhhxwkUroNLCjujs2KNvMUxRdgBGnfs9u1GjoNhnBhj6thJsLBjGF3YYsdUxiWFnckWuwsXNOpND6bE2AEaYbdrF7d4kZM7d+4gMTERGRkZth4KYwLGZsUCLOyUhueQYyGEplesscLu+HHABs0QXAJ7mT/cUqw66tWj/kWNGwPFxXo3EcJ0i12bNtTi5d49KrjasqWR42GqZdKkSbhz5w4OHz6MtWvX2no4jJEY64oFdC9OjPzwHHIscnM117OahF3z5oC3N113Ll6kuqqMvNjL/GGLXU0sWQJ88AGlFenh/n1NmTtjhZ27u+YCdfiwCWNhDPLLL78gPz8fv/32G4KCgvDdd9/ZekiMkZgi7Nq0oeX16xpLBSMPPIccD8kN6+cH+PhUv62Hh2b+8I2R/NjT/HEpi53JWbFGIFnrVCqaXMYSEwPs3UvC7tln5RuPqzJ06FAMHToUALB06VLbDoYxGiFME3b+/kBUFLVyPn5cE9bAWA7PIcfD2Pg6ieho4NAh8hQx8mJP84ctdjUhBJCeTgFxetB2w5rSYjYmhpZssWNcGbVaE+VgjLADOM6OMZ7t27djyJAhiIiIgEqlqtE9lpycDJVKVeVx+vRp6wzYREwVds2b0/L8eWXGw9gHLinsTEpYSE0FIiOBxx7TG3FqSg07bbSFXQ0dyxjGaZGsdYDxc4iFHWMs9+7dQ/v27fHFF1+YtN+ZM2eQkZFR8WguKSI7w1RhJ8XVscXOuXFJYWeSxa5FC8DLi0xzelqLmZo4IdG2LbmGb90Crl41bV9Gw4oVK+Dj44Nr165VrBs7dizatWuHHO6dY/dI/yJ/f8DNyF8jFnby4sxzaODAgfjoo48wfPhwk/YLDQ1F/fr1Kx7uUhyPnZGdTct69Yzbni128mOP84eFXU14epK4A4AzZ6q8ba6w8/HRdCxjd6z5PPPMM4iOjkZSUhIAIDExERs3bsQff/yBQGPqZzA2xZRSJxKSsDtxgq3dcsBzqCoxMTEIDw9Hv379sHXrVlsPxyCSsDPVYnf1KiX+MZZjj/NHUWFnb/ENZgk7QCPszp6t8papNey0sdc4OyEoJd4WD1Mv1CqVCjNnzsSiRYvw73//G3PmzMGGDRvQoEGDim1+++03REdHo3nz5li0aJHMfy1lsbc5JDemJE5ING9ORvS8PGpqbo842xwaNmwY6tSpg6efflrmv5R9ER4ejgULFmDVqlVYvXo1oqOj0a9fP2yvppq8Wq1Gbm6uzsNaSK7YkBDjtq9bV3MTdfGiMmOSA2eaP+np6ejTpw9at26Ndu3a4aefflLgL6aLolmxUnzDCy+8gKeeesro/c6cOYMArV/6esbamWvA7KxYSdjpCUwwN8YOIGG3bJn9Cbv79837PHKQnw/UqmXaPo8//jhat26NxMREbNq0CW2knH4AJSUliI+Px9atWxEQEICOHTti+PDhCA4OlnnkymBvc0huzBF2np5Aq1bU6e/ECaBJE0WGZhHONIcAqs/14osv4ptvvpFxpPZHdHQ0oqOjK17HxcUhPT0ds2bNQi+pF2QlkpKSkJiYaK0h6iBZ7IwVdioV3RilpJA7tm1b5cZmCc40fzw8PDB79mx06NABWVlZ6NixIwYNGoRapp7EBBQVdgMHDsTAgQNN3i80NBRBQUGyj8dsi50UmKBH2JnrigXs12LnaGzcuBGnT59GaWkpwsLCdN7bv38/2rRpU3H3NGjQIGzcuBHPOkiNGXubQ3JjjrAD6F7r6FEOApeL6uYQAPTt2xfJycnWH5gd0K1bNyxfvtzg+wkJCYiPj694nZubi0aNGlljaCYLO4DcsSkpPHfkpLr5Ex4ejvDwcAD0uxwcHIzbt287rrAzl5iYGBQWFqJ169Z455130LdvX4PbqtVqqNXqitfVmcHNyooFjHLFmiPsOnSgZVoamdSNjZNQGj+/ajuoKX5uUzh06BBGjBiBr776Cj/88APeffddHVP39evXdVxKDRs21AlydVaUmkNyY66wq+Zeyy5wpjnk6hw+fLjiwqwPb29veHt7W3FEGkyNsQMcI4HCWedPSkoKysrKFBf+diXspPiG2NhYqNVqfPvtt+jXrx+Sk5NlMYObbbFr3RqYPp2qO1bCkhi7wECgaVOKdTh6FHj4YdOPoQQqlemmaFtw+fJlDB48GNOmTcOoUaPQunVrdO7cGQcPHkRsbCwAQOgJmFCZUnDQwVB6DsmNswo7Z5pDjkx+fj7OaymYS5cu4ciRIwgODkZkZCQSEhJw7do1LFu2DAAwe/ZsNGnSBG3atEFRURGWL1+OVatWYdWqVbb6CNVirsUOsN+5Azjn/Ll16xaef/55q8R525WwMye+wRQzuNnCLjgYmDlT71uWxNgB1OLl4kXg9Gn7EXaOwO3btzFw4EAMHToU06dPBwDExsZiyJAhmDFjBjZs2AAAaNCggY6F7urVq+jatatNxmwNlJ5DcmNOVixg/8LOETB2DjkyKSkpOtZq6Xs+evRoLF26FBkZGUhLS6t4v6ioCFOmTMG1a9fg6+uLNm3a4Pfff8egQYOsPvaaEML05AnAMSx2joAp80etVmPYsGFISEhA9+7dFR+bXQk7fdQU32CKGdxsYVcNlrhiAaBlS+DXX0nYMcYTHByMU6dOVVm/bt06ndddunTBiRMncO3aNQQEBGD9+vV47733rDVMu0DOOSQ3Upkncy12aWlAYWHNfTKZqhg7hxyZPn366LXaS1Ru/TR16lRMnTpV4VHJQ34+UFREz01xxUoWu/R0oKAA8PWVf2yugLHzRwiBMWPG4OGHH8aoUaOsMja7r2NXU3yDKVjUKzYrC/jrL/KZaiGHsANY2CmFh4cHPv30U/Tt2xcxMTF4++23UddeghmthJxzSG4ki52poQz16pEYFMK+yzY4CwMGDMCIESOwfv16NGzYEAcOHLD1kFweyQ3r52daXFhIiOZGiueO8uzatQsrV67E2rVr0aFDB3To0AHHFa6urqjFzt7iGyyy2H35JfDhh8C4ccCCBRWrLYmxAzRheyzslEO7ObOjYW9zSG7u3qVlnTqm7SeVbTh4kNyxUrFvRhk2btxo6yEwlTAncQLQnTvnz1M4EKMcPXr0QJmedqRKoqiws7f4BouEneT7qZQZa2mMnWSxS0+n4oiOEDDKWA97m0Nyc+cOLc2pzKIt7BjG1TAnvk6iWTOeO86MosLO3uIbzC53AhiM1rbUFVu3Lk3M7GzSjFJtO4YB7G8OyY25FjuAEygY18acjFgJnjvOjd3H2MmJLBa769d1CuxY6ooFOM6OcV0stdgBfHFiXBNLhF3TprS8fFm24TB2BAs7YwkO1gQzaMU8WWqxAzjOjnFd2GLHMOZhbowdoGnDx8LOOWFhZwp6OlBYGmMHsMWOcU3Uaiq3AFhmsbt6lXpLMowrYYnFThJ2aWmmN71n7B+XEnYWlTsBqpgISksp4QGQxxV75oz5x5CD6mK5XAFX//zWRnLDqlSm17EDyIguCcILF2Qbltnw94f/BtbEkuSJhg0BNzeqAXnjhrzjsgRX//7I9fldSthZbLEbMwZYtAgYPhyApgYXYHrlfG20hZ2Vs6IBAO7lirdIqnbpokifX/p7MMoiuWEDA+kiYypS2QbAtu5YT09PAMB9NhtW/A2kvwmjHJZY7Dw9AamFtj24Y/kaRMg1f+y+84SceGh92rIyMy4mffvSoxypar6vL+DlZf64mjSh/QsLyTQumcmthYeHB/z8/HDz5k14enrCzZyrrINTVlaGmzdvws/PDx4eLjUtbIZksTMnvk6ieXPgwAHbCjt3d3cEBQUhKysLAODn5+fU/Yj1IYTA/fv3kZWVhaCgIL45sgKWxNgBdJ1JTydh162bXKMyD1e/Bsk9f1zqCqZ9vS4psUyMAboWB0vw8KC6QqmpFGdnbWGnUqkQHh6OS5cu4cqVK9Y9uR3h5uaGyMhIl7so2wpp/pgTXydhL30v69evDwAV4s5VCQoKqvhbMMpiicUOoOvMjh32YbHjaxAh1/xhYWcKpaXA9u3ApUvAqFHIySFzqaXCDiB3bGoquWMfe8zy45mKl5cXmjdv7tKmcC8vL5e7U7Qlcljs7KVsg3RhCg0NRXFxsW0HYyM8PT3ZUmclhJBH2AGAvegoV78GyTl/XFrYmYxKBQwaRD7Tvn2RkxMFwDKLg4Q9ZMa6ubnBh7upM1bCklInEtLF6dIlS0cjD+7u7ixuGMXJy9NcwyxxxQK2vynShq9B8uBS5gnt31uzhJ2bm2Y2XLxYEWMnh8XOXlxKDGMtLClOLKFdtsGsjjIM44BI1rpatSjG2xzsUdgx8sDCzlSiyEqHS5dki7EDKMYO4GKrjOsgh8WuQQOyxBcXAxkZsgyLYeweSxMnAKBxY1pevsy17JwNlxJ2KpVG3Jl9d68l7JSw2KWlUeFWhnF25LDYubsDkZH03F7csQyjNJbG1wFAo0Z0TSwsBFw858fpcClhB8hQy06K1pbZFRsaSt0rhAAuXrT8eAxj78hhsQPYpcS4HpYUJ5bw8tLUsrOXBApGHljYmYoei50cyRPaxVY5zo5xBeSw2AGaKcnCjnEV5LDYAXxT5KywsDMV6Spy8aKsMXYAx9kxroXcFjt2xTKughwxdgALO2fFpcqdADL1i124EIiKQs5/BACVbMKOLXaMK8EWO4YxDxZ2THW4nLCz2GJXuzYwdiwAIGcGrWKLHcOYjhwFigG+ODGuh5TsEBpq2XG0M2MZ54FdsRYgZ4wdwBY7xnUoK5Nv/mjXspNjXjOMvXPjBi3Dwiw7jr11n2DkwWWFnUXFTE+cAJYswd2b1PpEbosdlzxhnJ3cXE3tLEuFXXg4ZfiVlgLXrlk8NIaxe+QWdlzLzrlwWWFn0Z39smXAiy/KWu4EoElauzZZMzgQnHFmpMQJHx96WIKbm8alxPOGcQXkEnYNG9Ly/n3g9m3LjsXYDyzszCEqCsXwQEGJFwD5hJ1KpbHasTuWcWbkiq+T4Dg7xlW4d48egOXCzsdHc4y0NMuOxdgPLifsLM6KBSgjFho1FxBg2Zi0keLsOIGCcWYki51c8amcGcvoY/v27RgyZAgiIiKgUqmwdu3aGvfZtm0bYmNj4ePjg6ZNm2L+/PnKD9QEJGudry95eCxF6tzCws55cDlhJ5fF7i6CAAC1a4uKY8oBW+wYV0Apix27Yhlt7t27h/bt2+OLL74wavtLly5h0KBB6NmzJw4fPozp06dj0qRJWLVqlcIjNR5tN6xKZfnxWNg5H4oKO3u8W5JF2EVGVljsAv3LLB+UFmyxY1wBuS127Ipl9DFw4EB89NFHGD58uFHbz58/H5GRkZg9ezZatWqFsWPH4sUXX8SsWbMUHqnxyBVfJyHFp7Kwcx4UFXb2eLckS1asry9y6pDvJ9C3yPJBacG17BhXQG6LnVanP4Yxmz179qB///466wYMGICUlBQUFxfbaFS6SMLO0hp2Emyxcz4UFXb2eLckVx27nHqkwII871k4Il20S54UyasZGQfEHq3eciBXOzEJyepw7RpgJ9dfxgHJzMxEWCVTWFhYGEpKSpAttXuohFqtRm5urs5DSaTixHJZ7FjYOR92FWNnzt2SqZNKLmF394nRAIDARjJmTgCoXx/w86OSJ1w0krFHq7ccyNVOTCIsDPD2pnnDtewYS1BVClwT5QXeKq+XSEpKQmBgYMWjUaNGio5PblcsCzvnw66EnTl3S6ZOKlmyYgHkRLQCAASGeFl2oEqoVEDTpvT8wgVZD804IPZo9ZYDuS12bm6aCxTH2THmUr9+fWRmZuqsy8rKgoeHB+oaaMyakJCAnJycikd6erqiY1RK2GVksJfIWbArYQeYfrdk6qSSzRUrc3FibR54gJYs7BhTUTJGKCUFSHr7Nta+/hewZYumE7kZyG2xA7g9EmM5cXFx2Lx5s866TZs2oVOnTvD09NS7j7e3NwICAnQeSiK3sAsJoXp2QrC121mwK2Fnzt2SqZNKNmF3oxAAEHThoGUH0gOXPGHMRckYod27gemzgvHDFzeBfv3oytK3LzB/vsmBbXInTwDc0JypSn5+Po4cOYIjR44AoFCFI0eOIK3c75iQkIDnn3++Yvvx48fjypUriI+Px6lTp/D1119j8eLFmDJlii2Grxe5hZ1Kxe5YZ8OuhJ05d0umIktWLIC7WeV9Yrf9InuTPbbYMZagVIyQtzct1aGNgBYtKKAtORl49VWgSxeg/OJpDHKXOwE0wo4tdoxESkoKYmJiEBMTAwCIj49HTEwM3nvvPQBARkZGhcgDgKioKKxfvx7Jycno0KED/vWvf+Hzzz/HU089ZZPx60NuYQewsHM2ZCytW5X8/Hyc1zI7SXdLwcHBiIyMREJCAq5du4Zly5YBoLulL774AvHx8Rg3bhz27NmDxYsXY8WKFbKNSTaLXWktAEBg8U3g5k35cs/Bwo4xH3NjhOLj4yte5+bm6hV3XuXhpOrYh4D1Z6i2yM8/A//3fyTqOncG9uwBOnWqcZxKWOy4lh1TmT59+lTc2Ohj6dKlVdb17t0bhw4dUnBU5lNYqAkDYmHHGEJRYZeSkoK+fftWvJYuHqNHj8bSpUsN3i29+eab+PLLLxERESH73ZJswi6PsjACkUNXEgWE3cWLZBRxsyu7KmPPxMXF4ddff9VZZ0yMkLdkjquGCoudunxFVBTw9tvA888Dr79O7lkjRJ0QysTYscWOcXakUieenvLOHRZ2zoWiws4e75bkTp4Iwl2yXHTpYtkBtYiMpOzdwkLg+nWgYUPZDs04GPZk9a4i7CTCwoAffzT6OPfva44REmLxsCqQLHbp6RRqIWXAM4yzoF2cWI52YhKSsOObIufA5WxBcpU7kWKEKix2MuLpqblIsTvWtbGnGCGDwq4yt25R3J2BSSblcHh7A7VqWTysCiIi6MatuJhKNzCMs6FEfB3AFjtnQ1GLnT0ie7kT5CjSx+iBB0jUXbgA9O4t++EZB8GerN5GCTshgMGDgX37gJgY4OWXq2wiCbu6deW1Ori7A40a0XS8coUt3YzzYQ1hJ4S885KxPi5nsZMjK1aISsJOgWhtTqBg7A2jhJ1KBTz3HD1/910gL6/KJrdu0VJON6wElzxhnBmlhJ10E3Tvnib+lXFcXFbYWWKxKyzUVOgOWrOU6njJjCTsuJYdYy9Iwq7G6vTjx1Mxxqws4D//qfK2ZLFTUthxrBDjjMjdJ1bC11eT/8dzx/FhYWcGkrVOpQJqD31YExAnI1KRYrbYMfaC0TF2Xl4aQffpp1UC3rRdsXLD3ScYZ0Ypix3AcXbOBAs7M5CEXUCAcqVI2BXL2BtGCzsAePJJoFs3oKAA+PJLnbfYFcsw5qGksGNrt/PgcsJOjqxYnT6xa9YAH3wAnDlj6dB0aNqUlnfvArdvy3pohjELk4SdSgVIbZjmzyeBVw5b7BjGPFjYMcbgcsJODotdRamTQAD/+x+QmAjs32/p0HTw86PyDQBw7pysh2YYszBJ2AFktWvbFhg5korXlWMNi92VK7J3+mMYm6OksOObIueBhZ0ZSFlDwcHQmNYUKHnSogUtz56V/dAMYzKSsCspoY4oNeLuTq3GvvxSxzynZPJEw4ZkLCws1ASaM4wzUFiouSmSbvrlhC12zoPLCjtLyp1Ik6tuXWiE3cWLFo1LH5Kwk9nLyzBmod11zGirnZ72D0q6Yr28gAYN6DnH2THOxLVrtPT1lbfHsgQLO+fBZYWdJRY7KeYtOBjULxNQRNhFR9OSLXaMPWCWsAPIJ7pnDzBnDgBlXbGAxqXEwo5xJiRh16CBMgWEJWF38ybVs2McFxZ2ZiAJO6UtdpKwY4sdYw94emqemyTsLlwAuncH4uMhrl5T1GIHaO61FIiOYBibcfUqLZXqqBIURJUeAC554ui4nLCTIytWsjjoxNhdv05BEDIiuWLPnTMypolhFESlMiOBAqCijL16AWVluP/VtxXTRCmLHQs7xhnRttgpBbtjnQOXE3ayu2JDQoDatcndJPNsiIoiK0lBgeZujWFsiVnCDqjoGXvr63UAKBaudm0ZB6aF5IplYcc4E0pb7AAWds4CCzsz0EmeUKmAP/6gQDipqrBMeHhoDsnuWMYe8PKipcnC7qmngDp1kH2ddqxbV7lG42yxY5wRttgxxuKyws6SrFgdix0A9OgBNG+uObiMcGYsY0+YbbHz8QFGj8YtUGCdUm5YQCPsrlzhEAbGeWCLHWMsLivsZLPYKQxnxjL2hNnCDgDGjUM2SNHV9TfnAMbRoAHN8+JiCn1lGGeALXaMsbCwM5GyMj0WuzNngA8/BD7/3OLxVYYzYxl7wiJh17o1sqO6AABCvPLkG1QlPDyARo3oObtjGWegtBTIyKDnLOyYmnA5YWdpVmxensa9UyHsLlwA3n8f+Ppri8dXGXbFMvaERcIOwK3h4wAAIS0V9MWC4+wY5+LGDRJ37u5A/frKnUcSdteuAUVFyp2HURaXE3aWWuwkN6yfH4UNAdCtZSdzg0rJYpeWptNHnWFsgqXCLruQUmGVDmNgYcc4E1J8Xf36epu5yEZYGF3XhOBKDI4MCzsT0SlOLCHVV8jL0yg/mahXjwpHCgGcPy/roRnGZCwWdlKf2KASYN8+eQalB0nYcfcJxhmQ4uuUTJwAKFM9MpKeszvWcXFZYWduVqxOcWIJHx9NV2aZO1CoVBxnx9gPkrAz101TkXj04RtUtFhSejLDtewYZ0KynikZXyfBcXaOj+LCbu7cuYiKioKPjw9iY2OxY8cOg9smJydDpVJVeZw+fVq28chlsdMRdoCircU4zo6xF2Sz2IW6kTpcskSegVWCXbGMwzNnDpCYCBQXW81iB7CwcwYUFXYrV67E5MmTMWPGDBw+fBg9e/bEwIEDkVZDI7ozZ84gIyOj4tG8eXPZxiRXjF2VGCGpkvCFC+YduBpatqSljPqWYczC4uSJ8vkTMrIfPfnqK0WKzUnC7upVKnvCMA7FrVvAu+8CH3wAfPyxVS12krVbARsFYyUUFXafffYZXnrpJYwdOxatWrXC7Nmz0ahRI8ybN6/a/UJDQ1G/fv2Kh7uM0aKWZsUatNhJZjUFCs61akXLU6dkPzTDmIRcFru6z/YHAgPpRmjzZnkGp0X9+hQhUVbGDc1dHXvzGlXLxInA668Dd+4ACQm07qefrGqxU9BGwVgJxYRdUVERDh48iP79++us79+/P3bv3l3tvjExMQgPD0e/fv2wdetWWcelmMXuhRfIpLZwodljM4Qk7E6f5kr6jG2xRNjdv6/J7A6J9ANGj6YXc+fKMzgtVCqOs2Ps02tkkLw8YPFi4IsvgLt3qb+ySgUcO4arl8nsbA2LHQs7x0cxYZednY3S0lKEhYXprA8LC0NmZqbefcLDw7FgwQKsWrUKq1evRnR0NPr164ft27cbPI9arUZubq7OozoUi7ELD6csB6mZpow88ACN+949TXYUw9gCS4SddFPk6Qn4+wN49VVa8dtvipjVJGHHmbGuiz16jQyyZg1QWEjen9hYsh506wYB62XFAhphl5lJN2OM46F48oSqUqdvIUSVdRLR0dEYN24cOnbsiLi4OMydOxeDBw/GrFmzDB4/KSkJgYGBFY9GUsl5AyhS7kRhPD2BZs3oObtjXQ97ciVZIuwq3LB1yRCBli2Bvn3JDL1hgyzj00aKs+NYIdfEWl4jU40LBvnuO1r+/e/lEwTA4MG4gzooKPYEoCm+oCTBwVRiC+C546goJuxCQkLg7u5exTqXlZVVxYpXHd26dcO5c+cMvp+QkICcnJyKR3p6erXHU6TcicS8ecCYMcDx4+YdvBo4zs41sTdXkiXC7uZNWoZoN534z3+AI0fI7SQz0keu5ueDcWKs5TUy1bigl5s3gT//pOfPPadZP3gwroH8r3XrCvj6mn5oc2B3rGOjmLDz8vJCbGwsNlcKjN68eTO6d+9u9HEOHz6M8PBwg+97e3sjICBA51EdilrsVq0CvvkGOHTIvINXAws718TeXEmWCLsbN2ip0xKpUyegfXuLx6UPBfOZGAdCaa+RqcYFvRw8SJbr6GiNewYA2rfHlcheAIBG9c28aJkBCzvHRlFXbHx8PBYtWoSvv/4ap06dwptvvom0tDSMHz8eAE2I559/vmL72bNnY+3atTh37hxOnjyJhIQErFq1ChMnTpRtTHIlT+i12HFmLCMj9piAZImwk4wkBntdZmXJmh0kTcdz5zjpyBWxltfIVOOCXk6coGW7drrrVSpcjP8CANA02tP045oJCzvHxkPJg48cORK3bt3Chx9+iIyMDLRt2xbr169H4/IKiBkZGToupaKiIkyZMgXXrl2Dr68v2rRpg99//x2DBg2SbUyWlDspK6MsdICFHaM8lriSYmNjoVar8e2336Jfv35ITk5Gr1699O6jVquh1lJq1cUIKSbs3ngDmD8fWLcOeOwx0w+uhyZN6EauoICCz83xkDGOi7bXaNiwYRXrN2/ejCeeeMLo49TkNZIFPz+gdWsgJqbKWxcuknVRElvWgIWdY6OosAOACRMmYMKECXrfW7p0qc7rqVOnYurUqYqOxxKL3d271LMVsL6wk9qK3bxJVkNrJm8wtsVUV1K09GUBEBcXh/T0dMyaNcugsEtKSkJiYqJRY5GSvmUXdu7u1Inis89kE3aentQQ5uxZstqxsHM94uPjMWrUKHTq1AlxcXFYsGBBFa/RtWvXsGzZMgDkNWrSpAnatGmDoqIiLF++HKtWrcKqVauUHeiECfTQg5TA0DTwFqCurbm7UhAWdo6Ny/aKNUfYSfF1tWsbqGqioO+ndm3NhYk7ULgG9piApJjFbtIkwM2NihUfO2b6wQ3AcXauzciRIzF79mx8+OGH6NChA7Zv326U16hdu3bo2bMndu7cid9//x3Dhw+31UeoEFcPvPMMxeJZAUnYXb5sftgSYztcVtiZkxVbY6mTyr4fmWF3rGthjwlIigm7Jk2Ap5+m5599ZvrBDcDCjpkwYQIuX74MtVqNgwcP6liuly5diuTk5IrXU6dOxfnz51FQUIDbt29jx44dsoYC6aWkxKAhoKxMU2C7KS5SBrkVaNCA5npJCWBOLghjW1xW2JlzF1Jt4oR08AceoBpEClRFZWHnethbApKiyRNvvUXL778Hrl83/QR6YGHH2D3r1gEBAdS9qBKZmVSz2F1VikikWU3Yublp6kCyO9bxUDzGzt6QwxVbbXzb5s1AvXrUqFJmWNi5HvaWgGSusFOrNfPHoLDr0gXo0QPYuRP43/+ApCSzxynBwo6xe06coLZCeuJmJVEVWa8AnlklVhN2ANkoTp+mMTzyiNVOy8iAywk7KSu2tJQSIQzEoOulRosdoGiEduvWtJQxBIlxAOwpAclcYSfVsPP0rGH+TJlCwu6bb4B//UtzJ2YmkrC7eBEoLqbzM4xdIRW0b9u2yltS4sQDzdyArPJtS0osnhfGwAkUjovLumIB0+PsbNFOTJuYGBKi165p3FoMY00kYVdUZNp+2m7Yam+mhgwB5syhuxcZLl4REVRJorRUE6vEMHaFVMPuwQervCWJqqZtfIFatcgvayXzMws7x8WlhZ2p7lijLHY3bgDjxtEFSmZq19a4Y1NSZD88w9SIuRa7GuPrJNzcKENWp++Y+ahU7I5l7JiCAk3Pu2otdipNhxYruWMlYXf+vFVOx8iISws7Uy12WVm0rFevmo38/IBFi4DfftOY+GSkUydasrBjbIHiwq4y9++buENVWNgxdsupU5T6Ghysd3JUWOyagnrITp2qubtXGO15Y25vdcY2uLSwM9ViJ8UJVVtCzN+/fBZCkWC4zp1peeCA7IdmmBqxmrA7ehTo2RN48knTTqQHFnaM3aLthtUTo1BhsXsAwGuvAR9/rLc7hRI0bUo5gIWFHMbgaLCwMwGjhB2g6fengLDTtthJXTAYxlpYTdgFBgK7d1OW+cmTpp2sEizsGLulXj1g6FC9aaf5+RovkWQrsCbu7kDLlvTcwinIWBmXE3ZuWp9YcWF39KhpJzCC9u1JnGZlAVevyn54hqkWqwm7Jk001rq5c007WSUkYcdlghi7Y+BAqmP3zjtV3pKsdXXr0n0OACA7G/jzTyAnxyrDa9OGlizsHAuXE3aAebXsioqAO3fouS0tdr6+mhhbdscy1saqMXZSiZdvvwXy8kw7oRZSmaDMTE0CFMPYOxU9YrWtdT17Ao8+Cuzfb5UxSMJO8hgzjgELOyORTOIeHkCdOjVsLGUvnTihSNQpJ1AwtkISdqWlpn21zRJ2Dz8MREeTqPvuOxN21MXfHyiv58yWB8Z+KC2liWEgpqaiR+wDWiulxInUVGXHVo5kROB541i4tLAz5cIkuWFDQ3XduXpp2pRqk4SHa3aUESmBgoUdY20kYQcYb7UTQiPsqmlZWxWVCihvnYZ58ywKKpUuUGx5YOyGS5doQjRooPe7feYMLZs101pp5fZDksXu9GnzujUxtsGlhZ0pX1Sj4+sAUn43bpAtPSLC5PHVBCdQMLbCHGGXl0flugAj5482o0dT/MGxY5RMYSZseWDsDkm51aunNyNWCtGWInsAaOIKrGSxa9KEKngVFXGhYkeChZ2RmCTsAJoNCtG2LV1g79zhTD/Gunh4aK5Bxgq7jAxaBgSYMS3q1KHWYitWaEzVZsAWO8bukIRddHSVt0pLNZ3GpMgeAFa32Lm5aU7JN0WOg0sKO6lfrKLCTkG8vIBu3eh5crJNh8K4GCoVff8A44Wd2cWJJd56C3jmGc2JzUA7CJyt3IxdUI2wO3+erNx+fpVi7Fq2pEmYnQ3cvGmVYXJmrOPhksLOKha7ixeBvn2Bjh1NGpuxPPwwLbdsUeTwDGMQUzNjLRZ2MtCyJVkfbt9WJOyVYUynGmEnuWEffFBjiABASk/KBLJynB0LO8eBhZ2RmCzsgoPJnHb4sCJ3VpKw27qVOtIwjLWwibDLyQH+7/+AYcPMMrn5+mqC0Nkdy9gFRgg7HTesREICsGBBpawK5eD4VMeDhZ2RSBcno4VdUJDmVmfnTuNPZCRdutDN282bPOEY62ITYVdWBiQmAmvXmp0OzjW5GLshN1czMUwVdi+/DIwbp0hinj6keXPmDFBcbJVTMhbi0sLOnHInJsXY9exJyx07TNjJOLy8NIdndyxjTUwVdunptGzQwIKT1qkDPP00PV+40KxDsOWBsRuKioA33wSefZayiipRrbCzMpGRVL2ruFhjZGTsG5cWdoonT/TqRcvt203YyXg4zo6xBaYKu8uXadmkiYUnHjuWlitWUCNNE+HMWMZuCAkBPvsM+P77Km/duqVpF6lT6kSiqAjYtQtYvlzZMZajUmlCxbnbkWPgksLO1KzY4mJNKyKzLHaHD5PpXWYkYZeczMUjGethrrCLirLwxL16Ac2bk6hbudLk3bWDwDkzlrFXJGtd06bUNaUKBQVAjx7AqFGKXFf00aULLa3UyYyxEMWF3dy5cxEVFQUfHx/ExsZiRw1uyW3btiE2NhY+Pj5o2rQp5s+fL/uYTLXYSbkPbm7UkNloGjakq1lZGbBnj0ljNIaYGGoOnZsLHP7mGLBsGfXVXLMGOHhQFrWnVlO9vOvXqUDl8ePAtWsyDJ5xWCRhV1RU87ZqNX13ABksdiqVxmq3aJHJu7doAXh6UsFkSWwyjE04e9Zg4+Ia3bCBgZoWLlbKjO3alZb79mmtzMmhi6MxPwSMVVFU2K1cuRKTJ0/GjBkzcPjwYfTs2RMDBw5EWlqa3u0vXbqEQYMGoWfPnjh8+DCmT5+OSZMmYdWqVbKOy1RhJ7lh69WrlHpuDIMHAwMG6Jbslwn3rX+ij+cuAMCGsT9Rlf7nnweGD6f2FHv3mnVcISjf48knKUEjOJjio5o1I9dAw4ZAXBzwxReajgKM62CKxS49nb5Pfn7kfbKY0aNpAu/da7JP1dMT6NCBnitwn8UwxiEE8MgjNCE2barytlHxdVIHCisFjEoWu2PHgIIjZ4DnniMrR2go/SA0bQp8/LFBscpYF0WF3WeffYaXXnoJY8eORatWrTB79mw0atQI8+bN07v9/PnzERkZidmzZ6NVq1YYO3YsXnzxRcyaNUvWcZkr7MwqTvy//wEbNgB9+pixcw3s3Iknssly8ZPHc+Sb7d+fqhfXr69bqT8xkSbj1q3V+qHu3gUef5y8yOvWaUqpuLlRAK3UK3fvXuD116nO0p9/yv/RlKKwELh8sQxFGbcoEnjPHuD33ynWxYKWVa6EKcJOO75OT9ck0wkLA0aOJDeUp6fJu/foQUsF8pkYxjj27aM7ntq1NeE6Whw5QstqhZ2VO1A0akSXlNJS4NCOexTnqp19eOkSMG0abSizIYYxHQ+lDlxUVISDBw9i2rRpOuv79++P3QYuoHv27EH//v111g0YMACLFy9GcXExPM34IdeHqVmx9tR1Amq15so6fjyevD0Pr8wXOF7cCqe//AstW5ZvJ4TmSlpWRq6rq1dpQkZFkch79lm68yvf7sIFEnWnT1PW7ejRwOTJ5MLy0PqmZGQAP/0EfPKJwIULKjz6KNA3+jqGNz2CfsGH0RhX4Ke+QzXHnnuOdsrMBCZMoHO5udFF2cuLHt7eJHyfeoq2LSoil3JwMN0V1qmDQp8gHDhfB3sO++DEaXeUlKggBFBWJlBWXAr1vVLcyytFQX4ZytRFQHExAlV5qNfQG0VhjZCeDly5VIqMG+4A3OAJfzyIy3gA6QjCXYQiCy163kf0J93RsiV5Oxj9mCvsZOPbb81WiT17Av/9Lws7xoZI8aFDh1KBRS1u3NBY7CT3p16sXDVYpSKr3S+/APuKYvDQjBn0e92uHVkDfv0V+Pxz4Ny5GgZuHFlZwL17pH3r1NG9/jBGIBTi2rVrAoDYtWuXzvqZM2eKFi1a6N2nefPmYubMmTrrdu3aJQCI69ev692nsLBQ5OTkVDzS09MFAJGTk2NwbA8/LAQgxIoVxn2Wjz+m7f/xD+O218v160JkZlpwACHE558L0bu3EMXFOqsHDqTxffihgf3KyoTYv1+Il18WonZt2lh6REYK8Z//iH37hAgJoVUNIkrFoV33hcjIECI1VYjNm4X4+msh3nlHiI0bKw6bu+WAeB1zhAqlOocEhAjHNfF824Pip5+EyMsTQpw7J6pspP2YNEkIIURBgRBbfr4lPsbbIhHvigTMFI9gk/DB/Wp3N+XhjuJq3x89uuqfMCcnp8bvlbNQ02d9+mn6O33xRc3HmjGDtp0wQeZBmsmNG5r/861bth6Na2GrOfTll1+KJk2aCG9vb9GxY0exffv2ardPTk4WHTt2FN7e3iIqKkrMmzfPpPNV+zlLS4Vo0IC+gOvWVXl76VJ6q2PHGk6yfbvm99sa/PyzmJmQJwAhRo40sE1ZmRBnz+qu++knIe7fN+oUN24I8dFHQnTqpPt77O8vxIsv0kcuK7PsYzgypswfxXWwqtKdtRCiyrqatte3XiIpKQmJiYkmjcmqrlgAmDIF+PRT8l1+/rl5x1iwAJg0iZ7/8QcwZEjFW3/7G6368Ufg3Xf17KtSkVu2c2dKsf/1V+C774DNm4G0NGze6YthiXSHFNuuCL8ca4KIhzL0j2PyZHL3AvBvE4nPAx/B5PobsFr1FNbe6Y2jdxohv8gbGYjAshMRWDaC4queGBSJuL/tgAoCeQUeOJsZgCu3a8PfsxBhPrnIPdwA5ztR2JRaHQzgP1VOXR8Z6I7diO3iAb9nnyDjn7oA7v98C54oRi3vUvjWcoN7cCBQpw7u1G6ErPrt4NklBo0aAZGNBKKKz6LuA0G4nBuMQ8c9cf26Jjnk7FnyzuqpF8poYXOLncTx4xTm8PbbRu8SGkr/3zNnqGKE1jRinBApznvu3Ll46KGH8NVXX2HgwIFITU1FZGRkle2lOO9x48Zh+fLl2LVrFyZMmIB69erhKcmjYAl79lD2WUAAxV5X4o8/aDloUA3HkSx2aWmUDaQ3fVYmLlwAnnsOXeo9C2CpbgKFNioVZa1LbNgAjBhBE27pUk2D80rcu0dW9P/8hz6KdCgfH4rhzssDvv6aHs2aAS++CLz0Es1lxgBKqUu1Wi3c3d3F6tWrddZPmjRJ9OrVS+8+PXv2FJPKLTcSq1evFh4eHqKoqEjvPuZY7CQL15Ilxn2Wv/+dtv/Pf4zbvgp//EEHqFdPCAOfo1q++04IlYqO8fbbVW5bbt8WwtOT3k5NNeG49+6Jb946Kjw9yOL26KNC5B04pblVUqmECAwUonVrIQYMEGL8eCHWrKn2kGVlQty5I8TWrULExwvRtKnpFrXwcLorHD9eiIkTyVB5KrVMlN0voA97967uCfPyhCgpMeGDV4++u0K22Gl48UX6P/373zUf66GHaNsff5R5kNnZQnh40MGPHTNp17FjNVOJsR62mENdunQR48eP11nXsmVLMW3aNL3bT506VbRs2VJn3SuvvCK6detm9Dmr/ZyTJokCeAvx/PNV3iouFiIoiL6bu3cbcaIFC4TYskUItdrosZnF0KFCAOJu76FCpSoTAFnXamTzZvoxB4Rwc6MJl5+vs8mpU0K0aKH57e/YUYiFCzXOreJistS9+KKus6l2bSH+9S8h7l27I8ShQ2T9XLJE98d7yxYhvvxSiG+/pWvw/v1CXLhAF6jSUrP/HGVlVXcvKyNv05079CgsLB9KcbEQaWmieG+KyFrxp7j0+S/i3L9/FJc/WCJKPp5FG0v88Qf9ja5d03teU+aPYsJOCJpUr776qs66Vq1aVTupWrVqpbNu/Pjx8k2qcoYMoS/HwoXGHfORR2j7b74xehi6FBcLERpKB/ntN9P23bFDCC8v2vf11w3aogcNok0++MD4IU2erJkof/sbfRmFEPQkL08Wu3dZmRD79pHI+9vfhBgxglzaiYk03+bNozHPmiXE2rVCnDljn+Z2Wwo7u3IlCSFefZW+M++/X/OxIiJo2/37TRqCcUg+4Uq/MTUhubvi4hQYUzllZUJcuSLEqlVCbNpk5IXQybH2HLI348KZ02XiMZ8t4iHs0Hsd2LGDvpfBwbLep1qGZJTw8BDi5EnRqhW9/PVXI/e/dYt+8KULTYMG9MNfWip++YXcrNLq77+vXm/l5Qmx5L0LIjbimuZwSBfL8A9RinLDh/bffNy46i0Ily9rtp09W4gePYR45BFRNvhxcW7gRLGlf5L468nPxboR34oZb+aLfv2EeOABIXx9yBDi6V4qankXCU/3Er2HV6mE8HYvErWQp/d9LxSKlk0LRVwcaYzh0cfFWCwQb4/OFOfOVf38diPsfvjhB+Hp6SkWL14sUlNTxeTJk0WtWrXE5fI/6LRp08SoUaMqtr948aLw8/MTb775pkhNTRWLFy8Wnp6e4ueffzb6nMZ8+GHD6A9r7PXuwQdp+w0bjB5GVd54gw7yzDPG73Phgibwbfjwar/133xDmwUFCZGWVv1hS0qEePJJzRfsvfcsuoFxCWwl7KQ5tHDhQpGamireeOMNUatWLXHlyhW920tz6I033hCpqali4cKFss8h6YbAwP1ZBYWFmu9YVpbRpzeev/7S3L7n5hq924ULtJunp9HhP0ZTUiLE//4nRKNGVX/IGzSgefd//0fhq66GteeQteK833//fQGgyqPy57x+XQhPT7J47dtZVSQmJND35LnnTPmUCqJWa8xpb74phBBizBh6+dZbJh5r3TohmjSpmAyb+84Ubm70smdPA+HnxcVCHD6se3EaM0aUQiVWYKRojEsVc6uT30kxu9V8cWr3bY0onjuXrpv9+gnRoYMQDRsK4edXMYZ7V2+LQ4eEWL1aiE/jfhSvYJ7ogy0iCLdN9jIZ+/B1KxABHvnCy62o2u127qz657AbYScEWRsaN24svLy8RMeOHcW2bdsq3hs9erTo3bu3zvbJyckiJiZGeHl5iSZNmshubRCCrEaAccHfQmi01ZEjJg1Fl5QUOoiPj+5dhSFKS8kuDQgRG1vFhF2ZoiIhOnemzXv3rv6Ob8oU2s7bmywKTM3YStjZnStJCPHPf+r81hvk7Fnazs9PIStsWZkQ0dF0krlzTdpN8hBt3SrfcI4d08xBQAh3d7qetGihiaSQHj4+JJAtzadyJGwl7HZX8mt+9NFHIjo6Wu8+zZs3F/+uFGOwc+dOAUBkGFDjpoQDPf+84fv79u3pveXLjft84sYNuqNftMjIHUxEshaEhlaEv/z8M61q3NiMOV1QIERSkrhUu62oW7tAAEI8+6wQ6oPHhXjqKSFeeomyrEaMIHO6JMIOHdIcY/VqitOZM0cUbN0jkj4orJIP6OYmRFgYXTafeYYE88yZ5BWaNk2IUc+ViPZtioS7e5lBYeXlUSKi62WL1iGZokNImhjz9yLx1VdkVb3w7hKR1fVxkd71KXGx27Mi/ZEx4sbw8SLn5Smi8J1/icILV8WdO3TzduVsoTh/tlRkZenmPJaUCHHpEnmrV68mI+YXX5B7OT5eiKtXq/757ErYWRtjPvyzz9I/b/bsmo+Xn6/5Z2u7w02mrEyIli3pQMYG9+3eLURMjEGfe2XOnROiVi06xb/+pX+bRYs0n8fYrGDGNsLOWq6kytT0Wd97j74/NWW6btpE27VubdRpzWP2bDpJq1YmXWlGjqTdpk+XZxgrVgjh60vHDAig0J579zTv5+VRrNCsWUJ07aqZg0FBVUODlKKsjLxPGzZQ2MNvv9Fj9Woa/+LFdHH58ksK31q2jEJqf/mFXicmUvL6889T7OvChWRZSE0la1RN7kNndcVWprrPefiwRvRre1ZOntS4727eNOo0Gt+tEpmxZWV07QGESEqqWH3vnkZvmRNecf++EDHtSyrsFQUFQog5cwybrgIChPjhh2qPmZFB8e/9+mmilox9hIQI0aULackZM+g7f+iQ8mGL5mBXWbH2iClZsVJWX2AgEBRkwUlVKiqqOmMGZaWOGVPzPnFx1BrMyJpdzZpRN4gXXqDs2CNHgNmzgYgI+hwzZgA//EDbvv8+8MwzZn4WxipkZ2ejtLQUYZXSscPCwpCZmal3n8zMTL3bl5SUIDs7G+FSKyIt1Go11Foprrk19J/08pL2q378imbESkhf9lOngI0bgcceM2q3oUOpnNhPPwEffWR+8eSyMuCdd4CkJHo9YABl70VE6G4n1aLt2ROIj6eE9GnTqI30Cy9Qmcl//IPGFR5uWTHn+/eBlBTg9m26fF28SEXEd+3SZB0qgYcH0LChQLNmKmzaJFNBagvw8vJCbGwsNm/ejGHDhlWs37x5M5544gm9+8TFxeHXX3/VWbdp0yZ06tRJljqqHTpQyc7kZPqt/vhjqqcqdcobMsSEDi1S9wklMmPv3aMLyvnzwLhxFav9/KjW6Y8/0tzRroFfE0IA48cDh4+6IyQEWL2aMl/RqxcwZw71gC4ooBZPERFUhLlVK6p7Wg3161Ni/Ntv0zX95k2qZHH5MpXVS0ujOVFYSGVRIyKoNmuXLtRRydbfUyVwSWEntQUzRdjJcnF67TX69Zs8Wf/7ZWXAP/9JhR+l1HATv3WjR9MP+b//TQXAKxcBV6mAiROB994zffiMbbC3kkHGljuxirALCKDaB99/T3VrjGTIELqonDtHN0AxMaafuriYLsjLltHrqVNp3tXUdlCloopBDz9M1Yfef59E165dwKuv0keKigJiY4HevalbRlSU7k9BTg5Ve8nKogtWVhYVFj92jERdcbH+c3t6UkWKgAD6/ROC/p/e3nTR9vGhdcXFdI3Nz6fn4eH0CAmhG9wbN+hcF84L5Nwuwd08d5SUuOHyZVXFZ7QH4uPjMWrUKHTq1AlxcXFYsGAB0tLSMH78eABAQkICrl27hmXl/8Tx48fjiy++QHx8PMaNG4c9e/Zg8eLFWLFihYxjImG3YAHd6//5J1VB8fcnsWc0wcGkajIzgdRUWQoDV1C7Nqm3nJwq1dpHjKC3fv6ZhKmx/+u5c2muuLnRTVVFtZkOHTS9/izEw0PzXZXpkI6J4vZDK2OMuVIqd/DRRzUf74svaNsnn5RxkBLaTvfCQiFGjaKTBQdb6PcV4uhRTakJ6fHII+QKYEzHmV2xppYM+vxz+j6NGFH9+J97jrYzu0yQsUj1BUxk+HAa3z//afopCwo02fXu7pRpay5XrlAR9C5dDLuMgoIofu/BBykGvCYXU0SEEN26CdG9O43zs88oRticaktV0Pa57t8vBCBK4CbS0UDs9OorNv+u349lywLF9hTnXVqqW+JDSiJYsMDkj0b+R4D86FZC2x2bkmLcPjt3aqoTzZql7PicFXbF1oA5rljZrQ7FxWQPfughOviiRXQb7O5ORYwt8vtSp5edO6knsxDkPgsIkGXkjJWwlivJ29sb3pIZzghMtdhFRRl9aPMwc66MHEnuoB9/JFeqKVamiRMposLHh/a3pNBxZCRZ+6ZOJZfRlStkSdy1iyw7R45Q16YDB3T3a9QIaNiQulIFBQEtW5J3Li6uqoXPYi5coA+6di2ZN+fPp/UdOwJt2sA9JgYNH34YDfv0AZrI0/pRLiZMmIAJEybofW/p0qVV1vXu3RuHDh1SbDxubtSaa/p06sddWgr066dxx5pEmzbAX3+RxU4uNm4EmjbVLTashZ8fFVD++Wdyx8bGVn+4K1eA4cPpejtyJFksGYWxgtC0Ksao2okT6c7h3XdrPp5UKsuYRAuT2LhR/2220QWCGGti63In9lQySKoDN2CA4WOUlVE9bkCIAweMPrVllJZSCyMjk43y880LBF+xQhPortVhTzHUagroXruWsuj27LFSO7TsbDLPaqf6ApRSbEa2h6sU+Tblc16/TlmwZv9J5s+veTKaQnGxEPXr0zG3bDG42Y8/0iZ161b/XczN1ZQLa9++vL0kYxacFVvDh5fqcCUk1Hw8qW/d2rUyDlIITf/W8eOpsveKFTL5SRglsHWBYntyJUnCpk8fw8e4elXjppS7VpxBpCJbkycbvYuUHWtsXa4LFzRFVY25MXRYJk7UTTF0c6NYjq++MrsIHws7Bdi9m/4/YWHypFZLBYnr1q02NbSoSIg2bWjT117Tv01xsRCPP07b1K9fc31VpnpY2NXw4aU6bsa0FKpbl7a1qIYd4/C4ykVJiJo/6+rVNCeq69zw66+0Tdu2Cg1SH1J9FR8fo8XH2rWaGLbbt6vf9tYtjfWhRw/dEFmH5/x53dg5qVhhTAy5K2QouOcqc8iqn/P+fapHY6SVukakWmATJ9a46ZYtGs1f+fpYWqoJGff2FmLvXnmG58qY8r2qPo/YSTE2KzYvj2LUAIUz+xjGgZBi7IqKDG8jhSh17Kj8eCp45BHKJi8sBD791KhdHn+cwpTu3gU++cTwdnl5FFd0/DglIn73nSZW12FRqyk9sV8/Km2xebPmvYkTKbjv0CHgjTeASiV0GDvB15cCPCvX1zGHnBxgzRp6Pnp0jZv37UsZsmVlwIQJgFQlqawMeP114Ntv6Vq7cqW8CbtMzbiksDM2eeLKFVrWqVMl45thXBZjkickYWdOGRGzUak0dXzmzqUaIDXg7g7MnEnP58wBMjKqbpOVRQJw3z6qMPHnn1qlGhyRs2ep6FfDhlTMcssW+ttpJww0bAi0b2+7MTLW5+ef6aaoVauaMyLKmTWLkil27wYefJDup9q1o+mnUgHffAMYyPNiFISFXTVYpQ4XwzgYpgg7q1rsACpQ3KULpZe+/75RuwwdSoa++/eBxEQKKpP480/SN9u3U52xjRvJwueQ3L0LPPooEB1NV+TsbKrQ+t579GM3fbqtR8iYw8WL9F3/8EPLjiMVZBw92uiU6shIYMMGysJOSwOmTAFOniRDyNdfA3//u2VDYsyDhV01sLBjmKrUJOyys4H0dHpu9SKhKhWJFoAqwJ44YdQuUueIr74iIffPf5IoffRRqv/apg1ZJTp1UnDsSlBWpnkeGEgfRqUCBg+mmhuXL5OadWgTpIuTmUmibt4884+RkwMcPUrfjeeeM2nXnj0pRGHyZBJ4H3xAXytjmisxyuDoUSJmIQm70tLqt2NhxzBVqUnYHT5MS6nDgdXp2ZO6t1y5YlyxSlCbpw8+oEr6x4/TA6CaY6+8onE5OQy3bpFvecUKipWrVYsu2gsXUpAg/6g5Dx060Bc1M5NiCfS0DayRwEDad88eKpBoIrVqAf/9Lz0Y2+OSwk6q01pYWP12ly7Rkn8DGUZDTcLOJvF1lfn6a2qLVEOfSW3efx+YNAlYupTEaa9eFB9Ur55yw5SdnBwKdPrvf6kfGEDt1qR+n1KrQsZ58POjuLiTJ6m3+OOPm3ccX1/qc8c4PC4p7Jo2peXp09VvZ7XK+QzjQPj40PL+fbJ6V+6NarP4Om0qmwqFMCpuqE4d4M03FRqTkhQWAl9+Sc1qb9+mdR06AO+8A2h1LWGclNhY84VdURFZO+ylwS9jMS4ZYyfF/Zw4YbhZNsCuWIbRR4MGlB1aVATs2FH1fckVa1NhJ1FYSEkBb71l65EoR24u9RObMoVEXatWwKpVpLCfesokqyXjoEiT7eBB0/edOZO+Mz/8IO+YGJvhkjO+SRO6oS8qAk6d0r9Nbq7mxrdxY6sNjWHsHg8PTQmDn3/WfS83l/qcAjZ2xUrs20eZEbNnU/NkZyQggAqFNWgALF5MAYLDh7MFxpWQypOYKuyEoDjMM2dqDjpnHAaXFHYqlcZqd+SI/m2k+LrgYBsFgDOMHfP007RctUo38fK332gZFQWEhFh/XFXo3Rt48UW6gI0ZQzFojs6pU5rkEIkvviBF/eKLVX3jjPMjJVCo1VTWxlgOHKDvja8vF5xzIlxS2AE1CzspTshha1YxjIL066epnrF7t2b955/T0q5KHXz6KZndL1wAXnpJt1CdI3H9OvDyy1QJdvVqip+TqFePLs6Ma1K7NpUruXEDCAoyfr+lS2k5fDgdg3EKXFbYSW4iQ8Juzx5axsVZZTgM41B4e1NhX4CsdgCwfz95Pj09qUSI3RAUBPz4Iw1s1SqN+nQU7t6lOMFmzahcSWkpWVe0hR3DtG1rmrW2sJDcsICd3YkxluKywk7bYqfvBl4SdlwdgGH0I7ljf/6Z3LH/+x+9fuYZO2wt2qWLpn/slCnUUsIRmDcPeOABihMsKAAeeogyVtaupQ4SDFMZIYyzSv/yC900NGpEjV8Zp8FlhV3r1nQDf+cOtULRJjeXMscBttgxjCH69yfvzdWrNE9WrqT1r79u23EZZOJEqqrv7e04geIZGZpM17VrSdT16GHrUTH2ypQpJNQky0R1SG7Y55/nuEwnw2WFnZcXiTugqjt2/3664WnShIq0MwxTFR8f4KOPKEt2/34qHdStG9C5s61HZgCVigoX79sHDBhg69FUpbiYxrd9u2bdW2/RumPHyP3Kma5MdVy9Cly7Rg1ca+Ltt4F//IN6wzJOhcsKO8BwAgW7YRnGON54g64ls2YBQ4Zo3LF2i7e3bkbU0aPA2bO2Gw9AdZcWLiTX6ksvAdOmaVxpgYHACy9o+iAyTHVINywbN9a8bd++wLffUu8/xqlQVNjduXMHo0aNQmBgIAIDAzFq1CjcrSEVe8yYMVCpVDqPbgopLEPCbu9eWrIblmFqJiyMDEu//AJ06mTr0ZjAqVPAI49QSZQTJ6x//oICKlPSrBllu166BISGUikTR3EVM/aFJOwOHACys207FsZmKCrsnnvuORw5cgQbNmzAhg0bcOTIEYwaNarG/R577DFkZGRUPNavX6/I+CRhl5KiqcUlBAs7hnEJ6tYFIiKoZkv37hTDZi2WL6dif6+/DqSnU8zHf/9L4u6tt9hCx5hHRASVwxHC8Pd5zhxgwgTdOoiMU6GYsDt16hQ2bNiARYsWIS4uDnFxcVi4cCF+++03nDlzptp9vb29Ub9+/YpHcHCwImPs1ImKD1+9Cvz+O607e5ZilX18gPbtFTktwzD2QGgosHUr0LMnkJdHPVWnTaMyEEqgnano6Uk1xyIjgblzSdBNnkwN3RnGEiTjycyZ5ObX5v596ic8bx6QnGz1oTHWQTFht2fPHgQGBqJr164V67p164bAwEDs1q5oqofk5GSEhoaiRYsWGDduHLKysgxuq1arkZubq/Mwltq1gVdfpedJSfS7K3Udio2lBAuGYZyY4GDgr78oWBAAPv4YaNcO2LxZnuMXFwPr1lHRP6ncCkDu1hUrgPPn6UfIx0ee8zHMa6+RBfjyZWDRIt33FiwAsrIoM/C552wxOsYKKCbsMjMzERoaWmV9aGgoMjMzDe43cOBAfPfdd9iyZQs+/fRTHDhwAA8//DDUarXe7ZOSkipi+AIDA9GoUSOTxvnGGxRPvWcPZX9Pm0bruawPw7gInp7US/ann4DwcGqxZImwy8uj3mrjxlH/1iefBH79lTJLpJgPDw8q+OfpKccnYBgNfn7Av/5FpU/+9jfN+i1bNBe4hAT+7jkxJgdyfPDBB0hMTKx2mwMHDgAAVHpS84UQetdLjBw5suJ527Zt0alTJzRu3Bi///47hg8fXmX7hIQExMfHV7zOzc01SdyFh1PR7a++ojaLAFnr/vlPow/BMIwz8PTTwKOPUoqv9g/A118Da9ZQceBmzahOmK8v1f7Ky9NNnx8xgrbVTn4IDaWSEi++SP08GUZpxo7VfZ2UBHzwAblmn3xSc7FjnBKThd3EiRPxzDPPVLtNkyZNcOzYMdy4caPKezdv3kSYCWXpw8PD0bhxY5w7d07v+97e3vD29jb6ePp4+22qNlBWBjRtSvF23DaPYVyQwECydmizZg1Z4H77Tf8+arUmbqN2bRJ1TZoAgwdT3F6vXmwdsQF37tzBpEmT8MsvvwAAhg4div/9738IqqaX6pgxY/DNN9/orOvatSv2Shl1jsitW9SSDqAmzytWcHKOk2PyfzckJAQhISE1bhcXF4ecnBzs378fXbp0AQDs27cPOTk56N69u9Hnu3XrFtLT0xEeHm7qUI3mgQfIMv3HH8APP9hhOySGYWzHv/9NCRbHjgEXLlA3CLWa4ucCAshqV7cubfvOO0BiIiVFMDblueeew9WrV7GhvFjvyy+/jFGjRuHXX3+tdr/HHnsMS5YsqXjt5ejB1mlp1Ec2MpLaw3A8p9OjEsKYpnLmMXDgQFy/fh1fffUVAJpYjRs31plYLVu2RFJSEoYNG4b8/Hx88MEHeOqppxAeHo7Lly9j+vTpSEtLw6lTp+Dv71/jOXNzcxEYGIicnBwEBAQo9dEYF8OVvleu9FkZ62HN79WpU6fQunVr7N27tyKBb+/evYiLi8Pp06cRbaDP7pgxY3D37l2staD0Dc8fRglM+V4pGvDx3Xff4cEHH0T//v3Rv39/tGvXDt9++63ONmfOnEFOTg4AwN3dHcePH8cTTzyBFi1aYPTo0WjRogX27NljlKhjGIZhGGtVZQAsq8zAMEqgqKM9ODgYy5cvr3YbbYOhr68vNhrTCoVhXACOEWIY87CkKsOIESPQuHFjXLp0Ce+++y4efvhhHDx40GAsd1JSUo0JhQxjTThFi2HsFHvv3MIw1uaDDz6o0nKy8iMlJQWA+VUZBg8ejLZt22LIkCH4448/cPbsWfwuVbDXQ0JCAnJycioe6enpln9QhrEATo1hGDtE6tyiHSO0cOFCxMXF4cyZMwZjhABN5xaGcTbsrSoDIE9lBoaRExZ2DGOH1BQjVJ2wk2KEgoKC0Lt3b8ycOVOvW0pCrVbrFADnGCHGXnHGqgwMIzfsimUYO8RanVsAy7u3MIy90apVKzz22GMYN24c9u7di71792LcuHF4/PHHdW6KWrZsiTVr1gAA8vPzMWXKFOzZsweXL19GcnIyhgwZgpCQEAwbNsxWH4VhTMbpLHZSMgZbHRg5kb5PllYHsrfOLUDV7i05OTmIjIzkOcTIilxzyFi+++47TJo0Cf379wdAyUdffPGFzjb6qjIsW7YMd+/eRXh4OPr27YuVK1eaVJWBr0GMEpgyf5xO2OXl5QEAWx0YRcjLy0NgYKDZ+ztCjJD0A8JziFECS+eQsdiqKgNfgxglMWb+OJ2wi4iIQHp6Ovz9/atYNqQ+sunp6U5dOJI/p/wIIZCXl4eIiAiLjuMIMUKuPodc4TMC1v+ccs0he8fV5w/gGp/TnuePop0n7A1XqQjOn9M5sEXnlppw9r854BqfEXCdz2lPuMrf3BU+pz1/Rk6eYBg7hTu3MAzDMKbidK5YhnEWuHMLwzAMYyouZbHz9vbG+++/7/TFJPlzMkrhCn9zV/iMgOt8TnvCVf7mrvA57fkzulSMHcMwDMMwjDPjUhY7hmEYhmEYZ4aFHcMwDMMwjJPAwo5hGIZhGMZJcDphN3fuXERFRcHHxwexsbHYsWNHtdtv27YNsbGx8PHxQdOmTTF//nwrjdQ8kpKS0LlzZ/j7+yM0NBRPPvkkzpw5U+0+ycnJUKlUVR6nT5+20qhN54MPPqgy3vr161e7j6P9L+0Rnj9V4fnDmALPoao42hxy+PkjnIgffvhBeHp6ioULF4rU1FTxxhtviFq1aokrV67o3f7ixYvCz89PvPHGGyI1NVUsXLhQeHp6ip9//tnKIzeeAQMGiCVLlogTJ06II0eOiMGDB4vIyEiRn59vcJ+tW7cKAOLMmTMiIyOj4lFSUmLFkZvG+++/L9q0aaMz3qysLIPbO+L/0t7g+aMfnj+MsfAc0o+jzSFHnz9OJey6dOkixo8fr7OuZcuWYtq0aXq3nzp1qmjZsqXOuldeeUV069ZNsTHKTVZWlgAgtm3bZnAbaVLduXPHegOzkPfff1+0b9/e6O2d4X9pa3j+6IfnD2MsPIf042hzyNHnj9O4YouKinDw4EH0799fZ33//v2xe/duvfvs2bOnyvYDBgxASkoKiouLFRurnEhdB4KDg2vcNiYmBuHh4ejXrx+2bt2q9NAs5ty5c4iIiEBUVBSeeeYZXLx40eC2zvC/tCU8f3j+OPr/0tbwHHKuOeTI88dphF12djZKS0sRFhamsz4sLAyZmZl698nMzNS7fUlJCbKzsxUbq1wIIRAfH48ePXqgbdu2BrcLDw/HggULsGrVKqxevRrR0dHo168ftm/fbsXRmkbXrl2xbNkybNy4EQsXLkRmZia6d++OW7du6d3e0f+XtobnD88fR/5f2gM8h5xnDjn6/HG6lmIqlUrntRCiyrqatte33h6ZOHEijh07hp07d1a7XXR0NKKjoytex8XFIT09HbNmzUKvXr2UHqZZDBw4sOL5gw8+iLi4ODzwwAP45ptvEB8fr3cfR/5f2gs8f6rC88f+/5f2BM+hqjjaHHL0+eM0FruQkBC4u7tXuTPKysqqoqQl6tevr3d7Dw8P1K1bV7GxysHrr7+OX375BVu3bkXDhg1N3r9bt244d+6cAiNThlq1auHBBx80OGZH/l/aAzx/TIPnD1MZnkOm4UhzyNHmj9MIOy8vL8TGxmLz5s066zdv3ozu3bvr3ScuLq7K9ps2bUKnTp3g6emp2FgtQQiBiRMnYvXq1diyZQuioqLMOs7hw4cRHh4u8+iUQ61W49SpUwbH7Ij/S3uC549p8PxhKsNzyDQcaQ453PyxQcKGYkip5osXLxapqali8uTJolatWuLy5ctCCCGmTZsmRo0aVbG9lKL85ptvitTUVLF48WK7TzV/9dVXRWBgoEhOTtZJxb5//37FNpU/53//+1+xZs0acfbsWXHixAkxbdo0AUCsWrXKFh/BKN566y2RnJwsLl68KPbu3Ssef/xx4e/v71T/S3uD5w/B88cx/pf2CM8hwtHnkKPPH6cSdkII8eWXX4rGjRsLLy8v0bFjR50U7NGjR4vevXvrbJ+cnCxiYmKEl5eXaNKkiZg3b56VR2waAPQ+lixZUrFN5c/58ccfiwceeED4+PiIOnXqiB49eojff//d+oM3gZEjR4rw8HDh6ekpIiIixPDhw8XJkycr3neG/6U9wvOH54+j/C/tFZ5Djj+HHH3+qIQoj/BjGIZhGIZhHBqnibFjGIZhGIZxdVjYMQzDMAzDOAks7BiGYRiGYZwEFnYMwzAMwzBOAgs7hmEYhmEYJ4GFHcMwDMMwjJPAwo5hGIZhGMZJYGHHMAzDMAzjJLCwYxiGYRiGcRJY2DEMwzAMwzgJLOwYhmEYhmGcBBZ2DMMwDMMwTgILO4ZhGIZhGCeBhR3DMAzDMIyTwMKOYRiGYRjGSWBhxzAMwzAM4ySwsGMYhmEYhnESPGw9ALkpKyvD9evX4e/vD5VKZevhME6CEAJ5eXmIiIiAm5tz3w/xHGKUwFXmEM8fRglMmT9OJ+yuX7+ORo0a2XoYjJOSnp6Ohg0b2noYisJziFESZ59DPH8YJTFm/tidsEtKSsLq1atx+vRp+Pr6onv37vj4448RHR1t1P7+/v4A6MMHBAQoOVTGhcjNzUWjRo0qvl/ODM8hRglcZQ7x/GGUwJT5Y3fCbtu2bXjttdfQuXNnlJSUYMaMGejfvz9SU1NRq1atGveXTN8BAQE8qRjZcQXXCs8hRkmcfQ7x/GGUxJj5Y3fCbsOGDTqvlyxZgtDQUBw8eBC9evWy0agYhmEYhmHsH7uPYM3JyQEABAcH23gkDMMwDMMw9o3dWey0EUIgPj4ePXr0QNu2bfVuo1aroVarK17n5uZaa3gMwzAMwzB2hV0Lu4kTJ+LYsWPYuXOnwW2SkpKQmJhoxVE5L0IIlJSUoLS01NZDsQmenp5wd3e39TAYB8XV54+7uzs8PDycPoaOUY7S0lIUFxfbehg2Qc75Y7fC7vXXX8cvv/yC7du3V5vam5CQgPj4+IrXUuaItTlyBFiyBHjjDaBpU6uf3mKKioqQkZGB+/fv23ooNkOlUqFhw4aoXbu2rYficqjVQGIiMHQo0K2brUdjOjx/CD8/P4SHh8PLy8vWQ3EMbtwA/u//gFdeAVq2tPVobEp+fj6uXr0KIYSth2Iz5Jo/difshBB4/fXXsWbNGiQnJyMqKqra7b29veHt7W2l0Rlmxgxg/Xrgm2+ApUuBJ5+09YiMp6ysDJcuXYK7uzsiIiLg5eXlcnfdQgjcvHkTV69eRfPmzdlyZ2W+/x5ISqLlhQuAI/35ef7Q/CkqKsLNmzdx6dIlNG/e3KmLEMvG3/8O/PUX8Msv9MV3UUpLS3H16lX4+fmhXr16PH8snD92J+xee+01fP/991i3bh38/f2RmZkJAAgMDISvr6+NR6cfIYD9++l5Tg4wbBjw6aeAliHRrikqKkJZWRkaNWoEPz8/Ww/HZtSrVw+XL19GcXExCzsrs2sXLa9cAX7/nSx3jgLPH8LX1xeenp64cuUKioqK4OPjY+sh2T9//UXLixdtOw4bU1xcDCEE6tWrZ7fXeaWRc/7Y3S3VvHnzkJOTgz59+iA8PLzisXLlSlsPzSBpaUB2NuDhAUyaROsSEoDz5207LlNx9TtsV7tLtCf27NE8/+IL243DElx9/gDO8TdISkpC586d4e/vj9DQUDz55JM4c+aMrYflErj6b7Bc88fuZqEQQu9jzJgxth6aQQ4coOWDDwKzZwMDBgBFRcDkybYcFcM4BnfvAqmp9FylAjZvBvg6ytgKqUj+3r17sXnzZpSUlKB///64d++e/CcbO5aWTt6Ng7EudifsHJGUFFp27kwXpjlzAE9Pcin9+qttx8Yw9o4UxtC0KfD44/R87lzbjYdxbTZs2IAxY8agTZs2aN++PZYsWYK0tDQcPHhQ/pO9+SYFlDZoIP+xGZeFhZ0MSMKuUydaRkdr4usmTwZKSmwyLIZxCCQ3bFwcMHEiPV+6FCgstNmQGKaCmorkq9Vq5Obm6jyMplUroLgYOHVKjqEyDAAWdhZTVqZrsZN45x2gbl2Kif3zT9uMzRVYsWIFfHx8cO3atYp1Y8eORbt27Sp+kBn7RlvYPfIIEBYG5OZq5hWjHDx/qseYIvlJSUkIDAyseBhdbuvQIWDHDopFYBwWe5xDLOws5MIFyoT18QHatNGsr12bMtkBsj4wyvDMM88gOjoaSUlJAIDExERs3LgRf/zxBwIDA208OqYmysqAvXvpeVwc4OYG9OhBr6upS87IBM+f6pGK5K9YscLgNgkJCcjJyal4pKenG3fwTz8FevcGvvpKptEytsAe55DdlTtxNKTEiQ4dKK5OmzFjgM8/B9auBe7cAerUsfLgLKW6YGF3d1Kzxmzr5gZop7Ab2rZWLdPGB8qimjlzJp5++mlERERgzpw52LFjBxo0aIC8vDw8/PDDKC4uRmlpKSZNmoRx48aZfA5GOU6fphsjPz+gXTta16MHsGoVGTOmTbPt+CzCweePxP3799GqVSuMGDECs2bNMvkcjoqxRfLNrqUqZQzNnQts2AD8979ATIyZo3VSnGAOeXh4VFh7O3XqhEWLFpl8DpMRTkZOTo4AIHJycqxyvjffFAIQYuLEqu+VlQnRrh29P2+eVYZjFgUFBSI1NVUUFBTovkEl+vQ/Bg3S3dbPz/C2vXvrbhsSon87C4iJiRFeXl4iOTm5Yl1JSYm4d++eEEKIe/fuiaioKJGdnW3wGAb/DsL63ytbYs3PumhR1a9ISgqtCwwUorRU8SFYjLPOH4np06eLESNGiLfeeqvG4zjDHCorKxOvvfaaiIiIEGfPnjV5f6M+Z0mJED4+9H+rU4eW69ZZMGrHxpnnUN26dY0+hlzzh12xFqIvvk5CpQJGj6bn7I5Vjo0bN+L06dMoLS1FWFhYxXp3d/eKgrGFhYUoLS116XY19si+fbTUbiPWvj2FMuTkACdO2GZcroSh+QMA586dw+nTpzFo0CAbjc76vPbaa1i+fDm+//77iiL5mZmZKCgokO8kV65QdpCXl+bikZ0t3/EZq1LdHLIF7Iq1gNJSin8FgNhY/dv8/e/A1Kl0ATt92sHaAebnG36vcmeGrCzD21Yuunj5stlDqsyhQ4cwYsQIfPXVV/jhhx/w7rvv4qeffqp4/+7du+jduzfOnTuHTz75BCEhIbKdm7EcSbhpe6A8PCjebvNmirOTXLQOhxPMnylTpuCTTz7B7t27ZTunvTNv3jwAQJ8+fXTWL1myRL56qlIWbHQ0ZQsBwK1b8hzbmXCCOZSbm4vY2Fj4+vpi5syZ6N27t2znNgQLOws4d45c9X5+hgVbWBgVLF6/nmLtHCpmyJR4A6W2rYbLly9j8ODBmDZtGkaNGoXWrVujc+fOOHjwIGLLlXZQUBCOHj2KGzduYPjw4Xj66aft4o6KId+HdH1r1Ur3vR49SNjt2AFMmGD9scmCg8+fdevWoUWLFmjRooVLCTurWPWl+LpWrah8AsAWO304+ByStomIiMCJEycwePBgHD9+HAEBAbKc3xDsirWAw4dp2b599U3LJS/Gxo3Kj8lVuH37NgYOHIihQ4di+vTpAIDY2FgMGTIEM2bMqLJ9WFgY2rVrh+3bt1t7qIwBbtygSg9ubkCLFrrv9exJyx07SAAy8mLM/Nm7dy9++OEHNGnSBFOmTMHChQvx4Ycf2nLYzoN0R9O6NSB5Edhi51AYew2KiIgAALRt2xatW7fG2bNnFR8bW+wsQHLD1pTINGAALXftIsty7drKjssVCA4Oxik9RT3XrVtX8fzGjRvw9fVFQEAAcnNzsX37drz66qvWHCZTDdK/LypKN7kNALp2JZfstWsUjtSkidWH59QYM3+SkpIqSjgsXboUJ06cwHvvvWe1MTo1EydSbF3XrprWK2yxcyiMmUN37tyBn58fvL29cfXqVaSmpqJp06aKj42FnQVIFruahF2zZtQu6eJFYOtWYMgQ5cfGAFevXsVLL71U0W944sSJaOewAVvOh7Y3qjJ+fhS3um8fsHs3CzvGyejYkR4AXRg8PKioowXk5lJFj8pltxjbcerUKbzyyitwc3ODSqXCnDlzDHYwkRMWdmYihPHCDiCr3bx55I5lYWcdYmNjceTIEVsPgzGAofg6iZgYEnbHj1tvTIx+ZEsaYKoybBhQVERlFEwkMxP429+AY8coizwyEjh5kr1C9kL37t1x3AY/YBxjZybp6cDt23SjZaDTjA6SO3bDBmXHxTCOgnaYkT6keXXypHXGwzBWY+NGyqjLzaUAbTNEHQC89x7FoUqdq9LSgB9/lHGcjEPCws5MJGtdmzaAMUXH+/YlEXjhAj0YxtWpyWIntejjWnaM0zFmDDB4MHDpktmHOHsW+Pprer52LZCYSM8XLrR4dIyDw8LOTIxNnJAICAC6d6fnnB3LuDo5OUBGBj03VCpIEnaXLlXfLYhhHI7CQlr6+FBB1Keeor6xJjSNf+892nXwYOCJJ4CXXybjwd69fDPk6rCwMxNT4uskJHfsn3/KPx7GOdm+fTuGDBmCiIgIqFQqrF27ttrtk5OToVKpqjxOnz5tnQEbiWSti4gADPXJrlcPCA2l51KiBcM4BWo1Lb29yRW7cSOwfTtw86ZRux8+DKxcSc9nzqRl/fqa+O3Fi2UeL+NQsLAzE3OEnVTIfOdOrs3FGMe9e/fQvn17fPHFFybtd+bMGWRkZFQ8mjdvrtAIzaMmN6wEx9kxTocQuhY7wORadp98Qstnn6U6qhLjxtFy2TLNKRjXg7NizSA7G7h6lZ5rT6qaiI2lG7SbN6lrReWirAxTmYEDB2LgwIEm7xcaGoqgoCD5ByQTxgq7Nm2ALVtY2DFORHGx5s5eEnZ161LBRiNq2eXnU0wdAEyerPte//5Aw4Z0ffr1V2DECNlGzTgQbLEzAym+rlkzip0zFm9voEsXer5zp/zjYhiJmJgYhIeHo1+/fti6dWu126rVauTm5uo8lMYUYQdwzBDjREhuWECTeSdZ7IwQduvWAQUFdP3p3Fn3PXd3YORIev7HHzKMlXFIWNiZQUoKLTt1Mn3fHj1oycKOUYLw8HAsWLAAq1atwurVqxEdHY1+/fpV20otKSkJgYGBFY9GjRopPk52xTIui7aPVBJ2Ur9YI1yx339Py+ee018lpX9/Wm7ezCE/rgq7Ys1AEnaV75aMoWdPICmJag8xjNxER0cjOjq64nVcXBzS09Mxa9Ys9OrVS+8+CQkJiI+Pr3idm5urqLgrLNRUeTDWYpeeTgmDhhItGMZhqFULWLCALHdu5bYVIy12N29qqio8+6z+bXr2JL149Spw+nTNc4xxPthiZwYHDtDSHItdXBzdZZ0/T1XDGUZpunXrhnPnzhl839vbGwEBAToPJTl/nronBQYCYWHVbxsUBDRoQM85M5ZxCvz8KMth4kTNupAQqlVSVFTtrj//TCVOOnY0XCbI15fEHUBWO8b1YGFnIpmZdCekUmla/ZlCUBDw4IP0fNcuWYfm8ty5cweJiYnIkAqkMQCAw4cPIzw83NbDqODMGVpGRxtXcJ/j7KwDzx8bMn06ibpZs6rdTNsNWx2PPkrLTZtkGBtjNPYyh1jYmYjkhm3Vyvx+fBxnpwyTJk3CgQMH8Oqrr9p6KLKRn5+PI0eOVPS8vXTpEo4cOYK0tDQA5EZ9/vnnK7afPXs21q5di3PnzuHkyZNISEjAqlWrMFHbOmBjpJJ6hiwOleE4O+vgjPPHLrl7l0xp+/dr1nl41HiXc/265pohJUgYQoqzS06u0QjIyIi9zCEWdiZiSXydBAs7+fnll1+Qn5+P3377DUFBQfjuu+9sPSRZSElJQUxMDGLKCybGx8cjJiYG7733HgAgIyOjQuQBQFFREaZMmYJ27dqhZ8+e2LlzJ37//XcMHz7cJuPXh7bFzhikXrJSwgUjP846f+ySkydJef397ybttm4dLbt1o5Im1dGuHRX3vncP2LPHzHEyJmFPc4iTJ0zEkvg6CUnYHT5ME69WLcvH5eoMHToUQ4cOBQAsXbrUtoORkT59+kBUk9pW+bNOnToVU6dOVXhUlmGqxa5ZM1pyj2XlcNb5Y5dULk4MUHzPpEmUxrpmjd7dVq+mpTH3aG5uwCOPkOt282bqVsYoiz3NIbuz2JnaQsmaCCGPsGvUiALCS0uBgwflGRvDOAJCaCx2pgq7K1eotivDODRSHTttYVdcTILOQFDc7duAVI5y2DDjTvPII7RMTjZvmIzjYnfCztwWStYgPZ3SzT08TOs4oY9u3Wi5d6/l42IYRyEzE8jNJYvCAw8Yt094OF0DS0oALa8zwzgmksVOqmEHaAK279+nO/5K/PorrX7wQc2NTk089BAtU1I4zs7VsDthN3DgQHz00Ud2FRMkIVnr2rallHJLYGEnDytWrICPjw+uXbtWsW7s2LFo164dcnJybDgyRh+Sta5pU93rWnVoi8Dz55UZl6vC88cG6HPF+vtrnufnV9lF8s6aclls3hwIDiYD4dGjZoyTMQp7nEN2J+zsGTkSJyQkYbdnD1cHt4RnnnkG0dHRSEpKAgAkJiZi48aN+OOPPxDI1WztDim+ztjECQmOs1MGnj82QJ+w8/YmVxAA5OXpbJ6frylKbIqwU6l0rzOMMtjjHHL45Am1Wg21Vu89JftcSnXnuna1/FgdO9I8zswkF29kpOXHlAshyCNgC/z8jKttJqFSqTBz5kw8/fTTiIiIwJw5c7Bjxw40KK9qm5eXh4cffhjFxcUoLS3FpEmTMG7cOIVGz9SEqfF1Eo5ksXOm+SNx//59tGrVCiNGjMCsGmqtMTWgL8ZOpSKr3Z07VYTdpk2kBZs21dRANZa4OGD9ehJ2kyZZOG4r4mxzyMPDA23L6zZ16tQJixYtknvYOji8sEtKSkJiYqLi51GrNWWHpKreluDnR3F6Bw/SpLMnYXf/vvk1+iwlP9/0LOHHH38crVu3RmJiIjZt2oQ2UkVbAH5+fti2bRv8/Pxw//59tG3bFsOHD0ddqTcjY1VcwWLnTPNHYubMmegqxx0tA3TvDnz2WdUgU0nYVXLF/vILLZ94wjTBAThuyI+zzaGgoKCKWqTWwOFdsQkJCcjJyal4pKenK3KeAwdI3IWGUuyCHDjqpLM3Nm7ciNOnT6O0tBRhlXpUubu7w8/PDwBQWFiI0tLSasuHMMpirsVOEnaOYLFzNKqbPwBw7tw5nD59GoMGDbLB6JyQ9u2BN98EyktjVODvT24cLVNVaSnw++/0vPLmxtClC4nBy5e5haWS1DSHrI3DW+y8vb3hbWwUtgXs2EHLnj1Nv2syRLduwJdf2p+w8/PTG79rtXObwqFDhzBixAh89dVX+OGHH/Duu+/ip59+0tnm7t276N27N86dO4dPPvkEIVLDbcaqFBTQBQYw3WInGTcuXKA+s252fEvqbPNnypQp+OSTT7B7924ZR8pU4dAhwNNT5wKzdy+QnU2tKKUsV1MICKBkv+PHyTNkbKkUW+Nscyg3NxexsbHw9fXFzJkz0VvhwoJ2J+zy8/NxXuu2XGqhFBwcjEgb+iu1hZ1cxMXR8tAhsgZaQZ8ahUrlGEWTL1++jMGDB2PatGkYNWoUWrdujc6dO+PgwYOIjY2t2C4oKAhHjx7FjRs3MHz4cDz99NN2cVflapw/T7EzdeoA9eqZtm9kJBkz1GpqrVRT5X1b4kzzZ926dWjRogVatGjBwk4uLl4k81lkpO4X2curyqa//krLQYNI85lDt24k7PbudRxh50xzSNouIiICJ06cwODBg3H8+HEEBAQoNi67u++tqYWSLSgt1SROyCnsmjYFQkKoxtDhw/Id1xW4ffs2Bg4ciKFDh2L69OkAgNjYWAwZMgQzZszQu09YWBjatWuH7du3W3OoTDlSS7DoaNOt3h4eQFQUPWd3rOUYO3/27t2LH374AU2aNMGUKVOwcOFCfPjhh7YatnPwv/+R+W3u3Bo3leLrzHHDSkgGBM6MlRdTrkEREREAgLZt26J169Y4e/asomOzO4tdTS2UbMHx41RUtXZt6sEnF1I6+m+/0aSTYu6YmgkODsYpPc1D10kNFcu5ceMGfH19ERAQgNzcXGzfvt3mDZpdlZMnaaknNt8oHngAOHeO3LF9+sg2LJfE2PmTlJRUUcZh6dKlOHHihE1vsp0CfQWKAWDhQkphffZZ4G9/w/nzdDPk4QE89pj5p5OuKykpVOTbw+6u+o6JsXPozp078PPzg7e3N65evYrU1FQ0bdpU0bHZncXOHpHcsN27yz8p+G5KWa5evYpevXqhffv26NGjByZOnIh2cqpzxmhSU2lprrDjBArGKdBXxw4Ajh0D1q4lSwI0btjevQFLyqFFR1NeRkGBZg4y1uPUqVPo1KkT2rdvj8cffxxz5sxBcHCwoudk7W4ESsTXSbCwU5bY2FirppkzhpEsdq1bm7e/I9Wyc0bGjBlj6yE4B/rq2AGa+h7ldeykosSDB1t2Ojc3IDaWesYePCiv14mpme7du+N4uVi3FmyxqwEhACkkSwlh17kz4O4OXL1KhYoZxhkpKiI3KmC+sHOkWnaM47J9+3YMGTIEERERUKlUWLt2rbwnMOSKldqK5eWhsBDYto1e9u9v+SmlOH6pexLj3LCwq4Fjx4AbNygFWokYOO24PbbaMc7K+fMU3+Pvb35Gq7Yr1s7CcBkn4t69e2jfvj2++OILZU5gyBWrJex27aLNIiLMvxHSRhJ2Bw9afizG/mFXbA1I5vA+fZQrRxIXR1mxe/YAf/ubMudgGFui7YY1tw5kkya0zMsDbt8GuHkIowQDBw7EwIEDlTuBIVeslrDbtImePvqoPHVTO3Wi5dGjQHGx+aVTGMeALXY1IAm7AQOUOwfH2THOjqWJEwBdB8PD6fmlS5aPiWFswosvAh9+WLXxqx5hJ4cbFqD41IAAsgJyAoXzwxa7asjP1yROWEPYHTpEE6/yjRzDODqWJk5INGkCZGRQBwvJCsEwtkStVkMtWeFAXQaq5e9/17++XNhl3fXCkfL58sgjcoxQk0CxdSu5Y9u3l+e4jH3CFrtqSE4ms3WTJkCLFsqdp2lT6kFbXGzbGAh7qx9obVz98yuJZCWwVNhJRYql1mT2BH9/XPNvkJSUhMDAwIpHo0aNzDtQ377A/fv4M+EvAECHDnRdkAtHiLNzxe+PNnJ9fhZ21aDthpWrP6w+VCrbumM9ywMu7ms1n3ZFioqKAADu7u42HolzUVwMSIXWLXHFApo4O3tyxfL80SD9DTxdKIgrISEBOTk5FY/0msobHDtGteoKCnTXe3oCvr7Y/CddbORyw0rYc2as9Jsr/Qa7KnLNH3bFVoM14uskuncH1q0Ddu4EpkxR/nzauLu7IygoCFlZWQAAPz8/qJRUsnZIWVkZbt68CT8/P3hwaXZZOX+exF3t2oC5xgwJe7TY8fwhS8P9+/eRlZWFoKAgl7o58vb2hrcpmXWDBgHXrpHprGNHnbeEAP78k54/+qiMg4R9J1B4eHjAz88PN2/ehKenJ9zcXMvmJPf84SuYAS5epLpb7u7Aww8rf77evWm5fTtQVkYxEdakfv36AFBxcXJF3NzcEBkZaVcX5e3bt+OTTz7BwYMHkZGRgTVr1uDJJ5+sdp9t27YhPj4eJ0+eREREBKZOnYrx48dbZ8B6kNywrVpZbvm2R4sdwPNHIigoqOJv4ajk5+fjvFYV7EuXLuHIkSMIDg5GZGSk5ScwVO7k/n1c/Mf7uHr1E3h5CXTvLu/v0AMPUAeLnByKee3Qgc6JQYOAF14ARo+W9XymoFKpEB4ejkuXLuHKlSs2G4etkWv+sLAzwOrVtOzRw7J2LsbSsSNQqxZw5w5Z6a0d3CpNrNDQUBQXF1v35HaCl5eX3d0pSjW1XnjhBTz11FM1bn/p0iUMGjQI48aNw/Lly7Fr1y5MmDAB9erVM2p/JbC0R6w2krC7fJmsG/aiwXn+kPvIGSx1KSkp6Nu3b8Xr+Ph4AMDo0aOxdOlSy09gqNyJhweS19wGAHTpWAI/P3lNaioVXWekBIoOHQB89x1VQn7wQY2wu3+fCrdaGS8vLzRv3txl3bFyzh8Wdgb46SdaWquunKcniciNG2me2Spryd3d3Sl+nJ0FU2tqzZ8/H5GRkZg9ezYAoFWrVkhJScGsWbNsJuxOnKClHIVWIyPpAlVQAGRlAWFhlh9TTnj+OD59+vRRNojfUOcJLy8kuz0MlAF9Ot8DECT7qaXM2EOHgJdeFIBUhLlOHVp+8QXwwQdk2ejVS/bz14Sbmxt8uCyExdiXecJOuHIF2L+fLiDDh1vvvJI7VmolwzCmsmfPHvSvFHU9YMAApKSk2MySJLVJrFy2yxy8vIAGDei5PcXZMYxRlJZSCxagisVOCGAb6CLQp90dRU4vhfQdPAgK6D52DPD1Bd58k944eRK4dQt4+21u7+LAsLDTw88/07JXL8Ca4SLacXZCgH4E7t2z3gAYhyczMxNhlcxYYWFhKCkpQXZ2tt591Go1cnNzdR5yUVio6RErV/Nxe42zY5ga0ap3V1nYXboEpJc1hCeKEPeAMrGaUmbs0aNAyZwv6cU//qGx2L3/PsUE7d8PrFqlyBgY5WFhpwfJDTtihHXP26kT3TxlZwOpC3YC0dFAcDAFth45Yt3BMA5L5eQPya1kKClEtjpcejh1iu5PgoM1XSMsxR4zYxnGKCQ3LFDFFZucTMuu2Ae/4hxFTt+sGdVBLiwETq05TSsnTtRsUL8+MHkyPV+8WJExMMrDwq4SaWnAvn3khrV2SJKXF/DQQ/Q8eflV4MIFoKgIWLoUiIkB5syx7oAYh6N+/frIzMzUWZeVlQUPDw/UNdBc1eQ6XCag7YaVK9GBLXaMw+LlBbz3HvDPfwKVyipJwq43tlFDZAVwc6NLCQAcKmsP9OxZ1ZQ+ahQt//oLuHtXkXEwysLCrhI//khLa7thJSri7OoOB6ZPp0jXp5+mlfHxmiJHDKOHuLg4bN68WWfdpk2b0KlTJ4NFL729vREQEKDzkAs54+sktDNjGcahqF0bSEwE/u//dFYLoRF2fZCsmLADtOLs6jwCDB1adYPoaEphLy4Gfv1VsXEwysHCTouyMmDBAnr+3HO2GUOfPrTcussLpR/OpBU//kju2LIyYORINlW4EPn5+Thy5AiOlLvipZpaaWlpAMja9vzzz1dsP378eFy5cgXx8fE4deoUvv76ayxevBhTrF31upxjx2gpp7BjVyzjbFy+DKSnA56eAnE31ilaU06KszvUehTw1lv6N5LcVRxn55BwuRMt/vqLAr0DAmwk7FasQNffNiLQfzGys91x4ADQrRvIhzV3LmUsRUYC9erZYHCMLaipplZGRkaFyAOAqKgorF+/Hm+++Sa+/PJLRERE4PPPP7dZqROlLXa2KObNMGZz/z6VXahVi37Ly9m5k5axsSrUCq2l6BAki93hw0BpmQp6q/M88wwF4lk70JyRBRZ2WnxZniQ0ejRZzK1KWRnw4YfwPH0ajz04FSuPt8avv5YLO4AyqDZtItVpL1VZGcWpqaaWvoKpvXv3xqFDhxQclXHcugVkZNDztm3lO26jRtQRpqgIyMwEIiLkOzbDKMrRo9Q/MiqK2huVIwm7nj2VH0J0g3z4+dXC/fsqnD1LHWGq0KoV8PHHyg+GUQS+1y0nLU0TTjBhgg0GsHYtcPo0EBSEIZOaAAB++63SNoGBuqKO6wwxdoxkrWvShDLx5MLDA2jYkJ5zVALjUBhoJyYJux4+ByjsRsGMVPf/JKFD4V4A5fXsGKeDhV05CxaQ0ezhh4GWLW0wAKl43ssv47FhfnBzo/gkvW3zLl2iWLv//MeqQ2QYU1DCDSvBCRSMQ6KnnditW5p+yt2xh6og7Nih3Bj270ds2QEANQi7khJg3ToqfyIVVWYcAhZ2AG7fphA2wEbWurIyTbbr4MGoW1dT9uT33/Vsv3MnJVTMnAncuGG1YTKMKSgp7KQECrbYMQ6FHovd7t20bNUKCKlfHh2lVFZsWRlw4AA6IQUAcOBANduqVMBLL1GZrf37lRkPowgs7AB89BFw5w5dgJ580gYDOHoUuHmTAvvKg+oef5ze0ptt/ve/U2pTXh7wzjvWGyfDmIAk7OTqOKENW+wYh0Sy2GkVJ65ww/aAJmZBKWF39iyQk4Mu3pSufvAgVTXRi7s70K8fPd+0SZnxMIrg8sLuwgVNH+RZs6A/Q0hppLpjffpQAUsAQ4bQqi1bgPz8Stu7uWmKFS9eTOlNDGNHlJUBJ07Qc7bYMUw5eix2OsJOytpTStiVW95adApAYCANR5qnenn0UVpWqo3J2DcuL+ymTaM7lgEDgEq9061HUBClDWoNoGVLav9SVASsXq1nn4ceAp59lhIo3niDEykYu+LiRboh8fYGWrSQ//hssWMckkrCrqBA4w7VsdhVuZuXiXJh59a1M7p0oVX79lWzvSTs9u0DcpRpc8bIj90Ku7lz5yIqKgo+Pj6IjY3FDgWCSb/9lnIW3NzIWmczXn6Z/FZaPftUKkqOAjRFk6vw8cfUXHbHDuCbb5QfJ8MYydGjtGzbtkrnJFmQLHZpadSLlmEcggcfBN58s8Ilc+AAGRbCw8u/00q7YqUySJ01wq7a8LnGjenOrLSUuiAxDoFdCruVK1di8uTJmDFjBg4fPoyePXti4MCBOoVYLeLoUezsmYCxL5UBIKudnHW2zKZSfboXXiDX8K5dVJu4Co0aAe++S8/nziX/l5mUlgLXrlEIxpkzVAVd53A5OWQeOXMGOH9e0ZY3jOMjCbv27ZU5fkQE4OlJyXrXrilzDoaRne7dgc8+A158EQD9tgPkgFGpoLywe/xx6ioRE4OuXWlVtRY7QONJ4jg7h8EuCxR/9tlneOmllzB27FgAwOzZs7Fx40bMmzcPSUlJlh385Ens7DUdT+Z+gyK4Yfhw4F//kmHQ5nLhAtCgQZW6RgDdxQ0dCqxZAyxcCMyerWf/qVPpCvfqqyaV4FerKRH3t9+o48alS1Uz2n28y9C81nU8JHai352f0QfJCMEtevONNzQDKiwEHnmEEjoeeoh+CIKCjB6LLNy+TWri+HFanjpF1d3Dw0kFvPQS0Lw5bXvsGHDkCP3datcGgoOBkBAqjlZL2arvroLUSkyJxAmAbngiI2n6XL6sU8SfYRwGKSO2e/fyFc2bA9evy1v4UZvp0yuedgmi5alTQG4u1b7Xy6OPUiD6mTPKjImRHbsTdkVFRTh48CCmTZums75///7YLc0CM7n41yVMG3wBP6mphkgsUvDtNF+4ubWx6LgWMXIkmeN++02TgaTFK6+QsFu2DEhKIs+rDu7uQOU+oEIY7E5RUkJlkhITgatXdd/z8NDE7ubnlaFQ7Ybj6oY4jmcwH88AAFq7nUJf9+0YmB2AvvcBPz+QSNq1ix6ff05jioujq3qLFhTAKBUHvHuXfknq1aNHWRkFEnp7Q/gHICfPDTdvkk4rLaW379yhqi5375IgLb6dB4/0S/Bs3RzCxxdlZUDpX8dQumUbBFTwQn14IRhuKIMKAqUoRdFtT5Q0oD+L+54c1N5wEIHIgQ8K4Yayim3dHh+MB2a+qJggcRWUttgB5Lq6cIFuSnr1Uu48DCMbt24B9+4BdepA1PbHXqoTjLi48vc9Pelm1AqEhZGn9coVICWFarjq5ZFHyEvzwANWGRdjOXYn7LKzs1FaWoqwsDCd9WFhYcjMzKyyvVqthlpKIQeQm5ur97hFRcBDzzVGpjoKbijFSw02IOna8/Bb+QLQ2UYBdsXFZGEqKtIEDVXi0Uc1k2/lSmDMmGqOJwTw4YfUj1BPO5gdOyic7/Rpel2/PjBsGDB4MGmwiAhNVnBJsQpXuo7A8aCe2FprMLZcaIwTpzyQWtYKqWWt8OV3gNdPQOfOQI/Y9mj18i40yjqI4KNb4XHpLDx23oTHzo3wwO8oSIzAvUEtcecOkL01HZlJPyINkbiKhshEfWQhFLdQF3dRhlKjogP8AVRWXn3KHwZYqP2iZ/lDD78Bk5pqko4Z05G89oCywo4TKBiH49//Jlfs1Kk4P/ZjZGdTglFMjBXOnZVF15yIiIob/65d6dqyb181ws7Pj0Wdg2F3wk5CVcniJISosg4AkpKSkJiYWOPxvLyAqdPcsP6XYnz6fh7a5ZYCT9ymDIqkJLpTsjZnzpCo8/fXXKUq4eZGRZP/+U/g/ffJwFfFaiexZw/wwQf0vEEDYNIkAHSDOHWqpghzSAhZ5F99VcsDvH8/MOFfwHffAQEB8PBU4YH9K/CAhweeLN8kOxvYvp0y3//4g34QyFDnC6B7+eP1quN6v/wBAHgQwH+r/bNI3lGPontQZWYgCHcRhhsIxm14Qw1PlKC0biiK23eCqnEk3Nzo7+TuTr9XxcX0Zy0ro4eHB/3/PTxI+5aUUNJZTo5mu9JSQJSUQAigaVO7nRYOgeSGbdQIqFNHufNwyRPG4dCqY7dnDz2NjdUpa0c/9jdv0nWpkoHDIubOJVfNK68A8+cDALp0oVr3RtcfrsYbxNgPdncFCwkJgbu7exXrXFZWVhUrHgAkJCQgPj6+4nVubi4aNWqk99hvvAFMnuwJlSoYKB5IwmfkSGXS9oxB8le1a1dtfNzrr1OIQ1oa3ezNmGFgw+7d6Y5w+nT6sMXFONLvLTzzjCY8YuxY4JNPtELgbt8mxfjllzRp33mH3KlAlb9LSAgwfDg9hCA32M6dpCcvXaKEi5wcEknFxSSgSkpIiNaqRa1uJQ9sZCTQqH4RwiNUCA33QEhAEeq45aBOpD98g8uV6+GzFMcXHExmyyZNgGYxQNOm5T5gubG76eCQWMMNC7DFjnFAtMqdSMKuwg0rsXQpWdcmT5ZX2J0/T0st75CUQLF3bw2aLTub3D2HD9NxbFLwlTEWu7uSeXl5ITY2Fps3b8awYcMq1m/evBlPPPFEle29vb3hrXO7Yxgd7eTpaXt/m5FXQF9f8qw+9xzdxL3wAlnT9TJtGnDnDsQnn2DelAt4070ERaUeaNCAfi8eeaR8u9u3ScD9978UOQsAo0ZpsmxrQKWiOnvNmtXgHq4WL63n3gBCdd+OieEyLg6ItYQdW+wYh8MYYefvT8JO7szYc+do2axZxapOnchamJlJFRGiow3sGxRE5U7u3qWAPEkRMnaJXZY7iY+Px6JFi/D111/j1KlTePPNN5GWlobx48fbemjyYsIV8JlnqNvYvXtU7s5gT2aVCgWJ/8GYjsfxGuaiqNQDT/huxNH/btGIunHjKEA3MZFEXbt25F9dtozMaQxjAda22F29Wk1bJIaxJ8pdsXmidkXLvSrCTkpPVUrYSdUBQKE40vmrLVPn4cHtxRwIuxR2I0eOxOzZs/Hhhx+iQ4cO2L59O9avX4/GjRvLf7IVK8h1mZEh/7FrQgpGMuIKqFKRgdHdnbJk//Y3zc2fNrt3U9zEskNt4e5Whlm138eagsdQt6WWYPPyouCyDh2An34i83qF6mMY8ykt1bQoUlrY1a9PF6ayMgoDYBi7p/xHe39GQ5SVUUhKFe+LVOrEQCKgWdy+TeUFAB2LHaBJmtiypYZjcD07h8HuXLESEyZMwIQJE5Q/0cyZVG6kVy+rpZkDoCvg5Mlk3jCyOnKXLsCqVRQWuGYN0Ls3uUE7dyYz+h9/AMuX07b16gErV7qhb1wC8FcX3Yadb71F8RJKX3kZl+P8eWqTZI1EOpWKQi/PnKE4u6ZNlT0fw1hMubDbc6UBAD3WOkAZi51krWvQoEp8ct++tExOriHOTmovtmdPDYXvGFtjt8LOarRsScLu9Gngscesd153d8p+MpEnniABN3QoZTLpy2Z66SXg//6Pkh0AH6pnog1fARmFOHyYlu3aWSe+OipKI+wYxu4ZMgRo2hR7TpL3Sa+wU8Jipye+TqJLF9J6N2/SpdCgnSEqity4586R31ZPzDtjH7CwkwrnSsXdHIC+fcmL+8MPwIYN5PqKjqZcg1GjKBaPYWyB1IrSKnW5oImz4wQKxiGYNAlCAPvKI2OqFXZyWuxatgTefltvWS0vL6BHD/KwbtlSgwOpf38Sdn/8wcLOjmFhZytht38/1f9o1sws00ZUFJCQQA+GsRcki13HjtY5n5QZe/Gidc7HMJZy4QI1oPD2pjDnKnz0EfDee1TmSS46daKHAfr2JWG3dWtF+VP9DBlCd296B87YCyzsbCXsxo6lrhO//EKThWEcHCGsb7GTPEsXLljnfAxjETdvYu9ffgBqISaGrGVVsEFlAimBIjmZwr8N2hoGDKAHY9fYZVasVZGE3Y0bmqwhpVGrqV8qwAkMjNOQnk7Jdx4eRucDWYwk7KTaqwxj13TqhH3jvwZg5VJwu3ZRsToh9L7dsSN5gO/e1dycMY4LC7vatYGGDem5tax2585RIbqAAOq7xDDVMHfuXERFRcHHxwexsbHYsWOHwW2Tk5OhUqmqPE5b4bstuWHbtKnUIklBpMzbW7esd1/GMGZTWIi9oCBog7HQhw5RxQSpA5Cl3LlDQXTh4ZSyrgcPD001kzVrjDzmxo3yjI+RHRZ2ALB6NaXVWesWSspQio7mvntMtaxcuRKTJ0/GjBkzcPjwYfTs2RMDBw5EWlpatfudOXMGGRkZFY/mWkVJlcLabliAWtVJVYrYHcvYO4UFAkdBXhqDl5sLF6ho6apV8pxU+q2oV6/aVoxPP03Ln34yaNgjsrOB0FBg4EB6ztgdLOwAKgTXuHG1/VplRU8FcIbRx2effYaXXnoJY8eORatWrTB79mw0atQI8+bNq3a/0NBQ1K9fv+LhboXaI9ZOnJCQrHbsjmXkwhQruSkcLmyFYnghNKRUX4IqIXdWrFS9uwbv0ODBVPD7/HlN7Xy9hISQWV4Iyo5VigMHqATZsmWadVeuUIzf3LnUhonRCws7W3D2LC1btLDtOBi7pqioCAcPHkR/yUdSTv/+/bF79+5q942JiUF4eDj69euHrdX2CpIPW1jsAE6gYOTFXCt5jQiBvcV019O1Y4lhZ43cdeyuXqWlFHJUzWmlUq4//1zDMR9/nJa//WbycNLSKAN3/nzgs8+A2bOBRYuAnTspRhe3b1MV/i5dyN177Zpm5z17aOfXXqPPM2UKkJpq8hicHc6KBShxYu5cihydM0f587HFjjGC7OxslJaWIiwsTGd9WFgYMjMz9e4THh6OBQsWIDY2Fmq1Gt9++y369euH5ORk9OrVS+8+arUa6vIelgCQa8YF5eZN+v1VqayfD8QJFIycaFvJAWD27NnYuHEj5s2bh6SkJPMPrFZjH8j/2q1rNb5OuTtPGGmxA4ARI4C1a8kd++GH1UQKPfEEdW367TcapyRGDVBQQN07Fy4E9u6tfgzNPXPQq/hRPAI3DHw2CIHPPKN5My4O+PRTYN48mvCffkqPTp2oofpLLwFBQTV+TlnJzAR27KBwri5dqCUUQD+I3bsDderQj2KvXvR+ixaKByGzsAMokeHDDynH+5NPDOSgy8hbb1FDZaumRTGOiqrSr6sQoso6iejoaERHR1e8jouLQ3p6OmbNmmVQ2CUlJSExMdGiMUpu2ObNa/yNlx0WdoxcSFbyadOm6aw3xkpeI2p1ReJE17hqnGVyW+wkYVeDxQ4gQ5y3N3VzqbYLRadOFCN+5gyZ9154weAx//oLGDdOU0Tcw4O0TdOmpMFKS8lId/rwfVzJ8sO54iicw1gsxlh4/AT0zqJwvsceA1q3bgxVfDwll/z+O7B4MS1TUuhHaPRozYmr7Y9Gb9+5Q7osK4vEpzpXjYJiDxQWu6OggDrAFRYC9+/TsqxUADk5QEYG3DOuwuPqZXjcyoQ7SuGGMqB7IdwHkUvbK1sFVdoQqNIExFEVsOww3HAQHqoyeIYEwG3wQKj69kVREaDOuou89TuR614HOU3a45//qo3IyBr/XQZhYQdQF+batYH8fKp0KpVAUYqhQ+nBMNUQEhICd3f3Kta5rKysKla86ujWrRuWS02E9ZCQkID4+PiK17m5uWhkYra2rdywAAs7Rj7MsZIba/HOvOmOK2gCFcrQubun4UFIFrvCQqC4GPCsZltjkFyxRszpgAAKYfvlF+C77wCDBkqVikTU9OnAN9/oFXZqNfDGG8BXX9HrBg2A11+n/uZVfr527AD69cNd+GFX+9eQ3OMd/L7FF6dOkTD86y/yutatS0awrl3dEBs7BK3mDEHwZzdRe/2PUKVdkfpooqwMuP3QUGSgPq4264srJQ1wOacOrmV54PpNL6Sr6yE9J1Bq3atFTZY0FYCg8kerqm/vLn8AACIAfFF1GwHgJoCl5Q+g/Hjl7u3twLPjwMLOYlQqMjUcPkxXB6WFHcMYgZeXF2JjY7F582YMGzasYv3mzZvxhAntfA4fPoxwKXVUD97e3vC20DVw4AAtY2MtOoxZSMkTmZl0b1a7tvXHwDgXpljJjbV4F3vXxssvA7duuSEgsJoNtU3eeXmWd6B48UWysBl51zV6NAm7+fOps5GkM6vwj38AM2ZQjbysLMqULefOHWD4cCp4DFBIXFJSNdb8Tp2AXr0QFBKCwd9+gMGenvgEFI7+xx/02LaNyhr9+is9NNSDu/tr8PMDfJaSHiYvdvlGNbh+69QBQu+eQS2RD2+o4YNC+KJAs2xUD75PDICPD+DhLoB58yBq1UJpRCRKwhuiNLwhSjx8KzKJi4tJ1KrVZBWUDIcqFVBWJlCcV4ji3AIIHz8Ibx94eQHexfmoffUUAspyEDigGyIiLPsRY2EnERlJwk4yWyvF2bMkHtu2tUySMy5BfHw8Ro0ahU6dOiEuLg4LFixAWloaxo8fD4CsbdeuXcOy8syx2bNno0mTJmjTpg2KioqwfPlyrFq1CqvkKp1ggJQUWnburOhp9BIURHfyt26Rwb1dO+uPgXEOzLGSG2vxbtRIY72qFk9PSgjw96e2k5byj3+YtPmTT5Jt4/RpCmX75z8NbNioETUs79VLR9SlpZHrVPoIP/1kRLMKX19Sk15e5Kstp0ULerzxBlBURJfoXbvo9+bgQXLvFheTOzcvr2pYYkitAkR43UQTnxto7HUdDYPuoUF4KRq0r4fIlx9Dgwbl4W5775DCC3uAfLLXrtHjxn3ANwsYJR1RBfx7vAUVNFQAfMsf2tQGIN+PJws7CWkiKi3sVq6kPoBjxgBLlih7LsbhGTlyJG7duoUPP/wQGRkZaNu2LdavX4/GjRsDADIyMnSy9YqKijBlyhRcu3YNvr6+aNOmDX7//XcMGjRIsTFmZdGPuUplG4sdQO7YW7fonomFHWMu5ljJ5bB4V6GVHjeflXBzA6ZNo0vUZ59R71jfyjpE4m9/03mZmkoi7upVcr3+/ns1yVT79wN//klmQZWq2hp7AGm+rl11Q9OFoPi3u3dJjxUU0Fj9/UmneXn5Aogsf1SDdrXooCAqjmmot661yqJZAAs7CWsJO86IZUxkwoQJmDBhgt73li5dqvN66tSpmDp1qhVGpUFyw7Zsaf3ECYlmzYB9+zjOjrGcmqzkDsWdO5TgEBlJseRG8txzwPvvU9m4xYuBiRNr2EEI7F2TgcHjInD7NunSjRurCes7fZoK52Vnk5Ay8PtWEyoVFSmvVcus3Z0W+5ee1kL6Blpaq6gmuIYd42RIws4WblgJLlLMyMXIkSMxe/ZsfPjhh+jQoQO2b9+uYyW3Cl99BcTHAydOWHacHTuoRIiJyXqenoB0f/jBBzXUiMzKwpr276PvU3Vw+zYZv3bsqEbUpaUBjz5Koq5TJ2DUKAMbMubCwk5i0CAK0Nm8WdnzsMWOcTLsQdhxZiwjJxMmTMDly5ehVqtx8OBBg6WCFOP774H//hc4dcqy45iQEVuZF1+k0Ipbt6gMyt27VbcpKwM+XVoXTx3/AIXwxeORR/HnnxTzqpfr10nUXb1KJv4//rCdmd+JYWEnERgIREUpW8Pu1q3y0trQXIkYxoERgoUdw8iOXLXsTChOXBkfH8pnaNiQPKdPPKFpNSYEcOQI8NBDwJR/ukPADeMxD2vSYlHrh8X6m81u3079Bs+eJdfwpk0V5UkYeWFhZ00ka12DBhwUwDgF6enUdcLDw/odJ7SRajKnp8tXsJ9hbIZc3SeMbCdmiIgIKi1SqxbpsvbtgQcfpDp0MTHURcLfnxo3zR17GB4oBcaOBYYMocQISZhmZ1Oq7I0bdIAtW8wSm4xxsLDTZtYs4Pnn6fZECdgNyzgZkrXuwQfpDt9WBAcD9evTc6WmL8NYDTuw2El06EB9XEeMoBu4EyfoZs7NDXj6afIWv/oqoJo3F/j4Y/J6/f47uVyPH6eDhIRQ669//IP6vUpBsYwicFasNqtW0S2IVMhHbnr1Ar791vq97BhGIezBDSvRujUVKT550j7GwzBmI5fFzoR2YtXRoQPw448UIrdzJ0UttWlTqUKJhwdlXAweDCQmkqjTDjl65RV6VNPmi5EHFnbaNGpEwk6pkieNG9ODYZwEexN2W7ZQLS2GcWgki50lwk4Ii5In9BERUaV0XVXatCEVWBkWdFaDhZ021ip5wjBOQGkp1RgFgC5dbDsWgK4nAFnsGMahkSx2lrhiS0oovOjqVZNq2DGODws7bZQuUrxkCVW07t27mlLeDOMYnDxJvVn9/TWiypa0bk1LttgxDs/f/w707w/Uq2f+MTw9gddfl29MjMPAwk4bqXerEsKuoIAKAwGUIcTCjnFwdu+mZdeugLu7bccCaMTl5cvAvXuceM44MPXqWSbqGJeGs2K1UdJid/kyLf39KYWPYRycPXtoGRdn23FI1K2r6UVuaV1XhnF4Ll6kmPGsLFuPhLEydifsZs6cie7du8PPzw9B1s4elYTdjRsUnyAnly7RsmlTDiJlnAJ7E3YAu2MZJ+H6derl9e9/m3+Mr7+myfnhh7INi3EM7E7YFRUVYcSIEXj11Vetf/LQULrLuXePUrfl5OJFWkZFyXtchrEB2dmasozdutl2LNpwAgXjFGRnU8mQOXPMP0ZGBi3Dw+UZE+Mw2F2MXWJiIgBg6dKl1j+5m5tywksSdk2bKnN8hrEikrWuZUugTh3bjkUbl7HYlZbShbukhDIoAwLkvxllbIccWbHXr9OSM2JdDv4lsBbarliGcXAkYde9u23HURmnsNgVFJAy3bOHMlSiooCZMzXvR0fT70lxsWaduztt160bFUFnHBupjl1hIf2fPT1NPwYLO5fF4YWdWq2GWq2ueJ1raQuWn36i5niDBgHPPGPh6LRgVyzjRNhjfB2gsdjZdWZsURH1ZGrQQLPuySepbcbNmyTatJuoP/aY7v6ZmXSx9/CgC35BAVnwzp+v2rB32TLq0ckZlo6FJOwAKlJsTsIdCzuXxSoxdh988AFUKlW1j5SUFLOOnZSUhMDAwIpHI0srbB86RHe8Ui0HuViwgH5kO3WS97gMY2VKSjSFie1N2NWrR20phbCzzFi1Gli9mpprBgVRT2pt9u8H9u2jG0AhKMX3scco8H3qVN1tN28m5VpQANy/T0IxPZ3abrz3nma748eB0aMpxqpXLyApCUhOtrz/KKM8Xl6Atzc9N6f7RFERxekBHGPngljFYjdx4kQ8U4P1q0mTJmYdOyEhAfHx8RWvc3NzLRN30l30tWvmH0MfXbvSg2EcnCNHSE8EBgKtWtl6NFXp2BHYtIm0ks3vo4QAVqwA/vlPTXsnALhwASgro7heAJg/n5aBgRS4GBpqOHu+cpsPT0/qBVq5H2heHv0BUlKAHTvoIVG3LvDVV8BTT9HrI0eA//s/oEULEp5eXhTnFR5O4SPctN36BASQBdccIZ6ZSUtPT/pfMy6FVYRdSEgIQkJCFDm2t7c3vKU7GzlQStgxjJOQnEzLXr00usSe6NaNhN2+fcCECTYcyPHjwPjxGut/RATwj38Azz5LLlNt4TZ0qPzn796dmvlevgysXw/8+Sdw8CC1TLx1i8SbxMGDwMqVho/12WfAm2/KP0bGMP7+JOzMsdjVrk0ZtffucXktF8TuYuzS0tJw+/ZtpKWlobS0FEeOHAEANGvWDLVr11Z+AJKwk+IT5ODIESoU2bGjfTTVZBgL2LaNlr1723YchpDKr+zda9txYOtWEnW1agHTpwPx8YCPj/XH0aQJKVxJ5d6+Tb9v2p6NuDjgk08oTi8/n1zHd+9S5u3ZsxSnJzFvHj06dgQ6dwYefpisjCwg5GXNGkqKMSfhLjgYmDRJ/jExDoHdCbv33nsP33zzTcXrmJgYAMDWrVvRp08f5QcgBZpmZOi6Sizhjz/oh33UKIqzYxgHpbQU2L6dnltjOpqDdO909ixpGKs2eikp0ZQdee01+h2ZOFE3UcLWBAdX/aO0bq3JPKlMTg65iCUOHSJr5PHjgPRbXb8+CZDmzQFblKpyRtq1s/UIGAfF7hwpS5cuhRCiysMqog6gHyg3N/qBlqsVC9ewY5yEo0cp5CcgAOjQwdaj0U/duqQvAE2Sh+IIAfz3v0BsLAUgAmRtSUqyL1FnDtqiDqCEjnXrgPffB/r1IytkZiZZJ6V0aca2nDxJ/wspgYJxKexO2NkcDw8gLIyeSwGoliLVsONSJ4wZzJ07F1FRUfDx8UFsbCx2aAfB62Hbtm2IjY2Fj48PmjZtivlSYL4MSPF1PXuSbrFXJHfsvn3KnSM7G1i1Cpg8sQQvNd+GN+LdMPPY49icsAU5Ocqd1+aEh1NM4AcfUNzenTsk6n7+mYQsIw/r11P3CclEbgqffEIxlgsXyj8uxu6xO1esXXDoELkqtIOLLYGLEzNmsnLlSkyePBlz587FQw89hK+++goDBw5EamoqIiMjq2x/6dIlDBo0COPGjcPy5cuxa9cuTJgwAfXq1cNTUgakBUjCzl7j6yS6dqWqRUrE2d28CbzzDrBoEUVr0M9on/IHgM8Bty+oWsnLLwODBzt5UwgfH/ure+MMrFtHZbLc3ChTyRS4hp1L48w/N+ZTv758xyotpSw0gIKYGcYEPvvsM7z00ksYO3YsAGD27NnYuHEj5s2bhyQ91pH58+cjMjISs2fPBgC0atUKKSkpmDVrlsXCrrRUUzHDXuPrJLQtdkLIF9f/zTfAG2+gwiLX1j0VvUu3IML3LvKHjcJl0biiHN369fRo0oSqnYwZY5vcCcZBkdqKmWP+lfrEsrBzSVjYKc21axSv5+nJk4wxiaKiIhw8eBDTpk3TWd+/f3/sNlBAe8+ePejfv7/OugEDBmDx4sUoLi6Gpzmtico5dowSJf39gfKcJrulXTsSUXfuAOfOUXk2S/n4Y0D6V3RschtzrjyJHqU7KDt09WqgceOKbc+dI4ve119TtZFXXyWv2iuv0EOJmrEFBRQWnJlJj/x8alCRk0M/Q1lZlOwq5Xd4e9NSpSLxW1ZGDx8fSuT18tII4uJiEvYeHrS+Vi0KvfPzo/XFxRRaeO8e4OsLTJny/+3dfViUZb4H8C8vw5siZayKIYJYqGmpYAJZK7opHTPNs6Z1lvScsmzDNa1t0T1HsZdlM7qstFVzXawrvax8qVxL8VrB1k1bLdEUxRfCVCTEbBBfAOU+f/x8eJGZYWacl2dmvp/req5hxvuB3zjczG/u575/t+Ofn8/RNmE+d872czli59OY2JmydSuQlye1pm70L1RZmdzGxOh7UhLpTlVVFa5evYrO2pzPazp37owKM/M/KyoqTLa/cuUKqqqqEGUio7B2W75tBQ0A/DEk4jsEBvaz8dm4lsEg6xj+9S+5HHsjiZ1SktDNny/3s7KAV54wImBoKfCrSVL6IzS0xTm33SaJYHa2JHivvy6bQ8ybJ9u+/vrXwLRpcgXTltFEpeQ9+9tv5ThwQHbYKCuTRE4PunZlYucQ2srln36y7bzLl5vOYWLnk5jYmXL8OPDBBzKZ5kb/Qg0YIJNfL11yTGzkc/yue+dXSrV6rK32ph7X5OTkYN68eW3G0S+qCo/7bca9J7cB2zJ0P9EuNVUSu3/8o/UOXrZYuLApqcvNBZ5/HgDipKivpR0iIPnetGlSp3jdOmDRImD7dmD1ajm6d5eFpampsrYqKkpG1C5dkoGan36SpK2kBDh0SA5LV+aCgmQmSZcuciUvKEhq1XbtKo+FhMio29WrTfvLa+H7+8vXly/LyFtdXdOWtQaDnHflioz6XbggcVy6JI8HBsroXVgYt6V1GC2xs3XETvvQFxwsu4iQz2FiZ4r2KccRu0+Eh8sSQiIbRUZGIiAgoNXoXGVlZatROU2XLl1Mtg8MDMQtZrYWsnZbvuGPdsLwf+4AFi8H5hyRlRQ6Lko7erSMlG3YIAmMPVeht2xp2nDh9Ue/xfP9qgBcu9Rt5jUwxWAAJkyQY88eSfBWrZLPkH/7mxzW8veXknMDB8ol5969gZ49JZwOHXT9kpAt7B2xa34Zlr8MPomJnSnO2H2CyEZBQUFITEzEli1b8PDDDzc+vmXLFowZM8bkOSkpKdiwYUOLx/Lz85GUlGR2fp1N2/LNng0sXy6j0AUFsuuATqWmyoBaZaXkoPffb9v5paWSiDU0AJPuL8fzHw0GPoaU9hg0yO64BgyQ/8K33pLFKP/4B7B/v4zM/fijDLSEhMhgS8eO8v7cqxeQkCBJ3G23Ne0PT17M3sSue3cZZvbqpdhkkfIyRqNRAVBGo9H+b3L2rFJyFUKpixdvLKAlS+Q4derGvg+5lUN+r+ywevVqZTAY1PLly1VxcbF67rnnVLt27VRZWZlSSqmsrCyVkZHR2L60tFSFhYWpGTNmqOLiYrV8+XJlMBjUmjVrrP6ZbT7XzEzpG0OG3NBzc4WnnpJQp0617byrV5W69145d3D/S+pS+C/kzqOPyj+SzdzVh1zNYc+zpkap7duVOnjQMYGRR7Pl94oFik25+eamugTasnF7/elPMsFGW0RBZIMJEybgzTffxEsvvYT+/fvjyy+/xOeff47u11Zgnj59Gj9o5XQAxMXF4fPPP0dhYSH69++Pl19+GW+//bZDatg1mjVLJm9t3y6T2HRMe9rr18u8Mmtpo2nt2yusxqMIOX9GhgDz8hyzzSBRW9q1A+65R4ZriWzgp5Q2PdY7VFdXIyIiAkajER20OkD26NkTOHZMLjnZO0euvl4SxIYGuazrjBoH5BIO+73yAFY91ylTZLnnmDHAJ5+4ND5b1NXJ3LOff5ZEbciQts8pKZHt0i5fBpb+x6d46vOxUttj794WJU3INr7Sh9z+PHftkvee3r2bSqaQx7Pl94ofPc3RFlCcOWP/9zhxQpK64GCbJloT6d4LL8hyzmeecXckFgUFySIKQFaltqWuDvjNbySpGzHoHKZ8fm1u47vvMqkj1/vrX6Vmji3zvWfPlpG+v//daWGRvjGxM+eTT2Rd/7hx9n8P7fJrbCwv35B3SUiQfUJHjnR3JG3SuvAHHwBmSvQ1+uMfgd27ZaBjed8F8IMCJk0CHnnE+YGS27366qtITU1FWFgYbtJDqZD586X44bFj1p9z8qTcaosAyecw2zDHEXvFanvEcisxIrcZNUry0DNngD//2Xy7TZukTh0g5Ueil88DPvxQJtyRT6irq8P48ePxjF5Gou1ZGauV6WJi57OY2DmTNmIXF+fWMIicZu9e4OWXgS++cHckZhkMTQWGFyxo2rq5uX375BIsAPz2t8DYsZAaYI88IvPryCfMmzcPM2bMQL9+OtlZxdbE7vx5OQAmdj6MiZ05+/YBGRnAc8/Z/z04Ykfebs0aYM4cqbarY6NHy0YZly/Lot7m9u6VcnxnzwKDkhqQGz5P7hBZoba2FtXV1S0Oh7E1sdNG6zp0kC1HyCcxsTOnulom5VxX7NUmr78ObNsmVU6JvNHQoXJbUNC0/5QO+fkBb7whX69aBaSnS2Hg//s/IC3tWlI3CMj/j7cQ+lo2cN99svCJqA05OTmIiIhoPEzt2mI3W7cV0xK76GjHxUAeh4mdOVrHOHXK/j/wUVHyBsERO/JWKSlyrfPUKdsmeLtBYqJckjUYgM2bgV/9CnjlFXnPHDwYyF/6PW6aP1saZ2VxwZOXyM7Ohp+fn8Vj9+7ddn//WbNmwWg0Nh4nTpxwXPBauRJrR+y4cILALcXMu/VW+ZhfWyuzrlmuhKi1sDAgOVmKxBUWSv1HHfv974GHHwZefFH2gb33Xln0OnaMQvCYqXKtdtiwpgl35PEyMzMxceJEi21ib+DDt01b8tnK1kuxycmynViXLs6JhzwCEztzDAYZcSsvl9nWtiZ2J0/KTt99+gCPP+6cGIn0YOjQpsTuySfdHU2bevY0UdNuzVogP19qTi5ezM3TvUhkZCQiIyPdHYZ9/vM/gaQk6y+tJiTIQT6N1xosiYmRW3uG1r/7DnjttaaJPUTeSptnV1io63l2ZtXUADNmyNd/+ANw++3ujYfc5ocffkBRURF++OEHXL16FUVFRSgqKkJNTY17AoqOlmLDLI5NNuCInSXdugE7d5quj9CW0lK57dHDsTER6U1KitR8rK4GKio8b+u8+fNlhD02VubWkc+aM2cO3nvvvcb7AwYMAAAUFBRgqPYBRs+2bJHpEf37y16z5JOY2FkSEyOXZKxdkdScltjFxzs2JiK9CQ0F9uyRka5AD/yTMn06UFkplYxDQ90dDbnRihUrsGLFCneH0eT8eSAvT0aVZ89uu/2kScDp07J9SmKi8+MjXfLAv8IulJ0N5OTIfDtbaSsEOWJHvqBPH3dHYL9bbgGWLHF3FEStXb4sHzwAWfFj6YNTfb2MmANcFevjOMfOkvbt7UvqAF6KJdK7vXs9c04g+Q6t3AkA/Pyz5bYVFfL7HBgIdOrk1LBI35jYOYNSTOzIt9TUyE4tSUkycqB3e/dKReJRo4CLF90dDZFpgYGyiwTQdskTrThxVBRrMPo4vvqWXLokb1ZDhwJ1ddafV1kJXLgg8/NYnJh8QVgY8OmnwDffAIcPuzsay+rrgcmT5TY4mPPqSN+s3X1CS+x4Gdbn6SqxKysrwxNPPIG4uDiEhoYiPj4ec+fORZ0tSZUjhYQAH38s24JpncYav/iFrKTdvl1WCxJ5O39/QNs4fe9e98bSltdeA4qK5A1zyRLWrCN9s3b3CSZ2dI2uErtDhw6hoaEBS5cuxYEDB7BgwQIsWbIEs61ZDeQMfn5S8gSwreSJv7+cl5rqnLiI9Oiuu+RWz4nd/v3ASy/J12+/zR1lSP+s3X2CiR1do6tVsenp6UhPT2+836NHD5SUlGDx4sXIzc11T1AxMcDRo/YVKSbyJXfeKbf79rk3DnOUkp0x6uuB0aOBxx5zd0REbbM2sRs/Xt6vtJFz8lm6SuxMMRqN6Kj9YruDPSN2ixdLIvjII1IoksgX6H3Ebv164OuvZbU7L8GSp/jf/5WSJ7fdZrldUpIc5PN0ndgdO3YMCxcuxBsWtuWqra1FbW1t4/3q6mrHBmHPtmKrVsn8ujvvZGJHvqNvX7k9fRo4c0bmmupJRARwxx3AuHFA167ujobIOtpIOJGVXDLHLjs7G35+fhaP3bt3tzinvLwc6enpGD9+PJ60sLF4Tk4OIiIiGo9u2gibo9gzYsdSJ+SLwsNl94nevYEff3R3NK0NHy6jie6as0vkLErJQr9//cszyg2RU7kkscvMzMTBgwctHn21T/uQpC4tLQ0pKSl49913LX7vWbNmwWg0Nh4nHD0XTttWrNmooEWXLgHl5fI1Ezu6AefOnUNGRkbjh5aMjAz83EaR0smTJ7f60JScnOyagAHgwAGguLhp9E5vAgJktTuRpzh6VBb6rFxpvk1VlUz9ufde4OpV18VGuuSSS7GRkZGIjIy0qu2pU6eQlpaGxMRE5OXlwb+NQovBwcEIDg52RJimDRsmSZ21O1B8/73cduggWxUR2emxxx7DyZMnsWnTJgDAU089hYyMDGzYsMHieenp6cjLy2u8H+TKkjt63Cv2o4+AkyeBp5/mxujkeb77TubYpaQA//VfpttoV4luvZUfXEhfc+zKy8sxdOhQxMTEIDc3F2fOnGn8ty5durgnKFu3FGt+GZaTs8lOBw8exKZNm7Bz504MHjwYALBs2TKkpKSgpKQECQkJZs8NDg52X3/RNDToo/r9lSty6fXYMRmt0/bdJPIU2uLBqirzbbS9yePjnR8P6Z4O/vI2yc/Px9GjR7F161ZER0cjKiqq8fAYhw7JbVsrmIgs2LFjByIiIhqTOgBITk5GREQEvvrqK4vnFhYWolOnTrj99tsxZcoUVFZWWmxfW1uL6urqFofdzp0D7rkHiIy0bbcWZ1m9Wt70brlFSp0QeRptnveJE+b3Nua8bmpGV4nd5MmToZQyebjVn/8MDBkCbNzYdtuSErnV6xwj8ggVFRXoZGIj706dOqGiosLseQ888ABWrlyJrVu34o033sCuXbswbNiwFivHr+fQBUg33STz7M6dk7l27tTQALz6qnw9cyYvw5Jnio6Wqz+XL8t2laZwxI6a0VVip1sHD8pqo6KittsuXSrz7KZMcXpY5HlsWSHuZ+JSvlLK5OOaCRMmYNSoUejbty9Gjx6NL774AocPH8ZGCx9KHLoAyc8PGDhQvv72W/u/jyOsWycj6DfdBGRmujcWInsFBTXtJlFWZroNR+yoGV3NsdOtXr3k9uDBttv6+wOxsU4NhzxXZmYmJk6caLFNbGws9u3bhx9NlAw5c+YMOtuwDVZUVBS6d++OI0eOmG3j8AVIAwYABQWS2P3P/zju+9pK261m2jRZzETkqbp3lwVAx48DzaZnNOKIHTXDxM4avXvLrTZ/jshO1q4QT0lJgdFoxL///W/cfffdAICvv/4aRqMRqTbsQXz27FmcOHHCtfNUtRG7PXtc9zOvt3On7DIRFAQ8+6z74iByhNhYuWpkbsRu2TIpi2JhURX5Dl6KtYY2YnfokPnJqwCwbZvs19dG7T2itvTu3Rvp6emYMmUKdu7ciZ07d2LKlCl48MEHW6yI7dWrF9avXw8AqKmpwQsvvIAdO3agrKwMhYWFGD16NCIjI/Hwww+7LngtsSsqcl9NrQ4dpC8+/jhgwwgnkS794Q/Ajh3mp/g88ICMTEdEuDYu0iWO2FkjPl7qc124IMPh5iaX79gBrFkjJVKeesq1MZLXWblyJX73u99hxIgRAICHHnoIixYtatGmpKQERqMRABAQEIDvvvsO77//Pn7++WdERUUhLS0NH374IcLDw10X+O23A2FhwMWLwOHDTSPertSnj9Svc/fCKyJH6NfP3RGQB2FiZw2DAejZU0bsDh0yn9gdOCC3XBFLDtCxY0d88MEHFts0XzEeGhqKzZs3OzustgUEAOnpUkPuyhX3xsJakuTtdu2Sy7CJifKhinweL8Vaq3dvWXZeU2O+zf79cnvHHa6JiUiv1q4FPv3U9SMNFy8Cv/+9jBQSeYuLF4FFi4CsrNaj0CtXAo89Bvz1r+6JjXSHI3bW+vhjGYkw5+rVpsUVHLEjco9Vq2Q17Pr1wJEjHLEj7+DvL3PoAPng0ny7Sm1FLEud0DUcsbOWpaQOkDpCly8DoaFAXJxrYiLSM6WAU6dcN89NKWDhQvn6mWeY1JH3CAkBtG0Cr18Zq9WwY6kTuoaJnaNol2H79NHHHplE7tTQILW3oqOlYLcrbN8O7NsnH67cWT+PyBm0+qjNE7uGBhYnplaYgVirvh4YNgzo2hW4tgqxhR9/lJpZvAxLJB9utEVGrlrQoY3W/eY3wM03u+ZnErlK9+5ye/x402MVFXKlKCAAiIlxT1ykO0zsrGUwyD6wp0837Qfb3NSpUg7lzTddHhqRLj30kNx+8onzf1ZZmWwhBjTNRSLyJqZG7LT5dTEx8h5FBCZ2tmlra7HAQNmXkoiAsWPltqDA9Ch3c6dOAZMmSTL43/8NvP++bXPz5syRBUz338+aX+SdtBG75ond11/LbZ8+Lg+H9IuJnS20y6xffdXycXfX6iLSo4QEOerrgU2bLLdt315qcW3YAKxYIUleTo51P0cpKUcUEWH9OUSeRhuxa34p9umngc8+A154wS0hkT4xsbPFqFFy+8knLbdKmjVL3lhWr3ZLWES6pY3affqp5XYREdLm9deb9nb94x+Bd95p+2f4+UkfPHlSirQSeaOUFBlUaD5nNTwcGD0aGDrUbWGR/jCxs0VamkzKrqyUDZk1GzdKDTuWVyBqacwYud24Eaira/lvSjVdSgKAyEgZeVi0SC6tAkBmpoxImNP8cm379o6JmUiPbrpJkjut7AmRGUzsbGEwNE0IX7tWbr//XubcBQQAI0e6LzYiPRo8GJg5E/jww9ZlgP72NyA5WZK362VnA7/9rXz9yium59tVVABJScCXXzo8bPI9ZWVleOKJJxAXF4fQ0FDEx8dj7ty5qLv+A4keXL4MvPUWMHt2U2F8omu484Stxo+XOQ6DBsn9jRvl9p57uHCC6Hr+/sAbb7R+/ORJSfiAprlDzfn5AQsWAB07yije9aPh9fXAhAnAt9/KKtg9e1g/km7IoUOH0NDQgKVLl6Jnz57Yv38/pkyZggsXLiA3N9fd4YkLF2Q0+6OPpLxWaSkwcGDTwj4iMLGz3ahRTXPtamubRu60x4jIvB075A3p2WeB6moZsZsxw3TboCDg5Zeb7ldXS0J35QowfbqM1LVvb3o0kMhG6enpSE9Pb7zfo0cPlJSUYPHixfpJ7IKCgL//XT4YAfJ7P3y4e2Mi3WFiZ6/SUuDuu4GzZ+X+gw+6Nx4ivZszp2WiFhYml2Pb2q5PM3eulEGpqwNqamQULy+PoxXkNEajER07dnR3GE0MBmD+/KZFSYMHsxg3tcKPufaKi5MOdeutwJIlrCNE1JZOneTW3192h9izR1aTW6O+XkbofvpJkrpBg+T+r3/tvHjJpx07dgwLFy7E1KlTLbarra1FdXV1i8OpHnoIuO8++ZpXisgEjtjZy88PyM+XbZMC+d9I1KZnnwXuvFO25evZ07ZzDQZZQbtqlYz0jRvHy69klezsbMybN89im127diEpKanxfnl5OdLT0zF+/Hg8+eSTFs/Nyclp8/s7lJ8f8PHHMgWhjdjIN/kpZUt5d/2rrq5GREQEjEYjOnTo4O5wyEv40u+VLz1Xch13/V5VVVWhqqrKYpvY2FiEhIQAkKQuLS0NgwcPxooVK+DfxgeI2tpa1NbWNt6vrq5Gt27d2H/IoWzpPxxqIiIirxUZGYnIyEir2p46dQppaWlITExEXl5em0kdAAQHByM4OPhGwyRyGCZ2RETk88rLyzF06FDExMQgNzcXZ86cafy3LiwKTB6EiR0REfm8/Px8HD16FEePHkV0dHSLf/OyGUvk5Tj7mIiIfN7kyZOhlDJ5EHkSJnZEREREXsLrLsVqn66cXkuIfIr2++QLn97Zh8gZfKUPsf+QM9jSf7wusTt//jwAoFu3bm6OhLzR+fPnERER4e4wnIp9iJzJ2/sQ+w85kzX9x+vq2DU0NKC8vBzh4eHwu27jcK2+0IkTJ7y6vhCfp+MppXD+/Hl07drVqhIInszX+5AvPEfA9c/TV/qQr/cfwDeep577j9eN2Pn7+7da0XS9Dh06eO0vW3N8no7lzaMMzbEPCV94joBrn6cv9CH2nya+8Dz12H+892MTERERkY9hYkdERETkJXwqsQsODsbcuXO9fvsXPk9yFl/4P/eF5wj4zvPUE1/5P/eF56nn5+h1iyeIiIiIfJVPjdgREREReTMmdkRERERegokdERERkZdgYkdERETkJbwusfvLX/6CuLg4hISEIDExEf/85z8ttt+2bRsSExMREhKCHj16YMmSJS6K1D45OTkYNGgQwsPD0alTJ4wdOxYlJSUWzyksLISfn1+r49ChQy6K2nbZ2dmt4u3SpYvFczzttdQj9p/W2H/IFuxDrXlaH/L4/qO8yOrVq5XBYFDLli1TxcXFavr06apdu3bq+PHjJtuXlpaqsLAwNX36dFVcXKyWLVumDAaDWrNmjYsjt97IkSNVXl6e2r9/vyoqKlKjRo1SMTExqqamxuw5BQUFCoAqKSlRp0+fbjyuXLniwshtM3fuXHXHHXe0iLeystJse098LfWG/cc09h+yFvuQaZ7Whzy9/3hVYnf33XerqVOntnisV69eKisry2T7F198UfXq1avFY08//bRKTk52WoyOVllZqQCobdu2mW2jdapz5865LrAbNHfuXHXXXXdZ3d4bXkt3Y/8xjf2HrMU+ZJqn9SFP7z9ecym2rq4O33zzDUaMGNHi8REjRuCrr74yec6OHTtatR85ciR2796N+vp6p8XqSEajEQDQsWPHNtsOGDAAUVFRGD58OAoKCpwd2g07cuQIunbtiri4OEycOBGlpaVm23rDa+lO7D/sP57+Wrob+5B39SFP7j9ek9hVVVXh6tWr6Ny5c4vHO3fujIqKCpPnVFRUmGx/5coVVFVVOS1WR1FKYebMmRgyZAj69u1rtl1UVBTeffddrF27FuvWrUNCQgKGDx+OL7/80oXR2mbw4MF4//33sXnzZixbtgwVFRVITU3F2bNnTbb39NfS3dh/2H88+bXUA/Yh7+lDnt5/Al3+E53Mz8+vxX2lVKvH2mpv6nE9yszMxL59+7B9+3aL7RISEpCQkNB4PyUlBSdOnEBubi7uu+8+Z4dplwceeKDx6379+iElJQXx8fF47733MHPmTJPnePJrqRfsP62x/+j/tdQT9qHWPK0PeXr/8ZoRu8jISAQEBLT6ZFRZWdkqk9Z06dLFZPvAwEDccsstTovVEaZNm4bPPvsMBQUFiI6Otvn85ORkHDlyxAmROUe7du3Qr18/szF78mupB+w/tmH/oeuxD9nGk/qQp/Ufr0nsgoKCkJiYiC1btrR4fMuWLUhNTTV5TkpKSqv2+fn5SEpKgsFgcFqsN0IphczMTKxbtw5bt25FXFycXd9nz549iIqKcnB0zlNbW4uDBw+ajdkTX0s9Yf+xDfsPXY99yDae1Ic8rv+4YcGG02hLzZcvX66Ki4vVc889p9q1a6fKysqUUkplZWWpjIyMxvbaEuUZM2ao4uJitXz5ct0vNX/mmWdURESEKiwsbLEU++LFi41trn+eCxYsUOvXr1eHDx9W+/fvV1lZWQqAWrt2rTueglWef/55VVhYqEpLS9XOnTvVgw8+qMLDw73qtdQb9h/B/uMZr6UesQ8JT+9Dnt5/vCqxU0qpd955R3Xv3l0FBQWpgQMHtliCPWnSJPXLX/6yRfvCwkI1YMAAFRQUpGJjY9XixYtdHLFtAJg88vLyGttc/zxfe+01FR8fr0JCQtTNN9+shgwZojZu3Oj64G0wYcIEFRUVpQwGg+ratasaN26cOnDgQOO/e8NrqUfsP+w/nvJa6hX7kOf3IU/vP35KXZvhR0REREQezWvm2BERERH5OiZ2RERERF6CiR0RERGRl2BiR0REROQlmNgREREReQkmdkRERERegokdERERkZdgYkdERETkJZjYEREREXkJJnZEREREXoKJHREREZGXYGJHRERE5CX+Hw5Sn4QmBADrAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "mhe_timepts = timepts[0:10]\n", "oep = opt.OptimalEstimationProblem(\n", @@ -630,7 +931,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "bfc68072", "metadata": {}, "outputs": [], @@ -644,10 +945,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "49213d04", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "mhe_timepts = timepts[0:8]\n", "oep = opt.OptimalEstimationProblem(\n", @@ -661,19 +973,25 @@ ")\n", "plot_state_comparison(timepts, mhe_resp.outputs, lqr_resp.states)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "650a559a", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.6" } }, "nbformat": 4,