From 889d6f92edeebbc28806fe7fb41a11f1c56dc7a0 Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Wed, 25 Mar 2020 18:43:30 +0100 Subject: [PATCH 01/14] Added Code for ProMPs and Kinematics --- intprim/probabilistic_movement_primitives.py | 350 +++++++++++++++++++ intprim/util/kinematics.py | 208 +++++++++++ 2 files changed, 558 insertions(+) create mode 100644 intprim/probabilistic_movement_primitives.py create mode 100644 intprim/util/kinematics.py diff --git a/intprim/probabilistic_movement_primitives.py b/intprim/probabilistic_movement_primitives.py new file mode 100644 index 0000000..e57a4b5 --- /dev/null +++ b/intprim/probabilistic_movement_primitives.py @@ -0,0 +1,350 @@ +#!/usr/bin/python +## +# This module defines the ProMP class, which is the user-facing class for deploying Probabilistic Movement Primitives. +# The code for conditioning the ProMP is taken from the code by Sebastian Gomez-Gonzalez at https://github.com/sebasutp/promp +# TODO: Implement the EM based learning with NIW prior +# +# @author Vignesh Prasad , TU Darmstadt +import constants +import scipy.linalg +import autograd.numpy as np +import pickle +import sklearn.preprocessing + +## +# The ProMP class is responsible for training an Probabilistic Movement Primitive model from demonstrations as well as performing run-time inference. +# Support for importing and exporting a trained model as well +# +class ProMP(object): + ## + # The initialization method for ProMP. + # + # @param basis_model The basis model corresponding to this state space. + # @param scaling_groups If provided, used to indicate which degrees of freedom should be scaled as a group. + # + def __init__(self, basis_model, scaling_groups = None): + self.basis_model = basis_model + self.scaling_groups = scaling_groups + + self.basis_weights = np.array([], dtype = intprim.constants.DTYPE) + self.prior_fitted = False + + self.scalers = [] + # self.init_scalers() + + ## + # Exports the internal state information from this model. + # Allows one to export a trained model and import it again without requiring training. + # + # @param file_name The name of the export file. + # + def export_data(self, file_name): + print("Exporting data to: " + str(file_name)) + + data_struct = { + "basis_weights" : self.basis_weights, + "scaling_groups" : self.scaling_groups, + "scalers" : self.scalers + } + + with open(file_name, 'wb') as out_file: + pickle.dump(data_struct, out_file, pickle.HIGHEST_PROTOCOL) + + ## + # Imports the internal state information from an export file. + # Allows one to import a trained model without requiring training. + # + # @param file_name The name of the import file. + # + def import_data(self, file_name): + print("Importing data from: " + str(file_name)) + + with open(file_name, 'rb') as in_file: + data_struct = pickle.load(in_file) + + self.basis_weights = np.array(data_struct["basis_weights"]) + + try: + self.scaling_groups = data_struct["scaling_groups"] + self.scalers = data_struct["scalers"] + except KeyError: + print("No scalers found during import!") + + ## + # Internal method which initializes data scalers. + # + def init_scalers(self): + if(self.scaling_groups is not None): + for group in self.scaling_groups: + self.scalers.append(sklearn.preprocessing.MinMaxScaler()) + + ## + # Iteratively fits data scalers. + # This must be called on all training demonstrations before fitting, if scaling is used. + # + # @param trajectory Matrix of dimension D x T containing a demonstration, where T is the number of timesteps and D is the dimension of the measurement space. + # + def compute_standardization(self, trajectory): + if(len(self.scalers) > 0): + # N x M matrix, N is degrees of freedom, M is number of time steps + if(type(trajectory) != np.ndarray): + raise TypeError("Trajectory must be a numpy array.") + + if(len(trajectory) != self.basis_model.num_observed_dof): + raise ValueError("Trajectory contains an invalid number of degrees of freedom.") + + if(self.scaling_groups is not None): + for group, scaler in zip(self.scaling_groups, self.scalers): + scaler.partial_fit(trajectory[group, :].reshape(-1, 1)) + else: + print("Skipping basis standardization...") + + ## + # Iteratively adds a demonstration to the model. + # The demonstration is decomposed into the latent space and the weights are stored internally. + # + # @param trajectory Matrix of dimension D x T containing a demonstration, where T is the number of timesteps and D is the dimension of the measurement space. + # + def add_demonstration(self, trajectory): + # N x M matrix, N is degrees of freedom, M is number of time steps + if(type(trajectory) != np.ndarray): + raise TypeError("Trajectory must be a numpy array.") + + if(len(trajectory) != self.basis_model.num_observed_dof): + raise ValueError("Trajectory contains an invalid number of degrees of freedom. Got " + str(len(trajectory)) + " but expected " + str(self.basis_model.num_observed_dof)) + + demonstration_weights = self.basis_transform(trajectory) + + if(self.basis_weights.shape[0] == 0): + self.basis_weights = np.hstack([self.basis_weights, demonstration_weights]) + else: + self.basis_weights = np.vstack([self.basis_weights, demonstration_weights]) + + ## + # Gets the mean trajectory of all trained demonstrations. + # + # @param num_samples The length of the generated mean trajectory + # + # @return mean_trajectory Matrix of dimension D x num_samples containing the mean trajectory. + # + def get_mean_trajectory(self, num_samples = intprim.constants.DEFAULT_NUM_SAMPLES): + mean, var = self.get_basis_weight_parameters() + + domain = np.linspace(0, 1, num_samples, dtype = intprim.constants.DTYPE) + + return self.basis_inverse_transform(domain, mean) + + ## + # Gets the approximated trajectory for the given demonstration. + # This is obtained by transforming the demonstration to the latent space and then projecting it back to measurement space. + # + # @param trajectory Matrix of dimension D x T containing a demonstration, where T is the number of timesteps and D is the dimension of the measurement space. + # @param num_samples The length of the generated approximate trajectory + # + # @return approximate_trajectory Matrix of dimension D x num_samples containing the approximate trajectory. + # + def get_approximate_trajectory(self, trajectory, num_samples = intprim.constants.DEFAULT_NUM_SAMPLES, deriv = False): + # N x M matrix, N is degrees of freedom, M is number of time steps + if(type(trajectory) != np.ndarray): + raise TypeError("Trajectory must be a numpy array.") + + if(len(trajectory) != self.basis_model.num_observed_dof): + raise ValueError("Trajectory contains an invalid number of degrees of freedom.") + + basis_weights = self.basis_transform(trajectory) + + domain = np.linspace(0, 1, num_samples, dtype = intprim.constants.DTYPE) + + return self.basis_inverse_transform(domain, basis_weights, deriv) + + ## + # Gets the approximated trajectory derivative for the given demonstration. + # This is obtained by transforming the demonstration to a latent space composed of the basis function derivatives and then projecting it back to measurement space. + # + # @param trajectory Matrix of dimension D x T containing a demonstration, where T is the number of timesteps and D is the dimension of the measurement space. + # @param num_samples The length of the generated approximate trajectory + # + # @return approximate_trajectory Matrix of dimension D x num_samples containing the approximate trajectory. + # + def get_approximate_trajectory_derivative(self, trajectory, num_samples = intprim.constants.DEFAULT_NUM_SAMPLES): + return self.get_approximate_trajectory(trajectory, num_samples, deriv = True) + + ## + # Gets the probability distribution of the trained demonstrations. + # + # @param trajectory Matrix of dimension D x T containing a demonstration, where T is the number of timesteps and D is the dimension of the measurement space. + # @param num_samples The length of the generated distribution. + # + # @return mean Matrix of dimension D x num_samples containing the mean of the distribution for every degree of freedom. + # @return upper_bound Matrix of dimension D x num_samples containing the mean + std of the distribution for every degree of freedom. + # @return lower_bound Matrix of dimension D x num_samples containing the mean - std of the distribution for every degree of freedom. + # + def get_probability_distribution(self, num_samples = intprim.constants.DEFAULT_NUM_SAMPLES): + trajectory = np.zeros((self.basis_model.num_observed_dof, num_samples)) + upper_bound = np.zeros((self.basis_model.num_observed_dof, num_samples)) + lower_bound = np.zeros((self.basis_model.num_observed_dof, num_samples)) + + domain = np.linspace(0, 1, num_samples, dtype = intprim.constants.DTYPE) + for idx in range(num_samples): + # In rare instances, projecting the covariance matrix can produce negative variance values in the diagonals of the projected matrix. + # Therefore, we instead project each demonstration and manually calculate the empirical mean/covariance. + projected_states = [] + for dem_idx in range(self.basis_weights.shape[0]): + projected_states.append(self.basis_model.apply_coefficients(domain[idx], self.basis_weights[dem_idx, :])) + projected_states = np.array(projected_states) + + dist_mean = np.mean(projected_states, axis = 0) + dist_var = np.cov(projected_states.T) + + if(self.scaling_groups is not None): + var_scale = np.ones(dist_mean.shape) + for group, scaler in zip(self.scaling_groups, self.scalers): + var_scale[group] = 1.0 / scaler.scale_ + dist_mean[group] = scaler.inverse_transform(dist_mean[group].reshape(-1, 1)).flatten() + + var_scale = np.diag(var_scale) + dist_var = np.dot(var_scale, dist_var).dot(var_scale.T) + + trajectory[:, idx] = dist_mean + + for dof_index in range(0, self.basis_model.num_observed_dof): + std_dev = dist_var[dof_index][dof_index] ** 0.5 + + upper_bound[dof_index, idx] = dist_mean[dof_index] + std_dev + lower_bound[dof_index, idx] = dist_mean[dof_index] - std_dev + + return trajectory, upper_bound, lower_bound + + ## + # Transforms the given trajectory from measurement space into the latent basis space. + # + # @param trajectory Matrix of dimension D x T containing a demonstration, where T is the number of timesteps and D is the dimension of the measurement space. + # + # @return transformed_state Vector of dimension B containing the transformed trajectory. + # + def basis_transform(self, trajectory): + if(self.scaling_groups is not None): + scaled_trajectory = np.zeros(trajectory.shape) + + for group, scaler in zip(self.scaling_groups, self.scalers): + scaled_trajectory[group, :] = scaler.transform(trajectory[group, :].reshape(-1, 1)).reshape(trajectory[group, :].shape) + + trajectory = scaled_trajectory + + domain = np.linspace(0, 1, len(trajectory[0]), dtype = intprim.constants.DTYPE) + return self.basis_model.fit_basis_functions_linear_closed_form(domain, trajectory.T) + + ## + # Transforms the given basis space weights to measurement space for the given phase values. + # + # @param x Vector of dimension T containing the phase values that the basis space weights should be projected at. + # @param weights Vector of dimension B containing the basis space weights. + # @param deriv True if the basis weights should be transformed with basis function derivatives, False for normal basis functions. + # + # @return transformed_trajectory Matrix of dimension D x T containing the transformed trajectory. + # + def basis_inverse_transform(self, x, weights, deriv = False): + trajectory = np.zeros((self.basis_model.num_observed_dof, x.shape[0]), dtype = intprim.constants.DTYPE) + + for idx in range(x.shape[0]): + trajectory[:, idx] = self.basis_model.apply_coefficients(x[idx], weights, deriv) + + if(self.scaling_groups is not None): + for group, scaler in zip(self.scaling_groups, self.scalers): + trajectory[group, :] = scaler.inverse_transform(trajectory[group, :].reshape(-1, 1)).reshape(trajectory[group, :].shape) + + return trajectory + + ## + # Gets the mean and covariance for the trained demonstrations. + # + # @return mean Vector of dimension B containing the sample mean of the trained basis weights. + # @return var Matrix of dimension B x B containing the sample covariance of the trained basis weights. + # + def get_basis_weight_parameters(self): + mean = np.mean(self.basis_weights, axis = 0) + + if(self.basis_weights.shape[0] > 1): + var = np.cov(self.basis_weights, rowvar = False) + else: + var = None + + return mean, var + + ## + # Performs inference over the given time duration returns a probable trajectory. + # + # @param times Vector of dimension num_samples containing times at which to generate the trajectory. + # @paran mean Vector of dimension B containing the sample mean of the basis weights. + # @param var Matrix of dimension B x B containing the sample covariance of the basis weights. + # + # @return new_trajectory Matrix of dimension D x num_samples containing the inferred trajectory. + # @return weights Vector of dimension B containing the weights used to infer the trajectory. + # + def generate_probable_trajectory(self, times, mean=None, var=None): + _mean, _var = self.get_basis_weight_parameters() + if mean==None: + mean = _mean + if var==None: + var = _var + + weights = np.random.multivariate_normal(mean, var) + new_trajectory = self.basis_inverse_transform(times, weights) + + return new_trajectory, weights + + ## + # Get the PromP weights after conditioning to reach a particular joint configuration. + # + # @param t Time Phase at which the required joint configuration should be reached. + # @paran mean_q Vector of dimension D containing the mean of the required joint configuration to be reached. + # @param var_q Matrix of dimension B x B containing the sample covariance of the required joint configuration to be reached. + # @paran mean_w Vector of dimension B containing the sample mean of the basis weights. + # @param var_w Matrix of dimension B x B containing the sample covariance of the basis weights. + # + # @return mean_w Vector of dimension B containing the sample mean of the basis weights after conditioning. + # @return var_w Matrix of dimension B x B containing the sample covariance of the basis weights after conditioning. + # + def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None): + basis_funcs = self.basis_model.get_block_diagonal_basis_matrix(t) + d,lw = basis_funcs.shape + _mean_w, _var_w = self.get_basis_weight_parameters() + if mean_w==None: + mean_w = _mean_w + if var_w==None: + var_w = _var_w + + tmp1 = np.dot(var_w, basis_funcs) + tmp2 = np.dot(basis_funcs.T, np.dot(var_w, basis_funcs)) + tmp2 = np.linalg.inv(tmp2) + tmp3 = np.dot(tmp1,tmp2) + mean_w = mean_w + np.dot(tmp3, (mean_q - np.dot(basis_funcs.T, mean_w))) + tmp4 = np.eye(lw) + if var_q is not None: + tmp4 -= np.dot(var_q, tmp2) + var_w = var_w - np.dot(tmp3, np.dot(tmp4, tmp1.T)) + + return mean_w, var_w + + ## # Get the marginal distribution of the learnt trajectory at a given time. + # + # @param t Time Phase at which the marginal distribution is to be calculated. + # @paran mean_w Vector of dimension B containing the sample mean of the basis weights. + # @param var_w Matrix of dimension B x B containing the sample covariance of the basis weights. + # + # @return mean_q Vector of dimension D containing the mean of the marginal distribution at the given time. + # @return var_q Matrix of dimension B x B containing the sample covariance of the marginal distribution at the given time. + # + def get_marginal(self, t, mean_w=None, var_w=None): + basis_funcs = self.basis_model.get_block_diagonal_basis_matrix(t/T) + d,lw = basis_funcs.shape + _mean_w, _var_w = self.get_basis_weight_parameters() + if mean_w==None: + mean_w = _mean_w + if var_w==None: + var_w = _var_w + + var_q = np.dot(basis_funcs.T, np.dot(var_w, basis_funcs)) + mean_q = np.dot(basis_funcs.T, mean_w) + + return mean_q, var_q diff --git a/intprim/util/kinematics.py b/intprim/util/kinematics.py new file mode 100644 index 0000000..65aa384 --- /dev/null +++ b/intprim/util/kinematics.py @@ -0,0 +1,208 @@ +## +# This module defines the base class for implementing the forward kinematics of your robot. +# The code taken from the code by Sebastian Gomez-Gonzalez at https://github.com/sebasutp/promp +# +import numpy as np +import scipy.optimize as opt + +## +# Base Forward kinematics object implementing basic forward and inverse kinematics functionality taken from https://github.com/sebasutp/promp. For your own robot, please extend this class and define your own `_link_matrices` function +# +class BaseKinematicsClass: + + ## + # Initialization function for the class. When extending, add whatever parameters are necessary for implementing the `_link_matrices` function, such as end effector pose or arm lengths etc. + # + def __init__(self): + pass + + ## + # Function implementing the relative linkwise forward kinematics of the robot. This is the main function that needs to be implemented while extending this base class. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # + # @return T list of N + 2 Transformation Matrices each having dimensions 4 x 4. The first should be a transformation to the base link of the robot. The next N matrices are the result of applying each of the N degrees of freedom. The ith matrix is the relative transformation between the (i-1)th to the ith frame of reference The last matrix if the transformation to the final end effector link from the last frame of reference. + # + def _link_matrices(self,q): + base_link_transform = np.eye(4) + link_transforms = [np.eye(4)]*len(q) + end_effector_transform = np.eye(4) + + return [base_link_transform] + link_transforms + [end_effector_transform] + + ## + # Function implementing the forward kinematics of the robot in the global frame of reference. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # + # @return absolute_transforms list of N + 1 Transformation Matrices each having dimensions 4 x 4. The first N matrices represent the pose of the reference frames of each of the N degrees of freedon in the global frame. The ith matrix is the relative transformation between the global frame to the ith frame of reference The last matrix if the transformation to the final end effector link. + # + def forward_kinematics(self,q): + H = self._link_matrices(q) + A = H[0] + absolute_transforms = [] + for i in xrange(1,len(H)): + A = np.dot(A,H[i]) + absolute_transforms.append(A) + return absolute_transforms + + ## + # Function to obtain the euler angles from a given rotation matrix. + # + # @param rotMat The input rotation matrix. + # + # @return eul Vector of size 3 with the yaw, pitch and roll angles respectively. + # + def __rotMatToEul(self,rotMat): + eul = np.zeros(3) + eul[0] = np.arctan2(-rotMat[2,1],rotMat[2,2]) + eul[1] = np.arctan2(rotMat[2,0],np.sqrt(rotMat[2,1]**2+rotMat[2,2]**2)) + eul[2] = np.arctan2(-rotMat[1,0],rotMat[0,0]) + return eul + + ## + # Function to obtain 6DoF pose of the end effector. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # + # @return pos Vector of size 3 with the x,y,z positions of the end effector. + # @return orientation Vector of size 3 with the yaw, pitch and roll angles of the end effector. + # + def end_effector(self, q ,As=None): + if As==None: + As = self.forward_kinematics(q) + end_eff = As[-1] + pos = end_eff[0:3,3] + orientation = self.__rotMatToEul(end_eff[0:3,0:3].transpose()) + return pos, orientation + + ## + # Calculates the numerical jacobian of the forward kinemnatics of the robot. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # @param eps Amount to perturb each degree of freedom with to calculate the jacobian. + # + # @return jac Jacobian matrix of the x,y,z positions of the end effector having shape 3 x N. + # + def __num_jac(self, q, eps = 1e-6): + jac = np.zeros((3,len(q))) + fx,ori = self.end_effector(q) + for i in xrange(len(q)): + q[i] += eps + fxh,ori = self.end_effector(q) + jac[:,i] = (fxh - fx) / eps + q[i] -= eps + return jac + + ## + # Calculates the analytical jacobian of the forward kinemnatics of the robot. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # @param As list of N + 1 Transformation Matrices each having dimensions 4 x 4. The first N matrices represent the pose of the reference frames of each of the N degrees of freedon in the global frame. The ith matrix is the relative transformation between the global frame to the ith frame of reference The last matrix if the transformation to the final end effector link. + # + # @return jac Jacobian matrix of the 6DoF pose of the end effector having shape 6 x N. + # + def __analytic_jac(self, q, As=None): + jac = np.zeros((6,len(q))) + if As == None: + As = self.forward_kinematics(q) + pe = As[-1][0:3,3] + for i in xrange(len(q)): + zprev = As[i][0:3,2] + pprev = As[i][0:3,3] + jac[0:3,i] = np.cross(zprev, pe - pprev) + jac[3:6,i] = zprev + return ans + + ## + # Calculates the jacobian of the forward kinemnatics of the robot. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # + # @return jac Jacobian matrix of the 6DoF pose of the end effector having shape 6 x N. + # + def jacobian(self, q): + As = self.forward_kinematics(q) + #jac = self.__num_jac(q,1e-6) + jac = self.__analytic_jac(q, As) + return jac + + ## + # Calculates the position of the end effector and the jacobian of the forward kinemnatics of the robot. + # + # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # + # @return pos Vector of size 3 with the x,y,z positions of the end effector. + # @return jac Jacobian matrix of the 6DoF pose of the end effector having shape 6 x N. + # @return ori Vector of size 3 with the yaw, pitch and roll angles of the end effector. + # + def position_and_jac(self, q): + As = self.forward_kinematics(q) + jac = self.__analytic_jac(q, As) + pos, ori = self.end_effector(q, As) + return pos, jac, ori + + ## + # Calculates the trajectory of the end effector given a set of joint configuration trajectories. + # + # @param Q Matrix of dimension num_samples x N containing the trajectories of each degree of freedom of the robot in radians (for angles) or meters (for translations). + # + # @return pos Matrix of size num_samples x 3 containing the the x,y,z locations of the end effector. + # @return orientation Matrix of size num_samples x 3 with the yaw, pitch and roll angles of the end effector at each pointin the trajectory. + # + def end_eff_trajectory(self, Q): + pos = [] + orientation = [] + for t in xrange(len(Q)): + post, ort = self.end_effector(Q[t]) + pos.append(post) + orientation.append(ort) + return np.array(pos), np.array(orientation) + + ## + # Calculates the cost function and gradient of the cost function for the Inverse Kinematics optimization. + # + # @param theta Vector of dimension N containing the current estimate of values for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # @param mu_theta Vector of dimension N containing the mean values of the prior for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # @param inv_sigma_theta Matrix of dimension N x N containing the inverse of the covariance matrix of the prior for each degree of freedom of the robot. + # @param mu_x Vector of dimension 3 containing the mean values of the distribution for the goal's 3D coordinates in meters. + # @param inv_sigma_x Matrix of dimension 3 x 3 containing the inverse of the covariance matrix of the distribution for the goal's 3D coordinates. + # + # @return nll Scalar value returning the current cost function value. + # @return grad_nll Vector of dimension N containing the gradient of the cost function w.r.t. the current estimate theta. + # + def __laplace_cost_and_grad(self, theta, mu_theta, inv_sigma_theta, mu_x, inv_sigma_x): + f_th, jac_th, ori = self.position_and_jac(theta) + jac_th = jac_th[0:3,:] + diff1 = theta - mu_theta + tmp1 = np.dot(inv_sigma_theta, diff1) + diff2 = f_th - mu_x + tmp2 = np.dot(inv_sigma_x, diff2) + nll = 0.5*(np.dot(diff1,tmp1) + np.dot(diff2,tmp2)) + grad_nll = tmp1 + np.dot(jac_th.T,tmp2) + return nll, grad_nll + + ## + # Solves the Inverse Kinematics of the robot to reach a particular 3D location while trying to stick close to a prior distribution of the joint configuration. + # + # @param mu_theta Vector of dimension N containing the mean values of the prior for each degree of freedom of the robot in radians (for angles) or meters (for translations). + # @param sig_theta Matrix of dimension N x N containing the covariance matrix of the prior for each degree of freedom of the robot. + # @param mu_x Vector of dimension 3 containing the mean values of the distribution for the goal's 3D coordinates in meters. + # @param sig_x Matrix of dimension 3 x 3 containing the covariance matrix of the distribution for the goal's 3D coordinates. + # + # @param pos_mean Vector of dimension N containing the mean values of the posterior for each degree of freedom of the robot in radians (for angles) or meters (for translations) after solving the inverse kinematics. + # @param pos_cov Matrix of dimension N x N containing the covariance matrix of the posterior for each degree of freedom of the robot after solving the inverse kinematics. + # + def inv_kin(self, mu_theta, sig_theta, mu_x, sig_x): + inv_sig_theta = np.linalg.inv(sig_theta) + inv_sig_x = np.linalg.inv(sig_x) + cost_grad = lambda theta: self.__laplace_cost_and_grad(theta, mu_theta, inv_sig_theta, mu_x, inv_sig_x) + cost = lambda theta: cost_grad(theta)[0] + grad = lambda theta: cost_grad(theta)[1] + res = opt.minimize(cost, mu_theta, method='BFGS', jac=grad) + post_mean = res.x + if hasattr(res, 'hess_inv') + post_cov = res.hess_inv + else + post_cov = None + return post_mean, post_cov From cc7e6a9675c5ed4f3128d3a906c579ea385ee94e Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Wed, 25 Mar 2020 18:55:26 +0100 Subject: [PATCH 02/14] Added Author information for Kinematics class --- intprim/util/kinematics.py | 1 + 1 file changed, 1 insertion(+) diff --git a/intprim/util/kinematics.py b/intprim/util/kinematics.py index 65aa384..c69bb0d 100644 --- a/intprim/util/kinematics.py +++ b/intprim/util/kinematics.py @@ -2,6 +2,7 @@ # This module defines the base class for implementing the forward kinematics of your robot. # The code taken from the code by Sebastian Gomez-Gonzalez at https://github.com/sebasutp/promp # +# @author Vignesh Prasad , TU Darmstadt import numpy as np import scipy.optimize as opt From d271614c4057f1ace19973093f34df8e65f24f62 Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Thu, 26 Mar 2020 13:52:23 +0100 Subject: [PATCH 03/14] Minor bug fix in kinematics.py --- intprim/util/kinematics.py | 42 +++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/intprim/util/kinematics.py b/intprim/util/kinematics.py index c69bb0d..50af361 100644 --- a/intprim/util/kinematics.py +++ b/intprim/util/kinematics.py @@ -173,15 +173,15 @@ def end_eff_trajectory(self, Q): # @return grad_nll Vector of dimension N containing the gradient of the cost function w.r.t. the current estimate theta. # def __laplace_cost_and_grad(self, theta, mu_theta, inv_sigma_theta, mu_x, inv_sigma_x): - f_th, jac_th, ori = self.position_and_jac(theta) - jac_th = jac_th[0:3,:] - diff1 = theta - mu_theta - tmp1 = np.dot(inv_sigma_theta, diff1) - diff2 = f_th - mu_x - tmp2 = np.dot(inv_sigma_x, diff2) - nll = 0.5*(np.dot(diff1,tmp1) + np.dot(diff2,tmp2)) - grad_nll = tmp1 + np.dot(jac_th.T,tmp2) - return nll, grad_nll + f_th, jac_th, ori = self.position_and_jac(theta) + jac_th = jac_th[0:3,:] + diff1 = theta - mu_theta + tmp1 = np.dot(inv_sigma_theta, diff1) + diff2 = f_th - mu_x + tmp2 = np.dot(inv_sigma_x, diff2) + nll = 0.5*(np.dot(diff1,tmp1) + np.dot(diff2,tmp2)) + grad_nll = tmp1 + np.dot(jac_th.T,tmp2) + return nll, grad_nll ## # Solves the Inverse Kinematics of the robot to reach a particular 3D location while trying to stick close to a prior distribution of the joint configuration. @@ -194,16 +194,16 @@ def __laplace_cost_and_grad(self, theta, mu_theta, inv_sigma_theta, mu_x, inv_si # @param pos_mean Vector of dimension N containing the mean values of the posterior for each degree of freedom of the robot in radians (for angles) or meters (for translations) after solving the inverse kinematics. # @param pos_cov Matrix of dimension N x N containing the covariance matrix of the posterior for each degree of freedom of the robot after solving the inverse kinematics. # - def inv_kin(self, mu_theta, sig_theta, mu_x, sig_x): - inv_sig_theta = np.linalg.inv(sig_theta) - inv_sig_x = np.linalg.inv(sig_x) - cost_grad = lambda theta: self.__laplace_cost_and_grad(theta, mu_theta, inv_sig_theta, mu_x, inv_sig_x) - cost = lambda theta: cost_grad(theta)[0] - grad = lambda theta: cost_grad(theta)[1] - res = opt.minimize(cost, mu_theta, method='BFGS', jac=grad) - post_mean = res.x - if hasattr(res, 'hess_inv') - post_cov = res.hess_inv - else + def inv_kin(self, mu_theta, sig_theta, mu_x, sig_x): + inv_sig_theta = np.linalg.inv(sig_theta) + inv_sig_x = np.linalg.inv(sig_x) + cost_grad = lambda theta: self.__laplace_cost_and_grad(theta, mu_theta, inv_sig_theta, mu_x, inv_sig_x) + cost = lambda theta: cost_grad(theta)[0] + grad = lambda theta: cost_grad(theta)[1] + res = opt.minimize(cost, mu_theta, method='BFGS', jac=grad) + post_mean = res.x + if hasattr(res, 'hess_inv'): + post_cov = res.hess_inv + else: post_cov = None - return post_mean, post_cov + return post_mean, post_cov From 54aea2e783d47cbcc57c0136787c1191db4b8b18 Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Thu, 26 Mar 2020 14:25:43 +0100 Subject: [PATCH 04/14] Minor bug fix in ProMP and updated init --- intprim/__init__.py | 1 + intprim/probabilistic_movement_primitives.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/intprim/__init__.py b/intprim/__init__.py index 8dc03b0..3ed4292 100644 --- a/intprim/__init__.py +++ b/intprim/__init__.py @@ -1,4 +1,5 @@ from intprim.bayesian_interaction_primitives import * +from intprim.probabilistic_movement_primitives import * import intprim.basis import intprim.constants import intprim.examples diff --git a/intprim/probabilistic_movement_primitives.py b/intprim/probabilistic_movement_primitives.py index e57a4b5..200c4fb 100644 --- a/intprim/probabilistic_movement_primitives.py +++ b/intprim/probabilistic_movement_primitives.py @@ -5,7 +5,7 @@ # TODO: Implement the EM based learning with NIW prior # # @author Vignesh Prasad , TU Darmstadt -import constants +import intprim.constants import scipy.linalg import autograd.numpy as np import pickle From b9179169438db79835d96d99b479b2aa0ec384d5 Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Thu, 26 Mar 2020 19:34:07 +0100 Subject: [PATCH 05/14] Bug fixes in ProMP and Kinematics --- intprim/probabilistic_movement_primitives.py | 31 +++++++++++++------- intprim/util/__init__.py | 1 + intprim/util/kinematics.py | 17 +++++++---- 3 files changed, 33 insertions(+), 16 deletions(-) diff --git a/intprim/probabilistic_movement_primitives.py b/intprim/probabilistic_movement_primitives.py index 200c4fb..e77e77c 100644 --- a/intprim/probabilistic_movement_primitives.py +++ b/intprim/probabilistic_movement_primitives.py @@ -283,9 +283,9 @@ def get_basis_weight_parameters(self): # def generate_probable_trajectory(self, times, mean=None, var=None): _mean, _var = self.get_basis_weight_parameters() - if mean==None: + if mean is None: mean = _mean - if var==None: + if var is None: var = _var weights = np.random.multivariate_normal(mean, var) @@ -296,7 +296,7 @@ def generate_probable_trajectory(self, times, mean=None, var=None): ## # Get the PromP weights after conditioning to reach a particular joint configuration. # - # @param t Time Phase at which the required joint configuration should be reached. + # @param t Scalar or Vector of length num_samples containing the time phase(s) at which the required joint configuration should be reached. # @paran mean_q Vector of dimension D containing the mean of the required joint configuration to be reached. # @param var_q Matrix of dimension B x B containing the sample covariance of the required joint configuration to be reached. # @paran mean_w Vector of dimension B containing the sample mean of the basis weights. @@ -306,12 +306,17 @@ def generate_probable_trajectory(self, times, mean=None, var=None): # @return var_w Matrix of dimension B x B containing the sample covariance of the basis weights after conditioning. # def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None): + if isinstance(t, (list, tuple, np.ndarray)): + t = np.array(t) + else: # t is scalar + t = np.array([float(t)]) + basis_funcs = self.basis_model.get_block_diagonal_basis_matrix(t) d,lw = basis_funcs.shape _mean_w, _var_w = self.get_basis_weight_parameters() - if mean_w==None: + if mean_w is None: mean_w = _mean_w - if var_w==None: + if var_w is None: var_w = _var_w tmp1 = np.dot(var_w, basis_funcs) @@ -326,9 +331,10 @@ def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None return mean_w, var_w - ## # Get the marginal distribution of the learnt trajectory at a given time. + ## + # Get the marginal distribution of the learnt trajectory at a given time. # - # @param t Time Phase at which the marginal distribution is to be calculated. + # @param t Scalar or Vector of length num_samples containing the time phase(s) at which the required joint configuration should be reached. # @paran mean_w Vector of dimension B containing the sample mean of the basis weights. # @param var_w Matrix of dimension B x B containing the sample covariance of the basis weights. # @@ -336,12 +342,17 @@ def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None # @return var_q Matrix of dimension B x B containing the sample covariance of the marginal distribution at the given time. # def get_marginal(self, t, mean_w=None, var_w=None): - basis_funcs = self.basis_model.get_block_diagonal_basis_matrix(t/T) + if isinstance(t, (list, tuple, np.ndarray)): + t = np.array(t) + else: # t is scalar + t = np.array([float(t)]) + + basis_funcs = self.basis_model.get_block_diagonal_basis_matrix(t) d,lw = basis_funcs.shape _mean_w, _var_w = self.get_basis_weight_parameters() - if mean_w==None: + if mean_w is None: mean_w = _mean_w - if var_w==None: + if var_w is None: var_w = _var_w var_q = np.dot(basis_funcs.T, np.dot(var_w, basis_funcs)) diff --git a/intprim/util/__init__.py b/intprim/util/__init__.py index 46feeed..8856346 100644 --- a/intprim/util/__init__.py +++ b/intprim/util/__init__.py @@ -1,2 +1,3 @@ from stat_collector import * import visualization +from kinematics import * diff --git a/intprim/util/kinematics.py b/intprim/util/kinematics.py index 50af361..a8ab0e8 100644 --- a/intprim/util/kinematics.py +++ b/intprim/util/kinematics.py @@ -36,7 +36,7 @@ def _link_matrices(self,q): # # @param q Vector of dimension N containing the values for each degree of freedom of the robot in radians (for angles) or meters (for translations). # - # @return absolute_transforms list of N + 1 Transformation Matrices each having dimensions 4 x 4. The first N matrices represent the pose of the reference frames of each of the N degrees of freedon in the global frame. The ith matrix is the relative transformation between the global frame to the ith frame of reference The last matrix if the transformation to the final end effector link. + # @return absolute_transforms list of N + 1 Transformation Matrices each having dimensions 4 x 4. The first N matrices represent the pose of the reference frames of each of the N degrees of freedon in the global frame. The ith matrix is the relative transformation between the global frame to the ith frame of reference The last matrix if the transformation to the final end effector link. # def forward_kinematics(self,q): H = self._link_matrices(q) @@ -70,7 +70,7 @@ def __rotMatToEul(self,rotMat): # @return orientation Vector of size 3 with the yaw, pitch and roll angles of the end effector. # def end_effector(self, q ,As=None): - if As==None: + if As is None: As = self.forward_kinematics(q) end_eff = As[-1] pos = end_eff[0:3,3] @@ -105,7 +105,7 @@ def __num_jac(self, q, eps = 1e-6): # def __analytic_jac(self, q, As=None): jac = np.zeros((6,len(q))) - if As == None: + if As is None: As = self.forward_kinematics(q) pe = As[-1][0:3,3] for i in xrange(len(q)): @@ -113,7 +113,7 @@ def __analytic_jac(self, q, As=None): pprev = As[i][0:3,3] jac[0:3,i] = np.cross(zprev, pe - pprev) jac[3:6,i] = zprev - return ans + return jac ## # Calculates the jacobian of the forward kinemnatics of the robot. @@ -181,6 +181,7 @@ def __laplace_cost_and_grad(self, theta, mu_theta, inv_sigma_theta, mu_x, inv_si tmp2 = np.dot(inv_sigma_x, diff2) nll = 0.5*(np.dot(diff1,tmp1) + np.dot(diff2,tmp2)) grad_nll = tmp1 + np.dot(jac_th.T,tmp2) + return nll, grad_nll ## @@ -194,16 +195,20 @@ def __laplace_cost_and_grad(self, theta, mu_theta, inv_sigma_theta, mu_x, inv_si # @param pos_mean Vector of dimension N containing the mean values of the posterior for each degree of freedom of the robot in radians (for angles) or meters (for translations) after solving the inverse kinematics. # @param pos_cov Matrix of dimension N x N containing the covariance matrix of the posterior for each degree of freedom of the robot after solving the inverse kinematics. # - def inv_kin(self, mu_theta, sig_theta, mu_x, sig_x): + def inv_kin(self, mu_theta, sig_theta, mu_x, sig_x, **kwargs): inv_sig_theta = np.linalg.inv(sig_theta) inv_sig_x = np.linalg.inv(sig_x) cost_grad = lambda theta: self.__laplace_cost_and_grad(theta, mu_theta, inv_sig_theta, mu_x, inv_sig_x) cost = lambda theta: cost_grad(theta)[0] grad = lambda theta: cost_grad(theta)[1] - res = opt.minimize(cost, mu_theta, method='BFGS', jac=grad) + + kwargs.setdefault('method', 'BFGS') + kwargs.setdefault('jac', grad) + res = opt.minimize(cost, mu_theta, **kwargs) post_mean = res.x if hasattr(res, 'hess_inv'): post_cov = res.hess_inv else: post_cov = None + print res return post_mean, post_cov From b41996ab055a75bdb336ac56846e000cf06ee33e Mon Sep 17 00:00:00 2001 From: neo Date: Wed, 1 Jul 2020 01:16:45 +0200 Subject: [PATCH 06/14] Added ProMP example Committer: souljaboy764 --- docs/notebooks/5_promp_example.ipynb | 368 +++++++++++++++++++++++++++ intprim/examples/promp_example.py | 195 ++++++++++++++ 2 files changed, 563 insertions(+) create mode 100644 docs/notebooks/5_promp_example.ipynb create mode 100644 intprim/examples/promp_example.py diff --git a/docs/notebooks/5_promp_example.ipynb b/docs/notebooks/5_promp_example.ipynb new file mode 100644 index 0000000..f786c51 --- /dev/null +++ b/docs/notebooks/5_promp_example.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "source": [ + " \n", + "# 5. Toy example of a Probabilistic Movement Primitives (ProMPs) and Conditioning\n", + "\n", + "In order to run this, please first download the sample data at https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz\n", + "\n", + "This code is adapted from the code at https://github.com/sebasutp/promp/\n", + "\n", + "### Training a ProMP\n", + "\n", + "First we shall load some sample data and fit a ProMP with the learnt samples." + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "source": [ + "import intprim\n", + "from intprim.probabilistic_movement_primitives import *\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from intprim.util.kinematics import BaseKinematicsClass\n", + "\n", + "\n", + "# Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz\n", + "with open('strike_mov.npz','r') as f:\n", + "\tdata = np.load(f,allow_pickle=True)\n", + "\ttime = data['time']\n", + "\tQ = data['Q']\n", + "num_joints = Q[0].shape[1]\n", + "\n", + "# Create a ProMP with Gaussian basis functions.\n", + "basis_model = intprim.basis.GaussianModel(8, 0.1, ['joint'+str(i) for i in range(num_joints)])\n", + "promp = ProMP(basis_model)\n", + "\n", + "# Add Demonstrations to the ProMP, which in turn calculates the list of weights for each demonstration.\n", + "for i in range(len(Q)):\n", + "\tpromp.add_demonstration(Q[i].T)\n", + "\n", + "# Plot samples from the learnt ProMP\n", + "\n", + "n_samples = 20 # Number of trajectoies to sample\n", + "plot_dof = 3 # Degree of freedom to plot\n", + "domain = np.linspace(0,1,100)\n", + "\n", + "for i in range(n_samples):\n", + "\tsamples, _ = promp.generate_probable_trajectory(domain)\n", + "\tplt.plot(domain, samples[plot_dof,:], 'g--', alpha=0.3)\n", + "\n", + "mean_margs = np.zeros(samples[plot_dof,:].shape)\n", + "upper_bound = np.zeros(samples[plot_dof,:].shape)\n", + "lower_bound = np.zeros(samples[plot_dof,:].shape)\n", + "for i in range(len(domain)):\n", + "\tmu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i])\n", + "\tstd_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5\n", + "\t\n", + "\tmean_margs[i] = mu_marg_q[plot_dof]\n", + "\tupper_bound[i] = mu_marg_q[plot_dof] + std_q\n", + "\tlower_bound[i] = mu_marg_q[plot_dof] - std_q\n", + "\n", + "plt.fill_between(domain, upper_bound, lower_bound, color = 'g', alpha=0.2)\n", + "plt.plot(domain, mean_margs, 'g-')\n", + "plt.title('Samples for DoF {}'.format(plot_dof))\n", + "plt.show()" + ], + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": "" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": {} + }, + { + "source": [ + "### An example of Joint Space Conditioning.\n", + "\n", + "Here, we want to condition the ProMP with to start at from an initial joint configuration given by `q_cond_init`." + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "source": [ + "q_cond_init = [1.54, 0.44, 0.15, 1.65, 0.01, -0.09, -1.23]\n", + "t = 0\n", + "\n", + "# Condition the ProMP and obtain the posterior distribution.\n", + "mu_w_cond, Sigma_w_cond = promp.get_conditioned_weights(t, q_cond_init)\n", + "\n", + "# Plot samples of the conditioned ProMP drawn from the predicted posterior.\n", + "plt.plot(0,q_cond_init[plot_dof],'bo')\n", + "for i in range(n_samples):\n", + "\tsamples, _ = promp.generate_probable_trajectory(domain, mu_w_cond, Sigma_w_cond)\n", + "\tplt.plot(domain, samples[plot_dof,:], 'b--', alpha=0.3)\n", + "\t\n", + "for i in range(len(domain)):\n", + "\tmu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_cond, Sigma_w_cond)\n", + "\tstd_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5\n", + "\t\n", + "\tmean_margs[i] = mu_marg_q[plot_dof]\n", + "\tupper_bound[i] = mu_marg_q[plot_dof] + std_q\n", + "\tlower_bound[i] = mu_marg_q[plot_dof] - std_q\n", + "\n", + "plt.fill_between(domain, upper_bound, lower_bound, color = 'b', alpha=0.2)\n", + "plt.plot(domain, mean_margs, 'b-')\n", + "plt.title('Joint Space Conditioned Samples for DoF {}'.format(plot_dof))\n", + "plt.show()" + ], + "cell_type": "code", + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": "/home/neo/.local/lib/python2.7/site-packages/ipykernel_launcher.py:15: RuntimeWarning: invalid value encountered in double_scalars\n from ipykernel import kernelapp as app\n" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEICAYAAABYoZ8gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsvXl8XMd1LvhVdwMNdGNfSQDEQoAUCYKkRJEUtViSZWuxLdl5ybyxnTiOs4xeMtnH8Tjxy3uy4zhx1oknznu2EtuKYlvOSxw7jpeRFcsSZcmiJEqkuIEkiH3f0WisvdT88fVJ3Qa7gcZCoAHU9/vdHxp9b99bt+6t75w6dRaltYaFhYWFxfaBa6MbYGFhYWGxvrDEb2FhYbHNYInfwsLCYpvBEr+FhYXFNoMlfgsLC4ttBkv8FhYWFtsMlvhvIJRSQaXU7o1ux1aEUurjSqkvxz5Xx/ravcjx6/4slFK1SimtlPKs53WXC2dfruE5lVLqS0qpMaXUK2t5bovVwxL/CqCUek4p9UtLHae1ztFat6Z4Tq2Ualhkf6ZS6i+UUt0xEmtTSv0/y2n3jUZssP+GUuq8Umoq1tZ/UkodvJHX1Vp3xvo6EmvHdc9nOc9ivaCUuksp9ZJSakIpNaqUelEpdWyj27VGuAvA/QCqtNbHV3syhxANxrYBpdS3lVL3L+McTyil5h3nCCql3pvk2B8qpYaUUgGl1Fml1HtWew/pBEv8mwe/B+AogOMAcgG8FcAbG9qi6/EZAL8J4DcAFAHYC+CbAN61kY1KRyil8gB8G8Bfg31VCeATAOY2sl1riBoA7VrrqeX+cIkZUoHWOgfAYQDPAPiGUupDyzj9n8aUANn+Mclxvwlgp9Y6D8CjAL6slNq5jOukN7TWdlvmBuA5AL8U+/x/AGgBMArgWwAqHMdpAA2xz08A+BsA3wEwCeAUgPrYvpOxY6cABAG8N8E1vw3gtxZpUzsoHC4CGAPwJQBZsX2Fsd8PxfZ9G9TE5LdFseN7Y/u/6dj3MIAzAMYBvATgUJLr7wEQAXB8kTbmA3gy1o4OAL8PwBXb9yEAPwLw57E2tAF4h+O3dQCej/XdMwA+C+DLsX21sf7zAPhUrB2zsb78bIJnsZp25AP4AoA+AD0A/hCAO7bPHfvdMIBWAL8q7UrQF0cBjC/SV/UAngUwEjvfV0DScz7vjwB4M/befAFAOYDvxfro3wEULuifR2PPuA/Ahx3n+rj0Zez/E7FnPQ7gLIB7Hfs+FLu3yVjf/EyCtv9irP8jsWfwiRTHyq8CuAqgLcE5/+MZL/j+dwAMOJ7ffnB8jgO4AODdjmOfAPCHKxjvx2P3k/Td3mzbhjdgM26xF+uXANwXG5RHAHhB7e2k47iFxD8ae4k8sYH8tUTHJrnm7wPoBPB/AjgIQC3Y3w7gPIBdIJG/KC85gGIAPwXAB84W/gnx5P4dAP8ICogMAPfEvj8CYBDAbSCp/VzsOt4E7ftlAB1L9NuTAP411oZaAFcA/GJs34cAhGLk4AbwKyBJqdj+HwP4y1g/3w0Sz3XE73w+C67tfBaracc3AXwegB9AGYBXAPwXRx80O57BD5Gc+PNAUv97AO9AjKQd+xtAU4kXQCmoHPzVguf9Mkj2lbHn9DqAW2K/eRbAYwv656lYuw+CQu/tsf0fd/RlZaxd7wQtAvfH/i+N/TYA4KbYsTsBHEjyrD8E4EeO/1MZK8/E+i07wfninrHj+92x7/eD724LgI8ByIxdc9LR3iewDOIHFaTZ2Pn/P8SEy1bYNrwBm3GDIf4vgFNH+T4nRhq1sf8XEv/fOY59J4Bmx/9LEb8b1IheBM0BvQB+zrG/HcAvLzj/tSTnuhnAWOzzTgBRLCCe2L7/CeCTC767jJhgWPD9fwXw8hLtnwPQ6PjuvwB4Lvb5QwBaHPt8sT7ZAaAaQBiA37H/q1gB8a+yHeWx32Y79r8fwA9jn59d8AweQBLij+3fH3svumP39y0A5UmO/QkAbyx43j/j+P/rAP6n4/9fR0y4O/pnn2P/nwL4Quzzxx19+VEA/7Dg2k+DQt8PatI/hQTkvOA3H0I88acyVu5b5Hxxz9jxfVbs+zsBvAVAPxwEDQq7jzvG4GzsHsYBDKcw1jNAwfzbSx27mTZr418dKkBTAQBAax0EtaPKJMf3Oz5Pgy9/StBaR7TWf6O1vhNAAWjS+KJSar/jsC7H545Y+6CU8imlPq+U6lBKBUDtsSDmBbMLwKjWeizBZWsAfFgpNS5b7PiKBMeOgEIkGUpALazD8V0H4vvqP/pHaz0d+5gTu96YjrcXO8+zHKymHTUgEfQ5+uPzoOaPWDsXPoOk0Fpf0lp/SGtdBaAp9vu/AgClVJlS6mtKqZ7YM/tyrO1ODDg+zyT4f+H7lfD9WIAaAP95wTO/C7R3TwF4Lziz6VNKfUcptW+xe3QglbHStfBHKUB+Pxq7RpfWOurYv/DZ/rnWuiC2LezP66C1DmmtvwfgQaXUu1fQvrSEJf7VoRccKAAApZQfNKv03MiLaq1ntNZ/A9qgGx27djk+V8faBwAfBnATgNs0F6vuliaDg61IKVWQ4FJdAD7lGCgFWmuf1vqpBMf+AECVUupokmYPgxpejeO7aqTWV30ACmP96/xtMuhF9q2mHV2gxl/i6I88rfUBRzsXPoOUoLVuBjXSpthXfwzex6HYM/sA+LxWg2TvhxNdoMbvfOZ+rfWnY+18Wmt9PyjkmwH8bYrXTmWsLPbckuE/gWauy7Fr7FJKOXkt1We7FDzgusuWgCX+1eGrAH5eKXWzUsoL4I8AnNJat6/gXAOgvTIhlFK/pZS6VymVrZTyKKV+DrRROz17flUpVaWUKgLtnOKxkAtqgOOxfY/JD7TWfeCC4P9QShUqpTKUUiIY/hbALyulbou5avqVUu9SSuUubJ/W+iqA/wHgqVg7M5VSWUqp9ymlflfT1fJ/AfiUUipXKVUD4P8CNdlFobXuAPAagE/EznsXgEcW+UnSvlxlO/oAfB/AXyil8pRSLqVUvVLqntgh/wvAb8SeQSGA3012LqXUPqXUh5VSVbH/d4Fmo5djh+SCC6PjSqlKcCF3tfhvsdnfAQA/D/N+OPFlAI8opR5USrljz/De2D2VK6XeHSPtuVj7Iileey3HCmJt+TXwXf69mJZ/Clzo/r9j7/G94HvytWWee59S6h2xsZahlPoAqCw9v5K2piMs8a8cWmv9AwD/DbSv9oEawftWeL6PA/j72PT6f0+wfwbAX4BmiGHQ3v9TOt43/asgMbXGtj+Mff9XALJjv3sZXKhy4mdBLbgZ1J5+K3aDr4GLnJ8FZxctoO02GX4jduzfgDbUa6BG9m+x/b8ODsxW0HPmqwC+uMj5nPhpcJF5FBzsTy5y7GcA/G+KwUP/b4L9q2nHB0FTkXhP/TOMietvQXv4WXCh9V8WOc9k7H5OKaWmwOdyHpydAXTtPAJgAlx8X+xcqeJ58Bn+ADR5fH/hAVrrLgDvARWHIXAG8BGQK1yx9vWCz+Ee0NlgSazhWBmP9dc5cB3rP2utvxi7xjyAd4M2+WFQEflgbDa1HChwPA6CffCboKfd6ytob1pCPBUslgGl1OsA/kBr/c2NbotAKdUOLmj++0a3xSK9oJSqBV0vM7TW4Y1tjUU6wGr8y0Rsmrwf6Rc8ZWFhYZESLPEvA0qpPwFNKR+N2Z0tLCwsNh2sqcfCwsJim8Fq/BYWFhbbDGmZLrakpETX1tZudDMsLCwsNg1Onz49rLUuTeXYtCT+2tpavPbaaxvdDAsLC4tNA6VUyuuO1tRjYWFhsc1gid/CwsJim8ESv4WFhcU2gyV+CwsLi20GS/wWFhYW2wyW+C0sLCy2GSzxW1hYWGwzpKUfv4XFZsH8PDA9Dfh8QGYmP/f0ANEo4HYDGRmAxwMUFwNZWRvdWgsLwhK/hcUyMDcHdHYC4+PcZmf5/ZEjQGUlib85Qfb3EydI/IODwJUrQEEBt6IiCg0Li/WEJX4LiyUwOgpoTa1da+DyZcDv5/8FBSTugljhyuJi4F3vApSi1h8KccvO5n63G3C5KDza2vid3w/cfrs5xsLiRsMSv4VFAoRCQFcX0NEBBIPAjh3GXPPggzThJIJS3ACSvNsdb+IpLgbuuIMCZHISGB6mYJFjrl4FZmY4eyguvrH3aLF9YYnfwmIB2ttprgmFgMJC4PBhErEgGekvB0oBeXncdjuqA8/PA93dFDh+P1BTA1RVAV7v6q9pYSGwxG9hAZplnNp6cTGwdy+Qn7++7ThwANi3D+jtpTno4kVgYoJrCBYWawVL/BbbHkNDwPnz1LxraoDaWm4bBbcb2LWL2+Qk1wQAfr5wAWhoAEpKNq59Fpsflvgtti1CIeDcObpf+v3p6V2Tm2s+z8wAgQDw4x/TBLVnD1BevnFts9i8sMRvsS0xMgK88QbdMffuJYm60jycsawMePvbaQJqaQFeeYWa/4kTxkRlYZEKLPFbbEtIgNVddxlXzM0Al4tmqOpqeh2FQob0p6Y4c7GwWAqW+C22DUIh2vMrKoDSUuDeezevpuxycT1CMDQEvPwyvY/277cxARaLwxK/xbZAIAC8+ipNO0VF9JvfrKSfCAUFNFdduwb09XGhes8epouwsFiINLdqWlisHsPDwIsv0rxzxx1bM2dORgbdQN/2Ns5oWlp4zxYWiWD1AYstjZ4e4MwZ2r4lX85WRlYWcMstQF0d8woBjBIOBNY/JsEifWGJ32JLY26Oro/Hjq1NxO1mgXPBuqsLOHuWcQH799soYIsUTD1KqS8qpQaVUueT7C9USn1DKfWmUuoVpVSTY99DSqnLSqkWpdTvrmXDLSwWg2TN3L2bCdC2E+kvREUFg756eoBnn2VyOK03ulUWG4lUbPxPAHhokf0fA3BGa30IwAcBfAYAlFJuAH8D4B0AGgG8XynVuKrWWlikgKtXgR/+kMnVgK21iLsSeDzU9O+9l7Of8+eB11/f6FZZbCSWNPVorU8qpWoXOaQRwB/Hjm1WStUqpcoB7AbQorVuBQCl1NcAvAfAxdU22sIiGa5eZYK1ykrr074Qss7R12fMPeEwEIlY8892w1p49ZwF8JMAoJQ6DqAGQBWASgBdjuO6Y99ZWNwQtLUZ0r/lFqvpJ8POnXRpBVgU5oc/ZEZSa/7ZPlgL4v80gEKl1BkAvw7gDQBhAImGXdJXSyn1qFLqNaXUa0NDQ2vQLIvthOFhmjB27LCkvxxUV9Pb59w54Ec/YlUxi62PVRO/1jqgtf55rfXNoI2/FEAbqOHvchxaBaB3kfM8rrU+qrU+WlpautpmWWwzFBXRjn3kiCX95SAnh4vfR44wCdwLL1D7t9jaWLU7p1KqAMC01noewC8BOKm1DiilXgWwRylVB6AHwPsA/PRqr2dh4UQgQN/1zEx6rlisDJWVzPR5+bJJ+RwOM5+RFaRbD0sSv1LqKQD3AihRSnUDeAxABgBorT8HYD+AJ5VSEXDh9hdj+8JKqV8D8DQAN4Avaq0v3IibsNiemJkBTp0yWqvF6uDxsBCM4MwZxkEcPMhKYRZbB6l49bx/if0/BrAnyb7vAvjuyppmYZEc4TDTEofDQFPT0sdbLB9lZcClS8DJk8wIetNN2zseYivBRu5abDpoTT/0yUngttvii5VYrB2qq+kB1NxMu39PDyOgxSPIYvPCEr/FpkNLCzAwQBOE9QO4scjIYD9XV9P+n5PD7yMR2v8tNics8VtsOtTU0B69kXVxtxvy84Hjx/lZa+CllxgQ1ti49RPfbUXYtMwWmwYzM0ytnJnJ7JMWGwOtOdPq62PunytXOAOw2DywxG+xKRAKUcs8c2ajW2LhcjH3/1vfygXgy5cpACYnN7plFqnCmnos0h5am8LoVtNPH/h8wNGjwOgo02VIbqTZWWv+SXdY4rdIe1y7xsXcpiZml7RILxQVGU+fSITRv34/I6nt80pPWFOPRVpjZITuhBUVVtvfDFCKEdTBIHP/vPoqo6st0guW+C3SGhkZXEg8fHijW2KRClwuCuj77uM6wMgI8PzzwMTERrfMwglr6rFIa+TlMUhrqyIS4cL1/DyjkAsKSJ7BoNGUleJ3LhdQXMy/4TDXPtI1ktbjAfbsocttT4+p99vTw2dqg+42Fpb4LdIS7e0kvqYmEt1mhdYk8WAQmJpi3Vuvl3Vwz5273g3yvvtoH+/vZ7qEhXjgAf6+pYVFZ5Sie6vXywXVo0cZWBUIUKBkZ3PbqERrGRkm3iIaBS5cYP6fHTtoErJrABsDS/wWaYfJSRJEScnmI32tSbJjY6wPEAiQ8AQFBSTpnBwGonm9JO6MDGrJ4g1TXc1smXLOaJSbaPjl5fzd3BxnC/JXomlbWylcAPahz0dN+9Zb+d3MjLnmesHlYvnHtjZu/f2cwRw4YGYEFusDS/wWaYVolHl4PB7g5ps3ujVLIxQChoaAwUH+3bePWr3HY6KL8/Np2vD7DdEWFi6u7WZmckuGpX6/bx9TLU9Pc6YxNRUvgM6cYfEan49ty8ujZ05Z2bJuf9nIzGSyt/p6oLOTHlsyG5mbY//YVBA3Hpb4LdIKzc3Uko8fX986sMEg/dFnZ2l+CYdJlI2N1IyHh7k/I8No6RcucHYitvbSUppVAJLpRqaKzspa3Je+oYEzqkCA9zA4yP+F+N94g/eYn88tJ2dtzUUeD7B7NxeC5bwXLrAdu3ZRYNqayTcOlvgt0gbz80BHB00gYuZYS2hNkhsepilGBIzfT8K5EKsW4XKRmCRCFaA2f+oU27hzJ7+7epU298pKCoyZGf5mMyQwKy2NT3AXjfLeAPbT9DRTMsgahNvNxdo9sQTsU1OcLaxWGDh/L2sBbW00VZWUUDDs2LG6a1hcD0v8FmmDzEzg7rtvTNTn8DBw+rQht+xsarJSYHzXLhK61xu/rhAMkuC7u2kKycoCTpwgyR86RCEF0HQiNnWleO7SUiM40h0ul+l3pYA77zQL0xMTrMUrmTmnp5miISODaxayFRUtbp5aChIIduAAzUCdnZxl7djBtgQCdi1graC0Tlr/fMNw9OhR/dprr210MyzWESMjXOhbK4yO0jOotJSkPj8PXLxILbK42JhkFkN7Oz1vXC4Khepq/jaZljs3x5mEbC4XhQTAa2dlcSaz2U0YoRBnA+PjvE8xd916KwPtgkGgt9cIhJUKA1nUdrs543r5ZZrQKit5nc3ej2sNpdRprfXRlI61xG+x0ejvZ4TnkSMc1CtFJEKtu72dZJSRwYXEVCN+tWZbfD5qllNTJLDq6tWtN2jNKlbil5+TQ0FSVWW06M2MSIT3lpPDPu/u5hqBIDubAqCpicJPPJ+Wg1CIz6K7m0IdMKmibV4gYjnEb009FhuK+XngzTc5iMV2vlK8+io1w4ICRvpWVqZua+/vZ5bJQIBEf/gwNco9CYuKLg9KAffcQxPJwACv1dJCkszJIXHOzGxeIeB2x3sYVVXRPDM+bsxEExPGo+nyZQrovDzj8bRUUFdGBs1qNTXsq95emu9EIF+7RuFQVsa22ALxiyOVYutfBPAwgEGt9XXVTZVS+QC+DKA6dr4/11p/KbYvAuBc7NBOrfW716rhFlsD585xwJ44sXyffa1JIBUVJJWGBhL1ckxGIyM0w4yPk+iPHOH5bgR8Ps4+6uoo8ISc+vvpwlpQQLNURcXqbOXpAI+HZrWSkuv3FRSQvAMBCmqtefxDD7FPOjrYPzk53Pz++HcjO5vuoPX15rtAgFHBV68aD6udO2/cs9zsSEXjfwLAZwE8mWT/rwK4qLV+RClVCuCyUuorWut5ADNa603gjW2xEejro+a2bx81vuVgaMi4U0aj9AhJRDJLYWSEHjmHD5N010tTdBJ7SQkXNCWa98IFrgXcfPP6BlitF3bsMJ460SjXBGZnTd8PDlIYCpRiH8l6SU8Pv/P5KAS8XuCWW2hKcsZUuN2G+M+f5+yiuJi/2+5Y8rXSWp9UStUudgiAXKWUApADYBRAeE1aZ7Gl4XaT4BoaUv/N/DwHcU+PyQe/HBNRNEqtsKCA1xbNcSPdL71e+rTv3k3NtauLf4X0+/vZ3q1oy3a5KPSdgv/YMZq/JNVFMBifk+jiRQoK5zmqqii8KyrYdzU1/L63lzOKlhbzjGU2snv32joUOBGN8rqyud1sTzTKGBGlzOZyrb9pai30ic8C+BaAXgC5AN6rtZYYwSyl1GugIPi01vqba3A9iy2CsrLlR4q++Sbt5Hv30qyzHPPQ8DB/PzVFYVNenn7+9nl51P4F0SgXSiMR9lVNDf9udRu2222Cxxbi3ntpKpqe5t/Z2fj1ETEVObF7N2eFw8PAt75F05rMEqemeK59+6hMXL7Mv1lZpp/r6jgjnJkBfvxjQ+hC8Pv3c20oEGA20oW45RYKp/Fx4MUXr9+/XAVmtVgL4n8QwBkA9wGoB/CMUuoFrXUAQLXWulcptRvAs0qpc1rra4lOopR6FMCjAFBdXb0GzbJIVwwMcIDU18cTt9PbIxDgIJMoWqU4rd+/n546Pl/qpB8KUUvs7OTvTpyID15KZ7hcXBgWv/aBAfbD4cOb5x7WGhkZ3JKZBx980ASkzc/z+Ut+pJwc4OGH+U5FIjxufJzkL7Ottja+i4cOUfAEAux7j4cmutxco8GLxi6upV4vlRLZJ5sIMJ+PJinnbCASWf9spWtB/D8PavMaQItSqg3APgCvaK17AUBr3aqUeg7ALQASEr/W+nEAjwN051yDdlmkIUIhat0S3To1RTu9+II/9BCPu3qV0/RAgB4bOTnAwYPA/fdz/6lT1N6yszmY/H4OrkQ6w8AAB3RDAwdlumn5S8Hnoza6dy/NPh0dxpslGGSf2iyX8ZCAtIXmMZdrcdNiOMx3Lhg0TgPXrlFxEDdSgO/d3XdTEIyNUUkZH+ezuumm5OfPykqPgkJrQfydAN4G4AWlVDmAmwC0KqUKAUxrreeUUiUA7gTwp2twPYtNiFCIBDwywkCnkhIuYmZkUNvZsSM+qOqmm6gpzcxwmnzoEO3cgqoq/k6m/D09xhUTYGH2YJD/FxRQy1/J4m86weUiGTk9VVpaKNTy82m6WI4Lq8X18HjiS0kCnJnW1JjU2mIaknUHmY0J3G4qIvfcw/+HhylQfD5u6bBgn4o751MA7gVQopTqBvAYgAwA0Fp/DsAnATyhlDoHQAH4qNZ6WCl1B4DPK6WiYKWvT2utL96Y27BIR0SjRtseGqJGBJDId+/m/kQeFuEw7ay9vRx0hw9fP1gqK68P9pK8MpOTTPY2PMwBKkQo/vkAB2+yyE8xLznNAZGImZoLnItzLhevI5vk+rnRkDrEbW3A2bPUTOvr1yb+wMLA4zGRyAtx4ADfZ8mEOjPDd0fQ0sL3X5CZScFy7Bj/Hx3lO5OTs35COxWvnvcvsb8XwAMJvn8JwMGVN81iM2Nqilr37Cw1+dpaJt7y+6nNL/aCRyKcPjc2xvtqLwW3m2aQ8+c5I3jkEQ4wCSISop+dBb73PWOblWyb0SgHrzN9capQKl4oACQLKYQi5qisLF5PrrnaRVqPxwQ2jYwwalkEoNYUfiUlW38xeCPh8XD2mcxOf+utZpYgwsGpyJw9y9kEQPPReuQjSoNJh8VWQShEbbuoiERXUkJPhfJyEk9lpcm9kgjBoCHit751edqP1kyU1t3NRc9bbjF2cL+f+8fHOSUfHjZrCxMTxt3uwAG2V4h/tVNymTkEg7x2KHT9jCEnh4uUBQXGLz0ra2WzheLiePfE4WHmt/H5KHh37dr8gWGbEc5kdolw9KhxW12v/EM2V4/FqhGN0tQgpQDvvz+euKLRpYlMolfr6xdfHFsM586R2OrqTPrl/n5OvSU6VBb8nO2ZmiIxl5RQWPT1cXqem2vsvX7/2mvNWhvPk7k5IxRcLgqEoiKacbKzef3lmgGiUd5/eztnA7JG0NSUvrV6LVYOm6vHYt0wOkovnclJ+pfv33+9i+aLLy6eorijg+coKDA52VPF0JAxnZSUcF3g2We5LyOD2u5SOXD8/nhNKzeX2rFk+Gxvp0A5epTCYyVJxhJBKdN2p5lAawqCnh5e29mu4mIjiLKzFxeozsXgyUkjAGQmI6mW02Gx0WJ9YR+5xYoxMUFSz87mQlWighmtrSSYZLb6lhYWFS8rM4XCl0I0Si29s5OzhEDABNN4PCanfn09CTsQYBi/aPxSmNwZoOOE+HvX1lIbHxujbVYI8uJFmm2Ki6mRr3VyNaWud0VMJAxcLgqBkhJTJSuZJp+bS3dYEVpaA6+8QlNUZSXXCJKZIiy2HizxWywboRAJJj+fSc3KyxNrjdPT9M4pL0+cLEv2V1YyL00y7TUUInEPD1PY9PXRnh8OcxF31y5+5/WyHUrFL9DOzvL34QWJRG69lZrzxAQ14tzc6z0rMjOvrwaWm8u2SNHwzEzew65dqfXfSpBIGESjNGNdvszPSvF+SksplHJyrq87IIJOKaY0bm+nMOns5FpDY+P2DQzbTrDEb7EsXLsGXLnCCk15eYvnzz8Xy8t6MIlvl88HvOUtJNKFmncgwO9yc6npvvoqBcX4OE1D0SgXcPfu5XFSCSsRJDWERHPOzhpvI4AmHameJfb1ggK6fyYSRtXV3KTwyuioaX8kwhmMVKS6kQnBXC7jGy6QWUFbG//3ennvxcV8Xs5yiQUFFLgHDtBE1tFhziPeJ9YjaGvCEr9FSohE6HbW03N9sFUiTE3Rnrxv3/XHXrhAQq+ujg+7n5+n5tnVRQ+HykoKDVmYLCighu/zUStdbi3WZNGcdXXGDi6ePkNDZr2hu5u/LS6OL8ji9cZnmgRIvLOzNHG1tvJaRUW8l1Sqfq0WsmYgCId5L93dZoFbiqrLDMeZ617Q0UEzXHa2mVXZildbB9arx2JJzMxQ456YIJGnGhw0O0sScmqMFy6QEOvq6F0iOHeOpB+NkijLy0la8l1GBolnvbxRnJ5IZ86Y6lm5uSTO0tLFs2XOznImMDrKWcrNN5NkJR2A1O9db0jRl9lZCgJZJygroxCWxd5olOazri6atbTmPUtqZIv0g/XqsVhTdHRQgz9+/Hp7dyKMjXHRcyGxNTeT9GsHrCg3AAAgAElEQVRrSfpjY9TixTYtKQcmJmi31pr7g0EKjKIieg2tB5wmnptvpuljeJizj7Y2avaS82Vu7vrSjFlZxqMmEjHnGxkxZiWfz7iL5uevj0lFIkRlQVqC1i5dMusEeXkUBGIKAjjTc66RnDvHZ7xjh/UK2oywGr9FUojWq3W8TXwxjI7S0+fQoXjTgXjvVFczvP3iRS64SjraaJT/X7pEIi0sJKEMDVEIZGXR7LOa2rdrBckFn5VFIXX2LNtbVsbZwFKeSdPTZjYgefdFkw4EeN6NCrQS76GZGS6qA2yPFKkX09BLL/E+XC7ed0VF8kV+i/WB1fgtVo2BAWrZt99u0g4shWiU/vhiF14Iyb3//PMkiMZGfjc+zmsFAtR8xe7f38+F5Lw8zhDShVScM5msLAqzwUEKqJYWmkTq6pKbpWRBtqqKWrSzqMjFi1zryMujMBGyXS8k8h4Khznb6ekx7qBSI3dmxlRSu/VW3pNEKNso4fRFmgwli3RCfz/w2msk4eVEi167xsXR224zv5P0yw0NJI6hIZLinj0kh0uXaMf3++OLskQi/F7MO+macdLrpYmqpoba/8AATVhiBpqcpCBMJrQ8nnhib2qiOWhsjCa2jg6S6e7dJlZhvfvC44lfhJdZweQkSd7jofbf2moWxzs6OAPYtYt/N2sh+WSIRnnvsklSv9lZ9s38PP+fnzdJ/sSUJpvk98/IMPmcvF6+8zfa7GeJ3yIOAwPA6dMk/RMnUl9MnZqidl5RYQh8eJgmgbvu4st88CDPl5NDLfHCBR63sKKU5M45fJjHr0eWy9VCKZOPxRkkdekSB39pKftmqYIbYn+vqeHvRkeNN83UFBeaCwpoeiks3BjT12IBZlJDIRAg+b/wgsnb9La3mcpWXm/6CvNIhGQu6TTm502CNan6NTeX+LfODK2StVVIfuE7HonwmUpOJxEOb33rjV/4t8Rv8R8YGaGmn5u7PNIHqOn4/aZsYCAAfOc7JPj6erOIOT1NwTI4yP8XXqO9nYNq7970sOevBM4gqcZG9sHgIIVqTg5nPKkUTsnMjHcVdbv5/8iIKQqSl8fcRuvhKroYnMJAYiAAEtvAAGcC58/zu0uX+LeoiOs7O3aYBHWZmSTJjAz+dZLoSiCzpEgkPt22U0OfnSWZy7Yw0A+Ib5PPl7z612rhTN98I2GJ3+I/kJdHs0Jj4/LdJouLWQsVIOn/wz+QoN7yFmOm6O3l4Pd4EnsHtbfTvLNc//x0Rk4OzVp1dST/3l6TNnl+np9TJe3sbJqQGhro6SQLxGJL7+sjcUmwVjoEXvn9fP5OSIyHJNFTijMCie5OlNRPqetrHYjJxOmfIlqzFDWXOgrJ+sJ5TjFppetMZC1hid8C09PU1DIyTKGSVCFBV7t3czAODwN///cc3O9+N883N8eC4X19HOCJ7N2trQwy2rmTxJYOpLWW8Hiur57V22vWMSoqOAtI9b7FJOQsNTk1RSLt7qYwKC6miSndcvDU1nILhbiwPzHBeyktJVm//LJJVy157r1eU9hc0nE4P0u/iUnFWSDH4npY4t/mmJmh+2VREb0ylotLl+iXXl5uilDn5AA/8RM08QwN0S6tVHJNvr2dZFVRsXg91K2GnTvZL319nAllZ7MPFkuDsRgaGkioo6PUqAcHKXSF+MfHzTNKB2RkkOyduYGiUfZBIEDBKMS+dy/fn/l57pOiNltNQVgvWOLfxgiFWLQ8EllZqb6REaPtB4O0fRYWAo8+ygEr7o0FBYsvVuXnk+yWU21rK8Dr5SLurl2cKcnCqBD/7OzyF/k8nvjcROKLPztLV1tnRs+iovRxkRVkZhrTkGRhDQSM8Bob43sFmApqPh/7MSuL77Jo+xbJkWaP3WK9oDVTGgeD9NVf7mKV+OxnZlKTfPFFarAPPsjBd+YMvy8rSz4Ig0HODgoLU1vs3KqQICgha4DmN3GprawkSS+XzFwus0CemWnyHg0Pc3O5uJ7jLCyeTnC5ri9pWFJCop+a4vszPU1hIMGCvb2cQTpTb3u9XLtyu83CbboJvPVGSrevlPoigIcBDGqtmxLszwfwZQDVsXP+udb6S7F9Pwfg92OH/qHW+u/XouEWq8PlyzQFHD4cX64vVbS0kETcbppzPB4SfyBAe77bHe+XvxCdnRyghw6lnw16IyHkLppvby+DujIz2b+VlSsjLZfLCNj6ej6n4WHjX9/fb+rzJluHSQe43YvXt83P5wxKvHVGRznrkZTZ7e3sU5eLpqaMDPat5I0aHqb5UzyJxLNIFJOZGbM471xLkJnZ7KxZUAZMPiRxyQ0EKHy0NsdIIXc5fj2Q6uN9AsBnATyZZP+vAriotX5EKVUK4LJS6isAcgA8BuAoAA3gtFLqW1rrsdU122K1EA3IuTi4HGRl8SUuLOTgqariy3vq1NKmne5uDsCysvUpLL0Z4fGwTysrSV69vVxLETPQ/PzKI2OVYr8v7PupKV7r6lU+w5VkQN1o5OVdP3t1eglJcj3xzxcSFkjdBye8XgYlAlR4xhawl8/H1CMAhbQUTg8GucYi3lhi/pR+Hx1lGwoLqQB5vYldSW8EUiJ+rfVJpVTtYocAyFVKKZDsRwGEATwI4Bmt9SgAKKWeAfAQgKdW0WaLVUAIQ9wMVwq3mxpoJMIX1udjAFdp6eKLh/399OApLqb/uV2cWxxKmSLqEiULMPgtEjFpoVeroct5pFbx0BAXnYX4R0f5zmzGNAxOE1kigedEY6Px+ReXUCdqavjea00zUyDAMXXunKkXceQIn5vMirWmQJHU3k1N3H/lihEism6xUkVsuVirCd1nAXwLQC+AXADv1VpHlVKVALocx3UDSOizoJR6FMCjAFC9Xne/zTA/D5w8Sa1xpVkur12jJtPUZDT8UIgv8MII3IUIBvmySxoGS/rLgzO2YudOI0Tb22meqapafWoEMaPU1ZmF4XCYmmw0Sm1azEEbkVZ6PSC+/YL5eRJ4MMjtppsoaNvb+d6LWSg/n95tUrxGMq663YnfdfGii0RMgaD5+XW5xTUj/gcBnAFwH4B6AM8opV4AkGhoJ7Riaa0fB/A4wOyca9Quixi0pu19bo6ksRJ0dABf/SqntYcOmdwjThvlYsjJYT7/4mLrdbFaiIYeDFIADAzwGeTkkKij0dVr5yJoPB6mZ5aFYSky09BA18u1Kj6fDgiHDVmPjFBrd6Zn8PnMzEuijpMJwFSDIN1ukwhxs0Xu/jyAT2vmeG5RSrUB2Adq+Pc6jqsC8NwaXdNiGWhp4XTz4MGVLab29QHf+IZJSvbMMxwkEmizGCYmjH//Ygu+64WFyc6mp020p3jVOJOnTUwYO7As6GVmmgE/N2cW+ZJpdzcKOTkk4Lo6c92BARKz5MtfiUdQoutIDqHZWQoAeY9GRjgTLC42tQXSJVZgMYi7qFRem5zku9DYSK3d6zVF7GVzmtRWklJEgtA2un/Wivg7AbwNwAtKqXIANwFoBdAC4I+UUuKs9wCA31uja1qkiOFhFkGprDTlBJeD3l7gBz8gwd13H90M+/tNyubFEAwyOMnnY43cGwVJEibZEZUyQubKFZNJUuy3BQWctQC0l8/MxJ+vqMh4ekiiNSfKyjh7AVidzFnc3eUi4Uow2htvGKEgqQEk0ZrW1PKc+yQvzHLI2kkkRUVs78AATTTi219fvzZCKSsrPu22JN7r7zceM/n5NOeli3eQFJwJBk0+IYkoB3gPublco5IaxjJDTQXOOgZaGxfZ5ub4d09rCmSpQ/3KK1SgMjMpSNbLwy1Vd86nQM29RCnVDXrqZACA1vpzAD4J4Aml1DnQvPNRrfVw7LefBPBq7FR/IAu9FuuHaNR4DiwX4+NMqiblAy9dosnnnnuWJv2ZGS56eTxrVzlLBvDsLIkT4OAaGor3zsjONsQv7nYSterxxLddPC4k/wsQP01vbIxPE7Aw17z83pl+V9wNpWxkOEximJ7mMRkZbH84zPYvRG2tKeh+7pxJECYuiCUlvEY4TK1Vvpd7q6vjOcbGONObmTH31t8fX4VrtZAF02iUs6PRURKskH5bGwVRfv7SHl+rhWS9lGs3N7N/pqfN+7FzJ9uRnc1nm5OzvDaFQub96OgwLqDyjkhlNcDMHOXZuFzx715FRXwq5/UygdoKXBaLQmsO3OJi4F//lVN6SbO8GObmWJkqEmGsgGhRK8HYGIldpuLiG33nnSSz/n4T5SoBO5mZGz+dTgVS3Uw0QsntLvVv5+ZopguH4/O+NzRwVhEIMFhOIGsue/ZQOExNsQ6CCAalGHjn9fIaxcVGiNwoiJlRPGS8XgrlujrTByudiQwPU8jMzJiUyfn5RqM+eza+3KTfv7xMpuK5EwyyL6em2N477+T+tjZ+J/n0xVa/0syyQ0NMdrgS4WgrcFkAoDYSDjMQaLkDa2zM5EyvqaHW39lJc00qkZ7d3SSqQ4eWR/pzc7z2+DjJzeMxLoa5uaYild9v7mmz+Zo7odTiFc68XpPq2gnR13w+kpyzKEgoZIhDcvrLgq+cs6KC+86f57OSgiluNwVEQwPbFAzyWThTJEsQlctlzBeLJURraKCZaWqKM4KJCfPsolHWbJBiJBJxW1HB7wYHjcvk/DzfD4/HeMT09HC/uBQXFMSvOaWSdHB+Pj4t8/S08dwZHOR773KZRHJ+v5khivDabLDEv0Uh+c+Li69Pi7sUAgG6aebmmvqweXnA29+euqdCXV3qlZfm5rh4PDJCcgCosc/MsA1VVSSmreI5shZwZqNcLN1FYaGp5yuzhVDIVAXbtYsBW34/iWxoiApDNEqBOjND4luI48dJ0D09dGsUiLnsttt4/s5O2v2d0JomFoDrL319Jie+5Np56CGaqgYHOUORnDxSyEUK3O/bx7ZKVk4RiELM4TCFl9y3CJCqKvaBlPd0tj8r63rPHa93a71/lvi3IKJRLlp5PNTQl/PCTk8zLa7bzQHwox/xpU9lYVBrkkBlpQkSSwYheL+fg72ry/iPFxWZEHfAun6uFWTh2GlGKCwkiQsqKymwncnQsrJI1EqZxXFZ4ygooGLh9IqSGQAQb+8G4nPoywL87bebGYPWJGZZn9m9myQ/N2fy609MsH2SrVMWaJ0Qz5zJSa6ROJGZSc09O5sKTX0971GEivM9X47JZmKCwksigmUtQBSvlhYT1Sv36/ebWYPMzNYDlvi3IK5e5Ut47NjyXtz5eZJ+NEpN6utfp2dIbS0H3lJ2x6tXqUFlZyc2v4TD1Cj7+zkgxTPG5+PgTxcPkO0MSXmgNUlqbIxCWoR4czPJLS+PtnSZkSWDBHslg1RmSwafz5h1olG+o6GQea+9Xq5niMARwSKKQ04OzY3OhXGnIiGziFQgtQMkD5D494vg7OoyldEkz49T+XFmDZXMqc51qNbW9XN3tkNti2F2lppFVdXybd+XLnFQHzkCfOtbfJGrqpgLfSnSb28noVdXJ76u5NyPRjnQdu+Of8kt6acXlEqcDC0nh+9YXx/NPEC86+vEhLHTrzXEDOM8tySvS4aMjNRdJKenDbGLvX9ujqYyKTLU22tiOPLy4tsi7rsZGYkdC5ZKO97UxOuvB+xw22LIyqL2vBIvjQMHSNrNzbTzFhbSBuwslJEIfX2mZKIzTmB83IStu1ypFxy3SF9UVXGT4KeJCSO0tea6UiRC4hMPGvEcAlaXXG61mJ3lOymmI9HcDx3iuBkZoZeOU8CIm6rLxXdbKs0lwmqFXVYWZ8LrAUv8WwgzMxxoy82v3tHBwaw1P09PU4vKzl56YTgapeZXVGSSvg0Pc7YwOWlsrTb90tZColz5ALXW6WnjOy/eYRKz8PLL/G1mptnKyykcwmEu5ornkCgMPp/JXBkMxq8lSDBeVhav2d1t7OuymNvURAIPBMxCrlNrF+zYQeUk2ULuVpqVbqFb2d4YG2MxlCNH4uu6LoVr1xjdKYmorlxhsFV2dmrRoy4XXeaUon2zo4ODMzubgiBdi3xYrD2SpXt2or7eBCvNz1M4SDI4iVlYCCm7OD1ND5+F2LePJB4OcxyILT8313wG+C7Kulei99p57FaHJf4tgGiUQTxZWctbHOrvJ+mXlXEKfOkSv9u5c2nCnp6mvXP3bg6WaJRCBOBALS/fWu5vFquHx7N4PWGfj26gEgEtOZUkxsHno1lGPGIkmZqQdX6+cV1Ndv2tpLWvBrYbtgAuX6aWfeJE6i92IMDSi3l5HERdXbTTT0zE551JBAn8kcWvffs4AA8eTK5NWVgsBaUW90JLNQusxdKwQ3STY3ycmnZ19dKLsE6cOWN89YeGaBsdGGDE4mLafjjM6XZ3t4mylQWp7GxL+hYWmwF2mG5yBIOcAkskZKq49VZOjUdGSNyXL3OB9+DB5OQdjTKiV3K97NrF3PxWC7Ow2Fywpp5NDqnLmqo9vb+fNn0JNikroztmfv7SAV8zM3R3q6xk0EphIbX+0VF6VMzOMgrR4+F1+vv5O7fbeHDs2sX9zvz2FhYW6wtL/JsU4iq3HNJva6NtvqiIJiIplSiLuclMPENDFAx+P/ATP8EZxugoXfOceeozMkjsgEnuJTnKZ2ZoiqqpoUnp+ee5zuD3m8yJx47x78gIhYYIi6wsmpFycqwpycJiLWCJf5PizTdJ/FIpaCkMD7PgCGDq4165Qm08WdH1cJjudRcvknQrK7mJH7a47nk8FACFhSYQRgpySK6WjAy68kl+kvp6CoZAwAiHy5dpgopEOHsIBIyrH0CPD6/XZGwUoSEJxiwsLFKDJf5NiJ4eauFNTamR/vQ0q2bNz5tqTIODwI9/nDxt7fg4Cf/aNWro5eWmQhFgZhmXL1NAeL3U5vv6eB3R0P3+61Pl5uSY/Cta00w0Nma8icrKOKOoqDCBPTMz5l5nZ+PzuyvFc958Mz+Hw9Ztz8JiMdjhsckQClFzLyhIrYyi1sylHwhQ6y4rIzG+8AJJMlE+8YEBEvqVKyTl2lrg7rup3Q8MsLjFK69QM/f56AnU1MTznz5thMLICAVUQwOJf3qav83N5bkkIdjCalChEE1Fg4MUPGVl8UFp1dXcZmd5XDBIYSMC5MwZuqVmZ9P0VFBg3FQlj4zHQ6EkeV4mJuIjSu3ag8VWhiX+TYbmZpLcbbelRk5Kkfx6e0mgHg9TLY+NsdLPwlzuY2P8rriYpOhyUZMfHORMY26OBH/LLTxfXh7JX/Kv3H57/PkkvzrAcxUXUwhJFkOPhzmCnNGeGRn0Fpqc5AxiYMDkjA8ETMzByIipFyDFOlJFRgbPV1xs8gn5fPxcVMRI0fp6RkIrZaosWZOSxVaAJf5NhuJiaq2LhcULpPDztWvUmMVn/+pVaul795pj+/qoxRcUMCBLcuS7XCT8piaSYVXV8swoziyFWVnmmqEQteyREZMWt7/fLAh3dVHIXbrEdLULk1fl5bGtNTWmqLfkXpFKTl4vtXzJgZ6ZSQJvaTH53Z0zhdFRChInpLC4z0dzV3U1BcL+/RR8Ky2xZ2GxkVhyCCulvgjgYQCDWuumBPs/AuBnHOfbD6BUaz2qlGoHMAkgAiCcaj1Ii+RINQ/PyAjNOZEIhYWQ69wcSUtmDGIKOn2aJFddTaIdHDQh9ocPk/QTabtCnpmZPD4cJqG73YZ8k+VFKSlh21paGB/w4os0Ywn5ZmZSCD3wgCmOvXs3TTyAKQJSXJy6aSYSYd9IbvWZGX7f0MC+nZig0Bkf5yypu5v/i0eUrEO4XDx+/34ujldUcN1iOUF0FhYbhSWLrSul7gYQBPBkIuJfcOwjAH5ba31f7P92AEe11sPLaZQttn49OjqoJadSCWt2FvjhD0ngDQ0kWEnCtnOnWfwMhYCnn6bZpKqKZo1Ll0iwjY0kuYWkOjdH08vkJDcxr0girYkJ2vGdyMzkDKOwkIJmbo6uoM8/zwXm4djbUVnJ+ysqMhWRbrmF5iNnQW6t+RvJJCpeQisJJJNUvZLhcXCQM43MTH4nnks+H/urq4szqEuXKAyuXYsvLVhayr44fJjuqfv2bZ/EXxarR9oUW9dan1RK1aZ47fcDeCrFYy1SxOwsPWwKC02xh2SIRoFXX6UWXVlJ0teaBDs3Z1wuAbNekJdHcnr+eZLbO98Z79M/Ps6/BQUk344OCoeCAi7KZmZywVZcL53l8vx+atWTk8CzzwLPPEPBEApx3x13MMfQ4cOmqLVUbVLKmJUiEWrflZVsa2kpj5Fi2EvlF0qGrKz4wjH5+STu8XFug4P8XmrMlpfTxPP2txtBNDbGezp7ls/pwgXOXgD2zf79vL8jR/jX1iPYftA6vkLYRmPNbPxKKR+AhwD8muNrDeD7SikN4PNa68cX+f2jAB4FgGqbvD0OFy+S2A4eXPrYCxdokhD7N0Dt9NIlavFZWbSlT08bN8n5eWqt+fnAXXeR2CIRk8NnepqCoKCARHbkCH8XDJoAspaWxEW1IxFW83r6aZ4nJ4dacHk5if/gQRJ/IMDjCwvjszHK57ExEnxPDxerKytpTiovpxAQc1J7O9tWV7cyrcnrpSAQYTAzw7bJubq6TM548UrKz6eWdu+9PCYc5kygp4fxFi+/DHzlK8CTT7KvGhpoFrr1Vs5obMqLzQkp0ALw/ZTqXVILIBqlkwJAJWtoyPzW5eK7LW7Ng4P8zXoJhbVc3H0EwIta61HHd3dqrXuVUmUAnlFKNWutTyb6cUwoPA7Q1LOG7drUGB4mgezdG1+APBkmJvjy7N/P/wcGgJdeonZ84gQ10atXSXB5eabwtMtFTV0ia9vaKBD8flN6sbmZWrCYd5QiQWZl8fzZ2Tzf/Dy1+3/7N5qbsrJIig88QNfQnh6anaamqNF3d1PYFBRwZjAywvP7fGbghMNcfxgbI7n39vJcC9ce3G7+fmSEwkFSRKwU2dlG+AC8ZmEhhcHEBGc/fr8ZwN3dxv6/Zw9w333ss44OFgW/epXt/5d/Ab72Nfbhnj00Cx07RkGQynO2WF/MzPB5T0+bbW6OM1a3m44BUpbRuQlKS/lcRfN3ersBxrEhkXv1jcBaEv/7sMDMo7Xujf0dVEp9A8BxAAmJ3+J6SCk7n29pE4/W1BomJowLYigE/OAHNI3ccw/JuLWVWnJtLQlHaxK91ual09q4XtbW8oUdGSHpSjCW+N6L105BAWcATz5JDX9qipr9xz4GPPggz9HRQdLLyiLBlZebqF+pnXr2LMk6NzfefNPZaYpbh0JsSyRyfX3fXbsoRNrbqZ339y+dcXQ5kJJ85eX8Xxa3BX19ZsFYXETLy2niOXiQz2h0lPctgXUvvgj80z9xViDprY8f5wL8gQM2GG29oDU19qkpvstTU1w7kmj01lajqUu9XVkilbKMyTT2xQrOA6wzMDe3yWruKqXyAdwD4AOO7/wAXFrrydjnBwD8wVpcb7tAKRJGNJq4eLMgFAK+/32SYUODOXZsjGaIPXsoAFpa+CKXlZFQMjNN0NKVKyTKzEySl9QjLSggaRcVccaQ6MW+fBn40pcoWJSiZv/e99IFdHiYBA2QpLOzqf04zyOaUSjE9ly7RuJ3ppI4fpwDMRDgNj5uBtPUFGc1jY0kWa+XZF9ZyXOJy6Vzar5WWFjc49ix+MCyyUlDDtEo+zkzk32am0uBXFPDdo2MUDi++Sbwt38LPP44jzt2jH1/4gQX4S1Wj3CY701WFt+PsTGaVOVdVYrvaihkChwVF/NzojGw2PhMFclKPt4IpOLV8xSAewGUABgA8BiADADQWn8udsyHADyktX6f43e7AXwj9q8HwFe11p9KpVHWqyfei2UpnDzJhdmjR/mCShoEv5/Ee/EiiRGgFtnYSPJpaSGxDw7yWhMT1OJFSy0tTWwnl7WBN94AvvpVaq1+PxeF3/IWConpaWrbs7O83r59/J3UUl0Mg4PUrkIhmkzq6hITthB5ezsXjaNRChepTSD1UwXNzWZms9rC2CtBOEyhKvVop6fZ5ooK3kdnJ+/F76cw6OykEHj9dZPptKrKCIFjx6xZKFWEQjTDTU1xk9njnj2cac7Ocr+kGfH51obMl4v18upZkvg3Apb4jV/9gQOLH3fxIvCv/8qppgRHXbnCl/jwYRLNa6+RZG65hd+FQiSTzk4KgJtv5jR1bIwvvDOvjlMA9feTmNragO99j9f2+4EPfAB43/towujqoq1TUiCUlQEPP8xzNDdTEElyNUnd4LShC8Jhs86wVB8AHMxnz/LakQjt8LfdxvPPzPCeR0fZLwBNQlVVGzO4BeLaKuUDJycpTAcGTObUQIDrNRkZdNE9eZL9KL9rbOSC/F13kcS2a2Sx1ny+MzMk8ZkZvvNi1pRC71lZRrnx+41HW7rAEv82Jv6hIb6k+/Ylz5wJUDP+h38gcd52G78bGAC++11+Fjt/TQ2J7qabOBhefpkELd4vb3tb/EKUBDmNjnI7dIiD5dw54HOfY7BVTg7J/qd/Ol5QdHXRXFFdbTx+hIwkcEpsqOEw237sGPcHAhyQTtOJCJ6ZGfbLrl2LzxgGBjhbyM8nYTo9jjIz2VbRuLOySJzp6F4ZjVLonTrF55GXx3ZOT5PYJKr58mUulgOcvTU0UFAeOkTThMdDoZ6ZyT6fnibRiYlKhE46uBguhCyCyvswPMx7F1fh+Xn2SX0997/4Io93u41HmLgGy/nS8T6dSBs/fov1RTRKgpWgpGQQ3/xw2HiUTE4Czz1nAqsyM0nqjY184cfHgW98g7/Zu5cCwZmCYW6OWvbICAdQZibJY3IS+PznuQDp8QC/8AvAz/6sIczhYZJ7URHJPlkqg+JiboLpaeP7LwvZkQhJu6yMA1baNjTE2cbYGAndKaicKC9nO8RfOhjkeXJz2c7RUbNoLJHFcv10IgWXi4P/rrt47z09FGpC5Lffzuc4N0dB9sornA28+ipneACF7759wHvewwX/4WHO8hbijjt43mXadiAAACAASURBVI4OXsPtNpvLZd6foSG+C85i5y6XKaA+Pm6iqp33UVbGz8PDJo2IFFTPyGA7AQroQIDfh0K8v/x8k0G2vZ3vjPTNQs+Zw4f5PJNp8On0fDcalvjTDK2tHMi33bb4tL2lxXjriGfMyZMk7rExCg7xCgE4kFpaaK555zu58Op2c5BNTxub5vg4beNlZTzH179O0p+aIoE8+qhJSzA3x3OOjJhCLi5X6vlrJI2EoKmJxDw8THOVLEbv3Ely8HrpDvn66yT/ZPmKnAO/tZVmp127+JtolNcIh036CzERVVYas0q6wO02cQUTEzTdSf8KQYo57eGH+V1zM5WCU6e4qP/971P7PXKE2803814jEaMhA8ZbJRIxxOz0LZ+Y4PsjLomASesBsA8lCluQmWmIv7/fJOcTwZyTY4hfjpfZiMcT/440NV2/mO6EM8OrxeKwpp40QiQC/Pu/k0DF/JEIL71EDbC21giHQIDugOfPc0D95E9SkxsfJ1m63RzMQqSy0CiePOIvL5rv6dPAn/0Zyff4ceDDHzYzEK05iFtb+bm21ixQJoO4Pcr03O2mNh4IxLttKkWtfXaWGqgkY5udJfEUFvK6s7MUaku5aUow1cAASWTfvniCCIe5VnHpEknJ5+N5DxxIvPaQTmhvpwafk8OZW0nJ9c8gGOQM4NQpCgNZ4ygrM7EDx48bck4VorVrbYg4FDJeMQKljKAKhw3hb9e1iKVgbfzbkPgBToWVSv7gL14E/vEfaaqRLJpzcyTCz3+eA/Gee6gdtbWR2M+fp8b77neTJHp7+X0oROLctctoz6OjwF/9FdcJdu4Efvu3gbe+NX6aPDpqooMluAtgOyQ6NyPD+D7PzcWT+5EjPKanh6S8EJIeQbxcAFOOUSnuF014asrk2M/O5t9EpDIyQgEYCtH+vXC2EApR0Jw9y7WTvXspOEX7T0df+kjEpMuenqYAr6pa3OWzp4fmoFOn+FfScVRXU/gfPcrns5TfucWNgSX+bUb8YpNfDAMDwN/9HQn3+HF+d+YMSVzs5ceOUWvt6qIQ6OmhMHnXu6jVSZGVwkLa+GVhNhoFvvlN4LOf5bk++EHa8p0voLiIAiTSnJzECdsaG0kcgQCvn5VFAs3M5N/cXBKpmBqcRC0apFJGoIXDvLepKZ5PTFSzsyT9gQGan8Qmfccd/Ds8zN/6/RQK0h81NTx/Mr/+nh7+9uBBs1hdWsqZSGFh+tmKtaZ5r6eH/btvH7+fm1vc7BaNUhjKusAbb7CPAQqCW2+lWejw4eXVdt6ukOcwOMj3Z3iYgnVykmNhZobPRNI5iNlKTGz5+Rwrf/zHlvi3BaJRLsqWlFAbTYSpKQb1zM8Dd97JAX3hAvCd75CE6+uBd7yD2t6ZMxyk8/PGq0c8HLTmS+jUeNvbgU99igP/1luB3/3d+NDx2VkSxNCQSVlQWMgX+dVXee7cXG7iqnkjNeRIhGQfjfLab75JYXXoEO9bNN7z541NGeBgkllKKERzVk2NqcKVCBMTDEyLRDg78vk400il+tlGQIRZMMjnWVTE/kilfkM4zPWB11/nduaMqWUg7+bBg9z27duYWIiNRihEAdvZSaVA0nb39vKdlPgAJzIyTMEiUYBcLva3xMRIOojiYp7TevVsA1y7RmJvSpL0OhSi6SUYNAXHL12iL31rK8nr8GFjZy8s5DqABGF1dPA3kmJZSCAcBp54AvjCF0ig//2/A488Eq/ZtbeTQMbHeV6xEUsyNfEIWU+43fF1CWprmQRudJQBZEJ+Bw6YEPzpaaPNAjymo4MeVOXlZr1AZiMCSSQn5hStDRkC1Ory89NnQVhmMF6vqbw2MsL7qqy8PmraCY+H72BTE2d8kQjfrzNnaAI7d45CEOAz2L2bi+H791OY7tlz/YL9ZoRo7pJipKPDfJY4EUFODvt5zx6WJ92xw3iklZTwnUo1Ind+ntdZD1iNf4MxM8PAnNLSxAu60SgHnbjyFRZSw/jKV0xeG1mc272bZC7pjaVMYlkZZwROcmppAR57jGaf++8Hfud3jKulmF+uXmWZRgkUkuLn6abpac1B+cILvOebbqJGuhjJARRira0UvKGQqQcgppL+fhKmz0cB0tZGopegN6VoKxdX1h070s8UJLOjnh5TsnM1glrWdy5eNCmoJb+MUuzD3bvZj3V1VEpqatLP40ZrKjPd3UZrl5KeXV2cFQtEiMq9VFeb2Bgp27lWsH782wTnz/NvIm1fqmP19RmXOYDT8eZmkzt+xw5qHOPjHIwNDdRYcnK431lXNxxmIrXHH+f088/+jIu3AH/T18eX/tgxEtptt5lEVekKKRpfVkbTU0YGCb24ePHIXFkIvfVWElg0asxEs7N0KQVIlJKCWeIapD/27WN/DQ0ZobCYq+l6Q2ZHO3dyxiKkf/Ys34/KyuU926IiarZ3383/JcnflSvGBbe11QRTCQoLea2dO9keSalRWmpSfvv9qydRiYYeHzflNEdGaHcfHGRb+/rik+kBxpusupqKUG0tt5qa5NXnNjMs8W8g5AXduzex6+DlyzRhVFRwE9e99nYS1PHjHEhNTSSekydJOA0N1MKcAVAAp5GPPUZhc//9wEc/So22r8+YMiYm+MJrvXRG0HSD309tSbIszs9TW7t8mf2ULO+9309vFllwk5zqx46xPyYn+Xd0lDOfhgb2VU8PSa6w0FRGGxw05o7RUbZh4XPYCChlFuYjEfZLby+34mKS8kqElaTm3rHDCAPA5Mbp6DBadE8PFZYf/pAKyEJ4PCbrq89nEqhlZJgcTy6XcQqQADZJ0SBJ/CQocCEKCqgcVFdToamoMMK/omJ71U+2xL+B8HqpbSfSJnp7mc/e76c2e/Ystf/8fGqev/7rJJ+aGpLLhQu0Pb/zndfnkI9GgX/+Z+Azn+E1/+iPmEET4EC5etVkHZRi5RtNVKuBRJl2dtLsMDHB/4uK2JeJEptJNCpgTDoynZfUz5I9FKAw6Osj8Vy4wJlWWRlnD9J3omW2tHBfeXl6zATcbs5U6up4DxJ4Jd5Ya4GMDJ4/UX75aJTPZHCQz0WqnY2NmSRqwaBJyzA1RaKX2AGXy3jESBoOycGTm2tmZxJUWFTE/l/Ka247YRMP782N0VFqIIkIdmyMidcAmnCam2lrHxnhy/uWt5C8ysu578wZDqTbb79+4A4PA5/4BIN37rgD+L3fM6kZ6uo4QPbsIUkqRc11Nal/IxGzmFpYaFLetrdTQ5MCFEqRaHJy2PaBASOwsrOp8a1m2l9ebrJ8NjayTV1d9FYpL+d9JjMD7dnDa7e38zmJB4tzjaS8nJqypIhua6N2e/Ei7ykY5D3U1/Pz4CDXDEpLTZGcjYbXy9ndrl1GMAImq+rOnTdGCxYHhMJCrsdYrD8s8W8AgkESsXhFLNz3ve+RUKqqjL20v5/EKVk4c3JI+s88Q63one8kQTnJ8rnngE9+koP4Ix9hKt+2Np5HIjUnJqiRer0rrwc7O0vBIb7K4i/Q2MjzulwkTWdwldaGeOfmjFlE4HJRe5ac6C7X8jJper10P3zzTZJxUxNNN52dJt9MMng87MvCQvbN6dP8/UJt3eMxGqUsrAeDFMrd3bx2RgaFsfxW0l2Ew2YmsNELwhIMJwgGTZBfScniZjKLzQlL/BuAN9807nBOiF98ebkpYP7d79JGDdCt8JFHKBDa2mir37GD5iKnpj8zA/zlXzIh2759JP2ZGWqkRUUUHuJlkZdnUhSnat6ZnKSG6PPxfOEwZxZ5eWyH5DQXbTE/f3ETR1kZt3A4vgKSLDp2dFDw5edTyy4pSW3anpkZT/7Hj1MDl7QUoZDxjJI0yE6IaUbKKy4Fj8cQ5J49FIT9/dzGxkxaBcAUvunrM7EB5eXpsYje0MC2SmK4oSGS/2KZYi02FyzxrzO6u2mykUyCgvl5ZlgUV8qaGroZtrWRUBobgbe/neaZN97gsRJV6SSL5mbgv/5XarYf/CDwK79CQr161XibBIMkPMly6QxGmpszucxlgVSIaXCQSb+mp3lscbEhrNtvJ3G+9BL/iv1VMnzKDEPSISfSuJ2Le1LaEDBumWNj1JJbWkigjY1L97eQv9T3BQzBh0IUwJLaePfu6zXbrCxjjohEaM+vqlo6R5DLxRnG+DgJfmyMAnN4mNcYG+O5Jyf5ubvbFLtPB/LPyqKQrK0l8UubZHa3Y0d8Om6LzQVL/OuIUIjEUVhILVMQDtP2/MYbJNpIhOacwUEGFtXXkxDcbppvTp6k6eGWW4zmG42yGtZnP8vzf/Sj1PYzMrhJRPDAAIWAx0PSkUyMMtV/803j5iZlGTMyGLwzNcXjiot5DVkQFnu81iYBnCRlE9OH3P9rr5mydn4/t+LixTVq54xhaorkuTDITGYaieBM3zs0xGuL58jNN7Of29p47yUl7LdEgikU4j2dP28qgy1lfiooMPWIe3pMgNiBAyR8CRYaGzMxEjITERfIjRQEC81AU1NmvcI5U0mXADaL1GCJfx0xN8fBIqkFAJN//7XXaFJwu41P+M6dtMsfPkxN6+mnqRnedRdd54TMhofppnnqFM0Z73kPiTQ/35g1olHOIK5e5eeiIgohgMQig1sKRk9NcWYiqXAnJji4F4vMFH/6ZHC5qD2L652YjKQGrZijhOgTXUuEhWBmhn3S2UmCrapKbjOPREjwkQj7VARWeTkJX/IaCekvzOWTlcUEZm1tPHZsjPeTiuabkxO/kNnfTwKVvne69I6McBYyOck2VlZyf2XlxvuTFxfznRwaMhla29v53Wb2BNtusJG7GwgpPvLCC/wrBbdHRjjIq6uNj/ipUzTjPPAAyUeI7Uc/Aj7+cRLWT/0UF0QlitfrpcAYGeFfqdTkdpMk8/P51+fjtaNRzgi6uni8z0dz0I2s6yr+3B4PzSLNzWaRNzOT7autXVzrlRTTEp3q81FgJfrNzAy1aYDafrLzTk9zBiABPAsFyfg4ydnr5XmWi2iUz6Wvj+dyRr1Go1wfGBigWauvj7OAt72NAkAisjdaCACmqLwoDpcusW2lpRSI6RTFvBmQNpG7SqkvAngYwKDW+rr4UqXURwD8jON8+wGUaq1HlVIPAfgMADeAv9NafzrFe9hSiEa5mOdMm6A1ieP8eWrTUiBkYIBmoF27qCXW1dHDYnycBCOzhfl54K//GnjqKZLBJz5BLbqmhkQtPtKBAI9vajJkn6jg+fw8TU1zc6acnbNa1o2CU0ssKKDmKEmrxL9bzCmDgySZ4uJ4UvF42F+VlbznwUEzG5qdjR9E2dlcJJfcM4cPJ14o1pq/u3qV/b97d3wEdEEBhawIrlCIfZdqagKXy0SuTk+T3KWdkk6gutrMkLq6TMGS11+nQKirY7tSXey+EZA1GWm3UpwJ9PZSKEpWU1sUPr2wpMavlLobQBDAk4mIf8GxjwD4ba31fUopN4ArAO4H0A3gVQDv11pfXKpRW03jb24mgZw4Ydz5zp+nFt/QwEH87LPUWGUxsrSUBCzRiV4viUby1H/sYzzv299OM4+YCSYn6dcfjZoydXfdlXzgBYNm4F67RhOQk+DSCe3tNOtIhG1RUXxN1YWIROgl5fWSJJ0Lt4EANfq6uvh0GAsxNETTzuzs4gvKopnv2kWCXo02Pj5OoaQ1BZwk/RJyb2nh/pER9oVkHF3JzONGIBymEjM4yHuRPhZ317y89Jit3AhIreS5OT4/eeck2E8CBSUd80Jvt7TR+LXWJ5VStSle+/0Anop9Pg6gRWvdGmvU1wC8B8CSxL+VEAhwoFZVGdL/0Y9YaUsCuOrq+AKMj3NhsbycGp7k6K+p4UKu1wt8+9vAn/wJX55f+AWafTo7SexVVSb/yugota+yssQvUTDIdgWDTFcgXhzpjNpa3uP4uKmfK4QMcJaQk2NmCC4Xf9PRQZIXf3ufj+Qj970YSks5w+jpiS8mEw7Hz1Zqa02CvOFhauorLeIu9RaGhoy559o1tjc7m8pCfT37obWV99fXx9mL5HcqKDA5cJYT/7AW8HjiXXQFUlJTkg2KkrFZI2qdNTTa2/m8ZmdNHEt2tkm8ODhoktkJ8vKMsL56dXllS1eLNVuOUUr5ADwE4NdiX1UC6HIc0g3gtkV+/yiARwGg2lmEcxNDa5oUMjLoxTE9zQXa06dNQYYrV6ghVlaSPI4coctkIEDtsbSUM4BolGmTv/c9Dvqf/EkOrLk5vlRiYxWvl7k5HrdQmw2FqMH297Nd9fWbK0eJx2O0/GjU5GUJh6kFA9xXWkpSkTS5vb0k5dOnKURzcgzpi8fNnj2JNVGXK94La2yMtuzqapMKW4K+Sks5iM+cIfkvt6ShwOs1eWSmpijkZFbX0mIE3uHDNF1J5TZxt2xvNwvkBQVs60a4XzqFY2kp/x8ZYR8ODfF7STU+O7t4Td2NRDRqSoVOTJii8HfeaSLR/X7eo+QYco4rEcqSdkKKsQhmZnjOmpr1uZ+17OJHALyotZbSF4mWdZLalbTWjwN4HKCpZw3btWFobaVWduQISfbrX6ddPyeHGlp/v/FskQjJH/+Y/99+O007WtP75vd/n7955BGeLyuL286d8aH1ly/zhUpUXjAcpvdQOEyBUFOTnoMsVTg1JLfbJKsbHqYw9HhIvsXFJNDycmrQYtqSimLBIL/XmscvtSApwXWtrXwmdXVm1lFczH5vbzfT/GSVvlLFQk+mzEyS5+gohUxBgRH84ioq6yHj4/wr9QvGx/nboiK2cz1NLm63Edpas/8nJswzbG3lsxOPtLw89vNG1D6Wugs+H9stldgAtkdqN0Sj3J8KYTvrDS8cd6LcjYys/b0kwloO+/fBmHkAavgOPQlVAHrX8Hppj4oKPsiKCmqUWpNwn3/eFPDw+Yxf+Q9+QI2hoYEDORploZTPf56E8td/zamh1LaVcoOSrVDy5rvd8dNnWSPwePiC5udvvcU2pYzPvJhBnJkyZaFYCHJujovZfj/7pLiYJDoywpmXzJSam028gyQKy82lBjc6yhnY6dMkqd272feFhSazaVdXfArttahOVl3NTQLChodJoKJR5+TwPoNBKhey1gOY5HI9PfxO+kxmLusFpeIXhgH2ud9vIp57e7n/yBHu7+nh/UkpzbU2Yc3MmGRx4+NUkJqaSPKlpbxuXt7yTVMS15KVxffnyhVjApPUJUVF8UGLNxprQvxKqXwA9wD4gOPrVwHsUUrVAegBBcNPr8X10h2izVy4QPJ59VVqom43bfsjIzQBFBSQdCIRRrzecgsHn2ST/PjHaTJoaAAeftikjvV6zbR9ZobpCHJzr0/vHIlQS+npoTlABvhWhxRGcUbXjo2R2N98k8LgwAFq6s89x0X2khL2V3c3iUeIX7R7qefrcpk+LipiYfvemDpTUMAB7ZzCd3aSRFpa+Cx37KBJaO9e7pdAKL9/+UQm5S7r6kzu+6kpas6AqbpWWmoIdn6es8/sbP6dmuI9S2K+/n5zL+sdOOYM1JMx5Mzp39kZn3LZ6+VsVyzDw8O8J6/XlDdcDGJu8XopJF9/nd9LtHlhoRlnPl/q1cXm5ozwCARowiorM7m0Jid5nMwApIToeiIVd86nANwLoEQp1Q3gMQAZAKC1/lzssP8E4Pta6/8obqe1Diulfg3A06A75xe11hfWtvnph7k5kvulS3zQBQU0I5SVGW0lM5MvdiTCl/nKFU71cnONLfrxx/li3n03c+ffdhvPJZr97Cw9g65e5XeyoFtfb8otPvMMiai42JhFGhp4npkZDhSv12TE3MxmHyecphXJOS+BWaEQtfCMDJLhffdx4TQQYP/v38/jxDVxYT6lhRA7vKC/n89EKRLSnXfymqOjfCfEZVcKvkuxF4lmzstbWfpmERo5OXxXxsaoYPT3sz/y8ky0tbiLAvzO2f6+PkNMWVnx+ZHWEzIjcOLECc5eJABwZsa8s+EwFSAnPB4+g6oqU09Y0pFMTXGs7t5t0qcUFZnauAJZxA+Hr1+cBdhGr5fnlPiTc+d4ncxMY8J1rq8cTcnv5sYiFa+e96dwzBMAnkjw/XcBfHclDduseO455tHZv9+4as7Pc0BVVVFDfPVVahiZmSb3y0038dinn2ZA186ddNW8806+XK2tfJnq6qi1X7tm8vPv28eX1ePhYG1poY15xw6++H6/KVwhAyUY5CKvE5mZ1IRzc9nmaDQ98sYshbm5+EW3qSmSX2YmCSQriwNQbOWSI0eEYnk5Z1wZGXwOq0k/UFTEZ9fXR4IXwVBeTuEvazseD8n6+HETBBUMGhNgfj7JpKODglpIOxV4vaY4iuS+F0EiaScAvhN9faaYCkAzl0RqT0xQeChl7PLNzcbksRZmq+VAFlD9/usFkdtNk9D8PLfZWT5j5+L/6dP8HjAavJC8ZIgdHY0/r1S4m542ke7/f3vfHhvndd35u/Mghxy+X6JISqSeliXZkmzJD7mp7Si1HaeIi76QbdymQdq0XXTT7m6LLhAUXXQRYLGLbdpFs0iyu0E3i6Rpt2gat4ibJnb8rOTY8VOyRYl6UaRIDp/DIefNufvHj6fnI8XHkJwZvu4PGJCcGX7fvfe799xzz+N3BNkslax0WpUon49zUE4SYkLr6VHerUBAQ4xl081mS1uveIvoeOuHXI5Cdtcu1ShPnKDQv3KFZpZvf5sP+FOf4v90dvJ9v58a5+HD1M6/8hUKrU9/mhvEyAgnXDZLYSz0vuk0NTYhbZt/pI3FeP+l4skl6kVI2UQTEuEyOMh+lZWpo03K4603UimOXSBAU9rFi3zf5+M4eTVYcX4DWopPCnxksxzH9nYKsbffprYWCnHxVlZSO5OymAMDvG95OcdhIaFXVsaxb2/X6lPRKLVKY7SaGkDBe/Ei/xaiPIn8kH6K2Q/giUB4nvKNxBLue+94hEIch4kJfj42pqaV11/XWg+7dnFuirklk+F3pD0Ar7VnD+fTzAzbvBgJXzEhSY3j47qJSm2IPXvYpo99jJu6hNl6T4byrL3jD+g4V1ZyXQNcJzdvcty8p2afT6OrfD7et6qKc3R8nO+nUmyTmNx27uRae+89jutDD5VmvJzgXyVyOdpGu7s1DC0a5WRralITzrPPqqD6h3/gZ0J8tXcvhfQf/iFPCVVVwO/+LvBLs56QiQlOOHEmRaM6aU+e1EmZTnOTERbMfO34on0sJMzFUSia9PAwJ/Pp0/w5NaVl8YoNEdBiN00kVBMTp6o4rIVnaGREC2ZL8fTr15WLX9ouJ4Ljx/newACf6/g4NfZ0Wmmsr1yZa78vK+PClYiOREJttRUVvG9HhwrObFZDb0VJyOUo/AcGaKarqtKoovp6zWQeG9M2ySYxOsprNDbm/xy8pwGJXEkmlWwvEOA49fToRnPqFDf9sjLOu2yW4zg1xZ/eU+Q77/BaIgzLy9Vpm8nwXsEg/8db9WwhiDlUMs2F30nKLcrPU6f4+dgYhaiwu1ZVzTWxzD8leO/t8y2tcUtbEwlVNo4e5SafTOpJqKWF/Q6FOHaBwO3mQG//AK7XXI7KYKlCbh1XzyrQ30+BPz3Nh3voEAWPxN9XVjJs8pVXOHF37OBk2LuXpgRrae99912aduJxala/8ivc8ec7emZmNHTw0KG5seGRCAXSzMzyWagLQaILlluEwpMvNA5vvcVFKAXIm5rmtlsWrbxEYOZyczUq0Y7kpyxyOSpnswxxlegH4Rdqarrd9CGObOmTnFak2E0yyWssJyRnZjRa5tVX+Xzuv5+bTSikNV7jcfa/tZUbxLlzvHZNjbbTW0B8YID2//JybhZSA0BOV9ns8tXBvFrq++8rU2ltrSabrSUhSqKfxsY4ltEoNd0jR+gr6e/X+gXz54to3ImEjlEqpXTg3tOZwOfjpltVpaRv3nh3gOawUIhatpgny8o0pHn/frXDL0RHslrIHL52jXMwGFSivMpKpfGW+VyI+26YzF2H29HXp/ZZCcFKJlXwSXWsbJa/J5Pc1cWZ5/fTjv/DH/J/fv3XgY9/XE0SXkxNcZNIJLjgRGtJp6mVjYxoRI9o7uKYBLhYJbIgk+GrokKPre++y3sIgkHdzAAuRpnoXpPBvn3KMClZrUIOB/D+ZWWq+YlpZv7CzOX0SC48O6Oj/B+JfBEiudpaLoiyMvajt5ffvesutZs2NfH7UofVi3wXk9/P5ypO1m99iyaQZJJj3dZGYe819fh8bK/4GSQeW04m2axuVjducB709tIct3OnOuSnppaO7vEK28OH1S8wMsJNJRKhWQlQbXklkPDOri5eJxbTa8RitJO/8QafwY4d6p+qqND3FkNtLTeQTEbLcOZyuhGHQroZGsP7yrwBOI7NzYtH7KzV3yAcUeLbyOXYjmyWbZcCNdXVc++/GYnonMafB8bGKMiPH6cAymQ4yUQzFfvc2Jimof/gBxQW6bRO5GCQC/O996gZHTkCfOYzPKouFM41MEBtXrJCvVwzIyNsU2cn7zc1xQkbi7FN993H7124QKEqIW5CrSzmoOFhamW5HF/ZLL8rmapnz87dNEIhLr62Nj1Kl5VR2NXX8/2ZGQqHtja1n8+Hd3N6801lDpXFv2MHx1Lum0ppWOTVq2qXrq7mghTnZzHoCSIRauQtLRTWySRPV0tVpJL21tWpCenyZT0h+f002wSD6kPwao7pNDdlcQznI1ympjSCJ5NhmGpdHdst91wLrOVz7uvj8xoYoAB8/HHeo7ubc1DKSS7mB9kIEE4dUQZ+/GOuE0BrVaTTnFtCmLjYdYTZdmxMw3lFoRFixGxWnfqBgJYilQAEgdP4NwCmpnicHhrig4jHKTS9pgLR3OvrKegB4OmnWRC9ulpr4tbX03kohVg+9zlq+bW1iy/qUIgL9sABTpZ0mguvtpba46lTWkAcUMdVVZUK1iNHlu6j8Ad5kUxyY8pkqPlZywnq93MCd3RQ27SWFtMKQwAAIABJREFU5qzmZgrChgYugliMbb90ia+aGm4AO3bwupEIF8mZM7xmSwv71NJyO79NMMh71tWxX5cucQNua+M45nJaxWp0dK6ZR2zMa0VLi46T8LFIyOfUFDfntjY+E9EEy8vnar+1tdykR0fVXBEO6+aRTFLQt7frCSEQYH/7+vgclgup9AonSRYU84rPx//v7Fx9zLiYlERzB7gmysrY3qtXOR9nZvieFGq57z72NZnk94qRfLUcEgnOE3lJaU8Jrayr42a9Z4+a7oTZtbyc8+zaNSVgE8qVjg4+m5mZ28NJAY67CH7Jr/BCaFUymblO82LDafyL4MIFPmi/n4tzfrWlXI7a8D/+IydVd7eacR57jLv2K69QU0wm+fvkJBfBL/wCnXbzd3VrqUXNzMzlhgG4+N98U4uwnzzJhT45ycVXW7v6BS32e7G/19RQ0DU0aPjjQpuTcNvLsViiFMRJmUyyPxcu8JRz8KDan9vbKTwWE8xCeHbtGvsmC1Q234VgrcZ4j45yIYkZS046a9kIpH6CUCjX13Ocbt7kfaX/ra1La2zJJE9siYQK/gsXaJbz+Tjm7e281sQE51A8rhnDK4mYsZZaeCTCe544wXki45IvjXQ+kE1Y8geGhylQJZfhueeUoqG6WjeRgwc1N8WrZKwUIqzFv5BIKAVHdzcVODFbigO2ulqZRPv7uTnW1OgpeMcOLaBz9qyaFMWMKaG2ogSIOVN8ZvKsxF/grU6XTGpQwugo50BXF/DRjzqNf91gLbWjO+643VmWSPAY/dxzFARiepBSfseOqSZ06RKFXkcHnbc/8RMLh2AmEvxuNEqB29GhdWZfeIELqaKCgqK9XY/QNTUrjwQQelwxQ9XUaGJXdXX+ESIVFdzApNj6wIDGKicSPK00NvL0Ew6rU/CDD/hda5WITjaWZFIZJ7NZjoXXYb1cBTCJzW5upnksnVZhJIXDAS5aiWLJF5JkJQJDTGsnTrDdt25xE7h1i+OymIAOheZGeVhLwVherpErQ0Mcuwcf5M+hIX4m1/TSaS/XZrHb79+v/y8sohK62dy89tORaLe1terrkZNnKsWNTMyCUoSmrY3PaWKCp2epvyAlQ9vbebKNxThvpN6zmFMOHOA67e3liTqV0s/FR3DgAOfZ5KSWAxV+pkSCbW1t1UgvyXguL587xg8+uPQ4L8XGKnWoF5tvjY1UCiUSrdhwgn8W4+MU0MLNIXbX+RgeVpNNXR0F8sQEJ99jj3Gy9PRQw3jmGXUCHz/OCTif+jiXo6C4fp0L58ABLo6xMS6gCxc4Ge65h07M1SR5WMsFE49rgZG2Nq2StFZaXGMoRKSS1NWrGit+/jz7IUdav5+baWWlZtVKRvHevRyHq1fZvoWKn68Ukn7f2EjNMpnU6lZDQxS4Pt9cts6lsG+fJux0dnI8JfO5vl5PTyJgz59XErXFFr0xnB+JhG5OY2McF7+f90il1HQUj/P0V1NDgZZvwRzvRnTgANsViXC8r13j9cWhXijIhh4Ok3QQoOYrWrnX1NnSwnnhDdWUMRMqilhsLtlZKKR+LqG9KC/n+8GgJqtVVvL6sRgFdHm5BiscPLgxGGolsbAU2PamnpkZCumrV7WM3kJ2b6FQfv55aiYf+hDt3N/9LjWXI0d4jTff5M/JSSZY3XUXF/G99+ox24t4nI6lqipO3LExTnKh3B0cXB1vynytvqmJwqe+XmvNrga5nPLh+/26kT3/vC4uKSKTTvP43NvL8QgENKRVriWhcgcPcoNMJGgz37+/+FnDQrU7Osp2ilCRU8NiYyQO/ViMz72+XjmTDhzQE1gmoxu3z6c5Fvlo6tGo2pdv3aJJUfwEnZ1KPZFKcd7s3s1nvJrnKhtOWZnGlPf0aITURi2aIuGeXnPKYv2fnuZ4DQ+vjS672HDO3RJgbIzau5QsPHx4Ya1sZISUymfP0qY9PU0Bfvo08OSTjGn/3vfo3I1Gacr5zd+kAIhEeFT11ndNpylsdu6kgGlq4gOPRjWjVGz8kkqfD5JJjeyQRdzSwnasNdGqt5cbnEQuSNtE8D/66O2LrqyMY7FnD//v+nX9bGqKG97k5FxmQqGSuHaN49LRwXEqRnSIz6emsj17KADHx7kJjIxQkMgmMD/Z58gRCnXps9hu33lHq3AFg3zuU1MU3pEIN/K77lq+ypmXq0dMiNeuca598AHH5NQpLcvY3U0hvZrnXFGhSWEAlZGREa3ZICUiN1oN3fkb0kJtm5pSs5bPx1PnWk+RWwHbWuPv6aEt+dixhSMm0mmG4H3lK9Tment5Qmhtpdbwa7/GSIwvfIHO1/p6RuocOsTNQcL+jh2j0JfsvGvXKPjPnOFiGh3ltaemKGxaWubW510MUl5R7J4SPdPYODcDdCWQLNmxMW5EJ0/yOu++y/ckWWstiUIXLzLc8/JljuPDD8+14wtjZF8f++b3UwsqJZeJ0GL09XFTFgbFcHhhDVg2w54eCvjqas4D7wlvfuauFIcXGoXlIH4E8QX97M9yjoyMaB4FQPNSVdXcOg0rhYQnDg+r8/74cc6xQidKFRNvvMFTUXs7X6XINF8LSqXxbzvBL1wZDQ3qaZ+vTcZipFoQEqq/+ztmcOZyXPiNjfz/nh5ma1ZUkEXzzBkuvt27qS3JgvZyyty6pYv07rup6V68qNzx4mRdDJkMN4hMhouvuZn3WY05yBs3PjhIgTI5qe/X1NBJWV6+9DE6H6TTmqbf26s27L4+jW6QZCcvRPiIeejCBfa9vX31po2VIpPhJtDfT5OIbAKyud66xX4Iy+PwMDe1lhbl5V8IUqfXWs4nCVFdrk9i8xdl4hvf4Dzu7KSpSegtAI5RW9vK2T69yGZ5PRlvSRyUoiobpYZuLsexHxzkiSwQ0LDNjZpPMB9O8BdB8E9MaKz9mTO3T9bhYeCf/olRNCMjjMB55BGaJL70JS72ykou1osXufCffpq0ycPDWgoxleLEkwWcTgN//df82dZGYeA9OksI50LFMCREMR5XtkxxzNbW5h/2JvZsySydmODv99/PjWx4mAvaWwu1ENqR0E309NCUNr9SkXAe9fTw9w9/eGkhcv48TRvZLE8cra00B+Xr4FwrRAj291PACLVAT49y/gQCnAMS2jc9zbFc6ISUTPI6g4OcH62tK3OwCrX3++/rPGpsZHBCWRmvm83eTvWxFkiFs7ExLXy/3CZXTKTTWrglneYavfPO4hMKSkhmIMB7zsxwHkgSl2QmNzZSdiQSVAiEfmTXLq4zv59rMxjkZx/5iLPxFwz9/bTnh0K0jXqFSypFrem11/RYL0yFDzzASW6MhuoJU98nPsENBKDG/d3vatbszZtckA89xAV4/LgmKUUi1Fz37aPGP5+qQVgQxTHb2EiT0Xzul4Ug9AcSstbUREE+OUmnNMCJVlPDk4kII7HjFgrWUqBfvMjFIZm48+HzsR27dmmlqFyOm21X1+1tOnqUG0gkolFBfj/HyFpq5FKZrBgIBHSsMhluAjdvcqy7u2la8BLoARyDdJra+HyTYijEfu7eTZOK/F8ySZ/Izp1La+t+v/pRJiZ4auvpUUd6QwOd5eJwHhjgXGhtXf0pQDT9mRlNnPOup/PnOU+FOqOYyVrJJMc8l6MQveOO5f0nK4G3ehZA/4qYccW5vHMnx39ykuMvlBRtbZoYJuHJfX2cp9ksr1FVxecQjWpyZCmwLTT+ixe50zY2clFKpuHoKAf96lXgT/6EC0eocIXBsaODYZlytJVCJ3v2UMDfcQc/e/ZZtelHo0rX+ou/yIeby1Eo3bhBIdDQwO+Gw2qrTyQ03FL4W+Y7ZnM5TVKJx6lJNDZysr3wgvKNC6QuwMwM719Ts/zmUQgIDUN9PQX1QkJ/McRi3IQTCY75oUOLL2ahmZAQ2Fdf1SxV4dspRXWjVIpC4bnneP9Dh5QvaHqam8LUlJKwLWd6GBnh/8zM8Hnt3KnFfJaDt+7CuXNUeITFtKJCaT0qKnhNYZQsBLJZjWQS82B19crCTpdCJsN5nM2qQ7qvj/OrED6gSIRtl0RAWasS3v3ee/pdCeH1+ea+L2G4ounH4xxzMbvNzHBz9G4qkiRZWQk88YQz9awZ1jISwu9nNEU6zWPxK6/w55kz3JXffhv4+79XISx2aGsp4CW0srqa2vsDD/AhjY/TByATXZI+jhyh0JUFJfw8NTWcsGVlyrUfDHJSCAVzIKD8NFITFqBQEUeuYNcutgdgRInYniU8tJSp8ZOTWtJvdJTtX22px1yOm+Tly7xOaytPWUsJPms1UUsSngCeuhoa+OwXKnRdSNy8yftWVbH9Esop7JM3b/IZi8N/KWSzPIEODGhW6P33r+yZTk9T45d6wnKCfOABzb2oq6O/CeC8K4SJL5tl38Ws2NHBOT45yXVXVaUlJyVyailGUqlcJmvS2+aVYHpaq3cJiygwdw3FYnPbVV3NsRfzqGjnXmr1nh62SZIzX311Lgutz8dNv71dQ8jFQT4zo/QP5eUunHNN8JIwnThB4XHuHB/I+fMUwsEgtf1HHuEDuH6di1OyKE+dAj75SYZtvvYahcfJk9SQolEeMW/coEZ96BA5eyTVPp0mx357OzU8yb4U+2g4rEVDxN/w/PMqrAC+5+V7F0rYUEj9DV5NTVgZS41Egqeqvj6aMw4dWrt2J4Usdu3SKCgR2F5qYi8kX6GpiRvv1BTHWpzlV67wJbTOUle1kBuBl2pD7jsywnlSWalF0vOJtgkEtJCM8MuIcLx0icJzuVNAOEwBefQo29HTo/6ktjbOWXFeh0I0b0rRH9FYV4NA4Pa6x4AWeJ+e5j3FXHLsGE/fY2M034lPJBjkmozF2BbxbVVWcg0KhXNdHZ+/CGch95PwaEkeu3mTcwJQPiGvL0CcwvE4ZYacNH/0I2XgbWqi/JCQV0FZGe8dj2v/OzvZ53PnuIEPDOj3d++mEpjN8rQoWcelwJbU+HM5PqhEgtE2fj+F0u/9Hh+YtXyIw8P8jkwWv1+PY2KL7eoCfuM3+L3z5yngrl3j9SRr8Hd+hw/6/Hm+LyXcslluCg88wEkg6eg1NZoeLlQGgFbpKStTzX8jI5NRtkyA2s/+/cUNmUulgBdf5KIRHvZ8MTHBhSqarvDCPP44Px8fV2GwVlNYPE7T265dPGlaS+ElWr/4b3p7qRisJLY8m1U6bZ+PwnA1NvvpaeA731GhWlurkWzS/8pKOpuLUSAkl1PNu65OneQffMBnIcluqRQ3rtZWjp03H0Rw+jTbfe0av+P368ZRXk6TrM83N3vde8JIJrUWwcSEVsg6epSyob+f/3/qFL8vvqv6em6U3d1zC8HPL9LT36/jKqy+4bByWonvoLOzNKaeZZeNMeZrAH4aQMRauyCRgTHmEQB/ChZhH7HWPjz7/nUAMQAzALL5Nmo1+MY3gM9/nppVayvwcz9HTf/iRVIpdHfzMzl+ywTw+6lxnz5N88/EBB9GWZmScAFcGB98oPbLjg6Wcjt4kBpUNKpRBQ0NStOwc2f+JpdCOqVKgffe44Tu6Lg9Zr1YsJab8uXLfJZ33LF0iUkvhLMG0Ogcr5Ylx/xAQDlnxFewUlRW8sTS08Nnf/iwJovt38/5cvkyBfjLL7MPhw/nt2kGAqTwmJqiBhmJ8DS5UDjsUgiHgZ/5GeVYikT4eughbuJDQ2yj0B7I5zKOa/UVCSFdIKCJkQBPtnffzb5UVOgJ3BjNChcIdYM8/927VcteCJWVWmZSnNySU9HXx/tIveNolGZiQHM4hoe1EpwofoAmGYqZdb5CslSBJLFKWEulpBRYVuM3xvwkgCkAX19I8Btj6gD8M4AnrLW9xpgWa21k9rPrAE5aa1fUnZVq/N/4BvDZz95u/66r4wKX+qdizxOHaFMThe0f/AF//5u/oQbm9yvnfnk58Mu/zIny4oucIM3NXLwyKQ8f5v9HIuq82+iJIquBteqwDYc5JlKkotSIRrkJj45yoX3oQ2s/IQm9czTKhT05Sa1Tita8/LIStEnRb1ESFsN771FDveOOhcM0UymaV378Y87fri7O15WcOoQkr6mJYyDMmDt2rIyHPxbjHN61i306f14dw2K6k7BDIRyrqeH8F5rqxdosYclCizw5qZugtbT7V1dTaSokY6hAaCnk3lIZbu9eat+RCPv20EN8xnIqlGpqkqthLftdX8/XSjbafLBhKBustS8ZY7qW+MovAfhba23v7Pcj+dy4kPj8528X+gAfHMCH+NRTfMCvv660r6mUOgObmjihJyY4ySXppbFRqXFv3dLsWCHm2r+f8f7GaIm/rQZrKUwuXuTi2L+/NHHSS6G2lqe0wUEKaxH6wqG+GlRXz9UmJewOoJCQiJihIXXciU8jk2Ekk8wLidQ4cECdeVKm0Yvycs6fw4c1LLGiggLAGArB5U5SgcDt143H+bwkya+lZXlz0vz+19VRox0bo+IkUSenTrG/fX26UYTDvF88znXk87HdHR38n7feUipoocqQ+ZNP3Yh8kE6r6UicuBIrH4/zGdTWckOcmaFJSPpVVaVRQpI3E4tpyHNVFfvS0LDxqCtWg0JYkQ8CCBpjXgBQDeDPrLVfn/3MAvgnY4wF8BVr7VcXu4gx5rMAPgsAu3fvXlEDensX/ywcpqnnc58DvvlNLaAg2rykvI+M8MGK3Vccg7kcTUHpNDePcFhLwC1U93WrYWiIC3pykkLh5MnCazlrgRQOB7hQX3xRTU9rfTZSNQ2gAJWaAMJ2KpxNwNwqYWIaAWiyOHZMzRnd3Wp7LiujYBVOdtGcxYnZ28s2RCIrYxBtbaVwi0aV7TMe18gVb1H4pdDRQSUnFuP6GB7WUFFr1Un69ttqBkqnOU+E9fT++7VwzpUr6kuQylPClintknEXCEWztRzbbFadtpkMhXpTE/9XkjMFEiItSXQSnt3Rwf+vqKAQr67mRnDrFk85XgqUdJptLXSey3qjEII/AOBeAGcAVAA4a4w5Z629BOAha+0tY0wLgO8bYy5aa19a6CKzm8JXAZp6VtKA3bu5c89HMMjF9OijfIDNzdRUKyu1JF4wSHv87t1cmBcuaCZeSwuPXV1dfImdcavDe2QfHuaiOHGCQmAj9z8Uopnt6lUu4n378ouZXymMUVOPoLKSgQSAOi1TKTXZ7NnDcYzFaFOvr+eclLq+ExNqTwYo9AcHGRhw6hTn94sv8pp+PzcBcVqGwzz13LqlNm9pZ1cXT2hDQ/Q3ZDL0K0gh+uPHqcVGInzWQmMimaf33KNkg1Kc5O23NWN4/37NP5F6Dvfdx+sLFcnrr/PZSNa4ZKFLYt+dd7LNb7wxNwQS0Ex3OVEJrz3AsWxs5IkkkaCyJvz+gQBJFWVeNDVpqVBAa0tLbV9hO62p0Si8razUFWJJ9IEO3WkA08aYlwAcA3DJWnsLoPnHGPNtAPcBWFDwrwVf+MLtNv6yMuBTn+JifPppvldRwUkmE1uqRj3wAB/+6dOcvLGYcqpPTmpx50LFOG9UCIlcTw8jUSR5yks/sZERDPL5dnbSES9lCx99tLRcMuK09G4M4TA1/wsXKKQ7O7VYCUBB88gjmvV5zz0UrMPDFJzNzaQGiccp6Pr7NSQyGFSOewlv9L7Exi9Z6TU1FMISjSWF7JNJ3TgkGkZCZ0UQSr3YsjJlBx0fZ5vSaXUwp1LcUCTDN5Hg30Jrkc2yX8JKC7AvtbXKy/TOOzwl3LrFv9NpKmNCR3H2LN8T3qc9e+YK7AcfnLvp53K8l7B1ptP8/pEj/J/539/KKEQ3vwPgz40xAQBlAO4H8EVjTBiAz1obm/39MQB/XID73YZPfpI/P/95PtTdu7kZfOxjGiecSvGzQEAjCSRWPBCgRjQ+Tq22uZk/w2GlEQCAf/5nXk9iq9fDqVkMpNPUKKVMpDd0bzMuhMpKxm1Lco08v7GxlWUQFwN33skxvnCBc0n4bQKB2ys4tbdrRvDNmxSqkqshpf6Gh/lZLsfNRIqMzIfE7Xsh2etSVKaykr8PDSlfkzx/cWbOR1WVmkDEvg9obWWAQrW2lvcXJ3EgwLGQU4SUJQyF1HSXyfB9+b7fP7eO8r33qj9hIQQCc7OY331XE+oaGrRAj/f72wX5RPX8JYBHADQBGALwR2DYJqy1X579zu8D+DSAHID/Za39U2PMXgDfnr1MAMA3rbVfyKdRxSBpS6Wo4YyPU/sQjf/QIU76VIqTvqVlYa3eWgrHgQEuFuFqP3jw9vq4mw2SEdzcTGG5UYtUrAXDw0yiaWqi+W89N23JJu/v5/yTurtLYXxcM0gl30Octd5NoK9PT6v5+gS8GBzkPJcwVzGL7t278lq/ciIRE08mw9N1WRnbKhnOi21Wq0E2q1FZ4+PcZE+fZttHRjhuQrOwEeHYOde52PpSSKepFUnN0I4OrZkr9UtLSZWwEiSTFDiRCBehOA8rK4sTRrdRIBQQly7x+bW3U+iWkuPfC2tpK5+cZFTPSubL2bMajHDnnbcLCakq1tenGq5keudrspue1nj1VEozX69coQCvqVk5LYg34urqVc5DET/BIK8p0T1eGu+lkEholN6tWzRTAlr/V0IuN4s27wT/Bhb8C2F4mM6pbFZJwpqbeRpYb79AOs1F0d9PcwfABXHy5NZ2YC2ETEapG8rLGbG1Xv4LCRcNBhenoVgI2SwTq8RGv2/f4lnM3qpiclINhVbP4yScPxK5JElVhw7xbwmtlZq3S8HLJBuLsW1ynbff1oxi4cwRn4NEVE1P8xpSJ1s2vNrajVMjYDHMzOimJ8EUPh/bvyHi+B3yQ3MzU/8lL0DC2yRjLxJRB9dqq2Pli2yWAl4cjJOTTCSqqqLjLN+6r1sRwSCFS1cXBYWkz1+/Tt9QKTVDCRe1lglcZWUM/1xuboh9vLNTmWeFB2g+JK+grY3COhrlSXVwkMLH7+ccyVfQHDjAl5T5lIQugP0Q3wWgtAmtrVSArOVm5fdTyAl9QXU125fNKp/99DQF/61bGu4aCnENBQLcyIQdc3SU/+MlNFwvWDs33FTyQLyQyCTvGAjLbChUmg3LafxFhPdo+9ZbPHoDSgnQ0KAajuQWrGZDEMEVi/FoLtrTvn20Z0t9gfnOQwciEiEJX3k5hdpSKf/FggjwnTsZ0bOS+0uOhTGcY9ns8jQWuRz/T0jRpNB8eTk3kdVsgGLXF9rwVIoCUMwt2SzHWRy2AiEry2QY6SNZwcJZJXWjhd+ovJwmu3ic95HTx86dfH7W8vQdDHL9yXXq6qjwSPGctZpjJXdDoqkATXIT34VkdksklN9fvLKVztSzQeG1mwph24MP8rOXX6Y2JhNV4oxlYzh/ntqON4GlqUmTcp59dq5ds7GRE32z2DbXG+PjFL4jI9QkxWlfSjPQ1avUmJuaGCq5mmf3xhvU6EMhmn/y3cSSSW4EwvsjhGNyYiikz2p+uKmXa2c1kFBWv5/9lpODVMNLpynopeBNMkkSR59PN4VgkBtHQ4NSYAg1hZzKZO2JyCwv1+incFgzttfLxOQE/yZEfz+1rkRCqWRrahhPD9Chl0rpZCwro3CX4/1WzzEoFYaHuQHkcswBKbX9v6+P9u2mJjrfV4PhYWrEEt9+9OjK6iJIZnI0qoldoqULe+lmm2uZjJpYMhktdemlb969m+M+MqL+OkEoxMQ0oefo6dFxkFdnJzeAZJJrWd4Xpt1izyUn+B0c1ohUikIzk6F5Yu9eaoSl2AgiET3xrQWjozQfSYiuaL4rdRzKRiCmoZERzdaV+hCbqaC5YGZGTwXZrDpZxTcmgj0Q4Li1tPD9aFRpmL0vqV/d388sYy+MYfRWXR2fb28vN4Tycr4ku3gtY+icuw4Oa4S39m02S+drdTVtyG1txd0AvHkUPT1qulsp5icoSe2EnTu5GeS7sXiFodSHTqc1IkeYLCXzF9BTaXn5+m8I2axydImpRqgaamvZp5oajSBazqxVW0vtfzG0tJDl03uaEG4ggO9NTakZSvCRj5RurJzG7+CwDKyl3fzSJR7hC0UDvRxmZuj7mZ5mtM9aEwXjcQYB9PZS+NTWapWzQiCTUYer0B9Ho7dXlhKTi2TjSpTPSmz9koAp9MqS+Ts/ikYKG9XWKvuoVLATorj1hLV66lgr66cz9Tg4FAGyAYyNafHtkRE6+Irl0MtkeNoYHmaU1p13rl1YZbP0Jdy4QUF4zz18PxotTkbzzIxqvek0hZyUNpSoHLG3SyjocvBG/oippLxcKR2Ea0h4trYDnKnHwaEIMGYu500ySRqIsjKaTjo7C+/0DAZpO75wgUln8bjSQ68WgYAyzorTNhYDXnqJ5hyhYy5UvQXh2MmHCloifXK525k6vXHv662pb3Y4we/gsEqEQoy8kTqxly9T+O/bVzjuGYBC7uhRmpgKTQUi16uoYGjwzZt0XHZ30xF54kRpk/1EqG8XLX294AS/g8Ma0NTEVzTKDeDaNdrNAc2MLRSkQhSgVMUrCdNcCoEAbf27dimf08CAbmBCA93SQnOQ07g3N5zgd3AoAGprSWTmzad4/XWaLPbuJXlfIYWlcPWPjWnlrkJBCtrs26fvjY3RMdzdzc2gpYWvQm082xnWqu+jqqo0px0n+B0cCgivjb+lhSeA11+nKUUyR5cqzp4v7ruP5iWhGr/33uIyjd51F3mehINqcJCx/CL4JaFJiq04KLJZ+makFGQ8TkWho4OnwmefVX/Go4+WxrTmBL+DQ5Gwdy/NPoOD3AA++IBa/759c8tbrgY+HymMGxuZ6fvSSxQahfQtzEdZmdasFS0V4Knm8mUNpRTytF27tmZth/mQkMzpaWUOlYpgAPCDHygFBkDzX2cnx9HvJz2IN5mrFHCC38GhiDBGK7bFYqoN9/dTW+/qota82pyA1lZSS3jt8WvdVPKBkKUB3IQef1wze4WPqr6egj+RAF59VQubV1czYkjdwB6/AAAM3klEQVQKy2x0yCYn2roUhRdT2CuvsL8CY2jaE8F/5AgFvNBLzz/xHTxY/D7MxyYYdgeHrQEvO6rQALzzDkM1OzqoBXrLXuaLykoVQtEo4/7vvptO51LB52MUkFQFA9R8kctxE4jFtO4vQPNUWxuFplBLC/1DeXnpSAaF218SqVIpmmDuvpufv/EGT21eVFXpmHd1sU8i2Csq5trpN2KFPif4HRzWAa2tfI2NMZGqt5e/P/wwP19JYZaFcPYsN5LDh9dPq5ZTRzisFby8hVRkkxAKAy8ZHMDs6Lo6hpieP69MmZLte+IEhezgIE9Qcj/JBTh2jN+X8fVm92azwJNPcoyvXqXjWiB5B3Jy2rWL9TZCIRXsXl/ORhTsy8EJfgeHdURDA19Hj6oJIZtlHWSp4NbUlL/ppraWm0d3NwVaJELH7I4dxevDSiC1gL0OzOZm+ieAuRz38p1wmE5xKWySzXIDkTGRAjNeGKMnDp+PglropYV4TbBnDxPWxMY+f6OU4u9bCfkUW/8agJ8GELHWHl3kO48A+FOwCPuItfbh2fefAPBnAPxgEfb/nE+jHGWDw3ZGKkXTR18fhV0oRMG0Z09+2a+C8XGaktra1seO7EDMzHBjSqf11AFwQw+HuYklk3y2peLqyUfj/wsAfw7g64vcrA7A/wDwhLW21xjTMvu+H8CXAPwUgD4ArxtjnrHWvp9PwxwctiuEQ//wYRZFuXmT2ruYFKantejIUqivp+NXMDREO/vevS4zthiQ+saTk3zt2kWn/vQ0ndvzcfw4Bf/EBD83hs9rNX6elWJZwW+tfckY07XEV34JwN9aa3tnvx+Zff8+AD3W2qsAYIz5FoCnADjB7+CQB3w+jQjyJoZ1d9Om3djIk8DOnYvnBngFfCRCW/aNG9xUhGLZYXXIZmkWymaBH/6QWjtAAV5VpZp9OExqDym9KKYk+VlZSX9EPL6yE91aUAgb/0EAQWPMCwCqAfyZtfbrANoB3PR8rw/A/YtdxBjzWQCfBYDdC1WNdnDYxvA6E++4gxFCfX3Au+8C771H7fLYsaWvcdddtFdfuMBIlYYGbgBrLfiyXZDJ0AEtVcnq60mYFwhwE62qojO6pmbuhuv304+xGEIhraRXKhRC8AcA3AvgDIAKAGeNMecALGStWtShYK39KoCvArTxF6BdDg5bEuEwC8IcOECTQn+/avzWMpyzuZlCfn5CUHMznb+9vVqw3An+5fHOOzS5WctNWMZXcHRB7+fGRSEEfx/o0J0GMG2MeQnAsdn3vYFOHQBuFeB+Dg4Os6ipmWsTTiS4GQwM8DTQ0EAB1d6uPgFjNHNUNNOeHoaTHjw4NxZ/u8FaOmIHB1lr4fRpjlFtrXIU1ddvfpK6Qgj+7wD4c2NMAEAZaM75IoCLAA4YY/YA6AfwCdAf4ODgUCRUVgIf/jCduAMDfL3/PgVXKERHYyLBDcHLHOr3U/C//DKjTfbt2x50C4KpKTrQh4a0hGRjIyOshGdpK2FZwW+M+UsAjwBoMsb0AfgjMGwT1tovW2s/MMb8I4B3AeTAsM3zs//72wC+B4Zzfs1ae6EovXBwcJgDoUY4eJCCXkw+vb3U7gMBCviWFpotpATjjRsUgK+9xlOBZK9uNaRStNXX1vLElE7TZ9LSwhPSjh2FL6qzkeBKLzo4bCNkszRhDA3RQZlIUMA9/ji13GiU/oLRUfoS6uvpB7hyZfWUEhsB1jJsUthFhVvnwAHg0CHN9i1lmKtwAGUyWje4tnb1NRxc6UUHB4cFEQgoXQRAE8f0tNqs33yT71VV0dQhHDa9vQwFranR0owbmX7ZWvYjlVLOoh/9iIK2vp7CXorKAMUp55jL0eQmXEBSiL6zk+MfjdK05oWjZXZwcCg65tMnHD9ObX9sjNFCN25Q0P/UT7Hq19mzfK+qCnjqKWqna+UVKhQmJniKmZhg+9Npnlo+/GEK9fvu49+FqIfgRSZDh3osxldjI7Ol02nSZQukKLyQ1IXDDLH18g+VajN1gt/BweFfUF+v4Z3WUpAZQ2HZ2kq/QTxOQff97/Pv0VFGAjU38++dOwtfG1gwM0PteWpKXydOsI1CxlZVRRt9YyNf3r6tBbkc72ctTwrWklNJOJYAnqjEnxIKAadO0eEeDt8+JsHg+jmNneB3cHBYEMbMtemHQsBHP0oThdASxGI0pVirFNNSaGT/fgrBffsogONxauSBAE8I8qqroxCMx0l5IHw2Uo7w0CFe58oVRih5EQ7ze+XlTGy7887CavTXr3Nji8VU6Dc1AQ8+yPFpb+f9xJk+P/N2oxK8OcHv4OCQN/x+ZRSdj1iMQn5ggJtEMEizy/e/T3NRKkVBKtTGogE/9BCvNzYGvPWWXk9OGnv3UrA3NHATCIep1c/XoldjJonFuJGJr2Nqiu8LPfbgIN+vrtYTj/gFAG40mxFO8Ds4OBQE1dU0bXiRTDI8dGKCgr+ujhr9oUMUpBMT1OTlJHDkCDeGujoKe6/D1WuGWgy5HE8LwSD/d3KS90gm+Uok2A4hr7tyhRm5xvC+VVVzC+bcf//mT9ZaCE7wOzg4FA2hEPmABOIfqKvjZ5kMKaiHhpQ/H+ApIBRibP358zQJ+f3qRBZHbW8vSetyOQ2JBIDHHuPGMTBAagqApwcppjIzw+sdOECTVGXlwg7qrSj0ASf4HRwcSggpTyhobmbEkHDSp1K02YvWHQ7TTDQzw+9IRIyYeCoqGJYpG4MUWREh3tVFArTy8oUFezhctK5uaDjB7+DgsO7w+W7fFIDlzTvNzUszX84nqXMgNkD0rYODg4NDKeEEv4ODg8M2gxP8Dg4ODtsMTvA7ODg4bDM4we/g4OCwzeAEv4ODg8M2gxP8Dg4ODtsMTvA7ODg4bDNsyApcxphhADdW+e9NAEYK2JzNANfnrY/t1l/A9Xml6LTWLpHOptiQgn8tMMa8kW/5sa0C1+etj+3WX8D1uZhwph4HBweHbQYn+B0cHBy2Gbai4P/qejdgHeD6vPWx3foLuD4XDVvOxu/g4ODgsDS2osbv4ODg4LAEnOB3cHBw2GbYtILfGPOEMabbGNNjjPkPC3xeboz5q9nPXzPGdJW+lYVDHv39d8aY940x7xpjnjPGdK5HOwuJ5frs+d7PG2OsMWbTh/7l02djzC/OPusLxphvlrqNhUYec3u3MeaHxpi3Zuf3k+vRzkLBGPM1Y0zEGHN+kc+NMea/z47Hu8aYewreCGvtpnsB8AO4AmAvgDIA7wA4PO87/xrAl2d//wSAv1rvdhe5v48CqJz9/bc2c3/z7fPs96oBvATgHICT693uEjznAwDeAlA/+3fLere7BH3+KoDfmv39MIDr693uNfb5JwHcA+D8Ip8/CeBZAAbAAwBeK3QbNqvGfx+AHmvtVWttGsC3ADw17ztPAfg/s7//DYAzxmza0snL9tda+0NrbXz2z3MAOkrcxkIjn2cMAP8JwH8BkCxl44qEfPr86wC+ZK0dBwBrbaTEbSw08umzBVAz+3stgFslbF/BYa19CcDYEl95CsDXLXEOQJ0xZmch27BZBX87gJuev/tm31vwO9baLIAogMaStK7wyKe/XnwG1Bg2M5btszHmBIBd1tp/KGXDioh8nvNBAAeNMa8aY84ZY54oWeuKg3z6/B8BPG2M6QPwXQD/pjRNWzesdL2vGJu12PpCmvv8uNR8vrNZkHdfjDFPAzgJ4OGitqj4WLLPxhgfgC8C+NVSNagEyOc5B0BzzyPgqe5lY8xRa+1EkdtWLOTT538F4C+stf/NGPMggP872+dc8Zu3Lii67NqsGn8fgF2evztw+/HvX75jjAmAR8SljlcbGfn0F8aYjwD4PICPW2tTJWpbsbBcn6sBHAXwgjHmOmgLfWaTO3jzndffsdZmrLXXAHSDG8FmRT59/gyAvwYAa+1ZACGQzGyrIq/1vhZsVsH/OoADxpg9xpgy0Hn7zLzvPAPgU7O//zyA5+2s52QTYtn+zpo9vgIK/c1u9wWW6bO1NmqtbbLWdllru0C/xsettW+sT3MLgnzm9d+BjnwYY5pA08/VkraysMinz70AzgCAMeZOUPAPl7SVpcUzAH5lNrrnAQBRa+1AIW+wKU091tqsMea3AXwPjAr4mrX2gjHmjwG8Ya19BsD/Bo+EPaCm/4n1a/HakGd//yuAKgD/b9aH3Wut/fi6NXqNyLPPWwp59vl7AB4zxrwPYAbA71trR9ev1WtDnn3+9wD+pzHm34Imj1/dxEocjDF/CZrqmmb9Fn8EIAgA1tovg36MJwH0AIgD+HTB27CJx8/BwcHBYRXYrKYeBwcHB4dVwgl+BwcHh20GJ/gdHBwcthmc4HdwcHDYZnCC38HBwWGbwQl+BwcHh20GJ/gdHBwcthn+P0RlL7t0wFW2AAAAAElFTkSuQmCC\n", + "text/plain": "" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": { + "tags": [] + } + }, + { + "source": [ + "The blue dot in the graph shows the value that the ProMP is conditioned with.\n", + "\n", + "### An example of Task Space Conditioning.\n", + "\n", + "First, we need to define the Kinematics of the robot, which in this case is a Barrett WAM." + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "source": [ + "class BarrettKinematics(BaseKinematicsClass):\n", + "\t''' Forward kinematics object for the Barrett Wam\n", + "\tThis class implements the forwark kinematics functionality for the\n", + "\tBarrett Wam arm used in the table tennis setup at the MPI. The end\n", + "\teffector position can be changes with the endeff parameter received\n", + "\tin the constructor.\n", + "\n", + "\tThe code is taken from https://github.com/sebasutp/promp/blob/master/robpy/kinematics/forward.py\n", + "\t'''\n", + "\n", + "\tdef __init__(self, endeff = [0.0, 0.0, 0.3, 0.0, 0.0, 0.0]):\n", + "\t\tself.ZSFE = 0.346\n", + "\t\tself.ZHR = 0.505\n", + "\t\tself.YEB = 0.045\n", + "\t\tself.ZEB = 0.045\n", + "\t\tself.YWR = -0.045\n", + "\t\tself.ZWR = 0.045\n", + "\t\tself.ZWFE = 0.255\n", + "\t\tself.endeff = endeff\n", + "\n", + "\tdef _link_matrices(self,q):\n", + "\t\tcq = np.cos(q)\n", + "\t\tsq = np.sin(q)\n", + "\n", + "\t\tsa=np.sin(self.endeff[3])\n", + "\t\tca=np.cos(self.endeff[3])\n", + "\n", + "\t\tsb=np.sin(self.endeff[4])\n", + "\t\tcb=np.cos(self.endeff[4])\n", + "\n", + "\t\tsg=np.sin(self.endeff[5])\n", + "\t\tcg=np.cos(self.endeff[5])\n", + "\n", + "\t\thi00 = np.array([[1,0,0,0],[0,-1,0,0],[0,0,-1,0],[0,0,0,1]])\n", + "\t\thi01 = np.array([[cq[0],-sq[0],0,0],[sq[0],cq[0],0,0],[0,0,1,self.ZSFE],[0,0,0,1]])\n", + "\t\thi12 = np.array([[0,0,-1,0],[sq[1],cq[1],0,0],[cq[1],-sq[1],0,0],[0,0,0,1]])\n", + "\t\thi23 = np.array([[0,0,1,self.ZHR],[sq[2],cq[2],0,0],[-cq[2],sq[2],0,0],[0,0,0,1]])\n", + "\t\thi34 = np.array([[0,0,-1,0],[sq[3],cq[3],0,self.YEB],[cq[3],-sq[3],0,self.ZEB],[0,0,0,1]])\n", + "\t\thi45 = np.array([[0,0,1,self.ZWR],[sq[4],cq[4],0,self.YWR],[-cq[4],sq[4],0,0],[0,0,0,1]])\n", + "\t\thi56 = np.array([[0,0,-1,0],[sq[5],cq[5],0,0],[cq[5],-sq[5],0,self.ZWFE],[0,0,0,1]])\n", + "\t\thi67 = np.array([[0,0,1,0],[sq[6],cq[6],0,0],[-cq[6],sq[6],0,0],[0,0,0,1]])\n", + "\t\thi78 = np.array([[cb*cg, -(cb*sg), sb, self.endeff[0]], \\\n", + "\t\t\t[cg*sa*sb + ca*sg, ca*cg - sa*sb*sg, -(cb*sa), self.endeff[1]], \\\n", + "\t\t\t[-(ca*cg*sb) + sa*sg, cg*sa + ca*sb*sg, ca*cb, self.endeff[2]], \\\n", + "\t\t\t[0,0,0,1]])\n", + "\t\treturn [hi00,hi01,hi12,hi23,hi34,hi45,hi56,hi67,hi78]" + ], + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "metadata": {} + }, + { + "source": [ + "Next we calculate the configuration to reach the 3D point parametrized by `mu_cartesian` and `Sigma_cartesian`." + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "source": [ + "mu_cartesian = np.array([-0.62, -0.44, -0.34])\n", + "Sigma_cartesian = 0.02**2*np.eye(3)\n", + "\n", + "# Get the prior distribution of the joint space at the desired time.\n", + "t = 1\n", + "prior_mu_q, prior_Sigma_q = promp.get_marginal(t)\n", + "\n", + "# Compute the posterior distribution of the joint space using inverse kinematics.\n", + "fwd_kin = BarrettKinematics()\n", + "mu_q, Sigma_q = fwd_kin.inv_kin(prior_mu_q, prior_Sigma_q, mu_cartesian, Sigma_cartesian)\n", + "\n", + "# Finally, condition the ProMP using the posterior joint space distribution.\n", + "mu_w_task, Sigma_w_task = promp.get_conditioned_weights(t, mu_q, Sigma_q)\n", + "\n", + "# Plot samples of the conditioned ProMP.\n", + "std_q = Sigma_q[plot_dof][plot_dof] ** 0.5\n", + "plt.errorbar(t, mu_q[plot_dof], yerr=std_q, color='r', fmt='--o', capsize=4)\n", + "for i in range(n_samples):\n", + "\tsamples, _ = promp.generate_probable_trajectory(domain, mu_w_task, Sigma_w_task)\n", + "\tplt.plot(domain, samples[plot_dof,:], 'r--', alpha=0.3)\n", + "\n", + "for i in range(len(domain)):\n", + "\tmu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_task, Sigma_w_task)\n", + "\tstd_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5\n", + "\t\n", + "\tmean_margs[i] = mu_marg_q[plot_dof]\n", + "\tupper_bound[i] = mu_marg_q[plot_dof] + std_q\n", + "\tlower_bound[i] = mu_marg_q[plot_dof] - std_q\n", + "\n", + "plt.fill_between(domain, upper_bound, lower_bound, color = 'r', alpha=0.2)\n", + "plt.plot(domain, mean_margs, 'r-')\n", + "plt.title('Task Space Conditioned Samples for DoF {}'.format(plot_dof))\n", + "plt.show()" + ], + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": "fun: 1.2607255597690448\n hess_inv: array([[ 0.00572446, 0.00044346, -0.00582389, -0.00205088, -0.00312282,\n 0.00545993, 0.00661536],\n [ 0.00044346, 0.0014325 , -0.00066501, -0.00146189, -0.00108719,\n 0.00078602, 0.00159786],\n [-0.00582389, -0.00066501, 0.00683648, 0.00209646, 0.00510573,\n -0.00521655, -0.00925261],\n [-0.00205088, -0.00146189, 0.00209646, 0.00539554, 0.00688907,\n -0.00790783, -0.00856472],\n [-0.00312282, -0.00108719, 0.00510573, 0.00688907, 0.09056763,\n -0.01234715, -0.10080951],\n [ 0.00545993, 0.00078602, -0.00521655, -0.00790783, -0.01234715,\n 0.01772946, 0.01689341],\n [ 0.00661536, 0.00159786, -0.00925261, -0.00856472, -0.10080951,\n 0.01689341, 0.12345578]])\n jac: array([-3.86583891e-06, 8.02217272e-06, -4.46214839e-06, 3.75499468e-06,\n -2.51596661e-07, 1.66831373e-06, -2.80330763e-07])\n message: 'Optimization terminated successfully.'\n nfev: 20\n nit: 14\n njev: 20\n status: 0\n success: True\n x: array([ 1.12820721, 0.59177272, -0.21965488, 1.89876834, -0.14786706,\n -0.0641282 , -1.1013934 ])\n" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": "" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": { + "tags": [] + } + }, + { + "source": [ + "The red errorbar in the graph shows the posterior of the joint space that the ProMP is conditioned with, obtained using inverse kinematics.\n", + "\n", + "### An example combining both Joint Space and Task Space Conditioning." + ], + "cell_type": "markdown", + "metadata": {} + }, + { + "source": [ + "t = 0\n", + "\n", + "# First condition the ProMP in the joint space.\n", + "mu_w_cond, Sigma_w_cond = promp.get_conditioned_weights(t, q_cond_init)\n", + "plt.plot(0,q_cond_init[plot_dof],'mo')\n", + "\n", + "# Get the prior distribution of the joint space from the conditioned ProMP.\n", + "t = 1\n", + "prior_mu_q, prior_Sigma_q = promp.get_marginal(t, mu_w_cond, Sigma_w_cond)\n", + "\n", + "# Compute the posterior distribution of the joint space using inverse kinematics.\n", + "mu_q, Sigma_q = fwd_kin.inv_kin(prior_mu_q, prior_Sigma_q, mu_cartesian, Sigma_cartesian)\n", + "\n", + "# Finally, condition the ProMP using the posterior joint space distribution.\n", + "mu_w_task, Sigma_w_task = promp.get_conditioned_weights(t, mu_q, Sigma_q, mu_w_cond, Sigma_w_cond)\n", + "\n", + "# Plot samples of the conditioned ProMP.\n", + "std_q = Sigma_q[plot_dof][plot_dof] ** 0.5\n", + "plt.errorbar(t, mu_q[plot_dof], yerr=std_q, color='m', fmt='--o', capsize=4)\n", + "for i in range(n_samples):\n", + "\tsamples, _ = promp.generate_probable_trajectory(domain, mu_w_task, Sigma_w_task)\n", + "\tplt.plot(domain, samples[plot_dof,:], 'm--', alpha=0.3)\n", + "\n", + "for i in range(len(domain)):\n", + "\tmu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_task, Sigma_w_task)\n", + "\tstd_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5\n", + "\t\n", + "\tmean_margs[i] = mu_marg_q[plot_dof]\n", + "\tupper_bound[i] = mu_marg_q[plot_dof] + std_q\n", + "\tlower_bound[i] = mu_marg_q[plot_dof] - std_q\n", + "\n", + "plt.fill_between(domain, upper_bound, lower_bound, color = 'm', alpha=0.2)\n", + "plt.plot(domain, mean_margs, 'm-')\n", + "plt.title('Joint and Task Space Conditioned Samples for DoF {}'.format(plot_dof))\n", + "plt.show()" + ], + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": "fun: 8.526433566955966\n hess_inv: array([[ 1.01790925e-03, -1.20597328e-04, -6.83049901e-04,\n -5.64745932e-04, -9.38575355e-04, 1.59759304e-03,\n 9.30550358e-04],\n [-1.20597328e-04, 1.04710165e-03, 5.92392314e-05,\n -9.64291973e-04, -1.60284512e-04, -1.52605910e-04,\n -4.77335945e-04],\n [-6.83049901e-04, 5.92392314e-05, 9.69904532e-04,\n 7.33793011e-04, 1.17219845e-03, -1.62156922e-03,\n -1.06067202e-03],\n [-5.64745932e-04, -9.64291973e-04, 7.33793011e-04,\n 3.39707261e-03, 2.16315241e-03, -3.74044328e-03,\n -8.43452618e-04],\n [-9.38575355e-04, -1.60284512e-04, 1.17219845e-03,\n 2.16315241e-03, 5.51937068e-03, -3.75607916e-03,\n -5.16948474e-03],\n [ 1.59759304e-03, -1.52605910e-04, -1.62156922e-03,\n -3.74044328e-03, -3.75607916e-03, 8.96227655e-03,\n 2.73778708e-03],\n [ 9.30550358e-04, -4.77335945e-04, -1.06067202e-03,\n -8.43452618e-04, -5.16948474e-03, 2.73778708e-03,\n 7.92506940e-03]])\n jac: array([-1.01095865e-06, -3.63066719e-06, -1.45111913e-07, -3.32455895e-06,\n 1.21235033e-07, -1.01830181e-06, 2.07365472e-08])\n message: 'Optimization terminated successfully.'\n nfev: 20\n nit: 14\n njev: 20\n status: 0\n success: True\n x: array([ 1.09105955, 0.57642078, -0.17797006, 1.89303136, -0.14327379,\n -0.14483377, -1.21242533])\n/usr/local/lib/python2.7/dist-packages/autograd/tracer.py:48: RuntimeWarning: covariance is not symmetric positive-semidefinite.\n return f_raw(*args, **kwargs)\n/home/neo/.local/lib/python2.7/site-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in double_scalars\n" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": "" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "metadata": { + "tags": [] + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2.7.17 64-bit", + "name": "python271764bit6cfbe129fb454d00b6793c67f2ece257", + "language": "python" + }, + "language_info": { + "mimetype": "text/x-python", + "nbconvert_exporter": "python", + "name": "python", + "file_extension": ".py", + "version": "2.7.17-final", + "pygments_lexer": "ipython3", + "codemirror_mode": { + "version": 3, + "name": "ipython" + } + }, + "anaconda-cloud": {} + }, + "nbformat": 4, + "nbformat_minor": 1 +} \ No newline at end of file diff --git a/intprim/examples/promp_example.py b/intprim/examples/promp_example.py new file mode 100644 index 0000000..91ceabb --- /dev/null +++ b/intprim/examples/promp_example.py @@ -0,0 +1,195 @@ +### In order to run this, please first download the sample data at https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz +### This code is adapted from the code at https://github.com/sebasutp/promp/ + +import intprim +from intprim.probabilistic_movement_primitives import * +import numpy as np +import matplotlib.pyplot as plt +from intprim.util.kinematics import BaseKinematicsClass + + +# Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz +with open('strike_mov.npz','r') as f: + data = np.load(f,allow_pickle=True) + time = data['time'] + Q = data['Q'] +num_joints = Q[0].shape[1] + +# Create a ProMP with Gaussian basis functions. +basis_model = intprim.basis.GaussianModel(8, 0.1, ['joint'+str(i) for i in range(num_joints)]) +promp = ProMP(basis_model) + +# Add Demonstrations to the ProMP, which in turn calculates the list of weights for each demonstration. +for i in range(len(Q)): + promp.add_demonstration(Q[i].T) + +# Plot samples from the learnt ProMP + +n_samples = 20 # Number of trajectoies to sample +plot_dof = 3 # Degree of freedom to plot +domain = np.linspace(0,1,100) + +for i in range(n_samples): + samples, _ = promp.generate_probable_trajectory(domain) + plt.plot(domain, samples[plot_dof,:], 'g--', alpha=0.3) + +mean_margs = np.zeros(samples[plot_dof,:].shape) +upper_bound = np.zeros(samples[plot_dof,:].shape) +lower_bound = np.zeros(samples[plot_dof,:].shape) +for i in range(len(domain)): + mu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i]) + std_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5 + + mean_margs[i] = mu_marg_q[plot_dof] + upper_bound[i] = mu_marg_q[plot_dof] + std_q + lower_bound[i] = mu_marg_q[plot_dof] - std_q + +plt.fill_between(domain, upper_bound, lower_bound, color = 'g', alpha=0.2) +plt.plot(domain, mean_margs, 'g-') +plt.title('Samples for DoF {}'.format(plot_dof)) +plt.show() + + +q_cond_init = [1.54, 0.44, 0.15, 1.65, 0.01, -0.09, -1.23] +t = 0 + +# Condition the ProMP and obtain the posterior distribution. +mu_w_cond, Sigma_w_cond = promp.get_conditioned_weights(t, q_cond_init) + +# Plot samples of the conditioned ProMP drawn from the predicted posterior. +plt.plot(0,q_cond_init[plot_dof],'bo') +for i in range(n_samples): + samples, _ = promp.generate_probable_trajectory(domain, mu_w_cond, Sigma_w_cond) + plt.plot(domain, samples[plot_dof,:], 'b--', alpha=0.3) + +for i in range(len(domain)): + mu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_cond, Sigma_w_cond) + std_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5 + + mean_margs[i] = mu_marg_q[plot_dof] + upper_bound[i] = mu_marg_q[plot_dof] + std_q + lower_bound[i] = mu_marg_q[plot_dof] - std_q + +plt.fill_between(domain, upper_bound, lower_bound, color = 'b', alpha=0.2) +plt.plot(domain, mean_margs, 'b-') +plt.title('Joint Space Conditioned Samples for DoF {}'.format(plot_dof)) +plt.show() + + +class BarrettKinematics(BaseKinematicsClass): + ''' Forward kinematics object for the Barrett Wam + This class implements the forwark kinematics functionality for the + Barrett Wam arm used in the table tennis setup at the MPI. The end + effector position can be changes with the endeff parameter received + in the constructor. + + The code is taken from https://github.com/sebasutp/promp/blob/master/robpy/kinematics/forward.py + ''' + + def __init__(self, endeff = [0.0, 0.0, 0.3, 0.0, 0.0, 0.0]): + self.ZSFE = 0.346 + self.ZHR = 0.505 + self.YEB = 0.045 + self.ZEB = 0.045 + self.YWR = -0.045 + self.ZWR = 0.045 + self.ZWFE = 0.255 + self.endeff = endeff + + def _link_matrices(self,q): + cq = np.cos(q) + sq = np.sin(q) + + sa=np.sin(self.endeff[3]) + ca=np.cos(self.endeff[3]) + + sb=np.sin(self.endeff[4]) + cb=np.cos(self.endeff[4]) + + sg=np.sin(self.endeff[5]) + cg=np.cos(self.endeff[5]) + + hi00 = np.array([[1,0,0,0],[0,-1,0,0],[0,0,-1,0],[0,0,0,1]]) + hi01 = np.array([[cq[0],-sq[0],0,0],[sq[0],cq[0],0,0],[0,0,1,self.ZSFE],[0,0,0,1]]) + hi12 = np.array([[0,0,-1,0],[sq[1],cq[1],0,0],[cq[1],-sq[1],0,0],[0,0,0,1]]) + hi23 = np.array([[0,0,1,self.ZHR],[sq[2],cq[2],0,0],[-cq[2],sq[2],0,0],[0,0,0,1]]) + hi34 = np.array([[0,0,-1,0],[sq[3],cq[3],0,self.YEB],[cq[3],-sq[3],0,self.ZEB],[0,0,0,1]]) + hi45 = np.array([[0,0,1,self.ZWR],[sq[4],cq[4],0,self.YWR],[-cq[4],sq[4],0,0],[0,0,0,1]]) + hi56 = np.array([[0,0,-1,0],[sq[5],cq[5],0,0],[cq[5],-sq[5],0,self.ZWFE],[0,0,0,1]]) + hi67 = np.array([[0,0,1,0],[sq[6],cq[6],0,0],[-cq[6],sq[6],0,0],[0,0,0,1]]) + hi78 = np.array([[cb*cg, -(cb*sg), sb, self.endeff[0]], \ + [cg*sa*sb + ca*sg, ca*cg - sa*sb*sg, -(cb*sa), self.endeff[1]], \ + [-(ca*cg*sb) + sa*sg, cg*sa + ca*sb*sg, ca*cb, self.endeff[2]], \ + [0,0,0,1]]) + return [hi00,hi01,hi12,hi23,hi34,hi45,hi56,hi67,hi78] + +mu_cartesian = np.array([-0.62, -0.44, -0.34]) +Sigma_cartesian = 0.02**2*np.eye(3) + +# Get the prior distribution of the joint space at the desired time. +t = 1 +prior_mu_q, prior_Sigma_q = promp.get_marginal(t) + +# Compute the posterior distribution of the joint space using inverse kinematics. +fwd_kin = BarrettKinematics() +mu_q, Sigma_q = fwd_kin.inv_kin(prior_mu_q, prior_Sigma_q, mu_cartesian, Sigma_cartesian) + +# Finally, condition the ProMP using the posterior joint space distribution. +mu_w_task, Sigma_w_task = promp.get_conditioned_weights(t, mu_q, Sigma_q) + +# Plot samples of the conditioned ProMP. +std_q = Sigma_q[plot_dof][plot_dof] ** 0.5 +plt.errorbar(t, mu_q[plot_dof], yerr=std_q, color='r', fmt='--o', capsize=4) +for i in range(n_samples): + samples, _ = promp.generate_probable_trajectory(domain, mu_w_task, Sigma_w_task) + plt.plot(domain, samples[plot_dof,:], 'r--', alpha=0.3) + +for i in range(len(domain)): + mu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_task, Sigma_w_task) + std_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5 + + mean_margs[i] = mu_marg_q[plot_dof] + upper_bound[i] = mu_marg_q[plot_dof] + std_q + lower_bound[i] = mu_marg_q[plot_dof] - std_q + +plt.fill_between(domain, upper_bound, lower_bound, color = 'r', alpha=0.2) +plt.plot(domain, mean_margs, 'r-') +plt.title('Task Space Conditioned Samples for DoF {}'.format(plot_dof)) +plt.show() + + +t = 0 + +# First condition the ProMP in the joint space. +mu_w_cond, Sigma_w_cond = promp.get_conditioned_weights(t, q_cond_init) +plt.plot(0,q_cond_init[plot_dof],'mo') + +# Get the prior distribution of the joint space from the conditioned ProMP. +t = 1 +prior_mu_q, prior_Sigma_q = promp.get_marginal(t, mu_w_cond, Sigma_w_cond) + +# Compute the posterior distribution of the joint space using inverse kinematics. +mu_q, Sigma_q = fwd_kin.inv_kin(prior_mu_q, prior_Sigma_q, mu_cartesian, Sigma_cartesian) + +# Finally, condition the ProMP using the posterior joint space distribution. +mu_w_task, Sigma_w_task = promp.get_conditioned_weights(t, mu_q, Sigma_q, mu_w_cond, Sigma_w_cond) + +# Plot samples of the conditioned ProMP. +std_q = Sigma_q[plot_dof][plot_dof] ** 0.5 +plt.errorbar(t, mu_q[plot_dof], yerr=std_q, color='m', fmt='--o', capsize=4) +for i in range(n_samples): + samples, _ = promp.generate_probable_trajectory(domain, mu_w_task, Sigma_w_task) + plt.plot(domain, samples[plot_dof,:], 'm--', alpha=0.3) + +for i in range(len(domain)): + mu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_task, Sigma_w_task) + std_q = Sigma_marg_q[plot_dof][plot_dof] ** 0.5 + + mean_margs[i] = mu_marg_q[plot_dof] + upper_bound[i] = mu_marg_q[plot_dof] + std_q + lower_bound[i] = mu_marg_q[plot_dof] - std_q + +plt.fill_between(domain, upper_bound, lower_bound, color = 'm', alpha=0.2) +plt.plot(domain, mean_margs, 'm-') +plt.title('Joint and Task Space Conditioned Samples for DoF {}'.format(plot_dof)) +plt.show() \ No newline at end of file From c76a4920ef51e1ee766e8f28a29533cb0dca89c4 Mon Sep 17 00:00:00 2001 From: souljbaoy764 <6441764+souljaboy764@users.noreply.github.com> Date: Wed, 1 Jul 2020 19:02:10 +0200 Subject: [PATCH 07/14] Changed to imports to be Python3 compatible --- docs/notebooks/5_promp_example.ipynb | 6 +++--- intprim/basis/gaussian_model.py | 2 +- intprim/basis/mixture_model.py | 2 +- intprim/basis/polynomial_model.py | 2 +- intprim/basis/sigmoidal_model.py | 2 +- intprim/examples/promp_example.py | 4 ++-- intprim/filter/__init__.py | 3 +++ intprim/filter/kf.py | 6 +++--- intprim/filter/spatiotemporal/ekf.py | 3 ++- intprim/filter/spatiotemporal/enkf.py | 3 ++- intprim/filter/spatiotemporal/pf.py | 2 +- intprim/util/__init__.py | 6 +++--- intprim/util/kinematics.py | 10 +++++----- 13 files changed, 28 insertions(+), 23 deletions(-) diff --git a/docs/notebooks/5_promp_example.ipynb b/docs/notebooks/5_promp_example.ipynb index f786c51..00a7fc2 100644 --- a/docs/notebooks/5_promp_example.ipynb +++ b/docs/notebooks/5_promp_example.ipynb @@ -26,8 +26,8 @@ "\n", "\n", "# Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz\n", - "with open('strike_mov.npz','r') as f:\n", - "\tdata = np.load(f,allow_pickle=True)\n", + "with open('strike_mov.npz','rb') as f:\n", + "\tdata = np.load(f, allow_pickle=True, encoding='bytes')\n", "\ttime = data['time']\n", "\tQ = data['Q']\n", "num_joints = Q[0].shape[1]\n", @@ -365,4 +365,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} \ No newline at end of file +} diff --git a/intprim/basis/gaussian_model.py b/intprim/basis/gaussian_model.py index b8580d7..9b760bb 100644 --- a/intprim/basis/gaussian_model.py +++ b/intprim/basis/gaussian_model.py @@ -2,7 +2,7 @@ # This module defines the GaussianModel class. # # @author Joseph Campbell , Interactive Robotics Lab, Arizona State University -import basis_model +from intprim.basis import basis_model import intprim.constants import numpy as np diff --git a/intprim/basis/mixture_model.py b/intprim/basis/mixture_model.py index 86aaf1b..341a191 100644 --- a/intprim/basis/mixture_model.py +++ b/intprim/basis/mixture_model.py @@ -2,7 +2,7 @@ # This module defines the MixtureModel class. # # @author Joseph Campbell , Interactive Robotics Lab, Arizona State University -import basis_model +from intprim.basis import basis_model import intprim.constants import numpy as np import scipy.linalg diff --git a/intprim/basis/polynomial_model.py b/intprim/basis/polynomial_model.py index d6bd8ba..e093151 100644 --- a/intprim/basis/polynomial_model.py +++ b/intprim/basis/polynomial_model.py @@ -2,7 +2,7 @@ # This module defines the PolynomialModel class. # # @author Joseph Campbell , Interactive Robotics Lab, Arizona State University -import basis_model +from intprim.basis import basis_model import intprim.constants import numpy as np diff --git a/intprim/basis/sigmoidal_model.py b/intprim/basis/sigmoidal_model.py index 9f24ca4..8367790 100644 --- a/intprim/basis/sigmoidal_model.py +++ b/intprim/basis/sigmoidal_model.py @@ -2,7 +2,7 @@ # This module defines the SigmoidalModel class. # # @author Joseph Campbell , Interactive Robotics Lab, Arizona State University -import basis_model +from intprim.basis import basis_model import intprim.constants import numpy as np diff --git a/intprim/examples/promp_example.py b/intprim/examples/promp_example.py index 91ceabb..7cc7276 100644 --- a/intprim/examples/promp_example.py +++ b/intprim/examples/promp_example.py @@ -9,8 +9,8 @@ # Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz -with open('strike_mov.npz','r') as f: - data = np.load(f,allow_pickle=True) +with open('strike_mov.npz','rb') as f: + data = np.load(f, allow_pickle=True, encoding='bytes') time = data['time'] Q = data['Q'] num_joints = Q[0].shape[1] diff --git a/intprim/filter/__init__.py b/intprim/filter/__init__.py index 4d6d7a3..ebeb69f 100644 --- a/intprim/filter/__init__.py +++ b/intprim/filter/__init__.py @@ -1 +1,4 @@ +from intprim.filter.spatiotemporal import * +from intprim.filter.align import * +from intprim.filter.linear_system import * from intprim.filter.kf import * diff --git a/intprim/filter/kf.py b/intprim/filter/kf.py index 6b9aef8..4552e45 100644 --- a/intprim/filter/kf.py +++ b/intprim/filter/kf.py @@ -6,8 +6,8 @@ import scipy.linalg import intprim.constants -import align.dtw -import linear_system +from intprim.filter.align import dtw +from intprim.filter import linear_system ## # The KalmanFilter class localizes an interaction in space via the extended Kalman filter. @@ -36,7 +36,7 @@ def __init__(self, basis_model, mean_basis_weights, cov_basis_weights, - align_func = align.dtw.fastdtw, + align_func = dtw.fastdtw, iterative_alignment = False, num_align_samples = 100, cyclical = False): diff --git a/intprim/filter/spatiotemporal/ekf.py b/intprim/filter/spatiotemporal/ekf.py index 5610cfc..a3cf055 100644 --- a/intprim/filter/spatiotemporal/ekf.py +++ b/intprim/filter/spatiotemporal/ekf.py @@ -6,7 +6,8 @@ import scipy.linalg import intprim.constants -import nonlinear_system +from intprim.filter.spatiotemporal import nonlinear_system + ## # The ExtendedKalmanFilter class localizes an interaction in time and space via the extended Kalman filter. diff --git a/intprim/filter/spatiotemporal/enkf.py b/intprim/filter/spatiotemporal/enkf.py index af6d506..1bbbb98 100644 --- a/intprim/filter/spatiotemporal/enkf.py +++ b/intprim/filter/spatiotemporal/enkf.py @@ -7,7 +7,8 @@ import scipy.linalg import intprim.constants as constants -import nonlinear_system +from intprim.filter.spatiotemporal import nonlinear_system + ## # The EnsembleKalmanFilter class localizes an interaction in time and space via Monte Carlo approximation of the Kalman filter. diff --git a/intprim/filter/spatiotemporal/pf.py b/intprim/filter/spatiotemporal/pf.py index 43d62d5..0bc12db 100644 --- a/intprim/filter/spatiotemporal/pf.py +++ b/intprim/filter/spatiotemporal/pf.py @@ -11,7 +11,7 @@ import scipy.stats import intprim.constants -import nonlinear_system +from intprim.filter.spatiotemporal import nonlinear_system ## # The ParticleFilter class localizes an interaction in time and space via sequential Monte Carlo sampling. diff --git a/intprim/util/__init__.py b/intprim/util/__init__.py index 8856346..925f4e1 100644 --- a/intprim/util/__init__.py +++ b/intprim/util/__init__.py @@ -1,3 +1,3 @@ -from stat_collector import * -import visualization -from kinematics import * +from intprim.util.stat_collector import * +import intprim.util.visualization +from intprim.util.kinematics import * diff --git a/intprim/util/kinematics.py b/intprim/util/kinematics.py index a8ab0e8..fc3edeb 100644 --- a/intprim/util/kinematics.py +++ b/intprim/util/kinematics.py @@ -42,7 +42,7 @@ def forward_kinematics(self,q): H = self._link_matrices(q) A = H[0] absolute_transforms = [] - for i in xrange(1,len(H)): + for i in range(1,len(H)): A = np.dot(A,H[i]) absolute_transforms.append(A) return absolute_transforms @@ -88,7 +88,7 @@ def end_effector(self, q ,As=None): def __num_jac(self, q, eps = 1e-6): jac = np.zeros((3,len(q))) fx,ori = self.end_effector(q) - for i in xrange(len(q)): + for i in range(len(q)): q[i] += eps fxh,ori = self.end_effector(q) jac[:,i] = (fxh - fx) / eps @@ -108,7 +108,7 @@ def __analytic_jac(self, q, As=None): if As is None: As = self.forward_kinematics(q) pe = As[-1][0:3,3] - for i in xrange(len(q)): + for i in range(len(q)): zprev = As[i][0:3,2] pprev = As[i][0:3,3] jac[0:3,i] = np.cross(zprev, pe - pprev) @@ -154,7 +154,7 @@ def position_and_jac(self, q): def end_eff_trajectory(self, Q): pos = [] orientation = [] - for t in xrange(len(Q)): + for t in range(len(Q)): post, ort = self.end_effector(Q[t]) pos.append(post) orientation.append(ort) @@ -210,5 +210,5 @@ def inv_kin(self, mu_theta, sig_theta, mu_x, sig_x, **kwargs): post_cov = res.hess_inv else: post_cov = None - print res + print(res) return post_mean, post_cov From 6155a2a42ca46c229e01d2c214ebedf6f379a4fe Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Fri, 25 Sep 2020 18:19:36 +0200 Subject: [PATCH 08/14] Added recursive conditioning example and fixed ProMP conditioning instalbility --- intprim/examples/promp_example.py | 37 +++++++++++++++++++- intprim/probabilistic_movement_primitives.py | 12 ++++--- 2 files changed, 44 insertions(+), 5 deletions(-) diff --git a/intprim/examples/promp_example.py b/intprim/examples/promp_example.py index 7cc7276..0bfc189 100644 --- a/intprim/examples/promp_example.py +++ b/intprim/examples/promp_example.py @@ -9,7 +9,7 @@ # Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz -with open('strike_mov.npz','rb') as f: +with open('/home/corobi/playground/intprim_test/strike_mov.npz','rb') as f: data = np.load(f, allow_pickle=True, encoding='bytes') time = data['time'] Q = data['Q'] @@ -75,6 +75,41 @@ plt.title('Joint Space Conditioned Samples for DoF {}'.format(plot_dof)) plt.show() +q_cond = np.random.choice(Q) +q_domain = np.linspace(0, 1, len(q_cond)) +print('len(q_cond):',len(q_cond)) +print('q_cond.shape',q_cond.shape) + +# Condition the ProMP and obtain the posterior distribution. +mu_w_cond_rec, Sigma_w_cond_rec = promp.get_conditioned_weights(q_domain[0], q_cond[0]) +print('det:',np.linalg.det(Sigma_w_cond_rec)) +num_observed = 25 +for i in range(1, num_observed): + mu_w_cond_rec, Sigma_w_cond_rec = promp.get_conditioned_weights(q_domain[i], q_cond[i], mean_w=mu_w_cond_rec, var_w=Sigma_w_cond_rec) +print('det:',np.linalg.det(Sigma_w_cond_rec)) +# Plot samples of the conditioned ProMP drawn from the predicted posterior. +plt.plot(q_domain[:num_observed],q_cond[:num_observed,plot_dof],'bo', alpha=0.3) +plt.plot(q_domain[num_observed:],q_cond[num_observed:,plot_dof],'ro', alpha=0.3) +for i in range(n_samples): + samples, _ = promp.generate_probable_trajectory(domain, mu_w_cond_rec, Sigma_w_cond_rec) + plt.plot(domain, samples[plot_dof,:], 'b--', alpha=0.3) + +mean_margs = np.zeros(samples[plot_dof,:].shape) +upper_bound = np.zeros(samples[plot_dof,:].shape) +lower_bound = np.zeros(samples[plot_dof,:].shape) +std_Q = [] +for i in range(len(domain)): + mu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_cond_rec, Sigma_w_cond_rec) + std_q = Sigma_marg_q[plot_dof][plot_dof] + std_Q.append(std_q) + mean_margs[i] = mu_marg_q[plot_dof] + upper_bound[i] = mu_marg_q[plot_dof] + std_q + lower_bound[i] = mu_marg_q[plot_dof] - std_q +print('mean_std-Q:',np.mean(std_Q)) +plt.fill_between(domain, upper_bound, lower_bound, color = 'b', alpha=0.2) +plt.plot(domain, mean_margs, 'b-') +plt.title('Joint Space Recursively Conditioned Samples for DoF {}'.format(plot_dof)) +plt.show() class BarrettKinematics(BaseKinematicsClass): ''' Forward kinematics object for the Barrett Wam diff --git a/intprim/probabilistic_movement_primitives.py b/intprim/probabilistic_movement_primitives.py index e77e77c..2f32e47 100644 --- a/intprim/probabilistic_movement_primitives.py +++ b/intprim/probabilistic_movement_primitives.py @@ -321,13 +321,17 @@ def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None tmp1 = np.dot(var_w, basis_funcs) tmp2 = np.dot(basis_funcs.T, np.dot(var_w, basis_funcs)) + if var_q is not None: + tmp2 += var_q + else: + tmp2 += np.eye(tmp2.shape[0])*1e-7 tmp2 = np.linalg.inv(tmp2) tmp3 = np.dot(tmp1,tmp2) mean_w = mean_w + np.dot(tmp3, (mean_q - np.dot(basis_funcs.T, mean_w))) - tmp4 = np.eye(lw) - if var_q is not None: - tmp4 -= np.dot(var_q, tmp2) - var_w = var_w - np.dot(tmp3, np.dot(tmp4, tmp1.T)) + # tmp4 = np.eye(lw) + # if var_q is not None: + # tmp4 -= np.dot(var_q, tmp2) + var_w = var_w - np.dot(tmp3, tmp1.T) return mean_w, var_w From 6fe3acec89029118ea0642bc84644d90353a0ecb Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Fri, 16 Oct 2020 11:16:45 +0200 Subject: [PATCH 09/14] Updated examples --- docs/notebooks/5_promp_example.ipynb | 294 ++++++++++++------- intprim/examples/promp_example.py | 15 +- intprim/probabilistic_movement_primitives.py | 19 +- 3 files changed, 198 insertions(+), 130 deletions(-) diff --git a/docs/notebooks/5_promp_example.ipynb b/docs/notebooks/5_promp_example.ipynb index 00a7fc2..ce3587f 100644 --- a/docs/notebooks/5_promp_example.ipynb +++ b/docs/notebooks/5_promp_example.ipynb @@ -1,6 +1,8 @@ { "cells": [ { + "cell_type": "markdown", + "metadata": {}, "source": [ " \n", "# 5. Toy example of a Probabilistic Movement Primitives (ProMPs) and Conditioning\n", @@ -12,11 +14,25 @@ "### Training a ProMP\n", "\n", "First we shall load some sample data and fit a ProMP with the learnt samples." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import intprim\n", "from intprim.probabilistic_movement_primitives import *\n", @@ -26,10 +42,9 @@ "\n", "\n", "# Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz\n", - "with open('strike_mov.npz','rb') as f:\n", - "\tdata = np.load(f, allow_pickle=True, encoding='bytes')\n", - "\ttime = data['time']\n", - "\tQ = data['Q']\n", + "data = np.load('strike_mov.npz',allow_pickle=True,encoding='bytes')\n", + "time = data['time']\n", + "Q = data['Q']\n", "num_joints = Q[0].shape[1]\n", "\n", "# Create a ProMP with Gaussian basis functions.\n", @@ -65,33 +80,34 @@ "plt.plot(domain, mean_margs, 'g-')\n", "plt.title('Samples for DoF {}'.format(plot_dof))\n", "plt.show()" - ], + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### An example of Joint Space Conditioning.\n", + "\n", + "Here, we want to condition the ProMP with to start at from an initial joint configuration given by `q_cond_init`." + ] + }, + { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, + "metadata": {}, "outputs": [ { - "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": "" + "image/png": "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\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "" }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": {} - }, - { - "source": [ - "### An example of Joint Space Conditioning.\n", - "\n", - "Here, we want to condition the ProMP with to start at from an initial joint configuration given by `q_cond_init`." - ], - "cell_type": "markdown", - "metadata": {} - }, - { "source": [ "q_cond_init = [1.54, 0.44, 0.15, 1.65, 0.01, -0.09, -1.23]\n", "t = 0\n", @@ -117,42 +133,94 @@ "plt.plot(domain, mean_margs, 'b-')\n", "plt.title('Joint Space Conditioned Samples for DoF {}'.format(plot_dof))\n", "plt.show()" - ], + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The blue dot in the graph shows the value that the ProMP is conditioned with." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### An example of conditioning a partially observed trajectory." + ] + }, + { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, + "metadata": {}, "outputs": [ { - "output_type": "stream", - "name": "stderr", - "text": "/home/neo/.local/lib/python2.7/site-packages/ipykernel_launcher.py:15: RuntimeWarning: invalid value encountered in double_scalars\n from ipykernel import kernelapp as app\n" - }, - { - "output_type": "display_data", "data": { - "image/png": "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\n", - "text/plain": "" + "image/png": "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\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "" }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": { - "tags": [] - } + "source": [ + "# First, we select a trajecotry to \"observe\".\n", + "q_cond = np.random.choice(Q)\n", + "q_domain = np.linspace(0, 1, len(q_cond))\n", + "\n", + "# Condition the ProMP interatively and obtain the posterior distribution at each step.\n", + "mu_w_cond_rec, Sigma_w_cond_rec = promp.get_conditioned_weights(q_domain[0], q_cond[0])\n", + "num_observed = 25\n", + "for i in range(1, num_observed):\n", + "\tmu_w_cond_rec, Sigma_w_cond_rec = promp.get_conditioned_weights(q_domain[i], q_cond[i], mean_w=mu_w_cond_rec, var_w=Sigma_w_cond_rec)\n", + "# Plot samples of the conditioned ProMP drawn from the predicted posterior.\n", + "plt.plot(q_domain[:num_observed],q_cond[:num_observed,plot_dof],'bo', alpha=0.3)\n", + "plt.plot(q_domain[num_observed:],q_cond[num_observed:,plot_dof],'ro', alpha=0.3)\n", + "for i in range(n_samples):\n", + "\tsamples, _ = promp.generate_probable_trajectory(domain, mu_w_cond_rec, Sigma_w_cond_rec)\n", + "\tplt.plot(domain, samples[plot_dof,:], 'b--', alpha=0.3)\n", + "\n", + "mean_margs = np.zeros(samples[plot_dof,:].shape)\n", + "upper_bound = np.zeros(samples[plot_dof,:].shape)\n", + "lower_bound = np.zeros(samples[plot_dof,:].shape)\n", + "std_Q = []\n", + "for i in range(len(domain)):\n", + "\tmu_marg_q, Sigma_marg_q = promp.get_marginal(domain[i], mu_w_cond_rec, Sigma_w_cond_rec)\n", + "\tstd_q = Sigma_marg_q[plot_dof][plot_dof]\n", + "\tstd_Q.append(std_q)\n", + "\tmean_margs[i] = mu_marg_q[plot_dof]\n", + "\tupper_bound[i] = mu_marg_q[plot_dof] + std_q\n", + "\tlower_bound[i] = mu_marg_q[plot_dof] - std_q\n", + "plt.fill_between(domain, upper_bound, lower_bound, color = 'b', alpha=0.2)\n", + "plt.plot(domain, mean_margs, 'b-')\n", + "plt.title('Joint Space Recursively Conditioned Samples for DoF {}'.format(plot_dof))\n", + "plt.show()" + ] }, { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The red trajectory shows the full observed trajectory. The blue dots in the beginning are the values that the ProMP is conditioned with." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ - "The blue dot in the graph shows the value that the ProMP is conditioned with.\n", - "\n", "### An example of Task Space Conditioning.\n", "\n", "First, we need to define the Kinematics of the robot, which in this case is a Barrett WAM." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], "source": [ "class BarrettKinematics(BaseKinematicsClass):\n", "\t''' Forward kinematics object for the Barrett Wam\n", @@ -200,20 +268,37 @@ "\t\t\t[-(ca*cg*sb) + sa*sg, cg*sa + ca*sb*sg, ca*cb, self.endeff[2]], \\\n", "\t\t\t[0,0,0,1]])\n", "\t\treturn [hi00,hi01,hi12,hi23,hi34,hi45,hi56,hi67,hi78]" - ], - "cell_type": "code", - "execution_count": 3, - "outputs": [], - "metadata": {} + ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "Next we calculate the configuration to reach the 3D point parametrized by `mu_cartesian` and `Sigma_cartesian`." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": "fun: 1.2607255597690448\n hess_inv: array([[ 0.00572446, 0.00044346, -0.00582389, -0.00205088, -0.00312282,\n 0.00545993, 0.00661536],\n [ 0.00044346, 0.0014325 , -0.00066501, -0.00146189, -0.00108719,\n 0.00078602, 0.00159786],\n [-0.00582389, -0.00066501, 0.00683648, 0.00209646, 0.00510573,\n -0.00521655, -0.00925261],\n [-0.00205088, -0.00146189, 0.00209646, 0.00539554, 0.00688907,\n -0.00790783, -0.00856472],\n [-0.00312282, -0.00108719, 0.00510573, 0.00688907, 0.09056763,\n -0.01234715, -0.10080951],\n [ 0.00545993, 0.00078602, -0.00521655, -0.00790783, -0.01234715,\n 0.01772946, 0.01689341],\n [ 0.00661536, 0.00159786, -0.00925261, -0.00856472, -0.10080951,\n 0.01689341, 0.12345578]])\n jac: array([-3.86583891e-06, 8.02217272e-06, -4.46214839e-06, 3.75499468e-06,\n -2.51596661e-07, 1.66831373e-06, -2.80330763e-07])\n message: 'Optimization terminated successfully.'\n nfev: 20\n nit: 14\n njev: 20\n status: 0\n success: True\n x: array([ 1.12820721, 0.59177272, -0.21965488, 1.89876834, -0.14786706,\n -0.0641282 , -1.1013934 ])\n" + }, + { + "data": { + "image/png": "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\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "mu_cartesian = np.array([-0.62, -0.44, -0.34])\n", "Sigma_cartesian = 0.02**2*np.eye(3)\n", @@ -248,40 +333,44 @@ "plt.plot(domain, mean_margs, 'r-')\n", "plt.title('Task Space Conditioned Samples for DoF {}'.format(plot_dof))\n", "plt.show()" - ], + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The red errorbar in the graph shows the posterior of the joint space that the ProMP is conditioned with, obtained using inverse kinematics." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### An example combining both Joint Space and Task Space Conditioning." + ] + }, + { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", - "text": "fun: 1.2607255597690448\n hess_inv: array([[ 0.00572446, 0.00044346, -0.00582389, -0.00205088, -0.00312282,\n 0.00545993, 0.00661536],\n [ 0.00044346, 0.0014325 , -0.00066501, -0.00146189, -0.00108719,\n 0.00078602, 0.00159786],\n [-0.00582389, -0.00066501, 0.00683648, 0.00209646, 0.00510573,\n -0.00521655, -0.00925261],\n [-0.00205088, -0.00146189, 0.00209646, 0.00539554, 0.00688907,\n -0.00790783, -0.00856472],\n [-0.00312282, -0.00108719, 0.00510573, 0.00688907, 0.09056763,\n -0.01234715, -0.10080951],\n [ 0.00545993, 0.00078602, -0.00521655, -0.00790783, -0.01234715,\n 0.01772946, 0.01689341],\n [ 0.00661536, 0.00159786, -0.00925261, -0.00856472, -0.10080951,\n 0.01689341, 0.12345578]])\n jac: array([-3.86583891e-06, 8.02217272e-06, -4.46214839e-06, 3.75499468e-06,\n -2.51596661e-07, 1.66831373e-06, -2.80330763e-07])\n message: 'Optimization terminated successfully.'\n nfev: 20\n nit: 14\n njev: 20\n status: 0\n success: True\n x: array([ 1.12820721, 0.59177272, -0.21965488, 1.89876834, -0.14786706,\n -0.0641282 , -1.1013934 ])\n" + "output_type": "stream", + "text": "fun: 8.523225059594797\n hess_inv: array([[ 1.01800110e-03, -1.20595501e-04, -6.83124829e-04,\n -5.64921023e-04, -9.38689511e-04, 1.59783831e-03,\n 9.30587100e-04],\n [-1.20595501e-04, 1.04708066e-03, 5.92601574e-05,\n -9.64160900e-04, -1.60155857e-04, -1.52791383e-04,\n -4.77393770e-04],\n [-6.83124829e-04, 5.92601574e-05, 9.69966172e-04,\n 7.33882826e-04, 1.17225949e-03, -1.62170575e-03,\n -1.06071838e-03],\n [-5.64921023e-04, -9.64160900e-04, 7.33882826e-04,\n 3.39727882e-03, 2.16358794e-03, -3.74108595e-03,\n -8.43872132e-04],\n [-9.38689511e-04, -1.60155857e-04, 1.17225949e-03,\n 2.16358794e-03, 5.51992232e-03, -3.75680107e-03,\n -5.16995427e-03],\n [ 1.59783831e-03, -1.52791383e-04, -1.62170575e-03,\n -3.74108595e-03, -3.75680107e-03, 8.96353720e-03,\n 2.73836754e-03],\n [ 9.30587100e-04, -4.77393770e-04, -1.06071838e-03,\n -8.43872132e-04, -5.16995427e-03, 2.73836754e-03,\n 7.92560055e-03]])\n jac: array([-1.03046581e-06, -3.67914497e-06, -1.58208651e-07, -3.37715830e-06,\n 1.26679918e-07, -1.03817995e-06, 2.17537332e-08])\n message: 'Optimization terminated successfully.'\n nfev: 20\n nit: 14\n njev: 20\n status: 0\n success: True\n x: array([ 1.09107017, 0.57642739, -0.17798423, 1.89303316, -0.1432739 ,\n -0.14481857, -1.21240792])\n" }, { - "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzsvWeYJNd5HvqeDtM9eaYn7uTZ2TAbsBm7ABYECIKQSIhJIiXZl/IlJQbxUbSCZVGXEiXrWubV1WNbNi3rUqQoUZYVKEoMIiiCJEgCIAhswgKLXSw2Tg47OXbuc3+8/fGr7p3QkwPqfZ56pqeruurUqVPv+c4XjbUWLly4cOFie8Gz0Q1w4cKFCxerD5fcXbhw4WIbwiV3Fy5cuNiGcMndhQsXLrYhXHJ34cKFi20Il9xduHDhYhvCJfd1gjHmb40xH9vodmxFGGMGjDEPpj//njHmkwsc+wFjzFfWr3U/uO4njDGfXu/rLhXOvlzFcx40xrxsjJk2xnx4Nc/tYvlwyT0L6QEqW8oYE3b8/951asNhY8y3jDFj6e2sMebN63HtXGGMaTDG/KUxZtAYM2mMuWKM+W1jTHAtr2ut/bi19hfSbWg3xiSy9n/GWvv2tWzDUmGIjxtjOtLjqNsY87mNbtcq4qMAvmqtLbLWfmqlJ0tPlHFjzFR6u2qM+WNjTHWOvw8aY6wxZsbx7g7Mc+wPG2NeMcaMG2OGjTGfN8bUrPQeNgNccs9CeoAWWWuLAHQBeLvju79e6+sbYzwAvgrgSwCqAdQC+DUAM2t97VyRfsmeB2AB3GutLQHwOIAdAJo3sm2bFB8G8G4Aj6TH1SkAT29sk1YVzQAuL+eHxhjfPLv+0lpbDKACwI8DaAFwzhhTtYTT73W8u7XzHPMSgMestWUAGgD0AfjvS7jGpoVL7kuEMea0MeYFY8yEMabPGPNfZIAaY7zGmE8aY4bS+18yxuyd4xylxphnjTH/7xyXqANQD+DPrLVxa23UWvu0tfb76d++xRhzI62eGDXG3DLG/Ljj3D+avu6kMabTGPNbWdd+ozHm+XT7uowx/0f6+3xjzH9NS5UDxpj/bowJzNMNvwFgAMBPW2u7AMBa22Gt/Tlr7Wvp8z1sjLmQvs7zxph7HW14Pi3JPp9u5xPGmHLH/g+k2zZkjPl3We13qj+eBuB1SGdHjTEfMcZ803H8StrxhvSzHk+f47Rj3y5jzPfSkuXXAPzgd3PgXgBPWGtvp/uqz1r7AxWOMeZn09LpVPrZ/oxjnzzvj6Uly15jzOPGmHcaY24aY0aMMb+W1T9/Y4z5Qvp8Z40xB+ZqVHq8/nZ6DA0bY/7aGFOW3ldoqEocTd//C86+cZzjOQD3A/h0+hk0GWNCxpj/nX5+t40xv2GMMenjP2KMecoY8z+MMWMAfnOBfoO1NmatvQTgPaCA88uOa/+8ow/+0SxD4rbWDlhr+x1fJQHsWup5NiWste42zwagA8Cbs747Cb6sXgBtAG4A+Eh63zsBfB9ACThxHgBQnd73twA+BkrjLwL42DzX9KWv+0/p81Vn7X8LgASA/wQgD8CbAcwCaE3vfzR9XQ+AYwBGAbwlvW8XgGlQivQBqAJwOL3vTwH8A4AyAKUAvg7g4/O08SKAjy7Qb9UAJgH8RPo67wcwBKA0vf95AK+l+68QwHMAfje97wiAKZAwAgD+R/p+H0zv/wSAT6c/twNIZF37IwC+uQrtaAEwku5fD7gyGQJQnt5/wfEMHk0/g0/P0x8fTP/2V9PPxJu1/x0AWgGY9PXCAA44nnccwL9P38MvghPrX6XbfBRABEC9o39i6XP6wTH3mlwz/Vvpy98E8AwoUAQB/AWAz6b3/XJ6POSnr3svgMJ57u95AD/l+P/vAXweQBE45m4DeK/j+SQAfAh8h/LnON8PnnHW938I4Lvpz4+n7+VQuu2fAvCN9L4guKpsyPE93w1gHEAKQBTAv95o7lmNbcMbsJk3zEHucxzzmwD+Jv35cXB5ehKAyTrubwH8fwBeBfBLi5yzGSTb26Ak8S0oeb8l/TIHHcd/GcC/m+dcfwrgP6U//560NesYX5oQ6h3fPQLg1XnO2Q3g/Qu0/0MAns767kUA/yr9+XkAv+7Y96sAvpj+/AcA/sKxrzT90i2H3FfSjo+Dqyfnb78L4CcB7JnjGfzjXISU3mcAvA/At8FJYBjAryzQf/8C4Gcdz3sCgCf9f1WauA47jr8MncA/AeA7Wc92BFSfAZnkfhvAacexren2GQA/l77fgzm8Jz8gd3BCTgLY6dj/ywD+xfF8ri1yvvnI/d8CuJT+/NcA/oNjX1l6nNRCyX0CJO1xAH+Yw31UgvaD44sduxU2Vy2zRBhj9htjvmbShkQAvwMOCgD4GoDPgCQ+aIz5E2NMkePn70r//cxC17DWdlprP2KtbQWwM/31nzsOGbLWRhz/d4LSl6iNvpteEk+A0qq0rxHAzTkuWQdKeZfTS/BxAF8EJd+5MALq1+dDXbpNTnSC6iaB08A1C0p58ttu2WGtnQBf0uVgJe1oBvBT0h/pPjmRPmcd5n4Gc8ISf2mtfQQkoV8C8IfGmIcBwBjzDmPMGVGBAHgT9Jkhfa1U+nM4/XfQsT/saDeQ2X8JUI9c52xTWk3SCOAJx/29CK5SKsAx+l0A/2CM6THG/IExxjvfPTpQmz5Hl+O77D7vxvJQD65Egaxna60dB1dpzuscsNaWpbffWOzk1tphAH8D4EuiRtrKcMl96fgzcEneZmlI/A+gpCMv8X+21h4Fl4uH4dARAvgkuPT/ijEmP5eLWWs7AfxPAAcdX1eaTK+UJvAFBrgk/jsAjdbaUnCpLQO1G1RBZKMfXCq3OV6GUmttxTzN+iaAH1ug2X2427DaBKB3gd8429Io/xhjSkHpfS4sltJ0Je3oBqXHMsdWaK39L+k2zvUMFoWlDvl/g6qSg8aYQlCF8fugCq4MwFPQZ7YcOPvPCxJhn/MAS1G1F8Cbsu4xaK0dtrT1/I61th3AQ6BR81/lcO0BUIJ29kd2ny85Fa2hXettoBoJyHq26XFSgtye7ULwgf1VsMLzbDhccl86igFMWGun04aqD8kOY8x9xpgT6YE4A6o6ko7f2vTxvQC+aOYwWBpjaowxv2OM2WmIalD6ft5xmB/Abxtj8owxbwLwGIAvpKWNIgAj1tqIMeYB8KUUfA7A2wyNrl5jTJUx5pC1Ng6uDP7YGFOZvm6jMeaxefrgDwHsMMZ8xhjTmG53o6ERdi+oJjpqjHmPMcZnjPk/wRf8X3Lo378H8GPGmFPp/vm/QbKYC3dAg+p8xLqSdvwlgB83xjya7qv89OdaANcAXIU+g0dA9cmcMMZ80NAwWmSM8Rhj3gHqos+AOm1/+l5S6X1vzKF9C+EBY8zbjDF+0Pg9Agok2fhTAJ9wPMNqY8zb05/fnF6lekCJOIHMsTwnrLVR0F70B2mjbBso4Pyv5dyIMcaffs/+Hnz3/lt6198A+JChj30QwP8D4Clr7Zwujwuc/z2GxnGTNsj+EYDnrbWbxjttuXDJfen4FQAfNMZMg8a+v3PsKwMl5XEAt8Bl439z/ji9vH5/+pgvGGPyss4fAQ083wENiy8BGAONcoIO8GUbAEn5p621t9LS2EcA/JExZgp8sT/vuPZN0Ej7W+lzngONrwD1mX3p7yZAApzTa8Baewc0ePoBnE9f6+vp9nRaawdBg97/BRLLLwB4W3rpvCCstS+Crp//AKAHXN4Pz3PsGDjRnE+rFo5k7V9JO26BhuffS1+/EyQpT7qffxK0S4yC/bwQeU2BOvwesN9/H8AHrLVn06qAXwfwlXQb3wXgicXatwi+AOBn0td6N4B3W2vnIuY/BFdhT6Wf4XOgwRegeuNL6ba/km7T3+d4/Z9N/+0EVyGfBnXkS8H70m0aByeLXtBucAcArLX/DBq0vwyO21oA/2aJ1wAo/X8TdDS4CAplP7GM82w6mLQhwcUWgTHmLQA+aa3dHu5aLlYVxphPAKi01n5w0YNdbGu4krsLFy5cbEO45O7ChQsX2xCuWsaFCxcutiFcyd2FCxcutiHmS9qz5qisrLQtLS0bdXkXLly42JI4f/78sLV20QRqG0buLS0tOHfu3EZd3oULFy62JIwx80ZDO+GqZVy4cOFiG8IldxcuXLjYhnDJ3YULFy62IVxyd+HChYttCJfcXbhw4WIbwiV3Fy5cuNiGcMndhQsXLrYhNszP3YULFy5WBdYCqXTKf2+6WNTUFL9LJvk3lQKCQaCkhMd3d+vv5G95OVBRwd/cuHH3dSoruT+RADo7AY+Hm9fLraQEKCzkuSIRwO8HfD5gg4o6ueTuwoWLtYO1JMtkkp+D6eJVo6NALKb7EgkgEADq01Xyrl4FwmF+LwRdVgbs38/93/kOCVT2AUBDA3D0KD8//bR+L2huBg4d4ueXXrq7rW1tJO9UCrh27e79Hg/3x+PAlSt37z94EGhtBWZm2D6AxJ6Xx629Hait5fk9a680ccndhQsXdyORIPkmEtzicZJzbS339/QAExO6P5GgpHosXevj7FlgaIjkKygtBR56iJ9feYW/dyIUUnIfGSF5i1Qsm6CmhueW7z0eSs6C48f5V/Z5PDqxGAO8+c386/Fk/gV4H29/+/x9EwwCb32rrghkggoEdP+RI+yzWIxbNMrzAuzHdYBL7i5cbEckkySUeDxza2wkifX2AoOD/E7IO5kEHn2Uv790iQTuhN8PvCVdTXBwELhzh2oH5yaorAQKCvR7r1fJFSD5Wav7ssn79OmF72/fvoX3yyQ0H/JzKmE8N4zJvNds+P3s5/ngzaXO+MrhkrsLF5sVqZRKf/K3spLEMjIC9PVl7o/HSYqBAHDzJvDaa3efc8cOks/sLDA+znP5/UBRET9bS/JqbKQKQvTGcpxAJOP50Nq68H6nlO1iTeCSuwsXa41kUkk4P1/Jtb9fl+1CzgcOkPh6e4ELc9S0fughqjdmZkjufr9uhYW65K+p0Ws5N5E4d+/mNh8qK1e/H1ysK1xyd+EiV1jLzeOhKmN4OFOqjsVo1KuooD75zBl+5zTsHT8O1NWRnK9c4bmEePPy9NiSEhrgnPvy8ihhA0BTE7f5UFrKzcXrFi65u3j9wlrqpcXgFY1S+i0vJ2G/+KKStpD4vn3Arl089uxZPZeQdEUF/8/LA6qr7ybn8nLur6igUW4+3W1xMTcXLpYJl9xdbF9MTNCdLhLRrawMaGkhsX/1q3d7LrS2koC9Xv42EKBh0O/n51CIx+XnU0WSl5ep7hDk5wOHD8/fNvHgcOFijeCSu4uti4kJYHqa+mvZioqAe+7h/hdeoIQN0EgYCJCM5f/2dpJyIJC5ASTehx+e/9oej6v2cLGp4ZK7i80La6mbnpoiiU9Pk1RFIn75ZXp8AJkStuD4cZJ3MEhSz44U3LVrfe7DhYsNgEvuLjYHYjFK4jMzVJsAwLlzwMCAHpOfT7WK4NAhkn1Bwdy+w6L/duHidQiX3F1sHO7cAbq6KH2Hw/p9QwMl7pYW+mUXF9PQma3XdtUiLlzMC5fcXaw9wmHmEhkZAcbGgBMnSNbhMDA5SSOluO6VlCiJVy1a4N2FCxfzwCV3F2uH8XHg/HkaOgGSdnm55htpbubmwoWLVYdL7i5WjmSSUvnQELemJmDnTurIS0v5ORSiVL5B6U9duHi9wSV3F8uHtZr9T9KYVlRoUqZAgCoYFy5crDtccneROyYnNR/KPfdQCvf7qVqpqaF0vk4Z71y4cLEwXHJ3sTCmppj6tb+fbooApXPJHijFEVy4cLGp4JK7i7sxNaW+44ODTB9bWclKNbW1GsXpwoWLTQuX3F0Q4TDTzPb2Uv1y7Bir4jQ300AqYfsuXLjYEliU3I0xjQA+B6AWQArAp6y1f5x1jAHwxwAeBzAL4P3W2jmSUbvYdEgkaBQdHub/oRBrQYqPuTOc34ULF1sGuUjuCQC/Zq29YIwpBnDeGPMNa62zQuxbAexOb6cA/M/0XxebESMj9D1vbNQyZ3v3MjK0oGCjW+fChYtVwKLkbq3tB9Cf/jxljHkVQD0AJ7m/E8DnrLUWwPPGmDJjzI70b11sBkQiQHc3t5kZJtNqaKBR9OTJjW6dCxcuVhlL0rkbY1oAHAXwQtauegDdjv970t9lkLsx5sMAPgwATQtVkXGxuujsZMFja+npsmcPc7a4AUUuXGxb5EzuxpgiAF8A8G+ttZPZu+f4ib3rC2s/BeBTAHDixIm79rtYJYTDTMhVU8MsiqEQPV2ampjTxYULF4sjmdS4jb4+rn6l1m0sxveqpYUBfF/5CvdHo7RjpVK0Xd13H1Wgf/VXDPLz+Vih60d+ZM2bnxO5G2P8ILH/tbX2H+c4pAdAo+P/BgB9K2+ei5xhLSNFOzqYbdFaDqSyMmZV3Ldvo1vowsXmgbUkYXEYuHmTLsCzs1q9q7oauPdeHvud79CLLBol6ScSJO+WFv5/8ybPIxW2vF6thysr5Hic518nJ4VcvGUMgM8AeNVa+5/nOezLAH7BGPO3oCF1wtW3rzOefZaJugIBFqFoanKNoy5cCAYGmJl0Zka3khLgDW/g/t5e7rdWyVtWucbQRhUMstJXYSHfrdpa7vf7gZ/5Ga30lR2lnZ8P/OzPrt+9ppGL5H4awL8BcMkYczH93W8BaAIAa+2fAngCdIO8AbpC/vTqN9VFBoaHGTV68CAHX3MzSb2mxq3N6eL1h1iMkvXUlG7xOPDGN3J/Tw8D8goLSbZC1oJEQkk5L48kvmOH7v/hH+bx86XXcBaR2STIxVvmWcytU3ceYwH8/Go1ysU8iMXo7dLZScnD72fGxcJCSurbGakUX8Bkkp+TSb6kfj9f4qkpXf7K0jg/n6opSZXgYusjmeSzFiLft4/P+to14PZtHuP3UxUZCumzr68nOY+PUzBKpTLJfc8eHldayvcpe7yspq1qZmZdbF9uhOpWwcQEVS+pFAeteLxsh0Rd8TjtBJGIbrEYJ66aGhb4ePbZu393/DhQV8e++f73795/8iR/PzjIQC2fjy++30/p7MABLs1nZrgkF2lOJgUXG4t4nOPb4+EzfPVV1tG1aV8Mr5c678JCrlxra0nqsRifp6hZjOHnri6Sd2srJW2ntN3QkFubnEKGGE6TyUyhY2RES0aKDv/LXwb+7u/mP+/HPw787u8ut6fmhDuCNyvicS4lPR4O3JISkl1DAwfwVoK1HOyyXJ6Z4Uva3Mx7iseBC+mAZq+XBBsI6EtcUAC0t2vAlWzycpaU0CtBjk+luEkZvqIiTobi6SDeDqK+Ghqiq6gTfj/1sYWFnFzGx/lZ9K3uSmB1kUqxj53bzAyfa1UVn73ouaVil/M5JJNc0Y6M0OgJcByFw3xme/aolD/XtWOxzPERjaphVbxgxJgKqHFUyBvgWAaAy5fZdq+X4zgQAN76VuBDH+L+X/oltu38+bXrT7jkvvkwOspB2tfHQVdbSxI0Zmt4vMRifDEnJigBNzSQdJ99ln89Hr5sRUWa9z0/H3jkEQ74uSTmQADYvXv+a+blLVySr6iIEbjzoamJv5cXWjZJkDY4CFy/rscbw3t4wxvY3slJvvTFxa7EnyumpzlpFhWxOtf0NPC973FfMMiJu7FRnQIqKrTgeTRK1cr163x2oRCl6NFRPkc5trCQ75CsBGMx/lZIeWZG92XDGD5Ln4/PNhpl8jxRATkLt4saSMbgvfcqsc8lBKxTniZ3JG4mvPIK9YY+HwdtU9PWKQJ96RIlYEkLDJDYGxr4Qpw6xRd1LqnXGL7kGwWZcObTg7a3c/kvhDA9TVIQIr9xg94WACeq4mI+t/Z2fufq/NkHN2+quiQe5/c7d5Lci4tJiuXlc2cdTSTYz3fuUHAASKoVFRxTfj9w5Agn5ZkZTsjT0yrFC5yk7fNx3GWrNmdn2cbJSW5C/vffz7ESCvGaMmacZB2JcDKIRCjkJBI8NhTiRHPliq4m1hguuW8UUikOwO5uYP9+DrL6epJCXd3m1KVbywE7MsItkQBOn+Y+kVybmih1lZZm+vNu9WLXoo8Phe7e197OZ5btqSF4/nmSTEkJN1ErbNfUyamUFkT3eLjqMoYxGF4vbUXl5dxkUjdGXQsBtcMA9DePRChA+P1qF7GWKhCZPGVlKDaVggL280IQ/fzkpBpdJyeBW7d0BVFUxLHt9fKeRNqXyaO4WFUy58+r6kYghWw8Hr4z6wSX3Ncb4+PUpff2coAEg5QUZHlaXr7RLZwbN25wGSyDs6iIy1R5sY4c2dj2bSRkReIkJyeqqlRiFQm/upqrGYB9K0Q0l6fGVkFXl/qLp1K8j+pq3f/II/MLLfE4342uLgo8vb0a8CMroMJC/t7nUxJfjv0pEqHqc3JS9eUeD9890bFXV3OsT0/zrxhcb99muzweTs5+f6YqbvduvhOympicZF/09PBvWdm6CW4uua8HEgkOgERC9Yq1tdQpVlVtrpc5Hqc+884dbqdP6xK0vp6EXlGxfaXOtcCuXfo5HucL7zQEvvaaRjP6fCT5lhb2N6D1aTcTIhGOj5ERTuzGqAqjpYXjJBTKXL0ZQ2KMREiqU1M8hxgxr1/n+QoKKO1KYfWV2DFEPTI+TmKtqGA7b9xQ1UxBASdaj4erg7ExnTyEvMfH+be1NdNTprubXjwvvaSOAPn5auy/fJltANTNMh7PdMNcI7jkvlaYmaFRtK+PA0WMb6dO3a2y2AyYnNSBbS3bV1mppLNjR2ZQh4vlQfTEAq+XnhTiuz0xwU2W9jMzwLe/rXp8UemUlq6/8XZmhmQ2OMi2AuqRUlBA11JjSF5CqjMzamAXKTkSoXQ/McHJ4NQpkqGsWsTQvhK89hqD/MbGOKHU1LCvJydpDJ2d1RQds7PAxYtabSwWA15+mSoXKV4Tj7ONch55Pr29PC4vj5J/UxPvQVZo5eX83+PhuXfsAD73uZXfXw5wyX210dtLqUAGf3k59bGivqis3Nj2ASTskREO8lCIEmIgwAG7axeXpDIoXaw9PB4l7sbGzH1eL0lhYoJSbnc6+eqJEySKqSmSmBD+ahCjIJWikVxC7mdnObZDIXpuiWQ+Pc2xJCQuRkxrM90BjSHpTk9zf0kJ3weRYpeSLkM8WMJh9svoqPZVZyfwrW+RpPPy2Ce1tZS2ZbVsLdskapieHt6rGPxbWnhvhYVsb2GhPiPR50uw3FyrKudzjEY5ySUSmerYNYZL7itBIqEqjD17+MCSSUoDBw7w5VvNl22l6O0lEQwNabi1qFcCAeChhza2fS7uRjCY6QIbiVBwkGX/+DgJU+D3kzSPHuXYi8fVQyQXJJOUzPv7Oa4TCRJmczMJce9ekl13N9UoIgDIWHIaMRMJChHWcoIQCXbnzkxSnwvWKvGKv7nHQ8l4ZgZ48kmSuEj/NTUkZHkPT5/m39JS/o3H2Z6eHrb/5Em2uaODE1NlJdtnDMnb42FfVFUxWA7guy6eOkND/Ovz8ZjhYfbb1JQGOR06xBXX9DQNtAKX3DcpolEOquFhLvlSKT7gHTv4wMSFcaMgbljRqHq2lJfzhbp9my+lGHYKCqg26ulhDg6Ph65aHR0aEARwwD/+OD9fuqSqJtkCAeCBB7j/1i2Sj+gzxbtB9MeyNJ8rwZKLxZGdE6WxkWNP3PZkc2Y7vH5dSbe4mFtd3d0rM2uBr32NBGWtpnfo7KShE9DnvZAnyvg4iW5oiGOtooLk6fPdbXhPJtV9MRZTiffyZUrjiQT3WcsxU1JCl+GpKf5/zz00du7bx3aNjrKNNTW8P4l89vn4LoyP83djY7paPX2a38n7AWRGt1ZW8jzXr3PSk4mipUX7VNRVMzM69l97jRL/sWM8TjJPrhNccl8IEpAzNsaHs2MHH/i1a/y/tZUqDHFzWg+Ewxyk2dFzx4/zZXzpJeCFF9ju2VkOzmPH+ALcey9JtrtbvQ4kvFsgrn7OF9/5WfZLFKh4RQhmZjjxJRLqDijGWIC6TanX6vWqrlKko44O/laW8oGAGqpczA2fj89lLjdNp655cpIEJMJIVxdT2fb308tDAoHKyvhMpN/z8nJX0V29SiL0evlu1NRorIY4FgC8Zm8vx7EIEh4P2yWuiX19/JxM8jzBIN89gOpDr5fjPxTisZ2dml+mro4SdSpFYauyku+JU/CQdwDQfDOlpfpO7d5NdY7YGkpKtB3BIM8v4/KBB3jf0WhmCo1QSKOte3p0ElsHGOuU0NYRJ06csOfOnVvej51J9FcL8bhKOy++yEE1O8v/jaHku3//3ceuNiIRNfhIpOTsLHWsoRBfCAnVF3/eYBA4fJgv7rlzPL6qSoOINsL4JpAlqrwEw8Nsn0QMxmLcJ6qH735X7RWCqiqGoQP0GZekT0I8ZWXqRx+J6LLaBZFK6Tjq7aWxUAyBIukKUXm9lMpPnOBve3r4Nxjk98Gg9q3EPQwMkGz9fg1Qqqjgs3CmnQiHNXqzu5u/E7fBUIjkeeUKvU/E6JqfT+HkwAHex6uvcswI0QIk9eJizfZYXs4x4XxHrdU+mJnh57Iyknc0SoEIUB19QQH7RIKcrGWbnakIolFORm1tbJvkP3J62tTVqb6/q4v7fvu3eY1lph8wxpy31p5Y7LitKblfvcqOdnoPiDfBfHBOCP39HHSzs9SHTU/zQYtqIR7nuZqbNcGQkxyXQ+zizhaLqQ+vDLZwmKl76+v5/6VLmtVQ3MLkmtXVwIMPsv3Dw1z67t9P6bi2llF0NTXrFuK8KERKEixmUH74Yb4IEioejWb+PhBgH42Pa9UbMZIBNKSJqkzIv6GBS2hrqTbKy8vcAoHtkzYgldLw+vHxzARaXi9Xof39JKXaWpKqFJaIRFSgEYig4UQoxHeiv5/kHwxqzp3iYo7dzk4SdSzGY3fs4N8XXlA3yOlpfi4uJomWlfH4Bx/k/yL5Dg7qOyPCTH09V84A31PneI9GeX6Ph+e0FnjuuczgIsnNDvD5HznC34iRdmKC1w2F+H4Zw/uV42XciBE4HCZneDzsS8lHFAxyjI6Nsa/EFXIdbHFbc0T7/RyQvb2cyZNJfvf+93P/N7/JB+P1qpGksFBLW3V1kRTz8zWjnHMry60OAAAgAElEQVRiyLVgtCQcisV4/fx8tuXaNT5sZ/KhPXso3SQS1Bl6PBr8IvpvgJ8fe2zuvBTxOF+OsTH+L4NcBoqcb6vD6X+cjaNHM/+XbHwAX+J77mG/OycHWZ3G4yScbOzdy+cTiTAOQaQu2RoaKInG4yQ7Z/i6z7dxWSSdEvnYmLoXiqosHFYPltZWJfOWlrsnf+d4dOLECY5Z8U+fnKRwJeHzAwP8bVcXjwuHeX5JtysrM0Bdafv71d3WKZiVlfFY0bNL8FJvL8e6qHiKinhN0Ynn5XEyEVWkqAPlnFLvwJlYTvLTjI9TsCopoSfQ7CyvJZNISQnbMzGhEbCTkyTqeJx9evOmTqgS7CSqT1mZRKNsy40bqnpsaQH+438E3vve1RsTDmxNche9ViDAl86ZrQ3gg+hLV/mTFzT79wUFfIDWUoJwDvZLl/jgUinuF6OQBKN84xvc77xma6sWzpDQZbHW19aqd0N+PvBDPzS/DtnjUeu+eOL4/ZQeRA2zdy8l+E1YIGDdIRkiAfb9QsbsvDzgLW/RDIAyMTsNg+XlGlQTifAlDIX4/GdmaDPIxrFjnGRHRqg2ctozxHMqFOK4vH07c7/Xy6V7fr6Sp/O3To+mSET9xkdH+VfGqAgXFRUc+/39JBuvN3P8OfsrFyQS6jXT2Kj+25EISSqVIjmLl8rQENuQn8/2XbyoGTfr6/m748f5vty+zXfF72ffDA3xngsLM1d4Bw9quP/4ONsgOYxEfSRGV7m2kH9HB0m0oYFG2pERHi/9JYKRqFqLizlBXb/OtpaWsi2SR37PHk4y0aimJ5D8MuKOai0nJq9XVwORCO0bn/2sRnl3dgIf/jA/rwHBb02duyzHPR6+0DJgs/WsIkmEw9wnA+bKFQ580QcnkxwUBw5w/zPPqAuZeIRUV2tmQZG8hWylcstqpOLt7KRU4Awmqq+nROpiYyGqi0QicysvJ0nMzKgEK1GMySTHTVkZyevixcz83wC9NUIhSnsyecjkEg7TsBeNkrC7uzkmCgrUm2X3bpVGp6YoHQKcNGpqSDq5GkTHxki0k5Mk0b4+Emt1NSeJsTFer6CA9yuRqOGwvg/Dw3zHhEBFDSNGxj17SOJ1dRpsNDGhqp29e/k+3bnDawQCeozPx3uSKOnKSk0DMDLCd0cClAC+p/ffT34QQ20qxXMPDam9QXzd9+1jm3t6VHgsKVHV03zqFLlHCXiqrmY7zp9X98jPfW5ub5nmZk5COSJXnfvWJPftAGs5EEZG+MIcO8YX8NIlSidVVSqdu8bB7Qmp12mtZiLs6VGjs0jlDQ0kOwnXl4IRkvRKPDxqaqgmyU5X8MADJEXx6RYVkqxcamspaU5PU3AZHNTIzkSCY7GxkURXVaWRyzJ+JZlWayuPEzUOwMlKVsGiJhUvqb172XZjeE1xFZTVdjSqLo2SByaR4HWM4UR37RpX1IGAVmc6dIhtFJfM/Hye68YNvlMFBfw+Huf9SL1hqd7kRCqlq4rhYfa3uEGPj3PyGxnJdICQSTtXGLOk32xvg+pWxsgIB9nYWKarYCTCQSiqHRfbE0LkUv1pZET9yqUQc13d3Dp8Me5LpGN/v6oTRae+c+fdKwsh+qIiksitWyQhmVhKSkh+ly9zApDkVuXlPP/DD/OzpHSOxTgJANxfWam512/fJjGLDau1leP7pZd4fyJlp1IUZA4f1qjP4mLq5SXfv9fLCaeoiP0iK4KBAXWhve8+NQpLjdTZWdpObt0iMdfVqZrGWqpy8vLYf9ev0243Oak5aKJR3uvAgLr1ZiMQ4PUlcrWlhf+HQplFXcSrKxgEfuu3+MyzsUZxMa7kvhawVnWj4ie/fz8ln6EhvhihkCbhWodoNRcbhFiMY0G8m8Rv2xhVW+Tqwy8SeTTKsoFlZSSu7FQRqZTqp0XFcvQoyUYkUAlm8npJblevsq319XTtk+jWeJzkPzysqQcA/i9FUnbvpgR74QKvCaih9L77eM6hIV4H4LklpUF1tY7/ZJLHjY+zzZJwSyqQxeMac+LxkJz7+vj/1BQl+YoKtlEmrqoqkvPAAFVmkmZAPH2y1SSi9qmpYX/J6kqS51VWcrLbu1dVMKKOEtue3I84U0hbvvlN4JOfzMwxX1AAfOpTS9K5u2qZ9YKkBZU8FDMzwNNP62wv5eD27NkceWVcrB3EDXFmhhL50JAGkklCLDH2LQXiRgeo7UXypjiv7fGQzC9d0mW+eGM5vaoAktKtWzpWq6u5amxp4WQzPEziFC+RYJDjt6VF1TnT0+r50d2tnkiSGbGwkDrsRx4hwT3/vO7Ly+PvrOV5q6t5zjNnSLAy+chEALBNIyPqtdTZyfPu3Mnzjo2x76W/pKKZU/IWXX99PScCMZiKp04yycli714+u2vX1KlBVhzvfCff6298Q+0bgvx89do7e5ZtdrraXrjAWqrxOHXty/CWcdUyqwmZvX0+fr5yRf3jRbe4cycNslJaTpbQklPDxfZDPE4ymZwkkY+MqAeVkNhyK0xJ0i6JaszLy0xA5/Fwv7hASsCaxDvMVTAFUF26tSSttjYScHk5iUg8acSdtLGRknB+Pgn14kVNYSEFLmpreV2ZACTuIBLhsZcva43UwUEtWiF+7jt38jyXL/P79nZOSq++SrVJfr7mqZme5rHhMCenvj7g859XKR9gXzU26iqkslK30lIGUhUWUrV186amDgC0mIhI45WVqvfPThJ29ChVKpKOQOryyjOSSNR4XKt9vfOd6pDh1lBdB4hboyynbt3SiDoxlNTW0oXLGA5yv19TfDoDqDwe17NluyISIbmMjpJYZUkvUnl5+eoZv/v7STwFBVz1VVcrcYjRXVLWiu4X4P/O/PEAx3d3NyOvEwmS1/33c7zfuEGSkTqw9fXcLzVuz5zh2J+dZYzFnTv8XkLzw2HVI0ttgmCQ70Q8zn6SSaKhgdcvLuZnKWZRWKj6cCHwV19le2XlI8Zkp/ux1Fk9fpztLiriykIMpELGTk+6qSk1Kjc383eXLmmxHFH5AOrGPB9kwpgPJ07oSk7+Oit0rTG2J7k7g4tEAgE0v8mVKxyQzorm5eWMjAMoLYmBs7RUy4IJHn10fe/HxfpDwtWnp0lQkoAKUF35apYOjEYphRYXq7Qoro6i796zR4N2Ghs5JkViFM+VRIJkKQm4vv51SoqSErexkUbMRIIqgldeUduP6K2npnhun4/74nGeOxik1HvoEMm9sJDtdhLo9DSl4DNn9B0qK6PA4/Xyr3MC7Ovjsbdv8x47O9lWZ/6VujpK9w8+yEmhtpaTnc/HvxUVvO6FC7ym5J8BqF6RpGCXL+vzk2LXVVVsk+RCWs3CKJIbaYOqq21Nchc3JGeOB2u1bNn585nVyYHMzISSikCK8YoPq+ANb3BVKa83CJmLhDg0xHElZJpLPc7lYHaWwoS4ONbUaMCM6L2jUY7T8XESUHGxxlycPauZNiULpzGaSmBmhmN9716Oc0lBMDzM3x06BLzpTSS0O3dIqkVFPEYCdQCSud9PMhXVjagrh4bYbp+P17tzh4Te0KAxANbynbx6lSR7+TJ93CWFLsD7am1lhtJdu7jt3Jlb1HVREck/FuN9Dw1pUJHEjcgKJxBgX9++rZ44Y2Nq8HXmhtmzh8dMT7OtzpQVS81hJPbNdbJzbk1y7+mhIUdePCFoQVMTB2F2/hDBYmoTl9hfH5idzSTzWEyNh+LitpqwVleSJSVU/734oqaJrahQf++SEpKRBOs4E6U5BZGDB5WMEglKvyIBx+P83N5Osp2Z0ULmhYUkLmfN1ooKSr3PPMOJpK2Nx7S06PWSSTVsjo2phF1QwPbV1PDdE7fFV1/l36tX1ZPGGErMLS3cjh/nikByqi8HkYi2a3KSfV1Xx35raeEkkU3E4rUEaJStrITEU0gMoePjmpM9lVI9+8mT+twkJ5Qz22pTk9oIzp7l72dm1kZQyMLWJPe9e7mJlJINyRbnwoUTkvJ1eJhSpLikBQKrS+ZOTxapRStpYCcnKQk+9JASh5BOZSUJye+/O1ldNsQzR6oEiSvi+fM8h+RlaWvju9LQoFWGsmEt++TZZ7Wq0wMP0NCal6fufIWFJLQrV1TXHwrxmOvXgS99SaVyCfP3eHhMWxtJtrmZwtWuXStPniWGy/FxZroEeI+NjexLMWbP14/ONAzBYKZ+PR7XIC6AqtmBAbXFCfmPjpLcZ2c5oYqKSjaxf4i/vhTOXgdsTXLfLBkPXWxuiHpjdJSkJYWpxW11NaQnSdolRjMhhPvv1yhLSRM7MUFCKC8nEU9PaxSyRH4uROhSKEa8tCSCNRajimN0lBLoyZOac2UhtUE4zFVwdTXJubKSHl+7dmkN4JERfg6FuErw+/n5xg3gqadIqrdvq6qhsZExHY2NvK/ZWRLjkSMk9pUmWJue5kQ0PKyumVJbobJy6ROGM8f8jRvat0LqlZW8H0mFXFKSWWdArtfaCnzgA3wW4t8ei6ldZmhIPezcrJAuXCwDEjAk0YViX5GAmeVCjKuytbXxZZ+cpBpF8r1UV/PFFQnZ51M3QI+HQT3V1VR/VFdnFnwANABuelrzoEv4v9dLsi0oUF/w27dJ0Nby3EeOqNfKfJiaonR96xbPW1xMI6u0Wwyw4gUUDjNl7p/9GVUPkm+/tJSE/8Y3UuqVBFsDA9TRV1VRql2uO6gTXV1cAYnrcWmp6uI9nrtrz84FSU8gE/H0NAn6wAFNkCZl88STxxhOfBKIJMGHkQj7SRILyuTW2qoFUm7fplAhE6wUR18n4dQldxdbG8mkRn/29ZGIVuqaKO5q8oK/8opKcsaQVJySnagmBOJxEQ4z7H5oSFUY4jMtahOJYBV3wBdeUD22z0dilHPH4ySjnh4SsqQjLioiqeeSJfTsWerBw2G2pamJhNfVRd23JNB6+WWuBq5c0f7YuZPG18OHqVqpqOD5bt5kP+3cyQnrxImVJ9GTSbqujv9L5ta6Ova5ZHTNTrUg6pCZGZKypOGVVNzWaknM3l6OE2e++ro6rgbicS2u4dShiyumjANJXiibTNRSHUuIX9KSiy1wHeCSu4uth0iEkrAU+5YXZzmZOSXXy+SkVg0KhzUJlgTmSMSkvNACp5ohEiFh3LlDSba7m78/doxEGgppdSJJCxAOc6l/5AjJQfy/JRNhIsF7/N73VG3g85GI9+zJ7R4nJ0li166RsAoKSGBeL7+TTKSf/CQJXVY7e/cCP/mTDNY5fJiTx/Q0fzM8zHNNTbGv2ts1l3muiEY1xiSZVBWXTHjDw7xHr5f9IHYGIcfvf5/tkdoHw8M8p3jFXb3KfUVFml21qkqLfIRCmSX3pN4vwM8Lec0FAlqZbS4Eg7k/nzWCS+4uNj9EVTEyQvKcmFi+dC7nSia5tE+l6LGSSmUmrxLf5Ly8xV/S6WkSr9TWbWnhub1eni8a1WCXW7d4H0LgO3Zk6v4bGjJ9rW/fVuOvz5cZ/bwYxsboVTY5SX235Jjp7QX+5V80n7ronQ8cAN73Pk4c99yjao9kksdJMYuJCQ0gkjTZkswMUHKVaztTawcCWnBFEnYB/NvdzWd65AjVXsGgTmZeL38vUcDiTw/QRlBSwnPMzqox9fTphXPXNzcv3H9b3GvOJXcXmxOpFKXCoSGtXenx8KVdqu48HNbYCDFqirTs9dIrRPKjL7WN/f0s7Tc7q1WOSko0/7iob0R1I255c11raoqEdecOddniV33gAInT5yOp7t69sB5b3PauXFGf86efpqR99arWN2hvZ16Te++lZJ6XR6lZ2jY4yOPPnOGEWF3N9v/wD/NY8Vl3Ii8vM55EJk0h6GCQ30uN4spKLTw/NMTPBQUk77o6TTdQXExiv3yZz7KoiJOElOeTgCsXP4BL7i42D0R/LjUzxc+4qGhpni2St0Sk25s3SSaBgNb/dLo9VlTkfm4p9CBBLRMTJKNTp7jcHx2lBC+FHuRaokpw+qhLWwcGtFap+Ky/9BIJr6ZGw//37iX5LSRRJhLMPvjtb6v//vQ09zU1AW99Kw2vJ06QyAcHuSqQvOvW8jodHXwGQ0O8l/Z2SroSNQuQdCVS1O+/u15uW1tm2yYneZ/PP89nLdWLRG1SUED7hlMHLvldiovZl6dO5Z5F83UOl9xdbCySSdWf9/XpS19cvDS3OSl24ay2c999Ki1LGtvlIholaV+9qnnRAwF+X1VFkhIiKi1d+FqSHiMYJFF3dpL0m5o0r7i1vI5Eop48Ob/6aWoKePJJtu3llym1S+3Oe+6hbritTY22J05w38AApXhx6ROiv3qV+msp2j6fHSMX+4bT1fDWLU4WEiRmLVVDsRhXM3l5mtZB7CdO4+NSSwRuJEQVlUrx75//OSsxOeGcpD/+ceB3f3dVm+Cm/HWx/kgklND7+1UXKwUacoGktPV4SFKST6SggBJzdhKo5SKZpG74uef4WVYRoRDJp7ycW3Hx4jra2Vm2VVzuxBddcoKPjWmUYyJBEjx6dG5JNRymhP7Vr1JVISkIamupa378cUr5167xPFL8Ohhk/4j0LQXbz58nyZ44wRVIRcXydc7W8vl2dHDCPnKEk8TsLP37UymtVyoJu1Y7GngtIF4vEsAkBJ4NiaWQiGLZJKWBrEaXec9uyl8Xmwsioff2kuCE0KXqT67nkLwoo6OU9mprSQ67dpFwV6PwSTKpATyvvspreTxUaTQ2UhUjroi5YGyM+m4xBIdCbLeUWhS9srVqOGxo4IrDuXrp66N+//nnScbi+hcK0UXxwQepp25s5ASUSs3v8z48rOX0ZmZ43OHDXD0sl9QTCaqTbtzgszaGz7enh/cnK4nsdCGbCZJ+QFIQABoJKxkvCwo45px1bIW05e8mMMYuSu7GmD8H8DYAd6y1B+fYXwrgfwFoSp/vj6y1n13thmZgaEit7IDmXl4oPaeL9cdcKhfJkrcUiTqVIsmOjfGz5GERb45AQP2hVwLxjb5wgeqJkhJe4/RpSrMiaWXX2ZzvXCKtxeMkCwlwkUIV169zosvP5/eiq9+zR8n53DlGgj73nBbsqKmhEVSKwNxzD3Xi2YSZ3cditOzr0wny0CFK1ksNNAqH1XV0eporjHic9+Dx8JwyyTjtDJtBQp+LwAWBACfuqir+lWhUkb5XStrO2hBrjFyu8BcAPgngc/Ps/3kAV6y1bzfGVAF4zRjz19ba2DzHrxwDA3dXC/d6uRQFNMKutFSXzW7RjPWBFBTu76eUnkgsXUKPxbTiTlOT5jGXKEgpqrwaiEapJnnmGc0ZEgjQx7mlZWmkJwU2JNWB5BaXYueCoSEaecVr58ABvuz79rENFy5QAn7qKXUvrK6mv/w73sHJRXT9udoSrl3jeeNxTgjt7ezLXCToVEol14EB1ZNPTXHyLi3lBJOfD7zrXesSWp8T4nHNGuuMIg0E2O81NSRwScoWCKyOTl+qVEkkbH6+1kl98kl101xjLEru1tqnjTEtCx0CoNgYYwAUARgFMEdF2VXEgQN8EYzhAxMdmEBcqfr7uRwGOAAfeoifJUjDxerAWg357+nhs8jLU1/vXBCNamk6yeonecmNoXFvtSAl5q5dU++XSITXOnaMKoSljg/xR5e8ITt3agI750QUiTBQSKTBwUESekcH1S0S3i9kf+yYFpmur2c/jI+rC+BCEL/wri6dTO65h9L6QisnycnjDLY6dIiE6PPxPOEw2797N1VIIoluBLEnEpm1GUSNIrnkS0u1UlR+/upJzfG41lEVrcHTT2emMQZo+xBy37Vr3bx9VuMuPwngywD6ABQD+ElrbWquA40xHwbwYQBoWknF7+xyVz5f5qDauZMboFXmnbmUn3qKx9fWarV1F0uDteqX3d3NF0uMZLm+PPIbKXYs0ZPZWf1WA+JmOT5Ocr1+nWTV3q7l2JZSVEGCoaSNs7Mkkbq6u1cWYmCUQtbiZXP1Kl0QL11SNU57O6XzRx+l1N7RoWQhucUX65dkkv158SInqaoqrkQk58lcx0tVp+lp/k4M1lK2T56puFXW1pLUV2J4XQ5iMU3KJe+0VEVraNC6q/n5ayPAdXdzEp+YUCO2cAlAEk+ltAB4ds3cbPfQNURO3jJpyf2f59G5vwfAaQC/CqANwDcAHLbWTmYf68SGectItN3AgOaXLi+ny9lqVtbZjrCWL/edOyTiSIQvvUh0uSAapXQ+PEyp5+BBVTNIFaHVbO/oKK8l9TKlwEJzMw2QS/WmEb/0/n6+3CdPUiIUaTEbkl+mp4cT1tmzjIjt6dEl+9GjlNJ371bjcHEx8J3vsK8l9/liWRVjMbpCjoxogerKyruNpDIxj49zk1qora0kpo4OTlASwdvTQwk4FFKpfR3ykf+AyKUYD6ArllBIyXO1JWFRLY6NcZucZHI0Sao2NMS+KSnRbR0NxOvpLfPTAD5hOUvcMMbcBtAO4MwqnHv14fXyJdq9m4O0t1f1moBWr1lJ4YDtBkmz2tmpgTYyuHNFLMaISTGEFxaSrJxG0dV4SYW4Ll+m14bHo/U8S0sp3TU1UdJaCrHHYpzQBgcpIJSUsP3ih+0cK+LbPDhIKfjcOU4G166xbcEgyUIqIHm9HG9lZexnv58TgNTjbW1duBqRSOpPPcWx29xMzxen8VLcLQFGnEou+8JCrl7FSOzxcNUbjZLkBwZUqg+F1DNktZFIaM570fFLlk2poLRWudDjcU0M1tXFlZSsXCTFhagaV1M9uMZYDXLvAvAogGeMMTUA9gK4tQrnXXvk52s5L0FXl1Zcb2mhiuD1GBEniZu6ukjuQpK5hv6Hw/y9MxmW18s+razMrXTaUiBueOIB0d1NKU/Kw0WjVJksVY3gDMIZHOTv5wrscbppjoxQ9XP5Mts0Pk5iePhhRlju2qUkMTxMspdKPoWFJLiGBjVEz4dkkteQwstS2aipSROOifTp9apffWOjFgSZiyy7uzmRW8vn3dS0+rp0IXJnBs5QiBOLVIpaq6IWiQSfkbNy06lTGozW2qqOGJvVZTMH5OIK+TcA3gig0hjTA+DjAPwAYK39UwC/D+AvjDGXABgA/95aO7xmLV5riBtaRwfd7157jS/a4cMb3bK1hxC6FEleai4XkfClwANAMmxoIKEuVt4wV0jemdFRuvWVl/PzwIDmGamrYwKskpL5VSYLnX94mOoIr1fzrpw6NbdaRCI6Rc998SLJWpJx/ciPUPUSDGoxB5GkraWU3t3N/j5wYHFXy0RCvZEGBzlZHjqkE0FHB88nEndZWaY9YS630URCbVmS03y1SF3q087OqnqluFiLfEsd07VaKadSvL+8PI6b736X7fB4eP3du1XYyDUp2xZALt4y/3qR/X0AfmjVWpQLpHCCzP6SnGnfPv7t6KC05PVqvotgUBP6S/DHXIPJ4+Hgr6vjQOjszNw/NETCWq0K6RsNIeTubpXQcyX0VIpSj7wMfX0km5ISSmC5utrliokJDQYKh/lsfD4+17w8TeEqfu/ywuZKGqJP7+2lpF9QQJWFwOfjMaOjnLxaWzmRff3rdKWUur4nTgA/9mParnic/RoMUmqX1UMiQQHi9m1eZ8+ehUtEJpPU+b74IlUuTU1aaOLVV+lbnp/P/m9s1Cjahe4/leJz6+qi1F9Xx7Y473upSKX4fMJhnVhDIba3tJTja639vMU2NDTEZ9TYSOGiqIj9HAqR2Lex19zWjFC9fj2TdD0evkRC7pJNUNKMplIc9ELu58/rcriwUOtnZnvwFBdn6tgmJ+muJkV3nTrXrQLRSQuhiw49V5VLNMpl/ugo/yaTdNcrKmL/tbaubDntrA0qlYhaWjiBDA1x8pCUupWVVJGUlfGZlpWRlJbrwTE4SGN7SYlGvAoJj46qmiMc5oru6lUaSCWi9Ed/FHjPe6jPf+EFHSO3b5M0S0p4bEcHiaWjg/d78iT7bb6J0FoSVUcH1TCBgBaZmJlRbxGRikOh3AKthobYtkhE0zUsB9byHDMzmq64ooL3JInB1ppEnaszKfAN6LiUycqY1cmzLoVCZKxL9axEIjM1geQGunWLzzCR0OIqa4ytmVtmakpTkwaDi0vRUq1cdOd9fSr9zcxoNfIHHuD+557jwysuzrSKezx8QLdv88XwePhSt7dvbr28M9tiXx/7zuPRZFeL/VaW985CxHl5fIEly+JyXt5IRIsvFBXx/3Pn1JgliaKkSLN409TWUi0hSbCEgJcqDUrVoZISTmyJBNsjJCxt6OvTQhcvvUSDpFQyOn6cAsD+/RyP8TjHhs/HOqpOjIxwEsrL04hXyTMyH0ZGmEMmlWIbDxxgv1+6pCSeS16bbFy7xlVKYSFXWUtxAwU4hmZnVWdeVqapINaDzAE+g8FBbjMzNFADfD89Hi15KBD1TDKpf4uL2dapKfZ1dmWnAwdI4J2dmvteNoApKXw+LVvohDFUyUmpPlHVFRdrHvxlYHvnlllqtR2PJ5N8Re3ihDMBUGkpiayvT1cI9fVaUWdmhn9HRvjA5EFFIloVZqMxV7UiIdGFSNAZwDI+zs+NjZRAi4rU2JSLD7pkP7RWX7KrV9l/4bCSeF2dBnfU15NwiovZ/xLlWlCgUv3Nm1pUQ7AUYg+HtSanJHkCOE7icdWh79rF/7/8ZeCJJ/isCwuBxx7jS9vSQgm+spK/6e3ld3v2ZFYlikSoh796lfdw+vTihSJefpnePkNDvP8dOzSXDsCxuFTIpO7zkfgkSjOX8Sp9L6qW/HzeY2Ulz7NS46eMFVltyyYpACIR9VQaGGDfSH1ZUf99//s8l/z25k1OvqWlXKVevHj3dR9+mO0fHqbKSyAOACKdSwyHM7Wx369919rKsevML+Oc4MRDbx2xNcl9LeB8EM5ZVUqwiYQbjWYWKPD7KW22tlLvmUzm5pO82hBSFiPj1BS/lyRH861uwmEO4OJireEpUklREYlXpDrRbyeTKrsFyCQAACAASURBVEnHYhzgcsz16yRvCTQBKGlmT4BlZSSIggJNoSsFHGpquK+0lP1bV6fBRxJ4ttwAJzE2GsPzNDTw2UrpOJHKbtwAPvMZzdJ48iTwi7/INMKRiJJsWxt14AMDXEUcOZJJdNPTlPSvXePLf/z43PpssSMFAjT4nT/PZ3LqFJf2odDypWFrOfF0duokkYvRUPLix2Lqrrl7t5K5rJb8fo4JmYid244dJOBwWJOdCfkmElz1SKrjZ565uw1Hj3KMXLnCcZ2fT9XYwADH1b33qu3j8mW1s0kqAemz0lKusIV05a/YZRobOc6ySVkwl0DohGTd3ETYmmqZjYaEHUto9sQEX3JjSAbPPad1KiU4KrvK/UqRSmkR4cFBElMqxYEpodZzYXiYRDk9zbbHYmyrqKRee00LMQPqRSF6ypdfVn2moKhIJcmrV9UnWLL/FRTMr8+dnKQELfpIkSojEb7ETU2cKFMpTRq2VEiVe59Pg6eKi5V8AKpbOjpIxE8/TTJqbgbe/nbmLKqu5iro5k1O8BUVWq5PXC6dK0oJS+/p4fVra0lCMslKQJi45I2N8bOonOrrNUBqJZiY4EQ1M8MJIjsXjVNXPTKiRUhEym9r44RVWMh+kZqngt27SZqxGA3LAlkh7N3L90BWL05i9XpVeIjFSNjibz4xoakoZIW3fz/HgxzzOsX2VstsNPx+vtxzVfCRKvfXrlEHF43y/5MnSfBDQyRAya0tW22tSkNC0k4JQupGTk5qhKdIRx4PpV2PRyU0WUILAb373TzPhQvcL8WA8/PvDsAZHeV3svx0kkF1NaU+KZ0m2fIE7e2L95/k9kkkVIdfWakSf18fz9nQoFHD2SkncsH0NNUvw8MkalG3iZujLL2feIKqF0l/8EM/BLzznfSuMIbP8NIlku7sLMl8dpb9IEU2pG0TE1z9eL0cC/v3az/KBCXP6dYt/h+N8pk0NVGCPH165WqORIK659u3ed/793M1J0m/ZKusZN/ICkMqSIVCmk5BjLPV1aqikE0mbb8fePOblbizn1UwyFXPfPD7OYYDAbb9wgX2fU0NJ+CamvVdCW8DuJL7WiIa5UCPRDRPSGEhpR9jMoM43vQm7rt1ixKOZJWTMPGTJznwJfISUGMnAHzgAyTEp5/mMcbwf8k5/ba3qXFQPCyEdJz1J0UlM5+r6HIRiZBUh4b4/9GjvLfubq4KfD5OeoBGJS73+jMzJEsxbNbXaxi9RNd2dTE3+ve+x348coSE/uijmcvrRIIeMRKpKeqcEycyyWZmhtL/5cu81okTGhsxOkqpeHSU91pVxcnhzBldjUjEay6GTdFPSzSnkO/165xcpExdLMb2P/YYn+fFi+rvLaqRggLaFhobtR0yca8Hpqb4bvT0cAJ48EF+L1ldt7Gr4nLhSu6bAaKGKSoieU5Oklwlp4jkx5A0sYkE9ffnz6sLp0jQUkNSlsyiV8zLywwAOXGC23xeRIvlPV/tl9oZFCXFKLxeSrfRqKbzBXKT+heDtVwN9PSwb+67j1KfuOo98wzwz/9MNVAoxALR73gHVQdOyKrIGKom6utpcJPnJv1kLW0tnZ0qfd9/P5/Xq6/yeUmR6Koq/n50lCqM8XHNcZOttpJwfFEBAVqmzpk0KxjkxC+/6e/XotpStk4Icu9eCg2pFM8pvvAbEYXZ18fJaHKSfVxVpYW1gdxcOV0sCJfcVxvJJAes+CBPTqqvdnMzJfWvf5168lRKDXrd3XzZampowQ8GtVSXSNnA4lb3jTTqSGWhsTFKt5L9MJmkvjmZ1BTMxcXsj8rKlU8okQjVDYmEurbW1Gg5uW99C/inf+KEApB8f/3XmQJ6rmv39DCeIT+fknZxMdstxTEqK/lMCwv5Ny+P91JdrSX+BJLyoKSERN/ZSSm+qIiSfXOzJkuTQtkSwQpw8jt9WldipaWZ6jwRIAYGOGmUl3OsibeOpFJOJtn+gwdXP7gsF4iXi6h2JJDw4EH20WZ2Jd6i2JrkPjJyd+SoFBMwRvWzHg//F2lRkjSJykH2OzfnuQTOdMFiyJye5kso5C2Jn0ZHSQwSyCAS9uAg9ycSfKklEVJBASWx55+nWqK0lFJLUdHmKXqwEBIJNdKOjqoHjXjrTExw2V9bq8Zbp+S7kus688eLblzcKmdnga98hbr0kRGS/Qc/SNXLfBW7IhEaw6XuaHs7JcpLl/hcdu/m/Zw/T8nf4+Hzr6tTI6OTpCTdghTXPnNG1TrV1WpMPXWKv5OVmlSZEgIXON0rBbFYZnGaPXtInvIsCgvVqL8RE79EFff28jlJKT/ZXKwZtia5S6WfbH93p/1AiDibmJ3/yyYQNYa4+kWj+reoiC9IPM6XW+D1koSz0yBI5GsuJJaXR2+T4WFut25x27OHRCRG1o2OhpVIxIkJLZcnBaSlMEJXF/eNjWn4vrgt5uXlnqdmLkQiqru+do0qikCAag3xonjmGeBP/oSTpTGUet/9bkrrC+lvR0eBb3+bpN3eTolSjLlSIOPCBV5T8pJI3u7SUjVCAppbZ2KCKiJJvbt7Nye90lKd2AsKtF2LudvNBWM4kbW1sS1TUyT35maOneUEOK0GkknaMyYm2FdSsGIuJwQXa4KtSe4AX+r5cn+LWiQapWQTjfLY1lbuP3NGPTOkvmVtrRpzPv1p9eiQ1Aa7dtHjANBgFimcIB4jMjksNcgK0HOJ25gssQESvkiTxcVaNV6iZtcCThe5zk6+pNPTOuHl55P8pqbYHsk4KK6PZWUrX/pLgrCSErals5N9L9J/czOfyeQk8NnPAl/8Ivuqpgb40IcopS+Uq0XC+gsLOQbq6zkJhMOcsFIpVad873v8f2yM5L93L+8xGuX9FxRkRvDOztLAGo1Sgj9xQifnlT6zeJyScHMzx2lzM88ZCmkyro1wFRSVXHMz352yMhJ6ff3aZXh0MS+2LrkDfHFELQJo9SUx1MTj6iNbWqrkPjxMcs9W5QgOHcp0BbRWpTIJFpJrChoaeH1J4iR+3kL8kvkuFwSDmRJcaSnPPTmprpAAiUiqGI2Pa050cVOTySEW035wrmBEoh4aYn8IcUug0Z49JKnr13n/VVW0DYhaS9wBncYveQbLhfi3j47ynpJJLuVnZ6mG2beP0n8ySR36xz4GPPss7+eBB4CPfpTS+mIrpvFxeo9MTnKC2LWLJH/pEonT76eazBiOI0n41dPD45wlHJubNYJXCo9Iu3ft0hiI1cDoKMfX1BSvUVfH8bracRS5IpViX3R0sG0+H98Fr5ftcrFh2Jrk3tlJ9zTJGZNMao4MIDPFp5C2U6Vx9CiPET/vbM8S8T6YC14vJXyp2yr+wrKKEBezsTHuF7WPeFzMzlK6E9KXraqK55B6kBL55/FoqLdA8nqINCSRhCMjSuIej65EJGlR9n0cO8ZzXb3KdkpKVEn3K4U1gkG6Cno86jJZVLQ60phEseblZUq+gQBJPJUimcVinORiMeBznwO+8AWScCgEvO99TNqVi0pjZoaupFeu8PPOnezb732PqpyJCX63bx/bdP265rApKWE/ilRaVKS5x2dn2c83brBf2ttXN0o5meRzunWLq4THHuPqQVY1G4HhYUbnRiLsgwMHuHJw3Rc3BbYmud+4QUmhspKDKruKT3OzemuIUcpJRCtJZwporpq5JKVAQDO+SfHuWCwzf0kopOqi6WkeIzUXp6YoPTqv5fORLMQVUnJ/DwzopHTPPbz2yAjdzBIJkoF47zQ3q2FXfn/2LH+bTFLqDQR4zrExnfiy60AuNcFUNmS1JblrZme5dG9pIVFKLdOCAvbD2JgGWn3hC/R8icU4Mf3czzE+YCmTzM2b1J0XF+tzOnOG4ymR4PUrKtQ91Vp+V1DANshqSRCPc0Lq7eXzOX4899w7uUDSKr/yCkn04Yf1WW0ExKW1pIRjo6SEK5Sqqs2RU8nFD7A1yV3yVldXK4E7JaSVGO1WE+K+5lw1BIN3pxx1GnULCyk1OlOHyioE0AAWiXZ0Jt8KBjXBkzEqgefnU/csE11xMc/n92euHgDaHubzJlkqpIh0Mkmp21r68SeTGkxUU6NqHZGIxaujqIjG6yefpM2hsBB417toIM210LDkPPH72R/PPcf+qa7m5CceNu96F693+zavFYtREj14MNMHPZvYn3iCk6mkC1gt3XIspqH3DQ1sn4z5jcDwMCfGO3f4zE6eZHtOndqY9rhYFFuT3CUPe36+hpBvZTglHlHRzAcp/zUfqqsXJoC1rjQzMqLZJCVgprCQEq0xVCUEAiRS531HIpSexcD57W8z2Gh6mnrrj36U6VVzdecTY+nZsyT3khK2a2yMBH39OttWW0s1TEGB5lIpKOCkUF8/tzQqgUSdnbyXhx7ifa2GCkb89H0+XqOubvUqWC0Hd+4w35DYdETd5GLTY2uSe3c3l6nOpa9EIwJcTs/MqEQqwUCrtVR+vUN0/kJEsZgWNblzR4N0duzgKsEp+YrOXhCPkyR7e6mGOXeOz9bnY66S97yHy/7FlvxShKS/X9PBSkI1n4+SZlGResKIH/uePWzvhQskLcllMhemp3nu/n5K/C0tGrOwEojqJRbjxL1jB1cQxmxMyTfxtzdGHRMOH+YK4nWcsGurYWuSe1MTSaWoSA2bTtXG9LTmwRYEArqElJziTm8WqbQOaHj/63kgJ5MkwkiEf+vquELq6FAvEUCLTYjrqGQJzFX/+t3vAk89Rb33+DiJ7ed/nm6Mi4Wgh8P8jejvr10jGY2MqMG5vJxqrpYWPu9z5yipi6R9+TK9PCRoaC5Eo1RJSAWlI0d47ErtD4kE220tibOpieNW4gZOn175NZaCVIqC040bfIb19eyr1fT2cbFu2JrkLjnK5xv4EqIv+mmnKyDAF0ciKcWg6Swz9/LLJAfJeiiV4mU5KtGJ4tEi6QG2ymQg+nyJA4jF1JVuaIgvt4S/CyQPTnk571UibLMNe4upJlIpStRdXTSQfuc7JLf77wd+/MdpLJxPzSZl4aTIRnGxTkKJBAm8qYkThkSCHj+usQgAiT4UUvc9Y0hgdXXzP7+zZ6maKC0FHnlk5ZHD0SgnJK+XKqf6ek4WUr6vtpaS8nr5hktStWvX2IayMn2uW2VMu7gLW5Pcc4UUJc6WyLJ1htZm5qhuatJiE+Lt4lwF3LiR+T/AiUESX128qH7ykr+6rIwqCWtJbs4UCc52Og2iIi2Jm6IURZidVV91MaqKH300So8XZzmxRIL3VFamRQ2y4fQ6qqzUOp3iKiqkXVrKbamwlm58n/88M1feucPzvPe9Wkw6HGbbo1FdNUQimg64o4MEn5/P77xeLYAcCNBfvaVF+3THDkqiV66QLIuKtLh5MMhn1tJyd+SvPKPCQk5C4TDPfeDAyog9HKa6KBikHr22lv06M8P9+fnU36+3+vDMGfZjWRl90zeLQ4KLFWF7k3uuECIWLDa4jx9XdZBIwTKBSL1RZ7WiZFLT6iaTlJCyIe6A8Tj1v9kQf+xolL7F2di9m2QmOmxZWcgmkHiAbHuEHCP1YleCZFL7JhajLv0f/oEScCLBYLIPfEANhRLRK+H6smpqa+MEMDHB/48do9Td2UkPFfEpb2rifYl+uqmJK7KXXuLf6mr22/XrJHdJWJat/weoJrl1i9ecmOAx+/YtLNkvBknfXFrKe6iq0nNJ0WvRaa8XsQ8MaNK2tjaOCZfUtxVccl8O5vNxBzhRiHFxLni91P1LSl/ZZHLw+SglSt4bkd7FaCfpXCXpmVPyl+Pe8Ib5daTB4NwJqOaC+OnLRCFJwpyTWjzOSSUUIoldvMj7iUQ4SX3/+zSWBgJUaRw9SiKRSNpAQLMlikeGBAcdOEBS9vspWUoYu5BgURGPdwZ0AZTWOzvZZonsvXJl4ZQV4TBVPn19eu1kkmqo5aRRkAyZsvK4557MHPVSqKS3d3EPp9XE6Cj7YmyM47S1dWHvLBdbFi65rzeMWTgARWpVzgefb+HkS7kYviRXuOjdpV5pIkEpMlsVJeH1zlWHc2Ugx+Xl8bxPPsmIz2iUUuGv/ApzphcVUYIdH+fW1kZS7unhuRsbtbqRRKtOTPDcxcWU1AMBjUQeHCSxizujrD4kX3lRESVjgKui+vr59fm3b5P0PB5dISwH1mrOfWlXthprepqG3elpqvJ27Vp7g+X0NA21AwOcrA4fZn+72LZwyX27wVqt0iNbMEgXP2spSWfbC3bsyKx6I4m/xKAsapq8PA3UcZLk9DSNo1/4Asnf76eE/lM/RUPp7CxJdmJCr11QoFJ5QwM3SZEcidCwmJ+v9pH+fuqrJRGYeDTt20fi7+4mmZeXU4UiQUtSCzV7Qk2lKKWXlXEyGx8noTc0LE8tlUrxHIkEz9HaOr+KRYpO33ffwhP5auLSJbavvZ0TzlaPDXGxKFxy36oQo2M4TKlPokrPneN3TlRXkxSNUelV3EBFPQJwv5SGmwvGZNoWXnoJ+NKXgG98g4S8YwdzvDz8MEmztlZVRzMzmvNearACJMOhIRJtMEh1SDCoBbevXSMZShZMId6aGi1X9+KLWgQb4Pn37tUMmtmQtMqRiKq+CgqoDluqX7mT1MVuMpfqx1qqQkIh9stqFClZrF2dnXwmwSANpVJbwMXrAi65b2aI7joWU9J57TWSk9O7p7BQyV1KlYmXSyCQaQhcaXTh0BDw1a9mFpR+61t5Xcn1k0qpdCptyU7GNjtLQh8c5L2IJwugGSvDYe6rraXUPzzMiWnHDq3q1NOjBlhJvztfmt+JCapfJifZ7nvu0Xz9ziLXuUBIPZlUUp8vejYapf1hZIR2h1zz/C8XQ0NUr01NsZ1tbSsPtHKx5bA1yb2vj1KJMVQnbPUAi1RKiWVoSFMSh8Nad/T0ae4vLOT/Uvg6Pz9TGltqsYdcEI3SffErX2HmxFSKk8TjjwO/8AtcGbz4osYDlJfPL70CfF5DQ+qxUVdHiTwep149GqUEbwzvb2CAf8UoCdAw2N2tbqLFxSTYhdQcY2Mkdms5GS0nQEhyukvpwObmhd0jx8fpJRSLMfhpLUk2HCap9/dzfNx77+rlCXKx5bA1yX1mhi/85CQlIKmEsxUGslQyCod5H7Oz/O7++9XneXqaL6eUWysoUPVBrp4uK0UqRbXLE08A3/ymVhA6epSkVlmpGRQBfj8fpHBzXx9/U1lJchXdeDJJou7q0nwvqZQG+7S28nhJpQyQUI8e5e/Hx1Xt5IS4hZaXUx0iE6jko19qf4j6JRdSB3g/ly5xBfXgg8uLD1gKrl3jSqi9nf3sBiC9rrE1yd1ZINpZ1EHI/fp1vvQSRelMWbvWSCSUsCV0PxxmDpOCApLT9esqlRYWUncsUm1LC7eNgLWUnL/2NS3iHQyqC+PoKNu6Zw/JY7Gyf+EwXf0GBkiOZWWq3xe1xPQ0pc1oVFP9SgWs0lK6jfp8bMtLLzH4qb6eqhkJGsue1CUTZHc3ryuTx+QkSX7XrtzdG1MpTjDxuD6bXAOZolFOfsePr1206dgY+6e4mP2xe/fGFkl3sWmwNckdIAGUl+syXLwwrCVhTE8rYXo8JITWVn7X1aUBPBJFKgZG8e0GNGVBMqnHx+Pq6y1bNEpJrqxMc28L8vJIBnIuMSpm68I3Eh0dJPQnn9Rc721tXNY/8ggNpKL/XwpxvPIK+6aqiv3v9B4RzxgpyycFo8fG2D+yUonF6OFz8yZ/19JCY+l8evWhIR4bi5FYW1s5yVy7RvLL1Z/cWgoN8TifbWtrbqQuk7lMImvl5hiPM0dSRwcnuhMnXGOpiwxsXXLPhkiCxmilJclcODurXhOJBJfq2ZC8JNEow7GzIZWUJNIR0KIdfr9OJBIAI+kEsl3OJBfNRsJa3sPXvsb85jdvst9aWpiwq71di4eIisTjWZjYrSU5Syk8r5ckHAxmSviTkySkWIwSreT96e4mee7fzwlQ1DJiiJR8KzU1c0+KMhkkk7ymVAQStda99+ZmxHT6qTc1kdRzndCGhthev5+T4lrZggYGqO6JRjUJmgsXWdg+5J4Nj0ejGJ3w+zPL5El6AJHKfD4ubaXCPUCSkPMUFKiqYC5fYb9/c1Z4TyRo2PvWtygJDw6SfPbsAX7t11jRKBol8ebnUxqsqVl8Ikomea6eHi2cLWXXnP7i09OcVEdGeE4JoPF4KOm2tfGaqRQlUgly2rVLpdK5yFI8YGR1IHlobt3SUn0ScLUYJibY9vp6XnspqQBu3GC7i4o4kawVsff2cgIpKeF1NiIlsIstge1L7gthoTJ5Pt/CZfjkt1sBIyP0cjl7ll4uk5OckPbsofvikSOUquvqSOTJJEkjV8KQPDexGFcsO3dyYssmNok29XopgSeTJNKGBkrZp05xdXXpEvXqMzOU6gOB+QOKJJHYyAjvwefTtL+RCO9JkogtBgl2qqnhZLKUIKZUimTb389rHj68Nm6OsRjvc8cOrgxzvTcXr1tsXXJPJikNSnIua5WUBwa4TwJopNyduAlKkI/o3LcLwmESzTPPkNC7utgvFRXMNnj0KEkhkSA5plLsFzEuSpm7hRCNkgwlc2RVFc+f/TsxKodCJMv6el5XCnXX1qoqJR5nINTAAM/1wAML5xDv7iaxezyaViAe5z1LwE4uE5Qk9KqqYt8sx5tFcvvs35976b+lIB7XWrIPP6z5cly4WARbk9muXmVtTeeyWYJbAEqFIyOafEsScwm537ihLnVeL/eVlKgXzuSk1h7dzGHa4+M0Wr74IrfLl7VoRmsro0WPHaMOXTxwRILeuVNzuOeCSISkKuocSU+QTWgzMzxuaIjnvvdetlOKTdfUcBsb4zM8dIh/CwupGnLmiHEiHtfsncXFfJZiI/F6uR04kJlGYT6Ew3zG5eW8/nL83fv7tUi0RNOuNu7c4UomGuVqy5XUXSwBW5Pco1FKgYWFml/cuZTONjDNla+9uppL3WiUmxPXrlHyBLRKk+QdAUh0eXnr+7LNzrJdr77K7eWXqecGlNje8x5OcLt3kwRnZ3nvfX0agXnw4NLaLbVNh4ZIrjU17IdsAnaqSTweSvbV1fxNSQknkoICEv3Fi5Sam5o0grK4eG5vlESC99nbS2m/rU2LaF+/Ts+lw4c5BhZL9iUxBiUljJidS4W0GFIp9v+tW2z/QukalotUipN2Zyf75dSpladhdvG6w9Yj93hcC0mIy2NfH8nmgQd4zMgI/0pK2Ox87YsVnGhvV7WC/HVOAOfOkTQDAfWKqahQQ2o0SvJfjlFtdpbqlI4ObjdvksSEyAG+6HV1lHRbWkjs993H9vT0qFG0sZFSaXGxEnquxC4eMqkU+7OujqTulPRlVeT1cqKcmCChJ5Mk3XCY/ezzUXVy4YKmUxCPlrmKqQA8R38/VwHxOCcLp9rt1i1eu6Vl7vwxTsRinFQKCqjLd+ZTXwoiEa4yRke5Mtq/f+nnyAXGcLJsa+NYdCV2F8vAouRujPlzAG8DcMdaO2eicmPMGwH8VwB+AMPW2odXs5EZ+OIXgZ/4iczv/H7VHTvzoosPdVGRJrIqLFQvGtnkOwl4msvLRmAtJWNnpaDRUV6/ooKS5gsv8FhnQYzqai1jd/Mm1QJjYyTO4WENxxd1EcCXvKqKxPrYYyQT8bGXnOd+P9ssk96OHSsrLDE+TkL1enk9p3eQIJGgeqa/n5NHW5uW3hsc/P/bO7PYyK7zzv9PscgqsrgVWc1NJHtRs1tNtTrqzdPWYrUtR5b1EGEAYxIPjCSAEyMJkIfkZSbIQ4LkKQmyTJAEHmEQeDJAHGcmQSIEWewZW5YSRxpJtrWrW93Nbja7myLZLO6118nDn1/OLTaLVU3eWvn9gAsWeS8vz7nF+p9zvvMtLtvj+jr7evy4M6uEQpxhHzq0s1386lU+j2i0UMDff5/PoLvbBYYVI5vl82xro/lleHj3z2V11WXUPHPG5fDxC6lUJSX3Llxo/LQaSk0pZ+b+NQB/BODPtjtpjOkF8CcAnrXWThtjKlt14NQp4Fd+hfbItrbCeqAithsb/DCurVFspqbcuXJob3cFk2V2LgNIaysFQqIoxb89n3eVh2S2LwPAxsa9ph+htZWz29FR4OJFivbKCv9mezvPx2L0m+7r4z0XF93AFQ4XisBu9wju3nVRnG1theIlwr6+TkGXZF8yKMq5qSlX21SKU/f389lcusT7Hjy4faqAfJ7vaVcX7zs2xut6egqLn/f1cVAYHi4ufiLqLS30uX/ggb1vnEs6iGPHSq8U7hcpbCL7RNXI7640PSX/4621LxtjDu1wyX8G8NfW2unN6+f8aVoRjh8HfuZnOMu5340w8bB55x0XDSmiL4IuxSRyOZdWN5VyBSzEy0QqKUmtUzH9BIO8V1+fy8woqWe7uthm2SOQOqBra06A3nqL4i3CGIsV2qLb2/2fNc7MOL/wo0cpqjJIyAatXDc/z7aL2WR93VUSOnmSz0iihu/edTldHnlk+zQQUq90eprvg5TMk6Ro6+s0Sw0NuaMYkntG/PfHxvYWMCZRoCdO8L05e3b39yrG3Bw3w3M5uqZqAQ3FJ/ywuR8D0GqMeQlAF4D/Zq0tNsv/CoCvAMD4+LgPf/o+aWmhsD7xBL/PZimsq6sU3t5efi81TNvb+fPOTgrWbsqtbUUKQywt0TYuqwkR7OPH7y2G4TcySw6H2eeBAYqXBPxI6P3cHMVciksHg7SrX77MAa+zk7PxVIr3evBBXj8zw+cYCrmUBdtlQ5yf5zNIJHivkyfdpmg+71L6ijfMTv2RpF5HjtCMs9dYhKUl7q2kUhxQKlGKbmaGwt7dzYGj2oWxlabGD3EPAjgL4GkA7QD+1RjzqrX2nirQ1toXALwAAOfOnbNbz98XMgtfX+cH0FqXq1xcHcUVEqBQnzrF1yKqUmnIu/kZDlNkRPSXlylykQjPLS3xQym2+lKJyTIZfziGegAAHIpJREFU56HR1kZBu3LF+ZSPjnKWLmYDPwaQYmSztGPPzLgycFI4Y2iIbZ2aYn9XV52b4fo6+zs76zxvjh51exgAn+fbb7tV0LFjbrDw4q0Lu7rqfMS9qXpXVpzH0sCAK8e3FW+qgPvJ/1KKa9foERMKMdVypaJABwe5f6NujkoF8EPcZ8BN1HUA68aYlwH8CIB7xN03Ll/mrMo7GwyFnLhLfm/ACYlXHJJJCkgm41wku7u5LA4GKWDZLIV7ZMQNAoCrPyqDB8AP5tmzFJZ4nL+fTjtXS8Alu4rF3GZoNe2qMzOcCWezXL1IpSLJ2Dgywufxve/x+pYWZ4oSd78zZwo3V5NJml76+100abEoVWs5aExPc2CIRp0gb5eqN5crnMlvRYpPj4zwfn7lSb90if9fQ0P8f/A7D9DcHAfQ8+d5b8lsqSg+44e4/y2APzLGBAG0AfgPAH7fh/sWp7fXpX2VTUXvsr2Uycf7gcrlXPIqIRzmzH1x0VUTOnCAttdYjN4avb1uE1dm+VJY4uWXXaKtrq5CN8mNDYqXFJmoZJTsxoZ7LoEA27y+7tIOx+OuPJwEePX2ulD3nh4XEwCwf9ay/7OzfD6trRT8QGB7oRIT0M2bNL9EIk7Mve/Z/Dyf5+gon1U0uv1sVlZrg4McUP3y/5YVxfg4+374sD/39d7/8mUe3d3OHVRRKkQ5rpBfB3ARQMwYMwPg10CXR1hrv2qt/cAY848A3gaQB/A/rLXvFrufLwwM8EO+m8jCrbS03LuUP3rUvRYfaZml53IMwlleLhwQWlrYrokJind7u8tSmM87Ab99m+LoJRx2ZeimpiheYmeWXDay0XbnjjND5fP8Gg67AKsPPnBuivPzfEbDw8BnP0sB/8Y3XOGNo0c5AIm9PxBwm7gDA/dWuVpYoElJxH98vLR74dtvc5bd2Unzy9ZZfTLJey4uujQFkjbCixQxicW4kvDLVCIZMpeWOJtub/df2DMZ7uPMzfF9fOSR+o58VpqCcrxlvljGNb8D4Hd8aVE53LlDP+hYrHD2K2IvuWa8niyAEwxvNshczvlgy+z66lUKoATcABQT8SI5fZrXi1uktU5sUim3YQq4vDYLC2zvwYPOxCNtDAYLU9bKSkL6IQFJAIVbamPKEQ7TjLCwwPwqt265FAHhMO8j+dOfe44iubxMQU2lKL6A86+W55TN8p7i9x8K8evQUPHoTskfMzTk8uiPj99rXrGW7bx+nd8fOeKE3YukCujtZduiUf/MWZKLZ3GRg6N3P8BP3nyT5qtTp/Zew1ZRyqTxIlQBmhvicZciACisM3rliktQJbS1URwAurd5g4UA58cMUOwDAQqJBEZ5bbo75c+ORPh3xMddvortNp3m7H0rXvONhPDLbF+8ejo7OVOWpGhed8VUiveVoiQjI87TxxuhKwFUwSAFNxYrXAHl8y6oKh7n9+Pjbp/g5LZxbHxmt265/YpQiH0p5mWyscFVSjS6fWUk2Rfp6tp9qoCduHWLLrHWcrCuRPlCGSxOnuTz8WOlqShl0pjiLhkDxT6czRaaSAYHnVuZeMx4l8GjozQ7iOljq917r5tc4oGzXYoDmYHKhqvklZfBQ9w1Adcnr5kiEqFwb2xwxplM8n7t7RSRtjb+bGmJ569d4/N57DHe4+DBewuLe/PuvPFGYXrZgYGdg3ZyOc6+79xhe/v7ucrYzhYuKwHxsjlz5t6NUBH1SMSlCvB7Np3NMtK1q4vC7ndZOmt5/0yGm7Lq4qjUgMYUd0HC2bf6NEejO8+SajmDEjNNsfqj3d3FNwkzGQr2woJbDRw/zntK+l4JSAJ4vreX/ZU9g2iU10r6g3ic9xWbv9RG7e7eWVQzGeePv7zMFcDY2PZeKxKoNDVFYRVzkfdar6ifObP7/C87cfeuczt97DGKut8DRzpNM8zCgivrqNGmSg1obHHfD+RyzsyRybiSeJGIc9ucmWHyMPEyefBBzszFM0UiaQFn587lXKoAbym9UsE68Tj/3sqKc4t89NHiQry2RjPZygoHjK0mGBH1jo7KiXo2y3TI09N8TkeO+Oc66WV1lSUak0mNNlVqjop7PSLBRmLDDofpySGeIlJ4urWVppOuLjfbl9no2hr3HVZW+FrMA+3tNLVEoy4neynEnXFmhuagtrZC4SomxrkcvWUCgXuLWntF/fTp7QOe/GB+nikdkkkOLJLX3m/yeVa7sparArWvKzVGxb0WSK4aySWfTlPkBgZouvjWtyiMgQBFu6eH1wMUjbNnKfjpNDdsJTFZaytt7e+8w2uljuzIiNtz6Osrnfd8K5JLPhIpHnkqiB/8gQMus6SkLgDY3tVV3quSog7QxfHDDzn4Pf54ZQU3EHB7COq/rtQBjSnuIoyJhPP1BtzGVSLhXBiFQMBtDCYSnB17baESdARwlpfLFWYj9J5fW2Mb5G+LH7uIphSLFhfEbJZtE//5N990P5egnLNnndA9+CDFMRrlLDmXc387naaJQXzdhSNHnEfLsWMuhfFuhHN1lSsGScDV2UkhLpUNcWmJJhgJnpIMjoDzU5c8KrFY5URdTEySW75S4f35PFcm3shcRakTGlPcr16lf3Ik4nzWAeDZZ/n1+9939UNFpEMh4Md/nOe/8x16d3jp6nJ54r/1LVd5SAaAaBR4/nn3+8vLhecPHGDOdYBBTsmkC0KSpFwAB5bZWZe7JRDgjFs8VsbHWYHH6ysP0MWxp4fXdnc7F03JZimulsHgzpkTi5HPs8937rgyg95C4TsJeyLBTdy7d9mmyUk30K2uUuz7+mij7+ur3Abj+jpNVuGwq860m7qo5ZBO07Po7t2dXWMVpUY0priLCEne8K1ZFDs6XDpdEVjvUvnw4XtNE97zBw8WLuGtLdyAGxoq9CYRt0xhZMSZXCSfu7QvnXapCiRxlxQTkXsdPerSB3sLfgDFw/z3yvQ0j/Z2rhwGB8uzx1vrVhKHDtHN1BgOTOk0Bz2JKK2UqOdyXDFcuVK55+NlbY0bp4lEZQp3KIoPNKa4yyxXKs8Hg4Xug4cPu0jQcPhekTpxYuf7S/bIYpw/X9gWmaUDXEUEAs5mLpWgZBbc3Q186Us7h59LnpdKkc/TpXJ2lsIUjXKg6ekpT4Qll/vwMPtx/DhXRi0t9KbJ5Sjy5ZTA2yvxOFdqGxvsy+RkZW3emQzwz//MZ6Qbp0od05ji/tRTnBGGw67qkTeIaXq60KQhG5Mi2tPTnFUGg4Uze7GZLiw4c46E+IdCzk3wvfdcagLZ6Bwaom1X7jc0VFjGzzvLr1VekY0N+pt//LELVBKTVrFapl7EX/36df6+PJNQyJmpDh+mJ40fqXdLtcUYtrmtjasDb9rgStHa6rJV+h38pCg+0pjibgzFIxrd3vPjoYdcUWvxRvEK6vIyTSMibABnrCLuU1Nccnvp6yv0AQ+HOWBIGT75oBtTeuZfTUQEreXmn4TBDw/fn/3bW1iju5vPuLXVFf14+GGacooFZ/lFMsm0vImEi8x98snK/k2A3kLRKP8HKpGqQFF8pjHFvRQ7RYACzMoHFM7Mt563ljNwCf33mnYeftj/NvuJVCYSP/fz59mPEycohrsRYPGeeeghPot0miaXEyc4KFa62IQEcF27xvfm0CHnFVNJxCPm5k3+zUpUZFKUCtCc4l4uYiLZaiZpVD/lRIKBT/PzFEPx0snl+LpczxFr6QUyM0PxDoVobkkk+KxGR2l6qVbOlHgceO019umBBzjAVMMkks3SI2Z+niY39YpRGoj9Le6NjrU0L8nGcSrFTVLJxijFqctF3CFv3qR9PhTi7D8U4iz9oYdo1/a7OtF2ZLNsg+TaGRykL3mlXBu3IlWpVlc1lYDSkKi4NxqS9GthgUc6zZm0CN+FC7ur7JTPc5Yqs3Mp2DE+ztlytcoCptPc85ia4qBy8aLLoV9NWls5SE5OqilGaUhU3BsBr235jTe4qSj55mMxtxHszdteDqkUTR5DQy7LpNRXHR8vLNxdadbXaVOfmaEZaWiIVa2qnVFxcZGDSiRSPHe9ojQAKu71iLUMlInHKTbZLHDuHM+NjblUvrsV3qUlbpDevu0yGA4OskqTFLuuBpJrPxCgB9PNm24VUmn/+O2YnWVqiFiM0bSK0sCouNcbt24x/YC4aXZ2UmzEpdGbEuB+WVlhhsSlJZo6JiaY52V0tPJ+6V7Sac7Qr1/nYDUxwX5Vc2DZyo0bTLjW21t9E5CiVAAV91qQz3NmvrLCGevKCmfP7e2uPJ2k5N2L33g+z9loIsGZcD7Pez7xBL1gKpHTfCfm5xlANjvLtkSjboYuhVdqwaVL9GMfGOAKSYtXK02AinulsZZeH8EgxWtpicmtxLc+HC6slBSL7T7S0lqaWSQKNR7n3z12DPjkJymk1RYuqf0KcJM0Hqe/+Ph4bUwvWxEPobExBp9V2m9eUapEY4p7IMCl/fy8+5lEYcpr8V+XQ1INVHqDLpfjzHR93R35PO3Io6P0zx4ZoXtfV9feZqsSgZtK8XtjaO7IZjlgnD5N//RK5kzfjqUl5p65fZsD29NPs9+nTnElUg8CKsFrweDuPYwUpY5pzP/o8XFXGk6OXM4d3kIYyaTLzJhOuwHAW9tSvEy8x04DwfIy75lIuK/RKGekxjCKMhik2WN4mDNX8c9ua6PQl4v0RwpqS8m8VMrlhM/lgM99jiaXhQX+rNysjn6yuMgNyWSSbYzFaE8X01K9BIdlMsDrr3OQUWFXmpTG/K/emsK3XKx1gpjJuFzwUh1IMjzeukUBF0FNp10qXGuZhVCyP7a385D7GMMZ83a2cimwIWkPJN+8DE7eWqdCMMjB4cABzvaTSVYYstYVsh4Y4EDS0lJYyq6SiK/9/DwHsPFxtqG3lwNvNfLM7IZkktGuUnpQUZqUxhT37fD6gq+tcabuFXFjKM6trRTHu3ddVsdMhiL51FP8/VdecVGYra0U2N5emjiyWdpnJeeMtW6QkJWDFKUWIQdc2wKBQjOR5GoPhfg6GOT9ZFWwuko79egoj7U1mj1iMQp+te3W3/8+BV0qXXk3ZUOhwnTI9cb6OuucplLAJz6hwUlKU9OY4v7d7wIffFAoqi0twC/9Es+/9JIr3CApeCMRijtAgUwkXGbHjo7CfPDnz/P3ioXZ73V2nM1SYDY22I5EgqI+OMiff/Ob7tquLv5ccql0dlKYKkkmwwEkHufR0uL87LNZrhRk47eaLpR7RcobPvZYYXEVRWlCGlPcxXwRibgqTF4hHhx0s3XZaN3q9ic2+eVlft/R4fKHfPghZ8zeGXZnp0scNTXF3/WW2YtEXEWejz5ydVhl9RCNugpB3/ymKzgC8B6HDtG8EQrRXNDVVR3vllSKg51Euf7whwwmErq6Cr13Kj2wVJLTp91AryhNTmOK+6c/zaMY588XmgfExi1MTjoTi4ivV0QlCVc26wpde39/ZoaDgrdAdSzmxF0iP2VwaG0ttKU//DDPib0+HC70IKlkkqrFRbZvdZV2czGvfP7zLoukbAD39lYnSVgluXOHq4/JyfpwvVSUKtGY4n6/bK1+JBWSilGqBqe3OIRX4AWx3Rfj4MGdz++FVIr7CeKGubbG48knOWNdXmYgUXc3Nz67uijkMrhUusRfNblxg7nY+/qc6U5R9gn7Q9wrSbUTW2WznIkmErTZyzE5SRGLx2lbBrgiiEQo2NLOgwedy2Yz89FHNK9p1KmyT1FxrzdyOUaXen3oEwluBo+MOI8PwJUb7OhwK4j+fq4cOjq299+uhwCiSvP++8wwOTrK2qr7oc+KsoXGFPf5eYpcJEIRC4frc2YmbpLpNAWmo4O2+8uXXY1XCbI6fJhpArJZN/P22uVFoDo76e0h/d46A29tbXw7+V6RuronTjT/CkVRitCY4n77Nu3GXsJh4Ed/lK9v3KCdWXzIW1v5WvyaEwnnFy8eL4GAE0WJBPUGGgUCzk4/O8trZDM2m+U5saW/8gpNJZmMm1GPj7tZ5LVrzrddCn17I1gvXmR/thPplhbn2aI4xFx14AD3EoaGat0iRakpjSnup07RLVHszSLWQjzOAcDrbhiJAJ/5DF//4AfcdPTS0wN86lN8/eqrzkVS6O/njBngsn993Z0LBikmIu49PTza2lxwktdT4/OfLz6jNEa9Ou6XdJpRpysrzGNTL2kOFKWGNKa4G8MPcDjsluBeHn2URz7vIlC9Xi3HjtEU4o0i9YbKT0w4U4oc3gRfFy4U5qPZKtSnTpVuv+IPiQQH440N5qZXYVcUAI0q7uUiorw182KplLqlCmJItKhSW1ZXKey5HFMabzfQK8o+pbnFXWluZmf59bHHCtNHKIqCkj5ixpg/NcbMGWPeLXHdeWNMzhjzBf+apyjbICUIJybo9qnCrij3UI4D8NcAPLvTBcaYFgC/BeCffGiTohTnxg3g2992G9r1mFZYUeqAkuJurX0ZwGKJy34RwF8BmPOjUYqyLZcuMZ1AT49unCpKCfYcumeMeQDAfwTw1TKu/Yox5g1jzBvz3hJ5irIT1gJvvcXgr7Exl5JZUZSi+BGX/QcA/ou1NlfqQmvtC9bac9bacwe0UIJSLlevMmhtYoIurppOQFFK4oe3zDkAf2Houx0D8JwxJmut/Rsf7q0oTM0g9WgVRSmLPYu7tfawvDbGfA3A36mwK3tmbY2RwKdPMw2DCrui3Bclxd0Y83UAFwHEjDEzAH4NQCsAWGtL2tkV5b65exd4/XWaX5JJTYSmKLugpLhba79Y7s2stT+9p9YoyswMN08jEZb002hgRdkVGqGq1A9SOSkWY4ENnbEryq5RcVfqh8FB4OhRZvxUjxhF2RP6CVJqSzIJfPABfdnDYRbYUGFXlD2jM3eldiwtceM0m2VJPM1jryi+oeKu1Ibbt1k0JRQCHn9chV1RfEbFXak+V67QFNPXx43Trfn2FUXZMyruSvXp72fU6eSk2tcVpUKouCvVYWmJwUkPPsiC4NForVukKE2NirtSeW7cAN59l+aXgwdZd1ZRlIqinzKlcmSzwDvvMOr0wAHgzBkVdkWpEvpJUyqDtcD3vgcsLzMoaWICYOZQRVGqgIq7UhmMoX09FGI6AUVRqoqKu+IfqRSTfo2MMCjpgQdq3SJF2beouCv+8PHHFPZMhjliFEWpKSruyt7IZID33gNu3gS6u4ELF/hVUZSaouKu7I3FRXrDTEwAx45pUJKi1Akq7sr9k0pR1IeHaYL5zGe0qIai1Bkq7kr5WAtMT7sUvbEYC2qosCtK3aHirpTH4iKjTJeXKeqPPKKVkhSljmlMcU8mgVyO9t2WFoqMBshUjmSSAUmhEHD2LF0dFUWpaxpT3D/6CLh+vfBnbW3A5z7H1zMzwMYGiyx3dfFrS0vVm9nQpNN0bxwbY4Wk8+c5Y9fnqCgNQWOK+9gYc4HncjwyGX4V5uaAW7cKf6evj0UhAGB1lYKlZoV7SaeBqSng2jU+0/5+2tTVd11RGorGFPfeXh7FOHMGePRRYG2Nx+pq4fk33+TPIhGmnu3ro4h1dla23fVMJsMiGtevM+HX8DBzwuhmqaI0JI0p7uUQCDCYZruAmpMngXicOcbn5mjGGR0FTp/m+akpin5PT/Pb8rNZl6nxxg3O0CcmtOydojQ4zSvuOxGLFSazWl93rzc26BUCUPSiUc7qR0Y4028GcjnWML1xg6+feoomqqefVlOVojQJ+1Pct+IV7Y4O4JlnWDVIjg8/pMkmEqGZ5/ZtmnKi0cbaYFxaotnlzh3O2Ds7gfFxIJ/nSkeFXVGaBhX37QiFOFMXl7902ol4PA5cusTXxtDs09fH0Pu2ttq0txiZDM1O/f3cQF5bA2ZnaU8fH2e7FUVpSlTcy8Er2mNjwNAQRX5xkcfNm8CJEzx/5QqwsEB7vdj8I5Hq5FzJ5ynmd++yXcvLjCQ9eZIFqWXA0vwvitL0qLjvhtZWYGCAB0ABlY3XQIC5V65do9gCXAk88wxf37xJk0h7O2fToRCPcgU3leKRSHB/YH2dA8nYGP/e66/zXtEoN0YHBpxnkYq6ouwbVNz9wOtRc+QIj3yeZpCVlUIf/Olpzqq9RKPAE0/w9WuvUbDlnvk8zSfiyfPd71LchWDQXRsMAk8+ydWCCrmi7GtU3CtFMVfMxx+nDX9jw83CvZuyXV1cGVjL743hzFx4+GHeOxzm5m8oVHj/nfz/FUXZN6i414K2tuKbr5OTO/+ulq5TFKUMdO2uKIrShKi4K4qiNCEq7oqiKE2IiruiKEoTouKuKIrShKi4K4qiNCEq7oqiKE2IiruiKEoTYqxEQlb7DxszD+DGLn89BmDBx+Y0Atrn/YH2eX+wlz4ftNYeKHVRzcR9Lxhj3rDWnqt1O6qJ9nl/oH3eH1Sjz2qWURRFaUJU3BVFUZqQRhX3F2rdgBqgfd4faJ/3BxXvc0Pa3BVFUZSdadSZu6IoirIDKu6KoihNSF2LuzHmWWPMJWPMFWPMf93mfMgY843N868ZYw5Vv5X+Ukaff9kY874x5m1jzP8zxhysRTv9pFSfPdd9wRhjjTEN7zZXTp+NMf9p871+zxjz59Vuo9+U8b89boz5jjHmB5v/38/Vop1+YYz5U2PMnDHm3SLnjTHmDzefx9vGmDO+NsBaW5cHgBYAVwEcAdAG4C0Ak1uu+QUAX918/RMAvlHrdlehz58G0LH5+uf3Q583r+sC8DKAVwGcq3W7q/A+TwD4AYDo5vcDtW53Ffr8AoCf33w9CeB6rdu9xz5/CsAZAO8WOf8cgH8AYABcAPCan3+/nmfunwBwxVp7zVqbBvAXAJ7fcs3zAP7n5uv/A+BpY7zVqhuOkn221n7HWrux+e2rAEar3Ea/Ked9BoDfBPDbAJLVbFyFKKfPPwvgj621cQCw1s5VuY1+U06fLQApOtwD4HYV2+c71tqXASzucMnzAP7MklcB9Bpjhv36+/Us7g8AuOn5fmbzZ9teY63NAlgG0F+V1lWGcvrs5cvgyN/IlOyzMeY0gDFr7d9Vs2EVpJz3+RiAY8aYfzHGvGqMebZqrasM5fT51wF8yRgzA+DvAfxidZpWM+73835f1HOB7O1m4Fv9Nsu5ppEouz/GmC8BOAfgqYq2qPLs2GdjTADA7wP46Wo1qAqU8z4HQdPMRXB19oox5qS1dqnCbasU5fT5iwC+Zq39XWPMJwH8r80+5yvfvJpQUf2q55n7DIAxz/ejuHeZ9u/XGGOC4FJup2VQvVNOn2GM+SyAXwXwY9baVJXaVilK9bkLwEkALxljroO2yRcbfFO13P/tv7XWZqy1UwAugWLfqJTT5y8D+EsAsNb+K4AwmGCrWSnr875b6lncXwcwYYw5bIxpAzdMX9xyzYsAfmrz9RcAfNtu7lQ0KCX7vGmi+O+gsDe6HRYo0Wdr7bK1NmatPWStPQTuM/yYtfaN2jTXF8r53/4bcPMcxpgYaKa5VtVW+ks5fZ4G8DQAGGNOgOI+X9VWVpcXAfzkptfMBQDL1to7vt291jvKJXabnwNwGdxl/9XNn/0G+OEG+Ob/bwBXAPx/AEdq3eYq9Pn/AvgYwA83jxdr3eZK93nLtS+hwb1lynyfDYDfA/A+gHcA/ESt21yFPk8C+BfQk+aHAJ6pdZv32N+vA7gDIAPO0r8M4OcA/JznPf7jzefxjt//15p+QFEUpQmpZ7OMoiiKsktU3BVFUZoQFXdFUZQmRMVdURSlCVFxVxRFaUJU3BVFUZoQFXdFUZQm5N8ABN4J7MykNZcAAAAASUVORK5CYII=\n", - "text/plain": "" + "image/png": "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\n", + "image/svg+xml": "\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", + "text/plain": "" }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": { - "tags": [] - } - }, - { - "source": [ - "The red errorbar in the graph shows the posterior of the joint space that the ProMP is conditioned with, obtained using inverse kinematics.\n", - "\n", - "### An example combining both Joint Space and Task Space Conditioning." - ], - "cell_type": "markdown", - "metadata": {} - }, - { "source": [ "t = 0\n", "\n", @@ -318,51 +407,36 @@ "plt.plot(domain, mean_margs, 'm-')\n", "plt.title('Joint and Task Space Conditioned Samples for DoF {}'.format(plot_dof))\n", "plt.show()" - ], + ] + }, + { "cell_type": "code", - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": "fun: 8.526433566955966\n hess_inv: array([[ 1.01790925e-03, -1.20597328e-04, -6.83049901e-04,\n -5.64745932e-04, -9.38575355e-04, 1.59759304e-03,\n 9.30550358e-04],\n [-1.20597328e-04, 1.04710165e-03, 5.92392314e-05,\n -9.64291973e-04, -1.60284512e-04, -1.52605910e-04,\n -4.77335945e-04],\n [-6.83049901e-04, 5.92392314e-05, 9.69904532e-04,\n 7.33793011e-04, 1.17219845e-03, -1.62156922e-03,\n -1.06067202e-03],\n [-5.64745932e-04, -9.64291973e-04, 7.33793011e-04,\n 3.39707261e-03, 2.16315241e-03, -3.74044328e-03,\n -8.43452618e-04],\n [-9.38575355e-04, -1.60284512e-04, 1.17219845e-03,\n 2.16315241e-03, 5.51937068e-03, -3.75607916e-03,\n -5.16948474e-03],\n [ 1.59759304e-03, -1.52605910e-04, -1.62156922e-03,\n -3.74044328e-03, -3.75607916e-03, 8.96227655e-03,\n 2.73778708e-03],\n [ 9.30550358e-04, -4.77335945e-04, -1.06067202e-03,\n -8.43452618e-04, -5.16948474e-03, 2.73778708e-03,\n 7.92506940e-03]])\n jac: array([-1.01095865e-06, -3.63066719e-06, -1.45111913e-07, -3.32455895e-06,\n 1.21235033e-07, -1.01830181e-06, 2.07365472e-08])\n message: 'Optimization terminated successfully.'\n nfev: 20\n nit: 14\n njev: 20\n status: 0\n success: True\n x: array([ 1.09105955, 0.57642078, -0.17797006, 1.89303136, -0.14327379,\n -0.14483377, -1.21242533])\n/usr/local/lib/python2.7/dist-packages/autograd/tracer.py:48: RuntimeWarning: covariance is not symmetric positive-semidefinite.\n return f_raw(*args, **kwargs)\n/home/neo/.local/lib/python2.7/site-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in double_scalars\n" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": "" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": { - "tags": [] - } + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { + "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 2.7.17 64-bit", - "name": "python271764bit6cfbe129fb454d00b6793c67f2ece257", - "language": "python" + "display_name": "Python 3", + "language": "python", + "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", "mimetype": "text/x-python", - "nbconvert_exporter": "python", "name": "python", - "file_extension": ".py", - "version": "2.7.17-final", + "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "codemirror_mode": { - "version": 3, - "name": "ipython" - } - }, - "anaconda-cloud": {} + "version": "3.6.9-final" + } }, "nbformat": 4, - "nbformat_minor": 1 -} + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/intprim/examples/promp_example.py b/intprim/examples/promp_example.py index 0bfc189..0cfa554 100644 --- a/intprim/examples/promp_example.py +++ b/intprim/examples/promp_example.py @@ -6,10 +6,15 @@ import numpy as np import matplotlib.pyplot as plt from intprim.util.kinematics import BaseKinematicsClass +import sys -# Load the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz -with open('/home/corobi/playground/intprim_test/strike_mov.npz','rb') as f: +# Download the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz and provide it as an argument while running this file +if len(sys.argv)!=2: + print('Download the sample data from https://github.com/sebasutp/promp/blob/master/examples/strike_mov.npz and provide it as an argument while running this file') + print ('Usage: python promp_example.py /path/to/strike_mov.npz') + +with open(sys.argv[1],'rb') as f: data = np.load(f, allow_pickle=True, encoding='bytes') time = data['time'] Q = data['Q'] @@ -75,18 +80,15 @@ plt.title('Joint Space Conditioned Samples for DoF {}'.format(plot_dof)) plt.show() + q_cond = np.random.choice(Q) q_domain = np.linspace(0, 1, len(q_cond)) -print('len(q_cond):',len(q_cond)) -print('q_cond.shape',q_cond.shape) # Condition the ProMP and obtain the posterior distribution. mu_w_cond_rec, Sigma_w_cond_rec = promp.get_conditioned_weights(q_domain[0], q_cond[0]) -print('det:',np.linalg.det(Sigma_w_cond_rec)) num_observed = 25 for i in range(1, num_observed): mu_w_cond_rec, Sigma_w_cond_rec = promp.get_conditioned_weights(q_domain[i], q_cond[i], mean_w=mu_w_cond_rec, var_w=Sigma_w_cond_rec) -print('det:',np.linalg.det(Sigma_w_cond_rec)) # Plot samples of the conditioned ProMP drawn from the predicted posterior. plt.plot(q_domain[:num_observed],q_cond[:num_observed,plot_dof],'bo', alpha=0.3) plt.plot(q_domain[num_observed:],q_cond[num_observed:,plot_dof],'ro', alpha=0.3) @@ -105,7 +107,6 @@ mean_margs[i] = mu_marg_q[plot_dof] upper_bound[i] = mu_marg_q[plot_dof] + std_q lower_bound[i] = mu_marg_q[plot_dof] - std_q -print('mean_std-Q:',np.mean(std_Q)) plt.fill_between(domain, upper_bound, lower_bound, color = 'b', alpha=0.2) plt.plot(domain, mean_margs, 'b-') plt.title('Joint Space Recursively Conditioned Samples for DoF {}'.format(plot_dof)) diff --git a/intprim/probabilistic_movement_primitives.py b/intprim/probabilistic_movement_primitives.py index 2f32e47..c010d4f 100644 --- a/intprim/probabilistic_movement_primitives.py +++ b/intprim/probabilistic_movement_primitives.py @@ -310,7 +310,9 @@ def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None t = np.array(t) else: # t is scalar t = np.array([float(t)]) - + if var_q is None: + var_q = np.eye(len(mean_q))*1e-7 + basis_funcs = self.basis_model.get_block_diagonal_basis_matrix(t) d,lw = basis_funcs.shape _mean_w, _var_w = self.get_basis_weight_parameters() @@ -320,18 +322,9 @@ def get_conditioned_weights(self, t, mean_q, var_q=None, mean_w=None, var_w=None var_w = _var_w tmp1 = np.dot(var_w, basis_funcs) - tmp2 = np.dot(basis_funcs.T, np.dot(var_w, basis_funcs)) - if var_q is not None: - tmp2 += var_q - else: - tmp2 += np.eye(tmp2.shape[0])*1e-7 - tmp2 = np.linalg.inv(tmp2) - tmp3 = np.dot(tmp1,tmp2) - mean_w = mean_w + np.dot(tmp3, (mean_q - np.dot(basis_funcs.T, mean_w))) - # tmp4 = np.eye(lw) - # if var_q is not None: - # tmp4 -= np.dot(var_q, tmp2) - var_w = var_w - np.dot(tmp3, tmp1.T) + K = tmp1.dot(np.linalg.inv(var_q + basis_funcs.T.dot(tmp1))) + mean_w += K.dot(mean_q - basis_funcs.T.dot(mean_w)) + var_w -= K.dot(basis_funcs.T.dot(var_w)) return mean_w, var_w From 9385fe731d90540466eeb9087dd2a155bc47858f Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Tue, 10 Aug 2021 23:44:12 +0200 Subject: [PATCH 10/14] added single sample spatial conditioning --- intprim/filter/kf.py | 52 ++++++++++++++++++++++++++++++++++++++++ intprim/util/__init__.py | 2 +- 2 files changed, 53 insertions(+), 1 deletion(-) diff --git a/intprim/filter/kf.py b/intprim/filter/kf.py index 4552e45..53e6637 100644 --- a/intprim/filter/kf.py +++ b/intprim/filter/kf.py @@ -159,3 +159,55 @@ def localize(self, measurement, measurement_noise, active_dofs, return_phase_var # Return phase and updated weights and covariance return self.last_phase_estimate, self.state_mean, self.state_cov + + ## + # This method performs localization of space (basis weights) for a single sample and a known phase. + # This is NOT a recursive call, which means it DOES NOT update the internal state estimate based on the given observations. + # In case the internal state needs to be updated, for example when having a fixed ending location or so, it can be done externally from the code making this call. + # For each call, two steps are performed: + # First, the current state is propagated forward in time in what is known as the prediction step. + # $$ \\begin{align} + # \\boldsymbol{\\mu}_{t|t-1} &= + # \\boldsymbol{G}$ + # \\boldsymbol{\\mu}_{t-1|t-1},\\ + # % + # \\boldsymbol{\\Sigma}_{t|t-1} &= \\boldsymbol{G} \\boldsymbol{\\Sigma}_{t-1|t-1} \\boldsymbol{G}^{T} + + # \\boldsymbol{Q}_t, + # \\end{align} $$ + # In practice, the prediction does nothing for spatial filters because basis weights are time invariant. + # + # Next, we integrate the observations into the current state in the update step. + # $$ \\begin{align} + # \\boldsymbol{K}_t &= \\boldsymbol{\\Sigma}_{t|t-1} \\boldsymbol{H}_t^{T} (\\boldsymbol{H}_t \\boldsymbol{\\Sigma}_{t|t-1} \\boldsymbol{H}_t^{T} + \\boldsymbol{R}_t)^{-1},\\ + # % + # \\boldsymbol{\\mu}_{t|t} &= \\boldsymbol{\\mu}_{t|t-1} + \\boldsymbol{K}_t(\\boldsymbol{y}_t - h(\\boldsymbol{\\mu}_{t|t-1})),\\ + # % + # \\boldsymbol{\\Sigma}_{t|t} &= (I - \\boldsymbol{K}_t \\boldsymbol{H}_t)\\boldsymbol{\\Sigma}_{t|t-1}, + # \\end{align} $$ + # + # Lastly, the mean and covariance of the state are returned. + # + # @param measurement Matrix of dimension D containing an observation at a given phase where D is the dimension of the measurement space. + # @param measurement_noise Matrix of dimension D x D containing the measurement noise for the given set of measurements. + # @param measurement_phase The phase for which the current measurement is taken. + # + # @returns Vector of dimension D containing inferred mean, Matrix of dimension D x D containing inferred covariance. + def localize_single(self, measurement, measurement_noise, measurement_phase): + transition_model = self.get_transition_model() + + # Make forward prediction + state_mean = np.dot(transition_model, self.state_mean) + state_cov = np.dot(transition_model, self.state_cov).dot(transition_model.T) + self.get_process_noise() + + measurement_model = self.get_measurement_model(np.array([measurement_phase])) + predicted_measurement = np.dot(measurement_model, state_mean) + + kalman_gain = np.dot(state_cov, measurement_model.T) + kalman_gain = kalman_gain.dot(scipy.linalg.inv(np.dot(measurement_model, state_cov).dot(measurement_model.T) + measurement_noise)) + + state_mean += np.dot(kalman_gain, measurement - predicted_measurement) + + state_cov = (self.identity_cov - np.dot(kalman_gain, measurement_model)).dot(state_cov) + + # Return phase and updated weights and covariance + return state_mean, state_cov diff --git a/intprim/util/__init__.py b/intprim/util/__init__.py index 925f4e1..9da4124 100644 --- a/intprim/util/__init__.py +++ b/intprim/util/__init__.py @@ -1,3 +1,3 @@ from intprim.util.stat_collector import * -import intprim.util.visualization +from intprim.util.visualization import * from intprim.util.kinematics import * From ad050c3604a9a72d2edca2358a4a9ec17e0f124d Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Fri, 20 Aug 2021 00:09:26 +0200 Subject: [PATCH 11/14] Added paper in README --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 8890428..f7bda07 100644 --- a/README.md +++ b/README.md @@ -130,6 +130,8 @@ This library (or variations thereof) has been successfully utilized in the follo [G. Clark, J. Campbell, and H. Ben Amor. Learning Predictive Models for Ergonomic Control of Prosthetic Devices](https://arxiv.org/pdf/2011.07005.pdf) +[Learning Human-like Hand Reaching for Human-Robot Handshaking](https://arxiv.org/abs/2103.00616) + ## Acknowledgements This work was supported in part by the National Science Foundation under grant No. IIS-1749783 and the Honda Research Institute. From 4ab692c80deceb898e73941f7f3c69ecd7d54664 Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Fri, 20 Aug 2021 01:30:13 +0200 Subject: [PATCH 12/14] Bug fixes for EKF --- intprim/basis/basis_model.py | 8 ++++++-- intprim/examples/minimal.py | 7 ++++--- intprim/filter/spatiotemporal/ekf.py | 3 +-- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/intprim/basis/basis_model.py b/intprim/basis/basis_model.py index 7046466..373fea0 100644 --- a/intprim/basis/basis_model.py +++ b/intprim/basis/basis_model.py @@ -34,7 +34,7 @@ def __init__(self, degree, observed_dof_names): # Gets the block diagonal basis matrix for the given phase value(s). # Used to transform vectors from the basis space to the measurement space. # - # @param x Scalar of vector of dimension T containing the phase values to use in the creation of the block diagonal matrix. + # @param x Scalar or vector of dimension T containing the phase values to use in the creation of the block diagonal matrix. # @param out_array Matrix of dimension greater to or equal than (degree * num_observed_dof * T) x num_observed_dof in which the results are stored. If none, an internal matrix is used. # @param start_row A row offset to apply to results in the block diagonal matrix. # @param start_col A column offset to apply to results in the block diagonal matrix. @@ -46,6 +46,8 @@ def get_block_diagonal_basis_matrix(self, x, out_array = None, start_row = 0, st out_array = self.block_prototype basis_funcs = self.get_basis_functions(x) + if np.isscalar(x): + basis_funcs = basis_funcs[:, None] for block_index in range(self._num_blocks): out_array[start_row + block_index * self._degree : start_row + (block_index + 1) * self._degree, start_col + block_index : start_col + block_index + 1] = basis_funcs @@ -67,6 +69,8 @@ def get_block_diagonal_basis_matrix_derivative(self, x, out_array = None, start_ out_array = self.block_prototype basis_funcs = self.get_basis_function_derivatives(x) + if np.isscalar(x): + basis_funcs = basis_funcs[:, None] for block_index in range(self._num_blocks): out_array[start_row + block_index * self._degree : start_row + (block_index + 1) * self._degree, start_col + block_index : start_col + block_index + 1] = basis_funcs @@ -88,7 +92,7 @@ def get_weighted_vector_derivative(self, x, weights, out_array = None, start_row out_array = np.zeros((1, self._degree)) out_row = start_row - basis_func_derivs = self.get_basis_function_derivatives(x[0]) + basis_func_derivs = self.get_basis_function_derivatives(x) # temp_weights = self.inverse_transform(weights) temp_weights = weights diff --git a/intprim/examples/minimal.py b/intprim/examples/minimal.py index 385b64c..a3a93ba 100644 --- a/intprim/examples/minimal.py +++ b/intprim/examples/minimal.py @@ -58,14 +58,15 @@ # Compute the phase mean and phase velocities from the demonstrations. phase_velocity_mean, phase_velocity_var = intprim.examples.get_phase_stats(training_trajectories) - +mean_w, cov_w = primitive.get_basis_weight_parameters() # Define a filter to use. Here we use an ensemble Kalman filter -filter = intprim.filter.spatiotemporal.EnsembleKalmanFilter( +filter = intprim.filter.spatiotemporal.ExtendedKalmanFilter( basis_model = basis_model, initial_phase_mean = [0.0, phase_velocity_mean], initial_phase_var = [1e-4, phase_velocity_var], proc_var = 1e-8, - initial_ensemble = primitive.basis_weights) + mean_basis_weights = mean_w, + cov_basis_weights = cov_w) diff --git a/intprim/filter/spatiotemporal/ekf.py b/intprim/filter/spatiotemporal/ekf.py index a3cf055..03c96f0 100644 --- a/intprim/filter/spatiotemporal/ekf.py +++ b/intprim/filter/spatiotemporal/ekf.py @@ -8,7 +8,6 @@ import intprim.constants from intprim.filter.spatiotemporal import nonlinear_system - ## # The ExtendedKalmanFilter class localizes an interaction in time and space via the extended Kalman filter. # This class is a recursive filter, meaning it maintains state information between successive calls to localize(). @@ -155,7 +154,7 @@ def localize(self, measurement, measurement_noise, active_dofs, return_phase_var self.state_mean[0] = 0.0 measurement_model = self.get_measurement_model(self.state_mean) - predicted_measurement = np.dot(measurement_model[:,self.system_size:], self.basis_model.inverse_transform(self.state_mean[self.system_size:])) + predicted_measurement = np.dot(measurement_model[:,self.system_size:], self.state_mean[self.system_size:]) kalman_gain = np.dot(self.state_cov, measurement_model.T) kalman_gain = kalman_gain.dot(scipy.linalg.inv(np.dot(measurement_model, self.state_cov).dot(measurement_model.T) + measurement_noise)) From 20db5f761bb96b4dca5fa18e93afde87503773cc Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Fri, 20 Aug 2021 01:30:38 +0200 Subject: [PATCH 13/14] Minor changes --- intprim/bayesian_interaction_primitives.py | 2 +- intprim/filter/kf.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/intprim/bayesian_interaction_primitives.py b/intprim/bayesian_interaction_primitives.py index 4e5370b..711253d 100644 --- a/intprim/bayesian_interaction_primitives.py +++ b/intprim/bayesian_interaction_primitives.py @@ -165,7 +165,7 @@ def get_approximate_trajectory(self, trajectory, num_samples = intprim.constants # @return approximate_trajectory Matrix of dimension D x num_samples containing the approximate trajectory. # def get_approximate_trajectory_derivative(self, trajectory, num_samples = intprim.constants.DEFAULT_NUM_SAMPLES): - return get_approximate_trajectory(trajectory, num_samples, deriv = True) + return self.get_approximate_trajectory(trajectory, num_samples, deriv = True) ## # Gets the probability distribution of the trained demonstrations. diff --git a/intprim/filter/kf.py b/intprim/filter/kf.py index 53e6637..6bcd5a5 100644 --- a/intprim/filter/kf.py +++ b/intprim/filter/kf.py @@ -189,10 +189,11 @@ def localize(self, measurement, measurement_noise, active_dofs, return_phase_var # # @param measurement Matrix of dimension D containing an observation at a given phase where D is the dimension of the measurement space. # @param measurement_noise Matrix of dimension D x D containing the measurement noise for the given set of measurements. + # @param active_dofs Vector of dimension \f$ D_o \f$ containing measurement space indices of the observed degrees of freedom. This is not used for this filter but is maintained for API compatibility with the others filters. # @param measurement_phase The phase for which the current measurement is taken. # # @returns Vector of dimension D containing inferred mean, Matrix of dimension D x D containing inferred covariance. - def localize_single(self, measurement, measurement_noise, measurement_phase): + def localize_single(self, measurement, measurement_noise, active_dofs, measurement_phase): transition_model = self.get_transition_model() # Make forward prediction From ecf905ce69dc14215230be3b3819d2236223e9ba Mon Sep 17 00:00:00 2001 From: souljaboy764 <6441764+souljaboy764@users.noreply.github.com> Date: Tue, 24 Aug 2021 12:30:32 +0200 Subject: [PATCH 14/14] Minor changes --- README.md | 2 +- intprim/probabilistic_movement_primitives.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index f7bda07..5a29964 100644 --- a/README.md +++ b/README.md @@ -130,7 +130,7 @@ This library (or variations thereof) has been successfully utilized in the follo [G. Clark, J. Campbell, and H. Ben Amor. Learning Predictive Models for Ergonomic Control of Prosthetic Devices](https://arxiv.org/pdf/2011.07005.pdf) -[Learning Human-like Hand Reaching for Human-Robot Handshaking](https://arxiv.org/abs/2103.00616) +[V. Prasad, R. Stock-Homburg, and J. Peters. Learning Human-like Hand Reaching for Human-Robot Handshaking](https://arxiv.org/abs/2103.00616) ## Acknowledgements diff --git a/intprim/probabilistic_movement_primitives.py b/intprim/probabilistic_movement_primitives.py index c010d4f..6a4cca8 100644 --- a/intprim/probabilistic_movement_primitives.py +++ b/intprim/probabilistic_movement_primitives.py @@ -7,7 +7,7 @@ # @author Vignesh Prasad , TU Darmstadt import intprim.constants import scipy.linalg -import autograd.numpy as np +import numpy as np import pickle import sklearn.preprocessing