diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb new file mode 100644 index 00000000..8620b1af --- /dev/null +++ b/examples/cost_curves.ipynb @@ -0,0 +1,1406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cost Curve Creator\n", + "\n", + "This notebook enables fitting curves to ORBIT models to create a cost function that can be\n", + "embedded in NRWAL.\n", + "A variety of curve and surface fitting options are available, and new ones can be added easily.\n", + "There are also tools for visualizing the ORBIT data and fitted curves.\n", + "\n", + "## Dependencies\n", + "\n", + "- ORBIT\n", + "- ipympl enables interactive matplotlib elements in jupyter notebooks via the `%matplotlib widget` magic command below\n", + "\n", + "## Instructions\n", + "\n", + "Follow the steps below to configure and run the notebook.\n", + "\n", + "1. Create a basic ORBIT configuration file including at least the following sections:\n", + "- site\n", + "- turbine\n", + "- plant\n", + "\n", + "2. Configure the notebook by setting the following variables in the \"Configuration\" section:\n", + "- `BASE_CONFIG`: the ORBIT config file at a given path\n", + "- `DEPTHS`: a list of water depths to use for cost curves\n", + "- `MEAN_WIND_SPEED`: a list of mean wind speed to use for cost curves\n", + "- Add any additional global parameter ranges\n", + "\n", + "3. Run the notebook to establish a first-pass fit for the ORBIT data. This will also plot the ORBIT\n", + "data and curves.\n", + "\n", + "4. Refine the curve fits by swapping the curve-fit function from the options available in\n", + "the \"Curve Fit Library\" section\n", + "\n", + "## Practical Guidance\n", + "\n", + "This notebook specifically models spatially varying costs typically related to water depth\n", + "but in some cases other variables are considered. The same methods could be used to model\n", + "the cost relationship for other variables. The general workflow is to first create a parameterized\n", + "ORBIT model and obtain the cost as a function of the variables of interest.\n", + "Then, fit a curve or surface to the data by starting with the linear options.\n", + "Plot the data and curve fits to evaluate whether the linear forms are sufficient.\n", + "If not, move to the quadratic or higher order curve fits.\n", + "\n", + "A class `CostFunction` is provided to simplify running the ORBIT parameterization, fit the\n", + "curves to the data, and visualize the results. An example is given below to instantiate the\n", + "class:\n", + "```python\n", + "cost_function = CostFunction(\n", + " config={\"design_phases\": [\"MonopileDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + " },\n", + " results={\n", + " \"monopile_unit_cost\": lambda run: run.design_results[\"monopile\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "```\n", + "\n", + "The config parameter is a dictionary containing additional configuration parameters to add to\n", + "the basic ORBIT configuration provided through the input file created in Step 1 in the instructions.\n", + "Any parameters given in the `CostFunction` config will be added to the base configuration or\n", + "overwritten if they already exist. The parameters dictionary contains the variables to be varied\n", + "in the cost function via `ORBIT.ParametricManager`, and the results dictionary sets the results\n", + "variables from ORBIT. Each of these dictionaries are passed directly to the\n", + "`ORBIT.ParametricManager` class.\n", + "\n", + "The fitted curves are saved on the `CostFunction` object and multiple types can exist at the\n", + "same time. Two versions of one type cannot be saved at the same time. To create a curve fit,\n", + "call one of the curve fit methods on the `CostFunction` instance. Then, an attribute is saved\n", + "on the instance with the curve fit type.\n", + "\n", + "Considerations:\n", + "- The `CostFunction` class supports parameterizations of at-most 2 variables.\n", + "- One instance of the `CostFunction` class can be used to fit multiple curves for a single\n", + " cost model.\n", + "- A new `CostFunction` instance should be created for each cost model.\n", + "\n", + "### Plotting API for 2D vs 3D plots\n", + "The `CostFunction` class handles 2D and 3D data seamlessly by using the x and z parameters for 2D\n", + "and adding y for 3D. The appropriate matplotlib API is used depending if the data is 2D or 3D.\n", + "From the calling script, be sure to configure the Axes that is given to `CostFunction.plot` with\n", + "the correct settings for 3D as listed in the table below.\n", + "\n", + "| Matplotlib setting | 2D | 3D |\n", + "|---------------------|----|----|\n", + "| Independent axis labels | `ax.set_xlabel()` | `ax.set_xlabel()`, `ax.set_zlabel()` |\n", + "| Dependent axis label | `ax.set_ylabel()` | `ax.set_zlabel()` |\n", + "\n", + "### Template workflow\n", + "\n", + "The following code block provides a template for creating a cost function for a model with\n", + "two independent parameters.\n", + "\n", + "```python\n", + "\n", + "# Create the CostFunction object with the ORBIT configuration for the parameterization\n", + "cost_function = CostFunction(\n", + " config={\n", + " \"design_phases\": [\"Design\"],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + " },\n", + " results={\n", + " \"system_cost\": lambda run: run.design_results[\"system\"][\"system_cost\"],\n", + " }\n", + ")\n", + "\n", + "# Run ORBIT via ORBIT.ParametricManager\n", + "cost_function.run()\n", + "\n", + "# Fit two curves (surfaces since there are two independent parameters) to the data.\n", + "# After running the following two commands, the CostFunction object will have two related\n", + "# attributes that store the curve fits.\n", + "cost_function.fit_curve(\"linear_2d\")\n", + "cost_function.fit_curve(\"quadratic_2d\")\n", + "\n", + "# Plot the data and curves\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(1, 1, 1)\n", + "ax.set_title(\"Depth vs mean wind speed\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Mean wind speed (m/s)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_1d\", \"quadratic_1d\"]) # These curves must have been generated first\n", + "# alternatively, the two lines above could be combined into a single line:\n", + "# cost_function.plot(ax, plot_data=True, plot_curves=[\"linear_1d\", \"quadratic_1d\"])\n", + "\n", + "# Export the curve function to a NRWAL-compatible file\n", + "cost_function.export(\"design.yaml\", \"design_system\")\n", + "```\n", + "\n", + "### Adding a new curve type\n", + "\n", + "There are a number of curve fit options in the `CostFunction` class, and more can be added by\n", + "creating a new method and connecting it in some key places in the class.\n", + "First, create a new method on the `CostFunction` class that follows the naming convention of\n", + "`{curve_type}_{dimension}` where `curve_type` is the name of the type of function like\n", + "\"exponential\" or \"linear\" and `dimension` is the number of independent variables the curve.\n", + "The function should return the fitted curve evaluated at the data points given to fit the curve.\n", + "A generic function signature is given below:\n", + "```python\n", + "class CostFunction:\n", + "\n", + " def curvetype_dimension(self):\n", + "\n", + " # Such as:\n", + " def linear_1d(self):\n", + "```\n", + "\n", + "To fit a curve to the data for one independent variable, it is recommended to use the\n", + "`scipy.optimize.curve_fit` function via the `Curves` class.\n", + "In general, a one-dimensional curve fit function will follow the form given below.\n", + "By setting the curve fit function `f`, you define the shape of the curve and set\n", + "the order of the coefficients in `self.coeffs` since they are returned in the order they are\n", + "given in the function signature.\n", + "The `Curves.polynomal_eval` function is available to easily evaluate polynomial curves, but other\n", + "curve-types can be evaluated by simply plugging in the data points (`self.x`) to the fitted\n", + "function.\n", + "\n", + "```python\n", + "# Define a function for a prototype curve; this is where you define the shape of the curve\n", + "def f(x, a, b):\n", + " return a * x + b\n", + "\n", + "# Call the scipy.optimize.curve_fit function and get the coefficients as a Numpy array\n", + "# Note that `self.x` and `self.z` are given since the CostFunction class adds a y\n", + "# only when there are more independent variables.\n", + "self.coeffs = Curves.fit(f, self.x, self.z)\n", + "\n", + "# Evaluate the curve at the data points (self.x)\n", + "self._linear_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", + "```\n", + "\n", + "A two-dimensional curve (surface) fit will typically follow a similar process, as should below.\n", + "For these types, it is recommended to use the `numpy.linalg.lstsq` function.\n", + "First, reshape the data into a new array with each element containing the three-dimensional\n", + "data points.\n", + "Then, stack the data into a column matrix in the form of the equation that you're implementing.\n", + "See the comments in the code block for more information.\n", + "Evaluate the curve at the data points (`self.x`, `self.y`) by stating the form of the curve\n", + "with the coefficients from the curve fit.\n", + "\n", + "```python\n", + " # Reshape the data into a new array with each element containing the three-dimensional data points\n", + " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", + "\n", + " # Stack the data into a column matrix in the form of the equation that you're implementing.\n", + " # Here, the equation is z = ax + by + c and data_to_fit[:,0] are the x values,\n", + " # data_to_fit[:,1] are the y values. The third column is all ones to account for the constant\n", + " # term.\n", + " A = np.c_[\n", + " data_to_fit[:,0],\n", + " data_to_fit[:,1],\n", + " np.ones(data_to_fit.shape[0])\n", + " ]\n", + "\n", + " # Fit the curve to the data; the data is the cost and these are always `self.z` which is data_to_fit[:,2]\n", + " self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " self._linear_2d_curve = self.coeffs[0]*self.x + self.coeffs[1]*self.y + self.coeffs[2]\n", + "```\n", + "\n", + "Finally, save the coefficients to `self.coeffs`, save the evaluated curve to\n", + "`self._{curve_type}_{dimension}_curve`, and add the corresponding if-statements\n", + "in `CostFunction.plot` and `CostFunction.export`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget\n", + "\n", + "from copy import deepcopy\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from scipy import stats, optimize, linalg\n", + "import yaml\n", + "\n", + "from ORBIT import (\n", + " ParametricManager,\n", + " load_config,\n", + ")\n", + "\n", + "import matplotlib as mpl\n", + "mpl.rcParams[\"figure.autolayout\"] = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration\n", + "\n", + "Replace any of these throughout the notebook to customize a cost model parameterization." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "BASE_CONFIG = load_config(\"nrwal.yaml\")\n", + "\n", + "DEPTHS = [i for i in range(5, 60, 5)] # Ocean depth in meters\n", + "MEAN_WIND_SPEED = [i for i in range(2, 20, 2)] # Mean wind speed in m/s" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "orbit_to_nrwal_params = {\n", + " \"site.depth\": \"depth\",\n", + " \"site.mean_windspeed\": \"mean_windspeed\", # Not in NRWAL\n", + " \"site.distance_to_landfall\": \"dist_s_to_l\",\n", + " \"mooring_system_design.draft_depth\": \"draft_depth\", # Not in NRWAL\n", + " \"array_system_design.touchdown_distance\": \"touchdown_distance\", # Not in NRWAL\n", + " \"array_system_design.floating_cable_depth\": \"floating_cable_depth\", # Not in NRWAL\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Curve Fit Library" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class Curves():\n", + " \"\"\"\n", + " This class contains static methods for fitting data to various curve types.\n", + " Though they could exist outside of a class, consolidating them into a consistent\n", + " namespace allows for a simpler API throughout the script.\n", + " \"\"\"\n", + "\n", + " @staticmethod\n", + " def polynomial_eval(coeffs, data_points):\n", + " \"\"\"\n", + " This method evaluates a curve defined by a polynomial equation given a set of\n", + " coefficients and data points.\n", + "\n", + " Args:\n", + " coeffs (list): A list of coefficients for the curve. The order of the\n", + " coefficients should be from highest to lowest power.\n", + " data_points (list): A list of data points at which to evaluate the curve.\n", + "\n", + " Returns:\n", + " np.array: The curve evaluated at the given data points.\n", + " \"\"\"\n", + " curve = np.zeros_like(data_points)\n", + " for i, dp in enumerate(data_points):\n", + "\n", + " # This loop sums the terms of the polynomial\n", + " for j in range(len(coeffs)):\n", + " curve[i] += coeffs[j] * (dp ** (len(coeffs) - 1 - j))\n", + " return curve\n", + "\n", + " @staticmethod\n", + " def fit(func, x, y, fit_check=False):\n", + " if x is pd.Series:\n", + " x = x.to_numpy(dtype=np.float64)\n", + " elif x is np.array:\n", + " x = x.astype(np.float64)\n", + " if y is pd.Series:\n", + " y = y.to_numpy(dtype=np.float64)\n", + " elif y is np.array:\n", + " y = y.astype(np.float64)\n", + "\n", + " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(func, x, y, full_output=True)\n", + "\n", + " if fit_check:\n", + " print(f\"mesg: {mesg}\")\n", + " print(f\"ier: {ier}\")\n", + " print(f\"Coefficients: {popt}\")\n", + " # print(f\"R-squared: {rvalue**2:.6f}\")\n", + " \n", + " return popt" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class CostFunction():\n", + " \"\"\"\n", + " This class is used to create the ORBIT parameterization, fit a curve, plot the curve, and\n", + " export the function to NRWAL format. Parameterizations are limited to up to two independent\n", + " variables.\n", + " \"\"\"\n", + " def __init__(self, config: dict, parameters: dict, results: dict):\n", + " \"\"\"\n", + " On initialization, the config, parameters, and results dictionaries are prepared for\n", + " use in ORBIT.ParametricManager. Additionally, the independent variables are extracted\n", + " into x and y (for two-variable parameterizations) and z is extracted as the dependent\n", + " variable. Whether the cost function is 3D or 2D is determined by the length of the\n", + " parameters variable.\n", + "\n", + " Args:\n", + " config (str): Configuration settings to added to the BASE_CONFIG or overwrite\n", + " in the BASE_CONFIG. This must include the `design_phases` config.\n", + " parameters (dict): Parameters to use with ORBIT.ParametricManager; maximum of two\n", + " parameters are supported.\n", + " results (dict): Results to use with ORBIT.ParametricManager; this must include only\n", + " one variable.\n", + " \"\"\"\n", + " self.is_3d = False\n", + "\n", + " # Other attributes\n", + " # self.parametric\n", + " # self.x\n", + " # self.y\n", + " # self.z\n", + " # self.x_variable\n", + " # self.y_variable\n", + " self._linear_1d_curve = None\n", + " self._quadratic_1d_curve = None\n", + " self._poly3_1d_curve = None\n", + " self._linear_2d_curve = None\n", + " self._quadratic_2d_curve = None\n", + "\n", + " # Start with a copy of the global BASE_CONFIG and update it with the configuration\n", + " # given to this class\n", + " self.config = deepcopy(BASE_CONFIG)\n", + " self.config.update(config)\n", + "\n", + " self.parameters = deepcopy(parameters)\n", + " if len(self.parameters) > 2:\n", + " raise ValueError(\"This class is limited to parameterizations with two variables.\")\n", + "\n", + " # Puts the parameters and results settings into variables for use in parsing the ORBIT\n", + " # results and postprocessing the data\n", + " self.parameters = deepcopy(self.parameters)\n", + " _vars = list(self.parameters.keys())\n", + " self.x_variable = _vars.pop(0) # NOTE: This assumes the first parameter is site.depth; it's not critical to functionality but good to keep in mind\n", + " if len(_vars) == 1:\n", + " self.is_3d = True\n", + " self.y_variable = _vars.pop()\n", + " self.z_variable = list(results.keys())[0]\n", + "\n", + " self.results = deepcopy(results)\n", + " if len(results) != 1:\n", + " raise ValueError(\"This class is limited to results with one variable\")\n", + "\n", + " def run(self):\n", + " self.parametric = ParametricManager(self.config, self.parameters, self.results, product=True)\n", + " self.parametric.run()\n", + "\n", + " self.x = self.parametric.results[self.x_variable]\n", + " if self.is_3d:\n", + " self.y = self.parametric.results[self.y_variable]\n", + " self.z = self.parametric.results[self.z_variable]\n", + "\n", + "\n", + " ### --------- Curve fit functions --------- ###\n", + "\n", + " def linear_1d(self):\n", + " def f(x, a, b):\n", + " return a * x + b\n", + " self.coeffs = Curves.fit(f, self.x, self.z)\n", + " self._linear_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", + "\n", + " def quadratic_1d(self):\n", + " def f(x, a, b, c):\n", + " return a * x**2 + b * x + c\n", + " self.coeffs = Curves.fit(f, self.x, self.z)\n", + " self._quadratic_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", + "\n", + " def poly3_1d(self):\n", + " def f(x, a, b, c, d):\n", + " return a * x**3 + b * x**2 + c * x + d\n", + " self.coeffs = Curves.fit(f, self.x, self.z)\n", + " self._poly3_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", + "\n", + " # def logarithmic_1d(self):\n", + " # pass\n", + "\n", + " # def exponential_1d(self):\n", + " # pass\n", + "\n", + " def linear_2d(self):\n", + " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", + "\n", + " # Best-fit linear plane\n", + " A = np.c_[\n", + " data_to_fit[:,0],\n", + " data_to_fit[:,1],\n", + " np.ones(data_to_fit.shape[0])\n", + " ]\n", + " self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " self._linear_2d_curve = self.coeffs[0]*self.x + self.coeffs[1]*self.y + self.coeffs[2]\n", + "\n", + " def quadratic_2d(self):\n", + " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", + "\n", + " # best-fit quadratic curve\n", + " A = np.c_[\n", + " np.ones(data_to_fit.shape[0]),\n", + " data_to_fit[:,:2],\n", + " np.prod(data_to_fit[:,:2], axis=1),\n", + " data_to_fit[:,:2]**2\n", + " ]\n", + " self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " # This dot product is equivalent to the sum of the terms of the polynomial;\n", + " # np.c_[] is used to concatenate the arrays into the correct form for the dot product\n", + " # and C is the coefficients of the polynomial\n", + " self._quadratic_2d_curve = np.dot(\n", + " np.c_[\n", + " np.ones(self.x.shape),\n", + " self.x,\n", + " self.y,\n", + " self.x*self.y,\n", + " self.x**2,\n", + " self.y**2\n", + " ],\n", + " self.coeffs\n", + " ).reshape(self.x.shape)\n", + "\n", + "\n", + " ### --------- Plotting functions --------- ###\n", + "\n", + " def plot(\n", + " self,\n", + " ax,\n", + " plot_data: bool = False,\n", + " plot_curves: list[str] = []\n", + " ):\n", + " if plot_data:\n", + " if self.is_3d:\n", + " ax.scatter(self.x, self.y, zs=self.z, zdir='z', label=\"Data\")\n", + " else:\n", + " ax.scatter(self.x, self.z, label=\"Data\")\n", + "\n", + " for curve in plot_curves:\n", + "\n", + " if curve == \"linear_1d\":\n", + " ax.plot(self.x, self._linear_1d_curve, label=\"Linear Fit\")\n", + "\n", + " if curve == \"quadratic_1d\":\n", + " ax.plot(self.x, self._quadratic_1d_curve, label=\"Quadratic Fit\")\n", + "\n", + " if curve == \"poly3_1d\":\n", + " ax.plot(self.x, self._poly3_1d_curve, label=\"Degree 3 Polynomial Fit\")\n", + "\n", + " if curve == \"linear_2d\":\n", + " ax.plot_surface(\n", + " np.reshape(self.x, (len(DEPTHS), -1)),\n", + " np.reshape(self.y, (len(DEPTHS), -1)),\n", + " np.reshape(self._linear_2d_curve, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Linear Fit\"\n", + " )\n", + "\n", + " if curve == \"quadratic_2d\":\n", + " ax.plot_surface(\n", + " np.reshape(self.x, (len(DEPTHS), -1)),\n", + " np.reshape(self.y, (len(DEPTHS), -1)),\n", + " np.reshape(self._quadratic_2d_curve, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Quadratic Fit\"\n", + " )\n", + "\n", + "\n", + " ### --------- Export functions --------- ###\n", + "\n", + " def export(self, filename: str, key: str, comments: str = \"\"):\n", + " \"\"\"\n", + " This function writes the curve equation to a file for use in NRWAL.\n", + "\n", + " Args:\n", + " filename (str): The file to write the curve equation to. If the file exists, the\n", + " equation is appended to the end of the file.\n", + " key (str): The key to use in the NRWAL file for the curve equation. In the key-value\n", + " pair, this argument is the key and the value is the equation string.\n", + " \"\"\"\n", + "\n", + " x_var = orbit_to_nrwal_params[self.x_variable]\n", + " if self.is_3d:\n", + " y_var = orbit_to_nrwal_params[self.y_variable]\n", + "\n", + " F = \"{:.1f}\"\n", + " S = \"{:s}\"\n", + " if self._linear_1d_curve is not None:\n", + " # y = ax + b\n", + " equation_string = f\"{F} * {S} + {F}\".format(self.coeffs[0], x_var, self.coeffs[1])\n", + "\n", + " if self._quadratic_1d_curve is not None:\n", + " # y = ax^2 + bx + c\n", + " equation_string = f\"{F} * {S}**2 + {F} * {S} + {F}\".format(self.coeffs[0], x_var, self.coeffs[1], x_var, self.coeffs[2])\n", + "\n", + " if self._poly3_1d_curve is not None:\n", + " # y = ax^3 + bx^2 + cx + d\n", + " equation_string = (\n", + " f\"{F} * {S}**3\"\n", + " f\" + {F} * {S}**2\"\n", + " f\" + {F} * {S}\"\n", + " f\" + {F}\".format(\n", + " self.coeffs[0], x_var,\n", + " self.coeffs[1], x_var,\n", + " self.coeffs[2], x_var,\n", + " self.coeffs[3]\n", + " )\n", + " )\n", + "\n", + " if self._linear_2d_curve is not None:\n", + " # z = ax + by + c\n", + " equation_string = f\"{F} * {S} + {F} * {S} + {F}\".format(self.coeffs[0], x_var, self.coeffs[1], y_var, self.coeffs[2])\n", + "\n", + " if self._quadratic_2d_curve is not None:\n", + " # z = ax^2 + bxy + cy^2 + dx + ey + f\n", + " equation_string = (\n", + " f\"{F} * {S}**2\"\n", + " f\" + {F} * {S} * {S}\"\n", + " f\" + {F} * {S}**2\"\n", + " f\" + {F} * {S}\"\n", + " f\" + {F} * {S}\"\n", + " f\" + {F}\".format(\n", + " self.coeffs[0], x_var,\n", + " self.coeffs[1], x_var, y_var,\n", + " self.coeffs[2], y_var,\n", + " self.coeffs[3], x_var,\n", + " self.coeffs[4], y_var,\n", + " self.coeffs[5]\n", + " )\n", + " )\n", + "\n", + " # nrwal_dict = {self.config[\"design_phases\"][0]: equation_string}\n", + " nrwal_dict = {key: equation_string}\n", + "\n", + " with open(filename, \"a\") as f:\n", + " f.write(\"\\n\")\n", + " if comments:\n", + " f.write(f\"# {comments}\\n\")\n", + " # f.write(f\"# {self.config['design_phases'][0]}\\n\")\n", + " yaml.dump(nrwal_dict, f)\n", + " f.write(f\"\\n\")\n", + " print(nrwal_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ORBIT Design Phase Cost Curves" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Monopile Substructure\n", + "\n", + "Independent variables:\n", + "- Water depth: impacts the mass of the monopile since it is fixed to the ocean floor\n", + "- Mean wind speed: impact the mass of the monopile by the load transferred from the turbine" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/rmudafor/Development/orbit/library'\n", + "{'substructure_17MW': '-569653.7 * depth**2 + 12505.1 * depth * mean_windspeed + 545620.3 * mean_windspeed**2 + 6917.7 * depth + 235.1 * mean_windspeed + -15478.7'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d67df42313104cf1a234f208e058429d", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cost_function = CostFunction(\n", + " config={\"design_phases\": [\"MonopileDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + " },\n", + " results={\n", + " \"monopile_unit_cost\": lambda run: run.design_results[\"monopile\"][\"unit_cost\"],\n", + " # \"transition_piece_unit_cost\": lambda run: run.design_results[\"transition_piece\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "cost_function.run()\n", + "\n", + "cost_function.linear_2d()\n", + "cost_function.quadratic_2d()\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(projection='3d')\n", + "ax.set_title(\"Monopile Substructure\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Mean wind speed (m/s)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_2d\", \"quadratic_2d\"])\n", + "ax.legend()\n", + "\n", + "cost_function.export(\"substructure.yaml\", \"substructure_17MW\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Semi-Submersible Substructure\n", + "\n", + "Since the semisubmersible is a floating structure, the water depth does not impact the mass\n", + "of the structure.\n", + "The mean wind speed does impact the mass of the structure by the load transferred from the\n", + "turbine, but this is not included in the design phase cost model directly.\n", + "The plot here shows that the cost is constant with respect to the water depth." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4b13254c2f314312b9419d72d1c138c8", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cost_function = CostFunction(\n", + " config={\"design_phases\": [\"SemiSubmersibleDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results={\n", + " \"substructure_unit_cost\": lambda run: run.design_results[\"substructure\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "cost_function.run()\n", + "\n", + "cost_function.linear_1d()\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "ax.set_title(\"Semisubmersible Substructure\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_1d\"])\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mooring System\n", + "\n", + "This block creates a cost model for each type of mooring system.\n", + "For all types, the line length is a function of water depth.\n", + "For TLP systems, line length is the difference between the water depth and the draft.\n", + "For SemiTaut systems, line length is the sum of rope length and chain length.\n", + "Rope length is defined from a fixed relationship for depth and rope lengths.\n", + "Chain length is also defined from a fixed relationship for depth and chain diameter.\n", + "While the semi-taut system line length is dependent on rope length and chain length, the parameters\n", + "are fixed and depend on water depth so they are not included in this parameterization." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'catenary': '199913.5 * depth + 34961743.3'}\n", + "{'tlp': '156672.0 * depth + -156672.0 * draft_depth + 27496949.2'}\n", + "{'semitaut': '227446.8 * depth + 32803637.2'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9527723938a24d85b577e15df912cbfb", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "design_phase = \"MooringSystemDesign\"\n", + "results = {\n", + " \"mooring_system_system_cost\": lambda run: run.design_results[\"mooring_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "# Catenary mooring system\n", + "cost_catenary = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " \"mooring_system_design\": {\"mooring_type\": \"Catenary\"}\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_catenary.run()\n", + "\n", + "# Tension Leg Platform (TLP) mooring system\n", + "cost_tlp = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " \"mooring_system_design\": {\"mooring_type\": \"TLP\"}\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"mooring_system_design.draft_depth\": [i for i in range(5, 100, 5)] # Draft depth 5-100 meters\n", + " },\n", + " results=results\n", + ")\n", + "cost_tlp.run()\n", + "\n", + "# Semi-taut mooring system\n", + "cost_semitaut = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " \"mooring_system_design\": {\"mooring_type\": \"SemiTaut\"}\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_semitaut.run()\n", + "\n", + "## Fit the data to a curve\n", + "cost_catenary.linear_1d()\n", + "cost_tlp.linear_2d()\n", + "cost_semitaut.linear_1d()\n", + "\n", + "## Plot the ORBIT data and curve fits\n", + "fig = plt.figure()\n", + "\n", + "ax = fig.add_subplot(2, 2, 1)\n", + "ax.set_title(\"Catenary\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_catenary.plot(ax, plot_data=True)\n", + "cost_catenary.plot(ax, plot_curves=[\"linear_1d\"])\n", + "\n", + "ax = fig.add_subplot(2, 2, 2, projection='3d')\n", + "ax.set_title(\"TLP\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Draft depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_tlp.plot(ax, plot_data=True)\n", + "cost_tlp.plot(ax, plot_curves=[\"linear_2d\"])\n", + "\n", + "ax = fig.add_subplot(2, 2, 3)\n", + "ax.set_title(\"Semi-Taut\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_semitaut.plot(ax, plot_data=True)\n", + "cost_semitaut.plot(ax, plot_curves=[\"linear_1d\"])\n", + "\n", + "cost_catenary.export(\"mooring_system.yaml\", \"catenary\")\n", + "cost_tlp.export(\"mooring_system.yaml\", \"tlp\")\n", + "cost_semitaut.export(\"mooring_system.yaml\", \"semitaut\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Array System\n", + "\n", + "The array system cost is entirely dependent on the cable length.\n", + "The cable length is a function of some fixed plant parameters and the following spatially\n", + "dependent parameters:\n", + "- water depth\n", + "- touchdown distance\n", + "- floating cable depth" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "daeda722d6574a2198151c690f55f0cc", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACze0lEQVR4nOzdd1xV9f/A8ddlbxBEhqKggoqKMwz3zJWplWVpaMty5CgrqV+i5swytUHL1DKzr+bMvXDkHii4cDAcIAqyZXjv+f3Bl/v1yhCZF3g/H4/70Hvu55zzvudyPvd9z/kMlaIoCkIIIYQQotowqOgAhBBCCCFE+ZIEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUIgSWrZsGSqVihMnTlR0KEKIMlIa57m7uzsjR44svaD0UHV4j1WFJICiUsitfHMfZmZmuLq60rt3bxYvXkxKSkqZx/D999+zbNmyMt+PENXZw+d5YY/g4OCKDrXK69q1q/Z4GxgYYGNjQ6NGjXjttdfYuXNnqe1ny5YtTJs2rdS2J4rGqKIDEOJJzJgxAw8PD7Kzs4mNjSU4OJiJEyeyYMECNm7ciI+PT5nt+/vvv6dmzZry61aIMvT777/rPP/tt9/YuXNnnuVNmjQpz7CqrTp16jBnzhwA0tLSuHLlCmvXrmXFihW89NJLrFixAmNjY235S5cuYWDwZNeWtmzZwnfffSdJYDmTBFBUKn379qVt27ba5wEBAezZs4dnn32W5557jgsXLmBubl6BEQohSmL48OE6z48cOcLOnTvzLBflw9bWNs+xnzt3LuPHj+f777/H3d2defPmaV8zNTUt7xBFMcktYFHpde/enc8++4yoqChWrFihXX7x4kVefPFF7O3tMTMzo23btmzcuFFn3dxby/v37+edd97BwcEBGxsb/P39uXfvnracu7s7586dY9++fdpbIl27dtXZVmZmJu+//z6Ojo5YWloyePBg7ty5U6bvXYjqKC0tjQ8++AA3NzdMTU1p1KgRX375JYqiaMtERkaiUqnybbahUqnyXG26efMmb775Jq6urpiamuLh4cHo0aPJysrSKVeU81xRFGbOnEmdOnWwsLCgW7dunDt3Lt/3cu3aNYYMGYK9vT0WFhY8/fTTbN68WWdbNWvW5P3339cu02g02NnZYWhoSGJionb5vHnzMDIyIjU1FYCRI0diZWXFzZs3GTRoEFZWVjg6OjJ58mTUanWhx7gwhoaGLF68GG9vb7799luSkpK0rz3aBjA7O5vp06fj6emJmZkZDg4OdOzYUXsLeeTIkXz33XeA7u3/XF9++SXt27fHwcEBc3Nz2rRpw5o1a/LEpFKpGDduHOvXr6dZs2aYmprStGlTtm3blqdsUT7rxMREJk6cqP0ba9iwIfPmzUOj0RT7uOkbuQIoqoTXXnuNTz75hB07dvD2229z7tw5OnToQO3atZkyZQqWlpb85z//YdCgQfz9998MHjxYZ/1x48ZhZ2fHtGnTuHTpEkFBQURFRREcHIxKpWLhwoW89957WFlZ8emnnwLg5OSks4333nuPGjVqEBgYSGRkJAsXLmTcuHH89ddf5XYchKjqFEXhueeeY+/evbz55pu0bNmS7du38+GHH3Lz5k2+/vrrJ97mrVu38PX1JTExkVGjRtG4cWNu3rzJmjVrSE9Px8TERFu2KOf51KlTmTlzJv369aNfv36cOnWKZ555Jk8yefv2bdq3b096ejrjx4/HwcGB5cuX89xzz7FmzRoGDx6MSqWiQ4cO7N+/X7ve2bNnSUpKwsDAgH///Zf+/fsDcODAAVq1aoWVlZW2rFqtpnfv3rRr144vv/ySXbt28dVXX9GgQQNGjx79xMcql6GhIa+88gqfffYZBw8e1MbwqGnTpjFnzhzeeustfH19SU5O5sSJE5w6dYpevXrxzjvvcOvWrXxv8wMsWrSI5557jmHDhpGVlcWqVasYMmQI//zzT559Hjx4kLVr1zJmzBisra1ZvHgxL7zwAtHR0Tg4OABF+6zT09Pp0qULN2/e5J133qFu3bocOnSIgIAAYmJiWLhwYbGPm15RhKgEli5dqgDK8ePHCyxja2urtGrVSlEURenRo4fSvHlzJSMjQ/u6RqNR2rdvr3h6eubZbps2bZSsrCzt8i+++EIBlA0bNmiXNW3aVOnSpUuBsfXs2VPRaDTa5ZMmTVIMDQ2VxMTEYr1nIYSijB07Vnn4q2r9+vUKoMycOVOn3IsvvqioVCrlypUriqIoSkREhAIoS5cuzbNNQAkMDNQ+9/f3VwwMDPKtX3LP6aKe53FxcYqJiYnSv39/nXKffPKJAigjRozQLps4caICKAcOHNAuS0lJUTw8PBR3d3dFrVYriqIo8+fPVwwNDZXk5GRFURRl8eLFSr169RRfX1/l448/VhRFUdRqtWJnZ6dMmjRJu60RI0YogDJjxgyd99SqVSulTZs2ed7ro7p06aI0bdq0wNfXrVunAMqiRYu0y+rVq6fzHlu0aKH079+/0P08+hk/LD09Xed5VlaW0qxZM6V79+46ywHFxMRE+/kriqKcOXNGAZRvvvlGu6won/Xnn3+uWFpaKuHh4TqvT5kyRTE0NFSio6MLfT+VhdwCFlWGlZUVKSkpJCQksGfPHl566SVSUlK4e/cud+/eJT4+nt69e3P58mVu3ryps+6oUaN0GjKPHj0aIyMjtmzZUuT9jxo1SufWRadOnVCr1URFRZX8zQkhgJwOA4aGhowfP15n+QcffICiKGzduvWJtqfRaFi/fj0DBgzQaV+c6+FzGh5/nu/atYusrCzee+89nXITJ07M9734+vrSsWNH7TIrKytGjRpFZGQk58+f19nHoUOHgJwrfZ06daJTp04cOHAAgLCwMBITE+nUqVOe/bz77rs6zzt16sS1a9cKPS5FkXulsbBRGOzs7Dh37hyXL18u1j4ebtN97949kpKS6NSpE6dOncpTtmfPnjRo0ED73MfHBxsbG+17LepnvXr1ajp16kSNGjW03x93796lZ8+eqNVqnauxlZkkgMWwf/9+BgwYgKurKyqVivXr1z/R+tOmTct3WANLS8uyCbiaSE1NxdramitXrqAoCp999hmOjo46j8DAQADi4uJ01vX09NR5bmVlhYuLC5GRkUXef926dXWe16hRA0CnLaEQ+k7f67eoqChcXV2xtrbWWZ7bK/hJf3DduXOH5ORkmjVrVqTyjzvPc/f/aJ3i6OioLZsrKiqKRo0a5dnHo++ldevWWFhYaJO93ASwc+fOnDhxgoyMDO1rDyeTAGZmZjg6OuaJuTTqpdy2ho9+Fg+bMWMGiYmJeHl50bx5cz788EPOnj1b5H38888/PP3005iZmWFvb4+joyNBQUE67Q5zPfrZgO57LepnffnyZbZt25bn+6Nnz55A3u+PykraABZDWloaLVq04I033uD5559/4vUnT56c5xdZjx49eOqpp0orxGrnxo0bJCUl0bBhQ20j3cmTJ9O7d+98yzds2LDUYzA0NMx3ufJQw3Qh9F1Vqd8evXKXqySdH6BiznNjY2PatWvH/v37uXLlCrGxsXTq1AknJyeys7M5evQoBw4coHHjxnmSvYLiLQ1hYWFA4fVp586duXr1Khs2bGDHjh388ssvfP311/zwww+89dZbhW7/wIEDPPfcc3Tu3Jnvv/8eFxcXjI2NWbp0KStXrsxTvrQ+G41GQ69evfjoo4/yfd3Ly+uJtqevJAEshr59+9K3b98CX8/MzOTTTz/lzz//JDExkWbNmjFv3jxtr1ErKyudRrpnzpzh/Pnz/PDDD2UdepWV23i4d+/e1K9fH8ipNHN/sT3O5cuX6datm/Z5amoqMTEx9OvXT7usoC8UIaoSfa/f6tWrx65du0hJSdG58nTx4kXt6/C/K3MP95KFvFcIHR0dsbGx0SYzpREf5NQpuXUR5Fx9evSqW7169bh06VKebTz6XiDntu28efPYtWsXNWvWpHHjxqhUKpo2bcqBAwc4cOAAzz77bKm8h6JQq9WsXLkSCwuLPFcdH2Vvb8/rr7/O66+/TmpqKp07d2batGnaBLCguvXvv//GzMyM7du36wwvs3Tp0mLFXNTPukGDBqSmphb5+6OyklvAZWDcuHEcPnyYVatWcfbsWYYMGUKfPn0KbAPxyy+/4OXllW/bDfF4e/bs4fPPP8fDw4Nhw4ZRq1Ytunbtyo8//khMTEye8vkNzfLTTz+RnZ2tfR4UFMSDBw90vggtLS3zfJkIUd1UdP3Wr18/1Go13377rc7yr7/+GpVKpT1nbWxsqFmzZp72Wt9//73OcwMDAwYNGsSmTZvynebtSa8e9ezZE2NjY7755huddfPrOdqvXz+OHTvG4cOHtcvS0tL46aefcHd3x9vbW7u8U6dOZGZmsnDhQjp27KhNmjp16sTvv//OrVu3yu07RK1WM378eC5cuMD48eOxsbEpsGx8fLzOcysrKxo2bEhmZqZ2WW7zgEfrV0NDQ1Qqlc5V28jIyCdulpCrqJ/1Sy+9xOHDh9m+fXueMomJiTx48KBY+9c3cgWwlEVHR7N06VKio6NxdXUFcm6JbNu2jaVLlzJ79myd8hkZGfzxxx9MmTKlIsKtdLZu3crFixd58OABt2/fZs+ePezcuZN69eqxceNGzMzMAPjuu+/o2LEjzZs35+2336Z+/frcvn2bw4cPc+PGDc6cOaOz3aysLHr06MFLL73EpUuX+P777+nYsSPPPfectkybNm0ICgpi5syZNGzYkFq1atG9e/dyff9CVCR9qN8GDBhAt27d+PTTT4mMjKRFixbs2LGDDRs2MHHiRJ1OAG+99RZz587lrbfeom3btuzfv5/w8PA825w9ezY7duygS5cujBo1iiZNmhATE8Pq1as5ePAgdnZ2RY4vd5y9OXPm8Oyzz9KvXz9Onz7N1q1bqVmzpk7ZKVOm8Oeff9K3b1/Gjx+Pvb09y5cvJyIigr///ltnRg0/Pz+MjIy4dOkSo0aN0i7v3LkzQUFBAGWSACYlJWnHV01PT9fOBHL16lWGDh3K559/Xuj63t7edO3alTZt2mBvb8+JEydYs2YN48aN05Zp06YNAOPHj6d3794YGhoydOhQ+vfvz4IFC+jTpw+vvvoqcXFxfPfddzRs2PCJ2hE+rCif9YcffsjGjRt59tlnGTlyJG3atCEtLY3Q0FDWrFlDZGRkns+yUqq4DshVA6CsW7dO+/yff/5RAMXS0lLnYWRkpLz00kt51l+5cqViZGSkxMbGlmPUlU/uEAy5DxMTE8XZ2Vnp1auXsmjRIu3wCA+7evWq4u/vrzg7OyvGxsZK7dq1lWeffVZZs2ZNnu3u27dPGTVqlFKjRg3FyspKGTZsmBIfH6+zvdjYWKV///6KtbW1AmiHhCloiJq9e/cqgLJ3795SPx5ClAd9qN/yGyIkJSVFmTRpkuLq6qoYGxsrnp6eyvz583WGXVGUnCFE3nzzTcXW1laxtrZWXnrpJSUuLi7PMDCKoihRUVGKv7+/4ujoqJiamir169dXxo4dq2RmZiqK8mTnuVqtVqZPn664uLgo5ubmSteuXZWwsLA8Q6QoSk499eKLLyp2dnaKmZmZ4uvrq/zzzz/5HounnnpKAZSjR49ql924cUMBFDc3tzzlR4wYoVhaWuZZHhgYWOCwKw/r0qWLTr1rZWWleHp6KsOHD1d27NiR7zqPvseZM2cqvr6+ip2dnWJubq40btxYmTVrls6wWw8ePFDee+89xdHRUVGpVDqxLVmyRPH09FRMTU2Vxo0bK0uXLs03fkAZO3bsY+NRlMd/1oqS8zcWEBCgNGzYUDExMVFq1qyptG/fXvnyyy91Yq/MVIoiLdRLQqVSsW7dOgYNGgTAX3/9xbBhwzh37lyeBqlWVlY4OzvrLOvRowc2NjasW7euvEIWD1m2bBmvv/46x48fz3dYACGqM6nfhKi65BZwKWvVqhVqtZq4uLjHXo6PiIhg7969eaYnE0IIfST1mxBVhySAxZCamsqVK1e0zyMiIggJCcHe3h4vLy+GDRuGv78/X331Fa1ateLOnTvs3r0bHx8fnalrfv31V1xcXArtcSeEEOVJ6jchqomKvgddGeW2+Xj0kdvOICsrS5k6dari7u6uGBsbKy4uLsrgwYOVs2fParehVquVOnXqKJ988kkFvQuhKEWbYk6I6kTqNyGqB2kDKIQQQghRzcg4gEIIIYQQ1YwkgEIIIYQQ1Yx0AikijUbDrVu3sLa2linBhKgkFEUhJSUFV1dXnUF1RV5SxwlRuZS0fpMEsIhu3bqFm5tbRYchhCiG69evU6dOnYoOQ69JHSdE5VTc+k0SwCLKnXT8+vXrhc57KITQH8nJybi5uWnPX1EwqeOEqFxKWr9JAlhEubdEbGxspHIUooKoNQrHIhKIS8mglrUZvh72GBo8/nal3NJ8vKLUccU9/kKIslPc+k0SQCFEpbAtLIbpm84Tk5ShXeZia0bgAG/6NHOpwMiqBzn+QlQt0ipaCKH3toXFMHrFKZ3kAyA2KYPRK06xLSymgiKrHuT4C1H1SAIohNBrao3C9E3nyW/E+txl0zedR62RMe3Lghx/IaomSQCFEHrtWERCnitPD1OAmKQMjkUklF9Q1YgcfyGqJkkAhRB6LS6l4OSjOOXEk5HjL0TVJAmgEEKvRcenF6lcLWuzMo6keirqcZXjL0TlIr2AhRB6KS45g2mbzrElNLbQcirA2TZnSBJR+nw97HGxNSM2KSPfdoBy/IWonOQKoBBCryiKwqpj0fRYsI8tobEYGqjo3dQJyEk2Hpb7PHCAt4xHV0YMDVQEDvAG5PgLUZVIAiiE0BsRd9N45ecjTFkbSkrGA5rXtmXjuA78+FpbfhjeGmdb3duMzrZmBA1vLePQlbE+zVwIkuMvRJUit4CFEBUuW63h5wPXWLjrMlkPNJgZGzD5mUaMbO+OkWHO79Q+zVzo5e0sM1FUkNzjf/RaPIeu3qVDQ0c5/kJUYpIACiEq1NkbiXz8dygXYpIB6ORZk1mDmlPXwSJPWUMDFX4NHMo7RPFfBirYdPYWfx67jqudhXwWQlRikgAKISpEetYDFuwI59d/I9AoYGdhzGf9vXm+dW2Zu1dPqVQq6tTIScwDN4bRyNmKNvWk84cQlZG0ARRClLv94Xd45uv9/HIwJ/kb2NKVXe934YU2dST503NjujagX3NnstUK7644xe1kGf9PiMpIEkAhRKlTaxQOX41nQ8hNDl+N104Tdi8ti/f/E4L/r8e4ce8+rrZmLB35FIuGtqKmlWkFR132goKC8PHxwcbGBhsbG/z8/Ni6dWuB5bt27YpKpcrz6N+/v7aMoihMnToVFxcXzM3N6dmzJ5cvXy6z96BSqZj/YgsaOVlzJyWTd34/SeYDdZntTwhRNuQWsBCiVG0Li2H6pvM604c525jSr7kLG0JuEZ+WhUoFI/zcmdy7EVam1acaqlOnDnPnzsXT0xNFUVi+fDkDBw7k9OnTNG3aNE/5tWvXkpWVpX0eHx9PixYtGDJkiHbZF198weLFi1m+fDkeHh589tln9O7dm/Pnz2NmVjaDM1uaGvGTfxue+/ZfQq4n8tn6MOa94CNXb4WoRFSKosgM3kWQnJyMra0tSUlJ2NjYVHQ4QuilbWExjF5xKt8Bg3N5OVkx9wUfWtetUebxVIbz1t7envnz5/Pmm28+tuzChQuZOnUqMTExWFpaoigKrq6ufPDBB0yePBmApKQknJycWLZsGUOHDi1yHMU5VvvD7zBy6TE0Cnw+sCmv+bkXeX9CiJIpaf0mt4CFEKVCrVGYvul8ocmflakRG8Z2LJfkT9+p1WpWrVpFWloafn5+RVpnyZIlDB06FEtLSwAiIiKIjY2lZ8+e2jK2tra0a9eOw4cPF7qtzMxMkpOTdR5PqrOXIx/3aQzA9E3nORaR8MTbEEJUDEkAhRCl4lhEgs5t3/ykZj4g5Hpi+QSkp0JDQ7GyssLU1JR3332XdevW4e3t/dj1jh07RlhYGG+99ZZ2WWxszjR5Tk5OOmWdnJy0rxVkzpw52Nraah9ubm7FeDcwqnN9BrRw5YFGYcwfJ7mVeL9Y2xFClC9JAIUQpSIupWi9QYtarqpq1KgRISEhHD16lNGjRzNixAjOnz//2PWWLFlC8+bN8fX1LZU4AgICSEpK0j6uX79erO2oVCrmvdCcJi423E3N4t0VJ8nIlk4hQug7SQCFEKUiITXr8YWAWtZl0zGhsjAxMaFhw4a0adOGOXPm0KJFCxYtWlToOmlpaaxatSpPO0FnZ2cAbt++rbP89u3b2tcKYmpqqu2NnPsoLgsTI356rQ01LIw5eyOJT9eFIc3LhdBvkgAKIUokOSObT9eFMv2fwq9iqQAX25zp28T/aDQaMjMzCy2zevVqMjMzGT58uM5yDw8PnJ2d2b17t3ZZcnIyR48eLXK7wtLiZm/Bt6+2xkAFf5+6wbJDkeW6fyHEk5EEUAhRbDvOxdJrwT7+OBoNQIeGOVODPToYSO7zwAHe1Xru2ICAAPbv309kZCShoaEEBAQQHBzMsGHDAPD39ycgICDPekuWLGHQoEE4OOhOvaZSqZg4cSIzZ85k48aNhIaG4u/vj6urK4MGDSqPt6SjQ8OafNKvCQAzN1/g8NX4co9BCFE01WcALiFEqYlLzmDapnNsCc3paOBR05LZg5vj18Ah/3EAbc0IHOBNn2YuFRWyXoiLi8Pf35+YmBhsbW3x8fFh+/bt9OrVC4Do6GgMDHR/l1+6dImDBw+yY8eOfLf50UcfkZaWxqhRo0hMTKRjx45s27atzMYAfJw3O3pw7lYy607fZOzKU2wc10E7fZwQQn/IOIBFVBnGExOirCmKwl/HrzNrywVSMh5gaKDinc71Gd/DEzNjQ205tUbhWEQCcSkZ1LLOue1bEVf+5LwtutI8VhnZal784RBhN5Np6mrDmnfbY25i+PgVhRBFVtJzVq4ACiGKJOJuGgFrz3LkWs5Ybz51bJn7vA/ernkrHkMDFX4NHPIsF9WDmbEhP77Wlue+Oci5W8kErD3L1y+3lJlChNAj0gZQCFGobLWG74Ov0Hvhfo5cS8Dc2JD/69+EtaPb55v8CQFQ286cb19tjaGBivUht1hyMKKiQxJCPEQSQCFEgc7eSOS5b//li22XyHqgoZNnTXZM6sxbnepjZCjVhyicXwMHPuuf0ylk9pYLHLx8t4IjEkLk0rsaPCgoCB8fH+24VH5+fmzdurXA8l27dkWlUuV59O/fX1tm5MiReV7v06dPebwdIfSeWqNw+Go8G0JucvhqPGqNQnrWA2b+c55B3/3LhZhk7CyMWfBSC357wxc3e2nQL4puRHt3XmxTB40C4/48xfWE9IoOSQiBHrYBrFOnDnPnzsXT0xNFUVi+fDkDBw7k9OnTNG3aNE/5tWvXkpX1vwFo4+PjadGiBUOGDNEp16dPH5YuXap9bmpqWnZvQohKIr8eu/YWxqhUKuLTcs6rgS1d+exZb2payTkjnpxKpWLmoGZcvp3CmRtJjPr9JH+P9sPCRO++foSoVvTuDBwwYIDO81mzZhEUFMSRI0fyTQDt7XUHlV21ahUWFhZ5EkBTU9PHjowvRHWyLSyG0StO8egwAAnp2QDYW5rw1Ust6NaoVvkHJ6oUM2NDfnitDQO+OciFmGQ+WnOWb15pJZ1ChKhAencL+GFqtZpVq1aRlpZW5FHtlyxZwtChQ7G0tNRZHhwcTK1atWjUqBGjR48mPl4GKBXVl1qjMH3T+TzJ38OMDVV09nQst5hE1eZia873w9pgZKDin7Mx/Lj/WkWHJES1ppcJYGhoKFZWVpiamvLuu++ybt06vL29H7vesWPHCAsL46233tJZ3qdPH3777Td2797NvHnz2LdvH3379kWtLnjC8szMTJKTk3UeQlQVxyISdG775ud2cibHIhLKKSJRHfh62BP4XM6dnC+2XWRf+J0KjkiI6ksvE8BGjRoREhLC0aNHGT16NCNGjOD8+cLnGYWcq3/NmzfH19dXZ/nQoUN57rnnaN68OYMGDeKff/7h+PHjBAcHF7itOXPmYGtrq324ubmV9G0JoTdik+4XqVxcSuFJohBPani7ugx9yg2NAu+tPEVUfFpFhyREtaSXCaCJiQkNGzakTZs2zJkzhxYtWrBo0aJC10lLS2PVqlW8+eabj91+/fr1qVmzJleuXCmwTEBAAElJSdrH9evXn/h9CKGPLsWm8F3w1SKVrWVdMdOJiapLpVIxfWBTWtW1IznjAaN+O0la5oOKDkuIakcvE8BHaTQaMjMzCy2zevVqMjMzGT58+GO3d+PGDeLj43FxKXheUlNTU+1QNLkPISqzjGw1C3Zcov/iA1yJS6Ww5vcqwMU2Zwo3IUqbqZEhPwxvg6O1KZdupzB59RlkVlIhypfeJYABAQHs37+fyMhIQkNDCQgIIDg4mGHDhgHg7+9PQEBAnvWWLFnCoEGDcHDQnX4qNTWVDz/8kCNHjhAZGcnu3bsZOHAgDRs2pHfv3uXynoSoaMciEui3+ACL91zhgUahl7cTs59vhgryJIK5zwMHeFfI/L2ienCyMeOH4W0wNlSxNSyW74t4VVoIUTr0bhiYuLg4/P39iYmJwdbWFh8fH7Zv306vXr0AiI6OxsBAN2+9dOkSBw8eZMeOHXm2Z2hoyNmzZ1m+fDmJiYm4urryzDPP8Pnnn8tYgKLKS87IZt7Wi/xxNBoAR2tTZjzXlD7NnFGpVNSwMMkzDqCzrRmBA7zp06zgK+RClIY29WowY2AzAtaG8uWOS3i72NCtsQw7JER5UCly3b1IkpOTsbW1JSkpSW4Hi0phx7lYPtsQxu3knOYTr/i6MaVPE2wtjHXKqTUKxyISiEvJoJZ1zm3fqnLlT87boqvIY/XpulD+OBqNtZkRG8d1xKOm5eNXEqKaK+k5q3dXAIUQJROXnMG0TefYEhoLgEdNS2YPbo5fA4d8yxsaqAp8TYjyEDigKZdiUzgRdY+3fzvB+rEdsDKVrychypLetQEUQhSPoiisOhZNjwX72BIai6GBijFdG7B1QidJ8IReMzEy4PvhrXGyMeVKXCqv/HSEf6/cRa2RG1RClBX5iSVEFRBxN42AtWc5ci1n4GafOrbMfd4Hb1e57Skqh1NR93igzkn4Qm8mMeyXo7hIe1QhyowkgEJUEvm11dMoCj8fuMbCXZfJeqDB3NiQD57xYmR7d4wM5QK/qBwKmpc6JimD0StOETS8tSSBQpQySQCFqAS2hcXk6a3rYGmCuYkhN+7lzOrRybMmswc3x83eoqLCFOKJPW5eagWYvuk8vbydq0znJCH0gSSAQui5gq6OxKdlQRpYmhjy+aBmDG5VG5VKviBF5VKUealjkjI4FpEgbVmFKEVyj0gIPfa4qyMAlqZGDGwpyZ+onIo63/SBy3fKOBIhqhdJAIXQY0W5OhKXksmxiIRyikiI0lXU+aaXHIzgdPS9Mo5GiOpDEkAh9Njt5PtFKlfUqyhC6BtfD3tcbM0KnZvaxMiAzAcaXl92nPDbKeUWmxBVmSSAQuipG/fSWXYoqkhli3oVRQh9Y2igInCAN5D/vNQq4IsXmtOqrh2J6dm8tuQo1xPSyztMIaqcEncCSUxMZN26dRw4cICoqCjS09NxdHSkVatW9O7dm/bt25dGnEJUG2qNwvJDkXy54xLpWepCy6rImbvX18O+fIKrZqR+Kx99mrkQNLx1ofNSd21Ui5d+PEz47VReW3KU1e+2x9Fa5nMXoriKPRfwrVu3mDp1Kn/88Qeurq74+vri6uqKubk5CQkJhIWFcfLkSerVq0dgYCAvv/xyacdermROUVEeLsYm8/HfoZy5ngiAr7s9/Zo7M33TeQCdziC5V0tkjLSCFfe8rW71G+hHHfe4ealvJ2fwQtAhbty7j7eLDaveeRobM+NCtihE1VVhcwG3atWKESNGcPLkSby9vfMtc//+fdavX8/ChQu5fv06kydPLu7uhKjSMrLVfLf3CkHBV3mgUbA2NWJKv8a88lRdDAxUONuaFXp1RJQuqd8qxuPmpXayMWPFm+148YfDnI9J5q1lJ1j+hi/mJoblGKUQVUOxrwDGx8fj4FD0MZmetLy+0Ydfx6JqOhaRwJS1Z7l2Jw2AXt5OfD6wGc62uu36Hnd1RORV3PO2utVvULnquPO3knn5p8OkZDyge+Na/PhaG4xl5htRzZT0nC12AljdVKbKUVQOyRnZzN16kZVHowFwtDZlxnNN6dPMWcb0KyVy3hZdZTtWxyMTeG3JUTKyNQxq6cqCl1piID+IRDVS0nO2TH4yXbhwgaVLlxISElIWmxei0tt+LpZeC/Zpk79XfN3YNakLfZu7SPKn50pSvwUFBeHj44ONjQ02Njb4+fmxdevWQtdJTExk7NixuLi4YGpqipeXF1u2bNG+rlar+eyzz/Dw8MDc3JwGDRrw+eefU9V/2z/lbk/QsDYYGahYH3KLGf+cr/LvWYjSVOJewDNmzMDc3JwPP/wQgL1799KnTx+sra1JSkpi2bJlDBs2rMSBClFZFHarNi45g8CN59gaFguAR01LZg9uLlNc6anSrt/q1KnD3Llz8fT0RFEUli9fzsCBAzl9+jRNmzbNUz4rK4tevXpRq1Yt1qxZQ+3atYmKisLOzk5bZt68eQQFBbF8+XKaNm3KiRMneP3117G1tWX8+PElPgb6rFvjWnz1Ugsm/hXCskOR2FkYM7GnV0WHJUSlUOJbwD4+PsyZM4f+/fsD0LNnT1q1asX8+fP58ccfWbx4MefOnSuVYCtSZbs9IirGtrCYPJ01XGzNmPpsE5LuP2DWlgukZDzA0EDFO53rM76HJ2bG0oC9rJT0vC2P+s3e3p758+fz5ptv5nnthx9+YP78+Vy8eBFj4/x7uz777LM4OTmxZMkS7bIXXngBc3NzVqxYUeQ4KnMd99vhSKZuyPkcpg3wZmQHjwqOSIiyV2G9gH/77TcURSEyMpKQkBDi4+NRFIV///2XTp068dtvv6HRaLh27Rq//fYbAP7+/sXdnRB6b1tYDKNXnMozb29MUgaj/zitfe5Tx5a5z/vg7Vq5vmSrk/Ko39RqNatXryYtLQ0/P798y2zcuBE/Pz/Gjh3Lhg0bcHR05NVXX+Xjjz/G0DDnh0P79u356aefCA8Px8vLizNnznDw4EEWLFhQsoNQifj7uXMvLZuvd4UzbdN57CxMGNSqdkWHJYReK3YCWK9ePQBMTExwcnKiXr16hISEYGNjQ7du3VAUhczMTFQqFe7u7tI2Q1Rpao3C9E3n8yR/D1MBAf0a80YHD4ykx6JeK8v6LTQ0FD8/PzIyMrCysmLdunUFDjVz7do19uzZw7Bhw9iyZQtXrlxhzJgxZGdnExgYCMCUKVNITk6mcePGGBoaolarmTVr1mNvTWdmZpKZmal9npycXOT3oI/G92jIvfQslh2K5IPVZ7AxN6J7Y6eKDksIvVXsBLBLly4AtG7dmn/++YePP/6Ybdu20a9fPzp37gzkVHRubm7a50JUVcciEnRu++ZHAZrXtpPkrxIoy/qtUaNGhISEkJSUxJo1axgxYgT79u3LNwnUaDTUqlWLn376CUNDQ9q0acPNmzeZP3++NgH8z3/+wx9//MHKlStp2rQpISEhTJw4EVdXV0aMGFFgHHPmzGH69OlPFLs+U6lUTH3Wm6T72aw7fZPRK07x+5vtZJYcIQpQ4m+i+fPnExISQocOHYiKimLGjBna15YtW0afPn1Kugsh9F5cSuHJ35OWE/qhLOo3ExMTGjZsSJs2bZgzZw4tWrRg0aJF+ZZ1cXHBy8tLe7sXoEmTJsTGxpKVlQXAhx9+yJQpUxg6dCjNmzfntddeY9KkScyZM6fQOAICAkhKStI+rl+//sTvRd8YGKj44kUfejSuReYDDW8uO865W0kVHZYQeqnEvYBbtGhBZGRkvgOhTp48udI1JhaiOGpZmz2+0BOUE/qhPOo3jUajcyv2YR06dGDlypVoNBoMDHJ+r4eHh+Pi4oKJiQkA6enp2tdyGRoaotFoCt2vqakppqZVby5dY0MDvhvWGv8lxzgWmcCIX4+x+t32eNS0rOjQhNArpXYvKr9R8F1cXLC0lJNOVG0JaVn8daLwqycqcnoDy+2oyqm06reAgAD2799PZGQkoaGhBAQEEBwcrG2v5+/vT0BAgLb86NGjSUhIYMKECYSHh7N582Zmz57N2LFjtWUGDBjArFmz2Lx5M5GRkaxbt44FCxYwePDgYr7bys/M2JBfRrbF28WGu6lZDP/lKLGPaaIhRHVT7ARw1apVRS57/fp1/v333+LuSgi9pCgKG0Ju0nPBPtafvklBwzfnLg8c4C1Tt1USZVW/xcXF4e/vT6NGjejRowfHjx9n+/bt9OrVC4Do6GhiYmK05d3c3Ni+fTvHjx/Hx8eH8ePHM2HCBKZMmaIt88033/Diiy8yZswYmjRpwuTJk3nnnXf4/PPPi/weqiIbM2OWv+GLu4MFNxPv89qSo9xLy6rosITQG8UeB7BLly7ExcXx+uuvM2DAAJo0aaLzelJSEv/++y8rVqxg586dLFmyhOeee65Ugq4IlXmMLFH6btxL59N1YewLvwNAIydr5r7QnNvJGfmOAxg4wJs+zVwqKtxqq7jnbXWr36Dq1nHXE9IZ8sNhYpMzaOlmxx9vtcPStMStn4SocBU6F/DGjRv55ptv2LNnD5aWljg5OWFmZsa9e/eIjY2lZs2ajBw5kkmTJuHkVLm741fVylE8GbVGYfmhSL7ccYn0LDUmhgaM79GQUZ0bYGJkoC1T0EwgonyV5LytTvUbVO067vLtFIb8eJjE9Gw6NqzJkpFtMTWSAdhF5VahCWCuu3fvcvDgQaKiorh//z41a9akVatWtGrVKk/j5MqqKleOomguxibz8d+hnLmeCICvuz2zn29Ow1pWFRuYKFBpnLfVoX6Dql/HhVxP5NWfj5CepaZvM2e+fbW1/DATlZpeJIDVQVWvHEXBMrLVfLvnCj/su8oDjYK1qRFT+jXmlafqYiBfIHpNztuiqw7H6uDlu7yx7DhZag39mjvz9cst5UqgqLRKes5WnZ+vQpSBo9fi6bfoAN/uvcIDjcIz3k7sfL8Lw9rVk+RPiErGr4ED47o3xNBAxZbQWEb+epzUzAcVHZYQFUJawopqraD2eskZ2czdepGVR6MBcLQ25fOBTaUjhxCV1LawmDwdtA7/9wfeujHtcbCqemMiClEYSQBFtZXfF4KLrRnPtXBl3embxKXkDM77iq8bU/o2wdbcuKJCFUKUwLawGEavOJXvXN3RCen0W3SAv8e0p04Ni3KPTYiKIgmgqJYK+kKIScrgx/3XAPCoacnswc3xa5B3EGAhROWg1ihM33Q+3+Qv1+2UTF4IOsTvb7bDy8m63GIToiKVShvAGTNmkJ6enmf5/fv3debOFEIfFOULwdLUkH/e6yjJn5D6rZI7FpGgc5W/ILeTMxnyw2FORiWUQ1RCVLxSSQCnT59OampqnuXp6elMnz69NHYhRKkpyhdCWqaaszdkEnkh9VtlF5dStCng3B0sSLqfzbBfjrL3YlwZRyVExSuVBFBRFFSqvD0iz5w5g729zH0q9EtRvxCKWk5UbVK/VW61rM2KVC5wQFO6NnIkI1vD27+dYN3pG2UcmRAVq0RtAGvUqIFKpUKlUuHl5aVTSarValJTU3n33XdLHKQQpSklo2jDPhT1i0NUTVK/VQ2+Hva42JoRm5SRb7MPFeBsa0ZnL0c6etbkozVnWXf6JpP+OkNCWjZvdvQo75CFKBclSgAXLlyIoii88cYbTJ8+HVtbW+1rJiYmuLu74+fn90TbDAoKIigoiMjISACaNm3K1KlT6du3b77lu3btyr59+/Is79evH5s3bwZyfsEHBgby888/k5iYSIcOHQgKCsLT0/OJYhOVW3rWA77aEc7SfyMKLZf7heDrIVd3qrOyqN9E+TM0UBE4wJvRK06hAp0kMDelDxzgjaGBCkNUfDWkBTUsTPj13wg+/+c88amZfNi7Ub5XgYWozEqUAI4YMQIADw8POnTogJFRyTsV16lTh7lz5+Lp6YmiKCxfvpyBAwdy+vRpmjZtmqf82rVrycrK0j6Pj4+nRYsWDBkyRLvsiy++YPHixSxfvhwPDw8+++wzevfuzfnz5zEzk6s81cG+8Dt8ui6UG/fuA+DrXoNjkfce+4Ugqq+yqN9ExejTzIWg4a3zDPvkbGtG4ABvnfE9DQxUfPZsExysTJi//RLfB18lIS2LmYOaYWQocyeIqqNUpoI7deoUxsbGNG/eHIANGzawdOlSvL29mTZtGiYmJiXavr29PfPnz+fNN998bNmFCxcydepUYmJisLS0RFEUXF1d+eCDD5g8eTIASUlJODk5sWzZMoYOHVqkGKrDNElVUUJaFjP/Oc/a0zcBqG1nzszBzejWqFaB4wA++oUgKq/SOG/Lun7TF9Whjito4PeC/Hksmk/XhaJRoHdTJxYNbYWZsUwdJ/SDXkwF98477xAeHg7AtWvXePnll7GwsGD16tV89NFHxd6uWq1m1apVpKWlFflWy5IlSxg6dCiWlpYAREREEBsbS8+ePbVlbG1tadeuHYcPHy52bEK/KYrC+tM36blgH2tP30Slgtc7uLNjUme6NaoF5FwVOPhxd/58+2kWDW3Jn28/zcGPu0vyJ3SUVf0myp+hgQq/Bg4MbFkbvwYOj73K/4pvXb4f1hoTQwO2n7vNyKXHSMnILqdohShbpZIAhoeH07JlSwBWr15Nly5dWLlyJcuWLePvv/9+4u2FhoZiZWWFqakp7777LuvWrcPb2/ux6x07doywsDDeeust7bLY2FgAnJycdMo6OTlpX8tPZmYmycnJOg9ROdy4l87IpceZ+FcICWlZNHKyZu3o9gQOaIqlqe5tvCf9QhDVT2nXb6Jy6dPMhWVvPIWVqRFHriUw9Kcj3PnvLEFCVGalNgyMRqMBYNeuXfTr1w8ANzc37t69+8Tba9SoESEhIRw9epTRo0czYsQIzp8//9j1lixZQvPmzfH19X3ifT5qzpw52Nraah9ubm4l3qYoW2qNwq8HI3jm6/3sC7+DiaEBk5/xYtN7HWlVt0ZFhycqqdKu30Tl075BTVaNehoHSxPO3UpmyA+HuJ6Qd3BwISqTUkkA27Zty8yZM/n999/Zt28f/fv3B3Juvz565a0oTExMaNiwIW3atGHOnDm0aNGCRYsWFbpOWloaq1atytNO0NnZGYDbt2/rLL99+7b2tfwEBASQlJSkfVy/fv2J34coPxdjk3k+6BAz/jlPepYaX3d7tkzoxLjunpgYScNtUXylXb+JyqlZbVvWjG5PnRrmRMan83zQIS7EyJ0hUXmVyjfjwoULOXXqFOPGjePTTz+lYcOGAKxZs4b27duXePsajYbMzMIvua9evZrMzEyGDx+us9zDwwNnZ2d2796tXZacnMzRo0cLbVdoamqKjY2NzkNUHLVG4fDVeDaE3OTw1XjUmpy+SxnZar7cfolnFx/kzPVErE2NmDW4GatGPU3DWlYVHLWoCsq6fhOVh0dNS/4e3Z5GTtbcScnkpR8PcyxCpo4TlVOp9AIuSEZGBoaGhhgbGxd5nYCAAPr27UvdunVJSUlh5cqVzJs3j+3bt9OrVy/8/f2pXbs2c+bM0VmvU6dO1K5dm1WrVuXZ5rx585g7d67OMDBnz559omFgqkMPOX1VUG/dV3zdWH/6FtfupgHwjLcTMwY2w9lWhvYROcryvC1O/abPpI4ruqT0bN5cfpwTUfcwNTLgu1db09NbrgaL8lXSc7ZUB7Y6efIkFy5cAMDb25vWrVs/8Tbi4uLw9/cnJiYGW1tbfHx8tMkfQHR0NAYGuhcuL126xMGDB9mxY0e+2/zoo49IS0tj1KhRJCYm0rFjR7Zt2yZjAFYC28JiGL3iVJ4R/GOSMliw8zIAjtamfD6wqfTeFWWqNOo3UTXYWhjz+5vtGLfyFLsvxvHOipPMe8GHF9vUqejQhCiyUrkCGBcXx8svv8y+ffuws7MDIDExkW7durFq1SocHR1LuosKJ7+Oy59ao9Bx3h6dK3+PMjc25NCU7tSwrBpjsYnSVRrnbXWo30DquOLIVmv4+O+zrD2VM87oJ/0aM6pzgwqOSlQXejEO4HvvvUdqairnzp0jISGBhIQEwsLCSE5OZvz48aWxC1ENHYtIKDT5A7ifreZibEo5RSSqI6nfREGMDQ348sUWvN0pZ77g2VsuMmfrBcqwZZUQpaZUbgFv27aNXbt20aRJE+0yb29vvvvuO5555pnS2IWohuJSCk/+nrScEMUh9ZsojIGBik/7e1PTypQ5Wy/y475rJKRmMfv55hjL1HFCj5XKX6dGo8m3IbSxsbF2/CwhntQDddF+RdeylracouxI/SaK4p0uDZj3QnNUKlh98gbPLj4oYwUKvVYqCWD37t2ZMGECt27d0i67efMmkyZNokePHqWxC1GNZKs1fLf3CgHrQgstpyKnN7Cvh335BCaqJanfRFFsC4th4a7L5N79vXQ7hc7z9zJ/+8WKDUyIApRKAvjtt9+SnJyMu7s7DRo0oEGDBnh4eJCcnMw333xTGrsQ1UTI9UQGfHOQ+dsvkfVAg7eLNZCT7D0s93ngAG+Zvk2UKanfxOPkjlbwaJtlRYHv9l7lnd9PkK2Wq8VCv5TaOICKorBr1y4uXsz5tdOkSRN69uxZGpvWC9JDrmylZT7gqx3hLDsUgUaBGhbGTB3gzaCWtdl+LjbfcQADB3jL0C+iUKV13lb1+g2kjiuuooxWANCmXg2+fbUVLrbm5RSZqOpKes6W6UDQVYlUjmUn+FIcn64L42bifQAGtXTls2e9cbAy1ZZRaxSORSQQl5JBLeuc275y5U88jpy3RSfHqngOX43nlZ+PFKlsDQtjFrzckm6NapVxVKI6qNBhYPbs2YO3tzfJyXnnQ0xKSqJp06YcOHCgJLsQVVhCWhaT/gph5NLj3Ey8T207c5a+/hQLh7bSSf4ADA1U+DVwYGDL2vg1cJDkT5Q5qd9EURR1FII6Ncy5l57N60uPM2/bRR7ILWFRwUqUAC5cuJC3334738zT1taWd955hwULFpRkF6IKUhSF9adv0nPBPtadvolKBa93cGfHpM7yy1jojbKo34KCgvDx8dHOL+7n58fWrVsLXScxMZGxY8fi4uKCqakpXl5ebNmyRafMzZs3GT58OA4ODpibm9O8eXNOnDjxRLGJ4inqKASzBjXH368eAEHBV3nl5yPEJN0vy9CEKFSJEsAzZ87Qp0+fAl9/5plnOHnyZEl2IaqY6wnpjFh6nIl/hZCQlkUjJ2vWjm5P4ICmWJqW6syEQpRIWdRvderUYe7cuZw8eZITJ07QvXt3Bg4cyLlz5/Itn5WVRa9evYiMjGTNmjVcunSJn3/+mdq1a2vL3Lt3jw4dOmBsbMzWrVs5f/48X331FTVq1Hii2ETx+HrY42JrlqejWq7c0Qo6etZkxsBmfPdqa6xMjTgeeY/+iw8SfCmuPMMVQqtE37i3b98udCJ0IyMj7ty5U5JdiEoov/Z6AMsORfLl9kvcz1ZjYmjA+B4NGdW5ASZGMliq0D9lUb8NGDBA5/msWbMICgriyJEjNG3aNE/5X3/9lYSEBA4dOqSNxd3dXafMvHnzcHNzY+nSpdplHh4eTxSXKD5DAxWBA7wZveIUKtCZtzy/0Qr6+7jQ1NWGsStPce5WMiOXHmdM1wa838sLIxk4WpSjEv211a5dm7CwsAJfP3v2LC4u0kuzOtkWFkPHeXt45ecjTFgVwis/H6Hd7F10/yqYz/85z/1sNb7u9myZ0Ilx3T0l+RN6q6zrN7VazapVq0hLS8PPzy/fMhs3bsTPz4+xY8fi5OREs2bNmD17Nmq1WqdM27ZtGTJkCLVq1aJVq1b8/PPPxY5LPLk+zVwIGt4aZ1vd28HOtmYEDW+dZ7QC95qW/D26Pa89nXNL+Pv/3hKOfUxPYiFKU4l6Ab/33nsEBwdz/PhxzMx0//Dv37+Pr68v3bp1Y/HixSUOtKJJD7nHyx0Lq6A/KDNjAz571ptXnqqLgXTiEOWgJOdtWdVvoaGh+Pn5kZGRgZWVFStXrqRfv375lm3cuDGRkZEMGzaMMWPGcOXKFcaMGcP48eMJDAwE0Mb2/vvvM2TIEI4fP86ECRP44YcfGDFiRIFxZGZmkpmZqX2enJyMm5ub1HElUJzRCv45e4spf4eSmvkAe0sTFrzUgq7SFloUQYUOA3P79m1at26NoaEh48aNo1GjRgBcvHiR7777DrVazalTp3ByciruLvSGJICFK8pYWLWsTTkc0EN68IpyU5Lztqzqt6ysLKKjo0lKSmLNmjX88ssv7Nu3D29v7zxlvby8yMjIICIiAkNDQwAWLFjA/PnziYmJAcDExIS2bdty6NAh7Xrjx4/n+PHjHD58uMA4pk2bxvTp0/Mslzqu/EXeTWPMH6c4H5PT43xstwZM6im3hEXhSpqXlKgNoJOTE4cOHWL06NEEBASQm0uqVCp69+7Nd999VyWSP/F4xyISHjsQalxKJsciEvBr4FBOUQlRfGVVv5mYmNCwYUMA2rRpw/Hjx1m0aBE//vhjnrIuLi4YGxtrkz/IGYQ6NjaWrKwsTExMcHFxyZM8NmnShL///rvQOAICAnj//fe1z3OvAIry517TkrVj2jNr8wV+PxLFd3uvcjziHotfaZXntrIQpaXE3S7r1avHli1buHfvHleuXEFRFDw9PaUHWjVT1LGwilpOCH1QHvWbRqPRuRX7sA4dOrBy5Uo0Gg0GBjlXg8LDw3FxccHExERb5tKlSzrrhYeHU69evUL3a2pqiqmpaaFlRPkxMzbk80HNaFffnil/h3IsMoF+iw/w9cst6eLlWNHhiSqo1K4v16hRg6eeegpfX19J/qqZ28kZ/HEkukhlizpmlhD6pLTqt4CAAPbv309kZCShoaEEBAQQHBzMsGHDAPD39ycgIEBbfvTo0SQkJDBhwgTCw8PZvHkzs2fPZuzYsdoykyZN4siRI8yePZsrV66wcuVKfvrpJ50yovJ41seVf97riLeLDQlpWYz49Rjzt+cMHK3WKBy+Gs+GkJscvhqPWiMTeYnik4HXRLFpNAqrjl9nztYLpGQ8KLSsipwecblDwghRHcXFxeHv709MTAy2trb4+Piwfft2evXqBUB0dLT2Sh+Am5sb27dvZ9KkSfj4+FC7dm0mTJjAxx9/rC3z1FNPsW7dOgICApgxYwYeHh4sXLhQm1SKyif3lvDMzedZcSSa7/ZeZce52yTdzyYu5X9Xi2VOdFESMhdwEUknEF1X76QSsDaUYxEJAPjUseW5Fi7M2nwRyH8srPyGQxCiLMl5W3RyrPTTpjO3+HDNGTKy804dJ3Vr9VahcwGL6idbreG7vVfou+gAxyISMDc25P/6N2HdmA681anBE42FJYQQonD9mrtgXcAsSbk/tKdvOi+3g8UTk1vAoshCricy5e+zXIxNAaCTZ01mD26Om72FtkyfZi708nZ+4rGwhBBC5HUsIoE7qVkFvq4AMUkZMsKCeGKSAIrHSst8wFc7wll2KAKNAjUsjJk6wJtBLWujUuVN7AwNVFIRCSFEKZARFkRZkQRQFCr4UhyfrgvjZuJ9AAa1dOWzZ71xsJLhI4QQoqwVdeSEvRfv0MvbCQsT+VoXRSN/KSJfCWlZfP7PedadvglAbTtzZg5uRjeZokgIIcqNr4c9LrZmxCZlFDjNJsD6kJscjYgnoF8TBvi45Ht3RoiHSSeQaiy/MaUURWH96Zv0XLCPdadvolLBGx082DGpsyR/QghRzgwNVAQOyJnp5dGULvf5u13qU6eGOTFJGYz/8zQv/3iE87eSyzVOUfnIMDBFVNWGSNgWFsP0Ted1pm9ztDbB0cpMOx9lY2dr5jzfnFZ1ZWBvUTlVtfO2LMmx0m/51dkPjwOYka3m5/3X+C74ChnZGgxU8Gq7unzQqxE1LE0qMHJRVkp6zkoCWERVqXLcFhbD6BWnCrydYGSgYlIvL0Z1ro+xTEYuKrGqdN6WNTlW+k+tUR47wsLNxPvM2XKBf87GAGBrbszkZ7x4tV09GY2hipEEsJxUlcpRrVHoOG+Pzq/IRzlamXDkk55SWYhKr6qct+VBjlXVcuRaPNM2ntMO29XExYZpA7xpV7/gERqKkmAK/VHSc1Y6gVQzxyISCk3+AO6kZsmYUkIIUYk9Xd+Bf97ryMpj0Xy1I5wLMcm8/NMRBrRwJaBvY1ztzHXKP+4Ws6h65P5eNSNjSgkhRPVgZGiAv587eyd3ZVi7uqhUOVPL9fhqH9/svkxGthr4X7OgRy8OxCZlMHrFKbaFxVRE+KKMSQJYjSTdz2ZDyK0ilS3q2FNCCCH0m72lCbMGN2fTuI485V6D+9lqvtoZTq+v97E1LIZpG8/l2yZcppqr2iQBrCa2hcXQa8E+9lyMK7ScipzL/r4e9uUTmBBCiHLRrLYt/3nHj0VDW+JsY8b1hPuMXnGK2OTMAtd5eKo5UbVIAljF3U7O4J3fT/DuilPEpWTiUdOS93t5oqLgMaUCB3hLw18hhKiCVCoVA1vWZvcHXRjbrUGR63ppFlT1SCeQKkqjUVh1/DpztlwgJfMBRgYq3ulSn/e6e2JmbIiXk3WeBr/O0uBXCCGqBUtTIz7s3RjPWtZM/CvkseWlWVDVIwlgFXT1TioBa0O1l+xb1LFl7gs+NHH5XzfxPs1c6OXtLF3+hRCiGhvQwpV52y4WOjqENAuqmiQBrEKyHmj4af9VFu+5QtYDDebGhkzu3YiR7d3zTewMDVQy1IsQQlRjuVPNFTY5QJ0a5oRcv0frujVkjuEqRBLAKiLkeiJT/j6rHfSzs5cjswY1w83eooIjE0IIoc/6NHMhaHjrPM2CjA1VZKsVjkfe44WgwzR1tcHfrx7PtaiNuYnhE+9HBprWL3o3E0hQUBBBQUFERkYC0LRpU6ZOnUrfvn0LXCcxMZFPP/2UtWvXkpCQQL169Vi4cCH9+vUDYNq0aUyfPl1nnUaNGnHx4sUix6Wvo+SnZT7gqx3hLD0UgaJADQtjAgc0ZWBLV/mlJqo9fT1v9ZEcK5FfgnYhJpnfD0exPuQmmQ80QM70ci8/5cbwdvWo61C0iwwy0HTpq3IzgdSpU4e5c+fi6emJoigsX76cgQMHcvr0aZo2bZqnfFZWFr169aJWrVqsWbOG2rVrExUVhZ2dnU65pk2bsmvXLu1zIyO9e+uFyu/EPHD5Dp+uC+Nm4n0ABreqzf/1b4KDlWkFRyuEEKKyya9ZULPatsx70YeAfo1ZfeIGvx2J5HrCfX7af42fD1yjW6Na+PvVo7OnIwYFXM0raP753IGmg4a3liSwAuhdFjRgwACd57NmzSIoKIgjR47kmwD++uuvJCQkcOjQIYyNjQFwd3fPU87IyAhnZ+cyibms5ffLyczYgIzsnF9jte3Mmf18c7p4OVZUiEIIIaowOwsT3u5cnzc6erAvPI7lh6LYF36HPRfj2HMxDncHC17zc+fFNnWwNTfWrqfWKEzfdL7AgaZV5Aw03cvbWW4HlzO9HgdQrVazatUq0tLS8PPzy7fMxo0b8fPzY+zYsTg5OdGsWTNmz56NWq3WKXf58mVcXV2pX78+w4YNIzo6utB9Z2ZmkpycrPOoCAVN0ZOb/PVoXIsdkzpL8ieEEKLMGRqo6N7YieVv+LJ3clfe6OCBtZkRkfHpfP7PeZ6evZtP1oVyMTbnO/Nx88/LQNMVR++uAAKEhobi5+dHRkYGVlZWrFu3Dm9v73zLXrt2jT179jBs2DC2bNnClStXGDNmDNnZ2QQGBgLQrl07li1bRqNGjYiJiWH69Ol06tSJsLAwrK2t893unDlz8rQbLG+F/XLKdT4mGTPjJ2+MK4QQQpSER01Lpg7w5oNnvFgfcpPfDkVx6XYKK49Gs/JoNL4e9ni7FK1tmgw0Xf70rhMI5LTri46OJikpiTVr1vDLL7+wb9++fJNALy8vMjIyiIiIwNAwJxFasGAB8+fPJyYm/wmsExMTqVevHgsWLODNN9/Mt0xmZiaZmf+bHic5ORk3N7dybSB9+Go8r/x85LHl/nz7aRnORYh8SMeGopNjJUpKUXLaqv92OIpt52KfaP7g0vgeq269jKtcJxAAExMTGjZsCECbNm04fvw4ixYt4scff8xT1sXFBWNjY23yB9CkSRNiY2PJysrCxMQkzzp2dnZ4eXlx5cqVAmMwNTXF1LRiO1Ocvn6vSOXkl5MQQoiKplKpaFffgXb1HYhJus+fR6P542g08WlZBa9DzixUJR1oWnoZPzm9bgOYS6PR6FyNe1iHDh24cuUKGo1Guyw8PBwXF5d8kz+A1NRUrl69iouLfv5RZGSrmb/9Il9tDy9SeZmiRwghhD5xsTXn/WcacSigO290cC+wnAK82dE9z9z0T6KgtvK5vYy3heV/N7C607sEMCAggP379xMZGUloaCgBAQEEBwczbNgwAPz9/QkICNCWHz16NAkJCUyYMIHw8HA2b97M7NmzGTt2rLbM5MmT2bdvH5GRkRw6dIjBgwdjaGjIK6+8Uu7v73GOXIun36IDfLf3KmpFwcyo4I9IhUzRI4QQQn+ZGhkydUBTfhjemppW+V+Umbn5Im1n7WLMHyf5/UgUV+JSKWrrtMf1MoacXsZPcju6utC7W8BxcXH4+/sTExODra0tPj4+bN++nV69egEQHR2NgcH/kiI3Nze2b9/OpEmT8PHxoXbt2kyYMIGPP/5YW+bGjRu88sorxMfH4+joSMeOHTly5AiOjvrTczbpfjZzt17kz2M5vZNrWZsyY2AzQGH0ilMAOn/gub+WAgd4V+k2DkIIISq/h+efj026T3qWmuSMBxy5Fs/xyAQS0rLYEhrLltBYIOc7sH0DB/waONC+Qc0CZ7V6kl7G0lZel152AtFHZdlAeltYLFM3hBGXknOb+9V2dfm4T2PtWErStkGI4pGODUUnx0pUlGy1hrM3Ejl0JZ7D1+I5EXWPrAcanTJ1apjjV9+B9g0d8KtfE2fbnKZPG0JuMmFVyGP3sWhoSwa2rF2iOPWtk0mV7ARSXdxOziBwwzm2ncv5xVO/piVznm9Ou/q6v1Ie/uWkL394QgghRGkwNjSgTT172tSz570enmRkqzkVfY8jV+M5dDWekOuJ3Lh3n9Unb7D65A0g5/vSr4EDDpZF66xZ0rbyVfFCjN61AawONBqFlUej6blgH9vOxWJkoOK97g3ZMqFTnuQvV+4UPQNb1savgYMkf0JUQkFBQfj4+GBjY4ONjQ1+fn5s3bq10HUSExMZO3YsLi4umJqa4uXlxZYtW/ItO3fuXFQqFRMnTiyD6IUoH2bGhrRvUJP3n2nEmtHtORP4DMvf8OWdLvVpUccWAxVcu5vGH0ejWbzncqHbKo228lW1k4lcASxnV++kErA2VDvqeQs3O+a90JzGznLLRYiqrqzmOgc4fvw4P/74Iz4+PuXwToQoP5amRnTxctTOeJV0P5tjEQkcvhrPoat3uRibUuC6CuBoZcqn60JxtDalplXOI+f/Jjham2JlaoRKlf9FldKeyk6tUUi+n03i/WzupWeRmJ5FYno299KzSUzP+u+ybCY/0wj3mpaPPzglIAlgKSuojUC2WsNP+6+xaPdlsh5osDAxZPIzjRjR3l2u5glRTZTVXOepqakMGzaMn3/+mZkzZ5ZJ7ELoC1tzY3p5O9HL2wmA+NRMfth3lT+ORpOepc5T/uzNJM7eTCpwe6ZGBtrk8OF/Ha1MSEjLLlInk18OXMPFzvyhhC7n35ykLuffxPvZJN3Ppig9L1rUseONjh5lmh9IJ5AiKkpjy4LaCPj71WNDyC3tr5QuXo7MHNSswF5NQojSoc8dG9RqNatXr2bEiBGcPn0635mO+vXrh729PRYWFmzYsAFHR0deffVVPv74Y53B70eMGIG9vT1ff/01Xbt2pWXLlixcuLDQ/evDbEdClKbcCzA37qVjamRA7RoWxKdmcjc1izspmdxNzfzfv6mZ3E3JJC2fhLE8WJkaYWtuTA1LY2pYmHA/S835mGSdBPZxbQylE4ieyG0j8Gg2HZOUwbxtlwCoYWFM4ICmDGzpWuDlZiFE1Vbac52vWrWKU6dOcfz48SeKQx/mOxeiNOW2lYeiD/eSnvWAuylZ3Hk4OXzo34i7aVyOS33sdtxqmONqZ04NCxPsLIyxszChhoXxQ//PeW5rYYyduQkmD43xW1D+kNvGMGh46zLpaCJXAIuosExbrVHoOG9PoZeJzY0N2PdhN2rZyKwdQpQXfbwCWJpznV+/fp22bduyc+dObds/uQIoROnJ/X6PTcrItx0g5FypO/hx92Ldrn1c/pA7VV5+2y9p/Sa9gEvB4waiBLifreHqnbRyikgIoa9y5zpv06YNc+bMoUWLFixatCjfsi4uLnh5eRU41/nJkyeJi4ujdevWGBkZYWRkxL59+1i8eDFGRkao1QXf3jI1NdX2Rs59CCF0GRqoCByQ8+Ps0fRO9d9HSSZkeJKBrEubJIClIC6l8OTvScsJIaqPksx13qNHD0JDQwkJCdE+2rZty7BhwwgJCdFJHIUQxdOnmQtBw1trB5/O5WxrVuLbsxWZP0gbwFJQ1AEmSzoQpRCicgsICKBv377UrVuXlJQUVq5cSXBwMNu3bwdy5jqvXbs2c+bMAXLmOv/222+ZMGEC7733HpcvX2b27NmMHz8eAGtra5o1a6azD0tLSxwcHPIsF0IUX1lNyFCR+YMkgKXA18MeF1uzAtsI5N7DL8lAlEKIyq8s5joXQpSP/3UyKT0VmT9IJ5Aielxjy9xePIDOh5j726CsevEIIQqmj51A9JUcKyEqRnHzB+kEoifKso2AEEIIIaqmisof5BZwKSqrNgJCCCGEqLoqIn+QBLCIcu+UJycnP7ZsU0djmjrmTNuUllrwHIVCiLKVe75KS5fHe5I6TghRNp4kfyhp/SYJYBGlpOR8EG5ubhUciRDiSaWkpGBra1vRYeg1qeOEqJyKW79JJ5Ai0mg03Lp1C2tra5nGrQhyZxW4fv26NCgvRXJcn4yiKKSkpODq6qrTu1bkVdQ6rrL/DUr8FUviLz0lrd/kCmARGRgYUKdOnYoOo9KRGQbKhhzXopMrf0XzpHVcZf8blPgrlsRfOkpSv8lPYiGEEEKIakYSQCGEEEKIakYSQFEmTE1NCQwMxNTUtKJDqVLkuIqKVtn/BiX+iiXx6w/pBCKEEEIIUc3IFUAhhBBCiGpGEkAhhBBCiGpGEkAhhBBCiGpGEkAhhBBCiGpGEkBRbHPmzOGpp57C2tqaWrVqMWjQIC5duqRTJiMjg7Fjx+Lg4ICVlRUvvPACt2/frqCIK6e5c+eiUqmYOHGidpkcV1FRvvvuO9zd3TEzM6Ndu3YcO3asokPKV1WqnypjHXDz5k2GDx+Og4MD5ubmNG/enBMnTmhfVxSFqVOn4uLigrm5OT179uTy5csVGPH/qNVqPvvsMzw8PDA3N6dBgwZ8/vnnOnPu6nP8RaYIUUy9e/dWli5dqoSFhSkhISFKv379lLp16yqpqanaMu+++67i5uam7N69Wzlx4oTy9NNPK+3bt6/AqCuXY8eOKe7u7oqPj48yYcIE7XI5rqIirFq1SjExMVF+/fVX5dy5c8rbb7+t2NnZKbdv367o0PKoKvVTZawDEhISlHr16ikjR45Ujh49qly7dk3Zvn27cuXKFW2ZuXPnKra2tsr69euVM2fOKM8995zi4eGh3L9/vwIjzzFr1izFwcFB+eeff5SIiAhl9erVipWVlbJo0SJtGX2Ov6gkARSlJi4uTgGUffv2KYqiKImJiYqxsbGyevVqbZkLFy4ogHL48OGKCrPSSElJUTw9PZWdO3cqXbp00Vb+clxFRfH19VXGjh2rfa5WqxVXV1dlzpw5FRhV0VTG+qmy1gEff/yx0rFjxwJf12g0irOzszJ//nztssTERMXU1FT5888/yyPEQvXv31954403dJY9//zzyrBhwxRF0f/4i0puAYtSk5SUBIC9vT0AJ0+eJDs7m549e2rLNG7cmLp163L48OEKibEyGTt2LP3799c5fiDHVVSMrKwsTp48qfN3Z2BgQM+ePSvF311lrJ8qax2wceNG2rZty5AhQ6hVqxatWrXi559/1r4eERFBbGysTvy2tra0a9dOL+Jv3749u3fvJjw8HIAzZ85w8OBB+vbtC+h//EVlVNEBiKpBo9EwceJEOnToQLNmzQCIjY3FxMQEOzs7nbJOTk7ExsZWQJSVx6pVqzh16hTHjx/P85ocV1ER7t69i1qtxsnJSWe5k5MTFy9erKCoiqYy1k+VuQ64du0aQUFBvP/++3zyySccP36c8ePHY2JiwogRI7Qx5ve3pA/xT5kyheTkZBo3boyhoSFqtZpZs2YxbNgwAL2Pv6gkARSlYuzYsYSFhXHw4MGKDqXSu379OhMmTGDnzp2YmZlVdDhCVHqVrX6q7HWARqOhbdu2zJ49G4BWrVoRFhbGDz/8wIgRIyo4usf7z3/+wx9//MHKlStp2rQpISEhTJw4EVdX10oRf1HJLWBRYuPGjeOff/5h79691KlTR7vc2dmZrKwsEhMTdcrfvn0bZ2fnco6y8jh58iRxcXG0bt0aIyMjjIyM2LdvH4sXL8bIyAgnJyc5rqLc1axZE0NDwzw9TfX9764y1k+VvQ5wcXHB29tbZ1mTJk2Ijo4G0Maor39LH374IVOmTGHo0KE0b96c1157jUmTJjFnzhxA/+MvKkkARbEpisK4ceNYt24de/bswcPDQ+f1Nm3aYGxszO7du7XLLl26RHR0NH5+fuUdbqXRo0cPQkNDCQkJ0T7atm3LsGHDtP+X4yrKm4mJCW3atNH5u9NoNOzevVsv/+4qc/1U2euADh065BlyJzw8nHr16gHg4eGBs7OzTvzJyckcPXpUL+JPT0/HwEA3PTI0NESj0QD6H3+RVXQvFFF5jR49WrG1tVWCg4OVmJgY7SM9PV1b5t1331Xq1q2r7NmzRzlx4oTi5+en+Pn5VWDUldPDPQAVRY6rqBirVq1STE1NlWXLlinnz59XRo0apdjZ2SmxsbEVHVoeVa1+qkx1wLFjxxQjIyNl1qxZyuXLl5U//vhDsbCwUFasWKEtM3fuXMXOzk7ZsGGDcvbsWWXgwIF6M4zKiBEjlNq1a2uHgVm7dq1Ss2ZN5aOPPtKW0ef4i0oSQFFsQL6PpUuXasvcv39fGTNmjFKjRg3FwsJCGTx4sBITE1NxQVdSj1b+clxFRfnmm2+UunXrKiYmJoqvr69y5MiRig4pX1WtfqpsdcCmTZuUZs2aKaampkrjxo2Vn376Sed1jUajfPbZZ4qTk5Niamqq9OjRQ7l06VIFRasrOTlZmTBhglK3bl3FzMxMqV+/vvLpp58qmZmZ2jL6HH9RqRTloaGthRBCCCFElSdtAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAEW1FhkZiUqlIiQk5InX3b17N02aNEGtVhd7/1lZWbi7u3PixIlib0MIIYR4UpIAigozcuRIVCoVKpUKY2NjnJyc6NWrF7/++qt2zsXS3t+gQYNKbXsfffQR//d//4ehoWGxt2FiYsLkyZP5+OOPSy0uIUTxde3alYkTJz7xeiqVivXr15d6POVh2bJl2NnZVXQYZUZ+rOdPEkBRofr06UNMTAyRkZFs3bqVbt26MWHCBJ599lkePHhQ0eEV6ODBg1y9epUXXnihxNsaNmwYBw8e5Ny5c6UQmRCVW+6PwoIe06ZNq+gQK42Hj5ulpSWenp6MHDmSkydP6pR7+eWXCQ8PL9I2K2OyKD/W8ycJoKhQpqamODs7U7t2bVq3bs0nn3zChg0b2Lp1K8uWLdOWS0xM5K233sLR0REbGxu6d+/OmTNntK9PmzaNli1b8uOPP+Lm5oaFhQUvvfQSSUlJ2teXL1/Ohg0btBVicHCwdv1r167RrVs3LCwsaNGiBYcPHy407lWrVtGrVy/MzMzyxPDrr79St25drKysGDNmDGq1mi+++AJnZ2dq1arFrFmzdLZVo0YNOnTowKpVq0pwJIWoGmJiYrSPhQsXYmNjo7Ns8uTJFR1ipbJ06VJiYmI4d+4c3333HampqbRr147ffvtNW8bc3JxatWpVYJRlR36sF0wSQKF3unfvTosWLVi7dq122ZAhQ4iLi2Pr1q2cPHmS1q1b06NHDxISErRlrly5wn/+8x82bdrEtm3bOH36NGPGjAFg8uTJvPTSS9orjjExMbRv31677qeffsrkyZMJCQnBy8uLV155pdArkAcOHKBt27Z5ll+9epWtW7eybds2/vzzT5YsWUL//v25ceMG+/btY968efzf//0fR48e1VnP19eXAwcOFPuYCVFVODs7ax+2traoVCrt81q1arFgwQLq1KmDqakpLVu2ZNu2bdp1g4ODUalUJCYmapeFhISgUqmIjIzULvv333/p2rUrFhYW1KhRg969e3Pv3j3t6xqNho8++gh7e3ucnZ3zXHW8fPkynTt3xszMDG9vb3bu3JnnfYSGhtK9e3fMzc1xcHBg1KhRpKamAhAWFoaBgQF37twBICEhAQMDA4YOHapdf+bMmXTs2FHnfe3evZu2bdtiYWFB+/btuXTp0mOPp52dHc7Ozri7u/PMM8+wZs0ahg0bxrhx47Tv+dGremfOnKFbt25YW1tjY2NDmzZtOHHiBMHBwbz++uskJSXluSL7+++/07ZtW6ytrXF2dubVV18lLi4uz2fzuPewadMmnnrqKczMzKhZsyaDBw/WvpaZmcnkyZOpXbs2lpaWtGvXTueHfH7kx3rBJAEUeqlx48baCvvgwYMcO3aM1atX07ZtWzw9Pfnyyy+xs7NjzZo12nUyMjL47bffaNmyJZ07d+abb75h1apVxMbGYmVlhbm5ufaKo7OzMyYmJtp1J0+eTP/+/fHy8mL69OlERUVx5cqVAuOLiorC1dU1z3KNRsOvv/6Kt7c3AwYMoFu3bly6dImFCxfSqFEjXn/9dRo1asTevXt11nN1dSUqKqqER02Iqm3RokV89dVXfPnll5w9e5bevXvz3HPPcfny5SJvIyQkhB49euDt7c3hw4c5ePAgAwYM0Gkftnz5ciwtLTl69ChffPEFM2bM0CZ5Go2G559/HhMTE44ePcoPP/yQ57ZgWloavXv3pkaNGhw/fpzVq1eza9cuxo0bB0DTpk1xcHBg3759QM4PyoefA+zbt4+uXbvqbPfTTz/lq6++4sSJExgZGfHGG2880fHLNWnSJFJSUvJNXCHnSledOnU4fvw4J0+eZMqUKRgbG9O+ffs8V2Vzr8hmZ2fz+eefc+bMGdavX09kZCQjR47Ms+3C3sPmzZsZPHgw/fr14/Tp0+zevRtfX1/t6+PGjePw4cOsWrWKs2fPMmTIEPr06VPo5y8/1guhCFFBRowYoQwcODDf11566SXF29tbURRF+fbbbxUDAwPF0tJS52FgYKB89NFHiqIoSmBgoOLh4aGzjcTERAVQgoODC9xfRESEAijHjh3TLktISFAAZd++fQXGbmJiovznP//RWRYYGKiNOZe/v7/Sr18/nWWdO3dWJk2apLPsp59+UmrVqlXg/oSojpYuXarY2tpqn7u6uiqzZs3SKfPUU08pY8aMURRFUfbu3asAyr1797Svnz59WgGUiIgIRVEU5ZVXXlE6dOhQ4D67dOmidOzYMc8+Pv74Y0VRFGX79u2KkZGRcvPmTe3rW7duVQBl3bp1iqLknM81atRQUlNTtWU2b96sGBgYKLGxsYqiKMrzzz+vjB07VlEURZk4caLy4YcfKjVq1FAuXLigZGVlKRYWFsqOHTt03teuXbt0tgco9+/fL/C9PBzTw+7fv68Ayrx58xRFyXucra2tlWXLluW7zUfLFuT48eMKoKSkpBT5Pfj5+SnDhg3Ld3tRUVGKoaGhznFXFEXp0aOHEhAQUGActra2ym+//aazLDAwULGwsFCSk5O1y3r37q24u7srarVau6xRo0bKnDlzdNZdtGiR4u7uXthbrzSMKiTrFOIxLly4gIeHBwCpqam4uLjke6m/tBojGxsba/+vUqkACu2JXLNmTZ1bRvltJ3db+S17dNsJCQk4Ojo+cdxCVBfJycncunWLDh066Czv0KGDTnvgxwkJCWHIkCGFlvHx8dF57uLior2deeHCBdzc3HTuAPj5+emUv3DhAi1atMDS0lInTo1Gw6VLl3BycqJLly789NNPQM7VvtmzZxMeHk5wcDAJCQlkZ2fnea8Px+Xi4gJAXFwcdevWLerbB0BRFOB/dd2j3n//fd566y1+//13evbsyZAhQ2jQoEGh2zx58iTTpk3jzJkz3Lt3T1vHRUdH4+3tXaT3EBISwttvv53v9kNDQ1Gr1Xh5eeksz8zMxMHBocC47t+/r3P7N5e7uzvW1tba505OThgaGmJgYKCz7OHb2JDTXjI9Pb3A/VUmkgAKvbNnzx5CQ0OZNGkSAK1btyY2NhYjIyPc3d0LXC86Oppbt25pK+YjR45gYGBAo0aNgJxeXCUZBuBhrVq14vz586WyLchpE9SqVatS254Q1VHul3duggM5tyYfZm5u/tjtFOVHW0nlDjdz+fJlzp8/T8eOHbl48SLBwcHcu3dP206uoLiK8kO1IBcuXADQ/sh+1LRp03j11VfZvHkzW7duJTAwkFWrVum0x3tY7i3v3r1788cff+Do6Eh0dDS9e/cmKyuryO+hsM8mNTUVQ0NDTp48mac3r5WVVYHryY/1gkkbQFGhMjMziY2N5ebNm5w6dYrZs2czcOBAnn32Wfz9/QHo2bMnfn5+DBo0iB07dhAZGcmhQ4f49NNPdcZkMjMzY8SIEZw5c4YDBw4wfvx4XnrpJZydnYGcX3xnz57l0qVL3L17N88Xw5Po3bs3Bw8eLNmbf8iBAwd45plnSm17QlQ1NjY2uLq68u+//+os//fff7VXmHK/mGNiYrSvPzrIu4+PD7t37y52HE2aNOH69es6+zhy5EieMmfOnCEtLU0nzod/kDZv3pwaNWowc+ZMWrZsiZWVFV27dmXfvn0EBwfnaf9XmnLb8fXs2bPAMl5eXkyaNIkdO3bw/PPPs3TpUiD/H9IXL14kPj6euXPn0qlTJxo3bpznyllRFPbZtGrVCrVaTVxcHA0bNtR55NbxBa0nP9bzJwmgqFDbtm3DxcUFd3d3+vTpw969e1m8eDEbNmzQ/spTqVRs2bKFzp078/rrr+Pl5cXQoUOJiorCyclJu62GDRvy/PPP069fP5555hl8fHz4/vvvta+//fbbNGrUiLZt2+Lo6Jjni+RJDBs2jHPnzhWpF97jHD58mKSkJF588cUSb0uIquzDDz9k3rx5/PXXX1y6dIkpU6YQEhLChAkTgJw6wM3NjWnTpnH58mU2b97MV199pbONgIAAjh8/zpgxYzh79iwXL14kKCiIu3fvFimGnj174uXlpfNj89NPP9UpM2zYMO0P0rCwMPbu3ct7773Ha6+9pq2zVCoVnTt35o8//tAmez4+PmRmZrJ79266dOlSwqOVIzExkdjYWKKioti5cycvvvgiK1euJCgoKN8mNPfv32fcuHEEBwcTFRXFv//+y/Hjx2nSpAmQ80M6NTWV3bt3c/fuXdLT06lbty4mJiZ88803XLt2jY0bN/L5558/cayBgYH8+eefBAYGcuHCBUJDQ5k3bx6Qk5AOGzYMf39/1q5dS0REBMeOHWPOnDls3ry5wG3Kj/VCVHQjRCFKQ2BgoNKiRYty3efkyZOVUaNGlXg7L730Up6G7UKIvB0O1Gq1Mm3aNKV27dqKsbGx0qJFC2Xr1q066xw8eFBp3ry5YmZmpnTq1ElZvXq1TicQRVGU4OBgpX379oqpqaliZ2en9O7dW9txpEuXLsqECRN0tjlw4EBlxIgR2ueXLl1SOnbsqJiYmCheXl7Ktm3b8nS4OHv2rNKtWzfFzMxMsbe3V95++21th4hcX3/9tQLovIeBAwcqRkZGOmWL0rklP4D2YWZmpjRo0EAZMWKEcvLkyQKPc2ZmpjJ06FDFzc1NMTExUVxdXZVx48bpdDZ59913FQcHBwVQAgMDFUVRlJUrVyru7u6Kqamp4ufnp2zcuFEBlNOnTz/Re/j777+Vli1bKiYmJkrNmjWV559/XvtaVlaWMnXqVMXd3V0xNjZWXFxclMGDBytnz54t8BjEx8crZmZmysWLF7XL8vu+yK+T4KN/C4cOHVLs7OyU9PT0AvdXmagU5aHGEkJUUtOmTWP9+vXFmtO3uBITE/n++++ZMmWKTsPhJ5GVlcUXX3zBBx98UKS2SUIIIZ7Mhx9+SHJyMj/++GOJtvPyyy/TokULPvnkk1KKrGLJLWAhisnOzo5PPvmk2Mkf5LSn+b//+z9J/oQQoox8+umn1KtXr0QdebKysmjevLm2c2JVIFcAhRBCCCGqGbkCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKErE3d2dkSNHVsi+p02bhkqlqpB967uRI0diZWVV0WEIIYTQU5IAinwtW7YMlUqV72PKlCnlFkd6ejrTpk0jODi43PZZFCNHjtQ5JlZWVtSvX58XX3yRv//+G41GU+Yx6OuxEUIIof+MKjoAod9mzJiBh4eHzrJmzZqV2/7T09OZPn06AF27dtV57f/+7//KNRl9lKmpKb/88gsA9+/fJyoqik2bNvHiiy/StWtXNmzYgI2NTZntv7BjI4QQQhRGEkBRqL59+9K2bduKDiNfRkZGGBlV3J+wkZERw4cP11k2c+ZM5s6dS0BAAG+//TZ//fVXBUUnhBBCFExuAYtSd+3aNYYMGYK9vT0WFhY8/fTTbN68WadMVlYWU6dOpU2bNtja2mJpaUmnTp3Yu3evtkxkZCSOjo4ATJ8+XXu7ddq0aUD+bQBVKhXjxo1j/fr1NGvWDFNTU5o2bcq2bdvyxBkcHEzbtm0xMzOjQYMG/Pjjj6XSrnDKlCk888wzrF69mvDwcJ3Xtm7dSqdOnbC0tMTa2pr+/ftz7tw5nTK57feuXbtG7969sbS0xNXVlRkzZqAoSpGOTa6bN28yaNAgrKyscHR0ZPLkyajV6hK9PyGEEJWfJICiUElJSdy9e1fnUZjbt2/Tvn17tm/fzpgxY5g1axYZGRk899xzrFu3TlsuOTmZX375ha5duzJv3jymTZvGnTt36N27NyEhIQA4OjoSFBQEwODBg/n999/5/fffef755wuN4eDBg4wZM4ahQ4fyxRdfkJGRwQsvvEB8fLy2zOnTp+nTpw/x8fFMnz6dN998kxkzZrB+/friHahHvPbaayiKws6dO7XLfv/9d/r374+VlRXz5s3js88+4/z583Ts2JHIyEid9dVqNX369MHJyYkvvviCNm3aEBgYSGBgYJGPjVqtpnfv3jg4OPDll1/SpUsXvvrqK3766adSeY9CCCEqMUWIfCxdulQB8n08rF69esqIESO0zydOnKgAyoEDB7TLUlJSFA8PD8Xd3V1Rq9WKoijKgwcPlMzMTJ1t3bt3T3FyclLeeOMN7bI7d+4ogBIYGJgnxsDAwDzxAIqJiYly5coV7bIzZ84ogPLNN99olw0YMECxsLBQbt68qV12+fJlxcjIKM828zNixAjF0tKywNdPnz6tAMqkSZO0x8DOzk55++23dcrFxsYqtra2OstHjBihAMp7772nXabRaJT+/fsrJiYmyp07dxRFKfzY5G5jxowZOstbtWqltGnT5rHvTwghRNUmVwBFob777jt27typ8yjMli1b8PX1pWPHjtplVlZWjBo1isjISM6fPw+AoaEhJiYmAGg0GhISEnjw4AFt27bl1KlTJYq5Z8+eNGjQQPvcx8cHGxsbrl27BuRcGdu1axeDBg3C1dVVW65hw4b07du3RPvOlTsES0pKCgA7d+4kMTGRV155RedqqqGhIe3atdO59Z1r3Lhx2v/n3trOyspi165dRY7j3Xff1XneqVMn7XEQQghRfUknkGLYv38/8+fP5+TJk8TExLBu3ToGDRpU5PWnTZum7b35MAsLC9LS0kox0pLz9fV9ok4gUVFRtGvXLs/yJk2aaF/P7UW8fPlyvvrqKy5evEh2dra27KO9jp9U3bp18yyrUaMG9+7dAyAuLo779+/TsGHDPOXyW1YcqampAFhbWwNw+fJlALp3755v+Ud7CxsYGFC/fn2dZV5eXgB5bhcXxMzMTNtOMNfDx0EIIUT1JQlgMaSlpdGiRQveeOONx7ZHy8/kyZPzXJnp0aMHTz31VGmFqPdWrFjByJEjGTRoEB9++CG1atXC0NCQOXPmcPXq1RJt29DQMN/lyn87UJSHsLAw4H8JZe64gL///jvOzs55ypdFb+aCjoMQQgghCWAx9O3bt9BbhZmZmXz66af8+eefJCYm0qxZM+bNm6cdq83KykpnloYzZ85w/vx5fvjhh7IOvczVq1ePS5cu5Vl+8eJF7esAa9asoX79+qxdu1an121uJ4dcZTHTR61atTAzM+PKlSt5XstvWXH8/vvvqFQqevXqBaC9JV2rVi169uz52PU1Gg3Xrl3TXvUDtD2K3d3dgbI5NkIIIaoHaQNYBsaNG8fhw4dZtWoVZ8+eZciQIfTp00d7G/BRv/zyC15eXnTq1KmcIy19/fr149ixYxw+fFi7LC0tjZ9++gl3d3e8vb2B/12deviq3NGjR3XWg5zb4gCJiYmlFqOhoSE9e/Zk/fr13Lp1S7v8ypUrbN26tcTbnzt3Ljt27ODll1/G09MTgN69e2NjY8Ps2bN1bnfnunPnTp5l3377rfb/iqLw7bffYmxsTI8ePYCyOTZCCCGqB7kCWMqio6NZunQp0dHR2g4GkydPZtu2bSxdupTZs2frlM/IyOCPP/6o0BktStOUKVP4888/6du3L+PHj8fe3p7ly5cTERHB33//jYFBzm+OZ599lrVr1zJ48GD69+9PREQEP/zwA97e3tr2cwDm5uZ4e3vz119/4eXlhb29Pc2aNSvxbCTTpk1jx44ddOjQgdGjR6NWq/n2229p1qyZdhiax3nw4AErVqwAcj7HqKgoNm7cyNmzZ+nWrZvOcCs2NjYEBQXx2muv0bp1a4YOHYqjoyPR0dFs3ryZDh066CR8ZmZmbNu2jREjRtCuXTu2bt3K5s2b+eSTT7Tt+srq2AghhKj6JAEsZaGhoajVap1bd5BzW9jBwSFP+XXr1pGSksKIESPKK8Qy5eTkxKFDh/j444/55ptvyMjIwMfHh02bNtG/f39tuZEjRxIbG8uPP/7I9u3b8fb2ZsWKFaxevTrP3La//PIL7733HpMmTSIrK4vAwMASJzlt2rRh69atTJ48mc8++ww3NzdmzJjBhQsXtLerHyczM5PXXnsNyLkaV6tWLdq0acPUqVMZPHiwNtnN9eqrr+Lq6srcuXOZP38+mZmZ1K5dm06dOvH666/rlDU0NGTbtm2MHj2aDz/8EGtrawIDA5k6dapOubI4NkIIIao+lVKeLeOrIJVKpdML+K+//mLYsGGcO3cuTyN8KyurPB0AevTogY2Njc4gyaLiDBo0iHPnzhV4u748jBw5kjVr1uhcCRVCCCFKk1wBLGWtWrVCrVYTFxf32DZ9ERER7N27l40bN5ZTdOJh9+/fx9zcXPv88uXLbNmypcpcjRVCCCEKIglgMaSmpur0Fo2IiCAkJAR7e3u8vLwYNmwY/v7+fPXVV7Rq1Yo7d+6we/dufHx8dG6D/vrrr7i4uJTa4MPiydSvX5+RI0dSv359oqKiCAoKwsTEhI8++qiiQxNCCCHKlCSAxXDixAm6deumff7+++8DMGLECJYtW8bSpUuZOXMmH3zwATdv3qRmzZo8/fTTPPvss9p1NBoNy5YtY+TIkTJeWwXp06cPf/75J7GxsZiamuLn58fs2bO1PXeFEEKIqkraAAohhBBCVDMyDqAQQgghRDUjCaAQQgghRDUjbQCLSKPRcOvWLaytrWUKLiEqCUVRSElJwdXVNc+4jEIIUZ1JAlhEt27dws3NraLDEEIUw/Xr16lTp05FhyGEEHpDEsAisra2BnK+SGxsbCo4GiFEUSQnJ+Pm5qY9f4UQQuSQBLCIcm/72tjYSAIoRCUjzTaEEEKXNIoRQgghhKhmJAEUQgghhKhmJAEUQlQaGo3CltAYTkXfq+hQhBCiUpM2gEIIvacoCtvP3WbhrnAuxqbg627PX+88LW37hBCimPTuCmBQUBA+Pj7azhZ+fn5s3bq1wPJdu3ZFpVLlefTv3x+A7OxsPv74Y5o3b46lpSWurq74+/tz69at8npLQohiUhSFXedv8+w3B3l3xUkuxqZgZWrE0w0cUGtkFkshhCguvbsCWKdOHebOnYunpyeKorB8+XIGDhzI6dOnadq0aZ7ya9euJSsrS/s8Pj6eFi1aMGTIEADS09M5deoUn332GS1atODevXtMmDCB5557jhMnTpTb+xJCFJ2iKARfusPXu8I5eyMJAEsTQ17v4MFbnTywszCp4AiFEKJyUymKovc/o+3t7Zk/fz5vvvnmY8suXLiQqVOnEhMTg6WlZb5ljh8/jq+vL1FRUdStW7dIMSQnJ2Nra0tSUpIMAyNEGVEUhQOX77JgZzgh1xMBMDc2ZER7d0Z1ro+95ZMlfnLeCiFE/vTuCuDD1Go1q1evJi0tDT8/vyKts2TJEoYOHVpg8geQlJSESqXCzs6uwDKZmZlkZmZqnycnJxc5biHEk1EUhUNX4/l6ZzgnonI6eJgZG/Da0/V4p0sDalqZVnCEQghRtehlAhgaGoqfnx8ZGRlYWVmxbt06vL29H7vesWPHCAsLY8mSJQWWycjI4OOPP+aVV14p9IrAnDlzmD59erHiF0IU3ZFr8SzYGc6xiAQATIwMGN6uHu92rU8ta7MKjk4IIaomvbwFnJWVRXR0NElJSaxZs4ZffvmFffv2PTYJfOeddzh8+DBnz57N9/Xs7GxeeOEFbty4QXBwcKEJYH5XAN3c3ORWkhCl5ERkAgt2hnPoajwAJoYGvOLrxphuDXGyKZ3ET24BCyFE/vTyCqCJiQkNGzYEoE2bNhw/fpxFixbx448/FrhOWloaq1atYsaMGfm+np2dzUsvvURUVBR79ux57JeBqakppqZy20mI0nYq+h5f7wznwOW7ABgbqnj5KTfGdG2Iq515BUcnhBDVg14mgI/SaDQ6V+Pys3r1ajIzMxk+fHie13KTv8uXL7N3714cHBzKKlQhRAHOXE/k613hBF+6A4CRgYohbeswtltD6tSwqODohBCietG7BDAgIIC+fftSt25dUlJSWLlyJcHBwWzfvh0Af39/ateuzZw5c3TWW7JkCYMGDcqT3GVnZ/Piiy9y6tQp/vnnH9RqNbGxsUBO72ITExlOQoiyFHYziYW7wtl1IQ4AQwMVz7eqzXvdPanrIImfEEJUBL1LAOPi4vD39ycmJgZbW1t8fHzYvn07vXr1AiA6OhoDA93xqy9dusTBgwfZsWNHnu3dvHmTjRs3AtCyZUud1/bu3UvXrl3L5H0IUd1diElm4a5wtp+7DYCBCga1qs347p641yy4l74QQoiyp5edQPSRNCYXomguxaawaHc4W0JzrrSrVPBcC1fG9/CkgaNVucYi560QQuRP764ACiEqpytxKSzafYV/zt4i92flsz4uTOjhiaeTdcUGJ4QQQockgEKIErl2J5XFuy+z4cz/Er++zZyZ0NOTxs5y1U0IIfSRJIBCiGKJik9j8e4rrDt9A81/E79e3k5M7OlJU1fbig1OCCFEoSQBFEI8kesJ6Xyz5zJ/n7qJ+r+ZX4/GtZjY04vmdSTxE0KIykASQCFEkdxMvM+3e66w+sR1Hvw38evi5cikXl60dLOr2OCEEEI8EUkAhRCFikm6z3d7r/DX8etkq3MSv06eNZnY04s29WpUcHRCCCGKQxJAIUS+bidnEBR8lZVHo8lSawDwq+/ApF5e+HrYV3B0QgghSkISQCGqmezMNJJTbpKSGkNKWhwp6XGkZSZRw8oV55qNUVl4suTf2/xxNIrMBzmJn6+7PZN6eeHXQKZRFEKIqkASQCEqGY36ASmpt0hJuUVK2m2S026Tkh5PSkYCyZlJJGclkZKVSsqDdJLVGaRoskjRZJOMhhQV3DdQFbp9laJQQ63Q2M0AO8WculYONKxRh+RbdTlz3xNnR29qOjTG0EimURRCiMpKEkBRrak1CsciEohLyaCWtRm+HvYYPiZBKs9tKhoNEVHBnLy8iZN3QjiVeYdYA1BUT7A9FWCY+5//sdIoWCtgjSEGakhSqYk3hCwDFQlGKhKMAO5zSn0D7t6Au0e06xopCo4acDYwxdnICmcze5wsXXC2rYezvSe1HJpyOdGeO2lZpXZcoWw+LyGEqI4kARTV1rawGKZvOk9MUoZ2mYutGYEDvOnTzKVCtql+kEX41a2cvLaVk3fDOPUgkYSHExzD//3f9L8JnC0GWBsYYW1ggrWhGTZGFlgbW2FjYoONmR3WZvZYmztgY+mEtaUTNtYuWFm5kpqlYsras2wLi+V/80FqcLeMZ9TTGpws7xCbFMXttBhiMxKIfZBKrCaTOAN4oFIRYwgxZIE6AdISIO0KxB3QbslEo+CSrcI+zZFvHrRj+DNv069F/WId19I4tkIIIf5H5gIuIplTtGrZFhbD6BWnePSPPze9Chre+omTiuJsMzszjXPh6zkRuZOTCRcJ0aSS+sgVLVONQr0MIyzv1yIxvQm37nuTrHEgWzEvVqzJGdn8ejCCH/ZdJSNbk+f1xx0D9YMs7sZfJPbOeWLvXSY2+Tqx6bHczkjgRlYqcWSTYKjKc5XSSq2htcqOXnU70tFnJDUdmxQ55uJ+XnLeCiFE/iQBLCL5Iqk61BqFjvP26FxJepgKcLY14+DH3Yt8e7Go29z5ng9hl9ZyMjqYk0mXOatkkPnIPiw1Cq0MrGhToxEt6/Vk0uYaXE/OP44niTUlI5tl/0by84FrJGc8KLRsSY+BMRk4mlynjvkZjK3OE2WZSpKhgU75phpDOtk1obPX8zRtPBgDw/xvSJTk85LzVggh8ie3gEW1cywiocBkAkABYpIyOBaRUORerwVt09rgDp6WR7GyuESyxV06rdHwIPfKmApQqaihUWhjZEdrh6a0qd+XRg37aTtYHL4az/XkI3m2+ySxpmU+YPnhSH7af43E9GwAatuZczPxfpkdg2zMuJXlya0sT0gCAx7gZX6MWtbHybCL44KhmnMGas4lh/HDiTDsj02ng0ktOrt1wa/F69ja1s13u6UVqxBCVHeSAIpqJy6l4GSiOOUeLVvDMIZmNdZxzyaaaBOFyzq3QlU4qRXamjrS2rEFbT0H4FGvGyoDg7wbLWGs6VkP+P1wFD/uv0ZCWhYA9R0tmdjTC7Vaw6T/nCnWdotTVoMRF++35+L99izq3pIOtZM5eHYZ+28d4vCDeyQYqNj04A6bItZgeG01LTClk0NzOjd5mdvJzUq8fyGEELokARTVTi1rs1ItB+BoaUIT83+xt9/NBes0QrRJnwrXLIVa923ITvfg9e6v80zb7gUmfKURa0a2mhVHovhh31XupuYkfu4OFkzo6clzLWpjaKDi8NX4Ut3/k8Za07E2g3rMYxCQnZ1OSNifHLj6DweSr3LFEE6RxamEkyz69yROaoVOrrakpzTnQmpn0pX85xt+kliFEKK6kwRQVDu+Hva42JoRm5SRp1MB/K9NWVFmu8i4f4+t/87mz+s7ueGu5sZ/t+CRAZaJzbic3JVL6jqE/3ebPdt2R/UEw5Y8SawZ2WpWHYvm++CrxKVkAlDX3oLxPTwZ1NIVo4fa4JXmMSjpNo2NLXiq1Zs81epN3gdu3jzGwbAV7L99nGPqFG4bqrhtmwy2/2KmHKTpfWNMUz04GP86YFCsWIUQorqTBFBUO4YGKgIHeDN6xSlUoJOs5KZmgQO8C+38cP36v/x1ZD7rUq+QbKACAzBRFJqkWHE3oQdn77d/4m0WN9ZP+jVm5dEovtt7ldjknNugte3MGd+jIc+3roOxYd6rjaVxDMpqm7Vr+/JybV9eJifBPh76O1su/MPx7JvcNjbgosUDGhpcgXiDEh1bIYSozqQXcBFJb8Kq50nHldOoH3DwxDf8efEv/lVStcOcuKrhJce2PN/h/zh6y6JMxqrLL1ZnG1N6NHFi78U4bv13uYutGeO6N2RIGzdMjB5/m1kfx0IsyNazN/lp619YGgST/cCOo0kvP3a7ct4KIUT+9C4BDAoKIigoiMjISACaNm3K1KlT6du3b77lu3btyr59+/Is79evH5s3bwZAURQCAwP5+eefSUxMpEOHDgQFBeHp6VnkuOSLpGoqyswSSYmRrDs4k7/ijnLD8H/LO2DB0EYv0antezrTopXVbBW5241Jus/F2BS2hMZw415OT14nG1PGdmvIy0+5YWpk+Jgt5b9dfZ0NpSTblfNWCCHyp3cJ4KZNmzA0NMTT0xNFUVi+fDnz58/n9OnTNG3aNE/5hIQEsrKytM/j4+Np0aIFv/zyCyNHjgRg3rx5zJkzh+XLl+Ph4cFnn31GaGgo58+fx8ysaA3H5Yuk+jl3cS2rTn3P1sxY7Vh91hqFQVYNeNl3MvXqdSrXeB6oNWwIucXiPZeJik8HwNHalDFdG/CKb13MjJ8s8asO5LwVQoj86V0CmB97e3vmz5/Pm2+++diyCxcuZOrUqcTExGBpaYmiKLi6uvLBBx8wefJkAJKSknBycmLZsmUMHTq0SDHIF0n1kJWZwvZDc1kVuYWzBv8bLLmxxoChdXrSt0MAFhY1yzUmtUZh05lbLNp9mYi7aQDUtDLh3S4NGNauHuYmkvgVRM5bIYTIn153AlGr1axevZq0tDT8/PyKtM6SJUsYOnQolpaWAERERBAbG0vPnj21ZWxtbWnXrh2HDx8uMAHMzMwkMzNT+zw5ObkE70Tou5hbJ/nP4TmsTb6YM/euARgpCr2MHHjF521aNnu1yEO3lBaNRmFzaAwLd4Vz9U5O4lfDwph3ujTA368eFiZ6ffoKIYTQY3r5DRIaGoqfnx8ZGRlYWVmxbt06vL29H7vesWPHCAsLY8mSJdplsbGxADg5OemUdXJy0r6Wnzlz5jB9+vRivgNRWURFHWDh/gD2qBPRqFRgkDNQ8xCHVrzQ4VNq1mxc7jFpNArbzsWycFc44bdTAbA1N2ZU5/qMaO+OlalenrZCCCEqEb38JmnUqBEhISEkJSWxZs0aRowYwb59+x6bBC5ZsoTmzZvj6+tb4hgCAgJ4//33tc+Tk5Nxc3Mr8XaFfkhPv8sv20azLPkC2SoVqFS0w4yhDZ6na7tJGBmX/6DCiqKw4/xtvt4ZzsXYFABszIx4u1N9RnZwx9rMuNxjEkIIUTXpZQJoYmJCw4YNAWjTpg3Hjx9n0aJF/PjjjwWuk5aWxqpVq5gxY4bOcmdnZwBu376Ni8v/hoq4ffs2LVu2LHB7pqammJqaluBdCH2kaDTs+HcW8y//xW3DnMSvAxZ80GE6ng37VExMisLuC3F8vSucc7dymhpYmxrxRkcP3ujoga25JH5CCCFKl14mgI/SaDQ67fHys3r1ajIzMxk+fLjOcg8PD5ydndm9e7c24UtOTubo0aOMHj26rEIWeuhaxG5m75/CUTLAUEVtNXzU+DW6PT253Nv3QU7iFxx+h693hnP2RhIAliaGvN7Bg7c6eWBnYfKYLQghhBDFo3cJYEBAAH379qVu3bqkpKSwcuVKgoOD2b59OwD+/v7Url2bOXPm6Ky3ZMkSBg0ahIODg85ylUrFxIkTmTlzJp6entphYFxdXRk0aFB5vS1RgdJSY/lh22hWpF7mgUqFiaLwpm1z3ujzPWbmNco9HkVROHD5Ll/vCud0dCIA5saGjOzgztud6mNvKYmfEEKIsqV3CWBcXBz+/v7ExMRga2uLj48P27dvp1evXgBER0dj8MjVmkuXLnHw4EF27NiR7zY/+ugj0tLSGDVqFImJiXTs2JFt27YVeQxAUTkpGg2b9wey4No67vz3dm9XlTUfdf8KN7ei9Sov1XgUhcNX41mwM5wTUfcAMDM2wN/PnVGd61PTSpocCCGEKB+VYhxAfSDjiVUu4Ve2MvvgZ5xU5TQdcFPDlKZv0bndhAqJ58i1eL7eGc7RiAQATI0MGNauHu92rU8ta/khUlbkvBVCiPzp3RVAIfJT1CnAkpOu8/32MaxKj0CtUmGmUXjboRUjnvkWUzPbco/7RGQCC3aGc+hqPAAmhga82q4uo7s2wMlGEj8hhBAVQxJAofe2hcUwfdN5YpIytMtcbM0IHOBNn2Y5Pbs16gdsDP6Ur6M35wzkrFLRy8CWD3stwsW1TbnHfCr6Hl/vDOfA5bsAGBuqePkpN8Z2a4iLrXm5xyOEEEI8rMQJYGJiIuvWrePAgQNERUWRnp6Oo6MjrVq1onfv3rRv37404hTV1LawGEavOMWj7RRikzIYveIUQcNbU9foKLMPz+CMQTYYqHBXqwjweZf2bceUe7xnrify9a5wgi/dAcDIQMWQtm6M7daAOjUsyj0eIYQQIj/FTgBv3brF1KlT+eOPP3B1dcXX15eWLVtibm5OQkICe/fu5csvv6RevXoEBgby8ssvl2bcohpQaxSmbzqfJ/kDUABbgzv8FfwSJ63uoRioMNcojHZsx/BeizE2tSzXWMNuJrFwVzi7LsQBYGig4vlWtRnfwxM3e0n8hBBC6JdiJ4CtWrVixIgRnDx5ssAZOu7fv8/69etZuHAh169fZ/LkycUOVFQ/xyISdG775jLgAU/b/0F0zXOcMDQAVPQ1tOeDPt/g5ORTrjFeiElm4a5wtp+7nRObCga3qsN73RviXrN8k1AhhBCiqIqdAJ4/fz7PmHuPMjc355VXXuGVV14hPj6+uLsS1VRcSt7kr5H5IUydNxJqBmCAW6bCi7Xf5I3+k8o1tkuxKSzaHc6W0Jz5pFUqGNjClfE9PKnvaFWusQghhBBPqtgJ4OOSv5KWF+Lh4VFMVPdp57yYELuc8fMsNRoa3vXkSLw/TXp0KbeYrsSlsGj3Ff45ewtFyUn8nvVxZUKPhjSsZV1ucQghhBAlUSa9gC9cuMCRI0do1apVofPtClEYXw97XGzNIO08tdx+JsQspzVgi2RLLsa+zr/qOjjb5gwJU9au3Ull8e7LbDiTk/gB9GvuzIQeXjRylsRPCCFE5VLiBHDGjBmYm5vz4YcfArB371769OmDtbU1SUlJLFu2jGHDhpU4UFH9GBqoGNX8OEvifueaoQHWag1OMV04mNKf3BEAAwd45zseYGmJik9j8e4rrDt9A81/E79nvJ2Y2NMLb1cZWFgIIUTlZPD4IoVbs2aNTieQWbNmMX78eO7evcu3337L7NmzS7oLUQ1p1A/4YcNwvr67giRDA+pnqiByFKdT+gPgbGtG0PDW2nEAS9v1hHQ+WnOG7l/t4+9TOclfzya1+Oe9jvzk31aSPyGEEJVasa8A/vbbbyiKQmRkJCEhIcTHx6MoCv/++y+dOnXit99+Q6PRcO3aNX777TcA/P39Sy1wUXUlJUYyZcNQDpIGKhUvmrry4Ut/ceaW+rEzgZTUzcT7fLvnCqtPXOfBfy/5dW3kyKSeXrRwsyv1/QkhhBAVodgJYL169QAwMTHBycmJevXqERISgo2NDd26dUNRFDIzM1GpVLi7uyNTDouiOHdxLe8fCuSWIZhqFP6vbn8G9ZgHgF+DsttvTNJ9vtt7hb+OXydbnfO32smzJpN6edG6bo2y27H4//buPC6rMv//+OvmZlOWW1E2AZdUFERy/4ZWpkkuZdbUVKOO2mKlpGhZ6NRkNuXGd0xLQ80ZszFz0nLU0vxpJrmluGRaKqIipihubCrbfZ/fH4z3NwJL5WZR3s/Hg8d4n3Pd1/U5pxjfXeec64iISBW44QDYtWvxk5ft2rXjiy++IC4ujq+++oo+ffpw9913A7B3715CQkLsn0WuxrDZWLruJSadXEuh2USIFd65czItQh+o0HFPZ+eRsOEwi7alUWC1AdC5aT1GR4fSsXHFP1wiIiJSFcr9EEh8fDz9+vWjS5cutGzZkrlz59r3ffjhh/Tq1au8Q8gt7vKl87z1nz+yojADTCbuMXnx9iP/xtsSUmFjZuTkMXvDET7edoz8ouLg16mJDy9Gh3LHbVqySEREbm0mw0HXZs+dO1dqrb/09HS8vb3x8Lj534iQnZ2NxWIhKysLb289AOAoaWmbGP11DMlONpwMg5H1OvJknw9wMlfICkWcy81nzrdH+GhrKnmFxcGvQ6O6jI4OpXPTephMFfdEsVQ+/d6KiJTNYX/LlrXQc2BgxTyhKbeG9Vum8urBj8h1MuFjM4hvM4pObZ+pkLEuXCxg7sYjLNiSyqUCKwBtQurwYnQodzWvr+AnIiI1yg0HwMWLF/PEE09cU9vjx4+TlpZGly5dbnQ4uYUUFebx3ooB/DM3GZxMtDVcie8zv0Le45t5qYB5G48yf/NRLv43+EUGWxgdHco9ob4KfiIiUiPd8DqACQkJhIWFMXXqVPbv319qf1ZWFqtWraJ///60a9dO7wIWAM6ePcCzH99ZHP6AP9e+jX8M2Ojw8Jd1uZB31iZz15RvmPlNChcLrLRq4M28QR1YHtOFbi38FP5ERKTGuuEZwMTERFasWMF7773HuHHj8PDwwN/fH3d3dy5cuMCpU6eoX78+Q4YMYd++ffj7+zuybrkJ7drzEWN2TuWM2URtm8GbzR6n511/degYOXmFzN+cyryNR8jOKwKgZYAXo6NDuS/cX6FPREQEBz0EcvbsWTZt2sSxY8e4fPky9evXp23btrRt2xYnp+ubZExISCAhIYHU1FQAWrVqxeuvv07v3r2v+p3MzExeffVVPv/8c86fP0+jRo2YPn06ffr0AcBqtfLGG2+wcOFCTp06RYMGDRgyZAivvfbaNQcC3Ux+4wybjX999TzTMrZgNZloajUxrdt0bmvS3WFj5OYXsWBLKh9sPELmpUIAQv09GdUjlF6tAnCqwNfFSfWl31sRkbI55CGQ+vXr89BDDzmiK4KDg5k8eTLNmzfHMAwWLFhAv3792L17N61atSrVvqCggOjoaPz8/Fi6dClBQUEcO3aMOnXq2NtMmTKFhIQEFixYQKtWrdixYwdPPvkkFouFkSNHOqRuKdvF3FP8ddkfWWvLBJOJ3mYf3nhkCbU9/RzS/6WCIj7aeoy53x7h/MUCAJr6ejCqRyj3tw5U8BMRESmDw5aBqUg+Pj7Ex8fz9NNPl9o3e/Zs4uPjOXDgAC4uLmV+/4EHHsDf359//OMf9m2PPPIItWrVYuHChddUg2YSrl/K4f/H6MQxpJoNnA2DVwLu4Yn73sV0nbPCZblcYOXjbceYnXiYs7nFwa9JfQ9i721O39sbVMhr4uTmo99bEZGyVcxiaw5itVpZsmQJFy9eJCoqqsw2K1asICoqipiYGJYvX46vry/9+/cnLi4Os9kMQOfOnZk7dy7JycmEhoayZ88eNm3axLRp0yrzcGoMq83gwy/GMvvcl+SZTfhbDf7e6TVuj7i2p8Z/S16hlUXb0khIPMyZnHwAGvrUJvbe5vRr0wBnc/nDpYiIyK2uWgbAvXv3EhUVRV5eHp6enixbtozw8PAy2x45coT169czYMAAVq1aRUpKCsOHD6ewsJDx48cDMHbsWLKzs2nZsiVmsxmr1crbb7/NgAEDrlpDfn4++fn59s/Z2dmOPchb1OofTvDZN0PZVuc4OJloeclMVtZLpNOV28vRb36RlX8nHWfWNymczi7+5xJctxYjuzfn4XZBuCj4iYiIXLNqeQm4oKCAtLQ0srKyWLp0KfPmzSMxMbHMEBgaGkpeXh5Hjx61z/hNmzaN+Ph40tPTgeI1C19++WXi4+Np1aoV33//PaNGjWLatGkMHjy4zBreeOMNJkyYUGq7LiVd3eofTvDJ+oHsrnsWgLbn/dh0eiTGf/87I2FgO3pFXN/i4AVFNj7dURz80rPyAGhgceeF7s15tH0wrs4KfnJ1ugQsIlI2hwTAN998kzFjxlC7du0S2y9fvkx8fDyvv/56ufrv0aMHTZs2Zc6cOaX2de3aFRcXF9atW2fftnr1avr06UN+fj6urq6EhIQwduxYYmJi7G3eeustFi5cyIEDB8ocs6wZwJCQEP1FchWFRYU8O7s7O7wyAbg9oymbzg217zcBARZ3NsV1v6b78wqtNj7b+TPvrU/hROZlAAK83Ynp1pTHOobg5myuiMOQW4wCoIhI2RwyfTJhwgRyc3NLbb906VKZs2jXy2azlQhjv9SlSxdSUlKw2Wz2bcnJyQQGBuLq6mqv49fL0ZjN5hLf+TU3Nze8vb1L/EjZigrziPu4Bzu8MjEZBq1PtSoR/gAMID0rj+1Hz/92X1YbS3Ycp/vfNzD2872cyLyMr5cbb/QNZ8PL9/DnqMYKfyIiIuXkkHsADcMocz29PXv24OPjc119jRs3jt69e9OwYUNycnJYtGgRGzZsYM2aNQAMGjSIoKAgJk2aBMCwYcOYOXMmsbGxjBgxgkOHDjFx4sQSy7v07duXt99+m4YNG9KqVSt2797NtGnTeOqpp8px1AJQkJ9D3Ke9WUcWZsOgRXp7tmQ9dtX2GTl5ZW632gxW7DnBjHWHSD13CYD6nq4837UpA+9ohLuLQp+IiIijlCsA1q1bF5PJhMlkIjQ0tEQItFqt5Obm8vzzz19XnxkZGQwaNIj09HQsFguRkZGsWbOG6OhoANLS0krM5oWEhLBmzRpGjx5NZGQkQUFBxMbGEhcXZ2/z3nvv8de//pXhw4eTkZFBgwYNeO6558p9abqmu3zpPKOX9GYzl3AxDJqc7MK27Ad/8zt+Xu4lPlttBl/8cJIZXx/iyJmLAPh4uPJ819sYeEcjartWy+eUREREbmrlugdwwYIFGIbBU089xfTp07FYLPZ9rq6uNG7c+KrLt9xsdC9RSbk56bzwWV92mvKpZTOYFjGcl9e14FRWHmX9C/XrewBtNoPV+04xfV0yhzKKbx+oU9uFZ+++jcFRjfFwU/CT8tPvrYhI2cr1t+yVJ2ibNGlCly5dcHbWX9o1QVZmKs8ve5h9TkV42gzebz+WtpEDGV8rnWELd2GCEiHwyrzw+L7hmICv9qUzfd0hDpzKAcDb3bk4+HVujJd72Yt5i4iIiOM45CEQLy8v9u/fb/+8fPlyHnroIf7yl79QUFDgiCGkmjh79gBPLuvHPqci6tgM5kW9SdvIgQD0iggkYWA7AiwlL/MGWNx5f0BbzE5OPPDeJp5fuIsDp3LwcnNmVI/mbBrbnRe6N1f4ExERqSQOmbJ77rnnGDt2LK1bt+bIkSM8/vjj/OEPf2DJkiVcunSJ6dOnO2IYqWKn0nfzzOpBHDODr9VgbtdpNGt6X4k2vSICiQ4PYPvR82Tk5OHr6calAiszvj7E3hNZAHi6OfNUl8Y8fedtWGor9ImIiFQ2hwTA5ORk2rRpA8CSJUvo2rUrixYtYvPmzTzxxBMKgLeAtLRNDF03jJNmaGCFD3rMpmHDO8tsa3YyccdtPnx76CxT1hxkz/FMAGq7mhnSuTFD77qNuh6ulVi9iIiI/JLDloG5sqbeunXreOCBB4DiJ3TPnj3riCGkCqUc/n8MTXyRs2YTja3wQe+PCAhsW2ZbwzDYnHKOd9Yls/PYBQBquZgZ1LkRz951G/U83SqzdBERESmDQwJghw4deOutt+jRoweJiYkkJCQAcPToUfz9/R0xhFSRHw98zvNbXyfTbKK5zYm5D/6b+vVbltl26+FzvLM2me2pxYs9uzk78ec7GvFc16b4ein4iYiIVBcOCYDTp09nwIAB/Oc//+HVV1+lWbNmACxdupTOnTs7YgipArt/WMjwnZPJdTLR2uZMwsPLsNRpXKrd9qPneWdtMluPnAPA1dmJ/p0aMvyepvh5u5dqLyIiIlXLIe8Cvpq8vDzMZjMuLjf/jf41bT2xrTtnE/vDTC47mWhvuDHr0S/w8Awo0WbnsQu8szaZTSnFl/ldzU480SmE4fc0K/UksEhVqGm/tyIi18qhC/ft3LnTvhxMeHg47dq1c2T3UknWb5nKmOSPKHQy0YXavPPYamrV/r9X+n1/PJN31iaTmHwGABeziT92CCGmWzOC6tSqqrJFRETkGjkkAGZkZPD444+TmJhInTp1AMjMzKRbt24sXrwYX19fRwwjlWBV4nj+cvQzrCYTPZwsTHlsNa5uXgDsO5HFO2uT+fpABlD8tO8f2wcT060ZIT61q7JsERERuQ4OCYAjRowgNzeXH3/8kbCwMAB++uknBg8ezMiRI/nkk08cMYxUsM/WvsSEE2swTCb6Ovvy5mOrcHZx58eTWUxfd4i1P50GwMkEf2gXzIjuzWhUz6OKqxYREZHr5ZB7AC0WC+vWraNjx44ltm/fvp377ruPzMzM8g5R5W71e4n+teo5pp7ZAsDjbsH85Y8rOXTmMtPXJbN63ymgOPj1axPEiO7NuM3XsyrLFbkmt/rvrYjIjXLIDKDNZivzQQ8XFxf7+oBSPRk2G3NXDmZm5vcAPOnRjL53fsjIf//Al3vTMQwwmaBvZANG3tucZn4KfiIiIjc7hwTA7t27ExsbyyeffEKDBg0AOHHiBKNHj+bee+91xBBSQd5d9hjzcg8C8JRHBEcLxnDfjE1cmRe+v3UgsT2aE+rvVYVVioiIiCM5JADOnDmTBx98kMaNGxMSEgLA8ePHiYiIYOHChY4YQirAgi+ftYe/7pfCeO/AQGxG8eXeXq0CiO3RnLBAXTYTERG51TgkAIaEhLBr1y7WrVvHgQMHAAgLC6NHjx6O6F4qwOxlrzAreysAbc40YvnZwQBEBluY+HBrIoIsVVmeiIiIVCCHrQNoMpmIjo4mOjraUV1KBUlYFs8HWavAZKJNZl02nn3Ovm/vz1n8fOGSAqCIiMgtzKk8X16/fj3h4eFkZ2eX2peVlUWrVq3YuHFjeYYQBzqZeZnxH8/lowsfUmgyEZHrxub0l/j1vwYTVv6E1VZhL4gRERGRKlauADh9+nSGDh1a5vIKFouF5557jmnTppVnCHGA09l5jF++jz++M59v82aQa3ai2WUTu35+BduvJoENID0rj+1Hz1dNsSIiIlLhyhUA9+zZQ69eva66/7777mPnzp3lGULKISMnjwkrf+Suqd/w+bbd1Al6n7POTgQVGBxOe5F84+qLOGfk5FVipSIiIlKZyhUAT58+Xeb6f1c4Oztz5syZ6+ozISGByMhIvL298fb2JioqitWrV//mdzIzM4mJiSEwMBA3NzdCQ0NZtWpViTYnTpxg4MCB1KtXj1q1atG6dWt27NhxXbXdLM7m5vP2lz9x99RvmL85FawXCW88jTQ3E/WsBtnHh5Jt++3X8/l5uVdOsSIiIlLpyvUQSFBQEPv27aNZs2Zl7v/hhx8IDAy8rj6Dg4OZPHkyzZs3xzAMFixYQL9+/di9ezetWrUq1b6goIDo6Gj8/PxYunQpQUFBHDt2zP5OYoALFy7QpUsXunXrxurVq/H19eXQoUPUrVv3umqr7s5fLGDut0dYsCWVy4VWANqGeNLQYzLrTUV42AxmdZnIM6c9MBXkUdZdfiYgwOJOpyY+lVq7iIiIVJ5yvQpuxIgRbNiwgaSkJNzdS84YXb58mU6dOtGtWzfefffdchXp4+NDfHw8Tz/9dKl9s2fPJj4+ngMHDlx1NnLs2LFs3ry5XA+kVOdXSmVeKuCDjUf4cHMqFwuKg9/twRZGR4eyc+9zfHgxBWfDYFbEcDp3GM5X+9IZtnAXQIkQaPrv/yYMbEeviOsL7iLVUXX+vRURqUrlCoCnT5+mXbt2mM1mXnjhBVq0aAHAgQMHmDVrFlarlV27duHv739D/VutVpYsWcLgwYPZvXs34eHhpdr06dMHHx8fateuzfLly/H19aV///7ExcVhNpsBCA8Pp2fPnvz8888kJiYSFBTE8OHDGTp06FXHzs/PJz8/3/45OzubkJCQavUXSdblQv6x6Sj/3HSU3PwiACKCvBndI5TuLf1Y9FUMkzOKQ+/Ehg/St9vb9u9+tS+dCSt/Ij3r/+71C7S4M75vuMKf3DIUAEVEylauS8D+/v5s2bKFYcOGMW7cOK5kSZPJRM+ePZk1a9YNhb+9e/cSFRVFXl4enp6eLFu2rMzwB3DkyBHWr1/PgAEDWLVqFSkpKQwfPpzCwkLGjx9vb5OQkMCLL77IX/7yF5KSkhg5ciSurq4MHjy4zH4nTZrEhAkTrrv2ypCdV8j8TanM23SEnLzi4BcW6M3oHs2JDvfHZDKxdtNEppz+FkwmYuu2KxH+AHpFBBIdHsD2o+fJyMnDz6v4sq/ZyVTWkCIiInILKdcM4C9duHCBlJQUDMOgefPm5bq/rqCggLS0NLKysli6dCnz5s0jMTGxzBAYGhpKXl4eR48etc/4TZs2jfj4eNLT0wFwdXWlQ4cObNmyxf69kSNHkpSUxNatW8usoTrOAObmF7FgSypzvz1C1uVCAEL9PRndI5SerQJw+m9427XnI4bunkqBycTjbsG8+tiXmJzK9byPyE1JM4AiImVz2JtA6tatS8eOHR3Sl6urq/3Bkvbt25OUlMSMGTOYM2dOqbaBgYG4uLjYwx8Uv4bu1KlTFBQU4OrqSmBgYKnwGBYWxmeffXbVGtzc3HBzc3PI8ZTXpYIiPtp6jDmJh7lwqTj4NfX1YFSPUO5vHWgPfgBHjn7NiF1TKXAy0c3kzbhHlyv8iYiISAkOC4AVyWazlZiN+6UuXbqwaNEibDYbTv8NOsnJyQQGBuLq6mpvc/DgwRLfS05OplGjRhVbeDldLrCy8LtjzE48zLmLBQDcVt+D2B7NeSCyQanLtWcyfmTYN6PINpuItLkw5fGVmJ1dq6J0ERERqcaqXQAcN24cvXv3pmHDhuTk5LBo0SI2bNjAmjVrABg0aBBBQUFMmjQJgGHDhjFz5kxiY2MZMWIEhw4dYuLEiYwcOdLe5+jRo+ncuTMTJ07kscceY/v27cydO5e5c+dWyTH+nrxCKx9vSyNhw2HO5hYH30b1ajOie3MeatMAZ3PpGb3cnHSGf9mfk2ZoZIWZDy2hVm0t5SIiIiKlVbsAmJGRwaBBg0hPT8disRAZGcmaNWuIjo4GIC0tzT7TBxASEsKaNWsYPXo0kZGRBAUFERsbS1xcnL1Nx44dWbZsGePGjePNN9+kSZMmTJ8+nQEDBlT68f2WvEIr/046zqxvUsjIKQ5+wXVrMfLe5jzcNgiXMoIfQGH+RV78vB8HnGz42AwSoj+grk/TyixdREREbiIOewjkVleRN5PnF1n5dMfPvP9Nin1ZlqA6tXihezMeaReMq/PV7+EzbDZeW9yDFYVnqGUzmB/1Jq1a/sGh9YncrPQQiIhI2ardDGBNUmi1sXTnz8xcn8KJzMsABHi7E9O9GY91CMbN2fw7PcB7/3mcFYVnMBsGf2/1rMKfiIiI/C4FwCpQZLXx+e4TvLf+EMfPFwc/Py83Yro14/GOIbi7/H7wA/h0TSwf5BwAYHxIH+7qNPJ3viEiIiKiAFipiqw2Vuw5yYyvD3Hs3CUA6nu6Meyepgz4n4bXHPwA1m+ZytvpX4PJxHBLJA/fO7WiyhYREZFbjAJgJbDaDL744SQz1h3iyNmLANTzcOX5rk0ZeEcjarlee/AD2LNvMXEHP8LmZOIR10Cef/BfFVG2iIiI3KIUACuQzWawal8609cdIiUjF4A6tV147u6mDIpqhIfb9Z/+1NREXkh6izwnE3ebPHnt0RVa6FlERESuiwJgBbDZDNb8eIrp6w5x8HQOAJZaLjx7920M7twYzxsIflabwYY93zF1VwyZziYibM7EP74SZxd3R5cvIiIitzgFQAfbn57Ni5/uYX96NgBe7s48c+dtPHlnY7zdXW6oz6/2pTNl5Ra8fN7gpLuJwEKD82dH8e2RQnpFOLB4ERERqREUAB3M18uN1LMX8XRz5qkujXn6ztuw1L6x4AfF4W/Ywh1EhUxirztYrDYupT3FiYL6DFu4i4SB7egVEejAIxAREZFbnQKgg9X3dCNhYDtuD65DXY/yvYfXajOYsPInutT7B3s883E2DLyOP8j+gpYAmIAJK38iOjyg1HuBRURERK5GTw9UgHta+JU7/AFsP3qeOgXr+NE3BYBWZ0LZf/lO+34DSM/KY/vR8+UeS0RERGoOBcBq7OdTB8gLXkGRyUTrHHc2nXuyzHYZOXmVXJmIiIjczBQAqylrUQGrD47irLMTQQUGe06O4mr/uPy89CSwiIiIXDvdA1hNzVk5mCRzHu42g/yf+3PRVqdUGxMQYHGnUxOfSq9PREREbl6aAayGNifNZHbWXgCGeN9Hav7t/PoRjyufx/cN1wMgIiIicl0UAKuZ9JM7GbtvNobJxGNuQcQ8Mo2Ege0IsJS8zBtgcdcSMCIiInJDdAm4GinMv8iYNc+Q6WQi3GbmlYf+DUCviECiwwPYfvQ8GTl5+HkVX/bVzJ+IiIjcCAXAauTvy5/gB6civGwGf4+ejZu7xb7P7GQiqmm9KqxOREREbhW6BFxNfPXtm3x8ORWASWFPERx8R9UWJCIiIrcsBcBq4GjqBsYf/hSAZzxb0PWOF6u4IhEREbmVVbsAmJCQQGRkJN7e3nh7exMVFcXq1at/8zuZmZnExMQQGBiIm5sboaGhrFq1qsy2kydPxmQyMWrUqAqo/vpdunSWF9eP5JKTiY6GGzEPLqzqkkREROQWV+3uAQwODmby5Mk0b94cwzBYsGAB/fr1Y/fu3bRq1apU+4KCAqKjo/Hz82Pp0qUEBQVx7Ngx6tSpU6ptUlISc+bMITIyshKO5PcZNht/W/ZHUswG9a0GU/v+C2cXLeosIiIiFavaBcC+ffuW+Pz222+TkJDAd999V2YA/Oc//8n58+fZsmULLi4uADRu3LhUu9zcXAYMGMAHH3zAW2+9VSG1X6+l617ii6KzmA2D+HZjqO8bVtUliYiISA1Q7S4B/5LVamXx4sVcvHiRqKioMtusWLGCqKgoYmJi8Pf3JyIigokTJ2K1Wku0i4mJ4f7776dHjx6VUfrv+vHA50w6uRaAkfU60aHNkKotSERERGqMajcDCLB3716ioqLIy8vD09OTZcuWER4eXmbbI0eOsH79egYMGMCqVatISUlh+PDhFBYWMn78eAAWL17Mrl27SEpKuuYa8vPzyc/Pt3/Ozs4u30H9QlZWGi9tGU+h2UQ3kzdP3j/PYX2LiIiI/J5qGQBbtGjB999/T1ZWFkuXLmXw4MEkJiaWGQJtNht+fn7MnTsXs9lM+/btOXHiBPHx8YwfP57jx48TGxvL2rVrcXe/9vvrJk2axIQJExx5WMX1Wot4dfnjnDBDkBXeemQxJqdqPRErIiIitxiTYRhGVRfxe3r06EHTpk2ZM2dOqX1du3bFxcWFdevW2betXr2aPn36kJ+fz6pVq3j44Ycxm832/VarFZPJhJOTE/n5+SX2XVHWDGBISAhZWVl4e3vf8LH8Y+WTTD+/A1fD4F93vEV4y4duuC8R+W3Z2dlYLJZy/96KiNxqquUM4K/ZbLYSYeyXunTpwqJFi7DZbDj9dyYtOTmZwMBAXF1duffee9m7d2+J7zz55JO0bNmSuLi4MsMfgJubG25ubg49jqTd/+Ddc0lgMjEu6D6FPxEREakS1S4Ajhs3jt69e9OwYUNycnJYtGgRGzZsYM2aNQAMGjSIoKAgJk2aBMCwYcOYOXMmsbGxjBgxgkOHDjFx4kRGjhwJgJeXFxERESXG8PDwoF69eqW2O4LVZpT5zt4zGT/y8u53sJlNPOjixyP3/q/DxxYRERG5FtUuAGZkZDBo0CDS09OxWCxERkayZs0aoqOjAUhLS7PP9AGEhISwZs0aRo8eTWRkJEFBQcTGxhIXF1fptX+1L50JK38iPSvPvi3Q4s5f+zTl092DOWc20dzmxGsPLdF9fyIiIlJlbop7AKuD37uX6Kt96QxbuItfn0wTcJf/39ntcwYPm8HibrNo3LhrpdQsUtPpHkARkbJpGsoBrDaDCSt/KhX+ANp5rWS3zxkA3mj2hMKfiIiIVDkFQAfYfvR8icu+VzRwPcjJwI0AtL3gg6XBsMouTURERKQUBUAHyMgpHf7cTBepFzyfXLMTzfJMbD01ssx2IiIiIpVNAdAB/LxKLzDdKXAGqW5gsdo4efxZCnEvs52IiIhIZVMAdIBOTXwItLhj+u/nO+os4ntLNibDoN7JHmQUNSHQUrwkjIiIiEhVUwB0ALOTifF9i19T19R9Nyn+ewBocy6YH3LvA2B833DMTqar9iEiIiJSWRQAHaRXRCAJA9vh5u5PSIETYRed2XhmGAEWdxIGtqNXRGBVlygiIiICaB3Aa3at64lZbQZbk49z6kIGQX5N7G8CEZHKp3UARUTKVu3eBHKzMzuZuLNlQ6BhVZciIiIiUiZdAhYRERGpYRQARURERGoYBUARERGRGkb3AF6jK8/KZGdnV3ElInKtrvy+6lk3EZGSFACvUU5ODgAhISFVXImIXK+cnBwsFktVlyEiUm1oGZhrZLPZOHnyJF5eXphMWtbl92RnZxMSEsLx48e1/IYD6bxeH8MwyMnJoUGDBjg56Y4XEZErNAN4jZycnAgODq7qMm463t7eCioVQOf12mnmT0SkNP0nsYiIiEgNowAoIiIiUsMoAEqFcHNzY/z48bi5uVV1KbcUnVcREXEEPQQiIiIiUsNoBlBERESkhlEAFBEREalhFABFREREahgFQLlhkyZNomPHjnh5eeHn58dDDz3EwYMHS7TJy8sjJiaGevXq4enpySOPPMLp06erqOKb0+TJkzGZTIwaNcq+TedVRETKQwFQblhiYiIxMTF89913rF27lsLCQu677z4uXrxobzN69GhWrlzJkiVLSExM5OTJk/zhD3+owqpvLklJScyZM4fIyMgS23VeRUSkPPQUsDjMmTNn8PPzIzExkbvvvpusrCx8fX1ZtGgRjz76KAAHDhwgLCyMrVu3cscdd1RxxdVbbm4u7dq14/333+ett96iTZs2TJ8+XedVRETKTTOA4jBZWVkA+Pj4ALBz504KCwvp0aOHvU3Lli1p2LAhW7durZIabyYxMTHcf//9Jc4f6LyKiEj56V3A4hA2m41Ro0bRpUsXIiIiADh16hSurq7UqVOnRFt/f39OnTpVBVXePBYvXsyuXbtISkoqtU/nVUREyksBUBwiJiaGffv2sWnTpqou5aZ3/PhxYmNjWbt2Le7u7lVdjoiI3IJ0CVjK7YUXXuCLL77gm2++ITg42L49ICCAgoICMjMzS7Q/ffo0AQEBlVzlzWPnzp1kZGTQrl07nJ2dcXZ2JjExkXfffRdnZ2f8/f11XkVEpFwUAOWGGYbBCy+8wLJly1i/fj1NmjQpsb99+/a4uLjw9ddf27cdPHiQtLQ0oqKiKrvcm8a9997L3r17+f777+0/HTp0YMCAAfY/67yKiEh56BKw3LCYmBgWLVrE8uXL8fLyst9/ZrFYqFWrFhaLhaeffpoXX3wRHx8fvL29GTFiBFFRUXpS9Td4eXnZ76O8wsPDg3r16tm367yKiEh5KADKDUtISADgnnvuKbF9/vz5DBkyBIB33nkHJycnHnnkEfLz8+nZsyfvv/9+JVd669F5FRGR8tA6gCIiIiI1jO4BFBEREalhFABFREREahgFQBEREZEaRgFQREREpIZRABQRERGpYRQARURERGoYBUARERGRGkYBUERERKSGUQCU33XPPfcwatSoCh9nw4YNmEwmMjMzK3ys6uBGz2tBQQHNmjVjy5Yt5Rp/7NixjBgxolx9iIjIzUkBUBgyZAgmk6nUT0pKSoWNWVb46dy5M+np6VgslgobF/4vaJpMJpycnLBYLLRt25ZXXnmF9PT0ChvPUcF29uzZNGnShM6dO5ernzFjxrBgwQKOHDnikLpEROTmoQAoAPTq1Yv09PQSP02aNKnUGlxdXQkICMBkMlXKeAcPHuTkyZMkJSURFxfHunXriIiIYO/evZUy/o0wDIOZM2fy9NNPl7uv+vXr07NnT/s7nUVEpOZQABQA3NzcCAgIKPFjNpvLbHvhwgUGDRpE3bp1qV27Nr179+bQoUP2/efOneNPf/oTQUFB1K5dm9atW/PJJ5/Y9w8ZMoTExERmzJhhn4lLTU0tNVP24YcfUqdOHdasWUNYWBienp72oHpFUVERI0eOpE6dOtSrV4+4uDgGDx7MQw899LvH7OfnR0BAAKGhoTzxxBNs3rwZX19fhg0bVqLdvHnzCAsLw93dnZYtW/L+++/b96WmpmIymVi8eDGdO3fG3d2diIgIEhMT7fu7desGQN26dTGZTAwZMsT+fZvNxiuvvIKPjw8BAQG88cYbv1nzzp07OXz4MPfff3+pGj799FPuuusuatWqRceOHUlOTiYpKYkOHTrg6elJ7969OXPmTIn++vbty+LFi3/3XImIyK1FAVCu25AhQ9ixYwcrVqxg69atGIZBnz59KCwsBCAvL4/27dvz5Zdfsm/fPp599ln+/Oc/s337dgBmzJhBVFQUQ4cOtc82hoSElDnWpUuX+N///V/+9a9/8e2335KWlsaYMWPs+6dMmcLHH3/M/Pnz2bx5M9nZ2fznP/+5oeOqVasWzz//PJs3byYjIwOAjz/+mNdff523336b/fv3M3HiRP7617+yYMGCEt99+eWXeemll9i9ezdRUVH07duXc+fOERISwmeffQYUzzimp6czY8YM+/cWLFiAh4cH27ZtY+rUqbz55pusXbv2qjVu3LiR0NBQvLy8Su0bP348r732Grt27cLZ2Zn+/fvzyiuvMGPGDDZu3EhKSgqvv/56ie906tSJn3/+mdTU1Bs6ZyIicpMypMYbPHiwYTabDQ8PD/vPo48+at/ftWtXIzY21jAMw0hOTjYAY/Pmzfb9Z8+eNWrVqmV8+umnVx3j/vvvN1566aUy+7zim2++MQDjwoULhmEYxvz58w3ASElJsbeZNWuW4e/vb//s7+9vxMfH2z8XFRUZDRs2NPr163fVWn49zi+tXr3aAIxt27YZhmEYTZs2NRYtWlSizd/+9jcjKirKMAzDOHr0qAEYkydPtu8vLCw0goODjSlTpvzmeF27djXuvPPOEts6duxoxMXFXbX22NhYo3v37iW2Xalh3rx59m2ffPKJARhff/21fdukSZOMFi1alPhuVlaWARgbNmy46pgiInLrca6q4CnVS7du3UrcC+bh4VFmu/379+Ps7Mz//M//2LfVq1ePFi1asH//fgCsVisTJ07k008/5cSJExQUFJCfn0/t2rWvu67atWvTtGlT++fAwED77FxWVhanT5+mU6dO9v1ms5n27dtjs9mueywovscOwGQycfHiRQ4fPszTTz/N0KFD7W2KiopKPagSFRVl/7OzszMdOnSwn4/fEhkZWeLzL4+vLJcvX8bd3f13+/L39wegdevWJbb9uu9atWoBxTOtIiJScygAClAc+Jo1a+aQvuLj45kxYwbTp0+ndevWeHh4MGrUKAoKCq67LxcXlxKfTSaTPaRVhCuhrXHjxuTm5gLwwQcflAi8wFXvj7xeZR3fb4XX+vXrX/UhlV/2deVBml9v+3Xf58+fB8DX1/f6ChcRkZua7gGU6xIWFkZRURHbtm2zbzt37hwHDx4kPDwcgM2bN9OvXz8GDhzI7bffzm233UZycnKJflxdXbFareWqxWKx4O/vT1JSkn2b1Wpl165dN9Tf5cuXmTt3LnfffTe+vr74+/vToEEDjhw5QrNmzUr8/PoJ6e+++87+56KiInbu3ElYWBhQfKxXaiuvtm3bcuDAAYeF4H379uHi4kKrVq0c0p+IiNwcNAMo16V58+b069ePoUOHMmfOHLy8vBg7dixBQUH069fP3mbp0qVs2bKFunXrMm3aNE6fPm0PiFA8w7Zt2zZSU1Px9PTEx8fnhuoZMWIEkyZNolmzZrRs2ZL33nuPCxcuXNNSMhkZGeTl5ZGTk8POnTuZOnUqZ8+e5fPPP7e3mTBhAiNHjsRisdCrVy/y8/PZsWMHFy5c4MUXX7S3mzVrFs2bNycsLIx33nmHCxcu8NRTTwHQqFEjTCYTX3zxBX369KFWrVp4enre0PF269aN3NxcfvzxRyIiIm6oj1/auHGj/clhERGpOTQDKNdt/vz5tG/fngceeICoqCgMw2DVqlX2y42vvfYa7dq1o2fPntxzzz0EBASUWpZlzJgxmM1mwsPD8fX1JS0t7YZqiYuL409/+hODBg0iKioKT09PevbsedX75H6pRYsWNGjQgPbt2zN58mR69OjBvn37SgTVZ555hnnz5jF//nxat25N165d+fDDD0vNAE6ePJnJkydz++23s2nTJlasWEH9+vUBCAoKYsKECYwdOxZ/f39eeOGFGzpWKL7f8uGHH+bjjz++4T5+afHixSXubxQRkZrBZFTkDVUilcxmsxEWFsZjjz3G3/72twofLzU1lSZNmrB7927atGlT4eMB/PDDD0RHR3P48OEbnkkEWL16NS+99BI//PADzs66GCAiUpNoBlBuaseOHeODDz4gOTmZvXv3MmzYMI4ePUr//v2rurQKExkZyZQpUzh69Gi5+rl48SLz589X+BMRqYH0//xyU3NycuLDDz9kzJgxGIZBREQE69atsz+Acav65dtEbtSjjz5a/kJEROSmpEvAIiIiIjWMLgGLiIiI1DAKgCIiIiI1jAKgiIiISA2jACgiIiJSwygAioiIiNQwCoAiIiIiNYwCoIiIiEgNowAoIiIiUsMoAIqIiIjUMAqAIiIiIjWMAqCIiIhIDaMAKCIiIlLDKACKiIiI1DAKgCIiIiI1zP8HJDr21rWqzrcAAAAASUVORK5CYII=", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First plot cost as a function of depth, touchdown_distance, and floating_cable_depth to get a\n", + "# sense for the 1d relationships\n", + "\n", + "design_phase = \"ArraySystemDesign\"\n", + "results = {\n", + " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "# Water depth\n", + "cost_depth = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_depth.run()\n", + "\n", + "# Touchdown distance\n", + "cost_touchdown_distance = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_touchdown_distance.run()\n", + "\n", + "# Floating cable depth\n", + "cost_cable_depth = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_cable_depth.run()\n", + "\n", + "cost_depth.linear_1d()\n", + "cost_touchdown_distance.quadratic_1d()\n", + "cost_cable_depth.linear_1d()\n", + "cost_cable_depth.quadratic_1d()\n", + "cost_cable_depth.poly3_1d()\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(2, 2, 1)\n", + "ax.set_title(\"Depth\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_depth.plot(ax, plot_data=True)\n", + "cost_depth.plot(ax, plot_curves=[\"linear_1d\"])\n", + "\n", + "ax = fig.add_subplot(2, 2, 2)\n", + "ax.set_title(\"Touchdown Distance\")\n", + "ax.set_xlabel(\"Touchdown Distance (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_touchdown_distance.plot(ax, plot_data=True)\n", + "cost_touchdown_distance.plot(ax, plot_curves=[\"quadratic_1d\"])\n", + "\n", + "ax = fig.add_subplot(2, 2, 3)\n", + "ax.set_title(\"Floating Depth\")\n", + "ax.set_xlabel(\"Floating Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_cable_depth.plot(ax, plot_data=True)\n", + "cost_cable_depth.plot(ax, plot_curves=[\"linear_1d\", \"quadratic_1d\", \"poly3_1d\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", + "overflow encountered in cosh" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" + ] + } + ], + "source": [ + "# Then create functions of two variables.\n", + "# NOTE: The parameterization and plotting are split in two blocks since the ORBIT model takes\n", + "# some time to run.\n", + "\n", + "design_phase = \"ArraySystemDesign\"\n", + "results = {\n", + " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "# Water depth vs touchdown distance\n", + "cost_depth_touchdown_distance = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_depth_touchdown_distance.run()\n", + "\n", + "# Water depth vs cable depth\n", + "cost_depth_cabledepth = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_depth_cabledepth.run()\n", + "\n", + "# Touchdown distance vs cable depth\n", + "cost_touchdown_cabledepth = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_touchdown_cabledepth.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a228ee4b8be142bdb82efb0c18561d66", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# NOTE: The parameterization and plotting are split in two blocks since the ORBIT model takes\n", + "# some time to run.\n", + "\n", + "cost_depth_touchdown_distance.quadratic_2d()\n", + "cost_depth_cabledepth.quadratic_2d()\n", + "cost_touchdown_cabledepth.quadratic_2d()\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(2, 2, 1, projection='3d')\n", + "ax.set_title(\"Depth vs Touchdown Distance\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Touchdown Distance (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_depth_touchdown_distance.plot(ax, plot_data=True)\n", + "cost_depth_touchdown_distance.plot(ax, plot_curves=[\"quadratic_2d\"])\n", + "\n", + "ax = fig.add_subplot(2, 2, 2, projection='3d')\n", + "ax.set_title(\"Depth v Cable Depth\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cable Depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_depth_cabledepth.plot(ax, plot_data=True)\n", + "cost_depth_cabledepth.plot(ax, plot_curves=[\"quadratic_2d\"])\n", + "\n", + "ax = fig.add_subplot(2, 2, 3, projection='3d')\n", + "ax.set_title(\"Touchdown Distance v Floating Depth\")\n", + "ax.set_xlabel(\"Touchdown Distance (m)\")\n", + "ax.set_ylabel(\"Floating Depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_touchdown_cabledepth.plot(ax, plot_data=True)\n", + "cost_touchdown_cabledepth.plot(ax, plot_curves=[\"quadratic_2d\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'floating': '36269853.8 * floating_cable_depth**2 + 28303.7 * floating_cable_depth * touchdown_distance + -9366.7 * touchdown_distance**2 + -117.4 * floating_cable_depth + -249.9 * touchdown_distance + 83.8'}\n" + ] + } + ], + "source": [ + "cost_touchdown_cabledepth.export(\"array_system.yaml\", \"floating\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export System\n", + "\n", + "This block creates a cost model for systems with high voltage alternating current (HVAC) and\n", + "high voltage direct current (HVDC) cables.\n", + "\n", + "Independent variables:\n", + "- site.distance_to_landfall\n", + "- Depth" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'floating_hvac': '2840.0 * depth + 2840000.0 * dist_s_to_l + 8520000.0'}\n", + "{'floating_hvdc': '828.0 * depth + 828000.0 * dist_s_to_l + 2484000.0'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cf34930026454aa1a7d8511a87c5cce3", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9aYxt6Xnfh/7WPO6x5jOPPbOb89CkREmWrVxHlGjHiKzBgRHQ1zAQIIDvtT85UYTEsGHDQRTDoOPrSE5k0ZZoWWFEC5QUUSIpTiKb7OH0dOZTdWquPa95vB/W3nWq6lSdubvZrPcHHDS6au+191q197P+7/s8z/+RyrIsEQgEAoFAIBAcGuR3+g0IBAKBQCAQCN5ehAAUCAQCgUAgOGQIASgQCAQCgUBwyBACUCAQCAQCgeCQIQSgQCAQCAQCwSFDCECBQCAQCASCQ4YQgAKBQCAQCASHDCEABQKBQCAQCA4ZQgAKBAKBQCAQHDKEABQIBAKBQCA4ZAgBKBAIBAKBQHDIEAJQIBAIBAKB4JAhBKBAIBAIBALBIUMIQIFAIBAIBIJDhhCAAoFAIBAIBIcMIQAFAoFAIBAIDhlCAAoEAoFAIBAcMoQAFAgEAoFAIDhkCAEoEAgEAoFAcMgQAlAgEAgEAoHgkCEEoEAgEAgEAsEhQwhAgUAgEAgEgkOGEIACgUAgEAgEhwwhAAUCgUAgEAgOGUIACgQCgUAgEBwyhAAUCAQCgUAgOGQIASgQCAQCgUBwyBACUCAQCAQCgeCQIQSgQCAQCAQCwSFDCECBQCAQCASCQ4YQgAKBQCAQCASHDCEABQKBQCAQCA4ZQgAKBAKBQCAQHDKEABQIBAKBQCA4ZAgBKBAIBAKBQHDIEAJQIBAIBAKB4JAhBKBAIBAIBALBIUMIQIFAIBAIBIJDhhCAAoFAIBAIBIcMIQAFAoFAIBAIDhlCAAoEAoFAIBAcMoQAFAgEAoFAIDhkCAEoEAgEAoFAcMgQAlAgEAgEAoHgkCEEoEAgEAgEAsEhQwhAgUAgEAgEgkOGEIACgUAgEAgEhwwhAAUCgUAgEAgOGUIACgQCgUAgEBwyhAAUCAQCgUAgOGQIASgQCAQCgUBwyBACUCAQCAQCgeCQIQSgQCAQCAQCwSFDCECBQCAQCASCQ4YQgAKBQCAQCASHDCEABQKBQCAQCA4ZQgAKBAKBQCAQHDKEABQIBAKBQCA4ZAgBKBAIBAKBQHDIEAJQIBAIBAKB4JAhBKBAIBAIBALBIUMIQIFAIBAIBIJDhhCAAoFAIBAIBIcMIQAFAoFAIBAIDhlCAAoEAoFAIBAcMoQAFAgEAoFAIDhkCAEoEAgEAoFAcMgQAlAgEAgEAoHgkCEEoEAgEAgEAsEhQwhAwQPzb/7Nv0GSJL773e/u+/sf+7Ef45lnnuF73/sekiTxD/7BPzjwWJcuXUKSJP7u3/27u37+9//+30eSJH7u537uju/lypUr/O2//bc5c+YMpmlSr9f5+Mc/zq/+6q8ShuH9n5xAIDi0vJWx7X/4H/4HJEna/mfbNidOnOBTn/oUv/7rv04cxwce60//9E/5q3/1rzI/P4+u68zOzvKpT32K//gf/+PDnbDgUCIEoOAt5/3vfz9PPPEE/+7f/bsDH/O5z30OgF/6pV/a/llZlvy7f/fvOHXqFL/3e7/HaDTa97n/6T/9J97znvfw27/923zqU5/in//zf84/+kf/iBMnTvD3/t7f47/9b//bR3tCAoFAwIPHNoDPfvaz/MZv/Ab//J//cz7zmc/Q7Xb5r//r/5oPf/jDLC0t3XacX/7lX+bHf/zHuXDhAn/7b/9t/uW//Jf8vb/39/A8j//iv/gvtl9HILhnSoHgAfn1X//1Eii/853v7Pv7T37yk+XTTz9dlmVZ/o//4/9YAuU3v/nNfR/7+OOPl0888cSun335y18ugfLLX/5yqWla+W/+zb+57XlXr14tXdctn3jiiXJlZeW231+6dKn8X/6X/+V+T00gEBxi3srY9su//MslUG5ubt722H/7b/9tKcty+ZGPfGTXzz//+c+XQPnX/tpfK5Mkue15X/rSl8rf+73fu+fzEwjKsizFDqDgbeEXf/EXAfZdpb7wwgu8+eab24+Z8Ju/+Zs89dRT/PiP/zg/+ZM/yW/+5m/e9tx/8k/+CZ7n8b//7/87CwsLt/3+3LlzYgdQIBC8ZTxIbLvTsT7zmc/w7W9/mz/6oz/a/vl/99/9d7TbbX7t134NTdNue95P/dRP8dM//dMPeAaCw4oQgIKHZjAYsLW1ddu/NE23H3P69Gmef/55fvu3f5s8z3c9fxI4f+EXfmH7Z3Ec8zu/8zv8/M//PAA///M/z5e//GXW1tZ2Pff3fu/3OHPmDM8///xbdXoCgeCQ8lbEtrvxN/7G3wDgD//wD4GqhvCNN97g05/+NLVa7WFPSSDYRghAwUPzkz/5k8zMzNz27xvf+Maux/3iL/4i6+vr/PEf//H2z4qi4Ld+67f42Mc+xpkzZ7Z//sUvfpF+v89f/+t/HYBPf/rTaJrGv//3/377McPhkOXlZd7znve8xWcoEAgOI29FbLsbzzzzDFA1tgG8/vrrACLOCR45QgAKHpp/8S/+BX/0R390279nn3121+N+7ud+Dk3TdqVKvvKVr7C8vLxv+veDH/wg586dA6BWq/Gf/+f/+a408HA43P6dQCAQPGreith2N1zXBdhuehNxTvBWob7Tb0Dw7ufDH/4wH/zgB2/7eavVYmtra/v/p6am+Kmf+il+93d/l3/5L/8lpmnyuc99DlVV+S//y/9y+3H9fp/f//3f57/5b/4bLl++vP3zj3/84/zO7/wOFy9e5LHHHqNerwMc2B0sEAgED8Ojjm33gud5wC3BJ+Kc4K1C7AAK3lZ+6Zd+ieFwyBe/+EWSJOF3fud3+Et/6S8xMzOz/ZjPf/7zxHHMP/tn/4zz589v/5v4aE12Aev1OkeOHOHChQvvyLkIBALBhHuJbffCJJ5Nsh9PPPEEAK+88sqjfcOCQ4/YARS8rfzMz/wMtVqNz33uc2iaRq/X2zf9+8wzz/DLv/zLtz3/f/vf/jc+97nP8Su/8isA/PRP/zT/6l/9K775zW/ysY997G05B4FAINjLvcS2e+E3fuM3gKqzF+Cxxx7j8ccf5wtf+AK/+qu/up0iFggeFiEABW8rlmXxV/7KX+G3fuu3CIIAx3H42Z/92e3fLy0t8dWvfpVf+ZVf4a/9tb922/OTJOEXf/EX+fa3v81HPvIR/v7f//v85m/+Jp/5zGf48pe/zNzc3K7HX7lyhS9+8YvCCkYgELyl3C223Quf+9zn+Nf/+l/zsY99jL/wF/7C9s9/5Vd+hb/+1/86n/nMZ/i3//bfoqq7b91/+Id/SJIkwgpGcF8IASh42/mlX/ol/s//8//kD/7gD/jFX/xFHMfZ/t3nPvc5yrLkZ37mZ/Z97l/+y38ZVVX5zd/8TT7ykY9w9uxZPve5z/FzP/dzPPnkk/xX/9V/xTPPPEOSJHzjG9/g85//PH/zb/7Nt+nMBALBYeZOsW0v/+E//Adc1yVJEpaXl/mDP/gDvv71r/Pcc8/x+c9/ftdjf+7nfo5XXnmFf/gP/yHf//73+fmf/3lOnjxJp9PhS1/6En/8x38sJoEI7hshAAVvOz/xEz/BwsICq6ur+6Z/T5w4wXPPPbfvc5vNJp/4xCf4rd/6Lf7n//l/RlVVfuZnfoaXX36Zf/pP/ylf+MIX+OxnP4thGDz77LP8s3/2z/hbf+tvvR2nJRAIDjl3im17+Tt/5+8AYJom09PTvPe97+XXfu3X+IVf+AUMw7jt8f/T//Q/8RM/8RP8r//r/8pnP/tZut0urVaLj370o3zhC184cNEsEByEVJZl+U6/CYFAIBAIBALB24foAhYIBAKBQCA4ZAgBKBAIBAKBQHDIEAJQIBAIBAKB4JAhBKBAIBAIBALBIUMIQIFAIBAIBIJDhhCAAoFAIBAIBIcMIQAFAoFAIBAIDhlCAAoEAoFAIBAcMoQAFAgEAoFAIDhkCAEoEAgEAoFAcMgQAlAgEAgEAoHgkCEEoEAgEAgEAsEhQwhAgUAgEAgEgkOGEIACgUAgEAgEhwwhAAUCgUAgEAgOGUIACgQCgUAgEBwyhAAUCAQCgUAgOGQIASgQCAQCgUBwyBACUCAQCAQCgeCQIQSgQCAQCAQCwSFDCECBQCAQCASCQ4YQgAKBQCAQCASHDCEABQKBQCAQCA4ZQgAKBAKBQCAQHDKEABQIBAKBQCA4ZAgBKBAIBAKBQHDIEAJQIBAIBAKB4JAhBKBAIBAIBALBIUMIQIFAIBAIBIJDhhCAgtsoy5IsyyiKgrIs3+m3IxAIBI+UoijIskzEN8GhRn2n34DgB4uiKEjTlCAIAFBVdfufoijIslgzCASCdyeTxW0cxyRJgqIou+KboihIkvROv02B4G1BKsUSSEAVGPM83975S5Jk++dlWSJJEpIkoSgKmqZtB0shCAUCwbuByeJ2svuX5/n2zyeiT5ZlIQgFhwYhAAWUZUmaptsBESBJkm3RN3lMWZa70sL7BUshCAUCwQ8Sk7iVpun2Ynay2J3Eq0l8mzwWQJIkZFneXvCqqoosy0IQCn5oEALwkJPnOZ7n8a1vfYsf/dEfRZZlyrIkjuNdAnAvQhAKBIIfdCaL29dffx1d1zl9+jSSJJFl2S4BuN/z7iQId5bECEEoeLciagAPKZNamEnKN4qiXb+/W1CbiMOdK+jJKjtN0+3H7BSEqqqKYCkQCN4WJvFo527fJP7ca3wDUBRllyCcxMpJSczeGmkR4wTvFoQAPITsrYHZKeIelEkwnLBTEO5MJ+9tKhHBUiAQPEr21jNPRNnDxrf9BOHOxbMQhIJ3G0IAHiL2q4XZu4v3qLiTIFxbW8PzPE6fPn1bU4kIlgKB4EHZW888EWAPKwD3cidBGMcxL730EqdOncJxHCEIBT+wCAF4SNiZ8oXdAeztCEg7BWGapnietx2sJzuEogNPIBA8KBP3gp27fhP2CsCJYHtU7K2X7vV6HDt2jDzPyfN8u6Z6b4wTglDwTiIE4CFgZy3MfgFn8v+TYue3i4kgnATiSQA/KFgKQSgQCPayc3FbluWBMe7tjm+T+DV5jztT0ztttfaWxIgYJ3i7EALwh5iDamH28nYHnIMEqBCEAoHgftivnvkHNcbtLbeZCNc0TYUgFLwjCAH4Q8pBtTD7sdPr7weBOwnCiYM/CNNWgeCwclA980E86hrAh+V+BKEw3he8VQgB+EPInWph9uNOAjBKc1aHMXFaYOsKCw0DTXn4IHQ/wXinINxryRDH8a4dQmHaKhD8cHOneuaDOEgAlmXJlpfQDSrrqtmaQcvWHtn7vFfuJghB+KwKHj1CAP4QMUn5TlbF9yqADhKAHS/h2zf6bHrVjpsEHG2afPR0C9d45z469+rRJUxbBYIfLnbWM+8UTHdjPwFYlCUv3xzyxrpHlFb1gY6h8uwRlyfma4/8vd8PBwnCSdMcCEEoeHiEAPwh4X5SvvuxN0DmRcn3bw7oeAnHmxaKLJHmBYu9CNcY8dHTrUd+Dg/K3QRhr9cjjmOOHTsmOvAEgnch91rPfBD7CcDlfsSF1RFNS2OhXt0Ku0HCizdHTLsG067+SM/hYbiT8X6SJFy9epXjx49v284I433BvSAE4Luc+62FOYi9AbIfZmyMEubqJopcHU9TZKYdnZv9iCDJsXXloMMB1Qo7L8rbUsZvdT3OXkEYhiHD4ZAjR44I01aB4F3Gwy5u4faYI0kSy/0ICajtyGa0bZ1rnYD1UXxPAjDNCxRZQj6gse2tYq/P6traGgsLCwca7wtBKNgPIQDfxTxILcxB7LcDGKQFUZojS7CyslKlHAwLVIOsOFjApXnBG2seFzd80qJkvmbw5LzLXN14oPf2sOwsqN7PtDWKImRZFh5dAsEPGPdbz3wQ+y06o7QgSguCJCdPQjY2t6i5LnEqk+V3toxZG8a8vjZifZSgKxKPzbo8PufsWuy+3U0nE5E3ee29k5hkWRbG+4JdCAH4LmXy5Z54Wz2K2o9JwAqTnEubPtc7Pm+sedTVnLi7TtvR6AYpbVvjVcNjulmn3ajRrLko48BXlCXfvt7n5eURrqGgqzJvbnisDiN+4rHpd0QE7g3Ee4XyTo8uYdoqELzzPGg9892OCZAkCX/0zRf52rURS5HKbM2iDHs0tYKt3oB+mDFV9JH8KdqNGu1GDdsyt4+zNoz58ptbDKOMpq3hxTlfu9KlH6Z8/EzrHYkR+8W4u43mFC4KAiEA32Xs/CI/7Kp4J5MVclmWfOdGjzfXfU62LZb6MVdv3CQOA/qhxmzN4FjLYuQHjPyAa8tryJJEw3VoNWrkssEbax4LDWM7RdyyNa5tBby57r2ju4B3+t1+BdfCtFUgePt5FCnfvUziW7fb5U+//SIXfZPZ2Wnyns/S5hZrKzexVYXZusHpGRdLKVjr9Fjr9AAwdY12o0arUee1zYRRnHF62t4+vh9nXNrweWzWYbb2gxnjhM+qYC9CAL6LKMuSIAgoy/KR70hNAuSWl3CjEzJtybiWga2UjFZyeqmEqkg8Ne/SdHbbJBRlSW/k0Rt5LPcjXl/1ODvfwnUdHNfFsSzqlsrqMKa4S1okzgpWBhFZXjLt6o/EkuF+UzHCtFUgeGdI05QwDN8SGyfP83jhhReQGseYrpkca+icOzLFC6+lWMUU/SBm1pGw0z5vvLaOZVu4jovruhSOTZSk3Fzv8I2rPVRNQw6b1FwH13FwDI2NUUI/zO4oACcxth9mGKr8jttq7XyuEISHDyEA3yVMdv1eeOEFjh49yrFjxx7p8ScC0I9TltfWUcMusiwz9Hyaaka9qSEpGrZx58aPKM3p+gn5cgfHGODqCqqqEKFyZKqB5zeA/QPWUi/ka5e7bHoJRVniGirPHq3xoZPN24qsH+T8Hua5wrRVIHjrmHyfNjY2uHDhAp/85CcfmdiI45ilpSWiKOKjH/0oX70e4ESVlUqRpThyymNzNTZGOmfmXI61TLLxvHLP81heXiZNU2zbxrBseqOcsJAZBRFN20CVS3TdwCtURgs6advYt+YwzQu+fqXLG+s+YZqjyBJH6iafPN9m5hHsGj5MfSQI4/3DiBCAP+DsVwvzVhQXS5JEEIZ87aWrXN2MmZueo66VeJtd8jSmM4qwdYUNzcd2HRzHwdB12BEAFjsBVzYDhmHK1ijGNTVatsqUreEnAUdt+NbLb+ANh6RxyMzCJu1GDcc28eOMP73UoR+kHG9Wncf9MOPb1/o0LY3H59wHPrdHfb3uRRCur68zPz+PaZpCEAoEd2BvScvEzeBR0Ol0ePnllzEMg0ajAZpFx+9xYWXIfE0jGWxRZjlFWSLJErauoMgyqBrNVotmq7K7SuKETn/ISzcH3OxE9OMCU1dwTZ3jUzaSHFMzNNZWbtLZWGHx2jK62+QUMs2ai6oqvLI85HtLQ2ZrBkcaJklWcLMf8pXLXX722blHshP4KLib8X6SJHieR1EUzMzMCOP9dzFCAP4As18tzFslAIui4Pe+8SqbpcP0zCybfsz17gZKqjLtOkzbJacbCpqc0O/1WFlextB1HNfBtl3QTC5vhuiqzFPzLsuDBC9KudENKQp4+ojLkUa1yk2znN7Q4/Vri0BVXzNIVa6sRTx1bBp1HAhbtsYozri44T+UAHyr2U8QvvnmmzQajV1NOsK0VSC4xX71zBPB8SiOffnyZa5fv84TTzwBwKXFFb785habo4Q4K3hjZcBwfY0pR8NQZVq2Rt1UyYsCKFFkFUmqjqXrOkNMMj3n/edarA4iNkcRgyBhsNjjpFOyMGcz6OW4rosfxiytbdL1QiQkXNfmW4shimHi6hYAuipzrGmx0o9YHcScaFsPdb5vFfv5rHa7XcIwpFarbT9GGO+/+xAC8AeUya7f3kYPWZa3RcWjoCgKLl26RC9I8bRpnji2gKnKvLHc5cU1n06QoasyHzjR4GjTrN7H3BxFXuD7Pp7nsbm1yc1exEqkcaRpo+oa52ZsRnFGz0+YcTUen3V27RbuJEpSVrYGbKwNkfwulmHgjmtrVDS8KLvjOZRlydWtgMubAUGSc6xl8vicS9289fF+JwKRqqpomrZvB95ejy4hCAWHiYMaPR5FfIuiiJdffpk4jvnoRz9KrVZjeXmZxX5GlEc8e6zOXMPguxcu0y0K1oYx7zlS4/E5F1UZxwlJIi/y7WNmRcmml9K0dXRN4fiUw3TNJExzBmHKB486OHKC541YW1+jyAvW19dpxjGO6xKlGStrHSRZZrS5Qr1Ww7ZsHNchKwri7M7nPAhTLm743OxVmZhzMzZnpu1dce3tinE770WT+CYmMb07EQLwB4y93n57vzSP0kQ5DENeeuklsiwjkQ1k1aJpaZQl1Ak4O+0wjKpi5W3xN0ZWZGr1GrV6tQJUNjzWr3UI0gw/8Mk3NzFME0XSKbJKaMrjGpO9MSBOc9aHMUu9kK1RQttNmPJDTK3L2jDm6eNt3rhajLvwXDR198f2W9d6/NnV3th0WuK1tRGvr3l86j1ztGztbffjmrze5HrdyZJhMudTmLYKDgs7x7k96vi2ubnJK6+8wvT0NO9///tv+eIBm2HBiVkNWZJoGRLTWkx93qXjpxxrmjh3qG8uypIwySjKEkUCS1epmTKupZGXYFsmM/UGMzMzlEXJG2+8jq7r9Pt9lpdXGGYK1wYqXgpt12SukdK2h4Q3C5IclpoJetam3ajh2taua9L1E754YYOlXoipyaR5ySsrIz5+tsXHTrduizdvBzvT9Pc6mlMY7//gIQTgDxB7vf326yqVJOmR7ABubGzwyiuvMDc3x5NPPsn1L32Nvp9ysxdiKiVb3S6mrpAUYCgSd/qa9oOUG/2IblQyVBQadovpuoxKRq/vUyfgjdc7OE5VO5hlOcXYSDrLS168OWR5EOHqKoMwxUsKtjyJtq3RsnWmTYnFtQ0W1zYAqDv2tj9XJut8d3GAayhMOZVzf16UXNkKePHmkB9/bGr7ur1d3C0g36tHlzBtFfwwcS/j3B40vk0yGYuLizz55JP7NskFSeUwkJclXm8TWZawVBUjKVHVg3ffi6LkRjdk00vZ9GKapkrT1jjSMPDiAlOVaVoamqIAErlUnVuz2cKtudzsBly+1kFVIoooZbk7Yq03om2rNB2Tx+frZHHAm9cDADRFGce3ymf1xZsei92QczM28ngqU8dP+O6NPudnHKach3dKuF/uVKd5kCAsimJbEArj/R8MhAD8AeB+vP0etgawKAouXrzI0tISTz/9NEeOHOF6J+ByH5bThLWgixQN0JKItq3hRxnH55xtUSJVRTGkWYEkV6bRryyPCJOc+brJlhezOYroeRIzNZ1zC9M8e6yOXORVV53vMRqOKMuCxevX8TBY7OQstGzm6gbdIKMzihlGGWZD4f3HGzT3WMEM/YChH3B9ZZ3FTsjF9YjzR6bwSgfLslAUhaalcnnT55Pn23e9XmGaEyQ5NUNFv8ON4F6ZvN79DKoXglDww8y9evtN4tv9NILszGR87GMfw3V31wtHac6fL/lshAU3lodc35LwNpaYc1TSIsNSZeqGioSEoshIQF4U25ZV1zshFzd82pZKnhd4acmgG9IPU440qnITXZNJ81spYwkJVZGRJZnrvQhN13m67TIMM7b8lK1hSJhlnJZCyu6Ai+EmtZqL47q4jsN6t896t09RlPzJ5T66YTHQm9i2g2HotG2NK1sBa8OYtn3n23hZlvTDDFmChvVoxOKkIfFeOEgQCuP9dx4hAN9h7tf09GF2AMMw5MUXX6QoCp5//nkcx2EYpnzzapcSeN9RhxWv5PWlLaIkJagbnJ9zOdK0KGFcHD15H6AqCr0wYRjnzLg6EhItx6Dvx3T8mBlX57ljDQxNBhTaRpv2VJtet8fW1iaOW+P6cp/BIEJNhhiGgasbNFo6o1RjytFp3WV1mxcl3aHP5TzGMapibtu2CUqN6UZ9127qXpKs4FvXe7x4c0iY5NRNjQ+ebPD+443t+ccPwsOmZA4ybRUu/oJ3IwfVM+/H5Hf3KgD3ZjJ2LqQmvLoy4nIn4nhNRm/XeP3qEmu9kJ4ncX7G5dyMjaHJlJRkO0ScjEQhSawMEyxNpmFp1EyVfpTSD2UoSx6fdTjRMm97zepYBV6U4kUZNUNFlhVajkLN0jjeMtj0Up4706JtKdv11KsrqyRJgmVZuK6L7Tj4YczmIMD3htQtHVVVsB0HL1ZI06nbrt1OFrshf3alW809liROTVn86Ln2Q5tV348A3MudjPd3CsJJynhnSYyIcY8WIQDfQe5UC3MQD7oDuL6+zoULF5ifn+eJJ57YDpQrg4hBmNC2JGYcDaUIiKctOiOZaVfnqXl3O+2wCwmyPMePEqqOuWpLv6lC3ZRxDQXHUMfib89TJZBlhampNvVIRfaHFAZkFPhBQJLEDDMFs7Do9cCxHXTj9sHsW17CG+sem6OY9WFM3daYcVSmspzNUUJLCvjKdwL8YR/XNlk4GlBzbtXX/MnFLb5+tUfDUmlYKsMo5fdf3aAoSj5yunXf13jCo6zJuR/TVkmS0HV9lzG1QPBOcbd65v3YKQruxH6ZjP1IsoIrWx4NUyWOJU5P2/SWM6wZh2GUcGbGZvaA6UQFJX6UESYptl59nxxLxzI0ZmtVjHEN7YDmtupneVnixTm9IKVu5TRtHYUSJBlTUzF1FVVVaDQbNJqVR2qaVB6Eg9GIF250udLNGaQKrqHQdAxOTtus9wMUWeLG1Qxv02JpvctGp8/sdBtdq27rG6OY331pja6fMlvXKcqSl24O6foJv/Cho7jGg9/+H6VVz736rE7qpHVdF8b7jwghAN8B7qUW5iDudwewKArefPNNlpeXefrpp1lYWNj1+zQvSfOSrJDIshR/NGC2bqJIYCrS/uJv8tysoBekLPcjvDij7RjUDRlVkYnzkoaloSoyRVHungAiSRRlwetrPlc3QwZhSjcA11CZcVzcWhMpjJmvyXQ7XZZv3sQwjMpyxnJwXYcMme8tDgiSnDPTNmvDmGGY0vcTRvWc87Mup6cs8qKgN/TpDjwy+XU0RaHVqCFrJi9cGzLlmLTHu4yOobI6iPju0oD3Hm9gPGA6+K0syj5IEOZ5zle/+lU+8pGPYBiG2CEUvKPcSz3zfuzcATyIIAh46aWXdmUyDiIrSuK0eg9ZXtDrdamZKo4hU3YK9Lt47wVxRsdPudmLaNkabUfHMRSiJMfUFBxTQ5Xl7ZKYnQyjlEtrMf0wpeunWH5GzYg52jDxkpyFuoGry+y1nEHTaLVbbKYanqZyZgHW+gG9KGep67Pe9zheV3n2aB0pj/FD2OyPeOXSdZRrS9Rsi3ajxmtbKRvDiMfna9vXtWaoXN0KeHPd5wMnGnf9exzEoxSAezlIEF65coU0TXnssceE8f4jQgjAt5mHnXMpy/L2c+/GJFCWZcnHPvax2wJlP0i5uD7i9dUR4TDn5nCNmpxiagp+knFkxkFTlCr9mxeU3ArKWV7y8sqI5UEMZcnaIKLjp7QtjZql4ugKs65Glo998JjsUo1fOy5ZCz0alsqT8y4rg4RRnHKtk3J6yuLZ423Oz9iVWNxjObO0tMSw0FnxVBYaJpZhULd1BkFCx0+YdnU+fLKBto+AS/OcjW6f9WHMpcsdjrRsQtfBHjeoNCyNXpAyDNM7uvOXZcnNfsTGKMFUZU5P29uzj9/OruOdnXgAmqZt7xLvdfGfBEth2ip4q9hZvzoRCfcb34ADF7nr6+u88sorLCws7Mpk7EdRlCx2fK5t+VzfHKHEGc3BMi2rim/mOK2rKQpFUaVsd4q4tUHEKyujKpUbZwRZSSdImKsZUMKZaRtDhawoqpIYWUaSJYqipCwLLm1FdCOJ87MOq4OYQZSxMUoI0pznjtZ5+khte4G903JGkiSQ4OYgxtFVGqZCwzEYRimjOMMLU55eMGgqCVeuXmXSotftdqjX61CWjIKQFy512BwlmFED27FxHBfLspAk6AbJXf8WQZJzdSsgzgrm6jpHG+Yugf522s7s3AGc1BHu3SEUtlr3jxCAbyP3UwtzEPe6A7i2tsaFCxc4cuQIjz/++G2BMkhy/vTiJiuDmPm6waudgrX1DWqmxpSjMe1ozNf0XYXNslQVSZdFyXLPZ3UQMV83mHI0NryUQZCy4cU0bZX3HK1R31FwXFBSTIJcWTJKoFBlaqZGURTULJ1RmLDlJRxvWZyfvSVW91rO5FnOK0sdyuGA0XBIP8vQdR3bNMGUMRRpj/i7XZBFac4wSvHXh9QHAU2rh6YqhBlYtsNwWKemNzH3ST0nWcF/urDBS8tDgiRHliXm6wY/8545zkzbD3Tje1h2Gk5PAt+dLBmER5fgUbN3cfsg34HJ4/fGuKIoeOONN1hZWdk3k7Efb6yN+NrlDnVLw9EVrq6MWC8TphydpqVxaspEV6XtGCfLt5pA4izn0qZPXpY8Nuuy6cV0w4y+n7BBwkdPt3hsR4xCqoQg47cd5xL9tGDKtdBVhVPTCn6U4cUZcVbw5JxLzdz/9ltSEicFQZyjKSDJMrokMe0qTDkly/2Quek2x1omZVHi+z5Xr15lNBqxvr6OoigYlkN3CDf7GXGW07R9bG0LSZLYiiSG7ZLe0KLh2vsKpSubPr/3ygZro5iiKLF1hfcdr/OXn55FUx7ttJZ7pSiKXWJw7w7hpEYahPH+vSIE4NvAzlqYSfHsg3557lYDuDNQPvPMM8zPz+/7uMVuwHI/4sy0TTFl0Vm6gqSVhFlBw9J45kgde0/9XlGWFFkVLHtBhqzIGLqKVhScNlTCms7GKOFY02TavV04bSNJpHlBVGT4sYKpyagStB2TNOeWGesBZKVEUGj0UoUInZajoikFWZawNYjQ4pIb13wcx8G0LMpyd5nOYjfke4tD/CTHizO2ApW6LjNXN4iygqN1jSs3lrhyYwnHMrctZ1r1Grqm8p0bfb51vcecq3OsaZLlBTd6If/3y+v8vz9xAt6h4Ai3dx7fq0eXEISCh+FB6pn3Y78UcBAEvPjiiwA8//zz2LZ91+MkWcGrqyNMTebklI0tJWxcGVAaDnFWcH7O4Wh9d4za2QQyilL8uKDlGKiKzHzTYsrJ8esGYZpzrGneMU4VQJJlhGmGDOiaSs3UMHWVnh/f9fr0w4SOH9PxU5qWyoxr0rQUwrTAUBWato6mqORSgW1XE0ROnTqFJMn0hx5fv9LhRiccuypE2JrMbM3AMjVcQ4dwwHcu+CiyTKte245xNcciSHK+8PI6W37CqZaJqsgMwpRvXO0x4xo8f6b1jglATbu9KfBuglDsEB6MEIBvMUVRkGXZA6d893Ino9T7CZSDMEWWQJElpKJEzTxOtQ1S2aBp67iGesedxjjLGfgJmgR1S0eWSixdxdBzdE29Y4DoBjnrAWymIR0/pWFXu42GIpPlBdOusSudkuX59rHyvOSFxT43uhGGKtEPUkZRVhVI2ybH5mt88JiDlsd4vsfG5hZlWWBoGp2tLWTd5OWbPmlR8PRCjeVexCDK2PITSuAjp1o8vVDbfq9+GOGHEUtrmwC4lsUfXBoBGo5edf+piszJlsX1bsiVTZ8zzbe/3u5O3c47EaatgkfJw9Qz78fk8zmJcaurq7z66qscPXqUxx9//J5v2n5S7bY1J1mIJKCt5xw92qDjJTStyhD6IIoC/CQnKyIcQ8U1FFRFxtShlCSUOzw3y0vWg5INP2Nx4NG0NNqOxlzNoBckOIZKw9ZQZQVJgizLKXccbqUf8d0bfYqieh9bfkYv8Jh2NUxN4fyMg6tLpPmtCUmKIqOoKpSwGUv0c5Unjk0zDFNWBhHDIGGpF3HE8jk9qzHcyihcF9d12eoP2OoPgMqDcCuWuXLT4/Gjt8ZyNiyNUZTx/aUBHzvdfMcE4L38/fcThMJ4f3+EAHyLeNhamIM4aFTSJOV7L4EyzavmjWvj+g45DYjjBF3TKUqJ2riwOc5zbrOALksubQYs9iLWhgldP8W1Yo7UDXRVRi5L2raKLFXNIOX4WkwsZIZhyiurAWlRMO3q9IOMlX5I14uZqxucbFss1I1d6ZTJsZBgZeBzsx8xWzOYrels+gldr7KimasbfPhkk5maDji0p9pQliwuLZGlGaORx2J3ncWuxKyrk8g6x1sGs7nOMMpQJIn3HHHvuLIfeAEbm1vkRUE+3MC2bSzbxrZtsrwkygrK8uCbYFGWvLnu89rqiDgrODVl895j9e36wQflQXeWhWmr4EF52Hrmg5BlmTRNefXVV1ldXeU973kPc3Nz93WMIMlZH0YsdgNmazpr65uUJaQ5GJqKpWtI0v4L3FGU8draiI4f48WVPVTDVDjSNOn5KQtNE1uXUcbnW5ZVec8kVL62OuKmV8XBQVwyjHL6YUovSJivmzw26yBLkG3X/ZXIkoIiy2RFzpvrHklecnbGYcpJ2QpS+kFCP8z45NE6zxyp70ppVK9fkGc5siKzPIgxNA1DU5lSZJq2TphkrI8SPnKyzqm6hOf5rK+vc+PGDSzbwnUqMeg4NuudkN5mjxvJAE1TseyqPlouNfwkpyjvXAM4CFNevDlkqRdRN1WeOVLj9JT10J+NBxWd9+OzujPGHYb4JgTgW8Be+4NHWQ+2dwcwz3PefPNNVlZW7ilQpnnBn13ucGF1WBUl3xwQbd6kDHMyJaXumkzZGllRIMuVmakkSeR5ZYy6Pkq4tOFTN1XOTFts+Sk9P2UYpJxsWzw57zLtaJSUu+sHxyarq8MAPy1oGzIz0w6DOKfnxfTClCNNi/cdv715Y+ex+n5GiYQ5FkxHVYU512DLi5l19bH423XBUBUVTdVYOLKA1oq4GKyRUZB6AaPhEEVWQNYoVJU4TjC0g4eyb3gxvSBhZRDRtDSm3JS27ZNkBV5SsL5QYIQWfhjftmIty5IvvbbJn7y5RZyXKJLEt673+f7SgL/xkWO7ZhffL5P6mIflIEE48eiKokgIQsG2DdGj2PXbj5deeglN0/j4xz+OZR38fdyPpV7In17coh9mrA0jri5vEPdGKEmJ5secaNuYqkSaFmjarZ2fLMspypLXVkd0/JSz0zarg5hRXLDYD/GTnPOzDudnHCRZ2uWLOunkDZOc5UGCrcJcTWO2odENUzp+iiLLvP9Enfn6Ht/AsStCkRf4cc4wymjYOrIs03YNGrZKmhpsBSkLjTunngGSLCeME3xNwtIVNEVGtw2GcYGmKtQbNeqNqgM4SyvLGc/zWF5eJohTrgcaix1YG4ZM1SxmnQR7OGRlGPHEQpPXryhsdAfYjnvba68NY37jz2+y2A3RFJksL/nmtR4/++wcH30Iay249x3Au3E/gvCH3XhfCMBHTFEU9Ho9rl+/ztNPP/3IPzQ7dwB93+ell15CkqR7ro250Ql4bXXEmSmHOdfgpWtrXEliej7U7JInF2q0HK1KS5Rsd/FC5W6/PkpBkqmbKjVDoWUbDKOqVuXUtF01b+xzzgUlRZ7TD2I0BeRSQlUUpmyFlqWyPohpWnefxBFnOYMwQZOrnUpDHTvuywqWoSKV7EqnwK2Vox/nXFr36YY5G0VBzbKYtlVqelVYPSPHLF67fJvljDquO1npR3ztcpc0L1FlmW6Y0w89OpaGa6o8NuuglTHXbva5vrSG/ucv0ay52/U1g1Tia5c7uIbKifHYuiQreGPd49vXevzFJ2fu+vc7iEcVHPdyN9PWlZUVyrJkfn5emLYeAiaL2zfffJNms8n09PQj/TuvrKyQ5zmNRoP3vOc99/2ZzvKC71zv4ccZHzvd4tKmx0uvLtMJUuQUnm2ZPDZXCRdJul3EjeKCXlQwUzNQJLB1jWGUMAxVVFnmuaN13P0WapJEXuQMo4QozTAUCVmSsSwd21CZdnT8JMfW7nLLLUv8JGcUZdRNjaZjIAGyqmCoBbqq3LYTtnND4MpmwOogZrEXsuGlNGydo2MPQF2BtqOhyAqyPG4mVDWarRbNVquaOvLGBht9D11J8MLKDWFNlWjaKtM1i1MtjZXNDtdvrrE5DFjt+9vxrd2o86cXOyx2Q85OO9tm+iuDiC+9tsmT8+5DTSJ5K2PcQcb7cRxz7do1Tp8+jWmaP3S2WkIAPiJ21sLEcczm5uZb5gNXliWrq6tcuHCBY8eO3VdtzM1eiCxJmJqCqSnMaTHaXI1LaciRmsaRprn9OnspKQnjlLLMyUsFVVFwVQnHVMkLH0tTDjBFrYjTAi/OWR2mGOSYUYqrj0c/SeCaVV1Mlmf7HufiusfFTZ+un9H1M1xTY85VcQyVssyZrxmUO9IpRVmQjwVsCXz7ep+bvZCFhsHGKKl8A4OEKVvj5FSd50+3aZgyvh/sspyxbQvXcfj+ek6QFJyetpmJs6o2x0/wk4IPn3J5//HGuEu7BKqbS2cwpDMYAvDGesDizZDHj04Rqy6GUaXNHV3l5ZXRPQvArKgG0u+9CbwdRc17BeFwOKQoCqanp3dZMuyXTvlhCJiHmZ31zP1+H8MwHtnfNM9zXn/9ddbX11FVlZMnTz7Q57njV/N65+ommipzxIZBU6eu2GxshZydcTE1eXsW+S4kiSTLSZKUQpdQFAldV5nRLGw9JUzyu04I8uOMfpAy9EpSNWZWUTFVhTgrMDQV19SQJXb7oo7xoozv3BjQDVL6QYptpNS9mGNNk2GUMVszaJjKrpKYfMcC/WY/4js3+piqzLSjM4wLVvsBPS/maNPkqQWX2ZpBXuRMniaNnR0kSWKx43NzkHC05XJiWtoeWTeIMlQKTihDNhcHhI5DHMekaUoQRgRRzM31LeK04E9e72FYNlFQYlo2iqIwXzO42gm41gl477G7ew+WZUlegrrnWr8dMW6vz2qapiwvL3Py5MnbjPd/GHxWhQB8BOythVHVOzdQPOxrjUYjXnvtNZ599tn7ro2pdtCqehSSiCxJqNsGtq5sF/xOXqcsy101gF2vqke5vBGwYSXM1EzaVvURkiWpGoiuVp5aeV6ws3wwTnO+uzhkdRgRZyWDpCBe85hxNcyxHcyso5EVVcOHMi6QnvhzbfkJF1ZGWKrM+Vmb1WFCECdcChNOtk2ePVLnSMPYlU4ZnwmyLNGLq/T1TE1DV6ouup6f0A1S6qbKj5xtb9vW7LWc8TyP7mDIza0RUlnQLSN0TWPB0TjWcNgYpczWjB2p6/1rVZI0Yzgacv1mjKUp6JqKbTt4mULTaN71b3dl0+dPL3W4shXg6AofOdXiR861MVT5kaWA75eiKLbFHhzs4i9MW9+97FfPPCkPeBR4nseLL764nfL91re+9cDxsyhLvDhDkatGj43NTWxTqwzhuxL7WUJNyPKSjVHM6jBmeRDRsg1mXI26qTKKMtq2jmvoVVwqi9tE3I1OwMvLI6KsYJCUpIOMUeozWzPICnhmwUaWSoqyqmtWZGmXx+orKyNWhzFnp2zWtJh+lLE+jPHjnKfmHd57rI4sS7eV10jjZr7r3ZiihLmaQcvRGcY5fT/Bj3Men3N57mj9thixs/O56yeUpYRlVHFwoV55uXaDDFeX+fizc4RRhOd5+H7A5uYmnU4X13VwXRfNtPGDgIEXEHsDLL2a2mGaNnG8d7f1dqI058+u9Pj29V6Vbp9x+OT5Kc5MV5mtdyLGTT7jk9h1p0lM70ZBKATgQ7JfLYyiKG+JAPQ8j6tXr5JlGZ/4xCfuqzamHNe2vLriVUXK/ZC0t8qUAdVisqSmVcLL9z2uXLlCUZS4tao4OFVMXlr2idIcR5cZhDnDYMSWrdGwNI41Tdq2Rprd8gCbeGoVZcmNrsdKP+REy8JRSpa6OSUly8OYZ+Zc3n+8jm2Mt+HZWSBd+XNteAlpKTHt6JRlScMyGIYJW37MybbFe47W9t99HKd5gqQkzyV0pTJBro3H1dVNhRKp2r3cB2U8psl0XMzVFfw4IwHkvCAIBuQFhKWGPxrgmwW27YxtZ3a/l81RwpvrHlujlI6XUrN05lyVJE1ZH8WcMAK++t30luVMo4a1w4PwyqbPv/7GEl0/pWlrbHkpn//eCsuDiL/x4aNvWXrkbuR5jq7fep8HpYyFaeu7k4PqmQ9qRrvfYy8vL/P6669z8uRJzp07t11f+iDichCmvHCjx42tgH44pKll5MMuc7VqPrmjFriGhqoolHK521B/HB+vbgXUTJWOl7A+qup9p51qBvCpKZO8zLc1pLLjc+6FKa+ve0jAUwsub6Q+qQTdIEOWJD52us25mVu+gdUi9dbLB0nOppfRdnUsVeLMjMMgSPCSnDQvee/xBk17//Rp1WRX0g9iTLX6++iazLSm0LZUVgcxNVO541QnqOrDB3GK0g9wTRVLlceCU8I2tarMxrKwLIvhYEi73cYwDEbeiE63z6vrKyz1ZEaZhK3JtFyDY02Llc4QTZFZviZRDBvbMW6nB2FRlvz7F1b45tUetl6VAn3rWp+LGz5/6+MnKruydyDG7Wxwgv0nMU3+vRuN94UAfEAmKd/JqnjnH/hRBMe9rKys8Oqrr9Jut4nj+L4Lo290Q752uUPNUnlyweXKapebGz1WVZnjTYt5V6FhyqysrrCyusrC/AKaphFHIb1ulwvrIZuRxNGWjdvQ8fPKz8qPc55ecHn2aB1lR3Hy3sHqq4MYS9fQVZWaLnPUgXrTZd1LOD1jM3UH38CSkiipas7SrKqDMVSYqZtkZVmNc7qjpUOJnxZs+QWjOKflaDRNFU2RibKCmZqJaaiUe0fWjQninK9f7Y5TzwmGpuDoMsdaLUZhyoxaYpNw48YNpBJM26IoqrnGjmURJAVfudShG6bM1fVx40zMIEiYdjXOzTg8PucSJQkrmx1WNjsA2KaxHSz/6LU+3SDl3Iy9/TkbRhnfWxzwI2fb1Mp3RgDeLSgL09Z3Lzu9/Xb+DeHhY1yWZbz22mtsbW3xvve9j+np6Yc6dlGU/Nnlanf86SN1rm75XL6yjOf79P2Eo00dIy0r25U8H0/rqGp5ZVmmF6Tc7Ie0HI15xaBl63S8mF6QUpbwvuN15vY0b+TlLRHZDRKCpGS+biJRMmvLGLZBUqrIEpydsXfFx70kWUGcpWiySqHIqIpCyzVxs4KuH6PsnTO3hziHoCi42Q+ZijLatoFrSGRFiSRL1C0dVVHIspy9xg4Al9Z9LqyM6AcpXS/FMTWmHJWmpZLlGSdbdYqyQJEqUTgxzbYdG9uxWU8tNsoe0/UCvJggLbnZ8dgaBCzUVD50soFKQW84ojcccWUJFFnerpHuZwrfWxwwXze3DbKnHY3LmwFfudR5xwTg3Zqc3u0+q0IAPgB3sz+YrGAfhVfSztqY5557bnsm4v1yecMjL0qOtyxmawZRdw2lbTMIUk5NOzhxSL/XoygKzp8/j2mYFEVBvVFnZm6Oq8kG01GCREo4GlDmOTOazkhScdUS/W7mzUXJMEzQlKq2Q5agZukMk+Kuwa0fpKwOQha7IR0voe2azDgqqiyR5yXTNQNVUZCo0inFnjTP5W7K1UFBmktV+jvMqOkyU66OhMSZKWu7lmbSrVxSpb2KEl5eHnKjG3KybWJqMoMopxukhGnB0/MuHzvTqgbKlyVRFLPV2cIPAq5fuYqsyGxlFmv9gvm6ga6rtByDQVClnxfqBn/h8WkM7fZrEEQxQRRzY2WTr39vGVUz6NDAsmxMy6ZmKKyPIm72I56o370+ph+kDKOMlq0dOIXgfpmkgO8VYdr6g8+9ePs9jAAcjUa8+OKLGIbB888/j2nuFlZ38jo9iPVRzGI35FjTxNQUdFKCNZkuOq6p8tyRGotXVve8DpWdU1kyCBOSrGTaVZFliRlXpWUpeHEOSEw5B4+FnBDEKV2/2v2SkDBVBU3RyIvyTutTiqJkbRizNogJ05CmrTLj6rRsnUGY4hgKDbsaWVdZ2WS7/h6DMOVCTyJSU6K0YLkXsTmKmXENFFlioWEw42jjBfnuucNZVtALU767OECSJR6fdVgexPhxyo0oJW0avP9YnbPjNGxeFuQ524t7WZLIS3hzM8DUFNq2yUzdoh+mDMKUNMt4Zs6glg157bUNTNPEdd3ttPGkRvrCyoib1/roC21yy8ayLXTdpGlrXNr0ycaC/U5xICtK1oYRslRNZrqTz+O98qDxDd4dglAIwPtk567fQYXtO+dZ3s+HZy+T2hhVVXn++eexLIuNjY0HCryDMMUai4w4DDClnBNTDqtKiFpmDIdDNFXjiSefQFPVaqU4JstLkgJ6ccmUYzM130LKM6IoYjgM6W6u81p/FcepvtS1WtXgwDiQv7nuszqMWeqGbHoxtirhSlXKQpdhylG3x8wVxW5PrVGU8c2rPXpBRs1UGYYZo9hjy1OZsjWONi2ONoxbu41luV1/UZawOQq5PsiwNIUjUzVWBzH9sBJflq7wyXNTnJ66tZs66VaeEGcFi4OYhq1j6TKnpiy8OMePNYIk533HG5X4A5AkTMukXqsRhiHnzp4jikJWr2yRphHDQYisyOi6wZSlYqgahirvK/52IklVembL84iiiIZtIEslqmYwSiSSsEVqH1xzEiQ5/9dLa/z5jQFxmuMYCj9yrr091ulhmEx+eFDu1bT193//97Ftm09/+tMP9X4Fd+Zevf0eRACWZcnNmzd54403OHXqFOfOndv32FUj1f0dO0xz0qLAHJdy+IMeR1oWdVMhzkt09fa08s4JQVGSM4gyil6AY6rUdGVcoyePrVQUijLf9/32gyr9u+mnLA9imraOkuRYTs4wijk346CrMpqiUDWH5bsyDa+teryyMsI1VeIsoRvk9IKAKSelaWk8PuuiyNwaWSfJ493EcXzdCBik8NSCzVSoselnDIKY9VHMB040+Mip1i3rmHG38q1rDWvDhCArONo0KfIc1zYYBjEdL+FYw+TDp5q3Z1jGF68oS7woI4gzLFVGkmUMFeY0hWlHY20Uc3x+hpNTNlmabc90X11dI0kSLMvCdV0CX2IUJtxY6+AYVSOLqmqMcpWFqTpxFN2xBvDCyogvvLzGcj9CkiROT1n81fcubNcPPiiPKr7BnQVhHMf843/8j/lH/+gf3Xd272EQAvAeuR9vv0chAJeXl3nttdc4ceIE58+f3z7mg9THbI6qYPD9xT7Hmhb5aAM1zyjKgjAM2VjZ4EjDwqm5aOruj0SY5Lx4c8jWKGHTSyshNow50jDISo2j0xYfPNOkSGMCPyAIfDbW10GSqNVq9HOdNzoZTVOhaBr0w5wNL2GzKDBrBU8tuLQcfdeYuZ2r1Jt9n26QcKxlkRUFvTBnaxThxTkLDZOPnGpi7Kzf22PtsDVKSAuJKUPF0FROT6uEqUHPT3BNlfNzDnciyQqyNENTZIqyqu+s2wquqbLaD/etqynLyjJHkiV0w0LSHcIyQZXN8Xi9jCAI6XgZtTJgdaWqHXQcB3WPTUScFnz1UoctL6UbpHSCBGdYdfUFw8po1e+s8vXFIWkU0phZoN2o0aw525+Zz39vlT+5uEXT1phyNYZRxv/10joAP/vs/qMC75VHnZY5yKPrS1/6EgsLC0IAvoXcj7ff/QrALMu4cOECvV6P97///UxNTd3x2PcT47K8YG0QcWXT5/pWwLQJ/lYPS1Pwk4y2a+JY+tj6pLztO3ujE/Dmhs8wStkYxbiGRstWmXZU/KTg3IxFSbHD3L6kGJeLZHnJ95eGdLyEU22LtUHIKEzwQ8jkmCeONLfnmu/ni+rFGVc6VVPXQsOgbWl0gpSun5AXJR862eBke7cgqMprquuT5yWrwxhHk1FVhbYt0bA04lRn00s4N+1Qt+5wm5cgzjKKvCDLC1RJRpFg2jUpyqq5ZL/ty0mMg2qR7MUpa8OchqnSdgxsTSZKcwxNpWkbKLIMqkqj2aDRvOVBOBp5XFzr862lgC2/ZGMUYekqbVtlumYwDDOemZb5+ouvceXSdTBcTmQl7R010je6Ib/2zSUGYcZsTaMo4dWxl+P/5y+cufNY0rvwsJs4ezlIEHa7XX71V3+Vf/JP/skje617QQjAe2CyI3HQvNW97BSA90ue57z22mtsbGzw3ve+l5mZ3dYg97s63hjF/MGrG3T9FFWWubjSY7i5RtvSSCMPW0p49tnTjAZ9KKVxEXa1sizygmtbIauDiFPTFq6p0g0yBkGCn+Q8s1DjuaP1SoBp1USMKaYp8oIwDPB9n0tXB/T9GMlUaOgGbk1npGl0vIzHZh0en91HgO1YpW6NIgxVHnv9SczXVKZtlbVRzLSrbTeOHEQpVbsDoyjDMCsbB0tXCdMSTZHunKYvq9TMppfSD6tu4RnXoO1UIsrWlWps3fiLPOl8LsddwEVR8vWrXd5Y90iygtU4Q1dlGqZKzbCZmZJ47rgNxGxsrBNFcWU547pYlo3jOLy8POLNDZ8jjcoyph9lDKKMYNPnsVmHT5xtY+kKwbDAj2Ku3lzl6s1VZEmiVa+RKxrfuLhJ27Fpj70HTU2hJObPrvT4ycencYwHDwN5nj/SALmXiSAMggDXvd14VvDw3Kme+SAm0zruhcFgwEsvvYRlWTz//PNVduAO3E+MK8uSb1zt8v3FPoYisz6KuHZjDTULmXF1NFXheNMkz4rK+kUaj01ToCwqR4Q31j1kGZ5ZqHOzHzIMMxa7IWVp8p6jdU60KgG2n7l9d1xSMlur0q11S6cfxCyuxzRMlY+eam6b1u/kli9qQpjkzNVNFFmi5Zo0HZ0jDQM/KWjZ+h3rm6HKDgRpgRcmuJYORYljKgzigrutzUZRxnI/YmUQ0fFTplyDaadqwojSnCPNWpV63lESM7nukiSxNoj4k4td/LhgGGZ4SUnHT5mp6RQlnJ9xaJgy+Xj3bmI5UxYlpVqi2jUuDn0M2+UxB5Z7AUGasdzLGPkhT0zrzKoRYaASxSkb3T6jqKodtk2DVr3Gny0GbI0Czs/d6nJ2DIUrmwEvLA34qYfwV33YHcC7MRGEYRhiGMa2m8LbhRCAd2BnOup+HO8nj7lfAbjXDmFvbQzc/+r4wvKQLT/m2aN1jrcsvvNqh1FZcmOzx1NTKp989nGajok37N/6khdj+5WiYG0UU7d1DFVlvi7TsjWCRKcfpjw269B2b+9MkxUZx3WxbAd7S8JwCgy52l3IIx8zT7FliLw+vi9h25Wz/l6KoiTKSjZGKXkJDcvAVKsVvCTJ2HpVw1ceYO2wMYx5fdWjF1XdbZ0kYK6m0bRU/DjhidnGth3DxBR2Z2rmzXWfb17roSkSiizRj3KGkU/H12hYKu87XsfUpO30c2VfI6HI1TGXuiFvrvu0HY2WrbE2ShiFCVteQs1U+dFzU5zekaKYWM5UKZIVoiTlhS0dWVZQJZljTZ2pRMdPM0ZRxodONjkx3h2oAvKtQFWUJZ3BkMVOyMrSGrMNi9S2MS0Ly3ao6Sq9MKMbpHcVgBOz6iDJOdG2ONK49bl8uwqzfd8XAvAt4EHHud3LDmBZliwuLnLx4kXOnDnDmTNn7vnY9xrjNkYJr62OmK4ZHG/bXF7t8b2NiF5cGSl/4FSDhYZJlqWTN1XVCRdV52w3zIgyWKhXHqLn5+qMwpiun9J2NJ45UjvwtQtKgjglLwoUqXrflgx2wyIY9rE0+a7G9llR4McZi12fuqFStzQUWSIrJAxNwdKr+b77NW7kecmLy0M2vYz1AJL1gLqVcLxlMoozXE1m2tXHjRvVNd3psRqlOV+52GFlGOHoCqM4Z6nrszVSaNkaCw2D01P2baJ3e5OAku8uDhlGKY/NOWyOEjp+ihdnbIwSPn6mzUdPN7dfb29joCzJLA9CRmnJXM1EKkvqTuXu0PNTph2VHztv43s+V7c2yfOc1dU16vU6tZoLZUkQxbz05hrDfsRKXMOwqrGchmUjSxIbo/iePkdrw4gb3RBTU3hyzt3+u71d8c3zPBzHedvrAIUAPICHmXM5qWnaZTNwF27evHmbHcJBx77X4JjlVVdYy9KRJAlHLXGzIS1GuHWL9z1+nKYzuZlL1b7+DkqqsUJpXqDLYOoqjqJg6Qppzl1tBfphtVu10o9oOxpTjs1srUbf8xl1R+hyVROUpimO425bzlimSVbAd270WeqF9IKEfpBgGzELDQNFkrA1idmaWhk/IyGPLWcmg9WDOOeb13qM4ox5R6YXwyCIGYQxs67B+VmHc7NOFZR2mMJOUjNJXvDqmocqS5yasplyMjp+Qi9ISfKCD51s8tTCbkEyOVY1UqpKvRelhGPoFGXBGUMlSnQ2R1WQPr2nPmViOTNJkXhhzLd7NymzlNEohhJ0XcdVFRJ59z2hLIt9NwqyoiRIC25s+bhmTMMcoSkSo6TEtmy8wTS+IeHYty82oLKf+bVvLrHUi0iLkpqh8ImzbX7+g0eqtPgjTpEchO/7OM6d0/WC+2Oy6/cg49zuFt/SNOXChQv0+30+8IEP0G637/nY97MD2PFjwjTnaLNaCDllyOPzNfpBiqHKHKmb1fdiIkL2hM48L4jSDD9W0DUZhZymbVAicZfSXLK8pOun1e6ZlzDt6rTsqq43yaFpVWUnlfAqbhNxq/2IF24MGEQZXpxh6RoNM2W+pjOKc56ad9EUoKRqcpOkKlU79kp9fd3jwsqQKUfF9yAtS1YGEYMw5fSUxXPH6jiGOm7cKLav7WSG8cWNqjb7SN1gvmbQi26V18y4Oj/22NRt6eOCkqLIyfOCYZTT8aumPFWRmW9YTDk6QZIxinOemHew7jDjvHJ3SCnyDEoVkFBliSnXREJG1yRmZmaYmZmhLEouXLiAZZmMRiPW1lZRFAXTcvD8gs1RQlqU1O0Ie9CrPhshxAsSW70azZqLqt7+XrKi5LdfWOErl7uMogxFgmMti7/50WM8Pue+rfHtXiZ5PWqEANyHnfYHD9qdc6+r2J12CPulfPc77r0Gx6IsGUXVHMokz1i69DpbW1scnZtjVCi7xgpNmiZ2PvdaN2R9FLM5SqibKm1HZ75hEMQ5pibRsrWqZrAsb9s92/ISvn29T5hUI+XWhildP2XK0ZDLkilL5ukzx5EliKKYIPDxPZ+tjQ1KoFtYXOzDbN2iZjiseSlemHJ1M+CxOYf3H29sjxXa3bhRTQJZ9yL6Yc58TcfMFVqORoJKJ0hZaBj8yLn2vqvzybF6fooXpTSsaiZn09GpmSrHmkWVKnG0Az8Xk2uaF1V9jRcn2FoVwB2zcui/lw61flQQFjKbPtQMg5ajocoFoygmS3K6qzdYSmo4tk0UJ7eliq5tBfzJxS2COCdIM3phTkeLmXYMkqLg8VmLpZUVllZWMHVt7D9Y366vCZKcf/X1RZZ6EUebJroi0Qsz/uC1TWZcnf/X07NveYpkgu/71GoH78YI7p299cwPEuPuFN/6/T4vvfQSjuPw8Y9/fJdP5MMeey9RUtD1Ym4oMrZS0u110eSq4cIy1O0UqLRHfUmSRD9MudYJWR3EbAxjmo7OnKvjGuBFKU8vuKhjQ/q9Iq4oSl68OeTKpo8mSwyijFGcsTlSaDs6qiJxtK7d2j2T2G4CKcqCMMn4/s0hQVrw1LzLYi9iFFWzi7O84H3HGzy1UNt+7t6dsxK41qnq5WqaROKAWbcYRhlJVvDeYw3OzNwuKCqP1er+0fESlHHHfUnJnK4y42hsjGKaY3/Xg5iUCqRZgVcmyFRiV9cUJEUmzmP23bbcQZwWrI9iNkZVU17bNmg7KoYq4ycZZ6dr42sGGQVlWTI1NY1u6JRFyWDk8Yevb3K9GzGKqhS0oVZd1IZW7abWCfje65eRkGjWHFpjW61JjfSfXuzw+69uUDNVTk9ZpHnJYjfk//f1RX75Lz/2tsY313XFDuA7yb3YH9wr9yLUJnYIuq7va4ewH/e6A+jHGV9+c5ObvZArmx4vXhwSdzd44ugcXi7j6FU6V5Jk1HGN3c4gc3XL59WVEQ1Tq77kacmwG9INEo7UTZ5ccKudwPFNZNJ9Oym0vrjuEcQZZ6cdpt2ULa+aPtINMt6/YNIubzVQmJaJaZm0p6Yoi5Ig8LnyZocyjxj1Q5BgwTRJDZVRKvHEnMvx9gGdUlIVYEdhAlQeWJIkYekS046Frkroyt1TM5QlQVIQJBF1S6VuqmPLAwlDUzHvkJqBko2g4JLnbQe3mqkzX9cwFJm8qFKpiiSN07ZVWmrnDOPrnYA/frNDmlW1M1X6OaNhaTiGyfvP1njv8So9MhyNGHkesiRxc2kJx3FQNJOvXe4SJDnn58ZD7aOMYVwACT9yrs1HTja3Xy9KUlY2u6xsdgGwDINlv+TKco9Tcy2M8fVq2xphkvOVSx1+6qkZsQP4LuN+65kPYr/4VpYlN27c4NKlS5w7d45Tp049UPy81xj3xtqIb1/vstyPuboVokRd7CKk7eoEceWZOXmvunbLvFpRZKJxc9sgTJmr6Wx5CRuDiK6fMOMaHG8aHG/ZuwzpJyKuBFZHITe6AW1bY7ZmsOEl9LyYQZzTcuDxlsyMu/v2ujOV2vEzhlHBbN1AKuGxuRqjMKEfpOiazAeO19EP2IIsKQninDCpdjklqZqHPlMzmXILVvrhXZ0FKEvirKAfpShDqFs6hgKSJFMgU7O0O5bXpEXJG+sBm15SpZuNyjNwoW7SCRJalsasq6OO76FVw8ytLuo8L/njN7cqAa3IBEnOchrR8SUapkbb0XhqobZ9zcqxlY6mqaiKQk7O4qhkNZA4MV1nJs1ZHyUEccqmlzJvxZxvafjdDaSkyiz1Rh69kbddI92sOfzf3+tQpjLttlUZaKsSx9sWS72Ql5aHnNB+uOObEIBjHiblux93SpHsdMA/deoUZ8+evedAfK87gN9b7PPGmsfJukxvw2Mt9okwuLgV8uRcjaeP1MY39SplmZfl9gSLooSlXoypybRsnaat0QurzjQJiacWapyZ3iPAxjV0eVGt7Lp+St3WkRWZlm1QN1WSrAqU8zWd0jvAWFOWcFwXzQywCpWWrUGRkcQJZRKTBBlrqxFTUgPXdbFtG3mPlUk69rZaH8aM4hS9LGgrBWVREKcFM7MGqjxu3Chvv5ZdP+WrV7r0wwwvStE9lbqpcKRhMAgzzkzbNM0qKEwC3E5/rl6Y8f2NFLTKz6sbpGyNIvpBzFxN5/G5GmenHfKyhHL3zuWkAef7SwPitOD0lM0ozugEOcMgIUxzPnG2xYfH1g6WZTE9M83qygpJkqLrBr1en+sdn5WOwpSjUmRwvGWSZCXDKEOW4IMnGjtG191OGMcsrg0YdjpspH00Xcc0HQzbwlA0hlFOnOZ3XSFveQnfWxoQpQWnpiyeXqjddZ7qXsqyJAgCsQP4EDxoPfNB7I1vSZLwyiuvMBqN+OAHP0ir1XqoY98txnW8hK9d7iBJEs+fbfPacp+LKz1W05w4K3hyoc6xcfNGVddcbB9TURQ2g4iNUcTRhoUsy7Rck74f0/ETZlydD55s7pu+nAiSXpCQFWCblVA61lKYdXU6fkLT1pi+i71SXhQkWUqUyOiKhCpJ1G0DWZZJsvwOA+sqRnHVmNYPMhqmjJxAUeQEyaTztjJ+noyZ20lZlnxvccjFDZ9BkI3nDifMjsdyqhIcbRi3ldfs9Fh9s1eyngVMuzolEGYFXj+iH6acaNl86GQTRZG2dxvhln2NJElc73pc74RMuwZzdYNOkNP1Ivwkp2Yq/NRTM8zU9F3vuSwno0FzKEuudUIUpaqT1JSq+7maqJLwkdNNnp1V8Tyf9fV1bty4gWVVHoSO6+I6Dlv9Ectra+Q5LIdbGJaNaVoYlk1RVLEyl+8c37Ki5MLKiBvdAEev6sKnnPvvOn6napyFAOThamEO4qAglmUZr776Kp1O5zYH/HvhXlbHUZpzacOnDAd0vB4fODPLpcUUrybjRTlPjIeC7zou1ZzMcuzr5McppiojSxK2oWHrKrOuzsaoamC4W2damBYMoow0K2hYVbOGrqkYaoGqyNypf3CxE7IxirnRjdg0VVqOznzNQTVtprWEk3MGRZ6wurxMnKbYtk1tXD+o6SbfvNbj8mYwrsNLKIuCYQLTeYRrqJxqW9srewlQZAWkKoDmRcm3r/fYGCWcn7FYGcgMo4LNUUyU5jx7tM6HTja3z3+/ALc4SPFTibNT1TVuu0ZVfxhlnJqy+fHHpm75ct36w26Ph/KijI6fUbc0ZEWhYSu4Zk7R1FkfxszXzdueX5ag6xqzc7PMzs1C3eN7/TXysiQMIzzPR1NVZBQKZJI0gzuYQRdFyTDMGIQpfpxRMxNaVoQ2lNkYxZyba3F9qc7ADw+8WX3zWo9f/2Y1vk6SQFVkPniiwd/5kZPYd6gN2g+xA/jgPOrF7eQYk/jW6/V46aWXqNfrPP/88/ed8t3LvcS4qls35exMVTh/yskoZhy2/Ji5usF7jtT3dMBOzrckjhMuXb3BoBeghL3qpm+aLLgarm7hGsoda9cA0rwqr9kcStSMSoDoqoKiylXjxh3Kv8Mk53o3YG2YsDqMaVg6M65Gy9LoBwkn2xa2oW1f4ywr2OmVv9yP+MaVLnFaEGc5a6OCMiuReyGKJPHYrEvdVLaF0sRouCiqWsClbsTLK0Pqpoo5Y7E6SgjinOudjJNti4+cbnG0UcWuXeU142P5ccZaAPWaQtPRaVhqVe8dpKiKxI891t4W3zvZaV+zOazmFpt6FYPmaiozjkrHT6hbGnP13fenyedh+2MrSaRZTl7kJFmONq7vq1kKw6gSbfVGg3pjYjmT4fnjBrvxYjlXTbygmhDVD1NaTkpNH5HkJaO4wNtSWTYTXHP/z7MXZ/yLr1znxZvDyqgamHJ0PvP88eoecR+IGsB3gEdRC3MQ+wnAuzng3+tx7zZlxA8jrt64QZllPH3+LMPhgLql4Roqq0WAus+KRtrRAxKlOf3xjb9t67QdHVOTidICU1NxDA1Flvcd7h0mOS8sDej4CR0/wdJV6kbEibbJMMppWJXD/uZIulXfkd9a8S73I759vVdt0Vsqo6Rg2AnoeDGzNYPH5lzOHm1U515W8xeDIMDzPLa2tlj1Ct4YqczUTNqzFptBxmbPYxQVHGnJPH+mtcsXau/c4W6QseVlzLg6uipzZkZlFGeMQpUS+Njp1oG+WpMANwwzVKlKP8uSTNOWqRsK+ijC1tTbxd8eFFkizQr8JCPLc2pmJaCrCRlVsfrev39RFqhy9b7itOBaJ6If5XSCEsfUaVsKhlbSG8ZMGxnL1y7Rsy1qtRqmZeM6NvIk1VGWfOVyl+8vDSjKkmGU4yUFXb+qBbV0hafmdG6srHHl5gZfe+EC7UadVr0a69Ssu3SDjF//5hKjKOPklIUsSfhxxjeu9jgzZfNX3nt//oOiC/jBeBT1zPsx2QG8evUqV65c4fz585w8efItXTzvJB371iV51YHrjYZM102QJAxVvs3+ZPK+giDk2o1FRolKpruE46kduR8wSBP6qUwdi+FAwrIcNP32OrjrnYA31n06fsqWl1A3dWZclYalkqY5R+o6Rb9qttAVZZz+LMaLzJI/v9HnRqeyqdn0KleAnp8w5WrM102emHfH2ZRJ4wbbk47SouTlmwPCtOCxOYeOn7ExitkaJHS8lE+eb/O+442dJ77rWABL/YiSascsLxQatlGJWS/h/KxzcOfz+FiDMCXOS0ytMn62DQVTq7I1/SCtRnPehbws8ZOMzijCNTU0pUrRl1Q2XVLJrpKYspxci+rYNzoBG17Ccr9qwGnYOrOuRlGWKFLJQtPcbpyZWM40m02azSYAq12PL7y0zjBKSfKSzVFMz4txDQVTVzgz7VCTE64sVdNjhim06rXt0ZyWafDFV9b58xsD5usGtq5QFCXL/Yhf++YSj806d6yh3IvYAXyb2VsLcydj5wdhZxC7Vwf8e2HyvIME4Fanyxe+9n3WAo1YqhEvjUh7q7QshVGcYRnVKDJVUarGjYm7+njVvTqI+d5inyDJ6QUZo7hky0+YqxvkBZyZsrD1KhBIVIKEcX1HSeVqv9SNONm2MMZj09a9aqj5E3MO7z3WQCOhLHZ4au2Y3nFlMyQrS440LKZdnX5Yzd+Ns4LH51zed+yW1xOShGGaGKZJq92mLEq6lzeRgyFlluIFHo6koDvg5RJzrsaR5p1Fd3VTyShKjXJc39awdAxVYRjGt3UR3v78kjAr6EYFSiegYeu4xnhMXSExVZukZvZP84RJzp9c7NALE/phxpaq4Ogxx5oW/ShlxtWZrxm70ilFUVY1Mlolir98cYvX1zwapkovrMa/eWFK3VKZqzv8pSdnmHfVbVf+Xm+ZNMtwbRvHcRnmKi8vD7E1hdaMQ8dP6fsJUZbTkFT+0pPTnJu2txdOIN2qr1leQ5YkLvdyltcGnJlvbe+9OIaKFWV85XKHTz83d8/fgSzLiONYCMD74FHWM+9HnucEQcDS0hIf/vCHaTQad3/SPXK3HcCOl/D66ojX1jyW+iF66qEnEaamEKUZ52ZsVKXqvq2Ez61RbBcvX6GrNAkUlTSPWBmkWIZK27JwazVmypz5uszGxhZBsIg9nuzj1GpYlsUgKnjp5hBZgvMzNqvDmFGUMAgTjrUMnlqofAOv96trlOywiFIVmVUvYqUfM1vT0ZSqxKYbVItlR1f50XNtmvYe4bCjCaQfpPTDnLaroygK065CTQOnCNAcnVNT9p3rmyWI0oyyGBs/KzKKJDHlGkRpse/mwF7iNCfMSm70YppWQdOpapujNMfSVRpONYZt4v23l4vrHi8vD8cp7Or6z9gajlFtKpydsqr087gkBiAZe/9JEqz0I7702iZhWuDoCkGaszaI6PkxU47B0wsOJ1vmbY0zqiIDVYf5i6sBwxTOztbw4pxNP8WPUrwk55idc1qJWVqMybIc0zSI4oTVrS6rW1WNtK7r/Kdvb6BIOoZcbSjIssSRpslSL+TFm0M+ef5gs/O9CAH4NjGphbl+/TqapjE7O/uWdN4oijLevq8c8Lvd7l0d8O+FnR6DO2sTyrLk+vXr/MELl1mV2pw54rLUD7myvE4wGDDl6LQcnafmXXSFXd51qqKiKQoRJa+tDYnSnCfma6z1A7phzmA8EP2jp5s8OX9rdVhS7moCiXNYHVU1MLYmV/Vr4+64JCt47midmZqON6oaNHacVLVKzUt6QYylVl98U9aY06rU88owpmmrdxyoLskSqqZRSCqSaTDdaJAlCSPPg6ygs7HORblHrVbDdWs4jrOrfjDPS1YHEZujhJv9iIapM+2oNG2NQVClJlpOFbh31vxNSLKCL1/c4uYgI8nhZj9i06v8xAxVpm6qtwJTWaLIym3+XN++3ufSps9Cw0SVE0ZJQS9ICZOCx+ZsfvRsG1WRdqVTxpcQTVHY8jOubgU0LK0ScI5Oz08YxhmmJvPTz8xup1d2Ws6kSbrtQfjqzU0GnsS0o5ChMm1rTDsa/TDD0uXKvHssPCVJus3DsShLOv0h4bDLVukhywrzx08jK8p2wXdRwl02QrfxPA9A1ADeI2VZ4nkely9f5oknnnjk4q/b7fLGG28A8Pzzz6Np977TcS/cyQZmFGV86dV1lvsh83WDlX7I+tIyliox7erM1w2ONKzq+8RkYgUs3VxCliX05jyDbsFcXadpqqx5KYMgZm2Y8NisxodOT7Mw9rnc6ct58+ZNkjSlk1t0PYUTbQtV1alblW/dlh9zrGnz/uP1fa/1xES6HybkZYmhqUiSRMtRqFsqbVtDkqB+lxndsgRxlpN6OXVLG2djpCoFrakod/k7b3kJG6OUxW4VmybGz/LYwH62ZoxnDlfiea8Mv7YV8NXLHZIc/CBlmFQbBDOuTlbAc0cdDKWKAft5rG55CV+70qMo4GTLYn0UE8QpN+KMuZrB+0/UeWwSX8YlMdX1K1AVBU3TeHWti58ULDQM8qJyVej7MVFW8PSCy088Pn2bRdlOE+8sL7nRDXEtDUVVqEsyNVMlyQ06XsqHHp/m/JReZZU2twjDkOFwtD3q1K25JGlOf9CHsmQ17FBvTVFvTY+vY1UCdT+IJpC3gZ21MN1uF8uymJube0teS5ZlfN/nG9/4BpZl8fGPf/yuDvj3elxg1wo5TVNeeeUVtnoDitZxjmhVYe1sTefbW0usqwpZUfKeI3VOtm+vM8jyjLwoGUU5wzBjyjVRFTjScpip53hxRpQWnJm2D+4ukyTiNCNJs3F9V4mqqLQchZqpsTEMxyuwg0nygjAt2PISgrSoPLUUmawERZZxDR153FG2H1c2q9TMxtiQtGZqHGnoZKWMrit84IljzJgFvu+ztrZCHCfYto3jutTcGq9sxLy0PMLWFeKgsnsZBJWgbdkazx1tIEnlbTM5JUkizwsubwRc3QyZthVcHbxCZRSkbAxjHp9z+LHHpm6t7iXpNn+uKC251omqTl9NwZmqdm29WCXNSz5xdoqFA3Yw87waat/xYpKspG1XItq1VBxDJohz0qLEPcD0WdM1Wu0WrXaLDfq8MtggLyXKJCUKIyQJ0kJFlxT8MMSxrGr3eJ+GjiQr2PQqM9d+kDLdbtLISmy5ZBil/MjZ9n01gvi+DyB2AO+BST1zkiQsLi7y5JNPPjLxV5YlV69e5erVqxw/fpzV1dVHLv7gzjYwVzZ9lgchj8255AVcyANyW6UXpEy5Ou8/0cTZMR0oSWKuXr223ajl5UrVPKVrqDKcNVTCus76KObElLUt/uB2X84kTvjzq5tkPY/NzQAkMA0d27RoWgq6epcsUll17/b8hCwvqFsaNaMSX0leMl0zUFWZIi/2rbEO4pwXbgzY9BKGUdV527JVZh2FYVxyfqYycFa2BX9Jlt2yrukHKV9+c4veeA66n+R4nVvGzyenLI63zH0zMwBBlPLnN/rEWcFRB1LNYBgVeHGGRJV+/tDJWzvB+3msLvZigqRgvq4jAXVbZxQmdP2UU1MWP3quvb+ALqt6xDTLWO2HVX26rCBLJVO2RMu0WR8l1K27l9hIVKn4IM23/W2lAnRVRVYKFFnGsiwsyyLwA2zbwnFcPM9jMBiwurpCN1EY+hLdsMQxFE7V53HLEi/OMVV513z5e8H3fY4cOXJfz3kUHBoBuLcWZrJD91ZQjmvTrl69ytmzZzl79uwjrb2BW1NGhsMh3//+93Fdlyef+yBvvLzB1ERkxB7HmjrzNY1uWA0WP2iHX5KqVVuY5eDHOLqMrkoYqkJZWSyP/3vwOW96MeujBD/OaNoaM2Nj1GGY4hgaTUcf12Xc/vxhmPGNa126fko3SBgEGeuGXLn4FyWzbrUbV5TltlnzzlXq+jDm29f7KLLE8ZbJhp/S9WMGYUJTK3h63uL0jIssS1VhcFkSJwmB5+MHPq9fuc6frxYYusq8bdA0TfpRQT9MQIJPnm/fcSYnwI1egKYq6HKBIhXM1xzCJGd9FHN+1uXoHdLPJeAnGUmWVZM5JFAlhZatUDdL1obRHV21yrKaVVoW1ei71WGEoylV+lmWSPISS1exDfXWtsg+bI4SLqyMGEQ5/QgsTWXKMbBVGI4SjlgF169cRVEVLLOq7YuiCNMwtncF/9OFDd5Y81BliNKCrUzHXx7RtlUWGiZ/+Zn7W3T5vo9pmm+LHcO7lb31zJORUo/KpieOY15++WXCMOQjH/kIZVmysrLy0Mfdj2pBtX8XxZYXoytVcxpSgZn7PDbnsjGKaY/rnCf0+wOuX79Ou93m2LFjvPTyS2R5yShMMFVpPJe7xDU1hnGOKt15gRqXMn6p0UtVYkOnZWggp/i+z8YwYaocsbYSYbvOvveWV1c9Lqx6+ElBNwgx9ZSWpTBlaWRFyem2ub2rrsjyeLF7K9Pw3cU+V7shx8c7Z6M4Z6kX0Q9k2hp84EQDRZFuq82e1MJd3hzS9ROOtUyy3KAbZnS9ykj71JTFJ89P7V7gS7uPtenF9MOMacekF46Ya9lkecEwzigKeOZI7Y7OAgUlfpxCWVB5c8sYKpi1au5wVYl0kLdqFd+Koqp/7/gxeVlSt3R0WaKUqphWM/UD69PhVg1mN0jpBSkdX8Y1FOZrBn6SY6syx1smslTVJEqAqqjYjo3t2MzOzXJt0+ePXlolzlOgxMtVLm0lrI06NEyNn3hiptrFvA9ECvgt4qBamLdKAE5SvkEQcPz4cc6dO/dIj78zBby0tMQbb7yxPWbpRjdgy4vZGsXMuBqdtXUkICnKW951BxCkJdf7ORtBjB9XHagtS+VIw6DrJczXTeqmsu2DVewxfr644fPSzSGmKuPHsOln9IKUaaeqgXv2qIsm7zY03dkE8vraiPVhzNkZm4atsuVlDMOYG92A9x2r8+FTze2V3d7ONFlWWB4kxHnJvKshSRpNx8ALEzpByjEr47kFe3daQJIwDAPDMGhNtcntAKW7RtOqZpwWSUidEtfRKKWSui7ftfO5KEqiNEWRsmo3AHBMDT3KbjOi3Y9hmDIIq8kpdavadaybKqPJ3OFaZV9Tid691g6wOEj5zqqHF2d0gwJNVajpCm1bI0rzKj1FCZQosrrt2ZjnOUhV/eEXL6yzOUqYdqraJD9OCeKUpq1xbrbGX3zPHLYmE4Yh3W6Hoii4fOkSuqbhujW2UpWL6x4NS2O6puNlCrHt4sU5LVvn//uTZ+87OL5TY5LeLexXz/woBWCn0+Gll15iamqK973vfaiqymg0essW0AftAKZ51YBwbcsnzQuk2CNOKsPhAhnX1JCl6ua/urrC+sYGJ06cYGo8hWQ9lNgMQ272Yra8mJqhcqRpoMoFUlky7WrbN/5JqdDkXQRxzreuVu4Ati4zCqtsSc1UaVkOj51o8cycThGHrK+tE4YhGxsbpEmC7br4mcxrqyMsVeaZIy7L/YhBlLE6iFFkmY+eanJqajJz+HZ3gWGUszxMaNsaliZTM1R6QbUTSFnydCNhtr5PhmlH/eDqIMTUKx89RYYFVWK+prEyiJipGXftfEaSyPICL67S2ACGruFIMmGc3tW6Jkwqg/2NUcIozmk5Oi1TRZGrrMGRpoWmKuOYtHtySllCVsLvX9hgZRAzjDJGUY6pxcy41dzhuqlyomWQF8WtTQIqd4fJRuSLN4d8/WoPR6+yKkFa0vVSRlHO0YbBJ862qFtVM0mR52R5Rgnbu6pFWfDt632iDE5OOYRpQWxOMcpl4rzkfVMFTxY3+PM/36LVatFqtWg2m3fdKX+njO5/qAXgnewPZFkmSZJH+no7h55PT08/UJfv3Zi8/9dff51+v79dV3h1y+ePX98c13gkyOkIJRxUK5s05+y0g6VVz1UUZbtIN89zylLi9Y2QdT/n1HSN1UHEMMrp+THDKOX0tMOT85VL+d65kMq4+Pfiuo+hyszVDVq2xpZfNTFEWcEnz7dvG3tW1dBVx4rTnNVhQtMx0BWZ+ZpB21IJUp1ekPLkfO32wuhbF4SiLBgECcq42FuSZGoG1HSLvCzR1Yy7NaaVJaSlRD+VcHSLdr1Glmb0gpg8Tbl+9RIbhl7VD9YqHyl5x431ymbAUi+qAjoljiFzysgpyxxFKjnSMLaDSFmyLbomXFz3+NNLHfKiJClKNv1qhdocp8E/cKKBrcvbHct7/bnCtOBbKz5JKXN2xmF1EBEkOV0/gbLkw6dafOBEc/ua5UXOOPvMZEj79W7V2TjtaKiKTMPRGYUpwzBltqbzV56b394hsB173AgQcu7cue1O7KtLffwoxZRSylxlYfYI9VaNTlCJ2PsVf/DOWST8oLPT22/nRB+4lSnI8/yB07RFUXDlyhWuX7/OE088wbFjx3Yd/60SgPvVACZZwf/zxgYXVkZseglrw4ikc5MZW8FQZUxFZsbVidOE69euk2UpTz/1FLphQFmy0o+4PoR2W+bElMWWl7E+SuiFKcebJo/PVdZYkxs/VF/Pic/nzYHPhpdwrGkxXzfpBimboxg/yTk/o/PR0+2xO0ATWODypcuYlkkUJ2x1Frk+yNkMNI63LFR0zs/VqgWqnzJXN3j6DjOHS0qCJCVJM2rj+ee6KjNbM6mblX/e3SYLVXXGJR2/qr9uWAaaPK7ElhQsTR0bge1PmOS8vuax5SUs9wvUUoZRJb66o4QTbYu6pY3rBytXgp0bBHFa8AevbXKtEyJL0B83p23pMq5R1Rg/NmOTZrfuLzvH3xVFzrUhXA79quvWUOj4GWGSsdyPOT9n8xcfn64sytg7HQoUSaKUJF5e9VBkiSlbo2EpjOICP07HJTZtnj1W33XeRVGlwSc7imGSszZKcEwNWVaoOSbnjs1WJujdkB957hQ/cqZOv9+n1+tx5cqVbQ/TVqtFu92m0WjctigTNjCPmLt5+ynjTsxHwX5Dzy9cuPCWBMhJQXwURdtWMklW8GeXO3hJxo+cm+LNdY9XXl9mYxiR5AUfON7kiR3NG3meb9tUSZLMIMroRSUtQ6btGBgK3FjdYljkFHHGaVtDL2PKQt1V8zX5knX9hCDJmalXRqZTNYPmeNfJj3OmXP2uuzfJeH6uIYOuKRi6hq6WhOn+nWQ7CeKcUZSy1AsZhClTrknTmnzBJOqGiqqqB9YPLvcjvnW9zyBMWR8WmLpKw1SYq+lkqLz3dJtnj9fxfY8gCNhYX2MxirEsG9d1GBYGX70+ogSaljaeeJITrnrM1Q2eOeJyrGXuSktMRJc0Pvfv3OiT5XBuxqYTJPSC6pyCJOPHnp7lfcd2d1nu3QVd9wu8VOJoy4Sy4Mysgz/28bN1lR97rH1gbcxkSHs/SCjLstqZlSVsGWxVxlAkJKTb6j/LsqoBlBW5EsU1l/nIQOlukgEKCjkSna0t+qmC1TDY2tqi2Wxu71DdC+/UmKQfZPYubve6GExi3oPGuCiKeOmll0iShI9+9KO37U5MBOCd7KgelP12AN8cz709P+swU9N5+coK16KEq0HJ43M13nusgVomvPH6NWzH5rEzj1c7QEWJqiisDhNKJFq2iq7ptJ2Cnh/RC1LOzFTWJ7c3DtzaidsaJeiqjKoqqMCCJjPr6qwOY+brxm3WULIs4dgOrXarKjdZ7HLtSpeBHyHlQ5AkLNNEk1TgLveJsmQQVqM014cJLVujbWs4hoKXZFiGgqvLqLKy3Uy2kywv+frVLjf7IT0voe+n2EbMkYZBUYCryxxp6JQTz0BJrgTceAe0LEu+cqnD5c2AGddg04vxo4Ib3ZB+mHG8ZfKhk43KpmaP6JIkGUmCV1dHLPZC5uoGMzWdLT9j4Ff1gCfaKv/Z07O7F/nS7mxRWcJNX8Y0VEytEv1NSyNIMnpBxvuONThxh7q7vCwJxm4IplK9L12VaavVzOb1Ybxv+noS4yZo49IjL0qRKFloVz6+xXiIgqHJ6LrO7Owss7OzQFU+0ev16PV6vP766yRJQqPRoNVqUa/XcRznLTe6/+xnP8tnP/tZrl+/DsDTTz/Nf//f//c/fAJwZy3MZF7hfgHqUaWADxp6/laskFdXV7lw4QKSJPHMM89s7zCuDSM2RzHHWhaaInPMKQhaBtO2jFTCUws1zANHA1V1GUmWYyolge8z6Pc5Pl0nlxT8KKHIUhYXF8mLAtdxcN0atZpbNbWMmxmCNGe1H1IzVGqWNu6GktFUMPYZwj0hz0subvisjxK6QULNUJmydRYaOoMww9EVplwNVVZAKimKcpeI8+OcP7m4xXI/pgQ2vZTueOfM0WVmXYMZMyHL8l31g9VrF4RpzjeuVIPAH5t1We6HeHHB+jAmy0vee6zOe4/Vq26xbWPRBZI4IQh8At/nu9d6bA5z5l0N19GwZIUgK0gLiSfnXT5xtr1vV9okwG2MYgZhTsvRkBSFaceibeeEqYEXZxxrmnfsfkaSSPKcspAp8hxJBrmUqVk6UP19irvlZ8qSKC0YRRl5XnXIuXpVhxQXcKxW+WrtTP0XRVWXM+F6J+CFxQHDKGMQgttqYio2DVtBGka8b07j0qVLRFG0vSJutVr7roh3Ikygd3Ov3n4PGuM2Nzd5+eWXmZmZ4QMf+MC+Yn1nM9qjFoD77QBe3fTRFRlTU5hTZY6YKdZCnU0v5tyMjZGOuHR9mSMLC8zOzm1rIEmCvMgZhDGKVEJZ1Uc2lHL8+Q5wDeW27+dOyrIkyQo6foIsVWPTdAWUsXfdnUprALb8lMV+Si+GYarQsOtMmRJlmTHwAlrFgEsXh9TrNRynsptRdsTM11Z9vrPYpwD8JMdPi+2dekWReHbORI5GZEW+XT84sYfKipw31z3eWPeYrRuYmsKWl+LHKVc2cx6bdfjY6da2+MqLgnwsSKsdUIX1UczNfkzbUbE0lYalsLTRI1eqGPGfPTlD273dLHnnpKOVXogkyxhatUN4rCEzX9NYH1UCeufUj/0oioK0KNDLYvu+bsgSuqoSpgeb0e8kK0qSvGAQpNTTgoato4/Tz5oq07YNFFnZlZ3ZGeOyvOSPXt+kH2QM44x+lBO5MmeMjG5QWXQ9d7R+2+sahsH8/Dzz8/OUZUkURfR6PbrdLn/4h3/IP/gH/wBJkvjSl77EuXPneN/73vfI652PHTvGP/7H/5jz589TliX/x//xf/CzP/uzP1wCcGK7ci+O93ca1XavDAYDXnzxxX2Hnj9KAVgUBW+88QYrKys899xzvPLKK7t/X1aBYRRluIbC5uYWrqVXQ7mTjDsN5S6KaqxRN8xZixPcYcqJuSaua7ExjJhp1nj83DRSCZ7v4/keo9GItbVVFEUlVW0uDaDrZwRJjmNoNKyUhbpBP0w5P+NUhqFUEzckaffbeW1txPeXhrQslSwvqlrEblDNHG6aPHOkhqUpu8yaJ3U6AJc3BqwNY463LWbrOhte5VnXD1NOtev86PkpuqvBrfPdu3PmpQzigtm6iVwWnJ+rMQqrMUu2pvDJ8+19u5d1Q0c3dJqtFsr6Cu0yxtAkkjzDJMVQCkaAlEXkWYa8j6HsrfOBtCjo+SmuUVRGqJKEIiuoSnlXb644LegEBb2opL/u0bB1piwVW1cYRimPzTrYurrt9bhzJufkOnztcq8a2ZYVeHFON8xwdBnXUFFliWcWnG3BqkwKpHf8HYZhxhcvbDCKKjuHbpCRqg5XNwPm6gY/9tgMf/OTp7A0ZTsA9no9XnvtNbIs214Rt1otarXaLoujR1Ug/dWvfpV/+k//KS+88AKrq6v87u/+Lp/+9Kcf+rhvF/fr7Xe/WY6iKLh06RKLi4s89dRTHD169MDH7mxGe9B5wnc69t4dwDDLq67VOCMNRpR5Rssx8OKUzY11Mjni3Nlz1Gq3f06G4zKGVR/ohMwVCg1TJs8rL9OaVc2sLYqSvcYneV7y/ZsDbnQDOn41DrNuaSzUK687Q4FZV9/dMVuW236hflwtMHthykxNp+OlbAxDen41Ou6xYzM8f6pBngSMRh7Ly8skaYLrONTcGpJu8vLKCE2ReWLc7NL1k7E5u8xPPTHNsZrEzaXq9farH7zaCTE0FUdTsDSFlq3jxyndIOOZo/XbynMmTEzye0FMkuW0x6PqbE1hypSwaxZJXmJo9yBWJIkwzhgE4/QpoChVJ6+u3mmuesXKMCHKYKUbYmsJLUdnytaIswJNprLNGoum/TxWO17C//3yOsMww4snIrqqqcxLODVlMV/XyCciWpmU69xa4Hzzapfv3xzStFWgJNZrdIIUb2XEU/Mun/n48e0U9MGXQdruMD5y5AhPPfUUH/jAB/j0pz/N5cuX+cmf/EkURWFxcfGRLno/9alP7fr/f/gP/yGf/exnfzgE4J1qYQ7iYVLAO4eenz17ltOnT9/2eo9CYAKEYciLL75IWZY8//zz2La9a4XcD1JeWOxzbSvgjTWPupyghEPatkbPrwyEHVO95TeX5dur47KEV5YHvLoyIIlj/LSk0CwW+ylBJiNLcLptbb+WbdvUay7MSyRpymA04v95Y4stL6It5UiSTBQXjMKEOM14z5H6tqv8rokbY4v3opS52omwdIWmVY1C6oYZ/SBBliU+dKLJmZnbg9POOp2b/QhTrZpTVEniVEshrVepmVNTNk1bo8sB3WVj65osyymLgkICVZJo2jqyVK0Y8wLusIFJnBakecmWn5HZOk3HhqKamSknMmUScvHim6iqur1z6jju9grfj3O+fb1Pz0/x0xxbU6lbCgs1g46fcLxp0Xaq4nRFkSkK9qxQq1XplWGJoSoEaWXB0g8S6obKlKvxgRONPTcFCXXczJPnBTcHES8sDTBUmXMzNmvDajTUcNx88hcfm+b8jr9DPhYiaZohSVWB9OWtkFGUM23ryLLE3Mw0ueWy5SWcm7H5uz9xZtv6xTRNFhYWWFhY2J7zOxGEi4uLlGXl2t9qtYiiiOFw+EjqY3z//8/en8ZIdqb3veDv7OfEHpF71r4Xl25uTbJJqrV1a+nra9jw3IGvjbE0MuyxAcmCIGBgSfDyzbJsQ5BhXED+YEMwjIY8Nqy5Y0tuSW6ppZZ6Y7NZRRZZJGuvyj1jj7Mv7zsf3oiozKrMqmItYgu6zzcWM07EiXPiOc/yXwKee+45/vbf/tv8tb/21+7799euXePYsWOP/L6PIx7Gzu3j5KAoijh//jx5nvPaa6/dt+C+U43gccbO/Cal5N21IZfG4sE3uyFFb51ZTyPNUvq9LofmbJ599hls21JF3I7P1A8zvnG1Sy9U7OiNYUo/HjBTsXFNXU2fSqb6feySPVESKje6EZe2Quaqanq25acMo5xRlHNqvsxLh+u0yrenZzvPQdc1VocJvThnqeaiATNlQS+M6QY5yw2Xz51s4loGeLdty7I0YzQa4fsjrt3cYq0tWay6JJrNfNlmrmIzitVG48hMCZnF+7NnkYRprnKSlOiGgWeDZ5vERXBf3UBQTH4/KbjRjai6JhVbPUuiXFB1bcrOBD+49xzu4rrPh1sBnXFjXnIslqo2ug46giNNF7QJKVDhk3dueW52I37/0oBEgKlrBJkg6Ed0/ZS6Z/L0UoWlmn17ZbyHxuqfXumy6SusYi/M6IU5UZbTDjJePlznR56am06Bd25nikKMFSc03t0Ix3quFlXXwpldwk8lYSb4yVcP8pkJxvpjhK7rvPTSSxiGwa/+6q/y0ksvcfHixSe68SiKgv/8n/8zQRD8+S8A75Q/eFBHj4ddj0w094bD4T1Nz3VdsUkfJSarmMXFRc6ePTsdC09u7KwQ/P7FLS5t+ZxeKHOtHXDt2jp5ljBXdTjU8Dg1X9llhA7q3DWg4ydcXOsRDwcca1j0UkFhmAyijIpr8caxOodbt4ksO8U0NV0j1hxys8TpQ3VkIVhIE7qjkK6fQZIyj8AfCLRKFdd1dmFTpJQMo4QozanaBpqu47k6S7bJbMWi46e79Lz2CyFgGOfYZkLVVZ24Y1lYRjFd9e4HbU4ywfogZstP2PYTGiWH2bJaHQ+TnGMzJUqOwg7me5iqh0nB73+wzfogZpQUjNKQLV+nakh0Q2epWebVpxdwTRj5AXEYsL21xY3oJp7nUS6X+dZGzrVexlLdYWuUEGaCjWGOn+ScmC3zxommYutKiZgCpBWLV9PgRj/kcjugakG96hJk0AsTgkRQcQz+yqcX7/bVZDdW50YnIi0krbLCAR2bKRNlGd0gZ7Hm3AWMvn0NBfoYID2KFX5Q0zXQdFqtGUzLwtA0CsG+un+aplEulymXyxw8eHAqYjwpCP/G3/gbbG9vMzs7y7/9t/+WH/7hH35oJ50vfvGLfPGLX3zgv//1X/91fuVXfuVjv8/jDiEEaZp+bEePB81xW1tbvPvuuywsLPDUU0890PrpSRaAOyeAl7YCfv/iNmXb5OiMx42NLlsbPW5pkhIxpxerfObZo+i6Tp7fLo51XTEcLm/16YUZx2ZKyLBPbjuMkkIJ/h6u8cKh+m3s1x2yJ5qmsTpIsEyDkmPiWjqNkoUfZ7SDjDML5X2nZ6CKh0GYostxwa5rNAyDmmtQslNKtqGKvzvCsi1aMy1aMy2ohLwz2iAqJGkQwmCAYZrkuoVhmAiRj5n9e8dqP2YQZdzsxQpeU7aZrVhkucDUNGarNtbYNWUv/ODFdZ9vXesRJAVxLuiEORVLwxLg5ZIz8x6T0s/QdXRdkdzyXDWpK72YP7rcQUdjsaY2A8MoxY/VluiFQ7Up+3kvgqGUkrdXhkSZYL6kYXtlemE+FdR+/qDa8uz6TdyhsRqmBTf7ynPZNHRmKzYNzyLKC0ZRzqcPVPe395QCTdcZxRlJOrG50yhXqjSqJWbG5I/7QmzuExMWsGEYPPvss492sH3i3Xff5bXXXiOOYyqVCr/1W7/157sAfBSfy4eZ0PX7fc6fP0+lUrmv6fmjrICllFy+fJnr16/zzDPP3CUQOemQV3oRN7ohR2ZKiglHRtHW2fZNao7Jq8ead42kNW08Ipfw0c11trt9Ti0rdxLD92nNVOmFGY6pcbjl3VP6JC/URLHIleJ7pVymUi7TjHOiJKFSsQl8n82NDQzDmAouTwqzJC8YxhltP1ETwLKDbWgkudLjq7oWGtqenaUQkvMrQ1YGMWuDiE6QUPVsDtUdsiLHMWGxaqtEohuYho6ONl3xCCH548tdLm8FeJbBMM7ZGMZ0g0SBrMs2n1qqjjExKgxNJXGkkil4d23IzbEuV92z2B5ja9qp4PSsxQ+dnqE0LmLr9Rr1eo0FIM+U68Zax+fK1ghDCgzdZLlqEeUaYSYxDY0ff2qW2epe0g6qSwaF/ywEeIaa6s04Bo2xIbppaMzfB1sDaqJaFIKsKDA1DYHAtS3c9PYqa8/XCaGINUISJAqCkBWCVr0O44dKkBW8OPvgNmGaplGtVqlWqxw+fJi3336bv/f3/h7Xrl3jN3/zN/nZn/1Zfv3Xf52f+qmfeuBjPmx84xvfeOLvca94UDzzfnG/HCeE4KOPPuLWrVt75pl7xaTRftITwHdXh8jxpGup7lL0N0msgkGQ8urpOV47vXyXtumk4RVC/T5qnrJNKzsGtZqFYVfZHEQcbHn3bDIlkijNkKKgKAws08AwxtOzXGLdR1qgGP8uNv2EXEhlC2krOExeyLEuqr5LrHlndP2McytD+nHBZiaouTbNkkfF0VkfRhz0Yq5e+lBpcCIJfR/HvY0fXO3HfOWDNkkmcAyNYVIwigO6vkXNMzmzUGGhYpMVty0dTV35+4pC0AsTvnW9h5BwdrHM+iBhmOT0opyyrvG5w3U+vQPzpjyHb397hm5ypROR5pKFqg2aRbOsdBj7Uc5Ti2U+t4/w8wSqk+WqSfds5e/sWQZOdYIfTJmt2PcVfs6F+mxSqAGHbuhYpioww1TsT8GRCnOuazppIUgywXaSUnFMjs6o30qQFjiWzlL94U0eJsLtT1oG5syZM5w7d47BYMB/+S//hZ/8yZ/881kAPg6fy48zAdy58j158iRHjx59oPXLwyTHieBqHMd7su8mx5Zj1fG8kDjjDjYP+hxslah5avJY2kfXqSgE129cp9vzsbwqoTDQiwxRCGzTxDYEjqnfU7kuyQSr/YiNUczGMKZZcZgrFVQ9Jfx8sFni8IHZ8fRMWSqNRj7tTpsojOimGt9+Z4VhKBmlgn6sVpcLNZc0LzizUKFk60jkGHNm7BrNX9kOeXtlSN01kXWXbljQHsUMo5SjLY8XDzeYrdiI8WuUFZFQ6vG6xq1hxPVOwEzFYsl0lO/uSOlLeZbOj5ydvWtyVkgB0y2D5GonUjp/lkFTh3rJJEpt1ro+p2ecu14/CdOyaDSbDIWL5eS0PBNRZGSFwCoSPCHIpEl/MKBmN7CdexdxUVaQFRLTVYlZ0zQKCbXx9PJezWk/zMaYy4xBnFN2LWZLJrYpiPOC47PVHfI1u/W5hJBITeN339/m3MqQXEgl/ePZBGtD5XTgmvzYU3P3/Pz3CsdxmJub4+DBg/zrf/2viaLoicmP3BkbGxt/Ju+zV3wcPPN+ca8cF4Yh58+fRwjB66+//lArpyclBTPJb4WQdMJ0Ku4cBkPCzjqzVs7MUpPluca+wvYq1JZkGKfIMXnA0HUcU+HO7udGs96PaQcZ1zsh1WHCbMVhrqpEmw1NozUWtkdy1/SsEJK31kJWfUWuutYJ8fyU2ZJFydbxbIODdYe8EGO8rzYVUhdSkBeSP7nSYctPOdbyWOvHhFnBsJvhl21OLzT4/pMtPAPa7TbtTpsbN2+RFzm1sV3Z22sZYVZwuOUxnzt0wozuKCUpCp5dbvLZY807tFHH+MHxNV0bJASZYKmmtkDH50zCNKc9ihFJxGeO1Pcnz4yb1K6fYE4lVDXKtkbJdhHEWKZx/+fo+DsZRjllE8qliWmBhmaMCTj3wg9KydV2oGRnohzP1GmUbGbKlnJTsXUONtypfM1OjVUxHuutj1L+24Vt/KxQun+aTtJNmU9Vs/LZY42HkreaxETZ40kLQdu2PdUlfumll3jzzTf//BWAD4OF2SseFAOYpikXLly478r3zniY5Njr9Th37hzNZnMquLpXaOOV5PYo5kY3pBem1ExBMBhhGhpRJliqeziWIlbsXIFGUcSVK1cZFiaBPUOvH7AdjiibGiVN0Ewz/DTj5FxtihXTUD+GQqrzEULy5s0+19shNdekG+Zs9BM6o4SZisVs2eb0fHnX9KxaqVKv1UGDdqfLW99dIdEE81aGURREeUE3UZZqr59o8eKh21MjhTkbr/jH53+lE2EYOnXPpOZZzFSUbMog3o09vOOLm/pLdkaJmpyNyRGzZYOmazKIMyxDScDcMzTIckGaF2S5jmUa6BJqnsH2A5rchlmBnxQMopy6Z9DwXCqlEm0/pqRJZOxz6dIWhmFQqVaVD2W5gmmp++LqdsibN/pq8pZLRiKh6RXUPZMkLzg730CyWzMwz4sJBJMwKfit8xtsDFPKtoE/tqkaRikN1+RQ0+P5g/V9nQVAsjYqeGdtRMVROM5uqpG7HsM4Z6Hm8A9+4Oje1+JjRBAE09+d5308i6U/b/EweOb9Yr8ct7GxwYULF1heXubMmTMPzTh8UgXgpNkYRBk9P+VKO2DO01i7fAHP1JhrLdBPhBJ+Hk857/yOklzw9s0+WyPl87s1StCyArecM0pjSrbObNlG13TlBz4uOCcP/41BzDeu9ckKSdk2GSWCYRLQDpRv7/HZMrNla4dUiTZ1ORJCshEKbvZTlpsVmiWb9WHKIEpZH8acnivz6lHVoMLdlmkasDHK6IQ58xU1Jax6Fv0wpRfmNEsmnz8zM10fVyoVBoMBZ86cJklT/JFPbzDk2nqApmn4eo5lWSxVLA7UHNYHCXPV+0/O1CpXEGc5tqkDOp5jUk4t/DS+53YAlGZekgs2hglhWtAoOVQctZqXEmYrzlhZoNhzhZpkgv/5YZtOkNKLBANNMswDluo2QVJQ9ywONVSTvVMzcMKGBnjr1pA//LCNpetYuk6UQzSM6UcZM2WbV481KTvmXfI1uq6TCQES/uRqj16YcbjpMohyIqdFUki2/ZT//TPL/D8/e+iRmPATq8s/a6UDIcSfrwLwYbEwe8WDrIB7vR7nz5+nVqvdd+W71/E/zoTx+vXrXL58mdOnT3P48OF7n5um8adXB3zUV2PpS6OApLdBmXRMx9fGdj9q1WuMrZM63S5Xr16j0pxle2CQS8HphQqrvZhBmNBNJVY34qnlKsfnykgpdmkx6WgYpsH6IOZWL2amYrNk6MxEOd0goRNkuKbBGyda0+Q2CYFEjNeWwxTCQuPEstKmm8sL/CCkF8YkSYw1Wmdz3adSrlCtVrF2MGgnLiTDKMXWFaVYFYJKHV8j3hNXc5c2llAellvDhLJj4poKtJ1LjcaYNLOf5zBSSdd0w4yNYcLmMKFVsZmv2MRZgaXBfMXa4ZqiuvqdcWFtxNcudUlzQZAV+GlBJ8hpldXa+9VjLU4daSCKgiAIiMKQbrvNys1b2I6N5lT4vWsxiVCr+pttnzQTbGQJWSF5/pCSr5l+98Vt/KCuGRi6zqX2iK1RynzVRgeGiWAQJYSJYLnh8n97YenuFdkOfa6iKNgMJLmEsmMjZcHZpSUMV62LDrc8Xjna2Ps7/BjxSdkkLS4u/pm+38PimfeLO3PcTjWBZ5999pHP70lOANthwXtvr7HlJ2z2fS7fGGDEgsMzVbaDjOWaS9MzlR+1pmOaOkiF4ZNS8OGmz+XtULlLGDrdsKAbw8WtkKeXGzx/sI5nG+OGcPw7n+rgaVzZDomynENNT4kdRzmdUUKSC07PV3jhUP3u6dmO77oTKUyc55g4haA8XyJMbLZGCSfmygpes09IIEzUc84cs1Edw2C+puOaSs9wT2UA7ba7Ua3ZorRxi0GUEmQSO4/Ihym6bpJIkzyJKPLdcjM7YxTnXGkHbAcp235KrWQxV1bexaM4Y96T2KYxzpPiLueOMCn47fe2uNmNyIRkY5TSCVSj65g6cxWHYy13+p0pzJ/a8kxYvN++0ef99RFzFQdEwSjTGMYZcVZwfLbEF87MTN1Ldj2nNB3T0ElzwXdvDjF0jeWKTatkMYiV64ehaXz+TGvXCnsSU5JbXhAUko1hRr2kWN+ztTKzBxYI04JtP+WzR5vU7sP8vV8EQaCkf56g1eUv/uIv8sUvfpHDhw8zGo340pe+xFe/+tU/HwXgZOU76YoftfiDe69HdhZkp06d4siRIx/7/R40Oe4klbz88ss0Go37vqYTw4VRwKG5BssNj/dutbm4FbMVKx/ZV4+1ODA2Ndc0NfVZXV2l0+lw7NgxOrlN2O6xNMaX1TyHzd6QtU7GcsPllaNNdFT3tzMEEpHn9IKEohBKPV7XmK0oM/HZaoapacyU7+08IKXCwPhJRtk2sEydZqOGVyozSlIOHqqgZxHdbpeVlRUcx9nlwDFMBEFSsNqPaZUtmiWbmmuQFRJd1xS2Zoesg5RylxXbpa2At1eGDGKl31RyLFqeQaNkkeYFJ2Y8hNx79axeH/KHH3UwNCjbOlEuWe3FdIOUubLN8YZOq2TuCWoGGIQp37rWQyI5vVBma5TSCzOirMBPNH7s7Ox0AqobBtVajWqtxjyQZzm+7/P2zQHdIKVhFuiYLJc1pGUxSiSLNYcvPj23N35zOgUVbA1VF2/qyjKp7unUHJ1ulOGY+n1JOKpAVmvhJMtxbAu3pASbrbF49OOIJy2Sul+89tprf2bvtRPPvFNe51FiZ44LgoDz588DTNUEHjWe5ATwg25OUopY1IcUpZSNRNJOTFYHCa8cbfDcwQbmtACTUwIIKPb+zW5MfaxlWZ4tMxvn3BABumXy3ME6B5ueWtvufmMKIUjHjhkVV9klllwLzzZYrjmsD2JmyvefnhVCkOQFYZzhOha6lNRcm2FccJ/NM0Uh6YUZ235KL8qZKVnKEcjUCVLBoaaHZxtIqZEV+V1ajFFa8EeXOnSDjE6U09OVnNOBWolBpLZF0u9w8f0NSuWS0h8slXG9EpqukReS//lBm5u9iIZn0gtSun7KIFAi1AsVkxOevotoAdzeFknJhbUeK72Y5brDTNlmO8im2L9PLVf50afmqOwonFSTenvLUwj4cCuiZJtKxUKY1DJBoVtEacH3nWhxZGY/+RpFVuwEKX6inomaZuA5Op5lMFeRtP2UsmPdE+MuJv7DUpBkEks3qNeb6JqGaxn3hRA8aEx0Tp+k0P3W1hY/8RM/wfr6OvV6nU9/+tP87u/+7vd+Afi4Vr53xiQ53vnjSdOUd999l9Fo9MAF2V7xIMlxoiP4IKSSndFLlH1a1VWF1rwZw2KVbV+Jau5kpmVZxtWr1yiKnLNnz+K6Dqvro9t2R5qGo2vMVRwC31dq92OP2P0iyQTDOGd1oGQBypa6JrmAetnEuMf0LEoLLrdD+gn010fUPZvZsslcxaYTJCzXXZZnGhhGCw2IxysN3/dZW12jHWRcHFoMMo2skKwPBO0gZaZkYZkGR1se82Vrl6yDaejohgYSemHG16/2EEJycq7Eaj8hynJWkoxcSF48VOfsgpo23bl6njyU310fIYRkueEyW3HoRRn9MENIyWcON5gRnbvu0Z1TuLVBzCgRLNQddDSWGh6zFZtRrN7rqaXavtga0zJpNBs4XYnn5NQqFnmWkecFepFiCUkQFnQ6XSrVCo5t75vkpJREaUE3SCg7FrYxJglJqJdsDE2frv33ik6Qc2uohFVHcU5jZo5SUuCaOmkhefUxTP/g8QlB+77P5cuXp/997do1zp07R6vV4vDhw/ziL/4iq6ur/If/8B8A+Pt//+8/8nveLx4Hnnm/mKyA19fXee+99zhw4ABnzpx5bLp9T6oAjDLJpl9gxxvYJZvnThykdOUqS+Ua3TDj+GyFyj2akyQTZHmOM8aYGbpOs+wQejqRpu8ib0h5988jF4IwV/d1mgkaZQdDU/nA0HVKzr1xZ9c7IZuhZCPMGWUBdc9iuaZyu65JFmrulGxRjPHJk2supeSb13tc3PCRcmKZJqj4KY2SiWcZnJkvk40LL13Tx3p62pQw991bA660Qw40PRxLpx8X9KOMKC04u1ThB062WKq7ZKkio438EdvbbYSQ1KoVOoXLrW7EfNXBMjRmyg69MGUQ5bTKNl84XaO/Ge4+6TsmoNe6EbZlYFsmpiEoOQZpPp6AzpbuKfwsgTgrSLJsWmhruk7J1nA9l41+uO9rd4apa6SFIPILqk5BxbXQkGRCYlkGFdfcl2QIanCyEur0w1yRPWwTWTdZLhRevVW2eWrx0TcTfxZC9//u3/27Pf/9e7oA3Dn1e9R1yJ2x0ytzgrXbufJ94403HtpDc3L8e00YV1ZW+OCDD6bWcR/n3AoJo6Sg7ae4esFwNMJzTLysGGspqfB9n6tXr1GtVjh8+KRiPSUFG8OYm72IbpgyV3FplS2KoiAtJAs1D9MwKDRBlsm7pjgfbvi8tzFiGOVsBykVx6ZVMmh6FllecKRZQ4wnbuaYxl8UAqmNk9u1Ple6MQ0HEt1gEOcMopRumHGw4fHpA7VdEzfTMGi1GszMtBBC8D/eXScZ+iyWBZ6WM0g1ogy2R4I3jjd540TrtmvGuKPPimK65lkdJISZZLnmIKWgtugwiBLaQcaBhsv3nWjuWTBJVFcfZwX9MKPsmOiajmvDgqkzX7FYH6bUPBMt2Ed3cHJvaBq5KAgTNWkzdYUhtK3xd3UfcE2WC/qRcjwJ0oKaZ4MQzDQbjPoRy3WbwB+xubGOphlUaxWFH6xUFX5QSr51vc87qyP8VEnOWGZGq2RiGxqGBqfnShRSTAW80Xabqo/inD+4keBnGmXHJMgEQ+FwYX3EXMXmhYM1Pn929j538oPF41oBf+c73+GHfuiHpv/98z//8wD85E/+JL/xG7/B+vo6N2/enP7/J60B+KSa252xubnJzZs3+dSnPsXCwsJjPfaTKgD7/R5+klN368wsLNLd3sAyDAxXJ8jEvYY2AHSClG0/oRfmtMomsxWXpmcR5RK3pOwuLdOgKPK7Hv1BUvCNaz26fsp2kNINc8pDpaca5wWtksXMWAjY1E10TQnxZ0WOpmms92O+ebUPQNPTCXLBej+iGyQs1V3OLlRYrju7yBY7dTlXeiGXtgLqrsVsxWZrlNENEkaJwv5934nWXdJceVEoQtaY9HK9G1P3bMq2TqnpMZOqAiZMBJ890mBpvB2ybItmqzm1q4vjhJE/YuNGnzBM8GWI7Ti4ls3Buk3dNbENnZpjMLjPRZASkiwnSjXcMWbZtU1MM3+ge3wYZYRpQS/MqDgmJV1QsiBMM1zbZL42cSa6G14Ditz2397dZBTn4+PolKyUuaqNnwiOtDzmKxZSCrX2H9/LeS6YmBt9+8aQdzrg2jpZISjMMjf6CZ1QQQP+5meW7yv8/CDh+/4TnwDuF9+TBeDjxsLsFZN9+2QKeO3aNa5cufLQK987Y7/kmOc577//Pu12mxdffJGZmZmPddwPNkZc7BTcGAracRsj6tI0lGZekhUsNdSPu9vpsLKywsLSEvNz82iaEvT8xrUuK70IzzLohxmDKKc2MimZULHgUNOZJhS1ypuIc+a0RxnvrI0wdY2nlyrc6seM4pybvRQkvHC4xrGxptNOzUCQGJpBO8xYGya0PJO40Kg0K/RCZYhedkx+6PQMzTvWx6rwkkBBkhV0ooK5epmaa9FoCNIkIYxStvwURlvcutabCi5XKhX08XXWFFyQKMuRohg3FTqGLmmVHYTUlKH6AyS2OBf4cU6SF0pbSodcqmK14lok/v6HGcU5F9aG9IKM7VFKyTGZKVs0PZNBmHJmoULVNceq9opBvbNDLQrJ/3hvmw82FXNsGOeMEoEpNRIjpVFyeO30Akt1F1EIhR+MQnrjdbpl2fiaxx/fSDANg4MNl20/I8kLNocFCzWHHzjVmgo/7xLw5jZW54ONAYNYMle1sB2LwqqS2h6DuODZpQq/+GMnp+zNR41JgnzU+MEf/MF7Fte/8Ru/8cjv8aDxOPHMe4Xv+2xtbQFq5fskyDOPuwAUQvD2u+/ze++t00kM1nuwGW0geussN5SzUNVVVpHGdN0odm0rrrQD3rreVw2LhM2h8tCdrTgkBZyqW3iWRpYXU1awbkxE8gUX1oas9WOOz5YoOwa9sKAfpcSZ4NMHqrx8pDHVDdztTqRwZ9d6iSoUPR3Ldsh1m16QMkqU1eQrRxp7eg5PcuXWUGF4K66NRHCwYbJQtegEGQ3P2ld3cHL7xJkipk2UIQzDoOYZlF3BWj/any2rqema6zrURyai3SFEQ+SSLPXJ8wK/MDnQdImiaP+LKCXvrQesDxLWh8q1pOKaLNUcskJi63Cg4UyVBSaC2zs/1/VOyO9c2FbqBkLSCTN6UlK1dTw359nlKjMlY4czkZLnmpLckHzlgzYrvZgDdZd2kOCnglFSkIqEZxYr/PjTc9PfnJKvEdPv0TTUs/T8eoChSearDs2yjVafZ5CCqcHf/9wRPneytf/38DHik7S6/J4rAIUQJEnCN7/5TV588cWp3+3jjskEMIoi3nnnHYIg4JVXXqFef3DNsvsd/87k6Ps+586dw7IsXn/99Y99bhuDmN97fwsJnJ112QwE1zfbrGoahxouJ+crLNcsrl27xmjkc/zECVUE6bpya9gesdqPOdBwWay7tIOM9jBmFBcszTkcrOjUvd0F2E4c23aQkuRwsOFQiIKzCzWGseq2DzQcnj+4z3c3FuYcRMpSqF7SiTWoOBYl26ThZmRC3MOveMfnyQV+UaADZdfCcVxsxyMxYk6caDBrF/h+wPr6BmmaUiqVyLOMOE4wnIzNoWIF9qOcVtlhpqRWxHGWc6BRxTKNu9w2JjGMMn7vYpt+qKzi+lGOZ6Us1W2iVLBUd1mq2lzbVkr0ljmWFhiDmoWQ/N7Fba53ImYrNp0gI0iUvdXANTnc8nj1aOMuoeadpuqXt4Zcage0yhZzFZt2qDCZcQo1x+AvPTs/7fB1Q6daq1KtVWFhgSIvCAKfr3zYIUxyalaCqRss1yyywmQQF5yaK/Pqsf2Z7hOszpafgCYxDR1DM5mbm8WybdYHMaahP7bib+IU8klgAJ9ETFa+V69eJcsyTpw48diLv7W1Nd577z2q1SqlUumJMacfZwEYxzFvv/02317PGFozHKh0oeJx+fot+oOAXpRyfLbMs0s1LFPbRW7RdA1jrNX2wYaPrsGpuQqz5Yy2n9ENU/w456mGzum5Hd/FeEMw0QZNioK1YUazbGObBoeaHrPlAj+x8ZOcTx2oMbOH5y3cbnjbI0VC01Ml7VIr2TRck7VhTN017+3pPT5SlBX0wpiybWLoyiHDNApsU9/be3nS1EjJ9iilH2b0woy6pxQZ6p7JKMkp2yZzFQfLMBVx485rJyVv3xpyfmWIn+T0I4ljmbQ8l0rJwE4yDlc0tre3ybKcG9euje+xMq7ngqZxpR3xhx+10TWoOwajTNL2lQTLYs3hhUN1DjbcfZQFFO7861d6hFnBkZbHKC7G4tEJYS74/iMN3ji+e0uzU54LJP2o4NYgpV5ycEzJwWaJMMkIUkEuJJ8/O3vXoOH2PaFW2W0/IcoKXEOt6uuVKvWZKstCsjbWJXxc8UmR3OB7qADcKX8ghGA0Gj1Rva/JVPGtt96i2Wzy+uuvP9LK9864Mzmur69z4cIFDh8+zKlTpx4Kh3Npy2cYZSxWLUqeTUnzMWfLbPsph1olnllwuXr5EoZh8tRTZ6fnMxFGbfsxtqFhmSamFByouyxUbDaGMfMVk0p+7/fPckFe5CS5McawCJplm7yQanp2nwiSgmGUEcQSLZM0sxzT0IhzQa1kU3IsEGIqU7Iz0lzw5o0B7SCjE6Rs2SZ11+RAw1FTTMdgue5RdqzxulgSRTG+77O+vs7qxhbfvbBNJzUwNBjFSoKlPdKoexZzVYfT8yWyfIKNVKtPfYz9yYuCb13rszqIOTrjse0b9MOcUZKTdQWfPlDjh0/PYhgKUyKRt4+FIlrc6MesDhJmyiaOadLwbPpxxiDKqHkmf+XTC9S8u+/BnabqK/0YIcGzLSSSxarOjKez2hnRKtscuge70DANavU6hhPjOpJaSckE5XmOLjK0oqA/GNDeNqlUKne5t+wMKSVpAb0oZ9arYY7vtayQzO3zkHzYCILgsZAWPunYufLNsowwDB9r8ZfnORcvXmRra4vnn3+e0WjEcDh8bMe/Mx5XAdjpdDh37hylxhyy5rEkC7pxl0PLFZK2pKJ7aMCLh+ss1u5umqWQ5CgJo1Gc0So76LrBTEVJE8WZyzDOaHk598q6hVDfIYZOIdRatuTquLZFVkT3pTQp3FrBSi/CpaClSzypLNg0TUm5GLp+txf3OFZ6MRfWfdp+SttX086Fqk3FMYmznKOt2nTSONnKTIefmsaHWwFfu9yd7gs6YU4/ymiVFInlhYM1yo4xFX7eCdMRQrI+SnjzZh/T0Dg1V2ZjpBw7NoY5S3WX7zs5y0uH64xGI9bX1qnWaoxGPusbm+iaRrVa4c11SZLnLNdLzFRs5ZAUKT3C5w/W9obY7MAP9sOMzrh4NUyDekmn5poMRjmjDA43vdvOLXuFphGlOXmRUzJNNAw0zaDi6jimoBPEZMW9ITYAlqGT5YIgBz1MaczXp9fYNnUae+Tph41PMr99TxSAd2JhDMN4JK/eB3m/q1evIqXkwIEDnD59+rF34RMJhp3SC8899xzz8/MPfcxhlGOZOlqqqUSVhiw3S4pVlidc/miF2dkZlpcP7EkiyHJBN8ww9Yha2cFEYBoaumHg2gZk+/8wJoLBa4NYkS4qDnNlC8dUHeuzjSqmrrq4Yuw7uTPeWxvx9q0BYSoI0hyERt4OmCvbpIXgxIyLlEqz0BiLNQshp5iMc7eGXFgfMV+x0DTJMJGsD2OGccax2RIvH23g2oZipo0LWdu2mZ+bpd/rkmhVwm7AQlXda71Y4qc5QaJxsG7x+dNNGqXdcjM7VzxhKrjVT2iUbCzT4EDdZaasDOqDRPDKkQatyvj1dyDLJwbtij0tcU1TgZodHdfWqdiKaezcy3R4HLoGaVbgJymlsdyNMi5X4PY9JwQ7IkgKRmk+Zcg1Sg51x8HVHPw85tBMiSgM2NxUSb1cVe4tlUpFyfFIydcud3lndURSwLafE7omWS/CNnVcS+cHTn08WMP9YmKT9Oc5JkXfZOVrmuZjzW+j0Yjz589jWRZvvPEGrusShuETbaIf1e98koevXr3KU089hV6Z5WvfuknLNeggGfa7zFUUw78XZjj3kcmQQhKlgs1ckdPqnq1+CzrYloWp7Q/4F0Ky0ovYHCX0o5yGZzJbsZmt2AyinLJjMFtRuDMppJpg7fiZ+XHOH13uqqIpKejlgn4akwhVrMxWbBarFoUQ0yJuImklxpqHX7vcJUwKDjVdtvyMfpQyiDIW6zZPLVQ5vVC+A1qjIBmmYSKlxrlbQ6SEYzMlhiVVSA3CjCgT/NDpmbskT3YdS0pu9WKSQmOpZiElnPJsRlFKO0g51HT5zJHG9G91Q6c1M0NrZgakJIoihqMRm4MuRZrTJ8W2bMq2Ra1hszXKKdnmAwk/F4UkEBm6JnFME3TQDB1TaNzHfAWkYlCP4oL2KKPiqiagbBuMkpyKa7JQc8cY0LufU6AcWP7r+XWCTBBnkiTUSLspB+rKIvTFgzVO3MMC8OPGX+gJ4H52bk+qAJw4bURRhGVZzM/PPxHw5SQ5futb30JK+cjSC4MoY2MU887KAFekuHmXmqNwD4NRQCWNef6ZY9Rr9buSnBDwzupA6TqNEjp+Qs1NONhwMAwNU5PMV2xGwW2f4Pz2TJ0gKfiTK13afkrds+iHGTc7Idsjg9myzYGGy5GWd7tgkrdN1aWUdPyEd1ZHmIbOM0sVbvVCtgchHT/F0jW+70TrtpL6eC0zURfQdWUNd7UTq6TumFQ9i0GUM4pzCil5/ViTo3tJAmiq8MoLwVaSYxomzZqLkJIZIUnShI1BjF3EbFy/zMDzxthBtTrTdhTR+ZhMoms6CA0MA8/WsU2TNIuna6Tx6e8pgZIUSntwpS+ouCYVW+nxJbmgVXHwHBNZ7D0BBYWNeW/dpx/lDOIczzZZqFjoY6mbk3MldE1Z32na3abqYVLwX95e41YvRgP8JCdICrqWknxZrHu8cnKRmmcihSQMA6Iwot/vsra2imma9KXH164n2IZBy4FQcxCGza1+zNGWx0++fpAX9vEOfphI05Qsy/7cFoB34pknOe5x5TcpJaurq1y8eJEjR45w8uTJ6XbhUQu0+8WjTACzLOOdd97B931eeeUVarUa51YG3OxFvB+l4OcE8TauqRMkOWXHolraX/i5E2R850afTpAwinMqrkXTS1mue3TClKOtEmUUztcwjLGd422J/Pc3fM7dGlC2TaJM0IsK+lFIJ0iZKTu8cKiKbd6eVGmaNp7EQV4ILm74rPdjjs14tMoWt9o+US5ZGcS8cKDG6ydaOOOG7c4iztB1Vvopw6RguapY+82yyyBM6QQphxseP3hqZs/1sUCS5TnDVCkz1Es2um7QKOtUXZO84dILMxZqzv6uHeqESHMxZiWb442OoFZ2SAq5y079rvymaXilErrl4pVi+lmCKXUQkAUBWVYQS4si9olCBdvR96jk0lzwretKdNlPc2zLoG4bLNRshlFOq+SwVHOmnsNC7HYmAnh7ZchXPuyooZIQdEPUhsg1cEyD1461cExtup3RNX0q51KMN2X/4+IW64OE+bIyOaBSYxDlZEXED55q8dM/cH8nsI8TYRj+xSsA7yd/YBjGNGk+ruh2u5w/f37qtPH1r3/9iSXIfr+PEIJarcbZs2cfSeRxEGX8f8+tc3lLKbvfGqTEnTZzNRcRB5RNycvPnKBWKyv9OmPyA1GThxu9kPfXRzQ9E3u+wsYooR9ljJKME3Nlnj9YZ66iM9yQ0+9DCKWpZxoGt/qqWDtQdxFAPyro+DHDuGC57vC5E62p5y1wl6n65iglygUHGh5SCo60SjhFhOZ61FyTTx+o7r9qRBKmOXGWUXVM0MA2TGarinm8OUruvRKYHEdKgiSjG2hUXSV87LoebqpzaKnC2UMV/EBJInRu3EBIMRWiLpfLrPYyekHGMMmpOCYzFZuWZ06nA4tj9rSUUhmI33E+51YGfPNajyhTkgx2WFCxNRolZS317GJ5/DBVhBlN32291vFTfufCNkGqxKIHUa5WK0lG0zM5WIVnlqp3TS4n+EE0uLDWZ7WfMF+1mS3bdKOCYZSS5IKT82X+yqcXp6bomq5RrlQoVyrMzs9R5AV+EHD+gw5RlmPJDNcULM030UounbDg1WNN/tdnHy/TdKKS/0klyEeJnZAWYBfs43Hkt52EshdeeIHZ2d2s6ye5RYGHLwCHwyFvv/32VP7Ksiy+da3LH37YVtIncU57c8iWJaeFy6k5F1NjLPys7SJJ5ULw1o0e20HKmYUqK/2IQZRzqxcRpgVPL9V4/lCdzZU+RSGmXuigpudZobRBXdtg0bNoli16QUYnTJFS45UjDY7P7oZW7CziikJyoxdTLdmYpkGzpEFFQ+gWfmFwdqlC6x7aqMVY2F5jnDd0DU/XcGsOGhLL1O+LHdQ1SAtBZ5RQ80xKjommKStN0zSw7zM6G0QZa4OYrVFCP8xolh1myiamIUnygsOt+lTYHu7eMvhxzm+/t8W2n+EnBUGiVqVzFY/MFMy7GnN2wfXr1xGFoFqrTPGDjqOgJl+73OXtW0MaJVP5MOew5af4aU7L1vns4TK2ZewaEExs9DRdI0xy/vRKF6TkSMujHykCT5gqbce/9OwsLxza3ZxOnKEm0Qly1gZq0KEVKQs1h9nD8wzjnKyQ/O3XDjG/lz/7I4Tv+3/xCkBN08Y/xL2FnR/nikRKyZUrV7h27Rpnzpzh0KFD0y78ca9IpJRcvnyZ69evA/D0008/crfw7uqAa52AZ5ZrHJ0p8UdvrbMmC1bbQ87O2vzo88eZGd+UmjbB/DH979V+gq7rVF2LigvNsj3tLs8sVHhqqUoY7mZ2RVFEv9+nWq3Q8WNMQ7mA6BLmqgatksHmSP1QSvcRDJZSkuYFQZwpooeUOIaG5doY+v3xGH6iJl4bg4RG2aJVsihZBkGS49kGzZISfs52UPh3vDmX+wVXgoTuGBxddpJxJ6mha5LDTQfLtpjzZpibm6UQgjAM8UcjBoMBf/rhGh8MdAQ6mtQYxAWjJKTjmDQ8i5cO13EtbTodkFIl3QnYenuU8I2xNMSpuRJrw5QgyelFAsPQ+aFTrdt2aWPCzGQAO0lwH22HjNKChYqFpmk0Sw6jKGWY5BxtOjxXK/YUp92JH7zeCceSMyZSCBaqOvMVk61RykLVuedDyjAN6vUahhXgWjmVkkUURzheiSKL0HLJ+uYWN29aNJtNKpXKY+mSJz6ZnxRL7lHjzs3GJB41vw2HQ86dO4fruvsSyp5EfnvU46+srHDx4sVd8leDKONb13t4tsHrx1tc3tD56rURgXQZRgY/eGaGE3O7H5A7Nee6QUY3ylmouUrCaKHKIEzpBRm2qfPa8RZlx2BrLEUFt71pi0JMRdhbJRtd16l5Cne3WHfohbnCe93nXs7zgqQQeAY4toVh6Hi2SZrq95V1SjLBIMrYGqVEmaBZcmi4yroxFZL56kTyZO+V5TDJeWdbKLJLIvBsg7prslR36AYph5tqKrmfsH2YFHz5/W3W+gmerfLqWj+k4+s0ShbLdZezi+VpwTtRiDCN2yS3N28MuNWNONhwqDoG7TAnSnM2hgmfOlDlR87OKe2/sdyM7/sMBkNW19YxDQPTq/DuaoZnadQ8RVwZxgWjOEfXNV5dEhxp3l14TW30BKz2I4K0oFl20HSdZlmn4RnEmSDKCg403PvmpCgryHOBZxoIoFSpU3GU/M12oK7P444gCD62Gsjjik90BXyvqdjj6l53rnxfffVVarXbHcDjXpEkScL58+dJkoSXXnqJb3/72wghHtni5Wo7pOIo8/KSpVHJByy5GWmlxAsnl6fF334RJhmaFEipnCU8Hdy6QSbk2ONR5bdJoup2e9y4eYOSV2Jre5sbHVgNDNI0ZaZWpmSP17ug/Dg1bV/h526Q8dGmz9YoYXuUUCs5zLoauZAkccrzB2tjHabdmL9JXGuHfO1ylyRT69MgE3T8lLmKjdTgU0s1SrZOLtTrLENp1k3wHTe7MR/0JGVP53DDZStQosV+knOo4fHSkbqyZRqviydR8jxqlQrxbMHXtm5R9lJKhmQUpQySgqjQyTLJq6dqPH9g93pSJUUxBVvf7EZEmWSx7oAQHJ8rEyY5vSClWbbuybqdJLhukGIg0XWl1lx2NDxbR/cTdJ29raHuCF2DOM8JEx1vrAeo68qpXTGW740f9OMcP82n+oOVahWvpFjmAxHyzHKVXq/HtWvX0HWdZrNJq9Wi2Ww+NBN1ApB+XOLFf5YxaTL3iofNb1JKbt26xYcffsixY8fuySL+XloBF0XBxYsX2dzcvGtauTlUU6cTc2VFJtBilkuC6kwVTdM41Crf03UhzQvSLEeTJmjK9rJZdrENg2SHQ8h+RVwhJH6SE6UFNc+i7ppomiI0uZaJa+tIwd3NJaoYurgxYjtI2RqlVBzlFewhiOOMsuuxVPMwp1qau4u4NBf84aU2V9shhZBsDBO6QUbdMynbBnXX4tiMd1vyZNf6U6kLfOumz1YkONwqszFI8DPB5jAhzHLOzFd4/XhLDVx2CNsrmI46zytttb5erLsgHXpJQc+PCRJVNH3x6fldeneT58TkM+WF4EonouIq9vRMWaPhWWM2c642TBPh54ncjOcyOzc7hZpc2xwQxjGOVuDnCaZlUbMtqrZNLy7UdPQ+zhuGplEI8OOJw5SBpuugg27IHc4x+8QYixmkOd0wxbN0Ds6oxrMfKRmeI/cg2T1s/IXGAO4Xj2NF0ul0eOedd2i1WrzwwgtTweed7/G4EuTO9fKLL744/ffHUQAmmVCrTl1j48ZlojCkVi6R2dWpvdh+sTVK6AQpl7cCtvyUuapHq2wgComuQausDLl1w0BKwcrqKu3tNseOHsV2PN68OWDEgCCPGbZDVroBM56Ba1u4js1ixVRr58mUQ6IsljSNKC342uUO237KXMWh4ye0RzG9kaSkw9NzShj1TsyfoetoumJcfefmgEwoy7T2KKET5YxiJYL8+TMzvHCoset8d8un6FztxhRo1D0T27KoVxxGYUo3yDi7WOGVI/V9hZ+zsRyAnxY0qx62aVCtSubzjChRbORo0Ob99zenQsuVSuWuQqqQEiEV3EEDDB3KtkmaK7PxPe0IdkRRSNJc0I9zhIypeBZlS/19XkhaJRvTyO6pav/u6oirnUgxl+MCzzZUES0lpgbHZ7zbgrQShNxt0B4mBf/prXVW+hG6phFmkpwq728E1DyD43Nl/tqrJ5kp28qreTik1+uxvr7Ohx9+iOu6uwrCB2Xc/1nYJH0S8TC5J89zLly4QK/XeyAN0Se9AtY07YEKwDAMOXfuHJqm7alJKKRkGOWs9iPqrkm320XXwLYMNDT0e/Bvs1zlxo1hwsYgYabiMFuxqDgmwzhjvuYooXQmuLXdv4+NYcI3r/cZRup34To5dcdgsWYzSnLOLFRUwztmzDKWKpn8zi5u+Hz7xoCKbZK4giAV3OhFOBQs1AxeXq5ScY3dsIwdRdyV7RHXOxELNYeZis3mKFPTyzBjoerwg6dauybzd64/O0HGdlBQd3QqtsnJBYvhWN/V0OELZ2d3kdt2XDwKMXEmitCN25jGWVNj1iuzOUqoOeYUFnI7duc3AVPt2EIon2JdV01lkO49tZx+jDHUpJmbYET4QiCEhpsL0jQgTAs0w8LTIU8zpJB7FoJBUvDtG+o6bvsC2zJpODozZYtBmHFspsRM2VJbH13fU+rrrVtDfv9iW+F2hSTQy1wfCYYioOIY/OVPzT8W4ec745OUufqeLQAfZUWycw179uxZDh48uOcD5HGsSHb6Bu9cL0+O+yjHzwrBH3y4zUdbPu+vDXjv2gZFb5PlSokgg1pJY66i1ha6riEFY4kB9fqtUcLXLncIkgLX0ukGyrKsUbKouSZHZ0vMVWzyieMKkmA04tlnnsYwTN5fH3BpO2Cp6dGoOGwMUwZRynYsOGhJlsyAzRuX8MdYuWq1ovAcqEJidRCy7Wcs1pSRdqvi0PMTukFCwyz4/A4z7+n3iVTJUkB7lDCIcmaqal270CgxUykIkpwkF5yYq9zTk7OQglGkJmegEodn6Hg1l6QQWKZ239WOrkGaS7ZHCRXboOqaaLqBYelUyxbPnFnC1TKFHxyN2NhYRwjJ1tamshG0PG52I6VHFmTUPZuZsolrSoKk4MzhGqZpTj0075SIyAvJl9/f4sNNnyQTrCcxdpBR9wwsXafqmJxoWsiQsaq96uqlkOSFmopea4f83sVtBFAvmfiJWq0ESc5cxeblMcbpTv3BnQbt51Z7rI19UFslCHSPEQZxLnh1scH/+wvHmSmP7a50nUajQaPR4NixY+R5Tr/fn04HL1y4QLVanRaE9Xp93ybpkxRJfdS4V9FqmubHanAHgwHnz5/H8zxef/318e/s3vGkV8C6rt/3HLa3t3nnnXdYWlri7Nmzd01yb3ZDvvrhNiu9kA83fUoywE0DcgG9IOGZpRqOqd0Wft7h/CAEvHmzz6VNn7Jt0g1TVvoRbT9hpmxR96xxg7lbsNkyDHKhBJO/c7NPkBScXayw2o8YRAWbo4RcCF44WOe5MXN2L/at0DQ+2o6wTY1WyaZZsujHarKfJILnFlyeWb77wb6ziFvtJ1iGgWObOEJyfMYkrtlsDBOOznhTYf+9QgJBkpMWgoqu8psigGg4Y4jMPRw9dxxH4scFXTOh6tqYmmpIJcbYPm132byrX5WSq+2QQZTTDpQyQbNkMVu28NMC19Q4UL89AZ1MLXfdA52I335vizAtCNOCka7hmjozZQ9pFZxuWVjaiI2tTba2t6hWq9SqVbxSaWqf+t8vbHJ5K6RVtuiGGWlesJWpTc+RGY8fPjMzLnrl9H6YwGvQFH7wa5c6IOFQ02OUFIRunVhAJgR/7/uO86NPPR5nozvjL6wQ9L0S5MN2r5M1bBzHfPazn71nZf2oK5Isy3j33XcZDod3+QZPzu1REvDbtwZ842qXGVcwo0dspyF+bnC5l3OwavDsco1GydqF+QP13ekafLQZECQ5x2ZKLNQcOkFG24/xk5yXDtd58XATy9AIw4hrV68hBZw8dRrDUKudlX6CZZqUHQvHVOuRIHbYGqW8fKLJpw9USZKE0eh28WMYJtVqhWq1Rs+fyLooIkLD1anaGq4JxOldxd+dIaWyNhqGCRXHwjaVZZojNQqZo2n3zm6TImc7kuS9mNmaTt0xxrpcGrMVJQews6PfGd0g4w8+6tAf2xI5liq4Fms2vTDn5GyJZslA00xq1QpyUZJlBe+9dwHDMFnf3OYPbyR0UgNHhzCH7VFCL1TYyaWazQsH67vwODttoYQQfLAx4v11f1q0b/kZYZrTDTKOzpb48afnaJkJnUjb1dWDWlmZusG76z5JJpmvWUipLLH8OCNIcj59oMbnx8nxzthp0H6tHaKP8YMgWVicZzjyCTSbQ01vT322SZimyezs7HTtlyQJvV6PXq/HxYsXybKMer0+LQir1er09+P7vmJkP4YJ4P/xf/wf/Mt/+S/Z2Njgueee49/8m3/DK6+8su/f/9qv/Ro/93M/90jvOWHC3xmT/Ha/tbuUkps3b/LRRx99bNvIJ70CNgwFC9krdjbhzzzzDMvLy3f9TZDk/M67m2z7Ga8cbfLBxpDLl9skSYYr4DMHHc4sVKeFwyQmq/WNQcS1dsBM2Wa5YdANMrb9mF6QYRg6b5yYYXlHAaXpCqc7KeTaQcYgEczVHHQkx+eqBImSTjEMjVeO1qfM3TtDIBmGGUGSUrKUE4XnWLiWwVzZ5Mp6imfd/zpJqUhufqxTdhQsw3MsLCPH2GvnvPvFDKKcYVzQyQWhHtPyTDzLJEhyqp5Js+xg6tp0K3Pn6799Y8CHmwGDKGMY53h2ykLVRtfA0uHI2Hbu9oZnUoCrY72/HvD7H24DYOsaQSYI+zG9MKNZsvjMkTrNsjmdgKoNiHoeSClJ0pw/+KjNKM45NuuxPRaNjrKCTpDyuZNNfvDULNevfMTy8gFM02A08ul0ewS3VrAsi9Qsc60dU3MMPMek5lqMkgw/znEsg//7C8t7Cj9P8YOM8YOZoFmy0XSNuVYN03NIhEauWZyaf3JbiL+QJJD7xcMUgO12m3feeYfZ2VlefPHFu1a+e73HwxZog8GAc+fOTZlsk05kEpqmPTRLDhQu5dytAWngUyR9Xj4xz5Wb6/ScMlt9n2NNkxNzd3cN2jhZxoVk24+pOha6oVPWdUqWwYGGy1o/YqHmqqngGO83NzvL5ubWjpWyRpLlCFGQ5QWmqWOg0SzbBFkxtU1zXBfHVXgOUSjyxGg0ZH1jgysbKesjnSiOaVVK1EsWugaZgKat70/cQI30310d0Q5S4l5B2bWYLZvMVdUq+XDTm5I/NE2/S/JkGOV8+f0t1oYJUipR1EHsU/csPEtnse5ypOnclgNAG+Phbq8z/vCjNmuDhKMtj42hshNq+ylxXvDMYpXvO9kad8q3J2faeMWwvLTI5V5KeGuThRoIkSvbtrggKTTqtsEXzzZplnbfo3dO4S6PCy/PNhFCcHTGIs5y2n7Kmfkyx+dKdDvxvskpFwXtUcLYjhPN0CnpkpJps4kSPL3fFBRU0k6zgijNqNdqGIaSitDQsO/rbrA7HMdhcXGRxcVF5FhDrNvt0uv1pl68zWaTa9eucfny5cfSHf+n//Sf+Pmf/3l+/dd/nVdffZVf+7Vf48d+7Mf48MMP99Tm/NKXvsQv/MIvPHIBuF/stKLcb/qZZRkXLlyg3+/zmc98hmZzf6zofu/xpCeAex0/TVPOnz9PFEX3bMKvdUI2RzHHZhXGTyY+zLi0fQ0Zhrx6tLEnwWwirdPzEwohp4zX+Zpa+fXDFMvQ72pK7oRIJElKkmRknoGla5g6VDwlNZOk95+e5YVQYvJ+SsPLaZYcLEMjySX2WFppX1iGlHy0FXCtG7I+UJZpNc9iqe4ABYYuWarbY5kSHYm4yzLtrZsD3rw5mDJm1/oJXT+lWbKwDZ1nl6poCHKhzn7itiHGOoZX2hFv3ujjWTqHmi5tPydMCq6nEQcbLq8fb3K46U590G9/j4o9rWs6310ZICUcaLjMVmx6Uc4gVE3BGyeafObwbneondaeABujhE5Y0KzYGIbGUt1lplTgpyqfv3y4iWPpY1UKHa9UwiuVmF+Yn1pdvrvSJYozzCKhyE0s06JmG7imTlLsB4rZHcZ4a+fHGSXboFVvEqcpoKli+GPmuAcNKeVf3AngveLjYACFEFy5coXr16/z1FNPceDAgQeq1h+myJRSsrKywgcffHDfjvxRCsAoSbl6c4U8TXjqxFGiKKJsa5SaHmEYYj0AoHXCLiuEoF5y0KRaE5imAsjeWlmh0+5w7OgxSqUSm5tb0/H+rV7Etp9yrRuxNUqZrdjjdbHA0DRmq85YimGsnq9p6IZOpVrBK5W5GrkM9CGZjFkb5myOBtQsqDgGlmUyXyqmxA3T0NFQ43khlTfz1y53uNqOWKqpiWOYFlyPlf3a0ZY3TSyKuDGW2UDDMHWkhAvrXTaGCYcaHnYRE+suo1gVYafm6/zwHetngUTs0DFsBxmbvvIQtXU4Pl9mFKnu1NA1fvSp2T1dO0Ddj3lRsD1UdmnlkoemaVSrkKUpHT9BFwXbq9fpruuUK0psuVqtTB01JpHlSky8KMS0OPccCzsuxomUMZN+nwKwUK4kvTCjKCQVz8YxJEKqJmWm4mDqxt4TgnFcWFM4pWGiViq+PYOeFAS5huVqvDwRiH2I0DSNUqlEqVTi4MGDKgn7Pt1uly996Ut8+ctfxrIs/s7f+Tt8/vOf5wtf+AJzc3Mf+31+9Vd/lb/7d/8uP/VTPwXAr//6r/Pbv/3b/Pt//+/5hV/4hbv+/utf/zpvvPHGQ5/X/WLSnOZ5vmcB2O/3OX/+PJVKhTfeeOOuBvNBwhjLEk1kth537JXfBoMBb7/9NvV6nddff/2eTXicFUjUGk5KyWjQY67mYhga7Rjup+6UCaV9tzGIqbkmrjVeE2sajm2NfxO3H/+TCZaUsLKxyZsfrHGrBzc7Ps2ypZjwVY/eWPi46tp7EjdAEVf++HKXUZwziDJ6Uc72SMFd4lww52rUbFX8GboqloQUU1mnm72YP7nSQ9c05qsWvahQEixBxoGGwzPLVQ41vbFMye3vWJG9NPphyvnVEbahc7zpsDmIidEJ0oI0F/zImVnOLu2YKmm7mdMacKUdUUiNWc8GJI2ywyjM6EYpzyxXefGO4m0SSupK0gsVeadsm+MmVcMxNRYrFhvDhIZr3fc5XAiJKApEoSHHnr62ZVLWNYI4UyoG7J3jJlaXjYYGekIgwREa5BlpGuOnUjGx/T6pUcN27D1z3BQ/mBTkQY5TKiEDQVkv6KeSlw4r+7onFX9hMYD3w8gkSXLfY8RxzPnz50nT9L4r3zvj465IdupuPQgI+2ELwNFoxO987S06oUZPlBGbEXlvjZIhiDOBY+mUbR1DV+DiO7/FMCn45vUu237C1ihlO0ipuzGHmh5+Iqg6OqPNW2gi49lnn8Z1XKI4BsbCsgOFHcwKScU28BPBKA7ZGqXMlS1OzVeYr1g7Eoo2LQaFkFzr+XywGTBTcWiUbTYGKcM4ZZgLaobByWpBw5B8+MGH1GpVKhWltacbOoamsennrA5TWmU1rat7Nv0xMLrmmPzoU3N7ApsFEjGe6N3sRpRtC9NU69eZqoHWdNkcJhxpeXd5Hu8KTSNMczX5dE0YT7rqJQfbUEm2uMdllVIdQ0hJlBZ0fbXCtkwN0zTRTcnSXIlnn5kjCAK10uh0uHXrFq7rTsWoB7lB28/UgyHKqI3xg1LKsdZVCcswxqDyu5+WcVbwW+c2WenFYymEhE6Y0fCUIn/Dszg5qwS8FR5GH+NX5fTfrndCfvvCFpkQVByDSBiMCoMPt0KaNvxvT8/z0j4PiocJXdep1WrUajV+8zd/k3/1r/4Vv/u7v0ur1eJf/st/Sbvd5h/8g3/wsY6ZpilvvfUWv/iLv7jrfb7whS/wjW98Y8/XvP766/zH//gfH+lcYP8V8MSK8s78sxNTfPLkSY4efXjR2ck9MZGiedyxM7/tZCc/yOcO04Ib3YgPN0as9EIaZoYMI2xDJ0xyGq4+xjbvnUMvbwe8szKkF6jfR82zmStbNDyTOC147oCLHGuiGro+nmBJhJRcu3GdP706YKhVWGigrNeCgp7vU24PmSvbLLsmQRTi2KpoMLTxClRTTjxv3ugziDLOzCvLtF6QMRgL0796tMGyKabFRiEExbhJVetrnSudiFRIlqo2M2Wb2VQwCFNGcc5TixVeO9a8u6nboVSwPowJM8Fy3SVJBE1Pp1qtMIwzNE3j2Ny9YRMSGMUppqaKOU3XcEwdp6qE6e818JrkN1PXyQpJkKYUQlBxLUUClMputORa+7KnQTWnt7oRvShjy08pOybNkknNMej7GQtV5cRijiFNe53Pe2s+v3dxmzhXha9uGLgG1D0X3Sp4dtElDgM+2t7E0HRq9RrVihpSTJyN/tu7m3y45dP0THpRjrArrPRjPENyas7h77xx+ImS0P7CW8HtFQ8yndve3ubdd99ldnaWl1566b4r373eI8uyB/pb3/c5d+4clmXtq7t1ZzxMAbi2tsbvfus9LqV1KnWXQT/iveubZMMuc1Ub1zRYrJhUzELhvcbSLobGmOZf8O7akBudiKMzJTxLqZlvjZRG1Ok5h1bex7VLHD1yAsPQp4Wcwp/pfLTpk2QFB5suCzWHbpjT8VOyQvDUYoUXDzd2J6c7usvVQaKkSlyLoig4NV/GT2y2RinPHqzy8sEyly5dYnFxkZE/YnV1lTzPKJXKVGtV2olJmhXMltVqxzU05k13LPci7ytqCiAk+GmGEyuRUAX+NjH07J6SEqAeZv1QefR2/Yx6yaLpmZQcAz9RavutiiKm5Hvco1JK3l3zeXtlyDApGMQ5jpkxWzZxTKWDeGauBJpGrVqjXlcFVBKnUzHq966u8EcrOZEwsAxIcsnmMKYf6jQ8k1PzZU7NK22uLFf3sCJtTNwJCr5zQ7m/zFZsKq5Jx89JMiXjcnq+zP/6qYUpw29iVzeJiUL+uZURSV4wW7YBDaM6S2y4DMKMFxck/683Dj3R5FgUBceOHeNf/It/Mf1uP260222KomBhYbdI9cLCAh988MGer/mbf/Nv0m63P/4HfsDYyw0kTVPeffddRqPRXZjih4mda+YnEZP8VhQF7733Hu12m5deeolWq3XP16W54P/3zjrvrgzwbIPNYczlrRXKhqBVtqm6Jk1NNdyWZU2bE1D3aNdP+e7NPhoaTy9WWBkkDKOMK2HKoZbHpw/UOT5b3qGJOilSYdDrMSxsMqfGkmdjGRqzVY9uoNQS5mo233fQwchCLn20jWlaU4JbpVJBNwy6QUI3zJmtupi6xsGGx1zFHosFC547UMPvBHue+0SDrzNKcA1tXEhp1Dydqmuw3o8pO+a9XTtQtWWaFwzCFF2K6aRRkcDknk5EO2MQKQzwSj9mEOU0yzZ1Vwkwa8DCWNh+J+lm5zmEmeSbFzYZRBmjJKcb5pTthMWawzAqWG44LFYsNO321FIid62S/+DDNt+9NcSzDPIxRMZPMiq2yUzZ4o2TLbTxs0Xl2fEam4l4dsYffLhNkguOtjy2/JQgLQgziaHn/PCZWT53oqX82YVU2q7+iO12hyC4iee5xEaJK9shFdvEswzqlRJavcUgyjFlzs9/bpHjj9H2ba/4JK0uv6cLwP1WwEIILl++zI0bN3jqqac4ePDgQ79HPJ583SvW19e5cOEChw8f5tSpUw/cTX+cAnDiGbyytoZfXqbkmDw9U+JQq8Sb72yyhfLj/eEzdeatlNAfARPh50l/CUmuCrBm2cG1dI7MmMxWMkaJTX8U0Ui7nDyq8Fe7ntuTiVWS0R4lVFxTefJqsFQ3WazarA1immX7nsxbUBp4eV6QZPlUl6/qKWPwnYmp3qhTb9TVunoHmeTKhs92T2fgh0qRvuJgmQZJLqmXLMquhTbu5u/+HiXfvTVgc5iwOUxp+ymWFBxxC/wsUdpODXdqmSalvGv9+c1rfd680QcgygvikdLha5QsXEvn+QNVpBTkBVM9LV3Txv9W0Eng3WtDdA0Oj309oyRndZCzWHX47PEmZxYU5mOn6LNh6sy0WszNtHh/tEludFks6yRZzjApCHOV+I7WTX78bHN6HSZm84q0cRtsfXEzwLFMbNPA1HUqMyZxVtAPMz61XOPAPRmGCiC9NYqxxlqBpmkz02qoyVVeYBv3JjA8jrjTJunPSg7mq1/9Kv/sn/0zfvZnf/aJvcfOHNfr9Th//jy1Wo033njjgWVy7hX7TRkfV+i6TpZlfOMb3/hYjfGlLZ+LGyOOz5Y5Plfm4o0tLnYEozjnQMPls8dbbF7bRuyAOOxstDaGCXEuOVD3KETB2ZLDIEzYGiUcbHq8crR516bP9316vS6O41BrLSL8Hq5tgoRm2aTuGrTKNrqmcfLQgpqEjzFmo9GI9fUN0jSlXC6R6h5xkuLoYDgmpqHj2srfeximt5fO+zQrUVqQFoK1QUyUCRolG89Szk2MhagNTb/Lb3gSbT/l7ZtDumHG9ijFtTSqhqRcKRhGCc8drOFY+ti5Q1KMYSCT6IcZ//3dTTaGCqvXDTP6sdqueLbBoYbL0ZZz2/aOHRahRYEUku9uZKwEOcsNh7avM0oLBmFOnAmeWijzI2fnpu4lOxvLiZzOtp/w/oZPxTEoOzZBohyS/KTAMXX+6nOLHNqhuTfBAO68D250I4apZLZioyE50CyRZjnDKMcydV471px+BiU3U6ZcKbMAiKLA933O3+oRJRlmkRIVJvXWPLWSIpK0+yO0+xFxHjHSNCXP87+YBeDDsIAnK98sy3jttdceiT1zvxXwpChbW1vjueee2xMsfr/jP0gBGMcx586doygKnnruM7z93S3mKuoB4MqEwzWDxVKNbpix1PDQk3zfSchEFNW1DKRUeL+q55BFPbIk5ODZgywt3U1nnxRmhZTEeUEvyIizgoZnY+pQSHVNPNvcQ03rdqz2Y252I1b7MZ0go1GyWazaU6HpxbpStZ8Ul2K8TpiQSdYSiw1pIPSQbqwM1Tf6AXXXQDdMnlt0EWOpG1037gJIv7/h863rfcqOoSzTkoJBCpe2Yw7PeLx6pMFMxUbI2wzXnSvsbpBwfnWIY+qcnCsrl4FAdZZCSD5/epanFncAdsfM25130WZskBawWFPYmpqnXDu6YcqJuTLfd2KfCYmmTdlyq70Iz7ZwPRvXg6oQCFGwPoixRMLVS5ewbZtqtUqWZXc1JZKxXpkQSKlWIyApORZ+XNxTm2sSRSExNI1BnCOAubmmejBK9Thpuk9enPlxMORmZ2cxDIPNzc1d/765ucni4uKer/nH//gf87f+1t96pPe9X0wKwKtXr3LlyhVOnTrFkSNHHluROyGiPakCcDgcMhwOOXr0KKdPn37gxnh9EINgyrCtEvLMco3NYcJ81WWh6rB5D03LtCjGnrUKpqBrMFNxKQqwdP2u4m+73WZlZYVyuYLrunQLyTDKQAqqrk3J0tB1jUzATMnC0HWElFOMWbWmHs5pktIdDHn/Ro/VXsK1TkjFMVio2MzXXHphQats0SrbxH2Vm5DsKuJGcc7/vNhmY5gQpAV+rOzX5io2GhpzNZuDDZtCTizv9KkigBjjur/yYZvNYcKBmsvmKCZMBb4Q5HrEybkyLxxUG4Xdmqi3XUDeWe2w6accaLjMVWzaUc4gUJ/n6aUqnz8zu4v9LNmx4ZESP5VshIJ6yR0TSEzCNGeU5BQCvjBx/dgjJnI6G4OYOC1YqLvouk7FMyg7BlEqSAuxS3tQjhuBO6eihZDIokCKsceyLrEsE1eCyMUUI71X6IZBrV5nLjLgakIowZUGhuMxGo0YphLbABENCYLGY1MiuDMmTkf/Fwv4jthLB3CiKTU/P8/TTz/9yALL92LJRVHEuXPnkFLy+uuvP9SO/kEKwG63y7lz55idneWZZ56hF+bKqSLOmas69Nvb6LqBbkhsS2DpOoK9cUVCwOZQJZRBlNMq28yULGSsVpHL8zMcXZodn7fyrJ2EpmnEBXzlw22FiRmltIOUqh1zsOkRpAWzFZuFcWE6KZikkGqKBWwNE/7oow5RXlD3LCXu2gvpBMp/9tRshSMtjzxLxqxdxubsiuXVHsW8dWuIaWg8s1xjfZTSD1OiVKeMznMzBk64xXvvb05JE5VKVYF7UWvLi5shhq50uequSZAKNjoZ0tR5+XBjquu1K3assFd7KqEu1100XWO2qiYDwzhDA47NevdkzQohibMJMUWCpmNqij2dFWL/ynlnSImuwyjOMHSouqqANg0Ty7Y5fGCWZw5W8P0Ro5GP7/sURUGWpVTG38tmBEFWsDFM6EVKf7DhGaS5wDQ0DrU8Jekynq7c+bGSTPBb5ze40Y1JMkGcZ4QlndiMkBJansHzC4/2+3uQCILgoUgfO8O2bV566SW+8pWv8Ff/6l8F1AP1K1/5Cj/zMz+z52vCMHwsuLl7PTR0Xeejjz4iz3NeeeWVKRTgccaTYAILIbh06RI3b97EdV3Onj37sV6f5IJ2kFIZxNgiIYpChfPS9XHjqibLco8H+DDKWOvH3OrF45Wtx1xJCfzGWc5SvY5pGggBWZazunqLfr/PyRMnGQz6XO4k3AgHDOKc7VFKyc2YKymx4ywvOD5TU8L2OzB/RaFWrLZt8dFAYzW2WWrabI0SgkxwtROx3g+YK5scnqsQBj55XkzXnTtdQN5ZHbE2jDnS8miWLLb9nFGUsDlMeP5gnR84NYM7Lr720h5cGSRsj/Fxhq5TL9tsD3x6QcZsxeYvPTuPY9193+50AbnaDinZ5rgR1zhgaSxV7fEE1d1D+HlHaBpxnpMXgsnb6LpGxbVxLYNOkJI9gPigrmlkQtAJUspjxi6aRi6Vm5Nn7SgAp/Z9t88rydQEdZDk9OOMsmPRKpl4lo4fZZyaK1F1FTlFTZDvnqZ+uOnz39/dJMkL0kJiGxWKUGeu4qLJnOebCVnk8+abb2JZ1lSmqtVqPRQpa6+YFID/Fwbwjtg5AdyZcJ5++mkOHDjwWN5jv+54UmguLi5y9uzZhy4071UASim5ceMGly5dmgpId4KU//buBrd6EZvDhLKeY/htDjRcOkHGUsOh7pmMMmOHovnt41/cGPLWzT62qaNriqm21hnS9AzmW3WeXa7jGLc1tQxdV0rHUk17ro00/Djh+GyJimPQDnJ6UUqch3zqQJXPHmtimfrujpDbY/3L7YhRWrBcc1ioQj8R9P0EP8k5NVfhcyfU2rLIb/8ShbxN3FgfJES55EDdBSRHZ8rEVZtOkFF1DX7keXXdoyhiNPLp9/usrq5NJ2GOV2YYJeNkopqIuglZIIl1A9s07i/8rCt5h2Gc4pkGpqGhj7tnnftja8K0ICygHaaEWUHdc2h4KnFlheRA08UyjD1Fn0Fdh6982OZWLx5rfOU4VsJi1SEtJGVT48SMh65rNJstZlozrBg6WZ5TKpUYjXzeu7nNn25ALDQMDaJMEGcKP1hzDZ5dqnGo4ZLlO22hDHRNn67E37zZ58NNn2bJpGQbDKVLgc76IOGFQzX+5jMVZvW9cU6PMx6XTdLP//zP85M/+ZN85jOf4ZVXXuHXfu3XCIJgygr+iZ/4CQ4cOMAv//IvA/CX//Jf5ld/9Vf5lV/5lUd+772i2+0SBAG1Wo3XX3/9sax894onZXeZpilPP/00165de+DXSin5+pUu37rW42Y3ZKUXoftbzHsSyyhACpbqjpp8mcZdLkd+UvDHlztsDBLKtsEwyRlt+Ww7Bo2SxWLN43DLJc+VsP2Vq1fRgGeeeRrTtLi+0eWDdkq1avPMYoVbvZhhnHKzm3Ow6fLS4Ton5tSDuJA7mjUpMQ2TdpBwvRvR8ExFWChb9MauQg3X5PMny7gi4ebNm+R5QRzHGIYxbVKLQnK9GyqxZcOgWdKpuyZxZrMdpDy9VKFV2f8+ECgrSinF2C1Jx9FhtmShFwWGDo55/ymVpkEQZziGNt7oTFxAbmMt73ERGSWCIJX0t0PqrkWjpGzrRnFOyTJZqHlKbHuPxhJgpRfz1UttRklBN8yxLYOaY9D0TII45+WjDWxTOcDohj7drkxSpRCKuHFx08c1dcKkYBjl+HFGxRnjB0/MTDHx6rXadB1cFEp78XcubBNlggMNj06QIco1hkmBoWf8jZcPcDJXRhKlUonBYEC32+XWrVu8//77VCqVaUHYaDQeukaYSMB8UlaX3/Mr4CiKOH/+PHmeP/LKd7/3mISUkkuXLnHjxo19xUs/TuxXAE4snfr9/hTsLYTkyxc2ubwd8OLhBpc2fT66cpXRKMRPcs4sVnn+YANjbCE0kQcBNRmKs4IPNkY4ptK/qpiClfaI2LIwHYfXjrXuMlQvhJgoqBBmOd1UY75u41gmBxs6TS/DT5Si+4uH6sxW7j3W3xzFeKYqTHVNZ1YXtFyd9WFCs2Ri3UfXQUhJkRdEaY5j6ui6wLUtvFxJAKhtsXaHFpTCcoxGPtdXVul0C/zCoOGZtKoeFcckExqGpdOqqK55r8ILFLbmrZtDelHGdpBSsi1mS4YquuOMFw7UcEx9X1/PMCn4P9/ZZDPUUFINGaO4oBsYeLbBfMXm7MJtU/UJ0WKnjuG51SHfvTWk6poYmkY/LojTglu9iENNjy+cnZs+JCar56wosEyL+fk5Fubn+WZnBaGPmPcgyQpGqSTKJEUheHahzI8/PXMHiUfbxVQEjffWfUxDFc2WITi0tEwqdbb9lM+fmeNkK2c4fPJJ63FJJPz1v/7X2d7e5p/8k3/CxsYGzz//PF/+8penxJCbN2/uSsL/6B/9oyey8pFScuXKFa5du0apVGJ5efmJFX/weO3ger0e586do9Vq8eKLLzIcDj/WdPHSVsBXPtym5pl85kiDiyttbvYGtPsaR2fKfOpAjeW6wn0JIcmyHCnHMlG6xq3NgM1hwsGGy/K4Kd4exfhJwdm6y/efbFF1Tfwg4OqVq1RrVY4cPjydArWjglRotCouUgjOLFoMw4RtP+Vgw91X9mQCzegFKXFW0Cy5aLpBxTUo2watkk2aC5bnZig7BkjJtWvXAXY1qaVKhThOKTSdsq2YsrqmUzYk/QeAZUgp8ROF4U1zSc2zqLlqYpoIyWzVm27O9jqSEJI3b/TZHKZs+yndMKPimixVHaIsp2TrHGm6062M8jTffax3Vkd87WZEIVVDuxVm9CKlLGCZOi8eruOY4/XzzsZyDNNJcsHvvLdJN8g51FCqDHFR0PYLslzwqQNV3jiu9C4nmOY8ywA5tSy91gu5vB1Qd00cS8ePBcNIwXSqjsFff2mZhdpupxxFvrl9Jtc7EaNU0Cwr/ODRpVmceoNumOGaOv+Plw/w5jeUp7lhGNPJHyjcXq/Xo9vt8sEHH5CmKY1GY08h+/vFJ211+T07ATRNkyzL+PrXv87CwgJPPfXUI69874yd65FJZ5skyceWk9kv9ioAfd/n7bffxnEcXnvttaml09og5npXPeRLtsHT8w5ZW6dnlTB1jdeON6fSJbq+ewWcF7nyrE0K5qsOw9GQIo54+mALadgESc5sxeFeTYYcTwFlUSCEgabplFwL1zLJhvF9N5d5IclzwZafUgholG0sHaSmRvfKUug2rufOXNcPMy5th2z7KW0/o1aymK9YlGyTIM44c6g+FjLVxmtLNdKfYDkS3ePiqiQ3IuI0Y93PafsDao4S+DxalbRcVejsLryU4GuSCb783habfjrWHkwI04ybaUYzsTg5V+Llo42xFMOddmnqi31vo8/KIKFhS6q1Ep04ZxCoSeCJ2RL/y7Pzu7QDbyvR39YxvLAeYBg6FVs9XBplCBJVSL56tMFTS3c3QFJIsDTyQlAUkrV+TMU18VwL14NKUSCLgi0/RcY+H168SKlUolJV+oOe5+3219RU4aiPLfTccgXHsXGAwZjp+KSkRe6MxymS+jM/8zP7rny/+tWv7vpv0zT5p//0nz7ye+5M7Dtdil599VWuXr36RIWa4fHZXU62FadPn+bw4cMPJXT//vqQQkjmqw5UHZLeJt58hXaQcnqhzKcP1KZTHm2c4zTtdqO60Y+wTV3BTzSNharGQtVmtR+zUHWoeRbtdodbK7dYXlpmfn5+18C/EKppyvMCw9DRpKBeskmEvK8yAKjNQJAIVntKd7DiKGHltADXMSnZ5tQnzTANXMedNqnDkc+5G102+yG9RLJiaTQ9i+WmR5RDydJYrrv7WqZJKfmTKz3OrQxICslolNAJc2qOjqsLDF3j6YWS2syMCy8lQQR5XqDpSs/z69cUPjoXJsNEMar9OOdgw+Wzx5q38dH5bQKIOZaHCtOcb1zrKru0mkksTXphSpApebIfeWqOFw7ugNjc0VhqmsbNXkwvErTGvrzH5iz8JGMYZVRdi7/y6cW7SIaKDKSNcdsFa/2QvFAaf6BR9XSqrs4oVgYFs+X7r2eTvECKAk2qyadXrWNbOhXHoBCSOCv2zXG2bbOwsMDCwsIuIftut8uNGzfQNG3qed5qte7yvt4Zn7TV5SdeAO6lkyWE4Pr16wgheOaZZx7byvfOmKxHut0u58+fp9lsPpCDyMc5/s4EubGxwYULFzh06NBdbOIkF6S5UOtLoNftMFNx8SwD/w72LGi78Hug8k6U5ny0OsTTJQfmZ7AskyArsEwD+x62RELASj9mmEFnQ4mizlcc6q7BICqo2CZzVbW6LPYQRY3Sgj+61GFtkNALMvphTnmYsFR3yIWk7pos15yxV62BZRiqGB0DpKO04Pc/2GZzmNIs2/T8dGqZNlOyOdzyeGapuluNXtOmRVxe5Hzreo9OmHFivkwvyGgHmRItzuFERfB0LeXDixfxSt4UP1gqlccSMRq3+inbQc582cIwDOqezSBK6UcZsxWVmPbC1uxk3t7oRJgGGFLHMnUWqzYLZYvNUcryWCn/XiGk6mTV2yhguqtrOIZBmof7kQrH0g3q+qpbSjJKcnRNw7MNxVA2LSxL4/jhBc7MWvi+j++P6LQ7CCmojP2cK9UK3Uiq7t5PGcQ5y+U5alJhGw1d4+xCBVF0HntDtlc8rhXwJx0Tl6KZmZlpjnmc07n94lFXwJNtRa/Xu8uN5OMWgKMkxx7ntyiKIE9YqHukhVQizrt6kN3PBSkVm7QXpFi6Rr1kY4ybS03TsE2dGzdv0e/1OHHiBLU7GvheoJrCLb8gXB0wW3WYLVmYumr+lhsulmGOmfx348UubQV883qfUZKx7Qsc26Lh6syWLcJU8OxSnYk1pWUYqpCbfE+GwUqo88FQp1mrIIKEIBWsjxTBrOFoPLfkItOAJNUxTGOMAzbGzT5ca/u8uzqi4pg0SzYbg4ThWBh/oaTz4oLFsZlxoTEuvKbfpaau1YX1AFPXaJZsaq45JqHkRJng1WNNnt8DH71THmqtH+EnSg9UN3Rark2jZBFlBUkmONLy7ilfI5GM4gwhCgxdPWN1TVOC2+MohLyrAJSMRaDHN4hpaGSF0k30bANTH7PdJZQd877FfF5Itn3FOB7GOfVqhapmYY2t9T59oErdVdfvfjluLyH70WhEt9tlY2ODjz76CNd1pwVhs9ncNfF/nFaXe8Uv//Iv81//63/lgw8+mPqI/8qv/ApnzpwBvgcKwDtjQr6YJK39WHqPI3RdJ0kS3nrrrSkO73FeiEmCnGAYb926xbPPPnvXOWWF4GY35Fon4NKWz1JFJ+12KTsKV1Ev2dRKStm+yMU0KUxic5jwJx9tstodkQqNetlDDBKWairxnV2sULZNhe+YTtDkNGG9szrgzRs9TB2krtENcvphTtMzqXsWLx9sYBvsWl3quio5sqLgvXXlFHGw6VId+9X6ccb1TsQzS1W+70RTrUZQ3XxWFFPvYlM3WOmHSkW/7qCjMVN2pirzSzWHH396bvr6Seycno3inPVhSqPkYOgGM2WNhmcSZYJBnHO0WnD2xFFM08T3RwxHI27cuLmr8GkPASkwdAtd03EMlAuIoaOjPSC2RiNOx6xbTWErGVsmmQ8wYehHOUJK1gcxI8egXnIoWxpZoUDpC3UPyzCnU8vpdyHk2OdU8uX3t+iFCjs4jHJcS2e+6hAkaj1yfNbFdgwWSnMsLMxR5IIgVGLUg0Gfd6+t8ScbOmGurm8sDVYDjV7mU3NMXjve4sXDda5e3nriE0AplXbXJ9khP2pMfvt7uRT9WRSAj/IeO7cVr7/++nRbMYmPUwCuD2LW+zFvXuuy0nMxoy6uKBBIdE1tDNRnVeSpnVuOXEi+c73HtbbaEHTGtmkKKwy2Lkm7GwSm4JlnnsZxHIQQ09eP4pw/+Gib7SCnZCnM2PUkYNs2aXomB5oex2dKZGOShKbd9r4VUtILUr59o08uJE8tVFjtx4zinM1hBhJePtLg2eXbxVNWFOSiwMQay0NpvL/hY+owU3VolS36cUE/TJESvv9klYNezvbWFjdv3KRUKk391CfT+fVBTC6h5toIKTg6WyLOlA3dvAtH6/ewdNQgSnJGcYpj6miAZRo0DJOaY7ExipW26n2efUp/TxLmBZ6UOI56Fmi6Iq3dr/ASQjKKFckxTAuqrk3d1TENdU2OzJQouyZSatOpJYw3HOPPdr0T8vUrvXHxVmBZOo3xKj7NC55daqjN0HhCLSc4wMm5jYWf31kbKh3XTDLE46NNn6prMVex+d9fWp7e1x83x+m6Tr1ep16vc+zYMfI8p9/v0+12uXr1KmEYUqvVaDabhGHIYDB4og3uH/3RH/HTP/3TvPzyy+R5zi/90i/xoz/6o7z//vuUy+XvrQJwc3OTCxcusLi4yOnTp/nKV76yr1XSo0aWZVy+fJmiKHjttdeeCANP13XSNOU73/nO1KnkzostpeT3L27xp1e6lCyDtTDmu2sbmHnEbNXBswxOz5eVCXchxwBpc3w/a6R5wVcvrrG6PeD0XJluojEcY8biTPDsco3nDjaAvfwcDeJM8P7GCM8ymPfAq5YYJMrzVkh4/XiTk3O7GUrKnojxMSVXO7GyGLNMZnWNRskkiG26UcanD1ZZatztyTn5ELko6AYJEjkWDIW6Z1JxNMq2gWPqdxV/d4ZaXwsSKXAMMHQDw9QoGQZ+WkzXzqZl0mg2aTSbICVRHDMajuj1+1xfDdke6oRRQq3i0HDVJDDKBMfnylimSVEIxD6+nhfWfa53Q7pBhoZGSMhizaYQytLqSMvD0DS0iaBtXuyaMmwOE/7ruQ16YUYuJN0wZxDnVB0Ty9A5PlPicMOZPqSMsW2SlKrI0DWdP73S5e1bQ2qeiYbEzyRBIriVKWjBF5+Zn36XO9mF5VJZQR7kIm9+e4WUIS1PCfZmXpVEk6SZ4AefrvEzP3wUU1dr9SeJXZuE7/ufmEbW44i1tTU2Njb2hJV8HLvLh42HXQFPtE+PHDnCqVOn9myMH7QAXOvH/H/eWmFjmODaJlc3B4Tb6zRLNhXH4GDTY7FiTwtVXdfHMlHq/r6yHXBx02e2YuOYOlt+Rj9M8OOcoy2HBd1nplLh6NEjuyaeyklE40bXZ3sYs1S1SF0N4VTojCKGcc5y3eEHT83s8hy+UxR9Y5Tgp5LlmiKnnZivEiTZVBv09eONu4qnCdxFSMkwUg4fJdtA0zVc22TBMpgrm2wMU+YaFZZmVI7Ns0zpofojOtevI6WkUqkwGumkWU6c5cq/W0pcy8S2CiT3v4fSQm2YukFGWLJouBa2pZMWhSKklG1M3SAr8j2vtR/nfPfWkH6k5MEcUzIrY1olm0GQcny2RNOzdgk179oUSUVue+vWECEhSgrCLKEXQtUxcC2Dlw/X1fQVxqoHyks5QRWawyjn/3xnk1Gcs1BzaPsJWV6w7QtSV/KpA1VeOdoAmK6L1bG0KWnmejvgvfURnqmwm2GhkZaqhJmg7pn8k//lFM8sVacuZI/a5JqmyezsLLOzSnotjuMpfvCnf/qnee+996hWq/zar/0aP/IjP8LTTz/9WIdQX/7yl3f992/8xm8wPz/PW2+9xfd///d/8gXgRKj0ww8/ZHV1lWeeeYalpaWpFMCT6JAHgwHnzp3DdV00TXsixR+oInNzc5O5ubl9V8trg5jv3hwwX3U4OVfm2uaAt3sZvUx5QL5+Zo7DrZ0YAjn1hhVC8O7lW6x1fY4tzeK5NvOaziBS5uJl2+Rzp2aU+8SdMcaZtEcJYVIwX3VJfYNayaJe0lmsOfQCRd64Z2coIctzpRhfaOiGgaNpOKZBmO1/7abrHSmJMqE8drWYasnCMzQ0DbIxlvC2ldPdURSSDzdGdIKUUVxQclJmShazVZtukFFzTZq26njN8XEkgKbheR6e6/LB0GA91xAkdGJBL4nZ0kPKjo5tmpxsWVPGrKEb6MbYLi1XXsZX2xFf+aANEuolk0GY0w/VCnq+6vDSoTpHZzzlazlNSky1EAsh+dMrXbphxoG6S1gq6EUFQZzipwWfO17nC2dnpyw22C0gDSA1jXfXRjiWQdnWKTsuSSYIkpw4l/zwmVlOze89SZussYWQ3OhGlGwbzzMp6QatxWWyLGNtmCJG23znm1s0Gg3SNKVer09/p08qPkmbpMcRBw8eZG5ubs8m9kHtLh8lPu4KWAgxzcX30z6dTFjudw9850aPzVHCpw7UODZb4u2LPW5aOsM459nlGp850piuhiefYeKYoaEEfy3ToOxYeJZBo2Qzim2lD5oPeOHMEvPzC3elKbV9gfVBhG2aGEaBIYTyNS9ZrA1CWmX7vg1mlo/JCHmu1o2GTtWzKYScaqLe6xcgUfCcXiRoeoK6Z2FoGkkhpuc1CdOyaLaaNFvjJjWKuLbR56OtAZuDgrYfU3NMFqo2nmOR5QUHWzaGIcdNqpKf2Xk92n7Kf393k36UM0pz/Ew1+DNlm0JKjrY8lms2uSjG+Gh1LYRURZwQkv/x3hZXOhGzFZutYURSSNb6CaO44HDL4/tPtu5yhLrNLoZr7YDzK0NKlk5r1htvmVLSTGJ6Fn/p2XlOLezUV719rEIo1vPldsQoFsyUlTtMxbXw44xhnLNYc/hrzy/ueR9OC3ohuNULyYWkUVIuJfPNGcq1Kv0wQ9c1Ts2NBfrHRMHHveVwXZelpSWWlpb46le/yj/8h/+Qr33ta/zu7/4uv/RLv8Q//+f//ImKzw8GA4ApoeUTLwDDMOTtt99GSslrr702XffsZZX0qCGlZGVlhQ8++IDjx4+ztLTEH//xHz/2h9jEF7PdbtNsNnnuuef2Pf7GMCFMcw42VZHniZCzCxX6YYph6Hu7NYxdJy5fvkx/lCpvw3ES0TRolpyp+fj9P6sgygrWBiFpImmKAlPX6Q9H+FHEyvWAqFGhVq1OrZB2vJjr3YhumLM5TKi5BrMVh9myYg47ps5CVenNiULcpWwvhOQb1/q8v+7jpzmDKMcbpbTKJp6p9PNOzHiKuIECVstx8SvHx/nWDeXaUXFN0lwSpoIgieiGKQs1h1ePNsi3e+SFSv4a7DJnv7rtc25lSMk2OLNQYWOUMooz4gKqhsnzcwayt8r7g/UpaaJarWJayq7JNHQubASkhWS+atHIDRyZg+kQpDkvHKzxg6dbd11/lZTUvZ1kglv9mKqj1mAlTaNkGxQVi06QcnTG2zWh2PsaCqIsxxqfG7qO5+i4psG2nzyQ8LOugaFDGOdYJjRbTXTDwNJ1bBuefeoILx4t0ev1uHHjBr7vs729PWXINZvNx6aPpc5LfqI2SY8jJnlsr/heWwHvFKR/EO3TycNRCLHvORZCcmU7oFWy0TQNR5fM2gXNA3XWBzHLDXefAmyMc9YUCcpAjr19DVxDkkQ+Wp5w4MDSXRZ/O0MIBbHpBgmZJXENqSATmoZAYWQnRdxeESQFt/ohm8OEtp/QLDnMVS08U2cUK7yYPW7s98JHb49SvvJhm2FcMIwyemFOxU5ZrDoEacGx2RKzZXPqKGSMG8KJF3eCxZtbBYnmMlPJ6Uc53UjlyoolOVQ3WbQhy9TAAU35Fk+IaVme86dXurT9lKMtj15k0glywjRn20/47NEGP3h6dordU9CaHQLSus76IOZWP6XpqUmdITKSQiPMoeKa/G8vLO4it01ip47hzW5IKqDpKNat0le16I+ZyGcW9l+DSqma9sFYAkdDkT9MXac+9oTPxYM9w01dU2vsJMNzLEqV2vjaKRzq5HsQQjxxiIuu68zMzPDcc8/xpS99iSRJHtia9mFCCMHP/dzP8cYbb/Dss88C3wMF4HvvvUe9XufMmTN3JZHHuSLJ85z333+fdrvNiy++yMzMDGmqrHDulcA+buz0xVxYWMC27XvemHkh6UcZK72Iqg39fk8xMnX1Y9tLd07dKDmOZ+A0F9i81GXbHzBbc5ktqy55FGccnSlRGheGeS6mmL9JrA8S/vRKl16ofCF1qZO3Q8pkDBLB80fmOHbAI/B9tja3uHXrFp7rKXX8ao0bw5w/udJD18AxdQaxYBgHtH2LZsni0weqNDx9Oj2bKNsLQ6n13+hGvLs6pOIYnJ6vsDZICJKMtUHBkabH5062ONxSBbBAIqb3gvK9jFLJxc1ATQU8k6Zn0Y+Uh69tGvzImTmOzZW4sM10iinZbc6+0k/IBMx6yrj86EyJOM3Z9lOOzHj88AvLUx/J0WhEu9NW34PnUqlUqdWqbA0ibFNJv+i6hmtCvWazNVLfy4MkJiEgLzIcU2KZysVFM0A39PsoD6pCuhDqXuoECVXHoOpa2KZGkgts02B+7O15L4mIP7rUVULkibKeS8omh7KCfpRTc01eOdKgWnWoVqv0ej1arRblcnnKfpusMyYFYb1ef6QkmiQJRVH8uS8A94vvpRVwp9Ph/PnzzM3NPbDI/uTaFkWx/99LSZQVbI0SNA2SgfJXNnQD0zSw97GVnOCc1wcJ/TDnejek5VnMlG1kMiTJBK1GncPzzek53kkmzArJN692udoOlGSMKHANiWYlSMAzdQ7UFa5xImy/U9pp4rqx0ououAaDMGNtGNMJE1olm8Wqw1OL1dtwionsia7ygBDq/dt+yonZEpujhF6cMwgz8kLw4qE633/ydnO401FoYlV5pa0s35bqLuAwSgSDMGEYF5xdLvH6ARu/32UUply8+IHKzWOSm24YDOOc1cEYH23ozJRt6p5JnAmGcc6nD9buKfxcCEE3SMmLAse00TQd21DNZRWTrBjjne8Tk21ekmVTL3dTNzAM8UDYwQlZMEhyciGpuBZlS+FHk1xwYq4y9i6+uwifxMYg5s0bA/ykYBQXeLUSephTdQyirOAvPTs/xWo/zprgXrGT5OY4zl0428cZP/3TP82FCxf4kz/5k+m/feIF4EsvvbTv/9vLDeRhwvd9zp07d5df5QMlsI8Rk2mmYRi8/vrr3Lx5c1pk7hUX1ob84YfbrPYirm6HuNmAKhENzyJIUp5ebCpw7ZjSL4Rge3ubmzdvItFYLapcbQd4lk4/yrjZCWkPdVpli3rJ4sxC5bYQJruPE6U5X7/SoRdmnFmocKsX0h5ErHZjGp7OZ47P8+qxBiXboFZTXVKapIxGQ8IwZGu7zdc3JLE0Way7tDyPQVLQCRR28OUjdT59oLZrfTzpCAshkRJu9mIEGlXPRgjB6QU10t/2E07NV3hmeZ+uUFNdXNuPiZKcVlkRNzzHxLUMZso2/Si759Rs+pmk0sfLcjX5FELi2CautWOVscNHcpFF8iyfunBcuX6T4VDQTnSiJKPu2gqvKQFdo1l2MDR92tHfGUJI3r41mDL62n5KvWQxU7bUSvv/z95/xkqWnve96G/lULlqx85xuidwZsghh5qhJCqQonQk+cqSbflCR8m+OriGaPhY17AlGBDggwvogwBf2rIgwYblewEfwTrysSxbgQqkKJIiKabumZ7pnHv3TrUrr5ze++FdVb139+4wM91DWkcPwQ9s7lqrqtaqZz3hHwyVgx23lMCRK++7J7ubQc5fXh8yiTPirCDKRFm0aYDCU4sVlmv6bKWml3iY7euiv7w+5LOXe9iGSi40Ur3CICrwN3wOtm3+Hx/av0NbK89zdF2/Rx9rKofw5ptvkmXZjPk2LRbfyqTd96XQ9F8FFvBu8bjy24PiYStgIQTXrl3jypUrnDx5kn379j3yNdo+Adwt/Djjv59Z52Y/4OpWwPXuBDFcZX/LxoszqqbGQs0up6RqKVlSNqqKwto45uygS5jmmKrCphezNvBo2BrzzRpH5mvMV8x7MH/T41zanHB2fcJcxcTWVW4PQ7ww5eKmx/GFKi8fajJXMe8Rtp9KO13ZClgbRizVbVQVRqHEKw/DjLmKwUefnqPpbpt8TWVPCvm9DuOcTa8ovcwV9rVd5pKccSRxvt9yuEXN3v0RPN0QbIwjdOWOQHPTValbKpuTmLpjsXdpnk0Foiik1WrjeRM2Nja4eVOSSTBdaRWJTlHI78jQdTRV4CcFj9AbkBfTLZH0iFfyDE0zibKCumtSc0wo7mxl7o7uJOHChseonFw6lsGcq2PpgjjNeP/+lhR9VtV71sjT8395Q3AzGJEWgjBMmcQZjq5iG9I95qUDtdnrpgLSSnld5Qo+5//4+ho9L6Xl6oyijMxwudkPabk67z/Q5G+/b/nOOd9Fmat3o8H9+Mc/zu/93u/x2c9+ln379s3+/RteAD5oRfE4ViRTMPOBAwfukV7RtnV97zSm7iF79uzhxIkTZTK6P0h6cxLz+6UNzSuHO5xdHXD1So/1XCqTP7tc49g2PEJRCG7fvs2g3+fw4UN87fxNbvZD5qsmexo2vUBKpwzDFMe0+fDxeZYb27oJhR3f5cY4ph/mLNRtVAQHWyZG4hErJp16le86sYDKzu/etEw61hwdYOgn0L9NVeQEQUSe59iqyuG6yTBRaJes5QdFkuYIUZAXUr9JUaDumnhJ/jBC2vQjEWU5a6OCuq1L6x8FklxgGVKtH3FfT3a2vITrvYAtX8q91B2L+YqGrhUkWc6RsvBCyOJ1Zu1UkklMt87nNzbwhEeUp4STlC0voW4IJn2fuarBwdLXU1Wk3/Dd5uxfuTHkzy72sXQNxyiIMuh6CeMoY75q8O3HOtQd/S5szR1z9jTL+PpGzigW7GvajOPSlD2TLLlvP9biIyfnd0xAp3gYoPzeNb56c4yqKjTK79FoLxJkClEm+Huv7uejJ3fase3WIZumydLSEktLS7P17RTwfPXq1R0F46PYKXmeN5NZ+KsY79YK+H5TxjRNOXPmDJPJ5G1Z0T2sAPzspS1O3RxycrGKY2hcuL5CbxQyjlJOLFZ46UATxyzdZ7Jt2NhSKuryVkKU6RzpuPRMwUovIlI0Cs3kPXsbvHd/Y4e26RTzNz3OtV6IqWlULelmYykZQyMnVk3es7fOUwvVXb+bKSa2N0kokBN5RVFouSotR6frJ9RsfWfxt0vkeWkjJ2TDq6oKjqWjagqjslF+UAghyAvBKMrQ1Ii6Y2JqAIIcKYVzh1CnzHyLl4E0SRmNx3z1xoDuOCbMwdFlXp6r23KFbGnsadmz6efdxDSA11fGfOZSjzAtGIYZgzDDUgoaRY5Q4PnlSilJJkrmtCSopCU+2o9z/svpNbpeQt3RGYUZkygliFLqrs7htsv7Dzbld15sn6TqpVe84Fov5OpIUK9o1G2dLT8jSNKSuGHwN55f5FDnTo7YLs01hfxc7Hr0g4ymq6OrCp1Wi8Kt0Q8SDrZd/t8/eOIeHOq7NQF8kkonQgj+4T/8h/zO7/wOn/nMZzh8+PCO//8bXgA+KN5JgiyKgvPnz7O6unpfMLOiKO+YaCKE4PLly1y/fv0e95AHFYCXNj36fsKJRTkViT2BvlBh00vY13J45UhnltzSNOXq1WvkecaJk1K/Z5wU5FqBYxqgwELNZq5i0vMTGo6xs/jbJeKsIMsyFKHhBT6+J43NW5UKytQM/QFFmKqq5EIlKhRajkPNVEmTGD9KSOKMlZvXwatSr9eoViVmbnuMEtiIYm4PI/pBSqdi0anIvxGFkLpculZ289k9RJTbw4g/OddlEuYEaU4vSKmVbhvjOOe5PTUp1FquZU1dRy1lHQDGYcZ/f32DrpdQtTS8KKc7CRkFKk3X4GCpPbhjMnCX/M1f3hhyox+y1LCpOQa9ICOMUkap4FhN5cVWyrVL50tZB7mWcRzpJaypKmle8PVbYzQVWq5Bw9GYRDl+LLvW73l6nvfcT5urfF99P6UfQ80xpASBrVK3dOIsx4sznlmu45gPwA8CXiTFYK1SCsJxKjRqLh3g9jBG7NLaP6xDVhSFarVKtVpl//79FEWxq53S9nXx3Qn3G62S/zjiUdyOnmTcbwI4mUw4deoUruvyyiuvvG3s5v1ynBdnvLE6Ya5q0nBNnjY1oq2CplIhTHNeOtCa4Z7vjjzPCZKCQZDRrNtMfJ809DixLDGmq6OYhbq144G9WwRxiqrIVktVNWxDp2FpBIo6Iyc8KJKiwItztiYRVdvE0gBVoSigZpkPxA7mAjZ9CSVZGUY0HJ25ikndMRj6CU3HYL5mldqq97qA5LngM5d6XOr6TKKMUZjimgkLVekL7hoqh9u21ABVSu3BabGvKBimwaWxyptDlXrFpghSwkJwe5yw5UU0bY3n5yvkUUCqSj3Uu+Vvel7Mn1/ukReCI3MOGxOZJ/wUDK3gu5+e46Wpe0q5lZky0xRVOrhc7E7Y8lPmqyaqotCswCSImcQ5+5oOf+el5Zn38SwUZcc6/OYoIRMKrmUgCqnZmKYG/VDivB+IH0ROEHuTGFmkSiWGerOFaZno2hQms/N++B9R6H63+Nmf/Vl+8zd/k9/93d+lVquxvr4OQKPRwHGcb3wB+KAEqev628LITLUEhRAPBTO/kyScJAlnzpzB9/1dZR4eVACGaY7CHaZz5I+Zr9kUhZDac+W95/sBV69epVKpcOzYMTRNJUlS8gK8NGdrElJzDYySsVSg4FpSS+luzN804qxgYxyxOYm53Z9QNeDAfJNgPGQSpRxbdKnakvma79IVDoOUz1yU6+NxlNHzUuqOxnLdJlYUji7Vee5wlSDw6Pd63F5ZwbYdSaKo1Rkngq/3FISR4BgqfpzhxxlbnkbTMTjUdjjcdkizmQvkDnmBJCv4s4s9hmHGkXmHtVGMl+T0g4RcFLxvf5NvPdoCysldueJVNG22arjQHbPlyQSiIgvqYRDjxzmHOw4/8NziPSvku+VvLm74OKaOpasYKjRsnUmo0vMiXnlqkRf3NUjiZLYu7na7ZWFUoVark6gWfjyVh1AxVZV2RaPpFmx5qZR7eEgISgxgyQpXVSkPYym6XPE8IvlDIBgEGUlesKcji04p/AwLtXuLg7cKklZVdbYOPnr06A47pXPnzpGmKY1GY1YQVqvVx1oA/uqv/iq//Mu/zPr6Oi+88AK/8iu/wssvv3zfvx8Oh/zzf/7P+dVf/dV3fO77xbuxAt4tv92+fZuzZ89y+PBhjh49+o6+3/thDJPS9qtR4ssG/R5126BiqqwNo4fqYmqaQpwW3FjvUdEF+5bm0cr8pusq5kOmM6vDiFGYcm0roOUadGo2jpIT5TmqpTJXtSUeudjlfQjB12+NObs2YRSmDIKUqpWwWDMwNJlXD3Zkgz1l8hfbiBsAr20kXB7kuKZOnBX0/JxRGNB05OTwffvrgJjJOsm1szYToj634fHG6oSmY+AaGhuTlCDJuDWIODLv8B3H2zNIRlE6I8mmUOZKP8l4bdXD0lWaNYOOa0j8YZhiagrffaLOvJFw8+ZN8mKnEPwUh3a9FxKmpXMLBQfaFaIkZWPo03B1mWMfiG8v2JpEIKRsFQq4OjhVC0NLUeHe4m+XKAoBYuo+JPUhDUNFj9X7r3fuvqQIoqSgT0q9WsUw5WcM01zKrN1zzidPAgEJG3uSEJdf+7VfA+A7vuM7dvz7f/gP/4Gf+qmf+sYXgA+Kt1OcTVexS0tLnDx58qFj3LerkzUejzl16hTVapVXXnllV020+xWAwyDl+lbAuXWPjUlMVQToUYKqKURZwWLdQtd0Nrub3Lh5kz3LO2UOLm763PRgWCRseTF112K5Jm3T8rzgQMtGQZRMMGUHQDovBJ+71OP8+hiRJsSZIBM6cTfEKGCppZaTr2JGGDDU8jhCMnn/4uqA1VHM4Y7L+iRmFOVsTqRP5rPLNb7teIe6a1Cvyxs7S1PG4wlB4HPz5nVe3xJ4ieBgXWGh5jKOC3p+QpwWHJ+v8B1PdXa6btyFC1kdRfSDjPmaharA4bkqQZwyDGXR9J1Pde6Zek0T83TVsD4MUbVSpkBRaGgSW9P1ElxTezh+sHQmUBAUhYpaWjhVLJ1hMNuwYlombatDu9NBFFLWYTIZ0+v12BoHeIHGGJWao1N3ZJec5mDoOg3nwVOGohBc7voEGYzGKVaY03B0GrbOMJTg5v0tZ1Y872bO3vdTfuurq4yjjDDNiYRGPCpYKGLiTPDMcpX37r93NfhOcbN32ykFQTArCK9fv85//I//kcuXL5NlGbdv396BW3mr8Vu/9Vv83M/9HL/+67/OBz/4QT7xiU/wsY99jAsXLuy6GUiShI9+9KMPlEB5K7Gb2xG8+ySQoig4d+7czAt5fn7+Ia9+eOyW44QQrAxCbg1CTt2M2Nu0yXobVEyVSZRSMXVaVQtd02RjdlcN4cUZX70dsuUleJlCzbVIugH7Ow4DP2OuZrJQM+9g/oqdwvYrg5BPX+jixzmGrtINMgahbHQNIXhxT4XFmkGWFxSFQNdU1Jn3bcbNfsTXb42wdY2jcxWpAxilXI1TDrQdPnCwycG2U06X7iVuDIKE68Mc11CYazi0KibDIGEQpGiqykdPznGwc5e2KoJimxD15a0AVVNxLR3XFNQcAz9O6Xkpzy3XeequqdfsOyxz5dYkJowzmhUDRVWxbZVFU6NTMRiFGcudJnuaNghBFMVMJmNGoxGrq6uYpkG1WmPiaxS5tEwDBUUV2KYhRfFLnPPD9O0LIQjTjH6gULENDFUOPTIB7aqFWuIm79eEdCcJa+MUP4VrWwFV26Tl3pHPOrZQ2RXTvO1m5LOX+3zh6oA4Lwj8nMA0iXshFVPD0FS+/9l7f+ePixfwsHjSTke75Z3t8VemABRCcOnSJW7cuHHPKvZxnWMa0w76yJEjHDly5L43727JcRJl/NZXV7iw4eGYGrcHAf7mLeqWSt3Wmaua7G/ZXL12jcFgwLFjx2iW2JwsK1gfR3zt1hhNgeMLFVZHMeMgZhLG7G+5PL+vzpG5Son5u3NutRQOXhn6XFgfoSQ+Rzo2qebQ8yR2sGLAtx1psq/lzBorRdkpitoPMtYnCZ2qia0pHJ6r4EWSeQsKHz7euQcboxsG7U6bdqcNQvCVL97A0iYkSULqBei6wv6qRT+W0gAPWlmCnGDmeVF61QKKoGIboCpESVY6hJSx2w9ACBDyQdP3E2qOiV4Cz6ekFBVld9HnMq73Q/w4Z2MS45oqbdei6ej4cYqhKOxrSdeOQsj3iiLJJG7Fxa246NWEP9tYIy4CwqxgnKZsTWKatkoiVA53XBZr8nucrmVEIXZI6Xz+Sp8/v9RHV+XKKcoE8ThhHGY0XYNvP97GNtRZ8TyTwFFVRCEnDX98rsvaOGa+ZuJFGZHZIM4K1scJ331ijv/1uw7vOq15nB2yoihUKhUqlcrMTgngX//rf83Zs2c5ePAgJ0+e5J/9s3/GT/zET7zl4//Lf/kv+Zmf+Rl++qd/GoBf//Vf5/d///f5jd/4DX7+53/+nr//jd/4Dfr9Pl/4whfe2Qd7SExzz5PUUpyeIwxDTp06haIovPrqqw/0J30rMSWVbY+/vD7gD85soCDxuK9fuQ3BiPmaiamrvGdvA0dXZveltm26L4Tgs+dWuTWUws2x7jIKM9bGMX6ac3KpygcPtzA0ZSfmD2TDK+DM6pggyTnUcVlMc7aCjN4kIsxynmprfNvxDlrJ0oWdmDFQuDGMyIVC0zEQCOquyTiQDiQnF6u878C9DRHcIW6sjyPivKDlmqiaRtNRqVsacxWDNBfMVR8MzxFIoWStBDAriiI3DK509LnnVtmtuVCk/M3WJKZm6VRLsklaSE3UqmXM7jvbsbEdm/mFBYq8wPM9tgZjLq/16XqyOa85Oh3XwDENolRwfN7CKmE9WV7MMM3b39PnLvc5tTIhTAr8JEb3U1qO1GPVFXhmqUIhpMvRlACyXaVgHKb8p6+tsjnJMDRIChj4MZNIoW7rHGg5vHdf4x5Ms6ZKwlyWF9wYhHz2ch9VVViuWwxjQWE6DMIUx9T4f756gG871r7n+3u3JoB/7QX8GDAyU5P1OI555ZVX3lJF/VaEUrd30O9973tn6t4POvbdyfH12yMub/mcWKxydL7CmSsrXBnAOMo4MufyLYeabNy6Tl7knDx5Asuy7jB5Fbg9ikgLqBolbqxiMwpiuuOYo/MVPniovetUviiFg6+sbDKZeBxeaOJWXFBgrmrQ91Nif8RCdSer7e7kEqc5WZ7PTMtVlRKcrDKOsxIH8uDQdI0gg5bp0KwZpHFEmmVEUcbWxho3lBG1Wp1arYZh7iwms1ywOZE2cT0/pumadFwD21AZByl7m7LjVpB2QtN3M/1OikLw+St9zm96eFHOOAxwDLneEYClSe3BovQtVsrvYLs/6IUNjz94o0uSF+iqip8KgmFIL9CoGgqHGwoLVWObtZQyezgVQq5q/+hcl/Vxwt62Q99P8JKCOBUMYjjSgBPWiAvn/ZmsQ7VaRSvB6Lqm4sUZX7k5wtBUTFOgm7b09kxyNFXhh55f5MTSXa4zlBI45T05jjKu9UNcW662OjWH+tISQZwzjjP+5guLLNV3f1g9SZC0qqp8+MMfZn19nclkwh/8wR/w6U9/+oF6b/eLJEn42te+xi/8wi/sFxH02gABAABJREFUOP5HPvIRvvjFL+76mv/23/4br7zyCj/7sz/Lv/23//Ztf46HxXYS2pP8LuM45gtf+AJLS0s8/fTTj/XBdneO8+KMz13qYeoqHzjUYu/Q4muv32arEHhxzvcc7ezAbCnbyGlCwKUbK1xeH9Gp2rimzt56hUmUMQ4TcgEfOtopV5J3RdnwhklBdxJTt6WmZkXVcEydfQ2TG90JLTvfXRh/23H8KEVFErUUVcEQCp2aRZzlDyW2AahAmstmWTGk/ZqqKORCwdC1cqNy/9gYx0zilJv9iL6f0qpatBytlFyBxfrUt/jOCvnu1//RuS6jMCVKC3pGRs1SmauajMKMpxer1G1J2NA1dQcxTdVUHLfKly96rMcmrimlV/q+lK9xdYWGCU+1FMIonmG7pU6riqzFcq5shXzh2hBdVdjbsul6csPT9QoWaxbffbLD8dJh6m4CiKpqaKrK66sDen5Cy5HHzTQTL0yIMsGROZe/9d7le4YF2/VVEYKLmwFpodB2pdbisYV5sKt0JwlPzVf4G8/vnlPeDRLIdPPxjVQ5+IYXgA+KR1mR9Pt9XnvtNVqt1n3dNh52jkdZAUdRNBOsftQOerdjX+v6OLqGrqko5DTUiOf2NFgdhcy5Khs3r1CtVjhw4NhMzHN7+HGGipAqdoqCqSrMVW3STGCU+nq7RVEIVlZu0R8MUEyHSKjoaY6uyslULhQsTXmgpH1RCLa8hIGXsj6O6bgmbdegYmmMIyno2ana6Cq7GqpnueCzl/qsjhJGqULUDaiYGnubNrGistCyed/xBloWMRoNWV9bwzAMqjUpvuy6Ln92occbax6GrhBFgo1xwqAkvtQdnZcO1Gd2QpRrcE0rO0wBFzZ8vnpzRMXU2ddU6foJUZJxc5Czv2Xz4WNt9rWkTNBOQ/VSw1DAl64PSfOCvQ2buFIwjDLGQYooBB/YV2Of4d0jf7N9hb3lp6yOEhquiaEqLNUd4jTDT3JyIfibH9jPfMXE9/17ZB2mYtTdSEob1B2DKFOkdI2l0cil36bzCNiaLJfYQVMDIVTsWgNDU6k5Cl6SE2e7/y6EEO9Kh+x5HpVKhVarxY/8yI+8rWNsbW2R5/k9xePi4iLnz5/f9TVXr17l05/+ND/2Yz/2ts55d9xvBTzNVU/K7lIIwcbGBkEQ8J73vIe9e/c+9nPcneM2xjGDIJ25F9lFyNGOw1LNIEwkgH833bcsy7l+/TrdUYhbrWKRgSjQNY1mRcUx5Wr1YeWXqkr84SjNgHIzIAQCFV3TMdQH5/phIOWYbg1ChkFKp2rRcnTkjEthsWY9UG9uZRDxxWsDvKRgEBX0k4iOKzcbkyjlpQNNTP0OoUyS3O743q6NIn7vzCbDIEPXYBjlTGKfvqVRMXWOzbscaNl3sIOl6LMopjAPwZ+c67I5ljqmG+MEPynoeylpJnhuT40PH+9IM4FtQs3bC6+LmyOu9wI6FYOFuiWVBfwEP81ZbJi8vxmhJz5nz57FcZ2ZOL7rupJMAlzY9MkKOaSQ18EkiFKGQcqJhQofONjc/QIoSom1LlgZhGiKIi0BVahbOnVTo+cnGJr60E0RirRKlStsDVXVsCp1VFW+Ns7vfy+8WySQb7TV5Td1AfggqyQhBNevX+fy5cucOHGC/fv3v601yqNMAKciqQsLCzz99NOPnKx3mwCmuaA7iSTwP/HI0hRd18jSlO76kKNPLe1qawRyJN73E270Q7QMDC+lXZE/uFwULNadHYbqs3OWLOKb44yeUmcUhQxCaX69XLdwDJUsz9hXkWtG+fkERaHsSHJfuTHk1IqUC0nigttjuRZpuQauqfHC3jpQkBV3DNUpV0SFELx+e8wba2Nark4SCWJF2kGFXZ8jcxW+7Vib5U4FqAML5FnOxJsQeD6rt1fY8HNObSrUbJP5ls04Keh7MV5cYBsSy7F/u22eopBld2zzNE3nQjcAoObIjrDuyq5yEKa8uK/O8/vuZd3CHQ3DcZgy8FOqVomtMVUWdJWFqsnmJKHpaGjFgxNHlMr1q1PiHBVFwTal9/AokLhMVVPvkXWYTCZ43oSt7haDGOJEYZDlqEWOKwpQVHIh0HVNPvgeEl0/LgHqqZy2dFxcIWYSEfdj103v6SfdIX+j1iNFUbCwsPBEp3/weFQI7hdJkvD6668zmUywLOuJFH9wb45TEPhxxu1BRNvV6W31UFSJkTUMhd10n8Mw4sqVK1iWRXNpP8Ozm0yCmIalYLgxrqkziTKqlkG7aqNpqiya7jqWH+d87tIWW35Kz0voTlLqjsqBlssgSGg4Ck2rLL40lbzISdM7A4ZhkPLJs102JjGaptAPJK64bhtULY29LZsDbXun3pyqAnJDECQ5f3Zhi1GUsa+usekXxFnG7WFa+rLXeOlAfVuRU35nJWMWFE7dGjOJM/a1bOLMZBDkDIKIKC34lkM1vv14G127q7nMCrJyfb42SegGGZ2qZLjOIDpRhqmpO/zAd8S2wmttFAEKpiEdN5qOStPSGIQZFUun7eYsLy/jOA6eN2E8mXDjxg0KUcxEqCdhjIJgapSnAlXHIEzynRCdB4SuKoRpjgZSPLp8FglUao+Q34I4ZxCkeHFOmEa0O3M0hFSZiLOC994n18O7KwPzf+kV8IPifivgqX7VeDx+W/pVj3IOuFckdf/+/W/p2NuTY5YXfOp8l9duj7jcDbg1CFHGa+yp6QxHA+Iw4j0v7mN5eb7EaJVemOVvfRym/On5LmsjyaAbpXBxc0zbtahZGosNm33NO+viKRs08H0uXrxEormspHJ1cmyuwuo4YhIlTKKEvU2HF/Y1aKcRIEpckgTwTo3Z+0HMm2serqGxWLMYBCldT5qcFwK+43iHY/N3gM13G6oj4MJmgG3qVE2FxIRq02US5UzijJcPNu/xqtV0jWazSbPZBCEYXN2Cbh9NZIwnMYqqsVzRCB0Dy7iPbd4sZMc7CRM5gZhha1RaVYsoLXiwo6cMQ1XJiqL8e4FrySSZC1nwGqqCcj9FVAAhnV/8JKMfJFQsnaZj4BgqXjlF3dNw0DV1h16gYd7BUfa9hL/4+m3CLCTJczRFIxgENCyNMIfjC1U6rrZDL/BuAsjplRG/d2ZTJmMBgWJzc5DQD3Oqps7ffml5h/Dz9pje00+6Q34cAOm5uTk0TWNjY2PHv29sbNxXf2t5eRnDMJ74A+BJ2F2C9Ps8deoU9Xqd97znPZw5c+axHn97bM9xtwYhv/fGBrcGIeNwjEuEk4xZqFn0vZjj8xWqllHek1LqYzAYcO36dRYXFljPXE5dG6KgkOSCdR/8Na/EDmq8uL+OpoiZT6umqWUBXSBEwV9e73N5y2d/08bUFIZhLidgcc6JxSrvXbLIvVgWOlkxc5gwyut8dn3Ilpewv+mwWLPo+Rl9P8JPct6zt8a3H2vvYK1uX10qCqyMYkZxwULdJvBSDrV0MlXCa+arJt/7zPx9V8iSdCe4PYyoWDqaqmHrKst1laW6wcZYKhZY95nsKyigKARxKkXtHfm7R1GoOgaKCklalDn5wfe1AsRZzjhMcE1pTyelYcA19Rl2cKqH2my1Zr7Fk4nHanfA2lZIz1PxwoSaa9KyDYQiBxUH2lN91Tt6gTtCCL5wdci5DY8gKQgSga4WzCtSFsxQBU8vVrbpBcriNcvvsLCjNOd//8ptbg5ClFIbtp+Z+Js+NVtnf8vhB9/zIAvBJ7/hmGql/l96BfxWrZJGoxGnT5+mWq3y6quvvmPv0futgLMs48yZM4xGo7ddZG5Pjqdujfj0xS6LdRtNgQu3NlkfeKxvZSxX4Nue2ceR5U4JbJavmYqiKorCxc0hm5OY/W2XpXrBpdWIVNEYRRknl6p86FhnR2dXFAX9rQE3bt5gaXGJlcQh2hqyXDdQUKhVLMZBTNdLODZf4VuPdrh4cesePPF0erc+jAjTgn1NqWPXqai0XINxJFct+1v2AyUBkly6jxgyT6FoEpvjmDrZ8P4ssFkoCo5lUig6wtCpuBoUGVmaEkYJeRJz4/p1qbdXr82kDLav3oZBSpzKDteLMhoVk7qpksvhGYt1C0PXdnXbALly/eTZLqMww4ul7EzFlAXxMMyYr5ksVzUmYwVD0yTm7i6A9Jevj/j0pZ5c/eTSsWNSMnYtQ+Plgw10jdkae0oAoez0BYLffX2D1XEqH6x+QpgJglTKUOypwFFjwLVr6WxdbNulZEV5L6V5wZ9d6JHlgoWqKZngtQ5+JvXH/pdvPXBfbAywo8l4kvE4kqNpmrz00kt86lOf4od+6IcAeU9/6lOf4uMf//iur/nQhz7Eb/7mbz62h8C7ZQe33ev86NGjHD58GM/znqjUzDTHRWnOfz29yko/5P0Hm1xYH3P1ygprcYwXpzy1WOOF/Y0Z5k8IWFtbpbvZ5diRoyi2y6dPreKYGgt1i4pW0PNjwrwgTgu+88Q8x+e33wtix+fy4pyVYUy7YuIaGocsHT/KGIYphRB8+/E5KkrC7cnOBKeg7PCrrVg6uqahKbCnYbFcN1kbR+xpWjMixW4hkLqDosjLVlOgqdB0JZNfUR7OmFUUWVROohxdVahYOtIOWbJc76d7OM1xRSGn916UcykKaDgmLUdq3AVxznzNol2xJD46v1feC+DcmsepW2PGUcY4zLBMnfmKjqHJ63xyqYKYjNA0dWeuVBQc1yVTTb50OWKYFyhKhp8J/FFMfxJhGwqLVZOjrTt6hdunn9NceX7D588ubqEpCp2KzjDISHPB+jhmvmry4eMdjsw59+gFqjN9R4WvXB+xMpD6iy3XJFJsIsskyQVPzVf45993rLTX2z2mTkdPMqIooiiKv14B3y+262RtT24PY9++ldhtBex5HqdOncK27XdUZG4vAL96c4CpSSBuxzXwN66TGymRrvGhZ/bx4v7mrseYvrdbgxDXMjB0idOYswpa7QpdP2N/26W5zYxbCFhdXaXb7XL40GGazQbnL2whOa4yE9moWDWbLC+kDII65XzcbzwvSLKcfhBTMXUMTZHMYkVF15SHXothIHWsNicJdVtDy+W6Ic4LTE1lvi6xNXfbAE3jZi/kqzfHJfkjwbUM5is6FdNGM1Ne2l+lVlPwvAmbmxvouk6lUp0VEP0g5b+/scWGlyCEBGjL9Y6OqakcaLsc2qY9qCnKTBpimqw+dWGLcxsecxUTlQS/tFyL0oJDHYePPT2PVsgV83Zsja7pKApMwpTPX+mjAvtaNpMoZxgmhElBLgTf++wcL94l/Jzf1ZysjhLWxgl1R3r92obDYOyRqyaGpvD3P3wIS8mZTDyJH1xfR9N0arWqxFJWa6xNUsZRTtXRUVWNRt2hPl8nzQv6QcrBtvNAf8+Z3uATFmj2ff8dTfen8XM/93P85E/+JO9///t5+eWX+cQnPoHv+zNW8E/8xE+wd+9efumXfgmAf/AP/gH/5t/8G/7RP/pH/Mqv/Mo7Pv+D4nFpAeZ5ztmzZ+l2uzOvc3hrJLe3E9Mcd6XrszKIODTnSixyqqMMLbZ8hbZj8F0n5mYFTJ4XXL9+jTCMeOrEUziOw9WtAD/J2d+WW4BORaei52h2DSEEB1ouD6rFwyQjSjNaZR40NJVmxcI1VXp+Wq7bHywbJwSMI6mTV7UNFFHIdbGiPlSTM8sFAz+l56dM4hxHU6ibAlEU+EnOycUahq6TF7s3l2lW8OeX+vQ8CfPp+Sk1U2VP02YcJVRNKek0tTmTFpb5jqb7c5f7fPXmCIEgSHLCNKbvQ902cEyVl/Y3ZvlkNkEtJ7GFEKyPIv7oXJckK1iqW/T8hDBJWUky5qom7z1Q57nlGhfHgqIQs1w5tc4DeG1lwNpIFmqdiskwyhkFCUUhONC0+OCiwvqta3RXZU6q1eozgtv0WGfWPDKh0HFleWJqECc5UaHw3n11PlRqvN5z/bZhGq/3fISiYGg6INi7OI9uWqyPY5quIQcZD4h3YwX8zWB1+U1dAE7XI1mWcfbsWba2tnYkt8d1ju0TwKl13MGDBzl+/Pg7eshNk2NeCCbhHWD+6tptxr0u+zs1xrmcgj0silwwChJMDWqO7OL0ElujbXuPeV5w7do1oijixIkTOI6NF8tCY3UY4cU5nYpF05HvJS8Eiw0bTdVmwOC7Y20kpWf6Qcaml1CxDBYqOg3HYBwmvO9AA6sktkhh4nyHzdHNfsifnN/CSwqyQrDp5SgFFHqIrqmcWKgwXyntzqYFk6qU313BOEz5o3NdvDhnb8tic5wQxAk3kpS5iskzS1U+cHgOy1CZm5+fSRn4nsfGxjqqqvCpMzdZHwuWGg5zFYNeIFccflzw/JE6331ibof2YC6EFMEGQJIiLm+FVC2diqVRsTT8pMCLU4SA739ukX0tm37P33nPKMqMlXZzEBCkOXNVG02FuqNQszWiVIpbH2i6D5yiokgoQJrn1GxZgKkKWLqCaepEeUGcCeo1G8u2mZufo8gLgiBgMpmwubHJzRs3iVSbLMsJ4wLFgnqtObsXVEWZmbXfL94tgHQQBI8s5/Sg+NEf/VG63S6/+Iu/ONPA++QnPzkjhty8eXPH59m/fz9/9Ed/xD/+x//4HZ/7YfE4VsB3e5BPvc6nx3+SpJ1pjguSXNqmlfeONxowV7PRVWWGdQSJ97t69SqmaXLy5El0ffqQFcRpTm8SysmXkEXK9D0/aHomREne8FPWhzHtqvTSdg2JHXQtg07VIg3T0rZsZ+S54EvXh6yPIzbGMT1PNlj7GjZ+kuKaCnsbtpRQUlS5bty2usxzwZ+e73Jh00cAwzBlKARDXaGdx1QtjWf3VGfFyfaCafpvX74x5LXbY9qugYJgFMtmzE9yDnYcPnxcbnjulqzRVUkC6YcZp2+PsQ2Vo1WXgZ/S91OiLEdV4HufmefENojN3cQ0FYWL3ZAwLVioSEmtumMwCVOGUcaxeZfvfXpqKblTtmj7e7rU9TA0SbgpioI5V2GuotOdxByar/P8yfkdOWlKcHMcZ6Z40PdidPWODpkOGLZGEcOjKvaqqsTWxmmG67ro5nQjxINZ4LN74snnuKnV5eOSZHo78Q0vAB+2HknTlC996UsYhnFPcnscMU3ARVFw8eJFVlZW7msd91ZjmhxXRxE9P+Hc+oSWnuFvXGOx3QLNQAsz2hULTdXI8uIe9440F3z1xoDbo5Dbo4gtL6Hhxji5Qs+PcQ1p+6aqKmmScOnyJVRVnyVXL874o7Ob3OqHAGyMI3p+TMsxcU2N+ZrJoZZDXuQlLo6yUy1IM9lJ/tnFHsMg41DbZnUUEcQp1+KUuUrOicUKL+6t72SUIfWY5PSh4C+vDfHjjMMdh0lksuUn9MdyCvWRE01ePtS6cx9MC6byl66icK0fMY5zFmsGqqLQcCxGYcIgSNjfsvn+5xZ2YGtUTaVer1Ov11nIct548002QwVThcD3EQLausZcy6AfCfa3nAeud1BgFKQkaU7d0aFkptVsDVtXGIbZTFNMPrh2P4yuys49TFKskp2sKJK5rarigROOaWQlgHltJMHxFUOONYIsp2obzNUstPI7VMopZrVWpVqrsswyXhjze6+vEaQ+o7hAj1WSSsY8Ef0Ijsy5PLX4YFDy/4gA6Y9//OP3Xfl+5jOfueffXnnlFb70pS89lnM/KN5pAbi5ucnrr7/O3r17Zx7kdx8fnhymSVVVojTjth9yfStgfRTRNnLyiY+pS7miQ3NVHNOQntDXrjE3P8fePXtnv5O1UczXb4zY8hPWRrEUkdcLHCXHEzEv7mtgm5psUpHiy9s3FWduj/nStT65EARphj8o2PIS5iqSCPGBvRVMDSIh21tdl/7eqZCr99dvjzm9MpptUQZRTneSMAlTDnVcPnioRdM1pIQSU/yrMmt4r3QnXNr0absG81WLLS+lO/YJM4Frqnz06fkd+OQdRZwQZELh3EaAY2rUHZ2qrdGOCyZxRpoVfOfxuXvw0YAUfS6kYP+GlxOnBa2Gg6JApyaZx6MwQ1dVjs1VHthcFggGfiy3wqqCoqgYOrSr6p1mvnz9g3KcpijEWU6cppiGBqIs/lVtlqPvzklTowDPm7C2voU3gX4AcZJRdS1UUSAK2fAu1mwMTZMSX/d5Dxc3PC53A7xEWgrWzTZWImEHqgLfevRe3b97vo93IcdNJWC+kVaX3/ACEO4vkzAcDomiiMOHD3P8+PEnlsDiOOYrX/kKaZryyiuvPLaHjqqq3PYKvvzFG5Kt6gds+AF6pFBoGYYmODzn0HEN8iIvMX/yRs8ySTI4uzbm9ZURnYr0gOwFORvjCDWH41V4/8EW7YrJcDjk2rXrdDpt9uzdi2nILvrCxpDVUSSBzXWLTS+l70cMw5SjcxW+4+ScLGrK91vkgjTLyh+LysowZBjmUnlfUajZBqNQrjqWGxbf+8zCDlbaNAohk9wwSOkFKc2Khapq1B2FqqniFgHCMjjYdne6ftx9HASjIJXAY+S9YmgKnYo56+YfpM01/W0ZpkmS5DiugwokSUySpCRJwebGBl07plqr4di7YxnzvCDKcibDjJolp5+6JllqlqExX5cTAjlNvvf14zDja7eGjOOcfpBhGRotW6dma4zDlOMLFZqOPsOw7CYz8bWbI/74bJc0FyRZQZDCSC0wFbBUwcsHGigIciEneVOT93zbsf7wbI83NmNqtsEkzsCp048EXpKw4Ai+s1Nw7cplOp0OzWZz1yT4bvpkfiPXI48rnoTdZVEUXL58mRs3bvDcc8+xvLy8699Nr9OTwjQVKPzRxTE3wxBVUVgbRVzprVJRM1quScXUOD7vcmtlhfWNdY4cOiwF4ZHyJ2GS87nLWwwDmY9ujyK8MGWYF9RNwXsPuzy3t4EQgqyUPhFC5klNVRmFCV+/OUBXVU4sVtnyEnpezCjKCJKc73tukWeWJcZKVRTp4JPdgRUJ4EI3wDY06rZOzdZpJznjUDrjfMvhJieX7r0Htze8a6OIAnBKzN5Sw6SiJgzCgvmqNZPE2TUUBS9MidMM25AFpaZp1B2VqqWxPokfhZtWCvYLgiTFLvVCVUVDUQWqpjxwsQByhZ1kBaMoJRcFddtiquefFYLFhiMLr1K4fLcDvr4yZnUUS1xzlFGxDOYqOmkhMFQ4Ou/eg2lGuWMUYFUb/PHKbQZpQF7kDMOCURTg6PLaLdZtnlpwyu9dlKL2GkVezATybw8j/vOpdcI0p2JqhLmCLwwudwPmqiYfPTnHh48/vAB8tyaA32iv82+KAvDuKIqC8+fPc/v2bVRV5cSJE0/sXEmSsL6+zuLiIi+99NLjTZKKwpsDhdTxaRdDqos2NzZ8NmKFnp/yXScavLi/uWPys929IxdweSvEMXXqjkxOnUrOOErZ7I95YbnCicUqGxubrK6tcmD//tl6fJrkrm8FuIaBbuioRc6BpsaeusXaKOTgnEunshPfuH0FPGXNClFI4oaiYOoKczWrBDUruxZ/20P6ZBb4UYKuSAyjopYPJuXhiSnPpazEOEwpCinbUjWl9E2aw3J9W2La7fWF4OJQYRDIlUgvSGhYUt8qJqdVFTy1XCUMQ7a6XVRVpVK9g5fTdI0LGx6ffLNLlBaEaYGfyvVMyzXIC8EHDtZwDGlppCoKuq5Jk/e8KJmCgv/62jrX+gEtW2cQZsRpznqSM4k19jVtvvvEnJx+brv+mqKiatKxYODHfOr8FrkQ7GvaDMIUL8pIcoGmKXzkxDzfcri57dpxj8ZXL0g5vxni6CquqVN3LZRWh0ksxXE/8XeeoanF9Ho9Lly4QJIkNBoNOp0O7XZ7lqzezQngX4UC8EHxdiaAb0X4fnsB+CRiZVJwvhtxYn+dw3MVzq9scb4vCQSLNYtXDreIB2uEQcCJp07gus42YXuF2+OYQZiz3JCwlrprMvQT1oc+LSPno08vYNyVY5QypxRFwfoowk8L9jZdOSFq6HSqplQnKODwXGWH7uDOQYNCmOSEcYZV4phVTaOhaVRNWXzpj1AEKArEaYEfpSWcR0h7Mk16Gj8s4qwgTHK2Jgl1R6PpWli6QpBkOIZeQkbUHSzX7dELci71EoahlD1xTYO5qo5ravhxygcPNtHKVTFwD846Tgt+9/V1Lm76JFlBN5HHqVkS6123DZ5ZqpDm+YzQYug6uqqR5hmKonBhw+MPz3bJi4KKqRGkBaMwxYslA/oDB5scajv3YJpnTWpe8KVrA24NIjpVi7pTMIwKwiQlygWH6wovt2NuXj5PtVqlWi3JfqZZPkcUNFXh67cmBElOuyLJjkqlRapbTOKc73yqw//ru4/sqkN5d7xbGMBvpAQMfBMWgGEYcvr0aYQQvPTSS3z5y19+IlZJQghu3rzJ6uoq1WqV559//rGfYxTl9GOw8x57luaxTAOCAUtuXcoNtF3sB0y/krQgiCUoeSoZ0dA0arbGZDJBU+H6jetMxhOOHz9OdZebSQBelOAYChVLWhuZuoqmabvgau6gpCeTMVeuXufqUGVzLAjjjHbVpm5Lm50oKzgyb6OrqrRw2uX9x2nOV2+M6PkJkzjHNRJars581cCLC/Y3dZYaVimKrc7AyNPIcsEnz3Y5vz6RshDjiF6QULd1HF2jYmqcXHJniWk3Y/ZTK2PODqFaUalaOkEm6HoJ4yhjqWHxbcc6HNkniQaikLR8z5/Q63a5vbKCZtp88kZBkMOhjkPfTxmFGXFWMIkyPnJybsdKYer0kZZ4Rk3TuNmX6/umbWDpKnVHsqe9OKNu6/zYB/ZKXcK7IhcFU6H/K1sBYSZmBft81ablSl3CIk156UDj/pPQUiZhcxySZtIvGEWh0mjhVi1qtvwsQtWYn59nfn5erqrDkF6vR7/f59q1a2iaRrvdfuLsuGl8MyTIJx1vtQAcDAacPn36kYXvp3nj7fidP0p0g4K0ELgljrmphDy7XGfDi+m4Ov7mDQzD4MTJkxj3vFeBH6dQ5CgYKKqCicJCzSJNYsjye4q/ez4f0iJzVJLTdE1FVzVpj6jkO/DR27vNoii4ceMGt7bG9MYqfqrQrpp0qja2rhJlBaau0apaDyy+rm0FnFvz7mgGOgaLNVMKEOeCI53KDA5zt+gzwI1ewCfPdvETKYflpQU9P6NTMcgFPLtcpeWos+ZSK+VTpjk3iHP+/EZIPyqYq5j0/AQvSvBiqc96ZK7CBw42dmL+yrw09eF9fXXM5W5A2zVoOAZbQUYQpYyjjOMLFb7/2QXmqmZ5xeR3l+c5WZHPmLdfvzUhzeV7EICfCvwoIc4KPnCwyXef6Nw7NVR2FqNvrHlYuoahy+vnmBpprrE1jjixVOOV5/dJ32Jvwng8Zn19DV03qNaq1GvSLWltFMxwp6qm02q1UFQVMYoAHqn4m94f74bKgeu6fz0BnEa32+X1119naWmJkydPzhLj415fZFnGm2++Sb/f58CBAwRB8NgvQlEUXL1ymSSHaqOF6dbobdxG1VQMRVoCPcxWaBynTKKMnp8w5xq0axauoREkOYYK0aiP48gJqWXtnOQVBZxaGXJ7ELIyDNnyE5qOyd6mRZQVWJrC3qZTqr8rM20tIeR1uHnrNlfTGrfDmDTLWI9jupOEmgU1x6Rqm5xccMmKYlZ8aSUmpRDSw/Kzl/q8sebRqZgUSLmSlaFcEdR1+NDhJoamllOvO7InEmgteHN1yMVNj1bFpFUx2fRSJmHCKMyYmzP52DPzMyr/3cbsmqJSAK+vemgKtCsmTVfgRQWTOCUvBN95vLND+FlRlRk2hSUpvvzGrS3GyQhXLfC9DFfXqDYMorIwe3FffacwqwBlmuHLBNv1IrJCYOkaiqqiq9B2VWxDfs6HTVGnxy3ynLzQUAGhKOiqhqbm5IhdXQnuDkuTD5JBKIWfWxW5GotSOQHsVO4wyRVFwXVdXNdl//79FEXBaDSi1+uxsbExg0202206nQ71ev2xJsypTdI3UiLhccXjkIGZNqwXL17k+PHjHDx48JFz1pNkAhcoeHFOz0+wyPA9D13XyLOMfm/A88c77Nmzd9dcl2YFAz9lc5LIqU3VomnLvJjksGAp5Ypcrvzuji0v4fTKkK6fsDqKqLkGCxXpTjQIYp7dU8O1JHZQCIGKhBolScrVq1fpBgVvei5hHssCrB+xMQrpuAaqpnFyucacq22b7OulLaTcNmyMY/7k/BZxmjNXMRmEKb1JzChMaZpwpGVwYrEyg8PAHdFnBZU4zfjs5T5+knNkzqVfbimCJGcQZHznUx1ePdK6g73jTsEkc67KlZ7HICpoWwqVqkmzYjH0Y8ZRxp6GzY+8uHQvxKbMS9M74uKmj6aq2KZOnhfsb1gkFYMtX2o37r9rhb09x01X4eujCLPENANUTUHFsNjyEkkqe4R7tSgEQhTSuaN0SjHLLVEh5Pue+RaXZD/f95lMJqytrRPHCXGg48cSLtSZa8jiTwiEgIXao6t5vBsr4G+GDcc3RQEohODixYvcuHGDZ599dsb8mya4x1kA+r7PqVOnZqSSbreL53mP5djTiOOYz3/563z+VsxWpLCyHnKjH6J7m+xpSF/EuarJnGvOtNmmYqbTuNkP+fNLWwRJRpjk3EgLNr2UxbpJlue0jZyWY3P8+DE0TZNsv+nkCzi3MeFL1wa4lsZi3WIQ5KyNQwZhzIG2y/sPNFmoWZKxu81QfTIeEYYhWmsPt6+OWWxUWGwqbEwShn6ElxZUjYSDeki4lbIZy1G8Y9vk5fVSURjGOVf7EXVbgpobjsQOjsIMQ1N4qSl2xcZsB1pf74WAimPqUkagpZNUDTa9hMMdh0Md957XT6NAMC7XpIZaklI0jWZFULNVul56X12taRimQbVWR9c8XMdBJZeCrVlKluTkQmFjs4s538R1nRmL+u5cpyLXLFueJG7YhiSRxDk0HQPX0hGlKO2u91Oac3sY4iU5k56UA2rYKpYuCJOMPRWVqm2iKXLlPZ1+bo+bvZD/fGqNKJUTm1BxSQcJnYrAT3K+/9mFe+AAOz6DqtJqtWi1WjiOw+bmJktLS/T7fc6cOUNRFLRardm6+HEw2zzP+4YnyCcduq6TpukD/2Z7w/r+97+fVmt3GYz7xZOaAH71xpBTaxFrk5zRpS2MsMe8mZFEEaORx/ueXuTA/r0o2h3s3fS2TLOCP7u0xeVNn0II1kYRPT+l6erULB3HUNlbVWbFsabJxicvGc1xVvDpC102xjH7mzZro5hJmDLyU+ZrJkfnKrzvQHMndhBZh1y+dBHbrXB7ohMXEU8v1+kHGVteLJ1+woxnmglLeczKSlz6klfvlKDlBO3CZkCYFDPB9E7VYhwmDMOUwy2NV/Y5uzZ304Z3YxzRD3NaFQtVVZirWrQcAy/OSXLpHHI/fPTU17vvxyAksUJBxTIUFuompq6iwAPx1dMoymdPlueoZcFlmzpamN3bWApxz0auKAS6ClteigAp9q3IplRRFBoVU25mHtCjXukGRGlO15Os47pt0CgVEnQFDrYsDF1HFNLZSSjscEvKc8F/Pb3KWjAmzgVJkBL4Gr4yAUWj5hgSZvOI8W6sgKcYwG9kfFMUgKdOncLzvHvwLFOtscfVvU4Zc/v27eOpp55CVdXH3h0Ph0O+/vWv85WhS09rsbeyQWzZ3Li1QuAFjMKUI/MV3n+whaHv/Gzy/Uj/wq9c7xMmOcfnKwyqUj9vFCRsjEJO1BKOz+nMz5euIULcmSIIQFU5v+6hK5Is0bQNOlW5LgySnA8caPFiKco6jSzL8QOpS3TixAk+d3XEtPgSQnCo7RLXTdbHMc8uV/nw0SaTyZjxeMJmdxNN1ajVqtTrUtdp6CfEaUa9aqKqKqaq0NHlGtaLs4eKooJsDPIiJ82yEisisEwdQ8sQj4KMRirAj1OwA+myoalIULKu0XRNVBR2X2DLou1GP2Qc5vR8n6pt0HJ0Ko6BlyUsVlQcNeXmzesIAa7rSvLMNhmVM7cnfOrCFmGa48U5WphTNVUqlsQIvri3NcMl6arER24Xoi4KwW9/fZ1Lmz6WrhImBZMoxY/BNVUalsoL83cLou4kgMRpzv95eq0Uq7YYhinCqeHFGQjB9z23wP/yrQce6fuEOw3Z8vIyy8vLCCHwPG82Hbx48SK2bc+KwWaz+bYauG+GDvlJh6ZpRFF03//f8zxOnz6NaZq8+uqrM4HztxJPYgJ4edPjd19bQ1XgaFOjG2bc3uxzu8hom4KXjizy/OEleR9n0/ehzKZxl/seV7s+C1WLharFhpfQ9+PSNcPi5b1VhNednS/P79zfiqKwMozp+lnpzavQqNgM/YieJwXS/6f3LM2sFqfheRPSNJNWm26T3o01qcCgacxVNFqOgZ9kBEnBd7y4SE3LGI/vSJVUKq4Umq/VsW2LnhdjaOWgQoGKpeIaFihgaVII+kFRIKf6aQaGoklNVV3DFgpZlD58qi8EWS4Is4JBCIqeY+kyL6a5YO4h62uQK+h+kNGdJHIz4xq0HZ2syNEUONh2tona38FZTw8XxDm/89o6m570HPbTGFNN6FRNkqygXTE51nEoBOUKW0UU7BCivrTp85+/voaf5mgqJJlgaxIzDiUR5nBDYV/DIp1Nyu8lgHz15pDTqx4VW8cyBJ6wKDSdXijYU8n46HxM98obFEOZkxqNxgMnfH89AXwX48iRI1QqlV0fEo9DJ0sIwaVLl3ZlzD1OK6Zbt25x/vx56suHmExS9lcNNnyF9pyJMlQYaNKi6Duemtt12iKBzdCbxAyjjE5N+l52KipNR2eznzMMIl4+sZ903NtVs09RIEoyxlFa4gsVDF2nqWs0LJ3VcYRjajuKvyiKuXz5MqAwNz+HZVmSRJDlRGmGpesIUWAZOoYhpxXSmqxDu9OZYecmkzFra+skScJI2EzCnDDJaDgmdUdHUxXirMDSdSq6TAT3cyW62QtZGUVsegnDIKXhmsxXjRKiKDjYckoLJ+Ue7CBAd5Lw389sMIlTglTh1jDG1hPmqyZhWnB4zmGhalCIYibHIoS4kyyF4A/e3OTs2gTHVMniUmU/TKnaGp2KyUeeXeRAx5UyLEHIZDJmOBySpSmXL10i113+8GJAKhT2tRy645goLxhFUkPsW4+2eXlqiq6wQ/5mKkR9Yd3jypZPzdEwNYMgLZiEKWFa0HIMfuTZJrk/2PHZ7yaAXOuFDMKMumOgKoK98y3MZpNhIO+R//U7D1O1Hj0V3N0dK4pSPhhrHDp0iCzLGAwG9Pt9Ll26RBRFO8gkjyJ9MF0Bf6M75McRD1sB3y//rK+vc+bMGQ4cOPCOVBCehN3caytj/DhjT8MisgQVNSA1M7wMXjq2zIefWrhH1mj7NO72IERVVBxLTvf3t22Waibr44gDbYe9LZub490LICEE4zBBFDm6aqCqKpYqJUIsXUJathd/QsDa+hobGxuoqsLS0iKbk5iiyIkSgV6qL+iaimMaxFmCoihUqlUqVSlVksSJ9L0tC0JUjeHIYGMsvW0broWtCwoEQijUbf2B1z3JpHh2z09ZHcdULZ25ikHd0hgGKYs1i8W6LaVmhNihOzj9Dj57qc+plTFRJgjSnFES0nI0TF3qAz6zXC3X12rpy76ziLvVD/kvpzfwYrkNiXJBdxwz8lMajs4zy1WOzlV25BKJKZ1iEeFzV6T9Xqdi4hg5gzAjyQo2JzFPLVT4gfcs4pYOVYUQFNkdAtCUlPL5KwOirGC+alIUgklc6qsic+ReejvvfUUhLwR5kc2Odfq2h6pq0qrPECzPL5OgMQgy/tbL+/mfX1qk3+/T7/d58803yfOcVqs1g7DcvbF4t2RgvtH57ZuiAGy32/dNUG9XJmEaSZLw2muvEYbhroy5x7EeKYqCc+fOsb6+zvve9z62Movo/HUqDbne9YYD5moWFVPFS/JHAqKmWYEXJqiO9DocjUaIIqfdqFOr1RhM+nJtuEvEWU6USFxOp5LTdE0sXSHKCgxNp+GaM+md8WTCtavX6HTaJEmKqqhc2wq42vXZ9GIGYUrDNViqWUABhZh5OSqKBGCjckfXaQ+8uTLk1IUuflwQZRlbXkrFlNPITCh84EADLeiDItlyKDtlT9aGEb//5qY0gDc1vCRnYxQxDBLaFYMTC1WOLVR26A5O5QVkssz50/NbbE4S9jUc1ooxMSpBkrExiXnf/jrf8/QdX868EFDOF6ag5puDiItd6RtpGxrNVEra+ElOxdT50ZeWWayX2l6KgltxcSsuRSHI84xKpcqXrg8Zhxl1s6BIVJbqFmkhGEc581WTj5y8/0piKkR9axAghMAydBTAtRRcQ8WLpdh201bpBw+4nxQFL5Y6haoiE7hdbWAaKnVHJ8kK/Dh/SwXgw7pjXddnZBKQiW6afK9fvz4jk0z/u5vTThiG33CbpHcjdstv2zVJn3/++Zlg9duNJ7EC7vkJjqGhKBlhENBbvcly08ErDGqO+VBNSwGEaYYfS+asIsAydfRSUF5hd2kwkPhmL8oY+ClpLmg6BnVLR1GRzV2zUmIrC4TIuX79Br7vc/jQYa5du0qYFry5OqbrSexh1ZbEtLZj0PNS5qsG8zVpCzmdVpmWSduSDW8Yp/ze62usegF+nDOJfCw9oOMa0r/cMdlTVcrfnIqmlnkpl1IlCMGfnt/izbUJdVtnEKRMolySwiyN+aolsX/biBuKSslIlvi9K1sBX7k5wtIU9lQ1+pEgKQq6Xs6eps13nWhzdM4pv2sxE6OfEUBUla/eGuPFKYt1i6KAcVwwDhOyQvC+/XU+cnJ+J4u5hCrluVQ2EErBuQ0fx9CxdA1TU6jZOmGS48c5rx5p39effUpKidKcjXGMY2plDoemo9BwNPq+ZCIr8YNJoAKBF6dI1LeKYTlYto0F+LG0EjRNk6WlJZaWlmYbi36/z+bmJpcuXdqxsWg0pOzQuyED89cTwIfEO+lep6bojUaDV1999YlMGKMo4vTp0xRFMROqvnC1z+Y4YnMSISYpTjGiYlv4aU7NNmnYUtNvtwTnxTmv3x7TnST4SUbF0nGKiE5FR5gV5usOc1WLiaaiaco9opzr45g/PbfJMEgl5i7KqUxiFmsWaV5weK7CQtVACMHW1hZrq6scOLCfZrPF9RvX2fRSvri2SZAWM9ze2jBk4CcsVE2eWqxydM7dqSKvlKsdCkZ+wpduTEDVeXrZYX0SMQxSJnGBKCKebhYsIIiQxbm27ZpIhXyNM2s+kzhnuW5SAONYMA5iwrTgueUaHzk5fw+2Zru8wJafsO4lNCsmhiJoWgpu1cKLddJc8G3H2tS3WedtjymoeXUYkGYFLcdEVRUqpopjaPhJDgKazv3wcjLBttot3F6Baaa4jlxfpGlCkRdohcAPBd6k1IF6QEOgqyppLvCjFNvQZnI8BUjs4MMY8kIQpRIztTGOqbouDVMm5UmUcajj0qm+NavDt8qQm5JJ9u3bNyOT9Pt9bt26xdmzZ6nVarNicLqaeZw2Sb/6q7/KL//yL7O+vs4LL7zAr/zKr/Dyyy8/9HX/6T/9J/7u3/277/j8D4q7808URbz22mtkWfbYNEkf9wRwGKSMgoQ318ZUiYj7mzQrFRy3gjeOaFbM+55TCLk+vtwNWB/JlW/TNdnTsIAcRQj2NOTkSyvZnNvzZFHA565sceb2mCjLGQ4kiaTl6tRtHV1TOLlQIc9z0jTl+rWrqKrK00+fLAX/4c8vdDm7PqFdMcnzmEmcM4ky+k7KUt3ig4daqAozqzOg3DZIotmZVY9b44x9nQqdtGBznODFKZteyt5KwrFWgppqJBhkWUZRTrqkzqvGxjjmcten4ei4hkbLNRmGCaNQFsN/88WlGa5we2TbctzlrYC8UKhVDfwiYZ+lI1SDnh/z1HyFF/fdx0JxSgDJc271A1xT2kGiCpqqQtNx6HoJddu4DzlNzD5LnEl7ULW8RoqqYQCarRKmOWn+8KbDKPNIGGfoCliGPoP3KKqCY2oU4YNz3DjMUFFm6gzzValikBYSj31sYSdWfPvG4uDBg2RZxnA4pNfrzTYWIO1U5+fnn5hWn+/7bxnP+7jjr2wBuLKywrlz52am6Pe7gO8EHzOVZOh0Ojz77LNomsanzm3yx+e6RJkE/XvdMRU1YakhECg8td9FUQRFwWyKlpeaVkIofP7SFle2ApYaFquDXDK6FIXcMDnQNqRrBoJim6CppmlSFy8r+NLVPoMg4dhChZ5v0PVSJlHC2ljwoSMdXj3aRgFu3rzFYDDg6NEjs4esoWlc3pT2aMt1i6JqMIpMRkGCn0jXj+843ubuvCBZbnKKcWsYMYlzFuo2CnCgXWWhljLwM2xT5QdfWiTwxqwFPpcvX8E0jRJkXaNSqVAguD0IcHQVVdNQEbQcaNkO6+P4AYnpTiS5IM8LVEOdPTxMXaemqAyDhPQRLreuKqS5XDW5pnywKEhtRtdQMfTd30NRyM4xzQpGZWcfJgU1x6RmSus2bxKzVNVYvb1CVuS4boVaVSYkcxub+2o34MvXhwRpgZfEErdoq5i6RpoVvLCnRlEU6LqGqWnk21fYZfzJ+S0+f3lAIQRpLshxiLcCqpZ8+Pzdl/agP6I0wp3PWLxtUtZ2MsnRo0dJkuSe1czly5e5fPmynFa+Q+ef3/qt3+Lnfu7n+PVf/3U++MEP8olPfIKPfexjXLhw4YFuP9evX+ef/JN/8lgKwEddAff7fU6fPs3c3NwsnzyOeJwYwO4k5n//8i0ubHqMvIDVKKEYhOzv1NDTiPmayd66PTuftHpTZjaPtwYhn7vcpxCChdJvdm0Y0vdj9jZtnlmuc7DjEofhTHR4u+/01d6EN1cn1G2DtmuyOooYhQlbk4SarfPtx+Y41HHx/YArV65Qr9c5cOBAOe0XeJnCVS+k6ehSC9OWK9dBmOIYKt/39BwL9bvuOWUnpOJiN8A2dWxDx9AK6uXUa8tP+daTHY43VTbW1/F8n7Nn36Rarc5ynGmZbI4j4qyg5RooqoprKdgGNBydJBOPNI2Pk0yil8sGUFHALcXd80dQBKDUzRsEKbqq4NgGkjqnlu9JL1kzO19WzLZOCoMwIcsLen5KxVSpO6ZUqUhzLF1jX9uVeqi7iNqDfF794dku4yjFj3PGcYZtaHQqBl6UU7N1js27XB8KDEPfVe+15yX8//5yhe4kIRfgZwppqDIuQixd4+ml6kOdP3RdZ25ujrk5uZEZjUZ87WtfYzwec/PmzdnGYjohNIzdhwdvNYIgYN++fY/lWG83vikKwLeLkdkt8jzn3LlzbG5uPpJv8Ntdj0zxftslGdZGEZ+5tIVrqnzbsQ6XN0Z8+bbHBJWak/NdJ+Y5uShXWrLwu/O5FEWl6yesjBI6VYMijpgzUuZcl3EqaDg63/vsIq1Snl165coOZ/r9DIKUrpfQrjpomsp8zaFdMfEiCz/JeH5vHUdXuHLlMmmacvLkiR2g8rwQbPkplq5LQLKq0K6oNG2NtXFM3dJRKU3IcwnqVhR1xwQrL6AQeUnlVxCKim0aVHI58TRMk05njrW1dU6cOEEUR0zGE1ZWVmar0yQpGIY5qiolZ1RRUCiAqlKxjAd6EQkh6HqSEbg5iaWYaSkvMIlS6rbBcsPZpl94b2K6thXw+St9KUAdZRhaRsvRcC2NOMl4+UAblVKyRlUk+7pc7wgEuYD/89Q6F7qSXR4kOUEaMdAVXF0KvX70uWWWGxZRFDOejJmMR2ysr6EbBtVqjVx3+M+v9fHjnLarMwwy0jSnm+XUbcFze2p8y+Emo0EfISAp7wFNuSP4ujIM+cK1AZoGS3ULP4XErZLlAktT+Wffc5QPH3/rvtp5nu+6tn07sdtq5tq1a3zqU59CCMFTTz3Fxz72Mf723/7bfOd3fudbPv6//Jf/kp/5mZ/hp3/6pwH49V//dX7/93+f3/iN3+Dnf/7nd31Nnuf82I/9GP/iX/yLd/TZHiWmMjDXrl3j8uXLnDx5kn379j3WicPjXAF//kqPS+sT2mKM3dG4sZmwKmBjEvOBQy1eOdzGMe9Mh7NtUzRN07jUDUlywXLDohCC+arNMIwZhRnPLtd59WgbTVVIy/wG7Hjvt/shBQpVW24xjsxXiZKM9XHEobbLyaUq/f6AGzdvsGd5WRI+yq+yKGCSFERJRtOxQFWpWhZ2KbSfZAW2oc7y29TDWFGUHTkuyXIofcpVVZLTKrbKKMoAhXq9ju/5OEXO/Nwc48mE0WjE6uoqpmkyyG2iJGPLU6haGpYuC9y0ANvQZ0SO+8W0YO16CZM4w9GgaRVkWYYoBPtbbrm+3rZ23hZpVvBH57p0JwmjSOY420hYrJn4cUrV0jjScVCUO3Z3eT7NlfKaXNkK+J3XNgiSgkLILY0XR1RMDVNXeWFvjYWKfsf/eBcCyJ9d7PG1G6OZ93OUC/w4J0kLlhsWf+P5RTkBFHLlfEfvVUqFCSH4s4tbbHlS87BWCCKzQaxAmBR89OQ8//A7DuEYb62Rmua2559/HiHETP7qxo0bvPnmm9Tr9VlBWKvV3vaq+JtB5/SbogB8ULwVDGAYhpw6dQpFUXjllVceSYpi2h0/qth0URScPXuWzc1NXnrpJdrtO93F9V7AOMp4akGOjNtazMG6SqrZNCsWTy/VHiCHJBgFMUmaEmcJaZayZ2EOrfTzTbMCaxutTM6jdhYvRYkzSbMMU9VLv0qdiqUQpQVRknD+/BVs2+bEiZOzQmEauZDFXS+SrV/dNTDK5KeqGo2KjWHod/SaBBTFnWQZZQUrw4Cel7LlpbQqNh1XwzZUxlHK04tVXNPYZuF2x7N3r9jD2A/5wzc2WBvFjJJCqtrrAYsNi6RQqFkahzsWoOxQkN9exP3FlQFfuDoocYWCfpihFgrJQJrMv3yogaaWmJjSIUPT7hRx4ygrySPSnaDrJcRZzqaX08x13rOnzgcPte6sUqYSOmVHrSkql0cpF7sRdUun7RiM4oJRmJDlgk7T4Efeu8xyiY2Z6lqxsECR53iehzfx+MvL6ww8Qd2Sqvtu0yFMM7woY3/L5u+8b7lcjxU77qkdxuwbHmmu0HJlN78w18Kp1xiGEvQtcUZvPZ4UQHq6mvmpn/opTp48yY//+I/zr/7Vv+KP//iP+fKXv/yWC8AkSfja177GL/zCL8z+TVVVPvKRj/DFL37xvq/73/63/42FhQX+/t//+2/7s9wd97O7BLn2vXHjBi+//DKNxn1Wd+8gHtcEMMsLvna1SzzuMT9XZW+rRTrZwqorZKbF8fkKrcr9pyN5ntObhNiGAsjfS82BqmWjKpIIcQcfrezanEmP8pw0y2drWccysAzJaF9dXWVjc5PDhw7TbN77XeYC/CRjbSSoOwYVq9yeFOBaJjXXQilzmyglZ+QLZcN7vS83HKvDiK4X06natF05ATRUhT1NG13T0DT5nVu2zbw91a3LefNWj69cGjAOM/pBKqf6lkKzYuHHBS8cqcn1t6KgqKqUz9nGmB0GKb/99TU2JjGaquBHGR6CSaxSS2P2NR2eXqzM1tfTvDTF7wkEX7g64PTKmLqjoyjgJRIHfCsL2ddy+L5nF6g7+k5/91mulA3/py/2CLOcpbok1Y2jHD/OiPKC756K42+XirmLAJLkgtOrHoYumb4VU0q+BElGXgh+8PnFmf/x9hw3lb/JKSgKwcXNANs0pBSaDsvL8xRA10t4eqn6QGmr+8U0v02L/+nGAqTE23Rj8frrryOE2CF/9VY2Fn/NAn6EeNQJ4NbWFq+99hpLS0s8/fTTj1yVTx9kj1IARlHEqVOnEELsWmAKBFEq8SSODsPhAENXQZPK5g8KIWAcxGwOPSxNYalTR5QPjTDNaTkWri314iQObPs4XnZ1lza9UlQ1o2brLFSlgHLPT3D1gsHqdfYuLbC0vLyjqxYCgiTjS2sZa+OUUSLo+zEVU2NPyyHNoWHrHGzbqKqKYdwxmM8ySTBIs5w/fLPL9X6IY6hM4pyNccjAV2g4BnNVk5cONMiKnCKXPseaqmJoEseW5hlnNiJujAuWWhXcSCbIIM250YtYcgXvWXDJggmZXtvR1aooaLrK0E/46s0RhqZyoG3iRRl9P2ES5SgofP+zC5xc3NZxKdIhoySToSgKl7ZCJnHBnGugqFCxDbwoYxRK7+MffnFx1+mjBFrLFeztUUqBgmXKzrblKLQc6SJSs/X7AqNVTaPeaFBvNLD7OnpvgKFJe7g8CdEUObkL4wxRFCiaVmpt7X5zqYqCKHLyXE4F7Vpjdu+8k3i3JBJqtRrf//3fzw/8wA+8rWNsbW2R5/k9JIrFxUXOnz+/62s+//nP8+///b/n9OnTb+ucbyUmkwlnzpxBCMGrr7762Kaqd8fjUlK4efMmaxubmG6deqvNcNBDRZFORbq6a8G2PcK0IM0Lbg8jkiynUbGwNUVKhGgqjYpJyZKQBfNdJLeVYcSNfsj6KKLvJ3SqNgtVY7YFMbMJo2HCc888g2FZM1cj+f7hUjfgkmcw9CO6E0X6cTs6napFGOe8d18dQ1MBSUSZOvqIsuG9tOnzJxd6xGmBoSlMEvD7AT1P6py+Z0+NpZrUac3zQjbg6pQsl+Ongr+4FZKpBkcXbFZHIWGS0/UhSjyOt3QO2BG+5+G6FRQxxdsppVIBnF7p0fUSFmsW8zXBKJRFdVrA8fkK3/vswox1C3fy0vRLyIXCmTUfq3RSkoWXwE8y4rTgIyfmZoXXjihzZZrmjCJBP5DbFEXVcEwV19TIcoNRlLK3aT8QpiMQjEIpE2bpktiiqiquJcXx+yW5Zxpy03W/fCOkjmEBTr2NoqqoQg4w3m6ae1B+syxrh/zVZDKh1+uxtrbGhQsXcBxnh/zVgxrlvy4Ay3gnK2AhBFevXuXq1as888wz7N279y2dW5tNkh78UNsN77c9rvcC/uJyn+u9kOu9ADf3aBCTFQV+lvL8via6LrvN4i5MhBDwpcsb/MWFdZJCxc8VvK2QliNH22kueGrRLWn4Ui/OKFXpp6///JUer6+MaTg6aZEzjHLGUUDTT2mYgkUj5GDpFSzKomEqMZBmOV+9MWDVKzi81GTox2x6KV6ccWVjwqGGyov7mqh5ghD6juuh6TqmqnJ9fcytYcRcxUTXFMZxxtBPGMcFLUfnbzw3P7MTkiEnaGmJHSwEnF0PcEwD19JwTY12xcSPMyZxxnedbLPPzRkMBty+fRvbtma4Gtd1KTKJLwoTiT9UFYW6Y+CaKr1himXpEmj+EDbZ1PtYZg8p2NxwjBJDx0OrJ4FAUxSKXJCmOVqJHVRUFcrv/GEhhBRRjXPBJFNxLYOKKScBXpZRURLOnzuH7TjAHXuo7e9tEmVc7wdSmyuJqdYbOBlYuiBIcr73mXb5sHvr8VfVJmkymfDjP/7j/Lt/9+9meKAnFaurq7z55pvs27ePGzduPDZc0W7xTlfAeZ7z2pk3+PSFLWKjzpVewpq/iTZeo20pjOOCTk1jb9Pd5pYhm7xpjMKUT53vsjaOGEeSoFYZxSw3LLIC5qsWy3WLaWNoGsasyVVVhc1JzJ+c3WRc2q2NwpRbfY+ticSMNdWYRdvg2PETs9w4xUbneU7Pj/nclT6m7fJsXWWlL7c16+OcKIp5fsnmULUgTTMMQ5+R3FRFQTN1QOH07U3SHPY1LeLMYBDmDIOEohC8fLDOywebO+5XIZixbxUFrvUiJnHBQtVEAY4t1PGilH6QsFAz+cHnGkzGE27evEleFDNccL1eQyDvj2tbAaahoesqRSFouyqOkjKMBPM1i5r9gEe6ohDEGVGayaIdOWV0bYFtKHS9pFREuH8I5PUQQgrU6yWxRQCKJjdFjwIp1hSFPBf0kxTXyKV4tCqPaeoa8/XS/7icGu7mJPPG6oQ4FQzClHGcs1i3cQrBJM6wDZX3TyW23mI8an5TFGW2wTp8+DBpms7kr86fP0+apjSbzdm6+O589iRXwJ/97Gf55V/+Zb72ta+xtrbG7/zO7/BDP/RD9/zdN0UB+KB4kFVSmqacOXOGyWTCBz/4Qer1+q5/96DYbpa+WxIWQnDr1i0uXLjAU089xYEDB+55KPX9hN/88i3WxxHH5itc63rcXN1EUwqqquDIvM7J5fqOwkkpRVERgjevrvAXFzaoVlwOLFW4PZLM2e5E2uh867EOzyzd+WxZkcsfqipv1H6QcnkrpOHoVC2DdsVgEKT0vATyhGdqOR945thd3YYs/IqiIMkyLndDqpaBY2hYDYdOzcaPcwZ+wsuHKzSMhCtXrqCqck1XbzSoVWvS9inP2RzHCBRs2wAUWppG0zHo+wmOodJy9Bm2Ztdrmcv3oZcafIqqYalg6VI7UDcMFhY7LCwukGc5E2/CZDzhxo0bCCGo1aoEmUVWSA0pR5dTLwWJQ1Q1Zacv6C5RFIIwkYLNeRFTtQ0qplTUT7KC4wtOORm4v/Xa2iTnxlgWrV6c4VoabdcoAds5Jxcq2+zuil31vX7/jU2+fmtMmgmiNGUUZVQMicmsWAYfeWEPy1UNbzKht9UjCgMunD9PpVajVq1hOi7/8cur3BqEM/mfUK1wvRdQs3UOdVz+55ffWqO0PfI8f1eM0t9pdzw3NydZlxsbO/59Y2ODpaWle/7+ypUrXL9+nR/8wR+c/ds7kaDaHtMVcFEUnD9/nrW1NV588UUajQY3btx47HaX20NVVZIkeVuvnW49vrKeci1vs6dlkKOysraBN/TpmgpVBd67r0HF2pmrVVUyebO84NStEbdHEYfbLi3XZGOSMA4TVgYR7zvQ5FuPdWbafXkhXSmmGGdd0zi/4TMK5XRJCBjGOUMvZhyltJSQDx2qc/TQwR2FQl4eQwjBzX5IkBQSelEUPLW3hRcm9PyElq3xLQdt+r0tVldWcF2XekM+2B3boSgkNKQfJNQdA003sFXBkp6zWNVZmyS0nLLwTbMZ4WT7RFQAYZLKyT0Acr1Yc8yZgkGz2aTZbIKQPtzjyYR+vy8bXsemVq2V2oUZoa5im9pMmw9FxXgkeTFZnPd9KbFVdw1MTSFKcwxdY6Eu8dG7YQfl6wuujmEcZURpgamr1CyVpmMwDDNajsGBlnNff3eA28OI/+NrawRpTpQWhKnUWG04BlkuOLFUYbGik09tRjUVw5DblOl7Or0y4ndOb5AWBbqqIAyHblAwTnxarsGPvrSHI3P3d4p6ULzd/GYYBgsLCywsLMx0TPv9Pr1ej6tXr2IYBp1Oh2q1imVZT9Tq0vd9XnjhBf7e3/t7/PAP//B9/+6bvgC8n1XSZDLh1KlTuK7LK6+88rbXJ1OG2W4d8oPwftvjzO0xq8OIpxarqIqCnXvYnsWWl7LowisHKlStnTeUKARJlrKyssLZm30Mp8pypwpCcHS+ShBLkO9S3eZ9B5r3nHNahBZFwdYkIohT9jRsVE2joqlYuoKahcRZwfMnj1Ot7vwxSPxeIVegJUtPVUojEU06d5i6RpBkVKs1Di/XKErB5/F4zPraOjfiG1QqFer1OkkiiNKMkS8LJ1WR322BRtW10HW9ZDrLHwZAnk+TpcLQT4jSnF6p/dSqmLiGlBOwdJWlhoOuaWRZLrW27kqWNzeHfPn6gGGQ0/dTTEOj42hULY0wLXi2ZVO1jXIid29iKgrB753Z5MzqhCwvGKQ5oyjHNeSqyDE03revKhPjTEtrJwFkcxzzqesRQQYVQ8VPC8Zhhh/n1G2dpxervLivvsPubuoNCgpFKTHx1ZsjLF1lsW5KYdW0wE8KFusmP/iexZkFnmVZxLF8sNdqNXzfo9vd5Fw35kZPoWJomLZOYbjkrkOQ5BzquPx/fuSZu6axby3erQngOy0ATdPkpZde4lOf+tSs+y2Kgk996lN8/OMfv+fvT548yZkzZ97ROR8UYRhy+vTpGYTEdd1Z3nmSBeDbnQAOBgNOnTpFrT3HwDBoq4LFus1CzUQd3WYrNymKgpO1hKeX732QTYXtw7TgZj+k5VjohkZHl8L2fmIz8BOe31e/536cki6m4uxrQwktmd53bUfBVTKSyGe50+TY4UM7hvN3Y/jk77a4sxYWgqpjkuQCXVfZs7zMnuVlkiRlPB4zHo/Z2NhAUzXq9TqmUyHNC4JU+hK7ll5aP+oYeoFrS+mb6TnDMMI0DfJMsvKzQjAMJZQkTKU2a93SUEvtwqPzVQxdugMVgOO6OK7L4uIiWZoxmUz44tU+N3sR4xgGfkzV1FmsW3hxjqWpHJlzpeWlqsrpY5bvaC5XBhH/5fQaXpwTloXXIMxoOjqFgJOLFZZquvR3nxFAxI6G908v9jk7VHAtWSQmuWDLkyzeTtXkY8/MYeg7/d3vvCc5dPjvZzbKqaeFF2VM4pwsF4yjjFcONfm+Zxdm24y8tH7Lc4nL01SVQsDnLg3IC8mkzgVQmyMoZB79mQ8d4G+9947Zw1uNx5HfFEWhUqlQqVTYv38/eZ4zHA7p9/v8wR/8Af/0n/5TVFXlt3/7t2k2m7z00kuPtan+vu/7Pr7v+77voX/3TVEAPmwFfLdV0nR9cvjwYY4ePfqO10S7rZkfhvfbHl0vRlflurAoCoh89jZdTC3GFgG72TGmWca1q9fIspQ9e/dy68aYLCtKELTAtQzcpEC5D65mO0ZGlFpv66OIumNgqoLReEQudObbDaruvWbe0+JPQWFtGDKOMjYnMU3HoFO1qNsafpJh6RpLTVl85YqctNVqVfbu3UMcJ4zHY167OeDLt0N6kULPS3FtneWaialriCLn5Lwr1fpNk+FwwM2bN1heXsIwpLPHtZ7PH57dwouldlTXT8qOUILCn1muslDVS4mTO7I3eSGTpW7a/MVqTj81WKwbbHkxcVqwmuS4Biw6ghcXJJlIoDFNTNsncefXRryxNqFiadQdh54nRWr9RNCumPzAcwscnHoP70oAUXnt9oQgLWi7BoZpEqaCIJY4xmeXq/zwi8sP8AaVcW7dR6Di2DoUgmVTJ0lzhmHKsTmX5/bsfNAWokDX9JknJsD5YA2UIZoCSZLiVi1sC0xNk8b176D4g/+xfDJ/7ud+jp/8yZ/k/e9/Py+//DKf+MQn8H1/xgr+iZ/4Cfbu3csv/dIvYds2zz333Ds+527R7XY5ffo0i4uLPP3007Pv73HbXe4WbxUDuH3rceLECbTaPP7VK8xXpGJAOBnRqRg0LJW1UYihPGRtWIjSwzenKOTmQ9U1Grpc1+326imCa8YEFoKen6IoCg3XIvQ9/CDEcSvsWdjJZJ/mtynpJkwL1icxG5OEfphK4oajY2gKQZLx1EITXdMQAnQd5uY6zM11KArJSt/oD/mj11fZGBaEuUJ3HFN3dPY0bAaBtFecMm9BcPXqFbIsZe9e6WmfZjl/cLbLxc0AAYzCjElU4JgKFVPqF76wrzYjbkz1UEWpuKAbOrcCjTN9qLo2qCleIhhFOV7i0zIVXljUaBjFDniRojJzS0rznD8512UUZuxt2kyijEGYEpUEjg8fb/OdT3VmhdfdBBBN0xhFKec2Q0wVWq5JvcRH+0mOqan839+/h32te5+TUiZMHmt9HNP1JH5QV6FZMak5BUEst1qvHmntxDCWhEFFkWzkrCgYh3Jtbps6iqJhWxb1Vg0hBJsTKdv1TmqCJ7Hh0DSNTqdDp9Ph+PHjfNd3fRff8i3fwo0bN/jYxz7GwsIC58+ff1chL/BNUgA+KLYnr7vXJ1OngXcad7Pkpni/ubk5nnnmmQfeDEkmpzwrwxAAI/OJk1gyywQs2frdZF3CMOTKlSs4rktraT/nLvdZH0X0vJh2zWaxYmBoKkGa8cLe2q64GkVVKPKCy12fz13qMQpTNicFph5ji5S5momimzy1UJHTQFWuQ+XaUa5pVEV6Bn/6Ypc0l/KbPT9lGKY0HQPH1HhxX4OWvR0TI7vwQhSYpkFsVDk3nuBUKuyzcza9BC9MuBIldByN5/dUONKRD47VtTXW1tc4cOAAnXYbVZG+x1+8PiJMCw60bLw4pxfIjtKLM77n6TleOdLelpjYKUKNZOZtehltV2pFNRyzxBlltB2Vb5uPiCd9znbXcByHWr1WrndsckUmmCtbUl7CsWThtaepk+YGW37CvqbNU4v3n0ZNlfZXR6EkWagaqqLimgJHN1ACWWw+TL8QIColJihKTJ+Q/sd6XJDugs8RhUAxdh7XsQwQkCsqTqVCvdEmyzLiNEVEKV/96ldnyahWq73lpPNukEAel03Sj/7oj9LtdvnFX/xF1tfXefHFF/nkJz85I4bcvHnziX8WkAXgiRMndtX9ehJWbdvjrbCAd9t6XNvyGfgJG+OYpZpJ0O1CIYgzgWPq2Pr9lZnyQnB5y6c7jukFaUm6MJmrmgwDuYZcbkhbx3zbxG66yo3SnM9e2eLWIKQfJAyCBEsZ07IEhu3ScS0OtOyyMZTXMctkc6sqKnGW84dnN7jeC7F0lUmcEcQ+W6ZG3TaYqxi8Z2/tTn5T2Zbvc2q1Gp+57tPPbfa3VTYnEZOkoDuJmYQJB5smr+5voimSIXr16hV03eD48ePYpaXmmVsDLm+FNF2DuapBz88YlpPA5brFDzw3v4MYJpn8d7zdNVXh1G0pKdV2TZqutIT0o4wgyXh+AU404dq1a3dEjusSDjKNzbHEddddC1WVuOaarROm+Uxg3zHv85wrG971USQxelr5PFGh4SpULB0/yR4pjyS5LFJlgS8ndrqq4powiTOSu8Sjpw3A9kNb+h3xaBVBpS3rgKyQ6/AH4iAfId6NDceRI0dI05Rf+7Vf4+DBg7Nr927HN30BOJWBmTpu5Hk+W588rpiuSB4F77c9ojTnP33lNl++3mcQpKyPIxitMe9KvJZraCzXNPJCrgFUVWUw6HPlyjUWlxapNuf4gzc26Hpy8jYIElZ6Pr2x9Jrd33Y4sVSbFWyyQ5UgW01RGccJf7nSI0xzTixWud4dMw4TIkXFyXXed6A+Wx/neYEQxewHpesaWVHw1RtDigIOdRy8qsEgyOn7MXFW8NGn53lxf2OnzIgoShavfLBc2vQJM6nrhYC5WoVhGNH3U47PGTxTT7l4/ny5AijYs2cvjXpDdqrAlhfT9zNaFbkeqisqNVsnLgvrAy0bVRTk2VTwdKcmV4FkLIuiQFcNFEXB0FXarlKqzEvG3vGnniJLU8bjCZPJhG63i6aqM3P3rCgQRY7Ii1m2MXQdXc0eCoyehq6qxJmUmdBKwg9IfE7LNXYR7tkZozAlSDLGcUaY5dRsg6qpkmcZIDjccctJhRS6nuoObue7nVvz+PL1IWFaEKQFjt5ETQp0TcMwFP7Wt+xlzx6NXq/HrVu3pFzRNpHTR4FSvBsTwMfJkPv4xz++68oX4DOf+cxjOcfD4tlnn31idpcPi0ddAU+3HsDM1eiN1TG//bXb9IOUjXHM1ZUNzGTIUs0iSHNOLLhYfsnq1/SSkStmk5tTN0f85fUBjqliJyqDMGcQBmx5CXNVk5cPtXAN9c60SZEFQa5IPMrplREXNjyW6xa2rrI2CPBSQaboPN22+Pan5miUrj5ZVsw2G4amoaoaZ9c9bvQCFms2y3WLQZjT8yOCOGehZvE/PbfA/F0T8el1EgJGUcbNoczPjqFSc82ZKkBR5Hxon0k8WOfM1gogXW/2798vr2l5nJuDEIGCa5uIomCxrjNfNel60pt8T92cYQfv1lVFkc+ZYRBj69I2U0NKYlUMje4ETEOh1a4z15kjCAKZ3zY3uXXzFq7rUqvVCLAQRQFFjihUKKW9bBSiLKF4CIMbwNJU8kLg52DEpde8gKSQ33e91Ga87zNTCIZBSpgUjMIM19SoWRqWIaXOapbOvpaLrqnyHir/o6p3pAviNOd3XtvAS3LitCDIFZJIY8EoGEUZS3WLDxx8Z1JK75YPsMSuywHP8ePHn+j57hff9AWgpmnEccwXvvCFx66Qv/0caZry5ptvPhTvtz2+cmPIV24MONSpsFS3ee3KbW4nMSsxnFyq8aFjHTS/NxOyvL26wsbGBocOH2K+M8dXbvTZ9GL2NuTYfBTZ9P2IUZhxsOPwkacXd2AHp3IHOSAUWPcKJgks1Wwm4zELjmC5WWMYFSzWLL775Px0iLRjJaKqclXdHccMS69fRVVlwWHpLNVN+oHEHz7IJUIIwShM0VRxxwpIE3Q0yeyrVqscOTLHtWvXiaKISqXK+vo6a2trsylcodoUQhAlGbp6x9NXp0ArSS5T/MjdmlyKopaC2oIgzeh6UkXfMeQx4rxgsW6hazGiAN0waHfatDttRCEIAp/xeML5G2tcup3S99XZ6rlVMUHIDvTYfOWOnMNdSvQg/+aTZ7tc6vrEOWx6KcNIroLzQmDpKk8vVhBCoKkayhQ7WNxx7RiFKf/fL62wOZbT4ygtiNOIka5i6yp7Gg4v7K3vmH7qqoamKLPfw8Y45j+fWiNKcxqOwSQpyAyXtXFM2zX43mfm+eH37sXQVPbs2SPB7ePxrBic2rJtnw7u1gm/GxNAz/MeKuL+VyWe9ATwUY6/m8pBkOT87mtrjMOUV4+0udz1OHt+jZ4vMdmvHG7z3n01Lpy9XTYl2ybzqkqY5JzdmEgSWMWiXbEY+ilbfoymKHzHU3Mcm7+ryC8xf0JIoMblrVBidynQU4+DTRMMm1GY8fKhFodLWMaU7DGd/E3diVZHIaqqYpbSVfM1jbmKzsYkpu3q9xR/20NRYBKlJGmG6xigyg1I3TGxDJkrFhb34BJx48Z1KpXqzBfeduwZQ1RRJBEmTjLMcnql6zqKlmHoWokdvFdXdfrfQgiEkP7LaS6oOQa6IjdCiqpSt6aMXoVKtUKlWmFpeYk0SZlMxgxHY07d3qTvK6QTsA2VdsWkamoMw4yapbGvhPkgSsHlu4q428OI//r6BkFakOYQTlJcHeq2QZDkvLC3Ts3WUJBwGBRR6g7eiT+/3OfPLvRKLT/BpNQftE0Vx1D59mNtNPUOJEZTVHRVLcmSgAK//0aX12+PqZQEmMKu48U5cR5ydM7lF77n6FsWfr473i2ZK3g8VpfvJL4pCsD7dQxTv1rP83jmmWfYv3//ExuTXrhwAcMwZp3vo8Rrt0bYutRAcgyVg5WM5nKd9XHMM8s1DndcVsI+RZ5z9dpVwiDg5IkTOI5DlmdsjCIM9Y5zQ7uq0nI1VkcxDce4hziyPRQUklxOxobDAUWR0262ZTGgRHLwdFfxN7UMmoauSXDyKEiouwaWroECRSm0/LCVZZRKM+8tLyHJCpoVk4qhlucUdCoGV69eATROnjyJrkucTRAEjMdj1ta7fG0tYnOsEucKjqHRruh0KiYDP6VTMTnQqWAZOoiCNJta5k2TZcaXro/4wrURUZrjRTm9IKNmqVRMOYF7z6JD4Y9KUeypmXpOoUKlWiXC5C8vRHiFiqlnRJmg6yUMg5SKoXCw7fDMUmVXM/WiZCueWhnzlRtDbF2lacEk00hzeZzlusX3PjM/E37ORTFjQkujeFnEfumaVOZvuSZNBJNE4EcJeQEnFqv8355f2oGNQZFs8DTLsJGr8NdXPcJUULd1VEWhPTdPZlqMo5z37W/wTz+6Ey+rquqMTDO1Zev1evT7fV577TV5T5YevZ1OB8uyZoX4u5EgDxw48ETP8W7G43Q7eqvxsBXw1NXo7q3HtS2fjXHMwbaDoansdQryOZuBKwlQ7z/YYro1lHItd45ZFAU9L8aPM+YqFqqiUbVlnpyrSRmXpmPcV1VJKfNQnGaIPGcQ+9SqVdxKFVEURMmdKd325lAtm8LZcQSESc4kTKhaBoICVdEQKDLfPSSiVAocj8pGuWEbmJpKkORULA3iMbc21jlw8CCtZhOAtCRtjMdjvvjGVb7ehV4AwyCh7posVE1AwjyOzruYpoGqKmRZvoO5XBQFgzDlv72+Sc9P8OIcPykw/YS5ikGSFyw3bBYdOT2eNs9TAohhGrQ7Hb7eFZzzMmwzJ4tzghTCQYitK9RtnVcPtdBVdsB8pg4gRV6Q5AW/c3qdLS9hoWLQncSygIsKcgHv2VPje5+Ra9gpHGZ6caYN79BP+PzlPqoKi3WTIMmZRClxBpoCP/ziMs8t7yyGclGQpOmsiAwSwRtrHqau4RoqFcvE7MzjJVLg+p9/7BjP733rSiB3x7uV3zRN2+HE9Y2Ib4oCEO5Vys+yjDfeeINer4dlWU/sYdDv9/F9n2azyfvf//63NF1Msly6ZxQC3xtT5Dk1x2QQpttAzAWDwRDHcThx8qTUqGKqESVmrgwNxywnaSCEQsUyEUJBuQ/AOimgF6SsDlJMTWGpVSUXoBRSxuT4Yh1d00izfNfibxSmfPZSj0EgE4s7SWm5Ogs1k56XsK/psFgzyx8w5NlOxw0vzvlvr69zvReQZoL1USwlFRwDXVVoOjraaBWzU2f/vv0Yhj4jblQqLq7r8rUtWEkUGo50/QjSnGCQ0ZvELNUtPnysja7eAcgrClilV26eF1zrTvji9RGqCgdaDl0/xY8yhqF0TfmuE3M8s2hy7ZqyE9TMHRu307cnDIKUhZqJwMKLCyZhTJQVHGmbvNSJuXrxPJVKRU4tazUsy5pJN6iKJH8oqmwE1Fyh5uqkucIkznj5UJPn9+2elLYny4sbnnQAKL0zG5agaTv0/YR2xaTu7P5TldgrhQJBz4uhfMApqoZTraPpOrmQXs4Pa55M09whcjoej+n3+6yurnL+/Hmq1epsMv6k8SqPCwP4P0I8SOrqcR3/fioH586dY319fVfbzFwI0rwgywWaUjDo9bBNnVoBcZbvECGXK9+duVNBOhCtjyX+rWrKHJAUUjLDMR+sfThKoD8O2QoyOhULWzEo8gw/KbBMXfqNK9OVrbIjxwkBr98ec3bdo1/imqu2zp6aBUqOChyec1EUmQfk5FHsyLevrYz5zKUecSmUPIkFPV1qswoUDlcLepsbHD56hFq1NnMxEUKh3W4RqS5nr+bkakrVzPCSgu44ZODFtF2Np5dqPLNUnbGlQeqqWmVDkGU5n728yeokYbluMo5yhmFeOhMlvLi3zvc+u8B487YkEm27xooqISnDMOPULakq0KmYJekjxYsFpq7y7fs0LG+V8+e7M+xgtVK9k+uF4OpWSC/MaLoGIs+Zr2iouskkzrENlR95cQlrt6mboswa3uu9gCgraLkWiiJZxK6pE6cFaVGwp2HvLrBf5jcUGAQxaZ7LCZ+iYFVquLaBY4pZgfw44t2CuFQqlSdWaHqex+XLl2f/+9q1a5w+fZp2u72jlvqmKQC3h+d5nD59GtM0eeGFF3j99dcf+zm24/1c12V5efmRL7oQgtdWxlzvhbx+e8TNfoDpb9CyIMkEhqqy1HQIQ6kDpOsGx44dmwGb///s/XmQLflZ3w1+cs88e53a6+77vb23epG6tSCQkIQEtuQXXl78eiCYGd4Zv6EJCI09BmwzYb92sJqRTWArsIMhPEYGGwwvtoSEFgSW1Ejq7tu3l7uvtS9nX3LP32/++J1zqupW3a37dr+NzRPRIXV1VZ4852Q++SzfJckkX79c58p6j6af0OzHFF2LvWMuqZDkLI0D4y4acmRJowQx1U0ZpYKvXWlzvR5jmyZBKrneCKj1IoquxXje5oGZPFGcqJWIrmOZynEjTdUK88vna1yr+cyWXda6EX4sWWqFdKOUIxN5vuvY+CCpZEPSrJpYGRqZkLy00GC+4TNTcqjmbTZ6Cd0wpumnnJpyOeb22D87yfT0zJYkrULTlHbhpY2AomtScEzGi5JOkNDyY2wD3jmR0F+5wqWOkpkpl8uq8NpynBvNkERoTBWUvdz+ao4gSmj4CXsqDu/YWxgxyKWQN3kWKxbv9Vofy9TRdQOJoOTolFyPjV7EdLXEww9MEUUR3QF2cG11FdO0tiXLtp9gDh4ccrACcSyDMMk2VfjvEKahpBPSNMU0TYXXGeAHjduu4cWoeTI0dW10wpRSpYA+xAsKyaHxO9sibg1N0yiXy5TL5ZHIab1ep1arAfCtb31r23TwXiyQ7ibeDir5b1WYpvmWTwCjKBphqp999tkdKgftIOGVxQ7X6z5XNvpUrRQn7FNwDJp+xOGJPGXPBk0OxO13ar392cUaLV81H2u9hKqnGsyWn/DAbImCM5iADyAeW8/x3EqHF2sQZCmmYVAPBe31HtWcjWvqPLy3RNnRSdIUDU01mJoixgkpuFbz+fNLdXRgtqwkuVp+Qi9MmSu7vGNfmSOTeaQUbP1ojAHUo+3HfONqHSkkR6fz1LoRTT8hSAROnPH4pMZBL+XY0WODybhgi+0xpmHy6kqNXpwxW3YBjX4iaPsRvTDlYEnniNHg0oUuxWKRcrlMoVgYiB+rZqAXZ8y3E8qerXDNBZ2yp2zn+nHG0weKlGyNtpTbhifDSIVgsekTJBkTBQdN13BtA8dUJJAwFZw8vI+qZ9Lv9+l2u6wsL5MkCfl8YZTjelGCyASGZpANUpHrmKNVbpRKnDvomBsj8egUy1AC1NpgTaVrOsYtBh3D/AZgD549rSDBswyKU6qxHkqF3cph6V7jrYK4vJn57fnnn99mnfmpT30KgB/7sR/jt37rt0Y/f9sVgGtra7zyyivs27ePY8eO4fv+fU+OWZZx9uxZNjY2ePLJJ7l27do96WS9tNjmt7+9SJIpHaK1ehO/0aTomEwUbE7OFNGDNuevLlEqlTA0HXsgZJlmGedWu7y20qGat3AsnfVeQieIubiWcXQqz7NHxpkuOqNzhQEBxFDJ6ZvnFplvBIzndKrVCg0/pdYN6UcZhydsPnRqkvGcAuTqmhIy3jphWO/GLHdixos2jqGwf50wUd67ls5ff2Sakrfzjt5qm3Zpo49nW9imiWkI9o/pJKnFSsunKLo8dGQ/1erYrp+flIKNbkAQp0wXHSX6rGlM5LWRbt+J4/spmGKkybW6uoJlWSNcTb5QIEo3weYa6obNOTZBKsmkwgl2Op2RL6cm1IRgK9DaNHTCOCMwEzzbRDBMODqerYpmx3FwJh0mJicQmaDX79HtdFleWqYbJiSxSb2vbAAtDWy5ic8ZMhx3ww4O48xih41eRHcgqZCzFA4xzgSWLjk+ORCP1nXkwJ5qUwdS9er/6aVVTi92SDJlqxclDlEnwtAg55j8wMPTt3j1uwvLspiZmWFsbIz19XUef/xxGo0Gq6urXLx4kVwuNyoGK5XKG06g/z0VgG81BrDdbvPiiy9SrVZ56KGHdjS+cSr47W8tcGapw2zJYaEVcvHGMqZUsIzpksMje8ubqz5NQ9c1rIHWZz9K+bOLNZp+zPHpIkvNgHaYsNwOiTLBo3vKvPOQmiRnQsCW3GsaBv0g5Csv3yCTcGymRJRp1P2ERl/ZXH7PiVke2aOmVMOV780N5vn1PqmE6aINSMbyDp0gphUkPLq3zHuPju8YOCk88YC40QjoRYKZwZRxuuwxXnBo+TFxGHC47HDiyAnMXdbICiucstwKcAxV4AIUHJO8pbGqx8xNVXj0+Dj9Xo9Op8PS0iJJklAoFEY5LhVq+2GZKofrmolhKcvIIInIpEYcx4RhQLlc2iJCvUmWs00FyemGKZ6lq2NpGpmUmIaBa+johr5FRmpuW8O7vLzCjZ6JHwmiJMOzDWyFvyGIM6bLrsJLw0Cma2ez2g1Tzix16MfKJtWyTEqOjmfq9KOU41N5KjlntHbOtuRKMWD2ztcDPvv8MlEqVI4zPJJOSsWDREjef2x8pI/6RkMI8abZMg7jzXQBAXj/+9+/a1Nwc7xtCkApJRcuXGBhYYGHHnpopNQ/TF5349V7N7Eb021+fv6uC0AhJH92sU6SCk7MFDkwnuPloMayZyGE5PH9ZcbpsrbW5tjRo/T7Pr1+b4Sv0DS4tN7HMg3yjpJaqeRtuoFNo5/wjn1lTs7sfPBpmtIOXFhY4PJyE9u2cSwNyzCYyutM5kxWOxGTeWsEbN7NPkfToBPExEmKnVNdoYnGWM7GNjTidIvc+m1CdbyZEpAeOG6kSUSaZUxPTd+y+BuGoWskmWC9G1F0zIEEgSTOwLFN8o6JbcDk5CSTk5NkQtDrqmS5sLBIN0y42rJo9NQDp5JzKLsquSWZ4MhknvW1dXrdDgcOHtxCJJFAhswk37ja5kbDpxNmA/sgg6mCTZQKXFPj+KQSVh0xb4VAN/RRgq71Yr74rUWaYThY52doCPxEYho6+6oexyY9VbChpgu6pnSxhuuas8s9/vDMKkkmsS2dOFPaaH6SUXZNnjlc4fCEN5hYbq6dh8lSSsG59YgXB+LRjqnTFxbSsOiEKYfGc/ydDx7mgV2Eel9PZIMkP/wMDh48OLJAqtfrnDt3jiRJRgbp4+Pjt9XQvFX8t7YCvhMG8K1aAS8uLnLu3DmOHj3KwYMHdz2vc6tdzq12OTyew7F0KrbgfFuj0YexnMWHHphmPL/ZIOqDqVUyeA/L7ZBmkDJd9tCAYzNFOn6sRN5dg+89NXlLG8JWp8OLZ68QCIOibSghZtui6FrMlRxafsJsyVZC8zfh/YYhpaDRi0b4RN0w8HRwTYdMSGWDdocUN8K/pSmWrqHpBhqSJAwxdJ1DBw/tWvwNQ0glgNwOEnQdSp6NjprqK6kSJRw9vI+kVFPZTqdDu91hcXGZtdik3YeVVOF6K55F3jHphQl5x2Aqb7Awf2PgOzsGDCFE6rve6MR89fwG3Sij6SvCSdnVKLoWvSjhkbkSBdcY6KEqskmaZZsN78Q4Xz6/wcvNBkKiWLepwELSz0Icy+DZQ5UteUnlSmAEt8kyyb9/fpkbjYC8Y9CPMuI0o5ak5CyD6bLCSO+mO6gP8NFSwu+/tEo7VA1IL0pJciXiTLGJ/8Zj0/w/3n/o9l/oPcRbJXP1Vltd7hZviwJQSsmLL75Iv9/nXe9617bOf6iOfz+U8huNBi+99BJTU1M88MADoy/5Xjrwfpyx1g0Zyw2waHFIxZFUZoostnz69TWKOY0TJ07iODZBEGwzNZcS/FhZnimKu4GraTgFNdrXbrHuGwlHZylTU5PM32jhJxklOfRn1JHa0DT81glOSiWM6scZN+oBFc+m6KpVTJgISjmbomcjEbuWgVKqB0Sjn7LcDqn1Iqp5B5cIP84o5zyOzo2Npgppmu04l8sbfb7w2rpib6UJdTOl5OiUPYt+nPHOuQquqTpZw9AZegCVyyXK5RK9MOXffXuBpV6Arkn6UYIfZdRMjbxjMFNyGctadHspR44ew7at0So9SROyVPDCfIv/eqWBpeuUPYNurDraxWbIdMnhu0+MM1dxkWwms5uLuD+7VKfup0yVPOJMAbaDCMJUcqKQ8Xi+y/LCPKWSkpqx7E0nPH3w3r55rUWSSYUrkupv/ViZob/3aJUPnBjfgY3ZmiyFkJzbCBHouJaawEzMTCMsl0Y/5plDFd5z5M6M9ruN3fAxN1sg9ft96vU66+vrXLp0Cdd1R8XgnQzSgdEx3iybpLdbvNkr4GEBePbsWVZWVnj88cdv63W8PgD5D3FdRtjlQDVH2bPI2ea24g+GqgKbOS5MlMWkJiWqlDIo5WxVnGiqONot6o0G8/PzTE9OYXcC+n6PYpJimhZDuzOV3+Qtiz8AP85IhWC1reSsxnIujqmmjZquU807SlhY7t70d8KUyxs9GkFCvZ9QylmUHY0sDIikySNzFQqeja4pR6GbJy1RKvj8q+vcaPh0w5RulOBayu83TgVF2+TopPJ21wdY5CyTuK6D604yNTXJX1xr8Py5dYRMEULS8BURJWcbFByTx/bmWLpxlbnZWSYnJ9VxBueTphlRkvKHZ9ZZ6yrCSKOviHq1niRIBMcm83zgxMSmqP3wu9xSxM3X+3zrRhvLNNlXdWgFKR0/JpEaOSSPlSOc3jIryz2KxRL5fJ6EzSLONEyu1HostkKKjhLeLrgWQZjST9SW4395dh/5m3X7huc0cAHZiDXqfkrBtjA0qJaK5CfH6IYpUsL//NReCs79K2XeKqH7t8OG421RAGqaxqFDh0aaOFtj+EW8kQJQSsn8/DwXL17kxIkTO9jE9yKUqgF+lLEaRiSZS9DYAKls0ALfJz+Z48SJQ6Pi8uZEs9pRzLj5ekC1YDFecCk5BlEqNr0YDWOb6HMQhEo42nMJvVkuXW7QDFKagaQre+wp2WpULiWHJnIYxqbDRbZlLC8lfOdGk29daw0EQDMaQUrRVjp1mYCHZ4sD31qJPiiaFCtNvYdzq12+cHadVAg8y8BPBAsNH8eEqaLLY/srzJU2sXqaxijJiUzSCRO+8No63TDl4LjHaifCjwT1foKQ8MT+Mu89MgSj3ywtodiHZ5aarHcTZsoemgatIKPVD0kySdVMeTjXRk9NxmdmRu99dBypYVsWZ1Z8NE2n5JqUMClnapIYJIJnDpV5Ym9xB25QYV6UDE+cCi5v+HiOiWEYuDrMmg493SeQBk8en+GhKVfJMLRaLC0t4zjOyNw9l8uTCsFaN1TSEJqGroFna3iWIhIZW/SvbnN1E6QZ+uA7M20Hy1WrEEPX8JN7twC7XdyJIadpGoVCgUKhwIEDB0jTdGSQfuHCBeI4plKpjHQHb9UF//e2At7N7vJ+xXC62Gg07kpDNUqVJeNC0yevZ/T9vsIhSyi61g7R5605ThUZMbVeTNNPGC/ajHtK2L4bJRyZLJJzLOQWxwoplbvTxsYGU3P7eXE1ptaP6fjQExFTBclEwWajG7G34jJVdLEsJQ2ipEY2C7BWkPC5V9ZYakcEiaDfiljvxkwWVQE6XXQ4UHXV+W6Z7g8b1SgV/OdXVpmvB5Rdi2Y/ptaNqHcFFU/p1D1zuDrQMR1ZAWHqxmArInnhRouzK10qnoVj6tT9lDBOWWyFHJnI8eEHpkZF9FYCyJCQEsQZz11tYegGByY8/Dil0Y/oR0qD9YF8wGTqU6qUyeXym85OQ4cjw2C+FlLzM8by1shDvB8ldMOUimvxP71jRq2Hd8lxw+by8kafOEN5mWvKEalgKUu7SsHlo+88QK/Xo9vtsLAwTyYExUJxlOPQlMuUkFLh/jQdG7BcA8sYrqFvP2mTUsnOiIFklpTgFMsYmtLZ7ScZfnx/m6e3igX8dthwvC0KQIDx8fFd17Bv1CrpZrzf2NjO1eTdTgDXOiG//e1FltohK62Aa6sNLH+dcVdjrdljbzXP4ycOYZhKhmOYKYfd8Y1GwJfPrdONUtBgtR1T7yVUCxaOoXN8ushMwR6tiw3DoNtpc+nyFSYmJgntMn/+2hqaBhN5m3o/pt6N6PoRc2WXR/aWOTSe35YMtC3rwtV2wHeut9B1ODFdZK0T0goS2qFaf37wxASPDhirN/sjK809jRcWOmRCMlt2qXopa+0+fqphGibvPTbBUwfGdtQsW5Pc1bpPJxJMFV2QkoMTBfwwoTmQhfjYQ9O7rq7VcTKEgKu1PoahKbKElFRzOtWcxVonoGSnzFQK5PM56o06S0tLytx96P7h5UiyjGY/UqsgXU0WPMPAMQ3q/QjQbqnJtelROsTfCaRQKyI01dFrQhn4uZ6L67lMTk2RpRm9Ad5nfl4ly0I+jyYy/EigayhrIynVhERTzPCh/tWtohcpSZx+LIizmOpkdUT80NB4ZO7+TtHudT1imuZojT/0ga7X69Trda5cuYJt26NicGxsbNTk3a8C8Nd//df55V/+ZVZXV3n00Uf5tV/7NZ5++uldf/df/+t/zb/9t/+WV199FYAnnniCL3/5y2/4HODe7S7vV7Tb7RHk5YknnrjtOl5KyZfOrfPlcxusd0OWWgGmX2PSUSB7kQmOTKima0iWyAa+sUJKkkzylfMbXFrvYWga3TChF2XU7GjkPPHwXHFLc6iBhBs3rtHr9zl2/DhfvNDkWs1nruKSJsof/EbDpxUkHBrP8d6j4xj6kBS3KY4P6n789vUWS21VKFZzFuu9hF6QsN6JeHJ/he8+MUFuuBuWctvq3TAM5tcDllohk0VbOVQYSmg+kiYz5Rw/+MQclZvx0VKSZkOxfskrKz0cy8SzTTzLGGw2UtpByjOHqhyd3P3BPySkLDR8+lHKWEG5duQdNXmN04yOH1L1BNPTk0RxzJUrVwaQDJXfisUSpmnQ7EdIKbB0A03X0YGSZ2FoKjdJ2F1XdVsxqCEHAvkMmLiqCVc6jYahU66UKVfKypM9DOl2ujSbTZaWlnBdh8B3SNKMbqRkvgyNUTNRdi1cS7+tBLUQgihTDiIbvZica5M31TXcjVLG8zYH75Hgdqf4b4EEcrfxtikAb5cgX++KJAgCTp8+jaZpt9X303WdOI5veywhJL//4jIX1ro8trdM2TW5eOU6tVZAU5c8tKfM9z60B8tUQP3h2Q513nRd54XrTfw441A1x1Qho+YnqoALU959aoonDo6NtLRUV7zC8soy+/fvZ2pigj96eZVUwHTBomhKPD1FGC7dKOGRAbB5Z+0kRwXljXpAkMFcyQEke6s5ppKMWj+mmrN44kDllu9fSqH8I/sxeVtNKIO+z0TexnNdVrsxRdfkDg0dYZwOpgVDmQHIuxapVKrvArjTrWfpGlGSKRyjaYywcHGSUpjwOHr0CJoGcygv3G53YO6+vq4YurkiUmQ0fMXSLbgWpqamCZqmM13JKyP3mzS5gFFBeGGtR5gqDIplpJRci5JrEKQCxzI4MpEfrVLSVDmDbE2Wra7P759eoRmkRJnETwSWHg/IH1ByTU5M5dTDduB9vBU7CNDyEz4/L+mlMRKIhEY9tei3QhxT5+hknu89dX/sEofxRtYjWw3S9+/fT5Zlo+ng5cuXCcOQjY0NXnvtNfr9/ht2+/nd3/1dPvWpT/GZz3yGd77znXz605/mwx/+MBcuXGBqamrH73/ta1/jR37kR0a54hd/8Rff0OvfbbxZJJChZ/rhw4e5dOnSHX//3GqXz7+6jmsZvOvQGK8t1Fla7dJGcmA8x5P7xzgyEG4ekiVAEakMXWOhGXJ5o8dEwWGm7FLrJ9R7ivW6p+Lx4QemtnnFhmHElatXMA2T48dPsOELljvKHcM2dbKCTqZbdBIoOSZ/bRdy2lYCSJQKrtYCiq6FZRqUDI2CYxImCl/90Fzxlj7Yw+OsdQOEUJMpv9/HkBkHJwt0Y4lpaDuLv5siQ+U4JaEq0XQdS9MoD4S170YVwDQ0BOBHirgxJP8FUUwmBIcPHWJuQjV2YiRo32FtbY0bN+bJ5XI0+wpStC4leccibylITZRJ5ioexZxLlt2sq7rZ8HajjMVWQDdSsmJ5x6Ls6kiRkaaSU1P5gUXpgBwIeJ6H53lMTauG98VrGzy30CRMJEGSoOsZORNcyyAVknfsKyJRcBhd10HbTgAB+OaNHl9fVKveTEh8Pc9COyJv6Xi2wf/pnXtw36Dw883xVjmB/NUE8C7j9YCkb4X3u9Xx75SAl9shl2t99pQ98rbB4YpJQ+tguRIvl+dDD+/dgY2BQbeTKXu1Wi9iLG9jmCbFQXLaU3LY6EXMjeVGHodCKImadrvNsWPHKOTzZANhVddUFHrdMDBliqlFJLqOpdx9bhsSZcieZplSa5cS2zJwLSXQfKcwdY1UCJr9BFvGjJfz2JZFJpUbRf4Oul5JJmn5KZ1AYfYqOYuSa2JoKtmdmCnh2tbItm7H+Ut4abHDtbpPK0jpRikFx6LiavT9ENeyeMeRmRFjVkiBZZkj/JkQksWNFr/30hr1XkKQKjxMvRdRyVkICXMVlyPjqlEwTWvEIN4sBgUvzHf4/LkNRQrRlK5ZrR/RjXRsDZ7eX6Sat7a4dmziaoSQCARfv9HjaiulnFOiqH4sSYSg3k+ZcOG75myifgdbL25LiDoauqGYff/10iqdCEo5g4KrkVglIl0jziTfc2KMv/OBI5TeoC/mzXE/u2PDMJiYmBjh0Xzf56tf/Srf/OY3AXjf+97HRz/6UT7+8Y/zsY997J6P/6u/+qv8xE/8BD/+4z8OwGc+8xk+97nP8Zu/+Zv89E//9I7f/+3f/u1t//5v/s2/uefXfD1xv63ghBBcvHiRxcXFkWf6lStX7pjjXl7sEKUZB6qqSIuKgsJMgbVuxMnpAk8drOz6dxKNJElZ68QINFxbXXPTRY2pvM1aN2K8YG0r/nr9PlevXKFcrrBv3z7F2A96xEmGnTPRdB3TMtDTmIploiFuuRkYnYeUSJkhJIhMsW8NHfKO0sO7GzCEwkhnrNTaeJZOuVhQJJcwoeTZm+r6t4h6T7l1rHZCSq5FOWeTt3XCJMM2dOYqHqZpDuRrdkYnSPnWtSadIKXWi3EsgzHPxBQR3UhyfKbEvoniSFQfshHkYm5OMXi/fHaVb813CRNBP9ZoBxmeqdQANE3jyf3lAalyu65qlim8YRCnfPb5ZZbbIY6hESQZ7SCmF2l4pkbF1Xj2SHWbK5GhqecSA6WLdij4kys9YqkzUTBp+gmpEPRi9d9PVQ2O5hP8vk8u5216/jJQuwBqvZC/WAjQUBuvMJOk+SKxlFimzs9++Cjfffz+uwW9VU4gfzUBvMu4lw5ZSsmNGze4dOkSJ06cuCsB6bvxygyTjCRVtl5xknDxwnk806AyW6YbZiM8y82hD2y/dCCV0PVjDA0FsNYUQ80wzNHkL0lTrl65ihCCEydOjG7QIBZkQrLSjogSoVTpK2WCMCbNEpprS1zKGkqsuFzGc71tq9imn3Cjpjw4G72YsYLLRN7ANgz8OOXhuTFMwwQkqRA7klw7SPj8q+vUOiG9SGBZBlEnYbpk0A6UB+OeihL5VIzbQUc5iFRI/vPLq5xb7SGBXqQkT2qmKoQLjslTB0qbD0JN6eltPc75tR5feG2NTEhKjkkvFrT8mI6vMELvOjzOkYn8Dr/i0c2sCf5iMaAZw+xYjn6U0vRT4lTS6MccLWu8dzZH6PcxCwV0XZCmm8cxTZ1MwjeutZTvcd4hdpU6vx+r7/ipKXj3wZuEnzW2Jcskk7y80se21NrZNQ2KriSMM+JM8LGHJ9jjpdTqNRYWBn6eAxFqz/MQmfpuzq72MXRtwJjTGJ+aQDcMar2Y/WPeLacdbyTezO44l8vx/d///Tz55JMcP36c3/iN3+CrX/0qX/3qV++5AIzjmBdeeIGf+ZmfGf1M13U++MEP8txzz93VMXzfv29ElLfKCSSOY86cOUMURTzzzDOjKcPd5LhupBivAHEUEYc+1byDH9/+gTgkgUggijN6YUzOMRXJwVROEPaWa2ZI9pibnWNqampUUwUD140bDUHZM8h7ebIsZaMT4uoBVy+ep1RSmnnFQnEbC1dIpa7Q9FPq/ZiCYzCRdxjLWbRDJW+1byyHOZCqufmzkBJOL7T5zrUGbT+hBXiOjjBTLEMpCJyazivPcdNEQ4kcyy3HuVbz+d/PrNIJEzIJNV8JUJc8E0vXOTVTYK7sqBy3FWMtpdoaCckfnFnhWs1nLGfR8BOiRLAShXiWxoHxAh95UKljbF2BG8ag4c0y1voZp1djHNthf06j1o/xo4x+DLqMeGavw143IopiHMfedt0Zpomt67y03Ge1E1PxrAGOWBHtwkQwXTD4wD6Tyk3C9JmUbBVUfG2tT5AIyp7yQPcqFmGS0A0z9lYcPvFYhU63y7Vr1xRuuFigNPBlHz55Lq37JEKSt3Q03aBcLJCrFOhHaiL46N7Sm8KifatIILcjYr1V8bYpAO9HgsyyjNdee416vX5LvN9ucScSSCYki82ApVbAhdU2XtrDjmImKmVqvZiSazJRdNG1TZmMzfelEySCv7japN5TOlT5XsxEzmK65LDei5nM28yWXJI45tLlyziOy8GDB0cWcS0/4fOvrbHcDuhFKd0wwe3qTBddEqFzYKrM+x6cIA56dLtd6rUaumFQKBQol8tgefzRy2usdkLyjkE3SFltBTR6aqWxZ8zj0b2lbTiWrUlOZIIvn9/gwkqLsi3wbItOrKZ5YRpwYirPRx6cwjK0bYKuQ3yOjsb5tRYX1nqUPJPxgk3TT2n5iqU3Vzb564/OcKC6ZeV303EMQ+fFhS6JkEwWbISUdIOIjp+RYfLskQm+58TEDvzh1vPpRSlX6gF5R+F7yp7SQAwTQS9KefZohaKdDDB6GcVCcSTTYNsWQgjWOmpln7dNdMPA0XVsU1B2TRr9GEtTk4rdNLmG0Y9SkiTF1JW+l6br2DqYmkYriJGGxfTMBNMzM6QDW6lut8PVjZqSkBgItGraYDUtMuz82Ej4GRSb782It6o7Nk2T7/u+73tdkz+AWq1GlmVMT2/XP5yenub8+fN3dYy/9/f+Hv/yX/7L1/X69xL3qwDsdDqcPn2aUqnE448/vo00d6cct9oOWeuEvLbSZaMX40RNXJkilGOZ8gW/iZw2DE3TuVoPeHVA3mj4CWXPYq7soOuKyalcNzRWV1dYW13n0MFDVCplQN3fz99o8hcDiEy9H1PrG5Rcg4pnYjku7zk2zuExg3a7zcb6OovzC+TyudH9+cpqwJ9frmPoGrah040E3cin1jcYy9k8c2iMkru5Sbq5UZ1vBnz1/DpBGDJXMmmFSq1hoZkxU7R51+EqD8yWdmgOKgKI8h7+s8t1+nHG3jEPP85oBoNtR5zx4VNV3nNkE6JzM8YaTWO+FbLQVtsIx9QpOAb1Tp8g06gWHH70Xfso3jTR1zS2FbSX1vvEmWSiYIGAPZU8cZrS9BP2lGzeebBAq9UekdJGuqr5PLqu3ttCw0cisSz1WgVNkrd12kGCSFPKnqc+g1tgBxlIjSGVkoRU8EFcyyJJlXB0ZWyMytgYUkiCIKDT6bCxscHCwiKe51EsFUkTfYRnFjLDLVS2ve+/7Dnu4MGDb+pr3E28bQrA28XdrIC34v2eeeaZe3ImuF13LKXkD19a5isXNsiSmHYvpNbvYQtJIHwc2+DhPSU0KRBySLoYYL+yFE2DV2qCltZluqQmMt0o40YY0AoUE/Y9R8fxe6obmpqaZHZ2DsMwFNg5y/j29SZLzYB9Yx4Vz2Sjn9INElY6IU/sL/P+4xMUczbknNGqUxEO2iwvLXGunjLf0JkuOzhFl15Bo9UP6YQpB8ZzfP/D09tWhTeTbjZ6EReXW+QsjfFiEcPQ8WNlKSQlfOyhaaZKOz0Nh8kyQwmrZlLiDdZD43mL8bxJraeszm4n4jlMcmsdH8dUoOE4itBFymwlRyPIBiyz23/PSSYRmRh4HA9kJTSJZ+v04xTHy7F/j9LkCkKVlJrNBouLi7iuQ6lcBiuHRFlDoYFlKFuiOE1BCg7umcV1vRGuZiRULbaYuwul19X0EzxLJ++amJrydrZMgz0VD1NXziCmZTJWHWOsqpKl7/t0u12+c3mVdj8lFLDeTRgrOLjZQKdL13jXocrtP4zXGW+lTdL/kRpZv/ALv8Dv/M7v3NcC8Ga7y2HcDx3AlZUVXn31VQ4fPszhw4d3fHa3y3FLrYB/8/UbXKv3sQyda+tt4sYKY56FZ+vsHfPYP+ZtI6cpTKpACEktlLyw3kU3LfaUXdZ7MRvdkFYQM1dyeWiuxJEJj8uXLxMEIceOH8fzvBE5bbHR59vXWxganJzOs9KNaPsJzX6Ca+q8//g4D82VMHQoDCaaURTTbrfpdnvML63y56s6GQZTRYfxvEXLT2n5Cbqm8cGTEzw4u30qf3OjeuZGjY4fMVfxcByHibIisdT7ESdni3zXsVusGgfaefV+wno3Vnp/ukHe1sjbBknRotlP2V9Vmoq3DCmpd0NEKrBdUzlsBD4Vz6KkWwi4rSPQMJJMghQgQWpSwXxME8cQCE1jenqK6ekp0jSj21N+xTduXEcISbFYoFQuY2iq6ArjFMc20DQJUrHDc57J3NyewdR2U1d1WAwOGWtZJggTQUPGeLaFa6jPOhWCfdUcpq4sL9Ehl8+Ry+eYmZ0hTRI6nS4bzTYvXe0TphCmGq5u4WQani7x44x3HRpjLHcH+5HXGX+FAXybxZ1IIPV6nTNnztwV3m+3uF0HvtgK+frlOjLssd+LmCsXuXBpg5YvkMB3H5+8idW1lREG7Qg2QpiesMlZSg+r3Y9pBCmeqfPRB6fJ/DZXV5Y5sP/ASEB5yHgNooxrdZ9yzsI0DCo5jbJn48dqffno3jLj+e2rPl0fssKKSAkXXlrC6HRIkoQwCDAMg0nPwjEs8rZxW5xYFEWcu3iFVErGiwUl+qzr5FwD09To+CnxXQCbNSDNJEmaYRr6gFRmjCRi7hSpUBZ7G92QMIxwDfUwkGhouqCSswevcutzWetGhElGp5uSs/WRrlkvTPFMg4MTBcyBF2/O88h5HjPT0yNz97V6i69cqdH2IRHQClLytkHBkrSDjLkxj1P7J7EHIqZplioHkC1EkvlmyO++uEp/sO6NBfTiiLytpnenZovMFC3SAbtSPSQlWSZA18gX8tzoSP58pU2KgU6GtD06qU6/EVCw4aMnqzw4fX9U8W+Ot4oh90aT48TEBIZhsLa2tu3na2trI5H5W8Wv/Mqv8Au/8Av3jQF8p3gjOoBSSi5evMjCwgKPPvroruQWuH2O+7OLNRabAQ/Oljg8kfHqpS7zHZ1OlPDI3nHefWQcz978zrdLM+ks9SRhBgfHHCRQLTq0+hFNP+WBuRLPHipx5fIlTMPkxMkTAz/0TXLaQiMgSAWzZQcNODheICylbHQjZssOT+yv7Dhnx7GZmlKaeYsNn2xtEdcQ9Hp9pIS8ZVKqWHQTqHj2bXVR19ZWWa218Bwbx3FGjVo5ZxHE6e1SyubnMCiIojTFNhhsbzR0qaNp2V1I66tGN0gz1jsBhkjJexau49AKM8ZyNt4gR9yqMepFGXU/oROm+LGg6NmUHKUGEIuMo5OV0XBCSo2xSoWxSkVp0/o+nU6Hb11a4zvLMb1Ipx9l2JbBmGcQRzE6Gu86PoPtWCovSUVwG2K2pYRUZPzRK+ucWeqSCoijbHAcHUtXTOB3HiwpF5mR4LOSCEtFhmlZlCtj/IezXa77JraeEQtI7CIr7RDX0JgpWvzoOyZu+1m8kXirZGD+CgO4JV7PCngr3u/kyZPs27fvdb327dYjl1dbLK3X2ZPXmNm7l0Ztg+PTeVp+iqEPDcVv9Z6gGybEmcAzB9Y8usF4QSfnpPSjlNXVZUTQG5E9tr8/SIQiIOiaYmDphoGGRtHR6YbZNpHpW52DZZmkGGi2TblgksQRaZrQD1K6rYiFhYRSadOLchgKqH0Vyy2REXCjHlDOmZRdE9s06IUpOUeZsg91B3eLGw2fi+s9WkFCJ0opuhaTeQtNy0gzwbHJ3GCqsBNXAyqx/f7pFVY6Ib0wpadpOKYGZkqYSsbzFkcnc0gpt+BhxLbzef5Giz9+bZ10gFXqxpJ+HJGzElzb4L1HqxQdfYtjiz7yrxQGjI2N8blLfZYik7KnwNqx0OiECX4EM0WTH3hwAkPTtmEQTcPEHLicRHHC585uDOQLLII4oxcra6Mgzviuo1U+/ODkSGRtN3V8Dfja5QZxKii5BqGW4UxUiTDIpOTjJws8O97l61//OuVyeUSAuV8Ttb8sydG2bZ544gm+8pWv8PGPfxxQ5/6Vr3yFT37yk7f8u1/6pV/in/7Tf8oXv/hFnnzyyTd0Dncbr3cFnCQJZ86cIQiCHQL6N8etcpwQkrMrXcZyFrqm4eiScTOmMldiuROyd8zbsXbc/veCTpRhaUMtS025bpQ8hAjQRcKlixeoVCrs3btvR7On2J1iIDci0NAQusC1TDz77j4TxzKQuk4kDUo5F0tXWMheEBKmktWlBeykQrlcwnE2NxWKbDdPvd3DK5RorfbJmgHlvEPeGsilSJgd8wbf0c71Nyjtw9MLbVoDcptrK+JGNWfR6CdUchYHJnIj2ardxPFPL3T48vkaQZTREQLLNEl0yMuULJM8tqeoikhNifYPccXDw/SjjH/37UUWmwG6rhGmGVEvpO1r5GyDiYLNkwcq27DIQ8x3JiT5fI71EL5T6yB1VTj2Y0EYJ6wlKXlL44l9BR6aLQzkczYJbo6tCmyRCV6Yb3JmqYdj6uRsg04kCOOUKBGMl10+8dj05rZnJPis/nXocHRhrcuNekDO1pEGSNNBL+bwE8F00eT/+ZRH/dprfHPRGuW3rRJSbySGjfpfhhx3P+JtUwDeLnZbkbxevN+tjr/beqTVanH27FkSaeKUx0kzQafdRtcM0DIsQ0e/TW8npRrJh6nkeiNQ4/yBFlM/zkjDABKdkydPYt/EoB0mxisbCtjc8BPKrsl4wWHMM0fTp7khsPmmggcUducvrjY4u9KjNQAk522TubJDpuuUizaPHyqhaREry0ukaapMwEslpJQsryzT0Mc4vaqYbf04w08F9V7MWE6p87/rYBFbV+sgTdMxDA0EA79aJXz9B6dX6UYpJdekGymbpm6QMJazODFd4NG95V1wNapoSlLBn17c4EqtR15PMT2NfmYQJRlr3ZgT0wV+4OHpkbbXNoD3QOg1iBO+dqlOJiTTJYcgyegEKX6sJAe+/6Fp3nHTlGGrubtuaGz0Yq7UA3KWgWcZFFybdj8kSDQsU+fDBx166/O8Vlsa4WqKxYK6dgcT4dVuzEY/peDZGBoUXIO8IwjTjDiVPDRXwEAismwXXI1KllEiWGsrmRdNNzBMh2q5DEjq/YS56SmefWoPQRCM9PauXbuGZVlMTEyMkuXrXXG8VeuR+2GT9KlPfYof+7Ef48knn+Tpp5/m05/+NP1+f8QK/tEf/VH27NnDz//8zwPwi7/4i/zcz/0cn/3sZzl48CCrq6t3nBbeS9xuBXyvdpfdbpfTp09TKBR45pln7vjwu1WO0zQlL9TwYwqOid+qj35f1w2MO5xPlKoHeM1PMdohY3kHx1BNUJKl9Js1Hj05y/j45LaiR8EjJPV+xI2Gz3o3otlPqBZcJgomhq5WkIf2lVThJOTAa3b762/0Yr54doO2n9CPM1xLNaiTBYck0Tk247J/yqHX67K2topl2RSLRQqFAuvra/SijJd7BRZbEamA9Z7CMJZcE8vQmSranJjMjfLTUIw+S7ORAPWXzm/w4nybgm2SZpIwkSzHEe0gYaro8oETE1i6tgV/OCCnDe7ptU7In5xbJ4hixh1JTyhXplYg0DWN9xyt8vSIgS03JXi2EEnOLDVZagWM5SyqmkUvknSCiCST7K96/A+Pz21TqdA0RnkJVPF1erFLlErGPBNN0ykKQbsXEmcaD0w5PFQIOPvaa+Tz+VGOc113myTQhXUfgYZnWwgpGM+ZZK4iCs6WbI5UXbI026Grqt6ZanjnGz4SsExDkUBKZfJFh26YEkuN9z71qJLSarVGeqJBEIwE5sfHx193/hjeI3+1An4bxc0rkiHeT9f1e8b77Ra7deBLS0t86TtnuRKVaSUx37jSIJd1GdPVuq4XJjx4cAzD0Ebdws3HeHmpwzeuNokErLYjan5K2Y6ouCatXp/HZxweOHls0PmYo+5DDP73O9cbPHethWmozqgZZrTDPmXPouyZPHtojLytjxKLPlCSF0LpxZ1f7fLctSaOpbN3zGWjl9ALE67EGfvGXJ49PMYD+8YGeI49hGFIu91iY2OdJI5JNYvnF/ugGxyezNHsJzT8hCDOiFLB9z88zWN7K6P3K6Vga51uGiavrNTphOkA/6gYZd0woh9lPDhb5Acemd7pC7pFWDVMM84u99BFhutYVFyXdCBV0I8z3nesylzlFt//QOh1sRHQDVNKnoWu6+RstYpIM0EvzpgqOreX0JGSWjciSTI8V2H+kjDCMSSe4xBlgum5PcyWnJHY8/LyEnGcDIg4Q3N3qapyIWGAQ9R1A8vSiLNYaSDqtxehNnUN3VCscCPNsPMK2zQcBJcG7DzP89i7dy979+4ly7JRsrx06RJhGG7z6r0Xvb0sy/7S2CT98A//MBsbG/zcz/0cq6urPPbYY3zhC18YEUPm5+e3dfr/6l/9K+I45gd/8AdHP7sbQ/U3Gvdqd7m6usorr7zCwYMHOXr06F096HbLcWGS8Ucvr3C97nO97nOj1sPsrjBXcmiHKQVbY0/F2+LGtH0C1g1TvvjaOmu+IEgE1+o+q52QmaKDH0a4JDx18gATE5WRoD+SgWewpOUnfO7VNdY7irXbCVMWW33qPYOxnMVcxeXBmeI24oah62g6pKkgEYIvvrbOUltNKtc6Ib1YstYNCdOUE9NFvveBKcZyFlNTk2RZRrfbo9VqMn/jOgDXfJf5RsBM2WW8YFPrJ3T8mG6U8o59ZT50aoryFu2/ITQHVL5tBinnV/sKCuKaVHIWnUCtYT3b4IeemGVvZadQsRLrV3Fx3acbJBRMQS6fY9wyCeOURj9hruLywZO7a3luJZJc2eijobzhhZSUPCi5Ho1+TMm1dpUo23Y+UrDWDjA0iabppCIjjWLGcjadWODl8jzwwBxRFNPpKF3V1dUVTNOiXFYC1IVigSQTaFIMmpmh1aqJrit5nk1P9luLULumcgkJ41RZ0w2cjVKhLDOHxLlqtUq1WuXYsWP4vk+j0aBer3P16tWRwPy9Nrybhf6bNwF8O1ldvm0KwDutgIdWSfV6nZdeeomZmRlOnTp1X76oreuRoYbWa1cXeSUcx5c6D865XFprszpfY01KZkoux6cLPLynvA1MDIy61Y1OyLeuNdA1nb05SGyHZj+l3o9IopB3HSzywUcOjs5/WPAMx89hmo1G6dNFi4mCAhM3/BhNgw+dmuT41PaHpFo9bn6eZ1f7SF2n5FpoGpQ9m26Y0PITnjhQ4emDm1NTpQnlEMWxYu0dPsJryx36SZOimdLpRHiWzf6yjZ+qm/aB2eIthZ+HHeZSw1cEjYFGVM7WyVkO68S4ln5LU/hh1Fsd+r6P59i4joOu61gamK6yTErSuxNWBYiSDH3gm6xpGhJFAhn+99uFbehKA9EXWFqEpUtynqfwLabJeF6d2xB7CXsIw+3m7jcCkyBWdniupVNwFNvPD5We4aGpEp5tDnA1O0Wok0Ty+bMb9EJVgAepRi6fJ58JOmHKWM7ivbv4/hqGMUqGwA43Dsdx7tqrVwiBbd9/eZmtcT9tkj75yU/ecuX7ta99bdu/X79+/b685r3G3dpdSim5dOkS8/PzPPLIIzsYzreL3VbAf/zqGl86u8Fc2UVImF9aptvyafkxB6oe7zpUpeRtNt9SKo02XVOyHy/Ot5hv+kznTEqOpJuZtP2I+XqfwyX42DsOMTsxaFAG1/Bw8mcYOpc3fDY6EbNlFzSHdpDR7Mf04pQDVY+PPDh10/p5MP0aqFQttyLWegmTBRvT0Dk8VaQXxjT7KTnb4BOPzeBtEQk2DAPLsuh2e1TGqoxVx/jaNxcxyOj3uui6wbhjMpHzaPgZhybyTBZvfa0LKVhv+wRJxkTeQtN0LBOqBdQ0Ncmw7vB8yoRgaXUdkaXkS3kMTeVJzzbJJYIk2x1Wc3NYhpomxmmGZSpbOuUPb2Cbd85vQqpj9JMMKQUGAs+xMAabmMmii6bpOI7N5OQEk5MTZELQ66qGd3FxkWaQsNYw6UWCMAkpeBY5Sx8pip2YKeK6zmANno50Vbc2vNcaAd+81iJK1LbDLlQxY4nQMjIh+eiDU7vWCrlcjlwuN2p4m80m9XqdixcvbrOfvFPDO7xO/2oF/DYKwzAIgoDr16+/YbzfrY4vhCBJEl566SXCMMSaPU67XuP4lBolm3GHXN+j1os5OOHxoQeU7MnNMexWF1o+fqKAzRt9jZmxHGWrz2orYrqS5yOPH972d8PEKIQSa97oRvhxykTeRjd0crqOYxqMFyw6QUrFs+7AepW0/AhbA1Xq6DimhpW3iTKxw20jTTOuX79OmiYcP34c27YoFCWW2aeQt0AOTMajkDBWRVS93mCqWtmxvt76nkxdoxdlWGZCwbWUZ+2AgVvOOUh5a7vbeqPB+asLYFhs+BlhFlHylH1QP87wHJN94/kBRGDneggUfvDb15t0w5RGJrEtnbKjDNU7QcK+qsds2VUP4cHa/Wacz/m1Hr9/eoUoESRCdbauqSH0lDiDZw4UcC1FQBmtiDKxzdz9T86u8RfX60qMW4KfSPw4wjE1cpbJB09OYOub149hmji6MTJ3F0Lw5bPrfOd6B9vQEFJDOEViqbHcDtlbcfnZDx/dNq24VQyT5b59+7Yly/Pnz5Mkybbp4M3WYf892STd77hVk3s3dpdJkvDyyy/T7/fviPfbLW5eAXfDlG9db1LJWUwVHao5E60laOAiBLz/+ASHJrYX4Zq26YWdZJIrNZ9SzkFPBXldMFmxWSOgl2i876F97J+8mXk7mHxJARkstQPlIjLAto7ldMY8k5VOSDln3RZ7qGnQi5KBqL36PU1C0bXR0Egzyc21U7PVGugPzjI5qaZqjudiyZi8Z5JlgiSJScOYKFFmAt1JayCRsvt3ZxqKrT/UHlSuFBqxUIz+wm3eQ5KkXLx8lW6UEQqd5XZE0bMo2qrIjlLBgYn86Lu71TT61eUu12o+nTCjFwXkbJNq3iSNMwwEx6fyI+s+MRhYbL0W41TwH15c5sqGT5QIwoHridAkmUwoOCYPzxWQA5jP8LOQEsrlEuVyiXo/5j//1xvU/EiJ42eCRj+io2m4ls7esRzv2LcJ9dE0HdtWx0oSRSRp9GM++8IKfpRRcAz6sUA6BZqhICXl/cfG+ZEn5275eQ5jq8D8VvvJWq3G5cuX8TxvW8O7NZ8N89ubrUDwVwXgPYSmaSPLqKeeeopKpXJfjz8cSz/33HPk83meeeYZfu/0KvpItkOQ9LtMFRVLzdT1XYu/rSHEINkN1iadbocsyRivlHAcc1vhM0yMwxtcG2hLpZmk7iudQc8y1VRNalimgWve/iHcCVOEhJVOSJCYVHIunqWRZgpXMlF0R1OBOE4GY3OLY8eOYRgGnSDl0nqflp8MzsFiIm+Rdxy6WcjBiknU73BxYxXLcSgV1ZpTYS/UA+ILr61xpdanG6V0owTPUjINUSrI2zrHJlVxYRhKKzATSlBbSlhbX+P5K+ucabkkQpAKQSPIaIcpRdfE1HWe2F9mzDMGCW3gT6qDyCRi0Fn+/ukVLq33KLqq4ItSyXqS0IszZkoOH31wGo3t6/vhREYKSTdM+IPTK/TChJIt8VOIhSBI1Pf0niNVPnxqk3m5dUU0JJI0/YSvX1Gr/LJnEaaCfpgQpqAjeddERDlaZ3klVJpcuTzaFja5YRhkmsHp5R6GoZGzdHKOiV6uEKSgGQb/rw8c4sl9xXsGMG9NlsePHx8ly/X1dS5durQjWb4VAOm3Cz7mrYzbMYF7vR4vvvjiKDdZ1r3LX9w8AWwP9OmGCgK9TpuKqyzD1rvxHSfzQ5iKkKBLNalut9qUcg6kpvLG3hJbc5yuDVUAVIPmBTEF10Ybrg01nbxz+0eTkEpPsx+nXK8L5SrkGBiGag5nyi5F1xpNmNbX11ldW+XA/gNUKmWkhNdWujT7MSudiHo/oZq3Gc/n6EcZeT1ltmCwMH8DISX5fJ5yuUKpVBoJUF+r+3z+NYUjjDNB3TcoORplz8KPMt6xv0zeNkZagQBJKtA0SRTFXLh8hf+6AuuhDmR0QwVraZk6rq1T8SyevKloUiQ9OTrOpfU+f/DSKnGWkbOV5mw3TPDjlLGcyeP7K5yaKW3D6em6Oo5ErfW/cbXJaytdHENStiEQJkma0QrUJPYTj82MROWHfsXDGBbvz11r0gwSxnKKZNNLBH6YIKRkzhO8q9JjfWVBYQeLJSxrKMit8qhtWby81iJIJAXHRNegVBkjMnQiqfHATIH/90cOY+j3RkS72X4yTdNRw3vu3DmSJKFarW5xi3rz85sQ4m2T4942BeCtKm7f95mfnydNU97znve8YbzfbtFsNgGYmprixIkTxKmgFSQstUIk4KQ9kiQGKUmExlTJQx8ouO8WLT/hRqPPejdSdj7oVPWE8bEKq92ER/YWsAZJJBlMd4RUDDhd11jtRHz1Yo2mnxAkGZ5tUM0pHEezn3BqpqB8dwcA4K2AZICNbswfvbzKWkcJLa+0Y2rdmPGC6o73Vl0OVF2EEGqyeu0aY2NjzMzMoukaUSL4g5dXWGyElDyTph/T9BM6QULZM5ktu3zvw7NMFu2RREq32+H69WugQaFQ5HLH4KXFPkXHxDZ0GkFKkGQsNAMOVj0+9MA0U0WVLIZagaCug5XlZdbrDS75LqmUzJVdZaYepvQjtf780MNTvOvwduLPcD2kjqOz0Aq43vBVZ24aFF2LfqQM6guOyf/52f27entufVBeXO/RiTIcXWDqBqWCR5KmdKMMz9L56ENTt3xYDokkVzd6hElGJa8aCMfWcU2dKBOkmeTJB/djC7UuvnrlKruZuzd6EVGi9A7RNDQ7h6nDRNGhGagHx1YCzLCLHQre3k3sliyHuJqzZ8+OumPTNAnD8E25F+H+roD/ssSttADX19d5+eWX2b9/P8eOHXvdk4mbMYBBktHyE5ZbAbMlh6hWQyPDjzNyjknpNtN5IRTmrOEnbHQjXD0jZwhmxwokmkVOh71jeSxT4WyVTIhqypRagOSbVxpcXO/T8GOafkzRtdhTdoiFwDHgUNUbuQFpEoUt01SOkxL+/FKdF+ZbJKmkk8S0o5S8qSuSnQ6P7SmpYkUIVpdX6HTanDh2DHcw0X51ucMXzm6QSfAsAz+RLLdCGn2lS/rUoSrvOL5pUdhut6nXNlhaWsB1c9i5An90vk8nythbcRXuMBE0fDV5fHRfie8e/P1QKxDUPRbHMVevXGY5ctgIUyqeSTXv0ApSOn5MlAoOTnh8/JE5Zrboq6p8sjnWNA2T5+c7RKkYYPw0wkzSDxLCVPD0wTE+8uD0Dnyz3HI+UkpOL3ZASjSRUco5VAydaCCO/9TBCkcmd78Xt4piX1zrbbPgLNo6JduhFSQcmBnjwePlkdjz/MCvuFRS00PPyyEQ1LuRcs0anLBmOpQcgyDT6UXZtin51tx2LwWbaZpMTk4yOTk5wuLV63XW1ta4ePEijqNW1M1mk3K5/KYUg/1+H+CvMIB3iiHer1RSFmH3+4EjpeTq1atcvXoVgEOHDhEkgt/65g2+c6NJL0o5s9iG1hITnoE58O89PO4ipDL6HqqRD1eQvSjj86+usdIOyVs69X5MT0IoDSI9Yrbs8dBcUenDSRBZhm5omLqFyBQj9E/ObbDeidg/7rHSCugngqV2iB9nnJwu8N4j44M14/aubliUfuNKnfVexN6KRzVvsdFL6IYJTT/h3UeqfNexcRxTp9Vqc2P+BrMzaiUynKJdbfRZaoVMFGxMHcbyNm0/VmSOosMPPzE3WjValkm1Oka1OoYQ6oZqt9u8ON8iiQVSN8iZJoWKi5+oLvfdR8d5YHbn+DsTgvkbNwiCkPzUProLq5RzirhRdC0KjkmcCvqxchawbsPckFKw3glIUkHJsZW3qISSaw7wfNyWwT2MTj8gTRIKnoFt2SOFfFcwYDpK7uRFbg5EquMkUcxxXR88WTU0HWzLpJrPjT7Dm83d8/kculNQCSsSWHpKqTCB57pEmcQ2DA5MFnEcZ4AdFNuwg8NEeS/FIKhkOTU1xdTUFFIqcfGXX36Zdrs9mpYPO+dSqXTfkmW/3x+t6P5binuRupJScuXKFa5du8bDDz/8htnIW3HUL8y3+PffWaTpx2x0I+ZX1rHjNtNFmyiVPLynRMkZAPh1ZeWmZD9UAXZmscXXrzTQNTXB7sQaPU0n7QoqOcFT+8couTrxAE82vO4M1BTy1eUu37nRIm8b7K24bPSTwUQy5cC4x7uPjCtc4E346uG5XN/ocXqhhWvpHJvKU+slNPsR/Tij7Fl86OQkD84WyTIFa0mShMNHjipbzQGZ6vn5DplUqgATBZtOqPxupYTvPj7OkwfGRsVvPp8jn88Bs8RxQrvd5sx8i/VOSNkGmWXsq3iEmRocVDyLTzw6u6twc6fT4fr160xNT/HSfIKmCWxLTSon8jbVnBLHnyo4zFV2iusPY4SxbvqoIaP6vjxTw81bNIIEU9fv7A8vodP1QQjcvIs++IxdS4n9x+ldYhB1hZFWKgFDSTClhWga+ugznJ2dIUmSEZFkfWMdQ9eV8kSakQpBP0qxbJec6ynMpp9waCKPbdsjzP2w2X2jDe/QR/nAgQMkScLCwgILCwu89tprZFm2bTq4VULojcSwAHw7NLlvqwJwKJMgpeT69etcvnyZU6dOYds2ly5duq+vlWUZr7zyCq1Wi6effprnnnuOLMv45o02L8y3ODCeZ7bs8uq1ZZaSlJUk5YHZAu8/PsnkYHIlhRhNrnRdwzB0ri52We2EjHsadhpRqnpsdEJSKdk35vGRh6Ype9YmHgYJQkNKVRAutiJqvYTpkoOuw7HpEp0gptFPGMubfPyxmV0nTkNWWT/KWGiFlHMOhmlQ0DXyjkGcOtR7Sjal5Fqsr2+wsrrC/v37GduyUs9Exlo7RErU6+g6OV0xs1xL4dtuhTPTdY1isYCXz2OcDykYAtNQ3WYWRapDlBp+EO6YLqRpxrVrV5ESjh07xkpXPaySNMMwt9zgOui63IFh3C2sgZtGO0jI2Sb2gHmbCMjZJvnb4HMAWu0O88vrJEKnHkgKQpCzVIcaxCkHx3OUPHvQUYtdpyWdIOX0QpsgFvSiDNMwKDk6rmUQxCnHpwuMF5xtfsVbzd3jOOHqap1/f6ZOEGekEmLbQwgbGQuSVPD4vjIPzha3Jb9hEThMljuahcHv3UuyLBaL2LbNwYMHqVQqo+ngK6+8gpRylCyr1eobSpb9fp9Dhw697r//yxhbC8A0TXn55Zfpdru8613vui+TguEKuBel/MHpZfwo45nDVa7XfF67sEInSDB1jfceHeepLeSwrVN1Q9eJMsmZpS6GBiU9wcxJQmnSDFI04HtOTHJqungTrGXLVEfTObvWxzAMyp5JyTMp5xy6gWownz4wxmN7SzvOf4g/RChd0VjAuGuDhNmKyUTBotaPmSzaPLSnNIC1XME0LY4ePbbpGywlrV5M048o2EruxNRhLKdR8QzWujH5wQpyt7Bti8nJCYp9A3dtA89Vgu99vw9o2ECSaMRJiudsz5ONRpOFhXn27tvHeLWKvrCkMJVZNvA9H67HtbvKb1KCY+ps9DIMXWmyalIOMNYapZx1W4x1JgQvn78GCPqphvATCg44pkaSSXQN9g8w1rfSQAR4cb7NRk8pO/hRhucYlByDOMswdY1TM/lRzhEDotPmylU1lp9/dY3nlwOSTBJnAtsrYcQSLUmwDZ1PPDY7ylVDiM4wr92vhteyLEqlEp7n8dRTT9Hr9ajVaiwvL3PhwoX71vD6vo9lWfetoHwj8bYqAEEVZq+++uo2vF+j0XjDVklbYygjYxgGzzzzDI7jjBLwC/Mt3IHWm2vq7HUSynNFVjsRD8yW2F/dSekHRgKfiy1fiSz3E8rlMq7jYIqISHcoeRYl1xoQPQadywAPA5vC0YrBBdpgQlTJ2XelJA8MxEulWgubGrqhQMmOqYgbUkiWlhZptVocPXJ00NluD01TjNl2EFNwLHUumk4ioJyzb5tUANpBigA2eglFz6DkueQ88MMETUtIOnXOnWuQyxeolMs4jsP169dxHIcDBw+QZJKzq106QUqtJ/Bsk4prUHAM2n7CbNllpqy8SaVUReLN9+K51R5/fHZdYWKiDNPMKFo6nqWTpILHDlcGSixqzaTWNHK0Zmo0m/zutxeY903QBFEqiLOYjgaOpePZBt91bHzbakep7MuRX2oqJP/2WwvMN4OB3VxGkgkafoZrZUyXHL7/oekdTPLNBCcxLYsvXPbpxBp5SydMJdIrk2SSVj/iHdMW/7d3FAiCYBu77U7J8mZP1LtNlsM1sGVZTE9PMz2tzr/b7VKv11laWuLcuXMUi8VtyfJeVpdvF3zMWxmmqdjf/X6fF198Edd1eeaZZ+4b43qY3y6vK2jKgWoOQ9eZdFJOTHg0cwa6pvHEgTGcW+CLMyHY6ES0/QgjCcAymZ2awO/3KVoCYVqMDchpUorRynfrV58JSTeIsdUth27oeLaGYzoDgtWdrxMNJTqcZmIg1i6xTBPLUO4Svu9z9eo1SqUSe/fu3UHgsAydVEj8OEYiyTkWUkgyqWHqJnnr9o/FTEh6kSqmo0SnmLMo5h2kEHS7IVUz49KFc3jepldxu9NmbW2NQ4cOUSqVuLLRZ7EV0goUnKToWlQ9k0xKNCTHposj4kY2YMtujSgR/P5LKyx3QvpRRj8SOFZM1bMJMwVxOTWd34aNzlIxggqlaca3z17hi9di/MxASEEvFvhxhGvpmIbG0ckcRya8gUYlgxWvto1I8vJih987vUIqBLapE2cSP8qIYkHRNXj3kSpHJgvbpnVKL3ZwASCZ70pOr8UYhkGOlEhz0SxHKRu4Gn/zwQpHi9kOCaqtjezdNLz3kt9GnuvFIocOHSJJkpFyws0N7/j4+D3dp0Ono/8jrS6H8bYqAH3f58UXX8QwDJ599tlRhXy/zNJB4f1Onz69wzZuyLRKs4EOn5T0Om0ykZF3bGwjvuOxhZC0Wy06fkypWsBxXFXMaToCyDmmSoxik+xxc3LsRQntMCFKlb1Z0THQdfBjxQhzLHPw9zu7sUxIzq92afoJ7SAl7xiM52zGchZNPyFv68juBj4JJ0+cwLR2ik+/uNDiO9dbdEMlluxYCVNFC0PX0KTkgWFSGYB/s0xswx8uNkN+7/Qyrb5yQNnoClp+Sskz0TWN47Nlvusdc4QDXM3q6jJxlGAYBsVigTRJ+MNX6pxd6ZCzddJQ0I8zgkhJO0wUbb735CT6QAkflFCzMZCZyYSg6cf84UsrBIkietT6MXGa0UozBCZPHahsenveLONjmNTqG3znwgILoYlnG1TyNt0wpRempEIy4Zj88BNzHJveusaW24RVDcPgwlqHhabSjTQNnbxrEUQpQZxR8Sz+1/cdpLAL2H3r+Sy3Q1Y6MaYu0YBquUB+skovShFS8n991wxpr8k3v3kVz/OYmJhgcnJyB7vt5mS59Z97SZa7gaQVZlE96A4dOkQcx6Pp4JkzZ9A0bdt08E7J8r83FjCo66XVanHu3Dn27dvH8ePH7+sDYsQClqoxyaREF4JWo45lGeRsiyRL7+gsFIUB7W4fxzYpeDk0UILGUsc2TFxTH2Gaby7+ALpRQioEy62IIG9Rydk4pkacqCnYZOH2rkLr3YirNZ96P1br1pzDRN7E0AVRkrJ32uba1SvMzsxSnZjY0Ti3g4T/8soabT+lGymB/aKjyGktP2W27LCn6o6IGzc3mJmAz726xpnFrtIjTVK6cYZrauQtg4Ln8r2PzHCgYtPpdOh2O6yvryIyQalcATSu1fr8xxeX8WOFIw5SxYDtBDEVz+LBuSInZwvbiBs3s3j/9FKNs8tdio6JpWu0w4woEaxnEQfGPf76I7OjTc3WKa76bDOuXr3Ct1dSIqEznrdIMkk3FgRRSpQK3nN0gg+dmsQcTW5vlhlTxeB/vdIkEUJhqSWEmSCM1Cr3u09M8IETk7sMC7bn3NOLHVIJDhmObTI1OYW0XNpBzLOHyrxvv8O5c+eI45hqtcrk5CQTExPbIGE3P8eB19Xw3ooEYlkWMzMzzMzMIKWk0+lQr9dZXFzk3LlzlEolqtUqExMTFIvF296798Pq8n7F26YAlFLywgsvUK1WOXny5LYv4X4VgAsLC5w/f54TJ06wf//+bf9N0zRenG8z3wx4dbnLQsPH8TeoOEow1TJ1ZisulmmSbXWbGEQUJXzu+UtcbaQEwuByzafYT9lTdunGAseFA2OOmuoY6gJMs81CLhPwlQs1Xl3ukKRKLLnppxQcXd3khs4jc4VNpXJddexptkkA+caVBs9da2IbiqXcjQS9KKDhq8Ry0IuwdJuDB49imopAYhjGSGX/et3nqxfqSGDvmMt6NyJMEhaaKTNFh3cervLAwFR9W9EwEqAWfPn8Ou0gZW7MwY8sGn6CH6X0wozvPjHOdx+fwDJ0rKJ6wDcaDarjVSzLptvp8Or1VV5d1PBsnbxrU/JsemGsiBuuyY+9c+9oBb/l4tl2PhfW+vRTyVjORkOyt5ojiFI6QcJU0eETj83e8hpZXF5ifW2d0K4i6eHaFiCVPINr0g1TXNu4qfjbGVmWsdwKAIFpKNcUQ9coOApLmmQC+w5MS4BuEJMkKY4psS0bp1DG0JW9Uz/OKIxN8di+Y6RpOpI6eOWVV8iyjPHx8RHDd+u6YbfOeVgM3ilZ3o0QtG3buybLhYWFHdPB3ZLl20Uk9a0KKSVBEFCr1XjkkUeYnb319fl6Q9d12kHKjcU2N+o+V2s+VTPBi308y6DlRxydKlDKqeI83WXld2F+jT95dYVAmjT7gk7iU81ZlGxJO0x5dMai5CrcmRK2Z1sht9yO+Pyrq9R7CUEiWGxGbHRjJgo2QsKhcY+5iq3+RlNuQFLKUQHW9BP+8Mwq9Z5yLemEKavtgGZfV3I2OY1CVGfu8P6Bx61yytB1nSxVCgNfeG2DqzWfmZKD1YdOLGj6yqrs2HSBjz40rbDFW4gSug6maSAFXFxv88pSl7yjU83lqPspnSAmTASTBYcfeGSaY1Pq4T5WHaPb62IYJrOz0wSBz9LiIl9bErR9hfkzcg5BCr1B0//kgQoffnBqB755azGYSsmZpR72YEvlmgoj7SeqUf7AiUmOTO6udReEIVeuXAHLpZVKco66t21NMm5oSE+5duyreNs0FHeGVK5EnQBn8DyTGni6OqdOoCA8d9PDNHoBMk0xXQvLcbHcAkPR70QzOXXq1AiDXKvVWFlZ4fz58+Tz+VF+20rYuPl/76XhvZv8pmka5XKZcrnM4cOHieN4NB186aWX0DRtlN+q1eoO1v5QAuavJoBbQtM03vnOd+4qcTCUSHi95s9CCM6fP8/KygpPPPEE1epOsdwrXZ1vza+SYlB2TdbqLaJWg6JrMZ63eWC2yGzRHajYs6V4EnS6ff70zCUuNHXGK0WKqWCtmyh7ojBl3IHH5jz2lJXRuFCif6NjaMCVWpdXlzsUHJNqzma9q9hxSuDX5ntPTXJ0CxtrqMcFqgDz04xXlrs4pkbFcxjPW7TClJafYGjwUDHgxEyRffv2b9FxkttW6+fXfOJMMlVQ30HBs+kFMc1+woNzRb77+Pjun++gM6z3E9a68chxo+Aq/GGUKqHi41OFkWVbs9lkfn6evXv3jgSKmZ6iZjRgeRVLhyCIAMgZGrZngAaefWdF906YgBAoN09tJKyaZGqVu1tIqdxfWq0mR48dZflaD0RH2bINpBc0TVf/3KU5hGsZakoQZTi2gT5ow1MBJc/CvoOUT5ZlLC0vI6TETzSkDkVXFUZBkpG3lUMLqHvk5pVsrVZjaWmJs2fPUiwWR9PBrSvZW62Kh0XhzcnyXmUSbk6WURSNkuX8/DyGYYw657GxMSzLGlnBvdH49V//dX75l3+Z1dVVHn30UX7t136Np59++pa//x//43/kH/7Df8j169c5duwYv/iLv8hHP/rRN3wet4s0TXnllVcIgoA9e/a8KcUfKPmo/3I5pKHVmC46LLVDLs8vY8mUasFiuuTyxP7tXrFDlYE0Sbm2sMgXX6sTGh5HJl1W2iGdKGWpFdBzDGY8nXcfGgM0hGTk561ryu1GiIyvX6rR9BV2thMm1HoJ3TCl1o9539Fx3nt0fDRxUgXYwOFIV+dyfq1JfYCP1oBeomAQvShlNgcPlwJOHjsy8lQfSngNm+aNfsxCK6Kcs3EM2DuWw49TOkGKpml8/NGZkSzOzu9JfS7Xaj6plOQdCyklUyWb8bxJvZ8wVbI5MWgMFab5GkIIjh07jmWZwDhSwucWL+GYCUmaEkUxuq4z5hp0Il2J49+BuRElgjhJ1WelKf9lDY2ipmRmbpXjgkAVf5VKmfLENPLCFTIpkUIDfdOphbsEHJm6hmWoxsLQU2zTQDJwJdJ0yp6NEOyA52yNtVqTMPBJpE4/EZQHg4HhluyhWZXvbrWSrdVqnDlzBikl4+PjTE5O7ljJ3kvDm6bpPWP7bNtmdnaW2dlZ5Y09aHhv3LjB2bNnKZVKo4KwUCjct/x2u7jb3Pe2KQBBOVHs5ld5t0r5u0Ucx7z00kskScIzzzyz6wefZoKXNgSpJjkxV+TgeJ6Xww3WQlUIvfPQGI/vK2+7kIcXTqvV5vr1a9SzIrm8AjZrKKxcJ1CuGyerGuOizdq6RqVcxvNyg85oc3K10AgQUiPv2kiZsXfMY7pks9aN2FtxODlz64mTkILVVkA/zpRwtK7jODpTpkHe1Gh0fOYmquzfv+eWHZmmQcuP0AfzRMXaU4VKmGzaFt0phvhG1cQbaLrEMg00NgvNIQFliIfZGjnLRKCRYOB6BroQJJnqbC0tZXn+BmOVMqVSSbH6bopMSOJUyVlkmSDv2XimhgbEqeTY9E5h1aEpfL/f59ixY3QTjYWGTy8W9OMIzzEpOQaalpFmGQ/OVZRCvqawSHKXdfzZlR5fPr+hhFUTgR5lFGw1BRRC8vSBMjB8QOo7iCRpmvG55y/x9aUUgUYqJELLkXQicpaBqWv8j0/MUXJ3NkxbV7LDDrVWq1Gr1XjxxRfRNG3UOY+Pj29rum6FqxlKJgz/f5Ikrwto7TgOc3NzzM3NIYRQ8hoDv+IvfOEL/MZv/AaLi4tsbGy87oYP4Hd/93f51Kc+xWc+8xne+c538ulPf5oPf/jDXLhwgampqR2//81vfpMf+ZEf4ed//uf5/u//fj772c/y8Y9/nDi+M/Tj9cYQ8jJ8gNwPM/tbxcV6xI1OxiOH89imzpidcamj0/BhouDwsYdmqN5kF5Zl6h66du0aN5ohmV1gruhganB0ukg3iKn3Y3IGPD7Wp7W+hLxJK09IiciUrdlaN2Ysb4+IZCXXGvlyPzBbpODcurnLsoyFRoBpoPBjQFGXFCyXhXoXPYt4+NTx2wLr+2FKkqYUbGvUzOUdG0PT6MUZ0V24CslBcZuJDF3TkEK5oxh6Nipa4jjhypUr2LbN4SOHB9p9KjQNHMukHqR4jk3BU+zsJE2JE0G3scHCQki5XKFQKOwqQB0lAgnUegpeUnRtTEMJR5uGzp4xhe/cmk/6fZ+rV68yMTHB1PQ0z8+3CBNFTLONlIJrkrcMerHSEzw6VVDf4RZf960RJhm/d3qFVpASJhlBmmHpKWXPJEgEJcfi1Iw6f9NQmoM3i1kvrtX4rW8t04iVfV2QSrLUJuhGmLrGTNnlrz2yO/v95pVsu92mVqtx48YNXn31Vcrl8ijHbd0y3K7hVVaBXXRdJ47je8IODkPXdSqVCpVKhSNHjmxreG/cuMFv/MZvsLCwQBAEtNttyuXyXR/7buNect/bqgC8VbJ/vQVgt9vlxRdfpFQq8Y53vOOWf9sOUloxTJQHY+DQp2rD2EyB5XZIJWftoPRLCWtra6ysrnBg/wFeONfBMdQNp2kGjg4ThkacCqYnq8xUdNqdNpcuX8bQjcFUpEShUET5v4qBZlaGoSkVdsswsYyEW8gNbgvT0EaK9CXXxLV0wiii2w/I5T32zU3fdhwfJBmpkLSChFRIyp6NaylfWgnMlD0M3diVcAGq8Lq41qMTpkpLzDap5EyKjkHLV+LNB8ZzrK6sUK/XOXL4CIXCdhzElY0+Xzpfw48yOmGGZeiUXUW40Ax48kCJcsmk026zurKM7TgUB4VOPpcnk5L/dHqFl5c6ZELSSQW9OMQ1dWxTw7NMnjlYHoGaFYlEcO3GNaIo4tixYwSpxm89d4ONXoRtaoRJpoRVo5ScrbO34vHuI9XtwqqajmFoCKHwQnU/5ndeWCRMFDamE6WkQtAJIWcbPHWgwvuOqqmnekBuJ5IkacIr5y/xzeUU0Kl4ivyR5Ysj/OdPfs8RfvAddzctsm17R9FVq9W4du3aKFkOcTVbwclbk2Wv1+OVV15h//795HK5NwS03vo3Y2NjjI2NcfToUfbv30+9Xuef/JN/wk/+5E/yj/7RP+ITn/gE/+Jf/It7LgR/9Vd/lZ/4iZ/gx3/8xwH4zGc+w+c+9zl+8zd/k5/+6Z/e8fv//J//cz7ykY/wd//u3wXgf/vf/je+9KUv3dNr3im2vofh5GJubo4TJ05w+fLlkUzLmxEbPYUZHRI89LDLgWqOgmOQs4wdxR9AFEVcuXIFy7KYnNmDbNcwB8QpXdcoeTYMnG0OHzlC5PdYX19jfn5+iwd2GcexVQGAIsoJQ5HTdClxLY1upLyB7xSGrlQOuoFyFRIDKzIhNQ7smb4jtjTKBEGS0W9mFF3FQDZ1DT8R5BxzIPSv7drQAax2IuabAS0/pRNllD2bqmdCphrDEzNFkiThyuVLFApF9txEQIlTwedeXWe1E9ENM/pRhmvqTBRtQmEwVrR54kgVGfVZWlxEiJRcvkCpXB6JJ1+r+/zu88t0w5Q4lURZRicMKDqK7HdytsBsySYTYrBh0ul2Oly+cmXkgPKnF+t86dzG4DPViKVGo5/QN1Uh+IGTk5RcYzT1HHkwbyGk/PFr65xZ7OBZOjqqeEsySaOvcJQ//MSeQUG/VXNQ5VxNg/WNDb74yhKN2CBnm+RsiM08qaETpYInjozxsx8+vhPus0tomjYquo4ePUoYhqPp4PXr10di95OTk1Sr1W11wDBnDSXhOp0Ojz766I7p8euRmYGdDW8URfzSL/0Sly5dYmJigve85z3843/8j3nve99718e8U9xL7ntbFYC3iruxSro5hobphw4d4siRI7d9gJgGJJnGSifG9RL6jRpokkxoWKa5w3VDCMmN+Rt0O12OHztOolkkWYuFZoAfZ4zlHVxTI04zDF1jupJnYnxT563X69Fut5mfXyATGbGZ5+K6pNaLaAcJ1aLDRM4CBFkmOTyVxzQV+SPbpRtbbkf8ydkN2kFCmAgcy6BgSlwtI9NtHpgqUBoIR4MqOuSWSWs3TPm90ytKXiEVrMcxDV+JPhuaxkTB5tRUXnW9W/AwmRyYcgJfPl/jW9ea2Ka6gXtxRj9OydsGlZzF+4+Ns7Rwg8D3OXrsGK7rjm6kNM3ohAn/6aVVuqFa8dT6EXGaUe8LypnkoT1lvufUNK5lMD09RZpmdLsdOp0uN65fQ0NjJXY5sxiRsy2Knkk7yAaOGxkTRY9PPDrDoQk1AdY0iOJ4U3rm+HEc2+ab59fZ6McDqz2NMJX4kcLnHJ3M8zef2kv+pkmFkAIxGHDqhsaZpR5hCkXHRNM0XEeZu/txxv4xj//xiVvZGUn8IODKlSushgapFOTdwUS5XMSrFOjHal31wZMTIw3Ke4mtRdexY8dG2LNarTaaWgw752q1Oir+XnjhBfbs2TO6l25m3d2PZDk7O8tP/dRP8Qu/8At84xvfGHl53mvxF8cxL7zwAj/zMz+z7X1/8IMf5Lnnntv1b5577jk+9alPbfvZhz/84Xt63buJrRJXDzzwAHv27AFUkR2G4X1/vWFkQC+WrHZCPBLCwAdNrYaL3k65kG63x9WrVxkbG2N2zx6+c71JO0gJ4j7VvEPRNdE1ST/O2D+WY7JaJi0XmJ2dIYpiOp027XaHpaVlTNthMXKodSL8VFByLcYLFmXXpNFLKDsmeyp5TMMgE2IH4zUTkj+/VOfiWp9WkAxknQyKRorUDCp5h2NTBbW1MIwdrHqA52+0+NOLdeWhnQi6iaDhxyOixDN7K5g6yIFX+FBTdch23ejF/M7zSzR95ePtJ4KNrmJEl1yLQxM5jpYNzp07z+TkJNPT0yOctRRKBPvPL9c5vdCi4Cirt06S4ScZy62QvRWPjz08zf7pAlBFSggCRZRr1ussLy1hOw6fuy5pBxnTRRs/EbSDlCjN8BPB95yYGOSF4buW1Gq1AdRmH5OTE4SJ4BsDDcdy3ibNBP1E4EcSQ9f5n57YwwOzN+Nv5baGN8okLy11sQwdZ4BBzEtJGGekAv7GY7O7YhCHUj7r6xusrq6yErsYhlCNOIKpyQnQDdphxkOzJQ6Ov741qeu67Nmzhz179iCEoNlsUqvVuHTpEkEQMDY2Nspx+XweKSUXLlxgY2ODJ598crQlvN8yM7qu86EPfYhXX32V/fv388u//Mv88R//MWNjY3f+47uMe819fykKQNiUSbhTSCm5fPky169fvyvD9LVOyG89N089FLSiiKXmMk5QY7bs0ujH7Cl7A00+lRTCOObK5ctICSdPnqQeCP741RXqPaXgvtAMWe9GyjpHwsHxHHMVZwRsti2DsbEKhUKRvXv3Mr/R5g/OrNLyEyzUunCxnlLrGFTzNkcmcpyaLmzDKZiGAZrqpsMk4/OvrrLRjdk35rHaDunFGbVYUslZPDBZ4P3HJ9TNtyUpDm3KpIRvXdtgsRkwXXQYy9nU+wm9MKYTpDy+r8yHTk1S8jYvlWFnKKXENE2a/Zgzix0cS6fomlQ8U7GIwxTH1PnBR6cRnTXiLXiYrUla0zTOrfl0I0E1b6NpGvtdGz9UTL/ZissPPzG37QFlmsaokBmKJ//FC8skqUBoEUkGZcem7DqKlFJ2Ob6FuJEkCVeuXsUyTQ4eOqRWJmnKtY0+GnL0IPEs8CybVpCgaewo/na5AGn50aDA3kwOrm2SCYkf37qJiaKYK1cuky8UqLpFuLEMUgAaVr4EGgOyjbLaux/heR779u3b5gtcq9U4f/48cRxTKpXodrvMzc1x9OjR0d+9WZpcWZaNkvTjjz/OBz/4wXt+T7VajSzLdtz709PTnD9/fte/WV1d3fX372ekacqZM2dG2qNb1z+3cgJ5oyGlsmT88ysdWhH8xbUmlr/BtCvVVkNKjkzk0HVtoEUHq+trLC4usnfPHsbHJ/nqhQ1eWe6QZIJ2mNEMMoqOTtExsEydh+aU6LKGIqcVcjlcx2FyclJBGc4s8vJKH0NmaIKBSoEqvsbzNu8+Mo6pb2L+NnOTmh69tNjh29db5ByDOd2l1ovphimBrrF/3OX9xyfYU3G34bmkZOS2VOtG/PnlOlLCofEcTT+h6ceEicSzBd/34BRP7t98CA81VUfnYui8tKjUFaaKA+u8WNDxlePGA7NF3rffZXnhGnv27GViYnx0nGEkQvLSUg/LNPFsZeVYSgX9WBFQPvLgJKe2wHw0bdOzG1S+urhUp+bXsTSh/OoNg6m8SSotojTjobniwItYxcZGjeWVZQ4ePES5XEIIwVLTx48zCq6hxPE1nZKu8MT9KLsjLhmg7StVBcvQRo2eCeQdjc7Azm73axHW1lbZ2Khx5MgR5OISoMTCTS+Pbg6n0Nl9y2+6ro/wdydOnMD3/VHDe+nSJVxX+cBHUcRTTz21Q0rrzdBVHTodHTx4kL/9t//2fXmfw7jX3PeXpgC8GybwEFDd6XTuSkBVCMn/71sLnFvpcnjMZM2HldUarV5EEGecnCnyXScUa1UIQT8IuHz5CoVCnqNHjiCBb766SMOPOTiRZzxM2OiqoqXRS3jfsXGePTK2CerdyiwzFMvtSisjEgaHZ3IjQ+xWPyJMUmYsyZOTObI4QpqbuMFhopQSbjRC6n3BRMFB1yRTnqRgaoTSopq3+R+emMXa5aIc2pRJCefX+ri2iWkYmLrArTikmUWtF3N8Os90afcx/HAqu9QK8JOUyaKrVOQdHds0KLomfpyysbrIZMHm8OEjt2BYSTp+DDID1CpDQ8nmpEJh9243BNJ1peiey+exWgLPM0nTjDRVJuNZCr2+T6/fJ5/LE8eq0MrllOXZ1jWNY2pkmSRKFKh58EaR6BRd+464NCnB0JR1VS9KcWwTa8AaSSXsqeYwdIP0pkluGKp1W7lcYnp2jtfO1dSKJ0nw8nlyhgKdB3HGQ3Ol0YPofsZWX+ATJ06wsbHBK6+8gm3bLC4u0mg0Rv/9TjIzr1eT6+1kk/RmxFbt0a1xOy/gNxJnFjv872dWcUydw0VJI81Y7XTpdDQOjHs8sb/C0cnCiG27tLRIvd7gxLFjlMolLq11eW25Q9ExmcjbrHVjGv1oQE6z+MDJ25PTeknGfFcyUcqRd0z6QUS9H9EOBDKJeHLCYNpJSNNshBsc5iYVGq+u9pRMlGPgaDE4GcKzCDJ495HqLYWjh7n2Wq2PH0umSg4aksmSN3I3sk2Dd+yvcGtCvrqOb9R72IYitCAlRVsVwOudCC2LWFupjQqt3cKPUqI4xR4WTbqOY2lYhkZDxHcseCzLolQuY5ptcoO1a5oJ4iRBCEGcabRaHZKSjWmarK2tsr6+wZHDh7dJKqkCUWn15ewBnlJTTaWhG3dg/g7OxVCSW90wwzUFnm2haxBnEtPUma14O6R8pISVlWUajQZHjh6hEWroGvhRRpwIKiV1DcapQNfgqQOVO57H64lcLsf+/fvZv38/SZKMzCAMw+Bb3/rWiJB2O5kZeGO6qm8nq8u3VQF4L1ZJN8dWQPXdCqheq/tc3uizp+ISdCM8I8ULDZqWi6FrfN+DU5QGK4JWq8W169eZmVbA00wIWn7CWieimnfQNY2ia5G3DaLUphWknJgp7KrzBoxYbgsNH9fW0XUDTdOZLBtMlTyWWwEz4x4yi7ly5Qq6ru/ADWoa9KIEIZQKf7fXxzQtpooe3YEy/11Aa0iFACGQQgz0ncBGR9fSu8If2obq1jt+TN5RmncaakqVJjGVQpFDh7YXWltDSEiEIIgFDWLyrmLpAcRZxlylgKkb2/xAb471bkTDV6xCP8koujZFRxmOB1nC3qLO/PXro7VOoVDYIRL77etNzq318RNBkETYlkHFU0xeE3h4brBm2oW0AUrK5w/OLPOd6y2STJJkGb1Y4JpK2d8xDYVBFNlgkqusknr9PpcvX6JarTI9M8u/+/Yiryx1B9pbEJkF1joR7sDr9H9938E3XUKg1+tx9uxZDh06xOHDh0mShEajMZKZEUKMNLlutkl6I8lyWAC+ER3AiYkJDMNgbW1t28/X1tZuaak2MzOz6+/fz7Asi0ceeWQbEH4Y91PrdGt850aTOBMcHHNIupKqm1GazLPRi3lorsS7DitFhCHZI4oiTpw4ges6pGnGfN0nkYwwd3MVl6mCxVo3Yk/Z5eRt5JCEFKx2AvxY4cJ0XaOY98h7NkEsCOKE8WKO9Y115ufnyefzI8b4kOAlBnnFMpRUThwnjJWL6vtth7t+ljvOA1VUyixTleHA19s0TSRDGMvt7yfL0AgSdc6ubSGlmnimQhAHfY4+uLuo/uZnAZmUtHpKd7DgWRiapogbpsF0ybst/jATsNQKCWLl4exaym3Dcy1afkzRASfpcP78OpqmkwnB/n37yOc3v592kPDFs2v4UUYiJJ0oI2/pFByDXqjY2TMlZ3Tfbp3kD2O+EfBvv7VIkKgpXZzq9OOInKWTSTg5U2C2qKR8hpNcIQTXFxbotNscPXqMlV7Gv/nGDYJk4Hyj27QTA78T4poG7z06zruP7FTquJ8x3BT6vs8zzzyD67q7yswMsdHlcnlbzn0juqr9fv++bxeGca+5721VAN4ubrciGervzM7O7tAQvF30o5Q4FXi2QaRrNOsN5XyBIkVkYjvZ4+CBg4yNVbYdI5OCOE2xDGNABjBwdR093PTOvFVIicKCBBm2EVNwLbQB6UI3DMbLRQ4dKI9wg51Om4WFRdIspVQsUiiW6AWCTpjQ9UMlHO26IFWyOjiew7XMW9qUSQnnV3sEccZaJ6I+MEKveBa9OMO2NA6MK2yO2CUZAKy0I75yoUY3zGhkKbalU3FNPEuj2Q15YNrjxOH9mIY5wIBsZ4JlQvJHL6/x0mKbOBME/YxWoLCDlqHs557cXyYdYFBMw0QitzHKNrox/9/nFmj6CboOcSao90I6gdLLOziR5wOP7kXEAVeuXsVzlbr9ubOvkcvnKZVKLAcmf/TyGpmQFByDfiKIkoz1NKPiWrznaJVTM8XRWgrUs2Sosi8yyemlJt+53sLUdcbzOp1IkKQZYaI8Rz/x6MwWY3V1HN/3uXLlKtPTU8zNznJ+tccrSx0sQyPnmCTSROZySp6n6PD/+aGHRlITb1Z0u11eeOEF9u/fz+HDhwF2OH90Oh1qtdrIN7NUKo0655udP+4lWfZ6PRzH2VUO6m7Dtm2eeOIJvvKVr/Dxj3989Lpf+cpX+OQnP7nr3zzzzDN85Stf4ad+6qdGP/vSl77EP/pH/+h1n8e9xJu1Am70YxxTR9N14jjCQjKWd/ATMSK2bZI9bE6cOLFpmzYIkW3KjkgpsS0Ty0zvprfEHOidNvoxRdfCNpVkSSrAc2z2zc3gWnPbcIPLy8u4rkOpXEZ38oPVZUDOlExVlEPGSDi65I3kiXaLbpiy0AhoBgnNIKHi2Yx5JrYh6UcJj+wp4drWqJi7uePNhOTPLtW5VgvohCndMMWzlTh+pxdiInj21AHyhbwiSqCkWLY2qvONgP/w4jK9KCVIVD5oBSklVzl/nJhWxA05kJoyBxundIA/BPji2XW+ebWBprb2+HFGEGdKL9U2+b6Hpzmxt8SNG9fp9foU8nmWl5ZYXV2lUChSLJX492caXK/7FFyTXpiqIjBUws97x1z+xmPKv3hbI6JtOiXFqeD3Ti/THvgdB0mGHwsyIQkSwTOHxviBR2ZGzxopBUkK8wvz9Ho9Hjh1Etu2+cK3rxCkmSIg2QYiP0Y8gCP9zaf28n9/34FdfZTvV0gpOXfuHI1GgyeeeALPU+5eW2Vmhtp+tVqNl156CWCkq/pGZGZ0XR/pAL4Zca+57y9NAbjbikRKyfz8PBcvXuTUqVPs3bv3ro8nhGSjF1PrRWx0I3IyIO10qZSL9OOMSk5Zt83fuEGn2+XE8RPkcps2cEkqOLvSodZL6IUpRc9kIm9RyVnUewll12SunBtIjuy08olTwVcv1FhoBmrtG8QUXYPZskc/UgXQoYncDtzgnj0QhAHNZosvvrbGpUZCmGhkUiPoZfSSgJxtYJs6j+8rDdhgW5w7tpzLy0sdvvDaOlEmMA0NP5EErVCBo12LJw9UmCna2+zOdF3p4ClNvZTfP72szMuLNrVerEgk3QjXkBydyPHXn1DTqm2sWV0frQjOLDR5abGtbPfGPBp9ZQrfjzL2VBy+/5GZEaBYrXU219+GoW68v7i+TstPqOYtpLTox5JeFJNlkkf2lPhrj8yQhj7Xrl8bMeFAPfjabUUk+cqFPmGsUXbVNLbo2vixItU8c2SMjzy4UzoEtqvsn1nqItFxHaUPOZ63lbRAlHJkMsfDe7avh3r9PlevXGV6epqpqSnSLOPSeheJpqRzNCiWx3Dyjnp4pGIkMvtmxbD4O3DgwC39eLdq+22VOhgCznVd30YkuZPMzNZk+dprr42S5huxQfvUpz7Fj/3Yj/Hkk0/y9NNP8+lPf5p+vz9ixv3oj/4oe/bs4ed//ucB+Mmf/Em+67u+i3/2z/4ZH/vYx/id3/kdnn/++df9+vcab8YKuNaL6IYpF9Z6tIOEdrPDVMlDotaQE0WXft/n0qVLjI+Ps2fPnm0T8cVWyNWaP5iux4wXXCYLJumgODk8mRtNi9J0JzntWt3na5dqtMOEjZ7AsxPG8xYl16AXpTx9oIJrqevhZtxgt9vh6kqTL1/doBlBmGpEQqdf9xnP2wgpOTSeY29lIB2maVgDEkmaKivNMMn4/dMrzDcDcqZBN0yo9SI1MXOV+8czh8ZGn/sQ06xpmrLSRPL8fIuvX2ngmDpjOZNOKOhHCTfihDEHPvLQHIemStvE6Lfqu8ZJxn95dY22nzBTcuhGGe0gJUlVXnjPkSofOjV1U9G0SabSNZ1aL+LbN5qYhtJ4DVNBL0rwYyUm/z8/vYdD4x7Xrl0jSWJOnjyBZVlkQtAfEA5PX1ri2kaGo4Nj6HglmygV+JHAs3T+l/cc2H1bteV9LTR91nvK41jXJAXXIudIwkRJ4Lzv+MQ2jLQQ6vkcBAHHjh5DNwx6Ycz1uo9tGGi6ganrFCoKC9sOMiYKNo555zX0642txd+TTz65bc27NbZq+90sMzNseIfTwa2izrttP7b+k6YpL7zwApVK5U17j3fKfVvjbVUA3ssKWAjB2bNnWV9f58knn7wnJo2Ukt87vcyXzq0PqOsxQXMdO00ICDF0jQemPS5fuoAQklOnTuE69mh6JSX86aUaZxbaFByDKFU3dSdIqXgJEwWbZ45UsQy2JIXBOHxwQ337RpMzSx0qnomhazT6KS1fsewOjuf47hMTjOetXXGDVrHIUk9wo9fCNTXGCjaNIKMXprR9jZwhef+JSY5txeZsoeIbuk4G/MX1JqmUzJZc4lxGJ8roBAkaGh84OcET+8e2JfWb2XWXNgLqfko1r2Ry8q5Nu+fT9hOmiy7/l/cd2RR23RIKZK2S3Pn1PkLTlB+nFMyUXZI0o+HHHJnK8+AORhqDz3Pz5rq01sU2N+n8RQdKjkvdjym6JlG/w/z8PPv27ada3bxOHMdhamqSqalJ4suXsM1EraPjFLQER9dIdSXtcjfhxykgQOhoA0VFwzTQYmXTtDW63R5Xr11lbnaOycmJ0c/NgSSQyDQMy8TOFUffm21od+0J/Xqi0+nw4osv3rb42y1uljpotVojVvErr7xCpVLZxrq7VbK8cOECf+fv/B0+8IEPvGEP3B/+4R9mY2ODn/u5n2N1dZXHHnuML3zhC6PVy7BQHcazzz7LZz/7Wf7BP/gH/OzP/izHjh3jD//wD9/QOewWmqa9JSvgxWbAv/rza1xZ75NkggvLLaJ6QJgqKY49FZei9Ll4aYl9e/cxMz0FaCRpiqbBWificy+v0B5MqtphwmLDp9bTGc/ZHJnMcXK6sMNGUQ4wc50g5YtnN+iGKQfHPVbaEX6csdTKiPI2D80VeddhdS9uzQe6puM4BpY1zn+50KGfakzndSKh0QyUjEutK3jn/gIffGBiG756KNI/tIa8tNJjoRkwnrMwDZ1e4tD2I3pRxp6Kyw+9Yw9juc3m5GalCU3TeHGhO4D3GBQxKLmSZtcnEhofeXhutELfHpt5cqkdUOsllPI2hgYVz6LoGASxIMkE7zxUvSWxTEpJJjOu1/tEqWA8r4wEXFvDNXVCW0l3VVyDq1euICUcPXpsNME1dH2kB7qaNdEWVjBNNenMkgRD1/BMlTOjVFC4g+JKlAqEyLZQ2wYuIiaEsWIjD0MIxXaP44ijR48OhLCV7IyuqXOQApxihZE5AvKuSCivN6SUnD17lmazedvi7+bYTWZmSCS5du0apmlua3h3k5kB9Qz++3//79PpdEbTuTcj7pT7tsbbqgC8XWxNkFEUcfr0aYQQPPPMM6MR7t3G1ZrPn17YoOiYPHO4yrW1Dq/WAvqJKu7efbCE3lrELhY4cOAAuq5vsQXSqfdiLq71KdgGRc+kmndo+TENP8a1DH7gkRn2VLZfXFuBzZmEc2s+Odui4OgUHIuxXEY3UPi19x+b2B1bM8ANCiE5fWmJKMnYP6EscMoFjThNWWuHTHhgdlY4e3aVUklNagrFwkjLSUhBrRfT8hOKjqmEoy2NcUOnmrOo9RLKnnUbYPSmcLTyOjbRNJ00jDBlRrXgIgdWdXeKOBVoA+kHDbVCsSxj8JnfHRPMNHTiNCNLdQzTGEB61JQjDQPmF9ZuC9AWUoGj17sxpmHguiZSKBKJkBB2Gly+HFAqlSiXS7uKzfYGWmZBLEizBM8xcQyF3dGQHJkqYhrKRrDVanH9xnXlgrLFlWajG3Npo0+USqI0xTMLOJnE0JR/6/eenHzTsH+dTocXXniBQ4cOcfDgwdd9HF3XqVarVKtVjh8/vqvMzBA3OJSZAbh69So/8AM/wN/6W3+LX/mVX7kv7+mTn/zkLVe+X/va13b87Id+6If4oR/6ofvy2vca97sA/OPX1phvBJyaLbJ/3OPVS9eZl5Kmn/DeoyUO5mJqayscOXKEUrG4HdZg6Ly60qUdKOweQDcSNPsR/TjjwdkC33NiEsfaLnC8dTp/tRHQiZRciaZpHJ2ylXB0L2G27PIDj8yw25ZPSAEZLKy3uL7WoZxzKBdzIAUTJbW27QQxU2bIjUvnqY1wg1vuy0GjutTwkah8okmNoq1RsDwa/RhLN7YVf7tFGGd0glitrXVdSV9FfSqeSS/T0e5iTZlmUm1hhI401PrbMAxcS9lBKsu924dlKHZ2GKeq0dU0JUKPKqYWrl/j/8/ef4dJep113vjnPLFy6NwzPTlKGsmjaAnjLGwc5Gyztl/AhGtZE5YLln2B/cFeYJaF3eWCffdd73qBNa+JDottjANGtiUb27IkSyNpgjSxZ3o6V4fK9aRzzu+PU1XTPdMTZCsZuP+x1VI/9VR11V3fc9/fUMh4fTeDjcp3bKSCQBpaTdox/OggkjgoZiZP0S7mKRaLZHO5S66jNXRic78rLUXKsUh7GseyCKKErO+wZSCDZdnEccTZs2dJErkOkCoN35qsEktMbF2sKJcyuErRDBUp1+b7nyXuXw/8VavVpwX+NqpUKsXExAQTExPrbGZOnDhBEASUy+X+dLCnKtZa84EPfIBPfOITfOMb32Dfvn3P1FPbsK7U+9bW9wwA7NnA1Go1Dh06RLlc5sCBA1fN7duoTi42aUWSTcWUWWdZHXYO+Cw1Q3IuUJ1muCv2uPj7VkrFfK1NO0wYL3pYtkPa0viOTz7tEMWK/OWEH93qRJIgTHDt3iREkPFcfEcwX9eXJQJDL2LoDHGS4Hlu13jakKU91yXlS3L5FAcObOrzBqenL/AGe6ainm0SKZpBgiXopnUIkq5Zp3+VnFqtDbjpRJIlHeEJhaUTstkMK23JpkIKx7L6K+iNarkV0QwT4y8WKwppj5xnoqRQmp3D2X5W8Ubh8FrDA5OrVBrGWLUZSrK+Qynl0EkkllbkZZ09u/eQz+c2JDV3YslfPTzDTDUgTBRBonCsmELKJZaCctbl1S/ajA5btJpNFhbm8VyPXD5PsVggk8lSDxP+8OtTLNZD42gfK4JE4lkWji1MzNaWAolMWK1WOT81xa4dOyiWSsSx8VZshgkf+odzrLYjXFsQS4i9PJVGRNq12D+W58e/b+slr8EzUc8U+NuoLraZ6QlJejYzf/EXf8HY2Bgf//jHedvb3sbv/d7vPe0opn8M9d3GXa6tdiQ5Olc3WbOWIGPDeCqBvCC0HfyohrZkX+yxtrSGOE6YWWmTco2RsMZQIwopm7laQCHtrgN/F5cQJttWd82IjXe0oJjxSJTpb1fCTisrq5w9N4Xj+iaLW3dNjR2LjGXRSWDr1k1sLrjUajXq9Rqzs7P4vk+xWKBYLJHJZLCEIE4UrSAm7buI7msrschepUeDEW0ALDcjolhiyZiU52A5LrY2EzkjHtm4XysNlWZIJ5bUOjE53yXvW/iuWUcXUi6byxkcxzaT1w2usdyKeOjsKu3IbHg816GQMt57nTBmIqso5/Ps3LnD8Bg34HsfnqnzqcfnDcc61kaYZgtSrhGhvXTfMNsn0uZ1nJkhSRKy2RyFopkeuq7L/SeW+eKxRZSCRGlasaYdxfiuhWtZvHLvII6AOI44ffoMtm2xb9/edcKW+08s8bkji2jd/fun8jQiRZCY+NB//codjBe/c2B2uVoL/m699dbvCvxdXBfbzLRaLZaWlqhUKpw4cYKTJ0/y6KOPEscx9913H/fff/+zDv6eTr2gAODVVsC1Wo2zZ8+ya9cuduzY8V00Sm0yE2OJLRSNWtVEeylNq9lgx03bN9zRGy6fRqCJpWK5FZNPdd31hSE2e65z1TF2J5aE3bzgUtqlnHVxbYtOrEm5NsP5S2X00CNrn6GDR+hkWWk3aYQtytkUAxkb2T1R7hzO4rnOJbzBeq1m3phnznO45rLSUoQSltsJxbTNYNpltRMzXvSZKKewLBvLMqB37dpKa/jy8QrfOlMlTBSt0MQiFVIOcSfBsSxu3VLoKsFE1+hTI9cEzFcaEX/24HkqrQghzGvSiTtUHYu0Y7F1MMOB8fz6FbptTFUTqRFC8/C5VT5/ZAHdneAFUht/sEiSd+GGAbjzpj1k0ulLVvFam9Xul56s8NRCk4xn4dqCZqiQyhisbh9M87abxxkuZoAMjAyb9VajQbPRYGpqCrTm4SWbhXpCznfI+BbtWBNEhmR900SBtx4cJ+fbLK+sMD09zfZt28nlzXPrGWs/cmqV1XZE2jWvOX4OnXIJEs2LJor8vz90Yz9H+ZmsWq3Go48+ys6dO9m2bdszfv21Zds2w8PDDA8P0wt3/9znPsf//J//kziOuf/++/nVX/1V/vW//td9g+R/KvXdxF1eXAK6qTQJUrlUV5cBgWMLmmGAILWh2EPrHq3CKFxrnQTXiSmkjEABYT4/Gf/Kk7NYaZqhocRI1aGY8ch55nMfSs2+UmZDVX/PJ25+oYLKjdCaq1FZapNP2QxkPPIph2rLGNRvHkiTdV18z2N4eMh8Lut1arU6p0+f5mxTcHjFoh4oI9zwY4ZzLmgQWnH9WBZ6Snx9qXBjsRHyiUdnWW3FtCNJK5J4lmDQsYk6CVvKKbYNpg1v0LYRlkBJta5n//2TizxwZsX8XRWsBgmNQJPxjPjh5XsHzXQ/SUBrLNtZ12+DWPJnD04zXw8p+GYNH8WSpTgh7VoM+IpX7CyybdvWNb6b3RhPYbZWy62Ivz40RyeWDGZcqkFsojKVQFjw/bsGeNX+YVxLUCjkzaQxCKjVqqyurDA7M0Nk+XzxZILWgnLWI4gk7Tgxw4JuJOXNW4okieT06dM4js32LoWkZ6ydKM39J1dAa7K+TUbbWKUBQm22Ur91z35esfcCFeaZqh6vuFarPePgb6PKZrNks1m2bdtGkiTYts2HP/xhnnzySdLpNL/+67/Ou9/97udt03BxvaAA4OWqR8Ks1WrccsstfRL/d1KnKy0eOLPK+dUO09UOBdWkIBJa7TadWHLn/lEGBwfXqcK0viCJP7PU4msnV6h1YirNiJTnMJR1KHSVVXdsK+E7Aru7Ak2kXDfRO11p83fHFmiEMa0woRWZ+LbBrIdUmuvHcwxlHZRW/ZxYpRT1ZpPJM5OITJFvTSestELjSB8pZqttVloWxZTDtgEDnDbiDWbSGUZHx/jzh6aYbjUpeIJaIAmloNJIaAUJ24bSvP6Gsa4STdIbmPXd8ZXiqYUGD5xZxbEEQ76mFpuJVT2UjPkOr7lueA1374JvIdB/Xb5xep7lVsxw1kNloBGZiCcpNTdtL/L6A6PrAI/Wip5I0ohRbL55porWUMy4aDRhbFI7okRxy7DgDbfvvmRdu34Vrzk0bcxZPcfCszUZTxPGJi3gFXsH2XGRG71t25RLJcqlElpDq93iY6fPGmFMHCOEIGNb5LIurUgxWvApZ1yWlpaZmZ1hx/YdFArreY3GbqOF0hqrO3nN5Es4nocVJDTC5Hse/F1cQgharRZf/vKXec973sPv/d7v8eUvf5nPf/7zl1V0/mOoZzru8uKKEsW9Ty4yvdphphpQXKyTai1Q8IztR873uOPALlIpb02ykOiDv06UcN/JZaZWOyy3Y1bbMfmUw+ZSimZolJvbB1Ldg5Thufam2GDEYZ8/sshTC00iqWjWYpbbMcWUje8YxeqNm3IkXSsk27ZBm/Xx1NQUzWaLWTHI4+eaeI5FJ5ZUA0Uj6JBL2ZTSLt+3cwDPEsTdvmIJC9uzGRwYpFwuc2qxyZFHZoiVpOBq6rGZSHbChOGcx63bS1w3boQbF+LOLiQcJUryhaOLxuIrLXDQdJRDnCiW2xG3by3yugOjff7hWiEYwvTb+VqHh86u4lo2pYJLKzKRkp0YfMfinbdsWpfvbtJ11vRbITi+2GGxEVHwbRzHJpt2aQXmeyPvKN5zcJCtmzddMvFby6k8Nt+kk2jyaQ+0YjifJk4kzTBhIONdkrUrBKTTKdLpMRgbI44Tvnp8niipkrI1URzhWBaltEusjH3O3m5QwenTp/A8n+3bt68TEymlmKsGdELjEoGwcdNpMtkUWa2pdxIS9cwYP6+tHvir1+vcdtttV8yJfjbKtm2eeOIJ5ubmePDBB3Fdl8997nNMTk4+p/dxpXrBA8A4jnniiSdotVr9PL/vtOZqAR/62iTz9YDNpRQzqy3OziwgkBRcGM/Z3LZzZL1gwra6BGMzxv/y8WXaUcLO4SyztQ7NUDJdTRjJedy4ucAd20t91avsXcOysGyLIE64/+QSrUixYyBDtZOw3DYf6Gon5tX7hrhr5wXhRS8ndnV1lfPnz7NlyxYeWVSstJYZK/hooB4qau2QIFZcvynPa68bWQ8W9HoAttCImK7FDGRT+K7NQFFTbwXUA42N5NZ8k6S+SE1c4A3Cenf8E4stIqlxdYzn2mwtZomThJVmzI7BDLddwcSz97qcqLTwXRvLsRGJopQyq9vlVsRwzrtiMDxo6p2IajvCc6zul6pFypEIqZFKMzI6dtUPfJQoYplgA2gBloUFpFxBJE0qy5VKCMhlsziOhy1jPNfqx+yFcUIioV6rc/58zMrqyiWmrGsr7fYmEQmpdBbHM/eutGYw+8ybPvfA365du9i69dlZLV+pFhcXecMb3sAdd9zBH//xH2PbNu9617t417ve9ZzfywuhvpO4y43qU4/N8rnDC5QyLs0wobK4QNho4FuKgZTFnTsHyflOH/j0fC2llMRS8e2pGk/ONRnMeXiOxXI76UfA7R7J8oq9Q5QzLr3scrggugB4fLrGUwtNyhmXgYxLpRlTbUdUOwl7h7O89voRJvr8aANADa1lEtCMbN3FFx+aIe3aDKccBjLG564WSHzb5q0vGu/HOfaqxxsEQAgOz7dIsBktmc/QUKKotwPqgWTc67DTESxVoFgsrluB916TSj1kuhqQcgQyiRgqZEBYdCKzuXnJrkFK6ctMQbv99sxSiyhRDOYMBzLnG/DbSwLaOnBl3rrSmoVaB9DdSDkLG8h6AhkrlO2ybeJykZIXqhnEZoWOAWu6m5DiJYamcrVyXYdcNott1fE8k52ulHmOvV+vVBbp1FdJZzJs27ptQ7/X3ndSlCgsJH7WKH+lMok0l309v8PSWnPkyBEajQa33nrrcw7+tNZ86EMf4j/9p//E3/3d33H77bcDcPDgwef0Pq5WLygAePHpuNVq8eijj5JOp9mxYwfVavW7uv4Dp1eYqwXsGTFKRD+qccqVdKRg/3ievZkOmYuAR5IkSKWwhMXZakg9VIwVfCxg90iBZsdYC2wupXn9DaOXnMZ6oguVKGZXO1Rbxq5E2BblrEcx43Y9mRQ3TRTWRfloDQuLCywsLLB923aKxQJnj50j5V7IvCylLEopm4V6SCntXXVStNIyfJZSyjMTRmzKuQxpPyGIJWObhrDiNjMz08RxTD5foFi6EEYO0OwEJFGEk3XxUsZd33eMN1h0DaRmMMHuiewKNyyzIhZde4pr8YDyHPPftiPDYfQciygIkNpI+AfyKZSCK9HJgkRiCai2E1KuIuO5OLbxEbQti60DWbO+6NpKbFQnFppIpWiGknZkOIhp10EmCtdWjKUlqyvLWJbFUmWJKIopFArr1m+PTNV47HydSGmiQBKlM9ixRGmTifKmm55Z09BqtcqhQ4eeN/C3tLTEPffcw4033shHPvKR74jH+4+xrjXu8nK13Iz4+ukVyhmHoZzPaM7h20unWbY1+XSKF48q9g5dWIH1pn5JIlFaIYHji23SvkPGtcl6RihR7yS0YsnLdg+uS/1Ye6EecD291MayLFKeg1aKzeUUI3mXhXrEruHsJeAtDCPOnDmD53ls37Gd4wstOrFkNG/iN9O+Rcq1KaYNQB3IXgUoaE2lHuAK008QAt+zGHayKBEwOlqkXHao12vMzc31eYOFYpFsJosQ5vMfhhEuinwuY6I3LUEa0zPia+hxzhqaiWP10j8EWpgUD/sa6EuGC2yEL2nPRcuYMIzQtstIMYMQ1iX2YmtLdvl6YaxYVTFpzyHlKHNfSrF7sNAXpl3uOp1uVnEnUbRjScq1DV1G2AQyYWvBprm6ZHwCo4iFhQWKxQLpdKb/XdgMJZ96bI5QKnM/uJDYZG1DH9o+mOHmLcUNH/87KaUUR48efV7B34c//GE+8IEP8LnPfY4777zzOX38p1MvKAC4tiqVCo8//jhbtmxh7969zMzMfNen43OrbeM7JQSNZpPawnm2DGSoxYYU7Ir10TVKqe4q1vAU2kGM0KorgzcKrELaJUokSl85rgwMH0Ki0UqDpQEL2wbPs0kCzdopuFKa89PnadQb7NljeGxgVgPtSJGJYtKui6ZLtBYmmPtqZRI6FAv10Pg4eRYCQZAoMr7L5uEyFmU2b97c5w0uVZY4P3WebDZDjMvcUo2OtFnqKPJCkvcs43SvjNr1SsINpU06Qa0Ts9KOqQUJBd+hmHZpxxLPFuwZyXYNli/4ca2tepDw0W/PGL5fbPg5roCsK5DCYjjjsGc4019/667p8to/z+Rymz97cJpGYKwUGpGiHZm1uhCwfzTH5q7HWG/CcbFZ7JHZBn/x0DShVAgEEmM82w4FKc/i+iGPQTdk9649aE3XS6rCzMx50uks+XyelcTlo9+eQypNyrWIlI1yUqy0zOrtXbeO89rrN/Yg/E6qB/52797Nli1bnrHrXmutrq7y5je/mV27dvHnf/7n3zXf7Xutvpu0o6vVYiOkGSRsLafM2u3cJBmRMDhWoBVrUm6MUhe2G71pDpg1apgkREmCZ5vPgCUs0p6NZ1sk9ZBr2dIZw3iJkhIhzGfGcx1sK77YY5lWq82ZM2col0ts3jyBEOBaAimNuX3Otbt+egKJ4es5VxEIxUpjC6h2YgAKGR9La9OfLYvRQoaR4eIF3mCjQb1W48zpM91IyTxPLbboJIqGEsTthELKrG2bQULOd5kobxzn2KvlVsyRuQbNUFIPJGnPoZQ2r2MnjLlla5G072AJM5dLkuSS98VDZ1f52qllgljRjiSWlZCxFZ7jYCO4bYvJ9u1tlwxv8EK/lUrziUdmOTRdQ2qIY0knUbiWURWnXYuX7ir3t0O2ZfettWRXvBMrzZ88cJ4zlTaOBbE0SuAglviOEQUdHJCUy2VGR0f73OgzZ85gWRbZXI5iochHn1jlxGLLCAu1hFSBViQJE8mOwSy//ab9z5jxs1KKI0eO0Gw2ue22275rO6mnW1pr/uzP/ox/9+/+HX/7t3/L93//9z+nj/906wXZfScnJzl16hQ33HADmzaZMfd32xy1NqvBhXpIEgZ0lmfJZrP4nkc1jiikPFRkPkA9scda8BclinonodqOiKWilPXIecbsM5TaNAXb3tAQFYwp6eRSh9VW3J3WuQzmXDKuTbUVMV5MMZpPIyxzKjYy+pi9e/fieS6J0nzt5DIz1YCVVtRVldmMFXxakSLlwu7hjLlfS2xoPv3YdJ17n6zQiSVRoqkGJgoo79vESnNwRx7Hos9j6fEGx8bGiKKYE2en+dvjNVYj42XWDCXNqEPVNfye8aLPTZty6wQXjm2UwD2u0UNnV/n80QXjAeVYRBJW2jHNKKGUdnnF3iHGi6k+r0Zr1tgImPXqpx+f50ylTSHtYFvQijSRUugEtg+meNetm7t5lWvW31pjd8FGIiV/89g8zdDkmYaJohEmJNK43b9q3xCvvX74glJxzYSjZxartebvn1wkkpq8b6N9CGIIYqPmu3OTz56sMUDtrZlMVNR4N/WgTqNR5+9PtIkSSNnGM7BYHES6NkGsef2BEf7N3bu/4/f8xfV8g79arcab3/xmNm3axMc+9rHnvDm/0Ou7toIR0I4TTi02EUGNTr1KuVSiFWs8FzJuL47vggk30F/ZNcOETqSY64QMZFxKGQ/fEbSihJRnM1JIbShO69W5lTaLjYiFekStkzCQ8xlIOyRKY1mCbUOZriAMKt0UmbXG7DPVgK+dWqYeSJZbRnE7nDWH1GaQcOuWItmU0183rxWVmfuXfPKxOc6tdAhixWwUsNTlVydSU8647B3JdFXIFo7vMOi4lEsllNLU6jW++Ph5nljWRu0qYbWTUO/EZH0H37V4yc6yyQtfk0yEoH9QbUeSv3jICDdyvkM9iGlFMZ0oIedbbC6ledW+oXWUGsu6sNGRUnJ2uc1njyyipGYw67La/c5pKkHZEbx0zwC3bSuv2y6Zv3/3oKrh8ZlVDk3X8B2LnO/QiBSdMCaWMJx3ecfN45dkOLPmfizL4shsnTOVFinHxrFtIgVBFBNLwWDG4ZVjMdvHBhgfNzzEwYEBBgcG+slVjUadI5OzHF9IsOi6S2RTuOUinVjhOhYfes9Nz5jytwf+Wq3W8wb+PvrRj/JLv/RLfPrTn+YVr3jFc/r430m9oACgUoonnniC5eVl7rjjDorFC2Ph72Y9EsSSj3xrikfOVZmttpmWEq8dMFHwqDfDbupGmpVp3Y29kUit++AvjBWfO7LAqaU2cRdELnfVaCnXIu87XD92Afg4tvGik9ogGKngC0cXeWq+ScazSTqK5Zbh/ZXSDgMZj5fuGkBpSdiOOHPmNKlUij27r+uaZCoemqzywJlV0m53LROayLR2pNhc8nnlvmFG8v46PsxaALZYD7j3yQpRotg+kKbSjGmERmDg2oKX7Rnkrp4H00W8QcuyqK6u8sh0k5ZyGSv5yERSDUxiRxhLdpUsXrevQNa7cEK/2NVeI/jmZBU0lLMuBeUQxJpmGKOBe24cu2QVIATrvhRX2wmnlzpkfAdXaFKWJJW2SLSD0vDOW8bZVLx05L+WXzVXDVhoRmQ8B8sSpDyblGsTS0kQKw5syq9bxW90nXqQsNiI8B2B6AbEp11N2nVodBJUHLB3z95+puna8n2jXBweHiI8dQrbCgxo1wJte3hCEwlNrR1f+Y39NGp1dZVDhw6xd+/ep5WY80xVo9HgrW99KwMDA/z1X//1c76W+V6o76bHPTFT48++dZ75akC1HeHGTYrCxY6MSf3BLUUyrnk/Wd0DotkcmN8/sdDk3qcqNCPjRdquKirNiMGcBxoObM5TTnfFab0kHyW7Br5wdrnNZ55YoBkmpFyLTqyYXmmz7NmUUg77x/LsHMoQJ5LFxUUW5ufZtXMnpWKRWCpaUczfPDHPStMkZiw2Q8I4YXo1oZRx2DOa46V7BtYdxoD+hDCRkq+fWuZMpcVg1iPrOyy3Y4JIstQMuW4sz+sOjFJIm6+8i4GTkjFnzs/xVFWQTvmM+Bb1IKLeTgglyCThFbsK3Lzpwgr7Yu9Dx7E5tlBjoRlRzhiD/0LGo9mJaEWSiVKaH/u+rZfQdNbGhWkNT8w2iaWmmLKJ45iSLxC2SzNU7BvL84OX2wiseW2OzdbRwsJ3TW5xMeWQ92zqQcxIzrtinGQPiJ5ZaqC5cAB3bfBSrrGk6UTs3DTM6OilVmlWV1FcKORZ0nk4NYVjm+viprC0JO0IYm1CGJ4JALgW/N16663Py+Hyk5/8JD//8z/Pxz/+ce6+++7n/PG/k3pBAUAhBNlslr17914i1/5uTsd/f2yRrx6v4MYtdhYE87WI5U7MqShh70iWl+0ZYijrUFGKThAaQjaGAIuAQ+eXOb3UZijrMpR1qbRiVpsh9U7C5lKOu/cP9w1TTVO4MC2ybYfpapvTlRaljEvKtenkPFbbsTFiTrm8/ZZNZpLXajM5eYZiscTmzZvR9CaRgsdnTdpFMe1QSNkMJMbyJJSSH7humAObLjU5XgvATlVatGPFcM5DaM2mcpoolqy0IobzHq/at7EEXynNuamzNBtNVnUG31W4joMtBCOeC2gq9ZChrEtrZYEjC9OGN1gsUCgU+7xBrTXLrYhGxwSZIyxs2yJjJWQ8n5VWjGWJDaena6vaiUgSieNCEMa4nofnOshE0ohMNuXVKlG6twMz4o/uF6Ft2YC6JkWaaxuHq0SCY0ssy5zg40SiEUyMj20I/i6uXMomqRqhULZYJuWn+rYQsr7Aww93+tYpmUzmO7I+er7BX6vV4p3vfCfpdJpPfepTz7oVwwu5no0VcLUd85EHpphZbrA1FZJ1Peamm8xFMYk0NkLft3OQ+ZkmYRQRxwm9WEfHtujECV87tUyYKHYNZVhtGXpGI0xoBjE/cN0wt29bI05bozJFCGxh8e3zdVphwljBR2mPetc4OlGa27aXeNnuQWzg/Pnz1Os1du/ZTSaT6auBT1Y6VDuSobxJzMinjXH0ajtmUynND926ecNUod7rFSWSYwstMr6L55h1a953jAdfEHPnjvIa8cn6ajVbnDlzhrrOoqyQgYyHQFDKOJQymlaYECcJZTfmxInjuK5HqVRcxxvsHVTnqgEoM0gQloUrFKUuGIyVvipHWwhYbUV9Tp1WkE6lsCxBJCOC+NreH4kCrRRoBQizAemu9q9VcevZlllRS2lWtFp3/1mRy7iMjY1d7RLkfAcNxErguzbZ4iBaCMJQIlCcOfooojrSz9j9TvjASikOHz5Mu91+3sDfZz7zGf7Vv/pX/OVf/iWvf/3rn/PH/07rBQcA9+zZs6ENxHfaHKXS3P/UAmG7zlAxzY5yiczkGQZElmo75sU7BtgzkiNJYnzf5+jRI93Eh1KfrH96qY1tW/iucU/fXEozlveYrQbsHMpcVtHVk/bPVtskSpP2HIQlyFgWadcm5zs4AoZzPtVqjXNT5xgfMyuRtd8TzSCmFcR9v0HbtsnYhjO22Igu4dZsVJHpCF01mOEbeo5DypPEl0nckEpxdvIscRyxZ88e7q9MI1WCTKRJ3FAKsLBsm3KxyHX7hoyHVL3G8vIK589Pk8lk+rmxKcdBa0UrNI3Od7oWEF219dUMtAFjNiolrVCS8W1S3fi3QBohyngps8589OLS2nClIqlphDEpV5B1bTzHph2aVc/O4RyOba/LTV5bsdJ85fgSYaIJuuRo35F4QhEkkE+7HJgo9lcpF/uDgWnCH39klpOL5r2RRIpEpdCxJFGCXNrjp157PTnV7Kdo+N2s1OHhYUql0jUZJq+srPDYY489b+Cv0+nwrne9C601f/u3f0s2++xmGX8v13fa4x6frjI5v0rZjhgZH2a40ybbSbPUshnKerzuhmFAkM3mmJ6eplatUSwVKRaKZDIZplfa3RxWI7wYyNuUsx6Nrjjt+vHC5b1NtaYTx8ytdsj5DpZtYWkopQSlVIaFRkQ57WGhu1m1MXsumYxrqu0IrRS2cY3GFoJiN6lDKr0h+FtbiTLAxOpeT9hmFZrxoBHERJfpcbVanbPnzrJpfBwR+aizs0SxxLHAsuyueMPCdVx2bN9O2qHPG5w8Y+w8CsUCxUKRfCGPa1vEStEOE2MaLcykNUFQynhozRUPubEyPrPtKCGxoJBN9bl5SsPEgOFHx4m8rDBtpRWbdX6siJOQtO+ScQW6O2W8biyP6zgovd7CZ22dXW5zZLZBGCvCWOHYFhlHmImnsLhzx2B/5WxsfC6lPp2ptPnTB8+TSI1CE7s5VKhIuRZaWLzhwAgvuXWkb5ochiEDAwN9t49rOSj2wF+n03newN/nP/95fuInfoKPfOQjvPnNb37OH/+7qRcUALxSfafNcXp2jpmFCqVsjsHBEo1aFQtFOe3SiWSfD4MQ7Nu3jyAMqFVrLFYWmZqaIpfL0WlDkiikcrtTImP+aXdPSFcrSwjDM+vEZH3TVBACqU3GZGVxgYXFBbZu3Up5w5BoTaIU1UZMMeVQyJiGGiYKz7YZzKWu2FiCWLLaiWkEkk7Uppjxyftm+BVECdePlXEcGykvAJ44Tvpk3l27dnNkvs1KO2a5FVPtmKi4ctqlEye4lhFuuI6Dm8+RTqcZGx0ljmNqtTq1Wo3T03M8uGhT7xjOZD2SZBwj/2+GkvGiz7bB9Dqj5oubypHZBh//9jRBLJFaUAuhHYVkPMPJu3NnkZwn+hwfs+q6QGoG+OKTi9x3fAmT6axpx9CJYnxXknJsfmD/MK51YYrbJ0evSRH57BMLfP30CrYQOJYg0YJOrAiBYtrlnbdsIuc7/axiWGtArUmk4v4TSzx8roojBJZrEdkZtLCpB5ItA2n+fz+4h+s2l4FyP0VjeXmZpaUlDh8+jFKKwcHBfqzaRo2vB/727dv3vBgrB0HAu9/9bjqdDl/84hcva4Hzz2XqO+lxcRxz5KmTxEnMpokxbNtmeX6OfMoj7nqQKg1oxcDAAKVSiUajTrVW49TpUzi2Q0tkSJKYOLGxhOlXwrJxHXMwudoBs8fJa4QJrmN1J/wA5gBkozh58iSO466LBuuV7hoxN6ME0YRC2sOzu7GfUrOzkO77oV6uKs3Q+PS1InK+8QtMezatUOK7NlsGLuVoLy0tMzMzzdatW7FSOY4dqxgD6yAh4zmU07or/og5sKlAIeUiLMFgeaDPG2y3W1SrNWZnZzj6RMwTKzbtUNMOJa6TMJCx0QgsrTg4YbY0TnfKlVzEYQxjxZ89eJ6n5hskyogugnrYF+rlUw63bskjlQFtZv29Xpi23Ir5w384azYqAkKpiDohrdCIBDcVU9y2rbQuN9npfqf1rlNpRnz4m1M0I4nvWgTd3OK61Pi2SSV62QbreMOHNIb/nSjhT741RSNIyPo2nVgh0nnCxAwgXnfDCL/0mt1kPacfG9lut6lUKszPz3P8+HFyuVwfDBYKhUum5z3KWBAE3HLLLc8L+PvSl77E+973Pv74j/+Yd7zjHc/543+39T0DAJ9uVJLWmjNnzvCNw2dw0zlOVRPauoGoL+IJM7XxHIvhvI+APt8vk06TSacZHx8jDCOeOLfIbK3GXFOy1AgoZ1xGCykSLXAs2D6QwXXMtKgndFhbJxaaPHSuSi1IWG3HZH2X4ZyL51iEUcxYUbK8VGf/3r1kMtlulM+FpjBTDfibJ+aoB4kRXYRd4+icTxBLdg1nGSuYN75ZO4h1yR1BLPnYI3NMLrUATStUtOMOK45F2rMopz1u31ZaY4hqEUcRp06dwk/5bN+2ncdn6vzt4QUSqfAdYdJDmhGNIKGUdrhz5wBbyulLeIPpVArP8xkcHOT+b55jIWiR9zSEmkhpmqFZUe8YyvKOWzZ1rRMuGDWvTRFptCP++tFp2qHhsJgoIjO9jBPFq68b4tX7LnhEKq3o8Zp7JOuVZsTXT61gWYKyb9Tb7UgSSo1rCf6vOzZzfd/A2tRacrSxndE8PFXDEpD2bFLa6pOrbdviJ1+y9RKrC/N+XP+8vnW2hkCYOEBhURoaRAqHTqx4962beenuwXW/b9s2IyMjjIyMoLWmXq+ztLTEuXPnOHr0KMVisZ8/mc1mWV1dfV7BXxiG/PAP/zArKyvce++96/i8/5TrSr3r6XIAW60WDzz8CCuBTUv7PDbToGRHEARYAtqR4rrxbDeSUfYN1MvlMuVyGaU0i6s1jp2osNSMmK9H5FMWwzmPYsbkm28tp02PtES/R6ytTmzSdJZbJlt8tR1TSDmMFnxW2wE5V5CszDA0XGLLli1oxbrpvFSGonNoukYQm8n+cstwox1L4NkWL9qc6x/Sne7EP1nTa4/MNvjc4QXakUQqzWpHUe90yKccXMfi5i0FhrNuH6zYls3c3BzzC/Ps3LkLL5Xhww9MMVMNjHCjE9MMY9qhAS/jxRSv2jd4id+g59q4xSKZTI6OV+TI6WkUiqIvaUZmLb1Qlx/cLqAAANXrSURBVAxkHb5/9xA3bS5cRBEyPcOyjIr3H04ucny+TtoRFDK+MemPTFjA7qEMbzk4xkj+AndWrqMamfz0b5yaZ6Udk0s55AV0uub4SsONmwu87eDYeo/VNXzv3nUePlejFUmynhlWpFxFJ4iR2uK6cRNJebFq92I+5JG5Fs1Ik3IdLAGlYh63kKEVSvIph9984z4j1Ov/vuinaGzfvp04jvuRao8++iiWZfXB4ODgIEKIPvi79dZbcd1n1kfwWuqrX/0q733ve/ngBz/Iv/gX/+I5f/xnol5wAPCZcMqXUnLkyBEenlzhoUaZZpIQJopjUwuI1iqDWQ9LwHWjOYayRpUmLHMSUlohu3mKU7WYB2ZicHzyqYRmpJhvxKw0Qwqexf7RDIMpTRTLLg/E8NqE7lqtNAK+cHSRIFFMlFIsNkJaQUw7jBnOe0xkFFtTCbt378H3vT7Y6J3swiThC0cXWG7GTJTTpsF2DEmbVsQd24r8wHUjfbWqVKqvnDV8D8GRc1Umlw3/cDDnUQ8k1VZEnCh2D2V504vG+vxFgGaz2bVmKDMxMYGwBN88UyWRioGsRzkDrVjS7BjhxmuuH+HF28uXTB/Xqtzm6xHnaxGFjI9vQz4j6EQmBxituTVXp1XRLEUm1P3Ch9k0J63hoRMzNAJJOZvCtm1KnqCQMhYwlgUv3TXYz1a+uHok65OLDcJYks94CGHhuQLPsYkSidQwWrjyykFrzWy1RRxLPNe8vnFsRDQpzyGIFWFydQ6i1sbIuvd3c/w0jpvCAWKp+xYWlyshRH+tvmvXLoIg6DdLE8XkEMcxW7duZXx8/Kr380xXHMe8733vY2Zmhi9/+cuUy+Xn/B6+F+vpTACXl5d56JFDfH01z2TTAh0yU+1wdnWWnKPJ+YZicmAsa/oCZqVpC0HS9X2TwD+cbXOmLhjIpYy7QKBpBAFZp8NAxuHGoRxhFPendj1aQ+8w/pXjSxyebVDOmlzyeqRYaka0o4RNeY896Rabx0cZHRldYznTTTjSmiOzNR6drpFxLbYPZKg0I1phwnLLgM+79w+zq6dW7QI/uNBro1jyleMVIqnYVPRpRw7VQNIKFJFUvO7AKLdvL/X7k9aaybNnqdfr7N6zh3wux+PTNea6zgyObTKLG0FEM5SMFVP82F1byKcu+s5Zcy+WLXhsukmCYCDrg4CSgkYQ0gwlE6mICb3E3GxMsVggm831eYO9LUEYRjx4ehHLsslmPbTUjGRd4pRNI0y4fjzP9sFLD5bmtRD96zy50MS2jLeq0oq0AxnXpx7E5H2H3BVoNr3rTK+0jSurMFNXFSdkPYdAQhCrq1q2CAHVdmgs04QNCNxsEceySLmaSCpakaSUvjyFxXVdxsfHGR8fRylFtVqlUqlw8uRJDh8+3Ae8N9988/MC/r7xjW/wQz/0Q/z+7/8+P/IjP/IdcbNfCPWCA4CXq2sFgEEQcOjQIRIFJ+UgoYy5aXOBLeWEw08usCw1zSDhNdcNccvWUn/yt/Yk1DMjfvR8nTBRxpYkr2mEkpVWiJSaO3fk2JlLONtdk5ZKRYrFEtlsti9mOL5ohBcjORchBIW0T70dstKKGHFj7hr32bFjx7qVyFrV68xKh6WWsVNwLMFwPkUpYyLTlIZX7B2+tDFxobGAMWYVWPhd/l0pbTypjMLPXQf+6vU6k2fPMj42zsjIMKCptkziRsazEZaFpTU5zyLn+iy3475n2JWq2omIY2M5gxBYliCT9nEcm04sGds6ToaAlW5WbiaT6fNqfN9ndnaW1Vq9e1oWgAYFlm3j2MauJ1EKuDKBuMcjklKBuOCfqC2BUHANNorkfacbOyeJowjHtg3gUmDZFqXM1ZtRJBV532GxEaK0RSFtVkOJMrORPSNPjyeXSqWYmJhgYmKCSqXCE088QalUYn5+npmZGQYHBxkaGmJoaOhZX5MkScJP/uRPcvr0ab7yla8wODh49V/65wJMj4vjqyu/p6amOH78OO38Fs5NN9lSTrFjMMvJmQpnqmZLMFFKcff+ITaXe4a83agxLhwQp5fbnFvtMJgzwonBfIrVZsBqJ2as6HP39hSENY4cWSCXy/UPHZ5n3uONUHJyqUM+5ZL1LHJeV3TRSYiTmAP5Ngf3Xkpr6SUcARxfaKKFIJvy0EqydSBDGEsqzZDrN+W5aeJScZsps3GZqXaodxKKGc/wq32LjG8TZx1akWJrOb0mss1wmqMo6ttrSSmZXe2A1kbYZVl4AsppF9cyDgob9dj1t6JZbgbYXODh2LagmEmR6IhiOc+mTTlq9RqTk2eB9bzBKIw4ffoUSli4jgUKhLDBAteyEKEkvsZ4RMcSXWPnnjCtKwIRAvsa+htAxrdRShGEJqfdcxyEZaGVYiDrX5XHCJByTP5vO0zw02ls13zPRFKztZymcLXXdE1ZlsXAwAADAwPs2bOHRx99lHa7TTqd5sEHHySbzfa50Rutip/pevDBB3nHO97B7/zO7/CTP/mT37PgD76HAGAvKilJkstaSPTirQYHB0mN7mDx1EnGCj5CCHwdsLXgMpzO0gwlO4eyl7X6AKOwrTQCsp5tQKINpbSgmLKZb4SMDxTYtbnQ9TxqGBHHubNoDYVCnmKxxErDrGKEJRDCxsZ4xtVbCY7rsWvXrg1jc3oVK8OnsFBoba7h2jYZ33BMrsWR3sKsMRMpu7mbypCbEesee3l5melpw4dZO7HxHXNSD0Jz8vMcBzD8RcuyyXrXItwwU4elZkjWd8h0p2dRoki7LpsHC/hO6RLe4ML8PAiB1uYEGc7VWaiHZHzH/F00dKKELeUMA7lUN0ptY1JzI0g4NtcgSDTtOMJ1bHKehWtDGEr2jWUpZfzL8g8BKs2Iv3h4hjDRSK0NsEbjC00ojYJyNO+v4zFefD/LrZgP/cNZKs0IqUFpm2pskxFmorpjKMMrL6PIvlotLy9z+PBhrr/+esbHx9Fa02g0qFQqTE1NcezYMYrFYn+Vks1mn9HmJaXk/e9/P0eOHOG+++5jZOSZM7D+p1C2bdPpdC7775VSPPXUU8zNzXHbbbfxV0+sdld0po8VRZv9Y3nmawGbij5bypkNv6h7B8SFegeltRFjWRZpF1KlNBnPwXMt9u8w1IEwjKjValSrVWZmZkin0xRLRdoYJ4FS2umK0ywyliCJAqqhZNPmictwmi9UJ5LYWnfVqobCkvIcXDvuR81dqXpmylGcYLt2/1CHBUKYPHUwnObJyUmEgD171vMQXdsikoZSknLpTucMt7eY9rq99/JEyERpHFvQDCUQkU15OKi+Rc5YKcNAuUypVERraLWa1Gp1Zmdnic5G5hpuFs/VVKohYazI+A4pR5AojbBgx1BXmCbVZQVuj03XqXVi2pGkE0nSnk3Os4mkxhFww3jhsvxDMAeD+04scXimTiQ1kQTbMs9dSokt4NZtZo1tWRa2sC7Juge498kKf3esglSaBFBWFtWOcSyBbQved9eW/t/l6ZSUkieeeAIpJXfddReu6/ZXxUtLS5esigcGBp5xo/lHHnmEt73tbfzmb/4mP/3TP/09Df7gBQgAr8aRudyKZH5+nsOHD7N79262b9/OmaU2UpsPtedY1FaXEJbAEjaW0FcEXmBsPpQ2QNDprvjQGoXhofhebyUiKBQKFAoFtN5Cq92iVq1xfnqG+cWYlaaNTBLKuTQ2CY1GC8v22LV5pB+mvlFJBcstsyatdmKKGZeir/Bdm0ZggrxHi2ms7sRwo9ft5EKT89UO1Y7hDxYyLgNph7C7st47nMW2LRbmF5idm2Pnzl3k8xeI+o0g4dOPz9MIE9qhohZIsp6Jsqt3EkbyPjuHMxdWOupC0+vVofN1Pnt4njBRJtYo1vg2ZD0bpeCuHQV8x0z11vIGywNlzk5O0ukEPFCxOb5UQymQGmpBQjNM8B2LjGdz93VD/ffFWnJ03E3/iKXiww+cZ3qlg98NmI8SyWpiHO2Hcx5vvHHssvxDKRVSaf6/B84zV+vgW6Y5SgFBopHKxBm953aTZrD2OheTtT91aJZKIyTtWkgFcaoAQtBJFHfvG+RXXruX9GUPJpevpaUlnnjiCa677rr+2leIC+/Ni1fFZ86cwff9frMsl8vXpCq+XEkp+bmf+zkeeugh7r///muyiPinWN9pf4vjmMcee4wwDLnrrruMJRCrRN1osiTsEAUhtiW6+b5Xt1QSAoJIUmvHZNNOP54sUoJB3+1PenzfY2RkmJGRYeI4oV6vUa3WmFyap960aLQtSmmPQsYj6LRoh4pSIcfESPmK4Gm5FdGOJZWm+d9ixifvib5NyZaBLLZtoy4Dejqx5MhsnXonodJUXeGGTdZ3qLYiNpVSjJdTyCQxKvqUz9atW/uiFYBHp2p8a3KFdmT4h55jMZAxgBatODiRNxZRtnEs6Hm79qodSf7yoWlOVUw++nLX3quQclFAMe1w06YcSiuML6v5TGYyOXK5HGfPTtKysnzhREAzVigtaMeKdhziuxaebbFnJMuekcyFlXNP4LZGmPbYdJ2PfXuGRBrFdKKE4TfHioxn8ZJdA+wcyqzjHzq2SVvquRQcOl/jC0cXkUrhW+Z9IJXZfOV9h9cdGGF/1z9wrRXQWsHdmaUWf3esgtaGhhApC+VniJUmn3L4hVfv4p4bn360pZSSxx9/nCRJuOWWW/pr341WxUtLS5w8eZJOp8PAwECfG51OXzl/+Wr1+OOP8+Y3v5lf/dVf5ed//ue/58EfvAAB4JVqI46M1prTp08zOTnJi170IkZGRqi2Y+47UWF6pcNTYULBTcgEDQoph5V2yKZiipF82pgkb3CCaQQJX3yywkpX8braNrFcYwWf1U7MUNZjaymFbVuA6MeeCQG5bBbHS/GNeViSDUIZM9eIqTQj8q7xBRzIe+wfzXbVqhf4ML0Ps9Zw75OLPDJVA2EsXBYbEasts4JMezbft7MM2lgDXMw9FEJzptLm/zw2TxBLMq5FO1YsNyLq7ZhSxuHAeIF9YznOnp2iVquxe/du8rk8ljCmqkpr/ubxeY7PNymlXSxi2l3vwUgqtg1keNvN432g3FvpIExkExoqjYDPHl4gjBXjBZ9qENMKJUFsIp9etX94nf9gjzcYxwnnzp1FCIE7tJXJ0zPk0h6OBe3Q8P4SpUnb8JbrSuwaWD8R7r9HtMayHZ6aazG92iHtmyiprO/QiRKCxPgi/twrd2zAjVlvhn16qc18I8RG4zoW6ZRDIk0skudY/NRLt13W46t3P/VOzFOLxlJIWKa5lwbLJMpwa15/YOw7MkXtgb/rr7/+isBr7apYSsnKygqVSoWjR4+SJElfVfx0V8VKKX7xF3+Rr33ta9x3333Pi+jke6mEEH2R1tq6HAew1WrxyCOPkM1mufPOO3EchwcnV3jsfI3J5TZz9ZB0p8KAZ9SaAs32waxJrFH6EmEZwOPTdR46W6UeSFY7LTKey1jew7bNqvj68RxWF0xq3TtkGm/UwcFBFiOfIy1NTEgnkNTDAL/eIe8KcFyuH8uSdUVfWLD2QAYwXw/5xCOzLLXMmrHWSah3EnK+MWXfOpBm30hmzcFuvaWS0vCpx+Y5vtAk65sozVYkaUcJWT9hOOfxA9cN02kZj79SqcTEli39aMg4lpxbafO5IwskSjOc81hpxQSxZL6uGMy6vHh7mYMTJXrrZriQBATmff/VE8ucXm5TSLtkfU21kxDGknqYsG/EcKzLXVrI2oNhrVZl+vx5tm/bxscP14iIGMp7xImkGSmCWJEkitvHPV5zfWkduWWtwK1nxfKVE8vESlFIu6DNwTRIEpTSvO7AKC/bPbjuQCAE/bSl3g8emKySKI0rFJ7vkrUsokQSxYqX7hng5Xs2pnOsvZ/Hp+souhZfaAqlMm7WpxmZgcHbb376nOSLwd/lpnprV8V79+6l1WqxtLTEwsICx48f76+Kh4aGKBaLTwvAHT16lHvuuYdf+IVf4N/+23/7jwL8wfcgAFyrkpNScvjwYWq1GnfeeSf5fJ5YKj70D5McmqqyqZhiarXN3PwixEbBO1ZM8f27BwHVXzEYZ3vjji+V4ktPVji52GS04OFYglooWW5FBLFi13CGH7x+BN+1u1FErL+G1nx7aoWTlRZDOZ9S2mO21qEdShqJxbY07E83WJk5i+x6caXT3S/9rsrt/EqHQ9M10p7FYDZtUj+6p+WUa/G2F42xZ52T+4UGJYTAcWwemjKquqGs+SJvxYpmJyaSiju3D/DKvQOcP3eOMAzZs+eCCEViAGilFTG5GpBNOaQdkwkaxopmkCAseM/tmxnKbQAStO6rBU8smEzNUsZDaMVANkUxpWgEMRnf4e79a+LWuhXHMadPn8Z1TTj83x9bQmpNynPNqTJtk08bDz/PEWRli6NHK+t4g6lUqr/GUUpyfrkFdE+8GK5f1rexLUEnllckRvdqfrWJTCSeK3BcB7BwbPC1RmGmEVczeY27voIWAqE1TjZvpgKWBgGt6OnbHFUqlf7a9+lM3Wzb7vNm1q6Kz58/z7FjxygUCv1mmcvlLtvwlFL8yq/8Cl/84he5//772bZt29N+Dv9cpi7ub2DW+o899hgTExPs3bsXIQSPTFX5o6+foxNJRnIe8yt1FpdWWXBtRnMe148X2DGU6V+r1xMMkFNMrbS578QSSsPWgTTzdSNOm4wTNhVS3LylwI2b8v1EiLX3JzAE/y8drxAmml3DWSr1kJVmSCAFni24LhszFC1w7lyHYrFEvpDv+sWZA7AQ8M0zK6y0I8YKPon0qAaSajskSDR37ijwyn3D6yg6ay2VLMvi/Eqb00ttCikH3zETyHoQ0QhM6sWP3rkFV4acPDXJ2OiYoSOs4XlbtjHXjyQMpB2jQk25tIKYRpBw0+YCrz9wKYVhbaKQ0vD4bB3XtnFtC8eC0bxtLFOCmFu3lthSvnTqVKksMTs3y47t2xFehqnqAr7rYNk2nhAMGH99qp2Ism8xe36KWQy1qFAsUsjnLxgma02tHbHUCPFtGzBbpZQDvuPQDA3ovhpe0Uozt9pEKIWXchGW+VunHNtw+a6xNwWJQiuFsAVYFk6mO0EVJlLw6da1gr+Nqqcq3rZtG3Ecs7y8TKVS4dChQwgh1qmKr3Tdp556ije+8Y28//3v59d+7df+0YA/eAECwGtdkQRBwKOPPopt29x11139icWxuQZHZ+tMlNKkPYuCKzndgOWWMTd924vGKWfXE/XXKlaXWzFTtZByxiPlWGwZcBmMEqpt46v0ppvGNgQ+vWtoDcfmmqRcB8+xCTsNhn2FW8iwGkhesn+Eg5tz/TXKwvx831m+WCyRyWQ4u9wiTjQDWUNIKaQsCimTK+lZFrtHruSnZk6351fapBwTFK415DxBzrNYakZ4NkyeObMhH8b8DaDWMokB2bQLAixs0q7VtZeQBNegdg0TaUjIWhmldXft4NomhN7E7V34e4ddMnQmkzXeXJZAdB3opZRYwgI0CAuEjefa7N27mziOqdfr1Gr17uvpUigYwno2mzXrVm3U2p5tOENCmID5UurqHJ92u011aQGNIJQChMK2DL8oUZDxXUp9cvTlr9NT0LVCiact/FS++zopXMviRZsvR3jfuHqCjwMHDjA6+vTXKr26eFUchiGVSoWlpSXOnDmD53l9MDgwMNBfFSul+PVf/3U+9alPcf/997Nz587v+B7+uS5dAffEHtddd13fxFtrzb3HFmnHkp1DGaRKkQqWWcz5BInitu0l7toxcJFSU6+zcDm+2CKSMJb30EA+5VIPIlZaEdeN53j1vuFLAMNacdqZSotGKBktpIijiIyIyZc92soi7Tm866XbCIMOta4/XnwuNulA3QOvFoLJSpus7xpQKRTDOcukMTVNNNg6q5KLSinFbLWDlAo/bbz5XAvKtofvdpNBWg2m56bZsmUrAwMbqNC1ZqkR9I2ahbBMAknKIUquLQ1IaWNB1XODNdcRuHS9Xy/iMGoNCwvzLC5W2LVrF7ms4aMLbbzxtOryF7s7KWFZDA8PcWBLsU8tmpudYyo+Ry6X74pyCviOjWXRNWxOsG0z+dVYCKHJpq4sTNMazk6dwxeKOoIo0fhuNzDArJgYLV7ZYB+Mg4FUhuqjtCSdzxmRndYorblta+mqr+naklLy2GOPoZR62uDv4nJdk1wyNjaGUopardZ3TTh8+DDlcrl/IF67Kj558iRvfOMb+dEf/VF+8zd/8x8V+IMXIAC8UvVWJD2xx9DQEDfccMM67tJcLSCRJiVDa0haNYYLPqkuQTifvvJTboYxUSzJe8bWwBKWaVSWoBkm19QYwkSCVjTqdbCMZYewBPWwg9S6v0YZHBw0ubKNBrVqjdOnT5vc3TBFIiVxnPTtXMwbz7oqdxFMs3YtQa0tcW3jSK+1mTIhBLWVCtvG0mzdtm0dH2bda20JYmlMQXO+Q9rVfUPrlOcwdBU1WCwVjTChE0nCRJHzXbp4ljCRXDeeJ+U6/fV5pxNw+vQpSqUSmzcbLt1iI+TccptWaCLeMp5DzrcAiZSSA5vLl/gNSqVo1BvU6jXOnj3LdFPzrUVrnaN9tmusqpXijq0Fesbemg0C5lst7j10hm8tGkVgrDShBFcY1aAGvn9nCbvbGm3L8Gp64fC9OjJT5yMPThMmBgzHToZaqHGTGMeyuOemkQt2F9dQzxT426h831+3Kl5dXaVSqXDs2DFjp3PyJGEYMjU1xSc/+Unuu+8+9uzZ84zew8X1u7/7u33uzX/9r/8VMIfAf/Nv/g0f/ehHCcOQ1772tfyP//E/1r0eU1NTvP/97+e+++4jl8vxoz/6o/zO7/zOM04Ofzp1tRVwT+wxPz/Pbbfdtk6UFUvN1GqHYsp8pqOgQ1rEbB1MM1cLyXruVW06qq0IW2g0GmFZOEA54xHE3en0VVqM1IDWhJ0O7XabXC6Hn0qh2lH3y95QYXLZLJs2bTLpQDVj43F+6jzpbJY4SVBYSM94dKo1liHXIhDwLMv0mCAm4xt7G4E5kHlCsTA3y84dOykU8hv+fqI0jhC0wgQB5FIejjBARQvBaCHVBS+XP+guNoyVU6Ud04kS8mkP37EIE4ljC3YMZbvejsYyZ2Zmhmp11cTgpdMoDU9M1wmkohVKXFuS801KVCuSpB2LvaM5XMemkM+TSWfZvHkTQRBSq9VYXV1hcmqaR1ccmh1NrLRJJbIlua75cj7lcP1Ytp/frDGWWD0go5TmxOmz/M2JFsuR4V82woRWJMm4NhJNwXc4uDlnKEvdTZeGddeJpeIPv36Ok4ut/usb2FmSdmx4jymX99219ap/1/57bA34u/nmm5/Rz6tlWX0vzLUG1L1EEt/3+dSnPsUtt9zCBz7wAd75znfyu7/7u98VR/pa6vnocd9zAHBlZYVjx471xR4XI3KtNPUgZrbaIedo2u2GUYdqGEy72Fy5ucSJ4XWdX5WUMi75lMYWJtw847vG5+kKNbXa6YaYB2QcGCll0VrRCRSubTFRzuDYdp8PY9s25VKp7yw/ubDCmWMVakFCtZOQ9SwGsy6+69KJYm6ZKBsPJMGGUWVBLPnckUUqzYh6kNAIEzKezVDOo96JcVTM/tEiO3dux7EN93DtBxngcNf4OUyMr10zUqQcQc4z64Dbt5VIuQJYL5ToAadYaT767VmOzTcAuuArpG4LfMci57u8dPdAf6LQbreZnJxkdGSEoW4M3mo75n9/Y4qVdoznWoSxpBFEtEJBxrfZUkrzst2D6yavtmVhu8botlQqMlsN+OhXz9CJFCkbAqmJpaLWUWRcm4NbCnx/lxuTrJm89JpltVblsafO8MCiTaIhn3ZohQmJVETCrJFetXeIV+83PMa1vBqtTYi6EBDFio8fmiVOVF/8obIFeq/YT798Oz/84muPaVtcXOTw4cPPCvi7uGzb7lvI7N+/n2azybFjx/j93/99KpUKN910E5/85Cd529vexnXXXfes3MPDDz/M//pf/4ubbrpp3c9/4Rd+gc997nN84hOfoFgs8rM/+7O87W1v4xvf+AZgvkTe8IY3MDY2xje/+U3m5ub4kR/5EVzX5T/+x//4rNzrd1O9FfAjjzxCGIbceeedZDIXe7+p7gQsQABRbaWf9mELw2+9UgWxJFGKlVaE0lDKeHi26Hr0CUaK6csC1N7vLzZCVlshyw3NUCGDsB2kTGiFCfvHc2R9t9+bhIB0OkU6baYv7SDkH47PUw8CGqFxBiilHAZyHo1QkfUsdg1n+6KLjVT9Ty00ue/kEq1QUg96wg1jrt8OQnaWNfv2Go8/BN3p54Xn04klH/v2LCcrbcJE04lDVtsxxYyDUlBIOxzYlDd0jTWCi7ViuxMLTT72yCz1IEFpaMSadhyS9gzP+IZNOSZKJtdbK8309DStdmtdDN6XnqzwlRNLaG0mhrHSrLYTWrYkl3L4wRtGyPv2Or9B27LIZjOkUilGR0f4q4enOV6t4toGzElsgsTQm4byPu++bTNp114n2hDCwnHMz06fPsXXpjosdAQpx8K1NJ3EHMrbsWTHYIZ33bqpb9uydlvW454DfO3kMicXW7iWhe9AYqdRtovUcMNIjt944/5rtreSUnLo0CG01s84+NuoMpkM27Zt66+KJycnOX78OH/4h3+I7/usrq7yyU9+kje+8Y3PWo7589XjvmcAoNaadrvN8vIyBw8evMRiQmvNvU8u8n8OzbDcjJirBdjtFYa8GNcWxIni+nHTEBzbYW30Ta8emarxD6eW6cSSdii7qldBKeUi0dy+tYhnm19xnUuv8dR8k799fI6VVoAlBC0J51Y65FM2acfmwKY8m4q+sRjhAm/Q+DZpakHC55+qs9wxuZG1TkwzVLSikKwTsKngsK8sCMMQ13XWKbl6xqz3PlXh8ekauZQBiY1I0QglQdxhwNO8dn+ZvTsm0NqkcMCFhqC7XwyfPbxAEJt4tmo7oRmZXEnHMt6DF4Qb64USZp0jePzcCk/ON8m6NqWUSzNKaARmerol7/OOWzaxrZuf3PMe3DS+ieHhIXqg8ttTy6x0TPSdEIJQajpRQpQo9o/mePftm9epZYVgnVO/EJbxcZSCQtr4MOY0dMKIINGMpWJuLbZYrixQLJb6vEEwTW61VuXsubNU7TIJTTKumQYUMymklHSihHLa5Y2XUbStXZmdrrSodySu64AAN+WTyedIpJko3rq1uM4V/0rVA3833njjc26zIoQgl8sRxzFJknDvvfcyNTXFZz/7WeI45jd+4zee8cdsNpu8973v5Y/+6I/4D//hP/R/XqvV+N//+3/zl3/5l7zqVa8C4E/+5E+47rrr+Na3vsWdd97J3//933Ps2DG+9KUvMTo6ysGDB/mt3/otfvmXf5nf+I3feF6io65UURQRxzG2bffFHmur0gj40FcnmVrpMF8PmV1t4DUXGSv41AIjfNhWTvVtiNYKywDqQcLfPD7P1EqHTqJornaoNEMGMx4azWDWY89QGq31hkrTKFF88rE5npqtGlqGFszXTQJIzncopY1won+YEgK3a13SSyJ5cKrBQzMhGd8j1glhoqm0uk4HvsXt41kcFZEkhivYiyrT2kQ6LjZC/uaxeTqxZLTgs9SMCKVkoa7IebA9D/fcvod02t+wN0kp+YeTK5xabFFI2WR8m9W2EW5U2wl7R7Lcc9Mog12a0FqBQ69PJlLy+aOLtCPJUNYlkvS3HXGieM2Nw7xs92D3kH4hT33Xrl04jokTbUUJ35hcxRKQz7hIqenExr7FsS1++I4J9o5eRPW5iJPZCCWH51qkXBvfscn6miiRdCKzqn3pUIjXWWK1Gq/nDaIJo4izk5MEUcLZloNlKRxb4NgCz4MkMTZdL9szcNms+7Xc88MzdRCWyYjXinxpANvzaIUJIwWf/WPXFgPZA3/AcwL+Li7XdcnlckxNTfG+972PH/uxH+Nzn/scv/Vbv8Xdd9/9rADA57PHveAA4EY79p7YIwgCNm3atCH4OzZX568emkajuXlrkeOzVRYqdc416ecf3rgp3532XIi+cbqk5IVawDdOr6A17B7OUGnGrLYimoEk7dq8at8Qt28rde/x0mtIrfjKk3M02h0mSmmwHVY7STd1Q/OD1w9y+7byOtHDuumVbXFsvsVyO2Yk7yGEoJzxaQQh9UBy3XiWl2/xaNVWODo/SzabpVQqUigU+yfKViQ5Nt8m47tkHEHWcygmklo7IkwS7jkwzMFdG6mwdJ8w/tRCk1aiGch4oDVDeZ+ydKl1c4zv3j98WUPRXjM4sdBEA55rrHPyKY+c71DtGDV1D/ytrq4yNTV1EU/HgMozlSYWxlxZA54A33Gpd1MyrmaVorVivt5B9KIDhYWFNoazYYKXyTI8XKJWrbGwsLCON5gkMVNTU2zdto2zUwFijZkq2qxBHNsyiSzXULLL8aF7HTfbjUXrWk3Ia6AVwPML/sC81z/4wQ/ye7/3e3zxi1/kjjvuAODHf/zHn7XH/Jmf+Rne8IY3cPfdd69rjo888ghxHHP33Xf3f7Z//362bt3KAw88wJ133skDDzzAjTfeuG5K+trXvpb3v//9HD16lJtvvvlZu+8r1UY9bmlpiccffxyAgwcPXrJuUkrxkQemeHymzp7hLPmUw+mzU6y0IsJYsW8sy937R/C7B5U+5U/0AJTmwckK06sdRgse5YzLYiui0YlZakXcsqXIK/cNUehSZC5WmjqWzRPTyzw1s0reE0wM5KlHimrXwmUk7/Omm9anCqF1P3NWCItQag6db+A5htNcyjo0AyOYcCzBm24oMWCHfSpMz3g6lzOKZK3hyfkWrUQxmHWwsMikXNpBzHIzYDxj8WMv37thMsQ64cZMA9ex8RwHVyvSRZ8wkdQ7CbdvK7FtYOPEjV6fnKuFrLRisikXYVn4QuM5LjJtRBdbymk8xyJJJJOTZwDWZSDLrjAtiGQ3G97CtiFnQdqz6ETqmg6ElXpIIiUpu2ewb+ELC9dRtCNJaWQY142Zn5vn3Nlz5PM5CoUi+Xye8+enAJjYtoPkqVPYAtACYRv1rmsbClAnvjYDaqlBK4VWAsv1sb0LQCmW19bfLgZ/FwDrc1fz8/O84Q1v4CUveQl/9Ed/hG3bvPSlL+V3f/d3n7XHfD573AsOAF5ca8Ue4+Pjl5wIdPeE+uCZFVpRwu7hLAjBrpwkN5RlqRmxfyy3oYRdCNGPX5tcNqkd4wXTwMaLDkM5j+VWRCHlbhh31rtGIiXHzkyzWOswVMyQSqfQWjPmWAxlXVZbMeOF1GWjykTXmHV6tY0tTMIFQMoF3/ERRHiuw7aJcWCcKIqp1apUqzVmZmZJpVOUikVCO0MUJ/3UDgQIrfBJwHFJ5Tbmw6ytWCroTjX7wg3HxnNk17hYX3WNLjDPRytp7qPrgdUjOMMaJdyOHRQKl4ofUq7VDUSXuF0FobAstLDJ+dcW/ZN2bWJlVvq+26Uwa7PqGi2mGRocYnBgAKkUzUaTWq3G5OQkUkpyuZz5b7XukpsTfNfBFaYhJkqxZ7RoJgLJpaaqvVIaVppm3daOJI7r4Tvm/REmksGsxw2brv53WVhY4MiRI88r+PujP/ojfvu3f5svfOELffD3bNZHP/pRHn30UR5++OFL/t38/Dye51G6yGh4dHSU+fn5/n9z8Yq898+9/+aFUOfOnePEiRPs27ePY8eOoZRaBwC11kyvtDk622As75FNOWyzFTIPNTuN1PDa60YYKWxAT+kqX2OlObHYIptycR0H21Js99KEeZ+lVsSBTXnGNvr97jWarRaHTp4Hy6JcMmkLJVtTSplUoWLKWQ/+Lr0IC7UOnSihkHbM9gObYtpkztaDhIFSgW0Dma65vvk8Tk1NoZSiUDAikpVWCEohcLqNRiOSkLQj8LO5q8aCKa2JpMQSGo0y/QlByoGmSK4pytGcAzVaSbRlwK2gKyQTXe/Ri9wMLuZa+64BWlFsRCC2baGFQCmB6ALBq1U+ZZTdrViS0hrP6Zk8G07zxHCJwbTb5WH2eIOrTE9PY9kWw8PDtIMQ17KoBwmerfEBSxjQZlkW2wezWMLwny9HzVxuRSTKCGda0YXe2WUV8LLdl373XlxJknDo0CEsy+LgwYPPC/irVCrcc8893HLLLXz4wx9+Tu7h+e5xL2gAeLHY49SpU+uikno2BVprap3Y+M9136We7zFYzNGJa5fls6wtpTG+eqq3FjXrC9+xr/j7Smmmpqao15ukUmliZdYMtm2jtYUWGsu2rkrMBmNPEsSSVhCT9d0uh0aghKCQ9tDdaZbnuX3FUhwn1Bt1Yz69vEC7Y9EMBDnfxbeMWMLyfNKWzXAudXXhRmCyhsOaIpdyyXqYxI1Ycv14gbTvIOWl3MNezVQD5mohrVDRiUNyvkPet1HaKIKvHy9QWaywuLjQV8KtLa3hwbOrnKq0CGJJEEtSjk0+ZZFECltobtqc50LaxvpgeDAm2p95Yo7HpuvEUhMmMXYoyXoWSoNjC27fVkQp1ecNlkoloihidXWFiYnNhGHMXz08w8mqQipBAkQywbFMg/Qdi1fuGegSvMFxDMBda1cB8DePzfHVU8tobSCi8vPUQ4lnKzzH4hdetbPrmXX5WlhY4OjRo9x0000MDw9f9X30TJfWmo985CP8+3//7/nsZz/L933f9z3rj3n+/Hl+/ud/nnvvvfdZ490836WU4sknn2RhYYHbbruNYrHIsWPH1sVd9t5P9cBYOA10VzpKKQZKRRy7wUozuLo4TZvDj+hOaizjk4TvCJMWdIVfbzabTE6eJZ1OYbckcSJNZJkGYRnrEce5BuGGY9T4tU5C3lfdVCFIulSWTDdVyJjr5ykU8kxMTNBut6nVqszOzrKwGNMMTKJRPuWRRJ2uPY3DpmLmqsKNSiPCwqT6dCKrK9wQXYGYzfbhXJeLeWkSEBhxw4mFJu1YstpWeK5NoSvcaASSvG8zUfA4c/o0mWyWic0Tlwj3qp2YLz1VoRMrmsqAv6xnkXYE7VCxYyjDaM7HtmxYQyVZW+dXO/xZV1SWKE2QaFzLbKtiqbl+PMdwV3XX4w06tsPq6ko/qerEXJW/OVGhkwikho6EIInxHAsB7BvNsbWcMgIdS/RdGIyvpLmPhXrI/3v/JM2guxETNh2RIurExhJoPM+bbroyT/mFAP6Wl5e555572L9/P3/6p3/6nKyeXwg97gUHAHtf5HNzcxw5cmSd2GNtVFIP/PVOyzuGszwwuYpUGtsSFMuD5IoD1O0aB/fmKOUdqo3mho9Z7yTM1QKWW8b0eTCXYiBtY2mTZXjdthKe6yCVWkcE7o34O7FiyS5TC2q0uxE8g1mPYtpmpRkzmveYKKWNYOIygOX+kxWOzTVphJJ60CbjOYzkPaJE4VmC68eya7h6F8xdXddhcGCAVenz0GlJREgQKdpJjIMi7xvz1INb8gxmL/AGL5CjTcVS87FHZnlqvolWmrZUJtfTsfBdi7zv8JJd5f7vbESOnquF/H8PnDd2NY7h7VU7Mc3QiFl2DmUZt1ssLNbYuWsX6VQa27K6HEbDg3xips7fPD6P0pq0a9NJFEEiCVuKQsrm5XsG2Teauyi1o0dqNvfy4NlVvnl6FcuCvG/Tis2atRlKhnIub75pnB3dYPUeb3BxscLiwjz79u0jk8nw7bMrnG6s4joOPqbBxkqRKMFQ2ubtB0fNtJke30/Rd1XtHh5mqx2+dmoZIQQZTyCxIJNFasj6Dv/PO2/gtm0bWFSsqR74u/HGG5838PcXf/EX/PIv/zKf+cxneNnLXvacPO4jjzzC4uIit9xyS/9nUkq+9rWv8d//+3/ni1/8IlEUUa1W152QFxYW+n6IY2NjPPTQQ+uuu7Cw0P93z2dFUcTjjz9OFEXcddddfeuJXtyl53nrfPg2lVIU0y7VdsxowcfzUwyNbSJOB0yUA67fPkyr2eivXNeW1nC60qYZJiw2Iwoph3LGo+DbNEMDGrYOZowK+SJe9MrKKufPTxGmh5lbCljtBNTChGLaYzjnIGPjeLB3ONf/LK/tK72aq4X87eF5GkFCECtWHJtiKqGYcqh1EvaP5RnMuP0v/7Xm+tlsBi+V4utzMBvUSVTMcrsrknMEtgNZX3BwS757aDaJG0qt77UnF5p8/NAc9U5sEoVCRTMKyLiG0nHDeJ6Jot/vZxsJ3P72iXkeOlvFsQSREISxphLHpF1Fzrf5gb1lzpw+ccHNwDLerr2+LzV85FvTTK92yPo2rVAilabeSQgdi03FFG+/edz0RLUmtaN7SFRKEyUJf/rgNCutiIJvFMOR7K5ateSmiQLvunVz/48vpSSKzEQyk82wY/s2pIJ/eHSVSFlkPKOoDhLzLONE8ZLtOd50cFMf6GmtkbrnNdvzhBTc+9QMzSDBdUyGsk4VkV3A+4YDY/zfr9l9RWHSCwH8VatV3vzmN7N9+3b+6q/+6qpT5GeqXgg97gUHALXWnDx5knPnznHw4MF1X3o9n6yLwZ8Qgrt2DPC1k8ucXmox2DU/Xm5F7Bgp8OY7djOY9QjCiMWVKpWVKsvVBmBAwScfm2OmFpByLBphwmy1w3LTSNdH8h63bi1d4LJYFo5lgOjJUyfxU2mO1TxOLjYppB2kNiqq6dUOtY5JD/mB64axrAtK0x5goetNd+h8lW+eXsVzLMYKPkstk+d4fqXDpnKaV+4dZPtghrVcvR4gBmgFMZ95wkS2bS6mqNTbtGOItaCTwHUlyQ6xzNmzMcXSeiPRnsP+49MrPDXfJOvZlNIujUjS6ETEUjNRNg7u29aQgddyhHrXeODsKrUg7jrfC5O7G8TEUnHzlhI3l2PCdqNrPG3WRVKpvmrWti2+fmaVREMxZRztcxo6UUyUKF61d4i7r9sIBK1/XR46V0OLXkaqxncdokQSxIo7dwxwy9bimveb8eaqVJbYtWsXqVQKpRRPzDTQWHhdTlXONWHo7VBS8oHaDMeOLVAsFigWS2Sz2Qsn/S736cm5OkqbaSEI/GwBP+0TJYooUewYurIqbn5+nmPHjnHTTTcxNPSd5QN/N6W15hOf+AS/+Iu/yF//9V/zyle+8jl77Fe/+tUcPnx43c9+7Md+jP379/PLv/zLbNmyBdd1+fKXv8zb3/52AI4fP87U1BR33XUXAHfddRe//du/zeLiYn9tfu+991IoFLj++uufs+dycbVaLR566CFyuRwvfvGL100bjG1I0u9vPQuoYtrj7v1DfOLQHNOrHfIph0aQEEvNu27Zxh03mOzn1XqTheVVFperhJHJmX30fI37ji+RSI0tBNWOpN4xJspZ3+GO7SUG0hd6q207WAKmZ2ZYXKxglzfxteN1wkRRTLvUA8lyM6TWiRjOehzYlOe6Tfn+ZxnWJncYYcOnHp9jsREyVvCpNEI6sWK5KYkSxd6xHK+7YRjLEuumXWsN+h8+t8qRuTrZlEPKMX6tsYJWAuO+5kWFNs2Fc8wHxXWirt59SKX4u2MV2qFkOOcTSUU9kLTChEhp7r5usC/cMKXX8bxt26bSiHj0fA2/a4yfSynaYUI7EqRci/fcPEywPMPQyDCjo2MGPHWBH5i+f7rSYq4ekPGMeXTGswkjRSuWFFIOP/uK7Zdk1IuLpoAnF1ustiVpz8FCU8h4yO6B3bMt3nP75nXX6PmrZnM5tm7ZarZWK20WmzGe62Bb5rsk5RqXhFgqRp0OJ5861ucNFotFPO8CMOrdz9HZGqL7GgNkC0WEZdOJJYW0Qz51ZfD36KOP4jgOL3rRi54X8Fev13nLW97C6OgoH//4x59TYdgLoce94ACglJJ6vc6LX/xi8vn13KieTcLF4A9gKOfx86/cyWeemOfIbAMh4OW7B3nzi8b6gDDle2wdH2Hr+AhRnFBZqfLXD51mrh4ykvOwLUE9VKy2AtqRYvtgmtcfGO1H+QCgNdV6jckzkwwODqCzg5w9NU0x7ZJyu470nYhqkJBPObz39olLjKfXAhbLFhyaboBl9T8s+ZRLM4hphJKX7hroi08uvkbfmHWpRTWQlNImi7OUdhguejQCiWMJ/sX370QnIbVadZ2RaE9E4roOJxebaC3wPQcUFFMWBd9mtR1TSjvrwN8ld9IF5KcWW3i2wLZsFJqMA5m8x2orImjVkVljPL3RCas3RVuodfAs0fUsBAdBzndocm0ejKCptkNs0TVXtYw/mNddjXTWONprDXNzs6ysrLBr9y4yawxAI6lAS1BGQKK7HERhKRw/zYED2/q8wXPnzqKUNjylojFUtm0bp/ttopXhGnmZQvcOzfN1rkALmJub48knn3zewB/Apz/9aX7mZ36Gj33sY7z2ta99Th87n89z4MCBdT/LZrMMDg72f/4TP/ET/OIv/iIDAwMUCgV+7ud+jrvuuos777wTgNe85jVcf/31/PAP/zD/+T//Z+bn5/m1X/s1fuZnfqZ/AHk+amVlhdHR0X6yx9qybZs4jvvgby0X8I03jpHxHL58vNKfBL563wVVvhCCgWKegWKe/Tu2UGu2ODu3zCPfnEEI2FRKM5hIqoERpwG89rphDqwxIO9NIM+fn6LRaLJv3x4+92SNTqIYzXkgYCDR1NsR7Uhy27YSr9p3qTBsLRXizHKHpXbCYNb02G2DWdpR0u0tLu+5bWJDfvRay5Ejs3Usy8bWkiSO2FzKIIHVdsKL9wzxsl1lavXaOlFXsViiWCqSzWSZq4cstyJyKRfLskgJgZ+zKGccmmHC9sEMnrMx784kCqmuQb8il/URlsATJs4x7SmiOGFpfpo9W3tuBhuV4UFqpXE9s4K3hCDlGd5fojTyGjQX1U6C1hJLmCkcQmDbFp4yPobtSPUBYBCEnDp1ilKp2PdXBZDSCOWEFqAN/7AnRomlYtPEVnaUXWq1OtXqKjMzM6TSKYqFIsVSkXQqbSaBloVWZnToZAz461GmrtTf4jjm0KFDzyv4azabvO1tb6NQKPDJT37yOV/DvhB63AsOADqOw2233XYJ7653Cms0Gpw9e5bR0dFLPLImyml++uU7+pEzWe/yT89zHTaPDtHxVxmeEAynFJ1WE8tuUfBtFhohhbSzHvzRVa6eP9+3LXlsuk6cSFJppzvZE5QzHr5jk2iTG3ulUkpT60R4vZALYePYmmLGI5LhNYGeSGpUIum0QhzHJp1KgbBIuZpEmtVlMZshm830CcHVWpWlpWXOn58mm83S6QiUliip+kafQthAck0cSgDfMcqxREqzPhHamHErhSMEu3fvvSR15OJKu4ZUblsXVMQa0MLqpm1cObUjTBRZz2GlFaM0pFwHIVTf4HXzQAbLMgq92dkZqtUau3fvIZW68GFpBAlSaaLEiD8818azzN8Krdk3lsdzXUqlEsViAa23GJ5Svcb8/ALnzk3hpLM8tWiMVWOl8dIZfGFoBVJp7txZppjeeNXwQgB/n/3sZ/mX//Jf8ud//ue88Y1vfF7u4Wr1B3/wB1iWxdvf/vZ1Jqm9sm2bz372s7z//e/nrrvuIpvN8qM/+qN84AMfeB7vGrZu3XpJ5Bt0HQUch7NnzzIxMcHg4HryvG0JfuC6YV65b5BWaBSkzmXMaYUQlPI5vKbGGdjMrnGBDFt02i18J2Ag7dIIEoby/jpnAkNrmUQqyd69e/E8l5nVOdKO1RWWCdKOIl3wWWxE+I51WVeAXtWDCC0ltuUYwGIJMp6L0mZgKJXCvQoA6EQSFUeEUpHOZXFtB0do7CAxogfHZnBgoC/qatQb1GpVzpw+g2UJYjdnJpy2URPTFW50j2NXfgLd8rvG70Gc4Ntm3Q0GMCVSsnXzlcCfqbRnEStNK5SkPLAwD58oyKVc0leJkwTwbIFUJpc95Ti4jkQgiKWinPMZyPmgNe1OmzOnTzMwMMD4+IV1LkArMjnBjVjhO0b161jGxDrtOewYzpLxHHw/xcjIBa55vVZj8eQiju1QkWmkVERKE4eSXCmLpzWRNFz1V+zd+LV4IYC/drvNO9/5TlzX5dOf/vS69I8XUj3bPe4FBwA3qt6EaXBwkF27dvUjXHK5HCMjI4yMjJDLXfAZuhLwu7iyno1CkMkVyOQKaK0I2m1W5SLpNSNvrWFhcYGFhQW2b9tOsWhOzY5lGsBqOyaXcnC7TSFSkPMdUlcBgEEssYXJ3pVKk0+DjeFhCCEYLaSh36gurURpFqtNWmFCWwiKjourFJbQtMKEiXKGgVwKtcY0OpXyGUuNMjY6ShTFnJhZYra20l2JSLK+QynloIXZzV4/XjDB8lqTJJcGyyttjEAX6iHNUBoXe8+m6Ns0OhGuJXjpDdvwPOPH1+P3rK12JPnot2dYasXGgFoqHGGmqGGiKKZcDoznEEJ31+frw+XBmEf/8TemmK0FyG6TbUcJaddBYQLfbxzPIaViZmaaVqvF/v37sG23//rWOjH//f6zVJohYHg1iUoIuxO74bzP9+0orcletnAdCzufI53OsGl8nGY74L/df5b5RtwNTxLoVKGrtDPX+KW7d2349+yBvxe96EWXAIDnqr74xS/y4z/+43z4wx/mrW996/NyDxvV/fffv+6fU6kUH/zgB/ngBz942d/Ztm0bn//855/lO3t6tZENTK/H3XDDDczNzfHUU0+RJAlDQ0OMjIwwNDTU/6J0LIti+tp8Iw1AE2C7FMpDFMpDxHHE0kqViNq6yVsYRv3ov527dprpjgbXFiw2Y2xLdPlcGq3NZDyXcvvitI1Ka5BSE8SKhXpIPuWSds1aO4glm8oZMp6DVPqy4rSFekC706EaKHIpG1sKbEsRx+awumXQJG7EcdKfSpVKRUqlojlg1xt87USFZihZ6UhSjiDvW+RSHo0goZh22DGUw+kmsWwUdzZfD/nGmVUj3AglnmNTSBlrqXYQc3BznomxYaPm1XR5hOuv8fh0nc8dWSRKNGGc0IgUWVdgWwbQ3bm9iCXW+sNeKra778Qyf3d0AamMvVQoJW6kcWwzTXzF7gHQimarxbnJSUZHRy/hDn/5+BKfP7KA6grTAmnSmRzLJCW95rphfPvCOt6kLfl43gXXhAdOLvCpo8sopc2yxssQKps4SPAdix+6bTMHJy51d4jjmEcffRTP87jpppueF/DX6XT4oR/6IZIk4Qtf+MI67PB813Pd416QAHCtE33P5qW38t2yZQtbtmwhjmMqlQqLi4tMTk6STqcZGRlhdHT0iuH1F9ft28p8/fRKf9UJgjYegyPj/NCrd7KtYDO/tMwjjx1meWWVPXv29FeFR2YbfOnJJZqRpNpJcFs2QxkTTh7Gkrt2FLEtzOpCCGK53pF+oR7yiUdnqTRjOrGiHZs1RTnjkUjFRDnFjkG/OxkwPLK14Ekq+NiDZzk820BYFpGESiOk1hakXWNyujZxw4gTLKS6INxYais+c7xJIzIO7pFU1DoJrSAm5Qi2lT32DV5ornAhFL4HwL5xepkvPrmIQJB2LQIJ7VAShJK8L3jDTeNsGcisU8caFa+F0kZY89nDCzw53yTtmkzOTmJMtuudhM3lFO+6dVM/H7RPMu/zlQSJUnz28AJz9YCsa+E7Fu1IkyhJJ5bcPFHgLQfHSTkWZ8+dJegEXWNW84XWA5VfPj7PUjPEdyxSriCUEMXG7f+GzXneefOmdbyWtYbalmVWMSeWY+abMY5jYSNQjo9wPaTWjKTgAy8rUBQBSqXXrfhmZ2d56qmnnlfw95WvfIUf/uEf5kMf+hDvete7npd7eKHUpz/9ad7ylrc8q4+hu+rc3mc0n89TKBTYu3cv9XqdxcVFTp06xZEjR/pgcHh4+JpVitsHM+wczHJ0vsE2x4gdsBzaVpY7btrEW1++jcpKjTNT5zl88gTlNVGM7Ujyt4cXmK0H1DoJ9cBYtozkPJqRpJhy2DOc6fOizWf5gkJUa7j3yQoPT1VNolAoqXYkec8IyyxLcMfWAkprozLtfhbWHjInK03+7IGzNGJjX1APFM2wTdazcW3BruEsu4fS3TQjLhGiWJbgK5MtHp2L8V0HGUmCRBAkhgeZ8y1esjWPSmKS7mNa3dV7zwS7FUr+9MFplpshed9Y1kSJZKkp8S3YNpjhTTdPsJaWA91YSGE2IPO1gE88OkuUKEpph0YQEytJMxRkfZu7dpT7VmWXpG1YJsLt7FKTvztqgFsx7Ri3hliRaGObdc9NY3zfzgGarRZnTp9hbGysD/56oHKlFfF3RxfRQNa3iaWJyFRg+IN3bObgxAWO9Nr76QkILcvivjPG69V3jU+rlSsaD36t+aF9Hv9in0cQBOsma2vB34te9KJnPVptowrDkPe+9700Gg3+/u//fkMLsn8q9elPf/qFCQB7tZHYo1eua/yNNm3aRJIkLC0tsbi4yMMPP4zneX0wWCgUrggGb9tW4nU3jPKlpypMLhteTMazueemUW7ZWiJJEs6dWWHP5iFe+/Lvo9rqsLi8yrlKg787tkiUKLaW0iw0AtqRZK4uGc4Z4cidOwa6/BF54QPkWAgsEpnwxScrVJoRYwWfVmSz2pYEccJqO+LOHWVec91w3xBUriGH9BrUwyenODLbIJ/2yPgejSih3o6JpKaYcXj7wfH1+bJaEyfrhSjfnJyn3okZzHloBJ1Y0epaTtyyJcdtw4KZqXPMCigUzKk6l8sbwYPWaMvmm5NVBF1fKmUMXxvtCITg7bdOcOsGIeBGxWueUztSHJ5r4jkWniPwHIeM0t3YKnjbwbG+andt9XwcJdAKE47Nt/AcG9sWWBrctEYqQZAobt5aopwx67UoCtm9e7dJ5uhW7wvjiekaQlhYtlFbpxxNynEIYkU57V12bdt9VkgpObnYQCD63l+pfAmnO8lsa4uCJzhy5AhKKQYHBxkZGSGOY06ePPm8gr+vfe1rvPvd7+a//bf/xnvf+95rPkT9YyutTXTXL/7iLz6rAHDt4RboCz56/79nhLx7926azSaLi4ucPXuWo0ePMjg42J/uXEm1aFuCH/++rfw/953h/KpxUEDAzqEM77trC5mUT8rW6HaNN9/9MlK5AotLqyzXGnzl+ALHF5oMZDx822K1I2mGJo1n13CG190wYg5D+oJgYi2QOz5X56FzVVxbsHUgzUorphHE1EPFuO/z2utHOLCp0H8t1oEn2yaOIv7m22dpJ7CplCFWUA+MOC1IFC/fM8zL9w6um2JeLERZqEc8MVMn5Vp9i5RGGNOONLmUy9uvy5GSLY4ePUo2mzG8weIFc30hLI7O11huxRRSDpYlyKY86q0OnVizuZzmp1+x6xIOoxCsUfFqHptuEEmj/rcE+Pk0UZLQCiXbBtK89eBGBv3r++SR2QaJMoARFPmUS9ZTtCJJKe3y/bsGqNcbTJ6dZPOmzQwNXegjPRB3bM5YY6U9A05dx8G1FYk0dJ2dQ5nLTmJ7z2m1HbPcDLFtgbBsLMchncuitZn0ZrM5FhcXOXHiBLlcjuHhYcrlMsePHyeVSj1v4C+KIn7kR36ExcVFvvSlL13ir/dPpdb2txcsAOw1xo3A38XlOA5jYyZrUkrJ8vIyi4uLfQPpHhgslUqXkq4twY+8eIK7dpQ5Nm++uG/YlGfXUIYgCDh06BDpdJo77rjDPA6wf8cWPvy1U0i/xkg2QSYx24fzxpG+FbFjKMPrD1xq1rvWLqTSjJipBhTShhhdSLnkPIdO4tCJFHdsvzxHTCrN+enzHDu/guV65DIphIZiyqPQTdzIevZ68HdJGSHK6aUmvmNhWTZaSZMgkvdZaUcUcxl27xxBKU2r1aJWqzI1dR6lFPlCnlKxiHIzNAPj+SS63EEtQ0oZm1bMNaVcNMKEJJG4To8YbSGEJm1pmoGiGV6dGR0rjVISS4DGTAEE5jo6lgRRwuQZY/K81pX/0j+SeW3Qa814LxhYX0ul3C5oVxLH9bF9cwpWWlNIu1x//fVoranX6/0A8jAMyefztFotMpnMc85JeeCBB3jXu97Ff/kv/4Uf+7Ef+ycL/sCAry1btvCOd7zjWbv+Wg9T4IpfiEII8vk8+XyeXbt20Wq1WFxc5Pz58xw7doxyudwHgxsRv3cMZfite/bzyFSVpWbEcN7ntq1FMp7N2bNnOXPmzDqboYnRIRbrbT70aINySeOriLRrU0grmkFCKBU/eMNI15lgfa0FcicWm8RSM5Dz0VIyVkwxmPNYboZsH8ysU+Ovf77QbLY4/NQpViNBMZvq5p9rhjIwkEmz2oqZKKWumAhkhBtNIqnI+R4IC9eFAVuQdiVSa3ZsHqOQdrrm+jVqtRqzs7PrBA8LNZMoZFlGKBFFIZ6lcVIOkdSXNfhf+/erdSLzXSYstDAm/a5j4yaKdnRtaRtB3LOaEv3X2myXFEGiqNXqnD3X5Y8ODFz2te31N9XNIEZYIBRaXdt9eLbxCdRSo5F4GQM0dfcBtm4a5rYbx4jjmKWlJRYWFjhz5gyWZVEqlVhdXaVcLj+nIDCOY378x3+cc+fO8ZWvfIWBy7w+/xRqbX97QQLAo0ePsnPnzr6E/+l8GfUA38jICEopVlZWWFxc5PHHH0cIwfDwMKOjo+vegEII9o7m1mUv1mo1HnvsMUZGRti3b98lb9YQm3RhkNHBDEkU0Wk1cJ0mQSyJk6uDhVjqLn9CARbaMqP+FIbwnFxGDqaU5tzUOTrtNsPDQ5xs1NBSoi2r26R65OZrK9+2qEpFnCQGFCnV/SBbXfsSc6rP53Pk8zk2b55YJ3hotEOSxCZQ5rSqpcR1XYRlYytJKXPBwPpy5drmC7ERSFKuRcq1sRBECbiOxeby1cFQM0ywhKARJniJJu0Z7lMYK1zLwu2sItKC3bt2YV8G/J2utAEjJImlwnNsPNuscASaG8YLXW8wiONLQ+rBZD8/OdcgVppYgZfK4mnjayYQ3HOj8WbqTXiazSZJknDgwAGiKLrk5Dw8PEw+n39WAdnDDz/M29/+dn77t3+bn/qpn/onDf7W1sGDB5+V605NTeF5Xjfi7On1NzBKwR07drBjxw46nQ6Li4t93mCxWGR0dJSRkZF1qsZ8yllHyu+ZUFcqFW677bZLVmGdBCw/y0ixSNoRBJ0WQauJZzdZbIRE15CYESbacGCVBGHYsK5j4VhGCHG5ajabnDkzSXlgEHeu2becEpYxW+8JJy47qlpTfpeTF8YS39HdREeBQuBagh5+NOb6QwwPD5Ekklq9ZgQPJxaortpEMbQCjS00QmvSvk8t0gzkUv2IyMuV0mALSKSiGSakPAdHYDwGNUyUM9iWdYk/7NqKuj0pSjRSJvi+i29ptJZIpdheTjM1dY7t27ZRLG4MrMNYMV8LiaU2CUuOjW9rLGEyjHcMZSln/cvyD8Fwzu8/uYTU5v/HWFh2GkspwkST9Z3+Ktt1XYaGhjh37hxDQ0NMTEywtLTE0aNH+5z+4eFhhoaGnlXvvSRJ+Kmf+imeeuop7rvvvudNWPdCq4MHD77wAODc3BwveclLGB8f501vehNvfetbufnmm7+j04JlWQwNDTE0NMT+/fupVqssLi5y5MgRtNYMDw8zMjLC4ODguuv3/ptdu3axdevWDT+UWwcyCMyHwPE88t4gudIANafOzdszlPKZyxpPaw3LzZB2JFluReTTDsWUi+8YAJPzXSYGMpc40vcUekopCmPbmDm2RD1MaIYJ+YxrhBtSEkuTuOHYDhq9oau97H6QFxsRjUDSjBRZz6KcdmlFRuV2w3i+/wWllVHS9oxZs9kM6eIQX35wiiDpEElNO5a4FuSEJFKKTcWUWSl0wS0a4mQ9cDpdafPnD00TJIpYaqJE0QoVadekdhzYlGck5/bNUAXiEqL24Zk6f/HwDEEkUbpLam4bwYVlCfYUYTAj2L5jB5aw1jjsXzB4PTbX5E8emOrz+aQWdGJJGBsQesuWIntHs31PL8u+sOLtvb6LjZAPfnWSIFbYQiARaD9rSOO24I7tZd5315b+fU9PT3PixAluvvlmymVjCL1t27b+yblSqXDu3Dlc90LyyzN9cj506BBvectb+PVf/3V+9md/9p/B35p6z3ve86xc9w/+4A/40Ic+xN13382b3vQm3vCGN2y4nbiWSqfTbNu2jW3bthGGIYuLi/1DRD6f74PBtY4JSZLwxBNPEIYhd9xxx4bT5pG8TznjstqOyBRSpLN50tk8uhUxkm9x444xdNTe0HgaTNpFPYipBQlhIilmUuQ8gdQKqTW7ho2SN1FqHdBYrVaZOneOsU2bOVW3aEY1o5h1LYppl6xnUesk5HyHXSO5buKSXscv7tVsNeSbkyu0I2nMil2HcsrCtS2CKOG2bSXSnovdnWhF3UPdWkXxP5xc5vjZBUIlCTsJQljkPIiiBIHg9q0FtFJ970Qp1brelCjNx749w+MzdWKlCYOk29/MtiPlWNy1o9iNWusa/ev1PTtMFP/7m1OcqrRQWpMoTdSJ6FgCx4K0Y7HdbbB1qxEn9lKS1pr0J0rzx988x8nFFrYQJFp3/Ug1niXI+A5vedHo+nx6y8Kyra5Jv3l9P3lojq+fXgEMBrfSBSJp7innO/zWPfsppAyYi6KIRx99lHQ6zY033ohlmfi5/fv397cfPUpDuVzu97hncvshpeRnfuZnePTRR/nqV796SWzaP+V6z3veg9DX6vHxHFaz2eQLX/gCf/3Xf83nP/95BgYGuOeee3jrW9/K7bff/l0rh7TW1GrGL2pxcZE4jvtvvk6nw+TkJDfccMMV3yzVTsyvf+Ypziy1KWdcLAEr7ZihnMdvvGEf2wczfePpxeUqKzVjPA1w3/Elvn7aNKZWJFEIHKHJ+w6+a3P3/iHu3NFLiDDCgjiKOHHyJK7rkh3axJ89NEu1HZMowwFBaxzLIpdy2D6Q5t23T3S5IubD7DrOOlf7+04sc++TFWwLgkgRSIVSGtcSlLMur7thhDu2r0+psESvIUiU0vzh189xZqmFa0E7TIi08ctzBIykNa/e6rJttLzONwrRC6dXBHHCf7n3NKtts7LuxJJ23L0PW/DS3YO84cDIJcao0CM1W4Rxwn/4wglqQUzGtUmkphNLA8wtwV1jgts2p9m5Y8clkUwXriP4j393gtnVDn53fRsr84UghOBNN43yqn1DV4zzs22bTzwyy/0nKri28R60MkVIF5EKXr1vkN97xw19246NwN9G1ZtiVyoVKpVKXxn6TJycDx8+zOtf/3p+6Zd+iV/5lV/5Z/C3pi7O430mS2vNsWPH+D//5//wyU9+kieffJJXvOIVvOUtb+GNb3wjg4OD3/XfIooiKpUKCwsLrKyskM1mGR0dpVgscuLEib4K80rvn888Mc+fPDCFJQR534gOgljy+htG+Vcv235Z4+nlVsxfPjxNpRHSjIzZsxCQcW18x2K8mOL/umOCfMrp86JBMD+/wOzc/7+98w6Polr/+GdmW3ovkEDovXciWFB6SyhyVa78sKEIFuzl2q+K5Vqwtyt6FVEIgiKKSFVApAuE3kJJg/Sybeb8/pjskNB7Ajmf58mj7M7OnN3sfPOec973+x6kbp26LN3nZPnuHIQORW4vXh0URNlWtI3+LWIqbCEb3T9Us1tTkUvjg9/3klvsxqoq5Dk9lC1EEuiwUD8qkBs7xRNS3qhYqTip25pVxP/+3G9YSGleSjTFTGkJskHLcEH3esGEhYWZ3p++QgmlzNR66Y4cvl+fbtjGKFDk1nGX5RvHh/kxpE1NmtU8tgrV0GzjfIu2ZRvnsKpYFIVSr8Dl9iKA2qE2ukS66dC0HiEhx/YU93lJrtuXz2dL92Ara0uqla2KarqgZogfd15Zh+jgk5ggKwrFbp2nZm0us+0xLIGsEfF4dKOS+ZvbOtCsRrD5/Vu9ejUBAQFm8HciSktLTX3Lzc0lMDDQLHY6l90PXde59957WbJkCQsXLqR27dqnflE1wadvVW4FECAoKIjrr7+e66+/npKSEn799VdSUlIYNmwYAQEBDB48mOTkZBITE8+qZ5+iKISFhREWFkbjxo0pLCwkMzOTzZs34/V6CQ8PR9d1vF7vCc8f5m/jsT4NmbLyAOv2F+DVBR0TQhnRId7MjTme8fTGvRmsKGslFB/mR4lbI6/EQ7Fbw2pRGNq2hnkTGQiKiorZtWsXwcHB1K1bh582ZpJX4iYyyLhhSz2CIqdhn9IyPpjk1jUqBE2KQgVXew2FFXvyUC2GsAc5jOX7EpeGjmBYu5pmcnZ5dKGjl62QHch3sS/PhU0FRfMSEeiHjtEMXFUUxlxTF4vXSX5+HlnbDGNWXxFJYGAQigLbsw0D6wCHFRUI9LPhb9dxegxfq+uaRh03+ANfUrPOrkPFFDi9ht+fqmBTwWZV8Go6LrdG3YgTB3++8+SWesgscGK1WszqP7tFYFMtuLw6frZT93LWNI3dh4rKtrtVUFTsgSGoFiOwzS31nnHwB8euYhcWFlYoBjjbmXNqaioDBw7knnvukcFfGeVTFS5kfpKiKLRo0YIWLVrw9NNPs337dqZPn85///tf7rvvPrp3705ycjKDBg0iNjb2rH43drud+Ph44uPjzRXlAwcOsHPnTqxWK1FRUZSWlmK1Wk94/oGtYrGoCnM2ZpJT7CHYYWVImxoMbVfTfB9HG09nHsrj14WbyS50ERXkIEIICt06ecUu3F5Bh4QQ+jSPNivpFcWo+k1PP8jhwzk0adwINw7W7MvCYbEQGGAhVLNR5PJS6PLisKmM7Bx/TFFY+Wp8RVXZkJ5PXomXEH+r0QvX30aJ00ORWyMhwp9buyWYll3lTlKhEGVNWgFeIXDgRbVZCAmy43R7KXJrdKoXTv+mYeTlH/H+DA4OLivcCTED6zX78w0tsFsQuk64vw2vrlLs1mhRM/i4wZ/5uZSNZcOBAkDBZrWiC50Au0KAzfBxtAsPnVoc21P9yFsy3tO2zEIUKPNnBVUIAuwW3F6jg8hJg7+yz2bvoWLD09VirF5a/YOw22xYy1YT80o8wJHgLzAwkJYtW57yXvL39ychIYGEhIRjdj+sVqupbxEREad9X+q6zkMPPcSCBQtYtGiRDP44vr5VyQCwPAEBASQnJ5OcnIzT6WT+/PnMmDGDkSNHYrFYGDRoEMnJyVx55ZVntRqiKAoBAQEUFRVht9tp1aoV+fn5FartfLORo9vExIf583CvhhQ4PXg1QXiA7YRi6jOe3nhYxxaZQIyfhqu0GNVSSoDd6OcohGHbUP4UvnyYqOgoataoia7r7M4uwmpRURULOj5BcHCoyEjWPlHQ5Hu/uUVuStweHKox81ZVK342gcOqklfiwXNsK89jKCh143K7cagCP38/FIsFCxCAsWVR6oWEiHAiIsKPGLMW5LN79x6UsorivFIruqaj2BQECgjDOsFmMXwQnR4dThHTaL4FbKGDUMrygowAUCgQW7PmCYM/H75Ka13X0BWj44fhbVCWrH2aohNU1vNS1wU2f39US1lze0UhqixY37dvHzt27KB9+/ZnXIWmKAohIUankYYNG1aYOW/bto3AwEAzreFkM+dt27YxaNAg7rjjDp555plqHfz99ttvBAUF0bVrV7M442J+Hoqi0LhxY5544gkef/xxdu/eTUpKCt9++y0PPvggiYmJJCUlMXjwYOLj489qbDabDavVSkFBAfXr1ycwMJCsrCxWrVplOibExMQQGhpa4fyqojCgZSy9m0WXbbueWFt8xtNhwUEcWpJNdLwfwaoHZ3EhVtVDmMPCoWI3McGOCsVtui5IS0ujpKSYRo0MQ/ad6YU4PV4iAu0oqopNgVAV/O2WMqP3U+wACUF2gRMhdCyK1SgsExDksCEw9OmY4O+Y9wPZBaXoXi8Wu4rNbje2bG1GNb/ToxMQEEBAgOH96XS6yM/PJycnh/3795sVxcVODyo6CGPFDAVjB8St4TyNPEowiscQRi6l7/ejlZn4BQUFnTD4K4+9zABb9y2DClGmb0rZCuyp8dlw6ZpAsehYA4wVWF0XqIpCZKD9jIO/o7HZbNSsWZOaNWtW2P1ITU097d0PXdd54okn+Omnn1i4cCF169Y9ozFcTpxK36p8AFgePz8/BgwYwIABA/jwww9ZtGgRKSkp3H777Xg8HgYNGkRSUhLXXHPNabd6cjqdrFu3DpvNRufOnc3E1fLVdvv372fz5s2Eh4ebYln+/L6ch9PBoiplbcEC8A8y8kdczhI8h3PxukoquPLn5eWzN23vMSX9DpuKW9NxaxoOq8XIf1GM856sKs5HgM3wvCtyGYLia4Hk1Y0Z4tHdT45G1wU5h7IMg1dUVE3HAaAYnUAcNisxIUcS0I82Zi0uLiYvL4/M7MO4vTo5RRp+NgsBdqMYxunRCA90EBvqb1SbHScZGQwRzC5w4dV0nB6B3aLiZzVsdzyaQkSgnbpRgVgt6nEb1BvngBW7c9F1gUsTuLwadqvAblHKEsdVWsYHnzSfEmDpzhx2ZBejCdC8OrotCIumo5XFp0Pa1DCDv3bt2p0XC4ITzZxXr16NxWI57sx5586dDBw4kJtuuol///vf1Tb4E0Kwe/duxo8fT+vWrXnooYfo3LlzpQSBPhRFoX79+jz88MM89NBD7N+/nxkzZjBjxgwee+wxOnbsSFJSEklJSdSpU+e0x5iWlsaOHTsqpLUc7Ziwdu3aCgV04eHh5vltFtWcwJwOVouCanUQFBJCUFgkXo8bZ3Ehue6cCl1DNE1j9+49eDVvhRaRDosRoJS4NfxtZdW3qoqu6VhUFftppADZLIYWlbi9+DtsKGXpN14dIoP8Ttn/o6CgCI+zBI+u4BJG4YmlrEBOKAo1wwPM7woY5vp+fjHExsaYFcXph/NwO0sodql4vDr+DhsOC2hCR1WgXnTgMXneR5NZ4MKt6bi8Ol5d4LBZsKLh1YyCv1a1w7BZLei6OGERSXq+i12HSnDrArdLw+rTSc1w2ehYO8TwLFSVCrZE5ckr9fDjhgw0XeAFVKs/ViymxrWoGUydMBurVq0iKCjorIK/ozne7kf5vMGwsDBzcca3+6HrOs8++yzTp09n4cKFNGzY8JzGcKlyuvp28c14zhM2m41evXrx4Ycfsn//flJSUggKCuKee+6hXr163HHHHcyePZvS0tITnqOwsJC//vqL4OBg2rVrd8yMwldt16VLF7p160ZUVBQZGRn8/vvvrFy5kr179570/MejXe1QwgKsZBe5zP6yVkcAekAkvRPbckWbZtSKjSY/L4+9aXupk1DHDP50AYu2HWbv4VIKnV725ZSQnl+KR9cpKHXjsECzWKOy0Gq1oCrH/nqzi9x8vjyNIrfh6ZVZ6Ca70IXTo1Ho9FAz1E5ChL9hGm21GrYF5dJENV3n19Xb+Wl7CVqZb2BOscahIjeFLi8eTadTQih+VqUsH8ZalrPpW3pWCAoK4u88G39mG1ulXgFFHsGhIje5RS4UBD0ahqEII/nY6LZhKetM4DMIh+lr0/n+7wxzbC4d8l0aTs0Ikge3qYlSllAthJGnZ5hYHxHJ2RszmPV3Brrw9VtRDb8+t4ZVVRnWriZBDitezWtuD1ktFqMgpewmWruvgO9WH8Tl0bEooNj8wGKnxKOjAHdeWYfatqLzGvwdjW/m3Lp1a66++mpatGiBoiikpqaycOFCbr75Zl588UX69etHcnIyr7322gXZ5vzggw9o3bq1uVKZmJjIzz//bD7vdDoZN24ckZGRBAUFMWzYMDIzMyucIy0tjQEDBhAQEEBMTAwPP/zwcVunnQu+YOu5555j//79vPnmmyxbtsx8rrJTo31WDffddx+LFi1i3759jBo1it9++402bdpw1VVX8frrr7N9+/YTjlUIwdatW9m1axft27c/JqfZF/C1bNmSq6++mubNm6PrOn///TdLliwhNTWVw4cPHzcgOBndG0Tg9GpmpbDFasNlCyYmvg7/uLYzTerVJtDfwfbt21EUaNSwoam9GQUuFm47TJFbIyPfyYF8F4VOQ1eKnR4aRgcQFmArMyS2HFN8KwQs3HqYP3fn4vQadlsH80opdnkpdHmwqtChdohRwKCqWI8TTGYczuPDJbvIcCp4dEFeqZfMvFIKnF7ySz2EOqy0iw820z1sVitqOW2y220Iv2B+3C3I9VjLum0Icoud5BS5KCz1UiPITqsaQcdoSnkO5rl4d/Fu9uU6zYLDIqeHApfAKxTqRQbQvnYoHq9RCWzovhWLajE6tWDkY763eDe7D5VgVZWySaxhbu3x6iRE+HNd02g0XcPr9Zb1oDY+F5/eajp8sHgPWzOLjQUMQA0IMTo2eXVqh/vxbL8GrF692uxve761xbf70aBBAxITE+nWrRsxMTFkZ2ezdOlS3nzzTe6//37Gjh3Ll19+ybx582jSpMl5HYOPS0HjfPr27LPPnlTfqmQRyLmgaRp//vkn06dP5/vvvycnJ4c+ffqQnJxM7969CSxbLt+5cydpaWnUqVOHevXqndGMv3y1XW5uLsHBwabX4NH9iY/H3NQsPvljL4Uu4xeuoFA30p+nBzShZoiDHTt2sH//fuo1bIzTq5N1OBeny82ynbn8nJqJRTHMjYs9Al3TsKkKkUF2ejaNJrH+0YUbZa72usCj6XywZDf7c0sJdNgocnnMoguHTaVxTCDXt48nMvDoFUCjEEXTvKzZtJ1p29zoqAQ5rBS6vEafTmFsEVzbJJrrmkYd0wjc1+dUAXYfKuLdRbsBo/dvqVunpKzbRohD5epaFmrYXAQGBph5g74VV19S877cUt74bTuKouCwqHg0vSyHEcL9bdzWPeG45tHlP5cit87Ts7egaRp2i1F1rOlGL0urCvdeU5/60Sc+hxFUqrw2byd7Dxdj5LIr2EJjEVY/NB3GXlWHgfUs7Ny5k/bt25/QouFCIYTg8OHDPPnkk0ydOhVN07jmmmtISkripptuOqZN1Lny448/YrFYaNSoEUIIvvjiC1577TXWrl1LixYtGDt2LD/99BOTJ08mNDSU8ePHo6oqS5cuBYz7t23bttSoUYPXXnuN9PR0Ro0axR133MFLL710XsY4d+5cli5davbLnDlzJhMnTiQhIYF77rmHK6+8EqDSVgJPhhCCQ4cOMXPmTFJSUli4cCFNmjQhKSmJ5ORkmjZtiqIoFBQUsHXrVtxuN+3atTstXSp/jdzcXFPjNE0z7bMiIiJOWYSXV+rh33O2sSm90Ni+xLjPr28fx02d4ikpKWHNmjUEBgUTVSOO7Jw8DucVUuL28tHve8kucuOwKuSWGKk1iqIQaFepFxXIDR3jKmwhCwE2m6Ws/ZrOhgP5fLv6oNFSTVHIdXqNziJQppFRdG8QWWHFzXQYUBSys7NJWbWPrQUWAh1WdCEocOl4vMbqWpOYQJLa1DAmyUehKIZOCh0+XbqbjQcLjVajAko8Oi6P0TmpTayNNmEe/K0KIaEhhIWGERQcZLbes1gM+7NP/9jD+v35BNiMVJ1Sj4arrKDm6oaRDG5dwyxaO/Z3aLynmesz+C01E4fNqHTWhIrH60UT0Do+mFsSa5spMMdHYXNmER8s3oOqlHVssdqxhsfh8eoE+1mZc1d7UjesJzg4mBYtWlx0k2ePx8PPP//Mv/71L3bu3ElMTAxDhw7l+uuv59prrz3v16vqGndG+na5BYDl0XWdVatWmcHgwYMH6dWrFzabjfnz57N48WIaNDh+T9bTxVdtl5WVxeHDh80KptjYWAIDA0/4B2R7VjF/7DxMQamXelEBXNUokhCHhdTUVHJzc2nfvr0ZrAIczi9izOfLyTicS7DNaB/l1owOGB5N5x8d4k9orOpj96FSPlu+D3+rsRWtKkbgVOTyYrUoPNq7oZnHdjQej4edO3eyOVdheaYg2GFBEQLFYmzNFLkMa4Yn+zXmFOk1/LIpi9+2HjZySgQoqmEzU+LRCLBZeHZgEzweD/n5BeTn51FYWISfn8Nw6S+rKF607TA/bMggwGH0KPZ4jCILL8ZK3vMDm5w0FxJgc3oRH/2xp2x10Ri0rusIYfR3HndVXRrFnrpP5EMpqXg03RBuiw1HZBxK2XZ4n4ZB9IkuqJTgz0d6ejp9+/blyiuv5F//+hdz5sxh1qxZvP322zRv3vyCXz8iIoLXXnuN4cOHEx0dzZQpU0yT5S1bttCsWTOWL19O165d+fnnnxk4cCAHDx40V6w+/PBDHn30UbKzs4/Jwz1TXC4X999/P8uWLWP48OE89dRTAMyePZsXX3yR+Ph4xo8fzzXXXHNO17kY+AK1H374gZSUFObNm0e9evXo0aMHc+bMoW/fvrzyyivnVCnuc0zwBYNut5uoqChiY2Mr9Cc+mmK3l6U7c9iSUYS/zUKXeuG0igs2/VVr1apFgwYNTH30eL18u3wH789LJdDixaIIdKFQ6vaa7SDHXVPvlLl7k/88wNasIsL8jBaPKAqlLi9FLo0eTSIZ0PLEzg7Z2YfYf/Ags/Y5cOsQYFfL/P2MnOJit8aQtka7tZPh9Gg8P2cbOgp+VouZwiIQlLh0hratSdd6YWXm+ob5tFfzEhISQmhIKCEhRvHYk7M249WN3QyP24Moa1np9Ap6Nok+brOBo3lz/i72HC7Bz15O14WRw9gwOpB7etQ75TkWbD3EzPUZWMvcDWwhkVj9g/HqRveQFxOtJESHmrsOFxshBJMmTeK1115jzpw5FBYWMmvWLFRVZdKkSRdlDFVF485U3y6pHMAzRVVVOnfuTOfOnZk4cSJr165l3LhxrFy5EovFwuOPP05SUhIDBgw4JgH6dDletZ2vStPPz8/04To6Kb9RTCCNYo4EeF6vl3Xr1uF2u+ncufMxOYyK1Y7bHkJMrVD8FA1XaRHWkmIcVhc5xYYdzKkocHrwejWsdiuKqiIUsKESYFdxa4Jil3bcANDlcrFz504CAwMJFgEoGdmoWBCIslxiC1bVMCoVQpzSoFUXGEnNwnC1F7ooM3nV0crE0sjFjCQqKhKvV6OgoID8gnyytmdhtVgpLHEYfZG9Xry6hlW1YLFa8Xg1LGWz/1MR4PC12dNQhFI2BtDL/j/gBMHw0QT5WThUpKHoOrayPtQ+bzLVWbnBX2ZmJgMHDqRLly588sknWCwWxo8fz/jx4y/4tTVNY9q0aRQXF5OYmMjq1avxeDz07NnTPKZp06YkJCSY4rh8+XJatWpVYbuyT58+jB07lk2bNtGuXbtzGpPD4eC5557jtdde46effsLtdvP8888zcOBArFYrzz//PJMmTULTNK677rpzutaFRlEUIiIiGD16NKNHjyY/P58PPviA559/Hrfbzbx58wgMDCQ5OfmsvVTLOyY0atTIrELfuXMnGzduNFvSHZ2UH2i30rtZDL2bHQlSfP6qjRo1OqYq02a14lT98Y+sQWywHbezBFdpMZaSotMu3ADILXZhWLUbgZuCUTxSWtY393gIARkZGWRnZ1O3Xn20tP2ogCIAxdAEGyoKXlyeU6+X6EbNhpF3KMrys8sSTASGD2JFc/14SktLyMvPJysrk7S0NIKCgoyqZF3H49ZAAbvVhlAUwNC40yHQUfZpCN0obtN1o/OHCkF+p6dvIX7WMk9BY1XR4mdMinVdYFMENSJCKjX4+/DDD3n11Vf55Zdf6NKlCwC9evW6KNevahrncDh49tlnef3114/RN4vFwgsvvMCkSZPQdZ1rr7328g4Ay6OqKh9//DGHDx9m8+bNeDwepk+fzrvvvsu4cePo0aMHycnJDBgw4Kx9uMpXMGmaZrbBWbVqFTabzQwGjw42XS4Xa9euxWaz0bFjx+NazwQ5rAT7Wckt8RAU5MBqdxAYGkmJ00VpTh61osJOOT7D/0lwuMRDoN2Ko6z1mstr9MWMCvYr2/Y68pqS0lJ27dxJWFg4sTVrsmlzNk6PjkdzEeCw4yhrvOnWNJrGhBoN10/gIg9Q7NLILzUsa9yajp/dip8FhG50P2lfK9xcVfCUM2aNKFdRfDA7j30bsvDoOm5XWYNyRQFNQ9N0WtcKwc9u5C/quo5+nLEUOL3M33IIj1Zm26qCn6oZJqmaTq1wf+JCHKZptH6UwSsYq4RTVx3kcJEHXYBbV1CsASiakbBtV+G2nq0qLfg7dOgQgwYNolWrVkyePPmc/TNPlw0bNpCYmIjT6SQoKIjvv/+e5s2bs27dOux2+zE5kLGxsWRkGLmcGRkZx+Sq+f7tO+ZcEEIQExPDY489BsC8efPQNI3nn3+evn37YrVaefbZZ3nnnXcQQlQQ8qrOwYMHmThxIo8++igPPPAAP//8MzNmzGDAgAFERESY9lln66V6dBX60f2JIyIizJZ0R69i+KyPWrZsSUzM8VeuooMcIEBHwREQhCMgCBERQ2lWLrVDjCDxRMbTYNyPDpti+KJS1neXsipVVaVmWIChCeX0QAg4cGA/eXl5NGrUiCKvYRR9qMiN26sR6LBhVRVcmoaqWozCDdVyjKF9edJySzHav3mwWRQC7BbsFqO4zaoqNKsZjNViMXVSUTimonjptgy8WglOr8AlMNp1Kjoe3egq0qpWKFar9RjT6PL8tSeP3YdKjNxBl4ZF0fGzKmhCQxXQMSH0uKbR5dmWWcTMdUaOtC4Eui0IVRMoZa3krmsUQLvWLSst+Pvss894/vnn+emnn8zg72JQVTVOCEFsbOxx9a1fv37YbDaeffZZc5JbbQJAgLvuuosXX3zRbAVztA/XZ599xr333suVV15pWi/ExMSc1ZfbYrEQGxtLbGwsmqaZLemOrraz2+2sW7eOsLAwmjdvfsJZut2qMqBlLJ8vTyOvxEOwn2FHkOsUNKsbx8ierdC83uMaTwMs25XLL6mZeLw6Hl1Q4tFxWAwnegF0rRuGRRFmsYQC5BcUsHPnLmJioomMjmHKygOkpheWzcgFTq8Lu6pgsyj42y1c0zACr+YruFBRVQVNOxIMlrg1PvpjDwfyXCiKIdhep4cSxXh/4f42rm0SZSZGq2qZMatypNuGyyv439rDZBV4sQAeYbRYKtTAqggi/Cx0r+2H2+0xk6rNPMiyVTlNh49/38u+3FKzWlDo4NQFFsXIFfpnl1qGmat+pHrY15pQ14ygctbfGazcm4eigCpA8Q9GoOL0CkJt8O9BjWgQVzlth3Jychg8eDCNGjXiq6++Oiu/zLOlSZMmrFu3jvz8fKZPn87//d//sXjx4ot2/VMhhCAyMpInnniCiRMnsmDBArxeL//+97/p2bOnuRL44osvXlIBYOPGjZkxY4aZ9zRixAhGjBhxjJdqYGAggwcPJikp6ay9VKHMgiQoiPr161NSUnJcx4To6Gj279/Pvn37Tml9dFWjCKauPkBGgYvIQCPwyiv14ggI5OZrG3JN4yhy8gtNjfMZTwMUlHr5csU+0nJL8Xh1crw6+U4vIQ4LXl0QGeSgZc1A9LIe30a7M509e/aUWdA0Ji3fw1d/GbnZmi4odiuUuF342ywoKjSvEUxCuB+arh1XmwBW7Mllxtp03GXl/25NwVPqxWZRsFlUrmoYTlSgrYJOKoqCXm7SvOpAMT9tL8KrGWuYQlVxajouzYtDVbiiTgBhNg2Px2te16fZHs3IM1y/v4ApKw+gC8MQ3ysMy6wSj+FwcE2TKFrGhSCEjs8gQVFUYzxlKTC5JW4++iMNt1c3zqGD6heERzN08opaDp4Z2qHSgr///e9/PPnkk/z444907979ol6/Kmvc6erbSy+9VL0CwOMtrZ7Ih2vq1Kk89NBDJCYmmmIZFxd31sGgz5KjWbNm5ObmkpmZyfr16/F6vQQFBZ1Wi5oRHeLIL/Uwd3M2WYUubBaV1vEhPNSzATaLis1yrPF05uE8NqVl8UtqJroGMSEOCpwaRW4PTo/h/deneQxXNows+zyMZe38/AL27NlD7dq1iImJZsWuHFLTC3FYVQIdVordOiUuDx5dEBfux/C2cWbBhKKUGTWXTbR9gvvX3hwO5Lnwt6kEOlRcXnC6DbFtEBXADR1rHVWAIswATFEMwV29L5esAhdWRcfmsKKXdQPx6lA3wo8hTQJxFR5mY/ZBgoODzCIS3/aUoqjsyC5kf54Ti2pY1FitCppmtKILdFh4tHeD49rplLdI8OiwfHd+WcskBYtVxR4ciiaMLaB/9W3AdS1rnfF35XyQn59PcnIy8fHxTJ069Zzz5s4Uu91u2i906NCBlStX8vbbb/OPf/wDt9tNXl5ehUAgMzOTGjWMHsk1atTgr7/+qnA+XwWd75izQdM0c9XL+IOrEx4ezuOPP47FYmHBggU8/vjj/Pvf/zbzY1544YWzvl5lYLFYjpv0fjwv1ZSUFG666SZsNhsDBw5kyJAhdO/e/azzBQMCAqhbty5169bF6XSSlZVFRkYGW7ZsQVEUEhISTmnNFR5g56l+jXlzwU725TjRhCDEz8qIDnFc2zgKRVGIDAshMiykgvF01uFcvlt9kH25pYQ4bATYLBS4NFwejUKnRqv4YAa1rmGaT+u6jkfX2VNmQdO8WVNQLMxcl0aJWyPc34bbrhtdOzxGMNS3aQw9mkSVy28WFSaHVovhUThnYxaaDsEOC5pVpdQrcHuN79z1HWrSMeFIkZ5PJ4/8W0VHMDc1G10zVutU1XBJcHsNf9MhrcKp5e9h+44dWC3WMuPpUAIDAw2/UyGwWKzM33oYgdELGQXsKEa1sIA+zWPo2+J4q7BHjLAVRWFlWj4eDVSlzC83KBiL3YrHK0gIsfLh6MRKC/58f59nzpxZKfm6VU3jTkffnnjiCV544YUK+latAsBTcbQP1759+0wfrscff5wOHTqY1XYn6hF8KlRVJTIyEl3XSU9PN3NhNm/ebFbb+foTH71NY7Oo3H11PYa3j2PP4RJC/W00igk8br6bz3g6PjaKdblWlMACIiwePM4SwgMthPhZKCj1EBloN5t3+8jJyWXfvjQSEhIIDw/H69XYlF6AjoLdZkXogmA/K0F2lQKnl4gA20mrZX39JTenFyAQZe9L4LAKHFbD5d9mUY9TfVweQ3A37z+MLnRsdjuKqmARggC7FadHw6VBvYQ4IA6Xy0VeXj55ebkcOHCAgIAAUyz35ZYAAouqGnl/QqCoCkqZBYyv3dPJyCt2l1UGAooxM1ZUC6omQFUo1C7OduvRFBYWMmTIECIiIkhJSTltP8wLia7ruFwuOnToYBZgDRs2DICtW7eSlpZGYmIiAImJibz44otkZWWZW4Xz5s0jJCTkjApWylfw+sQxIyODd999l927d9O1a1d69OhBy5Yteeyxx7BYLMybN49//etfPPvss1xzzTV07NjxPH8SlU95L1WPx8OiRYuYPn06t956K5qmMXDgQJKTk7nmmmvOeuLg5+dHXFwchw4dMrY14+LIyclh6dKlpmNCTExMhSI3H81rBvPBja3ZklGE06PTKCawQtWvj/LG07XiavDv33MIDrfg0F1YPW6jcEKzUuzy0qluODVCjtwHRk/1XQA0qN8AFJW0nBIOl3gIcNhQVAW7ohBhseB1qDg9Oo1jgnCcwDBZUYyuHbuyi8v6FluM/ueKIMgq0DTDtzUywHHSAjkhdNIOFVFY6saigtVmA6FgExq2sjzGwMAg6iUYvYOLCovIy89jz549ABUqig/klaIIAarFd3Ls1jK3BPdpOP0jyCpwArpxHykqloAQEAJVgXyPUmkV8ikpKdx333189913VWaF/mJr3PnSNxkAngDfrPX+++/nvvvuIz09ne+//54ZM2bw9NNP07p1a5KTk0lKSqpQzXY67N+/n61bt9KyZUtz5a9JkyYUFBSQmZnJtm3bzGq7mJgYoqKiKmzTxAQ7iAk+/T/sLg1s/kEEh/ghdB2PswR3aTFOb4Hp1eUjO/sQB9MPUq9ePUJCjrSD08s6hAtdGA03BCiqBTAsYE4Ha9kMVeia2W1DUVUUlFO2WgPIzMzC6ywt8ybUUTAap6uqilCMXBsfDoeD2FjDmLV8RXF6ejqFxVY0TQA6tnKWsLpQcNjUU1YPg1H4YVEwt3psjoCyYhYFBMe1ibjQFBcXM3z4cAICAvj+++/x8/M79YvOM48//jj9+vUjISGBwsJCpkyZwqJFi5g7dy6hoaHcdtttPPDAA0RERBASEsI999xDYmIiXbt2BaB37940b96cm2++mVdffZWMjAz+9a9/MW7cuDMKZl0uF35+fqY4ZmZm0qlTJzp06IDdbufXX3/l22+/5T//+Q9dunThsccew2azMW3aNFwuF2+//fYZWadcivi8VHv16sV7773HH3/8wbRp0xg3bhzFxcUMGDCApKQkevbseUbfJbfbbaa6+Mz169WrV8ExwVdUdjzHBKuqHrcV5YlwenWw2gkKjSTQYcXrduNxFuMqKaLYVYSrnAm8z83AZrNTt15ds/evoKxyQ+gI3diWNRoLWaCscONUWFUFBWFsM5fVoRjBU1nhxilqcNxuDxkH0lAwVgNFmSefohi9exXVgl9ZEGpRVUJDQwgNDUEIKC4uIi8vn/379+PVvDhUlUKvwKIbuYs+I2yhqIQF2k/L4ijE34peZpBq9bODanioKirUi6qce+OHH35g7NixfPPNN/Tv379SxlAVNO586ZsMAE8DRVGIi4tj3Lhx3H333Rw6dMgMBl944QWaNm1qBoM+H67jIYRg165dpKWl0b59+wp9YBVFMVeoGjVqRFFREZmZmezateuYlnRnuk3TvGYwqqLg8hqdQ+wBQVj9AymwhpBYN4hasRFkHs4lbd9+srOzadCgYm/J7CI3xW4vpR4dj9dFgMOKv01F0wQKgmY1QyokNR+PXdklHCpy4/IK3F4PfnYb/jbD/kEBWsWFnLDbhq9Kb+2ebLI8Nty6p8zRXuBvVYzjhaBjnbCypGbVaOtWJtrlK4q3ZhSy9q/9aOhomo5bt2BTjP7FQkDXuhFYlCM5Ndpxij8OF7v5cMle3GUFJJrFgVd1mDdTw+hAutSt6Md4oSktLWXEiBGAIZLHW125GGRlZTFq1CjS09MJDQ2ldevWzJ0716zKe/PNN1FVlWHDhuFyuejTpw/vv/+++XqLxcLs2bMZO3YsiYmJBAYG8n//93+mp9XpsHz5ct544w0+/PBDIiMjKSkp4R//+Ad9+vTh008/BYxtm/3793PnnXfyzjvvcOWVV/Lwww+j6zr9+vW7aAUzVQWr1co111zDNddcw6RJk1i+fDkpKSk88sgj5OTk0LdvX5KTk+nVq9dJv1s+j7/Q0NBjPOHKOyZ4vV4zGPQ5JvhWBkNCQs5oQh0eYKNORABbMgoJsFuw2u1Y7XY0RzARQR6ual2LANxkZB8yA8/atRPMFpGaDhn5Lty6oKjYg8OmEmgzikFK3Ya9Vb2oQKwWi5ljdzQur87mjEJcmqDE48VqUQmwqdgshn9fdJCdOpGBWK0WQ1OO0kmXy83mbTvYlGdBQ8fl0VE9AofNqH52eQURATYaxQYZ/XwFeHWtLFg8ko8ZW6Mm367eR5G7AE0YedcWRcNmUdCEgsOq0r52iLFCWTYJP15By6+p2SzYcgidslZ09hAUHVCMtm+julz83rpz5szhtttu44svvmDw4MEX/fo+Klvjzqe+XdY+gBea4/lw1a9f39wmLi+Auq6zefNmDh8+TPv27Y0y/9PEV22XlZVFUVERERERFYpIToVb03lkRipr0vKxWozVNqdHIyLQzutDW9AwOoAtW7awe+8+atSuQ1GpC6fLSLDOKHDxyR97yS/14vbqeMssXKwWw4C5doQ/t3dLMFfffFVlQhxpTbQru4RPlu412xkZi44CFcPjqlVcCP/sUss0jzY6iBitiTweL+npB0ndn8PcfYYzvxCU/dcQI4dVoV3tMG7qFF9hJbFihZtOTomHV37djtOjowIuTTf/0FiAOiEwpFkIkeFhBIcEm6sDqqKiWlQ0TUPXBa/8uoOD+U7AMI62hMSgOgJQgI51wpiY3IyaoRdv9c3pdHLDDTdQWFjIL7/8UmlVx1WBXbt20aZNG55//nkmTJgAwI4dO5gwYQKTJk2iXr16DB48mOzsbB5++GGee+45VFXltddeo2fPnubKSFU0ga4MdF1n5cqVpKSkmF6qvXv3JikpiX79+hEcHGwem5+fz9q1a4mLi6NRo0an/fn5HBOysrLIzs7GZrOZK4Ona8+1dGcOz8/ZWtY+zoJbM/w8B7SM4ZHehn3Nir9WYvMPJDAkjJz8InxFcrPWZ7B0Vw4eTeD26ghUFHRjN8BqYWjbGnSsE2Zey2KxGLnSXt20wvrv8jQ2pRciBMY5FBWEjt2iEOSw8n9da1ew/TJ1EigqKmbnzh0sSLeyK88o7HB7hWH5IgRWRSHE38otiQk0KJdqI4TAarGWbUHrgCBlbTpLth9GwQjcvBjnUAB/VdC7np02CRGEhobi5+fwDcboT1w2+d50sICP/kgr01fQLHZs4XEABNkt3HdtfUZ2vrj5zb/99hs33XQTn3zyCTfeeONFvXZV4nzrmwwAzyP5+fnMnj2blJQU5s6dS1xcHIMHD6ZXr1689NJLJCcnM3r06HPamvNV22VlZVFQUEBYWJhpvXCy8xa5vHy76gC/bs6mxK3RIcEImBpGB7Bp0yby8/Pp0KGD2VOxoKiEzMO5vDr7b1bszCbIz1gRK/VCqcuDwGj5NLBVbIWt14oYzvgf/r6H1AP5hsegAm5d4Crr2tGrWRT9W8QedwvYZ9FQWFDAstxANhwsws9q5J5oGMGhV4erG0UwrF3cSe0HFUXh501Z/LwpG0vZLBZFNVq86VAn0p+7usaSl5dPQUE+Hq+XkOBgQkPDCAkJMSuK9+aU8vpvu6HM40u1WHFE1ULTjWv8NK4LtcMv3vavy+Xin//8J5mZmcybN6/CqnJ1ZO7cuTz66KMsWbKEgIAApk2bxo033khqairNmjXj5ZdfNrto1K5dm1tuuYXvvvuO+Ph4lixZQkxMzEXvZHCpoOs669evZ/r06cyYMYM9e/bQs2dPBg8ejMfj4auvvuLTTz+lbt2653QNX3/i7OxsFEUxg8GwsLCT/m5W7c1j6uoDbMkoIiLAxoBWsQxpW5OSwgLWrl1boeuTx+slOyefNTsO8uzM9QgE/jZLWUchLy4NwvytjE6sTcPoE694WiwWdh0q4d2FO7GUuRloQqHU7cGjQXiAlXuuqUf0CVJ2DJutXWj+YXy5Pt/I1bMYzgweTcftFfjZVJ7o04jwk+RI+ybFT87airusO5Sxra3gKSs0GXNFLWr4aeTn51NYWIjD4SA0LJSw0FD8/QMoizf58I80UtMLUTHyEm2hUaiOIAQK/VrE8MqQC28eX57Fixdz/fXX8/7773PzzTdX64nZ+dY3uQV8HgkNDWXkyJGMHDmSoqIi5syZw9dff81bb72F1WqlSZMmrF+/nk6dOp31H5njVdtlZmaydetWQkJCTK9BXyDnI8hh5bZudbitWx3zMU3TTPPpTp06Vcg/CAkKICQogH36PkJi/fATTtylxQQobvytNopcGsF+1pMEfwACj1djV1YRNqtalvcnsCvg8Dcqia1lM+FjXikgbV8axUVFNGjQkG/n7UZBoKhWc2bqZyszeNX0U3lPI4Qgs8CJEDqqauT3AFgUBaEICko95jaKEPGUOkvJz6tozBoaGsqhYhWha5Sl+mENDDN6LqsCTRjN2y9WAOjxeBg9ejQHDhxg/vz51T74AyP3MyMjgzfffJN33nmHYcOGceONN5rJ1atXr6Z79+5m8VVsbCwTJkxgxIgR51RlXB1QVZV27drRrl07/v3vf7Np0yamT5/Oc889x4EDB2jWrBmLFy8mODiYiIiIsy6S8zkm6LputqTbsGEDQogKLemO1tCOdcIqrNQBZGdns2HDhmPMp21WK3Exkfyxz4U1qjYhqlEgp7hKsZV59gkBcadYydc0jV1ZhWi6jp/DBoqCRTH01tcrN/gEhsvFxSXs2rWL6Ogo9pQ40Ly5+NnVMvNpBRugKgJNCFzayY3+FQUOFbrxeL2GnioKoKIoAptiWF0VeQRRtYxUGE0zzPXz8vPLVRSHEBoaxuFCF0LX0RVQrVasfkYTA7dm9Fa+mPzxxx+MGDGCt956q9oHf3D+9U0GgBeIoKAgOnbsyJNPPmn2Jfzhhx8YOnSo6cOVnJxMYmLiWecb+fn5kZCQQEJCAi6Xy8yp2b59u2ktc6JqO4/Hw7p16wDMyqXjYbMoKFYbfv4B+IVEoHk9eEqKKMnLP63CDQWwWxWKXIaFiloWBApUUHT8jtPLUtcFe9P24ix10rBhI+x2G0EOwwRbL0tqRhhbPIpqIcTv9KoVg+xluTOawGJRUNARCggFYkP8y0ZrGGEH+PsT4O9PzZo1cLlc5OcXkJeXS86hEgQqmjCqmS1+xmerC7CpykVLjvZ6vdx2223s3LmThQsXEhkZeeoXXabk5+cTGBho5rE99NBDPPXUU9StW/eYvJqwsDBWrFjBn3/+SXZ2Nl999RXffPMNrVu3rqTRX5ooikKLFi2YMWMGxcXFfPnll+zbt6+Cl2pycjKDBg06ay9Vn2NCZGQkTZs2JS8vj6ysLDZv3ozX6z2pYwIYLRBTU1Np0aLFCYN7m0VBUVSs/kHYA4KN1BVnCd6CAoS7BMtpjNthNbptaLpudOhQDEcBHWM1z3Kc6o+ioiJ27dpNjRo1iImJJie9EACPJrCpRwyZdRSsqmK0zTwFIf5G2oxXE1jRjYkpAr2s2C4m2B9foyaLxUJ4eDjh4eHouqCoqJC8vHz27NmDRRfm6qHVL8TcMrSoCk1OozXm+WLFihVcf/31TJw4kdtuu63aBn8XUt9kAHgBEUJw44038uyzz6KqKiNGjMDpdPLbb78xY8YMbrzxRmw2G4MGDWLIkCF069btrH24HA4HtWrVolatWng8HrKzs80ikoCAADNnMCgoCLfbzZo1a/Dz86N169YnDUCvaxrFt6sP4tV0rBYV1WLFYw8mNDaY/+vTnFCr57jG02Dkxy3Yeohil06pR8fpMYpQAmwqpR6P4WNYK8TMqfF6NcOcdfcePB43DRs2RLVYmb0hg4P5Tjy6wO3UsFp0/MosDWwWlQ4JoaAo2CxGgrWmH+toP29zNkt35aIJY6UOXceugg6oQPcG4YbIWVRUxcj38xV/OBwOYmKiyfI6mLMuDUFZCztHEG5dQdWNVcWkNjWIDLzwnnuapnHXXXexadMmFi5cSHR09AW/ZlXF6XTStm1b+vbtyxtvvIG/vz9r164lLCyMAwcO8P777zNmzBji4+MBSEpKYs+ePfTr1w+Hw8Gjjz5qNkeXnBmKomC1WlmyZAmtWrUCjArJXbt2kZKSwjfffMMDDzzAFVdcYRrrn62XqqIoZsDSuHFjCgoKyMrKOqFjQlpaGjt27KBNmzam8f/xuKJ+BIF2KwWlXkL9rSiKguoIgEAbvdo34Yq28WQdziMrp6LxtI+DeU5Wp+Xh9gpcXi9Wi4VAGyiKoWXt6oZit1gq5EUXFhaxe89u4uPiiYqKZH+ekx83ZBr6pgucqopD1bGoKpqm0zYhjEC7pcxPVUXTNY7O3Dpc7ObTMtNmAXi9oOLFWpZnGBfmoG6kn+GnWhaQer06imK0pQsJCcEvIIgfd3nYX1SMUd6n4LUHIDTdbKl3Q8e4M/7dnQ2rV69m6NChPPfcc9x9993VNvi70PomcwArEY/Hw8KFC0lJSWHmzJnnzYerPF6v12xJd+jQIex2O16vl9DQUNq0aXPK1cecYjcPTN/EtqwiyhwBsFtVRnWtzW1XJJjHlTeePpxXgBA6P2/MYt7W7DKH+iPFHxbFaNM0pG2NCtWyuq6zd89edF2jbr16WCwWft2czZyNmWWmqeARCghDkIIcFoa1i6Nz3bCjRq1gtVoQusCr6aw/kM/ny9IQGMGeu2wcAAE2CwNaxdKj8bEraL4OIpouKCx1868ftuAp6xaiCbBG1EKxWLEocGUNwbBGFuJrGKuup8pXOls0TeOee+5h6dKlLFq0yLzxqzP/+9//uOuuu7jjjjv4z3/+Q3Z2NjVq1OCTTz7hwQcf5O6772bcuHHmtsiWLVvIy8tDUZSL2j6quiGEqOClumzZMjp16kRSUhJJSUln7aV69DV8jglZWVmUlpbi5+eH0+k8ZfDnY8a6dN5ZuBun19j2VRWoFe7Pm8NbEB/mb16nvPF0qctFfqmHN+fvosBptKdzenRQjmhk3YgAbuuWUGH1riC/gLS0vdSqXZuQkDBKPBoT526nyOlFVcHl0cv6/Ro7Cg2jA7nliornEAIzJ1noAq+u88rc7aQXuFAVY4dDV44UfzSIDuD/uiYc47PqO4+hzxoz1x7gt605R6qc/YKxBhu6WDMARtTX6FjnSIeXC2UztX79egYMGMBjjz3Gww8/XG2DPx8XUt9kAFhF8Hq9pg/XzJkzKSkpYcCAAQwePPiMfbhORF5eHmvXrsVut+NyucxqO1/AcqIbrdjl5bcth9hwsIAAu4UejaNoW+vEVg1er8bujMOM+mQpxUVG4YYQAq8AV1lj83FX1aVRue0ETdPYtcswZ61fvz4WiwUdhad/3Eqx04PdqhqzXkXB7TW8B/+va21j9e8UvLt4L9uzirCWbc8IBXSvjibgyoYRjOhw8lmtEDB7zW7m7igp89MSWP2DsYVE4dUFAXYLvz9wBYX5eWbyuhDCXJU40RbVmaLrOhMmTGD+/PksXLiQOnXqnPpFlzlerxer1cqsWbO44YYbGDt2LM8884xZCf3ZZ58xYcIExowZwz333CM/s0pCCGF6qaakpPD777/Tpk0bMxg8Uy/VE11j48aNZGdn4+fnR0lJyWk7JmzOKOS3zdnkO700jgmid/Nowo5jQO2jsLiEd+dtYsrS7fgpRg6yjorb48GtCZrEBnLnlXVNZwOA3Lw80vbuJaFOHcLDwkBR+GNHLtPXHsSmGhNOVAXNq+P26tQIdfB4n0anzG/edaiUtxcaOdKWsuRkgcCrG04Lzw9qQshJ3gtAaamTf/20A5dm5B2Cgj0iHixWBAr396jHTe1jzALE/Pz8U5p6nw2bNm2iX79+3H///Tz55JPVPvi70Pomt4CrCMfz4Zo+fTqPPPIIubm59OnTh+TkZHr37n1WBrW+4M9XQCKEMKvt1q9fb1bbxcTEEB4eXmH1KtBhJalNDZLanF6SvNVqwWPxRwRGERYSheJ14XUWozpLsCqGL1aJ50hSs9ersXPnTqxWi7HyV3btwlI3JW4PFlUxe2KqgMMKLq9GkevEjeHLc6jQaQaPoKAIzO2VQqfnpK8VAg4ePMih/OJyLv4qFr9g41wYM3+3BlFRUURFRRmrBfn55haVy+UiKirKTG4/m21+Xdd59NFHmTt3LosWLZKBDEfEEYxt+qFDh/LWW2+h6zovvPACwcHB3Hbbbdjtdu677z7cbjf3338/9evXr+SRVz9O5KWakpLCCy+8QLNmzUz7rCZNmpzxH35d1003g8TERPz9/SktLSUzM5ODBw+yZcsWwsLCTI07ekLdrEYwzWoEn+DsxxIcGECOHoAjohZB9rK8QWdxWeafTolbrxD8Hc7JYf/+/dStW4/Q0DKTayHIyC8x3ARUi2H+XBbEWS0KBaXeUwZ/AIeKXOi6js1IQDRyEBWBqmsIMHoinyQAdDpdbN+xA5fXtxakoPoFolqNgFkgyCnx4O/vT506dahTp04FU+9du3bh7+9v5mSeqY+jjy1btjBw4EDGjh0rgz8ujr7JALAKYrFY6N69O927d+eNN95g5cqVTJ8+naeffpoxY8bQq1cvkpOT6du3bwUfrhPhq4Rr3LgxtWoZ/k2Kohy32m7jxo1mtZ1v9epstjLDA2xYVMPB3t8vEJtfIEIISkuL0YqLiAw2BNjj8bJz5w7sdgd169Y1zVkB/G0qVlXB6TFm2BbFWAX0JTVHBjpO6dcmhGHncKjIjQZYLGWO+EKgqlAzPNAILjl2IdywoTlAXl4eCTWiWJWVDYDV7kCx+SqmBbXC/Sts0SiKQlhYGGFhYaapd3Z2NmlpaaSmphIefmbbKLqu89RTTzFz5kwWLVokA5gyfOLYu3dvSktLufLKK7nhhhv48MMPKSgo4K233iIkJISbb74Zi8XCP//5TwYNGiQ/v0rGpz1jxozhjjvuIDc3l1mzZpGSksKrr75qeqkOGTKE5s2bn1J/NE1j/fr1x7gZ+Pv7H+OY4JuUhYSEmPYyRzsmnC5RQQ4UBVSLDUdQGI6gMHTNiycvj+iwI3rg665Uv159goMrFlEEOazowrB8sVoUo30bRvGHTyNPRXiAEdx5NYFF1c3WoAIFm81CTIgfus4xZs9gBH87dmwnNDyCsIACcks8aEJg8zP+ruhCoAtB85oV/84cbertW0xYs2YNFovF1LejFxNOxPbt2xk4cCCjR4/mueeeq/bBH1wcfZNbwJcQuq6zbt06pk+fzvfff2/6cCUlJdG/f//jmqaeTiVceYQQZrVdVlYWXq+XqKgoYmNjz3gr88GUTSzZfhh/mwWbRcGrC0rcGo1iAvnf6HZkH8ph4R/LcGuC2BpxFYK//FIPny/fx67sErzC2JKwKmCzKmi6IDLQwWN9G2JTVSMfRgjcnoqO9i6vzn+XpZGaXoQmjBBPEWC1GNdxWFUe69OIiAAbVosFFKMCWZRVGB84cID8/Hx2esL4dcthfGuW1pAYLA5jFVZVFV5KasqgVqe3OlpaWmpuE+fl5ZnbKNHR0cc1BxdC8MILLzB58mQWLVpE06ZNT/vzrw589dVXPPLII6xcuZL4+HiEEPz888+MGDGC4cOH8+abb5r2OFu2bJGfXxUnPz+fH3/8kRkzZvDLL78QHx9vBoNt2rQ5JpjweDysXbsWRVFo27btaa2uu91uU99ycnJO6ZhwIjYcKOCub/7GqwkCHUYuXYnbWHX79+CmXFk/jDV/b2RD6haia8QTGFhx5+aPnTn88HcGRS6jVZ2CgsNipKgIIbihYzxd6oaXy/fTze5G5cfw5Yr95nVBRaUsCFTgmkaRDG1Xs8yeRoWyYjtFMbZ9d+7cgRoQxjebisgpNvxdFath/Kxi6FudCH9SxnTCfoJeyOXRdZ2cnBxT43RdP2W19u7du+nbty/Dhg3jjTfekD6c5bjQ+iY/6UsIVVVp3749L730EqmpqaxcuZIOHTqYDuDDhg3jyy+/5PDhwwgh+O9//8vff/9N27ZtT9vjzFdt16RJE7p370779u3x8/Nj+/btLFq0iPXr15ORkYHXe+rt18f7NKJVfAhuTafA6cXp0agbGcBLSc1wu1zs2LaF1k0aMGr4YBLbNqderZoE+PkhBEz+cz97DpVgtSplWykKXiFweXRqhvpxR/cEbKph2+L1evFqGqpFwWqxYilrlTR7QyabM4pQFV+fTkMUvbogOsjO2CvrEhloM1z9dc2o/BVGd5DMjHQKCvIRoTWZu+WwWUCiWKwodn8ERq/Mfw86/eAPMLdROnbsyFVXXUWtWrXIy8tjxYoVLF26lO3bt5OXl4eu6wgheOWVV/jss8+YN2/eBQteXn75ZTp16mQGo8nJyWzdurXCMU6nk3HjxhEZGUlQUBDDhg0jMzOzwjFpaWkMGDDArDp/+OGHT+t7ci4UFxcTFhZmFsMIIejfvz/vvfceX375JU888QSHDh0CjH7bvmMkVZPQ0FD++c9/MmPGDDIzM/n3v//Nvn376Nu3L61ateLxxx9nxYoVRsHY3r18/vnn2O122rdvf9qpFXa7nVq1atG+fXuuvvpqEhISyM/P588//2TZsmXs2LGDwsLCU35PWsWH8MB1DfC3qRQ6vRQ4DQ++0Ym1ubZxJPv3peEqyueG5AEMvPYKWjaqR3SE0a5ya2YRM9am4/YYVlgKCrrQcWpG8NaneQxd6oYb2qQZ2qQLgaqoWK1WFEUlt8TD53/uw+Uxtn99xjE6gAJXNYpgkC9tRwhT4xRFwe12s3v3LiIiIvllt4u8EqMlpwpY/EPKzgTXNonkv6PanlbwB8bfqKioKJo3b85VV11Fu3btsNvtbNu2jUWLFrFu3ToOHjyIu6yiOi0tjf79+zNo0KALGvxdqhp3ofVNrgBeBggh2LZtGykpKaSkpLB+/Xri4+PJzMxk6tSp9OrV67xV2/lmzr4Ea18XkhOJry4Ea9Ly2ZtTSo0QB13qheEqLWX16tXExMQcN99nze5sbvlsGbhLUHWP0aMdgdtrePQ91b/xKe1WvLrg8ZlbcXl1LIpRuKEoCrpu2MDc2DGOKxpEHOd9Gt1H8vMLaNiwId+tz+KvPfnGTSUEtpBILP4h6ELQrEYQ0+7odNafaYXxlttGWb16NU8//TS1atVi165dzJ8/n06dzs91jkffvn254YYb6NSpE16vlyeeeIKNGzeSmppqroiMHTuWn376icmTJxMaGsr48eNRVZWlS5cCxh8p30TjtddeIz09nVGjRnHHHXfw0ksvnZdxHm+7f+nSpVx33XXMmjWLPn36mI+vWLGCpKQksrKymDx5MqNGjTovY5BUDiUlJcydO5eUlBRmz56Nv78/BQUFdOzYkR9++OGs7bPK43NMyMrKMh0TfCuDJ8trO1zsZvmuXDTd6EceF+pg+/btpKen06FDh2NW9r1ejXunrGRJ6n6s3lIjAUWx4NW8eDVBpzph3Nzl1K3WfttyiB82ZGJRjCQWFJ/VjE6In40Xk44/YfSt/EVGRmENCuO5OTuM/Giho6pWbJHGtQXw3g2tubrRuXuMCiEoLi42/348++yz5OXlceDAAfr06cNXX311QVf+LgWNqwx9kwHgZYamaYwePZoffviBhIQEtmzZQmJi4jn7cB2N72bOzMw8o/7EhYWFrFmzhri4OBo2bHjcsSzedoj7p2/C36aC5sXrLEZzleB1OfHoOvdcU48GJ2nPBFDk0nhy1mbA2MZQFENchNDQdOjfMpa+zSv65x0d/Dkcdj78fS8bDhSUVeip2CLiUVULmi6oGergt/uuONOP7pSUlpZy33338d133xEaGmraA7311ltERBwbtJ5vsrOziYmJYfHixVx11VXk5+cTHR3NlClTGD58OGBsNzRr1ozly5fTtWtXfv75ZwYOHMjBgweJjY0F4MMPP+TRRx8lOzv7nC2NNE0zt48KCwvN3Nfi4mLuvPNO9u3bxxNPPGGK5Pr16/nggw949NFHqVev3jldW1K1+Ouvv+jTpw81atQgMzMTh8PBwIEDz9lLtTyaplVoSWe1Wk/LMUEIwdatW8nOzqZ9+/Yn3FK+4bNVbMssxt+morlK8boMjXO6PDSpEcTdV9U95Rh9fX8tqoLRwVgFFDyasRL55vCWxxSRlA/+atasQVpOKa/8usO0frEGhWMNDDNyrYGXk5oxuPX575CzbNky/vGPf2C1WsnJyaFdu3ZMmDDhovX5rWoaV1n6JreALzOmTJnCihUrWL9+PX///Tc7d+5kyJAhzJw5k2bNmtGzZ08mTZrE3r17z2krLDAwkHr16tG1a1e6detGZGQkBw8eZMmSJaxatYq0tDScTmeF1+Tn57N69Wpq16590mbxCREBWMsc7VWrDXtQGP6Rcdgia+EfFk3DuEjg5EGsVQU/m4pXF0Zen66D0NHL9kfqRAaaydJgBH/791cM/jQd/G3GTakLgeoIQlUtpit+p6PaTp0PhBB8+eWXzJ49m8WLF5OZmcmcOXOoU6cOISEh5/16xyM/Px/ADDZXr16Nx+OhZ8+e5jFNmzYlISGB5cuXA7B8+XJatWplCiNAnz59KCgoYNOmTec0HlHWdQUMo+Hrr7+e3r17M2/ePPz8/JgwYQIxMTHcfffdTJgwgYkTJ5KUlISu66Y4ynnu5YHX6+Xmm2/mkUceITU1lczMTL744gsUReGWW26hYcOG3H333cybN8/cZjwbfIUMLVu25Oqrr6ZZs2Z4vV7Wr1/PkiVL2Lx5M4cPH0bXj7gZCCFITU3l0KFDdOzY8aT5hA2jA00Js/oF4BcajX9UbewRNWhcuwaO0wgmghxWvLrAowkUYXT9EEIDRSE+PBCrRaXc8CgpLWXHjiPBHxgaaQSQgKKg+hmrlb6Ulza1zr/mZGVlce+999K7d28OHDhAeno6d99992kVNJ4vqpLGVaa+yRXAywxd18nPzz+mL6wQgoMHD/L9998zY8YM04crOTmZpKQk6tevf15WBp1Op9mFJC8vz6y28/PzY/PmzdSvX/+0LEwemL6RRdsPY1GMHEBPWSA3uHUNnh3YBLfHS1ZOHlnljKd9ZBS4eHfRbnJLPGWufcYWic8HMD7Mj4d6NsSigkU1ij/S9qaRX5BPgwZG8OfRdD5YspetmUVmfbDNZ/ysKjgsKt/c1p5GMeevNZIQgsmTJ/P4448ze/ZsrrrqqvN27tNF13UGDx5MXl4ef/zxB2BMKm655RZcLleFYzt37kyPHj145ZVXGDNmDHv37mXu3Lnm8yUlJQQGBjJnzhz69et31uPxbQ09/fTTfPzxx9x3333MnDmTvLw87r77bu6++27S0tKYOXMmH3/8MXXq1KFJkya88847Z/kpSKoyhw8fPm7rQ6/Xy++//860adOYNWuW6aWalJTEddddd168VHVdN4vkMjMzTceE6Oho0tPTKS4uNvOmT8bGgwXc9tV63F7dKPwA3JrhKfrV6PbUjfQ/xnjahxAwc306C7cdxquXs27xlYGoCrddkWAEb4qCRVUpLSlh67btREdHmfngGw8W8vEfe9F0o0BOLWf8bFFgUOsavJTU7Jw/s/IcPnyYAQMG0KhRI6ZOnXpeVmvPlKqkcZWtb9IG5jJDVdVjgj8wijvi4+MZP34848aNIzs72wwGn3/+eZo1a2YGg2fjw+XDz8+P2rVrU7t2bbPa7sCBAxQUFOBwONA0jaKiouNWvJbn+UFNefHn7czfmo27rOVb/9axPNKrIQB2m5VasVHUio3C69XIzs0n83Auh3KMrh8FziNtkLxlsaEmoEPtYK5vH4+vPadX09i3bx9FRYU0btwYP4cfutCZn5rN1swi47MDFEcgisW4XZrEBPLMgCbnPfj7+uuveeyxx/jhhx8qJfgDGDduHBs3bjSFsbLxiePGjRvZv38/s2bNokuXLjz++OOMHz+ejz/+GI/Hw5gxY0xXfIvFYm7HnMomSHLpcaK+11arlR49etCjRw/eeecdli1bRkpKCg899BB5eXn07duX5ORkevXqdVZeqmB8HyMiIoiIiKBJkybk5+eTkZHBhg0b0HWdmJgY8vPzsdlsJ3VMaBkXwsSkZrz22w4yC1woKCRE+PNEn0ZmP/Gw4CDCgoNoUq8WhcUlZB7OI/NwLsu2ZbJg62EUjG4hXt3IkdaBEIeVYe1rHlm5E4LCoiJ27thJTEw0cTUN0/til4f/Lk9DKwsgFcASYLzGqiqM6V6HO688v16jubm5JCUlUbduXb755ptKCf6gamlcZevbJbcFvGTJEgYNGmTmss2cObPC80IInn76aWrWrIm/vz89e/Zk+/btlTPYKorP9PnOO+/kl19+ISMjg/vvv5/Vq1dzxRVX0LlzZ/7973+zcePGClscZ4rdbsfhcFBUVESzZs1o2LAhBQUFrFix4pTVdkEOKy8nN+Onu7vw+ah2/DSuC0/3b4Kf7VhRtVot1IyOoG3TBsTWaUA2oVj8AlEtxvaGTQWroqAqCtc1jSHYzwjkhMAM/ho2bITVasWredF1nRW7c0BRzcRqa0CIIZKqQvOawbSKP39bI0IIpk2bxgMPPMD06dPp0aPHeTv3mTB+/Hhmz57NwoULTb9IgBo1auB2u8nLy6twfGZmprma4MvHOvp533PnwpdffkmfPn34/fffTY83gHfffZdevXrxxRdf8P7773Pw4EH8/f0r5OJcasGf1Lfzg8Vi4corr+Stt95i9+7dzJ07l4SEBJ566inq1q3LP//5T6ZNm0ZhYeFZX0NRFIKDgykuLiYoKIgOHToQEBDAjh07TMeE9PT0E1aJ9mgSxay7OvO/0e35+tb2zBjTiS71jp28g2E83TAhjm7tWrDLHYolMAyrw/AhtNtU7KqCRVGoE+lfITWlpLSUnTt2Eh0TTWxsrFEJrGtsTC/A6RWGxgGqwx+L1YaC0cN9WLua2CznLzwoKChgyJAhxMbGMm3atPPS5vRsqIoaV5n6dskFgMXFxbRp04b33nvvuM+/+uqrTJo0iQ8//JAVK1YQGBhInz59jslHkxgoikJERAS33HILs2fPJjMzk8cff5zNmzdzzTXX0L59e5555hnWrl17xsFgRkYGf//9Ny1btqRWrVrExcXRtm1brr76aurXr09JSQkrV65k6dKlbNu2jfz8/GOCwehgB63jQ05Z9euj0KWhOgKwh0bjiErAFhqLLSAY1WJskBSXdQ8RAtL2pZnBn91ecTZa6taNbWUhsNj9UG2G2AohKDzNDiSny8yZMxk/fjxTp06tUOl1sRBCMH78eL7//nsWLFhwTFJxhw4dsNlszJ8/33xs69atpKWlkZiYCEBiYiIbNmwgKyvLPGbevHmEhITQvHnzcxrfDTfcwBVXXMG+fftYuHAhpaWl5nNvvfUW/fr14/XXX2fFihXndJ2qgNS384+qqnTt2pXXXnuNbdu2sWTJEpo2bcrLL79M3bp1+cc//sGUKVPIy8s7o1wqr9fLmjVr0HWdDh06EBERQaNGjbjiiivo0qULQUFB7Nmzh0WLFrF27VoOHDiAx1Ox85DNotK8ZjBNYoOMNm6nQaFXwRIQiiMiDr+o2lgCwlDtfgiE6SkIxvaksfIXQ41yeWsAbo+hbQgdEKj+FSe05c9zrhQVFTF06FBCQkKYMWNGhSDnYlGVNa4y9e2SzgFUFIXvv/+e5ORkwPglx8XF8eCDD/LQQw8BRrJnbGwskydP5oYbbqjE0V56FBYWMmfOHFJSUvj555+Jiopi8ODBDBkyhI4dO560bN/XfqlVq1ZER0ef8Lijq+18ydexsbEnrbY7ETnFbnpNWo5HE2WtkQzcXh2r7ubD4Y1wlhSybcdOiouKadiw4bHBn0fjrfm72J/nRAC2kBgsfgH47pQn+zXipk6ntmk4HWbPns0tt9zCV199xZAhQ87LOc+Uu+++mylTpjBr1izTSwoMTzZfl4SxY8cyZ84cJk+eTEhICPfccw9gVPPBEYuEuLg4Xn31VTIyMrj55pu5/fbbz8gi4URbGrquM3z4cLZu3coTTzzBkCFDKmzjff3114wcOfKs3n9VRerbhcXXO9hnrL9161Z69OhBcnIyAwYMICIi4oT64/F4WLNmDTabjTZt2px0u7e8/UlhYaHZCSgmJuasgqH//LaTL1fsw6IcWQEy7F80kpqGkNw8lP3pmWzfvoPY2FhiY2OOOcfqtHw+W5YGgGqxY4swtoYFEBFgY+GEK87LCmBxcTHDhg1DURTmzJlz3noGnylVReOqmr5dVgHgrl27aNCgAWvXrqVt27bmcVdffTVt27bl7bffrpyBXgaUlJTwyy+/MGPGDGbPnk1wcDCDBw8mOTmZrl27VhDAffv2sX37dtq2bXtGtiXlXeSzsrLMllGxsbGn3VII4PV5O/hyxX6jr6ailLnnK9zcpRYP9WzApk2bOJiRRVztOuQVlVJSbvXkcLGb//y2k7xSY5VPsVixhsejKAoWVaFWmB/T7+hIoOPc02d/+eUXbr75Zj7//HNGjBhxzuc7W070R+7zzz9n9OjRgFHc8+CDD/LNN9/gcrno06cP77//foWtj7179zJ27FgWLVpEYGAg//d//8fEiRPNlkanonxC9Lp168jOzqZu3brExMSYzc+HDh3K1q1befTRRxk2bNgxf1DKn+NSR+rbxcNn35KSksKMGTPYsGEDV155JcnJyQwaNIjo6GjzPnG5XKxZswZ/f39at259Rt83XyegrKws8vPzCQ0NNb0GT7dI5UCekxGfrqLQeaRXsBAQ5LDw3e0dCVbd/LVyJaERUdj8gziUW7FIbvaGTOZsysKw0QdrcBSqX5Dpq/DcwCYMbx932u/pZO91xIgROJ1Ofvnll4ta5Xs0VUHjqqK+XVYB4LJly+jWrRsHDx6kZs2a5nEjRoxAURS+/fbbShrp5YXT6WTevHnMmDGDWbNm4XA4GDRoEEOGDGH+/PlkZmbyyiuvEBYWdtbXKF9tl5WVhaZp5qw5IiLipDNuTRdMXp7G/1bsJ7fUQ5i/jX92rsUtibXZsjmV/Px8OnbsaM6+i0pKyTyUS+bhPF79JZXUg4Vm2zdLUITpjD+wZQyP9G5EVNC5568sWLDA7Os4cuTISy5X7XxTfmb8+uuvM2nSJGw2G06nk5tuuomRI0eaQc8NN9zAxo0bueuuu7j99tvPS3VnVUTqW+UghGDXrl3myuDq1atJTEwkOTmZNm3a8PDDD/PCCy9w9dVXn9MfY5fLZepbbm4uwcHBZjB4qiKV7VlFvP7bTlbszgWgc91wHurZgFg/jTVr1lRwW/B6NQ7l5ZN1OI9VOzJ46ZcjHTAU1YI1opbRv9zfylP9m9CvxbErhmfz3m688UZyc3P59ddfzQCnulJV9U1WAUvOGD8/PwYNGsSgQYNwu90sXLiQ6dOnM3z4cEpLS+nbty8rV67k6quvPutk3+NV22VlZbFlyxY8Ho/ZnzgqKuqYYNCiKtzWrQ6jExMocWsE2C2oCmzatMnsHlB+6yUowJ+gBH9iY2PYNnM/SqAVxVWC0DyoDqPSVwHa1g49L8HfkiVLuPHGG3nnnXdk8FeG7zP473//y8SJE/nss89ISkrikUce4aOPPiIrK4vx48fTqVMnpk6dSv/+/Vm1ahXjx4+v5JFLLjcURaFBgwY8+uijPPLII6SlpTFjxgymTJnCgw8+SEREBH///TcNGjSgdu3aZ33/OhyOCo4J2dnZZGVlsWPHDgIDA81g8HiOCY1igvjopjaUuI1cvQC7hfz8fNasWUODBg1ISEgwj7VaLdSIiqBGVAQ/7/HiCMvD4yxGd5Wg+gWb49cF5yX4c7vdjBo1iqysLH777bdqH/xB1dW3yyoA9C3VZmZmVpghZ2ZmVtgykZw/7HY7vXv3Zv78+YSEhPDOO++watUqxo4dS2lpKQMHDmTw4MHn5MOlKAphYWGEhYXRqFEjCgsLTaHcuHEjUVFRxMTEEBUVVcFawKIqBPtZ0XWdjRs3UVhYSIcOHU6Yd+P06GCxYQkIxRIQitB1lLIZvqJgiu25sGzZMkaMGMFrr73G6NGjZfBXjszMTGbOnMkLL7xAUlISS5cu5bPPPqNfv34sWrTI3KLp3Lkzc+bMMV9XXaxepL5dfBRFoU6dOvTv35///Oc/3HrrrbRp04bvv/+ep59+mrZt25KUlHTOXqp2u534+Hji4+PxeDxmS7rdu3fj7+9v7n4EBwdXuEaA3Zj8nij4OxqnV2BxBCBs/oigipt/pZ5z1zePx8Ott97K3r17WbBgwUXpXHSpUBX17fJIlimjXr161KhRo0Ilj892xFfJIzn/uN1u0tPTWbJkCbfeeivvv/8++/bt44cffiAiIoKHHnqIevXqccstt5gGrWeLoiiEhITQsGHDY6rtFi9ebFbb+boA6LrOpk2nDv4AIgNt1Iv0N3NhlHLbO7qAriewaDhdVq5cyfDhw3nxxRe58847q0XQciaEh4dz1113kZSUxI4dOxg5ciT3338/U6dO5dZbb+XXX3/lueeeY+3ateZrqkvwB1LfKpOdO3cyevRoPv30U+69914WLFjA/v37uf3221myZAkdOnSgW7duvPLKK2zduvWcOs/YbDZq1qxJmzZtuOaaa2jQoAElJSWsWrXKdEwoX7Gcl5fHmjVraNiw4UmDP4Au9cJN82hFUcx7R1WgS91z0zev18uYMWPYsmULv/32G1FRUed0vsuNqqhvl1wOYFFRETt27ACgXbt2vPHGG/To0YOIiAgSEhJ45ZVXmDhxIl988QX16tXjqaee4u+//yY1NfWyzRWq6ui6zl9//WXm1GRmZtK7d2+Sk5Pp27fvKU2hT5eSkhIyMzPNaruwsDC8Xi+aptGpU6fT2o5euPUQ47/dgKIYQR8Y27+9mkXz1vUtz3psa9euZeDAgfzrX//igQceqDZBy5lSXFxMYGAgr7zyCosXL2batGkEBgby5ptvMm3aNFq1asV777132oUllxpS3y49hBDk5OQwa9YsUlJSmD9/Pg0aNCApKYkhQ4bQrFmz85K4r2kaOTk5ZGZmmo4JoaGhHDp0iEaNGp0y+APwaDo3T17LxoMFpr5ZFGO35Ktb2tMy7uz8TTVN4+677+avv/5i0aJFFVaoJUeoavp2yQWAixYtOq5R7v/93/8xefJkhBA888wzfPzxx+Tl5dG9e3fef/99GjduXAmjlRyNruusXbuW6dOnM2PGDPbt28d1111HcnIy/fv3JyQk5LwERyUlJfz9998UFxcjhCA0NNTcRvGV/Z+I5bty+PD3vWw8WEB4gJ1/dIhjdGLts7ZF2LBhA/379+ehhx7iscceq7bBn6+Czel0njJYefrpp5k/fz5ff/01devWZdSoUVx99dWMHj0ai8Vy2a78SX279MnLy+PHH39kxowZzJ07l1q1apnB4JlWDZ8IXddNtwVVVVFVtUKR3MmuUezy8tHve5m5PoMSt0bnemGMv7oezWueXZWuruvce++9LFmyhIULF1K7du2zfVuXNJeivl1yAeDF5uWXX2bGjBls2bIFf39/rrjiCl555ZUKXkK+vfupU6dWKB+PPcp8U1KR8j5cM2bMYNu2bVx77bUkJSUxcOBAwsPDz+om0HWdDRs2UFJSQocOHRBCHFNt5/MaPNuWUKdLamoq/fr1Y/z48Tz99NOXZdByJmRlZXHVVVcxadIkevfufcLjvv32W/71r39Ro0YNXC4XBw8eZOPGjYSFhV22wV9lIPXtwlJYWMhPP/3EjBkzTC/VpKQkkpOTT+mlejJyc3NZu3YtjRs3Jj4+ntzc3AqOCdHR0cTExBAZGXlSx4RzRdd1HnroIebOncvChQupW7fuBbvWpcClpm8yADwFffv25YYbbqBTp054vV6eeOIJNm7cSGpqqunRM3bsWH766ScmT55MaGgo48ePR1VVli5dWsmjv3Qo78OVkpLCxo0bueqqq0hKSjrGh+tkHB38Hb3tW77a7vDhwwQGBprBYGBg4Hm98bZu3Uq/fv249dZbefHFF2XQgrFVlJSUxF9//cXXX39Nr169KjxfXvy+/vprNm7ciMvl4sknnyQyMvKy8vmrCkh9u3j4vFRTUlL46aefCAkJYfDgwSQlJR3jpXoyygd/5duZgXH/+BwTsrKycLvdpmNCZGTked1a1HWdxx9/nJkzZ7Jo0SIaNGhw3s59qXKp6ZsMAM+Q7OxsYmJiWLx4MVdddRX5+flER0czZcoUhg8fDsCWLVto1qwZy5cvp2vXrpU84ksPIQQ7d+40TVnXrFnDFVdcQVJSEoMHD6ZmzZondFPfsGEDpaWltG/f/pQ5f+Wr7Q4dOoSfn58ZDB5dbXem7Ny5k759+3LjjTfy6quvyqClHLquc+uttzJjxgy+/fZb+vXrd8zzXq+X3bt3V1iJksHfhUfq28XB56WakpLCDz/8UMFLtVu3bicM1HJycli3bh1NmjQhPj7+pNcQQpiOCVlZWZSWlhIZGWnaZ5V3TDhTdF3n2WefZcqUKSxcuLDCfVrduZT0TQaAZ8iOHTto1KgRGzZsoGXLlixYsIDrrruO3NzcCsbHderU4f7772fChAmVN9jLACEEaWlppKSk8P333/Pnn3/SqVMn03rB58PldDrZsGEDmqaZfR3PBE3TzGAwOzsbm81mBoOhoaFnFAzu2bOHfv36MXjwYN5++20ZtJyA22+/nalTp/LNN98waNAg83Gn08moUaNYsmQJu3btuuDb9JIjSH27+JT3Up01axYAAwYMYMiQIVx11VXmRHb//v1s27bttIK/41FUVGQGg0VFRURERBAbG0t0dPQZ+bUKIXjppZf49NNPWbhw4Tn3+r5cuRT0TQaAZ4Cu6wwePJi8vDz++OMPAKZMmcItt9yCy+WqcGznzp3p0aMHr7zySmUM9bJECMHBgweZMWMGM2bM4I8//qBt27YMGDCA2bNn07hxYz744INzmtnCkWo7n1j6+hPHxMQQFhZ20oBu//799OnTx8yTksHfybn77ruZPHkyX331FUOHDsXtdnPPPfcwffp0/vjjD5o1a1bZQ6w2SH2rfLxeL0uWLGH69OnMnDkTp9PJgAEDqFmzJp988gm//PILrVq1OufrlJSUmPpWUFBw2v2JhRC8/vrrvPPOOyxYsIDWrVuf81guZ6q6vsm/TmfAuHHj2LhxI1OnTq3soVRLFEUhPj6ee+65hwULFrBv3z5GjRrFe++9x+rVq1m/fj1vvvnmOftwWSwWoqOjadGiBVdffTUtWrQwt5eXLFlCamoqhw4dQtf1Cq9LT09nwIAB9OjRg/fee++CBn9Llixh0KBBxMXFoSgKM2fOrPC8EIKnn36amjVr4u/vT8+ePdm+fXuFY3Jychg5ciQhISGEhYVx2223UVRUdMHGfDzef/99xowZw0033cQ333zDww8/zNdff82SJUto1qwZmnbu5rSS00PqW+VjtVq59tprTS/VmTNnUlRUxOuvv05paSlvvvkmP/zwwzl5qQIEBARQt25dOnfuTPfu3YmOjiYjI4Pff/+dlStXsnfvXkpLSyu8RgjBpEmTePvtt5k7d+4FDf6kvl0cLk8zrQvA+PHjmT17NkuWLKmQeFujRg3cbjd5eXkVtkgyMzMrNJGWnF8URSEiIoK5c+dSr149VqxYwaJFi0hJSeHll1+mUaNGZrXdufhwqapKZGQkkZGRCCHIy8sjMzOT1NRUNE3D39+fHTt20K1bN4YNG0aXLl345JNPLmjlHRh+Um3atOHWW29l6NChxzz/6quvMmnSpAp+cX369KngFzdy5EjS09OZN28eHo+HW265hTFjxjBlypTzNs7ySc8nqm5766238PPzY+TIkaiqyqpVq8yg+0J/jhIDqW9VD4vFgtvtZt68eUyePJlGjRqRkpLCk08+ye23306fPn1ISko6Zy9VPz8/EhISSEhIwOVykZ2dTWZmJtu3bycoKIi9e/fSpEkTli1bxiuvvMLcuXPp0KHDeXynxyL17SIhJCdF13Uxbtw4ERcXJ7Zt23bM83l5ecJms4np06ebj23ZskUAYvny5RdzqNUOTdPEa6+9JvLy8szHdF0Xubm54ssvvxRJSUnC399fNG7cWDz00ENi6dKlorCwUBQXF5/zT1FRkTh48KCYOnWqiI2NFYqiiFq1aomvv/5aFBQUXNTPARDff/99hc+gRo0a4rXXXjMfy8vLEw6HQ3zzzTdCCCFSU1MFIFauXGke8/PPPwtFUcSBAwfOeUxer/e4j+u6fsLXvPnmm2Lt2rVCCON3K7nwSH2r2qxfv15MnTq1wmOapolVq1aJxx57TDRu3Fj4+/uLQYMGiU8//VQcPHhQFBUVnReNy8vLE9u3bxdDhgwRqqoKVVXFLbfcItavX3/S+/h8I/XtwiEDwFMwduxYERoaKhYtWiTS09PNn5KSEvOYu+66SyQkJIgFCxaIVatWicTERJGYmFiJo5b4KCgoEN98840YPny4CAoKEvXq1RP33XefWLRo0XkJBvft2ydatWolrr76avHEE0+I5s2bC4fDIdLT0y/aezxaIHfu3CkAU2x8XHXVVeLee+8VQgjx2WefibCwsArPezweYbFYxIwZM85pPD5x3LNnj3j88cfFhAkTxAsvvCBKS0vP6PWSC4/Ut0sbXdfF33//LZ566inRsmVLYbfbRd++fcUHH3wg9u3bd87BYFFRkfjggw9EYGCgePLJJ8WwYcNEQECAuP/++y/ae5T6duGQAeApAI778/nnn5vHlJaWirvvvluEh4eLgIAAMWTIkHMKAN5//33RqlUrERwcLIKDg0XXrl3FnDlzjrleRESECAwMFEOHDhUZGRnn8jarBUVFRWL69OnipptuEqGhoaJ27dpi3LhxYt68eaKgoOCMxfHAgQOiffv2YsCAAcLpdJrX2bFjx0V9X0cL5NKlSwUgDh48WOG466+/XowYMUIIIcSLL74oGjdufMy5oqOjxfvvv3/WY/HNgHft2iUiIyNF7969Ra9evUStWrVEixYtxIoVK8763JLzj9S3ywdd10Vqaqp4/vnnRbt27YTNZhPXXXedeOedd8SePXvOOBgsKioSn3zyiQgMDBS//fabeZ3i4uJjtOVCIvXtwiGLQE6BMILkY35Gjx5tHuPn58d7771HTk4OxcXFzJgx45zyY2rVqsXEiRNZvXo1q1atMrtjbNq0CYAJEybw448/Mm3aNBYvXszBgwePmychqUhgYCDDhg3j66+/Jj09nXfffZeioiJGjBhBkyZNmDBhAkuWLMHr9Z7yXAUFBQwdOpSoqCimT59eoXKuOhuiKoqC2+1m7NixDBgwgLlz5/Lzzz+zadMmIiMjufnmm8nNzQU4p0IdyflB6tvlg6IoNGvWjKeeeorVq1eTmppKr169+N///kfDhg3p378/H330Eenp6ad176WkpHD//fczbdo0rrvuOvPxgICAatvr97LTt0oIOiVnQXh4uPj000/NnJxp06aZz23evFnm5JwDLpdL/Pzzz+L2228XUVFRIjo6Wtxyyy1i1qxZIjc395iZcVZWlujevbvo0aOHKC4uruzhV4ktkvLbGm63W3Tt2lV8+OGH5nmFEMLpdIrGjRuLu++++4zPL7m8kfp24dB1XezevVv85z//Ed26dRMWi0VcccUV4pVXXhFbtmw57srgN998IwICAsSsWbMqe/hS3y4gcgWwiqNpGlOnTqW4uJjExERWr16Nx+OhZ8+e5jFNmzYlISGB5cuXV+JIL13sdjt9+/blk08+IT09nalTp+JwOLjzzjupX78+d911Fz///DMul4uSkhJGjBiBoij88MMPVdKkuF69etSoUYP58+ebjxUUFLBixQoSExMBSExMJC8vj9WrV5vHLFiwAF3X6dKlyymvIY6a3VosFgoLC00T7eLiYv766y/AsLbweDw4HA569OjBgQMHzsfblFwGSH278CiKQt26dXnggQf4/fff2bt3LzfccANz5syhZcuW9OjRgzfffJNdu3YhhGDOnDncdtttfPnllwwePLiyh38MUt/OI5UcgEpOwN9//y0CAwOFxWIRoaGh4qeffhJCCPH1118Lu91+zPGdOnUSjzzyyMUe5mWN1+sVixcvFvfcc4+oXbu2CAkJETVq1BDt27cX+fn5lTq2wsJCsXbtWrF27VoBiDfeeEOsXbtW7N27VwghxMSJE0VYWJiYNWuW+Pvvv0VSUpKoV69ehUTlvn37inbt2okVK1aIP/74QzRq1EjceOONZzSOp59+Wvzyyy9C13URFRUlvvrqKyGEEJ9++qlo2rSpmDRpUoXjJ0yYIIYPHy5cLtdFrSSUVC2kvlU+uq6L9PR08cEHH4iePXsKm80mGjRoIBwOh5gyZUqljk3q28VBBoBVFJfLJbZv326W+0dFRYlNmzZJgawkNE0TS5YsEV27dhX79++v7OGIhQsXHjd5///+7/+EEIa4P/XUUyI2NlY4HA5x3XXXia1bt1Y4x+HDh8WNN94ogoKCREhIiLjllltEYWHhaY8hNTVV9O7dW1x55ZUiLi5O3HDDDeZzaWlp4p577hFt27YV99xzj/j111/Fm2++KRwOh5g5c+Z5+Qwkly5S36oWuq6LQ4cOiUcffVSMGzeu0oMXqW8XB9kK7hKhZ8+eNGjQgH/84x+yN6ekyvD777/Tp08f/P39+fjjjxk2bJj5nK+H84cffkhJSQnR0dHcf//9jBo1qhJHLKmKSH2TVEUud32TnUAuEXRdx+Vy0aFDB2w2G/Pnzze/jFu3biUtLc3Mf5BILjSizPVe0zRuu+02srKymDRpEi6Xi5tuugmAhIQEJkyYwIQJE8jIyDBb7EkkRyP1TVKVqC76JlcAy/B9DMdr5XKxefzxx+nXrx8JCQkUFhYyZcoUswVPr169GDt2LHPmzGHy5MmEhIRwzz33ALBs2bJKHrmkurJu3TomTpzI/v37ueuuu/jnP/8JwObNmwkJCSE+Pr6SRyipKhon9U1yqXG56ptcASyjvCjquo6iKJUmlFlZWYwaNYr09HRCQ0Np3bq1KY4Ab775JqqqMmzYMFwuF3369OH999+vlLFKJABt27bl8ccf59VXX+WTTz7h8OHDdOrUie7duzN79uxLViAvJ6qKxkl9k1xqXLb6Vnnph1WH559/Xtx2221VwvOoqvDyyy8LQNx3333mY9KhXyLEyftdbty4Udx5552ifv36ombNmuL555+/iCOTnAipcRWR+iY5EdVJ36r9FnBGRgajR49m/fr1qKpKbm4uSUlJ3HvvvSQmJpq5ANWJlStXMmLECEJCQujRowdvvfUWAGPHjuWnn35i8uTJhIaGMn78eFRVZenSpZU7YMkFRdM0LBbLMY+f6N7Izs6moKCAnJwcOnXqdNJjJRceqXEVkfomKU911rdqbwT9119/UVhYyBtvvMGBAweYN28ewcHBPPnkk8ybN++S/KWeC0VFRYwcOZJPPvmE8PBw8/H8/Hw+++wz3njjDa699lo6dOjA559/zrJly/jzzz8rccSSC0l5cZw0aRITJkzgySefZPny5Se8N6Kjo2nQoMElL46XC1LjjiD1TVKe6q5v1T4AXLFiBaqq0q5dOwC6devGxIkTqVGjBqNHjzb7U1YXxo0bx4ABAyo48QPSob+a4hPH/v3787///Y/s7GwyMzPp1q0bCxYsOK1zXKrieLkgNe4IUt8k5anu+latA8CsrCw2bdpEvXr1aNq0qfl4REQE7733ntleBo40Tffh9XrRdf2ij/lCMnXqVNasWcPLL798zHMZGRnY7fYK3lwAsbGxZGRkXKQRSiqD1157jX379vHLL7/w1VdfERUVRUhICMHBwZU9NMkpkBp3BKlvkuNRnfWtWgeAq1atIisry/SX0nXdFECv10twcDDbt28HMCvmMjMzAaP/n6pePh/fvn37uO+++/j666/x8/Or7OFIqhC7d+8mOTmZyMhInnnmGT777DPmzJlDp06d2LJlS7VaQbrUkBpnIPVNciKqs75dHnf3WfLnn3+iqipXXXUVYAigTxz//vtvbDYbNpsNML4kzzzzDEOHDiU+Pp5Ro0axcePGY86padoxjaQvBVavXk1WVhbt27fHarVitVpZvHgxkyZNwmq1Ehsbi9vtJi8vr8LrMjMzqVGjRuUMWnLeOd6KT2BgIF6vl5dffpl3332X7777jiuuuAJd1/n111+ZOnUqJSUllTBayamQGmcg9U0CUt+OptoGgDk5OaSmplKnTh1atGgBGOLo+4L8/vvvlJaW0qdPHwDGjBnDpk2bePjhh5kyZQr5+fk888wzFBYWAke+WBaLxcwJ0DTtuF+4qiie1113HRs2bGDdunXmT8eOHRk5cqT5/z6Hfh/Sof/yQtM0c8Xn119/NVeGmjdvzldffcUrr7zC5MmT6dGjB2AEDJ9++inR0dEEBARU2rglx0dq3BGkvkmkvh2Hi+k5U5WYPXu2aNu2rXjvvfeOeW7fvn2iUaNG4tprrxVCCDF58mTh7+8vXnzxRVFaWmoeV6tWLfHZZ58JIYT4448/xODBg8UXX3whdu/efdxrer1ekZube97fy4Xi6quvruCTddddd4mEhASxYMECsWrVKpGYmCgSExMrb4CXGe+++66oU6eOcDgconPnzmLFihUX7drlva/uvPNO0bx5czFt2jTh9XrNxwIDA8W7774r5s2bJ+bMmSMaNWokbrrppos2RsmZITXu5Eh9u/hUlsZJfTs+1ToArF27tvD39xdjx44VP/30k/jzzz/FG2+8Ibp16yZq1aolfv31V6FpmrjxxhtFw4YNRWJioggKCjJFtWHDhuLDDz8UQgjx5Zdfiri4ONGxY0eRlJQkLBaLGD9+vMjLyzO/fJs3bxaJiYni7bffFkIc+VJmZGSI9evXV84HcRKOFkifUWp4eLgICAgQQ4YMEenp6ZU3wMuIqVOnCrvdLv773/+KTZs2iTvuuEOEhYWJzMzMizqOp59+WtSuXVusWbNGFBcXV3huzJgxolOnTsJqtYqrr75ajBkzxnzuZOapkspBatzJkfp2cakKGif1rSLVNgD08fPPP4thw4aJ2rVri86dO4uOHTuKvn37iuXLlwshhNA0TbRv3148++yzQgghtm7dKt544w3RtWtXkZCQID7++GOh67q46667hJ+fn5g0aZLIysoSc+bMEfHx8WL27NlCCCEWL14s7r77btG5c2fx119/VRjDAw88IKKiokRJScnFffNVgGeeeUYAFX6aNGliPl9d3Pk7d+4sxo0bZ/5b0zQRFxcnXn755YtyfV3XRWFhobjyyiuPWTFyu93m/2dnZ4uNGzdWEO3LVRwvF6TGVS5S4wwqU+Okvh2fahsA+pZ+y7N9+3Zx4MCBYx6/7rrrxLBhw44Rr/3794uSkhKxdetW0aVLlwozhtLSUpGcnCyGDBkihBBi7ty5IiwsTCiKIjp27Cjeffdd4XK5hBBCtG3bVjz88MNCCOOm0DTtvL3Pqs4zzzwjWrRoIdLT082f7Oxs8/m77rpL1K5dW8yfP1+sWrVKdO3aVVxxxRWVOOLzj8vlEhaLRXz//fcVHh81apQYPHjwRRtHZmamiImJETNmzBBCVLxHCgoKRGpq6jHfzctZHC91pMZVDaTGVQ2Nk/p2LNW2CMRnAKnrOl6vF4CGDRsSFxd3zLEvvvgi27dv57///S/5+fkUFxezf/9+4uPj8ff3Z9WqVezbt48bbrgBAJfLhZ+fH0FBQRQXFwNQu3ZtOnTowJgxYxgyZAhff/01W7ZsYcuWLfz9998MGTIEAFVVLxvrhdPFarVSo0YN8ycqKgqoPu78hw4dQtM0YmNjKzx+IT3IxHGS9GNiYmjQoAGTJ082HfI1TQOMitHJkydz6NChCq+5lE1QL3ekxlUdpMZdXI2T+nZ6VK+78DioqorVaj3pMR07dmTcuHG8+uqr1KtXj+TkZNM80uVysWLFCnJzc83qIbvdDsCSJUu44oorAKPirrCwkOTkZJ544gmWLVtG69atmTt3LkFBQRw4cIBhw4bx1ltvUVRUdGHfdBVj+/btxMXFUb9+fUaOHElaWhog3fkvFLqum8KWnp5OVlaW+dyYMWPYu3cvDz74IGAEEQUFBTzxxBPs2rWLmJiYShmz5OyRGlf5SI27eEh9O32qfQB4OlgsFvOL8/vvvzN06FD69+9P7dq12b59O1u2bEFVVb755hvAmH38+OOP7Nu3j+TkZMC40cPCwujSpQtwxFIhJSWFoqIi1q5dS/fu3XnzzTd58MEHzRn7yVi/fj3jx483Z+CXIl26dGHy5Mn88ssvfPDBB+zevZsrr7ySwsLCauPOHxUVhcViMQ14fVwoDzLf6svrr7/OoEGDaNGiBY899hhbt25l5MiR3HTTTSxYsIAGDRrQu3dvunXrhsfjYdq0aUDVs/iQnDtS4y4cUuMursZJfTt9Tj4tlADGF0LXdSwWCy1atDA9tcAQqMzMTMaOHcsPP/xAaWkpmzZtYvr06dx66620adOG1NRUdu3aRdu2bQkPD0fXdVRVZefOnSxdupQvv/yS4cOH43A4qFmzJmPHjmXcuHG0bt36hGOaN28ezzzzDF27diUwMPBifAwXhH79+pn/37p1a7p06UKdOnX47rvv8Pf3r8SRXTzsdjsdOnRg/vz55h9TXdeZP38+48ePP2/XEeWalv/444+8+uqrPP/88+Tm5vLxxx+zY8cOnnzySR555BF69+7Nt99+i67rDBw4kHvvvdccV3XbvqsOSI27cEiNuzgaJ/XtLKis5MNLFV3XzeTR0tJS8eijj4qOHTuKoqIi8eabb4oGDRqIjh07io8//thM9E1JSRGtWrUyk099VUevvvqqqF27dgXfrI0bNwpVVcX+/fuPe20hhFi9erXo0qWLeOKJJyo8p2naZZG02rFjR/HYY4+J+fPnC+AYX7GEhATxxhtvVM7gLhBTp04VDodDTJ48WaSmpooxY8aIsLCwC1INuGnTJvH000+L999/33xsyZIlom3btiIpKUn88ccfx31ddUrcr85IjbvwSI27cBon9e30kQHgObB+/XrRsWNHMXbs2AqPFxUVVfj3unXrRO3atcWCBQsqPF7+tT5Re/HFF0WDBg1Efn7+Ca87fPhwMXToUHHo0KETHuPxeC5JoSwsLBTh4eHi7bffFnl5ecJms4np06ebz2/ZskUApoXF5cQ777wjEhIShN1uF507dxZ//vnneT2/ruti586dps/Z888/X+H5ZcuWifbt24uhQ4eKH3/88bxeW3JpIjXu/CM17sJonNS3M0cGgOdAenq6eOihh8S8efOEEMZs2SdI5YWpsLBQ3HrrrcJms4krr7xSZGVliT179gg/Pz8xf/78Cse3atVK3HPPPcdYOPj+/fPPP4t69eqJlJQU8zmPxyMmTZokPvnkk2PMLX1UVaF88MEHxaJFi8Tu3bvF0qVLRc+ePUVUVJTIysoSQkh3/gvBd999J2rUqCH69esnNmzYUOG5lStXijp16ogJEyZU2e+M5OIhNe7ckRp3cZH6dvrIAPAikpWVJb777jtRUlIi3n77baEoisjJyTGfT0tLE6qqil9//fWY1/rEcciQIaJv374VHOp37dol+vTpI+Lj48WLL74o6tSpIx599NEK5/bhW+b2/XfOnDmVas76j3/8Q9SsWVPY7XYRHx8v/vGPf4gdO3aYz0t3/gvD9OnTRa1atcSYMWPExo0bKzy3ZcuWamnYKzl3pMYdi9S4i4/Ut9NDBoAXgeMZnxYXF4tly5YJIY7MXJ977jlRq1atk7bGiY6OFpMmTapwvjlz5oiYmBjRs2dPMWvWLPHdd9+J+vXriw8//FB4vV4xZcqUE24ntGnTRvzwww/n+hYlVRDf92rVqlXi66+/Fh988IHYs2eP+d2ZPn26qF27trj11luPmSkLUT1zYiRnh9Q4ycVG6tu5I6uALwLHqyoKCAggMTEROGI2eejQIQYOHEhERESFY0VZddOaNWuIiYmhbt265jl1XWflypU4HA5+/PFH/Pz8APjkk0948cUXWbVqFSUlJcyePZsBAwbw7rvvVjj/TTfdxPTp0xk0aNAFee+SysH3nfnhhx+49dZbad26NampqUyfPp2bbrqJm2++mWHDhmG327n//vs5fPgwEydOpGnTpuY5qlU1nOSckBonuZhIfTs/yACwCjFp0qTjPu4Tz9zcXKKioipYB6SlpbFmzRquuuoqUxidTicBAQH4+fnxyCOP0KhRI1atWkWPHj0YN24c3bp1w+v1YrVa2bx5s+mGLsqV0UsubRRF4c8//2TMmDG8+OKL3HnnnWzcuJG2bduSn59PSUkJY8aMYdCgQei6zuuvv37cDhESyflEapzkfCD17fwgQ+AqghDCFKkT0apVK7Zs2UL9+vXNx3z+W/379zcfW7VqFbm5uYwaNYpGjRoBUKNGDfz9/SkoKAAwOwOoqkpYWBhOp1MK42WAMNI60DSN3377jeHDh3PnnXeyd+9ekpOTGTlyJHFxcbz66qt8+umnFBcXk5SUxPz58wkJCTHNeyWS843UOMm5IvXt/CJXAKsIiqKYvTtPRGFhIUFBQRVmxytXrkRRFPr27Ws+9ueff+J2u7n22mvNxxYsWECdOnUqCGBubq75X9/MWnJp4etpKcrc6xVF4cCBA8THx3P99dfjdrtxOp2MGjWK7t27M3nyZNLT02nZsiVvvfUWAHfffXeFP5YSyYVAapzkTJH6dmGRn8YlRGxsLL179+b3338HjHyanTt3UrNmTTPnxel0smHDBmrWrEmnTp3M1y5YsIC4uLgKORBZWVls3ryZhg0bXtw3IjlvWCwWCgsLeeGFF1AUheXLl9O4cWPWr19PgwYNaNWqFRs2bCAnJ4f7778fgOzsbDp37kyPHj1MV34pjJKqgNQ4SXmkvl1Y5KdyCREUFETfvn1N0YuKiuLLL7/kyy+/NI9ZuXIlq1atolWrVthsNsDot7hlyxZatGhB3bp1zWM3b97Mjh07GDhw4EV9H5Lzy9q1a3n22WcZPnw4PXr04Mknn6RNmzbmaovT6aS4uJgdO3bg8Xj44YcfCA8P54033iAuLk5ui0iqDFLjJEcj9e0CUhmlx5Lzw/GMLDMyMsR//vOfCpYI//vf/0SnTp0qGKtmZmaK22+/XXTv3v2ijFVyYfB9Bz766COhqqpo167dMW2lcnJyxHXXXScaNWokmjVrJsLDw8Vff/1VCaOVSM4MqXHVG6lvFxaZA3gJc7yE5tjYWB544IEKj/3999/4+/tXaPD+3XffsWXLFu68884LPk7JhaF843KPx8ONN97ItGnTGD9+PC+99BIJCQkAhIeH88033zB79myKioq47rrraN68uZlfI5FUVaTGVV+kvl0EKjsClZxfdF0/7qy5vLN8enq6iI2NFa+//rooLCy8mMOTnCd8XRPS09PFtGnThMvlEkIIsXz5cuHn5ydGjBgh9u7dax5/tBGqNEGVXKpIjbv8kfp2cVCEKCuvkVQLtm3bxhNPPAHA9OnTK3k0krPBN7NNS0vjmmuu4brrrmP06NF07doVi8XCypUrueaaa+jfvz8PPvggGzZs4K677mLz5s00bty4socvkVxQpMZd2kh9u3jIALCaMWvWLDIyMrj++uuJiIiQxqiXKIcPH6Zjx4706tWLt99+27TNcLlcOBwO1q1bR//+/YmOjmbfvn188cUXshOCpFogNe7SR+rbxUEGgNUQKYiXFqtWrcLlctGtWzfzd/fRRx/xxRdfsGzZMgDWrVvH7NmzWbNmDXfeeSd9+vRh//797Nq1i5iYGJo2bVohp0YiuZyRGnfpIPWt8pBFINUQKYyXFvfffz8jRoygW7du5u8uIiKCAwcO8PPPP7N48WI2b97Mrl27aNq0Kf369SM1NZWmTZtSq1Yt8zxSHCXVBalxlw5S3yoPGQBKJFWcP/74A4DS0lI2bNhAx44dad68OZ07d+a2224jLi6OCRMm0LNnTzRNY/v27RQXF1fyqCUSieTUSH2rPGQAKJFUYTweDxaLBVVVeeCBB/joo4/49ddf6dmzJx9//DHp6ek0b97cPD4lJYWCgoIKrbQkEomkKiL1rXKROYASSRXiVLlL/fv3Z9WqVXzxxRf07NnT7ISwfft2Fi1axAMPPMB//vMfxowZc7GGLJFIJKeF1LeqhQwAJZIqQnlxXLp0KWvWrGH16tUkJibSqlUrrrjiCgAGDhzIn3/+yeTJk+nVqxdOp5PXX3+dRYsWMWrUKO64447KfBsSiURyDFLfqh4yAJRIqgDlxfHhhx/mzz//JDMzk4iICNatW0f9+vUZO3Ys99xzDwBDhgxh8eLFfP755yQlJXHgwAEKCgpo1qxZZb4NiUQiOQapb1WUi+c5LZFIjkf5rgajR48W9evXF7/99ps4cOCAEEKIX3/9VfTu3VvExsaKt956yzx25MiRwuFwiK+++uqij1kikUhOB6lvVRdZBCKRVDK+mfHYsWP57bff+OOPP6hTp475fK9evYiMjOTxxx/nk08+oUuXLnTt2pWvvvoKp9NJbm5uZQ1dIpFITorUt6qL3AKWSKoA06dPZ8SIEUycOJFHHnkEMJqhK4piCujChQvp06cPkyZN4q677qrM4UokEslpI/WtaiKdEyWSKkCDBg24/vrr+eWXX5g8eTJgGJsKIcyfHj160KlTJ/766y8AvF5vJY5YIpFITg+pb1UTGQBKJFWAdu3a8dRTTxEXF8cnn3zCZ599BhwRSUVRSE9Pp6CggE6dOgFgtcoMDolEUvWR+lY1kQGgRFJFaNmyJU888QQNGzbks88+46OPPgKOtDjasmULQUFBtGzZsjKHKZFIJGeM1LeqhwwAJZIqRPPmzXnyySdp2rQpkydP5t133wUgOzub2267jcTERK688spKHqVEIpGcOVLfqhayCEQiqYLs2LGDiRMnsnXrVvr06cPnn39O586d+eabb4BTO+pLJBJJVUXqW9VABoASSRVl9+7dTJw4kf/+978MGzaMqVOnAlIcJRLJpY/Ut8pHBoASSRVm7969/P777/zzn/8EpDhKJJLLB6lvlYsMACWSSwQpjhKJ5HJF6tvFRwaAEolEIpFIJNUMWQUskUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNUMGgBKJRCKRSCTVDBkASiQSiUQikVQzZAAokUgkEolEUs2QAaBEIpFIJBJJNeP/ARDjVKj1iJ/6AAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "design_phase = \"ExportSystemDesign\"\n", + "results = {\n", + " \"export_system_system_cost\": lambda run: run.design_results[\"export_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "## Run ORBIT for each hvac and hvdc export system types\n", + "\n", + "cost_hvac = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " \"export_system_design\": {\"cables\": \"XLPE_1000mm_220kV\"},\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.distance_to_landfall\": [i for i in range(0, 400, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_hvac.run()\n", + "\n", + "cost_hvdc = CostFunction(\n", + " config={\n", + " \"design_phases\": [design_phase],\n", + " \"export_system_design\": {\"cables\": \"HVDC_2000mm_320kV\"},\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.distance_to_landfall\": [i for i in range(0, 400, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_hvdc.run()\n", + "\n", + "cost_hvac.linear_2d()\n", + "cost_hvdc.linear_2d()\n", + "\n", + "## Plot the ORBIT data and curve fits\n", + "\n", + "fig = plt.figure()\n", + "\n", + "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", + "ax.set_title(\"HVAC\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Distance to Landfall (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_hvac.plot(ax, plot_data=True)\n", + "cost_hvac.plot(ax, plot_curves=[\"linear_2d\"])\n", + "\n", + "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", + "ax.set_title(\"HVDC\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Distance to Landfall (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_hvdc.plot(ax, plot_data=True)\n", + "cost_hvdc.plot(ax, plot_curves=[\"linear_2d\"])\n", + "\n", + "\n", + "multiline_comment = \"\\n# \".join([\n", + " \"The floating HVAC mooring system is \",\n", + " \"special because it's the only one that \",\n", + " \"is like it is.\"\n", + "])\n", + "cost_hvac.export(\"export_system.yaml\", \"floating_hvac\", comments=multiline_comment)\n", + "\n", + "singleline_comment = \"HVDC export system\"\n", + "cost_hvdc.export(\"export_system.yaml\", \"floating_hvdc\", comments=singleline_comment)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Offshore Floating Substation\n", + "\n", + "This component is not a function of a spatially varying parameter, but it is included to complete\n", + "the export of the capex breakdown components." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'oss_substructure': '0.0 * depth + 2005200.0'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4960b52c4ec14543a4d3f0cf4ba7b7aa", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cost_function = CostFunction(\n", + " config={\"design_phases\": [\"OffshoreFloatingSubstationDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results={\n", + " \"offshore_substation_substructure\": lambda run: run.design_results[\"offshore_substation_substructure\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "cost_function.run()\n", + "\n", + "cost_function.linear_1d()\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "ax.set_title(\"Offshore Floating Substation\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_1d\"])\n", + "ax.legend()\n", + "\n", + "cost_function.export(\"oss.yaml\", \"oss_substructure\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bos", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/nrwal.yaml b/examples/nrwal.yaml new file mode 100644 index 00000000..561dbfa7 --- /dev/null +++ b/examples/nrwal.yaml @@ -0,0 +1,60 @@ +# --- Minimum Required --- +site: + depth: 30 + distance: 100 + distance_to_landfall: 60 + mean_windspeed: 9 +turbine: 17MW_low_SP +plant: + layout: grid + num_turbines: 36 + row_spacing: 7 + substation_distance: 1 + turbine_spacing: 7 +# --- Additional Configs --- +OffshoreSubstationInstallation: + feeder: example_heavy_feeder + num_feeders: 1 +array_cable_install_vessel: example_cable_lay_vessel +array_system_design: + cables: + - XLPE_630mm_66kV +commissioning: 0.01 +decommissioning: 0.15 +export_cable_bury_vessel: example_cable_lay_vessel +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_1000mm_220kV + percent_added_length: 0.05 +landfall: + interconnection_distance: 3 + trench_length: 2 +oss_install_vessel: example_heavy_lift_vessel + +scour_protection_design: + cost_per_tonne: 40 + scour_protection_depth: 1 +spi_vessel: example_scour_protection_vessel +wtiv: example_wtiv +port: + monthly_rate: 2000000.0 + sub_assembly_lines: 1 + turbine_assembly_cranes: 1 +# --- Don't specify these here since they're set in the curve generator --- +# design_phases: +# - MonopileDesign +# - ScourProtectionDesign +# - ArraySystemDesign +# - ExportSystemDesign +# - OffshoreSubstationDesign +# install_phases: +# ArrayCableInstallation: 0 +# ExportCableInstallation: 0 +# MonopileInstallation: !!python/tuple +# - ScourProtectionInstallation +# - 0.5 +# OffshoreSubstationInstallation: 0 +# ScourProtectionInstallation: 0 +# TurbineInstallation: !!python/tuple +# - MonopileInstallation +# - 0.1