diff --git a/Ausgleichsbecken/Ausgleichsbecken_class_file.py b/Ausgleichsbecken/Ausgleichsbecken_class_file.py index eb01f6b..b00d957 100644 --- a/Ausgleichsbecken/Ausgleichsbecken_class_file.py +++ b/Ausgleichsbecken/Ausgleichsbecken_class_file.py @@ -1,5 +1,4 @@ import numpy as np -# from Ausgleichsbecken_functions import FODE_function, get_h_halfstep, get_p_halfstep #importing pressure conversion function import sys @@ -34,6 +33,9 @@ class Ausgleichsbecken_class: velocity_unit_print = 'm/s' volume_unit_print = 'm³' + g = 9.81 # m/s² + rho = 1000 # kg/m³ + # init def __init__(self,area,outflux_area,level_min = 0,level_max = np.inf ,timestep = 1): self.area = area # base area of the rectangular structure @@ -58,16 +60,26 @@ class Ausgleichsbecken_class: self.set_volume() def set_influx(self,influx): - self.influx = influx + self.influx = influx def set_outflux(self,outflux): self.outflux = outflux - self.outflux_vel = outflux/self.area_outflux + self.outflux_vel = outflux/self.area_outflux def set_pressure(self,pressure,pressure_unit,display_pressure_unit): self.pressure = pressure self.pressure_unit = pressure_unit self.pressure_unit_print = display_pressure_unit + + def set_steady_state(self,ss_influx,ss_level,pressure_unit,display_pressure_unit): + ss_outflux = ss_influx + ss_outflux_vel = ss_outflux/self.area_outflux + ss_pressure = self.rho*self.g*ss_level-ss_outflux_vel**2*self.rho/2 + + self.set_initial_level(ss_level) + self.set_influx(ss_influx) + self.set_outflux(ss_outflux) + self.set_pressure(ss_pressure,pressure_unit,display_pressure_unit) # getter def get_info(self, full = False): new_line = '\n' @@ -86,7 +98,7 @@ class Ausgleichsbecken_class: f"Volume in reservoir = {self.volume:<10} {self.volume_unit_print} {new_line}" f"Current influx = {self.influx:<10} {self.flux_unit_print} {new_line}" f"Current outflux = {self.outflux:<10} {self.flux_unit_print} {new_line}" - f"Current outflux vel = {self.outflux_vel:<10} {self.velocity_unit_print} {new_line}" + f"Current outflux vel = {round(self.outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" f"Simulation timestep = {self.timestep:<10} {self.time_unit_print} {new_line}" f"----------------------------- {new_line}") @@ -98,7 +110,7 @@ class Ausgleichsbecken_class: f"Volume in reservoir = {self.volume:<10} {self.volume_unit_print} {new_line}" f"Current influx = {self.influx:<10} {self.flux_unit_print} {new_line}" f"Current outflux = {self.outflux:<10} {self.flux_unit_print} {new_line}" - f"Current outflux vel = {self.outflux_vel:<10} {self.velocity_unit_print} {new_line}" + f"Current outflux vel = {round(self.outflux_vel,3):<10} {self.velocity_unit_print} {new_line}" f"Current pipe pressure = {round(p,3):<10} {self.pressure_unit_print} {new_line}" f"----------------------------- {new_line}") diff --git a/Ausgleichsbecken/Main_Program.ipynb b/Ausgleichsbecken/Ausgleichsbecken_test.ipynb similarity index 70% rename from Ausgleichsbecken/Main_Program.ipynb rename to Ausgleichsbecken/Ausgleichsbecken_test.ipynb index 9a76e26..eea80ce 100644 --- a/Ausgleichsbecken/Main_Program.ipynb +++ b/Ausgleichsbecken/Ausgleichsbecken_test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -21,16 +21,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# define constants\n", - "initial_level = 5. # m\n", - "initial_influx = 0.5 # m³/s\n", - "initial_outflux = 0. # m³/s\n", - "initial_pipeline_pressure = 1\n", - "initial_pressure_unit = 'bar'\n", + "initial_level = 10. # m\n", + "initial_influx = 5. # m³/s\n", + "initial_outflux = 1. # m³/s\n", + "initial_pipeline_pressure = 10.\n", + "initial_pressure_unit = 'mWS'\n", "conversion_pressure_unit = 'mWS'\n", "\n", "area_base = 1. # m²\n", @@ -41,33 +41,33 @@ "\n", "# for while loop\n", "total_min_level = 0.01 # m\n", - "total_max_time = 300 # s" + "total_max_time = 1000 # s" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "%matplotlib qt\n", "\n", "V = Ausgleichsbecken_class(area_base, area_outflux, critical_level_low, critical_level_high,simulation_timestep)\n", - "V.set_initial_level(initial_level) \n", - "V.set_influx(initial_influx)\n", - "V.set_outflux(initial_outflux)\n", - "\n", - "converted_pressure, V.pressure_unit = pressure_conversion(initial_pipeline_pressure,input_unit = initial_pressure_unit, target_unit = conversion_pressure_unit)\n", - "V.pressure = converted_pressure\n", + "# V.set_initial_level(initial_level) \n", + "# V.set_influx(initial_influx)\n", + "# V.set_outflux(initial_outflux)\n", + "# converted_pressure,_ = pressure_conversion(initial_pipeline_pressure,input_unit = initial_pressure_unit, target_unit = 'Pa')\n", + "# V.pressure = converted_pressure\n", + "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", "\n", "time_vec = np.arange(0,total_max_time,simulation_timestep)\n", "outflux_vec = np.empty_like(time_vec)\n", - "outflux_vec[0] = initial_outflux\n", + "outflux_vec[0] = V.outflux\n", "level_vec = np.empty_like(time_vec)\n", - "level_vec[0] = initial_level\n", + "level_vec[0] = V.level\n", "\n", - "pressure_vec = np.full_like(time_vec,converted_pressure)*((np.sin(time_vec/5)+1)*np.exp(-time_vec/50))\n", - " \n", + "# pressure_vec = np.full_like(time_vec,converted_pressure)*((np.sin(time_vec)+1)*np.exp(-time_vec/50))\n", + "pressure_vec = np.full_like(time_vec,V.pressure)\n", " \n", "i_max = -1\n", "\n", @@ -82,7 +82,15 @@ " if V.level < total_min_level:\n", " i_max = i\n", " break\n", - "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ "\n", "fig1, (ax1, ax2, ax3, ax4) = plt.subplots(4, 1)\n", "fig1.set_figheight(10)\n", @@ -98,16 +106,16 @@ "ax2.set_xlabel(r'$t$ ['+V.time_unit+']')\n", "ax2.legend()\n", "\n", - "ax3.plot(time_vec[:i_max],pressure_vec[:i_max], label='Pipeline pressure at reservoir')\n", - "ax3.set_ylabel(r'$p_{pipeline}$ ['+V.pressure_unit+']')\n", + "ax3.plot(time_vec[:i_max],pressure_conversion(pressure_vec[:i_max],'Pa',conversion_pressure_unit)[0], label='Pipeline pressure at reservoir')\n", + "ax3.set_ylabel(r'$p_{pipeline}$ ['+conversion_pressure_unit+']')\n", "ax3.set_xlabel(r'$t$ ['+V.time_unit+']')\n", "ax3.legend()\n", "\n", "# plt.subplots_adjust(left=0.2, bottom=0.2)\n", "ax4.set_axis_off()\n", - "cell_text = np.array([[initial_level, V.level_unit], \\\n", + "cell_text = np.array([[level_vec[0], V.level_unit], \\\n", " [initial_influx, V.flux_unit], \\\n", - " [initial_outflux, V.flux_unit], \\\n", + " [outflux_vec[0], V.flux_unit], \\\n", " [simulation_timestep, V.time_unit], \\\n", " [area_base, V.area_unit], \\\n", " [area_outflux, V.area_unit]])\n", @@ -133,7 +141,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.8.13 ('Georg_DT_Slot3')", + "display_name": "Python 3.8.13 ('DT_Slot_3')", "language": "python", "name": "python3" }, @@ -152,7 +160,7 @@ "orig_nbformat": 4, "vscode": { "interpreter": { - "hash": "84fb123bdc47ab647d3782661abcbe80fbb79236dd2f8adf4cef30e8755eb2cd" + "hash": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" } } }, diff --git a/Druckrohrleitung/Druckrohrleitung_class_file.py b/Druckrohrleitung/Druckrohrleitung_class_file.py index 94143dd..f682643 100644 --- a/Druckrohrleitung/Druckrohrleitung_class_file.py +++ b/Druckrohrleitung/Druckrohrleitung_class_file.py @@ -41,7 +41,7 @@ class Druckrohrleitung_class: self.n_seg = number_segments self.angle = pipeline_angle self.f_D = Darcy_friction_factor # = Rohrreibungszahl oder flow coefficient - self.density = rho + self.rho = rho self.g = g self.dx = total_length/number_segments @@ -89,8 +89,8 @@ class Druckrohrleitung_class: 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 + def set_boundary_conditions_next_timestep(self,v_reservoir,p_reservoir,v_turbine): + rho = self.rho c = self.c f_D = self.f_D dt = self.dt @@ -108,6 +108,14 @@ class Druckrohrleitung_class: self.p[0] = self.p_boundary_res.copy() self.p[-1] = self.p_boundary_tur.copy() + + def set_steady_state(self,ss_flux,ss_level_reservoir,pl_vec,h_vec,pressure_unit,display_pressure_unit): + ss_v0 = np.full(self.n_seg+1,ss_flux/(self.dia**2/4*np.pi)) + ss_pressure = (self.rho*self.g*(ss_level_reservoir+h_vec)-ss_v0**2*self.rho/2)-(self.f_D*pl_vec/self.dia*self.rho/2*ss_v0**2) + + self.set_initial_flow_velocity(ss_v0) + self.set_initial_pressure(ss_pressure,pressure_unit,display_pressure_unit) + # getter def get_info(self): new_line = '\n' @@ -150,7 +158,7 @@ class Druckrohrleitung_class: def timestep_characteristic_method(self): #number of nodes nn = self.n_seg+1 - rho = self.density + rho = self.rho c = self.c f_D = self.f_D dt = self.dt diff --git a/Druckrohrleitung/Main_Programm.ipynb b/Druckrohrleitung/Druckrohrleitung_test.ipynb similarity index 100% rename from Druckrohrleitung/Main_Programm.ipynb rename to Druckrohrleitung/Druckrohrleitung_test.ipynb diff --git a/Regler/Regler_class_file.py b/Regler/Regler_class_file.py new file mode 100644 index 0000000..c205257 --- /dev/null +++ b/Regler/Regler_class_file.py @@ -0,0 +1,140 @@ +import numpy as np +#based on https://en.wikipedia.org/wiki/PID_controller#Discrete_implementation + +def trap_int(vec,timestep): + l = np.size(vec) + int = 0 + for i in range(l-1): + int = int + (vec[i]+vec[i+1])/2*timestep + return int + + +def ISE_fun(error_history,timestep): + # calcuate the integral of square error + e = np.array(error_history) + dt = timestep + ise = trap_int(e**2,dt) + return ise + +def IAE_fun(error_history,timestep): + # calcuate the integral of absolute error + e = np.array(error_history) + dt = timestep + iae = trap_int(np.abs(e),dt) + return iae + +def ITSE_fun(error_history,timestep): + # calcuate the integral of time multiply square error + e = np.array(error_history) + dt = timestep + n = np.size(e) + t = np.arange(0,n)*dt + itse = trap_int(t*e**2,dt) + return itse + +def ITAE_fun(error_history,timestep): + # calcuate the integral of time multiply absolute error + e = np.array(error_history) + dt = timestep + n = np.size(e) + t = np.arange(0,n)*dt + itae = trap_int(np.abs(e),dt) + return itae + +class P_controller_class: + # def __init__(self,setpoint,proportionality_constant): + # self.SP = setpoint + # self.Kp = proportionality_constant + # self.error_history = [] + # self.control_variable = 0.1 + # self.lower_limit = -0.1 # default + # self.upper_limit = +0.1 # default + + # def set_control_variable_limits(self,lower_limit,upper_limit): + # self.lower_limit = lower_limit + # self.upper_limit = upper_limit + + # def calculate_error(self,process_variable): + # self.error = self.SP-process_variable + # self.error_history.append(self.error) + + # def get_control_variable(self): + # new_control = self.control_variable+self.Kp*(self.error_history[-1]-self.error_history[-2]) + # if new_control < self.lower_limit: + # new_control = self.lower_limit + + # if new_control > self.upper_limit: + # new_control = self.upper_limit + + # self.control_variable = new_control + # # print(new_control) + # return new_control + def __init__(self): + pass + + +class PI_controller_class: + def __init__(self,setpoint,deadband,proportionality_constant,Ti, timestep): + self.SP = setpoint + self.db = deadband + self.Kp = proportionality_constant + self.Ti = Ti + self.dt = timestep + self.error_history = [0] + + self.cv_lower_limit = 0 # default + self.cv_upper_limit = +1 # default + + + def set_control_variable_limits(self,lower_limit,upper_limit): + self.cv_lower_limit = lower_limit + self.cv_upper_limit = upper_limit + + def calculate_error(self,process_variable): + self.error = process_variable-self.SP + self.error_history.append(self.error) + + def get_control_variable(self,process_variable): + + self.calculate_error(process_variable) + + cv = self.control_variable + Kp = self.Kp + Ti = self.Ti + dt = self.dt + + e0 = self.error_history[-1] + e1 = self.error_history[-2] + if abs(self.error) > self.db: + new_control = cv+Kp*(e0-e1)+dt/Ti*e0 + else: + new_control = cv + + if new_control < self.cv_lower_limit: + new_control = self.cv_lower_limit + + if new_control > self.cv_upper_limit: + new_control = self.cv_upper_limit + self.control_variable = new_control + return self.control_variable + + def get_performance_indicators(self,ISE=True,IAE=True,ITSE=True,ITAE=True): + ise = np.nan + iae = np.nan + itse = np.nan + itae = np.nan + + # self.error_history[1:] because the first value of the error history is set to [0] + # to avoid special case handling in the calculation of the controll variable + if ISE == True: + ise = ISE_fun(self.error_history[1:],self.dt) + if IAE == True: + iae = IAE_fun(self.error_history[1:],self.dt) + if ITSE == True: + itse = ITSE_fun(self.error_history[1:],self.dt) + if ITAE == True: + itae = ITAE_fun(self.error_history[1:],self.dt) + + return ise,iae,itse,itae + + diff --git a/Regler/regler_test.ipynb b/Regler/regler_test.ipynb new file mode 100644 index 0000000..bad0931 --- /dev/null +++ b/Regler/regler_test.ipynb @@ -0,0 +1,343 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from Regler_class_file import PI_controller_class\n", + "\n", + "#importing Druckrohrleitung\n", + "import sys\n", + "import os\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 Ausgleichsbecken.Ausgleichsbecken_class_file import Ausgleichsbecken_class\n", + "from Turbinen.Turbinen_class_file import Francis_Turbine" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "#define constants\n", + "\n", + "#Turbine\n", + "Q_nenn = 0.85\n", + "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "\n", + "# physics\n", + "g = 9.81 # gravitational acceleration [m/s²]\n", + "rho = 1000. # density of water [kg/m³]\n", + "\n", + "# define controller constants\n", + "target_level = 8. # m\n", + "Kp = 0.1\n", + "Ti = 100.\n", + "deadband_range = 0.05 # m\n", + "\n", + "# reservoir\n", + "initial_level = target_level\n", + "initial_influx = Q_nenn/2 # initial influx of volume to the reservoir [m³/s]\n", + "initial_pressure_unit = 'Pa' # DO NOT CHANGE! for pressure conversion in print statements and plot labels \n", + "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", + "area_base = 74. # total base are of the cuboid reservoir [m²] \n", + "area_outflux = 1. # outflux area of the reservoir, given by pipeline area [m²]\n", + "critical_level_low = 0. # for yet-to-be-implemented warnings[m]\n", + "critical_level_high = np.inf # for yet-to-be-implemented warnings[m]\n", + "\n", + "p0 = rho*g*initial_level-0.5*rho*(initial_influx/area_outflux)**2\n", + "\n", + "# offset the pressure in front of the turbine to get realisitc fluxes\n", + "h_fict = 100\n", + "offset_pressure = rho*g*h_fict\n", + "\n", + "t_max = 1e3 #s\n", + "nt = int(1e6) # number of simulation steps of reservoir in between timesteps of pipeline \n", + "dt = t_max/nt\n", + "\n", + "t_vec = np.arange(0,nt+1,1)*dt\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# create objects\n", + "\n", + "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,dt)\n", + "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", + "\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "T1.set_steady_state(initial_influx,p0+offset_pressure)\n", + "T1.set_closing_time(500)\n", + "\n", + "Pegelregler = PI_controller_class(target_level,deadband_range,Kp,Ti,dt)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "level_vec = np.full(nt+1,V.level)\n", + "LA_ist_vec = np.full(nt+1,T1.LA)\n", + "LA_soll_vec = np.full(nt+1,T1.LA)\n", + "Q_vec = np.full(nt+1,initial_influx)\n", + "\n", + "Pegelregler.control_variable = T1.LA" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "10.0\n", + "20.0\n", + "30.0\n", + "40.0\n", + "50.0\n", + "60.0\n", + "70.0\n", + "80.0\n", + "90.0\n", + "100.0\n", + "110.0\n", + "120.0\n", + "130.0\n", + "140.0\n", + "150.0\n", + "160.0\n", + "170.0\n", + "180.0\n", + "190.0\n", + "200.0\n", + "210.0\n", + "220.0\n", + "230.0\n", + "240.0\n", + "250.0\n", + "260.0\n", + "270.0\n", + "280.0\n", + "290.0\n", + "300.0\n", + "310.0\n", + "320.0\n", + "330.0\n", + "340.0\n", + "350.0\n", + "360.0\n", + "370.0\n", + "380.0\n", + "390.0\n", + "400.0\n", + "410.0\n", + "420.0\n", + "430.0\n", + "440.0\n", + "450.0\n", + "460.0\n", + "470.0\n", + "480.0\n", + "490.0\n", + "500.0\n", + "510.0\n", + "520.0\n", + "530.0\n", + "540.0\n", + "550.0\n", + "560.0\n", + "570.0\n", + "580.0\n", + "590.0\n", + "600.0\n", + "610.0\n", + "620.0\n", + "630.0\n", + "640.0\n", + "650.0\n", + "660.0\n", + "670.0\n", + "680.0\n", + "690.0\n", + "700.0\n", + "710.0\n", + "720.0\n", + "730.0\n", + "740.0\n", + "750.0\n", + "760.0\n", + "770.0\n", + "780.0\n", + "790.0\n", + "800.0\n", + "810.0\n", + "820.0\n", + "830.0\n", + "840.0\n", + "850.0\n", + "860.0\n", + "870.0\n", + "880.0\n", + "890.0\n", + "900.0\n", + "910.0\n", + "920.0\n", + "930.0\n", + "940.0\n", + "950.0\n", + "960.0\n", + "970.0\n", + "980.0\n", + "990.0\n", + "1000.0\n" + ] + } + ], + "source": [ + "# time loop\n", + "\n", + "for i in range(nt+1):\n", + "\n", + " if np.mod(i,1e4) == 0:\n", + " print(t_vec[i])\n", + "\n", + " if t_vec[i] == 0.4*np.max(t_vec):\n", + " V.influx = 0\n", + "\n", + " p = rho*g*V.level-0.5*rho*(V.outflux_vel)**2\n", + "\n", + " LA_soll = Pegelregler.get_control_variable(V.level)\n", + " T1.change_LA(LA_soll,dt)\n", + " LA_soll_vec[i] = LA_soll\n", + " LA_ist_vec[i] = T1.LA\n", + " Q_vec[i] = T1.get_Q(p+offset_pressure)\n", + "\n", + " V.pressure = p\n", + " V.outflux_vel = 1/V.area_outflux*Q_vec[i]\n", + "\n", + " V.e_RK_4() \n", + " V.level = V.update_level(V.timestep) \n", + " V.set_volume() \n", + " level_vec[i] = V.level \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib qt5\n", + "# time loop\n", + "\n", + "# create a figure and subplots to display the velocity and pressure distribution across the pipeline in each pipeline step\n", + "fig1,axs1 = plt.subplots(3,1)\n", + "axs1[0].set_title('Level')\n", + "axs1[0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[0].set_ylabel(r'$h$ [$\\mathrm{m}$]')\n", + "axs1[0].plot(t_vec,level_vec)\n", + "axs1[0].set_ylim([0.85*initial_level,1.05*initial_level])\n", + "axs1[1].set_title('Flux')\n", + "axs1[1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[1].set_ylabel(r'$Q$ [$\\mathrm{m} / \\mathrm{s}^3$]')\n", + "axs1[1].plot(t_vec,Q_vec)\n", + "axs1[1].set_ylim([0,2*initial_influx])\n", + "axs1[2].set_title('LA')\n", + "axs1[2].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs1[2].set_ylabel(r'$LA$ [\\%]')\n", + "axs1[2].plot(t_vec,LA_soll_vec)\n", + "axs1[2].plot(t_vec,LA_ist_vec)\n", + "axs1[2].set_ylim([0,1])\n", + "fig1.tight_layout()\n", + "fig1.show()\n", + "plt.pause(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fig2 = plt.figure()\n", + "plt.plot(t_vec,Pegelregler.error_history[1:])" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[8. 8. 8. ... 7.21126138 7.21126138 7.21126138]\n" + ] + } + ], + "source": [ + "print(level_vec[:])" + ] + } + ], + "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/regler_test_optimierung.ipynb b/Regler/regler_test_optimierung.ipynb new file mode 100644 index 0000000..7bf1ed9 --- /dev/null +++ b/Regler/regler_test_optimierung.ipynb @@ -0,0 +1,386 @@ +{ + "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/Turbinen_class_file.py b/Turbinen/Turbinen_class_file.py new file mode 100644 index 0000000..fa7e832 --- /dev/null +++ b/Turbinen/Turbinen_class_file.py @@ -0,0 +1,40 @@ +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 Francis_Turbine: + def __init__(self, Q_nenn,p_nenn): + self.Q_n = Q_nenn + self.p_n = p_nenn + self.LA_n = 1. # 100% + h,_ = pressure_conversion(p_nenn,'Pa','MWs') + self.A = Q_nenn/(np.sqrt(2*9.81*h)*0.98) + + def set_LA(self,LA): + self.LA = LA + + def get_Q(self,p): + self.Q = self.Q_n*(self.LA/self.LA_n)*np.sqrt(p/self.p_n) + return self.Q + + def set_closing_time(self,t_closing): + self.t_c = t_closing + self.d_LA_max_dt = 1/t_closing + + def change_LA(self,LA_soll,timestep): + LA_diff = self.LA-LA_soll + LA_diff_max = self.d_LA_max_dt*timestep + if abs(LA_diff) > LA_diff_max: + LA_diff = np.sign(LA_diff)*LA_diff_max + self.LA = self.LA-LA_diff + + def set_steady_state(self,ss_flux,ss_pressure): + ss_LA = self.LA_n*ss_flux/self.Q_n*np.sqrt(self.p_n/ss_pressure) + self.set_LA(ss_LA) + if ss_LA < 0 or ss_LA > 1: + print('LA out of range') diff --git a/Turbinen/Turbinen_test.ipynb b/Turbinen/Turbinen_test.ipynb new file mode 100644 index 0000000..23d5dd8 --- /dev/null +++ b/Turbinen/Turbinen_test.ipynb @@ -0,0 +1,239 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "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\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.018834355072879172\n" + ] + } + ], + "source": [ + "Q_nenn = 0.85\n", + "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "Untertweng1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "print(Untertweng1.A)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "n_p = 201\n", + "n_LA = 201\n", + "\n", + "ps = np.linspace(0,2*Untertweng1.p_n,n_p,endpoint=True)\n", + "LAs = np.linspace(0,1,n_LA,endpoint=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Q [m³/s]')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a76ad86e29fd4594a88621371ce94083", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d3Bk+XnfjX5O6JwbOQOT0+7EJXdnSYtLk6JpXUq6r2yrpKtM8YqXslgyZanEksSrV2JJr0VZpmWaVKLFogKtYPPSskhLsvRSDJu4uwNgAMxgAAxyRgd07j7p/tHTcYAZhMYMZvH7VE3VnMY5v3M6f/sJ30eyLMtCIBAIBAKBQHBkkB/3BQgEAoFAIBAIHi1CAAoEAoFAIBAcMYQAFAgEAoFAIDhiCAEoEAgEAoFAcMQQAlAgEAgEAoHgiCEEoEAgEAgEAsERQwhAgUAgEAgEgiOGEIACgUAgEAgERwwhAAUCgUAgEAiOGEIACgQCgUAgEBwxhAAUCAQCgUAgOGIIASgQCAQCgUBwxBACUCAQCAQCgeCIIQSgQCAQCAQCwRFDCECBQCAQCASCI4YQgAKBQCAQCARHDCEABQKBQCAQCI4YQgAKBAKBQCAQHDGEABQIBAKBQCA4YggBKBAIBAKBQHDEEAJQIBAIBAKB4IghBKBAIBAIBALBEUMIQIFAIBAIBIIjhhCAAoFAIBAIBEcMIQAFAoFAIBAIjhhCAAoEAoFAIBAcMYQAFAgEAoFAIDhiCAEoEAgEAoFAcMQQAlAgEAgEAoHgiCEEoEAgEAgEAsERQwhAgUAgEAgEgiOGEIACgUAgEAgERwwhAAUCgUAgEAiOGEIACgQCgUAgEBwxhAAUCAQCgUAgOGIIASgQCAQCgUBwxBACUCAQCAQCgeCIIQSgQCAQCAQCwRFDCECBQCAQCASCI4YQgAKBQCAQCARHDCEABQKBQCAQCI4YQgAKBAKBQCAQHDGEABQIBAKBQCA4YggBKBAIBAKBQHDEEAJQIBAIBAKB4IghBKBAIBAIBALBEUMIQIFAIBAIBIIjhhCAAoFAIBAIBEcMIQAFAoFAIBAIjhhCAAoEAoFAIBAcMYQAFAgEAoFAIDhiCAEoEAgEAoFAcMQQAlAgEAgEAoHgiCEEoEAgEAgEAsERQwhAgUAgEAgEgiOGEIACgUAgEAgERwwhAAUCgUAgEAiOGEIACgQCgUAgEBwxhAAUCAQCgUAgOGIIASgQCAQCgUBwxBACUCAQCAQCgeCIIQSgQCAQCAQCwRFDCECBQCAQCASCI4YQgAKBQCAQCARHDCEABQKBQCAQCI4YQgAKBAKBQCAQHDGEABQIBAKBQCA4YggBKBAIBAKBQHDEEAJQIBAIBAKB4IghBKBAIBAIBALBEUMIQIFAIBAIBIIjhhCAAoFAIBAIBEcMIQAFAoFAIBAIjhhCAAoEAoFAIBAcMYQAFAgEAoFAIDhiCAEoEAgEAoFAcMQQAlAgEAgEAoHgiCEEoEAgEAgEAsERQwhAgUAgEAgEgiOGEIACgUAgEAgERwwhAAUCgUAgEAiOGEIACgQCgUAgEBwxhAAUCAQCgUAgOGIIASgQCAQCgUBwxFAf9wUIBAKBZVkYhgGAoihIkvSYr0ggEAje3AgBKBAIHiumaaJpGtlsFsuykGUZm82Goiioqoosy0IQCgQCQYORLMuyHvdFCASCo0cp6qfrelkElj6OTNMEQJKksiBUVRVFUYQgFAgEggYgBKBAIHjkWJaFpmnltK8kSRQKhfL/S/uU/glBKBAIBI1FCECBQPBIMU2TQqGAaZrIcrEPbW5ujomJCdxuN6FQiGAwSDAYRFGU8nH1gnBxcRG3201LSwuqqgpBKBAIBLtA1AAKBIJHQinlW0r1yrKMpmmMjo4Sj8c5e/Ysuq4Ti8W4ffs2hUIBv99PKBQiFArh9/vLglBRFJLJJJIkYZom+XyeXC6HLMvIsiwEoUAgEDwEIQAFAsGBY5om0WgU0zTx+XzIskw8HmdoaAifz8f169eRJAnLsujo6MCyLHK5HLFYjFgsxtLSErqu1whCKKaES6KwFB00DAPDMMjn8+WUsRCEAoFAUItIAQsEggOjlK7VNI1bt24hyzKnT59mamqK6elpTp48SV9fH0A5MriVOLMsi2w2WxaEsVgMTdNwuVx0dHQQCoXKwrL6mNL5S+uWBGNJDKqqWr5dIBAIjhJCAAoEggPBsix0XUfXdQDGx8fRdZ1sNksul+PSpUv4/f7yvg8SgFutPTw8XBZvsVgMy7LKtYMlQVi91sMEYUkUCkEoEAiOAiIFLBAIGk4p6mcYRjkNm81m2djYoL29nStXrqCqe//4kSQJVVXxeDz09/djWRapVIp4PE4sFmN2dhagRhB6vd5yjSBUBKGu62iaViMISz6EpZSxQCAQvNkQAlAgEDSMem8/WZaxLItbt26xvr5OKBTi6aefbsi5qqN0kiTh8/nw+Xz09PRgWRbJZLIsCKenp5FluSwGg8EgHo/ngYIQuK9+UAhCgUDwZkEIQIFA0BDqvf1kWSaTyTA0NARAd3c3ja442W49SZLw+/34/X56e3sxTZNkMkksFmN9fZ3JyUkURSk3lASDQdxu95aCUNO0skehEIQCgeDNghCAAoFg39R7+0mSxNLSEqOjo3R3d5cbP3K5XMPOuZs6PVmWCQQCBAIB+vv7MU2TRCJBLBZjdXWViYkJVFUtC8JQKITT6bxPEJZS26UIYSkVLQShQCB40hACUCAQ7JmtvP0Mw2BsbIz19XUuXbpES0sLQNnmpdHn3wuldHAwGGRgYADDMMqCcHl5mfHxcex2+32CsN6Y+mGCsNRlLBAIBIcNIQAFAsGe2Crlm0gkGBoawul08vzzz+N0Osv770QA7rQLeKfr7ZTqdDCAYRhsbm4Si8VYXFzk9u3bOByOGkHocDi2FYSFQgFJkohEIrS0tOBwOGq6jAUCgeBxIwSgQCDYNaWoX/U4t9nZWSYmJjh27BjHjh27T+g0OgJ4kEJKURTC4TDhcBgAXdfLgnB+fp6xsbGasXWhUAi73X6fIBwdHeUtb3lLTTd0fcpYCEKBQPA4EAJQIBDsmHpvv9I4t5s3b5JMJrl27Vo5ilbPYUoB7xZVVWlqaqKpqQkomlbH43Hi8Tizs7OMjo7i8XhqBKHNZgMop4KhUiu53ZQSIQgFAsGjQghAgUCwI0rpTdM0gaKgi0ajDA8PEwwGuX79Ona7fdvjGy1sHqdQstlstLS0lOsbNU0jFosRj8eZnp5mZGQEr9cLQDQapa2trSzyoCJchSAUCASPCyEABQLBA6mubav29pucnGRmZobTp0/T09PzUKEiSVJZPDby2g4DNpuN1tZWWltbASgUCsRiMUZHR5mdnWV8fByfz1euHwwEAtsKwnw+/0DbGSEIBQJBIxACUCAQbMtWjR65XI7h4WEKhQLPPvssPp9vR2u9mSKAD8Nut9PW1sbo6ChXrlwpj6uLxWKMj4+Tz+fvE4QlgacoStmD0LKs+wRhaUqJqqplyx2BQCDYLUIACgSCLake51YSGqurq4yMjNDW1sbVq1d3Nc7tzRwB3Irqa3M4HLS3t9Pe3g5ANpstTym5desWhUIBv99fFoR+v78cHawXhCUvxVLK2GazlSOEQhAKBIKdIgSgQCCooRT1q270ME2T8fFxlpaWOH/+PB0dHbte9yAigIdZAJbY6n67XC5cLhcdHR1YllUjCJeWltB1/T5BWOq2FoJQIBA0AiEABQJBmZL4u337Npqmcf78edLpNENDQ8iyzPXr13G73Xta+0ERQEmS9iRUngQB+DAkScLtduN2u+ns7MSyLDKZTFkQLiwsYBhG2bg6FArh8/l2JAhLqWIhCAUCQT1CAAoEAqDW268UXVtcXOTWrVv09vZy8uTJfY05O0o1gPtBkiQ8Hg8ej4euri4syyKdTpe7jOfm5rAsqywGg8HgtoKw1FSSy+XKY+2EIBQIBCAEoEBw5Kn29iuNc4OifUn9OLf9cJRrAPeDJEl4vV68Xi89PT1YlkUqlaqxnZEkqSwIQ6EQHo+nRqyXBKFhGBiGsa3tjBCEAsHRQQhAgeAIY5omuq7fN85tfn4eSZJ4/vnncTgcDTmXiAA2BkmS8Pl8+Hw+ent7MU2zLAgjkQh3794tzzouCUK3212OAEKtIFxaWiKTyXDs2LFyyrh6jvFRfZwFgjc7QgAKBEeQam+/6vm7MzMzTE5OEgqFUBSlYeIPnuxJIPvhoAWULMv4/X78fj99fX2YpkkymSQWi7G+vs7k5CSqqtYIQpfLVRaEuq6XI4K6rqNpWln41dcQCkEoELx5EAJQIDhi1Hv7SZJEoVDg5s2bpNNpnnnmGeLxONFotKHnfZgA3K2wEEJka2RZJhAIEAgE6O/vxzRNEokEsViM1dVV7ty5g91uLwvCQqFQFoP1EcKtBGHJh7CUMhYIBE8mQgAKBEeIrbz9IpEIw8PDhEIhrl+/js1mI5FINDy69iABaBgGU1NTWJZFOByusT15EE9CBPBxU0oHB4NBBgYGMAyDzc1N4vE4y8vLbG5uoigKY2Nj5Qih0+ks1wiCEIQCwZsRIQAFgiNAqd5L1/WacW4TExPMzs5y5swZuru7y1G1g2jY2E4AptNpBgcHAXA6nSwuLmKaZk3K0uv13hfxO+w+gIf12hRFIRwOEw6HAZicnCSVSuFwOFhcXOT27ds4nc5yh3EoFMLhcDxQEMLWY+uEIBQIDi9CAAoEb3K2GueWzWYZHh5G1/Utx7kdhLjaas3l5WVGR0fp6uri2LFj5XrEUlNDLBZjenoaWZbLYrBUwyZoDJIk4XK5OH78OAC6rpc9COfn5xkbG8Ptdpcf+2AwiN1u31IQappGoVAoRwiFIBQIDi9CAAoEb2JM06RQKJSjfpIksbKywsjICB0dHZw5c6Y8cqyaUoSwkVQLQMMwuH37NsvLyzz11FO0tbWVRepWXa7JZJJoNFpTw2a32wHI5/MNbVZpNIe9VrG6CQhAVVWam5tpbm4GQNO0siCcmZkhlUrh8XhqBKHNZrtPEJbKDUoRwnpBWOoyFggEjwchAAWCNyGllG+py7c0zq0kui5cuFCeS7sVB5kCLqV8dzpZpLqpobqGrSRGvvnNb9ZEqEKhEDabraHX/mamXgDWY7PZaGlpKXtBFgqFsiCcmpoik8ng9XprBGFJ5FWfoyQIt4oQVncZCwSCR4MQgALBm4ytvP1SqRRDQ0Ooqrpj0XUQEUBd13nppZfo6uri9OnTe0oJlmrYUqkUNpuNM2fOlAXJ9PQ0IyMj+Hy+GkGyVZRTUKTa/Hsn2O12WltbaW1tBYoR2NLjPzExQS6XqxGEgUBgR4JQluX7mkqEIBQIDg4hAAWCNwnbefstLCxw+/Zt+vr6OHHixI6+7BsdATQMg+npaXRd5/Lly7S1tW15zt1Q2r8+QpXP58v1g+Pj4+Tzefx+P6FQaFcdxvvlsDaB1POwCODDcDgctLW1lZ/TXC5XFoTVj3+poSQQCJQFXun8wJaCsL6GUAhCgaBxCAEoELwJqB7nBpVo2+joKLFYjCtXrtDU1LTj9RrZBJJOpxkaGsI0TVRV3VL87ZWtrtHhcNDe3l5OcWezWaLRKLFYjMXFRQzDKIuRcDi8ZYfxUaLRQtXpdN73+JfG1t26dYtCoUAgEKgRhKXoX/X1lOpXSybVpX8Oh0OkjAWCBiAEoEDwhFPt7VeKnMTjcYaGhvB4PFy/fn3XTRKNSgFXd/l2dnbyrW99a99rltjpl7/L5aKrq4uurq5yDWIpQjgzM4MkSTX1g263u6HC4rCLlP1GAB+Gy+XC5XLR2dmJZVk1gnBpaQld1wkEAuXH3+fzbSkIC4UC3/zmN7l+/TqqqooIoUCwT4QAFAieUCzLolAosLGxQSgUKqc17969y9TUFCdOnKC/v39PX4r7TQEbhsH4+DhLS0vlLt9UKtXQSSCw++iVJEl4vV68Xi89PT3bjk0Lh8M1pshvZg5aAFYjSRJutxu3210W5JlMpizI5+fnMU2zRhB6vd5yBztQFn+WZZHP5ykUCsDWPoRCEAoE2yMEoEDwBFLyXEun07z22mt8+7d/O4VCgeHhYTKZDG95y1sIBAJ7Xn8/EcBSyleSpJqGk0Z7Czbiy71+bFqpw7iULi6ZIpcEYckDbycclRrA/SBJEh6PB4/HQ3d3930R2tnZWSzLIhgMlr0qq0fWKYpS9iAsCcJSyliWZWw2W1kQVotIgUAgBKBA8MRR7e1XSpNtbGwwMjJCU1MTly9fRlX399beawSwOuVb3+V7EObSjV6vfkpGyRQ5Go0yPT1NOp3e0vLkSWa3XcAHSX2E1rKssil4JBIB4Bvf+EbNlBiPx7OtIMzlcuV1hSAUCGp5sj+5BIIjxFbefiWGhoY4e/YsXV1dDYuM7UZcbZXyrWcnAnA353wUX971psiFQqEcnbpz505Nh3F1Q8OTxGGOVFabgjc1NfHqq69y6dKlsiC8e/duedZxdQ3nTgRhyYxaCELBUUUIQIHgCWC7cW6lGbrXrl0jFAo17Hy7idZtl/Ldak3YPuW4FyHyqMWL3W6vsTwpNTTEYrGahoZwOFxOWR52UfE4U8C7oRTx9vv9+P1++vr6tq3hrJ5j7HK5thSEpmmWBWEprSwEoeAoIQSgQHDIKUX9qse5lVKtHR0dJBKJhxo775adpoAflPLdak1onOA4DF/O9R2umUymbDkzMzMDwMjISDmt3OgO40bwJAnA+tdXfQ2naZrlGs7qsYH1grB0f6sFoWEYGIZBLpcTglBwJBACUCA4pNR7+8myXJ6hu7q6ylNPPUVra2u5c7KRlFLA24mDnaR866kWgI3iMKUvqxsaenp6yOfzfPOb38Tv97OxscHU1FQ5OlX653K5HvdlP9ECsB5ZlsuPLVDT1LO8vMz4+DgOh6PmOXA4HPfNMa4WhPVNJdVzjJ+Ex00g2A4hAAWCQ0jJ268k7CRJIpVKMTg4iN1u5/r162XxUJrz20geFK3bacr3QWs26hoPkwCsp3R/e3t7GRgYqIlOVYuRasuZnXYYN5InRQDu5Tq3auopPQfz8/OMjY3hcrlqBKHdbt9WEOq6XhZ+9TWEQhAKnjSEABQIDhHV49yqIx7z8/OMj4/T39/P8ePH7+uuPYgIYOl6qtlNyreeg4gAPknUR6dKHcYlu5PR0VE8Hk+N5cyj6DB+UgTgTiKAD0NVVZqamspTcbZ6Dtxud02X93aCUNd1NE2rEYTVc4yftGYgwdFDCECB4JCwVaOHpmmMjo4Sj8e3Hed20BFA2FvK92FrNuIanwQxuZ242qrDuGQ5MzExQS6Xw+fz1XQYl2x/GslREoD11D8HmqaVBWG17U+pfjAYDGKz2XYkCC3LwuFwlEWhEISCw4YQgALBIaB6nFup2DwWizE0NITP5+P555/fNj14kALQNM09p3y3W7ORAvDNhN1up7W1ldbWVgByuRyxWIxoNMrY2Ni2I9P2y1EWgPXYbDZaWlpoaWkBKqI8FosxNTVFJpPB5/PVCMJSPWC9IBwcHKS9vZ3W1tYtp5QIQSh43AgBKBA8Rqpri6q/4Kamprh79y4nT56kr6/vgV/QjZrbW78mwOrqKuPj43tK+dbzMAH4KEbBPUr2e21Op5OOjg46OjruG5k2NzeHZVk1tWsej2fPj+GTIAAfx3XWi/J8Pl+eY1wfpQ0GgwSDwXI9oGmaZePpUnS/UCiUI4RCEAoeN0IACgSPia1Svvl8nuHhYXK53I7HuR1EBLC03vj4+J5TvtshIoC7Z6uRaSX/u0gkwtTUFIqiEAqFyjWEO+0wflIE4KOIAD4Mh8NBe3s77e3tQCVKG4vFGB8frzEGr04H10cISxF/TdMA7hOEpaiiQHCQCAEoEDwGtvL2W1tb4+bNm7S0tHDlypUdNwA0WgCWUr4Aly9f3rLucC9U10Y1isMcATxIJEm6zxA5kUgQjUYfaHeyFUIA7p3qKC3UGoPncjlGRkZq0vZ+vx9ZlmtqOasF4VYRwuouY4GgkQgBKBA8Qqq9/Urj3CzL4vbt2ywsLHDu3Dm6urp2tWYju4BXVlYYGRmhq6uLZDKJ0+lsyLrVNCoF/KR8IT6K6yyNQwsGg8DWdicej6emu9Vmsz3Sa9wvh2lm8XZUG4NHo1FOnz6NpmnEYjEWFxe3reN8mCAs7VPdZfwkPGeCw40QgALBI8I0TXRdr0n5ZjKZcrTt+vXreDyeXa/biAjgVl2+CwsLB2YwvRWrq6vEYjHC4fCOO16PagTwYdTbnZRESH0zQzgcLv8YOeyYpvlEiR7TNMtp+66urvvqOEsG7vWCsGQpU2I7QfjVr34VWZZ53/ve9xjvpeBJRghAgeCAKX2AFwoFoJIKXVpaYnR0lO7u7n01WOxXAG7X5XsQzSVwv2gzTZPbt2+ztLREOBwud7yWOi3D4TBer/e+L//DLgYOk6iy2WxbdhjHYjHy+Tw3b94sC5HSHOPDFm07jCng7Si95+v9OuvrONPpdPl5mJ2dBShHckOhUPl1XxKEpdeUaZr81V/9FX6/XwhAwZ4RAlAgOEBKjR4zMzOsr69z9epVDMNgbGyM9fV1Ll68WP5S3iv7EYDVKd96EXoQPnv1ojKbzTI4OIhlWTz77LPl4vf6mbolE+X6BofDJLK24zAK1eratWg0yokTJzAMg2g0Wo78lkRItRB5nDxpAtCyrAdGsSVJwuv14vV66enpKTf2VPsQSpJUM8e41OmtKAqZTKZce7gfvva1r/GJT3yC119/neXlZb74xS/y3d/93dvu/9//+3/nM5/5DIODg+Tzec6fP88v//Iv8573vGff1yJ4tAgBKBAcENXefoqiYJomyWSSwcFBnE4nzz//fENq7PYSqduJsfNBdBdDRbStr68zPDxMW1sbZ8+eRZKkcoqreqZu6XGrbnBwOp243e6y+W51PZtg97hcLgKBQDlVmUqlypGp6enpmikmJQH+qAXhkyQAq8s8dkp1Y09vb2/5dV/f6b2yssLs7CypVGrPnpzVpNNpLl68yI/+6I/yPd/zPQ/d/2tf+xrvfve7+bVf+zWCwSB/+Id/yPve9z5eeeUVLl++vO/rETw6hAAUCBrMVt5+siyTzWZ55ZVXOHbsGMeOHWvYF+huhdpOjZ0PKgJomiYTExPMzMzUNL1sdx9kWSYQCBAIBBgYGCiP71peXkbTNL7+9a+X69kOcmLGbnkSopMlql+LkiTh8/nw+XxlIZJIJIjFYqyurnLnzh3sdntNRHa7DuNG8iQ0gZQovZb38zqsft2X1kwkEszPz/M//+f/5ObNm/zjP/4jIyMjvPDCC7zwwgscP3581+d573vfy3vf+94d7//JT36yZvvXfu3X+NKXvsRf/dVfCQH4hCEEoEDQQLYb5zYzM1P29ivNgm0UuxGAD0r51nMQM4ZLHc+apvHss8/i8/l2vUZpfJeiKCSTSa5evbrlxIxwOLxt/aCgwsNsYKo7jAcGBjAMo5ymLHUYl+bnhsPh+zqMG0XJWPlJoHqiT6MoPQ/f//3fz/d///fzrne9ixdeeAGHw8HnP/95PvOZz/D666837Hw7pRSpDIfDj/zcgv0hBKBA0CBKjR7V3n7RaJShoaGyPUSjxR/sTKjtZZZvo5tA4vE4hUIBj8fD9evXd+xz+DCqzXlLnZZb1Q+WBMpODZKPCrv1AVQU5b4O463GpVVbzjQiIvskpYDvu1YrBRggPdzYfafkcjmuXr3Kv/yX/5L/8//8Pw+kXGMn/Pt//+9Jp9P8q3/1rx7L+QV7RwhAgWCflFK+mqbVePtNTk4yMzPD6dOn8Xg8jIyMHMj5HxYB3Oss30algC3LYm5ujjt37mCz2Th+/HhDxN9W1/eg+sGVlRXu3LmDw+EoRwdDodCBRpWehMjjfo2g6+fnlsalxWIxbt++TaFQ2NIMebccegFoWWAtIZnT2IxZLvS9gjP7x0jWDLIVIeP6r1gNEoClDmKv11u+7XE8Nl/4whf45V/+Zb70pS/tu5lN8OgRAlAg2AdbefvlcjmGh4cpFAq89a1vxe/3E4/HD+wX+oME4G5SvrtZd6fous7IyAixWIxr165x8+bNfa1XzU5Ey3b1g6XmhpGRkUNZP/goafQkkPqIbPV0jFKHcSlFv5sO48NSA2hZOpizYE5hmXfBWsdm3gRzBokcAG75AuHmcbj39jHkK1jyyYZeRyqV2lMJRaP4sz/7M97//vfzF3/xF7zrXe96bNch2DtCAAoEe6DanLX0BVo9zq2trY2rV6+WI12lLuCDQJblsgAtsZeUbz37jQBWdzxfv34dh8Px2EfBleoHm5ubgUq0KhqNcuvWLTRNa1j94JPSBHKQo+AkScLtduN2u8sdxiXvu2g0WmN1Uvrndru3vJ5HbQRtWSamuYBljmOadzCNSSxjGrsUA2u9vJ+qvBXJvF05TmrDwUTNWprtXzb8+jKZTE0E8FHyhS98gR/7sR/jC1/4At/xHd/xWK5BsH+EABQIdkn1ODeo1OCVBNf58+fv8+faSqQ1ilKjSYlMJsPg4OCuU7717KcJpGRy3d/fz4kTJ8pf3I0UgI0QA1vVD5bEyVGoHyz51T0qYVXvfVdtdbK2tsbk5CQ2m61GEJaskg4yBWyYG+jGJIY5hm6MYxh30M1JPMopLLNSuqHKV8C6U3WkA9mcrFlLkfuQzGh525RaMJR3NvR6S0J6L5OD6kmlUkxOVu7D9PQ0g4ODhMNhent7+ehHP8ri4iKf//zngaL4+6Ef+iH+43/8jzz77LOsrKwAFSshwZODEIACwS6o9vYrjWRKpVIMDQ0hy/K2gquUTj2IL9vqVO1+Ur5brbsXf8Hbt2+zsrLCpUuXynVhJR53BPBB1E9qqK4fLNmfPMr6wUfJ46pVrE7R9/f3YxhGeYbx4uIit27dKncY5/P5fUfRLUunYE6T029jmZMUjJtoxjimFcGjXsMwXi3vq0rdWOZozfGqlIKql5yiPIVkDlbWx45qTtUco6v/B0iN/arNZrOYptmQFPBrr73GCy+8UN7+yEc+AsAP//AP87nPfY7l5WXm5ubKf//d3/1ddF3nJ3/yJ/nJn/zJ8u2l/QVPDkIACgQ7YCtvP4CFhQVu3bpFb28vJ0+e3FZwlW4/KAFYmi6yn5RvPbuNANZHHreKlh22COCD2Gn9YCk6uFX94GFvAik9F4flOhVFKQtsKNaQVo+sGx8fZ3FxseYx366hyLSyZPU7ZI1xTHOFjP5N8sYkFgVc8nFk63bV3ipmnXCzyx1gLlauTT4FdfsoVqxmW5afQrKGAcjrXiRbW1EANph0Og3QkBTwO97xjge+J+tF3Ve/+tV9n1NwOBACUCB4CFt5+xmGwejoKJFIZMtIVz0lYVDyB2skmqYRiUTK9iqNmA4Au4sAlmofOzo6OHPmzLb38TBHAB/GbuoHQ6HQE9FMctgEYD2qqpY7jGOxGL29vUiSRCwWY3x8nHw+j9/vJxBy4QpGwbmAbi6T1b9JzpgBDCTsuBU7hhUvr2uXnehVFRku5Skss+KhJ0l+uC/656uJ/knyGUxrHVM6gYkbAwUViZzVjmmuIMvrSNIzyHJzwx+XdDqNLMtvupIEwaNFCECB4AFs5e23ublZ9va7fv36jsa5lQRRoxtBVlZWmJmZweFw8Na3vrWh4nInYs2yLCYmJpidneX8+fN0dnbue83dXN/j5GH1g6UI6uLi4qGtHzzsArAa0zRxOBwEQ35cTXG82irR3Ci6PsmaNA6mCRlwFvqQHZVInc92loJREXc2qRXdqO1Gl4hVazuc8hkwvwWAZdmxpH40LEz5KqalY1ib2C07lrkGrAGgyKex7tUDyvceTsn2/Y1/IKBc//ckPG+Cw4sQgALBFmzl7QfFAumJiQlOnDjBwMDAjj+AS/s1SgBWd/l2d3eXIwKN5GEp4Hw+z9DQEPl8nueee25H6ahGf2Edlk7breoH19bWuHXr1qGuH3wSBGBaXyKu3SYZ/nvuGn/L5vrXMSkAEFJPUZBvlfe1EUa23y1vWxbk8/M1JXhupQvdqKR2HfIpTPM2Fn6QOjDxk8eGIT2Nbm5gWKt4lSAF/ZXyMbLUhmXN1FynKnlrIoR5bQC370qDHoVaUqmUEICCfSMEoEBQx1Yp30KhwM2bN0mlUjzzzDO7nughSRKKojSkE7i+1i4ej5NMJve9bj0PSgHHYjEGBwcJhUJcuXJlx8bOjRwvd5i//GRZxufzIUkSV65cQdd1Njc3y9YnO6kffBQcNgGoWzmihQki2i0S+hyb2ivkzXt1dn6FpGUviz8ARcrVHO+3dZPVV8rbbvk0llRJ5ZqGs1gHKJ1AVoJYskoBlYIVw7CiwF3cytNo+kvlYyTsWOZ4zXnsSh8Ya5V9pGYks9boPZH9DhpTjHE/mUymIR3AgqONEIACQRWlqF91yjcSiTA8PEwoFOL555/fc+SmEcbKW3X5JhKJA/EY3EqsWZbFzMwMk5OTnDp1qlyTtZs1G8lhiQBuR+n+qqpaMz6telpGdf1gSRCWxONB87gFYMaIslq4zVr+Nrq1ymLuRSyKP5I6HWcr4g+w5zrQPZXonl/pI2tULFkUyU1er0QDsRyoagCDa5jY0MwsquQkKb0KpMGcx8oFcdojSFLldSSTpvpV71IvYBmvVd3iAKPaCgZs8nEwK/sYppds/h17ekx2Qjqd3tYvUSDYKUIACgRUfLVKc0xL0a9SfduZM2fo7u7e1wfufgTgg4ydGyEst6I+AqhpGiMjI2xubvLMM88QDAZ3veZRiQA+jAfVD87OzpbNkUvp4kY19tTzqAX0pr7CYu4WcX2exdxLJI1itM4rNwErWPekl11yk9SrRZaEbIvWrOVU7KSLVpwoUhNe5TQWOUzLIG/GUGQb69qN6hXwK7VpWo+tG1PaKG+b+XZ0Z624k61IjSB0KBfAfKPqFhXZuotlyZhSC6YUJJq4iKwcXIQulUo9NhNowZsHIQAFR56St9/y8jIrKys888wz5HI5hoaG0HWdZ599tiF+W3tNAT/M2LmRoqp+3ZJASCQSDA4O4na7uX79Ona7fc9rNpLDHAHc6bXtxn+wZI6818d/q2ssTbE5CKLaMnO528S1u0znXiNtFEVcr2OgLP4AwrYwEW2pvN1s7yeuDZa3m2ynSEs3sSwZh9KOXWqjYIIlXSRjrKFbaQymKJiRqmPOole9LQLqWbQq4SZLXiypVuy57SGgUh9o5HswndPlbcvyYaFiyJcwsWNgouKlYN7GtEywFoFlYsn/D37fwY2tq58DLBDsBSEABUeW6nFupmmiqiqmabK6usrIyEjZ0qRRtVl7idTtxNj5oCKAJWFZ8jocGBjg+PHj+xILIgL4cOr9Bw3DIB6Pl6ODo6OjDasfbLQvZVzbYCE3yUxukLncLVJGjCa1lay1QCn0FlBaiGiVUWku2U9Mq9TYKdhJ68WImlPpQJWasCw7mUwPOFOk9Bjt9nbWteHyMc22s2SMwfK2Q2oio9fauEhs1mx7lZMUjG9VziuFQboNBJCkNgzLC4qTaNaLbiWR1U0kswkX36pb5zimtVzetqlvp5BvQQkeXE1no6aACI42QgAKjiRbNXpIkkQ6nWZkZIQLFy7Q3t7e0HPuRqiZpsnt27d3ZOy8l4kdO2VjY4OlpSUuX75c9r/bDw8TG7sVI4c5AtgoFEWpqR8sFApEo9GG1A/uVwBmjDQz2XGmsiNMZ28R09c55upjOV8ReH6bi2yh8jwFVT/rWiXK1mzrIKqt45BbscutuGQfGWOdtLXCphajWQ0QN0fhntuSQwqQ0Kpq/QDLitRse9Uu0lXNIF7lGAWztj7QtDRk+QqW5MCwTBTJRdIYwrCSwCw2qRVFWQXFKH9ROszumvOYhS5MR+3cX6f9/3WgY+tACEBBYxACUHDkqB7nVhJ+yWSSO3fuYBgGb3vb2w6k5mqn84B3O8v3ICKAmUyG5eViVOP555/fkdfhTtipt+BORElpn0c5y3a3HMR12e32mvrBbDZLNBolGo2WR3ZV1w+6XK5tr2O3j51pmczmpriTHuNO5hYJPYbFJgbFYryQ2sRKvjJXNqg2sVaoCCSvHGJDu4OKC4/ahU3ykjYyZK1W4loKmQwh1UO2KpVrl02yVS/vkK2buFap2wupx8maY+VtRXKTM4pTPhRCyHIbqtyMThDdzJG3oriVVjb0wfIxEnbcsnpP/BVxK13kjUpaWpWakZTalLFD9tds63o7G+sn0fWFA+3qFilgQSMQAlBwZNhunNv8/Dy3b9+mra2NSCRyYAX3iqI8VKjtZZZvowXg6uoqN2/eLNelNUr8wcMF4G4EyWEVfY8SSZJwu9243e6a+sFYLFZTP1gtCKvrB3fyeMe0GLfStxhLjWGSYypbSa2edg8wn6+ItbDqY6lQSYeGbH5W8sv4lDacSjNu2UlMdxLX14gbC/Q6T7GqVUybOxzHiWmV9YNqJ5t6RUCqkpOUXhtxUyUDXQqjSq1Ikheb5CFvrZA119GsJC6yZMxXoKqVwy3XmnL71TPkq8yiJRxo5u2afVxKH5qxWt6WpSA2W+21aPn3sbq8QjqdZnx8nI2NjfJj36i6TSg2gZTG5QkEe0UIQMGRYKuUr67rjI6OEovFuHz5Mna7nfX19QO7hgcJtd2kfHez7m4wTZOJiQnm5uZ46qmnSKfT5ZmjjWI7AWhZFvPz88zOzpbHqYXD4R1Z7hzWCODjSE9X1w/29/dvWT/o9XprxtXVP3amZTKVmWU4eYv5/AR3s0WB5pDteJTKffIrfpbyFVuWoBJmuTCJbKkEbZ045QBZPY1hhVkpbOJRTGQSGGgA2CQHcW2m5tyaWdvp61VcxKpe2mH1BJqVwC75MS0FGYU1bRzNygFzxU5f1UferEQI/WorKX2hvO1R+skZtcLNsmrf9171LFqV9YuEHcOsjf65lBOY+k2Qe7GkAOCls+P/TXdngG984xv09PRQKBSYm5tjbGwMj8dTbuIJhUI79s7cimw2KyKAgn0jBKDgTc9W3n7xeJyhoaHy/FyHw0EqlWqIUfN2bCfUdpvyracRjRWlrmdN08pTPaanpxueWt5KAJbmKm9sbDAwMEAmk6lpdiiJwUAgUBMRPYyi77DxoPrB27dvUygUTZXHpyfYcG1yW5vkZuoWKSPDKU83C/lKdG7A1cVsriKC2h1NLOQjqNgJ2ToIqkHiuocNbZVEfpUTLhdLhUoHbbu9jeVCJVrY4ehjtTBa9fdjJPRi1M2yJPxKD7op41GvktfzxHPrSGzcSw8Xo4xdjpNoVWnbJtspUlVj3lTJTUavrRd0yC4yVS9rr3KKQt3cX8sqRfp8yHILdqkbQ8piWhKmVcAwM+jGOrqlg7EMLOO3fw+yFLh3vFWux4SihVLJ93FqaopMJoPf7y+Lwd028qRSqQPLVAiODkIACt60WJaFruvoul4zzu3u3btMTk5y8uRJ+vv7y0KilKI9qIjSVjYwe0n51lM9Z3gvx0ciEYaGhmhububq1avlyEQj5/aWqF+zJH5lWebZZ58tC3RJkspmydFolNHRUQzDIBgMlgVh6TqPQiNIo6iuH4xrSb46/wqvRIdZSvxvOuIeNmxF42UZSOsVE2aX7GS1MA+Aip1WWyemqeKV+1gvrAFZ1goLmPfSrH4lwEqVeHTJHtarUr0KKol7UTnJUvGqbdglP371Elkzw6a+TkgJMl8lEN16G1mzEslzyyHi9c0gJGq2w7ZjpPVKatcuNZGt7g62bKiSH0t+CiQXlqUg4yRlzqNZzRhWGsxl/IpEwZwtH+ZVLqDXRQSDjsrc31J9cQmbzUZrayutra1A8QdXvRG43+8vR2ZLXqTbIWoABY1ACEDBmxLTNNF1/b5xbsPDw2QyGd7ylrfcZ2Rc+gVumuaBFHBXRwD3k/Ldat3SmrsRgJZlMT09zdTU1JZG1wfhL1gtANfX1xkeHi7b7QDliBTcb5acTqeJRqNEIhGmpqbKAnBtbY2mpqaG1lg1isMWpdwobPJybIxvxW8R1VeJ6QmwQacjTESvpEE7rTBRoxhlk0yZLrUTFEhLeVYKa3Q67NzJVtKorfYg8/nK8W32JhartjsdnSwXRpEsBZ/aTlBto2BlMUkR19ZwWS6mcpXInUv2ES3UGTKrmRpD5pCtjZhW6fQNqv2kq1K7EgoFYwbJcmGT25DkAE4piGYlMKwceTOGjI0VbZhqd+iweopcldjzKCdqO4gBmdoRdE71Cg61+Bou2Us96DPE6XTS0dFBR0dHTSNPLBZjbm4Oy7IIBoPl+sH6ub+ZTGbfAvBrX/san/jEJ3j99ddZXl7mi1/8It/93d/9wGP+8R//kY985COMjo7S2dnJz/3cz/HBD35wX9cheHwIASh4U1Ht7VdtcruxscHw8DDhcJjnn39+y/qb0ge2YRgHKgD3m/Ldal3YXSRM0zSGh4dJpVK85S1vIRAIbLnuQUQATdNkamqKu3fvcu7cObq6uoAHX78kSXi9XrxeL729vRiGQSQSYWRkhLm5OW7duvXAdPFRZj2/yWubE/xj9A0m0otYWFz09xTF3z38qoOoXnz8FSTcXgdeTpIuFIiZm0wXFtC0YqevBzfzueravwCLVbWAXtnHSn6ymMZVW3ArYfKmhEM6TtRYZzMfo2BpJI3qTl8JqoLjbfZO1qrSxWG5l4y9EkG0Sa7aSSGWikMKIisXQHJiWmCXHCSMO+TNHJjrKFIClzSHbqXKh7XYL5DU58vbTqmNjFHpKC6ey1Z9aTjlHgp1DSLV0b/Sj6adfobUN/JYlkUqlSpHv+/evYuiKIRCIeLxOOFwmFQqtW8bmHQ6zcWLF/nRH/1Rvud7vueh+09PT/PP//k/5wMf+AB//Md/zDe/+U0+9KEP0dLSsqPjBYcPIQAFbxrqGz1K0aY7d+4wNzfH2bNn6erq2jYqUxIMB1UHKMsyyWSSF198cV8p363WBXYcrdvc3GRwcBCv18v169e3bbQ4iBSwZVmsrhbrq9761rfi99faaOw0YqYoSrkL8urVq5imWbZC2Spd/Djmpj7O1HS8kOLrsTG+FhnlVmqeC74O7mSK6VO3bGc5X4mcNVtelvNr9Dr7kLDhlBXG0xVj5nPefu5WRfuaJQ9rxMvbftyss4FDchFU2wmoATb1OBFtg8V8kpPuFqZzFcHU7zzGmlbZDqvtrGsVAWmTnMSr0sUAyj2bGQU3TqUVv9KKbmWQLY2smUCWZOYKY1RH8lpt7TWzhMPqCZJ6ZTScKnnI6JX7CeBR20hXNYzYpSZyRm19oEMOkzcqtY2K1ILX9q7ydul9uNf3tiRJ+Hw+fD4fvb29mKZJIpEgFovxB3/wB3z+85/H4/Hwe7/3e+RyOd75znfS0dGx6/O8973v5b3vfe+O9/+d3/kdent7+eQnPwnA2bNnee211/jN3/xNIQCfUIQAFLwp2MrbL5PJMDQ0hGma5caGByFJ0o69+vZyfdFolGQyyaVLl/aV8q2nJGweJgAty2JhYYHbt29z/PhxBgYGHiiKGm0vk0wmWV5eRlXVfY2Tq8eyrPu88erTxTabrSwGGzlK7TCRNQp8PTLO36+NEjMjLOaKEbQ+VxMTmYqoOeVt407mLs22JjyWh0I+Q0TPEdOWsEkKzY7KDwKP4mQxV0mHBhQfEWkFLAjITThNL7lCAcsME1XSpAsRVpSlsi+gTbIR0SoRNoCCFavZ9qou0pXMP532XmLaXXzKAKrkw4aDjL5OVg+jKxlkc528mSJbJe66HKdrzhO29ZGq6/TVzOWa7aB6jJRRGQ2nSG6ydQ0jHrWHbJWhtIwHzVxClk8AHsCJ3/5OJKnymFWXnTQCWZYJBoMEg0E++clP8iu/8itcv36dlpYWPvnJT/JDP/RDvP/97+f3fu/3GnK+7XjppZf49m//9prb3vOe9/DZz34WTdN21LEvOFwIASh4otnK20+SJJaXl8t1KqdPn95xOmav83ofRCnlm8/naWlpaaj4A8pp7geJtepO2ytXrpS7Qh+2bqOiWMvLy4yMjJQjG40QYNuJ163SxZubm/eNUnszpItNy+L12Ax/t3GTb0bukDM1ng50lMUfgEuRsbBQUOh1tmJYMm6piblsgj6bjVU5Ug6cnfZ2lW1fAPpdbUxlJ5EsmRZ7K232JhJGiLVChKVCirOeJmZy88WuEaBNbmKVufLxLVYTMbOy3ePoI1Ll4+eXm8gaGZrVc1ioaKbGhpYgrgP6KrBKn7OfmDUP997C7fZjRLVKmtYhe4lrdQbNklJTpRdWT5KpieRJFKyFmmP88nHy5gw2qQNJ9oLlJG+BJT+DbuXQrAReuZOo8Rrci4BKqPT4fqNmneofoQeBz+cjGo3ycz/3czz99NPEYjEikcjDD9wnKysr9312tbW1oes6Gxsbe4pCCh4vQgAKnli28vYzTZNbt26xurq6p+aKnZg174bqLl+Hw0EikXj4QXvgQdG6dDrNjRs3sNlsXL9+fcfGzo1oAjFNk/HxcRYXF7l48SLxeBxN0/a1Zj0PE6mldHEpZVyyQimli3VdLxfbNzpdfFAiYD4T5csrI/yv1RH6PEFuJotROrussKFVImMnPe0okswxVz+z2XWcioObyZnK9cl62R/ZLqmsF4rpeRmFdlsbpqXSovazUtggrhVY18YxrOL7LaB4WchX1nLJLmLSallMKihk5YowUQ0nRk4iqJ7GUhRSRgqn4mUxPw4Ufft6nceJFCpmyz4lxIZWH8mL12w323qIVM0F9sgtbOp1DSRSASwFm9yMIgVxKk2Y5FDlPjQrT8FIEmOTnJmjZDHTZDtPQhusWkVCk2rfD0H7C9jl2hGJB9VEVr1+9Si4kpXMo6D+9Vx67x22ZifBzhACUPBEYpomhUKhJuqXTCYZHBzEbrdz/fp1XC7Xwxeqo1ERwK26fOfm5g60vnArsVYSoD09PZw8eXJXka79NoHk83kGBwfL3oIej4fNzc2GRRX3+qXzqNLFja4BzBkaf786wY3NGf7X2ggAQdXJZLqS2rzgb2cut8Jpdx853SRjZJhIF0VYs83LRKaSJj3t6WQ2V4zOSZbMOV8fmmXgkQss5NZxuVyMpiq1eSfc7UxlK+Ky09XETNV2j7Oj7BPoU0J0ODrRrDx5UyOmxXDIbmaZBx3QwWk6KZiV9CpA7j5x18RqVadvq22ARJW4U7CR1GfK2zYpREDto2A1AzZ0y0KVVCLaLDnTjWWmgBQtyCSNSqTz/gghmFatKXVAOUXeHKm5rc35r6in3gKm0WQyGSzLKnsMPira29tZWal9vtbW1lBVdUcZBcHhQwhAwRNFKeVb6vItfdDOzc0xPj5Of38/x48f3/MHcCME4HZdvgcxs7dEvVirjrzt1WZmPyngWCzG4OAg4XD4wL0F97Pek5Auvpva4L8vDvOV5Vs4ZZWcVJnOctwXZiQ5j1dx0u9qJaXlieUtNnJLPO3vYDZbicB1ugKMp+NAMWNrkyR61W7S+RxZ1WAys0zKyAAQUDzMZCtiMaj6mMnNlLf9ipeFe7WBXiVAQGnCsFTCtmNsFKKsFjJYLLFpxMvHNDl9UFXr16o2s1Hl2xc22tjUF8vbLtlDRK/MFQZQMHDKzdjlELLkwim5yVpxLDNN2oihoJAxb2NY+fIx3Y6TNbOF/UpnjfgDUKTaqLRfHSBr1kcRaz8XXMpJfLbL1HPQEcBMpvgcPWofwOeee46/+qu/qrntb//2b7l27Zqo/3tCEQJQ8MSwlbefruuMjIwQj8d3XNv2IPbbBPIgY+eDFoCltXO5HIODgxiGsS+bmb1cr2VZzM3NcefOHU6ePElfX9993oKPOwL4IB5nurgazTT4h9UpvrJ0m8HELBmjKFBOhoOMJDcB6HT4MS2JAVcnE6l1JDfcSRXTpzZJJlolvjqdQeazqxxz9SBjw6nIjKQq4uqiq5fxTCXa1+tuYiKzWd7ucoaYykZxSA6a7K2EVT+bRoqNQozlfIqQ18btTCVVe9LVz0Khst1ua2elUKkFdMpOEtJSddMusqpX/m848ertSHYDRXGQ0bKYmsm8uXxvlFxRBDXbwiSr5vN2OM6wXqj4CTpl/331gW7FR6FyKjxye62lDGCX7RSqXvpOuZ2sUWv90ur8l2zFQdlIlUin06iqisPh2Nc6qVSKycnKa2B6err8o623t5ePfvSjLC4u8vnPfx6AD37wg3zqU5/iIx/5CB/4wAd46aWX+OxnP8sXvvCFfV2H4PEhBKDg0FPy9ksmk7z00ku84x3vQJZlYrEYQ0ND+Hw+nn/++YY0Fuy1BnAnxs4H0WBSoiTWSn6HLS0tnDt3bl9fRLsVa6VGk0gkwrVr17asSzpsEcCH8bB0saqqZTEYDofvew3uVhxG8xn+Yu4mfzl/k418mqvN7WXxd9wbZjy5whlPB6AgSQY34sWIWZvDx+1UJXp2IdDBrfQM7fYmgjY/NglGckkihRUUSaLLVflR4ERlPrdU3g6qXmayc2BJNNnDBJUgBdPAq3SwXoiiW0mW82toVvG6HLKd5Xzl3BKQrpvp61ZtxKpe+j2OLhZzt/EozbiUIG7Fi25lcZseNvUYBgUseZWCkS37AzZZzeU5wgDt9gFiVcJNRqmZ+QvQbOsiqlXmAjvkAIl66xclREKvFqdh0lXdwBJu3EovBdODJLmwsCHjpMmxtYXKQaeAS2Pg9nuO1157jRdeeKG8/ZGPfASAH/7hH+Zzn/scy8vLzM1VHpeBgQG+/OUv82/+zb/hP//n/0xnZye//du/LSxgnmCEABQcaqrHuUmSVK77m56e5u7du1tGmfbDXkTaTo2dDzICKEkSi4uLrK2tcfbsWbq7uxuy5k6vN5PJcOPGDRRF4bnnntu20eQgIoCPym/vQeniubk5xsbG8Hq9ZTG4m9fknc0N/ujuIKv5BN+KFVOvx70hbm4WhdUxdxPNdjfr+RQ3N9c47WvhbrZSj9Xh8nArFUdFYcDdApaCVwozk04w4LaxWNVYccHXxZ1MxceuS/azaK6hotLmaKbVHiSup1jJR5nPJgj6AoxnKlYwPc4WJqs6hY+5OpnOTVRt97JUqK6vayKpJWi3HUeRHBiWRVRLkTF9JIw0kOaYq4vlqrnBA64TLOUrETen6SZjr9wHAL2QKncfw/3dwQo2Uvp0zTEhtZu4XhSEsuXEJjehWTou5RKWZMO0JOySi4y5imalyZsJJCSy1h0MK1tep8/1L1CkrWuM9zqScaekUqmGpH/f8Y53PPC987nPfe6+277t276NN9544/6dBU8kQgAKDi0lb7+SCCnVmbz22msUCoVtJ1jsh92mgHczy/egBGChUCCXy1EoFLY0V94rO20CqR/p9qDHoNERwMfZffigdPHY2Fi523lubm7LcV4Ar64v8NnJ13lpfZ52l4dNs1Lf53fYuOjsYTWbwq3aeTVWjMbIgF5VTDfgCgMSJ93dTGciOBU7NzYrkRuHSrn2zibJrBeKAsgh2WiSApgmtDm7WchtECnkWclPoVnFHGlI9TKdq6zlU9zMVW3bJRtrWiV66JRc2CUHXfYzGBakjCxu2cFMbgooTuA46T7Gar5yTLOtmeXCTHlbQiJZNZYOICQ3EZMqKWk/zSTlpZp9coVIMfwIKDhos59Cs5LYpQFAxbQgaeTQOUHW2ESzMnSqHSwWKh3ECjZcsopmVWoTW+3nSeiDVWeS6HV9N9tx0CngTCaz7ykgAgEIASg4hGzn7be2tgYU03LXrl3bcpzbftlpBHAvs3wPwmQ6Ho+Xo48nT55smPiDh4s1y7KYmppienqa8+fP09nZue8198LjnLhRTX26eGVlhTt37hCLxbh79245XRwMhXgjv8l/nR5lRUuwliuKvlaPm414krOBVpodbl6OzmJYJnZZxpArgu/pUAcL2QhP+XrI6DqyYjC0WewEDqouJqq6gk97W7mbKQolGyqX/L0ULA275GMhF6HTYWfKWIZ7wa0eV7DcKALQ7Qoxka1s97pamMhMgSURtAXpcbZTMPN4ZZ2otklQ9XOzqnM4pAaY0ytCTUYiXifugjYP6XzlOex29rNWVT/okFwkqE3thpzNpA0VRfJgGgqSJpE2NslbHehKDkPJQz5Cmqp5xPZTRLXqWcESWWOxZt1m23Hi+s2a2zSzNvLYbL+GR90+wn7QTSDpdPqxTLYRvPkQAlBwqNjK28+yLMbHx5mfny8LnYMQf7AzAVhK+QK7arJopMegZVnMz88zPj7OiRMnWFtba/gXwoMiltWzhHcTdXyYANytQDysX4KSJOFyuVBVlYsXL2KaJpFYjP/f1Ch/NvESq3qe0y4Pa3pR/J0LNuOQVJrsXiYTMSLOFIZVfOyfDrUzuDlPQHUx4G4ipxeI5jQ2ckuc97cxkV4rn/e4N8zNZMnaRcKrOjjn6SelF1jNJxhPL5PQi2ovqLqZ0yrHNtl8TFbZxJSjf5ZE2B4iqAbQTZkWWx9r+Sjr+Ry6tURCT5aPCdpqU//tjiAzuUoN3oCrj4V8pfHAr/hZrpojDKBbaRRsuJUwdtmLXwkQz0TQLAPLboJlMZGZwcQAit29vc4+EoVKSjxotZOmdgJJXq81S26xnyCh18791a14zXZIPU62bu5vr+v/yYN4FDWAj7oDWPDmRAhAwaFhK2+/dDrN0NAQUBRbr7766oE1UsDDBeBuUr71NCoFrOs6o6OjRKNRrl69SjgcJhKJNDwStp0YSyaT3LhxA4/H88BZwrtZcz8clgjgVkiShG6afGl6nL+bn+LFyBwW0OH2MK2n6bV5UA1YS8aJ3GuquBpuZShZjOI121xIlsRxdzuTyQ0kj8TtRFG0KRJkrEz5XO1OPyu5OOe8PeiWhV1WeD1eqd27EuxiJFXZ7neHuZWupDq7XAHupGMEFB9he4iQzU1E22QlH2MhmyTkDTOaroi1894+pqpqAfucHSznK6LLp3hYyFfOJwFZs3I+FTudjm6yVggZG4ZVTCmvFxZIGSoxfROFJEFbnBSbxQU0OOY6STpfiXIGlCbWCrW2Lh6nnWyVs4vPaCUt1Ub7TCNdsx1S+0gZtbYzNlkiW/WWdckdtNif5UE8ChsYkQIWNAIhAAWHBsMwasTf0tISo6OjdHd3l8XWQXbSQlEAFgqF+27fS8q3nkYIwFQqxY0bN3A4HFy/fr1sBXEQ9YVbNYGUnpOBgQGOHz++6wjcm6kG8GEYpslLqRi/+tf/leV0kq6QFwtQJYmTgSacaRvTqTjXWtqZvtfNG1Zs3E6s0St5UBQ7bpvKt6LFv4VsTsZTlSjXxWAHt1JLHHe14VYcyLLJUGKBxVz6XqdvRSR4VUdN00iTzcNEZh6bpRKSfLR6wmT1PHaCLOfTFMwks7kl9HtTPzyyk9lcJQ2rSDIRrTaVq9RNyehxtjCd3cSnhvAqAbyKF83KEVQ9JPQkBUtjPHOXglVdz9hF0qjU+vU6+1kqVDp9HZKT9ap6QYCwLcRyVfQvoLSwodVGFf0uD5EqQeg0mkjJszX7qPdmzUmWDZvsxyGF0C0Zj3IJUDGR6HV+G5L04B99B10DKCKAgkYhBKDg0CBJUrlObmxsjPX1dS5evEhra2t5n0chAOvX32vKd6u1S5Y2e0kRlcRXX18fJ06cOHCPwdL6lmWV0/CLi4tcunSJlpaWPa15VCKAfz87zZcmx/i/I8WI2LX2du4kI1xrKtZJfm21mKZtcji5nSxG9I55wnS6vQzHV5jWc3TKMjOZyqSNDpuTO4U0PsXBgKcZw7SQTQe3Ehsc84ZZyFcE2VP+DsZSlWjcKW8LI6kZgoqXVkeQoM3Fcj7OQjZCkhRBy894uhIh63bX1gIe87QxXhX9O+XpZjpb2e62t5I18/Q4BlAkGxawXkiQMz0k8xkgw4CrmeVCVX2i+xgzuYq4a7E1s5SvFWXZuskgXc5uFqu7g2UX61pt9C9gC5IrVOoOvXKYuDaHU25GlbwokguPw4dmdaLpOjk9j6mZLMtRDCWIJRfAzNJp72W5UJn8oeDg2dDHeBiGYTTEkmo7qsfACQT7QQhAwaGhepybw+Hg+eefv89ORFVVdF3fZoX9U9+osZ+U71Zrw+5tIkrRx+Xl5fsEcfXaBxEBhKKx9PDwMLqu70sAl9Z8M0cA31hd4T+8/gpL6SSJe7YhnW4vIJHXTIYja4TcFQPfE8EQhmmxmk0jI/PNjUqHbdDjZDVZrK/rdfjAhDbLy3IhS4YMk0ZFHLpUCe4Nv7DLCiv5og9fqz1Aqz2AZpgE5DCruQRYaSYzy+Uaw7Ds4k66IhbDNg9TVbWAbtnBbPaeOLQkQqofGyrHnCcoWCabWhpkB/PZDbg32eOct5/lQqW+sNfZznKhsqZNUlkr1KZkAzYviarfXt2OHta1io2LhMSmXtuQ0WHvIa4v45F9qLITBTsF08KnPI1mFcibWRxymKXCCBhFIeqUvcjabMVTUIIe35mayKJkKsTyE1AVyOtx/hMc8sPHrz2KJpAnOQL48ssv86d/+qe0tLTg8Xjw+/34/X68Xi9+vx+fz4fH48Hr9eJ2u3G5XGLSyAEhBKDg0LC2tsbrr7/+wPTio4gAmqbZkJRvPdUCcKdks1kGBwexLIvnnntuW/G1G8++nVK63pdeeonm5mbOnz+/7y+2N2sEcCGR4HOjQ/z5naKB8Pn2ZpSMhVsGt9vNt9aLEaln2jp4LbLEmUBzsdN3fR7dMpGBgWDF0uipUCtxLc3lQA8buQweh8pYsih+AqqDBbPSeNEju8qNIM02Hye9LST1HAVDYT6TotURYDhRSd+2u7zEUvHydpPiIFW9nivEeGYTh2Sn2R6mzR4kbeRI6llWC3ECtjCDyYow63Q0MZOtrG+XbSznay1aHHLte3nA1cNslXegX/GzmKtN2yqYeJQQTslLPmvhVT0osoRCG3kzR9bIMp/bIG1mKbUxH3OdZC5XiRDaJAemFatZt9XexWpNZM9GQpup2afdeYKYXjv3d/NWB2843yhPgvH5fFv+kDvoJpB0Ok1zc/OBrX/QfPnLX+ZTn/oUb3vb24jH4+TzefL5PJqmoWlaedqTZVnYbDZisRj/+l//a377t3/7cV/6mw4hAAWHhlAotO0EiRKPqgbw5ZdfBvaX8q2n9KWw0+sv+eu1t7dz5syZB4qvRkcAS13GAP39/QwMDDQk2vZmiwBmNI3fH7zB1+fnmEoVhcbF1lYsLFbTGXqcToZjReHW6fYgIdHh8HM7GuFYSEe/F4W73NzO4OYSnU4fHU4/CT3HfCrNfCrN2WAzt5KVyNdJf5jBzaLg8itOOjwhPAUXK/kUES1HqjBHlmKUvMXu4XayEmnrdAYYr5oY0qx4mDcjeBQnLfYwHtlJztDwSi2sFTbJGSnWCwkyRg4oehCmjEojB4Df5mSjKih/wtVZYxTd7mhmPl+JbBatYDaQLQWPGsCteAmpQXJmDt0yyZkF7JLKZHYGExPIggTtGMSylTR3v/MYy4XqSSAycb1WeHY5elkpjNXsk6ibFtJuHyCijdbcptWJxibbWZ6//F1ln8fSeyMYDBIOhwmFQmVrlkcRARwYGDiw9Q+a8fFx3v3ud/OXf/mXrK2tlWe7a5pGoVAoC8JMJkMoFOJjH/sY6XT64QsLdo0QgIJDg91uf6D4g6JAO8gUcCKRIJlM0tfXt++Ubz2lGseHCTXLspicnGRmZoZz587R1dX10LUbKQANw2BkZIRotJhG7OrqapjQepAANE2TxcVFHA4HoVBox1+ijysC+Hd37/IbL79MJJumO+yn3e2h3e1lOh0nkstil2U2JY1eT4AWu4ecpPHqWlGgXG1t541Y8f8tdjd2RaHXGWImFafd6WMiWbQskYF8VZNEh9NL1tC4GOhhI5cl5HDwaqIi6K6GOhhOVgSOT7PYlCs/OJodLtJminZHGJfixMzlKBgWET1LJL/OxUAXY1UC8ZSnjVvpSrTvtLeL6WylTq/VHmI6W0ntqpLMWpW1jFN20mwL45XdyJINw7Jwy3YWC0skDQebRgaXbLIiRShY+fJxJ92998RfkbAZIibXNp0UrFoh2u3sZ7VKEEpA2lir2afDcYwN7VbNbVqd9UvY1kvKqK0rPOn5f+Byuejq6qKrqwvLskgmk0SjUdbX15mcnMRmsxEOh8nlcgc28QeKNcmN+lH6OPjxH/9xHA4HPp8Pn+/hKfUTJ04cqKA+yggBKDg07ERkqKp6IBHAUsp3cXERu93O2bNnG34OeLhQKxQKDA0Nkc1mefbZZ3f0AVlatxGPS2mkm6qqPPfcc3z1q19teMRuq/Xy+Tw3btwo2wAVCgUCgQBNTU3bTtEorfeomYtv8vuv3+DLs1PopslbuzopWDrDa2u0+bxEclkkCy43tbCU3GR+M0mw2clovChgfDY7S9kEl0MdZDQNv8POy2v3Ino2BxOpil/dpaZ2FnNxLgW6yBsmqgI375k+q5KMTqVGNmhzciddiRR2Ov2saAnaFD9O04akm8xtbhLHJFbYoNMRIKJHKT0bzTYvd6oaQZyyjblcpWlDArJGquaxaLZ7yeYSBG1BXLIHv+IkbWZRCRDTkkiWneHEdI2Y63aFiOuVTt8+Vwd3s5V0cEDxs5CbqTmPjdrnucvRzUZd2lazaq+tw95PVJ+ouc2o26dZ7SGlL+CQwiiyBwUHLjmEgg9LkrEsCZvsotv5tprjJEkq16719/fXjAXM5/OMj4+zsLBQnhQTCAQa5l36JHcBW5bFu9/9buD+bumtaqMty+L3f//3H+k1HiWEABQ8URxECri6y/fChQvcvn37wQfsgwddfywWY3BwkFAoxOXLl3f1hSHLcnn02F5ZW1tjeHj4voaXRkYzthKA8XicGzduEA6HuXjxIlBsPCml2+7evVuOrjQ1NREKhWqKwh9VBFA3Tf7oxk3+4PUbtIQ8uFSVC80t3FhfIWfoHAuFuBlZ5UpzO6Zp8UZ0Hc0ycSoKq4UUkiVxJthEs9vFtzYWWUmn6XR7uZupCL5TwTBvRJc45g0TtruIFjKsZrKsZrKc8IWZTlVMlS+F2sqpYIATvjATqVVOeTpwyHbsskS0kGMuX/QKfCrYSrSq9s+e17CqAitdLj9j6YowO+Ntr4n+nXV3o0k6x13HMa2iIJzLrhPXLWJaDJk4bQ4vEa1yjj5XC5OZaHl7wNXJYqGSDlYlhbWqzmCAdkcTM7nKMWE1TLwukmerE/5t9i6i2iyWJeGQXTgkL07ZQ1g9jSypgIJNUtGsDC7ZS8HMU7ByaFaQDX2N4qy8Ah7Zz7q2dM9kushV//+BIj24CaF6LOD6+jrHjx8HIBqNMj4+Tj6fJxAIPLR+cCdkMpkd/zA8bFTXKiuKQiQSIZVK0d7ejsPhIJPJMD8/j8PhoLu7+8AM/wVFxKMreKJQFIV8Pv/wHXdIfZdvKpU60PTNVhFAy7KYnZ1lYmKCkydP0tfXt+vI1n5SwNUp5/qRbgfdtLGwsMCtW7c4ceIEfX195fF/Ho8Hj8dDT09POboSiUSYnp5mdHQUn89HOBwuW9QcNBPrUf6///CP3N6IcLmnHSSLSCpNtJAlZ+g4ZYV2r4d4PseNlVVOt4bR7tX3XWprQzdNJEMio2m8tLaBce+am9xOluMJFGTOB1qxTAipbiY3YzzT6uRuqiKEqrNgbsXGdGaDoM1NlzOIW7Gzmk2QyFuM5NfpcwdZLkTK0b0BT5jbqYrQ6nEGWdYqwtNn2bidWgAJ/JKLsM2PhMJx1wBJPcdaPkFUL7BQNdXjor+buF6JqJ3ydHG3Kj3sVzzMZGuncUhS7Y+fY67ue3OCizhlJ8tV9YIATfYAuUwMl+zDqXpxSi4sLNrs5zEsC83UUCUHppUla6RJGgbNNge3MuM16/S7BljOV87llQOs1hlIt9jbWSlUHhcZhXOeb2c3mKaJw+EgEAiUO/az2SzRaJRYLMb8/DyWZZXFYHX94E4ojYJ7Uqn+rPqDP/gDAD7wgQ/gcDj4jd/4DT7zmc+QzWb59Kc/zQ/8wA88zkt90yMEoOCJolEp4O26fA+6yaReqOm6zs2bN9nc3HxoA8xu1t0ppZFu6XR6y5RzaRRfoyitV21tc/nyZZqbm7c9T3V0BWqjg5qmMTQ0VE4Vh8Ph+6yD9oNumnzu1SFeWlzg9kaEcy3NLKdSLCWTXO5sYzy+wbXWDmRF5psLxWjcpbZWBmNrnPaFkAsF3lhboWAWX1Onm0MYueL9PBdqBkviYqCTqUQUg6JNDEDY7uRWohL1eirUylhyhZDNRbcrRNDuYCoVYSmbYCO7yuVwO7NVnoF+u42lKj9zt6qUbWIAgnYHcV0liBu37KLF62c5G2c1n2DN0vAUCryer5z/pLuNmVylwSKoerhbJe4kIFM3WaOnNDf4Hl2OVhbyizXHJPVNfEoAl+LBLjnxq15yRhbdMsmbBUwspjIbZE2FmJkBLcNpdz9TVesG1SAb2mxNmjmgeklWvY09so/VupFzTfY2lvJVAhuVuF4rPvtdz+BVw+yGrYygt6ofjMViNfWD1YKwZPBej2VZpNPpJzYCWKL0Xv/zP/9zfvAHf5BwOMzo6Ch/+Id/yMc+9jGSySS/9Vu/xbVr1zhz5sxjvto3L0IACg4NO/kF3AiB9iBj55INjGVZB1JfVj0PuDRSzeVycf369X2Zx+4lUpdIJLhx4wZer5fnnntuS6+tg7CXMU2Tb33rW+i6/kBrm+1wOp10dnbS2dnJN7/5Tfr6+tA0jaWlJcbHx3G73eV0cSAQ2HMB+Xx8k1/6ylexZFjNpHmquYUUGkvJJGGnE5uioFgKc5sJNo2iugrY7DhsKm12D+OxOH0eR1n8XWxpZSS+xvlAK3ZJYaOQZv7eKLZzoWZGNyuCayAQ5EZ8CZescswTxiM76LKFmctsYuibTEp5skaxGarXHWRksxLdO+Ft4nbVxJAT3iZW8puccLfjkh04ZJWFXISUJpEgQ0g2mYlHyh3JDlklac9DVa9VMh2v8cTrcxetYkocd3cyl6sIQpfsYD63gEt24VV8OBUXYZsbj+pFMw2yRgG/6uJutlQfmEOVZPyqk4RRsaQ54xlgXcuWt92yi8U6s+hWe5jZqsikW/awUjctpM3RzmK+IpBVSSWq1UYnOxx9bGi15R9Pef8Zu+VhPp/V9YN9fX019YPz8/OMjY3h8XjKYjAYDNakQjOZTENqAD/96U/ziU98guXlZc6fP88nP/lJ3v72t2+7/5/8yZ/wG7/xG0xMTBAIBPhn/+yf8Zu/+Zs0NTXt+Rri8TgnTpwA4C/+4i9429vexvd93/cRDof59Kc/TSZTLF84qM/jo44QgIJDxcOEzH4F4MOMnautWg6i/qTUrLG4uMjY2Bj9/f2cOHFi3x9uu40A7nSkW6MjgJlMhlwuRzAY5OrVq/t+jCVJwuPxEAqFGBgYQNM0YrEYkUiEW7duoWkawWCwHCHcaartb29P8fH//Q1UWeJ0ZzOJSJ7ukJ+59Q2utrVTkExeWSpGxLpDfmx5mTaXBxSJl+/dfjYU4lY6AhacCjZhkxXckoORyAbXWtvL4k+WIG3eC89ZcC7YgozMSVcLU8kYdp+NlzcqtX7H/UFuxCuRNL/dxmK+8hx5bCqnlDacsoO8YSBhspHV2MgWRdJTwVaW8xXx1mb3MFmozBQ+529jtGpm8Al3G7NV0T+XpTKVngMJ7JaNgM2HV/bcqw2UyJs6AdXJeGaWnFlgnTitdpjJLmBRuc5+uaUmajfg6mY6V6k5tEkKq4VaW5ceZ0fN9BCH7GClLmXc6ehgvmpaiCIp94s9ez8rhdoUsWHVzwbuodN5jt1Qim7v5kdHfYS79BqORqPcuXOnXD84Pj5Oa2trQwTgn/3Zn/HTP/3TfPrTn+b555/nd3/3d3nve9/L2NgYvb299+3/jW98gx/6oR/iP/yH/8D73vc+FhcX+eAHP8iP//iP88UvfnHX5y99pnR1dfHVr36Vp59+mi984Qv81E/9FH6/n2QyWXM/hfg7GIQAFDxR7HUSSHXK98KFC7S3t2+5X+mD+6DqACVJYn5+nmQyua+RavXsVABWp153cv5GRgAXFxe5desWiqJw8eLFA/EVtNlstLa20traimVZZDIZIpEIkUiEqakpbDZbWQzWN5MAZAsan/yHV/jHuTnavB58bjuvzi3R4fNgYRGyuyiYJsPRYrTumY52MobBUiKFXVaZvjc+zakq6JLBKZuXTQn8dgffumcB47c5uJOsRKyuNHegWQbhoIeZZPH4knG0S1FrxsF1unwMV0X7TnqbyBs6lwLd6KaFQ5F5PVYRO2f8LUxWeQjW1wIGZQfTVTVvdllhIVdrt+JQZLocLbgVF4qk4lFVVrIxolqamJnDVjB5tSq9apcUfDaVnFnJQbc5vCQylfvc42xjqc4sOl1lRg1Fs+iZ3GR5W0FmQ6ttGOl1dDOXH6/ZJ1rnBdjtqIg9y5Kwyy4sy8KvdKJIdmTJjkNyIEkaYVsIywILeMr3beyW0o/T/dhHVb+GoVI/+F/+y3/hi1/8IoVCgY985CN853d+J+9617s4ffr0rt9Lv/Vbv8X73/9+fvzHfxyAT37yk/zN3/wNn/nMZ/j1X//1+/Z/+eWX6e/v58Mf/jAAAwMD/MRP/AS/8Ru/saf7WPrh9+EPf5iPf/zjvPrqq8iyzHd+53eiqipf+9rX6OrqKotiwcEgBKDgiWIvEcDdzPLdrVnzbq8jkUhgs9m4fv06LperYWvvRADmcjkGBwcxDGPHqddGNIGYpsn4+DhLS0ucPn2aqamphvoKPuhvpWaS3t5eDMMgHo+XO4uz2Sx+v7+cLo4WDH7+i3+P1+egL+BHt0wGV9Y4GQ6hOBTeWFrFa7exkEnwVHMLpm4ytRknmsshS2DJFnZZ5my4GY9N5Rsrxahdu8fDULTKyDkcYjGd4JSvmYJhMpmIES8UjZbPBZsZq0oFXwi38nqsEu3r8npp1p3YZBubhTxgMpGMAUWReMIXrHkMDGp/LHlstbWArYqLu0YWGZkWh49+VxN5q0CbDdJ6HpdiY7jcaRzHrdixKSYZo7JIyOcllq2It1bdzZocL28HFA/TVZNCAFxybYSs39XFQlUkTwKSRrxmn157F0v6vQihJeGUXRSsAk22blTJgYyKR3FRsLK4ZQvDMtEtnYyhYFld5M0ceTNHu72diVxtRHDAOcBSldh0SC6+p+0Zdkt1h2ujKNUPfupTn+JXfuVXOH36NM899xxf+tKX+Lf/9t/yi7/4i/ziL/7ijtcrFAq8/vrr/PzP/3zN7d/+7d/Oiy++uOUx169f5xd+4Rf48pe/zHvf+17W1tb4y7/8S77jO75jT/fp1q1bnD17ln/xL/4F4XCYl19+me/6ru+ip6cHgLt37/LDP/zDBIPBPa0v2BlCAAoOFY1OAe92lq8kSQfSCFKyWLHb7fT29jZU/MHDBWA0Gi03S+xmpNt+U8CFQoHBwUEKhQLPPfccmqY9tlFwiqLQ1NREU1MTJ0+eLDeTRCIR/mbwFl+YWKEr5GY1XiBnmvi8dp5ubUWxyby+uoIMXO5sYya+yejKOpe624kmisLtWkcHmmWylk4X/xUq6cRmj5vlWIpeT4Aej4+FdJKVVIaVVIZr7e3E760hUZUKBprsTlZzSS4GOpCQkIDX1pfKSdTzwRZup6oaRQJtjFVF984FWrlTVQt4zBNmKrVOpyOM3+bGJduIpmIECRAxMqxks+SNVWJa5drP+GvnTp/yttakh3tdzdzNVs4pI6G7zZr6wUBBYc1euaHVHmI2VysIJQyckhO34sEhOwkoPnQKeBzNmJZFZDNOwWbDKXWRMbNkjCyt9i7uZKZr1ulxNLOmVe5zp6OTuVxtitil2qlyecEte+5rELngext2effNRIZhIEnSgaUsS1MyPvrRj+J0Oslms+RyuV2tsbGxgWEY9423bGtrY2VlZctjrl+/zp/8yZ/wvd/7veRyOXRd5zu/8zv5T//pP+3pfnz0ox+lqamJf/JP/gnvec97eOc731nz95/6qZ/a07qC3SEEoOCJYqeTQHaa8t2KRpkql65jYmKCubk5Lly4wNra2oHYlmwnAKstZk6fPk1PT8+uvpz2kwLe3Nzkxo0bBAIBrly5gqqqJBKJbe//Xr449/NFW2om+dpshP82s8HZ9mZuxaLkNZ1jQSfT8SQpR44kOhdbW3AoKl+fK0aOTjSFGNlY42JLG5gWI5F10vd8GHtDfhZzxYjYcacLp6zS5fAxv5nAbbMxmyrW37W7PQzHKl+4l5vbWcjEuRTqAEvCpkh8K7LIHMW1zoaby+JPwiJbJRZlIGFUmiUkil55p70dOGQbBcPEpljkdIVpLQEkuBLq4G6VIfOVQBcjyYpYGnA3MZmuXJ9DVpnL1frxeZXaFPoZbxeTVVYwTsmO7jYJG2FkQ8bULBx5lSZ7B5Yio8smXtXJVGYR3TKJakkgyYBLYb6q7rAJL9N1tX4GtXZQXY521rRaYemo8+/zKT6W87Wisd3ewWK+ejqIxBXfP2UvlBpADkoAptNp7HZ7uWHM5XLt+cdk/TU+qNFibGyMD3/4w3zsYx/jPe95D8vLy/zsz/4sH/zgB/nsZz+763O/733v46tf/Sp/+qd/ype//GVOnz7NO97xDk6fPr2jyUeCxiAEoOCJohSde9CH1W5Svg86x37J5/MMDQ2Rz+d57rnn8Hq9bGxsHEh94VZCTdd1RkdHiUaje7aY2WsEsNRkcvz48Zo5wgftK7gbNN3g//ofX2c+maDD6yVlGXQH/DT5XLw4v4gEdPncLCfT3Fpex+cpiomA3U6zx81GNsvw8ipPdbaWxd9TrS1Echmeae5gOZFk0ygwtVqMkD3V0sJwrCKg2rxu0sk8Z/whnLLCWi7NWibHWiZHt8fHSr4y6uxcsIXbVbYwF8Pt3EwUBZKMzNVwMQLZZPOR1Ap4VRs3qlLHJ71NjKUqtX0tDg9jyYrAsksyi7lKLSCAS1Vr0sVnfe010b92e4D1wibdjlacihMFBbuk0OfoJ2sUSOpZepxhxqrMpAM2NxtWEt00KPV/9OQD6ErlR12HvblG/AGoUu1z3GFvva+G0K3YoMoL3a8EWKrrGG5ztDJf1Q281fzgfuc5muwd7IWtLGAaSSqV2pVn4FY0NzejKMp90b61tbX7ooIlfv3Xf53nn3+en/3ZnwXg6aefxuPx8Pa3v52Pf/zjdHTs7vF6//vfz/vf/37Gxsb4yle+wl//9V/zP/7H/+Dpp5/mbW97G//0n/5T2trantiJJ08KjRt0KhA8AkrFw9uJqJWVFV588UVCoRDPPvvsngxTq61a9ko0GuXFF1/E4XCUxV9p7YOoL6wXaul0mpdffplcLsf169f37C+42whgKfI6NjbGpUuXOHbsWM2XVaMF4F6/CJPZPD/9R18hks0yF0ng9dhx21Q2szkGV9Y4Hg7xXH83wxtx1vMa5zpbsCsqJz1emhWFlxYWieVynAgFGNpYJWB3cK21nZxmsJRI89rKCk1uJxt6sRHCJsus5TNISBz3BXm+rZtMQSeT1xneWMOSKEcGAUJOZ9ksWsIid28esIxEjyuAW7Fz0d9Nn6MF1bQxl05yI7rC69ElJpMbbGi1Ha02pfZx6nH7y7YvAOcDHTWp3x5XmInUCmHVS7+rjTOeXiTLxklXP932LvxSEwE1yEoux2Q6xkhimZyh8/rmXW6nFpnNrpPUMyzmayOGfe5m9Kr8a0j1sq7Ea/ZR8rWvtxZbkJhts+Y2n1rrk1ccH1cn9uy1XcaqpLChLdbs0+3oI23Urn3V/y72imEYDZ0fXk86ncbj8exrDbvdztWrV/m7v/u7mtv/7u/+juvXr295TCaTue9+lYTuXt7PhUIBTdM4d+4cP/MzP8M//MM/8IUvfIGTJ0/y6U9/mre//e188IMf5M///M/JZrMPX1CwJ0QEUHCoeNgXeulDZ6s5kntN+W51jr2KNMuymJmZYXJycsuU634mdjyI6nW3G+m2F3Yj2EpzjEsRz62+qA5DBDCSTPNzf/p3eF0OvjW7xIm2MLPRBBvpDBcH2mk1TFYSKZbSxSkXZ1rDaKbFaioLPk9Z1CkyKKZOn+JkMVsg58wzkShGl8JOJ3fujV3zqDautraR0DTyeYO7sTimZDF9r+O3yeliJF4RSqcCTYzEi00jTXY3Z4JN5AwDxWVjLr1Jk93DN9cqTQxXmzsYrLKFeSpUiQ4CnPY1c6eqVrA6+qdaMmHVU5xE4u3DtCSyhoZXVVnIJljO5VjO5bgU6Oa1eEVgNdu9jKdrxZRB7SjC094uxjMz5W2nbGc2Wxtt63KFuVPlJxhQvKyZ0Zp9XLrCZtVL2K94ma+r6+twNDNdNT7OJtlYzS9gl5zYZAeq5KDZ1kTeSuJT2pBRQFJQJDsttqcwAQsLt+zhhPsSe2W3FjC7JZ1O4/V6951i/shHPsIP/uAPcu3aNZ577jl+7/d+j7m5OT74wQ8CxRq9xcVFPv/5zwPFlO0HPvABPvOZz5RTwD/90z/NW97ylprJQTtlK8/Ts2fP8ku/9Ev80i/9Enfu3OHzn/88v/mbv0k0Gi1fl6CxCAEoeKIoiRld18sfIvtN+dazVwGoaRo3b94kkUjwlre8hUAgcN8+jZjZuxWlusWJiQlmZma4cOHCrtMy2627E4GVSCR44403CAQCD5xj/LgjgMvRJP/xf72MU1VZSCa42N3Gei5LMp/n2ePdvLawTMEwONXZRMhygWWRNQxmIkVxEfA4sHLQ5fWhqDIvLxdFUKvLxe17gg6gw2nHxEE6lycny7y2tkLmXu3qpbZ2bkQrjRN9/gA3osvF6J4nQJvTjUvpYCmTJJbPMpmIs5ItilGnojBXZQtjl2Xmq7ZlCTYKlfFsxcfIotXuI2T34JRteBQb6wUPkUKGSD5N0OHh1WhFzHW7gtzNLpfrDRVJYrUqbQrQ7Q4wmqwIt2PuFmazlZSiDMT0eM0xJz3tjFelg92Kg9lcrYjscjZzJ1NMfUuWjF92k5XyeAp+ZEtBlVWClgfT1oSiqsVrtGBTL+CV+ymYGnlLo8XewlR24t6q+eI/y8aaVunGbrG3cFevTYO+t+m7kaS9/2B6FBHARoyB+97v/V4ikQi/8iu/wvLyMhcuXODLX/4yfX19ACwvLzM3VxHZP/IjP0IymeRTn/oUP/MzP0MwGOSd73wn/+7f/btdnzuXy/E3f/M3xGIxenp6GBkZ4fu///tpaWkp/4g9deoUH//4x/n4xz9+oJOZjjpCAAqeKCRJqhkHt9su352wlyaQRCLB4OAgbrf7gVM9GtlgUo1hGOi6zvLy8pYj3fbKTlLApXq/Y8eO3Zfy3Wo92L7gfC+RjZ0KysVIgv/01y8zH0/QGvZAGiwFvA4bbluQNxZXKBgG13o7iOXzTG5EudzTzq2VYgfwMz2dbBbyrCbSYEJEr6SmmvxupKxEt8cPlsnrkdWygDrucbN6T/w5VYW5e16BqiRzLtiMgsRZXwszyU0CNgdfX62N7r0erUTNnqqzhbkYbueNeLHxQUHmaqiTrKnRZg+gGSYum8rQ5iIF02Axk6HV4WFTT5fTvwqwptf67zU5naxW/UY57+tgLFVprgioLiZStZE8R9377pS3k6mqUXEKMgk9SbMtjFN2osoqIdVD1sxhAsa9mc4bhTxOqYWMmSdr5Ol3dzCevlvsapGKHoObZppcvlCuT+xX2lmwaoWkV6n9atuqQcSveolV9ZOpko1nAs+zHw46AphKpRpWF/ehD32ID33oQ1v+7XOf+9x9t/3UT/1UQ7pzV1dX+ehHP4ppmvziL/4in//858tiFO73UDzIx/OoIwSg4FCx03FwmqYxNjbWkJTvVuvvRqQtLCxw69atHQmgRtQX1pNIJBgaGsKyrG1Huu2VB0UATdPkzp07LCwscPHixbJx7YN4mADcbXRwp4JxKZrk1/7iH1nYTNLfHuSN2RV6W/wUNIPbyxv0d4bo9HsJOJ2MrW+QLmi0+71Mb25ytb2dSCbD7UiEeK6oOoJeJ0uRFK1uN6fCYRZTKVaTGdZSGXpD/rL463DYmcoXa+skC46pDkwUQg4HC9k0mmUyvFZMzyqyxHq+UofnVlSmUpW0ple1lw2kW+xuWp1eFGQu+DqJ5bOs5VJMpzZZzVUigKeDofIoOoBut5/IZkXwHVN9TFd1Ane6/Nyuag6R4V5nboVj3iZGksV0sFt20OEMo1smJ919yMhYSNgkiS57DxlDI63n6HGFuV1uIEmhSjIhu4O4XrnWC75eJtOVCJ1NUljKrVafmhOebiYzFcsWCYuEuVkUiKX7oLSwodVG9uobRJyy674GkYvea3iU/Ymrg24CyWQy+64BfNxsbm4Sj8d55zvfyQ/8wA9w4sSJsvn0QTgkCLZHCEDBE4ckSYyMjKCqakNSvvXsVKQZhsHY2Bjr6+tcvnyZ5ubmhx7T6BrA0ki5np4eZmZmGir+YPsIYKneL5fLbVvvt916jeZhXxrrmyl+64vfJKNrDLQFubm8zrnOFhaSCdY3Ylw71kFGNxhdXeN0dzPpgkabx0NfyM/Q8hpvpFa42N3G9GoxNfl0RyuyDKcDYRYSCe7Eoqzdm1l6qb2NN9ZL4sPCa7NxJRhCM0w283mm8inyuaIg67HbuRWvTMe41NTGG7EqH79wK29ElujxBGi2uwnYHaxkU5h6gtV0jl5PiJfXK1Gtq02dvFFVC3gu0MJ4qiKg2hweRhOV9RVJIkath1yb08O6FkNGJmRz0+9qImdqhL1BuDchI5bP4ZPDxLUsEU2ny2FjLFk57wlPC6OpWgHm12tfl6e9ndzJVASYgsRqobYL+aS7k8nsTHlbAuJavGafPld3jYE0gKVrNXOLfbLnvgaRbmdnzUg5gOvB3U/+qOdhc4D3S6kG8EkmmUzyjne8g5/+6Z8GYG5uTkz8eEwIASh4olhZWSGXy9HS0sLly5cP5MN2JxHAdDrN4OAgiqJw/fp1nM6dmcY2KgVcP9LN5/MxMzPT8C+grSKAyWSSN954A5/Px3PPPbereb4lAdio63xYTWEineN3//pbIFsUNIOUrtEbCmDIJllN463HunhjaYW8bvBUTyubhXzR/FmVeXm+GAk72RxmeG2NC83N2CWFucQmG5li+vdKdwev3bN58dnszCU3OR9uxqnYkAyd16LrkCpG9S62tzKbLUbbZAkstx3SRQHmlCRux1ZpURy02D24HQ42czlsKMwnEqQdBTKmRs4o5iz9Nge3ExVbF7ssM5uprdPT6poyutx+Nu5F/xySwsVgJ6uJCO3OEDabHVVWiOWSeAgQ1zIsFbLYpRTz2cq6V0LdTKYr521z+Lhdlw6u7zg+7WnnbrY2RZswaqOKJz1dTGZrhVyybp9jrk7m87UTPGSp9sdJ2BYgatQ2kXgLTqL2SpRTAmJ67bi7Hmc/3c4+9stB1wCmUqknPgJ4/PhxfvVXf5Xjx48D0NLSwlvf+tbHfFVHEyEABYeK7SJE1V2+Ho+Hjo6OA/ugfZgAXF1d5ebNm3R3d3Pq1KldXUcjUsClkW6maZZHuhUKxc7URqdQ6gXW8vIyIyMjDAwMcPz48Udq3LxbCprO73/5NZY2k0xH4pzra+Xmwhp9rQEkScIuKayk0uR1gxMtIXTDZHZjk5DbRV4qPv9tHjdht4tQJsvYygaXe9rL4q/T52VofZWww0m/P4DLbuP1tRXG0hEcioLbXglDHQsGGdqoROMutbYxlYryVLAVp2zDaVN4fX2ZNU1jLRfnhNPJlJ4p79/nDXCjyjT6dDBcUwv4VLidN6q2LwRbWcknOOFpxq04cEoKeVOnz9lCtJAloeWYzWyyrGchdU/MhjqYSleicOf97YynKxFDh6wyk6m1delw+oloFXHV4woxma6d12tR+1466Wlnpq75I2vWWn0cd3Uwn6+bFlIn9lrtYeZyC0iWjEO2Y5PtdDjaiBVsKJKCLKnIyLhdNhyGF1030TQdqWCi53UCqg9VVZFVlbcF3kEjOOgUcCNsYB43pXIdXddRVZUXXniBF154ARD1fo8aIQAFh576Lt+xsbED7QyTZXnLaSPVNW97rTvcbwo4Go0yODhIS0sL586dK39glkRoo4vQSylgy7K4c+cO8/PzO6732249aJxQ3S4CaFkWn/3ya8yux5mPJ7jQ28aLk/P0NPvJ6DpTyzEuD3QQy2Y529KEZJMZXS1GhTrDXiwLDMPE7bTxynxRrPSFAgyuFkVYu8fDsXAIV8rGVDRGRLWzEFkre/ddaGspRwYBFFWi0+OjzelBkSTWMhk20xqb6Q2aXS4SZp78vdd0p9vLTFXdXVixMVQl/kI2ByObRTHpVWy0On0oyFwJdlMwDBJanqxmsJHJs5Ep1ixeaWpnMF65nkuhDoYTFRHWUpceBihYtRHEc/42biYrEbig6uJOqvaYkN3JSqGy3edqYjpbmw4uCTkbNtyKgzZHiLyVo8/RfU+4KfhUO8dkJ5YFeU1Dz+bIOVVCajeapVMwdbxymGU9g2bpJLFwyhZpY5Fc1YSUU+4+bqZqJ38cC7SzVPIn1MFRsJO5lWUiPEE4HCYYDO75PXTQTSCZTGZbs+YnCdM0UVWVhYUFXnnlFdLpNE6nE7/fj9/vx263c+zYMZEaPmCEABQcarbq8t3pOLi9oihKOaJWIpfLMTQ0hKZpu6p5q2evAvBhI92qBWAjKYnh119/nWw2y7PPPruvGqRGC8Dt+NLXx5hYjqKrFi0+DxPrES71tZMyNMZXIxxrCZLXdabX41zoaWV4dQ2fw85Tna3c2Yiyns7QGfAytRm/t6JF0OMk7HURTWfxOu3lsXAAToeKkSnep1a3m+H1VTpdHrwWtIebuBlZI5bPsbSZ4lpHO7NVFio9fj9vRCoiqdXjYjlWmQLSGwpjJuM0qU5spoXNNIkZEglUEnmNEx4Hr6xX+wC2MpqoRBtbnR5GNqssWiRYL9SmV3vdAQarmkPO+FqYzFTWUCWZpVxtavWYt4nhxBwqCj7VSdjuJW+YnHL3IEsKEhIeRcUle9BMg7yp41MdLGQ2KBguMpbBplYgaJO5k66kmTsdQcZStfWA/XKAu5mK2PTITiYz82hW5XPguLuDiWztTN+MUWuI3WILsZivjT7+k6a3caL1BNFolPHxcfL5PMFgkFAoRFNT06589wzDaHgdbjVvhhpAy7KQZZmRkRE+9rGP8eKLL2K328tzji3LIplM8mu/9mv8/M///IFHVY8yQgAKDhXVNWLbGTtX28AcBPUp4EgkwtDQEM3NzVy7dm1fH0Z78RjUdZ2RkRFisRjPPPMMwWDwvn2qH7dGous6q6ur5ckq+/1ye5gA3EtKuX6tF4en+froLIpD5u7cOueOtZGIFDBlWI9nuNzdzkYuy9TSOgGXg7SucbmjjdnoJrfWI0TvpXg9LjsZQ+dCawtOu8o354spSYeq4DUrNj9Pt7cyFFmj1e2m2+PDaVe5tWGynMqgShCXi40TAE0uF8PRShq11+dnMFoRWsf8QVJagSuhDiQkbLLC7c0N4oUCcQq0uTxE9EzZxsUpydzerKwnYZHSa2fkdnt8bMQr4u6pYK1RdFB1MJasjeTZZZl2ewCP6sAh2wjanGTMAq32JjTTxLRMFjMpFMtF2iiQ1nN0OJsZTlREcZvDR0xLYFJ5fp4OdLBZldpucwSYqDOUbnJ4WdcqAtArO1klXrPPgLuN21WeghIQ1WsFarejjZVC7f1qtvvZzFbq/2Rkvq35bYRtIVpbW7Esi2w2SzQaJRqNMjs7iyzLhMNhQqEQ4XD4gfW+j8II+klPARuGgaqq/M7v/A6zs7P88R//MZcuXULXdXRdR9M0MplM+TNfiL+DQwhAwaHjYcbOBzVOrX59y7K4e/cud+/e5cyZM3R3d++7hm23EcB0Os2NGzew2Wxcv34dh8Ox5X6SJO16bNvDWFlZYW1tjUAgwJUrVxpSv/cwAbi5uUmhUCAUCu2otrL+msburvLfvjEGNonX7y5x6WQHr00t0hYqpl5zuWKH6Fxsk4GmIE1+N6/PL2NaFhf72rixtIpNlrnW00E8nyeZyXPXiKErles9397CayvLOBSFE6EQTlWly+llKZEiZHPyxnqVoPN4GM9UrE56An5ubBSjcV6bjV6/nxa3B8M0iWSzOCSV27ENoBghPN/cTLxQ6dTt9HpZjVbWe6q5jdeqTJz7bR5mM/HydqvDXRP9U5EwLIMT7hacio1MIkWbO0gKjayhkdQKhOwuBmOl+5BGBjo9XpZzlajk1VAXE4lKFNOvuhivSwd31tUHNtu93EnXNoy0OXxsaJXoX0BxMZWurf3rtge5WzWmTkFiJb9Rs89xdydzdQ0ibqXWi9Mh21moqyt8yneesK0yJlGSJNxuN263m+7ubkzTJJlMEolEWFpaYnx8HLfbXRaEoVCoRqA8CiPoJz0CWHrPrq6u8l3f9V286117H70n2B9CAAoOFZlMhhdffPGBxs4HLQBL0zreeOMNUqnUtlM99rr2TkVaaaTbTptNGmUxY1kWExMTzM7O0tzcvO/h89VsJwAty2J6epqpqany81uKuDQ1NeFyuR54vQCLa5t84e+HQJZYS2a40NPKGzMrnGpvImPqvDGzTH9rkGS+wJmWJhSbzLfm7nX6toaJZrJc6WhnJZliZHWdZL5YBtDXEmRwpSiI+oN+AM6Fm7kbjeOy2Xh1cenefYO8VXldBux2ZvPFaJdDljkdbkKVZC6F2ljLZAg6HXxjsSJIzoWbGKuyhTkVDDMar0Sruj1+hqqihX7Vzq1EbfTP4XbSoys4UZB0C5um48ZNQYKUZdDvDTIcrQhCj6SwkFgmb1ZSqU2O2sf6QrCd0SpvQLusMJut7aI94W1iqCr6F9hCEPa4goxUzTv2Ky4mMrWCsN/TzFhqprytSjJrdZG9E+4upuo6husbRPyKl5lsrSAccHVyNztZc9s7wm/nQciyTCAQIBAIcOzYMTRNIxaLEYvFuHPnDvl8nkAgUH6dPoomkEaZvD8uSp9jP/IjP8JXv/pVhoaGuHjx4mO+qqOJEICCQ4Xb7ebatWtbpjlLqKpKPp/f9u/7JZ/Ps7m5SUtLC9evX2+4sfLDxGu1ANvNSLdGCEBN0xgeHiadTvPcc8+xsLDQ8LRyfdrWMIxyivvatWs4nU6y2SyRSIS1tTUmJiZwuVw0NTXR1NREIBAof8mWBGUuV+B3/tvLrGUyBIIuEsksNqfCqbYwNofC2NwGA81B7HaVW8sbeJ12FIeMXZE5195CWteY20gwR4Kne9pYWi5G2U62hIlnc1xtb2cjlcFps/H64r1GEK+H4fWKALvU3l72AGxzeej3eYim0+iqjbnEJgXTZHi5JIosHI5qoWCRMWvrWi25ViSHXU6WcgnanB5Cdhftbg8pvVBs/CgUaHa6eK1qakiby0PMqKSLJSyWUrViqlNxcNesRBT73EFuJWvNl5N6bYfu+UAbN6vEnlNWuZupFYTH79UHlvAoDibrxN6Ap5mRsjl00fh5PlfbZXzK08lUZg4bKg7VgXqvSaTN3ooiycjIuGQ7lmXQ5xi493qQ8SsOMmYWCQkLsCywLJlux2ksLCwLQjYfpz0n2Q02m43W1tZyE1QmkyEajRKLxZidncU0TXRdR5Kkh6aL90KjRsE9Tkrv/+/4ju/gT/7kT/iJn/gJ3vGOd9Da2orX68Xv9yPLMu9+97sJhUIPX1CwZ4QAFBwqJEl6oPiDg4sAWpbF/Pw8U1NT2Gw2Ll++3HDbkofZwBQKBYaHh8lkMrse6bbTub3bkUqleOONN/B4POWJIgcxuq5aAOZyOd544w1kWS57Cmqahtfrxev10tfXh67rxGIxIpEIt27dQtO0coF+KVX/q7//v1lMpWhq8vLqnQWeOdvN8Nwq7WEf8UKe8x0tqA6FG/NFgXamqxndNJlciyLJEnfWi8LoVFsTw8urDIQChF1uovkss9FNZtnkQkcLwxsVodPkc7G8nkKyoCfgw64oXGxqZTGRxCkrfGttjdIzfa6lmdFo5diLbW0MRqpsYVraamoBn25qJWfpXAl1IEtSMeqWjiMbMivJDDm7yWwqTvaeL6AE6HV2K90eH+uxqtq/UDs3E5XonwuZRStTc0zA7mC+yhv6XKCV8SpTZ0WCtXy85piz/vaa2j+vZCdSSNFuD2FXVGySSovdQ8rMIiMDEhJgmHDS1Y9hmeiWSZPdw1Iuik92UzANCqZOpFAgVTKR1jX6nAFubNbWDD7l6+FW1ag6m6TgV1WSRuW+HXN1MJ6pPe6Hu76T/VKfLn711VdxOBwsLy8zPj6Oy+UiHA6XU8b7iQ5alvWmiACWpgD90R/9UTmK+pWvfIV0Ok0mk8EwDNbX13n11Ve5du3atlODBPtHCEDBoeNh5r4HIQB1XWdsbIyNjQ1OnjzJ/Pz8gXzolETaVh9qm5ubDA4Olg2Wdxt53E8EcHV1leHhYfr6+jh58mT52hpdV1ha07Is4vE4N27coLm5mfPnz28rNlVVpaWlhZaWlvKXYDQaZX19nXg8zp/97ThLeYuWZi93V6O85Uw3L04sEHQ78HkcTM/GcLapjMyvM9AUoDPk46XZRQzToq8pwNByUXh1BbyEXE7a3V5mNjYJ9bq4G40DxcaP5WylDu3p9hZUSeGpplbm4pu0uL28slARGM0+N+a93RUJNqvq+GyyzPK9usCw3UWb241btXMl3EGyUGAtnSKeyzNXlS4919zMQroi5k6EQrweqUTUnm5qq7GKaXN5uBmvbEtYbOq1Uz8uNFXmCAOEsTF6TyCqyPhVJx7Fzgl3K3ZZQZEU/KqdtFmgSQ2hmxa6abCZNwjKITJGgbReoC/YUZMOViWZNUeSmFYRZBcDXYxW7SNhkXEFWc5X6gFPeFqZzdWmkT2qozwDGMAjO7ibrY0snvR0MpmZqblNlWvfa07ZwdtCV2gksiwjSRKdnZ00NTWhaRrxeJxoNMrExAS5XK6cLg6Hw/h8vl1/xmQymSe+BrDUKPOrv/qrvPDCC/zyL/9yOcthWRa6rlMoFMqRTiH+Dg4hAAVPHI22gUmlUgwODpYbLXK5HDMzMw1bv5rt/Pp2M0/4QWvvVqxZlsXk5CQzMzM89dRT93kb7jequBWSJLG6usrdu3c5efIkfX19O76/kiSVo4O9vb186nNfYSGho7pUoskU6DpDc8ucbQ+hOFRuzCzjtCn4PHZOy00sxhLEtQKGaSFL4HLZuOhtI5bJEva6eGW2KOJavG5G1yr1eE93tZHXDbo9PpY2E0TSORaTRUHW6fcytFaJ3l1obeFmVbTv6bY2hjdWGfAFCTmd+B12VtJp8rJBLJ3jmC/Ii0sVIXaptY3BKluYk8Ewo7HKes1OFyOxyvlkCTbytXYnW0X/ZjIxul0B3Iodl2JDRqbf9OHxejEk8Ko27qaipLQ8WcsgbMArG7VRs35vgLmqJpNLwQ5uVo2BUySJpboI4flAO6PJyv2TsIjW2dCc9LYzlanvRK59TYRUD5N1Ubzj3raamkG43/qlyeZnum4SydtDV3ApWzdU7YfqJhCbzVb+4QJF8RaLxYhGo8zNzSFJUrnOdafp4jdTE4jD4eD7vu/7akpcJEnCZrMdqJWOoIIQgIInjkbawJQmW/T29nLy5ElkWaZQKBxYk0lJ9JWKxU3T5NatW6ysrOx4nvB27FYAVtf7bZdubnQE0DRNTNNkenp6y/tbio7uhJvjS3x1aBnNJjHQHGbw7jKXTrWzsL5JtpBneiNGt8+J1+PgxnRRUF0YaOPm4irn2poJeZ28MruEbpp0BX0MLVfqz5r9bjy6nZDThWmaDC6soN17HK50t/PaSkWgBd1OFjNFQaPIEgk9z4lACJckUcgXSOTySKbMTHyTiC2LpVgk7/lMulWViUSlLk+RJVayteKIut6fvkCANyJVps7hdlayKc74iiPonIqCbplc8HeQ0XUS+RyJfIHNrMZmtmjufK2lk5dL3oGbGdqdXm5rqbKRNUDA62ElXan/65XdNeJPwiKm14qt8/52RqsEoYRFXEvV7HPG18FEXTewJNU+520O/301gz2uJkZTlcdGBlbytTWNfc4WlvK1xtPtjhCbVdcN8K7mZzkIHmQDU0oXd3V1lbuLo9HoluniYDB434hFwzDI5XJPvA1MSSB/6EMf4i/+4i9ob2+nv78fWZbL/0quBoKDRQhAwaHjUaSATdNkfHycxcVFnn766Rp3/UaMa9uO6ghgLpfjxo0bWJbF9evXH9jpuhN2I9ZSqRQ3btzA5XI9MN38sOdiN2iaxtDQEKZp8vTTT+9L7EZiKf7dZ/9vNAW6OwLcWdjgmTNdvDq5SMDjotnv5ZjNDpLFrbViKrXL6yCXThOyO4gmM0zFYuj3Hi+H04achXOtzYS9LkZW14llc0wT50x7U1n8hdwuxiIVj7ozLWE2czkut7YhWRIuh42XFxfKQuqU38tUPF7e/1RzuGZCyLnWFr61VhE6l1raeH2j6u/hZuYzmwx4Q/hsdtyKim5aXPC3kyoUiOezLKfTLGfSLFEUY1da2nkjWlnjqVBrjRWMS1GZTNbaqHR6fKxWRQwHPEHG07X72Fx2qEqD96k+5rPxmn1SRm3DyBlfGxOZWkFm1tUqdjmDTKZr9+lw+ommKulgFZnZbG1zyklvF1OZ2k5fr2qHKg93u6wyn6+NLJ7zHqfLubdJNg9jpzYw1d3FAwMD5TrXB6WLU6mikG5EDeCnP/1pPvGJT7C8vMz58+f55Cc/ydvfvn1HdD6f51d+5Vf44z/+Y1ZWVuju7uYXfuEX+LEf+7E9X8Pf/u3f8qUvfYmvf/3rXLlyhVAoVI7u2+12PvzhDwsPwANGCEDBE8d+BWA2my3P0t3OZ7A0/qzRv0JLv2yj0Si3b9++b6TbfthpBLBkL9PT08OpU6ceeB8blQKubjCx2+376o7UdJ1f+o9fIZHN0drhIV3QGGgL8trUEt1NfgJ+F8Ozq3gcNhxuGwPNQYIuJ7PxTRY2il+i7UE7ed3ALktc6GwmZ4JqydzdiLGeyxDLFuvlLnS0cHOtkn7tCwdIFQr47Xbyms5mocDiZorFeAqf3Y6lWmXxF3Y6uFslmIoTQipRxpDDyUh0DcmCFrebJocbm6Rwramz2Nmby5PXTJJZnWS2KGIvt7WVO42hKPZuVIm9NpeH4VitUEobtR3z50OtNXOEw3YXI/FaARZw2KGqZPCEt4m7mVpBKNvkGrHVp3qZzdRG5Kw6e5Y+d5ip9CoyMnZJwa6otDsDGBgoKChS8facoTPg6kRCJp/L45PsSA75XvtI8fXqke2cch+n5DOtSDKmpXPMdaJ4bsD3/2fvz6MjS+zyfvhz93tr3xftUkvqbkk9PT0e42k7nKzYGF7iOIudcAIcsBN8hhCMIbw4JMQYfjgHBx8nhHHMEngdCHEgEEwCwUMIJvZ4m26pW0t3q3eptaukUu3bvff9o1TLLfXekqf7Rz3nzDmj6qpbt0qqqqee7/d5HkmlYJVAacUFvSNy/+iXJ8HjBkG377kCjjDqpaUlPvrRj+JyuUgmk+zs7DxRRdpnP/tZPvjBD/LKK6/wtre9jU9/+tO8853vZGFhgYGBgbve5j3veQ8bGxv86q/+KqOjo2xubj7WGk77e2o4HOZ973sfGxsbXLt2jWw2Sz6fp1gsksvl+KEf+qHHfoxdPBy6BLCLZw5PsgO4vb3NhQsXiMfjnDx58q5v1u1j2s4xzJOi8QY4NzfHyZMnDyVcuoEHkTXbtrl+/To3b968677f3XAYI+CtrS0uXLjQJJxf+MIXnohU/tS//WPWUzkkXUaQBDZ28sTiMpN9MZAFZpbWEYBTwwk29nLc2NzlueEEqf1x5nODccqWid+w2MzmmV9PUTLrj/FkIsh8qq486bLETqnIiUgYt6KgSBLnVteaauCZvgRLqRYpGosFOdc2Go57XKTSLfLV7/PhLin4VA1ZFDEUmdvZPTaqebayRQbcAb6y2mbsiEUdrSE9bg8X2pzDkiiwWmyFMwP0eryOoOipQNRRC6dJEjfyTpI25PEznW4ZNPoMH/P7XcMiIm5ZIaga9FtBNFFGFiW8ikrVrvGc5q07kGsmkmUhmBI108QWBXyKxl6xSlgMU7VNKpaJR/RQrWUwbYsCNkFF5vWdNapt+Yln/H1c3HPm/PUoLrb2Wo+rTw86eokBTvv6meu4bNAIsFpuKbZR1c/zvkeLfnlYNL40HsaXOcMw6O3tbY6L/8W/+Bf87u/+Ll//+tc5ceIEY2NjfMu3fAsf+MAHmJiYeKRjf+ITn+B973sf73//+wH45Cc/yR//8R/zqU99io997GMHrv+//tf/4gtf+AI3btxoEs+hoaHHelzt73W/8iu/8ljH6OLw0CWAXTx1eBAhauwAPopC105+GsTrXjgqAtiodLMsi6mpqfuew+PgfgpgrVbj4sWLZLPZR4qXeRIF0LZtbt26xbVr15icnKSnpwd4srHyL/3mF5m/uUHBNOmNBLm+vsvkSJhrm1lKbo3dSonn+uOoqsSXr9bJwFhPmAvL6wxHAkQ8Lha3d0gX9hW+wRgXV+skK+51cWVnl7im4JVlXIbGwk6GVSuHIMBA2N8kfz5N48pOi0j1+jzMbNRJkyKKjIdC2LbJCcODpOnIksj0+gbW/uNOetxslvLU9n/2qup+Awj7zxHsVJyu3ajbxUqpNaZ9Phx3jHrvpv4V7QrY4FFUvLLGiDdIulZiwAggIpJN74El8py3h6plUbZqRHSDQs0kX6tQMmskVDdf2XLu4z0XjDUdwwBDrgBLpdbIFhPGZYnlUsvJHJQ05jOrmHbrb3TYHWamzQ0sCQIrHZ3Dg7KPVTPtuCyoulirtIidLIgsdWQIjriiLJecyuY7oi8iCUfT1NF47R12E4goivyVv/JX8Pl8fO5zn+POnTt84Qtf4POf/zyZTObBB2hDpVLh3Llz/PiP/7jj8re//e289tprd73N5z73OV588UV+7ud+jv/0n/4Tbrebv/k3/yY//dM//UhrK6ZpMjMzw+nTpxEEgWq16nj/bkxHGv9JktSNgDlidAlgF88cGgTtYcctj5qt13jDOUwjSMNprKoqmqYdySL3vQhgPp/n/Pnz6LrO2bNnUVX1Lre+Ox5XATRNk/n5eVKp1IEmlcclgJ//wmX+5MvXMC2bRNyLZdsc7w9wcXkHUYLJeJzaxi4313eRjPqHsE9XCLh0en1ebm2kcelKk/wdT0a4uLqJX9cYCgZQVJHCZo2tfAXBo3BrZ4+aVT/PY34PV3dbZGYkGuT8+jo+VaXH6yXqcRFxudgplljNZqmaFos7DUKU43gs3CR/ABGPi9ViS9EaD4V5fbNF5k53OIH7PV6HGqgIAtlqmRFPAENS0UQRn6aRrVWoWRalmklQ07iS3UayZLKlGiXRomLabJdbat+orHOuzVAS093cLuw2w6MBQprh2PXrd3lZyDiJVUDTWWrjqzHNw83anuM6cUnnWtuOoCKIBwKkT3oTXMo5Hbudr3CfZBwwkZzwJLmUd6p/huT8eFMEmbdH3sRRofF+cVRVcI0eYL/fz7ve9S7e9a53PfIxtre3MU3TsfMMEI/HWV9fv+ttbty4wRe/+EV0Xef3fu/32N7e5uWXX2ZnZ4f/+B//40Pf99bWFv/0n/5TvvSlLwEP7vgtlUr88i//Mh/4wAe6ruAjQpcAdvHModNJez+k02lmZmbw+/0Pna3X+PZ5WEaQjY0NZmdn6e/vZ2xsjC9+8YtH4jK+GwFs3/druJwfBY9D1hrmFoCzZ88e2Pd7nGNeuHSHX/vtr1K2TCqmhT/oYnuvwGqmwGjMTyDg4auL9aiRiZEYxUqVvoAPSRH52vU6oZjoizK3WiccPQEvAZfGaDDIre00hOD1pRYRCvgM1jfrRMmjKqyXy2iiQFhR8MkyuWyOmKKzXSgheOD/3m6Rj8l4hLm2wOh6CHRL3RsOBBy7gGHDYDbV+tmQRGqWyUQggi7JSAjoioxP0clXK+yVy4wEAg6zSNxwc2Fn00HcxoJBdsstVnYq5FQMPbLCHcupMg54fWy1jZDjuoe5PaeqGDXcrJZb5C6muR1jZoA+l4/tvZY6ZUgKazgdw/2Ch1sdJLHQsa+Y1PzcaesKBhjxRJjN3nZc1mk+CSkerneQxLeFJvEpR+egNU0TQRCOlAB6PJ5D7eRu4H5Km2VZCILAb/7mbza/yH3iE5/g7/7dv8sv/uIvPrQKuLu7y5e//GV+/ud/Hk3T8Hq9eDweXC4XHo8Ht9uN2+1G13UikQiLi4v85E/+JO9///u7BPCI0CWAXTxzaMQE1Gq1e6pZtm2ztLTE4uIio6OjDA0NPdIb52E4jdsr3dp37o7KZdxOAG3b5saNG9y4ceOR6uTudsxHIWt7e3ucP3+ecDjM5OTkXQn6/Qjg3X5HO7s5Pv6L/5tstYot2mg+hUu3N3nueA/WpkmpUuP1m6vIosDzx5JsZPIsbe9xLBni2mp9nOhWFWwRXuhPsJHOE/e5+eqNOjH0aCq32py6kz0xZjc3SXrdxN0ePLrC7XSGlVKWtWoFI2JwfV8NFIBUvkWYJBEH6QLImhXHzy5VZtDrw6fqaKKEW1PYKRbJVSvsFIuMhkKc22wbr/r93NpKN7wOKKLI7ZyTOPV4vaynWudxMhjhcqZFQiVBYKXgHBce94c5v9siSQFVZy7tHKP2ub1strmDI5qL+T2nUtTv9rOdbt23R1K5knMSwglfzBEOLWBT0XEYTeLo3C46jSYJ3cN2GwGUBIE7pZTjOkNGlOWS8/76jSALHc/Rt0W/iaPE4xpAHhaHUQMXiUSQJOmA2re5uXlAFWwgmUzS29vrUPFPnjyJbdvcuXOHsbGH26k0DIMzZ87wB3/wB5RKJarVKqZpNv9rj4CSZZm9vT1isdiREeouugSwi6cQDyJqDYXuXgStsWvX6JZ9nD7JJyWAlUqFCxcuUCqVOHv2rCO89TA6e++Gxri2VqsxOztLJpPhLW95Cz6f74mP+TBYXV1lfn7+gYT7URRA0zT5V//mj8ibNUTBpiaBJIs8P9rL1xdXUBWBQMDgdH+cVLbAlbUUmWIZVRbJVir0BLzEfG4ESeDc7br61R/2cWGlRRhGkiEu3FmnP+Aj6nFRwyas6Gzs5lGRmN3YbDp7J5NR5tpcwad6YsxstkjTkEvnWjaLLolENIOgLKHpbsKKQb5SwatrnNtofPhm6fF62Nhq5e9pksTNTNrxHLhVhfZn67lozKH+JVweLu44CZDZEbXyXDjO9E7rQ18XJa7lnERq1B/i3E5r/BpQ9KYZpIFhj5/z+2SvXrmmsVrMEFM9SIKILEj0uX1sl3OIgogoCIg2iILEhKe3vt+FgFtSKVoVwh4/DVevR1YIlwvUalWq1RqWaZJOF0naIRRFwdB1vKpGwSwRVVoRQj5ZQRdaKpSIQNWEY/rI/iUCCd3HuOdwd2478bARMI+LwwiBVlWVN73pTbz66qu8+93vbl7+6quv3nOk/La3vY3f/u3fJpfLNe9/cXERURQfaY+5p6eHz3zmM9i2TblcplwuU6lUmv/f/l+lUiGTyRCJRLrq3xGiSwC7eCZxL4KWzWaZmZlB0zTe+ta3ommPl/b/JARwb2+P6enp5ti500hyVARQFEXK5TJf+cpXUFX1kff97nXMB5E127ZZXFxkeXmZ559/vhllcS88igL40X/zv1heT1MVbRRNRK6YJCI+Xr+6gtfQ6I8YXN/KsrGzzvHhKLdXMngNlamBOCvpLLe30rhUhavbO/vHB1mRMC2bmNfNYMhPoVbDr2rcSWWIel1cvNPmmtVkzGz9XBVJZKvQ2p9zKTLbpSLjoRAeRUUWBfZKRUJli3S5wmalQFYVybSNQgfCLRUFIOI2WC20FLapaMyxC3gsGGCurVVEkyRuZdOOYyQ9HtZSrWOcDIa5nGkpaSIC6XKZmO5GF2U0USLp9pAuF8nXsgQCQWRBBMvmjL8Py7YxLYugrrFWzFGzTCqWhSwI3NjLIJsaFdOkiM2kN+yIlJFFgUy1yk6lrfYtkOAr260mEICT3ihXci3iHNM87NacQdRn/EkuNkKly/X/+hUXa1ZLbQwpLvJmwTH6nvL1MrvnvL93xP4/HDW+EQrgYewOf+hDH+K7vuu7ePHFFzl79iy/9Eu/xNLSEh/4wAcA+PCHP8zKygqf+cxnAPjO7/xOfvqnf5rv/d7v5ad+6qfY3t7mn/2zf8b3fd/3PZIJRFVVJicnn/j8uzg8dAlgF88k7hYF01CghoaGGB0dfaJdmcclaY1Kt2PHjjE8PHzXcziKLmOoh7Vub28zMDDA+Pj4oagRD1IAG20ihUKBs2fPPtQH1MMqgP/+V/6MC1dXqCoCMgKFYhXZo5Iulzk9lKBmW8wu10nE5HCMkmky1RujXK3xlWt3sGwbRRbJVivYgCqJnBlKUq6ZJDwetvZy6KrM7Z36qLDH72G2rQ1kqjfGxY36z5Ig8GJ/D/lqlT6vl0Klis/Q+Oqd1gj1hb4Ei/vdwQDjoQDz6db4cshtcGOvNZYc8vuZbdsFdMsyi2mnKqe0EQrBhtPRGCv5LGO+EJokY0gSIPDmUC+WbVOzLHRRYkgLUTSrFKpVjgWCDvVPlURS5SI75f29ua01Xoz28Pp267G4JQUxb5OrtcbXL0Z6ONf2+FRR5HqHingqkOBC2rl7l+vYMxw0Ag7yB9Dv8rO91yKxkgBr5b0Dt1upOB3CUXT2bGfTSMF03p9fNvgrkUeLSnkcPMxO8pPgsGrg3vve95JKpfjoRz/K2toaU1NT/OEf/iGDg4NAvR1paakVw+PxeHj11Vf5wR/8QV588UXC4TDvec97+Jmf+ZlHvu+Hed13Xb/fOHQJYBdPHR7mDaC9Ds6yLC5fvsza2tpDKVAPg0claZZlsbCwwMbGxgMr3Q5bAbRtm5s3b7K1tUUoFOLEiROHduz7kbWGu9gwDF566aWHHtU8iAAKgsAfvjrH/3ltkZJo40UkI9mYgsTJwQjXN9MUChUsGQxFYjDqZStTYD2dQ5FFwiF303H73FCCSs0iqOvs5IvM3tmkUKnXoT0/lOD8nRYx8rg1VvI5JEGgL+DDpSq8kIiTLpYpVCrMrKxTrNa/dMQ9bkfDR9TtcgRG+zSNm221ZbIokOvg43atTkxdkkxQ1xkOhMhWy3U1jrrCuFUqMuQKkK2UKddMrqbSjh3DM/E4022K4fFgyDEOFgQcrl+AU6GYwwyiiRLXsk5idTIYcYyDNVHiRgfZmwrGmW4je/WOX6fRY9wb5lre6fQNaQbLbZExhiiz2EEI625gJ5EMaAYrbeuUsiCybjr3Gntk34E9wm+NP48qHv1HnWVZRz4CPqz0gJdffpmXX375rv/267/+6wcuO3HiBK+++uoT32+X3D1d6BLALp5JNAhao9XDtm3Onj37xEvSncd/GLSfw8NUuh0mAWzsO6bTaXp7ew/lmO241wh4e3ubmZmZh2oT6cSDCODc/Aq/+d9eB01Gt0z2SmU0WUY2TS4u1YnCmZO9VGsWl5c3KdRqrO/vpU0MxVhO7fH8QAJJEJi+uYa5H+UyMRhlfaVOUEIencubdUITdhuMxkJULJPRUJDl3Qxht8HXbrYI0Kn+OOtrLWIV9blZ32iRnWTAw+Z6W7xKJMC59XUUQSDm9jAU9JOv1Rj0BjAtG00UuZVJo5sSxaqJUC3yen6FUtvfxVgkyOJui5i9KZHg9TZzSMLlZjbl3NHr/DWcCse40JYNeDczyFQoxrk2QqiIIjdzTkI4FYw5DCMCsFF2dhZP+ONcyjrPR5OdilhQ0VnocAyf9MeZ6RjZlm2ncSYgaVzJOSvdTnqTLHQEPxsdxckCAt8amuIbgW+EAvis9wC3oz03sfF+0CWI31h0CWAXzyQkSWJ3d5dLly6RSCQ4efLkoX77flgCmEqluHDhArFY7J7NIp0QRfFQRsCFQoHz58+jqipvfetbWV5eJp/PP/iGj4DOEbBt29y+fZurV68yMTHxWKTzfgRw+c4OP/fv/4RMqUJNETBsG0WSKJkmll9hMB4gEfHy1cUVLNtmtMfH4lYGn6Ex2hNiN19iJ1NkN1ukN+Zvkr+TvRHmV/YjYPwehmJBMqUy63s5soUy17d22c7XCVzC52FuraVaDUcCXGwjf2PRELP7o2HBrhO1YqXGmXgcURBQRJGtQhG/qJKpVEnnSsxXq6RLrYiTkUiA9bZ9wtFwmAup1n0OGIaD/OmSxLU9ZxxKj9fD+nZblmAgxGXHCNkmXXWOQ09HYo5xsAgsFZyj1uc6yJ4ocKBxZCoYZ64jC9DC+aWmRz+YFzjiCTOdbpE9EVgvOe9/yBXiRkcP8YARYKHoJIC5mlPZ9MsGd2zneZ4QIix+fZZVj4dwOEwoFMLv9x+JUveNMIEcxZe8bzQakTPtz1WX+L0x6BLALp46POjNwLZtisUiqVSKU6dONRsmDhMPImntLRcnTpygv7//oY99GDEwjUq7np4ejh8/jiiKR2Iuaf92blkW8/PzbG9v8+Y3v5lAIPBYx7wXASwUyvzkx/6AimlRlQWUQoWMT0UQRIR8lYTHT7lcY/rmOpZtE/W7sAUYCXlZSxfYyOS5k6oTgOeGE0wv1clH1GPgMVROJWPcSWXw6TpfutZSjs4MJzi/3CIqQa/OWlu0C5KAKkkkvR78mopL19AlmUypzGY2Dwhc3WyRtVM9Ma7vtMjayUSU19da5GUqHmG2LScw7DK4nO7o0O3o2R1yubmUb5GbhMvNxQ71T5Kcr5upcIzZtlgXAditlPArGpokIdkiPtPGlDXCPhcSAiICmijzfKAHUQDBFvCoCnmzSq8eAAFsu05Iz/j6sKm/FlyyQsGsMOXp2b8MQrpOoOKm8auWBIFCxWLUqMch2dRjZVKVPCO6G0HYv0w1kFEAAUGAYjZHoSowrPXVm4AF8CsaeavMmMu93w4sEFA1srU64a27jeF7B9/KpKun2as7Pz+PaZoEg0FCoRDhcPiRjAz3wzfCBHIYO4BvJBpj8lQqxf/5P/+HlZUVRFFkYGCAiYmJh46U6eJw0CWAXTxTKJfLXLx4kXK5TF9f35GQP7g/SWvErOzt7T0WEXoSotZOPDsVuCepWLsXGgpguVxmenq6OWrvDHd+1GN2nqdt2/yrn/l9dtJ5TFVEKlSp+jXEYgVDlckGdDZyRXp7A/glONETJl+rcnU/5++50STT+zEvMb+bqmlxpj/B5l6OWNDD16/VFS1FFtkttVSxZMDD7GqLJJ1IhMkWK5xKxlAEEZcqs5japVY2WSrv8VxfnK/cailYk4kos1ttamEo0FQHATyyxHzbv4sC7FacYccDAT/nN1oEdCoaZbat9cMjSezVqsQUFckCXZaJaDpx3UDZd5gbikyuWuWUP07NsqhYFoIlkpC9lMwaJbPGyVCYmSZprCIAZVUmtdtS0p4Px3lt3dnEMez3czOXbv487gvzesqp0D0fjnNht/UY/IrG1VyNstUyar0QSjKddqp4J3xhFnOtY4VUgxv5bYerd0Rwc6ljj/D5YIK5TOtYoiAQ1nRSbTuIA0aI5/2DCIJAIpEgkUhg2za5XI5UKsXm5iZXr15F1/WmOhgIBB67/vFZiIF5I2HbNqIo8sUvfpGf+Imf4Ny5c2iahm3bFAoFenp6+Imf+Am+93u/F1EUqVaryLLcVQePEF0C2MUzg93dXWZmZggGgyQSiUPt6e3EvUbAuVyO6enpZszM48SsiKJ4wMH8MGjf9+usV2sc97AVwAYB/PKXv0woFLpnuPOjHrOTAH7s5/4n8zc20V0KhXIVCwu9bFK2bLJ6PaLkhYle9gpllnd3SYa9TfIXC+jc3k7z3EAcs2ZRxWJhf1dwIOrn4lJLKZsciDXVPlUSGQj7idXcYEO2WCZTrLCaznInlUGXJVwulVSh7pbVZIk7bd2rkiiwXXI2UMiy6MjsS3oMFrMtNfG5RIzbe3sM+nwYsopbkRFsgTfHkliWTc00EREZNPzkq1VylQonozFe32iRnaggMb2z44hMGfX7uZptjVInIhFHuwjY7HZ0C08Ew8xlnESuc2Q8EYywkHGSL1Vykpy47mYu7VQjx/3OeBgBm82OncEhd8BB/gCGPSHOp537gHmcr5WwanA56xwtT3jjLHSYRv5275kD5EEQBLxeL16vl6GhIWq1Gru7u+zs7HD16lVKpRJ+v79JCB+leeNZiYF5I9AY+167do0f/uEfRhAEfuEXfqG5NrO+vs5/+S//he///u9vvrf+zu/8Dt/2bd/G1NQ3ZofzLyK6BLCLpw53qylq7J2Nj48zMDDA4uLikUSpNCBJEtVq1XHZ+vo6s7OzDAwMPFatWvuxK5XKg6/YhkKhwPT0NLIsc/bs2bvmGx4FAdze3sa2bQYHBx+5TeVe6CSAv/If/5zXpm8hKyLpUgXdMim4FQqmBV4VZbeM26tx/upqvQc45OHSyhYBt07co1K2bbZSOeYyRaaG48wv1wmLKIItCk2iNBwLYNs2Z3oTpPNFvC6Nr15vkZQzQwmut42CT/ZFHS7hiZ4o51daP5/qjXN+te3nZJRMpcJkNIImSbBP4CaDEQqVKoVqhbV0jnS+TDpXVwGf64lxYa11jOcSMWY2WmTKrShc3nW6b3sDfjY3W8Szz+V2kD+AYtX59zUVjjG363TaZmrO60wGoyzsOcmeJTiJer/bx3xHW0i/x8dmW32cKopczzvPeSIQO2D+CGoGS8XWqFwRxQO7f2OeCNc71L9hT4iZPaf5o2w7X6uGpPDO+IOJgyzLRKPRZnJAoVBojotv3bqFJEmEQqHmf/f7wnfUCmChUHhgj/nTigYB/MVf/EUikQi//Mu/fCBE+ju+4zsYGxvjlVde4Qd/8Af5+3//7z9S0HQXj44uAeziqca9xq2yLFMul+9/4yeAJEmU9keFlmVx9epVlpaWHJVuj4tHJWqpVIqZmRmSySQnTpy454fMYRLA9ho74NDIHzgJ4J/87zn+56uzKIpEqVZDKZXJBzSwQCrUQJOpuhXKuohpWeiKxEAyiCdT5PrqDjGfxs2NuioX8Ojc2KoTClGAN430UjFNPD1RVlIZFEniwq06CdFliWytRRqCboNL6y3yEfW6HEaQsNtgZS/LsVAQt6qgyRI1y2YiFCZTKrNTKLKbL7HSlmU3HglwdS8H1MnRmb4E59vIXp/fy2xbi4goQKpDUTwRDfN623g44XYzu+UkUn63i+VSa/Q55HJxs6MGrdBB9iZCEeY7yJ7ZYeIY8QW4vOckZBHdxXKbacQjq1zqOM5UMMZMx6jXtJ3HDqkGCx2VcpP+OBf2nCqeITk/omRB5FahwyDiChwgie+IT+KWHz0E3uVy4XK56Ovrw7Is9vb2SKVSLC0tsbCwgNfrbaqDPp/P8Vo0TfOxg+cfBrlc7tBSDt4ofPGLX+T7vu/7ms8vtN4PRFHkR37kR/jMZz7D29/+dv71v/7XB6YcXRwuugSwi6cSgiCQyWSYnp7GMIwD49ajClNuoEGm7lfp9qTHfhDa9/1Onjz5wG/Dh0UAa7UaFy5cIJ/P86Y3vYmvfe1r9y2Lf1Q03vAvLazyq/+/L1HFopYrU5UF8GnI6TIun85euL6cL+YqSLrIUNiF7tL46qX6iLAn4uP6VmskO9obplIzKVdqZIpl5pY3KFbq48PJgRizK227fv1Rh/GjL+zl4somXk0l7nGTCHnIV6pUqyaZUoWgR2dmZYNN6kTrzECC6TY18HRfnJk2p/BwyO8IhTZkmRu7ThdvwKWznGud/6mEs1bOq6pc2nEqaQmPm7ViS20b9geYSznJj27oUG4RwkHN4EZHe0i1oypuzB/iyp7zvjyqCrn6fp2AQEjTWNzbRhPrY04BmAhEuJheb14G9TGyIohNM0i/y8uVzFaj8Q2AkbuMenerTldvRHNzKXuQJM5nnTuKIdXFnZLTRPO3e17gSSGKIsFgsFklWS6Xm+rg7OwslmU51MGjzAFs7Mk9qwpgA4VCwbEz3Xi+GqsmXq+XcrnMD/3QD+H3+w/1faeLg+gSwC6eSty5c4eFhQWGh4c5duzYgTeBoyaADQXwtddeu2el25Mc+0Hnbpomc3Nz7OzsPLTR5DAIYCNaRtM0zp4963AAH+aH28ZGln/3i58nU6pQxaSqy0j5MqImU1NE9hQQqiZ6xaaoSeQscJuwtF5XnwQBRNGkL+BCFkW8Xg9fX2wRgxOD0aYa59YUVtItZS4Z9HBje5exaAiPpuJSZbZyBUKqTjpfQvR6+OLV1ohxOBJwdAfHvG7m1lukS5cllvac8SOKIjt2AU8mIpxrU/+GQwGH+ieJsNEWCyMgcDIa5vpemoCqo0kibkXFNG2eD8fqHbuIuHWVsL7vYrXrwdjZapXTgTiWbWPZNm5NQSkaVGpVqrUabgG2d3KEBI2aZSHKMm5BxWWr9Ro42yLucjO3uY1ti02q2B8IOjqIZVHgWjpNqdx6pJPBKPMdo2af141ZzSBQJ5OaKHN9bw/F1BAFAUkQGfEEuVPMEBT8SPuXDel+Vuw9SsUiXrcbSRARLJlRowcRAUEQ0EQJ07SYcA82HcIDrgAj7nsHsT8uNE0jmUySTCaxbZtsNsvOzg7r6+vNbtxyuYzX6yUQCBz6PuCzvAPYwNTUFK+++ir/4B/8gwPvJ6Io8vWvfx1N05rKX5f8HS26BLCLpw6WZT2w1eNuVXCHib29PdLpNMePHz/U8Sc8mKgVi0Wmp6cRRfGR+oyf1AXcGDW3R8s0nuPDdBdXKjX+w384R7FWBcHEqph4RJFcwMA0LSRRQE6XMXWZoiFiKSKCICDrKkFBoDfkRZYFpm9tYFo2qiyg5Fqj05P9URZWthw/58oVhsJ+ylUTW4S1lRyZbBlBgP6on9upFrEsWU5yLsqCg8zF/G421loK20RPjHMrLWJ0Ihbh0tY2AuCWJcIeN6VajaloFEUUEQUBQ1UIahqmZVM1TYIug1t7e0RkF4VaFUWUmFvbotD2N/58Mu7YDxzy+zm36VTITkbDLLQ5dMeCQb627hyZTkQi7Lb1C0dMgYupDedjdHlYbuso9sgKl9PO4zwXijO90zHq7RgjhzWjaRCxAdO2OREIM73beTubVFtjiSZK5MwimVp9zWMjV+aYJ+QwlgC8KdTryCwE+Ht9T67+PQiCIODz+fD5fE0zyfnz5wG4cuUKlUrFYSZxu91P/B6Sz+efWQWwQfZ++Id/mG//9m/nx3/8x/m+7/s+enp6kGWZYrHI1tYWL7/8Mn/pL/0lBgYG3uAz/ouBLgHs4qmDKIp80zd9031JUnsV3GHCNE0uXbrE+vo6breb4eHhQ7+P+2UMNkjY44RbP64CaNs2S0tLLC4uHhg1Nz60DosA2rbNL3/6PFt7JaxaFVmTkQSRnCqg1SyqpQrVgA6CgFAoYyoyYqnG2FCUgmWR2s2jiALbhVIz5Lkv6uHaVp2saBIUClnGIz5sRGRZZvpGWxtIf4z5tlHwcwMJZtqMHqcGEsy0jXanemPMrreuPxIJsLSzx0DAh1tVMCQJEYEXkglqpkW5WkOw6zEo2VKZvGkyHnU5zCLjkZDjZ1kU8HsMtvItAnSyN8K59RZJSno8DsUQwKOrjfXC+rkFAg7yB6B0NHEM+fws7DhHxr3hENttmYIeUeRiykksT4Qijq5gAZvtsjN0fNjrP7AzOOIL8nrKSdo6q+mSuoeFPedjmwzEmE47b+dVnAYMAbhTTDsui2se/krsGN9oyLKMJEn09PQQj8ebOaU7OzvcuHEDRVEc4+KHrU1soFqtUqlUnukYGICXXnqJD3/4w/zMz/wMv//7v8/p06fxer1sbW3xJ3/yJ/T09PBTP/VTzyzRfdbQJYBdPJM4ihFwQ3kTBIGTJ09y69atQz1+A3fLGGx3Oj9qsHQDj0MAGx3Gm5ubvPjii819pwYaBPCwzCU/9ZO/x1q6iIhFVVOo2ha6S8HMVVA8GsXg/t5fpoSkSAiZKpYAi1tprP19INVQqGTq5KM/7MYybZ4fSJDOFfF7dS7c3gDqBp6IT2mSP02WWMu0qVqayo3t1l6eW1W4k96jx+fBp+sYqowii5xOxChVamRLFSREsvky2XxdmTo9EOf12y1idKo3xsU2wuhXFeY27u+sPZWMc269RbgCusbCtvM2ca+btUKL7Q34fcx1XMdQnG/nQ/4A8x2E0KdrDtIYkBTmd5zkazQUYbrtMgm41qH+TQRjB0ibX9OhjRPqosRiR8zMRCDKpYzzdr1uH+uVnOOy7Y6fQ6pxwEVc3wd0EtW/3fccknB0Ttz7oREDIwhC00zS39+PZVmk0+mms3h+fh6fz9cMovZ6vQ/8opfL1Z+PZ50AAvzoj/4ox44d43d+53e4du0a+XweTdP4x//4H/Mv/+W/PPAe1MXRoUsAu3gmcdgEsKG8xeNxJiYm2N3dPfRIlQY6iZppmszPz5NKpZ6oYeNRCWAj3NmyLN761rfeNdz5MBXAT/3Cn3BubgkqNUouBUUUqBRNCoaCoAjkFBspW8Wrq+x6VExZxLZsME2s/fs/PZ6kWKny/GCcnb08mUKJdLEGmzkGY35ml9rUvZE4F9oyABM+hZt7RRRRIOZ1MRgLUaxWMS2bQrmK36Nz7tYqNrBOjjNDCb5+s0XuJnujjt2/pN/DxbXW/cmSwHrOqYpF3dq+E7iOiXiEha0WKVIlkZt7TsfuSDjgIIR3U//8ho7dZiAZ9PkPmEG8mgpt0Xu9Hg9zKedxYrpKutRyCLskmWsdhpGTgRBzGadBpNSRFxjVXQdiZiZDMc7vOMezQgf5dUsKlzpyBk/4IlzJOY814glyvkMR7Bw3K4LE3+p94zLj7hUDI4piU/kbHR1tmklSqRR37tSNMMFgsDkuvtvrsFHx+KzvADbw7ne/m3e/+91Uq1VM03yiYPkuHh9dAtjFU4kH7cvIsnwoO4C2bXPz5k2uX7/uGH8epcmknai17/s9acPGoxDATCbD+fPnCQQCnDp16p4L64IgHOgDfhz8t//6VT7/p3OYpoVgyIi5CrJXo+TTwbQRyjVkRaJiyJQl6q4IQMpXMHWR5wbjSLLIpVublPadvQNRo07+qGf+1QS7SRT9bo3l1B5DET9eQ8OlKqSLJaIV2MmVqJYrfOXqcpNCJPxubu6km3twfpfGlY0W6ZElge2CM6Il6DFYybXI3akeZy5g3G1wfc+pZOU7siUnkzGHOSSgadxIpwloOqokIosiQ8EAhiIjiyKiIOJSJKqWxelwDAQBUQCfphHWjbrRVqhn6tVsizdHks1jezSFpMvbNOOatSrFcokXQ/U2HUGoO3+zbRmCNja6IvPmkI6NjWmaCJZJoVLmmOBCFEVkRSbocpOnPrazsLEsGwWRE94oFnVjiS4p5ColkroP0zapWhaj/iCzuxsItoC9Tw7ljko7EbiZd7p8ew0fl7NOkvg34mOEtTeOIJmm+VDGj7uZSVKpFGtra1y5cgWXy9UkjA0zST6fx+VyHYqx5JVXXuHjH/84a2trTE5O8slPfpJv/uZvfuDtvvSlL/GX//JfZmpqipmZmSc+DwBFUR55HN7F4aFLALt4JtEgaE8SE9CeMdjZrHGUBLBx7J2dHWZmZojFYkxMTDyxy/ZhiVoj0PrYsWMMDw8/8Plr7wN+HPzZn87xG//5yxRtoFDBVgxsRSAv2Gi5ClXborY/+pVyZQp+DTFXxaMqZDUJNJm5mxuM9Ieb5C/sUVjea+VAPj/aQ65U4cxQkmrNRFZELt7eYDdTV6pGe0NcXW+RCJ/fy2ZbdIho16i1PXeD0QAX7rTUw6m+ONNtu4Ij0WBTDRRsCBga6VKZ4UAATZZQJAlNsAkoMh63G5u6GzldKjMRiVA1LQRgJ1skqhiUayblWo1jgaAjKzDu9fC126uO1o9TySizmy3VrN/n48K608RxOhFnZrN1/lGXwU615HiMz4XCXM7lYJ/EyqKAT9ccWYRT4egBo8npWIwrhRY51isiNwtZim1Zf5OBCF/ZcBo9XogmuNU2gheA2+QolG1AQBYk+tw+lvZyhEQfsiAiAT7TwpJ0orIfSRSRBIGgphNVfQgICIKNDby3/wxvJB6nCaTdTDI8PEy1Wm02k1y+fJlqtcqv/uqvEo/HiUSe3Nn82c9+lg9+8IO88sorvO1tb+PTn/4073znO1lYWLiv8WJvb4/v/u7v5q//9b/OxsbGPa/XxbOFLgHs4plE4432ceuXGpVuuq7ftdLtKAmgIAjUajXOnTvH8ePHD83x9iAF0LZtrl27xu3btzl9+jSxWOyhz/dxCeD516/w7z75KhXALYtkgi7scg1DlSnYYCsiNVddARCyZbBtVBMqqkRJFbDE+lvUqbEEF27UiYgoQG8iTK8gUquZVGomC7c2KVXr5HC0N8xcm9FjYiDKvMMVHGF+tTWGPdET5lKb2hdxKVxZ2yRiqHg0DY+hIQsiL/Qm6nVtloUsi/S5veTKFfLlCiOhEOfvtAjPcDjAXDpd/2EniyhAPOBhNdNSBF/oS7DYZjgJuXTmNp3j0ITXzXq+dZten5e5Led1Qh15ggmPh9mtjrYOv5/NzZb5wiXLXO9oDzkViXF+20n2KrbzNRA33Mx17AxORuIOgwjAXt5Z++ZT1AMNIlPBGLNtFXI12yKiG9zeceYlJmWN9bZdQrekgAgFs6WmnvRFmQo8WUD7k+IwmkAURSEWixGLxbBtm3w+z2uvvcbnP/957ty5w9DQEO94xzt4xzvewbd+67c+8k7gJz7xCd73vvfx/ve/H4BPfvKT/PEf/zGf+tSn+NjHPnbP233/938/3/md34kkSfz3//7fn+QhdvEU4Y3Zlu2iiwfgYUbAwGONgdfX1/nyl79MPB7nxRdfvGu9U0P1Ouw9QNM0uX79OpZl8eKLLx5q3EHjw+duZK1WqzE9Pc3a2hpvectbHpr8wcMri52YvXiJn/vZP0KUJaiaZC0Lj2UjYFNQJLBsbF1CTpeRc1XQJMyATlUEqVilvP/uFPEbVGomx6Iekj6dUyNJLlzf4MK1NeZvbSLKYpP8yZJArm2EaSgy63utvTxdkdjNl+kL+jiRCHO6L4ZHUzmVjDIWDpF0ewh7fZTLNqlshdvbWfLZHK/fXGX69joXluuEZebOBqt7WTKlMj5D41KH0UNVnV9KTvXEHeTPrSgsbjvHmoOhAJW2Lx0Jr4fZDSdpCnuM5pgboMfrYbaDECa9Hodi6Ne0A7t/E5EI+bbXjiDARsm5v3gsEGQx7TzHPp/XcWxJEFjOO4nksC/Aiuls6YkhUe74QlXtIJcuSeZyxz7gsMvHuuXcNzwRiDrIH8B7h57jjUTjveIws/8EQcDj8fDP//k/58d+7McYHx/nV37lV/D5fHzkIx/hxo0bj3S8SqXCuXPnePvb3+64/O1vfzuvvfbaPW/3a7/2a1y/fp1/9a/+1WM9ji6eXnQVwC6eSTR20x5FpWtUui0vL/Pcc88Rj8fved12hfGwApBLpVLTdAE8ttnjXmicZ+cHUXu480svvXTfPtN7HfdRFEDLsrhwYZaf++n/Q9UWyFVqeFwq1aqJpQhYbhXNtKmUqtQ0Gduro5omVb1+znK5himLRCQRxa0iaxKXb9aJQSzo4dJyiyRMDseYW26Rm8mRBNM31/AZGlGfi0TIS6FcpcfvJVeqEPYbvH6jpVY9N5Tg9RttGX49YS6tt9TAuN/NnbbdP0GAlY5Gj8GIn+m2cfF4PMzlTef+4GrOqYgdj0cc2YERl3FA/Yt73ay1qX89voNmkJjHzWrbdSIu44D6NxoO8nrbOFYRDhpPpsJRLnYoe+6O3SyvorKw21H7Fo4ys+McCQZU5x6rLArsSBbt5SMxST0QGTMRjHKuwzTilp3nIAAbJedepV/R+daecd5INF7TR9UE0sgAfPvb387b3/52fv7nf/6Rj7G9vY1pmgfe9+LxOOvr63e9zdWrV/nxH/9x/u///b+HFoTfxdOD7m+0i2cSgiA80pi2UqkwMzNDpVLhpZdeeuDopEGgTNM8lDe+3d1dpqeniUajjI2N8Wd/9meHrhjcjQDeLdz5UfEoCmC1WmV6eppf+fevU7XrI1pqNbK2hF2tUcZCrACSiBWo7/0JhQplr4K0V0ao2dh+FUuVSFUsjsU0rq63yIqqCZSz9d+5W1fIFMuM94RxaSqKJLKTKxJQNTLZMj5V5atX7lAz6+ceD3i4uNQalfoMjWubLYVLEgXSJadyFfYaDmfvc/1xZtpaQQKq7GgJAah0BEl3mkN8usalTSf56Qv52VlfR5NEJEEk7HaxlN4jpBuIQv130O/3YmIhCAIidYKWKhTp9bQy0wYDfm7tpYF68LKEQKpYIK67sAQby67nBS7u7uCWJGqWhS0IlCynkt7r8TDXkRd4PBQ+MOrNdnQMR3TjgBt4KhhjZtdJMOIeL5uZ1nMtYLOccxLrsKpzpcP8ccIf5XLWeV5/q38CXXpjP8oar4/Dbv9oIJ/PH1oETOd05V571KZp8p3f+Z381E/9FOPjbyzB7uJo0CWAXTyVeBhjx8O2gaTTaWZmZggEArzwwgsPRegeR2G8G2zbZnl5mStXrnD8+HH6+/ubxzxKAgiwtLTElStXHjtXsP24D6MA5vN5zp8/zx/89lX2sjUK6QKKR8M2VMRsCduvUZNEhHKNki5DzcItChRsG8ESsN0acrVGaX98GvBo3N5uEbaTQ2GK5SojYYNyxcTldpLD48NRrq+1CIPLpVJrq4AL+Q3W21y7Q4kgM7fbQqAH40wvtdW1xYLMr9WJmmCDz1BJF0v0B7zosowiSQRdOrv5ArValVq1hiYLmDWLyVCQWs3EtCwq5Rpj/iA1y6JmWvQGvVzd3kWRBGqWRdCls7CyiW1BFYsqFpGQwZ2dtr0+r4dzS+uO8evzvXGutvUPB3SN87k1x6j1hZ6EI1JGEGCFHJl8i7gdDwW5srWDSN1gIYsivYaPfKmGLIpIooguSWSKFUaMEJJYr2oLGwaZaonn/Yl6X7Ag4Nc0stUyda2ubs4wJInTgUSzZs4GilaNHsNLxTIpmTV6VYPFUtrx99RneLiYdTqvJbHTISzwnsE3LvqlgcZr+igVwCeNgIlEIkiSdEDt29zcvOs0JJvN8vrrrzM9Pc0/+Sf/BKi/t9i2jSzLfP7zn+ev/bW/9kTn1MUbiy4B7OKZxcO0gSwvL3P58mVGR0cfqdJNEIT7NnY8DNpDlt/0pjcRCoWA1oeEaZqHGoHQeGy1Wo1r166xsbFx13DnxznugxTAnZ0dpqenOf/lXW7dylIyLURNplyqoLh1qrqEJYnYloVUsyBXxnKpWIDlrVfd6ZZN3l1/PlRZJOyT6dF9mBbkimWWN7PkinXiMpjwc229RZD6Iy4ut4+Gh+LMLrfI0Ym+iKMebiDiZz2d41g0iK7KaJKMJAq80J/EtCyqpoUqi/S4POTKFQrlKsfCQabbjjkY8XNpraXkiQJEfW7Ws63zGvEbLLRVsQVdOjOrG5Rrrb+rca/bESeT8Hoc7SMAcZ8zCDrqMg4ETB8LBzm31hr1apLIjYYRZR+nYjEudIyIJalFWkzbxqcoXNzadBDJM/EE57ecxGEqGnFkD+qShCJLjhiZ48EQ57acGYIvxpJ8fdupgAq6hlhV0CUJVRTREEllCiQsF7Ig4NJ1fJqOZQu84K9HNdnYDPuC9Lr8vNForIocVXftYSiAqqrypje9iVdffZV3v/vdzctfffVV3vWudx24vs/nY3Z21nHZK6+8wp/+6Z/yO7/zO0fSktTFNxZdAtjFM4v7jYAblW6bm5u88MILhMPhxzr+45pAGvt+tm1z9uxZDMNo/lvjg+KwDSaND58LFy7c9X6f5Lj3UwDv3LnDpUuX2FgWOPe1VXIVE7tSQfYZ2CioikDFFvFZkCtUqfnrO2JCrkwhUP9/SYCRiSSiILC5nUZTBa6v5WlUS5wcjbG8r4hJkkDVphl7oqsS2WrruVRFyORyHIv68Rh6neCIcDweJl+ski4U0WSZpa2Wevj8SJLXr7fGm1P9MUeIdMitO3YDARTFqd5O9sa4uNoiV4YssVpyjkijLpWdnZapIe51HzB6xL1u1toIYdzjPrD71xf0s9kWF+NVVS51kKrJWIxzG07StldxjrgTun6gPm4kGHDsDAJslZz1bb0eD/MdwdOTkSjnOkii2qFwy6LAtWxHpp/by+X0NjaQq9V/j8+H41xoHxvnSoyWXVwznefx/rEXeRrwsBmAj4vDUAABPvShD/Fd3/VdvPjii5w9e5Zf+qVfYmlpiQ984AMAfPjDH2ZlZYXPfOYziKLI1JRTXY3FYui6fuDyLp5NdAlgF88s7kUA2yvd7tVw8STHfxB2d3eZmZkhHA4zOTl51w+Gx+3tvR8ymTpBUhSFM2fOHNrS9r1GwLZtc/nyZVZXV6mV/PzRf/8KhVIFlyKR02QqALkSVY+KIEtYgoC5T/4o17BlES1fxR10kRgKMX+1/oHvMWQy1dZzdmI4xvytNqPHsSRXV7YZigfxGio+t8ZeoUzQMNjJFumPe5ldapCTPUZiHq6l2to4BmPM32kdLxnycnHZ2c27mXUSjf5ogJm265zoiXBpo0WcFElkdc9p9BgKeVlIpZs/hwyNG2nndYK6wnqh9dzeTf1L+j2sr7f2EIOGwXyHYWQ8GnKof5IoOKJhACaikYPVcKrCeqVFSA1J5squk+hORqIH9gETbjcrhbZMPwGHGQUg6XIzf8A0EmO6o2c44fI4jgWQrTmJqi5KbIg1h5EkKqpoy5vcKlqEw2E8Hs+RKXAPwmGaxe6Gw9oBfO9730sqleKjH/0oa2trTE1N8Yd/+IcMDg4CsLa2xtLS0hPfTxfPBroEsIunEg/zRn63NpDt7W0uXLhAIpHg5MmTT/Sm/DgEsDFyHh8fZ2Bg4J6P47AJYCPcWRRFxsfHD9Wxdze1slarceHCBQqFAonoCD/zzz+HZZnUbLBtC9G0sfMlTI9KRZagWqOgCIi5KoamUDAtLI9GBRjuDTJ/vaW29fSEuHy7Thw8hoIoCZweTiJQH7PeWk9TzFdYyu/QG/WzsLTZ7PtNhr1cWmkRmIBb506mtUcmibC243TA+j26g7ydGkhw/naLTPWGfMzecRo9Ohs9pvrinF9u3cZvaFxPOwlYfzjAzGp7OLPOlZ204zohQ3Wof1G3yxH6DDAc8jvaQwxZ5uqOk7RNxWKOIGio5+w57kvTuN5B2iZikQPqX2dci1/VDhDCqXCU2Y7Lerxe1jocu+mKM9LFKysHnMWjviDXO1TCiVCM8zvO8/qH42dI+hKkUilu376NJEnNft1QKPQNbZj4RiiAhxEEDfDyyy/z8ssv3/Xffv3Xf/2+t/3IRz7CRz7ykUM5jy7eeHQJYBfPLNoJ2r0q3Q7r+A+CZVlcunSJ9fX1hxo5H1bQtG3bXL9+nZs3b/Lcc8+xsLBwKL297ehUANtjZcaOTfBjP/Bb5DIFTJeGKkLZtLE0GUwTZAkKFTBNRE2mZih1QqnV9/68Ho0722kANEVkcjRJ1baZHIyR2isQi3i4eK1FdkaHIuxk9tU5AVRNbpI/ALdbpdZG5vrifi7ebhGhk/0RZu+0VLD+gItLK1uokohb0/DqCoVKleOJMLIoIYsCHrdGzNcav3l0lUypTCipY9k2oiBQqdQYD4ewbJuaaeESLTYLNrKuYNk2fkPjztYeAUnDtm1sbPr8fvKbNWzAtmyChsL1jV20er8FgiDQ5/FQTFURRbneGqGprGxniMkGoiAgCgJDkQB3MhlCbgNp/zJMOBmIIDXMGbpGrlrhhUjdsAEgWlVylQoul6t+DtTr254Lx+qPw7IwZIVUtUjS5aFimpTMKuPBIF/fcpKxcofz2SMrXNp1qo1jgRCLHZ3Cx4MRXt92Hst7l5ii7bJTkTUkmb83OoVX0ejt7cWyLPb29kilUty6dYuFhQV8Pl+TEHq93iNVBw8jBPp+OEwXcBddNNAlgF08s2iQqPtVuj0JHlalK5VKzMzMYFkWb33rWx9q7+4wFMDG485kMrz00kt4vV4uX758JLuFjWPu7u5y/vx5kskkvT2D/H9f/g1KxQqCriDkS5SCLgA8kkC+XEUs17AsCzNgYAFCqUpu3/QRDrhIxt2k93J4VA+lisni0jbZQn38N9IfZvZ6i/xNjsaZvdVWz3YsycWbbf8+HGdueQNZFPC7DZJhL7WaxemBRN25KopUbZPJZJRytUaxXEUAFFOgVrXYKxWJu1SutBHE0WSoGf4M9fFwyOdiM9MayT4/nGS+bV/Qp8msmCY1y4b6IJxk0MvVVCvmJOlzM7u66XD1xgIR1poKoY1PlZld38Rs4/Oj4aAjUkaVRCrbJjvFlrI2lYhysWOMPJmIOnIGfZpKyaxStizYVypPx+N8dd0Z8/JcvLV7CaCKIjdSaTRTwpBlNFmmz+MjXS5xwhNBEUUkUSBo6GQrFRrFwzY2Hk1FFSSqlknZqpPJ3XIJWRCb6mRY0w/EyAzqbm53hE1/e/84XkVr/iyKIsFgkGAwyOjoKKVSiZ2dHVKpFEtLS4ii2FQGw+HwoauDh+3o70ShUOgSwC4OHV0C2MVTiYeNgSkWi7z22msYhnHXSrcnwcOodOl0munp6fvu+90NT0oAC4UC09PTKIrC2bNnm4/7KHYLGyaQhtnj+PHj9PT08iPv+3XWV9PUTAvRpWJ6NDTbppIrkQu4sN0aimVR9e1/UJsWHpdGz1CUVLqAyxCZXWyRkuPjMS7drH/4K7JIvlylwY88LpWlrT1EQSDsdxHw6MiiyJmRJJZlY1omhVIFv6qRLZbZTRfw6Cq3N9PN40+NJJhti315biTBhVutn6M+g2vbzrFtseI0cUwNJphpGw/7XRqX1jv243wuFlOt4/QEvMytOklNxO9mNd8ikXGvm7k153VG4hGm26riDFFgft051p1Ixphec+7UZTvOuc/vO7AzOBYO8fq6U3nrHM/G3W7mtjuMHtEo0/tGj2qlApUKPR4vN/azB6E+po+43GwWWo8v5nKzXc47O40jUWb3jSS6pOCSFU56w6wX8qiShCKJVMtlXKJENBjAoh4jU7MtvnPkFPeDruv09PTQ09PTVAd3dnZYWlri0qVLeL1ewuHwoamD3wgF8DBMIF100Y4uAezimUWpVGJra4vh4WHGxsYOfcTzIALYIERjY2MMDg4+0v0/ScRMI3IlmUxy4sQJxwfPURHA9fV1MpkML7zwAqFQiI/8yGdZvr2NrclYlo1sm4jVut5leuqEzzYtJFVEypRBkghEPWyXK2Sub+J2yWTa+MbJsTjzN+vkRgCeO95LtlAiHvRgWza6rnBrbZeCWSa1nScR8jKzuNK8/XPjPdxYapGV5445yd1QIshcW8afS1O4vZV2PM5oyMvmcmtfcDTmZ3G7pTzpssiNDecIczge4vxSi0hF3TrXd52GhpDXYCXTNpYO+phb62j98LtZbyOEIZfOXIeKd7Inzvk2QigKcLPD+XsiFjngBg67DZbbomk0SWJx17ljdzIS5lLHHmGvz8t6sb0ezmaroy4uahjMbXcEP0diXOy4rN/nZWPTuQ9Yafs7LZsmpm2xsLvNbrn1hxFUVNJmFSvTIo4vRpOM+R/e1d+uDh47doxyuUwqlWJnZ4fl5WUEQXDsDj7Ol8ijVgBzuRxer/fBV+yii0dAlwB28dTiXvEjlmWxuLjI9vY2gUDgyFLq70UALcvi8uXLrK2tfcMjZhomk+PHj9+1R/iw42VqtRqZTAbbtnnLW96Cy+Xi5//Vf+fK7B0qto1YqaEqImVVqe+21UwEU8AlihRKVUqqDh6dkE9nu61lIxDUWd7I43GpJMIedE3m1HCCbL6MJMLMpRXM/ccx0h9m9uZ6Uw0c7g0x1zb6TUZ8zLWNhj2Gys3NtlYJARCh/U9pvC/C9M0WcTuWDDHfVikniwJ7VefvfiDoZjHVInJht8ZsRwtIMuxnq80w0h/yMbfiJEMBj85ypkXIkj7PAUI4EPIz3WYYcSkyix15elOJGBc64mHyReeuXNTlOhAhMxmPOMKhAayO7y5eVT0QDzMZiTLfYfQY8AfY7DCNFGtOg4whyVzucBYP+nxcSXc8nnCMmQ6HcFI32Mk7Fc1/MPZkESSapjnUwUwmQyqVYnl5mYWFBYc66PP5HuqL3VGaQGzbJp/P43K5juT4XfzFRZcAdvFMoVwuc+HCBSqVCkNDQ+Tz+Qff6DFxN5WuXC4zMzNDrVbj7Nmzj/2m/KhKXTvpbA+VvttxD8sEUiwWOX/+PAADAwMYhsGnP/5HfOlPLyMoIqomUypVsd0q1Mz6uFcUsBW53vjgq0e+aKqEqUpIFYGQVyEa8WAJCvEAbKVyqD1Bpufrap4gQl9vsEn+ZEmgUGmNgkVRoGyZDjLncqnU2lS3kd4wF26uIQIuXWWsL8xWpsBoIoQsSWiKBDacGUw0v2SomoxHU7Ftu27acOtsZwsENQ3TstFViXylSr/fR800qdZqBFSZSrkGgoQgiiSCXlY29ggqrdihsOEiW6jUm2WAhN/D5k6OhOFGQEASBXr9PlRBapo6PLpKqVRjIhypN2wAQbdOulRGEKCh96qSzJsSCaC+YycBe6UiQ4ZBzTRBFIm6dGRJoGpZlE2TimlyJ+tUKIcDAa6knGRsPBI+MCI2cf69GpLM5R0nSTzmD3I17ax0OxmJcK7DNBI2XNzuiKmpN4i0oIgiSx2KY8xw8dd7Dy+AWBRFAoEAgUCAY8eOUalUSKVSpFIp7ty5A9BUB8Ph8D3VwaMeARcKha4C2MWho0sAu3hm0Ni3CwaDvPDCC6ytrbHXUWp/mOhUAPf29jh//jyhUIipqakn+sb/KCPgRo9xtVp9IOk8rBFwo7s4Ho9T3Y88+R+//TVe/aM5FF0ij4AiCCCLuIF8uUbFq9UD4So1yoYClk1fwk+yL8jq5i7ZPZtqVeDmSpZCqX7M46MxFtoiYKbGk1y41iILk6NJZvZ/FgWB54/3sJXJc6I/iipLuF0qhXKV5wbiVGomLl1hZWsPr6xQKFewyjVur6fZaasUmxyOMX+jLVdwKMb0lTvNn92agiiLZIotQnJ6JMHNtiaR3pCP6zuZNiJq4svn2S20bjMU9TuyAwF6Ql622jIGk34P526vOnbjzgwmubLaImS6LKHuyey1KahTyQgzS07DxslEhKttu4deVWGzkKba9vdwMhJkcTeNT1GRqQc1J3Q3GlKz9k2RRERL4MVoEgALG0UUyZllxvxByqZFyawy6A/w9fXVptEDwKN1mitsR4MJ1GNkOpXEUX+QaxnnWHoyFGN6x/n8/b1jE8hHSLRUVSWZTJJMJrFtu6kONtY9vF5vkxD6fL679m8fBbo7gF0cBboEsIunFg11pr1Pt73S7WGq4J4EkiQ1yU/jA+BRK+Xud+yHIWrZbJbz58/j8/keqsf4MAjg6uoq8/PzjI+P09/fz/z8PK9+7hx/9ge3qBarlH0GFMpYhgqqUo99cSl18leuIVRraLpCTZHw+g2+NnO7fmABwlEv127XVSOPS2WtLaA5FnKTzpc4MRhDUyRURSZfrjAUD5DJlZAkgYXrG5Qq9exHXZXR3WorFgY41h9mM91SjY4Px5m+3iKUI8kQ87db5E+RRDYyTpVprGM8nAh6HLVyADJOFXIkHuTGllP5KpedporBcID5jnFw1O9mNdt6DoIunfkOM8hET4xzd5wK2l7ZORYdCHhZ2HSqcaPRsMMxDLCdrxsx8pX633VIF3h9Zc3ZMZyMO3IGAU4nYyy07T8KAoiWiFgTcCkKbkUh6nZTKpmcCsT2yaSAS5HJmzUSupuqZVGxTKIug0vpFNiVZnyMWz3oyt2rOZ8/WRT5eyMTB653VBAEAb/fj9/vZ2RkhEql0nQWz87OYts2oVCIUChEpVI5VANaJ/L5fFcB7OLQ0SWAXTzVME2ThYUFtra2DuzbHVaW3r3QcBkvLCywtrbGmTNnDi2M9WGI2sbGBhcvXmR4eJhjx449FOl8EgJo2zZXr15laWmJM2fOEA6HMU2TvXWbP/8ft6hZNrYiIhQrIEvUZAnbtlFkkVqhguoWKddMLJ9BEQh5NW60RapMnuxhdnGNgFcnEvQQDrvJFytEfS529wr4PAbXllrXHxmOcG259fOJY3G22hpBxoejTXUQYGIkznxb5l804HaQPYS6mtWOieG4g+xFfC7HLiBA2O9iLdPW1evRuLXrJI2y5FSlRuJBrm07CaFtlh33nvR7DuwHDkeDnGsLlFYlkZsdYdFTPbEDBhG/24A2o4khyyxudxg9YmEubTtHvX5JJFVxPidbHXuEEZdxYI9wKhZldquu4uWrVfLVKn1+P3MdjuiT0TCX2sbLkgA7xWIztkaXZHo8XvbyFY67I2hyXYl0KwpFq4aiWiCLIEucCseIGG/cHpyqqiQSCRKJBLZtk81mSaVSrK6ukslkUFW1aSjx+/2HNhKuVCrUarVuDEwXh44uAeziqUUjcPhelW5HTQBt22Z7extd159o3+9uuB9Rs22bGzducOPGDU6dOkVif8/rSY97PzQyBbPZLG95y1twu92YpsnNxTV+6edfJV+s1T+IVRW7UgFNRsiXQICiYoBLQxQEbO9+z68goOig2SJDvWFcbpW9fBm/S2MvXSQW9vLV6dvN+588nnRm/o0nmL3R+vn4UIxLbeQvGfExd7NF9nRFYr3DfRsJedi43SIzp4bizLYRRJ9LY3HNqZolw162bhcQqE82B2J+Lq1sIQo0y4dl2TnqG0+GWezoCRY7COFg2M/tXee6glsWHMqb39CY7zCDTPbGOd+h/hU6WkgSPs9B4pWIcm6lo9Gj4+/CLUusdCiJ/YbGUsb5PA4E/GytO0lhqaOBR5ckrnS4iPt9Pgf5A5iMxriw3fodlE2TsGEcaB85HYszs+VUXf/Fm76ZpwWCIODz+fD5fAwPD3Px4kVEUaRcLjM3N4dlWY7dQU3THnzQeyC33wzTJYBdHDa6BLCLpxZXrlwhEAgciDpp4G5VcIeFvb09bt26hSRJvOUtbznUajW4N3mt1WrMzc2RTqd5y1vegs/ne6TjPg4BbHQntz9W0zTZ2tjjYx/6r+T2imgejZIFuixQrO4rkZJYN4AAds2k5lWI+nS8Hg1Ek9XNEsVijezeJgPDYW4u18mAy1DYblPQ/D6dm2sttcrr1ri10VLPVEUilSsgAm5DxaUrJGNe3G4VWRKRRRGvRyNfqjAQ8WPb9ZiXvWKZiWQE07IQECiVavQFfNRMC9O0GEgGWLyTwiMqWJZNIuzl8q0txLZfiyrK2OUWSRuMeLmVyjaNGJIoYJk2uiAh7odND8eCLO9kiOkupP1RaNTlRrLr/y4KAm5VJlsqMuJ2YVsWsiIRcBtUBLG5S2YDiiByKhHDtCxqloXPUFnN5Ai7dEpVk2K1SsLncdTHyaLArd2043d8LBzg2o5TkezzuLjcQfZUlwHl1q6hJgpc2urIJwwGuLrrPNZENMq5DefYOOJyHegjztechFMWBG7sOY8V1HTmU05CeyIY5kzs4b8IvREIBAL09fU51MG1tTWuXLmCy+VqksFHVQdzuRyCIHRdwF0cOroEsIunFqdPn77vvx+VAriyssLCwgLRaJRyuXzo5A/ubgJpJ2KPG2r9qDEwDWNNNBrl5MmTdResZZHeyfHRl3+TTL5C1bLRLBsKFSo+AwwNSYCqLiNUTCTLZuBkgjsbGba3itSqNfYKZrOibWwszOWbLSVoeCjC3GKLLPT3hUil8/RG/KiKhNujkS9WqNVMyhWTYNDFldubiCbks2UGYkHOz7cyAGMhD5eXtqjW6s+nIEJvzM/yZktxOz3e49gFTIQ9XLixTs1sPVeqKjl+Pt4X4fKqUyG0Oxb9x3sjLKw6yUq+UmE33zKdjMSDnL/lNGycGog7Qqfdqsxypki57f4nk2GmlzrcuYkw6zstshdxG1xfTxGSdXRFRpMl+kI+dgol+r0+JLFeK+fWFAK6sU8kTQqlErlymYiuUzJN8pUqQ0E/1zqI43g4xMWOOBj1LpsIax2dwn5NY6GDxA0HAlzrcAhPRWMHlL6RQJDXN52K4N8/MXnwTp8itLuAO9XBarXa3B2cn5/HNE2CwWCTEHZONjrRMIAcpcu4i7+Y6BLALp5aPIjgNf7dtu1DCYG2LIsrV66wurrK888/Xx+B3rz5xMe9G0RRbBpMoOW6jcViTExMPPab/aPEwKytrTE3N8fY2BgDAwNYloVlWdSqJh99+TdY3cyhKgKCIlMybexG726liu7VqJVNUGSGx2Is3qqTBFESkA0dc1+RCocNri3t4HXJ+NwqgYAL27Q4PhglVygT9LuYW2iRo2ODEWbbun+TUS9Li7tUa3VipKsyqztOVSkYMNjYaxGQqZEEF9vGxyGfwaUlJxkJel2s7bZuM94X4cpKG9ERoFBxjlqnBmPMtu0HCgJkO0aoJ3qjXOoghGrHyDgZ8Bwwg4z3RB2B0qIAd9LOkfGxaIDFzY4xayTA+eU1oArFfRO2ZbHapuz1+r2sZrKO/cNhr85qW76eJAgEFI2E6mpWvGmyhCbJvDmWxAaqtSo1s0auWCYqKZSxKVomxwIBLnUQu7FQ6MBY16cd/ELT2VoiCXAzk3Zc5lUUvn149MBtnybcLwdQURTi8TjxeBzbtsnlcqRSKdbX11lcXMTlcjXHxYFA4MBrv5EBeJRdxl38xUSXAHbx1OJBb3iNN1zTNJ9YpWtErVQqlea+39bW1pHtGLYrgO0Va/39/U/0Rv8wI2Dbtrl27Rq3b9/m+eefJxKJOIj0z7z8G6ytZ1EEKItSnVWUygiiWD9v2yZnAYpMLO7j1krrw//kyQSlikki4sOsWVSxyeRS5LM1amWbbLFGJlf/0NdUkXypRQAUWSRTchICl0ej2rbbNzYS48LVFrEYH4py+XaLcLl1xTE+BkjG/My27Qse6wmxsOQ0hxQ7VgmmBuPMtvX7iqLAdq7ouM7kYPyAO7jYsZ93LB7icseeYcTvZrXNVOLRVS6vO69zqj/BzB3nSLVUdN6/Tz9YQzfVE+Nih4s46nU7mkgEIIeTZEQ9LmbXtxw7iVOJKK937B+e6YlzadtJTAuZIgFLrruBNRW3piHZ9RgZG5uaZWFhky1XCOsGe+USNdtmxB/gesf4dyoSY6ajReSdfUPoR6DCHyYeNgZGEAS8Xi9er5ehoSFqtVpTHbx06RK1Wo1gMNgkhIZhHGoEzCuvvMLHP/5x1tbWmJyc5JOf/CTf/M1336383d/9XT71qU8xMzNDuVxmcnKSj3zkI7zjHe84lHPp4o3H0/2q6qKL+6BB+p6UAGYyGc6fP4/f73dErTxJXduD0FAvGw7jx20U6cSDztk0TWZnZ9nb23OYPSzLQhAEPvr9n2Hx8joV00bwaFCo4PLp5N0GAFaliu2uL7Qrikg04UN3C1QrJj6/h/mFtWY8ytSpXhYvtwjE6Gic2Sstta8n6ePGnRaZGB4McflWS+GaHEs4Gz9iPubajCKyKFCq1vC5NBRZQpJEBpMB1lJZgm4DURTqOYGlKmPJ8H5enY3fazAm1p9rAQh4dXZyJUYTIWzqH+bFQp6oW0VV6481GfZyaytNyG1QtUyqVZOdnNMYMdEXZX7FScgkyUnmkwEP83ecBGcsET6g/m1knS7joUiAWx1u4Igmcj3rDE/OdCiSIZfOfIdjeCIRYa4jMqbX72M957zPQmejhyxzpcNZPBDwcXu/1SRTM6FYYtBQuV12ntcLPUnmtlrPjVdRialuJLeIIcsokoQogq4oPB+OU7ZM8tUqu4Uc7xoc4WnH4wZBy7JMLBYjFos1Gz9SqRSbm5tcvnyZn/iJn2BkZASXy0W5XH7guPh++OxnP8sHP/hBXnnlFd72trfx6U9/mne+850sLCzctVXoz//8z/mWb/kWfvZnf5ZAIMCv/dqv8R3f8R189atf5cyZM499Hl08PegSwC6eWYiiiCAIT0TSGpl3IyMjjIyMONS3x61rexjYts3u7i6aph2qw7hztNyOUqnE+fPnkSSJl156yZGjKIoiH/un/5m52VUsScS2a4gW2JJIwa4/J7ZlgQjJkAfdq6N7Vebm6rt4LpdKoZpvkr/e3gCXrrbUsZGhCHOLLfI3PBhmI5UlHvagqRKqLFAqlRiI6vW2DlXFskyO90ep1upjaY9Ho1ioUqnWKFdMJkcTDjUwGfEyvbDS3D0EGO4PcWO1RVqmRuKcu9QKfVYkkV2fwfZei8yNxN1c326QoQqqLFGumKTaApyfG6l3DcuCgCpLKLJItWKR9HhQJBFFkogEXGSLFU4lY4iiUCekhkbSX89zs7D3dy5tjsfCVEyTcs0kGfQccAN7dOf41KXIrJedqmW/xzhAEofDwQMZgoUOtdOrqSxsOu9vPBJicacjRiYe4VxHrmDA0LjtnMgjGrrDSCIJsLjlPL4mS5xfX6fW9voa9Pu51VFRN+X20O99NCPUG4HDCIIWBAGPx4PH42FwcJBSqcQP/uAP8ju/8ztcv36dUCjEX/2rf5V3vvOdfM/3fM8j5wJ+4hOf4H3vex/vf//7AfjkJz/JH//xH/OpT32Kj33sYweu/8lPftLx88/+7M/y+7//+/zBH/xBlwD+vwRdAtjFU4uHGYU+rhGk0Sd8584dnn/+eaLR6KEd+0HI5XLN3cIGETss3GsE3GgxiUQiTExMNM0ejdv88k//AXMXljFrNURJAZdeJ1KyiC4KFHIlVLdKRVFZ384xHNRZuNxm5BgKc+lK/WdJFlF0mXjUi8etoSkSoiJxciROqVSlXK5RKlYp5CoUchUQYHgwwtJKunm8oX4fN5Za48GxobCjMSToNVhccqpYXo/O6k5r1HlyJOYMfZZF1jqiYiZG4sy0qYqqJLDeoapNDMWYvtEiUYokcme/ccOybUrVGqM9B8fBsixytS0eJhn0sLG84SCoZ4aTnG/LIUQA0RYoF2rIgoBLUxgI+chly4wHQ6iyhCyJ+N06uXKlrlhiU6nVUCSo2DaFapWSaSGJAgsdI+LxWJgrHVmA47HwgVGvqjjJjCjAnQ7HcFDXD+QKjgQD3OjYBzwRDjPXEQfTYxjsdARlB106t7LO8fI3B4LPhPnhKKrgdF3nH/7Df0ilUsG2bX7hF36BP/qjP+Jzn/sc3/M93/NIx6pUKpw7d44f//Efd1z+9re/nddee+2hjmFZFtls9p41lF08e+gSwC6eaTxOFEylUuHChQuUy2XOnj17z/2aoyCAm5ubXLx4kVAodCQO47sRwPX1dWZnZxkdHWVwcLBJ/hoK6n/+5Of5/OdmsEQRzaNTssAuVRAkQFMp1iwUTaay/wHn8+msrNc/qAN+g8GhCDXTYup4kkKhjC/gYmau5dKdnOrh4mxLdZua7OHi5ZYaOHk8ydzVFgkb6A1ya61FBFRFZHXLSQwScR8LN9tCoQejXGkzesiSyFZHw8fESNwRHO0xVK6tOFWuwYSPxfXWfbk1hWtrzutMDMWZaSNtogjbHePg8d4wi2tO0hPxu1ltM6u4NeVAfuBkX6wZDm3ZNrlSBVmWWGrbI1QlEZehsltoEaiRaJCFVIcRI+pjaS9LRJIxFAVDUwmrGi8m6xVvpm1Ts02qNZM+n5dsuUK2XCbh8zC/0ZFHmIhxsWOUPBIJ8vqqkzi61YN/zznT+fqUBFjKOcmkW5aZ33YS+n6vjwmX65kggEdZBddoAZmcnGRycpIf/dEffeRjbG9vY5om8XjccXk8Hme9Q3W9F37+53+efD7Pe97znke+/y6eTnQJYBfPNB6VpGUyGaanp/H5fJw5c+a+BEySJAdZehLYts3Nmze5fv06U1NTiKLI9evXn+iYd0OjPq9xn41A6dOnTxONRpv7fg3y99lf+BP+52+fw5Rl7GoNURIRKlUkRaS279p06zJ5y8br1Qj6VQTVxrbd7KQKiDZcu7pBvlDfPesbCHGxzdU7NBRm4UrrA6Y36We+jez5vDq32kiYIAqYQp38NHB8NM7FxRbRiId1B/mTRIG9glNNmhh1kj2fW2PxjpNgHOuLMNMWDeM1FJZ2Omrh+iMO9U9XJG5tOonW5GCci7ed6l+7ygd19a9z92+8J8L5W071L1Nyqo8J/8HbTfTFmO7oGDY6OngVSWQ5kyNfs8jXLCjXiFkWV3ecRPp0X5yZNuVSFAT6vT5kW8SlyGiKjCyJGIrCm5IJaqZFyTQpVCqs53IINuxvCBB1ubjUERlzLBjgWjrtuGwyFuNiR7Zgj6ay2NFA8p6TJ7F3dp96Ath4jzhKAnhYIdCdU5WHTVD4rd/6LT7ykY/w+7//+8RisUM5ly7eeHQJYBdPLQ57BNyIPbnbvt+9jg08MQE0TZO5uTl2d3eb4c5bW1tHsl/YUADb7/Oll15ymD0a5O/zn/0q/+OzX6dYNTF0mYKkUKxa2LZNTVXBNPG4VPrH42xvZdnayOIPyCzf3CdJAoyMxbh+o64WKYpI1bSw9smPqkgUytUmmRNEEJR6TI3XpaEbCoN9IVLpAj0xEVkS8HoN8qUqobG66URVRSqmzenRJNhgY6OoEhF/fRewWqmiKBbFSpWRmBdFlnEZGtWazanBePN37HGr+45jAYH6eNa0bSZ6QxQKBVwuF8GAh0yxjLW/l4cAxXKVwWignklYMxlMBLhwq0W+JFFgPe3MwDveG+HK3Zy/beqfocqO8TDARG+U+Y4ImUTAw3qbY1gUBVb2nOpZb9DL/KqTUPV7NG5kna7hRDjIRoezeDnlVDc9msrF1Q3KtdZraiQc5HzH7Z7vjTOzuoEiCPgNHa+mMhDys1cpI4siNmDaFm5NoWJapMtlsuUytgDZipPkCgKkO16KqiDQs5epVxHu7WEYxlNLBNv3aI8Ch+ECjkQiSJJ0QO3b3Nw8oAp24rOf/Szve9/7+O3f/m3+xt/4G090Hl08XegSwC6eaTwMAbRtm8XFRZaXlzl9+vRDf4NtvKE/icu4YbwQRZGzZ882K6GOymEsiiK1Wo2vfe1rCILASy+9hKqqjg8pQRD48/8xza98/I+RVBnbtCiYgCQii1DFRhNsKqJAtD/Epbm6oheJG6yutVSayVO9zQw/SRKYPNXHTrrIyfE4siTi8mhks2V8Lo1yuUYk5uXS4jpUbfLVMsmoj3MzS83jBXwGt+7sUii1TCwjwxGut4UhTx1POEKgfR6Nqm3t36ZOePriBkvbLUUwGfGycMu5ezdxLM58WzRMPCyxuLLjuM5zo0kutOUJegyVK7e2MEsWiiigqzInB2Ks7GQYCQX29/Mk3LrCmf5Ek3xKkkDZNDmZjFIxa5SqJj0hHzNLHeaMqnNUGvG6mOtQ/6b64lzoIGNhr4s7HaQwYzoVyIjbOEASJ5IR5jecRDWuy1zNOAmau0NdBNjZV1xN22anUCRfrpAqFR25iFG3i51isRkto4giJ6MRsrUKU/4IiiwhCgKGIrFbKeORVbKVMjvlEt82Osbp48eZnZ3lxo0bLC4uOqrVnsQNe9hofJE76hHwk0BVVd70pjfx6quv8u53v7t5+auvvsq73vWue97ut37rt/i+7/s+fuu3fotv//Zvf6Jz6OLpQ5cAdvFM40E7gI19v1KpxEsvvfRIo5QndRnfL9z5qBzG5XKZdDpNMplkYmICaCkUgiAgCAJf/9MFfuVf/xGWJFKtWYiqVI93EUTwqGBoVCyYPDPA3GydbKmqCLJKJKIR8BsYLoVqzWJkIMzeXhF/wMWFC3ea6t/AQIj5y+tN9S8S9jB/eY1ypf67UhWJdKdClfSzcK1Fyk6OJxzGD49L5daqc/w60Btitm3U2xPzc2fHSYZEwXQQu4FEgIWbzpFt2O9mvS0YOhpwOwwkAKO94eY42LRsKlWTm5u7pDItUnyiP8rXF1cct5sadnYQG4pMLlemVjTRJBG3rnIsESJdKDEVjyJLEpIo4HGpZEplTNOmYtYoVKpUzBqqJFHZ/51Gva4DquF4NMBiKu24rD8cYGv5/t3AqiiyUXY6yIOaeqBn+EQ8zOWOQOqJZJTzHQ7hgaCfrULruTEtG0kWudWxz3k8GuZym5lEAN57/CSBQACAN7/5zVSr1QPhyY9brXbYaH99HQXy+TzJ/b3NJ8GHPvQhvuu7vosXX3yRs2fP8ku/9EssLS3xgQ98AIAPf/jDrKys8JnPfAaok7/v/u7v5t/+23/LSy+91FQPDcPA7/c/8fl08cajSwC7eKZxPwUwm81y/vx5vF4vZ8+efSwV73GNII1w5/HxcQYGBg58ODxOZ++DsLGxwfXr11FVlampKWzbbroTG/c//7Wb/Lt//t/I10DTZMxCBUvRQJXBrFGth+UxPB5jdzdPb58bRVHxBjxcWlilWjVJbWaI9wZY2XftapqMoMlN8ifLIuWa6djj8wcNtvZa+3Xj43FmL7U1gAxHHOTP0GTWtp35IkMDYWbbdgH7En7mr3fswrlUrFTrfkf6glzvII3lStHRijGYCDB/y0kI42Evm23ELuDRubTcYYwYijFz03n/nUHQyZCX+SUnkTzeH2V630RSNS3S+RLpQonrG61xrN+lU6xVHaPYib4o8/tGF5ci49VVjoXDpAtFsC1KxQIutxuf14UiKxRrNfKVClXT5HKH0jccCbC45Rz/TvbEmO4gcXGPwc6OM1sQ26kuAmzknbuTmiRxtWO8HDT0A+aSPp/XQf4ATidijIWClEp1ldGyLAzDoL+/n8HBQUe12tzcHLZtO9TBx6lQfBI09v+OkgAeRhD0e9/7XlKpFB/96EdZW1tjamqKP/zDP2RwcBCor8gsLbUU+U9/+tPUajV+4Ad+gB/4gR9oXv493/M9/Pqv//oTn08Xbzy6BLCLpxZPsgPYcL4ODw9z7Nixx35zflQC2F4nd+bMGSKRyF2vd5gj4HaDyeDgINvb281at3byd31umZ/9J7+BoMlQLCMaKrjqozS7WkVxqQyNxpBkiTtrabL7cSgnpnq4eGG5eX8npnqYm2sjb8fjzC20iNmJk0lm24wgExNJ5tu6f5MJH9dubuF2qciSWO+rFUUSYS+iKIBQN4usbmVx7effeVwa6b0iPVEvNgK2ZRMKuClUqliWTc206E0EuLaSQgQsAAGqHWaMnrDOyq7TMGLjJOK9UT/zt5ykbTARZKbNDKIpErc2047rnByIsnDHSXDCfher6ZYiqSsSNzqaSsaTYRY3OuJUEkGnQQRnNV2pWkOVJWZur1FqGx2PG26+vLjsuN2ZoSQLa1skDTduTcVQZQJug7BuYFJ/7grVKjXLQpclSvuk060o3M46jRkRXeVKB3E8EYtwqcPBOxGPMr3mJJMj4YOu4ZjXw3LWqdh+5+lT2LbNwsJCc3etU8WORqPNarVsNksqlWJlZYVLly7h9XoJh8NEIhG8Xu+RV6gdRQRMOwqFwqE1gbz88su8/PLLd/23TlL3Z3/2Z4dyn108vegSwC6earS7Wu8GSZIcI2Dbtrl69SpLS0uPtO93LzwKUatWq83apIbx4n7nbVnWE/cYW5bF3NwcOzs7vOUtb6FUKnHnzh3W19ebH54Ay9c3+Og//gzFUg3BEkAUKJo2lCt4fDoFWaVmwfXFDeJDwSb5i8S83Lrd+nAfGomysLCGJAn4/S4SST/VisnkiQSiIKBpMsWKyYljMWo1C1kW2dstEPbolCsmlUp9hFnKtVSlU1O9XGxTAxNxH9OzK5hmi5gND4ZZaaucOzEad5BMURTY0wqYhRoCoEkiJ8fi3FrbJeY2kEQBs1bFkBSOJ93IkgTYqJJNplhiKKgjiRKyouDzGXgNlappUamaSLLA7c00kgCN1bqTgzEHIUSAXEcLx93UvxN9MaY7iF1HK1u9Gm7VSaiOJyMH6uJG4yHO33YeSxCdf0uKKHJzO02pWtsninliPjeX17YdtW8TPdHmuboVmYBL51gsyF6xgiyJINZHuF5D5cbOLrvFIvl94pnNOwkcQKrD0SuJAjd2047L3IrCpY6A6KjbxV/q6+H8+fP4fD4mJycBmmp244tNe4al2+3G4/EwPDxMpVIhlUqRSqWYmZlBEISmMhgKhVCUg/uMT4r79QAfBg7TBdxFF+3oEsAunmnIstxsvqhWq1y4cIFCofDI+373wsPu6uVyOc6fP4/b7X6ocOeGYvAkBLBcLjM9PY1t202zh6Io9PT0cOPGDebn5wmFQkimyif+ye9RqJgIioxdqYIsgWWBJFGTZaz9Von+sRC3bu5n/AUN+oZCVMo1BOpEvFCuV69lMkVKuTIb63ukUvXxnySLxHoCrKymm+d44kTC8fPkZA9zbfVw0YiXy9ec41fDpWFutwU6jyVYaBv1KrLI1q5z5Dg5nnBExYiiwMrmHplcS+071h/g2krb/pkAfXE/y5ut3b9k2OBqWyA1wOSxOLf3yadHUwh6DTJ7RcZirWBmj1ujUKkSchn1/UDTJOAxqFkW2VKZYqWu2N3ccqp/xxKhA3mBYz3hA+qfifNLkKHIXOloCxmMBA70Dk/0x5jpiIzpDfrY7Kiaq9mtv/FitUY5k8O0bcf1vLpKxbIo7X/h0mWJsWiIYrXKSZ+OZZrUzPrjLNRMYi6DdKlMxbKYjMe4sOH8PR+PRTjXoQj+zfFRps+dIxwOc/LkyQPNPEDT5d74AtV4fQqCgCRJxONxkskklmWRyWRIpVLcvn2bhYUFfD5fkxB6PJ5DUQePMgIGugSwi6NDlwB28UxDkiRKpRLZbJbp6Wncbjdnz549tG/6DzMC3tra4sKFCwwMDDA2NvbQo2t4/IiZbDbLuXPnCAQCTE1NAS238tjYGOPj4+TzeW5cXeLf/MB/pVSzMGs2siFRE2WQ5fruVNJPeq9IsjeAYoBtWgz0BdnezNLXH2Lm67eb93niVC83b7RIx9BoXQ1s/vtEj0OVGxuP1V2/+wj4Xdy47SQ7/oDBZpv5otP4oakS6x27gCfGEly80hbo7FK5cadjLDka50Jb9Zwii+xknft5k8fizN3oJJ8u2G2ZUwJuxbEfWCxXGR9w5gciQG8swJ02c0My5OXanVRzD1KTRJ7vT7CezpGIuVGVumPYZSj49LraWK7VKFWrrHS0lYzEggciY/oDBovbzut5XSo4n4YDRM+rq1zqJI7hAFc6RtCTPTFmO1zDY7Gwo1auUjNRZOmASeR4NMBymwnFq8iYpQqTwTC6oiCKAjXLQkag3+cjVShQqNWQRZGRcoFYXx/j4+P3fB2Joth8zTRIYIMQtr9WRVHE5/MRCAQ4duwYpVKpqQ7evn0bWZabZDAYDD620/8wckLvBdu2D3UE3EUX7egSwC6eajzMCDifz/OVr3yFoaEhRkdHD3Xn534E0LZtbt26xbVr15icnKSnp+ehj/skETObm5tcuHCB4eFhRkZG7rrvVz+4yL/74O+T3S0heVyg2IiKBDUb0TJJDAWRVI18rkw6lUXQFPLZ+hhzeCzGwnyLQB2f6OHSpdaH/+jxuIP8JXsCDrJnGApb2858vHjSx+W2fuATxxNcajd+6AeNH+PH4ly80jqPgN9g8ZaTcAwPhB3qn8+rs7jkvM7JY87eYFkS2Nhxnt/4YJQrHUaPnniI3TYCqMkCl5acpHFiKH7AMRwOOHf/AK6t7bCba5HLoXjA0SgC8PyxJNM311AlEb9Lx62rxDxuvKqGJApY2Oxls9RqFkm/h0ypTL5cJe73sLDiPPeJ3hjzax0kLh7mfEf8jM+lgVOYJF9xkmVJFLjVMcL1aiqXOsbSCZ/nQNh0UNdY6FA+x6NBLrSN9L2KzPNeNycHBx9pZ7fxOrqXOthYDxEEAUVRSCaT9Pb2YlkW6XSaVCrF9evXKRaLBAKBJiF0uVwPfQ5HPQLO5XJPHAPTRRd3Q5cAdvHMwrZtUqkUmUyG559//oGBpo+DexFA0zSZn58nlUrxTd/0TY8ci9D4cHkUJ3A74Tx16hTxePxAuHMDpWKZH3nXvyW3VwSXgWVaYNaQRAXBtkgMhVhdyWLbORAg1u9jY62uFrm9OruZYtPV6w8Y7KTzxOM+DF1B1SQMt8bURA8IAgI2kiITCLiwTAvTsvH5DVK7OfwuDcuyCUc9bGxm6Ql7sW0bRZUp5CvEgx5Esb7Y35P0s7GdxRfXEEUBn1enUKhwfCC6bxQR8Hp18sVK/bEKdcdx1bQ4NZrANC1qlk3Qb3BzZQtVtLGF+oj26rKTqJw8luDiNaeKV+jY4euP+1noaPg4PhR3ZAMCbOw4SWsy5D1ACCcH4wfInq47VWpVlri53zJSMy1S2QKGKvO1q3ccxtuRiJsbqZayZygSQ0E/XqVu8JBlCUEAXZM5EQuTrVTZKxap1ExubDuJWNhjHCCJo9EQ17YPOoQvrDqfi7F4mHMd0TI9AS/rOSexDvk8LOecSmQh79wRLFRrvPPkGKOjozwJOtXB9v861cFAIEAoFGJsbIxCodBUB2/cuIGqqkQiEcLhMIFA4L4E76hNIN0RcBdHhS4B7OKZRLVa5eLFi+zt7eHxeI6E/MHd41pKpRLT09MAnD179rFCaQVBeCSDiWVZzM/Ps729zTd90zfh9XrvSf5M0+Rf/IP/wM52nhoCItW6z9WlU6xYhOI+dtPlJqk4NhFje6tAoseNKNkYHo1aTcDjCpDPlQlGvVy/2iIJx0/1cuF8Ky5i8rk+ZtoCnYeGI5yfud08vqbJFCrV5q4gwORUryMGJpnwMzPvNH6Mjca4drOlag32h7h0fcNBhsZHY1y50Tq3RMzL9VtbtMy/NaZOJLl0fYOArqLrCl63Rq1cY3IghiTVfw8uQyVbquBzaVSqJuWqSdBvsJHOUa7Wf0c+t8aVjjq5EwNhLnWMn92GhJVunaQiiSxvO1Wx/qj/QKzMyYEoM7ec5DLgMVhuJ5gCFC2nMqUrCjO316m0RcYcS4Q430E4XxhKsJrOEQ+F0FWlvrvoUtkpFClUqqRLZXYKRfS79Plmys5waFEQWNp1PiZDkVncdD4/QUNnoSP6Jen1sNoRG5PQVZIi3L59m0gkcigjz7uNihtksFMd1DSN3t5e+vv7MU2T3d1dUqkUly9fplqtEgwGm+qgYRiO+znKHUDbtrsEsIsjQ5cAdvHMoWG4cLlcnDhxgps3bx7ZfXUqgOl0munpaSKRCJOTk0/0zf9hDSaVSoXp6WlM0+Sll15C07QDzR4NmKbJj73733NrcQ3d76FWqiHKAtb+B5SqSyQHI+SzOcoVlWDIz+KVDaoVkz3g+HO9XG4b7fYN+xzkb3wiyeW2UXAi6edK2+hXlkUK5aqDpI2Ox5lrGyf39gaYv+IkJ4ZLwdxqPRejI1EW24gdQr1ztv24x4YiDvJXfz4s2pNfYhEPl65vUDMtMvkymXyZRMzn2A+URIFQyMNm20h4uDfIxf3HaSgSHpfGSF+Y3VwRVZGQJBEBUFSZiX6JUrVGrlBBFG2uracd5zTWG2KhQ4H0ujVoW7uTRIE7HUpiPOBhoaMJZLI/dqAbeCR+MDJGUzre2gVYz+RZ38uxvs/bDFVGkATybeHPCb+Hje0sx/xBXJqCKkvomkS2XGE0EmKvWCJVKDKZjHKxQzk8mYhwfsVJYIcjQcfeINRVwrUOlfC733KGaDTE9vY2V69eRdd1otEokUiEYDD4xArbvUbFDVLYqQ6GQiEikQjj4+NNdXBzc5OrV68eCKE+SgWwVCphWVaXAHZxJOgSwC6eanTu4WxsbDA7O9s0XOzs7Ny3CeRJ0U4AV1ZWWFhYYGxsjMHBwSfeNXyYMOhcLse5c+fw+XycOnXK0UzSyERrwLIsPvx3f5H1pR1sSaFUNsG2UTSVgN/A5XNh+HTmz9WNHR6/Qb6QplqpHy/eF+DG9ZZaE0/6WV9vjeoMl8Rym9oliAKKLlOttj48j0/0MNdW1dbXG2ThknPUKipSc7wMcLJjF1CSBDJ5Z1bfxHiS+astciEIUOzYU0tEDFY2naPFUNDt2PULeA2udGT8TYwmuHjNSVzaP9DLVROXbTFzdZVK22OdOpZgZsGZuTc5Emdvr4TPraMrIrIE5Vye4YCOJCsIkoSiyGyl88iiQG3/eZgcjHPhdkcIc9DD+p6TKOU7xtSGcrBTOBn0srDS8Rh7owd2BE/0Rg/EyCSDXqZvr5Fq21Wc7I8x13Y8SRAQajAeCOJSFWRZwrItFFFiKOBnp1gkU64gCQI3d9KO42uSxJUt5/l6NZW/dXoSQ1EYGBjANE1SqRTb29vMz89Tq9WahCwSiRxKDdz9jCSdMTO6rtPX18fAwAC1Wq0ZQj0/P49pmmiahqqqlMvlZtXjYSG/r5R2CWAXR4EuAezimYBt21y7do1bt25x6tQpEokEUI+BOYpO3QYa3bpXrlxheXn5vuHOj3Ps+xHAhrt4cH8xvqFUNMbHnfi5lz/D9YU1kCQQQBGhikCpYlHayhPuDXKlEeAsCkR7A9zYV/cURUKQREzTwh8wMFwqsWQAb8CFJNfDmmVNJJstUq1UMC0Lt0/HrMHJ8RiCIGK4VAqlKifH6r8bQQBVV/B69TpZBdxejXyxwnMnevafAxBkkanxBJYFlm3h9eps7eboTwaoVE1M02R7N4+Ajb3fVDJxPMncopNYmjgJ+WBvkEvXnXtrfb0BZtvMIJoisbzhHGWODkQO7Az2JYKOnUFRFNjsIGfJsJdLtzaxbJutdP2D+9RogovNncH9ruKwzvZuGQHwGyoBj4Fgwum+BJIkYNk2lg2ZXBG3IlKoWtjA8d4IVzpiXo73RQ/kCkb97gMGlPbxcP38YbnDrOHWFC53OIRjPjcLHVVzA2G/gxACnOyJMLPceq7disxzvQky5RLDPj+iIFC1Ldy6wqWNbQS7rugC/M3J4xhtrn1JkojFYsRiMWzbJpfLsb29zerqKpcvX8bj8TTJoN/vP5QvYo37hfvHzIiiSCQScZzblStXKBQKvPbaa7jd7mYItc/ne+Jzy+VyiKJ4YOzcRReHgS4B7OKpR61W4+LFi2SzWV566SWHI+5xq9oeBZubm0iSxNmzZw81juFe527bNrdv3+bq1atMTk6STCbvue/XuP7/8/5fZfqL19HcKqWKhSCK2KIAYv1DrWc4zNXL67jcKtGEj0giQKlU5eRED+VSFU/QxbUr61ilGplSjf4Xwlw814qAOT7Vy/y5O82fozEPNzbT1Kr7BFaAWI+PjfUWKZo81cvMTEsh8/p0TCCfb+2TTU31MNt2nUDA4NbSDqVSS907tb8vKAkCuq7g9xkUsiWO9YQQsCmVi4TCXhAVEuEApmVRMy1cbo1SpUq+WCVfKBOJeBwRMwDHR+IOdzAcJEuRgItLHVVxEyNxZjvMICG/i7W2HmJJFFhNdYx1Qx5W9uoqpQ1kixWCLomLN5xkbGIgzNJa/TJFFAh4DLyywqlkDEWuE/yaZWKZFjGfm1SugGnZBN0GlzraSIZjQa5tOPcUJ3rjzK50PBfJyAFFsCfkY6PDwOE1DqpcnT79YrXGdj7P9Q73b8LnJp0toYgCYY+LgKHz3ucnDxyvAUEQ8Hq9eL1eR9Dz9vY209PTCILQJIPhcPhQ4p8eJWamEUIdDAbp7+9vqoMXLlwAaI6KH/fcGhEwR91m0sVfTHQJYBdPNfL5PF//+tfRdZ2zZ88e6PlskKgnbdS4132vrq4iiiIvvfTSobcI3E0BtCyLhYUFNjc3efOb39zcMboX+QP4f773V7l8YQnbtinXQBBFVE3GCLqJ9wQQRIvUbg5Dl8lnSwhJP9NfvYG1X2sxOpl0kL3B0SgLc60xbiDkYmnJOfp1eQ0220wdo8djXL3aUqe8XpVr150qUV9/iIW2EOhk0sfCFSeJSiYDjssiYU8zKNqybQrFCsdGIo7mEEURKVRFdtOt8e/xYzFmZlvEUhQEEgEPsiXUncyqjKbLCAicHklQtSzK1Rpet8bVO84RZSLqY+t669iSKLDRkdXXE/FxqXO0PBJvU//qiAU9rKfbCJUAFdup5hqKyNW11vNdb+DQOH/dSc5ODce5uJ9jKAoCEbfBeCJMtlhBkSVsASqmiUdX2c0X2SuUmkQtV7mLqaNDEXQpMosdMS8ht35AEewJeA+0lAxHAgfI32DQy619ZbJm2Wxk8oyEg/QHH95Br6oqyWSyGfS8t7fH9vY2N2/eZG5uDr/fTyQSIRqNHgpxepiYmUqlgqIoTeUykUhg2zaZTIbt7W2WlpYOVNQ9bAh1LpfrEsAujgxdAtjFU42dnR1isdg9g2EbGXqPk6d3PzTGrz6fD1mWj6RCqpMAVioVZmZmqFarvPTSS+i6/kDy95l//T85/6WrKIYCqoquSsiKiOJxsbuVI7OTJ9TrYXt/l8/rd7G7W2iSv0DIxfpa64NfNxRy+YpjRy8c83OtLb9v4lQvc20EMRz1sLSUdpyXP2SwvNxSv3r7/A7yV78v1eH6HRoMHyCEkYiH7TbCFA65HfuCACfGkly87KyFS+ecO4R9PQFmO4wnz53sYaaNSApC3Y1cyJbRZAmfRyMZ9VErm5werlfdWdi4DJWVVIaw1yCdK2LaEPQZDrVPFAXWd5wkMRpwH4iHOTkQZWGpc+yqcrujr1hTOkb+AqSyrT09y7YpVqrM3tpwmDpifg+Xs1tYto0mS4S9LvqjPko1kzf1JzFti0K1hs9QmV5yPvfjvVGmOzIDhyLBAzmCMb+HlYzzsfr0gyqhVaseuOw9b5o6cNnDQhRFgsEgwWCQsbExSqUS29vbbG1tOaJcIpFIvRHnEJy6nerg8vIyu7u7Tfdw+/W8Xi9+v59jx45RLpebMTNLS0tIkuSoqLvXe1c+n++GQHdxZOgSwC6eajQWr++Fxpv6YRHAznBn0zTZ6KiwOiy0x8A0nM0ej4czZ844/u1e5O8XfuQ/82d/cBHBtuujWFFAlCQsWWZ3P4S5ZzTInf1qN0EUiPYEuLG4gcuj4nJr9A5HyOwVSfYGkSQRt1+nWKiQSPgAMNwahWKVqakebEBVZao1i6mJXhord5pLoVxq/Y50Q6FQquI94aJarVEuVxAVi3BAwULEsurB0VeutciQIApUTacaemw4cqAmLtpBCP0+g8WbHXEq4wnnfiAgy84P/4DP4HKHg/jkaJz5fUWtWjNJpQskIj4u32xdT97vQN7eVxtFQWC0P0w+U2aiN4aiSogCGIbKViaHJIrs5oqUKjWSER+bmY78u7Lzb1uRBLaLzhF02K1yZcWpSp7oi3Bp5eA+YGfWYDLsZSNT/1uo1EzWdrMEvToLHWPiwVgAoQpRj4uAS8etK+iCxPO9CUrVKnulMuliietbzlGyR1O43NEEEnTpLHRc5lMk7uSdqmNvwMdfGh3gsNAwa/T19TWjXLa3t7ly5QrlctlhJDmMnbqVlRVu3LjBCy+8gM9Xf73cK4RalmUSiQQ9PT1N5TKVSnHz5k3m5+ebymVnCHWDAD6pAvjKK6/w8Y9/nLW1NSYnJ/nkJz/Jw+UrGwAAuU5JREFUN3/zN9/z+l/4whf40Ic+xPz8PD09PfzYj/0YH/jAB57oHLp4+tAlgF081XjQG1+DHB3GHmB7uPOb3/xmAoEAq6urR7Zj2IiB2d7eZmZmhoGBAUZHRw+4EO+GT/7T/8TrX7iCbZqIhoFN3cjhiXjZXE3j8qlEe70Ybg+Tz/uoVUxcfoNb1zaRRChkSgyNxZn56q3mMccme3j9S9ebP4ejXvKlCsXivnIjwNBonJttTuGTUz2cbzuGbijoHo3dnbbMv+f6HIqhqoos39yCsoWmiBiGyrGxGKmdPONDUWRZRJZFFE3m1PEklmVTrZnIqsjK+i6aKlKpmNgI9PUGmWtT9jRV4k5nDMtw9EB7SF9PgNm2+BpJEprGjQaSUR+XOqri6gHSrdtZto2qSA7TiCBCNORxuI/7oj7SOwUmkhFURUYQBTRNIpUrEg+42c7kMS04MRBltkMl7ImF2O7IB9zZc+4WSqJwIGvQa2hc7iB6yaCHSx1u4NFEiKv7O4KpbIFUtsBkf4yvXr3juN7zgwnu7GYYD4VwaSqSKOA2VNayWXYKJXbyBSxgJBI8EBA9HAsz01Et93dfmEA8otGmJElNstfI0tve3mZjY4MrV67gcrma/x4IBB45xmV5eZlr165x5swZAoFA8/KHDaH2+/0Eg0FGR0cpFosHQqjD4TALCwtkMpknVgA/+9nP8sEPfpBXXnmFt73tbXz605/mne98JwsLCwwMHCTgN2/e5Nu+7dv4R//oH/Ebv/EbfOlLX+Lll18mGo3yd/7O33mic+ni6YJg369nq4su3mBYlkW1enB01I7//b//dzMc+XHRHu585syZZtTE+vo6N2/e5OzZs4997HuhcX/b29tMTEzQ09PzwJEvwB//5mv80k/+HoIiYQkSoiwS6wmQHImzu51h/c4OhkejVLIo7ZO3ofE4t29vN0e/fcMRVlf3MGt1oukPurCwyWb2R49C/TYOsvdcHwtzrZGp12dgY5PLtZSdidN9zLePh8NusoUK5Tala/JUryMXUNNEkEVKpdaH5ORkD3Nt41kEiEQMtlL185MkkeHBMMVKDV2XUVW5rmC6VTL5MpWqSbFcJZsv4fHqLK+lm4eKhT2kMkVqbYrj1PEks9ecpOXksbiDAMqSiM9nkNprqXjJqI/1VLbZ+QswOZpgrmP37/RYkgsdxx/pD3O9TdkL+wxCAXed/MoSNmBhkymV2coUyJXqETAjyRDXO0wdQ2EXt3ac6uKZkeSBMOjTw4kDcTMTd8kWPJYIHTCO9Id9jlBqQai7hDcydeKsSCJxv4eAR0eSRIqlIoVyGVuWKQPr2RYh/v+z999hkh30lTf+uZVzzlXd1TlOHqHRSGDM4kUIhDSyDbZhBQ5LeG38YvAajNf2bxeDscE/8IJNsmVjWzyYlQaBjAmSQSQFJE2ezjl3V1VXzvH9o7qr695qJI00o4DrPA/PQ1/dqnuru6fr1Pl+zzlqhYJvvfstmLXPPdLlSlEqlYhGo4TDYba3t6lWq43dPIfD0bJnLMVPI38/Dc1Gklqt1vgf7DmLm4Ph4/E4CwsLvOUtbyESiWC32/mjP/ojXve619Hb23vFr/fEiRMcO3aMz372s41jw8PDnDp1io9+9KMt53/gAx/g/vvvZ2JionHsXe96FxcuXODRRx+94uu38eJFWwFs4yUPuVz+nLIAE4kEZ8+exW63Mzo6KtoVulYu42q1SiqVolAocN1112GxWBpvEE9F/v7uj+/hO//3SWrUd+iKxQpQw+6zcv6RWQBUGgVqnZb4Tner0aIjFt/b+9No6xmBu+QPwOE1MTfVtOd3pIOxS3tEzuYwiDICAXwdVqaaMv46gjYmxtdF59icRiLTe8/r9ZqZmBQTkN5+D2NNz6NSCcxJDBV+r57VpkzCSqWKIBdYayJ2ZpOWfLFEvolsDg96mJzdwmrUYNSr0WqVWK16vPkS1VqNYrlCNl8kmc4hA3a/Ix1uC5MLUvXP3ZIXaDVpWW/qLxZkiEbUUG/zmJCoer1+G7OSsa7PaW4xjRzu97G0Vn+NBrUSm0mL26DDrFbXDSSVCqlcgZpM/DleIROYleQDmnRqJiUGDrelVRHsclpayN+g186U5PlG/E7Gmh5bqlSx6rVcXBF/3w51urmwuoVFq8Zh0KHXqDje5X1ByB+AUqnE7XbjdrtFZo2VlRXGx8cxmUwNMmg0GkX/Fq+U/MGVh1Dvto5MTEzw4Q9/mO985zvcf//9/P7v/z69vb2cPXv2GY+wi8UiZ86c4Q//8A9Fx1/zmtfwyCOP7PuYRx99lNe85jWiYzfffDN33XUXpVLpmuxDt/HCoE0A23hR45nsvjwXkra+vs7Y2Bh9fX10dXW1XO9aEMBSqdQwe/j9/mfk9AX47Pu/zPfvP0+1WAaFvB70DAweCTLeVM3WNexjfmoTq8OAzqDCFbCRSeXxBqzIBAGtUU0uW8TlriumOqOGdLrA8Gh9z0+jU1IsVhgZ8SEIgCCg1qrqKp4A1ECtVZLLFRkc8lCtVCmXq/X9wUKZfKFELluku9fJ9LSYDKh1YuOHz29hQmL86O11i8wgcrlAIiVWgXt7nMzMS8a6fguXm4wmCrlAOJqmWquRSOZIJHP4vWZmFyOiRpEDwz4uTa2jlMswm7QYDWrsdgM2Y/1NtlipkCsUiaXyoixCr9PExILE+dvt5rKEOAa9lhb1T5CJf8YygRbTiFGnZrKpLi5bKGGtaXl8UtwNPNjhYHI1skMQdWhVMnQqGYlsDpNcoFCFeKFIt8vChWXxvXmsxpawaaOu1cAhl7eOSIuV1gzLtCSoGiCRryvEyVyBZK7+/99/y00t570QEAQBs9ksMmtEIhEikQiLi4uiUXIul2NhYeGKyN9+uJIQaplMxqFDh7j77rtJpVI8/vjjV7S/GIlEqFQqLVWZbrebzc3NfR+zubm57/nlcplIJILX672Sl9vGixhtAtjGSx7PhqTVajWmp6dZWVnhyJEjOJ3Oq/bcT4VMJsOZM2fQ6/W4XK5nZPYAePSb5/mPe56o5/rJZQgqJTK5QPeIj3whj7/HjEatwWQzMjO+QTlfJpZP4uvs4tyPZxvPM3gkwJNNXzu9ZhLTWw0ThyAT6OhxsLywt9M2dDjA2Z/s1e1pdUo0evGe38jhAJfP7cWuqNRyErEsFqMarVaFWqPE6TaSThc5MOJFoB54rNGrUKnk5PIlUukCRqNGZA4B6Ow0M7/UtN8mQCYndsl6XCYmZiTu4EEvlybFiqReqxaRJ41aweKOEleuVNmOZdDrVDx5YVn0uINDPi5Ob6BUyLCadJgMahx2A26TnkqtRr5UJpnJk8yK78uoVzMlcfl2uMzMSNS/kW43lyTEscdv57wk+sVm0rEmyRbcbRPJFkpkwwkQwGc3st40ElbIYG19G59Wg0GrRqNRIchlFAolbHot0UzdUWzTa1oaQzwWAxMS5bDDbmppIOlymJmXRL/0uKzMRcTHDgbcDHn3//f2QmO3E9jv91OtVonH44TDYSYnJykWi5hMJhKJBEql8qr1FcP+MTPVapVvfetbDXOb0Wjk1a9+9bO6zn7ZoU/14Xq/8/c73sZLG20C2MZLHlc6Ai6Xy1y4cIFMJsMNN9zwlDVLzQTtuWJ7e5vz588TCATo7+9namqKUCiEWq3G5XL91Iqru/70Xh74yhPUBBl6owatWYferCOTyrO5EiOTrKsqXUMeLjy+0Bj1dg26mbiwR8rsbhNL83vETiaXodapKYT2FKCRIx2MNT3GYtOLHgPQPeBmXDIenp0Rk7b+IW/D+JGI59BolcQTOeJNWX1Dw17OPr4oelzAY6GQLdX3Ailjd5iRq1QcHNJRKlfJZPJodDLmJbEzRqOajfAeMdJqlCyuiseYPZ32Fsdwf69LFCEDdadzM9RKOUsbdRJTLlcJR9Mo5DKeuLAs2v0b6XczvrCFzaDBatSi06qwmLQkcwXyxTKJbIFIIk2lInbDIkC0KdIFQKOUM7cuvn+7ScfEsvj73OW2MLsuJmLDHc6WMOiRoIcLi5tAGRJ1ktpt17IQrV9Xp1TgNOvodFvJFIpUqZErlYll8ngtrZV0NoNOtA8IIKu2/hvUa1r36d50/U8Pfn4xYbcTOJPJUK1WOXjwIMVi8Zr1Fe9eczce6gMf+ACRSIS77777WT+fw+FALpe3qH2hUKhF5duFx+PZ93yFQoHdbn/W99LGiw9tAtjGixrP5BPnldTBZTKZxg7NyZMnn3afZdep+1yDppeXl5mammJ4eLihLnR0dKBSqdja2mJ6ehqj0YjL5RKF2H7u/V/mga88jkwuQwDyxSrZrRSJWA6zW08mXCcTFoeBaHRvz89g1hJvyvuTyWVozRoi23tv5ENHOhg7v+f09PgtTEt2+OxuE7NNu4HBXgcTTSYPqBPA7aZRr8dnYVKS+dfb7xY5gdVqBVtbYgLR1+9mWqLi2Rw2Ll5cFT1Op1NRy1cx6FTodQqMJgXZZIpunwGFQkkVAavNwPi0+E1MOrA06FXMStzB3R12ZiTHBnrdXJTEyljNWjYiYkNELJ2jVoNEKk8ilUevVbKwDtmmVhObUUkuXaXPaUOnrYcHqzVywskMdqOWaCpXr33rcreofx0uM9tzYqOHTttKsIrSfwsChFPix8llAvHCHnktlMpsRVNE0zlRjqBerWQ+V8Snr5s7NEolMplAoVLGZ6lHzFSqNfQqOYsJ8TWsem1LaLRNr+XVIz0t9/xixX47f82dwNeir7harfInf/InfO1rX+MHP/gB/f39z/q5VCoVx48f58EHH+SOO+5oHH/wwQe5/fbb933MyZMn+bd/+zfRsQceeIDrrruuvf/3M4Y2AWzjJY9nOqaNRCJcuHABv9/PwMDAM/rELpfLG669Z0MAq9UqU1NTrK+vc/z4caxWa2PEo9Fo6Orqoquri2KxSDgcboTYqtVqYgsZHvzK4whyOQgCKqOW4s6o1tllIpssERxwo9Ep0Zl1FPMlakEb1WoVlU5NJpnHYtVTrVSxe02EN5IEAlYArG4T8ViWrm47MpmAXFFXAy1WHYJM2NsVzJUYPeijWq1RLlfR6FX4/Fby+SLZbJHObgeTE2KipdEpKW/t0S2vz8zEhJjM9A94RISwvucnVsECHVYmJOHNA/0uLu04iLPZ+j1o9XbWN/b257RaGSsrMUqlKjqNAqtFj99vIVcocWjQS6VSJZsvYbHqOD8ujjqR1AmjVslZXBePML1OU0uG4FBvXf1rRm+nkwvTEkJtMTKzGiOR2VP3gn4rizsKo1ohx23TUytWORr0gACFcoVsscicROlzWw1MSMbLXR4rcxti5XAosI8i2Oni0pJk5OyxMLkhfq3dbguXVsOk8kU24/UPD0d7vIztmHRkgoBdo8Rv0iLX6BBkkCtViOVyeG1Gzkiq5U4dG0Z5FQKZnw+srq7+VMOHQqG4Jn3FtVqND3/4w3z5y1/moYceek7kbxfve9/7uPPOO7nuuus4efIkX/jCF1heXm7k+n3wgx9kbW2Nf/7nfwbqjt+/+Zu/4X3vex9vf/vbefTRR7nrrrv48pe//JzvpY0XF9oEsI0XPQRB4KnSip5uBNzcrTsyMoLf73/G124Omr7SEU+pVOLChQvk83lOnjz5lM0eKpWqsXtUqVT49Hv/iZ88OAlyOcjBN+hGr9eSzxWpySuszcSpVmskQmlGru/h3I9mGs818rJuLj62t7PXNejm/GML1HZ2xdQaBYVyhfDmnoI1eizIWJORxGzTUapUyTRFvIwe7eTymb1ztHoV4bUEZp0anV6FRlvvGc5kCxwc9VGr1ffqNHo1lSokUzlyuRJOp5EpifFjcNjL2LgkvFklF+3rWcxaZiT7gYODHiYlqmF3l4uxHadxPl9mYytBqVIiEs2JnmtjI4G8IuAwazEZNdjtBvKFEgf6POTyJeLpHH6vhQtTT63+IUAiI97906oVzK2KR+cOi5a59bjoWF+nXVQ9VypXsJh0XJoTf3+O9HtZXY/jMumwGrVoNUqMBg0Oo5ZEtkg4lSFfLKPXtCo05WqrWWPXjNH8GpKSUGpBgGXJTp9MgOWmvMFqrUYiX4KUgljT2FAuE6iWqvh1BqwGLWqlAmTwS9eNtNzLixGrq6vMzMw8I8PH1eorrtVq/OVf/iV33XUX3/ve9xgeHr4qr+VXfuVX2N7e5kMf+hAbGxscOHCAb37zmwSDQQA2NjZYXt77d93d3c03v/lN3vve9/K3f/u3+Hw+PvWpT7UzAH8G0c4BbONFj2Kx+JQEcGJiAkEQGBoaavlv1WqVsbExIpHIs3LvVatVHnjgAX7+53/+isY62WyWM2fOoNVqOXz4sEilFAThKRWBv3nv3Xzv3idQ69QIchkmt4XwThSIs8tEZC3TIEaDx7qYahqRBgc8rCzu5f3pTRqUGiXxpt7eoeOdTFzYe4wvaGNrIymKhek74GOmSbXzdVjZ2kqJzhk+HGD84p6KpzeokSlle1mCwNCoT6T+qdUK+oY8pFMFNFolCoWcmlAlkU5TLNYoVwRi8Sx9/e4WYjcy4mW86bnkcgGbw0govKf+uZwGIrGsyGk80OdgekGsnvX12JmRHAt22Fhq2hvUahSoNHWTismgQaNRolTLyebLpLN5Ioks2XyJoV5XSw/woUEvFyRj44P9Xi5JYmR6gw5mm0OkBXDbjWxs770mtVKOWq0g2dSkYdKryZfKFEp7yneP3wYyAZ2mbhAqlqsIcpjZ2CbfdF6f18bs5j4qocT8Mdrp4rIkH7DDrGYlKSaPBzpdXF4JtRy7JDn2qtFuPvpmcbzIixFXQv6eDs19xZFIhEwms29fca1W45Of/CSf/OQn+e53v8uRI0euymtpo42nQlsBbOMlD7lcvm9YdKFQ4Ny5c1Sr1YYCd6XYVeqq+6goPw3RaJRz587h8/kYHBwUZX09nYp48cdTPHT6CQS5nGKpSvdwgIWdvTyzU0cqWmqQP7NLy9zkOkqVHIVSjs6ooVKtYjBpgRrVKnT2uZib3EAmE6hWa/Qd8IvIn0Ipo1YTRMRu8KCfyaZdQEEmIFcoROd0djuYuCTeBQz2OhlvGutqdUrWm3qGATqCdsYuih/nCxpYW90jqEqljFwqT9BjRqtToVTKUaoV5PJlOgNW4okcyVSeoSEvlyWjZavNwFZkb89RLheISQiLxaRmbklMgHq77MwtSUmii4s7u4yhneccHhATU5NOhbImcKDThUIpp1KtkiuViMbF+3B2i64lMibos4rIH8BQl4txCZkc7HK25A92+22cnxG/doNOzQXJ3uCBHjelTBmnSYfNpEWnUaLXqVHJ5cSzebYS9R2+yj4fsPL7qOoKjRYk3894KtNyXrbY+thfvuHFb/64muQPWvuKc7lcgwzOz89z+vRpMpkMNpuNr3zlKzz44INt8tfG84Y2AWzjRY9nMgLO58UjuEQiwblz57BarRw4cOA5FcFfSRTM6uoqExMTDA0NEQgEGnEOTxXxsou//u1/5MwPpkBe/2d56OUDJONZAgM2ZHIBrd5APlMinylQA5AJJHJxAEp5MDk0rDY3dxwPMn5mqfG12W4gGkpiNmpQqRWo1ArcnTaS8SyDo17kchlypRxBJjB0wE+5WKZQKGNzGkWEUCarq0vNP5LObjsTY2Ji193vFoVJyxUykknxz8liU7G+JiYQA00O4l309ruZm9sjRlazhnQsR3+nA7VGiUwGMoWMaCKL0aAmtTO6Hh7yirIBAXw+GzHJWDcWF2fw6bRK5pfFhNDjMjE5Kw2otjAmMZscGPIyv7CJRiHgtBkxGTVYLFpS2SKZQpFoMksslUe7z7g2kxfn6AkCbG6L702tlDO3Jiaw0sxAAJtpL4A6mswSTWZx2wyE5kMN97JMJnCw00WlWuNYp5eqUCNbKCGTw8SGJObFZWEhFBcdC9gMrMbEDmG/1dDSVNLjsnK855mvXrwQuNrkbz9otVo6Ojro6OigUqmQy+X4whe+wDe/+U3K5TL/63/9L17/+tdz6tQpfD7fNbmHNtrYRZsAtvGSh3QHcGNjg8uXL9Pb20t3d/dzzq56JgSwVqsxNTXF2toax44dw2azPaNw51184p138aN/O4/eoscbtOPstHPx4fpenyAX6BoJMLW7fycI9B3uYLaJJA1f181EUw6f2aFlZkxsQHD6zMw27dl19jk5/5P5xrgYYOBQgOmmujeHy8TUepxivl65ZjBp6exzkUrlsB3wIcjq6qhKq6JcqZJM5EinC3j8FiYlO31DIz4RIQTQm/TEEvHG10ajhjlJ40hfv4vZOTHxCnQ6Wkhid5+TlcU68dBrlbicJihVOTTgpQbkiyVqwPScJC+w383krMR9bFWysik2pVjMWlHUDIgdvgBKhYyFHVWvVK6xHkqSyRWZW9mmKBrXWsklChzocKFUyilXqyiUcmbWxIrgSLebMYm5ZLDL1VorF7Bzflb88+50WVqcxG6rkc3YHuGuVmvIZTLGFiQkttuNoabAZTVg1KlRKGSoVALpdIZEsUxp53fGZmolgEqhVS3/pRe5+re6usr09DTHjh27ZuRPCplMRiQS4fHHH+eb3/wmTqeTb37zm9xzzz0YjUbuvPPO5+U+2vjPizYBbOMlj90YmFqtxszMDMvLyxw+fBiXy3VVnv/pCOBurmA2m+WGG25Aq9VeEfl7/NsXePjfzyMo5GTTeTqHfVx8eC+seehlvUw8udj4euREN+NP7il7wUEP001jVYVShlqrIRHdG792DjlE5E+5E77cTP76D/hF5A/AZNMR2dmxK+TLGEwCl88vU2zu9j3SyYWmPD+1WoHFpEWrUqLWKustEjIolyp4vWYi2ylKxSq9A05m58SEpyNoY2xMPH7OZMWqmMWqa2kY6etzMdOU8ZfLlTCZ1A3H8C4GBz3U8hVcNj1mkxatVolKo2Swx0UynScSTaNSKdiOi0eYNrOaSQlxHOhxtuQK+tx6FjfEhKjTb+WiRHHU69SMSca6fV0OsokCFr0au0WPQa9Cq1Yx2ukinsmxFc9QqVbZkARBKxUyFiTOX61a0RI2bdCqmJKMnE36VuXQotcwuRKmVKmytBUHwKxXky4UqVRr9T1Fkw6fzYhQFTja4SFTLBFJZylXq6ylxCNitVyGNb/N1NQUTqcTi8VyVTLzrhZeCPJXq9X40pe+1OjdfeUrXwnAyMgI/+N//I/n5R7aaKNNANt40ePpCNSuAnju3DnS6fTThjtfKZ4qDDqbzXL27FnUajUnTpwQZRI+Hfmr1Wr82a98msmzi9Rk9RF192iA5bkQJocWk9WA3WenmC8xcl0XCKDWqigWy4werzv45Ip6M4jerIVaXdHRm3XEoxm0unpXsEwG0a0MUGM356RjwMncxB6hMZg0bEkcqkOHAkxKFDuzXUekaSRpsemYl7pw+11MSojk0EEfU01kzGrVQlVgsM+NUiWvj7QF2I5mUCpllEp1FWl42Mf4hPi5vD4L483qolBvwWiGwaBmbkFMdvx+C1Mzm9RqEImkiUTSDA97OXNuzwEpEwSGBlwkUnk0WiWCTCCXL6JQCcRSO6P3HWQlTlqZTCAq2Y8z6FTMLEncwDY9E/Pi71mn18LMcv28VKZAKlNgIOjg8sweSZQJAseHfKTzJfxWE9VajUyhiMmo5cyM+Oc00OFs2Qfs9TtaFMEer63lWJfXyjnJMatWRiJXf/W1GkQSWQIOc8t51/X7iKRyGHUq5HIZ+XKFI90eDgz3Eg6HuXTpEtVqFbvdjtPpxG63o1K1Zhk+X3ihyN8999zD+973Pk6fPs2rXvWq5+W6bbQhRZsAtvGSR7lcJpVKoVAouOGGG676G8puGLQUsViMs2fP4vV6GRwcbHR6wtM7fQH+8tc/x7nvT2LxW+nqcqFQyVma3SKXzJMDLHYzYz+Zp7wzOrS6TZSKFdKJndGkINB70M9cE7HqPRio7xHuQCaX4e9xko5mkckFdAY1nk4ziVgat0+HSq1EpVJhshlIJwuYLTrSqTzVWo2VRbGCNHjIz6REUXP5rEw3kTGtTsnGmtj4EexxtDzOH3RwWWIG6R1wsbUcQxDAZtHhcBmRCzUOjPioVKpksgWQCUxOipWzoWFvS59wd5eDS5KdRI1WJdpblMkEIlHx/qFOr2JiepNc02jX6zGzFU6hkAnYbXr0OgVqtYxkJofboiZdqJDJlen0GVlYF+/r9XTaW2JkvE4TkZjkurrW39mKZO21WqsRSWRZ3ozvHdxxDZvkKpxWPQadGplcQIYMr9VAKJ6mUqvHsixL9veUchmLW7GWYwubkugXGURz4g9AcpnAouT5ZAIshROEE3uvTRDgT9/4KlwuSyMzL5lMEg6HWVpaYmxsbF9X7POBF4L8AXzta1/jd37nd/jKV77CzTff/Lxdt402pGgTwDZe0tje3mZychJBEDh+/Pg1GS3tNwJeW1tjfHycwcFBOjo6rsjsAfDAP/+Iiz+eQa5RkQinqVUBpYx0rE7urC4T8e1sg/wplHL0Jq3I5DHysm7Gzyw2vjbbDWztxMXsYvhYkLEdI0i1UqNULBOL5NkO7REVb7eF+XGJ8/RIBxurUQKdVrQ6FRpdvTt2cNhLLl8kGc9hd5tE5A+ge8DDWJPLWJBBUeImtdh0zEyLr9c36GZ2Z6xbq0E8lsUftLWQxL4BD3qlAptdj96gRqFUIFMKBANWItEMmWwRi1XLlMSY0RW0t+wRDg16GZOQs+6gnUuSNhSzWctGKAmVWiNyprPDxtr6ntNXq5JRzBTodunRaFRUBTnZfJElSYi01aRtCZH2OIxMSdpHOn1W5iTj2r5OhygzEGAw6GJyx+iRydVH5SM9bsZ3ImiUChl+q4FOn5VMoa4cJrJ5NuNpBjsdLf3DQ0EnFyXH+r1WpiQB0UMdTi5LaumGOpyMS8bJ1/UFCLosja8FQcBsNmM2m+nr6yOfzxOJREQB6Ltk8GrVq+2HXfJ3LQ0f++Eb3/gG73jHO7j77ru59dZbn7frttHGfmgTwDZekqjVaiwvLzM9PU1XVxcrKyvX7M2imQDWajWmp6dZWVnh6NGj2O32K9r3K5XKvP8XPsraXIiqTE61WkOlVaI0qojuqEcqjQKjw8TWyjZqrZJarUbfoU7Gm/YAg4MeJs/vjS4RBGxeMwtNrRwdvU4mz+8ZQwB6RnxMNB3TGdTkUmKC5uo0MHmpTuISsTrJGT7SwUTT3qFSJUerVuKy6zGatai1KtQaBdl8mc6gjVgsSyqZZ2DEw9S4mIy5/VYmx/aIl0wmkEpJ3MFWLTOSPb/uXiezO+PmzE4m3uhBPxfO7JFEs1FDX6eDXK6EfCcLL5nK1/cQmyCXC2xKDB1Gg4YZCUn0us1MS5y/vd3Olgq53m7XTvXc3usI+g1kYjk8Vh1Wix61WoHeoGY1lCQUSzdURrtNz0ZUrBzuF+gsyFp/t6TkGsRO4lK5ylo4iSCXsbKzzwf1cXI1X2HE60CtVlCp1UjmimTzrc+Xl0qRQLbYGru0X+D0L9301OYPjUZDIBAgEAhQqVSIRqOEw+FGvdruqNjhcFw1Zb+Z/Fmt1qvynM8E3/72t/mN3/gN/vEf/1FUy9ZGGy8U2gSwjRc9pKSqWq0yPj5OKBRq9FMuLi5es+vvEsByuczFixcbe4Y6ne6KyB/Ap3/7iyxNbRAY8mN2GCkWiuSKBbLxIkaThny2SNeIn+mmvbShl3Uz/vg8giCgVCuwOg2USxXcPgsqtQKlSoHFZSSbKTJ6rHOntq2MQq3GlC6QjGWplKv0jHhF5A+gs8/N5IW9YxqdkmJe/DrsHh0TF8WVaQMHA4ztuI53G0WCfS4WmxRKm13P9laMYNCC0ainWqshKGSsrcURqFHb2UccPtDqDvYEbEw0K3ECjb3AXWi1SpYk2X1anYoL51ZEQdC9fS4WZkK47QYsFi1qjRKdQcPWdopSqUJyh3x2ddq4JNk3tFhanb/livg+BAG2JSNdpVJGJFGkWq0R3s4Q3s6gVcupCjLyOxl5drMWv9eCUBM43Oshky8RiqfRapQtimDAY2Z6WawIdvmszEviYHr8NubXxcf6OuwtymGP38bkUrjl2NxSBIdBg0ZRw2IxYtBrCaUy6NXKRkdw0GVhXjIm9tlNTEtMJx6rgZuGgzxTyOVynE4nTqeTWq1GKpUiHA6zsrLC+Pg4JpOpQQYNBsOzGhW/UOTve9/7Hm9961v5/Oc/zxvf+Mbn7bpttPFUaBPANl5SKBQKnD9/nkqlwsmTJ9FqteTz+YYL+FrsD8lkMgqFAj/5yU9QKpWcOHECpVL5jM0eUFcO//n/d5rZC4uo9FpWZ7ZYndnCN+xkY2bvzXT0xj7GHt+rcfP3uho7frVajWKhjMFqYK4pAsXf62Thx1tUyntj6uHrupl4ov48giDg8Jqplqv0DrpRqetNESq1glg0i91lJL6dplKp0T3sZbyJJMoVMuQyJdT2IlHMdg1TkgiWwYP+FuOH1iSwvpxleysHREGAjqCDxFYKjVqB3WXEYjcgFwSGh71ksgWi2xlMFh1Tkuy+oWFvS+dwT7+LyxLiaLXpCTWNtxGgUChRrdaIhFNEwimUShk6k5b4Tliz2aDGH7AiVGocHPKSL5SJxbMo1YqWeJieLgdzElPHUL+HiRlJtV2fm0uS1+D1GJlb2duPjCVy+D1mLknCrPtG7BhVKvQ6FQiQKZTQGzSshMREdL8cQZWq9U+6VP0EUChaj6mU9cfG0nVCvBEvMNLtZmmlTiidJh0Oix6HVY9ZqyGVz7MRT5MrlnGadaxHxfd3x8lRZPuols8EgiBgMpkwmUz09vZSKBREo2KVSiUaFT+TnM8Xivz98Ic/5Nd+7df49Kc/zVve8pbnbcexjTaeDm0C2MZLBslkkrNnz2KxWDh48GDjj35zX69CcfV/pcvlMltbW/h8PoaGhqjV6grbrtHj6f6g51I5/p/r/phcpoBCr6W4M/qTkr/+Y0HGn1hsfK03a8nlSpSaI1eu72as6Ry1VkmxWBGRv74DASaaAqBrtRp2j5mpJqVPq1eh0WuI7ey0CTKBocMdZBM5hkb9yJUyKpUqOoOW2UkxsTOa9SRie/et1shZXxUrQhaHmo1VcRvG0IEAkzvEsVAos74Sw2I3cLGpXxgg4Leg8lnQ6etVeMVimXKxgkyA6m4LilnLjMR9HOiwMi3tGB70tPQODwx5udykLqbTBRQKOZclRpXRES9KBIxGDXKFjEKpQoWSSL1EgERSnBeokAusbYqNMGqVnK2oeMytUcmYkriBLSYtYzOblJp+nnaLjqXlGBaNCqfNgE6vQqGUk8zmMenVjYo4j93A1JJkv9BuZGpZrPS5bYaWY06LnknJTp/drGOq6Vg0Wa/Ym1/fptSkggadZiq5Csc6PZRrNRL5PNF0jjdc31rN+GyhVqtFXdmxWIxwOMzExATFYlE0Klar1S2Pf6HI36OPPsqb3vQmPv7xj/Prv/7rbfLXxosKbQLYxosegiCwubnJpUuX6OnpoaenR/SH9FoSwPX1dcLhMBaLheHh4YbZQxCEZ7xzePdHvkYhX6TneC8yAXL5HIIC5IKa/kP10ajerCOXK9F/OIBMJiDIZGj0GoqFEp6AlXKlilKpILGdwWI3kIxnqFZqdI/6mWwaFxvMWsKS+rW+QwER+QPoGvQy0fQ4uVwgtp0WmUicXjPz0Q1KxQoarRKb04ivy04uW8J4UEcmnSe6ncbm1rM0KyaARrOBeGxvFKnWKNhYE5/j9JhE0TAAfUNupiTGktHDAcYurqFQynG6jBjNWsw2PYlkjmQqRyicolSqotaIXb7CPuRMo1GwvCIekVrMrbmCXq+J8ckN0fP5vEbWNlOolHLcLiNGoxaDSUM8lcNp17O9naEKDPZ5uCzpAR7oczdq5RrHej1clJBrs0FGLCU2HPncFrYTG414GIADg17m5utKpM2owWEz4HIYcJkNpPNFNmMpsvkSzn32C912I1uS8GarUUUoIR5jd7jMbCfFJL7LZ+W8JITabta1RM7ccmIQs/7KqxefCeRyOQ6HA4fDQa1WI51OE4lEWFtbY2JiAqPR2FAHjUYja2trLwj5e+KJJ/ilX/olPvKRj/DOd76zTf7aeNGhTQDbeNFja2uLS5cucejQIdxud8t/3x3BPtO6tmeC5lBpj8fTiIK5kn2/1HaKT737i0Q3E2gtRqYenwPAEbSQCOcayp7BokNj0rG9EW88dvSGPs79YLLxtcGsRalR7Sl2gsCBG3qJhpL0DntRqRXI5HXSuL2VRKGUE4uk0Bk0hCT5ft1DHhH5Axg80snYWfExvUnb2O8r5ErEt9NkMkUSTdEp3k4b22spAgEzyCrUqKFUy4nF08gVApVynUH1DfsYk+wfmq16Qlt75ESQ1dW4Zuj0KpZ2iE65VGFjLU6lXGV2JtTY85PJBA4e8FMsVTg44qs3kqTzWCxaxiRksnfAw2VJPIw/YBUpggBmk46NTenuX/3nVSpVWF2LA3ECAevO/6+PXz0uI0pBxqEBH/lCiUgiQzKdZ6XpZwt1RXBhRbK/qFGwFRW/fq1azrSkG9igVzPd1Cuc2IntWd2IUWhqGwl6zZRzFY72eChXaySyeRLZAtMS9U+tlLEoUSxVCjlzkl1CuUxguclIAoBAC5kEuOMVz0/zhyAIGI1GjEYj3d3dFIvFxqh4aWmp8Xeht7cXk8n0vNwTwLlz5zh16hR/8id/wrvf/e42+WvjRYk2AWzjRQ+n08mNN96IXq//qecoFApRHdxzQblc5tKlSySTSW644Qa2traIRCLk83k0Gs0z+mNeLJR4+6E/RK5SoLebiO/sb5ldBvLpSoP8yRQynJ0OFpvMB72HOhl/Ym8PEEHAHXQyd3nPiGFzm5i7vEYus0cYho53ceahicbXMrmMYL+LTCqPr8OKTCGjUq6CIKDVq8hl6m5RT9DGpMTkMXSkg8kL4mNdg17GJcRRpVGQWc2T2TFSqDQKdEYtye0cggAmsxqTTU0mmaS3306hUGM7ksLjtzIjyfMbPuhn/JK03s3NmOTeLA4DW+E94lit1kgl8yw3GULkcoFyvoTLpsdq1aNU1wO6s+kCcrlAZcfZarXqmJppVf+mJDt9ToeWrbBYTezvczHTZHopFsvoDWouXBLf76EDPpLpAh0OM8ggkythNGk4PyF+rf3dLi5IFEG/x8Tsclx0rMtv5ZLk/noCtpa8QZtZz4Vp8fMdHvQRiqWxuLUolTISqSzIysyHMuyGhAMMBp1cmpeM04MuxhYltXQBB1Or4p3I4aCLoc6r08JzpVCpVPh8Pnw+HysrK0xPT+N0OllbW2N+fh6bzdYYFWs010ahvHTpErfddhvvf//7ed/73tcmf228aNEmgG286CGXy5+S/O2eczUUwHw+z9mzZ5HL5dxwww0olUpsNhtbW1s8/PDDWCz1QFuXy/WUbyBf+/R30Jk0dIx2kk3nUOoFtHotJouZUqFMjRq1GugteuKRFJ0DbnKZInKljM3lbWpNs8fR63sYayKEMrkMvVknyvKze80sSghA36GA6HEAI9d1M76zH2i06LC5jJidRmwOA6VihWQiRz5XYlUSAu3vsovcwgBDhwONuJhd9I/4G0pfrQapeAGX18rcZBNxEARK9gLdXTb0Bg3VGuRyRcJb4lGlza5nWmKQ6AjamZIc6x/yMDMlISYjPsZ2lL7wzvfpwKEAi+ObKBQyPC4jJrMOs03HdixLNJ5heztNDWFf9c9g1BPaFhPAQlHygUOAeEJ8jiDA5laKUGTvtcllAmaLDodWi92uR6NVUqnWyOdLKOQC5R1yqlTICMfEe4NyGcxKdvUUchmLkvG6Qi6w3BLoLLAairMdz+45mwVwWPXoUOB2GDHq1Qiy+nqDSasm2dR2kiu0Rr+wD7n5xVccaD3vecbq6iozMzMcO3YMq9VKrVYjk8kQiUTY2NhgcnISg8HQGBWbTKarQtTGx8e59dZb+d3f/V3+8A//sE3+2nhRQ6g1v9O00caLELVajWKx+JTn/OhHP2J4eBiHw/GsrxOPxzl37hxOp5Ph4WGARgOIIAgUCgVCoRChUIh4PI7RaGyQwV2CevEHE3zpI18juhFHY9KxuqPUKFQK/IM+lpv2wEZu6BUpfUq1AlfATmglitGmx2DW4fBbKRRKgECpWCaXLmDzmLn42HzjcYJMoKPfzXLTHpvJrqdShUzTDlzXkIel6bCIXI68rKtBCHcxfCxIZCuJ2aZHrVFSrlZRqlVMj69TyNVJgFanQqmRk4zvPb/TYyIez1Eq7hHx7gE3CzNiwtIz5GJuSjyGHDzkZeryBnanAYvdgEZbj2pZXY0R2kpSLtd/Dl39LhaaVDdBEHB7zWw27T0qVXJ0BnXD5QtgMKqpVGrkcnskxm7XE0/mGs+t0Sjp7XdSQ0aNKpFokkSqiMtlYklicunrdTE7L3kN/e4W1/DwoIcJSSj16JCXsX2OXZ7aQC6X4XYYMZu1mMxathMZIvEM2zvE8sCAl0szElLs1rESEu/qjfZ7uDwnvsZIr5txiemkP+hoiZfp63AwuxMbYzVpcVoNmE0a0oUisUyOjWiKSrWG21ZvGml+B7EYNNz7v+9EpXx6V+61wjMxfBSLRba3twmHw2xvbyOTyRpk0GazPatd4qmpKW655RZ+8zd/k4985CNt8tfGix5tBbCNnwns9gE/W2xsbHD58mX6+/vp7OykWq02iNKu2UOj0dDZ2UlnZyfFYpFwOEwoFGJ+fh6tVovJYOYv7vwc5WIZ36CPpZ2xriAT6D3SxfS5PaLVNepn6rx4nNp7qJOpnbDn2FaSUr5MOpUn1hT/0TXs5dIjM2h1KqwuE3qzDrPTSDqRIzjoJhZOkYxmcQVszDZFtag0CtLJgoj82d0m5iS7b12De/uB4Z3dwZHjQS7/ZB5BALvTiNVhQG9RE9qKodUbiUVyFAtlzHYD4dDePpggE8jnxaqRRqskvCU2GxjM6oZCuB1Osx1O4+uwMXFxjWq1hlwuw+sx4QvayOfL9Pe7iEYzbG9nGBrxMiHZ8xsY8nBZElPT1e1siYxxec2iKrh8vkS5XGNqUtJ/HFQzFHSi0iopVyrEkrl9qwF3mzj2vgGQSOVajm3HxWRNECAcrX/fKpUq61sJNkIJXE5jY9Rt1qtxOQyo5TIO9rpJZgqsR5KUKlUK5VaiEYmnWo41B0TvorrPx//miJhYMkcsmWO0z8P4XP1npJDLCDhMdLot+CxGMoUSoUSaeCbPrSeHX1Dy90wNHyqVCq/Xi9frpVqtEo/HCYfDzMzMkMvlRKNirVb7tNedm5vj1ltv5S1veQsf/vCH2+SvjZcE2gpgGy8JFAqFp/zvjz/+eCMm4kpQq9WYnZ1lcXGRw4cP43Q6rzjcuVwus729zZc+/DUufW8Si99CIVMCAXQ6PRaXhe3NOMV8iVy6gFKjJJ8rkortEYGRE71MPC7e++s73Mnspb2xq96kRaVVEmsa/QZ63WysxkQxMKMnekhEMxjMWmQKeT070KzjwmPz1Jre8XtGfcw3jVMVSjk2l0lkGjFZdZQrNbJN5gynz0QklKrX11EneqPHgxTyZZQaBaVihUQsg91rZvy8eEQ8crSzxQwydNjPpIScOX16wht73x9BEPB2WFlf2VPijGYNnoANhVIOAqTSBRLJHOVajXRTs4jJrKVQKFNoitOxOw3EYllRYLTXa2ZzKylStDo6baxIXMPd3U5W12O43CZMJi2CTEChkjM1FxKRwIE+F9OSZpHBfjdT0mN9LialNXV9bibntp7yPJlM4NCwj0K5gkIhJ1sosRVLYzIoWQ6JCWDQa2GpuUMY8LvNrIbE5g+nzcB2PEu16Ztg1mvIFEuiaBq1So5CLheRSptZx2c/8Iu4bAZeCKytrTE1NfWc3b67o+JwOEw8Hkev1zfUQbPZ3PI3YXFxkVtuuYXbbruN//N//s81ayRqo42rjbYC2MbPBJ7NDmClUuHSpUskEgluuOEGDAbDFZM/gG9+4Xt85x++z8ZCmJ5j3cw1GSX8IzLO/sceCVJrleiMdnKpKt5OOzqTZqcRpMzA0U6y6TzxcIrOYT/jj8+LruPrdTHTpBoq1QpKlaqI/FldRubH1kXmkM4BDxcuraJQyHEELJisOow2PfFoBrvbxPZWXWEcPNLB2JPicbC3y8GUxAxSFSoN8gd1IrK1FhfFz+iNaor5MoGAFaNZiyCXUS5XWZU0d/iDtpZQ6Z4BN/OSsbE/aGJ1STyG7ehyMCbpCj5wNEBoK0VHvxuFSk6+UEZn1HBBQjpdLhORiNi9qjeoqYmnpmg0+/yJlAkUixVWV2JA/Z66uu3kk3lcdj12uwGVWoFCrcBh1RNpagnZb4/umR4rFMW/39VqjVSm2BJMHXRZ0Hrr1Xy5QoFoKkepKFYdoT7elRJAn8NEWNJqEvRbuSAZOw8GnVyclYyxu90vefIHoNfr0ev1BINBSqVSY1R87ty5eqi6w0EikWB4eJhsNsvrX/96brnlljb5a+Mlh7YC2MZLAsVikaf6VT1//jxms5nu7u5n9Hz5fL7xB/3IkSOoVKorjnkBiIUSvOeGPyUVTdN/oo+Zs3sEqu9YFwuX16juqkwC+Ic9rDXtvxmsepQqhWjM2znkIxZOYXEY0Zu1KJRy1AY1m0vbhNdijR27kRO9on5gBKGu6jVl6ylVcqxuM6GmHTajVUcNSO/slam1SnoP+KlRD7XOZgqE1xM4A1YWp8VEzNdjYn1RrC6NHA8yLomQGT7Wyfg5MekaPORn6vIaVocBu8uEWqtEpVWxvBBhO5xsXF+q9MkVAkazlnh0b5yqUstRalSkk3tKn8GooVKtiPb8LDY9mXQBjVaJ021Cq1ODXCASTbO5mWiMQF1uI6GQmBAGOqysSnb/gkE7i8tSRdDOgoTY9nQ7mVusEzOdToXbbcLhMJDOFkmkc2yEklSqtX2bRbo7bSxIVMdgh5VFyb10+CysSDIfPS4jm5GUSMW0W3QkM3nMRiVGvZpSpUSxViWeq5At7JFKjUqBXKLqyWX1IOyYJE/R7zKxJqnI+///3hs4NnRlCvzVwNUkf0+FarVKIpEgEonwnve8h4cffhiXy0UgEODuu++mv7//ml37hz/8IR//+Mc5c+YMGxsb3HfffZw6deopH/ODH/yA973vfYyNjeHz+Xj/+9/Pu971rmt2j2289NBWANv4mcCVxMAkEgnOnj2L3W5ndLSeV3YltW67WJ/b4u/e/yXcQQfBwx2ENrbxD7oRagJqrZqt5e098gcMXd/LpISwWVwGVptIlt6sJZ3MkY5nSe/sirk77cQiKYr5EoJMwOm10DHooZArMXikg0QsS3gtxsDRIBPNzw8MHOkUNYcA+LodTDUpYoV8mUyywFKTMUGukEHFTN+gG5VGQTyRIpspkk6Iv8cWm140RgZw+y1MSZS5zj5nQ+mLRdLEImn6RryN7EGtXoXLa8HpM5NOFaADttbjVCo1BkcDjEuiYDwdJpbm4qJjwV5HS2SML2Bl/NIapVKF1A5ZHDrgZ3MphlqtwO0zo9LIKNcKyD1GItuZRuewTqdCCsU+VWuyfarWaKpAy2aLLCxEkAkCczvGEYVCht9jxm7Soh/wkswW2AwnyRfKKJWt19BoWu/FaNACYgJotxnYCIsJulEvYztRJRIrEInVleHhPiehrTA2oxK9Vo5arcJg1LIgcWIPdrsYkxhH+jrsDZPILoIe6880+YP63war1YrVauUf//Ef+eVf/mU0Gg06nY7R0VH6+vr4xCc+wWtf+9qrfu1MJsPhw4f5jd/4DX7pl37pac9fWFjgda97HW9/+9u5++67efjhh/nt3/5tnE7nM3p8G/850FYA23hJ4OkUwImJCQRBYGjoqeundhtFent76erq2tfs8Uzw5Y9+jXv/6htUylX6ru9h7uweobL7LJTKVZLbaXQmLRanEV+fm1y6rqwU8iVi4SRmt4GFC3tqnSBAz6FO5ptGogqVHGeHnY2FPdVQb9KiUCtINI0wXQEbKq0SvVmHQiEnnyuBILAwtSkioX0H/cxK2jeGj3cxcVY8+h15WTfjknHw8HVBFiY3cQes6E1aqrUaap2ay08uNnL1AHqGvcw1Z/wJ0NHjYGVhT+mS7RDZraZ9Q6VKjsGsI7bzuhRKOR1ddnQ710ql8mxtJlGpFJQrVZHSp9UrKJUqlMtNJhengUR8z+UL4PKYCIfTVJt2Ic1WFclEkVqt3pvr8pjw+CwUSxXS2QIbWwny+TKBDisrq3v3C9DRYWNlLdpybFmi1gUCrWqiz2dhvSkgWiYTGBhwUxPqrz2bL7EVSaHVKQlHM6K9PKtFRzJdEO0wGg1q8qUyxaZRsVIhIJfLyDcdU8gFDAaJqieA1aQmlixi0CqwW3UYDFo0OhWLm3FC8VSj/m6428WEJJz6//3Vl3PHzz+/8S/PJ/lrRiQS4XWvex2jo6N86UtfQqFQkEqlePDBBzlw4AADAwPX9PqCIDytAviBD3yA+++/n4mJvVzQd73rXVy4cIFHH330mt5fGy8dtBXANl4SEAThKQmgXC6nVNonp2wHtVqN+fl55ufnOXToEC6X61nt+wE88MUfcO9f/TuVcpXu450i8qczaVFoVGzvjPWyyRwWl4nLP56h0GwQON7Fwtg63qANg0VHVaghKGBraRuosRvKO3AsyHizOYTWXUBBENAaNSw1RczIlTKcATsGgwqHz4JGr6ZcqojIENTHwcuSIGS7x8ysxJThDdqZurBCtVJjaSduJtjvZvLsMgqlHH+HFZNFj8aoJrSRQKGUUd5R0gYPBZiS5AUOHepgXJIrOHDAz1jT2LhcqqAzqBlriqmRyQX6R33k8yUEuYx0psDmeoLuPndLiLTOoGA7In69VruBLYnK5XCaScTrBLtSqbKxFsdo0jK9Q2JlMgGvy4jXbsJq1JLJldjYSpDNldDqlEih1baqdQZ9az+t2aRhvUk8rVZrCILAhLQyLujAbtChVCnIl0psbacIeC1ckpzX1WFvqZbr8BqZXxWPagd63YxJgqT7u5zM7Iys07ky6VwSmylHNFn/N2XQKPG6TFjMGvLlCn6HkY3tFNUa6DRKbr7h2pIeKV4o8heNRrntttvo7+/n7rvvbsTFGI1GfvEXf/F5u4+nw6OPPsprXvMa0bGbb76Zu+66i1KphFLZ+nvbxn8+tAlgGz8TkMvl5PP5ff9bpVLh8uXLxGIxTpw4gdFopFKpUKvVroj8lYolvvap73D2Py7Rf1035VqJbLpIYMBNOpYjncjg7nay0NTYYbQZKGSLIvLn6rSzPLVJqVBiY2ck2DnkY20+RKVcRalWYHEb0NnVJGJxPEErsXCaQrbE0HXdTJ5ZFN3X8PU9LYaRoePdjO0Qx+RO1MnI9d1Mn1tGo1fj7rChN2nQGbWszIXIpvONvTGLw8i2hCSptEqqTSqfIAgNV2i5VGFtPsKmfBubx0x4PYFcLsMfsGJ1GZCr5ASCNjbX45RLVbQ6FSuL4r03g1HDgmTf0GTVMjshJipmq56xs8uUmirPHB4T8c0Uw4MeZAo56UyeYrnC2rKY+NideqYk7SNuj4n5WXGeny9gYWZq77zdKJqzTyw0vkeCAMNDHqjWODjkI5svshlK1omjJAvQ5TIyLSHZDruhpYHEYml9rMGgZmxik2JT6LRGo2B7I8VghwONRkm+VGY7nmFJokQiQDrXGleTyrQ66gVa/w14XDaiyfr95PIl5pe36ekwMbdDKDVKOR6XiVee6EO3z4j6WuGFIn+JRIJTp04RCAT413/91xc1idrc3GypzXS73ZTLZSKRCF6v9wW6szZeTGgTwDZ+JvDTdgALhQJnz54F4OTJkyiVymel/OXSeT7+65/lzHcuAhA44GF9OlIX63YwfLKf6EaC/sOdqLR1U4lKq2bqyT1yptapkMll5JvehHf3/io76lypUKaQLZNPl0ntOjIFcHZZyKRT9B8JUCpWCa9E0Vt0zF4UK2m+XheTkpFu56CHiZ2Rbj5TYGlyg55RX0Nd1OhUuDvtOP0WtsMpjFYVqVgBEBg62tnaAnK0s7VP+Ggn42fqxyqVKutL21gdBi4+XO9AlitkBDpseLscZFJ54qYsm2txqtUanX0uxiVO3UDQ0XLM47cysS1WE+0uE5OX1thoGrEOHfaDvYLFbthp6MggV8moRcQqssWmY2tLTBSNJi3ra4l9jsUbX9dq9fibSWkGYZcTq16DQiWvK4WhBA67gZAklsXjMRGJSkwnfhuXxiVVeF0OLklG9n29Li6Nr7PZZBwaGfKyuh6j32elVC6ATI7RYuDSlFQltLGwKiaKHqeRmSUxCTbp1Q1FcBdKhYzNpjaUQqnC0lqMGw48f7t/LxT5S6VS3HHHHdjtdu69917U6lZF98UG6d+23QlKO6OwjV20CWAbLwk83R+t/WJgkskkZ8+exWq1Mjo62iiGhysze0TWonz4Tf+HhYt1cuMZcrE5uy0if6M3DTL2yAwAWzvj3+GT/Vz4/ng9OsJvxeo2Y3aaiIeTmF1GEjukwNvrZrY5FFoQcPiszDeNTQVBQK3WsDy2pxAJMgFXwIzZ5kapUpBNFwit10lQpWnUq1DKKeRKohG6Uq0g2ZRDmM8W2VyKEA0nSUXrx3UGNYF+N0qljP5RH+HNBPHtDHqThhVJC4bRomNBoq5ZbHpmm4KmK+Uq2UyBC4/ONbqQlWoFvSM+hEqVoVEfse00oc0EDo+ZKWlws8/C1Jj4mNtvYVpCkDyB+rFqtcbmDmnzBqxsrSdwWNRo9ArkSgWFUkmk9AF4fObG6LdxDa+55TyX28i05JjdYeDypTXRXp7FqiMeSjHS50KukJPOFUilC0zPitVOrVbJ3IL4e6pUyliSOI4FAdY3xeQUIJ7IkkzlSTblH/bIlFjValxOI1qtkkK5gmqfWBunzcimJBKnK2DjooQ8DnS7uCyJfukNmFieH2N7axGn03lVa9WkeKHIXyaT4Zd/+ZfR6XTcd99916xD+GrC4/GwuSn+WYVCIRQKBXa7/QW6qzZebGgTwDZ+JiAlgFtbW1y8eJGenh66u7sbES9wZWaPufOL3P2/v4pGr6b/ZV0UqgWUqJF1yomsRSkXKwzf0N8gf7sYubGf8cdmgfon7/BqFFennSd2FEQAk93A4HU95DIF+g51EFqNkoxmGL2hl7HH5sTPd6KXsZ+Ij3Uf9LFwUfwmPXJDD9GtJENHOhDkMpLRDGaXkfHHF0Xn9R/uaNkt9PbaWWwimNl0AYVCzqVHZhvHzHYDfYf85LIlctkim6sxcpkigR4HE5LYF0+njUlp/p7PQiy8R2xLhTK1Wk1UR6czqAl02HC5TBRLlTrxjGWx2PSEJLEnJouOzXXpMS2bTeYSAL1Jw8ZanGg4Czs8a2DUR6ySw+rUoVRDpVpDa5DX5b2mkajVqmdLcl27a6+lYxdur5ntbXGGnj9g5fLlNVFV3cFDAVRCGqtVh6CQkUoXMFo0LUrfQL+HMYnDenCgtVqut9vJ3KKYPAb8VuZ3oml2SaHdpicWz2LTq3G7jKg1KorVCuFtMfmTyQRW9yGZiUzrisWdd5zkxKGORlbe2bNnkclkDTJos9mQy597M8gLRf6y2SxvetObEASB+++/H51O97xd+7ng5MmT/Nu//Zvo2AMPPMB11133oh5dt/H8ou0CbuMlgXK5/JRBz+FwmKmpKW666SYWFhaYm5vj4MGDuN1uqtUqlUrlis0ej3z9ST759r+juLO/5+i2ktzKUNqpN5PJZRx4+SDFQhmFUkEuU2BraRtX0M7y5LpIhQuO+Fmd2RQd6xjysbEQptK0zzZ4XTcgoFApSCezrC9EcAZshFajlJvO83Y7iazFRccsXgPJSFa0q+fpspOIpHEFbOgtOsrlKuVShaXpkChA2uYxEJc81ttlZ2s1LnIR+7odbK7GGscEQWDoWCc1QUCQyUhEs2ysRvF1Olhfiojy6ALdDtaWtsXHevY/trogjhkZOBigRl0xzGQLbKzFcbhNrC6JFbJA0M7qivix3oCVjfW4SLH1BqxsrsdF13V6jES2UihVckxWFTqjBqVKRSSaIxbdU0ttdj2JlNhdbDZryeZKot1Eg0FNqVIV1eGp1QqUKgXppmYVuVyGxaJDq1VismipCfUKtgqwKRlPd3RYWxzG3V02FiTfh5EhL+MSonhw2MelCTHJPDDs49LkOhazFpfTiFqtQKVRMrkYJpneI3xdASsLa+LrOm0G7v6rtyBv+kDVXKsWDocpFArY7fZGrdqzGZ2+UOQvn8/zK7/yK6TTab7zne9gMpmet2tLkU6nmZ2tfxA7evQon/jEJ3jVq16FzWajs7OTD37wg6ytrfHP//zPQD0G5sCBA7zzne/k7W9/O48++ijvete7+PKXv9yOgWmjgbYC2MZLAs9kBFwul7l06RLb29tcf/31mEymZ+30vfevvsHdH/pqY2xq77CQieQa5A/A0+1k5uwSuaY3SmeHnUImT9+hTuQqBel4pr7vFk6JyJ/erCWbzInIn1qnIrqVINwUAqzRqzAYNVgOd1Cp1theTxDbTiKTyUTkT5AJGIwG4pKe3XK5Xj/XcAgLAp0DHowGFc6Oeo1aaCuKQqkQkT8AlVolIn8ASo1SdKxWq5FNF0UZgmqtEqtNi8USoFiqsLUWJxnPIVcpkH7cVOx3bJ8cvGKpzMLUnjopkwlYB7SYRr3UBIF4LMvmehyNvlXdqAllEfkDMJq1bDTt9AHY7UbCmymKhQqRzRxs5gh0m4lvpjAYldhdRnR6DTqThrGxdREB7AjaW7qGg91OLl8W7yv2DbgZuyxR+gbde33GO+RuYNDD4mKEHp8Fg1FDuVYDmcCYhNS5nIYW8mcxa5meF4+Y1So585LAaUGAzZ0w53giR3wnGLyr004mmsVp1eO0G1Cq5ai19SiadJOZ6Q2vGhGRP6ir6zabDZvNxsDAAJlMhnA4zNraGhMTE5hMpoY6qNfrn/bf5C75O3LkyPNK/gqFAnfeeSfxeJwHHnjgBSV/AE8++SSvetWrGl+/733vA+Btb3sbX/ziF9nY2GB5eW+NpLu7m29+85u8973v5W//9m/x+Xx86lOfapO/NkRoK4BtvCRQqVSeMug5Eolw5swZTCYTR48efdbNHqVimS/8/r/w6P1PotGpUWhlaC1atBo9keVtQjvqksVtRhBkxLb2RmUagxqr28xm0y6XXCGjc6SDSrmC0WagVCyztbyNK+hg9pzYqDF0fQ+TEjfvyMm9UfIuDr9yiFymgFKtIhXPsr4YZvC6bsZ/InECv6yLSUkIdPdBLwuXxSSic8TF+mwUb5cDo01PuVRFqVEx9oR4RDx4tJMpaXTLkU6mJcf6D3UwIzGmHLi+h1KpglypIJnIsrEcpWvYy5zERNErzRAEugc9zE+L3bFd/S4WJXVxPcMeatRHyIVimY2NOEq1QCwidr3up/65PPV+4+Z8QNs+OYJavZxiqUq1UsPpNmFzGpEpZKSzRZaXo43Hq1RyVBolqaadPLlcwGzRE42KSbrHaxaNiKFeLbe4KFYy+wc9rK3F8XjNaHVK0rk8pUqB5XVxzdvBUX+r0jfk5bIkNma/DuKAz8JqUzYhgNmkJZ0tUK5UcTkM2G0GVCoFf/Tu12AxaXmmKBQKjY7d7e1t1Gp1gwxaLJaW1Yxm8mez2Z7xdZ4rSqUSb33rW1laWuK73/1ue2eujZ9ZtBXANl7ySKVSXLp0CYCXvexlyGSyZ2X2SG6n+Ys3f4qxh6fqz7udxuwxkY0XSezsrRmsegIDXnRmLbGtJOl4hlKhjCAT6BjyMXt2UfScgyf6Gd9nPzC8vM3Q8S6QCUQ3E1jd5hby132wgwnJ3p+/38PlR2dFaqKvz0Ummmbkui4K+RIbi9to9CoWJEqTwapjfV5MKjQGFdH1NOVShZWdWBKtQY1SpcBm1+H0WZEp5aQSOUISYqBUK4hIjskVMmKSijCZXEZoPU6oSXFTa5Uo5QKjRwIUixU21+OkEjlyTQrTLprHqrvY73NrrVZjQUIUe0fduB1W5EoZiUSejbXYvuqfzWEktCm+b7fPwnZETNa6+z2M77SchDaThDaTdPfbWJ6tN4t4O2zoDRq0RhUzkniZgUEvE5Kdvv5+NzOSOJhgsJX8udxGZmdDVKs15nYMJFqtjHIVnEYtTqex7jzOF9nYZ38vIiGdAKVya0SM2ahhVXyLdAasXNwhlKFImlAkzatfPnBF5A9ArVbj9/vx+/1UKhWi0SjhcJhLly5RrVZxOBw4nU7sdjuhUOgFIX/lcpnf+q3fYm5ujoceeqhN/tr4mUabALbxkkYoFOLChQt0dHSwuLhIrVZrkD9BEJ4x+Vud2eCLf/SvbDTVXpkcBhRyJdtbe7tP2WSOcqnMuf+4DNRHmMERH+6gg+2NOGqdikK2TmIGr+9tIX8dQ16mnpinUqoQ3onjsPssRNdj9B/tRKFSEA+nSG6niYWSLc7dSrkqIn+CAAq5nMUmd6xMJtA93Ee1WqNSqbG1GiURSePrdjEtUR2tPgMbM5KdshF/I1cwukMmRm7oJbIWo2fAjdagIZstoDdruSwxlwwe6RT3EwNDR4MikwdAz4iPCUl/8KGTPRTyZYYP+esj3dUYfaP+Fpdv77CHOUk+YNeAu4X8eTstzI1LFK5uB8VUntEDPkqlCltbSVRqBdPj4mtYbDpmJNcwGNXMS1RHlVrO5nrdRFEolFmcCyOTCZitOhLbGexWHU6PGaVaDnIZKpVc1NRRKreSW422dYztcJjYknQVdwYdTE2HiEYzDVVxZMTL8laEgNuE1aYHmYBcKefihHg87fOYWzqIjQYN0xInslwmsLwu/v0AuO01B1uOXQnkcnlD/avVaiSTScLhMAsLC40Pcx0dHWi1V0YynwsqlQrvete7GB8f53vf+x5Op/N5u3YbbbwQaBPANl4S2C/TanFxkdnZWQ4cOIDdbmdxcZFIJILD4bgip++Fh8b4yzv/hsxO967eqiUw6EVn0LMkyWUbOtHHxGN7pK5cLKPRq3n8m+eBeuRK56AXm89KJpFDqVY0Ik/0Ji3ZhHjvT5AJGKx6libWG+NlgNEb+ynmS/i6HMQjKTYWwvQf72Zc4g4ePtHXMiIeON7N5UfExw7c2Ee5XKV71E14I046WqBz0MOKhNCYXTomnhSPfp1+K9PnlimXKszvEE2L08jmQhh/hxWzw0C5VCWRyLIoGTNqDWqWJZEnKo2C9WWxwiVXyFibj7DdZHrQGzUoZTB6OEAuW2RtNUYhVyKfbW18qdVa1SytrrUrV6dTtRDKQ9d3YbfokCvlJBJ51tdi+DrtjF0Q7+919Tm5LDnWP+hlTNqaEjCwtlx3CMdjWeKxLH2DHmam15DLZXT4zJitelQaBWsSBdXpMrQoggaDhhnJ91ChkLEhUSwBYtEs1WqNjY0EGztj5Z5eF+qaDJ/Xgt6opliuoNErWduSjJ07bS2j44E+N+OS1pCBHhdDfZ6Waz9bCIKA2WzGbDaj1WqZnJzE7/eTyWR4+OGH0ev11zxiplKp8Lu/+7s8+eSTPPTQQ3g8V+/1tdHGixXtHcA2XhKoVquNqrdqtcrY2BiRSIRjx45hMpkol8vMzMywublJrVbD5XLhcrmw2WxPSQa/8w8P8fn3/YvIEas1abC6LazvvPG5Oh04OuzoTDrGHpki3+TgDAx4CK1sU2zupTVqMNoMhJYiKNUKAoM+9GYdSq2KC9+fpNa0Zzb68oGWCJnB63uYkoyD+451IQgCKq2KeDjFxmIEh99KIpKm2GRMMVj1AKTje3thKo0Sg0XXUPMArG4TgQEvlUqVaCjF1o7xJNDvYlVCCjuHPSxPiY8NHg0yJVETR17WQ3g9ht1rAZnA9lYSV8DOmEQRHH1Zl6jeDWDkeKtKOHw0yERTPqJMLnDoRC/FYplytUZoI0FsO1NXBCWZfJ29TpbnxQqXt8PG5mpUtPtnd5uIb2dE2X0OlxGjTY9Wr6ZQrLC5EadcqSJTyMg0u3cVMkxmHbFnsNPn8OgJb4l39QaGPUxPbmIwqPH4Lai1KjR6JWNj62Sbfp9GDwa4fFlMMkdGvYxLxsl9vU5m58QKnsdjZkPiJDYY1BRLFXRaJS63CZVaQSZfJJ0vNUwhuwh22lhcEZtM/se7Xs1//bmn7tx+Nthv569UKjUiZiKRyDWJmKlWq7z3ve/lu9/9Lt///vfp7Ox8zs/ZRhsvBbQVwDZeUigWi5w7d45KpcLJkydRqVSNWreBgQEGBgaIxWKEQiHGx8epVCo4nU5cLhd2u73lDcMVdPBf3nITj9z/BJlYDrVOhTNgZ7lJ+QstR7B5LTz5rXMolHK6Rv3ozToyyTyJSFJE/gACgz5mdto/SoUyCxeXGX35IOcevIzOpMXf70GlUVKt0bLjZ3WbWZGoMCqtkkQ41RgZQ91F7O204/BZiG4ldzqEwd/rYkpSFdd3pLNFOfT2uLj08HTja6NVx+DxbrKZAt4uOxs7O2iBQVcL+Qv0OVvInyfoYPLcEtVKlfBOBp/NbWJjfouBUW99tB3NkErmmZMQF61e1aISKlVyNiWxI7UarC9vi3YJ7S4jBr2Krj4b8ViGRLRArQZyRSsxMJg0LY5jl9fMtqSlw+23MibJLzxyorse5yKXEYtl2NyIMzDsZUKyZ9k/5GFGYmLp6LKzLHHqWm0aZnZczel0gdmpLQxGTZ3clir4PWYs9voIN5spIFCj1pRNGIuLyWQdrcqYzW5oIYDdXXYuja1TLJYbzt+hQTeL6wkCbhMWqx4EqAg1JiXVdGajhlee7N/n2s8N6+vr++78KZVKPB4PHo9HFDEzNTV1VSJmqtUqH/jAB3jggQd46KGH2uSvjf9UaCuAbbwkUKvViEajDafvgQMHROHP++371Wo1EokEoVCIUChEsVjE4XDgdrux2+0oFApyuRznzp1DrVKjyGiYeHSWB/7x+2w39ap2H+xkZWqdclMfq0KlwNfnIbmdwtfrplyusjq9Qe+hIJd3TCS76BjysTEfFsW26E1aVLp6f6qn21UnN/MhHH6rqEsY9ncCj5zsY/zRvWMmu4H+63rIpfKE1+NEdkiYt8fJ1lJEFPFicZnIZwvks3uGC61RjVKlJLkTCqw3awn0udGadITXE6wv7dXeWb16Yhti1avnQKAxHt7F4LEgU5K6uAM39JDLFFHr1aQTedaWthk62sHYkxJF8LquFkVw6GhnS7B03wEfs00kTGdQM3A4QLFUJZMpsLYSpVSs7Kv+2ZxGEvGsaKfSYNRQrlTJN5F6lVqBRqskGd+rQdMb1XT2uRDkMjK5EutrMQqFMp1ddpYlBo6+YW8LKezqtbI4Lya4owf9LePk4QN+JsbWUanl+AJW9EYNcpWcydktck336PWYW8wfBoOaQqkq6hGWyQQsFi3RmJhAdnXZWVgS3/fIkJeFxQhenwWdXkWhVOb40SBvfeMJribW19eZnJy8IsNHrVZrRMyEw2GSyeQVR8xUq1X++I//mHvvvZeHHnqI/v6rT2zbaOPFjDYBbOMlgWQyyY9+9COCwSC9vb1Uq1VRt+XT/bGv1WqkUqkGGczlcphMJlKpFB6Ph6GhocaouFarMf3kPI/d/yQTj82wPL5GJiF+wxw+2c/Eo+LRbd/RLirVGnqTlsh6jK3FCDqTFq1Rx7ZkkX7guh6mnxSPeUdvGiARTmF2mcil8yxPb9I55GNxbE1kBnH4LKTi2YbZBECjV6Mz6RqxNDavBUfASrFaJLQYJ5vYG10OHO9qMYOMnOhlXKJGjt7Q14iW0Zu0+HqcmF0m1ubDbCxvs6s4ubvMbC1JAov73KzOh0X37fTX1cpmwmX3mjE7jGj1ajLpImvL2ygUMuRKBenEHuGSK2SY7QaiErXO5tYTlWQfdg16WNwxhCiUcnxBO86AhUQsy/pqnMxObuPwkQ4mJDt9o8c6GZM0mowc6WjpJB444GeqaZdQLpcxcqyDSqVaH0+HksSiWdxeM1tbSRHxNJm15PJFSk1mELlCQKmUkc81mUIEsDl0RCN73weAngEXC/Nh3B4zVrueKqDWKTl/flmkEh444G9pFxkadDMpMcv4/RZWJc0pBoOaYqFMselDi0wmcNdn3orbdfUy8Z4N+dsPVxoxU6vV+NCHPsQ//dM/8f3vf5+hoas/0m6jjRc72gSwjZcEqtUqm5ub2Gy2Zx3u3IzdthCVSkWxWMRms+F2u3E6nahUKvG5l5Z59OtP8sjXnmBlcp3Rlw8y9mOxymf1mCmXKqSaarUcARtdBzuJh1IsT643zCAjJ/sZl5BHX6+L8Gq0cQ6AxWnC1+9GkMuJbMQJ7Rgnug8GWLgkIS4n+1sInH/YydpEfSfM0+XA5rWi1qqYPL9ErmmXzdfjZHNpWxTwbHEaKWRLIpVQo1eh1qpIRNLozVp8PS4UagXFUpm5y+s0jyD9fU7W5sQ7eP2HO5iRZAYOX9fNRNPIWqGUc+imPgq5ErlcibXlKIVcqb4jKHEN+3osrM/HRce6hzyiwGgAX9DGxnJd/RMEcAesuAJWiuUqm+txYjv1bTpDfYSYzey95vqen7Zxzi68nTbWV8SkvnfIzVwTubI5DPQMeshki8QTOTbW41RrdVPL2EWJynvQz7hE/XN7dWxtismf12du6QI2GDUUCyVUaiVenxmVRkk6WyBbKLMpIczBLjtLEqVveNjLuMS8c3DUzyWJonvD9d386R/eytXC1SJ/UjRHzITD4UbEjFarxWKxYLfb+Yu/+As+97nP8dBDD3HgwIGrdu022ngpob0D2MZLArsNA8+V/NVqNebn51leXubIkSM4HA6y2SyhUKjRVmCxWBpkUKPR0H2wk+6Dnbz5j3+R1ekNHr3/SfKZAnPnFgGQK+UYrPqW3T130MmT3zoP1Fs++o50oDPp2FwUEyOFSk4NROQPwNfvZqJp9GvzWug90kUikkJr0DQaSILDPiYkphGdRUNkKd74enMxwvZmHJPNSCGRpaPfjcluJJ3MIVPIWxo/PEFnyy5h78GORkdxJpFj5twSIyd6mTu3jMGiw9vtBBlUahXmL4t3+jr6XS3kz+W3Mn1BTOo0ejXjjy80iKdcIaOr341cgL5hD2tLUXLZIgiQTbVmBkrbTKCuXu5+zK3VYHMlhtVlYnJnPG13GnH6LZhsepbmIyICODDqa1EJe4e9zEpGuv6gTUT+oP6h5dxP5huKp1anoqPHgYIaPd0OVtdjFAsVBAEiEqIGUN3no7nBrAEJAezqqreQFIsVZqbqvxODw15WF6IEfWZMFh2VWo1yrca0JPjZaNAwIzkmCLAucScD3PraQ6039Cxxrcgf/PSImX/913/l4x//OIODgywsLHDPPfc8L+TvM5/5DB//+MfZ2NhgdHSUv/7rv+YVr3jFTz3/S1/6Eh/72MeYmZnBbDbz2te+lr/6q79qZxK2cdXRVgDbeEngscce48knn+T1r389TqfzimJedlGpVBgfHycej3P06FEMBkPLOfl8nlAoxNbWFolEApPJhNvtxuVytWSSbS2Feez+MyyOrfDQlx4WjTs7hnxszG2J9v4UKgWuLhfrM5v4+z1YPRYS22nMDiNjTYYMqLt+586Lx7Q2j5lcukAunUcml9Ex6MNgNwACE4/PicaMwQM+liQGhdEb+xiTxMMMXd/DwuU1AgMe1Ho18UgKpUbFsoTgOHwW4uGUZI9Rg6CQixzHcoUMm8dMMV/CEbBSrlSIhlIotUqi6+Icu/1aREZe1sW4pL1k5PruRragTC5gdupwd1opF2RsrMQaztyeYS/zkvtuVv92YbHryWQKohGsRqdErpCTSeYxmLV4O2woNUoqtRpT4+s0p8x09jpZkjiMBw76WuJlRg93MCZ9fUc6GN8hlHK5DG/AiqfDSiKRY3MrSWJn7G1zaIhuixtMdAYl+UKZShPJlctlGI0a4hJTSOc+xpOhUR8bG3HcHjMKlZxEKo/ZquOidHez382UJIom4Lfw+U/9t6sSwXItyd9ToVar8ed//ufcc889WCwWzp07x/DwML/2a7/GBz/4wWtyza985SvceeedfOYzn+Gmm27i85//PH//93/P+Pj4voaTH//4x7zyla/kk5/8JG94wxtYW1vjXe96F/39/dx3333X5B7b+M+LNgFs4yWBb33rW/zpn/4p58+f58Ybb+TUqVPcdttteDyeZ/SmVCwWOX/+PACHDx9+Ro7BQqFAOBxma2uLWCyGwWBokEG9Xi86d3sjxmP3n+Gx+8+wcHEZtV5FZFX8Bjz68qEWotd9qIPYZqJuJKlUWZ5cR6GQ1+NeQuK9ut7DQeYuiEnh6E0DjD08jdGqx95ppVAqYjKZmJaMS11BO9GNOOUm0qM1aurGj+geMRNkAt0HAijVSmRyOZsrUeLhFP1HOpk5L37OkRt6G4HRjWPX97Qc6zvSyfZmArNLT7FUJraVQWfWsC0hhDaXiWQsIyKZWoMamVxGpqlSTSYXsLlMRDYSCDIBb9COxWFEpVUzM7YuimrpP+hnRjJaHTkeZFxiThk51tkyYh48HGDq4hoanQpf0I5Gr0KQy5kYW6Nc2mOETq+J7bC4Rk5vUFORmElkMgGL3UA0In7dwR5Hg1CabRoMZjVuv4OV5RhbTcrg6OEAlyWjf59fx/qahPwF7Swvi3/3TGYtmWxBVGsnkwk4HAZ0ejV6k4ZCscJ6KIHTZWR+QUxw3/lbP8ftrz/Mc8ULSf6+8IUv8L//9//mW9/6FidPniQej/Ptb3+bzc1Nfu/3fu+aXPfEiRMcO3aMz372s41jw8PDnDp1io9+9KMt5//VX/0Vn/3sZ5mb21vn+PSnP83HPvYxVlZWWs5vo43ngjYBbOMlg1qtxtLSEqdPn+arX/0qP/nJTzhx4gS33347t99+O4FAYF8ymE6nOX/+PCaTidHR0WeVHVYqlRpkcHt7G71e38gaNBgMousmIkme+OZ5HvnaE1z4/jjlYpm+Y90t3b86kwaNXkO0adymUCk49PPDFHJFtha3iW7W/9vwDX2icTCAu9tJZDUqCpZW61TozTq0Rg0Wl5lMMs/KzCbBYf8zchcPn+htiaY5cNPATg5jldW5EPlMEWfARjScFF1bZ9QgyAQyTeYNmVzA4bMRkpDhnsN+SqUShWKZRDhPIVdm4EiA6fOS3cYT3YxJFMHh40EmJA7h3gN+5sbWRYRQppCzMB0SkUezTUc2KzZgqNQK1FolqSaXLwJ4AjY2VyUtKcNeVuYj+Lvs6E0astkiWqOmRekbPdLREiUzKDGOAHR2O1iWkC2LTUcqVaBSrmI0a/H4Lag0SvKlCrPzIRHR9PrMbKyLR8LdvXYW5iUfPg75uSwhwoNDHqYkiqnXa6aGgM2upyYTiMQyJNI5/uXvfhOdTrwbe6V4IcnfF7/4RT74wQ/yjW98g5/7uZ97Xq5bLBbR6XTcc8893HHHHY3j73nPezh//jw/+MEPWh7zyCOP8KpXvYr77ruPW265hVAoxJve9CaGh4f53Oc+97zcdxv/edAmgG28JFGr1VhbW+OrX/0qp0+f5uGHH+bYsWOcOnWK22+/na6uenDyd77zHWq1Gn19ffT29l6VEVa5XCYSibC1tUUkEkGj0TTIoLSpIJPI8sS3z3P+u2M8/LUnKTZ13Q6d6GPyJ5IWD4k72NfnxhV0kEnmmb+w1BhlCkI9b3BlUkwoRm5s7R4+8PJBioUKcpWczcUI8XAKX6+rxfihN2sBQeR4FmQCnqCDjZ2KMLlCRmDAi7PTTngtxspcuBFsPXKip+Ea3sXw9T1MPCFuFuk9GGCuSckSBAgMOalUq1QqAtGtDKVCBYNFR7lcERlRFEo5RouOWFi8MxfodbE6Lw5B7j8UYPbyWoMQFosVNEYNl6WRM/uof/0H/cxIRuj+bgerkogXi01HLlfC5bVgtOooFMuEQ0lqQDIhNnD49jGODIx4mR4XGzBGj3S0tJAMHwowfmkNtUaJr8OKzqhGrpAxMbVJoWl31GTWkE4XRSRRLhfQGzWN8fIuurodLErI5+gBP2MSkvqG2w7zjnf+PM8FLyT5+9KXvsTv//7vc//99/OqV73qebv2+vo6fr+fhx9+mBtvvLFx/M///M/5p3/6J6ampvZ93L333stv/MZvkM/nKZfL3Hbbbdx7770ola0VgW208VzQJoBtvORRq9XY3Nzka1/7GqdPn+YHP/gBBw4coK+vj3/7t3/jrrvuEn0Cv5qoVCpsb283yKBCocDlcuF2uzGbzSIyWMgWOPPgJR79+pPEthJc+uGk6LmMNj0IgshJDNB/rJuZswuY7Ab8A14q1RoanYrLPxaPkwODHtZntkRv/jqTFoVaSbJp7OjtdeHtcRELJVmZ2WqYFEZu6G0JjN7vWNeBAIs73bk6Uz0vUG3QEFqNEmpSzNS6ums4KWnK8HU7WZd0zvYf6WyYRGRyGVavHrPbQDpeJLyRorYj2I1c19XSNdx3sE70RNcI2nd2//a+FyarnmKxgt1twuwwUiyW2dpIIJPLSEju0d/tYE1C9voP+pmWkML9yOPw0Q6S8Sxmu55iucrGWgyX19LSI+x0m4iEU6JmGI1WiUwuExlREMDts7ApUfr6hz3MT4fwBiyYrXoKlQpavYoLEvLo9etYXxePif0BC2urcdExnU5JpQaFvNiM9Def+W8Eg8/egPBCkr977rmHd7/73Zw+fZqbb775ebs27BHARx55hJMnTzaOf+QjH+Ff/uVfmJycbHnM+Pg4v/ALv8B73/tebr75ZjY2NviDP/gDXvayl3HXXXc9n7ffxn8CtAlgGz9TqNVqhEIh/tt/+2/88Ic/JBAIoNPpuO2227jjjjsYHh6+Jl2iUHd9bm9vEwqFCIfDCILQIIPSLLJSocSFh8Z5+GtP8sQ3z5GKZfbNBhy6oY9JyZjW7rOQzxYxOHVoDRpS4eyOqudmTdLbOnLjgCgwGmDoRC+TO2NerVFDx6AXnUnH8swmseYuXpMWQSaITB6CTMDb62Zd4hwdON7F9JlFnH4rzg47pXIFjV7DZQl5HDzWxdTZRdGxjgEPKxLTgcVpJBXPUClVUajk2HwGdGY9taqMpemmawsCvi4H6xJndf+hADPSqJXrulvCpUeu6yIZy2CyGyjkS6wuR/F3O5ifEH8f3X4LWxsJkZlEZ1BTrdZECqUgq9fLRZq+j4IAI0c7qQHlSr2nN5nIMXTQx+QliXFkH/Wvd9DN7LT4++1wGYlG0iKyr1TJUWuV6A1qbE4jNQG2Qkk0BjWrEuWxq8vC4mJcfO2DfsYkBPfgwQB//he/xLPFC0X+AO677z7e+c538pWvfIXXv/71z+u14dmNgO+8807y+Tz33HNP49iPf/xjXvGKV7C+vo7X631e7r2N/xxox8C08TOFXC7Hf//v/53V1VXGxsaw2+3cf//9fPWrX+UTn/gEnZ2d3H777dxxxx0cPHjwWbmJfxqae0qr1Wqjku7SpUvUajVRJZ1SreS61x7mutceplKuMP7IND/+6hOEV7YbYc4mh4FVyYgXwGg3sL2+SqaJmB17zUGKuRICblZ3yFRg0NsgervQGjWsN9V75VJ5pp9coGs0QHRlG1+vG6vXQiaZR2/Rtqh/Qy9rHel2DHqY3omMCa/FCK/FMDsMlAplOnscGGx6kvEcm8vbRCSB2LB/bZvFpSe+M+YtFyuEFhN0H9CyeHkdjV6JI2BBrdOg0WtbWkR8QTuzkn03o1XHnGS0KVfI2Fjaro+T5/ZG3Dq1gtHDAbK5IquL25SKFSxOY4sC1z3gZkw6Oj7gZ1qqRnbaW84L9jpJx5N0Bk0kk2XisSyCTGi5BuwfB+P2mluiY/qHPYxfWiOdyrO100Xc2e0gFc0y0udCppCzHc+STOVYXRUbjBAgJKmMA3j9G5599MsLSf6+8Y1v8I53vIMvfelLLwj5A1CpVBw/fpwHH3xQRAAffPBBbr/99n0fk81mUSjEb8u7O8ttraaNq422AtjGzxQqlQp/9md/xnve8x6sVqvovyWTSb7xjW/w1a9+lW9/+9u4XK4GGTx27NhVJYPNqNVqxOPxRgtJuVwWVdI1m1Kq1SqTj83yyP1nWJ/d5Mx3Loqeq/dYkLmzkngYr4VMIkchW3e/Wlzmet+wXsX4o3OifMH9QqiHru9hUuLc9XQ5yCRyePvcyJVy1hciFHJFNAYNCYmLtXPIy7IkSHj4+p6WbMKDrxigkC0hVynYWo0SC6XoOeBnXkLMzE49qWhWlOmn0atQKOSidhAEMLsNVCs1nH4rcoWSjdUY3k57i/o3+rIexiSj4+FjQSYk38uuob0WEajvHPYf8iOTy0mni6wsbVMpV+vGEY2SlGSvzt9tZ00StDx40M+UhJAGes2szu8RLqfHTHDARSpZIBRKEt0JnvYGLKyviUmhVqeiVquJHMYI4PFb2JQ0egyOeJmS7BgeOh4kly2i1CiJJbKsb8Rxe/VsbIjHxA6Hgb//h99ALr/yfxcvJPn79re/zVvf+lb+8R//kTe+8Y3P67Wl2I2B+dznPsfJkyf5whe+wN/93d8xNjZGMBjkgx/8IGtra/zzP/8zAF/84hd5+9vfzqc+9anGCPj3fu/3kMlk/OQnP3lBX0sbP3toE8A2/lMik8nwrW99i9OnT/Pv//7vWK1WbrvtNm6//XZOnDjxrJzCzwS7wbS7WYOFQqFBBh0OR8un/5kz8zx6/xke/foZEpEklWqFvCQAeXdHsBkjNw0w/vA0ap2a4GgAhUpBIV9iaXxdZPxQ61ToDBpiLZEzncw1hTQLgsDRV49SyJdIJXOszoaoVWsMHOtiWjLSdQfthFdjoutoDWoUKgWppg5aV6cdf5+LVDzHylyI4s7uma/fxvqMxMV6oocxicFk4FiQaYnT1uY1oFAosHkslIpVVhbCqNRKymXxqFYmF7A5TUQkocrdoz4WJsSEaeR4sDE6VqkV+HucOPxWNlZjrC1FG2PYniEP89OS/ESXkeh2WkRm5QoBtVZFNi3+OQa6HazumDLsbhNOrxmDRcfsTKhBCGGnSUQyJu4ZdDMvHaPb9KQSOSoVcfSL2aon1rTzqNYoGT7oo1AsE0vl2NxKUanU+LlX+rnjF4/gdDpbzE1PhReS/H3ve9/jV3/1V/n85z/Pm9/85mu27nEl+MxnPsPHPvYxNjY2OHDgAJ/85CcbTuRf//VfZ3Fxke9///uN8z/96U/zuc99joWFBSwWC//lv/wX/vIv/xK/3/8CvYI2flbRJoBt/KdHLpfjgQce4PTp03zjG99Ao9Fw2223cerUKW688cYWUna1UKvVSKfTDTKYy+VElXS7rr9arcbMzAwXHxsjNVvg3ANjLI3VCcDAy3qYfkJMjMxOE8V8kVxT/AnUzRvVKpgcRrY34mwtbTN6Yz9jEtdw/7EuZiSkzua1kIplKOXrqpPeoqNzyI/aoGLu8hrppgiVviNBZiUh1qMn+xmT7DLu7g0CKFUKbAETOquWQrrKRpMBQ2fUQA2y6b3XI8gE3J0ONpfFalvnsJvliT0iJFfIOHhjL8VilVQiz+riNrVqjaGjnY0mkF109LlYkTiJjRYdhVyRYpOKKpMLWOxGoqEkGp0Kf48TtVaFTC3n8tll0Z7gyNEOxiXdwt1DThamxDuLwT4XS7PiPT+TVUc2U6RcqmBzGnH5zNRkAvl8hQXJffYNuZmVNJHsF0Q9MOJlWrLf6HKb6s7lnftWKuUEuuz8P+99OYVimkgk0mjXcLlcWK3Wn6qWv5Dk74c//CFvfOMb+fSnP83b3va2FwX5a6ONFzPaBLCNNppQLBb5j//4D06fPs3999+PIAjceuut3HHHHfzcz/3cNY1iyGQyDTKYTqex2Ww4HA6i0SjpdJqjR482AqjXZzd55OtnuPzjSc79x2XR8wye6GNKEi8zfEM/E4+JiV7fsW40Bg3ZVI7lyQ2qlRpypRybx0x4RazADb6shykJ0Ry5qZ/xR2eRyQQCA16MDiOCTGDsMfF5JoeBQq5EQaLA2b1WwpJ8wL4jncyeX8bsMOLtcVJDQK1Xc0nSYDJwrItpSTC1r8vBxtK2aFdKo1dSKVcpFeo2Yq1BTaDPjd6iZ21xm/DGngLYd6jVTbyf63joSAeTEuUx0O1kdTGC3qTB1+VAoVaQTufZ2kxSEI1qBZxes+i6AP2jPmakTSLHOhmTkMeBAz6mL683CCEyGflSmYX5sIh4KlVy1GolacmHgOA+LSajh1q7iV/56mHe+0evAxDts4bDYSqVCg6HA6fTKVKtd8nf4cOHn/faskceeYRf/MVf5OMf/zjveMc72uSvjTaeAdoEsI02fgpKpRI/+MEPuPfee/na175GqVTi9a9/PadOneJVr3rVM2oTebbI5XJsbGywuLhIpVLBbDbj8XhwuVxoNBrRueGV7Z0x8ZMU8kXmWgKntSiUcpKSeJm+Y13M7ih9BouOwJAfk9PI5R/PkM/stWl0DvtYlvQc681akIQ+A3QMeklup/H1ualUYXVmi+4DgZZ2kP12BDsGPKxIRqgGq55KqYzda8HsNJFJ5VmdD2P3WUWRMwD9hzta+oZHr+9hTLrf2Gtlcz4OgM1twtVhR6lVsjgdEu306QxqajXIZcSVbJ4OG5sSgjxwuINpqev4eJC1xQgOn4lsLkcmU8HlszEj2clzec2ENxOtBE6rIp0UE7jOHifLEvVv+EgHW+uJhkIYCiVx+SxMSPYO/R3WlugXtUaBXBo7A/zlp3+NwREfUjR364bDYTKZDDabDZVKxdbWFkeOHHneyd8TTzzB7bffzoc//GF+53d+p03+2mjjGaJNANto4xmgUqnwox/9iNOnT3PfffeRTqe55ZZbOHXqFL/wC7/Q0hP8XJHL5Th37hxarZbBwcFG1mA8HsdkMjXiZaTXjW3Feewb53j0609y+UdTVMqVRl1cM/qOdTMr2Rs02g2Ui2VKhTLB0QAag4bNxQgGq6ElcHr0pgHGJGaSweu6mXpS/JyebidaowadSUd0K8nmchSlWoHerGupuus+EGhtK9knh3D0ZB+lUgWFSsHmWpxYKLVvtqDOqKFWq5FrqoZDEHAFLIQkRKj7gJfFsU28XQ4sLiP5fBmtScPYE2Iy3XfA36ISOrxmtkPiPD+lWo5GqyYl6egdPNqJIJNRo8b6WpxkIlfvB5YoisNHOpiQ7Pl1dDtYkQQ36wxqKpUahXxJdLxvxItCKacmE9jaShKNZhg+6GdCmmN40M+4hCj29Lv4xOfu5Jkgm80yOzvL1lZ9/Lz7u+l0OtHr9decjJ07d45bb72VP/mTP+G9731vm/y10cYVoE0A22jjClGpVHjssccaZDASiXDzzTdz6tQpXvOa12AwGJ7T8yeTSc6dO4fL5WJwcFC0b1UsFhtu4mg0isFgEFXSNSMVTfPEty/w6Nef5Nx3LzfcwPUxr4Xwinh/bl+H8A19pKIZrB4z8Uia9dkQ9oCVRCRNubi3FydXyOrPKRnpDhzvZvrMHil0+K30HA4SWo+xMrNFtVz/89M16mdxTExEzA4DuXSBYhO5kckF7D4r4bU99c/daadj0EcskmJlLtx4naPXdzP2uJiQ9h/uaHEIW1164uGMSIFTaRTojVosThM6k4ZYNMv6cpTOPhfLkl294eNBJqRh0Mc6W4519rtYnhWT1K5BN3pzvUFkdTlKLlsEAVw+CyFJJMx+buLRo50tlXNd/S4WJaHTgW47RrOOqgCboSSxaJ2YenytzuF3/4/X8Au3HOSZoHnsazQaiUQihEIhtre3UavVjd9NaSj61cClS5d43etexx/8wR/wgQ98oE3+2mjjCtEmgG208RxQrVY5c+YM9957L/fddx+rq6v81//6X7n99tt53eteh8lkuqLni0QiXLx4ke7u7kad3U/Dbj/x7huuVqttKIPSfuJsMseT37nAo/efIZPMceF7Y6LnCgx4WJ8Vt4goNUqMVr2oq9jqsdB/rItoKMXS1EajC3g/8hgY8LAqGelqjRoEAbLJPEq1guBIAJVORbUqtARE71ctN3R9D5MSldHX42R9ZyyqVCvoHPSiMWpIJ/IsS4iQv9fFmmSEOnQ8yKQkINrbZ2FjNi46NnCkrt4JShlbawlikTQmq55criiK2hEEsDoNREOSRpeDAWZadgyDjO/kGMrkAv4uB64OG9FIhpXlbUo731+LXU8qLnb0CjIBq91AVBLL0z/ibRkzjx7tZKzJ9OLwmOjsc5LOFNncTBLfUSqNRg1//5V3oFY//a7rxsYGExMT++787Tbk7I6KgYaJxGazPWeX/fj4OLfccgvvfve7+dM//dM2+WujjWeBNgFso42rhGq1ysWLFxtkcG5ujle/+tXcdttt3HrrrVgslqd8o1pbW2NycpKRkZErTvzf7ScOhUJEIhFUKlWDDEojPArZAmf/4zKP3v8kT377AplEjq7RAItjYmXswMsHufxjcV9p54if5fE6idEaNXSOBJArFWxvJlrUv+4DHSxcFqtT/dcFmZEEN/cf7WLm3CKebid2n41MKk86ldtRGSuN82RyAavHwnYTIYWdGjmJIWT0hl7GHpvD5jHjDjqolGvIVEqmJPuRNreJxHaGSnnvOnKFDKNFR1xCrAIDTlZn9kawroCVrhEf0XCa1aVt8tm6Utk15GJxUlL7thPc3DwmVihl6AwakjHxmLh7yMPC5CZKlRx/jxO9SYtKp+bcE/PU9vgfA6N+psfFI939GkLq0S86Ytviuru+UV+DKLq8ZhxuE0du6OGNd97A0+GpyJ8U1WqVRCLRMJHsRh/tmkhUKtXTXq8ZU1NT3HLLLfzWb/0WH/7wh9vkr402niXaBLCNNq4BarUaExMT3HvvvXz1q19lfHycV77ylZw6dYpbb70Vh8PReOOqVqvMz8+zsrLC4cOHn3N8xq76svuGK5fLRZV0zW+YpWKZyz+a5MdffZzH//1cwyhidprIZwqNcOlddA77WZ6QjCFvGmTyJ7N0jvrRm/VsrUSxuEyiHEGoR8cUcgXKhYrouK/X1VItd+Dlg5SKZQS5nNW5EJlEjuHre5mQVOU1q3+70BrUyGQyMkmxQSU45EWQCegteuLRLOuL2/u6fIePB5mQKIKuDmvL3qBap0Qul5NN5ZEr5AT6XCi1cnLFAuvzSdFIefhYkAlJ7Mzw0Q4mJC5fX9DG+pKYSKs1CuRKBbVaDX+3E6VWSXQ7g1qnYmlO/NpHj3S0jIR3ncPNsDkNxGLisG2ZTOAzX3kHbp+Fp8KVkD8parVaw+0eCoVIp9NYLJbG3uDT7dLOzs5yyy238Gu/9mt87GMfu2bh7W208Z8BbQLYRhvXGLVajdnZ2QYZPH/+PDfddBOnTp3ita99LX/4h3+Iw+HgIx/5CEaj8apeu1qtEo1GG2+4giDgdDpxu90teW6VSpWxH0/y6P1n2FqKtLSQDF7fy9TjYkOGxWMmm8hSbIo6EQQYOtGPXKUgGcs0qul8w07WJ8SEZb94GYffRiyUoFKuy10ymUDnsB+L20xoPSbKCNxf/etryRzsORBgXmIw8fc6MTvMVIG1hQjpZB5BAIdkxxBg8GiQKWnsTL+F9Zm4+N4DBiKraXRGDf5eFwqVgmQyR3gzJcoSBHAHrGxJnMyDhzuYkjiZ9yOP/m4H6UQOT6cNQSFnczNBNltELhNaHL3BPidLkt3DkX12B192Ux9/9LGn7v19LuRvP+Tz+cYaQywWQ6/XN8ig0WgUfVhZXFzkta99LadOneKv//qv2+SvjTaeI9oEsI02nkfUajUWFxc5ffo099xzD5cvX8ZqtfJbv/VbvOUtb8Hv91+zkVa1WhVV0lWrVVE/cfMbaq1WY/Kx2Xq8zL+dIboRw+I0E1kTq1PDJ/uZ2Mc4MtlEwAw2HY5uKwq5huXJjcZYVyYXcPhthCRhzkMneluq6UZu6GN85zmtbjPeHhdyjYqZ80uinD21ToVSpSAtcd8Gh30sSaJsRm/oa+wYCjKBQJ8bT7eDzZUYq025eg6fhWgoJWo2kStkGCy6llo8b4+VjXkxqRu9vpvQWhyH30q5UmN1cRtfl4M5yfjWbNORSRUol5oUUgGcPgthqSHkcIApiUv40MleSqUylSqsrUZJpwr4Oq2sL4vvR6mUo9K1Rsz86SfeyNETPfw0XG3yJ0WpVCISiRAOh4lEIiiVSpaXlzEYDBw8eJA3vOEN3HzzzXzmM59pk7822rgKaBPANtp4AbC5ucnrX/96NBoNb3jDG/jWt77Fww8/zPHjxzl16hS33347wWDwmpHBWq3W2Mva2tqiVCo1yKDD4WhZ0p+/uMzD9z3Bo19/krWZurHD1+dmcz4k2jeTK+VYXCa2pQraiV6mn5hHo1cTHAkgKBUoNUou/1gcT+PuchBeiYqeU6GSY7QaiG1JwpOPdbE4tkbnsA+1QUNoNYqny8mYJDama8THooRsGcw6yuWqKJwa9kbKBosOf58LQSZHoVVxWWpGORZkUtIj7PCbiUh6exUqORqdWtRhLFfIGL2+h0qlSjJVYHUxQq0Ko8eDjElGz30HfMyOiQ0dZpuOdDLfUEgBEHYUxbV4/UsBfEE7vm4H2+E0K8vRhgI5dCjQkhHo7bDyt19++0/9fbvW5E+KXeX605/+NHfddRe5XA6/38+f//mfc8stt1x1pXw/fOYzn+HjH/84GxsbjI6O8td//de84hWv+KnnFwoFPvShD3H33XezublJIBDgf/7P/8lv/uZvXvN7baONZ4M2AWyjjRcAt912GyaTiX/4h39ApVJRq9XY3Nzkvvvu4/Tp0/zwhz/k4MGD3H777Zw6dYq+vr5rSgZTqVSDDObzeRwOR2MUJ63CW55Y49H7z7BwaZlHv35G9N9Gbxpk7GGxccTT4yK8HGkhdRanGaPdgM6sY2slyvZ6nIHrekSxMQAjJ/sYf1Q80vX3uVmbFVefqbUqvD0u9BY9mXSeldktqpUa3aMBFiQGl2b1bxc9BwPMXxKfZ7YbyKbzuDpsWFxmUsk8qwthHF5LSxD1fqTQP2BjbUZ8njSzUGfU0DngQalRsr4SYzuUavy3riEPi1OSird9iGLviJe5SUmItklLIV+iVCyjUMoJ9DjQG7WgkDF2cZVqE3/8zf/3v/CGX3kZ++H5Jn/N2Nra4pZbbqG/v5/R0VHuv/9+5ufnef/738+HPvSha3bdr3zlK9x555185jOf4aabbuLzn/88f//3f8/4+DidnZ37Pub2229na2uLD3/4w/T19REKhSiXy9x4443X7D7baOO5oE0A22jjBUA0GsVqte5L6mq1GpFIhK9//eucPn2a733vewwODjb6iYeHh68pGcxkMmxtbREKhchkMtjt9gYZlDo2N+ZDPPr1J3n0/jOsTq8jV8hJRcVu0/7ruhuNI7sYuWmAcUk49ciN/cjkchLRLKs75O6nhUbv11c8erJfFE6tN2sZvK6HbLbI6ny40VpSN4nUzRvNCA55WZoUq237RtFc1021WiNfLhBeT5FLl7A4jaRiWZGbWBAEHD4LYUnOnr/fxtqMZJR+XRcTO2YUp8+C029FplYwN7lFrmmnT6mSo9GpSMXFBpfeUR9zE5Lol32I4m6Ooc6gxtflQKlRkkzl+egX3ore0Nps80KSv0gkwute9zpGR0f50pe+1PggMj09TSaT4ejRo9fs2idOnODYsWN89rOfbRwbHh7m1KlTfPSjH205/9vf/ja/+qu/yvz8/PPegdxGG88WbQLYRhsvYtRqNeLxOPfffz+nT5/mwQcfJBgMcvvtt3PHHXdw4MCBa7oPlc1mG2QwlUphtVob4b7SKrzIWpQfnn6M7375R6yNb1Gr1giOBFieFI8b1ToVaq2qpZqu/3g3Mzvqn9VtxtvnQWfRc/4Hk428Qdhf/VNqFGj1mta6uyNBZs8vIZPL6Bj0YrQZUOk0nP+RmHzuR/50Rk2d6Emq4Dr63azM7F3f1+MkMOBlaz3Oylyo4azdL3Ta4jCQimfF41vqbSIRST/w0PEgM5dWCfS6MFh0JBN5DBZ9iyHE5be0VMnJZAJmm56YZEdx4KCfacn497/+4jHe9T9fjxQvJPmLRqPceuutdHd383//7/+9ph3cUhSLRXQ6Hffccw933HFH4/h73vMezp8/zw9+8IOWx/z2b/8209PTXHfddfzLv/wLer2e2267jT/7sz+76i1BbbRxtaB4+lPaaKONFwqCIGC1Wnnb297G2972NpLJJN/4xjc4ffo0r371q/F4PI0x8bFjx646GdTpdHR3d9Pd3U0ulyMUCrG5ucnU1BRms7lBBrVaLRqzCvthPb/7mrfhtnl5/BvnmD4zz9rspkgZ6zvWzZgkX7Bj0NcgfwCxrQSZZBaNXoNSqNJ7uANBLmNlZhOdqfUNdeBod0s1nb/Pzez5ugJWrVRZGl9DpVWi1qqwWtS4u10Ui2VWZkIolK3BxN2j/pZ9wuCwlyWJ0hYPp4iGU+QzBbQGNYEhLwqVgkqtVaX1dTsZf0I84t7POGKy6ZkbW6dSrrI0tTfa7RryMjDsRqaQs7meIL6dweExE5KQx74RH9OS0GmzTdeiEgLc8qbrWo69kOQvHo9z++23EwgE+MpXvvK8kj+oK4+VSgW32y067na72dzc3Pcx8/Pz/PjHP0aj0TTagX77t3+baDTKP/zDPzwft91GG1eMNgFso42XEEwmE29+85t585vfTDqd5lvf+hanT5/m1ltvxWq1NsbE119//XNuW5BCq9USDAYJBoMUCoWGm3hmZgadTtdY1B8cHEQQBG7+zZ/n5t/8eX7jw7/CE9/+/9q787Aq6/SP4+/DvoMIh0V2wQXQBDTFvTQVN3BJp820Mm2xKSqXtl9TTk1NTdY0WJpWZjqWgJE6CaW4YgVuBbgCIrKDgOzLOb8/iJOHg1uxCffrury6fHjOeb5HTT5+l/s+RkJMEqcS00g/kanz3kamut/kfQK9NPsJT/3UuAfQtb8z9ZXV+N7uSe75YorzSjE0NiDrrO435paCos8gD01QbCoo7e7bCxrq6RfoRs75IkqLKjA0NiDzlO571tbW6Fzz8O+lWSauKq/hzNHzuPV1JPNUY29hWycbKspryM8pJaPZSWQAYyMTnWuW9saUnWleINqJ9GazlG4+DigaGvDq60BWRpHmoEdNjXZvYAAXD3uSm+1R9A10w91HO+h0ZPgrKytj5syZ2NnZsXXr1psuEt2amm+zUKvVV916oVKpUCgUfPnll1hbWwPwr3/9i9mzZ/Of//xHZgFFpyQBUIhblIWFBXfffTd33303VVVV7Nq1i6ioKGbPno2ZmRnTp08nNDSU4cOH6xzk+LOMjY1xdXXF1dWVnJwckpOTMTMzIysri0uXLmkKT5ubm2PRw5w77hnBHfeMoLK8miO7TpDwbRJJsSeorqjB3c+Fc8e0g4mxmZFOwWkAEzNjrZnCXj6O9OrrTHZaAaUFvx+ecPJUcrZZ1w99Q32yz2kvHTc96/QV7eV6eTvg0s+ZnPPFXL70+35GWydLcs5p790zMNLnYrPewADGJo3BJSejkJyMxu4h/sO9qamqw8DIkJysS5QUltPL046MZqHOwEifkvwqnfdUK1Q61yysTUn+sXGW0tDIAE9vJdb2luTnlAFqoDGw6OsryMoo0Hn9pLu1Z/86MvyVl5dr/uxu27YNExPdYNwemk7BN5/ty8/P15kVbOLk5ESvXr004Q8a9wyq1WqysrLw8fFp0zEL8UdIABSiCzA1NSUsLIywsDCqq6v54YcfiIqK4v7770dfX5+pU6cyY8YMRo0a1apLajk5OaSkpODv74+jo6Omllt+fj4ZGRmYmJjg4OCAUqnE0tISMwsTRs66nZGzbqe2uo6jP/xKyqHTFGYVU1H6+4yXd4AHyc0OifTycdQKfwB55wuoKK2kJL8MWycbnHo7UFVZi5GpMTnp2sGsb6AnKT9qnyZWuvXUOaCSk15ATVUdRTklWPW0wLm3krLyCgyMDCnOuax1r/dtbpxM0n690qUHZ3/RLrKs0FOQnVZAce7vS7VOHnY4u/XA0FCPC2mFmn2BPgNdSW02U2dtZ875k83CqwLyryi3U1dbT3pKNv2C3Mk+k4u1rTmOHnagp8DAxJDkRO2ZV1t7S4bd2f/3z92B4a+yspI5c+agr69PTExMh86YGRkZERQURFxcnNYewLi4OEJDQ1t8zYgRI/j6668pLy/HwsICaDysoqenh4uLS7uMW4ibJYdAhOjC6urq2Lt3L1u3bmXbtm3U1dUxdepUwsLCGDt2rM5BjpuRmZnJ2bNnrxoYGhoaNGGwoKAAQ0NDTRi0trbWWk6rr6vnl70nORSTyPH4FCrLqii/1Ow08RWHRJr4Du9DyqHmtQTtqSitxKWvM2oUZJ7Opba6FltHGwqb1SfsP7Q3qT9q7/Prd3tvTiVqP8eypxm1lXX08nHExNKU/IslFOWWoXSzJf9CsxO9Q7xIbdbdpE+gO6ebhTobe8vGAyF1DY17B30cMTA2pLZexblk7aXillrWKd0tyT+vHUgtrE2pqamnrlnXETcfBxrqG7C2t6KyspYL6YXMfmQ0cx4dDXRs+Kuurmbu3LlUVFTw3XffYWVl1a7Pb0lTGZiPPvqI4OBg1qxZw9q1a0lOTsbd3Z0VK1Zw8eJFNmzYADTOXvbv359hw4bxt7/9jcLCQh555BHGjBnD2rVrO/jTCNEyCYCi07nZAqx79+4lPDyc5ORknJ2dWbp0KYsXL27HEd8a6uvrOXDggCYMlpeXM3nyZMLCwhg3btwNz7qo1WrOnTtHVlYWAQEBWsteV9PQ0KDVkq6pP7FSqcTGxkbr8IpKpSL54GkSYpL4cfsRirIv0cvHUVOAuom+oT7WPS0pzi3Rut68E4mhsQED7/ClqryWnPQCSn47GWvraE1pUbnWCWOFQoGjp5LcZsulV3YiaTJgVF9UKjXl5TVcOJuPWqXGooc5NZU1OgHMxcdB0xJP854tlJjx8u9FWnK2Zu9geXkNhXllNNSrqG5WtNqtjwOZp7Xf02ugE2m/aP86uXjZkZVWqHXNwtqUVTF/pYedRYeGv5qaGu677z4KCwuJjY3FxsamXZ9/LREREbz99tvk5OTg7+/Pe++9x+jRjYF5/vz5ZGRkEB8fr7n/5MmTLFmyhIMHD9KzZ0/mzJnDypUrZf+f6LQkAIpO5WYLsKanp+Pv78/ChQtZtGgRBw8e5PHHH2fz5s3MmnXtvqbdWUNDA4cPH9aEwcLCQiZNmkRoaCgTJ07E3Ny8xdep1WpSU1MpLCwkMDBQs9x1M1QqFZcuXSIvL4+CggLUarUmDNra2uq0pDudmMYv+1KJ27CfvCuCmW9wH1IStGf/7FxsKc4p0WrbBuDoaU9uegEKhQKXvk5YKa0xMjXiWPxJrft8Aj0426znr4W1GXW19dRUNQtg/Z3J/O1Qh7m1WWOZGTtLUn5Op7L898MiLZWYMTY1xMDQgIqyZvX8Brpyrlkxav9gb2qq69A3MiD3QjElxZU4uvUkt1kLPYWeAnNrE8pLtOsb9gtw42Sz0jEjQgYQ/s7cDg1/dXV1zJs3j8zMTH744QepnydEO5MAKDqVmy3AumzZMmJiYkhNTdVcW7x4McePHychIaFdxnyrU6lUJCYmsnXrVqKjo8nOzuauu+4iNDSUkJAQzZJcVVUVP//8M/r6+gQGBrbKzEZTncOmWoMNDQ1a/YlbakmXEJPITzuPUn6pkqLsZku6LfQm7jPYi9OJ2jNtlj0tqKmswdrOCqWHPRVl1WSeysGtvwuZJ5v1DG5WYBrArZ+zzn2GJgaYmBpTUVaFWz8nzHtYUJhXhlVPC84e194T2P92L1Kb9TtWuvSgILuUK/9KVijA1tFGc2IZfqs76ONA3sVSMtMKUP/WYaXPba6cblZ30NjMgPpalU7dwb9/sRBrJ6MOC3/19fU89NBDnDp1it27d2Nvb9+uzxdCSAAUncgfKcA6evRoAgICeP/99zXXoqOjmTNnDpWVle1eQ+xWp1KpOH78OJGRkURFRZGWlsb48eOZOHEin332GQ4ODmzatKlNynOo1WrKyso0YbC2tlbTks7Ozk7nJPOFU9kcjkkiISaJtBOZ2DrZUFZ4mforlnSBFpeP/Ub00Tlk4jPYC4W+grLLFRRfLKe+tgEjE0OMTAwpL9EuyeIT4M6ZZqeMW9pPqHRtnNWyd7OjsqqOC2fyUDWosHPuQUHz/Yi3e5HarEagzyA3zjSbkTS3MqWutp7a6jrMLE1w8XFEz0CfBoVCp/B0S3sHnTx68NdV08nMzGTQoEHtHv4aGhpYtGgRx44dY8+ePVc9WSuEaFtyClh0Gn+kAGtubm6L99fX11NYWIiTk1Objbcr0tPTIyAggICAAF5//XVSUlL4/PPPWbFiBTY2NtjZ2bFp0yamTp1Kz549W7UlnUKhwNraGmtra3x8fCgvLycvL4+0tDSSk5O1WtIZGhri2tcZ1+edufv5aeRlFHBsdzK7Nx/k9M9pmlk07wAPzh7N0HqOqZUJ6c1O6QLU19aRfqLxurGpEd5+Ltg49eDkz9qvV7r31FkmVijQOWACYNfLlpTDZzUHRUwtTPAd6U3l5Rqqyqsp/609nbmVKWm/Zum8vvleQmgsRt20d7DycjWnj2Tg7GVPTnohvXrbY2NvxeXL1WRlFJFzvkjn9QF3epCRkYG+vj45OTnU19drSp+0tYaGBpYsWUJiYiLx8fES/oToQBIARadzMwVYr3Z/S9fFzVEoFFhaWhITE8PkyZN55ZVXiImJYf369fz1r39l5MiRhIWFMW3aNBwcHFo9DFpaWmJpaYm3tzfl5eXk5+eTmZlJSkoKtra2mn2DRkZGOHjYawpPF+dc4vD2IyR8k6RVx6+J10B3nU4kjl72mvAHUFNVy9mjGfTIvkR5QSlu/XthbmtBwcUSbB1syG8WrLwDdHsTW9iYazqRNKkqr6Yo6xIZKRfR01M07hvsaYmRuW57Omcve53C0Xr6CnLStQ90AFjZWpCdVsDFs/mauoT9hniiVqlROlpx8XwR5WXVmFka4+JnRUBAAIaGhuTn53P27Fl+/fVXnYDd2lQqFc888wz79+9nz549ODs7t/ozhBA3TgKg6DT+SAFWR0fHFu83MDBo96Wtrmjjxo3ccccdfPjhh+jr6+Pv78+KFStIT08nMjKSLVu28OyzzxIcHExoaCjTp0+nV69erR6+LSwssLCwwMvLi8rKSvLz88nOzubkyZPY2Njg4OCAvb09JiYm2Dr1YPLCcUxeOI7SwjJ+2nGMhJhETuxNRaGvR2aKboFpDHV3wvQZ7MXJ3+oGZvzaGA6t7Swp1QffIR6UXaok67ewVV2p2yHEvb+zzt5BF29HMn57vkqlJjM1G30DPSx7mGNrY4yDhz01NQ2cP5uHVQ9zstE+jew90JXTR5sfUml59rC6ooaMlMYAqdBT4ORhi1uAPYOHBGr+37C2tsbb25uKigqtgN3U87np1/TPUqlULF26lLi4OOLj41s80CWEaF+yB1B0KkOHDiUoKIiIiAjNNV9fX0JDQ696COTbb78lJSVFc+2xxx7j2LFjcgikFVxvNlWtVnPhwgWioqKIjo7m4MGDDB48mNDQUEJDQ3F3d2/Tmdjq6mpNaZmSkhKsrKw0tQabH1IpL6nkeHwy+74+zNEfkqn97VSvhZ0ZlZeqdU4OO/V2IKdZ5xC/EX017ekAejhY4xXgQWlhBedP5WgOWxgY6WNmYUpZcbnW6/sO8eJUsxqBLV2z79WDHs490Dc04GJGEZd/24PY0onilsrJOLr3JLfZLKVCAa9HLab/bd5cS1PP5/z8fEpLS7GystIczLna6fBrUalUvPTSS2zdupU9e/ZIVwwhOgkJgKJTudkCrE1lYBYtWsTChQtJSEhg8eLFUgamA6jVanJycoiOjiYqKop9+/YxcOBATRj09vZu0zBYW1urCS7FxcVYWFhowmDz4FJdUcOerQfYveUAeioDTiVoH95oae+giYUxenp6VDYr3dJUoNrU0gR3XxfQ18fQ1IjkQ9p1A20crLhcVK5zItfFx5Gs5odUhvuQnND4ej09BS59HLFz6Ulu1iWtfX0KPQU97C0pzivTen3/IZ46B0r8R/Tmb1881tIv3VXV1tZSUFBAfn4+RUVFmJmZaZbeLS0tr/v7qVaree2119iwYQN79uyhX79+N/V8IUTbkQAoOp2bLcC6d+9ennnmGU0h6GXLlkkh6A6mVqspLCxk27ZtREZGsnv3bvr160doaChhYWH069evTcNgXV0dBQUF5OXlUVxcjKmpqSYMWlhYkJeXR3JyMgMGDKCHdQ+O7k4mISaJxP8d4/KlCjz8XTXLvk1aOjmsdOtJwYVimv812svHERMLE4wtTMnJKKS0sLzFcjLuvs6cT9He56dvqI+5tRllRdqzh/2GeHHy5zRsHa1x9FRSU1uPkamxTis6M0sTGupVOnULX1j3MEF39OePajpYlZ+fT2FhIYaGhlrFvFvai/uPf/yDjz/+mN27d+Pv7/+Hny2EaH0SAIUQbUqtVnPp0iViYmKIjIwkLi4OT09PQkNDmTFjBn5+flrFn1tbU3DJy8ujsLAQAwMD6urq8PHxwc3NTSu4NNQ38MuBUyRsS+THHUcoyW+cWdM30MPKzpJLV/TyBfAN9iGlWahrPnuoUCjwGOCKpZ0lBRdLyMv8vXVcn0APTjc7PNLv9t6cbLYkbNXTnMrL1dTXape48R7khkJPDwNjI7IziygrrsD3di9SftJdEv5w9/JWC90qlYqioiJNmz8Ae3t7TE1NcXR0xNTUlPfee4/33nuP3bt3c9ttt7XKc4UQrUcCoBCiXZWWlrJ9+3aioqL47rvvcHJy0swMBgQEtGkYPH/+PGfPnsXGxoaysjIMDAyuOoulUqlITThDwrdJ5KYVkLjruNZ7Wfa0oLqihrrqOq3rngPdSD+hfVDDd0QfUn6bPVS62WHvbkdDg5pzv2TpLAn38nHk4tlmew+DvTVLwk2ceyvJPpev+blC0bhU3NPFluzMQgqyfg+rD74wlemPjL3BX6Wb01TMOz8/n9WrV7Nx40YGDBhAcnIy27dvZ+zYtnluS262jWSTgwcPMmbMGPz9/Tl27FjbD1SITkACoBCiw5SXl7Nz506ioqLYuXMntra2TJ8+nbCwMIYMGdKqtekyMjJIT08nICAAGxsbnVkshUKhCYM9evTQCaKnk9JI+CaJw98mkZOWj9/IvjrlZFoqOq1QQM9ethRmFWtd9xvRhwsns3Hp60xdg5rM07k4ezlwPlV3SdjC2ozSwsta1/vf3pvUn5rtXRzkpqlRaG1vSS9vRxrUal787FEsrM1u/hftJjU0NPD3v/+dr7/+GoCsrCzGjx/P3Xffzfz589v02TfbRrJJaWkpgYGBeHt7k5eXJwFQdBsSAIUQnUJlZSWxsbFERkayfft2zM3NmTZtGmFhYQQHB+t0ArlRarWatLQ0Lly4QGBgoKa13ZVUKpVWSzq1Wq3Vkq55GMz49QKJu06w7+vDZKb+Xlam31BvTemYJn2CvDidpL0ka2ppAurGuoBNjE2N8B/Tn8ryGrLO5VNR2vi1fkM8OdnsQIeFtRk11XXU1WjPPrr5OpGZon1KePy9w3n83Xuv98v0p6nVaj777DNWrFjBjh07GDVqFGfOnCE6OpqsrCw++OCDNn3+zbaRbPKXv/wFHx8f9PX12bZtmwRA0W1IABRtqq6ujrq6OszM2n72oT3dzFJTfHw8d9xxh8711NRUORV5FdXV1fzwww9ERkYSExODgYEBU6dOZcaMGYwcOfKGCxWr1WrOnDlDTk4OQUFBWFhY3NBrSktLNWGwqVOGg4NDi/2JL57JISHmCMf3ppB66LROKzp3XxfOp2jX6WvpQElP5x5cyitF1aBCT18Pdz8XzGwsaFCpOX1Eu6B0S0vCtk7WFOeWQrO/0d+NW46nv8t1P/efoVar2bhxI8899xzffvttuy77wh9rIwnw6aefEhERQUJCAitXrpQAKLoVKQQt2lRiYiLvv/8+xcXFjB07lieffLLFGZhbyZYtW3j66ae1lppCQkKuu9R06tQprc9ub2/fHsO9JZmYmDBlyhSmTJlCXV0d8fHxbN26lYceeoiGhgamTp1KWFgYY8eOvWpfYrVazcmTJyksLGTw4ME3XMNOoVBgY2ODjY0Nffr0oaysjPz8fM6cOcMvv/yiCYNN/Yl7+Tgx+9kpzH52CnnnCzn8beMy8ckfz+HSx0kn/Cn0FORl6HbzcPS0pyi7sZ2cqkFF+olM3Pr3IjP1Is4+jtg69aCkqILczCKy0wp0Xm9ibQjak3/0G+LVLuHvq6++4tlnnyUqKqrdwx/8sTaSZ86cYfny5ezfv/8Pzy43mT9/PiUlJWzbtu2q92RlZeHl5YWXlxcnT578U88TojW03W5r0e2p1Wrq6+s1+2teeuklYmNjO3pYf9q//vUvHn74YR555BH69+/PqlWrcHV11Vp6aolSqcTR0VHzoz16r3YFhoaG3HXXXXz88cdcvHiRrVu3Ym5uzhNPPIGHhwcLFy5k+/btVFf/vpxaX1/P4cOHKSoquqnw11xTf2IfHx+GDx/O7bffjoWFBenp6ezdu5ejR4+SnZ1NXV3jUqyDux2hT07kzV0vsO7ku8x4OoSBY/qjb/D777VPoCeFF7X3AxqbG7XYn9jUsrELR/aZXH7dl0pWcib9Brni6GKNR38n9PQbD60YGOtTnHVZ5/WTHxr9hz73zYiOjmbJkiVs2bKFCRMmtPnzruVG20g2NDRw77338re//Y0+ffq0y9g+++wz5syZQ2VlJQcPHmyXZwpxLTIDKNqMQqFg1KhRjBo1ivfeew9PT08CAgJ07rter9/OpLa2lqSkJJYvX651fcKECRw6dOiarw0ICKC6uhpfX19eeumlFpeFxbUZGBgwduxYxo4dywcffEBCQgKRkZEsXbqU4uJiJk2axJQpU9iwYQMqlYrIyMhWaWUG2v2Je/fu3WL7tKaWdMbGxtg62nDnvSO4894RlBWX89OOoyTEJFGSX6rz3r1v8yDlkPaSsI2jNWeblYgBKC+pIOO3sGhmZYq1uyVKVwdOJ2mfPO7hYMWwKbr/v7Wm7du3s2jRIr788kumTJnSps+6lpttI3n58mUSExM5evQoTz75JNC4D1StVmNgYEBsbCx33nlnq41PrVZrlptdXFxYt24dI0aMaLX3F+KPkAAo2lRdXR2GhoZ8+eWXjB49WtMAXqVSaTbWN4U/laqxHEZblgH5s/7IUpOTkxNr1qwhKCiImpoavvjiC8aNG0d8fLymwLW4efr6+owcOZKRI0fy7rvv8vPPP7NlyxaWLFmCiYkJw4cPJyYmhpCQECwtLVv9+ebm5nh6euLp6alpn9bUn9ja2lpTeNrExAQrWwvGPzCK8Q+MoqK0ksRdx0mIOcLRH36hprKWwqwinffv1duR5FztU8bO3kpN+AOoLKuisqwKdbWa+opKevu5YmhmTNa5Au66fwQGhm03y/zdd9/x0EMP8dlnnxEWFtZmz7kRRkZGBAUFERcXp7UHMC4ujtDQUJ37rays+OWXX7SuRUREsHv3brZu3Yqnp2erjm/Pnj1UVlYyfvx4XFxcGDp0KO+//36b/LkU4kZJABRtytDQkNLSUo4cOcLy5cs1/VmbQt7hw4c1pSJsbGy0XtuZZwZvdKkJoG/fvvTt21fz8+DgYC5cuMA777wjAbCV6OnpMWDAAF5++WV8fX156623iI2N5a233uKxxx5j3LhxhIaGMmXKFKytrVv9z5WpqSnu7u64u7tTXV2t6UJy+vRprKysNOVlzMzMMLc2Y8ycYMbMCaamsobj8SkciPqZ8pJKTZs5Q2MDMlOzdJ5jY29N9tl8rWtX1h0889tpY0NjAybc13YzTLt372bevHmsWbOG2bNnt9lzbkZ4eDgPPPAAgwcP1rSRzMzM1HQFurKNpJ6enk5nkqaw3hYdS9atW8df/vIX9PX18fPzw9vbmy1btvDII4+0+rOEuFESAEWbqa+vx8DAgM2bN6NUKhk0aJDma9nZ2Tz99NOcPHkSAwMDHnzwQaZPn05ERAQ9evTQClQpKSkkJCTg6+tLcHBwB32aRje71HQ1w4YNY+PGja09vG7t888/p6amhri4OCwtLRkzZgwrV64kOTmZrVu38uGHH/Lkk08yduxYwsLCmDp1Kra2tq0eBk1MTHB1dcXV1VXTSzcvL4+zZ89iYWGhCYMWFhYYmxlz++QAbp8cQF1NHcfjU0iISaI4p4SjP/yq9b4W1macPZah87yWZvmGhAzC1smmVT9Xk3379nHPPffw4Ycfcs8993Saf6TNnTuXoqIiXnvtNU0byZ07d+Lu7g5ATk4OmZmZ13mX1ldSUkJUVBQHDhzQXLv//vtZv369BEDRoaQMjGgzTcu8w4YNw9vbm9WrV2NpaUlFRQWPP/44WVlZREdHY2VlxYkTJwgPD2fixIk8//zzQGNduCVLlrBv3z48PT05cuQIJiYmvPrqq8ybN++qpz/b2tChQwkKCiIiIkJzzdfXl9DQ0GvWG7vS7NmzKS4uZvfu3W01zG5HrVZTW1uLsbHxVb9++vRpIiMjiYqK4vjx44waNYqwsDCmTZuGUqls8/7ETS3pioqKMDU1RalU4uDggIWFhU5Lul8PnCIhJokftx/hUl4pfiP6knxQe0nY1tmGktxSVCrtv8b/vnMZfiP60toOHTrEzJkzeeedd1i4cGGnCX8d7VqngCMiInjiiSe0Dn2p1WpUKhXJycn4+vq240iF+J0EQNEmmsJfVVUV5ubmbNq0iblz56JQKIiPj2f+/Pnk5+ezaNEipk6dyrhx43jzzTfZs2cPsbGxFBQU8NZbbxEdHc3//vc/+vTpQ0NDA1u3biUvL48lS5Z02Defpo4DH330kWapae3atSQnJ+Pu7q611ASwatUqPDw88PPzo7a2lo0bN/KPf/yDyMhIZs6c2SGfobtTq9Wkp6drwmBiYiLBwcGEhoYyffp0nJ2d2/TPV319PUVFRZr+xEZGRpowaGVlpdOS7uSPZzkQ8yP7v/6JywUVmq+1FArd/Vx4/9BrrT7mn376ibCwMFauXMkTTzwh4e8K1wqAQUFB3HHHHTqdUJ566ikCAwN555132meQQjQjS8Ci1dXW1rJy5UrMzMyora3FwcGB22+/XfMNIzMzk7y8PLZu3cqXX37J/fffj56eHnp6evj4+FBRUcGePXv44YcfGD9+PLGxscTGxvLAAw8wd+5c8vLyOvSbz80uNdXW1vLcc89x8eJFTE1N8fPzY8eOHUyePLmjPkK3p1Ao8PLy4vnnn+e5557jwoULREVFERUVxbJlyxgyZIimJZ2bm1ur/3kzMDDAwcEBBwcHGhoaNC3pjhw5gr6+vk5LOltPK3qPd2bms/9HSeZlEr49ws/fHeN8sm7pmMkLW+/0apMjR44wY8YM/u///k/C31WUlpbqFJEuKyvjyJEjfPnllzpF3++55x5efPFF3nzzzRsubC5Ea5IZQNHqGhoaWL16NW+99RYXLza2yQoPD+ehhx7C19eXd999l08++YTU1FSgsSTD/v372bVrF1ZWVrz++us89thjrF27lj59+hASEsKhQ4cwNzfnv//9L3Z2dh358UQXplarycnJITo6msjISPbv38/AgQMJCwsjNDSU3r17t2n4UalUFBcXk5+fT35+PgqFAgsLCy5dusRtt92mUzw8M/Uih75JJCEmifPJWZhbm7Eu9V1MzFteBv8jTpw4wZQpU1i6dClLly6V8NeC+fPn8/nnn+tcnzp1KmlpaSQnJ+t8raCgACcnJ7766itZCRAdQgKgaFNFRUV88cUXfPzxx3h4ePDf//6X48ePc8899/Dmm28yb948ndfk5OQwffp0ampq+P7771EqlaSlpREaGsrUqVNveJ+dEH+GWq2msLBQEwb37NlDv379NGGwX79+bRqG1Go1586dIz09HUNDQ01/YgcHB2xtbXUKiWefyyMvo4CAca13ijUlJYWQkBCWLFnCyy+/LOFPiC5EAqBoN1VVVZoyMC+//DLffvstYWFhTJkyhYKCAnr37k3fvn1JT09n+PDhhIeH8/zzz2tqCf71r3/lyJEj7N+/X6uOoBBtTa1Wc+nSJb755huioqKIi4vDy8uL0NBQZsyYga+vb6v/eczNzSU5OZmBAwdiZ2dHaWkp+fn55OXlUVdXp9WSri26ypw6dYqQkBAefvhhVq5cKeFPiC5GAqBoV03lXWpra/nyyy9Zs2YNOTk5BAUF8dhjjzF+/HhqampQKpV8+umnzJw5U1NOZsSIEfTt25f169d39McQ3VxpaSnffvstUVFR7Nq1C2dnZ83M4KBBg/50GMzLy+PXX39l4MCBOsu+arWay5cva8JgdXU1dnZ2KJVK7OzsWmU/2dmzZwkJCeHee+/lrbfekn9sCdEFSQAUHa6mpobMzEzc3NwwNjampqaGRx55hEuXLhEdHY1areaHH35gypQp7Nixg5CQkI4e8i1h3759/POf/yQpKUmzr+16HRv27t1LeHg4ycnJODs7s3TpUk0hXdGy8vJydu7cSWRkJDt37sTOzk5zgGTIkCE3HZ6uFf6u9vymMFhRUUHPnj1RKpXY29v/oVJJGRkZTJo0ibCwMFatWiXhT4guSgKg6JSSkpK4//77UalU9O3bl+TkZMaMGSOzfzfhf//7HwcPHiQwMJBZs2ZdNwCmp6fj7+/PwoULWbRoEQcPHuTxxx9n8+bNzJo1q/0GfgurrKxk165dREZGsmPHDiwsLJg2bRphYWEEBwdfd6n2ZsNfS89vCoOXL1+mR48emhPFV6uPeKULFy4wadIkJk6cSEREhIQ/IbowCYCi01Kr1URFRZGamkpISAgDBgzAyMioU7eI66wUCsV1A+CyZcuIiYnRnM4GWLx4McePHychIaEdRtm1VFdX8/333xMVFcU333yDoaEh06ZNY8aMGYwYMUJnqfbPhr+Wnt8UBktLS7G2ttaEwaa9uFfKyclh4sSJjBkzhjVr1rTJvkIhROch/7wTnZZCoWDWrFm89NJLBAUFaZazJPy1jYSEBCZMmKB1beLEiSQmJlJXV9dBo7p1mZiYMHXqVNavX09ubq6mB+2CBQvo3bs3jz/+OLGxsdTW1vLpp5/ywgsvtFr4a3q+m5sbQ4YMYdSoUTg6OlJYWMjBgwf58ccfSU9PJyMjA2gMn1OmTGH48OHtGv4iIiLw9PTExMSEoKAg9u/ff9V7o6KiuOuuu7C3t8fKyorg4GB27drVLuMUoiuSACiEABpPnTbvZ+zg4EB9fT2FhYUdNKquwdDQkAkTJvDxxx9z8eJFvv76a8zNzXniiSfo3bs3zz77LB4eHlhaWrbJ842NjXF1dSUoKIjRo0fj4uJCYWEhw4YNw8/Pj0mTJuHh4cG6devaLfxt2bKFp59+mhdffJGjR48yatQoQkJCrtqvd9++fdx1113s3LmTpKQk7rjjDqZNm8bRo0fbZbxCdDWyBCxEN3AjS8B9+vRhwYIFrFixQnPt4MGDjBw5kpycHBwdHdthpN3LV199xYMPPsikSZM4cuQIJSUlTJo0idDQUCZMmICZmVmbPv/cuXMsXryYrKwsCgoKcHV1ZdasWSxYsAAfH582ffbQoUMJDAxk9erVmmv9+/cnLCzshmt9+vn5MXfuXF555ZW2GqYQXZbMAAohAHB0dCQ3N1frWn5+PgYGBvTs2bODRtV17dy5kwULFrB161aio6NJT08nNjYWNzc3XnnlFTw8PLjvvvv4+uuvuXz5cqs/v6SkhPnz52Nra8uZM2coKCjgjTfeICMjg9OnT7f6865UW1tLUlKSzpaDCRMmcOjQoRt6D5VKxeXLl7G1tW2LIQrR5UkAFEIAEBwcTFxcnNa12NhYBg8eLL1K28DgwYOJiYlhypQpAOjp6TF06FD++c9/cvr0afbt20f//v35xz/+gYeHB3PnzmXTpk2UlJTwZxduysrKmDlzJvb29nz99dcYGRlhbm7OrFmz2LRpk2ZMbaWwsJCGhoYWtxw0/0fI1bz77rtUVFQwZ86cthiiEF2eBEAhuqjy8nKOHTumaVCfnp7OsWPHNHusVqxYodWKb/HixZw/f57w8HBSU1NZv34969at47nnnuuI4Xd5SqWScePGtfg1PT09AgMDeeONN0hJSeHnn38mKCiIDz74AE9PT2bNmsWGDRsoKiq66TBYXl7O7NmzMTc3Jzo6GhMTk9b4OH9I8wNdN3rCf/Pmzbz66qts2bIFpVLZVsMTokuTAChEF5WYmEhAQAABAQEAhIeHExAQoNkvlZOTo7Xh3tPTk507dxIfH8+gQYN4/fXX+eCDD6QGYAdTKBT4+/vz6quvcvz4cU6cOMHo0aNZu3YtXl5eTJ8+nU8++YS8vLzrhsHKykrmzJmDvr4+33zzTYvlYNpDU/u6lrYcNJ8VbG7Lli08/PDDfPXVV4wfP74thylElyaHQIQQ4hakVqtJS0sjMjKSqKgokpKSCA4OJjQ0lNDQUJycnLRm06qrq5k7dy4VFRV89913WFlZdeDoGw+BBAUFERERobnm6+tLaGjoVQ+BbN68mYceeojNmzdft6uNEOLaJAAKIcQtTq1Wc+HCBSIjI4mOjiYhIYEhQ4ZoWtI5ODhw3333UVhYSGxsLDY2Nh09ZLZs2cIDDzzARx99RHBwMGvWrGHt2rUkJyfj7u7OihUruHjxIhs2bAAaw9+8efN4//33mTlzpuZ9TE1Nsba27qiPIcQtSwKgEEJ0IWq1muzsbKKjo4mKimLfvn1YWlqiVCpJSEjoVKdmIyIiePvtt8nJycHf35/33nuP0aNHAzB//nwyMjKIj48HYOzYsezdu1fnPR588EE+++yzdhy1EF2DBEAhhOii1Go1BQUFLFu2jGeffRZ/f/+OHpIQopOQQyBC3AJUKtWfLv3Rme3bt49p06bh7OyMQqFg27Zt17w/Pj4ehUKh8+PkyZPtM+BbhEKhQKlU8umnn0r4E0JoMejoAQghrk9P7/d/q6lUKq2fdwUVFRXcdtttLFiw4KZOHZ86dUrrMENr9dEVQoiuTgKgEJ1YTk4OS5cuxdTUlPvuu48xY8Z0ufAHEBISQkhIyE2/TqlUdooDDUIIcavpet9JhOhCEhMTOXr0KPv37+fuu+9GqVSycuVKSktLO3ponUJAQABOTk6MGzeOPXv2dPRwhBDiliEBUIhO7PDhw9jb27N7927y8/N5//332bBhA9HR0QBdel/gtTg5ObFmzRpNDby+ffsybtw49u3b19FDE0KIW4KcAhaik8rPz+fRRx/FwsKCL774AoVCQUNDA6NHj0ahULBz506t/W/19fUYGBjwn//8h5iYGKZNm8YjjzzSoa2+/giFQkF0dPRNF/qdNm0aCoWCmJiYthmYEEJ0ITIDKEQnlZSURH5+vibYQGMfV2dnZy5fvqzTyUFfXx9oLJh7/vx5XnnlFaKiorTuaWho6LKzhsOGDePMmTMdPQwhhLglSAAUopP66aefSElJYfXq1cTFxVFWVsa//vUv4uLimD59OtA46weNS8EKhYKMjAzOnz/Pq6++SnFxMffeey8AZWVlNDQ0oK+vrwmTKpWqYz5YGzl69ChOTk4dPQwhhLglyClgITqhoqIijh8/zpAhQ+jfvz+PPvoomZmZODk58cADD/D4448Dv5eHUalU6OvrExUVha2tLZ6enpr3UqvVbNiwgaeeeophw4axYMEC5s2bh7GxcYd8tpaUl5dz9uxZzc/T09M5duwYtra2uLm56bQFW7VqFR4eHvj5+VFbW8vGjRuJjIwkMjKyoz6CEELcUmQGUIhO6MiRI+Tl5TFjxgw++OAD0tPTyc3NZceOHfz73//WzHQ1BcCm/8bExBAYGEjv3r0171VdXc327du58847mTlzJu+99x59+vTh008/bf8PdhWJiYkEBAQQEBAAQHh4OAEBAbzyyitAYzmczMxMzf21tbU899xzDBw4kFGjRnHgwAF27Nih1SNWCCHE1ckhECE6oWXLlrF3717Wrl3LgAEDNAc8WtK0/Hvx4kWGDh3KK6+8wqOPPqr5+qlTpwgMDCQyMpJJkyYBsGTJEr7//nuio6Pp168farUatVrdJWsMCiGE0CV/2wvRydTX16NUKvHx8WHAgAEAVw1/8PtevqioKGxsbBg4cKDW1/ft24eenh5jx46ltrYWgPvuu49Tp06Rk5MDNJ68bQp/Vx4UaXrvmpqaVvyE4lYVERGBp6cnJiYmBAUFsX///mvev3fvXoKCgjAxMcHLy4uPPvqonUYqhLgeCYBCdDIGBgY8++yzfPHFF8D1a/01BbdvvvlGZ/m3vLycXbt2MXLkSExMTDAyMgIa99iZmppiYmLCmTNnePvtt/nuu+8AtA6KNL33hx9+iJeXF0uWLCEvL691P7C4JWzZsoWnn36aF198kaNHjzJq1ChCQkK0luavlJ6ezuTJkxk1ahRHjx7lhRde4KmnnpJ9mkJ0ErIELEQnczPLsU3Lv3l5eQwePJgXXniBxx57TPP106dPM378eLKyshg6dCihoaHU1tby9ttvM2HCBP7973/z888/s2HDBk6cOEFJSQkrVqwgPDxcEwKhcQbwq6++4sEHH2TDhg3cf//9bfLZRec1dOhQAgMDWb16teZa//79CQsL480339S5f9myZcTExJCamqq5tnjxYo4fP05CQkK7jFkIcXVyCliITkahUGiFr2tpOv27bds2LC0tue2227S+npCQQGFhIb/++ivfffcd0dHR5OXl8dRTT/Hoo4/Sq1cvlEqlpujyunXrWLVqFcOHDyc4OFjzPsbGxiiVSiwtLRkzZkyrfVZxa6itrSUpKYnly5drXZ8wYQKHDh1q8TUJCQlMmDBB69rEiRNZt24ddXV1GBoattl4hRDXJ0vAQtzCmoJiTEwMQUFBuLu7a75WU1NDTEwM48aNw9fXl/DwcPbv38/p06d544038PDwIDc3l40bN/LRRx+RlpbGww8/TFVVFSdPngS0l58/+eQTgoODcXFxad8P2Qm9+eabDBkyBEtLS02APnXq1HVfd6vuiSssLKShoQEHBwet6w4ODuTm5rb4mtzc3Bbvr6+vp7CwsM3GKoS4MRIAhbiF6enpUVRUxN69exkwYAC9evXSfO3ChQtER0dzzz33AI2HOxoaGjQHO3bt2sW0adP48MMP2bp1K4MHD8bb25uqqirNoY+mgFlRUcH333/P7Nmzb3h2sivbu3cvTzzxBIcPHyYuLo76+nomTJhARUXFVV/TFfbENf+9b9qCcDP3t3RdCNH+ZAlYiFtccXExgwcPZvny5aSnp2v2aNnZ2bF8+XJNbbymVnFNAfDzzz+nV69evPzyy/j5+aFWq1m0aBFJSUm4urpq7tXT0yM+Pp7q6mrGjx/fAZ+w82k6MNPk008/RalUkpSUxOjRo1t8zUcffYSbmxurVq0CGvfPJSYm8s477zBr1qy2HvKfYmdnh76+vs5sX35+vs4sXxNHR8cW7zcwMKBnz55tNlYhxI2RGUAhbnE+Pj7s2bOH48eP89BDDwGNwc3GxoY33ngDExMTrfv19PRQqVT07NmT3NxcBg4ciImJCaampmRnZ+Pq6oqfn5/WazZt2sTw4cNxc3Nrt891KyktLQXA1tb2qvdcbU9cYmIidXV1bTq+P8vIyIigoCDi4uK0rsfFxTF8+PAWXxMcHKxzf2xsLIMHD5b9f0J0AhIAhegCFAoFAwYMYMiQIcDvIe9qh/z19PS49957uXDhApMnT+add95hzJgxHD58mCFDhuDh4aG5r6qqil27djF79mwpFN0CtVpNeHg4I0eOxN/f/6r33ep74sLDw/nkk09Yv349qampPPPMM2RmZrJ48WIAVqxYwbx58zT3L168mPPnzxMeHk5qairr169n3bp1PPfccx31EYQQV5AlYCG6qOuFteDgYA4cOEBERARVVVX4+fmRmZmJr68v8Pvy7/79+7l8+bLO7JVo9OSTT3LixAkOHDhw3Xtv5T1xc+fOpaioiNdee42cnBz8/f3ZuXOn5uBR83Z9np6e7Ny5k2eeeYb//Oc/ODs788EHH3T65W4hugupAyiEAKCkpIT9+/czaNAgXF1dNaU6FixYwLlz59izZ49mH6FotGTJErZt28a+ffvw9PS85r2jR48mICCA999/X3MtOjqaOXPmUFlZKcuiQoh2Jes5QnRjarWahoYGAGxsbJg2bZrmAEhTINm5cyezZ8+W8HcFtVrNk08+SVRUFLt3775u+APZEyeE6FxkCViIbkyhUGiC3ZUdSM6fP89///tfrK2tKSkpISQkpINH2rk88cQTbNq0iW+++QZLS0vNaVdra2tMTU2Bxj1xFy9eZMOGDUDjnrgPP/yQ8PBwFi5cSEJCAuvWrWPz5s0d9jmEEN2XzAAKIYDGMNi0b7C+vp5ffvmFJUuWMHLkSDn928zq1aspLS1l7NixODk5aX5s2bJFc8/V9sTFx8czaNAgXn/9ddkTJ4ToMLIHUAhxVYWFhVRXV0v3DyGE6GIkAAohhBBCdDOyBCyEEEII0c1IABRCCCGE6GYkAAohhBBCdDMSAIUQQgghuhkJgEIIIYQQ3YwEQCGEEEKIbkYCoBBCCCFENyMBUAghhBCim5EAKIQQQgjRzUgAFEIIIYToZiQACiGEEEJ0MxIAhRBCCCG6GQmAQgghhBDdjARAIYQQQohuRgKgEEIIIUQ3IwFQCCGEEKKbkQAohBBCCNHNSAAUQgghhOhmJAAKIYQQQnQzEgCFEEIIIboZCYBCCCGEEN2MBEAhhBBCiG5GAqAQQgghRDcjAVAIIYQQopuRACiEEEII0c1IABRCCCGE6GYkAAohhBBCdDMSAIUQQgghuhkJgEIIIYQQ3YwEQCGEEEKIbkYCoBBCCCFENyMBUAghhBCim5EAKIQQQgjRzUgAFEIIIYToZiQACiGEEEJ0MxIAhRBCCCG6GQmAQgghhBDdjARAIYQQQohuRgKgEEIIIUQ3IwFQCCGEEKKbkQAohBBCCNHNSAAUQgghhOhmJAAKIYQQQnQzEgCFEEIIIboZCYBCCCGEEN2MBEAhhBBCiG5GAqAQQgghRDcjAVAIIYQQopv5f/A6hnG4OqryAAAAAElFTkSuQmCC", + "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": [ + "Q_mat = np.empty([n_LA,n_p])\n", + "\n", + "pp,ll = np.meshgrid(ps,LAs)\n", + "Q_mat = Untertweng1.get_Q(pp,ll)\n", + "\n", + "fig1 = plt.figure()\n", + "ax1 = plt.axes(projection='3d')\n", + "\n", + "ax1.plot_surface(pp, ll, Q_mat,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": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2b95e8650af64ab7a401d9624aef4b85", + "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": [ + "d_LA_test = 1/(n_LA-1)\n", + "\n", + "LA_test = np.arange(0,n_LA,1)*d_LA_test\n", + "\n", + "fig = plt.figure()\n", + "plt.xlabel('Druck [Pa]')\n", + "plt.ylabel('Q [m³/s]')\n", + "\n", + "for i in range(n_LA):\n", + " LA_index = int(np.argwhere(LAs == LA_test[i]))\n", + " plt.plot(ps,Q_mat[LA_index,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'P = 1144800.0 [Pa]')" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bce1ff4c4e1946ff93e954cd79af4bfe", + "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(ps-p_test)))\n", + "p_test2 = ps[p_index]\n", + "\n", + "fig = plt.figure()\n", + "plt.plot(LAs,Q_mat[:,p_index])\n", + "plt.xlabel('LA [-]')\n", + "plt.ylabel('Q [m³/s]')\n", + "plt.title('P = '+ str(p_test2) + ' [Pa]')" + ] + } + ], + "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 new file mode 100644 index 0000000..2eff1de --- /dev/null +++ b/Turbinen/old/Durchflusskennlinie.csv @@ -0,0 +1,22 @@ +,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 new file mode 100644 index 0000000..457d819 --- /dev/null +++ b/Turbinen/old/Turbinen_class_file.py @@ -0,0 +1,33 @@ +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 new file mode 100644 index 0000000..52e26e6 --- /dev/null +++ b/Turbinen/old/Turbinen_test.ipynb @@ -0,0 +1,319 @@ +{ + "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": "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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": [ + "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 new file mode 100644 index 0000000..b7cc1dc --- /dev/null +++ b/Turbinen/old/messy.ipynb @@ -0,0 +1,278 @@ +{ + "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/Main_Programm.ipynb b/Untertweng.ipynb similarity index 76% rename from Main_Programm.ipynb rename to Untertweng.ipynb index 9ae83b9..cd4de2e 100644 --- a/Main_Programm.ipynb +++ b/Untertweng.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -11,57 +11,62 @@ "\n", "from functions.pressure_conversion import pressure_conversion\n", "from Ausgleichsbecken.Ausgleichsbecken_class_file import Ausgleichsbecken_class\n", - "from Druckrohrleitung.Druckrohrleitung_class_file import Druckrohrleitung_class" + "from Druckrohrleitung.Druckrohrleitung_class_file import Druckrohrleitung_class\n", + "from Turbinen.Turbinen_class_file import Francis_Turbine" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "#define constants\n", "\n", + "#Turbine\n", + "Q_nenn = 0.85\n", + "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "\n", "# physics\n", "g = 9.81 # gravitational acceleration [m/s²]\n", "rho = 1000. # density of water [kg/m³]\n", "\n", "# pipeline\n", - "L = 1000. # length of pipeline [m]\n", - "D = 1. # pipe diameter [m]\n", + "L = 535.+478. # length of pipeline [m]\n", + "D = 0.9 # pipe diameter [m]\n", "A_pipe = D**2/4*np.pi # pipeline area\n", - "h_pipe = 200 # hydraulic head without reservoir [m] \n", + "h_pipe = 105 # hydraulic head without reservoir [m] \n", "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", - "n = 100 # number of pipe segments in discretization\n", + "n = 50 # number of pipe segments in discretization\n", "# consider replacing Q0 with a vector be be more flexible in initial conditions\n", - "Q0 = 2. # initial flow in whole pipe [m³/s]\n", - "v0 = Q0/A_pipe # initial flow velocity [m/s]\n", - "f_D = 0.1 # Darcy friction factor\n", - "c = 400. # propagation velocity of the pressure wave [m/s]\n", + "# Q0 = Q_nenn # initial flow in whole pipe [m³/s]\n", + "# v0 = Q0/A_pipe # initial flow velocity [m/s]\n", + "f_D = 0.014 # Darcy friction factor\n", + "c = 500. # propagation velocity of the pressure wave [m/s]\n", "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", - "nt = 1000 # number of time steps after initial conditions\n", + "nt = 3000 # number of time steps after initial conditions\n", "\n", "# derivatives of the pipeline constants\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", - "initial_level = 20. # water level in upstream reservoir [m]\n", - "p0 = rho*g*initial_level-v0**2*rho/2\n", + "initial_level = 8. # water level in upstream reservoir [m]\n", + "# p0 = rho*g*initial_level-v0**2*rho/2\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+1)*dt # time vector\n", "h_vec = np.arange(0,n+1)*h_pipe/n # hydraulic head of pipeline at each node \n", - "v_init = np.full(nn,Q0/(A_pipe)) # initial velocity distribution in pipeline\n", - "p_init = (rho*g*(initial_level+h_vec)-v_init**2*rho/2)-(f_D*pl_vec/D*rho/2*v_init**2) # ref Wikipedia: Darcy Weisbach\n", + "# v_init = np.full(nn,Q0/(D**2/4*np.pi)) # initial velocity distribution in pipeline\n", + "# p_init = (rho*g*(initial_level+h_vec)-v_init**2*rho/2)-(f_D*pl_vec/D*rho/2*v_init**2) # ref Wikipedia: Darcy Weisbach\n", "\n", "\n", "# reservoir\n", - "# replace influx by time variable vector\n", - "initial_influx = Q0 # initial influx of volume to the reservoir [m³/s]\n", - "initial_outflux = Q0 # initial outflux of volume from the reservoir to the pipeline [m³/s]\n", - "initial_pipeline_pressure = p0 # Initial condition for the static pipeline pressure at the reservoir (= hydrostatic pressure - dynamic pressure) \n", + "# replace influx by vector\n", + "initial_influx = Q_nenn/1.1 # initial influx of volume to the reservoir [m³/s]\n", + "# initial_outflux = Q0 # initial outflux of volume from the reservoir to the pipeline [m³/s]\n", + "# initial_pipeline_pressure = p0 # Initial condition for the static pipeline pressure at the reservoir (= hydrostatic pressure - dynamic pressure) \n", "initial_pressure_unit = 'Pa' # DO NOT CHANGE! for pressure conversion in print statements and plot labels \n", - "conversion_pressure_unit = 'mWS' # for pressure conversion in print statements and plot labels\n", - "area_base = 20. # total base are of the cuboid reservoir [m²] \n", + "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", + "area_base = 74. # total base are of the cuboid reservoir [m²] \n", "area_outflux = A_pipe # outlfux area of the reservoir, given by pipeline area [m²]\n", "critical_level_low = 0. # for yet-to-be-implemented warnings[m]\n", "critical_level_high = np.inf # for yet-to-be-implemented warnings[m]\n", @@ -69,6 +74,7 @@ "# make sure e-RK4 method of reservoir has a small enough timestep to avoid runaway numerical error\n", "nt_eRK4 = 1000 # number of simulation steps of reservoir in between timesteps of pipeline \n", "simulation_timestep = dt/nt_eRK4\n", + "\n", "\n" ] }, @@ -91,23 +97,24 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# create objects\n", "\n", "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,simulation_timestep)\n", - "V.set_initial_level(initial_level) \n", - "V.set_influx(initial_influx)\n", - "V.set_outflux(initial_outflux)\n", - "V.set_pressure(initial_pipeline_pressure,initial_pressure_unit,conversion_pressure_unit)\n", + "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", "\n", "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", "pipe.set_pressure_propagation_velocity(c)\n", "pipe.set_number_of_timesteps(nt)\n", - "pipe.set_initial_pressure(p_init,initial_pressure_unit,conversion_pressure_unit)\n", - "pipe.set_initial_flow_velocity(v_init)\n", + "pipe.set_steady_state(initial_influx,V.level,pl_vec,h_vec,initial_pressure_unit,conversion_pressure_unit)\n", + "\n", + "\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "T1.set_steady_state(initial_influx,pipe.p0[-1])\n", + "T1.set_closing_time(30)\n", "\n", "# display the attributes of the created reservoir and pipeline object\n", "# V.get_info(full=True)\n", @@ -116,15 +123,15 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# initialization for timeloop\n", "\n", "# prepare the vectors in which the pressure and velocity distribution in the pipeline from the previous timestep are stored\n", - "v_old = v_init.copy()\n", - "p_old = p_init.copy()\n", + "v_old = pipe.v0.copy()\n", + "p_old = pipe.p0.copy()\n", "\n", "# prepare the vectors in which the temporal evolution of the boundary conditions are stored\n", " # keep in mind, that the velocity at the turbine and the pressure at the reservoir are set manually and\n", @@ -134,36 +141,26 @@ "v_boundary_tur = np.empty_like(t_vec)\n", "p_boundary_res = np.empty_like(t_vec)\n", "p_boundary_tur = np.empty_like(t_vec)\n", - "influx_vec = np.empty_like(t_vec)\n", "\n", "# prepare the vectors that store the temporal evolution of the level in the reservoir\n", - "level_vec = np.full(nt+1,initial_level) # level at the end of each pipeline timestep\n", + "level_vec = np.full(nt+1,V.level) # level at the end of each pipeline timestep\n", "level_vec_2 = np.empty([nt_eRK4]) # level throughout each reservoir timestep-used for plotting and overwritten afterwards\n", "\n", - "# set the boudary conditions for the first timestep\n", + "# set the boundary conditions for the first timestep\n", "v_boundary_res[0] = v_old[0]\n", + "v_boundary_tur[0] = v_old[-1] \n", "p_boundary_res[0] = p_old[0]\n", "p_boundary_tur[0] = p_old[-1]\n", "\n", - "v_boundary_tur[:] = v_old[0] \n", - "v_boundary_tur[1:] = 0 # instantaneous closing\n", + "LA_soll_vec = np.full_like(t_vec,T1.LA)\n", + "LA_soll_vec[1500:]= 0\n", "\n", - "const = int(np.min([1000,round(nt/1.25)])) \n", - "# # v_boundary_tur[0:const] = np.linspace(v_old[-1],0,const) # linear closing\n", - "v_boundary_tur[0:const] = v_old[1]*np.cos(t_vec[0:const]*2*np.pi)**2 # oscillating\n", - "\n", - "influx_vec[0] = initial_influx # instantaneous closing\n", - "influx_vec[1:] = initial_influx # instantaneous closing\n", - "\n", - "const2 = int(np.min([1000,round(nt/1.25)])) \n", - "# influx_vec[0:const2] = np.linspace(v_old[-1],0,const2) # linear closing\n", - "# influx_vec[0:const2] = initial_influx*np.cos(t_vec[0:const2]*2*np.pi)**2 # oscillating\n", "\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -191,8 +188,15 @@ "# axs1[2].autoscale()\n", "fig1.tight_layout()\n", "fig1.show()\n", - "plt.pause(1)\n", - "\n", + "plt.pause(1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ "# loop through time steps of the pipeline\n", "for it_pipe in range(1,pipe.nt+1):\n", "\n", @@ -200,7 +204,6 @@ " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", " V.pressure = p_old[0]\n", " V.outflux_vel = v_old[0]\n", - " V.influx = influx_vec[it_pipe]\n", " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", " for it_res in range(nt_eRK4):\n", " V.e_RK_4() # call e-RK4 to update outflux\n", @@ -208,14 +211,18 @@ " V.set_volume() # update volume in reservoir\n", " level_vec_2[it_res] = V.level # save for plotting\n", " if (V.level < critical_level_low) or (V.level > critical_level_high): # make sure to never exceed critical levels\n", + " i_max = it_pipe # for plotting only calculated values\n", " break \n", " level_vec[it_pipe] = V.level \n", "\n", " # set boundary conditions for the next timestep of the characteristic method\n", - " p_boundary_res[it_pipe] = rho*g*V.level-v_old[1]**2*rho/2\n", + " p_boundary_res[it_pipe] = rho*g*V.level-V.outflux_vel**2*rho/2\n", " v_boundary_res[it_pipe] = v_old[1]+1/(rho*c)*(p_boundary_res[it_pipe]-p_old[1])-f_D*dt/(2*D)*abs(v_old[1])*v_old[1] \\\n", " +dt*g*np.sin(alpha)\n", "\n", + " T1.change_LA(LA_soll_vec[it_pipe],dt)\n", + " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_Q(p_old[-1])\n", + "\n", " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", " pipe.set_boundary_conditions_next_timestep(v_boundary_res[it_pipe],p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", " p_boundary_tur[it_pipe] = pipe.p_boundary_tur\n", @@ -236,7 +243,7 @@ " fig1.canvas.draw()\n", " fig1.tight_layout()\n", " fig1.show()\n", - " plt.pause(0.00001) \n", + " plt.pause(0.1) \n", "\n", " # prepare for next loop\n", " p_old = pipe.p_old\n", @@ -248,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ diff --git a/Untertweng_mit_Pegelregler.ipynb b/Untertweng_mit_Pegelregler.ipynb new file mode 100644 index 0000000..0b57fc4 --- /dev/null +++ b/Untertweng_mit_Pegelregler.ipynb @@ -0,0 +1,324 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from functions.pressure_conversion import pressure_conversion\n", + "from Ausgleichsbecken.Ausgleichsbecken_class_file import Ausgleichsbecken_class\n", + "from Druckrohrleitung.Druckrohrleitung_class_file import Druckrohrleitung_class\n", + "from Turbinen.Turbinen_class_file import Francis_Turbine\n", + "from Regler.Regler_class_file import PI_controller_class" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "#define constants\n", + "\n", + "#Turbine\n", + "Q_nenn = 0.85\n", + "p_nenn,_ = pressure_conversion(10.6,'bar','Pa')\n", + "\n", + "# physics\n", + "g = 9.81 # gravitational acceleration [m/s²]\n", + "rho = 1000. # density of water [kg/m³]\n", + "\n", + "# pipeline\n", + "L = 535.+478. # length of pipeline [m]\n", + "D = 0.9 # pipe diameter [m]\n", + "A_pipe = D**2/4*np.pi # pipeline area\n", + "h_pipe = 105 # hydraulic head without reservoir [m] \n", + "alpha = np.arcsin(h_pipe/L) # Höhenwinkel der Druckrohrleitung \n", + "n = 50 # number of pipe segments in discretization\n", + "f_D = 0.014 # Darcy friction factor\n", + "c = 500. # propagation velocity of the pressure wave [m/s]\n", + "# consider prescribing a total simulation time and deducting the number of timesteps from that\n", + "nt = 1500 # number of time steps after initial conditions\n", + "\n", + "# derivatives of the pipeline constants\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", + "initial_level = 8. # water level in upstream reservoir [m]\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+1)*dt # time vector\n", + "h_vec = np.arange(0,n+1)*h_pipe/n # hydraulic head of pipeline at each node \n", + "\n", + "# reservoir\n", + "# replace influx by vector\n", + "initial_influx = Q_nenn/1.1 # initial influx of volume to the reservoir [m³/s]\n", + "initial_pressure_unit = 'Pa' # DO NOT CHANGE! for pressure conversion in print statements and plot labels \n", + "conversion_pressure_unit = 'bar' # for pressure conversion in print statements and plot labels\n", + "area_base = 74. # total base are of the cuboid reservoir [m²] \n", + "area_outflux = A_pipe # outlfux area of the reservoir, given by pipeline area [m²]\n", + "critical_level_low = 0. # for yet-to-be-implemented warnings[m]\n", + "critical_level_high = np.inf # for yet-to-be-implemented warnings[m]\n", + "\n", + "\n", + "# define controller constants\n", + "target_level = initial_level # m\n", + "Kp = 2\n", + "Ti = 10\n", + "deadband_range = 0.05 # m\n", + "\n", + "# make sure e-RK4 method of reservoir has a small enough timestep to avoid runaway numerical error\n", + "nt_eRK4 = 1000 # number of simulation steps of reservoir in between timesteps of pipeline \n", + "simulation_timestep = dt/nt_eRK4\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Ideas for checks after constant definitions: \n", + "\n", + "- Check that the initial pressure is not negative:\n", + " - may happen, if there is too little hydraulic head to create the initial flow conditions with the given friction\n", + "
\n", + "
\n", + "- plausbility checks?\n", + " - area > area_outflux ?\n", + " - propable ranges for parameters?\n", + " - angle and height/length fit together?\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# create objects\n", + "\n", + "V = Ausgleichsbecken_class(area_base,area_outflux,critical_level_low,critical_level_high,simulation_timestep)\n", + "V.set_steady_state(initial_influx,initial_level,initial_pressure_unit,conversion_pressure_unit)\n", + "\n", + "pipe = Druckrohrleitung_class(L,D,n,alpha,f_D)\n", + "pipe.set_pressure_propagation_velocity(c)\n", + "pipe.set_number_of_timesteps(nt)\n", + "pipe.set_steady_state(initial_influx,V.level,pl_vec,h_vec,initial_pressure_unit,conversion_pressure_unit)\n", + "\n", + "\n", + "T1 = Francis_Turbine(Q_nenn,p_nenn)\n", + "T1.set_steady_state(initial_influx,pipe.p0[-1])\n", + "T1.set_closing_time(5)\n", + "\n", + "Pegelregler = PI_controller_class(target_level,deadband_range,Kp,Ti,dt)\n", + "\n", + "# display the attributes of the created reservoir and pipeline object\n", + "# V.get_info(full=True)\n", + "# pipe.get_info()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# initialization for timeloop\n", + "\n", + "# prepare the vectors in which the pressure and velocity distribution in the pipeline from the previous timestep are stored\n", + "v_old = pipe.v0.copy()\n", + "p_old = pipe.p0.copy()\n", + "\n", + "# prepare the vectors in which the temporal evolution of the boundary conditions are stored\n", + " # keep in mind, that the velocity at the turbine and the pressure at the reservoir are set manually and\n", + " # through the time evolution of the reservoir respectively \n", + " # the pressure at the turbine and the velocity at the reservoir are calculated from the method of characteristics\n", + "v_boundary_res = np.empty_like(t_vec)\n", + "v_boundary_tur = np.empty_like(t_vec)\n", + "p_boundary_res = np.empty_like(t_vec)\n", + "p_boundary_tur = np.empty_like(t_vec)\n", + "influx_vec = np.empty_like(t_vec)\n", + "\n", + "# prepare the vectors that store the temporal evolution of the level in the reservoir\n", + "level_vec = np.full(nt+1,V.level) # level at the end of each pipeline timestep\n", + "level_vec_2 = np.empty([nt_eRK4]) # level throughout each reservoir timestep-used for plotting and overwritten afterwards\n", + "\n", + "# set the boundary conditions for the first timestep\n", + "v_boundary_res[0] = v_old[0]\n", + "v_boundary_tur[0] = v_old[-1] \n", + "p_boundary_res[0] = p_old[0]\n", + "p_boundary_tur[0] = p_old[-1]\n", + "\n", + "LA_soll_vec = np.full_like(t_vec,T1.LA)\n", + "Pegelregler.control_variable = T1.LA\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib qt5\n", + "# time loop\n", + "\n", + "# create a figure and subplots to display the velocity and pressure distribution across the pipeline in each pipeline step\n", + "fig1,axs1 = plt.subplots(2,1)\n", + "fig1.suptitle(str(0) +' s / '+str(round(t_vec[-1],2)) + ' s' )\n", + "axs1[0].set_title('Pressure distribution in pipeline')\n", + "axs1[1].set_title('Velocity distribution in pipeline')\n", + "axs1[0].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", + "axs1[0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "axs1[1].set_xlabel(r'$x$ [$\\mathrm{m}$]')\n", + "axs1[1].set_ylabel(r'$v$ [$\\mathrm{m} / \\mathrm{s}$]')\n", + "lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit)[0],marker='.')\n", + "lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.')\n", + "axs1[0].autoscale()\n", + "axs1[1].set_ylim([0,2])\n", + "# displaying the reservoir level within each pipeline timestep\n", + "# axs1[2].set_title('Level reservoir')\n", + "# axs1[2].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "# axs1[2].set_ylabel(r'$h$ [m]')\n", + "# lo_02, = axs1[2].plot(level_vec_2)\n", + "# axs1[2].autoscale()\n", + "fig1.tight_layout()\n", + "fig1.show()\n", + "plt.pause(1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# loop through time steps of the pipeline\n", + "for it_pipe in range(1,pipe.nt+1):\n", + "\n", + " if it_pipe == 150:\n", + " V.influx = 0\n", + "\n", + "# for each pipeline timestep, execute nt_eRK4 timesteps of the reservoir code\n", + " # set initial conditions for the reservoir time evolution calculted with e-RK4\n", + " V.pressure = p_old[0]\n", + " V.outflux_vel = v_old[0]\n", + " # calculate the time evolution of the reservoir level within each pipeline timestep to avoid runaway numerical error\n", + " for it_res in range(nt_eRK4):\n", + " V.e_RK_4() # call e-RK4 to update outflux\n", + " V.level = V.update_level(V.timestep) # \n", + " V.set_volume() # update volume in reservoir\n", + " level_vec_2[it_res] = V.level # save for plotting\n", + " if (V.level < critical_level_low) or (V.level > critical_level_high): # make sure to never exceed critical levels\n", + " break \n", + " level_vec[it_pipe] = V.level \n", + "\n", + " # set boundary conditions for the next timestep of the characteristic method\n", + " p_boundary_res[it_pipe] = rho*g*V.level-V.outflux_vel**2*rho/2\n", + " v_boundary_res[it_pipe] = v_old[1]+1/(rho*c)*(p_boundary_res[it_pipe]-p_old[1])-f_D*dt/(2*D)*abs(v_old[1])*v_old[1] \\\n", + " +dt*g*np.sin(alpha)\n", + "\n", + " LA_soll_vec[it_pipe] = Pegelregler.get_control_variable(V.level)\n", + " T1.change_LA(LA_soll_vec[it_pipe],dt)\n", + " v_boundary_tur[it_pipe] = 1/A_pipe*T1.get_Q(p_old[-1])\n", + "\n", + " # the the boundary conditions in the pipe.object and thereby calculate boundary pressure at turbine\n", + " pipe.set_boundary_conditions_next_timestep(v_boundary_res[it_pipe],p_boundary_res[it_pipe],v_boundary_tur[it_pipe])\n", + " p_boundary_tur[it_pipe] = pipe.p_boundary_tur\n", + "\n", + " # perform the next timestep via the characteristic method\n", + " pipe.timestep_characteristic_method()\n", + "\n", + " # plot some stuff\n", + " # remove line-objects to autoscale axes (there is definetly a better way, but this works ¯\\_(ツ)_/¯ )\n", + " lo_00.remove()\n", + " lo_01.remove()\n", + " # lo_02.remove()\n", + " # plot new pressure and velocity distribution in the pipeline\n", + " lo_00, = axs1[0].plot(pl_vec,pressure_conversion(pipe.p_old,initial_pressure_unit, conversion_pressure_unit)[0],marker='.',c='blue')\n", + " lo_01, = axs1[1].plot(pl_vec,pipe.v_old,marker='.',c='blue')\n", + " # lo_02, = axs1[2].plot(level_vec_2,c='blue')\n", + " fig1.suptitle(str(round(t_vec[it_pipe],2))+ ' s / '+str(round(t_vec[-1],2)) + ' s' )\n", + " fig1.canvas.draw()\n", + " fig1.tight_layout()\n", + " fig1.show()\n", + " plt.pause(0.1) \n", + "\n", + " # prepare for next loop\n", + " p_old = pipe.p_old\n", + " v_old = pipe.v_old \n", + "\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# plot time evolution of boundary pressure and velocity as well as the reservoir level\n", + "\n", + "fig2,axs2 = plt.subplots(3,2)\n", + "axs2[0,0].plot(t_vec,pressure_conversion(p_boundary_res,initial_pressure_unit, conversion_pressure_unit)[0])\n", + "axs2[0,1].plot(t_vec,v_boundary_res)\n", + "axs2[1,0].plot(t_vec,pressure_conversion(p_boundary_tur,initial_pressure_unit, conversion_pressure_unit)[0])\n", + "axs2[1,1].plot(t_vec,v_boundary_tur)\n", + "axs2[2,0].plot(t_vec,level_vec)\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", + "axs2[2,0].set_title('Level reservoir')\n", + "axs2[0,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[0,0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "axs2[0,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[0,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs2[1,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[1,0].set_ylabel(r'$p$ ['+conversion_pressure_unit+']')\n", + "axs2[1,1].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[1,1].set_ylabel(r'$v$ [$\\mathrm{m}/\\mathrm{s}$]')\n", + "axs2[2,0].set_xlabel(r'$t$ [$\\mathrm{s}$]')\n", + "axs2[2,0].set_ylabel(r'$h$ [m]')\n", + "axs2[2,1].axis('off')\n", + "fig2.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.13 ('DT_Slot_3')", + "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": "4a28055eb8a3160fa4c7e4fca69770c4e0a1add985300856aa3fcf4ce32a2c48" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/untertweng.txt b/untertweng.txt new file mode 100644 index 0000000..1c6adb3 --- /dev/null +++ b/untertweng.txt @@ -0,0 +1,22 @@ +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)