diff --git a/Druckrohrleitung/old/Druckrohrleitung_ETH_class_file.py b/Druckrohrleitung/old/Druckrohrleitung_ETH_class_file.py deleted file mode 100644 index 357186f..0000000 --- a/Druckrohrleitung/old/Druckrohrleitung_ETH_class_file.py +++ /dev/null @@ -1,171 +0,0 @@ -import numpy as np - -#importing pressure conversion function -import sys -import os -current = os.path.dirname(os.path.realpath(__file__)) -parent = os.path.dirname(current) -sys.path.append(parent) -from functions.pressure_conversion import pressure_conversion - - -class Druckrohrleitung_class: -# units - acceleration_unit = r'$\mathrm{m}/\mathrm{s}^2$' - angle_unit = '°' - area_unit = r'$\mathrm{m}^2$' - density_unit = r'$\mathrm{kg}/\mathrm{m}^3$' - flux_unit = r'$\mathrm{m}^3/\mathrm{s}$' - length_unit = 'm' - pressure_unit = 'Pa' - time_unit = 's' - velocity_unit = r'$\mathrm{m}/\mathrm{s}$' # for flux and pressure propagation - volume_unit = r'$\mathrm{m}^3$' - - acceleration_unit_print = 'm/s²' - angle_unit_print = '°' - area_unit_print = 'm²' - density_unit_print = 'kg/m³' - flux_unit_print = 'm³/s' - length_unit_print = 'm' - pressure_unit_print = 'Pa' - time_unit_print = 's' - velocity_unit_print = 'm/s' # for flux and pressure propagation - volume_unit_print = 'm³' - - -# init - def __init__(self,total_length,diameter,number_segments,pipeline_angle,Darcy_friction_factor,rho=1000,g=9.81): - self.length = total_length - self.dia = diameter - self.n_seg = number_segments - self.angle = pipeline_angle - self.f_D = Darcy_friction_factor # = Rohrreibungszahl oder flow coefficient - self.density = 1000 - self.g = g - - self.dx = total_length/number_segments - self.l_vec = np.arange(0,(number_segments+1)*self.dx,self.dx) - - # initialize for get_info method - self.c = '--' - self.dt = '--' - -# setter - def set_pressure_propagation_velocity(self,c): - self.c = c - self.dt = self.dx/c - - def set_number_of_timesteps(self,number_timesteps): - self.nt = number_timesteps - if self.c == '--': - raise Exception('Please set the pressure propagation velocity before setting the number of timesteps.') - else: - self.t_vec = np.arange(0,self.nt*self.dt,self.dt) - - def set_initial_pressure(self,pressure,input_unit = 'Pa'): - p,_ = pressure_conversion(pressure,input_unit,target_unit=self.pressure_unit) - if np.size(p) == 1: - self.p0 = np.full_like(self.l_vec,p) - elif np.size(p) == np.size(self.l_vec): - self.p0 = p - else: - raise Exception('Unable to assign initial pressure. Input has to be of size 1 or' + np.size(self.l_vec)) - - #initialize the vectors in which the old and new pressures are stored for the method of characteristics - self.p_old = self.p0.copy() - self.p = np.empty_like(self.p_old) - - def set_initial_flow_velocity(self,velocity): - if np.size(velocity) == 1: - self.v0 = np.full_like(self.l_vec,velocity) - elif np.size(velocity) == np.size(self.l_vec): - self.v0 = velocity - else: - raise Exception('Unable to assign initial velocity. Input has to be of size 1 or' + np.size(self.l_vec)) - - #initialize the vectors in which the old and new velocities are stored for the method of characteristics - self.v_old = self.v0.copy() - self.v = np.empty_like(self.v_old) - - def set_boundary_conditions_next_timestep(self,v_reservoir,p_reservoir,v_turbine,input_unit_pressure = 'Pa'): - rho = self.density - c = self.c - f_D = self.f_D - dt = self.dt - D = self.dia - p_old = self.p_old[-2] # @ second to last node (the one before the turbine) - v_old = self.v_old[-2] # @ second to last node (the one before the turbine) - self.v_boundary_res = v_reservoir - self.v_boundary_tur = v_turbine - self.p_boundary_res,_ = pressure_conversion(p_reservoir,input_unit_pressure,target_unit=self.pressure_unit) - self.p_boundary_tur = p_old+rho*c*v_old-rho*c*f_D*dt/(2*D)*abs(v_old)*v_old - self.v[0] = self.v_boundary_res.copy() - self.v[-1] = self.v_boundary_tur.copy() - self.p[0] = self.p_boundary_res.copy() - self.p[-1] = self.p_boundary_tur.copy() - -# getter - def get_info(self): - new_line = '\n' - - # :<10 pads the self.value to be 10 characters wide - print_str = (f"The pipeline has the following attributes: {new_line}" - f"----------------------------- {new_line}" - f"Length = {self.length:<10} {self.length_unit_print} {new_line}" - f"Diameter = {self.dia:<10} {self.length_unit_print} {new_line}" - f"Number of segemnts = {self.n_seg:<10} {new_line}" - f"Number of nodes = {self.n_seg+1:<10} {new_line}" - f"Length per segment = {self.dx:<10} {self.length_unit_print} {new_line}" - f"Pipeline angle = {self.angle:<10} {self.angle_unit_print} {new_line}" - f"Darcy friction factor = {self.f_D:<10} {new_line}" - f"Density of liquid = {self.density:<10} {self.density_unit_print} {new_line}" - f"Pressure wave vel. = {self.c:<10} {self.velocity_unit_print} {new_line}" - f"Simulation timesteps = {self.dt:<10} {self.time_unit_print } {new_line}" - f"Number of timesteps = {self.nt:<10} {new_line}" - f"----------------------------- {new_line}" - f"Velocity and pressure distribution are vectors and are accessible by the .v and .p attribute of the pipeline object") - - print(print_str) - - - def get_boundary_conditions_next_timestep(self,target_unit_pressure ='bar'): - print('The pressure at the reservoir for the next timestep is', '\n', \ - pressure_conversion(self.p_boundary_res,self.pressure_unit_print,target_unit_pressure), '\n', \ - 'The velocity at the reservoir for the next timestep is', '\n', \ - self.v_boundary_res, self.velocity_unit, '\n', \ - 'The pressure at the turbine for the next timestep is', '\n', \ - pressure_conversion(self.p_boundary_tur,self.pressure_unit_print,target_unit_pressure), '\n', \ - 'The velocity at the turbine for the next timestep is', '\n', \ - self.v_boundary_tur, self.velocity_unit) - - - def timestep_characteristic_method(self): - #number of nodes - nn = self.n_seg+1 - rho = self.density - c = self.c - f_D = self.f_D - dt = self.dt - D = self.dia - - for i in range(1,nn-1): - self.v[i] = 0.5*(self.v_old[i-1]+self.v_old[i+1])+0.5/(rho*c)*(self.p_old[i-1]-self.p_old[i+1]) \ - -f_D*dt/(4*D)*(abs(self.v_old[i-1])*self.v_old[i-1]+abs(self.v_old[i+1])*self.v_old[i+1]) - - self.p[i] = 0.5*rho*c*(self.v_old[i-1]-self.v_old[i+1])+0.5*(self.p_old[i-1]+self.p_old[i+1]) \ - -rho*c*f_D*dt/(4*D)*(abs(self.v_old[i-1])*self.v_old[i-1]-abs(self.v_old[i+1])*self.v_old[i+1]) - - self.p_old = self.p.copy() - self.v_old = self.v.copy() - - - - - - - - - - - diff --git a/Druckrohrleitung/old/Druckstoß_ETH.ipynb b/Druckrohrleitung/old/Druckstoß_ETH.ipynb deleted file mode 100644 index fafcd56..0000000 --- a/Druckrohrleitung/old/Druckstoß_ETH.ipynb +++ /dev/null @@ -1,187 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#imports\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from pressure_conversion import pressure_conversion" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#define constants\n", - "\n", - "g = 9.81 # gravitational acceleration [m/s²]\n", - "\n", - "L = 1000 # length of pipeline [m]\n", - "rho = 1000 # density of water [kg/m³]\n", - "D = 1 # pipe diameter [m]\n", - "Q0 = 2 # initial flow in whole pipe [m³/s]\n", - "h = 20 # water level in upstream reservoir [m]\n", - "n = 10 # number of pipe segments in discretization\n", - "nt = 500 # number of time steps after initial conditions\n", - "f_D = 0.01 # Darcy friction factor\n", - "c = 400 # propagation velocity of the pressure wave [m/s]" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# preparing the discretization and initial conditions\n", - "\n", - "dx = L/n # length of each pipe segment\n", - "dt = dx/c # timestep according to method of characterisitics\n", - "nn = n+1 # number of nodes\n", - "pl_vec = np.arange(0,nn*dx,dx) # pl = pipe-length. position of the nodes on the pipeline\n", - "t_vec = np.arange(0,nt*dt,dt) # time vector\n", - "\n", - "v0 = Q0/(D**2/4*np.pi)\n", - "p0 = (rho*g*h-v0**2*rho/2)\n", - "\n", - "# storage vectors for old parameters\n", - "v_old = np.full(nn,v0)\n", - "p_old = p0-(f_D*pl_vec/D*rho/2*v0**2) # ref Wikipedia: Darcy Weisbach\n", - "\n", - "# storage vectors for new parameters\n", - "v_new = np.zeros_like(v_old)\n", - "p_new = np.zeros_like(p_old)\n", - "\n", - "# storage vector for time evolution of parameters at node 1 (at reservoir)\n", - "p_1 = np.zeros_like(t_vec)\n", - "v_1 = np.zeros_like(t_vec)\n", - "\n", - "# storage vector for time evolution of parameters at node N+1 (at valve)\n", - "p_np1 = np.full_like(t_vec,p0)\n", - "v_np1 = np.full_like(t_vec,v0)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib qt\n", - "# plotting preparation\n", - "\n", - "fig1,axs1 = plt.subplots(2,1)\n", - "axs1[0].set_title('Pressure distribution in pipeline')\n", - "axs1[1].set_title('Velocity distribution in pipeline')\n", - "\n", - "lo_00, = axs1[0].plot(pl_vec,p_old,marker='.')\n", - "lo_01, = axs1[1].plot(pl_vec,v_old,marker='.')\n", - "axs1[0].set_ylim([-20*p0,20*p0])\n", - "axs1[1].set_ylim([-2*v0,2*v0])\n", - "fig1.tight_layout()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "for it in range(1,nt):\n", - "\n", - " # set boundary conditions\n", - " v_new[-1] = 0 # in front of the instantaneously closing valve, the velocity is 0\n", - " p_new[0] = p0 # hydrostatic pressure from the reservoir\n", - "\n", - " # calculate the new parameters at first and last node\n", - " v_new[0] = v_old[1]+1/(rho*c)*(p0-p_old[1])-f_D*dt/(2*D)*abs(v_old[1])*v_old[1]\n", - " p_new[-1] = p_old[-2]+rho*c*v_old[-2]-rho*c*f_D*dt/(2*D) *abs(v_old[-2])*v_old[-2]\n", - "\n", - " # calculate parameters at second to second-to-last nodes \n", - " #equation 2-30 plus 2-31 (and refactor for v_i^j+1) in block 2\n", - "\n", - " for i in range(1,nn-1):\n", - " v_new[i] = 0.5*(v_old[i-1]+v_old[i+1])+0.5/(rho*c)*(p_old[i-1]-p_old[i+1]) \\\n", - " -f_D*dt/(4*D)*(abs(v_old[i-1])*v_old[i-1]+abs(v_old[i+1])*v_old[i+1])\n", - "\n", - " p_new[i] = 0.5*rho*c*(v_old[i-1]-v_old[i+1])+0.5*(p_old[i-1]+p_old[i+1]) \\\n", - " -rho*c*f_D*dt/(4*D)*(abs(v_old[i-1])*v_old[i-1]-abs(v_old[i+1])*v_old[i+1])\n", - " \n", - "\n", - " # prepare for next loop\n", - " # use .copy() to avoid that memory address is overwritten and hell breaks loose :D\n", - " #https://www.geeksforgeeks.org/array-copying-in-python/\n", - " p_old = p_new.copy()\n", - " v_old = v_new.copy()\n", - "\n", - " lo_00.set_ydata(p_new)\n", - " lo_01.set_ydata(v_new)\n", - " \n", - " fig1.suptitle(str(it))\n", - " fig1.canvas.draw()\n", - " fig1.tight_layout()\n", - " plt.pause(0.001)\n", - "\n", - " # store parameters of node 1 (at reservoir)\n", - " p_1[it] = p_new[0]\n", - " v_1[it] = v_new[0]\n", - " # store parameters of node N+1 (at reservoir)\n", - " p_np1[it] = p_new[-1]\n", - " v_np1[it] = v_new[-1]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "fig2,axs2 = plt.subplots(2,2)\n", - "axs2[0,0].plot(t_vec,p_1)\n", - "axs2[0,1].plot(t_vec,v_1)\n", - "axs2[1,0].plot(t_vec,p_np1)\n", - "axs2[1,1].plot(t_vec,v_np1)\n", - "axs2[0,0].set_title('Pressure Reservoir')\n", - "axs2[0,1].set_title('Velocity Reservoir')\n", - "axs2[1,0].set_title('Pressure Turbine')\n", - "axs2[1,1].set_title('Velocity Turbine')\n", - "fig2.tight_layout()\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Kraftwerk/Kraftwerk_class_file.py b/Kraftwerk/Kraftwerk_class_file.py deleted file mode 100644 index efcabd4..0000000 --- a/Kraftwerk/Kraftwerk_class_file.py +++ /dev/null @@ -1,19 +0,0 @@ -#importing Druckrohrleitung -import sys -import os -current = os.path.dirname(os.path.realpath('Main_Programm.ipynb')) -parent = os.path.dirname(current) -sys.path.append(parent) -from functions.pressure_conversion import pressure_conversion -from Turbinen.Turbinen_class_file import Francis_Turbine - -class Kraftwerk_class: - def __init__(self): - self.turbines = [] - - def add_turbine(self,turbine): - self.turbines.append(turbine) - - def print_info(self): - for turbine in self.turbines: - turbine.get_info(full=True) diff --git a/Kraftwerk/Kraftwerk_class_test.ipynb b/Kraftwerk/Kraftwerk_class_test.ipynb deleted file mode 100644 index a820c4c..0000000 --- a/Kraftwerk/Kraftwerk_class_test.ipynb +++ /dev/null @@ -1,105 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "import os\n", - "from Kraftwerk_class_file import Kraftwerk_class\n", - "\n", - "current = os.path.dirname(os.path.realpath('Main_Programm.ipynb'))\n", - "parent = os.path.dirname(current)\n", - "sys.path.append(parent)\n", - "from functions.pressure_conversion import pressure_conversion\n", - "from Turbinen.Turbinen_class_file import Francis_Turbine" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[, ]\n", - "Turbine has the following attributes: \n", - "----------------------------- \n", - "Type = Francis \n", - "Nominal flux = 0.85 m³/s \n", - "Nominal pressure = 108.09 mWS\n", - "Nominal LA = 100.0 % \n", - "Closing time = 500 s \n", - "Current flux = -1.0 m³/s \n", - "Current pipe pressure = -1.0 mWS \n", - "Current LA = -1.0 % \n", - "Simulation timestep = -1.0 s \n", - "----------------------------- \n", - "\n", - "Turbine has the following attributes: \n", - "----------------------------- \n", - "Type = Francis \n", - "Nominal flux = 0.85 m³/s \n", - "Nominal pressure = 108.09 mWS\n", - "Nominal LA = 100.0 % \n", - "Closing time = 500 s \n", - "Current flux = -1.0 m³/s \n", - "Current pipe pressure = -1.0 mWS \n", - "Current LA = -1.0 % \n", - "Simulation timestep = -1.0 s \n", - "----------------------------- \n", - "\n" - ] - } - ], - "source": [ - "#Turbine\n", - "Q_nenn = 0.85 # m³/s\n", - "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", - "closing_time = 500 #s\n", - "\n", - "T1 = Francis_Turbine(Q_nenn,p_nenn,closing_time)\n", - "T2 = Francis_Turbine(Q_nenn,p_nenn,closing_time)\n", - "\n", - "KW = Kraftwerk_class()\n", - "KW.add_turbine(T1)\n", - "KW.add_turbine(T2)\n", - "\n", - "print(KW.turbines)\n", - "\n", - "KW.print_info()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Regler/old/regler_test_optimierung.ipynb b/Regler/old/regler_test_optimierung.ipynb deleted file mode 100644 index 7bf1ed9..0000000 --- a/Regler/old/regler_test_optimierung.ipynb +++ /dev/null @@ -1,386 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from Regler_class_file import P_controller_class\n", - "from Regler_class_file import PI_controller_class\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# # %matplotlib widget\n", - "# pi_controller = PI_controller_class(setpoint=100,proportionality_constant=1,Ti = 30,timestep = 0.1)\n", - "\n", - "# t_max = 100 #s\n", - "# dt = 0.1 #s\n", - "# nt = int(t_max//dt)\n", - "# t_vec = np.arange(0,nt+1,1)*dt\n", - "\n", - "# PV_0 = 50\n", - "\n", - "# PV_vec = np.full_like(t_vec,PV_0)\n", - "\n", - "# for i in range(1,nt+1):\n", - "# pi_controller.calculate_error(PV_vec[i-1])\n", - "\n", - "# if i == 500:\n", - "# pi_controller.SP = 0.\n", - "# PV_vec[i] = PV_vec[i-1]+pi_controller.get_control_variable()\n", - "\n", - "\n", - "\n", - "# plt.plot(t_vec,PV_vec,'.')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "SP_0 = 1.1\n", - "SP_1 = 0.24\n", - "PV_0 = 0.5" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n" - ] - } - ], - "source": [ - "n = 10\n", - "Kp_max = 5.\n", - "Ti_max = 5.\n", - "d_Kp = Kp_max/n\n", - "d_Ti = Ti_max/n\n", - "kp_vec = np.arange(1,n+1,1)*d_Kp\n", - "Ti_vec = np.arange(1,n+1,1)*d_Ti\n", - "\n", - "XX,YY = np.meshgrid(kp_vec,Ti_vec)\n", - "\n", - "ise_mat = np.empty_like(XX)\n", - "iae_mat = np.empty_like(XX)\n", - "itse_mat = np.empty_like(XX)\n", - "itae_mat = np.empty_like(XX)\n", - "\n", - "\n", - "t_max = 100 #s\n", - "dt = 0.05 #s\n", - "nt = int(t_max//dt)\n", - "t_vec = np.arange(0,nt+1,1)*dt\n", - "\n", - "for i in range(n):\n", - " if i%10 == 0:\n", - " print(i)\n", - " for j in range(n):\n", - " Kp = XX[i,j]\n", - " Ti = YY[i,j]\n", - "\n", - " c = PI_controller_class(SP_0,Kp,Ti,dt)\n", - "\n", - " PV_vec = np.full_like(t_vec,PV_0)\n", - "\n", - " for t in range(1,nt+1):\n", - " c.calculate_error(PV_vec[t-1])\n", - "\n", - " if t == 500:\n", - " c.SP = SP_1\n", - " PV_vec[t] = PV_vec[t-1]+c.get_control_variable()\n", - " \n", - " ise_mat[i,j],iae_mat[i,j],itse_mat[i,j],itae_mat[i,j] = np.log(c.get_performance_indicators())\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d9226014321c46daa6791bc1dfd0f06d", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "573c49fc68ec444583bcedf327db5c7c", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b5663fc661a64698ad0230c2174ef8a5", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "224a5fbc49b344c4ab9b241e6bc56d96", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%matplotlib widget\n", - "fig1,axs1 = plt.subplots(1,1)\n", - "ise_min = np.min(ise_mat)\n", - "ise_max = np.max(ise_mat)\n", - "mesh1 = axs1.pcolormesh(XX,YY,ise_mat,cmap='RdBu', vmin=ise_min, vmax=ise_max,shading='nearest')\n", - "fig1.colorbar(mesh1)\n", - "fig2,axs2 = plt.subplots(1,1)\n", - "iae_min = np.min(iae_mat)\n", - "iae_max = np.max(iae_mat)\n", - "mesh2 = axs2.pcolormesh(XX,YY,iae_mat,cmap='RdBu', vmin=iae_min, vmax=iae_max,shading='nearest')\n", - "fig2.colorbar(mesh2)\n", - "fig3,axs3 = plt.subplots(1,1)\n", - "itse_min = np.min(itse_mat)\n", - "itse_max = np.max(itse_mat)\n", - "mesh3 = axs3.pcolormesh(XX,YY,itse_mat,cmap='RdBu', vmin=itse_min, vmax=itse_max,shading='nearest')\n", - "fig3.colorbar(mesh3)\n", - "fig4,axs4 = plt.subplots(1,1)\n", - "itae_min = np.min(itae_mat)\n", - "itae_max = np.max(itae_mat)\n", - "mesh4 = axs4.pcolormesh(XX,YY,itae_mat,cmap='RdBu', vmin=itae_min, vmax=itae_max,shading='nearest')\n", - "fig4.colorbar(mesh4)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "ise_ind = np.unravel_index(np.argmin(ise_mat,axis=None),ise_mat.shape)\n", - "Kp_ise = XX[ise_ind]\n", - "Ti_ise = YY[ise_ind]\n", - "iae_ind = np.unravel_index(np.argmin(iae_mat,axis=None),iae_mat.shape)\n", - "Kp_iae = XX[iae_ind]\n", - "Ti_iae = YY[iae_ind]\n", - "itse_ind = np.unravel_index(np.argmin(itse_mat,axis=None),itse_mat.shape)\n", - "Kp_itse = XX[itse_ind]\n", - "Ti_itse = YY[itse_ind]\n", - "itae_ind = np.unravel_index(np.argmin(itae_mat,axis=None),itae_mat.shape)\n", - "Kp_itae = XX[itae_ind]\n", - "Ti_itae = YY[itae_ind]\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "05f5663bd9ab4b23a30ec4ee94e41a1e", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "t_max = 100 #s\n", - "dt = 0.1 #s\n", - "nt = int(t_max//dt)\n", - "t_vec = np.arange(0,nt+1,1)*dt\n", - "\n", - "\n", - "PV_vec_ise = np.full_like(t_vec,PV_0)\n", - "PV_vec_iae = np.full_like(t_vec,PV_0)\n", - "PV_vec_itse = np.full_like(t_vec,PV_0)\n", - "PV_vec_itae = np.full_like(t_vec,PV_0)\n", - "\n", - "c_ise = PI_controller_class(SP_0,Kp_ise,Ti_ise,timestep = 0.1)\n", - "c_iae = PI_controller_class(SP_0,Kp_iae,Ti_iae,timestep = 0.1)\n", - "c_itse = PI_controller_class(SP_0,Kp_itse,Ti_itse,timestep = 0.1)\n", - "c_itae = PI_controller_class(SP_0,Kp_itae,Ti_itae,timestep = 0.1)\n", - "\n", - "\n", - "for i in range(1,nt+1):\n", - " c_ise.calculate_error(PV_vec_ise[i-1])\n", - " c_iae.calculate_error(PV_vec_iae[i-1])\n", - " c_itse.calculate_error(PV_vec_itse[i-1])\n", - " c_itae.calculate_error(PV_vec_itae[i-1])\n", - "\n", - " if i == 500:\n", - " c_ise.SP = SP_1\n", - " c_iae.SP = SP_1\n", - " c_itse.SP = SP_1\n", - " c_itae.SP = SP_1\n", - "\n", - " PV_vec_ise[i] = PV_vec_ise[i-1]+c_ise.get_control_variable()\n", - " PV_vec_iae[i] = PV_vec_iae[i-1]+c_iae.get_control_variable()\n", - " PV_vec_itse[i] = PV_vec_itse[i-1]+c_itse.get_control_variable()\n", - " PV_vec_itae[i] = PV_vec_itae[i-1]+c_itae.get_control_variable()\n", - "\n", - "fig5 = plt.figure()\n", - "plt.plot(t_vec,PV_vec_ise,label='ise')\n", - "plt.plot(t_vec,PV_vec_iae,'.-',label='iae')\n", - "plt.plot(t_vec,PV_vec_itse,'+',label='itse')\n", - "plt.plot(t_vec,PV_vec_itae,'*',label='itae')" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Turbinen/messy.ipynb b/Turbinen/messy.ipynb deleted file mode 100644 index d9e0b09..0000000 --- a/Turbinen/messy.ipynb +++ /dev/null @@ -1,90 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from Turbinen_class_file import Francis_Turbine\n", - "from mpl_toolkits import mplot3d\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib widget\n", - "\n", - "#importing pressure conversion function\n", - "import sys\n", - "import os\n", - "current = os.path.dirname(os.path.realpath('messy.ipynb'))\n", - "parent = os.path.dirname(current)\n", - "sys.path.append(parent)\n", - "from functions.pressure_conversion import pressure_conversion" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current attributes are: \n", - "----------------------------- \n", - "Current flux = -1.0 m³/s \n", - "Current pipe pressure = -1.0 mWS \n", - "Current LA = -1.0 % \n", - "----------------------------- \n", - "\n", - "The current attributes are: \n", - "----------------------------- \n", - "Current flux = -1.0 m³/s \n", - "Current pipe pressure = -1.0 mWS \n", - "Current LA = -1.0 % \n", - "----------------------------- \n", - "\n" - ] - } - ], - "source": [ - "Q_nenn = 0.85\n", - "p_nenn = pressure_conversion(10.6,'bar','Pa')\n", - "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)\n", - "Untertweng2 = Francis_Turbine(Q_nenn,p_nenn)\n", - "\n", - "\n", - "turbines = [Untertweng1,Untertweng2]\n", - "for turbine in turbines:\n", - " turbine.get_info()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Turbinen/old/Durchflusskennlinie.csv b/Turbinen/old/Durchflusskennlinie.csv deleted file mode 100644 index 2eff1de..0000000 --- a/Turbinen/old/Durchflusskennlinie.csv +++ /dev/null @@ -1,22 +0,0 @@ -,11.4,11.2,11,10.8,10.6,10.4,10.2,10,9.8 -0,0,0,0,0,0,0,0,0,0 -0.05,44.6719225,43.934144,43.3914212,43.005945,42.7411852,42.5620659,42.4351104,42.3285595,42.2124611 -0.1,93.5257218,92.1813802,91.0120507,89.9819869,89.0566946,88.2030946,87.3896575,86.5865116,85.7655241 -0.15,142.455373,140.502298,138.703994,137.026824,135.438371,133.907593,132.404945,130.902474,129.373898 -0.2,191.35358,188.792245,186.365298,184.041241,181.789769,179.581903,177.390108,175.188376,172.952294 -0.25,240.112708,236.946245,233.893698,230.92573,228.014163,225.132101,222.254034,219.355912,216.415204 -0.3,288.625576,284.85976,281.187353,277.581187,274.01522,270.464644,266.905977,263.31713,259.677456 -0.35,336.786234,332.429439,328.145567,323.909615,319.697669,315.487006,311.256165,306.985012,302.654777 -0.4,384.490739,379.553866,374.669505,369.814802,364.967956,360.108307,355.216403,350.274048,345.264331 -0.45,431.637894,426.134271,420.662881,415.202987,409.734875,404.239922,398.700655,393.100789,387.425251 -0.5,478.129951,472.075209,466.032607,459.983487,453.910176,447.796055,441.625591,435.384378,429.059145 -0.55,523.873268,517.285198,510.689413,504.069281,497.409128,490.694283,483.911113,477.047044,470.090565 -0.6,568.778912,561.677293,554.548395,547.377555,540.151033,532.856054,525.480827,518.014558,510.447451 -0.65,612.763186,605.169605,597.529525,589.830179,582.059697,574.207132,566.262474,558.216649,550.061519 -0.7,655.7481,647.685753,639.558081,631.354134,623.063835,614.677994,606.188309,597.587364,588.868614 -0.75,697.661758,689.155243,680.565018,671.881864,663.097416,654.204159,645.195426,636.065384,626.809013 -0.8,738.438667,729.51377,720.487263,711.35157,702.099947,692.726469,683.226022,673.594278,663.827671 -0.85,778.019972,768.703447,759.267942,749.707427,740.016685,730.191293,720.227602,710.122707,699.874419 -0.9,816.35361,806.672962,796.856534,786.899741,776.798797,766.550685,756.153132,745.604572,734.904109 -0.95,853.394385,843.377654,833.208949,822.885029,812.403437,801.762466,790.961126,779.999101,768.876705 -1,889.103974,878.779525,868.287549,857.626044,846.793778,835.790258,824.615682,813.270891,801.757325 diff --git a/Turbinen/old/Turbinen_class_file.py b/Turbinen/old/Turbinen_class_file.py deleted file mode 100644 index 457d819..0000000 --- a/Turbinen/old/Turbinen_class_file.py +++ /dev/null @@ -1,33 +0,0 @@ -from matplotlib.pyplot import fill -import numpy as np -from scipy.interpolate import interp2d - -#importing pressure conversion function -import sys -import os -current = os.path.dirname(os.path.realpath(__file__)) -parent = os.path.dirname(current) -sys.path.append(parent) -from functions.pressure_conversion import pressure_conversion - -class Francis_turbine_class: - def __init__(self,CSV_name='Durchflusskennlinie.csv'): - csv = np.genfromtxt(CSV_name,delimiter=',') - n_rows,_ = np.shape(csv) - self.raw_csv = np.append(csv,np.zeros([n_rows,1]),axis = 1) - - def extract_csv(self,CSV_pressure_unit='bar'): - ps_vec,_ = pressure_conversion(self.raw_csv[0,1:],CSV_pressure_unit,'Pa') - self.raw_ps_vec = np.flip(ps_vec) - self.raw_LA_vec = self.raw_csv[1:,0] - self.raw_Qs_mat = np.fliplr(self.raw_csv[1:,1:])/1000. # convert from l/s to m³/s - - def get_Q_fun(self): - Q_fun = interp2d(self.raw_ps_vec,self.raw_LA_vec,self.raw_Qs_mat,bounds_error=False,fill_value=None) - return Q_fun - - - - - - diff --git a/Turbinen/old/Turbinen_test.ipynb b/Turbinen/old/Turbinen_test.ipynb deleted file mode 100644 index 52e26e6..0000000 --- a/Turbinen/old/Turbinen_test.ipynb +++ /dev/null @@ -1,319 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from numpy.polynomial import Polynomial\n", - "from numpy.polynomial.polynomial import polyval\n", - "from Turbinen_class_file import Francis_turbine_class\n", - "from mpl_toolkits import mplot3d\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#importing pressure conversion function\n", - "import sys\n", - "import os\n", - "current = os.path.dirname(os.path.realpath('messy.ipynb'))\n", - "parent = os.path.dirname(current)\n", - "sys.path.append(parent)\n", - "from functions.pressure_conversion import pressure_conversion\n", - "\n", - "%matplotlib widget\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "# create turbine object\n", - "T1 = Francis_turbine_class()\n", - "csv = T1.raw_csv\n", - "\n", - "T1.extract_csv()\n", - "ps_raw = T1.raw_ps_vec\n", - "n_ps_raw = np.size(T1.raw_ps_vec)\n", - "LAs_raw = T1.raw_LA_vec\n", - "n_LAs_raw = np.size(T1.raw_LA_vec)\n", - "Qs_raw = T1.raw_Qs_mat\n", - "\n", - "Q_fun = T1.get_Q_fun()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# interpolate Qs for more LAs\n", - "\n", - "n_LA_int = 2001\n", - "\n", - "LA_int = np.linspace(0,1,n_LA_int,endpoint=True)\n", - "\n", - "Q_int = np.reshape(Q_fun(ps_raw,LA_int),[n_LA_int,n_ps_raw])" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "# fit a polynomial to the data from Qs_Raw\n", - " # receive a coefficient matrix \n", - "poly_deg = 3\n", - "fit_coeff_mat = np.empty([n_LA_int,poly_deg+1])\n", - "fit_weights = np.ones_like(ps_raw)\n", - "fit_weights[0] = 20 # put extra weight on the p=0 => Q=0 data\n", - "\n", - "for i in range(n_LA_int):\n", - " x = ps_raw\n", - " y = Q_int[i,:]\n", - " fit_coeff_mat[i,:] = np.polynomial.polynomial.Polynomial.fit(x,y,poly_deg,w=fit_weights).convert().coef\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "p_ext_min = 0\n", - "p_ext_max = 2.5*np.max(ps_raw)\n", - "n_p_ext = 200\n", - "\n", - "p_ext = np.linspace(p_ext_min,p_ext_max,n_p_ext)\n", - "\n", - "Qs_ext = np.zeros([n_LA_int,n_p_ext])\n", - "\n", - "for i in range(n_LA_int):\n", - " Qs_ext[i,:] = polyval(p_ext,fit_coeff_mat[i,:])\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'LA = 0.05')" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a89d999414644e6a8d81f1e32c31e49b", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "LA_test = 0.05\n", - "LA_index = int(np.argwhere(LA_int == LA_test))\n", - "\n", - "fig = plt.figure()\n", - "plt.plot(p_ext,Qs_ext[LA_index,:])\n", - "plt.xlabel('Druck [Pa]')\n", - "plt.ylabel('Q [m³/s]')\n", - "plt.title('LA = '+ str(LA_test))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "def Q_formel(p,LA):\n", - " x= LA\n", - " y = p*1e-5\n", - " a = -215.9324\n", - " b = +332.86766\n", - " c = -2.40164\n", - " d = +67.45335\n", - " e = -6.92688\n", - " f = +0.23341\n", - " g = -0.0225\n", - " h = +0.0499\n", - " i = -0.09458\n", - " j = +0.00324\n", - " k = +1.\n", - " return (a+b*x+c*x**2+d*y+e*y**2+f*y**3)/(1+g*x+h*x**2+i*y+j*y**2)*k/1000" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'P = 1145728.6432160805 [Pa]')" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "32ee8a91fb3c43dcb085155ea58f3b41", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "p_test,_ = pressure_conversion(11.4,'bar','Pa')\n", - "p_index = int(np.argmin(abs(p_ext-p_test)))\n", - "p_test2 = p_ext[p_index]\n", - "\n", - "fig = plt.figure()\n", - "plt.plot(LA_int,Qs_ext[:,p_index])\n", - "plt.plot(LA_int,Q_formel(p_test2,LA_int),'+')\n", - "plt.xlabel('LA [-]')\n", - "plt.ylabel('Q [m³/s]')\n", - "plt.title('P = '+ str(p_test2) + ' [Pa]')" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Q [m³/s]')" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5b7343c1b0f244e8a40bcb8c91920c68", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eXDc2X3f/b7Pb+t9w76DBLhzZjjkcEZDjhzLi2wrLilO7JvcpBzrOrIrqjh22XIqT1SJXU6ur/I8tuwoXqQ4iWM/emzrOnbsKLpWYj9ZZG0zkmaGABeAG4iN2IFuNHr/bef+0egmgAFJLM1tcF5VKg1J4NcLGugPzjnf71dIKSWKoiiKoijKgaE96TugKIqiKIqiPF4qACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMCoAKoqiKIqiHDAqACqKoiiKohwwKgAqiqIoiqIcMMaTvgOKoihSSjzPA0DXdYQQT/geKYqivLupAKgoyhPl+z6O41AqlZBSomkapmmi6zqGYaBpmgqEiqIoDSaklPJJ3wlFUQ6e2qqf67r1EFj7ceT7PgBCiHogNAwDXddVIFQURWkAFQAVRXnspJQ4jlPf9hVCYNt2/b9rH1P7nwqEiqIojaUCoKIoj5Xv+9i2je/79fAmpXxHANxqayCcmZkhHA7T2tqKYRgqECqKouyCOgOoKMpjUdvyrW31bg1qtSB4P0KI+sfruk4ul0MIge/7VCoVyuUymqahaZoKhIqiKA+hAqCiKI+c7/uk02l83ycWizUklNUCoa7rwL0VQs/z8DyPSqVS3zJWgVBRFGUzFQAVRXlkatu1juMwPT2NpmkkEomGXr+mFgg1Tav/28ZCk42BsRYGDcPYtLKoKIpyUKgAqCjKIyGlxHVdXNcFHr7Fu1sPC233C4Su6+I4zjsCYS0UqkCoKMpBoAKgoigNV1v18zyvHsJq5/UaaTeBcjeBsNaHsLZlrCiK8m6jAqCiKA2ztbffxvN2j3sFcCef/6BACLzj/KAKhIqivFuoAKgoSkNs7e232yrfvd5mo9wvEDqOU29RowKhoijvFioAKoqyb9v19tvqaVsB3Mn1twZC3/e5ffs25XKZ48ePI4RQgVBRlGeSCoCKouzZw3r7bfSgADg/P8/IyAiBQICmpiaSySTJZBLDePCPqMfZx752PrD2GHVdr591rG0Zbw2EtSpjRVGUp40KgIqi7MnDtny32i4Aep7H9evXmZub49ixY0gpyWaz3Lp1i3K5TCwWI5VKkUqlSCQS9Z5/97ve47SxByFsbnlj23Z99XC7KmNFUZQnTQVARVF2rbbq96At3622BrZ8Ps/Q0BCGYXDx4kUMw8D3fTo7OwEolUqsrq6SyWQYHR3Ftm0SiUQ9ED5tdhoIt24Zq0CoKMqToAKgoig7trW3326matQCoJSSmZkZRkdH6evr4+jRowgh6tuoNaFQiFAoRGdnJ1JKSqUSmUyGTCbD3bt3cV2XQCCAYRikUimi0ehTdf5u65QSuHdW8n5TSlQgVBTlcVEBUFGUHamtZtV6+e22YXKtD+Dly5dZWVnh7NmztLS0AA8/yyeEIBwOEw6H6e7uRkrJyMgItm2TzWaZnJxESllfHUwmk0Sj0acmTG2cYQwqECqK8uSpAKgoygNt3MrczZbvVpVKhXQ6TTKZ5OLFiwSDwT3fJyEEpmliWRZHjx5FSkk+nyeTyZBOp7lz5w6appFMJuuhMBwOPzVh6kGBsFKpPLDtzNPyGBRFebapAKgoyn3tttDjfteYmppiYmKCUCjE+fPnGxJitvYYjMVixGIx+vr68H2fXC5HJpNhaWmJ27dv17eKa/8LhUL7vg+NsjEQ6rpe3yqXUm4KhMVikWg0SjAYxDCMPYdxRVEUFQAVRdnWxnFuew0ajuNw9epVstks/f395HK5hgaW+20da5pGIpEgkUhw6NAhPM9jbW2NTCbD3NwcN27cIBAIbAqEgUCgYfdrvzZur28MhCMjIwwMDJBKpepbxqZp1lcIVSBUFGWnVABUFGWT2qrfXgo9NspkMgwPDxOLxbh48SKLi4vkcrmG3c/dtIHRdX1T9bDnefUK4+npaUZGRgiHw5vOEFqW1bD7ul8bA2FtS7gWCsvlcv1jVCBUFGWnVABUFKWuFv6uX7+O4zicPn16T1u+4+PjjI2NcfToUfr7++sBplZAstVuC0o23tZe6LpOc3Mzzc3NALiuWw+EExMT5PN5IpHIpkBomuaebquRpJT152q7FcKtgXBrD0IVCBVFqVEBUFEUYHNvv1pI2G1YqFQqXL58mWKxyCuvvEIikaj/W6ODRyOvZxgGLS0t9apk27brgXBsbIxisVhvSl2pVJ5YA+r73e79AmGtqKRcLqNp2juKSlQgVJSDSwVARTngNvb2q41z0zTtvqt197OyssLly5dJpVJcvHjxHStmD1oB3KtHFcQsy6KtrY22tjagGmxrPQhXVlZwXZe33nqrvkIYj8c3NYF+lHbadHvjx9UCoed5eJ5337YzKhAqysGhAqCiHGC+7+O67juqfDVN23G48n2fsbExJiYmOHHiBD09PduGiKd5BfBhAoEAHR0ddHR0EAwGyeVytLS0kMlkmJ2dxXVd4vE4qVSKpqYmYrHYI2lKvdfAWwuEtft0v0BY2zLeOMdYBUJFeXdSAVBRDqCNvf02niur2WmBRblcZnh4GMdxePXVV4nFYvf92Ecxu/dJbcUahkFXVxddXV3bTinxfX/T2LpYLNawINWoFjrbBULXdXEcp/7v280xVoFQUd4dVABUlANma2+/7d7Ud7Jdu7i4yJUrV2hvb+fEiRMYxoN/nDwsAO42WDwtQWS7KSWFQqEeCCcnJwE2NaWORCJ7Lnp5FI97J4FwbW2NUChU3+6ubRkrivJsUgFQUQ6Qnfb2e9AWsO/73Lhxg7t373L69Gm6urp2dNsPC4B7Wc17UiuADyKEIBqNEo1G6e3tRUpZb0q9srJSn1KytSn10xJoYftAODU1RXNz86atYV3XMU1TBUJFeQapAKgoB0DtvJfrujsa53a/FcBiscjQ0BAAFy9eJBKJ7Pg+NHoL+FFsKT8KQgji8TjxeJz+/n583683pV5YWODWrVs7nlLyqFYAH6b2XNcC39YVQth+bJ0KhIry9FIBUFHe5fYyzm27cDU3N8e1a9fo7u7m+PHju35zf1YC26NWm1GcTCY5fPjwrqaUPMnnr1YhDvffMnYcB9u26/+uAqGiPL1UAFSUdzHf97Fte0erfhtt3AL2PI/R0VEWFhZ4/vnnaW9v39N9OagrgA+zdUqJ67pks9ltp5TUqrafhAetPm4XCGvHDWorhFsDYW0rWVGUJ0MFQEV5F6pt+daqfHfb3622BZzP5xkaGsIwDC5evHjfrcmdXrPRAfDdyDCMTVNKHMepN6X2fZ9Lly4RjUY3TSl5WAFOI+xm+7l2PnDj59YC4XYrhBurjBVFeTxUAFSUd5n79fbbDSEElUqF119/nf7+fo4cObLv7bt3UxuYx8k0TVpbW2ltbWVubo4zZ85QqVRYXV3l9u3bm6aU1ALho2hKvXFCzG7tJBBqmvaOohIVCBXl0VEBUFHeJR7W22+nXNdlcnKSSqXCSy+9VB+Ptl/v1jYwj5OUEsuySCaT9a34jVNKrl+/jm3b9abUjZxS0sgClI2BsPaa2C4Qbj1DeBC/5oryqKgAqCjvAhvHucH2vf12IpvNMjw8jK7rBIPBhoW/2n16UACsVCq4rrurbeaDsAL4MBunlEgpKZfL9UBYm1KytSn1XlZzH2UPQmDbQGjbdn32ciaToaOjQ60QKkqDqACoKM+4jb39Nh7E3w0pJZOTk9y6dYuBgQESiQQjIyMNvZ8PCoCzs7Ncu3YNz/PqBQ9NTU0kk8l3zBTeeL2D5mEhTAhBKBQiFArVp5QUi8V6IJyensb3/U1NqaPR6I6ey41VwI/SdoGwXC5z7do1mpqaHth25iC+JhRlr1QAVJRnlJQS27ZZXl4mlUrt6awfgG3bXL16lbW1Nc6fP08qlSKdTj90EshubRcAt1YYRyKRekuUsbGxTefbmpqaSCQS7zhL9iQ8qaCx28crhCASiRCJROjp6UFKST6fJ5PJsLq6yvj4OEKIHU0pedI9CIUQm3oQSimpVCrYtg2oQKgou6UCoKI8g2o91wqFAm+++Sbf8z3fs6c3u0wmw/DwMPF4nIsXL2JZFvDgSSB7tTUAFgoFhoaG0HW9ftuO49QLHuDe+bZ0Os3o6CiO4xCPx2lqasJ13QO5BbyfUCOEIBaLEYvF6Ovrq1d616aUjI2NbWpLs3FKyZMKgLB9D0KorhJuDYSVSqW+Em6aZj0Q7vUXJEV5t1IBUFGeMRt7++31cL+Ukjt37nDnzh2OHj1Kf3//pjfHncwC3q2NAbDWVLqnp4djx46haVq9anmjrefbSqUS6XS6HliklFy+fHnfM3afBbXnrpGPT9O0B04puXnzJpZlkUqlcF23vtr2uNX6WG7nQYGwXC7XP0YFQkXZTAVARXlGbNfbr/am+KA3yK0qlQqXL1+mVCrxyiuvkEgk3vExj3IFcGRkhNnZ2W2bSj+sSjgcDhMOh+np6WFmZoa5uTkSiUR99WqnI9WU7W03paTWlNrzPK5cuUIoFNq0ZVybUvIo7aYFzU4DYa0ZtQqEykGlAqCiPAPuN85tYwDcieXlZS5fvkxzczNnz569bwPhR9Gzr/bmu7q6ysWLFwmHw5v+fS/n23Rdp7+/v756VQsrtZFqwWBwU0FJbYv7WfQoVgAfRtd1mpqaaGpq4u7du7z44os4jrNpSkkkEtkUCO9XtLMfu/kFZ6v7BULf9+uvydovUyoQKgeJCoCK8pSrrfptN85t4+itB/F9n9u3bzM5OcnJkyfp7u5+aDVpI7eAFxYWuHLlCgCvvPJKQyZXbL3/mqa9Y6RabYLG+Pg4hUKhPkGjVlDyOCZoNMqTPu8opcQ0TRKJRL090MYpJePj41y9evWRTClpZAXy/QKh53l4nke5XFaBUDkQnp2ffopywGzt7bfdG1Dtzw8Ka6VSieHhYVzX5dVXXyUWiz30tmtbwPs9+O/7Pjdu3GBmZoYTJ05w9erVhr6JPigUGYZBS0tLPazYtl0vKLlx4waVSqVeUFJrmPw42pzs15MsxNh62xunlMC95ziTyXDr1i3K5fKmKSVbq7h3aj8rgA+z3RzjjYGwVlRSLBZJJBL1c4R77bWpKE8LFQAV5SlU6+1XC3b3e7OpvXHdLwAuLi5y5coV2tvbOXny5I7ffGu3tZ8AWCqVGBoawvd9Lly4gGVZXL16tWErWbvdprYsi/b29vq5w40FJXfv3t1zf7zH5UmuAO70l4Gtz/HGptSjo6PYtk0ikag/z4lEYkfBbj9j6HZru0Do+z7f+ta3eOWVVwgGg9ueIVSBUHnWqACoKE+RjePcttvy3c5227UbV95Onz5NZ2fnru7HTreW76cWPDs6Ojhx4gS6rtdXMp/0VmZNKBSiu7ub7u5upJQUCoV6IBwfH9+0pbyxHcqT9iTuw17PHwaDQTo7O+ns7KxXce9lSsmjXAF8mI2P2bKs+rax67o4jlMPflvnGD8Lq8nKwaYCoKI8Je5X6PEwW1cAC4UCw8PDAFy4cIFIJLLr+7JxBXA3fN/n1q1bTE1Ncfr0abq6uvZ9zQfdx0ZeKxqNEo1G6/3xtrZDCQQC9XYoz1IIe1pue2MVdy10b5xSMjU1hZRy21XYxzWF5H5q318bV/q2bhmrQKg8a1QAVJSnwMZxbrs9bL4xAM7OzjIyMkJ3dzfHjx/fV+Vk7X7tVLlcZmhoCNd1uXDhAtFodNtrNjK0PSrbtUOpFTusrKxg2zbf+MY3NlUYP0sFJbv1KMLng6aU1FZhhRCkUqn6KveTaka98ZeyrR4WCGuft3VKiQqEypP27v2JpSjPgNphc9d1d7zlu5Wmabiuy9WrV1lYWOCFF16gra1tX/drt1vAS0tLXL58mba2Nk6dOrXtWcOHBcC9vLE/ru1kXddpbm6mubkZXdcpFou0tra+o9ihVlCy07Ntu/E0rAA+ytCy3ZSSXC5Xb+tTKpX42te+Vq8ufpzb8rUziDu5rfsFQsdxsG27/u8qECpPmgqAivKE7HXLdzvXrl0jFApx8eLFhjQ/3ukK4Mb2MqdOnaK7u/uh134WVgAfRtM02tra6kG7XC7Xzw9uPNtWC4SxWGzf9/dJF4HA433ONU0jkUjUw3Q2m6Wnp4dMJsP8/PymKSW1/wWDwUdyXzzP2/PUnfsVlTiOU18h3BoIa1XGivIoqQCoKE/Ag3r77ZSUkrt371Iqlejo6OCFF15oeK+0B4WOcrnM8PAwtm3vqL3MTq65W09LQUkwGKSrq4uurq762bZaIJyYmKhvZdb+Fw6H9/wG/6yeAdyP2tjDjX0eN04pmZmZ4fr16/XG37X/NarxdyOLUGrnA2s2BsLtVgg3VhkrSiOpAKgoj9HG3n61g+17+cFe2/JNp9OEw2E6OjoavoX0oLC2srLC8PAwLS0tvPTSS7s6/9aoLeCn9Q1x49m23t7eTVuZS0tL3L59G9M06yGlqalpR+PUnmTY3diO6End/tbb3jilBDY3/p6cnOTatWtEIpFNTan3OqXkUfchfFgg1DTtHUUlT+vrX3l2qACoKI+J7/u4rrvvLd9sNsvw8DChUIjXXnuNS5cuNXRqR8127WWklIyNjTE+Ps6JEyfo6enZdcHKw+b97saTCEW7vc2NW5mHDh3atHJ19+5dRkdHCYfDmwpKtgsqT/oM4JMMHDsJYNs1/q4FwrGxMYrFYr0pda3AZ6e/uOxnC3i3dhoIv/SlL6FpGh/84Acfy/1S3n1UAFSUR6z2A9y2beD+TZ13cp3JyUlu3brF4OAghw8ffmgj6P3YGtYqlQqXL1+mVCrxnve8h3g8vqfrvhvOAO7HxpWrwcHBTePUNgaVjQUltUDwNE0Bedy3v9sVOMuyNp3TrFQq9QrjmzdvUqlUdjyl5En3Iazdr9r3ju/7fOELXyAej6sAqOyZCoCK8gjVCj0mJiZYWlripZde2tMbqW3bXLlyhVwux/nz5+vnoOCdfQAbZeMWcDqdZnh4mFQqxdmzZ/fc8uRhK4C79bScAdyPrePUKpVK/fzg6OgojuMQj8eJxWL1XyYedxh5nH34pJR4chnPX0TKJXy5jBG6iaFJ8sUikjxSFjBEM9IfA2yQOpoAKfMA6PphNDkLmICFph3DkMu0JcK0JaNog524jqRQsljL6dyd0LlZDhII9ZJMtr9jNOCTDIAbbZxhXCwWd93gXVE2UgFQUR6Rjb39dF3f8zirTCbD8PAw8XicixcvvuNge6ND1cbrep7H2NgYd+7c4fjx4/T29j411azP6grgwwQCgXdMz0in0ywvLwPwla98ZVOhQyQSeeTPRaNXAKWUOP4MtjeJ499a//9pDDzK3luAQ1A/Bf5VAEIxEO4hKs44ALoYwONrQPUXH0N/Gd/71vrVdYSvI+Xk+p/bwL8NlJCA0I4j3D/BQmIFIRU+w+HWK/X7lis+j+ZkyM0m8ekE4xg4MSLBOMgKiIef13wcCoXCnpq8K0qNCoCK0mDb9farBcDdXufOnTvcuXOHY8eO0dfXt+2b8KNaAQS4ceMGtm3zyiuvkEgk9n09tQK4OxunZ6RSKb75zW9y9uzZekPqsbExDMPYVFDyKFqh7CcASulS8m5TdEcoeXew3cuUvZv4lEgYp6h4lwEI6c9R9i+vf5aBJlepvaq98nGswA0gjiSEobXhYyCkDkTwZQW0FwCBLlJIVkE8D9JH05rx5TxCukjpYKIjZQAhykgSaP70vftKM/HwJIIcsdAMrj+NlG9gRvP0pcDL/Qs8/xCa0YRmHkVqg0jtKL42AGL/7Zd2o1AovKPZuqLshgqAitJA9+vtt9uQtvG83cPC16MIgJlMhkqlQjAY5OLFi3uuntzO0zgK7lmhaRrxeJx4PE5/fz++79cLSubm5rhx40a9FUqtoKQRrVB2EwBdv0jOHWbNucSacxlNrlDx7wAQN85Q8qpjCsP6CSreZaQUaKIZjQCmdhaEiSEieHIFnwhIF19fxpYCQY6gcYyS90b99gL6cRz/BgCCduAGUAZA117E8/5yw/P3Cra/vlIoDQztCL6cB9EMhBBaAinLgI+gAiKBLofrn+94R4hYo+sP9BvkSidIhG4i0ZCiF0+/gBRtePoJfO0kiL2dk90JFQCV/VIBUFEapFbosV1vv9p26k4sLy9z+fJlmpubd3Tebrtq3b2SUjIxMVFvVTIwMNDQ8He/0CalZGpqiuXl5Xp42U+vvHej7UKYpmmbeuNtbIUyPj5eDwm1gpJkMrmnatYHHV+Q0iPrjLJif5MV+1sENY28+yYASeN5yuvhzxLduP4SQf1FJBZCePhiAEcuENMHKHjfBEAXKVzKSAoAhPXzuMYYAELE8f3b9du29Jfw/bfqfza1dqS/uP6nGHBvdU+Iw+Bf2vDcnUL4b64/CBD6S2jeV+49Lu0lNPk6AI4fpVAZJB4RuJxD4uF5HmFrpnptfBxnEen8BQEjDQ5IBJ7+7UAYT38eT/8OpNa6m6f9gYrFotoCVvZFBUBF2afalq/jOPft7beTLWDf97l16xZTU1OcPHmS7u7uHQWgRq0AOo7DlStXWFtb4+WXX+batWv7vuZW2wXAWk/DTCZDZ2cny8vLjI2N1Xvl1Spmt65kHcQVwIfZrhVKJpMhnU5z48YNKpUK8Xi8Hgg3Fjo8yNbw6folFu1vMl/5OiV3lqJ3GZCEtTY8fx4Akw6EsAjo53FkDl3oFL0R8GeJGy9ScKvBzRBNON7V+rWDej+293b1GqIXd/2/q/92FNerhjYh4kh/GimjCGGgi8Hqn6mGLF07ipTr28bSQxcm4K5fKY4uZ+89QNGGWF9FBJB0om34sy9NooExNL+w/jcRDC0GcgVbJqurfqIZz8vhlEMEjGVy5R6aol+qfrg3ihv+qw99nndKSqlWAJV9UwFQUfZhp739HhbSSqUSw8PDuK7LhQsXdvWDvREBMJvNMjQ0RDQarReaPIqt5a2hLZfLMTQ0RDAY5MKFC8C91dLa1ub09DQjIyNEIpF6GEwmkwdudXAv5/Asy6K9vZ329naAekFJrQeh7/v1ubqpVIpoNLrtbUgpQXeZKP0vpotfwZVT5L0JAJqNbkAS1DqJGf04soWSN0vA6CbjVENeXD9BaT3k6SKG7d+sXzuid1PxLoEMYmlH8KSNrr1UDXVY+LKFQjGLZSRALCBpQcoyQf045VoYlCFMppByCQBDO470XweqrzVdfxnX+xagA0FM/QSOnEVoh0EG0LQUEhvQEFICIQRLSFkAuYrvJwiYk/X7LLVBtPXzioJV0I4Q5BvVywMeR4mH8xTso5QrFpfGPoTQr25qSr3frfl8Pv/Q6TuK8iAqACrKHmxszlp7Y37Qm/ODVgAXFha4evUq7e3tnDx5ctdbdLvZXt5qY2/BI0eOcOjQofrjeBQrbBuvOTs7y7Vr1zh06BBHjhxBSlnvlbi1V16tqe/GlaxIJILruqytrTVk1u7TrhFfi1AoRHd3N93d3fVVpFogHB8f37Sl3NTURCBoMVMZYtJ5ndnuv2Bq1aXdOk7em0AnTJN5EkkJTbShizjLTnXLNChaKLjVylqBDqTXH4RJxHwOX+YwsNAIUPZncWnBI4suypS86pZxWH+e4vq2sGaBRh+erG65mtqRTSuDAf00Xr0K2ECnjFwPf4JOpFer8vXQ9QHwv7n+nIKmnQfv69SfXf1lhPcVat9RQn8ZTY5QdNsxrSYQrWiygK89DzIHMobhD9Xvi08LOmk0LYNuraDFP8P55ufrv9BMTEyQz+f3PaWkWCyqFUBlX1QAVJRd2jjODXbW2Hm7kOb7PtevX2d2dpbTp0/vuaeXpmn1ofK74TgOV69eZXV19R29BaGxZws3XtPzPEZGRpibm+PMmTP1Rr0PCjgbm/rWWqPMzs4yPT3N0NAQQD20pFIpQqHQuzIQNvIxCSGIRqNEo1H6+vrwfZ+1tbXqKLWl67yx8k0KiRE8vUhShJCaS0CkMAgS1I6T9+YoeHeo+CsIBGHt3opWxGim5GYI6McJilZc1vBEEE0IVp1vIdfjVULvrReIRI0XqayHOkEQ6d/bovXLRyFc25IV6MLHk+stYMRhvI1h0HgJuR4cATQtifTnavcMTS5yTyfCH9nwpBxGeEMb/jyI8IfQNBddKyKlieaPVQtEAEkLGqt4MgpaC1ImQISQrCFlANf6cXz9HKbOjqeU1JpSP+jsby28qzOAyn6oAKgou7Cxt1+tuncnatuptdXCQqHA8HC1uvDixYuEw+E936e9bNXWxsmFw2Fee+21bbejHkV/QSklN2/exDAMLly4sKfHXWuN0tbWxtzcHO9973vJ5XKk02kWFha4efMmgUCgHgabmpoaWsjypDzq845CQCZwmyvRv8AJr5F1q4Gr2T+MUynjCRNJiLnQEACd1knW3Op/N1unsL0ZovoLGEQpelOUpMTxViiLWTxZPTuXMgYprf8ilDBeoOJVt4g1EcX1x9cfaJCI8WK1AbTWBdLC9nNI/yyGoWOIGJ5cAHEMX7pIYri0Ai66aKLs3QJZXRkz9dP4/iiIFKBjaEdx/BkQh0BaGFoKjzIIHaSJJkw82YzAA99B0yyk34Tvp9fPGfobwp+O0FKIWlGKv4rUzqL5XwXAMX8Yz/yBbZ/rB00p2XhWsxYI4/H4pp2BUqmE7/tqC1jZFxUAFWUHtuvtt9sZuLXrzM3Nce3aNXp7ezl27Ni+JwzsJgBKKZmenubGjRsMDAwwMDBw38fR6BXA5eVlisUiTU1NnDt3bt+zVTduVddao9Rm7da2iycnJ7l27Vp9daWpqemBI7+edo9iVbPil7iS+0tmKpeYrgyhodFuNtNinkRKQdEbxw4WMLwwvlndytXcMFl3DOEfRtfD5Fiiwip4WVJmByX/LgAxo4/cekiMGycoeVeQUscSHQg0AvrLSMAQIWxvCkdKdELk3CHketCKG2exIqO4gO8n8PGQrAEQ0M/hePeqgC2tHc9Prz9XKfBHqh8rQddO4ntvABIkmPrLSP+N+tavpr+M732jfi1dO4dfW1kUYLsnCJppEEeBIJrWjCZz+NpzIPNAG9r61rKvfxue9bM7/hoEAgE6Ojro6OgAqgGvFghnZ2dxXbceCLPZbH0lcb9bwF/+8pf55V/+Zd566y3m5ub40z/9U37gB37gvh//J3/yJ3zmM59haGiISqXC6dOn+YVf+AW+93u/d1/3Q3kyVABUlIe4X2+/3agFjitXrrC8vLxp63O/dhrUXNfl2rVrpNNpzp07R3Nz8wM/vlErgFJKxsbGGB8fJxgM0tPT07AAtt3903Wd5ubm+uOzbZt0Ok06na6PVkskEvUzhvcrfHjaNHoaR95d5a21P2co97+IGwkK/iQJvYcms5UF+yqOO09v4Bi2W129i/oJTD2KpbVgmLDkXAZmSbp9VKhuq4bsPkpadUUspHVR9mYIa6cQhKqrauIwtlwganSwul4FbIlOkAtIqscYokY/Za9aSRzQeusVwQBBfaAe+DQSeP6t+r8F9BfxNrR5sbRD+PU/BxEye+9coOiuTxmBaksYNgRJTTu7qWVMoXicWPhKtaZEgtDOoXtfqv+7r51E+G/iEULqL+MH/w8Qe//FLhQKEQqF6OrqQkpJsVisbxl/+MMfZm5ujqamJn7zN3+T7/qu7+Ls2bN7+p4qFAqcOXOGH/3RH+UHf/AHH/rxX/7yl3n/+9/PJz7xCZLJJL/zO7/DBz/4Qb7xjW9w9uzZvTxU5QlSAVBRHuBBvf12o1CovokWi0Vee+21hk5r2ElQy+VyXLp0qd7YORB4+DirRhSB2LbN5cuXKRaLvOc972FkZOSxj4KzLKu+ulJ7M60VPkxMTNQLHzaeH3waNep5y7ppvrr6X8k6M9ytXEWTBimjGc2T5L0MrlzGkWUSehvLlRskzENoToSCPonr5kgaBmVvEpBEtGZcawIATYYwTBO7fIKKV8YTHoRWgVVS+mmy6yuBAdFK0b03ei2oJSl51RXDsH6MslebBiKwRByPLopFSSTUhi9B119BIjBEGClzgA9Sx6cC2imk9NFFK7acQ4pBQGKKblw5A2IApI4pkngkAA0IIqVAaC8CGoIgCA+pvQT4CKkjxAqu342uVYAEhrx+7+tCN8KfRuAhRRQ/8M9A7P1Ix1ZCCCKRCJFIhO7ubt5++23+83/+z/zsz/4sX/va1/jEJz6BEIJ/+2//LX/zb/7NXV37Ax/4AB/4wAd2/PGf+tSnNv35E5/4BJ///Of5whe+oALgM0gFQEXZxk56++30Onfv3uX69eobxpkzZxo+qutBW8BSSmZmZhgdHa1X2+70cex3CzibzXLp0iXi8TgXLlzANM2Gr7TtNhRtfDPt7e3dVPiwcZLGxnYzT9P5wf08f1lnlTfW/oJvZf8nAS1ATNfptE5hCMl4uXoe9XDwCAvONWJ6N3GjlRXpsODM0CpacLUcAJYQlJHoBEmah3FlByV/jYiWIONeAgtS+iAlvzoxQ/hBiv4NxPq7jeXHcbRZhAwSNk7g4xA0Xsb3BQgftON4/hpBvYvc+qqcDICHib3eeiagHcGR36LW5iWin8NZnzAiCIG2ii8XADC1o3jevbnBAf0V/No0EMDQz+J7tdU+HVM7gl9fWQyhixbCoWpAlcTQhIkr/fXpIS0ILYigpVr8YX4MtPY9f412Qtd1uru7sSyLz3/+8/i+z6VLl+qtfh4n3/fJ5XI0NTU99ttW9k8FQEXZohFbvlCtsr127RqZTIZz587x9ttvP5KZvfcLgK7rMjIywvLyMmfPnq2fG9rNdfey6rTxnOHg4CCHDx/edF6vUc9BI8Kkpmkkk0mSySSHDx+uT9JIp9OMjY1RKpWIxWL11cFGzEPeq71uARe8PP8z/efcKY6y6k0S15totzqYLF9n1R2naT3gJrU2fHQs0YdGkOnKEABd1hFW3RGkL+gInEITkpB+BAHMVKp9+IJaEs+vTcUQINbqt98SPInjZ5BeEM82WJNLeFozwijgVxbw9WpQS5pnyLvV7V6NINKfql/DKx7Gi9YmgOhowsZff21a2tHN5wCN53DqLWFMNFnCXw9/uuhB1ucNV0fF3Qt/YOrnYUM41LWT9a1gKQW63g/+eoN0aaPpLQj/EhIdGfw1ME7s6muzVxungOi6zvnz5x/L7W71K7/yKxQKhV2vPCpPBxUAFWWD2qrffrd8a42VI5FIfcv1UTRWhu0DYD6fZ2hoCNM0uXjx4p5WHfcS1jzP49q1aywvL297zvBJrwA+zNZJGuVyuT5JY3Z2Fs/zsCwLwzDqvdye1vODju/wjezr/PnK56n4JU5EBghqRyn7Be6UriKRHAkOYlMioLVjUGGyfAMNjYBVnWGrYWAIi6B/nLy/RN5fouBVz/u1mV3120oZ7WTcJQwSNJnH8CkT0puQuCzbV5DrEzgSoV4q3iwCiHECR6tuBUs3RMG/jlg/xhYzjlNZb/KsizgiMI+QLWh6hIDWjySDoZ9HSh1NmKAnkUgEIVyZQ2hnAB9TNOPJORDHQAoQETxqFe8xJEXQBgENXbThyQyIU9U/a834MgfaOdbWcoTDbWjCBu0lEJLqhJFlpDiONP8fCOPbH+0XdINCofDERyV+7nOf4xd+4Rf4/Oc/37DzzMrjpQKgonCvr1atH9d+tnxrs3S3rn49rgBYa7Dc39/PkSNH9lxlvNsVwEKhwKVLlx4YOp+2FcCHCQaDdHZ20tnZWX+N3Lp1i2KxyJtvvolhGJvG1e3kbOVe7WYF8K3sJT6/+GeEDYeQFuFwcJCx4hUkkv5QOyXPoiMwQNpbZNVdptvqY9GttmHpDQ7iS5smsxlLGExVqitmTX4PhfUmze3mMbLuNUJ6JxGtA0eW0eiiLPOsujexZRaAVnOQ8nr4S5mnybvVaxkiii8mqtW5xIgGTlFx07gVgWNDWltFNw+jGTZBvR3XuIRLGcPXcP238SkCENVfouh+bf1R64T0bhx/AgBTHMJmlNr4t6D+Mt6G/oDVFjHVVjeCOEKs4q9PEtHEIfBuIylX/10cwtS+jvTWi0i0lxD+l6ob0Ob/C2H9P3f2RWyQfD7/RJtA/+Ef/iEf+chH+KM/+iO++7u/+4ndD2V/VABUDrxab7+5uTnm5+d5+eWX9xQubNvmypUr5HK5bRsr67q+54kdD1ILVZ7nMTo6ysLCAi+++CKtrfsbPL+bIpCFhQWuXLlCT0/PA1vbPO0rgA9Sa5ycSCQIBoMcP36cbDZLOp2un7OsTXeonR98UDPfR+FuaZ7/tPin3Cjc5GRkAB+XmcosMIFEcig4gIHAkRmksFl1l9HQ8OQazUY/loix4kxS8rMEtAimqE5mMWQQx5gjqDUT0TqRwkeKFjLuMpZZbQkD0Bk4TcYZAiBpDJBzq+cANUJI6RExXgBMLBGg4s/gSB0hEmS8t0B41fOD4eOUvOrYNel0YGtD1F42mtuKb1SvaYhWHO9eMUnYOItTD3gauibwfHf9Y3vxNjR4NvWXN50DNLUBfP8q1bfEEBoa1ZdWECHaCFlpJCbVM4dH0fz12zU+AIF/tO+v2249yTnAn/vc5/h7f+/v8bnPfY7v//7vfyL3QWkMFQCVA2vjODff9zEMA9/39xRS0uk0w8PDJJNJXnvttW0LBx7lCqDrurzxxhvous7FixcbUsm6k9U63/e5desW09PTPPfcc/U+Zvu55m7u35O0cWwaVM981nq33bp1i3K5TDwer68O1laW9+pBK4Alr8KfLPwFs+W7zFWmOBo+znRlnLJf4lTkMDk3TU/gGBl3npy3SofVyWxljIiWpNPqY9mZYsmbYTB0lJJbXb1rt7pYrNwkZR7GqAQoiHmKboZooItFuzo9o9UcJOtWC5xCWhNZZwRTJAmIdiwtiuAMZT9NRG9jxa2epQtr7RTlXH0aSFDvpLD+i1FMP0bJu1Z/XJFgkIq/Ps/XO4ynXUe6IaQXBtmJMBMYRghNBJH4GPorgMQghs8yaKfB90AE8QGJgy5SuP4dpAwDHqb+AvaGMGjpz+HWw2IYU0h0c63aAUb0YMq7gAP6yxD8xBN5HTZqCkg+n+f27dv1P4+PjzM0NERTUxN9fX18/OMfZ2Zmhs9+9rNANfz9yI/8CP/6X/9rXn31Vebnq+16QqHQEz0fq+yNCoDKgbRdocdeVug29rg7duwYfX19931DeFQBMJPJUKlU6OzsbEhj6ZqHzRgul8sMDw/jOA4XLlzY0RvSw94sd/tm+jhXAB/GNM1N0x1qzXzT6TR3797F9/1N7WZ2e4brfo91KHud3539UypehaORDjxMoELZL9FutuP4Hgv2KsciKXL2KkhB0khiahZpZ4F5+zYlP09MT7Jo30THosU8jCN9fMIU3CK+NoUULgEtQtatbgMLNKRfIKYPYGgxLGGQdSVFL0PIsli0q4UZAZFkzb03bi2sx8i71arauHGcwnrgEwQxhIWmn0YQwNAi+DKHJp4nX0gTjxjYfgCpOQS1dtAu4wCOBIo9WKHqqqEhOnFZhvVG0iHjZdz6yqCOKcL4cqX6J9GL799bRTS1l5HrZw9BYOrHoF40EsdEAjnQjkLo1xHinRN0HodGBcA333yT7/iO76j/+WMf+xgAH/7wh/nd3/1d5ubmmJq6V4zzW7/1W7iuy0/8xE/wEz/xE/W/r3288mxRAVA5cDaOc9t41m+3AbBcLnP58mXK5TLvec97iMfjD/z4hwWq3fI8rz5L2DAMTpxobAXig1braiuezc3NvPTSSzve6tzJtvJOz7rVPqbRDZIbZWsz33w+TzqdZmlpidu3b2Oa5qZxdduN49tq4+NcdfL8h+k/425lgogWpjvQxEjhNl2BVtbcNboDAwSEy0R5grgeY8WepTdwHFPo3CxVQ9fR0CAzlVF0TDqsPop+Mwv2NBKPuUp1ZajT6mDJqa70tJp92LKIJiIEhMWifQkfl6TRTWa9N6AuLCrrFcEAcaOTVXe5+t/6UVy/TMQ4A9IEfHTtGBU/TcLoJ7PeHFoXISzfwpXVqR64h6j41W1mjQCGvoK7/jIKaS/ghWqVulApQTBcDX9CduN696p4A9p5pH8bIXoBC01rR5JCoFebVQsf9FeqtyOiIHP44kXW1tZIxVvwRQG0fkTg/4MmntwYtkZtAb/vfe974Pfj1lD3pS99ad+3qTw9VABUDoyHjXPTdX3HK3RLS0tcuXKFlpYWzp07t6MAtJvrP0yxWGRoaAghBC+++GJ9rnAjbVcEsrHI5fjx4/T29u4qfD0sAO4mzD2Noe9+hBDEYjFisRj9/f14nlc/Pzg1NcXIyAjRaLQeCJPJ5DsmO2x83r68Msx/uPtnHA23E9cTFPwCN4tjJPQ4STPCreICfcEg0/YkMT1Jd7CT8dJt1rwJms3q8YC4lsD2y3QETuL4FW6VrgCSDquHRaca/pqNLsp+gYh7BF8K7nIHDxtTBInq4K8XWASERnm9J1+rdZSsfY2w3k9Aa8aTLkHtJGV/BZcSRe8ueNBiPs/qenNoU8Qoezfrjy9mHKewHgYNUhCevvdv5ikq7jCa1o4u42jCQOgvATqGiOLpGRw3heuV0Vwf3Yii6TYarQjerJ41lBDUz+N4X69+fYhiaXE8fw4AXX8OvLfutY/hCJr8Fsg4WvhfIvQHH3V41PL5vOq9p+ybCoDKgbCT3n47WQGsnXmbmpri1KlTdHd37/g+NGoLeH5+nqtXr9LV1cWJEyfqg+EbbWtYcxyHq1evks1meeWVV/Z05qcR00W2elpXAB9E1/X62UCoFhDVtouvX7+ObdubxtXFYtXVpiI2/3byi/zfy29wMnqI8fJdSl6Zk9FOmswBhPC5WbyNhiCsGXRZRyn7RW4WR5BIjoUHSDuz9AROYAiP6Uo1dPVYHdSaKpvCo8U8gsBCUmTBmQUNWmQnHtWikE6rn2WnunXaYgziyiJJ8wUEJjl3kaI0KLhztJkWWbcaJlutU+Tc4fXbiFL07p09Sxh95NfPCAbowfFXCerPIQig+Sa58jzReABNWOTd23jSB2+FuNFDbr13oCFa0MgjKYAGMeule1u/MoDmF6rhD3DLg3jBjef+BpH+ZSSg0Y8mKyAGgSDST+LLBaT+Kpr1kwj9aCNfCntSKpWeaBWw8u6gAqDyrrfT3n4P26ItFosMDw/jeR4XLlzY9Q/g/QZA3/e5ceMGMzMzmwouGllYsdHG+1sbJRcOh7l48eKOtiu308gA+KyFvgexLIv29nba29uRUlIqlerj6mpnsO6G8vxn7wqHCwk6A51IbMquzQvxI0yUp/GkS9LUaDVbabdaGC2MVnv9hVtZ9SSdVh+O9Fl1K1hanrX18Wu9gX4y9jQd1jHCepi7lWu40qY7cJgVZwKAmN9Czqjej5BI4uGRMs9Q9oqU/AI5bx6YpztwnNz6dZs3FIgYIkhlvbIXIGkcw5GrBEUEjSCOXEPTjlDxVwjqcda86ufF9CM4chQtAkUPYvognqxOJAnpRylvaOIc1FupeNWm0pbow/UuIaVAE3GCxvPrPft68D0DXXcplk7i+hWEF0GG59H1GELzMYSszxjWtXNo4mvEYwLN+mk04+kYd5bP5wmHGzduTjmYVABU3rWklLiui+u6OxrnVtui3W5Fqbbq1tnZyYkTJ/Y0eH0/bWBKpRJDQ0P4vv+Ogota0Uct4DZKLazNzMwwMjLC4cOHGRwc3FfwelQrgO8mQgjC4TDhcJienh7Krs3/Of4/+PzK2wz4cW7mF2knRM4SNOvNTJVnKHglzsYGKfoVZsoLlP1JJJLBUC+G0IhonQQ1i8lyNdgENUne02kz+xEIyujcrUzRbIZwpY1A4PirAOhYhGScgBfBMx1ieoSZSrWooztwnBW7upIX09tIO9W/Fwh8mcUSSQJ6G2GtGUfm8GUBIWHRvlKvAm42D1HwqvcrYZyg4F1dv4aGRq7+vMSMFyivrxIKDHRA0w4hRARDpJAUMfXz+NLBEBLXL+CxSkDrpeR9tX6dkH4SV4xgmhAWR9HkCEJ4SCko5w9hRicA8Lwj6CKPL08xMfUKJ5/7zkfw1d6bJ9kGRnn3UAFQeVfyfR/XdXc1zq0W6nzfr/+353ncuHGD2dnZHbU5eZC9rgAuLi5y5coVOjo6tg2fjyoASinr59Qa0VcQ1Argbk0VV/j0+H9n0VnmsNnGvL9ARA+StKLctmcZ8BOUPZduv53R/B1cPE5F+1isLDAYPEbWXSLtpmk1m5iuVIsoBkJHAR9XhtGFwVSl2gx5MDTIbKXaY68vcAKEhxAxTGGwSPVjErKVRae2qhegsF7NC5DQ23BJIDCxtAAZZxRbFnBlljxT9e3jNvMwFb/6fdlkHq8HPg0Tb70RM1Inab6IL1cx5AsUCzZewkDTTuHKNaJ6F3m3ur2riziWmKlO8QDixjkq61u/moiBnK/fx1pFsJQ6umjH0OJAtTehKSKYsSU8vwvPFZjaPFBgdv6HWFx5D63Ly0+kt+N2isWiCoDKvj35V7KiNNDG3n61lbydBoWNoU/XdQqFAkNDQ2iaxsWLF/e95bLbALjxvOHp06fp6ura9uNqoa+RK2HFYpHJyUlc1+W1115rSF9BeHAALJfLTE5OEo/HSaVSO36jfbetANb834vX+NWxP+dcspvFcpGBQJQ2L0VzJMZo4TZtZoJYMMFsYY32ELieR8wLkVldI2s4JCmSXq+ibQ1E8WWcjLNG2llh1U0T0AKk3Wq1riUC+NKj3TrNmrvKkjND0V9DIGiz7jU0jxlhyo6PQZAu6wQeFUy/HUNo3LWrQc4UQUKawF7fqo2ZbWScarBrMgZZW98WRuoIXCL6SYQIYoowtr8MGEjhsuaN4snqxA9dHCK3XjASFB2U3HtFTxHjUH1lMKD1YHuXAAtdtBLUB/HJozGARhDfnwfakKxgaEns9ZYvlv4CvvcmING0OFYgjpQhpPY3Qf8hhJip93bcOhu6kb907VSj2sAoB5sKgMq7xtZCj92EP7gXpDzPq2979vb2Nqy33m7awJTLZYaGhnBd96HnDTeuADbC0tISly9frhceNCr8wf0D4PLyMsPDw8RiMRYXFymXy+8ogtj6tXy3rgDavsv/NfU6/3nuLV6M9/DNzG2OR9opeSWyskCumOFY+DBQ4Vp+gsPhdgp+nkPBAXThMl6eJCQslv0FYk6csB/iJlP4wudosJ+7TrXS9VCgB1tWiBvdBDWN8XJ19W8wdITZSjUY9gYHWbRH0f0gCboBk7DWR8UvMmtfx5XVUWltZnv9/rdZh1lxqr3z4kYPGfsGIb0TU6SwtCBCPE/ZXyOmN7HiVIObJZJo5PHWR6+1WKfIu9XzfAF68EN36tcP6lFK7iyG1kZQ70NKh4D+Mr700DUXxy/iyTQRrY2C+2UABGFCWgxPzlavYVTHwkkEhjiCjgH6eZASTbh43m0M83uwgv+YeHyZdDrNyy+/TLlcrp/NnJ2dxXVdkslkvSH4dq/TRquNJKx9fyrKXqkAqLwr3K+3327UAuPo6CiZTKZh2541uq7juu5DP64WwNrb2zl58uRDzxvWHut+A6CUktu3bzMxMcHp06cBmJ6efshn7c7WACilZHx8nLGxMU6ePFl/vmtvtLU2KUKITTN3N84ZfjetAC6Wc/zctf8fAVMS0oKMFeZ4PtZP2k2z4KxyWmsmp3vYvs3dyl2SepyIHmK6tEhAi7Do3EVH51j0MEv2CgtykaBl4Hs+pjSYL08R9ZuI6DGmynOUZJG4HgexBkBIi7Bs30GTJk1mN0JahLQ+VtwFwnqeu5VqKOsLHmXBrvb267KO1s/+BUUKR5ZIGmfwAAMPRy5TdpfpsFqYt6sVuwERJ1/b7qXaKzDrVquKY/qh6sxgqWOKVky/hVLFIhqLYxCi5I9hY+H4JTQxjeNX71PCPEvZq64MGrTgbagyjujH8eUiuv4imogjyYE2CDKHLgq4/i1AYOkvIr0hNP37sIK/iBCi/jMFqrOhu7q66r0dC4VCffrLxMRE/XVae62GQqFHEgjVGUClEVQAVJ5pD+vttxu5XA4pJeVymddee21TyGiEh20B+77P7du3mZyc3FWLmVpw3U8AtG2b4eFhSqUSr776KrFYjLm5uYaHq43303Vdrly5Um8rE4/Hse3qObFQKER3dzfd3d34vk8ul2NlZYXZ2Vlu3LhBOBwmmUwC1RXb7UbvPWuGMnf5p1e/wPF4C29mJni1uY9FO4em+ZR9m+cCPVy3pzAqgrjRxJHwADqSkfwdBBDQJEdCRyh4Ja7lb+Djcyzcx1RljKSRojfYxUx5mrSXJSxClNa3V6OOxarpEBYJegJ95P01luw5TC1cXxVslu3kRPWXgbjewqJ9AyF1onoHugiTNJ6n4GeJ6HHm1sfEtZmDLG2oAi569yZKpMxuVtdXCWPaAI5fJGq8SLWXn4vj9VCRS0SMTvJcghAU3Aim0HDl6vo1TlFc7xUY1HqwvWEEUTQ6COqdSFFEyAqGiFL03gBcdL+MJSbXzwtqhPUT+P4MQnseUzSDXEY3votA6JcR4t6Z4O12AGqzoaPRKL29vfXXaSaTYXFxsd7se+P0l0Ag0JDXijoDqDSCCoDKM2snvf12ep3p6Wlu3LiBruucOHGi4eGvdv/uF9JqY9Vs264HsEZd+2FWV1cZGhoikUhw8eLF+tm7R9FeprYCmM/nuXTpEsFgsN5W5n5hU9M0EokEiUSCgYGB+szdlZXqOK/XX3+dZDJZXx2MRqPP3Pbw5+9e5fenv8XhSAuXslOcTfQyvDZNTLdoDQSoeJARWQypczZ5iNH8JJAlYUFMj3Ik0sWt4h3Kvs2JSCe+42OgY2km7WYfa+4at4o3caRNs9nEslfdBu4wujB9HcttoezZ3PKvIYVPgCCL9jgAGhq+toYuLRJmDzE9Sd6LknEXCOhNTJarK3cJvZ2l9QIRgYa/HtQA2qwBss4NovphAloSTzoE9RMUvWVcIcl70+BBq3mKjFPrFRij4t9bxYsZA+TXzwGGxSCeXyJkvIQvBbpwqXhFXJkmbibJe19Zv0Y7cAtwAb06Qk46aNoRdC2E593Al6sEOYr0/hJNf5FA6JObRrxtLAp7kI2v00OHDtWbfWcyGaanpxkZGSEcDm9q9r2XX1x831dnAJWGUAFQeSb5vo9t2/te9as1N15dXeXcuXOMjIw8kp56cP82MCsrKwwPD9PS0rKrsWob7SUAbgy+R44c4dChQ5uex+0mgeyXEIJiscgbb7xRP1+5269dbeZuS0sLc3NznDt3jlwuRzqdZmJiAk3T6mGwqampYasuj4InfX5l9MvMltPkbIdUoMJAqI1VL0fKjNAZjDKUneZMvAvbLlNBcj0/Rcm3OZ84hC09JksLTJXvUvZt+kPtrDprHA4dJSAEI4Vq9e7JSB8T5WqVbLvVhu2nWHbSmLrBXXcSBAzE+pmxq1vBSS9BVs4TdlqJ6gkKrFA0ygR9jyVnCABLBMm693r7RYwQZaf6Guy0TuDJEk1mOwKNrDtDwfcp+Hdpt/R6c+gW81R969cUEUreWP16SbOXsjeD4bfhVQL4MQ1TP1otFNEq5P0p8CFhnKWwHgwDWheOV72ekGFCxiEkDr50CYjA+uQPSVA/h+f+JRIDSzuPEBrC+G4CwU8gxOZir41bwLuxsdn34OAgjuOwurpKOp1mbGyMYrH4joKSnQTNYrGIlFKdAVT2TQVA5ZlS2/KtVfnuJ/ytrq4yPDxMJBLhtddew7KsffXqe5itIU1KydjYGOPj45w4cYKenp49P5bdhjXXdbl27RrpdJqXXnpp27FSje7ZJ6UknU6zurrKmTNn9tVSZ6NgMEgikaCnpwff91lbWyOdTjMzM8Po6CiRSKT+RrzdiLUnpeDa/G9DX8T2XK7lZ3kx2cF4cYmBSBJNi2D7Dldz0/QGm8l7FSbsZY4aCbKawZlILyP5O9jS5Uy8j1vFMXoCXQSExZS9SM6bJ6BXt9PbrWbW3Cz9geOAZKRQXaXrCXQyW5lc/5h2Zip3aDI7iepN2DKLY5u4Vh6PIhVRAMAtl2F90arT6mXBGcESUZrNPgSShH6Ckpcl7d6l7FfDZLd1hIK3CECrdYSsW91WNkSIkl9tI2OQoNk8jicL+Ah0YZB2rlargGWOkJkg61av0WyeoeBWq3cDWhcl9woacQyti5CewqMJx18mpHdQcF8HIKI/j+t9DYmGJU6jCQOpPYdAIuQ1fNlBOPSraNo7p9s0qr2SaZq0trbWz7lWKpV6Qcno6CiO45BIJDYVlGx3u8Xi+ta92gJW9kkFQOWZsZfeftvZOM9268rXbip1d2tjAKxUKly+fHnTmbtGXfth8vk8Q0NDWJbFxYsX77tC1qjRdXDvjGE+n6elpaUh4W+7r72maSSTSZLJ5Kbt4tqItdqbbHNzM01NTUQikT0XDO3HfCnPv7r+FcqOR8bL8WKim9vFWWJGgDWvwnR+haOxFKeifRia5Fp+kk49hkAj73rYsoQtXRJ6GCQ0Ge2YmsXN4gQAA+FWZsp3ORQcxBCS26U7QJbDoZb6fdCFi4lFa6CHoBYg6xW5W1nmWDjKvF0NZgPBI8ys9wZsEV3kjGlCfhOiEma5nEWazaxpawRFhrX1Obq9geMsrlcap4xuVta3hTV0PH+VkNaNqTUR0qKUvGUkOkJEWLDfROIDgiajo94CJiqP4BrXgGoLmIo3TVA/DYQx8KkIF1suEtYj5NyvARDWj1Px3kSiERBH0UUIXz+D9FcRYhbHW0EX3ZhaJ0J/jVDw59G07Qu+droFvFuBQIDOzk46OzvvO/2lVmHc1NREOBxGCEGhUMAwjH2vbH/5y1/ml3/5l3nrrbeYm5vjT//0T/mBH/iBB37OX/7lX/Kxj32Ma9eu0dXVxT/+x/+Yj370o/u6H8qTowKg8tSr9fbL5XK8/vrrvO9979vzb+S2bXPlyhXy+Twvv/xyvZCgpjYN5FGorS6m02mGh4dJpVKcPXu2IY1ldxrW5ufnuXLlCn19fRw9evSBz2OjVgCz2SxDQ0PE43H6+vrqKxiN8qD7WNsubmtr2/Qmm06nGR8f37RN18hD+g9yc22ZT1z+S8rSJhW0sKSJQ4XD4TZ0zeNy7i6vpvq5WZgnYbisehlORfvJ21nG3BUGw61MluY4Hj6MoUmu5McxhY4U1RYq/cEuHF9Q8HRKns2CUy3eGAz1MmvfIaxF6Qn2UvLzFKVOxfeZrlRDWovZzEyluj0bFCFW7CmazB7sAuhBA2SUVdY4nGhj1q5+TsrrZM2vBhbLj7Bs3wQBmjSJ6ilCWgyf6pbxgn0ZH4eIJsnKm/g4AMTNBDmv+vptNU9u6PnXi5Q+VE5ihQx04ZD3roOfpsk4Q96rFoGEtEOU3LdBWgS0Q5haAl+cwvFn0bUyJW8UgUVUH0SIFMij6EziySmiwf8dTbv/LyR73QLeja3TX6SU9YKSlZUVxsbGMAyDz33uc7S3t9Pc3Lzv+1QoFDhz5gw/+qM/yg/+4A8+9OPHx8f5q3/1r/LjP/7j/N7v/R5f+9rX+Af/4B/Q2tq6o89Xnj4qACpPtY3j3IQQ2La951BSC17JZJKLFy9uewD7UW4BCyEol8u89dZbHD9+nN7e3oYVK+ykwrg2R/iFF16gvb39vh+78f7uNwzX+ikODg5y+PBhJiYmGj4JZKfX2/om6/t+fdJJ7ZB+NBqtB8KdnsnajW8t3+V/H/4yGBJDE9zOL9MWDFPxJI4sUaHMc9FeruZnKHk2p+PtOEUPT3rMuGkMqdFsxVhxcqw4OTJutRXLyWgvvvTBtzA1g5vFyfXHXN0GDoswIT1Ei9nPXGWekLPEirO8fq/s+v1L6CEsrZ2wliSkmUxXbpK1F2imjQV/AoCk0cKcfRMAHR09WES4OmGtlQhJynaOssyjyyDTotYcOowl5L3AZ6TIONUJHa3mcdbcEUJ6FwGtGdAI6CcpePOYeoycHAEdIuI0hfXzfUHRQcm7gk4cS+sjqIVwpaDiTWHqBkX3jfXbOYPnz2PpL2MJgeO9icAkpB9BE0cJBf8Jutb3wK+Z7/uPvcpcCEE8Hicej9Pf34/v+6yurhIKhfjCF77A4uIix44d47u/+7v5ru/6Lt7//veTSLxz+/pBPvCBD/CBD3xgxx//b/7Nv6Gvr49PfepTAJw8eZI333yTT37ykyoAPqNUAFSeWrXefrUQUvshXJvUsVMbz9o9LHg9qi1g27YZGxvDcRxeffXVXf+wfpgHhbVaU2nP894xR/hB9lME4vs+169fZ25ujrNnz9LS0lK/n408V7ifAK1pWv28Ve2Qfm11sHYma2N18V63i2v+1+w4v3v7Es3hMK70KFOmXY9R8EvMFVe50HKIS5ksHUGPlBHhTKyXb2RuYwqNiCkZNDqRnstb2eoKXU8oiiaStFpNTBRnyHsleoOt3ClVw9/RUC+6Bh3WIUKawdV8NbQdj/QzVa5e41Cwn4w7T09gkKAIMedMUPDyxHUHxBqudNDRcfRs/XHEjSjSKRA1OojpMda8ZSqUsYTBknYDqUkEGhGN9bgHZiGOHak2l47TTdlbJWk+h8DElTk8Iqy6S3QGmllarwJuMo6Sc6tbv5ofoeyNYWndmLQS0HXKHpT9WSKaQb4W+MwXqbiXsfTTWKIJ17+J688S0Dpx3csY2gtYmkD6twhG/jm6fuShXzfP8x5JV4DdqBU2ffKTn+S///f/zj/6R/+IX/3VX+V//s//yT//5/+cRCLB+9///kd6H15//XW+53u+Z9Pffe/3fi+//du/jeM474pWTAeNCoDKU+d+vf1qwcF1XSzLeshVqsrlMpcvX6ZSqfCe97yHeDz+wI9/FCuAmUyG4eFhQqEQpmk2PPzB/VcAaxXGra2tnDp1alfBea9hrRY4fd/nwoULm0boNToAQuMaQZumSXt7O+3t7UgpKRaL9UB4584dDMOgqakJ13V3vTL4n8ZH+V9zYyyV87TpYYSQhPUAuibJlgtcaBrg9ZU7HIs2o6GxVCni4aCj8VLyELcKs8x7ORJ6NYCejvThSoe58hqtVoK8VwIgqEOP3o1BgIybYdnJYAqdpvXvF0PoZN0lmo02onoST5ZYc22y7iT9wQ4KXh6AjkATdyvVNjv9wcMsFe7SLAaJWDHS7gxZr0Len2dNn6fsVz8npgdZ9qtfi+7AEZacaniLaz0E42EcN0bJLVCSRRxrBbxlmuVhClo1jCaMXjJOdcVQJ4CUq0T0Y9hlHQOBa0xS9hZoNtvIOt8CIKofoeS+jSm6sbQefLmGi44uCzh+dYs5rL+EhouHwNQE4BMJ/zsM/fSOvnaNnrG9X7UpIB/84Af54Ac/+Nhud35+/h07B+3t7biuy/LyMp2dnY/tviiNoQKg8lR5UG8/IcSuAlptokZrayvnzp3b0Vm7RgbAjcUmR48eJZVK8eabbzbk2lttV2Fcm7Cx1wrjvRSB1LbZm5ubOX369DuC0sMC4G4D4qPq9yeEIBKJEIlE6k1+a9vF6XQa27YpFAqbqovvFxL+z5vDfHV+klv5ZbqiEaZzqzRHg6xVyvTHEvhScCU3w+loJyWKXMou8lKyGw+PsBbiWn6KomdzMtCM7TtEjSSrXo65SppWM85YcYqEEaU/2MndygJpZ43TsT6WK9W2L8ciPYwVx+gMdNFiJblbnmXezXA8HGe6Uj0f2BfsYc6eAKrnANfcDF3WcXw0Fp1FslqFVW+aXr+TrFsNhj2BPmbXmz63mz0sO7cxRZiY3okUAWLGCbLuIoYWZd6prj52hY6z4lZvMygTFEW11yASZEkQMo9iGBZBPUDGeQvJAiHRi23eAQlB0ULJvYZOnKB+GEsTlGUHZZnGAGxvGk2ECWktQBIpc+Bfw8FY7xk4STT0CQzjxR2/Fp62AJjP559YBfDW77fa9+qz1ndTqVIBUHlq7KS3n2EYDw1ovu9z69YtpqamdjVRAxoXAB3H4cqVK6ytrdWLTfL5/CMrMNm4XVu77VwuxyuvvLLnFcfdhDEpJVNTU9y8efOB2+xP8wrgg2zcLhZCUCqVaG5uJp1OMzIyguu6m0bV1So2/6/rl/ny/CRFWeF4oplVp0R/Isl4YYXBeIo30zNcaOkh59iYusaNfJrBcCurbomJ4grnkp3M5hxOxnpIlzMseXnOhLu5UZwDKTgcbmPVjXGnOEtIT5N21qpbsc4iSEFPoB2kRlBLsFDJknVXKfpFTKGzut5WRQACj57AAGCgC5/J8m0gy9HwIFk3DVSbRi861WKPsBZl0R4jrrcT1psICI2y7CbrLpMyQ0yVqyt5rUYvy+vhzxQBCuttX3SCtAYGcLGxZQXT18lp1ckgWimBZWVA+GhYCC2NlCYRY4CgFqPihyh600Q1v14skjTOIGWBoP4SAVGh5H0TTUSJ6ceQHMfEQMpZIsH/N6bx8q6+9rs9cvKoFYvFJ9IEuqOjg/n5+U1/t7i4iGEYNDc3P/b7o+yfCoDKU8PzvIc2dn5YQCsWiwwPD9e3H3f7m7Ku6/VxZHtVm6wRi8XqUy6gsW1Vtqpde21tjUuXLhGNRrlw4cKOt8q3s9MiEM/zuHbtGisrK5w/f55UKvXAaz4tZwD3Q9d1Ojo66OjoqM+ETafT9YpN0zT5H6U1rjt54pEg6UKJqGWCgLLncCTazNuZu7zc1MPl1XlMTaMtZHEy2oOp+1zLLdIbTOBLaDJT6EKw5OWx0Eg7q5yIHMaTkm9lbyOB07EextZbwJyM9uHh4XkrRIwwo4Vqc+VT0UPcLlW3W4+Eein4efqMDoKaya3SCBJJh9VO2q2e1QtpIRbW+wQiJUibZqOXoB4loBnMVsZYdNL0agkm7WqrmIgWZ8m5de95EtXZ12GtlRazF4cikMASFtP2JQAsESGsOfXPaQonyLsZDLcHUQlT0TPIQAmzLCmZ3wQgaRyn6FwjZJzGEknK3jCezJI0X8T2xglor2CKPBXvWwS1cwitQjjwv2GZr+76a61WAKsuXLjAF77whU1/9xd/8RecP39enf97RqkAqDw1hBAP7e33oAA4Pz/P1atX6erq4vjx43v6rX0/K4BSSiYnJ7l169a2kzV0Xa+3tGn0G4qmaWQyGW7evMnAwAADAwP7Dke1+yilvO+1isUily5dwjCMB/YUrHlWVwAfZONM2L6+PjzP45fe+ArXSqt4nsebhWUOhSJ8a3mGc01tjOSWOZyIczTSypKdx/U9zjd18fbqNN1hndniEiejXSB8htdm6Q0muZ6fJiFCdOtxJp00d8vTnIy2IgFDaJT9EsciAxTdCmPFGYp+mYQeYapU3W6N6WHmK3P0BQ5hCItZe56su4bGCh2BKJLqcxjU9erUNKA30E3RL2KJMMVsgaXQHJ7nktBT2DKNj4eGRsVP15+LFquVxcoaKbOfmN5ERa6BSGFLmKlcwcNBIGg27/UjbLN6yNjXiBiHiOjtOH4aR4SxLAPPvInER/di+PoE0gsiy+2UzTLSsii5i0htAlfmiehnkNLFkTZh4QKCoP4aQo4Tsv4pAfPb9/T1fdoCYKPGwOXzeW7fvjdqb3x8nKGhIZqamujr6+PjH/84MzMzfPaznwXgox/9KL/xG7/Bxz72MX78x3+c119/nd/+7d/mc5/73L7vi/JkqACoPDWEEA8NLYZh4Lrupr/zPK9ecfrcc8/tq8nwXquAN46Uu98qWO1NpNFvKJ7nsba2RqVS2VRxu18b26xs93WpnbGsBe6dPKZ3ywrgg/ybK29z1y4SDUfI+iXOBrq4lVvmuXCSt7LznDIijK9lOBpJIITOiVg738hM4EuftmAYQQu+hJuFajPlrlCcJi/MVGGJOyxTweVYpJ3x4hyD4W5SZpjh3G08ljkT72PWrvYD7As3c7c8x0DwMCE9wPXCGMvODM9F+8m61SkdR8N9TK33/eu2unB8j97AcXwpuVOawpYVNAQJ08RbT4bNVoKZylL1NoIDpJ0pWs1BgiJKwVvBlgbLziK2zFHwquGwNzDIkl39nM7AMVbsUeJGHyHRQsVfxSXCmpvG8TPYMotAENA8Cp6PcFNERQ/CLJJ3x2mKWZTlaPXcYKGdkoijWQU8JnBFnrhxDp9xhNQxtTChwD8hYH3Xnr+ej6oR9F4VCoWGrAC++eabfMd3fEf9zx/72McA+PCHP8zv/u7vMjc3V29IDXD48GG++MUv8jM/8zP85m/+Jl1dXfzar/3arlvAvPHGG/zBH/wBra2tRCKRerubaDRKPB4nFosRiUSIRqOEw+F68ZzSeCoAKk+NnbyZb12hy+fzDA8Po2kaFy9e3FRxuhd7aQSdzWYZHh4mHA7XR8ptZ2MAbJRiscjQ0BCO49DT09Ow8Af3D6xSSu7cucOdO3c4ffo0XV1dO77mu3EFcKP/cHmIN2Zm0AMaQUsju2YTC1g0BSPM+0VeberhrbVposLAcRxuOWv0mwFSWpBDkRTfTE9hCEFnOEJ/qIX2QJw3V6tbuCeDTYy5iyT0CAkjTNSIMVlOs+Ss4OGTMqLcKU4R1oL0BrvIu2XWHA8hVymTw5UeUT1UL/wwhI4jy/QHj1LxPVwqzJYXgUWOhw9hywoAg+FD3K1Uz/G1mu2sOit0WMfQpEHOy7DmOax5U/QFe1l2qmf8+gPHmLerVcDNRg/LlTESZj8BLYHjF/AIs+TM0WkJsk61EKQrcIK0cwWkTnvgBSQ2mvARrkk+OAwuNJuncL07RIxzWMIkr30dEITdAexyCPw4dvhNcI8RCSxi6n+DgLW5dcluPY5G0LtRKBQa8n3+vve974HfO7/7u7/7jr/79m//dt5+++193e4Xv/hFfuM3foP3vve9rK6uUqlUqFQqOI6D4zj1aU9SSkzTJJPJ8A//4T/k137t1/Z1u8o7qQCoPFM2BsBak+GdTLXYy/UfRkrJ9PQ0N27c2NG2a+3+NarKeHFxsb4CF4/HG/4mtV2j5Y0FJjtpq7PdNd+tK4D/9tLb/I+74wQCBp70+NbiHOfbu3hj6S6vdfWwksmz6pc4He/E0gVvr97lhWQ7+D63CyvcLi4AMKglsB3JuJMGqq+V9kCMsnTpFS1EgyHeWrsDwIuJXkbz41jC4Eikk1WnwJ3SPN14jJdmAegMJblVXAXgUKidsl/GEEGCms71YnWax+FQD7OV6sc3GSmmytXrm8Kg4heIltoJRWOYQrJgL7Ls5DkaHmSlUl2l7LR6WLSrnxPQwqw6UzQZ/ZhaDA2XrLBYcGboC0RZcqqBtss6yqpbLRaJa71IIG6cwvbXWHFG8GSJgBbHtPIgg8TN40iKlGQZzc9iyzGC2mHCejsl8QZBK0VU78F28xgI5u9+iPRSjHj8rXqBzl6+T57GLeDDhw8/6buxZzdu3OD9738/f/zHf8zi4mJ9trvjONi2XQ+ExWKRVCrFz//8z1MoFJ703X5XUgFQeabUijQuX77M0tISL774Yn24eqOuv5OA5rouV69eJZPJcO7cuR1VwdXOOO53BVBKya1bt5icnOS5556js7OT0dHRhheYbF2xzOVyXLp0iXA4vOcCk3frCuBnL1/m7aV5msNhyr7Dilvh5bZu3lyZ4WJHD19dmORccwe29MjZZaYrGc4mu5mrrLJQyfNKcycZu0iPFuRuZZG8YzMgoswWM/TpTYTQuWUvYiBoc6orcwk9hO05DIYOkXNLvJW9jY+kK5DidrG6dddmJZmvLDMYOowmdcaK05T8CkHNJGKst1cCHP/eeL52qwlHxpFoBDWD26VRsKBLBlhYXz0M6xEW19vGAOh4NBuHMLQIQU3nbmWUrDdLd2CABecGAHG9heX18XE6FpoQpMwzFLxVdN1nsd5SZoBVt4RGgBbzKKu5OdzAPIICOfcGuggR0ZuwfQ9dWJScNwkZL2Iygy9XiBopIpG/SW/7X6dUKtVnQc/MzOD7fr2ae2O19oM8bVvAxWJx3zsdT9KP/diPEQgEiMViO5qBfuTIkafq+X83UQFQeWrsZDXH932mp6eJxWK89tprDe/Qv5MzgLUgFAqFdlT4sPX6+wlqlUqF4eFhKpXKpirnRzHBZOMK4NzcHFevXuXQoUMcOXJkzytv78YVwP9y4yZvzM6w5pQJBA0sQ8OrSHJehcFYE9eyC5xt6mSqtEq6UuA9bT1IAULAQiVPTyhBxZOM5Vd5ubmTfMkmpBm0JpvJ5Dxszeeuvd57jwh5p8IRs5ugZXA1X63SfT7WyaJTfV5TVhBJnBarBVOTjObHWbGnOB3ro+TXtnW7GFuvCB4I9SPx6A8cQyK5XryNRBLUggS1e68pIe5V6nZbnZRlEVOECYgAk5VreNIlqTfhsYyHi45B2V+uf06T0Y5HtZdhSDeZta+sX+sYq271v1vN40jhEzeewxCwZH8TApDkKI5cIWqcIyAqZJ1vYokWokYvJRHGEh5CthDUg0SsDxGyqg2SQ6EQoVCIrq4upJTk83nS6TTLy8v1au2N7Xu2/lJTa0r/NK0APsk+gPslpaxPLNnaXme7lVYpJf/u3/27x3ofDxIVAJVnQm27dWFhgXg8zssvv/xI3vwftAIopWRmZobR0dE9B6H9VBlnMhmGhoZIpVLvaGytaRqO4zzgs3ev9thu377N/Pw8Z86coa2tbd/XfFgAfFDV8f0+/kn5i1tj/KfRUdZkhVg4QMG2ubmW47mWFi5nFjnd0oyhJ9E1QcV1eG9rP19fnqI5EKJSLnMm3oPQPC5nZ2kPRpkpZ3gh1o+hwzcz1XDXEU8hCoJeLYknfFZcB8ddpWIXQUC7HuVWcZomI05vsI0VJ8tcpYBOgBV3CYmk2Uxwp1RdFQxpAcp+mcOhoxRdm7STY8WpNo0+Gu6sVwT3B7uYKFfP/iXtJFg6vYETSCQT5XEcaaNTnU3syWqBSJMVY96u9orrCR7BlzYhrQMNwURlfbtXb6HgVXsQBrUoZX+epHkapE7Bm6LsZzBFmKgmEdJEK3fjh0uUvEVCWjNl9w5h4zymXCTvXiFlvoDtXSVuHCVkfE89/G0lhKivOvX39+N53jtmQUcikU3NvWuvw6dpBapYLO5o5exptLG1lK7rrKyskM/n6ejoIBAIUCwWmZ6eJhAI0NPTs6Pm/creqWdXeeptrLCt/Sb/qFZ+7lcE4rouIyMjLC8v76vSdi8rgBvbyxw9epT+/v53PP5H0WOw1g8xnU7vaobww9wvsDmOw61bt7Asi5aWlh1tzz3JFcCvTk7zx6PXCQQNOnWLomdTweW5plbeWpnlWKKZW2sZoqZJkxEgYYS5uraAIQQnEi1cyswS0UpMlZdpssIMRpu5tHqXsrOM1Kth/rlYBwFNJ2rEMTEY86qVtP2JJq4XCsREkCYZwXN95rwilrvMPKsAxEyLZbf6XHcFU1T8GKAT0jRGi9XVvxORfuZK1fDXE2hnulINiRERpuyX6AucoOhVKDpLrNqrwAJHwodwZPW10R86zEylusXbZnbiSJd28zQV32auMoktS2hoNJvJ+vOWMMIU3BhRo5ug0Fiwr7LqrtITOM6aX70v7dZxPFmmIscx9Twl5glrnejCoIhLDAdNSxDXm5BkiZvPETG/j3DgB3b89dN1vR72oPp6z2QyZDIZbty4QaVSqZ9xzefz9SbgT1qhUHimt4A3/qz69//+3wPw4z/+4wQCAX7pl36Jz3zmM5RKJT796U/zwz/8w0/yrr7rqQCoPNU2NlV+7bXXmJ2dJZPJPLLb226FLp/PMzQ0hGmaXLx4cV/bzrsNahvPGj6oyXKjA2A2m+XSpUsIIThz5kzDwt/GiSUb5fN53n77bQKBAEIIxsfHMU2TpqYmmpubSaVS920F8SRWAG9ksnxl4i6GKVgplYhFAhiGRkCarHplnku2sewWkVLSGgzx9soc59s6cfwABjpfW66u7sUtkzOBHgqezRvpCQCeS7aRcQoM6GEyzhpz+SxJI8S0rLZU6QmmQAr6A91IfEYrc6DB4WALs0519a3VC7GYX6Fb78AyAlzNTeNJn7gRBlGdG2wInRVnqf6Y4kaYiHEUx/cJ6ga3i9WGzkdCfSyb1Xm/LWYLd8vVIg4TE186dAdOUPZtEA7T5en1zxlgdX0+cU9wkAV7hITeRUJvo+gtkvUKmFqejDcOSFJGDwV3lpR5Bl1oLNjVWb8d1mlylVmCnCagr7HqXKLFfBFXTmHIEEI3MQkTMr5jV+FvO5ZlbZoFXSqVWFxcJJvNcvVqdfWytl2cSqUIhUKPPRDWmo4/qyuANbXv2f/4H/8jf/fv/l2ampq4du0av/M7v8PP//zPk8vl+NVf/VXOnz/PiRMnnvC9ffdSAVB5amz8Ybpxju7GpsqNnNW7ndoKYG2VsVZp3N/fz5EjR/Z9Fmg3bWby+TyXLl0iEAg89KxhI8/WTU9Pc/36dY4cOcLt27cb/ia39X7Wqpn7+vro7+9HSomUktXVVdLpNOPj41y7do14PF4PhLFYrN438nEHwLu5PF+YnKZoauQ8m5ZYmKVigYJ06InFWLFLhMIGSStIRyjCN9PTDERTFByHG9lFjiRTRA2LF5OdvLl6l4rvcjyRAgmn453kHZuJ/Cpnk2HmKlkABqNNLBeyWCJA0DC4vFat2D0Wu1d8ZOg+HaKZhJHAx+ZW8S4r3jK9XhxPq77m2rUI0361B+CxcC+OdGky2tAEjBSqq4IJPYZDNfDpaOS9e+f4WswUCSOOK31Cusl4qToBpC/Yz4JdDX8po4V5+xaaNGk2e5FSxxRtrDhpBDY5bwkBGMLGIEDcGMDQXFacGQrOHVK6AdIgZZ7A9rM4gWWSWjMaQeLmGWzvGmH9NBqTBEQ/ceu7iQT+RkO/xkIIwuEw7e3tjI+P823f9m3kcjnS6TQLCwvcvHmTQCBQD4NNTU2PrVddsVh8Zs8AbrW6usqRI0cA+KM/+iPe+9738rf/9t+mqamJT3/60xSL1eKkR7nrc5CpAKg8VYQQVCoVLl++TKFQqM/RrXnUAbAW8Gzb5tatWywsLDS00ninxRqzs7Ncu3aN/v5+jh49+tAffo1YAfR9n5GRERYWFuqVzePj4w0NWBtXAKWUjI2NMT4+zvPPP097ezuO4yClRNd1mpub69XV5XK5PmptenoaIQSpVArXdRt+9vFBlvNF/r/X75D3PcKBACkrxKpdxjA1OvUot3MZDCFIBi3GcmmiQZ2Xmrop+RVGs0u81NyFpglWSmVuFZap+C5nEu1omqAjkEIIya3cEqamM1tJEzdCDIbbmS1lmHPy9Boak/nq+bkT0XbulGboDrTQGUgxVV5k0c5yNBJkqlwd59YTbGbBrn58XIQoemVa7BYqeEzIeYqi2jT6UOjekYbOYBN3SqsAHIkcwvVsvHyARCLO9fVVwYgWQVv/XA1Bxc+u/32CNquTgh9lyZ7F1ANMV6oh8XDwGAv2VTRp0hM8iUuBEhlSmsbyeqVwtzWIxMWVAsiQ96bQC9248RxFb4F28ygVrZ2A5qPTTsz6zoaHv41qBSBCiHrD4kOHDuF5Xv0XlMnJSa5du0YsFquHwUQi8cjODTaqEfSTVPsZ0N3dzZe+9CVeeOEFPve5z/GTP/mTxONxcrncpqCrwt+joQKg8lRZWVlheHiYVCrFxYsX3/Fb9XaTQBqp9kP7W9/6Vn28WSgUatj1HxbUfN/n+vXrzM7O7qroYr8BsFQqMTQ0BLDpMe90HvBuSClxXZfLly+Ty+V49dVXicViDwyawWCQrq4uurq68H2fXC7HysoKS0tLXL16lWg0uunw/qOo2izYNp/5+pu4QmIZGgXbwTA1TEPHFDqe7tMdjmKaGkPpBb6ts5dbuTQV32U0u8SLTZ3MlnLMl/O83NLJlbVZziZ6WHbWuFvKciTaxEiu2lfvfKqHvGtzfW0RO+TUVwJNXYILHVaSqBEmqTcxUcggkSza1Y+R3AvESTNETO8DNCxNMFoYBx1OhrsZt6tHKVrdGLOV6tZxUsQoe5X1ApESM+VF8l4eLIhueLvoCrYzVb6JkBoDoeP4wsWVFgHN5FbpcvVaehPz6w2kQyKKLx2azdPk3BUWnZvYskhES5F1b5EwBojoKRbtN5G4dAVO4fslIvpJvOA4rgzSbB4h51yn2RxAky6JwF8lGvihhn+dN7pfD8Ctv6BUKpV6u5nR0VEcxyGRSNRfk9FotCEhxvM8isViw45kPCm14o6f+qmf4hd/8Rf55je/iaZpfOhDH8IwDL785S/T3d1dP5+pPBoqACpPjdoK1ODgIL29vdv+wHzUK4ALC9VmvMlkklOnTj2Smb33u/+1ECal3PVUk/0EwFrobmtr4+TJk5tWLhq9xVq7n6+//jrBYHBP/QQ1TSORSJBIJFhcXGRgYAApJSsrK4yMjOB5Hslkkubm5nqvt/3yfJ9/89U3mS3kWSyXyUubvrYmxjJpEpEgmiaI6lb1/GJulYttvby+dBchoCca4VC4GUPTmC/nSZlBNAQREUYIyd1SNbiFDI3nYz3kXYcr2XnyboW+UJLRXHW797CWIIBBu9VMwgzy5mp1gsZzsS5urs/8PR7pIOfmOB45jCUMRnJjePg0mzGKfg6AoGayuF5MIoCmeIK4E6fgVNB9lwlZDYOH9E7ysroV3OTEmNerq4pNegu+FLSbx1hx0sw5dyl4OQTQHby3kpg04rhE0EQQE4/pSrUH4KHQAIv2LJaI0Wb1s+pOk3FmMMjiS58W8zQlL03em6Y7cIJspZlIIIKkQpN5AlP4pKzvJRr86/v+uj7MTptABwIBOjo66OjoQEpJsVgknU6TyWSYmJhA07R3nB/ci1pD5Gf9DODo6CgnT57kh37oh2hqauKNN97gr/21v0Zvby8Ad+7c4cMf/vCm3R+l8VQAVJ4amqbx3ve+94Ef86gC4MZ5wpqmcejQoUeyinS/M4DLy8sMDw/T3t7+jhC2E3utLq6dszxx4kT9h+/W6zYyAGYymfrYukZOb2lubq4f3i8UCvXVwVu3bhEMBusrMalUak+tJX7njSFupdOU8AhaGgkzTLZSoSMeJV0uYVk6V1YWONfRgVbUWHEKJMwAp1KtfGVxkvZQhMVslrPJLnQdvrEyQ9SwuF1YImWGORlv51p2jjW3zMvNXYyXqv36UoEgqUAXZdej6OSYsFfRACGq1akasObn6Q60ENejOLLMbKXAbKXAyWgrHtXXRGcwyc3CKgDHIz1UpE2baWAKjdH1s38dgSYybrXfYEBYLPuL1YTogyUN4mKAAmUiRphbxTvr1zrMVLm6fXsoeJglZ5w2a4CwiDHn3KTil2gzO1n2qtXFLWYXnm/TbJ5AR3K38hYA/dYJfOFhaRYeyxTdBToD58i7VxG6hS4MTAS6zJMM/PXHEv7gnb3qdkIIQSQSIRKJ0Nvbi+/7rK2tkU6nmZub48aNG5tek8lkcsfnB2tn4p71LeCPf/zjNDc381f+yl/he7/3e/nO7/zOTf/+kz/5k0/onh0sKgAqT5WHBRld1xu+BVybpyuE4OLFi7z++uuPbJVx6+PbOFf35MmT9PT0NOS6D1OrLl5dXX3HOcuNGrUFLKVkfHyc27dvo2kax48f3/a2drtNtvXjhRBEo1Gi0Sj9/f24rls/q3X79m3K5TKJRKK+OriTrbnPD11nZHGJQMBECJ3VbAHdFERNCymgKxbjenaFl9u7+Or8NC+2tmFoGnnh8ObKDEIKTiSauZlbYbFcYH59q/ZMqp2S53Atu8h0McOaW6bFCjOam6M/1ExHMM7V3F2Kns3ziQ7GK9XVuOfi3YzmpukLtdIRTDBeXGDJXuVULMTtUnX1biDcyp1SdTu5zUqw5hQ5Gh6g4rvcKs5R9MrVFbtQsv44k0aA1fW2MUfC/TjSpeJ7aK7PjDYJboaYG2bSmwcBIRFkvjJBQIRoNbvxkVR8i6nSNF2BZip+tQrY0jyiNBPV2vFFmnlnAlMEiOsmJhFarSOkvTuU/VV6reOAS9yIkneHiOrHsY3rmFoXQYo0Bf8GseAP7Oo1sh+NGAOnaRrJZLL+PbbxNTk2NkapVCIWi9V/QUkkEve9zUKhgGVZe5rC8zT54Ac/yJe+9CX+4A/+gC9+8YscP36c973vfRw/fpzu7u4nffcODBUAlWdKbQWwUVVh8/PzXL16le7ubo4fP46maY90m3ljULNtmytXrpDP5/c0V3ej3QS1QqHApUuXsCyLCxcuPLC6uBErgBvD5vPPP19vqdEoD7p/hmHQ0tJS79tY25pLp9NMTExs6gW33SSIb4zd5asTUxQ9l3SxTNot0RkJciuX5WQ4yFwhT3M0RHswzLeWZjkWbyJTKTOZz3K2rY24Z5GwAnx5sdr25bmmFoJGiiYzzFvpGSq+x7mmTi6vzRDWTE7G25gqZrmdy2DqgqJnowNZtxr+OrU4pjCJGwnGixlKfoUlO4cGFPx781KDmsZAqAddmOhCMpKfBNKcifdSLFeLN45HerlTngCgx2rFlXA4eJSCV+ZmcZqKb6MjaLPubaG3xpLMVNYIyQgpO05JFMiZaySkwyLVxzgQGmDOvkFAhOkJDFDw0qw4qyRCzaw40+u3dwQPh2V/nIpcouyv0mYep+RnKHjz9AWOUPa7CAiPip0kGPZIBv4a8ccY/uDRzAHe+posl8v184Ozs7P1Iwy1LeNIJFL/WZfP53fUH3MnPv3pT/PLv/zLzM3Ncfr0aT71qU/xbd/2bff9+N///d/nl37pl7h16xaJRILv+77v45Of/OSOxmBu9ZGPfISPfOQjjIyM8F//63/lz/7sz/gv/+W/8MILL/De976X7/qu76K9vf2ZX+l82qkAqDxTatt3+53P6fs+N27cYGZmhueee46Ojo76v+2mVctu1cJlNput9zfcrthlt3Ya1GotV3p6ejh27NhD39z2uwJYLBZ5++23sSyLixcvYtv2Ex0FFw6HCYfD9PT04Pt+fRLE1NQUIyMjxGKx+urgSsXjTy6PsubYVPAwAxonki2MrixyKBbl6vISZzra+cb8DC92tvFcoA2hw5srK5xMNuN4PtdXlxhYX/k5k2rH9lxur2U422JR8T0Cmo7jO7wQ7yHrlPn6yiSelJxOtHGrUD37dyZZXRUulDwiRpA3V6tB68VENyP56tbqqXgXi3aak+FDBHWTa/lxbOnSGUiRdqrbulE9yGSpeo5PR+DjcSQ8SMlzMDSf28W7AJyO9jO/3gT8aKSXifIY0q+OjDOEQdLowvFtlrR5PDwCBMnIORCg+RrlQomk0c8aGRbtCYr+GiEtwqozTrM5SFBEmbGHkXj0BU7gyiIxfRBXLmF7eXoCz7HivEmHdYaKN0ZI6iSt7yMZ+oG9v1D2aC9bwLsVDAbp7Oyks7OzfoSh9kvKnTt3MAyDVCrF0NAQ0Wi0IQUgf/iHf8hP//RP8+lPf5rXXnuN3/qt3+IDH/gAIyMj9PX1vePjv/rVr/IjP/Ij/Kt/9a/44Ac/yMzMDB/96Ef5sR/7Mf70T/9017dv2zZCCE6dOsWpU6f42Z/9WUZHR/njP/5jPv3pT/MLv/ALfOd3ficf+tCH+OAHP9jQQjzlHhUAlafKw97Qaz+M9/ODuVgsMjw8fN9ii0e5AiiEIJvNMjU1xeDgIIcPH27Ib/MP2wKWUnL79m0mJiZ47rnn6Ozs3PH93Wtgq51r7Orqqq+u1tq8NNJer1c7mJ9KpRgcHKRSqdTfeN94+xKfvzVPJaBjhgIELJ2i7VLyHZoDFqu2zUsdnXxtfprz7Z2Mr60SMAxKssL5pk4yXok7qxnOtnRQ9ByOR1pZc8pMFFY5FE1ydXWB0/EOUlaQr61MAPBCqg2vJBFINOHxQqyXVbvC3VKWxUoOAwHrr0tLaCxU0nQEkjSbCSpehaVymcXyXY7GmrDro9mCLK/PCD4aaaPk2xjCIqDpXMlXz/71h9qYKVXDZkKPMrE+Ms7CQEen2xhgtrRIGZvxYjV8Hg/3MFVZXP/8LirSRmBhSJ8Z9xZIaC03UQjNY8gA7XovORaYrUzRG2hD4tGkD1D282TcSfqsYwjRRkhrIu+O0WadQ7JISu9habWd1KG/tqev8X49ihXAB9l4hKGvr6/+S8rCwgK//uu/zvXr14lEIvzMz/wM3/3d3823f/u376kg5Fd/9Vf5yEc+wo/92I8B8KlPfYo///M/5zOf+Qz/8l/+y3d8/BtvvMGhQ4f4qZ/6KQAOHz7M3//7f59f+qVf2tPj3G4L++TJk/zcz/0cP/dzP8fNmzf57Gc/yyc/+UnS6TQf/ehH93Q7yoOpAKg8U2o/jF3X3dM5mMXFRa5cuUJHRwcnTpzYNkQ+ykKTlZUVisUiL7300p62Tu7nQQHQcZx6X8Vay5XdXHe3AWtjccmpU6c2nelpdFVxI/uDBQIBOjs7aWtv57/fzWIm45TtEjNrWbKeS28sxJX5DMdScQoVl4ncKi+1dDBVyJIul3hvdy+XVxbwheROPsNgNEXF87mxmuZcSzs3VxcJaDq9kQQV32Myl2XKqE73GIymuL62wMlYB81WiG9kJnClz7mmLqbWqkFr0Ewy5q/QF2qmJ5hkvLTMVDFLKhHjVqF69q/WGxCgO9jEip3jROQwvpRcz89R8isYQqMlcG9FJbAh3/SHO3B8h7LvEtFNrhWqUz/aZIK5SvVMYWegjbvlSToCfUS0GNOVcUp+kYSewBfV841JPUkoZhHwBqn4BWbcERCSZrcdR0hCWh+m5pF2J2kzj1LyM1T8LD2BPkoygCFsLBklwgvMZo89sT5w+91p2K+Nv6S88cYb/N7v/R6/8iu/QqVS4ad/+qeZnJzk9ddf5/z58zu+pm3bvPXWW/yTf/JPNv3993zP9/D1r39928+5ePEi//Sf/lO++MUv8oEPfIDFxUX++I//mO///u/f9WMql8v8+Z//OZlMht7eXq5evcrf+Tt/h9bW1vrPsGPHjvGLv/iL/OIv/uIj7fpw0KkAqDxThBAYhrHrHwq+73Pz5k2mp6c5ffo0XV1d9/3YnTZr3o1CocDQ0BCu69La2trQ8Af3D4Bra2tcunSJWCzGhQsXdr3VvNstYM/z6qPrXnnlFRKJxDuuB/fv7L+XN/pGryj+4etXubOaxdMEvmkStaL0h0NcWpzjeDLB5ewqJ8MhpotlmkyTsG5wsaOHr8xNETYMSr7D8/F2AqbOm+lZgrpOxi5yLtWDL32+sn4e8OWWTt5enaE9GKMjGGPVKXF9bYGucBRX+liazkypGhD7Qs0IV5Igwt3iGjm3RMYpogvB8npRCYCLzaFgByEtBMLnWn6K2XKBs4keSn61svhEtJubxQkADgfb8aTPkdARKr7Dtfw4nvQIaCYRvZoMBeDrZYTU6Ax2E9dDrLl5xkvzHAvrlPxqZWpbIMmyXaIjMIApPKYq1abRfcFmMo5Gqz6AI5ZZYZlEqZU1J0dQ9FMR8wghaLe6yLrjNBkpDClJWS8QlX8HId5q6Nd3N2qNoJ8WUkq6urr4zGc+A8D4+PiuiyaWl5fxPI/29vZNf9/e3s78/Py2n3Px4kV+//d/n7/1t/4W5XIZ13X50Ic+xK//+q/v+jEsLCzw8Y9/HN/3+Wf/7J/x2c9+lpWVFf7Fv/gXAO94vp9kAH+3e3pe2YrCzgLAblfoSqUS3/zmN1leXubChQsPDH97uf7DLCws8Prrr9PU1ERfX98jWc3YLqjNzs7yjW98g56eHs6ePbunc4a7WQEslUp84xvfoFwuc+HChXeEv9r9hPuHtt2GuUY/l395bYy3Z+aQOuimRiRogoScW+FIczPjpQLnkk2MlouEDQPHcZhZW2NkZZ6YbvBcopmbmTQzxRzXsou0BEK80tLNXKHI20uzpJ1qWGqxQri+5FiknYQR4usrk6TtEi8kO5ktV0e1nU120RNsptlIkjLDXHfSrHglnot3kFm/zvPxLgpuhRORHl5OHGGuVORmfpm0U+Da+vnApBHidqF6vs8UOjmvwJFQP4eDh/ARjBWXuJqfIKgLPFl93R8Jd5P3ihjoHLMOo3sRBFGk1LhevEnBK9JttTNdGV+fSzyAKwV5z6Psl+vhbyA4iKUlMLRmLEOSZ5mIliSVSFA2C4R1AZU4ohBgLZ8m5LQiXJO43kN7+Mcf+xbsVk/69rfa2gT68OHDe64I3vq986DCupGREX7qp36Kn//5n+ett97iv/23/8b4+Pietmaz2Syrq6ucP3+eH/7hH+Y3f/M3GR4ert8H5fFRK4DKM2c3AW1paYnLly/vqr9eo4pAfN/n1q1bTE1N8fzzz9PR0cHk5OQjKTDZuAJYK3CZnZ3d9xi7na4ArqysMDQ0RGdnJydOnLjvm+ajCL+NetO4ObPMX4yO4wqJh2Qplydt25xob+Kt+Tme72onYQSYtYsMRmIYYYvR9DIvd3ZiOw6LxQJvZRbwkHRqBtIIsuiUeHN5lrLncq6lnYlihpeSPaBJ3kpXt2qPJatB2RAaRa/Ci4lesnaJ67klsk6ZsG5yp1htqRIQOpOlZZrNKF2BJsqeTc71ubw2x2A0ScGrrvLFTIu5ah0Hh0JNZL0icSNGUDMYWruNT4ajkQ6m1yeAtFtJxorVwBgVYUDQFzzETHmJeXeZrJ5D+OBzb+s4YYaJmseZryziUGH+/8/en0fJld/13fjrbrXve/XerW7tuzTWaCYOmICJQ8CPT3IgcH7kAdsJnDksDoTEPk74GewHExP4+XmAcQwkOAafB4IDIYDBHg5gj8ezSt2tpSV1S93qtbpr35d76977++N2lVoaLS2pZUmm3ufoTE911ffeW/d23Xe9P5/3+9NcQQAEoYFbDBBRkuS0JWpGmT5bP0VthYTtAIrQJKVeIq6MIVBGUlSCchCjLYBewSg7uTZznKx/qtuf+7hmwT7uEvCt2IkxcJFIBEmS3qb2pdPpt6mCHXzyk5/k+eef5+d+7ucAOHz4MG63m3e+85184hOf2HZPMUClUuHbv/3b+dCHPgTA0tJSb+LHY0KPAPbw1GE74+AMw+Dq1assLi6+rQ/tXtgJBbDVajE1NYWmaZw+fbr7of0oysuddcFS4c6dO0e73eb06dMPPQXjXgqgaZosLS0xOzt7xzDprejcxHdKWdmpnsJsucYXXpumqrdBgpqmYYgC+6JhXl1d4R2Dfby+tsaJvgTFeg0dg0v5LEfDcZbKZTYaNQ7GIqh1g92+MG/mV2k3TXbZHWR1jaTspK22qTTbpMQKG6ql8h0OxpivZzjs68erKLyaW8Qgz8lQHwuNLAD7/VGmy8tEBCfDjhAZmizW8yQdJpcr1k38gC/BXM0ilEPOEEv1NBOufpyig8XmOgWthiKUCSg2DDZnMaN2j7/PEUQ1fNR1Da9s42LV6v3b5x7mWsMKfR53DVJoZxh1jmMTZC7XZwAYcw6RUq3njzt3Y9Ai084RtWnUjDI2wY5X8pLS1zFoUGyvEVcOoptLiDjwSAomGk5FJ+qMMxz/RdQ+gXw+z/r6Opqm8corr9wU5n236KKdhK7rD+3Q30lUq9WHdgHbbDZOnDjBSy+9xPvedyNQ+6WXXuK977292aZer78tQL1DjO/372/Xrl18/OMfZ9euXQBEo1FOnTp1X2v0sDPoEcAenijsRAm42WwyPT2Nqqo3ka/t4mEJYD6fZ3p6mlAoxIkTJ2764HxUETMdMvXaa68RCoU4ePDgjigXdyNYuq4zMzNDNpvl5MmTBIPBba33pKGlavzuVyepaBo6OggiLoeC2jDINOscjcWZSqc5GI1ypZCnoWn0eRzs80cwRdho1NgXDGMXZSpNjbyrQds06Xd5cTrtjKt27ILAucrmlA1dRzdNRh1+7KKMqctcKmXx2EQMTLySjdnqpsPWEUBEIqaEyDYrNJpZqoaKIoist6xZvgImDb1BRPERtwdRRIHVRpmL5Q2OBfopaFY+4D5vH5eq1wFrZJyGym7nGCYwVV7AxMQnuchpmwHOgkxaTePAjrftxTBNClqDonadPoeVWSkhohpVBu0TNPUWaXWZulElqsTIqiv02ffhEGCxdQ5FsOESnVTaYBM0BDGJXdARMHFLBgFUhtwfRZbdyLIV2eN0OrtfLvL5PMvLy8zMzNw0+9nv9z8yle5JKwHXarUdiYH5mZ/5GX74h3+YkydPcvr0aX7rt36LpaWlbkn3Ix/5CKurq3z+858HrODmf/Wv/hWf+cxn+O7v/m5SqRQf+tCHeMc73nHPlppb0YncarfbyLLMu971Lt71rncBvX6/bzZ6BLCHpw53I2idubaRSORt5Gu7EEXxgaaNbHW/7tmz57bzjB9mZu/dtru2ZsV4DA8P71i0DNy5BNxsNpmcnATg9OnTOByOba/X2eed2r+HXev3vzrNRrVKzdBQbDKZao2SpjIeC3E5m8UV8TMRCNIWTBrtNvsDfqZLBXbZ7MwWczwTSZJWa1xKZzkUiTJTynAsmMAUTaby63hkG+LmZTjm8eORZGKGjqC2eatlnbfD3hAXG9Z83oPBBKqhk2pUCDk8vJG3wpP32vxc1S3Sd9Cf4GJlhRFXlLjdx0ozx1qzhiLYWW1ZymFIcTO72ftnEyUyrTxjzn5kFJpGncVGHshzwJfA3FQFR1wRZuvz2AUb+zyjlNs1FrUUfgEWmlaJeLdrmMXWVcJylIQ9xvXmVVJqjn3uEZaaVRyCi6ASYaVVJq+lkYU8YWUUn2RnqXWehDJCwyyhmDKi2MYvOfGQYdDzcRT55lJgpwS7Na5H07RuXM+lS5fQNI1AINAlhFuDkx8WT1oJuF6v37FMez/4gR/4ga7xIpVKcfDgQb70pS8xPDwMQCqVYmlpqfv8H/mRH6FSqfAbv/Eb/OzP/iyBQIDv+I7v4D/9p//0QNs3DANZlllZWeH111+nVqvhcDjw+Xz4fD5sNhtjY2O90vAjRo8A9vDU4Xbj4Lbm3O3bt4/+/v4HvglIkoSqqvd+4ha0223Onz9PqVS662i1nSaAHRUuk7HIw8Mc9+1wuxJwoVBgcnKSWCzG/v3770sh2WkC+LD409dnmNnIoMvgstsotppoGOwKB3l9dZVDiSiLxRIJnxvThHF/kHOlLIZpEnW7SDfq6ILJYrWETRDx2uyEFRe1tsZs1SJie0NhimqTMXeIlqlyrpxFFgVElwua4BJlcq0ao6aHJiZnc6u0TB2fbOdyxVLvXJLCmlHBhsQuTwwBEafo5molh47OarMIgEdRwGoDZNgdYLWpk7SH8Ug2piuLrDU32OdNsli3FMZBR5hrmwHQIcmDYcKgfZiNVoHZ2iJ1o4kiSFRFq2RtExQUUSaiDFDQiqjmPE2jSVgOUNQyDNj3IAgmVxsXARhz9tPQvehmiw31MknlEKq5gFMIgpnFK/bjEeYZdH8Eh/L29gHTNN92fSmKQjwe785+3jrdpROcfLfpLveDJ80FvBM9gB288MILvPDCC7f93ec+97m3PfaTP/mTOzKjt3NOL1y4wM///M/zjW98A5vNRqvVotVqYZomlUqFX/qlX+LDH/7wNyWM++8regSwhycK2yEvt8bAtFotzp07R6PRuO+cu9vhfkvAlUqFyclJnE4nzz333F1vODvpMO7MMBZFkdOnT/PVr351x9XFWxXApaUlrly5ckeFczvrwZ0J4IOs96Bk8tXzi7x8ZQlTFqi3NWyihMOuYIiQbtQ4nkhwtVJANwwUUWJqY4M98TDDLg8eRebrqyt4FIXVeokT4T5sssg3UhaZ8joV7KLEwUCcbL3O9WqR/cEIlysWKTwaSnC1muNYoA+XrPBKtjPdI0KqZpG+mCmxoDdwCwqHPAlS1SJregNFlDlbtFTBQ/4klzd7/0acYa5UUgw6w4RtPnKtMplmk5K6gUcRaRnaZrm43n0PQjYHfmWElmHglkQubJaID3uHmK1bvX+jSoySWibmHsAhCszUZgHY7x5hoTlHWI4Rs/mZb8xRbDcIKApu0Uu/fZj5xjkEYLdrlEI7iiK0sIn9OMU2ohnDZV6hz/4CHtvh254jwzDuek0IgoDb7cbtdjM4OHjTdJfblYsDgcB9Ebpv1RLw44Su68iyzH/5L/+FxcVFfv/3f5+jR4/Sbrdpt9tomka9Xu+Winvk79GhRwB7eOqwlUR1+u2CwSDHjh17oJLv3da/F9bW1rh48SIjIyOMj4/fk8DslALYmbKx1XX7sGPbboeOAmgYBjMzM6TTaU6cOPHApZlHUQJ+EFxby/LHZy5RNzUqmobXbSddrdOgzWDQT6Wi0hYMBrw+HIrE66k1jsRjaBhsNBqkVFAEkePxOOezGa40s0g2a1+OReNIokiGJoZgcr1atIiXqSIhss8fRdMNqq02c3oeQ7SutaDNwVzD6hOM2zz4nF6GmjbWW1Umiyma6MjAUs1SewVMqnoduyAz7IrhV+wUtRbXakX8ioulzbX2+RJcrFgEc5+3n5yaZ697BJsgc6Eyj24aRG1e1jaNKT7JyWJzBb/sI2GLkWmmyVOj1jSwSdYc4aDkQzM14soIAjpzjcsATDjHMDDYaK2Sby9iF5wMO0a43pym3zZI06zgEVw09SxJOU3C8f8h5PqOO56n+yVgt053UVW1qw7OzMzQbre7M3ZDodA95+o+iQTwaZ+P23m/NzY2eO9738t3fud3PuY9+vuLHgHs4alDpwR87do15ufnH1iNuhO249Q1DINLly6xvr5+X1ErD0sATdNkYWGBa9eusW/fPgYGBnZs7dtBEARUVeWNN97AMAxOnz79UHM5H0UJ+H7Xqtaa/PZfnaEl6QiKSERxU2o2aYsmCZeHc+sbJH0e1LZBodWkqDV4JpHkeq1Eul5nX9CPbhigyLyaWkUzDE4mE2SadXZ5QqzVK6TqVQY9Xs7lLZfu8XASQRQoSip2Se5GwOwJhDlTsH7eF4ig6jpFVSVgs3GmaD1+MtzHZNFSFsdtPq7pBdyGzIDsQ22ZNDWJmtbmctWa1BGxublStXoL7aLMciNNwhYkJPvQDJV0q8lGa4V93hi6aV0vSYeP2XoBp2hnwj1ITiuz2NggbjPIGxYxHHVFWG4uM+oYRxZ0rtXnEYAhpx+7YGfQvovV1jWaRoPdrjEQDJpGnRX1Iv22vWjmdfxiDM1IMygXCCr/kIT7n9/1XD0sAbPZbCQSCRKJxE1zdnO5HNeuXUNRlJvcxbeq909a+bFWqz10heNxo3M+f+RHfoS/+7u/Y3p6miNHjjzmvfr7iR4B7OGJwnZInCAIpNNpRFG87bSJh8W9FMBGo8HU1BSmad531MrDxMBs7TO83XE/CgLYarXIZDLE43EOHDjwSJ3F9XqdyclJNE0jEol0b8p32+b9kn7TNPlP/+PvMG0CkihRa7VAErA7ZEK6QEVTGQ8GKeoqV9MZnh/pZy7XxhBN0vU6R6Ix1qol0q0mh+JRNMNgbzBMXWuzWCoTibtI1asARFxOIi4XdVUl1ayxVq/gkRVmN8vAIZuDtUaZ44F+NMPgTDZFy9Ctx5uW2cMj2ZitWP16McGB0+ZgwIyyWMtTFNuk1AoAerNujewABhxeLlUrjLrixO1e5utpluplfD4PczWLJI46I1yrWyQxbvNjmDBsH6aoVThXuYZm6gRkD9cbVqk5aHgxTAnVsFFp1yi0rXX2uEcQBShoDdrUaBoNEko/NaNCVksx4RzGKQxhFzXs9OMQVYJCBpc0wajvZ7Z1vnZKgbt1zq6u691y8eLiIhcvXsTr9d7kLn4SFcCHjXZ63Oj8/X/P93wPX/jCF/ixH/sxvv3bv51YLIbH48Hn8yGKIt/1Xd+1rWSBHh4cPQLYw1OFQqHA0tISkiTx3HPPPZKMrrtFtXSCpROJBPv27bvvm8ODxsBUq1UmJydxOBx37DN8kLm9d8PKygobGxv4/X4OHTq0o87iW/czn88zOTlJIpHA7/dTKBSYnZ1FVVUCgQDhcPiOJbv7Oeb/5398nYKmUVfblDWVcMBFulrFEAXCXiduU0aURaqlFu8cGuTlpSUSHg9VVWPCF6Rl6qRbTYZcbgzDZMIbwi7LTOc28MgKc5U8Ay4vI54A08V1KprKiViC2bxVjt0bjDBbznA82IdDlngts8JqtcrJaJKWYX0xGPMFOVtYRULkaChJQ9dYrpXxmgKTm/Ewh/xxZjYVv1F3kJVWFjsSCdwUShVEwcZCLU+mVaSitxCBil7tvg9OWWJcHgBTQhYNLlQsonfE38+VWmf8XIi24afcbGAXDC7VFqzXSj4ahoN++wBpdY2yXmbE0U+xnaPPPoEs1thQU+xy7GFDnSeqRGiaDYKSFw8XsYth9gQ+ta3zda8ewIeBJEldsgfcVC6+ePEiuq5jmia5XA6Hw3HPcvGjRkfBfNoVwE6o9+/93u8xOztLq9XiL//yL6nVatTrdXRdJ5PJ8MYbb3Dy5MnHFgL+9wE9AtjDE4fbEYROxMrc3ByxWAxN0x5ZQOvtFMCtLuP7DZbeig5Ju58PtfX1dc6fP8/w8DATExN3fN1OKYCGYXD58mVSqRSJRKLbX7hTuPX8dowle/fupa+vD03TiMViNzk8OyU7m81GOBwmHA4TDAbva7/++G/Oc241jd1nQ5IkBgN+is0mpihgE0VWSmVMTAbDAWRT5EI2TczlYiDg5c1UigOxKBdyaSbcXtqYXMxk2RUIMp3bQEDgeDxBptHgcj6Ly6ZQ0VRskshy3XII7wtEUds6ddVgsVqiojcxMIk53JwvWqXisOJEN0wO+frZqFeYzKeo6So2UUQTrWMVMKnoVi9exOah3xHALipcq+bwB/2cK2/GxihBrrUttXFE9rPeLLHLmSCguLlUX6auq/Q7gmQ1q6cwbvNxtbZMTAkRs4e5Xl+mqjeISj7ygkUKJ5wD2ESJplFAFA3KehlFUPBIbtLqBiFFp9ouM2DbQ0abJyjF0cwNfEISL2/iEF3s9f36ts/bN1OBu125+K233qJcLrO2ttYtF3euvccREF2v15/6HsBOtM7HP/5x3vWud/Gxj32sO0nENE3a7TaqqnaVzh75e3ToEcAennioqsr58+epVCq84x3voF6v35RRtdO4lQCqqsq5c+eo1+sP7TLu3My2ky9mmiazs7M3jZK719oPSwA7E0w6k0RSqRS1TVfqTqFDALcSzY6xZOv7fqvDU9d1CoUC+Xyeubk5ms1m1/QTDAbvqtBMza7yZ29eItrvt/L86g1U3cBuk7ELCg2zjdjWiPldnFlJcXwwgQlohs6bqRSKJOKyy4x4AsiCyVy1BIDdJnLSmaTSavH6+hotXedAOMKFkqXUnYz20dTb1Js6sihxJreZ1+j1czZvva+j3gCq4aVtmNhliTM5q/fvmWgfZwtW/92hQIKp0gqYcDw0gAnohoAsiHw9ZylzYZuLSxVrfYcok6GGQ1AYtIcRTZ12S+JSNcOAVKUuWDFHfkUho4FTtDPsjLOu2llqZAgobqq6FQjtkWRE3UvYEaWqF8g0cwRlHyuN6ww7JnCIIlfql7CLNhyijY2WRkzRCCvDOEUVgSQR8QJ2QWTc8yvY5O27WB9XCbZTLhYEgb179+J0Orvl4uvXr3PhwgV8Pl9XQeyULR81vpVMIHa7nR/8wR+8aYycIAgoivJETV/5VkaPAPbwRKNYLDI1NYXX6+2WPlVVfSTj1DrY2qfX2b7f7+f06dMP/cHUIX33ai5XVZXp6Wmazea2p5k8LAEslUpMTk4SCAQ4efIkkiQ9Emdxx1jSCfHd2kfZUUdvB0mSiEQiRCIRwFJDzp8/T71e58033+yqg53ewQ45XM+W+PQfvYIv5iZfbZCu14iFvaxXqjgdCoosYlckkj43Z9c3OJyIsVQsU2w2Cfmd7AmGiLhdfH1lBYcsYVNEgoqNQ/E4Z9Lr1DSNY8k4rYoOmJiiyTPhfvKNBhfzGUpqi7DDyYXiBgBxp5uFap5jwT5kQWQyl0I1dMJ2J1Vjc5avbONK2SKRdkFEEgRGBT9ZQSXTqrNYt3oEDwdiYImBjHgCnCtX8MlODnqT5LU6V6sZJFnmctVSGCc8MRabVuk4ioNSuUJCDKNh8mbpKiYmA44g1+rLYArsdQ9TUytkjDpxwSSj5cAUGHEmWWkJrDXT2KUGYSVOTPEzV59hyDFIzajhFGVaRosx2zUUSiSd/wGffei+rpWd7AF8EHS+qN1aLm61Wt1y8fnz5zEM4yZ3sdPp3HHlStd1ms3mUx8D0zmfL7zwAn/0R39EIpFgZGQEURS7/wRB6Cl/3wT0CGAPTxw6pGNxcZG5uTnGx8cZGRnpfiDsZJbe7dBZv1OavHX7D4OtCuCd0CFiHdK53WibhyFrq6urzMzMvO1Yd2rW7laYpsm5c+cIBAIcP378gaN7XC4XLpcLv99Pf38/xWKRXC7H1atXaTabBAIBfD4/v/wHbyK7FdqCjiHBaCJMoVFHkkXy9QYhr5OFdJF40MP+cIRqWyNTq3NquI9Ss8V6tcZS1VLijiUSFKpV5qtlrhYL1DSNQa+P6ewG+4MRok4Xr6wv0zZNTiYSXMtapdNRv58rpRz7gzEcssSb2TXONtY5Ho2jbvb+jXgDnC1YCt7BYBTVMGi2dVyKzBs5ywW8xx1irr5Z1nUHmdmcBTzg8COYIsP2OCuNEhfKKUrtBiJQ0m70/omCzpAjhltyoqMxW1sDs8GY4OueZ2fbxCv3UTBb1Iw6q3oWGxJpdZ1h+xCKaGe6egmAw54RdEwq7TKLzSsM2ffQNFaw4aAtFBiz5ZAp4lN+iD73P7zvc/woewC3s+07EVC73U4ymSSZTGKaJtVqlXw+TyaTYW5uDrvdfpO7eCcUrWrVOo9Pew9gB1/5ylf40z/9U15++WWOHz9OMBjsmnRsNhs/9VM/9UQ5sL8V0SOAPTxx0DSNc+fOUSwWbztj9lETQLjR8/cwmXe3Q+eb7Z2IWoeI7dq1675Huj2IAmgYBleuXGFtbY1jx4511bWta+4kAdzY2KDdbhOPxzl48OBD39y3fino9AYC3d7BX/7vXyPXaBD0uNDbJq22jsMh43basRsGAbeD6dQ6p0YGOLOaYm8iwkalxqm+PqZTaRrtNkf6Y5TUFhGHk7Mb67R0nX1+HzPVEkG7gxG/n5ahcyWfJ+9p0jZN/DY7F4sZHKLE/kCUlmbQVHU26lU21Cq6aZJ0ejhX2Oz9szvJtxqcCAxQa6ucL2SotlVkUSDivDFmr2lapVvBFOh3eAnbXKSbVcJ2N2/mLZJ4ItTPubLVInHIn+RSdYV+R4g+R5Dr9TQZtcKIK8yaaimMQ84Qq2qauC1ETPRxtbVMS2/Tp7tZNYqYBgyJYRqizmx9jTFXCEyB3a4xVlqrVPUaB9wDNI0hbFIbhSguoU1SmcNJDkl8J3v8P/pA59cwjMdWDuz8Ld1LgRQEAa/Xi9frZXh4GF3XKRaL5PN5FhYW3uYuftBycacV42kuAW/tfQ6Hw3zgAx9gY2ODq1evUqlUqNVqNBoNqtUqP/3TP/2Y9/ZbHz0C2MMTh86M2eeff/62btfbjYLbKXTctgCnTp16JOWW2xHYrbmCtyNi28H9kjVVVZmamkJV1TvG2exUCdg0Tebn55mfn0dRFAYGBnZM2bndMbtcLj7/51OkGwaDIwkabZX5XJGQ18b1jQx+jwNDFDFkgWN9CV5bWsWtyNgkiWpDpe5r02i32ReJ0NJ0FnJFfP12WrqOUxLRTIOjkThNvc3XVi3TxYlEnDPZdUQEjkRjlFWV2UIOU4Dzuc0oF7ebtZYV3ZJ0u/C2FXyyA0kUeT27wjwlnokmqVYtonckmGCqtDnpQ3JhF20c9g7QMtp8I7eECYQUJzNlS6G0ixKLdcvU0WcPYBdtRJQQC7WSNQ94MzbGJUuggk2Q6HMEkASR640Mbo9CizYiAopbYJA+qs0GS2KWdktnUAiiaW3CcoIWVap6jX3uCVZaCwQkL4bpRDcbBG2XcQoFVHOc04Gff+Bz+zhjWDrX/f2qULd+GblbuTgcDm87V7MzL3cnwu4fF7b+zf/O7/zOY9yTHqBHAHt4AnHkyBFkWb4jQeiMgtvpeID19XUuXLjAwMAAtVrtkX3Q3qrUNZtNpqamukHLD5rzdT8KYLlcZnJyEp/Pd9cy7E4ogLquc/78eYrFIqdOnWJycnJHJ4Hcbq2//OpF/nrqGrE+P4Io0DJN9g8nSFereB02looldoW9zObL1NQmu3xuHA47byyvMRENUVNV9ocjqOjMZfOMBANczGY4GomDrjJVzEOlwq6wpU47ZIlGu83JcJJ8s9E1hPS7PZzLW71/Ax4fM4U0+31RAjYHlyoZCq0mYbuTim71/nlkhSsVi8BJgkC13eSov59WW6dQL7FQsUrKR0IxOkc96glaBhHgWNDKFFxvVggoLt4oWBNA9npjzNet3r8xV4SmrrHPPUxL13i9eA2A3e441xurKMgc9o2w0kqzrKbZbQ9TMnSCog9ZVFjWcyRbXgp6jZiQZL25iEN04ZAF8lqag86rhKQKDSPBO4KffCgC9zgjQDpf0h52+7crF+dyOdLpNHNzczgcjpvKxXf6W6xWq489iuZhoOs6U1NTHDlyBEEQ0DTtpmPpVEc6/yRJ6kXAPGI8OQmXPfSwCYfDcdc/+s438p0yJ3TcqBcuXODQoUPs2bMH4JGVmbcStXw+zze+8Q3cbjenTp16qJDX7RLAVCrF66+/zsDAAEePHr0r0X1YBbDRaPD666/TarU4ffo0Pp/vkfQVbsXM1RSf+9JZ7A4Z2S4h20QEATTDIOixbqDHh/u5nK9wfCiJ1+6k0TY4n8kRlmV0tcV8roiAwVw+j0dR6Pd68Et2VsplZspFAA5Go6RqVU5EE5yMJpnJ5nhrY52Ay0Fr89qJuF2ICBwMxBjx+LGhcDGfpW5oFFqWe2PEF+j2Ae4LhInY3ZwIDPBsaIgrxQJnsilMTFKG5coddvu5WLZKxwHZQV3XOOIbJKEEuVLOcqawQqpRoti+0ftn0sYvuzjoHcYh2ZivFZgurSBIN65xRTDZ6x7DLnpZaKTIqCUS9gAFvUS/kCThirBsrGMTJOKBCE3BxC4a2FU3Sl2gXq+z35YiINao6F72ef89TuXh2icetwL4KCKQvF4vIyMjHD9+nHe+853daKdr167x8ssvc+bMGRYWFiiVSjf97e3kHOAXX3yR0dFRHA4HJ06c4OWXX77r81utFh/96EcZHh7Gbreza9cu/tt/+2/3tc1MJsNP/dRPIcsykiThcDiw2+3dfzabDUVRur9vNpv8xm/8BpqmPcyh9nAX9BTAHp46bNdJux00m02mp6e7btTOB+yDBjZvB6Io0m63u7mGOzXK7l4EsBMrs7y8zJEjR4jFYvdc82HIWqFQYHJyklgsxv79+7s38p0kgLeulS9W+ZX//ndokkEg4kJSBC4sbTAQD5AqVkiGvWDCxfU0p4b7mN5I02y3OdAXI+z3YmIylU6jiAK5aoVxhwtZkXll2VLYjvbFmczUGXa4sIsyumZwLZ9HE619SLjcnMulUQSRA6EomGA3FcotlYvFNCbQ5/JwvmCpgmG7kyulDAf8MVySwlK1xEazyqJQJua6URpUudHyEHY48So2FMEqWb9ZsErQJ0NJpkqWO/igP8Gl2ioOQeagr5+q3iTfUgkoTRYb1rYnPDHm62sk7SEG7GGmKwuoZptj/gEu1xZwinYGHGFmKmVaRpFSM0vCFiNm8zFTv0zCFsZms1PVqkSVAFHpCkF5laLqRcy+k2xOxgxvEAqFHriP73ETwEdtQpBl+SZne7PZ7JaLl5c3p7AEg7zyyiu4XK5uNM3D4A//8A/50Ic+xIsvvsjzzz/PZz/7Wd7znvcwMzPD0NDtXdrf//3fz8bGBv/1v/5XxsfHSafT992GUygUePXVV/nVX/1V7HY7Xq8Xj8fTPa5O5JPD4SASiTA7O8vP//zP88EPfrAXC/OI0COAPTx16Hwrb7fbt+0R3C5yuRzT09NEIpFu7EkHj9JoIooi8/Pz1Ov125pcHmbdOxFATdOYnp6m0Wjw7LPPbruR/EFLwCsrK1y6dIndu3czNDT0tlLPndZ8mJubprX5D//3lyg2VfqGAjicNrK1OhMDUdYKZXweO1NLKZ7Z1U9FU6m2NURB4PTIAG+upLDLEqYMSY+bXZEgr66skUEjKNgBiMgS9WqVqGjHIUqc2bBKqgdiMd5Kp5CA3aEgSdXDXCGPgcm5jNX7N+YMsGQJeMQ9bhpVjVF3EI9i463sKhfzGU7Gkmw0LdXuSCjOVNFyBO/zR1hvlRkTvQRcXi4V0zT0Nj7ZgS5a6ogiiiw1rPKwhIhbtrHPPcBcJUteqzG/6RyWN7mUhEjE7sakj4VaGhMT1WzjluykWzn2uUdRDY2pypy1/1IMxe4g08pzTb9Kn60Pu6yxWF9mn3cEp/l1orYcTTNI2Pkcu4ffTy6X645Ye9DMvMdJAHVd/6Zv2+Fw0NfXR19fH6ZpUqlUWFlZ4Qtf+AIXLlzA4XDwEz/xE7z73e/m27/92/H5fPe9jV/7tV/jAx/4AB/84AcB+PSnP82Xv/xlPvOZz/DJT37ybc//q7/6K7761a8yPz/fNcSNjIzc93adTifHjh3jz/7sz2g2m2iahq7r3X9bI6BkWaZUKhGLxZ6oUXzfaugRwB6eONyLBHT6Qx6UoJmmycLCAteuXWPv3r23NSQ8KgJYr9ep1+s4nU6ee+457Hb7jq19p3JtpVJhcnISj8dzX7Eyd1vzTtjqKj5+/Hi3Ef7WNR+FAviLv/Fl0pU6DreNlmnglAQkSUQ3DBIhL/PZAqfGBvjGwgr7+iIookTAbufcehpV1zk+mKCmaqyVK7y1tk7bMDjenyDfbDDgC9DQVS7n88gCNAVL/fDLCsV6jRPhOPV2m6+vrmKYJiM+f9f4Mez1cz6/QZ/Ty7DHT67ZoFTXWNRL1IwWLUPHLSlcKVskTRIE1ptlBlx+4nYPBgalhkYBlUMuBw3d2vZuf4izRcsgcsgfp2Vo9NlDyKLAqznLBbzPF+Vq3SoX7/ZEKao1DnqHAZPX8laA9GFfH5frS7hEO4e8A1yuLnOutcRur+X2HRFjrOp5GtUWh739IPiRaFNo59nr2Y2XrzHiyNI0PRjCIO8I/XsEQeh+sbnVBGGaJsFgsJvZ6HDccDnfisfZA/a45wALgoDP52P//v28/PLL/PZv/zaf+9znEASBn/u5n2N+fp7Lly+za9euba+pqipnzpzhwx/+8E2Pv/vd7+Yb3/jGbV/zv//3/+bkyZN86lOf4vd+7/dwu9183/d9Hx//+Me3bWAB6Ovr4/Of/zymadJqtWi1Wqiq2v156z9VVSmXy0QikZ769wjRI4A9PJV4UIKmaRrnz5+nXC7zjne8A7/fv6Pr3w2ZTIbp6WkURWFsbGxHyR/cXgHsjJEbGRlhfHz8vm+m96MAaprG1NRUt9/vTv2MO6kAdp7/G7/3VS4ubdCWBWweCa/HzoWlDYYSQdbyFZIRL36HnbOr6+yOhqirGjPrWQ4PxTGqcCAe5Y2lNXTT5PBAnHMbGxyJxai2VK7nS+yNSlwuWArb7oCf9WaDo74QuqFxvlQEyoy63Ribx+VxKJh1GPMG6Pd6MUyT5UqZmNPDbKmTDRjoTgbZF4owVVhnny9KzOHmSjnLUrWCM2BjrmqZQkKiwqWqRRK9so1r1Sz7PHFsosJao8R6s4KAyYjnxjVt0EZGYsITxyaKXG1mSTVX2O21yJksCDSMJgfcI2y0SpyvXKdlaOzzJjHRiChR2rpKgxbjrn5ymuX8nXCHQbcTliaJSHlqugdV8PHO4Mfedg5vNUFUKhVyuRypVIorV67gcrm66mAgELhJif9WLwHfD9rtNoODg/z6r/86AIuLi3cs2d4J2WwWXdeJx+M3PR6Px1lfX7/ta+bn5/n617+Ow+HgT/7kT8hms7zwwgvk8/n76gO02WwcOHDgvva3h0eLHgHs4anEg0TBlMtlpqamcLlc3akid8JOzdUFS8W4du0aCwsLHDhwgLW1tUfSX7iVrG2dXXz48OG3feBvF9tVAKvVKmfPnsXtdvPss8/e01iykyaQv/3GNb56dgUDSCT9+AJOMrU6E/0RFjJF+mM+phbXOTKWwOOyI9tErqysMxYJIJiQLtVwO2zopsloKIAsCETtLmRJZDaTB0yaho5TltkXipCvV8k3VGxSg3TLymYb9vmYr5URTBi222mVawQFO5ra5uU1q5erz+PtOoLDDgcXChsEbA7GPEG0tonNVLicz1H2tlhvWKVgaQv3CckKTbPNhDdGwObgTGGNC8UMJ0JJ1ptWvMshf4KZqkUqD3mTKJKITWigGgaXNh8/4Itztb5GzOZjzBVlqnwd1cxxPNDHTDVHzBYEBOZqaSZccTbaGQalPlSzQUYtcMw3xuX6Fb4z0CYiXULHRcN0csT7U/hs0bueq46q5fP5GB0dRdO07ni/y5cvo2kagUCgqw4+jjJsB49z27fDrWPghoeHH3itW0n63ZTWThj3F77whe4X5l/7tV/jn//zf85v/uZv3pcKuJ2/+57r95uHHgHs4YnDdj4AOlEw20WnJ210dJRdu3bdcxs7pQB2Qq2r1Wp3jvD6+vojI4C6rne3WavVtj1G7k7YDlnrKJtDQ0NdR+PDrHk/N4CZ2QxfeWMZUxJxeW3UdR2PAIosoeo6Y/EAZ5ZTnNrVz/TqBiGPi1pF43hfnLzaYmp1g4P9MVbKZU72JSmpTc6urBP3uDmXtkq4z/T1oZkGG6UagihwfXMiQ9zrJtWsIiIw4PMRdrpYKBVxeTzM5C2lzm+7oSD5RJFV01LoRnx+VmoVrpUKiF6Rs5tK4JFIjOnNcOhxX4jL5QwhxcWYJ0i6XEDVReZKBSTZpNZWkQSBtZY1l1jAxBAMjvgHyTYb1A2NawVrPxJO1+ZzwCPbGXf1M1/LYrCOaraJ2bxstArsdo0giyZXaguIgN/mJNd0IokGFb3BXvc4V+qX+Yd+A7d4AY0gNcNOUvnHDLtPbfu8daAoCrFYjFgshmma1Ot1crkcuVyOa9euYZomq6urmKZJKBT6pmbgPe4S8K3YCRdwJBJBkqS3qX3pdPqOXxKTyST9/f03VUv27duHaZqsrKwwMTGx7e33yN2ThR4B7OGpxHYJmq7rXLp0iY2NjfsKWN4JAtjpvesojp1elp1UF7dCFEXq9TqvvfYaTqdzR2YX360EbJom169f5+rVqxw4cIC+vr5trblTCuD1pQz/46/naBg6oiKgyyaDARczixuMDoRZLZQJ+12MR0Jc3sihGwaDIR/TqxsYgsBCvkjC68YmiVQbKqpfZy5nuWj7Q176DC+FeoOlUpmNWo2g08GFTVNH3GGn2W5zIppE1XVeWbFcwuPBYJf8jfkDzNcK2ASRXW4fZtvAbyjkylXWahVU08AuiVwr5zvvKAV1M+rF5afP6bUCtCsFhj2w2LZ+dzSY4EzB2t6RYJxrtSxHfP24ZYXX8osYmOzzRZmrWTf5vb4oy40MB70DOCUbbxTmATgR6ONidQmf7GLEFWGqvEheXSdoFwjIHsZdSabKV7AjIwvQ0gV0ypxwGwzaztA27eTbCk5pN++IvP+hz6cgCF0n6NDQELqu8+qrryJJEvPz8zeZScLhMF6v95ESiietBLwTBNBms3HixAleeukl3ve+93Uff+mll3jve99729c8//zz/NEf/RHVarX7ZXJ2dhZRFBkYGHjgfdk6aaXzedAjiN9c9AhgD08ltlMCrtfrTE1NIQgCzz333H2VKh6WAKZSKS5cuHDb3ruOUrfTqNfrpNNpRkdHt6XEbQd3KgHrus7FixfJ5XJ37aW805oPSwArlQaf/I2XaOkGoiQQCLsJxzzkag3GByNcWstwcDjOmYUUB0aiDDl8OGwKry6s4HXYqGotjiRiSIrEmZUUNklkvVZjJOCn3+flTGqdZrvNsYEE85tqyUjIT7HVxGmAaupcyVjEbU/sRtaduFmzDdgdDHi9uBWFq8UCdrudqaxV/j0SiTBVtPr6BiUb19QGCgJHgnEMSaSpGoiCxNc2rBDnsN3JhaL1WockMVfN4JYUxj0R2oZJXTU420qxy+fH2IyHNjZjYxIOHwHZxappZ6qwxqjXOk8OUaagVTjgGaakNThTWsDA5IhvAEMwWahnud5cxS4oDBHgqrbOAc8Qfukiw44Fym0XDdONJIT59tDNhoKdgiRJCILA4OAggUCAZrNJLpfrRqQIgtDtHQyFQjveU/skloD7+/sfep2f+Zmf4Yd/+Ic5efIkp0+f5rd+67dYWlrix3/8xwH4yEc+wurqKp///OcB+KEf+iE+/vGP86M/+qP8wi/8Atlslp/7uZ/j/e9//319pnbQKTdvfW97xO/xoEcAe3jisBMl4HQ6zfnz50kmk+zdu/e+P8gflKQZhsHs7CwrKyt3zNrb6YzBTo/h+vo6fr+f3bt379jat1MAm81md1ze6dOn7+rivB0elgDqus7P/8qXyDUamIKJLEs0TB0DsCkytZbGocEEb8yvsq8vTK2psVGuIdgE+v0eBsJ+3lhcI+x2Umi3kASBk4N9bFRrXMsVUGSJZruNW1GYKxRIuj2MBHwsVkqsVaoMelwsNeoA7ImEubyp+B2MRLHLMrt9QUwTvray2fvn9nQdwQGbnSsVS2WM2l1EfH7khoPr1TLL5QIbujUCbq/tBqEe9QU4k1/DhchRf5yS0WZ20zF8rmiR04OBKJeqFknc443gFCXGXAkkAV7LW0TycCDJ5doqYdnNHl+cydIi1+tlDvljGKrJhDvJmlpmo1XkhL+futHAL/tZaa3QJ0VROM8h1zS6KdIkDjg47vsJnIr3gc/lvbC1DOtwOOjv76e/vx/DMCiXy+Tz+W57h8fj6aqDfr//ocnbk1gC3ok5wD/wAz9ALpfjF3/xF0mlUhw8eJAvfelL3Z7CVCrF0tJS9/kej4eXXnqJn/zJn+TkyZOEw2G+//u/n0984hP3ve3Oe5rL5fjbv/1bVldXEUWRoaEh9u/ff1/l5B4eHj0C2MNTiTspdKZpMjc3x+Li4n2VJW+3/v2StFarxfT0dHe27p3KNTtZAm63211X8/DwMI1GY0fW7eBWBbBYLDI5OUk4HObAgQMPVCJ7WAL4S/+/L7OSK2FKAqYBTafIQMDFlZUMuwYjrG7kqagtjg0nSFWqpEpVnhnvo6nqVFot3lhcwzBN+sM+BkzI1xpMrW1Q1zQOJqKcz2RwKwrH+hOkqlWu5gpEPU7WKpvGjE2VTzAh4LBzMppkvVpD1XUuZC1lb3/shhki7nGz1qxYE0GiMZrtNpl6nYjLyevpzSzBcISLJeu1SbuTKzWLJIZEmVajxYQzzGKtyEwlR1FrIQJZtdbdRsvUGHGFCMguGkaLqU3FcI/PcvuKgCTAAc8gC7U8F8ortIw2u9xhqu0mY84+nJLEfKOIX3YCItdqGQ5548TNCCPOFLs8i6iGn6php41Ev/3dDLkPP/B53A5M07wtCRNFkUAgQCAQYGxsDFVVu1EzFy9eRNf1B5q3uxU7ETS/k9gpAgjwwgsv8MILL9z2d5/73Ofe9tjevXt56aWXHmqbnXP59a9/nY9+9KOcOXMGu93e7f3s6+vjox/9KD/6oz+KKIpomnbXkaA9PDx6BLCHpxK3I4CqqjI9PU2z2ewaLnZy/buhWCwyNTVFIBC462xduDEJ5GFRq9WYnJzEbrdz+vRp1tfXqdVq937hfWArWVtbW+PixYuMj48zMjLywB/MD0MAP/M7f8OFaykEWUBv69gDNkJRNy1VZ7Q/xNRCilN7B7iwnCYeEKirGqd3DfDG9TXahsFIIkjY7WQ8EmJqbZ2G1ubIcIKFSglRALsicyQeI12p8cbqGq22zkjQz/lNQ8iecJim2mKfx4/b5eL1Fcu8sTcS4lIhB8BoIMCFnEXmBjweBBOOBuOk63XObqSot9vIokDdULvH1TRvXA+jwTD97QDZRh2fLHNuM/pll+xgXrOUx4PBKBcqG0RtLnZ7oyw1iizXS+zxSVytW9vu9AGOu2PE7R5eLcxjAs+E+jhXWSIkuwkpLqZKS4RtbVbVCmPOJH5F4VxlgQl3HNU0cdiWOOJ7Ax2ZrBZBFyRs4h6eD//wA53D+0HHgXov2Gw2EokEiUSiO283n8/fNG+34ywOBALbMpM8iQrgTo2C+2ajU/a9evUq/+bf/BsEQeDXf/3X2bdvX9eU8gd/8Af82I/9GHa7neeee44vfvGL/JN/8k84ePDg4979b1n0CGAPTxy284F/K0ErFApMTU0RDAY5duzYQ7sFJUna9gzK5eVlLl++vG1iJEkSqqre9Tn3Qsd5OzAwwO7duxFF8ZGYSzprXrlyheXlZY4ePUo0eveoj3vhbgQwl8uRyWRuW8b7338xyctnFmmLJi3DwOOyodtEDNPEbpPIVRq8Y2KAV+dWSAa9CALomsFKqULbMDg2nKBtGCzniqzZKjS0NoNBH0uFEieSCWyKxKtLVrDykYE4a+sWmXbYJfYoYVyyQkVTWSxbj4/KN85zW9hsYjch4fYQcrgoNpt47TYmN6wy7clkgrWMFddyOBLjbM56fF8wgijAiWCSRrvNq6lVDEx8io20Zp1PWRTIYl0zLkS0co1+3KzUGnjlMst1ywncEaxsgkjY5qLejjBXyVE3mpiAT7GTahU45BlCM9ucLVnl4RF3gJbho6hVWW2tMupIopoNBH2BdwbmyWsOdMFDGwmTKN8d/pmHuAK2jwchYZ15u16vl+HhYdrtNsVikVwux9zcHM1mk0Ag0FUH3W73bf9mnzQTSL1ef6gvtY8THQL4m7/5m0QiEX77t3/7bQaS7/3e72ViYoIXX3yRn/zJn+Rf/It/8VAmkx7ujR4B7OGphCzLtFotTNNkcXGRubk5JiYmGB4e3pGSQWcY+d3QcRin0+k7Tr24HR6GqG2dYnJriftREMAOyd7Y2LivEXJ3w+0I4NbzGA6Hu2W8zk169lqJP/zzSVoYaKaJQxLRHCIOh8xStsLesQSVXJnZdo5DAzHq7TZnF1IcGU1QqDc52h9nPluk2GhyZCjB1No6u6NhvC4baysbXGnlkGwW0Rjwezm3kWZ3KETM7eJCJkux2eRAPMJc3irN7vJ7uFosArAvEkYURY5HkrQNg1dXLBKZcLu5vtnv51EUZgo3Jn3UdY3j4SRqW0c1dC7lLfXwaDzeNXLsCYV5azMe5mgoQaFYpM8VxCZLnCtZ5HHY7ma+bm1j0OYmV69yxNuPicnXsxa5OxZMcKGyikeyc9jXx1RpmbX6Krt9fgRT4LBvkNnqOlW9xRF/nLgwgiQaNNrX+L74BTCblNsxWqadtunmtO/9uJTtm34eFFtdog+DW+ft1uv1brn4+vXrSJLUvc62zi3Wdf2hRk3uNKrV6h3D1Z8WfP3rX+f9738/AwMD3fPb+TwQRZGf/dmf5fOf/zzvfve7+eVf/uX7Mpf1cP/oEcAenkjcq0zYUeimp6cpFAo7OlMX7k2mGo0GU1NTgGWEuJ8eowclau12mwsXLlAsFm/rvN1pAtgpMQOcOnVqx1yWt55bwzCYmZkhk8lw8uRJnE4ngiBQrVbJ5XK88cZl/t8/n6MtgAGIsohol+gfCLGRL9EX8XDm6hqn9g2QKlQRBZGrG3mGw35UTWcxUyQwmqDYaOKxydgkkQGvF1kQeGvJ6sE7lIhxdm2d4YCfgYCXhtbmajqPHjMpbn4RKGsd1dZEEOBELEFDa6PqOlezFoHbH7+hjiZ8HlJpq29wbyRMVVVxy3bsssgr61aMy+5giNmy9dq4y835vFVqdskya/UKx4IWSVypVljXGqA12LXlvLvcDqRKjT3uMIKpM1OvsdFKMWizjDmSALV2kyO+QVKNMmeLSzSNNof9cVpmk6QjSguVqt5ijydOsd2kqFU57DM4Fpilpjtotd3UsSEIMknbtzHuPb4j18G90LlGdroM63K5cLlcXRJSKpVuO7e41Wo9MYSr0yf3tCqAHdTrdQKBQPf/O+e202vs9XpptVr89E//NH6//7GOAvz7gB4B7OGpRLvdJp/P4/f7d3ymLty9BzCXyzE1NUU8Hmf//v33fYN6kIiZer3O5OQkiqLccYrJThLAbDbL9PQ0iUSCer2+46Wwzs1dVVWmpqZot9s8++yzKIpCs9lEEARcLheNusFf/s0aSDK6odOQQDHayA6ZarWGLAmkSnWe3TPAa3Mr+F0OZJvIgb4ogixwfiVNf9hHqlzl+EACQRR48/oaogjG5iElfR5EQWDQ60URRF65bpGz/Ylo19RxKBGlqmmcTCTQWi2mCwUoVtkXDXO1YClwo8EAFzefH3O5SNdqHI8mwICruQLFVgtBsLbXgSzduLn1e70INeh3+3DKMq9sLLNaqXIsEme9vEkk/SGubPYEHvTHsIsybsFB0zCZb1ixNHt9YebqGQKinT7TztVqCY0Chz1hss02IcWFLEpcLBWY8ES4VtvggGeImllhtZnn20IhDnr+GK+kUWw7qZt2TCQQxvjO2L/c0evgbtiqED0qiKJIMBi87dziYrFIqVSiUqlsa27xo8bT3APYwcGDB3nppZf4wR/8wbd9boqiyJtvvondbu9+ue2Rv0eLHgHs4alDKpVifn4eRVE4efLkI2nUvh1J2xp8vHfvXgYHBx9o7fslah3C2dfXx549e+54vDuRr7e1FLt//37i8TjLy8s7OrqtEy3TGR/n9Xo5duwYgiB0s9es3zf4xV/+C8rNJpphYMgCTgyUoAuby85qrkY8ZIe2weXVDUJOO4MxP1OLG4z3hbmykmMkHCDkczC1tIFkwkbdMlEcGUigmQY+xYbdLnNmUwkc38z0EwSotlX2RcK4JYVso8FiscSiAFHPDbW3tcW84bHb2B+K4JJkREnkjfU11spVTiQSFFstAA7FYkznLIfumD/A5UKO3f4QIbuT1VqF9WqNQqOJ0y5jYCIAWbXe3YZNEjkR6ifXaGBgciZrlYj7vR7YNID7bQ4OSf3MlNIUXAZayyAg2Vhu5hkyvMi6yFTJIrl+xUbbjGCgs9Es8Kw/Rp/9z9FNNxuqTssM0DY1mkaIH0z85I5dA9vBTpWA7wdb5xa3Wq1uH+p25hY/atRqtadWAeycw3/zb/4N3/M938OHP/xh3v/+99PX14csyzQaDTKZDC+88AL/4B/8g/uecdzDg6FHAHt4InE7MtMxI6yurjIyMkImk3lkN4dbCeC9yq/3g+1mDG4lY/v27btnQ/TDKoBbS7HPPPMMgUCgu587SQDBupm99tprDA0NMT4+jmma3dgNWZZRVZX/65N/Sa5SQ8MqZWptHZvHRrwvSLHeYnQwzPnFNLv7vIiSQr3VYnJxA1EA0WgzGvThtiucWbT65XweB7JNIupxcS1XoFBvMhjycSVvKWf7EhGu5vIciEUJuRxMpTZYaqkc6Y+zWLRMFgeTMaY3HcH74xGKrQYn4klsosjZjXVauk7UZeULwmZwc2nrpI8mfpudUW8Al6KQrTeYzRU4kbSzXC1b24hEeStnEdLD4Rjz1QLHgkma5QoXCzl002SXL8DMZmzMLm+QK+UMB3wJ/Iqdb2z2/h0PJzhXXkURRA4F+7hQTrFk1InKCrImMoaXqeIaogBOwUvS5uSI70sE5AKaYadqhDAFg5rm5qjjPQTuMed3p/HNUADvBtM0cbvdJBKJm+YW53K5284tdrlcj2xfNU1DVdUdi4F5XHj22Wf5yEc+wic+8Qn+9E//lCNHjuD1eslkMvz1X/81fX19/MIv/MJTS3SfNvQIYA9PBZrNJlNTU+i6znPPPUej0XjbPMudxFaS1umFs9lsnD59+qHLzdvJGNR1nQsXLpDP57tkbDv7/KAEsNVqMTk5iWEYN4U7d25oO1Va7vQylUolDh06RDKZRNf1rtuzs71P/tJfsJQu0sJElqAqgiyJOEMuBAG8ToVLyxn29wW4lqtgYOL3OznQF8VhE3lrcQNFErDVayiiwN54gFJDZSlftgKg61Zfn9OhINcEJsJh7LKMjMhsOkvI46LSUpElgbWK5dwVBSipLca9XmwI6G2DtWKNtWKN/fEIrc3rZSDgJ522rs0DsShnNtYZ9wfp83hZrVWoNjTyUoPp+gYm4LfZmclbZE4WBRZrJbyywrg3jAA0VZ2zmXUGbTb0TSLu2jQq+BUHfW4f1bbG+XyavUFLwZQFgaxa4Yivn5qm8kZ+Cc3UORFK0jQ0ROzUFR2jZXLYGWNZW+V9ibPoukleD1I2fQiiSEO3IzYGOBh5fkfO//2gYwx4XATwVhfwveYW22y2myaT7OTc4urm/OmnnQAC/Nt/+2/ZtWsXX/ziF7l69Sq1Wg273c6//tf/mv/4H//jjvZy93B39AhgD088tvbcdXKjVFV9JOPUOuiQtHQ6zblz5xgcHGRiYmJHFMftGEwmJycRRfG++hsflACWy2XOnj1LMBjk4MGDN930OjffnVAADcPg0qVLlMtlkskkiUTituTv//n0l7l0PYMpgGJCUzdQZAFZFlEFk8WNIiMDISIuJxvlGi1V55k9fSznK6RLNUqqpb4dG+2joWnMr+dJletk6y38dplzaxtIAhzpt8rANlNCkSTOrlik7ehggsm1zQkbyTgb1SrHkwlcNpk3VlKous6o38O1nKXsjQT83d6/kNPBhWyGqNPJoMePrpt4JRvX8kUMYL60GfDscrJUtxS/iXCItzJrBG0ODoZj5JoNZmt5NJfBhU1TyLg/yLWatb1htw/NMDjiT1Jpq7y8OTJurz/MbCWDhMip8ADztRxnqylORhJoTZ2w4kI3YKaU4UQoyfVGmsPeIdbUJb43cZZ+VwbNgPVWgjYtNFWh0Y5wtPAP0RLbi0TaSWw3A/BRbv9u7Ra3zi0uFovk8/mb5hZ31MGHnVvcyfd82nsAO3jf+97H+973PjRNQ9f1x9pb+fcZPQLYwxOJTgl4fn6e+fn5t5VAZVnekTDlO0EUxe5kj0OHDpFIJHZ07TsRtXw+fxPZvR/C+SAEcH19nfPnz7Nr1y5GR0ffdpMSBOGO84DvB5qmMTU1haqqxONxbDZbl8BvJX+f/+9f57Wz12mbBqoIsgSibiKoJrGxKOWmykh/mKmrKYajTtw2F30RB2fm12kbBnsGwwQNB26HjcnrKTTd4PBInKnVDQQTxuNhKo0Gy4Uqy9kcmaaGLAqslC0yZpckVkol9kTD+Gw2Nqo1UsUqG+UqUa8bdXOfm+aNLx9uh4KjLrErGCTscnEtX2C1XGHI42dqw+r32xcJd2Ng+jwezm2Ohht0+5AQGXeHWSgXuVoskKpbas/W/kKHIuFDYjwQAwnObpaIj0SisNkiqEgixwL9rFUrXKvl2GhWSTo9zFbSHPUPIolwtriEXZSQBJCxoYgq/zR+Fr8ssNHyghCiDsiCSN30c1r8P2jpBhcuXMDpdBIOhwmHwwQCgUfem/e4g5jvZxawJEnd92ZiYuKmucWLi4uIothVBsPh8H3Hy9RqNVwu1xOVS7gTUBSlG7vTwzcfPQLYwxMJTdOYnJykWq1y6tQpfD7fTb/v9Og9ipgAVVW5cuUKuq7z/PPP73g/yp0MJktLS8zOzj6wweR+iJppmly9epXFxcU7zizu4HbzgO8HtVqNM2fO4PF4eMc73sHs7CzZbBaXy0U0Gu3eDP/8T8/yV399ERWDBiYCJpoBqiwQCrhwOW0odpmpaymSPoW2IHN9o8Ron4ggwDMTfawVqqzmy+wZiKDpBh6HQrHR4Fh/HNM0ObNkEbJDgzHOpSwSNhJws1ytMeZ24Xc7uFwoky3nODaYYKloEcPDyTiT65vmjYCX+WqFXYEAMbebXKOBrkGqWONqvkBL15FFgaXNnj6ANtZ5sYkiuwJBEpqHtUqFuMvD62ubWX+xGFP5zRFuoRCXy1ncssLBYIyS1qTcNlivV1lXLYI45PFxvriBX7FzwB/nYilNSWtyPJJgurQKJkx4w1ypGFwqpXEo4BQVjgf7eb04T8Lu4qDv6ww6V2ibCtVWgqap4RRlcpqb3Z7neS7+bXxt7WscOnQITdPI5XJcunSJdrv90KPW7oU7jYH7ZuFhgqC3M7e4ow5uZ25xhwD2XLE97CR6BLCHJxJXrlwB4LnnnrvtN8TOB/NOp/WXy2UmJye7+V+Pohn5VqVO13VmZmbIZrMPlWe4XQWw3W5z7tw5KpUKp06duucxPoy7uFO+HxgYYGJiAtM0GRwcRJZlVlZWmJmZwefzsbLU4I//1yU0TBDAIQtoDY2GS8IpymgOmfm1PD6vQp/PjuJ2cj1d5MiuJIIIIVeLxWyJdKnG3v4I1zIFjgwmsNsk3phfZYkyw4kAAIosslapEnW7GAz6qGkaba1G2lRZb7VotHVsIsxmNoObRYHVapWEx0PS67by4UyJhUwRl6Iwu1kKHg0HOLNuKXMH4zEmMxaZOxCJYJdlDgSilJotXl1bpW0Y2CWJeqmj8pnkVMvGaxclYk43dlHmSiFHU29zuWhlBUbdLtZUqydx0O0j4nBzMZ+moDUoaU0kQWC9VWKPJ4pTUng1t4humjwT7qOua1S1FjPVNRRE/mnyHKKwTrkdp6Yb1HGimxrlthOnNMA/jf2AtWemiaIoBIPBbv9brVYjl8t1R6111MGddMc+TQrg3bATc4u/FSJgenjy0COAPTyR2L9//117gDoN1u12e8cIYGfW7djYGH19fXz1q199JDehrUSt2Wx2w5a3mi8edF3grqpovV7n7NmzXUPLdkpRD1oCXlpa4sqVK+zbt4/+/v5uv5/L5WJ8fJzx8XFarRavvjLDH//Pt6gbOoZpYCgipi4i2UUCLju+gQC5co2Y38ZcusrBsTjXsyWeGe/ncipLudHi2HiSs9dTDIV9uB02FEEkV6mT2jRwHByKc25tgz6/h9FIgOVihaV8if6AlysbFrna3Rfh7OrmeLZklNlsnlG3C6dgkmqoFFSNgKJwOV8EYDDg40La6v3z2W1c2uwD9NkUHLLMiUiC1XIZwzA5m7LWPd4XZyW96faNRnlr0yxyKBpHECAUdNLSdV5eXQag3+3phkMHRJlLxQyHA3HsosyrG9bIuAlfiEubjuCTYasv8FIxw/FoDN00CckO2qbBTDnNO8J9rLc03hNfYsA5A4istwJUDRdQQ8ePQZB/Fv3gTf2fW68nQRDweDx4PJ7uqLVb3bHBYPAmd+yD4EnuAXwY3M/c4mAwiCRJVKvVO46su1+8+OKL/Mqv/AqpVIoDBw7w6U9/mne+8533fN0rr7zCt33bt3Hw4MFuCH4PTzd6BLCHJxKSJN1Vder0pu2EEcQwDC5fvkwqlerOuu3MAX6UBLDT7xeNRjlw4MBDb6fz+jupoh01LplMsnfv3m1v735LwFvfz5MnT+L3+29r9gBYXSny+f/+FhqWy9cQJSqiidxooYVchGNOJFPHaxOY3agS9buQJJFWU6PRblNutIgF3Bimya5IEJ/HwVvzVkl1IOZHL5kk/R5cNoUhv59CvcH0appqSyXocnA5bZE/v9POpXSWsaCfkNNJsdlCbRmsaA38bgcF1boeCpvN+ABORcQE7JLIkUSMutamUG/gczh4fXOm8GgwwKWctY2gw8GF3A23b67Z4HgkTls3qKka1zYNIodiN+JWoh4XK60ycYebiA7rosF0Ns3x2I2RcTZFYMwdwi3ZWKyV2GhWGXT7uFja4Kh/AEWCt4rLBBXry8WE+zwxxzolLYYstikZQQQMJMFLue3kWe+7ibvi3X24VylWlmWi0SjRaLSrDubzeTKZzE2EptM7uN0vbI9TATRNE9M0H3nP3d3mFs/OzlKtVvnP//k/MzIygtPpfOiWlz/8wz/kQx/6EC+++CLPP/88n/3sZ3nPe97DzMzMXbP3SqUS//Jf/kv+0T/6R2xs9rX28PSjRwB7eCohCMIDTdS4Fc1mk+npadrtNqdPn+6qFZ0Pfl3XdzTOYevab731Fnv27GFoaGhHvtnfjQB21LgH6S+8HwWwY/ZotVo8++yzOJ3O25o9ADLpMr/yS39BU2tjGiaGLNA2Ddw6NGM+xvqDpIoVmmoNm1NmLOxElyUmr6aYGAyzVihzfCRJQ28zPb9O0ONkdVPxOzAQxabIjIQCBL1OXr9mBR8fG01ydtkq0w7HAlzPFtkbDeNy2Di/tsH1TInAoIOrWYuMHUnEmNq4kft3MZNFBAZdDsyWxoBso9LWObOSotHWrUkf/hvXpNOugLVLjIUCZBo1Yg43TkXhlbVlFs0Se8PhLvkb9Hq7zt+Y04lgCuz3Rsk26lxu19ExSbjcnC9YzzkcjNE2TK6Vc5yIxNmoWP2BI14/Sl1ivlJAE5t4ZTt7vDGq+qv8H/0XAZNq28OGFkAUDEQTcm0HYWmM74h9Z3f/O0Rou9fnVnVwaGioqw7m83muXLmCqqo3lTvvpg4+zh7ArdfsNxO3zi3OZrN853d+J1/60peYnp6mv7+f7/7u7+Yf/+N/zPd93/fdd+/lr/3ar/GBD3yAD37wgwB8+tOf5stf/jKf+cxn+OQnP3nH1/3Yj/0YP/RDP4QkSfyv//W/Hvj4eniy0COAPTyR2M4NR5Kkh3ICFwoFpqamCIfDHDhw4G3xJzulMG5FJ8wa4OjRo3c1X9wvthLArdu7dOkS6+vrnDhxglAo9EDrbkcBrNVqnD17FpfLxalTp256/zrvZweVcp1f+MgfUyjXaZompl1CbKm0nAojoxEku0yx0aDeUNk7GmF2tYASdHBtvUDUrdCq1yiVWlScdeYyVkjzcDyAbpq0VI1CvcnaagWv005mc/pH1OfiwtoGY5EgUbeLdKVGqdJk1RQpaS1UXcfrsHMla/X0KZLISqWCCAwF/PjsNvaFwyzkCtgUhbnSZnk5FuL8Zh/gsNPBwiYJHfT5WCyVOByJ4ZRkrheLpGt1VoQKCb+lWgIYWy71sMuJ22bDJclIksibG5aaeTweI5231Md+j4eY4aKh6eiYzBQzSILAWrNMzO5m3BvhlfQiJvBMNEFT12jpBqvNC3xP3yJ5NYxp1qiZMRpmA5sgUdD9iHj4F8n/86Zz2jnvD/oF5VZ1sJOdl81muXr16m3LnR08TgXwcUwhuR0ikQj/7t/9O9xuN/F4nJ/7uZ/jr/7qr/jUpz7Fe97znvsigKqqcubMGT784Q/f9Pi73/1uvvGNb9zxdb/7u7/LtWvX+P3f/30+8YlPPPCx9PDkoUcAe3hqIcvyAxG0rY7b3bt331aBEwRh2xM7toutYcvA25zND4tbQ5s7c3Y1TeO55557YKfmdhTAfD7P5OQk/f397N69G8MwblvyBWg2NT727/4nhUodHRAUAbHRouKxc3hfHzNLaYb7vciCzsRQhOmFDB6nDYfTzu5ECLfbzuRCCkUWSFdqJD02/C47Fxc3UHWDo2MJLm/29Y0lQ1xaS3OwP4rP6WBmLcPCegHPsI2FbBGA/oiPzGYG4HgixNmlFMMhP8MhP7l6g2azjUtWeG3RImMRh8LVTfLnlGWub6puAIZNZkh24zDA1DQaDZULjTRHEzHSNYuI3jQOLhjkSj7H7kCQqNPN5UKWfLNJyOGgaqoABOwOLpay2BA5Gk6wXC2TqlcZ9fm5umkOORqOIyBwPr9B1dXCBCI2F7phcqGY4Xg4TsgBQ64sRdVGxUyQabfxS3bKbQ+qIfOu4PcQsAduOlcPSwC34tbsvFvLnaqq3jRZQ9f1xxoCDY+fAHZQq9Xw+/28613v4l3vetcDrZHNZtF1nXg8ftPj8Xj8jqH6c3NzfPjDH+bll1/e8UpID48fvTPaw1OLBykB67rOxYsXyeVy93Tcbmdix3ZRLBaZnJzsqo1//dd/vWNrd7A1s69SqXD27Fl8Ph/Hjx9/qA/ve7mAO9EWe/fuZWBg4I79fgDtts7/92f/gFS2hGaaSDYRra2j+F0cHI9xfmGdwZib9Xwd3RQotSscGIkj20SmrqZIRLws5IqEvE72DEa5upZjo1xDtNlQdQOHLHBpLY3HJjEcDqA2NWhDpa4ys5bFME2GIn7Or1gELOn3cH5tg6TPQ7/fS0vVCdjsbBQqVFWVXM1y5jaNG9eZz66Q2ewR3RMLUWi2mAgGcMoKZ9c3aLTbJLxu0s0mBmATBa7kst3X55o1RAR2B0OEXS5KjRZXc0W8STv5pjWhZDQY4K2MVareFw7Tare5mE2jY3ZzAr0OO46WxEF/nLVambVGhRGvnwuldQ77E9hkkTOFFYZcfmRBQjdylDQ3NT1AQ1AJKDL1tkLLtBOVJ/iHt5n2sZME8FZsLXd21MF8Pt+drCFJEqIoks1m36YOPmp0HMBPSuzKTrqAbz2mO5X4dV3nh37oh/iFX/gFdu/evSPb7uHJQo8A9vDU4n4JYL1eZ2pqClEUt+W43YkeQ7hBkCYmJhgeHu6qiztNAMFSLDrN96Ojo+zateuhb2J3KgGbpsnly5dZW1vj+PHjBIPBu5I/wzD4+L//I5bWS1bci2FQNCAWclHGRDV1En4HpWabcl3jHYeGuL5eQGvrXFjaQBBgKB4g4HVRqjV4c3bFCnrelWBqcZ2Q28newQjrhQrXMyWq9QaLJUt1k0SzW3J1O2wE3Q4GAwHcThlt3WA9XyXp83J+1eqtOzac4MymI3h/MsrFTbdvyK5gyjZO9vnRdYPlYoVsrc4iMBYJ0NhsSYj73KQaFlE7mIhzZmMdlyyzy+Oh1mrh0EUK5RpX8nlMbkwQAfAqNq6W8hwNJ9B1g+lMmnpbwy2KXNjs/Rvy+LEh4RBs6BisNSxFMuly41EUNho1cnqFoOIk4nDxVmGFnz84z0YzQBUXYCIKCkXdjmy6+T+Hf/i25/5REsCt2KoODg4Oous6c3Nz5PN55ubmaDabXXWw0zv4KPfpcUfQ3IparfbQY+AikQiSJL1N7Uun029TBQEqlQpvvfUWk5OT/MRP/ARgvS+maSLLMl/5ylf4ju/4jofapx4eL3oEsIcnEtv5cL+faSDZbJbp6en7csA+LAHc6oY9fvw44XC4+7tHQQA7Dfuzs7McPnx4x6aX3K4E3G63mZ6epl6vc+rUKVwu1x3NHh186j/8MdcWMpiYSAJossBwX4B0o8WukQjnZtcZGfLhczoZ6Zd57eISdkVCtkscHUui2GRev2SZOSaGI2jFCgG3HZsksTsWoq62eX1uBd0w2ZUIcTWzOaot4mOlUGHAbcdrk8gVKxSqTTxKnXOrZYuAuR1c2AyGtskSCwWrr1ASBBySyLjbCYKE3+/l7EqK6xQ5Npgku1nW3RMLc3nT7Rt2ObiYscjcoMeLjMgef4hr+SINj8B83VIVh91ONkrW2LqQKJIzdEbdPgYCfibT60xvbHAymaTettTGhM3GmqnyTLiPtmDwViaFKMB6U8QuSpyM9HMmt0LL0DkejRMxHEiCyFRpje+I5zDQaIoqdsHANCWWm05sosJ3R96LW7m9utQhgN9sMiRJEk6nE7/fz4EDB26auzs/P4/NZrupd3Cny5M7nS/6sKjVal1jyIPCZrNx4sQJXnrpJd73vvd1H3/ppZd473vf+7bn+3w+zp8/f9NjL774In/zN3/DF7/4RUZHRx9qf3p4/OgRwB6eWmyHoG0dJ7d//376+/t3dP07odVqMTU19TZ38U6sfTu0220uXLiAYRiPZHTdVgWwkyVot9s5depU14zTKUHfjvz935/4My5eTqGZBg0TbBL4E37cYQ9DhoPpK+uMDwWpqjob+QKiUyYW9DDaH2T66jrFUgNTsdbdPxJDlAT29kVwOhTemrMiV/YMR1kpWRl7hmAyFPYTdrvQMRAKVdbKLYZiPtKbEzqMdovOUQ2EfUyvprFJEieHkjR1nbjLhWCaTC5b5eKY1831zRnBiiRyvVjc8iZZ/wk5nByMRyk3WywVy0Rcbt5YtUq546EAcwXL7Rt3u5ktWyRzwO3B43QQa+usVSqsN6o0DAO7JHKlZJWOQzY7oiEgmTLrtRqrLesYjkbiGKaJoQuUtQYtQ2fA5UVA5EJhnf3hEId8SY6Fvs5yK0QbP029TaXtwC7ZiMn7eDZ04o7n/pulAN4OW3MAXS4XLperqw52egevXr16kzoYCoV2JC9vp0Kgdwo7oQAC/MzP/Aw//MM/zMmTJzl9+jS/9Vu/xdLSEj/+4z8OwEc+8hFWV1f5/Oc/jyiKHDx48KbXx2IxHA7H2x7v4elEjwD28NTiXiTq1okX92u6eFCVrlQqMTk5SSAQ4MSJE7dVJ3ZSAWw0GkxOTiJJEg6HY8fHcm1VAAuFAmfPniWZTLJnzx5M0+w269/phvlfPvWXvPXGddqiiQrYFBFHxIPN42R5NY/TLTDaFyBfV8kWazxzeIhKvUW9qfHGpRUMw+Tg7gSNVpuxeJCVQoVMqUYy7GWuE+I8EOF6usCBgSgBt5PLa1lylTr+YTvnVyxlb99AlIspS5kbjQaZzxdwKRJxp41qsUzSbqfU0phJZSg2LGUu7rkRlN0X9LKxajlxD/TFOLu2jt9uZyISwsRkyOOj3GzxxtIazXYbQQDFfkNFUpQbP48EffS3PeQaDcJuJ2fSFsk8kYx3w6FHnC7yWpO47MauKFyoFQHYFQqw3Cox7g3S0HQul7Ls8gW4UEqzxxfBpcicza1xIBDBKSoUWyuYYgObJGLqVZpGBB0JQQ/ygdEfvOu5f9wE8HbX1Na5u8BNvYPz8/MoitL9/YOqg09aCbher+8IAfyBH/gBcrkcv/iLv0gqleLgwYN86UtfYnh4GIBUKsXS0tJDb6eHpwM9AtjDE4ntxsDciQBWq1UmJydxOBzbnnhxP+vfCZ1pIrt27WJ0dPSOx7FTBLBQKDA5OUksFmP//v288sorj8RcYppmt5dxz549XSXmTv1+Hfzeb77EN16epS1ZJNLpVkiMxWgJJplcCa9HYTndYP++IKIqM9Yf5vULy4iiQDLhJ+BxMN4fZn6jQKZY48juPjIli4R5PXZaepvBsJ+2YGJoJnPLWQIBF7lKHUkSSFfqm8cA5ZZKwOlgIOTD67Bh6AbL+RL+hJ+pJYt07Yn5uJy31LU+t43VhuXEDbudXFhPE3I6GfB7UQSRYa+PlUKZZqDNxXWLWJ4YSvLWpuJ3KBljKm2Rz+GAj0Zb52Sij4aqMplKo+o6Dlkip1nGD1kUWCiXkASBg6EoLVMnU61SlU0wrOcEJZmNSom9ziAOSWG6ZK3vc9g45ugj32owV80QVJyYgsBkfoUfO/AGhiChmw6qmouSISGYdv5Z4p/ilO/eB/s4p3FsNwewow52DEjFYpF8Ps+1a9doNBr4/f4uIdyuOvgkloB3ygTywgsv8MILL9z2d5/73Ofu+tqPfexjfOxjH9uR/ejh8aNHAHt4anGnHMD19XXOnz/P8PAwExMTD3wDux8CaBgGs7OzrKysdKeJ3A07ETFzKyF7VOYSQRBYX1+nXC5z/PjxbkTHvcjfFz77N3zlSzO0RBOjraO47TgiXiS7hF6tEvDbWUjVOLQnSbnaJJ2rkq00EIHj+/qpNFpsZMus5itkijXiIQ8XFjdIhrwMx/ykClXyxQYDET8XrlsK2pHxJJPXNwnYUILr2SKHBmL4nQ7mswXK1Saqx8Vrm6pgzO/mwsqN3r+Nptrdf1GRiQAeUcBjlxEMg2ylwZDfx5ubkTBDQV+X/LkVhcuZXPf19XabQ9EYNkHEEEwm1ze4TpETgwnUzXN/IB7jrQ1rf4/F4uimyXzbRETgct5aa380ylvZFCFBZiIU4c1sig0aBFVrRvZ+d4Dr5RIFtcnhSIS9thgexcZbxWXeO7qKS7HMKI22SdlwIaIQt+/lHcEj9zz3Dzt54mHwICrcVnVwYmKCRqNBLpcjn8+zsLCAoijdEOpQKHRHdfBJKwFXq9VHMpe8h7/f6BHAHp5Y3Ct+RJZlWq1W9/8Nw2Bubo7l5WUOHz58W2fb/WC7BFBVVaanp2m1Wpw+fXpb39QfJmKmEybdcd9uNZc86NzeO6HdblMulzFNs2v26JDuu5G/L/7uy3zlz85jygKCYRBO+ikbEAg4uLaYwe1W8AW87BlxsbheoFRpcvhgP6ZhEvU5OXc1RUvTObwnydS1lEX6kgGUjMRGvoJhmmwUqrjtCtfTRQA8DhupYoWDAzEcsky6XKNYblCpNQkH3GyULCJkbtnlRNDLenWzrDsQJVMoEfW5CQcCnF/PUG2pGC4Ha8Uaqm69r0uboc8APpcDypZiuCcRJt9osjcSxiZJvLmyhmYYJH0eUg1rGx6bwkzW6uuTRYF0vcaJWIJqU2W1WmWtWkUU6DqI7ZJEVVM56IuwWi7xVm4dAzgSjZNu1pgQ3DSNNgW1SUJS0Boqs80SfV4XJ4L9OKQr3X2tG0FMZNp6gB8f+v5tnf/HTQAfVoVzOp0MDAwwMDCAYRjd3sH5+XkuXryI3+/vEkKPx3NTluaTQgA74/UedKZyDz3cCT0C2MNTi60ErUPCms0mzz777I70y2xHpSuXy0xOTuLz+Th27Ni2+40eVKm7lWzeelO437m9d0Oj0eDs2bMADA0N3TTW7U5mD4A//4NX+fP/eYa2CW1Nxxn1EugPYa83WUwV8HrsuLwu5hYy7NmdwGlX2DMaZWouRUttMzYWpaXpJCIeJEFgOBLA47Lx2swyAEcm+pict1Sz3UMRqi2VsVgQmyLxxtUV0tkqR3clWcpaJouDw/EbJd7+CJdTFgEbjQYQTDg+kKBUa3B1JUNV2zzfdgfVlqUGjsaCnNkcH3eoP8a5dUsxDNpkUrk8u70eJElmKVciW29wnSLjsRDa5vmN+z2sbmb37YlHOJ/e4HA0TsDh4LXVFZbzZY4k490JJIficaYy6+wOhEi4PXxtbQkT2O11UWiqOEUJhyiTrTdwen3MNyoMuHz4FIWZSpbddhd6QyetFTiWKHbPi2aCqjv4Z7F337P028HjHMe20yRMFEVCoRChUKirDnZ6BxcXF29SDzVNe6JKwPV6vacA9rDj6BHAHp5adErAHdOF3+/n9OnTOxYJcS8FMJVKceHCBcbGxhgbG7svpeRBSsDVapWzZ8/i8Xh49tlnH6m5pNNbGI/H0TZDj7czHeEv/+hN/ujzr2IIIgYGhtfB4K4Y0xdWSQ46iYU8OL0uLsymOLSvj5amUy43uWbmaaltDuxOYAqwuy+MaBOZvLKGXZGote0ABDxO8tUGR0cTSILAzFKGhtomGnBTaDQxTfC7HVxas8qyNlliKVfCaZMZDAUIOp3sT0RZzZfxOuxMX7eI4WjQ2SV/44kQs2mr/Opz2pnZLPEKgCJLnOhPomk6siJydmWdXKPKRMhDdjPeZdDrYm6TzIVcDs5vpHHKMntCYYy2gdwWuZhKkwh4uqXg4mYfoAh4ZIVxX4iFQpFcq4EJ+BWZRbXB8XASSYDX01YJ2qGIHLcnqLU1ZipZojYXpsPG9WqOdwYlbFKze25qqkyYQU4HD2/7OnicCuCjJp9Op5P+/n76+/u76mCnVFyr1VAUhevXr79NHXwc2MkewB566KBHAHt4YrGdEnC9XueNN964p+niQSBJUpf8bEUna295eZkjR4480Dzf+y0Bp9Npzp07x9DQ0F37GneCAHaMLLt372ZwcJCLFy+ysrJCu90mGo3i9/tve2P+8hff4n/8t6+jmybYBJLjfTg9di7NphgYdLGYqjM+7kVV2xzYFWd+OUe1rnJwf5Jyrclg3M/VtQLlWpM9Y1EuLVrEa+9YjGpTZSDsBxGmrqZYBvaNxWmoVjk6FvKQXrTKrCOJIGuFChMJNz6XncVsiVK5iSIIvDZnqYh9QS8XN3v/ZBGy6g0yLkjWe+tz2Dk8EKfR0qg2VRw2udtfGPG4yLcsciWJAiXjxnUqS9Z745Ulhpx2aoadxVIVWRA4sxkjczgZYypj9S0eiEdZb1R5JpZEEAReWbGyDo/Eo0zm0ps/J5kvFTm7kWI46AdgTyBEs21wsbzB3nCQvd4IfpuNN4srPBsZwOf9KwxkwLqGtbaPdzb28vLLL287VPlxl4C/WerjVnVwfHyc2dlZKpUKlUqlqw5u7R1UFOWbsl8d1Gq1ngLYw46jRwB7eCphGAarq6s0m01OnDjx0CGpt4MkSTSbzZse0zSN6elpGo3GQ5Wat0vUTNNkYWGBa9eucfDgQZLJ5I6se6dtzc3NsbS0xLFjxwiHw+i6zvj4OKFQqBumDRAOh4lGo4TDYRRF4aU/OcMf/PZXaRommk1iYn8/6WwFTdDweRSWNxpMjMWoNVSWVguMT1j5dScODLCWK7OWLuPaY6dca2K3SZTqLQ6MxHHaZGaWM9QaKiPJINczVo7eWF+Ii0ubDtt4gGqjxdGRJLIocm0jR6HapF5rgSJSabQQBCht6RcN+Vysbs7z3ZMMM5spsCsSJOZzU1U1ki4P9ZbK1EKKmmoRqNHEjbGBA2E/6RXLYXywL8bU+gayKLA/HkWRJAwk8rU6lwtVmrqOAMznbhhESloLSRDYH4lilySKlSZvlVOMRa1tiAJcL+YZd3lx2R28sb5KU9c5HItzqZjhmUg/dVPlciHH3mAIr2LnUiFDxg7H/X2sq2kOuCpoWy6F74m9m2/ve65rjLg1VLkTm7K19Pk4XcCPc9uiKOL1ertzrUulErlcjuvXrzMzM4PP5+sSQq/X+0j3U1VV2u32jrS19NDDVvQIYA9PHZrNJpOTk2iaht1ufyTkD95eAq5UKkxOTuJ2u3n22WcfSgXYDlHTdZ0LFy6Qz+d5xzvegd/v35F1b4d2u8358+e7mYlut7vr9FUUhUQiQSKRwDRNSqUSmUyGhYUFLly4wNL5In/759cwRAFn0MvorhilUgNdaLO8UmfP/iRyoY5m6CytFjh8oA/dBEUQWdooks5XmRiNsrCa58BYHJfLxuSVNVIbZXaPRak1VKv+KoFpgiRAwOfkmNtOo6mhCzC3mmORIgfG4hSqFmmfGIxwdsFS7A4Mxbvzf/tDXvLFCqM+Jz6Ph4raxtBM5tcLKLLU7RE8PprkzJL1+j3JcNfh63faubieRgSGg37cisKBcISFbBHBFLr9gicGt0TC9MWY3oyEGXHakRoqHmTqjRbnM1av4t5omEvFHIIJ4w4HDUlivlzlRL+Hpq4DJm7FRtTmodBqMFfLEbG7sMsyb2XWOJVI0mjrCDIcDl6nrDsISlZZ2jBFviN6Ek3TsNls9PX1dWNTCoUCuVyO2dlZVFUlGAx2CeHfFwXwVui63iXCoigSDAYJBoOMj4/TarW6BHppaQlRFLvKYOcL0U6iWrX6R3sEsIedRo8A9vDE4nY3nnw+z9TUFNFolIGBASYnJx/Z9reSqY2NDc6dO8fIyAjj4+MPfVO8V39hh+QCPPfcc9jt9vve5+1ia5D0qVOnkGX5jmPdBEEgEAgQCASYmJjgK3/0Gl/780mauok7YMcRVCiXK2joSKLExJ4E5y6sceCA1e93eF8/swsZGi2Ng/v7uDS/wf6xGKYk0FZ1iuUGlxbT6IbJnpEol5YyiAIcnehDN01290VwOmTOXramf+wdjnF5xSoVD8UDXNyc2hFwO5hZzSAKAv1BL267wrHBBKVaE4E280VLvTsaCDC/uhkOHQt2yZ9TkZlN33D7GgLYJJHhYIBkwEumWmcpV8Rjs/PqvFWyjfs8XNg0iNglibktbmFBFDiZTLJermJ3Kl3DR0C/ETujtVX2ef1kKzWqosRarYbXZmMmnyHudLMnGOZra1ZI735PmCP2BLIgcDa/RtThJt1okKpXOB6PIctZVFNGFKxrwS66um0HW6+7TukzEolgmmZ35FpnnrTNZkPXdfL5PIFA4JtKyB63AeVORM5ut9PX10dfX19XHczn8ywtLXHp0iW8Xm+XQO+EOlitVhEEoecC7mHH0SOAPTwVME2TxcVF5ubmurl3tVptR8ep3YqOyWRubo7r16/vSLRMB3czgRSLRSYnJ4lEIhw4cOC+boL3GwPT2VY0GmXfvn2YprktswfA3/6vs/y/n/06LRNiIzG8YTcLSzmCEdANEBWYuZxi964w2XyNjUyF4dEwjZbGvvEYpm5iE0RkRWJ6LgUC2BwyumESCTjxuu0cGIyRzle4niqQrzSwyRJen31z/wRKjRtlXYdDJhn0EfE48bodpPJlVnNlwh4Xb1yxSFrEYyO7Ge5skyUWssUbr7ff+DjcOxBltVhhNOTH67STKlUxVUjlKqyVK9RaVlm40b7RI5oMekhtun33J6MUGk12h0JIkshryxZh3RUJdsnfcMDPQrWIz25j3OvjarFIud1m2OXget3qZ9wbtVS48+k0K3arZD0eDOIQFM6m1xmP+tntCxNyOHkts8w/6BskZ7xBfPPUdaiHXXRjs9kwDKN7jjs/d2J9BEHA4XAwMDDA0NAQ7XabxcVFVldXmZmZQdf1rsoVDoe3/aXkQfE4FcDtRtBsVQd37drVVQfz+TzLy8sIgnBT7+CDBNJ3DCBPSixND9866BHAHp54tNttLl68SD6f55lnniEQCAA3VLRHWaaqVCq0Wi2effbZHW3CFkXxtgaTjgFjYmKC4eHh+z6u+4mB6biYJyYmGBoa6pKCu+X7dfC1v5jiC7/5NyAJjOzvA1lmPVcmFrOztNEkEvHg97toNE3ShRqFUovRYR+SYJAMeciXG6xnKgz2BTl/bR1JFDiyr592W6c/5CUa9vDWRYu0dbIAAfaNxbo/H96VpNXWiflc2BSJ84tp6i0NrdXm0koGTTeQJIFUsdLdb4/TRmaTAO4bjDK5aJkyJuJBRARODCXR2jpr2TKZco1MvsrewSjzm72Hh/vj3RLv7niYK1mrLBx0OZnPFTgUj2IXJTYqdVaKZRYpMha70TvosN9QlQYCXoIuB5c2slRsLcqbRMx0KEhakzGHi8vrG1QMnQm/nyulAgdDURDhbHqdg9EodkVisVxirVniVHSAhcYcJwfTdKifsskZZNHRvT6ALrnpnPPOv1vVQY/Hg9Pp5OTJk1SrVXK5HKlUiitXruB2u7tk0Ofz7ThBeZw9gA8aBH2rOlgul8nlciwvL3fVwQ4h9Pl82zq+Tgbg43Qh9/CtiR4B7OGJhSAI1Go1JicnURTlbaXQzk1M1/Udi37poFqtMjc3h2manD59esf7em5VALc6i7czSeRu695LATRNk6tXr7K4uMjRo0eJRCJdIr0d8vfXX3yTL7z4txiKRP/eJItLBfpG/KjNFlXFxf7dCTLlOjOXN9h/sI+W2maoX+Hi1XW0tsFAn4uldAObLBD02/G4Y+QKNa4uZijXWoSDbi5dt0qp0aCbi4tpbLLEcDxgGScGY+TKdRZTBQrVBggwlAxS31TlkhEfmeubBo2ROFObUS9xv5PFQpW+oJewx4UiSuyLR1gvVrErCheXrW0eHU2SLlsK3FDEz8yWSJlruUL3fZBkgfFwkIDDgd0m89r1FS5WMhwZjLNStMKhJ6IhrmyWggf8XpaLJU4mkmi6zmuLq+imScxp52rFIqn7omEcNoWWauAPeJnbsPZD0zVGJSeFcoVVo4lDlLCJEm9tpDiVTFLRnJiizkS4iCjc+ALgkiTaJijC7edDi6LYJTodRbBzLZim2TVBtdttXC4XbrebkZERNE3r9sGdP38e0zS7ZPBBla5b8bgVwIfdtiiK3XaJjjrYyR1cWVnpqoMdQnin96wXAdPDo0KPAPbwxCKTyXDmzBn6+/vZs2fP2z6QO6RvpwlgJ3IlEolQLBYfSeTD1hgYTdM4d+4c9Xp925NE7oR75Qvqus758+cplUpvM3tsh/x95Q9e4w9++6vYfU4SE0lyhRrhhIvZ2SyHTwyzsJBDFyBfqHHsyCCr60Uy+Sp9g0G0tsFQfxC3z8EumwNRNDl32erZGx70sr5ulXMjIQ/NtM6uvjBenwN3rsLKRgmHXeHsFSv/7sjuG6rg/pE4FzYdwcmwl4tL1ppuu0yrpTLqd+BwOHG5nZRqGqlMhZjXw1tXrbLsQMTHzGonEkZgOVfqHq/XZYdNzndwIEal1WJXKIhNkpheWaehtXHbFAwZ9M0omGyj0X29rEjYRJG90Qheh403ltY4W01xdChhxeUAHkUi2xY4HEvQMjQm19ZxyBLNYhvBhFN9/VzMZymrLXaHAyRbAj5B5Ew2RURWWK2U0DBw2LzYlfpN58swrff0TgRwK25VB1OpFAsLC+zduxfgbepgLBbrGoO2Kl0dl+zD9sE9bgK400HQdrudZDJJMpnEMAwqlUqXDN7aO7hVHaxWq9ueYXw3vPjii/zKr/wKqVSKAwcO8OlPf5p3vvOdt33uH//xH/OZz3yGqakpWq0WBw4c4GMf+xjf/d3f/VD70MOThR4B7OGJhSRJ7N+/n76+vtv+vkNYdqoP0DRN5ufnmZ+f5+DBgzidzkdmMukodbVajbNnz+J0Oh/aWdxZ93alZbCMJWfPnkWSpG6Q9J3MHrfDl77wCl/87ZdxRX0oHgeq1sZAw9RFDh0dYnJymX37kwhYxOnaYpZSucGhQ/2obZ39u+IUGy1mrqwTDrmpbJZiB/v8pIs1BiMubLJJNlOkXmnR8jmZOW8Rs/64n4sLmwYPj4Mry9nN/RbIVeskQ17CHic+t4Ogy0G2VCfks3F52VLfBqN2Lm+sYZqgSCJLuWL3uPweJ8sFS7E7MHRjashYNICIwPGBJJVGk9VsmXRlc2zcYIyGZpVsd/dFOLOy6Tbui3IhncEmiRyIRzEAGxIbxSqX1CZtwyDocnJh0xEclGWCPh/ltkm11WK2ZO3vgXiMfKtOxOYi12pSVluMBQL47E4WymVsQQ+jhh+PLHCpWmDU5mCpskIseiO2SBIkDKx9VMR7E8CtWFlZYXZ2lsOHDxONRm9SB7eWjK1zYJWKvV4vY2NjXaUrm82ytLTUzdCLRCJ3nb97Kx6nCeRRzwIWRRG/34/f72dsbAxVVbu9g52opWAwyOuvv45pmg+tAP7hH/4hH/rQh3jxxRd5/vnn+exnP8t73vMeZmZmGBoaetvzv/a1r/Fd3/Vd/NIv/RKBQIDf/d3f5Xu/93t5/fXXOXbs2EPtSw9PDnoEsIcnFp1vwnfDduf13gudGJRyucypU6fw+XxUKpVHZjIRRZFms8mrr77KwMAAe/bs2ZEenzuVgEulEmfPniUSibB///77MnsA/Mnv/C1/9oXXCA9FEZx28qU6tXYLQ5Rwex2ksxWOHh3gyrUM9brKxL4EqtpmYizGxasp6g2Ngwf6WF2w1LVwyENA13E7bNQ1jcZ6m1RDJxxxkys3EAQobM7oBVAUAcM0cdhk9gzHaLQ0ME2cDoXJa9YIOZsgMLOU3iR5AjX1Bhlyu+2Ym6bcA8Oxbu9fX8jLzMoGCb+HiMeFTZLYG4+wVqjgdTiY3nze4eE4V7OWFNgX9DKT6pSFxW5Z2O+wE3A6OByLcS2dxzBhes0irXsTEdKrljo3FPKymG8Td3lwe928tUkeYwHrJh92OMGE67kSuyNhLhWyRBxOAg4nb66nOByPIYpQajWZb5Z5R2yQi5V19vflMc0b59Jm3PhZ3oYC2MHCwgLXr1/n2LFjBIObuYS36R3skMGt15IgCMiyTDwe7ypdnQy9hYWF7vzdjtJ1N2XrcWcQfjPJp81m66qDHUV1YWGBz372s8zNzeHz+fjoRz/Ke97znjtOAbobfu3Xfo0PfOADfPCDHwTg05/+NF/+8pf5zGc+wyc/+cm3Pf/Tn/70Tf//S7/0S/zpn/4pf/Znf9YjgN9C6BHAHp5qyLLcdTE+KOr1OmfPnsVut3P69OluL85OkctbYZom+XyeSqXCoUOH6O/v37G1b0cA19fXOX/+POPj4wwPD3dv2NtR/QD+x298hS9/8SyRkRiyy4Fm6jjcJvmSgT/oQLHLLC7nkWwysiRy4sQwy2sFsvkqLV2n3tDoS/pJZSoc2p3E5VSYvrxGs9Xm0P4+Zq9bat6B3Umm56wS74GJJNdWc4wm/DjtIpV6k5BdRpREzswsoxsmNlnC5bHR2pwG4nLa6fhfBsJO5nObhCseYGazv8/rUDBNODaUAKwSbaHSYCNXJeb18OZmWTjic3UnhQgCZGs3SqtRv5vVcgVREDg+lETVDQq1JrIk8o2r1qSRmNfdjYTx2m3MpDOIwJ5wiHy+RKmugSlRa1gkdzjo53qxyDPxPhDhzZT1PiDDsWgCVdc5k04hYOJWFF5NrfBMfwK5JdE0VYbdHgS5esP2C9iEG2pyIVthsbpIJBK5o5rUCQJPpVKcPHnyrqanO/UO3s5I0lG6xsfHb5q/u7CwgKIoRCKRO4ZQfyuVgLcLQRDw+/0cPXqUN998k0996lN86UtfYnFxkfe9733ous7i4uK2TWmqqnLmzBk+/OEP3/T4u9/9br7xjW9sa41OyToUCt338fTw5KJHAHt4qvGwJC2TyXDu3Dn6+/vZvXv3TTccSZJuIks7AcMwuHjxIul0GpfLtaPkD24en7e1pH3kyBGi0eh99fsB/N6n/oK/+9J5QsMxcsUGEY/C4rUcw3tiDHhE6prOlcvrHH9mhFqtRdtl4/ylNVqtNgcP9ZMt1ji8t4+GprE2n6FZayHaJJqtNkG/k9lFi/wF/U4aLY0j40lAIFOs0qyrLDc1YhEfa1mrr26030+uZpWO+yJO5jNW7MpYX4jLy5uqnCTQMETGEyHcDhtOh4JDksiU6gzG/UzPb5pCgh7S1Rq6YVokb4viOBD2kalapG//QIwLa2kkQWAsGkRGYH8sylKuyEKmxEbZ2od9AzeMO31hH+srm+XiZBRVN1jI5lGbdZbrVl/eWCzIW2spHLLEkN9Hfr3JZGqdiM9S63aHgkimyNT6BvsTEYJ2B4eiUb6WWmLY52ejXschS1TbGpHQErW2gl+5Uf532xzdn73OILlsjrm5ORwOB5FIhGg0SjAY7DrHZ2ZmyOfznDx58r5KjvdSB7fGzHSUrv7+fnRdp1gskstZ+9VsNt8WQv2tWgK+HxiGwd69e/n93/99dF3n4sWL95VIkM1m0XX9bRFW8Xic9fX1ba3xq7/6q9RqNb7/+7//vva9hycbPQLYwxOL7RCUByWAW0esHThw4LZ9hltvaDtxM2i1WkxOTmIYBvv27WNhYeGh17wVHQWwM0WkUCjw7LPP3rfZA+B3fvFPOPPKVQb2DdAGgg5YWy0wvi/BzIUU+48N4bZJHDs2xNmzi4iSSGIwSER2k0j4WF4rspGpEA64mZu3yNnwcJgLs+v4PA4mxmI0mhrlShO3x86Fq9bN6NC+JP9/9v48SrL8ru5FP2eI4cQ8T5kZOc9ZQ3dVd1cJuJhnL7BAxmAwLBaPyVi2njDvmcZmeO+yzOLC8rMFWMwILxldLD1ZxlxA4MaSkISEpFZ3V2WNmVk5z5mRMWTMc8Q5748TGRFZXd1dU6urROx/qiLOiRO/OHkiYsf3+917H8T1mby50RA31vX7h/vcbMT0dqtNMRDLVXBZjFgMAlKzypDLTL0JoYCbq2t6W3Uw6OLGpv54WRLYP+687oDbxmGLvM1EA9xuVfxOTKTdFoWwy4bDZGTS72U3mcVuNnG1lS5yZiDAzQP9MQMeB0sx/TU6zCYOs3kuRMIUKzWWYkmylSqSAA1Bry5bjQa2slmeC4fJlit8aWcPVdM43xfkZuKIi8EwJa3BQiLBsNtFU1UxaAIb+QyDNicOs4nVbIoRj5O6VqdIGg0Rl2ymik6WjWLn493jCnAu+izNZpNUKkUymWRhYYFGo4Hb7aZardJoNHjuuecwmzvE8WFwd3XwzWxmTggf0DahTiaTrK2toWkaW1tbBIPBNlH9WuGdrD7ejW4VsCRJnD179qGOc/d7/n7tsz7+8Y/zi7/4i/z5n//5Q+We9/DkokcAe3iq8TAEsNFocPv2bTKZzJtGrJ18ATwOlXE2m+XatWu43W7m5ubIZDJvS3tZFEUajQavvvoqgiBw6dKldprDyfb7+dD/rX/7cRZvH2B222mgkckVkIwSA4MBNjdSnLs4xMZmAgGBhgAej5WhUT/7+xlSqQINTeMokScQsLO8cYTTbmZowEND0wh77djsJl69vg3AcNTbJn9Bv43FDX1uzmI2sBnLIIkCQY+dgNuGw2qm2VBRFAM31mPkijW8ERdrsQwAJlkgWTpqvw6TqdPGm+2yhPE7rdze7eynabp5s2KQMZsMLB8kSeVKBG0Wvrqq+xHazEaWWrN/cDpb2G1XqKgN+p0OFKOBlzf3ODoucH4wTPZY328m5ONmPIlHUZgL+5nfO+Rq5pBz0RBqVq9CGkSRfouT43KF9UIaCYE+u42v7O9xJhSgpjbR0NjIHfNcIMxWKYPTfYjW+puaZZFqayLCIHReu0HQUyQkSSIQCBAIBNqxfrdv36ZWq9FsNrl+/To+nw+fz4fT6XzkGbx7tYrfyITaZDLR19fHwMAAtVqNL33pS2iaxp07d6jX66dMqB+VpL4V3skW8N0oFouP5EHq8/mQJOl11b54PP6Wxvaf+MQn+PEf/3H++I//mH/wD/7BQ6+hhycTPQLYw1ONB50BLJVKXLt2DVmWuXz58pumGTwulfGJ4fLo6CjDw8MIgnDKBuZxolqtkslkCIfDzMzMAB37DkEQ7usL/df/X/+Vvb0M/qifQrlGsVQglaoQ7vcgSBIer507dw6pN5qce3aQ41QRFY35azuoqsbsmT7urMUYHfLhdCnIcZFEMk8sWSCWyCHLIk1Rb1MLokD1hJwC4YATt9OCUZZRFAM7R2kqxSouq4lXb+nzdW6HQqFWo1rXH5crdebzpkbCXGvZwwScJpb3daNmUYTdVBanxUzAYSHosdNXrlEsV1HMRm60iKHVZECVaHsKdmkqGI94ubqtH3sq4mP5KMmY34PPqnCQK5BIl8jnq8hmGVXTEEXYPG49vwCiJHE+FGQ1nuLWYZxCrY7XqnArHidgtTLl8/LFHT3qbbbPT1izMehw8qW9XUQBrLKRWwd7zEX8hFU7mUYZp6UOxk7kXF3tkFJZFGm0LjGD8HrCVK/XWV5ebivQVVVtV+CuXbuGIAhtMvg4Mm7fqFV8Qgrv9sUEmJiYQJZlisUiqVSKWCzGysoKFoulTQadTudjrdY97rGPR0WxWCQcDj/0441GIxcuXOAzn/kM3/3d392+/zOf+Qz/+B//4zd83Mc//nH+2T/7Z3z84x/nO77jOx76+Xt4ctEjgD081XiQCmAqleL69euEw2Gmpqbu6wP+UWYMuw2Xz507d6p98jCZvW+Fo6Mj1tfXMRqNzM3NtQfz77fq12g0+MD/4//kOFNFcdoQjCKFZAlkA1OzfaxtJqkeZhiZCuF0KYhGiSuvbaEoBsxOM06HmcFBL8VyDQkBi2Jg/oZO2ubO9HHzji5smJ4Ic2fjiKE+N0G/nWK5jiEkoChGri+0RBhuK9lKhVq9iSgKZAodRW9fyMnNVls44jWzn9G32RQjy3tJTAYJv8PKQNBJuFKjWq0hCiob8TyVuopQb7J9lKHe1M//cF9nsH2838e1LZ3kDQVcrBzqBM4kS6zGj+lzOQja9Vxdq2Rg4/AYx3CYnZZ34HR/gPmWqnfYbWMrX+RcMIDNbOTL23ol8ZmBEPMHLauZgJtmQ+PWYZxdo972HnDaMQoS2WKFolXBIIpcivTzxf0dXURSquC3KuyXcviCCbr/tFWtc55kQeDkp1G9cdpY/MQSyGq1cubMmfZ7odunLpfLkUgk2Nzc5Pbt2zidzjYhtNlsb0t18IQQptN6q//kx52iKAwMDDA4OEi9Xm8LSW7fvo2maaeqg49qQn3yvnySKoCPagPz4osv8kM/9ENcvHiRy5cv8wd/8Afs7Ozwvve9D4Cf//mfZ39/nz/6oz8CdPL3wz/8w/zGb/wGly5dalcPFUV5w45JD08fegSwhycWj2sGsDtHeHp6mv7+/vtew8MSwEajwc2bNykUCly6dAmbzXZq+1sZNj8IuucZBwcHSSaTDxTrBlCpVPnVf/kRSg0BVZZpShprN/cZmQuzv50hcVwkHHZishi5dWOPwREf2ytp/AEbg8N+YrEciUSO3YMMyVQBr8fKakvdGwzYyeYrnJkIYzTKxFJ5mrUmx8dFkukihVINURLw+zuWP4GAjcR6S0QxFuLmSYvYZ2Nh8wiLScJiEAl6XQQ8Ak1VQ1GMrO4lSZdKGJwCX7290zrXAj63jUpd/2IPui2sxHTCFnErrMf0CppJltiId5I+bBYTo5Ibh9mM1Wzg1s4Rh/kcJlFis2X94lBMbUsYSRTYzWQRNIhYzUgamJC5tRdnIKB/aYoCHOQLWA0G5oJ+Fg6T5Ks1pkM+Fo6ThG02AnYrVw4OGXI7OSoVGLa5WM0eE7Ha0ATIVStoskrUbicnbHBSl5MEkabWqYaf0BeLMEWq5AGXfvvEe9Lj8TA9PX3PH0LdKRbj4+NUKhWSySSJRIKNjQ2MRmObDHo8nkcmS93VwVQqxeLiIhMTE+384rur2H6/n2AwiKZpbUPl/f39U4bKPp/voUyoH8Qe6WuBUqn0yATw+7//+0mlUvzSL/0Sh4eHzM3N8dJLLzE4OAjoXYqdVvUZ4EMf+hCNRoOf+Imf4Cd+4ifa9//Ij/wIH/nIRx5pLT08OegRwB6eaHSrWu8FSZLetAV8oppLpVKncoTvFw9D1LptZU5m8O617pOqx6NUUlRV5fbt2xwfH/PCCy9QqVTY29sjFou1Z3/eCvlMgV//f34MVZKwuBXqhSKFQpHoRJCNlSRzFwbZ3kricCrcurGH22vF5bXSUFWsdjOvvbYFwMzZPm4vHWA2ywwN+6lWG5SKFVRJYHNbr6SNjvnZP8wAEB3wcnulleYxHubmaku40edmaeMIn8uKy6ZgkCTOjekZvUajRDZbolJsMDQS4PqyTgwdNhOVZpNKyxLGbO60K2eHg9zc0uf9nFYz26lCe5ts1D8CJQEG3WaQZKIuG5Iss7ATp95UEUUBj1MhW9bbq5auY4+GPFzd0df97KAe8VYv1zBIIivHLXVw2MdCUifDZ/qCyKLISrlGA418VVc0NwSN50JhUqUy84f6axpwOrl5dITVZqRR13CZTazkjzkbCJCulcmICbpS37CKp1u0J5FwX9oa5Ucm9G35fJ75+XnC4TDj4+P3fe2ZzWb6+/vp7++n2WySTqdJJpMsLy9TrVZxu934/X58Ph+K8mCm0904UeXPzMy0255vZUJttVqx2WwMDw+3DZVPqv2CIJyKqLufNnb3vOyTgGKx+LofkA+D97///bz//e+/57a7Sd3f/M3fPPLz9fDko0cAe3iqIcvyGyZflMtlrl27hiiKr8sRvl886KzeyRdPJBK5Z3zdCU7ufxQCeKIq1jStTTQNBgORSISNjQ0WFhbweDz4/X78fv89B+fju8f83v/7v1NVRaq1Js1KhnS6wsB4CDSByTP9XH11k0jUiyCKjIz4kMwGrs/v4PZYSOUqGAwiE5MhBGAw4sbuNHN1Xhd4zM6Eub2iE5rJiSBL6zoRG+hzs7gWw+1Q8LgsyJLAufEwtWoDQRYwqBLHiSJ9fgfzi3rrtD/kZG8zi4Ze1TvOdyLXhvo8XD9R/oZc3NlJtM6zQDzbsXcZjnhIZAs4rWZsZiOFSo1+JySzRZLFJuliKwPYq7RbxLMDfm62FMIRt70dG2eWJepNlQv9YfaPsxyk8+xn9Exfn8cBeX02sS5o+K0WBp1OEsUS2+ksiiyznNRJ8blIkFSpzGosxZloEKEI3zDQz5d2dhBFAaMscXCcw2RyE1ZsZOtlnCYjG0KakGSkiU5MzdLdBBAswgR/va3x/lkj6XSa69evMzQ0xPDw8INdbF2QJKld/dM0jWKxSDKZ5OjoiOXlZSwWS3u7y+W6byIVi8VYWFhgbm7ulDjhQUyoJUk6ZUJ9ElG3vb39uoi6N2pjP0jl/GuBx0UAe+jhbvQIYA9PNSRJagfWd+P4+Jjr168TDAbfsM11v8e/3wrgzs4Oy8vLTE1NMTAw8JbHhYe3m8jn81y9ehWXy8Xc3BzQUSuPj48zMTFBsVgkkUgQi8VYXl7GZrO1yaDdbmdjYZePfeCvkCwKBk2jUiySipcZneljZTFGOOqmVqxy5twAB0c5Fm7uMXOun4XFAwJ+OwPDPtKZEslEjsPDDMfpEi6nhWRWJz5Oh8Lm3jECGl6PFaNR4uxkhGZTRRPALElk0iX6Qy6u39Zn/6bGgiyt6wTLYTe3fQIBGo0qJwWvmbEQt1pzgC6bwtJ2vL2f1WKk3+fAbjHjspspVeq4zCYq9QYr2wlK1Tr75Jga8rPU8g48MxLiZiv1w2tX2Mt1rqm9ZEdkEXZb8TutqE0Vk1HmtU19rnEi7OFOQt9vJOBmrfX/M2E/CAKbuTIBi5XttN56nor42c/lGXa6qDWb7GVzhBxWUqUiwzY3hXodDXihr4+XD/c4E/BzXK3S77SxmUtTlo+piyoRxc5uVSedinT641ygyZe3jxcvOwAAz+NJREFUxgGNai7PtfVNJiYmHmgE4q0gCAI2mw2bzcbQ0FB7Pi+ZTHLr1i1UVW23Y30+3xvO5x0cHHDnzp129Nyb4UFMqB0OBy6Xi9HRUSqVSrs6uL29jSzLbTLodrvbSv8nSQCiadpjaQH30MO90COAPTzRuJ8W8N3qwd3dXZaXl5mcnLxnzuWD4H4IoKqqLC0tcXR0xMWLF9vxWW+GR7GYicfj3Lhxg+HhYUZGRt5w3s9qtWK1WhkaGqJWq7VnuLa3t4mtHHP9Mzs0kVFkmYPdFJ6wi1BEYXnhkJGJIPlilb3tFObZCKl4jpGJIKIkEPTZ8YccXLmyBcD0XITFO3r1LdjnJFeoMjTgxWI1kkgVOKqrhAMubt1uiUCmQiyu6mQrHHCwuHbUOtcCx7mOojfa7263hQNuE4fHFUTAaTejqhozQwEMkoTVaiSdK1Ms11BMBpbWThI8cgT9dg5TOkE6NxFhK6ETsD6/gzt7idZ+kMh1mUAHXCRaQpBzQ0EaTZVgvUG+VObGRoymplfXXI5OqzNb7LSVHRYzzyohUrkyGgK3WxXDGvp15DAZkQWBdKGEzWBgLZNG0GDM5+W1vQP8NpE7qSwXAmHWssd4zWbStSqVRp2VbIoxj4tNQT9/Kp1r0yxJdF+p5ZqHz2zr753N5RUunzv/lrYfjwqDwUAwGGzP5+VyOZLJJLu7u6cqcCc/QgRBYHd3l9XVVc6fP//ASRMPYkJtMBjaJtSqqrZNqNfX1ymXy7hcLrxeLyaT6Ymp/gEUCoVHsoHpoYc3Qo8A9vBUo9sGRlVVFhcXicfj903E3gpvRQBrtRrXrl2j0Whw+fLl+55/OvmCeZD28okx7traGmfOnCEYDN63ubPRaCQSiRCJRHjt0zf5wpfvIJiM1Gt1apksTU0keVQgOh7CnjORyZY52Etz7oVh6vUmgaCDYqHGxlqCcL+Lpdbs3eRUCE3TmJuOYDTL3Fo4oFZvoozJLCzrJCoccrLUInyK2cD+Uba9LqvdTDOpE7SZiRB7sSyDETcOqwkBmB7wUCiUUKwKalMmkysTDXSIodupkK/WqbUsYSaGOtWjmeEgt7dbnoImA6stSxgAl11h71hX3c4MBri9G8ehmIi4bUgIzIUDHKZyFEv1tkjk/FiY/UJLIeyzs3asrztgNXBUrjEd9OFUTFzbjVFrNIm47Swc6uRvNODmIJvnYiSMIAm8tqOTYbPJQMhmo89u4+WdPRqqSshtQy5IaKKGLIoMONwsZ1KM+9wIIiTVOHVZv+ZrWmf8wSCIpwjgV3d9gE5snz9/nmDg7SV/d+Mk0szpdDI6Okq1WiWZTJJMJtne3kaSJMxmM4VC4aHI373wICbULpcLj8fD+Ph424Q6lUq1FcgrKyt4vV5cLtc7qgjutYB7eLvQI4A9PNU4IWiVSoVr164B8K53veuxGcW+mV3LyUC9w+HgwoULD1TJEwThgQQmJxFyyWSS559/Hrvd/sDJHgB/8z9e4fOfvEZTk5GNGsVkEYfXSSAikkqXuH11h6FpL6IkMXkmwq3ruzSbKtNn+1lcOMDntxGMuHC4reRyJWKxLNlsGavNhGCUqNWbGA0Sma4WqtlqoJFUkWWR6akQ2VyF/qALq8VAvlRjtM9DvdFge/uYfLFK5rikzwuu6ORtdNDD6rb+pWwySmzHOkrdvpCbmyezf2E3y63ZPwQ4LnZmBMcH/W1/wLDHRrFS4+xgEEkQ0ACfWeE4V8YS9HCtlUc8Evaw1iJ/VpOB5cNOO7omiIgChC0m3HYzhWSB5b0kI34rtYb+N/W5rOwV8jjMRkJ2G0fZItd3DvF59C/zfpcds6TbvURcNhqqyqzfx3I8RbFWY9bqp1xpkDSV6LfaqKoNzAaRtNAhsjW1iwCKIpXWpeoTR7kR10mLJAhEvsbk7144MXo+iYE7qZobjca2SfpJq/hxtDwf1oQ6kUiwsrJyyoS6O6LuUUQuD4qTGcseAezh7UCPAPbwVEOSJGq1Gi+//DI+n4+ZmZnH+mv9jSqAR0dH3Lx5k+HhYUZHRx+qZXS/ApOTKmOz2eTSpUuYTKYHTvYA+PTHvsQrn12iqYnUaXCwkSE6EWZ98YjB6TDBkJnBMSM3ru5gthrQJBFRguEJH41GA6/HSjDi4tpVXeAxNRth/1Cv5g0MeVm8E0OSBObm+iiUaoQDDiwWvQ3stSuYjDI3b+zRaKq67UvQQawV+XZmJsJuTP9/tM/dFosIokCx0jn/k6MBbrSqf16XhaWt7tQP/eNMQOPMWJhcqcrcYBCDLKI1NSYCHo5zJQIOKzdbecATUT/L+zqxMxtl1g47834GY+c6Gh/Q/QEdZhOTfT7S2TxmTUQTZBZiWTQN3FYz2635R5tBZCeRYtrtpNLU+Mr6LhpwJhrkRuyIcZ9Hj5XbPcRtUVg4SvBcOExNVMkeV3l+IML1eIy5oJ9EpUTIY+WoVOBITqAZOuej0mX8bBAFaF1Ory65Kdf0bVbDo/niPW5omsb6+jqpVIoXXngBm81GqVRqVwdP8opPVMWPIwbuQUyom80mRqORyclJJiYm2tXBeDzO6urq22pCfTcqlQqqqvYIYA9vC3oEsIcnGm9Fbo6PjymVSkxPTxONRh/77M69ZgzX19fZ3Nzk7NmzjzRTdT9m0IVCgatXr+JwODhz5sypZJL7TfZoNpv86W//NQuvbaIZZIrlEqoGA2MhjvayzD4/xNrSIf6Ii5X5XVxuC8NTYY5TRXK5EjubGarVJv6whYWWUfP4ZJB4Is/EeBC7w0yhWCXisyMbRG7c3KPZVLFYjEgmiVyrGjg65qeRaLVdpyLcWtYrbX6vrT0HCFBtdEjNzFioHROnmGQOU3nCPgdWswG/x0axXEcAjEaJZK5E0G4hnSuTzpTZi+vk9OxEmButKqHHobDYJRhpds2XTkb9XG/l/Pb5HNzZT2CSJQb9LmRERjxuduIZDpNp9jI60fO77Rzk9TbrUMjN/PYhE0EvXpvCKxv7ZApZoh6lLV6p1Kqc9ftJFMusH+uVzImQh1S+zGGuwH61wHOhMBvZNIosk6iUEARYSCXod9soSp1rUQKqau3UbQBrZYBbRwJhrxEaVSzyoyV4PE6cVNWSySQXL15sV/osFgvRaJRoNHrPvGKPx9OuDj6O6v4bCUlOLG5OfliKoti2wIlGozQajbYJ9cLCAs1m85QJ9cM4DbwZii1Veo8A9vB2oEcAe3gqcSK8ODw8RJbltqHp40Z3m7Y7Q/jSpUuPPJj9VgQwkUhw48YNBgcHGR0dbVcqTtrH94Nqpcon/uNLbK7GyRWqaIYyh1t5Zp4fplxuEB70cu2rGwQiTqxOhb5+Dw6Platf3USSRcKDHpKpEm6vFa/fgd2uUK3U2N9LUSo2KGZLKHYz6XQJQRToG/TSPEnYGPFze6mlkh0Pstyq6tlsJjZ29aqb0SjRF3GhpI0YjRKqWqGpwpmxEADNpspgwEmhVCXa5+F6K03E57GyvZem0Xqu8VE/G3t6a3RqOMBSqxUsSyI7R5n2+egPuUi2WsHDEQ9rB/pjJElgN5XF57AQdNlwWE0YJYndRBaL0cDVVZ34Bp2mNvlz28xtSxiP1dzK7bVzmMyxm86iahp+u4XdYhmrUWbC4+R24pi6qjHis9Isa5wL+VnYT1Co1Tg/GCKgWVFFDVXTmA0EWMmmCDit9JvsHGopnEYz5YZOCizy6cqeKKigCbyyos9BVtVma78ngwBqmsbi4iLpdJqLFy++YSv17rziQqFAMplsK4VtNttjzys++Xdra4vj42POnTuHKIqvs5kRRRGfz3fPtS0vL2O1WtuqZ4fD8chrKxQKiKL4NW079/B3Bz0C2MNThxP/O1VVOX/+fHv27+3ASSWgXC4zPz+PLMu8613veuS4qZNj36u93J1cMjs7Szgcfqh5v3y6wP/vP/4lh7tpkCVqag2hYWTu0ijXXt5geDqEZJQZmw5TLNe5+do2o9NhFm7t4Q/YGRz1UyhW8HkteIMO7tzSidPEbIS9Q52EBCJWdnZ0McTwqJu1Tb2FOjjgIZMtMT7ix2SUMZpk5ibDNBpNrHYzO3vHqNUmQa+D6zd1nz8E8HoUkukykGduJtIWm9htJpa3Eu3XFvTbSWRann0RN8vbnW3FWmcubnokyM0W4XNYTW3bF4Ms4nNasJoNyKKIYjawsJ0gW6wgNOHOboKmqiEIcNTlI2g2yVDUK5RDITe1ehO1oWE2y1xZ18npMyNh5lvm0AMBF/2qk9VYioKqUVc13BYz6XqTEauVQj5PoVbDZzaSKZTYyxcYDLqwCAb2SzmidicIGqqgkWwUmTPbiRV00mq9y/evWMhjqkVZz+i1wHJDPw/WR8zwfRw4MSwvFApcvHjxvqt4giBgt9ux2+2njJ4fd16xpmmsrKxwdHTEhQsX2pXJt7KZOVHan6ztpDp448YNgHZl8GHXdmIB8ySpknv4+kGPAPbwROPuD75sNtuOsZqbm6NWq7Vned6OD0lJkiiXy7z88suP7Cl4N+5VAexWMj/33HM4nc6HIn/760f89w9+imQsS6FUo9aoI8omrDaFVDzPuUsjrC7HKObjTJyLkjnIMDkXQTJKeNwWHC6Fq69uoGkwdaaPpUWd0EzN6qTMbJYZHPaBIDAzY0NVm+TyZdxWmWKxQaVa5SiuE6e5uT7mr+sxU6Ggg9WtZLtKiNR5PSNRF+u7GUAnWtv7HbHH0ICXmy1VccBrY2mj08Y1WzofYxNDfpZ3T2b6JOqNJlMDfswGGYvFSCpbIpMvYzRIXF3cQ9MAAUIBB9mi3qruCzhJbOhVvunBAAu7rSqfzUiiVOdMv57msbZ3TL5cxSCLWKx6688oi2wk01iNBmYifpYPU2TLVcZCHlYTxwgazET8XNuPkdSaNA0w7HJgkmApk2PMbiaWzjHkcXBcr2N2SFS1BrHmMflGlaZm6bxuWabTANbtbF7djkArAbjc1P99pyuAzWaTmzdvUq1WuXjx4iP9eDIajafyirPZLMlk8nV5xX6//76J0wn5O3EPsFg65/hBbGZOKpehUOiUBc7Ozs7rIuruN0u5UCj0CGAPbxt6BLCHpwb7+/ssLi4yNjbG0NAQgiC0lbcP46d3PzjJGZ2ZmXlkT8G7cTcBrNVqXL9+nXq9zqVLlzCbzQ9F/ha/usr//C9fpFis0RQBg0Yx3WRwwkE2VyWTKlCqNTCZDUye7ec4WaRZbVAq19hdSuF0WUgk8mga+AI2GvUms3MRDAaJfLGG26FQLFZJp0scHekzfZPTYQ729Urg+FSA5TWdhFktMndaog0Am8PMYcv2ZXIiyJ2W6bMsCWQKHTozPhbgZstb0OVQWN7U9zPIIn0hJwaDhGIyYLUaaWoa50cjNFUVSRbpd+vZw8MRb9ss2mIygCRQrOjPMTMWREvqM4LTQwEWWpVBu8XU9gcEyJXKeC0yfrsNh8PG/PoBC5tHnB8Lk29Fw01HA1zf0Z9nLhpE02DlIElD09rxcQaDxKDbhd1o4OruIeV6g2cGQwiCwH42z3axyKTPS7xapKFpHBUKyILG7VgRn8NIWtHJdL0r61cRJWpdFplNdYitY135bJYlSi2LGMs7WAFsNptcv36dZrPJhQsXHrpCdy+Ioojb7cbtdj90XrGmaSwvL5NIJLhw4cIp8vdGz3m/NjN2u/2UBc6JzczOzg6SJJ2KqHujz65isdgzge7hbUOPAPbwxENVVZaXlzk4OOCZZ57B5/O1t518qD9uAnjynIlEAofD8djJH5yeLywUCszPz2Oz2XjmmWdObXsQ8ve3f/oaX/jTKxwnSzRFlVymzMBEH5JYYW87jSQLTJwfIH6Yw+gwcP2VTVRVY/rCIKtLh0SHffhCDor5KopRRrErrC3rs3tjM2HWV3UiNnO+n9ut9I7xiSDLrVat1W5iP5Zvryfc52Z1XSdUfr+J7d0UTrsRRTHSaNQJec04bFY8LWuWfr8TSRKpNVSmBv3U603cbgsbu8cIjSpuu4WbC/uoqs58xseCbXI4NuRjdV0nnoIgkOhq3Y4N+drqYb/beio5pFjvkKrRPg/JbBGv3YIoqNzZS1KqqahqhY1knkZTRZYEtpKZ1vNAPF9kPOhFkSQOUnli2QJmg8RqXG+HR70OTKLEcjLJueEQ5XoDt2KmUm+yGEtwfjBEECuiJLJXynO+L8xG5hiDWWZCMbKvpsi2hDH5SscoWxbgRF2iiGYWtxVAJ4CKwUCJFgF8hyqAjUaj3aZ99tln35YfaN14q7zibiGJoiivE6Q86Jzd3WQQeMPqoCzLhEIhIpFIu3KZSqXY3NxkYWGhXbn0er1YLJb2+/2EAD5qBfB3f/d3+cAHPsDh4SGzs7N88IMf5Ju+6ZvecP8vfOELvPjiiywsLBCJRPiZn/kZ3ve+9z3SGnp48tAjgD080ajValy5coV6vc7ly5df9wv9hBzdr5/e/T7njRs3qFarjI2NEY/H3/pBD4ETG5hkMsn169eJRqOMjY29Luz+fqCqKn/xoc+y8PI6tbpKU1SRTTKSwcz2SpzRMwMIBhmzw8z8VzbwBh2UyjWGJwK4PHbi8RxqQ8XuUJj/6iYAs89Gud2az5ua62NpqaWQHXCztHSIzWrCbjdhMhmYmgwhSSIWm4liqUazoepJIMk8QbeVSrWBhJFGuUq+3MSuSGys6QQprzQ4OMpRLOrVubm5PhZa1T+v28JOLEOjoZ8Pr8dKrJXs0R9xt8kfnFb0To8GWGhtM8oSmweddnLI7+AoV0QUYGooCAI8MxyiVm2yc5AmnS+zH8sS8pop1fTnHQq7ubahr2lmMMj1nRhuq8JUn4/tRIb1RIrZwQCxrJ4IMjUQYOEwzoX+MA1B5fpODItRZiWRYi4UwGo28NWdfXw2BUkQuHkYJ+Cx0W+zs5PLMOh2oYoaRSqkxUrb3qVGh6xWCkVovR0C1VHWah2SoMjySScYq/y1t4Gp1+vMz89jMBg4d+7c19xI+X7yigVBoFarPRT5uxvdQhJ46+qg0+nE7XYzNjZGuVxuVwdPKpder5fFxUVyudwjVwA/8YlP8K//9b/md3/3d/mGb/gGPvShD/Hud7+bxcXFe/6w3dzc5Nu//dt573vfy0c/+lG+/OUv8/73vx+/38/3fM/3PNJaeniy0COAPTzRyOVymEymN60gyLL82AhgdyXu0qVLJJPJB0rreBCIokgqlWJ5eZmZmRkikchDtXyrpSof+/d/zu5agtjeMSa3mWyyRGQ0TGRIIp+rcuPldWaeHyJ9XGLuQpRKtcHm6hGyQWRvN0OlXGdg2MedBV3IEBlwEzvMMjzqx2IxIhokpqdC1KoNNElA1qCUrTA85GuTxOigh8WlAzRN9+8LRVwcHGYAmJ3tayuCTSaRVKbT7vV6DOwenuQHm9tqYYBQ0ElyRa8uhgJ2lrrsYiyWDrEZiXpZb6mAESBT7FjJTI8GSOfKDPgdmE0GKvUGgz4XR6k8zXqTldbM4NnxMOm8XkHz2A0cZPVjmI0yq4ct4YVJxmyUmQ75WDtIcZQpcJDWCWmhpr8mWQSjJGKXjBwc54lX9ErkdH+ARkNl6TCOYjdhNRgY8Xl4ZXefC4MRjvIFHA4TlUIdURQQZZAMKpVih/TVhc61aDbIFAGlaeLzr5VwezoE2CRLHQL4NW4BV6tV5ufnURSFs2fPvuO5uvfKK7558ybZbBZRFHn11VfvK6/4QfBGNjOapr2uOniS0nNSucxkMmxubvJzP/dzJJNJvF4vv/Vbv8W3f/u3Mzo6+sBr+fVf/3V+/Md/nH/+z/85AB/84Af51Kc+xe/93u/x7//9v3/d/r//+79PNBrlgx/8IADT09NcuXKFX/3VX+0RwK8z9AhgD080/H4/LpfrTfeRJKn9gfooiMfj3Lx5k8HBQcbGxtqD3Y+zungCVVXJ5/PtwXiXy9X+gngQ8pc6SPPff+1/kornqdUbYBYREPEP+Fm5tcfY2QFEWeTZbxpjcyVOOlnA5lJYWzrEaJIRDTIWq27kbHWYsdpNlIpVak2NZCxHMpZjbDrE2i293Tt7foDbrf9H+t0sLuqkThAFmsBJEW5mNsLt1jar1cjWTie9IhS2s7Wjzw663RaOkh2yZnfKZA712x6XcorwuV2W9vxgf9jJUTJPJOBAMRrwuqxYFSMietzccbZMv8tOrlBh/yBDqmXQfGYqwkKLYA6EXG3yJ4oC+6lc+7kCPhfJ1raZwQBNVaVabSDJIq/e0QnvaMTTbvOOR7xsHWd4JhrGIIm82rKNOTca4nC3wJlIgN1klni+yPnhEEfFEkHFwrWDGGGblf1sjlKthqEk4rVbiJeKuB0mJLFzHQholJsd4uy020hVwFYYp6aWqHS9B9R6Rwn9tWwBVyqVtm/l7OzsO07+7saJ4KNSqfCud70Lk8l0z7ziEzJ4klf8KHgQE+qTuUav18vS0hK//Mu/zKc+9Sk++clP8tM//dOMjo62yfX9oFarcfXqVX7u537u1P3f+q3fyle+8pV7Publl1/mW7/1W0/d923f9m18+MMfpl6vP9Y5zh7eWfQIYA9PNO7nw/dRSZqmaWxubrK+vs7c3BzhcPixHfteqNfrbbFHX1/fQyt9165v8Se/8b8olxpsrcZwR51oTRFBMlKv1jn3DeNsLB1icZhZvL5HpVRj9oUhysU6s+cHkI0yG8tH5HNl/GEH11/bAmDmmSgLN3UCM322j6VWVTAYdrJ8R6/GCaKAaBDbs3jTsxEWFg8QBHC6FZKpAj6vDVkS6RtwE4vnsCgCitmAYlKYHlcQRAG73UyxVEUQBAyySE1VsStWarU6oqRilHSZrt1mJpUo4LaYKJfr2Mwm9vez5IChAQ+vXd9un5dov4ftVst3djLE7RMhiNnA6m4nzs1uM0FL7zE15Od2ay7Q61BAE3hmKEQmV2Y3liGZ0wnkcH8nr1Y26F/oLosZn93CUabAjc1DIn4HAG6rQiJfZDbgxyCJxPNFJFHAIEmkcyUC/X76BDtBh5X5wxjnB0Ls53MclYtE3Q6yQgVjF4GySAY0OhF7ogARQ4jP3yoCAo2u60YWRU6CgTPxBHt7e4/NRPmNUC6XuXr1Km63m5mZmSdOuappGgsLC2SzWS5cuNA+F2+UV7y1tXWqlez1eh/LHOMbVQe7W8bd+509e5aPfvSj5PN5Xn311QdqVyeTSZrN5usM64PBILFY7J6PicVi99y/0WiQTCZPfT728HSjRwB7eOrxKCSt2Wxy+/Zt0uk0zz//PE6n87Ed+14oFotcvXoVq9VKIBB4aLHHlU9d5/OfeJVaTSVfKmL1WzjeLzL+zBD7W0l8fR6uf2Udu1vBF3bhCTiQDTK35ndQmxrTzwxwo0X4pp4ZYKlV1RuZDLF4ax+b3YzHZ0VVNaZmIogimBQjXp+dZlPF7jRzdJQjEnAgGyUO9zMYRZF6vUlfyM1CizQGQg6uz+/QbOpEcXLGxZ0WiQyHHdxZibVJ5NRUmKVWuzcc0it8aqukaDTJJFL6fJ3fq7DSZQMjdUW2jQ35Wd05EYJAsksIMjrkbwtBAm5bWwjid1ppVMuM+WyomozTpXC9lRwyOxpia1tXCw9H3Ky3soH7vA7q9Qbn+oMUyjVeXt4FYHrAz8JhAsUgM9Pv47X1A2JaAa/HglmWuDAU4Uubu7gsCrVmk3S+TFGtM+P3s53NEPW4ECRQBZWbqSOe7e8IngyaRpfoF9BIbvnQ0MlpqdGp+tmsFsjoFU2vzc7h4eEpE2W/3/9YjIpPcHJdBwIBJicnn1jyl8vluHjx4hsmdnTnFauqSiaTIZFIsLa2xq1bt96WvGK4t82Mqqr81V/9VZt02u12/v7f//sP9Tx3/z3eyjbrXvvf6/4enm70CGAPTz0etgVcqVSYn59HFEUuX758zy+FboL2qEilUly/fp3+/n7Gx8dZXl4mHo9jMpkIBAL3XZ35nx/6LK986hbIIlvLh/hHPdiMCk6PkWtfWmX64jACMDoZoq5q3H51C2/IQbnaRG1qRAa97G6n6B/04HBbEWWJ6Vn9Cy9XqCKLAsVsiUDIwfJtncjNnO/nWoswujwWtrcblMs64Zg608fOnl5x6+t3t8UiAGZFbpO/gaiH5ZVO1cFmV1BbNjL9fW7urHa2OZ0Kh63YuEjYyW4rcxhAUYxoab0SFvAprHYZRHcLQaZGgyy2soINskgiXWQk7MGmGLBZTTiPTRwmc5hosrrbitxSjBzmCu1jZEqdipvJZMBtVRjyuxBFgfmW8fPMaBBaHe6a2uR8NEQyU+T6doxas8mZoSD5ag3ZLLKe0s/TdMTHV7f2ODcYolirIZtE7KqJpqYiCwLJRpmmptHUOjN/DrNCls7aqNq5uamfF6MkUlY77wGpq3I4EArx3NBE20Q5kUi0r/sTMvhmViRvhXw+z/z8PJFIpD068SRBVVUWFhbI5/NcuHDhvuPaRFHE4/Hg8XiYnJx82/OKT57zxB7qZ3/2Z0kmk3z0ox996OP5fD4kSXpdtS8ej79hjGUoFLrn/rIs4/V6H3otPTx56BHAHp5o3M+XycOIQDKZDNeuXcPn873prNKJUvdRjaZ3dnZYXl5menq6XV0YGBjAaDRydHTEysoKdrudQCDwhia2jXqD//b//STbdw4RjBLJRBp3v4utG3HOf8s09VqTMy+MsnR9l0a9yeTFIdZv7OEJ2hkYDVCrNWg2VfL5CoVMiWqpSlNDTwoBxs/2cdgictPnBlhsVQU9Pisba52Kmz/kZKVVxRsa9Z0ifLJRalf0+vodbG931LeSQWzPCA4NeVnpmu8zWwztbf197lNCELvdjHakE51IyMnOYWdWz6wYEI5LGIwiQY9CrVplctCHyWjAZJKYjQYolmp43Fau3dFfj9NuptioU6vr14zL0clZHRn0tqt/E4N+7uwnsSsmJiJe8tUa+VyFPTVDpqrPKfpdVhb34ojA+ZEwh5kC6wfHnB8Ns7edRxJ1S5aF3TjT0QALR3Gei0a4unuIURIpVGukiiWaInjsFspqDcVkZPFIJ7W5UqeCaTUaybYuc5NoYG+zM4ulGA2UuxTC3ZfOiQr4bhPlk+rW6uoqlUoFt9vdJjT322bMZrNcu3aNaDTKyMjIfT3ma4m7E0geReDRnVd8kgn8duQVq6rKL/zCL/Bnf/ZnfOELX2B8fPyhj2U0Grlw4QKf+cxn+O7v/u72/Z/5zGf4x//4H9/zMZcvX+Yv/uIvTt336U9/mosXL/bm/77O0COAPTz1eNA27Ymh9Pj4OIODg29K7CRJaiv3HoYAdnsYXrhwAbfb3W7xmM1mhoaGGBoaolarkUgk2ia2J1XBExFMIV3kv/zvn2BvNY7JqbC7foR/0IfZrHDum31c/9IaoUEv+XyVcNSDv99NLlPG4TTjDzm5/vI6AOPn+tnf1stV43P9LN5o2byc62/P+nn9djbW4igWAyaTgf5BL4l4Htkv4vJYKRSrjI0HEEQBq11h0mxEAKwtC5jpyRClUhFB1pgc9yOJEorVSKlSZ3YyBAgoFgMWRX+cyWygWm9wZiqMACgWIx6nTkCMRplKvcHcWAhV07BYTVhMBur1Jjarid1YBoMm0iypyD4DW/tZIE84oHCQ1BW9gihQ6vL6i/Z7uLGqv9awz8peUidZBllk87BVyfQ6cNsUxgMeNg+PqTfVtmCkP+giuamTxIjfQbBpJ5UpUq41OEzn9eMk04z63fgcVr66vgcC1LQGIx43DUHDKEuciQR4eXePZ6JhUqUyh/kcfT47i/lORbPSJfowSVJ7rm9CjZIqd6qdikFub9NfdOe/91IB313dutsmxWq1tquDb5S3m06nuX79OiMjI29bFvej4IT8FYvFRyZ/d0OW5bclr1jTNH75l3+Zj3/843z+859/JPJ3ghdffJEf+qEf4uLFi1y+fJk/+IM/YGdnp+3r9/M///Ps7+/zR3/0RwC8733v47d/+7d58cUXee9738vLL7/Mhz/8YT7+8Y8/8lp6eLLQI4A9PPEQBKE9g3Iv3G8L+EQBuLu7+zpD6Tc7Nuizgg/a4qnX69y4cYNKpcLly5ffNNnDaDS2Z4+azWa7VXfjxg3SBznm/687qE0R2W4itp8kMhZi83aM8WeH2FtPMPfCMLV6k0y6iNlq4tqX19A0mHluiMVr+nzazMUh4rEsIxNBHB4r9brKzLl+ZINIIV8lEnZSKddwuRSOEzk0DYaGfdy8qse4mUwyxVKN46Tehpw5298WjphMMha7ifSxPo/WP+RgZz0P5BBFAV/Q0U4NmZgMcfXKQfu1D4742GqR0sGoh1uLnW0TEyGWW5XCSNjJnbWjdqVwciJILq+3aAf63GztZ9qPkw1GTkyRI34ze601KyaZ1d0OwXK5bBykS4Q8NoYiHvLlGgdqFoMg8spt/XW77Eo7Q9hqNrBykMRqNjDZ52PnKEsyVyLic3DnQN9nLhpE1TRubR+hti6Zc9Eg2+kcjWaTEg28JjNLySQX+yNsZbMMeB0YTTKCUePwuNPm1QwytETShlZsXtDoZP4recItsQmA6W4C2IX7UQGfZNoODg5Sr9fb11933q7f728LIU7ybicmJujv73/L43+toaoqt27dolQqceHChcdK/u7G48or1jSN//Af/gMf/vCH+dznPsf09PRjWd/3f//3k0ql+KVf+iUODw+Zm5vjpZdeapP2w8NDdnZ22vsPDw/z0ksv8VM/9VP8zu/8DpFIhN/8zd/sWcB8HaJHAHt46nE/LeATMlYul7l8+fJ9D3CfkL5ms/lA7Y9SqcTVq1dRFIUXXnjhVJXyrcQeJ5migUCAG19Y5LOfeI3D3TTWoIVcoozdbyd9VGDm0gjxgyylQoVUosDhdoq+ET+JWI7B8SBOr416vcnwRBCTYmD5xi7NhkqjauUolqOYryCIAtGxANtrOnmZfmaAxZavn92psLvTaeGOzYRZaG1zuS2n2sLj0yFut5TDRpNIJtsRJEzNRtqiEEEUyOY7c3Vj40FWuwUdho6go7/P3SZ/oM8FHsR1EhkKOk61iRVrZ65raMDD5v5x+3ZT6HzMeVwSmWKDoYAdj8tOqVrHZTaRSBTQNDhqka9QwNFWCA9G3Fxbb4lChoJU6g1WdpNoKm11sNtlYT+f41w0RCxT4DCdZzziZSWZ4mI0TLJSJl0sc2m8n5WjFAMBJ05NoSGo+BWFhqpiQKVQ6U73hVKzcx7l1jVjjfuoNbJUu655o3zaaFntkotYDQ9GfgwGA6FQiFAodCpvd319nVu3bmG1WikWi4yNjT2x5O/mzZtUKpW3nfzdCw+TV6xpGv/pP/0nfud3fofPfvaznDlz5rGu6f3vfz/vf//777ntIx/5yOvu++Zv/mbm5+cf6xp6ePLQI4A9PPWQJIl6l+/Z3SgWi8zPz2OxWLh06dIDEbkTsvYgZtDHx8dcu3aNSCTC5OTkKa+vB6kifuG/v8wX/uRVkGQcATvxnQzDZ6Mc7R5jtBq4+dVNEGD82X5EQcIbcpI8ypNJ5pEkgWS8QCFXxuZQMCgGmg0VQRJw+uxsrZ1EukVZuK5XCH1BO+srHVIVjnpZXmy1Ogc8LLWi3wCCERd3Wtt8ATt3uuYAx6bCLLTEI4piYHe3Q8amp8MsnOwrQLnaITzDQz7WNzvVOcXa+eIOB50sdxFOt8vSFomEgg6WNzrrNplkvC4LDqsZr8dCva7itVnJZgtks1VKpSalXB61WWc3qZPRiSEfd3b1KmTAbWNpR38uxSRzlC7wzHCIXL7C6n6KdL6MySCxfqS/Lq/DQrPZpM/hQNU0DlvG0FaLkTGfh2K9zmYyw0zIx+39OJVmAxA4yudxWM24nWYaqKSrFSr1TvVPQDul7BVFgWlTP1fu6POQ5a62tkE6fV11i2EexQj67rzdnZ0dVlZWsFqtrK2tcXBwcKpV/E77/t1N/t7pmbW7z1+5XG4LSTY2NviTP/kTisUiHo+HT3ziE3zmM5/h/Pnz7+iae/i7gx4B7OGJx/20gCuVyj23ncSsDQwMMDEx8VBzfA8yY7i3t8fS0hJTU1P09/e37RwexOJFVVU+9st/xtr1LbaWDvCP+SiXagzODLD4yhYTzwxitJowmhREo8jK/D6SLOIM2TmOFTGYJExWE6nkMbJRZGg6RPa4iDdgx+G1US7XmD0/gNEkU601mJqLoKoaJsWIs1hF0zScHhvHxwWGh70IAig2M4pZRhDA7rJQyFeYnAzq/n0mEZOxiVlRsDusNFSNudkIAFabmUKxgqbpJtGyLDE1rrdIbXYT2XyV0SE9rsvpUhjGiyAIWCwGStUG48N+BEHA5bbgcimIgoDBINHUNM5ORFA1FYvFiM1spFypY1GMrK3GUTWNdLKIgMBmi9gNhC3kSzppcjrMHHVVKZPZTn6xx22mpjUY8LuwmI28emeXo6Mcc+Mh1lsZwJODfm5sxRgLe/HYFV5Z1SujglH/Gz87HGZpP0mpWmek38Oz/WEEWaCYqPHC2ABf2dzl2eEw2VqN43IFj93Erf0EUz5bV4KHkSqdNUoIbN7sXCfFeoc8y3cRr0aXevhxGUEfHBywtrbGuXPn8Pv9NBqNU6MKAF6vt90q/lqTL1VVuXHjBrVa7Ykgf/eCoigMDAwwMDBAs9mkXC7zB3/wB7z00ks0Gg1+8Rd/ke/4ju/gu77ru4hEIu/0cnv4OkePAPbw1ONeM4CaprG9vc3q6iqzs7OP9GF6PwRQ0zSWl5fZ39/n2WefxePxPJS5c6VY5Y9+8Y+JbSepN5rYQna2bsY4/y0zVEp1Jp8dZGs1QbVcY/bSKAtXtrC5FMbODZDPlLA7zTRRKWZKKIrEwESQ2605vcHxANdeXkdtahiMEt6Qg1hrbm7m2Si3rupmyorVyPFxkfSxLo6YOT/QFotIkoAv5CR2oFehBobd7C5lWqsvMj5jaCuEXR4LpWKdWk3/28ye6+fWNX3W6O65wNGxANevduaQxiaDbLba0sGgg/WNeFtdPDMTaWcF+3w2jrOl9rbJqVDbO3BowNsmfwhQVTtt0mi/u+0JODLgZTOWJhpwYJEFUskc2WyNfDaG3WHWjy1AIl9qrR0kUWAs4OEomWf3WD8Xk1EfqVKZ6aCPSqNJqVpnNOTBIhtYPkhgsMicjYRYiie5PDzAWuaYfr8Tg6xxo2W7YbYoUNHPp9VooJORAmraTDytny9JFKg2uhMkTl9fdbV58rIfCwHc3d1ldXWV8+fP4/HoZtiyLBMMBgkGg2ia9rpWp8vlOtXqfDvRbDa5ceMGjUaDZ5999okkf3dDFEWSySSvvvoqL730En6/n5deeok//uM/xm6380M/9EPv9BJ7+DpHjwD28NTj7hnAE9+vZDLJc88995ZRcm+FtyKAjUaDGzduUCqVuHTpEoqiPBT5S+4f81s/8WEESWbl2haBST9ms4nZy+Nc+8IyoWE/miASHQ9g99rIJAs4nAoDE2Gu/62u8p15bpjFeZ3IhYfdrN7WSY7JIpNOl1BbnnzjZ/pYbLV+/WEna0sd36+hiWB7DtDlsbSJGMDkmX4WWmRQlARyrRk4gKFRf5v8AYQj7ray2GYzsdHV3p2a0ZNDTlCtd87vwICH1e52r8dCrNXu9Xpt3FnttHuDAQfJtE5UA37bqZlBg7FTFZsYCbDc8gtUTDL7iRzj/T4sJgOSLGLWRPb3spyZjpDcPzF+drIa0//f77eyny4wN+DHqph4ZUU/B+cmwlzbPEQSBdxWhe1YBqMgsZfMEXTYMBtkbm4f8cxYmGK1jiALjLhdlNU6/U47zUadbKlAtqmT5EbX7J5FNnDcKuQNKW7KndOFxWigRqcCeDcBrLWuV7MsP7Iv39bWFpubmzz77LNv+F4SBAGXy4XL5WJsbKzd6jwxUVYUpU0GXS7XY20Vd5O/Z5555qkgf5qm8bGPfYyf/dmf5ZOf/CTf/M3fDMDMzAz/5t/8m3d4dT38XUGPAPbwxOOtvsC6CVq1WuXatWtomtZW3j4q3swMulQqMT8/j8lk4oUXXjhFRh+E/G3c2OZj/8efgiRTKlewhx3s3Ixz9punqFYanPumCY72sxztpLC7LFz/0hpqU2Xy2UEWruiEb3g6xOrCHg6PBbvTgtWhoExYQNAwKCL5XBmL3YZiM1GtVJk604cgCChWE75SDQ0No8lApVpnbDJIs6nh8tqIHWSw2IwYDRI7m50otcignb1tvXUqiAK1ropUpN/Nctdc4OCon9utGUKDQeQg1jF2Hp8IstJF+ExK5ws8ELCz3EX4QsEO4XO5lFNCEJ/PTqwl4ggHHaxsJpElgYDXjsNq5txEmHq9iUUxcnVxl+N4gUjQyX5SJ5dGg8TmYWdesdwiX0G3FbfNwnG2wtJGHI/H3H4dG0fHTEV0IvnVOzqh9rgsOB1mGo0mt/fiOBUTx8Uy++k854ZDHGbzWK0mzCaBYrHAptap89W6zJzNsgQ1kAQB07aZuthl+2I0kKl1CUbuusxOBCInHoAPA03T2NjYYHd3lwsXLuBwON76QSfr62p1nnjmJRIJbt26haqqp1rFjyLSaDabXL9+nWazybPPPvtYotrebmiaxh//8R/z4osv8id/8id8y7d8yzu9pB7+juLJf7f00MNb4KQFfGJK63a7mZuba1u4PI7j30sEkk6nmZ+fJxwOMzk52c70BJ203i/5e/mTV/kfv/aXmB0WNhf28A578fjd9A31cfMrqzg8NmSridRhlv7xAI2GyviZPsw2E7Vqk+GpIJIokEqVqFcaNOsqbp+DlVYVb/rCIEstKxiLzUgh2yCfadmnjLtZuqFvMxglXD47iVirLTsd5trLG+11TsxFONxNI4oCDpeJelEjEnJgNMr4Qk7yuQqz02EEUcRsNeJ2W1BV3T+xXmswNOil3mjiDzrY3k5hs5mo1RqUyh0iEx30sLreIYNer42jpE4yXS6Fta0EVsWIySQzPOwjdVzEaJAwGSUEQeDseJhatU6tUcZpMlAo1VAMMldv7LT+lgJ2l9K2knG7LG0CODEa4GYrN3h8yIfZIGMKiGgC3NrQq4ejA15WWnFw/S4T1YbKyk6S0QE3AD6nBVGDW1txpocD9Lnt9HudvLy1x/Njfbyyuc+FkQiZcolytYzNYaPSVUWtNDsE0NgSdjxrHODWdorhaCeH2GyQ6SoAcveEbLmlHn5YAYimaW2Rx8WLF7HZbG/9oDfA3Z55uVyORCLB9vY2CwsL91TF3g9OyJ+qqk8N+QP4sz/7M37iJ36CT3ziE3zbt33bO72cHv4O4+l4x/TQw5tAlmWq1Sqvvvoqo6OjDA8PP9Y4qnu1gE/MpCcnJxkYGHgosQfAS//5c3zhv38VWTFRrJSxhxzs30ky9w0e1m7uMjLXj91ro5Ar43BbScay5NMl3AE7KgLZ4yIGk0xgwEc6oROlqWejLLbm6UJRD2uLnUpc32iQlVbChz/i5HCnk6oRjNrZ22hVw0xyewYQYGQyyEqrZaupGuF+H3daSl+TWSadKZNN60RmdDLIwq299mOnz/SxsqCvwawYyKfL5FtWMJMzYe4sx5BFAVkWUQwyNllCEMDrtbO3kcAiiqhNjWjQxe3FA+qAwWFm4fY+1apOmObm+rjZel02q0yxrrbnAuUua5nJsSC313SS53Ep3NnUyaYgCJSqdc6NhCiX62gNjVsts+fJsa7ILFkk7LYTsCsc5ovEM2X8TjNrsTRBqxGHWeLGZoyI105TVamU69xJ6FYwq/FjXhjuYy2VwmYAt9tJ5a5OaLfq1yCJRMwOll/JAFDpmnN9ne2LdvoHSrm174NawEBnnjUej3Px4sXHOr8nCAJOpxOn08nY2BiVSqXdKj4xQD8hg28Wr9ZsNtuV/meeeeapIX9/+Zd/yb/4F/+Cj370o7znPe95p5fTw99xPB3vmh56eANomsb+/j71ep1nn32WQCDw2J+jmwDebSbt9Xofat6vXmvw+z/1X9ldOaCpQmwrhi3gwOlyMjDWz+F2imazSa3e5PrfrmBzWVAcFvLpEibFgOJQiO9ncLgtDM/2kzrKMTgWwO62UC7XGZsNgyBgtZuxORRUTcPusnCcLBCJemjUG7j9Ngr5Ms1Gk3DUw8FWpy3r77Oyt6UTSkkWT8369Q15WV7oDKSNToXbc4GCKJyq6IUizrZdDOjijhO/QEEUyOR0s2ZV1QhFXKwsd2YIo0Mmdvb0apvDoZxqEw8OernZIqQ2q+lU1TAccbGyqYs/ImEnKyezhwKk8+XO8fu8FMs1FKOMwSBxZUF/DQNhF9sttW/Ib+dOyxJmfMCHURDZTOTxORTiGZ0gh4MuIqrAZuyYrRZptogNVvfzjEVcGI1GVEEj6naSLhZxywIOl4OrsThn+k/nsRa6lL2SKOA+tHNc09dyyvblLgLYbfsiCp1K4oMKQDRNY3FxkXQ6zXPPPXffkXAPC7PZTH9/P/39/TSbzXar+CRe7aRV7PP52q3iRqPRNlh+9tlnH1ul/+3G//pf/4sf+7Ef4w//8A9PxbL10MM7hR4B7OGJxxuRqkajwc2bN8nlcoii+LaQP+gQwJPnKxQKXLp0CYvF8lDkL5cq8If/n0+wu3JIuVxDNIM74uZo85hAxM+1LywjGyUmLg5TLlaZeX4Yg8lIuVRFsRqxOixsLB3QqDboPzfAjS+vAuANOkge6QbPoLd+b7RauO6AndjOMaWCPm82+9wQC/OdtqgsSjidCmbFiC/ooFAqMzzqptGsI5lEKqUGkQE7miZht5sRJZFmQ8Xjs7HaJfyYmou0hR8ANoeFw1Z2r81uYr1bUDIdYqnrsd2VOp/fzkqXJ2F0yMutBZ04WiwG1rY6s4hDw752eojVamzFwelwOi3sx3PIksD0eBBVA69doVSqsbp2RKmiV9wGBjrtVZvDBK3D+zw2HHYFtaFilCVut/wGsy3D5pmon/14jmS2xLmJMEv7cZ4f6uO17QN9Lk9VWdiLE/VaKDWaiLKGz+fiqFKhqWoIXdxFFKDYVQE0l00srnXIc6l+ujrYjXq37YvBQK6lH34QAnh3bu7jmJ99EEiShN/vx+/3o2ka+XyeRCLB7u4ui4uLOBwOPB4PyWQSWZZ55plnnhry97nPfY4f/uEf5kMf+hD/9J/+03d6OT30APQIYA9PKbrFFxcuXODLX/7yQ+f1vhVEUaRarfLKK69gMBh44YUXMBgMDyX22Fs55Nf+2e9jddkol6rkjgsYLGYkSePs/zZFtdpgcDqEyaqw+MoGgigwdn6QxSs6yZt9Qbd+ARiaDrPcmt+TZAnFYSHVmlUbP9vfnvtDAKfbylZCJy/BfjcrXabOk+ejbTIoiAKySWa3dRyHR6FUqNGo6wQjFLWxfF1PB7FajfT1u8hly5hMBowmCckgMTsboalqyEaJ9HEJr9dGsVRlcMTPQqtNK0oCqa4Wc3TIy3pXhS8QdJBM6YIOq/10hW94NNAmfCaTzHqrjWs2y0yNh8jky5iNMmajTKFSo89tI54sUCrU2NjRK4NnZvsotdJCRqJe1lr/93msLG3F8TgUhsIeduMZEukiPreV5JFePRwf9JGt1JiO+DAYJJLZElaTgVy5is9ipao1EQR4fnyAL6/tcmE0zLXdGIMeMw1Bo1AssF3UK6pqV+XObjJx3DIB7LPYETrcD0GAcq3LFPqu663eNaJglmVyLWHJ/c4ANptNbt26Rblcfuy5uQ8DQRBwOBw4HA5GR0epVqscHR2xvr5Oo9HAZDKxsrLSbhU/yUTwi1/8Ij/wAz/Ab/3Wb/GDP/iDb8tnVA89PAx6BLCHpw6pVIrr16+3kzZOiFiz2XxbZoEajQZHR0dEIhGmpqbQNI1Go9EWetzvB/qtv73Df/v3f47ZprC3FsPqVwiPhUjuZQiN+bn2xWUApi+NcadF8mZeGGV37YjggIfAgJdCvszYXB+SQcJgNjDWMly2u63kMmXGZiMIgi4KiAx6qVbrRKJebl/VjydIAgazgXpNP2f+sJOV252K3dT5fpZudOb3FJtELq2TP5NioFToEBaTVeTWfMe7b/b8ADdanoMA0bEA+1s64XJ5LGzeOcRhMWA2G+kf9pE+LuIc8SNJIhabCbtiBEHAYJRoqCpnZiJogNVuptgyqBZFUBsa08N+6nUV2aSxf5jHLIqIdY3l5RjFYqvKOdfHcquKGB3wtMmfLAtsH3Yi7k7i52wWI2NRH650kY2dFM2gSiJ90uZ1El8v4bSacVrNbOwfUzJVqYj6uTkzGmJ+7QC7xchmIs1EwMtq/JiJkJflWJIhp0IBkaDLxkY+037udLbzf6XV1pUEAW/MTEPsquqZDGS7TKGFu2xfqs1u9bDMya73owI+EVM0Gg0uXrz4RNqoiKJILBbD6XQyNzfXFpIsLS1Rq9VOtYpNJtNbH/BrhJdffpnv+77v4wMf+AA/+qM/2iN/PTxR6BHAHp54nHxoaprG7u4uy8vLTE9Pvy6H9O0ggAcHByQSCVwuF9PT022xhyAID+Rl9uk//AJ/8p9eIjwe4mArjmAQKabrHK7tcuZ/m6RUqDLz/AiK3UzuuER4yIe/z82tl9fRNA23z87SlU0a9SYGo0Rw0Mdey1R54pkoV/5GJ4+CJBIdD7G9qpO6UNTLnWvbaA0Vi83ExNkBUvEcY1NBZIOMYjfjC9Wo15s0a00yqQKCCJoKgX4bR7udKt3YdJiFrqqi1W7jOKWTLbNFYmXpoGvfEKvLnapdZMDN4q19KNcplWo0gVRSr/ANDntPWcZMn+1jsdVGtliMaKJAqaS3XOfO9LGw0Kkimm1GCkWd7czNRdqVQZvNdCpjuDtWbmIs1BaCDPW5MRtkJvq9JFIFri/tU6k2MJtk1vd1wmizmthNZDk/EqZQrvLakk6Qh6NetuNpxgJu7uwmqDWaDPd5OEjlMRhlXKIZrVHDbZSRbAojNgvxQpHjcie1RrHZ4Fi/rTVqIMMZ3GxtZpga7ow0WExGsm8Sd1jpqgCaZKlDAN+CzJ3M0wFcuHDhiRRT1Ot15ufnMRqNnD17FkmS8Pl8+Hx6gkyhUCCZTLK/v8/S0hJ2u70tJLHb7e8Y6Xrttdf4nu/5Hn7lV36Ff/kv/2WP/PXwxOHJe7f30MM9oKoqS0tLHB0dcfHiRdxud3vbSQv2fuPa7geaprG6usrOzg6hUKhtBfMwsW5//B//kr/9v17BO+Bl6dV1vINugoNByvkKQ7P93PzyGgCz3zDOfIvITVwYapM/b8jJcbJAo2WWPHp2gDutylug381OV+t05sIQC61ED9mgq2lPqn0Ot5XbV7bax5m+MMi11nMDTJ7tZ3PlCEEUcLiMOKw2XNMOZKOEbJCoVBv0D3rIpEv0DXm50zXrNzweZqkl7kCEeKIzh+cL2FjpIngTMxEWu6qOUpegweO1nhKCDI8F2v6BkiSyf5Bpb+vrt7O9X2htE9jr2jY05ONWi5AG/DZWWi1kj9OC2ShzZjREIpnHqpja+52ZiXBjRV/n+IifG2uHuO0KU0MBrq8ecDN1wNRECACTUUISBBqVJrJBIlOsMBb2sLyXIl+p4PNY2TtIE/Ao2Gw2JFEiX6lRa55W6za6WsAehxOjamTnVV18k852zqHZ0CF1cA/bl1Pq4c75fLMZwBNiZTAYOHfu3BPZRu0mf+fOnXvdjy5BELDb7djtdoaHh6nVam1V8fb2NrIst8mgx+P5mr3Ga9eu8V3f9V38wi/8Av/qX/2rHvnr4YlEjwD28MSjWq3y2muv0Ww2uXz58j2VibIsvy4O7mHRaDS4desWuVyOS5cucXR0RDKZpFKpYDabHyjW7dd+/EMcbhzh6fNwsHmEK+wge1QitnbMzOVxbn1lHZvLwsiZfor5KhPPDGK2mWg2VGaeG0aQBERZbpM2xW6mUqwy+9wQoLdz3cUqjXoTk2IgfpjBbDFSKdWYODfAYosMipKAZJDax3H5bGx1GSyPTIdZbs3naapG31CQxZNqHzA2G2atReIMRon0UY6Az4bNbsbhsdJoqMzM9VGrN7DazaytxRHQ0BAwmDQaDZ34yAaRw4MOsRkc8bHRRWBD/W5SLcJnNstsbafa2yanQyyeKIoFKNc6f4fJyVA7Hs5olNg/zBAJOnDaLTidCi57kXg8j99lZb41N+l2KSy35gcNssjWQbp9rpqqypnBEFu7KRY2jyhX6gQ8NpZ24oQ9dgZDLr66tIsoCuxn8jwzFEKTBFbix5wbDnJzK8ZowMZBscaU30QTlVe3D5iM+E5dI922LyZZorYi0XKvQTQYoSXmqFdPZ113zw7CaYGI3E0A36ACWKvVuHr1KoqicPbs2ceazPG4UK/XuXr1Kmaz+b7XaDQaiUQiRCIRVFUlnU6TSCRYXl6mWq3i8XjareK3S+Ry69YtvvM7v5Of+Zmf4cUXX+yRvx6eWPQIYA9PPOr1OhaLhenp6TdsUd1PXu/9oFKpMD8/jyRJXLp0CYPBgMfj4ejoiC9/+cu4XK62qe2bfYEk94/5z//2Y2zc2MYRdHL7Syv0T4Vw+pz4I6DYFPY24hiMEn1jQW5/dQNN1QgOetlbj1PKVxBEgZEzUdZvbwIwOBVm+fouzVbixtSFIRb+dgUAq8OMUTG2vQBH5/qI7x4zOOrHbDHi8Fgp5itY5iIU81UcXht3ugygM60EDQBvwHHKO3B0OtQmfwATc/0stNrPicMsY7N9HXJokLC5LBRTJSRJZHjcT6lcJdrvQENFNgk0myIelxtRkrE5LaBqNOpNRFkkfpTD7jCjNTVGxv2srMaxWAyIgkChUMFulzEaDfT3+yiUavjcFiRRwCBLzI4FqZTrOD0WbtzaJ6NqlBw11jcT1E+Ir7/jadfX7ybVIo0TY0E29485OxbCbJJ57bbe5p2bDnNjXd8nFHIQUh3c2Yy3s3ZnRoI0VY213SR1k8CZPj+7iWMcJplUtclQ0MVBOsdxi8AZDacrUMUu2xdP0cT6UUcl3V0tdDhskO6klGTyHf9GkyxR0roIYNd84L1mAE+ucZvNxtzc3BNJ/mq1GvPz8yiKwpkzZx5qjaIo4vV68Xq9aJpGsVgkmUxyeHjInTt3sNls7eqgw+F4LERtcXGR97znPfzkT/4kP/dzP9cjfz080egRwB6eeNjtds6cOfOm+zwOApjJZLh27Rp+v5/p6WlAnyu02Ww8//zzVKtV4vE48XiclZUV7HZ7mwx2m+Wuzm/yqz/6e9jcVgIjPhIHKQbnIhysp9hdjjN9aZz5v7mDpmmMnh9k/fY+mqrh8tmo15uUTmxcnh9l8TWd/Ll8NtLJwinyd6eV+QsQGfGz2kr+UGwm0skix/E8ycMs4UEv60uH7erfxLkB7lzdwuow4/bZcQdtpJJphid9NBtgdVpIXmt5AEpC27QZwOG2sH6nK+JtPHCKHI7PRVi4vtc6dyqCJHCwq1fWjCYZk2Ikn9XVtN6gwtpSpwo5c76fvVYV0mCU2FlLUs3pFbDRyQBrbQuZGmaTif09/bgTUyEWWi1lURJxlqptE+jooKc9FxiNethsCUEUs4G17RSKSWa4z4OgajRKDRaWDunr18cLBAEO03kkUeDMaIjN3TTZQoXZiRA3t2IMh9xkCxV24hnOTkVoNppk8jmaCEz0BzjKFyg3G4Tddra3dcIm3UVkcq04twvuEM3E6eu32BX1ZjKeruQJXT+E7q7xdSuE764Alstlrl69itvtZmZm5okkKCfVSYvF8tDk724IgoDNZsNmszE0NEStViOVSpFIJJifn0cUxVOt4oeZhVxeXuY973kP733ve/l3/+7fPZHntoceutEjgD18XeAkDu5hcXh4yO3btxkfHycajaKqKlqrzXbyBWQ2m4lGo0SjUWq1GolEgng8zsbGBoqi4Pf72bka469+//OoTZXMcZ7jW1lGnolSr2sMzfZjdVmoV5tMXhhEsSmkk3kC/W5EScComMimCngCdgYmQxxupYhEPZgUI4pToVFv0jfsw2Q2UG+oTJwboFqu4fBaWbzSIYPRCb1SCHo7U5TENvmzORQOd/RKUjFXwWw1cPBaCrWpAVlGZyMsvbaFxWrEE3AQHvJSKlbxeKwUChVcXhu3T5S/AnQn5FlsRrbWO/58A8NeVrvJ4Uy4TQ71tThIJnRSp1hllrtFJFOhzpygAMlkp208NhFktattXC53ql8Tk0EWW8pfs0lmo6uFbG4JQYI+O4NRD+l0ie3dYzRVY6E1dzg67GN1V3/M5FgQURQQ66AhkC1UdDPpUplnRsLUmk1u78YxGURq1TqLO0kG+x046pAslfDYLVTrDZYTnTUIXVxGMcjk1Tr9Njv7ryaZ7BJ9CAKUql22L3epfrUuUmQxG8l2VQBLpY5wx9o1A1gsFrl69SqBQIDJycknkqCckD+r1fq2VieNRiPhcJhwOIyqqmQyGRKJBKurq5TL5VOt4vsxw15fX+c973kPP/iDP8gv//IvP5Hntoce7kaPAPbwxON+PkxlWX6oCuBJ5unW1hbnzp3D7/ffl7mz0Wikr6+Pvr4+Go0GqVSKP/7Vv+RLH7+Cq8+OJaBQLdaZ/aYJ7ry2RbOhMvX8CDf/dgW1qRIZC7Kzprd6JVliaLaPjdbs29BMhNtf3aB5ItZ4fpTFV/VKoNlixOG1EW9Vv0JDXu5cTaI2mri8NoZnwpQKNWafjdJoqFgcJu502br0jfrb5BABELQW+dOrbtmWN1+5WCOfKXF8JU+5qFeiIoMeFq9s43CYcXtt+PtclMt1JmcjlEs1nD4rN690bGEMxs7Hi1kxsN1FDofGA2yud9qdw+MhXSWMTna2tzoELxhWiB11qpCNrtboyKifjc3OcbMto2uAsfEgS6sxon1uPG6Fal3FazVzHM/TqDc5zuhefJV613UjChgNElNDfvLVOhu7KcwmmcKBTrBmRoJkSxVurBwSjbpx2RSGw06ubhwxGnaSrzQJBezEMnl8DivXtw5oKJ1rSO2Sb9hMRuqShn1XIFZtnkrzsBgN5LptX+66Drtj4awmI1Q6pE/sMone29hkW5WwWq0sLCwQiUQYGxt7IglKtVrl6tWrX/PWtCiKeDwePB4Pk5OT7Vbx0dERy8vLWK3WdnXQ6XS+7txtbW3xnve8h3/yT/4JH/jAB57IlnoPPdwLPQLYw9cFHqYFfGJ+m81muXTpEjab7aGSPTQV/vwDn+Hmp5bxD/hI7KaoltJEZgIsvrKB2WqifypEqVhjcDqCQTFgMBuxuvW2scNrIxPPE50MIkgS9VoDWRZp1ptMPz/CUsvDDyA6GWbluk6yDCYZNKi38nBRNVau71FsxatFhn2s3d6j2Wji9NoYnolQq9SZOt/PcTKLUZHZW8u0jz1xtp+Fqx0CFxn2ced6RwhiNBvRVI18pkypUKVQrJE60lubLq+F2G4Ksyzg9tkID7ipVBrMne2j2dSwOszs76YRRCjkKmh0zq3DqbDWlfoxORtp28AA1BodYjQw6GGzi/AJooiAhtNpYWDAQ62p4p0O02yoFHNlxIbK3nYKhz3CUqt1PT0TYXG1ZQMT9bDRipsb7HdjNRlQRIliqcbGgX7/+GiA5Z0E50dDZGs19o6yjEa91DUVuamxvJ/Eb1doCCKZYh6lZMDnsPDa6h52xUxK6yKvahfJMxmINmys7Mdb27p8/8xGcpUOAdTuuhTfLBbOrChQ1H8gRHw+YrEYuVyu7e+XzWbvSWTeSZyQP7vdzuzs7DtKoqxWK1arlcHBQer1ertVfBI/5/P5yGazTE9PUyqV+I7v+A7e/e538xu/8Rs98tfDU4UeAezhqYAgCO2W7L3woASwUqm0P9BfeOEFjEbjQ8e6/Yf/+28T20zgH/JSKpcIjvrxhbxsLuwjCgK+qJuNG/uoTQ2rx4LBZCQT12fsZi+PcfWziwAodhNOr4OjXZ14DM/2kdg7ZmDUj9lqwumzUcpXGJ3ro5At4Q25WGwZRiMIeMJONlrESZJFEIT2zGClVGVnJcZx63kVmwFRMuB0mPGGHDjcVmr1Jv1DXo4OMgT73e2UEYCx2cgpYcjE2QEWr3XIYjjqZam1f2wvjcEks7uhEzWLzQSC0I6hG54MkjjIEPTZMJkNBCJO8rkyoiTqamVRZGTISb3RwOd3U6k28Drr1Go10Kr0By0IgoTdYSF2lEPSBLKpIh63lY1WgsnUbKStIHbYzadyhDNdecBmq4npkQDNuorBLLfzhQMRJwCiCLIoYpVlcsUqG3GdWHmdFq4s7RH2mTGICn6XjdsHcS5M9LOZOKbSaKJqGjbFSKrL96/bsLlftnHzSieRpdad5mGUoUv4e/e1X36TWLjuKqPP4SIT32B0dBSLxdImMt0zb16v9x21gDkhfw6Hg9nZ2SeKmBoMBkKhEKFQCFVVyWazJJNJfuVXfoUvf/nLBAIB+vv7+emf/um3lfx98Ytf5AMf+ABXr17l8PCQP/3TP+W7vuu73vQxX/jCF3jxxRfbld+f+Zmf4X3ve9/btsYenj70CGAPXxd4EBuYbDbL/Pw8Xq+X2dlZgIeOdfu9f/1HbN3eJTwZYuW1LTRNY/YbJ5n/nE7qxi8Ms7l4oJM/p4LJauL4QK+aDcwGWXhlHdANnCMjwXYb2Om1cRzPkW2ZJQ+MB9lc2G/P8o0/M8jSlU18QSdOnw1P0Ek+U6JvxE98P83EuYF2ZBzA6Gw/i92VxPFIuxWcPS4ydqaPtYUTIYWAzWZifDqMwSRTrTbQVA3dfU7AYjOx3R3bFnGdipYbm4mcEoYMTwQ7BtKAqkE+VyGfq2BzKMSPMlQr+t9u8kwfizc684wGWWGz5eEX7ndxeJjnhAuFBuqk0+X2thPyB5DtEq4MDHnbQpCxsQDbh2kmRwLYFCNLazFK5Tpej5Xjsk5QIyEnK1sJRvu9eN0WXr2tr90XtGNXTEwN+nllYRcEcLjsbOylMduMTIb97KYzDHhdvLLVEuSYDdDhm5Rb1+ikxwuHp42dq11VPZPx9Edzd3tYlgSqXWRRuosANrsqiRt37vD81AwDAwP6OWsRmZOZt5WVlVP2KH6//2uapFGpVLh69Soul+uJFaWcQBRF3G43brebP/zDP+R7v/d7MZvNWCwWZmdnGRsb49d//df5h//wHz725y4Wi5w7d44f+7Ef43u+53vecv/NzU2+/du/nfe+97189KMf5ctf/jLvf//78fv99/X4Hv5uoEcAe/i6wP1WAGOxGLdu3WJ0dJShoaF7ij3uBze/sMgHfuT3MFtNDJztI5cpMHZhELvHQe64wOBMH+6gk9h2Ek/AjsFkQHFYKGRL9I368UbcpJNZ+iZ8qJqK1anQrDUZnApSyFWwu6xstUiU1WGmWKi2yZ876OBgM4GmaiQPM4iSwO5anFqrZdg/GiB1mGHybD+SUUYUBLZWOubKQ9MdkQjA2Jl+1hY6BG7izMCp1u/MhUEWr25jUgz4wy5Cg15KhSqVSp1MuojTayEeywB6pbZY6JAvm8PM+nKnvTs8EWRjrUPUBsd8LJw8lygQ64poi4742uQPwOGyctAiz76AnaOjztyb1iWCGBz2sLWnr8dkktncSREJOfE6LYgGCbGmsXonxsxchFJLQBLqc5FY1s93JOTCohhZ20pQqbsAPQpOU8GIQDKrr+HcaJBbWwmGIm4MkoxkFLA0ZLJdnn2mu2xfCrUaQauV0u08Ythzalt31q9BPn0t1rvbwwYjVTqzjtJdApGG1tl3bmKyTf5O0D3zNjExQbFYJJFIcHBwwJ07d3A4HG0yaLVa3zZSVqlUuHLlyhOtSL4Xkskk/+gf/SNmZ2f52Mc+hizL5PN5PvOZzzAyMvK2POe73/1u3v3ud9/3/r//+79PNBrlgx/8IADT09NcuXKFX/3VX+0RwB7a6BHAHp4K3E8LuP4mUVmaprGxscHGxgZnz54lEAg8VMsX4NMf+QJ//lufolKq4om6ufPlDQDm/rcp5j+7AMDouUEWX1mnXm0gGyUGpvtYv6kTnb6xACtXt6i04s2mnh9uZ/8C9M8E2LlziCdox+Wz4wo4KBeq2J0KqVgWh8fGdku1KskiBrOhTf4kWaTZVIntHBPbOUaSRdxBB4V0CafPSmjAh2IzMjwV4mgvTb3eJJ3Mt5/bpBg43Ov4zdkcZrZaz1Ut1ykXqtz4ylo7XWRgxM/uUoy+sAubS8HhsZLPVTAZ5XZiyN3Vv+5jr3elfoQHbBx2Rc8ZzB0Fq9dvZ+VOZ19/2Emi5V0YCJ4mg021TtBnwqKYsNkVNjeOOTpOIw8I7LaIqsNhbqeDWC1G1raTjA/6MBtkrt/apdFUGR/1c2c3iVUx0Bdw8NrCLh6nia14jjODAeL5MpqmYTYbWdiOMTsSYu3gmHCfo70W6S4i12iqBFIGYrkCQt/pa65Y6TZzPv247vawYjSQrnUI4N3Xbrlr29hAlDdDtz3K8PAw1Wq1naSxsbGByWRqk0GXy/XY2pwn5M/j8TA9Pf3UkL/j42O+8zu/k/HxcT760Y+27WLsdjv/5J/8k3d4dR28/PLLfOu3fuup+77t276ND3/4w9Tr9Scy77mHrz16BLCHrwtIkkSlUrnntmazye3bt0mn07zwwgvY7XaazSaapj1wrNv/+b//d/7yQ3+NK+hk4FwflXyFyRdGsLttVEp1Zi+PY7QYadSajD87BJqG4lDIp0sMz/ahqRqVar1N/obn+lm93pmlm3pumOWWzcpxLIfiMjD/uU51bvbSKAdbScbm+jApBsw2c9v/D1rm0C3FMMDQbIj1m3plK5ss0j8c4PrfrgL6l/+5bxynXKoRbM3hObw2Fl7rspQZC7LY5TfoizhJJTqEUTJKVCt1DrZTiHsCnqCDZEyvkDncFraXYvi9VmwOBXfQQaVSZ/ZsH6qqYnUoHB1mKZdrlIplNFVEFAVUVSMy4GatixwGIy4KpRpmk4zdrlCt1JicCGKQJRSbCY/LSrFQxWCU2NjSZ/8EsYLVUabYUjHLps7fOTro5ebSAYrZwOx0mN29DOurcebO9LVVxnU0ZoaDVMo15lv5vw6HAbdkpwHE0wUuTvbz8uoeL0z28cqq/nfKVTr+fac8+YwyY3U7G3t6BVTrmtUTRYFSrdv25TTR6lb9mg0S1Lo23nX55it6z9kkSa/zHXwrmEymtrq92WxyfHxMIpHg1q1bqKrazuD1+XwPTSJOvAi9Xi9TU1NPDfnLZrN813d9F/39/fy3//bfnmgSFYvFCAaDp+4LBoM0Gg2SySThcPgdWlkPTxJ6BLCHrwu80QxgtVplfn4egMuXL2MwGB6q8lcpVvntf/WHLHx5GZPFiGgS2XhtF0EUcF5yc/UzeuVv6MwAq9e3qVXqCILA1KWx9jarU8HmsXG0ncJgkhma6UMDJp8Z0p9EEtr2LqAnf+yudkiQd8DB0mubqKpG+ihHdDLE0pUt1KaKO+BgcCpEvaYSHQ9wuJ3C4bWwudB5fKDPxUqXsMMbdrDw2ib1mn7efGEXid1j+vpdOLxWDCYDx4k8oiSgNjX6h32sdJHN0ZkI612zfpPnBljqah33D/tZvLZDMV8hGcuhCrRnB612E6oK5RYRHhjzsrvRimITdOFGAn3q0GY3s3Z7n3qtSQ3o73ez0FqHw6lQqjbaSR8Tc5H2809MhbjTIpEut5ntHf34kgSFQpGpYT/7+xlWVuNkcmUsioHVbV24MjrkQ2vCnY0YM7NhmnENv8tIvqSRzKQYHvEyHPBwXKpwYTjM+lFr7SLky50KXLOL5F1wBbl+pXP+1K5yqF0xkVK7fsDcdVlWuuYDjXepfl9XF5dlaNbvmQLyIJAkqV390zSNXC5HIpFga2uLhYUF3G53e/v9eOWBTv6uXLmCz+d7qshfPp/nu7/7u/F6vfyP//E/vqZzkg+Lu8/tSQflaTnnPbz96BHAHp4KvNWH1r1mAHO5HPPz87jd7ra68GHEHsn9Y375+36DnaV9XGEnTo+DZkUjOh3BH/WROsgwMBnG4lTIHRcxGGVqlToz7xpn8au6yEM2Svj6vWy3zI6NZgPZVIF4S/Fr91iRjTLpeA6rQ2FgIoTRbGT8XJT0UY5ivkyjorVJg2wUyRwXUFvVqly6wNH2MYctAiMZRMw2iYlwP82GyuHuMRaHQnw/035dTq+9Xa0DcPmsJA8z7G8m2N9MMDrXz97qEQaTTN+QB3/Yid1pIZ8tETtIt8kb6B6Ch7sd8uryWlntsnIZngqx0ZU9PDQeasfJAWhqp1LlCzlYWTxov9a+QS8LLS9DxWI4NRc4MOLndosM+gJ2VrvsZArFDhHri/rxlGuYZAlNaLK4rFfh+vqt7B7pfoAjo372YlnG+jzUBI0763FsVhNLm0eMBG3YXHZurMUYH/JRrjYQRAGHbKapaSRz+jEcVoVko6P6OJnde94fJrvZidvr3gagKAYo3ruCDadTQe62fVG7Zv4Aaq3bb5QD/DAQBAGn04nT6WRsbIxyuUwikWgLSaxWa5sMvlGsWqlU4urVq/j9/ifWiPpeKBaLfO/3fi8Wi4U//dM/fdsyhB8nQqEQsVjs1H3xeBxZlvF6ve/Qqnp40tAjgD18XeBuAnh0dMTNmzcZGRlheHgYVVVRW1+4DzLHtDq/yW//xB+S3EvhDjmplGsc72eRDBKj54eY/2u9uhed6WN76YBKi3TMfeMke6tH9I0GsNjNOHx2ysUqI2f6ySRyOH0ONlvCC1ES8IZdbLXIYSlfoVZpsHy103qdem6YerVB/7CfUqGKwSqzcrWr2jbhY3uhQ4wi4z527yQBnWBOXRgkHc8z/UwUDRBlkcWu44/MRli71Wk1j8xEWG+tr15tYDIbmW+1jgEmn4mSTRWYnIsgGfQ27NZqAkEATYPwoJelrtm/bmWqYjWeipMbmQqz0UXcvEEH8ZZdjcVqZGO187pGJkNtwmdWDGx0mUkHwk4SLSPr4VE/jUaTMzMRmk2NrdUjisUagijgDtr1BwhQaeokRDGL5DJZCpkyMU0j2fo7+rwGHHWZZLrGfi5JxOegqWnsxDK8cDbKq7d3mJ3qtNPsFhPJXIcAVhsNng0GWfnSPuPDfrpRrd9l+9IZY6SpdreHT/v+3d3WLVTKp24XG3oruTsF5HFDUZR2Kk63V95JrNoJGfR4PEiS1CZ/gUCAiYmJp4b8lUolvu/7vg9BEPjkJz+JxWJ5p5d0X7h8+TJ/8Rd/ceq+T3/601y8ePGJbl338LVFjwD28HWBkxawpmlsbm6yvr7OmTNnCAaDbfL3oGKPr/z5Ff7Te/8ztXKN4LifYrZMvdJAsZvom4iwOr8FwMB0mMReqk3+Zi5PsPDyGgDZZJ6Zy+NcbRFFgJlLY2ws7BOdDGFzWrC6FPbW4giigKZqzL4wysIrG+39p58fYenVzu2x81HWr+0yMBbA7ragobHZ5dFnc5s52sq0b1sdCnvrCQqZEke7xxhMMna3FbfHSqDfjSSJp0yIBVFop3/ot0UKuU51SpJFkocZUrEcsZ1jzBYjskmmkC3rre3JEM1qg5nz/WgqyGaJw70MBqNEvdYkHHWxcadD3JpdyR5un42VUxYyoXb1TzaI7O52BCojkyEWbu3jdCp4vVZEAeamwxSyZWQNtjZS7AGz5/vbc4ATUyGWWpXI8YkgmVyZMxNhEOFWi5QqNgm1oNHvN3GUrFCqNDgz10epWkdEYHEvwfmxMK/e3kHT7qrkmWXoFFXxGRWWv7gPGhjuUgSXu6LejHdta6gdcmgxGal1Df3drfotVzuVToMkUlV1smg1PFoL+H5xt1feicXM8vIy1WoVp9NJPp8nFAo9VeSvUqnwAz/wA1QqFT71qU9hs9nesbUUCgXW1tbatzc3N7l+/Toej4doNMrP//zPs7+/zx/90R8B8L73vY/f/u3f5sUXX+S9730vL7/8Mh/+8If5+Mc//k69hB6eQPQIYA9PBe6nBdxoNLh16xapVIrnn38eh8Px0Erf//Frf8lf/cFnkSTomwkQ3zimUWtishoJDQdYv7aFSTEyONtPKV8hPBTAqBiwui2U81UGp8OkYlmiUxEWv9r54J65PMZii9zt3Dlk6rkRXvvUbUA3JZ56foR6rcHwXB8HGwncATtrNzqtUrvHSnzvmGZDZXclhmyQ8EVc1Eo1PGErDq8Nk8XE6vVONS8w4Dw1CzhxPtoWiqTjOWaeG2bl6jY2l4XwoBen387RXhpJ0hXFU89EWZrvrGHy3MCp6uHobISF1u16tYFkkLjT1d6NjgdJtvKHnV6FbCLH0JAXk2LE5lSolHVhiIZueZPPVQANBJAEgZm5CAJgset2OGG/g0a9SSFVRBEE8okC0QEPt+f1imOk3812q2ooG0R2uuYqC+UaogBjIwGMskQyliMRy7WNn51OhVpDIOw0YTAYKVXyGGSBQj7P1l6BwVEP54ZC1JrNth9ht31LN5GbDHrZfe2o3aYX71L2dmf93k0Ou1W/FpOBTFcL+O5cYNlsgppO0C0GA1V0Amh5GyuAb4S7LWaSySS3bt1ClmX29/fJ5/NfE4uZR0W1WuWHfuiHyGQyfPrTn8bhcLz1g95GXLlyhW/5lm9p337xxRcB+JEf+RE+8pGPcHh4yM5O5z03PDzMSy+9xE/91E/xO7/zO0QiEX7zN3+zZwHTwyn0CGAPXxdQVZVqtUqxWOTy5csPnexRrzX43Z/8Qz73sS8BEJkOEltNoTZVREkiMhZhq2UM7Aw42Fs9otRq+Y09M8j1zy+1M3zHLwyze+eAoekIFocZg9nA4XangtU3FmD9ZudD22wxsn5jl3xa7wWarUacbiuegINyscbeaozgoJe1LiHH5LNDbTPp4/08gbCPO1/dxGg2EJkMYHGaiO2mOTFxdgdtLHepju1uS7v1XMiU2Ks3ONo5Jpcu6tW8qSCyJDI2FyG+l6FarbPXZbhscyhsdNmz+MLOU6rkkenwqe0On8LeWobjmD4zNzwVZrMl1LC7LFRqdWqtaLuZZ6LcahFVQRTwhZzEWzOL0+f6WW8JSowmma2ueDiH28r+YVb/G0yHWWhVFKemQkgGiaJiolautW1gxieDLG/EMZtlhqNubi3F0ASwSxKKSWZmIsyVhT18XoVGqcR+MU+qy3IoX+4mZzrJGw94yN04pthF5O6+BAtdYhFROr2x2uhqDxvkU6rfu0Uf9S57JEWWSbce+jhnAB8GpVKJxcVFBgYGGBsbo1arfU0sZh4V9XqdH/3RH2V/f5/PfvazuN3ud3pJ/L2/9/fe1AbrIx/5yOvu++Zv/ua2AK6HHu6FHgHs4alHPp/n1q1bADz33HOIovhQYo9cqsCv/bPf42AtRnDIj9ltpFZqMnp+ENkgY/dYKWTKjJyLkj8uYLaaibcqWw6fjcOtRJv8RUaDbC/uU6vUyaUKBId8FNIlSvkKVqdFzwQ2GxBFkf11vSXp9NnZ7pqNG57rZ6mrFTx7aZRyscrMxSFS8TxGk8zSa53tDo+1rRquVersLsfw97k53s1gd1vxD7iQzCKVUo1Gy8cvGPWwdqOLsM32tauD9WoDs2Li1lc6s3/nvnGccrHGwLCPUqmG1alw+7Wt9nZvyHlKWNJodNqjBqNIJt6V0DHqb5M/gIExf1sYIooisYNse9vYTISVkza3AOl0qbNtOsxCK4nE5bWw2jK9FkU9JePMdJh4LEez0eROiwz6+1ztx9ebTeYmwxzFMiyuHNFUNaamw+RKFRRRYn03hYDGYMTL1dt7jA57SMY6VcV0vrMWBBjze8hdP8ZsNKB1EbnuiDaL2UBO7cz1vd7L743bw4XiaTFJt0WMUZbhhAC+AxXAExQKBa5evUpfXx+jo6MIgnBfFjMn0XTv1Jxao9Hgx3/8x1lfX+fzn/98TzDRw9c1egSwh6ca8XicGzduMDAwwNaWHsV2Qv4EQXigWLf/43t/ndiGXhXyDDhJr+SplWocEmfyhVFefel6e/+5b5xi8atr+CIuXAEnrqCD/HGR41iWxL6ehXtizixKIqIoUmrFk5XyZcqFSrs1bLaamHvXBKVSldCgl9h2iolnBk+RP1/EzfrN3bZ/oMEo4x90ERx2YjYpHGwmCQ36WLnWac1OXhhmsVUdzKeLhAa9rL6qEyx/vxtX2Er2OItsFGnUVNwBOytdNi4Or7UtBAGwu60sX9tpr8HltbG/doTHreANObE4zVTKDUIDblJHOQbGAmwsdQje+NkBFruEIaYuo2fFamSjK61k4kwfd7pEKaWumcTx6XBb7StIAkdHOuE0KwZGx4JUKrrPosEkc7vVug71uVhrVQz9QQer63EkSWBuJsJBLMvWepLIgJVaXgUBLGaZ1bUsE5MhDrfiXJzu52rrXCiWjgrUqhjIdhG5RrFE9maWeqWB12UlVelU+Rpds45Wi5FcsfO4u2s7pVOpIKcJYP0utXup0UUWuzJ9re8QiTohf/39/YyMjNzzPfhGFjObm5vcvn37oSxmHhXNZpP3ve99LC4u8rnPfQ6/3//WD+qhh6cYPQLYw1OBe3labW1tsba2xtzcHF6vl62tLZLJJD6f74HaSTc+v8B//rcfxeG1YfNaKJXKaFU4LulK1NCwn53FDhkZmO5j8atrqE2VxO4xTr+DK//rZnv77DdMUi5U9IpdoYrFaWmLQgCmXxhlsev2wGSYK399u317cDqCwSgxfj7KzvIhtWoDi91M8qBTdYpMeNm+3VHOTl4YolGpMX1hiNiungCyer1DBo1mA6nDTPt2Yi+NYjMT30gjGyRCUSeK04ggNUkfNdBUiAz5udNlAj0wFmCxK7EkPOxj6coWx5U6x0c5Jp6Jtn0GBVFAUJv4Q2asdgWb3QaCwNCYn1KxhmIznfIQHJ4Od2xhBMgcdySxw5OhthLYaJIxmGSGR3yYzQasDjO5bBmpqVIsVFi8sUu5Fe8WHQu0j+Hy2jiI60Qx1OciEHRwuJemUmmQSBYQRYF8WSMcsNMXcvHajV0EQaBQqTHkdVKuN1Hv0YJzOixkc/pxJ4JumrsV6q1cY1W9O+u3q61rMkKxUznsPrYgnJ4PvDvr12yxdD1Wo1zvJoCdfd+JCmA+n+fq1asMDAwwOjp6X495HBYzj4pms8lP/uRPcuXKFT7/+c8TCoUe+3P00MOThh4B7OGpg6qqLCwskEwm22KPRqNBNBplaWkJTdMIBAIEAgE8Hs+bksFP/ZfP86EX/yvNVqvO5rUgSTLZeA6r00L/ZBiLw4Lda+NoK0G1XKNaqrUH+00WI5mjTqtSsZnZWz4g24pXszgUDCYj/aMBHD471UqNg/UOcTMpBo52Uu3bQmvAf6HVdjWYDFz4limKuQoOr41cqoBvwMnOYscaRbGbOdpJkelK6Jh71ziBiJtcusjeepzxc9H2rCDohHG5Re4a9SYmg4nNazohM5oNhCbc5LJpfBE7qcM8noDjLhNp56lqYWjQe2r2LzoeYP22PluYIM/Mc1YWX+08//j5AcSmimIzYXMqFFIFov1uREnEE7BznCoyGPWgNlXMRgm300S5WCMYdrDUJUCJjPjYb7XhZ56NstCqGkaHvWy35gKdbgsrqzH6+lz4PDZW78QolWoEQg5WWn+LsQk/RoOBpTuHGBWdOM1MBInF8+QKZWrHnWuoW6BhVQyQgzN9Afa+eoAv0hELKBYzZDot73wX4TOZ7lb9dmX9mozktHuniQA0usiixWgg3zUg2B0h96hG0A+KE/IXjUYfKRP3QS1mHhWqqvLiiy/yxS9+kb/5m7+hr6/vkY/ZQw9PA3oEsIenCrVajWvXrtFsNk+JPTRNY2JigomJCdLpNPF4nMXFRZrNJn6/n0AggNfrfd0XRmDQx//tB7+Br/zFFbSmimJRSOzqhKyYLaGpGtf++lZ7//P/4Ay1Ug1v2EV875jQsJ/Frhm5kbNRFr6y0r49fCbKwldW24Rw9l3jFFMFRmb7MFnNmKxGrv/Nnfb+08+NtNu2AIGoh2stYYkgCPgHnTh9VrQ6pGI68RyajpyyiZm8MMTtrjUNz/WjNpqMzvWzsxpDlESOdjpiFDhtxVKr1DFKJnZaYhejWcbqFrG4HDTrAsnDHL6wk9Rhh/ja3RZiXRYt+VxnTs1gktnf6Ig0ggNu1m7vo2lQyJaJjgdYvNoRpqga7LaEJn3DPpa6iKexq208PBlioyXkkAwSe11qX5NFT2rw+qyMjAfZ301zsHWMx22l1GphWxwyWhrGhryUinWW9+IMDXvZ2D1mbjxENl8hlS4SDNrZz3Yqkt3VOaNR5tn+EGtf2gEN8oVOy9diOW0YXOrK+m3Ua6e21bpmBa1mA7kuYUmhkD+1b7U7F9hwmgCKQocAOr6GBPDEdH1wcJDh4eHHdty3spjxer34/X58Pt9DpXOoqsrP/uzP8ulPf5rPf/7zRKNvnp3cQw9fT+gRwB6eCgiC0J4tcjgczM3NnTJ/7hZ7nNhQTE5Oks1micfjrKysUKvV8Pl8BINBvF4vsiwz9a4xykqeyz92HmPFwlf//Covf/Iqqf1j5r5xkttfWm6vYfSZIa5/tuPn1z8Z5nAtxuTFYRAEapUad17ttHb9A16Wr3Ryed1BJyvzW9Qrddavb2NzW2k2mvhDDvxRL+VijYPNjsIWQFO1trBE0zTsrv9/e+cZHmWZtuHznd4ymfRCElJJSADpvVpABEmw7trAjnUVG6u7rKt+a3fRVXBdUdfOSkABWRVXmgIqEFpCGi09k977zPcjycw7Q6gSCOQ5j4Mf885bnokxuXI/931dRrK3twuiPtEBBIb7kitL2DCYdRQeLnW5hyTh6DfU6NQMGBNFXU0TdrudqrJa4oaFk77jsOP88P5BLpPGPkFe5KaWOaYQPQMMlORaiYjzQ6VRIymVHJClfviFeVCS6xSAMQNdbWMsfmaKOwY8lCoFBbLJ6PC4QA7LjJ8NnjroWEpAHy+XbWNJNjkbEx/M/rQCFAqJiGg/tColoYGelJfWkLo7j/r6ZjRaJYeOtIt7o0lNXW0TEcFeKCQFuXntx3UGDQmRATQ3tZJbUAmAyaQDmQCs7kjsUEgSFruKlM2HHJ+lrt4pAJHbtUjQ0OwUbu5WLrWyHGudRg0yb2d3+5gm2dCHXq0C2U5z56njFUH45Sogjm6nurqaHTt2EBERQXh4eLc9x91ipq6ujpKSEvLz89m/fz9ms/mULGZsNht/+tOf+Oqrr1i/fv1vqloKBOcjQgAKzgtqamrYtm0bffv2JSoqCpvNdsJhD0mSsFgsWCwWYmJiqKmpwWq1cuDAAfbt24fZbHYY1MbFxaFQKBg4vj93vHQjWTsOsnXVDkoLKig6aMVkMVLWIQig/Zey3WanLL+Csvz2ylPkoDB8Ai349vGmsaEJtVZDiawqFRDuS4WsuhfWP5i0LVk01DRizSkjYWwMJXWNxA3tS2urDZVOTbqsshcQ7sPhPU6hZc0to7mphZLccoKj/PEK8ESlUbN7s1O09hsaTmaHYTWA2dvE7o0ZtDS3IkkSYf2D0GiUhET5kX+wBLu9fUtYjsGkc7Gg8AvwIXtPLuUF7ZWpgCgvaGnFJ8CERq/EN8gXs4eZ6oo6qirqKDjs3OL2DfYka59zq7jfoBCXxBC52PEL9iRbZnDt5edBcUfVMSjMm4NZxXh5G/HxNaHTqIgK9yX/SDk6lYrUjuGP+KGh7OvYio6OC2JfWgF+fnrMZg0HDlYD9YTGtDf7R/b1pdxai7Wkhuj+AY7nyodVFEqJytpG9Fo1MXoPWkudgs/DpKO8wSnk5Fm/RrepX6PJCFbntLTcEkZyi3bTG41Q5awCNrjnAssEoITE5Cp/8lYdQf+ngXQ3VVVV7Ny5k8jISPr27dvtz+tEkiRMJhMmk4mIiAiamppOyWLGbrfz7LPP8vnnn7NhwwZiYmLO2toFgp6CEICC8wKTycSQIUPw9vY+LX8/SZIwm82YzWaio6MdaSEajYaCggIaGxsJCAjAz88PjUZDv+FR9BsexZxnruPQ3hz2bNzP9x9uprLjl3b8mBiX6mDsyCgyOnrcig5ZCR8YSk5aHpEDQtAatbS2tJEps2zxCbaQKasOGs16Du3Lo766gf3bslGqFARG+NO3vz8NTc2U59Vg9DBQbHOKqX5Dwx3DJQUHrChVCvIziwiO8MMrwJPykhpK8ly3ei3+Ho5hErvdjslsYPfG9i1oDy8DsSMiqa1uwOxtpLq8jvD4YA7IBFtojD/Ze5yCLbRfALnZ7VXLsvxq/MM92fujzPh6ZATFeRWER/uiM2jx8DLiH+RJW5uN5o6KWGCIhZYWG57eBsqtNVi8jSiUEn3CfdDo1Kg1KnQGNUoJEgaF0NbSisaoobKkmsqiKnx9jOz6uf1rafLUk9VhLaNUKcjvtJKRQFJAkJ+e8tJG6hvaRVbfCB9yCysY1C+IVsnOwY4s5fJKZ7+eJKvWWcx6FAYlxrI2DmUWEjPAGQNn8nAVgC3yqV+jjupaZ1XU7jb32yJ7aZcJRYCWVtfXx8oF9tLqCEiF/es6ovJ03TsEcq7EX1ecjMWMXq/HYrHg4+PDCy+8wHvvvcf69euJizsLZVKBoAciBKDgvKBz++d0kz06sdvtHDx4kJycHAYPHoyvry/19fVYrVbHVpLFYnGIQZ1OR8TAMCIGhpF4/zTyMgv5ec1OF0sYrUGDNce57SpJ0NLYQnNDC9k724VJ1OC++AV74tPHh5rKegyeepeKYviAUJfewX4jItkvmxSOGRqOQikRfVEYh/fnY/Iykimb0JUUEq3NbdhsdgoOWCk4YCVhTDSV9hqCR0ZgzavAw8eDbJkJtMXPg+zdzns01DVxKDWfssJKJEkiKMIPLx8TioQ+5B8qoam+GZXGVVQo1a4/QpQK5/uSUiInu5jaigbKCqvwCjCTtSfPMXATOyTMpXfR29fkGKjx9DGS+vMhWjpEYvyIcFI7/Aa9/T2orGpw9C22tDnVU99oP0d0XHR8EAWFVQxICEahktiT0n48/qIQ9nVsJfv4edBQ10xhQQXlHX13SpWCcpnPoHxAI9TXk9zdhVhr289tlPUD6nWuX4smWaVOr1eDzL5PnvWrUko0Nss8Ad3EYWWNs/qnVipolK2nc+gj2uSF6ZsqFD5Ocag3dF8PYGVlJSkpKURFRfW4vrljWcx8/vnnvPzyy8TGxnLo0CG++OILBgwY0O3rWbx4MS+//DKFhYUkJCSwaNEiJkyYcMzzP/nkE1566SWysrLw9PTk8ssv55VXXhGehIIzTs+wXhcITsC2bdt49913sVqtp+TvJ6etrY19+/ZRUFDAiBEj8PX1BcBgMBAeHs7IkSMZP348/v7+FBUV8eOPP/LLL79w5MgRGhram7JC+gVx9fwZvPj9U7yz72Vu+9vvGDd7BJXFzu28uNEx5Gc5Pe2ihvTlwK4jFB60sm/zfloaGinMLCBuRDhRF4Xh08dC1k5nNVCjU3Nkv9N2BqCxromMXw6Q9esB1BJEDwghNCbAkSARNzySwoPO3jn/vj6kbz9EfnYxqVuyKC8oR62EhFGR+Id4AxAY7ktTg1PA9BsW4bCKsdvtGD317FyfxoFdh2mpa2Dg6Aj0ehXRA/tg9NQRFhfEYVlPXvTAEAoPOSuU0YNCqK1wNrN5eGsd4g9JorrK+Z5/iBfZMs/BkEh/h/jTGzUuaSIBYd4O8RcS6cfhjgqkRqviyMFSTB46+icEI9mhrqyOtJRc8vPb16VQKigorsbH28iQQaGk/HIIa3E1QSHOe3p7G11sWRqaWlGpFAwJ80dZ0khDrVNkyYc+1BpXAVgvG+TQuL0nrw6a9K7DC1qd22uDwfkMt297lUJitD4AxUfF1OTVYZNtH+v13SMAO8VfdHR0jxN/7nRazERHR/PUU0/x+OOP09zcTEJCAomJiQwaNIjnn3++256/bNkyHnroIZ566ilSUlKYMGEC06dPd4ltk/Pjjz9yyy23cPvtt5OamsoXX3zBr7/+yh133NFtaxT0XkQFUHBeUFFRwb///W8efvhhxo4dS1JSErNmzSIwMPCkxGBzczO7du0CYOTIkcecGNTpdA4LiqamJkpKSiguLiYrKwuTyURAQAD+/v4YjUYC+vqS+MA0AG76y9VsW72TX9amkCMTMpIEDTWNLs8weOgpyC52bCcPmBiHt78ZSaEgJ70AvwgvcmUef/2GRZC5wykQPbxN7PhuL7Y2Gx7eRvomhNDa6tq352ExYj3iFGOxIyJdvAfjx0QjKSSCI/woOFSC0aznyH5nf6FCKTkmlwHaWm1UWKvJ7dhelSQJT18dodFemMwe1FU3uqxBqVJQVugUxWZvAwUHnP2QQZEWCmW9gd6Bnlg7ztebtByUJ6LEB5PW0dNnNOs4IBODepMOpVIiJMwb/yALJUVV5B4upbnJgwMdwtA32IC1tP2/QWx8EAqFRGZaIU0BZkeeb6tMOHma9RTLhj7USgXhSh2ZW46QMDjU+UWWoKraKWLd49xq62VbtWq3QQ55dVCnhjrn94hBrwcqnefKpn7NBgM1ze2lRI1CQrOvgpJNznPbZMkrOv2Z3wKuqKggJSWFfv36ERIScsbv313Y7Xbeeecd3nrrLf773/8yZswYKisr+eabbygqKjrxDU6T1157jdtvv90h4BYtWsS3337LkiVLuhSe27ZtIzw8nAcffBBoz/S9++67eemll7ptjYLeixCAgvOC6dOnc/nll3PkyBGSk5NZvnw5jz32GKNGjSIxMZHExERCQkK6FIO1tbXs2rULs9lMQkLCSXuHabVaQkJCCAkJoaWlxSEGDxw4gNFodHgNmkwmfIK8mHHXJcy46xKqS2v4+esUtq7aQVN9k0uvYMSgULJTDjte+4f5sn9LlqMyZvDUYW9tI3Z4OLkZRTTUNbkIMQCzrwfFHb1qNeV12G020rdm4R3oSVBUAJJKQeoWp9gzWYwclvXxAdRVNXCkw9zaJ9iLyIvCKCmooKGuEVubndhhES7bs9EXhZG921m18OvrSUFGp4CzEj04jAP78vALsmDx88AzwExtRQMmDx2V5XWERPuTJouMs9tkfnWeWrJkqR8R/YMctjAqtYJ82VRzRFwQFWW1mDx0aHUqKisaUNns5GZbqa9rprSjEmuXfR9oDXpMJojo60NZeT0FeRV4eOrJlCWP1NY5K3naDuGkkCQGRgWQvT2f1o58Yrvs28tk0lEl68eTb9yqVArqZBVAdzPnBpekDzeTc7dvYbnRs1bTngscbvbE+6dafAw65HPj1TXOfWbDGa4Ans/i74MPPuAvf/kLa9asYcyYMQBYLBZ+97vfddtzm5ub2bFjBwsWLHA5PnXqVLZs2dLlNWPHjuWpp55i7dq1TJ8+HavVyvLly5kxY0a3rVPQexECUHDeIEkS4eHhPPLII8yfP5/8/HxWrFhBcnIyTz75JEOHDiUpKYnExETCw8ORJIlvv/0Wu91OdHS0I5P0dFCr1QQHBxMcHExrayulpaUUFxdz+PBhdDqdQwyazWbMvh5cNmcil82ZSF1VPb9+s5utX20n5X/7HBm8nXgFerr0DwZFB3CgwzJFpVYy9NIB1FU3UVtZR11VA6FxQWTJqoEmLyMHO4YyyouqKC+qIqRfIH5BnviH+VJSWIFvH2+X6l/M0HCyZJPBEnbH2oyeevr274NSKWGy6KmtbECSoE5W6QJQSK4/Ohrqm7Db7JTkV1BWVImX1eLYTjZ5GTiSmoevnxGjhx7vYAuN9c14+3hgt9tQ6hRUV9TR0tKKSqmgubGB2IFBKBUKDGY9lWV1mAwa6msbyUkvorpjQKP/8HCOdFjG9LsoxJEVHNzXx5EcEtjHjKdRT2lOJQ31zRR0TGUHBJnJPOiUTqWy5BFJguAATwx1rZTuL3GIP4AWWYXNw1NHVYlT5Mmj3jxMOhobXCu/cuSegC3NTS7vtdlcp4DlsXBalZKxRn+snx+moqmN4CEebnd2Cs09e1MIDg7Ez88Pk8n0mxI0ysvL2bVrF7GxseeVUbLdbueTTz5hwYIFrFq1iokTJ561Z5eWltLW1kZAQIDL8YCAgGNWHceOHcsnn3zC9ddfT2NjI62trcyaNYt//OMfZ2PJgl6GEICC8xJJkggJCeHBBx/kgQceoKioiC+//JLk5GT+8pe/MGDAAKKjo1m9ejVLly4lOjr6jD1bpVI5zGnb2tooKyujuLiYnTt3olKp8Pf3JyAgAE9PT4yeBiZfP4bJ14+hsb6Jnev2svWr7fz6zW58gr1cJoM9fIzkpjm3YSWFRHbKYSqKqlCqlEQMDMUr0EJ5YSV1Hf1znVYyncSOiCSj457WnDL8Qr2pKqokYVQURbllVFqrqbQ6DZyhvQJY2jGQUlfVLvj2bkxHoZAIiQ4kOMofa0EFSrWCthYbffsHkZPu3KKOHhzmMhncb2g46bLIuL79gkj95SB1VQ2UUomkUjh6B02eelpa7TR1VMuiLupDdkpHNVACS6AnlSXt4qz/sHD2d6SPmDz1ZMv6D+tl2616s4ZA9KhRYbKYSOu4xiazAtHKtkfNnnoqOq7X6dQYUFC9t5iKVht9Y/wprXIOhDTKqnoGtyGLJtkgh8GoAbkljLw+KEFto/M+JpMBZDYwLTIBqFBIDtsXP6OByCIlaf91Wgm5SkWw29s/o1KpIDIy3JGveyJblONRVlbG7t27iYuLIzg4+KSvO9fY7Xa++OIL5s+fT3JyMlOmTDkn6+gqxvJYYjwtLY0HH3yQhQsXMm3aNAoLC3nssceYN28eS5cuPRvLFfQihAAUnPdIkkRQUBD33HMP8+bNw2q1ctNNN7Fq1SpCQkJ44YUXSEtLY/bs2fTv3/+MZokqlUpH9c9ms1FWVobVamXXrl1IkuQQgxaLBZ1By9jE4YxNHE5LUwt7Nu3nvx/8j73r02msaSY0tg9pLpPAUaR2bB+3tbYhAdv/uwuVWknkwFCMnkaOZDhFkFKtpDS/wmV9XgGeZG4/RF7HdufQywbQ1NCCrc1OWWElof0CyZSZQBs9DRzq2C5unyguoqm+iZK8clQaJaFRfvj4mVGgoPBIKU0NLTTIBiEkheQQkwAGDx0H5TnK/QJcBkf6xgWT+mt7RVNSKqgqc4qtiPggDmV0VOkkKMxz9gyG9QsgtcM/MLxfAIWFlcTEBaJQtnFwfyEtzTY8fUwUFLc/S6FUkCvriZRP4Xr5GKkqaiE+yh/r/mJKskodvXQ6N5FXLfusGq3b0IesqqfTuV4nrxwadRqqZDnBOr1rYkiLPGpOp6GZJkZY/Kj68gj2CDc/O5vrxHBzx1SyXu+sWHfaolitVvbu3YvdbneIwa7SceScr+IP4Msvv+T+++9n2bJlTJs27aw/39fXF6VSeVS1z2q1HlUV7OT5559n3LhxPPbYYwAMGjQIo9HIhAkTeO655wgKCuryOoHgdBACUHBB0dDQwB133EFeXh6pqan4+PiwatUqVqxYwWuvvUZYWBiJiYnMnj2bgQMHnlIl5ETIc0ptNpsjkk7+S9cRSadWogtWMmnecB546zYOpeSxbfVOCg8UU1FchcGs40iqs29PkqC+pr3q19rSRvbOw8SNiqa2pIrIgaFo9FrUOjV7NzsFZFj/Pkd5DWb8epC6ji3UkNgg/Pp40Vjf5DCs7hsf7LJdHDs8kv0d5tWtzW3oDTp2dqShKFUKBo3rR0tzKx5DwqipasDsY2K/rPoXEd+HVFkvoVY28ao1qDksE7Axg0LJlFUS5fZ3Ef2DOJTRGfum4PCBYvqEWfC0GFGqlRQcbCZ7dy5BMRZamjsnhH3Z12EJ4x/kSYHV2Uspn971tRhoK28ge3P7OpuaXYdZHP8NFBJVMn9A94SOmlpnxU+tdhVV8vQOnUZJlUwsuv890igz4vY16InNVVG4KqtjDa7PlA99ADR2bFfLLWDcbVHk6TjyOLVOD8xOSktL2bNnD/379z/vhMeaNWu46667+OSTT85Z/5xGo2HYsGGsW7eO2bNnO46vW7eOxMTELq+pr69HpXKzVuoQ6HIzdoHgTCAEoOCCQqvVMmzYMD788EO8vLwAmDNnDnPmzKG6upo1a9awYsUKLrvsMvz9/R1icOjQoWdcDPr4+ODj40NcXByVlZVYrVbS09NpaWlBqVSiUCgYOnQoRqORwVM8GTwlgbteuZH0bdmk/pTBt+9vpLaiffszdlQ06ducwqxPTCAZvxzAbreTvfMwBrMetVZN1MA+qHUactILwc1PLnxACKmy7WKDScuOb3cDEBjhR2CkP5UlziECjU5NTqZsS1qSqJH547W12ijJK6egI49XUiho6euDr58Ji58HOqMWsBMZH0xdTSNag5YD+5zVwKiBoS6DIXU1zj7D8P5BHM4qwWjS4eGlx9PLSPzgPthabah1KtJ25FJQWketTw3V1S1gB41OSVmRU4TVybaFPb2NTgEoQWlpLXH9AqgvrKatvIHijolkD0891bLr5Gkenl4GymUT3XKrGJVa4fI8pdtgR4PMLxBc+0Ddf603tLSgUigYbvaBX8rJPeisXEpuEXItbtPfTR3C8lgm0O7pOJ1xanl5eezfvx9PT0/8/f1RKpVkZmYSHx9PYGBgl/fqqXzzzTfcdtttfPDBByQlJZ3TtcyfP5+bb76Z4cOHM2bMGN555x1ycnKYN28eAH/84x/Jz8/nww8/BODKK6/kzjvvZMmSJY4t4IceeoiRI0eedxVYQc9HCEDBBYVSqeTpp5/u8j2z2cwNN9zADTfcQF1dHf/9739JTk5m5syZeHl5MWvWLBITExk1atRJTwqfDJIk4eXlhZeXF2FhYezYscPRB7Rt2zZHPrGvry8qlYr4sf2IH9uPax+70hFJt18m/gB0Rq1LRSByUBj7fsygqqR9CjZuVDRtrW3EjYggJ70Qg4feJZdYqVJQUezsBSw6VILZ18zhvbl4+nkQFBVAm6KVw3ucFbrY4RGky+4RM6QvWSlOI+l+w8LJ6NhOLskrJ2FMNKk/OQVn3IhIFLY2jB46jJ56GirrCIvwQaGUsPibqbDWEBLmRWtTKxq1ErXdRl1ZNX7+RnZ1pJVISgXeQV4Oz76AMF+q97av0RJgoLigQ6BKUCzbilZ2VOT0Bg39ovwoOlTKgZ/aK34mD+cWrJevieocZ3qK3OjZbNa7CEC5l5/ZQ09pnWxQxq2sVyfzW/Q0GyludK7N5hb9Fqw30mdPPXmZ6YT363qr0LEGWbVQq1XR2LF9fDIm0O5xao2NjY5s3ZqaGnQ6HbW1tVRVVWE2m89o60R38cMPP3DLLbfwz3/+k2uuueZcL4frr7+esrIynnnmGQoLCxkwYABr1651JKcUFha6eALOnTuXmpoa3nzzTR555BEsFgsXX3wxL7744rn6CIILGCEABb0So9HINddcwzXXXENDQwPfffcdycnJXHfddeh0OmbNmkVSUhJjx449akvmdKmpqSElJQVfX1/i4uKQJIna2lqsVisHDx4kNTUVb29vRwqJWq0mZlgkMcPaQ+oPp+aybdUODu7O4eevUxz39Q6ykLHduc2qVCkoK6igJLe9cqTSqIgdHo5vHwu5mUXUVTUQNyLSJXlEvl1cVVJDc1Nze7JIm53wuGCMFgOtLTYkCez2dn1T6xaXVimzq9Ho1OTKbFb8QrzJ3JWD3WanuryOPtEB7JeJyXCFgiMd3n9BEX5kpjh/KSplJsoxg0LJ7Mj2VagUHM50ml97+3o5BKCHRUt1XXtFTpJAo1KQEO3H4d25NJp1lOZXOv+7yAyp9UZXf8iaaqfgc+8HbJRt4xqNGhcBKK8cIkFtvcxmRuvWH9gx9BHkaSKsHHI+Sne8p3JLWnHfBmyWDZ7o9Boaa9vXcDom0DqdDq1WS11dHQkJCSgUCkpKSti5c6djG9nf3x8vL68zWi0/U2zatInf//73vPnmm9xwww09RrDee++93HvvvV2+98EHHxx17IEHHuCBBx7o5lUJBEIACgTo9XqHl2BzczPff/89ycnJ3HzzzUiSxMyZM5k9ezYTJ05ErT49c93S0lL27t1LeHi4w6IGwMPDAw8PD6Kioqirq8NqtZKTk0NaWhre3t6OARONRkN4QijhCe1GxAXZRWz5agfbVu9ApVFR3mG5Au3Vv9SfnOIuOCqAHd/uAUCpUhI7PBKFAsw+JqrLOrd8XX9Z+of7cGRPu9A6tDeXhLExpG/LwmgxEBwVgMXfTOHhUiSFhN1m76j+OauB0YP7kvazc1rVN8Sb0sL2iqOkkCiVrTc0JpDDsulns68HhbntPYn+fbxcto3l/n4+QSZKCp32LXKxFhTqi7G2EY3CRnlOBVlbs2iobRds8glgSSlRKusNVMp79ySolG15q9z6+uR9hDo3wSUf5NBrVdTau+4rBFChYIzBi7xV2ZS73Ufldq7NbeijSSZCtVqlI25Ofxom0J39qgMHDsTf3x+AwMBAl37W1NRU2tra8PX1xc/Pz1G1Ptds2bKF6667jldeeYU5c+b0GPEnEPRkzv3/uQJBD0Kj0XDFFVdwxRVX0NLSwsaNG1m+fDl33nknLS0tzJgxg6SkJKZMmXLMNBF38vLyyMjIID4+/rjN9EajkYiICCIiImhoaMBqtVJQUEB6ejoWi8UhBnU6HcHRgVzzyAyueWQGJbllbF21g61fbSdnf77D4LkT+S/DttY2FCoFu9enoVBIhMX3wT/Mj4OygROvIDN5afK0DS05HSkhdZX1HNh1GJ9gL0pyy9EZtQT1C0Cn1xAzOJTyoioqy2opPOz02PPwNnJgt3O4I2pQqIttjNHijDrTG7UclIlBvxAvrEXtwlGpUpJ7wHlfvUkDtAtAjVZFc1MrcQOCoaUNdWsbxXvavw6ePkaqZAMaFZXOrW9vPw/Kypwi0iazYPG0GKiQGUS7aGQJqmXeiGqNqziUZ/tq1BLIWgAd4l+vob/Bg8YNhRzp6EHU+2hcEkQkt0ET98SXxkbnc9SyqeRTrQAWFxezb98+F/HXiXs/a2e27qFDh9i3bx/e3t6OIRKdTneMJ3Qfv/76K9dccw1/+9vfuOuuu4T4EwhOEiEABYJjoFarufTSS7n00kt566232Lx5M8nJyTz44IPU1tYyffp0kpKSuPTSS9Hr9Uddb7fbOXDgALm5uQwdOtQxlHIy6PV6+vbtS9++fR29WcXFxWRmZmI2mx32Mnq9Hr9QH2bdN5VZ902loriKbWt2svWr7ezbnEHUkL4uXoO+Id5k/NJembPZ7ORmFFJbWU9pXjmWPmZ8g30wWTzYU+jchowc1Ndluzh2RJSjJ7GxrgmNTs2uH1Id7yeM60dtZT2BIX2RFBJ6TwP5WVbKS2poaWp12cbUGjQckgm+vv2DSd/lFIdVFU5xFhrjz+HsUpQqCbNFi4+PJx4GA011TaiUEuk7cxypGH37O82KfYM8qapyCkC7zSnWlGrX/rsGWa+e2ctVALbKTaA9dFQ2OYWa+5aoPAXE4mmivLTS8VolSYz09qHwf9kcrsnF4u80c9a6CTd3LSNfg6SQXCqAavXpCcCioiJSU1MZNGgQfn5+xz23M1u3M1+3vr6ekpISioqKyMjIwMPDA39/f/z8/DAajd0uxlJSUkhKSmLhwoXcd999QvwJBKeAEIACwUmgVCqZPHkykydPZtGiRWzbto3k5GQWLFhAaWkp06ZNIykpialTp2IymWhoaODzzz8nOjqaESNGYDKZTvvZOp2O0NBQQkNDaW5uxmq1YrVayc7OxmQyuUTSeQV4Mv32KUy/fQo15bXsXLeXzT4/s2t9Ki1Nre2mz3nOIYe4kdGk/tTuNViZX43FYmbXr3vwCrQQFBWAHTiy31kdVGmUFB1yVuHce/8kSaI0r5zinPaKllqrQmfUUtORtBEaG0RdaTURMX6otWrMfh7U1zQ5lI7epCV+cHvMmEqtpLXVRlxCEK1NrRhMavQ001DZTE1dPfuK2wUlQMKoKOcalAqKcp2fUWuQVWolqChxikqLtyfWImclr1Rmku3eD9ggE1seZh2VshQQu9ssb5VsolnbMZEb6GUixK5CtauUzBSnyK0/jreg+4hwi6yyqNerqZOllMi3qE82B7ioqIi0tLSTEn9dYTAYHH+oNDc3U1pa6uhp1Wq1ju9NT0/PMy7O9u7dy6xZs3jiiSd4+OGHhfgTCE4RIQAFglNEqVQybtw4xo0bxyuvvMKOHTtYvnw5zzzzDHfddReTJ08mJycHm83Gpk2bMBgMJ77pSaLRaI7KJ7ZarRw6dAi9Xu+oDJpMJjy8TUy6fgyTrh9DfXUDO9ft4acvt6M1aGiqb8bkaeDgniMu9+/sMasoqqSiqJL4sf1orK4jamAIGoMWjU7L7o37Hef3Gx7hMl0cMzScTFnMXPTgvg4fQWjv75P7DPZNCHEMf5gsBhrqmhzedvGjo9n/q/PelmAPGmraRVdITACHZWkk8oGMwFBvCvMqHa/lXnnefh6UVTjFmXzIQq1RUlfrFHWNTc7+P4Aa2QSw3qhBHsIrj4FTqhQ0tbS/VkgSFrWawQodOWuzOWi3EzXAmaOrUitoPoaIA1erGYAm2ZavVucmAJVOAXQyFcDCwkL279/PoEGD8PX1PeH5J0Kj0biYT5eVlVFSUsKuXbsAHEMk3t7ev3nKPi0tjZkzZ/Lggw/yxBNPCPEnEJwGQgAKBL8BhULBiBEjGDFiBM8//zzffPMNc+bMQa1WU1tby5w5c5g1axYzZ87EYrGc0V9UXeUTW61Wfv31VzQajUMMms1mDGY9468exfirR9HU0MzOdXvY+s12tq3Y6bhf7Mgox/YwgH+oDxm/HKCttY2sHYfQGrVodGp8A834hfnQ0txKfbVr3m1djevriuJq53q1KkcvIYB/mI9D/EF7dXC/zDRaHrum99RSWeys3BnNMlEtSRTKUj4svh4uArBSlvNrcROAjbItXx9/M4Wy9SpVsiqaBJWyqWeNxvVHp7znT69TYjJo6GsyUL4zFxWl5MgGZJpl1jJGDz1VsilkpcpNALa5CsBGWYScVqcG2bVyY2q94fgVwM7e0osuuggfH5/jnns6uCfkdJpPZ2Rk0NTU5DJEIjefPhkyMjKYOXMmd911FwsXLhTiTyA4TXreLL9AcJ6ye/dubr/9dq677jpycnLYtm0bo0aNYsmSJURERJCUlMT7779PSUnJGXf178wnHjRoEJMmTaJfv340Nzezc+dONm/eTHp6OhUVFdjtdtRaFaYILSNvGMC76a+wMPlhLr1lAs0ywQXgFWihTTZ0EDMknJqyWqw5paT+mIFCgry0XEKj/IgfGclFE2Ox5pQ6zo+6KIwi2TBI9EV9Xaxj/EJdhUeDbFDDaNZ3mFm3ExTuWqGqlQmfwDAf6uXCU2aWrNaqKJFNHLtbucjFocnsOsAgKZwiz8ND5zKB29Ts+rWqq29Cp1US7qOjv15P2w8HOPDlHipyKo4yepaLTvf1KJSuYsZ96KOh3nmtxm3wRG4S7R5FJ6e7xZ87CoUCLy8vYmNjGTduHKNGjcLDw4OcnBw2bdrE9u3bycnJoaGh4YT3ys7OZubMmdx00008++yzQvwJBL8BUQEUCM4QarWaJ554gj/84Q9IkkR8fDwLFy7kz3/+M9nZ2SxfvpwPPviAhx56iHHjxpGUlMSsWbMICAjo1nzizhzY3bt3I0kSkiShUCgYNmwYer2eYVMHMWzqINrabKT+mM6Wr3ZwJDXPJZfY6Gng4B6nN58ktVf32lrbHJF1EYPCsDU2ERYTiIe3CY1Ri9Gso66jSiivDkpKBfkHnB5+Fn8zR/a7VgMzdjqrZvJqnFavJk82Dezl70FRnjMDuVomMgNCvMmTVQdlQ76oNUoqypzJJ2q39Iw6WW+exdtIlcxYurWtveJnMqgIMGtpLqqkPs1KSZsd88AQl4xe+WQxuPb8aU/Qq9csi6VTa5Q0y7aaVZpj//g+lg1Mfn4+GRkZDB48GG9v7+M+uzuQm09HRkY6Bpw6o+mMRqNjiMTDw8Pl/4vDhw8zc+ZMrr76al566aUe6UUoEJxPCAEoEJwhBgwYwIABA446LkkSMTEx/PGPf2TBggUcPnyY5ORk/vOf//Doo48yevRohw9hnz59zqgYVCgU+Pr64uvrS2RkJNu3b8dms9HW1sbPP//smk+sVDBoUjyDJsVjt9tJ/zmbrV/tYOvqHfiF+pD6Y4bjvrEjo0iX9fb1jQ/h8L72wYYjqXkERQVQeKAYSZIICPclKDqQ5sZWQqL9Kcopo2//Pi7+fsFR/lSWOIdJGhudIkmhVJCf7RSLfaIDOJjmFIvyYqpKraJIluTh4WUAmQCslYlQ30BPCgudQx/uX/cKWXVQZ2yvqOl0akKCPPHWabC3lFP8cx7FKgVtdtm1kmvNr7VFNrmrVFAvq3S6byW7Vwvl28V6g5Zm2VSySnXsPrquegDz8vLIzMxkyJAhpzSR3p3IB5xaWlooLS2lpKSEI0eOoFarycnJwWQyMXDgQK688kquuOIKFi1aJMSfQHAGEP8XCQRnEUmSiIiI4NFHH+Wnn37i0KFDXHvttaxZs4b4+HguvvhiXn/9dQ4fPnxGt4nr6urYvn07np6ejB8/nokTJzJ48GDUajXp6els2LCBvXv3UlxcTFtbG5Ik0X90DLc9/zv+te9lbnv+91zz6Ez6xAQ6qn9yNG49ZxY/M9BuhVN0qISm2kZSN+8nZ+8R2uoaMBrVxA7qQ/9hfYmMD3bZflZplORnOyt8obGBLqJJb3Tdqi0tcq4lKNzbZejDPTu3RLZuD4urdU+TrI/P6KGlqakF/wAz/fv546NWEK4E9h0h57+7KNuTQ3F6u1eiwdN1PY1NrluZTbLPZjRp3QSre8+fa7VQvl2s1buKRYVb3rB8YMS9BzA3N7fHiT931Go1QUFBDBo0iMmTJ9O/f38yMzO57777GDFiBEqlkosvvpi6uroT3+wMsHjxYiIiItDpdAwbNozNmzcf9/ympiaeeuop+vbti1arJSoqivfee++srFUgOB0k+5luRhIIBKeM3W6nqKiIlStXkpyczKZNmxg4cCCJiYkkJSURHR192pXBqqoqUlJSCA4OJiYm5qj72O12ampqsFqtFBcX09jYiK+vr2Mrzj3pITc9ny1ftRtPH9qbS3B0AIUHnRU6s6+JhppGh0WL3qzD1mJzCCGTxUhjQwutHYLLP9QHa24ZepMODz8jRj89Oo0RhVJJY2MLlgAL+3ccpqlDDIXEBpHXURE0exuplnn89R8RyX5ZjFzf/kEcyWo/18vfg3LZAEjCiL6k7srDYNRg8TbiG2CmtakFW2MTSruNAzsP09QRJxc/Ooq0X2QTyf5mKkvbt49DYwLIPejsfYwfGUlaRyYygIefgZry9sqdb7AnpcXObef4YX1Jk/keRg3sQ7ZsK1xt0DqmhEPCfciVRdjFDw4lVVZFjR0YTHrHtYveupHIqHZD59zcXLKzsxkyZAgWi4XzieLiYqZPn05MTAwJCQmsWrWKgwcP8vjjj/PMM89023OXLVvGzTffzOLFixk3bhz//Oc/effdd0lLSyMsLKzLaxITEykuLua5554jOjoaq9VKa2srY8eO7bZ1CgS/BSEABYIeht1up7S0lK+++ork5GR++OEHYmNjHfnE/fv3P2kxWFpayp49e4iKinIE0J/o2XV1dRQXF2O1Wqmrq8PHx8chBt0nNgsPWtm1PpUfPvmR7J3tVcuE8bEu28UJ4/q5RNPFj4slbUuW4/WAcbHs+0m2vTwqysW8uk9MEPnZxeg9dPj08UGpUaLRa1FpVHh4GahvaHX4CBrNeurqmgAJu92OUq1sH96w29EbNNTWNNLW1EJzXRNmHyOZ2w/RVNfuQ6jWqRyiNWZIX7L3OP0PY4dFkJHS0ZMogUKldEzoRl8USvY+53Rz3PBw0mUi1GgxUFfTLgC9Ag1UlDi3cRNGhJO603luWFwARzqqn0qlglZZ/EhEbAAHZUIzYUgo+/Y6BWB0/0Cystqtcd5+71aCgy3k5ORw4MCB81L8lZaWcsUVV5CQkMAnn3zi+EMkMzOTuro6hgwZ0m3PHjVqFEOHDmXJkiWOY/379ycpKYnnn3/+qPO/+eYbfve733Hw4MFz0lspEJwOogdQIOhhSJKEn58fd9xxB7fffjuVlZWsWrWK5ORkXn31Vfr27UtiYiKzZ89mwIABx+yHKigoYP/+/SeMoHN/dmeTflRUFPX19RQXF5OXl8f+/fvx8vJyDJhotVqCIv0JivRn+u1TKM0vZ9uanez+IRWFQnJMzZbmV7g8o0rW6wdQku/s2ZMUEgXZTn8/Tz8P8jteN9Q0ojeoyZL5DCaM60fqVqeYDIz0dxhV+wZbKJNtD8ePiSZ9m7NvMSw+pF38ARZfE5WygRCN1nULtbFelvtrVNNYLx/OcD23RTa40d7zJx8m8aSixFktrapy3UqX+/zpjRpq6pxbwMfr+QPXiWG9Xs2RI0c4ePAgQ4cOxdPT87jX9jTKy8uZNWsWMTExfPzxxy5V6H79+nXrs5ubm9mxYwcLFixwOT516lS2bNnS5TWrVq1i+PDhvPTSS3z00UcYjUZmzZrFs88+22VKkEDQExACUCDowUiShJeXF3PmzGHOnDlUV1ezZs0akpOTueSSSwgMDHRsEw8dOhSFQoHNZmPDhg1IksTgwYN/k9WHwWA4Kp+4M/bL09PTIQb1ej2+fbyZefelzLz7UipLqvl5zU4yfjnAxv9sc9wvODqQ/CxnznBQdACFMsEXnhDCYVkucVBUIFWlTtGmcZvUrZFFxWn1GqxHnBUyryAvFwEon8wFKC92DoB4+nm4CEDcCqw1MtsZD4uBxnqniHW3bnHp+fPQUVsjm/p1E5ZqtdvksSxBRGfQughApcpV6NvcU0JanAKwpKSQ/Pzc81L8VVZWkpiYSEhICMuWLTvqa9TdlJaW0tbWRkBAgMvxgIAAioqKurzm4MGD/Pjjj+h0OlauXElpaSn33nsv5eXlog9Q0GMRAlAgOI8wm83ccMMN3HDDDdTW1vLf//6X5ORkZs6ciZeXF1deeSX5+fn89NNP/PLLL2fU502eT9zU1OSIpMvKynJkwAYEBGAwGLD4mZl262Sm3TqZ2/72O3757y62rd5BQ20zBTL7F5XeVTwZzK7VEvehiAqrq7F0/gGneAyM8OOIzGha6yYW5d6BJk+Diyeh3uQ6yCGv4iFJVMni7jy8zJQUOF/b3JSYfGDFXQDKzZoBlAo3Q2nZ0AeS62d3v9bdXqa5o6dSkiA/P5dhw4ZhNps5n6iuruaqq67C19eX5cuXn7JJ9Jmkq17ZY7Ve2Gw2JEnik08+cQju1157jWuuuYa33npLVAEFPRIhAAWC8xSTycS1117LtddeS0NDA2vWrOHxxx+npKSEkJAQXnzxRRITExk7duxRgxy/Fa1W65JP3OnlduDAAYeXW0BAAEajEZOXkYtvGMfFN4yjobaRHd/t4ceVv7Jj3V6qily3g+XG0ZJCQV6ms+JishgolInH4OgAF8Fnshhd7tUsi4cD161o72ALtZlO8ah0E1dyY2kPi54a2aCJVuf6tWxtcTVrlgtNd6NndwEhz/ZVKBUuwlOldl1Ta6vr55FPOwM0dfQvqtWK81L81dbWcs0112AwGPjyyy/R6XQnvqgb8PX1RalUHlXts1qtR1UFOwkKCqJPnz4u1db+/ftjt9vJy8sjJiamW9csEJwOwgZGILgAaGlp4e2338bHx4e0tDReffVVmpubuemmm4iJieGBBx7ghx9+oKWl5cQ3O0U0Gg19+vRhyJAhTJo0ifDwcGpra/n555/ZsmUL2dnZVFdXY7fb0Zt0DJmWwLi7BvHk2nu4d9FcJl8/BqOngT79AimXpXaExgVTX+0UU8FRAS7WOO6Cr7W11eV1uczyxSvQ0yVpxL3S6J64USXbDlbpXX9MSm5isalRbtWidsn2dd+ytnPsbF+DSevynslscnldV++aTdzsJjzrO7aejUbdeSf+6uvrue6661AqlaxateqcVsw0Gg3Dhg1j3bp1LsfXrVt3zInecePGUVBQQG2t8/smMzMThUJBSEhIl9cIBOcaUQEUCC4ADh48iMVi4auvvsJkMhEWFsaMGTN4++232bhxI8uXL+eOO+6gpaWFmTNnkpSUxOTJk9FqtSe++SnQ6eUWFBREW1ubI594+/btqNVqvLy8KCkpoU+fPu2WNEMlRs8YQmtLK6lbsvhp5a/8vHYX1aU1eHi5Cjz35IumRtc4tnKZqbPeQ0dZgbPi5xVgdvEudM/clVf8tAaNy/awp5cHFUXO1+69hPWyLV6Tp4Em2ZCL++BGW6vrtQ0yY2edQU2N3OjZTWiaPTwBp8CorpJVTyXntrXBeGb/m3Y3jY2N/P73v6e5uZlvvvkGk8l04ou6mfnz53PzzTczfPhwxowZwzvvvENOTg7z5s0D4I9//CP5+fl8+OGHANxwww08++yz3Hrrrfz1r3+ltLSUxx57jNtuu01s/wp6LKICKOhxnKoB68aNGxk2bBg6nY7IyEjefvvts7TSnsPgwYNJTk4+6penWq3m0ksv5e233yYvL4/k5GQ8PDx44IEHiIiI4I477mDNmjUnlcN6qiiVSgICAhg4cCCTJk0iJCSEoqIibDabY5CkvLwcm82GSq3iokn9uXfRLby3/xWeXfUo/UdH4xNkcdyvrFA2TSxJjmlfAKOnnpI85zRxQJhr76PO4N7j51otlPf4efm7Vs8MJsNxr62pdA6iGDxcn+Pet9fS4nptvUzwafXHzwVuc+v5Uyqd1UW12nmu+xZ1T6apqYmbbrqJqqoq1q5d22Mql9dffz2LFi3imWeeYfDgwWzatIm1a9c6rJQKCwvJyXHa95hMJtatW0dlZSXDhw/nxhtv5Morr+SNN944Vx9BIDgh589PCkGvYNmyZTz00EMuBqzTp08/pgHroUOHuOKKK7jzzjv5+OOP+emnn7j33nvx8/Pj6quvPgefoOeiUqmYPHkykydP5vXXX2fbtm0sX76cJ554gtLSUi6//HISExOZNm0aRqPxxDc8BcrLyzl06BBxcXEEBwdTUVFBcXExe/fuxW63O6aJvb29USoVDBgfy4DxsdzwZCKZ2w/xyze7+enL7Y77+Ye1m0d3EtDXj4N7nYbKRrOraHOv2tXIKnxag4ZqWeybxi1xw73vv7HeWXnU6tUOg2roasvXFfmWr1qrdOn5c4+Fc+8XPFbPH4DBqKO5o4rZ1FTPtm3bHDF/JpPpjMYLnilaWlqYO3cuhYWF/O9//+txPoX33nsv9957b5fvffDBB0cdi4uLO2rbWCDoyQgjaEGP4lQNWJ944glWrVrF/v37HcfmzZvH7t272bp161lZ8/mOzWZj+/btLF++nJUrV1JQUMBll11GYmIi06dP/81VmcLCQvbv309CQsJRTfR2u53KykqH8XRbW5tbPrHrFuqhvblsXb2T/Oxitqze6TieMNbVDzB+dAz7f5F5/vUPJie9I2FDktAYtI4hkaAIPwpl9jHBcb4UZjmrjbHDI8jYecTx2hLg6cgt9g22UFrsrB66m0DHDQsnXZb04RPsRVnHVrTFx0hlpbPyGjMohMw051BL/NC+pO52WuKExQZwRGYErdSrHDnDAUGeFJW033f4yHDuvGc0VquV0tJStFqtQ2B7enr2CDHY2trKbbfdRkZGBj/88AN+fn7nekkCQa9DVAAFPYbTMWDdunUrU6dOdTk2bdo0li5dSktLy1n3EDsfUSgUjBw5kpEjR/LCCy+we/dukpOTefnll7nnnnu49NJLmTVrFjNmzMBisZySgMjNzSUrK4uLLrqoS0uaTp9DLy8vYmNjqa6upri4mMzMTJqbmx2RdL6+vqhUKiIGhhIxMLT93pmFbFuTwrY1KTQ3uQ63yP0BwXUC2CvATEWJs5fOZDGAU9/h4eFBIc7z5RU/SSG53NvgoYNiuSeg2+Su26CGa8+fBmQCUHmcbF9wtaZRKCWH+IN2SxzHmgxalz7MsrIyrFYrKSkpKBQKhxj08vI6pol4d9LW1sa8efNIS0tj/fr1QvwJBOcIIQAFPYbTMWAtKirq8vzW1lZKS0tPOgFD0I5CoWDIkCEMGTKEZ599lrS0NJYvX85bb73F/fffz+TJk0lKSmLmzJn4+PgcUwza7XYOHjxITk4OQ4cOPantPUmS8PT0xNPTk5iYGGpraykuLubgwYOkpqa6RNKp1WpC+wUROj+Ia+dfQfGRUrZ9vYuta1LI3nWY4hzn9rDF3+yo2HW+lgtAtZs5s+TmAl1b5dwu9rAYqJaJNve+Pfc9X/mEsMItFeSonj83Mdbm5oEov5daLdEmaydUq52VUr3svkql0iH4bDYbFRUVWK1WUlNTHdVWPz8/h/VJd9PW1sYDDzzA9u3b2bBhwzFtVQQCQfcjBKCgx3EqBqzHOr+r44JTQ5IkEhISSEhIYOHChWRlZbF8+XLee+89/vCHPzB+/HiSkpK48sorCQgIcHy929rayMzMxGq1MmLEiNOa6pQkCQ8PDzw8PIiOjqa2thar1UpOTg5paWl4e3s7hI1GoyGgry+J915K4r2XUlZYyc9rd7Ht612k/XwA70CLiwDUu03J1je42qs0yERauwm0rFroZXQRgO6Tye6DGg2y6qHBpKNWdm+15vg/fuUVPoBGmQA0mvQ0ytchSwnRG7o2T1YoFPj4+ODj40NcXBzV1dVYrVays7PZt2/fUQL7TGOz2Xj44YfZvHkz69evJzg4+Iw/QyAQnDxCAAp6DKdjwBoYGNjl+SqV6oymYPR2JEmiX79+PPnkk/zxj3/k0KFDJCcns2zZMh555BHGjBlDYmIil19+OY8//jhBQUG89NJLZ8wCozOfODIykvr6eqxWKwUFBaSnp2OxWAgICMDPzw+dTodPkIUrbp/MFbdPpqq0ht0b09mY/Ct7f8xo35KV3Eyfa10noOUDIWYvI9XyxBCjW9XO3di5yW3KV2YvYzBpXQSgSu1acXPvxnafNpaLSZ3ebftYtvWs051YvMmrrdHR0dTV1bkI7M7M586v6W/FZrPx+OOPs27dOjZs2NDlQJdAIDi7CAEo6DHIDVhnz57tOL5u3ToSExO7vGbMmDGsXr3a5dh3333H8OHDRf9fNyFJEpGRkTz22GM8+uij5ObmsmLFCpYvX87ChQvx9vZm2LBhFBcX07dv3zNeiTUYDISHhxMeHk5jYyNWq5Xi4mIyMjIwm80EBAQ48ok9fT2YePUIJl49grqqerav28f+Xw+SvTvHMQRikxX8lGqliwm02dvgIgA1btvF7n168hxgpVLpsuXrngribvNyVLSbTEyqNUqaZZPMarXrj275vY5VATwWkiS5CGz3zGez2ewYzDmd6XCbzcaf/vQnVq1axfr164mIiDjlewgEgjOPEICCHsWpGrDOmzePN998k/nz53PnnXeydetWli5dymeffXYuP0avQZIkwsLCuPXWW1m5ciUJCQlcd911fPPNN7zwwgsMGjSIxMREEhMTiY6OPuNiUKfTERYWRlhYGM3NzS75xCaTySEGjUYjRk8Dk64ZyYSrhjPsqmhSfzpASWYde7dkO+7n7W+mtMhpGK0zHd/Xz33IQy74jJ46qmURcvJBDegiFs5ty7dBJiZVGonmJrvstWv1UH4v/UlUAI+HPPPZPebPYDA4tt49PDxO+N/Tbrfz7LPPsmzZMtavXy8i0QSCHoQQgIIexfXXX09ZWRnPPPMMhYWFDBgw4LgGrBEREaxdu5aHH36Yt956i+DgYN544w3hAXiW+cMf/oDBYGDt2rUYjUYeffRRSktL+fLLL0lOTua5554jLi6OxMREkpKSiIuLO+NiUKPREBISQkhICC0tLZSUlDiGSPR6PQEBAfj6+pKdnY2NNm64fzYajYbmxhZ2b85g2zd7KM4pcxGAao1bxc/NT1A+IQyuAyMGk9ZVALr1/J3Klq/Jw0B9k3NrWt7z586pVgCPR2fMX58+fRyDVfJkl04x2NV0uN1u54UXXuD999/nhx9+IC4u7oytSyAQ/HaED6BAIGPx4sW8/PLLFBYWkpCQwKJFi5gwYUKX527YsIEpU6YcdXz//v297pddWVkZHh4eaDRHiw+73U5FRQWrVq0iOTmZdevWERERQWJiIrNnzyYhIaFb7Ug6hUtRURElJSUoFAr69OlDUFAQZrPZRbi0tbaxb2s2277Zyy/f7SM42p+0Xw453o8eHEb2Hqc3n08fL8o6BKPeqKFBZvQcHhfE4Syr43X8iAjSdjr/eIkdEkaG7F4Bfb0pyq8E2qPq5KlxIZG+5OY6rWn6XxRCWqrMM3BwCKn78gH409OzGDk66pS/TqeCzWZz2MuUlLQnsvj5+aHX6wkMDESv1/P3v/+dv//97/zwww9cdNFF3boegUBw6ogoOIGgg84UkqeeeoqUlBQmTJjA9OnTXSqOXZGRkUFhYaHjX2/c5vLx8elS/EH79qS3tzdz585l9erVFBcX86c//YmsrCwuvvhiBg8ezJ///Gd27NhxVB/cmaBzIKi5uRkvLy8SEhJoaWlh586d/Pjjj2RkZFBRUYHdbkepUnLRhFju/r9r+NfPC7nx0SuYMXc8vh2RdI11rhW/GtkghtHimj5y1Jav27rct4/lU75aneuPZo3bwIikcO8fdKpFnbs1TTegUCjw8/MjISGBSZMmcdFFF6FSqXjjjTcICwvj4osv5oUXXiA5Ofmsir9TjZHs5KeffkKlUjF48ODuXaBA0IMQFUCBoINTTSHprABWVFT0uBir84Xa2lrWrl3LihUrWLt2Ld7e3syaNYukpCRGjBhxRrzpmpub2blzJ1qtlkGDBjnu6V7FkiTpuCbJ2Xty2f5DGpvX7KboSFlHxc8p4sJiAsg56Mwn7j88nP0pucd8HdYvgJwDzvM1Jq3D68/DS0d1tVMQxgwIJjOj2PE6YUgo+/bmO173GxBERnr7NPyrb/yemH6Bp/fF+o20tbXxf//3f3zxxRcA5OXlcemll3Lttdcyd+7cbn32smXLuPnmm11iJN99991jxkh2UlVVxdChQ4mOjqa4uJhdu3Z16zoFgp6CqAAKBDhTSNxTRY6XQtLJkCFDCAoK4pJLLmH9+vXducwLDpPJxHXXXcfnn39OUVERixYtoqKigquvvpr+/fvzyCOPsHnzZlpbW098sy5oampi+/btGAwGLrroIhdBKa9iTZw4kYEDBwKwb98+Nm3aRGpqKiUlJY6qZPSgUH730DTe+v5xXl39EFfdczFhMU57Io3BtV/QXUDa2twmhmUVP6VK4fLaw+w6batUuVnGuH3OVllOsP4sVAC7wm638+GHH7J48WI++OADDhw4wL59+5g0aRI7d+488Q1+I6+99hq33347d9xxB/3792fRokWEhoa6/EHXFXfffTc33HADY8aM6fY1CgQ9CTEEIuhWWlpaaGlpwWAwnPjkc8jppJAEBQXxzjvvMGzYMJqamvjoo4+45JJL2LBhAxMnTjwby76gMBgMJCUlkZSURGNjI//73/9ITk7mxhtvRKVSMXPmTGbPns348eNPyuKnoaGBHTt2YLFYiI+PP26foUKhwNvbG29vb+Li4qiqqqK4uJj09HRaW1vx9fUlICDAkU8cHhdEeFwQV909hYJDpWz7bh+5B6xk73P25bmLtObjDHnojVpqZDFxWp2bzYuia7PzTlpbnZXIcyEA7XY7H3/8MQsWLGD16tWOvtmYmBgef/zxbn/+6cRIArz//vscOHCAjz/+mOeee667lykQ9CiEABR0K9u3b+f111+nvLycyZMnc//992M2m8/1so7JqaSQxMbGEhsb63g9ZswYcnNzeeWVV4QA/I3odDpmzJjBjBkzaGlpYcOGDSxfvpzbbruNtrY2Zs6cSVJSEpMnT+6y97C+vp4dO3bg6+t7yhPHkiRhsViwWCz069fPkZiRlZXF3r17HWKwM584OMKXq+6eDMDvH7qMn9elsW1dKja3KLfmRte84noXU2jXNajcfP5wW39b27FzgvX6s+t/abfb+c9//sMjjzzCihUrmDx58ll9PpzeH3BZWVksWLCAzZs3o1L9tl+Fc+fOpbKyki+//PKY5+Tl5REZGUlkZCTp6em/6XkCwZlAbAELug273U5ra6ujv+ZPf/oT33333bleVpecTgpJV4wePZqsrKwzvbxejVqt5rLLLuOf//wn+fn5LF++HKPRyH333Ud4eDh33nkna9asobGx3XJlx44d/Pvf/yYgIOA32810JmbExMQwduxYRo4ciclk4tChQ2zcuJGUlBQKCgpoaWkXd/7BXlw5Zxz/9/FdPPra9dz51AwGjopEqVK4VPw0WpXLEIhC7fqjWHkcmxfoIidYVl08G0MgclauXMkDDzzAsmXLjmqhONuc7B9wbW1t3HDDDfz1r3+lX79+Z2VtH3zwAddddx319fX89NNPZ+WZAsHxEBVAQbchSRITJkxgwoQJ/P3vfyciIoIhQ4Ycdd6Jsn7PBqeTQtIVKSkpBAUFdccSBbRP9E6ePJnJkyfzxhtvsHXrVpKTk3n88ccpLy9n4sSJbNq0iVtuuYWYmJgz+n0lzyeOiorqMj6tM5JOq9Xi5evB5deP5PLrR1JTWc/2TZlsWZfGnp8PYfDQ0Vzh9Az09DRRVuKcKHbfrj5qy9dtgripIzVEq1UdtV3cnaxZs4a7776bTz75hBkzZpy157pzqn/A1dTUsH37dlJSUrj//vuB9qEgu92OSqXiu+++4+KLLz5j67Pb7bz//vssXryYkJAQli5dyrhx487Y/QWC00EIQEG30tLSglqt5pNPPmHixImOAHibzeb4Jdf5S7qz2b47PeGOx6mmkCxatIjw8HASEhJobm7m448/Jjk5meTk5HOy/t6GUqlk/PjxjB8/nldffZX33nuP+++/n/DwcN5//33y8/NJTExk+vTpeHh4nPHnG41GIiIiiIiIcMSndeYTe3p6OlJIdDodHhYDU2YNZsqswdTXNpGyJYu1y7dxYJ+VlmYbareIOXfPGPeKX7O7hUxHasjZrP5988033HbbbXzwwQckJSWdted2xan+AWc2m9m7d6/LscWLF/PDDz+wfPnyMx5Xt379eurr67n00ksJCQlh1KhRvP76693yfSkQnCxCAAq6FbVaTVVVFTt37mTBggXo9XrAKfK2bdvmsIpwt1I525XBU00haW5u5tFHHyU/Px+9Xk9CQgJff/01V1xxxVlbs6CdTZs2MX/+fF599VXuuecedu/ezfLly3nxxRe55557uOSSS0hMTGTGjBl4enqe8e8reXxaY2OjI4UkMzMTs9nssJcxGAzoDGoMfi3Mun0gCfED2fvLETJT88k9XEZ95yCI2wRJW6vblq/bBHHnFPDZ6v/74YcfuOWWW3jnnXe45pprzsozT8Sp/AGnUCgYMGCAy/WdYt39+Jlg6dKl/O53v0OpVJKQkEB0dDTLli3jjjvuOOPPEghOFuEDKOg2WltbUalUvP322zz99NP8+OOPREdHA1BQUMBDDz1Eeno6KpWKjIwMZs2axeLFi/Hy8nIRf2lpaWzdupX4+Hhh1SDokjVr1lBSUsKtt97qctxut5Oamsry5ctZuXIl6enpTJ48maSkJGbOnIm3t3e3/pHRmaVbXFxMeXk5RqORtrY2lEolw4cPd5lmbmlpY8+vh9j6QzqlJbXs3n7E8V5YvwCOHCp1vDZ6Gaitae95NHpoqe2oAEZE+fH6Wzd12+eBdrF97bXX8o9//IM5c+ac8/YNOYsXL+all15y/AH397//3TGQNXfuXA4fPsyGDRu6vPbpp5/myy+/PC0fwOMNgVRWVhIUFMSPP/7IsGHDAHjllVdYsWLFCS2mBILuRAhAQbfRuc07evRooqOjWbJkCR4eHtTV1XHvvfeSl5fHypUrMZvN7Nmzh/nz5zNt2jQee+wxoH2S84EHHmDTpk1ERESwc+dOdDodTz/9NLfccssxkyfONzZt2sTLL7/Mjh07KCwsZOXKlSfcUtu4cSPz588nNTWV4OBgHn/8cUelQ9A1drudzMxMkpOTWbFiBbt372bChAkkJSVx5ZVX4u/v361iprGxkZSUFBobG7HZbOj1evz9/QkICMBkMrlF0tlI3ZXD1g2Z/LwpE62HjsKOmDgApU7lqPr5+JkorWjPCY4f0IcXXrmu2z7Dli1buOqqq3jllVe48847e5T4O5ccTwAuXryY++67z8WD0m63Y7PZSE1NJT4+/iyuVCBwIqaABd1Cp/hraGjgl19+YebMmZhMJgB+/fVXNm7cyNatW/nLX/7C//73PwYNGsQll1zCunXrACgpKWHhwoVs2LCBr7/+mu+++47i4mJeffVV6uvrT8oH7nyhrq6Oiy66iDfffPOkzj906BBXXHEFEyZMICUlhSeffJIHH3xQ9B6eAEmSiI2N5cknn+TXX38lIyOD6dOn89lnn9GvXz+mT5/OkiVLyM/PP2ro4rfS1tZGamoqSqWSCRMmMGnSJKKioqivr+fXX3/lp59+IjMzk6qqqo5IOgWDhodz96NTeffL+3hwweXMunYYfgFm1Gqli/GzRuPs5OnOLeBffvmFa665hr/97W9C/J0CS5cu5ZFHHmHXrl2Of7t372bKlCm8995753p5gl6MqAAKzjjNzc0899xzGAwGmpubWbJkCT/99BORkZEAfPjhh9x9990sX76cTz75hPXr16NQKFAoFMTExLB69Wq+/vprnn/+eUaOHOlIaLj55pvx9PSkuLj4lKxZzickSTphBfCJJ55g1apV7N+/33Fs3rx57N69m61bt56FVV5Y2O12cnNzWbFihWNbbsSIEY5IurCwsN8kdtra2ti1axc2m40hQ4Yc5TnX1tbmEkmnVCpdIuncn52dUcSWzVls/TGbgrwKwiJ9OZJTBsD4if14/MkzP427c+dOrrzyShYuXMhDDz0kxJ8bc+fO5ciRI/z97393OV5dXc2kSZPYv38/cXFxLu/961//4qmnniI/P/+C+oNWcP4ghkAEZ5zOX2Avvvgi+fnteaWLFy/mtttuIz4+npKSEsLDwx1GvzU1NWzevJlvv/0Ws9mM0Whk/fr17N27l6amJkwmE1u2bOHLL7/k888/v2DF38mydevWo/zWpk2bxtKlSx1T14KTR5IkwsLCeOihh/jDH/7g2IZPTk5m4cKFDBo0iKSkJBITE4mKijol8dPW1kZKSgp2u71L8Qe4CD6bzUZ5eTlWq5U9e/YgSRJ+fn4EBAQ48omjYwOJjg3kljsmcORQKbt2HuF/36dx+FBpt6SA7Nmzh8TERBYsWCDE33HYsGHDUTZXM2fOJD4+/ijxB5CUlMQ999zD6tWrueqqq87WMgUCB6ICKOhWysrK+Oijj/jnP/9JeHg4n3/+Obt37+b3v/89zz//PLfccstR1xQWFjJr1iyampr4/vvv8ff35+DBgyQmJjJz5kyef/75c/BJzg4nUwHs168fc+fO5cknn3Qc27JlC+PGjaOgoED4EJ4h7HY7paWlDjG4fv164uLiHGLwRCbTra2tpKSkIEkSQ4YMcekBO9nnV1RUYLVasVqttLW1OcSgt7f3UfcryK+gqqqB/vHBp/V5uyItLY3p06fzwAMP8Oc//1mIP4HgAkJUAAXdio+PDw899BAPPfQQDQ0N6PV6Jk6cyG233cZrr73GwYMHmTFjBiUlJURFRREbG0tjYyN5eXnMnz8ff39/WlpaiIyM5OKLL+bHH38EXH0EeyNdJR50dVxw+nRW3+666y7uvPNOKioq+Oqrr1ixYgUvvfQSkZGRJCYmMnv27KOyhjvFn0KhYPDgwacs/jqf35lPHBsbS1VVFVarlfT0dFpaWlwi6ZRKJcF9vAju43XGPn9GRgYzZ87krrvuEuJPILgA6b2/QQVnHb1e7xAqf/7zn/nDH/7At99+y7XXXsvSpUvJzc0FIDg4mPr6eqKiogCnqNm+fTsxMTHAuTOL7gkEBgZ2mXigUqnw8fE5R6u6sOkUY7feeiurV6+muLiYJ598koyMDKZMmcKQIUP4y1/+ws6dOyktLWXq1KkcPnz4tMVfV8/vzCYeP348w4cPx2AwkJ2dzYYNG9i9ezeFhYWOSLrfSnZ2NjNnzuTmm2/m2WefFeJPILgAEVvAgnNOU1MTOTk5hIWFodVqaWpq4o477qCiooKVK1dit9v53//+x4wZM/j666+ZPn36uV5yt3GyQyCrV68mLS3Nceyee+5h165dYgjkHFBbW8vatWtJTk7m66+/xmAwEBAQwEsvvcSECRO6/Y+V2tparFYrxcXF1NXV4ePjg7+/P35+fqdllXT48GEuv/xykpKSWLRoUa/+Y0sguJARAlDQI9mxYwc33XQTNpuN2NhYUlNTmTRp0gVpm1BbW0t2djYAQ4YM4bXXXmPKlCl4e3sTFhZ2VATdoUOHGDBgAHfffTd33nknW7duZd68eXz22WdcffXV5/Kj9GoqKyu57LLLsNlsxMXFsXbtWkwmE1deeSVJSUmMGTPmjFQDj0d9fb1DDNbU1ODl5eUYMNFqtSe8Pjc3l8svv5xp06axePFiIf4EggsYIQAFPRa73c6KFSvYv38/06dPZ+DAgWg0mrMeEdfdbNiwgSlTphx1fM6cOXzwwQddJhhs3LiRhx9+2GEE/cQTTwgj6HOIzWZjwoQJeHt7s3z5crRaLY2NjXz//fesWLGCr776CrVazZVXXsns2bMZN25ct09rNzY2OsRgVVUVnp6eDjHYGckop7CwkGnTpjFp0iTeeeedbherAoHg3CIEoEDQyznVJJJjCdauvM56E5s3b2bkyJFdVtpaWlpYv349ycnJfPnll7S1tTFz5kySkpKYPHlyt6faNDU1OaaJKyoq8PDwcCSfhIeHU1xczPTp0xk5ciTvv//+WRN/ixcv5uWXX6awsJCEhAQWLVrEhAkTujx3xYoVLFmyhF27dtHU1ERCQgJPP/0006ZNOytrFQguNER9XyDo5ZxqEkknGRkZFBYWOv51Duj0ViZMmHDMbVa1Ws3UqVP55z//SX5+Pl988QVGo5H77ruPiIgI7rrrLtasWUNjY2O3rE2r1RIaGsqwYcOYOHEiISEhlJaWMnr0aBISErj88ssJDw9n6dKlZ038LVu2jIceeoinnnqKlJQUJkyYwPTp08nJyeny/E2bNnHZZZexdu1aduzYwZQpU7jyyitJSUk5K+sVCC40RAVQIBA4OJkhlM4KYEVFBRaL5ayt7UKkra2NLVu2kJyczMqVK6msrOTyyy8nMTGRqVOnYjAYuvX5Bw4cYN68eeTl5VFSUkJoaChXX301t956a7cL+lGjRjF06FCWLFniONa/f3+SkpJO2uszISGB66+/noULF3bXMgWCCxZRARQIBKfFkCFDCAoK4pJLLmH9+vXnejnnJZ3ZwIsWLeLQoUN89913hIWFsXDhQsLDw7nxxhv54osvqKmpOePPrqysZO7cuXh7e5OVlUVJSQl/+9vfOHz4MJmZmWf8eXKam5vZsWPHUYk2U6dOZcuWLSd1D5vNRk1NDd7e3t2xRIHggkcIQIFAcEoEBQXxzjvvkJyczIoVK4iNjeWSSy5h06ZN53pp5zUKhYJRo0bx8ssvk5mZyaZNm+jfvz8vvPAC4eHhXH/99Xz66adUVlbyWzduqqurueqqq/Dz8+OLL75Ao9FgNBq5+uqr+fTTT5kx48znCcspLS2lra3tqFjHgICAozwuj8Wrr75KXV0d1113XXcsUSC44BFJIAKB4JSIjY0lNjbW8XrMmDHk5ubyyiuvMHHixHO4sgsHhULB0KFDGTp0KP/3f/9Hamoqy5cv54033uC+++5jypQpJCUlMWPGDLy9vU9pKr62tpZrrrkGo9HIypUr0el03fhJjk9XiTYn81k+++wznn76ab766iv8/f27a3kCwQWNqAAKBILfzOjRo8nKyjrXy7ggkSSJAQMG8PTTT7N792727NnDxIkT+de//kVkZCSzZs3i3Xffpbi4+ISVwfr6eq677jqUSiVfffVVl3YwZ4PO+LquEm3cq4LuLFu2jNtvv53//Oc/XHrppd25TIHggkYIQIFA8JtJSUkhKCjoXC/jgkeSJGJjY3nyySfZvn076enpTJs2jU8//ZR+/foxffp0lixZQkFBwVFisLGxkd///vc0NzezevVqTCbTOfoUoNFoGDZsGOvWrXM5vm7dOsaOHXvM6z777DPmzp17VrapBYILHbEFLBD0cuRJJNCeNLJr165jJpEsWrSI8PBwEhISaG5u5uOPPyY5OZnk5ORz9RF6JZIkERUVxeOPP85jjz1Gbm6uY5p4wYIFjBgxglmzZpGUlERAQAA33XQTVVVVfPfdd5jN5nO9fObPn8/NN9/M8OHDGTNmDO+88w45OTkOQ3P377vPPvuMW265hddff53Ro0c7qod6vR5PT89z9jkEgvMWu0Ag6NWsX7/eDhz1b86cOXa73W6fM2eOfdKkSY7zX3zxRXtUVJRdp9PZvby87OPHj7d//fXX52bxgqOw2Wz2vLw8+z/+8Q/7lClT7Eql0m6xWOz9+vWzl5WVnevlufDWW2/Z+/bta9doNPahQ4faN27c6HjP/ftu0qRJx/0+FQgEp4bwARQIBIILFLvdTklJCU888QSPPPIIAwYMONdLEggEPQTRAygQnAfYbLbfbP3RU3n++ecZMWKEI54sKSmJjIyME163ceNGhg0bhk6nIzIykrfffvssrPb8QpIk/P39ef/994X4EwgELggBKBCcBygUCoc9hs1mO8erObNs3LiR++67j23btrFu3TpaW1uZOnUqdXV1x7zm0KFDXHHFFUyYMIGUlBSefPJJHnzwQdGHKBAIBCeJ2AIWCHowhYWFPP744+j1em688UYmTZp0rpfU7ZSUlODv78/GjRuP6Sv4xBNPsGrVKvbv3+84Nm/ePHbv3s3WrVvP1lIFAoHgvEVUAAWCHsz27dtJSUlh8+bNXHvttfj7+/Pcc89RVVV1rpfWbXR+tuNFfG3duvWoGLFp06axfft2WlpaunV9AoFAcCEgBKBA0IPZtm0bfn5+/PDDD1itVl5//XU+/PBDVq5cCXDB9QXa7Xbmz5/P+PHjj9uzVlRU1GWMWGtrK6Wlpd29TIFAIDjvEQJQIOihWK1WUlNT6dOnD4GBgQBcd911+Pn58e6771JdXe0Sm9Xa2grAW2+9xbRp03jzzTdpbGw8J2s/Xe6//3727NnDZ599dsJzu4oR6+q4QCAQCI5GCECBoIeyY8cOrFYrV155pUPU1NbWEhwcTE1NzVFmvkqlEmg3zD1y5AgLFy5kxYoVLue0tbX12KrhAw88wKpVq1i/fj0hISHHPTcwMLDLGDGVSoWPj093LlMgEAguCIQAFAh6KL/88gtpaWksWbKEdevWUV1dzWuvvca6deuYNWsW4Kz62e12JEni8OHDHDlyhKeffpry8nJuuOEGAKqrq2lra0OpVPa4aWK73c7999/PihUr+OGHH4iIiDjhNWPGjDkqRuy7775j+PDhqNXq7lqqQCAQXDAIASgQ9EDKysrYvXs3I0aMYNCgQdx11114eXmxdOlSbr75Zu69916g3R4GnGJuxYoVeHt7u4gou93Ohx9+iFqtZuzYsfzrX/+iqanJce255r777uPjjz/m008/xcPDg6KiIoqKimhoaHCc88c//pFbbrnF8XrevHkcOXKE+fPns3//ft577z2WLl3Ko48+ei4+gkAgEJx3CBsYgaAHsm7dOp5++mluvPFGh9grKSmhoKCAiy666KjzOyuAkydPJiIigpdffhlfX18AGhoamD17Nq2trVx++eW899571NXV8fTTT3Prrbee1c/VFcfq2Xv//feZO3cuAHPnzuXw4cNs2LDB8f7GjRt5+OGHSU1NJTg4mCeeeMKRIysQCASC4yMEoEDQA3niiSfYuHEj//rXvxg4cCCtra2oVKouz+0Uf/n5+YwaNYqFCxdy1113Od7PyMhg6NChJCcnc/nllwPt/Xbff/89K1euJC4uDrvdjt1u7zFVQYFAIBB0L+KnvUDQw2htbcXf35+YmBgGDhwIcEzxB67bvxaLhUGDBrm8v2nTJhQKBZMnT6a5uRmAG2+8kYyMDAoLC4H2Klyn+JMPinTeu6mp6Qx+wp7F6UTRbdiwAUmSjvqXnp5+llZ9bli8eDERERHodDqGDRvG5s2bj3u+iOsTCHouQgAKBD0MlUrFI488wkcffQSc2OuvU7h99dVXDB06lKioKMd7tbW1fPvtt4wfPx6dTodGowHao9T0ej06nY6srCxeeuklvvnmGwCXQZHOe7/55ptERkbywAMPUFxcfGY/8DnmdKLoOukU0Z3/YmJizsKKzw3Lli3joYce4qmnniIlJYUJEyYwffp0cnJyujxfxPUJBD0cu0Ag6FHYbDZ7W1vbSZ9rt9vtRUVF9pCQEPvixYtd3s/IyLCHhobaJUmyjx492v7888/b//rXv9qNRqN99uzZ9ry8PPvKlSvts2fPtkdFRdl9fHzsr7zyiuO+nTQ2Nto//PBDuyRJ9o8++ujMfNAeitVqtQP2jRs3HvOc9evX2wF7RUXF2VvYOWbkyJH2efPmuRyLi4uzL1iwoMvzH3/8cXtcXJzLsbvvvts+evToblujQCA4eUQFUCDoYci3Y09E5xbtl19+iYeHx1EDIlu3bqW0tJR9+/Zx7bXX8vXXX/Pxxx/z4IMP8tprr9GnTx9mzJjBihUryM7O5sUXX+SDDz5g27ZtLvfRarX4+/vj4eFxwecRn0wUXSdDhgwhKCiISy65hPXr13f30s4Zzc3N7Nix46j4valTp7Jly5YurxFxfQJBz+bYjUUCgaDH07lVu2rVKoYNG0bfvn0d7zU1NbFq1SouueQS4uPjiY+PZ/78+S7XFxUV8d///pempiamTp3K7bffzvPPP096ejpjxoxxDJgAvPvuu4wZM+aEJs3nM/aTjKILCgrinXfeYdiwYTQ1NfHRRx9xySWXsGHDBiZOnHgWV3x2KC0tpa2trcv4PXdD7k5OFNcXFBTUbesVCAQnRghAgeA8RqFQUFZWxsaNG1m4cCF9+vRxvJebm8vKlSv5+OOPgfbhDnBWGL/99lv+9Kc/YbPZ8PLy4sknn8Tb25uGhgbH0Een+Kurq+P777/n5ZdfvqCj1jqj6H788cfjnhcbG0tsbKzj9ZgxY8jNzeWVV165IAVgJ13F7x3v+0HE9QkEPRexBSwQnOeUl5czfPhwFixYwD333OM47uvry4IFC7jqqquA9uGOzrg4gH//+9/06dOHd955hzVr1pCfn8/YsWOxWCyEhoYCzi3mDRs20NjYyKWXXnoWP9nZ5VSi6Lpi9OjRZGVldcPKzj2+vr4olcou4/fcq3ydiLg+gaBnIwSgQHCeExMTw/r169m9eze33XYb0C7cLBYLf/vb39DpdC7nKxQKbDYbPj4+FBUVMWjQIHQ6HXq9noKCAkJDQ0lISHC55tNPP2Xs2LGEhYWdtc91trCfRhRdV6SkpFyw25oajYZhw4YdFb+3bt06xo4d2+U1Iq5PIOjZiC1ggeACQJIkh2cgOEVepz+dOwqFghtuuIEVK1ZwxRVXMG3aNFavXs2OHTt4+OGHCQ8Pd5zX0NDAt99+y7PPPntBGkXfd999fPrpp3z11VeOKDoAT09P9Ho90B5Fl5+fz4cffgjAokWLCA8PJyEhgebmZj7++GOSk5MvaIuT+fPnc/PNNzN8+HDGjBnDO++8Q05OjiN9xf1rNG/ePN58803mz5/PnXfeydatW1m6dCmfffbZufwYAoGgAyEABYILlBOJtTFjxvDjjz+yePFiGhoaSEhIICcnh/j4eKC9iqhQKNi8eTM1NTVHTXReKCxZsgSAyZMnuxyXR9EVFha6+N01Nzfz6KOPkp+fj16vJyEhga+//porrrjibC37rHP99ddTVlbGM888Q2FhIQMGDGDt2rWOwSP3r1FERARr167l4Ycf5q233iI4OJg33niDq6+++lx9BIFAIENEwQkEAgAqKyvZvHkzgwcPJjQ0lJaWFtRqNbfeeisHDhxg/fr1Lj2EAoFAIDh/EQJQIOjF2O12bDbbcYVdQEAATz31FA8++OBZXJlAIBAIuhOxBSwQ9GIkSXKIP7vdjt1uR6FQcOTIET7//HM8PT2prKxk+vTp53ilAoFAIDiTCAEoEAgAXAZGWltb2bt3L8uWLWPixIkX5PSvQCAQ9GbEFrBAIDgmpaWlNDY2XtDpHwKBQNAbEQJQIBAIBAKBoJdx4Zl6CQQCgUAgEAiOixCAAoFAIBAIBL0MIQAFAoFAIBAIehlCAAoEAoFAIBD0MoQAFAgEAoFAIOhlCAEoEAgEAoFA0MsQAlAgEAgEAoGglyEEoEAgEAgEAkEvQwhAgUAgEAgEgl6GEIACgUAgEAgEvQwhAAUCgUAgEAh6GUIACgQCgUAgEPQyhAAUCAQCgUAg6GUIASgQCAQCgUDQyxACUCAQCAQCgaCXIQSgQCAQCAQCQS9DCECBQCAQCASCXoYQgAKBQCAQCAS9DCEABQKBQCAQCHoZQgAKBAKBQCAQ9DKEABQIBAKBQCDoZQgBKBAIBAKBQNDLEAJQIBAIBAKBoJchBKBAIBAIBAJBL0MIQIFAIBAIBIJehhCAAoFAIBAIBL0MIQAFAoFAIBAIehlCAAoEAoFAIBD0MoQAFAgEAoFAIOhlCAEoEAgEAoFA0MsQAlAgEAgEAoGglyEEoEAgEAgEAkEvQwhAgUAgEAgEgl6GEIACgUAgEAgEvQwhAAUCgUAgEAh6GUIACgQCgUAgEPQyhAAUCAQCgUAg6GUIASgQCAQCgUDQyxACUCAQCAQCgaCXIQSgQCAQCAQCQS9DCECBQCAQCASCXoYQgAKBQCAQCAS9DCEABQKBQCAQCHoZQgAKBAKBQCAQ9DKEABQIBAKBQCDoZQgBKBAIBAKBQNDLEAJQIBAIBAKBoJchBKBAIBAIBAJBL+P/Aeft12mJRdUnAAAAAElFTkSuQmCC", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "XX,YY = np.meshgrid(p_ext,LA_int)\n", - "\n", - "fig1 = plt.figure()\n", - "ax1 = plt.axes(projection='3d')\n", - "\n", - "ax1.plot_surface(XX, YY, Qs_ext,cmap='viridis', edgecolor='none')\n", - "ax1.set_xlabel('P [Pa]')\n", - "ax1.set_ylabel('LA')\n", - "ax1.set_zlabel('Q [m³/s]')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "a = T1.raw_csv" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Turbinen/old/messy.ipynb b/Turbinen/old/messy.ipynb deleted file mode 100644 index b7cc1dc..0000000 --- a/Turbinen/old/messy.ipynb +++ /dev/null @@ -1,278 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from numpy.polynomial import Polynomial\n", - "from numpy.polynomial.polynomial import polyval\n", - "from Turbinen_class_file import Francis_turbine_class\n", - "from mpl_toolkits import mplot3d\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#importing pressure conversion function\n", - "import sys\n", - "import os\n", - "current = os.path.dirname(os.path.realpath('messy.ipynb'))\n", - "parent = os.path.dirname(current)\n", - "sys.path.append(parent)\n", - "from functions.pressure_conversion import pressure_conversion\n", - "%matplotlib widget" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": {}, - "outputs": [], - "source": [ - "T1 = Francis_turbine_class()\n", - "csv = T1.raw_csv\n", - "\n", - "T1.extract_csv()\n", - "ps = T1.raw_ps_vec\n", - "LAs = T1.raw_LA_vec\n", - "Qs = T1.raw_Qs_mat\n", - "\n", - "Q_fun = T1.get_Q_fun()" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [], - "source": [ - "p_min = np.min(ps)\n", - "p_max = np.max(ps)\n", - "\n", - "n_p = 100\n", - "n_LA = 200\n", - "\n", - "ps_vec = np.linspace(p_min,p_max,n_p)\n", - "ind1 = np.argmin(np.abs(ps_vec-np.min(ps)))\n", - "ind2 = np.argmin(np.abs(ps_vec-np.max(ps)))\n", - "LA_vec = np.linspace(0,1,n_LA)\n", - "\n", - "Q_int = np.reshape(Q_fun(ps_vec,LA_vec),[n_LA,n_p])" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [], - "source": [ - "poly_deg = 7\n", - "n_LAs = np.size(LAs)\n", - "fit_coeff_mat = np.empty([n_LAs,poly_deg+1])\n", - "fit_weights = np.ones_like(ps)\n", - "fit_weights[0] = 1000\n", - "\n", - "for i in range(n_LAs):\n", - " x = ps\n", - " y = Qs[i,:]\n", - " fit_coeff_mat[i,:] = np.polynomial.polynomial.Polynomial.fit(x,y,poly_deg,w=fit_weights).convert().coef\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [], - "source": [ - "Qs_poly = np.empty([n_LAs,n_p])\n", - "for i in range(n_LAs):\n", - " Qs_poly[i,:] = polyval(ps_vec,fit_coeff_mat[i,:])" - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 92, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "667375b5fbc34d41b8d8238cc1cbfa8d", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "XX1,YY1 = np.meshgrid(ps,LAs)\n", - "\n", - "fig1 = plt.figure()\n", - "ax1 = plt.axes(projection='3d')\n", - "\n", - "ax1.plot_surface(XX1, YY1, Qs,cmap='viridis', edgecolor='none')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": 93, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "98df0bde396247f29d513c1229bb1f54", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "XX2,YY2 = np.meshgrid(ps_vec,LA_vec)\n", - "\n", - "fig2 = plt.figure()\n", - "ax2 = plt.axes(projection='3d')\n", - "\n", - "ax2.plot_surface(XX2, YY2, Q_int,cmap='viridis', edgecolor='none')" - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 94, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6278e4d6be114c629d964392d9b296ce", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig3 = plt.figure()\n", - "ax3 = plt.axes()\n", - "\n", - "# ax3.scatter(XX1[-1,:], (Qs[-1,:]-((XX1[-1,:]-XX1[-1,0])/(XX1[-1,-1]-XX1[-1,0])*(Qs[-1,-1]-Qs[-1,0])+Qs[-1,0])))\n", - "# ax3.scatter(XX2[-1,:], (Q_int[-1,:]-((XX2[-1,:]-XX2[-1,ind1])/(XX2[-1,ind2]-XX2[-1,ind1])*(Q_int[-1,ind2]-Q_int[-1,0])+Q_int[-1,ind1])))\n", - "ax3.plot(XX2[-1,:], Q_int[-1,:],'.-')\n", - "ax3.plot(ps_vec, Qs_poly[-1,:],'+')\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/untertweng.txt b/untertweng.txt deleted file mode 100644 index 1c6adb3..0000000 --- a/untertweng.txt +++ /dev/null @@ -1,22 +0,0 @@ -L = 535 m dn 800 mm -478 m dn 1000 mm -Ersatzdurchmesser - -h_pipe - -h 851.78 Pegel + Leitungsgefälle -Leitungsgefälle: 113 - -Fläche 4.25x10.5 + 30m² = 74 m² -Pegelminimum: 851.18 m - -Unterwasserpegel 738.56 -Gesamtfallhöhe = 851.78-738.56 - -Rohrreibung: 0.014 f_D = lambda -c = 500 m/s - -Q_0 = 100%*0.75+30%*0.75 -Q_extrem = 30%*0.75 - -Q = LA*Q_nenn*sqrt(H/H_n)