From 60f028e25bd6942890f729d3c80b69d833f0daf6 Mon Sep 17 00:00:00 2001 From: mcarfagno Date: Tue, 17 Dec 2019 10:37:32 +0000 Subject: [PATCH] Minor folder structure arranging --- husky_mpc/CMakeLists.txt | 208 ++++++++++++++++++ husky_mpc/package.xml | 74 +++++++ husky_mpc/scripts/cvxpy_mpc.py | 176 +++++++++++++++ husky_mpc/scripts/mpc_node.py | 84 +++++++ husky_mpc/scripts/utils.py | 33 +++ husky_mpc/scripts/utils.pyc | Bin 0 -> 1529 bytes .../MPC_cvxpy-checkpoint.ipynb | 45 +++- MPC_cvxpy.ipynb => notebooks/MPC_cvxpy.ipynb | 16 +- MPC_scipy.ipynb => notebooks/MPC_scipy.ipynb | 0 {img => notebooks/img}/mpc_block_diagram.png | Bin {img => notebooks/img}/mpc_t.png | Bin 11 files changed, 617 insertions(+), 19 deletions(-) create mode 100644 husky_mpc/CMakeLists.txt create mode 100644 husky_mpc/package.xml create mode 100755 husky_mpc/scripts/cvxpy_mpc.py create mode 100755 husky_mpc/scripts/mpc_node.py create mode 100755 husky_mpc/scripts/utils.py create mode 100644 husky_mpc/scripts/utils.pyc rename {.ipynb_checkpoints => notebooks/.ipynb_checkpoints}/MPC_cvxpy-checkpoint.ipynb (63%) rename MPC_cvxpy.ipynb => notebooks/MPC_cvxpy.ipynb (64%) rename MPC_scipy.ipynb => notebooks/MPC_scipy.ipynb (100%) rename {img => notebooks/img}/mpc_block_diagram.png (100%) rename {img => notebooks/img}/mpc_t.png (100%) diff --git a/husky_mpc/CMakeLists.txt b/husky_mpc/CMakeLists.txt new file mode 100644 index 0000000..d3ea737 --- /dev/null +++ b/husky_mpc/CMakeLists.txt @@ -0,0 +1,208 @@ +cmake_minimum_required(VERSION 2.8.3) +project(husky_mpc) + +## Compile as C++11, supported in ROS Kinetic and newer +# add_compile_options(-std=c++11) + +## Find catkin macros and libraries +## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz) +## is used, also find other catkin packages +find_package(catkin REQUIRED COMPONENTS + geometry_msgs + nav_msgs + roscpp + rospy + std_msgs +) + +## System dependencies are found with CMake's conventions +# find_package(Boost REQUIRED COMPONENTS system) + + +## Uncomment this if the package has a setup.py. This macro ensures +## modules and global scripts declared therein get installed +## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html +# catkin_python_setup() + +################################################ +## Declare ROS messages, services and actions ## +################################################ + +## To declare and build messages, services or actions from within this +## package, follow these steps: +## * Let MSG_DEP_SET be the set of packages whose message types you use in +## your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...). +## * In the file package.xml: +## * add a build_depend tag for "message_generation" +## * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET +## * If MSG_DEP_SET isn't empty the following dependency has been pulled in +## but can be declared for certainty nonetheless: +## * add a exec_depend tag for "message_runtime" +## * In this file (CMakeLists.txt): +## * add "message_generation" and every package in MSG_DEP_SET to +## find_package(catkin REQUIRED COMPONENTS ...) +## * add "message_runtime" and every package in MSG_DEP_SET to +## catkin_package(CATKIN_DEPENDS ...) +## * uncomment the add_*_files sections below as needed +## and list every .msg/.srv/.action file to be processed +## * uncomment the generate_messages entry below +## * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...) + +## Generate messages in the 'msg' folder +# add_message_files( +# FILES +# Message1.msg +# Message2.msg +# ) + +## Generate services in the 'srv' folder +# add_service_files( +# FILES +# Service1.srv +# Service2.srv +# ) + +## Generate actions in the 'action' folder +# add_action_files( +# FILES +# Action1.action +# Action2.action +# ) + +## Generate added messages and services with any dependencies listed here +# generate_messages( +# DEPENDENCIES +# geometry_msgs# navigation_msgs# std_msgs +# ) + +################################################ +## Declare ROS dynamic reconfigure parameters ## +################################################ + +## To declare and build dynamic reconfigure parameters within this +## package, follow these steps: +## * In the file package.xml: +## * add a build_depend and a exec_depend tag for "dynamic_reconfigure" +## * In this file (CMakeLists.txt): +## * add "dynamic_reconfigure" to +## find_package(catkin REQUIRED COMPONENTS ...) +## * uncomment the "generate_dynamic_reconfigure_options" section below +## and list every .cfg file to be processed + +## Generate dynamic reconfigure parameters in the 'cfg' folder +# generate_dynamic_reconfigure_options( +# cfg/DynReconf1.cfg +# cfg/DynReconf2.cfg +# ) + +################################### +## catkin specific configuration ## +################################### +## The catkin_package macro generates cmake config files for your package +## Declare things to be passed to dependent projects +## INCLUDE_DIRS: uncomment this if your package contains header files +## LIBRARIES: libraries you create in this project that dependent projects also need +## CATKIN_DEPENDS: catkin_packages dependent projects also need +## DEPENDS: system dependencies of this project that dependent projects also need +catkin_package( +# INCLUDE_DIRS include +# LIBRARIES husky_mpc +# CATKIN_DEPENDS geometry_msgs navigation_msgs roscpp rospy std_msgs +# DEPENDS system_lib +) + +########### +## Build ## +########### + +## Specify additional locations of header files +## Your package locations should be listed before other locations +include_directories( +# include + ${catkin_INCLUDE_DIRS} +) + +## Declare a C++ library +# add_library(${PROJECT_NAME} +# src/${PROJECT_NAME}/husky_mpc.cpp +# ) + +## Add cmake target dependencies of the library +## as an example, code may need to be generated before libraries +## either from message generation or dynamic reconfigure +# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS}) + +## Declare a C++ executable +## With catkin_make all packages are built within a single CMake context +## The recommended prefix ensures that target names across packages don't collide +# add_executable(${PROJECT_NAME}_node src/husky_mpc_node.cpp) + +## Rename C++ executable without prefix +## The above recommended prefix causes long target names, the following renames the +## target back to the shorter version for ease of user use +## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node" +# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "") + +## Add cmake target dependencies of the executable +## same as for the library above +# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS}) + +## Specify libraries to link a library or executable target against +# target_link_libraries(${PROJECT_NAME}_node +# ${catkin_LIBRARIES} +# ) + +############# +## Install ## +############# + +# all install targets should use catkin DESTINATION variables +# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html + +## Mark executable scripts (Python etc.) for installation +## in contrast to setup.py, you can choose the destination +# install(PROGRAMS +# scripts/my_python_script +# DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +# ) + +## Mark executables for installation +## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html +# install(TARGETS ${PROJECT_NAME}_node +# RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +# ) + +## Mark libraries for installation +## See http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html +# install(TARGETS ${PROJECT_NAME} +# ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} +# LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} +# RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION} +# ) + +## Mark cpp header files for installation +# install(DIRECTORY include/${PROJECT_NAME}/ +# DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION} +# FILES_MATCHING PATTERN "*.h" +# PATTERN ".svn" EXCLUDE +# ) + +## Mark other files for installation (e.g. launch and bag files, etc.) +# install(FILES +# # myfile1 +# # myfile2 +# DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION} +# ) + +############# +## Testing ## +############# + +## Add gtest based cpp test target and link libraries +# catkin_add_gtest(${PROJECT_NAME}-test test/test_husky_mpc.cpp) +# if(TARGET ${PROJECT_NAME}-test) +# target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME}) +# endif() + +## Add folders to be run by python nosetests +# catkin_add_nosetests(test) diff --git a/husky_mpc/package.xml b/husky_mpc/package.xml new file mode 100644 index 0000000..a4c6bc6 --- /dev/null +++ b/husky_mpc/package.xml @@ -0,0 +1,74 @@ + + + husky_mpc + 0.0.0 + The husky_mpc package + + + + + marcello + + + + + + TODO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + catkin + geometry_msgs + nav_msgs + roscpp + rospy + std_msgs + geometry_msgs + nav_msgs + roscpp + rospy + std_msgs + geometry_msgs + nav_msgs + roscpp + rospy + std_msgs + + + + + + + + diff --git a/husky_mpc/scripts/cvxpy_mpc.py b/husky_mpc/scripts/cvxpy_mpc.py new file mode 100755 index 0000000..666f7a9 --- /dev/null +++ b/husky_mpc/scripts/cvxpy_mpc.py @@ -0,0 +1,176 @@ +import numpy as np +from scipy.integrate import odeint +from scipy.interpolate import interp1d +import cvxpy as cp + +def get_linear_model(x_bar,u_bar): + """ + """ + + # Control problem statement. + + N = 5 #number of state variables + M = 2 #number of control variables + T = 20 #Prediction Horizon + dt = 0.25 #discretization step + + x = x_bar[0] + y = x_bar[1] + theta = x_bar[2] + psi = x_bar[3] + cte = x_bar[4] + + v = u_bar[0] + w = u_bar[1] + + A = np.zeros((N,N)) + A[0,2]=-v*np.sin(theta) + A[1,2]=v*np.cos(theta) + A[4,3]=v*np.cos(-psi) + A_lin=np.eye(N)+dt*A + + B = np.zeros((N,M)) + B[0,0]=np.cos(theta) + B[1,0]=np.sin(theta) + B[2,1]=1 + B[3,1]=-1 + B[4,0]=np.sin(-psi) + B_lin=dt*B + + f_xu=np.array([v*np.cos(theta),v*np.sin(theta),w,-w,v*np.sin(-psi)]).reshape(N,1) + C_lin = dt*(f_xu - np.dot(A,x_bar.reshape(N,1)) - np.dot(B,u_bar.reshape(M,1))) + + return A_lin,B_lin,C_lin + +def calc_err(state,path): + """ + Finds psi and cte w.r.t. the closest waypoint. + + :param state: array_like, state of the vehicle [x_pos, y_pos, theta] + :param path: array_like, reference path ((x1, x2, ...), (y1, y2, ...), (th1 ,th2, ...)] + :returns: (float,float) + """ + + dx = state[0]-path[0,:] + dy = state[1]-path[1,:] + dist = np.sqrt(dx**2 + dy**2) + nn_idx = np.argmin(dist) + + try: + v = [path[0,nn_idx+1] - path[0,nn_idx], + path[1,nn_idx+1] - path[1,nn_idx]] + v /= np.linalg.norm(v) + + d = [path[0,nn_idx] - state[0], + path[1,nn_idx] - state[1]] + + if np.dot(d,v) > 0: + target_idx = nn_idx + else: + target_idx = nn_idx+1 + + except IndexError as e: + target_idx = nn_idx + + path_ref_vect = [np.cos(path[2,target_idx] + np.pi / 2), + np.sin(path[2,target_idx] + np.pi / 2)] + + #heading error w.r.t path frame + psi = path[2,target_idx] - state[2] + + # the cross-track error is given by the scalar projection of the car->wp vector onto the faxle versor + #cte = np.dot([dx[target_idx], dy[target_idx]],front_axle_vect) + cte = np.dot([dx[target_idx], dy[target_idx]],path_ref_vect) + + return target_idx,psi,cte + +def optimize(starting_state,u_bar,track); + ''' + :param starting_state: + :param u_bar: + :param track: + :returns: + ''' + + MAX_SPEED = 1.25 + MIN_SPEED = 0.75 + MAX_STEER_SPEED = 1.57/2 + + N = 5 #number of state variables + M = 2 #number of control variables + T = 20 #Prediction Horizon + dt = 0.25 #discretization step + + #Starting Condition + x0 = np.zeros(N) + x0[0] = starting_state[0] + x0[1] = starting_state[1] + x0[2] = starting_state[2] + _,psi,cte = calc_err(x0,track) + x0[3]=psi + x0[4]=cte + + # Prediction + x_bar=np.zeros((N,T+1)) + x_bar[:,0]=x0 + + for t in range (1,T+1): + xt=x_bar[:,t-1].reshape(5,1) + ut=u_bar[:,t-1].reshape(2,1) + + A,B,C=get_linear_model(xt,ut) + + xt_plus_one = np.squeeze(np.dot(A,xt)+np.dot(B,ut)+C) + + _,psi,cte = calc_err(xt_plus_one,track) + xt_plus_one[3]=psi + xt_plus_one[4]=cte + + x_bar[:,t]= xt_plus_one + + #CVXPY Linear MPC problem statement + cost = 0 + constr = [] + x = cp.Variable((N, T+1)) + u = cp.Variable((M, T)) + + for t in range(T): + + # Tracking + if t > 0: + idx,_,_ = calc_err(x_bar[:,t],track) + delta_x = track[:,idx]-x[0:3,t] + cost+= cp.quad_form(delta_x,10*np.eye(3)) + + # Tracking last time step + if t == T: + idx,_,_ = calc_err(x_bar[:,t],track) + delta_x = track[:,idx]-x[0:3,t] + cost+= cp.quad_form(delta_x,100*np.eye(3)) + + # Actuation rate of change + if t < (T - 1): + cost += cp.quad_form(u[:, t + 1] - u[:, t], 25*np.eye(M)) + + # Actuation effort + cost += cp.quad_form( u[:, t],1*np.eye(M)) + + # Constrains + A,B,C=get_linear_model(x_bar[:,t],u_bar[:,t]) + constr += [x[:,t+1] == A*x[:,t] + B*u[:,t] + C.flatten()] + + # sums problem objectives and concatenates constraints. + constr += [x[:,0] == x_sim[:,sim_time]] # starting condition + constr += [u[0, :] <= MAX_SPEED] + constr += [u[0, :] >= MIN_SPEED] + constr += [cp.abs(u[1, :]) <= MAX_STEER_SPEED] + + # Solve + prob = cp.Problem(cp.Minimize(cost), constr) + solution = prob.solve(solver=cp.ECOS, verbose=False) + + #retrieved optimized U and assign to u_bar to linearize in next step + u_bar=np.vstack((np.array(u.value[0, :]).flatten(), + (np.array(u.value[1, :]).flatten()))) + + return u_bar \ No newline at end of file diff --git a/husky_mpc/scripts/mpc_node.py b/husky_mpc/scripts/mpc_node.py new file mode 100755 index 0000000..f60dedb --- /dev/null +++ b/husky_mpc/scripts/mpc_node.py @@ -0,0 +1,84 @@ +#! /usr/bin/env python + +import rospy +import numpy as np + +from nav_msgs.msg import Odometry + +from geometry_msgs.msg import Twist + +from utils import compute_path_from_wp +from cvxpy_mpc import optimize + +# classes +class Node(): + + def __init__(self): + + rospy.init_node('mpc_node') + + N = 5 #number of state variables + M = 2 #number of control variables + T = 20 #Prediction Horizon + dt = 0.25 #discretization step + + # State for the robot mathematical model + self.state = None + + # starting guess output + self.opt_u = np.zeros((M,T)) + self.opt_u[0,:] = 1 #m/s + self.opt_u[1,:] = np.radians(0) #rad/s + + # Interpolated Path to follow given waypoints + self.path = compute_path_from_wp([0,20,30,30],[0,0,10,20]) + + self._cmd_pub = rospy.Publisher(rospy.get_namespace() + 'husky_velocity_controller/cmd_vel', Twist, queue_size=10) + self._odom_sub = rospy.Subscriber(rospy.get_namespace() +'husky_velocity_controller/odom', Odometry, self._odom_cb, queue_size=1) + + def run(self): + while 1: + if self.state is not None: + + #optimization loop + self.opt_u = optimize(self.state, + self.opt_u, + self.path) + + msg = Twist() + msg.linear.x=self.opt_u[0,1] + msg.angular.z=self.opt_u[0,1] + + self._cmd_pub(msg) + + def _odom_cb(self,odom): + ''' + Updates state with latest odometry. + + :param odom: nav_msgs.msg.Odometry + ''' + + state = np.zeros(3) + + # Update current position + state[0] = odom.pose.pose.position.x + state[1] = odom.pose.pose.position.y + + # Update current orientation + _, _, state[2] = euler_from_quaternion( + [odom.pose.pose.orientation.x, + odom.pose.pose.orientation.y, + odom.pose.pose.orientation.z, + odom.pose.pose.orientation.w]) + + self.state = state + +def main(): + ros_node=Node() + try: + ros_node.run() + except rospy.exceptions.ROSException as e: + sys.exit(e) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/husky_mpc/scripts/utils.py b/husky_mpc/scripts/utils.py new file mode 100755 index 0000000..c978f42 --- /dev/null +++ b/husky_mpc/scripts/utils.py @@ -0,0 +1,33 @@ +import numpy as np +from scipy.integrate import odeint +from scipy.interpolate import interp1d +import cvxpy as cp + +def compute_path_from_wp(start_xp, start_yp, step = 0.1): + """ + Interpolation range is computed to assure one point every fixed distance step [m]. + + :param start_xp: array_like, list of starting x coordinates + :param start_yp: array_like, list of starting y coordinates + :param step: float, interpolation distance [m] between consecutive waypoints + :returns: array_like, of shape (3,N) + """ + + final_xp=[] + final_yp=[] + delta = step #[m] + + for idx in range(len(start_xp)-1): + section_len = np.sum(np.sqrt(np.power(np.diff(start_xp[idx:idx+2]),2)+np.power(np.diff(start_yp[idx:idx+2]),2))) + + interp_range = np.linspace(0,1,section_len/delta) + + fx=interp1d(np.linspace(0,1,2),start_xp[idx:idx+2],kind=1) + fy=interp1d(np.linspace(0,1,2),start_yp[idx:idx+2],kind=1) + + final_xp=np.append(final_xp,fx(interp_range)) + final_yp=np.append(final_yp,fy(interp_range)) + + dx = np.append(0, np.diff(final_xp)) + dy = np.append(0, np.diff(final_yp)) + theta = np.arctan2(dy, dx) diff --git a/husky_mpc/scripts/utils.pyc b/husky_mpc/scripts/utils.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15af75ad231d0e8ecb4131bbb0cc298bef2b411b GIT binary patch literal 1529 zcmbtUPmdcl6n~ycve|43R4Qs=L2_@YwAu)ItEy574shASazIL1jm(TEad*b!+Ri2; zB^Q=2QN9UZi7Oufe)c5YU7+HCGk*5_>)(6NPWs2a(Ww3XBB$L*u)f4}-+~nQ7*#|w z7WWBN3DqghQer`uQq`lnPqTiQ9Wb3B%S0zA2>A zzT<~Muf4S9i(>xk+c19nDo-K(0CR--HKzL+&U2z|8flL<32pnde#|^#GTIPb11O_M zSiZS9WZMDxgkGnS_9E>^ItaEK&;b<*J$xM861qUP;^XQmvscl=DL8k~=RAe^pqDW&VQ1AC8b6f?PR|6>PqsJXk*ShKvw#t)$VR4A&G@Bl24wVoIQ!iRd^>Vyhepd zz6Wxtba6I03Tz)FmfD9$Qb~=z5@{1zx2&VRdt-gHG|fudC@NH0;&#GCX=g+(&)>aA zVT{y;KY&u$94+~B5*}Z)-Z$VD)0*xKG%ZR?l)XZaZZR+kI15>M5rL^Eg+$7A%%^PQ0rpE zpDvc}vdwCfM-E-7+^K2(1NiMOX=a39WTkEDY-PfKllv5eMgxXl@;Uo4`6QXLY4V7D zmK?KVHaUbgg3-&`wC5p9{~?IWm1$2yI&+Ilcn%Ty`*#%9gsZcwdvMIJ)<6>y%+2{R emYdxEUxGu#dR{lhvXU=Cmt7Ey*+=+|lfMAFXliQ! literal 0 HcmV?d00001 diff --git a/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb b/notebooks/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb similarity index 63% rename from .ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb rename to notebooks/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb index 59c10ef..db4ff85 100644 --- a/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb +++ b/notebooks/.ipynb_checkpoints/MPC_cvxpy-checkpoint.ipynb @@ -291,8 +291,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.51 ms, sys: 390 µs, total: 4.9 ms\n", - "Wall time: 4.39 ms\n" + "CPU times: user 3.81 ms, sys: 0 ns, total: 3.81 ms\n", + "Wall time: 3.75 ms\n" ] } ], @@ -390,8 +390,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1.31 ms, sys: 5.59 ms, total: 6.91 ms\n", - "Wall time: 2.05 ms\n" + "CPU times: user 404 µs, sys: 4.79 ms, total: 5.19 ms\n", + "Wall time: 1.54 ms\n" ] } ], @@ -819,8 +819,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 329 ms, sys: 173 ms, total: 502 ms\n", - "Wall time: 281 ms\n" + "CPU times: user 304 ms, sys: 195 ms, total: 499 ms\n", + "Wall time: 288 ms\n" ] } ], @@ -984,7 +984,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -993,6 +993,13 @@ "text": [ "/home/marcello/.local/lib/python3.5/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in true_divide\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CVXPY Optimization Time: Avrg: 0.2550s Max: 0.3976s Min: 0.2298s\n" + ] } ], "source": [ @@ -1001,6 +1008,7 @@ " [0,0,2.5,2.5,0,0,5,10])\n", "\n", "sim_duration =100 \n", + "opt_time=[]\n", "\n", "x_sim = np.zeros((N,sim_duration))\n", "u_sim = np.zeros((M,sim_duration-1))\n", @@ -1027,6 +1035,8 @@ "\n", "for sim_time in range(sim_duration-1):\n", " \n", + " iter_start=time.time()\n", + " \n", " # Prediction\n", " x_bar=np.zeros((N,T+1))\n", " x_bar[:,0]=x_sim[:,sim_time]\n", @@ -1057,10 +1067,16 @@ " idx,_,_ = calc_err(x_bar[:,t],track)\n", " delta_x = track[:,idx]-x[0:3,t]\n", " cost+= cp.quad_form(delta_x,10*np.eye(3))\n", + " \n", + " # Tracking last time step\n", + " if t == T:\n", + " idx,_,_ = calc_err(x_bar[:,t],track)\n", + " delta_x = track[:,idx]-x[0:3,t]\n", + " cost+= cp.quad_form(delta_x,100*np.eye(3))\n", "\n", " # Actuation rate of change\n", " if t < (T - 1):\n", - " cost += cp.quad_form(u[:, t + 1] - u[:, t], 5*np.eye(M))\n", + " cost += cp.quad_form(u[:, t + 1] - u[:, t], 25*np.eye(M))\n", " \n", " # Actuation effort\n", " cost += cp.quad_form( u[:, t],1*np.eye(M))\n", @@ -1085,22 +1101,29 @@ " \n", " u_sim[:,sim_time] = u_bar[:,0]\n", " \n", + " # Measure elpased time to get results from cvxpy\n", + " opt_time.append(time.time()-iter_start)\n", + " \n", " # move simulation to t+1\n", " tspan = [0,dt]\n", " x_sim[:,sim_time+1] = odeint(kinematics_model,\n", " x_sim[:,sim_time],\n", " tspan,\n", - " args=(u_bar[:,0],))[1]\n" + " args=(u_bar[:,0],))[1]\n", + " \n", + "print(\"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(np.mean(opt_time),\n", + " np.max(opt_time),\n", + " np.min(opt_time))) " ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/MPC_cvxpy.ipynb b/notebooks/MPC_cvxpy.ipynb similarity index 64% rename from MPC_cvxpy.ipynb rename to notebooks/MPC_cvxpy.ipynb index 403a9bd..db4ff85 100644 --- a/MPC_cvxpy.ipynb +++ b/notebooks/MPC_cvxpy.ipynb @@ -984,7 +984,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -998,7 +998,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CVXPY Optimization Time: Avrg: 0.2452s Max: 0.2904s Min: 0.2282s\n" + "CVXPY Optimization Time: Avrg: 0.2550s Max: 0.3976s Min: 0.2298s\n" ] } ], @@ -1076,7 +1076,7 @@ "\n", " # Actuation rate of change\n", " if t < (T - 1):\n", - " cost += cp.quad_form(u[:, t + 1] - u[:, t], 5*np.eye(M))\n", + " cost += cp.quad_form(u[:, t + 1] - u[:, t], 25*np.eye(M))\n", " \n", " # Actuation effort\n", " cost += cp.quad_form( u[:, t],1*np.eye(M))\n", @@ -1111,19 +1111,19 @@ " tspan,\n", " args=(u_bar[:,0],))[1]\n", " \n", - "print(\"CVXPY Optimization Time: Avrg: {:0.4f}s Max: {:0.4f}s Min: {:0.4f}s\".format(np.mean(opt_time),\n", - " np.max(opt_time),\n", - " np.min(opt_time))) " + "print(\"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(np.mean(opt_time),\n", + " np.max(opt_time),\n", + " np.min(opt_time))) " ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABDAAAALICAYAAACJhQBYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xl0XPd52P3vbwACBAmSIAguIEiRhERam5fYlvc0cuyocmLVUtP3xq5T1n6dumGbxF1yUneJnCqpnTQ5VXy6OHVRN4LrmL2xm9eR40R2vMQJRTGR5VWWqIWiuBMEiI0ACZKY3/vHDCiQBEgsM3MHg+/nHJwZzNy597mXJDjz4Pk9T4gxIkmSJEmSVM1yWQcgSZIkSZJ0PSYwJEmSJElS1TOBIUmSJEmSqp4JDEmSJEmSVPVMYEiSJEmSpKpnAkOSJEmSJFU9ExiSJEmSJKnqmcCQJEmSJElVzwSGJEmSJEmqevVZBzAPMesAJEmStGCFrAOoEN8zS1oorvtzeSEnMDh27FjFj9nW1kZvb2/Fj7tYeH3Ly+tbXl7f8vL6lpfXt7y8vuU12+u7cePGMkZTfebynrmW/87W8rlBbZ9fLZ8b1Pb5Xe/cZvpz2SUkkiRJkiSp6pnAkCRJkiRJVc8EhiRJkiRJqnomMCRJkiRJUtUzgSFJkiRJkqqeCQxJkiRJklT1KjpGNUmSTwHvBHrSNL29+NhvA/cA54HngfenaTpQybgkSZIkSVJ1q3QFxu8Dd1/x2FeA29M0fQXwDPCvKxyTJEmSJEmqchVNYKRp+k3g9BWPfTlN04vFbx8DNlUyJkmSJEmSVP0quoRkBv5f4P9M92SSJB8EPgiQpiltbW2ViuuS+vr6TI67WHh9y8vrW15e3/Ly+paX17e8vL7l5fWVpMWhahIYSZL8W+Ai8JnptknT9JPAJ4vfxt7e3kqEdpm2tjayOO5i4fUtL69veXl9y8vrW15e3/Ly+pbXbK/vxo0byxiNJKlcqiKBkSTJ+yg093xbmqYx43AkSZIkXUfM54lf/iM4M3TN7cIr7iDsuL1CUUmqZZknMJIkuRv4FeDH0jQdzToeSZIkSTPw4nPEzz8E9fWQm6a13nie+NUvkvvnDxB23FbZ+CTVnEqPUf0scCfQliTJEeAjFKaONAJfSZIE4LE0TX++knFJkiRJmp148FkAcr/x3wlr1k69zZkh8r/1r8j/198g9yu/Rei4oZIhSqoxFU1gpGn6nike/p+VjEGSJElSCRx8DlasgtbpG6iG5pXkPvRr5H/zV8h//NfI/ZvfJrSsqWCQkmpJRceoSpIkSaoN8eCzsHU7IYRrbhfa1pP7pY/AwGniX/xZhaKTVItMYEiSJEmalXjuLBw/Qthy04y2Dzd0wvqNxCMvljkySbXMBIYkSZKk2Tl0AGKesHX7zF/TcQMcPViuiCQtAiYwJEmSJM1KfPG5wp2tM6vAAAgdW6H3JHHsXHmCklTzTGBIkiRJmp2Dz8LqNsKq1TN+SejYAjHCscNlDExSLTOBIUmSJGlW4sHnYIb9Ly7p2FJ4rctIJM2RCQxJkiRJMxZHz0DPMcIslo8AsHY9NDTAURt5SpobExiSJEmSZu7F5wGYVQNPIOTqoP0GogkMSXNkAkOSJEnSjMWDzxbuzLYCg2IfDBMYkubIBIYkSZKkGYsHn4W1GwjLV8z+xR1bYGiAODxY+sAk1TwTGJIkSZJm7sXnCbNt4FkUNhUaeXLkYOnikbRomMCQJEmSNCMxn4eBvkJDzrnYWJxEcuxQCaOStFiYwJAkSZI0M6NnYHwcVrbM7fWrVkPzCvtgSJoTExiSJEmSZmZooHC7cvWcXh5CgI6tRJeQSJoDExiSJEmSZqaYwAhzrcAAwsYb4NjhwnIUSZoFExiSJEmSZiQO9hfuzCOBwaYtMHYW+npKE5SkRcMEhiRJkqSZGZ5YQjKPCowNmwt3Th4rQUCSFhMTGJIkSZJmZmgA6upgWfPc97F6DQBx8HSJgpK0WJjAkCRJkjQzQwOwYhUhN4+PES2thdv+vtLEJGnRMIEhSZIkaUbi0OCcJ5BMCEsaYPkKsAJD0iyZwJAkSZI0M0MD82vgOaGllThgAkPS7JjAkCRJkjQzQwPzGqF6SUurS0gkzZoJDEmSJEnXFWMsWQVGaFnjEhJJs1afdQCSJEnSYpckyaeAdwI9aZrePsXz7wX+FRCAYWBXmqbfrWiQo2dg/GLJlpAwOEAcHyfU1c1/f5IWBSswJEmSpOz9PnD3NZ5/AfixNE1fDvw68MlKBHWZoYHCbUkSGGsg5mF4YP77krRomMCQJEmSMpam6TeBaddUpGn6aJqm/cVvHwM2VSSwyYoJjFL0wAiXRqm6jETSzLmERJIkSVpYPgD86XRPJknyQeCDAGma0tbWNusD1NfXX/W6c0+PMwis3rKN+jnsc7ILWzs5DazIX2DpPPc1W1OdWy2p5fOr5XOD2j6/Up2bCQxJkiRpgUiS5K0UEhhvmW6bNE0/yUtLTGJvb++sj9PW1saVr8sfPQxA/ziEOexzskih78XQoYOcufHWee1rtqY6t1pSy+dXy+cGtX1+1zu3jRs3zmg/JjAkSZKkBSBJklcAXcA70jSt/AzSoQHI5WB58/z3tXJVYV8DLiGRNHP2wJAkSZKqXJIkNwD/F/gHaZo+k0kQQwOwooWQm/9HiJCrg5WrYbDyeRhJC5cVGJIkSVLGkiT5LHAn0JYkyRHgI8ASgDRNfw+4H1gD/LckSQAupmn62krGGAf7YVUJJpBMaGkl2sRT0iyYwJAkSZIylqbpe67z/M8BP1ehcKY2NFCaEaoTWtbAqeOl25+kmucSEkmSJEnXNzxAWFG6BEZoaYV+l5BImjkTGJIkSZKuKcZYhgqMVhg9Qzw/Vrp9SqppJjAkSZIkXdvZEbh4sfRLSMBJJJJmzASGJEmSpGsbGijcljCBEVa3Fu6YwJA0QyYwJEmSJF1bMYERVq0u3T5XFSow4qAJDEkzYwJDkiRJ0jXFwdJXYNBSrMCwkaekGTKBIUmSJOnayrCEhGXLoaEBrMCQNEMmMCRJkiRd29AA5HKwfEXJdhlCgFWOUpU0cyYwJEmSJF3b8ACsWEXIlfjjw+o19sCQNGMmMCRJkiRdUxwqJDBKLViBIWkWTGBIkiRJuraRM9C8svT7Xb0GBk8TYyz9viXVHBMYkiRJkq5tZBiWN5d+v6tWw/nzcHa09PuWVHNMYEiSJEm6tpFhQgkbeF4yMdVkeLD0+5ZUc0xgSJIkSZpWjLGwhKQMCYywopjAmBjTKknXYAJDkiRJ0vTGzsH4xbIkMC5VYJjAkDQDJjAkSZIkTW9kuHBbjh4YxckmcdgEhqTrM4EhSZIkaXrFBEZZemCsWAUhWIEhaUZMYEiSJEma3siZwm05emDU1RX2awJD0gyYwJAkSZI0vUtLSMpQgQGwYhXRKSSSZsAEhiRJkqRpxTNl7IEBhUaeVmBImgETGJIkSZKmV84mnkAwgSFphkxgSJIkSZre6BloaCQsaSjP/le2gEtIJM2ACQxJkiRJ0xsZhuYy9b+AwiSSs6PEC+fLdwxJNcEEhiRJkqRpxTPDsKyMCYyVLYVbl5FIug4TGJIkSZKmN3KmfA08KfbAABhyGYmkazOBIUmSJGl6I8PlG6EKVmBImjETGJIkSZKmN3qGUO4eGEAc6i/fMSTVBBMYkiRJkqYUY4Qzw2VdQnKpAsNJJJKuwwSGJEmSpKmNnYPxi2VdQhIaGmFpk0tIJF2XCQxJkiRJUxs5U7hdVsYKDCgsI7ECQ9J1mMCQJEmSNLWRYQBC88ryHmdlC9EKDEnXYQJDkiRJ0tSKCYyy9sAAWNHiEhJJ12UCQ5IkSdLULiUwyjiFBAgrW1xCIum6TGBIkiRJmlKc6IFR7gqMlS1wZog4Pl7e40ha0ExgSJIkSZpahSowWLkKYoQzQ+U9jqQFzQSGJEmSpKmNDENDI2FJQ1kPE1a2FO4M2wdD0vRMYEiSJEma2shw+asvoNDEE2zkKemaTGBIkiRJmlIcOVP+/hdQWEICjlKVdE0mMCRJkiRN7UyFKjAmlpAMOYlE0vRMYEiSJEmaWqWWkDQth/p6l5BIuiYTGJIkSZKmNnqGUIElJCGEQh8MExiSrsEEhiRJkqSrxBgrV4EBsLKFOOwSEknTM4EhSZIk6Wpj5+Dixco08QRYtRpOn6rMsSQtSCYwJEmSJF1t5EzhtkIVGOGGTjh+hDh2riLHk7TwmMCQJEmSdLWRYQBCpRIYW7dDzMOhAxU5nqSFxwSGJEmSpKsVExgV64GxdTsA8eCzlTmepAXHBIYkSZKkq11KYFSmB0ZYtRpa2+CFZypyPEkLT30lD5YkyaeAdwI9aZreXnysFfg/wFbgIJCkadpfybgkSVrMTp7M8TM/U89//s851q3LZx2OpCoRK9wDA4CtO6zAkDStSldg/D5w9xWPfRj4apqm24GvFr+XJEkV8ru/28yjjwYefLBCkwYkXSVJkk8lSdKTJMkPpnn+5iRJ9iZJMpYkyS9XJKgzQ4Xb5solMMLW7XDqBHHi2JI0SUUTGGmafhM4fcXD7wIeKt5/CLi3kjFJkrRYdXa209Gxke7uZvL5QHd3Mx0dG+nsbM86NGkx+n2u/kXfZKeBXwJ+pyLRAAwPwtImwpKGih0ybCv0weDgcxU7pqSFo6JLSKaxPk3T48X7J4D1022YJMkHgQ8CpGlKW1tbBcK7XH19fSbHXSy8vuXl9S0vr295eX1Lb//+C3z4w3V84Qs5zp4NNDVF3vWuPL/1W+Ne6xLz72951cL1TdP0m0mSbL3G8z1AT5IkP1WxoIYHYcWqih0OgC03QQjEg88Qbn91ZY8tqepVQwLjkjRNY5Ik8RrPfxL4ZPHb2NvbW5nAJmlrayOL4y4WXt/y8vqWl9e3vLy+pbdkCSxZsopz55axdGnk3Dn42tcip0+fpr7eXhil5N/f8prt9d24cWMZo8leKX7pV19fz5KzI8Q1a2mtcHKot2MLdccOsbpMx62FhNe11PL51fK5QW2fX6nOrRoSGCeTJGlP0/R4kiTtQE/WAUmStFj09ubYuXOEX/iFRn72ZyP79y/hwQeb+djHXH8uLVSl+KVfW1sb50/3wtr2iiff8pu3Mf7ktzl16hQhhJLvv9YTirV8frV8blDb53e9c5tpYrkaxqj+MfAPi/f/IfCFDGORJGlR6erqZ/fu5dxxxxL2728A7IUhqWhogLCywktIALbtgKEB6K/ND3KS5q6iCYwkST4L7AVeliTJkSRJPgD8JvATSZI8C7y9+L0kSaqQvXtP8u53j9PUVFg20tSU5777RnnssZMZRyYpK3F8HM4Mw8qWih87bJ1o5Ok4VUmXq+gSkjRN3zPNU2+rZBySJOkl69fnWbECzp0LNDZGzp0L1NdHdu1azSc+0c+6dfbDkMqt+Iu+O4G2JEmOAB8BlgCkafp7SZJsAB4HVgL5JEn+GXBrmqZlWe8Vhwch5ivfxBNg0zaoqye+8Czh1W+q/PElVa1q6IEhSZIy1tMDO3eO8N73jvKZzyzj619v5PDhevthSBVyjV/0TTx/AthUoXDID/YX7qzIoAJjyRLYuJl4+EDFjy2pupnAkCRJpOk4vb1DdHa2Mzb2UtO87u5murubaWyMHDhw/Bp7kFRLJhIYmfTAAMKmbcQffjuTY0uqXtXQxFOSJFWJvXtPcu+9o/bDkBa58cHThTsZ9MAAYPM2GOwnDg1kc3xJVckEhiRJuqTQDyNe1g9jz56GrMOSVGFxYGIJSVYVGFsLd468kMnxJVUnExiSJOkyvb05du4c4eGHT7FjxwV6eup48MHmrMOSVEH5wX7I5WBZRv/2N28DIB4+mM3xJVUle2BIkqTLdHX109nZzkMPvfTBxV4Y0uIyPtgPK1oIuWx+3xmaV0LLGiswJF3GCgxJknSVK3thLF0aWbNmnC9+8VTGkUmqhPxgf2bLRy7ZvI142ASGpJeYwJAkSVe5uhcG9PXl+PSnl2UdmqQKiIP9kNEEkglh01Y4cYR44UKmcUiqHiYwJEnSlHp7c4RAcaxq4au7u5mOjo10drZnHZ6kMsoP9hOqoAKD8XE4fjjbOCRVDRMYkiRpSl1d/Tz+uGNVpcVofOB0diNUi8KmYiNP+2BIKjKBIUmSpjXVWNX6+siuXavp6fFthFSL4tg5GDsHK7JNYLC+HRoawEkkkop85yFJkq5p8ljVnTtH2LevgX37GhytKtWqoYHCbdY9MHJ1sHGLFRiSLnGMqiRJuqaurn4AOjvbi/0wChytKtWoYgIjZLyEBCBs3kb89l5ijIQQrv8CSTXNCgxJkjQjV45WtR+GVKOGBwu3WTfxBNi0Fc4Mw8DprCORVAVMYEiSpBmZqh/Gnj0NWYclqcTipQRGFVRgFBt54jISSZjAkCRJszC5H8aOHRfo6amzF4ZUa6qkBwYA7ZsAiD0nMg5EUjWwB4YkSZqxrq5+Ojvbeeihl5IW9sKQaszwIGHZcsKSKqiwal4JDY3Q51I1SVZgSJKkWbIXhlTjhgbIrVqddRQAhcada9YR+3qyDkVSFTCBIUmSZsVeGFJti8ODVZPAAGDNOug1gSHJBIYkSZoDe2FINWxogNyq1qyjuCS0rQMrMCRhAkOSJM1BV1c/u3cv56671rF/fwMQ6O5upqNjI52d7VmHJ2k+qrECY2SYeHY060gkZcwEhiRJmhN7YUi1J+bH4cxQlSUw1hdurcKQFj0TGJIkaU6m6oVRXx/ZtWs1PT2+xZAWpDPDECO5lupJYIS2dYU70yQw4sljxIHTFYxIUlZ8dyFJkuZsci+MnTtH2LevgX37GuyHIS1UQwMAVdUDgzWFBEacopFnvHCe/H/8MPmP//tC9YikmlafdQCSJGnh6urqB6Czs52xsXDp8e7uZrq7m2lsjBw4cDyr8CTN1sgZCLnqWkKyYhU0NMDpKRIYe79eSLoMDRAf+wbhTW/LIEBJlWIFhiRJmjf7YUi1IbzsdnK/93mW3PKKrEO5JIQAreuuqsCI+TzxK1+AGzph63bi//cZ4thYRlFKqgQrMCRJ0rxN1Q9jz56GrMOSyipJku4ZbjqWpuk/KmswJRRydYS6uqzDuNxUo1S//y04cYTwc/+SsHoN+d/+N8Q//wLhp5JsYpRUdlZgSJKkkpjcD2PHjgv09NTZC0O17meA52fw9TNZBVgrwpp10Hd5RVf+y38ErWsJr3kzYcft8MrXEf/s88RiHw9JtccKDEmSVBJdXf10drbz0EMvJS3shaEadzhN039/vY2SJHlPJYKpaWvWw5lh4rlRwtJlxBeehWd+QEg+QKgvfKTJ/fT7yH/kF4hf/iPC33t/xgFLKgcrMCRJUsnYC0OLSZqmN81wu5vLHUvNuzRK9RQA8WtfhKZlhLf8xKVNQvsmwqvfSPzml4nnzmYRpaQyM4EhSZJKxl4YUkGSJJ1JkmzNOo5aEYqjVOntIZ47S3ziUcIdP0poWnb5dj/xLjg7Qtzz1QyilFRuJjAkSVJJ2QtDi1GSJJ9NkuRNxfvvB54EnkyS5APZRlYjihUYse8k8Ym9cH6M8Ma3XrVZuPFmuPFm4lf/mJgfr3SUksrMBIYkSSqprq5+du9ezl13rWP//gYg0N3dTEfHRjo727MOTyqXtwGPF+//C+DtwOuAD2cWUS1Z0QJLGqCvh/jY12HtBrjxlik3zf3Eu+DUCfjOX1c4SEnlZgJDkiSV3FS9MN7xjrPcdtt5enp8+6Ga1JCm6fkkSTqA1jRN96Rp+iSwPuvAakEIAdasJT73FDz9PcIb7iw8NpVXvQHWrCP/lS9UNkhJZec7CEmSVHJT9cJ4/vk6vv3tBpeTqFZ9J0mSfw38KvAnAMVkxlCmUdWSNevgwH6IkfCGq5ePTAh1dYS33wPP/ZB49FAFA5RUbiYwJElSWUz0wsjnIcbAM880EKPLSVSzPgC8HGgC/l3xsTcCn8ksohoT1hSLWW68mbDu2j8/wq0/AkA8fKDcYUmqoPqsA5AkSbWpq6sfgA996AwPPLCSRx5ZytmzOZqa8tx99znuv99fTGvhS5Lk54AvpWn6PPD3Jz+XpunngM9lElgtKjbyDG/88etvu7YdQg5OHClzUJIqyQSGJEkqK0erqsa9FvjVJEn6KSwd+RLwaJqmMduwak+45ZXE7bcS7njL9bddsgTWrocTRysQmaRKcQmJJEkqO0erqlalafrzaZpuAf4BhX4XHwNOFMeq/mySJG3ZRlg7wtbt1P3KbxKWzfBnx/oOohUYUk2xAkOSJJVdV1c/nZ3tPPTQSx88urub6e5uprExcuDA8Qyjk+YvTdPvA98HfitJklXA3wZ+EvjtJEleBD6SpukjWca42IT2TcSnv0fMjxNydVmHI6kETGBIkqSK2Lv3pL0wtCikaToIpMUvkiS5I9uIFqkNm+DCeeg7BWs3ZB2NpBIwgSFJkirCXhiqdUmS/CjwI8BlaxzSNP1oNhEtbmF9BxHg5FETGFKNsAeGJEmqGHthqFYlSfKfKUwc+VvALZO+bs4yrkWtfROAfTCkGmIFhiRJqhh7YaiGvRe4PU3TY1kHoqLmlbCs2UkkUg2xAkOSJFXU3r0nuffeUZqa8gA0NeW5775RHnvsZMaRSfNyGBjLOgi9JIQA7ZuIJjCkmmEFhiRJqqipemHU10d27VrNJz7Rz7p1+axDlObiA8D/SJLks8Bl2bg0Tb+ZTUgK6zuIT3476zAklYgJDEmSVHETvTDe+95RPvOZZXz9640cPlzPgw8287GPOZVEC9JrgHdQ6IFxdtLjEbghk4hUmETy6FeJZ0cJTcuyjkbSPJnAkCRJFdfV1Q9AZ2c7Y2Ph0uP2w9AC9lHgnjRN/zzrQPSSsKE4ieTEUdi2PetwJM2TPTAkSVJm7IehGjICuFSk2mxwEolUS6zAkCRJmZmqH8aePQ1ZhyXNxf3A7yZJ8gDQM/mJNE2v29glSZJPAe8EetI0vX2K5wPwceAngVHgfWmaPlGKwGva2vWQyzmJRKoRVmBIkqRMTfTDePjhU+zYcYGenjoefLD5+i+UqsungJ8HjgIXil8Xi7cz8fvA3dd4/h3A9uLXB4FPzDXQxSTUL4G17VZgSDXCBIYkScpUV1c/u3cv56671rF/fwMQ6O5upqNjI52d7VmHJ83UtuJX56Svie+vqzip5PQ1NnkX0J2maUzT9DGgJUkS/4HMxIYOOGkFhlQLXEIiSZIyt3fvSR54YCWPPLKUs2dzNDXlufvuc9x/vxNJtDCkafpimQ/RARye9P2R4mNXdbtNkuSDFKo0SNOUtra2WR+svr5+Tq+rRsPbtjP65LdZs3o1oa6ups5tKrV8frV8blDb51eqczOBIUmSMmcvDC1ESZL8epqmvzqD7f59mqYfqURMAGmafhL4ZPHb2NvbO+t9tLW1MZfXVaP8qla4eIHe/U8S1m2sqXObSi2fXy2fG9T2+V3v3DZu3Dij/ZjAkCRJVWGiF8Z73zvKL/5iC/v3L+HBB5v52MeswlDV+mfF5pvhOtv9EjDfBMZRYPOk7zcVH9N1hPbNhVGqx4/Aupl9SJJUnUxgSJKkqtDV1U9nZzsPPfRSA8/u7ma6u5tpbIwcOHBVpbyUteXAc1w/gXGuBMf6Y+AXkiTZDbweGEzT1H8UM9FeyPvE44cJr3xdxsFImg8TGJIkqWrYC0MLSZqmJWuInyTJZ4E7gbYkSY5QqNhYUjzO7wFfojBC9TkKY1TfX6pj17qwbDmsaoVjh6+/saSqZgJDkiRVjal6YdTXR3btWs0nPtHPunX5rEOUyiJN0/dc5/kI/NMKhVN72jc5SlWqAY5RlSRJVWWiF8bDD59i584R9u1rYN++Bh58sPn6L5akKYT2TXD8MDHGrEORNA9WYEiSpKrS1dUPQGdnO2NjL7UWsB+GpDlrvwHOnYWB07B2bdbRSJojKzAkSVJV2rv3JPfeO0pTU2HZSFNTnvvuG+Wxx05mHJmkhSa0byrcOX4o20AkzYsVGJIkqSpN1Q9jz56GrMOSppUkSTPQAgykaXom63g0yaVJJPbBkBYyExiSJKlqTfTDeO97R/nFX2xh//4lPPhgMx/7mFNJVB2SJLkd+MfATwFbKIxUjUmSHAT+FPjvaZp+P7sIBcDKFli2HI47iURayFxCIkmSqlZXVz+7dy/nrrvWsX9/AxDo7m6mo2MjnZ3tWYenRS5Jkt3AHwDHgZ8F2oCG4u0/AI4CnylupwyFEKB9sxUY0gJnBYYkSapqe/ee5IEHVvLII0s5ezbH0qWR5cvz7N7dl3Vo0v9O0/SLUzzeDzxa/PpYkiTvrGxYmkpo30z87l9nHYakebACQ5IkVbWre2FAX1+OT396WdahaZGbnLxIkuT1U22TJMnrpklyqNLaN8HwIPmhwawjkTRHJjAkSVLV6+3NEQLFsaqFL5eSqMp8ZZrH/6yiUWhaodjI8+KRg9kGImnOXEIiSZKqXldXPydP5i5bStLUlOfuu89x//029FR2kiTJUcyqJUkykWGbcCNwMZPAdLUNhVGqF48chHUd2cYiaU6swJAkSQvCVGNV6+sju3atpqfHtzTKzEXgPLCseP/CpK8fAv8tu9B0mTXroKGBcSswpAXL/+0lSdKCMTFW9eGHT7Fz5wj79jWwb18DDz7YnHVoWry2Uai0OAJ0TvraBqxM0/TXsgtNk4VcDjZscgmJtIC5hESSJC0YXV39AHR2thf7YRR0dzfT3d1MY2PkwIHjWYWnRShN0xeLd7dkGohmpm094z3+jJAWKiswJEnSgrN370nuvXeUpqY8AE1Nee67b5THHjuZcWRaTJIk+U9Jkmy4zjYbkiT5T5WKSdcWVrWS73cEs7RQWYEhSZIWnKn6YezZ05B1WFp89gN/nSTJU8BfFL8fBlYAO4A7gZcBv5FVgLpCSytxZJg4NkZobMw6GkmzZAWGJElakCb3w9ix4wI9PXX2wlBFpWn63yn0v/gfxdt/BfwX4Fco9MH4PeCmNE27MgtSl1vVWrgdPJ1tHJLmxAoMSZK0IHV19dPZ2c5DD72UtLAXhiotTdMLwOeKX6pyoaV2A+1vAAAgAElEQVSVCDDYD+vasw5H0ixZgSFJkhYse2GoWiRJ8rtJktyRdRy6jpZCBUYcsAJDWoiswJAkSQuWvTBURQLwhSRJRoA/AP4gTdP9GcekK61aXbgdtJGntBBZgSFJkhY0e2GoGqRp+iFgE/BPgM3AY0mSfCtJkn+RbWS6zPIVUL8EBvqzjkTSHFiBIUmSFjR7YahapGmaB74CfCVJkl8F/hfw24BjVKtECIFcaxvRJp7SglQ1CYwkSf458HNABL4PvD9N03PZRiVJkhaCvXtP8sADK3nkkaWcPZujqSnP3Xef4/77h7IOTYtIkiTLgfuA91AYofoXwD/MMiZdrW71Gi7YA0NakKpiCUmSJB3ALwGvTdP0dqAOeHe2UUmSpIXCXhjKWpIkfwicBD4IfBHYkqbpT6Zp+r+zjUxXyrW2FaaQSFpwqiKBUVQPNCVJUg8sA45lHI8kSVpA7IWhjP0NcGuapn8rTdNPpGnam3VAmlqutQ2swFAVyP/xZ4kvPJt1GAtKiDFmHQMASZJ8CPgPwFngy2mavneKbT5IIatNmqavOX/+fGWDBOrr67l48WLFj7tYeH3Ly+tbXl7f8vL6lletXN9Vq5Zw7ly46vGlSyODgxcyiKigVq5vtZrt9W1oaIDC1JDFIB47NvvfC7a1tdHbW5s5mKa/+BJn/vfvkfsvf0hobMw6nJKr5T+7Wjq3ePIY+X/384Q3v43c+z4E1Nb5Xel657Zx40aYwc/lquiBkSTJauBdwDZgAPjDJEl+9sqSuzRNPwl8svhtzOIPt5b/UlUDr295eX3Ly+tbXl7f8qqV6/voo7lpe2H09uYzi6tWrm+1mu31Lb5R1iKVW91WuDN4Gta1ZxuMFq34/b8p3B5+4fLH+/uIe79GeNs9hMalWYRW1aplCcnbgRfSND2VpukF4P8Cb8o4JkmStMBM1Qujvj6ya9dqenqq5W2PpCzlWosJDJeRKEPxe48X7hw7RLz4UoVg/NoXiX/0afL/8cPE/r6Moqte1fI/+SHgDUmSLEuSJABvA57KOCZJkrQATe6FsXPnCPv2NbBvX4P9MCQBhSkkANFGnspIPHcWnnkS1qyDixfhxJGXnjuwH1rWwMnj5D/6L4kvPp9hpNWnKhIYaZruAz4HPEFhhGqOl5aKSJIkzVhXVz8f/egQ99yzloceaubQoSXEGOjubqajYyOdnZaMS4tZrnVt4c6gv91WRp76LoxfJNz9dwGIhw4UbscvwsFnCa95E7kP/yaEHPlPPZhlpFWnKnpgAKRp+hHgI1nHIUmSasPevSen7YchafEKzSugfolLSJSZ+P3HoWkZ4c1vJ/7hp6DYB+PioQNwfgy27SBs2kZ489uIf/KHxAvnCUscDQ5VUoEhSZJUalP1w9izxzeA0mIXQoBVq8ElJMpAjLGQwLj1VYWkRMfWS408L+x/EoDQ+bLCxhs2QczDydlPEqpVJjAkSVLNmtwPY8eOC/T01NkLQxK0tBKtwFAWDh+AgdOEl98BQNjcCYcPEGPkwjNPwopV0La+8Fz7ZgDi8SPT7m6xMYEhSZJqVldXP7t3L+euu9axf38DYC8MSUBLq0tIlImJ6SPh5a8uPHBDJ4yOwOlTXHjmB9D5skKVEMCGDggBjh/OKNrqYwJDkiTVtL17T3LvvaM0NeUBWLo0smbNOF/84qmMI5OUlbCq1SUkykR8+nuw5SbCytUAhM3bCo8/9V3Gjx4i3HjzpW1DQ2NhUskJKzAmmMCQJEk17epeGNDXl+PTn16WdWiSstLSCmdHiGPnso5Ei83pU4QNHS9937EVQo74zUeASf0vJrRvdgnJJCYwJElSzevtzRECjI0FoPDlUhJpEVtV+O03gy4jUeXEGKG/F1a3XXosNDbC+o3wwjOQy8GWmy57TdjQASePEvPjlQ63KpnAkCRJNa+rq5/HH798KUlTU5777hvlscdOZhydpEoLLa2FOwMuI1EFDQ/CxYuwes1lD4cbOgGov+FGwtKmy1/TvhkunIc+lz2CCQxJkrRITDVWtb4+smvXanp6fEskLSqrCh8goxUYqqT+PgDCpAoMAIp9MJbsuO2ql4T2TYU7NvIETGBIkqRFZPJY1Z07R9i3r4F9+xocrSotNi3FJSROIlEl9fcWbq+swNhcqMBY8rKrExg4SvUy9VkHIEmSVCldXYVy8c7O9mI/jILu7ma6u5tpbIwcOHA8q/AkVcqyZmhogNO9WUeiRSQWKzC4sgLj5lcQ/v4/Zumb387I8PBlT4XlK2DFKieRFFmBIUmSFp0rR6vaD0NaXEII0LGVeOj5rEPRYtLfC3V1hYTEJKGujtxbf6rQ0HMq7ZuJLiEBTGBIkqRFaKp+GHv2NGQdlqQKClu3w4vPO91BldPfBy1rCLnZfQwP7Zvg+JHCFJNFzgSGJElalCb3w9ix4wI9PXX2wpAWk63bYewsHD+adSRaJGJ/71X9L2ZkwyYYPQPDA6UPaoExgSFJkhalrq5+du9ezl13rWP//gYg0N3dTEfHRjo727MOT1KZhW3bAYgHn804Ei0a/X1XTyCZgVBs5ImNPE1gSJKkxcteGNIitr4DljaBCQxVQIwRBuZYgVEcpWofDBMYkiRpEbMXhrR4hVwOttxUdRUYMUbyj36VODJ8/Y21cIyegfPn55bAWN0GjU1WYGACQ5IkLXL2wpAWr7D1JjjyAvHihaxDecmh54n/6+PEr38p60hUSv2Fkb1zWkISAmzeRnzhmVJHteCYwJAkSYuavTCkxSts2wEXL8KRg1mHckn8wROF22d/mHEkKqn+vsJtyxwqMIBw0y1w6ADx/FgJgyqtODZGPPwC8UL5EoL1ZduzJEnSArF370keeGAljzyylLNnczQ15bn77nPcf/9Q1qFpEUmS5G7g40Ad0JWm6W9e8fwW4FPAWuA08LNpmlpTPh9bX2rkGYr3sxZ/+J3CneefJo6PE+rqsg1IJRGLFRjMoQIDCgmM+Gefh4PPwY7bShhZCR18hvzv/FtyH/o1uP3VZTmEFRiSJGnRm6oXRn19ZNeu1fT0+HZJ5ZckSR3wX4F3ALcC70mS5NYrNvsdoDtN01cADwAfq2yUNah1LaxYBS9URx+MeG4Unn8K1m4ojHg98kLWIalU+vsg5GDV6rm9vvNmAOLzT5UwqNKKxw4V7nRsKdsx/B9ZkiSJy3th7Nw5wr59Dezb12A/DFXK64Dn0jQ9kKbpeWA38K4rtrkV+Frx/teneF6zFEKArdurp5Hn09+H8XHCPe8BID77ZMYBqWRO98Kq1XOuqAkrVsKGDuJz1ZvA4OiL0LQcWlrLdggTGJIkSRR6YXz0o0Pcc89aHnqomUOHlhCj/TBUMR3A5BmJR4qPTfZd4O8W798HrEiSZG4L6nVJ2HoTHD9CPHc261CIP/w2NDQSXvsWaFtvH4waEvvnOEJ1knDjLYWlRfl8iaIqrXjsEHTcUEgMlok9MCRJkiaxH4aq2C8D/yVJkvcB3wSOAuNXbpQkyQeBDwKkaUpb2+zX3NfX18/pdQvBlec29srXMvDwblYN9tKw6UcyjAx6n/4edS9/Davb2xm8/dWMPbGXNWvWzOoD4WL6s1tIeocGqL9hGy3XiP9653f2Va9jaM+fs3pslPrNW8sQ5dzFGDl1/DBL3/TjrJziHEr1Z2cCQ5IkaZKp+mHs2dOQdViqfUeBzZO+31R87JI0TY9RrMBIkqQZ+Ok0TQeu3FGapp8EPln8Nvb29s46mLa2NubyuoXgynOLKwrl7gNPP0lu/ebpXlZ28dQJ8sePkP+xd9Db20v+hhuJ3/hTep/8LmHDphnvZzH92S0UMUbyvSfJ3/yKa8Z/vfOL6wt/D04//ii5pupa3hgHThPPDHOudT3npziH653bxo0bZ3Qcl5BIkiRdYXI/jB07LtDTU2cvDJXb3wDbkyTZliRJA/Bu4I8nb5AkSVuSJBPv3/81hYkkmq+WVqhfAj3HMw0jPvltAMJthSqQsL3Qw9VlJDXg7CiMnZvzBJJLNnRA84pCo9dqU2zgGTaWNwloAkOSJOkKXV397N69nLvuWsf+/Q2AvTBUXmmaXgR+AXgEeKrwUPpkkiQPJEnyd4qb3QnsT5LkGWA98B8yCbbGhFwO1m4gnqqCBMaadbC+2PpkfUdhQoqNPBe+/r7C7Xx7YIQAN95CfO7pEgRVWvHYi4U7ZZxAAi4hkSRJmpK9MFRpaZp+CfjSFY/dP+n+54DPVTquRWFde+YVGDz/FOHlr73U7yKEANtvtQKjFvQXlk6E1vn3gAg33kL87l8ThwcJK1bNe38lc+wwNK8krGwp62GswJAkSZqCvTCkxSOs3QCnThBjzOT48cwQDA9Cxw2Xx7X9Vug9STy98Po+6CWxmMCY9xISINx4c+FOlS0jiUdfhI03XH/DeTKBIUmSNA17YUiLxLp2OD8Gg/3ZHP9EoV/rlc06w82vACA+9Z2Kh6QSmlhCsmr1/Pe1bTvU1xOfrXwCIw4PEb/1KPH73yI++0Pi+bHC4zHC8cOEjvInMFxCIkmSNI2urn46O9t56KGXkhbd3c10dzfT2Bg5cCDjknNJJRHWbiACnDpRaOpZYfHEkcKdK6eNdGyFVa3wgyfgzW+veFwqkYE+WNlCqF8y712FJQ2wbQcxg94o8U/+D/GrD7/0wI7byP3yRwtLZM6OWoEhSZKUtb17T3LvvaM0NeUBaGrKc999ozz22MmMI5NUMusKzXljVn0wThyF+npoW3fZwyEEwu0/Qvzhd4jj49nEpnmL/b0lWT4yIWy/HV58jnjubMn2OROx9yRs6CD34f9IeOfPwDNPFpJrRycmkJS3gSeYwJAkSbqmqXph1NdHdu1aTU+Pb6WkmtC6DnI5yGgSSTxxBNZtJOTqrn7yttfA6Bk4+GzlA1Np9PfNewLJZGHHbZDPw4EKTyMZOA1tGwg33kz4qQTWrCP/hc9MmkBiBYYkSVLmJvfC2LlzhH37Gti3r8F+GFKNCPX1hRGmWVZgXLl8pCjc+koIOeIPnqhwUCqZ/j5CCRMY3PgyyOWIz1R4GcnAaUJxiVWoX0K45z2FSpCv/QmsaiUsX1H2EOyBIUmSdB1dXYXGfp2d7YyNhUuP2w9DqiFrNxBPnaj4YePFi9B7gvCaN0/5fFi+Ajp3EJ98At719yscneYrjp0rVNC0lLACY+kyuOHGivbBiOPjMDRwWY+Y8IY7iX/6OTh5FG55ZUXisAJDkiRphq7sh7F0aWTNmnG++MVTGUcmab7CuvZsKjBOnYDxcdjQMe0m4bZXw8FnicODFQxMJTExgaSEPTCguIzkwDPEC+dLut9pDQ1AzF+WiAl1dYR73l24X4EGnmACQ5Ikacau7ocBfX05Pv3pZVmHJmm+1m6A0TPEkeHKHrc4geTKEaqThdtfDTESfzj3carx4gXi0Rcr3vhx0evvBSjtEhIgbL8NLl6AFyrUG2XgdOG4V0zpCXe8hfC37yO86W0VCcMEhiRJ0iz09uYIgeJSksJXd3czHR0b6exszzo8SXMUipNI6KnsMpKXRqhOX4HBlpugeWVh4sNs9//4XzH+6/+c/C/+DPlf+0Xi539/boFqTmLxg3+pKzDYfmth/5VaRjJYrCS5MoGRqyP3995PuKGzImGYwJAkSZqFrq5+Hn/c0apSzVlbHKVa6UkkJ45CSyuhafpKrpDLEW79EeKTT8x6nGr+z/8YBvsJb/s7sHkb8bmn5huxZqNYgVHKHhhQ7I3SsaVijTxjfzERU+LzmC0TGJIkSbM01WjVPXsasg5L0ny0bSjcVrgPRjxxBNZfo/qiKLzmjTA8CE/NfBlJzOfhyEHCa95E7u+9j/DyO+DYIeL5sfmErNno74NlzYTGxpLvOuy4DZ5/atZJrTkZOF0YNbxiZfmPdQ0mMCRJkuZg8mjVHTsu0NNT51hVaQELjY2F8vgKTiKJMcKJI4T26ftfXPLyO2BZM3HvN2Z+gN4TMHYONm8DIGy9CfJ5OPzCnOLV7MX+Xihx/4sJYcfthT/f558uy/4vM9gHK1cTcnXlP9Y1mMCQJEmag66ufnbvXs5dd61j//4G7IUh1YB17cRKVmAMD8LoCFyjgeeEsGQJ4XU/SvzOXuLZ0Zntv5ioCJuL/Qm23AhAPPT8nMLVHAycLn3/iwm3vxqWNBAf/6vy7H+S2H+6bImY2TCBIUmSNEdXjlW1F4a0sIW1GypagTGTCSSThTe8Fc6fJz7x6Iy2j4deKJT9b9xceGB1G6xYBS8+N6dwNQf9vSWfQDIhLF0Gr3gt8Vt7iPkyLyMZPA2rWq+/XZmZwJAkSZqjqXph1NdHdu1aTU+Pb7OkBWdtOwyeJo6dq8jhZjSBZLLOlxWqRPZ+fWb7P3wA2jcTlhR69IQQYMuNxIMmMCohXrwAQwNlbXyZu+NHC8fY/4OyHQOAgdNXjVDNgv+zSpIkzcPkXhg7d46wb18D+/Y12A9DWoDC+o2FOyePVeaAx49CQ8OMlxiEEAhvfCvs/z6xr+f6Lzj8AqHY/+LSPrbcBMcP28izEi6NUC3j0ovbXwuNS4l/85dlO0Q8PwYjw1eNUM2CCQxJkqR56Orq56MfHeKee9by0EPNHDq0hBjthyEtSMVKiHjyaEUOF08dh7XthNzMP5aF199ZeO1j37j2voeHYKDvUgPPS6/fYiPPihnoAyCUqwcGheaz4ZWvJz6xl3jxYnkOMthfuM14hCqYwJAkSSoJ+2FINWDdRggBTlQmgUFfD7Stn9VLwtoNsON24l9++dofWI8UG3huujyBcamRp30wyi72FxIY5W5+Ge54S6FC4qnvlucAxUoSl5BIkiTViKn6YezZ05B1WJJmITQ0QuvaS801y66vh9C6dtYvy911L/T1EB+fftlAPHygcOeKCoyXGnk6iaTs+nsLt+We3nHbq6FpedmWkcRiJYlLSCRJkmrI5H4YO3ZcoKenzl4Y0kKzoYNYgQqMOHoGzo5C27rZv/jlr4WNNxD/9PPEfH7qbQ6/AC1rCCtWXfZwoZHnTVZgVEJ/HzQuhablZT1MWLKE8KrXE7+zjzhehmkkE708XEIiSZJUO7q6+tm9ezl33bWO/fsbgEIvjMbGBnthSAtE2LAJTh4lxljeA/WdKhxvzewTGCGXI9z903DsEHz/W1NuEw+/cHX1xcTrt9wIxw4Tx2zkWVb9fYUkUgjlP9bLXwtnR+Dgs6Xf98BpWNIAy8qbiJkJExiSJEklNFUvjHe/e9xeGNJCsaEDxs4VPnyWU1/xZ0LrHCowgHDHj0LrWvJ/9rmrnosXzsOJI1dNILn02i03Qcxf6pOh8ogDfeVfPlIUbn4FhEB86jul3/lAH7S0ViYRcx0mMCRJkkpoql4Y3/iGb7mkhSKsL0wiocyTSGKxAoM1s++BARDq6wl33QfPPUV85snLnzx2GMbHp01gsGlrIYZjh+Z0bM1Qfy+hUgmMFSthcyexDI0848BpWJV9/wswgSFJklRyV/bCOHECe2FIC0X7JgBiuRt59vVAQ0OhoeYchbf8BKxsIf+5/3VZL4z4/FOFO5s7p37hytWF2zNDcz62ri3mxwtLL8o4QvVK4ZZXwvP7iefOlnbHA6crloi5HhMYkiRJJTZdL4yOjo32wpCq3apWaGwq+yjV2HcKWtfNqyw/NDYS/p/3wwvPEP/yywCM954kfuEPYOt2WLth2tfR0GACo5yGBiGfr2jjy3DrK2H8Ijz75PU3nqEYY2EJiRUYkiRJtWuqXhj33TdqLwypyoUQipNIKlCBMcflI5OF198JL3s58f92Ewf7Gfz4r8P4RXL/6F8Sctf4uNe8EoZNYJRNsYdKRSsXbroV6pcQf1jCZSRnR+H8WFWMUAUTGJIkSWUxuRfG0qWF2/r6yK5dq+np8S2YVM3Cho6yV2DQ10NYs37euwkhkHvvz8PYWfIf/WUu/OAJwnv+MWHdxmu/sHklcWR43sfXNAaKTWAr+ME/NDTC9ltL28hzcGKEqgkMSZKkmjbRC+Mv//IiO3eOsG9fA/v2NdgPQ6p2GzbB6VNlGzMax84Vlm+UoAIDILRvJtx1L5w+ReOb30Z4049f/0XNK11CUkZx4trOo8fJXIRbXglHXyQO9pdmhwOFBEao4FKYa6nPOgBJkqRa1dVVeAN5443tnDu35NLj3d3NdHc309gYOXDgeFbhSZpG2NBBhMIkkhumaYQ5H309hds1cxuhOpXwzndD6zpW/uTf5fTo9Zs4huUriL0uaSubM8XqluUrKnrYcMsriUB86ruEN9w57/3FU8X/o1or14z0WqzAkCRJKrOnn75gPwxpIdlQGKUayzVKtThCNZSoAgMKywdyd76D3LLlM3uBFRjlNTIE9fXQuLSyx72hs5A0+eG3S7O/A/sLf1fa5r/cqRRMYEiSJJVZezuX+mE0NhZu9+xpyDosSdNZtxFCgOPlaeQZL1VgZPihsHkljI4Qx8ezi6GWnRmG5SvnNWVmLkKujvCq1xG/9Shx5My89xefexpuvLni5zEdExiSJEkVMNEP4+GHT7FjxwV6eurshSFVqdDQCK1rC0tIyuF0D9TVw6rV5dn/TKxYWbi1kWdZxJFhaK7s8pEJ4cfvgfNjxL/6yrz2E4eH4ORRwo23lCiy+TOBIUmSVAFdXf3s3r2cu+5ax/79DUCgu7uZjo6NdHa2Zx2epCu1byrfKNXeHmhtu/aY03Kb6M3gMpLyODNc8f4XE8INnbDjNuLX/2R+FTYHni7s78abSxTZ/JnAkCRJqpC9e09e1gtj6dLImjXjfPGLpzKOTNKVwrqNcOoEMcaS7zuePlXSBp5zEZqLFRhnrMAoiwwrMAByb7un0Cz2u/vmvI/43FOFSqGtN5UwsvkxgSFJklQh69fnr+iFAX19OT796WVZhybpSm3r4exoeZZY9PWUtIHnnFxKYFiBURZnhggZVWAA8KrXw5p15L/68Jx3EZ9/Cm7oLCypqhImMCRJkiqotzdHCDA2FoDCl0tJpOoT1hYbbJ4q7bSgeOECDJyG1mwrMCYSGNEERsnFGGH0TKYVGCFXR3jrT8EzTxIPPT/r18eLF+Dgc1XV/wJMYEiSJFVUV1c/jz9+0rGqUrVr2wBA7C3xv8v+4pKxjJeQXPpwbQKj9M6Owvg4LF+ZaRjhR38CGhqIf/HI7F986ABcOE+4yQSGJEnSonb1UpJAfX1k167V9PT49kyqCm3FCozeE6Xdb18hgRHaMu6B0dAIDY1OISmHiWuaYQUGQFjWTHjVG4mP/1Wh8mcW4vOFBp5UUQNPMIEhSZKUicljVXfuHGHfvgb27WtwtKpUJcLSJlixCkpcgXGpoqM14x4YUFhGMmwFRskVG6Nm2gOjKLzxzsJylu//zaxeF597CtrWE1payxPYHNVnHYAkSdJi1NXVD0BnZ3uxH0ZBd3cz3d3NNDZGDhw4nlV4kgDa1hNPlbgCo7cHcjlY3Vba/c5F8wp7YJTDSPGaZlyBAcAtr4KVLeQf+wZ1r37TjF4SY4TnnyLc/IoyBzd7VmBIkiRl6MrRqvbDkKpHaFtf8goMek9A61pCfRX8Lrl5pT0wyiBOjKbNuAcGQKirI7zux+B7jxNnulzoe4/DYD/cdGt5g5sDExiSJEkZmqofxp49DVmHJQkKfTBOnyKOj5dsl/HUCVi7oWT7m4/QvNIeGOVQJT0wJoQ33gnjF4l/81fX3TYePUS+63cK41Pf+OPlD26WTGBIkiRlbHI/jB07LtDTU2cvDKkarN1QmCbR31u6ffaeJFRJAsMKjDKZqMBYViU/xzd3Qvtm4mNfv+ZmcXiI/H/9DWhcSu6f/jtCY2OFApw5ExiSJEkZ6+rqZ/fu5dx11zr2728AAt3dzXR0bKSzsz3r8KRFK1yaRFKaZSTx3CgMD14a0Zq55StgdKSkFSai0ANj2XJCXV3WkQAQQiC88a3w/NPEnql7K8UYyf+P34b+PnL/5N8QWqugR8sUTGBIkiRVAXthSFWomMAoWSPPU4V/z2Ht+tLsb75WFHs0uIyktM4MF5JDVSS87scAiN96dOoNvr0XnvouIfkAofNlFYxsdkxgSJIkVQF7YUhVqHVtYWJIqRp5TiRCqmkJCbiMpMTiyPBL17ZKhDVrYet24rf2XPVcvHiR/Oe7oX0z4W/97QyimzkTGJIkSVXCXhhSdQl1dYUkRqmWkPQWExhVsoQkmMAojyqswAAIr34TvPgcsa/nssfjXz4CPcfI/fT7qmbZy3RMYEiSJFUJe2FIVWjthhIuITkBy5oJy6skMTnxIdsERmmNDBOqZALJZOE1bwQgPrH30mPx7Cjx4d3wspfDK16bVWgzVgXDhyVJkjRh796TPPDASh55ZClnz+Zoaspz993nuP9+P2DUuiRJ7gY+DtQBXWma/uYVz98APAS0FLf5cJqmX6p4oItMaFtP/M6+kuyrmkaoApeWOcQz/z97dx4fV13vf/z1nayTTNJmb5ICbdqmC0spKIsoIG7FDar1KCL1Xpd6UXC9ItyreC9XQVQs/NxrFAmgeAQVi0JVBBdoC5Y10IaW0tIlTTJtmn2f7++PM2mbNm2TNDNnMvN+Ph59JDM5M+fz/Z40yXzm8/182zE+h5JUErUCo7QCps/EPvU4vOUSAOwffw3trQSW/hvGJP53gSowRERERBKIemGkJsdx0oDvAxcDC4DLHMdZcMhhXwZc13UXAR8AfhDfKFNUcRm0t2J7uo//uZobD+xskghCqsCYaHagH3q7D8xtgjFnngubN2D37cE+vx67+jeY896MmTHH79BGRQkMERERkQSjXhgp6Sxgs+u6W1zX7QPuAS455BgLDHUGnALsimN8qWuoYuI4+2DYyCDsaUqoCgyTmQVZ2UpgTKSO6I4uuYnVxHOIOfM8AOyff0+k5haoPAlz2Sd8jmr0EmYJieM4U4Ea4BS8H84fcaDHh20AACAASURBVF13zdEfJSIiIpJ8ampaqKoq5447DiQtamtD1NaGyMqybNnS4GN0EiOVwPaDbu8Azj7kmP8B/uQ4ztVALvDmkZ7IcZzlwHIA13UpLi4eczDp6enjetxkMNax9c+ay14gr6+b7OOYk8Hm3YQHBwjNnEVODOd2rONrzp9CZn8fUybB9Z4M35cDXW3sAfLLK8b8/RKX8RUXE54+g8E//RaTE6Lwv75JenllbM/JxI0tYRIYeOv9HnJdd6njOJlAjt8BiYiIiPhFvTBkBJcBP3dd9xbHcc4F7nQc5xTXdSMHH+S67kpgZfSmDYfDYz5RcXEx43ncZDDWsdmMbADatrxER9X8cZ/X1r8IQGcwj64Yzu1YxxcJhujZ00z/JLjek+H70u54FYD2CHSMMdZ4jS+y6BzYsRXzkc+yLyMb4nDOY42toqJiVM+TEEtIHMeZApwP/BTAdd0+13X3+RuViIiIiH9G6oWRnm658soCmpoS4k84mVg7gRMOuj09et/BPgq4ANFK5Wwgsd+OTgahPMgKQrjp2Mcexf6dTBKpBwZ4jTy1hGTiDC0hSdAeGABm8XsJXH8bZuFZfocyZolSgTETaAZudxxnIbAe+Izrup0HHzQR5XDHazKULU1mmt/Y0vzGluY3tjS/saX5ja3xzm9bWxrLl0f42Mci1NQEWL06yKuvGn74wxK++93BGEQ6OSXJ9++TwBzHcWbiJS4+AHzwkGNeBd4E/NxxnPl4CYzmuEaZgowxUFKGbTrOpVvhRggEoLBkYgKbICaUh23WsrSJYjsTuwcGRHufnDDT7zDGJVESGOnAGcDVruuucxznNuBa4CsHHzQR5XDHazKULU1mmt/Y0vzGluY3tjS/saX5ja3xzu8PontMVFWV09vrbW/3/um/I+PhvWRlfUT9MKLGOr+jLVWOJ9d1BxzHuQpYjbdF6s9c133BcZwbgH+5rvt74AvATxzH+Rxez7h/c13X+hd1Cikth13bj33c0TTvhqJSTFraxMQ0UUL5B6oG5PhNggqMySxREhg7gB2u6w5tsHwvXgJDREREJOUd3A/jjILneW/lH+k59QKu+mqu36HJBHJd94/AHw+57/qDPn8ROC/ecQmYkmnY557ERgYxgfElIGzz7sRbPgJeAqO7EzswgElPlJeHk1hnG2RkQmaW35EkpYRYQOm67m5gu+M4c6N3vQl40ceQRERERBLGwf0wfrDt40RsgNfs+rnfYYmkjpJyGBiAlr3jf47wbkxJ+cTFNFFC0aUOXarCmBAd7ZCb5y09kgmXEAmMqKuBux3HeQ44HbjR53hEREREEkY4HGDZsk5+cm+A+9uWcnHRQ/ziW41+hyWSEkxpNPEwzl4RtqvTe2FbkngVGCYvmsBo1R4KE8F2tmv5SAwlTI2Q67rPAK/xOw4RERGRRFRT00JVVTl33BFiSvpHWfzG37PgpZ9RWXmbemGIxFrJNABsUwNm3mljf/zuHYC3FCXhDC1r2dM4aRs7JpRoBYbERiJVYIiIiIjIUaxZ08ill3bRlxHi+y//G28qfYwvXvIYa9eqEkMkpgqLIS3da8Q5Dvb59WACUH3KBAc2AYaSM836OTIhVIERU0pgiIiIiEwSB/fC+EWDQ0NPKW9s+TFYbUQhEksmkAbF499K1T69BmbPw+RNmeDIJkBOCII5407OyCE62jAJvIXqZKcEhoiIiMgkMtQL497727m77WOcEnqR1Tc/7XdYIsmvtHxcPTBsUwPs3IZZdG4Mgjp+xhgvORNWBcbxstZCV4cqMGJICQwRERGRSaSmpoV77snlrW8t5fvr381L7VWc3VDDidNLqapKwB0ORJKEKZkGzbu9F6ljYJ9Z5z3+9LNjEdbEiI5NjlN3JwwOqgdGDCmBISIiIjLJDPXCyMwOcHP9J5kVepX/W3wfJ5/cR1OT/rwTiYmSadDTDe2tY3qYfWYtTJ+RmA08o0zxNNjThI1E/A5lcmv0KnRMcanPgSQv/YYTERERmWQO7oXx99bzearlVN46UEvdM4YVK0J+hyeSlA5spTr6SgXbtg82b8QsOidGUU2QkjLo74O2Fr8jmdTsjle8T6bP8DWOZKYEhoiIiMgkNNQLIxIxfGfTckozGnlf5Spqa0NUVlZoOYnIRCvx/k+NpZGnfe5JsBHM6YmdwDBDW6lqJ5Ljs3MbZGZBceJW20x2SmCIiIiITEI1NS3ceGMb69Y1UnjeaTzVeipXzf4Z+Tk9LFnSpa1VRSZacRkYM6ZGnvbptVBUCifMjGFgE6B4aCtV9cE4HnbHVqg8CRPQy+xY0cyKiIiITGJlZRHy8uE7Ly2nMtjIu4sf4LHHMv0OSyTpmIwMKCge9RISu2MrvPA0ZtE53k4fiayo1EvOhJXAGC9rLezcitHykZhSAkNERERkkguHA8y8+BS6yufz2bm3sy88qF4YIrFQMm1US0hsfx+RmlsgN4R5+/viENjx8ZIzRVpCcjxa90JHu/pfxJgSGCIiIiKTXE1NC/f8KsTH7/8UpRmNONPVC0MkFkxp+agqMOx9d8DObQT+7TOYvClxiGwCFE/DhpXAGLcdWwFUgRFjSmCIiIiIJIE1axopOu9Unmo9jatm3a5eGCKxUFIO7a3Y7q4jHmLr1mMfXoW56J2YU8+MY3DHxxSXaQnJcbDRBAaVM/wMI+kpgSEiIiKSBIZ6YdxSv5yKYCOXlKxSLwyRCXZgK9XDl5FYa4n87SEi378RKk7EvPfDcY7uOJWUwb692L5evyOZnHZug4JiTK6W78WSEhgiIiIiSSIcDlD19pPpqljAZ6p/zt5mq14YIhOpJLpbx+6dw+62XZ3Yld/C3vUDmHsKgS98DZOZ5UeE4ze09eeeJn/jmKTsjq3qfxEHSmCIiIiIJImhXhif+v3HKc1o5B3lD6sXhshEKquEvCnYX/wY++LTANjNG4jc8BnsU49j3vNhAp/+KiZ/qs+Bjp2JJmdGu8uKHGAH+qFhB2b6SX6HkvSUwBARERFJImvWNJJ/7iJe7pzB8pl3EgwOqheGyAQxWVkErr0ZphYSufV/GfzRN4h88zowhsA13yBw8XsxgUn6EqukDECNPMdj904YHFD/iziYpP+7RERERGQkZWURQvmGlVsu59Qp9ZyRs570dMuVVxbQ1KQ//USOlymtIHDtN+GMc2D945izLyBw/W2YWfP8Du345E2FzCxtpToOdv8OJDP9DSQF6LeYiIiISJIJhwPkvPF8BnKm8j9vqGXdukzWrctUPwyRCWKygwQ+8SUCN64k8NHPYYI5fod03IwxUFyG1U4kY7dzG6SnQ1mF35EkvXS/AxARERGRiVVT0wLAty/6AJ+b9SOy976KtbOorQ1RWxsiK8uyZcvhuyiIyOgZY/Y39UwaJdNg+ytE1j7idyQj6g7lEelo9zuMw9gNz8K0EzDpenkda5phERERkSS17Kfn03fj7fzH7Lv4/DNfJRiMsHhxD9df3+Z3aCKSgMwJM7HPPoH96Qq/QxlRIv/kMhcs9juElKAEhoiIiEiSKp0Z4rGsi3nXtD9wS94n2dVRzGOPZfodlogkKPOuyzDnXgRYv0MZUUFBIS0te/0OY2RFZX5HkBKUwBARERFJYg/0vJ+zAvez6gs/57Jffob6+gxWrAhx002J/F6miPjBBAJQmrhbLqcXF2Mysv0OQ3ykJp4iIiIiSeymmlz+0nQBgX8+xCubAAy1tSEqKyuoqkrcFyoiIiKHUgJDREREJMmd/cWLKMxs5Z3TvcZ8wWCEJUu6WLtW2yWKiMjkoQSGiIiISJIreN1ptATKWFK2iqwsS0+PUS8MERGZdJTAEBEREUlyJhDgn4Pv4A0l63jw7jqqq/tpakpjxYqQ36GJiIiMmhIYIiIiIingkpvPAwurrnuc+vpM1AtDREQmGyUwRERERFKAKSphYM7pfHjO/eQG+wH1whARkclFCQwRERGRFJH9prdQSBOvCT25vxdGerrlyisLaGrSn4UiIpLY9JtKREREJFUsPJsOO4Uvvf43rFrVzLJlnaxbl8m6dZnqhyEiIglPCQwRERGRFGEyMsh7ywWcMvBPPvyedO64I8Srr2ZgrfphiIhI4lMCQ0RERCSFmNe/BQYHePjm+7j00i6CwQgA2dmWoqJBHnig2ecIRURERqYEhoiIiEgKMZUnQfkJhLasJS/P64Ph9cOAPXsC3Hlnjt8hioiIjEgJDBEREZEUY04/C16qozPciTHQ22sA75+WkoiISKJK9zsAEREREYkvs/Bs7IP3cdvHH+bLX38jN9yQz+rV2XR3BwgGIyxe3MP117f5HaZMkIqKirg+bjJI5rFBco8vmccGyT2+iRibKjBEREREUs3MasibAs8+QVlZ5JClJIYHHggSDuvPxCRhxvPPcZz1431sov9L5rEl+/iSeWzJPr5Rju2Y9JtJREREJMWYQACz8Cxs3XrsQD/hcIBlyzpZtaqZ/PwI/f3wqU9N9TtMERGRYZTAEBEREUlB5vSzobsL6uuoqWnhjjtyeetbS2ltTQMML72USWVlBZWV6oUhIiKJQQkMERERkVQ0fyFkZmKfWQfA6tXNVFYOADZ6gGX69AH+/Gdtq5qiVvodQAwl89gguceXzGOD5B7fhIzNWGuPfVRisrt27Yr7SYuLiwmHw3E/b6rQ/MaW5je2NL+xpfmNLc1vbCXq/A5+/+uw7WUCN/8UYwwXXljCpk0HerxXV/fzyCOJF/ehxjq/0UZyo1pvLSIiiUO7kIiIiIikKLPwLK8CY+c2mD6DtrYAs2YNYAxYS3Q5iYiISGLQEhIRERGRFGXmngqA3fQCAE891ch55/Xy8svpnHdeL0891ehneCIiIsOoAkNEREQkVRWXQUExvPQCVR/9GL29B1ZV1NaGqK0NkZVl2bKlwccgJZ4cx1kM3AakATWu637D55DGzXGcE4BaoAyvuctK13VvcxynEPgVMAPYCjiu67b4FefxchwnDfgXsNN13Xc6jjMTuAcoAtYDV7iu2+dnjOPhOM5UoAY4Be/6fQSoJ0muneM4nwM+hje254F/B8qZpNfOcZyfAe8EmlzXPSV634j/1xzHMXg/Z94OdAH/5rruU6M5jyowRERERFKUMQYz52TsphdY8/huLr20i2AwAkAwGGHJki7WrlUVRqqIvhD+PnAxsAC4zHGcBf5GdVwGgC+4rrsAOAf4VHQ81wIPu647B3g4ensy+wyw4aDbNwMrXNedDbQAH/UlquN3G/CQ67rzgIV4Y0yKa+c4TiXwaeA10Rf7acAHmNzX7ufA4kPuO9L1uhiYE/23HPjhaE+iBIaIiIhIKpt7MrS2UGp2kpdn6ekxGON9zMuLUFoa8TtCiZ+zgM2u626Jvut7D3CJzzGNm+u6DUPv6rqu2473ArgSb0x3RA+7A7jUnwiPn+M404F34FUqEH1n+yLg3ughk3J8juNMAc4Hfgrgum6f67r7SKJrh7caIug4TjqQAzQwia+d67p/B/YecveRrtclQK3rutZ13bXAVMdxRrVntxIYIiIiIinMzDkFAPtSHeFwgOrqfqz1diBpblYTzxRTCWw/6PaO6H2TnuM4M4BFwDqgzHXdoXVRu/GWmExWtwLXAEOZxiJgn+u6A9Hbk/UazgSagdsdx3nacZwax3FySZJr57ruTuDbwKt4iYtWvCUjyXDtDnak6zXunzVKYIiIiIiksmmVkDeF+25+hQcfDFJfnwkY6uszefDBIFVVo3pTTCRhOY4TAu4DPuu6btvBX3Nd1+L1IJh0HMcZ6jew3u9YYiAdOAP4oeu6i4BODlkuMsmvXQFeFcJMoALI5fDlF0lloq6XEhgiIiIiKcwYA3NO5pL5/1IPDNkJnHDQ7enR+yYtx3Ey8JIXd7uu+5vo3Y1D5erRj01+xXeczgPe7TjOVrzlPhfh9Y2YGl2WAJP3Gu4Adriuuy56+168hEayXLs3A6+4rtvsum4/8Bu865kM1+5gR7pe4/5ZM+oEhuM4KxzHOX20x4uIiIjI5GCqTyZtXyPTc3bT02PIylIPjBT1JDDHcZyZjuNk4jUV/L3PMY1btB/ET4ENrut+56Av/R74cPTzDwP3xzu2ieC67nWu6053XXcG3rX6q+u6lwOPAEujh03K8bmuuxvY7jjO3OhdbwJeJEmuHd7SkXMcx8mJfp8OjW/SX7tDHOl6/R5Y5jiOcRznHKD1oKUmRzWWbVTTgNWO4zQDd+JlMXeM4fEiIiIikoDM7PlYYErLRpYuLWPjxgzmz1cPjFTjuu6A4zhXAavx/vb/meu6L/gc1vE4D7gCeN5xnGei9/0X8A3AdRzno8A2wPEpvlj5EnCP4zhfA54m2ghzEroauDuaTNuCt81ogCS4dq7rrnMc517gKbzdcp4GVgJ/YJJeO8dxfglcCBQ7jrMD+CpH/r/2R7wtVDfjbaP676M9j7F29MtQolsrXQxcjrfH6zq8vZV/47pux6ifaGLYXbt2xfmUUFxcTDgcjvt5U4XmN7Y0v7Gl+Y0tzW9saX5jK9Hn1/b3Ebn6/Zi3vZf/fuKT3HlnLldc0clNN7Ud+8EJYKzzW1FRAWBiFpCIiMTEmHpguK476LruA67rXoa3l3IJ3n6vu6OdYSd7l1QRERGRlGMyMtm4byZ/+fkuamtDWGuorQ1RWVmhJp4iIpIwxrKEBMdx8oH3AR8CTsNriPNJvDU8XwAejN4vIiIiIpPIjDecwLRnnicYjNDdHSAYjLB4cQ/XXz85qjBERCT5jTqBEV2j8zbg78CPgN+5rtt70Nc/j7d/rYiIiIhMMsE5M8l+5hFyIy30mEI18RQRkYQzlgqMtcBV0Y6wh3FdN+I4TtnEhCUiIiIi8WROmIkF3jJ/A7985jzmzlUTTxERSSyjTmC4rvvtURzTdXzhiIiIiIgfzrjkXP51AeS3bgFeT319JvX1UFWVzZYto9rdTkREJKbG1MRTRERERJLTQ//oYS9lnFZQD0AwGGHJki7Wrm30OTIRERGPEhgiIiIiQllZhMaM2cwLvURWllUPDBERSThj2oVERERERJLXtr4ZvDn0BHOre5k3f1A9MEREJKGoAkNEREREALj4Q3mk00/jpjaysy01NS1+hyQiIrKfEhgiIiIiQlVVOVd8dj4A07MbqK0NUVlZQVVVuc+RiYiIeJTAEBERERHWrGlk7usKAJie06AmniIiknCUwBARERERysoi9OeVATA9uEtNPEVEJOGoiaeIiIiIANCwJ4eWyFSmBxuoru5XE08REUkoSmCIiIiICFVV5fT2Gq58XQXTgw3U12VSXw9VVdls2dLgd3giIiJKYIiIiIiI1wPjhhvyadhRTnXOJoLBCIsX93D99W1+hybHx/odgIjIKJljHaAEhoiIiIhQVhYhL8/yakc5FxX9g54e1AMjSezatWvMjykuLiYcDscgGv8l89gguceXzGOD5B7fscZWUVExqudRE08RERERASAcDjBt3hSy0vpYtrRJPTBERCShKIEhIiIiIgDU1LTQm+ltpVqUsYeamhafIxIRETlACQwRERERoaqqnMrKCn77sFfG+9hDPVRWVlBVVe5zZCIiIh4lMERERESENWsaufTSLtqNV4FRGQqzZEkXa9c2+hyZiIiIR008RURERGR/E8+d7UUATAm0MKgmniIikkBUgSEiIiIigNfEs2RGDgORNKrLm9XEU0REEooqMERERESEqqpyensNAHsrpxJob+XBNUGqqrLZsqXB5+hERERUgSEiIiIiHOiBEQxGaO4roixnj3pgiIhIQlECQ0RERET298Do6THs7S+kIH0veeqBISIiCUQJDBEREREBvB4YS5d2MZCdz4kFe9UDQ0REEooSGCIiIiICQE1NC8Gg5eWmYkLso6amxe+QRERE9lMTTxEREREZ1sTzU7MKyLLdVJ1QCBlZauIpIgnPdndh1z4CAwMT/+QZGZjXvQmTmTXxzy1jklAJDMdx0oB/ATtd132n3/GIiIiIpIo1axq54YZ8Vq/OJtxbAMDl727g6q8GfY5MROTY7Lq/YX/x49idIC0d84a3xu75ZVQSKoEBfAbYAOT7HYiIiIhIKhnexHMqAKXBPZSWVvgcmYjIKOxtgrQ0ArfcCcZM4BNbIl+9Gl58BpTA8F3CJDAcx5kOvAP4OvB5n8MRERERSTnhcIDq6n7CjYUADOxr9zkiEZFR2huGqUWY3NCEP7WZvxD7/JPYSAQTUBtJPyVMAgO4FbgGyDvSAY7jLAeWA7iuS3FxcZxCOyA9Pd2X86YKzW9saX5jS/MbW5rf2NL8xtZkmN8pUzLo6fHetTwpx0tgvPJcJ7NmldPa2u9naMc0GeZXRGLLtoShIEY/BxacDmv+Ctu3wEmzY3MOGZWESGA4jvNOoMl13fWO41x4pONc110JrIzetOFwOB7hDVNcXIwf500Vmt/Y0vzGluY3tjS/saX5ja3JML+PPx44rAfGBWc08uUbGgmHIz5Hd3Rjnd+KCi2LEUk6LXswM6tj8tRmwUIsYF98BqMEhq8Spf7lPODdjuNsBe4BLnIc5y5/QxIRERFJHQf3wBhID9IzmElh5j5KSxM7eSEiYiMRaAlDQVFMnt/kF8D0GdgXn4nJ88voJUQFhuu61wHXAUQrMP7Tdd0P+RqUiIiISIoJhwMsXdrFxo0Z9KRPIdDV5ndIIiLH1tHmbZ9aUBKzU5j5C7GP/AHb24vJ0naqfkmUCgwRERER8VlNTQvBoKWuLoOuwBRef3qz3yGJiBxbi7eEzBTGrheOWXC6lyTZ/GLMziHHlhAVGAdzXfdR4FGfwxARERFJKVVV5fT2Hth6cPPuIhrCXXzgO+Vs2dLgY2QiIsewN9oDJ0ZLSACYcwqkp3t9ME5eFLvzyFGpAkNEREREWLOmkUsv7SIY9HpetEamcGLhXtaubfQ5MhGRo7PRCgxiWYGRlQWz5qsPhs+UwBARERGRYU08jbE0dxcQQk08RWQS2BuGtHQITYnpacz8hbDjFWxXR0zPI0emBIaIiIiIAF4Tz+rqfqyFQH4+QduJHRjwOywRkaOL7kBiAjF+eVsQrfDoaI/teeSIEq4HhoiIiIjE36E9MF7aVQSFcM4pQdZt7PcxMhGRo7Mt4ZguHxlisoNYgJ7umJ9LRqYKDBERERE5rAdGB14p9h/dl/0MS0Tk2PaGMVNjn8AgO+h9VALDN0pgiIiIiMiwHhhZWZbdnQUAFGa0+ByZiMiR2UgE9u2NSwXG/gRGrxIYftESEhEREREBvB4YS5d2sXFjBmdVZ0E30Km13iKSwNpbYXAgtluoDokmMGxPN+YYh0psqAJDRERERACoqWkhGLTU1WUwEMwHwKpZnYgksr3eFqomnhUYWkLiG1VgiIiIiMhhTTx/cncF114Mt9wAX7zQv7hSmeM4acC/gJ2u677TcZyZwD1AEbAeuMJ13T4/YxTxXYuXwKCgJPbnUgLDd6rAEBEREZHDmnimZ6fRQw5XXrHL58hS2meADQfdvhlY4brubKAF+KgvUYkkELs/gRGHJSRZSmD4TQkMERERERnWxNMY72N3IJ+cSJvfoaUkx3GmA+8AaqK3DXARcG/0kDuAS/2JTiSB7A1DegbkTYn5qUxaGmRmKoHhIy0hERERERHAa+JZXd1PfX0Gc+f20zY4hQI18fTLrcA1QF70dhGwz3XdgejtHUDlSA90HGc5sBzAdV2Ki8feGyA9PX1cj5sMknlskNzjG2ls+7raGSgupbgkDktIgOZgLllY8mMwx6l27cb1PBMQi4iIiIhMcof2wKivz2RrfgEt/+zgzE/7GFgKchznnUCT67rrHce5cKyPd113JbAyetOGw+Exx1BcXMx4HjcZJPPYILnHN9LYBnfvhPyCuI05kplFz74W+mJwvlS7dgerqKgY1fNoCYmIiIiIHNYDIxiMkFsW4tSZe3yOLCWdB7zbcZyteE07LwJuA6Y6jjP0BuR0YKc/4YkkkJY98dmBZEh2ENurJSR+UQJDRERERIb1wMjK8j72Z+aT1qMeGPHmuu51rutOd113BvAB4K+u614OPAIsjR72YeB+n0IUSQg2Mgj79sSngeeQ7KB6YPhICQwRERERAbweGEuXdlFd3c/73tdFc/dU6OrEDg76HZp4vgR83nGczXg9MX7qczwi/mrbB4OD8dlCdUh2jhIYPlIPDBEREREBoKamheuuy6euLoNFi/q45N0Z2F8Ane2QP9Xv8FKS67qPAo9GP98CnOVnPCIJpakBAFNcFrdTmuwgNnpeiT8lMERERETksCaetbUhWv58Et9fBHS0KYEhIgnH7tzmfVJ5UvxOqiUkvtISEhEREREZsYnngrOC3hc7tJWqiCSgHdsgmBvfHhhZSmD4SQkMERERERnWxNMY76PNzfO+2KFGniKSeOzOrVB5EsaYYx47YbKD0NuNjUTid07ZTwkMEREREQG8Jp7V1f1YC9XV/WxvKQDAKoEhIgnGWgu7XsVMj+PyEfASGAB9PfE9rwDqgSEiIiIiHN4Do74+k62byrh5MarAEJHEszcM3V3x7X8BBxIYPd3ejiQSV6rAEBEREZERe2C8/ZIINjPb24VERCSR7NwKgKmcEd/zHpzAkLhTBYaIiIiIDOuBkZXlfczLi2AiedDe6nd4IiLDHNiB5MS4ntdkB7GgBIZPlMAQEREREcDrgbF0aRcbN2Ywf34/zc1pMGMKtl1LSEQkwezYBgXFmJxQfM+rCgxfaQmJiIiIiABQU9NCMGipq8sgO9tSU9MC+VOhbZ/foYmIDGN3bYt//wtQAsNnSmCIiIiICFVV5VRWVlBbG8JaQ21tiMrKCn69ugLaWvwOT0RkPzswAA07MH4kMLK8BIZVAsMXSmCIiIiIyIhNPJcs6eIdl2VDeys2EvE5QhGRqMZdMDgA8d5CFVSB4TMlMERERERkWBNP3LLrOQAAIABJREFUYw408cwtnwKDg9DZ4XeIIiIAWL92IIEDCYxeJTD8oASGiIiIiABeE8/q6n6sherqaBPP/ALvi+qDISKJYuc2CARg2vT4nzsrG4xRBYZPtAuJiIiIiFBVVU5vr9l/u74+k/p6+OBTVdx9Jl4fjDhvVygiMhK7cxuUVWIyMuJ+bmOMl8RQAsMXqsAQERERkSP2wPjend7XrSowRCRR7NzmTwPPIdlBJTB8ogSGiIiIiAzrgZGVdaAHRtHMfO+AVu1EIiL+s/39sKfJn+UjQ5TA8I2WkIiIiIgI4PXAWLq0i40bM5g/P9oDI5gL6RlKYIhIYmhpBmuhuMy/GLKC2kbVJ6rAEBEREREAampaCAYtdXUZZGdbampavPXeBUXQEvY7PBERCDcCYPxMYKgCwzeqwBARERGRw5p41taGqK0NkZVl2fTJEqwSGCKSAGw0geFrBUZ2EPY0+3f+FKYKDBERERE5YhPPtWsbMYXFsFd/rItIAgg3QloaFBT6FoLJDkKvKjD8oASGiIiIiAxr4mnMgSaepaURKCiBfXuxg4N+hykiqS7cBIUlmECafzFoCYlvlMAQEREREcBr4lld3Y+1UF0dbeIJUFQMkQi07vU3QBFJeTbc6O/yEVACw0fqgSEiIiIih/XAqK/PpL4eqqqyefn+EizA3jAUlvgWo4gI4UbM6Wf7G0N2EPr7sIODmDQfK0FSkCowREREROSoPTAoLAbAqg+GiPjI9nRDeysUlfobSHbQ+6gqjLhTAkNEREREhvXAyMo6pAfGUNWFdiIRER8NNjV4n/i9hCRLCQy/aAmJiIiIiABeD4ylS7vYuDGD+fMP9MAwwRwI5mjbQBHx1WCjl8AwficwsnO8j0pgxJ0qMEREREQEgJqaFoJBS11dBtnZlpqalgNfLCzB7mnyLzgRSXmDTbu8T0r8TWCY/UtIunyNIxWpAkNEREREDmviWVsborY2RFaWZcuWBiirgF2v+hihiKS6waYGyMyEvKn+BjKUwOhVBUa8qQJDRERERI7exBMwZRXQvBs7OOhnmCKSwgYbG6CoDGPMsQ+OJTXx9I0SGCIiIiIyrImnMYc08QQoq4TBQdAyEhHxyWDTLv8beML+BIZVAiPutIRERERERACviWd1dT/19RnMnXugiSeAKa3AAjTugtJy32JMBY7jZAN/B7Lw/l6/13XdrzqOMxO4BygC1gNXuK7b51+kIvE12NiAmTHH7zBUgeEjVWCIiIiICFVV5Tz4YJD6+kzAUF+fyYMPBqmqiiYryioAsI07/QsydfQCF7muuxA4HVjsOM45wM3ACtd1ZwMtwEd9jFEkrmxnB7arI6EqMOhWE894UwJDRERERI7ZA4O8KRDMhaFdACRmXNe1rut2RG9mRP9Z4CLg3uj9dwCX+hCeiD/C0X48iZDASM+AtDQ18fSBlpCIiIiIyLAeGFlZh/fAMMZAWQW2UQmMeHAcJw1vmchs4PvAy8A+13UHoofsACp9Ck8k/vZEk6lF/icwjDGQFdQSEh8ogSEiIiIigNcDY+nSLjZuzGD+/OE9MCDaB+PlDT5Fl1pc1x0ETnccZyrwW2DeaB/rOM5yYHn0eSguLh7z+dPT08f1uMkgmccGyTu+zu4OOoCiufMJhPL9Dofm3FwyrWXKBM51sl47mLixKYEhIiIiIgDU1LRw3XX51NVlsGhRHytWtAw/oKwCnvw7tr8Pk5HpT5ApxnXdfY7jPAKcC0x1HCc9WoUxHRixIYnruiuBldGbNhwOj/m8xcXFjOdxk0Eyjw2Sd3yRbVswOSH29vRBj//ji2Rk0dPaQv8EznWyXjs49tgqKipG9TzqgSEiIiIiVFWVU1lZQW1tCGsNtbUhKisrDjTxBJhWCdaCGnnGlOM4JdHKCxzHCQJvATYAjwBLo4d9GLjfnwhF4s/uaSYtkXZAytYSEj8ogSEiIiIix27iCZjKkwCwO1/1JcYUUg484jjOc8CTwJ9d130A+BLwecdxNuNtpfpTH2MUia+2fQQKCv2O4gAlMHyhJSQiIiIiMqyJpzGHN/H0DqrwOu/v3OZfoCnAdd3ngEUj3L8FOCv+EYkkgI42AifOZNDvOIZkB6Flj99RpBxVYIiIiIgI4DXxrK7ux1qorh6hiWd6BpRVYnepAkNE4qy9jcCUAr+j2M9k56gCwweqwBARERERqqrK6e01+2/X12dSXw9VVdls2dKw/35TeRL2lZf8CFFEUpTt74PebkzeFL9DOSAnF7o6/Y4i5agCQ0REJkxdXTrz5k3jxRcP5McbGwO8971FNDUFRrw92mMaGhjX48ZzTCyf2+/zj3RfXV06JSUZw66bpJ7R9MAAoPIkCDdie7p8iFJEUlJ7GwCBKVN9DuQgwVzo7cYOJsyilpSgBIaIiEyYq6+eSnu74VOfOvAHxq23hli3LpMVK0Ij3h7tMTfemDaux43lmFu/E8S2t2HDjdx5yz72vrCde77VgN1Sz2+/tYX0zc/wwM0vYJ9Zi13/OA9+8znSNz/Dvd/cin31Ze769h52PLuHlbf0Y3u6sIOD44oxFmM72n1XXz2VtjaGXTdJPQf3wMjKOkIPDMBUnuh9smu7D1GKSErqiCYw8hLo91ROrvexW1UY8WSstX7HMF52165dcT9pMu/Nmwg0v7Gl+Y2tVJ7fyspywBzzOD9kBXqYHtzN9OAuKoO7KcjcR0FGK4WZ+yjIbGVqRisFma0UZLQyJaONgJnY34ut/SEae0rZ3VPC7t7ox55SGqMfd/eUEO4rxCbUewqWnTsbjn2YjNpk+fnwsY8VEApF2Lgxg/nz+2lvD1BT0zLsGNvUQOS/P4FZdhWBN7zVp0iHG+v8VlRUQKL+0Jp44/qbebJ8z45HMo8NknN89sWniaz4KgVf/wFtpdP9DgeAyON/xd5+K4Gv/xgzQdu7JuO1G3KssY3257JqRUVE5Lg0NgY49dQ+wuE0GhrS8H73WMrLB5k/f4A1azLp7g6QnR2huDhCOJxGT48hGIxw4YU9gOHRR7NGcUw23d2HP66nG2ZP3ckp014lv283Zem7OSlvJyeX7qSIBqaYvYfF3DkQZN/AFAaz8uhgChua5hLumUqHzaf4pBx6yOX5DTl09mRCehrBvDT27MuisycTk5nGwjMiREjjufUG+vvID3ZTOrWHvs4+0gZ7ycvu4eQ5nWTSS2tjO8XpzVTkNDFvyhaKMvaQZiKHxJPDi21z2NhVTaSyiu1Uc8/f5tHWlTUB8+YdM9J9WVkRAgHo7jbDrltxcYSmpsBh77xL8qupaeG66/Kpq8tg0aI+VqxoOfyg4jLIzAI18hSROLFDS0jyE6cCw+TkYgG6OvwOJaUogSEiIsfl1ltD1NVlkp8/9GLXq2DIy4tQWTm4vxy9t9eQkxOhtzdtf3l6SUkEa82ojunthcKcDqqyNvOO0AtMG3iZ5ae/wty8lwmlH1iL3x9JY1fPNAYyy9gUOJdHnz+Bhv5ytrZVkllexPr6Emx6Fn19cMUVnVhruOuhHDIz8e57jXffr7cduG/OnH427c7wbu+DuSXeMU825+y/b06on02vZhx4ntcd/txz5vTz8qYAFaG9FKY18YG3bScvsoe9L+zilKn1LJn2B0LGG8s156ezubOKuta5NGXNZnXHQurtfHp6AmOat4OXAxx6X1+fIT8/Ek1geNetq8tQV5fBihUhbrqpLZ7fSuKzQ5t41taGqK0NkZVlhzfxDASg4kSstlIVkXjpOCiB0TfgczBRQ0tI1MgzrpTAEBGRcTn0xU5rq7fdYnq6ZdasfvbtSyMcHmTZsk4uv7yLu+/O4aGHgsNuNzV5jxnpmCuWNrPu7k1Mbd7EdDbzn+/YQsHgTu9kndBpQzSVzqLv5Dfzu83V/HH9bKrPLeCdH8rh7l/m7X/u0vMG+fhBz/3+D3Vz+eVtRzz/0WKaiGM+tKybyy+Hu++ewd+bZnkxvnaQcy7v4pt3ZWObGziRTczNreeMGfWcuP0fhOwqriqBgZwCno2cy7rm89jAa1m2zI7p/CPdd889Ocyd28+WLRn095v91/FIL14lea1Z08gNN+SzenX2/qqdxYt7uP76wxNZpvJE7HP/wlqLMamyEkNEfNPRBiaAyc2DvhEqw/yQE+0tpR4YcaUeGGOUzOuSEoHmN7Y0v7GVSvPb2BjgYx8roKwsMmyJwtCLnfEsPbA93bD5RezG57Ebn4NXt4CNgAlAWTlZs+bRV1KOmT4Tps+AwuKUeOFkrYV9e7Ev1cGzT2DrnvL+WErPgHmnYRa+FnPaazGFJcd1nv7+Yj772YERX7xqKcnxmyw/H669dgp33ZWz//YVV3SOWIkTeXgV9p6fEPjWzzFTC+MZ4ojUA+Oo1APjEMk8NkjO8UXu+gF2/eOU3flQwozN7m0m8qWPYq74FIHz3zYhz5mM126IemCIiIhvbr01xNNPZzJnTv8xdyw4EtvXCy9v9BIW9c/B1k0wOAhp6VBVjXmHg5l3KsyoxmRlMTWJf6kfjTEGCoowZ18AZ1+AHRjwEj3PPol97gns3T/C3v0jmD4Tc/rZmDe8ZVzJjPJyDtuBIi3NcuWVBfzwhy1KYqSIcDhAdXU/9fUZzJ3bT3Nz2ojHmRNmeouOtr8CCZDAEJHkZjvaIG+K32EMp11IfKEEhoiIjNqhy0ZeeikTgEjEsmxZ5/4lCkdi+3rhuSeJrPs71K2HgX4IBGDGHMxbl3gJi1kLMFlZMR3HZGbS073Ki3mnYZ2PwO6dXiLjuSexf3Cxf3Qxi87FvPldMGv+mKpUwuHAsOUlf/1rNjt2pKkfRoo49P93fX0m9fVQVZV9+DKi6TMBsNu3YE49M55hikgqam+DUJ7fUQyXFfT+hlEPjLhSAkNERI6psTHAJz9ZwKpVzfzgB6ExLTOwkUHY+Dx23d+wTz0OPd0wpRBzwWLMyYtgzgJMds6Ij5WjM8ZA+XRM+XR423uw4Ubso3/E/uNP2PWPwYmzMG96J+a152MyMo75fEPbZY62maMklzH1wMjJ9XYjeXWLD5GKSMrpaINplX5HMYwxxqvC0C4kcaUEhoiIHNOtt4ZYty6Tu+7KOWyZwUjLRqy1sG2zl7R48h/Q2gLBHMyZr8OcfSHMPQUTOHq1hoydKS7DLP137Lsuw659FPvwKuztt2Hv/bmXMLrg4lH1KxjpheyFF/bQ2Jiu7VWTWFlZZFT/v/c7sQq7/ZX4Bikiqam9FTN7vt9RHC6YqwqMOFMCQ0REjmikd+IBAgHLqlXNw3a2AG+JiH3sYexfV8HunZCeDqe+hsDZF8KpZ2IytTQkHkxWNuaCxdjz3wYbniXy1we85SUP3os56wLMpR/CFBYf8fEjvZB9+eV0Nm3S9qrJLhwOsHRpFxs3ZjB//pF7YEC0D8bTa7E9XaqiEpGYsZEIdLZDKMF6YADkhLBKYMSVEhgiInJERyspLy2NcOON3gtZ29XpLV34y++hvRWq5mKWXYU543WY3JDPo0hdxhhYcDppC07HNjVg//oA9u+rsesfw1y8FPPWS4+YVBrqh/HLX+Zirdnf70TLSZJbTU0L112XT11dBosW9bFixZG3KzQnVHnVVju2wuwF8QtSRFJLdydEIpCXYD0wQEtIfKAEhoiIjGio78X06QNHLCm3rS3Yv/we+7cHobsLTjmDwOKlUH1ySmxxOpmY0nLMBz6OffO7ifz6duz9d2P/+WcC7/sInHHuYccP9cP4zGc6Rt0XQSa3Mfc+OWGokecrGCUwRCRW2qO/bxKyAiMXWvb4HUVKUQJDRERGNNT3Yteu4TtTNDWlYZt3Y//0W+w//wKDA5gzz8Nc/F7MibP8DluOwRSXkXbltdiNzxG55ydEfvQNmHsq/VdeA7mH/3E40nISba+anMbSxBOAgmJvVwD1wRCRWOpoBcCE8n0O5HAmJ4TVNqpxpQSGiIgMc+i7sK++msEdd2Rwzz25vPz8S9jf3UXky6shEMCcexHmbe/BlFX4GLGMh5l3GoGv3OotKbn/bvZ+/sOY8xdjLvngYX8kanvV1HBwssqYYzfxNMbACVXYbS/HOVIRSSkd0d8zeQlagdGpJSTxpASGiIjs19gY4OST+ygri/Doo1n734W9+G2dfO3i+4h8+Q7o6vR2s7h4KaagyO+Q5TiYtDTMG9+OPesNZK3+Dd0P/Rb7r38Q+PCnMaefvf84ba+aOsLhANXV/dTXZzB37tGbeAKYk2Zj/3w/tr8Pk5EZpyhFJJXY/UtIEq8Cg2AuDPTrZ2AcBfwOQEREEsett4Z4+ulMXn45bf+SgXlZL/Cfkf8gdP/3oOJEAl9ZQeCDn1DyIomY3Dzyl3+BwPW3QmEJke9/ncgvfozt7xt23Jo1jVx6aRfBoPeOfHZ2hKKiQR54oNmPsGWCVVWV8+CDQerrMwFDfX0mDz4YpKqq/IiPMTPnwOCAlpGISOx0JHACY6hRuXYiiRslMEREhKqqciorK6itDe3fcaIwo4Wvz/s/7n/dv5PbvwfzsS8Q+M8bMdNn+h2uxIiZPoPAtd/CvPnd2Ef+QOTG/8Q2bN//9ZH6YezZE+DOO7WFZjI4NEEVDEZYsqSLtWsbj/ygGXMAsFs3xSNEkRFF/vhrIrXfw254FhsZ9DscmWjtrZCZhclKwK3Yg7neRyUw4kZLSEREUtzhy0YMH5n1a66Z+wOCgW7MW5ZQ9M73Y7L1IjUVmIwMzPs/hp2/kMjttxH52ucwH1iOef1bMMYQDgcIBNBSkiQ0UoLqaD0wAK+R55QCeEUJDPGH7enCrvolDAxg//EnmFJI4D++hJk93+/QZKJ0tCVm/wuiTTxBW6nGkSowRERS3MHLRvIie7jzrE/zP3O/SUNGNWn/810CS/9dyYsUZE57LYGv/j+YNR9b+z3sj7+J7eqgpqaFJ58cxzv1MimEwwGWLu2iurqf972v69g9MIyBGXNUgSH+eeEZGBgg8OmvEvjENdDRhn32Cb+jkglk29sSc/kIeE08QRUYcZQQFRiO45wA1AJlgAVWuq57m79RiYgkt0MbMp6wbx33vP4GQuld/D70Of7QvoSa8n0+Rih+M1MLCXz2f7Grf4P93V3YrZsIXP0VyipP0taqSaqmpoXrrsunri6DRYv6WLGi5ZiPMTPmYJ99AtvViRn6Y14kTuyzT0BOCBacjklLg/vvxjapEiypdLRBXqImMLweGLarA3OMQ2ViJEoFxgDwBdd1FwDnAJ9yHGeBzzGJiCSlxsYA731vEatWNXPppV0U5HbxtZO/we2v+Rw92UX0fH4FS1a8kZoaJS8ETCBA4OKlBK75BgwMEPnGNdi69fu3Vl21qpllyzpZty6LdesyWbEi5HfIMk6H9sKprQ1RWVlx1CaeAGZmtffJts1xiFLiwUYi2MHE7yVhI4PY5/+FOeVML3kBUFIOTbv8DUwmVnvrYdt7JwxVYMRdQiQwXNdtcF33qejn7cAGoNLfqEREktOtt4ZYty6Tu+7KoTpYz31nLmPZSfeycsvl/KTwBxSdMt3vECUBmVnzCPzXt6F4GpH/93+svPxubryxjXe9q4Q77gixfXv6mF70SuIZVxNPgBmzATXyTBb2pToi//Ee+jc863cox7al3nt3/vSz9t9lyiqgqQFrrY+ByYTqaIdQYvbAOJDAUA+MeEmIBMbBHMeZASwC1vkciohIUhn+7ipk/P33LG+5krz0Dl59z9fZfvbH2R0O+h2mJDBTWEzgS9+AU8/E/uJHRO75CWse23XYi96LL+7i5JP7aWpKuD8z5CgObuJpzCibeOJtw0tpOfaVl+IUqcRUMBdshEh7m9+RHJN99klIS8OcfMaBO0vLoa8XWo+9/EkSn+3vg95uCOX5HcqITEYmZGRCtyow4iUhemAMcRwnBNwHfNZ13cN+ajqOsxxYDuC6LsXFxXGOENLT0305b6rQ/MaW5je2Enl+Gxpg4UJLeXmEv/2lj/+ZfSPvqXyQF9LfwIJb/otps6fw2iuGjk7MMSTy/CaDscyvvf47dNzxPbpW/YqKfXuoLPoavb2G7GxLb69h69Zs6usNP/xhCd/9buKXocfDZPn+bWtLY/58y4YNhvnzLa2tQYqLM4/5uNZ5p9JX9xRFRUVeY884myzzOynkesvAIu2tPgdybPbZJ6D6lGG9V0xJubcrRNMumFroW2wyQYYSaQm6CwngVWFoCUncJEwCw3GcDLzkxd2u6/5mpGNc110JrIzetOFwOF7h7VdcXIwf500Vmt/Y0vzGViLP7/XX5/PkkxmcM6+B2oXXcfrUF7nlpU+w79z3c+PUjoSN+2CJPL/JYMzz++7LMfkF9P1yJR8c/Djmgzez0j2JSMSwYYP3AnblyjRWrkzT9qpMju/fQxv7vvii4cUXIT8/cMzrF6mcgf37nwi/tAFTVBrrUA8z1vmtqKiIYTSTXK7Xa8B2JHYFhm3aBQ3bMee/bfgXyiqiX2/AVJ/iQ2QyoTq8RFrC9sAAyAlhtYQkbhKittNxHAP8FNjguu53/I5HRCRZHLxsZNGU5/lu+UeYHdrKJ575NvvOu4ymcIbfIcokFrjw7QSuvp4TsndxTdpVPPHg89pedRIbdw8MwMyeD4DdvCGmMUocZGZCekbCLyGxzz4JgFl41vAvFJZAWhpoJ5Lk0KEKDBkuIRIYwHnAFcBFjuM8E/33dr+DEhGZ7IZekHxo5u/41dmfoDsS5LvBH3LjH+Zx441t1NRojbAcH3PKGQQ+fwN0tlN4+zWclLN9xO1V1Q8j8R3cA2Po+o2mBwYAlTMgKwibX4x5nBJbxhgI5RFJ8AoMttRDcRmmZNqwu01aGhSVeRUaMunZoURaIldgBJXAiKeEWELiuu4/QVvniohMpMbGAFd9Mo9Plt7G+fPv47E9Z3Hl0zfy7g+kU1qa4H+YyqRiquYS+MLXiay4no+2f5qMD97CWz9cyt135/DXv2azY0caK1aEuOkmfd8lunA4wNKlXWzcmMH8+f00N6eN6nEmLQ2qqlWBMUEcxzkBqAXKAAusdF33NsdxCoFfATOArYDjuu7EZ6Jz87AJ3gPDNjXAtCNsWlhargqMZLG/AiNxExgmJ4Rt3Ol3GClDb4eIiCSp769I4+MD/835A/fxeHApRf/7FS65LH3UL0hExsKcWEXgizcydWqET/d/mmsu26vtVSehmpoWgkFLXV0G2dl2TFVaZvYC2LkNq3ciJ8IA8AXXdRcA5wCfchxnAXAt8LDrunOAh6O3J15uKKGXkFhrobnhsOqLId5Wqru1lWoyaNsHgQDkhPyO5MhycrULSRwlRAWGiIhMnKqqcnIirdz+ms+ysORF/qvuWu56dSlZD6iRosSWqTiRwBdvIvKdL/O7Cz7BioFbWPnnM+juDhAMRli8uIfrr0/cF0Wp7tAmnrW1IWprQ6Nuwmpmz/deMG6ph1POOObxcmSu6zYADdHP2x3H2QBUApcAF0YPuwN4FPjShAeQm4fd0zThTzthOtqgu8urtBhJSbm39Wb7PsgviG9sMrFa9sDUQkwggd93j/bAsNb6sgtTqlECQ0QkiTQ2BnjjaVu5ofjzTI008Ymnvsk/2s5nyZIuvXCUuDBlFQSu+Qbc8mWuav4c/8z+HnWR04b1w/jhD1tG11dB4mrNmkZuuCGf1auzx5d0qqoGE8C+vAGjBMaEcRxnBrAIWAeURZMbALvxlpiM9JjlwHIA13XHvMVsa1EJfds2U5KgW9P2hRtoAabMmkfWCDH2zp7LPmBKTxeZVXMO+3qyb7ubTONr6WzDFpdRGB1PIo6ts6SMjkiEolAOgWDusR9wFIk4vokyUWNTAkNEJIn86tsNfC3vWrIjfVz+xPd5rmshfX2MvhGfyAQwRaUEvngT+774FX7xus+w+7Kb+NmfT1U/jAR3cBNPY8bYxBMw2Tlwwgz1wZhAjuOEgPuAz7qu2+Y4zv6vua5rHccZcY2E67orgZXRm3asW/hG0jKw7W00Nzcn5DvKkc0bAWjLzsWMMDYbfRG5b9NGAqWH98mYDNsaH49kGt9g026oOHH/eBJxbJHo/8I921/FFJYc13Ml4vgmyrHGNtrtrRO4FkdEREarqqqc95+2nWXNn6XfprPksf/P3p2HR1WeDRz+vZN1soeEhCQgEElYAoq4VqlWcYHWjQqnWiu21Vq1ahe1i/pRqwLWve5FagWl2oOtVlqpe3FjUVQ0oAHZA9kmC4RM9vN+f5yZECCQbfY893XlmsnMyTnvTJJJ5jnP8hc+qp2IZcGsWQ3S90IEnErPIOePt+NMjyflmdm896JL+mGEAZfLQWFhK1pDYWHPm3h6qSPHwpYN6PZ2P61w4DAMIwY7eLHYNM1/em6uMAwjx3N/DuCfOo/EZGhtgZZmv+y+3yrLQCnI7DIBBQZl2X0TpJFn+KurRqVnBHsVh6USPFkX0v8nICSAIYQQYayiwsFFF2Xwv/teZNGJP2dXcw4XfvhXSttHMH26m9WrK2RcqggalZGF45d3kp6ueem0axiVXgqA02kxbZqboqJWGa8aQvLzc1i2zElJSSygKCmJZdkyZ+8CTaPGQnMT7Njst3UOBIZhKOAvwJemaT7Q6a5XgMs91y8H/uWXBSQl25cN9X7Zfb9VlsGgwaiYmC7vVtHRkJEFMko1rOlGNzQ1QogHMPCWjbj3BncdfqJbW9CfrQr2MjrIfw1CCBHGHnooiRE7l5Gz7B52RBcxY8V86hjc69RvIfxFDckj+qY/EK8aefqo6xiaXEVTk2LTpmg+/TSGBx8M4c7yA8yKFRVceKEbp9N+3XA6LaZPd7NyZUWP96FGjQNAb1zvlzUOIKcAlwFnGIbxmefj28DdwFmGYWwEzvR87nMq0fN7uTc0Axi6sgwOMYGkQ3auvZ0IX3XV9mVaiAcwvL8vEZqBoT9ZgfXYHHTp1mAvBZAeGEIIEZa80wJ+POJ57prYC05AAAAgAElEQVRwP+9UnsxPP7mHFuL473+qWLw4gcpKKRsRoUENHclD1n38KvEXLDzmWmaseIoNG9KA3k+6EP7TuQdGXFzve2AAqEGZMHgIesM6OOsCP642spmm+T5wqOYTU/y+gMQU+zJUMzCqylCTTj7sJmpwDnrTVzIZIpzV2gEMFeoBDE8GhnY3HPKXNqzV7wZAl+1ADR0R3LUgGRhCCBF2KiocFBW18PC0P3P7uPt5tfx0rl9/D9MusFizpoKiojYpGxEh57YFuThvvI1RaaW8cvZ1ZCTZqbZ9Ocsv/MflcjBjhpvCwlZmznT3qX+OKiyCjevQlmSAhS3vGeUQDGBo9147M+RQI1S9snLsUaueN18i/GhvBkaol5AkRHYJCQ2ex1W+M7jr8JAAhhBChJmHHkzkrIb5XKie4h87v82v1s+lvjFOSkZEyFNjjiLq6t8wTG/gvjG3kRDfSmOj4oMPYoO9NOGxYEEtTqemuDiG+Hjdt0BowXj7jW/ZDt8vUASGpweGbgjBN2RV5YCdYXE4Ktsz0aBC+mCErVpvCcmg4K6jO84Ib+LplgCGEEKIPsjPz2Fo3hBGrXmcnx25kGe3XcSv1t5Oa3u0TBoRYUMdfQLP618yJet9VvziLkaPbqGyMkp6YYSA/Pwc8vJyWbQoqV/TYlRhEYBdRiLCU4K3B0bojTvu6GvRXQbGkKH29hJIC1911ZCYjIqNC/ZKDktFRUG8ExojNIDhycTSFRLAEEII0QsrPtjFC+fezg9HLOHJzZdx1+Zfc+H0Jpk0IsLOrAWnMX/rLNI//w+nt74AyGjVUOCLJp6APdoyPRM2SgAjXKnYOIiNC82UeG8Ao7smnhlZ9mPYtd3/axJ+oWurQ798xCshcV+pRYTR3syS8p1orYO7GCSAIYQQYaGiTLPuN0/wDetV/vT1Fdy/5XqamhxSNiLC1ncXzWCN4wxuGfMI5+W8LqNVQ0DnJp5K9a2JJ4BSClVYhN5QHBL/7Iq+cSSnhuYUksoySB2Eios/7GbK4YCcYZKBEc5qq0N/AolXUio6BDOWfMIbyGxuhN3BP1kmU0iEECLE6fZ2ds55jNPi3uSpip/g+salLH3UJZNGRFjLzoFH0n5L+9c1PHj07/n+6kw2bRrPxo32aNV58yL0H8EQ53I5KCxspaQkhtGjW/temlZYBKuW2282vb0IwpxhGGf0cNN20zSX+3UxAeBITqEtFJt4VpVBVjfZFx4qdxj6y8/9vCLhN3XVqOFHBnsVPZOSBnvqgr0K/2ioh8Rk+7JiZ9B7kkgAQwghQljBkYO5Z8xszs99kz+W/IzHNv0I1sALLyTKyEkR9sqrnbxZ8Acyt1/Pgkk3ceGKp9F6hIxWDRLveGavkpJYSkogPz++198HVTgeDegNxfuaKYa/N4BtHHq8qddgIOybuqiklJCcQkJlOWr8MT3bNucIWPEO2r0XlRD235IBRbe12hNkQr2Bp4dKSUPv3BbsZfhHw17IHw1ffIwu34kaPSGoy5EAhhBChKiKXRZ/OfkWTol/h3u+vp7HNl2O02kxdWoTs2fL2WkR/uy+LYqqL2cT/cCNPH3cjZz3wULaYhLk5zwIVqyo4I47UnjttXgaGx39e73JzrPPSG5YB9882/eLDQ63aZr53W1kGEbwc6x9wJGcAtVVwV7GfnRzE+yugW4mkHip3CPQAGWlcOQYv65N+NjuWtDa7qcTDlLSoL4OrTVKdRfjDB9aa3A3oPKGo0s+D4lJJFJkKoQQIUi3tVIx535OiX+HJ6pu4LGNs4iL63tNuhChbPDYLJ5PuYNhzlIem3QrLU0WUVGaa65Jl34YAdS5B0Z/X2+UUqiCiOuDcWEPt7vIr6sIEEdyauhlYFT1cAKJV+4wALQ08gw/nhGqKlx6YKSkQVtb5I1SbW6C9jZ7tHJWbkhMIpH/CoQQIsSMPjKT/373TxS1vMfsdTcx76NZaK2wLGRcqohYH++exLKUG/hW5gcs/O6fWLUqjlWrYmW8aoC5XA5mzHBTWNjKzJnu/r3ejB4PNVXg6uUUkxBlmuZbPdzubX+vJRC8JSQhFYCqLAdA9TSAkZEFsbGwSxp5hp06O4BBeniUkJCSZl/uiYgErH28DTwTklDZeVBeGtz1ICUkQggRUip2tvPMyTdzQvwH/GHDzTyz7Xv7pXFL5oWIVHY5yek8N20blwx9nmPaitihp0o/jABbsKCW3/0uheLiGI45poUHH+z7P+OqcIKnD8Y6VHcjL8OMYRiXAJ+ZpvmlYRijgaeAduAa0zS/Cu7qfMORnArt7fbkgfiEYC8HAO1985TVs74qyuGAIcMkAyMM6Y4ARniUkKiUNLtcaU8d5AwL9nJ8xxPAUIlJ6CF58MkKdGsrKiYmaEuSDAwhhAgRurUV15x7OCH+Ax6uvJGnNxlSNiIGnLMWXMbX6ijuO+pOJqR8KeNVAyg/P4e8vFwWLUpCa8WiRUnk5eWSn9/Ds90Hyh0GSSlQ8oVvFxoa7gJqPNfvA1YDy4HHg7YiH3MkpdhXQmmUalkppGWgnD0PqKjcI0BGqYaf2mqIiYVwab7qycDQYT6JRDe60W1t+25o2JeBwZA80Na+Uq4gkf8EhBAiBIw5MoM3ZjzImNYV3FL8W+77+BIpGxEDUnZeFGbaHVS3pLHguBtJsmrYtCmaTz+NkXISP1uxooILL3TjdNrBUqfTYvp0NytX9q0ERCkFhePRG4p9ucxQMdg0zQrDMOKBycCtwB3AxOAuy3dUsieA4X0DEwJ02Q7IGdq7L8odBrUudKT1Joh0tdWQNih8GmJ2lJCEbwBDt7Vh3X49+l+L993Y0LmExPO7F+RGnhLAEEKIIKqocPC9i5JZdcUvmJL1PrNLfstz22d0vHFYvbqCuXP3eNLrhRgYttVk8K+cu0iL2c2jE29h00aHbzICxGF1buKplG+yv1TheKiuREdIH4xOqgzDGAVMAz4yTbMZiKf7Eathw9ERwAiNaUBaayjfiepler7KPcK+IlkYYUXXVYdN+QgAicngcIR1AIPij6Gmyg4UemhvI9/EZDsDA4LeyFMCGEIIEUSPPhjDlW23kbTlI15OvJGFmy+SshEx4C1YUMv192bTZlzLNzI+4TfjngT6nxEguudyOSgsbEVrKCxs7Xf2lxo9HiASszDuBNYAfwHu9dx2JrA2aCvyMW8JiQ6VDIxal92Po7cZGDkyiSQs1VaHzwQSPP1WklPDOoBhvf+mfcUzAQbYN1UlMdEu3UpNlwwMIYQYiPLzc8gflsGpX/6BM7I+4Ldf3MINSy5BKVi6tErKRoQA0qaezkdx3+Hq4c9wTu57NDUpGa/qR/n5OSxb5qSkJBZQlJTEsmyZs38ZL7lH2GfuSiIjgGEYRgKAaZrPADnAUNM03/DcvRK4OEhL8zmVnGpfCZUeGGV2A8/eZmCQ6ZlEIhkYYUNrDXU14TOBxCs5LWx7YOjdtfDFx6Ac+ybAgN3E0+GAOKf9eXaeZGAIIcRAtOLd7bwy7Rd8a/AKfv35bbzkupDp092sWVNBUVGblI0I4bGw6ZeURY/iyRP/j+sv3STjVf3I1z0wwHNWsqAokjIwthmG8bphGL8Ack3TdHvvME2z0jTN8iCuzac6mng2hEYAoyOtvZcZGMoRBUOGSgZGONlbD22tEEYZGIDdByNcAxgr3wHLQh13CtTv3tfIs6EeEpM7epGoIUOhrDSo45UlgCGEEAFWsaOFXbfNY7T+mF9/cRsvVV0gJSNCHMITC9zk/eEm3A2aKZvvpLxUSz8MP+ncA8OXpWxq9HhwVaBrqny00qDKBf4IDAOWGoaxwTCMPxmGcY5hGLFBXptPqZgY+6xriAQwKCu1s3mS03r9pTKJJMzUugBQ4dQDA3uUajgGMLTW6PffhFFjYcwE0Br2eE6iuRv2nwQzdISdleH5HgWDBDCEECKAdHMTe+bNYXz0GuaW3oZzyhQpGRGiGyorF33ZzzkmbR2/n/AggIxX9ROXy8GMGW4KC1uZOdPtk9clVVAEgN64vt/7CjbTNFtN03zLNM0bTdMcC0wFNgI/B3YahvGKYRhXG4aRHdyV+khiUsgEMHTZdsgZ2repFHnDocaF3hsaDUlFN3Z7JhSnhVkJiSeAEczshD7ZXALlpahTztzXd8TTB0M37IWExI5N1bCR9pUdWwK9yg7yF18IIQJkfEEqH1xyN8Nb1vKLtXcw//MLWLgwifPOGywlI0J0I/2Mk/ggfiazhppcMOwNmpqUjFf1gwULanE6NcXFMcTHa9+8Lg0bAfFO2Liu//sKMaZpbjZN81HTNL8NHAHMByYA5wV3ZT6SlIwOoR4Yve5/4aFGFNhXtn7tu/UIv9F13gBGGJaQtLVCo7v7bUOIXvkOxMbZ5SPeoJE3iOQpIekwdAQohd6xOeDr9IoO2pGFEGIAqdzexPMn38bomHXctP4OXt41FafTYurUJmbPljNCQvTE4sZrOCKmmDlj5vBx1Xg2bLDLRxYtSmLRoiTi4jSbN5cFeZXhKz8/h+bmfWe3ffW8KkcUHDkmIjIwvAzD6OokYLNpmv8G/h3o9fhNYrKdLh5kun4P7N0DQ3o5gcRr+Cj7TdfWDajxk3y7OOF73gBGau/LhYLKu949dftlLYQ6XVkOecNR8QloT9BI19bYM6Hde1HZeR3bqngnZOWitwcvgCEZGEII4We60c3eeXdQGL2OOeV/4J/bz5FRqUL0wZ8X7GX4Hb8kKamdZ6fcSqKzFZDxqr7ijyaeXqqgCHZtj6QU/jag9cAPwzCaDcPYYhjG/YZhhH1qkEpMDo0SEk//ij5nYDgT7EaeWzb6clXCX+pqICkFFR0T7JX0ikrpFMAIJ40N4PQEXJJSICoadnsmkTTshcT9gzFq2EgpIRFCiEh1TGECn8y6g9yWL/nZZ3NZ8OlUtFZYFtL3Qog+UIOHEHXp1YzSn3NF3kLi4jSNjYoPPoio/olB0bmJp1K+DbKqgnH2la+/7Pe+QsT1wNvA2cBY4BzgLeDXwDXAycBDQVudryQmhcQYVV3etwkknamRhbBlQ/j1JxiA9O6a8Ot/AXYJCUB9+AUwlDMB8EyOSk2H2hq0ZdnBjc4lJADDRtqNmYOUnSUBDCGE8JPKTXtYcvLVFKVu5Prie1hWPqXjjObq1RXS90KIPlInfYvV+kx+WTifN+a/x+jRrVRWRkkvDB9wuRwUFraiNRQWtvouyDqyEKKjI6mM5FfADE9Dzw2mab4JGMANpmn+F5gBnBvUFfpCYjI07LXfyARTWSnExsGgwX3fx8gCqN8NkTENJ7LVhXcAQ4ddBoZ7/5KX9Ax0XTU0ue2JJAn7/21Vw/LtK6VbA7fGTiSAIYQQfqDrqmm/9xaGOHZw6657WbbzVCkbEcJHlFKc9PAVlDVmo56+n52bWgAZrdpf+fk5LFvmpKQkFlCUlMSybJnTJ8+niomFEQXoyGnkmQIkHHBbApDquV4OOAO6In9ITgFt2WnkQaTLdsCQPPvscB+pkYX2lS0bfLQq4Te7a1Cp6cFeRe8lpYByhF8JibtTCQnYwaO6mn2/9wcEMPBMItFBKiORAIYQQvjY5HGw+dr/I6HZxWWrH+GFtZOlbEQIH1MJiSTd8EuGJZYxZ8I9gPTC6C9/9sAATx+M7ZvQzU0+2V+QLQLeMAzjJ4ZhTDUM40rgNWCh5/6zgZKgrc5HVHqmfaWuOrgLKStFDelb/4sOecPtLCDpgxHStNUOu+sgNcwmkOBpWJyUHFYBDN3aCq0t+49KTcuwf+c9JSIq8YAMjLRBdrZJkCaRSABDCCF8pKwMrp3ZyJtTryArsY4frX2U1bWTpGxECD/JOGEM/3NexvScV7lw2Os0NSmiojTXXJNOZaX8i9NbnXtg+CNjTBWMg/b2SBlleTPwKHAx8CDwfeAx7B4YAO8ApwVnaT7kHWNZ6wraEnRTo1320Y/+F4DdEHJYPnqrZGCEtPo9dtZPOJaQAKSkhVcJSWODfenslFCWNgiaGqHaU251YAYGwLCRQcvAkDGqQgjhI/P/sI3b4q+nZW8rf019iNWVE6RsRAg/W+L+IQUxq3ng+LvJ/dYYlv4vl9JSux/GvHkRM/EiYFwuBzNmuPnqqxjGjvVhDwyAEQUA6K0bUaPH+26/QWCapgU86fno6v6ISDPBk4Gha6tR3WzqN5W7AFD9DGCAXUai338D3d7W730JP/GMUFVhHMBgdxidqHJ7Ahide2B4R6nu2mZ/nnhwAEMNy0e/8S90W2vAp8XI6QkhhOin/Pwcpo7dzczt16DQnL/8Ke55fiJKwdKlVVI2IoQfzV9Qz/DZ19He0MTR6x5hx44otJZ+GH21YEEtTqemuDiG+Hjt04wxlZwKGVmwNfxT+A3DUJ7ykbcMw/jcc9uphmEYwV6bT6Wm2zX9QczAwOUpYcoc0v99jSyAlmbaSrf1f1/CPzwBDMKxBwaeUaphlYHhBkA59wUpOoJHO7fbl10EMBg2Etrb7Aa7ASYBDCGE6KePF7/BPyb/lEbLyYyVT1HaPoLp092sWVNBUVGblI0I4WcqZxht3/kB04a8w8zhywC7f8O0aW6KilqlnKSH8vNzyMvLZdGiJP8FgUaMQkdAAAO4A7gCeAo4wnNbKfCboK3ID1RUlP1GMog9MHRHACO73/tSI+xGnm2RMw0n4ujdnp+1cM7AqK8Ln3G9jZ5GnfuVkHgyMHZ6An1dlJB4J5HoIPTBkL/oQgjRD7XvrCThL7+nVmVz0coFlLUPk5IRIYIgefp5bIsu4v8K7mNochVNTYpNm6L59NMYGa/aQ/5u4gmgRhSAqwJdH/blPT8EzjVN8wXA+05lC5Dvi50bhvG0YRiVhmEUd7ptkGEYbxiGsdFzGZhT1OkZ6NogNvF0VYAz8aBGgn2SlQMJibRKACN01XlO+KSEZwYGKWnQ0gLNjcFeSc94MjD2LyHxBI8qd0F0DCo27uCvy86xRxsHoQ+GBDCEEKKPrPffIOlvd/NF3Rh+vP4Jzp+VKSUjQgSJckSxoPUWEmObuHPMXLSGDRtipZykFzo38VTKP/17lKcPBtvCPgsjCvDOFvUGMJI63dZfzwBTD7jtt8BbpmkWAG95Pve/9EwIYgBDuyohM8sn+1IOB4wopOXLz32yP+EHu2sgORUVHaatGlPS7MswKSPR3h4YncaoqninnZHR3g6JyV1+nXJE2Y08gzCWWAIYQgjRB/O+9QZ64SO8W3Uil6x+nHVbMvnzn6M477zBUjIiRJDMXZBMrHEZUwa/x5zzXvJrJkGkcrkcFBa2ojUUFvq4iSfA8FGgVCSUkbwKPGAYRhzYPTGAO4Glvti5aZrvAjUH3HwB+8a0LgQu9MWxuqPSM4LfA8MH5SNeatxE2ndsQddU+Wyfwnd0XQ2khmn5CJ4eGBA2AYyOKSSdMzBg3wSiA2/vRBUUwdav0c3Nflpc1ySAIYQQvaC1pn7hM/y64BE+0mdw3br7aGx34nRaXHxxu7xBEiLI1JRzYdQ4ZlgPk6KrOyYByXjV7uXn57BsmZOSklhAUVISy7JlTp9mrihnAmTnocN/lOqvgBxgN5CKnXkxHP/2wMg2TbPMc70c8N27+sNJz4SmRrQ31TyAtNZQXYHyZQCj6Bh73+s+9dk+hQ/trg3f/hcQdhkYuBtAKYiL3/927/fgMKVbqnC83chz81d+XODBwjQ3RwghAk+3t6Ofe5yE999g0bYZPNf6c+obYzveIKWkaOl7IUSQKUcUjh/eQPStN/DXqXcTfe1vWLw4gbffjpfxqt1YsaKCO+5I4bXX4mlsdOB0Wkyd2sTs2b59vtSIAvRXa326z0AzTXMPMN0wjGzsJp47TNMsD+DxtWEYh+wSaBjGVcBVnm3JzMzs9TGio6PJzMyk6YgR7AbSaSe6D/vpj/baalwtLSSNOJIEHx1bZ2TgGjSYmK/Xkzb9+z7ZZ6jxfu/CUdWeOmILxpJ6iPWH+mNrd4ALSGxv7dPPbKAf3x4smhKSGJy1f5nW7uxcmr5cS2x6BumHWI914mSqHFE4d2wm6ZtTuj2Wrx6bBDCEEKIHdFMjb1/yMN/K/ICHNv6EBzZeBSgALEsza1YDFRXO4C5SCAGAys4ldrrB+Jef46c/Oo9lO7/Vcd+iRUksWpREXJxm8+ayQ+9kAOrcA8MbmPVLQ+LcYbDyHXSTGxWf0P32IcIwjK7Sd6o8Hx33m6bpr0h2hWEYOaZplhmGkQNUHmpD0zTnA/M9n2qXq/clIJmZmbhcLnS03cCvdvPXKGfX9fD+ojfZZ3Yb4hNx9+ExHErsxBNoWvk/qioq7EkrEcb7vQs3ur0dq66G5viEQ64/1B+btiyIimbv9q19+pkN9OOzqqvR8c6Djml5emK0Rsccfj1H5NPw2Sqazp7e7bG6e2y5ubk9WrPkUQohRDd0XTUtc2/hmxkrWKxv5InSnwCqo65+9eoK5s7dg2m2B3upQggPdc50yBvO49+cx8UXVO3XD0PGqx6ay+Vgxgw3hYWtzJzp9ktDYpXl+Se1MuwCSG1Aaw8+/OUV4HLP9cuBf/nxWPt4Usl1EPpg+HKEamdxx5xop86Hfy+WyFJfB9qyR/eGKeVwQMZgqD5kfDGk6MaG/Rp4dkj39sA4/PQfVTgetmxAtwSuD4b85RZCiMPQpVux5t1Me9lOrljzAH/ddJH/z04KIfpNRcfgmHUdUfU1TI+av9/vrYxXPbQFC2pxOjXFxTHEx2v/NCTOtntq6Ipdvt+3f43EHpOaD1wPLMeeFDLWc/kOcJ0vDmQYxvPACmC0YRilhmFcAdwNnGUYxkbgTM/n/udt5heMSSTeAEaGbwMYsUcdbzeTXfeJT/cr+mm3/XqjwrkHBkBG1r7gW6hrbOiyUafyNlI9xBSSju0Kx0NbGwRwGomUkAghxCHo9Z+y+957aGhL4EcfL2DdnjEdCbvespHKyshLPRUiUqj80ajTv8OJb73MLZecyb0vnoDWig0bYgEpJzlQfn4Ozc2q43O/PT+DPRkYYRbAME1zm/e6YRi/Ao4zTdPbqW+DYRgfAx8DT/jgWJcc4q7uC819TMXEQHJqcCaRuCogJQ0VF+fT3TpSUmFEgd3I8/zI7IMRluo8g3dSM4K7jn5Smdnoz1YFexk943bbGSMH6mEGBgVjQTnQJcWo0RN8v74uSAaGEEJ0oe7VN2l54A5ihmTxePITbG4tBDiobETGpQoR2tT0H+AYlMFPE+9h5fulXHihW8arHsKKFRUBeX5UXJw92aIyvAIYB0gFDmzgkeC5PfKkZ6KDkIGhXRUweIhf9q2KJsGWjeiGer/sX/Se9gYwIiADg/rdAR8v2ieNDaiuRqVm58HgIajhRx72y1VCEgwbid5Q7KcFHkwCGEII0YnWGuul50h+6WE+cB3PvdajtKcMlrIRIcKUik/AcenVsHMbg9f+86AmlTJedZ/OTTyV8vPrXVYOOvx6YHS2EHjTMIyrDMOY5pn68Zrn9siTnhG0DAzl4/IRL1V0DGgLvT68J+JElLoae6SndxRpuPL2bKkJgz4Y7q57YKiERKLmzkeNGtvtLlTheNhcgm71ZwugfeSvtRBCeOiWZl4+/3H0qybPb7+QH338EE89l82zzyaiFCxdWsWsWQ1+aWonhPAfdfQJMOkb6P/8He2qYNasho7f51Wr4li1Klb6YXi4XA4KC1vRGgoLW/32eqeyc8OuhOQAvwYeBr4HPABcDDzquT3iqPTMgPfA0O3tUFPl8waeHUYW2rX/X3zsn/2L3ttdA8mpYT8ZRmV4RpK6QjuAoS0Lmtxd9sDoDTW6CFpbAtYHQ3pgCCEEoKursB6fy/lDNrE06ipu33QFbToKp9Ni6tQmZs/eQ1aWxdy5e4K9VCFEHzi+dyXWuk+ZO/E+oq67LXD9HsLIgc9JSUksJSWQnx/v++ckKxf27kE37EUlhl/wyDMq9UnPR+RLzwD3XnRzEyouPjDHrHWBZUFmll92r6KiUOOPQ3/xEdpqRznC+01zJNB1NeFfPgIdP7O6ugLVzaZB1dQIWoOzn+OsC4rsprhffoYqLPLN2g5DMjCEEAOe/upzrLt+iVVRxt319/BO3KU0NTmkZESICKIGDUaddzGsXY3+bFWX/R4G+njVQPXAAPaliIdR/wHDMM7u4XZn+XstAZeeaV8GMgvDM8VB+SsDA2DiibC3Hr7+yn/HED23uwZSIyCAkZIO0dEhn4FBo9u+7GqMai+oxGQoKEKv+dAHi+rewPwLLYQQePpdvPkvrAdnQ3Iqf0r4M0+8fzqrV8ful2IuJSNCRAY15XzIPQLrhafISnMf1A9joI9X7dwDw98B3I6pEs1NPt+3H73Yw+3+7tdVBIHyTiSoC1wAo2MMpR8DGGr8JIiKRq8Nk4kRka6uJvxHqALK4YBBWVAd6gGMvQBdN/HsJXXsyVC2A71re7/31R0pIRFCDEi6uRn97KPoVct5vfJb/OK/t7O3zX7Tsn17DAsXxvDCC4kDNpVciEikoqNxXHoN1r2/Q//HxOX6ObNmNfD884kyXtXD5XIwY4abr76KYexY//XAINZThhBeAYwkwzC6++9cAb6d+RkKPBkYurY6cCnxrgpwOGBQFyMefUQ5E2DMBPRnq9AzfoRSIZ3wH9F0ezvU74bU9GAvxTcys9ChHsBw+yYDA0BNOhn9wlPoNR+ico/o9/4ORzIwhBADjnZVYN3zG/Tqd2k48zKesO7km2dFyWhFIQYAVViE+sYZ6Ndf5qk7P2fu3D2sXBnA0okQt2BBLU6nprg4hvh47b9R0d4+Ci1hFcA4Hbism48fAFODtUC/SfNkYARyEomrAtIz/d7QUU08ESrLoGyHX48julFXY/dj8JYrhTmVkdVRBhWyGhvsS18EMNIGwaix6DUf9Htf3ZEMDCHEgKK/XIs1/x5ot3Bcdxvznp/CJ5/GU1DQKlwH72QAACAASURBVKNShRgg1Iwfoteuxlr8JI4b7zqodKKxUfHBB7HBXmbABbSxqTeA0RQ+AQzTNJcHew3BouLiIDE5oD0wtKvCr+UjXuqoE9CLn0SvXe33M8fiMGqqAFCDIiOAQWY21O8ObOPbXtLeAIYPSkgA1LGn2FkYZaWonKE+2WdXJANDCDEgaKsd699/x3rw95CcxplvLWLotAtYtCipI3Vca4VlIX0vhIhwKiUNNf0yKPkC/dF7gF064e19M3p0K5WVUQOuF0ZAm3h6/qHX4ZWBMbClZ6ADmoFR6d8Gnh5qUCYMH4X+TPpgBJP2BDD8WTIUUN5RqqFcRuL2cQBj0skAfs/CkACGECLi6epKrHtvRf9rMer4yVRfeT9J+UOYNq3xoH/UV6+uYO7cPf5LmxZChAR16tn2mxbzaXSTmwULannhhUTOPjuLkpJYQLFoURJ5ebnk5+cEe7kB0TkTRSk/Z6N1NPFs9v2+hX+kZ3acJfc33dJsT6QYPCQgx1MTT4AtG9C75W9/0NR4gmMRkoHREXwL5QBGxxSSfo5R9VDpGXDkGL9PI5EAhhAiolmr38X6w8+hdAvqil/i+MlNPPhEFp9+GsumTVFSNiLEAKUcUTguvRr21KKXvgB0nYEw0EarulwOCgtb0RoKC/3YxDPOaV+GVxPPAU1lZkNVOVpr/x/M+6YvABkYAGriSaB1QOr3xSHUVkFCIireN2+mg86TgaFDeZSquwFiY1HRMT7bpTruFCjdgq7Y5bN9Hkh6YAghIpJucqP/Nh+94m3IH43jyhs58sRj9qvv9k4csCzNrFkNVFZK2YgQA4kaWYiafBb6zVfQJ08hO294l6NVN260R6vOm7cn2Ev2qwN7YJSUxFJSAvn58b7vgdHWZl86BkZgKCJk50FTI9TXQYqfJ0VUlQMEpIQEQA0dAUNHoj98G844NyDHFPvTNa7IKR8BSEmD6BioDuFGno0NPmng2ZmadDL684/t1wo/kQCGECLi6M0lWAvut+tnz72YquMv4dqrM1m6tIrHH0/itdfiaWx04HRaTJ3axOzZeyTzQogBSn13FvqTFVh/exLHTXM7emEMxNGqK1ZUcMcdKV2+Rvqcp5eCCrOJA4ZhRAPnA98BjgbSgDpgLbAMeNk0zbbgrdB/VHYOGqB8l98DGLrK86YvQCUkAOqUKei/L0Dv3IbKGx6w4wqP6qqImUACoBwOOwsj1DMwfB3AGDSYqF/d6dN9HkjC3kKIiNHRqPOPvwHLwnHzXBwXfJ+HHkll1apYnnsu4aCzq1I2IsTAppJSUN+dBRvWoVctZ8GC2gE7WvXAaSx+fY2sDb96d8MwrgY2Az8FNgFzgKs9l5uAnwCbPdtFnqxcAHSl/1LDO7gqIDYOklP9fywPdeJpEBWF/vCtgB1TdFLrQmVEUAYGQEaWPU0nROnGBp/1vwgkycAQQkQEXbkL65mHYeN61Amnoi69miPHFxw0EhDA4dAsXVrF4sUJUjYihLDLSN5/A73kafRRx6ESkrp8Mx8VpbnmmnSeeKI2YgOfLpeDGTPcfPVVDGPH+q8HRsc0i/QMv+zfT0YBJ5imWd7FfS8Bcw3DyAFuDOyyAiQjC6KiIQABDO0qh8FDUEp1v7GPqORUOOp49Ip30NNnoaLlbVKg6OYmaKiPqAwMAJWZhd6+KdjLOLRGt88mkASSZGAIIcKabm3BeuV5rN9fD6VbUT/+JerKG1EJSYccCbhmTQVFRW0ybUQIAdipvo5Lr4H6PeiXnu24vfNo1VmzGli1Ko5Vq2IjerzqggW1OJ2a4uIY4uO1/14ja6shKsquEw8TpmnedIjgRedtykzTvClQawokFRUFg7PRFQEooaoqD1gDz84cp5wJ9bth3ScBP/aA1jGBJMIyMDKzYe8etB/7QfSLuwHl4xKSQJAAhhAibOn1n2LdfgN66fOoY07CccfjOL5xOkopKiocXHttOtHRUjIihOieGn4kasq56OX/RW/6CqCjnOS88wazcGESO3ZEo3XkjlfNz88hLy+XRYuS/P84a1yQOgjlCM8sOMMwag5xewgXvPtAVi5U7PTrIbTWdg+rIAQwKJoEyalYH7wZ+GMPZJ7xvCrSAhieSSSEahlJY4NkYAghRCDouhqs+fdiPfh7QOP45R9wXHUzKm1QxzYPPZTEqlWxrF4du98ZVL+NBBRChD11wfchLQPr2cfQbfv6MB4qmyvS+mEE8nHqWle4lY8c6KC5g4ZhxAAR/UdGZedCVRna8uOJgL17oLkxoA08vVR0NOobp8PnH6H31AX8+AOV9gQwwqknTk+oIUMB0GWlQV7JIfihiWcgSHGXECJsaKsd/c4y9L+eg9ZW1HmXoKZdhIqJ7djmwDGA27fHsHBhDC+8kBixkwOEEL6h4hNwfP8qrMfmot/8F2rqRUDXzS0jsR9G58eplP+beKrho3y/Xz8zDOM9QAPxhmG8e8DdQ4EPA7+qAMrKhZYWqKvx35vNAI9QPZCafDb69ZfRH7yJmjYjKGsYcGpcoBSkhXVQ82A5Q0E5YNc2YHKwV7Mf3doCba1h2cRTMjCEEGFBb9mINecm9AvzYeRoHLc/guP8S/YLXlRUOCgqamHatMaIP1MqhPAPNfEkmHgSeunz6Kp97Q4GSj8Ml8tBYWErWkNhoX+aeGp3A1RXBuUMuw8sAJ4G2oC/dPpYAFwDfDd4S/M/lW1PIvFnGUnH1IbM4Px8qJyhMHqCXU7mz0wTsU9NFaSmR1zjVBUTC9k56J3bgr2UgzU22JcJ4fc3LLJ+SoQQEUfXuND/MdHvvQYp6airfo067pQuO5M/9FASn34aS0FBq/S9EEL0meOSq7Bm/wzrb0/iuOH3KKU6mlkemOW1aFESixYlERenwz7L68DHVlISS0kJ5OfH+/Sx6eI10N6OmnCcz/YZKKZpLgQwDGOlaZpfBXs9AdcxSrUMNfZo/xzDGzgMUgYGgDptGnr+PbDuU5hwbNDWMVDomqrIa+DplTscSrcGexUHc7vtS8nAEEII39A1VViLn8S69Sr0B2+gzjgXx52P4zh+8kHBiwMbz23YEIvWCstC+l4IIXpNDcpETf8BFH+CXrV8v/u66hMxbZqboqJWKivD+9+qgPXA+GwVJKdCfqFv9+tnhmGc771+uOBF5+0iTnoGxMT6d5SqqwJS0lBxcf47RjfUMSdCShrW8mVBW8OAUuOKvAaeHirvCLtvTEtzsJeyP08GhgrDJp6SgSGECCm6ugq9bAn6fbsDuDplCmrajEPWwnrLRrKzLf73vzgaGx04nRZTpzYxe/YeybwQQvSJOv3b6I/eQz//Z3TheJSn3r+rfhibNkWzcWMMDz6YxLx5e4K88r7r6rH5OoNNt7aiv/gYddzkcJxAcrFhGHOBxcByoASoB5KBQuA04AfAZ8ArwVqkPymHA7Jy0BX+C2BoV0XQy4tUdAxq8lnoZf9AV1ehMiLzzXUo0FpDrQsmnhDspfiFyhtuP8ayUhh+ZLCXs4+3hCQMm3iG96kCIUTE0NWVWM8+hnXrT9Hvv4mafCaOOU/iuOxnh23k5S0b2bQpSspGhBA+oxxROH78C2hrw1r48H618N5+GFqzX9ZXJIxXdbkczJjhprCwlZkz3b7PYCv5Apoa7V4jYcY0ze8DlwB5wLNAFdAIVAILgSHA90zT/EHQFhkIWTngxwAGVeWojOCVj3ipU88BNPrd14K9lMi2dw+0tkR2CQmEXh8Mt7cHRvgFMCQDQwgRVLqqHL3sRfSHb4FSqG+ebU8W6eYP2YG12hs22M08LUsza1YDlZVhd2ZPCBFiVFYuauaP0YufQC9fhjr9OwAd/TB+/vO93HFHCq+9Fn9Q9le4WrCglt/9LoXi4hiOOaaFBx+s9en+9dpVEBsHY4/y6X4DxTTNL4DrAAzDSADSgDrTNN1BXVgAqew89Bcfo612n2fR6LY2eyLFSSEQwMjIgvHHoj98E33B9+3sE+F7nhGqKj2yRqh2yMqB6GjPJJLQoRvDtweGBDCEEAGntYbtm9DvvIpe+Y4duDj1HNTUGR1p2odSUeHg2mvTWbq0iscfT+ryjYNkXgghfEWdNhW9dhX6xb+ixx6NGjK0475IG6/q7wal2rLQn62G8ZNQscHrb+ALhmEcZZrm58CACVx0yMqBtjaorvJ9qUdNFWgr6CUkXuq4yegvPobtm2BEQbCXE5mq7QAGEVqmo6KiYMgw9M7twV7K/rZssEe8JiYHeyW9JgEMIUTA6N216FX/Q3/4NuzcBjGxqNOmoaZehErv2ezvhx5KYtWqWJ57LsHvtdpCCKGUwnH59Vi334D19EM4fvNH+x9SD285yaWXulm8OIG3346ntDQqLPthrFhR4d+Mkm2boK4adfSJvtlfcP3bMIxE4D3sfhjLgU9N09TBXZb/qexcNNhlJL4ONHhGqB6udDSQ1ITj0MqBXrsaJQEMv9C1LvtKpJaQYDfy1BvXBfSYet2n9rGLjjn4vpJi9Huvo848HxUXH9B1+YIEMIQQfqXbWmHtR1gfvgXFa8CyIH806gfXoo6fjOrh/OmuzgwCOByapUurWLw4QcpGhBB+odIyUJdeg55/D/rVJajzLu64L5LGq3bOKFHK94Fh/cbLEBuHOvp4n+wvmEzTPMIwjHzgVOzmndcBGYZhvG+a5rnBXZ2fZecBoCt3oZjk011rl3eEaohkYCSnwKgxdubQBZcGezmRqabKnmyTlBLslfhP3nBYtRztbgjY1A/r+fngKsdx3W2o8ftGAevmJqyFD8PgIagLLwvIWnxNirmEED6ntUZv24T1/Hysm3+I9eTdsH0T6pzpOO54nKjf3YvjtKk9Dl7Aocf7rVlTQVFRG3Pn7ul4IyGEEL7mOH4y6oTT0P9+AV1SfND9B75GxcdbZGS08+9/VwV6qf3icjkoLGxFaygsbPVZE0+9ZSP6o/dQZ12ACsOU5a6YprkZ+BBYAawE2oGsoC4qEFLSIN4J5aW+33dVBURFQ/og3++7j9TRJ0LpFnR1ZbCXEpmqqyA9E6VU99uGKeVp5MmuwJSR6OYme9Sx1lhP3I3etG/qs37pWagqx3H5DUEdVdwfkoEhhPAJrTXs3IZe9wl6xTt2iUh0DOqYk1AnnwHjJva52Ze378XQoW1SMiKECBp16dXo7V9j/fmPOG59YL/Ril31w2hqUjz7bELYlJIcmEVSUhJLSQnk58f3K4tEa431j2cgKQV1znd9sNLgMwzj78A3gF3A/7BHq15tmmZ9MNcVCEopGD4KvXmDz/etq8ogY3BIjdhVR59g98BZuxp1RmQn1wSDrnVBN/3Pwl7eEQDoXdtQo8b6/3g7t4HWqB9cg37tJayH77AbJ5dug4qdqNO/jRo93v/r8BMJYAgh+kzXVaPXr4UvP0N/uRZ2ezIgRhaiLr0adfypqMSeZ1kcirfvxa5d+9eaS8mIECKQVEIijp/dijX3JqzH5+D49R/3O4PlcjlwOOiylCQ+XrNpUzBW3XN+64Gx7hMo+QJ18VWoMOx4fwiTAAtY6/n4LFDBC8MwpgJ/AqKABaZp3h2I43amCsah/7ME3eRGxfvme6rb2uCrL1DjfVuW0l9qSB5k56HXfgQSwPAprTWUl6KOmxzspfjXoMEQ54QANfLUpVsAUGMnosZOxHpsDuzYAnnDUSefgZpyfkDW4S8SwBBC9JhuaoQNxej1n6HXfwZlO+w7klNRY4+2syzGHt3tCNSeOvBs4PbtMSxcGMMLLySGTU25ECKyqCFDcVx5I9ajd6EXPQpX/qoj9XnBgloqKhxdBgEeeij0/+XqKoukv5lu2mrH+sdCu976tHN8uNrgMk2zwDCMHOweGKcCvzUMwwm8a5rmlf46rmEYUcBjwFlAKfCRYRivmKa53l/H7IoqGIfWFmwqgS6aBPbJhmJoqEdNOtk3+/MhdfQJ6LeWohvdkRSEC77dNeBusHtERDDlcEDuMPTOAI1S3bHVLvPKzEYpRdTtjwTmuAESMj0wDMOYahhGiWEYXxuG8dtgr6crFRUOpkyJprLS0fH5RRdldHze1W2yjWwTStuUl9Pj/WitqSpxMffiL6l//gXa7/0d7b+4FOuRO7GWvwbpGagZP6T2Zw/zvW3/xnXBr3GcciaVrdk+WXNxcTTR0Zozzmg6qO/FypUVCCFEsKijjkddcCl69XL06y/vd19XQYCWFpgwIYb16/cFMXryOujr23qyjcvl4DvfaSQqSnPuuY397oGhVy6H0q2o6ZehomP6ta9QY5pmGVACfA1sBYYA0/x82BOAr03T3GyaZgvwAnCBn495sPzRoBzor30XN9GffAhx8RBiGRhgBzBob7OziYTveDISVIQHMMDzGHdutbNO/EyXboWhIyK2r0jU7bffHuw1eKPJ/wXOAeYBDy9ZsuTdmTNnHq7z1e319YEtM5wzJ5n//CcWt1tx5pnNzJmTzKuvOjs+927T+TbZpnfbJCQkcOutUSGznkjbpqFB8a1vNRy0zZTT6vnrnRXo4k8Y/PUbDF1nos2ncS5fwuS4N4naUoxKTOa95rP53YdXUzz+Oqb836moUWO5809H8OqrCT5f8/e+N4jy8ihqahw0NDiIi7PTso8/voULLmjywW+07yUkJOB2u4O9jIglz69/yfPbSwXj0Lu2w9v/QeWPRmXldNz1wgsJnHxyM/Pm7cbhgFdfdbJ3r2LVqlh++EP7Oe7J66Cvb+vJNuef38QDDyRRXm4HLv75z5o+P0W6tQX9xDzIysXxvSv9+s90b39+k5OTAf7Q1+MZhvHKkiVLHgO+CzQDbwC3mKZ5a1/32RNLliw5CciaOXPmK57PRwJjZ86c+eoB67tqyZIlf16yZMlVM2fOzI2LiyMhIaFXH9HR0cTHx3d5X2JKKs0fvU9UQz0Z587o9b4P/HDGxdE4/z5iJ55IxjkX9Ht//XlsXX7kDsW97J/ExcQw6Ixv+319AX98Qfpg7WpaPltN5lU3kjgoI6Ie24EfjuYmmt97g/TJZ5I8bLjfHp/T6cS98FGcx5xE+qlnBv1x9+axRdkjyrt9XVaBiAJ1xzCMbwC3m6Z5jufz3wGYpjnvMF+md+3aFYjlHZTGLkR40mTG1pDnLGOYs4xhCTsZk/w141I2cGTiNqId7QC42+L5qn4UX9YXsG7PaL7cU8BX9aNoaA/M2KfDrf/yyxuorIwK2WkjmZmZuFyuYC8jYsnz61/y/PaebmrEuvvXUFuN47d/ROUM2+/+vLwcIBL+f9Ds3Nm7sj2tNXrxE+jl/8Vx412oMUf5aW223v785ubmQj++OYZh/BBYbprmlr7uo4/HnQFM9ZapGIZxGXCiaZrXHebL+vQ/c3fPqfX3Bfb39+Hn+51do0uKse67BXXVr3Ec7/9+CH15vbOeuh/95Wc47ltolwSEsHB5PbeeeRj9+UdEPfBsj78mXB7bgXTDXqwbZ6HOPA/HjB8dcrv+Pj5dVY51y1Woy67FcerUPu/HH7p7bD19XQ6Vgsw8YEenz0uBEw/cyDCMq4CrAEzTJDMzMB1rS0pa+e1vo/jXvxw0Niri4zVZWZrKSrvDuNOpOftsO8X99ddlm/5so5SD114jZNYTTtskOtuYcVYl6bqcXV+UMziqnOFJZYxM2cVgRzm58eXERzXv97O9szGbkoYCVjaexpqKQtbWFFJp5XHm2Qqy9j/WEXlWQB5XXJwmKgrsE2kK0AwfrnnxxTaOOirWs/LQ7FYdHR0dsNelgUieX/+S57dv2v/vfmp+exU88H+k3fEI0cNGdty3enUrM2ZEs327wvt6lpenGT9e8+679mteV6+Dvr6tJ6+9Tqfm1FMtiosVO3fuW6/39be3PxvuV/9B/fL/kjD9ByRPPqPvT3APBfrn1zTNZwJ2sP3tBDpHyoZ6bgs4NWoc+s1XYNsmOHJMv/alP/kQYmJRE4710er8YPwkWL0cdmyG4aOCvZqIoHdtj/j+F14qMQnGHo1e8yH6oh/6LyOtdKt9vKEjD79dGAuVAEaPmKY5H5jv+VQHKvoWEwMxMak0NSUQH69pbob4+Daam2M89a2QmtqI1oqmpgTi4mSbvm4TF+ekqckRMusJ5jYJ8c0k6kaOHFRLiqrl5PhyEq068oc2MNhZS1pUHcPSqnEOryMjro60mN1EtXkarY2zL1zN6VTrbL6qO5K3XZPZ0ZBDwYnp1DhymP/iSJodSbS0QEFBKxtLY4iNhZYWSE1tCNpjb2mBlBQLu0WPnSEWF9dGbq6LUA+4h+tZgXAhz69/yfPbR1Gx8Ku7sO6/lepbr8Vx0xxUrj0yLy8P4uIGY/+7Zb+eJSa2kZXV2vGa19XroK9v68lrb1MTZGc3snlz3H7r7cvrr17/KdZfHoSjT6Bp6gyaA/Bz1ccMjHD0EVBgGMZI7MDFxcD3g7KSAnscpP56PaofAQxtWXYAY/wkVLzTV6vzOVV0DBrQxZ+gJIDRb9qyYNd21OSzgr2UgFHHnoxe+Ahs3wzDj/TLMfSOLaBURAeGQqIHxpIlS1KBC2bOnPmc5/PvAPUzZ858/zBfFtAeGN561iefdNDc3Mi6dbFcdJG7o761qioKt1vtV/Mq2/R+m6amKE480R0y6+n3NkpTX9VMjLuGbx+/jTnXfcGYhK9Ida3n6tPeZ/aFb3FWxluM2/06x7qXcu3Y57n5qL/ys+Hz+fGgP3N1/rP8YOiLzBz6bya0/I/RrSv5RsYnFGXtICOpgTq3E5WRRcqEfFbvPYkPWs7if1zEqkGXknbFLJ7a8SPuWTGT+FNO4dybx7Kh5Ti+qBxKVVMGx52kg//8HGKbzz6LZdSoNu66aw9ffx3N7t1R/PSnDQH7fe+rhATpIeBP8vz6lzy/faeSU1ATjkevfAf9wVuo8cehUlIBePjhZIYObePhhzXr1rWze3cUqanWfq95Xb0O+vq2nrz2VlVFsXVrNEOH9v31V5fvxHro9zA4B8cNs1Exsd1/kQ/09ue3vz0wgmXmzJnWkiVLNgKLgeuB50zT/Ec3X9an/5m7e05VnBO9ajm0NOM44dRe77/D5hL0m6+gzv0eauiIvu+nF/ryeqfi4tGffwTVlTgmn+mnlflGWLyeV1eiX3sJNfnMXgWEwuKxHcqgweg3XoaEJHt6Xxf6+/ist5aCpXGcfWGf9+Ev3T22nr4uh0oPjGhgAzAFO5r8EfB90zTXHebLAtYDozM5Q+Vfofr8aq2huRHq98DePVC/G92wFxrqoWEvuO3ruuO65z73XrAOM34uKhoSEiExGRKT7Bc0zyUJSZCUAskpqORU8H4kpaCi+tYVPlSf30ghz69/yfPrX/L89p8uL8W67zaw2u2+D53OgA2E51c37MWadzM01OO49X5UZnbAjh3oHhhhxi89MMDTw+DTlTgefK7PfSGsF/+KfnOpvY8AjSjt6++j9dJz6P++aK81IckPK/ONcHi90Ws/wnr0Thy/+SNq1Ngef104PLbDaX9wNrgqcNz1ZJdlJP19fO23XAVH5BN1degN9YyoHhimabYZhnEd8BoQBTzdTfBCiH7TTW6oq4HdtXZAYu+e/QMUnT/fuxva2g69s4REO+DgCUSoQYM7AhIdtyUk2bd1vj02LmJHHAkhxECjhgzFcdMcrPtvxbr/toOCGJFMt7Vh/fmP9j/mN94V0OCFCKKCIvjgTSgrhbwj+rQL/fnHUFgUsOBFf6jxk9CvmvDlWjj2lGAvJ6zpXdvsK7l9+7kJV+rYk9HPPg47t4KP+1ToJjdUlaNOnuLT/YaakAhgAJim+SrwarcbCtEN3dwMu2ugrgbtufR+7Pd5c2PXO3AmQnKKnf2QMRg1PB+SOmU/eO9LSraDEM4ElKNvGRFCCCEiixqSh+OmuVj33YJ13604rrr5kKnCkUK3NKOfeRi+XIu6/HpUwbhgL0kEiCoYZ/eFKPkc1YcAhq4qh7IdqFPP8f3i/CF/NDgT7T4YEsDon13bIT0TlRDsKXeBpSaehH7uSfSaD33faLPUDgqpYZHbwBNCKIAhRE9oraF+N1RXQXUFuroSXJX2ZXUl1FWDu4ta3ZhYSBsEqYPsX+rxk+zP0wahUgd1BCdISu73KDAhhBADm8rOxXHzXKxH52A9OBt17sXoy68N9rL8QtdUYT0+D7ZvQn33chwDqCGfAJWVA1k56OJP4Ixze/31+vOP7f0cdZyvl+YXKioKxh2NLv4ErbVk0faD3rmtz1k74UylpMGYCej330R/e6ZP+wTpUs9U5wieQAISwBAhRmuNrt8NVeUdwQk7UFFlByiqK+wxGZ0lJEFmFmTl2nPmvYEKzyVpgyAhUf7ICCGECBiVlYvj1vvRi59AL32euq0b0JffgEpND/bSfEZvXI/1xDxobcHxs1tRR58Q7CWJIFATjkO/+xq6pRkVG9err9VffATZeais8JkKo4omodd8aGcQDJASMV/TVjuUlaLGTgz2UoLC8e2ZWPffhn73ddSU3gf+DmnjevuE7KDIHokuAQwRFNq9FyrK0BU7oXKXfb1yF1VV5eiGAzplJyZDRhbkDEWNnwQZ2aiMwXbQYlDWgEs9E0IIER5UXDzqx7/EGn0ULX97Eu74OY4rb4yIkhLr3dfQf/szZGThuHkuKmdYsJckgkSNPxb91lIoKYYJx/b463RTI5R8gTr9O35cne+pokn7xqlKAKNvKsuhrXVAZmAA9gnX0RPQy5agv3lWrwN/XdHNTejPVqFO+lbEn7SVAIbwG93SDOU70RW7PEGKnejKMqjYZTfG9FIKBg2GrBziv3kmTSmD7JTEzGy7B0V86Dd1EkIIIQ7FccoU0iYeR/Xdv+soKVHnGmHZP0m3taL/vgD9v2UwfhKOn9wU0tMYRACMHg+xsegvPkb1IoDBV2uhrQ01ITzKR7zUoEzIGYZe/xmcMz3YywlPngaeaoA18OzMcf4lWPfegn73xPOO8QAAIABJREFUv6gzL+j3/vTa1dDSjOrPSOMwIQEM0W+6uRnKd6B37YBd29Fl9iWuCug8pjdtkJ0meMxJkJ1rpwtm5ULWkI76r5TMTFrCeDSSEEII0ZXo4UfaJSV/exK99Hl08RocF12OGj0h2EvrMb1lI9bfn4JNX6HO+S7qu5eFZRBG+JaKiYUxR6OL1/SqL4T+/GOId0IYNn1V4ybaZTOtLT7tYTBQ6J3b7ROYAzhzSxWOh7FHo199Ef3Nc1Bx8f3an179LqRlhOXvU29JAEP0mG5qhLJSdNl22LUDvWs7lO2we1N4AxVR0XZw4ogj4aTTIWcYakgeZOX0+xdTCCGECGcq3mmXlIybiP7HIqz7boVxx+CY/gPUiIJgL++QdNkOrJefg09W2M2ur7wRx4mnBXtZIoSoCceiP/8IKnbCkKHdbq+1tgMYRceEZfN0NW6iXTazcT2MG5h9HPpDr/sEco8Y8O8NHOdfgvXH36Lfex115vkdt+sv12I997j9SVQ0avwkHMYVh9yPbqiH4k9QU84dEEFlCWCIg2irHSrLYOc2dOlWdOlWKN1qZ1R4RUfb2RQjC+HkKXYKWO4wGJyDipYfKyGEEOJQHCedjj72FPQ7r6KXLcGacyNM+gaO/2/vzqPkLOtEj3+f6g4JgewdknSnk5AEEAiLyCqoIKgwbDpXHsFxZhQdzuyLM8c7DHNn7pk7zvVe79HrXK96mNGrnmGGeVTcRoZFRB0loKyCIBgIWZosdPaQEJLu5/7xViBLJ+nuVPVbVf39nNOnqt7t+b3vW6k89atneef7Gmosidy7hvztW8mL74WxYwlXXkd429WEI+3aqb2FRW8oxoV4/CHCIBIYLH8ONq0nnHJW3WOri+MXQVs7+clHCSYwhiSvXlm04nr3B8oOpXRh4Ukw+1jyI4thzwTGj+6GLZuLAXKXP0v+0d3ka64/YOum/PBi6Ns1KrqPgAmMUS9v2Qw9ryUp8srnYdXy12b6CBWY2UWYdxycvztRMadIVLS1foZPkqR6CGOOILz9neQ3vZ189zfJd3+D/keqA7BdeS1h+szSYsubN5C/8xXyD+6AEAiXXEm47BrChImlxaTGFjpmFONCPP4gvO3Q/fnzQz+GSqVppk/dVxh3JCx4HfmpR8sOpenk++4p7v25F5YdSkMIp55JvuNr5Je2Eo46mty3qxgg9vRzqFz/x/Tf82/kW2+GzRvhALNY5Qd+ADO6YM6CEY6+HCYwRom8a2cxoObuREVP8cjG9a9tNGESzJ5HePNlxePsecXMHzUYGVeSJO0vHDmecNV15IsuJ9/xVfL3vkO+/16YfwLhtHMIp59DmDWIX7QPU968sRjD4Gc/hccfgl07CedfQrjiPYSp0+tevppfOOUN5Hv+jfzi6oMm4HLORQLjhFMIEyaNYIS1FU46nfyNfyJv2dTU5zGScn9f0aJr0RtaakrpwxFOOZN8+1eK1jxnXcDOp5+AbVsJpxWtk8LMLjLA6p4BExh54zp45onis7rFZx/ZzQRGC8qbNxRJihXP79GqYgX07So2aG8vxqY48bTXEhWz5xEm+kEiSVIZwoSJhGuuJ198FfnH3yU/+gD5ti+Rb/tS0RLy9HMJp58Dxx5PqFQOu7ycc1FH+NlPi6TF0meK8awmTS1agbztncUYVtIghTdeQv6Pu+n/2w9T+dCHiy9m/f2waiVMmkw4utqCZ+XzsHYVocln8Hg1gfHkowTHhBmcJx+FjeupXHtD2ZE0jvnHw9ET4PGfwlkXsOPB+6CtDU6sdk2qfg7nNSsJJyzab/f8k/+AnEdN9xEwgdHU8s6dsHolecXS17qBrFgKWza9ttHkqTD7WMKiM6rJimOLQTYdp0KSpIYTpnYQrrwWrryWvP5F8mM/IT9yP/nub5Dv+BpMnFzMXDK1AyZPI0yeWow8P2UaTJqy14CIedfOotnx5o2waWPxA8fmjdC7hvzzR2BDddavY48vxrc49SyYM3/U/Iqn2gpdc6j85Sfo/9zH6P/7v4ETT4MVz8HWLdB9LJW//ASh0kZ+sNp95PXnlR3y4Zm7AMYfDU89CiYwBiXf973iy/ppTTr2SR2EShvh5DPITzxM7u/nlYfug4UnEcYfVWwwpQOOOAJW9Qy4f37gBzB34eDGnmkRfottAvmVHUX3j+r0pPmFFUWLirWrIPcXG7WPga65RV/C3YmKrnn2V5UkqUmFqdMJF10OF11O3raV/PhD8OgD5KXPwCOLYdcu8r47TZhUfKnasgm2bR34wEdNgBMWEa5+L8Gm3KqhcMwsKn/+P8np8+SnHyecejYcPYF81zfIP7wT3nJZS3QfgeKLJyeeSn7ysSFNHzta5Ze2kh+5n/DmdzTlzDN1dcqZ8MAPyA/dx67lzxGuuf7VVaFSgWM6yWv2T2DkVSth+bOE9xx4hpJWZAKjgeQdO4oWFauW752oeHHNa4mK6puYrjmEM88vpiDqPhaO6XRQTUmSWlQYf3TRTL36S2/Oufhle9M62LC+6Ae9cT1sXAcvbS0SGZMmFy02Jk6BiZOL/tMTJxPGHFHy2aiVhSPGEt73u6++zjmTlz1L/sYtxa/Ea3oIgxjosxmEk04nP3TfoKePHc3yj++ujq1zcdmhNJyw6AxyqJC/+oXi9T6D24YZXeTlz+63X37g+xAqhLNGT/cRMIExovIrO2Ddi7BuLXndWli3BnrXkte/CL1rYdMeA2q2tRVJie75RWVl1hxCZ3e1+4dZS0mSRrMQAkyYWPzNPhZ/+1WjCiFQue4G+v/mj+j/7MeKL1yvP7fssGoiLDipmD526S9HVRP+ocovbyffcRucdDphlMyUMRThqAmw4ARY8hRts2aTZ+wz/tCs2fDwYvLOnYQxxffAnHPRfeTEU0ddKzoTGEOUcy5aSuzYDjtehpe3F89ffhl2bCdXH3l5e9F0c30vuXcNrFtb9DvdU1t70Yd12jHFGBUdxxBmzYHO7mKaUsepkCRJUpMLXXMJF11Ovufb8LpTCRMnlx1SbczqgiPGwrIlcN5FZUfTsPK9t8OWTVSuem/ZoTSscMqZ5CVPMfYNb2THvt2RZnQVrfFfXAWdc4plz/4CetcQrrxu5IMtmd+Qh6Dvxt9i7foXob9/cDu0t8PU6UWC4rSzYdoxMG06YdqM4vnkKUX/OUmSJKmFhauuI//ySSoX/krZodRMqLTBnPnkZUvKDqVh5e3byHfeBqecSVjwurLDaVjhjDeS77iNcW96Gzv2XbfnVKrVBEZ+4AdwxBGEM1qjNdNQmMAYgnDeWxk/9gi29QPjxsHYcYRxR8LYI2HsOBi3x+O4I6F9jAP6SJIkadQL44+m7b98suwwai7MXUj+j7vI/X3+MDmAfM+34aUtVK4afS0FhiLM7KLt7/+FMR0d0Nu798oZu6dS7SEAedcu8oM/Ipx2DmHc+JEPtmQmMIagctV1HN3Rwcv7vqkkSZIkjT5zFsArO4ppLrvmlB1Nw8i9a8gP/Zh819fh9HMI844rO6SmFY4cD5OmwqqVxYKf/QS2biace2GpcZXFBIYkSZIkDUOYu7AYyHPZEoIJDPLaVfR/+dPw9OPFgnnHUXn3B8oNqhXM7Hp1KtX+H94JUzpg0RklB1UOExiSJEmSNBy7B/Jc/iy88a1lR1OanDN58ffI/3wzVCqEX/0NwpkXEKbPLDu0lhBmdJEf/FExOcSTjxKuuHbUdlkygSFJkiRJw/DqQJ7P/7LsUEZc7u+HXzxGfvoJ8lOPwdJn4PiTqVz/YcK06WWH11pmdsG2reR//xoQCBdcUnZEpTGBIUmSJEnDNFoH8sy3fJb8wzuhUoG5Cwnxg4SLrxhV12CkhJmzi65KP7oLFp1BmDp6E0QmMCRJkiRpuOYuhHu+PaoG8swP3Uf+4Z2Ei68kvPN9xcyMqp+ZxUwk9PdTefM7yo2lZJWyA5AkSZKkZhXmLgAgLxsd3Ujy+t5ioM65Cwnvfr/Ji5EwbTq0j4HJU+GUM8uOplQmMCRJkiRpuGZ2wdhxsOzZsiOpu9zfR/8XPgl9u6j81p8R2seUHdKoECpthAsvK1q7tI3uLjp2IZEkSZKkYQqVNuieT162pOxQ6i4/8EN4+nHCb/4BYUZn2eGMKpX3fKjsEBqCLTAkSZIk6TCEuQtgxXPk/r6yQ6mb3N9Pvv0r0DWX8MaLyw5Ho5QJDEmSJEk6HF1z4ZVXoHdN2ZHUzyOLYfVKwuWRUPFrpMphFxJJkiSpQcQYrwH+K3AicHZK6cE91t0IfBDoA/4wpXRnKUFqP6FrLhngheVwTOt1rcg503/7V2BGF+ENbyw7HI1ips4kSZKkxvEE8KvAD/dcGGM8CbgWOBm4FPhMjHF0j+bXSDq7Acg9y0sOpE6eeAiWP0e47D8VY35IJTGBIUmSJDWIlNJTKaWnB1h1NXBrSmlHSmkpsAQ4e2Sj04GEceNh2jFFC4wW1H/7V2DqdMI5F5YdikY5ExiSJElS4+sCVuzxemV1mRpF5xxyCyYw8poXYMlThIuvJLQ7AoHK5TtQkiRJGkExxu8CMwdYdVNK6Zs1OP4NwA0AKSU6OjqGfIz29vZh7dcM6nVuWxaewLZvP8a0KZMJbeV9zar1+b3047vZCky75HLaSn5PtPL7Elr7/Gp1biYwJEmSpBGUUrpkGLv1AN17vJ5dXTbQ8W8Gbq6+zL29vUMurKOjg+Hs1wzqdW79k6fDrp30PvkEYdbsmh9/sGp9fn2Lvw9dc9lQGQMlvyda+X0JrX1+hzq3zs7BDX5rAkOSJElqfN8C/jnG+AmgEzgO+Em5IWlPoWtOdSaSZVBiAqOW8ratsORJwtvfWXYoEuAYGJIkSVLDiDG+K8a4EjgP+E6M8U6AlNLPgQQ8CdwB/F5Kqa+8SLWfmd0QQkvNRJJ//gj09RFOdbxYNQZbYEiSJEkNIqX0deDrB1j3UeCjIxuRBiuMHQsdM+o2E0le+gz5xdVUzn5zXY4/oMd+AkdPhPnHj1yZ0kGYwJAkSZKkWuiaW/OZSPKWTeTbvkz+0d0A9O/cSeX8i2taxoDl9vWRH3+IcNpZhEpb3cuTBsMuJJIkSZJUA6FzDqx9gbxzZ02Ol5c/R/9f/g558fcI73gXvO5U8j99hrz0lzU5/kE9+wvYtpVw6ln1L0saJBMYkiRJklQLnXOgrw/WDDhBzJDknOlPn4e2Nip/9Skq7/4AlRs+ApOm0P+ZvyNv3lCDgA9S/s9+Am1tcPIZdS1HGgoTGJIkSZJUA6FrDkBtupE88TA8/TjhivcULTuAMGEild/9C9i2hf5bPnf4ZRxEfuJhOO5kwpHj61qONBQmMCRJkiSpFmbMhkrlsAfyzP199H/tizB9JuHN79hrXZgzn3Dh5fDYT8kvbT2scg5Y/ktb4YXlhBMW1eX40nCZwJAkSZKkGghjxsAxnYc9lWq+/wfQs4zwrl8ntI/Zv5yzLoC+XeRHFh9WOQf03C8gZ8KCE+tzfGmYTGBIkiRJUo2ErrnQ8/yw98+7dpG/eQvMXUh4w/kDbzR3IUyfSf7pj4ZdzkFjWPJU0ZJk/gl1Ob40XCYwJEmSJKlWuo+FF1eTt28b3v4vroL1LxLeegWhMvDXtRAC4cwL4BePkbdsOoxgB5aXPAnd8wljx9X82NLhMIEhSZIkSTUSZh9bPBluK4zeNcVxZnQevJyz3gT9/eSH7hteOQeQd+2Epb8kHHdSTY8r1YIJDEmSJEmqle55AOQVzw9r99y7tngy7ZiDbzh7HszsIj9Y424ky5+Dna8QFjr+hRqPCQxJkiRJqpUpHTD+aFi5dHj7r1sD7WNg4uSDbhZCKFphPPMEeeP64ZU1gLzkyeKJA3iqAZnAkCRJkqQaCSFA97HkFcNMYPSuhY5jDjj+xV5lnfUmyJn8cO26keQlTxXTt06eWrNjSrViAkOSJEmSaijMngc9y8j9fUPeN/euOXT3kd3lzOqGaceQn35iyOUMWHbOsOQpu4+oYZnAkCRJkqRa6j4WXtkBa1cPfd91awnTZgx687DwRHj2qSL5cLjWroItm8AEhhqUCQxJkiRJqqFXZyIZ4jgY+eXtsHUzdAyuBQZQJBs2bXh19pLDsXv8i7DQGUjUmExgSJIkSVItdXZDpTL0mUjWvVg8DrILCfBqd4+85KmhlTWQpc/AkUfBzNmHfyypDkxgSJIkSVINhTFHwMzZ5KHORFJtRRE6Bt+FhM45cOR4qEECI6/ugc7uQQ0gKpXBd6YkSZIk1ViYfezQu5Csq3YDGUIXklBpg/knkJ+tQQuM1T2EGV2HfxypTkxgSJIkSVKtdc+D9b3kl7YMfp91a2HMETBh8pCKCgtPhBeWk7dtHVqMe8jbt8Gm9TDTBIYalwkMSZIkSaqx1wbyfH7Q++TetTDtGEIIQytrwYmQMzz79JD228vqnuJYjn+hBmYCQ5IkSZJqrbtIYOQVQ+hG0rsGhjL+xW7zTygGDT2McTDympXFE1tgqIGZwJAkSZKkGguTpsCESfDC8sHvtG4tYShTqO4ua+w46J5/eONgrO6BSgWmzxz+MaQ6M4EhSZIkSfUwq5s8yARG3r4NXtoypClU9xQWnghLnybv2jWs/VndAx0zCe1jhre/NAJMYEiSJElSHYTObli1kpzzoTdet7Z4nDaMLiQAC06EV15h19JnhrV7Xr3S7iNqeCYwJEmSJKkeZnbDtq2weeOht+0tplANwxkDAwjzFgKwc+kvh7xv7u+HtasIJjDU4ExgSJIkSVIdhM7u4skgupHk3S0whjEGBlB0PRk7jl3Lnxv6vutfhJ2vwAwTGGpsJjAkSZIkqR5mFQmMvGrFobftXQtHjIWjJw6rqFCpQOcc+oaTwFhdzEDiFKpqdCYwJEmSJKkeJk2BI4+CQSQwcu8amHYMIYRhFxc65wyrBUZe3VM8sQuJGpwJDEmSJEmqgxACdHaTV6089Mbr1sAwx794Vddc+jdtIA9mzI09remB8UcV075KDcwEhiRJkiTVSZjVfcgxMHLOsHY1YfrMwyura27xpGfZkPbLq3tgRtdhtf6QRoIJDEmSJEmql1ndsGUTecvmA2+zoRd2bH91zIxhqyYw8iAGDd3L6pWOf6Gm0F52AJIkSZIKMcaPA1cCrwDPAh9IKW2srrsR+CDQB/xhSunO0gLVoIVZ3WQoxsGYcPLAG72w4tVtD8vEyYQJk4bUAiO/vA02rnf8CzUFW2BIkiRJjeNuYFFK6VTgGeBGgBjjScC1wMnApcBnYoxtpUWpwatOpZpXH3ggz1fXzTq8VhAhBNrnzB9aC4w1LxT7msBQE7AFhiRJktQgUkp37fHyfuDd1edXA7emlHYAS2OMS4CzgcUjHKKGakoHjB33aiuLAa1aCUdNqMkgmu1zF7Dze98h5zyoMS1yNYHBDBMYanwmMCRJkqTGdD3wr9XnXRQJjd1WVpftJ8Z4A3ADQEqJjo6OIRfc3t4+rP2aQRnntq57HpXe1Uw5QLnre1fDnPlMnT79sMvaMW8h21/eztS8i7bpsw65/Us7d7AVmLbweCpHTTjs8uupld+X0NrnV6tzM4EhSZIkjaAY43eBgaabuCml9M3qNjcBu4Bbhnr8lNLNwM3Vl7m3t3fIMXZ0dDCc/ZpBGefW3zGLXb/42QHL7Vv+HOH159Ukromz5wGw/olHCaeOOXRsq1ZC+xjWbXuZsH3HYZdfT638voTWPr9DnVtnZ+egjmMCQ5IkSRpBKaVLDrY+xvh+4Arg4pRSri7uAfYc4XF2dZmaQWc33H8vedtLhPFH7bUqb9kEW7cc/gwkVe1z5hfH7VlOOPWsQ++waQNMmuIUqmoKJjAkSZKkBhFjvBT4CPCWlNK2PVZ9C/jnGOMngE7gOOAnJYSoYdhrJpIFr9t75ardM5DUZhrTylFHw9QO6Hl+UNvnagJDagbOQiJJkiQ1jk8DE4C7Y4yPxhg/B5BS+jmQgCeBO4DfSyn1lRemhmTecRAq5J89uN+qvGpl8aRGLTAA6JxL7hnkTCQmMNREbIEhSZIkNYiU0sKDrPso8NERDEc1EiZPhZNfT77vHvJV1xHa9pgBd9WKYpaSKbUbvDF0zSH/4jFyX9/eZQ1k0wbC8YtqVrZUT7bAkCRJkqQ6q7zpbbBxHfz84b2W51UrYOZsQqWGX8265sGuXbD2hYNulnfuhJe2wKTJtStbqiMTGJIkSZJUb6eeBRMm0f+ju/devmplzca/2C10zSme9Cw7+IabNxaPk6bWtHypXkrvQhJj/DhwJfAK8CzwgZTSxnKjkiRJkqTaCe1jCOddRL7n2+TNGwgTp5C3b4MNvTCztgkMZnUXY270LCOcecGBt9u0vojNMTDUJBqhBcbdwKKU0qnAM8CNJccjSZIkSTUXLngb9PWRF3+/WLC6GMAzdM6pbTljjoAZs8iHbIGxoXg0gaEmUXoLjJTSXXu8vB94d1mxSJIkSVK9hFndsOB15B/eST7zgmL8C4AadyEBoGsurFh60E3yRhMYai6lJzD2cT3wrwdaGWO8AbgBIKVER0ftRuodrPb29lLKHS28vvXl9a0vr299eX3ry+tbX17f+vL6qplU3v4u+j/73+m/8UMwYRK0tcP0WTUvJ3TOJT+8mLxjB2Hs2IE32rQBQoAJDuKp5jAiCYwY43eBmQOsuiml9M3qNjcBu4BbDnSclNLNwM3Vl7m3t7fWoR5SR0cHZZQ7Wnh968vrW19e3/ry+taX17e+vL71NdTr29nZWcdopIMLZ5xH5e9uJi/+Hvm+78HxJx96qtPhlDN7LjlnWLUc5h038EabN8DRE+tSvlQPI5LASCldcrD1Mcb3A1cAF6eU8kjEJEmSJEllCNNnEq56L/nK6wgh1KeQzrkA5J7lhAMkMPKmDc5AoqZSeheSGOOlwEeAt6SUtpUdjyRJkiSNhLolLwCOmQljjoCe5w+8zcb1MNnxL9Q8GmEWkk8DE4C7Y4yPxhg/V3ZAkiRJktTMQqUNZnWTe5YfeKPNGwkTTWCoeZTeAiOltLDsGCRJkiSp1YSuueQnHx1wXe7vL8bAcAYSNZFGaIEhSZIkSaq1rrmwaT156+b91720Bfr6TGCoqZjAkCRJkqQWFLqKgTwZqBvJpg3FNiYw1ERMYEiSJElSK6omMPILy/ZfV01gOAuJmokJDEmSJElqRZOnwvijYeX+CYy8aX3xZNLkEQ5KGj4TGJIkSZLUgkIIMHsueeXS/Vdu2lg82gJDTcQEhiRJkiS1qHDcybD0l+QN6/ZesWk9jDuSMHZcOYFJw2ACQ5IkSZJaVDj3Isj95J/8YO8VmzbARAfwVHMxgSFJkiRJLSrM7IL5J5AX30vO+dXlefMGmGwCQ83FBIYkSZIktbBw3kXQswxW7DEWxsYNBMe/UJMxgSFJkiRJLSyc9SZoaycvvve1hZs3wERnIFFzMYEhSZIkSS0sHDUBTjuL/MD3yX195C2b4OXtzkCiptNedgCSJEmSpPqqnHcR/Q8vpv/TfwvPPAFAmLew3KCkITKBIUmSJEmtbtEbYNIUePpxwtlvIlx0OWGuCQw1FxMYkiRJktTiQvsYKn/5SRgzpuhSIjUhExiSJEmSNAqEyY55oebmIJ6SJEmSJKnhmcCQJEmSJEkNzwSGJEmSJElqeCYwJEmSJElSwzOBIUmSJEmSGp6zkEiSJEkNIsb434CrgX5gLfD+lNILMcYAfAr4FWBbdfnD5UUqSSPPFhiSJElS4/h4SunUlNLpwL8Bf1VdfhlwXPXvBuCzJcUnSaUxgSFJkiQ1iJTS5j1eHgXk6vOrgS+nlHJK6X5gcoxx1ogHKEklsguJJEmS1EBijB8FfgPYBFxUXdwFrNhjs5XVZasG2P8GilYapJTo6OgYcgzt7e3D2q8ZtPK5QWufXyufG7T2+dXq3ExgSJIkSSMoxvhdYOYAq25KKX0zpXQTcFOM8Ubg94G/HsrxU0o3AzdXX+be3t4hx9jR0cFw9msGrXxu0Nrn18rnBq19foc6t87OzkEdxwSGJEmSNIJSSpcMctNbgNspEhg9QPce62ZXl0nSqOEYGJIkSVKDiDEet8fLq4FfVJ9/C/iNGGOIMZ4LbEop7dd9RJJaWcg5H3qrxtS0gUuSJKl0oewABhJj/BpwAsU0qsuA304p9VSnUf00cCnFNKofSCk9OIhDWmeW1CwO/bmcc/ZvCH/XXHPNg2XH0Mp/Xl+vbzP/eX29vs385/X1+jbzn9fXa+q5jY7za+Vza/Xzq9W52YVEkiRJkiQ1PBMYkiRJkiSp4ZnAGLqbD72JDoPXt768vvXl9a0vr299eX3ry+tbX17f2mvla9rK5watfX6tfG7Q2udXk3Nr5kE8JUmSJEnSKGELDEmSJEmS1PBMYEiSJEmSpIbXXnYAzSLGeCnwKaAN+MeU0sdKDqllxBi7gS8DMyjmKr85pfSpcqNqPTHGNuBBoCeldEXZ8bSaGONk4B+BRRTv4+tTSovLjap1xBj/BPgQxbV9HPhASunlcqNqXjHGLwBXAGtTSouqy6YC/wrMA54HYkppQ1kxNrMDXN+PA1cCrwDPUryHN5YXZfMa6Pruse5Pgf8FTE8p9ZYRX7NrpTrvgeqYrfZ5t28dL8Z4LHArMA14CPj1lNIrZcY4HAPVrYCnaZF7N1DdBphFk967odQtYoyB4nPmV4BtwPtTSg8PphxbYAxC9UPh/wKXAScB18UYTyo3qpayC/jTlNJJwLnA73l96+KPgKfKDqKFfQq4I6X0OuA0vNY1E2PsAv4QOLP6H2IbcG25UTW9LwKX7rPsz4F7UkrHAfdUX2t4vsj+1/duYFFK6VTgGeDGkQ6qhXyR/a/v7i+rbweWj3RAraIF67wHqmO22ufdvnW8/wF8MqW0ENgAfLCUqA7fQHWrlrh3B6nbNPO9+yKDr1tcBhxX/bsB+OxgCzGBMThnA0tSSs8WpjwQAAAFXElEQVRVM2C3AleXHFPLSCmt2p1xSyltofhw6io3qtYSY5wNXE6RxVaNxRgnAW8GPg+QUnrFX1Zrrh04MsbYDowHXig5nqaWUvohsH6fxVcDX6o+/xLwzhENqoUMdH1TSnellHZVX94PzB7xwFrEAd6/AJ8EPkLxa6aGp6XqvAepY7bM592+dbzqL9tvBb5a3aQpz+8gdauWuXfsX7dZRRPfuyHWLa4GvpxSyiml+4HJMcZZgynHBMbgdAEr9ni9Er9g10WMcR7weuCBkkNpNf+bolLXX3YgLepY4EXg/8UYH4kx/mOM8aiyg2oVKaUeiibhyyn+c9+UUrqr3Kha0oyU0qrq89UUTa5VH9cD/152EK0kxng1RfP5x8qOpcm1bJ13nzpmK33e7VvHmwZs3CNh2qz38EB1q5a4dwPVbSi6jLTCvdvTge7XsD9rTGCoYcQYjwa+BvxxSmlz2fG0ihjj7r5oD5UdSwtrB84APptSej3wEk3apLERxRinUGTqjwU6gaNijO8rN6rWllLK+Ct2XcQYb6Jo1n5L2bG0ihjjeOAvgL8qOxY1poPVMZv5867F63iHrFs1+b3br27DAF3jWkmt7pcJjMHpAbr3eD27ukw1EmMcQ/Efyy0ppdvKjqfFnA9cFWN8nqIp6FtjjP9UbkgtZyWwMqW0u+XQVyn+01VtXAIsTSm9mFLaCdwGvLHkmFrRmt3NN6uPa0uOp+XEGN9PMcDZr1UrcqqNBRRfAh6r/l83G3g4xjiz1KiaU8vVeQ9Qx2yVz7v96ngU40ZMrnZLgOa9hweqW7XKvRuobnM+rXHv9nSg+zXszxpnIRmcnwLHVUf07aEYYOW95YbUOqp99T4PPJVS+kTZ8bSalNKNVAeLizFeCPxZSslfr2sopbQ6xrgixnhCSulp4GLgybLjaiHLgXOrv7Jup7i+D5YbUkv6FvCbwMeqj98sN5zWUp3Z4SPAW1JK28qOp5WklB4Hjtn9uvpl7kxnIRmWlqrzHqSO2RKfdweo4/1ajPErwLspkhpNeX4HqVs9SQvcOw5ct7mXJr93+zjQv7VvAb8fY7wVOIeie/CqgQ+xNxMYg5BS2hVj/H3gTooRYr+QUvp5yWG1kvOBXwcejzE+Wl32Fyml20uMSRqqPwBuiTEeATxHMRWWaiCl9ECM8avAwxRN7x8Bbi43quYWY/wX4EKgI8a4EvhrispFijF+EFgGxPIibG4HuL43AmOBu2OMAPenlH67tCCb2EDXN6X0+XKjag0tWOcdsI5J63/e/Wfg1hjj31L8n9ms/z4GqltVaIF7d5C6zXdo0ns3xLrF7RRTqC6hmEZ10PXmkLMtGCVJkiRJUmNzDAxJkiRJktTwTGBIkiRJkqSGZwJDkiRJkiQ1PBMYkiRJkiSp4ZnAkCRJkiRJDc8EhiRJkiRJangmMCRJkiRJUsMzgSFJkiRJkhpee9kBSJJqI8a4APgpcElK6eEYYyfwGHBNSun7pQYnSZIkHaaQcy47BklSjcQYfwv4E+BM4OvA4ymlPys3KkmSJOnw2YVEklpISukfgCXAA8As4KZyI5IkSZJqwwSGJLWefwAWAf8npbSj7GAkSZKkWrALiSS1kBjj0RTjXtwLXAacklJaX25UkiRJ0uGzBYYktZZPAQ+mlD4EfAf4XMnxSJIkSTVhAkOSWkSM8WrgUuB3qos+DJwRY/y18qKSJEmSasMuJJIkSZIkqeHZAkOSJEmSJDU8ExiSJEmSJKnhmcCQJEmSJEkNzwSGJEmSJElqeCYwJEmSJElSwzOBIUmSJEmSGp4JDEmSJEmS1PBMYEiSJEmSpIb3/wEx81yeLukXpgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] diff --git a/MPC_scipy.ipynb b/notebooks/MPC_scipy.ipynb similarity index 100% rename from MPC_scipy.ipynb rename to notebooks/MPC_scipy.ipynb diff --git a/img/mpc_block_diagram.png b/notebooks/img/mpc_block_diagram.png similarity index 100% rename from img/mpc_block_diagram.png rename to notebooks/img/mpc_block_diagram.png diff --git a/img/mpc_t.png b/notebooks/img/mpc_t.png similarity index 100% rename from img/mpc_t.png rename to notebooks/img/mpc_t.png