diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2075d9c..883b6ee 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -53,7 +53,7 @@ repos: - id: blacken-docs - repo: https://github.com/asottile/pyupgrade - rev: v2.35.0 + rev: v2.37.3 hooks: - id: pyupgrade @@ -70,13 +70,13 @@ repos: # types_or: [python] # args: ["--write","--no-fixers"] - - repo: https://github.com/regebro/pyroma - rev: "4.0" - hooks: - - id: pyroma + # - repo: https://github.com/regebro/pyroma + # rev: "4.0" + # hooks: + # - id: pyroma - repo: https://github.com/commitizen-tools/commitizen - rev: v2.28.0 + rev: v2.31.0 hooks: - id: commitizen stages: [commit-msg] diff --git a/pyproject.toml b/pyproject.toml index 6ddb5c8..83c1c1b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,89 @@ +[project] +name = "mettoolbox" +dynamic = ["readme", "version"] +description="mettoolbox is set of command line and Python tools for the analysis and reporting of meteorological data." +requires-python = ">=3.7.1" +dependencies = [ + "toolbox_utils < 1.0.0", + "cltoolbox", + "solarpy", + "standard-precip", + "pydaymet", + "pyet", + ] +license = {file = "LICENSE.txt"} +authors = [ + {name = "Tim Cera", email = "tim@cerazone.net"} + ] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Science/Research", + "Intended Audience :: End Users/Desktop", + "Intended Audience :: Developers", + "Environment :: Console", + "License :: OSI Approved :: BSD License", + "Natural Language :: English", + "Operating System :: OS Independent", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Topic :: Scientific/Engineering :: Information Analysis", + "Topic :: Scientific/Engineering", + "Topic :: Software Development :: Libraries :: Python Modules", + ] +keywords = ["time-series", + "cli-app", + "meteorology", + "evaporation", + "precipitation", + "climate", + "weather", + "climate-data", + "climate-data-analysis", + "climate-data-analysis-tools", + "temperature", + "humidity", + "wind", + ] + +[project.optional-dependencies] +dev = [ + "black", + "cleanpy", + "twine", + "pytest", + "coverage", + "flake8", + "pytest-cov", + "pytest-mpl", + "pre-commit", + "black-nbconvert", + "blacken-docs", + "velin", + "isort", + "pyroma", + "pyupgrade", + "commitizen", + ] + +[project.scripts] +mettoolbox = "mettoolbox.mettoolbox:main" + +[project_urls] +documentation = "https://timcera.bitbucket.io/mettoolbox/docs/index.html#mettoolbox-documentation" +github = "https://github.com/timcera/mettoolbox" +bitbucket = "https://bitbucket.org/timcera/mettoolbox/src/main/" + +[tool.setuptools] +include-package-data = true + +[tool.setuptools.dynamic] +readme = {file = "README.rst"} +version = {file = "VERSION"} + +[tool.setuptools.packages.find] +where = ["src"] +exclude = ["examples*", "tools*", "docs*", "mettoolbox.tests*"] [tool.check-manifest] ignore = [".travis.yml", diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index 0bf4009..0000000 --- a/setup.cfg +++ /dev/null @@ -1,3 +0,0 @@ - -[upload_docs] -upload-dir = docs/_build/html diff --git a/setup.py b/setup.py index 86bcec6..44b2869 100644 --- a/setup.py +++ b/setup.py @@ -4,11 +4,12 @@ import subprocess import sys -from setuptools import find_packages, setup +from setuptools import setup pkg_name = "mettoolbox" -version = open("VERSION").readline().strip() +with open("VERSION", encoding="ascii") as version_file: + version = version_file.readline().strip() if sys.argv[-1] == "publish": subprocess.run(shlex.split("cleanpy ."), check=True) @@ -18,68 +19,4 @@ ) sys.exit() -README = open("README.rst").read() - -install_requires = [ - # List your project dependencies here. - # For more details, see: - # http://packages.python.org/distribute/setuptools.html#declaring-dependencies - "tstoolbox > 103.18.4", - "solarpy", - "standard-precip", - "pydaymet", - "pyet", -] - -extras_require = { - "dev": [ - "black", - "cleanpy", - "twine", - "pytest", - "coverage", - "flake8", - "pytest-cov", - "pytest-mpl", - "pre-commit", - ] -} - -setup( - name=pkg_name, - version=version, - description="mettoolbox is set of command line and Python tools for the analysis and reporting of meteorological data.", - long_description=README, - classifiers=[ - # Get strings from - # http://pypi.python.org/pypi?%3Aaction=list_classifiers - "Development Status :: 5 - Production/Stable", - "Intended Audience :: Science/Research", - "Intended Audience :: End Users/Desktop", - "Intended Audience :: Developers", - "Environment :: Console", - "License :: OSI Approved :: BSD License", - "Natural Language :: English", - "Operating System :: OS Independent", - "Programming Language :: Python :: 3.7", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", - "Topic :: Scientific/Engineering :: Information Analysis", - "Topic :: Scientific/Engineering", - "Topic :: Software Development :: Libraries :: Python Modules", - ], - keywords="time_series", - author="Tim Cera, PE", - author_email="tim@cerazone.net", - url=f"http://timcera.bitbucket.io/{pkg_name}/docs/index.html", - license="BSD", - packages=find_packages("src"), - package_dir={"": "src"}, - include_package_data=True, - zip_safe=False, - install_requires=install_requires, - extras_require=extras_require, - entry_points={"console_scripts": [f"{pkg_name}={pkg_name}.{pkg_name}:main"]}, - test_suite="tests", - python_requires=">=3.7.1", -) +setup() diff --git a/src/mettoolbox/disaggregate.py b/src/mettoolbox/disaggregate.py index 3a64d56..ab00a86 100644 --- a/src/mettoolbox/disaggregate.py +++ b/src/mettoolbox/disaggregate.py @@ -14,7 +14,8 @@ import numpy as np import pandas as pd import typic -from tstoolbox import tstoolbox, tsutils +from toolbox_utils import tsutils +from tstoolbox import tstoolbox from .melodist.melodist.humidity import ( calculate_month_hour_precip_mean, @@ -95,7 +96,7 @@ def temperature( tsutils.error_wrapper( """ The methods "mean_course_min", "mean_course_mean", or if `max_delta` is -True, or if `min_max_time` is "sun_loc_shift" require a HOURLY temperature +True, or if `min_max_time` is "sun_loc_shift" require a HOURLY temperature values in the CSV file specified by the keyword `hourly`.""" ) ) @@ -710,17 +711,18 @@ def precipitation( pd.options.display.width = 60 tsd = tsutils.common_kwds( - tsutils.read_iso_ts( - input_ts, skiprows=skiprows, names=names, index_type=index_type - ), + input_tsd=tsutils.make_list(input_ts), + skiprows=skiprows, + index_type=index_type, start_date=start_date, end_date=end_date, - pick=columns, round_index=round_index, + names=names, dropna=dropna, + clean=clean, source_units=source_units, target_units=target_units, - clean=clean, + usecols=columns, ) if method == "masterstation": @@ -731,10 +733,25 @@ def precipitation( # If masterstations_hour_col is a column number: masterstation_hour_col = int(masterstation_hour_col) - 1 - masterstation_hour_col = tsd.columns[masterstation_hour_col] + try: + mhour = tsd[masterstation_hour_col].to_frame() + except: + mhour = tsutils.common_kwds( + input_tsd=tsutils.make_list(input_ts), + skiprows=skiprows, + index_type=index_type, + start_date=start_date, + end_date=end_date, + round_index=round_index, + names=names, + dropna=dropna, + clean=clean, + source_units=source_units, + target_units=target_units, + usecols=columns, + ) # Should only be one hourly column in the input. - mhour = tsd[masterstation_hour_col].to_frame() dsum = mhour.groupby(pd.Grouper(freq="D")).sum().asfreq("H", method="ffill") master = mhour.join(dsum, rsuffix="sum") mask = master.iloc[:, 0] > 0.0 diff --git a/src/mettoolbox/indices.py b/src/mettoolbox/indices.py index e84df02..dd9270f 100644 --- a/src/mettoolbox/indices.py +++ b/src/mettoolbox/indices.py @@ -5,7 +5,7 @@ import pandas as pd import typic from standard_precip.spi import SPI -from tstoolbox import tsutils +from toolbox_utils import tsutils def _nlarge_nsmall( diff --git a/src/mettoolbox/meteo_utils.py b/src/mettoolbox/meteo_utils.py new file mode 100644 index 0000000..5c8249e --- /dev/null +++ b/src/mettoolbox/meteo_utils.py @@ -0,0 +1,580 @@ +# -*- coding: utf-8 -*- +"""The meteo_utils module contains utility functions for meteorological data + +""" + +from numpy import arccos, array, clip, cos, exp, log, minimum, mod, pi, sin, tan +from pandas import to_numeric + +# Specific heat of air [MJ kg-1 °C-1] +CP = 1.013 * 10**-3 + + +def calc_psy(pressure, tmean=None): + """Psychrometric constant [kPa °C-1]. + + Parameters + ---------- + pressure: float + atmospheric pressure [kPa]. + tmean: float, optional + average day temperature [°C]. + + Returns + ------- + pandas.Series containing the Psychrometric constant [kPa °C-1]. + + Examples + -------- + >>> psy = calc_psy(pressure, tmean) + + Notes + ----- + if tmean is none: + Based on equation 8 in [allen_1998]_. + elif rh is None: + From FAO (1990), ANNEX V, eq. 4. + + References + ---------- + .. [allen_1998] Allen, R. G., Pereira, L. S., Raes, D., & Smith, M. (1998). + Crop evapotranspiration-Guidelines for computing crop water + requirements-FAO Irrigation and drainage paper 56. Fao, Rome, 300. + (http://www.fao.org/3/x0490e/x0490e06.htm#TopOfPage). + """ + if tmean is None: + return 0.000665 * pressure + else: + lambd = calc_lambda(tmean) # MJ kg-1 + return CP * pressure / (0.622 * lambd) + + +def calc_vpc(tmean): + """Slope of saturation vapour pressure curve at air Temperature [kPa °C-1]. + + Parameters + ---------- + tmean: pandas.Series, optional + average day temperature [°C] + + Returns + ------- + pandas.Series containing the calculated Saturation vapour pressure + [kPa °C-1]. + + Examples + -------- + >>> vpc = calc_vpc(tmean) + + Notes + ----- + Based on equation 13. in [allen_1998]_. + """ + es = calc_e0(tmean) + return 4098 * es / (tmean + 237.3) ** 2 + + +def calc_lambda(tmean): + """Latent Heat of Vaporization [MJ kg-1]. + + Parameters + ---------- + tmean: pandas.Series/float, optional + average day temperature [°C] + + Returns + ------- + pandas.Series containing the calculated Latent Heat of Vaporization + [MJ kg-1]. + + Examples + -------- + >>> lambd = calc_lambda(tmean) + + Notes + ----- + Based on equation (3-1) in [allen_1998]_. + """ + return 2.501 - 0.002361 * tmean + + +def calc_press(elevation): + """Atmospheric pressure [kPa]. + + Parameters + ---------- + elevation: float, optional + the site elevation [m] + + Returns + ------- + pandas.Series containing the calculated atmospheric pressure [kPa]. + + Examples + -------- + >>> pressure = calc_press(elevation) + + Notes + ----- + Based on equation 7 in [allen_1998]_. + """ + return 101.3 * ((293 - 0.0065 * elevation) / 293) ** 5.26 + + +def calc_rho(pressure, tmean, ea): + """atmospheric air density calculated according to [allen_1998]_.. + + Parameters + ---------- + pressure: pandas.Series/float + atmospheric pressure [kPa] + tmean: pandas.Series/float, optional + average day temperature [°C] + ea: pandas.Series/float, optional + actual vapour pressure [kPa] + + Returns + ------- + pandas.Series containing the calculated mean air density + + Examples + -------- + >>> rho = calc_rho(pressure, tmean, ea) + + Notes + ----- + Based on equation (3-5) in [allen_1998]_. + + .. math:: rho = 3.486 \\frac{P}{T_{KV}} + """ + tkv = (273.16 + tmean) * (1 - 0.378 * ea / pressure) ** -1 + return 3.486 * pressure / tkv + + +def calc_e0(tmean): + """Saturation vapor pressure at the air temperature T [kPa]. + + Parameters + ---------- + tmean: pandas.Series, optional + average day temperature [°C] + + Returns + ------- + pandas.Series containing the calculated saturation vapor pressure at the + air temperature tmean [kPa]. + + Examples + -------- + >>> e0 = calc_e0(tmean) + + Notes + ----- + Based on equation 11 in [allen_1998]_. + """ + return 0.6108 * exp(17.27 * tmean / (tmean + 237.3)) + + +def calc_es(tmean=None, tmax=None, tmin=None): + """Saturation vapor pressure [kPa]. + + Parameters + ---------- + tmean: pandas.Series, optional + average day temperature [°C] + tmax: pandas.Series, optional + maximum day temperature [°C] + tmin: pandas.Series, optional + minimum day temperature [°C] + + Returns + ------- + pandas.Series containing the calculated saturation vapor pressure [kPa]. + + Examples + -------- + >>> es = calc_es(tmean) + + Notes + ----- + Based on equation 11, 12 in [allen_1998]_. + """ + if tmax is not None: + eamax = calc_e0(tmax) + eamin = calc_e0(tmin) + return (eamax + eamin) / 2 + else: + return calc_e0(tmean) + + +def calc_ea(tmean=None, tmax=None, tmin=None, rhmax=None, rhmin=None, rh=None): + """Actual vapor pressure [kPa]. + + Parameters + ---------- + tmean: pandas.Series, optional + average day temperature [°C] + tmax: pandas.Series, optional + maximum day temperature [°C] + tmin: pandas.Series, optional + minimum day temperature [°C] + rhmax: pandas.Series, optional + maximum daily relative humidity [%] + rhmin: pandas.Series, optional + mainimum daily relative humidity [%] + rh: pandas.Series, optional + mean daily relative humidity [%] + + Returns + ------- + pandas.Series containing the calculated actual vapor pressure [kPa]. + + Examples + -------- + >>> ea = calc_ea(tmean, rh) + + Notes + ----- + Based on equation 17, 19 in [allen_1998]_. + """ + if rhmax is not None: # eq. 11 + esmax = calc_e0(tmax) + esmin = calc_e0(tmin) + return (esmin * rhmax / 200) + (esmax * rhmin / 200) + else: # eq. 14 + if tmax is not None: + es = calc_es(tmax=tmax, tmin=tmin) + else: + es = calc_e0(tmean) + return rh / 100 * es + + +def day_of_year(tindex): + """Day of the year (1-365) based on pandas.Index + + Parameters + ---------- + tindex: pandas.Index + + Returns + ------- + array of with ints specifying day of year. + + """ + return to_numeric(tindex.strftime("%j")) + + +def daylight_hours(tindex, lat): + """Daylight hours [hour]. + + Parameters + ---------- + tindex: pandas.Index + lat: float + the site latitude [rad] + + Returns + ------- + pandas.Series containing the calculated daylight hours [hour] + + Notes + ----- + Based on equation 34 in [allen_1998]_. + """ + j = day_of_year(tindex) + sol_dec = solar_declination(j) + sangle = sunset_angle(sol_dec, lat) + return 24 / pi * sangle + + +def sunset_angle(sol_dec, lat): + """Sunset hour angle from latitude and solar declination - daily [rad]. + + Parameters + ---------- + sol_dec: pandas.Series + solar declination [rad] + lat: float + the site latitude [rad] + + Returns + ------- + pandas.Series containing the calculated sunset hour angle - daily [rad] + + Notes + ----- + Based on equations 25 in [allen_1998]_. + """ + return arccos(-tan(sol_dec) * tan(lat)) + + +def sunset_angle_hour(tindex, lat, lz, lon): + """Sunset hour angle from latitude and solar declination - hourly [rad]. + + Parameters + ---------- + tindex: pandas.Index + lat: float + the site latitude [rad] + lz: float + longitude of the center of the local time zone [expressed as positive + degrees west of Greenwich, England]. In the United States, Lz = 75, 90, + 105 and 120° for the Eastern, Central, Rocky Mountain and Pacific time + zones, respectively, and Lz = 0° for Greenwich, 345° for Paris + (France), and 255° for Bangkok (Thailand) [deg] + lon: float + longitude of the solar radiation measurement site [expressed as + positive degrees west of Greenwich, England] + + Returns + ------- + pandas.Series containing the calculated sunset hour angle - hourly [rad] + + Notes + ----- + Based on equations 29, 30, 31, 32, 33 in [allen_1998]_. + """ + t = tindex.hour - 0.5 + j = day_of_year(tindex) + b = 2 * pi * (j - 81) / 364 + sc = 0.1645 * sin(2 * b) - 0.1255 * cos(b) - 0.025 * sin(b) + + sol_t = t + 0.006667 * (lz - lon) + sc - 12 + + omega = array(pi / 12 * sol_t) + omega = _wrap(omega, -pi, pi) + + sol_dec = solar_declination(j) + omegas = arccos(clip(-tan(lat) * tan(sol_dec), -1, 1)) + + omega1 = omega - (pi / 24) + omega2 = omega + (pi / 24) + + omega1 = clip(omega1, -omegas, omegas) + omega2 = clip(omega2, -omegas, omegas) + omega1 = minimum(omega1, omega2) + return array(omega1), array(omega2) + + +def _wrap(x, x_min, x_max): + """Wrap floating point values into range - github.com/WSWUP/RefET + Parameters + ---------- + x : ndarray + Values to wrap. + x_min : float + Minimum value in output range. + x_max : float + Maximum value in output range. + Returns + ------- + ndarray + """ + return mod((x - x_min), (x_max - x_min)) + x_min + + +def solar_declination(j): + """Solar declination from day of year [rad]. + + Parameters + ---------- + j: array.py + day of the year (1-365) + Returns + ------- + array.py of solar declination [rad]. + + Notes + ------- + Based on equations 24 in [allen_1998]_. + """ + return 0.409 * sin(2.0 * pi / 365.0 * j - 1.39) + + +def relative_distance(j): + """Inverse relative distance between earth and sun from day of the year. + + Parameters + ---------- + j: array.py + day of the year (1-365) + Returns + ------- + array.py specifyng relative distance between earth and sun. + + Notes + ------- + Based on equations 23 in [allen_1998]_. + """ + return 1 + 0.033 * cos(2.0 * pi / 365.0 * j) + + +def extraterrestrial_r(tindex, lat): + """Extraterrestrial daily radiation [MJ m-2 d-1]. + + Parameters + ---------- + tindex: pandas.Index + lat: float + the site latitude [rad] + + Returns + ------- + pandas.Series containing the calculated extraterrestrial radiation + + Notes + ----- + Based on equation 21 in [allen_1998]_. + """ + j = day_of_year(tindex) + dr = relative_distance(j) + sol_dec = solar_declination(j) + + omega = sunset_angle(sol_dec, lat) + xx = sin(sol_dec) * sin(lat) + yy = cos(sol_dec) * cos(lat) + return 118.08 / 3.141592654 * dr * (omega * xx + yy * sin(omega)) + + +def extraterrestrial_r_hour(tindex, lat, lz, lon): + """Extraterrestrial hourly radiation [MJ m-2 h-1]. + + Parameters + ---------- + tindex: pandas.Index + lat: float + the site latitude [rad] + lz: float + longitude of the center of the local time zone [expressed as positive + degrees west of Greenwich, England]. In the United States, Lz = 75, 90, + 105 and 120° for the Eastern, Central, Rocky Mountain and Pacific time + zones, respectively, and Lz = 0° for Greenwich, 345° for Paris + (France), and 255° for Bangkok (Thailand) + lon: float + longitude of the solar radiation measurement site [expressed as + positive degrees west of Greenwich, England] + + Returns + ------- + pandas.Series containing the calculated extraterrestrial radiation + + Notes + ----- + Based on equation 55 in [ASCE_2000]_. + + """ + j = day_of_year(tindex) + dr = relative_distance(j) + sol_dec = solar_declination(j) + + omega1, omega2 = sunset_angle_hour(tindex, lat, lz, lon) + xx = sin(sol_dec) * sin(lat) + yy = cos(sol_dec) * cos(lat) + gsc = 4.92 + return array( + 12 / pi * gsc * dr * ((omega2 - omega1) * xx + yy * (sin(omega2) - sin(omega1))) + ) + + +def calc_res_surf(lai=None, r_s=70, r_l=100, lai_eff=0, srs=None, co2=None): + """Surface resistance [s m-1]. + + Parameters + ---------- + lai: pandas.Series/float, optional + leaf area index [-] + r_s: pandas.series/float, optional + surface resistance [s m-1] + r_l: float, optional + bulk stomatal resistance [s m-1] + lai_eff: float, optional + 1 => LAI_eff = 0.5 * LAI + 2 => LAI_eff = lai / (0.3 * lai + 1.2) + 3 => LAI_eff = 0.5 * LAI; (LAI>4=4) + 4 => see [zhang_2008]_. + srs: float, optional + Relative sensitivity of rl to Δ[CO2] [yang_2019]_ + co2: float + CO2 concentration [ppm] + + Returns + ------- + pandas.Series containing the calculated surface resistance + + References + ----- + .. [zhang_2008] Zhang, B., Kang, S., Li, F., & Zhang, L. (2008). Comparison + of three evapotranspiration models to Bowen ratio-energy balance method + for a vineyard in an arid desert region of northwest China. Agricultural + and Forest Meteorology, 148(10), 1629-1640. + .. [yang_2019] Yang, Y., Roderick, M. L., Zhang, S., McVicar, T. R., & + Donohue, R. J. (2019). Hydrologic implications of vegetation response to + elevated CO 2 in climate projections. Nature Climate Change, 9, 44-48. + + """ + if lai is None: + return r_s + else: + fco2 = 1 + srs * (co2 - 300) + return fco2 * r_l / calc_laieff(lai=lai, lai_eff=lai_eff) + + +def calc_laieff(lai=None, lai_eff=0): + """Effective leaf area index [-]. + + Parameters + ---------- + lai: pandas.Series/float, optional + leaf area index [-] + lai_eff: float, optional + 0 => LAI_eff = 0.5 * LAI + 1 => LAI_eff = lai / (0.3 * lai + 1.2) + 2 => LAI_eff = 0.5 * LAI; (LAI>4=4) + 3 => see [zhang_2008]_. + + Returns + ------- + pandas.Series containing the calculated effective leaf area index + """ + if lai_eff == 0: + return 0.5 * lai + if lai_eff == 1: + return lai / (0.3 * lai + 1.2) + if lai_eff == 2: + laie = lai.copy() + laie[(lai > 2) & (lai < 4)] = 2 + laie[lai > 4] = 0.5 * lai + return laie + if lai_eff == 3: + laie = lai.copy() + laie[lai > 4] = 4 + return laie * 0.5 + + +def calc_res_aero(wind, croph=None, zw=2, zh=2, ra_method=1): + """Aerodynamic resistance [s m-1]. + + Parameters + ---------- + wind: pandas.Series + mean day wind speed [m/s] + croph: pandas.series/float, optional + crop height [m] + zw: float, optional + height of wind measurement [m] + zh: float, optional + height of humidity and or air temperature measurement [m] + ra_method: float, optional + 1 => ra = 208/wind + 2 => ra is calculated based on equation 36 in FAO (1990), ANNEX V. + Returns + ------- + pandas.Series containing the calculated aerodynamic resistance + """ + if ra_method == 1: + return 208 / wind + else: + d = 0.667 * croph + zom = 0.123 * croph + zoh = 0.0123 * croph + return (log((zw - d) / zom)) * (log((zh - d) / zoh) / (0.41**2) / wind) diff --git a/src/mettoolbox/mettoolbox.py b/src/mettoolbox/mettoolbox.py index 823d05b..19767f8 100644 --- a/src/mettoolbox/mettoolbox.py +++ b/src/mettoolbox/mettoolbox.py @@ -3,10 +3,11 @@ import os.path import sys import warnings +from typing import List, Optional, Union from mando import Program from mando.rst_text_formatter import RSTHelpFormatter -from tstoolbox import tsutils +from toolbox_utils import tsutils from . import disaggregate, indices, pet, ret @@ -1075,6 +1076,152 @@ def allen_cli( pet.allen.__doc__ = allen_cli.__doc__ +@program.pet.command( + "blaney_criddle", formatter_class=RSTHelpFormatter, doctype="numpy" +) +@tsutils.doc(_LOCAL_DOCSTRINGS) +def blaney_criddle_cli( + bright_hours_col, + source_units: Optional[Union[str, list]], + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, + k=0.85, + start_date=None, + end_date=None, + dropna="no", + clean=False, + round_index=None, + skiprows=None, + names=None, + target_units="mm", + print_input=False, +): + """Evaporation calculated according to [blaney_1952]_. + + Average daily temperature can be supplied or if not, calculated by + (Tmax+Tmin)/2. + + Parameters + ---------- + lat: float + The latitude of the station. Positive specifies the Northern + Hemisphere, and negative values represent the Southern + Hemisphere. + + temp_min_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily minimum temperature. + + temp_max_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily maximum temperature. + + k: float + A scaling factor, defaults to 1. This is an adjustment for local conditions, + for example, Lu, 2005 found that k=1.2 was a better fit for the southeastern + United States. + + source_units + If unit is specified for the column as the second field of a ':' + delimited column name, then the specified units and the + 'source_units' must match exactly. + + Any unit string compatible with the 'pint' library can be + used. + + Since there are two required input columns ("temp_min_col" and + "temp_max_col") and one optional input column ("temp_mean_col") + you need to supply units for each input column in `source_units`. + + Command line:: + + mettoolbox pet hamon 24 1 2 degF,degF < tmin_tmax_data.csv + + Python:: + + from mettoolbox import mettoolbox as mt + df = mt.pet.hamon(24, + 1, + 2, + ["degF", "degF"], + input_ts="tmin_tmax_data.csv") + + ${start_date} + + ${end_date} + + ${dropna} + + ${clean} + + ${round_index} + + ${skiprows} + + ${index_type} + + ${names} + + ${target_units} + + ${print_input} + + ${tablefmt} + + temp_mean_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily mean temperature. If + None will be estimated by the average of `temp_min_col` and + `temp_max_col`. + + + Returns + ------- + pandas.Series containing the calculated evaporation. + + Examples + -------- + >>> et_blaney_criddle = blaney_criddle(tmean) + + Notes + ----- + Based on equation 6 in [xu_2001]_. + + .. math:: PE=kp(0.46 * T_a + 8.13) + + References + ---------- + .. [blaney_1952] Blaney, H. F. (1952). Determining water requirements in + irrigated areas from climatological and irrigation data. + .. [xu_2001] Xu, C. Y., & Singh, V. P. (2001). Evaluation and + generalization of temperature‐based methods for calculating evaporation. + Hydrological processes, 15(2), 305-319. + """ + tsutils._printiso( + pet.blaney_criddle( + bright_hours_col=bright_hours_col, + source_units=source_units, + temp_mean_col=temp_mean_col, + temp_min_col=temp_min_col, + temp_max_col=temp_max_col, + k=k, + start_date=start_date, + end_date=end_date, + dropna=dropna, + clean=clean, + round_index=round_index, + skiprows=skiprows, + names=names, + target_units=target_units, + print_input=print_input, + ) + ) + + +pet.blaney_criddle.__doc__ = blaney_criddle_cli.__doc__ + + @program.pet.command("hamon", formatter_class=RSTHelpFormatter, doctype="numpy") @tsutils.doc(_LOCAL_DOCSTRINGS) def hamon_cli( @@ -1174,11 +1321,35 @@ def hamon_cli( None will be estimated by the average of `temp_min_col` and `temp_max_col`. + Returns + ------- + pandas.Series containing the calculated evaporation. + + Examples + -------- + >>> et_hamon = hamon(tmean, lat) + + Notes + ----- + Following [hamon_1961]_ and [oudin_2005]_. + + .. math:: PE = (\\frac{DL}{12})^2 exp(\\frac{T_a}{16}) + References ---------- - Lu et al. (2005). A comparison of six potential evaportranspiration methods for - regional use in the southeastern United States. Journal of the American Water - Resources Association, 41, 621- 633.""" + .. [hamon_1961] Hamon, W. R. (1963). Estimating potential + evapotranspiration. Transactions of the American Society of Civil + Engineers, 128(1), 324-338. + .. [oudin_2005] Oudin, L., Hervieu, F., Michel, C., Perrin, C., + Andréassian, V., Anctil, F., & Loumagne, C. (2005). Which potential + evapotranspiration input for a lumped rainfall–runoff model?: + Part 2—Towards a simple and efficient potential evapotranspiration model + for rainfall–runoff modelling. Journal of hydrology, 303(1-4), 290-306. + .. [lu_2005] Lu et al. (2005). A comparison of six potential + evapotranspiration methods for regional use in the southeastern United + States. Journal of the American Water Resources Association, 41, 621- + 633. + """ tsutils._printiso( pet.hamon( lat, @@ -1322,6 +1493,151 @@ def hargreaves_cli( pet.hargreaves.__doc__ = hargreaves_cli.__doc__ +@program.pet.command("linacre", formatter_class=RSTHelpFormatter, doctype="numpy") +@tsutils.doc(_LOCAL_DOCSTRINGS) +def linacre_cli( + lat, + elevation, + source_units, + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, + tdew_col=None, + start_date=None, + end_date=None, + dropna="no", + clean=False, + round_index=None, + skiprows=None, + index_type="datetime", + names=None, + target_units=None, + print_input=False, + tablefmt="csv", +): + """Evaporation calculated according to [linacre_1977]_. + + Average daily temperature can be supplied or if not, calculated by + (Tmax+Tmin)/2. + + Parameters + ---------- + lat: float + The latitude of the station. Positive specifies the Northern + Hemisphere, and negative values represent the Southern + Hemisphere. + + elevation: float + The elevation of the station in meters. + + temp_min_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily minimum temperature. + + temp_max_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily maximum temperature. + + source_units + If unit is specified for the column as the second field of a ':' + delimited column name, then the specified units and the + 'source_units' must match exactly. + + Any unit string compatible with the 'pint' library can be + used. + + Since there are two required input columns ("temp_min_col" and + "temp_max_col") and one optional input column ("temp_mean_col") + you need to supply units for each input column in `source_units`. + + Command line:: + + mettoolbox pet hargreaves 24 1 2 degF,degF < tmin_tmax_data.csv + + Python:: + + from mettoolbox import mettoolbox as mt + df = mt.pet.hargreaves(24, + 1, + 2, + ["degF", "degF"], + input_ts="tmin_tmax_data.csv") + + ${start_date} + + ${end_date} + + ${dropna} + + ${clean} + + ${round_index} + + ${skiprows} + + ${index_type} + + ${names} + + ${target_units} + + ${print_input} + + ${tablefmt} + + temp_mean_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily mean temperature. If + None will be estimated by the average of `temp_min_col` and + `temp_max_col`. + + Returns + ------- + pandas.Series containing the calculated evaporation. + + Examples + -------- + >>> et_linacre = linacre(tmean, elevation, lat) + + Notes + ----- + Based on equation 5 in [xu_2001]_. + + .. math:: PE = \\frac{\\frac{500 T_m}{(100-A)}+15 (T_a-T_d)}{80-T_a} + + References + ----- + .. [linacre_1977] Linacre, E. T. (1977). A simple formula for estimating + evaporation rates in various climates, using temperature data alone. + Agricultural meteorology, 18(6), 409-424. + """ + tsutils._printiso( + pet.linacre( + lat, + elevation, + source_units=source_units, + temp_min_col=temp_min_col, + temp_max_col=temp_max_col, + temp_mean_col=temp_mean_col, + tdew_col=tdew_col, + start_date=start_date, + end_date=end_date, + dropna=dropna, + clean=clean, + round_index=round_index, + skiprows=skiprows, + index_type=index_type, + names=names, + target_units=target_units, + print_input=print_input, + ), + tablefmt=tablefmt, + ) + + +pet.linacre.__doc__ = linacre_cli.__doc__ + + @program.pet.command("oudin_form", formatter_class=RSTHelpFormatter, doctype="numpy") @tsutils.doc(_LOCAL_DOCSTRINGS) def oudin_form_cli( @@ -1611,6 +1927,148 @@ def priestley_taylor_cli( pet.priestley_taylor.__doc__ = priestley_taylor_cli.__doc__ +@program.pet.command("romanenko", formatter_class=RSTHelpFormatter, doctype="numpy") +@tsutils.doc(_LOCAL_DOCSTRINGS) +def romanenko_cli( + source_units, + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, + rh_col=None, + k=4.5, + start_date=None, + end_date=None, + dropna="no", + clean=False, + round_index=None, + skiprows=None, + names=None, + target_units=None, + print_input=False, + tablefmt="csv", +): + """Evaporation calculated according to [romanenko_1961]_. + + Average daily temperature can be supplied or if not, calculated by + (Tmax+Tmin)/2. + + Parameters + ---------- + temp_min_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily minimum temperature. + + temp_max_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily maximum temperature. + + rh_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily average relative humidity. + + k: float + A scaling factor, defaults to 1. This is an adjustment for local + conditions, for example, Lu, 2005 found that k=1.2 was a better fit for + the southeastern United States. + + source_units + If unit is specified for the column as the second field of a ':' + delimited column name, then the specified units and the + 'source_units' must match exactly. + + Any unit string compatible with the 'pint' library can be + used. + + Since there are two required input columns ("temp_min_col" and + "temp_max_col") and one optional input column ("temp_mean_col") + you need to supply units for each input column in `source_units`. + + Command line:: + + mettoolbox pet hamon 24 1 2 degF,degF < tmin_tmax_data.csv + + Python:: + + from mettoolbox import mettoolbox as mt + df = mt.pet.hamon(24, + 1, + 2, + ["degF", "degF"], + input_ts="tmin_tmax_data.csv") + + ${start_date} + + ${end_date} + + ${dropna} + + ${clean} + + ${round_index} + + ${skiprows} + + ${index_type} + + ${names} + + ${target_units} + + ${print_input} + + ${tablefmt} + + temp_mean_col: str, int + The column name or number (data columns start numbering at 1) in + the input data that represents the daily mean temperature. If + None will be estimated by the average of `temp_min_col` and + `temp_max_col`. + + Returns + ------- + pandas.Series containing the calculated evaporation. + + Examples + -------- + >>> et_romanenko = romanenko(tmean, rh) + + Notes + ----- + Based on equation 11 in [xu_2001]_. + + .. math:: PE=4.5(1 + (\\frac{T_a}{25})^2 (1 \\frac{e_a}{e_s}) + + References + ---------- + .. [romanenko_1961] Romanenko, V. A. (1961). Computation of the autumn soil + moisture using a universal relationship for a large area. Proc. of + Ukrainian Hydrometeorological Research Institute, 3, 12-25. + """ + tsutils._printiso( + pet.romanenko( + source_units, + temp_mean_col=temp_mean_col, + temp_min_col=temp_min_col, + temp_max_col=temp_max_col, + rh_col=rh_col, + k=k, + start_date=start_date, + end_date=end_date, + dropna=dropna, + clean=clean, + round_index=round_index, + skiprows=skiprows, + names=names, + target_units=target_units, + print_input=print_input, + tablefmt=tablefmt, + ) + ) + + +pet.romanenko.__doc__ = romanenko_cli.__doc__ + + @program.ret.command( "penman_monteith", formatter_class=RSTHelpFormatter, doctype="numpy" ) diff --git a/src/mettoolbox/pet.py b/src/mettoolbox/pet.py index 02e62c3..07240b7 100644 --- a/src/mettoolbox/pet.py +++ b/src/mettoolbox/pet.py @@ -1,16 +1,17 @@ # -*- coding: utf-8 -*- - import warnings from typing import Optional, Union + import pandas as pd import pydaymet.pet as daypet -import pyet import typic -from tstoolbox import tsutils +from numpy import exp +from toolbox_utils import tsutils from tstoolbox.tstoolbox import read from . import utils +from .meteo_utils import calc_ea, calc_es, daylight_hours warnings.filterwarnings("ignore") @@ -54,7 +55,6 @@ def _temp_read( round_index=None, skiprows=None, index_type="datetime", - names=None, ): if temp_mean_col is None: tsd = tsutils.common_kwds( @@ -208,25 +208,24 @@ def et0_pm( @typic.al -def hamon( - lat: tsutils.FloatLatitude, - source_units, - temp_mean_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_min_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_max_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - k: float = 1, +def blaney_criddle( + bright_hours_col, + source_units: Optional[Union[str, list]], + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, + k=0.85, start_date=None, end_date=None, dropna="no", clean=False, round_index=None, skiprows=None, - index_type="datetime", names=None, - target_units=None, + target_units="mm", print_input=False, ): - """hamon""" + """Evaporation calculated according to [blaney_1952]_.""" tsd = _temp_read( temp_min_col, temp_max_col, @@ -238,37 +237,43 @@ def hamon( clean=clean, round_index=round_index, skiprows=skiprows, - index_type=index_type, names=names, ) - pe = pyet.temperature.hamon(tsd["tmean:degC"], lat) - pe.columns = ["pe_hamon:mm"] + bright_hours = tsutils.common_kwds( + bright_hours_col, + start_date=start_date, + end_date=end_date, + round_index=round_index, + dropna=dropna, + clean=clean, + ) + + pet = k * bright_hours * (0.46 * tsd["tmean:degC"] + 8.13) + pet.columns = ["pet_blaney_criddle:mm"] if target_units != source_units: - pe = tsutils.common_kwds(pe, source_units="mm", target_units=target_units) - return tsutils.return_input(print_input, tsd, pe) + pet = tsutils.common_kwds(pet, source_units="mm", target_units=target_units) + return tsutils.return_input(print_input, tsd, pet) @typic.al -def blaney_criddle( - p, - source_units, - temp_mean_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_min_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_max_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - k: float = 0.85, +def hamon( + lat: tsutils.FloatLatitude, + source_units: Optional[Union[str, list]], + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, start_date=None, end_date=None, dropna="no", clean=False, round_index=None, skiprows=None, - index_type="datetime", names=None, target_units=None, print_input=False, ): - """blaney_criddle""" + """Evaporation calculated according to [hamon_1961]_.""" tsd = _temp_read( temp_min_col, temp_max_col, @@ -280,37 +285,37 @@ def blaney_criddle( clean=clean, round_index=round_index, skiprows=skiprows, - index_type=index_type, names=names, ) - pe = pyet.temperature.blaney_criddle(tsd["tmean:degC"], p, k) - pe.columns = ["pe_blaney_criddle:mm"] + + daylh = daylight_hours(tsd.index, lat) + + pet = (daylh / 12) ** 2 * exp(tsd["tmean:degC"] / 16) + pet.columns = ["pet_hamon:mm"] if target_units != source_units: - pe = tsutils.common_kwds(pe, source_units="mm", target_units=target_units) - return tsutils.return_input(print_input, tsd, pe) + pet = tsutils.common_kwds(pet, source_units="mm", target_units=target_units) + return tsutils.return_input(print_input, tsd, pet) -@typic.al def romanenko( - rh, - source_units, - temp_mean_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_min_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_max_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - k: float = 4.5, + source_units: Optional[Union[str, list]], + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, + rh_col=None, + k=4.5, start_date=None, end_date=None, dropna="no", clean=False, round_index=None, skiprows=None, - index_type="datetime", names=None, target_units=None, print_input=False, ): - """romanenko""" + """Evaporation calculated according to [romanenko_1961]_.""" tsd = _temp_read( temp_min_col, temp_max_col, @@ -322,38 +327,47 @@ def romanenko( clean=clean, round_index=round_index, skiprows=skiprows, - index_type=index_type, names=names, ) - pe = pyet.temperature.romanenko(tsd["tmean:degC"], p, k) - pe.columns = ["pe_romanenko:mm"] + rh_col = tsutils.common_kwds( + rh_col, + start_date=start_date, + end_date=end_date, + round_index=round_index, + dropna=dropna, + clean=clean, + ) + + ea = calc_ea(tmean=tsd["tmean:degC"], rh=rh_col) + es = calc_es(tmean=tsd["tmean:degC"]) + + pet = k * (1 + tsd["tmean:degC"] / 25) ** 2 * (1 - ea / es) + pet.columns = ["pet_romanenko:mm"] if target_units != source_units: - pe = tsutils.common_kwds(pe, source_units="mm", target_units=target_units) - return tsutils.return_input(print_input, tsd, pe) + pet = tsutils.common_kwds(pet, source_units="mm", target_units=target_units) + return tsutils.return_input(print_input, tsd, pet) -@typic.al def linacre( - lat, + lat: tsutils.FloatLatitude, elevation, - source_units, - temp_mean_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_min_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - temp_max_col: Optional[Union[tsutils.IntGreaterEqualToOne, str]] = None, - tdew=None, + source_units: Optional[Union[str, list]], + temp_mean_col=None, + temp_min_col=None, + temp_max_col=None, + tdew_col=None, start_date=None, end_date=None, dropna="no", clean=False, round_index=None, skiprows=None, - index_type="datetime", names=None, target_units=None, print_input=False, ): - """linacre""" + """Evaporation calculated according to [linacre_1977]_.""" tsd = _temp_read( temp_min_col, temp_max_col, @@ -365,15 +379,33 @@ def linacre( clean=clean, round_index=round_index, skiprows=skiprows, - index_type=index_type, names=names, ) - pe = pyet.temperature.linacre(tsd["tmean:degC"], p, k) - pe.columns = ["pe_linacre:mm"] + tdew_col = tsutils.common_kwds( + tdew_col, + start_date=start_date, + end_date=end_date, + round_index=round_index, + dropna=dropna, + clean=clean, + ) + + if tdew_col is None: + tdew_col = ( + 0.52 * tsd["tmin:degC"] + + 0.6 * tsd["tmax:degC"] + - 0.009 * tsd["tmax:degC"] ** 2 + - 2 + ) + tm = tsd["tmean:degC"] + 0.006 * elevation + pet = (500 * tm / (100 - lat) + 15 * (tsd["tmean:degC"] - tdew_col)) / ( + 80 - tsd["tmean:degC"] + ) + pet.columns = ["pet_linacre:mm"] if target_units != source_units: - pe = tsutils.common_kwds(pe, source_units="mm", target_units=target_units) - return tsutils.return_input(print_input, tsd, pe) + pet = tsutils.common_kwds(pet, source_units="mm", target_units=target_units) + return tsutils.return_input(print_input, tsd, pet) @typic.al diff --git a/src/mettoolbox/ret.py b/src/mettoolbox/ret.py index dcbab62..e6b70ab 100644 --- a/src/mettoolbox/ret.py +++ b/src/mettoolbox/ret.py @@ -2,10 +2,11 @@ import warnings from typing import Optional, Union + import pandas as pd import pydaymet.pet as daypet import typic -from tstoolbox import tsutils +from toolbox_utils import tsutils from tstoolbox.tstoolbox import read warnings.filterwarnings("ignore") diff --git a/src/mettoolbox/utils.py b/src/mettoolbox/utils.py index 4035a1b..f7dab17 100644 --- a/src/mettoolbox/utils.py +++ b/src/mettoolbox/utils.py @@ -4,7 +4,7 @@ import numpy as np import pandas as pd from solarpy import declination -from tstoolbox import tsutils +from toolbox_utils import tsutils def _check_cols(*args): diff --git a/tests/Disaggregation_test.ipynb b/tests/Disaggregation_test.ipynb index b654ebb..7021963 100644 --- a/tests/Disaggregation_test.ipynb +++ b/tests/Disaggregation_test.ipynb @@ -3153,9 +3153,9 @@ "metadata": {}, "outputs": [], "source": [ - "data_obs_hourly = pd.read_csv('data_obs_hourly.csv', index_col=0, parse_dates=True)\n", - "data_obs_daily = ts.read('data_obs_daily.csv')\n", - "plot_period = slice('2014-07-01', '2014-07-05')" + "data_obs_hourly = pd.read_csv(\"data_obs_hourly.csv\", index_col=0, parse_dates=True)\n", + "data_obs_daily = ts.read(\"data_obs_daily.csv\")\n", + "plot_period = slice(\"2014-07-01\", \"2014-07-05\")" ] }, { @@ -3448,10 +3448,10 @@ "source": [ "tempdf_mettoolbox = pd.DataFrame()\n", "plt.plot(data_obs_hourly[\"temp\"].loc[plot_period])\n", - "temp_methods = [\"sine_min_max\", \"sine_mean\",\"mean_course_mean\",\"mean_course_min_max\"]\n", + "temp_methods = [\"sine_min_max\", \"sine_mean\", \"mean_course_mean\", \"mean_course_min_max\"]\n", "for method in temp_methods:\n", " print(method)\n", - " if method in [\"sine_min_max\",\"sine_mean\"]:\n", + " if method in [\"sine_min_max\", \"sine_mean\"]:\n", " tempdf_mettoolbox[method] = met.disaggregate.temperature(\n", " input_ts=data_obs_daily,\n", " temp_min_col=2,\n", @@ -3465,7 +3465,7 @@ " max_delta=False,\n", " )\n", " plt.plot(tempdf_mettoolbox[method].loc[plot_period], \"--\")\n", - " tempdf_mettoolbox[method+'_shift'] = met.disaggregate.temperature(\n", + " tempdf_mettoolbox[method + \"_shift\"] = met.disaggregate.temperature(\n", " input_ts=data_obs_daily,\n", " temp_min_col=2,\n", " temp_max_col=3,\n", @@ -3477,7 +3477,7 @@ " lon=8.86,\n", " hourly=\"data_obs_hourly_temp.csv\",\n", " max_delta=False,\n", - " ) \n", + " )\n", " plt.plot(tempdf_mettoolbox[method].loc[plot_period], \"--\")\n", " else:\n", " tempdf_mettoolbox[method] = met.disaggregate.temperature(\n", @@ -3494,7 +3494,7 @@ " )\n", " plt.plot(tempdf_mettoolbox[method].loc[plot_period], \"--\")\n", "plt.legend([\"Observations\"] + list(tempdf_mettoolbox.columns))\n", - "plt.ylabel('Temperature [K]')" + "plt.ylabel(\"Temperature [K]\")" ] }, { @@ -3791,7 +3791,7 @@ } ], "source": [ - "tempdf_mettoolbox.iloc[0:20,:]" + "tempdf_mettoolbox.iloc[0:20, :]" ] }, { @@ -3857,7 +3857,474 @@ "\n", "\n", "plt.legend([\"Observations\"] + wind_methods)\n", - "plt.ylabel('Wind speed [m/s]')" + "plt.ylabel(\"Wind speed [m/s]\")" + ] + }, + { + "cell_type": "markdown", + "id": "72a8c412", + "metadata": {}, + "source": [ + "### Humidty" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5c1a57fc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAGdCAYAAADg57m4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddZxU5f7A8c850zM7293NLt2NhCAIBioiit0gKl6x49pYqNj+9AK2goGBgkoK0t213R3TdX5/DOwysEsJLCzn/XrxujvnPOec58wdZ873ie8jSJIkIZPJZDKZTCaTyWSyU0Js6QrIZDKZTCaTyWQyWWsiB1kymUwmk8lkMplMdgrJQZZMJpPJZDKZTCaTnUJykCWTyWQymUwmk8lkp5AcZMlkMplMJpPJZDLZKSQHWTKZTCaTyWQymUx2CslBlkwmk8lkMplMJpOdQnKQJZPJZDKZTCaTyWSnkLKlK3AyPB4PRUVFGI1GBEFo6erIZDKZTCY7DpIkUV9fT3R0NKIot/PKZLLW65wMsoqKioiLi2vpashkMplMJjsJ+fn5xMbGtnQ1ZDKZ7LQ5J4Mso9EIeL+k/f39W7g2MplMJpPJjkddXR1xcXENv+MymUzWWp2TQdbBIYL+/v5ykCWTyWQy2TlGHuovk8laO3lAtEwmk8lkMplMJpOdQnKQJZPJZDKZTCaTyWSnkBxkyWQymUwmk8lkMtkpdE7OyZLJZDKZTNY6SZKEy+XC7Xa3dFVkMpnMh0qlQqFQHFdZOciSyWQymUx2VnA4HBQXF2OxWFq6KjKZTHYEQRCIjY3Fz8/vmGXlIEsmk8lkMlmL83g8ZGdno1AoiI6ORq1Wy1kIZTLZWUOSJMrLyykoKCAtLe2YPVpykCWTyWQymazFORwOPB4PcXFx6PX6lq6OTCaTHSEsLIycnBycTucxgyw58YVMJpPJZLKzhijKjyYymezsdCK96/I3mUwmk8lkMplMJpOdQiccZC1btoxLL72U6OhoBEFg7ty5PvslSeLpp58mKioKnU7H0KFD2bt3r0+Zqqoqxo8fj7+/P4GBgdx2222YTKZ/dSMymUwmk8lkMplMdjY44SDLbDbTqVMn3nvvvSb3v/rqq7z99tt8+OGHrF69GoPBwPDhw7HZbA1lxo8fz/bt2/nzzz/59ddfWbZsGXfeeefJ34VMJpPJZDLZWS4xMZG33nqrpatxyixZsgRBEKipqWnpqshkZ50TDrIuvvhiXnjhBa644ooj9kmSxFtvvcWTTz7J5ZdfTseOHfnss88oKipq6PHauXMn8+fP55NPPqFXr17079+fd955h2+++YaioqJ/fUMymUwmk8lkZ1p+fj633nprQ2bEhIQE7r//fiorK1u6aqfEoEGDmDx5ss+2vn37UlxcTEBAQMtUSiY7i53S7ILZ2dmUlJQwdOjQhm0BAQH06tWLlStXMm7cOFauXElgYCDdu3dvKDN06FBEUWT16tVNBm92ux273d7wuq6u7lRW+1+pdbp4YslqqkqKuVv7F20HX0NgQH/+b/U6Fmbl01WzgkuT1WgD/FGpAomLuxWl0tDS1T4nldmdvJNXSum6tVxm+ZrojEj8wsL4tTacTWVKMrJr6OFSMmzy/S1d1XPakq/uYblKT05QW/qE2EgsWIXH5iR/czt+S22HITiARzKLUEpZlO7eha1WweCx/4dSrW3pqp/TXC4TefkzMTvq+Kg2k5rSUoatrWT4zeOITE5l9t4/yLU5eLDdSDkxwCm2f9WP7N47C1tFJzZe4h1V8UxqDCLeSc7zy2tRiwJDQvxbtqLnGY9HotriaLHrB+nViOLxTXLPysqiT58+pKen8/XXX5OUlMT27dt56KGH+P3331m1ahXBwcGnucZHcrvdCIJw2r4z1Go1kZGRp+XcMtm57pQGWSUlJQBERET4bI+IiGjYV1JSQnh4uG8llEqCg4Mbyhxu6tSpPPvss6eyqqeM2e3hO6UBRXQStwl/Ul4Rgrs+ntW761mRnE6EtIHy+jlQDx5EnKoI0mPHtnS1z0nVLjcfF1SgD43kGsV6qu1QXQAruI8V+oHo4n7GuMLMsAPlPZKEKK+xckKKdi3HHTmf/dzM70IXhOofSDQsRzRAjjaF5QmJAIzd/Qla/SqyDUlUGkLx/PUxw0fe27KVP8eVlv5CdvZbWNHynfAl+CWTrP6exTPncO3zj/FjaSWLnZn0Kd1K/6hOLV3dViWr+B00MbnsKo/i44IKAO42bqKq4g+S2rzKH5W1/FJWw54BHeR1m86gaouDbi/81WLXX//kUEL8NMdV9p577kGtVvPHH3+g0+kAiI+Pp0uXLqSkpPDEE0/wwQcfAFBfX8+1117Lzz//TGBgII8//jj33HMP4B0R9OyzzzJjxgxKS0sJCQlhzJgxvP3224C30fmJJ57g66+/pqamhvbt2/PKK68waNAgAGbNmsXkyZP57LPPePTRR9mzZw/vv/8+9913HyUlJQQGBjbU+f7772fr1q0sWrSIyspKJk2axLJly6iuriYlJYXHH3+ca6+9FoCbb76ZpUuXsnTpUqZPnw54G9ZzcnIYPHgw1dXVDef+/vvvefrpp9m3bx9RUVHce++9PPjggw3XTUxM5M4772Tfvn3MmTOHoKAgnnzySXnaiKzVOSeaQx977DFqa2sb/uXn57d0lfB4PAD4KRXcIFkYWbMOgLKyedQ77QyrMTIyt5DEUjuRgdfxl+ImbuErXt57tLPKmrJg2hssef99dKY67k+I4BLbegC0ymQSEybQzVnH5dL3dNRtoH1iLA/syiN+yWZmFla0cM3PPboIFQDtXDu52rORweGJxETfjlQ7kBS7jqFZOdyy346iIoXEhAl85bmZN4VH2aY59srnsqPbuWwuAAprGGOrNzGyZhW97Gl0uWYkAOsdUURJhVgctS1Yy9ZHkiS0YRYAopQKrsmt5bYQBTu2PURZ2Tw2bbiLr4qrqHd7qHO5W7i2srNRVVUVCxYsYOLEiQ0B1kGRkZGMHz+eb7/9FkmSAHjttdfo1KkTGzdu5NFHH+X+++/nzz//BLwByptvvslHH33E3r17mTt3Lh06dGg436RJk1i5ciXffPMNW7Zs4eqrr2bEiBE+CcYsFguvvPIKn3zyCdu3b2f8+PEEBgby/fffN5Rxu918++23jB8/HgCbzUa3bt2YN28e27Zt48477+SGG25gzZo1AEyfPp0+ffpwxx13UFxcTHFxMXFxcUe8F+vXr2fs2LGMGzeOrVu38swzz/DUU08xa9Ysn3LTpk2je/fubNy4kYkTJzJhwgR27979L/5fkMnOPqe0J+tgl3FpaSlRUVEN20tLS+ncuXNDmbKyMp/jXC4XVVVVzXY5azQaNJrja006Uz5/9jksdgdDh17Ia0MvZPPaBVTUQ2jIMPJ/2cKg8hiihXqG/OdNAMTv/4srWEW2VW4FPRGWykpW1NUimeqJ3LCexy6+GGfc9ZhMPRBFPUZjO4bkLUIo+Ri7OYV+d93B/+Ytx2EMZfemzRA79NgXkTVwueoAgUEhLrp3u6Vhe0YGcAWkL/yLuD8d5Ph3ICXlajLKPsdh3U1ETFCL1bm1+FsRgZWLaVdh5OGdKeyJKKTvE5ej1Xof2r4J/JjqmlW007zZwjVtXeYW5/O840kGSYuYXDqSvkWQn7+DHYbBJHb4C7t5OZ8YNQzo+Br+yqMvPCk7P+3duxdJksjMzGxyf2ZmJtXV1ZSXlwPQr18/Hn30UQDS09NZsWIFb775JsOGDSMvL4/IyEiGDh2KSqUiPj6enj17ApCXl8fMmTPJy8sjOjoagClTpjB//nxmzpzJSy+9BIDT6eT999+nU6fGHu9x48bx1VdfcdtttwGwcOFCampquOqqqwCIiYlhypQpDeXvvfdeFixYwOzZs+nZsycBAQGo1Wr0ev1Rhwe+8cYbXHjhhTz11FMN97djxw5ee+01br755oZyI0eOZOLEiQA88sgjvPnmmyxevJg2bdoc57suk539TmlPVlJSEpGRkSxcuLBhW11dHatXr6ZPnz4A9OnTh5qaGtavX99QZtGiRXg8Hnr16nUqq3PauJ1OFoTH8uxFV/Oc4J1fVbBnJQAle8pJK4/BjZuk0V0B8HjcJJds5E1pAvdXfdxi9T4XiQoFFW278smAy/g2tSMAKlUgQUG92LWpgn9e/h5rlZmYzZMIyBuMQqFl8NZ1jF+1gJ47NrRw7c8ttpoa1tKDb8L/YEfEm6xc+Beb163G7W5svQ8MDwUgwKoH4N7AHTzL4/TTFrZInVuT9YE9+Uy4nRxlGrtSirjg3jENAZbb4cBWbQXA5ZaXuzhVFr/7Hr/n51IkxFLjisUuQdklAtYo6FwxnNpNl6BQGNHVLyRrx33yUEHZUR3sqTqWg89Dh77euXMnAFdffTVWq5Xk5GTuuOMOfvzxR1wuFwBbt27F7XaTnp6On59fw7+lS5eyf//+hvOp1Wo6duzoc43x48ezZMmShgRjX375JaNGjWoY4ud2u3n++efp0KEDwcHB+Pn5sWDBAvLy8k7oPdi5cyf9+vXz2davXz/27t3r81tyaP0EQWiyAV4mO9edcE+WyWRi3759Da+zs7PZtGkTwcHBxMfHM3nyZF544QXS0tJISkriqaeeIjo6mtGjRwPeFp0RI0Zwxx138OGHH+J0Opk0aRLjxo1raJk52wkKBcmdu7LIIRAZFYUkSaj8vF+CqnLvQ+jexBKGJg9ixYIFuDbVkJzaGY95AxGZg1uy6uccbWAg6o5dkEqqCFI3flydTieKxbXE2CLZXex9wA9w+OF2u+nVvi2x+/aR1KF9S1X7nPT1K6/wS3I7/kltT6AiiK6LHQS6HGywraBH/wsAiE9OYffoLYREelsblUojAC5XfYvVu7VId9eglLYS4rEx5LabcbmdbN+yhZqcItat+JvwTrWER4LbbW7pqrYKm+bMYWlFOV02v0diqoLU2mDKB7Wnb/8LWFzyE9GeYEyqnnTpfAPr1o+hqno5Ho8LUTylA0BkRxGkV7P+yZYbjRCkVx9XudTUVARBYOfOnU0m79q5cydBQUGEhYUd81xxcXHs3r2bv/76iz///JOJEyfy2muvsXTpUkwmEwqFgvXr16NQ+Paq+vk1DtnW6XRHNAj06NGDlJQUvvnmGyZMmMCPP/7oM4TvtddeY/r06bz11lt06NABg8HA5MmTcThOT+IRlUrl81oQhIZpGDJZa3HCvxbr1q1j8ODGQOE///kPADfddBOzZs3i4Ycfxmw2c+edd1JTU0P//v2ZP38+Wm1j5rEvv/ySSZMmceGFFyKKIldddVXDpM5zgSiKPN+3C/c7XUiS98shIMqAyQThdYnYBDsdrxgIgHNLNanVMewyiwy96rkWrvm56c2MOB5PjkIpCtjtZeTl/4+CPTbSbEOpV5jpet1Q6l/dDup69u79iIQhg2h/+WUtXe1zir2ujkJRJLKuggdVLkIqCwl0GalTmOnUo/G/d4PBSNfeja2UeYttZNX1xb6llrTJLVDxVuSm0O6U78jHLz4GURSxmawEfGXGH392ILJC04+d3MSoajX/iW/p2p77jKGhBFmtJAVUkk4WodVX4tfZO8dEF+JtPNCalRiNHdhIV/aTjrqyjAFh50ZjYGsgisJxJ55oSSEhIQwbNoz333+fBx54wGdeVklJCV9++SU33nhjQ+CzatUqn+NXrVrlM9RQp9Nx6aWXcumll3LPPfeQkZHB1q1b6dKlC263m7KyMgYMGHDC9Rw/fjxffvklsbGxiKLIqFGjGvatWLGCyy+/nOuvvx7wzjvfs2cPbdu2bSijVqt9eqOakpmZyYoVK3y2rVixgvT09CMCQ5mstTvhIGvQoEFH7RIXBIHnnnuO555rPqAIDg7mq6++OtFLn1UEQSBM3dgSY7d7MyMWhLkgqoahEd45aerOIbAQQvZpWVBWzT91FoaF+NM/yNgi9T6XLHrnHSISE8kcOZJwjfe9rqjYTl7eJyhcUcBQSrvZyQwOpVBpxpo+h7qiFRR6bOz1CyVUrWRM5JlPmXsu0vj7M/m++9i08nECA7MpXRkBDKAooZa2R5kPuUZI5pu0QWTUVjLyzFW31SnbuYtAl0TGlSPQGL3fDf7+gZSINvQeLX0uGc42RSnb7W1oZ99/jLPJjkfK4MFM6tePlWsuxu4ATX08UbHeICsgPASow9+qx1RSxlpPH5YqhpBcUycHWbImvfvuu/Tt25fhw4fzwgsv+KRwj4mJ4cUXX2wou2LFCl599VVGjx7Nn3/+yZw5c5g3bx7gzQ7odrvp1asXer2eL774Ap1OR0JCAiEhIYwfP54bb7yRadOm0aVLF8rLy1m4cCEdO3b0CZqaMn78eJ555hlefPFFxowZ4zPXPS0tje+++45//vmHoKAg3njjDUpLS32CrMTERFavXk1OTg5+fn5NpqR/8MEH6dGjB88//zzXXHMNK1eu5N133+X999//t2+xTHbOOSeyC55NagsK+PH5F9j+yy8N25x2O2mpj5Kc9ACDxt/O0PFjGvZ17tcHi2gjzBHIO78v5KP8chbszWmBmp9bavPzWV5ezpz168k/kN0IwGzxPmDqTDGUq2voO2oEAPUaK8ZS79prGyv28cz+Ij7JkucJnQi/iAh08RZKy34l1OxtcY3tm3FEuY1rVvLXl9+xed1qIrr1oNQ/GEeKPFn531j54w/MWDCfn6ZN89leo/HOv3KoVIxLzuSlqDKuT5Df61PltYJK1uheQr95Mg5TFHq9d8hVeKS3kSzQZcTpdKLcY6RtYRYdtIEtWFvZ2SwtLY1169aRnJzM2LFjSUlJ4c4772Tw4MGsXLnSJyB58MEHWbduHV26dOGFF17gjTfeYPjw4QAEBgby8ccf069fPzp27Mhff/3FL7/8QkhICAAzZ87kxhtv5MEHH6RNmzaMHj2atWvXEh9/7O7t1NRUevbsyZYtWxqyCh705JNP0rVrV4YPH86gQYOIjIxsmOZx0JQpU1AoFLRt25awsLAm52t17dqV2bNn880339C+fXuefvppnnvuOZ+kFzLZ+UIeXH6Cdv75J5vcLv5XYWFkXhk3hPkz8+4bCI2N54rHnkGp9E1lrdf7kRddSVKVwIC4uQS7O9Cmpk8zZ5cd5Ha5yBRFsiWBj0LiaFNYwU0xoVjM3iBLY46mIs6C+kBLXMKtPdDqelOy5WOCXbvIqN5HYKUF+nY42mVkh9ljUyMQRqQjmGJdJd3a9juiTOXGXDKyY9jlzGPwlf15o3QLUWq5vebfqNO7mdF7FAFSLZdZrWgPDDey6B1gBVNFLRf07kefyI7HOJPseBRt2oQzKJi3c6vwoGHNXXcQ4LQ27A8KCqVG2IpGUmPyOHksNgJjWBixkSEtWGvZ2S4hIeGIVOWHy8nJOer+0aNHHxHcHEqlUvHss882u3bozTfffNSAZvXq1U1uDw4OZu7cuUetW3p6OitXrvTZlpiYeMTopquuuqoha2FTmnoPNm3adNRry2TnIjnIOkGhCQlEFRSxLrENG/YXMdJSgdNmRaiCDf+sJKFtOrGxiT7HhPRMQPFrBd1ZQzfW0LvL7S1T+XNIcFISVz/zDH+W13DDthza+Wm5KSYUs8WbdEVtjkbfrrFlMDrG24oXEjoId9lv3Fz/GZb9TafTlflaMO0Niisr6DfkQh5X3IVV0POVYj9SGw+ieGTwJAZpIBuEWhcB7hwi8iei1adCwrAmzi47Hm3GXYZzp4QDDVl7d9G2YxcAXEYJKsFRbeGH558nx2Sif7t29Lzxxhau8bntm6+/ptQYwPU9+1MfE0+8Xgs0zhsWRZEKXS1KjwI/ayDtL5PneMpkMpnsxMhB1glKHTKEgP4DqMgvp97lJrFNHDdMe5btP/1C9D8m9po2HxFkdezWk23zfgJAEEEbpGvizLKmxOk13BsfTrBKiSRJmA/0ZBXrlbRtf+RQtvCwEZSV/UZ6GxN9bnr5TFf3nLS9rJQ6nY6U/Bz0CfE4URFsVhMxsHOT5Q9NCmCvtgNgrZdT7/4bcYoq3pIew21KwZj6fMN2IeBAdrNaF9VYKEtVsEXMp2cL1bM18Hg8eBDQuRyMC9mASruW+vqLMRrb+pTr8eTohkaGgoIvKS39jcCI0aTEXt0S1ZbJZDLZOUYOsk5CmFrFkymNk58trtV4Mj+nwr8/xogje6kUCgXlKW4EjxKP6CbXXEOknx6DnGmnSf/MmEFqnz6EZ2aSYdDxRIo3KLU7KnC5agGBQbdNQKFobHnes3Mbecu2IRjdiNFqrNZczOY9+PnJ81eOxuPxcFG/fhRnZdPx4gt4e8cIJAQS71tJYGDT6YaDIsI4mBSgIquEnWJbTPgx5MxWvVWxm4sIoxy9LYKg4NCG7Zog73pkarOAenBXZjnTSKAIuS/85ImiyJRXXsZhNrN11+3U5K4hd1kpUd2vI7NDZ59yB63eu4vJ0n0Y6tzsim2BSstkMpnsnCNPpDgBuf/8Q1VW9hHbrbZiAFS2IMJiopo8duiNV6NUGfkvU+m3oZKVNfJaN02p3LePP3Ny+eDrb6jcu9dn38H5WDptnE+ABVBbWUVGdgyG/VoM/j2YwAwy11mocbrOWN3PRaIo0v6yyxg2+X4Uft41StSqoGYDLIDwKG8DQ5DTH4wRvCA8z1vKR7C47Gekzq3Njl9/ZdXvcwAQHcaG5AsACZnp7OtZhd/AWJJT0gmVyggSalqopq1Hgc3BVpdEnWk3APFFHXEeZT2g+qw8nIKGWkmL5zgXnJXJZDLZ+U3uyToBv879iXK9jkHpGfQbdw2V2fvYtvgPNMnbABDtgURFxTV7vMPsIVRbTq4nmTKH80xV+5xira4m2m7HjURIWhqFNgdhaiVqUSQwsCf+mjcx+Iu43W6fNTcCQ4OBavzsOpKSpmJdX4JTEKix2ghU+TV/QVkDp6sOEFCpjp72PjAohErRjs6jQR8SQbQ5Cx0WLM449Mqzf02bs03hvv1sj0zARhwdRCO9DulBiUtIJi4hGQCzOYvpXIlS9Aeua6Hatg4/llbzYlYx/aUbmeB5H7UpGr9o39Tsm9euwrKgAKufi5gQPW9JdxNoDUUUfm2hWstkMpnsXCIHWcfJO44fBI/E/yVkcu3SzUyoL8Lw5+90GF+Gwg+sbm1DtrumOO0it2s/5OrNq7juws/OXOXPIbE9enBHjx44LBYkSWLgml1Y3B5W9MokQavC8Jsaf7eBneM20b5zt4bjgsPCsVKNv8sAooErNixB5XYR1DYK/OUgqzm7fv8dQRCI69mLjVIbpttn0a6gGqVzKT0GDGzyGFEUqdbUo7NqqC2vZpr4KB6PFQOLATn72onqOGwoM3JXsFjoyVjNBppLaVGX412Lz+WsR5KkhoVNZSfmnxkzWO9W45+cRqhQjsYcjQuICT9yFEKcKYJSVxXx149hy5Y/8G+ijEwmk8lkTZGDrOMkiiL3vvoKtupqrtpfjuSwkBofT9TIy3Hr3gbAKmqbPf7veb8RVtGbelsubYddcaaqfc5S6/XUOl24JAkPEKVRUZCXjb/bgFNwkZbZzqd8YGAIdYILlaSkzlzPMLcDlVqNRq1umRs4RyxasoQynY6LS8vYMWg4a7R+hIkarDVHT2Thf3UKLq2O9jHxrFnrj91hxeWqP0O1bl0i2rUjtXgpNsdW4q1HDrncvWMrVcWlmHZuRmwLCBIejxWFQn/mK9sK5ObkkCiKXKv9BUXMOjT1fanS1JF82BzZkMgIoIAguxGlIgAAh7O6BWosk8lksnORHGSdIG1QEL90C6TS6cKgUKDpkMqSpd4sdk5twFGPjdp/DeaQIlKvlYOspmydO5f0IUPQ+PsDEKBSkn1BRyqcLrQKkf17/0tgagjmyi4kaQb7HKtQKKhVmQh1BFJUNJ+U0bUEBnZHGxTUErdyzjAqlZhsNmLaZmIINlL2x1Y61OjxSwk86nEZbRvXa9q/KgUHKbSPc2E0nuYKt1LXRw8gf+0u1MFHDtWs/HE38fURbInR8T4PYUVPB1s94QY5yDoZXfr0IWTXLowxHiyApj6OKoPtiHLh4dGUkIdaUmE2e1hDb/Ls6fjVW+hklN97mUwmkx2dHGSdBFEQCFOrALBYSg5sVRPbt2uzxyi13h4V0Snywv4i9llsTM+IJ0Al/18AULp9O99v3Ih6zRrunzwZQ3g4AMKB99rlqsejWElVMkiKLk2ew6yxEeoAS90ultXlUGdO52qjlbZ+csr85tzw4osNf3vyZ3KxYT5BtRegjhh63OeYHTKKguBwAiqcjE07HbVsvWzV1WyfP5/ItDSG3tR0anCbwQX1oIuOYasQgR0tVXYT4YaIM1zb1iHj4ovJuPhiVq/5C0ygqY/HFXjk0Eu1RkONykSw05/CTVn8ox/AWnrTo6ZeDrJkZy1BEPjxxx+PuqCxTCY7M+Qn/OP08SOPolaIjBg/noh27SjN2odKq8MvNJC2ma/hdlswhrQlv8rS5PFWvENRskx5zNoTg0mrZ0uNmQFhR+/9Ol9U5+XhZ7MTAA0B1qEOro+lsAegiW86h7Jd74Z6cFpFFumGsra+K1GllbT1k3MuH4/y8hVYItfhV51JXET0UcsWFeaxY8kaBAQ0sYmUKrWYw+T5WCcqf8MGftm9C93mTTzSvXuTZTxGEUrAXWPj8ba1KIU6wnWJZ7airYgkSdy4NZtAv/e5cPcCxNpYFElNZxas11kIdvpjtYroCjS0N+wnvWPSGa6xTCaTyc5FcpB1HCyVlRRqNSAIZKt1vLO3AOvChUQv/oWL7r6PdgOv4MmftvHV6j+aPUcHdTkvxu8jLuNrhtaZyNmexA1Li7m9ewJPXtK22ePOFxkXX0z6RRdRX1zcsG1GQTn7LXauiAgipMqbwVFjjiap85GLEAN0uH4QarWGNqZiMnYvx2NXwZYISJGDrOOx2ywhEobRpcVgOPq4v9qaajK2RlCjrOeeQXrGWEroFiRnFjxRHqeTYKeJ1y8ay6eLF7GoWxci/X2HuCoPvK9incRdmcNbopqthq26mr2bt/Cn5G3cevm629AJAgnOprO92gxuqAO3W8F/Y0IxhoURGygn0pHJZDLZscnrZB0HtV7PNT17MTA0jGy/AD4pqGBDRCIKpRL/6Bg+/+BLSjev8jlGPGwpFYukQHR7H5YurP2V8mIl2Dx8sjybrHLTmbqVs5qoUBAQ2xgQ/V5Ry/8KK9hvsVNUsBYAtzWEyKimg6awsEgCAoJQqvwYwTxus/6PTnXyRPXmfPXUU0x/5BE2ffcdAM87b2Cy8CG7dYHHPDYyKgaAQJeRiOovicifgKrur9NZ3VapzYgRXP7QRByChmopkL1r1h1RRhfsDXgVtR7efeQR3nn4kTNdzVYje+Uqvlm2jIu3rOLplGgMCgWiKDabFVYKUlCqrUKhUdLu0kuJ790bUV5EXtYEj8fD1KlTSUpKQqfT0alTJ7478N0K8Ntvv5Geno5Op2Pw4MHMmjULQRCoqakB4JlnnqFz584+53zrrbdITExseL127VqGDRtGaGgoAQEBDBw4kA0bNpyBu5PJZCdD7sk6DkqdjsxRI8kENtZZmBQfTlKbOMaO+pY///6C3hYb7cRAFh4o382mIMOp5DuDHfuBMNbkUSG6vOP4yw1BVKoahwnuLK4nOUxuHT3c+KgQOhn1dPbXYzLUYasBTzMB1qGUCgMAMTGh9LqiuYTYslKHg1qdDlEUkSQJNXZUkgOt59jHBgQGUyHa0Hm0VOdXgAbqSrJAHkl1wvykat6SJmGzxeMX+sAR+/3DQoA6/JwGSqIUOA2QW51FQlDyma/sOc5hteBvtdAheCHt6nZQXn4JYWEXNVt+6I2N8+SysqZTVb2ayPgJxIYNOBPVlR3KYW5+n6AAlfY4y4qg0h29rNpwwtWbOnUqX3zxBR9++CFpaWksW7aM66+/nrCwMJKTk7nyyiu55557uPPOO1m3bh0PPvjgCV+jvr6em266iXfeeQdJkpg2bRojR45k7969GOWsQzLZWUcOsk5QF389Xfy9wVKtxUlNzRwKuu3FsedSyBlGN5uCITZvkosMp4LNajdtnQoK1WqKsCIAOpUVSSMiaRWItU4Kqpuex3W+2PTddyxeu5aUwEAue+yxhu2jI4IYHeEdOvWPPReA9l1HNXuegoIcds1bBbpchFhwu4/yQytj/M23ULhtK8l9+yJJTt5gIhLQa/zfxzzWu1aWCZ1Vy95CO5bktmhLrXQ+7bVufdyuSsIoR2sLwC/Q/4j94ZFRWKkjzB3IpvYdWKfIJKZwO/fJQdYJ63TVVXS66iq2bfsPpWU/UbNaYrO9iqETxx3z2KU52TzFA0Rvt7Nm0Omvq+wwLx1lnmjaRTB+TuPr11LB2czvakJ/uGVe4+u3OoCl0rfMM7UnVDW73c5LL73EX3/9RZ8+fQBITk5m+fLlfPTRRyQmJpKSksK0adMAaNOmDVu3buWVV145oesMGTLE5/X//d//ERgYyNKlS7nkkktO6Fwymez0k4Os47D0/feJTEkhZeBAlFotkscDgsDD329mVID3y7jcofUJsDoNj+eWkYks+3wX+9eV0aFPMhlDkti6eSYKtRr7oCjwSGj+KqKwxtqSt9fiirKzqdXpqDc3/aPo8ThxOLw/ggZDarPncdjsZGTHUBVgYl5sb2bZ7qLv1mxmdpC7V5oSnplBeKZ3fpvdXgqAgIifX+RxHW822MEK2w0d+FIYTjfDLm4/bbVtfVw2G2898wwxMfsJbwdKh5GAgCNTuAcFhbKl50r0QUYitQpCrOWI0pHracmOT4HNwR4bKNETaYqh1nR8P4O2knJcUSqq3K7TXEPZuWbfvn1YLBaGDRvms93hcNClSxesViu9evXy2XcwGDsRpaWlPPnkkyxZsoSysjLcbjcWi4W8vLx/VX+ZTHZ6yEHWMVRlZ7O4rAyhpJRHevak2OnmpykT8ARGsVjqxVUXeudTVVuCGgKs7iMT6XlpEoIg0KZHBPvXlbFtUQEJHcMACFMUoXI5cdkFUIkUVJ/fQVa/ceOIXbcOwyFrWlU7XdS53ERr1FSVl+PKfRxDLKjVYUcc73I6UapUhIZHUEcZQXUpGCzB1Br8ySksAjnIOianswYQUamCEIQjp2pa6mqpLipEo9cTGp8IgNtfgAqI1OmIlgqI0MsP/ifCXFEBwJ7ACDYwkg4Y6dLEOlmiKDL4yssBCNrzPPkFs0jQTzijdW1NZhVW8G79jQwnhMftAVj9mk56YbK72J5fwcLPVzLEpSG+rZO3pLsJsWQAJ/6ALPuXHi9qfp9w2Dy5h/Ydpexh32+Tt558nQ4wmbzPAfPmzSMmJsZnn0aj4b777jvmOQ4O2z6U87CELDfddBOVlZVMnz6dhIQENBoNffr0weFoOjumTCZrWXKQdQwOk4kEux2nR0ITGEj/JZuxXzOZ67/9ACkYFCpv74vTHI0SiG8X0hBgASR1CiO9VwR7Vpfyz3fFhPcBtdLBnXO/4n9671pEhed5kBUQF0fHuDifbb+V1/Lg7nwuDPbn/to8MnZEU5hTjjDEdz2bTQvmsf63uVz73Gv4Gf0pE+xoJQ2h27O4Wsyhnd0GI/qdyds5J2yaMwdzTQ1p/fsTnpnJFmcM02v+R7qljqSELOLifYei5W7dxG9vv0Z8+05c/ZR3bS3xQNa7rlWVdPWfjr+6I3DTmb6Vc1ZAbCzXjhnDUwXL+E0Ywkjtdm5UHT1DY21eGYhgrS09Q7VsXWY+9hg70zrinxRDEFUoHclIEY0/gzanm3lbivlsVS6b82sObFWTiY7Etl2pql5PRHLvFqn7ee9E5kmdrrLNaNu2LRqNhry8PAYOHHjE/szMTH7++WefbatW+SbLCgsLo6SkBEmSGp4fNm3a5FNmxYoVvP/++4wcORKA/Px8Kg401shksrOPHGQdQ2SHDtwydSrg7V2RBAEQWa3rSpC2DgDBrSZKGUsNEvHtghu+IA8aMDadgp3VZNRIWCraUoOT31SNadsLqi0+X6wyqHe50YoCcTo19TurgDBMgb6tdU6bjfXz5lJTWszWxX/Sa/TV1KrNaO0aIkNDGFpaTGyqPG+lKevWr6dAq8W1ZAnhmZnsNFlYE+SPwaFDoTjya0Gt1RIYGYVfcONaWB0G9cbUrY52hgvZvv0LXO76M3kL5yRLZSWFmzaRduGFAMR0706mbRM1pq2kmJrvCczPzaJgXxb79hUSnQ71FflnqsqthsNiIVetJj1/B7cmPokEKOwXogmFKrODT/7O4pu1+VSZG79nwowaIsxWlB6wmbzfz06HnLFU5stoNDJlyhQeeOABPB4P/fv3p7a2lhUrVuDv78/dd9/NtGnTeOihh7j99ttZv349s2bN8jnHoEGDKC8v59VXX2XMmDHMnz+f33//HX//xnmaaWlpfP7553Tv3p26ujoeeughdDodMpns7CSncD8BgUoFV5R40CwqJl8bT4zO25qstAXjZzQiiAIx6YFHHKc1qEjqFIpKUpGw4WG0wQ9TrGqcxGt2uKm1Nj1kpbUr3b6dZR98SPby5T7b744PJ+uCjvw3JRpcyynq+D7E7PYpo9JqGf3I01xw/a30vHwM1vo6LBrvg6oiYRXpV9TT8aqLz9i9nEtiQkKIslqJa+sN9jM9dh7eYWNUoYOw8CgsdbXMe/s1zDXeB8qUbr24bfrHXHzPfxrOERYWSVJyOoV/76dwSw9KV6e0yL2cKzweD7NefZXZixZRsmVLw/Zx8UOYWKqlt/LIoYIH7Vm2gbg/NWRp2/IWD/GdoueZqHKrMyotjb4hKgAEjwKF04B/eDCLd5Xx/pL9VJkdRAdoeWh4G9Y8cSFrnxjKlGAzXVBirhX5pX4UM81d2W22tfCdyM42zz//PE899RRTp04lMzOTESNGMG/ePJKSkoiPj+f7779n7ty5dOrUiQ8//JCXXnrJ5/jMzEzef/993nvvPTp16sSaNWuYMmWKT5n//e9/VFdX07VrV2644Qbuu+8+wsPDz+RtymSyEyD3ZB2mdPt25n3xBVfedRf+8fE4zWY0B1KjzllfwE+bijjY36TXeMdhe/yCuPw/3XHYXKjUTa+hojOqcSEBAlrcuBP9cAeoUeSbUVTZKai2EqhXn4E7PLvsWb6cRaUlxOTkcEf//j77REFApxBQKPOoD9+IWog74viQmDhCYuL4Yep/yd60nq6drgHAxj98XdyLcHUxE5L9Uci9hD4ufughn9eq0m/oH7QBKtuhUvXjt+nvsG/tKiy11Vz9lO/DwM7lS9i3dhXdRo0mOj2DOpPIO3G3IIkKLpUk+b1uhq26mnpBxKlSYa6qatgeF59M3E1H73FVB3szmrp18awVeoIq67TWtTVS6/X0uP566uu3s2bt5ygc/giIhEVH0ykmFrdHwl+nZGhmBEpFY/ujywilFR7u+ycdK5lYh0QzyGSljUF7lKvJzjeCIHD//fdz//33N7n/kksu8ckAuGTJkiPK3H333dx9990+2x5//PGGv7t06cLatWt99o8ZM8bn9eHzumQyWcuRg6wDvl6Tx9sL93JlyW+Yg4x8PO0d1ho70k65H32dmR/CRkBVEb3r95Orj6dYG0WBNYOI+BeICPAmY1Brm387dUY1djyASPaSlSS068y+yHjEKjtU2SmottA+JqDZ41srv6AgYrKziQs7MqEFgMvlQqmqxw0EhaXjcjr5Yep/yRwwiLYDhuARRF5fsJvSfBtxQFFdHWmAw6Xm/zSTIM/GDfFuAlTyR/1ozPXbcEeuQeH0fgb7X3sTpuoqhtxy9xFl969fw55VywmOiWP35l2YqyA/IQIAk0t+r5ujDwnhkZen4rBYUOv1DduPZ6iwISQA8NCpRMsj7QpINoSe5tq2Ti6PxO37tQQE/cJlv22iWLDQJcI7qmBsjyMbcQDEADXhCOgAi0cgaVcOCT3anMFay2QymexcJD8NHWC2uyiutfGHlMGwqp38pOhIh6o8pEgRCSiudxAf5qYuIYro4gqKpSgeGTWE9qlRuJ3HXr21w6AYFm1Zjivqa6JCt9E1TyJsfTnrbd7Fdc/XDINdxo6ly9ixPts21Jp5bn8RI8MCGOGux631tvpHR3dmx7JF5G/fQnVxIW0HDOaV33exeHEuvT29+CW6N5WCm5co5zk7dFWvwVEZgIf2LXFrZy1bTQ1qoxFR0djrmutSolaFEyx6J4GHxMRx3QvTmnz4b3vBYEJi4kjp3ovszzaRZknmfnE3CdFBKLEB8sLaR+MbYLnJXLIUEYFv2ibRMSKxyWOCwsOAUjqWRnFF2wsRRXmk94nKX7OGIqudpR4jinoH2foo1EaRL+wego7yS6gN9kNAoIfCw3wPdBD86Rbw75MlyGQymax1k4Osw+zVR7MXb8tmgSaE2JpKAt3eDIJFMfGYYkOJ8uzj+sR4jHkbWbh1JSVrg1BHGBk1sSN6/6aH/AmCgKQGQfI+2HYqWcWa0usQNd41V87XIKspS6rrWVVrJlStpGNFFi6td16QwRBPRt+22C1mdH5Gluyt4pPl2fR3KYkmkI4uNz9L3knrdpeaB3mF3bkDCFJd05K3c9b56c232OtyMiAmhoETJwLwpvIaSoRwntQvY/iBcs31riR36UFylx4A7FatA6Cn6znItyHE/AUqOcg6XhZ7FTV452LtW7qRjmMTmywXERlNFaVkCeUseOwx2sXFM3jSPWewpue+3+f+yp/KaGLEaCptCvYCEf4a6mxOggzND9UOiAihVFtAZz8X8yvUrCx343B5UCvlQFd28gYNGiQP7ZPJWjk5yDoaQaRAG0bBgZf2cgGFo56ooFieHNWW1Z98R6wpgjq0VJYr0Pmpmj6P2wUKJahFRKe3FVvVtT8lixonup+PCxK7HQ4QBBQq3/dtbGQwYWol8VoN7RMFVq+RACVqdSiCINLj0isprrVy/fS/AchTeuhjh2hX40NPreRHBGW428gJAg5XZbPi0unQGhqDITV2VJIdQ7WNJZ99TPtBwxrWwzoat8qDCzeSU4WgtuFyyRkGm7PgjTcor6qiW5++ZI7ypmB2Oyt5S7obszOSYMOdzR6r1/uRozBTr7BQEi2AuojBZ6rircCm/Bre8HTD5vD+5ClFD4PTVTx5aR8SQhp7pfavX8OuFUvpM+ZagqO9owzadeoGnbrRxSPx0fNzqbbCgm2bubRzlxa5F5lMJpOdG+Qg64Dh7SJJizAes1ygTkW7aH+UChF30lwK1CbsVf8lJiEOQTys5d9hgb+egcp9OK+ejSs/CFe8GiQJnU7Co1cguCUEu+e87Mna+vPP/LJ5M4keDze8+GLD9litmhuivXNOqqt3AKDTxTQskmu1OPlw6mo8HheIUKL0ICGht+/nbkcuMdo4Qg70GNbazGf4rs5+dz7/PMWbNxMYH9+w7VXlk7jcJgqz+7B+Xw3xHTofNcjyuN2U7N+L5HRix0m2Kxq7WkGMuY5DMg7LDpFTWkqxTkdKWeMaVy5nFWGUE2NXoQnUH+VoMKmtBCiD+aTtOJSSk3skN8Lhi7DKjlBeb+eOz9ZhQ0lyqIHB8Wvo4P8FIfkXUbJVTcKgIQ1lN//5G9kb1xEcHUufMdf6nEcUBeJCiqguSOSJFRVc2vkM34hMJpPJzilykHVAXLCeuODmH3L2r19NVFoGen9vYoDamjIktTe7YL05kLYpGph7D0huuOJD70F1RbDhU3DZUBatJMj0A53y57EtSMPPaj2OAZGIRRbUW6spqLac9ns825Tk5uJWKBCOMmTC6axGEFRITiM/vvocva+4hm9/rye8xsMohYqv/Rw4BLDrFSgshWiLtjM4cQRFjqW8xiTWBvWhfWk1oyOCzuCdnd0UajWxPXo0vPZ47LjdJgSg+/BxFCflEp2WedRz7Fm1nHlvv0a32FGoVEq+Vo9nh9AOdXUlGVGn+QbOUX379KE4O5ukbt0atjmclQAoHP7o/Y/eyCMMCQaHFZ1kRocVm9OMTi1HtMcSYlBzZdcYlu4u582bu7F192xEs0RofSw1bt/5tB2GXERwdAwp3Xs1ea5kvyy2kEh9iRO3R0JxeMOaTCaTyWQHyEHWcbDU1vD1O29i02h5+OU38A8KJi93A+BdiNjhMJAkLIZNX4B/bOOBoakwahoYIxGSBxCknY5WshFZBp6ISlQuJ5LH+yNfb3NRa3USoGtmyGErNOy+++i8cyceT+ODzh8VtbgliX5BRvRIbP22BkJfoGDPCgp2rMGiCcaxKxMVAls0bhAgNkhHu/Aw9q5IRRcbiFmyEL77OkoEN7YoLcUVlSAHWc1yOmsAEUEQaTtgFO0uOPaDY1y7jmj9jLjUEmpJSSQmqqVC1PJDZ7M6jB5Nh8O27ag3M59RpKNjeGDgUY/vMWAgAP9bnIEkORE8fwNykHUsoijw2MWZTL4wnWdziplluZPLCWaKPYDAcN8sjWk9+5LWsy9ul5O1P39PzpaNjH74KZa/8yNh1f5c0H4nphSRC4wGREFeg08mk8lkzZODrONgqq4iv9dgfsroRUlhLZ8EBVNTthcUIFiD0BrU+A2+HaIjIX+N78Fdrm/4c5/mGooVGtwpK7mgYgnRiyx8pepDvco7J6Cw2npeBVkKlYrIjh19tk3LKWFzvZV3MuPpaauiTWEM9iIHHSdO5p+ffuTHnDh6SAK1goedKjdKUeCda7ugzrWwf3UMxsBMyutzSXSE0ztrBZ0Ls+jRtx+Q2jI3eZZZNXMmZcUltO/Xl+SB3of2Rbm1fFQ5k3h3LUOOc40rQ2AQEz/+kgfe+pnnykxMrFrBbeErSNM/fuyDZQ1W1Ul8LtxKP+0+xgY1vxhxfpWF//68nfzyOu5pF4xRW4rLZTqDNT23uNweft5cxKiOUWiUCrb99DPL/llBYec++EcGEUwVSntXQqJjWP3jbMpzs+ly8WXEtPH24IoKJRvm/4KpsoKC7VtR2RUEuoyEhEVybfgPJCbec8y0+zKZTCY7v8npkY5DeGIybS6+HI0gkKr3LkDpqCvy7rQGE50eiKBQQNvLYfiLPscu3VPO87965xW5FREEChcgVrUhRJvKooBeDQEWnJ/JLw4lSRLd/Q2k6jX0D/KjJCcPgHJ9DSEx8Xyn7k262ft+rdG68Ajw0PA2dIkPIiIpAJsCVKJAoWBlDnbyaoII2V+MpNC15G2dVbbv3s0Gh53cbdsatm0rr2ZVqB/7lMHUVZQd97kEUaR9lzTy8LDc6l1IWk580bSanByyli7FVFLisz1SgL72LXSos2A0Nr9O3m9bi1m0q4y9lTbm5/QBwO2W5xseTpIkFu4sZfhby/jP7M2M/3g1DpeHnJ07KdPpGLlnJR9ItzKUBThdWgICg9m+dCG7V/7t89kXBIGel49hyK13E56UgkPrBsDt8H7/O53VLXJ/MplMJjt3yD1Zx+k/iZHcnxCB3XNg/pDdu3aTx+1PYvsgJEliwfYSCmtsDcfsLK7ju/Xe3IS9k0PIU7j5tTqJqzfdz9CXRvBu4XLIr20ofz7NyyrauInV8+YRl5xM9+u8E8wFQeDF9MbhljuKayjqOBuzzsYnSyKo2mUiQFJjEjxsUbtJCTOgEAX+tzybTXnVrI2R+P2uTD59eSfTsaNQReFpU0pvv/CWus2zTruMDPyys0nu2rVhW1xdLY9k+SOYSvl4zovc8d5M/EO9i0O7PRJzNxZSY3UC3odYjUrBDb0TAEiPCQdy+GtPOJ2q+xCrjIDkM35bZ70t8xewqKSY2N9/5/aXX27YPjp+KPFbl4BLwi3Bd2vzqbe7Gvbf0jcRURS4rX8S7/2xgzq3yKLiAeSnp/KUyULv82/98mbtKa3nvz9tZ2WWd55bsEHN2B5xqJUifa66kohVq9BHSpTwHaJTT43KjiiKjJz0IHtWr2hYluCgLsMvafjbc2C6rmTVsEQ9mB1b2hKzZRPPjWpLoL759O/nKovDxb4yEx1jA1u6Kq3WkiVLGDx4MNXV1QQeY6jwQTfffDM1NTXMnTv3tNbtTF1HJmvt5CDrGMw11ej8/RFFBQpBQK/wDhGJ6BhIaRlkaC3EbLySjZbJ3L2w6Seem/sm0i81hDdsTnbiZABrsX/0CsmBY1ht6IRqlzfQKjyPMgxmr1vHZpeTss2bGoKsI5TbMLXdCKKLOYs20t/mHcqzQOfEI8D+cjMvzNvZUFwU4PM58+laU0dqsJp9TgMV6ggWVdYygsgzcVtnvd4330zvw7aFWpaTHLQHkyOUrPCIhgAL4MV5O5ixIueI8/y+tZhQg4rw5TMI0PWjVhXAdN14dpi0vHl6b+GcJEkedHY7gTrfXtXgkDCG3ng1ANP/2subf+3x2X9TnwREBJQKkVdTbTyx20ClU8XGsk4UJNmQeWVXmLn6w5XUWp2olSK39kti4uAU/LXe4dchaWmEpKVRU7OOkvUiSnsAZoMdQRCITE0nMjX9yJNaqqBiD8T1AoP3p9JR4eGPwJEU7zSw3lLI6A5RDMmIOJO3ekY88/N2fthQyEPD23DHgGREea7lKde3b1+Ki4sJCDj+lpLp06fLa2vJZOcQOcg6jMvpZP+61aT16oMoKpj39mtUFeZz8T0PktCxc0O5hMRbCAnuSfj3z0NlNgkd6xnTrR1/7ihlYLr3IVWlEBnTLZY+KSEADIs0sjO7Cpe4F03xBoYHa5iT2h12ec95PqVxD4mNoX1RIRHJjd0eRTYH0drGVmG92YFFdCF5IK1oN3uM6YhOiWy1N1FGz6RgIv29w3c0SpFre8UTVp/Png35jNJXM73WwP6KBExWeVjVUXnyqY9ci2Tsxy33zmjYvHxvhU+AFenyPmgJwIa9ldhEuMsKw1VWZqsCqKsUyekchuxIAydMYCD4JHkBb8+gIAjU2Zz8b3kWAIPahDUEB4fO+1FrFVyGipk4SCypomPw0TNAni9qLU5u+3QttVYnnWIDePe6rk1miq13ubkjJxA8s3hwcx722KZHy9dVWin8Zy2Z6y8FIPeiOUjWA9/NZe2IUFqxqRTUomRdTnWrC7J+2lTI7HXeERhTf9/FyqxKpl3diRA/TQvXrHVRq9VERp5Y49+JBGQymazlyUHWYbYt+oOFMz4goWMXLp/yBBV5OezTB7DQrmZwXhkT471Dz2xVMWjVcYh3DIUNnxPc82ZeVx79R2j8lcl8Na2K/7kvJDpiP19oL6Pjth1sxXvOgprzZ7hgxsUXk3FxY3auEruTrit3kKRTs6RnBgqPhwDBiQWwW3XsMmSQpXOxQgsj2kVSYbIz8+YeGDSNH+HKQhMLf7ZRbujEP5q/0SpDsVm1GHdlw4iuTdTi/FKxaxdKvd5nfSyAYlGLkghC1aEolN73s8rsYMKX633K3WDSNvy9TuNisc7J7qh2POxJ40fqcJpcDBWrTv+NnMNE0ffBvveSX6jHjxE1WupsLlLD/fjfTT2aTA0uapVchppPsVNUJuCxywEtgMXpQq0QiQ7Q8vFN3Qk3an32F23cSP6WLdCpK39XuzFqjPR+6lqqiwtZMftL2vTpT6BBTe5fC9mYnUFpdh0AxqD2hBqKWfrhS/hHDUUUAgiVrLwcEcNSPyOvbKhnXW7rmpuVXWHmse+3+Gxbm11FrdUpB1nHMGjQIDp06IBCoeDTTz9FrVbzwgsvcN111zFp0iS+++47IiIieOedd7j44ouPGC44a9YsJk+ezLfffsvkyZPJz8+nf//+zJw5k6go77oYhw/jO9FrArjdbu68804WLVpESUkJ8fHxTJw4kfvvv7+l3jqZrNWSE180QWMwkNq9NyqNlrs+/JSoGyfwt8nB2lpvj8iendvY+dE/LH9pDdvXmKDvJDhGgAUQ6B/AZajIlyJ4zXwdPXeuo6y4MZvg+TRc8HA7TFaUAhiVCjSiSElJAR6N9wEmzxFFliEJgD4pIbw3vivfTejrE2ABaA0qynNNUOfB7tJxQcw/ADgLz9/39VALvviCt2bM4M83fQf0ve9/CQ8I77NblwF4e1emzNlMaJ0HxSEjU5ZpnWxVe+cLJTi9Xx1lSj3+CPTX1gCwct2G038jrYTbbadSCqLKFcjv67zziO4dktrs2ktKrZpQBNKpJV0qx17duh7wT1ZUgI7vJvTl89t7HRFgAWxdtJjfs7PZ9OP3vJMZz39TYwDY9c8yVn3/NWu/eBvpk2HEbH+ciuwKELzfJT9XP8PK+G+xGZNIDtpDlPZGEsQfaDtqFMMGdQFgc34NzsPW2jpX2V1uJn21AYvT935evKIDyWF+LVSrRhanpdl/drf9uMvaXLZjlj1Zn376KaGhoaxZs4Z7772XCRMmcPXVV9O3b182bNjARRddxA033IDF0vQ1LBYLr7/+Op9//jnLli0jLy+PKVOmnNJrejweYmNjmTNnDjt27ODpp5/m8ccfZ/bs2Sd93zKZrGlyT9ZhOg8fReaAQShU3mFrCqWKK9umE1FtIkrjDYiK9uwlNGILamMIWYpkPvhyA/demEpG5NHXrNFotIxEyaeCjb01KSRd34/S2Y3ZxqotTsx21xHBQ2tkq65GHRDQ0LI/JMSfXf07UOLwJlioIpCP9YWMBpzmEJKdIvUBSqaP69zsQ6ghUINfkAZTtR2DQ8eg2BX8kTuEfEUQ+VWWoy42fT6wu92gUBAWG+uzXYkDtWRHyPVmzPzf8myytlYwxqKmVpT43M9Om4RAeqSGgt0Nv5UQ5hG5JD2cbdneB/2LlPVs1XqIN+Sc6ds661kqK5n16qv4q1Rc+/TTKNTe7xans5IXmUKtFERhxJ0U+MdxScfoZs+j0qoREOgdsAOXvxvJEQcknKG7OLv5aZT4NRMI+PkbCSstJT0+jkTb15hMu6jSjiMiKZXkbj1J6dYJ1Z7VKFUCFw4MI7pbe4r21vDHJ9spzvZwx7szEEq3wYc/ERZtYMuWidgcNQTobqLW6mJ7UR2d4wLP7A2fBlN/28X2ojqfbWO7xzK6S0wL1chXr6+aXiAaYEDMAN4f+n7D60GzB2F1Nd241j2iOzNHzGx4PeL7EVTbfRsstt609aTq2KlTJ5588kkAHnvsMV5++WVCQ0O54447AHj66af54IMP2LJlS5PHO51OPvzwQ1JSUgCYNGkSzz333Cm7Zu/evVGpVDz77LMNxyclJbFy5Upmz57N2LFjT+q+ZTJZ01r/0/xJ0OgNPq9T9FpS9I0tpK7SUiJ4h3Cdki/WhTCv2J+YIB2Pjzx6kGUzO1EIbrqG7KSiMoTitRvooA1iiz0J4UCPQWGNlfQI4ym/p7PNO6+8glWl4oaLhpM0wJv+20+pIFWpoM7mZNKXG7gkOBeAgPpQrjSr+TVMZMH2Esb2iEOjVDR53ohEf4SKldxuqwFDOZnBu9lZ1YYqi+O8D7JunToVW00Noto3G9pz4kt4qKKuejib8mt4/9fdXGfxPtDnKt34+av5+MZuDb0E32wxUVlgYnxSBE/s2gIiKMVaJgyYg8Ud2DDPSOZVvns3ZTodtQ5HQ4AFYLeXEEoFkS436bEKBl3Z4yhnAZVOA3jIa5PEb0HdqbHs5N3TXPez2QdL9pNdYeKaHnF0S2h+jbF+d9xBvwN/r113HXV1q6lZbqTHzU+R3PXAe95nAILTQlpALE63h72iC0mACouDV37ZCUol3Ucspn+3Tvy87A4+EB4gxL8GrLAup+qcD7Lmbyth1j85Pttig3Q8c1m7lqnQOarjIes+KhQKQkJC6NChcQnyiAjv/L2ysjL8/Y98XtDr9Q0BFkBUVBRlZUdfVuNErnnQe++9x4wZM8jLy8NqteJwOOjcufNx3qVMJjtecpB1EvxMxYTWORFwssVuRasK5I4Bx85brVSL/FOtoF+brfiZHNxevABF9Gg2F6ciWL3rsBRUW1p9kOXxeLCpVHgUCgyhIT77JEni8R+24izOItGYh8cDClMIuzQedtXYeG3Bbi7vEtN0kFVfQlrAZkwiJKky2Yofhd3aYHNEopSzYwGgPSxVsCRJoLCABzoMuYrbv95Aul3kT52TNKfIIr2Tmdf09BmGFdsmiMoCE7ZCM1GCdwiKUgrmCfENEOE2twd9M0Hw+SgkOZlL0tJw2HyHNFVVrwRAW5eIO/jYa7nFJiWze8BGAgwatB4LZrPE+0v2MXHQ+bnQ9pLdZazOrmJAWhjdjqNDb7/Fxk6zQJCkI67WjrZoDSQPpDyvnuDoQBR6b6A27Y89fLh0P1oj2AQr/OPt3dG6rVxVpMBP78KtUSEcaIvLqTy3E+tUmx088v2RPSv/d0N39Oqz5xFh9XWrm92nEH2/b5aMXdJsWVHwnSUx/6r5/6peh1KpVD6vBUHw2Xaw8enwBDhHO/5Y2QRP9JrffPMNU6ZMYdq0afTp0wej0chrr73G6tXNv78ymezknD3foGepOpebdbVm2hi0xGgPDiEUWd0tkDWbhpAnRXBbrwTCjMeek6VUKVBrFcRpKklqs5W1Re0oUEd4c48fcD7MyxJFkUcefZS6wkKCEhPJtdp5KauYLkY9/sU2ft1SzGsGgaBdt7NhQz56dV82hErggFv7J3kzr5krwV4LwQeC28r98PEQkpx2dqmfQ2ULJHTFYKr7hoNWwb4qC+2i5cxMh3M4qgAPILCfNBxl29ipglqFRI7SzZ2DUhiQ5ptgIblzKG6nh6TOoUTVJ0MudLEkEihVobZYWbY3lP7JkfidB8Nej4dfZCTdx48/YvsvBcXMWPUCw9VWroo/di9reEQU4aOiSCmazdBtt3HPotdZzG7G90wgQK865vGtTbXFAUDQUdapctlsiGo1oijyVm4pczwPMcn2DpdaP0H68jPcY77ihw9UiAqRcU/1RGVUMWNFNgC2g8/iksT1hV8zOmQE2nWF7O+5n3dUd2CMuI6u105och7YueT7DQXUHlgH76D2Mf60jT76yIwzTa86/pEIp6tsa7BixQr69u3LxIkTG7bt37+/BWskk7VepyXxRX19PZMnTyYhIQGdTkffvn1Zu3Ztw35Jknj66aeJiopCp9MxdOhQ9u7dezqq8q9trLNw3ZYsxm7yfgnZbHaU2lq2u5N4wzwGtULkrguOf/VVnVGNx6WjLELDelUU+k0Corlx8dHzJY272mAgND0dhVrN1norP5XV8HVhJc/+sp1UVRV93Omk6duiUV9AnihS5HDip1FyS98kKFgH09Lhk6GNJwxKgqiOCGHpSKKOMOUL9HPP5Ol1HzPur3nsLqil5sBD2flowRtv8Onjj7P9l198tk//aiVvVnzM34r/4/sNZeg9ArUKCbUEydFG/jPsyPWDotOCGHhdG+LbhtCtWwdsggOFW8s70p2o11Vy96eb2V1Sd8RxskZOZx2zs9OpqfPn19pI/E4gNXNdfjlapQODyjuBv7T+/Fwvq9riDQyCDM0HmEv/7/945cknmffKK+gECX+pBpdOosaVws7qILILtLgcHrQGJX5BGjbl1+Bw+fYyqBBwCBo0oo548UdGbNtNWnUJnXomnPMBFsD3GwqP2HZdz/gmSspag7S0NNatW8eCBQvYs2cPTz31lM/zmUwmO3VOS5B1++238+eff/L555+zdetWLrroIoYOHUphoffL/NVXX+Xtt9/mww8/ZPXq1RgMBoYPH47NdvY9LDg8HtL1WtoZvcN59m7Yj1tbzbKCvgBc3CGScP/j/6GNc5uIMSfjrk4iMSKd+h4jffafL0HWoTL9tDySEEH97mrsLg+jld7PwXpVMUqPhq0670PP6C7R3hZ7SYLwtmCpbDyJKMKYWQh3LESKScIhpeOW1CSW5bDKlsD7S/Yzf1tJU5c/L2SXlpKtVlNbVu6zvcTjx5oQP/Y6NCzeXUad6B2aEuwWuKlvIkrF0b8ieiUFc5eyiHHKAqwuHYEHsgyW1tmPetz5ZPeCBWQtW4a9rjHw9EgO3CXenoLhooag4MBjnsflcrH+n79Zs8ybwTFQ5T1fad3Z9715ukmSRLX52D1ZJWVlaNU2ejhm81xIDR9wGwM8y1lnuoF1yuFk5wYBkNIlHEEQWJ3luwTB5U4t99bq2BU0jCyjFREzGpeT0EoHDue5v1zBjqI6dhYf2SByeO+1rPW46667uPLKK7nmmmvo1asXlZWVPr1aMpns1Dnl43msVivff/89P/30ExdccAEAzzzzDL/88gsffPABzz//PG+99RZPPvkkl19+OQCfffYZERERzJ07l3Hjxp3qKv0rw0IDGBYa0DAuOmrrk5jt+9lfeh8A155gi59S9BCVczkzKwbzmwn6pmgAU8P+gprWH2RlLV3KthX/EJ2QQPfx15Gi11K0voyqnVWMrFjE8LCLsRsK0XT4BH1xG/bkjgIOea/jesBdy+CwVLwYvPO7Oo2Nov7Dy8mOVvNnvIXK/QbwnN8P/oMGDSJ/1y5S+/Zp2GYxmxhZrCDeZqMksJIVbgVlB6Y2CAqBkR2jmj2f2+WhNKcOT62dOm0U0UU7KduSjsrsDcrOxwf/5sxbtIg6nY6x9fW0HeX9LO+vUFNcqUKBRL+ICoKD+x3jLN7AIuJnWBWdwf/RFqtWB5bz83NtsrtwebzfyUcLsq5+7DHcH49AV7MP5++PQSwo7QFIA1O4atCtfPHMJgBSunrXKlyVVelzfHyYAYXZQhQhVCkKMDlHsTKxjD8S2yKWBzPUWspny3NoG+XPYyPPrsWh95WZ2FFcR//UUIINTb9HP2wo8HkdYlBz98CU8z5J0MlYsmTJEdtycnKO2HboHKtD/7755pu5+eabfcqOHj3ap8ysWbP+9TU1Gg0zZ85k5syZPmWmTp3a7HVkMtnJOeU9WS6XC7fbjVbr27uj0+lYvnw52dnZlJSUMHRo41CvgIAAevXqxcqVK091dU4ZQRCgJp/Q4kUkVOVwSdxf9E9W0iup+axWTXEpvQku/Nzwvfq/vFE8npCAxonThdWtf0Hi3K1b2eCws337NgAWbC9hzvoCUixZDEOLDi2lxr1o/XPY7DLiBjrFBvjOqRIEUDWdLECr1SHhR03iP8QllSEGeOe8na/DqsC7+POwBx4gPLPxQTAnay9hYb/SM+h16q153o0Hpgd27xzpnfvWjJKsWn58fQPLvt3L6IIf6W1eyU8hY8gN9K5nViIHWQ0MgM5uJzS5MWvYN2u97/fwDlFcNfEaNJpj94arVCrsgoNYKZWlwoXUa73/PZyPAW212TtUUKsS0ambT7KiNhjQ3fgpJF2A6YLbwCOidARgCAukNNeBy+7GL1hDeKIRu8vNhjzfVN7JnUK9/+tUUIMLlxRPlTuMb8TxfFqXTInZwd97K1i6p7ypy7eYBdtLGDn9b+77eiMXTltCSe2RnxGX28PcTUU+267pEccdJzD8XSaTyWTNO+VBltFopE+fPjz//PMUFRXhdrv54osvWLlyJcXFxZSUeIdsHUwrelBERETDvsPZ7Xbq6up8/rUIYxSM+xJbj+u46fKrmXFz9xNOVe1We4e++blsxAgVRHoqCNfVNuyvMDmwOd2ntNpnm8jkFNoLAqlJSdg9Ht7ZkIekENivTyYyrDMAtfHeFuXuaSIj20dyfe8EKN4Cm74Ct+soZ4eAIG/gK7q0zGUMxjABPTbKzsOH0aOpzC/BErQTa+RGqsy+D4lXdT362jiRSQEoVSLWOgepykg66jpRrvGnNsg7BK60iYe689Vdr7zCI1OnEp7pXey5uq6Ab9d5lyc40Z5wm8JBXK2eG9Xb6Bbs/Z44Hz/XB5NeBDfXi+V2eocVAwQnUzbuB+6o7sxHNf+HetvthERHsH+DN6V1SlfvUMEtBbXYD5mPJQhwQb9YVBoFfpKA8UCPoSO7B+lFhXTN3UO3eO9ww92l9dTZfJNHtJS8SgtTZm/GcWCR5GqLk0/+zjqi3LK95VSYfHtBr+oWe0Q5mUwmk52c05L+6/PPP+fWW28lJiYGhUJB165dufbaa1m/fv1JnW/q1Kk+i+edKaV2J1ds3Eemn5ZP2iVSWWxj764M4tv2JSYq6KTO6YmzUV+xm7CYv5i86R6cChX7TZE+Zcrr7a16uEbmyIvJHHkxAOuqTayLVUNYBF3+2UacIxmn4CIm1UB5BfRKMXL9iG7eA7+aAnvmQ8k2GPFSs+fP21LL32YXQU4Fj2TNYEjBZp5R3MSGmqvOxO2ddQo3bMBcWUl4mzYExjc+1JuL6siKDiaYMMqswWg8YBcgzKg+5pwMhUokKjWA/J3VxAa0J8EVSnr9Dmz2IGowkFfV+ntkT9Ybv87F7kxC0ilICT+xrIB2hZNwSxA36DPYlBLKqm3bz8vhgh1jA9jx3HBM9iYaXHb9Bn88QU7AZewoNdCmRw/qu/VieY2J4EADm8v/ok9eONlbvD1gqQeGCq4+bKhgmwgjIf5a4toGk7WxHIOpBoIgAhUv5H1PxygBQ+hY4oP15FVZ2JhXw8D0lp3L5HB5mPT1BuoPe1/mbiri0YszfOZYfr++MeGFO0xDkB2yys2kNLOos0wmk8lOzGlJfJGSksLSpUsxmUzk5+ezZs0anE4nycnJREZ6A4rS0lKfY0pLSxv2He6xxx6jtra24V9+fv7pqDYA2RY7YzbuY0FFLbvNNrKsdqrLsxGqc8jdVsHvy7P47NNVFBQXHftkTRA1CvAoCdJXssrTli3OZCSL73CXw1sXW7MNxbVgcyGaXJS7tXyp28neqEocNm/PilZ7oEdFkiChL/hFQPdbj3pOpUaB1SnhcWpJ0OxBiYd2Qk6TQ2bOByt+/pmvVqxgxddfN2wrz8uhvlLkOd1kHuEtqm3B3FSv4f5aLWOSI1Acx7pisRkHhspK3gaBoQHzuCNmBnB+JnA5Hkvn/oLGk4cqAvyjBBS2EwtGHUoXuWI5K76di3PJT0y9sgO3D0g6TbU9ewmCgF6tbDq7X8FaqMpCnzWHNRYL21etIkGn5oO2CQzesZra0hKUGhVXPdyNPlekEJHo7X1dne2byKJ3sneOZ2IH7/+axTBKKKdc7aKP41cMub+ApYruCd4Gt/W5vkMNW8Ir83expaD2iO0VJjvL9jb2VtdanPy5w/sb7DEokVQK6ursvPu3N4vuulozk3bkHnONJplMJpM177QuZGMwGDAYDFRXV7NgwQJeffVVkpKSiIyMZOHChQ0rjNfV1bF69WomTJjQ5Hk0Gg0azbHXoToVZhSWs7zGhEYU+bBdAj9khNJxzu2wtpoq6VnmKAOxugXa5uwgNir6hM+v0KhQuPQEaLxDHp0oiPLTUHzIkJ/y+tYdZFmqqtEGBiCKIs5SK71+/oMkaw5bjR34O7EjMeVqqrMKWVg9mjuio4gD79idfvdD74mgOHrrv97/wBAil57iCA2fFY3iy+rRCC4HLrfnmBnzWhuNWo1fbR0B0Y2f1y1//U6dzUmUpEeDHYsliABJxIPERf2ObwhbTBvvw6VkUyOpJDR2EUNgKZlBu9D79znG0eeHv6ZPZ09REZ1S0+h+4/XErlPQZ9Bc+kR/T1rHeUSENv8d4vG4EQ9bZNWpdGEV3JSEuwgS8rmuSwhaleF038a5pf8DoNKTlx1A2r48Urp1I0ilpH3dxyQPzEbR42oSO3VDo9cTEu3ttXG6PUcESQfn28a38wZZNimNayUbRjGUjKBYwmPCiUagU1wgP2wsZEfRkcHNmbRwZyn/W57d7P7vNxQyJMM7TP/XrUUNwwkFuxtFkTfYf/KiNgDM2biIIdYshMCBEN359FZcJpPJWqnTEmQtWLAASZJo06YN+/bt46GHHiIjI4NbbrkFQRCYPHkyL7zwAmlpaSQlJfHUU08RHR3N6NGjT0d1TshdceFoRZFBwUaMSgV9/VSg1iE56llepMCqFgjXl5Gg+wcYeszzHU6l0WNxqlArnKSq8slwF6BXhzGb1IYy5a28J+vdV1/BplZz4/DhrMpSkmbeT5S9lCxdMoNqFdRW1pNjiuOP3CEULBD5LeOQg48RYIE3yEpWlKJxu3ArRUr9AqAaBrYJw+WRUDY/T75Vuvzxx4/Y5h8ajjr/a15nOr9nD+EfzxW4kDBpRdolBB7XecPijWj0SlwuK6h0VKFGowmibeR+VhV3OcV3cW4qKS+nTKfDVFdHUWEejuA9ILrR6RKJD81o8hiX08lfn7xH1oa13PLmh+j8jA373CoP0Z4gZnS+AoegYVhtLm1D256p2zlr/LSpkOV7KxjaNoLhSWrY/A30nuBtjNH6w8CH6D4Quh9yTF7W76DKQyqPoH0f3+HYWwtrsTh858L2PBBkGQI0tOkXxScb8xAAAYm3OlzPIobxn/0VXBDtDcJ2FLXc2nDVZgcPztl81DJ/7iil1uLEX6dkzrrGrIKCy9tbNbRtBD2SvPdyU/ehhKmVoD7/FrmWyWSyU+W0NOnX1tZyzz33kJGRwY033kj//v1ZsGABKpX3C/vhhx/m3nvv5c4776RHjx6YTCbmz59/REbClhCrVfNESjT9gg482Bgj4Jbf2dbuY+Ypvdm8Bsb8g1bX9NDGY+nafwCrq7wtz8MC1vGu+h0uk372KVNR33oXzfV4PNhUKjyiiDY4hPW51fwefhHOuAu4wJCAX7kDp7GWhQWDABjfOw22z4WC9Y0T2Y9BZ1QRrfHHXwhjBf1ZknoJzswA2kQY0arOswirGT0uu4pBt4+jwhrEvOzhFCkl9qnchCYaj33wAaIoEBrrh8tjQkBgm6YTjwtvsCpsIIU11vMyIcPhBo8ezaiUFNoPHsSWvUW855IoMYcTEjKw2WOUKhVl2fux1tWyf91qn32G3tFU9fOgF2xoJQtrsquZu7Gw6blJrdia7CrmrC9gR2ENzL4RFjwGC55otvzqGhM5gj8OVGAJ5M8Z28na1Dh87vDU7ekRfoT4NY6eGHpDJs40Ix7JicFUjwI3bkFJYXkpGZFGAvUqEkIM2F0tk7To1y1F1Fh8E29MuSgdlaJx2K/D5eHXrUV8uTqPTfk1SIeMCBYFeOzixqC/rZ+OMDnAkslksn/ltPRkjR07lrFjxza7XxAEnnvuOZ577rnTcflTzqHQ859VDipEiRClhf6xq9Bqmh7aeCwavRJc3iDLP6WWlTkdyVUnwiG/8eWm1vtwKooijz72GPWFhWyVjFR3DUasNzJyZwDBHgN/iU6+CwqlqsZCYoiOKzqEwrv/8S48fMNcSBl8zGsoVQpcgpqQrEspMJcwOGQjIyqXUmMbAJxda9m0FLOpnl2F5UzfcDdWl44gt0CaU0HPns2vjdWUvlelsnnuXiiGSLuSAKkawep92NtWVMuQE1iouzWK6d6dmO7dqTDZeeGnPym3p/P79id5tE0gbY5y3AXX3YxCrSYmw7eXqkd/79qDn665DJNpOw/Pf5tK8yZ+vbc/7WMCmjpVq3Qwu2CQQQMdx0LpNugyvmF/7sqVBCUk4H9giOy9O3LJUz3Lk9JTpJvD2butFJfTQ3Jnb6KKwxch7nWgR8d3WzCP7sslUExii/QJl7l+pKvlaozKnmx8atgJZ5o9lfaXm31e908N5Z7BqWwrrGP+9sasvZ/8nU1hjRVJJeDoHopqQyWi3cO4HvGNCS9q8kAb4P0nk8lkspN2fk1OORE7fob1nyI5LDw0exN77XZ0Ejyc/gt+KgsazYk9jB4kiAJqnR+SRyAlYBOLqzpTrb7Mp0xrn5Ol1usJSUvj96JapAA1hKgJ9hhwI/FTFOypsRCkVzHrll7oJSukDoWgJEgccNzXcCpFVLZQokpquHL/Qq6qW0xw5abzbk0hl9XKew8/wozHHsNeV4fH46YsJ4u/Z/3KQwtSKDJHgSAx1qRGgUB6u9ATOn94gj+qBO/Qqw6WSt7ndsRd3sW1l++tOOX3cy6yOd3c/uk6yu0CCp0Hc5dIdPojk1UU7dlFXUU5kiSR2LkbcW07IAgiVUWF1JY1JgpymM24zN4ek1CDt3e37DxbA+7gOllBBjV0vRHu3wIR7Rr2/zh3Lm989BFb585FkiSM9nr8pDoiKMFa4Q2sDia0cLk9rMs5LMhK9l3/UPJIdA7yQ6vwQ6cwonPYGbV2P4mbpkLx5hYNsMB3rTRJIbAxScsz+4q4/LClGLIrzDhcHjzBGgSrG9HuQa0UeWBYemOSi/mPwStJsPGLM3kLMplM1urIQVZTJAkWvwi/3EfF35/wx45SBAkeRk1U0D4AtNqTC7JKigvohgtNVSaemmi6pqcipvj2rlSYWu9wwUOV7cqhy9Kl9NzlzWj1lsfGRpMVtVLk4xu7kxhqAEMoXPl/MGkdKI6/49Wh8waqkWYoL/Znuv0Kvq7vxOcrc0/LvZytaouKKNfryFepUBkMFOzYzmeP3MfsPB01ZieSQiBUrcJfEnHpFRgCTjzBTLt+PTDdGMBqnXdSfaDGmwAg/zxP457993JWzvqMiZ/8zab8GgJ0Sj6/LoK3UuoZHn5kqu+fp73Ix/fcQsm+PQ3bln05k5kP3MXG+d4hxUWFeaz69TcKy72BbKjeO0zwfEvj3rBOluFAkhutf8M++4F1FAUJEnr2RBAEvm6j4CNuIdRpp7rMO2Q4ob23QWF7UR3mZuZjHWSpd7B35h48Hu9wWrtHT51RhU0fDtbGAM1xyDpbZ9Khi397QjVUihJ/VdYxNCOcEMORa4kpSm2IZVY6pATz2MUZaNnP38t7sGbNZTirdoHkhjC51/90WrJkCYIgUFNTc9zH3HzzzWdk7vqZuo5M1tqd1uyC5yyPC7pcD5u+JqzfTczJgN3FdST8soE6rTcD1cn2ZCmUSoIFFcEbHubbjv68s72AznVlPmVac0/W/sWL2bZyJVEJCdi3ZjO0YhURYf2w+0WzXfS2Tt/a7lN0loXA640HnkCABWCPrMNWUUNw+DZ+sqbyT3EvAGJqzq/U4oaQEC7NyMButiAqFFQXF7AlqCvLRBUCoAuRcJR5+Fvr5LLO4Sd8/tpyK0VbnKh1YcTsLSKvpj3uWu8QwZLz7MH/cBsWL+IzeySb3WbUCpH/u6E7vZJD6NtEWYfVgs4/AJvZRGh8QsP2qLQ2iAoldov3c7v7nw3EbAzih179KCYEQe3tfTjflieoMju4WrGEtD2bIGgshKY17NP4+zP5lVeozc9vGC5osnuHzCntAVg8EJ7o35CFdHW273ys5DDDEanhDQEa9P5qHAfmXFW6I3i9bW8quZhP0oezpaCGSV9tRK9WMH/yBafprptXWmvDo1eCAGK1g3v9A2kXG4BKIXJZ52hmrMjB2TEIZbYJsd77PdtFUPPdLT1RiS7WrL0cp7Map7OaZRnQdsgLRMlZBU+rvn37UlxcTEDA8Q/LnD59upxWXyY7h8hBVlMUKuh7L/SZBIJA+xhoHxOAs5Mfy/72tqBqtSeX+MLPz5+Dj542p5OPVG/QuSKLu4X72Sh5HxTK6+1IktTiQ1BOh5ytW9nocFCxZRv71OmojO0YaQxBIwlMamOmJr6MGGEtgpAIOcshtA34ncQCnyoBuzEf/9QNBNdF4rGoEGud590iudrAQLqNG9fwutOwkUSXGdFsrePqhMUYA7L4X+X1rNJqePfKtKOcqWnVJWaWz9mLxz6HilA930TfQZUoQrFElfn86JFtjso/mO3FkSDAS1e0JzO0+aQrap2em157F5fTiVLVmHAguUsP7vnfV6h13iGZokaJHg252vasFNrST50DnF/DBSVJosbi5DrFIiLX7oOUzj5B1kEBcXENf1eV5yB4lAjWECQahwrCkfOxDq6PdbiwBCP2fd5GtnpnCJ8qbifIXuPdZ9SQV2VBIQrYnO4zmmDH45Eoq7fj6hSEJ1yHcns1l0YE0jEiEICrusbyyZ4SPFF6XEoR1cZKjGol717XBY1Swb59r2M270WlCiEqcjSlZfMIS70ZRDlJ0OmkVqubXRu0OScSkJ3NHA4HavWRPaynkyRJuN1ulEr5sVd25sjDBZuxvaiWzQW1WOoceDzeliOFQk+XLl/Qrt1biOLJrdul0Wjx4B1SUlawgxChjgipikih8Yfe6nQfMXyltYhOSaW9IIIxnOLEBBYnXUioKhCAiMRQMox/ABDs3xNm3wRvZHgzC54gUadEdGmwouM7/+vxT/SQIeRRVnt+9WQ1ZXS0k2+1Ngamz6Vj2A4cbjWp4X6E+p34Z1rvr0YjQIo2nRRbAPvCY6kJ966fVWd1HuPo1i193I2kRQeREWlkSJKW5Z/+zDNff8KfeRubPebQAAtAqVY3BFgAKq33waRPhYm7AnPoGOZ9r8+n4YJmhxuH28MCd3dcncZ752se4PF48Hgah+xZamuY+O0PPGbqxarsaYgb7gAgsYN3qKDbI7Hm8PlYhw0VPCgszoj9QCeCcmNnUkvzSc3xpkKP9NcSpFfh9kjsLTWdsns9HhVmOy6PBB4JnB4Eu4fIQxLOtIv2J8OgQVFgBgFQi3SKC+D3bSXkFK8hN+9jADIzXiQt7XH69lmMUnn8WUZlXoMGDeLee+9l8uTJBAUFERERwccff4zZbOaWW27BaDSSmprK77//Dhw5XHDWrFkEBgayYMECMjMz8fPzY8SIERQXFzdc4/BhfCd6TQC3281tt91GUlISOp2ONm3aMH369H9135MmTWLSpEkEBAQQGhrKU0895dPjlpiYyPPPP8+NN96Iv78/d955JwDLly9nwIAB6HQ64uLiuO+++zCbG5O4vP/++6SlpaHVaomIiGDMmDEN+zweD1OnTm24j06dOvHdd9817D/4/v7+++9069YNjUbDjBkzEASBXbt2+dzDm2++SUpKSsPrbdu2cfHFF+Pn50dERAQ33HADFRXyHGPZiZODrMN4NnxJ5YoFvD5/F5e/t4In3lvDrEeWk7O1AlHUEBzUh8iIS0/6/KIoYlHYKOrwPh06fMZzzhu4zP48f3s6+JSraKVDBjNHjWTMf59mYWJ/nB2DcfYOI8sRjAWJiIRg6k07AAhSJkFQIuhDIarTCV8nLKYzG81qdFhId+1m2+5rmK95FLel8tgHtyIlW7aw548/qMrKxu3yzt8xF1ZRGlzPLqEtBbYEMhxKescFntT5dUY1agE6BnSnu7EH0dl7iarOAbyNBeezjEh/fruvP1/e3ouy4iJWxNTyYWR3PisuO/bBTfB43Kh03kB4QG4wz3YZzQUJ3nkz59NwQT+Nkp3PjeCGh95CMfo9iGjMwLj3zz957fEn+PGFFwHYsnABmy12tgpqggZ0Jd8/DEOAmtA4bya9ncV11Nt8098325MVb8R+IH5rX6+nx8LFXJL1O+53eyJsmU27aG8vw47iM7socWmt97dCvbka7aJiVJV2n/TzgiDwzuiOdKnxELfXxJSBqazYV8nLv+8iJ+8LQCIq8krC/HrAO90Qf3sU3GdfA4nHYsFjsfg8vEsOh3e7w9F02UMCbsnp9G63249Z9mR9+umnhIaGsmbNGu69914mTJjA1VdfTd++fdmwYQMXXXQRN9xwAxZL0yMqLBYLr7/+Op9//jnLli0jLy+PKVOmnNJrejweYmNjmTNnDjt27ODpp5/m8ccfZ/bs2f/qvpVKJWvWrGH69Om88cYbfPLJJz5lXn/9dTp16sTGjRt56qmn2L9/PyNGjOCqq65iy5YtfPvttyxfvpxJkyYBsG7dOu677z6ee+45du/ezfz587nggsahuFOnTuWzzz7jww8/ZPv27TzwwANcf/31LF261Oe6jz76KC+//DI7d+5kzJgxdO/enS+//NKnzJdffsl1110HQE1NDUOGDKFLly6sW7eO+fPnU1paetSM2TJZc+R+00PZ65HmPUSI24zZ/hQCmYQV2rG6BAp/Wkbu707ix3QhKTn9X13GpnAgKZzE63PZIiUDAjqVCM7GL/lyk92b+KEVcnskSvdsRaVtQ2A9vIidt0Q7v6rrAQmDIQ1NRBe4YyGYK094PhaAf1AAVpuaCJw84noJk1uHTVShcdad8eE8LWn1L7+w0emkw6rV7Cgtxz8mno6qaH5JNPKd8ByDWMGlFjX+NSd3fr1RzYG1TNFIal6Of5xqeyCP5D2DyyPh8XgQxfOvLcdhsaDUahFFkRA/DbtLyggVi+kuraazIeGI8t8+8yhaPyODb7oD/zDfuXEOq4Xf3n2Dot076H3bREBiv7WIbY8+Sq/Lr2bqlR2ID9Yfcc7WTKdWEKPWHbF9z4YNWLUaTFbvA2VS527csHAhToWFEfEhJD0RjcPmahiKffj6WIkheiKaWXYgLN7IRo9ErctBnk7iD1UvMtU/oajYDXkraRvdkeX7Ks74osQlh2VMjTRqUIi+Q80zIv359V5vdtbv1nt739rH+DOg+2vk5qURF3sT7F0ClftwOZwoLzn71sja3bUbAGn/rEAZ7O1trJwxg/K3phN49Riinn++oeyefv2RrFZS/voLdaw3w2L1V19ROvVl/C+5hJjXX2sou+/Cobirq0n+5Wc0aSc+ZPpQnTp14sknnwTgscce4+WXXyY0NJQ77vD2oD799NN88MEHbNmypcnjnU4nH374YUOvyqRJk4651M2JXLN3796oVCqeffbZhuOTkpJYuXIls2fPPulAIi4ujjfffBNBEGjTpg1bt27lzTffbKgDwJAhQ3jwwQcbXt9+++2MHz+eyZMnA5CWlsbbb7/NwIED+eCDD8jLy8NgMHDJJZdgNBpJSEigSxfvIvd2u52XXnqJv/76iz59+gCQnJzM8uXL+eijjxg4sHEdwueee45hw4Y1vB4/fjzvvvsuzx/4vOzZs4f169fzxRfebJrvvvsuXbp04aWXXmo4ZsaMGcTFxbFnzx7S0//d85/s/CIHWYdy2qgKGUFd8QbWSBkkO0UCXALBkVpiTSHYgndity/GZBbwM5z8l7FD4UJwa1CIHoJ1bqqsSgL0aqyHtEa31uQXlspK9lTbGb57LiN3e1gYfSc7NAr6poVjN/8CkkRQYJ/GAwxNtyofiz5Ajcflbc31CB76Wd6kVuXNQFZWZyc+5Px4KNVoNBjr6lAEBbBITCe7LonLIpw4lUVESHoizN7PWe+BsSd1foVKRNR6A1ZJEnC5lARo6jCoTJidflRbnYQYTm5o7bns+Zc/QeksZ1B8NAMnTMBaUU8P7Uo68i2dIn1beG0mEwU7twEw/O77jziXSqujPDcLa30d9vJKIJhSdS31Rg+1tTu4dsQNZ+KWzi6S5P13WAB/0aRJJC5chCEoEICI5FRui0tg/fprMGXF4kh/BrW2cTjg6uxjr491kF+QhlqdkiX1TlYmWrgp4Q/KKv1YlfwOvQeOpO0e739LO4rPcJB1YAh0jF8R93f5iH2mQcCFzZZfstvbkzooPRyFQkNy0r0A7NhtY4trFP4VDi6yWlHqjgxiZUfXsWPHhr8VCgUhISF06NA4SiUiwpuBtaysDH9//yOO1+v1PsPWoqKiKCs7es/3iVzzoPfee48ZM2aQl5eH1WrF4XDQuXPn47zLI/Xu3dtnDnmfPn2YNm0abrcbhcL7+9C9e3efYzZv3syWLVt8epUkydswl52dzbBhw0hISCA5OZkRI0YwYsQIrrjiCvR6Pfv27cNisfgET+Cd63UwEDvo8OuOGzeOKVOmsGrVKnr37s2XX35J165dycjIaKjX4sWL8fPzO+I+9+/fLwdZshMiB1mH8gtDe+tHDHrxT0Ciu9PbmhcR70GxR6Q8djH24nVo9fyrIMuqdaFye8+drKuin30foYKemXRuKFNhap1B1juvv45NpcKujwAX7FJ7v4AnDU2juvAf4gptxNXshDT3v5p4XVNXTDLeoFWtdDQEWJmRRrTq86dnZcSUKYwAcivN5Ly2BIDojDa4q75ibMA0yorHkKOC1LSm56EcD5VRBQ43+xUlVElhOEUFQYZazDV+VJoc512Qtb2ols8dKWiI5wK1N1GCVO3AlXQwM2mET3mVVsPY/06luqgQbRM/7IIgMPS2iegDg7DigX9KqEmM4uP4S1kn7Ob4V49rHVZlVTJvzU6e3zUK1EZ4OAuU3rlqGqORDqMv9ymfk7UBs2UzZvMWMtq80rDd45FYe4z1sQ4lCAJ9rkjlo3+y0agq+CHiBvIiEqhzaeltCKVtdD0AO4vr8XgkRPHMJC4qqbMhaRWYOkfyi+4qRghrG/Y5nbWUlf1GVNQYRFGF0+Vm6e4CQMHAdN818SI79WDu2k0EetyYKyp8EoecDdps8M7NFQ4J/kJuvZXgG2+Ew5IZpK9Y7i2rbeyVDLruOgKvvhoUvr8rqQv/OqLsyVIdNqdSEASfbQcDEU8zQxObOv5Y2QRP9JrffPMNU6ZMYdq0afTp0wej0chrr73G6tWrj3qdf8tg8B2ZYzKZuOuuu7jvvvuOKBsfH49arWbDhg0sWbKEP/74g6effppnnnmGtWvXYjJ55z3OmzePmBjfteA0Gt/fm8OvGxkZyZAhQ/jqq6/o3bs3X331FRMmTPCp16WXXsorr7zC4aKiTi6rtOz8JQdZh5mzrgCzUyI13I8nb+pJeV49uXtWAKHY/bxDS7Qnmb79oK53XMr8b/8iGFDq63nH8i4FrjifIKs19mR53G5sKhUmrZ7lIRcQ4QrFI3iIEz0EU0Wo31Cis9chSL9D5q/Q9vJjn7QZNnsdqepY9gEfKyZi7x+OckcN4f7aI9Iznw8+W5mLBFyQHsa+MjM9jN7PstMcihSn+1eZLPUBWtxl9WglFe+p7idbSCExaBvUeOcKpUecX5PoZ63IAaBPpJZuFw8HQFnvxqWuRwA0Gt+MYgqliri2HYhr24HmJHXxtsaaTHWs6bYdw4HPsFMQWZ9bTV6VmT7JoUQGtP7P9o6iOhZt2sfzWsDtaAiwDpW3bTPZm9YTf8lV/JyXTbgimlibjR1/V9BpiDd42F1aT43Fd+5Rr2bmYx2U2TeKwIoqane48SDiERQUlXn/W0oONdAtIYj0CD+sTjcGzZn5eS2ptSNpFZQaItkiKRkmNi5cnZv7Ebl5H5Gb9wkpyf9h5d691NvT0CvNJBh3Av0bygYnJ3HTmDFEduiAQnX2DRcU9UeOPhDUaoQmstQ1WValQmjivpoq25qtWLGCvn37MnHixIZt+/fv/1fnPDxAW7VqFWlpaQ29WE3p2rUrO3bsIDU1tdkySqWSoUOHMnToUP773/8SGBjIokWLGDZsGBqNhry8PJ+hgcdr/PjxPPzww1x77bVkZWUx7pAMvF27duX7778nMTFRzkQo+9fkT9AhPB6JT1fmAHBz30T8Q3T4h+jIXXog4NF5Wz21uphmznB8dEYVHre3taU4MZp/nJ2RlHFwSFKq1hhk5VRZ+dHdHXOMH6buAVQuLgUJbvMYqCmvpEPXR0HIgPw1kHnZv7qW1k+P6NLjv+o/ZLdJYgCbGOv8lcryNKDnqbmhc4TJ7mL22nwALmtj4N2Fu+jRVsTjVuIwh5LWJ+IYZzi6fmNSqfpwFSmeSAyebPzFGvB4k15sL6rlgvSTSMF/jqo02flpcxEA917RC/9ob/Y/ndvBOD7Dn3r+koyc8DsiSbBrHn61BQy56k4612+h2/qr0SsjeWFeNBvzavjw+q6MCGj9La01FgfFhPByu1959ELvMFeP281PL03FP8CfLpdcwsIZH1JVmM8SQygfBGbQQbqNx8xzCEpsfKBefdh8rLhgHTGBRx8i5/F4GLZxJ0ZNDNt5FWe9mnUFN8C6/SgNoXw/4eSTIp2s0jobgsXFhTW/khqQjVrTuIiwTheHShWM1ZrDtu338efeUUAavZOUhIc2BlgseAICYonpfhsoz74AS3bqpKWl8dlnn7FgwQKSkpL4/PPPWbt2LUlJScc+uBl5eXn85z//4a677mLDhg288847TJs27ajHPPLII/Tu3ZtJkyZx++23YzAY2LFjB3/++Sfvvvsuv/76K1lZWVxwwQUEBQXx22+/4fF4aNOmDUajkSlTpvDAAw/g8Xjo378/tbW1rFixAn9/f2666aajXvvKK69kwoQJTJgwgcGDBxN9YD09gHvuuYePP/6Ya6+9locffpjg4GD27dvHN998wyeffHLUwFEmO5wcZB2isMaK0+XBX6vkyq6NgVRQlQG30gIKb9Yog/7fTY5VqhQIeH/Mb6r9HysLu6EcMQEK9zSUaW3DBW1ON/d8tZE6p4QtwIBQYcchSYQiMAglwakH3tN2o73//iWdXoeAiKM+mp45exhoXsUYzxKWOuvJrTSTENI6k4ocyuPx8NFjj7FBiqBebEOcvwrN+s08IyZwv/p5ovKgd20do7r/uwfz8AR/ClV2/Bw67nR8Togyi0dKnwZg+d4KJgxqvqWytZmzvgCHy0PH2AC6xgc2bC+Ir8EqGLChI1Dl+7W7dfEfBIZHEpWeeUQK9wa/3Idn0zcUBw9EFdQbj1CHiAens64hXff5ksa9yuLAg4g6IByCvQ+G+WvWsNnlhKoqkvLzGXjDraz+YTaKrj1I3rmVRHU2TlsYcZknNx+rkUCQ3YhaEUo4pZiUeiKs2+DXGZA+AjLPfJBVUmdDcHjo515GG/Zj1Te27MfEXEtExKXk5c8kL+8TnB41GqXEyM6NDU17v32f1J3vISBBXE+I6XbG70F25tx1111s3LiRa665BkEQuPbaa5k4caJPmvcTdeONN2K1WunZsycKhYL777+/IU17czp27MjSpUt54oknGDBgAJIkkZKSwjXXXANAYGAgP/zwA8888ww2m420tDS+/vpr2rVrB8Dzzz9PWFgYU6dOJSsri8DAQLp27crjjz9+zPoajUYuvfRSZs+ezYwZM3z2RUdHs2LFCh555BEuuugi7HY7CQkJjBgx4rxM4iT7d+Qg6xBxwXqWPTyYfeUm9GrvW1NRUUqYIxBzgDcA0qgjUKmOnLB6Ipb88BOJjmBqKxOI8PiTMWgwW5S+//G2tp6sF+ftZGdxHe1Mu+n3zSz+iL+CHDGEIaioVxfgb/dgsSSi08UjCP/+i0xv8MMK+KMjPqeUSo8fLweOY5cUj/8fe3j72i7HPMe5zlZTS6lOR5YjBDzQJ8iBf7mKXD+RUqMWhcNFaYCSqIB/P8Fde3Uc9aKAJ9+bxlqn9M6HK2tln+Nj2ZDrnXeVXrWbovVaYg5Mur5k7B20qd5DucOB6pC5Ok6bjT8+egckCdc1T/PjrnocDhsqXLgRceAdCnUxgbwouVizsZB61yrE2iyiBoDLbSbc6O0VPzzLXGtVfWCIX5ChcZhYQp8+9Fy+HD+jP8kHhg8ld+mB2+0m/u9PMUevYr/9Em79dC0vXNGB6ABtE0HWseclCgJ4nBoUTm8jjVZtY7UjEUf6QNRxvQCwu9yU1p655DqlBxIm+Wu8c8IC/Xx7ppVKP5KT7iUu9kZ69axDUEb77F+6MYed2gvpqKgmUQ6wTtqSJUuO2JaTk3PENp8U9If8ffPNN3PzzTf7lB09erRPmVmzZv3ra2o0GmbOnMnMmTN9ykydOrXZ6xyLSqXirbfe4oMPPmhyf1N1AujRowd//PFHk/v69+/f5P0dJAgC999/P/fff2SyIPCu33W0+Wzffvst3377bZP70tLS+OGHH5o9ViY7XnKQdRilQiQjsjGIqq+rJT+wGEJ2A2D4FwkvDnLVO4gu64stvxdVw2O5Z8lu4oJyfcq0piBrZ3Edn6/KpXv9PjqRh+hnIMNdxINdA0ja5EeoegaGj9ezK81A+iUr0en+/YRrg8GIFRCjNuAU8/hf+XCq7N6W6q7VTa9R0tooNWouy8xk8RbvQ32HpAhi8uoIdrqJ3pyL2eGHf7uTT3hxUG25BXtpME5LJfZdavJU7alzeOdh1Vgcxzi6ddlf7h3zW+esJW/r1oYgS6Pyo3141yPK2ywmUrv3pqiolFfWlANwveJPXlDNZKO9F9/XPczvegffKnpRYXIh4WRyaSzbdUq+4Gbsgpp+Ru/wldLzJcgyO8gUculRsBp29YKMUQCMfOghPG7ftdm2/bMHt977vi6pD+GfsnJu/N9qpo3tTJXZ97PZ3PpYhxIEAavSib/LwH5S2CW2ZVtYOpsG3UDPpGC2FdYy+r0VhPppWPV48xn+ThWz3UW93YVHr8SkNmKjjthmhoyqVAGoVAH/z955h0dRdX/8MzvbWza9NyCE3ntXQRAEKzYs2FFRUdGf/bV3X9trL4AVFMWGYgFBeu89IYX0ns32Nr8/JoWQUIRQgvt5njxPdubOnbuzs7P33HPO9zTZnhqXwLZ8AUuXdEKKCgiNiWvm6CBBggQJ8k8J+j6PQGqb9gx78DJiRsg/TgbD8Yc+KTTypEgpCGwJeHhG+TFznTcwXrGivk2ZzXNEVaHWwjfr5LosKYFSfFERSNpIbrv5CnQVTiz4CWEvGk8Ar86AVnt8+W51qNUafPipSFlAu05Z6GP9BPR1k9Ezx4A9HGqDgV6XX87vT17C7/cMo3uyAa2kxhf5F3ckv8YI83x6pR+bRP6BVBQ6WD43g+U/fMCf+hF8HHMjFUY568jm9h3h6DMHrz9ATrlswHcP2EjtLXsFqirLqbE2X6DWFBbBBdMfoWrkbU33SQpi/Qp6uZWAwELjEBZFnoVfmcNgXzG/CuNZJIwmtDbyteRfcl9XOrz0UGTQZecb7P7yEZZ/+CEAeTu28ck9t5KxdlV925wl+SAJEBDZ75Q9PJmldm79bF2jPuNCtCSEHp1H16XxIPg1bJV68qUwmYQwG1llsnGdEmHAF5AosrooPwkh33XeS3+6iSfUL/FX4GxiQ5s3kqoPEvmok8E/56676N+/F2t//o6dS/860UMO0orIzc3FaDQe8i83N/dUDzFIkNOaoCfrKElNuZ3IiHNQqY9/Uipq5bwLn+jir4ps+gguoqkkVmhIxPb4A1idPkL0rTsJ2esP8MOmfACWd+pJeUoUI/Ny6d4hhRVz1wEq1ve/BWP1e0gxXVokVBBAoVDgEt0ofBpW0Y+M9J5ECvtJyN5Pvi0eSZKOS1GvNaFRirSPNrF8cx5h6Cg3Z5ISsp+9VW1IaYHcNL1JTZRSQCe0Y5mgJiMmCWVVFVR4cPualyo+E1EqBP6aPoLMUhvD24+tv7/W/bCIAl8126O9XDZgFL0jmy7UlBQXoAlIeASB2f6zmOsfxlCnhh5AG68CJECAzkI2PcWHCUharvCFY46IJlore8j+TZ6sbCmGjb4uFCojsNSWeijPz6W6uIjM9Wto13cAORV2HugRSoLjGUb8vYU8T0OR54MXWvq3CT/q54HH5ENwCag3tiUtIZfYkjL2Rdsh4Mco2UkJ15Nd7mB7gfWEi77UhQpKfsAb4Mc9l/DKyIgm7SRJ4uxXFxNmUDPj+r4khOph61xY/R6MfpbQ2HjUOj1K9b+r3EKQwxMXF8emTZsOu/9wIX1BgvzbCRpZB1FYuJ8d3y6n99WjMJtDsVorsVjCUalCCQ0d0CLnELUqXOYsvD1fY5B/BG/7JvCx7zxypahG7UptrlZvZC3ZXUp5bVhOdlIiklFNWJe+jHr0D/r5TNwG6MNclItq4gwtW+TPOjiGKquaKEpIcOTzU/FdxGoqmOB+Gpvbh0nbuq/tkSjZuZPSzAyMsTEk9exNTW4loGOVKYUwSil1RhJ/lKv3h0NnVhGvUpBk7McQczaZ2Rn4XQGsGAhIsuiJVnXmKzIJgkBimJ7EsMa5OEK1n1/SYbFmICElBY2MLL/PiygquSXvQe5Re1lSdSezVfGcfV4qg1PD2fDGVsw+BdP6pfD62my2S8lYpThUgSQmOQz07XkRGSVyLs6/xcj6a/oIKh2DKFjZmUink07DRgDQYfBwdvz9F0OvkpXFXlixjyqDiF0BGZ6Yw/QIAw5TH6sJFqAURu33E7X9S1bqehNn+Baefxs6nE/PpDvILnewIrP8hBtZdZ4s9RY5FzAlummdNYDcCgfldg81Lh+RJg34ffh/ewzRXkhg39+kj3iAhI6d0YdYTuh4g7QulErlYSXWgwQJcniCRtZB7J21kvSqePa9thzPCCMJv6nYoyuj96MTWky6U6XTyCEsGivnOBawwDcAm2hErxbB05BTUFLjpl1U664x9O2GvPr/R83/FmvHjsS06cFenwel5MZxfQIKt1yJ3mhMb9FzRyXGU7BRy0CWE5Hno9JjQin6MAguiq2uM97I2jB/PnOqVeQ7Cxj401KGaWPxCPB26AQk4UJ6+xbXK9MdD3qzGh9yaGsn7SpeCV/A3+IAZhVfBcj1iLonWI77PK0BR3k5AZ8PrdmMsrZoqq5GSRthDzbJRxdTg6qb3+fl9UkXkZIUxnn6HFSihDcQil0hMSI9kt7JYZR1CCNnWzndRA16n4NJ+V+xI2IaGmMCG1euoWDbs5x7/4O8cHFXokO0/woPrU4tolPrWL9rKz6Pm4RuXTFERKDRG7jy6ZcB+G17Eb+s3I/apEJSytcj3KCuX/A5mKNTFpTRxuux7gqgkuL52TyGAk0oXex7weuAst2M6B/JvI35LN5dwoPndTj+N3wYDhY7iT7E93lDrmyEdY43o1GKIEn85R6Ll0ysCyu5fAQYLKEndKxBggQJ8m8jaGQdRMwFnSidvY8odyj8Jm/zGAvYl/UyIeYeREWNOe5zaHQ6FLV1snRGNe2SYtmUX4NJq8RxgJFVZmvdogFVDg8Ld8oGlMbvokvNLhSrtpNrSAMk3tE+TeryKDYmVYMIhhb2ZOnNagI+edKR7TbyiudJfApZkazY2voN2COhUqsp8erYo4wjVVNJcaqBwi1WukqZVBCKIhCDUjz+8EylSsQryEaWZAPCwSTa6/c3yQU5Q5m1IpslP/+GWVnJGLOKMdPvAyDEqecc8XvOwc/gqKX17X0eLwkdu5Cfk8WIyDd4zJ2LM2ChRHSSGiF7JJK7hJOzrZzqTCth4RbU+734AgEkwUOR2Y1NqiaAnSv6JZ2S93zKkCQ8TgfZmzfQfsAQYts1LNC4fX5e+nobRr+Li0N/JiVqB6sMA7n3woeYuTybOev2N+oq2qwh+R8oAQ4eM4qPFi9Dn7yKy2N38mvBIH6uaseTd61BjGjHUKcfQYBdRTUUVjtbRL3zUNSFC/aO3sjYlD/xqQYC/Zu025hbBUCvpFpDShDY79SQK3RlRPK/7N4JEiRIkJNEUPjiINp37ELqPYPJiMiv3+aKyyI390Py879qkXPojAactZoWfr+DZLPEeMUKLmVho3atXWHwpy2FePwBJAG8ChWelE7Y0nuRUVJDqlBEopCLVLgJa+DEeLJ2bVhJSEC+0GbK6w2s9GgjcUcoOnomcM5ddxHStisAI4YPpCasAzUuG/8nPM2zgQcwtICKYx1+lZx7leVwUEokiA3rN/8W8Ytv1u9nUSCBakmLsrYWVo21GoMYAIUfEJj/2jt4XfLEWKPX03PM+cScfRHKgIVcd19qBAmVQUVobZhwchfZw1KYWc2AxHC+iL+crREioQEjf/bow7r2Hfgrf12z4zkTyS6zM/2bzWS+fREXeN/j3N6RxKU2Dmf6dcV+LigWuMOt4QKdk5SQ/ZzfRUvHWDNPTOhMWlTjkLqB/yAfq45BV7Znb0wxb8ZMY3v3IVT51BQoE0EhEmZQ13tul+wuPa73eySKrC4kjYKMdj34K2QMYdqKZtvVebJ61tZu8/t8CK5qDBmbMcYeXzHyIEGCBAnSPEFPVjNYLOEMvWcii7/+gZDdCgzJHhyullEWBEjv1JW95xugGn4SJrDKV85q9f/weFS8zWBA/sFv7UbWt+vlUEFfZwtejUhRViQRDiuFbiiUYvlUeoMhnXLp0KMbDmcO6hYQFTkQ/75KQi1h7CSGuW2vwx0fgWZtGREmDakRZ34xYoCMEln1rENCGAt+zCDWVARAkT2S+NDm8zeOhYBaAi/kaFN4Qrib2LCGRYrC6jM/VygQkMgskb13D916DW1q76+igv2gqUQCVGIo2Zs2sW7+PAZcfAWCINC+YwrL/fFEb5BLRBSLAVIjDPWTfnOEjgEXtiEmNYSlVVbmbgvlL9xUaTeyYO0rqCQf33eZxbb8avYU19A1PoS06DPXQ5tb4WDu+jwmGctRSm52O5xEWWvq90uSxI75OYQgkJOgxRMSRhv09GvXDZBDDd+Z1ItJH62mpMaNXi0yZUTbfzyOjt0iUW/wYBVCQAkaAbLK7PX5eJMHpVBa42Zwu6YiFC1JkdWNpFVSbIwlIKmYqKlp0sbp8bOzUN7eKykUaooRl73G5decy4bdNfQaN6HJMYGARMAfQPkvyKUMEiRIkBNF0Mg6BKIocs6VFwOwcdP3tUbW8dfIqkOrN0I1qPBQmJLAjqpO+JQJaAq9uGsLkJadBAngE0VmqY1N+6uQRAF/tA6UCrq0uYALTQE+/UQu7NzdnUieR0/76PNPyBgCarDkjcBankJB3yS6u3dyi+pzfKXRQMuImJzOWF3e+mLAgYocwvdXoDT4qLJFkW+LJT6q5bx5mk4+2KyhnTsEteRGIfioe7zsKGhevvxMotDqwun1o1QIpMaG1odhVhSVUGVxcRNfER8oZbJlNkUZe2Qjav8a+GQ0XcPGscp/DQAlYqDeQKuj95gUAAaUyc+FNe4Y1hDNfToffpXEYCGXF5fu44dNBTwytuMZbWRV1tZdeyfiMS4o+AmPT40hosGQ2byqkJBqPz4k5nU2Y9VcwzPSFvT65Po2adEmfps2jK351XSKMxNh/GeKejablZ2vLmRwvJEY6R6ceRb+67ua6n3rIGclhCRyYb+bW+YNH4GiaieCy8c5lT/T1pKNUdsFAKetBq3BiCAIbMmrwh+QiDZrCFcHKPrudWIy3kUXt4rBtyyu70sKSBRmVpGxroSMjaX0OjeJHiODoYRBggQJcqwEjayjwG7fC4DB2IJGlkFHwK9khLgQwyo1GebL2N9lPO7C3fVtWrMn67tawQvBL9FjwWKqU5O47sZx5Nf4CbAHrQRRgoDdePzCC4dCUoPaGY3DW8KYbavoULKdS8Rl7HEnsbuohvSYM3cyCvDqEy8BPQgRfVT/tZuxQhyTOg4nMzAURU4lr6S3nJGljZIfJWl+DzO4iiJXFI/wKABrsytb7DynK3Uew5QIA6oD8tzM4WGsjFmHV1ATEHXc+u4s3I7aYtj7FoMUwOl0Ee2vreEmBhhwCC9rcriejmIFxrJ9VKpCeDt9KN2St9FWo6wXPDjTFQYra4UrVKZwQjv3I0KlRmmSPbI+j58VczMAWKPx0a3KTV5ULlEUodMlN+on1KA+ZuU/nc5AlDOMak84SeSS4/OjIoCnaBdkvwGJA+AkGFk+f4DSGjeCBAMDy+jIXsxGuQDyDy8/g62ijDF33Is5JJEr+ibiqyzhg6k3EhqlpZOmM5G+NOoChqtLHfz45maspc76/nO3lweNrCBBggQ5DoJG1hHw+Wpwu+UQK4O+ZYysQCDA7s9/R9M+BY9Uw8BoC4ndh1DgaJwX0FqNrGqnt74AsSrgZXj+UtR5XkpHpFGuT+Bp5adE40DlvwyFoYDycgMhIb1RKlsufA0AtTzZjfap8OzZR0HAwvOWK8mRoin+bgvzbh/csuc7jfB7vWQozeCDEGcZpupwAkCmRYFPqUTtg4SWykuTJNI6tSXPVEyEvhOFJaARG+7daueZL3xRZ2SZq4uY98yz9B83lriePenYtQfJ7VMYVZ2FiygEhQKtsfY+H/4AdDif/328AUHlp0aQKFZKpEY2NbLydlWwb3MZ/YQKwq1bqApJI0IlGxwuWzlRJtkbU9xKnxlHS2WtiEqoTsWqr78GSaLr0CFUZ2xl3XIvkt2HS/AgGrbx4t5EsqMeRqHQoVLVSrR7XVC4+dAnMEZBWKr8v88DBRubNBEBu+hE9Mmfk81owi1qKajxQYfzIbIj5K6mwhlgUY4HlShwQfdYiKj9/ZAk2Yt5KHQWiDwgP3X/WpCa1purtntox372kIhZLYcDRnlrqFz7C8X79uLzeDB78knw2nihL6xdtoclTifF/nhyvSOYNvxcyF2N3yfx26curKUB1Bpok66kXRc9CYO7H3qMQY6bxYsXc9ZZZ1FZWYnFYjnVwwkSJMgJIGhkHYE6L5ZGHY1KZW6RPhUKBVE2M/p1j/Kn1cvAR3sz+s1l6NTl1FcdpXWGC0qSxIPfbqGkxo0kAEist/RkkL6MdfN+ZND4sfQ3rAR3NSX+sXiZw6bNH9Cnz3eEmFv2R11Qi3h0JUQnb2JtscSPFWPBL1/b2DM9T0iSSAiLQSiRSI8PJao0FAEIX5NFhdaC4PTJBUmPBbcNXFUQkgC5q+CX+zEbkiD2efau2IBL25n91gaD2eE584UvMktlI0vpqmCz4CVt/37ievYEQK+x0DG8G4pmSkC4wtJZU5OFpG24Rs0ViN66JJ99G0uJS0nCHtGd6w0jeFvlZxEDGWwz/Hs8WbXhgudWzSZ2cDi5Yhc07lJ2fvYRu2yTAJhgfoP++hC8Ojm80uDXNghb1BTCJ+ce+gT9boGxsgw8rqpDtnUoPsToNbCePuwydEKtD3Bn+TNQDuz6GZa+zFL/IKZ7p9JByOGCik9g4kz5YEk6/Bjaj4Gr5jS8nnU++Jp+ruHAE8pOXKF6ApvGjIsq/vjgK7xie3Sh4QwQlmP+bmJ9+yhtX866eio9Rp+PvaQE/exRYM0jwzmM0up70ApWLjffi7GkHLZ1gmErDz3GIMfNoEGDKCwsJCQk5FQPJUiQICeIoJF1BOz2TKDlRC/qcIse9AEtNr3AnPIqbhTnc6swn2+VQ3nRdyUA5XYP/oCEqGg9dW8+X5XDr9uKkADP4Gh85S6U7hE4c35ji99P19IKYq6aQ/lH7+JQJhCQqgEBYwvmu9Wh0CjxGHNQJC0g2dgNUSHiqwog+OUaZK3t2v4TRLWaF++dyBMeP9u2bkH8xkaFtoin+zxJgS2GV8rvIibkGEI1fW54q7dsYN34O2hMULQFpTKTNSu2UqLJYGHf6/FpJaRKECTw+qUzvn5TdpksetE9TEsnr4qIVNkbsnPrJpLbtmPJJ+9Ttj+XoVdeS0r3XhDwgagit8KBJDXuqzlRluQu4ezbWIrBF8dfYRVc5haIcwbov3MjrogYYvrLn2VhtbPJsWcSlQ4varwMz30bgEVOCyO1BtpF5ZLj20GcehkqTSYV0m2ECwEklxG9/oCwQIUSQlMPfQL9AeI7gnjItq5KO2avgd8Yx3Z9N3qqNpLtiiY5TE/dXT4sUIVQHGCXlEyhsoDYAzs43BiMB6n9habI37uDsHv8FFtD8aWZeEr9PNd4PybBm0t1aBQCEhGiheoQM9m+cJTlTpSaKLp1iEJ0lGCOiwNLIogq0kP3I+m/RKu0YzSaATOY4w89viAtglqtJibm8EWygwQJ0roJGllHIDb2UsLChuD3t+zkxS16wQsllnI+KAtlqgKihCrihbL6Nv6ARKXD848Ts08V2wuqeXr+TvmFVkQyKPHrDDzXOZmKhXlk7tlDmxEj8AJO7824w3YAoNMlIorH6FU5DKJWhaK2TtYMyxTsfaKJXplBfE0x+YEIymzuQxbvPFPQqUVqthQTi4E8YwYGlZMwbRWRJgNq5VFUcFj4tFxkdfDdYIqRV+FtRSCqoHo/RHeGiz4gz9+V+JklGHwR7IxNAUFAk1kAXtmCKKp2EXsGy+Z/ekM/9lc6CTOoCdHJ8uuVFWWYvqjh7W6fk220EmkrYYRaDfnr4asroO9N7IuYTIRfwCVI2ASIDtFg0DR9LCd3lif/1fl2tHFacEOvimKGWBexRRxEWK3BXFTtIhCQUJyhiweVdg8ifnaZRiDV5GFVGKh26DHe9xvPP7+IMlsqeK7BNyASkwivx42kc5fODR1YEuHuTUd3MkP4Idt6/zsbXWk0EftKSTPmkmLLYoT/Nf64fChpeht4HIRGtKPHO8vZmFvFkvhbuKLuYIXi6McAcMfqZjfPXZHNf37cDgHAE2Bj/sU88EgqnrIKCrZvJ+6aZ/hhUz53z95EFFbGunfzyE93Q9UeuPwLuGFBfV8ntmRyy+B1+w+5T1DQSAnxsG0FUKoP31al+eeqiiNGjKBr166IosisWbNQq9U888wzXHXVVUydOpW5c+cSHR3NW2+9xXnnndckXHDmzJlMmzaNOXPmMG3aNPbv38+QIUOYMWMGsbGxRzz/5MmTqaqqol+/frzxxhu43W7uvfdeHn74YR566CE+/vhj9Ho9Tz/9NNdff339cf/3f//HvHnzyMvLIyYmhkmTJvH444+jUqmQJIlRo0YhiiILFixAEAQqKiro1q0bN9xwA0899dQ/vk5BgvybCBpZR0AQBLTaIz/g/ilepY/Czh/RMTybnhU38Tt9WeXuSJ7UOBm7tMbdKowsu9vHnV9uxOOrzR3wBkhdtpmhAzqSGh1Km0lX0VuSGP7cIvROPy+jAaOct9XSRYjr6DqoH9sFOYwriRzEcgUfeF+mn2YXt3vuoqDq3DPCyKpyePhhUwFalYLzu8Vh0Cgp37uXzPXriG7XDilHNnTWRBqQGIHC6SIh9CgMHkcFrHwbfE5oe45sZCmUcOG7cu6JtjZ8tvvlkJFHd305MJTbQtzM25JPjaTEX/uI2VZQfUYbWUpR0cQDlbV7N1HAtzHRZAsDeDoll7j2HeH3h8FeCpXZZGHnXIeKeL/ID3o3YYcQvTBYNITG6KksctDGGAp2iCkfxNOEEKbuwy1mLQpB9hqW2d1EmVr/fd0cH13Xhwp7N9S+s/jj2TloPIkUb9hKvkNVH14tqRT4dGqqgIEdO54QD6pfC4Kk5PLtCvZWfgkeD0JiXzxrZ8D6xyHtXJj0DSPaR7Ext4rFu0tbvGB0UW1oqHqrLCwzxruY97K0XDJgAH2vkdUq64oQx0k1hDptEKkFQcQb04e132XQ89wkdEZ1i47rRPHB3UsOuS+5SzjnT20IN//k/qX4PE3z2ADi0ixcdF+v+tefPrICl61x3ugd7519TGOcNWsWDzzwAGvWrGHOnDncdtttzJs3j4suuoiHH36Y1157jWuuuYbc3Nxmj3c4HLzyyit89tlnKBQKrr76aqZPn84XX3xxVOdftGgRCQkJ/P333yxfvpwbb7yRFStWMGzYMFavXs2cOXO49dZbGTVqFAkJCQCYTCZmzpxJXFwcW7du5eabb8ZkMvHAAw8gCAKzZs2ia9euvPnmm9x9991MmTKF+Ph4Hn/88WO6RkGC/JsIFiM+RfiUAfzqGqK0eVyy53OULoltUhs8akujdq0lL+vNhXvZVxsyBSD6fFyy+0eiP3qKgj27ACjf9ifnO2bj9OVR2j0CzwBZ2rulixDXERoWQVRcGwDu9L/GVUsXUOQLpVQKQYXvjKjfFAhI3PrZev7z43b+79utPPb9NgAW/LSQOzcLTJ2zGnWNnO/zZ1QK7wt3si3QnfijMXh0oXDF59D7emgnq5YhKqHHVQ0GVi1h0Za6ETHUegOvJj+ARdkg3b67qGn9njMRR0Ulvtpiw1XZxfhFJz1YRx9pFcN7DUVUKmH0s3D55zBwKlmlNUT65cdwmSiRGnFo8RdTuPyZRe34BYCd6FFVadi4w45SIfDqZd2ZeX1fzFrVCX6Xpw6tSiTOosOWl0VBwXz8lT+g0muZW6tmCiB4A/TeZWdez3aYlSemzpMQpqZYXY3GH4ZTfT4fJ1yNJCjY7ouXwwxrw/tGpMuLZssyyhoWoFqI4oOeXx61Er8oYgxvCHncWFuE+Porx3H3i6+gumMpvnsy+WVWIRt/z+X7/24kEDgoXjXIMdO9e3ceffRR0tLSeOihh9BqtURERHDzzTeTlpbG448/Tnl5OVu2bGn2eK/Xy3vvvUefPn3o1asXU6dOZeHChUd9/rCwMN58803S09O54YYbSE9Px+Fw8PDDD9ePSa1Ws2zZsvpjHn30UQYNGkRKSgrjx49n+vTpfP311/X74+Pjef/993nwwQd56KGH+OWXX/j8889RKoNr9EGCHIngt+Qw+Hw17Nj5AAZDGm1SpyEILWeT+pQBND7ZQzV0wnns2dadfRuL0KlEHJ6G8IXWojD467aiRq97xGhpE9adipJi9i1ZikGjI7B2Bg+o5hODnfDoUXgCcsFao+HEGFkABnMIVIIo+vlR6Mo73rOoExbpWtX681e2FVSzOqui/vV3G/N5aGxHCiUdxZIJCS+5DgVVKh/x/gw0UhW+aomEpKMIzxQEaDdS/jsCencxgvJFFIJNLlAmuNEqG+7dA2XNzzR+317EL1sLOSs9kk3zPkRSCNx17XVQ6MGnrWQis1EqTbQ3T5EPEFXQcTwAxfnLSEbAg0SlQmpSI+tAjGHy80KoNRyKxEq8iSpMZflYnT4u6plwYt/oaYTbWfvdFRT4VBr+2FFcv2+KPp9obQ2erfexVhdPj+4fo1JZWvT851xxMZVFdrJ+vItu2mq+z7gYj0fDMxt19Lt9LykxsqHTNT6EcIOacruHddkVDGrB4sR1nqzekRu5MulbfO50eibeT0S6HBng8vrZXmAFaosQAz6vn19n5pC3qxKlRmT4VemtJrT0ljeGH3LfwT/NN7w89NBtD3q71z476HiG1Yhu3brV/y+KIuHh4XTt2rV+W3S0nG9XUlKC2dxUSEuv19O2bUNx7NjYWEpKSo76/J07d0ahaLgY0dHRdOnSpcmYDuxzzpw5vPnmm2RmZmKz2fD5fE3GNnHiRObNm8cLL7zAu+++S1pay+dQBwlyJnLmznyOEa/XSk7O+3i9VdjtGZSW/k5hwdwWNbBADjfxB+QV55pKD/HhZs5TrOY66QdCsNW3ay1GVklN41XV0ed2Ju7We4lK6sDCggK+efc9dpgG8be/K6vdgzCFqbHb5aLEBuOJCResKC9l51JZKlmh8BPjyaHOwGofbaR3cugJOe/JZPW+iibb1mRVoOouTxx6pbWnMqBlpyRxIbN5mCexV2iOHC54sBrDEVAo1ejF5ejEjTirFJQRgUrVEILj8rbsKv7pxOqsCr7fVMDGnAqk2gmr2qAnrMqAT1NbI8xvBr8XbKWNjnWWyN+bUjGAJDQvelGHKVQ2shK6yYpxVYkhzO0xiupBYVTZbIc87kzB5fUz/ZvNfP3F+7T7cyIXti2F0GFsLvfUe4ksCgdXOdIZlgdebyk2226UyhNTDy8kUseutir+L+FOlJ1kD6TVA3d8vQO3T14oUygEzuoQhSDAjkJri56/yOpC0ijYl9aV78KvRHRk8seXVXz6+Hp+fX8rK7YU4wtIRBg1JFi0+D1+Fry/jdwdFSjVCsZP7UZcO0uzfTudDvz+Q+c1nQpUGvGQfwfmYx2xrfrIbY95jKrGXmRBEBptqwtdDQSafx42d7z0D57FRzp/3ba6869cuZJJkyYxduxYfv75ZzZu3MgjjzyCx+NpdIzD4WD9+vWIosjevXuPejxBgvzbCXqyDqKw8BsyMl9iX9ab9WFshhOgfDdy6hUs+klOaL7UPQJPVTnbDLMJ8xbzl9COjZJ8ztYQLujw+JpMoj+triazpJTHomMJz8+jXXISfyiH8YU3lbMDSrIWLUGZfgcde0Wg16WckHHZbTWk745nTxL8xnnsOHsgvhI1ylw7oXo1PZPOACMrq7zRa0kl8EZBCWkV8gQpQhIRBIFilZueOtkgK7JHE384I8tRAZ9OkOWse0wCxVFMOiyJFHtvoowknjdHkyG0JzVsK9TaGEVnsLR4XY2stBgzl953H167HbcCIjwWKrRbkQB7iRt+vkcuQHzV1xDdiWqnF73dDygoFuWJVMphjKwuwxPoNCQerVHJ8898RJ7kZenaazH77exKO5ssRQc25FQSbdYyJK3lPCanC5UOD3PX54Eym8uUDlA7cBusLMppMDD7aSp5PjUZi9rBEDTEmLogCCcmZFAhKlD6FdSoQrDoauhXuZY1oX3ZXmDl+V928cQEWXBj2sg0HjyvQ4vn1hZXu5B0IoWmZDySnkuVaxEEAb83wL6NpQSS5FyrnkkWln/wO73yb6W9pwv5qumcf0d34tKaf/7t3L4Z+zdZ1HQROOvSC1p0zEFOL1asWEFycjKPPPJI/bacnJwm7e677z4UCgW//vorY8eOZdy4cZx99rHlrQUJ8m8iaGQdhE6XiNHYCZttB1arXLSypeXb6xCVBnyAgJ9AuA6pw7lsyy/GUdjwY9waPFnlNk+TbSl6DV4Bxk4YT+oVlxIIBHj3g1UAJCOSXhLLbnWAuHGXnrBx6QwGXJJI3IZpZEaGUZEURWrFHh5QzcRQqgJ+OGHnPhn4AxJrDggVlABP7wi2aCRK8mTrxlDjJ1YlUGQsZkd5OmZ1DVaP6fA1stZ+DEVbYfUH0POaox5PvnIY0R4LeikXleRBKTashO8orD7Mka2bOiOrXZQJjUn+27NyOVHAgkgtb/EVZ4VsZezed8CaX6vK2InsMjtRtflYxWIAhQBJYYf+XLSGhhXpeYo2KEtyQOPB4RNx2KpZvquEp3/ewbiusWekkVVhl58za7SD2BYXzrI9NlQeE2uK3aCQn5npWj0vJ6oRpe4Mx4/Z3O1wXR4zmXt2UvHVbjp2z+J58z2UZSTgq7axztKLOEU5fde+TkVugLCpC4+9Ht1hqHF5sXv8CEicXfkz7SzZOFwm3JpyRozth6hS8EGR7DXtmWQhZPNf6MUqzKpyxt7Rnfj0pgaWz+djyTc/0nZzGCbCEbdW4hnvRq05/YWXghwbaWlp5ObmMnv2bPr27cv8+fOZN29eozbz58/nk08+YeXKlfTq1Yv777+f6667ji1bthAa2voXKoMEOZEEjayDiIw8l4iIUVRVrWV/3ixqarYSE3NiVvOUSj0+4P7il8nfkob3tvtYERlgd8Gu+jalrcCTVW5vbGSpRIEJP3yE01qNOnQqRGpQFGwkp0j2niTWRl5KuhObC2AwmHABhrJuxAfWMdpaQ3mpn4vE5Ti8GlZlljGgbeudjO4qsmJ1NRSxFQBlhhVfhxBqKhyAguqS3fTVp7AqpSMvWJ5C3GdDiY3Yw9XIGng7qPUQ0b5pAsNhcGvc4IEHlXOQ2M6HNdewHznxf2fhmSl84fT4ya/N7WsX1SBaEZ2YwJ4+myg2K/AKagKhCXDjH5CzHNqPBmBfqY3oWiOrRAyQGKY/Kln96pJieleswSdVsvZ8M96AEq++A3G1oYoFZ2itrEq7HH6qNZhRt+2Ce8lGNCqwhsseG4EAfVyRTNnrJjdtNSrJd8KMLKVaRawzHK9bi5E96JUxzIkYgEIKYJN0jFGsRSyTqCnJxhSVUn9cS9Xmqys6LXgCDPCtoDO72c0g3Joy0gfEYAjRMDnbQLf4EIamRdKm+604CvoTqZYQ08Ka9Odw2Fj/xi+kV8tKunui8+l53ciggXWGM2HCBO655x6mTp2K2+1m3LhxPPbYYzzxxBMAlJaWcuONN/LEE0/Qq5esyPjkk0/y+++/M2XKFObMmXOY3oMECRI0sppBEARCQ/sRGtrvhJ1j9eJFBDIcSHGxRNcEaJsSR0Chxh9oPEEqq2nqJTrdqLA3NgTD9CrKMrNweLyymtraj2HV27ykGsatrttIVEpUJi5ECK/B5Rp2QiTyATQaLX4CiChIqfDjtufwk6oDL+iuoEAK5+ePVrLr6XFHVy/qNGRVM/lYYpkbxbIS/ChAkJh1bhfOWuMk26BAUongl4gyadCqDhNCpTbAwDv+8XjM41Lx5CwivbiUXJMPjdhw73p8gTOyIHFmqezFCtWrECuK+eHNz9HrdIy65x7iL02mr72QG+zFqFXpoA+DjuORAhKCQiCr1M5CnZdov4IyUWLYYUIFAaSAxLK5eynJ3kvP4u14okNBEFCJfsocTrokyGILhVVnZmhmpUO+n0L1avZtXYvPtRyFPgUP5wGQrq6grbMNsTnl5KW9jQSYzd0P0+OxE2IJxUYhKq8JJ2AKT+PSAVeyYd5WqlDxqO8GdgWSuDpX4JKo2hqCP+9AIQh8efOA4z7/ljzZM6wKeAlX1T4HauIxSRYMIbJh1DcljL4pBxhUocMO2d+a3/+iXXUsToWLoiE+Roy5rJGAQpAjs3jx4ibbsrOzm2w7MMfqwP8nT57M5MmTG7W98MILjzona+bMmcc0ppdeeomXXnqp0bZp06YBEBkZSVFRY1ErlUrFunXrjmpMQYL82wk+RU8RrmoHqTmjCVnyLIL1MUZPuZvxM3fw4oLdCDTkN1ld3sP0cnpwcLhgmEHDlc+8gju5AzM+mUmNUwRzPMMnTmXn8+ehjCinMuVXMH+Pw5l9wsalUChwKdzYIjbR5+wKNui1FKjCec8/gR8DgwlIivoV4dbI6n1yPpYkCkgqBXU/xYIUwIILjQYkUcHacCUPbytCvbwYsdh5+Hys4yAhtiMRGQuI370DRUYMRZVRjfZXO0//e/mfsr1Anuy2izJStX8/Gz0eNpSUEAj4WT57FtoZF9O5qoS00BQANvyew8yHlmOrdJFV4WCH2s9fOi+BI4heAAgKgd2riijMkOgZN4FUY3++ZSJfci1WZw1xFtk7WVLjwuc/84RG6jyGg9lMt7Bi2vdM53tVpzotGwaJ8nc5L3E7kuRDpQpFqz0xiosmkwU/fvAaWMzZzNckcEmfeAa0kY2ar/znsFFKI6NMHrNZq2LVvgpWZ1VQ5Tj+hbPvNsjKrKHKKpxqAw50xBn7kt7p2Dx3vgK5/EZeTztDx54XNLCCBAkSpAUIPklPEUqdnF8hCrBKH+C17CKG6/awWnM736mfqG9nbQUT04qDwgWtCXou3VfBtoS2eJVK9Oc/DtO2QrtRCIKA0u/GqysDwGTsfELH5hI9VKQsoEo5n/YROShDGu9vrbWyAgGJNdnyCnYgUov77Fi8vWvr4wgKYmIimXXrEN43eJmc5aGyz0u80ecB0vR7D50jkr8eZk+CzL+OaUwVBXa25LVnibovnxsvoUCX2mj/3pIzTwGvxOpGLSoYmhaJMTKSbqJIutHEXzNnY130FcqyHUjzbgGfB3u1m5XfZeKo9pC5oZTsA+rKAYeVb6/DGKpBUOip0Svp4Esmv7oj43duomvGe0QYNKhEgYAExa0gl/OfIEkS32+UDYvzpcXE7fkAvXUHHT0Nwi/FegObQiT88QbCw88iPHz4CfOciqKITelE9Br4iCl8G9GPLas30INCDL6G+zyrVP6ME8P0pEeb8AckFu8uPVS3R0VhtZPlmfLzs6pjPI/qX+WvwCjOu2koo66Xn6c7C638vKWA3HIHFG+Hpa/C/jWH7HPk7VfguSmSHucMOa6xBTlxGI3GQ/4tXbr0VA8vSJAgzRAMFzxFqGpj3QXBz9JIK1lZRVyqMRBtq+LAaYHd48fnD6A8jesMHWxkuQ0imd4Al40Zw0SfHZsPSiocpEXLUsoqTQkeQCFEoVI1rRXSkniUPkSfjhxS+bjPXYg2N+HLs0kUSqnGSGErzV/ZU1JDlUM2wCVN7b3hbhCa2F1cg2NJMbrSGiRE/PpSzKK3VvTiEJ6sdTNg189yuGDbs/7xmMrLc6jyTeRTcw5/t+2JIbscyhqM2MwSW+PwpTOAO89JY9KAZERBIESv4uLHHmP9imVE/yhRETeOuUkW4ixh9BCU5NTWkotINNJ5WBxZf+9o1NfhChHXYQzVUp5vJyAp0AYEBtas58LSRWTrO6JQCMSEaNlf4aSwynl0BadbCeV2D25fAI1SQWynQezL20WhOoroAx6LMf36cVPAQYg4mF3dbjvhoakOlZvonDG0MxcBfpZtW4Nq7ybahw1kY0gPOgvZDMr7GfIFiO/FOR2j2F1cw8JdJVzYM/6YzztvY359hQWboEfwBugWOwWVqiG/9KfNBbyzOJOr+ifxXMQfsPAp6HQBJH56yH7btOtwzGMKcuLZtGnTIffFxx/7/RQkSJATR9DIOkWodVpcpr1UdXuX3sJZaAv6UObUcr77GQql8EZtbW4fFr36FI30yBwsfDEiL4e01BCGOjyEW5R8sj6Pp37ewRCTgUu0ZhIMciFEjfbEqDYeiOXyduTnGjGRTaS7DGW1j2nKb7hO+Qdv+yaQX9U6V24PrI+lzLETX+2n0u3FA3SpySDGV8n2ZS5SFWFsSrbxnTiJNoE9lDnDDz35HngHqI3Q5ZJjGlN1Rg49DFHkWiPoGOrhh+1Wqmi4b7PL7Yc5uvUSZmj83azKKSGaSHa3reLOhAdRECBLgNxtstcltVsEFU4vNrev0XGpkUfnyQIIoEAADPtieNp7NaHmTkwF4kJ07K9wUtBKPbSHIsKoYdF9w8kstaOLOo/taxVYsxM516BktbqMPd4IurQJIyzHTbpBe1Jy/1xqDwqnhtu3lFNUo6JduzZkl+QSqA0QuUH5K5e4lyJti0CoNbLeWZzJ4t0leP2BYyrQLUkS367Pq3+t3lbFpM4Kslf8yLNf+7nvnnvRh4Wyp1gWmkmPNkF4R+h0YbNFxQOBAHZbDSZzSJN9QU4v2rU78b+XQYIEaVmCRtYpQqPTIgkBAoZixrt+JGFJHqVtz+FbqU2Ttlbn6W1kHezJituzEtuf24k42wyF8wlRTwCuIMTqp2B/FfHX2cAJUZF9T/jY0jp0oboymkTnUu4t/B87V3UmPyKCUikEHyJlrVQk4OD6WEPaRFBQ5WBlZjl7jMmkatzUVK9HrRjFh6lalgrjiSeXgCQe2pMV1RHOe+HYB1UbhdjJtIIOZXMwRQ7gf3mT6nfvr2ydXsPmcHn97D/AOwvg93oRFAqEQvn7IISVM076AUnfFWWgB7k7ZcM4uUsEby3KaNSfRqkg1nwYxcda6ows0VqGTatHafdDjY7lyb2ZCtw9Mg2PL0DX+DNv0iwIQr2CY8bGxXQ3DSNZ7Ml0bHzaLpyLEiOYEGek3FV1UsbjDgmQ7y0l1BhFRYVEaGwn+l1/Ja8+twiABf6+6HDTL7wnEUCPxFDCDGoq7B7WZlcw6BiUTTfnVZNZasfoq6GDbQ9uhYb+9GcDICGitcif++5aI6t9tAnangfp5zXb344tG9HNqWJ1Yikjb7/imK5DkCBBggRpnqCRdYrQGHRIfnlSpTWouPXJ5/hrv5tvv9vZpO3pLn5xsCfLkNQOCTeVhRsJF5TMt7VHpxJpW5uK4JPkCWZo6IlR/joYtdYMTtD5LPxh6EKl38QH/vEAjGyF4YKSJDXyZAH0bxPG8owACAJCQMLiq8bo7ostQUmK7TcKLN3oXbWcHzn30EbWcSLqlaiEDIaUf4RnnY+MtMbXtlOs6RBHtj4WbCti2pxNTOgex5tX9gRg7eefsyAnhxSfmv6qObTz27iKfbRP+A+FmdV4XX50JhXra2x8tqpxwc9BbcNRHIW0tzFUfmb4EfAKPsrMLpRGPzaXrbaf1luS4FBkldmJDdHWK2IGAhIBnxe9Uvb8LRCrmNBjMADV1o1s3Xg1Ieae9Okz94SOa+TtV+ByFbBx9QtEm2pw1EwnyqTFqFFic/v4I9CHPwJ9+DykP0MAUSFwVnoU327IY9HOkmP6rL7bIHuxYtwlDKxcg6adH2PMIjpa22HgKhQKBXa3j/0V8nevffThQ1CLVu2lgxSPcObppAQJEiTIKafFE338fj+PPfYYqamp6HQ62rZty9NPP91EtvTxxx8nNjYWnU7HyJEj2bt3b0sP5bRGp9MTCMiTBq/XjkIZSmJkCAMV27lV+RPdhMz6tqe7+MWBEu6SViRv4DkUWmL4irOYqnyVJYHujEmPQoOASuPD5ZYnmEbTiRW9AFi/YhklWYUAiL69tLFnUCdH1i7SyOV9k074GFqajBJbvWErCeDpGsomnURupQMAt0JNsXUQIiEQF0qIYi9P8RBUyuFp8ZaDhC8KN8Mfj0N5JseDqFURwIgSDxp3ALWvcXigTnXmrOl8tSYXaFwby+uRP5OOii0YxEWk7d4CkoTRkE5ObahgeLsQ/u+7rY360qoUPDy241Gd11AXLqiKRS9p+KV/X77qfz4d9H+D68wr+CxJErd9vp7+zy2sV9P0vdaNW9LWUWOw4cFHlUJkoy6Ayx/Aat0CgOYElYU4GL/fxfv+SB5uO5l1CaUIgkBqhAGNv+GZmFXWIIQxpksMZ3eIomfSPy/i6vb5+XFzAQDZuiR2hHXg66G384E4CrWhnJSuKUCDwEyEUUM4VnA3X6PO7XaRsF8eR2ifxH88niBBggQJcnha3Mh68cUXeffdd/nf//7Hzp07efHFF3nppZd466236tu89NJLvPnmm7z33nusXr0ag8HA6NGjcblaZ+jWsRAdHU/Kw3KM/K+K8+i2dTcfFRVxf/R6HlJ+xRDFtvq2BxacPR2pOEDCPRCm5sMaKyt6DKKNoGKhPRI/ImdFyGEsoWYdgZ0PQ8XtaNQnftW9cmse0YXyeT5IvIkd5wxAUsu3vUWvYlSn6BM+hpZmVVaDF0vSiATi9Hy+v5TNuVX126MkeTK+wWanXeg+ADIq2xBuUKNTH1Qja+3HsPwNWPz8cY1LqVHhlyJ5K+pG2g/6lTfCpjXa3xLS1acDmaU2VmdVoBDgsgMmpwOvvZb+oVHEes+lPDCIbfGhBAQRo7E9KV3C6Tgklp8qqqg56Pv81IQujcIOD0ds2xBueHkI/nO1fK3PQELiq63383LeG7B/LRV2D9+uz2N2rRHY2tmcV82uohpcXj/pMSaQJJS2fEyijS3a/XjwsaFzGh8XVzB1Z069kWU2dT0p41OpzHhRYxVC2Ja7H2tpCYM2f8I1eV8iSLJ7KL+4uF7Zb1SnaD6Z3Jdx3WQjsMbl5bftRUdVC+mPdRk4a2QDyqdQ8UfSuezRJLKJXvhcZqJTZBGhPUWyUdUhxgR/vwwvJMnqggexacUKjH49lSor3fr0P/6LESRIkCBBGtHiS8srVqzgggsuYNy4cQCkpKTw1VdfsWaN/CMjSRKvv/46jz76KBdccAEAn376KdHR0Xz//fdcccW/Iy5crkMih20JBHALAgX5OfQaOo7FC1xkeOLq257O4YIurx+7p0HVTvD4GUs5PVKi8FuuwvPTDjrGmvFvrwLAEuenQ05b9lecpNAxtQJjYTfya24gs2cnHJEa1KoiXpXeo21pOdh+AGPkyRlLC1G3og8g+CW6W/3UbNtFgWQhQnBTGdAQ5Ze9dYVlOwgLaU+NsYh91cmkxzYTKtjhfKgphN7XH9e4VDoNIBAqtcOu1KML2IEGw2pdTiWBgHRUYXGnM3UGzNkdookJacijUup0qKNiUBRGsj7xbG6IGYFCkFgdMBCfruar7BL+3NbYq3BBjzgm9jn6Wk5KlYhSJdKhWx/uXOjg6vKvCdMUUOE0YPa6KKp2cd83mwk3qLmiX+vz0h7MV6vlaz2ua6yclypJPBX3Ie13/45RG48aJX0dNlZFh3N7YhTWbZsBMJuPrV7UP2Hd8qVIf5YwZujPjJQWoKscgc4citpdAwEXUe5SDDo/0zddAzt08EAWKBvn1r63JJO3/8pk6lntmD46/bDnW/H9XG7OXclqS1/WhvahX5iJs/R/scteiFPyUZ25nsikEY3zsapyQQqAJblJf/aNJUA8xal2uirPHC9zkCBBgpwutLgna9CgQSxcuJA9e/YAsHnzZpYtW8Z558mJt1lZWRQVFTFyZIPSUUhICP3792flypXN9ul2u7FarY3+zgQEQY0kiQxjMdevmcugpT9Br2v5MOohfg80iEKczuGCB4te9MlYzUPzb2Xq3OG41shywRd2iKZgbzWCAOpo2VvpUZ8c75ygFlG5IrFVpjBk7ybGr1mG4A4wRLGVnoHtbNi6udUVyd2QU1n/v+ANcKXgwFol113rSg5RXi8eQUKjzGNKwMRlO6fw8+arcfl1zdfIan8uTPoGUgYf17g0OtngaOPyMUu6nJf4T6P9KzLLm+TvtTbcPj9za9XdrurfNMQqtX9nCs+XkHpZEGp15qLVKjy+ADNXZDdqmxKu59mLuh6TEp5RKdGvci3JNfvZ0VnPE1EXUZ00qr4gcbndg8vrP0Ivpzc1Lm99eNyV/WWDUQJ+3y9irVIzwt0VNUoGmTWsGtCJzloHbnchIGAydTnh45MCAWKdUcT5y0giF6O5H7MeWknCVffzYdJkirXRZEkxVAsmMMeBNa9JH2LtZz9jeRZ296GfiU6Pn+qSYgSgSiVHBVzWK4HuzrVcyLfY8VC4V/7NvXFIKu9f05uLe8XDVbPhvt3Qfkyj/kqKC0ktlb34yUNOfNh2kKYsXrwYQRCoqqo61UMJEiTICaLFl68efPBBrFYrHTp0QBRF/H4/zz77LJMmySpjRUVyrZjo6MZhWtHR0fX7Dub555/nySefbOmhnnIWvj0HMSkKdcBPF4eN6K5dsLt9teLMDZzO4YIHG1kRvgq0Cg8Kyc/1Ey8ioTyC7iF6dvX1EvAF8GmfoyTdgs91ckQvFBr5FtcrFXTLq8RudSCYU3kpcDk+lCz9oZT/RVYzuF3rEAzwBySKrI3Dag1xKdhEKzq8jNY7WYLIUMMj9Bd3ket9HIimUpJX0HsmWeSDbCVgLYC4Hi02tqQ2bdk9ZjOR9kpicqyUWsQmbQqrnUSaNC12zpPNz5sLqXR4iQvRMrx9VKN92374kZpdi4ht046+EyazBxd5Dit7VhXhUAvYXT4O/Gq/dWUvjJp//gje+Hsu+/eUcI59H1q1FgSBWKmCaqeX1AgDOpWI0+unsNpF6lEUOD5dmbs+D6fXT7soI32S5dyhvSU2AtZy7DVZKEJlI7JDYiQ6UUFppRwqaDC0Q6k8cs2x40VvNgIOFF49AdGDtbIMt0NDW200LlFW+ZFQMMr1IqumXIZa2XRN855R7flxcwHZ5Q7mbynksr7N50btLq5hftRo9D47XoUaQYAxXWNYu6QMVGBwhJM4QDaW4iw64g4s02CKadLfll+W0kGKJdtcxJD2Q4//YgT5xwwaNIjCwkJCQs48JdAgQYLItLiR9fXXX/PFF1/w5Zdf0rlzZzZt2sS0adOIi4vjuuuuO6Y+H3roIe69997611arlcTE1p+oG16qJzLvef6u8ZE2Jpl+49twxxcbWJpRhgof3tqP53T2ZB3smdiYPIaMiDR+KN6B+q0vueVFWRI86UYLfr+LvxavozI5gJR9cowsUavCr3SgbbOJkZ2juP+zcJAkvgsMq2+TX9V6FAbL7W4CB6RvBLQiPdqGsfDeYewrs3OOq4ZxfzyAyVmAVxLR6nbgdHYloDZwcdd4JvVPBo8DvroCSnbC5Z81Wz/nWLCEhtOmTV9cX75EosuBs7ppGFxBlYtuRx8dd9pR51m5emAy4kFhj7s2b2JI4GditpdSFWfBMvhqUoVQPv5yKT5vgAiTQKkof3hmrZKuCcc2uSrYW0nNzhrGJdzMx+p5rKYrgslPtdOLIAjEWrTsK7VTWOVstUZWICAxq9bzd92glHpv35YdOxmvWYMqQsdF3f34VCJL0uUwu4Z8rBMfKghgCrEADiSvmWXabpR1iyEtV8KX52jUrkIykVvhaCSSUocgCFzeN4kXF+ziq7W5hzSydhbK0RuOWkVFffdwfq6wEqZ2opKg/9kTSel59J7o/peMZs3PfxLervX/jrZW1Go1MTFNDeB/O36/H0EQalMqTh4ejwe1+vQtlROkddLid/H999/Pgw8+yBVXXEHXrl255ppruOeee3j+eTmpvu6hUlxc3Oi44uLiQz5wNBoNZrO50d+ZgEeUPVR2ncB3kpPPCspINkms0dzObs116JA9Fgcnyp9ONFIWVAkUDIjkofjOFAXCMapVjdra7XsRhAAKjwFBHX5wVycEpVaFX2VDSpnL1qrv6KTKQH1QqGJhK6qVVVrjbvTa1z2UoZv2shM/pj12qhd+islZAP2nUHnT32wd8DcZZ9/Ob/f25b+X9ZBFLyQ/aC2g1EBoaouOr2BvFZvKE/jFNIyvVKOQxMaGSGErlMw/kA+v7cPrl/fgimZUKZNSUnD5tNj9Bkrt8vvO31OFzxtAYVBSqmiwjuObC9s8SgyhWny1Qgklmp5sdQzgkrI1RC95AJALEgOtuiDx5rwqsssdmLRKLu4ZX7+9IGMzj+hmc1nEesri46iK0tc/Z0JDB5CQcB0RkeeclDGGhIYBoPLq+YDb+UYfSUl4AXlbCxjs3Mbg8hX1bbPK7CBJ4GsaLntJ73iUCoGNuVXsLmpeCXBHQUOIfEArUhGl4d7d+3FpExFFI8kd2wKwt7iGt//KYHlGmawY+uOdULStSX8mcwjnXHUJPfoNOK5rcDLxulx4Xa5GIiF+nxevy4XP622+bSBwQFuf3NbjOWLbY2HEiBHceeedTJs2jdDQUKKjo/nwww+x2+1cf/31mEwm2rVrx6+//go0DRecOXMmFouF3377jY4dO2I0GhkzZgyFhYVHdf7Jkydz4YUX8txzzxEdHY3FYuGpp57C5/Nx//33ExYWRkJCAjNmzGh03P/93//Rvn179Ho9bdq04bHHHsNbez0lSWLkyJGMHj26/rpXVFSQkJDA448/fsQx1b3H+fPn061bN7RaLQMGDGDbtoZ7su59//jjj3Tq1AmNRkNubi5ut5vp06cTHx+PwWCgf//+LF68uP64nJwcxo8fT2hoKAaDgc6dO/PLL7/U79+2bRvnnXceRqOR6OhorrnmGsrKyhp9XlOnTmXatGlEREQwevRorrrqKi6//PJG78Hr9RIREcGnn8rpD4FAgOeff75eQbt79+7MnXtiy0UEab20uJHlcDiarECIokig9gGWmppKTEwMCxcurN9vtVpZvXo1AwcObOnhnNZ4lXK4S0FINTNNXl7amkF4qAUdbhSCRJwgCxyczsIX5QcoCybqyhEUfiqLBRbrh6I/7xo2L9pPRYEs5V1j2wGAtiYZ0XByQsZUWg0Kn5yn8r3qMuZMuBFfjB49LjoLWXQV9rWqiX+ZrfEEQayNP9s751vW/rKTrzPvpazvKzD0Pkoqt4MigMIdgl7fIKSCxgRXzYEbfoPwti02Nr/fT1nOLuzeUdzc/Qk+6nQZqBo/Cwpb8cQfQK1UcGHPeMIMTVc8+117Lfs1j1AqvM8jopt7133Pph1y2Jg3Ut0oVPB4apUZQzX4aueZ3StEOti2MaJqM6H5iwGIrRXjKGxFHtqD6ZkUyqL7hvPKxO4YakMqJUlibZGfte509gnJjNm4ivGIGJRyWGpY6EDS2z9OVOTokzJGkykEP36SNk+lb2UpHQqz8Ssd2Kvc9CpaSi/rZlQB+fuq3TwLXu8Gq95p0k+UScs5HeXQ09lrm1eF9P05k3NK/8LisZLsgnP2+xntVzO224f0bDsftVoOv/9zSzYv/7abT5Zlwe4FsOFTsDWE4bvdrvrf4tbGm9ddypvXXYqzpsHgXPvjd7x53aUs+uTdRm3fuWUSb153Kday0vptm36bz5vXXcpv773RqO2HU2/gzesupTx//3GPcdasWURERLBmzRruvPNObrvtNiZOnMigQYPYsGED5557Ltdccw0Oh6PZ4x0OB6+88gqfffYZf//9N7m5uUyfPv2oz79o0SIKCgr4+++/+e9//8t//vMfzj//fEJDQ1m9ejVTpkzh1ltvJS+vIT/QZDIxc+ZMduzYwRtvvMGHH37Ia6+9Bsie1lmzZrF27VrefPNNAKZMmUJ8fPxRGVl13H///bz66qusXbuWyMhIxo8fX2/I1b3vF198kY8++ojt27cTFRXF1KlTWblyJbNnz2bLli1MnDiRMWPG1Jf7ueOOO3C73fz9999s3bqVF198EaNR9hZXVVVx9tln07NnT9atW8eCBQsoLi7msssuazSuWbNmoVarWb58Oe+99x6TJk3ip59+wmZrKLvw22+/4XA4uOiiiwA5feXTTz/lvffeY/v27dxzzz1cffXVLFmy5KivR5B/Dy0eLjh+/HieffZZkpKS6Ny5Mxs3buS///0vN9xwAyB/aadNm8YzzzxDWloaqampPPbYY8TFxXHhhRe29HBOa/zKAMUdPqVdeC4dq25EU+bGZ6ziYs+TVEgmypE9dqdzuOCBOVnvOV8mfmklU/z3s9rbFoWgZdnXexEUApNfGExNzXYANNZkpKQTUxD3YNI6dyZXtxuqIYIyQu1W3D4YptjCe+rX2RBox+vVrUe++GBPlmpNKW29BZQYijBbXAztcy4R42SRmZqajQCI1UlNxRVEFUQeXs3snyIIAml71KRr4zg7r5TIDha+D3hr5R9k9lc0P7k43XF4fGiUYpMQwSYoRSr1+fytGAA1kLqlDAVQYlJAVUOzeEvLGFljMxOZIXl4UnkNw7v3YAQQa2n9niyANpFG2kQ2hNjtK7Oz1J7IJu90ptlruMoWjeDZTnm3SiyW/ojiyc31UygU2JROQrxGngh1o/er2FHUlfwiF76I7mzwKVHUrf7XOKA6FzL+hCHTmvR1Rb8kftteLHu8DsJltxNWupsIJBJUg4hyqGGlFXOEh932vXy7cSOhTieDxo9j90L5M0+PMUHSo1C0FWIaQrOXfvEj+gIFxvOS6Na734m5MP9iunfvzqOPPgrIaQ4vvPACERER3HzzzQA8/vjjvPvuu2zZsqXZ471eL++99x5t28qLX1OnTuWpp5466vOHhYXx5ptvolAoSE9P56WXXsLhcPDwww83GtOyZcvqlZzrxguyGvT06dOZPXs2Dzwge8bj4+N5//33ufbaaykqKuKXX35h48aNKP+BIuV//vMfRo0aBciGTUJCAvPmzas3erxeL++88w7du8v3am5uLjNmzCA3N5e4OHmBcPr06SxYsIAZM2bw3HPPkZubyyWXXELXrnK5hjZt2tSf73//+x89e/bkueeeq9/2ySefkJiYyJ49e2jfvj0AaWlpvPTSS/Vt2rZti8FgYN68eVxzzTUAfPnll0yYMAGTyYTb7ea5557jzz//rHcKtGnThmXLlvH+++8zfPjwo74mQf4dtLiR9dZbb/HYY49x++23U1JSQlxcHLfeemujVY8HHngAu93OLbfcQlVVFUOGDGHBggVotdrD9Hzm4VdJeHVlxBgymLJtLtkbRQwjLmSv1DhppTUIX6jx0lZRgA4vOV4LKeF6LHku9gPJXcLRm9XU7JGNLMPgvqQnnJwwFUtoOJbeg1i0SM1lfEnKVhc/lHSjQBtOqRRCpWRqVSv+BxtZAQmcohl1IA+NpGXgJQ2eKbFiLd2yrSjsu+UNPjdsmQNdLgF1y+fqKBQK3IIXnaTh2tjpKGscLFc+RrGnQSAir7L1XOsDeWtRBj9tLuDhsR0Z2/XQhW5FvwKPoYAbpPeoUPRDUZaC3qxmr9D4O3x8niwtdb1lKIq4oGYzO3xJhJmHMwJZFr53cihtI1tnPpbN7WtWEGRVbemCDrYd+Ow5dEq4gTLNdjZtfpRQS3+6d/8YUTy5vyHlxhpsHichMe1o36kbHk0++Xt2Ywwdy2pfVX27X/x9ueCKr6DNiGb7GZYWyW/ThsnG0UEU1Hj5Ofo8kl1l9MeCD4n2A2Lo1E9PwRr5u60XBKozi9mHfHx6jAk6TZD/aikrKyZlbxhaSUOhs/UZ4HfNkkOylJoGY7rvhIvpPfYCBLGxyM7tH3whtz0gx6bH6HF0O2c0wkGRNjf/75MmbY+Vbt0a8gFFUSQ8PLzeCIAGwa+SkpJm0x70en29gQUQGxtLSUnJUZ+/c+fOjSKJoqOj6dKlQWmzbkwH9jlnzhzefPNNMjMzsdls+Hy+JmObOHEi8+bN44UXXuDdd98lLS3tqMcENIpSCgsLIz09nZ07d9ZvU6vVja7d1q1b8fv99cZQHW63m/BwOdXgrrvu4rbbbuP3339n5MiRXHLJJfV9bN68mb/++qves3UgmZmZ9f327t270T6lUslll13GF198wTXXXIPdbueHH35g9uzZAGRkZOBwOOoNxjo8Hg89e/b8R9ckyL+DFjeyTCYTr7/+Oq+//voh2wiCwFNPPfWPVmjORAIqEPzyg73XqOGce9lFuNRGHt25tFG7mtM5XLDWyPKgYlT1MyTqHRQRzkW2vexeKa/idh4aRyDgw2aTH6oJiUMxGE5SnaxaFKIBv9+DxdGGCpWRIimMvm45xMTYilb8y2zuJtsm9ehEp9Vb6RbxOeK+ZEgbiSQF8CsLiCz3IFEIjgrY+7uco7HqPbhtORyDdPiRcIkedD4HZ63OQxGQ0CkbG1XXDUpp8XOeaJweP1+tyaXK4T2sJ+uXh66gs3oLAY+Wc6jGlRdGNil0GhLHRzuyG7U93nBBAG/AT6GyAm+UjtTSwvpSBG0jjbSNPPHqeieCaoeXIS8tYlhaJC9e2q2RsbV6n1yEWx9wsj8mnu1x2dBpJkokdPoUFIqTr1o57MHLsFq3kJf/Jfv2/UVc51tI6BCKK0oDm6vqQ0Q3VWqgw6EFZkSF0KyBBbCnzEmOPpkwsQ1rEjSIdh93XtuR9RsuhQ527h73DKI3njXf/s0+5BD09rXFrRd+8S2Uy/eFtkYkWYphv7GY/oMubrmLcJJQNbMIKypViErVUbZVIjbjfWmu7bGiUjUeiyAIjbbVRRQcKmSzueOPplD10Z6/blvd+VeuXMmkSZN48sknGT16NCEhIcyePZtXX21cvNrhcLB+/XpEUawP12tJdDpdo2gLm82GKIr15zyQOsPppptuYvTo0cyfP5/ff/+d559/nldffZU777wTm83G+PHjefHFF5ucKza2YZHMYGi6EDVp0iSGDx9OSUkJf/zxBzqdjjFjxtSPC2D+/PnEx8c3Ok6jOfnPnyCnP8EKhKcStYDgl7+YWVvLaDcxlkBAoqOYx1A2UiSF8WNgcKsJF8yJb0deuRslfnRSIW5HG5QqJUmdw/F4ChFFI4KgRK9POWnjc7mcrPrld/wGBahAsC2km6M760J7ARBl0jB9dHqrKZJ7sCdLoVJg1Qp01v9BlG8XFG2BtJHY7XtxaDzsSQul3VnzEHShIKohNAW6XHxCDCwAt9JLhV8kPiAhAOnqIrJpKIR6PMbFqeKHTflUObwkhukY2TH6kO2MQhXJQj7FgRBAhaMsBkEh0H5QDIUrdzZq22y9sqPEaJGfGT4EyuPVfJh+AZ1cOxlbuhlqwpqV7G4tfL1uPzUuH5mlNgzqhsmVJEmszirnHuU3XBWzkI9SruS6Nl35j5TKkMg2dEh/6pjqjbUEHk8ZvxXu4W3GE+dYw8xeAr70dig2Z6DzObErjRRb3djdvvr8ssNR7fDil6T6vL8dhbIYRpxfZF53PQFRYFP5LqzWzQiCEkNIKmp1BLYaERtyonXbQBY7/9xG+tZYoPEkWzki6qQrtwU5PVmxYgXJyck88sgj9dtycnKatLvvvvtQKBT8+uuvjB07lnHjxnH22Wcf9XlWrVpFUpIsFlRZWcmePXvo2LHjIdv37NkTv99PSUkJQ4ceusRAYmIiU6ZMYcqUKTz00EN8+OGH3HnnnfTq1Ytvv/2WlJSUfxTWCLK0fmJiInPmzOHXX39l4sSJ9YbqgcIcwdDAIEdD8El7Chl+/cVou8oSug+bBpO8eDO7nW6uT6nkYdVXXCr+DUCN20cgcPSrWSeTg+tkAXQ3u+kimhBQYInWo1AIaLVx9Or5J/4d01j4yTf4fCcnBDIQ8NNuTRgap5FddOTzAZdQ0L0hHEMCLuuT2CoMLGhqZHkSDex0u/ij+h5KU2+FHnI9uqrq9QDYOg1BEddTNqq6XAx3boCBU0/Y+DxKLyrUTOr1NG0H/0pZZOMJf5Wj9RUjnrVSnnRcNzDlsJ6s5HNvIdNzC2sSkignjPNuGs+l/9cbmwIO/voeT06WUi1ywytDWJ6YS5bCiUfQ8EDmZ9yVNQV2/YwkSXy7Po+3Fu49bIHb0w1Jkvh0VTYA1w9OaWQ05ZQ7KLa6iaKKSNGK0VeDVnIQTx6pqXciCE1rsp0stNoEDNiwCQbylGp2rV6NoiiD27I/ZELR/Pp22cUVsPYjmHN1syqDAB8t3Uff5/7kvSWZgKx8V7jiD8Lc5URLCtIKvcS6QV8hh85FRIxErZZr/JU5ZeM7ziSiXvIcHZfdjqPtPPb2Lq//yxvtpe+QYc2eO8i/j7S0NHJzc5k9ezaZmZm8+eabzJs3r1Gb+fPn88knn/DFF18watQo7r//fq677joqKyuP+jxPPfUUCxcuZNu2bUyePJmIiIjD5uC3b9+eSZMmce211/Ldd9+RlZXFmjVreP7555k/X/5OTZs2jd9++42srCw2bNjAX3/9VW+43XHHHVRUVHDllVeydu1aMjMz+e2337j++uvx+49cpP2qq67ivffe448//qiv8QpypNb06dO55557mDVrFpmZmWzYsIG33nqLWbNmHfX1CPLvIejJOoWoVCo0Wjmswyv68QDL//qTC4aN4PvPl7A5IBsDkgQ2jw+ztmlYxKmmvDZ87TXV22Rbo5nBGO66aiTmvXZWfJtBaHTDin1VVQXpOWm4Bc8/Xl06VrRaPX4CRO6ZSK45QEZ6R8yiFXJruF38nuHuLfh2elB2HHtSxnO8HBwu2LtqK6ayGioMItKIR8Ak114KDxuGSX8THruO0tIiIuuMHYUo/50gfMoARklLpTYUu1KPoGscQvHnzhK6JliOy8g4mZTb3PU1ii7pdfgCX8kjLmbzciv3hp1PjRBCeiCS7slGVmaWN2pnUItY9Mf3XdYZ1dBrCIsX/c3raVNIUBdRpogkAkEOx/55B9VOL6O7xNSHjp3u5JQ72F/hRC0qmNC9cSjOmiw5VPAN38VYqy2EaAU+4hoErxGDoX1z3Z0UlvzwM/rNdhKH5PK8dC/e1f2JbNsVjdqCAgm93yk/wAWBfRUeOi9+AeylkLui2fys1AgDHl+A2WtymTYyjdI9u4jZ8SsTRCMF4ddz9korXSanUFz8PQC5f0tk//Q8Ay+9hFKvBvDRPkoPKh1oQmg/6nLapww5qdckSOthwoQJ3HPPPUydOhW32824ceN47LHHeOKJJwAoLS3lxhtv5IknnqBXLzn648knn+T3339nypQpzJkz56jO88ILL3D33Xezd+9eevTowU8//XTEmlQzZszgmWee4b777iM/P5+IiAgGDBjA+eefD8hqtnfccQd5eXmYzWbGjBlTr4oYFxfH8uXL+b//+z/OPfdc3G43ycnJjBkz5qi8uJMmTeLZZ58lOTmZwYMb1597+umniYyM5Pnnn2ffvn1YLBZ69epVLy4SJMiBBI2sU4xKI8cXX1fxOQW72lG5ewOqD75imrext8Hq9J52RpbXH8Dq8hFNBReJywlIAhur4+gbMY7VS+XEWkuMHqt1CwZDO2xV1RgBm/LkiR8oFApcCjeGii7o7Fs5S1qPqsjP38STpsinv2IX27auQxs+rNlioacbpQcaWZLEsIw11MSl4hTdRCU3FLfV6RJwLG1Du/I4SnI+JNK5BM57CeJ7ndDx+dUBBASm8j0K6VnWKq5nHQ3erLnr8xjWPrLVGFmb9lcB0C7KSGgzsu0HUz7Eg9lfgxMD7Q3yAsPBxa4TQvUtEtpmUkl0K91GJKXktFNyl/MjFvQdAcgy7tVOLwVVzlZjZG3cL6+Md443y/XcDmBrfjUARYSz3R/DGEMxAiDUtDllYYIAAY+PWEccVq+GJFUOfe99k/J90fzw+hb8MVP4WEt9aG5WuRMG3iEbXeHtmu3vrPQoUsL1ZJc7+HZDPn3VErnaBKpVZhYbfICP70LWU2mrRquJY1VBCF6Vmw5FRVyNjoEEMI/sAKkz5fP8g3yeIMfHgTWc6sjOzm6y7cAcqwP/nzx5MpMnT27U9sILLzzqnKyZM2ce05heeumlRgp7IHuJACIjIykqKmq0T6VSsW7duqMaUx1DhgxpVBvrQJp733XnefLJJ3nyySebPe6tt9467DnT0tL47rvvDrm/uWtTR8eOHQ953QVB4O677+buu+8+7PmDBIGgkXVK2bxuNeXbMyEyhIRKHYlKCD1nNDQTSnc6FiSurA0VdKHmWdcVjLQto7tjL+6yMgZd2o4uIxJQaX1s2nw5khRAp7gfI/G4VCc3ZMypdGPw6EjyBTDmlLK/Rg0m+Mp3Nn/5e7J5YzzjQ/KZPrplJc1bGo8vQJXjgPw8QeCKc5OR9i4jL7RhtToQ8AACGrc8UU0s/RWqtsPP98CtJ7aWR8SItuRV15Dq9qHNqcYr7gK6NGrTmtQc64ysHomWI7f9790Y0XKfNRW7p4yqpBp0bUPIq2wsWx/fAnlpGetLsC8soKdfHp9CkHC4G84TZ9Gxq6imVdUl25RbBTR/rXcUNtRGCrXmohCrEfwqJEebJm1PJsq6en/uUFDZcDr3ExojG356nx5ouNezy+xw+T2NOwj4G3mWFQqB6wal8ORPO5i5PIu2F3bhh9jx9fvVooKA/UcAYmIuoW+EhNVqRR0VQXbINjR+Bb1Sa9U8BeGE5V4GCRIkSJAjEzSyTiGO6hra77yYku3j2WWFi6b3Iq6dhc9WyTkgauQJtQfVaSl+UVcYtxojHzKBT4zjeMCwnDdmzmRkXBxDbrmFvLwv8Hor0GoT8NTIsrBu9ck1GN1KLy71fjoOtxFubMfjc0oQpABr6CgnZQEFraAgcbm9wYslKUDUC0Ttm4PKXUT82JsAcHvK2Lr1Dkymjmg9sjxtUZ//w5w/F4b/3wkfY9defcnbVUHVTxW0sTtwmpsmUbemif+QdhG4vH76pYYfvqEk0aX6M5SCny2FIgH1uYTFyp6sg2XrW0L8o7rUQVqpH49lDD+jw4UWp6ehgGZrLEh8KIM2EJDYVWtkna9YiadfIq9HXMJtMe0Y2ieKU4nWLKuTic5wthlNLCnwMzyiBkGUwC9gkgRqBPkhs+/gGlgFm+Cb6+Ccx+WyCrVc2juBV3/fQ2apnflbCkGCKL9AQQcTJGr5psrCuQjEx19G23saioynPNTphL/fIKeO5uTI6/j1118PKxBxopgyZQqff/55s/uuvvrq+lpcQYL8WwkaWacQdW2+iihIFIco+ay8kp4WgXiLlg9Vr3COYiNTvXfyS2DAaVkr60DRi4BRiTc1lK8DAxmasZGwuDgkyU/u/o8ASEq8gcy1sqHo0zYvX3ui8Cr91EStxub9heVruhLjikOjisQlNuSLFbSCyeiBoheSQYVjYCQ3VDzIw2t/oCarB+kpm9i67Q7c7iJstl1EiZ0AC5qEzjDkgpM2zr3rS9jk70OuyUKBO7LJ/oPD505n+rcJp3+bIxhYAF4HZYEwDIIDkxBFeO9INLV5V/kHGVktESppDNVSIkkkBiL4TLiBCE8l/w08RWDWlyiu+5642nPkV52+Bm25zc3TP+9gf6WT6walMKFHPLEhOnolhTZqt7/Sgd0jJ6s/ovqC2IoKzk3phTUrn7Cu3Zvr+qShNxsBO2pHJOuIZ0FlAqs3/83FZvCUuhleto08jZlNId3ZV2pDkqSG8Mblb0BlNuz+tZGRZdKqmNgngRnLs1m4o4jQgMB1Ni1fq9TsVqswa8/Htr0QoY8RatXHX/5tF/mVTq4fnEr3jHchexn0v7VRnawgrZtNmzYdct/BcuIni6eeeorp06c3u89sNhMVFfWPJOiDBDnTCBpZpxC1Vgu4UAqwJ6GaxY5qRu2q5qHUZPaiRSFIxApy0vzp6Mkqt7sR8TNUsZUNtnZYt/qIubgztw8ewtZlRTiXzsbpy0WptBAXN5Hd9l8ACJzkdByf2o/Cp8WPglfaPw7tIey3vSjxkS7sJ1KoIrNq0Mkd1DHQyMgSJDRuFztI5LfqiQyxLGX9hv8iSR70+nZ07PAGtl9LAQixhB6qyxYnJzsDb3k+a01DebHTdXTN2QPVjdscbHScEagNOK74lsf3raFIZeJSsaJ+V15V43DB45Fvr8No0VAggVpS0NexGb/XxbnSBsgC3DX1hlz+Qec+nXjsh238slXO91ifU8lH1/bhxiGpTdrtKGgIFVwd6EBnMY+03DzCVBEnbayHwmQOAeyE7xvHpWP7U/7nciw1lShEBVLATap9G2pfLJtCumN1+aiwewg31oYYXvA/iOoI3Zuu9k8elMLM5VmUWh0MsBcBaXTfYmNYsgXvgjVsFLqheOcdxj/4IJIk8f3GAvKrnFzQIx72r4KcZc32G6T10q5d83l8p5KoqCiiok6tNzlIkNOZoJF1MFvnwg+Hkbi+8O2GVcddv8DcGw7dduzL0Osa+f/Mv+CrKxvt1gqpuEx3UN5xJt38yeSWXIw/dw85m5w8572KJ73X8rv6fqYrv0E1XwG/1q6AjngQhkyT/y/cAh+fe+gxDL4bznpI/r88E94dfOi2/W6Gc5+W/7cWwpuHqWDe82oqLHfQXshjpvolrJKeYe5XueW3myl3RLGrcgpphrcRQyHBHoYo6pEctd443cmVW44d25mqqgxULh+h/kpwqrGrjYR6qpmvkeuDdKqahT8gHVai+1RzoLKgWO1lyuev4kpIxZagpNr/LQh+IiNG0anTy5SX1wCl+PFjMllO2hj3rd9Op4IwRoSEIJRXkJyaxN5djdX1Wosna2ehlQq7h24JIZiOQnRGFxrGZn0UOYpkJijk9+gPSBQe5E1qiZwsY5gGX+0C8flrPLzqjORx1XXcdv5gYhXK+nMcHKp4ulBidbFgW+OE+ulzN/PLXUPrvXB17DwgH2uadyrv9nqC8cJ3qLZdxoZVy+k14DDPtBNMSGgYNRRg8FoYGWJiQO+OKLU92bHBy/riLVQY+rDFEFbffk+xjYF1RpbaAMMfaLbfeLOaCa51RBRvpyz0cgDKfT6uSAxH0zGddRs30vsC2Tu9r8xOfpUTFeDPWA+jn4OirZB8+i8cBQkSJMiZTNDIOhgpAL7DTEwOrNQu+Q/fVjqgHkMz/WoVVlwqL15LFgNcxaSsiSM/Yzv+zu1w0ZZqjJQTQoSQBwHkP4DAgaGD0hHGe4AHTDpS23/Qr99Dhd2DRbCRFYgmT4okwlaKuqaMKm1nRE0NYmgxAIlOucL6sMkXUlVZTm/VyZVcTu/UlcKiTHbsgKerH2Xv2gm8TxeqMJITiKIKI4aAnZIaF7Ehp6/q3YGerPuVc4hvb2CvQ4VCVw2CH40mlq5d30EQFFRX5qJHVnIUxZNn1CprjZEuxr9oG/YVKsVwvuIipANK8lU7vdS4vEdluJxKPl+Vwxerc7llWBseHnvowpl1uN01XCnMpFiKoZNuGgDFVhe+g4pktUROliFEgw/w4kftrOJax1Y+MozigrghxKp0dIhRMvP6vi3iNTsRfL8pv0ntsCqHlzu/3MCcWweiFBvul7pivACRQgkqcwWCAG09bcguKDtZQ24WkymELHUVbqUXvd1GRIcOAIQVFaIQQ1GbhpOhbvAm7iy0MrBtM+GnPjdkLYW0kQAoVSpu+797ueql77nMFYoHiWpjGRbfLEKHt+Xmy56vl6Jeslv2WHdHRKcWILqz/BckSJAgQU4pQSPrYNLHwrSth96vP+AHsu05h2+rOyBMK3lQk7a6ygo8X+wEQGlUc+G903E77BhNBv7z8jJwwVWeR9Di4Yq+idx5Tpp8oLZBqpvIjocfg+YA+ebQ5MO3VR+QWGuIOmLb8t/yWRnozFme/6LCT39tJlvF8xCVHVAhS7hrVFGoR8u1KzQrXiN6wywY9yqEjzt03ycApSi/N42kwuTuDBoAgeGe11EqBHxI5FU6W4WRpSDAdcrfMUou5jpeQNLI95lOl4QgyBOviMgotg/NOekKzkqtLHOu8KkZuqIcte9b4hhGPnJuliDArOv7olae/nXQN9aq3fU8CmVB2/znENfOZHSanYJoIwmmZ4CmXjutSkH4UUjBHwmlWsSvkACBHL0NhdGE2Wan2innSZq0Kkakn55hPHKx5Pxm963PreL1P/c2Uvo80JMVk1TBeqEvaTUVKD0WRE1Nc92cNBQKBT2ektX/du1+nOzcLJLTXyYixUyfsSn8klcOuQ1G1oEqifV4XfBGd7AVwZTlECOrce4qqiGgjMAowacmN1atiXe3rOXqpCXExl5Yf/iSPbKR1R8lpnDziXuzQYIECRLkHxE0sg5GY5T/jga1HtRJR9dWpQNL47Z6dRg1vn0AeDwOdq6opNfoZAAidHCJ9yeihCqe8V3DfimiyfEAKNXNb28OUfUP2iqP2LbCllX7n4AXJd7YKPa63URV29BbO5MS8T2RKYCh1jB1VkJNoZzo3eHkGVmZe3aSu3MLmEAh2vAUf0cfUwrrQnvXDZ+XLulKcvjpuepfR52RpcLHa5YrGSTksLumPb30NlJT7kSjaahHFRYeydBxJ7/AslqnBSRyFZV0FwXwScRSVm9kSRL0SApFozy5IaP/FKfHz+5ieQLfI8lyxPaK0p0kUsw+tw7RbSYkok5Z8CD5douuxeo6SRpQomD5gA7sUafQP2Mpivx1ENZGzvU5DVi6t5S56/NIjzFxy9A2KEUF2wus9de2Od5enEH/NmEMTYuk2uGtN1TbCvm8X/kOWZsT+DbpAnrhR9ScPt7Q8vK/uct1H/mri7h//VfceOlFbAsJxZK5B5+gxKY0NjIY61FpIak/7F8L1nykqE4ICgU7Cq0k+BRUKCRKRQnJLvLT+lHszchjTjcvIToVLq+f1VlyOG5/lEQLRbDjR4jvDSGnRgwhSJAgQYLInP7LyWcwWq2e8Hv7AeBX+JkklJO0eDNWn5/0mBAeVn3FTcpfMWPH6jy91QUlAZZ070xiRCwqdxxICiLj22E2d61v82dWOn+Kd1Cye1XjsMsTTP7ufSRuk1f1f9KP5ZvRY5DCtfX7fX6J0Z1jiTJpD9XFaUFuhTxhd6PmnU5XM6n7f/AJEBrWhTZtphEff+oT3TV62ROYo4lncI85DBgwkz3expO9KvvpJ+JyMFvzq/EHJKLNmqPybqrPvpclhsGsjuxEqS+RkMjanKiKg5QFWzB8r91VEfwWkoFLUOEWdIx1rWXE0qtgxf8A2cB5a+FeNuRWttg5/wlZZXau+XgNP2wq4KUFu3ng2y0AfLshr1E7o6bxWp8kwQNzt+DxBdhZ1GCUWLAR5ykjyV0A1dV48aPSak78GzlKdLoEdMjf0S0aPfs3bUa7cT7X5H1FN6scFbC32IbX38yzb9xrcuRA+9FsW/wnM+69jeK1i0n0KQgPKOgoqrHEulEoAuyqTmDyjDXY3D7WZFXg8gaIRCAZiNj/B3x9Daz7+CS+8yBBggQJ0hxBI+sUolAoMBhkhSwlfuyKAF7g9++/pWtCKF/6zuZt3wQEJGrcp9/ENLF6LYvU9/Kg8ktQK+ikUXP2eRehcoWjVCkwhTY2WlLzUuhgPw+PywYFG0/aOJU6NSpnBOLey9hl609WUnv2Rcg1ZUYr1jBH/RTeP58+aeM5VgqtsoCCBAxc9RfD1v2FSrWckr1/NGm7d8921q9YRl5e9kkdo0Yvf+ZtvGEUaKOoVIeiPCgnbO76/SzdW3pSx/VP2VhrmBxNEWIAZVJP1vW7iHuM/+V/uuvqtx8cLtgS+Vh1dOzWldXx3RhQ/gevSbfhCXip0UTXe+K/31jAq3/sYUXGqclbOvgz/m5DPrPX5PLjpoJG2zvEmDiYwmoXf+0uaaQsWKg2s7ZHCEXpHtrs16JCRH0aGFl/zvqGdU98T3Up3Ml/+aD4dS6uKUdriSLcFI1PUCLW5ud6/AEyS21NOzGEy9EDQMbalVTk76e6oop1Wh+rNF6q3D6eb/ctj/d/CaPKy8bcKm6YsZYal4+2YSr6o6RG6UAMTYbYHhB7aqXtg8iMGDGCadOmnephHJLJkydz4YUXnuphtBpmzpyJxWI51cMI0ooIGlmnGIVCA8jhQxO3/sl1i74l+9sv0LmtPOy7iZd9V1CN8bT0ZKW4dtBGUUQiJVyW9Q3nv/sIxio5pC22z8/sy34Np1POvXA4bGgkORclJFANu385aePUGvSIPgOaol60zcvhrF3rSaidu1kEO/0Vu7BnrWXx7pKTNqZjweqQDe3uQiZtsvfQJ2cXHk0Al7ARhyMH6QChlZzF24j+UWLXn2tP6hh1erk4a5oN3pGu5x31EyhDwhq1eXNRBrPX7j+p4/qnNBTGPXr5e51RT4xUSIzYUHT2RBQiPhCLGhKtuURRwm5dFP/tMg/OexFoUDE8VWqONc3U9nto3lbKD/CAA/V1dA6+Nt+uz2sUXpcWmYnVrKLMH8m5tgEoEWvDU08xDj8xrnD8TjMRlNGuWyQXPPww+QVhZKwJJzvpTpaGD6lv3mzI4AGMm3QRZ986jfXKFEpFiaU6HwXKAKYIBYmmAt642I9Jo2RNdgV/7S7huf4q7kdLjdYBw6bDrUug08mrixek9fLGG28wc+bMf3SMIAh8//33J2Q8pzuXX345e/bsOdXDCNKKCBpZp5iFs74BjxG/y0z36nRGt02g58gxGPSNw4qsrtPLk+UPSHzpGsQ1ngf5zHU2Me4SBL0Jk76GG18ZjDllEdnZb+Pzy7kX1VWyZ8CHH4PkgD0LTtpYNQZ58qb1a+lUWEHvnFKia6UaVwQ6cZfnDm4vOp+nf95x0sb0T3F6/HgDEgaczFM/zgtJcxk59nxGRIUT3nMhK1edjcfT4LEQXPLEVWE4uTkr4eFRZA2toaafhnhbBW0zsrhCubhJu9O9VladkdXzKPKx8Hup+uNdev61nWt/qObsHxpy4w42cFqiEHEdWVtKSN5uxaKUF2naBgqpPqCeXsIplnF3eJoaWQcLsfRMDGFPsezZuahn47DSv3aXsDqrod7Yjor2WKs7ULpLhSjIfWt1p4FQjbE23NEqCxI5XXI4ZGi0HkEQSVA2/g4e6J07kJqSQqQPzkL90VCMMeHUqBpELAQBREn+fvdIjmbmDX3pFGvmnlHtUWnU5IYUYYs8/RbigpzehISEnHTPjMfjOXKj07BvAJ1OF6wLFuQfETSyTjGGPJH0xW9h/eW/OMvDOOu6Wxh50+3oIuUvshovIdhOu2LElQ4PhVI4SwPdWKXsxnvJN1Id34a3PvsMW/Fu/H65Aq1eJ4tn1FTLr21Khyw9XLwNqnJPylh1Rtm7Ilj2cOXdnbh88ijMyiKUAS/7pWh+DAxmu5RCfpXztK1OX1cjK04op5hQSoQw/En96Xnl+SBIKBRq1OrI+vZKlzzxVhtP7kq/Tqdn6LixKCpDEfOjScmuYpR/aZN2p2v9JpA9Kx9e24enL+xCt4SQIx9QU4hl+YP0tb2HXbsVjU722AYCUhNjsiUl1cvyK7jQq6JY05EFjGW/KbHRcyLBcmo9WXa3/4hthqZFUuP2oVOJXD84Bc0BqpNev1SfhwhwScRGlrrPYlvCzZQMrES8O4X4xOQTMvZ/gj5GvkfUlRFUE8Jntk48szsXrUYO7zUf9OjeWdhY9EOSJL555lE+uPNm3IIeRDXWrHWc41DRxqtAIYGmVwi3OO5hE73QaKLpnRzGz3cOId6io9eAwQx96DJG3XL5SXm/p4qAx3/IP8kb+Adt/UdseyzY7XauvfZajEYjsbGxvPrqq432u91upk+fTnx8PAaDgf79+7N48WJAvgciIyOZO3duffsePXoQGxtb/3rZsmVoNBocDvk7IQgC7777Lueddx46nY42bdo0Oh5g69atnH322eh0OsLDw7nllluw2RrCVQ8OFxwxYgR33XUXDzzwAGFhYcTExPDEE0/U709JSQHgoosuQhCE+teH44knnqBHjx589NFHpKamotXKv0lVVVXcdNNNREZGYjabOfvss9m8eXOjY5955hmioqIwmUzcdNNNPPjgg/To0aPJ+J999lni4uJIT5dVSffv389ll12GxWIhLCyMCy64gOzs7PrjFi9eTL9+/TAYDFgsFgYPHkxOTg4Amzdv5qyzzsJkMmE2m+nduzfr1q0Dmg8XfPfdd2nbti1qtZr09HQ+++yzRvsFQeCjjz7ioosuQq/Xk5aWxo8//njE6xbkzCCoLniK8SnlB7ooQI5Z4L2sYnqGGYkP0XGFuIjnlB+zINCXO133IElSiymTHS8Hil4EjEpsfaNZWCEyauc6RIsXckCtjkIU5UllWV4hSWixaVzQ+TIwRIBwcmx8kykENyVUdfqM3J0BNi8bjC7PQZhhBCWahlUplzdAud1DhPHU53kcTGmtkbVXSqB/+MfoOqqI2JLD4xt2o0oArTahXr4dQO2Wv9oa06lRTNyx2c7muEsoMfyNw25psr/M5sbl9aNVnX4qg4Ig0CU+hC7xR2FgAfjc2LQpVNkdWDwKjAZ5wldqc+M5SOSgJcMFzeFGoJQiTS++EDrT1bKe+7f/Fz4qgwlvER+aCMhew1Px7GjOk3UgaqWCy/sm0THWTKnNTZhBw7mdY/hpc8FBLSXCVTXcV/o5qhI/73INezxmBl502Ykb/D8gMjEWqCS8Mol8NMz2j0fMK8X8+7eIjESq2MVFvnVk65PZGNKDHYXWRp+HIAhojSYQBPZFXkCnK2eyYn4xvTwldPaIvB3iQqGBUiGK8l2d0A2XF64UBxdO//sVWPcJ9LsJht53kq/Ciafg8RWH3KdNDyXi+i71rwufXtXE8KpDnRpC1K3d6l8XvbiGgL3xvZrwwtB/PL7777+fJUuW8MMPPxAVFcXDDz/Mhg0b6o2CqVOnsmPHDmbPnk1cXBzz5s1jzJgxbN26lbS0NIYNG8bixYu59NJLqaysZOfOneh0Onbt2kWHDh1YsmQJffv2RX9AlMtjjz3GCy+8wBtvvMFnn33GFVdcwdatW+nYsSN2u53Ro0czcOBA1q5dS0lJCTfddBNTp049bIjgrFmzuPfee1m9ejUrV65k8uTJDB48mFGjRrF27VqioqKYMWMGY8aMOeoajBkZGXz77bd899139cdMnDgRnU7Hr7/+SkhICO+//z7nnHMOe/bsISwsjC+++IJnn32Wd955h8GDBzN79mxeffVVUlNTG/W9cOFCzGYzf/wh5yZ7vd7697106VKUSiXPPPMMY8aMYcuWLSgUCi688EJuvvlmvvrqKzweD2vWrKn/Pk6aNImePXvy7rvvIooimzZtQqVqPiJk3rx53H333bz++uuMHDmSn3/+meuvv56EhATOOuus+nZPPvkkL730Ei+//DJvvfUWkyZNIicnh7CwsGb7DXLmEDSyTjF+pfxDoFJJbE11MiOniKsLA9zRtg3lkhmFIBElVOEPSDi9fvTq0+Mjq7DamSgupkAKZ7m3K5JaSVKnLvSpTmbz36sgBPS6hlVm565yIB5bvA8ufv+kjtVoNOMGFF49y9U9mTX0ZtILsmGdHMKYJuSRpixmrbct+ZXO09LImr+lsP7/cE85Vk88OmcRKrO8+qbTJjRqr/PK3hSDuamowIlm4+oVhCpUzGt3Dl8rR3PN8oWN9isVAr6AREGVkzaRR1ku4XQmIg3xjqVMWfEDCknFNZvlsK6DvXVqUUFkC95b5nADXkmiQ7WCjqatCNUeUtx7IC8DKrOIbdseQQC3L0CZzUOk6eTe1/YjeARGdYwmPlRXnzsGcHGv+CZG1mXtfyBSrGB2/liG64ooro7A7PfidXpR6U69hHtCchtKWIvZGc2wTl9w3vYSSnOzcAoSFpUCn8tGgqsACdgY0oMKu4eSGjfR5gYv85DLr+asa2/CGCaXu7Du3YMFyFT58Qtw1Y7tVElW0n0qRLHx5+j3++WJa84yqCloXJ8xyEnBZrPx8ccf8/nnn3POOecAsrGSkCA/l3Nzc5kxYwa5ubnExcUBMH36dBYsWMCMGTN47rnnGDFiBO+/L/82/v333/Ts2ZOYmBgWL15Mhw4dWLx4McOHD2903okTJ3LTTTcB8PTTT/PHH3/w1ltv8c477/Dll1/icrn49NNPMRjkaI7//e9/jB8/nhdffJHo6Ohm30u3bt34z3/+A0BaWhr/+9//WLhwIaNGjSIyUo6WsFgsxMTENHt8c3g8Hj799NP645ctW8aaNWsoKSlBo5Hv51deeYXvv/+euXPncsstt/DWW29x4403cv311wPw+OOP8/vvvzfyxAEYDAY++ugj1Gr5N+/zzz8nEAjw0Ucf1RtOM2bMwGKxsHjxYvr06UN1dTXnn38+bdu2BaBjx4aSF7m5udx///10qC0snpaWdsj39corrzB58mRuv/12AO69915WrVrFK6+80sjImjx5MldeeSUAzz33HG+++SZr1qxhzJgxR30Ng7ROTo8Z+78Yv0qipP1sdHF7aJt7NpUlXSnL3MqaxU6WBnrQ2/Uu5cix+Van77Qxshxl+3lZ9QFuScUA23/ptHAPN154Fjs3VRDeaTeRIaDTNxhZmhp59Sqy28kP79FotBSM9RMI6DAFajB4HWgDIeTU1th5SfUBPRUZ3OqfRn7V2XQ/SkW5k8mqfeX1/7fJ2M2g9Z9hS+9FbspGksJBq2tc08zolSeuJstRemNakl/K6OcOZ0B2DfpYJboug2FVw/i1KhGb20f+aWpkfbk6F38gwMhO0UddnFpj0LNVlYZb0HI1cu27g2tkxVm0Tb0Px4EhREuZBOdlJvD1vkyyfdG8b76UVyd2hLheqJUKokwaiq1u8qucJ93Icrgbewe6JYSwNb8aSZIN7SnD2zY5Zmi7CCJNmvqacBG6cs5JWoJS4ecvzUNc0H8I0a+vJ0FlZMnMHxl52yUn5b0cDp1OT7mmmih3KCW5xXw4qAeOjkkYr72Mr59fj9fdhu06P6v1cfXH7Ci0ElX7eQiCQGhsQz6aFJDQFrvRKarYo5bbxA89l0cHN17Br2PzU/NRBUR0V/yHdkPvkwvUn4HEPTXokPsO9tLGPjbgMG0bv475v37HNS6AzMxMPB4P/fv3r98WFhZWH762detW/H4/7du3b3Sc2+0mPFw2rIcPH87dd99NaWkpS5YsYcSIEfVG1o033siKFSt44IEHGh0/cODAJq83bdoEwM6dO+nevXu9gQUwePBgAoEAu3fvPqyRdSCxsbGUlByfKFRycnK9gQVySJ7NZqt/73U4nU4yMzMB2L17d73xUke/fv1YtGhRo21du3atN7Dq+s7IyMBkarzA6HK5yMzM5Nxzz2Xy5MmMHj2aUaNGMXLkSC677LL60Mx7772Xm266ic8++4yRI0cyceLEemPsYHbu3Mktt9zSaNvgwYN54403Gm078JoaDAbMZvNxX9MgrYPTY8b+L0ZSC7iNeaDex6WWLozYt4WMHetwxcXjUmhw0TAxsrq8xIScBmpagNXuYLG/OxKQ4CigV94yhB2xQBT6MHkl/0BP1pCHJ5K9by+dElPkDT437PpZLsAZ07VJ/yQNgPDaB1t1HuxbcujBJPSFyNofr5oiyGjsOVEA/UywvgYGBpZj2avAnz2MUlHH2eJGnJKanYEkvCjJ27ZcHhvI44qtfTg6K2HXYRQRozpCfC/5f3eNXBD0UES0h8S+8v9eJ2z77tBtw9pA8kBKa9zEUcaX6mcoCA9jdeByFF4nBpWcRK+rKIGspZA6FIfDhlaS7xuLJfzQfZ8gPKI8ub4lYRoKjY3CwGto8ONG/iFUifIs53TNy3r/70xyyh20jzYdtZHl9lQwldeoDIQR4jofaE6+vWVDN/VmNT6gTFHBefYtlDr8fKcZw6udz6tv886k3oTolCSFGQ7d0QnCcZAn69LeCTw6rhNrssoZkR5Fl/gQPl+VQ6RJw/D2kWhVIkpRwUU94/ng732AxIR2v7JT0RmhzE1o2FAWz/kMVUU5PeOvoibP0fyJTwGV4Q5cNR50UhxKnQ5zrSBHaIye8jwzhpj+VDsbcrF2FFhJce5n0Sfv0XnESAZc3JBPVZxdzSjtB3TW/8Fyzz3slXqSbM5i374fMJu7ExHRsELu9/sJ9ZhQSUoUloiGZ9AZiEJ99KHFJ6rtsWKz2RBFkfXr1zcJsTMa5YWmrl27EhYWxpIlS1iyZAnPPvssMTExvPjii6xduxav18ugQYc2NFuKg0PjBEEgcJx1LQ809EC+HrGxsfU5aQfyT4U4muu7d+/efPHFF03a1hl6M2bM4K677mLBggXMmTOHRx99lD/++IMBAwbwxBNPcNVVVzF//nx+/fVX/vOf/zB79mwuuuiifzSuAzkR1zRI6yBoZJ1qVAIKvzwhTh3Uh/4TLsZRVYUhLIxnn1zUKKfjdBK/yCaW173/B0CCaj+e6HS2bd+JRxtAa5YVwXS6xl6rlDYHuN0XPQ0r3jr0CS58t8HIKtoGP9x+6LZjX2kwssr2HLKtspMJIjSYXNE4/PEkijt5RSWHZ7zovZxFgV4kbvsNds+SDxjxUIORZS08/BgG3dUwwXGUH75t35sbjCy37fBte0yC5IFUO72co8ggRVFCslDKRkUPwsshWf8hNkR06+dClANSh6JQiGQNrsRrtTPCOPjQfZ8gvLV5hpJPQ++deVis17BQcT9/BXoCYNGrePPKnnSMNR+um1NCICBRWCULFsQfbf7Ub4/gXDuXUemO/2fvvMOjqrY+/J7pLZPee0JCL4HQexNUUIqgiCD2rlhQr35exYKVa/fasaHYUFQUBKRJDb0nISGk9zYzmT7z/XHCJIEEUEnxOu/z5Elmzj579jk5c85ee631W5Tp/JEKlwFnGpEXUlkQQKaQYne7KBFqqPX3wYdyrA5Xk1y3frHtFzp2upGlUcgYEB/AgPiA+u0O/u/7QwAceOIiVHIpbrebSV0NlBf+SL/QfaRph1BdHEC2LYibu+qpqqxEimjE2yQd53449m6xEHhxyY/s3TsXtf9IoqLm0W1oBDHdAik7UQIHG4yso0W1dDmRRnVJEYaKpvXEDu8sIRAZUsHBIOlh1shT2Wyt5GDZRsaF5Tcxsiory5C7ZbhwERLSvGfCS+uTmJiIXC5nx44dxMSIUQVVVVVkZGQwcuRIUlJScDqdlJaWMnx48/legiAwfPhwVqxYweHDhxk2bBgajQar1co777xDamrqGQbF9u3bmTt3bpPXKSnifbZr16589NFHmEwmz35btmxBIpF4PGx/BrlcjtP558RBTtG3b1+Ki4uRyWQtimd07tyZtLS0JseXlnbukiR9+/blyy+/JCQkBL2+5WdMSkoKKSkp/Otf/2Lw4MF8/vnnDBokekCTk5NJTk7m3nvvZdasWSxZsqRZI6tr165s2bKFa69tqI24ZcsWunXrds5xevln4DWy2hul1GNkHdmSRZl/GX3GRyMIAlqFlEnWDfSWZPG1cyS1ltR2HmwDFfVCDAAnYzqRJZPhV1dOUJURhel5BozToVCIkymb1YpCeVqo0sDboLZQ9Po0h0+DqhLaYEi6qOXB+DUKlVMHNNt2V00ItdKjwEnkODAXf8UgdyXrEvsgCBBEDc+EbSJFZwF1/f4BjUIEFNqzjyGoURiITH32tiFdGv6Wys/eNrQ7ZpsTq8PFVrqzy5nE5vDBrIzXMvKYgVhnJ0wGMz5B3T0Goar0AMN3zwG/WJDMarnvVsIhd2HHgQUndrkoxhEiVHu22xxuhicFt7B3+1JeL1YhEWiSM3NWCvcR4Cim0OmDy6ZDUi8nd6ay4IWXG7cLLkrD4Ivuowh0laNea6EuaxsqpQviR1zwz/sjmE4TvtCc5jEorDdmfZQy9CpxpdfhqKU8Zw6XJoj7yqywKPNlFG4HBUMGUpnSj+1WCdWCCZus4xhZp7BZy3i1KolV1f24aOO3PNs9ga5DUkly1xG3I4dAWyW7/fpypKiW/9w+l5gevdAHNxhHbrebE3vLyDNdxvvuQfwki0cTBP81dKI7U7lEVtTk8ypKStDhRq94FsXOi6HfdaDqeIsX/+vodDpuuOEGFixYQGBgICEhITz66KOiki7ipH327NnMnTuXxYsXk5KSQllZGevWraNXr15ceumlgKjud//995OamurxcI0YMYKlS5eyYMGCMz7366+/JjU1lWHDhrF06VJ27tzJBx98AIgCDo8//jjXXnstTzzxBGVlZdx1113MmTOnxVDB8yEuLo5169YxdOhQlEol/v5/fCFn3LhxDB48mClTpvDCCy+QnJxMYWEhK1euZOrUqaSmpnLXXXdx0003kZqaypAhQ/jyyy85cOAACQkJZ+179uzZvPjii1x++eU8+eSTREVFcfLkSZYvX86DDz6I3W7n3Xff5bLLLiMiIoL09HQyMzOZO3cuZrOZBQsWcMUVVxAfH09+fj5paWlMn958WPKCBQuYOXMmKSkpjBs3jh9//JHly5ezdu3aP3xOvPxv4jWy2pkh0yeSnb2L2lLIqrJwl185wsZKjo3qg59GwSWOHYyT7iXdHdNscc/24tQECcDRSc9PvqnM3ZuB0iolIEyPRiMqm+WdzMbyTha5oRWMunNGQ6iEbyRc8eH5fVhUP5j99fm1DevRbNu657/EV2Mjz7+CpUnDqPG3MmX1ZzxQdxNVCvEh8c2UwXSLa0Htxz/2/MfgE3r+bdV+52xbUCom+lbjwxX2hbhjgrBqlYwpcxF2RTM3c5/6B6ihWCxM1Maqci65GxlS3lTeySNJMYxz/cQPhSNO1dymuq51a5n8FU6F+IXpVcil56l+OeEZtq56hgx9Nf6mUHTB4uT/eGnTBO3z9oz9Acp713Ciuo4awR+5xEY34TABy64XFx7mHyS7zMjKA0X4qGTMayGnp7Wos57uyWpqZJ061xGNPHyfl9rZrPo3l1nW8Om+RCrLQ/hFPpAodzkpnfqw/bPlFPhLOeJwEiXza/Vj+KPI5KHoSAcgXyan8NgxIlNTSQpUMKnkFwTgqK4LOeXglCpJGtA0/MtssOMQwOAKZJVU9D50tVdjspaQrDiCStOjSfua8gr8hGL8JNvgtz2il9xLu/Diiy9iNBqZPHkyPj4+3H///dTUly4BMUTt6aef5v7776egoICgoCAGDRrEpEmTPG1GjhyJ0+lk1KhRnvdGjRrFihUrmrx3ioULF7Js2TJuv/12wsPD+eKLLzxeFI1Gw+rVq7nnnns8qoTTp0/nP//5z186zsWLF3Pffffx3nvvERkZ2UQa/XwRBIGff/6ZRx99lOuuu46ysjLCwsIYMWKExwCcPXs22dnZPPDAA1gsFmbOnMm8efPYuXPnWfvWaDRs2rSJhx56iGnTpmEwGIiMjGTs2LHo9XrMZjPHjh3j448/pqKigvDwcO644w5uueUWHA4HFRUVzJ07l5KSEoKCgpg2bRoLFy5s9rOmTJnCq6++yksvvcQ999xDfHw8S5YsafZ/5eWfidfIamc0Gh1KlShOoJSVU6OQgBt+W/YZUVJffnEOJN0dzWFXLF07ULjgdQWPsUCRz9P22WyqHEycn5pIZxwymxG/kIbck+NpB0lyBSA3S85b7rU1cCjc6IuGINcEsTs4HnzgcOJ1VDsVhFDFa4o3SPoOuHd7u42xJRrn9ghuF2O3rqAmJBJpbQ2Hfyyn++TJTdqv/XEnetlwUu2bkZirQNO2MrEuBQgIKJBRrgyEiFhk+Q5s9f9/k83Jsp25GK0Obhx+9lXJtqa5if85iejD6pTZvFMdxzjnYa53S8irrDsjJ6t7xIUXIRk3eyr/fm4Zi9z3IXdZect9C1ZtBEq/WHC7OVlZx+I1GXQJ82lzI+t0T5ZW2fRxU1h/fk4Zn1V2Bw9n5OOmO//Xbxp527ZS7LRwj/MOrhscTT+JgEomQ2PT4eNW45B2nJwGm9XK/ud+QS81MHHIT1xsX4P95BWEjBpFQUYV8kI4qYnHIFUjwYnLDeklBvpE++FyuSk5UUtYgh6NXkHtqCA++S0LR/2iRJxOz7Wmx6mQV6BSjmvyuXWVBlxuPRmqK0keEAOK9inZ4EX0Zn366adN6iQ19j7JFfKnZQABAABJREFU5XIWLlzY4oQdxNpYp9dqnD9/PvPnz2+2fUREBL/++muL/fXs2fMMoYjGnC7l3lyO1Pfff9/k9eTJk5l82jPnbDzxxBNNam2dwsfHh9dee43XXnutxX0fe+wxHnvsMc/r8ePH06lTJ8/rlqTow8LC+Pjjj5vdptfr+e6775rdplAo+OKLL1ocz7x585g3b16T92677TZuu+22FvdprvZmdXV1i+29/G/hNbI6ANL6FUstJq5I24DeUMGejH0E9ZnOt64RUD+XuKgDebKiHbnESgqQO23cs/olJAoVflH34go+Rrn5O2SFI4mIuAJplujxciYqztFj6+JSgLqkE9b0aobUHERXJyVAEYXbYsCEikGSo1AD3249wsWpyR1GxRGgoKqOKKGUwZIjHLTHEZhXTILdiitAQk3dbiyWfqhUonLZ8YwjJB8JRcJD5GjySKgtbHMjy60QZ4fzbCuZJ3uF5L7z+X5303DRh5cfRCoRmDckDtn5eozagNMn/ueLSuIgzF2Ev8JEZEJvdpyobLLdXyMnKaR1lBS1gpJYToIEStGz+dINjOsmrgZH1x/H6aGLrY3b7W4mJ+s0T1bVKYNW5dnnkYRwtlUbCdUq+ezGAXy9K59gHyWzBsTgdrnw8ZHQJTOCnvooMuUFbXMw54FCqUThlKG2haLGAjILEx68G5lMx+cLd1BVZKI6dhqbLaJYx+DK7exaVUPY2HGsfj8TY6WVmY/0JzjGh5wKE8b6r8QUye88WfkVPiXl7O2hR6lsGublrLbiIpzcwLEkj/nfLkbs5Z9FXV0db7/9NhMmTEAqlfLFF1+wdu1aTz0sL17+DnSc2c0/lMyMw2Rvy8DtkiN1KelyoidT+vehz0WXIPcLatK2owhfuFxubrTdz1zbQ+TaxTFKtHom3RDK8DlOqmp/pqp6G7W11cRUiZOCxP7NKAi2JSpx4i+TKxmelcmA4nLU/uLE34SaO213McuxkId/yCSnvOOolgFc3COMUZL9vCh/l0eUX/BV5HRGDxjOoLgqzMGfkpH5tKdt7soDSJCQodtHgitHDBlsYyL6d+LEcAPhARqCbZVEHVjBw7LPm7SRSwWcLjdFNZYWemkfTk38z1ukwlQBR39k5rEibl1TSacfwlG5w9nRSHIfYGB84AWVbz/F8T2FXFRS63mtF2qpaXSfOOWRM1gdTd5vbawOF05X0xVcraIFT5af6H3J2HsZQyru5f0kKWqphE6la/jXyBBuHJ6AVinDZrGQtn0Hgl0Mx3O1f4msJlTrTEicanCLi2ZmSz4A0V3FcOTOiANWOS30rdlHzdrP+en7wxgrrchUUqpLxftOdpnJ0+cWV3eKw0Zh1Eip9JejVDatTSTzV3HCtwhlRNvXw/PiBaB79+7odLpmf5pT+DtfToUUjhgxgn79+vHjjz/y7bffMm7cuHPv7MVLB6HjLNf/QzFW19L5wEyK1GPJLPVDcLvpOuxSfAJUbFpxCE6KQg2hQhW1lphzd9gGVNbZyHSGkUkYKOHNuJu5Tr6T1z/7jMkXiYnZanUch3amEYOKYlUFqXHNKyq1GSopDkUNmogSrr15AmpFL15bsoKetQUc1PfgJ9dgfJVy7A47BdVmukV0nOTxarODKrcP211d2Up3AjUKlN0H4C8coLCooRBxxtFDJJdE4sJFbOhuKEAsTtrGdO/dD3rDTx+uQiEk4n9yDddLZTzvuAp3/bpOoFZJca2Fgmoz0QEdJ8TprrFJTO4dcf4FqYv2wZfXoHf5U6ych1YWjkItO8OTNTChdbyJJ3/bzXhlCN+6x2ATlMgVTqobGVMahYwArYJKk438qjp81W1TN83cTCFijbKpJyu/usGTZbWWYDJlAAIKRSBUZsM314NMBfceAm0QbpeLTv0HY6kzI1wfQ095pzM+oz2xBQCVYLKG8YsqlZWZ5TwRWkh01wAO/JaPv8EJMtA5DOzX90TttBB13EkQEr6XmunpJyXR5SanosHIKsOfqVE3Ioubzv3CC+K5cTlhyyvQ/0ZGDU2GHvkQ2/rS3l46Fs2FobUHP//8M3Z78ws4f0VgQ61WewUkvPzt8RpZ7YxSpULAgcIpQ+Or4KDMybu5pUxUBKNXyQmgll1KMd53vnl1O49WpLiR98Gpl2PtF8Yv1YOZcHgHLqk4udSoYzEfrQAiqY5pf6EDmVqOxTcbIeoz9mdlIPd/BsOBXxliMHDQpzsIAqccDQVVHcuTVWawstI1iJW2QTiDVdj7BnLTkZO8GXoCAJVaFBkpWHmIJCLJDC9kbIhONLJqi87Sc+uypqQnecGpqAQrNSY1cqkTW72R5aeRi0ZWB6uVFaRTnr+BBaIKZuwwajOzUTssBKCisLKc3Mqm19DA+NapV+bWgH+5hveF23ALEqLV+0nI+gSO/Q5950LfOUT6qak02SioMrdKXlhznJ6PBZwRgvvvSd3IqTDRL9af4sp1HKUbfbRyZDIfMGdAeG/QBok/gEqno67WSpXVjuHgEbpcfPEZn9GeKEN1cByw+PKdeiZUQ+SXr3PXE08hkQq4TE4utq2nk+kYmwKGcNBvGH0MEly4yZY6eebno7w3NxWLvSHXzC1AhVyJW4ggQXYjgiCFXx6Ene9A5lpRUXTH29D3Wris5dwWL15ai9jY2HM38uLlH4rXyGpnVBoNYETplKPzU7IzspaMqkqc+0rxlaqpxAdb/b9JMHaMCuHGvEPMkG7gmCuGfdIuuBVSAqMTSSmNwGBcDQIolVFEFIv1X0J6x7XreAGkKgUSh5j7sdzSj6/zakkdfAkhW/YgdTsJEWoY6DpJvqChoLptBQLOxX83HPf8HW8+QUGdCo25DpstBwTRk3XkwF6SyiNx4iJhcj8wSkGQiBPVNqa8vISc9AxqfCPYmhhJJbcwdNdObH4N8V26ehGE08Uh/naEdsNx7Y/c9Nu3qB1OXtjux970o3ikFAFftZwuYa0TziVoJEiR0N+cSbXgwOCSoTQVQelOsUg3YujjwYKaNj3Xp+djAajlTT1ZPSJ96REpGn1fnMzhaeEpIqwm9gBE9oObN4CtqUJjqcVGlUZNdWlVK438z+MfGQJYiNo3h2lj7Zw8kYVFKkGhkhGW4EthZjUKeRAuBHwcJhIc4oJDvtSFVQKHC2v55VDT8F5fiZNrN6+kUKGizy03iG+mXAOHl+PqfyOusmPI9FGQOKaNj9aLFy9evJwLr5HVzqg1Gky6PKqSvqJz92TiNybjlNWRfTSNLgU5EDiTQdY3qEZHb0f7FRZtjDxnPS/K3+VH5yBeKpSQsOEQF/UaSP6xGjp3LwdAIgmhIPE4ktoqhvdqvsZEW9KpTw9ytKXgBG3dSTRuCxJ7FHm+vjglLi6R7uAxPuMn2SBWVo1q7+F6cLrcbMxoKFbaNfswkzLXYIrvgjW0EKkM1OpoSlfvRk8Ex6OKGJswEkiGXjPbZczZh48S8YuUEQFaik/UMjwmkSxHNOQ0TJhPFcvtSJ4sk9XBa79lEumn5pqBseedQ1VUV80RaRISiRONrZo8Ux3Q4A3rHxfQKvlYADKdeB7//VsoVwuVIMDWyDEMmXkxhIpy31HtIH5hsjb1ZKnlUqRnOQdFxlz83FX00jaqTSYIoGxqnCYp9JQbkqjJcHFw7y56pnSc2oFRcfGYOEqIzZ9ne8QhJEWimzMDEPOyCjOr6Z84jI3+QzFYBfrm2AE32fIGz1XjBRWA6FB/7r/7sSbvEd4L7t5HebUB89IgqhW96JE8gfbTbvXixYsXL83hNbLaGY1Wh1FqwRx8EHdtNbfrelBTnMX+4wfFquoBLqoFcaJh6CDCF3l2XwzO3uxzJdKlNoPk4iw0vsEYtWKMuEymR6+PZNz17TPJb47wiGh8/UaxbfuTjBF+RbUtEN/KnuyQ6MjERZY7gn2uBE66QzqUd6XMYCXcXcYPyv/jhDuc+/R3kmyJRemuQCoTJ7ISaTDOSBnHtAV0vnRAO48YFGoVYKeHZh2xcZ+jlIzA4HM9vhipQVTYk0vFCXd+dccJzSyoNvPOxmz0KhlzB8ede4fc7RCRgtpVwf3uRZicAchds8msttDYyBrUSvlYAApfUbXzhDyTecZdHLf6cdg1Hbo1XAfzhsZxZf/oVqnT1RKne7K0p+Vj5VbUse5YCUkhPgyMU9Dbspw3+JZ+XbdA+iroNA6kTR9Px9O2k5Wzm/6BnYhyRnD8ZBGktPqhnDf+AUEc9CvCrnHRy5VEcESEZ1tU1wB2/HACRwW8u2AYuOHbF3dTYqwlS95wrsqNTUOr44O0lJT+gtF4jMDAEfj59gMgr7iUrK/S6EQEICCVt696qxcvXrx4OROvkdXOaDQ6BKe4eutwmBh67VzcLhf9S2dwoAr4eK+nbVuqg52NXxjMartY36iLJp0kfwXZJTlo/OzglqBWxyK0cQHc80EmEyf4UpmDgSF9OV6iIkDqRuays4E+bLD1ASCwA3lXCqrriBTKCRQMGNwa7LJgVEQTrhLlqxWKYNQqX8Ze3Yy30GoAYykEJrbpmFUaNWBHWn9dx2Tu4bmC5STILmWRYzYghgt+cv0A4gK1bTq2s+FRFvQ/DyEOUwV8PBkUOpj5H/qyG4vFjwrhMgpNTb+nrZWPBaD0UQIuMhUl2ILC0OdVkXvafSLqfI7nAnO6J+v0fKy9eVUs/PEIA+MD6DLdArjRqOPwLzgEX1wJId3h1t9B0iCAazbUYrNbkdXfW2TKDiYvCIx4eCbV1bvIyn6AvNJ4Ond5Aq1USkisnsvn9yEs0Ve8NwpwxUOpHDpewYvvtVybTxms4r2TeQQbVjNRqkWp6MqWb34m4UgAndwR2AUHtYO8PiwvXrx46Yh4jax2Ri6X43CJkwanw8wv7xxEo1cwclZn/OzVAPQSspgm3UyRLRgY336DrSe/kRFyuFMf4hQBaGtLCKoKJES2huTeOkpKRFW7oKDQdi1CfAqzuY5dG7dC/YJvp4E9yNz1G/F1vzBJGcT34ZcBcMfoRIZ2CjpLT21LfpWZ/e5EJlqfQ4MFY2c9y+VyJpljGNXlOVzuFgxvYxm81AkQ4LEykLbdhFSpUQO1FLkMqIFal+itCnY35NGY7U5GJAe32ZjOhwKPpLjqHC2ByizQBoM2mAqDGM5psYveK6u74Xr3UcpaValSqVYBdewcFE26KopuJ/ZSW2WFvDSozYcuk9r0f38Ks/0cNbKqG6TypVIJgYGj0Wjioa4CNIGQMLKJgQWQ0G8AgWF9qVFICMGFTNUxvTdOl4XnqvuxWRjN1G3LeLhbPLFDhhDV5UyPZo9OgfSO9mV/fk2zfZ3M3c9S2QAmUsplihB2vfITXWrCAcjyLyR2Rl+GJyS16vF48eLFi5c/h7dOVgdAf6MoTuDGzKbcMm7yMzJy0170anFyFC2UMU/2KxcJO7HYz0wob2vKDFbP3454Hd9364NTkYjKEozWV4tSEcTBbzdhfzmL9cuar6ze1litZuI3+CE4ZbiBF9x1LB3fBbNKhn+9MQvQK8qPIYkdx8gqrLZgRcExdwwHnPFYggQOxypx+vgTETGDqMiryc/PIfv4MUwmQ8OOmkCQyAA3GEvadMwaregxLFSEcSOfcF38f3j12BBeNUzytDldfa8jUFj9B2pkRQ+A+Qfhqs9Jt9k4Qnek1iT0bjVWd8NttX98wFlzkf4q/kHB7A/Oo1aiokoIxKjSUFVnh48uga/nQW0hTpebN37L5F/LDzQrrd4amKynhws2XyMrwk/NN8YEHrAtYKf2Vuh9Jdx7BEY+eEafcrmCHH8JmzUHceBCofoDKpBtiFTihxYx/zBHLiP/yNEm291uN/ZG52d6v6gW+/KrraKfI40EjmM2y4mvCceJi7zxVoYvmEGc18Dq0IwaNYr58+e39zBaZN68eUyZMqW9h/G34aOPPsLPz6+9h+Hlb4TXyOoAhIU1PCglymJqVVLy6qwc//lL4upOctAdz38dk/nYMYFaSzuHDNrqWGe7hlWKh1C5zSgqTKQolYSbI1DYAtDU54jIDeLEUunfMcLBdDpRxSzk2BzC/e5la7WZk2E6zCGz+C5CDGF7QfYOQ38aDdkb2nGkTSlolLPkZ69hzI4VjDiwFUfmzxz8/nsAjv28A8X7ZWz7+peGHSUS0NUXLm1jGXdtvZHVyRqAWdBSLAvFv88IzJIGD1FORR0/HyjilbUZ5JSbWuqqTSloNPE/LyRS8I3kO2cczwhPslUxFDkybI08WQPjWy8fCyAiMob4WZPoXrmVZ9wPEGvOotLswB3ZD6IHgdOGRIB3Nmbzxc68JtdTa1JnOz1c8DRPlic0U82WagOHjGaq7fX7yFWgbhD5yT92mKqiAhxmMyqLDB+XBhmS+ty/jsXhA3sofTmD6XzFB65ruKXgOOHJ4v3d6XCx+asM3rptPe/es5FV7x4EYHKvCE+O4uk8fulE7pMsZiibkctDOdapkMyYIgaPHYdE4n18e/lrvPrqq3z00Ud/aB9BEPi+/tnzT+PKK68kIyOjvYfh5W+EN1ywAyCRyJHJ9DgctYRZjUxP20igsZID6buJ9enBRs1wnnfMAuBus4OQ1lGDPi8sFbn4CGYiKUdtr+OmXz9Cud0Pte8t+A/4gKKq7/ANW4DOLE6A9MEdQxFRJpNRJ7HgVzCS/ONF9C4/gNQpIcASh6/cQjUugoVqdOZC0vbuQSHvQ+9ov/YeNoXVFiZLtiLFxTEhDN+CcuIdDtTRBqqMJhyOsUgNouCI/HTjQB8uhowZ2tbIUqu1VANRJjXPu+/BX+Jk0O1r+feidZ42NoeLdzZlsT+/hoRgHXFB7W+MezxZ5xKIqDoJ/g21YfwkVsIpQqcy81/1UQzmhjDIgQmtl491ikCdAo3FSBwnMJulbHIMpmLmCk+9LwHxmI4VG8irMtOpDW4gp3uyTjeyCqvFWnvBWhsLo5VMCYmlt+5Mo8lUXcWP/3kWu9XKFY8+Sae6YPq4uiKRCCg7oCcrODQcq60GDXUgwEULbkcuF++BUpmEnAPlnrbuelFBf62CMV1CWH24qcc5QKsgLD6QjHxxYS0iogfRN3YcNUUvf398fdumbl5jbDYbCkXrhPq2Zt8gFkhWq9tOQOjP4HQ6EQShzRdhWvvc/13xLoV1ANZ/swJ7nRwBJb4KOd2yezJ95Hj6TLiUEl3TUBJDO3uyiiRhjLW+yHW2BWid4qRUrvVhyi1hBCQcpLL6ZxwOG/5WcSIXGB7WnsNtglkqhjkq/P0ZnJPBoMJiHBFKDBLRSHnZcQXztc9xQ1rkGfVq2otXr+rD3bLveEXxFoEqM19FTmfYwBH06LwXe8Tn1BoOoa4Tw0o1Qac9MH3qz30bG1lSqZTjA6ooShGIIh+tq4igPS/zsvJdgqn2tDsVQpbfQYo/e7wrZ/Nk1VXCG6nwzggwizlmL/a8lEd3VqD7NZTK8his9Yl/WoWUHq2Yj3WKymPl9LCLoaIBShN+9hoqTU1V6k7JuOe3kajL6Z4sbSPhC7fb7fEayq3rOL5rFF2qXyb+h+vhv0Mhe2OTtgGRUeiDggmOS6BXigtBIvatUre9oMe5CAoOpU6wI7GLiwY2W0WT7Y3zsmJ7Nhjg0/ueGTIYF6TFaBa/u3K5P1Jpx/PctSU2mw2bzYbb7fa853A4sNlsOByOZtu6XA3y+E6nE5vNht1uP2fbP4PJZGLu3LnodDrCw8NZvHhxk+1Wq5UHHniAyMhItFotAwcOZMOGDYB4nQcHB/PNN9942vfp04fw8HDP699//x2lUkldnXi/FASB//73v1x88cWo1WoSEhKa7A9w8OBBxowZg1qtJjAwkJtvvhmjsaGUxunhgqNGjeLuu+/mwQcfJCAggLCwMJ544gnP9ri4OACmTp2KIAie12fjiSeeoE+fPrz//vvEx8ejUonXcXV1NTfeeCPBwcHo9XrGjBnD/v37m+z79NNPExISgo+PDzfeeCMPP/wwffr0OWP8zzzzDBEREXTu3BmAvLw8Zs6ciZ+fHwEBAVx++eXk5OR49tuwYQMDBgxAq9Xi5+fH0KFDOXnyJAD79+9n9OjR+Pj4oNfr6devH7t27QKaDxf873//S2JiIgqFgs6dO/Ppp5822S4IAu+//z5Tp05Fo9GQlJTEDz/8cM7zdmqcgiCwcuVKevXqhUqlYtCgQRw6dMjT5tSYfvjhB7p164ZSqSQ3N/es1xvAyZMnmTx5Mv7+/mi1Wrp3787PP//s2X7o0CEuvvhidDodoaGhzJkzh/LyhkWiUaNGceeddzJ//nyCgoKYMGECV199NVdeeWWTY7Db7QQFBfHJJ58A4HK5ePbZZ4mPj0etVtO7d+8zrtv/JbxGVgdAkmUheeNzKGz/QS50A8A/vCtjr7+NyuAuAEhxEisUY6kqbM+hUmx0kuWOZJe7C/nqKD7ufDtVaj/e/OJjnC4x7MtocKFwy3HiJDQ0sl3H2xirzI5Fl4tdk8GNC+/mjmf/hSLWTKfanSQZMzngTuSYvDu16DhZ0TFC2AwWB9tdXdnq7MZJIYxwtQJp58FI1eIkWqUMw9ciTuj8Qk7zmvjUS0i3sZEFMGraZXRN6oOlPBFTUU+EvUuZKmwgRmhYrVfKxNtPRwkX/Pb2IXxz62A6n61wcH4aom9I8IS07Vu9kkPm49T6H8MqNEzU+sUFIJO2/i1WtTwTgzKGzYwkW5uESaqh4jQp8Nh6Fce2Otem08MFG0m411ocGOvVBxWunQBoNYmQtwNKDoGiwaup8w9gxmPPcMX/PY1coST5uttQ3ZmI9fogQsM6zr3lFBKJhHJtDQZ7BN9wJc9mlVOTl+fZHpHk5/k7tkfD93VU5xACtE1XgbtU7aP7rjoe4zmUylBysjOprCj7y8bA35VFixaxaNEij5EBsHXrVhYtWtRkcgjw4osvsmjRImpqGgRFdu7cyaJFi86Y4L7yyissWrSoyQTyz7BgwQI2btzIihUr+PXXX9mwYQN79uzxbL/zzjvZtm0by5Yt48CBA8yYMYOJEyeSmZmJIAiMGDHCMwmuqqri6NGjmM1mjh07BsDGjRvp378/Gk3D4sJjjz3G9OnT2b9/P7Nnz+aqq67i6FExB9BkMjFhwgT8/f1JS0vj66+/Zu3atdx5551nPY6PP/4YrVbLjh07eOGFF3jyySdZs2YNAGlpaQAsWbKEoqIiz+tzcfz4cb799luWL1/Ovn37AJgxYwalpaX88ssv7N69m759+zJ27FgqKysBWLp0Kc888wzPP/88u3fvJiYmhv/+979n9L1u3TrS09NZs2YNP/30E3a7nQkTJuDj48PmzZvZsmULOp2OiRMnegzyKVOmMHLkSA4cOMC2bdu4+eabPYrIs2fPJioqirS0NHbv3s3DDz+MXN68eNB3333HPffcw/3338+hQ4e45ZZbuO6661i/fn2TdgsXLmTmzJkcOHCASy65hNmzZ3uO83xYsGABixcvJi0tjeDgYCZPntxksaCuro7nn3+e999/n8OHDxMSEnLW6w3gjjvuwGq1smnTJg4ePMjzzz+PTieG+ldXVzNmzBhSUlLYtWsXq1atoqSkhJkzm5bl+fjjj1EoFGzZsoW3336b2bNn8+OPPzYx5FevXk1dXR1Tp04F4Nlnn+WTTz7h7bff5vDhw9x7771cc801bNy4kf9FvOGCHQCn3I3ELcdhMaH1U7INGxXlVVxr1qFXyyk1WHlG9gFXyTaQfvRO6P1Mu421sFENKZevnIrUIL6rHsHUDPEmLAgKyktq8QeqFAZiW7g5tQc2uYOKhO8wWveSVx6MxW8SRnM5A6t3ka2JJVOXhN0pTmBOdJCJf6XJxmOO6wFw+SmwDQzmxpw8XtOJ47PbFfg4xUnpGZNOff0qaBvnZJ3CXFPDVyXTqFbrUZV+gKpOQ4mmIXzU6RJXpHPKO4YnK9xXTbjvOUJBkifAfUfA0ODprCgqQGYyIJP5E6ywckrCMqWNwk2tEgcn1X34WOhBD789GOR6hBMbYf1/ISgZprzpCcdsq8WDutOFLxp5stRyKctvH0JprYVfqzbhZiTxqu5w6xbc+Wns2ZONadMhRlw9DwCJRIrOP4CsDRtY/csvBKrUXLnwiTY5jj+DVePEYQviO+1M5GV2Apa+wX3PPw9AfO8gQuP1BEbq0Po2hDsqZBKu6BfFu5uyPe9VKJ24BAkyexjdui3myH8OIqsL5sRl0G/I8DY/Li8tYzQa+eCDD/jss88YO3YsIE5Ao6JED2Vubi5LliwhNzeXiPr6aQ888ACrVq1iyZIlLFq0iFGjRvHOO+8AsGnTJlJSUggLC2PDhg106dKFDRs2MHLkyCafO2PGDG688UYAnnrqKdasWcPrr7/OW2+9xeeff47FYuGTTz5BqxW//2+88QaTJ0/m+eefJzQ0tNlj6dWrF48//jgASUlJvPHGG6xbt47x48cTHCyGQvv5+REWdv5RKjabjU8++cSz/++//87OnTspLS1FqRS/By+99BLff/8933zzDTfffDOvv/46N9xwA9dddx0A//73v/n111+bTOABtFot77//vidU7bPPPsPlcvH+++97DKclS5bg5+fHhg0bSE1NpaamhkmTJpGYKJY36dq1q6e/3NxcFixYQJcuXTznoCVeeukl5s2bx+233w7Afffdx/bt23nppZcYPXq0p928efOYNUtM+Vi0aBGvvfYaO3fuZOLEied1/h5//HHGjxeVpU9dV999953H6LHb7bz11lv07t3bcwznut5yc3OZPn06PXv2BCAhIcHzeW+88QYpKSksWrTI896HH35IdHQ0GRkZJCcne87NCy+84GmTmJiIVqvlu+++Y86cOQB8/vnnXHbZZfj4+GC1Wlm0aBFr165l8ODBns/9/fffeeedd864vv8XuOBGVlxcnMft2pjbb7+dN998E4vFwv3338+yZcuwWq1MmDCBt956q8Uv/D8Bd/0CpsvqQOunZHOUkSKnkdhd+wiQ2sDt4qQ7DItbjs1iPHtnrYwk/UdmSLPZ5urOSWUUTpkE37BYelQPAlagUARiKK/CHxUGdcepNwXgUDhROsRQhTU1cp46nkGX6ET6aJLI0MaixkJf835SpZX8UDEOt9vdrvW+cspNPLOyQZmsn2E/B0yD0VmtoANBkFNebkAJ1EnMROn9mnYQ2Q/6XQcxg9p03ACZxw5RWVNOemhncoL98csdSq+SvRTGBoqOIEQvHUBOB/EanjfaIPEHOGGs4YnOCQTH6XljYwxWmZsvEfONYgLaJpzNKrURb5DR3TcDaX2YoKnODPk7wSae27hAcSxttXhwejHixnWyFDIJfWP8cbudPLphGAVCNAMdfiQEh1Mo6cSGpaKyYOdBwwhN6OTZr6awgFK1GrvZhsvpQtIGXsI/g0sr0GP3zYzuU0qtsRJLoxIWCpWMKx5qPq/qvvHJZJeZ2JFdwYQeYYzIPkzShhWMmDULjTqRILNYGy8oIrzZ/f/XeeSRRwCaeBWGDBnCoEGDzsg/WbBgASDm4p5iwIAB9OvX74x7+in1v8Zt/yhZWVnYbDYGDhzoeS8gIMATvnbw4EGcTqdncnoKq9VKYKDo0Rw5ciT33HMPZWVlbNy4kVGjRnmMrBtuuIGtW7fy4INNVTdPTVQbvz7lKTp69Ci9e/f2GFgAQ4cOxeVykZ6eflYjqzHh4eGUlpb+gbNxJrGxsR4DC8SQPKPR6Dn2U5jNZrKysgBIT0/3GC+nGDBgAL/99luT93r27NkkF2j//v0cP34cH5+mEQkWi4WsrCwuuugi5s2bx4QJExg/fjzjxo1j5syZntDM++67jxtvvJFPP/2UcePGMWPGDI8xdjpHjx7l5ptvbvLe0KFDefXVV5u81/icarVa9Hr9Hzqnjf/Pp66rUx5LAIVC0eQzzud6u/vuu7ntttv49ddfGTduHNOnT/f0sX//ftavX+/xbDUmKyvL02+/fv2abJPJZMycOZOlS5cyZ84cTCYTK1asYNmyZYDo0ayrq/MYjKew2WykpHSgyvIXkAtuZKWlpeF0NjxgDx06xPjx45kxYwYA9957LytXruTrr7/G19eXO++8k2nTprFly5YLPZS/DW45GEJ34tL9RqeB00lco0Bj9+Pg4e0MTN9HZuSVfCBczNvOSdwQlEjPdhxr99zPmSo/wN22OwnIKiLO5sOATv0pLywgOhEUikB8/EI4lpyO7HzqDbUhAaMTqK5VgRvsx7ah1YXhKreSpJzMLxozvlTxouN5HDIJ31hHUFJrJcy3/Y7heKmRbdnlnLJKeubsZ8jJbdAnAgLFc11TVkEIUK1sZvIcP0L8aQeKvz9CfHU4A+Il+BlNjBlxMT4TZ+Nakelpc6oUQKnBisnqOEPmuy1Jy6lk7dESUmMDGN+thQUfUwVom04KcozlnCAKs0KC4JZhFyxQnzJyTgGNC4RVamfS8Uj89tn4t0qGv6uKTHkyY2d8DAHxAJ6iz3lVZpwud6vKykMz4YKnCV8AWK2l9HLvI0gop5vvVQBEdulGv0unEBARRUh804lNVIwvATu7EimTs/6L7xl7zbTWO4C/gOAjR+MUuKG4nEEzxqC5dua5dwJUcinvX5vaaHGnt2dbUVEeSrcCJ07CI6NbaeQdm+aS6lsyjJprK5VKm63Z2BbJ+kajEalUyu7du88Yw6mJbM+ePQkICGDjxo1s3LiRZ555hrCwMJ5//nnS0tKw2+0MGTKk1cd6emicIAh/OUS1saEH4vkIDw9vkiN0ij8qkd5c3/369WPp0qVntD1l6C1ZsoS7776bVatW8eWXX/J///d/rFmzhkGDBvHEE09w9dVXs3LlSn755Rcef/xxli1b5gl3+zO0xjltjFqtbrJ4cD7X24033siECRNYuXIlv/76K88++yyLFy/mrrvuwmg0ejyep9M4T/D0cw9iuOXIkSMpLS1lzZo1qNVqj8fulBdy5cqVREY2jbw55dH8X+OCz2oar1YAPPfccyQmJjJy5Ehqamr44IMP+PzzzxkzZgwgXuxdu3Zl+/btDBrU9ivuHQKFBLurAkF9DJPpMA+p+lBXmUeGsZJaQOc0UYWYMF1Q3b7eob1CV4qckOUOp1dtGkF7K/DTRlOtqgVAoQiia/fedO3e+xw9tT29+g3geNZGTp5cT1dbOnO2r0ZbFwx0JcAlUCzxZbcrCYM8CK3VQk6FqV2NrMIaM/Okq7lL9h1fO0fyq/84htmNKCSHAVDIAwkKCSO91z4kqo4V+euQiw+Qyb5vIAnZiU64A13oFUQIFRQieoEKa8z4aeRU19nJqTDRPaLtla5OsfNEJe9szKain615I6twL7w/HnrNhMvfhPoHWpysivvdL+Cy+SIwF5vg9BhZUW1kZNkUdiqtRqpUuVxfswW7sY5C2xPQfYqnTaSfmlXzhxMboG11Awua8WQ1ysn67VgJuRV1dA8u5ho+QqWMInZXBehCoOtkRs29sdk+fXw1+Ns0DFTJqT5maLZNR8A3Jpj00nwUcb7o/kBI1SkaT5Zy85Zgt1dTXRpLKMGUK2uIlf9vTkb+ziQmJiKXy9mxYwcxMTGAmFeVkZHByJEjSUlJwel0UlpayvDhzYd6CoLA8OHDWbFiBYcPH2bYsGFoNBqsVivvvPMOqampZ0xqt2/fzty5c5u8PuUR6Nq1Kx999BEmk8mz35YtW5BIJB4P259BLpc3WUj/M/Tt25fi4mJkMlmL4hmdO3cmLS2tyfGdTw5Y3759+fLLLwkJCUGvb1l4KCUlhZSUFP71r38xePBgPv/8c88cNDk5meTkZO69915mzZrFkiVLmjWyunbtypYtW7j22ms9723ZsoVu3bqdc5x/hO3bt59xXTUOcWzu2M51vQFER0dz6623cuutt/Kvf/2L9957j7vuuou+ffvy7bffEhcX94c9vEOGDCE6Opovv/ySX375hRkzZniMzMbCHP+LoYHN0aozM5vNxmeffcZ9992HIAjs3r0bu93OuHHjPG26dOlCTEwM27Zta9HIslqtWK0NBXBra2tbc9htjqCUIjWIrm2bvYL+9bGsqdVVLFqbQ96uBrGLklpLu4zxFK+4rqTIXj8GHzMX+1SSkX+UwKgScAsoFB2nkG9zyKTiKk5QXCizAgezd6+ailoHoXYbgr2M6Sykf4Q/taYqcspNDGoDCe6WKKgyEymUEygYkOLCKQ9H6VCQEOIE1iBXBBATl0hMXPOhDABYasX8oYB4kLZdfpyr/qMElximpi5Io/vGhbyjiGOyTYzzdrlh4WXd6BXlT3QbGSQtkX8uZcHMteCyg9PuMbAANK5S+rIbQ10Ia+UH6OaKASRIJQJh+rYx0B1yFxWCgRJdEVICcJvMVNY29WxKJAJdwlpf6fAUJmvL6oLf7ilg5YEi7hnhopcK1PIw3OueR3DaIG54kxpZjbGb6pAK9ap9UkezbToCqUOHU9FlEzk577A//RDJnRag/oOhjRWZmbzpVuEozWOg7Us05msJJRiDrn3v/16aR6fTccMNN7BgwQICAwMJCQnh0Ucf9YQxJicnM3v2bObOncvixYtJSUmhrKyMdevW0atXLy699FJAVGy7//77SU1N9XgcRowYwdKlSz0hkI35+uuvSU1NZdiwYSxdupSdO3fywQcfAKJH4fHHH+faa6/liSeeoKysjLvuuos5c+b8pfSMuLg41q1bx9ChQ1Eqlfj7//EyLePGjWPw4MFMmTKFF154geTkZAoLC1m5ciVTp04lNTWVu+66i5tuuonU1FSGDBnCl19+yYEDB5rkDjXH7NmzefHFF7n88st58skniYqK4uTJkyxfvpwHH3wQu93Ou+++y2WXXUZERATp6elkZmYyd+5czGYzCxYs4IorriA+Pp78/HzS0tKYPn16s5+1YMECZs6cSUpKCuPGjePHH39k+fLlrF279g+fk7Px5JNPEhgYSGhoKI8++ihBQUFnLSJ9Ptfb/Pnzufjii0lOTqaqqor169d7DLc77riD9957j1mzZnmUJo8fP86yZct4//33m/UIN+bqq6/m7bffJiMjo4kIiI+PDw888AD33nsvLpeLYcOGUVNTw5YtW9Dr9U2M1f8VWtXI+v7776murmbevHkAFBcXo1AoznAHh4aGUlzcsmT2s88+y8KFC1txpO2LRClDahNvqBZzBb+8fRCH3cXku3rjq2tQY7tbupzB5Seg+FUIa5+gwRpzg6LN/q6pJKuKkJeexFLQjYH9H6FTkj/pRw7iHxhEYFDIOb+MbUluThYnM/JABnIfOZ2HTKCkKoOyrEMMK/4QpyDl3Zjrmdw7gnvHJdM1vO0mpc1RUG1mqWMay53DMaDGmaRjuUbOFdp+XN7lOeSK8yh0+59uYDPAnbsgqOUE3gvNqTzDKqOJAKDEIl7HfjSd/KvlMuI7QI2sUx7iFo2skQsgaRwomsaoV1VtB8Bo1lMrmLEKdgYI2URqJchO1HscogeAsj4/oDIbKk+0PJCoVFDVe/SqTkLF8ZbbRqSAJgCX3E21r4wfUlNRCRYS12bQtWoX7DoMNfngHw+dL/bkkVFbBKVHWu43tAf41E/CjKVQfLDltiFdQV+vYmkqhyJRgrm7eT/BkoaFsehKM1QPBL9oj3hOFLXE+IxH7dZRHTyE2pwjlK34itThqRCYCP5x4s6WGgp/+47ffjsA0nGAD/YObGQBOBy1PFYzij21/blm/cfc1jmOxEaJ8Ofi7Y8/4a2x04HLGMgynBXidefwa5XherkAvPjii54wKx8fH+6///4m6oZLlizh6aef5v7776egoICgoCAGDRrEpEmTPG1GjhyJ0+lk1KhRnvdGjRrFihUrmrx3ioULF7Js2TJuv/12wsPD+eKLLzxeFI1Gw+rVq7nnnns8qoTTp0/nP//5z186zsWLF3Pffffx3nvvERkZ2UQa/XwRBIGff/6ZRx99lOuuu46ysjLCwsIYMWKExwCcPXs22dnZPPDAA1gsFmbOnMm8efPYuXPnWfvWaDRs2rSJhx56iGnTpmEwGIiMjGTs2LHo9XqPYuPHH39MRUUF4eHh3HHHHdxyyy04HA4qKiqYO3cuJSUlBAUFMW3atBbnn1OmTOHVV1/lpZde4p577iE+Pp4lS5Y0+7/6Kzz33HPcc889ZGZm0qdPH3788cdzhrme63pzOp3ccccd5Ofno9frmThxIi+//DIAERERbNmyhYceeoiLLroIq9VKbGwsEydOPK/6W7Nnz+aZZ54hNjaWoUOHNtn21FNPERwczLPPPkt2djZ+fn707dvXk3P5v4bgblx04gIzYcIEFAoFP/74IyCqjFx33XVNvFIgJjOOHj262fhPaN6TFR0dTU1NzVndwX8XamurKS9P40TOrSgU4Xz12yJ+SdWSohOYIPjxdL34wTLFUwySHIWp70LvK8/R64XH5XSS+OiqU9FQWIeH4tbImLs9k7BiNzNuG0dksh8nHl2P0q3AfVsk0bFnX3VqSzau+ImgnMMU93yXAP9h/OCziC15VaT+Wo5fzn+plipYGXoxz84bzSU9wpp4LNqDqW9tYW9uNQA6hxFJ/3BKQ/Q8ZNNw7wQx8fTIgb2oNGoio+NQKpvxnLyeChWZcO2PbZqftfbDr+iSEc5HnX/lw9gJhNlKufKj9ygI789Xyobk8H9d3IVbRp7FE9dGjPvPRo6XGll640CGdjo/b+zmyhqWH3yZVOcahN870dl8BQZFDaOEO5o2vG0bhNaHj2x4DjY823KnN/4GUfXJxFtegzWPtdy2/n+64bsfOJFTzr/69EXlNpO55WLkztNu67O+ZKsslR/2FdLdlcGcwze03O8VS6BHfb7T4e/h67OsLl7+JqRcI/6d8St8PqPlthe/CANvZuCitZTUWrk+ch2fdpnGrOKfGbRpDUdrQ+nrX8DosGwYtxCGzRf3K9jDsmde5FhIZ/S2QGa6+pCjL2bYI2f5rHamrGwztx/cxWZhNIOyDnGvrZaRpyXxt4TVYOCpxf9hb1IS2vBibhXegb3/Jrk0huMDqhg17bJWHn3rUltbi6+vb7PPb4vFwokTJ5rUU/LSPIIg8N13353Vo/G/xvjx4wkLCzujFtX/Khs2bGD06NFUVVX94Vw1L63HH7lPtZon6+TJk6xdu5bly5d73gsLC8Nms1FdXd3kgikpKTmrHKhSqfyfTYoD0Ov9kMs7cyIHHI4q3DIDRrWe9KoqJp7YSmpVJbv8+/GJYzw79KO5J7p/u4zTsOcr9ivvZbWzP49Y50GpgT49I4moCUNutaPVK6moKEXpVuDCRVgHq2Mj1yhR1yQgzZlMdK/L+X1PLgflahJ8BAL18/jCz8Vk6VaGr3wKskbDlLfadbyN5fKjzPkk7NpJZWQy5poqdpXHkDr7aszf5qK3BnDsihp6pw48sxN9uGhktbGMu1CfgxMo01Mn6DAobCQNG0elJRAalaM5VFDDq2szEQS4e2zbedoa43a7PYWII85WiPg0Pjx5nF9cUzBKFHQLi2FEth/G+jpgpYooQk6F0cga3bu0wRB6Fi+0vNHna4PO3ra+ntSoqZfht+ZjHnE8gY+0liOyKFROKZ11ZrAaQB0ASh+yi00sS8tjTJSaOWfrV9UoN06lP/sYGof2KXWetseKa3E1svPigjRoNAHYHC5K6wVPTEExGGQ6BE0Q43sriS83EaLzAW1P8Tw1OicpAVVU1Brwc/cBJThlHbdWlMPhoOrtXOYM/ZB5js9wll5B5KBmvpstoPTx4cnH/o/sfV9wsuZN1OoE3D1DOJZTSGTnLq04ci9eOg51dXW8/fbbTJgwAalUyhdffMHatWs9Nbu8ePk70GpG1pIlSwgJCfHEGoMo9yiXy1m3bp0nxjU9PZ3c3NwzpEj/acjlYuiXy2Uh2WJl+q6NhNXWUJ2xk24yH3b59+Nn1yB2OpTcE9A+3iFzcRZhghlBgH41++i/ai99mEy2tSsBqR+TV/Y9gmsCAeipkhuI6WCGsVKrQlEXhqpgBEFBo0k4+BohKjXhNaGoBB1hTgsOqQQfSyHlOYf4aHU6941PRtIGQgGnY3e6MBiN3C5dSYE7iCOSULQlVXRypSNE1VFtKcNiuQh/mxiGFhga0nxHPvVKQIa2LWItqVcKjLO6ecF9N6EqPRPu/IncjVnwyzFPuxPlJn48UESQTtluRlZ1nR2zXUzkDj9d6KQqBz6/EmKHwKX/aeLdHK13UWo8yUS9hG0OPz5T72W4dDNWu4wvUz7jroubkaTtf4P4cz70uVr8OQ9k3aYQsu8NgtWVfFE1nExDEl//+5Em1268Q7RucyxaeOD38xtD4hi4bcz5tY0dArf9jsvlZuIjTYvDrp45gs5hPhRX1OF2g0ou4b6J45mLHwGmi5BHzKdrS2EoIV3p/PQqpLtLSf9YDHN0ylotAOMvI5PJsLjkaKkDqZnRDy9AIvljj1qJVIoy1A01oNEk0HvQ+HPv5MVLO9C9e/dmy/YAvPPOO8yePftP9XsqpPCZZ57BYrHQuXNnvv322yY5/X93br31Vj777LNmt11zzTVcddVVbTwiLxeaVjGyXC4XS5Ys4dprr22iTOLr68sNN9zAfffdR0BAAHq9nrvuuovBgwf/c5UFgYL8kxz9ZRskSJHJlET4aZBk9GD07FgOB+vZfLShWGuFyUphlZmIdhAKOBR3LbO3huBEQpwrAzcCgktg6m1hHC4+THlFFUpXXwLQd7gaWQBKjQaoQ+kQr8mR1eXYHA4qtAGstNuolLjZ5uzGW3Gv8XGGnJLi41w9MOYPeTcuFHKphP3zuyN/61rq3Eq6aT8kU5vEO70dyH2fx60qoaBgKEp3sOg1DIloviOPkdVyzmNrENEtgQx3FoHhcShsBcgctbB/GZNOrGazpDNbXKLHo7heyKXcaMVgseOjavvi1afysYJ0SlTy03II83dB2TGQa84IH52b2J+5if3J2LSbk+lZSJ2RDA36lfWu3oQGta0AjCGzEpVNADUkSPOw1imotdjx0zTE7Z8qSJxbWYfD6ULWSnWmThmsjTkl4Z5fLd7LIvzUHD1wNRJzLd23V4LSF+4/BoqWa4sFhGtRxJqhTOfJ+euo1AkScAsguLE7qlH+QUGgcpsDg0nM3dNo4lphhF7+7rRipscf4ueff8Zutze77a8IbKjV6gsuINHRePLJJ3nggQea3abX6wkJCekw/2cvf45WMbLWrl1Lbm4u119//RnbXn75ZSQSCdOnT29SjPifjMlgoEtWJJX5L9Br4RRWpR9EoAyHTcmwubfw4HNi8T0BF5GUk7XjJyImXNHmOUNFJhdZbjEE8ERwONW9J0HGSjbl5TN8eDUIYK0UJ25W3V+TeG0NNDotbsGARFNAaekqZj25EEEQeH1dJkfWZDCwaiddDOmkB1yKJiACyk3klJvaxcgCcAsyvnaMQBBAKghEqJQ4E3qhdUiwWsFU60IJ1MiNLXsNT4kS1LatJ6tzt5507taTyrx0dmxPxGBVY5X+RlTOclKEGWypr/ZWbrQRoFVQabJxsqKOHpFtL+PeNVzP1ofHUFVnO3Nj4hiYtQxPBeXTqCktYfX3n1Hr74vK5M+PzkGsd/bhijZcBNn4w08kbvVl08DumJDiCoa9pt5UmGxNjKxwvQqFTILN4aKw2kJMYOsUSz69RhbgqYFWWG2pH4scp9OIzuzEgQyn1AdlMwbWlvc/wGYxM/iaawiI8KP/9QMoKyumszqqVcZ+obCqnFTY4/hNMZC0zDxu1Rrxa0Gq+nQ+fuQRXhsykRLtJTzELiKdgRw+sIfImFj8/NpP7dSLl+aIjY1t7yH8bQkJCSEkpIUoFC//E7SKkXXRRRe1aH2rVCrefPNN3nzzzdb46L8lKrUaqEJtF1eatX5K0iPk5FoM3CRtWAFVYud35XzYDgwfc0Zh1NZm14lKz9+Orn7sitTgI3SiW3UGCG5AgqtKvKTcvh1HVfAUWh89VqGA8v4vUX4I+g9J44RdRa1GNAxVTgt6pxFDUSZxvTtzotzEiQoTQ85TCOFCU6UMZ4HjVgB8NHIyhwdxV2UZ76srADBWuQgAalV1LXfiU5/r2MaerFO4rVKWls6gVqXFnrGccEMsh7XR0OjyCNOrqDTZOFFuahcjSyoRiPBTN29MawJEZb5GWF0ufsjdz0WhUZiqqzAZKpAr1KhcSp5yXU+pS8d8/9YxYJpDphS9f2tUl3NIiCM1bCM5pXFU1RhgxVSoyYO7diNRaIkN0JBZauREhanVjKw6a8uerPHdQll++xAMphy+LJpJoN7AhmM5JHeJ43Q5B5fTydbjmZhUKqRffsOIW27Ezz8QP/+Ob2jYNW5M9nC+V87AJ9+IZP2XPPjcc+fcrzo3l2yFgnKFCgcyxvb5D8Wbd9Npm4l9QWsY9YA3fMiLFy9e/i50rAqm/1A0Oh0WQO1S4XA40Pop2dxDSpHGRuy63wiQ2DDa3VikSk64QlEqlUSYK9vWyDJXMST3vwiSQL53DcOtkeGUCAxKHU/M/iBgOXK5P65a0WBRBLTdJPN80el8sLsUSGxaXAoTe6uKufKYjRCJlCCnAMpebFTFEx5o40rnT1QIQZysaJ/8t6925fHzwQaxiiFV61hnmoyPU4JLKXpcLPU2r1V7Fq9hcFfod50otd2GmEwGTmRm4LRaORTZmWJfPZ0KcojMsWDwj4RGQ9bVF1LOKTe10FvHYlOlgbtOCIRlp/FzJyWdUi7B94iMrrpQ5IpjvGTRtWkRa7la9GJ2MZhxCRnYzOL5LLcIYqijtVaUcg/uTFyQlsxSIznlJkYmB5+t2z/N6Z4sqURAKRPvC75qOX1j/NldsI/lxVeiFGx8cUUWwTFnroZLpFLG9e3L2j17yTyehHZVDn0vikVohxzJP4xWQkrazYzpWYbRUIZNJsPlcp1T/lih1XJRVDSp+zbQ5+75RCjlFJbvAcDh+zc4bi9evHjx4sFrZHUAfH0DqMNFbdRGCve+Q1TPGfRcZUZr05KffZjZWb+zxX8Qe/xSGG37D8n+PvzahjWPACg9xpXmLxkqD+JXUwrjV60jvH9fukQMJrewgJgkUCgCcfUO4FheETGdLmzF8wuBWq1l7ygTKPwBE/ajv6O19kRRZ6C/RUYPZzg7lEGMs7/FxPwNHJVM50j5kHYZ6++Z5WxOLwakyF02kgsPk7T0GPbeiTAAJBI1zmrRW+zSn2XiFpwMk19pkzE3piAvF79ldVTLDIwcGkt6TjWd44cz99472f/VUchskBiU1U+aT1S0j5H1+rpMTDYnM1KjSAxuVAerMhuyN0DM4CZGaoUxh2B3CX2EQ4RG3o076AQymagqaMNNWH1YXluhVKsAO3ekRfKbwcGbPnKCHGWUlZTBjI9A7Qd+ohFzqiZZqaH1itqabU2Nfo1CinBaaLPTVswYdxpKVTRDrpjVYl+9r5hBVk40JdlmsvaUYREysZTXEpmSRJduvVpl/BcCqY+SIBtcn1/GoKvHogm+6pwGlsvlQhMYyNAbmwqjSKtFJUVZUPsW7PbixYsXL38Mr5HVAZDL5RhkdVi1hRgM26ir68O/QrpRlptLrVZOOqBynZoUCRTXtN4EqUXUfixzjafapcLfXk0XQwbqHDkSXSoyZS0ACkUQfS+6qO3Hdp5IJBKGTZzI3n3LqKzMJ1xVw5xNq5Hb7WyRD6eHHWIcUnY4OzMsSsHxnMh2865klxv5RP4cXSS5PGi7maOBV9DdbkIpiDXTFIogdH3iSNfkE9gpul3GeDY0Wg1Qicqp4ArVU9hi07AV3INa3otB2iI2IeNUnpPdIU4iT1acJeyxFflmTz4nK+oY1Tm4qZGVuQZ+eRCSLoLZX3veTnWs4mXexTfoMqRSFdVVRkLqbQiJYG25oHErodCoATs1klrqtOXMrEnDp+YkFYccMPbGJm1vH5XIPWOTPDlSrYHpNCNLq2j4rOd+OUakn4refnnc4H6bAUcDoGYfjP03KLS4XC5+e/11Bs+ahTYkhD2rcijJNiNXSrnohu7s/ewHOpdFkq3P69BGln9MKOmFOchifNCdI/m/OjeXNR9+iMVuZ84zzwBQVbWDwsKv8PcfhM4oekX1YR0/TNKLFy9evDTgNbI6CEaFGVW9HLfdVkHXSy+hK2Az1/G9bghbMxvyoWotDsw2J2pFG+Y9hXTlX7brcAM+sho2BwxhVqiefQd/wi+8EBBQ/EEFrfZCqRTzlJRBMmYNHow+JpbPPzwOKAixVbGpwo/Nfa9nZbYLRWUdLpe7TWXc3W43J8pMRArlBAoGatHiJ4tA4ZLRp4cvFn5BoQgU62I1VxvrdCy1YCgSlQZVbVO8W6PRUQeo3Erkcj02G9jNRfBcDLcD7/M2lYhjMdudrL1vJNEBbb9Sb3O4yKsUjbuEei+PB10IxI8Uf+pxu92Ulq5CACL8R7L166WY07PYrdXidsVQ41YQ1cbKn2q1BqilSlqDSZ2D3KWmzqBCajlT8auxEEZrUWdtGi54Kh+rus7G2xuzAPj6qiKUNhc+eZm4C04gTFgEwM8vvMAui4XDixczYPAN7F2dD8CIWcn4hWqQOsTvobQVjcQLQZ8BgyiNqyYv71MOZuWRHH8ryhY8WabSUg673SCXU7h3L+tDY9hdXEly9WGGuhwEWaYAEBLVgoKoFy9evHjpkLRdTIuXs2JR2pHaxVV0m72SVe8e4utn07DbpPjrG/KbkoR83pO/hH3ZnDYdX5nBwikpk5qAQNL6DeOkXyA1KiOFxUnE+W8mLOReDu3bTVlZ+4gsnA8H96RRmm8EwOGuovOECYR37YJMp6Bc4gJHCYOrtlKVto7PbhjIuvtGtrWII2UGKyabk8ttT3Gx9VkOuePIS9Tw7WAtx7Rd6drlOWJibjx3R6f4eBK8OQByt7XeoE9Dq/Px/F2SVQBADbnYZL5YJVoChFrP9pOVdSQGa1HK2l4sJbfShMsNOqWMYJ/TFBq7T4Vrf4Ahd3reMpmyMFtykUiUlKdL2PbNF5jc5dTKDFgEG1Ygqg1FLwA0WvG+URgu8MPw/my8pAcfxF5HSewgsQj1oeWQvqrNxnO6J0tTX5g6u94rHO6rIixsPE5jXzYZYzjhOx4kUlwuF1ofHyIsThRCd/asysfthh4jI+k8UFwYkTnEvuQdrAZfc9hsFdxXcynjc4fw9Jvvsu6115ptF5maymC9L1cOGEhESgo/lVXzeU04+cTgcgUid8uwCw7Cwjuex9pLA6NGjWL+/PkAxMXF8corr7TreP4sH330EX5+fu09jLOyYcMGBEGgurq6vYfyp3jiiSfo06dPh+nHS+vRsZcD/0F0mj2IOrML8sBur2J7ZS2f9Vby8vb9TNI0rLC7gfHSPbgLfMDtbjMZ94PHc+o/XcAVpMKZqOewVEffw1acNjU6Py3HD6YR9auCDJ/NBD86o03G9Uep+vUEQbpgSrqB1VrCGydLWFdZiyJKy8kKEwGyEGqViQTGd2dYgi8IkjaXys8qEyejTqUfR606wizFVAf4kxOlw6DzJyKiHzarld1bN+MfEkxcQvLZ8z18wqFof5vKuCuVKuyCA7lbxm5VXz7jEeIi86n4rQq5jz/HAxskuA0WB5UmG4G6tp84Z9ef6/gg7Rl5Q83x2PEi1vM6VyvTuFIbQ0yP3qgKt+JWTSSGIGwYiWxjT5bOx4cdQQVUKu0USiJxChLASYXRBnnb4ZvrIHogdJ4IwFM/HeFoUS3PT+9FdCsI1NTZTvdkiY+Zxuf6vuJYdgU8yhTfn7i57whADOcdfccdJKVXsOKV/Sg1MkZe3Zmk1IZwO4+Rpe74RpZEqkeDmKuXKVcQceIEY1toO+H++zx/XxkWgN64jkRrJmZDMgAVyhriZd7H9d+FtLQ0tFrtuRt6+VMMGTKEoqIifH3PX4123rx5VFdX8/3337fewM6TBx54gLvuuusP7SMIAt999x1Tpkz5S/14aVu8d+0OQmRULFVVxeTmgd1eiZ9ailEtxWFz4LPnJ8aXlrAhaDi5klA+8ruTeZPHtp2R5XIy8oeh7FcqGGd5AVu5CZNW4NKx3amoq8HldKPxVWCuMACBWDpgjaxTOBQu1FWdkVimEh01jf37T7INBX2EKnLlUvrZgpDpJjPR/DQ8fT/c8CtEpbbpGE/Ur/ir5VKMVge9ag+h3HuA+Kq+GGuK2Lo/hKixIwn9AaxCATyTfPYOTxUk/vUx2FAvI63Qwt17Gtp8cwPk/N78/oIE7j/a8HrFHZB5liKR9+wHuQqLxIrcKSPEUUydoMUul5Hkb8JXVcV2xR0Igpvx1heoRcfHW3MoOLqNqaZvGKbIbL7fm9c31P1a/yzs/qjlMVz3MwQmin///gps/2+zzbLrRgOTPYIQ7HgXNi8GtwsQzvh+HR7wGsVCBCpVOLGOA8SqvsQdUsZ6YTp6iwYbtHm4oEajY/QDV5Gfls4jhgfxpZpF0nuoMNkgsBNED4Lw3p72W46Xc6zYwPFSY6sYWSbr6TlZomF0olz0ICcEa1lnsWGWSJl51/108W06GY3qHMiYOV2J6RaA1q+pMSV3io8spart1Bv/DC6Xi8pP8rml/9uo3P5YK8YT1cyKc0VmJv6JiU0WSaaE+hOQ8T52KggO601m/0okXgPrb0VwcOsod/5R7HY7cnnbF3hvbRQKBWFhYe09jD+M2+3G6XSi0+nQ6XTn3uEcXKh+vLQe3nDBDoRcEQCAzVZJJ52GmTu3MnfrOqwn9tPFlIGPw4gNOV8KE8UiqedQq7pg1BYgcTtRYcfslDH3wCfc8uOLTNJpkSulhPb7lJyCB3EacwFwn03trp1xKUFpisRdM4SAgCEk79/J2CNpDMg+QK7MhQs3Pi4Bmx1wO1m5cQvf7c1v0zFW1dnoI83mOve3DJMcpEauR1VuYEjuITTaXKqsuykvPi62VRrOqVpG9ADxt80AxuL6n9KmbcxVjbY189OkbfV5tbVIxZyg3obDvOi+myfrHuPS0H0M8z1CmKSKUKHaU+J3a3YF3xYFs6cuqOV+3a6GMVgNZx+Dq9FE32Zssd0Jq/iASgjWNm1rKgVTyRntPwy18XZMKZdG9wdbHZjKsLk1nJRk86nmKOlOdZuHC54iUudHsvMYUeQz3riOXvs/o1YWCjeshkte8LSLCxSPNaeV1BzP8GQpm3qyYgPkLE+2sinOTB9HGYJLbJ+5dh2WqioAug4JP8PAAlA6xQmjStOxlfYkEgkWtxwfjCiESi5/9FH6zWqqoliZfYLXly7lhUcfxWE2e96322ux28VaeLFxgxk9/XJGXj6pTcfv5a9xerigIAi8//77TJ06FY1GQ1JSEj/88EOTfQ4dOsTFF1+MTqcjNDSUOXPmUF7eoMK6atUqhg0bhp+fH4GBgUyaNImsrCzP9pycHARB4Msvv2TkyJGoVCqWLl16zrF+9NFHxMTEoNFomDp1KhUVFWe0WbFiBX379kWlUpGQkMDChQtxOMTv7QMPPMCkSQ3X5yuvvIIgCKxa1RCi3KlTJ95//31A9ChNmTKFhQsXEhwcjF6v59Zbb8VmaygGb7VaufvuuwkJCUGlUjFs2DDS0tI8208PFzwV4rh69Wq6du2KTqdj4sSJFBWJZVCeeOIJPv74Y1asWIEgCAiCwIYNG856XoYMGcJDDz3U5L2ysjLkcjmbNm0C4NNPPyU1NRUfHx/CwsK4+uqrKS1teLaeGucvv/xCv379UCqV/P7772eE+aWlpTF+/HiCgoLw9fVl5MiR7NnTsAgaV1/IfOrUqQiC4Hl9ej8ul4snn3ySqKgolEolffr0afJ/OHWNLF++nNGjR6PRaOjduzfbtrVdKsE/De/yWAch+/gxsjdtQYgDt9tJQICCzmld6DU6ivzIML7eU4hFIk468qvq+HRbDnMGx7XN4PxieHf47yxbux2V00atzAeFQk7x3p1MuzOaw4UZlJYVIzHfBoC8A9bI8qAUp/Uui/iAGBXoS9CRI5gUQdgcsFRnpUzqxhwyn/iwQB5eX8M4RxFTU6LO1usF5Y7RnbhF6kD22+dESIcw3/9OdvgPYHEPJ/5+r+DWnKS2OpQQRmNSW8/dYZ+rRRlym7HhPeE0w+zSxU23n40Ji2DUwy1vl4riCjV9oboun5gu87BVP48yKAKmLYTDy9lUKPBs+TCMiJNlSb3HKCfpWphwf/P9akMa/h5yJ/RpWfobv5iGv/vfCN0ub7ZZ3rclkGdt8GSlXANJ42HVw6Jnb9h90GOap32UfzxhgoLMHVuw97iMfF0fvno7G4VEye8SN8dUasLbsEZWY3SCm3K7AqQO4qSFCCY7lYUF6INCmrSLDRK/n62lnFl3hrrgKU+W+HlhmhKO7LuevkftqMtqYPKr1MVfztLNm2HzJu68Zh5BSfHN9q10iUaWUtWxjSwAiyCO1e024XLZkEiaio6UHDuG4HKhcrmQqcXjKbc5KKs5gQsBlSIYmcy7Sn0Kp/Ns6qNSpFLlebaVIJWqztpWKr3wz7CFCxfywgsv8OKLL/L6668ze/ZsTp48SUBAANXV1YwZM4Ybb7yRl19+GbPZzEMPPcTMmTP57bffADCZTNx333306tULo9HIv//9b6ZOncq+ffuaLLQ9/PDDLF68mJSUFFTn8Pju2LGDG264gWeffZYpU6awatUqHn/88SZtNm/ezNy5c3nttdcYPnw4WVlZ3HzzzQA8/vjjjBw5kvfffx+n04lUKmXjxo0EBQWxYcMGJk6cSEFBAVlZWYwaNcrT57p161CpVGzYsIGcnByuu+46AgMDeaZeXfPBBx/k22+/5eOPPyY2NpYXXniBCRMmcPz4cQICApo9lrq6Ol566SU+/fRTJBIJ11xzDQ888ABLly7lgQce4OjRo9TW1rJkyRKAFvs5xezZs3nhhRd47rnnPKHkX375JREREQwfPhwQPYVPPfUUnTt3prS0lPvuu4958+bx888/N+nr4Ycf5qWXXiIhIQF/f/8zDDyDwcC1117L66+/jtvtZvHixVxyySVkZmbi4+NDWloaISEhLFmyhIkTJyKVNp+//Oqrr7J48WLeeecdUlJS+PDDD7nssss4fPgwSUkNZX8effRRXnrpJZKSknj00UeZNWsWx48fR+b1mF9wvGe0g1BdXkHnjCQK859l4L9ncnCD6D0xVFroNmkae7K3eNoKlhq2r13OnLD+ED+8TcZXaIQT7nDcKvgoYS4zuwXz+a/f45BJGTFCXG1TG/wB0Aadf5x0WyOo6m9OwklKS1eRMmsK/WVzeGvDcViVTrHMTZ+a/ch/2UbJ4MuBcM/ksC2RhXXnB0ay1ZWMHgm+ajmuhCS0UhVGEzgN4gTO7uM+R0/1BDQ/aT3v7Y3xP7NwbHOMmjIZgMqig2RkJ1Jj1FEUBuHpP9NZnchR92xPW5td9FKdMCkgrOe5O9dHNIQOngufMPGnGT67rQfFtRZ86gsiowsRf+b+AOUZoA0GbVPVzONbNvLzG4sJjokj8vrHsOs3YFZYiCoNoCy4Gyp52wt47HhyOZF1wfw2rC91yHEGKNlpS2J26JmLA/H1nqwTrSSZ31xOlsvl9nyPQrXlGGrBbnbgEmRIfKPITjuCxClOknURLS9ouK4NpdpiJTm444cK2eRyCl1RbJEM42j2SaYZjLjdbiL79gWg6yUX86+RI6jOzfXs80VRBc9kuxnGXfxLs4Otv/5KUEwkCZ06/+MnQBs2tnxfCAwcRZ/eH3heb9o8AJfL3GxbP7+B9Ov7uef1lq0jsdsrm7QZOybr9N3+MvPmzWNWvTdz0aJFvPbaa+zcuZOJEyfyxhtvkJKSwqJFizztP/zwQ6Kjo8nIyCA5OZnp06c36e/DDz8kODiYI0eO0KNHD8/78+fPZ9q0aZwPr776KhMnTuTBBx8EIDk5ma1btzbxfixcuJCHH36Ya6+9FoCEhASeeuopHnzwQR5//HGGDx+OwWBg79699OvXj02bNrFgwQJP7tOGDRuIjIykU6dOnj4VCgUffvghGo2G7t278+STT7JgwQKeeuopzGYz//3vf/noo4+4+OKLAXjvvfdYs2YNH3zwAQsWLGj2WOx2O2+//TaJiWKY+J133smTTz4JiGF1arUaq9V63mGGM2fOZP78+fz+++8eo+rzzz9n1qxZHqPr+uuv97RPSEjgtddeo3///hiNxiZhfE8++STjx49v8bPGjBnT5PW7776Ln58fGzduZNKkSZ7wUz8/v7OO/6WXXuKhhx7iqquuAuD5559n/fr1vPLKK7z55puedg888ACXXnopIP5/u3fvzvHjx+nSpct5nRsv50/Hjev6h6EP8EdAQG8VZa19AlRkhcpYobJTKWk6kZ4gTeNN50Kcp/JrWhm32803e0Sjz62RYR0TzspgCWq7HblgwY04qdKZxMmob6B/m4zrzyBRi8aJEPYFBw/dgcmUzTGTmVwluOu/DSapBsHtRl0rhr7lVZpxus7TmLlAOBLHcbflFr5yjiZYrSBzRBCPGSqx1YcRuWvrVyh9O/7ES6WI4OOyq1jiuoI1W9P5vTSW/c6+TdpU1YmhIm1dl0wiEYjwU+OjOi1vQSIVCxA3MrB+yD/Kiwd/INORhz44hE4DBpNfZUbiVCN3aJAr3MT4tr2BBeCSiEbql8qreVe4k6yQLmTqkrBINbDqEVjcBfaKoUNx9V671jrXp+dkicWIYevDY/jm1sEUu2v5hit5M3gCh4cthYTR1BhDCSwfSJ+QMai0LeeQJHXpQY8+/VD8DdQFXRoJlY44vhdm8ElmAe+uWMHab75p0kah1RLStaHQdYhCjkoiMCT+CqIi/k3Mb2o0H1ViMhnaevheLjC9ejXUddNqtej1ek9o2f79+1m/fr0nx0an03kmvKdCAjMzM5k1axYJCQno9XpPyFhuIyMdIDX1/HOIjx49ysCBTcuADB48uMnr/fv38+STTzYZ20033URRURF1dXX4+fnRu3dvNmzYwMGDB1EoFNx8883s3bsXo9HIxo0bGTlyZJM+e/fujUajafKZRqORvLw8srKysNvtDB061LNdLpczYMAAjh49SktoNBqPgQUQHh7eJHTvjxIcHMxFF13kCbk8ceIE27ZtY/bshsXB3bt3M3nyZGJiYvDx8fEc5x/9n5SUlHDTTTeRlJSEr68ver0eo9F4Rj9no7a2lsLCwibnDWDo0KFnnLfG12J4uJiz/VfOlZeW6fgztH8I/oFBmKnAx6nFZreiC1CxK1lKRoQU1c8/IXfpiLQUkqOJ44grjpOuEPSqSNrCnKlb+zw3OdP5VhhOjkYMw9LL5UyaOp/0vbuAb5BKfdDb/ADw9e+4RTNl6vqQHZseFDVYrSVMOyih0u4kUGHHWScnkUSMwRHMH1eB5OfPedo+i8Jqc6uIBJxOTrmJ+V/u8xTFDbcU0dmWSa7xMgLcUmxy0ciS1YrblX4dNzSzqDCPyrJS/AKD2BPXjVqViv4FNsoqYgiKaCpHXVgjrjpX1dmpqbPjq+l4ydrLCov5zRTDzZptLHztfRwOO+t/PY5vTQ/G+cjRqQTeVpSfu6NWwC4TjawEUzkByhrkVtEIqTDZiLObxDpp1ScBPKGR+VV12BwuFLILu9Z2uidLq5QhCAKBOiWBOiWP74LvhJmMjM0hrmcqLiRk7hQXNHqMSLigY2lXfGQM2HEj43tW0UkNEofjnLtcGR7AQD8tGomEvN3ZhAIlqkqifDvuwlVbMWrkwbNsbbq4MWL4zrO0bXq9Dx2y8c8P6g9wugCFIAi4XOL31mg0MnnyZJ5//vkz9js1CZ48eTKxsbG89957RERE4HK56NGjR5NcJuCCqxoajUYWLlzYrHfsVDjiqFGj2LBhA0qlkpEjRxIQEEDXrl35/fff2bhxI/ff30II+AWkufPrdv+1xdHZs2dz99138/rrr/P555/Ts2dPevYUPaomk4kJEyYwYcIEli5dSnBwMLm5uUyYMOEP/0+uvfZaKioqePXVV4mNjUWpVDJ48OAz+rlQND5Xp7xyp65FLxcWr5HVQfDzC8SIk+r4nynY8zadOt3BaB8TrpJKqCrnhtxvkbsdfBw1m8PyOEbaXuGN7im0RTq0bO9HzJcVscnZi26Hf8JxTMroOXMpyzdSXlCAtjMo5AFkp1bjNNoYETCgDUb154jr3pkcIQOFNgybIw+rrYToUpBLpAyyZbBW6E53hwY5MqSrb+JGKbxpn0R2ualNjKzjpUYO5ZXjNNcA4OMwkFh2mE7LajF10cNQ8aGhMYjx5Logv1Yf05/l8Hdb6JIXSXrv3VzaqTdHDxWjJorb3luKESWPL1rnaWt3ugnUKagw2sguN5IS0/qTyvXHSvlmdz4jk4OZ2b+R0bf9bTAUQs+ZENYQhtNNkkWVG/rq1QgSCXKFkqIKM34ISOsVPHx92idXyCkXH5ATdmiwV/myS+6Lv7yU7B2/03f07Qh950KAaMCE+CjRKKT4qGRUmKyE+17YMTfnyWpMtCubMe4yRoT1wScwiLyjlZhqbCg1MmK7t7xAU1FRyr7Vm5FplX8LIQi5j4poM1yfXcKIu6fBuGFI6yc31Tk5LH/nHSICg7jovnub5NTE1cvTHzxRSighVAc0H/b2T+OP5Em1VtvWom/fvnz77bfExcU1GxZaUVFBeno67733nid07fffW1CD/QN07dqVHTt2NHlv+/btZ4wtPT29Sbjf6YwcOZIPP/wQmUzGxIliqYhRo0bxxRdfkJGR0SQfC0TvmNlsRl2fi7h9+3Z0Oh3R0dEEBQWhUCjYsmULsbFiaLrdbictLc1Th+zPoFAocDr/mPLx5Zdfzs0338yqVav4/PPPmTt3rmfbsWPHqKio4LnnniM6Wnx+7Nq160+NbcuWLbz11ltccsklAOTl5TURPQHRMDrb+PV6PREREWzZsqWJ53DLli0MGNBx52T/63iNrA6CVCqlVm7Coj+B0bQHs/kS7u4+iLG/riG4e2c+Ss9EZjWgdZqolYshhRnFBuh1jo7/Km43h2Nmk35oN1mucAbUbUTudpCkV1GdbkWmEovKKpTBDLmieXGBjkR0bALRsQmkp28nvyANm7WER0vr+K24CFVNLU6f7lRL3AS4lFTFXEFarRShWDzXI5NbX5Y3u9xIN+EkPxgf47AilqnqJ6jxnUGgG3yF3QDIZL7YB+nIqCyjZ8KQVh/Tn0ZRv0JmdTLTcQ91sUfJP3kfKvkA1DXHiVUaOWltiFsP06uoMtkoqDa3iZG1J7eKlQeL0KvlTY2sw9+J9aXCejUxssa7VjCYI/QKapCDL60w05WGtfEAn/apjVOvB4GUaqq1NSTYrHQr+Incb92Yxn2MLrKzp60gCGz711h81a3jLWzsyeoXsg9/4wrmvt+NUG00s4aOoZtzKyk1mfQs6A5V6WzbHENlUDqhaJDKR7TYb1lJMZ0PhFApr4WOf6shMCac9JxMpFFqpIqmohc5u3aRq1RSU1bKBEFg8Ylipof5E6tSsHffHFTKCISyrkAIkoiOL/Lh5a9xxx138N577zFr1iwefPBBAgICOH78OMuWLeP999/H39+fwMBA3n33XcLDw8nNzeXhh88iPnSe3H333QwdOpSXXnqJyy+/nNWrVzfJxwL497//zaRJk4iJieGKK65AIpGwf/9+Dh06xNNPPw3AiBEjMBgM/PTTTzz3nJjGMGrUKK644grCw8NJTm5aZsRms3HDDTfwf//3f+Tk5PD4449z5513IpFI0Gq13HbbbSxYsICAgABiYmJ44YUXqKur44YbbvjTxxoXF8fq1atJT08nMDAQX1/fc8rba7VapkyZwmOPPcbRo0c9OXUAMTExKBQKXn/9dW699VYOHTrEU0899afGlpSU5FEqrK2tZcGCBR4DtPH4161bx9ChQ1Eqlfj7n/mMXLBgAY8//jiJiYn06dOHJUuWsG/fvvNSmfTSOnhzsjoQJoUFqd0HEGtlBSYmMuK2W+l66SWk95jO0qirKFKFe9ofLTaItbJaE0HgW+UU/uW4iRp0rA4ex+8Bg8n5fhkHstbgVlUCEhSKoHN21ZFQKsUCp1ZrCX2nXM6tM2byjs9oAMqlbpz2HL7P6sTvfjOpRE9madvkRJwoNxEtlAFgRI1NqkQtjUQmjebSaVMAUCgCGXrRBMZcNY3gjiwAoKi/vdhcKJSiGIqgqMH1zS0Ibw9llnZPk+YX9wjjyJMTmdTrPAUt/iKnJMUTgk4zjFKugUG3N6kt5XLZMZlE2fwfX/iQvCNi6FJlVR1VAftYq9yLFTsh/u1jZLnrU5QkrlrqfHKQamopVQYjCYvHYjpTNbK1DCxoqi7Y2S+T1+XDWF/Vg6/3qziSX4TFXIDO6ECRtRVXznZyyypwyuqQuM6Ujm6MtU706NjqSwN0dHr06UfXGTJ84r5kf86nGB0N5yWiew+GBwTQNy6On8pqeDGnmIt2pVNeV0xV1TaKS74nqFL0VgclRrbXIXhpI055IJxOJxdddBE9e/Zk/vz5+Pn5IZFIkEgkLFu2jN27d9OjRw/uvfdeXnzxxb/8uYMGDeK9997j1VdfpXfv3vz666/83//9X5M2EyZM4KeffuLXX3+lf//+DBo0iJdfftnjZQLw9/enZ8+eBAcHe3LJRowYgcvlOiMfC2Ds2LEkJSUxYsQIrrzySi677DKeeOIJz/bnnnuO6dOnM2fOHPr27cvx48dZvXp1s4bF+XLTTTfRuXNnUlNTCQ4OZsuWLefeCTFkcP/+/QwfPpyYmAbV2uDgYD766CO+/vprunXrxnPPPcdLL730p8b2wQcfUFVVRd++fZkzZ45Hvr4xixcvZs2aNURHR5OSktJsP3fffTf33Xcf999/Pz179mTVqlX88MMPTZQFvbQtgvuvBq22A7W1tfj6+lJTU4Ner2/v4VwwNrz4Jb7+W6lM+ImoqLkYsq7lxL4yeo6J4tnDeWzMKPO0HSfZzaPKr4jvOQSmvduq45r59jZ25ojqS/ZufkjtLm7LXo1VLsO3sgdzH74Im1BGZVkNwaHhhISGn6PH9sNut3Nw905qq1bjVC4lwH8YKSkfA9DvqTVUmGwMNcvoX52G07KdqOETGXjVdcQEaJBIWr/w88x3trHzRCWze+vZsD+LIncwPeIDMKolLBwdQqJsN4JERnjYlFYfy1/lt2XLSd4XzLGoAhwh7yEPyiHn8HgmuioIrtnMz7qZzC+d4Gl/3dA4Hp/cvc3Gd/GrmzlaVMsH16YytmvoWdsWVh/j4J7LEGxuDi5J5rqX30EVFMaIR35ikm4fAHMsI6i6NobUri2H1bQWa5d8RZf0cP6btJ+f4+KJt+WyZ300N45I4P8uToJjP0F1Hgy+QxT1aEWGPvcbBdWiQXRDj0+pjgjj200XgcXN4kszcWXtQVO+j55BIwjqMZ5fNwVTXJrP6LH+dD6LAlfa75sI/0kgT1fK4P+b3mK7jsSJnDe5PVvJXiGVhwzF6LZsINzfn0kPN9TfOVFn5cGMPPr7arnRL4e9e69BoYgi/qenceIk+N+paDT/O1LuZ3t+WywWTpw4QXx8/Dnlx738PZk3bx7V1dUe9UEvXv5u/JH7lDdcsAPRefYQqqqKoATstkqO15p5tLcESW0hV9rqV3ndblQuM33ig4gvyoOi/a07qNoiqiqKAQVuKTijtTiB4T4D2La9GplDh2+wls0/ridpZwCHwjYyZv5VrTumv0jg93a0ARHkp4LVVoLN5eLq/dmUDAxEuqmYcqkbqTwWqQYGDO5PnNoMkrbxUJySuXYofCkgmD6GDDJDB1HhpwRtIBGBV1BdVcGe7VvwDQggMbnrOXpsPyT1in0SG6xXjuIrxtAjJhvpxjQqClIRRjdVQWpLqXyXy+1R14s/3ZPVDM+eKGM5S5nns55bHpuIf1gEWeUmqiQCRcUyZgV0Ro6UqHbKkVOF6zleUYDRR0uRJBKN3AQSgUqTTayJ9u2N4HKINb98o8irrOPR7w9hsNj57vah5/6AP4CpUbjgdv+RpDu7gsUICDjqvuee2FdQRdr4LVaPJrkLU1LB6XAhPYcAh91iBVQ4pH8sr6I9kUh88acAATeFdidatQpHVVO58HiNkq96J+J0Q3HRegCcNnHFvlhTSez/kIHlxYsXL/8kvOGCHYjwiGj8A+MAsNurCPVVYlJLMcikBBcfIdRSwrX5S7m8eCWFPj3h6q/hmuWtOib32n+zxj6PG6UrCbBV4nc4n8hyCwl9R6Cpi8LXT49MLsVpFFVwXB08fUAul1OlMKA0RuKjuY5OiQ+ikEhIrzbgkEu4yHWICqkLiSySGLWWuJWXwmdts2pusNgpM9QXF3YDbjcDKzcxfPu3jD56nN2v/ocNb71F9rFjhHzvonxZy3K2HQFZvZEltQuERMZjFrQIAQH0Gn8RA6deSVR803pb2WVGHl9xiKlvbaGopnWT/YtrLZjtTmQSoamgidUAhmI4TWnphNmKU5ATrvEnpkcvBImEvCozTomMTf7d6eQKQ4IEX137JNEPmziRUQ9cRVxwAo+4H+d619uAqC7oFiTQ5VLocQW4xePSq+Rsyihjb241tZYLG35X10j4wiGRYzJrAQGN3IqlXgVRqVKTkNxQk+VcBhaA0yqO85TIx9+Bim8LmMkXfCp7god6JjE2PJxRI0ZyZOVKTI0kkwVBQCYRqK0VF82CQntRchkIo85eMNWLl7Nx8cUXN5Feb/zTuCbXP5FFixa1eG5O1efy4uWv4vVkdTAUcnEF02avJNxPzdVrtqJxFaKRK6iR69E5jKgEM5m1Dki+qNXHI9Sr3OW7gxlRuoWY3HzKel+OrXMnVFo5wX2WcvDQF+BIAMJA1/EvKYPaTFBNOI7aAQQFiUUA7zUUsysjnQhHBeskbpy4MQiBCC47lso8Hvh8D9P6RjKmy9nDyv4K5UYb0f4q7rO8hVAUz08M4KQ6Gn1hJb3dB6gLraDKXoisNhCIwKrs2LkpcpWY7C93SJkQ7Cak9i4S9X3pO/xVAA7kV8P6hrj4/Coz27IryCgxcqSw9oKr3jXmlNcsJkCDXNpogn9sJXx3CySOgTnfed7+fsAQMqoyCVCM9ryXVWokwS6hVA5L1UfxU8i4UdG+QiSR2iACjYdABirqiNrxCW9tfYXrX3kHtc7H085XIyfCV0VhjYX0YgP94y7MZN7mcGFzNhhB11iWsNfSm+VcSqy/Apcg5WH3QqYFzMVeomXv2jSsxmq6jh5N0GnJ8adjrTABPjg7nrp/i1jdCnwwIHGUEJSczPDkZPZ98w3fHzqE76ZN9H3o/4hQyknQKDEZDlJUJC6aRURcTED3wefo3YuXs/P+++9jNje/YBUQ0D4G/EcffdQun3s6t956KzNnzmx22+miE168/Fk6/oz4H0R2djrZv+9GiAKXy4I+SE1iQQT64EQUl0Ri+fYg34VdRqkymDiThGd/OUq4XsW8ofGtN6jZX/HwF1tZv7+EEdJNGKVaAmVurEW7mXF/Tw7mHKa0NA+J/WYA5LqOH0dv07mgBsyVDYIAMwekYNu8hb0GH1y+Ll7ztTAgPo5JY9by/F74aW8Rkf7qVjWy4oO0bL61C7y8FmeFhAeE4awKFXOWHu9sp0vgO7h0GdiMeuBy7KqOvaIfFhfDse77UAZqCVZDBIUoHBHgsMFP99Kt6iRKbsCKaIy53BDlryGjxMixYsM586T+CuVGKwqp5MxQQXOVGF7n01R8QybTUPpLGnUBgfiODEHto2ffkTKm1ckwyxxsM9pIGjUIqbR9ihGfwlfth6tWQCJxc5mzGEVdFRZbLaUnsojt2adJ2y7hegprLBwrqr1gRpbZ1jSUz0dtgArxOlXo9PxLeJk4Zxb3fD0PAdhqfYhqpQ376tWMOYuR5XK50OSJOZHKzn4XZKxtgU0QFUlcrlrPew6rFZ3FQpBcwXWHTlDndLGxfxLVxx4FXISGXkaAv9fA8vLXiYz0iqa0REBAQLsZml7+OXiNrA6EoaKKzkf6UXziOfo/PgNDpQUAY5WFRI04ES1Ui5O/CpOVlZu2c3VgFvilQvcprTImt9tNrlGCFQWr4yYi2Jw8Ur6FL7YVkrJrF77DxPwCuUlMYFbq27/myLlw+0qhANzmHEpKf8ZX3wddWAQJ8+7kuU9FmXQH4L97BR+sT8dn7A2AgqNFbaAwKFXAqEf4futhHBYZUYIMQS3DmdAFvc6X6hpwmcVVNremY0f7xsZ1IjZOFIGoKEnDUZXAiWywnzzBoGPfIbOZ6KGdwW5TgzKlf30R4iNFtc32eaG4vE8kk3pFYLScViB20G3Q/yZwNF39tdbVsfvnFeB203XYKFwuN7YMAw6pGVPgYfqbLXROaL8H9t6d29B/V4ePuppNAwZQp9DgqzGzLngkX9w5hsDo+tBMpwOk4m2/a7gPvx0r5cgFvK4b52MJuNDK6yg3i+dlaFwoh1y1JNbmYNOGIbWYsNnC0LtLSejb96z9SiQSUh+czK6NmxgwcvRZ23YkHHLxfrhKGMdXh7K4RSVBplRy+bjx+A0ezOdH8zlpsZKoUVMZdwfZJ17F1+c61n70FfqEEAaMGNW+B+DFixcvXv40XiOrA+ET6I9AKXqrKHet9VWQGywjP0CGwtY0NMxkczBOcoTbje/iThuO0EpG1mMrDrHzRL2yYL9A3BoZBbvD8SnPJzAqFKtTDLvSGMUiolq/jq/2qPAXJz5CwM8cOvQm3bu9jF/wJEq1EhxxOmQ5ooerVKInSa4gQm4BFBxr5Yk/ALpgGPUQz/6+BrAR6qdmywA9n1hNdFfWi5/U1Y9f+/f5+ur0Pfig7GrMCiXj1h/FZA/H4Zah7xkKpgbvh6y+qm9bnGupRMBX00zsmVQG0obQuo9P7GdHyTH6zB1LbK4ErZ8/R/Kr6VQnIEhBWedAbneS5Nt+4ZsqrQal24HOruRd+R3UCVpu0O0k2xqJT1QcsoIdoviFPgJuEotAdw0Xv6vHii/cuW4s3+5C4OaMt3h6cgxP+Uahk8u5SSFBWhuLYup9rHxjP9qCSkZcdRFxQ6PO2bdCrmTIuJbVBzsibrUaiVPODskwMsoMhJ88AjkZJNjtzB03ll9Sk3G53UgEgZCQiQQHT2DbmjV0ORZObkEJtFw2zIsXL168dHA69lL4P4yAAHFFX+tSY7GYkUglZCYpWddHw0+7f/ckrcfWneSi/J84QgIbnb2oCmulPJC0D7g4/f8Ywj5Rh6FewXzIZTOI1k2j2pEIgESiRGfxA0Dv79c6Y7mA6IL9AJCZxd9WWwlO3Cw4UYijsy+DLBmEOAQSZANI6DKF2SH7uFa6mlKDlQqjtdXGNeeDHcx4eyuH8muoqrMzuHI7etMmfEwWAutqsJjFRHmJSQxxk+mUrTaWC0XeyWwO7knD6XaxJak3afHdqJVrOGiIJsMcTZhv03A9q128xk+Um7DYO4aK3C9llSw3d6YwSMWEW+8GYOvmfLRuAYtTy1ZlJ65SXobj40PtNkb/AHGRQ2/XEW4uoLslA7VdAW6oMNpA5QuGQqjM8uzTJUw0stKLDbhcF6aSR+NCxFHWQsxdQrj/hIVAHzWBOiX+Cjn6oBAEQaAsT1zMCI7xaak7AAoLcrHZW+9715pIfBR0Wv8mowt0/F9COAOC/PEzm/HVite92+3G6WjwJAqCQF1eFQB1QY5m+/TixYsXL38PvEZWB0Kv98cuOChNXsa+fddjNKZz1ahYkkpy0VqNBNvFFedQaynx5lxqhCCutT/MjsjrWmdAGasYat5AglBEj5pDzP3iLbqt2Ey8QkFFvpHSvFwA5PJACvuZOda1mKCg1sujuVDEJiVxYoQRRbS4em61lqCVShkmcZJcnEtsgAkXTmKcSlSVWcjT3maaMg2AY8WtEzLodrvZfbKKopPp2K0mnC43vvZaeqRv545vNtNn32pcbnFSqqgPzVT9DUIzje9m4P+VhcL8k1wREUj/QjNyt5RpD7/BXR9/TWxM09ynwmozgVoFLjdklLTOubY6nFz2xu/c/cXepjlEbjcsvxl+fQwsDd6d0bL9XOz+kUF6hee98gOid/eQwoFcIhqGTkn7GYUBQcEAyJDi3C5h6opA/HNjULvcpO/cxraNu7HPWQl3NRSAjg/SEuKjpEeELzXmC+OFMzVSFgy3FZOcdYju5hq00qaPGlONFVOtBbfgJjCyZYlyl8tFzkc7OfrUGg7t231BxtiWKPRqJC4FY4sM3BkbyiWTLmb+889z+SOPAFBZuZlt28dQXLzCs4+ytD73LNq3XcbsxYsXL14uDF4jqwMhkUiokRup8z+GqW4nFksBM2PCeN5UzoPhgVgU4qQ6WxPPpoChJESKnq+jrRRaZR5wF4vtV7DZ1ZMYcz6htlJUditKi7jqrQsSc8aUiiBGT7+ccdfOQKs7+6p0RyAwMIThl1xMZExvQDSyAJYN6cXEA9sIrKhC4qzBgZtSazLWXjeyM2gq0HrnutRgpc7m5DPFc6R82pV+Qjo7Aoah8LkKiTIBf0/ivARp/0gy+pQRmdiKgicXCINCzG2qraxiRsUs5odfQ5CiAJvJjlB6hJ7S3Cbtcyrq6BquJ9JPTXVd64Tf5VbUcSC/ht+OlaKSN7oFmqvgwJew9TWQNXgJ+9jXcA0f0cdXLLJdW2FGVyWO7aDCiRLRyGrP+k0KuZJaqRi6299ZiFGdjUVdjJ9bwpFvlrB1+deU2gNA05A3JpUI7HhkLF/dOhh/raKlrv8QjT1Z0gAn422/EJiez9sbsxsabXwRvpxNqM86KoJ/56cXn22xv4N70ogxhOJj1xAWde6Qwo5GUEwE6ZEFOBLO9DpflJbOdRl2Cu0yKit/B8DhcBBmEP9Hkckd//vtxYsXL15axmtkdTDqFFakdnFl12YXV8uH3HA9vaZNQ6MXDZhyZRD7fXsRGSqGCB0rqgZz9QUfS6a6F687p5HljmRr4CB+DrmIBImVbz56BZPuBFp/ByBBoQg6Z18dEaVS9LqdMrKkcjmJl9/EW+oxlCr9qZS4qTAV81WanLRiPTKJQFWdrVXGklliRIILvUQ0XPPcIcgFLRJZBFapH9ctuBUAhSKAwWPGM+aqaURFd/xJmEUlnq+6agMyueiBk6iqkWSuhv8OIeVQ01otpQYrr1+dwpaHxzAiObhVxnS8VPQIJgRrEQShYYNEChMWwfAHPEaWy+XAVHccgOUL/5+98w6vqsr68Htub7npvUMSCD2hN6lSVBREEGREHLsCIqLw2RC7M+rYRkdBQRTFhuBYQESp0ksoCS2EkN7b7e18f5xwwyV0goCT93nyPLnn7LP3PuWeu9fea/3Wv3E5nezYVoyAwDGFmy6mXXQzHWGH/Ahu+eVVezTVG7Tx7lps/gXYNMUEemRoUtJoc81AlKfITO9z/k2A+cSVwWABtwG2lASw/nBZw/bc9egLV6JVVCDKxDMqMlatzgHgSHzpVbFKfjKt23Sg26QO+Lf8ig0772dbjRm7x0Ol08Vuk5UttmD0mDAapQmfo0cOovWoscpsxNWLxjRzddC/f3+mTZsGQEJCAm+++eZl7c+FsmDBAgICAi53N87I6tWrEQSB6urqy92VC+LZZ5+lU6dOV0w9zVw6rp7I+f8R7BoXBodkTDkdlRzbV8Hm74/gH60nSK+mpLYhNsFfo+QW+RpeyJkPP46AWz5u0r7syqv2/l/eNo4yVSJtD2zEJHeittowqIZzzYAplJTksi9jO0FhYURGxjZpHy4VWXt2UXIsG7RgtzckBW0bG4woA8ED5XIPwfJgyo9toHOEmdefnYCf36VZqduVV4UHGc8kf8eoVhpKvz5Ckkfgm14GHILIzWIwqamveuPyrhacOhGqwFFjxWIzITeC0/8IhWVJxMp02M1WBEHy1DtOQZWVQF3TrKyciuPPdbvok9yxNP7Q8yGfTbm1uZSIwQS5yjH4J6JQKsnzl/Ghnw21CKNt5dT4GfG4RNyypolrulCsGgdYIbuTkU3hLWlnPohnNYjdRzK8X0soyoANb0FICrTyTbbpcHlQnUNC4LNhsTesZOmVFo7USKqGPtf6mseoChpEaFkK1wX407JD2Cnr2rJ2NUnl0XjwkDysy0X37XIhk6moqt7M/cICTDsO8WuXFFrptfzUOZnlu55E57JiMEiJmfP3HSaJQIr9qkhWNP88X61s3boVvV5/9oLNXBC9evWiqKgIf/9zd6mdNGkS1dXVLF269NJ17ByZMWMGU6ZMOa9jBEHgu+++Y+TIkRdVTzN/Ls1v8SuM1hN6U1q6Gyo24nRWYXe5mdVRjkVj5979W8hC+jFWehxoy49wd/d4NDscUH6oaTuSs5aK/XkoMeBEgSdci6hTUGJtR7eiWsotCvzDtAiCnEPb95O4zo8DwX8Q+ditTduPS0TRqv0kVkdz5BpwOEoQRZF8u5M7cvOx949E/VsR5XKRNso4AlvexU1jw/FzlAKXxsjaeawagLS4QIqcMjRuGyl12SyLuha3XIZKFUiU8RZMplq2/7EeY1AAya3bXZK+NCWiXhq4e0wOvve7kR/oQ7fYLPQZSrYc6kxkciuiA7TkVzVIpueUm2kX7Y9Yb3k19WqL91rHBpy17IL8Yj4Q3mOodgsfPHMbAJuPVFAjl/r2taoL99pySBYiKZNXN2k/zxdXtJxD8gJMOn+KZNEEqUrJVrmpNNevvmb/Br8+C+3HeI2sgyV13LNwGx5RZN3jAy+6D151QVGkKiiCXdmtAZG02MCGQgl9CEzoQ/cz1LNzy0ZCfvYAcg4mFDE4od9F9+1yoVRGI6AgWsyjRt2OKqcbpUygvdZBleu/AF4jKyQxGs9mE/arb9GumRMIDb00q/Dni9PpRKm8irJ3nyMqlYqIiIjL3Y3zRhRF3G43BoMBg+H0sajnSlPVcylxOByoVJdu0vRKa/dkmt0FrzAiI2Px95diDxzOSsKDtdhVIAoCdrUVuUeaKU4yZ+P68X32bs+Gydvh3tVN25EVT/BI7oPcrMsgwFFF/K4s9PtLiAyKQCmPR+n0xz9MihFz1kkubm7t5Z3JPx88RhkKeyBi2Qjatn0T8BCuUlBid4JSxkQ2UVHv/tXC8hvGzwbBqjkAOGxWXI6mcxsURZGd9asr6XEBVJodBDsqSaxbz6DVPzBgXxY/znmWrZ99Rv7RHMK/F7Euym2y9i8lMj/pJSeYPBiDwrAJOnRR4Qy/fxDdR40lffiNjRICHykzMfHjLaQ/v5KiGluT9sfp9rC7oBqA9PhA353VeVBbBJ6G1cJahxmF6CRRI6DRGxBFkU1HKr37y1X+aFKS8Bd1eOSX9/kf9LdbGDBjHC1VBp4QZ3OT6xsAfttfis3pxhHUFrHtzZDQx3tMmJ+a3AoLeZVWam0XHwN3PCZL7zZjdNXiMUnXJD0u4JzrOHLkAIalZlSikkOhBfS7a/RF9+tysv0fP6Kqi+AJ5vBrqwr6BkkTNXV1WQDIhDAUCmmg1K5TZw61L6fjiGbt9quZk90FBUFg3rx5jBo1Cp1OR3JyMt9//73PMXv37mX48OEYDAbCw8O5/fbbKS8v9+5fvnw5ffr0ISAggODgYG644QaysxvUQo8ePYogCHz55Zf069cPjUbDokWLztrXBQsWEBcXh06nY9SoUVRUVDQqs2zZMtLT09FoNLRo0YI5c+bgcknf9RkzZnDDDTd4y7755psIgsDy5cu925KSkpg3bx4grSiNHDmSOXPmEBoaitFo5P7778dxwm+q3W5n6tSphIWFodFo6NOnD1u3bvXuP9ld8LiL44oVK0hNTcVgMDBs2DCKiooAya3uk08+YdmyZQiCgCAIrF69+ozXpVevXsycOdNnW1lZGUqlkrVr1wLw6aef0qVLF/z8/IiIiOC2226jtLTBM+Z4P3/++Wc6d+6MWq1m/fr1jdz8tm7dyrXXXktISAj+/v7069ePHTsaRIoSEhIAGDVqFIIgeD+fXI/H4+G5554jJiYGtVpNp06dfO7D8WdkyZIlDBgwAJ1OR8eOHdm4ceMZr8Vxjl/npUuXkpycjEajYejQoeTl5XnLHO/TvHnzSExMRFPvpl5dXc3dd9/tvecDBw4kIyPDe1xGRgYDBgzAz88Po9FI586d2bZtm3f/+vXr6du3L1qtltjYWKZOnYrZbPa5Rs8//zwTJ07EaDRy7733ntM9tNvtzJgxg+joaPR6Pd27dz/rs3E+NBtZVyBKpRT47HRW4Res5a5fapi09jeia8wY65OkFqsjcOkC8YtMgJAkKZ6kqfB4wD8OtEF4orvSvm4fY3Z/Sc8da4g3atHolah1Ciods9m7bxoeezFw5SfHPRFFkBZBVCAv6EFY6FAEQY5KJuPrxGDu3PAjco0ci8eMWRApFOIR5SpySmu55plvmfbQ/5Gzc9vZGzlHTHYX6XEBPKpfToedzyDkb8YpU5KtTYQSKz2zd1IXXEe1bTu11VKMikXVtMbHpULtLyVOVlrl3Bxs4Z/iFKYEbiM4Jpo+4ybSunc/WpxkZB2tsFBSY6PK4mzSHE4A+4vqsDk9+GuVJAaf5M6z4gl4ozVsnevd9K/0IRzuk8wjbUcA8MMnmfQvFolzNjzrsUnR7G9RiCL5yhB9SQ+PoC17SVTmonC7OFxi4s0pD/LOnLcp7fwkdJ7kLRugUxHpL/0IHmgC5czjMVl6t4W4ysMIgFHuIHtVQX2BCiy7f+Pwil9Z+uLLbJo/v1EdcXEtyY0p50hgIT0fuumqn4m3GF2ozVEoaIjv+7SwnOUlBdhQoy2OIefIQW/5QRNGExp69c3SX2rMbjdmt9u7wg3g8Hgwu93YPZ5TlvWcUNbpETG73djcZy97KZgzZw5jx45l9+7dXHfddUyYMIHKSmnCprq6moEDB5KWlsa2bdtYvnw5JSUljB07tqGfZjPTp09n27ZtrFq1CplMxqhRo/CcdO6zZs3i4YcfJisri6FDh56xT5s3b+auu+5i8uTJ7Nq1iwEDBvDCCy/4lFm3bh0TJ07k4YcfJjMzkw8++IAFCxbw4osvAtCvXz/Wr1+P2y1999esWUNISIh3oFpQUEB2djb9+/f31rlq1SqysrJYvXo1X3zxBUuWLGHOnDne/Y8//jjffvstn3zyCTt27CApKYmhQ4d6r9epsFgsvPbaa3z66aesXbuWY8eOMWPGDEAyBMeOHes1vIqKiujV68ypbyZMmMDixYt9nrcvv/ySqKgo+vbtC0grhc8//zwZGRksXbqUo0ePMmnSpEZ1zZo1i1deeYWsrCw6dOjQaH9dXR133HEH69evZ9OmTSQnJ3PddddRVye9k48bmPPnz6eoqMjH4DyRt956i9dff53XXnuN3bt3M3ToUG688UYOHfL1dHryySeZMWMGu3btIiUlhfHjx3uN5rNhsVh48cUXWbhwIRs2bKC6uppx48b5lDl8+DDffvstS5YsYdeuXQCMGTOG0tJSfv75Z7Zv3056ejqDBg3y3tMJEyYQExPD1q1b2b59O7NmzfK++7Ozsxk2bBijR49m9+7dfPnll6xfv57Jkyf7tPvaa6/RsWNHdu7cydNPP31O93Dy5Mls3LiRxYsXs3v3bsaMGcOwYcMaXbML5eoZFf+PkHPkIFmrpRlOj9uGWqsgxiEjpqgjwjW3U6WSBnJVqkAO9JuK3+DbuP/T7fxr5cEzVXt+yGQw/nN4/Aj7LX7UKPwpUEdSrQgkZPty2rSr5M5/9qLW9BslJf9FqPf0khmunsGQPkTy5daaffvcMyGWJLkfe8sCKVUqec/fxuLwjghPFPJxzAscc2goVoZQfKTp3DP9NErm3dGVydGHkO9ciKviGKXqMJaHD2VtcB/8UrvSJSkPWYvvsZh/B8Cuvjpy6ES2SGB/m2IUnQOJ0BqJohClSzLK+eNd+GQE/TybfY45Um4mNVJ6zrOKmlbGvc7mJCXcQHpcADLZSW6ILjsIMvBvULGrKS1myZzn2f6lJLGdn1VJoktOsLOG+2pXMcK6j/59ezP43lu5ZsT1TdrXC8Hj8dAzUeq/TmnlAZuDKLeM4vrvaEX+sUbHHE9K3BTKmcdjskrVYRymBQDxMhM7fsml7FgdHF2HbskodGsfZ5fTzub9+xvVoVAoGHj/WLpOHYFGo73oPl1uhDAVKlM0AGbTIRweD08cLGB6cTJ19kS0tYlk/7LjLLU003LtHlqu3UPFCfnz3jtWSsu1e3jiYL5P2Xbr99Fy7R7ybQ2rI/MLymi5dg/TD+T5lO26MZOWa/dw0HJpJ64mTZrE+PHjSUpK4qWXXsJkMrFlyxYA3n33XdLS0njppZdo3bo1aWlpfPzxx/z+++8cPCj9to8ePZqbb76ZpKQkOnXqxMcff8yePXvIzMz0aWfatGncfPPNJCYmEhkZecY+vfXWWwwbNozHH3+clJQUpk6d2sgwmzNnDrNmzeKOO+6gRYsWXHvttTz//PN88MEHAPTt25e6ujp27tyJKIqsXbuWRx991GtkrV69mujoaJKSGoRcVCoVH3/8MW3btuX666/nueee4+2338bj8WA2m3n//ff55z//yfDhw2nTpg1z585Fq9Xy0UcfnfZcnE4n//nPf+jSpQvp6elMnjyZVaukxOsGgwGtVotarSYiIoKIiIizupKNHTuWwsJC1q9f7932+eefM378eK8L+9///neGDx9OixYt6NGjB2+//TY///wzJpPJp67nnnuOa6+9lpYtWxIUFMTJDBw4kL/97W+0bt2a1NRUPvzwQywWC2vWrAEa3E8DAgKIiIg4rTvqa6+9xsyZMxk3bhytWrXi1VdfpVOnTo1EWGbMmMH1119PSkoKc+bMITc3l8OHD5/xehzH6XTy7rvv0rNnTzp37swnn3zCH3/84X2WQXLVW7hwIWlpaXTo0IH169ezZcsWvv76a7p06UJycjKvvfYaAQEBfPON5HFx7NgxBg8eTOvWrUlOTmbMmDF07CgJAr388stMmDCBadOmkZycTK9evXj77bdZuHAhNlvD93bgwIE8+uijtGzZkpYtW571Hh47doz58+fz9ddf07dvX1q2bMmMGTPo06cP808xAXghNBtZVxim6hpS9vYjYN2rpKUtBMAQpEFAwM/je7sqzA4qzA427DtC7M5/wvzrfVydLob8KgsWp5viWhu7YtL5pvUYRJWebFsl3/y2CoejBI/HgSCokNdKblcqv6tnQBQYVp/4WV5HSelPmEwNRmry6PFs80vCJZNCFveVWHAhJ6l+5UPTsR99x9/R5H0Sej4E/Wbyu0kSD0mVqYjRafDr1ovARKm/bpu06uC6SlwzWyS1YvDEMfS69lr0+mSoacn+jXX8+N56LEf2QM5aEmxZPsfklJloFXHcyGralaxeSSH88kg/5t3RtfHOCV/BU2WQPMS7qTTnCEWHD1BwIBOb2YmnRnKpS3FkYg8zkiAvbfKYsQtlz46t5Dz5Owff3cZ2sQurGYhCW0OYW+DX0AEsSr4Xfdvu4LSBsyEGrnVE0xm0J6oLCoKIWm4jGheIsO6rg4iiiFkRQ7U7kiinHykhDcqkJ87Iy2QytNorPw/cuWCMDUVtjsKBkhcq2nDNlv0MCTHS2agjZsckgnNGoG0RePaKmrmqOXEFQ6/XYzQava5lGRkZ/P77794YG4PBQOvWUpzecZfAQ4cOMX78eFq0aIHRaPS6jB075jtx0qXLuYvEZGVl0b27b3Rkz549fT5nZGTw3HPP+fTtnnvuoaioCIvFQkBAAB07dmT16tXs2bMHlUrFvffey86dOzGZTKxZs4Z+/XxjKjt27IhOp/Np02QykZeXR3Z2Nk6nk969e3v3K5VKunXrRlaW72/Fieh0Olq2bOn9HBkZ6eO6d76EhoYyZMgQr8tlTk4OGzduZMKECd4y27dvZ8SIEcTFxeHn5+c9z/O9JyUlJdxzzz0kJyfj7++P0WjEZDI1qudM1NbWUlhY6HPdAHr37t3oup34LB43xM/1WikUCrp2bfj9bN26NQEBAT5txMfH+xiCGRkZmEwmgoODfZ6jnJwc7/M9ffp07r77bgYPHswrr7zi4wqbkZHBggULfI4dOnQoHo+HnJwcb7mTr/PZ7uGePXtwu92kpKT41L1mzRqf9i+GZuGLKwxjUCAy0YbR3qCaUxGlZqOfmxaCixhbGUa3lUx9HJVmO6mRfthRMtT8X7BYIX8rxJ0ppPwc8Lh57OvdbDlaidsj4koLwhOmpXxnHWFFR9EpFVis0oOt1cYis0ly11r/q0dNKSIqhmoqsMesYe/etSQmTsNgSCHP5mCT4MQVr0eRK/n72pweVn+fTf5Wyb/7UKX9TFWfN2V1dkL91JA6gur4oexesRKlx40xSs/O9jp+dlq5T5RegKJFusai7soY2J8Pfv7dWJh/C+UGIwN2laAwuPCUpeCfnOBTrtbmIiZQ+gG+VHnJ5CevYnl3NLwSfy/N5w17IR0fGM4Nmo6U5kp9qZZ52COPpEdxNqEJsVRXV+B0OtHrDeh0ly8IWWcwoBZtGBx63pD9HwBPKPcSbpOxU+0HLjj6wTjiHOsQRr4PncYDTbySdUKerM1iL4YkyIjbL91LhUqOo+UIlrkiqaq2cP1DHUho32BkrV36XzT73Ng7quh34w2N6r5aiU1qiem3QjQ2HVtlralzOZjXNoFWGiXHvpFWVaKSrvx0DJeb7GvaA6CTNUw2PhgXxj2xoShOmujY26ctANoTyt4ZHcqEqGDk+Jbd2rNNo7KXgpPdXgVB8E4smEwmRowYwauvvtrouOOD4BEjRhAfH8/cuXOJiorC4/HQrl07n1gmoMlVDU0mE3PmzOHmm29utO94vE3//v1ZvXo1arWafv36ERQURGpqKuvXr2fNmjU8+uijTdqnU3Gq6ytepAvohAkTmDp1Ku+88w6ff/457du3p3176Tk0m80MHTqUoUOHsmjRIkJDQzl27BhDhw4973tyxx13UFFRwVtvvUV8fDxqtZqePXs2qqepOPFaHZ8kPNnt9GI4+XxNJhORkZGnjHU6ni7g2Wef5bbbbuPHH3/k559/Zvbs2SxevJhRo0ZhMpm47777mDp1aqPj4+LiTtsunPkemkwm5HI527dvb5RKpKkERZqNrCuM4JAwqilC69FgNtWhN/hRGqZiVUvIqaliiH8Ouso6MonDXVHMmldm4lEO43XXGO4b3o3I8DYX1wFRRHyzA7NqNDwkTiFfDAanBxxuCl1G2va8l/yMcg5nSD7BOl0CMqdkZOkDzl1O9XJjMBjJl1tQ2KUZZEd9rqwCm4M38kvRx6oYsPsPfvXviEIEx9YfGe/5L1p5Am/X3UxhtZWogItfubM4XPR4eRWhBjXLp/Ulp9yM3OPintyP2BY0CKO5NyG2fCyaencYk/TFF/RXj2tm3rEjVJWV0yKlNavadMElk9E9s4hKeSqltmq668NRyWU4ToiVUNfLieeUm6mxOvHXXvz5OlweBAGU8nMbTG2tLGSrOwm1vI5WPfqw8mtptbNQ7iFTH0cmcfz6935s++pHWh+JIiO1mMF3jLnofl4oQSGhmCkn2KWnvaIQhcuKS5AT7mo43wKLAkEhQnWDcMpxI2t/cS02pxuN8sLjO812aSUrrWYXu3v04Tt/f27Pq+X6GxJp3z8Gl8NDVYkFgNA43xg2z1ErMeZoDljKGtV7NRMaGkGlzZ/ktW/x4BgtKXHxRKsFco5koRNVWGQ2Wsa3PHtF/+PoT5FPTSWTcSqnr1OVVcoElDTefqqyfzbp6el8++23JCQkoDiFdH9FRQUHDhxg7ty53liSE12gLpTU1FQ2b/Z11960aVOjvh04cMDH3e9k+vXrx8cff4xCoWDYsGGAZHh98cUXHDx40CceC6SVCavVilar9bZpMBiIjY0lJCQElUrFhg0biI+XUkA4nU62bt3qzUN2IahUKm/c2Lly0003ce+997J8+XI+//xzJk6c6N23f/9+KioqeOWVV4iNlbxPThRqOB82bNjAe++9x3XXXQdAXl6ej+gJSIbRmfpvNBqJiopiw4YNPiuHGzZsoFu3bhfUr1PhcrnYtm2bt84DBw5QXV1NamrqaY9JT0+nuLgYhULhXYE9FSkpKaSkpPDII48wfvx45s+fz6hRo0hPTyczM/OMz+DpONM9TEtLw+12U1pa6v1eNTXN7oJXGDqdAZtgp7TVInbvuQuz+Qh3XduSIcFGrg+uX14XQOFxUSZqqS7MI8pawAL3ML519AD1RQbfV+ci1OaTSg51iiDa1O3noR/fYPA3S9DUurCWW6kuseDySIN+nTaBinQ3+1OLCY+Iusiz/3OpuVaJrY00k26rF+9oqVMzwF5HalkuyVopINMlgCfZTQvNNgbK9gLw9tyvWffFJxfdhz35Nbg9IgniMfxrD5BTVkuAqwY5HrrvWstdK3LRbfkNt1gDgNwkGbIqv8aJZa9UyuftI+hrO7lHDnFLVDDD3AJKt5LAmMFM/eQbeowc00hhsKTOTlKYAY8Iv+0vaZJ+rDlYRrvZK3j0q4zGOwu2w9d3wsZ/ezd1V+Zwp/ghw3SSaMPRQ9LzUKSQjMEQg4qWoXpw10vNN0GeqYvB6B+IU5BWkhYmteerjtejLg8nxCND6XGTXr2TbSUR/LPd99CvQXGpRYieTrEBjOsah9VxfoOQkzl+fLLpEC0LDpJotjJ4SAIt08IQBIGKAhOIoPbzoPVrMJzdbjeRFQEAhLeOv6g+XGnIZDLK/KRVwi4lhQwKMmKr+Im8/FspSV1IiV/VGRMyN/PX56GHHqKyspLx48ezdetWsrOzWbFiBXfeeSdut5vAwECCg4P58MMPOXz4ML/99hvTp0+/6HanTp3K8uXLee211zh06BDvvvuujxodwDPPPMPChQuZM2cO+/btIysri8WLF/PUU095y1xzzTXU1dXxww8/eA2q/v37s2jRIiIjI0lJSfGp0+FwcNddd5GZmclPP/3E7NmzmTx5MjKZDL1ezwMPPMBjjz3G8uXLyczM5J577sFisXDXXXdd8LkmJCSwe/duDhw4QHl5OU7n2dVU9Xo9I0eO5OmnnyYrK4vx48d798XFxaFSqXjnnXc4cuQI33//Pc8///wF9S05OZlPP/2UrKwsNm/ezIQJE7wG6In9X7VqFcXFxVRVVZ2ynscee4xXX32VL7/8kgMHDjBr1ix27drFww8/fEH9OhVKpZIpU6awefNmtm/fzqRJk+jRo8cZDbnBgwfTs2dPRo4cyS+//MLRo0f5448/ePLJJ9m2bRtWq5XJkyezevVqcnNz2bBhA1u3bvUabjNnzuSPP/7wCrQcOnSIZcuWNRK+OBVnuocpKSlMmDCBiRMnsmTJEnJyctiyZQsvv/wyP/7448VfLJqNrCsOmUxGrcqCJWg/Fut2bLY84rVqFnZowUOd27O8Non3dINwyRQ4ZSoGTHuau2+R8tv8vLf44jsQEM+yfj9xr3M6EcEBBDsr0XjsgEikQUFNmRTLIVNJrnNaXQL9R93I4DvGEBgUcoaKrzy69x9ISmp/ACwWyf82VKXkrfgQBuzbgdva4Grwu6sVnqGv8ot4JwDr8m3sW/3rRbsj7KjP2fSI5geE//QhfNe7VCiDWB/+d1SGWxBUbkI80gtVEJToO7fgYFo5UclXj3uRRS0FppoqaxhTdTu3y24mVJ2HqcqFUH4Q9v9Ih3DfQWZWUS03dIikV8tgApooMfHOY1XYXR4Up3IVLN4L+5ZA9u/eTaH23QxmBd1lNjweD5Yi6dlvbdtGiqWA7onBkhxwvYecTHV5B8pyuZxaheTiWrh7Hxs+/jd2v1xkQJBbTrfqbUTX5rEvrw5OcK+SyQSWPtSbZ29sS6D+4q61ud5d8Lew/pQVaxhas54hvWPRB6jBZcf49WCGBrxKie53XnrmGarrYw6OZh/Ez63HLjhISb3y87+dN+0M7G9TTFhCDOkb93HdoQhKhUDwyLGHXR3xlc1cOo6vQLjdboYMGUL79u2ZNm0aAQEByGQyZDIZixcvZvv27bRr145HHnmEf/7znxfdbo8ePZg7dy5vvfUWHTt25JdffvExngCGDh3KDz/8wC+//ELXrl3p0aMH//rXv7yrTACBgYG0b9+e0NBQbyzZNddcg8fjaRSPBTBo0CCSk5O55ppruPXWW7nxxht59tlnvftfeeUVRo8eze233056ejqHDx9mxYoVBAZeeOziPffcQ6tWrejSpQuhoaFs2LDhnI6bMGECGRkZ9O3b18c1LTQ0lAULFvD111/Tpk0bXnnlFV577bUL6ttHH31EVVUV6enp3H777V75+hN5/fXXWblyJbGxsaSlpZ2ynqlTpzJ9+nQeffRR2rdvz/Lly/n+++9JTk6+oH6dCp1Ox8yZM7ntttvo3bs3BoOBL7/88ozHCILATz/9xDXXXMOdd95JSkoK48aNIzc3l/DwcORyORUVFUycOJGUlBTGjh3L8OHDvYqTHTp0YM2aNRw8eJC+ffuSlpbGM888Q1TUuU3sn+4egqTYOHHiRB599FFatWrFyJEj2bp1a6NyF4ogXuwo8TJQW1uLv78/NTU1GI3Gy92dJmfDS18jT1qEOWQPqa1fISpKckFy2F10f2YlVUKDW9UPU/oQ6a+h64u/YhDN/H6DhWCjDjqMPV31Z2XG1xl8sz2fvskh/HGgmEBnNQa3lUHGfGSeQPwrO9HtzgWYLJvp1HEBQUFnlkK9knE4ylm3vjsg0L/fbuRyabVw2a4CHl68y1su3Khm8xODWfJpJk/vyaGdrJznRyWR1LUHsouQz7934TZ+ySxhRcIXtKr8nX+HPs0/s2PpY1XQ067EFqfl7oc0bNt+CxpNNL17rb3IM/7z+e2NxaSURpPdoxpt9Dzq6vaSu+FeqO3F3yPvg9oCvkufzyN/qL3HdIoN4LsHezWpqMS4Dzey6Uglr9zcnnHdTnqBlmZJyXr9IqGdFHuwccMoLPbdFG9OZswjP/D8rLUYnSbMoTsQ3B4S+4xk4tB0fvvXYlJKojncvYr+o25ssv5eCBtf+IZYUzj7kw6zPj8XhUtGYHkfVmgd6M0bcAkK8kLbs/H5UZdEsGPAa6vJKTejEJy4RCX3d/yMWeO/kHaWHYB/d8Ph0fKScC9yj8iTzz6LTC5n9dL/krQpgCOBhVwz8+pIaH6+FBUvZcfh93nI9QI2Ucl8cRy67JtQtxxCj4GDLnf3/jTO9Ptts9nIycnxya/TzF+LSZMmUV1dzdKlSy93V5o5TxYsWMC0adO8+cn+Vzmf91RzTNYViF3jxmgLkP53SIIHufsq+O/He+nsr+NXiwm124HWLakLtov2p1fLELqaMgj+9VUITob2Y3xmq8+HHceklRO9WoE9KYCCkAjaHTiA264AlwtBEOic/gmC3E1VZTl7d20nKDSUqOimsfz/LAryc8netQ+0fiDUYTYfxmiUVHeSIgyIcgGh3hWspNZOu9kriLcLPFCrQe3fkpTuvc9U/VkRRdG7klU37G2I82f5O+sAM0EeGQsG+uGvVXKXKoo2qf8Errr5EAA89Z6AzlobSqP0yrGHZOHOT6M02IhScJLg7/sqOlBch0cEeRPZAS63h935kstloyTEAGGp0l89dS43Wx1+RBBEQGAbSiwOPtVYaevK55qKWhChe0dpdlBW72EnU17+16ld4wITfB/tZl2LrvSt2UOr3ABMeSXsDuoBwJ3iz5i/W41h2LOga5ATdrk9bDlaSYhBTUr4hbkdm+sl3F2idC0SDZUUH6khooU/GKOx3/wFxftymTFkApbSAmT1bnLuXDMQgCPmr+s2J5OpERzHSJQXEcchVKKTtHG3Y/T7C67cNdNMM8000+wueCXSdsI1qNOlQGi7XTKyNOFaXhlm5Ie+/lxv38tE5VauM++kotZMxsqfuc25icn33A+RHaHdaPBcQB4lhwX7skdIrViFgAcBEY+/CjFQzQFjDEZjJ/xqUvAL1CBXypDJlBzM2EfAYgtHPtl89vqvMPIOZdNivR+yWmlZ3mSWhA1ePVLE4KwcxCQjiA2rhnJ7NaHCDsKUBygz26msuri8KvlVVspNdhQygXbR/oiCjOwKGz0qN2Pw7CcvVEmWHoyaUCIjbyYo6Hq2/7GO/Zm7m1QJ6JJjqDc+zG7WqAdwF5+xLGYgIjI+3xvJx5mt8I/t6HOI1ekmt0JyfSuts7Hu0MWJIRwoqcPicOOnVpAUenbVoB3V5bzEdF7kOYbePYfNOVI81j5DPO/rB7E4bBjJYfUiJG7JEpRfZndBAHe0ikOhBTg0ARQJ0TjCI7jl4TTK/Bpe9Xcpfsaw+xMo982t9+JPWdw2dzPzNxy94PYtDjcKjwMQENTwgfpOfv9iI6aSElAbUHe4jvjxD2AINhJW72/v8XgIK5eMutBWsRfc9pWOzeKHGgdPuR9houc9BEGBXtd0bjzNNHMyw4cP95GmPvHvpZdeutzdu6y89NJLp702w4cPv9zduyw0Py9Nz+Wfem2mEeHhUTidiZSWNqjehYfoiLZDtd2N0y8Ip8yKv7KWCouLoi8/xVZXS8tOnWl130W4k+VvQb3zY141RhDW5lZyDx6kS9Fhjka0pNqiRx+fiOtgBf5hDQGZ9loLoMahubiA+cuBf1gwUIsxZyhxt3fE378TAEFKBSKQqCrn2tp1zPOXYt7GylfzpPJzlsu786HrYfw27KWLopzu117rnZE/H46vGLaNMqJRyimpteGw2ehSswOnQkWLLSmkGwr46JfF9L/2WjTJiYR/D3ahDNnLV8/8iMooPS8KMwQaQ7CVaxH9w7j/nQFk/FKHSqslMiyIEIOaclODPH5mUS0uj8jQN9eiU8rZ/vS1F6x8t7N+xbBj7CmSEAMUZYAhHPRhIJNRZ6skiiJiZcUoFH5sPuibM6N7YrC3Hrlbuhdy5eVXfBw0XnJ11BVuoO3+Z0iSqRCESaRGGtmSU4nC4+R7Rw+6JYXSRe+b0LJ/qzDmbzjKysxiXhjZ7vQy96dBFEXMDhehzmpK1WG4AjRUCzIOODche28Tt8559pTHWa1mSkPrcFa4SW07+ILO+2qgZGEJ9JJ7lz41mgTkcvVZjmqmmQtn3rx5WK3WU+47VVLcP4MFCxZclnZP5v7772fs2FOHVZwsOvG/wtmel6CgICZNmvTnduoq55IYWQUFBcycOZOff/4Zi8VCUlIS8+fP9yYKE0WR2bNnM3fuXKqrq+nduzfvv/9+kwbnXe2o1dLqynF3QYB/aYPY8XU2JfJw9mJmlz6Ney0uBtw4GrvFQly7DlSY7FSYHRfm7mMIh+4PYNAYmT2gHfc9sox+hRsJrypiZdhg/A1qZHF+BCZtYOu2F4gIH4GrXlLccxXmDQ2PiMJCLeGl3fDz64JKJb1Yx0YEErPqZzYdPYJK2eCilynGc8QTQQFBIIq8vr6Ea8tWEd8inqiU08uXno6WoQbu7J3ApNwnYMErlKRORy562Oafjp+rjkqThxaVBzBF1FLn2IG1UiAIJXVKS5Ndgz8DTX3+NLVNwYAAGYayybT0a4NSNYwuN4zylmsTZWTtwYYVq6yiWq5rF0mEUUNRjY31h8oZ3Cb8gvpw3KBNjwtovNPjgbmDwOOEaXshIJbro1tzXVQr3G4TbreHmLWV3CWo+EpnpU4hp3uLhgGKvYWc/RUFxIa3vaC+XQraB0RhYh8ym4aq3FzaBeg5Zj/EmMKvqJBp+Kjt7XQJ9pUN79kiGKNGQbnJwdajlfRoEXxebdpdHkQR7DJJPGOI/y+0rqzB7gpHoZKT9fY0Wo0Yze/f/YHZ7qHLsGFEpaWh1/sxaOq4Jjv3K5U6fycqSwQOg6RWqcgOZVXuEgaNa5x/qJlmmoLo6OjL3YUrluNGQzMNND8vTU+TG1lVVVX07t2bAQMG8PPPPxMaGsqhQ4d8VGH+8Y9/8Pbbb/PJJ5+QmJjI008/zdChQ8nMzGwOdgVyjx7m0NrdCDHgdjfMKnRID2fn19lEuA18Z0zGJYNKs4Ouo0cD8H1GIdMWr6NrQhBf9q+B0kzoex4yr2GpMPwVQDKEjwghuA2tKFRHMal6NfriAq6feReHsn8kP38XgQHdwCzdL0F/9S2KBgQGUynY0YhqigvzSWghGfn+SgU9B/an5f4IDEmtuFZhxCPCN9tjGbhFSmJ3PJ9lQVhHPK4LW8VrF+1Pu0gDvLINyk3kxUzDLlezKUhKJt06WM/w5H4Ui69Rpf4FTfXdBNEHi6ppkyFfaqIS49nfZhuaMD9CdDoiKULmqA94N5XCknvAVEZqwryTjKw6ZDKBoW0jWPDHUX7eW3zBRlbXhCBqrc5TGw62ammCwVwqCV8AtWWlfPbEI0S0SKL1jVNQiKCVWRmr2YK61kK3+IZ4vCttkOzxePB4/EEEj8fGZ/MWEVzWg1BNAAACIgfzyxsdp1LIGNwmnCU7Cli+t/i8jazj8Vg1Sqmdrv7bCamIJ2XgHfzw6zyGVn6J7JP5FNlGc1gTR8v8fKJOo5L1lyRMhdoU7TWydFWtcba6ehK4N9NMM800c340+cj41VdfJTY2lvnz53u3JSY2yE2Losibb77JU089xU033QTAwoULCQ8PZ+nSpYwb99ef0TwbVouFVlldqMp+nQ5zRnq3GwI1eIJVyCocJDvl7FS7qTA3ZARPiw3AI0Jd7i74YhYgQGx3SDg3gQa3R2TJjnzS4gIIMajZH96C/XHJdMo7AH569hXkMEIux2I5Ckjy7TKLtNIj97v63F5kMhlVmjoirCqKC39CFGTExk5CofAjIC6OgHoJz+MioVaHmy+25AHQz6Jgjc7FYVkYgS1bX3gnBBnc/SvkbyWjMBw4RiuHHJlRSUiQltihvane9iYWCzgt0kqbQ30B8XaXkZjYRGImSu8AiyUXlaMdRUdlLPrlc1q2aUf3I2sQEOnU2ddYzSyUcgsNbycZWSszi3G42qO6gHxU47vFMf5kRcHj6IJg+j5wu0AuvRLLjh3FVleLuaqSnRmSy65VVoZboQCZQGrUlZl4O2vPLlSfV1CtMpPRtzdlgoFIfSWUQYio4cO4O7HLNSirbZhLc9CH+aYCGN4ukiU7Clixr5hnbmhzatfK02A5IcdWgLqaeGM+tUVtCIwKoKVCoNwdjEqrJy6oLarKOiLbSoIPRw7vJz4x+S+fK8oYG4IyU5opNhT0IqCgH/rrL2zSoJlmmmmmmSufJg/s+P777+nSpQtjxowhLCyMtLQ05s6d692fk5NDcXExgwc3+N77+/vTvXt3Nm7ceMo67XY7tbW1Pn9/ZcLCIxFEOUH2YOx2X3GFvR0NvDfcH0+8mr9VraXVtm+8+/S2SuKUVjI9cRyKuxV6PAAxXc6t0doisvdn8Ng3GYz89x8UVttwxxlwdgwiLzEGRYmJJK3kE3jcyNJpE1HZpIGR2u/q9GE26xwICJhtn3Ik501MpgMAfFpYzswDeRy2NFz/9PgAb46leLGWALeAw+3h9wOlp6z7TByrsPBHdjk2l0daQUyfyJEKGwaXibZ2qEv2Y2Wsku9Kq7DXx+W5TdKqoevqvNQA6HTxLC+4hbnCrWQ5rOxbv5EfC1JYrbiF5NhIn7LFtTYqzQ66JAQRYlBRa3Ox8UjFpetcvYFV53Iz3mxi3YMT6fG3myjIllQJD8ii2FAZTW1YBx/jo7qqArOpDrf78sclGoxG1KIKo1PHv+UPMl+4l7hekqpguFuGXa4hXihmv/oONB/2hpMyePRNDkGvklNUYyMjv/q82j6eIwvApA9g2e43OFQ0BL9ADSNnzCRuzm5UTxzmmqmPMvbZZwlqkUhBfi6qeWVkzV6Bw351rdCeLzEtEtHUJqCtSkFjjsYisxEX3/LsBzbTTDPNNHNV0uRG1pEjR7zxVStWrOCBBx5g6tSpfPLJJwAUF0sJc8PDfWfwwsPDvftO5uWXX8bf39/7Fxv711WgAsmNzS5IK1SlxYU++1SROiqMcvZHyFBEarH4K7HX1QGwf8MaoksyAHjecycMexkU57jCtH0BKV/140XFx3RJCOTIocOoai0INQ4qTRrWhQylrKQPy97ags1W7+6iS0DrkOIvdP4XJvl8uXH5SYNM0e6rMPh1cRWfFFaw+KslHP7tNwB0KgX9It0sV83k/4Im09YpDap/zCjgaMaO82r32x353DZ3M7O+3e3ddqTczOjC74gqfw+tzYLR5UHYuRG32yT1sa4+8E139YheHCfv2BEytm2mpqaKXxNT2Z7QmjpVBDarhmx7LFXKOBLCgxqtUmUV1SKXCQxpGwHAT7uLzrvtPfk1FFafOpj3VBww1ZHnCWa/O5T41h1xl0uD/yIFHNJFkdC3r0/5ote2UfXCLnJzDp9335qaoGBJzELrUdNFU0kPZTbGIMlVO8IjAxGKRMkN0CN6wFrlc7xGKWdAa+m7sPZgY5fCM2GyuUAUGVL6K37BTpamR7EzzsEP77yMy2ZDJmv83ObszQKgVmtBpb76VsPPh/CIaKhKJm7rEwQfvZ4Sv6q//OpdM80008z/Mk0+WvN4PKSnp/PSSy+RlpbGvffeyz333MN//vOfC67z//7v/6ipqfH+5eXlNWGPrzxkMhlV6jrKW35HztFHqKre6t13bZg/yl0V2PbUoSypw1IhINbPoKdfdxPXtpIGUGsPV/LLvhOMVttZVv9sNThRsk9MoHtiMIeXfsKU3/5Fu183Iqt2kKxR43GLCMpSwINcrkelCsWULmd/ajGRsVdXjqzjxPVvT9nNCsJiOwNgrjeybg4P5NrcAxSXFZO1uUGePiWpJf6CGSVO+onHAPh5bwlvvfkhNaWnniQ4FZtzpBWZieIyyPoBl81EYXktGo8dAQ83bbbwyu5NFOz9HQC53IBglgxameHyq9idL0XzMwj+xkF2ViajEqK4LUxPgFWFKMZw9zufM2rmbBRyGa1OEmzJKpKe2+vbS6tc23IrcbjOT75+1pLd9HrlN1bsO839Wfc6fH0nHFkNQLRQzEzxOSbJPqOsVofRIRnixXKp3e6JvrFKSo80UFapVefVr0uB3uCHVSatvv4zshVL+4ymX+oA5AoZSg8k2srpXb6B+0vv4Zk2v/jkyTrOQwOSWPZQb6YOSjqvtmusTlQeO0nmbJJKDxBYYcXgKOOwQo6iXq2r+uhR1n3wAbYqybiz5VQDYIm8ilISXCAymYwyQ433sz3s6sx710wzzTTTzLnR5EZWZGQkbdq08dmWmprKsWPSgDQiQpqRLikp8SlTUlLi3XcyarUao9Ho8/dXx6y1YzPm4HTvxWrJ8W5vHaBDXmJDcAvM9R/IYmN3ZAbpemj0Bv7+6DTu7iPFWTz2zW6KCo/BZ7fA22ngPH1eJ8/Ql+kjzOc7d2+6JwRgt0mz9+WqIKJt5UQiDSSNkVK+IK02HkEQ6HfjDQy+Ywxh4ZGnrftKJqV1W9K69SQ0VArAN5kkI2tSdAiTBRtdq8oJP0Fxp3uLEO53TCPd9j41jta0t8tBECgLTKK2/NxyOdldbnYeq8YfE+kH/gVfTqCovBKbKGdZ9N2o/e/BIlcTbNQQhDQYVavDCewWy8G0cqLatGjiq3DpsWqklVlLVR1Dqh/j+pJhtAndgyAImAoL4cByOLiCNpG+3+3MeiOrV8tgnrmhDd891Pu8YrJqLE5vHWmxAaculP077FsCdZIRJpoO0IEMepPHHzsKJXdSuZmxtau5wZRBm6iGPno8HpSiZPSqVFeGaE9tvfpkTWUl2xYt4us5z6Lwl4z6CKeNdnVZhNYVk1Vcd8rjUyONdIwNQDjPZOY55WYccg3/SbibzoZNTLIv5F6jjT6BgahXzYT/9OGnBc+wqqiIRa++CoBfmWSY+rUMPVPVfxlUPUK8/2tP9zw208xF8uyzz9KpU6cLPr5///5MmzatyfrzV+Bir2kz/5s0ufBF7969OXDggM+2gwcPEh8fD0giGBEREaxatcr7wNbW1rJ582YeeOCBpu7OVYvTT0RvDwDwxuQABOlVKEVo5ZAT4BFYr3VRZXEQbmwY4D0+rDVbj1ZSWGOjyKEjsmw/WMohdwMkDfJpRxRFbGYTR+tESqwydCo97WMDebnLJHbvLyDRWkqPkBJEyzFEemEIlONQxaHX/7ViCfSGFEBayRJFEUEQ6H7HHXQ/qVyXhCD2Csm4BZFchZtBViWd47U8PXkacsW5fZ0y8mqwuzy00IPY8Q4EUwmH61UaQzxyBJmWaqWHfvf8nVbFwezLXItaHUZ6Wm/o0ZRn/efh0olQBY5aK/6x0kqQ2liCiAdX9kbY9gBEdCC1/UKf446LXwiCwN/7JDaq92xsPVqJKEJiiJ4w42mMoL6PQvIQiO0GQHmx5PpZdriWvSoTxSoXEZ58ZBF6EmsqffJHudxO5PVzVeorRBnVqnaAHUxVNeQdOsRBhZtwdzEQiEIeypaAzlQqg8grrsXtEc+YDyu3wszPe4u5v9/Zv+97C6RVGo8gp23KIXTK3XTq/hh6fQt4vw+U7KFH3ACKD1jpP3w4Ho+HEKskIBIR/9d2AT9O9wEDWVP7A65jJlJad7vc3WnmL4AgCHz33XeMHDnycnflL82MGTOYMmXK5e5GM1cZTW5kPfLII/Tq1YuXXnqJsWPHsmXLFj788EM+/PBDQHohTJs2jRdeeIHk5GSvhHtUVFTzS+JE/BUoLFIsxYm5sgJ1KmRKGeHBftiUAmHH8tn99Tf0HX0DmoAAAGoKj3FfWAlR3VvQKSEEbnoX/GPhpLw4NrOJJa88i62uDs/IRwHoHB+IUi5jc7gCR3QC2vWlCB4PMo8eAYGo6OuJSp6AKIpUV1eQf/QoASHBxMQk/CmX5VKwbcM6qvfnIiQKOJ1VOJwVqFUh2D0eiu1O4rUNsSIGtYJ20f5k5FVzTOEh1akguFR+zgYWwOZ68YYWLZIRbrwVgJz10mpliEdgc4qaHS3UpBaWc0tgF9qkvoZSeWWq2Z0rokEyRDx1DjRqacW6QnEAl7Inmfty0QuhKDXRpJ60kpVdZsLh8visXomiyKebclErZNza9cxuqsfdMnu0aOwW56XlAOmvnj/sCmx0oEVAKBtya8nWOUk3OUkrriMgLMTnULu1YXVYrb4yjCyH1g21sNtczX+u6Y4f1Tx3zIirXRSLt9nJ03cjRihjpjgf8zf/xTj2vVPWU21xMOKd9dTaXEQFaLmxY9Qpyx3nUKmp/j8POqUUA2epUqHXA2M/gfKDtIjtzvR6F8WSkkLUogo3biIj/zeMLIB+N91wubvQTDNXJA6HA5Wq6d2unU4nyotMFm8wGDAYDE3Uo2b+V2hyd8GuXbvy3Xff8cUXX9CuXTuef/553nzzTSZMmOAt8/jjjzNlyhTuvfdeunbtislkYvny5c05sk6g8/D+aK6RVlfs9gYjSy4TUAWp+bGrnnVttdyoymBD3mEOrV7jLZO59jeyvp1P6Y510oYW/RsZWACbvv2C4kMHGZWYTbctU2grHKVHi2AqrQ4cGhmo5eyQJ/CNpROGGinRalCklNdFEAQO78skYLGF/PnnJ/pwpVG7uYDWh+LBJa2wmE0HKHM4SVizm56bsjCZzLhOyILeIzGIDkI2k/VvkG78mIMGEVEUKamxMuatVWzcX3DG9jbnSC6XJya0zSk306tyE4k16ygMcFPur6DK6UarjSYychRBQf3Z/sc69mfuxuW6uiTcAeQG6YdTMIvscCdxF5/xYcQkRMFFXkkdH2W25mDEBFKjfI0sp1vksHfwLvFLZgnPLNvHM8v2sb/4zLGG3mudeO45n95x9OMVYTa69DEcKTcDsMPQko8CBpJ+9/0+Ze2OBiNLpbpChBtiNBwKK8DoF0SREEkxUfS6rTuDx7fGGigNNOS4uVOxAv3+ryXp+lMQoFMxqVcCAE8s2cPR+mtxOvIqJTdFf6GGh3mf/+N1Nqzaj6mkRHr/tBruEwNWXB9bW6Gu/cuLXjTz16d///5MmTKFadOmERgYSHh4OHPnzsVsNnPnnXfi5+dHUlISP//8s/eYNWvW0K1bN9RqNZGRkcyaNcvn/d6/f3+mTp3K448/TlBQEBERETz77LPe/QkJCQCMGjUKQRC8n4/z6aefkpCQgL+/P+PGjaOu7tQuwqfC4/Gctl2AY8eOcdNNN2EwGDAajYwdO9YnDGTSpEmNJs6nTZtG//79fc5v8uTJTJs2jZCQEIYOHXrWfgmCwPvvv8/w4cPRarW0aNGCb75pUFk+evQogiDw5Zdf0q9fPzQaDYsWLQJg3rx5pKamotFoaN26Ne+95zvBlJ+fz/jx4wkKCkKv19OlSxc218dkn+wuePz85syZQ2hoKEajkfvvvx+Hw8G5cCHPC8DevXsZPnw4BoOB8PBwbr/9dsrLG0SKli9fTp8+fQgICCA4OJgbbriB7OzsRtdnyZIlDBgwAJ1OR8eOHU+r7t3MxXFJZMpuuOEG9uzZg81mIysri3vuucdnvyAIPPfccxQXF2Oz2fj1119JSUm5FF25agkMCiE4SAo8d9h9JcLDkBNebKfbQRtulx96ixWH1eLdn9AxnaSuPYhp0x6rw82nG4/y4KLtiKIIngaZ6d633k5K9x4E1O6hg2UTT93YgaGpwSx+9H6uW7wI7R+FCHYPejTIPRq0RhWaE0QXrDXS4Neudl7KS3Hpia4f4OXcTI/uKwgI6EaIUoFGJqBwOXn2rbf57Lnn8XjqhQ9aBOEvmBmi2EySdg0rLbXYXR4ee2cJW4tsPPP11tM25XB52J5bhYCHXmENP6Y55WZamQ5isO7CfSiP0XYl1Z/MZe6sWVRkZ2My1RL+PRgW1uByXX3XWx0gGecqq4wgtT82QYtZHcjkf46i/+2juPaeycS174RRoyQm0Fej/nhM1XGuTQ1nQKtQ7C4Pr/68/7Rt1tmcXhe27qdbyao6Csc2+6jsJcoriaUArWAg1CkgP0GfIDHEN3nscdlxu+A4pXre5WDgmJEMmD6Okdf051nFm8xhFtZ6RdA2UUZkohuTXcF8x7UsT/w/EE8vPT91UDLdEoMw2V28sfLgacuV1tqorVcXHFv3HeVCGMeEBLYd/YPlH3xwymMCQoLZ36aYqtZX36RBM38+FofrtH82p7tJy14on3zyCSEhIWzZsoUpU6bwwAMPMGbMGHr16sWOHTsYMmQIt99+OxaLhYKCAq677jq6du1KRkYG77//Ph999BEvvPBCozr1ej2bN2/mH//4B8899xwrV64EYOtW6bdm/vz5FBUVeT8DZGdns3TpUn744Qd++OEH1qxZwyuvvHJe53K6dj0eDzfddBOVlZWsWbOGlStXcuTIEW699dYLumYqlYoNGzacs0Da008/zejRo8nIyGDChAmMGzeOrKwsnzKzZs3i4YcfJisri6FDh7Jo0SKeeeYZXnzxRbKysnjppZd4+umnvcrXJpOJfv36UVBQwPfff09GRgaPP/6493f/VKxatYqsrCxWr17NF198wZIlS5gzZ855nfu5Pi8A1dXVDBw4kLS0NLZt28by5cspKSlh7Nix3jrNZjPTp09n27ZtrFq1CplMxqhRoxqdx5NPPsmMGTPYtWsXKSkpjB8//qqcwL3SaXJ3wWaaDrVaklI+0V0QIFivwrCligFWFcfknYi7rRWdezfEq8S370R8+06ApPj10k/78TitFH+1kIi85QgPbQJtIEq1hhsengXF18GxTURqtOSv/gFrRSnxcjNirQcEgWCjhqRWYSg1Ltat745WG0dap4U462yAAZf26lbJCkmKhp12wvPao9W28A6Wt/dqS/ZXX/GT3UpkaIh3e5eEIO4X2/CWaxQr3Z2xiSK78qq5v3cs65dXc8isJLOw1kcg4TgKmcDX9/cke88mkj7tDKGp8OBGcspMVAR2JdhRRb5bx/RANds9LqxRZVjF3dSUJaICLDIbGs3VlyhLH+AHONHaVCQbA3ldnEyk2oBSvZwWaV19yqZGGsmvalg5zDrJyJLJBJ4Z0ZbfD6xm9cEy8iotxAbpGrW57WgVHhHignRE+p/mmmV8CatfgrS/wU3/BuD73iOQyeRs3FvMHSYrTsHJElUhJYYw/LW+LidKlYrd0QUgwJUWpaiVy+iis1JTU0r+ntW44yJpp1LjqtpO55rtrPVrA8l9uP4MaR4UchnP3NCGG95Zz897iyg3tSHE0Lj8pvoVQ6OrFqO8lufFx6m2heO0xxMTYIGdi6ScfaGtvMfEJyQRn3B+CobN/O/S5pkVp903oFUo8+9siHHr/PyvWJ2nnjzonhjEl/f19H7u8+rvVJp9Vx+OvnL9BfWxY8eOPPXUU4CkivzKK68QEhLinWh+5plneP/999m9ezf//e9/iY2N5d1330UQBFq3bk1hYSEzZ87kmWee8f7edOjQgdmzZwOQnJzMu+++y6pVq7j22msJDZUEYwICAhoJh3k8HhYsWICfn6TYevvtt7Nq1SpefPHFczqXM7W7atUq9uzZQ05OjjelzsKFC2nbti1bt26la9euZ6rah+TkZP7xj3+cc3mAMWPGcPfddwPw/PPPs3LlSt555x2flalp06Zx8803ez/Pnj2b119/3bstMTGRzMxMPvjgA+644w4+//xzysrK2Lp1K0FB0qRcUtKZ308qlYqPP/4YnU5H27Ztee6553jsscd4/vnnz2nS7Xyelx49evDuu++SlpbGSy+95K3j448/JjY2loMHD5KSksLo0aN92vj4448JDQ0lMzOTdu3aebfPmDGD66+XnvM5c+bQtm1bDh8+TOvWrc/a72bOnStj6rWZRng8HrZ8uwkAt9uBKDbMQgTrVRQqpM8RbiWVptMn8fTXKhmZFo0dJZ7stQimYgqWNHxBkckgqhMHxLZ8+/KzZPz6M4ohd7I2uDeR9krur1tF/6rVDL2nHd1GaXE4yjGbDyOTafCYpRUVUXd+KmRXGslt2uHCTYDLj6LChvQAQUoFXSfcxt9vuIFrT1BaMmqUpEQF8S/XGPaKLZCLAltW5iKrjWZQsvRy/mxz7inbkskE2kX7c1N0HQhyMEZic3koqLGR5ZfK+uBeOGUqEsKN3JKeTttWOzlwbAbVlZkAmJTnnu/pSiIyLp79bUuwdlNj1IYTQRGCI09aXQXY/CG81RF+e7GxwmBhY5fAxBA9fZNDEMXTX+u0uADevS2NR65NPn3H5AowxkBwQ5n3757Ae/dM4OhuKU7OqixiYGAu99T91khxLzQ0gkFTxjFo8rhzuQx/Gh6PB7OpDq0mBoCNWev46t316NdXgCwQu6BCpPEq4aloF+1Pp9gAnG6RL7eeOn3Gpvo4w1qlP6tiBtKCbFLNhTw882l6tFfBsgdhx8JTHttMM38VOnTo4P1fLpcTHBxM+/btvduO5wctLS0lKyuLnj17+rxTevfujclkIj8//5R1gqTgXFrqO/F6KhISErwG1vkcdy7tZmVlERsb65OztE2bNgQEBDRaUTobnTt3Pq/yAD179mz0+eR2u3Tp4v3fbDaTnZ3NXXfd5Y2tMhgMvPDCC15Xul27dpGWluY1sM6Fjh07otM1TPD17NkTk8l0zmmGzud5AcjIyOD333/3OYfjRtHx8zh06BDjx4+nRYsWGI1GrwvpcYXvU7UdGRnp004zTUfzStYVikwmIzw7Gv+Dc7HcHoIgNNjDQXoV5TIRmyBSY1RAiRWXzcbBX3+lzQ0NQdUOm5XaslL+1iOOL7Yc42nzGIZWrSF/fxZ3tVtJQP4KaHMTb2VHYHMEIY9KoVWHVvxfeCJFrhBuzFiLLcyIX50Ui2GxHAVAp01AEAQEk2ToyQyXPz/QxaDV6igylBNtCSBn/7vU1ilo3fol749fbLeGGVK3w8E3L75Ezw4j2FsgDVDD3TJUO0vZKa9hwn2tWXl4B0t3FvD4tUkYVHIUpwrkbX8LpAwFSwVHK6Tr29IpI0Kp5ECoHKdRR9qIGyhd/TiiCPY6aQXFqjq9QX0lExYeyeDbbwHA7bZhVPeiJLuC9596nejQAQxMLsOv6iiUHyC1ja+RlVVc61V8PJGJPRNYd6icr7bm8cjgFDRK38SuAToVN3Q4s1gDfR+V/uqNPafDjs0sucHKKqRtbuoQPB6Eq+R1eejgPmTzi7EobOTd1op1DMFgcBOtcWCuAYsmhQ/jkxAEkbi6XGoOrMW/1TVnrHNiz3h25VXz+eZj3N+vZSNFwtu6xbF8bzGVZgdBSilOze3Uo/NTSfFYLfpDdLrPMft27yAgKJiIyJjmpLzNnJXM504fryM76d2w/enB51x2/cwBpyl5/pwsriAIgs+24++wM7mgnUud53L8hR7XVMfLZLKGSbR6nM7Gru56vb7RtqbgxHpNJumdPnfuXLp399UMPv7u0Wr/fA+R831eTCYTI0aM4NX6FBgnctxQGjFiBPHx8cydO5eoqCg8Hg/t2rVrFCt2sc9lM+dG80rWFUyd1opMVFJTWu6zPVivwiODN0cG8uEwf2rLqnl39my+2rqVnHXrASjYn8m//z6OZa+9QNsofzrHB/KbuyPb29xPfPs0/POXw9a5iNs+4tNNuby/9ig97nuMqDETydPKcLXwY7cqBmuRg4CAeESPiMUizZTodJJrorZWGnTqw65u5TsAc5gbQZTjFJZRWPQVNlshe+os/N/BfN482pDE9usXXiRLgLZVUpoCNQ4e0sxlaPCziG4X8qw6UsINWBxuZr/6ISs/fMf7Q+N0e3j8q518vS1PSqir9oPABNYfLKN97V5a2qyog7XkpwfyRn4pTmcVoij9KNlNkqHm0Jw+fuZqQS7XcEA2jffdE8kyKsnLLOSLz3/ny9wOuIe8QtuT3CyrLU525VU3qmdg6zCiA7RUWZz8uLvo4jpV/yPz36IsvnrgQbKn3IKlSrpvu2UpfG7tRHH7xoM8p9OJzWa9on6c/Pz8UYsqjE49v9qSmC/cR0Fcd5LbSzPGIShAEEgXDrFGPR3ld3eftc7r2kfSNsrI+G6xON2Nz7VdtL/X8Mqq7saSXe+wq+g+BJkA3e6BicugXYMbi8fjQbm4AvHdY+TmHG6iM2/mr4xOpTjt38kTLBdb9s8gNTWVjRs3+hgiGzZswM/Pj5iYmHOuR6lU4nb/ub8Lqamp5OXl+azYZGZmUl1d7c2TGhoaSlGR73t5165dTdL+pk2bGn1OTU09bfnw8HCioqI4cuQISUlJPn+JidJ4pkOHDuzatYvKyspz7kdGRgbWE0SxNm3ahMFg8Fnha0rS09PZt28fCQkJjc5Dr9dTUVHBgQMHeOqppxg0aBCpqalUVVWdveJmLhnNRtYVjE0nBSFaK30VgYL0KgQRRKsLnB4yQ3QEK5SonU5qiqWXWkhcAqJHxOP2YLdYuL2HlKdsXZ2RkbPmIKTfAW1vpihpHOUmOyqFjC4twwhRKvDLrkORYyJfE8aSgN7YCtrw4bQ11NZKhoVen4zH4yHYIg2GQ6KvzkTEJ6JNCEAQFQhWycfdbD5Isd3J/IJyfiir8ZbziB4MVhvhatAoZYQJVdwo/4N4xX6iVXvJ3FDIrWnSD+RaczAej4inXr1tb0ENX+0o5Pn/7kNxwkrA76s30r9iHckVn6O2u4kweUioKGHv8i8BUCqDcddJdbivvnAsL3nHjpCxbTOVFWUsV/uxPaE1FkMSoqDFrgzGEtgOG1piArUkBPvGWC3Z0VixUS4T+FuPeIa0CScx1Hc2dE9+De/+dojd+dXn1cejllpyxSjKRCVUSwZumdyDXa4m8BTP+e6tmyh/dhubX/zuvNq5lASFSM+wHDmpKhU9lNm0NvgREC5d0xb1Sn77xTisoopitxGcZ3ZD1Sjl/Di1L5MHJjcapIIkqy9UlzKs9BeMukq+TYtiZZSCz556CtspfuQrK8vQeTR48BAVc2YZ/maa+Svy4IMPkpeXx5QpU9i/fz/Lli1j9uzZTJ8+/bxEdBISEli1ahXFxcV/2oB68ODBtG/fngkTJrBjxw62bNnCxIkT6devn9dNb+DAgWzbto2FCxdy6NAhZs+ezd69e5uk/a+//pqPP/6YgwcPMnv2bLZs2cLkyZPPeMycOXN4+eWXefvttzl48CB79uxh/vz5vPHGGwCMHz+eiIgIRo4cyYYNGzhy5AjffvvtGVX3HA4Hd911F5mZmfz000/Mnj2byZMnXzIRpIceeojKykrGjx/P1q1byc7OZsWKFdx555243W4CAwMJDg7mww8/5PDhw/z2229Mnz79kvSlmXPj6vB/+R/FYxSoVK/Apd5KaamasLBhAATVB57Ld1Qgd3hwh+q58YH7EWQyjFGSe5Rap+Pe9xdgCJT8i4e3V/PcDyqKamys2l/K0LYdYMx8Vm8+BuyhU2wAaoUMpcWN83Ct98EIdkvGgEqjwGo7AjQYWSU9nTjKq+kT1+D7fLXSoUcPatpUEVbdhdLSHzCZD9ImvDdT48JI0TekFrhl1ixU9W4IQxfvZNkuDzOc92MWNbSRdcTf5qFFiZPkMAPd/QTUKjtyhbQs/+s2SZ1tkrAc2deLoOM4svz7klthJkIdQQQhtMt3MfKaYMp+mcu60BLatQeNOgKHuV71R3f1ulUd+2w78bURHBy6h8HJ7YnQCkTlBSMTLFwz6TXa92+Y/bs5PcZHze77jEKeuiEVtcL3/O/v16KRGyHA8n1F/Pv3bI6Um3ljbKdTdyhvC/w8ExJ6wxBJ0WuAtghBfIsoXRvKLJJRVSaXVm7CT5HM2OVwAkrc8itnJUulVFMrN2N06+mvDOSePn0AKDwkDcCCPDJaWQ/Spi6Lcfrp7PbvwHozRAdcWHv/zSjE4fKgtVWRbM6mqi4cY2kLAq0VZMsFlLrGoiTF+fkEAJWqWuKuQiGXZpq5WKKjo/npp5947LHH6NixI0FBQdx1111eIYRz5fXXX2f69OnMnTuX6Ohojh49emk6fAKCILBs2TKmTJnCNddcg0wmY9iwYbzzzjveMkOHDuXpp5/m8ccfx2az8fe//52JEyeyZ8+ei25/zpw5LF68mAcffJDIyEi++OIL7wra6bj77rvR6XT885//5LHHHkOv19O+fXum1cdbq1QqfvnlFx599FGuu+46XC4Xbdq04d///vdp6xw0aBDJyclcc8012O12xo8f30jqvimJiopiw4YNzJw5kyFDhmC324mPj2fYsGHIZDIEQWDx4sVMnTqVdu3a0apVK95++20f2fxm/lyajawrGHmABoepCEF7GJP5IGFIRlawvj7nkEMa2FWaHfifwr3guIEFkP3HGka01FHoCiTcqMHtEVl3sIy56yTDqUAnELsmg6khUj6h4dU7qBM0WLXSEnxQlMbrLqjXJ6NQKLhmxIUpMF2J+Bn98TP643BKGnFWy1ESNCqeaOkb06M6wc97dHoMy3YVssIjKSkVye3cjJqDvxfywQPtadFRWlFwuj2sPlDGjwelGK4h2kzI2gwR7VmSnUi+NoZydQyTayTjuV+XKFas0+ISpBU0lTqM0PQEDgYUEtYy/tJeiEuIXSMlybXVmOle9waxRV8hC5xIJn0xVTkgbyvkb4GkwYxKi/UxsmqsTn7LKmV4e9/VpJMNLLvLzaqsUpbtKgSgx5nyY5VmQuEO0DWUEUp204FdaGqCKQcsqjL+ZtlMsdNAhDG9URVuhwtQ4pFdWQqbJpUVo1VPXWU19ro6lr72OpU2OyKDcJuchMitxNgKsck0ZBg7sHRnAQ8NOLvSn9PtYWVmCdUWJzenR7NiXzEv/phFaZ0dnTqUdUG9SPE/TIvawwxRtSDEWI78jSRofT2MapBnri4qIwA9tbqrU8ilmWZOZvXq1Y22ncrgOdE9sF+/fmzZsuW86ly6dKnP5xEjRjBixAifbc8++2yjwf60adO8BsXZOJd24+LiWLZs2RnrmTNnzhklzU/VzrkQFRXFL7/8csp9CQkJjWLBjnPbbbdx2223nbbe+Ph4n5xbJ3KqawpnP8fTcSHPC0hqjEuWLDltvYMHDyYzM/O0dZzq+gQEBJz2mjVzcTQbWVcwuiA/FBUBANjtDUn+gvQNQgppdjnJJoHczAri20iDxezVq8nJyGDwww8DkgDGqo/fx89qZfacV4mJDWDG1xl8s71BwahQ5sElQpXJgSC6ifM3Y9e6EWpKgEQCogSMAd2wWo+h1Z67v/jVhlYruS5ZbWdXB+oeYyDCqKG4Vgr0z1Z6EBNE4gt3sm6xmvi2wczdkMNH63Moq5MEK+QyAf/rZ0PVJlwtr+W7jyVjIMItA0GGRydHo1Ny05NPciTnbXJytqNWh5PasTtc5QuG7nr71FVrQ6UKAcAjFuCW2airtMH6N+DATyDIie1xP90Tg7zJhAG+3ZHfyMg6Tl6lheveWofF6cbtkX4sVAoZfVNCTt+h5KFw62egMng3VZUdAh2Yy02s17lo6zyKK8RIaEkdEf6NpcstJbWAFpf6ylnJArBqHGAFS3UdSr2ebKw49UpCHXZEq5ak1M6sElUUaqTr+e32fB7s3/KUq4Insv5wOQ8u2oFOJeeVn7Ok3FiAVinHgp5d/h0ZFL+ONsEHaZV6I1H75bCmFvCt11ZWB+hx+F9Z162ZZppppplmmopmI+sKxhgWjHtvAOCbkDj4BCOrLlHP6nANiQdLeaBNMMW7d/Pp778jE0V6lpez6ftv2L9+NRFJrbDW1hCdIq1MDWkTzpId+dSPR/FkVvNYbBi2GgcGlw2PxYnG7cGjSgQrBEdE0K7TAm+7+/dmYLfZiE9KIiDgDKsFVxH7du+g5I8DkAJWa4PcaabJygd5ZbzWKhalTGDbos9ZuzuDGK2Wkd3H8Z810gpfOJXcZXsUdZCb2onbkStkVFkclNXZCTGouDk9hlu7xhIbagB6s25/KZ7KXciUAaQ4lZT6y/l8sD+bdx/hsw4tCA+7Dq02zivDfbUjO57I2uRGrY5ABAptR7HqCynNqSZDayXW2ImgAMnQHd05xsfIWn2gjHKT/ZR5mu77dDt1dmnAH25Uc0vnGMZ1jTt9fiwAYyQYfWeA9xha4va4aBfSmo0qJ3VOP9oW1XBYHsEdJ7kLejweArOlc1KlBpzn1bi0uHQiVIGj1srA9SvI7nczL1f8QpIiFkNQEHUhSj7Jc5Es5PMvxQeINQK78paSFhd4xnqvSQ4lJlDrzWMWHaBlTJcYUsL9eHDRDgBCFPWrU24D9Hsc2o6U0hWcgFAl3StZ0OlzdDXTTDNNz7Fjx87oWpeZmUlc3OWJk1y0aBH33XffKffFx8ezb9++P7lHF8aVfI2b+XNpNrKuYFqmtCZfmw1HfRMSB55gZBUGKagMU7I138IDQESHDoR+tgh/lRJbVRXFhw9gM5to228Qqb37IdQHZMaH67H0j0BW50S5qxLBJbJyRyEtQw3UKfXM9R8IoodHHTLAQ1CUr7BA4S9ZpJRGs6vbevrffNOfcDUuPS6HkxaFbchOAbutGI/HiV2UMy4jm1KHi3itiukJEShUSmq1WvKtVkanR3uNrBKCyPLE0ioAAtSVQAJj2keRpNfSNyEIpVyGVi3du/z9+1jx3R+MLlqOCFQF3EpFWCQmBVQ6pAGoXp+EXp8k5Uxbuxr/kGBapqSiUFydX1tVgGTwKMwChURyF4tQBDu5l/3YLXX8eshFYqf+3Nz6OgCGt4vgmWV7sTml1Q6XR+T7XYX8vU9io7r/cUsHvtmezzUpIVyTHIpCfmGBxx8ynHLhVt4MkYQ29urj2auPRxAgzM/XyDq4fy/htiDsgoNOfXpdUHuXCnmMjkPOArTBIbgFAaegRmybQo82Um4UURSJD9bhqFQwQJ6BXVTy4vajZzWy5DKBt8Z14r8ZRQxKDaN3yxBkMoFf9hUT6KjCIVPxiWESFQQyNbOaUcpyDOGNVb+09SkJ/grKpM00czURFRV1RpW/qKizpL24hNx4442NJNaPc1xy/Epxa1uwYMFp913J17iZP5erc7T2P4JKqSYkNIWco2A/YSVLKZdh1CiotbmQ55sZUeCmRYUbj0dEJhN44JWXveo23W8ehyh6iG3T3mtgAXyxLROUKkSVnGhTGSM9Gaw60oq11QkN7SBDZpUGuAHhvo+KoU6agTaEn3viviudpNQ2lH1jIeGPF1DfkY5MpkQLvJISw6eFFUyKllzPUgYN5kaPh1YDBqAP86NDjD+786X4qbscM+gT0Yp36nMCqWvdlH+Zw7duKfathW4zrfqF8/0X3xAqynAjwybXsMSo5YkeEdybHsWazz7jja8/onN8PP0efJDqqgqifpID1XjmuOEqNbL0wf6AB71FTZguGLsgYhc0PPT8JJxVpeRlxhMc3TC756dRMqxtBEvr46tAchk8lZHVLtqfdtHnMWB3O2HvEghOgqg0KSk3kKioROesxZ4HQW4ZlTIRBAjWq1EpfA23/E37aU0kueFltDQYT9XKZaP/qBu9/z+z/0PKC5+ivTAYuBWQYtlGpQby3xUm3nDeyHplOjkZxTw5wt1IXORkOscH0Tne93tfY3UyouRH/F11LJQ/RIkQyZZDyzFuPcBNTz7ZuJLu/uwvKKZ1cteLPtdmmmnm3FEoFCQlnT3+8nLg5+fnk0D5auVKvsbN/LlcnaO1/yHUKinjt8NRjsfjQiaTblmwQU2tzYWpyk5qjYAagbysSuLbBvvIhyZ1aTwr9MfHHyPLyeF6s4GVIWnc6MzAEmpkUPVBvqj1J8ZjI18TigBE9g5HZ/GwJ2scDkcF7du/i5+hEyE2aUAbHhN96S/Cn4Re78dufSWxphiOHThGTGwrAK4LDWB4iL83XkUXFEj6rbd6jxudHuM1sqow8ktmCbU2J5hdrPniAGqddM9cDjd99R9i2FlJXNQg/lubxOaALihFJwqFnFt6xhOoV7Ej/yi5Wi0uwx7Ky3+nvNSIAahRmIhRX73uVcER4UARgTYDoZpQXhfHEijUoFfvQoiMJjCy/lly2aXkwEoNozvH+BhZ+wpr2V9cS+uIizRqqo/Bd/eCUgf/1yAPv7THDdjMbhbM3MBEmZVt7GefJooI/8Yumwl92rFf2EtQ6qXJidJUtDUGklVYiql0HwcLf8eYmI7V5KSrshR36UqKVWHsiE4Bm4dVWaVcd5q4tzNRbXEgIiDK4GH+Sa3oT3iZho6aOsjdCPE9fcr3uvbapjq9Zppppplmmrkiac6TdYWzcflGEGUI6HC5GvI1HRe/EAXYo5YSEW75IcdnKb0mL4+KQ4ca1VlZWoZHLifZXoKsxs636nS05bX8JLZhsHkPgwOOck/NbzgE6H1TS4be2waLJRuHoxSVMoTionxUohKn4CIi6soeYJ4v5jApN5LlmG++kRMFATZWm3B6Gq7ziI5RKOUN++0uD9/vzMdoy+Rvz/fk7//sy9//2Zebp7Wh2NmKOncIy6Lu5/eQftjkehzyAAa2DvO6gY667z5Gp3eAmF/I2H03NeWSkVGrtlyy8/4ziIiMYX+bYgp72VEogogUSlGLFhyOioZC39wFL0ZKAhhAr5YhRJwUC3WqnFnnjcsG8X0grod3FcvtcvHW327m44fvQPRYsakKSQqr41b71kZ9AEhKacPgO8eS3qP3xffnEuDxeCgtKUKlklxTyupy+H7lSr79x3Z+nZ9Ju7SOWPRhFGvCJKMWWLIj/0xVnpY6m4tPYyewOmEC8eTSTtzDuE6BJNjWUbp+IWZz3dkraaaZZpppppm/EM1G1hWOq8BCyq8fIhY9g0rVIDBxosLgFrWTQ1FKnk+BXXvLAFj5rzf517x5/PrZZz71iaJIq7sfpKxY4ANDfxBklKkCed8wiKPaCPwEaRWhzqNCp5IT5qfGaj2Gx+NAJtOg1cZSki8NxCrUNV4/6b8KijAd5qBMBMO3FBR80Wj/u7kljN55mI3FZaz9zwd8/vQzBGgVDGgV5i2jxkHfFcNh7kCoyPZuD0kM40Dsqyws+xB1va5GvEvGg7UaepULvJ1bwrLSKrRxcSQP6QGAICix1tt7Np3z0p34n4BarWHwxDFcM+J6VCoNkRGjcRS1Yd6Lb7H4pV/ZtzYLk9kOohvKpMTXcpnAyDTf1dLvdhbgcl+kKl14W7jzR7i9IYmwpaYaUfTgtFlA0ODyONCYLZhcylPmyLqScbvdHHj6Fxz/OsyxagW/MoQ1mmvQeFyIgojD6kKpCaTVg3PYEdyZfvLdXC/bxJqDZVjqYwLPh2qr9GwG14teuF06hNbXUxY9FPa2Z88bDXLLx45ms2vLJsrKipvmZJtppplmmmnmCqTZyLrS8VcgiArEGt8B9okKgyYZrErXUxqg4DO3GYDIFi1AEKiz232OW19lYtCebJZ2G4goNI69+DhgAD/WJbNS34GeKi02sxOTWcpXpNe3RBBk1BZLim91BluTnuqVgH9UCA59AYRso6JyXaP9mWYbHmCHxcGa/DwOymXkb93G+O4NsUR2VGS7wzELelzF9fkqbDVgqSSwSwg7NW7+0Ej3s7VDjgwBY6Sel44U8cC+XKkOuzQAVavDcNVI19ndoDT+l6As/AnmWW5lR3AUhSVV/PH1e3z+SzGHes+D/rO85W7p7GtkldXZWXe4vMn7s9KUz1cPPMTuO0YgCAJ7ZUn8R96PzwL6+KxkOZ1Ofv3PYrZtWIfLdf4GyZ+BXC7HrJSem5wSB/OF+1gqu4V7nn8M/2BJgKS6xMzwdhG0kefziepVnlEuxOn2sCO3+rzbq6k3sqz2SJbseodf816E1tdT3utJHGJ7YsxhHDm8H4CDG3YSssRJxlerm+Rcm2mmmWaaaeZKpNnIusJRB0qqfkqTb56ZE1eyBKCjSeS+mFCeby8lq2095FqmTJjA3a+8AoCtqoof//EPluQW4gA4wb1NdZISW5kqEI0sgPR8N1/M2YzZdBgAvS4ZAFeZ5LbmDvzrPT4RcbGItgDAV8b9ONMTwtnUI5VpSTF00GrpptOhDw6if0ooN3RoiGV5yvl3uljf4fW8ZPjjHXitFY717/LE2oP8qnFikoFchGSnZOgmp4VyR1Qw6aKDjf/5D/l71gOgVodDreQOKhhVjfpztVFWVsyuLZvIPpjFqspaNiS1wxychMKpR+MXizIsCacmBE5wz0wK86NjjK+oRZO4DJ7EUUstuWIklXLpOlfI6lfLBBnh/g1G1u6tm2l9NBrdT2Y8orvJ+9FUHJ8E0ZXV0FOVxxB9MW7RTUC4DoCqYgt+GiVCZAcKPUGscqehxsnmnIozVXtKxJwMhpX+glZWxLdpUSyLDOKzp56iZUISB8Oke3Xk110ACJXH5duv/ue5mWaaaaaZZk7HX2+U/BfDEBJATdQ6aDmfvPxPvdtPNLIAXLUO5iRHo6s3mBRaLcHJyd79a+bPZ6vFQsIXH5O0vw75UZN33529ExoZWrEu6XNUcgBmixTXpddL9cX1aUt2zxoiOrdswjO9MggPjybx3hsAsFrzGsnFJuk0JGgl8YmbnnyS6x5/nOCkJARB4OWb2xMXJA1gCwnBiob3V2ezqUwFLivZu9ZwtKIhrirBJUONgD5ATdvkIF5tFcvfN6xgdWkpOfs3ApLwidIsGRzqAN0lP/9LTcZ/1xKyxEnOmt308Nfztwg918RGIPdoCIy6ljv/9R/a9B3Q6LjRnX2FJ37ZVyyJi1wo7/WEeYOh6qh30wBtETPF5xhcK+V7Mska7v2JK1lV9XFLhXHVqJRXrhDJ8UkQZZmZ73qP4L3uY9BpIrxGVnWJhcrCfLrumM+8w515wnk3dlRsPlJ5pmpPibw8j2RzNiZ3Of6lJrqU76VUsEjvoWskNcjE3FCqKsvR1EkTC9qwK0uRsZlm/io8++yzdOrU6YKP79+/P9OmTWuy/vwVuNhr2sz/Js1G1hVOcFgYLlUtrsBDVFZu8G4/OSFrpdkBQE2ZhVULs/jhBEU2j9tNVIsWBFqtdExKJj+3Fpm1YQZ+SNsIBrcJ86nvuJEVnRKI2VxvZBkkIysltR39brqBdp06N+GZXhnIZDJ0Omk10O024XRWneWIBvw0St69Lc1HBAPgjo1hjLLPYXjlI95tYS6Bm83SPUxKD0OQSceER0QQa7PhHy5df402Gn2fKA6mlxPdqsVFnduVgCJQMlbktSKpli8ZXjSMLsqPADBV1RtNe5fAj49CUYb3uBEdGouL/Li76MI6Ya+D0kzI3wqaAO9mT+EOOpBBVGUxNk0pN7GGCVWSy2hE/UqWzWYlrlCSLw/rcmXfD1WYtAquqJY+b5o/nw9nzqLw0GpAMrL8QkKR2erQuu3o612Nd+VVY3Oe3wpdrjGJdUG98A8sZ3TtR7xR+A7T5R9x5PMnqCuvokpZi1pUseOXtQRYJL/X4KiIJjnPZpr5X0YQBJYuXXq5u/GXZ8aMGaxatepyd6OZq4xmI+sKJywiCl2llMyzqnIjHo/kanPyStZxI2v3mnxeddVyd1UpB8w2vpnzHP946imCYmKY8tJLWLsP8zlOq5TTIcaf0ekNKwUyEaKPr2SlBBAY2IuAgO4Y9K0u2XleScjlatRqaQBoteU12n/AbOOJg/m8lC0ZsgdWrOC3d94BoENMALOG+yZftaNip5iM5NgpEXFCrqvI9BCOWaXYud733MNdr7yCIVYSFNHpWtCld18Gjh1FYouUpjvJy4Q+RHL701pUkisk4LDl4lTWYqqqj/Hb8zVsnSdJf9cTqFcxsLXvRMCFKuGh0ML96+HWz0Ab4N1cVSKJbah1SqyeI9gMWjSC9H07LnxxKHMvOo+WakUdba/wSQb/SCmvm9FUH4NVXUKxv4DJUgJAVYkFpUrNTU+9zLyEuzArDERRjsFdzc5j1efVVq4shF3+HYmIKmNQy7Wo9YAgw344nITVekrDJXXB2N0G/F2SkRUVG3eGGptpppn/NRwOxyWp1+m8eNEog8FAcHDw2Qs204hLdV+v1HZPpNnIusLRaLTYLMHInDrcHhN1dXuAxkZWlcWJxyOSfm08dqWA4BFZX1xDtdWCTa1m95q1TNh7lHeLKhEVDYP9zvGBKOUyrkkJJSZQGoxFumUoEdAYlARF6klJfpLO6Z+j1cZQVlbMup9+JnP3zj/vIvzJ/PHrSlylkkvVqeKyyhxOPi4o5/OiSo5u2sIXGzeyrqyM0qwsAP7eO4HBqeFnbOP+29qR0i2cVj0iyDCIdNuUxR17jnj3J7V8nDap/yAosFcTntnlJzA8FIAAmx6NOgIRKLCUUR24D7vFxaZvv2b19jJKIq+H+oTOxzlxIgBg69EqcivM598JuQIi2kPqCJ/Ne/1bs5tOuMNS+EEeS26Jmi2KRLRKOUaNZBSXH5EM67LAWuTyMyftvdxE1hsxwXZ/5mT8wj0dB3CscwR9Bw+k763J9LtNmjRp2aYNKTEhzFZ8wh+aqdwqX31ecVmiKFJjdaIUIUEmucMe6P8gzMpD5mwNQPTANlQr6tB56g0+RR2GKyyBczPNXAz9+/dnypQpTJs2jcDAQMLDw5k7dy5ms5k777wTPz8/kpKS+Pnnn73HrFmzhm7duqFWq4mMjGTWrFk+Yjr9+/dn6tSpPP744wQFBREREcGzzz7r3Z+QkADAqFGjEATB+/k4n376KQkJCfj7+zNu3Djq6s49lYLH4zltuwDHjh3jpptuwmAwYDQaGTt2LCUlJd79kyZNYuTIkT7HTJs2jf79+/uc3+TJk5k2bRohISEMHTr0rP0SBIH333+f4cOHo9VqadGiBd988413/9GjRxEEgS+//JJ+/fqh0WhYtGgRAPPmzSM1NRWNRkPr1q157733fOrOz89n/PjxBAUFodfr6dKlC5s3bwYauwseP785c+YQGhqK0Wjk/vvvP+eB/YU8LwB79+5l+PDhGAwGwsPDuf322ykvbxCCWr58OX369CEgIIDg4GBuuOEGsrMbVI6PX58lS5YwYMAAdDodHTt2ZOPGjZwLCxYsICAggKVLl5KcnIxGo2Ho0KHk5TVMSB+/VvPmzSMxMRGNRpqkrK6u5u677/Zer4EDB5KR0eCxkpGRwYABA/Dz88NoNNK5c2e2bdvm3b9+/Xr69u2LVqslNjaWqVOnYjY3jAESEhJ4/vnnmThxIkajkXvvvZdevXoxc+ZMn3MoKytDqVSydu1aAOx2OzNmzCA6Ohq9Xk/37t1ZvXr1OV2Ps9FsZF0FxM7oSXBkHwAqKyVBhGCDr5Hl9kgDHb2/mtHFMOWHGvpVC1wzcCC3pKcTMnESv1fWsVPhhhNyPHVPDMLldGOptPHB7Z3pnhhEF500EIpOCfDJDwVwdP8BEtcaqF2WcylP+bKjN0kiFnZ7SaN93fz1/D06hNdaxRLbvSuxNjutBRmK+heJIAj869aO3NgxiiC9Cj+NwvsXF6Tj+ZHtuK5DFNf+vS2DJ7XhmM2BXIB4uYC7/gXt59eGyMjR2KxatqxdzaGD+/68k7+ERERJhpLBrcPh0nMPC3lY/x52uRa1XobVZGF7nobtzs4Q283n2P6twgjU+aYM+LYJBTDmyq7jVeFp8v3aU6wO4nf/DuwxJBDpr/F+DzxFkkS5J+LKT10QEhrOwfACDiWXoJGpcQpqqrRBpAzoTYcBscS2DvKW7dEiiEOeaDyiQLRQxqYj525kmW1Ogi3FhDvMrA3syyzeYE2JjsqSSvzqJTHDI6KwDNGxP1VSzazWXYBx3Mz/Ng6z9HdinKzLIW1z2U9d1nNCqge3U9rmtJ297AXyySefEBISwpYtW5gyZQoPPPAAY8aMoVevXuzYsYMhQ4Zw++23Y7FYKCgo4LrrrqNr165kZGTw/vvv89FHH/HCCy80qlOv17N582b+8Y9/8Nxzz7Fy5UoAtm7dCsD8+fMpKiryfgbIzs5m6dKl/PDDD/zwww+sWbOGV+qFsM71XE7Xrsfj4aabbqKyspI1a9awcuVKjhw5wq233npB10ylUrFhwwb+85//nNMxTz/9NKNHjyYjI4MJEyYwbtw4suonOY8za9YsHn74YbKyshg6dCiLFi3imWee4cUXXyQrK4uXXnqJp59+mk8++QQAk8lEv379KCgo4PvvvycjI4PHH38czxmei1WrVpGVlcXq1av54osvWLJkCXPmzDmvcz/X5wUkI2XgwIGkpaWxbds2li9fTklJCWPHjvXWaTabmT59Otu2bWPVqlXIZDJGjRrV6DyefPJJZsyYwa5du0hJSWH8+PHnrJZrsVh48cUXWbhwIRs2bKC6uppx48b5lDl8+DDffvstS5YsYdeuXQCMGTOG0tJSfv75Z7Zv3056ejqDBg2islKKA54wYQIxMTFs3bqV7du3M2vWLG+aoOzsbIYNG8bo0aPZvXs3X375JevXr2fy5Mk+7b722mt07NiRnTt38vTTTzNhwgQWL17sE1//5ZdfEhUVRd++fQGYPHkyGzduZPHixezevZsxY8YwbNgwDp0iz+x5I16F1NTUiIBYU1Nzubvyp5GXv0j8dVULcdu2W0VRFEWb0yXGz/zB5+9QSZ0oiqL42+f7xXfvWyX+tGCvWFhtEQurLeKB8jrxrf35YvT7q32OWb21QFw0e6P42TMbRafdJYqiKC791w7x3ftWibt/zxNttlLR5TJ7+7Hqq+/EvJlrxVX/+uLPvwh/Egey9oo5T/0g7nt6qeh2u89a3u1yXXSbNU6X+N17/xHnPPWU+PWcOd7t2zeuF/NmrhU3P7vkotu4Ush6YrmYN3OteGD/DrH1ql/F8N92iltKi0RRFMXKwnwxZ9d20VpXd8pjZy/b6/P89n5lleh2e86vA+vfFMW9S0TR5tvGiHVLxK6/fS++9c0SsdOMH71tjPtgo7fM2pe/FPNmrhW3rFtzfm1eZo5W7hc/X9VTXLm66yn3f7t0pTjnb2PFYY+8KcbP/EFMefIn0eY8t+f6UE6++NrY68V/jL1BHLziMzH8t53ipE/eEJc8/6KYN3OteGTWb6Kr/juSl5cjrvn+B3HDyl+a7Nyaubo40++31WoVMzMzRavV2vjA2Ubpz1TWsG3NP6Rtyyb7ln0hQtpeebRh2x//lrZ9c5dv2VcTpe0lmRdxVqLYr18/sU+fPt7PLpdL1Ov14u233+7dVlRUJALixo0bxSeeeEJs1aqV6PE0vL/+/e9/iwaDwfu7c3KdoiiKXbt2FWfOnOn9DIjfffedT5nZs2eLOp1OrK2t9W577LHHxO7du1/QuZzc7i+//CLK5XLx2LFj3v379u0TAXHLli2iKIriHXfcId50000+dTz88MNiv379fNpJS0s7pz4dBxDvv/9+n23du3cXH3jgAVEURTEnJ0cExDfffNOnTMuWLcXPP//cZ9vzzz8v9uzZUxRFUfzggw9EPz8/saKi4pTtzp49W+zYsaP38x133CEGBQWJZnPD+Oj999/3uX9n4nyfl+P9HTJkiE89eXl5IiAeOHDglO2UlZWJgLhnzx5RFBuuz7x587xljt+7rKyss/Z7/vz5IiBu2rTJuy0rK0sExM2bN4uiKF0rpVIplpaWesusW7dONBqNos1m86mvZcuW4gcffCCKoij6+fmJCxYsOGW7d911l3jvvff6bFu3bp0ok8m874v4+Hhx5MiRPmVKS0tFhUIhrl271rutZ8+e3mc5NzdXlMvlYkFBgc9xgwYNEv/v//7vlH0543vqJBSnMryaufIICuwNQE3tTlwuE2qFAYNagcneMPNQaXbw0focluw6ynUo2bK5iPsP5iK4Gyx4BQ3S4Tk6kbSUIHKsRzDXONj8/RF635LMgL+1puBgNdGtAjh0aBYlpT/QKmUOMTF/w1MhzQJ6gq5sV6mLITY+kTJnOUZkVFaWERJyZtc/WRO4jRkVchwlRXjkcjT+NeTnf4bR2AFzZS1gwKq9/L7FTUW1xozBrKOmtJYXFa+gceWTql0KRBAYGU1gZDR43FB+GAyhoGmQbx+dHsOCP456P+dXWdl6tJLuLc7RV95eB78+C6IHpu8HtbTSIooiS7rfwO7fCln3+25GCUfZjMA+fZxX9AKg76yxlJUV0+4qc3WL9osijBJww85vFxHVvi/VVSoEAVK6RSDP2YneYaZF1SGywpOwuzxk5NXQLTHorHVXVNZQJzegQOA21yIGZGVhqfWnWCWpdNYqzF7XypiYBGJiEi7lqTbTzGWjQ4cO3v/lcjnBwcG0b9/euy08XPotKS0tJSsri549e/p4i/Tu3RuTyUR+fj5xcXGN6gSIjIyktLT0rH1JSEjAz8/vvI871bmcfHxWVhaxsbHExsZ697dp04aAgACysrLo2rXrObfTufP5x7b27Nmz0efjqyXH6dKli/d/s9lMdnY2d911F/fcc493u8vlwt9f+n3ZtWsXaWlpBAWd/Z13nI4dO6LTNaj+9uzZE5PJRF5eHvHx8Wc9/nyeF5Dc6X7//XcMhsZJM7Ozs0lJSeHQoUM888wzbN68mfLycu8K1rFjx2jXrt0p246MjPS207p167P2W6FQ+Nzj1q1be+99t26SB0p8fDyhoaHeMhkZGZhMpkZxbVar1evOOH36dO6++24+/fRTBg8ezJgxY2jZsqX3+N27d3tdP0H63fZ4POTk5JCaKsXCn3jfAUJDQxkyZAiLFi2ib9++5OTksHHjRj744AMA9uzZg9vtJiXFN+bdbrc3SQxes5F1FVBWVszuLzYiS4giMD4Vp7MGhcJAkF7lY2Rtz63inyv2oxJBRMnWTgbsiSpUW8qR1UmBn3IRRplVJLrk5AQoMRo19P9ba3789252rcqjRVoYkS39MYZILoPmw9JyqUYTBYCqul71LsyPvyparY4KVS2hjgAKc3NPa2Qds9pZXVnHzeGBGBRyKnNy+P3TT+kzejThbdued7u3PP00Zfv3U277hgMHZxMZeQuOqm6AAadBPOvxVwvubnqOOGpJatEeT4Eak8mBzV6EwXCCsMonIyB3A9wyH9rd7N3cLtpIcpiBQ6UNKQh+3lt87kaW0wZd/g5VuWBsyGtmra3h/Xv/hkKlxx46DI+xlD6ltewjzit6cZzQ0KtHFc/j8VBVVY7FZEKhMOJy1bIyeyudKzTs3xFIUJSelG4RDJx4J78es/GLQvoRluFh85GKczKyPP7hLIi7nd4WGb2FKcRXVSJQiT09HVaBRf3XS1rezGXgiXrFXOUJqSx6PQw9HgTZSUOZx6Tcjii0Ddu63QOd7wDhpEmxaXsal71Ajrs2HUcQBJ9tXrfj83BNPFWd53L8hR7XVMfLZLJGKVBOJUCh1+vPuc7z4cR6TSbp92Lu3Ll0797dp9zxCSCt9uLv//lyvs+LyWRixIgRvPrqq43qOm4ojRgxgvj4eObOnUtUVBQej4d27do1ihW72OfybJx8X00mE5GRkaeMdQoICACkWK7bbruNH3/8kZ9//pnZs2ezePFiRo0ahclk4r777mPq1KmNjj8+IXGqdkFyQ5w6dSrvvPMOn3/+Oe3bt/casyaTCblczvbt2xvFWZ/KmD1fmo2sqwCjMYDokkD0hS9SHqFEq40GJPGLY5UNeZcW/JGDRwSbDMpkHmrUAihkONsFoMgxISuz0cskJ9Elx4FIShtpAJXQPoRWPSI4sKmY3xZmceuTXVGo5Hg8LswWKfbqeI6sALP0AAdG+Sq9/dWoNtbgDl1KbWURHs93yGSN8yGNzcjmqNVBuFrJ0BB/ln74IcfUaqxffMHfTvKrPx2TM3Oxejw8Eh9OOz8d4W3bUrZvHtRIyoJivXGM31/nq9r7hOBmh/N6HCUBLHt/CU5LNh269KN1Dy0ei5IgmRqZxTc2SBAEhrWL4NBvh73b8qus5964IRSuf73RZlOV5BMuiiD3aFHXQrlbetYjjFduLqyzsWnVKuJWaTjqX8T6a0aQ6xJpqyzHz08a/FQWmbFbXfgFhRAy4GbcG47wuvJ9Bsp28tTheTAo+SwtQI1VekYDFQ5ElYcdHf1JC3+Uugo1oYBdc25+/s00c0ZUpxiMK1TAKZJan6qsXCn9nUvZP4HU1FS+/fZbRFH0DnI3bNiAn58fMTExZzm6AaVSidv95yZFT01NJS8vj7y8PO9qVmZmJtXV1bRp0waQVhD27t3rc9yuXbsaGRYXwqZNm5g4caLP57S0tNOWDw8PJyoqiiNHjjBhwoRTlunQoQPz5s2jsrLynFezMjIysFqtXgNt06ZNGAwGnxW+piQ9PZ1vv/2WhIQEFIrGY4KKigoOHDjA3LlzvfFG69evb/J+uFwutm3b5l21OnDgANXV1d7VpNP1vbi4GIVC0Uig5URSUlJISUnhkUceYfz48cyfP59Ro0aRnp5OZmYmSUlJ593fm266iXvvvZfly5fz+eef+zw7aWlpuN1uSktLvdesKWkWvrgKUKs15MdUISBQsSXXuz34JIXBktqG4N8v/Ozk5lWj2lIGbhFnxyDESB0dHNIXs7iVjkkjG74QfcYko/dXUV1i4cOH12CpdWC1HkUUHchkWjSaaMymOoKckptUdOzZl8KvZtz+Cmqj/kCUH8BmKzxlmWuDjXT316Os/4EccP31GK1W+t900zm14fB4+Km8hh/Lany2WyySyqBel4iifsFGFfDnz7L9GZhDJrHIMpYVoelUeqwUH6nh6K5tfLHezjLVA9Ls80mE+vkaPTXWi3elXC/U8eUDD7Fj/CA0tjDW0INvA3sADTmyfv3wS1b/80sytm666Pb+LAIj6tUcLXq+cQ3ie2E0LW8YRrfxt2AM0YAIpTm1AHRPDMaDjBZCEYGCieCC33C6zz6zWVtvZKmcGr7JeI9/lb8JPaeS0qUjRTeIBA24svOJNdPM5eDBBx8kLy+PKVOmsH//fpYtW8bs2bOZPn06Mtm5D80SEhJYtWoVxcXFVFWde17Hi2Hw4MG0b9+eCRMmsGPHDrZs2cLEiRPp16+f111r4MCBbNu2jYULF3Lo0CFmz57dyOi6UL7++ms+/vhjDh48yOzZs9myZUsjAYSTmTNnDi+//DJvv/02Bw8eZM+ePcyfP5833ngDgPHjxxMREcHIkSPZsGEDR44c4dtvvz2j6p7D4eCuu+4iMzOTn376idmzZzN58uTzun/nw0MPPURlZSXjx49n69atZGdns2LFCu68807cbjeBgYEEBwfz4YcfcvjwYX777TemT5/e5P1QKpVMmTKFzZs3s337diZN+v/27ju+yup+4Pjnufsmd2XvSUgChL1BQBDFURWldVartba2aKvW1vqz1tpa9ffr0A5trQPbWsVqnXXUgaJsZO8ZRshed+SO3PH8/nggEJNAwABJ+L5fr7yA+5znPOc5CTf3+5xzvucGJkyY0BZ0dWbmzJlMnDiR2bNn8/7777Nnzx6WLFnCvffey+eff04gEODWW2/lk08+Ye/evSxevJiVK1e2BW533303S5Ys4dZbb2Xt2rXs2LGDN95445jfd9BGt2bPns19993Hli1buPrqq9uOFRcXc+2113L99dfz6quvUl5ezooVK3j44Yd5++23v3RfSZDVR6SN1+al5lUm0di4lUjE2yGN+5FaFXjturFs+P40vl2WRYHFxLMjC4lTFeJcJh7+/nhMhsPffku8kbO/rs3FVVUI+sK4PWsBsNsHoSg6DuzXAjyvvgVXQv/eL8Kc6UAJak+zOkvjDvCLoizeGDWQGUla4Flw1ln84Je/JLuT+ehbfAE+avC0e82gKLwyfAD3FmbgffUV5v/sZ+z+9DP8B0cP4+IGYAlo3+O4xL61BuhoWnxe1q1cxsrPFrKjJcjrqblUZxYS15KNrzFEVukQskdMJG9453P1ndb2T0IPjaQck6qCu6J9drKD9vjd7FMzaDJoAZVPd7jMoemCrkozRQ2ZhFu//J4rp0pWXj4ACWEH59lauCxuB2k2bbpjWoG2FqG6XAvyxxckoo9FWFBXxPN7R/BmywjWV7g7rfdINZ+8wfm172PQ1fPqyHQWFObz/E/vIyUplbFnTWXY6K5/8QpxpsrKyuKdd95hxYoVDB8+nFtuuYWbbrqJn/70p8dVz29/+1s++OADcnJyjjqa05MUReGNN94gISGBqVOnMnPmTAoLC3nppZfaysyaNYv77ruPH//4x4wdOxav19tuBOHLeOCBB5g/fz7Dhg3j73//Oy+++GLbCFpXvvWtb/H0008zb948hg4dyrRp03juuecoKCgAwGQy8f7775OamsqFF17I0KFDeeSRR466Vcc555zDwIEDmTp1KldeeSWXXHJJh1T3PSkzM5PFixcTjUY577zzGDp0KLfffjsulwudTodOp2P+/PmsWrWKsrIy7rjjDn7961/3eDvi4uK4++67ueaaa5g8eTI2m63d974ziqLwzjvvMHXqVG688UaKi4u56qqr2Lt3L2lpaej1ehoaGrj++uspLi7miiuu4IILLmjL1jhs2DAWLlzI9u3bmTJlCiNHjuRnP/sZmZmZ3Wrztddey7p165gyZUq76YWgZee8/vrr+eEPf0hJSQmzZ89m5cqVHcqdCEX94qTZPsDj8eB0OnG73Tgc/efD59FEo1HWP/AOrYP+gS9tFYMG/S9/WzuEJxfu7rR8abqd926fSiymoqoqer2O13+3mgPbmxl7UT7jLu786fLGhRW0hqKMOi+PLVv/h8rKl8jNvZmBRT/B5/OwfeMGQi0BJp4z82Tebq+wbv13qK//sC3px7EcOe0DoHLNGporK8k7/3zO/3w7O/whfl+ay5UZiewNhGhojTDKqU1V+fPdd1NjtTIxSYdhyN9QFD1nT9vI1vsW4IjG478hkeLS41/n1Rtt3bgO2/MemowejHfP4On9FeTTivL7GhSdwi1/Ohud7oitA1QVjujXj7fVcuO8w6mK0xxmlv9PN34eG8vhDyPAlQvfXwu6w7881+x5iU92v4RSn4VxwWU8bQ/SpNfeGpfeMwOb0krTQ2vRocNyV/Exk6H0Jht/+g6uiB3vdQ4GDRne9vqGTyr4dP52cockcvFtIwA4/9GFlK59gZzgAZa5xnL2Vdcyd/rRp2f85rZbUWr3sDB3FtPyd7DBMZCibdX89MFfnczbEn3U0X5/B4NBysvL2+2tI8SRFEXhtdde67AH16l2ww030NzczOuvv35a23GqPffcc9x+++00Nzef7qacNsfzPtV/Fnr0c3q9noaiIEkt2uLGxsbFJMV3/dRqzqhsFr28g61Lq5h2TQkpOXYObG9GUWDQ5K4j/7Jph+eCu92rAXA5tREFm83BqAmTe+J2+gSrVXuK0dVI1iExVeXX5dXUhyP8ukSbi71/xQr+/sYb6FSV26ZPZ0qCHW8kxowEG02+Fq7btJ+9wRDPlBUwM8nBjOnTWbV4MSXTy9hVCxZLDjqdieaz9VQ31TMue/hR29CXpGRkEMBDQtiBsWU5F1TdRFzcANbq7iEWU/G7Q9gSLLD5DVj2Zxg8Gybc0nb+CY9k1W/XFr3Hp7YLsAAi+1YwjHU0uPVsSV3MVV43f9ZPR6dAis3MpjXrSUJHg8nN8D4UYAE0xftwue00HajB7djPv/70OH5Urvru/wBQU+5BjakoOoXxhUm8WjEdBRWP0UHazl1QWAt5XW+K7Rt0Nmsi2xlu38gP6+bT0hDH6uz7Wfz+f1FjKiWjR/SpZCFCCCFET5Dpgn1I0VkjiG/QRjMaGj4jMa7zBaR6ncKlIzNRYyohf4TK7c2E/BFS8x3klSVhTzz2E0JVVcnJ/gbp6bNxOk/NFITexmrVAqYW/9GDrLVeP4/treEflQ2saNYWUaWVlZEUiWCMxbDFxfFQcTbzWut5+f77+Ogvf6EgzoTLoGeITftelJx/Ptf88pcYXFomtvh4bXropHPPZcYVl2HrYynDjyYhIZmgoq0f9B6cjRYMVKLYGokpYTz1Wh9Em/bDvqWw+fV257u+EGQFwzGC4W4s/C6eBfdUwFef6XCooXorAIqiouqioNdGzpJtZgx6HQ3lVVo5l6/Dub1dyKmtqwrUejA4TFQnRWmyWjHpvBhMOkL+CM21WgKdMfmJeI12PEYHhUolPz/wbXjxKmju+v9AQ8IA1jmHY3d5qU02cSAtiym33IJ1cYj8T+Kprqg4JfcphDi2ffv2YbPZuvzat+/ov+9Opn/+859dtmvICWTsPV16cx8fywUXXNBlux966KHT3bw+R0ay+pD8woF8FLccVCORSBOJ5v2dlps6MJlUuwVfcQLrP67gwPYmpl1Twtd+MoZwa/eyECmKQlbW1WRlHV4g+NE//40lxcaIyZOIj++/KdwP2f5+OeRDU8OWo5Yb5YjnZwMySTIZGOfSUn4uD0ZpuulWZu3a1FYuWllBrdWKp6GeJwvTqNMbyTC3X1eXlnYJNlspiu7LZ2DqrXQ6HU0WHxkBM57GGCrgVXVUOdfiDA2jbp+XoHcHHz35NqPyJzJ6ztPtzv/iSBZoyRcsxm7sV2aKA1N+h5e3Jg0hhoXklCEsXZ+BJRYG2+GkF2qllsFQTe973xddkhn2wdZIiBtW7SFtzBT+EdITn5zIxbcNx5kaR7xTSyZSlHo4Ze1+NZX9sSQSbQZ04a7TsLsDYZKjCiaLjQ1FDpqUcyiKxXC0aqm2Xcex74wQ4uTKzMzssKfUF4+fLpdcckmHFOuHHMpK2FtWuDz33HNdHuvNfXwsTz/9NIFA5xl7ExMTSUxM5IYbbji1jerDJMjqY8657eusXfsRDY2fEqeuAzpm+ZszWpvylznQBUBTtR+/p5U4hwmj6cQ2zm1qrKdkg5a2PTah5/ZS6NXC2ofDWMR/jILw3dz2Ke1XuFv4/YEGKvMHURKJEm/QM+qqq6j73e8Yd911WOLjyQF2LlhA+bp1jJ49m8SCAoxGBy6Xlp1p756d1OytIDUni/zCY6fS7kta4kIQAF99kAfjH2YrxXw14SOSGiESjuJKz8AT0rO6MZVR9kyOWKGFo5Mgyx0Ik+o48TUcT+u/Qr3q4Ja4rWyLO/wAIf1Q0oumgwFDft+aKgiQWpLLVs9OUnLSCCtmGtVECmcUYzLHkTkwrl3Z/KSD6axVlYmNy1gYyEK9/CFGpRR3qDccDLLw+WeJ1qeSGbGxNamM57mIyf4qplXsx6JqgVtiUkqHc4UQp4fBYDihNNingt1ub7eBcl/Vm/v4WLKysk53E/oVmS7YB7lcWvY6JbKhwzG7xcDMQdoHQYvNSFKW9mR699q647pGXd0HeH1bUVVt5GvPju0A1JqbsDucJ9z2PsWezsCP/gzbf3jcp452xvGd7BTSTUZCB5+86fR6LvjRj0g6uIM5wLIFC1jsdvPBc3/rUMeu5RvIfFfPrrdXnfg99FKRg/s0tTa24NRra6qGzJjIbb/5KqPPzychI4tvPvYk3/rjMyhfSIdr1OuI/8LDgmOuyzqwCuZfC58/2+nhAYYG8tgPVeCKHg7p0p0WwuEwLZYQfl2AgpKSTs/vzcpGjGbmzVdy2fRzeNz4M57gJoKhqk7LWk16Mp0WUBQSWpuIhlU2Lf+807JbFn/Cug/eoXjz66TFfPgMeiqUPGpaoqx8+VUAArog8ba+/6FJCCGEOF4SZPVFipYZsKV5BdB+6PwrwzLbTZtypWn7Ky18YRuhQPc2BY3FwmzcdAcrVlxES8suAJr31Wp/uo49qtNfxKcnootasbqPf8D37EQHDwzM4t4BmSQaOz/fV13NgAEDSA0EGHP2NKLRIDt2PMSBAy+iqlFiHm3/J9Xe//6b6pzaNEnFE+VO+2LmqVdzqeNAW3ZGRVFIyMjSRrB2fAhvfh/8jW3nu+LaT7M8ZpC1ZxFs/Q/s/KjDoVgsyr/Hf4VHmwZhX60yO7ib7KD2UCLNYcFoNDL1J1cw4Jfn9OlRGaNOIc9qxkiE7QtfY/Pbb6PGVFa+Xc5bf1xLyK/1YUGKNpq1MmE0r6d9BXfRZIi0woZXYM/itvrSCooonTyNLQnDucT8X/6+5l7e2H09ZbXbMVi1ETKv8Tg2ihbioFjsDJktIYToc45nyqpMF+yDdq/0kuA9F3ckmVS7iVrv4Q+YXx3dfqh36NnZ7Fpdx8CxaZit3ft2+3xbiMUCGAwO4uO1Ie9YlbYmQ03te2tSTlRydgbQQFKLg5qa/5KScjY6nfmY5x1LNBzmtYceYkskwjcvvZSJN94IgNe3lX37n8FgcJKZeRU6r/Yf2fAlpsH1Vjkji9lt20tmfikY11PZ1EowVN12PBZTtTTuigIf/hxqNkDOOBippdJ3WI0caD78Ab7Zf4wga+AsUHSQ2HHrgqbKSp774XcxWRPxZ5WB0U9hjZ8KSwpZR2wCfbT9Unq75qYGDuzbAyQAsLZ6M9GdAQZfdBFbl1XjqQtQU+4hd0gSBcnxLN7ZQKVFWzdQ3hCAz34LCx+BwumQr2UYTSss4sLb7uL7977L3erH6FBxmuu5cNpXCe0NwT7wm0NdtEiIjkwmEzqdjsrKSlJSUjCZTO22xRBCiNNJVVXq6upQFKVtneDRSJDVB+WUDcL6XDp2XYjvXZjHz/+jTeWbPSKTUbkJ7cpmFSfw9V9OIN7V/eDgUOp2p3MkiqKNotibtPMdeX33Sf7xys4toIY6/APeomLTO2RlXUNpyS+/dL16oxFvMEjUbGb9xx+TNUZbg+X3a3uexcUVoigKloD239OaaOuyrr5qYGkZA/YEUjsAAETxSURBVEvLAKiprSLsC7P0lVW83vBzkpRzKZ2UwfDpqSz994s46xIYOeYmlPShbec7v/DA4JgjWaml2lcnfE0NAMRUHabWBFS/lwqTth5vVG4CoVAQs7lvB7rrnvqQAY2ZvD8jhy2Ga8ixNVBs0QLIjEInnroAVbvdB4Os9j9v5fU+OPcaWPMPyJ3Qbt8yXyhCNKbyludOfOfvJGYOkx2fwn73dsBMq7V7iXaEAC0pTkFBAVVVVVRWVp7u5gghRAeKopCdnd2tB68SZPVBhQMHsV3/AfZoPGNsHhb+6Gx8oQiDMxydPvVzpsR1UkvXmt3aGiDnwf2xAgE/aQEteMsZ0Pkmxv2RxWKlwewmrqkU8t/lwIEXcDiGk5nx1S9d96wrrsRdWcmgiy5se81/cGpmfJzWx7ag9iHYmZz0pa/Xqzln8oZ5IItTVzOhZTOmGj+1ezwYzDms/+BdImGV/G/dSWLG4T3cTnivrE6scsBL353LQM8+Jr0zgH/FZ7PXHCPDaSEn0crqB94EFexXF/XZDaHDThUaYXV0IB8YS7m6YA1XXq2NoKYXOti2vJqa3Vo+/cLk+Lbz9LEIpm2LeeUJL5f9eC16owm/x83Gjz+gbPq5NEeMWt/EFF7a/nvWWdy8MjmL0ok29qfuJtXWvxK2iJPPZDKRm5tLJBIhGpUgXQjRuxiNxm7PbJEgqw/S6/VUJteT07qPmvIdlI34dY/Wf3gkaxQAe3Zux44et8HHoLTem3r0ZGgsCOGvTCUn93vs3/8427b9DLttEHb7l/uwnTlyBJkjR7R7ze8vB7SRrHA4jDOsjSgkpqR+8fR+Yf2qFbhrGnCOHsXj9T5M2QP4qc7E2mqFmj0e9AYDk6+6DltCIvGu9iO0xxVkVa2HYDNkjwWjtcPhvQEP+9QMUkzaukOfTpumOb4gkZYWL2lBbVTLmtJ3R3F1CWYohyGNQexFO5iQeDhLYlqhlsimareHgK+VgiOCrJiiY3DdSlqs2VTv3kVWySAObNvMZy88x65VKxj6nXsxq2BQFF4ZlQ5KBu/+8QluuOdu0o8IioU4Hoem4nRnOo4QQvRWEmT1UboClf2O/wVVIRK5H4OhZ6aUBYOVhELVKIoep2M4ACVDhlF9WwVqXR06Xf9LwnA006+7nECghfh4G37/ZhoaPmb9hrlMnPA+Op3p2BUchxb/wZGs+EIa6mvQoyNClPQ+nGzhaKJvVlMQSqA6dS9fT08gVR9gzJSL2bj8M0ItEdy1AcZ85bLDJzTt0bIEls05vsQXy5+Etc/D5Nvh3Ac6HJ5urUZRH4XmLCCHFuVgkFWYRPmO7SQATUYP2Ul9N9iNS9ECqal7bEy69vBIbDQcJjnLRlK2jYYKH8vfLOesKwdi0ClEYiqqomOrrYTSnAwyi7XplgMyzWRZ3Qw9ZxbulgBPmR+m2pTG2P2zKU/IwdvcdFruUQghhOhNzqxPzP1IXtlYjIFkUFTqG1b0WL2HpgrabIPR67VphjqdjsysXMpGjO6x6/QVer0em82BougYMvi3qNF4gsH9NDV1ntb6RKmq2m4ky2Z3sO+cIHsn+jAY+uezEJ9VS6YSqD/ABVXnM7riMoz6EMk52gODmj2ew4Ubd8MfRsIr34T1Lx/fSFZcAtgzIP+sTg+Hdi9hKOtJ9x+gPnUxX/cuALSRrIa9WqrzBof3RG+zV0hM1wJEZ0AbpVr81NP85u6f8Ob//i+KTmHqldq0vs2fHaC5qoXcxMNTjFe4xhApGKlNRV77ArqnpjN7aAuDp0zHHYxSotvPFYYPucD3Cjdv/xtnjR7FonffY9F779HQUHvqb1YIIYToBXo8yPr5z3+OoijtvkpLDy84DwaDzJ07l6SkJGw2G3PmzKGmpqanm9Hv5RcWo3fnA7Bn1397rN7kpOmMGD6PwoIf9Fid/UVdrRtnzQgAdu58tUfrbm2tJRptQVH0WK252GwOJp17LtMu/UqPXqc3Cdm0NM2tDTH0ei2w2vzBv/AFtOmqh4Isd20NmzftJTzhB5AzHnIndNiQ+KhB1nkPwp1bYMA5nR6ur9oMQNAfQdVpa0BS7GYKkuOJVLUAEEnpu5kFAdKztKl7zoiN5uZKmq1eWuL1VHm14DFzYAIDx6RSOimDOIe53ZTBiM5IleHgusCBs8DswJI/CiUSpDkY5Y+Ry3jeOoWSQRtxFNcz8oorcCyJkv9JPHVVne/HJYQQQvR3J+UR+ZAhQ/jwww8PX+SIJ/F33HEHb7/9Ni+//DJOp5Nbb72Vyy+/nMWLF3dWleiCTqfDkD8Ugp9jtlYf+4QuVFX9m4oD/0Sns2AyJjJ06J9ISpradjwSibDw8Vcg2ciE2ecRH3/mbiyamZXLtkAetpogPoujR+s2mVI5a/IygsH9PT4NsbdSXAaoANUdxlSYTn2gire3rSJIEom6bGrKtSDrjV//krp9ezDc8WOKZ94LeiNOa/vMY8dMfKEobRnxvmhL6kh02NkVyWJHYyatJj0TCpNQFIW4Ru29Ky7b9aXv93RyOFwc0PuJj8YxYs0+glnT+VvCZ0wec0VbmZnfHKKlzYd2QRbA7not2CQ+CX64FUzacXcgzLLALKypJjLYQhQn0WgUR1g77kxKPAV3J4QQQvQ+JyXIMhgMpKend3jd7XbzzDPP8MILLzBjxgwA5s2bx6BBg1i2bBkTJkw4Gc3ptwYPncOKlfNwe9aiqlEU5fietkciXrZt/wXRqA8Ao7FjFruKfeWUVGURqm7FfGXHpAFnnMQxZK08j12JPZteWFEUzOYUzGZt/dXniz8jFokyoGwwSX14LdDRmBK1D+JGr8Jzsat4UxnJrLTFTKupwZiqJ6NIW0eUM2QYBpMZnd4Eem0Ey2U1kkYjNWgf4rsMsiIhMBx9+4KnDJfgVuMZalrEjjhtn7lvFSQSiURI82kJNzIK8770/Z5uVcP96AxB7IqLUMyEflA+trTDCTAOBVhwcENiFTj4Unldy+GKTIcDMHcgTFFET2NiFnfzKCVKBV+p2I8B7b0oKbF//uwKIYQQx3JSgqwdO3aQmZmJxWJh4sSJPPzww+Tm5rJq1SrC4TAzZ85sK1taWkpubi5Lly7tMsgKhUKEQoc3tfR4PJ2WO9PYbMXo9TaiUR8+3zbs9sHHdX5l5b+IRn3ExRVSWHB752V27SEXCzW2Jgb007VBxyN3aDGsrCe7KZlgMIDFcnICz+DCavI96WwNrmHyrFkn5RqnmyM1EWjFFrCQYgpCK9iKCvnmVXPblTv7Gzd32JqgsPwFPjX/klvDt/FBbAxufxhVVTtuYfCXs0BvgjlPQ+qgDm1QVZUiXQ01YQMJzRacUQW3XmVCYSIBfwvl2XVY3XrG507s6ds/5WZcoSUReWLjA7TUvkChcmun5Zpr/MQ+rWViyMBSSwSA8vqWTvvXHQjjiCnUW01UKLlkxOrYuWgx+eTi1beQbf7ym3cLIYQQfVGPr8kaP348zz33HO+99x5//vOfKS8vZ8qUKXi9XqqrqzGZTLhcrnbnpKWlUV3d9ZS3hx9+GKfT2faVk5PT083ukxRFT6xVW2uxacPxrRGKxSLs3/8cALk5N5GWdhFpaRd1KOc/oGUK8ydFvlxj+4mCohKaDV4USxPrV/+jR+oMher4fNUVlJf/EVVVicVipPi0UZyUvP6bBjv54Gh3YsjBlc5m5qlXc5t9SYdyne39Zg8cwKyEma1fBEBrNEYwHGtfyFcH9duhZpOW+KITqhrjeuMIRr9uZkyDnkv8O8iyxBiQYsPucDJz7lVM/p+v9avkI9nxiRiJ4K7ZwoI//pFP//yXdsdr93rw7PIyMmTgYKJFAuEoNZ5Qh7rcgTC2mMKU0HLuUR9gQu1qFIu2cbPXFDjp9yKEEEL0Vj3+yeGCCy5o+/uwYcMYP348eXl5/Otf/8JqPbGn/vfccw933nln2789Ho8EWgepe88mr/ZK9mSZYFL3z6ute5dgqBKjMZH09Mu6LGes1T5lGTN6JkV8X6fT6ajJ2wgDnkRtiUNVbzruaZpf1Ni4CLd7FbFYkIKC26iuqiA+ZiVClPyCoh5qee+TmpbJkkkbsKckkGxNpo5WQkHtYYuvpgYUAxGsuFK1THeqqhINhzGYTKhn/ZBrViSxJHZ4vzJ3IIzVdMT3wpYCd+3Q9smyujptQ+3uXVQ8dicFxmT8Rfno7TAyP6nTwK6va2nxsm/3LjxeLfjxunfzaUMqjkCAqUeUGzA6lc/+tQN8YfIiOvYYteB1d72PdKelXZ0+TyvFMYVkQxW57KRm4KWoQW06YdDSekruSwghhOiNTnoKd5fLRXFxMTt37iQ9PZ3W1laam5vblampqel0DdchZrMZh8PR7ktoTBlDsHgKsB44/vVYBoOd7Ozr0Ou7ntKT5NESXSQXnFmbEB+NMWswSsSMovfj9W760vU1NmmjMYmJUwCo2K2lcq+zNmHqx9OtjEYj0y75CqMmTsblGk5Ozo2kpl3Eiz/7Gb954gmefPg93n58PQCf/+c1nrj5Wla88QoA9sRUlsTKaFs0RBfrsmypMHBmx9cPanFrI7WKYsDiT8fcGGFssfazXlGxh9ZQx9GbvmrbhvXY/+mlfL2N+VzLO5YJZAeDDEpOJhY7PAqo1+sYOEZbqzWk9fD7Snl9S4c67dUhDChg0bIUWsxJtHq0IC5sVU/m7QghhBC92kkPsnw+H7t27SIjI4PRo0djNBr56KOP2o5v27aNffv2MXFi31/zcDoUDNfWYWV6kmlo3N/t87KzrmHypEXk5tzYZZnamipcETtRYhQUFX/ptvYXk847n6R07dl/Q8OnX6ouVVVpbNQyayYmTAbAW1EPgMfVfz7gH4vNNoTX9DfxSNMo9DY7KAoRQ4DmGj9BXxiDyUzQ66F613YA9DoFu+XQQLyKkQjN/uMfOXnbFObvN3+PTbNHYfcU85ppEuMLtWQajU9u4sDPl7Bt84aeus3TKiVTmzLpj+TwlnI5C2PDuenhh7ngRz/qsMl4yXjtodfAsB7jwVipXfILtJ/drAYt5f0fd93Dj7c8CNZBDJoyhuqLIePskpN8R0IIIUTv1ePTBe+66y4uvvhi8vLyqKys5P7770ev13P11VfjdDq56aabuPPOO0lMTMThcHDbbbcxceJEySx4grKz81lmX4RS8Ba7llcyY9YCdDrjsU8EDIajTwGsrtiPRRegyeIjL06mCx5iMBhISppKff0HNDR+RkFB5wkEuqOlZTutrXXodBZcLm2zZ7XuYLCQ0r3vY1+2e/c2KreV40hNZJ7fSnMkytdnX85Mo473/lZDk9dP1W43A8dNJCWvgPQBA9vOdVqNTG1dxJ2Gl/lX9GzcgfGHK/bVwQc/g4IpMPzqLtO3r29yU6PPImg+AIAh3kBxqp3GhjoSw9qIeUpu388sCJCWkUUV+xjUaONi01ZK7CZUNYKidPw5S823E7MZMPoiFIf1bDJFO4xk+ZpDRFSVELC9NIWgNYfyTz7g8tu/S0aGTOcWQghxZuvxIKuiooKrr76ahoYGUlJSOOuss1i2bBkpKVpq6kcffRSdTsecOXMIhULMmjWLJ554oqebcUbRn+3E592CYmph9aoHGDP2wS7LBgL7CQT2kZAw6ZjrToaNHkdrWQhrzYGebnKfl3Rwap/bvbpt6uWJaGj8DIAE1zh0Om1qoK1J2yfLltX/9xgqX7yBkk1pbM3bzZUzxpCoayE/O5lEq5OMohBN1X6qdjZTMKyIeFdCu3OdViNxniADdFXMZjEbj5wuuHcRrHsBqtfDiGu6vP7glvUMNT+N0pRPjELKChPQ6RT27txBClBrbiLb1j+mJ5uMZhrNHnL8CXw/roihw8YA0Or307hzJ+nDhrWVVRQFR4kT36oGBrd2HmS9uOEAz8QHccUUUhuD+B3xmNyNp/SehBBCiN6qx4Os+fPnH/W4xWLh8ccf5/HHH+/pS5+xxk6+mI+eXQr5L+F2v4THexUOe1mnZfdX/J39+58lO/t6SorvP2bdJrOZnNzCnm5yn7d7ey2GllQi8bU0Ni4hNfXE0qw3NrZfjwWQcs1g9u3eR0nZiJ5oaq9mSjq4V5ZH4fym7+H370KX+CxYp5FR5GTzokqqdro7PddpNfJmdBJGorwRncQdRwZZKaVw1p3amqyjcDWuJi9jPQeCRspTFzO6PA4YS9O+WlJIotnp76lb7RW8cQFSQgm4a7QpqfuWr+C5/7yFKRLhx2Vl7aYNDhyfxn/X1FFuiIEK+xr9RKIxDHoda/Y18X/vbQMFlLhGZre8jb1Oz6xJN/Dpf95Bp9cxZPwYEhKTT9etCiGEEKfVSV+TJU6NknO/jdJYBroYmzffRSzWcT2PqqrU1b0PQELC0adnBoOBdovhRXtZefnE1w8FYH/Fu906p6FhIbt2/ZZIxNv2mtGYgF5vIzFxcttrhUWlTDrvvH67CfGRHCna6JQtYMFh1/qz2b2avUuXsvI/f8Vn303tXg+R1igtzU0s+/d8Fsx7EgBXnJEQJl6InkMLVjyBMNRuBVXV9sSaeT9M+O5Rrx8XrgAgHIih6mJY47QMqGp1UPszrX9N2Wy1awusQvUedjduw5cZAUVBVRS8le032B5clMjfHCE+t0RAgUhMpaIpgDsQ5mfPrUGJanWlxtUxfuAKhoyuovjcmSQv1ZG/MJ76+ppTfn9CCCFEb9F/Nn85w2Xn5JOa9izLlp9PS8sOdpf/gaIBP2pXxufbQjBYgU5nISlxahc1aRb9/U0SD1gJTrEyaea5J7PpfZLLlUSweShZjWXUDjr2+hOPZz3r1n8HVQ1TW/c+w4f9lbi4PMqGPEosFvnSaeD7qqSMdGA/iSEHBsco9tS8x8L6WkY0NrPLoKJTqol6C6jd6yXe2crifz2PTq/nrKuuw2k9MgBSKd73Iiz7E9zwH8jt3hrPzxPHkkElG4OFHGjMZOJ5ZwGHp2zas5N6+I5PL12CCfbBC3aVt9cFuMy4igevv56EwsIOyS9ccSYS4ow0+Q+PED6/bC+7arycVaVytmrhJVsIu8kHgDM+hdZwCEdUG51MTEo5dTcmhBBC9DIyktWPmExJlJZq67H27XuG1taGdsfr6j4AIDHxLPT6rvcsi8ViJFfEkRpKwGg2nbwG93HBxHRsdSMJ7zp2FsCdu/4PVQ0DCn7/TlZ+fjmNTUsB0OkMbevjln+ygAUvv87O7ZtPZtN7jbS0LKJEMaoGYrF8fsr/8T8tV1I3fATD9HrGpJUxeU4RjmQrztQ0hp97AdNv+A4AjiOCrDKlnPymZaDooLp72QBbozFesH2DXys/ZZduANvjssjKy6I1FCI1oI2wZQ0o6PmbPo0yhxexY0wjRSlpKGqUpnAYV0FOhwDrkILkeIwqjA0amBQwsGjBPiLrm7GpChEF6vUqztxkfsxj/MFzHrUHR8OiRHG5+leAKoQQQhwPGcnqZxITzkENZaFX/TQ2bCY94/Ban7p6LchKSWk/MhWNRtHrD4+k7Nq+meRWFyGllbIxklq/K8mDcmBLmKzqBJqa9uDx/Jfc3G93mlBkaNnj7Nr9W3Kyr2fzlh/j8axjzZqvM3Lk8yQmHO5j/+paimuz2KHbQVHx4FN5O6eF0WikyeQludWFp9HMQN1eWmMmGiNw9X33dSg/81tz2/5+5EjWATWZhdZzKPve8xDfvXVABzxBCsM7CBmsJDfH0xRTSHNYCIdbKR/WRKyhlRmZk49dUR9SOngYpYOHMS4SYfSSaegj1fhazsHpGN5p+YJkG5lbWhgU7virYr0pgjPeyMAcG2+35GAPttCwbx9J6PAYW9q9pwghhBBnGgmy+hmdTodr9bdI8+Wyx9JKurY1DoHAfny+LYCO5KQZADQ3NbD2mQ9Ia3LRelkCw8doKbD3rdpGCansS65jgDXuNN1J71c2agzr3nmblFYbq1deAYYGFMVIbu43O5Q1Gp2UlvwCgFEjX2DL1nuoqXmTrVvvZfy4t9tGFh1u7U9XTv9fj3WI1xogudWFt66RH6VtxNPwW4p0PwFGHPU8l/XwKGsTDj7UTWJuNwMsgGZ3gKqPrHzNHybR0kpxcBdJ8Reg05mZcfXlJ3g3fUO8wUCKYyCNjdU01X3OB4+9QY2vhTnXfZ30oUPbyk0tTuYXKw9gVBWOnJzpV1RWmSM8/rUxGLy/x6r+m5a6dAKWrwEmvJbAKb8nIYQQojeRIKuf0el0NKdbSN+hp2VTNWjxFPUNnwDgco3FZEpk5/bNeP65k6JQFgCe15qoSCsnO6eAuHJtQbuhtH+krj5ZDAYDgQlmdJ+YsO8+G2/xv9m56xG83k3odCYiUR9Oxwhycr7ZbnRLr7cwZPDvSEycjF5naQuwWlq8pIRcAOQUnjkZHR0zc6mNRCkpHoGvZS+ehv/S3Pw5ebk3U7l2Las//IyMQWczcEIRjiQrIb+fii0bsNF+Opr7iLVD3bF70ya+t/cpWh25+JNTSVDD6HRH39agP9i+ZSMNldXY0wYAnxFo3UmTX6UuzsqS11/n8iOCrEuGZ1Lva+WDzdWEIocT4dgtRh4bl8M5g9LYsNFLmW8DA6dfyu7PWwATQWvk1N+YEEII0YtIkNUPpY0sgB1BMmsc1DesIDlpHNlZ12C3D0ZVY2xY8zmWl5tJjSVQb2omZAiT5U+h8tm1hK8Lk+NLI0aM0nGjTvet9HrjzzmHhTWvUzrje7i9MaqrX6O65vW247W17wBKh9EtRVHIzPhqu9f2l+/Ghg63wUd2ctopaH3vMHzs4SQVFssMFMVAgmsCqqryygsv0hhnxf7hBkzxCQw9O5uXHvgJdXt2U3Tl99rV4w4cX5DVUK+lMddFweJPh6j27y2b1mG2WsjKysNstnzJu+t9ml7eTo4/hTcvyOE9fsjgRjffv/ICdi5bxuRv3dSurKIo3HRWATed1fXatHCrtjeWyZhIxK1lZYzZ+n+wKoQQQhyNBFn90KBhI9ny5ms0jHuEynVezpq8CLM5FZdzNACGAW62mj+mytxI2c3TaW0NUffEOvSqjl2frqWUDPY7apmcMu0030nvZzQamfmNrwGQGXuIpMQphELVxNQIaiyCTmckM/Nr3aqrbu8BbNhpsHtOZpN7tfj4AbzqdvLMlnquSK+jODWVrfUBYlETVbvcDD07m5xBZYSDAaxfWPLjDoRRVfWYm2wfsiTTwJqb5zK+fhfDPylm+1jt/4f/5T3Yg4lsndPULgDsL/y2VvBDlS+JFXEjaGndQNqEQWSOHHFC9TVlPYIvpYmYLYPB5waoHLiXvKQhPdtoIYQQoo+RIKsfMhgM1KRGsQaSiVqaqax6mYL8wwkD7A4nebeMx5WYiMloBsB7nZuc1HSq9u9na3Arxgzb6Wp+n6XTmbBYziI9/cSyqoWqvICd1sSebVdv5/E0s37JMsL+ENMvvxRfJMbWliDL3T6+d9cPKdvayBuPraVqZzMAU7/+Tabf8G32N/ph6cdt9URiKv7WKPHm7r2t1cUi1JhyCZvKAUhMshKLxXCFtJ/9xNT+uS4u6lSgFgbVt3Lr8L2MS8hrF5jGolH2r1hB3sTuJb356crdlMc7ua9+MXO/NpvMrNyT1XQhhBCiz5Agq59yDsskbtV0qhN2snv37wgGD5CcdDUpKdp6i9S0jHblBxZrT55driQGDR1xqpvb5zU3NbB63gekN7gw3DMJm+3417MZD2bcN2XYe7h1vZvH00z+J/G0Kiail0Y51xXDnlnFcOtOoJC0AieKTsHXFMLbGMSeqE3hc1g7bhTcHAh3O8ga71/Geca/o2ssIUgx6QlWmpsaMKtaQo3U9Mweu8fexJCgrQHMaAhzzYg57Y75qqt57tFHaTIa+W5CAsmlpcesL8HdhDemYnU3n4zmCiGEEH2S7JPVTw0dM5Zmfx6qqn3grKx8if3PLuGj38+nsaHuNLeu/7HZnTg9VhzReJa9+t8TqmPMrRfivdbO4Amje7h1vduhvbJMqpGG+loSwjvIOHArnoo/AWA060nKshDR+9tGswDsZgN6ou3qOp7kF1n+9ZSxAUtsD76UJaS4D1BXUw1As8HbL9djAcSnugCI83XcAy8uNRUDoKgqFRuOvd9YY+MSfp71Jk8GPuT8MSNY8NJrLHr3PQIBfw+3WgghhOhbJMjqpywWK5PvuZq0tPPaXktpGkRSQ/wJjbKIozMYDIQma+nuizensvzjBcddR3y8nUFDR5B8BiW9gMN7ZQHUVlXidI4AdASD+wmGqtn18cdsC76HO2EDB3Y0AbBz5TLm3fFtZjUubFfX8SS/cCq1ALSGLaj6GGkD8mmu05JfeC39N0hIytR+vhKCdpqDHt7b8wlv7fg3oGUnvey66/jet77FiK8dey1hfcPHeGMLSRoO8QV5FK9JJn9h/EltvxBCCNEXSJDVzxUPvA+X6yycG29EQcEzVofJbD7dzeqXJpxzDlsLDqBDR/L7Kls2rD3dTeozvFZtXyVPbQMGg51I/Bg+5hyeLt9C1siRoKigqFRs10aaTFYrzdVVZPgrQVXb6ulukOUJtLLUdRZrGcXCxgIWN2aSnZ5EoEEL9gJx/TcFeWamtmYqLmbhhfJybih38ViFn2g0BEBaWRmJBV1nEzxSbeMqAFwJ46k/OAro0/uxyv56QgghznCyJqufi0SsBN77CvmedOrMTUw4f9bpblK/pdPpmPbNOSx+7FWKGjIJvFTJgYQEsrLzjnnuh3+eD0DxBWPJzR9wspva64TsMXBDsMEHQL11Ck/7J5Fe6+fWUhc3zv4aQTWVnFItK0hm8SBm//g+7vrMC9Whtno83Qyydjb5+adVS6ufw1rq4lJIc1jYcSgFub3/piC3WKzsGN2AIyuJcam5JFWvIVGtp6VlGw7HsHZlG8vLceXlodN1fB4XDnv4RctXqOFmft1aTFJ9FWmAx9R/RwGFEEKI7pIgq59b/Yd3KfBoSS584wxt2QTFyWE0Ghnz3QvY9LsPyfKnsPe5lWT8Tw46nY71q1bgrmlg8vmz2n1obW5uoHBfKibVSIv/zPyAqjgNUAGx5lYAJqUUUli/g4m6PURiE8kZNbRdeYPJxIDR47GtXd4uyGoOtHbrehVuL8Xhzag6HXaPC1OcEYtRT8rQPLaa9pNYmN1zN9cLTf/abABUVeX5hL/T2PgZHk9qW5AVi8X4x09/yh6DkWvPnkbRjBkd6tiz5S12UoJfiUfdXYXf5wHs+OO69z0QQggh+jOZLtjPRUq0oCpClAnnnXuaW3NmsNkc5N48lor4WlyXDGgLqOq27qfgUxtLP/igXfl1C5diUo0ciKtjYOmZub+QKUlbx2P0aiNImYmj+SU/4cLWJ4lFGtrKxWIxIsFg27+/mGGwu9MFQ94YBz6MZ9abXs5WGzkroK3PGj5mPDOv/SqjJk7+UvfTVyiKgsNeBoDXu7HtdZ1Oh0GnQ9Up7F63rtNzw2zl99zCbXVPc+7UybQ2a1M+I/Fqp+WFEEKIM4mMZPVzky8+n0Xhd8gbWYrR2DHltTg5MjJySLs3q92IVcynBQDWJSFazw61rY0zbgwCTvyDdJ1OyzoTDBw5lAOuPRRmjwXAbE7Bbi/D692M27OOlORzWPzs31m0YzcJugy+/avvEGltJbViFefWbuHDlOmoiq7bQVbV1g18b+9TBHKG4LdZSfS5TuLd9T7BYIB1y5biq2xi6ExtlNDt2diuzDlXXMH0WIzMESM6rcMX2kAcfm6aeh46RUH1HOx7u/xaEUIIIeS3YT9nMpqZceVlp7sZZ6QvBkyTvn4R5Q9/RmoogSXvvs/Zsy9m985t5HrTiBBl6PTubf7aH6VnZJOe0X6K3qDSRzCaUlkXMKOGwkTCIQJmCIe9eOoD2BJMxK//L6XhIOucQ6k1p+IOdC9hRXNDA/GAviWMQVeAmpxINBpl3cpluFKTycsrQq/Xn4Q77R2ikQjp7+nRk8qKsXZ+ya9xtjTzQv3HJCdPByB92LAuz4/FwsRi2jRNV8I4AAwt2jGjs3+mvhdCCCGOx5n52FyI0yA+3k79aC0ISP5cT0uLl92faVOxylOqz7jU7cditw/i1h0eLl2zk1dqmhgz5zIywwNwNg6jYlsTOr0e07CpLHWNw6/Xstk1+7u3Hujz4jj+9u25VE7Kx+4pxjR4KPX1NaS+HkP/12pisdjJvLXTLt5mp8baCIC3ws1epZBmEvH5tnda/sgpmrFolJcffIQn/A+we8BHYEgFoOCrY6i5BAaO7jo4E0IIIc4UEmQJcQpNunAWdeYmXBE7y15/n7Td2lqkuFGpp7llp9/yjxfw4T9fYffubW2vTU6w4zDoCEajxCcnM3z8ZHSqgYqt2n5ZqWfP5vOE0fgMNqD72QWbdXpqdRlETXpUVNJS4tpSkDcbvWfE1FpPijYSlbS3hh/kJvHv4Vnk53+nXZlYLMZrDz7Ig488QsXKlQCsf/VVFsbZeR8Tv97rwajT1tHl5RcxetIUMrNyT+2NCCGEEL2QBFlCnEIms5mWiSYACjcmUpPjY398LSMnnRmJFo6mZU0tpRvSKF+xqe21C+Mq+Lv1Ec7x/hyA7NIEACq2NaGqKs4TTHwx1fc+/6Pez+D6WvwKZCRY8NRpIzu+g3t29XemHDsAlmq4Z0AOOUlj246pqjaSp9PpaGrR5gHGJSUDkFpUxJCgj9n7t/OtnBT0Sv9Ndy+EEEKcKAmyhDjFJsycyYG4OiocdZTMGsvE++bIBtGALt8KgGHf4UAp3milxbOchoZPiUS8pBc4CVsbqNatYdW/38NpNaJTo6QHq3GEPd0KssLRGAMimxjCRnRKORH7GtIcFoKN2h5dwfjoybnBXiZ9YD4AGZ4EIpHDa9neOrCDJ5f9iPr6jwGYeemlZAaC2NK16aypQwcyZMrLfGfo2/ww1wVAfX0NH734Kkvef/+U3oMQQgjRW0mQJcQpZjAYKL51KpPv/io5eYWnuzm9RlZZkfZnUxKtIW0qW3x8MXFxBahqK7trPkFv1IH5AK2WBlav2YAzzsiM+k/4WtVrDPJtxR0IE4sdPYV4nTdEokmbbtjaaoWAh3SHhahbu6ZqPzPeFguLSgjoQlhjFvbs1tZivVPXzM3bW/hN4FIWb/010WiQ3AkT+Pb/PoIpTlv35navIhr14Q/sRa/XAuPKvXspWZeCZXGwy+sJIYQQZ5Iz49OEEL1MQmLyGZuuvSuFA0rx6FuwqGa2bd4AaPs4uZIv4EEeYPr2LGpDYUryS7C1ZFFYOA6n1UilJYOAThsJjKngaz16hsG9zX6W2KeyhlF80DCAN82DSYw3ofNqwZnBdWaMKhoMBqrt2hTJqh17AJiR6GCozcw0/edYWndRUfG3Dudtr1vLdkqwuQ5nw/Q1ugFosUiQJYQQQoCkcBdC9BJ6vZ7q5GYcNfHUbt4LI8cAkJU2i9Z9m4miY1FjIxd/8zxm6RV0eh3eYJitthI22wbBwbVBbn8Yh6XrxBVbmpr5m/HbWFQ/8WoFianJKIqCxa+9HVoT7Cf/ZnuJ1EsHEbFYmJyvrQm06HW8OaqE5trNbN4SYc/ev5CZeSVGowuAYKia12pq+LvyENNbWnjxYD3BJh9goTXuzJhqKYQQQhyLPEoXQvQaunxtSpqx4vBolN02hG+b3uQx9RbO0q/BaNKj02tvXTazAUVvaAuw4NjJLxp9HorDmyiObiPTbyPXoo1cKRNcbB1aQ1ZRQU/fVq9VMngo+YUD242qWvU60tNnY4svIRLxsGfPE4C2N9bGjd8nM7oFOy1MTjncT1GPljpftfffvcWEEEKI4yEjWUKIXiN3aDEsr8PREkc0GkWv16MoCpPSh7Bv31Jqa98lNfV8APYtX8HK/75Pnq6U3TFtbVBmsBJ3S+io1wi7DdR/YuI6tRq9Au6wNnI18ZyZJ/fm+hBF0ROf+xN+s2UVwyo2cld2BRUVf8ftXsVIg513h2ZitSa3ldf7tKmWeueZMdVSCCGEOBYJsoQQvUZ+YTF7vgXDCie3G11JS70It3s1GRlz8EaiuHd5+McbHxM2RZjq2cDuuHHMqPuYIb6t7FliY3Lx1V1eo2X9Ym6s/oCWoqGgtmBLGH4qbq3X+uztdwjv8JA+o4TBw0a2vb4gVMxnioOt6mAu3zePoG8rAIMH/R8pCe1H+8x+bQTLmmA7dQ0XQgghejGZLiiE6DV0Oh2FRaUdkoI4HMMYNfIl/tA0gGGLN1FhVjEHsjAHk/DZ0gGoNyUTQ8HX1NRl/Zu9foKGKmKxKJZGPXEt2SSlxlFXV83qZYvZv3f3Sb2/3ii83UNxdRbVW/a0e/1bOalcmKDw69wWbDl38pPYfeiL5pGScl6HOuKDFgDsSa5T0GIhhBCi95ORLCFEn6DT6agOhQnEYnwUDZJpysffnEnN4DiobGCDYwj7rdlMThvcZR0/2bqNlWMuYU6pj9K3x6G0GklLjWf76nXkfRxHuetzcn5yhqXVzzRDDXCg/TTLOL2OZ0cMB4Zz88Y9bPAFeUyfwbQcFeULGxA7rh9ITW09JQMGnrp2CyGEEL2YBFlCiF6lxedl2TP/IbExnkH3nIvFYm07dnt2HNP5lPE6HztLp7F9eQ1D9CZeB1RFR5Mpgfc31+AOhHFa22cYDEZjhEPVKKRi9/pQFCMRVDJS4vDubgHiaI2PndJ77Q2SBmTCmlZSGx20hkOYjB3XVf2mJBurXuFHBRkdAiyAwqJSKDoVrRVCCCH6BpkuKIToVaxx8aTWO0gJJbB1/bp2x1LCG0mpeYC9+/5CZrH2jCiusYXLm5djiGkZCVsjMd5cspVF8/9OwOcFQFVV1r/7PD8K38HvuYWGbQXElAgtikqG00rMfTA7nuPMy45XPGQoHn0LroidxW+812kZp9HAHwblkWMxneLWCSGEEH2TBFlCiF5Fp9NRm6IFR/XbKtodS0qajs02iGi0BdX5NkED7AotwpGuY5p3EwD6WISKeQ+y/LV/sfLNfwOw6/PlbNvwBKoaxt0cT2GLl4a0JcSMlaQ6zBi0y2F0WTnTWK1x1E/Q9rfKWm2lrq76uM7fvnUTH734KisXfXoymieEEEL0SRJkCSF6HWOBllbdXNF++p6iKOTnf491jODaujI+nhyHOZRCXODwvlpRnYF3E8/GlVPAiHMvBKA+3o5rmLbm6OOKqaBo5Sv1McwGPdaANkITl+Q46ffWG02+8Hz22WqIi1lZ99Inx3Vu5dbdlKxLwbei8uQ0TgghhOiDJMgSQvQ6+UNLAcj2pNBycMrfIakps0iyuKghlT1pMcqGj+fa79zFmsyxbWX2xeXiPu9WHCmpRFWVu5oD3GH9A5sZxYrqkfzFMJVXfEPYl5MLgDOobYLsSk06RXfYu+j1elyXDKDcWUXezLLjOjfiDgIQjT8ZLRNCCCH6JgmyhBC9TnZuAbXmJoyqgY2fr2x3TFH0zCq8lB+ov+bXym3MmJNIVqGLS4Zntiv379UHiMVUAtEYhmgzYYwEPfmEY9qolc8QR1leMn6/D/vBCCE1rX0dZ5LBw0Yy+e6vMrD0+IIsvNpUQ8Up67WEEEKIQyTIEkL0OjqdjsbsAADeTbUdjqelXcx5rhgmtZldu/4PgK+OzubKpsXc2PwxAAeaA6zY04jNoOeN8VN4LD/If7aMZJx3OwVhHcWtOsamOVEUHeVTfWwbVovd7jx1N9kLHbk/WUuL9yglDzO1aNkGza64k9ImIYQQoi+SFO5CiF4paVgOB6qq0adaOhxTFIWS4gfYs+dxCgvu5t8bKnHs3YE1w4SKiUm1m1mUMYx/r9rPhMIknCYzxZaRjNnzIfYMA2bPDuz+IeQpeqzWOKZceMFpuMPeye/3seTFd0jYZ2bEz76CXn/0jItxAS3le3zimR2gCiGEEEeSIEsI0SuNHD8Jxnd93GYrpqzs99zx9mZejGtlrC6BS6MmdtV6WThmOrEBdkItz+Px5+GIS2D57kaMRAEDimpBQSE7w37K7qevUBQdObtcxMesrFu5jFETJndZ1utxkxDS+jAhOflUNVEIIYTo9WS6oBCiT7soMwF9VMXS1Mz5d36XpXl55Dv3oyo6zPGtfPDPG9n18ccsL29gfsJZbKxLwBwoBCDOYWL7lo2sXrqY6qqKY1zpzGC1xrE/rxGApuX7j1p267q1GFQD1ZYGcvIKT0XzhBBCiD7hpAdZjzzyCIqicPvtt7e9FgwGmTt3LklJSdhsNubMmUNNTc3JbooQog9qafGyZvmSLo+fVeLgoao/ckvGjWxbM4b7Jvyam5Of5qfqfYyrWMOGA8PYsWo1K8q1wGG9rQjTwbc+q8PEvgUbSX0jxqYFy0/J/fQFOVOGAFBYnUZTY32X5cZOmYZ+bi6W2TnHnFYohBBCnElOapC1cuVKnnzySYYNG9bu9TvuuIO33nqLl19+mYULF1JZWcnll19+MpsihOiDfD4PVQ8uJ+W1KFVVnY+qmK1xpMb52/6tKk5aGs1s35XLf5fNwljTAgOG0eQPAxAf0xI1GMx6jCY9Zq/2NmhOkhzkh5QMHkpFfC1G1cC6TxYftWx2TgFlI0afopYJIYQQfcNJC7J8Ph/XXnstTz31FAkJCW2vu91unnnmGX73u98xY8YMRo8ezbx581iyZAnLli07Wc0RQvRBNpuDGnsTANtXrOu0jKIo5Gc8wp4Pf8Ke9x5lZNln/GXDnby560I+dIzkKecMHtl5ePmp7WCQZXNpCRvsfisAzjRZU3SkYJkRAOvGKLFYrMPxqsqjTyUUQgghzmQnLciaO3cuF110ETNnzmz3+qpVqwiHw+1eLy0tJTc3l6VLl56s5ggh+qhQgTYNTd3h67JM6YQ8HI6RBD021r69l4uGZbQ7vqfh8EhXVlR723MkW2gNh0hodQCQmnnm7pHVmRHTJ9OqhMnyp7Bt0/p2xzatX034D7tZ8Nj8TgMwIYQQ4kx3UoKs+fPns3r1ah5++OEOx6qrqzGZTLhcrnavp6WlUV1d3Wl9oVAIj8fT7ksIcWbIGV2i/dmQgt/feaCl6BSmXlkMQMAX5rIRWV3Wt8wcwT4ljTEXFlBTdQA9OlqVMMnJaT3f+D7M5Upid1EdWwdVd8gcWP3xdnToiBna760lhBBCCE2Pp3Dfv38/P/jBD/jggw+wWDrub3MiHn74YR544IEeqUsI0bcMKBrEetPbJLe62Ljyc8ZNO7vTcmkFDq64dyzJ2TYAchPj2Nfo71hQgWnn55ORFM+a5ZtIARrNHgolcUMHM2+6ssNrByr2UlSVDkDezLJT3SQhhBCiT+jxR5CrVq2itraWUaNGYTAYMBgMLFy4kD/84Q8YDAbS0tJobW2lubm53Xk1NTWkp6d3Wuc999yD2+1u+9q/X9YCCHGm0Ol01Ge1AODZ3Plo9yEpOXYURUFRFC4f1X40KzWiYFQh3WEhNzEOAG+ttt7LFx86CS3vX9bc/yZrfvYW7j9vQY+e3QmVDCyVIEsIIYToTI+PZJ1zzjls2LCh3Ws33ngjpaWl3H333eTk5GA0Gvnoo4+YM2cOANu2bWPfvn1MnDix0zrNZjNms7mnmyqE6CMSh+VAeYz0Aw4ikQgGw9HfugLeVgbsaWV4SM9mUxSAOS1mVKBhoBNF0ZJfFAwfRLl+G/H2zh/wiMOSQk50RzyXs03LPo2tEUIIIXq3Hg+y7HY7ZWXtn27Gx8eTlJTU9vpNN93EnXfeSWJiIg6Hg9tuu42JEycyYcKEnm6OEKIfKBszhkX73qF48shjBlgA/316Iwe2NXMeJqYGVBr0MWyqQpMuxsjBh9cX5eQWkpMrm+h2h+8aR9vf7U4no2TzYSGEEKJLPR5kdcejjz6KTqdjzpw5hEIhZs2axRNPPHE6miKE6ANMRjMzrrys2+UvvGUYW5ZUseS9PVi8YbKi2nqrj61hrhkoqdpPxOBhI093E4QQQog+Q1FVVT3djTheHo8Hp9OJ2+3G4XAc+wQhxBnJ42/l+l99Sq5HpUkXo2mAlbdum9I2XXDRu+8Rl2Bn8IhRWCzW09xaIfo/+f0thDhTnJaRLCGEOBErF31Ky7JKLKNSmDDjnGOWd8SZuP87o/nTgp3YDDruP6+4LcDy+33kL4wHYgRL/RJkCSGEEKLHSJAlhOgz3LtqKK3PYsfqAzCje+eMzE3gmRvGdni9urICE9CiC5DtSurZhgohhBDijCa7SAoh+ozCyUMBKKhPp6mx/kvV1VBdC0CTtfMNjoUQQgghTpQEWUKIPqOwqJSK+DoM6Fn/2bIvVZfv4B5Z/vjWnmiaEEIIIUQbCbKEEH2Kv0RbU6Xb7P9S9UQbgwDEnMqXbpMQQgghxJEkyBJC9CmDpowhRowCdwYHKvaecD16j5ZY1ZAgCS+EEEII0bMkyBJC9CkZGTnsddUAsHXRqhOuJ85nAiA+1dUTzRJCCCGEaCNBlhCiz1HLbOx1VBOf6jzhOuIuzqV8ipf8kuIebJkQQgghhGxGLITog2KxGDqdPCMSoq+R399CiDOFfEoRQvQ5EmAJIYQQojeTTypCiD6ruamBT15/i0Dg+DIN7ty+mU/feputG9edpJYJIYQQ4kwmQZYQok+KxWLs+v0iipa5WLNo8XGdu2/NNgoXOziwYMtJap0QQgghzmQSZAkh+iSdTkdTobaRcHhN43GdG2sOAaA69T3eLiGEEEIICbKEEH1WybTRABQ0plNVtb/b5xk82gbEpqT4k9IuIYQQQpzZJMgSQvRZOXmFlDur0KFj8ycru32ercUMgD014WQ1TQghhBBnMAmyhBB92zAbAK5temKx2DGLR6NREkNa6uiUjPST2jQhhBBCnJkkyBJC9Gmjpk0hoAuRFkxkzbIlxyxfX1+DSTUSJUpaevYpaKEQQgghzjQSZAkh+rR4m529ufWElQihlsAxy7d4Pfj0fhpNXoxG4ylooRBCCCHONBJkCSH6vIlfvwjfFXYmnXvuMcvmFxZj/EYu9bnHt7eWEEIIIUR3Kaqqqqe7EcfL4/HgdDpxu904HI7T3RwhRC9TV1dNnDWeeJv9dDdFCHEE+f0thDhTGE53A4QQoift3r0Nz3Pb8cQFiJ+awaARIzEazXz65L9JHp/P8LETTncThRBCCNHPSZAlhOhXAl4f9nAcyc0ueBOq31pBg8VNSSALf6WH5oENuFxJp7uZQgghhOjHZE2WEKJfGTJ8NOFrk9mae4AGkxuTaiQjkEyMGI0z9RJgCSGEEOKkk5EsIUS/U1o2nNKy4cRiMfbs3sG+9duwpycwYdI5p7tpQgghhDgDSJAlhOi3dDodhUUlFBaVnO6mCCGEEOIMItMFhRBCCCGEEKIHSZAlhBBCCCGEED1IgiwhhBBCCCGE6EESZAkhhBBCCCFED5IgSwghhBBCCCF6kARZQgghhBBCCNGDJMgSQgghhBBCiB4kQZYQQgghhBBC9CAJsoQQQgghhBCiB0mQJYQQQgghhBA9SIIsIYQQQgghhOhBEmQJIYQQQgghRA+SIEsIIYQQQgghepDhdDfgRKiqCoDH4znNLRFCCCFEdx36vX3o97gQQvRXfTLI8nq9AOTk5JzmlgghhBDieHm9XpxO5+luhhBCnDSK2gcfJ8ViMSorK7Hb7SiK0qN1ezwecnJy2L9/Pw6Ho0frFu1JX5860tenhvTzqSN9fer0ZF+rqorX6yUzMxOdTlYsCCH6rz45kqXT6cjOzj6p13A4HPKL+xSRvj51pK9PDennU0f6+tTpqb6WESwhxJlAHiMJIYQQQgghRA+SIEsIIYQQQgghepAEWV9gNpu5//77MZvNp7sp/Z709akjfX1qSD+fOtLXp470tRBCHL8+mfhCCCGEEEIIIXorGckSQgghhBBCiB4kQZYQQgghhBBC9CAJsoQQQgghhBCiB0mQJYQQQgghhBA96LQFWQ8//DBjx47FbreTmprK7Nmz2bZtW7sywWCQuXPnkpSUhM1mY86cOdTU1LQr8/3vf5/Ro0djNpsZMWLEUa+5c+dO7HY7LperW218/PHHyc/Px2KxMH78eFasWNF2bM+ePSiK0unXyy+/fNR6169fz5QpU7BYLOTk5PB///d/7Y5v2rSJOXPmkJ+fj6IoPPbYY91qb1ekr7vu66eeeoopU6aQkJBAQkICM2fObHft4yV93XVfv/rqq4wZMwaXy0V8fDwjRozgH//4R7fa3Bnp6677+kjz589HURRmz57drTZ/kfRz1/383HPPdajTYrF0q82dkb4++s90c3Mzc+fOJSMjA7PZTHFxMe+880632i2EEKeceprMmjVLnTdvnrpx40Z17dq16oUXXqjm5uaqPp+vrcwtt9yi5uTkqB999JH6+eefqxMmTFAnTZrUrp7bbrtN/dOf/qRed9116vDhw7u8XmtrqzpmzBj1ggsuUJ1O5zHbN3/+fNVkMqnPPvusumnTJvXmm29WXS6XWlNTo6qqqkYiEbWqqqrd1wMPPKDabDbV6/V2Wa/b7VbT0tLUa6+9Vt24caP64osvqlarVX3yySfbyqxYsUK966671BdffFFNT09XH3300WO292ikr7vu62uuuUZ9/PHH1TVr1qhbtmxRb7jhBtXpdKoVFRXHbHdnpK+77uuPP/5YffXVV9XNmzerO3fuVB977DFVr9er77333jHb3Rnp6677+pDy8nI1KytLnTJlinrppZces82dkX7uup/nzZunOhyOdnVXV1cfs81dkb7uuq9DoZA6ZswY9cILL1QXLVqklpeXq5988om6du3aY7ZbCCFOh9MWZH1RbW2tCqgLFy5UVVVVm5ubVaPRqL788sttZbZs2aIC6tKlSzucf//99x/1l8mPf/xj9etf/7o6b968bv0yGTdunDp37ty2f0ejUTUzM1N9+OGHuzxnxIgR6je/+c2j1vvEE0+oCQkJaigUanvt7rvvVktKSjotn5eX96WDrC+Svu68r1VV+5Bgt9vVv/3tb8dsd3dIX3fd16qqqiNHjlR/+tOfHrPd3SF93b6vI5GIOmnSJPXpp59Wv/GNb5xwkPVF0s+H+7m7bTxR0teH+/rPf/6zWlhYqLa2th6znUII0Rv0mjVZbrcbgMTERABWrVpFOBxm5syZbWVKS0vJzc1l6dKlx1X3ggULePnll3n88ce7Vb61tZVVq1a1u7ZOp2PmzJldXnvVqlWsXbuWm2666ah1L126lKlTp2IymdpemzVrFtu2baOpqalb7fuypK+77mu/3084HG7rmy9L+rrzvlZVlY8++oht27YxderUbrX/WKSv2/f1L37xC1JTU49Z3/GSfm7fzz6fj7y8PHJycrj00kvZtGlTt9reHdLXh/v6zTffZOLEicydO5e0tDTKysp46KGHiEaj3Wq/EEKcar0iyIrFYtx+++1MnjyZsrIyAKqrqzGZTB3miaelpVFdXd3tuhsaGrjhhht47rnncDgc3Tqnvr6eaDRKWlpat6/9zDPPMGjQICZNmnTUuqurqzut99Cxk036+uh9fffdd5OZmdnug8SJkr7u2NdutxubzYbJZOKiiy7ij3/8I+eee2632n800tft+3rRokU888wzPPXUU91qb3dJP7fv55KSEp599lneeOMNnn/+eWKxGJMmTaKioqJb7T8a6ev2fb17925eeeUVotEo77zzDvfddx+//e1vefDBB7vVfiGEONV6RZA1d+5cNm7cyPz583u87ptvvplrrrmmy6fln332GTabre3rn//853FfIxAI8MILL3R4WjdkyJC2ei+44IITan9Pk77u2iOPPML8+fN57bXXvtTi9UOkrzuy2+2sXbuWlStX8qtf/Yo777yTTz755Ljb9kXS14d5vV6uu+46nnrqKZKTk4+7LUcj/dzexIkTuf766xkxYgTTpk3j1VdfJSUlhSeffPK42/ZF0tftxWIxUlNT+etf/8ro0aO58soruffee/nLX/5y3G0TQohTwXC6G3Drrbfyn//8h08//ZTs7Oy219PT02ltbaW5ubndU7uamhrS09O7Xf+CBQt48803+c1vfgNo05RisRgGg4G//vWvXH311axdu7atfFpaGmazGb1e3yFjU1fXfuWVV/D7/Vx//fXtXn/nnXcIh8MAWK3WtvvqrN5Dx04m6euu+/o3v/kNjzzyCB9++CHDhg3r9j13Rfq6877W6XQUFRUBMGLECLZs2cLDDz/M2Wef3e17/yLp6/Z9vWvXLvbs2cPFF1/cdjwWiwFgMBjYtm0bAwYM6Pb9HyL9fOz3aqPRyMiRI9m5c2e377sz0tcd+zojIwOj0Yher28rM2jQIKqrq2ltbW031VAIIXqF07UYLBaLqXPnzlUzMzPV7du3dzh+aIHvK6+80vba1q1bj3uB7+bNm9UNGza0fT344IOq3W5XN2zYoDY2NnbZvnHjxqm33npr27+j0aialZXV6QLfadOmqXPmzDnWLauqeniB75GLd++5556TmvhC+vroff2///u/qsPh6PRej5f0dfd+rg+58cYb1WnTpnXrGl8kfd15XwcCgXbt3bBhg3rppZeqM2bMUDds2NAuuUB3SD93/2c6EomoJSUl6h133NGta3yR9HXXfX3PPfeoeXl5ajQabXvtscceUzMyMrp1DSGEONVOW5D13e9+V3U6neonn3zSLt2r3+9vK3PLLbeoubm56oIFC9TPP/9cnThxojpx4sR29ezYsUNds2aN+p3vfEctLi5W16xZo65Zs6bLDxLdzaI0f/581Ww2q88995y6efNm9dvf/rbqcrk6pOfdsWOHqiiK+u6773brvpubm9W0tDT1uuuuUzdu3KjOnz9fjYuL65Cq9tB9ZGRkqHfddZe6Zs0adceOHd26xhdJX3fd14888ohqMpnUV155pV3fHC3d8NFIX3fd1w899JD6/vvvq7t27VI3b96s/uY3v1ENBoP61FNPdesaXyR93XVff9GXyS4o/dx1Pz/wwAPqf//7X3XXrl3qqlWr1Kuuukq1WCzqpk2bunWNL5K+7rqv9+3bp9rtdvXWW29Vt23bpv7nP/9RU1NT1QcffLBb1xBCiFPttAVZQKdf8+bNaysTCATU733ve2pCQoIaFxenXnbZZWpVVVW7eqZNm9ZpPeXl5Z1e93hS7v7xj39Uc3NzVZPJpI4bN05dtmxZhzL33HOPmpOT0+7p2rGsW7dOPeuss1Sz2axmZWWpjzzySLvj5eXlnd7TiT7xl77uuq/z8vI6vaf777+/29c4kvR113197733qkVFRarFYlETEhLUiRMnqvPnz+92/V8kfd11X3/RlwmypJ+77ufbb7+97bppaWnqhRdeqK5evbrb9X+R9PXRf6aXLFmijh8/XjWbzWphYaH6q1/9So1EIt2+hhBCnEqKqqrq8U4xFEIIIYQQQgjRuV6RXVAIIYQQQggh+gsJsoQQQgghhBCiB0mQJYQQQgghhBA9SIIsIYQQQgghhOhBEmQJIYQQQgghRA+SIEsIIYQQQgghepAEWUIIIYQQQgjRgyTIEkIIIYQQQogeJEGWEEIIIYQQQvQgCbKEEEIIIYQQogdJkCWEEEIIIYQQPUiCLCGEEEIIIYToQf8P6BuCeLWhbisAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "humiditydf_mettoolbox=pd.DataFrame()\n", + "humiditydf_mettoolbox['equal'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily,\n", + " method='equal',\n", + " hum_mean_col=6,\n", + " source_units=['dimensionless']\n", + ")\n", + "humiditydf_mettoolbox['minimal'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily,\n", + " method='minimal',\n", + " temp_min_col=2,\n", + " source_units=['degK'],\n", + " target_units=['degK'], #this is expecting degK \n", + " hourly_temp=\"data_obs_hourly_temp.csv\"\n", + ")\n", + "humiditydf_mettoolbox['minimal_preserve'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily,method='minimal',\n", + " temp_min_col=2,\n", + " source_units=['dimensionless','dimensionless'],\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " preserve_daily_mean=6\n", + ")\n", + "humiditydf_mettoolbox['min_max'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily,\n", + " method='min_max',\n", + " temp_min_col=2,\n", + " temp_max_col=3,\n", + " hum_min_col=7,\n", + " hum_max_col=8,\n", + " source_units=['dimensionless','dimensionless','dimensionless','dimensionless'],\n", + " hourly_temp=\"data_obs_hourly_temp.csv\"\n", + ")\n", + "humiditydf_mettoolbox['min_max_preserve'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily,\n", + " method='min_max',\n", + " temp_min_col=2,\n", + " temp_max_col=3,\n", + " hum_min_col=7,\n", + " hum_max_col=8,\n", + " source_units=['dimensionless','dimensionless','dimensionless','dimensionless','dimensionless'],\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " preserve_daily_mean=6\n", + ")\n", + "humiditydf_mettoolbox['dewpoint_regression'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily,\n", + " method='dewpoint_regression',\n", + " temp_min_col=2,\n", + " source_units=['degK'],\n", + " target_units=['degK'], #this is expecting degK\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " a0=0,\n", + " a1=1,\n", + ")\n", + "humiditydf_mettoolbox['dewpoint_regression_preserve'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily, \n", + " method='dewpoint_regression', \n", + " temp_min_col=2,\n", + " source_units=['dimensionless','dimensionless'],\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " a0=0,\n", + " a1=1,\n", + " preserve_daily_mean=6\n", + ")\n", + "humiditydf_mettoolbox['linear_dewpoint_variation'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily, \n", + " method='linear_dewpoint_variation', \n", + " temp_min_col=2,\n", + " source_units=['degK'],\n", + " target_units=['degK'], #this is expecting degK\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " a0=0,\n", + " a1=1,\n", + " kr=6\n", + ")\n", + "humiditydf_mettoolbox['linear_dewpoint_variation_preserve'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily, \n", + " method='linear_dewpoint_variation', \n", + " temp_min_col=2,\n", + " source_units=['dimensionless','dimensionless'],\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " a0=0,\n", + " a1=1,\n", + " kr=6,\n", + " preserve_daily_mean=6\n", + ")\n", + "humiditydf_mettoolbox['month_hour_precip_mean'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily, \n", + " method='month_hour_precip_mean', \n", + " precip_col=4,\n", + " source_units=['dimensionless'],\n", + " hourly_precip_hum=\"data_obs_hourly_precip_hum.csv\",\n", + ")\n", + "humiditydf_mettoolbox['month_hour_precip_mean_preserve'] = met.disaggregate.humidity(\n", + " input_ts=data_obs_daily, \n", + " method='month_hour_precip_mean',\n", + " precip_col=4,\n", + " source_units=['dimensionless','dimensionless'],\n", + " hourly_temp=\"data_obs_hourly_temp.csv\",\n", + " hourly_precip_hum=\"data_obs_hourly_precip_hum.csv\",\n", + " preserve_daily_mean=6\n", + ")\n", + "\n", + "\n", + "methods = humiditydf_mettoolbox.columns\n", + "plt.plot(data_obs_hourly[\"hum\"].loc[plot_period],'-',linewidth=3)\n", + "\n", + "for method in methods:\n", + " if 'preserve' in method:\n", + " plt.plot(humiditydf_mettoolbox[method].dropna().loc[plot_period],':')\n", + " else:\n", + " plt.plot(humiditydf_mettoolbox[method].dropna().loc[plot_period],'--')\n", + "plt.legend(['Observation']+list(methods),bbox_to_anchor=(1, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "11a2dbe2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
equalminimalminimal_preservemin_maxmin_max_preservedewpoint_regressiondewpoint_regression_preservelinear_dewpoint_variationlinear_dewpoint_variation_preservemonth_hour_precip_meanmonth_hour_precip_mean_preserve
2014-06-01 00:00:0082.16666787.92284591.46599285.34523888.0074487.92284591.46599285.06628890.70530892.08333389.381944
2014-06-01 01:00:0082.16666790.93478794.47793486.83333389.49553690.93478794.47793487.75456493.39358492.83333390.131944
2014-06-01 02:00:0082.16666795.99675199.53989789.21428691.87648895.99675199.53989793.2247198.8637394.08333391.381944
2014-06-01 03:00:0082.166667100.0100.091.093.662202100.0100.098.360806100.094.58333391.881944
2014-06-01 04:00:0082.166667100.0100.091.093.662202100.0100.099.859545100.094.66666791.965278
....................................
2014-08-31 19:00:0086.41666778.22721287.42778284.69444487.562578.22721287.42778280.80814189.91642584.19230883.579744
2014-08-31 20:00:0086.41666787.49235896.69292889.88888992.75694487.49235896.69292889.59738298.70566687.96153887.348974
2014-08-31 21:00:0086.41666794.771545100.093.55555696.42361194.771545100.095.600597100.090.03846289.425897
2014-08-31 22:00:0086.41666797.346539100.094.77777897.64583397.346539100.096.501484100.091.92307791.310513
2014-08-31 23:00:0086.416667100.0100.096.098.868056100.0100.097.644056100.092.65384692.041282
\n", + "

2208 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " equal minimal \\\n", + "2014-06-01 00:00:00 82.166667 87.922845 \n", + "2014-06-01 01:00:00 82.166667 90.934787 \n", + "2014-06-01 02:00:00 82.166667 95.996751 \n", + "2014-06-01 03:00:00 82.166667 100.0 \n", + "2014-06-01 04:00:00 82.166667 100.0 \n", + "... ... ... \n", + "2014-08-31 19:00:00 86.416667 78.227212 \n", + "2014-08-31 20:00:00 86.416667 87.492358 \n", + "2014-08-31 21:00:00 86.416667 94.771545 \n", + "2014-08-31 22:00:00 86.416667 97.346539 \n", + "2014-08-31 23:00:00 86.416667 100.0 \n", + "\n", + " minimal_preserve min_max \\\n", + "2014-06-01 00:00:00 91.465992 85.345238 \n", + "2014-06-01 01:00:00 94.477934 86.833333 \n", + "2014-06-01 02:00:00 99.539897 89.214286 \n", + "2014-06-01 03:00:00 100.0 91.0 \n", + "2014-06-01 04:00:00 100.0 91.0 \n", + "... ... ... \n", + "2014-08-31 19:00:00 87.427782 84.694444 \n", + "2014-08-31 20:00:00 96.692928 89.888889 \n", + "2014-08-31 21:00:00 100.0 93.555556 \n", + "2014-08-31 22:00:00 100.0 94.777778 \n", + "2014-08-31 23:00:00 100.0 96.0 \n", + "\n", + " min_max_preserve dewpoint_regression \\\n", + "2014-06-01 00:00:00 88.00744 87.922845 \n", + "2014-06-01 01:00:00 89.495536 90.934787 \n", + "2014-06-01 02:00:00 91.876488 95.996751 \n", + "2014-06-01 03:00:00 93.662202 100.0 \n", + "2014-06-01 04:00:00 93.662202 100.0 \n", + "... ... ... \n", + "2014-08-31 19:00:00 87.5625 78.227212 \n", + "2014-08-31 20:00:00 92.756944 87.492358 \n", + "2014-08-31 21:00:00 96.423611 94.771545 \n", + "2014-08-31 22:00:00 97.645833 97.346539 \n", + "2014-08-31 23:00:00 98.868056 100.0 \n", + "\n", + " dewpoint_regression_preserve \\\n", + "2014-06-01 00:00:00 91.465992 \n", + "2014-06-01 01:00:00 94.477934 \n", + "2014-06-01 02:00:00 99.539897 \n", + "2014-06-01 03:00:00 100.0 \n", + "2014-06-01 04:00:00 100.0 \n", + "... ... \n", + "2014-08-31 19:00:00 87.427782 \n", + "2014-08-31 20:00:00 96.692928 \n", + "2014-08-31 21:00:00 100.0 \n", + "2014-08-31 22:00:00 100.0 \n", + "2014-08-31 23:00:00 100.0 \n", + "\n", + " linear_dewpoint_variation \\\n", + "2014-06-01 00:00:00 85.066288 \n", + "2014-06-01 01:00:00 87.754564 \n", + "2014-06-01 02:00:00 93.22471 \n", + "2014-06-01 03:00:00 98.360806 \n", + "2014-06-01 04:00:00 99.859545 \n", + "... ... \n", + "2014-08-31 19:00:00 80.808141 \n", + "2014-08-31 20:00:00 89.597382 \n", + "2014-08-31 21:00:00 95.600597 \n", + "2014-08-31 22:00:00 96.501484 \n", + "2014-08-31 23:00:00 97.644056 \n", + "\n", + " linear_dewpoint_variation_preserve \\\n", + "2014-06-01 00:00:00 90.705308 \n", + "2014-06-01 01:00:00 93.393584 \n", + "2014-06-01 02:00:00 98.86373 \n", + "2014-06-01 03:00:00 100.0 \n", + "2014-06-01 04:00:00 100.0 \n", + "... ... \n", + "2014-08-31 19:00:00 89.916425 \n", + "2014-08-31 20:00:00 98.705666 \n", + "2014-08-31 21:00:00 100.0 \n", + "2014-08-31 22:00:00 100.0 \n", + "2014-08-31 23:00:00 100.0 \n", + "\n", + " month_hour_precip_mean \\\n", + "2014-06-01 00:00:00 92.083333 \n", + "2014-06-01 01:00:00 92.833333 \n", + "2014-06-01 02:00:00 94.083333 \n", + "2014-06-01 03:00:00 94.583333 \n", + "2014-06-01 04:00:00 94.666667 \n", + "... ... \n", + "2014-08-31 19:00:00 84.192308 \n", + "2014-08-31 20:00:00 87.961538 \n", + "2014-08-31 21:00:00 90.038462 \n", + "2014-08-31 22:00:00 91.923077 \n", + "2014-08-31 23:00:00 92.653846 \n", + "\n", + " month_hour_precip_mean_preserve \n", + "2014-06-01 00:00:00 89.381944 \n", + "2014-06-01 01:00:00 90.131944 \n", + "2014-06-01 02:00:00 91.381944 \n", + "2014-06-01 03:00:00 91.881944 \n", + "2014-06-01 04:00:00 91.965278 \n", + "... ... \n", + "2014-08-31 19:00:00 83.579744 \n", + "2014-08-31 20:00:00 87.348974 \n", + "2014-08-31 21:00:00 89.425897 \n", + "2014-08-31 22:00:00 91.310513 \n", + "2014-08-31 23:00:00 92.041282 \n", + "\n", + "[2208 rows x 11 columns]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "humiditydf_mettoolbox" ] }, {