diff --git a/docs/sampling_algorithm copy.ipynb b/docs/sampling_algorithm copy.ipynb new file mode 100644 index 00000000..582b2245 --- /dev/null +++ b/docs/sampling_algorithm copy.ipynb @@ -0,0 +1,464 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Dict, List\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import schema\n", + "import math" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "signal_params = [\n", + " {\n", + " 'freq_hz': 0.15,\n", + " 'ampl': 0.837,\n", + " 'phase_rad': 0.0\n", + " },\n", + " {\n", + " 'freq_hz': 0.2,\n", + " 'ampl': 0.286,\n", + " 'phase_rad': 0.0\n", + " },\n", + " {\n", + " 'freq_hz': 0.12,\n", + " 'ampl': 0.227,\n", + " 'phase_rad': 0.0\n", + " },\n", + " {\n", + " 'freq_hz': 0.06,\n", + " 'ampl': 0.183,\n", + " 'phase_rad': 0.0\n", + " }\n", + "]\n", + "\n", + "display_freq_limit = (0.025, 1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Comparing tests and expected" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#This gives us a new sampling method which mimics the actual scheduling algorithm \n", + "#These are the intervals at which we will sample the given signals (signal_params)\n", + "\n", + "json_file_actual = open(\"../tests/no_check_outputs/actual_file_tests.log\")\n", + "\n", + "#how long does it run plus one period\n", + "maxVal = 0\n", + "\n", + "scheduleA = np.array([])\n", + "scheduleB = np.array([])\n", + "scheduleC = np.array([])\n", + "\n", + "for line in json_file_actual:\n", + " if(line.find(\"test\") != -1): #get the line we want to measure\n", + " startInd = int(line.find(\"[\"))+1\n", + " endInd = int(len(line)-2)\n", + " \n", + " values = line[startInd:endInd] #get the lists without the end brackets\n", + " tasks = values.split(',')\n", + " for task in tasks:\n", + " actual = task[task.find(\"\\\"\")+1:len(task)-2] #get rid of the quotation marks\n", + " times = actual.split('|')\n", + " label = times[0]\n", + " start = float(times[1])/1000\n", + " end = float(times[1])/1000\n", + " if label == 'A':\n", + " scheduleA = np.append(scheduleA, start)\n", + " elif label == 'B':\n", + " scheduleB = np.append(scheduleB, start)\n", + " elif label == 'C':\n", + " scheduleC = np.append(scheduleC, start)\n", + " else:\n", + " print(\"Error, No Acceptable Label.\\n\")\n", + " if maxVal < end:\n", + " maxVal = end\n", + " break\n", + "\n", + "# print(scheduleA)\n", + "# print(scheduleB)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Input Sampling Patterns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#temp \n", + "delay_injection = 10\n", + "delay_amplitude = 0.1\n", + "\n", + "sampling_freq_hz: float = 1000/25 #40 hz period, 25 ms period\n", + "\n", + "sampling_duration_s = 900\n", + "\n", + "sampling_int = 1.0 / sampling_freq_hz\n", + "\n", + "startTime = scheduleA[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Process Sampling Patterns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "#The following code processes the inputs and creates an ideal sampling pattern\n", + "#It also introduces various types of noise to compare the efficiency \n", + "#selects evenly spaced intervals when the samples are actually taken\n", + "\n", + "\n", + "#Reference sampling number must match the number of given samples in the schedule being compared\n", + "#Need to figure out how to compare multiple \n", + "reference_sampling = np.arange(startTime, sampling_duration_s + sampling_int, sampling_int, dtype=np.float64)\n", + "\n", + "\n", + "#total number of samples taken\n", + "n_samples = len(scheduleA)\n", + "\n", + "print(len(reference_sampling))\n", + "print(len(scheduleA))\n", + "\n", + "temp_interval = len(np.heaviside(np.arange(-1 * delay_injection, sampling_duration_s - delay_injection + sampling_int, sampling_int), 1) * delay_amplitude)\n", + "\n", + "if len(scheduleA) > temp_interval:\n", + " scheduleA = scheduleA[:temp_interval]\n", + "elif temp_interval > len(scheduleA):\n", + " interval_priority_sampling = (np.heaviside(np.arange(-1 * delay_injection, sampling_duration_s - delay_injection + sampling_int, sampling_int), 1) * delay_amplitude)\n", + " interval_priority_sampling = interval_priority_sampling[:len(scheduleA)] + scheduleA\n", + "else:\n", + " interval_priority_sampling = scheduleA + np.heaviside(np.arange(-1 * delay_injection, sampling_duration_s - delay_injection + sampling_int, sampling_int), 1) * delay_amplitude\n", + "\n", + "# increment_priority_sampling = reference_sampling.copy()\n", + "# increment_priority_sampling[delay_injection] += delay_amplitude\n", + "\n", + "gaussian_component_noise = scheduleA + np.random.normal(0, 0.0088,n_samples)\n", + "\n", + "combined_noise = scheduleA + gaussian_component_noise - scheduleA + interval_priority_sampling\n", + "\n", + "sampling_behaviors = {\n", + " 'Ideal_Timing': reference_sampling,\n", + " # 'Interval': interval_priority_sampling,\n", + " 'Actual_Timing': scheduleA,\n", + " 'Gaussian Noise': gaussian_component_noise,\n", + " 'Everything': combined_noise\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class SigGen:\n", + " #Validates the data -> are the numbers entered actualy floats, etc.\n", + " def __init__(self, params: List[Dict[str, float]]):\n", + " signal_params_schema = schema.Schema(\n", + " [\n", + " {\n", + " 'freq_hz': schema.Or(int, float),\n", + " 'ampl': schema.Or(int, float),\n", + " 'phase_rad': schema.Or(int, float)\n", + " }\n", + " ]\n", + " )\n", + " signal_params_schema.validate(params)\n", + " self._params = params\n", + " \n", + " def add_signal(self, freq_hz: float, ampl: float, phase_rad: float):\n", + " print(\"Signal added...\\n\")\n", + " self._params.append({\n", + " 'freq_hz': freq_hz,\n", + " 'ampl': ampl,\n", + " 'phase_rad': phase_rad\n", + " })\n", + " \n", + "\n", + " #Generate the height of each signal at a given time?\n", + " def generate(self, t: np.ndarray) -> np.ndarray:\n", + " output = np.zeros(t.shape, t.dtype)\n", + " for component in signal_params:\n", + " output += component['ampl'] * np.sin(t * 2 * np.pi * component['freq_hz'] + component['phase_rad'])\n", + " return output\n", + " \n", + " def __call__(self, t: np.ndarray) -> np.ndarray:\n", + " return self.generate(t)\n", + "\n", + "sig_gen = SigGen(signal_params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "reference_signal = sig_gen(reference_sampling)\n", + "reference_spectrum = np.fft.rfft(reference_signal)\n", + "\n", + "signals = {label:sig_gen(sampling_sequence)\n", + " for label, sampling_sequence in sampling_behaviors.items()}\n", + "spectra = {label:np.fft.rfft(signal) for label, signal in signals.items()}\n", + "fft_freq = {label:np.fft.rfftfreq(len(timing), sampling_int)\n", + " for label, timing in sampling_behaviors.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "\n", + "\n", + "for label, sequence in sampling_behaviors.items():\n", + " ax.scatter(np.arange(len(sequence)), sequence - reference_sampling[:len(sequence)], label=label)\n", + "\n", + "ax.legend()\n", + "ax.set_ylabel('Sampling Error')\n", + "ax.set_xlabel('Sample Index')\n", + "ax.grid()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "\n", + "ax.plot(reference_sampling, reference_signal)\n", + "ax.grid()\n", + "\n", + "ax.set_ylabel('Signal Amplitude')\n", + "ax.set_xlabel('Time (s)')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "\n", + "for label, signal in signals.items():\n", + " ax.plot(np.arange(len(signal)), signal, label=label)\n", + "\n", + "ax.grid()\n", + "ax.set_ylabel('Signal Amplitude')\n", + "ax.set_xlabel('Sample Index')\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#Generate amplitude vs. time index (Instead of amplitude vs. sample)\n", + "\n", + "# fig = plt.figure()\n", + "# fig.add_subplot(111)\n", + "\n", + "# for label, signal in signals.items():\n", + "# ax.plot(scheduleA, signal[:len(scheduleA)],label=label)\n", + "\n", + "\n", + "# ax.grid()\n", + "# ax.set_ylabel('Signal Amplitude (m)')\n", + "# ax.set_xlabel('Time Sample Start (s)')\n", + "# ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "ax = fig.add_subplot(111)\n", + "\n", + "for label, signal in signals.items():\n", + " ax.plot(np.arange(len(signal)), signal - reference_signal[:len(signal)], label=label)\n", + "\n", + "ax.grid()\n", + "ax.set_ylabel('Signal Difference')\n", + "ax.set_xlabel('Sample Index')\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "ax1 = fig.add_subplot(211)\n", + "ax2 = fig.add_subplot(212, sharex=ax1)\n", + "\n", + "labels = []\n", + "\n", + "for label in spectra:\n", + " labels.append(label)\n", + " ax1.plot(fft_freq[label], 2 / n_samples * np.abs(spectra[label]), label=label)\n", + " ax2.plot(fft_freq[label], np.angle(spectra[label]))\n", + "\n", + "\n", + "print(labels)\n", + "\n", + "ax1.grid()\n", + "ax2.grid()\n", + "ax1.set_ylabel('Amplitude')\n", + "ax2.set_ylabel('Phase (rad)')\n", + "ax2.set_xlabel('Frequency (Hz)')\n", + "ax1.legend()\n", + "ax1.semilogy()\n", + "ax1.set_ylim(1e-6)\n", + "ax1.set_xlim(display_freq_limit[0], display_freq_limit[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure()\n", + "ax1 = fig.add_subplot(211)\n", + "ax2 = fig.add_subplot(212, sharex=ax1)\n", + "\n", + "\n", + "rms_sum = {}\n", + "spectra_sum = 0\n", + "\n", + "for label in spectra:\n", + " #plot fft vs. amplitude error from original \n", + " ax1.plot(fft_freq[label], 2 / n_samples * (np.abs(spectra[label]) / np.abs(reference_spectrum[:len(spectra[label])])), label=label)\n", + " ax2.plot(fft_freq[label], np.angle(spectra[label]) - np.angle(reference_spectrum[:len(spectra[label])]))\n", + "\n", + " #deal with RMS at the same time:\n", + " #square each value then sum them for RMS for each label\n", + " error_array = (2 / n_samples * np.abs(spectra[label])**2)\n", + " for num in error_array:\n", + " spectra_sum += num\n", + " rms_sum[label] = spectra_sum\n", + " # print(rms_sum)\n", + "\n", + "ax1.grid()\n", + "ax2.grid()\n", + "ax1.legend(loc = 'upper right')\n", + "ax1.set_ylabel('Amplitude Error')\n", + "ax2.set_ylabel('Phase Difference (rad)')\n", + "ax2.set_xlabel('Frequency (Hz)')\n", + "ax1.semilogy()\n", + "ax1.set_xlim(display_freq_limit[0], display_freq_limit[1])\n", + "ax1.set_ylim(top=1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#RMS values\n", + "#Right now only works if theres only 2 being compared\n", + "fig = plt.figure()\n", + "ax1 = fig.add_subplot(111)\n", + "ax1.grid()\n", + "\n", + "rms = {}\n", + "\n", + "for label in rms_sum:\n", + " rms[label] = math.sqrt(1/n_samples * rms_sum[label])\n", + "\n", + "colors = ['tab:red', 'tab:blue', 'tab:green', 'tab:orange', 'tab:purple', 'tab:pink', 'tab:yellow']\n", + "\n", + "ax1.bar(list(rms.keys()), list(rms.values()), width=0.8, color=colors[:len(spectra)])\n", + "\n", + "ax1.set_ylabel('RMS Value')\n", + "ax1.set_title('Root Mean Square Error by Origin')\n", + "\n", + "\n", + "print(rms)\n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/sampling_algorithm.ipynb b/docs/sampling_algorithm.ipynb deleted file mode 100644 index 7eb7e119..00000000 --- a/docs/sampling_algorithm.ipynb +++ /dev/null @@ -1,270 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "delay_injection = 10\n", - "delay_amplitude = 0.1\n", - "\n", - "proper_sampling = np.arange(0, 100, 1, dtype=np.float64)\n", - "interval_priority_sampling = proper_sampling + np.heaviside(np.arange(-1 * delay_injection, 100 - delay_injection, 1), 1) * delay_amplitude\n", - "increment_priority_sampling = proper_sampling.copy()\n", - "increment_priority_sampling[delay_injection] += delay_amplitude" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.scatter(np.arange(len(proper_sampling)), proper_sampling - proper_sampling, label='Original')\n", - "ax.scatter(np.arange(len(interval_priority_sampling)), interval_priority_sampling - proper_sampling, label='Interval')\n", - "ax.scatter(np.arange(len(increment_priority_sampling)), increment_priority_sampling - proper_sampling, label='Increment')\n", - "ax.legend()\n", - "ax.set_ylabel('Sampling Error')\n", - "ax.set_xlabel('Sample Index')\n", - "ax.grid()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def signal(x):\n", - " return np.sin(x * 2 * np.pi / 15)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD6gklEQVR4nOydd5gkVbn/P1Wd4/Tk2ZxY4rIsgiBGQGCXNYFeL3hRhKvyE0XEFRG8ZOSikpSrgBcliCJcw+Wq4MK6sCK4AhKUsITNYXLonLvq90dV11SzM7MTuis0/X2efXamu/qcM6frnHrP+37f7yvIsizTQAMNNNBAAw000MCYEM0eQAMNNNBAAw000ICV0TCWGmiggQYaaKCBBiZAw1hqoIEGGmiggQYamAANY6mBBhpooIEGGmhgAjSMpQYaaKCBBhpooIEJ0DCWGmiggQYaaKCBBiZAw1hqoIEGGmiggQYamABOswdQD5Akie7ubkKhEIIgmD2cBhpooIEGGmhgEpBlmUQiwezZsxHF8f1HDWOpCuju7mbevHlmD6OBBhpooIEGGpgGdu3axdy5c8d9v2EsVQGhUAhQJjscDlet3UKhwKOPPspJJ52Ey+WqWrsN7I3GXBuHxlwbh8ZcG4vGfBuHas11PB5n3rx52nN8PDSMpSqgHHoLh8NVN5b8fj/hcLix8GqMxlwbh8ZcG4fGXBuLxnwbh2rP9b4oNA2CdwMNNNBAAw000MAEaBhLDTTQQAMNNNBAAxOgYSw10EADDTTQQAMNTICGsdRAAw000EADDTQwARrGUgMNNNBAAw000MAEaBhLDTTQQAMNNNBAAxOgYSw10EADDTTQQAMNTICGsdRAAw000EADDTQwARrGUgMNNNBAAw000MAEsJWx9MQTT/CRj3yE2bNnIwgCDz744D4/s2HDBt7xjnfg8XjYb7/9uPvuu/e65kc/+hELFy7E6/Vy9NFH88wzz1R/8A000EADDTTQgC1hK2MplUpx2GGH8aMf/WhS12/bto0PfehDHHfccbz44otccMEFfP7zn+eRRx7RrnnggQdYs2YNV1xxBc8//zyHHXYYK1eupL+/v1Z/RgMNNNBAAw00YCPYqjbcySefzMknnzzp62+//XYWLVrEjTfeCMBBBx3Ek08+yc0338zKlSsBuOmmm/jCF77A2WefrX3moYce4s477+Tiiy+u/h/RQAMNNNBAAw3YCrYylqaKjRs3csIJJ1S8tnLlSi644AIA8vk8zz33HJdccon2viiKnHDCCWzcuHHcdnO5HLlcTvs9Ho8DSmG/QqFQtfGX26pGm/HkMOFgy4zbqRfEs2mCbi+iqDhXqznXdkQql8PlcOB21n5LsMtcx7Npwl6/2cOYEaq6h9TBfFQTY60Zu9zbtYAkSSTzWcPukWrN9WQ/X9fGUm9vL52dnRWvdXZ2Eo/HyWQyjIyMUCqVxrzmtddeG7fd6667jquuumqv1x999FH8/urfKOvWrZvR5x/f/SMeC3Rzeu4DHNJ1UpVGZV/8Lb6TPxTvoj1/GF/tOqXivZnOtR2RKOa5cfh2JCHHN5svIOA0plq6lef6h71r6fU8xcnCv/OeyCKzhzNjzHSu/xzdyjrpHrryR3Ne1+oqjcq+GClk+f7IrQBc0no+Xkflo9TK93at8IPe3zPgeYZTnP+PI0NzDet3pnOdTqcndV1dG0u1wiWXXMKaNWu03+PxOPPmzeOkk04iHA5XrZ9CocC6des48cQTcbmm9wD70zP/w+Mj3ciCwB7hZb6x+vtVG58dkcrluPH+D4KrQNr1PKtW3Y4oilWZa7vinAfOo+hWOHrFuR5Wv2NVTfuz+lz/5oV19EafBGCQv7N69ZdNHtH0UY25jmWSXP+rb4OzRNb5DKtX/7DKo7QfPvvLz1NyDwPgXtzG6kPeDVj/3q4VfvbMgwxEnwagnxdZvfqcmvdZrbkuR4b2hbo2lrq6uujr66t4ra+vj3A4jM/nw+Fw4HA4xrymq6tr3HY9Hg8ej2ev110uV00WyHTbzedz/Pcr30XyCADsFIbfVgt4LNz4i08x4lJOEimHxD/7d/LOeUu192v1HVoVf974c14oPgWCco+8vP1xXEd/xJC+rTjX6cQA9/7jYnArv/fnN1tujNPBtOdalrn+158h5swCEHUW2RLt48B24zwHVsPDG37My9Jz2pp5ftufOHXFByquseK9XSvEhnbxwKarQf1z+zKbDP3bZzrXk/2srbLhpopjjjmG9evXV7y2bt06jjnmGADcbjdHHHFExTWSJLF+/XrtGjvjxl99kc0eGa8kA7DLJTMU7TV5VCZBlnn1/9bwR3kTAD5JAuDxTX8yc1SmorhlAz/+57cpCYI2HzsSr5g8KhORGuKnP1vJTreszUe3M0W6kNvHB+sUsswLv/4ij4rbgdE1s+7VP5s4KHORe+2P/PSNm5F1a2bbyD9MHpWJSPRxx/0fosc1en90O+IUSyWTB1Z92MpYSiaTvPjii7z44ouAIg3w4osvsnPnTkAJj5155pna9V/84hfZunUrF110Ea+99hq33nor//M//8PXvvY17Zo1a9Zwxx13cM8997Bp0ybOPfdcUqmUlh1nV2za+hz/l1f0oj7ufietRYmSIPDECw+aOzAzIMtIa7/FLd2/IyeKLCi0cGLGAcAbvX81eXAmYfN6fvN/n+UlrwuPBJ93LAOgR3ibSmYk+9lx1yru9SuG0Wn+4wmVJAoirN/8NnwYShKlP6zh+8OPURQElhQ6+UBGeevV3U+YOzaz8NrD/PKPX+QNjwt/SeBsFI90t9Rt8sBMQmwPb9y1kvsCipH02eAH8UgSGYfMX3eOz/m1K2xlLP3973/n8MMP5/DDDwcUQ+fwww/n8ssvB6Cnp0cznAAWLVrEQw89xLp16zjssMO48cYb+clPfqLJBgCcdtpp3HDDDVx++eWsWLGCF198kbVr1+5F+rYbblj3ZVKiyH45ga9/8nYWFBXi+Uu7/2LyyEzA49fy6Mt385TfhygLfPODt7HEo4QR9uS3mTw4E7DrGQYf+Dd+EAkCcEzrWZyy7FQEWWbEWWTL0NvM+1jIIN29musdI2REkUhxPl/7+PUcks8D8LfNj5k8QBOw7jJ+9/oDPO/14pAcXHbyj1niUvbEPZk3TB6cCdj2BD2/+Sy3qmvm2NnnsnJ/hds36MzRl4yZOTrjkUsg3X0y33OnKAgCbaWlnPvhazgor2SWPfHGBnPHVwPYirN07LHHIsvyuO+Ppc597LHH8sILL0zY7nnnncd555030+FZBvc+/B2e8aYQZZlzD/0WbreHeZ75PM8b7MxsNXt4hiP63F18t6UZgMPC/8r7Fh2Mv+twGNxFnyNOtpDHgWDyKA3Ei/dxQyRAwiHiLs7l+pO/gjexh4XPFdnmdrH29Y18+d2nmj1K47DjrzyW3s2fO9tBFrn6uO8gurwsLgX4GyW2DT5n9giNhSwz9Pxd3NgZAeDo1k9zxJwlpFuXQ2I9veIwkiRpshtvC7zwC77THCYjivhKS7j2xHNwDr5G12s/oNfp5I+vP8NZR5xo9iiNw9YNPFQY4OlIG0hOvnPCdxF9TSwpunkReLPvb4B9EyPGwtvobn97IJGK8rPunwNwfHE2Jx3zKQAOnvUuAHaKCdPGZgqyMW7zlBh0OnAW2/jRh74OwGH7H09AkiiIMhu2vWzyII3F4z3/4KFgAGS47Jgr8LrcEFnAQXmFZ/DPnW+vMEus7zWua1WM6eWhUzlu8aEALPUvBKCntHO8j9Ynkv38IOQh5nDgKs7m5pO/AsAR+x+LW5LJOCT+tuvt5V36Y99LPBbwI8gC177vSpwOB7TtzyE5xZPy3Pa3F49rsPcVblAPoEc1n87R85WQ5H6e2QB016HHvmEs1Rke+/uv6XUJhEsSF596l/b6+w77BAA9LoFte+ovnjwuhrfxaEAJQf77wRcQ8vgAcM4+jGU5JczyxJa3F2/psYKS/XmgsJxTDlaMaESRJWIrAHuSby+S9192PEO/00mw6ORHq7+hvX7EvKMBGHKmGUhOLr24HiANbdbWzPkrvoHfpWT++ucewYFqaHL9lr+ZNj4zsEEaAmCZ8yhOXLpCedHhYomsSMXsir29eG0bdv6dYYeDcNHDLSdfoL1+WNcRAAw4Y6Ry9ZUY0TCW6gw7+5UH3Zyii87WOdrr87oWM6eghDD/8o/fmjI2MxDr3cSgUyFzf+ygd4++EWhj/4Ly+pb+t9HGX8wxICoPvAPbj6x46+DmAwHoF/uR1MyWtwN6kornqF1uJeILaK8vWvIeOotFZAHWvvl3s4ZnOLr3/JOUGmI75WBdVnDTXA5S95DXup8yY2jmIBuj16msh0O6KrOkDwgtAaBffnuRvHszyt/bRQcBnYzOIfu9j3CpREmAP2150aTR1QYNY6nO0Kdu/C2E9npvvtQEwGt9zxo6JjPx5u4XAfBIAnPDrRXvLfEoxmRfof5cxuNiZAd71PIMizoOrnjr8EXvxSnLZBwlnt29xYzRmYLBwiAATa63aKt1LtO8j3/bMX75o3rDlp6XAAgWnRXGI4LAYmcHAL3Zt1EYbnibtmaWdh5Q8daRC9+NIMsknHleG9htxuhMwVBpBIAmz5yK18VZh3Fo2WO//WnDx1VLNIylOsNQQUn9bnW17fXeAr8SV96V32XomMzErpE3AWgq+fcipB4+6x0ADDvjjKRTho/NDBQH36Rb3fgP7VpS8V5g3miY5U9b3iYGtSQxhJIT3xqqnA/8LSwtKeqUO0eeN3pkpqE7phwewnJwr/cObVP4XMOOkbeN/lSq/zX6HYoX+rCuxRXvtcw/iiVqbbG3jfexmGNAUP7m9qb9K98Lz+bAgpIss23gGaNHVlM0jKU6wzBJADqDC/Z6b/n89wOw3ZVBqkPRsLHQl+4BICTsXUR44cJjaFfDLI9ueXs8DHfs/id5UUCU4dDO+ZVvth+kEVZf7nmbhCYT3XQ7lW1wbtvBe719gEryHpTePiTv/pxy4Ao72vd676DF7yVUkiiKMus3/9PooZmCzbv/gSwIuCSBpa1v8T52jXofX9hdX56UcTGygz0uxXhc+BbvNIKgkbwHCvWVed0wluoMQyofZX7bQXu99/53nIJTlok6RF588+1Bah4cx10MIM5arm10f9319jCWtg28CkCo5Fay4PRwedlPUEK1felXjR6aORjeyh6X4mk7qHPJXm8fPudIBFkm6czy5mCP0aMzHrLMkKSQ2SO++Xu97Zy1nGV5xaP05x1vD0/KziEl5Bgu+faWS/A2sVRSkka6E28Pkrc0tFkLSy7r2LvI9GFdig5i1JmoK/2phrFUR0hnUww4FRfoAQuO3Ov9pmALC/LKV/70q38wdGymIJ9iQFQ8JW1vdRcDtCzi4LxCWN0+8vbQ0ulJKiHYkNw05vuHRBSS97BjgGwhb9i4zMJI76sMqyGWw2ct3uv91vnvZFGhCMDaN+srrDAmMiP0OpU10akS/ivQfiCH5JT5eLP/7WEs9aUVMnNIaB7z/TLJe1joeVskRuzufomMKCLIsGL23sbSvIXvYlaxCAL88fX6Cec3jKU6wqtbnkUSBNySzNL5y8e8Zp6gkJw3D79o4MhMwsh27QS0sG0MY0l0sJ9HcasPl94eJO/BvEJmDjvHLhR90IJjCEoSJVHisa0vGTk0U7C5W/kbvSUHs8N7h2rpOpRlagr0s3smFretCwxv1dbMfm377f2+081+DmUPGcy/PUjeZe902L23dxpg+fyjcUsyeUeRv+2u/znZ3qd4nQMllybFUoGuQ0c99rvrx2PfMJbqCG/sVrwjHSVwOseupLwofAgAu6Q+w8ZlFqTBzexWQyzLOvf2GgAc1rUCgJQzxUA+bdTQzEGpwADK39gc3PtECOCcfSiHqBvdn7fXz0Y3HnaPKFl/ISkw9gWRBRykOCfZE3/RmEGZiIIuAeCwWXuHJQGWtyt1BBPOaP3rT+VT9Je90+ExDlyAb/YKLTHisW31b1Dvie8AIKRqTO2Ftv017+OOOkqMaBhLdYQ9w8qpprXkGfeady49CYBtriLZXH0bB309r2h6MWOFWADa5x3JQrWe0T9TewwbmymI7aJb1Zya3TJGiAWgc9ST8upA/W/8Aznl0BAS984eBUAU2d+vcHdG2FX3YZZte/5BUVASAA7pmDfmNfPmH/X20Z8a2c4edc0saF069jVdh2rp8i8N1D9vaTA/AEDIOU79VIeL/d3Ke/XksW8YS3WEgbSi89Eijs1HATh62Ur8kkRWFNj4zz8aNTRTsLVfcRf7i65KvRg9upazTD0VbsnXuU6Kjsx8YPvYniWC7RygElYHc5uMGpk5kGUGVTJzk3dvMnMZh84+ApcsU3Dk615/auegcuAKlry4neOUDtUZB0/trnODWheWPLhj4djXROZzUFF5lPan67x0UqnAgKBIbUT84+whwPKuFYiyTNaZrhv9qYaxVEcYLg0D0OoZx+IH3G4PCwtKFtTzW/5kyLjMQk9cSfcOynsLdGroOEiLr4/I9XMKGguZgTfoG0cvRo9lzYrwXsoxxFC6jmsJJvvoUaaD9sgB417mm30YB6r3yLqt9UNYHQu9qnc1KI9NZgZUsU7F+7h5uL7lAwZ7XyFWTgCYPXZYEkHggJBiOCTEXvL1LMsS3al5p2e1jB2WBGiacziL60x/qmEs1RGGUYQVZzWN/yAEmOdQyL1b4/XtOegvqO5ix/jGI+4A+zuVEEzGuaeuwyxb9ryELAg4x9KL0WHe3CNU/SmZtW/WcZbg8FaN07Zf2wRrputQDlG9jy/01neYZbBYJjPPHv8ifwsHqBUCosX6JjRv6VHKR3lLTjqD43vsl85+B6GShCRKvJyuYz7o8DZ2q562A9vG9yzpSd7P9rxowMBqj4axVEcYcConmoUdyya8bmmrooOxSxiq+ZhMQzHHAFkAIoEJFjVwSOdynLJM0ZnjhZ7tBgzOHOyOKiJxoVJgb70YPXQb3VM76zfMIg1tGdWLaV84/oUdB7FMFevsSdVxkeFsjD6HQsxteaua+VtwcNvBCLJMzpmsa/2p7oTqnZYm8E4DjtmHafpTr2XrI+w0FnKDb9KrepaWd02wr3Yu00K1O+P1EZpsGEt1goGRbqIO5es8eMkxE157zMEfBmCnSyadrdMyHyM7RsnMkXGImSr8s1ewVCV5/3nHi7UemWnoy/QCEBiPzFxG16hY5+Zo/Xofe3pfJSOKMI5ejAaXjwO8swBIibvr1/s4vE0jM89vnthYapnzDhaq+lN/2lq/BvWASmYOOjomvlB3wOgt1q/xuKPnZUqCgEMWOLh97AQAAHwRDnAoodykvMOg0dUWDWOpTvDyZqXQZ6gkMXc8IqKKgxe/E6csUxIEtu2p04ehLsSytHXv0i8V6DqUuUVl49+d6K31yMyBVGJQVsjMYc/cia9tWcQsSdkasvn6raa+feA1APwlz9h6MTrM71BqokliiT3xkZqPzRToyMwHTuRpA+haxhx1zeyK1qlxUMzRr0ptNPkWTnxt+4HMLipinkVhsMYDMw87hzcDECj5cKpcrvEwp1XJuC06siRymZqPrdZoGEt1gm29iquzvbTvr9TpdBEpKQt7Z299Gkt6vZjlE5CZAeg6lLaiEsIcStWpsRTvptuhqLu3hcYQG9RDdBDyKwZVkeFaj8w09CSVcElQjuzzWv+cFYRKikfpzaH6lJhIDrxBv7pmDh9HY0lD16G0q0Tm3npdMyM7tD1k1j680zg9hDyq90moU2Ma6MsohnGAfXingZY5h+OSlefMG4P2P3Q1jKU6QXdUSWlukfyTur6ppJwKeobrMwNsV+8rml7MoZ378CwFO2lCyRDMZurDZbwXdLIBi1sW7vPyZjXTJSfWaZhWlhksKoZg0DVr39d3HUqbahxsG6lPT8o2lczskkQWRvYuoluByEIiqvcxlazPPUTvaVvaOr60RBlNTYqBWXTU6ZqRSprURmiMWptvhTjrMG3NbBm2/5ppGEt1gsGccjO2OCZI+dUhJCvGwWCyPsmIO4cV49Ff8o+vF1OGIBBwKQ+HXHGg1kMzB7qN/5Axil++FbO6DgMgL0qMpJM1HZopSA/TKyqeokhgH55HgPaDNE/Krpj9T8ljYU9cMXoCpdDECQAAokjQqZSHyebr07OkFIxVDpVjFYx9Kzo6lOoIGUeBvBqirCvE99DtVO6LfXqnAToOol312O+og1Btw1iqEwxLUQDa/fu2+AHCoiLSGMvWp3Ew6i5undT1zR7lujR1aBgAw32biO5LL0aHtraFeFQi8xv1mO2k47TNj+z7QUiwgzY1DDcU31XLkZmG/pyyFwTEfZCZVTS7FWMpLddnyZPdPa+SUwvGHjZR5peKOe1LEGQZWYAd0TrcV4e3arIBi5r34a0HCHZqnqW+uP1D1w1jqU4wLChp8nP2FVtXEXZGAIgVozUakYkoFRiQFDHF4DjFL9+K9oCixZQWszUblpnYNvA6AJ6Sa0K9mDLEUJdmHGwdqUNPyvBWzWtwQNskNn7RQZOkPCii6Tqcj3xKk9oI+SYxH0CbT/HGpoX6LJu0c+RNAHwlHwHP+CWkyvCEZ9GirpnNw3V4j+i80we1Ldz39Z4gLZLCk4wm7H/AaBhLdQCpVKLfqSzSJXMOm9RnIh5lo0tIdehJ0anMtu5DL6aM2RElDTYjFskW8jUbmlnoSSqblV/et6EEQLBDCzvtiNZfmKUw+Ca9WgLAJDxLQERUMuaS+f6ajcs0DG/TOG1d4cnNR1eTchBJi/m6lFPoSyseVT+TozYQ7BxdM7H6E6aM97/OkLPsnZ5E6BpoQjEy4zn77yENY6kOsL37NUUvBjhkydGT+kxrUNnoEkKuZuMyDSPb2ONSFvWiyL6JmQCzWhbhUF3om4fsv7ArIMsMFBQyc8AxCTIzQGDUWOqrw7DTjv5NagLAPvRidGh2KoZmuhSt4chMwsioMvOS5smtmbmtygOzKMp0J6K1Gpk50HunXfuQ2ihDF3baE6u/0PUO1TvtkhzMDU+O3hBxKGKeqaL9s2obxlId4JVtTwPQVpRoCrZM6jOdEcXVHnXUYR0jnST/QfvSi1HhCHfRqm50dedC19VAa/IvnNxnPEGaS6oLvQ6TAHZHtwPgLwX3qRdTRou3jnltOj7KZMjMAKHmufUrpxDbxR6VzNwanNx84G+hVZ2P4ToIO70Ve9S/yV9q2ncCgIpmt+KVy9QBr61hLNUBdg4qWkltJdekP7OgSxEMG3EISHVW+DE18LqmF7NiXxpLKuRgh3Yq3F5vYSedbMDc8OS8BgARzYVefyGFfvVv8gn7SJHXoSOoeOXSjvrzxg72bSKhVgCYbIiFwOia2VYHqeEV0PFzFk7SO43ooEnNMo5n62w+ZJmBglIeyz9Rrc23oD2g1KBMCw1RygYsgL7EdgCaCUz6M0vmKorERUFgV9+WWgzLNJTdxQ7JwaLmyWX2EGjXCM098Trb6HRk5qUtkzeWmpyKCz1TqjORvUyUPhReWsgzuRAcwBw1A6ge5RR2DClkZk/JQ6t/4jpoGnS8tl2xejtgbNOMpQP2VQFAh4ig6Nyli3VWdzPRS49DEZgM70vNXIdZZV5bHcgpNIylOsCQSjhtde1bVbWMgD9Ek2ocbOuur+Kg5eKXfik8aXcxvhYtDFdvLnRpcLRg7KGdk/QaAM2eOk0NHxklM3eGJv8gbGtdULdyCr0qmdknT5LMDKqcgrJm+utszWQrCsZOYc24VF6bKuVSN9B52uZMwTs9u3WRJqewbcTeiRENY6kOMKw+zDoDk7+JASJqaZTuoc1VH5NpkEr0FxRPiE/smvznRAdhNYwZz9QXZ6m7fxNZtWDsZPRiymj3K+72jGh/F3oFdPycxZMNsVDHcgqFLP0lhcwccE5OagMAl49mVcU7lqqj+QB29m9CEgRESeSAttmT/lyrTzmwZupNTkG3Zpa2TP6A4WmaXTdyCg1jqQ4wJBYAmKsWLpwswpJiHPTH6uhUGN9Dj1oDrWmSejFlBCWFo5OqMxf67piizOwt+SelF1PG7CYlCyhdb3IKU9WLKUMvp1BPYafoDi17tGWqBy6hPuUUulVPmU8KTToBAKAjqBhWaTFXV3IK0tAWzRt7yD4KtVdAt2a227xMUMNYsjny+RwDajWP/ecfMaXPhtT4+kimjgi8OjLz7OAkU35VhFD5BlKs6sMyDbJMf1Z5kHknUfxSj9lti3HIMtSZnEJy4A0Gp6gXA1To6PTG7X1KroDOeJwXmjyHCyDiCAOQridem1SiXyUz+8TJk5kB5qicwHqTUxgceJ2USmk4fNYU1owuCWBP3N7PmYaxZHO8uu1ZioKAU5Y5cMHhU/psSNXAiBXsr4GhYXjqejFlBEVl468rF3p6mF5BIVYGp0BmBnDWqZzCTjXs7JSck9aLAcAboaWkkFxH6klOQbdm9p9EwVg9WrwKry1TT3IK8W7NOx3yTHEPidSnnMKuEcU77S55ifgmn0ik57UN2pzXZjtj6Uc/+hELFy7E6/Vy9NFH88wzz4x77bHHHosgCHv9+9CHPqRdc9ZZZ+31/qpVq4z4U6qC13f+HYCOIrjdkw+xAETciqchofIV6gKpgSnrxZQRckQAJTW8blzoqX6tBlqHf2rGEnUqp7A7qxwOfKXI5BMAAESRJllZY4k6UCQuo5Too1tTM5+c4n0ZmpxCPZUJSvVre8icKXra9GumnuQU9hSiAPjlyen4aXB6iKhlgmI2LxNkK2PpgQceYM2aNVxxxRU8//zzHHbYYaxcuZL+/rHj5b/97W/p6enR/r388ss4HA4++clPVly3atWqiut++ctfGvHnVAV7ht8AoFVyT/mzLQFlo0sI9bPRDY7s1vRiVkzFXQyE3YqXQRJgZ3Sw6mMzBamBUb2YpqmFJRUXumI0difs7ULXo1ct8RNyTC0sCRBxKKfqdB0oEpexZ2QneVFAkOHQzql5Uuao3tu8o0Q0k6rF8IxHalBbM4sjUzOW5MBoqHZ3ok54XLJMv6wkeYSdUwtLAkREld5QsHdxYafZA5gKbrrpJr7whS9w9tlnA3D77bfz0EMPceedd3LxxRfvdX1LS6UVfP/99+P3+/cyljweD11dk8+cyuVy5HKjwnTxuJKNVigUKBQKk25nXyi3NVGbfcld4IRmwlPuuy00DxIQE4tVHbeZ2BJTwiPekouIxzfpv6tQKCC7m2kqlYg5HLzWv5M5oSmkUVsUQrxP2/iXNM+d2vfsadY2/sH4rqrdI5O5r2uGUoE+UQlLRjxzpjyGZncE6CMjx22xZiYz19sSPeACf8mHA2FKf1ckPBvPLomcKPJK7w6Omju5Qt5WhhDv03iPS5vnTWk+Cp5mzbPUE9tti3tkn8jG6XYqYclm39TmAyDiDANR0lLM8OfjVNrZF2xjLOXzeZ577jkuueQS7TVRFDnhhBPYuHHjpNr46U9/yumnn04gUBlz3bBhAx0dHTQ3N3P88cfz7W9/m9bW8bkM1113HVddddVerz/66KP4/f5J/kWTx7p168Z9byDXD07wFgI8/PDDU2p3KKpwc6IOecqftSqSw7ugBfzFqc9Hq7OJ9oxiLK19+glyr9ufczCnfwO9aqZT/M1uHt41tTlpUuUleoc2V/0emei+rhU8hahmPEop75T/JlfaAW6F12anNTPRXI8keqe9Zjpiu2krSewRRX7/lz8x2PTmTIdqOrp6/sywT1kzI69t5+EtU/CqyjKtKq9td+9rtrpHxkMgN3rgkhOOKf9NzqwTfEqZoFrMx0z3kXR6chxV2xhLg4ODlEolOjsr3YCdnZ289tpr+/z8M888w8svv8xPf/rTitdXrVrFxz/+cRYtWsSWLVv41re+xcknn8zGjRtxjJMyeskll7BmzRrt93g8zrx58zjppJMIh8PT+OvGRqFQYN26dZx44om4XGOXMvn5XVcAsLDzQFavXj2l9gdG3sGtf/w5aVHknce8g/bmKegSWRQ//bEyH03O1inNR6FQYOPvu2lLltgMBGZFWH3c1ObTitj6x6cojQiIMnzuY5+cUho0wM9/fBkggys95ftrPEzmvq4Z+l7hroeVOTjmwHey+l1T+5u61z4Jw91kHEWOP/EEvK6ph7+NxGTm+rbbvwWINHu6pv4d98yh/Y8/Z4/LSdP8Dla/x/5r5qUHH4E0uCWRT3/sE1P6bKFQoPvHyjwLnkzV1oyZEHY/yy1/UkyFDyx7F6vfceKUPr/5/9ZC6kkyjhyrVq2aGk9wAlRrHylHhvYF2xhLM8VPf/pTDj30UI466qiK108//XTt50MPPZTly5ezZMkSNmzYwAc/+MEx2/J4PHjG0KtxuVw12fwnajclFAGB9vDcKfc9u2MePkkiI4rs7NvE7I4pkhktiJScAdwEXK1Tno+ss4n2osLRGUz1Gf8grwGG0wpvwldy4fN6p/z5FmcTECUjx6o+H7VaLxMiHyUqKsbS/EjX1NdM2yLEIRlJENgRH2JZ19Q4PmZhwj2EHOAj6Gmb+vcRma2FnXpTA3WxZkYyCl/RV/JM6+8JyD5AIlMarov5IBclqvJAF7TMmvLfNLd1EaSepCTKDGRTzG2aIkl8H5jpPjLZz9qG4N3W1obD4aCvr9Il2tfXt0++USqV4v777+dzn/vcPvtZvHgxbW1tbN5sD1XruFqvp3OKafJllCvL7+63v/scSSKBEn8OeCdfILWMosNPq6TMZyxdH6nhI2mFVOmVp24oAbRpisT1Q94dUTf+eU2TrBuogys8q77kFIo54qJyQAj6puFZDrRrxtJIyt6p4WVEs4rGkhfftD4fFIIAZKiPLONCoo+o6g1aEJn6vhpqrg85BdsYS263myOOOIL169drr0mSxPr16znmmGMm/OyvfvUrcrkcn/70p/fZz+7duxkaGmLWrFkzHnOtkc/nSIiKsTO7bWqZX2WE1bTOgdjOqo3LNGSjxFR9lLB/Gt+fINCEYlSk6kSROJqPAuAVpqCNokNnWCl/kXHk60JOIRbdQ6a88TdPPRuOYKeWIbgzWgcZgqlBRtT5iASmYSw5XERk5WSeyNSHnEKiqIRlPKrRM1WEynptdSKnMDCyC1lQ9tX50zCW9MKU20fse4/YxlgCWLNmDXfccQf33HMPmzZt4txzzyWVSmnZcWeeeWYFAbyMn/70p5xyyil7kbaTySTf+MY3+Nvf/sb27dtZv349H/vYx9hvv/1YuXKlIX/TTLBnYBuSehPPm7X/tNoIqx6HoVQdaIKkhxhWvQZtwal7DQAiqlBnWqoPReJEUUmT94iTrCT/FsxW60BJglwXcgp9UeVk65AFOgJNU28gqE8NrwNjKT3qaesKTsN4BCKiYlSk66RMUKKkeFF9zsi0Ph92KVm09SKn0K+q1XtKDvyuqWn5ARUlT3bZWMXbVpyl0047jYGBAS6//HJ6e3tZsWIFa9eu1UjfO3fu3Is89vrrr/Pkk0/y6KOP7tWew+Hgn//8J/fccw/RaJTZs2dz0kkncc0114zJSbIa9vQrocJQScLvnZ7nQFHxThHL2/9BqJySFT7KrGlu/M2eFmAP2TpRJE7IGcCD3zkFpWod/OHZmpzCm0PdLGyZnhFqFQwmlEOBt+SaHtE00K5t/APJOgjDpQYZUUn/s8PT8BoAza4mYIiMXB9lghLkAD8B9/T2EI+7BY+kyCm8OdTDO+fuV90BGoyhlFouSZ5mMkOwc5TXlrCvZ8lWxhLAeeedx3nnnTfmexs2bNjrtQMOOABZlse83ufz8cgjj1RzeIaib0QJnYUkYdptNLlagF7ipcllBFga6UGNiDg7PL2Nrj3QBfk9ZMRMNUdmDqQSSQqAB793evNR9qTEHA62RXuAFVUcoPGIZgYVqY1pcrjwhGhR9n3iafvyLzSkBjU+ytzQ9Iyldn8HSENkxDooE5RPExeV50XQN3UBRoC8K0JbQZFT2DLcbXtjKZobAQ945elxuAi0aaHrkZR914ytwnANVGIoodx4QWlq6eB6NKsbQkK2/0Y3UyIiwOyIonJdECUGkjY3IDMjmvHYFJgmB09XvmFXzL4u9DJiZQ4X0/PEIgg0CWVFYvt7Y2Oxbo3DNV2vYZfKa8uKBbKFfNXGZgrSoxyu5uD01kzWGdG8jzvroExQoqB4DD3C9EL5iA4iKF6ppI3LBDWMJRsjqmY6BZi+1kt7WDEO4qL9lWZnTEQEmiOKnALAGzbO3AAqMr/aAtObD4KdmpxCX8r+xlKZj+JxTF8PTVEkhkwd8Nr6o0rWp0MWaPdP72HY1bIAUZZBgC3DNr9HdGHJzsD0UtxzrrB2wNhTB7y2REnxsk+XwwWjvLZMyb5lghrGko0RzymEygDTDCkAs1uVwplRh/0znfrjCh9l2kREQNaREbfavRBmeuYcLgJttKou9KiNXehlJNQaV37X9LVeynIK2TqQUxhUOSTT5nDxFjmFIZvzuNJD2gFjuhyunLNJM5aGbF48FlkmKSilvfzT5HABNHsU0nsG+3rrG8aSjZEqKjoeAcf0UlwBFs4+BICYQySVtrcuSFlTyDNdIiJUhp1snLkBKHyUGXK4EB00q57LVN7m81EqqhwuCHinT1TvCCop9hlHzvZyCiOqppBnuhwugGC7xknZYfewUxU4XCWHlxa1TFDS7nIK+SQx1UoI+qdf4aEjoNA9sjYu2t4wlmyMZLl6uisy7TYWdC3FqRLgt+x5pRrDMg0jWSUs4pWnX59PDnTQXlSMpW6bVw2vBocLIOIou9BtHnZKD2khlmlzuIA5LYoAbD3IKcRyUWD6OlxAXckpxKK7yc6QwwUQEZX5TBftfX/odbhaAtMjvAPMblKqQ+QdRdvKKTSMJRsjLSvu0ZBnemnhAKLDQbNa+HFX375r7FkZo0TE6XvaFEVi5ZQ8nLK3C72/ChwugGa3ErLK2tiFDlRoCrX5px9S8DfNoUk1Dt60edgpUVIOXF5xGppTZeiMpf6kvY0lvQ7XdDlcAM2uMq/N5nIKVeBwAbRE5uCRyire9qQ3NIwlGyMpKpknLcHpW/wAkZKyGHqGt814TGYiISkZfT5n8/QbcQdolpVlkcjac1GXMZCYOYcLoEMV+LS9InGFDtf0Dxh640CRU7AvkrLync6Ew4WvhVY1CSCesTevbTA5cw4XQGuZ1yba04uiQXfAmC6HC0AMzdIOoVtsWiaoYSzZGEm1plN708wK4AZl5UE6lLTxRifLJFGMR79n+osaRl3omZK9FYmHU0oIwCvPTGC17EIviiV7yynoNv65TTO4RwIdGund1nIKxTxxQTH6At4ZHLhEkSZB4TylCwPVGJlpiGaUbK1pawqp6FRlB7Ji3t5yCjoO1/xp1FLUoOOC2lVOoWEs2RgxtS5cZ/PCGbUTVo2DaM7GG102RlStCxeapphcGS0uJSSRtbkLPZZTNn73DDf+5ub6kFMoJPqIieUiujMwlnQZk70pG/PadCKu4RnwUUAnp2BzXlusEAXAMxMOF9DRPK8u5BRisT0ah2smoXy9N3ZP0p5rpmEs2RRD0V5yqrE0r2vpjNoKq2GreMHGxkF6SEdEnFlJjjafsilkba5IHFcLgnrF6WsKAZVhJxsXwuwf2a1xuBZEps9ZIjiaBBBN2zgMp9Ph6gjMYD6AVq/KaxPsXSaorMM1Iw4X4Ax1aXIKdpYg6R1ROVzSzDhces/SkE312hrGkk2xq0+pC+eSZdoj00/pBIh4FeMggY3j66mBqhARAWaFZwOQcxRI5XIzHppZSEqKppDXEZlZQ3oXesy+xtKgjsPldc1AXsLlIyIr91rKxorEeh2ursAMOFxAZ0DZg7KOrK3lFMocLt9MOFwAgQ6No7Pdxry2YdWw8Uoz43DhjdCqJhLFMw3OUgMGomdQIWM3lWREx/TLnQC0BVUVb8G+hoH+lDwTIiJAR/N8TU7hTbueCiWJRFlTaIYcLr0nxc5yCsMpJczslWZeJLvZYX9FYlJD1eFwAbObFV6breUUClniKg80MMNQvj5Uuztu3zUzqsM1s1A+okhEUNqwq5xCw1iyKQZj5bpwM/8KZ7UsAiAmlmbclmlIz1xMrgwx1KV5UuyauUE2ykiZwzUDMTmgIgw3mLanCx0gmlf4NB6mr8NVRotbCV3bWU6hkKwSh4s6kVPQ1YVr8s/MWJJ1a8bOZYLieeX+nimHC6BZ44JGZ9yWGWgYSzbFcErxeARl14zbmt91EABRh0CxaM8acbHonqqIyQEQ7NSMpR125eikBjTjsWUGmkIAeCO0qJGVpI3lFOIFRaHeM1MOF9DuV+6xrJiZcVtmoWocLqjwpNhWTiE1oONwzSwsib+NNtUbG8vYdD6AuFTW4YrMuK02r3KP5Wwqp9AwlmyKeLZcF27mIYVFcw5CkGWKgsD27tdn3J4Z6Ispp1lxhmJygFK+oVjO3LDpqVAnJtc13bpwZYgiEUHxxmSK9s2YLNeF885Eh0tFV5MSuraznMJAvEocLoBgp/3lFFJDVeNw4fQQQTnIpvI2DcPJMklV+NjnniGHi9EyQVkxZ0s5hYaxZFMk1JBCoAruUb83QJOkcHR29tpTxXtINWp8JffMiIhQqUicsqlxoNMUmhWa4cbPqCJxVranYYBUGq0L55mh8QhEmmZrcgp2DTuNpMs6XDOoC1dGYNSz1Je2/5qZKYcLIOJQDm1ZyaZyCvkUcVF5LgRnosOloqt5viansG3EfgZkw1iyKVKqezTonKEXRUVELfzYPbSlKu0ZjajqaXNXZeNv1zb+uE0LYUrJAY1/MSMxORVlF3pWsKcLnfSw9iAM+WbI4aKS17Z1xJ5hljKHyz2DWooadEkAw2l7rplcoo94lThcAK0exRuTw6YFyis4XDPfQ1zhWZqcwmYbHjAaxpJNkVLTwkOembtHAcKS4obvj++qSntGI6YREWdQF64Mp4cIynykC/YMKSRiPeSqISanokuVU8g78vaUU9BxuFpnyuGCCu+jXeUUEsXqcbjwNo3y2mwqpzAQrSKHC+hQhT6zjow95RR02ZIz5nCBKkFiXzmFhrFkU6QEJebb7Ju5xQ8QUjkp0aw9jYOkpIrJOWYmJleG3V3ofbEqicmp6IjMs7ecQlrP4arSxm9zOYUyh2tGtRTLEAStTFC2aM8yQYMah8s5cw4XMCsyB1DkFHbHbTgnaX0txWocMOwtp9AwlmyKpFgEoFmtQTRThBzK6TKet6FxIMskVCKi31WFByHQornQ7alIPKyW4fBKVeBwAWKo096KxCk9h6s6G3/5lDyYsSFHp1TQOFwzraVYhpYablM5heGMwuHyzLCWYhn+pjmEtbCTvdfMnHB1vLHl0HW/DXltDWPJpigT7zpbFlSlvZC60aVlG6ZC5+LEVF3OGRUE1aFFdaHnRRuGnICRbHXqwmkIdtCsGgd9KfsZ1JUcrioYB4F2IpKy8WdyNhTZSw8xrHrawjPUFCqjya/Ma1HIVqU9oxHLRQHwVIPDBRDspFkNv/Uk7Sdemkv0ElPvkQWRKkQwgh1EVGMpmbPffDSMJRsim0uTUOvCzWpbVJU2gx7FFZ+WbWgcpEaJiJEqEBEBWsKKx64kSsSy9qsRFyuodeGqweECCHbSpG78Ayn7bXTx+CiHqyobv8NFACWZIF+033zovQatvup4Y5u1A0aBYsl+AreJkuJFrgqHCyDYQZN6wOhP2u+AMRAdLZo9r6kK94g7SFAtE5TN2++A0TCWbIjdfVs1IuL8rv2q0mbYp7hZ04L99C9I64mI1SG8N0fm4VA5Ortj9uMbJNVsSU+VOFwEOwmrxtJQJlqdNg3EgI7D1eqvjgHpdyrt5Es2LECdGiAqVpHDBbSqHB1ZgN6k/eYkIZU5XNXZQ/RrZiBtP4N6IKEQ9avF4UIQCDgUr12+aD/jsWEs2RA9g1sBCJUkvJ7quIybg8qpMCXaMWujegVByxBDoxtdt93ImZJEQlaMXp+rClwDgEC7Vs4inrHfqXBQ5XB5qsThAgi6IgAUZBvKKaSHGK4mhwsINs3Bq66ZPXY7YBRzJATl/vZVicNFoEPzxkYz9jMOolXmcAH4VW5sQbKfnELDWLIheod3AhCWhKq12RFRFIlTKhfKVtCVKaiGmBxQ4ULvtRvfIBslptaFC1YpWxJPiJCszHEma79MlmhOrQtXLQ4XEFbDV3kbcnSkZL8mpVAVDhdUhGp7kjYzllKDmvE407pwGgJt2h6SytgvyziajwLgkWcufFxG2Kt47fLYj9rQMJZsiOGkIugVlBxVa7OzdT4ACdF+9eGqLSYHVJwK++1GaE4PMazOR7O/SvMhCPgFhaOTK9jMeERfELQ6Iq4AER1Hx26Ix3qry+GCigNGn90OGOlBohqHq0phONGBX9Vry9iQo5MoVpnDBYTV/ciOiTMNY8mGiKaVk31ArkIcWcWstoUASIJAz6C9hCkHY3uqKiYHgK95lNBsN75BakDb+Dv91QlLAgREJeSbK9nPhZ7QdLgiVWuzLawYSwVRIpGzVxbpQLz6HK7KNROtTptGITUwGsqvEocLICAqB4xswX4crqRWS7FKxiPQElCMpZxYtJ1QZ8NYsiESuXJduOqFFEKBiFbrqndoW9XaNQKDal04d7WIiKBs/OopOZa22alQx+HqrOLGH1IJzVm7cXSkEklUDpe7evPREp6FYNMkgFEOl6dqHC69sTSUttd86NWqq8XhAgg6VKFO2WZ6bfk0cUG5t/1VqKVYRntYKTUkCdCfspcB2TCWbIhkUbnJAo7qhRQAgqqhPzCyZ+ILLYZhdWP2VKMuXBnuACH1QZjK2kxATVcQtGphSSDsVjLr8tjLi0JmRPO0VaMgaBnOQIuWBLDHZkkAsRpwuPBGNGMpYTPRQSnZrx0wqsbhAkIuNWNSthlHJ10DDhcQCnfiUe8Rux0wGsaSDZFSF17IHalqu0FJuR2GE/ZSm42XiYhUj4iIIBCUy3wDe3GWcol+TUyumsZSs8rlyIk2k5dIDWocrpZq1IUrw9dMRLJnEkC8UH0OF063toekbCbUGY/3kle16xa1VM84iKj6dTm7JQHoQvntVQzl672PPQl7rZmGsWRDpGRl4YU9VbyJAb/sBCBqs1NhXOXQeITqERFBxzewmY5Of3S38oNcJTE5FXq+ga1EB1MDWl24Dn/1+Bf6UK3dRAfjknLg8jgjVW03ICgHjGwxWtV2a43+mJI045AEmr3VO3RFVEPDdkkAqSHN01Yt7TqgwljqtdmasZ2x9KMf/YiFCxfi9Xo5+uijeeaZZ8a99u6770YQhIp/Xm9lqEaWZS6//HJmzZqFz+fjhBNO4M0336z1nzEjpNSF1xLsqmq75cyNRNZGp0JZJikpxqPXVcVFjY5vYDNC85DK4fJIVeRwAa0qoVm2G98gPailyVeTj4KvWQvDDdpJR6dU0Dhc1aqlWEawnARQtFd9uOF0DThcQGuonDEpkcrZKAMsra8LVz3vdMUBI9UIw9UMDzzwAGvWrOGKK67g+eef57DDDmPlypX094+v+xIOh+np6dH+7dixo+L9733ve9xyyy3cfvvtPP300wQCAVauXEk2a123aUIVjmwLz61quz4U/kIyb6MHYT5JTL2Lq1UQtIwyodlumiAjqpicu5ocLiAY7tSSAHZFbbTR6TR0qlIQtAzdKdlW3tj0sOZpqyaHC0YPGDmbEZprocMF0BruGk0CsBGvTamlqNwjc6u5ZnS8tiE7HTAAp9kDmApuuukmvvCFL3D22WcDcPvtt/PQQw9x5513cvHFF4/5GUEQ6Ooa2wMjyzLf//73ufTSS/nYxz4GwM9+9jM6Ozt58MEHOf3008f8XC6XI6c7JcTjyimqUChQKFTP3VpuS9+mVCoRU2PrHZF5Ve3P7wgAQ6SKyaq2W1PEerUHYdjbNu1xjzXXYU8TyD3khZx95gOI5WPgUcTkqjluwRUiLElkRJHdsX7eUVg4rXbGmutaohjrIa4aB7ODLdXrV/Rqp+REZsCS98iYcx3vHa2l6Guu6rhDrhAwQo6sJedjPMQKivfYLYRmNO63zrfgaSIsScQcDnaO9LE4Ut0DXa0QH9mjcbjmhqq4ZpwBzViKpfqrOtczbWdfsI2xlM/nee6557jkkku010RR5IQTTmDjxo3jfi6ZTLJgwQIkSeId73gH//mf/8khhxwCwLZt2+jt7eWEE07Qrm9qauLoo49m48aN4xpL1113HVddddVerz/66KP4/VWqWK3DunXrtJ/Tubh2E7/56m72bHm4av3IWQGCkCjEefjh6rVbSzSnNmtExPRAcsbj1s91MFaAMOTEgm3mAyCajwM+hKK3quNuTb5GpCTR54Qnnv8bzq0zC9fq57qW6Nz5HIQBGV7567O8XsUwi18Vhh2K7rb0PaKf67bEq5pnKdETreq4PSkJmiAn5Cw9H29FvJQCAlCozpopz3dHfDNNqrG0/m9/Ib1p54zbNgIt2/8BEYXDtfGxJxDF6lWLCKp0x77B7VWd6+kinZ5c5MA2xtLg4CClUonOzkq3cWdnJ6+99tqYnznggAO48847Wb58ObFYjBtuuIF3v/vdvPLKK8ydO5fe3l6tjbe2WX5vLFxyySWsWbNG+z0ejzNv3jxOOukkwuHqkYwLhQLr1q3jxBNPxOVyAfDC60/Ac+CRZD7+0U8iOqqn4v3mr9dCfgd5R4nVq1dXrd1aQnhjLf/1lDIH7zxoBavfOb1xjzXXw+ufg74tFESJ933weEKe6oa1agJZ5ie3ng/4CAdmVfd77F9E0+9/AkDr3A5Wv796c11LvHzfPQB4JBcf/fCHq9r2z26/FACHu2DJNTPWXAuvZPnOs4rB+J7l72T1YcdWrb+dDz0Osd3kHEVWrVpVVf5PzVDM8cP/LgIQCc+d0ff41vkW9nTR9Mi94IKORXNY/S7r3SNj4dmf3QYoHK4Pf/hDVW27+7ZvAuDyFqs619NFOTK0L9jGWJoOjjnmGI455hjt93e/+90cdNBB/PjHP+aaa66ZdrsejwePZ+/igi6Xqyabv77dwaiigRSWZDze6j68I4F2yENaKBjyEKsKctFRImJTx4zHrZ/r1sgcxF4ZSRDoS8doCVZX16omyIwQVU+Bfs/M56MCofZRjk4uVtW5riWi2WHwKhyuavcXdPiBNDk5aek1UzHXuagWup7f3FnVcXdE5kBMSQIYyafpCjVXre2aITNAVD10hrzVWTPafIfatCSAoezM14xRiOei4AS37K/6mAOiDyiSk+LVnesZfH4ysIHZr6CtrQ2Hw0FfX2VBwr6+vnE5SW+Fy+Xi8MMPZ/PmzQDa52bSptEYiCmlSEJS9b+6cq2rlGiftHA9EbGaYnIAzkCr/UQHdUrEEV8ViZkAvgjhsqp5xj6E5rhaaqKqOlwqFI4O5GwkOphN9GkcrqrVhVMRCnVoooO77CI6qNPhaq2mphBUJgFk7KMrFCuW5Viqf0AMOtUkAMlelQBsYyy53W6OOOII1q9fr70mSRLr16+v8B5NhFKpxEsvvcSsWbMAWLRoEV1dXRVtxuNxnn766Um3aTRGUophF5Crf0JpjyjZdUlRrnrbtUIiURsxOQB8EZ0miE02Ol3Kb3s1NYUAXD5CsjLXaRvJS8RL5YKgTVVvu8kTASBvI9HBQVVTSNHhqrZBPWocdNvlgJEe1DxLnYEqG0veJiLqASOZGT9r22pISuW6cNX3DIbdClXFbpUAbBWGW7NmDZ/97Gc58sgjOeqoo/j+979PKpXSsuPOPPNM5syZw3XXXQfA1Vdfzbve9S72228/otEo119/PTt27ODzn/88oGTKXXDBBXz7299m6dKlLFq0iMsuu4zZs2dzyimnmPVnToi4+pAKUH3+TFfLfAASokCxWMDptL7LuD9eFpMTqyomB4xqgrhsJDqoKwhazbpwZZRFBzNFm8yHJJGQc4C36jpcAM3+VkgpSQB2wWBS4WN6JBduZ5UfAaqx1A/0pWxywEiNHjCqWUQXANFBAGUfzeRtMh+FDHFB4XB5q1hLsYwmTwsUd5ETbaQ7hc2MpdNOO42BgQEuv/xyent7WbFiBWvXrtUI2jt37qwgFI6MjPCFL3yB3t5empubOeKII/jrX//KwQcfrF1z0UUXkUqlOOecc4hGo7z3ve9l7dq1e4lXWgWJQgycEBCrH1Loal8AgCQI9A7vYW7Hwqr3UW0MpwfAWX0xOaBCE2QwbRPjQLfxz66mAKOKoKDyDewi1JkZIabeFwFPdUNOAK3BDkhBQRUdDIzBZbQaoplh8FVfhwuoEB0cSNlozaj3yNwqh/IBAoJyT2TsomqeGvW0hb21WDOtEFUOGJIk2SMJAJsZSwDnnXce55133pjvbdiwoeL3m2++mZtvvnnC9gRB4Oqrr+bqq6+u1hBrilQpAU4IOqpb2gOgKdiCV5LJigK9A9ttYSyNZEcgCO4qi8kBFSGFkYw9QgpScrS0RzXrwpURdAaBKHnJJqKDurBkk7f6p+SWcBdCr4wsCOyOD3FA++yq91FtxAoxxVgiWP3GdWtmKBOtfvs1gJ7DVW3eI0DA4QOy5CSbHDDSulqKvup7Y9tCsyAKkgAD6QSdweqHx2sBe5h0DWhIyUqcN+yp/k0MEJIUvtJAdFdN2q82EsWymFz1jUe8TRqhOZm1B6E5luilICi8osXNVeZwAWGXMs85u/ANdJ62jmrzUQBXoJWQlgRgDx5XoqQQa2vB4dLz/OI2UTUfjKmFw2vB4QLCToUknbdLEkBqqHYcLiAYbMetPmd2x+yxZqBhLNkOKUGp6dTkr40SbEDNshtO9NSk/WojoRIRq10QFADRQVB1vtqFbzAQV743hyTS7K++56DJFwEgJ+ar3nZNkB6sTUHQMnzNRMpV1O2QBCCVSKh14WrB4cLlJ6xMB6mcPR6EgymFw+WuBYcLaPIoRmnOLkkA6RpyuAAx0EKTpGRcd8dtsGZUNIwlmyGhpvW3hubUpP2ArGwWtqh1VcgSU+vk+d3VPxEC+AWF15Et2qNe3nBW2Xw8Um24My0BxUgv8w0sj8zIqA5XqAYHDH1hUDskAWRjWlHhYA04XAiCVpA7U7DBfAAj2SgAnlpwuICIKkeQt0sSQGaE4XJduBqEJfWh2n67JAHQMJZsh4Sa1t/ZPK8m7ftkZaOLZ2xwKsxGR8XkqlxEt4xQuYq6ZI8q6iN5ZZweasDhAtpCiv6YLEB/yvoGpJQe0Thcc2sQYsHXrGlx2SIJQGc8NnlrE8oPisq9lyvZY83Eiqq0RA10uABagopRmhdLpAvWzwDLpoZIlEVLa2UsqQcM22RM0jCWbIV0NqXdxHPal9SkD7+onK6Sees/CMlEdWJyNeJwuezFN4gVVT4KtVEbD4U78KrGwW4biA6OJPpryuGynehgNsqwoxyWrH6IBSDoUIwOuyQBxCRlbXvFGvAegbbwqMDxnpj175GBuFrqq0YcLjsmAUDDWLIVdvdtAUCQZeZ27leTPvyqJEG6ZIONTudZ6qiRsRRW+QZ5wfonQhjlcHlrkC0JVHhS7KBqPpBUhABrxeHCG9FOyQk7JAFkoloYriYcLiDktlcSQEJWOFy+WvAeAVegjVDJPmtmMK1EFTySsyYcLr2xFLNJljE0jCVboXtAMZbCkozbXRtOSlDNdkpLNvCk6EIKs2qgKQTQrBphtiA0yzJxFF5EoAZickDFRmcHF/pQWtmMvZK7Nh04nARRDPZ0zgYbf605XEDEq6g+5+0gOljMExeU+zngqc0eoiQBKFxTO1QCGMoo4WSvVCOtQXeQcEmhk6TtcMBQ0TCWbIT+kXJdOKFmfQTdykaXlm2QuZGJ1lRMDqA1qIRuyqKDlkY+Scyh3BshXw3Iu2A70cFoLgqAtxY6XCoCKAcXOyQB6Dlc86tcF66MFjW8Z4skgGyUaJnD5a9RPVA9odkGSQAxlffoxV+bDgQBf7kSQN7681FGw1iyEUbUFNeA5KhZHyG1+GpasH7mRiE9pInJzQ7VxpPSGu5CkJVT0K64xU9BuhBL2FvLU3KZb2B94yBe5nAJNdr4gaCjnARgfdHBeHKUwzU3XJs10xZSam+WRQctjcyosdTsrX4dNKAyYzJtfc9SoqREFdxiDcLWKoLlLOOS9feQMhrGko2QUNPCfTUooltGc0DxpKRViQIrYzjep/08L1Kbjd8ZaNU4OpbXBMlGiWuE90ht+tCVgInZIGMyJZU3/toQ3gFCTuWhkpetX0V9KKFwuERZoLUWHC4gGGyzj+igbs20+2tkLHkj2h4ynLG+J6UcVagZ7xEI2SwJABrGkq2QykcB8Am1qz/V1qScCpOqRIGVMZRSPD0uScTvqtGc6FzolhcdzESJq6fktloZS54QIZVvkLIB3yCtkne9ztpt/GFPBIC8DUQHR1QOl0dy1qwml+jXiw5anMeV0RlLgUht+tCpmttizWiipZGa9RFyq1nGNkkCgIaxZCukCopL2y/Ujn/R1boQgIQoIJWs7V2KqRu/W6qdp81WooO6U3JHoEanZEEgoPINslYXHZQkUirh3eeuTeYXQLPPPkkAsazynblrRXiHigNGr43WTGewRmvG6SGkVkawfBJAIUNStQr8nholiQBNasgzZ5MsY2gYS7ZCOUPN56xdLHlW+wIASoJA/0h3zfqpBuJZJd7tlmtY6d1OooOZEW3j76rVxs8o3yBndb5BLkZCnQ9/rThcQEtQSS4oiJLlRQeTKnnXTY0ynaAyCcDiHJ1iaki7R2aFamdQB9RoQLZg8TWj20OCvtqtmWa/0nbOYYMkABUNY8lGyKix5EANQwqRUBselW/Q3b+1Zv1UA1oR3RqpVQMVhGar8w2yqSEy6kY3O1y7jb8sOpizOt9AF5aslVo1QFt4lvaz1UUHk2oRXXcNCe92Eh2MJvqQVMJ7LddMoKxqbvVKALqwZItaB7IWaFcrAUiCzFDa4vuIioaxZCNkUE6tQZUjUSuEVGOpP7q7pv3MFKlimbxbmzIFQIXoYNLifIPBsvIutfUshVXRQcvzDbJR4qLyIGz1NdWsG1eg1Taig6ly4WlH7QjvdhIdHE4qa9ohCTR5a2dAhrVKABZPAtAnidRwzYSCbbjULOPdFl8zZTSMJRshQxGAcA3dowBBNb4+nLB2GK6cteGpYdYGTjdBWZmPjMX5BiMpJfPIXXLURnlXRbjMN7C66KDulFwzwjtUiA72JKx9j5QJ754aqVUrjYdpKicBZKx9wBglvNeQ98hoJYCc1ZMAKgjvtTtwiYFW7RDabfE1U0bDWLIR0qJyczUHayQ4qMIvKw/aaMrCG50sG5K1ATq+gcVFB8u1ydw1lJYAaA0oxnre6qKDWWM2/kpVcwuHaktFUoJi1PlrSHhHFAmg3IMZiycBJHJl3mMNCe9ARA0D5wWLJwHo1kwtvdPKmlHuxb6EtUPXZTSMJRshpabzt+g4ErWAX9044lbW0SlkSKhC5rXM2gD78A0SOZW8K9eQvMuoqrnlRQd1p+RZoRpv/CUbJAFkY9p8BLy1XjPlJACLr5lCmfBeQ94j0KomAeQdJbIF6xpMhdSQVqy9loR32xwwdGgYSzaBVCqRVPkXHc1za9qXT812SuYt7EnJjpJ3gzXe+O3CN0iq0hLuGkpLAITDHXjUjc7KooPJRD85Awjv+PSig9Ha9TNT6DKdmnw1NB7Rq5pbm7ybVBXea8p7BFpCndrPeywsbqsX+p3TVGNjqVROAmgYSw1UEf0j3ZTUrI1yen+t4Fc3ulTJHl6DWmZtgH34Bhp5t4ZlCoCKU6GVVc3LatWCDB2B2pFV9fNh6SSACvJupKZdhcoHDKxdkDstqbzHGiq8A3iCbbZIAhhKKWumpkK/ULFmyvQBq2NaxtKWLVu49NJL+dSnPkV/vzK5f/zjH3nllVeqOrgGRtE7tAMAtyQTCdWY4O1UHiwZycIbnRGlPVREVM9VXrR2vbyUEYR3qNCesnIVdY3wLjlxOmpXTxGXj7Ba3NrSooNGEd6BiJoEkLd4EkDKIN6jnqPTY2GOTkzVxaqp0C+At0kzltI563qn9ZiysfTnP/+ZQw89lKeffprf/va3JJOKm/Uf//gHV1xxRdUH2ICCgZE9AASl2pchKUsTpLHwRqfP2qjxxt+qiQ6WrCs6KMukVbVqr6u2IRa7iA5qatU1JrwDOlXzaM37mjZ0oeuaqVWr0EQHrZwEUMyREpSx1VLhXelg1JPSn7LumonnDBD6BRAdBNR1mclbdz70mLKxdPHFF/Ptb3+bdevW4XaPZhAcf/zx/O1vf6vq4BoYxXCiB4CAeoKtJcI+xZNSzjazJIwoU6CiNTzKN9gVtajnIJcgoXLa/DXmcNlFdDCRL2/8tSW8AwTEMkfHuoRmKT08mulUS/Iu0B4qJwFYWHRQd+AK1FiOpaJskoUJzZrQb415j2CfLOMypmwsvfTSS5x66ql7vd7R0cHgoD3caXZELK1wIfxyDcMJKiJ+ZaNLidatDVdMDWmE95pmbVApOmhZTRCd8Vg2dmuGCtFB654KNfJuLdWqVYTUEkR52bqh60RygKLKe5xT4zUTDLZbX3RQt2aavZHa9qVbM8PZaG37mgE0oV+htoR30CcBWJgbq8OUjaVIJEJPT89er7/wwgvMmTOnKoNqYG8k1IeSz4CQQlvTbGBUqsCKGI73Iasb/9xw7Y2Dsuhgr1X5BrpMpxZvDcnMAN4mIqVyFXXrHpBSJWXjrznhHQi5lTnPC9ZVNR9KKArvogyt/trOiS1EBzMjWliy1rxHPc8vaWFJFkOEflXYphKAiikbS6effjrf/OY36e3tRRAEJEniqaee4sILL+TMM8+sxRgbAJL5KAA+ocaxZKCzdSEACVFAKlnTuzSsCmY6JZGAp8ZzYgdNEAPJu4gO/CjCpemCRY1HIC0r/DKPs8bGI9DsUzw1OdG6oeuR1Ch5VxRrnAhdccCwqrGkFy2N1LYvl5+wSt1K5S06HwYK/QKEtQOGtbOMy5jyivnP//xPDjzwQObNm0cymeTggw/m/e9/P+9+97u59NJLazHGBoCUGkv2GRBLntOxEICiIDAQ7Z34YpMQVYnFtS5TANhDdFBH3q2pWrWKgKrFlbMq30AqkRaU8kA+d+3nww5JAHE1/OOpsVo1UOFJ6U9Fa9/fdKDnPdZ6zQgCAVSOjlWTAAppEqq3vtZCvzCaBGD5SgAqpmwsud1u7rjjDrZs2cIf/vAHfv7zn/Paa69x77334qhleu7bHBm1WrjfWftYciTUhkfNutszsLXm/U0H8VwUAFetszagYuMftqqAWsagMgUqQirfIG9V0UGdWrXf217z7lpCoyWIeuLWvEfKatUuAwjv+gLUVhUdlNLDJDSF9xpnwwFBTdXcogeMjHFCvwBt6popiTIjWWsL/gJMu9rm/PnzmT9/fjXH0sAEyKix5ICz9rFkUCQKcqLAwMguQ/qbKpKFBLjBjQEbvy4Ml8ha04WeTQ2RLqtVG7Dxh9xhIGtd0UGd16DJW3vj0RNQRAcTDpE98SGWtHbVvM+pIllUDFsjCO8VooNZaxpLI4l+Teh3Ti0V3lUEnUEgbt1KAFnjhH4BmkIdOHtlioLArtgQrf7aCoPOFJMyltasWTPpBm+66aZpD6aB8ZFRq4WXNZBqjaAkMgQMxfcm81sBSZW86zaAvKvnG1hVQG0oMVqmoKalPVQ0uSNAP3nBmiEn/Sm5xVd7zlLZ+5hwiJYVHUxJWcBZc7VqAHwRzViyahLAUFIRVHZIAhFf7T32CqE5bl2OTsY4oV8A0a8kAQw5HXTHh1gxa2HN+5wJJmUsvfDCCxW/P//88xSLRQ444AAA3njjDRwOB0cccUT1R9gAABlBERwM11oPRIUiUVAipsrfWw1K1obHkKwNhW9gbdHBEXXjd0sO3M5pO4wnjZZAK6Qg51D4BjUnDE8VuuzAWouWAhqheQ9Oy4oOKoR3Jx6XAcajw0VQlTmxquhgLK14iWuuVq0i4muBwm4LHzCMXjOKQT2Egz4LVwIoY1I73OOPP679+8hHPsIHPvABdu/ezfPPP8/zzz/Prl27OO644/jQhz5U6/Hyox/9iIULF+L1ejn66KN55plnxr32jjvu4H3vex/Nzc00Nzdzwgkn7HX9WWedhSAIFf9WrVpV6z9jykiJyimtKVB7/gWAXyWBxqx4KjQ4awMgKCrEeqtqgmhq1QZt/G1Bi4sO6kIKHQYQ3i0vOlgqGKdWraKcBJAtRg3pb6qIqYR3txGEd6A1oBKaHSWyBQtmTRoo9AtUlIDps+gBQ48pHwdvvPFGrrvuOpqbRyezubmZb3/729x4441VHdxb8cADD7BmzRquuOIKnn/+eQ477DBWrlyp1ad7KzZs2MCnPvUpHn/8cTZu3Mi8efM46aST2LNnT8V1q1atoqenR/v3y1/+sqZ/x3RQ1jxqDc8ypD+/utGVJQsshUKahCpkbkTWBpT5BliWb2BYmQIVwZDFRQf1hHcDOFyWFx3M6sm7xning6IS2srLFjSmUXmPgJvaZxhD5d7dnbCeQV1MDRsm9AtUHDCsXAmgjCn76+PxOAMDe1fWHhgYIJGo7an7pptu4gtf+AJnn302ALfffjsPPfQQd955JxdffPFe1//iF7+o+P0nP/kJv/nNb1i/fn2FJpTH46Gra/KEzFwuRy436kqNx5Usk0KhQKFQvWKr5bZy2ax2E7eEu6rax3jwiQFghHQxYUh/U0JicLRMgbu5KuMrtzFeWyF3CIVvkLHefADJQhI84MJvyPgEj5LtNOh0sGukj2Xtcyf92X3NdTWQjfeTLYcUvKHaz4krpGVMxjODlrlHyuMo6tZMyNNkyPhCrgCQJS+nLTMfeiRLowrv1RrfRPe209tMUJJIiiI7h/uYZ4RBMgUMxXo0od9OX7j235kzOJplnB6ecn/V2kcm+/kpG0unnnoqZ599NjfeeCNHHXUUAE8//TTf+MY3+PjHPz7V5iaNfD7Pc889xyWXXKK9JooiJ5xwAhs3bpxUG+m0smhbWipv0g0bNtDR0UFzczPHH3883/72t2ltHd9jcd1113HVVVft9fqjjz6K31/9TJPf/fG3WtbGq//YyrZNtecRyTkBXBDPx3n44Ydr3t9UEM7s1E7J8f5YVce3bt26MV9vSkjQDHkhb7n5AIjlE4ALim5DxtcV20JEKjGIgw1/34i8uW/fH3oLxpvraqBt13MQAmR47i9/5R+15lTJMuGS4mnrH9ppuXvk2b+s04yl6J5BQ8bnywBeRXTQavMBkCimAS9ywVX18Y11b88Z2U5TSTGW1m18gtgr26ra50wR3vkyhBWh3z+vX1/z/kQpT0Q1lrr7t077O5jpPpJOTy6jd8rG0u23386FF17Iv/3bv2kWmdPp5HOf+xzXX3/9VJubNAYHBymVSnR2dla83tnZyWuvvTapNr75zW8ye/ZsTjjhBO21VatW8fGPf5xFixaxZcsWvvWtb3HyySezcePGcXWjLrnkkooMwXg8roX4wuHqEY4LhQLr1q1jv4Pmw/PgkmVO/cgnEA3Qs3r9Vw9BYRd5R4nVq1fXvL+pQNjxFLc/pmz8hx94KKuPmvn4ynN94okn4nLtzfvp/8NjEO+h4Chx3Ikn4HMZw3OYLP771q8DLkK+NkO+L2FXC+F19wHQNr+L1e+dfJ/7mutq4OVf/RoK4JEcfPTDH65JH2/Fvbd+AwCnp2CZNVOe66OW788NG5U1c/Sh72D1iuNr3vf23/4OskPkxQKrVq2yXBLAD2+9AICmYFfVvq+J7m1hq4+mP/+GPTjpWDy3KvtWNfH3+34GKLxHo+7f3T+6CACPb+rPmWrtI+XI0L4wZWPJ7/dz6623cv3117NlyxYAlixZQiBQ+9TLmeA73/kO999/Pxs2bMDrHdXmOf3007WfDz30UJYvX86SJUvYsGEDH/zgB8dsy+Px4BmjxIbL5arJ5h9V08KDJRmP1wBdIaDJ3wYxSAv5mj3Qpo1CUsdHaa3q+Mb7Dtsis0BdU33pOEvbjOGOTQqSRFooAD587mZjvq9gm8Y3GM7FptVnrdYLQCIXBVEh7xp1/ypJADJ5KW65NeMsJEbXTLjNkPG1hzshq4gOJkt5Wj0W0tEpZDQeqM9T3T0Exrm3g606Xtv01kwtkcjHFO062WPY2AKiqmpeik67z5nuI5P97LRN/UAgwPLly1m+fLkhhlJbWxsOh4O+vkp3f19f3z75RjfccAPf+c53ePTRR1m+fPmE1y5evJi2tjY2b9484zFXCyNJpeRIQBYM6zMSUNRV04IFa8MZnbUBeAKthFTjYI/VCM25uKZE7DdAeReoIDSPWJDQnMwrlq3bCLVqFUFnmdBsvSQAOT1aNNYQ8i4QDnbgVJMAdsUstmZ0CQBBn4FrxsKE5mRBFS01iPAOEBQtXglAhyl7lo477jgEYfyH9mOPPTajAY0Ht9vNEUccwfr16znllFMAkCSJ9evXc9555437ue9973tce+21PPLIIxx55JH77Gf37t0MDQ0xa5Z1PAfRtEKo90vGlZNpDc+Bbkiqpy8roZjSlykwxljSiw72Wk0TRGc8ho0ylrzWFh1MqGrVLiPUqlUohUGT5AXrVVFPJYcoqPu2EaKlAGKgxbqig7o10+yNGNOn7oARz1psDwFSmtCvcVGikDMIjJCXLVoJQIcpG0srVqyo+L1QKPDiiy/y8ssv89nPfrZa4xoTa9as4bOf/SxHHnkkRx11FN///vdJpVJadtyZZ57JnDlzuO666wD47ne/y+WXX859993HwoUL6e1VPDTBYJBgMEgymeSqq67iE5/4BF1dXWzZsoWLLrqI/fbbj5UrV9b0b5kKEhllYflk49y2HS3zlL4dAlKpZAhParIYTvRpWRtzwkadCiOjooNJi6X9ZvRlCgwQHARweQlJSp9ZC4oOpksZwIHHCIV3FU3eCBT3kBesp6EzrIrLCjK0G1VWQjUOLCk6qFerNqC0BwCeJi37y4qVAFJGCv2qaPJGgBHrqprrMGVj6eabbx7z9SuvvJJksrautNNOO42BgQEuv/xyent7WbFiBWvXrtVI3zt37qwgEd52223k83n+5V/+paKdK664giuvvBKHw8E///lP7rnnHqLRKLNnz+akk07immuuGZOTZBZSBUVDxycYRyqe17EEgKIgMBTvo715tmF97wvDScXT5pQEQh6DXMY6F/pA2mLGUtbYMgVl6PkGVkNKzgF+PE6DjEegNdABsVfIO4rki0VDlNQnixFVrdojOY0jWquq5uBiwGpCnTrdqfZAxJg+RZGgKoBpOaFOTejXY5jQL0CztxVy28iL1jtgvBVVW82f/vSnOeqoo7jhhhuq1eSYOO+888YNu23YsKHi9+3bt0/Yls/n45FHHqnSyGqHVCEOTvALxsWSm4ItuCWZvCiwp3+rpYylmOppM0qtGqhwoVuuirquDlqHURs/ZdHBPHmrqZqXiqSEIgBel3FaNq2hTlALyu+OD7G4pXPiDxiIeC4KTuNESwEldF0+YFhxzZR5j0YovKsIONRKAMWYYX1OCvmUJvTrM0joF6A11A45JQlgJJ2k2W+cJ3iqqJqxtHHjxoosswaqh4ykxHP9DuNiyaLDQVCSGRYFBkb27PsDBiKWi2pZG4ZB5SwBJHNW2/hHazp1GUR4Bwi6gsAwedliHJ1sbFS01CgOF+AJthGQJFKiUkzXSsZSMq8cuFwGEt71ayaatZZxIKWHtHtET3gvlUozEjksFAo4nU6y2Syl0t7JMU2BxcxyZ2gS/WSzFgo9xQfAP5dZbj9zAnMMG5s3vIjZ8S5kBHYN9eMTJ2+S7Guuy3C5XOPKAE0FUzaW3io8KcsyPT09/P3vf+eyyy6b8YAa2BsZSXkY+V3GxZIB/LLAMDCSmLrgYC2RLCTBDS4DszbwNBGUFLK71QqD5lJDpMbY+GuNkKcJGKZgtcKgurBkk8844xFfMyHVWOpLRo3rdxJIFkfVqg2DzlhK56y1ZmKJAU3od064BVmW6e3tJRqNzqhdWZbp6upi165dYyZCdS77Gt8USoiIbNtmIVHKUp4PHnol7xUE/M6wcWMLHcnF++2PBJRGEmxLTr7ffc21HpFIhK6urn1eNxGmbCyFw+GKDkVR5IADDuDqq6/mpJNOmvZAGhgfGbVobMAdMbRfJftO0rLxrILRrA0DXbaiSAAl7JctRI3rdxIY1hmzs43KDgTC3hZr8g10YckWozKdQAs79TqxHEdHIe+68DgM1Dpy+QjKyvdgtQPGkEp4F2WBJq9fM5Q6Ojrw+/3TfqhKkkQymSQYDI7JDUuPOHCSQ0BgUfOiGf0NVUU+hSMpkBMEmt2dtAUMOphnYwjpPgqCQJt3Ns2+yUdP9jXXoBhU6XRaqx87kyz3KRtLd99997Q7a2B6yAiKWzhslB6ICp/sBPIkLZbmmpKVOgqGbvyAT1RCGPnS5BRfjcJwSiHvuiQHXgOVxZsDCt+gKEqkCzn8LoskRWRHw5JtBhLe8UYIabw2a4Wd0nIecBlKeAfwodyP+YK15iOqVrn3SE5kWdYMpYnKXE0GkiSRz+fxer1jPsAFrwexpOznHo9nRp6OqkLOgktEFAT8Pp9xlBqhgKsgUBJERJdjSv3ua67L8PmUCER/fz8dHR3TDslNOS1i8eLFDA3tLTAWjUZZvHjxtAbRwMRIi8oGXBaKNAo+QXn4JfNRQ/udELJMWlY2GyOzNgACKmesIFlLdDCaNYHwDrSGRzk5PXELeVJ05F0jCe/6sNOwhYwlQSqSEpRx+dzGFm/1lwnNFksCiOeiALglj8ZRqkVdz7fCoePklNR7xRKQSkiq3eY0UiZGcOBQpfyKUrFm3ZS/25nw0aZsLG3fvn1MMlUul2PPHmsRgesFZVn+1vDESuXVhk9QrPx0wUIbXT5JQr1rjczaAAi5lLBfHmsRmpM55cFsKOEdcAVaCZYLYcYt5H3MRjXR0q6ggcaBzliKZa1jPLpLKS0saSThHSDoUNZMwWKq5omC4h3W8x6N8PI4HC7KveRraBxMFbJUpKSOzDUFkvWMIToom2YlqXbVIqrx3U56Vn73u99pPz/yyCM0NY26c0ulEuvXr2fhwoUzHlADlZBKEklR+aLbm+ca2rfPEQAGyJQstNHpvAYhj7Gn5JCnGeR+yxGaE4UEeAwm74JGaE6KIv3pqLF9T4BMcoCMeo8YpVYNgLdJC8OlLRS6dpVGaylGjORwAUF3GIhZbs2kyoR30dg1I4gORGRKCBRLJbBIebiiNOpxcTuMNJacONSSOCXZgqW1dJj0rJRLjAiCsJdSt8vlYuHChdx4441VHVwDkC0mKapW8ay2BYb2HXCGQIa0lVLDdWJyLUYp76po8rVAGvLi9F25tUCqlAFEYwnvAL4I4ZJEjxP6U1Fj+54Ag3GFzIkMs0IR4zp2OAnIypaaLVjIWCqmjVerVtHkbYbiLvJWM5bKatWiwcV9RScOGUoCFCzkWSqVlLEIgMMo0VIAQdTCW5KF5mMsTHpWJElCkiTmz59Pf3+/9rskSeRyOV5//XU+/OEP13Ksb0sk1SwSpyzTHGo3tO+gJwJARrZQtpNOU8jojb8l0AZAUZRJ5KxjQKZl5UFkZJkCALyj5RuGLORZiqaUUhJuyWEs/wIIqDy/XNE6SQDuUsocwjsQ8SuevZxYRLIKR0eWVcK78bxHBAcOFE9KsYZhp8lg+/btCILAiy++qPGFhH0Ua7/77ruJRCLVG4QgsHtnN8val/HKP/9ZvXZrgCmbkNu2baOtra0WY2lgDGQKCvchJMmG12cLepU09KxgIU+KLgxnWJkCFc2hUYJ9t1UIzZJEijLh3UBNIajI/hqxkOhgVOULuWXjMgPL0DImLVRF3aUzljoMFC0FaAkqa0YWYChtkTkpZEZ5j25jOVyIekJzdYylXbt28e///u/Mnj0bt9vNggUL+OpXvzpmIpYe8+bNo6enh2XLliGpITCBiY2l0047jTfeeKMq4y6j7FuSsYgxPQ4mFYa75ZZbOOecc/B6vdxyyy0TXnv++edXZWANKMgW4uCBgGR8immTvx2ikBYsFEvWCQ52GrzxuwIthEoSCYei0HxAuwVKwORiJNSwpN9g8i6+yCih2ULlLBKFODjAbaRatQolCcBaVdRdOoK3kQrvAKFgG05ZpigI7EkM0x402Ps5FnR7iNGEd0SH5qGoBqF569atHHPMMey///788pe/ZNGiRbzyyit84xvf4I9//CN/+9vfaGnZm7eXz+dxu910dSlJQyVZAgGEffhPfD6flopfLYiCaiyp3CWrYlKepZtvvplUKqX9PN6/73//+7Uc69sSWUlx5ysCkcaiOaikhqdF69zExdSIlulkpFo1UEHgtQxHR+dpa/Ia7FnyhLX5yOQmPsUaiVRB8WAYTngHgi6FA2OlKurFQpK8OKpWbSRE/2iGYF/SIga1bs00e8fWnZJlmXS+OK1/mXxp/PcLMvl8iWxeIpnL7fX+VA2GL3/5y7jdbh599FE+8IEPMH/+fE4++WT+9Kc/sWfPHv7jP/4DgIULF3LNNddw5plnEg6HOeeccyrCcJKsfEePPbKBpUuX4vV6Oe6447jnnnsQBEFTNn9rGO7KK69kxYoV3HvvvSxcuJCmpiZOP/10EonRDOq1a9fy3ve+l0gkQmtrKx/+8IfZsmWL9r6ocnLrwrOklz63lET72wA5VdPHJxtfwbxNzb4rZ+NZASPJPmR1cRma6QTgVTwp3VhIoVl3So6Ms/HXDKJjlNCct8h8AEkpCziMJ7wDYW8zFHaSF6zD80ur/ClBho6AwfeIV0kCGHY46LeKsaSTlhiP95gplDj4ciOKrL9U8durV6/E757cXj88PMwjjzzCtddeu5e3p6urizPOOIMHHniAW2+9FYAbbriByy+/nCuuuGKvtiQkdu/o5qv//hW++tWv8vnPf54XXniBCy+8cJ/j2LJlCw8++CB/+MMfGBkZ4V//9V/5zne+w7XXXgtAKpVizZo1LF++nGQyyeWXX86pp57Kiy++iCiKOATFEVAXxlID5iGv6pOUBSKNRFfrfAByokAsOUyTkZo142AkqZRecUhKmQJDoSc0W0V0MGOSWrUKv3pfZi2kap6Ws0DAcLVqgGZ/C8QgrxKaJ1IWNgpZlT/llpzGj0e3ZgYs440dMY33WE28+eabyLLMQQcdNOb7Bx10ECMjIwwMKHvm8ccfz9e//nXt/e3btys/yDISMr+651cs2m8x119/PQAHHHAAL7/8smb0jAdJkrj77rsJhRSv6mc+8xnWr1+vfe4Tn/hExfV33nkn7e3tvPrqqyxbtkwT6twHt9x0TMpYWrNmzaQbvOmmm6Y9mAb2Rg6F+1AWiDQSHc2zEWQZWRDoG9ppDWMprYR7jFarBsA3Smi2TBV1vVq13+AwHGWF5rx1CM2lAimVY2c44R2V0BxTNv6BdILOoPEG21uRkdRaiiYQ3vVrZthKa8YxMeHd53Lw6tUrp9y0JEkk4glC4dC4hulw/yb6RHDiYWlbZdULn2vqdIvJhu6OPPLIcRqQKOFg25ZtLD98RcVbRx111D7bXbhwoWYogVJ/rVyLDRSj7vLLL+fpp59mcHBQy4rcuXMny5Ytq5gnqxwwxsKkjKUXXnhhUo1Zps5NHSGPkhbudxgfUnA6XQQlmYRDoH94N/svWGH4GN6KRD4GbuPVqgEtDAcQs4rooE53ymjCO0DIGQSGKViF0JyN6ci7xmftBoNtuGSZgiDQHR+2hLGUVXXS3HJ1ibmTgm7NWCVjUkoPa/fIrHEKTwuCMOlwWEXbkkTR7cDvHt+Ll3M78YoSTlmeVh9l7LfffgiCwKZNmzj11FP3en/Tpk00NzfT3q5IzgQC4xSplUqUBMWQns4z3OWqPLgKglAhE/GRj3yEBQsWcMcddzB79mwkSWLZsmXk80qo2imOfr4glfDY2Vh6/PHHaz2OBsZBThVz87sMFk9TEZQEEg4YinWb0v9bkSgkFWMJEzZ+HaE5nbUGobmQGiZphlq1CoXQPGwdQnMF4T1iePeir5lwSWLI6aAnMczhmF9ZPksOEHGZQHjXh+GSGWusmXhyQBP6nRM2OBsOcAgiICEzs8SZ1tZWTjzxRG699Va+9rWvVfCWent7+cUvfsGZZ565bwNILlECFi1ZxFOPbax469lnn53RGIeGhnj99de54447eN/73gfAk08+WXGNKI560wqlIh6nRWTN34IZmXC7du1i165d1RpLA2Mgp6pFB90RU/r3qYHkaGrAlP7filRJDSmI45ySaglRxK/WJ8gVosb3PwaGEqPu7llh4z1LYdUgyVtFi0tHeG/xmeDV0YWdrMLRyapkc8PVqgFcPk32JJu3hjd2SOU9irJAs9f4fUSsIqH5hz/8IblcjpUrV/LEE0+wa9cu1q5dy4knnsicOXP2yTdSBiJREuCTn/0kW954k29+85u88cYb/M///A933303MP2oUXNzM62trfz3f/83mzdv5rHHHtub1qM3lkwW6pwIUzaWisUil112GU1NTSxcuFBLF7z00ktnVNG3gbGRVfkXYZ/xJyAAv5rtFE8PmtL/W5GSFA+G4WrVKgIWIzSXCe8uScTvMj40WVY1z4tFpdaV2dDxUcwgvOvDToMWUTXPCoo6sxmEdwQBvxriyRajxvc/BqIa79EEwjvoCM0zl2RZunQpf//731m8eDH/+q//ypIlSzjnnHM47rjj2Lhx45gaS3tBkpAQmLtgLnf+4l5++9vfsnz5cm677TZNesDjmd7eIooi999/P8899xzLli3ja1/7mkYg1yCMfgdmq5pPhCkHTL/yla/w29/+lu9973scc8wxAGzcuJErr7ySoaEhbrvttqoP8u2MtCgBAk3+jn1eWwt4ZTdQJJmPmtJ/BSSJNHnAi8cZMWUIftEH5ChI1iguHM0OgwBuyQTyLtAcVIRLZQEG03G6xuGAGAZdplNHwISx6LS4hq2QMVnMklJ10nwGF54uQzlgyORLiX1eawTiuRFwmcR7RDWWJJCBkiTNuBbbggULNA/QeNAy33RYuHChQg5PDfJapheAj37kI3z6k6dp11x77bXMnTsXr1dJMDrrrLM466yztPevvPJKrrzyyop2L7jgAi644ALt9xNOOIFXX3214ho9KX3hosVs7f8naUHUyq5YEVM2lu677z7uv/9+Tj75ZO215cuXM2/ePD71qU81jKUqQxGEFGgNd5nSv5KFlyaVt4AnJZ8goWo++TzmeNqCziCQs4xCczwXAy+4TNr4Q6EO3JJMXhTYEx8231jSheGMVqsGKlTNR7JR4/t/K3QcroBJaybg8AMp8hY5YCTySXCBC+MzjAGcDheoNkFBKhlbuHYMyFKJklrm5M47fsJ73nUMra2tPPXUU1x//fWcd955tR1AuQSMUGeeJY/Hw8KFC/d6fdGiRbjd5pxu6xVSqUTCodzEZYFIo+EX/cAw6ZIFUsN1G3/Ia84pOeQOA0OWqaKeKpqnVg1oYadB0UGvBUQHs6khMiYS3vVhuJQVkgCyMS0sGTGB8A7lJIAUeaxRfDpVUow2t2AC7xGF0CwiIyFQKBXxmkxoLkmj9JltW7bwveu+w/DwMPPnz+frX/86l1xySW0HIDi14sLVKAFTK0zZpD3vvPO45ppryOVGHxa5XI5rr7229hbo2wwjidGsjVlt800Zg8+pSBaUtVpMhS5NfrwyBbVGWO3XKgrNyTLh3aSNXx92GkhGzRmDDkPxXu1nUzxLLi9BjdBsvvEoZKPEVW9sqxmEdyDssdaa0XiPokl16mpQTHcmKJZGQ18/+P4P6O7uJpvN8sYbb3DZZZfhdNZYu1p0UK6oJcl1FIZ74YUXWL9+PXPnzuWwww4D4B//+Af5fJ4PfvCDfPzjH9eu/e1vf1u9kb4N0TusZBo6ZZnWcKcpYwi4w1CAjGwBT4rOs9RqBnkXaA60QR7yYoliqYTTYXzNPj3Scg7wm0PehYqw04AFCM3DKZW8W3LgrvUmPw4sRWjWhSVNIbwDTb4WSENetEACkCyrvEcPHpdJa0Z04gAKWCP7q6TyhESzJLQFAVENA0qy+fMxHqa8m0Qikb3ky+fNm1e1ATUwisGRPQAEJRnRpIdyyNuiGEtWSA3XbfxmlSloCXXCCCBATyLKvIg5PBAApBJplfzgdUXMGYNedNAChOZ4dgQcJqlVqwiIXkAiZwVCs06ks90MwjvQEmyHNBRFiVQuR2CamVVVQSFNQo2n+N0mVSQQHDhkGQTBEoTmklwCAQTME5V2qH3L9WQs3XXXXbUYRwNjYDihhBTKOiVmIOxthQRkBPMXtT7TqdOkjT8YaMUjSeREkd7kiLnGko6P4vcYr1YNVIThormoOWPQIZGPgQ9csjnkXSjz/JKWIDQLujUznlp1rdEcbAdVDqw7McxSzyxTxgFU7CFBr0lrV3Ro/BcrcHRKsqQaS+YRzUVBBGRLG0vW1BVvAIBYStlh/JJ5X1MkqEgWpAXzK0IXUyNatfBZIZNOhb5mzZPSmzBZZE+38Yd9JmWh6RSarUBoThTL5F2TCO9ASFXbz2O+qnk6OUjOTMI74Aq0ECop90iP6Wtm1DsdMYn3iOiwFKFZkpXvRhDMoxSIqilSDaHOWmHKT+GhoSG+/OUvc/DBB9PW1kZLS0vFvwaqh4Raf8wnm5ct0RaZDUDKAmZ1LNmPpJUpMOles1IVdb1atVkbv47QnMmZT2hOl4vGisbXUiyjTGguWCBjsqxWLcjQETDpHtGtmX6zkwB0a6bVFzFnDMIowdsKhGZJNVDM9Cw5VENNmmEJmFpiymG4z3zmM2zevJnPfe5zdHZ2Norn1hBlIUgf5vEv2iOKZEHSIZLP53C7zeMbDKsbv0MSiPjMyv6KEJKUBW26QrOe8G5SphOAz0KE5pScB1x4HObNR5O/BVLWIDSP6NSqTUtG8I6WgOlPm2xQZ8wnvFcQms32LMmyZqCIgjkJEQAO0QFydVTNa4Upz85f/vIXnnzySS0TroHaIV1MgAN8oglFY1XMalug/dw3tJN5s5aaNpZoRvG0uSUTdUl02V9DZhOaKwjv5olBBkQfUDJfoblUIKWWB/K5zZuPlkA7pKAoyiRyGUIe89ZvQlWrdplIeNevGdMPGDr5kU4zpCVUlI0lGbONpZI2AtGEMNzdd9/NBRdcQN+2f0IJZGRkWbakE2bKfrcDDzyQTMYa4mL1jrQqnuYTzeNfBPwhvKonpW94j2njAIjnFePErDIFQAWhOW42oTljslq1ioBDMQZMVzXXzYffLPIu0BxqR1DLOXTHzfWkJAqqaKmJhPeKJICsuQa1lB4eXTNm8R4pE5pnnv111llnccopp0z6ekEQePDBB0dfkEqUVMOkXLPODDgco31bQXtqLEzZWLr11lv5j//4D/785z8zNDREPB6v+Fdr/OhHP2LhwoV4vV6OPvponnnmmQmv/9WvfsWBBx6I1+vl0EMP5eGHH654X5ZlLr/8cmbNmoXP5+OEE07gzTffrOWfMGlkJMUoDbhMEk9TESyHnWLmGkvljd+FeSd1vBHCKlk1mTW3uHAhPULCYTLhHQiq96fpCs26NPkmk9SqAZz+Fm3NmE1oTlqA8K6Xl4hnTZ6P5JAm9DvHxDXjECxCaJZK2ggc4uQ9S4VCdUPMDtGpCRcUrFCQewxM2ViKRCLE43GOP/54Ojo6aG5uprm5mUgkQnNzbU+3DzzwAGvWrOGKK67g+eef57DDDmPlypX09/ePef1f//pXPvWpT/G5z32OF154gVNOOYVTTjmFl19+Wbvme9/7Hrfccgu33347Tz/9NIFAgJUrV5LNmp/JkkFRvA2YJZ6mIqBm45WlDMxCqqxWLZrEVwJwugnKynxkTFZoHk6M3vdzmszb+JusotBsBcI7VISd+kwuAZNSD1xuMWTeIDxhzbOUNvmAMaRmGIsytPonSAKQZcinpvevkN7nNWIxj1DIIL/1Wnn6nJ1jjz2W888/n4suuoiWlha6uroqityWy5SdeuqpCIKg/C6XKAnw2B8f4+T3fxCv18vixYu56qqrKBZHyeeCIHDbbbfx0Y9+lEAgwDXXXMPcuXP3qgX7wgsvIIoiO3bsAOCmm27i0EMPJRAIMG/ePL70pS+RTO5dOksQnYgqd6pgAe2psTBlv9sZZ5yBy+XivvvuM5zgfdNNN/GFL3yBs88+G4Dbb7+dhx56iDvvvJOLL754r+t/8IMfsGrVKr7xjW8AcM0117Bu3Tp++MMfcvvttyPLMt///ve59NJL+djHPgbAz372Mzo7O3nwwQc5/fTTDfvbxkJZCDLkMzfL0Cc7gBKJtLkbnVKmwIvHYeLGzyihOVc0t7jwcEohvDslEb/LvNBkk88ihGYrkHdBy/7ag/kcHUWt2o3HaaJ3WhTxo/AMs4WoeeMARtKjvEdxogK2hTT85+wpty8CkUlcFwIOHuuNb3WDe/qHwXvuuYc1a9bw9NNPs3HjRs466yze8573cOKJJ/Lss8/S0dHBXXfdxapVq3A4HCCV+NvfnudbX/4W37nhek4+4SS2bNnCOeecA8AVV1yhtX3llVfyne98h+9///s4nU4ymQz33Xcf5557rnbNL37xC97znvewYIHCdRVFkVtuuYVFixaxdetWvvSlL3HRRRdx6623Vg5cLQFTEqzrWZqysfTyyy/zwgsvcMABB9RiPOMin8/z3HPPVRT1E0WRE044gY0bN475mY0bN7JmzZqK11auXKnFbLdt20Zvby8nnHCC9n5TUxNHH300GzduHNdYyuVyFbXxyuHHQqFQVfdkWigBAmFva9XdnlOBT3YCJWKZIfPGIcukKQBe3I5I1cdRbm8y7foFLwqhOW7q9xJND4OobPxmjqPZ3wopKIkyQ4kYYe/EIZ+pzPVUIKQGNfJuizds3pw4g7pU+RHzxlHMkVL10TzOZlPvkYCgGPO5YszUccQyw+AGt+SuuA9lWUaSJCT1e0OSTEmklyQJpMmH5mRZ1sYOsHz5ci677DIAlixZwg9/+EP+9Kc/8cEPfpDWVoXHFw6H6ehQ9PPkzDD/dcNtfO78z/Hpz3yGkMfHwoULueqqq7j44ou1tgA+9alP8dnPfrbi9xtvvJHt27czf/58JEni/vvv51vf+pY2nvPPP1+7fv78+Vx99dV86Utf4oc//OHo3wvIgqhqTymq5tIk5kBWvXD6v388SJKELMsUCgXFSNRhsvfjlI2lI488kl27dhluLA0ODlIqlejsrKyR1tnZyWuvvTbmZ3p7e8e8vre3V3u//Np414yF6667jquuumqv1x999FH8/upxAxblW2gtpoj1FffiWhkJV8kJ5Ogf2WPaOJyljFamIJumZuNYt27dvsdSFIESmVLS1O9FGumBVnBKblPHsaBvCNEtIwkCD/zx98zxTM7zN5m5ngoWDjylGUs7XnmDh7eZI5Lpyw9qxtKm7a/xcMqc78ZTGPW0ZRKSqfeIs+AAZNKFmKnjyCUHoQUcujXjdDrp6uoimUySz6uhZFmGL2+q2Thc+Sg7RIVW0CF24Sx7uTJFyE7eY10oFCgWi8TjcYrFIgceeGAFd7itrY09e/ZUvJbJZLTf3YUkr7/yBi888yJ3fP8nGm+oVCqRzWbp7e3VnmkHH3xwRTuLFy/mgAMO4K677uJrX/saf/nLX+jv72fVqlXadRs2bODmm2/mzTffJJFIUCwWK9rNZrPIskwilVG0pwRIZzPES5M3VROJfScN5PN5MpkMTzzxREV4ESCdnlxiypSNpa985St89atf5Rvf+AaHHnooLldlGvfy5cun2qTtcMkll1R4rOLxOPPmzeOkk04iHK6eu/vEwomsW7eOE088ca95NhKP3f1fQArBC6tXrzZnELFdbHhAWUDzu5aw+uTqjqNQKEx6rp+4+1agm5KYN28+gN//9zUAeMSAqeMQ/hEl+M8niDscLF1xCMcuWjbh9VOZ66kg/8QrpHcr98jHTljFwkh71dqeErJxnrrn2wAEm73mfTeDb/DQ/yrzsWTuElafaN498uidNwHDSA5z18yvb1c8JV5HSBtHNptl165dBINBvF591uDUeW+yLJNIJAiFQhNSVIS0E7IDyIAv1IbPNT1pB5fLhdPpJBwO43Q6CQQCFc8gl8uFw+GoeM3n82m/l+JJ0qk0X77oy3z+376gEc/L6Ojo0MKVbW1tez3fPv3pT/PAAw9wxRVX8H//93+sXLlS40Zt376d008/nS9+8Ytcd911tLS08OSTT/KFL3wBr9dLOBzG6/UiCALBcBPx4T4AHC7HpJ6jk51rUL5jn8/H+9///rd8x0w6MW3KxtJpp50GwL//+79rrwmCoGkjlGoUb2xra8PhcNDX11fxel9fH11dXWN+pqura8Lry//39fUxa9asimtWrFgx7lg8Hg+eMYpBulyumhg1tWp3svA7g0AfGSlt3jgKyVHyrr+5ZuOYzFw3+Zqh1E1ezJv6vaRKGUDEIwRNHQeBVsKSRNzhYCibmPRYqn1fD6gcLoAFzR24nCalQjuaCZWUEEE2P2zumnGURUtrt2Ymg7C7CRgmL+RMHUdaygIePI6QNo5SqYQgCIiiODGPaRIoh4PK7Y0L0YlDlikKAgW5RGCa/QqCUNHXW/t96/sulwtZlrXf81KRgw49iG2bt3HQAQdO2NdY83PGGWdw2WWX8cILL/Cb3/yG22+/XbvmhRdeQJIkbrrpJu21X//61xVtlV8XRReiGlaTpNKkvodJz7XanyAIY+45k70fp/wNbdu2ba9/W7du1f6vFdxuN0cccQTr16/XXpMkifXr13PMMceM+Zljjjmm4npQXP/l6xctWkRXV1fFNfF4nKeffnrcNt+OCDiVsEpWNjFDUFc01rQyBSrCfiXrMy9OLrZeK6TU78PjNJfwjk+vam6eUOdwSgm7uSQHbrMMJbAOoTmrJ7ybm1EbVqUcCoKJSQCyTErNMPY4I+aNA0B0ag/fooGE5oULF7J+/Xp6e3sZGRmhJBU598Jz+f3//J6rrrqKV155hU2bNnH//fdz6aWXTqq9d7/73Xzuc5+jVCrx0Y9+VHtvv/32o1Ao8F//9V9s3bqVe++9l9tvv33shkSRMpPICiVgxsKUjaUFCxaM+W/evHm89NJLtRijhjVr1nDHHXdwzz33sGnTJs4991xSqZSWHXfmmWdWEMC/+tWvsnbtWm688UZee+01rrzySv7+979z3nnnAYpFesEFF/Dtb3+b3/3ud7z00kuceeaZzJ49e0pCX/WOoCcCQEY2MTW8Qq06Yt44gNaAEt6RBJlY1iQhRkkijbKpeF3mCVIqAxit/TVkYvZXLKuk6Zuq8K7CX86YLJmYManTneowUeEdoDmgkItzYtFQ46ACxSxJNVrjc5tcx1RXTLdoYKr8jTfeyLp165g3bx6HH344JbnEe45/D7f9/FYeffRR3vnOd/Kud72Lm2++Wcto2xfOOOMM/vGPf3Dqqafi841q4B122GHcdNNNfPe732XZsmX84he/4Lrrrhu3Ha2Y7gyFOmuFGR+/Nm/ezJ133sndd9/NwMBATTMdTjvtNAYGBrj88svp7e1lxYoVrF27ViNo79y5s8Id9+53v5v77ruPSy+9lG9961ssXbqUBx98kGXLRjkVF110EalUinPOOYdoNMp73/te1q5du1dc8+2MsK8NMqNSBqZAlxbeafbGH+pA7FEIzXviwzRPpNdSK+Tio2rVHvPUqoEK0cHhTNS0YSTycfCarFatIujwA1ly0t6aMoZBv2aCEfPGAbSEOmEEEKA3GWOuGbpgmdFSJ0ETFd6B0WK6wswUq++++27t5w0bNuz1foVaN/CRj3yEj3zkI9rv0f5NIMD7jn8/nz/tC+P2I0+g/3TuuedWyAfo8bWvfY2vfe1rFa995jOf0X4+66yzOOuss4DREjCS2SVgxsG0jKVMJsOvfvUrfvKTn/DUU0/xvve9j8svv5xTTz212uPbC+edd57mGXorxrpZPvnJT/LJT35y3PYEQeDqq6/m6quvrtYQ6w5hfxsMQ1o0L+QkpYdJiOarVQOIvmZCkkTM4aA3OcIy5hs/CF2Nq5DX5FOyzrOUzJonwpgsqqU9zFSrVuF3BoAsBdk8VfN0aoBsec0Ezb1HgoFWPJJEThTpTQybYyzpvNPNJiq8A6pnSUHJRE9KSS7zfswQSqiEUgJGQpZNVjUfB1Mylp599ll+8pOfcP/997NkyRLOOOMM/vrXv3Lrrbdy8MFjSmw1UAdoDStE+JRoXkXokeSAVsNoTthk40BVaI45HPSlTDIOMhZRqwbwhDRCczpnTro+lAnvDtyiCZ6+tyDsaQKGyAu5fV5bKwyVFd5l6AyafI/4mglLEgOiSE/C/DXT7DN5PkQHDo3QbB5HR0JC8ekYX0T3rXAIDkAyvwTMOJi0Obl8+XI++clP0trayl//+leef/55vv71r1uyOnAD1UV781wAkqKAZBLfYDhZLlMg0LQP0cOaQxd2GkhFzRmD7pTcaqZaNYAgWILQnJIVw8TjMLeWIkCTV00CMLEEzIhKeHdLDpwOkx+GFWvGJGNJz3s0fc2I2sNXMsuzJMtIKm9KFMw3lspjkDHvUD4RJm0svf7667z//e/nuOOOa3iR3mbobJ0HQFEQGEkM7OPq2iCaUTZYz77KFBgBXRX1kYxJ2V8ZC238gF9UFZrNIjRLJdKCckL3uU0mvAMRv8KJyYsl0wjNZcK7S5qehk9V4W3SMiaHLLBmOoLm3yNlc8k8Y2mUHSQKJmaPqigX8pUFmxtLW7du5YADDuDcc89l7ty5XHjhhbzwwgsNz9LbAK3hTpyqy7hncIcpY4hnowC4ZQts/L4I4ZLJhOasnrxr/sYfEBVvX15OmTMAXeaX6YR3oDWslJNAgJ5E1JQxJPKK4WoJY0lXXHjIpDUjpYc1np/ZvEcAUX12mpb9JZWQ1DGIovnGktOheKdloGSiJMt4mLSxNGfOHP7jP/6DzZs3c++999Lb28t73vMeisUid999N2+88UYtx9mAiRAdDgJlHZ1otyljSBYUSXuX7NvHlQbAO6orlMyZE1IopqMkRWWjs8LGH3ApxT9NIzTrjMew2YR3wB9ow6tu+L1Jc+6RZFExXJ0WyA5U1owyH/GsOZ6lZGqIgmoczDab94guVd4sjo5c0jxLTtH8MJxDZ7AVStbTWppWPOP444/n5z//OT09Pfzwhz/kscce48ADD3xblDp5uyIgKZvMULzHlP6TJUXPyC1OvyJ31eAOaMZSxiRC83CiD1nd+OeGzfekKArNkBdMEi7VE97NJu9CRYZgb2LYlCGkJMVwdcjmZwfibdK8scmsOWtmSOU9CjK0+00WcqVMaDbRWJJKlNTAkBWMJVF0IKp8pcIM5BRqhRmRP5qamvjSl77E3//+d55//nmOPfbYKg2rAashICm3SixlDmcpJalq1aL5mxyCQEAwl9A8nFS+B6ckEhij9I7RaFJTsfOiSVpcViK8Q0XYqd8kQnOZ8O7EAgcMp5ugrBb1zZtjPEbTipFmCd4jOo6OWYRmqUhJ1TaygrGklIBRfqwbz9JYWLFiBbfccku1mmvAYvCqKhPxjAmnQlkmrZYp8Los4DUAfIIS2siV9l3xuhaIZZQHjhXUqgEiQUXVPC+WyBdN2Oh0goMdJiu8A+Bt1sJOQ2aUgCkVSAnK6dwhmC+lAOArq5oXzQnDxazEe2Q07CSZRWiWRz1LLgtwlvTaUzMR6qwVzDevG7AFfCjei2QuanznhTRJ9U71uc0POQEEHAp3Ki+bo9AczysPHLdsvlcJoC3Uof1sCkdH51nqsgDhXQnDmZj9pSO8OwULeGOBgGjuAUMjvFuBwwU4dQaKGcaBrPMsucyWlgBV1bxcAqZhLDVgU5Q9KamiCanhuo0/YHaZAhUhp3Jaz5tEaE4WVLVqLEB4B7yBVnyqJ6U7bnyYJZcaImURhXegImMyZoaquY7D5RctwFkCgk4lHJiXzamnmCophHe3YIGwJOBw6AnN0zMOzjrrrGnXMS3pQl2W8yxNMkPwS1/6kiGVQ6BhLDUwSfjUDTdTMiE1XK+8a7ZatYpyceGCSQrNliK8Q0W2U18yanj3w2W1amB2yBqepfJ8pMxIAtCVwwmI1jCoAy7Fw1XAnCSAMuHd47BGWFIQnVox3YIJKt76Ar6OMThcpVIJycgUfh3B20xV8/HQMJYamBQCTmWjy0gmeFL05F1fxPj+x0DEZEKzRni3gFo1UJH91W+CqvlwchAAl+TA67IAJ8XhIqASmrN5cz1LIYc1jKUm9YCRF805YKRkhffoce77wCXLMulCelr/MsXM5K4t5ckXsmSLWRK5JOlCesKCtfvCsccey/nnn89FF11ES0sLXV1dXHnllRXXRKNR/t//+390dnYSmbU/p7zvFJ549M8IgsDdd99NJBLhd7/7HQcffDAej4edO3eSy+W48MILmTNnDoFAgKOPPrqiDmv5c3/4wx844IAD8Pv9/Mu//AvpdJp77rmHhQsX0tzczPnnn09J50Hbq91j3sPTTz4LKMZSud1HHnmEgw46iGAwyKpVq+jpUTKyr7rqKn75y1/yu9/9DkEQEARhzPqw1cKkfG9TIW6ff/750x5MA9aF3x2GPGRkEzY6HXm33QrkXaA50AZZKIgS2ULe2Ae0LJOmAHjxuiLG9TsRTBYdjKp6V1YhvAP4BIVPljWD0KzXnXJYg6MT9jdDAvKCCV6DYo6USqT2ufcdps0UMxx939G1HtVeePrfnsbvmn7Y9J577mHNmjU8/fTTbNy4kbPOOov3vOc9nHjiiUiSxMknn0wikeDnP/85HRGRJ998TcvKA0in03z3u9/lJz/5Ca2trXR0dHDeeefx6quvcv/99zN79mz+93//l1WrVvHSSy+xdOlS7XO33HIL999/P4lEgo9//OOceuqpRCIRHn74YbZu3conPvEJ3vOe93DaaacBjNnuv/3bl/jtn/+X/ZccpLV7ww03cO+99yKKIp/+9Ke58MIL+cUvfsHXv/51XnrpJdLpNHfffTcALS21C8FPyli6+eabJ9WYIAgNY6lOEfK2KsaSYIInJWutMgUALaEOUKMr3YkRFrd0Gtd5PkmiTHj3tBnX70Tw6lXNjTcOkrkYeKxDeAcIil6gSL5kQhJANkpCXTNNFvEstQbaIQElUSaaSRHxGRhCzsZGw5IW4T3WAsuXL+eKK64AYOnSpfzwhz9k/fr1nHjiifzpT3/imWeeYdOmTey///5E+zfhXNSFU9ZxpwoFbr31Vg477DAAdu7cyV133cXOnTuZPXs2ABdeeCFr167lrrvu4j//8z+1z912220sWbIEgH/5l3/h3nvvpa+vj2AwyMEHH8xxxx3H448/zmmnnTZuu7//3a/531/+Lxddur/W7u233661e95553H11VcDEAwG8Xq9lEolurq6aj21kzOWtm3bVutxNGBxNPnbIA4ZwfgsBSk9rBlLs6zAR0EhNPslibQo0pMYNtZY0odYvNaYD32hVDMIzYlCUjGWBGuQmQECzgAQM6UETCY5SEa9RyIuaxhLzaEOxB4ZSRDYEx821ljSrZlyCH0i+Jw+nv63p6fcjSRJJBIJQqHQvrWcSgX2DL9BXBQJOVuZ29SBzzmz7+qtwtCzZs2iv1/h87344ovMnTuX/fdXDJGSKoYpCKPjdLvdFW289NJLlEol7TNl5HI5WltHjU6/368ZNACdnZ0sXLiQYDBY8Vp5LBO162uJIMnSmO3q/x6jYQEKfAN2QHNQSQ1Pi8arzcYSA5RUteo5FlCrBsCnEJrTomg8oVlH3m2xCIdLXyg1bYJCc6qUBkTcojXIuwBBVwiIkTeB0DxYJrzL0OSwhrdN9LcQkiRiDgd9yREO6ZxnXOdT5D0KgjCtcJgkSRSdRfwu/76NJUeJgNNDXnTgdrhnFH4rw+WqDEMLgqCRtH2+SkNMkmVAQGA0DOfz+SrqvSaTSRwOB8899xyOt8gL6A2hsfqdaCzjtZsY2ko86NFUzcdqYya8rplgWsbS7t27+d3vfsfOnTvJ5/MV7910001VGVgD1kJbRHGVJk1ICRhSVcNFWaDZa5XsL4XQ3AcMGK3QnNFv/NbIDsThJCArm17GBEJzWs4BPjwOa2gKAYS9ESjupiDm93lttTGSUgjvbsmB0wJq1YC2ZsrGkqHQrZk2Kyi8AwgiovrcNyL7a/ny5ezevZs33niD/fffHwkJcCAK42ssHX744ZRKJfr7+3nf+95XtbGM124iIrOT/KQNIrfbTTxujJzNlI2l9evX89GPfpTFixfz2muvsWzZMrZv344sy7zjHe+oxRgbsAC6WuYDkBFF0tkUfgONlmha0e3xSE5LlCkAKjg6g+mosX3rTsntAYuE4QC/qtBsOKFZkkhRAHz4XNaZj2ZfCyQgJxaRJMnQezeWHQHROmrVQEWodsDojEkL8h4RBERVFFKapK7QTPCBD3yA97///XziE5/gphtuINRc4sWtO/E6giz55IIxP7P//vtzxhlncOaZZ3LjjTdy+OGHMzAwwPr161m+fDkf+tCHpjWW8dr94+9/RftBizj2pA9Mqp158+bx+OOP8/rrr9Pa2kpTU9Ne3qhqYcqr95JLLuHCCy/kpZdewuv18pvf/IZdu3bxgQ98gE9+8pO1GGMDFkBn63zt596B7Yb2XebAuCQLbfy+UV2hkazBQp26U3KnVTZ+wK8SiQuSwYTmXJyEGpb0WYi8Ww5dS4JMLGusEGNZrdpKhHf9mhnOGmxQZyym8K5CVB/BMsZwQX/zm9/wzne+k0+dcQbHfuDj3HT1Tcj7YFbcddddnHnmmXz961/ngAMO4JRTTuHZZ59l/vz5E39wHxir3RdefJlZc2chw6S8S5/97GfZf//9OfLII2lvb+epp56a0ZgmwpQ9S5s2beKXv/yl8mGnk0wmQzAY5Oqrr+ZjH/sY5557btUH2YD5cLs9BCSJlCjSN7KLxfMOMazvZCEBLuuoVQOmEpqL6REt08kqhHeAoMMPxMgZrdCsU3hv8lpAvVtFJNiGQ5YpqYTmZr9xfKpksaxWbR3CO94mXcZk1NCuE8kB8mKZ92ide0QUREDSCM1TRTllHhhTY+jBBx+s+L2lpYU777wTChl2jGwmKYpE3EpyyllnncVZZ521Vxsul4urrrqKq666aswxjPW5K6+8ci+NJ/1Yx2u3FO/hNbXQ8hmf+Qxnn312xWdOOeWUCiOqra2NRx55xBCv7ZR7CAQCGk9p1qxZbNmyRXtvcHCweiNrwHIIqoef4Xivof1qatVW2/hVYymdNba8x0iiH9lqhHcg5FIEMguCwYTmrD7TySIcLhRCc/keMbpeXkpTeLcO4V1/wEgafMAYSiqEd0GGjoB17hGHUPYsGZw4I40W0XVMwFkyGg6HE8FEVfOJMGXP0rve9S6efPJJDjroIFavXq0JQ/32t7/lXe96Vy3G2IBF4FMViUcSfYb2q5QpcFuKvIvowK/qk2QLxhpLwyrh3SkJhDzW8baFvBEo7iIvGExotiJ5F7Sw04jDQZ/BSQAK4d1vHYV3AHeAoOoUSBtcAmYkpfTnthLvkbKhUjTeWJJL1iqiW4bgwCFDUZh+vbxaYcrG0k033UQyqXASrrrqKpLJJA888ABLly5tZMLVORTjoEgsY6wHMS3nATceZ8TQfveFgKrQnDO4uHCZ8G4ltWqAZn8rxJUSMIYSmvXkXb91wpJ676OhhGapREpVyfZaiPCOIBBAuWezhaihXcezI+CwGOEdFPVsCWTB4HR4nWfJaYUiumWIThTzsQ48S4sXL9Z+DgQC3H777VUdUAPWhU92AUVjXeiFLEk1v9bvsQ7XAMAveoECeYMJzfFcFNwWI+8CLcF2iIMkwEg2RavfIE+grhyOlQjv+uLCI0aqmus4XH6rKLyr8AlK6ZV8ydgDRiIfBx+4ZWuUfinDIToVYwlF90jUaRzVErJURLKiZ0krpitQkmzuWSojn8/T39+/V1XimTLkG7AuvIIHyJAqmLPxW61MQcAZBEbIG0xoThYSirFkJcI7EA6245RlioLAnviQYcZSIT1MUr1HZluIvIsvYg6hWV8XzhcB42WexkXA4QfShquaT4bw/tZnmRFwOlyKGwUolIp4nMZ4i0ulImVflttKniU1DIcAxSoaS9X4bqc8S2+88Qaf+9zn+Otf/1rxuizLCIJQUVW4gfqCX/QDUdIFAz0p2amVKTASYXcIGCFvMKF5lLxrEYFOFaK/mbAkMexw0JMYYXnXQkP6HdQlHMwKW8mzNBqGSxrJ0dFxuFo8TZYylkLOAIqxlDG0X4X36MQj7m3Au91uRFGku7ub9vZ23G53hYr1VCBJEvl8nmw2O7kwdEGGQgkJgWQ6jew2xlucy2Y0A6KQz1M0yKO1T5QKyAUZSZTISVmy2fH31snMtSzL5PN5BgYGEEURt3v6YdgpG0tnn302TqeTP/zhD8yaNWvaN1UD9oPPoTycM0Z6UjKjBUEnU6bASIQ9zVDcaTihOSVlAY+1yLughZ2GHQ5DOTpltWqXJOJ3WSg06fJrhOZMzsDQta4cTqs/AgnrcD+CnggwQF7IGdqvwnt04nHunQkniiKLFi2ip6eH7u7uGfUjyzKZTGavsiHjIp9mIB+lBOQ9JcPu31xqgCG5gICAM2ohz5IsE0v0kRJF3EKCfGD8g/lU5trv9zN//vwZ8SinPEsvvvgizz33HAceeOC0O23Angi6w1CEjGygJyVr0UwnIBJogRjkjVRolmVVrdqDx2WdFGhgVEfHZSyhOaqGuKxGeEcQ8KOqmhtJaNaFrjsCEcA6ki4RbwSykDeyBEypSEotAO5zj+15dLvdzJ8/n2KxOKPoSKFQ4IknnuD973//5JSkd2zkxn98m50uF5/e7yL+df/3TrvvqeBvv/5PvuvoI1D08ctPPmBIn5PFvT87h1+F/CxyrOAHH7163OsmO9cOhwOn0zljx86UjaWDDz64oaf0NkXQ0wJFSBvp17cqeRdoC3ZADGQBepNRY/gyhcwo4d1tLQ4XvlEdncG0cZ6URD6qEt6tRd4FCApeQCZrJKE5U1naY9hCxlJLsB2yUBAl0oWcMZ6UCt7j+IT3cvHXmZTLcDgcFItFvF7v5NoJhimmd9Pj87I7PYDXa8w9HEtuo8cXo63QZlifk4WYHaTH48ItRSYc25TneqbjmuoHvvvd73LRRRexYcMGhoaGiMfjFf8aqF9E/Er5hrRgnFtfyoyMlikIWYi8C4RCHXhU42BP3CCtJZ2nLWgxwjveCE1aCZioYd0mVA6dW7AW4R3KquYYmjGZTQ2RKRPerXbACHVqP++JGbhmHGWFd2vNh37NDBmYBGBJhXcVAVFZx3kpYfJIKjFlz9IJJ5wAwAc/+MGK1xsE7/pHS7gLBiAlGpc1Ek8MaOTDORYzlvA20SRJ9Isi3fEhYL/a96nztLVYjMOFt4kmNfsrkTXOm6ER3gVrEd4BQq4gkCKPcYTmQZ1obFcwwsuG9bxvuPzNhEoSCYfInvgQS9tm1b7TTJS4Wuqk1We10PWosRQ1UJIlLWUAl7WEflWEHH4gbnzZpH1gysbS448/Xotx7BPDw8N85Stf4fe//z2iKPKJT3yCH/zgBwSDY8v5Dw8Pc8UVV/Doo4+yc+dO2tvbOeWUU7jmmmtoahpdMGPFMX/5y19y+umn1+xvsSs6mucBkDRQALdcpkCUodXA2lqTgk/Z6PqBvpTxniWrEd5x+QiboNCclrOA13qEdyDiiYDcR040jtA8klQU3t0lB26nhci7AL4IEalEwiHSmzRqzYxYlveIt4mIesBIGSj2qxDeXXjHILybjSZ3ExAnLxibMbkvTHklfeADH6jFOPaJM844g56eHtatW0ehUODss8/mnHPO4b777hvz+u7ubrq7u7nhhhs4+OCD2bFjB1/84hfp7u7m17/+dcW1d911F6tWrdJ+j0QitfxTbIuu1kUApEWRVDpBwAAdnZF0uUyBy1JlCgDlVFgqKzQbdCrU8VHaAxFj+pwsBIFAmdBcjBrTpyyTlguAF68rYkyfU0CLvwVSkDNQ1TyWjYIAbtlihHfQPCm7wDhjqWLNWCwM53ASQBGFNKxsUjFPUo0O+NwW89YDEV8ECiaUTdoHpmws/fOf/xzzdUEQ8Hq9zJ8/H4+nuqS9TZs2sXbtWp599lmOPPJIAP7rv/6L1atXc8MNNzB79uy9PrNs2TJ+85vfaL8vWbKEa6+9lk9/+tMUi0WcuhNXJBKhq6urqmOuR8xqm4cgy8iCwJ6BLey/YEXN+4xno+C0XpkCQAvDAQxlDDKWdJ4lqxHeAYKiQmjOlQziG+STJByKd9jvsRiHC2gNdUBKKWcxkE7QGaz9ST6ei4LXmoR3fajWsCQA3ZqZFbLgmkF5XmaKBon96nmPPmspvAO0+NuULGNHiWwhj9dljb1/ysbSihUrJkzBc7lcnHbaafz4xz+uGst+48aNRCIRzVAChTsliiJPP/00p5566qTaicVihMPhCkMJ4Mtf/jKf//znWbx4MV/84hc5++yzJ/wbc7kcudyoW71MbC8UChQKhan8aROi3FY125wpQpJM3CGwp387i2YfUvP+koW4aix5azoP05prZ2DUWEqPGPI9yYlBTXeqzRe21L0BEHQEgCR5OTXu2Kp6XyeHRjd+T7Pl5sPnbcYtyeRFgR3DfbR4ak+oTWjkXZ/19hBXUMuYNGrNZOL95LTagbVdM9OZ74DDh1I2KWHM95Qc1NZMyN1knXtDRbO/FVS7cftwP0taOse8rlr39mQ/P2Vj6X//93/55je/yTe+8Q2OOuooAJ555hluvPFGrrjiCorFIhdffDGXXnopN9xww1SbHxO9vb10dHRUDtzppKWlhd7e3nE+VYnBwUGuueYazjnnnIrXr776ao4//nj8fj+PPvooX/rSl0gmk5x//vnjtnXddddx1VVX7fX6o48+it9f/c1w3bp1VW9zughKEHfA3198knh37QVJo+ko+ATEkpuHH3645v1NZa5FqaCdkvsGtxkyvll7nkEKKPP+6t/+zjbHP2re51TgzgkQgByZfc5HNe7rcGantvHH+mKGfAdTwfyhPTTJJQZEJ3/8y3p6gnt7wauNeD4BuKDg1ubYKnuIq5jSDhg7erYY8n217HoeQiDI8Oyfn8JpQCh0KvPtyDuAAjk5bch8NKc2a2sm2j1ouTWzuL+foFMiKYr83/q1HBhon/D6md7b6fTkiORTNpauvfZafvCDH7By5UrttUMPPZS5c+dy2WWX8cwzzxAIBPj617++T2Pp4osv5rvf/e6E12zatGmqQ9wL8XicD33oQxx88MFceeWVFe9ddtll2s+HH344qVSK66+/fkJj6ZJLLmHNmjUV7c+bN4+TTjqJcLh6JNNCocC6des48cQTDdGRmAzuvusyQKa53c/q1atr399tFwNO/O7mmvY33bnu+dE3AHB5i4bMx5YH/whpcEgCn/jIx2re31Tx+gP3Q+llCo78uPNRzfta2PEUtz2mbPxHHLSc1e+s/XcwFQivQ9PGhxgAZu23gNXvOLHmff74tq8DLkK+Nk488URr7SGyxJZbL/n/7Z15eBzVma/f6kW9S63WLm/yAtgGgwkOjoGsNtiYhCVMMiQOhIRAwnKBwEwGbgIECHvCzJgwkEACJJhhQu7AAJMQDA5riAGDCYvjfZEta1cv6la3eqn7R1WXWtiWW+qq7q72eZ/Hz2Opq6pPH9U5/dU5v+/3AeD0ZIoyZj544veQhKqMjdO/+EVD32si9/b6Vb8GtpGyJIrSH9KWF7jrNWXMHH/UJ1g+//OGv+d4kD6IUrNuDYMWC1PmzGL5USfu9zi95pF8LY/GHSy9//77TJs2bZ/fT5s2jffffx9Qtur27t170GtdffXVnH/++WMeM2PGDJqbm+nu7h71+1QqRX9//0G1RpFIhGXLluHz+XjyyScP2qkLFy7k5ptvJpFIHFB75XA49vtaoYZmB8Ko604Ej2wHhgkn+ovSpmyZAqe9pijvN96+9mhV1ENFaV9ITS92ZMrnnsil3tcIQUha0iTJjGk6qMt9nRwc0XD56sqvT7z1IxqdeBHukUyGmFqZ1VVVq71fOc0hXknRoCRSA0VpUzgRBIuieyxWH4ynv+vc9TC0jYQ1idVqNT4JIDmo2Y+01tSXzX2h4W2gJpNmDzb68hgzhd7b+Z477mBp9uzZ3H777fzyl7/UitIlk0luv/12rQTKnj17aGra/z5jLg0NDTQ0jL3EBrBo0SKCwSDr1q3juOOOA2DNmjVkMhkWLlx4wPPC4TBLly7F4XDw9NNP56WhWr9+PbW1tbqL1CsFl+QAhhlMFCFzI53MKVNQflkbkNXoJEjIxTEdjCSCYIcquTzvz7rqZggq/98T6jfeRydHrNpchoJ33IHimg4OR4ionkLuMdyqS4liOiiTKJKreWQ4rArey3PM1PuaYAgykkxfbJAGr7EWGJlYf9ka/QLgGhkz3cXKMs6DcQdL9957L6effjqTJ0/m6KOPBpTVpnQ6zbPPPgvAtm3buOSSS3Rr5Jw5c1i2bBkXXngh999/P8lkkssuu4xzzjlHy4Tbs2cPixcv5je/+Q3HH3884XCYU045hVgsxqOPPjrKYbyhoQGr1cozzzxDV1cXn/rUp3A6naxevZpbb72Vf/qnf9Kt7ZWGW3IDEQZTRZjo4iHtCchbphO/r8oHJEhSHAO1SDKiBEuUYaYTYPfUF9V0MBntI2LNZjqV98QfLIareU6afLWrDPsD8Nm8QIRhOVqU9xtMZR3ey8+tGsDra8LeJZOUJHaH+wwPliKDZWz0C+Cu1VZj+4tYCeBgjDtYOuGEE9i+fTurVq1i06ZNAHzlK1/h61//Oj6f4rtz7rnn6ttKYNWqVVx22WUsXrxYM6VcuXKl9noymWTjxo2aWOudd95h7dq1AMyaNdpZefv27bS1tWG327n33nv5/ve/jyzLzJo1i7vvvpsLL7xQ9/ZXCm6bF+gili7CRJcz8fvLrUyBSrWjFugtWhV1za3aUn5u1QC4aqkpoulgf2Rke35STRlO/K6RiT9aDFfznJW2gLP8DAcBfFXVQISkVJyC3NH0EGDFYSkzU1sViztATTpDr81KR6SPY5lu6Pv1DSoO72Vp9AvqHJKtBFAk76k8mJC9q8/n43vf+57ebRmTQCBwQANKgLa2NmRZ1n7+3Oc+N+rn/bFs2bJRZpSCg+O110AahjJFcFfNmfhry61MgUqdpw6im4tmOhjNxAE7Dkv5lSkAtG2n3UD3oPFL6H1Rxa3alrEUpyjreLFVaaaDQ8NFcDXPKRpbdm7VKn5XAJJ7ivaAoegeXTjK0K0aUMdMml6sdEWMDw4GYsp7lKXRL4Cjhuq08t0dS5RPEei8gqWnn36aU089FbvdztNPPz3msaeffrouDROUJ9WOAMQgVgx31Vzn3TKd+Ot8zUU1HYyilClwlKFbNQCuWq18Q3fM+Ik/pL6HI1NmItUcfKrpYKIYpoM5tQPLzq1apd6jJAEUxXQwkyEqjQjey5KclZTuIhh1huNBsIKjHI1+ASwWLQkgnjSZZunMM8/UvI7OPPPMAx4nCulWPjWeBjVYKoKRWc7KUmM5incBr7dBMx1sD/YYGyylEkQlZVJ1l6ngHVdAMx3sL4KgOZwIQVX5incBPDYvECchF8HVvNwF70BtbhJAuJ+ZdQZWT0iEcgTvB08mKgmuQFFdzSPDYXCBvRwd3lWKnQSQD3mtwWUyGc0UMpPJHPCfCJQqn1qvMrFlv7SNJBMb0J6Sy1K8C1jcddRklPt+r9FL6DkrbZ4yLFMAfExvYPy2UySlBCBVksvw95ooPruiC0kWoYp6PNpHTL1HWst0zDg8dfjU4GBP2OB7JGfM1JSp7jF3zAwUQdA8mM46vJen4B3Aa1M0mcNFyjLOhzLcsBSUMw21kwGIWI1/r8HBXpJq1kZrdXlO/Lmp4Z1Ga3RyNVxOv7HvNVEcPqozit5gKGF8sBRNqYJ3qUwF70CNQ/mSLoZGpy/cpf2/nMdMdvXR8AeM+Mi2ZKBMdY+5wVIs3mP420VVvWnZ6h5RyrAADBcpCSAf8g6W3njjDc0aIMtvfvMbpk+fTmNjIxdddNGoemmCyqSlrg2AmMVCLG5sRlw2a0OSocFdpgM7Zwm9x2iNTo4epa5MNVxIEm5VoxNPGb+lEJOVOcdhNTbduhD8bqXAb8KqJAEYSb8qeK/KWKmyTSh/x3jUjEmA7mjxVmPLVfeIrQqvnE0CMF7npwjewVmugnegVrW9KFYSQD7kHSzddNNNfPjhh9rP77//PhdccAFLlizhmmuu4ZlnnuG2224zpJGC8qGlfhqSmmXY0b3d0PcaiCqZEI6MrTyzNmDUU6HhpoM5K0sNHr+x71UAPouyJWa43kCWiaFO/PbynfgbfcrWddZ00EjCQyOZTmWLKzCSBGC06WCu7rFMBe8wUgnA8CSAdIooqtGvo3z7I6DWgxu2phlOpUrcGoW8v4HWr1/P4sWLtZ8ff/xxFi5cyAMPPMBVV13FypUr+d3vfmdIIwXlQ1WVA6+6zdLZv8vQ9wqp+/dV5Zq1AaO24YJxgyf+nKfkpjKe+L02RaNjuOlgcoiIWsvZ7agz9r0KwOtrxK4+YOw2WKMTTigBajkL3nPHjOGmgzljpizdqlWUSgAwbHQSQI7Rr6dMjX4B6qpHzGw7wuXhtZR3sDQwMDCqhMnLL7/Mqaeeqv38yU9+kvb2dn1bJyhLvBnlG6p3wNi/dySpinfLOGsDp3/EdHDIWL1BZmiAiKW8Be8A1ZrewGAvLhM4vANYPHXaPdIRMTZYimTdqilfwTuuWk2zFBkytj9i0T7iJhgzPrsiM0gYnQQQzzX6Ld/+cHrq8Kj3SHuoPLyW8g6Wmpqa2L5d2XYZHh7mnXfe4VOf+pT2eiQSKb+CfAJD8GSU26Z/sOsgRxZGuZcpAMBqw6s6cAwljX0CGoh0k86WKShX8S5Q41JWeYaN9uLKdat2+Y19r0JwBTSNjtGmgyMO72XozJylyku1Kt2KDRv7Rdgb6VT+I0OzwR5ohVDt8ANFEDSbwOgXUFYf1QeMvUWoBJAPeQdLy5cv55prruHVV1/l2muvxe128+lPf1p7/W9/+xszZ840pJGC8sItK0Fx2OCVlFi6/LM2ANxF0hv0DSqlPawZCb+rfLO/6rwjeoN40sCAKWeLpWwF71BU08Gs4N1pK1/BO5KEB2VrPWGw6eDAoLJy5chYsVmLkMI7QWrdysrosMXgJAAzCN6hLIvp5h0s3XzzzdhsNj772c/ywAMP8MADD1BVNaIl+fWvf80pp5xiSCMF5YVbUvQQkYSxN3FUFe+WbZkCFc0TJGOseDcYy078ZZrlpFJXPWIyuMdIvUHcJBO/u0img6ME7+WraQPwWpTV4rjBSQAhtbZYWesegQY1CSBtkQnFDdyKM4HRLzAqY7IYRp35kPesW19fzyuvvEIoFMLr9WL9WJT+xBNP4PWW8dKvQDfckguIEE0aONFl0sRQyxSUcdYGZPUGQwxjrN4gHA+CrczFu4DD24AvnSFitbAn3GecQ3Ou4L3sJ/4iJAEMR3PcqstX8A7ZB4yw4UkAkUQYnGWuewSqfQ3YOmVSkkR7uJdagwrcmsHoFxj1gNFXJsHSuPOxa2pq9gmUQCl0m7vSJKhc3Gq2UzRtYOZGbtaGo3zFu5BjOmgx1hNkUA1OqyjviT9XwGuk6WAq1s+gGhyU9cTv9BfHdDBn1cBX5sFSsTQ6g+ms7rGMBe+AxVOvBQe7Q8aJ3k1h9AujHjDCRagEkA9lal4jKGc86rZYTDZwohsaGClT4CrjVQNGPEESBusNoinlKdxuKV+9EqBVUQdjTQf7Q3uR1Yl/cnUZBwdWGx5ZTQIw0nQw1m8OwTsjmVhGmw6OCN7LW/eYGxx0GSho7lMF72Vt9AtQ5cWnTqVDCeNdzfNBBEuCceNTaywNyQZOdLG+EfFumU/8DT7FUsNo08FoRpn4Hdby1nDlTvy9saBhb5PNxrRlLHgc5b01mTUdjBuZBJA7ZspZwwXUeotjOhjLKA905a57zH3A6DFQ0BxUk0TK2ugXQJLwSspO1VAyWNq2qJRxbwnKFb9bKaockwx0Vs2Z+OvLfOIviumgLDMkZwXv5b3SluvQ3Dtk3MQfiilp52XtVq3iyxp1Zgzcuo71aVvXjWXs8A7QUDNiOmjYmEkliKpzlKOqjFceYVTZpF4DKwGEVcG7vcx1jwAe1TJm2OhKAHkigiXBuKlVMzeiFgNTXHOCpbLO2mC03sAw08F4iIg6Wp1l7FYNjCqUOmigvUREFUvby1y8C+Czq8GSkUkAOdtwzWU+ZhyeerzqPbLHKI1OTn94ylzDNSoJYMi4bbhIIgiAXS5vDReMVAJIGF0JIE9EsCQYNw3+SQBErLJxb5ITLJX7xI+rFr+6hN5pVLCU0x/ZbdCyxe7Cp7q8xxIGilVVwbu9nE1LVaodxmt0hge7iZrArRoojulgzpjxO/3GvIdeuEaSAAbj3Ya9TTRr9FvuukegukrxCjO8EkCeiGBJMG6a69oAiFosxOLGRP2DkS6GLeXvVg2Aa2QlpTsaNOY9cp6Sa51lrr8APKoXVzwVNOw9omlV8C6Vv2VJrUdZ2TAyCaA/vFf7f6uvzAPqnIxJw0wHc7YlA+UeLFmseFSz3/iwcVvXMVX3aLeWsWmpSo0r+4BhcCWAPBHBkmDctNRP1f7f2bPDkPfoDSkTvyRDo6fMgwPXSH24PqM0OrE+QlZzCN4BPKrpYMIovYEsa9mYZS/eBepzTAcHDHrA6FfFu7aMFae9zG1cXLmCZuNXlspd9wjgsWSTAILGvEE6SVT1rit73SNQ51W0sQlLytAkgHwRwZJg3DgdbnxqcNDZv8uQ9+iNKVoXR6aqvLM2YFQVdcP0BrE+BiyKv1mrr7x9pwCqsxodo/QGiQhB9bZwOxqMeQ8dqfE1YlOTANoN0uj0q/eeI1P+Gi5ctVoSQJ9RguZYH/2qJ+Ck6vIfMz6r+oAhG5RRG+tnQCs83WjMe+hIfbYSgASdg6U3pizzbyFBueJVNSk9wT2GXD+kinerMuUvRMRRQ3VG+SI0zHQw1qdNdFNqyj848FUpqz2G6Q1ifQQ1H67y749RSQAGZX+FhoMAOCh/PUruA0bEoCSA1GAvIfUemeYv/+DAa1e2xpKyQUkAsT4G1OAx4CpzwTvg8jbgzhhv1JkvIlgSTAi3rNw6/ZG9BzlyYoRSSoq1wwR6FCwWvKrewCjTwWiki5g68U81wcTvVyfjhFF6g1i/tmpQ7yxzTRuMKgxqlOlgWNVwVUllbDaYxe7CKysPXEOJXkPeoj+8l7RqWjrVX/4rSzXqfZwwytU81seAVkvRBGMmJ6A2LAlgHIhgSTAh3KojcShmzFNhOGvAaPEbcn290fQGaWNMB7vDWeddiVaf35D30JOAqjcwzHRwqJ9g1lPIW/5PybmFQQ0xHZRlIqqGy2UCPQqAB2OTAHpV01J7xorPUf4r1LXukSQAQ8hZnW4xxZgZyZg0LMt4HIhgSTAh3OpEN5gwYOJPpxhUDRhdVSZ4AgK8VmXrYzhjjN6gL6pquNIm0HCRozfAINPBHA2XKSZ+d6028fcYkQSQjBGyKFvBLhNouAA8FiWAMSoJoG9Iue+qzKDhAurUSgBpi0xwyACtX842XIsJdI/FqgSQL+U/6wrKErdamDKaNGAlJR7UnoA8JhAiAviyniAGmQ4OJFTxrgnM5ACc3gZjTQdjffSbSMM12nTQ2OCxxmmC/gB8NmW70CjTwdCwMjc55PL34QKo9TVpSQBGaHTMpuFSvLiU1VjDsozHgQiWBBPCY1W0RNG0ASspOU9AteXuvKtS7VC2PowyHQwnFQ1XlWQC8S4owYGBpoOD4S6GTKThGpUEYISgOWeLpd5ljtXYakc2CcAYjU5YNWB0lHsRXRWLp17zntpjwLZTf7jDVBqu3AcMo5IAxoMIlgQTwmNXJrpYxoBspxwhYqPHHMFSnVoYNG41xnQwq+FyWv26X9sQ3AFDTQe7Qx0AWEyi4cJi0UwHh5IGPCXnBEum0HABfs100JgHjIiszE1OmzmCx1EPGAZsXXerPlxm0XApSQDKPT1kYCWAfBHBkmBCeNWVlJgRE12sTxPvmkKPAtR7Fb1BRjLAdDCTJpLVcNlNNPGrgubemP7BQV/MXBouGEkCSKQM2LqO9RM0kQ8XjCQBJCwGJAEMxwirGi6PSTRcuEdWUnoMGDMDauFpU/hwqXhQzFWHkiIbTmBSatzKBBSTDMh0yjGTM4UQEaiubjLOdDAeImhVls89jiZ9r20UuVXUY/pPdFkNV5UJiuhmySYBJOSI/hfP0XBNNoEBI4w2HewI63yP5Gi4fCbRcBktaA4mlWtWmUTDBeA1OAlgPIhgSTAhAr4WAGKS/ltOqcE+cwkRAYunzjjTwVgfwayZnMccX4RKcWG1MKgBeoOshssUPlwq1arp4LABpoOD4U5Nw9VWa44x4/I24jFKozM04lZdbwZPIVAfMJTV2GBc/22nSErdyjeJhgtykwAMMuocB6YJlvr7+1mxYgXV1dX4/X4uuOACBgfHFhd/7nOfQ5KkUf++973vjTpm165dnHbaabjdbhobG/nnf/5nUmVQh6bcafBPAmBQXerWkz6zCRFBDQ6UiU5308FYH/1ZMzmXOTx0sFXhlZUAzwi9QSSt+nBZy78uXJZq9W+XMGDrOlfD1ez16359Q3AHcjQ6BqwsWc2le8RZQ7X67GlEEkBY03CZZA4BfA71AcOoSgDjwFbqBuTLihUr2Lt3L6tXryaZTPKtb32Liy66iMcee2zM8y688EJuuukm7We3e2QJMp1Oc9ppp9Hc3Mxf/vIX9u7dy3nnnYfdbufWW2817LNUAs0BpZhuxGpheDhBVZVDt2t3RxQDRtMIEWGUQ7PupoOjNFwmCR4Bt5Q1HdS5PzIZInICcOC2m+SLEAi46yFijOngiIbLbhoNV3bbqQPo0ruYrgk1XEgSHvUrWfdKAMk4YUl5mHNXmWRbErUSQGInw0ZVAhgHphhVGzZs4LnnnuPBBx9k4cKFnHTSSdxzzz08/vjjdHR0jHmu2+2mublZ+1ddXa299vzzz/PRRx/x6KOPMn/+fE499VRuvvlm7r33XoaHS//HKWdaG6dr/9/Ts13Xaw+oPjSOjH4BmOG4aqk2ynQwx0qh1SR6FMjVG+is0UnkarjMseUEUOdTNDpGmA4OqLUUzeLDBYBrJGNSd42OCTVcMGLUqbur+dBI8OhzmWfMBDxKYJewpEipW5SlwhQrS2+88QZ+v58FCxZov1uyZAkWi4W1a9dy1llnHfDcVatW8eijj9Lc3MyXvvQlrrvuOm116Y033mDevHk0NY2IZpcuXcrFF1/Mhx9+yLHHHrvfayYSCRKJkaX0cFgRnyWTSZJJ/Z4as9fS85p6YbXY8WQyRC0W9nRtY3LjTN2uHUwMgE0xkyvWZy+4r+2+EdPBaI+u7ZZDXVrR2FZvoCzvh/3hsXmBfhLy4Kg2F9zX4S5Nw+V31ZmmP6o99dhkmZQksa23k3nNU3W7digZAidUSV59+9pI7F5No9Oj85iJBTs0DddkX/HGTKH97bG4gSiJTETfNoe7tOAx4Kwtz/thPwS8TdAPsgTtAz1MrhlZSdbr3s73fFMES52dnTQ2jo6GbTYbgUCAzs7OA5739a9/nWnTptHa2srf/vY3/uVf/oWNGzfy3//939p1cwMlQPt5rOvedttt3Hjjjfv8/vnnnx+1zacXq1ev1v2aeuBLQ9QCa999mb52/QZfMB4Cjx1Lyskf/vAH3a6bDxPua1nGp5oOdvZs1bXdze1ryfiUlZQNf13Hdut7ul3bUIYAJyQY2m9/TLSva6ObNQ1XtCtc9HtkorQO7KI6k6HfauV/X3mBdm/zwU/Kk1ByEHAhJfc/ZspxDpEyKS0JoL1js65/x8DOd6BG0XCte/kvWCySbtfOh4n2tyVhAQ/E5aiu/VEf+VDbyg/v7TfNmJnatxeXlGHIYuG/V/+BWe59t90LvbdjsfzE4yUNlq655hruuOOOMY/ZsGHDhK9/0UUXaf+fN28eLS0tLF68mK1btzJz5sRXQq699lquuuoq7edwOMyUKVM45ZRTRm3zFUoymWT16tWcfPLJ2O123a6rFw89dB0gU9fkZfnS5bpd91f/cRVgx+dqYPly/a47Fnr09e77fgCA3ZnWtd0f/e53kIKqtJUvf+l03a5rNB/8/ikY7mfYkhzVH4X2tbTpOX72F2VlaeFRn2D5sUv0arKhSNvc1LzyJP1WK5MOb2P5/C/oc2FZ5j/uuxxw4fe26NrXRrNFHTNOT0bXMbNu1cOAouH64hdP0+26B6PQ/n7rP1eBvIHkx8ZMoUgfJbjpLWXMfHr+QpYfeYJu1zYSaSPUrP0jQxYLU488nOVzFmqv6XVvZ3eGDkZJg6Wrr76a888/f8xjZsyYQXNzM93d3aN+n0ql6O/vp7k5/6ezhQuVjt6yZQszZ86kubmZN998c9QxXV1KpeqxrutwOHA49tXT2O12QyYko65bKG7ZBiQJD/Xp1750kojq3eRxNBb9cxfS14reIEMiHda13aF4n7ot6SjL++BA1FU3Q69iOihLElW20dPNhPt6OKQ9JU+tbTZPn/gatK3avriO90g8REhdOfG69j9mynUO8ahJAIlUUN8xkxgAp6LhKsXnnmh/13kbILKBhCWpb7sTIS07cHrATGOmkZp0hk4b9B5gzBR6b+d7bkmDpYaGBhoaDq7MX7RoEcFgkHXr1nHccccBsGbNGjKZjBYA5cP69esBaGlp0a57yy230N3drW3zrV69murqaubOnTvOT3Po4ZIcQJJwXMfMjVj/iJmciYSIkDUdjJDI6CtoDiZCYIMqzGMmB9BQowRLSNA5OMBUvz5ZOKnBXk3DNdUMRXSzjDId1DEJICcBwO822ZixuIBh4jonAYSTYSVYMpEPF0CdrwkikLJkCMVj1Dj1GfOR8N6cWormHDM9emdMjhNTZMPNmTOHZcuWceGFF/Lmm2/y+uuvc9lll3HOOefQ2toKwJ49e5g9e7a2UrR161Zuvvlm1q1bx44dO3j66ac577zz+MxnPsPRRx8NwCmnnMLcuXM599xzee+99/jTn/7Ej370Iy699NL9rhwJRuOWFPfkqJ7lG3KyWOr2sz9dzviqVE8Q9PUECavFih2SeczkQDEddGc1KaFe3a7bG+ogo/pwTas10cSfU0U9GNOvP5QHDNVTyCwGjCpezXRQ3+zASEa5ntNiHh8ugEB1C1a1EsBuHSsBdIX2Aibz4QJlzKhzSL8BlQDGgymCJVCy2mbPns3ixYtZvnw5J510Er/85S+115PJJBs3btTEWlVVVbzwwguccsopzJ49m6uvvpqzzz6bZ555RjvHarXy7LPPYrVaWbRoEd/4xjc477zzRvkyCQ6Mx6pMdLHU2Oag4yLHU8g0ZnIqNU5jCoNG1GLFLhOZyQGKUacBpoM9YWXir0pbcdtN9FBT5dVMB6NxHU0Hc1aWmk02ZqodfkBn00FZVn24wFVlruDR4qnTggM9KwH0RRUZi6l8uACcfu0BI2KAUed4MEU2HEAgEBjTgLKtrQ1ZHnGTnjJlCi+//PJBrztt2jTTZAaUGx57NWQgJus40eXUdDKNmZxKwF0PYYjraTqYThKRkoALd5W5+iP7VKi36WD/0IiGy1RIEm61MGhcz8KgOQ8Yk8y0LQn4XQGIbyWhp+ng8CAhNR7wOM21LZn1a+u3WunUsRJAMN4PDnCayYcLRlUCiCV0XI2dACYKMQXlhs+hrHTEZB1XUnLKFJjJTA5GCoPqajo4NKCtGlS7TFJEN4ur1hDTweBw1oDRXBouAK9F2bqO67h1nRrsMaeGC6jzKsFMwpLWz3TQxBqu3G2nbh0rAYSSSsZXleTR7ZrFIpsEEE/qbPY7TkSwJJgw1S5lYo5J+q2kRExYEDSLv7oZm7q6uSuk05JxrE/To9S5zRU85hYG7Yvpt6UQSSmBqMOin01HsfBYlS8rPZMAesyq4QLqa9SsYwk6IjqtpOSMGbNpuEYJmnXU6ITT2SK65tJwQdao04BKAONEBEuCCRPwKisdUUtGt2uasiCoisVTp62kdOil0clZaWsymR4Fl1+b+Adj3Qc5OH+yGi63za/bNYuFEUkAPWHFQNd0Gi7A7W3Cpd4jugmaY/3aypKZaikC6gOG0h8hvZIAZJlBOQ5gqlqKWXx2JaMxLuuojZ0AIlgSTJj62ikADFrkgxyZP71RZUXGaTYhIihPhepE16njU7LpCoJmsVjxytnCoDp9EWbSqoYLXGbTcAF+p7J1ndAxCWBgSPlSNZ2GC5QkADVY2quXRidHw2WmWooAVHmoVisB6JYEkIwRUudoj8tcK48A1VXKatgw8ZK2w2TfRoJyojmg1LYatEgMD+sz+Q/E1SK6ZhMiArgC+DNqrSu9fHRi/SMarhqTTfyM2EsM6aU3GApq/WE6DRdQ684WBtVv63pgWNE/OU2o4VLsFJRgqUunYClXwzXNTJ5CAJKER00CGBrWc3VaeeCqNeGYqXEpq2EJS2mL24tgSTBhWhunAyBLEl19u3S5ZmhYESI6TChEzF1Z0st0MBwyr4YLsqaDOmp0cvQoAbNpuID6auXLKqVjEkA4qfStw2IuHy7gY0adQV0u2RPao2m4TGXAqOLJJgGkdUoCyNnKr/eYTMMFBDzZB4yUfkkAE0AES4IJ43Z6NNPBjt6dulwzks6ayZlPvIs7oGmWQjppdLrDIxquRo/5xJleu86mgzkTf7PXfPoLI0wHB2WT+nABuEbGTF9UH42OmTVckJMEoJegOceOxXQaLqChRqm4IUvQHdXRAHmciGBJUBA+NdDvHtBnZWlQ3Zd22c33BITdhS+jPNHqpTfoHVRqFZpSw8WI6WBC0klvkLOlYMaJPzcJYHdYh+AgkyGCsj1hRg0XrhzTQZ0eMPpUYbTTjBouwKdqdBLE9LlgrN+8Gi7A6xtJAmgP6pdVO17MN/sKygpfRvni6gm1F36x5BAhSRkUpjOTU6lR9QaRYX2CpQG17p5DdupyvWLToG6VDVl0EjTH+jQ9ypQaE94jrlrq1OBgV6ir8OvFg9oXoRk1XFis1KhJAJGEDv0BhIaDgDl9uADq1UoAQxZ9HjCSg93m1XABuAMcnRhmblwiLYttOIFJ8anBQe9gR+EXi/UTVFcNatwmnPiBWtUTJJbSR7MUSqriXZMVBM0yqWYSAElLhp7BcMHXy9VwTas131MyrgD1arDUrkewlFMXzowaLoBaNQlgMKnPqkFYLb9kSg0X0OJTvKeGLEniycJFzb2hDmQTa7hwBXiws5v/GpI5YdrskjVDBEuCgvBKSnAQiuuwpZBTRNdsdeGyBFSNTkzWR28QUc3kzGjACOD3NWpL6Jv69hR8va6wcg2rSTVcuGqpz9pLRHXYdjK5hgugVtXoxDL66FEGM8qYcZnQhwuguaYFiyyDBFv7Cw+ou9Vaig6TarhwqVo8vTKMJ4gIlgQFUW1VvrDCqWDhFzO5EBGgQV1Cj1v00RtENDM5E2q4AIunXltJ2T7QWfD1+gaVAMOsGi7cARpSSn8EY4X3R66Gq7XahKsGQJ2q0YlLOiQBZDJEUGwZPFXm7A+7t17bqt3SV/iKfVbDZUofLoCsC/twBNI61t0cJyacbQTlRI1DeZodzOjgrmpmMzmVFo9a68qaJJooUKeTShCRlEnT6zTntiSuWho0jU7hwcHAkLk1XNhdBNQkgMFhPbbhRjRck33mDA6a3cocErfGyWQKrAaQCBG0Kv3rdZlQ0wajVh/1GDOhRBAwr4YLZw2g/E0ZKt3qkgiWBAVR51G+xAcpXMCbNLOZnEpjTYtWH25z/97CLpZTtqHGbAVBs7gD1KsrKR2RwredzK7hAqhVvadiqcJNB0f5cAXMeY+0VLcCkJFkdgUL3M7P0XDVeczZH7jrtAeM3eHCx0w4pUgCnCbVcGGxqgETIlgSmJcmv+LiHbGkCr6W6YWIgKW6Vdt22tpf4BJ6jh6lwWPO/sDXQkM6Wxi08AzBcNq8RXSz1Fb5AUhQuEanM7QbUDRcDW5zfhm6/ZM1+4DNhW47xfroVx8wmkxowAioY0bpjy4d7BSytRSdVhNq/LKcfCOc/nMo4TxoK9k7CyqCyQ0zYSeErDKZjIzFIk34Wl2qAaNphYgAvmYaUmk6bTZ2FqrRydFwNXtNOvF7GqhTg6XBeOH6C6UgqMu0Gi6ABncTMEhCB11bX9TkGi7QgoOQ1cr24F5g/sSvNWor36QPGN4mbTW2YF2bLKs+XFV4HCbtD4Djzi91C8TKkqAw2lrmADBotdA5UNjKwUAsWxeuquB2lQxfiybO3DNYoCYlZ2VpslknfqsNv6RsOw2lClxZSicJqxous/pwATT7lQLUKUu6YDuFgaHsmDGphgvA16wF1AXbKeSUwzGrhguHF7+6jhErVNeWCBNSNVw+s2q4ygQRLAkKIuCfgl3V6Gzv2FjQtQYSyn60KQuCZvE1a0vo3dHCgoPkYA+hrAGj35yCdwB/dtspEyzsQjlOxH5Pc2HXKiE1NVN0s1PI1lI0s4Yrd9ups8AxEw7tJW5yDReA36psqcYzBXpP5dZS9Jg0SaRMEMGSoCAkiwV/WgmWOno2F3StiFoQ1CmZU3sBgLdJm/jDQ4UJvLsHdptewwVQ78oWwiwwNXyUhsu8waOlplU3OwVT11LMom5dAwwUuO3UGVR9uDLm1XABBNQs4wQF+rXlJIk0m9SOpVwQwZKgYGrUkie9ocKK6UZUMzmnSc3kALBVUYOyJTKULGwJvWdQ+eIwtYYLaK5WXLwLtlPI1XCZ1LQUGLX6WGhquNl9uABwVFObramYKOwBQ9NwZUys4QIafUrx2ILtFHIeMFp8Jh4zZYB57yZB2VCtaoz6owVM/LJMRFKs/T0Ocz8B1dqVp/x4prA01z51S8KsBUGzNNS26WOnkKvhqjHvShu+Fn3sFNIpIpKShWpmDReSNLLtlC5s2ymr4XKaWcMFtNZOAxQ7hd3hifdJZrBH24abasZaimWECJYEBeOzKOUKwvEC9AbDUULq3eg188QPBJzKF3mcwow6R8zkXIU2qaTYalo10XshdgqjNFwmD5aydgq9sQJWH4cGNA1XjYk1XAABh+p8T2GC96wPlwNPwW0qJW7/FM1OYVPvxMdMJNJJIhssmXgrvxwQwZKgYKptykrKYDo48YvkChG95p74G32KyV7cmiCVnniV7HAqK941r/YCGCXgLcROIVfDNc3EgndctdRllJW2guwUKkTDBSPmtnHLUEHXyfpwuawm1nAB+Jp10bV1DlSGhqscEMGSoGBqncpEHZULEPDm1LgyrZmcSkugDUmWkSWZ7QMT32bRzORsJjaTA2XiTxVup9ATGSkI6rSb2F5CkqhRs9fihdgpVIqGC2it0cdOYVDVcLnMrOECZatWXX3cHZ54sNRbIRquckD0nqBgGtSVoKhUiHi3X3tKNq2ZnIqzZhK1qihzawEanYhaQsZTZe5Vg9yVpZ7BiQeP2YKgroy5NVwAtQ6lkno8U8C2U6VouAB/YJpmpzBhF+90igiKhsvsW/m5SQB7CxgzA/HK0HCVAyJYEhRM1mRv0JJCVoW846YCCoJq5Ah4twcn+FQ4HNM0XNUuk/ujuOsIqAk9kaGJ+woFVR8uB+bWcAHUqQaB8QLsFCpGw8XoMkHbBib4gBEPasFjtdvcW/l4c+0UJr5VGx5WaymaXMNVDohgSVAw0xpnAUrJk0hiYjXiQhViJgdA9chKyu6JpobnBI9+k2u4sFjwS4rRaCw58afksObDZWIDRpVmddupEDuFitFwwajVxwnbKeSYljZ4zR08YnfiR9lqjhVgp5DVcDnNruEqA0SwJCiY1sbDAYhYLXT0T6xq+N6gWhC0EoSIvhbtKbkrOkGNTo6GqxLM5Px2RXcVL8DFO+vD5bLV6tGkktIYKNxOoTusnOc0u4YLRunaJmynEOujX9VwtVTCmFHtFIbS/RO+RkX4cJUJIlgSFEx19VRt4t81wZInfeq+vKsShIieBk2cGYpNcNtpqL+izOTqVBfvuDRxO4VBFB8ut8P8E78edgpZDZczY/JACVSNjjJm+qMT3HbKKaI7qdr8wVKt6uIdn6iLdybDoJQEwOM0+UpbGWDybyVBOZBb8qSzd8uErjGg+s2YuiBoFouVakn5HNHExFaWMqGOijKTy7p4T9hOIREhZFG+TKtdLXo2rTTkCHgnaqcQUn3NHJi4lmKWKg9+WVkVmqidQjK0R9NwTfObf8zUq95ZE7ZTiI4YUta4K2DMlBgRLAl0IVvypC+8a0LnD6oTf5XZPYVUaq3ZbaeJLaFH+rZXlJlcS2A6kiyTkWBHcALbLMH2EQ2XyQ0YgVFJABO1U4gOK/dWlcXk1hIqNRZFizaUmphjdU/PZk3DNaXG/KuxrQHFxTtpSdMXm8DqUqhdW2mrN7uGqwwwTbDU39/PihUrqK6uxu/3c8EFFzA4eOAl/R07diBJ0n7/PfHEE9px+3v98ccfL8ZHqihqVDFiaGhiT8nRlJK1UWU1/xYLQED1npqoi3d331agQjRcgNM/WbNT2DYwgeAg1J6j4TL/F2HuylLf4AQ0S5kM0bTyBeqwV8YXYaBKdfGWQxM6vzeo1KZ0pG3m13ABtbVTNTuFjT0T2M4P7tJ8uCpBw1VqTBMsrVixgg8//JDVq1fz7LPP8sorr3DRRRcd8PgpU6awd+/eUf9uvPFGvF4vp5566qhjH3rooVHHnXnmmQZ/msqjRi15EklMQOAdD2t76w6H+ZfPYcTFe8gysUKYA5F2AKoyDvNruAB8zZpGZ8dE7BSCu3I0XBUw8Tt81GaUzzMhO4VoN2GLsvXtdJjcWkJlxMU7NqHzg4PK9p3d5OWBshRspxBq18ZMJWi4So2t1A3Ihw0bNvDcc8/x1ltvsWDBAgDuueceli9fzk9/+lNaW1v3OcdqtdLcPHq5/sknn+SrX/0qXu/o1GO/37/PsYLx4bfXgNxPbCIlT3JWDXwVIkScFGiDPWtJWTJ0R0M0+8aXwRUe6oYqsMnmT5MHlNTwVJrNVbA73MVkxvd3zgzszNFwVcA9IknaA0YsOQEX72A7/eqYqXVVxhdhq38K9H1I3JoimkjgcYzPfHQw0QNuB3bMvxILaHYK7Xb7hOwUhvt3EFLvkUrQcJUaUwRLb7zxBn6/XwuUAJYsWYLFYmHt2rWcddZZB73GunXrWL9+Pffee+8+r1166aV85zvfYcaMGXzve9/jW9/6FpK6970/EokEiRxvlHBYceFNJpMkk8nxfLQxyV5Lz2saRa0jAPHtxIiOu71S33Y6s6VOXPUl+bx697W7ZhLe9gyDFgsfdbZT5xxH0CNn6EsGAT8OS8AUf/+D4qwfsVMY7ABbw7g+V1/PFk3DNb1mfOeWK36bHwgylAmOf8z0b6fTpm5Lug88Zsw0h9T5p2HrlUlJEn/vbufo5mn5n5xK0JeJAQ4c1tLdH7r2t6t+xE4h3Dnua7b3bQUJJFmi1eM3xT0wHvTq63zPN0Ww1NnZSWPj6MjYZrMRCATo7Mwv4v7Vr37FnDlzOOGEE0b9/qabbuILX/gCbreb559/nksuuYTBwUEuv/zyA17rtttu48Ybb9zn988//zxut/6ZKatXr9b9mnqTDKehCqJSnD/84Q/jOnd6z2r22JRbMdkVG/f5eqJXXzeG2qlPpRmssvCHv6wh8tH2vM91JgfYa1OCdSnpL2l/6IYsE1CT4Dp7NkPLMePqa3/X36EeHCknr615yZg2FhnrsB3cMCRFx/03ntX1gjZmEh2hg55vhjmkJdhJIJ2m22bjyZf+xO7qyXmf64l3av0hJapLPmb06G9JTlGn2ins3PPRuD+Tu3crNFhwpjy88PzzBbenXCm0r2Ox/LZ9SxosXXPNNdxxxx1jHrNhw4aC32doaIjHHnuM6667bp/Xcn937LHHEo1Gueuuu8YMlq699lquuuoq7edwOMyUKVM45ZRTqK7Wzyk1mUyyevVqTj75ZOx2u27XNQLvW7v57eb1RK1pFp+8FIfdmve58uq/sqdbuRW/+tnlHDdphlHNPCC693XXVOqf/S07sOObHGD5Z5bnfaq0+y1Wdyn9cXjLXJafmv+55cxv7vshAFKV4io8nr7+48//GSVJvo7lyyujP3Y++wKEXyJuHeaUpUuxWfMfM4n/fZHuoHL8uaecyczA/nVLZppDpN0NNKz+Hd02G/5pTSxfNI4xs/1lnnpRGTNHTT2K5UtKc4/o3d+777sWAKsrNr77XpZ5auuVgBePpbFixkwuevV1dmfoYJQ0WLr66qs5//zzxzxmxowZNDc30909Ot04lUrR39+fl9bo97//PbFYjPPOO++gxy5cuJCbb76ZRCKB4wB75g6HY7+v2e12QyYko66rJ1MbZ8FmCFtlBuIZprjz90va0b+VpCQhyTB/0vSSflbd+rp2ykjx2Gj3+K452MEeuzI0Z9ZOK/u/fb747X4grLl4593XyTjdDAEOvPbWiumPyQ2zkEJ/JiNJdESDzKzLXze5ZWAbskXCmrFyeEPrQZMAzDCHUDtZqYfmgM5Yz/jHjLoteURdW8k/q179rbh4DzOU6hvf9YYG6LQo84/PMaXk/WEkhfZ1vueWNFhqaGigoeHgYs1FixYRDAZZt24dxx13HABr1qwhk8mwcOHCg57/q1/9itNPPz2v91q/fj21tbUHDJQE+6ehTil5ErZa2Nvfz5RA/tuRuyPt4AZX2lMRKb8AuALUqUadweju8Z0bate2FOY2tuncsNJR56oHwuN38Q7v0b4I6zxturerVGTtFPqtVjb3dYwrWNoT7QAfuNPVlZEtCeBt0nRtfZHxjZnMwE5tzBzVNF33ppWK2qo6YC9Dcn6rHxrBdu2Bq8k7Du2X4ICYYpTNmTOHZcuWceGFF/Lmm2/y+uuvc9lll3HOOedomXB79uxh9uzZvPnmm6PO3bJlC6+88grf+c539rnuM888w4MPPsgHH3zAli1buO+++7j11lv5P//n/xTlc1US1dVTtJInu7vGV/KkK6GY0LmpAP+cLBYLNZKSwjyYGF8mS7B3q5YdeGxL8bckjaLBp7h4xywJMhk5/xODu7SJf+o4dCxlj69Fs1PYPh47BVmmOzkAgMdaAZmBWWwO/LLysBQZGp+Ld2fvVoYsFpDh6OY2AxpXGhq8ivP20HhdvHMeuKb7K2jMlBBTBEsAq1atYvbs2SxevJjly5dz0kkn8ctf/lJ7PZlMsnHjxn3EWr/+9a+ZPHkyp5xyyj7XtNvt3HvvvSxatIj58+fzi1/8grvvvpsbbrjB8M9TaVisNq3kSU//1vxP1LZYwOeorEFdo1b6jo2zEOaO/m0AVKXttFZXhkknwOQ65Yk/ZckQSScOcnQOoXZ2qxP/4XUV9JTsa1a2nYDdoXH46MSDdGZLvzgrqD+AGuvE7BR2BncA4Eq78Dkqw2cJoMU/BUCzU8ibYLu2Gju3oXJW2kqJKbLhAAKBAI899tgBX29ra0OW931avfXWW7n11lv3e86yZctYtmyZbm081PHLVnqR6Q+3539SaLf2RdjgbTOmYSUi4KwDosTl8ZUq6IjuhWpwZyqjjEWWmkAbnu0ZohYLe4fz75Nk/w72qvfIMS0zjWpe8fE2a9tOPZFxGFMG29mtrrS1+CorWKq11wI9DI3Txbsz0QNOC27G52dW7jTVz8TWpdgpbO7fy/yWtrzOG+zfRo86ZuY3V87qdCkxzcqSoPypVkueDMbH8ZQc2qVN/NNqphjRrJKRXUKPjWcJXZbpVo09PbbKcGbWyFlJ6Unmr1tq791MSpKwyBJzGypo9bHKTa1aUzESG0ewFBpZNZhZO9WIlpWMOrdyzw9J43DxzqTpzijBt8++r0GxmbHVtBLIunj35z+v7ujZrJyfsTLVXxmmpaVGBEsC3fBbFFH34PA4CmEGR/bWZ9e3GdCq0tFa2wZAwpomFM9z8h8aoFMtY+F3VdaqAb6WEQFvOv+VpfaQUpzZnXZTZTPNYnheZF28o8lxFBcOVmYCAECz+sA0ZB0mpd4rByWyl71q8BjwVtiWU04NwZ3j0LXtjiqaL08lJQCUGNGLAt0IVPkBGFJTw/Mh1r+Nbk3MXEFbLEBj/XSqVCHzlr48nwpDI1ssk2raDGpZifA1aRN/NDWQ92l71XqDHqmCEgBUFDsFGBpHmaC+ns1aGYtPVNiYmdSgfJ6MBDuDeeqWgiOatraaynvAaNBcvPNfWepOKjrJikoAKDEiWBLoRp1ao2qI/JfQt/dsRpYkbBnLAY31zEpuIcyt+S6h5wgzZwUqbOLPKR6byOS5+phJ0yMrW3a+qgraglOpdymVCYbGYaewvX8LAM60nQavfia45YDLP4Vadcxs7sszIy43AaC+wsaMu16zIOmP7MrvnOEYXdIwADXOytqmLSUiWBLoRpNP8YkZsiZI55kavjuiiME9aW/lLRfnbDvlu4Q+yi+moc2olpWMGknZqk3Kea4sRfbSoQaPDb7KE6o2qVYIip1CJq9zOqJK4F1pCQAA+EZE7/naKSRy6uQd01Rh94jFQg2K518kXy1oaLc2hzRXV9i2ZAmpsG8nQSmZpK6ERK0p+gbzS3PNeix5LBUoQszRG3SG8xPw7unZpPnFzG+tvImuxqashAxb8tQs5W6x+CvvKXlSvfI3TlpkuqP5ZYBlPZa81gqsJJ+z7bQ7lN/K0s7ujaQlCWtGYnbDJCNbVxJqrEoR7liyN78TQru0YGlWbYWttJUQESwJdKPBrwzMiFWmO5JHsJRO0SMrW3Y1jsrKhAPAWUOtqlENDua3hL5T9Vhypx0V5ReTJeBUguJhSzS/E3IyvyotAQBUOwV1RWlTbx7BwXCMLotSJb22gtzMNTwNWvHY/nB+Y2ZXaKdyatozrvp6ZsFfpXitxfK0U8gMjGQYV5KbeakRwZJAN+oCswAIWS10DQQPfkJkL3vUgrsNNZUlVAVAkqiRlBp5+S6hd8aUrQev7DeqVSWl0aekdg9Z81t5jPRu1fxiKk3MDIxaSckrNTxni6W1psK2nACsNmpUF+9wni7eXXFFCO6VKsfANZd6T9ZOIT8Lkp6ezQyqkoZKqgBQakSwJNANf00bVtUYtKMnj5InuX4x/spcLtZcvFP5uXhnPZZ89vzrhJmJSYE2AOLWDJFE/KDHb+9W7iN7xlKZfjE5Gp3d4a6DH5+zxXKY2peVhmanMJxHNpws06OavlY7KstjKUuLuv0cy9NOYXuvkgDgStupdXsNbduhhAiWBLphsdrwq8LuXnU7aUxy/GKOrNDl4oBDSXeP5VMIczhKlyWlnOepzP5orJ85YqeQx0pKu+oG763EBAAA74idQre6nTQWmYFd2gPG0ZUmZlaprVJcuGP5WJDE+uiwSgA0+GYZ2KrSMblO+Vz52il0qB5L3kpMACghFTj7CEqJX3UkDg0evORJb8+mivWLydLgVZ52Y/ksoedssUzyV2Z/WGomjctOoUtdXfBaKs9jCQBbFTWyHYBwbPdBD2/v/DsJiwVJhnktlSd4B6hT7RRiUh66tuDISltbbWU+YLgC47NTyHos+WwVmABQQkSwJNAVv5QteXLwtN+t6haLM22rOL+YLC1qNkrMmmI4lRr74OAuLfPriErzi8mSs+20K3SQe0SW6c0o/kM1FVZkOZesncJg4uAu3jtUjyVP2oHb7jC0XaWiSXXxjlmGD26nEBpZnZ5TgVYbwCgLkoPaKaSTdEvK9nZtpVUAKDEiWBLoSq1WNfzgpoMdg0o6vS/jM7RNpaS1YSYWWUaW4O+9Y68c5PrFHN1cmU/JeEfsFDoGto99bLSXvTZli6Wp5jCjW1Yysi7ekfTBx8zemLIa56vQBACAKQ3KtlPSIrM7PHafhHu20qeOmfkVujqdW1NxV/9BtmrDHZovWXNtZW5LlgoRLAl0pcHpByCaDpJMj/1U2KXWkPNVsCW/wz+ZGUkl1XvNtvVjHrt970eKX4wsMbehAq0UAOxO2lLKtLMj9OHYx4ZGVtpmBCpTnwNwuFfxBuq1DBxUwNudCgJQba8st/tc/HVtTEoqq7Crt7wz5rFbujYA4EhbmeKv0K1aVy0zk8pcuqX3vbGPzVlpO6KuQh+4SoQIlgS6Msmn7JOnrDE2do5hPCjL9MqKJsHvqtDAAMDXwlEJpfTAW3vXj3nozqCy0uJLOSvSLybLbEnJ0OlO7hj7wAouGJvL0Y1H4MxkGLam+cuuvx/4wHSSbkmxXKjUBAAAfM3MSyif8y+714956O6wstLiy3iMblXpkCSOkBXPtb2JzWMemurfyR7VY2lehSbNlAoRLAl0pc6jpLwnrMOsbw8e+MBRWyyHF6FlJcLbpAVLO8Njr6R0Dimp416p1vBmlZKjPYrofdAWpDNy4LInXZ0biVhVv5jWyl1ZcvonMXtYWX18cdvbBz4wvEfbYplUW8FjJucBY0vogzEP7VKLLPsqNQFAZZ4qeg9bewjFD1x7c1fnBpKShCTDUU2VmQBQKkSwJNCVKfVzAeh0JFm/cwy9Qc4Wy6z6Cn4CcniZjSrglbeNKVjtSSkOvTUV6rGUpanhcFpSKZDgj5sOHBxs61USANxpG3XuytW1EZjBUepKyvruvx34uJyVtiMqVcwM4AowJ618zkhq7JWUnoyyeu13VF6Zk1za6g+nNp1GlmRWb373gMdt61f6y5d24LRXFat5hwQiWBLoytzDT8eZkQlZLXR0vHLA4zIDu7Sn5Er1i8lyxKRPUZWRSVuHeaP9AGadqWG6LcoXZr23svtDnvIpbeXgjT3rD3jcbtVjyZepcGO9yZ/kqGHVayn20QEPG8pJAJhfyc7MFgtzm4/DIsskbVE+6DxA2ZNEhE6r8vDRWMEJAACWthO1MfNq+4GDpb2DSgJAtSw8lvRGBEsCXbFXeZiPsr8up15jMLH/dPldnR8RV/1ijm5pK2ILi49z+qeZPaxMdC9uW7f/g8J7tFWDyXVHFKtpJUGeskjTpGwdOPBKStewssVSXYlFlnOp8jBbDZCjlg6iif2XgtnW8SEZScKWkTi8rjLdqrN4p3+aWerW5J+2vLX/g3JW2qbXV3awxLQTtTHz974Dj5melLKtXckJAKVCBEsC3VlYq3zZZ9y7+GDP/os/bu/JLhdXVaxfjMa0E5inPhWu71q//2NG+cVU8LYkQHULbSllazKc2nTAw3plxWOptpITAFSmT/8MNek0siXD6q37XznYOaC44lennZXpZp7LtBOZpz5gvH2AxIjMwIiY+cjGCh8zgRmayDs4vGH/x2Qy9Krmt3XutiI17NChwkecoBQsaFsMwB5X7IC6pT2qw7dPrmAtSpbGucxW0+V7ovt/Kgz1bNH8YipZzJylqWoWFlkmbouxoXs//lPxMJ1WpSxKc21lr7QBWNpO0rZZXtm5/9XHTtVjqRp/sZpVOlqOYe6w8vffG1m/30O6ujYStVR+AgAAksSRTQsAiNmC7A7tp9ZktIc9atJMS4WvTpcCESwJdOfII76MM5MhZJX4aOer+z2me1gZ7DUV7LGkYbFwROBIAMKWTmLJfbdZNnUoWT+OtIXJ1ZWd2QOQ8M3R/Kee27yfbZaclbaZlb7FAjB1oRYsbezZv7dQtsiyv6qlWK0qHbYqZvkUk8mQtHu//lObVY8lX8pGjdNd1OaVgqaZn9P8p/64aewxM6dBGFLqjQiWBLpjd9UwL6NsrQWDa/Z7TC+Kx1LAfWiktx42czG+dIaMRebFLfsay7WHdgBQk3FV/hYL0Os9QgsO3unYdyUl1b9jxC+mucJXDQBctcyyKQ8OweH9JAFkMvSoZSzqvRW+5aQyd8YXcGYypCyp/fpP7Ykowm+fXOEJAFmmnaDpltbu2TegjvZuoVv1ZzumkhMASkTlz8qCkvDJGuXJZsi2lZ7Ix1ZS4mG61C2WlsDsYjetJNimn8RRw0o/vLRj33T5riGl5lN1hXssZYlVNXJEWklt7gzvq9HZ2fEhSUnCIsO8Q8Qv5qjWTwEQtoX29Z+KdrNX9ZyaVD+n2E0rCc4Zn2ZONjFi674rKVmPpZpKTwDI0jiX2Ullm213/779sbXjQ2RJwp6RmBkQAm+9EcGSwBAWTVd0Sx3uQd5r/9jE3/Wh5rF0WGMFm+vl0nIMc4eVNOftPWtHv5ZO0ZdStiUPiS0WAElill/x5OqX9uzjP7V9rxJAVafth4xfzOQjltCaPID/VNcH7FZX2uY0VWgNtI8zaQFHqtm0Gzr/Ovq1VIK+jJI8UuuqbI8lDYuFWT5lvhyQ960Rt6v7fQBqDoUEgBIgelRgCFndUtgq8eam0bqlxNr7c/xiDpGJ32pnhlNZIekd/pjR3oan6bYo+p3awNHFblnJmDdrCVUZmWFrerT/1NAAke6/AOCgsUStKwFTT9DMKdfuHB1Qh9/4BQPqFsuxh8oWS5WbGapBa2/8Y/5T7/+eLpsSYDfUHVPslpWM+TO/gFWWidmGR/tPDXYz2K9szTksh8gDV5ERwZLAEOzeBo5MKU/C7Z3PjbwQbKd9yx/JSBJSxsoR9ZXtF5PL0VM+DUDQFqFrULVUkGUyb9zDdrsdgBl1h0jwCFRN/4zmP7Vma05wsO4RdqrbtHbHISRU9TUxU61xtjeYs83Su4Vd7S8BYEk7aa0OFL9tJeLIloUA9NsGRvynZJn0G/ewQx0zh9UfIsEjUDPrC8zU/KfeHHnhrV+xw6Z8nTvdh8hqfZERwZLAMOarXh+9mQ3IsvLlx5u/4B6/Yhfg4fBDarm4bfYpNKVSyBI8l81maX+TZ0Mb2VFlh4yNk2ceV9pGFpP6w5mtzPts6lBXH9NJOt68n8erlXvkuOZDqD+Aw9StyR65Xftd5o17WRlQHJlrrIeGXinL7DnLqEmnSUuM+E9te4n/N9TOXpsNMg4Wzzy2tI0sJi1HM1d1e/+w/WXld8k4u9Y9yP/zKYH2p1oXlKp1Fc2h800lKDonzvg8AHucYXb2RSER4YX3V7HG40aSJW7+9A9L3MIiM3kBRyaU6OCd7S8B0P3qv/LTgB+AhYFzOKLh0FlpQ7Iw3aFsTXbH1W24j/6HnzqTRC0WnOk2fvz580rYwOKz4PClWGSZiC2p+E/F+vnfTf+PN1wupIyF2z/3f0vdxKJimbZopDTOlpcA2PPav/FvtX4APt/4TSbXHDorbVjtTLcpW5NdUcVuJPPe49zukYhbLHjSR/CDk75SyhZWLCJYEhjG/CO/gjOTIWKVWLPhNQbW/oo7/E4A5npOZ8msQ0drAIDdxXSUiX13cB0M7ODnA28yYLXiStWzcvmVpW1fCZg3+UQAuq0hYsNxnnv1LlZ73Egy3Hjij7GpOp1DhdrDF2v+U89vfI2ev9zHz/xKavwnar7KCdMOjexRDWcNM1Tj2l29a6FnI/8++D4RqwVPqpWfLr24xA0sPnOajweg29pHKpXimTf+nVfdLiyyxJ2fv/GQWq0vJqJXBYZhr57EkUnlFtuw/Rnuff8BOm02vCkX9512TYlbVxoOq1ME3N10svq5H/OkunT+/QU/rvyyL/th3rzT8aUzpCzwp9d+xb9WhQE40rGE5UccWltwAPincrg6ZjbufIGVG39Ln81KdcrLPaddVeLGlYaZ1crWY1emnWeeu54/ej1IMvzwhJupUrNqDyWOnXc6zkyGuEVm9Sv38+9uxX9rvud0PjP9yBK3rnIRwZLAUObYJwOwMf4yv/coHiHnzvkXat2HiJHcx/jk3C8iyTJBW4qfRRWB5lHykXztmM+WuGWlwdJyDHOHlfTw/9h2Hx12GzUpGyu/dGOJW1YiJIlpVcrW5Mb4X3nKq4iYLzr6BnwOVylbVjIWHL4UgF5bnJ8nlHJB860L+NKc40vZrJLhnLqQ2arI++5t99NjsxFIOlj5pUNri7bYmCZYuuWWWzjhhBNwu934/f68zpFlmeuvv56WlhZcLhdLlixh8+bRadv9/f2sWLGC6upq/H4/F1xwAYODgwZ8gkOTBZNPAmC7QyItSRw93MAlJ5xd4laVjsbDvsB0tWTBHruVmrTMHWesLHGrSojVxjR1a7LTrgTTK6ZdSIO3upStKilzWxcB0K32xyeSrXzzk8tK2aSSMm3uclqTKWRJosNuI5CCu87811I3q3TYXbRllPGRHTPfOvzKQ6LkSykxTbA0PDzMV77yFS6+OP896jvvvJOVK1dy//33s3btWjweD0uXLiUej2vHrFixgg8//JDVq1fz7LPP8sorr3DRRRcZ8REOSU469h9xqoaDnkyGHy35WYlbVGKc1cxIjWy3fdXzOabWHkJeQvthpn+e9v8FcQcXL7mkhK0pPcfPP5uqjJI9Wp3O8OPl95S4RSXG28Cs5Mh22zcCp9Hk85euPWXAdN+Idu2EuJfzP/ONErbm0MA0G7433qgsyz/88MN5HS/LMv/2b//Gj370I8444wwAfvOb39DU1MRTTz3FOeecw4YNG3juued46623WLBASbe85557WL58OT/96U9pbd1/ZlIikSCRGCnhEQ4rOotkMklSFWfqQfZael6z2FhqpnFcXOZ1N3w9PYVZk48qy89TzL6e4zqMF9jIcUMpvvsPt5RlfxjJx/t64ewv4nj3dWzAVfOvOuT64+PY64/gmESKt1x2zpVmMblh+oT7pBLmEIAjqqbxCjs5IZbmvK/8qGw/T7H6e+Gspdj+vh5PJsPVn7q2bPvDSPTq63zPl2TNAMccPPzww1x55ZUEg8Exj9u2bRszZ87k3XffZf78+drvP/vZzzJ//nz+/d//nV//+tdcffXVDAyMlONIpVI4nU6eeOIJzjrrrP1e+8c//rEWvOXy2GOP4XaLpdCPU733WdKR18lMuYIhV3Opm1NyXNF25I57cPlPZaDh86VuTsmRMin82+9Cktz0T78cJKnUTSo5NR1Pkom+TWra9xmqOkRqn42Be3ALmb2/wF13Fv2BE0rdnJJjyQxTve1OLLYA/W2H9kpsocRiMb7+9a8TCoWorj7w9r9pVpbGS2enUpi0qWl0QcGmpibttc7OThobR2+B2Gw2AoGAdsz+uPbaa7nqqpHMlHA4zJQpUzjllFPG7OzxkkwmWb16NSeffDJ21a3WnCwvdQMOSvH7+rtFeI/yZP99fXpJ21R+6DNmKmcOAbi81A04KMXt7zMNvn55o1dfZ3eGDkZJg6VrrrmGO+64Y8xjNmzYwOzZ5eUt4nA4cDj2TfO22+2GDBCjrivYF9HXxUP0dfEQfV1cRH8Xj0L7Ot9zSxosXX311Zx//vljHjNjxsTq/jQ3qy6nXV20tIwUFuzq6tK25Zqbm+nu7h51XiqVor+/XztfIBAIBALBoU1Jg6WGhgYaGhoMufb06dNpbm7mxRdf1IKjcDjM2rVrtYy6RYsWEQwGWbduHccdpxjgrVmzhkwmw8KFCw1pl0AgEAgEAnNhGuuAXbt2sX79enbt2kU6nWb9+vWsX79+lCfS7NmzefLJJwGQJIkrr7ySn/zkJzz99NO8//77nHfeebS2tnLmmWcCMGfOHJYtW8aFF17Im2++yeuvv85ll13GOeecc8BMOIFAIBAIBIcWphF4X3/99TzyyCPaz8ceq1Sa/vOf/8znPvc5ADZu3EgoFNKO+cEPfkA0GuWiiy4iGAxy0kkn8dxzz+F0OrVjVq1axWWXXcbixYuxWCycffbZrFx5CJsECgQCgUAgGIVpgqWHH374oB5LH3dBkCSJm266iZtuuumA5wQCAR577DE9migQCAQCgaACMc02nEAgEAgEAkEpEMGSQCAQCAQCwRiIYEkgEAgEAoFgDESwJBAIBAKBQDAGIlgSCAQCgUAgGAMRLAkEAoFAIBCMgQiWBAKBQCAQCMZABEsCgUAgEAgEY2AaU8pyJmuGGQ6Hdb1uMpkkFosRDodFBWuDEX1dPERfFw/R18VF9Hfx0Kuvs9/bHze1/jgiWNKBSCQCwJQpU0rcEoFAIBAIBOMlEolQU1NzwNcl+WDhlOCgZDIZOjo68Pl8SJKk23XD4TBTpkyhvb2d6upq3a4r2BfR18VD9HXxEH1dXER/Fw+9+lqWZSKRCK2trVgsB1YmiZUlHbBYLEyePNmw61dXV4uBVyREXxcP0dfFQ/R1cRH9XTz06OuxVpSyCIG3QCAQCAQCwRiIYEkgEAgEAoFgDESwVMY4HA5uuOEGHA5HqZtS8Yi+Lh6ir4uH6OviIvq7eBS7r4XAWyAQCAQCgWAMxMqSQCAQCAQCwRiIYEkgEAgEAoFgDESwJBAIBAKBQDAGIlgSCAQCgUAgGAMRLJUx9957L21tbTidThYuXMibb75Z6iaZnttuu41PfvKT+Hw+GhsbOfPMM9m4ceOoY+LxOJdeeil1dXV4vV7OPvtsurq6StTiyuD2229HkiSuvPJK7Xein/Vlz549fOMb36Curg6Xy8W8efN4++23tddlWeb666+npaUFl8vFkiVL2Lx5cwlbbE7S6TTXXXcd06dPx+VyMXPmTG6++eZRtcVEX0+MV155hS996Uu0trYiSRJPPfXUqNfz6df+/n5WrFhBdXU1fr+fCy64gMHBwYLbJoKlMuW//uu/uOqqq7jhhht45513OOaYY1i6dCnd3d2lbpqpefnll7n00kv561//yurVq0kmk5xyyilEo1HtmO9///s888wzPPHEE7z88st0dHTw5S9/uYStNjdvvfUWv/jFLzj66KNH/V70s34MDAxw4oknYrfb+eMf/8hHH33Ez372M2pra7Vj7rzzTlauXMn999/P2rVr8Xg8LF26lHg8XsKWm4877riD++67j5///Ods2LCBO+64gzvvvJN77rlHO0b09cSIRqMcc8wx3Hvvvft9PZ9+XbFiBR9++CGrV6/m2Wef5ZVXXuGiiy4qvHGyoCw5/vjj5UsvvVT7OZ1Oy62trfJtt91WwlZVHt3d3TIgv/zyy7Isy3IwGJTtdrv8xBNPaMds2LBBBuQ33nijVM00LZFIRD7ssMPk1atXy5/97GflK664QpZl0c968y//8i/ySSeddMDXM5mM3NzcLN91113a74LBoOxwOOT//M//LEYTK4bTTjtN/va3vz3qd1/+8pflFStWyLIs+lovAPnJJ5/Ufs6nXz/66CMZkN966y3tmD/+8Y+yJEnynj17CmqPWFkqQ4aHh1m3bh1LlizRfmexWFiyZAlvvPFGCVtWeYRCIQACgQAA69atI5lMjur72bNnM3XqVNH3E+DSSy/ltNNOG9WfIPpZb55++mkWLFjAV77yFRobGzn22GN54IEHtNe3b99OZ2fnqP6uqalh4cKFor/HyQknnMCLL77Ipk2bAHjvvfd47bXXOPXUUwHR10aRT7++8cYb+P1+FixYoB2zZMkSLBYLa9euLej9RSHdMqS3t5d0Ok1TU9Oo3zc1NfH3v/+9RK2qPDKZDFdeeSUnnngiRx11FACdnZ1UVVXh9/tHHdvU1ERnZ2cJWmleHn/8cd555x3eeuutfV4T/awv27Zt47777uOqq67i//7f/8tbb73F5ZdfTlVVFd/85je1Pt3fnCL6e3xcc801hMNhZs+ejdVqJZ1Oc8stt7BixQoA0dcGkU+/dnZ20tjYOOp1m81GIBAouO9FsCQ4ZLn00kv54IMPeO2110rdlIqjvb2dK664gtWrV+N0OkvdnIonk8mwYMECbr31VgCOPfZYPvjgA+6//36++c1vlrh1lcXvfvc7Vq1axWOPPcaRRx7J+vXrufLKK2ltbRV9XcGIbbgypL6+HqvVuk9mUFdXF83NzSVqVWVx2WWX8eyzz/LnP/+ZyZMna79vbm5meHiYYDA46njR9+Nj3bp1dHd384lPfAKbzYbNZuPll19m5cqV2Gw2mpqaRD/rSEtLC3Pnzh31uzlz5rBr1y4ArU/FnFI4//zP/8w111zDOeecw7x58zj33HP5/ve/z2233QaIvjaKfPq1ubl5nySoVCpFf39/wX0vgqUypKqqiuOOO44XX3xR+10mk+HFF19k0aJFJWyZ+ZFlmcsuu4wnn3ySNWvWMH369FGvH3fccdjt9lF9v3HjRnbt2iX6fhwsXryY999/n/Xr12v/FixYwIoVK7T/i37WjxNPPHEfC4xNmzYxbdo0AKZPn05zc/Oo/g6Hw6xdu1b09ziJxWJYLKO/Oq1WK5lMBhB9bRT59OuiRYsIBoOsW7dOO2bNmjVkMhkWLlxYWAMKkocLDOPxxx+XHQ6H/PDDD8sfffSRfNFFF8l+v1/u7OwsddNMzcUXXyzX1NTIL730krx3717tXywW04753ve+J0+dOlVes2aN/Pbbb8uLFi2SFy1aVMJWVwa52XCyLPpZT958803ZZrPJt9xyi7x582Z51apVstvtlh999FHtmNtvv132+/3y//zP/8h/+9vf5DPOOEOePn26PDQ0VMKWm49vfvOb8qRJk+Rnn31W3r59u/zf//3fcn19vfyDH/xAO0b09cSIRCLyu+++K7/77rsyIN99993yu+++K+/cuVOW5fz6ddmyZfKxxx4rr127Vn7ttdfkww47TP7a175WcNtEsFTG3HPPPfLUqVPlqqoq+fjjj5f/+te/lrpJpgfY77+HHnpIO2ZoaEi+5JJL5NraWtntdstnnXWWvHfv3tI1ukL4eLAk+llfnnnmGfmoo46SHQ6HPHv2bPmXv/zlqNczmYx83XXXyU1NTbLD4ZAXL14sb9y4sUStNS/hcFi+4oor5KlTp8pOp1OeMWOG/MMf/lBOJBLaMaKvJ8af//zn/c7P3/zmN2VZzq9f+/r65K997Wuy1+uVq6ur5W9961tyJBIpuG2SLOfYjgoEAoFAIBAIRiE0SwKBQCAQCARjIIIlgUAgEAgEgjEQwZJAIBAIBALBGIhgSSAQCAQCgWAMRLAkEAgEAoFAMAYiWBIIBAKBQCAYAxEsCQQCgUAgEIyBCJYEAoFAIBAIxkAESwKBQABIksRTTz1V6mbw4x//mPnz55e6GQKBIAcRLAkEgqLQ09PDxRdfzNSpU3E4HDQ3N7N06VJef/31UjdNF3bs2IEkSaxfv77UTREIBDpjK3UDBALBocHZZ5/N8PAwjzzyCDNmzKCrq4sXX3yRvr6+UjdNIBAIxkSsLAkEAsMJBoO8+uqr3HHHHXz+859n2rRpHH/88Vx77bWcfvrp2nF333038+bNw+PxMGXKFC655BIGBwe11x9++GH8fj/PPvssRxxxBG63m3/4h38gFovxyCOP0NbWRm1tLZdffjnpdFo7r62tjZtvvpmvfe1reDweJk2axL333jtmm9vb2/nqV7+K3+8nEAhwxhlnsGPHjrw/80svvYQkSbz44ossWLAAt9vNCSecwMaNG0cdd/vtt9PU1ITP5+OCCy4gHo/vc60HH3yQOXPm4HQ6mT17Nv/xH/+hvfbtb3+bo48+mkQiAcDw8DDHHnss5513Xt5tFQgEYyOCJYFAYDherxev18tTTz2lfanvD4vFwsqVK/nwww955JFHWLNmDT/4wQ9GHROLxVi5ciWPP/44zz33HC+99BJnnXUWf/jDH/jDH/7Ab3/7W37xi1/w+9//ftR5d911F8cccwzvvvsu11xzDVdccQWrV6/ebzuSySRLly7F5/Px6quv8vrrr+P1elm2bBnDw8Pj+uw//OEP+dnPfsbbb7+NzWbj29/+tvba7373O3784x9z66238vbbb9PS0jIqEAJYtWoV119/PbfccgsbNmzg1ltv5brrruORRx4BYOXKlUSjUa655hrt/YLBID//+c/H1U6BQDAGskAgEBSB3//+93Jtba3sdDrlE044Qb722mvl9957b8xznnjiCbmurk77+aGHHpIBecuWLdrvvvvd78put1uORCLa75YuXSp/97vf1X6eNm2avGzZslHX/sd//Ef51FNP1X4G5CeffFKWZVn+7W9/Kx9xxBFyJpPRXk8kErLL5ZL/9Kc/7bet27dvlwH53XfflWVZlv/85z/LgPzCCy9ox/zv//6vDMhDQ0OyLMvyokWL5EsuuWTUdRYuXCgfc8wx2s8zZ86UH3vssVHH3HzzzfKiRYu0n//yl7/Idrtdvu6662SbzSa/+uqr+22jQCCYGGJlSSAQFIWzzz6bjo4Onn76aZYtW8ZLL73EJz7xCR5++GHtmBdeeIHFixczadIkfD4f5557Ln19fcRiMe0Yt9vNzJkztZ+bmppoa2vD6/WO+l13d/eo91+0aNE+P2/YsGG/bX3vvffYsmULPp9PWxULBALE43G2bt06rs999NFHa/9vaWkB0Nq2YcMGFi5ceMB2RqNRtm7dygUXXKC1w+v18pOf/GRUOxYtWsQ//dM/cfPNN3P11Vdz0kknjauNAoFgbITAWyAQFA2n08nJJ5/MySefzHXXXcd3vvMdbrjhBs4//3x27NjBF7/4RS6++GJuueUWAoEAr732GhdccAHDw8O43W4A7Hb7qGtKkrTf32UymQm3c3BwkOOOO45Vq1bt81pDQ8O4rpXbNkmSAPJuW1av9cADD+wTVFmtVu3/mUyG119/HavVypYtW8bVPoFAcHDEypJAICgZc+fOJRqNArBu3ToymQw/+9nP+NSnPsXhhx9OR0eHbu/117/+dZ+f58yZs99jP/GJT7B582YaGxuZNWvWqH81NTW6tWnOnDmsXbv2gO1samqitbWVbdu27dOO6dOna8fddddd/P3vf+fll1/mueee46GHHtKtjQKBQARLAoGgCPT19fGFL3yBRx99lL/97W9s376dJ554gjvvvJMzzjgDgFmzZpFMJrnnnnvYtm0bv/3tb7n//vt1a8Prr7/OnXfeyaZNm7j33nt54oknuOKKK/Z77IoVK6ivr+eMM87g1VdfZfv27bz00ktcfvnl7N69W7c2XXHFFfz617/moYceYtOmTdxwww18+OGHo4658cYbue2221i5ciWbNm3i/fff56GHHuLuu+8G4N133+X666/nwQcf5MQTT+Tuu+/miiuuYNu2bbq1UyA41BHBkkAgMByv18vChQv513/9Vz7zmc9w1FFHcd1113HhhRdqWVvHHHMMd999N3fccQdHHXUUq1at4rbbbtOtDVdffTVvv/02xx57LD/5yU+4++67Wbp06X6PdbvdvPLKK0ydOpUvf/nLzJkzR0vrr66u1q1N//iP/8h1113HD37wA4477jh27tzJxRdfPOqY73znOzz44IM89NBDzJs3j89+9rM8/PDDTJ8+nXg8zje+8Q3OP/98vvSlLwFw0UUX8fnPf55zzz13lH2CQCCYOJIsy3KpGyEQCARG0tbWxpVXXsmVV15Z6qYIBAITIlaWBAKBQCAQCMZABEsCgUAgEAgEYyC24QQCgUAgEAjGQKwsCQQCgUAgEIyBCJYEAoFAIBAIxkAESwKBQCAQCARjIIIlgUAgEAgEgjEQwZJAIBAIBALBGIhgSSAQCAQCgWAMRLAkEAgEAoFAMAYiWBIIBAKBQCAYg/8Pr2ZFWX5kgC0AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "ax = fig.add_subplot(111)\n", - "ax.plot(np.arange(len(proper_sampling)), signal(proper_sampling), label='Original')\n", - "ax.plot(np.arange(len(interval_priority_sampling)), signal(interval_priority_sampling), label='Interval')\n", - "ax.plot(np.arange(len(increment_priority_sampling)), signal(increment_priority_sampling), label='Increment')\n", - "ax.grid()\n", - "\n", - "ax.set_ylabel('Signal Amplitude')\n", - "ax.set_xlabel('Sample Index')\n", - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "ax = fig.add_subplot(111)\n", - "reference_signal = signal(proper_sampling)\n", - "ax.plot(np.arange(len(proper_sampling)), reference_signal - reference_signal, label='Original')\n", - "ax.plot(np.arange(len(interval_priority_sampling)), signal(interval_priority_sampling) - reference_signal, label='Interval')\n", - "ax.plot(np.arange(len(increment_priority_sampling)), signal(increment_priority_sampling) - reference_signal, label='Increment')\n", - "ax.grid()\n", - "\n", - "ax.set_ylabel('Signal Difference')\n", - "ax.set_xlabel('Sample Index')\n", - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "ax1 = fig.add_subplot(211)\n", - "ax2 = fig.add_subplot(212, sharex=ax1)\n", - "\n", - "proper_sampling_spectrum = np.fft.rfft(signal(proper_sampling))\n", - "interval_sampling_spectrum = np.fft.rfft(signal(interval_priority_sampling))\n", - "increment_sampling_spectrum = np.fft.rfft(signal(increment_priority_sampling))\n", - "ax1.plot(np.fft.rfftfreq(len(proper_sampling)), proper_sampling_spectrum.real, label='Original')\n", - "ax1.plot(np.fft.rfftfreq(len(interval_priority_sampling)), interval_sampling_spectrum.real, label='Interval')\n", - "ax1.plot(np.fft.rfftfreq(len(increment_priority_sampling)), increment_sampling_spectrum.real, label='Increment')\n", - "ax2.plot(np.fft.rfftfreq(len(proper_sampling)), proper_sampling_spectrum.imag)\n", - "ax2.plot(np.fft.rfftfreq(len(interval_priority_sampling)), interval_sampling_spectrum.imag)\n", - "ax2.plot(np.fft.rfftfreq(len(increment_priority_sampling)), increment_sampling_spectrum.imag)\n", - "\n", - "ax1.grid()\n", - "ax2.grid()\n", - "ax1.set_ylabel('Amplitude')\n", - "ax2.set_ylabel('Phase')\n", - "ax2.set_xlabel('Frequency')\n", - "ax1.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Frequency')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACT90lEQVR4nOzdeXhU1fnA8e+dNZnsISQhIRAQBBEQBEHclVXcsGpdqIBaUCtuaBVaRAEVtajUveICWhGrpVatPwRRXClYFEU2ZQ2EJCwhmUwmme3e3x83MyRkmwkzk+39PM99ZubOveeeeTPLm3PPPUfRNE1DCCGEEELUydDcFRBCCCGEaMkkWRJCCCGEaIAkS0IIIYQQDZBkSQghhBCiAZIsCSGEEEI0QJIlIYQQQogGSLIkhBBCCNEAU3NXoC1QVZX9+/eTkJCAoijNXR0hhBBCBEHTNMrKysjKysJgqL/9SJKlMNi/fz85OTnNXQ0hhBBCNMHevXvp3Llzvc9LshQGCQkJgB7sxMTEsJXr8XhYsWIFo0aNwmw2h61cUZPEOTokztEjsY4OiXN0RDLOdrudnJycwO94fSRZCgP/qbfExMSwJ0s2m43ExET5IEaQxDk6JM7RI7GODolzdEQjzo11oZEO3kIIIYQQDZBkSQghhBCiAZIsCSGEEEI0QPosiZap0g5lhdDxxOauiRCinfD5fHg8nqC393g8mEwmKisr8fl8EaxZ+3Y8cTabzRiNxuOugyRLomV653ew60uY+j9I69HctRFCtGGaplFYWEhJSUnI+2VmZrJ3714ZYy+CjjfOycnJZGZmHtffSJIl0TId+hXQoPBHSZaEEBHlT5TS09Ox2WxB/6iqqorD4SA+Pr7BAQ3F8WlqnDVNw+l0cuDAAQA6derU5DpIsiRaJpddvy3Ja956CCHaNJ/PF0iUOnToENK+qqridruJiYmRZCmCjifOsbGxABw4cID09PQmn5KTv65oeVQfuB36/ZK9zVsXIUSb5u+jZLPZmrkmIlL8f9tQ+qMdS5Il0fL4W5VAWpaEEFEhfY7arnD8bSVZEi1PZenR+6XSsiSEEKJ5NSlZevPNNznzzDPJyspiz549ACxYsIB///vfYa2caKcqj2lZ0rTmq4sQQoh2L+Rk6cUXX2TatGmMHTuWkpKSwJgHycnJLFiwINz1E+1R9dNwHic4i5uvLkII0Qbt3r0bRVHYsGFD0PssWrSI5OTkZq9Hcwg5WXr22WdZuHAhf/7zn2v0Kh88eDAbN24Ma+VEO1W9ZQmgZE/z1EMIIVq4vXv3cuONN5KVlYXFYqFr167ceeedHD58uMH9cnJyKCgooG/fvkEf6+qrr+aXX3453iq3SiEnS7t27WLgwIG11lutVsrLy8NSKdHOuY5NlqSTtxBCHGvnzp0MHjyYX3/9lbfffpvt27fz0ksvsWrVKoYNG0Zxcd2t8m63G6PRSGZmJiZT8CMIxcbGkp6eHq7qtyohJ0vdunWrs7ls+fLlnHTSSeGok2jvjm1Zkk7eQogo0jQNp9sb1FLh9gW9bWOLFmL/zNtuuw2LxcKKFSs499xz6dKlCxdeeCGffvop+fn5/PnPfwYgNzeXuXPnMmHCBBITE5kyZUqdp78++OADevbsSUxMDOeffz6LFy9GUZTAyObHnoZ76KGHGDBgAG+++Sa5ubkkJSVxzTXXUFZWFthm+fLlnHXWWSQnJ9OhQwcuvvhiduzY0eS/TXMJeVDKadOmcdttt1FZWYmmaaxbt463336befPm8corr0SijqK9cZXWfCwtS0KIKKrw+Ogz65OoH3fznNHYLMH9LBcXF/PJJ5/wyCOPBAZe9MvMzGT8+PG88847vPDCCwDMnz+fWbNm8eCDD9ZZ3q5du7jyyiu58847+f3vf88PP/zAvffe22g9duzYwfvvv89HH33EkSNH+O1vf8tjjz3GI488AkB5eTnTpk2jf//+OBwOZs2axeWXX86GDRta1UCeISdLv//974mNjWXmzJk4nU6uu+46srKy+Otf/8o111wTiTqK9sbfsmSJ1wenlIEphRCihl9//RVN0+o9o3PSSSdx5MgRDh48CMAFF1zAPffcE3h+9+7dNbb/29/+Rq9evfjLX/4CQK9evfj5558DSU99VFVl0aJFJCQkAHD99dezatWqwH5XXHFFje1fe+01OnbsyObNm0PqL9XcmjTdyfjx4xk/fjxOpxOHw9Fuz2GKCPH3Wco4GfaulZYlIURUxZqNbJ4zutHtVFWlzF5GQmJCWFpJYs2hT8UR7Km7wYMHN/j8tm3bOO2002qsGzJkSKPl5ubmBhIl0Odf88/FBnpSN2vWLNauXcuhQ4dQVRWAvLy8tp0s7dq1C6/XS8+ePbHZbIFhxH/99VfMZjO5ubnhrqNob/yDUvqTpdK9+lhLMsKuECIKFEUJ6nSYqqp4LUZsFlPUTyn16NEDRVHYsmULl19+ea3nt2zZQkpKCh07dgQgLi4uIvUwm801HiuKEkiIAC655BK6du3KwoULycrKQlVV+vbti9vtjkh9IiXkv+6kSZP49ttva61fu3YtkyZNCkedRHtXWa1lCfSWpsqSZquOEEK0NB06dGDkyJG88MILVFRU1HiusLCQt956i6uvvjroqT569erF//73vxrrvvvuu+Oq4+HDh9m2bRszZ85k+PDhgVODrVHIydIPP/zAmWeeWWv96aefHpVBpZ5//nlyc3OJiYlh6NChrFu3rt5tFy1ahKIoNZaYmJga22iaxqxZs+jUqROxsbGMGDGCX3/9NdIvQzTEfxouPgPi9P+KpN+SEELU9Nxzz+FyuRg9ejRffvkle/fuZfny5YwcOZLs7OxG+xtVd/PNN7N161buv/9+fvnlF/7xj3+waNEioOlzq6WkpNChQwdefvlltm/fzmeffca0adOaVFZzCzlZUhSlxmWBfqWlpYHRvCPlnXfeYdq0aTz44IN8//33nHLKKYwePbrG+dFjJSYmUlBQEFj807P4PfHEEzzzzDO89NJLrF27lri4OEaPHk1lZWVEX4togL9lKSYJknL0+9JvSQghaujZsyf/+9//6N69O7/97W854YQTmDJlCueffz5r1qwhNTU16LK6devGe++9x7Jly+jfvz8vvvhiYOgBq9XapPoZDAaWLl3K+vXr6du3L3fffXegA3mro4Xo4osv1q666irN6/UG1nm9Xu2KK67QxowZE2pxIRkyZIh22223BR77fD4tKytLmzdvXp3bv/7661pSUlK95amqqmVmZmp/+ctfAutKSko0q9Wqvf3220HXq7S0VAO00tLSoPcJhtvt1t5//33N7XaHtdwWb34vTXswUdPyf9C0dybo9799PmKHa7dxjjKJc/RIrINXUVGhbd68WauoqAh5X5/Ppx05ckTz+XwRqFnze/jhh7XOnTs3dzWOO84N/Y2D/f0OuYP3448/zjnnnEOvXr04++yzAfjqq6+w2+189tlnYU7ljnK73axfv54ZM2YE1hkMBkaMGMGaNWvq3c/hcNC1a1dUVeXUU0/l0Ucf5eST9b4wu3btorCwkBEjRgS2T0pKYujQoaxZs6beoRBcLhculyvw2G7XW0I8Hg8ej+e4Xmd1/rLCWWZrYKq0owAekw1DYjZGwHdkN2qE4tBe4xxtEufokVgHz+PxoGkaqqrW6JgcDK3qSjT//q3diy++yODBg+nQoQPffPMNf/nLX7jtttua/bUdb5xVVUXTNDweT41p2iD4z0jIyVKfPn346aefeO655/jxxx+JjY1lwoQJTJ06NaQmv1AdOnQIn89HRkZGjfUZGRls3bq1zn169erFa6+9Rv/+/SktLWX+/PmcccYZbNq0ic6dO1NYWBgo49gy/c/VZd68ecyePbvW+hUrVgSuDgynlStXhr3MlkrRfFzq0afN+fSrdWQfKaM/cGDb/1jn+Tiix25PcW5OEufokVg3zmQykZmZicPhaPIVWnV1TWmNNm3axMMPP8yRI0fo3Lkzt912G3fffXegQaC5NTXObrebiooKvvzyS7xeb43nnE5nUGU0aZylrKwsHn300absGlXDhg1j2LBhgcdnnHEGJ510En/729+YO3duk8udMWNGjU5qdrudnJwcRo0aRWJi4nHVuTqPx8PKlSsZOXJkrcsz26yKI7BBvzviot+g7EyBf7xBZoybsWPHRuSQ7TLOzUDiHD0S6+BVVlayd+9e4uPja10A1BhN0ygrKyMhIaHJnaBbkueee47nnnuuuatRy/HGubKyktjYWM4555xaf+NgE8EmJUslJSWsW7eOAwcO1GoSmzBhQlOKbFRaWhpGo5GioqIa64uKisjMzAyqDLPZzMCBA9m+fTtAYL+ioiI6depUo8wBAwbUW47Vaq2zw5vZbI7IF1Okym2RyqomYzbFYo6xQYduACileyMeg3YV52YkcY4eiXXjfD4fiqJgMBhCHivJ//vn319ExvHG2WAwoChKnZ+HYD8fISdLH374IePHj8fhcJCYmFgjy1MUJWLJksViYdCgQaxatYpx48YBegBXrVrF1KlTgyrD5/OxcePGQAtFt27dyMzMZNWqVYHkyG63s3btWm699dZIvAzRGP+wATFVLXTJVVfDVZboV8nFhK/lTgghhAhGyCnaPffcw4033ojD4aCkpIQjR44EluLi4kjUMWDatGksXLiQxYsXs2XLFm699VbKy8u54YYbAL1Vq3oH8Dlz5rBixQp27tzJ999/z+9+9zv27NnD73//e0BP7u666y4efvhhPvjgAzZu3MiECRPIysoKJGQiyvzDBlirkiJrAsSm6PdLZawlIYQQ0Rdyy1J+fj533HFHRDoyN+bqq6/m4MGDzJo1i8LCQgYMGMDy5csDHbTz8vJqNNEdOXKEyZMnU1hYSEpKCoMGDeLbb7+lT58+gW3uu+8+ysvLmTJlCiUlJZx11lksX7485HPXIkxc1cZY8kvuovdlKtl7dFRvIYQQIkpCTpZGjx4dGASrOUydOrXe026rV6+u8fjpp5/m6aefbrA8RVGYM2cOc+bMCVcVxfGoPOY0HOgDUxb8KANTCiGEaBYhJ0sXXXQRf/zjH9m8eTP9+vWr1Tnq0ksvDVvlRDvkOuY0HEByV/22ZE/t7YUQQrRKixYt4q677qKkpKS5q9KokJOlyZMnA9TZEqMoSsSnPBFtXF0tS/5O3tJnSQghAiZNmkRJSQnvv/9+UNsrisK//vUv6ZPbBCEnS809kqdo41yl+m2NlqUu+q2chhNCiGbn8Xja3ZAUxzUwhEw2K8Kuso4O3oHJdKVlSQgh6nLeeedxxx13cN9995GamkpmZiYPPfRQ4Pnc3FwALr/8chRFCTwG+Pe//82pp55KTEwM3bt3Z/bs2TVGulYUhRdffJFLL72UuLg45s6dS+fOnXnxxRdr1OGHH37AYDAEJqx/6qmn6NevH3FxceTk5PCHP/wBh8MRsRhEUsjJks/nY+7cuWRnZxMfH8/OnTsBeOCBB3j11VfDXkHRzlQ20LLkPATu8ujXSQjRvmia/l0TzOJxBr9tY0vVHGhNtXjxYuLi4li7di1PPPEEc+bMCUx589133wHw+uuvU1BQEHj81VdfMWHCBO688042b97M3/72NxYtWsQjjzxSo+yHHnqIyy+/nI0bN/L73/+ea6+9liVLltTY5q233uLMM8+ka1e9n6nBYOCZZ55h06ZNLF68mM8++4z77rvvuF5jcwn5NNwjjzzC4sWLeeKJJwL9lwD69u3LggULuOmmm8JaQdHOHDsoJUBsMliT9FN0pfugY69mqZoQop3wOOHRrEY3MwDJ4Tzun/aDJa7Ju/fv358HH3wQgJ49e/Lcc8+xatUqRo4cSceOHQFITk6uMevF7NmzmT59OhMnTgSge/fuzJ07l/vuuy9QFsB1110XGNMQYPz48Tz55JPk5eXRpUsXVFVl6dKlzJw5M7DNXXfdFbifm5vLww8/zC233MILL7zQ5NfYXEJuWXrjjTd4+eWXGT9+fI3Ze0855ZR6J7QVImjHDkrp5+/kLf2WhBCiTv3796/xuFOnThw4cKDBfX788UfmzJlDfHx8YJk8eTIFBQU1JpkdPHhwjf0GDBjASSedFGhd+uKLLzhw4ABXXXVVYJtPP/2U4cOHk52dTUJCAtdffz2HDx8OevLalqRJg1L26NGj1npVVfF4PGGplGjH6hqUEvRTcUU/S7IkhIg8s01v5WmEqqrYy8pITEgIz9xw5uMb7PnYTteKojR6UZbD4WD27Nn85je/qfVc9cGZ4+Jqt3iNHz+eJUuWMH36dJYsWcKYMWPo0KEDALt37+biiy/m1ltv5ZFHHiE1NZWvv/6am266Cbfb3SwDWx+PkJOlPn368NVXXwXOSfq99957DBw4MGwVE+1UXUMHQLVO3pIsCSEiTFGCOx2mqmD26du2gol0zWZzreF9Tj31VLZt21ZnI0hjrrvuOmbOnMn69et57733eOmllwLPrV+/HlVVefLJJwOJ5D/+8Y/jewHNKORkadasWUycOJH8/HxUVWXZsmVs27aNN954g48++igSdRTtSV2DUoIMHyCEEMcpNzeXVatWceaZZ2K1WklJSWHWrFlcfPHFdOnShSuvvBKDwcCPP/7Izz//zMMPP9xoeWeccQY33XQTPp+vxqDUPXr0wOPx8Oyzz3LJJZfwzTff1EimWpuQU+HLLruMDz/8kE8//ZS4uDhmzZrFli1b+PDDDxk5cmQk6ijaC59H71gJdZyGk4EphRDieDz55JOsXLmSnJycwJmg0aNH89FHH7FixQpOO+00Tj/9dJ5++ulaZ4/qM378eH788Ucuv/xyYmNjA+tPOeUUnnrqKR5//HH69u3LW2+9xbx58yLyuqJB0bTgr1X0er08+uij3HjjjXTu3DmS9WpV7HY7SUlJlJaWkpiY2PgOQfJ4PHz88ceMHTu2fQwA5iyGJ7rp9x84BMZqr3n/D/DyeRCfAff+EtbDtrs4NxOJc/RIrINXWVnJrl276NatW8gTqKuqit1uJzExMTx9lkSdjjfODf2Ng/39DumoJpOJJ554osZgVUKEjX+MJbOtZqIEkFR1Gs5RBB4ZDFUIIUT0hJyiDR8+nC+++CISdRHtXV0DUvrZUsFc1eGydF/06iSEEKLdC7mD94UXXsj06dPZuHEjgwYNqnU5YfUOXkKEpK4BKf0URe/kfXALlOZBWuhXbgghhBBNEXKy9Ic//AHQ53w5lqIotS5LFCJo9Q1I6ZecoydLckWcEEKIKAo5WWpsgCshmqy+ASn9ZPgAIYQQzeC4uu9XVka/o+3zzz9Pbm4uMTExDB06lHXr1tW77cKFCzn77LNJSUkhJSWFESNG1Np+0qRJKIpSYxkzZkykX4aoS30DUvoFBqaU4QOEEEJET8jJks/nY+7cuWRnZxMfH8/OnTsBeOCBB3j11VfDXsHq3nnnHaZNm8aDDz7I999/zymnnMLo0aPrnftm9erVXHvttXz++eesWbOGnJwcRo0aRX5+fo3txowZQ0FBQWB5++23I/o6RD3qG5DST1qWhBBCNIOQk6VHHnmERYsW8cQTT2CxWALr+/btyyuvvBLWyh3rqaeeYvLkydxwww306dOHl156CZvNxmuvvVbn9m+99RZ/+MMfGDBgAL179+aVV15BVVVWrVpVYzur1UpmZmZgSUlJiejrEPXwXw1XX8uSP1mSgSmFEEJEUch9lt544w1efvllhg8fzi233BJYf8opp7B169awVq46t9vN+vXrmTFjRmCdwWBgxIgRrFmzJqgynE4nHo+H1NTUGutXr15Neno6KSkpXHDBBTz88MOByQDr4nK5cLlcgcd2u94i4vF4wjqZsL+s9jJBsbGiBAPgM8ej1vWa4zphBjT7fryV5WC01N6mCdpbnJuLxDl6JNbB83g8aJqGqqoh98n1j+ns319ExvHGWVVVNE3D4/FgNBprPBfsZyTkZCk/P7/OCfdUVY3oB/PQoUP4fD4yMjJqrM/IyAg6Sbv//vvJyspixIgRgXVjxozhN7/5Dd26dWPHjh386U9/4sILL2TNmjW1guo3b948Zs+eXWv9ihUrIjKT8sqVK8NeZks0ePcvZAObduxll/3j2htoGhcrZoyah9UfLMFpTQ/r8dtLnJubxDl6JNaNM5lMZGZm4nA4cLvdTSqjrKwszLUSdWlqnN1uNxUVFXz55Ze1BtV2Op1BlRFystSnTx+++uqrWvPGvPfee4G5Zlqixx57jKVLl7J69eoaw51fc801gfv9+vWjf//+nHDCCaxevZrhw4fXWdaMGTOYNm1a4LHdbg/0hwr3dCcrV65k5MiR7WLKAuOS16AE+gwcxkn9x9a5jWFvVzi8nfMHdkfLPScsx21vcW4uEufokVgHr7Kykr179xIfHx/ydCeaplFWVkZCQgKKokSohvW74YYbKCkp4V//+lfUjx1N9cU52NdfWVlJbGws55xzTp3TnQQj5GRp1qxZTJw4kfz8fFRVZdmyZWzbto033niDjz76KNTigpaWlobRaKSoqKjG+qKiIjIzMxvcd/78+Tz22GN8+umn9O/fv8Ftu3fvTlpaGtu3b683WbJarVit1lrrzWZzRL6YIlVui+PW/2swxaVAfa83WU+WTI6C+rdponYT52YmcY4eiXXjfD4fiqJgMBhCnnfMf0rIv3+0+a/gjsSxq8eludUX52Bfv8FgQFGUOj8PwX4+Qo7CZZddxocffsinn35KXFwcs2bNYsuWLXz44YeMHDky1OKCZrFYGDRoUI3O2f7O2sOGDat3vyeeeIK5c+eyfPlyBg8e3Ohx9u3bx+HDh+nUqVNY6i1CUNnIOEugD0wJckWcEEJUc95553HHHXdw3333kZqaSmZmJg899FCNbUpKSrj55pvJyMggJiaGvn37Bho5Fi1aRHJyMh988AF9+vTBarWSl5eHy+Xi3nvvJTs7m7i4OIYOHcrq1asDZfr3++ijj+jVqxc2m40rr7wSp9PJ4sWLyc3NJSUlhTvuuKPGoNXBlvvJJ59w8skn07lzZy688EIKCgoAeOihh1i8eDH//ve/A0lT9f3DLaiWpWeeeYYpU6YQExNDXl4eZ511VrOcC582bRoTJ05k8ODBDBkyhAULFlBeXs4NN9wAwIQJE8jOzmbevHkAPP7448yaNYslS5aQm5tLYWEhAPHx8cTHx+NwOJg9ezZXXHEFmZmZ7Nixg/vuu48ePXowevToqL++dq+xoQNAhg8QQkScpmlUeCsa3U5VVSq8FZg8prC0wMSaYo/rdN7ixYuZNm0aa9euZc2aNUyaNIkzzzyTkSNHoqoqF154IWVlZfz973/nhBNOYPPmzTX65jqdTh5//HFeeeUVOnToQHp6OlOnTmXz5s0sXbqUrKws/vWvfzFmzBg2btxIz549A/s988wzLF26lLKyMn7zm99w+eWXk5yczMcff8zOnTu54oorOPPMM7n66qsBgi53/vz5LF68mIqKCm699Vbuvfde3nrrLe699162bNmC3W7n9ddfB6h18VY4BZUsTZs2jWuuuYaYmBi6detGQUEB6enh7VwbjKuvvpqDBw8ya9YsCgsLGTBgAMuXLw90+s7Ly6vxhn3xxRdxu91ceeWVNcp58MEHeeihhzAajfz0008sXryYkpISsrKyGDVqFHPnzq3zNJuIsMYGpQRI8idLMnyAECIyKrwVDF0yNOrHXXvdWmzmpl8k1L9/fx588EEAevbsyXPPPceqVasYOXIkn376KevWrWPLli2ceOKJgN7tpDqPx8MLL7zAKaecAui/qa+//jp5eXlkZWUBcO+997J8+XJef/11Hn300cB+L774IieccAIAV155JW+++SZFRUXEx8fTp08fzj//fD7//HOuvvrqkMp96aWX6NatG3a7ndtuu425c+cCeqNHbGwsLper0a444RBUspSVlcU///lPxo4di6Zp7Nu3r97Ru7t06RLWCh5r6tSpTJ06tc7njm2C2717d4NlxcbG8sknn4SpZuK4+Dzg/09OWpaEECJkx/bJ7dSpU2DQ5g0bNtC5c+dAolQXi8VSo4yNGzfi8/lq7eNyuWoMr2Oz2QKJEuhXqefm5hIfH19jnb8uoZbr77OUmZlZ7yDUkRZUsjRz5kxuv/12pk6diqIonHbaabW20TRNJtIVTVdZ7YqEBpOlqj5L9nzwecEY8jUKQgjRoFhTLGuvW9vodqqqBq7SCtdpuONxbGdlRVECiUZsbONlx8bWPA3ocDgwGo2sX7++1lA61ROhuo7bUF2Op1z/mEvRFtQvzZQpU7j22mvZs2cP/fv359NPP21w0EYhQuaqGr3bHNdwAhSfCQYzqB4o23+0pUkIIcJEUZSgToepqorX5MVmtrWIq8Ya0r9/f/bt28cvv/zSYOtSdQMHDsTn83HgwAHOPvvssNUlXOVaLJaoNdCE1MG7b9++vP766wwbNiyoLFWIoDU21YmfwQBJneHILr3fkiRLQgjRqHPPPZdzzjmHK664gqeeeooePXqwdevWBiePP/HEExk/fjwTJkzgySefZODAgRw8eJBVq1bRv39/LrrooibVJVzl5ubm8sknn7Bt2zY6dOhAUlJSxIbKCCoVnjZtWmDgphtvvFFGKxXhVxnElXB+0m9JCCFC9s9//pPTTjuNa6+9lj59+nDfffc12jLz+uuvM2HCBO655x569erFuHHj+O677467f3I4yp08eTK9evVi8ODBdOzYkW+++ea46tQQRQviBGCXLl2YMWMGY8eOpVu3bvzvf/8jLS2t3m3bG7vdTlJSEqWlpWEfwfvjjz9m7NixbX9guS0fwju/g86nwe8/bXjbf0+FH96E8/8M59533IduV3FuRhLn6JFYB6+yspJdu3bRrVu3kEfwVlUVu91OYmJiiz8N15odb5wb+hsH+/stHbxFyxDMgJR+gZalPZGrjxBCCFFFOniLliGYASn95DScEEKIKAr6uuuEhIRAB+8zzzxTBm0U4RXMgJR+Sf4pT2RgSiGEEJEX8iA1EydOjEQ9RHvXlJal0n2gqvoVckIIIUSEBJUspaam8ssvv5CWlkZKSkqDc9cUFxeHrXKiHQl26ACAhE6gGPWxlhyFkJgV2boJIdq85hrsUEReOP62QSVLTz/9NAkJCYH7xzPRnxB1CrQsBdHB22iCpGy9z1JJXutIlnweOLAFCjbodTZawBQD5lj91hQD5hgwxeq3MUnQsTcY5UomISLJf7Wg0+mU8QPbKKfTCdQeETwUQSVL1U+9TZo0qckHE6JeobQsgT6hbkme3m+py+mRq1dT+DxwcCvs3wD7f9ATpMKfwecKrRxTLGQNhJzToPMQyBkC8dGfwFqItsxoNJKcnByYc8xmswXdIKCqKm63m8rKShk6IIKaGmdN03A6nRw4cIDk5ORaU6uEIuQ+S6WlpaxcuZLdu3ejKArdu3dn+PDhYR1fSLRDoQxKCXq/pT20nOEDyor0sZ+2/R8U/QzeOiaatiZBp/6QdiKoXn0bbyV4KvVJhKvfOg7oU8Dkfasvfsld9aSp8xDoMhQy+4O09ApxXPyz1oc6SaumaVRUVNSaU02E1/HGOTk5OfA3bqqQkqW///3vTJ06NTCat19SUhIvvfQSV1999XFVRrRjrhDGWYJqnbyb8Yo4VYXdX8L/XoOt/9ETID9rInQ6BbIGQKcBegtRSrfgO6OrKhz+FfZ9B3vX6bcHtujJYcke2Piuvl1iNvS+CE66BLqcIRMLC9EEiqLQqVMn0tPT8Xg8Qe/n8Xj48ssvOeecc2Twzwg6njibzebjalHyC/qb9fvvv+eGG25g/Pjx3H333fTu3RtN09i8eTMLFizg+uuvp3fv3pxyyinHXSnRDoUydABAsn/4gGYYa6n8MPy4BP73OhTvOLo+ZygMvB66nhFaYlQXgwE69tKXgb/T11WWQv562Psd7FsHe9aAPR/WvawvsanQayycdDF0P1/v+ySECJrRaAzph9VoNOL1eomJiZFkKYJaQpyDTpaeffZZxo0bx6JFi2qsP/XUU3njjTdwOp389a9/5bXXXgt3HUV7EMrQARD9gSk1DfL+q7cibX4ffG59vSUBTrkGBt8AGSdHtg4xSXDCBfoC+um6nav1qWK2fQwVxbDh7/piiYceI/QWp54jg2+xa0s0TT/N6XaCpxw8FeAuB4/z6DqvC8w2PUm3JuinSv33TTFyilMIAYSQLH3zzTe88MIL9T5/yy238Ic//CEslRLtjNd9tI9P0B28q1qWSvfpP4qR+lFTVdj6EXw1Hwp+PLo+ayAMugH6XgHW+MgcuzHmGOg1Rl98Xr1v05aP9Pra8/WkbvP7YDBD7ll6q1OvC4+2yrUFFSVwZHfVsqva/d1V43B5G9q7YQaz/n6MSYKkzpCSW3NJzgVbqiRUddE0PSmttOstoq4y0FQwGEExVN0aj97618UkQUyyjJ0mWpygk6X9+/dz4okn1vv8iSeeSH5+flgqJdoZV7U+cMG2LCVm61+w3qrO0AkZ4a2TzwublsFXT+pXtoHeAtHvSj1Jyj41vMc7XkYTdDtHXy58HPZ/r7c4bf0PHPoFdn6uL//3R71TeK+x0Hts6+kgXn5I7zhftElfDmzWE6KKI8Htb7SCxQbmuKpbG1jiwGTVW5tcZfoPu8uu30fTx/FyHtaX4p2w68va5VoSqpKnrpDWU++8n9ZLvx9s4t9a+Lz6uGal+WDfV3WbD/b9+t/BVZUY+ePY1ERVMUBsin5a2dahakk5ej+hk/75T8qGhCwwWcL7Olsqd7n+OagoBmfVUlHHradCj73PA6pPfx8f+9hg1j8Hlrijn4lj78ckQ3wGxHeEuHT9vq1Du+0XGfSrdjqdDc7IbLVaqays4wqgMHv++ef5y1/+QmFhIaeccgrPPvssQ4YMqXf7d999lwceeIDdu3fTs2dPHn/8ccaOHRt4XtM0HnzwQRYuXEhJSQlnnnkmL774Ij179oz4a2npVE3lgPMA+Y589jv2s8+xj8MVh3F6nDi9TpweJ+XecpweJxXeCso9+n2f5sNmsmEzVy0mG3HmOGwmG7HmWOLMcSRaEsmOzyY7Ppssr48sBazmeP2/y2CYLPqXpj0fVj8Kwx/U/8s/Xl43/Pg2fP203lIB+qmZoTfD6beG5xjH0DSN4sriGnE+6Dyox7Mqzk6vMxBf/zq36ibWFBuIb6wpFpv5aKxtNhsJQ6+mEyayj+wle98Gsvf9gK3wJyj8Cb54DBI76y1TOUMhexCkdm/e5MnrgkO/ViVF1ZIjR2H9+8SlH23tSe1WreWni558m22BL3i7205+2dE4F5YXBuIciK+nPLCUe524fG6sBhM2jNg0iFN92LwubB4XNlXF5ssn/sBeMvZ/QbbXW7X4SIzLQEk7UU+gOlYlUCnd9B/6lviD43bqF0yU5FVdSFA1jllpVWLkKNRbh4LgVBT2m83sN5vZFxNHgTWWMgWcQLmi4UTDqVBtUXAqYNY04jSNWFUjTi3D5rVjK9lB3BGNWFXFpmmke3014twhtiNKUnZVAtX5aCKV2Fm/jc8I/nulOag+PQkq2w/2gmq3BXoiWlagP3aV1trVDRSYTOSbTOSbjew3mSgxGHAaDHpMDQacZgWnYqDcoN9WGCwoQJxajk11YPOq2NwaNk3FpmrEqfr9Dj4fWf5Ye7yk+3wYUfSEKT69asmExE560lr9Ni69Zb7Hj0NIr+aTTz4hKanuvg8lJSXhqE+D3nnnHaZNm8ZLL73E0KFDWbBgAaNHj2bbtm2kp9cef+bbb7/l2muvZd68eVx88cUsWbKEcePG8f3339O3b18AnnjiCZ555hkWL15Mt27deOCBBxg9ejSbN29uMDmMNE3TcLq9uHzgdHsxa5H5AXP5XOwr28tu+y72luVRUF7A/vJ89jvyKXIW4lGDvzKkujJPGWWesuB3yO1CR59Gp//8jqy4bDrFZ5Ed35ncxFy6JnYj0VL7v3TzSZdjXvscrF+Etul9PGf9Ee+gG/UBH0Pg8Xjxetx4//sSxnUvYCjbD4AW2wHP0FvxnnrT0VYCd9P+W/aqXvaX57PHvps8+x4Kyvezv3w/+x35FJTvp9LXtH80yj3llHvKOVhxsPGNjUDXbJKNsWSp0Lm8hGy3g85bl5K78U26ezykmhPQOg1E7TQQNetU1E4D0RI6Nalux/J4qr2fK8swHPoF5fAvVbe/6rclu1Hq+UFWU7qjpvdBTT8ZreNJqKknoCV30ftn+bfRVA44i9ht383evavJd+zT39NVcQ7pPVlNheqhAg+HARTAbNAHFG1AvKqS5dpG9p5NZO/w0tnrpavHS65XIzMuEyW5K1pyLmpyF7SkrmgpXVGTuugtKsf5414j1ipQWYLiKEIpP1C1HNQfl+5FKc3DULIXxdn4e0gzmNASOqEmZFGckMHO2Dh2m0zsw8N+Xzn73aUUuIspdtsbKEWpWmpzKQou0N+rQYpRVbK8+8kqziP7gJ5EdfV46ebx0NnjxaQY0RIy0RKy0BKzj97GpaHFpEBsMlpMClpsip5chxD7GnH2f0drmj4EiKsMxWVHcdmh/BCKo1CPeVkhSnkRSllB1d/kIIrmq/cYdoPCbrOZXfFx7LXEkG+NJd9sJt8ABxUfTR2busRopCSEOJs0jU5eL1leH529hWQd3keXIi/d3B66er3EVBslW1MMaHEd0RI6ocVngq0Dmq0Dmq1j1W0aWlwa2NLQbB30/oEN8Me5OUdZV7Qgjx7MQFCKouDz1f9HP15Dhw7ltNNO47nnngP0gapycnK4/fbbmT59eq3tr776asrLy/noo48C604//XQGDBjASy+9hKZpZGVlcc8993DvvfcC+jhSGRkZLFq0iGuuuabOerhcLlyuowMM2u12cnJyOHToUNjGm3K6vax97CLKiGWdehLr1N7s0jKp70umUcZyjJaDGCwHMVgPVN0eRDEXoyj1vwU0zYDmSUb1pKB6UtC8iWg+K6hWNNUKqgVNtaKplqPrUMDgRjG4UAxuqLpVDK6j940ODOYjKOYjmC2HUQ0NJyGqNx7V1RHV3RHVla7fujtyhm8fM01vcZJBH0Jgp5rJPO91rFQHNRorIz5OVX7lAuMPXGn8go6K/gVfpCXzsvdilvguoIIQE2aDS49tjTgfwGA5jKLU/9nQNAXNm4DqSUXzpKB6kkCNOSa2lqqYV63TTKC4q8W2eoz9cXaimI9gMJdgsBSjGCsarH6CT6Wbx0Oux0O3qh+cBLeNI64cjmjJlBJHqRaHnThKtPjA41LicGoxJChOknGQpJSTjINkxUGyUk5S1f2OlHKCYT+ZSv2nz+yajS1aF7aqOWzVurBV7cI2LQdn9b+F4sFgOYzBcgCD9WC1mB/U33MNUL1xaJ5U/f3sSUbzxdaObfV4a2ZQPPXE2X+/8miMzUcwmBwN1iFGVcmtim+3arHu6tF/dMq0WOzYsGs2yqpu7cRh12w4iMWAhgkfZrxY8Or3Ff2+vs5DqlJGR6WENEqxNPDeq65Mi2Wf1rFqSSNPS2OnKZZ8i8Zhs4cKa9nRODfyXtJ8MUe/N9wpaD5btRj74+z//rCCZgHFq//9FDeK0VVHnF0YTKUolmIM5iMYTKUNfsxNmkaOx0v36nF26+/vhDp++lRNwY4t8N52Y0LFgIaCpimo6ItWbYlR3CTgJAEn8UoFCVRgDjLefl5NYYsxmR/NSWwzx7LbbKLAonHE4sJtangwW001V8W46j3ti6vxXq75Pa3fB63Ge7nm+7pqncmOwXIk8D2tKPW3KioapHkh1+PlRHcFJ3jddHfr7+kUVW30V8ulmXBhrlosuDQz7sBjMy5NXz/wzndISkoOKbaNsdvtpKWlUVpa2uDvd9AtS6oaXPNrpLjdbtavX8+MGTMC6wwGAyNGjGDNmjV17rNmzRqmTZtWY93o0aN5//33Adi1axeFhYWMGDEi8HxSUhJDhw5lzZo19SZL8+bNY/bs2bXWr1ixApvNFupLq5PPXcFlhu8xKhpXGL8G4ICWzDq1N/+tSp5+1bLRqEpiFbf+pvZ/iZirvrQtVfeN9bdcaL6YqiQkDTXwI5KC6k5F8yYS0r951csNcrtRhrU8FvMsq4zdmMFV1V7HYf2H0FyKweTQf4DidtXY90fVxJWejqR70xjm288J3nKu8L7E+a4c3qj8LVu9van+bZpMGecafuQC4wbONfxIslIeeG6v2pGXfJfwnu8cXNTTOqV4UUz6j6L/S8RgLsZgOdLoj6SmmlHdaVWJnj8p8sc5WU9+miCk/7UMlXp9/XW3FOuPqxLnMqOBn4xWfoqx1tjNqB0m03uAbK+XLK/eSjLUo58GyfZ66ejzEWqX3CItme1qNtu1LLZr2fqiZnGQZEDVv6ytVe9j825izMUo/i9vk73eJF/TDFVxTqv6AUmt8WOC1rQ+LiHFWXFjMJegVL039Hgf1v9hsR6i0gBbrRa2WmvWRdE0Ovp8VXH2ke2x09lbTJbXS2+vlwyvj6ZeOF2ixXFQS+aQlsRBkjikJbFP68AuQwJ7zRaKTBouc0XVZ68Eg7kIxbytxo9k9WNrmlL1PaG/nwOJvjsF1ZMKatOmDgmt7cCLYi6t+Rk0F2OwHMJgPYDX4GGXxcwuS+2oxfsUMjwa2V4vOV433b2VZHm9ZHtdZHnLyT3ORgxVU3AQSxmxHNIS2KUkscNkI89spcBk5LBJpczsptJcjmq2oxi8gAqU1y7Lk1gV5w56ou+uSkI9qWi+OJryT3RoL6/q81jtM6jH+TAG6wEwVnDQDAfNJr6zJdTY0+QzkeCxkOo1ku7V6OzxkOt10dNbzkneUpLxYlW8WPECVQl4PS/n3S++xGIK7+k9/1QojWk1JxUPHTqEz+cjI6NmR96MjAy2bt1a5z6FhYV1bl9YWBh43r+uvm3qMmPGjBpJmL9ladSoUWFrWfJ5Kni7w10UbF9DnNFOpbMIJypO5Vechu10NXxER6MFp8XGYaOBI76G/8sDyLBl0jWhK10TutE1oStdEnLpmtiVVGuHZh191ryxCNtylXFduzLqyrtqPe/0lJPnyCOvbA977LvZU6Yv+xx78eBBsR7ikBU+xAr4f+QrgMWkY6BjTBpxPi9xLgdxlaVYVZUNqsovmplYQwbW5O4UepJJOGkYiXi41ruRCm+F3jfI66Si6tbutnOo4iBaI18zqdbUQGz9se6akEu6LQOD0nKv8nH5XOQ79gXim1e2hz2lO8kr202F6ibfbCLfXPdXhlnTyPR6idcM2BQjsQYTNoOVWGMMNlMsseY4Yk3xHC4uJ6lrTypiEnDiC8S2wluBwfMTOb61pLjLOFBxAF8DpyYA4s3xdE3IpWtCLl0SutI1Ub+fFZeNydByv9q8qpdCZwG77bvJqxbr3fbdlHnsHDCZOGAy8UMd+xpR6GiwkqiYsSlmYg1m4gwWYo2WqnjrMbcqFnYfPExS5xwqjCYqFA2n6qbCU44z8N4u44BzO271aEuctY5jWo3WozGudpuTkIPV2HLH8lI1lYMVBwMxPhrvPRyuPITDqOEwwg5M6D+FNf/RTTMlkGSKxWawYDNYjsZaMWMz6PG3YiT/wAESOnWi0qDo39H4cKoeKlR34HvkQMUBKrxHgLpbVBXAqBjJie9S472sx7sLceZmuuI2CJqmUeI6UvW9sScQ4z1luyksL8Br9HLE6OUIsKPGnnFAHEnmRFKtyVVxthJr8MfXRKxixIaBWE3BXlDEjSPOJ/6YZOx4HTvIdn1a7jdKC2a1WrFaa3+tmM3msA2YZTKZeHLfv/Faq05PJcbVs6ULqn5TEs3xZCfk6J2m47MCHaj9j23m8LR6hZ2mt3qZ41JIiqv932gSsXRKTmMoNa9A86peCssL2e/YT74jP7DsL9nFviO/cFB1U6Go5FVWTWFgAGx1/LfrywdDPmzbFFR1Y02xNeJaPc7ZCdl19q9qHWJJT0xmIH1rrNU0jQPOA+wv38++sn2BeFfvJO3Bx94a732vvqjlei9U/++xEdhX9z83xzIbzIH41vV+7hDTvEn+8eiQkMDJGTWvLtY0jSOuI4G47nfsJ78sn/zy/ECndLfqplCtpJAg+rgpQP7PjW5mUAxk2jLJTsgmKy6L7ITsGrFOt6W36CS/ISnxcZzYMbfW+jJ3Wc04O/JrxNrpdXLIW8YhbxB93AxA0Zag6pMem66/l6ti3Tmhs/44LpvM+EzMhtY5sGVyvI3cDtnAmTXWV3orA3H2f2dU/64udZVS6rFT6gkiYTHBzVZL2AelDLa8VpMspaWlYTQaKSoqqrG+qKio3jlfMjMzG9zef1tUVESnTp1qbDNgwIAw1j50iqIwvMtwCvYXcEKXE0iwJuhXOpni9CvMjFZsZUXEFW0haeM/yXbaSTDHwZhb9VGkW9OPSKgDUlYxGUx0TuhM54TOdT7vzltDwapZHDz8K86Mk3B26kd5x544zTE1rjRzuBzk5edxQpcTiLfE17iirPpVfImWRLLis0ixprTaH+mmUBSFjLgMMuIyGJg+sNbzXtXLAecBipxFgQ7nNa6YrIq1w+Vg175ddM/pTrwlXo9t1dWSx8a8U1wnOto6ttof6aZQFIXUmFRSY1Lpm9a31vOqpnK44jD7y/dT7i4PXIl67FWTTo+Tcnc5BwsO0jO359HvjupXpFZ9j2TY9L9ra/2RbqoESwK9UnvRK7VXrec0TaPUVUp+eT52l/1obKtd/VvuKafCW0GZq4yigiJOzD0x8N0R+N4wH71KNS02jaz4LKzGutru2q4YUwzdk7vTPbl7nc873A7yHfmUuEpqXPVb/erqcm855a5ydufvxmJovmEiWk2yZLFYGDRoEKtWrWLcuHGA3o9q1apVTJ06tc59hg0bxqpVq7jrrrsC61auXMmwYcMA6NatG5mZmaxatSqQHNntdtauXcutt94ayZcTlHlnzuPjjz9m7NCxDWe/Q+6A9/+gD0r4we362DqXPBP+sYciJdSpToJk6TKMrjespGsj23k8nuDiLOpkMpjIis8iKz6rwe0CcT5d4twUBsVAR1tHOto6NrptINanSaxDpSgKyTHJJMckN7qtxPn4xFvi60xYj+WPc3P+k9qq/m2bNm0aCxcuZPHixWzZsoVbb72V8vJybrjhBgAmTJhQowP4nXfeyfLly3nyySfZunUrDz30EP/73/8CyZWiKNx11108/PDDfPDBB2zcuJEJEyaQlZUVSMhahdRuMOkjGDlXv2z+l+Xwwumw+YPmrllw/OOHhNiyJIQQQkRDk1qWSkpKeO+999ixYwd//OMfSU1N5fvvvycjI4Ps7Oxw1zHg6quv5uDBg8yaNYvCwkIGDBjA8uXLAx208/LyagxxcMYZZ7BkyRJmzpzJn/70J3r27Mn7778fGGMJ4L777qO8vJwpU6ZQUlLCWWedxfLly5t1jKUmMRjhzDv0+cD+NQUKN8I/rof+1+gjOscmN3cN6xdoWWqH85cJIYRo8UJOln766SdGjBhBUlISu3fvZvLkyaSmprJs2TLy8vJ44403IlHPgKlTp9Z72m316tW11l111VVcddVV9ZanKApz5sxhzpw54api88roA7//DL54HL5+Cn5aCru/hnHPQ/fzmrt2dauUliUhhBAtV8in4aZNm8akSZP49ddfa7S+jB07li+/rGPuJBF9JgsMfwBu/ESfvsK+D968HDa+19w1q5srMn2WhBBCiHAIOVn67rvvuPnmm2utz87ObnBsItEMcobALV/rp+I0FZZNgU3/au5a1VbZtKvhhBBCiGgIOVmyWq11DuL0yy+/0LFj41dpiCizxMG4F2HAeNB88M/fw5aPGt8vmlzSZ0kIIUTLFXKydOmllzJnzhw8Hn2CVUVRyMvL4/777+eKK64IewVFGBgMcOmz0P9qUL3w7iTYtry5a3VUhIYOEEIIIcIh5GTpySefxOFwkJ6eTkVFBeeeey49evQgISGBRx55JBJ1FOFgMMJlL8DJvwHVo18pt/3T5q4VeF3gq5ooUk7DCSGEaIFCvhouKSmJlStX8vXXX/PTTz/hcDg49dRTa0xGK1ooowl+87LeurTlA1g6Hq57p3mvkqusdkrXGt45f4QQQohwaPII3meddRZnnXVWOOsiosFohitehXcnwraPYck1MP5d6HZ289TH31/JkqC3fgkhhBAtTFDJ0jPPPBN0gXfccUeTKyOixGSBqxbBO7+DX1fAkqvhd/+ErsOiXxf/GEvSX0kIIUQLFVSy9PTTT9d4fPDgQZxOJ8nJyYA+orfNZiM9PV2SpdbCZIXfvglLr4Udn8FbV8L170POadGthwxIKYQQooULqoP3rl27AssjjzzCgAED2LJlC8XFxRQXF7NlyxZOPfVU5s6dG+n6inAyx8A1S6DbOeB2wN9/Awe3RbcOMiClEEKIFi7kq+EeeOABnn32WXr1OjpTcK9evXj66aeZOXNmWCsnosAcC9cuhZzT9cRl6XVHW3uiQeaFE0II0cKFnCwVFBTg9Xprrff5fBQVFYWlUiLKLHFw9d8hsTMc3g7/nAyqGp1ju2T0biGEEC1byMnS8OHDufnmm/n+++8D69avX8+tt94qwwe0ZvEd4Zq/gykGfv0EVj8anePKgJRCCCFauJCTpddee43MzEwGDx6M1WrFarUyZMgQMjIyeOWVVyJRRxEtWQPhkr/q97/8C2z+IPLHlJYlIYQQLVzI4yx17NiRjz/+mF9++YWtW7cC0Lt3b0488cSwV040g1OugYKf4L/Pw79ugQ49IKNP5I4nLUtCCCFauCYPSnniiSdKgtRWjZwDRRth15d6h+8pn0NsSmSO5ZKhA4QQQrRsISdLN954Y4PPv/baa02ujGghjCa4chG8fB4c2QX//D1c94/IjLAtV8MJIYRo4ULus3TkyJEay4EDB/jss89YtmwZJSUlEaiirri4mPHjx5OYmEhycjI33XQTDoejwe1vv/12evXqRWxsLF26dOGOO+6gtLTmZfGKotRali5dGrHX0WrEdYBr3gJTrD7h7mcRGkNLBqUUQgjRwoXcsvSvf/2r1jpVVbn11ls54YQTwlKpuowfP56CggJWrlyJx+PhhhtuYMqUKSxZsqTO7ffv38/+/fuZP38+ffr0Yc+ePdxyyy3s37+f9957r8a2r7/+OmPGjAk89o9M3u516g+XPQf/vAm+fhoy+0Pf34T3GDIopRBCiBauyX2WqjMYDEybNo3zzjuP++67LxxF1rBlyxaWL1/Od999x+DBgwF49tlnGTt2LPPnzycrK6vWPn379uWf//xn4PEJJ5zAI488wu9+9zu8Xi8m09GXnpycTGZmZtjr3Sb0uxIKfoRvn4F/3wZpJ0Jm3/CVL6fhhBBCtHBhSZYAduzYUedgleGwZs0akpOTA4kSwIgRIzAYDKxdu5bLL788qHJKS0tJTEyskSgB3Hbbbfz+97+ne/fu3HLLLdxwww0oilJvOS6XC5fLFXhst+s/+B6PB4/HE8pLa5C/rHCW2STn/hlj4UYMOz9HW3od3ps+D1tLkMllRwE8Rhs00+tsMXFu4yTO0SOxjg6Jc3REMs7BlhlysjRt2rQajzVNo6CggP/85z9MnDgx1OKCUlhYSHp6eo11JpOJ1NRUCgsLgyrj0KFDzJ07lylTptRYP2fOHC644AJsNhsrVqzgD3/4Aw6Ho8EJgefNm8fs2bNrrV+xYgU2my2o+oRi5cqVYS8zVOa4qzjX8jNxJXvYt/j3/JQz6bjLNKhuLvG5AVjx5X/xGsMfu1C0hDi3BxLn6JFYR4fEOToiEWen0xnUdoqmaVooBZ9//vk1HhsMBjp27MgFF1zAjTfeWKvVpiHTp0/n8ccfb3CbLVu2sGzZMhYvXsy2bTUneU1PT2f27NnceuutDZZht9sZOXIkqampfPDBB5jN5nq3nTVrFq+//jp79+6td5u6WpZycnI4dOgQiYnh63vj8XhYuXIlI0eObLDO0aLs+QbT3y8DwHv9h2hdhh1fgY4DmP/aBw0F75+KQAn5eoOwaGlxbqskztEjsY4OiXN0RDLOdrudtLS0wJmn+oTcsvT5558fV8Wqu+eee5g0aVKD23Tv3p3MzEwOHDhQY73X66W4uLjRvkZlZWWMGTOGhIQE/vWvfzUa6KFDhzJ37lxcLhdWq7XObfwjlx/LbDZH5AMTqXJD1uM8OHUifL8Y08fT4JavwRzT9PJ8FQAo1gTMlrpjHU0tJs5tnMQ5eiTW0SFxjo5IxDnY8kJOli644AKWLVtW64oxu93OuHHj+Oyzz4Iuq2PHjnTs2LHR7YYNG0ZJSQnr169n0KBBAHz22WeoqsrQoUPr3c9utzN69GisVisffPABMTGN/7Bv2LCBlJSUehOldm/kHPhlORz+Fb6aDxfMbHpZMiClEEKIViDk8x6rV6/G7XbXWl9ZWclXX30Vlkod66STTmLMmDFMnjyZdevW8c033zB16lSuueaawJVw+fn59O7dm3Xr1gF6ojRq1CjKy8t59dVXsdvtFBYWUlhYiM/nA+DDDz/klVde4eeff2b79u28+OKLPProo9x+++0ReR1tQmwyjJ2v3//6aSja1PSyZKoTIYQQrUDQLUs//fRT4P7mzZtrdKz2+XwsX76c7Ozs8NaumrfeeoupU6cyfPhwDAYDV1xxBc8880zgeY/Hw7Zt2wKdtb7//nvWrl0LQI8ePWqUtWvXLnJzczGbzTz//PPcfffdaJpGjx49eOqpp5g8eXLEXkeb0OdS6H0xbP0IPrgdblrZtNG9ZUBKIYQQrUDQydKAAQMCI1xfcMEFtZ6PjY3l2WefDWvlqktNTa13AEqA3NxcqvdVP++882is7/qYMWNqDEYpQjB2vj53XP56WPcynN5wJ/s6yYCUQgghWoGgk6Vdu3ahaRrdu3dn3bp1NfoaWSwW0tPTMRojMHeYaJkSO+n9lz66C1bNhV5jIaVraGXIgJRCCCFagaCTpa5d9R9CVVUjVhnRypw6ETa+C3u+gY/uht/9ExoYzLMWf8uSnIYTQgjRggWVLH3wwQdceOGFmM1mPvjggwa3vfTSS8NSMdEKGAxwyV/hxTNhxyr46R9wytXB7y8dvIUQQrQCQSVL48aNC4yiPW7cuHq3UxQlcKWZaCfSesK598Fnc2H5dOgxHOLSgttXWpaEEEK0AkENHaCqamC6EVVV610kUWqnzrwT0k+GimJYPiP4/fxXw0nLkhBCiBaseeaXEG2L0QyXPqtPV7LxH/BrkPP3BFqWpIO3EEKIliuo03DVxzNqTEMT0Io2rPMgGHor/Pd5vbP3bevA0sjEuNKyJIQQohUIKll6+umngypMURRJltqzC/4Mm5ZB6V7Y+Tn0vqjh7Sulz5IQQoiWL6hkadeuXZGuh2gLLHH6eEv/exV2ftF4suSScZaEEEK0fMfVZ0nTtEZHyRbtTPdz9dtdXzS8nabJ0AFCCCFahSYlS6+++ip9+/YlJiaGmJgY+vbtyyuvvBLuuonWKPdsQIGDW8FeUP923kpQPfp9OQ0nhBCiBQs5WZo1axZ33nknl1xyCe+++y7vvvsul1xyCXfffTezZs2KRB1Fa2JLhU6n6Pd3fVn/dv5WJRSwxEe8WkIIIURTBT3did+LL77IwoULufbaawPrLr30Uvr378/tt9/OnDlzwlpB0Qp1Pw8KNsDO1fWP6F19QEqDjGAhhBCi5Qr5V8rj8TB48OBa6wcNGoTX6w1LpUQrV73fUn192qS/khBCiFYi5GTp+uuv58UXX6y1/uWXX2b8+PFhqZRo5XJOB6MF7PlweHvd27iqxliS/kpCCCFauJBPw4HewXvFihWcfvrpAKxdu5a8vDwmTJjAtGnTAts99dRT4amlaF0sNsgZCru/0k/FpfWsvY0MSCmEEKKVCDlZ+vnnnzn11FMB2LFjBwBpaWmkpaXx888/B7ZTFCVMVRStUvdz9WRp1xcwZHLt52VASiGEEK1EyMnS559/Hol6iLam+/nw2cP6FXGqDwzGms/LgJRCCCFaiVZzGVJxcTHjx48nMTGR5ORkbrrpJhwOR4P7nHfeeSiKUmO55ZZbamyTl5fHRRddhM1mIz09nT/+8Y/SUT0cOg3QW40qS6Hgx9rPSwdvIYQQrUTILUuVlZU8++yzfP755xw4cABVVWs8//3334etctWNHz+egoICVq5cicfj4YYbbmDKlCksWbKkwf0mT55cYzgDm+3o5K4+n4+LLrqIzMxMvv32WwoKCpgwYQJms5lHH300Iq+j3TCa9AEqt/1H77eUfWrN511yGk4IIUTrEHKydNNNN7FixQquvPJKhgwZEpW+SVu2bGH58uV89913gWELnn32WcaOHcv8+fPJysqqd1+bzUZmZmadz61YsYLNmzfz6aefkpGRwYABA5g7dy73338/Dz30EBaLpc79XC4XLpcr8Nhu13/4PR4PHo+nqS+zFn9Z4Swzmgxdz8K47T+oO1fjO/32Gs8ZK0owAD5zPGozv77WHufWQuIcPRLr6JA4R0ck4xxsmYoW4uRuSUlJfPzxx5x55plNqlhTvPbaa9xzzz0cOXIksM7r9RITE8O7777L5ZdfXud+5513Hps2bULTNDIzM7nkkkt44IEHAq1Ls2bN4oMPPmDDhg2BfXbt2kX37t35/vvvGThwYJ3lPvTQQ8yePbvW+iVLltRouWrv4ivzGb5lBj7FzMf9X0Q1HE0+h+z8K51K1/NjziR2p13QjLUUQgjRXjmdTq677jpKS0tJTKz/TEfILUvZ2dkkJCQcV+VCVVhYSHp6eo11JpOJ1NRUCgsL693vuuuuo2vXrmRlZfHTTz9x//33s23bNpYtWxYoNyMjo8Y+/scNlTtjxowaQyTY7XZycnIYNWpUg8EOlcfjYeXKlYwcORKz2Ry2cqNG09D2LsDoKOLCvqlouecEnjL+/WUohZMHDaPPyWObsZJtIM6thMQ5eiTW0SFxjo5Ixtl/ZqgxISdLTz75JPfffz8vvfQSXbt2Dbli1U2fPp3HH3+8wW22bNnS5PKnTJkSuN+vXz86derE8OHD2bFjByeccEKTy7VarVit1lrrzWZzRD4wkSo3KrqfBz+9gynvG+g5/Oh6dxkAJlsqtJDX1qrj3IpInKNHYh0dEufoiEScgy0v5GRp8ODBVFZW0r17d2w2W60DFRcXB13WPffcw6RJkxrcpnv37mRmZnLgwIEa671eL8XFxfX2R6rL0KFDAdi+fTsnnHACmZmZrFu3rsY2RUVFACGVKxpQlSyxczUMrzbRsgxKKYQQopUIOVm69tpryc/P59FHHyUjI+O4Onh37NiRjh07NrrdsGHDKCkpYf369QwaNAiAzz77DFVVAwlQMPx9kzp16hQo95FHHuHAgQOB03wrV64kMTGRPn36hPhqRJ26Vc0Tt/8HqCiB2GT9sQxKKYQQopUIOVn69ttvWbNmDaecckok6lOnk046iTFjxjB58mReeuklPB4PU6dO5ZprrglcCZefn8/w4cN54403GDJkCDt27GDJkiWMHTuWDh068NNPP3H33Xdzzjnn0L9/fwBGjRpFnz59uP7663niiScoLCxk5syZ3HbbbXWeZhNNkJQNHXrC4V9h99dw0sX65LoyKKUQQohWIuRBKXv37k1FRUUk6tKgt956i969ezN8+HDGjh3LWWedxcsvvxx43uPxsG3bNpxOJwAWi4VPP/2UUaNG0bt3b+655x6uuOIKPvzww8A+RqORjz76CKPRyLBhw/jd737HhAkTaozLJMKge1Xr0q4v9FtPBahVA3/KaTghhBAtXMgtS4899hj33HMPjzzyCP369avVZymcV4NVl5qa2uAAlLm5uVQfBSEnJ4cvvvii0XK7du3Kxx9/HJY6inp0Pw++e0XvtwRHW5UUA1jim6tWQgghRFBCTpbGjBkDwPDhw2us1zQNRVHw+XzhqZloO3LP0hOjQ7+AfT+4qqapsSaATLgshBCihZOJdEXkxaboc8Xt/16fWLdDD329VforCSGEaPlCTpbOPffcep/7+eefj6syog3rfq6eLO1cDXFVV0BKfyUhhBCtQMgdvI9VVlbGyy+/zJAhQ6J6hZxoZfxDCOz84ugYSzJsgBBCiFagycnSl19+ycSJE+nUqRPz58/nggsu4L///W846ybaki6ng9EKZfshf72+TlqWhBBCtAIhnYYrLCxk0aJFvPrqq9jtdn7729/icrl4//33ZRBH0TBzLHQZqvdZ2lI1fIOMsSSEEKIVCLpl6ZJLLqFXr1789NNPLFiwgP379/Pss89Gsm6irel+nn5bske/ldNwQgghWoGgW5b+7//+jzvuuINbb72Vnj17RrJOoq3qdh5QbcBPOQ0nhBCiFQi6Zenrr7+mrKyMQYMGMXToUJ577jkOHToUybqJtiZrQM3hAqRlSQghRCsQdLJ0+umns3DhQgoKCrj55ptZunQpWVlZqKrKypUrKSsri2Q9RVtgMEK3s48+lpYlIYQQrUDIV8PFxcVx44038vXXX7Nx40buueceHnvsMdLT07n00ksjUUfRlnSrNk6XtCwJIYRoBY5rnKVevXrxxBNPsG/fPt5+++1w1Um0Zf5O3iBXwwkhhGgVjntQSgCj0ci4ceP44IMPwlGcaMvSekJSjn4/PqN56yKEEEIEIeTpToQ4LooCv30Din6GzH7NXRshhBCiUZIsiejLPlVfhBBCiFYgLKfhhBBCCCHaKkmWhBBCCCEaIMmSEEIIIUQDJFkSQgghhGiAdPAOA03TALDb7WEt1+Px4HQ6sdvtmM3msJYtjpI4R4fEOXok1tEhcY6OSMbZ/7vt/x2vjyRLYeCf6iUnJ6eZayKEEEKIUJWVlZGUVP9AyYrWWDolGqWqKvv37ychIQFFUcJWrt1uJycnh71795KYKFODRIrEOTokztEjsY4OiXN0RDLOmqZRVlZGVlYWBkP9PZOkZSkMDAYDnTt3jlj5iYmJ8kGMAolzdEico0diHR0S5+iIVJwbalHykw7eQgghhBANkGRJCCGEEKIBkiy1YFarlQcffBCr1drcVWnTJM7RIXGOHol1dEico6MlxFk6eAshhBBCNEBaloQQQgghGiDJkhBCCCFEAyRZEkIIIYRogCRLQgghhBANkGRJCCGEEKIBkiw1s+eff57c3FxiYmIYOnQo69ata3D7d999l969exMTE0O/fv34+OOPo1TT1i2UOG/atIkrrriC3NxcFEVhwYIF0atoKxdKnBcuXMjZZ59NSkoKKSkpjBgxotH3vzgqlFgvW7aMwYMHk5ycTFxcHAMGDODNN9+MYm1br1C/o/2WLl2KoiiMGzcushVsI0KJ86JFi1AUpcYSExMT2QpqotksXbpUs1gs2muvvaZt2rRJmzx5spacnKwVFRXVuf0333yjGY1G7YknntA2b96szZw5UzObzdrGjRujXPPWJdQ4r1u3Trv33nu1t99+W8vMzNSefvrp6Fa4lQo1ztddd532/PPPaz/88IO2ZcsWbdKkSVpSUpK2b9++KNe89Qk11p9//rm2bNkybfPmzdr27du1BQsWaEajUVu+fHmUa966hBpnv127dmnZ2dna2WefrV122WXRqWwrFmqcX3/9dS0xMVErKCgILIWFhRGtoyRLzWjIkCHabbfdFnjs8/m0rKwsbd68eXVu/9vf/la76KKLaqwbOnSodvPNN0e0nq1dqHGurmvXrpIsBel44qxpmub1erWEhARt8eLFkapim3G8sdY0TRs4cKA2c+bMSFSvzWhKnL1er3bGGWdor7zyijZx4kRJloIQapxff/11LSkpKUq108lpuGbidrtZv349I0aMCKwzGAyMGDGCNWvW1LnPmjVramwPMHr06Hq3F02LswhdOOLsdDrxeDykpqZGqpptwvHGWtM0Vq1axbZt2zjnnHMiWdVWralxnjNnDunp6dx0003RqGar19Q4OxwOunbtSk5ODpdddhmbNm2KaD0lWWomhw4dwufzkZGRUWN9RkYGhYWFde5TWFgY0vaiaXEWoQtHnO+//36ysrJq/UMgampqrEtLS4mPj8disXDRRRfx7LPPMnLkyEhXt9VqSpy//vprXn31VRYuXBiNKrYJTYlzr169eO211/j3v//N3//+d1RV5YwzzmDfvn0Rq6cpYiULIUSQHnvsMZYuXcrq1asj31GznUpISGDDhg04HA5WrVrFtGnT6N69O+edd15zV61NKCsr4/rrr2fhwoWkpaU1d3XatGHDhjFs2LDA4zPOOIOTTjqJv/3tb8ydOzcix5RkqZmkpaVhNBopKiqqsb6oqIjMzMw698nMzAxpe9G0OIvQHU+c58+fz2OPPcann35K//79I1nNNqGpsTYYDPTo0QOAAQMGsGXLFubNmyfJUj1CjfOOHTvYvXs3l1xySWCdqqoAmEwmtm3bxgknnBDZSrdC4fiONpvNDBw4kO3bt0eiioCchms2FouFQYMGsWrVqsA6VVVZtWpVjYy5umHDhtXYHmDlypX1bi+aFmcRuqbG+YknnmDu3LksX76cwYMHR6OqrV643tOqquJyuSJRxTYh1Dj37t2bjRs3smHDhsBy6aWXcv7557NhwwZycnKiWf1WIxzvZ5/Px8aNG+nUqVOkqilDBzSnpUuXalarVVu0aJG2efNmbcqUKVpycnLgEsjrr79emz59emD7b775RjOZTNr8+fO1LVu2aA8++KAMHRCEUOPscrm0H374Qfvhhx+0Tp06affee6/2ww8/aL/++mtzvYRWIdQ4P/bYY5rFYtHee++9GpcAl5WVNddLaDVCjfWjjz6qrVixQtuxY4e2efNmbf78+ZrJZNIWLlzYXC+hVQg1zseSq+GCE2qcZ8+erX3yySfajh07tPXr12vXXHONFhMTo23atClidZRkqZk9++yzWpcuXTSLxaINGTJE++9//xt47txzz9UmTpxYY/t//OMf2oknnqhZLBbt5JNP1v7zn/9EucatUyhx3rVrlwbUWs4999zoV7yVCSXOXbt2rTPODz74YPQr3gqFEus///nPWo8ePbSYmBgtJSVFGzZsmLZ06dJmqHXrE+p3dHWSLAUvlDjfddddgW0zMjK0sWPHat9//31E66domqZFrt1KCCGEEKJ1kz5LQgghhBANkGRJCCGEEKIBkiwJIYQQQjRAkiUhhBBCiAZIsiSEEEII0QBJloQQQgghGiDJkhBCCCFEAyRZEkIIIYRogCRLQgghhBANkGRJCCGEEKIBpuauQFugqir79+8nISEBRVGauzpCCCGECIKmaZSVlZGVlYXBUH/7kSRLYbB//35ycnKauxpCCCGEaIK9e/fSuXPnep+XZCkMEhISAD3YiYmJYSvX4/GwYsUKRo0ahdlsDlu5oiaJc3RInKNHYh0dEufoiGSc7XY7OTk5gd/x+kiyFAb+U2+JiYlhT5ZsNhuJiYnyQYwgiXN0SJyjR2IdHRLn6IhGnBvrQiMdvIUQQgghGiDJkhBCCCFEAyRZEkIIIYRogCRLIvq2fAgrZoLqa+6aCCGEEI2SDt4iulQVPrgDKorhpMsg57TmrpEQQgjRIGlZEtF1cIueKMHRWyGEEKIFk2RJRNfub47er7Q3Xz2EEEKIIEmyJKJr91dH77tKm68eQgghRJAkWRLRo2mwR1qWhBBCtC6SLInoObgVnIePPq6UliUhhBAtnyRLInp2f13zsUtaloQQQrR8kiyJ6PGfgrN10G/lNJwQQohWQJIlER2adrRl6cQx+q20LAkhhGgF2mSy9Pzzz5Obm0tMTAxDhw5l3bp19W67aNEiFEWpscTExESxtu3EoV+h/CCYYqD7+fo6aVkSQgjRCrS5ZOmdd95h2rRpPPjgg3z//feccsopjB49mgMHDtS7T2JiIgUFBYFlz549UaxxO+EfMqDzaRCXpt+XliUhhBCtQJtLlp566ikmT57MDTfcQJ8+fXjppZew2Wy89tpr9e6jKAqZmZmBJSMjI4o1bif8/ZVyz4KYRP2+tCwJIYRoBdrU3HBut5v169czY8aMwDqDwcCIESNYs2ZNvfs5HA66du2KqqqceuqpPProo5x88sn1bu9yuXC5XIHHdrv+o+/xePB4PGF4JQTKq37bamkapt1fowDezkPRjDbMgOYqxdsCXlubiXMLJ3GOHol1dEicoyOScQ62zDaVLB06dAifz1erZSgjI4OtW7fWuU+vXr147bXX6N+/P6WlpcyfP58zzjiDTZs20blz5zr3mTdvHrNnz661fsWKFdhstuN/IcdYuXJl2MuMprjKAkY4ivApZv5v4yHMvr2MARRXGR//5yNQWkYDZ2uPc2shcY4eiXV0SJyjIxJxdjqdQW3XppKlphg2bBjDhg0LPD7jjDM46aST+Nvf/sbcuXPr3GfGjBlMmzYt8Nhut5OTk8OoUaNITEwMW908Hg8rV65k5MiRmM3msJUbbcoPb8AWUHIGM+biceCthJ9vB2Ds8LMhJqlZ69dW4tzSSZyjR2IdHRLn6IhknP1nhhrTppKltLQ0jEYjRUVFNdYXFRWRmZkZVBlms5mBAweyffv2erexWq1YrdY6943EByZS5UbNXv0UqCH3bAxmM5jNYLSCz4XZ5wRzWjNXUNfq49xKSJyjR2IdHRLn6IhEnIMtr2Wc/wgTi8XCoEGDWLVqVWCdqqqsWrWqRutRQ3w+Hxs3bqRTp06Rqmb7ommwu1rnbj/p5C2EEKKVaFMtSwDTpk1j4sSJDB48mCFDhrBgwQLKy8u54YYbAJgwYQLZ2dnMmzcPgDlz5nD66afTo0cPSkpK+Mtf/sKePXv4/e9/35wvo+04sgvK9oPBrA8b4GdN1MddkuEDhBBCtHBtLlm6+uqrOXjwILNmzaKwsJABAwawfPnyQKfvvLw8DIajDWpHjhxh8uTJFBYWkpKSwqBBg/j222/p06dPc72EtsU/anf2ILBU6/wuLUtCCCFaiYgnS5WVlVEfEXvq1KlMnTq1zudWr15d4/HTTz/N008/HYVatVN1nYIDvWUJpGVJCCFEixeRPkuqqjJ37lyys7OJj49n586dADzwwAO8+uqrkTikaImqzweXe2bN5wItS6XRrZMQQggRoogkSw8//DCLFi3iiSeewGKxBNb37duXV155JRKHFC1RyR6w7wODCXKG1nzOWjVcgLQsCSGEaOEikiy98cYbvPzyy4wfPx6j0RhYf8opp9Q7OKRog/yn4LJOBUtczeekZUkIIUQrEZFkKT8/nx49etRar6qqDAvfntR3Cg6O9lmSDt5CCCFauIgkS3369OGrr76qtf69995j4MCBkTikaIn2+JOls2o/FyOn4YQQQrQOEbkabtasWUycOJH8/HxUVWXZsmVs27aNN954g48++igShxQtTUmevijG2v2VQIYOEEII0WpEpGXpsssu48MPP+TTTz8lLi6OWbNmsWXLFj788ENGjhwZiUOKlibQX2kAWBNqPy9DBwghhGglIjbO0tlnny0zMbdnDZ2CA2lZEkII0WpEpGXpu+++Y+3atbXWr127lv/973+ROKRoafydu7vWkyxJy5IQQohWIiLJ0m233cbevXtrrc/Pz+e2226LxCFFS1K6D47sBsUAXU6vext/B29pWRJCCNHCRSRZ2rx5M6eeemqt9QMHDmTz5s2ROKRoSfz9lTqdcvR027H8LUvuMlB90amXEEII0QQRSZasVitFRUW11hcUFGAytbm5e8Wx/P2VutYxvpJf9SRKTsUJIYRowSKSLI0aNYoZM2ZQWnp0dOaSkhL+9Kc/ydVw7UFg8tyz69/GZAVT1QTLcipOCCFECxaRZp758+dzzjnn0LVr18AglBs2bCAjI4M333wzEocULYW9AIp3AEr9/ZX8rIngrZSWJSGEEC1aRJKl7OxsfvrpJ9566y1+/PFHYmNjueGGG7j22msxm82ROKRoKfb4+yv1h9jkhreNSYTyA9KyJIQQokWLWAeiuLg4pkyZEqniRUu1u2qam/qGDKhOhg8QQgjRCkQsWfr111/5/PPPOXDgAKqq1nhu1qxZkTqsaE7lh2Hbcv1+XZPnHksGphRCCNEKRCRZWrhwIbfeeitpaWlkZmaiKErgOUVRJFlqi3xeeHciOAohpRt0P7/xfaRlSQghRCsQkWTp4Ycf5pFHHuH++++PRPGiJVr5gH4KzhwH1ywBi63xfQItS6UNbyeEEEI0o4gMHXDkyBGuuuqqSBQtWqINb8N/X9DvX/4SZPQJbj+rfxRvSZaEEEK0XBFJlq666ipWrFgRiaJFS5P/PXx4p37/nD9Cn0uD3zdGTsMJIYRo+SJyGq5Hjx488MAD/Pe//6Vfv361hgu44447InFYEW2OA/DO78DnghPHwHl/Cm1/mR9OCCFEKxCRZOnll18mPj6eL774gi+++KLGc4qiSLLUFnjd8I8JYM+HDj3hNy+DIcSGSungLYQQohWISLK0a9euSBQrWpJPZkDeGj3hufbto61EoZChA4QQQrQCEemz5Od2u9m2bRterzeShxHRtn4xfPcKoMBvFkJaz6aVIy1LQgghWoGIJEtOp5ObbroJm83GySefTF5eHgC33347jz32WCQOWcPzzz9Pbm4uMTExDB06lHXr1jW4/bvvvkvv3r2JiYmhX79+fPzxxxGvY6u1dx18fK9+//w/Q68xTS+rtbQsOYvh15WwbiH88BZseh9+/RT2fAsFP8LhHVBWCK4yOGYAViGEEK1fRE7DzZgxgx9//JHVq1czZszRH9MRI0bw0EMPMX369EgcFoB33nmHadOm8dJLLzF06FAWLFjA6NGj2bZtG+np6bW2//bbb7n22muZN28eF198MUuWLGHcuHF8//339O3bN2L1PF5Oj5PDlYc5XHGYI5VHcHgclLnLKPeUU+Ypw+F24HA7KPPo61w+V6Nlmgwm4s3xxJvjSbAkEGeOI94ST4I5gXhLPPEeD0krHqCDQSWt51gSzpqG0mipDWiJLUuqDw5sgX3rYN//cO9dy+GSXRwyGjliNFBmMOAw+G8VHFWP9XUKlYoBzLH6Yoo9et9gDBzCgIE4S9zRuJrjA7cJloTAbVpsGmmxaSRZkzAoEW0EbnZe1UtxxWEOle6huGwfZR4HDk85Do+TMq9+W+51UuYpx+F14vRWohkMoBhBqftdqKAQZ44jzhwXiGv1eCeYE0iwJJAak0pabBopMSmYDBGb1KBFUDWVElcJhyoOcdh5GLvrCA5XKQ53GQ63HYe7rNr3iINyjxMVDRRDVZyrbo+JeawplgRzAnGWuFrvY3/8/XHuENMBs7FtzxGqaRp2t53DFYc5VHEIe+URyiqP4HCV6HF2HY21w1NOudeJV/OB/xs1EN+aj61GK/GWROKtiSRYk4mzJtT8HjHHkxKTQofYDqTFphFrio36a2+rFE3TtHAX2rVrV9555x1OP/10EhIS+PHHH+nevTvbt2/n1FNPxW6P3I/j0KFDOe2003juuecAUFWVnJwcbr/99jqTtKuvvpry8nI++uijwLrTTz+dAQMG8NJLLwV1TLvdTlJSEqWlpSQmJobldbh9bpb93538fOAAph4nc8RbVpUcHaK48jBOrzMsxzkeFoOFDrEdSI1JIzUmlQ4xaXSI7UCHmA7V7qeRGtOBGFNM7QLKD2H7ay8AnNOLIEo/VD7VR4mrhMOVeiwPFv7Ezp8+QDE59HWKxiGjkUNGA3ajsfECI8yomEiNSSG1gfj679tMthoj5jenwA+GPY/iQ5s5dPgXtu38AWOSkWJPGYe95RxWXRzSPJQoGloz11tBIdmaEohlh5gOdKj6cU+tdr9DbBoJ5oSWE2dVpbwsn+Ij2ym276HYsY9DjgK2F+5EjTNS7HNy2FfBYc1DMT58LaDaiZbEY967R9/TqdVin2xNbhn/KGgauB24HIUcLt3FYcc+ih0FHCov4teCHRBfLc6qi0P48LSAOMcpJjoYY+lgTqCDJYkO1lQ6xKaRasugQ3wnUuM70yGxCykxqS3jHwWfBypL8ToPUly2j8OOfIrLCzlUXsTO/Tv544R/YbFYwnrIYH+/IxKdgwcP1tmKU15eHtEvGLfbzfr165kxY0ZgncFgYMSIEaxZs6bOfdasWcO0adNqrBs9ejTvv/9+vcdxuVy4XEdbavzJn8fjwePxHMcrOKq8rITHDn2Fz6jArl/q3EZTzWjeBDRfHJovBk2NQVOt4L9fdYsag6aaoJF2IEXxgrESxVCJYnChGCvJMubTw7gDo7ECh8HAYYOJfGMsmtGNW3VTUF5AQXlBo69H81nRvAmo3gQ0XwKaNw6DauGPSQnEqxoPP/Uo5b6kqrpW1V0zg9ZYnX3V6lyJYnRB4L7/tgLFVFa1OFCMDhTlmP8R/J8/m7WOyhv0envjA3U7Wk9rIMZGn4kkzU0X5SBdlAPkKAfoohygo1Jz0E0fCg6Dwj5DItuVDuxRkilQ4ig2WNAM7qrXU4FicmAwlePTvBysOMjBioNwpJE4+98T3gRUbzyaLx7NFwuqteZ7oqreet2taI3GWYWq94Q/1tXjHmMsI8FYjMVUgmJy4Da6cJjq+GE2A9XzfKVqQcGgaXTw+Uj2acSrGvGqSpyq369+q9/3Eas0/FnTgPJjWgHLDAYcioFig4UjBjOlBiN2I5QbfWiKxhFXMUdcxWzn10bibKx6H1fF2Zugvyd8+mdQj3FMIMb6e8aKpjX8w68oGhhcWAwOEg3FxJuOEGcsJdZQhsXgwGR0ohgr8BpdOE0eyowqJUaorOtKVDPgPibWVVJ8Pjr4fCSqKgmqRpyqkqCqxKsqNh/EqmBTFWI0sGgqZrwYlbpPMWuA02CgXKkW46qWVofBQLnBgN1goNho4LDRiFdRsLvt2N12dtl3NhwPTcHss2DyxqJ44/T3thqrx9kXg6rGoqkxeH2xqKoNrxqL1xeHSdMw48OMV18ULxb0xYwHC15ijA5iDA4sRgdmYzkmgx5bxeBCM7jxGd1UGD04jCqlRjhs0l9LnXGu3nBfLc4JPlV/T1fFNkFViVX1+MaoBmJUAxafAYtqwIgBAyoKGga0GveVqkU1+PAYvDgNCuUGJRDr6vE+YtD/0XMZDJRrXsq9ZeR5y6BifwNx1khUIckL8T4jNq8Jq2rGqJow+cwYVTMG1QKqBcVX7XtEM6K3Nx5bbwAVAxpGgwej0al/pxlcaEYXqsGNz+DBZ/DiNvioMHopM6kcMSocMhopreufVDPcWHqEtOTUBt8zoQr2NzsiydLgwYP5z3/+w+233w4QSJBeeeUVhg0bFolDAnDo0CF8Ph8ZGRk11mdkZLB169Y69yksLKxz+8LCwnqPM2/ePGbPnl1r/YoVK7DZgpjmIwiqq5xuZR3oxgFy1XI6+HykeX1YfFY2uvux2n0WP/j6oBGZlo/TlK3ca/4HQw163BxaDK/4xvKqdyxl2EDx6MmH0YHBn4QEEpIyDMZqjw1eFKMLxejCYD1U4zhPk1J171+EJ3JB0iDRB5k+N2k+H15vIoe92Rz0ZHPA2xnVm4jmjUf1JoAaS2OJJoAHqASKgO+qrU+knJOUPE4y7KGPsod+hp2crezDqDiBo+8zt2Zks5bLD2oPflT7sk3LYaeWjtvkDiR6BmNZzcTPVKbH31iGYnSjGDwolmKwFEfonVE3DaivvTjJ5yPFp2HzmjH7YjB6YzF441C98Xi8yVT4UnF60ijxppFPEjsJ7j9HIz7iqSBRKScRJ4mKk0TKA7fJSjkdKSFdKaGPot92oATjsYky4AOOGAwcNhmrWhWNHDYaKDKYyTfFcMhootioUGoEp1FDMfhQDCVgLolYnCurlkMNbnX0x9umqiR7FeJ8RmJ8ZizemKNJhi8BrycRlzeFCm8qZcSzT7PhwowPI96qxYeB+t7rBlQseLBWLRZFv43BTYJSEYh9UtVtRuBv4SRRKScZB0lKGQZDOWUmLRBnPdZGDpr0mPsfFxuNaIqG2+TCbXIBJY1GwgI13j3eqqWisWA3WGrNBMmiaiT7IN5rJNZnxuq1YvbFVL2n4/B5k3B7k6nwpuDQkjik2cjDigszbsyox91VWMOKh1hcxFFJrKLf2qpuM6ggQXEQayjDWPXdoJqdeIyVVJpcgcSkxAiHjQaKjUZ8iv7eLjUCqOhZtrvhaoSNgp5x1mTSNJK8Cgk+AzafCavXyuerVxBnCc/ZGz+nM7izNBFJlh599FEuvPBCNm/ejNfr5a9//SubN2/m22+/rTXuUms0Y8aMGq1RdrudnJwcRo0aFbbTcJqmcbbzEj5btYpRfVKI/fUDzFv/jcF1kPP5ijvMX6GmZuPpfRmeEy/Cl34y1HWqK0SGop+I+eoxzLs+0+thtOIeeAPq0KncYEvjhia8jnJvOcWVhzlceThwW+I6QrnHgfvnpThUF6VZp+JQNMo95ZR7HDg8DrxacFdRxpniqvqm6Ofs48zxVeviiTfHkWBJJDWmA6nWDnSwJNFp8/tkrHsJs+pBjUmm/Lw5/F9+EhcMH47ZHJ2maIfbgbFwA6b932MsWI9x/3oszkMMUHYwwLAjsJ2mGFCTc1E7nIivw4moab3029Qeel+oapxeJ0cqi2vF2eFxUO5xUO4tD9zXb8sp95TjVhvvzwYQG2h90Ft9/EuCprdMxJvi9dMocZ1ISehKSkoPktL6YErtCdZEPB4vn332GRdccEHU4nwsh+pDcR5CKT+AobwIxXEAQ/kBFOdBEssPkFx+kB7lBzCUH0Rxl9VZhkuBYkPVD71J/y/+kNFY7T/8Y1tZ9PsVQY5DZvXHWNOIx0C8wUycwUq8yaa/ty2JpMSmkWrLJDUhh5SkbqQkn0Cs9ejwHS0h1vXSNKweJx0rilEqS1AqjmCoLEapKNFj7ipDcZfhrSyl1F3KYY+dQx4HxWoFh30uyhQVBxoOA5QBjmNaWeps/amDSUOPr2IiXjETb7QSZ4whzmSr+h5JILnq/Zwa35mUxC50iM/GZooLNAC06Dg3RtPAW4FaWYLdsZ8j5fspLi/kcMUBiiuLsXvKcPgqKPe5KPdV4lDdOFQ35ZoXh+alHB/BXM5iBOIVM3GKmTijlXijlXhjLHEmW9X3dgJJ1hQ6xHUiNT6blIQcOtjSSTAn1orzRaNHROQ0XDAi8tc966yz+PHHH5k3bx79+vVjxYoVnHrqqaxZs4Z+/fpF4pAApKWlYTQaKSoqqrG+qKiIzMzMOvfJzMwMaXsAq9WK1Vr7dI3ZbK41WvnxSFIUrCaFuB5nYD7pXLjocX2y2o3vwZYPMJTlY/3uBazfvaD39+l4EmSdAp0GQNZAyDi51g9qDaoPnIf1K7nKCmHDW7D5ff05gwkGXo9yzh+xJmVTx8mpoCVjI5uOdT/5wwdwOB/G3gm5ZwVWa5qGT/M1WrZBMQTfp6FwI7z/Byj8SX/c6yIMFz9NTEwq1qKPSYqLCevfr0FxsZAyEk4aqT/WNCjZA/v+py/7f4CDW1EqSzAe2YnxyE7M25dXK0CBpBywpUBMMsQmkxSTRKeYZH3Mq9hkfX1SR/BUgLscPM5qt07wlIPbibeiBOx7oWQvuB11VldB/9LDFKMPQprWE9JOPHrb4QSwxDX4kj0eD1Yj0Y1zXRLigdzGt3M7ofwAOA7qFyG47OAqw+oqo1PV4l+Hy4HevlY/nwaaJQ6s8WBN0BdLtfvWBBRrAsa4dIhL0/9+oQ70WqXFxLpeNkhJa3ALKxAHZDVWlKqC5tP7u6heVJ8bVVHAaAWjpd4YhqOPTsuPc2NsQAdSOIGuIe4Z7He0UTEed/cbf5wtFkvY4xxseWFPljweDzfffDMPPPAACxcuDHfxDbJYLAwaNIhVq1Yxbtw4QO/gvWrVKqZOnVrnPsOGDWPVqlXcddddgXUrV66M6OnCJjOa4ITz9eWiJ+HXFbDxXdj9NVQUQ9FGffnh7/r2ihE69oasARCfrn/pO4rAUahPVVJ+ELRj/zdQoN9VcN50/Qcw0uoZPkBRFExKmN6eXjd8/RR8+RdQvRCbAmPnQ98r9KtMwtTP7LgoCqTk6ku/K/V1mqb/nQ5urbZs06/WqyiG0jx9OU61ohyfAcld9GQsuUvV0lVPjJJymvwD3upYbGDJ1f8mYdD8lwq0UYaqU2VVV9jVPnEmIiGs39GtQNhfqdls5p///CcPPPBAuIsOyrRp05g4cSKDBw9myJAhLFiwgPLycm64QT+BNGHCBLKzs5k3bx4Ad955J+eeey5PPvkkF110EUuXLuV///sfL7/8crPUP2jmGH3S2j6X6j+qpfugYIM+7s/+Dfr98oNwYJO+1EuBuI76D2R6bzjrbr1FKloiPXzAgS3wz8l6EgnQ+2K46ClIyGh4v5ZAUfR6JmRA93OPrtc0KD8ER3ZBRQlUlkBlabX7JVX3S/WWJLNN/+E32/TWn8DjOP3WmgBJnfWEKKlzw62RQgjRDkUkLRw3bhzvv/8+d999dySKb9DVV1/NwYMHmTVrFoWFhQwYMIDly5cHOnHn5eVhqPaf8RlnnMGSJUuYOXMmf/rTn+jZsyfvv/9+ix5jqRZFgeQcfTnpEn2dpkFZwdHEqbJUb12Kz6haqu7b0vQWq+YSyYEpXQ74+5Vg3wexqTD2L0dbk1ozRYH4jvoihBAi4iLyK9mzZ0/mzJnDN998w6BBg4iLq9mXIdIT6U6dOrXe026rV6+ute6qq67iqquuimidok5RIDFLX3qPbe7a1C/QslTa8HZN8cVjeqKU3AV+v0pPEIUQQogQRSRZevXVV0lOTmb9+vWsX7++xnOKokQ8WRKtiH8C3sowJ0uFP8OaF/T7Y5+UREkIIUSTRSRZ2rVrVySKFW2RNQKn4VQV/jNNv0LmpEvgxFHhK1sIIUS7E9GLBtxuN9u2bcPrDW68HNEOxUSgg/eGv8Petfpl2WMeD1+5Qggh2qWIJEtOp5ObbroJm83GySefTF6efnnz7bffzmOPPRaJQ4rWKnAaLkzJUvlhWDlLv3/eDEjKDk+5Qggh2q2IJEszZszgxx9/ZPXq1cTEHB1VesSIEbzzzjuROKRorcI9dMDKWVBxBDL6wtBbwlOmEEKIdi0ifZbef/993nnnHU4//fQaI3eefPLJ7Nixo4E9RbsTzqED9nyrn4IDuPjp5h0SQQghRJsRkZalgwcPkp5e++qj8vLy4x72XLQx4WpZ8nngo6r5+k6dCDlDjq88IYQQokpEkqXBgwfzn//8J/DYnyC98sorLXMaEdF8wtWytOZ5OLgFbB1gxEPHXS0hhBDCLyLnKR599FEuvPBCNm/ejNfr5a9//SubN2/m22+/5YsvvojEIUVr5Z8p3VOutw4ZmzBJYkkefFF11duoh8GWGr76CSGEaPci0rJ01llnsWHDBrxeL/369WPFihWkp6ezZs0aBg0aFIlDitbK37IE+uztTfF/94PHCV3PhFOuDU+9hBBCiCpha1maNm0ac+fOJS4uji+//JIzzjiDhQsXhqt40VYZzWCKBW+FPop3qK1CW/8D2z4Gg0mfIFf6xAkhhAizsLUsPfvsszgcDgDOP/98iouLw1W0aOv8Yy2F2snbXa63KgGccTuk9w5vvYQQQgjC2LKUm5vLM888w6hRo9A0jTVr1pCSklLntuecc064DivagphEcBSG3sn7y/lQulefKPec+yJTNyGEEO1e2JKlv/zlL9xyyy3MmzcPRVG4/PLL69xOURR8Pl+4DivagqYOH7D5ff12xGyw2MJaJSGEEMIvbMnSuHHjGDduHA6Hg8TERLZt21bnWEtC1NKU4QM0Dez79ftZA8NfJyGEEKJK2PosTZs2jfLycuLj4/n888/p1q0bSUlJdS5C1NCUlqWKI+Ct1O8ndAp/nYQQQogqEengfcEFF0gHbxG8prQs+VuVbB3AHNPwtkIIIcRxkA7eovn5W5YqS4Lfp6xAv03ICnt1hBBCiOqkg7dofk0ZOsCer98mSrIkhBAisqSDt2h+1uM4DSfJkhBCiAgL+9xw1Tt4m0wRmXpOtDVNalmSZEkIIUR0hC2bsdvtJCbqLQQDBw7E6XTWu61/OyGA4+vgLcmSEEKICAtbspSSkkJBQQHp6ekkJyej1DFHl6Zp0mdJ1NaUoQMCHbxl2AAhhBCRFbZk6bPPPiM1VZ8E9fPPPw9XsaI9aFLLkr+Dd3b46yOEEEJUE7Zk6dxzz63zvhCNCrVlyV0OlaX6/URpWRJCCBFZYRuUsrpff/2V+fPnM3XqVG6//Xaefvppdu7cGYlD1VBcXMz48eNJTEwkOTmZm266KTBQZn3OO+88FEWpsdxyyy0Rr6uoxt/B2+MEn6fx7e1Vp+As8UcTLSGEECJCwn652rx585g1axaqqpKeno6maRw8eJD777+fRx99lHvvvTfchwwYP348BQUFrFy5Eo/Hww033MCUKVNYsmRJg/tNnjyZOXPmBB7bbDIpa1RZE47er7RDXIeGty+r6tyd0Anq6BsnhBBChFNYk6XPP/+cmTNn8sADD3DnnXcGRvAuLi5mwYIFTJ8+nSFDhkRkBO8tW7awfPlyvvvuOwYPHgzoU7CMHTuW+fPnk5VV/1VTNpuNzMzMoI/lcrlwuVyBx3a7fvrI4/Hg8QTRMhIkf1nhLLOlMpltKB4nnvLDYGm4tUg5shcToCZ0wheG2LSnODcniXP0SKyjQ+IcHZGMc7BlKpqmaeE66NVXX01ycjJ/+9vf6nx+ypQplJWV8fbbb4frkAGvvfYa99xzD0eOHAms83q9xMTE8O6779Y7ovh5553Hpk2b0DSNzMxMLrnkEh544IEGW5ceeughZs+eXWv9kiVLpFWqiUZvvIMYbwmre82h1Jbb4LY9Cz+kT8G75KWexQ9dp0SngkIIIdocp9PJddddR2lpaYPDGoW1ZWndunW8+eab9T5//fXXM2HChHAeMqCwsLDWiOEmk4nU1FQKCwvr3e+6666ja9euZGVl8dNPP3H//fezbds2li1bVu8+M2bMYNq0aYHHdrudnJwcRo0aFdYxpDweDytXrmTkyJGYzeawldsSmfY+DIdKOGtwP7Tcsxvc1rD8CyiA7N6n0en8scd97PYU5+YkcY4eiXV0SJyjI5Jx9p8ZakxYk6WioiJyc3Prfb5bt24NJi51mT59Oo8//niD22zZsiWkMqubMuVoy0S/fv3o1KkTw4cPZ8eOHZxwwgl17mO1WrFarbXWm83miHxgIlVui1LVydvkdUJjr9Whv4eMKZ0xhjEu7SLOLYDEOXok1tEhcY6OSMQ52PLCmixVVlZisVjqfd5sNuN2u0Mq85577mHSpEkNbtO9e3cyMzM5cOBAjfVer5fi4uKQ+iMNHToUgO3bt9ebLIkICGX4gEAHbxm9WwghROSF/Wq4V155hfj4+DqfKysrC7m8jh070rFjx0a3GzZsGCUlJaxfv55BgwYB+kCZqqoGEqBgbNiwAYBOnWT8nqgKZWBKmepECCFEFIU1WerSpQsLFy5sdJtIOOmkkxgzZgyTJ0/mpZdewuPxMHXqVK655prAlXD5+fkMHz6cN954gyFDhrBjxw6WLFnC2LFj6dChAz/99BN3330355xzDv37949IPUU9gm1Z8nnAUdWCKMmSEEKIKAhrsrR79+5wFheyt956i6lTpzJ8+HAMBgNXXHEFzzzzTOB5j8fDtm3bApP8WiwWPv30UxYsWEB5eTk5OTlcccUVzJw5s7leQvsVaFkqbXi7skJAA4MZbGkRr5YQQggR9tNwzSk1NbXBAShzc3OpPlJCTk4OX3zxRTSqJhpjrRrFu9FkqdoEuoaIDEAvhBBC1CC/NqJliAnyNFxgAl05BSeEECI6JFkSLYN/frjGOnj754WTCXSFEEJEiSRLomUItoN3oGUpO7L1EUIIIapIsiRahmCHDvD3WZLTcEIIIaIkYsnSjh07mDlzJtdee21gsMj/+7//Y9OmTZE6pGjNgm5Z8g9IKafhhBBCREdEkqUvvviCfv36sXbtWpYtW4bD4QDgxx9/5MEHH4zEIUVrF2zLUmBASjkNJ4QQIjoikixNnz6dhx9+mJUrV9aY/uSCCy7gv//9byQOKVo7f8uStwK89UyJo6rVTsNJy5IQQojoiEiytHHjRi6//PJa69PT0zl06FAkDilaO3+yBPWfinMeBp8bUCA++Pn+hBBCiOMRkWQpOTmZgoKCWut/+OEHsrPl9Imog9EE5jj9fn0DU/on0I3rCKb6J2wWQgghwikiydI111zD/fffT2FhIYqioKoq33zzDffeey8TJkyIxCFFW9DYwJQyga4QQohmEJFk6dFHH6V3797k5OTgcDjo06cP55xzDmeccYbMuybq19jAlJIsCSGEaAYRmRvOYrGwcOFCZs2axcaNG3E4HAwcOJCePXtG4nCirWhs+ABJloQQQjSDiE6km5OTQ05ODj6fj40bN3LkyBFSUlIieUjRmjU2fIAMSCmEEKIZROQ03F133cWrr74KgM/n49xzz+XUU08lJyeH1atXR+KQoi1otGWpaqqTBEmWhBBCRE9EkqX33nuPU045BYAPP/yQnTt3snXrVu6++27+/Oc/R+KQoi1orGXJLi1LQgghoi8iydKhQ4fIzNTHwfn444/57W9/y4knnsiNN97Ixo0bI3FI0Rb4W5bqGzpA+iwJIYRoBhFJljIyMti8eTM+n4/ly5czcuRIAJxOJ0ajMRKHFG1BYOiAOpKlSju4y/T7Mi+cEEKIKIpIB+8bbriB3/72t3Tq1AlFURgxYgQAa9eupXfv3pE4pGgLrA0MHeDv3G1NAmt89OokhBCi3YtIsvTQQw/Rt29f9u7dy1VXXYXVagXAaDQyffr0SBxStAUNDUrp79wtp+CEEEJEWcSGDrjyyitrrZs4cWKkDifagoYGpbTLBLpCCCGaR8SSpfLycr744gvy8vJwu2vOIn/HHXdE6rCiNWto6ADp3C2EEKKZRCRZ+uGHHxg7dixOp5Py8nJSU1M5dOgQNpuN9PR0SZZE3RoaOsA/iW6iTMQshBAiuiJyNdzdd9/NJZdcwpEjR4iNjeW///0ve/bsYdCgQcyfPz8ShxRtQTAtS3IlnBBCiCiLSLK0YcMG7rnnHgwGA0ajEZfLRU5ODk888QR/+tOfInFI0Rb4W5a8leB11XzOLi1LQgghmkdEkiWz2YzBoBednp5OXl4eAElJSezduzcShwTgkUce4YwzzsBms5GcnBzUPpqmMWvWLDp16kRsbCwjRozg119/jVgdRQP8LUtQ+1RcIFmSliUhhBDRFZFkaeDAgXz33XcAnHvuucyaNYu33nqLu+66i759+0bikAC43W6uuuoqbr311qD3eeKJJ3jmmWd46aWXWLt2LXFxcYwePZrKysqI1VPUw2AES9UYStVPxXld4Dyk35eWJSGEEFEWkWTp0UcfpVMnvQXgkUceISUlhVtvvZWDBw/y8ssvR+KQAMyePZu7776bfv36BbW9pmksWLCAmTNnctlll9G/f3/eeOMN9u/fz/vvvx+xeooG1DXliX9ASqMVYlOiXychhBDtWkSuhhs8eHDgfnp6OsuXL4/EYY7brl27KCwsDIwwDvqpwqFDh7JmzRquueaaOvdzuVy4XEf71NjteiuIx+PB4/GErX7+ssJZZktnsiaglIG3/Aha1etWjuzFBGiJWXi93rAfsz3GuTlInKNHYh0dEufoiGScgy0zYuMstQaFhYWAPpdddRkZGYHn6jJv3jxmz55da/2KFSuw2WzhrSSwcuXKsJfZUp1VodIB+H7N5xRscQCQfeS/DAYOeyx88/HHETt2e4pzc5I4R4/EOjokztERiTg7nc6gtotIslRUVMS9997LqlWrOHDgAJqm1Xje5/MFXdb06dN5/PHHG9xmy5YtUZ1zbsaMGUybNi3w2G63k5OTw6hRo0hMTGxgz9B4PB5WrlzJyJEjMZvNYSu3JTPa34Adv3LqyT3RThkLgOG/u2A3pHbty9ixY8N+zPYY5+YgcY4eiXV0SJyjI5Jx9p8ZakxEkqVJkyaRl5fHAw88EJhMt6nuueceJk2a1OA23bt3b1LZmZmZgJ7c+ftY+R8PGDCg3v2sVmtgvrvqzGZzRD4wkSq3RYrVpzwxecrB/5rLiwAwJGVjiGAc2lWcm5HEOXok1tEhcY6OSMQ52PIikix9/fXXfPXVVw0mHMHq2LEjHTt2PP5K1aFbt25kZmayatWqQF3tdjtr164N6Yo6EUZ1DUwZmERXroQTQggRfRG5Gi4nJ6fWqbdoyMvLY8OGDeTl5eHz+diwYQMbNmzA4XAEtunduzf/+te/AFAUhbvuuouHH36YDz74gI0bNzJhwgSysrIYN25c1OsvqDblSbWr4QKT6Mq8cEIIIaIvIi1LCxYsYPr06fztb38jNzc3Eoeo06xZs1i8eHHg8cCBAwH4/PPPOe+88wDYtm0bpaVHf4jvu+8+ysvLmTJlCiUlJZx11lksX76cmJiYqNVbVGOtY344mURXCCFEMwpbspSSklKjb1J5eTknnHACNput1jnB4uLicB22hkWLFrFo0aIGtzm2xUtRFObMmcOcOXMiUicRohi9zxKuqoRW9YGj6spESZaEEEI0g7AlSwsWLAhXUaI9O7ZlqfwgqF5QDBCX3nz1EkII0W6FLVmaOHFiuIoS7VmgZakqWfKfgovPBGO7HhZMCCFEMwlrB29VVXn88cc588wzOe2005g+fToVFRXhPIRo62KOaVmSCXSFEEI0s7AmS4888gh/+tOfiI+PJzs7m7/+9a/cdttt4TyEaOuOHTqgTK6EE0II0bzCmiy98cYbvPDCC3zyySe8//77fPjhh7z11luoqhrOw4i2rFbLUtUYSwmSLAkhhGgeYU2W8vLyakxHMWLECBRFYf/+/eE8jGjL/C1LPhd4KmWMJSGEEM0urMmS1+utNT6R2WyWGZlF8KwJR++77DJ6txBCiGYX1suLNE1j0qRJNeZNq6ys5JZbbiEuLi6wbtmyZeE8rGhLDEawJIC7TD8VJx28hRBCNLOwJkt1DR/wu9/9LpyHEO1BTKKeLLlKpYO3EEKIZhfWZOn1118PZ3GivbImAvlQshc8Tn1dgrQsCSGEaB4RmUhXiOPiH5jy4Fb9NjYVzLHNVx8hhBDtmiRLouXxDx/gT5bkFJwQQohmJMmSaHn8wwcckGRJCCFE85NkSbQ8/palw9v1W+mvJIQQohlJsiRaHn/Lklo1PpeMsSSEEKIZSbIkWh5/y5KfjLEkhBCiGUmyJFoe67HJkvRZEkII0XwkWRItj3/oAD85DSeEEKIZSbIkWp5jW5akg7cQQohmJMmSaHmqtyyZ42q3NAkhhBBRJMmSaHmqd/BO7ASK0nx1EUII0e5JsiRanuqn4aRztxBCiGYmyZJoeaq3LCVIsiSEEKJ5SbIkWh5LAlB16k1aloQQQjQzSZZEy2MwgDVBvy/JkhBCiGbWppKlRx55hDPOOAObzUZycnJQ+0yaNAlFUWosY8aMiWxFReP8/ZYkWRJCCNHM2lSy5Ha7ueqqq7j11ltD2m/MmDEUFBQElrfffjtCNRRB63K6PmxA1qnNXRMhhBDtnKm5KxBOs2fPBmDRokUh7We1WsnMzAx6e5fLhcvlCjy22+0AeDwePB5PSMduiL+scJbZalz6IngrwGyDCL/+dh3nKJI4R4/EOjokztERyTgHW2abSpaaavXq1aSnp5OSksIFF1zAww8/TIcOHerdft68eYHErLoVK1Zgs9nCXr+VK1eGvUxRm8Q5OiTO0SOxjg6Jc3REIs5OpzOo7RRN07SwH72ZLVq0iLvuuouSkpJGt126dCk2m41u3bqxY8cO/vSnPxEfH8+aNWswGo117lNXy1JOTg6HDh0iMTGxzn2awuPxsHLlSkaOHInZbA5buaImiXN0SJyjR2IdHRLn6IhknO12O2lpaZSWljb4+93iW5amT5/O448/3uA2W7ZsoXfv3k0q/5prrgnc79evH/379+eEE05g9erVDB8+vM59rFYrVqu11nqz2RyRD0ykyhU1SZyjQ+IcPRLr6JA4R0ck4hxseS0+WbrnnnuYNGlSg9t07949bMfr3r07aWlpbN++vd5kSQghhBDtR4tPljp27EjHjh2jdrx9+/Zx+PBhOnWSme6FEEII0QqSpVDk5eVRXFxMXl4ePp+PDRs2ANCjRw/i4+MB6N27N/PmzePyyy/H4XAwe/ZsrrjiCjIzM9mxYwf33XcfPXr0YPTo0UEf19/ty39VXLh4PB6cTid2u12aeCNI4hwdEufokVhHh8Q5OiIZZ//vdqPdt7U2ZOLEiRpQa/n8888D2wDa66+/rmmapjmdTm3UqFFax44dNbPZrHXt2lWbPHmyVlhYGNJx9+7dW+dxZZFFFllkkUWWlr/s3bu3wd/5Nnk1XLSpqsr+/ftJSEhAUZSwleu/ym7v3r1hvcpO1CRxjg6Jc/RIrKND4hwdkYyzpmmUlZWRlZWFwVD/ON1t6jRcczEYDHTu3Dli5ScmJsoHMQokztEhcY4eiXV0SJyjI1JxTkpKanSbNjXdiRBCCCFEuEmyJIQQQgjRAEmWWjCr1cqDDz5Y5wCYInwkztEhcY4eiXV0SJyjoyXEWTp4CyGEEEI0QFqWhBBCCCEaIMmSEEIIIUQDJFkSQgghhGiAJEtCCCGEEA2QZKmZPf/88+Tm5hITE8PQoUNZt25dg9u/++679O7dm5iYGPr168fHH38cpZq2bqHEedOmTVxxxRXk5uaiKAoLFiyIXkVbuVDivHDhQs4++2xSUlJISUlhxIgRjb7/xVGhxHrZsmUMHjyY5ORk4uLiGDBgAG+++WYUa9t6hfod7bd06VIURWHcuHGRrWAbEUqcFy1ahKIoNZaYmJjIVjCkSdBEWC1dulSzWCzaa6+9pm3atEmbPHmylpycrBUVFdW5/TfffKMZjUbtiSee0DZv3qzNnDlTM5vN2saNG6Nc89Yl1DivW7dOu/fee7W3335by8zM1J5++unoVriVCjXO1113nfb8889rP/zwg7ZlyxZt0qRJWlJSkrZv374o17z1CTXWn3/+ubZs2TJt8+bN2vbt27UFCxZoRqNRW758eZRr3rqEGme/Xbt2adnZ2drZZ5+tXXbZZdGpbCsWapxff/11LTExUSsoKAgsoc7pGipJlprRkCFDtNtuuy3w2OfzaVlZWdq8efPq3P63v/2tdtFFF9VYN3ToUO3mm2+OaD1bu1DjXF3Xrl0lWQrS8cRZ0zTN6/VqCQkJ2uLFiyNVxTbjeGOtaZo2cOBAbebMmZGoXpvRlDh7vV7tjDPO0F555RVt4sSJkiwFIdQ4v/7661pSUlKUaqeT03DNxO12s379ekaMGBFYZzD8f3v3HxJF/sYB/L3tuma7XuZtrSuoUVsWUeR5dGxUWln2A/M4sp+YlnUcV9xJFF30R90JZbVRVGAhqVGRSXFFHGhlWiYVdWlYidVSYMcldXeF1rXruc/98YWhOW2/7ua6br1fMH/MZ56ZeeZhGR5nPrv2Q0pKCq5evdrlPlevXlXFA0Bqauo748m3OpP3eqLOr1+/Rnt7OyIjI/2V5gfhfWstIqisrERTUxOmTJniz1SDmq91/umnnzBkyBDk5OT0RppBz9c6t7W1IS4uDjExMUhPT8fdu3f9miebpQB5/vw5Ojo6YDabVeNmsxlPnz7tcp+nT596FU++1Zm81xN13rBhA6Kjozv9QUBqvtb65cuXMBqN0Ov1mDt3Lvbt24cZM2b4O92g5Uudr1y5gkOHDqGwsLA3Uvwg+FLn+Ph4FBUV4cyZMzh69CjcbjcmTpyIJ0+e+C1Pnd+OTETUTfn5+SgtLUV1dbX/J2p+pMLDw1FfX4+2tjZUVlZi7dq1GDZsGJKTkwOd2gehtbUVmZmZKCwshMlkCnQ6HzSbzQabzaasT5w4EaNHj8bBgweRl5fnl3OyWQoQk8kErVaLlpYW1XhLSwuioqK63CcqKsqrePKtzuS996mz3W5Hfn4+Lly4gHHjxvkzzQ+Cr7Xu168frFYrAGD8+PFobGzEtm3b2Cy9g7d1djgcePz4MdLS0pQxt9sNANDpdGhqasLw4cP9m3QQ6ol7dEhICBISEvDw4UN/pAiAr+ECRq/XIzExEZWVlcqY2+1GZWWlqmN+m81mU8UDwPnz598ZT77Vmbzna5137NiBvLw8lJeX4/PPP++NVINeT32m3W43nE6nP1L8IHhb51GjRqGhoQH19fXKMm/ePEydOhX19fWIiYnpzfSDRk98njs6OtDQ0ACLxeKvNPnTAYFUWloqoaGhUlJSIvfu3ZOvv/5aIiIilK9AZmZmyg8//KDE19bWik6nE7vdLo2NjbJ582b+dEA3eFtnp9MpdXV1UldXJxaLRdatWyd1dXXy4MGDQF1CUPC2zvn5+aLX6+XkyZOqrwC3trYG6hKChre13rp1q5w7d04cDofcu3dP7Ha76HQ6KSwsDNQlBAVv6/xf/DZc93hb5x9//FEqKirE4XDIr7/+KosWLZL+/fvL3bt3/ZYjm6UA27dvn8TGxoper5cJEybItWvXlG1JSUmSlZWlii8rK5ORI0eKXq+XMWPGyC+//NLLGQcnb+r86NEjAdBpSUpK6v3Eg4w3dY6Li+uyzps3b+79xIOQN7XetGmTWK1W6d+/vwwaNEhsNpuUlpYGIOvg4+09+m1slrrPmzrn5uYqsWazWebMmSO3bt3ya34aERH/PbciIiIiCm6cs0RERETkAZslIiIiIg/YLBERERF5wGaJiIiIyAM2S0REREQesFkiIiIi8oDNEhEREZEHbJaIiIiIPGCzREREROQBmyUi6pOys7Oh0Wg6Lf78z+JERF3RBToBIqJ3mTVrFoqLi1VjgwcPVq27XC7o9freTIuIPjJ8skREfVZoaCiioqJUy/Tp07FmzRrk5ubCZDIhNTUVAHDnzh3Mnj0bRqMRZrMZmZmZeP78uXKsV69eYdmyZTAajbBYLNi1axeSk5ORm5urxGg0Gpw+fVqVQ0REBEpKSpT15uZmLFiwABEREYiMjER6ejoeP36sbM/OzsaXX34Ju90Oi8WCTz/9FKtXr0Z7e7sS43Q6sWHDBsTExCA0NBRWqxWHDh2CiMBqtcJut6tyqK+v51M1ogBis0REQefw4cPQ6/Wora3FgQMH8OLFC0ybNg0JCQm4efMmysvL0dLSggULFij7rF+/HpcuXcKZM2dw7tw5VFdX49atW16dt729HampqQgPD0dNTQ1qa2thNBoxa9YsuFwuJa6qqgoOhwNVVVU4fPgwSkpKVA3XsmXLcPz4cezduxeNjY04ePAgjEYjNBoNVqxY0elpWnFxMaZMmQKr1epbwYjo/QgRUR+UlZUlWq1WDAaDssyfP1+SkpIkISFBFZuXlyczZ85UjTU3NwsAaWpqktbWVtHr9VJWVqZs/+OPPyQsLEy+//57ZQyA/Pzzz6rjDBw4UIqLi0VE5MiRIxIfHy9ut1vZ7nQ6JSwsTCoqKpS84+Li5J9//lFiMjIyZOHChSIi0tTUJADk/PnzXV73b7/9JlqtVq5fvy4iIi6XS0wmk5SUlHSjakTkD5yzRER91tSpU1FQUKCsGwwGLF68GImJiaq427dvo6qqCkajsdMxHA4H/v77b7hcLnzxxRfKeGRkJOLj473K5/bt23j48CHCw8NV42/evIHD4VDWx4wZA61Wq6xbLBY0NDQA+N8rNa1Wi6SkpC7PER0djblz56KoqAgTJkzA2bNn4XQ6kZGR4VWuRNRz2CwRUZ9lMBi6fPVkMBhU621tbUhLS8P27ds7xVoslm7P9dFoNBAR1djbc43a2tqQmJiIY8eOddr37YnnISEhnY7rdrsBAGFhYf83j5UrVyIzMxO7d+9GcXExFi5ciAEDBnTrGoio57FZIqKg99lnn+HUqVMYOnQodLrOt7Xhw4cjJCQE169fR2xsLADgr7/+wv3791VPeAYPHozff/9dWX/w4AFev36tOs+JEycwZMgQfPLJJz7lOnbsWLjdbly6dAkpKSldxsyZMwcGgwEFBQUoLy/H5cuXfToXEfUMTvAmoqC3evVq/Pnnn1i8eDFu3LgBh8OBiooKLF++HB0dHTAajcjJycH69etx8eJF3LlzB9nZ2ejXT30LnDZtGvbv34+6ujrcvHkT33zzjeop0dKlS2EymZCeno6amho8evQI1dXV+O677/DkyZNu5Tp06FBkZWVhxYoVOH36tHKMsrIyJUar1SI7OxsbN27EiBEjYLPZeqZQROQTNktEFPSio6NRW1uLjo4OzJw5E2PHjkVubi4iIiKUhmjnzp2YPHky0tLSkJKSgkmTJnWa+7Rr1y7ExMRg8uTJWLJkCdatW6d6/TVgwABcvnwZsbGx+OqrrzB69Gjk5OTgzZs3Xj1pKigowPz58/Htt99i1KhRWLVqFV69eqWKycnJgcvlwvLly9+jMkTUEzTy3xf0REQfieTkZIwfPx579uwJdCqd1NTUYPr06WhubobZbA50OkQfNc5ZIiLqQ5xOJ549e4YtW7YgIyODjRJRH8DXcEREfcjx48cRFxeHFy9eYMeOHYFOh4jA13BEREREHvHJEhEREZEHbJaIiIiIPGCzREREROQBmyUiIiIiD9gsEREREXnAZomIiIjIAzZLRERERB6wWSIiIiLy4F+ErlofdrugEwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "ax1 = fig.add_subplot(211)\n", - "ax2 = fig.add_subplot(212, sharex=ax1)\n", - "\n", - "ax1.plot(np.fft.rfftfreq(len(proper_sampling)), proper_sampling_spectrum.real - proper_sampling_spectrum.real, label='Original')\n", - "ax1.plot(np.fft.rfftfreq(len(interval_priority_sampling)), interval_sampling_spectrum.real - proper_sampling_spectrum.real, label='Interval')\n", - "ax1.plot(np.fft.rfftfreq(len(increment_priority_sampling)), increment_sampling_spectrum.real - proper_sampling_spectrum.real, label='Increment')\n", - "ax2.plot(np.fft.rfftfreq(len(proper_sampling)), proper_sampling_spectrum.imag - proper_sampling_spectrum.imag)\n", - "ax2.plot(np.fft.rfftfreq(len(interval_priority_sampling)), interval_sampling_spectrum.imag - proper_sampling_spectrum.imag)\n", - "ax2.plot(np.fft.rfftfreq(len(increment_priority_sampling)), increment_sampling_spectrum.imag - proper_sampling_spectrum.imag)\n", - "\n", - "ax1.grid()\n", - "ax2.grid()\n", - "ax1.legend()\n", - "ax1.set_ylabel('Amplitude Difference')\n", - "ax2.set_ylabel('Phase Difference')\n", - "ax2.set_xlabel('Frequency')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "base", - "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.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}