diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1bccc1f --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.h5 filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..95d475d --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +.vscode/settings.json +__pycache__/* +output/* +input/* +baselMorphableModel/* +faceNext/* +drjit/* +mitsuba/* +*.pyc +ext/* +chi2_data.py diff --git a/INSTALL b/INSTALL index fcc1304..4eb8f84 100644 --- a/INSTALL +++ b/INSTALL @@ -5,4 +5,5 @@ pip install redner-gpu conda install -c conda-forge opencv conda install -c 1adrianb face_alignment=1.2.0 conda install -c anaconda h5py -pip install mediapipe \ No newline at end of file +pip install mediapipe +pip install mitsuba \ No newline at end of file diff --git a/README.md b/README.md index 0bc6cbb..9cf94b9 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # NextFace + NextFace is a light-weight pytorch library for high-fidelity 3D face reconstruction from monocular image(s) where scene attributes –3D geometry, reflectance (diffuse, specular and roughness), pose, camera parameters, and scene illumination– are estimated. It is a first-order optimization method that uses pytorch autograd engine and ray tracing to fit a statistical morphable model to an input image(s). +

@@ -10,109 +12,145 @@ NextFace is a light-weight pytorch library for high-fidelity 3D face reconstruct Practical Face Reconstruction via Differentiable Ray Tracing

+# News - - -# News +* **1 September 2023:** Implemented the use of vertex based and mitsuba renderers in the pipeline. + * Mitsuba supports newer graphic cards architectures and is producing results up to 5x faster than redner. + * There are new utilitary methods in the utils.py file to help debugging + * You can change the wanted renderer from the config file (optimConfig.ini) * **19 March 2023**: fixed a bug in the optimizer where the gradients whare not activated for the camera pos (rotation and translation). Also I added a new optimization strategy for the second and third stage which should improve the overall performance. plz pull * **21 June 2022**: Many thanks for **[Jack Saunders](https://researchportal.bath.ac.uk/en/persons/jack-saunders)** for adding this new feature to NextFace: Added support for [mediapipe](https://google.github.io/mediapipe/solutions/face_mesh.html#overview) as a replacement for FAN landmarks detector. Mediapipe produces much stable and accurate results than FAN . To try mediapipe, you need to pull the new version of the code and install mediapipe ** pip install mediapipe** . Now by default the landmarks detector used is mediapipe, if you want to switch bach to FAN plz edit the **optimConfig.ini** file (set **lamdmarksDetectorType = 'fan'**) -* **01 May 2022**: i you want to generate an animation like the one of the gif files in the readme that rotates the reconstruction on the vertical axis, plz run the replay.py script and give it the path of the pickle file that contains the optimized scene attributes ( located in checkpoints/stage3_output.pickle). +* **01 May 2022**: i you want to generate an animation like the one of the gif files in the readme that rotates the reconstruction on the vertical axis, plz run the replay.py script and give it the path of the pickle file that contains the optimized scene attributes ( located in checkpoints/stage3_output.pickle). * **26 April 2022**: I added export of the estimated light map (as an environment map). this can be useful if you want to render the face with other rendering engines (Unreal, Unity, OpenGL). plz pull the code. U can choose to export the lightmap as png or exr (check optimConfig.ini) -* **25 April 2022**: if you want to generate textures with higher resolutions (1024x1024 or 2048x2048) I have added these two maps here : **https://github.com/abdallahdib/NextFace/releases**. to use these maps, download **uvParametrization.2048.pickle** and **uvParametrization.1024.pickle** and put them inside **baselMorphableModel** directory and change the **textureResolution** in **optimConfig.in** to 1024 or 2048. Also dont forget to pull the latest code. Plz note that with these large uvmaps optimization will require more cpu/gpu memory. -* **24 April 2022**: added a colab notebook in: **demo.ipynb**. +* **25 April 2022**: if you want to generate textures with higher resolutions (1024x1024 or 2048x2048) I have added these two maps here : **https://github.com/abdallahdib/NextFace/releases**. to use these maps, download **uvParametrization.2048.pickle** and **uvParametrization.1024.pickle** and put them inside **baselMorphableModel** directory and change the **textureResolution** in **optimConfig.in** to 1024 or 2048. Also dont forget to pull the latest code. Plz note that with these large uvmaps optimization will require more cpu/gpu memory. +* **24 April 2022**: added a colab notebook in: **demo.ipynb**. * **20 April 2022**: I replaced landmarks association file with a new one which gives better reconstruction, especially on face coutours. Plz pull * **20 April 2022**: I tried NextFace on a challenging face and surprisingly we still get appealing reconstruction, check below: +

-# Features: +# Features: + * Reconstructs face at high fidelity from single or multiple RGB images -* Estimates face geometry -* Estimates detailed face reflectance (diffuse, specular and roughness) +* Estimates face geometry +* Estimates detailed face reflectance (diffuse, specular and roughness) * Estimates scene light with spherical harmonics * Estimates head pose and orientation * Runs on both cpu and cuda-enabled gpu - # Installation -* Clone the repository -* Execute the commands in 'INSTALL' file. these commands create a new conda environment called faceNext and install required packages. An 'environment.yml' is also provided. The library is tested with torch 1.3.1, torchvision 0.4.2 and cuda toolkit 10.1, but it should also work with recent pytorch versions. + +* Clone the repository +* Execute the commands in 'INSTALL' file. these commands create a new conda environment called faceNext and install required packages. An 'environment.yml' is also provided. The library is tested with torch 1.3.1, torchvision 0.4.2 and cuda toolkit 10.1, but it should also work with recent pytorch versions. * Activate the environment: conda activate nextFace * Download basel face model from [here](https://faces.dmi.unibas.ch/bfm/bfm2017.html), just fill the form and you will receive an instant direct download link into your inbox. Downloaded **model2017-1_face12_nomouth.h5 file** and put it inside **./baselMorphableModel** directory * Download the albedo face model **albedoModel2020_face12_albedoPart.h5** from [here](https://github.com/waps101/AlbedoMM/releases/download/v1.0/albedoModel2020_face12_albedoPart.h5) and put it inside **./baselMorphableModel** directory - +* Make sure to use a default morphable model in rendererMitsuba to create an initial scene. The mesh will be modified at runtime # How to use ## Reconstruction from a single image + * to reconstruct a face from a single image: run the following command: - * **python optimizer.py --input *path-to-your-input-image* --output *output-path-where-to-save-results*** + * **python optimizer.py --input *path-to-your-input-image* --output *output-path-where-to-save-results*** + ## Reconstruction from multiple images (batch reconstruction) -* In case you have multiple images with same resolution, u can run a batch optimization on these images. For this, put all ur images in the same directory and run the following command: - * **python optimizer.py --input *path-to-your-folder-that-contains-all-ur-images* --output *output-path-where-to-save-results*** + +* In case you have multiple images with same resolution, u can run a batch optimization on these images. For this, put all ur images in the same directory and run the following command: + * **python optimizer.py --input *path-to-your-folder-that-contains-all-ur-images* --output *output-path-where-to-save-results*** +* For now, our mitsuba implementation doesn't support batch rendering, you can still handle a folder of images (look at the commands_demo jupyter notebook) + ## Reconstruction from mutliple images for the same person + * if you have multiple images for the same person, put these images in the same folder and run the following command: - * **python optimizer.py --sharedIdentity --input *path-to-your-folder-that-contains-all-ur-images* --output *output-path-where-to-save-results*** - the **sharedIdentity** flag tells the optimizer that all images belong to the same person. In such case, the shape identity and face reflectance attributes are shared across all images. This generally produces better face reflectance and geometry estimation. + * **python optimizer.py --sharedIdentity --input *path-to-your-folder-that-contains-all-ur-images* --output *output-path-where-to-save-results*** + + the **sharedIdentity** flag tells the optimizer that all images belong to the same person. In such case, the shape identity and face reflectance attributes are shared across all images. This generally produces better face reflectance and geometry estimation. +* Mitsuba doesn't handle this usecase, it is in our roadmap + ## Configuring NextFace + * The file **optimConfig.ini** allows to control different aspect of NextFace such as: - * optimization (regularizations, number of iterations...) - * compute device (run on cpu or gpu) - * spherical harmonics (number of bands, environment map resolution) - * ray tracing (number of samples) -* The code is self-documented and easy to follow + * optimization (regularizations, number of iterations...) + * compute device (run on cpu or gpu) + * spherical harmonics (number of bands, environment map resolution) + * ray tracing (number of samples) + * renderer (which renderer to use Vertex based / Redner / Mitsuba 3) +* The code is self-documented and easy to follow + +# Output -# Output The optimization takes 4~5 minutes depending on your gpu performance. The output of the optimization is the following: -* render_{imageIndex}.png: contains from left to right: input image, overlay of the final reconstruction on the input image, the final reconstruction, diffuse, specular and roughness maps projected on the face. + +* render_{imageIndex}.png: contains from left to right: input image, overlay of the final reconstruction on the input image, the final reconstruction, diffuse, specular and roughness maps projected on the face. * diffuseMap_{imageIndex}.png: the estimated diffuse map in uv space * specularMap_{imageIndex}.png: the estimated specular map in uv space * roughnessMap_{imageIndex}.png: the estimated roughness map in uv space * mesh{imageIndex}.obj: an obj file that contains the 3D mesh of the reconstructed face +* If the debug options are used : + * in the debug/mesh folder : the mesh at {renderer}_{step} _{iteration}.obj + * in the debug/results folder : render, input, difference, diffuse, specular and roughness maps (the order from left to right) + * in outputStage1 folder : the render after step 1 + * in outputStage2 folder : the render after step 2 + * in the checkpoints folder : the loss graphs and the architecture parameters in pickle format + +# How it works + +NextFace reprocudes the optimization strategy of our [early work](https://arxiv.org/abs/2101.05356). The optimization is composed of the three stages: -# How it works -NextFace reprocudes the optimizatin strategy of our [early work](https://arxiv.org/abs/2101.05356). The optimization is composed of the three stages: * **stage 1**: or coarse stage, where face expression and head pose are estimated by minimizing the geometric loss between the 2d landmarks and their corresponding face vertices. this produces a good starting point for the next optimization stage * **stage 2**: the face shape identity/expression, statistical diffuse and specular albedos, head pose and scene light are estimated by minimizing the photo consistency loss between the ray traced image and the real one. -* **stage 3**: to improve the statistical albedos estimated in the previous stage, the method optimizes, on per-pixel basis, the previously estimated albedos and try to capture more albedo details. Consistency, symmetry and smoothness regularizers (similar to [this work](https://arxiv.org/abs/2101.05356)) are used to avoid overfitting and add robustness against lighting conditions. -By default, the method uses 9 order spherical harmonics bands (as in [this work](https://openaccess.thecvf.com/content/ICCV2021/papers/Dib_Towards_High_Fidelity_Monocular_Face_Reconstruction_With_Rich_Reflectance_Using_ICCV_2021_paper.pdf)) to capture scene light. you can modify the number of spherical harmonics bands in **optimConfig.ini** bands and see the importance of using high number of bands for a better shadows recovery. +* **stage 3**: to improve the statistical albedos estimated in the previous stage, the method optimizes, on per-pixel basis, the previously estimated albedos and try to capture more albedo details. Consistency, symmetry and smoothness regularizers (similar to [this work](https://arxiv.org/abs/2101.05356)) are used to avoid overfitting and add robustness against lighting conditions. + By default, the method uses 9 order spherical harmonics bands (as in [this work](https://openaccess.thecvf.com/content/ICCV2021/papers/Dib_Towards_High_Fidelity_Monocular_Face_Reconstruction_With_Rich_Reflectance_Using_ICCV_2021_paper.pdf)) to capture scene light. you can modify the number of spherical harmonics bands in **optimConfig.ini** bands and see the importance of using high number of bands for a better shadows recovery. # Good practice for best reconstruction * To obtain best reconstruction with optimal albedos, ensure that the images are taken in good lighting conditions (no shadows and well lit...). -* In case of single input image, ensure that the face is frontal to reconstructs a complete diffuse/specular/roughness, as the method recover only visible parts of the face. -* Avoid extreme face expressions as the underlying model may fail to recover them. -# Limitations -* The method relies on landmarks to initialize the optimization (Stage 1). In case these landmarks are inaccurate, you may get sub-optimal reconstruction. NextFace uses landmarks from [face_alignment](https://github.com/1adrianb/face-alignment) which are robust against extreme poses however they are not as accurate as they can be. This limitation has been discussed [here](https://openaccess.thecvf.com/content/ICCV2021/papers/Dib_Towards_High_Fidelity_Monocular_Face_Reconstruction_With_Rich_Reflectance_Using_ICCV_2021_paper.pdf) and [here](https://arxiv.org/abs/2101.05356). Using [this landmark detector](https://arxiv.org/abs/2204.02776) from Microsoft seems promising. +* In case of single input image, ensure that the face is frontal to reconstructs a complete diffuse/specular/roughness, as the method recover only visible parts of the face. +* Avoid extreme face expressions as the underlying model may fail to recover them. + +# Limitations + +* The method relies on landmarks to initialize the optimization (Stage 1). In case these landmarks are inaccurate, you may get sub-optimal reconstruction. NextFace uses landmarks from [face_alignment](https://github.com/1adrianb/face-alignment) which are robust against extreme poses however they are not as accurate as they can be. This limitation has been discussed [here](https://openaccess.thecvf.com/content/ICCV2021/papers/Dib_Towards_High_Fidelity_Monocular_Face_Reconstruction_With_Rich_Reflectance_Using_ICCV_2021_paper.pdf) and [here](https://arxiv.org/abs/2101.05356). Using [this landmark detector](https://arxiv.org/abs/2204.02776) from Microsoft seems promising. * NextFace is slow and execution speed decreases with the size of the input image. For instance, if you are running an old-gpu (like me), you can decrease the resolution of the input image in the **optimConfig.ini** file by reducing the value of the *maxResolution* parameter. Our [recent work](https://openaccess.thecvf.com/content/ICCV2021/papers/Dib_Towards_High_Fidelity_Monocular_Face_Reconstruction_With_Rich_Reflectance_Using_ICCV_2021_paper.pdf) solves for this and achieve near real-time performance using deep convolutional neural network. -* NextFace cannot capture fine geometry details (wrinkles, pores...). these details may get baked in the final albedos. our recent [work](https://arxiv.org/abs/2203.07732) captures fine scale geometric details. -* The spherical harmonics can only model lights at infinity, under strong directional shadows, the estimated light may not be accurate as it can be, so residual shadows may appear in the estimated albedos. You can attenuate this by increasing the value of regularizers in the **optimConfig.ini** file, but this trade-off albedo details. -Below are the values to modify: - * for diffuse map: *weightDiffuseSymmetryReg* and *weightDiffuseConsistencyReg*, - * for specular map: *weightSpecularSymmetryReg*, *weightSpecularConsistencyReg* - * for roughness map: *weightRoughnessSymmetryReg* and *weightRoughnessConsistencyReg* -I also provided a configuration file named **optimConfigShadows.ini** which have higher values for these regularizers that u can try. +* NextFace cannot capture fine geometry details (wrinkles, pores...). these details may get baked in the final albedos. our recent [work](https://arxiv.org/abs/2203.07732) captures fine scale geometric details. +* The spherical harmonics can only model lights at infinity, under strong directional shadows, the estimated light may not be accurate as it can be, so residual shadows may appear in the estimated albedos. You can attenuate this by increasing the value of regularizers in the **optimConfig.ini** file, but this trade-off albedo details. + Below are the values to modify: + * for diffuse map: *weightDiffuseSymmetryReg* and *weightDiffuseConsistencyReg*, + * for specular map: *weightSpecularSymmetryReg*, *weightSpecularConsistencyReg* + * for roughness map: *weightRoughnessSymmetryReg* and *weightRoughnessConsistencyReg* + I also provided a configuration file named **optimConfigShadows.ini** which have higher values for these regularizers that u can try. * Using a single image to estimate face attribute is an ill-posed problem and the estimated reflectance maps(diffuse, specular and roughness) are view/camera dependent. To obtain intrinsic reflectance maps, you have to use multiple images per subject. +* When using mitsuba in the command line, you might receive leak variables. This is a known issue and the team at drjit is on it. The Python shutdown sequence is rather complex and some Dr.Jit variables get freed in an undesired order, hence the warning message (It only happens in the Python script and not in the notebook as the notebook's kernel keeps running even once you've executed all cells.). It shouldn't impact the optimisation process for individual images and for our approach for batch optimisation. +* If your kernel is crashing for no reasons, it might be an overflow issue. Try reducing the number of samples or reducing the amount of debugs. # Roadmap + If I have time: + * Expression tracking from video by optimizating head pose and expression on per-frame basis, which is straightforward once you have estimated the intrinsic face parameters(reflectance and geometry). I did not implement it yet simply, because i am running an old gpu (GTX 970M). I may add this feature when I decide to buy an RTX :) * Add virtual lightstage as proposed in [this](https://arxiv.org/abs/2101.05356) to model high frequency point lights. -* Add support for [FLAME](https://github.com/Rubikplayer/flame-fitting) morphable model. You are welcome if you can help. +* Add support for [FLAME](https://github.com/Rubikplayer/flame-fitting) morphable model. You are welcome if you can help. * Add GUI interface for loading images, landmarks edition, run optimization and visualize results. - +* Add support for batch and shared identity for mitsuba + # License + NextFace is available for free, under GPL license, to use for research and educational purposes only. Please check LICENSE file. # Acknowledgements + The uvmap is taken from [here](https://github.com/unibas-gravis/parametric-face-image-generator/blob/master/data/regions/face12.json), landmarks association from [here](https://github.com/kimoktm/Face2face/blob/master/data/custom_mapping.txt). [redner](https://github.com/BachiLi/redner/) is used for ray tracing, albedo model from [here](https://github.com/waps101/AlbedoMM/). -# contact +# contact + mail: deeb.abdallah @at gmail twitter: abdallah_dib -# Citation +# Citation + If you use NextFace and find it useful in your work, these works are relevant for you: ``` @@ -141,3 +179,4 @@ If you use NextFace and find it useful in your work, these works are relevant fo journal={arXiv preprint arXiv:2203.07732}, year={2022} } +``` diff --git a/commands_demo.ipynb b/commands_demo.ipynb new file mode 100644 index 0000000..ab95f72 --- /dev/null +++ b/commands_demo.ipynb @@ -0,0 +1,178 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Reconstruction of a face from a single image ( Vertex / Redner / Mitsuba)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "! py -u ./optimizer.py --input input/test/s1.png --output output/test/mitsuba_blank_text" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Batch reconstruction of a faces from a folder ( Vertex / Redner)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "! py ./optimizer.py --input input/test/ --output output/test/all_images/vertex_reg " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Batch reconstruction of faces in loop (Mitsuba)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "py ./optimizer.py --input input/test/s1.png --output output/test/mitsuba_rednermat_clip\n" + ] + } + ], + "source": [ + "import os\n", + "import subprocess\n", + "# Directory path containing all images\n", + "imageFolderPath = './input/test/'\n", + "\n", + "outputDir = './output/test/mitsuba_rednermat_clip'\n", + "#setup\n", + "if not os.path.exists(outputDir):\n", + " os.makedirs(outputDir) # Create the output directory if it doesn't exist\n", + "# Get the names of all files in the specified directory\n", + "image_names = [f for f in os.listdir(imageFolderPath) if os.path.isfile(os.path.join(imageFolderPath, f))]\n", + "\n", + "# Filter only image files by extensions (if required)\n", + "image_paths = [os.path.join(imageFolderPath, image_name) for image_name in image_names if image_name.endswith(('.png', '.jpg', '.jpeg'))]\n", + "\n", + "# Print the command for each image\n", + "for image_path in image_paths:\n", + " # Removing the './' from the image path\n", + " image_path = image_path.replace('./', '')\n", + " outputDir = outputDir.replace('./', '')\n", + " command = f'py ./optimizer.py --input {image_path} --output {outputDir}'\n", + " print(command)\n", + " # Execute the command using os.system(command) if desired\n", + " # os.system(command)\n", + " result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\n", + " print(result.stdout.decode())\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "^C\n" + ] + } + ], + "source": [ + "! py ./optimizer.py --input input/test/s3.png --output output/test/mitsuba_rednermat_clip" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Display images" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "def display_images_in_folder(folder_path):\n", + " # Iterate through the folder and subfolders\n", + " for root, dirs, files in os.walk(folder_path):\n", + " # Look for the file \"render0.png\" in the current directory\n", + " if \"render_0.png\" in files:\n", + " image_path = os.path.join(root, \"render_0.png\")\n", + " # Open the image using PIL\n", + " image = Image.open(image_path)\n", + " # Display the image\n", + " # Plot and display the image using Matplotlib\n", + " plt.imshow(image)\n", + " plt.axis('off') # Turn off axis\n", + " plt.title(f\"Image from: {root}\")\n", + " plt.show()\n", + "\n", + "# Path to the output directory\n", + "output_folder_path = outputDir\n", + "\n", + "# Call the function to find and display the images\n", + "display_images_in_folder(output_folder_path)\n" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "name": "demo.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/config.py b/config.py index 5dd284d..a707d3c 100644 --- a/config.py +++ b/config.py @@ -12,7 +12,7 @@ def __init__(self): #morphable model self.path = 'baselMorphableModel' - self.textureResolution = 256 #256 or 512 + self.textureResolution = 512 #256 or 512 self.trimPca = False # if True keep only a subset of the pca basis (eigen vectors) #spherical harmonics @@ -51,11 +51,16 @@ def __init__(self): self.weightRoughnessSmoothnessReg = 0.002 # smoothness regularizer weight for roughness texture (at step 3) self.debugFrequency = 10 #display frequency during optimization + self.debugOutput = False # generate outputs at each debugFrequency self.saveIntermediateStage = False #if True the output of stage 1 and 2 are saved. stage 3 is always saved which is the output of the optim + self.saveTime = False # if True will save the time taken in the txt self.verbose = False #display loss on terminal if true self.rtSamples = 500 #the number of ray tracer samples to render the final output self.rtTrainingSamples = 8 # number of ray tracing to use during training + self.bounces = 2 # number of bounces + self.smoothing = True #should we smooth the face when doing diff + self.rendererName = 'redner' #default renderer name def fillFromDicFile(self, filePath): ''' overwrite default config diff --git a/demo.ipynb b/demo.ipynb index b4b4e8e..f08f422 100644 --- a/demo.ipynb +++ b/demo.ipynb @@ -1,64 +1,72 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", + "metadata": { + "id": "iKuIEsqO6vDS" + }, "source": [ "1. Clone NextFace and set the correct path on google drive\n", "2. enable gpu from Menu->Runtime-> Change runtime type" - ], - "metadata": { - "id": "iKuIEsqO6vDS" - } + ] }, { "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "YG4jOi1Rwx2A" + }, + "outputs": [], "source": [ "!git clone https://github.com/abdallahdib/NextFace.git\n", "import sys\n", "import os\n", "sys.path.insert(0,'/content/NextFace') #verify ur path" - ], - "metadata": { - "id": "YG4jOi1Rwx2A" - }, - "execution_count": null, - "outputs": [] + ] }, { + "attachments": {}, "cell_type": "markdown", - "source": [ - "2. install dependencies" - ], "metadata": { "id": "h3pczgA468RG" - } + }, + "source": [ + "2. install dependencies" + ] }, { "cell_type": "code", - "source": [ - "pip install face_alignment==1.2.0 redner-gpu" - ], + "execution_count": 2, "metadata": { "id": "zQ-elwGa0J3S" }, - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "pip install face_alignment==1.2.0 redner-gpu" + ] }, { + "attachments": {}, "cell_type": "markdown", + "metadata": { + "id": "0wyQLAtM7DnR" + }, "source": [ "3. create optimizer and set the correct path to the **'baselMorphableModel'** directory \n", "\n", "PS: u have to manually upload the file **'morphableModel-2017.pickle'** from your local pc to google drive or download the **'model2017-1_face12_nomouth.h5'** from https://faces.dmi.unibas.ch/bfm/bfm2017.html and **albedoModel2020_face12_albedoPart.h5** from https://github.com/waps101/AlbedoMM/releases/download/v1.0/albedoModel2020_face12_albedoPart.h5. put these two files inside the **'baselMorphableModel'** directory\n", "\n", "The reason for not adding these files directly because we are not allowed to share these files and u have to manually agree with their license term before using these data. so yeh! unfortunately u will have to manually download them (please refer to readme file in the github repository)" - ], - "metadata": { - "id": "0wyQLAtM7DnR" - } + ] }, { "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "jNPREJEczUYg" + }, + "outputs": [], "source": [ "\n", "from optimizer import Optimizer\n", @@ -67,45 +75,34 @@ "config.fillFromDicFile('/content/NextFace/optimConfig.ini')\n", "config.device = 'cuda'\n", "config.path = '/content/NextFace/baselMorphableModel/' #verify ur path\n" - ], - "metadata": { - "id": "jNPREJEczUYg" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "AwYMbIY00IvC" + }, + "outputs": [], "source": [ "imagePath = '/content/NextFace/input/s1.png' #verify ur path\n", "outputDir = './content/outputOptim/' + os.path.basename(imagePath.strip('/'))\n", "optimizer = Optimizer(outputDir ,config)" - ], - "metadata": { - "id": "AwYMbIY00IvC" - }, - "execution_count": null, - "outputs": [] + ] }, { + "attachments": {}, "cell_type": "markdown", - "source": [ - "now we can run the optimization" - ], "metadata": { "id": "khcuAPKZA9RT" - } + }, + "source": [ + "now we can run the optimization" + ] }, { "cell_type": "code", - "source": [ - "#run the optimization now \n", - "optimizer.run(imagePath)\n", - "#display results\n", - "from IPython.display import Image, display\n", - "from IPython.display import Image\n", - "display(Image(outputDir + '/render_0.png'))\n" - ], + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -114,19 +111,18 @@ "id": "5lQYBcXb90iH", "outputId": "4ff2113d-6eec-4b77-9d8f-4a32138ea7fc" }, - "execution_count": 5, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "loading image from path: /content/NextFace/input/s1.png\n", "detecting landmarks...\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "/content/NextFace/landmarks.py:35: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ../torch/csrc/utils/tensor_new.cpp:201.)\n", " return torch.tensor(landmarks, device = self.device)\n", @@ -142,66 +138,68 @@ ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAABwAAAAEACAYAAAC0x2IlAAEAAElEQVR42uz9bZBsyXnfB/6eJzNPVXffvvfOoGYwMxiQeCMJUAJFApBJkyGKEkDLsHZFrcMWRZuyTGhDtumVbIcd4aAi/MUR65U3NmK/WEFZdngj1ra4YXtlhe0IiZRDkk2HqBUhGxRJk4RAkAAGGABTM/e9u6pOZj774clzqrpv932ZuS89mPMgMLe76lSeU3kyq+vk7/z/f7n83LebmjGUIeN//Sf/TTBEFDPD2pa0bYbfRBTM2i+tNREwMNrrTBABE0MRxl2bv8hEUDFqe1iGozAB9ddjhgkIRhDBEMxq26n4noaGVcAEE0Mw1KS1XdHxTdd2/GF4NUpFUMrwTq2ioqhUqBXUUDFKqWAFsUKuGatQzVAFQzGraBWqQa0GAkM3KYKIjW9fBIoZKoIG341UQ1T8mEQQ874zEajmbSKIVsTEz8G2mwhBWx8YZoYCuRTUBKSdn/aeBT9OE1AxrLbTaSBBCaoggtXatq3+fkQQFA2CWKUUa20oKSqGv3dVPz4xQ1WRqMRgSIWiCgVqKZRS6aIiKtRaKBi5GDn7mQtt3FQfnEgQYorEoAQgt/dYS6CQMAkgirbxWM1fbyrj4BUEk+r9MoxwMRDFqgIVwagCYq2TwM9NtXG2mBki4yj0bYYTTsVMAAXZ9vm4P4yA+itF8Vkg7Y0OByrjnPNRDKHtq5rPU2jzo4K17cXfJGaChMT6zutYPuL40nM88loCi4d8btn+Xdyv8QT093jsfs8/WC1OHdbJx1enjn155rbvtDqrzxaL8877gjnAfOfstG5dsWS+09rqZDfftZ9F29Ecds6O79C3mZ84xiXpAd9R38bOgz7OOePs9Pi713hNO+33b2rs3n8eJlj+DgD/xo+c+Dh5bLXzFeMx7+gJvfwpvB+7oH123ybs6Z1ve8r9cm6zdjHOZbf/hIbxNP8fyQHZBZz70/x/+87/n/0HTDXVVFNNNdVUU0011VTvkIpixsAzBBAnYYgMIG33It5R4BbAQaNyjfc5YGlsxIGUQW2MQ3EQ569ymOgb+r6EBp4GejUCKtmlkYA12CGguj2Oduy1HaeIAxLFUGvtDlASWpvV9y0OYCqKWHZ6MpBMM1RApTTAU1ExsAqlRxqosdaR0qCLWW3ssuFPsbG/GABc20uloihBGmw18X2GgIiQax3bV3UmJCjESi4VqoO4AFCNEGXn1HlfjKdTvM/qAEpVfQw00BQEMB2vJoOIn6NGAw0otoVxYtL4rEMrCULQSIiBKEIuBaQ6x6rVx0TNUMCCMpsF9qIQ9yKQWPdl7JXNsQM2ESEFh5ulVEwUBUQdk5VcEKBgpCCkWaDP0OcVpQRM5pgq4IC5mIGFbQ+J9+8AnrX1m1VziCv+uw4Ql0o1cUjbxpMz7G2/NQaOSXUQV9vcaoDO54g1AAl1Zx7U1r9CZYu2ZVw8sAYDEaHWBrelPS+C1HbOsTant2A4DHOgPXYCFNwL3vGA27yZ5xYPuY+x0ql/z6r7AZQBMc3PeWx1/qEvl9NfkbNOp1O51nvLM+jgktXCuzbNF+wniPve/6nf9nR/63Sb2zYWp87DauF4b84C5gtWK0eAy+UCFvP20sSCvjWRzhgn6Yyxda8xlc4Zj/09xt+DPNc/4Ni9ByB8gDn9UOuF9uTGjz3Bfb3Z92VPaD9vZh92AfvrgV/6FICBPeV+uWdTjxEWXNT5/9DHNs3/t8X8f6CXT/P/ZHN2Mc/jVFNNNdVUU0011VRTTfX2quggaIevDUI72yqYrKmXhOA8THxDUaE0eKENENUmZRMb2jAE3VEN+iNijLADXKmkSJO9eXsDgJGm1DoNtARxxVxjf9UcdvixFGBQ2TWohrjqqza4YpVqTd3lpLApt8q4Hyjj+wNcsWeFmjNiFaxSdwClYQ0ESQOO/ppgQm4KMTXG46HBx2CDskvGvhKNOOaqDuFwWZez0aYPEyUqWGn7FIdiIgHMHCQ18EQ1aoOOMigwZctVR1UmQq0NWqkD3GE8aDu+YDRILEhw9KdilAYxVRRqJRvkklEJWyHbIL2sxsaMTd8TtWc+7+i6xDwmUNj0BU1GKoo1dd963VPq0Md+PABWKxTa/ozLOiPOAhKFzXFPX46o1hFCAoGg1t6jjlBtgN9WChbVVXhWXTnIAAcdPBfZ6k0FaerOUfo6KmdNBbXqKj0ZWtpCv91rcbEGhLf/acC89boTxPF0DtCdcQ47oBWgiM+FQc8rw3yWgaGfc/V/L3Xe8PyCBweF8IAgb+c1Cx4QSJ4HcB5WNTU/tZ9dhd858G8H/D1OBLh4k/tY8GQViYudnS52flmddfCn3tStBggP5wtSgr3ksC73K/r5gvmKUSl4a7W8x7BYwhJWiyWHLEiH0PcLFosGAdu+l+PRnaPkW/awOGtsccb42m3jPIB4nvrvUVT/cPPqTSwCvul1wgkYvrWueELAwC5gfz3wy+zJHrtdgH65bxP2aI9hmv/T/J/m/7fo/J9qqqmmmmqqqaaaaqqp3jEV6ynl3+61gyuRGvgZFESDWm6AfYMuaRdoNAWeNVhoTYVUR3vEk/DP1YGt9aY+3K1qRhhAjWxtEwdbUbEtNoMdpdS4MjC0a2jd4j1rcM1QSoOE2qxOHfT5Fmg7OstQC9TeMY4JJkqtdbTBLOZWkVK20HCQS6po65OdzhosOAfVYIM8mGClkhvwM2n2kIPCsCkUDQgaKPgxUBuocsqHNiYVVMlmfvymjS/ZCG4NoYqrDp0w+uEprgzU1v8VV0GqREJQt9c077fhZWJuyZotOz0UoY4qSP8dE4IoVWk2n3C07tn0hRDE1YMhklQpAsRI0oDGwKxUaqlsNhtKGZxh/YCDCutSub3O7AGzoOgsUFcVK2sHoqEjyBaY2XiaGpnUZlvbrEEdmg0YW1zR2kaYnjGut3a4zcK1vd5kC+JOwD/ZgtXazgVtWx8io3QTse2wlmZHWsVVmNLG02D1auoiVWnqRRntS0+tENwL6L0ZiMc5r3kQaLg47/fTYKXnbPhxL3vGe4CxxYMdjr/4ycC/R9n+4wCCi/MOtvXR8pz9L845sFurJaxgzoI099OYwEWYCRJzDtMC5k2XuVqeCReXS2DhSkB//QABgaYGPLsv0j3GQnrI3knnPNbfY/vHBAoXD7mA+BYWEy+i5dqZu7mgwOAi998T6bfHDVeewPHbBemXB3mpPc1zMc3/af5P8/+pzv+ppppqqqmmmmqqqaaa6p1TcYAcsgNwxhpYDezk6DUwIQ306K7ar9lESjNSFB1tQD37ruWZjS6JcgKGOOiS8Zdm8knVbftuaWgj4JLquWwqLd+v7TvoYMFZG/BSRLTBMbfYHDRtoxViO/YBYrmuqrb8vIpYdoDTwFltr7FaGxyz8QowawOXO/l77ZC3irudd+82oXIiR1GGzLcxu21QTjpAG2wpQ4igGaq5zWWDhCjUKsQQkQDUghLacTZ1XwNYDErJnezG0MClDJDM3L4zhkjQsM0BpEJQBhFctUrFKFaJGgiqVCq1Qgh+rsQEUSOKYCGMoNmVdALFsJoJ6paneb1hVRVRbTzWSBpcl1e97w0/lC5Eai0cryohRlKA/ZmyybDe9FiuWIggEdcsOtrT1reD/a2YQ9VhXFoDxDT7VXHf1QbeRtY8ZgBKU+tVc6Y4njvcGrZqG+FbvteUiFtrXLERKZ6wzHUl4DarExvGj88vKSB1gJVDjOCOxes4/nbqLKXWeUq809DwLKJy+rX3Uw7eExA+TB7a7jYrWM7Hdh8Egp17CBfU7nNxj+4fu/QRE8C7cvhOtX8yn2/74GJxRiOnOnw1/mdHQ9dDv1qNSkBoEPAMyDwcy2qxZNVsSOcsWCxguVw2CDi0cBq6wcn8vfPqQba51+tO7/NeY/gB6vTceUAL3UeunHmSwPCRNPAQzV+wHLOL2ndPtM8ed1+9HXPAHqZfnuL8v4i2i9P8n+b/O2n+TzXVVFNNNdVUU0011VTvnIpijAolafKikTOwtfesbMEBpkg1MgbFECpBAyEIqmGESEOuXKlGKdsrEh2yAmFUNI07tDoCLFdSee5aVVdTjRRtaEukZdk5WBq0VG6d6KCpypAPmNtrFKUAAQvS4B6IFESK7x+3z7SWryZWsQYHkUC2Sq0FqqGqFBvxZOvDBhkH8NegWt3JkqsD8MNtTLe2ndnVeG66ishWLxlSagGAng3oAK40e9ZKpRJUHT5Jg5KqaBAkF4zSwJG0fjBqdcikTYlWze02pUFMk6Zyq5UuJSQGt9w0vF1RSvWBI7W49akaURXRlpMXteUT1i1oVHGghxDMqDgQpOUrVlOqJx2CKqVWLGdqrt7fOxagtTpwFCexo41m3WSqCjFFugig9NmoJfuAloCQgdj6vI3NSmtIt3mYLcOyCS0H304/j+NYtqbSbCpXbbNoUN41Gj4AxyFn0jBoWYeYUbWB5kGB2BS6Dgj9sdIguba+oClzMWlQfICatb10MHjdmXS7oOBBYB6ntjkl61qcYcu5fFD4dK5MbNvWg7x828zq7ifOaH771OruRpec2SlPCwUuTvfR8vxTtzzxoruP+qzTck7zJ/ttd78DWF2ecwp3+n5xJgBejMmLzelzWyvo5yf3v1rt2IqeOonjQ8PPTYm4WjgAnAOLxaIpAYHFXXvcqQcFfKe3Oes16R7j92HA9n0G/71+f9oLko9gofIiA4OnasVmT+gt27dAn9nbZ3zZE+ybiz7/L+oYnub/I25qmv9PZf5PNdVUU0011VRTTTXVVN/6FWWQpG2Fd6MFp1lp8Co4tzBxG0kxUhAO9jr2u8Ssi8QYSMGpg+xAMDPoc6XPmc2mcLzesFkX+mKejTcq4HYUSbKbpdfQV4M6OqgUt/8Z8wsHuFYBSnFgotpsMAtNzuaZbKquNmzt11qb6lAxMXK1BoEMoYzKr2JGqdl5TmkWnA2egSvdSjMXHYSOg4WqYEhtar9mtWlWQV1tZ1YxKhrCCIdUvRWzAdi5ci9bhSqoOEST7NamGgJSK6UW0IiqYdZjNaKqVC1odcVjbQGAjgHdOjQ3UKUiVJMGgx1oxRQJIVCLI8SggWqVXIwwaNtsyMATVIKfnyawDAJV3Da1AGqu9FN1SKxADS0LclQ+VnJ1qBVi9JzBUNFcHU5aU3wGZcCvJVdsCKfE3Cxy3SMKKSizqORqFMuAoKYUekTSyXw8U7fRHGw72xwRP2Wj3abIIHqV7Rg22VlUa4/q0LRtrWwbxJUR7rXUTGfrzZ7UlZ/upmpNiSnNFteaXamNwFzGnMGmHrRB2VnZfXuCnK3ku0vexZkkaDFPHKZE2ovEGJn5iTixWSnwfC7kZzN9n7nV9yxX/fm5cPCA+X93lzeZWrYbnIA7I+xZ7SCnu3d9oq0d+Pdms/jeap3ZFcP5OHV+zj9d/urF4qSIcXluH579/F1Kwp39Lh7kTdzV2bvY9QzyO2dLBdu/hyzoV4Pyb3lyPJ5z4Mt2MgdYuWg/nHwbZ8Df+8K/R2Hb+YCvuV8nv0llrb0Vxd4FBQYXLafpgZt7isDAnsJ5estN2JPvq4s0th7FWJrm/zT/L+r8f+r9ZRd7bF2IsTTVVFNNNdVUU0011VRTvW0qSrN/PLESMIIHxZqyrprjg4N55PDSnL39ji6EraXlGRcc0jLlwiwyn0U4MMz2WG8qR0crbt1Zsek9826IVRMZcJ64espO5QU2S0ZXCg62oc061AyV2hRYbtFotYywUESJTe1YrFlMxthgnNts+ntxO1EoVLIDqQYzs1WHLbW6Yq/BltAsLatsj1d27Bdr6w9RabltjPaatakBhzBEBVTVLT/bWxUVt8MUB3WSwSjOOa2pHmtFNXqeH+q2k+0c9puNQzYR7yO2NqTWwFSUwcIVXFBoLbvQwa6K0JdCCpEoQl8yfSkE0aZGtJ08PFepRVG3A62MGXU5e45gXwuqAZXgSks1ap9RdSVpCkJoALdapVQjqxJCIFRXZxoOYrPVEVyKujKwWINlzZHWCvS1kkIgBlcx1tpjhGYLmxEJ7dq52Z+2fEbv4dZv0lSJyDj2h+EvaLNMHaj6jvVro4But9u2qdv8SmmKTWl2nyqKWHUlqjZgKtv9YnVrn7udIP7fnTE3qHFHJeNAZOFuJd/w83mZeIvE4bN7HM4dBgcYMzXPqhAghMBsFoAZV4Hn14XjwxW3bh2ddNU8y2b0fnXXsZ6GKQPYmbcm5w/0wbgFbw8O/x6ly+Zd1pnn9Mdy9/nzjmF5OpHvTRzL0NTypKBwedbx3Of8LU+pKncZ9CtDfy+AVTtbq+2pvAXM5zBf7eg1l3fjw7P6YTn2YwOinAf+To+n0wq+03mU3ON3zni+v8d4PWPbN5Od+YDP2eNWFT3tRcnHrfh4TI1eCPh1al/2lM7TI3vZ2zX/600e/4Ns/kTn/9P4DHiS89+eYFNPKcPQpvn/LTX/p5pqqqmmmmqqqaaaaqp3TsVdlV0RmiJvyDlze81cKvv7HVev7HNpb4aqjOq+Wpv94Mn0wJMXIWOOmbc5nwX25pe4enWfW7dWXLu5Yr32vLcB/9kOQRsjBc3Vc8gAWmoDbrKFP7gOr/E7nLAEB4INVtZaPDNQoGbX7ImBqP8bpGJWMCvoLmi0pgoUZYCWvi1kgQCkIEhWV6aJ71tb94iCmqu2kjSrRlW0VsQMTZEgSq21AUzXcsUUkCCej2duK5nUA/wKrgbzlRyl5opGJWoDd9VhUz+oztTtLaWpG1UcFA19GEQajPTsvRDD9sLWKl0MVBH6XCi5tD5vNqwCqHrf6xYx0saV1cJmU9q48EZDxG1Ite7kAIJYpi+KtfX06F1OLoWcM6VZiTYhpGM1g5JLy2McxoKPv8Fu1Aw2uRLMCCGgWsilQoOA45s1c0vQ9rYqWzvcwi7oZMz9qw3o+va1qTaF4fTIkH/Z2rGWlTjkahqujgRGm9QhEpET9qIngf2Ax31kGWba9kFTIjZr39rAupWzlwdO+2Lu/LxYJJ59fo+D2YwQXNkH94Z/59VsFtjfP+Dq1QMOn11z641jlsuzQMgOADnrGM/6nR34M1Kh+YlNnadswaAnxZ2u5XnNn1sn7Ucfvs7N6lssRhHc1k/Tfz7BS5enMv/OOpcPcAxn5veN42D78z3dWs/poPOEn7v7PWnfuWhnaVur1fKuRhbL+7/V3XGx2IWAY6edtgTtd/49nQ/4JmoJLPo3OTAeQY0nrH/4RcInDQqe1gqmPcFDsCf48ifUl/atkpP2ds9He0Cl3IWe/0/jM2Ca/99S8/9Nv/V3yPyfaqqppppqqqmmmmqqqd45FUcoRiWYjvlrilKrEYPy7DOXuHJ5z4FENWrdNiAiD7Qj2QGEA0wThCuX97h0MOfa9Ttcv7miWoMj1aihEnZfKQP8qJ69JkP2WgOFaoTWfj3nal6ozXKyqbMsO6cTg1obZylYKVQro6ptVFaJUU2aGquOVqUmDug8yw9XvKmrvZSmUKxGrbWpw5wFibpCKojQzRMEQap4dmFtgXYCGoVahdxn1IQQA6UUAuoqOyuIGKUUjEqU4Pl7LSMu1+oqQlEQqFrG9zUc3wBJh/4WVWqpqGpTAQYMI/ctS3Gwx7RC0MBArLzV4K9pIKvUSil+3lQDZt5ubWOuDpanjZTWUjApiLn9ZV88RzAGtxbNfSaXZlVaalNkCiF4ViB1yN9jK1EVtyEt5pmG1EoIQgRyLU3J12xLKQQLft7a2VccookMAM+a2nO7Hxs2tjBmag6ZkujWrrahOHQYXzpOlDEXc7AX3S6sbO11BwhudbCfbe3WptgdIb5vbGNGpY3v8a75cRbBWsD7Dy9z9epsfKiUt/7BM7Rx9WDG4XzG/PAOr/zO0cljOA1LFnA/AHOSlazO2WbFckRqq0EQdrIjHgAoPaoadj1fLJw/vXzGoc+bE+aqAbH5zs/Du10sRxB21w6Wd/fPA723MzIiT+f9nd7kPMHa8h7Nn6ckXJxIc2yKwPkCVssTCsAz3uq5fT3C4dZZi8XijNeclw+4qwJ8APXe7s/36pQ3kXl51/nhQTs/3bUKeJHVMA/c3FOEBfaE9/fYT8OTykqzp99vFyn764nD8LfJ/H+gJqf5P83/h3wvFykfcbL0nGqqqaaaaqqppppqqqkeZ8XRQhOHY2YBUEqpHOzPeG5xmdksjODvQYHfg1Y1UBUW7zrkYH/GN5Y32fSVEHS0oLRmm2liIwIZMs8GfZYKJIFsUCjttdJsOhWo1BowUbTBFrOKiCHi2XvUgtXsujup1DLYczbllTrgc8hl275oKjjMyE0qJmHEaG6rWZulY9iBOQpRhZAiUdRPRHbVnSvkKrUaVoy+N8+5U1d0lT477KIp4DRiFAji8MyM2leHciJ0qlhTbqKCWnCpXVMZtgg7BCWov7eSCxIc7JVGbKzZSIamEsylEII2pZuMtpRBFG02m33fu0IzKIq/z8GyVXBrzyEzUK1Sq+9LAWuKvlxAS6Gq0HWJ2VxJJqyOe8zMLV2z5yeKBjp1tWZG0KaSzKUSg7ScPBqFUqIGTIxiBas9Jopoy70cEh1FWyblTr5ly/AbrtClzaJhbIwaSPPMR90J2hwA+Cjva4xZmkrPdkCsmYzwbhhTAwiUNh4GwDfs90QDnDhMTvjTnq5dmLJIvPTSIV0XHgn0O69CgOeuHnD5u+d885tv7CiyhgN5sHa28Ge187r5XW9tawPaIOCoalueGYH4MPUwr9lm+u0Yk64gzf3Q+hXbd7NaMt/piNWKHVXg8Fa2ysDxYBY7+zr1xs6DgWcqEZfnHPsZJ2BxaofL5fLc/Z3Bm08ysRNvxaHffLEgzRck4FZTA56nLDzLYXZx+oHd/S5Xd40br9P2n7uqwN3nz6r+/IFyFkXlzQyiM9744j4dwsMvyF40C7i31MwTXFS1J7y/B31/9nY6f09BXXSRxvvjGNvT/J/m/9vq/Nk0/y/a2J5qqqmmmmqqqaaaaqqp3h4VDXdrNNQtDFte27OX91g8d3lU/cH5zOCt1NBkrZX9vcTLL13l1W/e5Pg4E1S3Vova1EtN/cdw3O15VcjVlX/arC0HsaDvRylNaWalwSUz1CpGplh1K06MapVaHa4ZLiesGGraFIqGNGtQGXdkGOptqriVZvW8QHA7xqCuqgNXqoWonvVnrhjUZml6tF65g2ZrurQAPTOIMfr78YA/wgDL1MFaCorVMFrx5L7HajP5lMEG08CUoE0th6vg+lqxIMSW5yeqUCs5F7RZaLq2bzS5RKI4JFSl5B5DCCG0HLtKqRkwtFmJ1uJQt9ZmNDpYnqrDxVJre20bF6WOo8QqFBPWm55qyqxLHOx3HK02rDbW8hSbnSfmqlZRTILnAVbDChCqqwyxppirpKhoNfqcwSLUQNUdi88GbXcVgdKUhNtovsFPdUSqbdIMuG57VS4NzBpnmec2O1cMrXbXZNnd3s/loBTVnfb9+GRUKg62ooZZxs7Z81Avv5x47rmrAI8V/u3W/izw0kvPArfcEvRBVFE7jpj3cgqFUxaTcML68zSkehzKv8WpX+bnEJ9bpy0u2wGvWDKft9c0gdp8Ryk4H/+z8Ofba+55IKfUfHf/wrnw7y6r0F0L0lNbLU6pB8+re0VCDr+vWphfmi84nC+4tbjbW3R5n/ZHpeL2P6fUgWe9+qzsv/PAX3/vbe8LuB/A/vasN3X6HJ4mqouTx/GWLNvsKa092lN6+bdyXtqTPJf2hF5qT6DL3uYKxrds2WhPadjaU5jC9oTf0jT/p/n/gPuYeN9UU0011VRTTTXVVFNNdb+KgwBpsCbMFRbP7PHcs5eo9uQyHUSEUo2okZdfeIavvnaD41srV5G1HDNFduwThxeCBv+3Ng9EGYGcuWKtAZpqNODnREepiFSUBvSoDf6Jqw0bvDGpBIGwY1U5qP7cNvJk1p3DIlcXBg2oBoLgCjh1QKZBqblQS3EBWMveUwRVJWkgzSICbDYbYghuyQkEDQR1u86SM1oLVYQaosM+rRhKioGaAptcHPTl4qCwwUlE0eoArlbP/wtjVqGr+0ouxAb+illT+Nl40RmCqxfdItM9NlWbvSqKVCFqBFFKLa6Oa9AyxOiZgNXVjWKCaMAaQKXlTPpA1Qb3XO2Ws2EUYheYzWaIBkqfydmzBGvLPqxaCdIGSGjAjDAafWKeA9nXStRAFyGX7GAvC6ahgW9r8M9GGNskkzuQ0E4MzCGGUqT6mDihGLUxB3EY/z5sXOmKFX9MZMwfHPvdbHyNg2kYZa3j8W2PzWQ4Hh+/gdhyG8+ul9+/zwtXDyhP+MOo4Ha4733vVZhfZ/lKf39V1H2eX571wGJ16qXLJwP+2g9zFjvyvUGzuKMCbD+nQ3+kn68cIY38aU5K7feESwUT9Luuk3NICVK/8IdGOd2pJMSd8LwTKsHFSavPe763xVm/t32NuYGLu+jf4tRDpwEpy/NP84qmgpzD4XxH+XhOzuDyXufllB0owHI5qEjn9zm7D6ICfIjcv/EU9Q80vu85DxZnPLcEFttjtqe0yPxEFyztsW7+GBt5iCafgrrILtj5u0hw56nlWj5kht00/98e8/8i2p9eNNA7zX+ebIblVFNNNdVUU0011VRTTfW2qnjiorxW3nXlgMWzh67EehySv3uUNHtJgJcWV3i1VO6scsua88sZhxkVMwceITrayNkQKa5OM6hou/pplp8V1Ipn3TEopgoDqFOD0sBRdaqHiiAqFFN0sF1sAMyamk4baKzteKxBIBUhqBKjA0CqQ6DB9jHnQimltSqEprATYKae6xfEAdssNt9Q3V7QqXiSW4mApQZwK8UEq4GgQgxKrpUUI7kUaswjQC2lsaoQqKU2CNiOpinxqBCjqwmzbTPwEEMasFNxYKkKSnBX0dDMLmvdyUG01uvefgqDHWtxVePAxqqMQFQ1oepKwTrkJ1a3qo1UpBj92rMEU0p+3mvvdrEItSk2S4PC4pJNTPw4VGng1xWPuRZiiMRolGoN5GZEIpWwVc2NGZZbKN2OfruiZtYUtQNE3tXbDWRddl5mY17iCPxaP0iz96T13S4Cl93QRnYyB8XG9yUn5hj3lPK+/PI+zz0F+He63vvcVVhdv4cScFu71p8DRluewGm0x1ZnAJ3Hm/K3OHXsu/BvddqUtB3aYXs0ATHBXprf7TgJnl2Z/IWx/U5akYHInJj8sT0gpxV9vz2YfswSHNSC20y9XWvR0wKyu8Rxi53XjBvvQMbF3f18JjS8b+ctT8LCBu1Wq9Z/Yybi3TB3ef+Bc9cb2+7apZa+2e5JOG0JOvzcv8UB85gn1uIhFgif4uqhPa39v00tEO0J7++hmn/KSqaLpGK6KAome9Bd2DT/L/J4mub/g70vm+b/xZhfU0011VRTTTXVVFNNNdVTq+YnCaVWDg9mPLe41Gw15akemIrwwruv8tVX32CzySCBJvBDxZVoqurpfrUgVFd1iWvPRAJG8Tw6g0px605xDGUth03NKGpIEKy6KmrYj6kRRRy0sbV6NHOgg7X2BrvOBgPdkzSggWYH2nIMxYGZq/4cgqkqog6nVJQYlBQCcWBDzepzsJKspTTLU3VLURRMkeCU1BWMLgjTqOS1q9l6BAvRIWepBBxYOmwKqEBuSrFBZRdjcBBo5sffDqMYRJQuOhbV4Pl9KIQG1AhCzZ7NWBuAU4Vojs0wQxRSSljJUFvuopmDRdejusLSKiEEYtfR5+yWtCbU4taqiiC1EkOgpkLus+cIymDPSjvnrsYLNqToubJRxEgNUfYloyEQ1KAMVqS1AbvQIJ2OqkCRRmWltmEgmJX28xYK22jJqSeu7WUH/mHb8+zWvNt8RtkN8WuQsTbe2Hp0VJC2dMKmFGw7RhyaN7vQYZvdWryceO65gwvz4fTSe68Cr53MBBwUfMv5KevPwc5zdQL+bWv7/InaCYZbPmIWOBzyANR2c/78cYeBJxBS2sI7gDBApT2ARMkOmEJMBKBrn+IhAhkKyZWU+GObAUj1c2KDg/ScjLibOxCc73pGDsq9M+w/xy7bVTSydR/dvuntGfGTtRyEdlvr1lP7GE/14MW52N321EnaGRdDH652rEjvd17OtM4888FdNHoGiWXo1OFI7gUBHwYSPgKgeLpOE9xHCbyedKbWU9r3vfZ7Ee0P7Qnv7y039wSz/i7K+Xpq58geYZPT/J/m/1tt7gnDwnf8/J9qqqmmmmqqqaaaaqqp3jEVPSevMusi737uygNbAmnLkrO34CGkqmNGmds77l7PGFGV55895KvfuLHNAhQHTDKozob8vNEk1M0oS3WgJhSqGcXMFX21YmKEalSpDvyKjZaf1sCSyPZ9lQZoXPXVbEhrdWBVHcS46s9z80wU1NVzQ35garl4iBAUgsvPMNzeUqMDo5kGJADmx+8WpwEVgVIpLUsvxYRGIyCYqFuZqlIJlE2mVvFtKuQ+E5JieOafBcAqhUoukIthIUKpbktq5uCxqcdEhtw/7wdtUDLF6GpJAY2BoH4uWjwiJhCCQFUXMAZFzdMDq/mG1tR6mOfxEUBFsWptG4evsUIM6lmKMTKo2wzQJMSUKLmSiK4WLM0GtKk1tcE624r4qNXfn2o7BtnCTzdkrVQbMJnv28ZtBp2eNaVebUAtIhrcDnRQBDZ4V9Xa9icBu5k14OkQD21tDs6yp2B8HfbbMgmt2X5K69sWqIjj3YKHGW7v+T9rzi4W8NKzVx947oYQKG8xHDCEsJ1jZ7TVAc8/f5klN0+AOtjCv93yTU7Cv0WDN3cp13ZsH8/MwXsUdSKub7v3dIpPDvaeA/gLJz6hHQKOgK+RwRATIfQk0mjlGjs/4/2mpwBdSDCHsurZT1CaUpAE8x4yDgT73o+pH7ID4Z4KvUHBdyLDcH43rhqg53w8C9wzZPHMvl+eyuo7SyE3905NrGDVbE0f5kQuz3mjZw4cuD+UG3riLIDXP+A+HmQ/9zjue7b/aDIAL2qe1oVVNb0TFI1PejzZE+o2ezrn63Grzab5P83/af6/c+f/VFNNNdVUU0011VRTTfXOqYgUTAKLd10iRnV11T1KVck5c+vWLWKM7O3tvakd11q5desWtVZSSuzv75+xjTHf67h6ZZ/Xr90iqttGGg6JRCpWCiqVimIS3Oaz5dtZLaDVtV4qiBWKZagOE61BByvFNVEqqBimDZKYUAZVVTVQV/6pQdXgAGuESxA0ElQp5uq7FAOlZESUkILn+wmEoA70cNCYJBKSNuFg8PYKlOYDGYOMGY2xQZMwqBmrkWIDivjrqyirPtNFIcVIWUOfCxqDA89cKNJhVqi1sNoU0EjOmQ1Qit8aazoo2IZMRRBVYrM/FXXFYt70gKExUTeu7EOExmpdIegHRw0VzFVzm1waeIMiBVFp8K+MKkaHspAxqIVaK6KuXzQq0QSKeLtipG7mAAwom9IgXnUg1pSMFYVqFCvEAfy1fMCuZSRmM4I6iC7GCGvNoqv4xJGzWR1tXG2AbqoNABaHw9YsUa3ZhY6Kv9anLafSzMeWWcuRbIBa2hiswx3Lo11qU8NCk3IONrUNNLZ9NxfSBv6afa55zuWgpnv2+ct0nVvD3qtCCGw2G+7cuUOMkdls9qbmfymFO3fu0Pc9KSUODu5WHhZgNpvx/sN9fmf5Bpxh6zko+5zhzN3ms6kDWa7GDUfu1BRkW5XZo4N+p60xHXwtmbMYod8u7BuOPzIn7Lmiz4EfTc3n1cXx03qEgyH0PqdKT+wSqT2hITID1qUndf5zAdbZFYFlaHsOJTugOmLlAK1f0eORgqMN6FlUdFflB1to2No4UfPdf04CxtWphu+Kqjv9+/IcVrYAkjecDufQL1gslucqAZdn7XNxzlaLXVPREzrOVmcBvnTOcw8ycB6i7o50fOj2H2gt8EnYnT3BBcuLqGq8EIqmJ53RZm+/cWQXYMzY2+T9TPN/mv/fSvPfLsiYsac5Rqaaaqqppppqqqmmmmqqt23FvhjPHHZc2p9Ryvm5f9pg0O3bt0kp8dM//dPcvn2bn/u5n2Nvb++hlIC1VmazGZ/+9KfZ39/nK1/5Cr/0S79E13Un2xHPnHv2yj537qxY972rhlqO20kfRRyCjCl37RrJmgCKitmQ+ee5cNTCoBZ0/V0zcVRXlw0qNRly48yaqaM4ZAREjaCeg2cIpRohCl10yDXvIjEEt40Eggqp9SXiqjZRJURFa7P8rE0FFoUQPAtQq0EKSK00kSPBhCLNWtRcaailuhIvKtRKEnH1nzTLUFWK+vvJVag1UMuGCsRZJAgcbxxi1WYVadVc1Wi1sSQhxdCUav7+XQpZ6ZIrwxRgHsjZcGZpVBO6mDznzkDWvYNVoBSHYyW76k4bkCu1+nkxKBJQTeSa0cbQisKmFOLayNktX2OKpJjcuTODUlsmoLkdbK1AbYo+pbeKZn9fRRoEVIe+gUq1DFXdclNBiEMipCvwGrATE9/TYFHahqNr9Dx/0LfzJ7aWobWN2Na7ho9VaeAPVzNKszSVU4sBQwygyWj+6bmJ7Zh2ownFdLQmBWAJL7+cOJjN7gn/BrXezZs3mc/n/PRP/zS3bt3i537u5x4aApZS2Nvb44/+0T86zv+///f//glF4G5dvXrAYnHEcrnN8LsX79gFNWdt96iVfmcBqUEddzhfkHYcI3ftPQG6OIem8Dv97kOEEBLRPYh9g9KgUnDMVBts0uIff0omBuhJUDIR0C5R3aGXWYASmlIw9JSSmCVvPu7NiR4IuAMBz1bdDe/vtMYtpTl9vyIB6dDVhbs8LB2OP8KtLZ1dcbcac/f8LU/9vNv3K4BbrY2VH9sAX+9Xo/hvefLcrXa2WDRovGThwPwuCHiW4u8e9p1n0s3dtrj7tfce8Oc/d+br0om/j49ndfIprZE+LUXTY3pTFwE4nbmrJ734bE/4bdsTOu1PGeJN83+a/9P8f4rj2J7Q4U6wcKqppppqqqmmmmqqqd7xFZNGnrmyf1JatFMD+Ds6OqLve77ne76HP/tn/yyf/OQn+e/+u//OFVnNHvNBSlW5efMmn/rUp/j3/r1/jxgjf/tv/23+5//5f2Y2m93djrgq7OqVA1597YaryqhIqG7xaNKyz4Bm9znm2FERcXtFq8VXO1zGBXWwDDXHXOaKKmsqqiCVoAGz2qwmGyA0g6AkPM8vBMeGxSpRPDcvxkiMDnNmKRIDhAEvCsRmcxlCQBsoVIQa/FgliC/Iq5FUCCZoxMlR2Mn8w4hDxF3xDER/WOgMeiv0xmjV2q9Bglt/WgFQalO2lVKoVRENdDHRq1Gq90lp2wzU1YWHRkSJqphCqZ4tGLtICg4PgypdqJRaKeZ2rKKQNLiFagoOTFUp2VpWYEaq+LktxcefNQhIbfmA0gxft1ajCEhUSi7Ude+Kz0Gp2FR11pR8Dc25xWoDcdWMIEYpwtqEmNq5KZ5BmGslUCjVLThFAjIeANSB7LXffZgNsM52hzODYS3D3gcebK5qHKCoj01/v4jvw7exlnPphrQy+H+ajTazA3gcght1aFs829IViQrMuXz58Nz5OkC5o6Mjcs589KMfPTH/c87s7+8/sB1oCIHr16/zoz/6oyfm/9/9u3+Xy5cvn9lOIPDss5dPxL+dnfe32qFDq53tWj3ikL8zGU4DSIPiby+dBH6wVfS5jSdQ3Oaz0I8QsEQIwT8rEqCBFuzntE5Da6QbXpBRhlDXyB6ZTenJNNVfgZyhxoaW8vAXoP3bt4cGK82xG3eTEwed5ckaLU17VxLu7W+3cOdSf3Wfhj86c2IPzLf7SQ06rhZng8D79f/2keUW/C3ucnk98/W7cJHlcAyLUbU4WIouxiG0BdFj55357wMe+Gl7zrMsSRcP1AEPvY09zYXBJ72o+yZ3dhFt2Owp7fdNNfmkAcVThhMXAW496KbT/H9K02aa/9P8fzuN16mmmmqqqaaaaqqppprqbV/x8uGc2awbQd5uiQi3b99GRPjwhz/MH//jf5wf/dEfpes6rl+/zmq1OlcxeFaJCDlnnnnmGX78x3+ca9eu0XUdd+7cuWc71SqXLs04uBW5s+pJQRBza8aCIqYYFaXHZV2uhnJuUrHSFF9mjQG6cg1xeOg5euZwpGWkqRkSQJvVp1MmB2bibwZt/zcBJTJLSlAlBHUFoEa6qEQVh2LmdqMxqFt+tkRBE++bDm9LVOhQTCrBDA3ilp/BgOBHrE4ORlgUPaWv1oKpEGOEkunNoLq1KYGWVagNLVWHfMmBZSmZdTY0RpIVZF3ohVGFpkMeXgxbVqxCCok0ANaaIUaHg0CYJweMm0I/5ANaIYVACErfF4eAswAoZoFSK8fHPbkB2yFdT5qFZVQnfsUqZtCvM0Slm3cEDfSbjSsHRQgqVPP8PpFAqQVyBcxVnMaYaehKPLcU7Q26qGhQQidQCrmvaAULbqtZq7fpVpuDnadnY4oMMA63hB3O9QDam7q1DSUH20PuYoN22BZWDsGFg8ZPRgy4s+jRAKfbgdqJ5QDb2WQ8j8DLL+8zm4Vz597NmzeJMfJd3/VdZ87/GONDfeBsNhve9a538Sf/5J88Mf/v1U6hcHAwY7FgRwW4OtuZsgGP5c7P/suO9SePUAW4YzF6EvwBTe3XxZ0MP3o6EqGJJhVG6V9sqrEQtiowxeFfHLeLDQaODXqFiOKi5hogNrK38Q5EB8tQXAVY274zQEwOHHPPundABytX77Wan+i1HaqU5k1PNsA8V8jFdrhhL1FIlNwTB3vQfkVMcw7TnFW/auK5OSmt2GdB38OtM3L8Fqf+3ar3lqwWMJ97SORqtTz7NLXDX55+/c5222jIpQdjDlsslo3+DeGTqxM986ZqeWowLs44oIdt74xT9JbWGC/CSqI95UOxp7jQ+rQWfb9FAMVFgRNPHEy8BShh0/x/oM67SDaZ0/x/k01O83+qqaaaaqqppppqqqmmeodUvHI4x/PC7oZ/6/WaH/7hH+bHfuzH+OhHP8q73/1uXnvtNV577TVeeumlh1L+gav/rl+/zk/91E/xnd/5nVy/fp39/f37QkQX3SmHl+asVmsHOSZNwTeAm0xzO2zspLpCq1pTi3lem2f7GZVKNVdxmTpQNBzsSIMztUiLVnMAh0rLE/TF7UFlloLQdYl5A0bgtp0hBmJQYlSgoBlQX9AfstqCtv2pERDPr2vWj+C/htB+V/E8QRVyLRgtTxCooogVogZUoDfBgtBveqDSiUDnZpgYWPQcPDaGRsEU+r4jJcgls95UiggaG8GyplQzh2ohBMwKVgsmkKKABJKIqxNzpTa7TRUhhUinAROjLxWNSidCADaljhmGqOc1qijHqw0lF8SC27E2G0xpkDdpwETIpbLeZGquxBSaxaiRS9mxzbSWeehZgWaGVD+XSrMbNe9LxGHmpq9oEWIXUQ2IFqgVtQwSEXwcSovZq01dKoMSsKnz2hlq0X/e75VBqXpKKdhkotIIjTFYeTYw6KOCweYToA6KRvdN3RHySmOCw77Ej21nOeDy5fMBxnq95kd+5EfuOf9zzg88/wf135/5M3/mxPwfVMb3fC1w+Oy+A0A4qfxrqqzl4jzR1N1A6K3Cv939zIE0X7C3m+2XXOHX0VjdzvsYftfSlH0AoSe5cSaEQRSaGgCMIyhU9azRvmaoEEJEtbkf10xqr80husPxJhPoURJ0jDg5DHaiHv8JAVYx0c1hk2kiNvcBPRnrt4WcwKj6i+3BGUBMkPvGJvv2nhMdCWLPpuURhoYOc3vJANPme0Ba0LPFvIvTvp87fG7ZJHyLXbvSc8L/lvc4j6e52Wq53LEEdQi4WC4ZBtryzcK/ewG68yDeg0C9BwGIi7v/tr6dFlLvu9unvdJpFwtUfEtmeb3Fxi4CnHjaYNKm+T/N/2n+v+Pn/1RTTTXVVFNNNdVUU031zqmYunTmIsCwuP9jP/ZjfPrTn+batWt89rOf5Wd/9mf5U3/qT/H+97//oeCfiHB8fMwHP/hBfuInfoLr169z48YNnnnmmQd4rQOdg/0518NNSi2YNepCdWtJl/217StBittMtssdh38OAA0XzpgVgnk2nNhgG9p2KOp2ou6V2ZReLW9PIEX/Paiyt98xnyWSQWwqwWLFIWAQlEo1P+aoiqgg4vCOASZKGG0cq7kKUAlIgMEyUkVRiVjNiBWCBKIoFQgeAkcUB2PVHH7FLrLebDznUKqrv6TBIhVSrJ59Z5kYIhkh1jAq56QUTOqoJIzRAWUIjihlAGCiJA10MaDBkBRHEGXm2CGIutKxutit1kqISipuyVprRdTbv9QlEsJR31OzkTH6nKm5OIQMDlvTLLE63pCtUmslZ+8nzy2EasVBrpn/X2TM3hMqakoxo8r2wlhRFzNKs4btKwQhNmtTP5dDXiNIDU3FiSsBB5VfcwVVKlWaMA/BpOU4IkjrG4fWNmb8WTsSrLIrAmTU/EnDe5WAjqI/oVJRoMF52V7yD6+sUsclgPPUfyGEcf7/M//MP8Mbb7zBZz/7Wf7yX/7L/ORP/uRDz39wG9Hv+I7veOj5T5uvh/O5qwAHq8/RhrERqh1IshgfOFmPDPwttqq4/UOY783pcrPyjFByP8I+1+p6RlyICW2QLnQtv48dEIir+Hah31B+ViO1Zs8LBWKDf6pAjSR1G+BaISkkIutNTy6+/wG1uopwj4hbh+bSoyGRiYSQCcBR69u70uwSpJYQOLDNSIN8Q5ZhTNtjbyrFMAOlbROgFH9NaY2U3BOaX+phgny4gn4Bq8GJdHnKr9NVf4vFcuvuegYou985X576+UT+4I4l6Gkl4OIuC9p7NLyb8bfot4+dliEu7tPOw9S50HB7Nu1JZZA9wZXHi5abdebunuIK7FOzfXxaqhR7wkPBHuvmj7QBe9JKL7sQp3ya/9P8f3zH8Daa/1NNNdVUU0011VRTTTXVO6fiYIV590Wiq61u3rzJL/3SL/HX/tpf43/6n/4nrl27xmc+85k3tbOcM5/5zGf49m//dv7SX/pLvPDCC3z4wx9+YJAQYyTtzdjcOmqAqoBVz0prdp+hQlU/9opg1ZCSR8NEM7dIFPWEtcFeslTPSFOVUZsVxBfWRQKqijRw1kVFgqf6zeeJg72OLka0Qp97hJbdp4LljEQlakS6Bt7E3D60XbzpTv97Fp2Q1EFjDW5RWofst1qwClGVQHAYJgUzIyJUgRKErqiDHg3MZnvkCn1fqNXVfi02D9XgwAElipJrJWdFZzM0RHKfWfWZWBVKQWLniswIXezcWrPBsBjVFY0aOehiU0P6uQ3qfV9zU2Ei1Frpc6FXR2N9rhRzUKjB0M7BWtZMqhWVSMbhxrCQIRVmMVLzhiqCNGWoq/yKK+4MynCmy1bJaKJUG+w/rSkPW3qkuKWqth3VUokxoig5V4q5hagOVM0crYjVlkmog4snNhguiiswBUGq0Q6NAffJYOw5hEW2fhJtj9mg4GuvMZoK1rc1ATNtEHvA3I3CSIOVslUD3qtKKcQYuXnzJn/v7/29cf6//vrr/NRP/dQjmf8vvvgiH/7wh12V+QAVQoD5Ibxyyx9Yru7eaAd6LFk8sty/k+DPf0tAOoSDvUOHWhE2p8AfuUdjQkNqkC9B6Am7MG5nP7W4w67nhkJJEGoDt7SfS8sH1Di+vtZMaL8bgaQFiDCD2eyQHrfKrTtDYlAXDsAxArlATyTMGpzLiaO0Y9+5o3CcxcMtn4zQtWPWkNr8bzalgMYINVP7Lc+uJbMuUENPBTYxUZo6sCMRgH1WDZ1Cv9rm8e3WnAULlidy/B60zlME3s3OdiBgA5HL0Qp0fub4uyd8223uHmN4bGfJ2arA3efvAor3OLaz1g6fpMLhCS9q2gU4hjfV9NMEpk8TkjyNRW17+hl09jT3N83/af5P8/8dNf+nmmqqqaaaaqqppppqqndOxfM4gJkxn8/5T/6T/4Tr169z69YtLl26xOHh4UMrfwbrv09/+tN8+tOf5jd+4zf4q3/1r/IzP/MzD6kihP2u446sALe8dDNF/xkq1vLhsGa+aGsKBbMhTU1QGZSB4raSNqbMMWjDwAFN0OAQqe0/BFfuhQApBC7vd2hUtFmLShACRhcTfa5EdXDpbQzAstlcjp1vVKsO4UIkqqAYom6Rqc2itWCouG0o4iAvqkBxi8kQx6Q5QhRXhlXP/EsBZiFgBbLCJhtC8cw8KlGUIAkT6FNl0xckwLyDvRJYbyp9nzHRpkeEpMpsv8Oqqy4jEGNgPp8xi54cOGTbabNjzbEp6BBqCd5fuTaFohB7V+ppCBhuKSgY640xC0oMSr/JlOogzaohQYlJOF71WIgEK6j6+y+Nd7U4QVRdI2fmr6/axgTi51qr/9wApVvKCmIOxYKqWy6ak5ihv6H6vwLDWQPPojRTVFztt80CkVEZOapPpVmECg0UblckznTJbfDV1aG1qWIr0rxDbYCbPqF9tBkNkt5/RWA2m/FX/spf4fr169y5c4eDg4M3Pf9v3rzJH/kjf+TE/P8Lf+EvPFRbIcBhSo1xuALtdC13FID3coN80DqLzwxulSnB5b3DHdjnCsBAzywm1g1maUhuuUlPKX2DZHeDPw34/G8gjQGo+fQGQMkOEhWq4jcB1EIi0j6msFDGEejtBgIwnzkSLkBfQcioRioQyQSdUWfQ18JmBVoy2iX2ChyvPcevtPcH0EXo9vbcRrQpCVMXmc9mzFJTLFZ/o/4eAn0q1JKBSK0R7TO5+HF69Q4BcSA4ByIrjnua9WiDgEMNjGsn32/xVs71roL0roGzmwG4ZDFaga6243ExjM171PKc3+8FDs977LwcweU5x7EEFmnn7/yTW0S8CGqLx3I8dgGaeJrwxp7iaX0akOZpqNge0z6f1Py/aHN/mv/T/J/m/1RTTTXVVFNNNdVUU031Tqp4LyWQiPDaa6+RUuLq1avUWtlsNg+1A1Xl+PiYb/u2b+Nf+Vf+FUSE/+w/+8/4xje+wXw+fygAYAbzWYeIUmtx9VkDKYIxrIxbLZhlRNxrUquSS6WZ5VHaTyJDdltwAdcAZBC02Vx6PpkRVIiqaIBZUuZdR4yBFCMGbDY9ihCj+KJ6ywDsYudKODNqFVCILedva/coaHX1YdSABkaY5Eo1h1khQBSBbGQrzfgRQixQIipKlICpv2+Hb019BlitlOhqvBQDVitYJY5KPUFTx55CrpnVqpCrUYvRzTJ9n8mlesbfqD0zuhSIIZCaymm/iw5KJdCFZkfZYFrOhT4LBchiGAE0UGol9Jk1zaYUV+NFIDWCl0slBlcG9dXGQVGqkWLHhsxms6GKEoKSUnQwKxWtSilb68tqTfXXsvVCDKg0JZ46WNRBtdjUsEN8nsaAlkK13FSlwfvDhCr+fmmv8dO4zcocka9sHT3txBhv+xpVen6ORHRUCfp6wBbh+dkdLHH9t0rBJIy/MSgD26t2DG/vWa+//johBC5fvkwp5aE/YEIIHB0d8Z73vId/9V/9V8f5/81vfpPZbPZQ878U2NsbTCdX52+4pOnBTmi2Hrp2gRBscUqaw3x/PlpewqD8S2O2XW3wbtbtuxKuZCqJEHoiWwAzsD0Hgg3+hTYbdfsxrQ2ihXY6C7lBvoJoRvFMSg2B2sIFtUJQl/wFdvL/FDoCpXZAIe3ajMaOfYW8VzheF3Iu1DIndplcEqUAwY/f959JXSSGSBdnKDDfC4RmRdqF1ngbOiUXNtnfX9+UjV2I5AK6yaxhVEqG4n1a2vnOvUPXxOJkLuFqUGUuh9Pv52/ICtwOi4cfAMt7PDFagzb4t5w/OH1cnPPzOeP5gdo9sc0Z6r+xHq0F6JtdJL0oFpBP7HjssWz6WBu9CLld9hT3/ZZebk+h2x7WfnCa/9P8n+b/O3b+TzXVVFNNNdVUU0011VTvnIr326DrOsyMUjxT7qEvXtoKw7/+r//rfOhDH+K//W//W37+53+ew8PDNwEUjJgiQQO5uuJKrDYvSG1ZgRmqoeKyEtOAxoTVloM3KLXMdV8IiBRoGXuem2ZNiaOekxccmKlCp5FZCsSoKEJxKQ0qRgwwS6ElEipJG3CqtS3gKxIawBmOxQQJisaIqmfXudVjwsxVNcEU1UqQACJo9CwwbcqzKBHrHMepe4qC+GsgtPco1KpY74u/MwULQi5htEMN6sShB/a6GUFcrWPAOgf6FMklN3jm22twa9BOI7OozDolpUCMgbiTR5Z78+xE7UhBWfc9ASMCGzM0e+Zhl4JDx1yoUQlZSFXoonBztaYvhdk80TW71VKl9RnsHexhR8eu54sNmKkSTTzPD88ZVKCKnwOzITOwUlUIDeANQ71KA7RNRRiaLWeIivUFrBA0U80Ri2CYNIJjA8KzUe1lVKromMc3hPeZDZl+DfoBQ+pbbWO7Ydxx0W78d2jLxlZRaQpD2+pMEQeRZg++UhAawHkz8G/3dX/uz/25u+b/g1p/nvjAitGz/86y/zwD2LxZRdgu/JuzaOoz2EswS/Nttl9u/QSE2DMLqZ29RAwNtBRX7TmXc3g22mCyzftTDwv0U6Ut65MG/gb4FwKEQijbj+4UIlVDGy2uWh6yRWErNbQa3OMTzwesEUoenndoB27aOes6ghZqLj7/+8CmuiVwxWFsCoxws9PILEDXBbouEILP/+gCRTIFBbrQkSKsNqUpkKF3d1yUSEf7jClQg/dhjft0Ea43CLiXHAS2j7IRBr68WPDKcgt+T/zwZmWgdw2eU1agLJsBKbA4ZZP6IG0uzxi3i/sdwznv6UQb861t6D3mx0XJg3rqa5d2QY7lIvSLPdTDT2z/j/0Ynha0ehqAyqb5P83/Czj/7SnMv3fw/J9qqqmmmmqqqaaaaqqp3jl1XwBob2GFIITAtWvX+NN/+k/zoz/6o3zhC1/gr/yVv9JUdW/imsXcwlEDWDawgjtHejaaVWuWiBmsuuKtGqLqkM1cGaUmoEZo+inB8/LMABVC8AXpIQMuqTILShCh6xIxCEndZrOYL7TH1IEaIsGBn5jDJBVUWgpckxxaU69pEEQDVqUdhaFRmmKsgBkxOeoTGeCeg8cwKNT8VYSgYAXLrlbUph6s1fw9q6uDEgHRgAZBRQkJCoYVP4YuBWYhUM1ICpuNURG6JGxKJtdEKZVghYKi2hb61ehUiF2k65QgwRVMtS38J/X8v+o2milGYvWMwlALNQpWC7lCyUZuCsW1FEoxVBJXgnB7tWLTu01npwG6xHrTs9pkuhiYdR2bvoAJuXp+Xgqtf8WPXRS6TtlsCiYZRT0WsLqFq6qrMymu/hucOFU8Y1EBKnQxUaxSSu/YTgJizeqzBfwNSG8Yv4Osa8jeNFyBKG2euWVoU/rJoBqsKGGH9AlIcYDN1vJzx1G2ZQGWpgIdOaO3N0YAymP9cAkh8Prrr/OZz3xmnP//8X/8H7+lz5YQwvnCrOVdP5zx28PVHFf87TXRnsO/REdPig7LAxAb2PMJ1fvnRntMw1bl1xw7x8fHDL72WSPJQVj1+wqI0fV7IRS00ISeDe3pTjbgSNocqmnbplYo1a1+JQYS+PyPkAjkCIUCtX3WpcBMAxWoATY4k4xdYJYLedZR+kKgUAhICETtSFqIGkizQOoCUVIbXd4XXQwO9UtpOapNcK2BVesQS9AXP+a++o5Xm0G3nbh6mLi9ukXu/Q9XpJ0cVtxaweHcVX9D7ONyuQNyF6dsPU/FQ97N2O6vG52zaDrUHQh4L/h32qLzQWw9zxvji/u0vYR7qwDv/tt6keoh7lF4MsdjU79cqGOwd+C+7cQ/F7/db5H5Px3LNP9Pd4B9K83/qaaaaqqppppqqqmmmuodUfFxNTzkfv3gD/4gn/nMZ9hsNvzsz/4sr7zyCleuXOHo6OhNXP+4PWIKSo/7x8kQbGaNjpggLeNtUETVWlHRpuISVzI2QOaarAYkBaIGglh7vdFFJQW37EwpEmMgCBCVYkIQI0ZGtZfViogQRNAgVHO7SR0kXOZWkg4ZfaF9MHUMAiH44n/JG0IMrngqLaNPvQ2rnieo6qq/2pR0FfEMxKZk1JZjGDUhHovYoOGQVxhIAqEaJQj9prA2mHUQg7Ku0GcImkEDnUS6BL0Wt0jVwGZdCQHm3YykDhBiF4ju44dVwfrsGYwxUKxiVojJsws3mwKleB5iaBKoaIQi9CLMUPpgsPGna51R84ZqDiajCjEFYi6YGSlFNn2m5oyqkPsKRZpy1CFuFVf9SRIqAZOmaBxsWUcloDmkaKo5lda/Tb5VBVKM1Jpbxp5DuWKCk7cA5spH28rwHPbZjo3nDpgTpyKjclAANTBKU/NJUwxaG+dDu8PP2uxKbTznnpdZER2MIOWxL2IM8/8P/IE/cGL+f/WrX+Xy5cscHR29KUXxveutJMBta7eFxGI07BzgXwCIiZ5EokfdSdOr9Cie+aeNyQ35fv58HHP8NES2Br0O9IZMPuszIUVCCtAXh4CJNv9Dm/8OAwuF1M6sNfVfG32gkNRhvEHLvHTgRwp0+OdTBvKmUCvMZv45uC6wyW4jqgS6Bu76ZkcqGsgrzzmcdXskweFfF4kyLNQljB4zKDEglDb/gRJYb0r7kImuFh76Gj+meQebAmwSM3pKnHPcr/x4/TSQmDNfreh3rEB3hXWL3WGxOOM8n8rPm+9svLqHNG8FzOewWi12tlg5WFzM7x6Sp9WIyzMG3vIew/pE3t8O3Dvd3oIHUxbeYyH1ouUP2QM/+JSO5Qkfj73lDd7+x3Ch929vjzH4dpj/F2G+XYRzftGOY5r/b//5P9VUU0011VRTTTXVVFO9c+qxAEBV5ejoiJdffpl/+9/+t7l69Sr/+X/+n/MLv/ALXL58mdog2Zu56hFtOXgtRE3ayruJuGrGWsLfzt2SY2raIKoya9lt4jmBeD5dVLeuE3ElWBciKWlT4kRCUpQGv0RbTl/1/CpzO0xR6NTVdRWX8YRm+egyMlckqgi12CjE0iBIVErOHK82GLA360AjiYpifmxmaCdYDd6OSVNBOqASUfomo5EYiEFbFp1n5WkjEaJuPSrgcNSKKxqreU7Xqvfz1MwqOzGqVWo19johZyVJJM0rpjT451adgiK1YKUBK3NVH9Jy8URIQC9GiMqMGbkWNsWtWKMAUVALZIGIolKoGfbnfv7WfaE0Wdt+VCQF+uz9fTBLrHOmFj+vm1zoC6ToSkkFSnUloBr0ffbzlBJb2Z6fpyRCsYq7VbqVZ1aHuLVkIDiErtVVd2KYCFT1cdQy/nzM6/YKXWB3CgzCvgH+OeBjVPM5UHRo2FxIx8etYZMhJ3BQFVqzfx2sUNvsxEx29vfoazf376z5P9iCvll18Xye2GYAnpZELd/Sse9CoV3rzzjafvYOAQNQ+lHRp0M2XoDEVvVHOPUhGzJa3PKz7riqagI0UnPm+NhtNvdm0RW2ySGhq/wgdLT57wAwtJ+1+YjmjVNHiW7FO5z5UhnBPAqqoamcA50UYoRcofaFVd5QK2POYGzgsdbCvAv0GTo6unnx+S+QOuiGVNnC1mbZIGd/UNqYTPiNBCEG5szoa2FTAXLLJIyjPWhIsA5QNxBmfvibvO3XmIC5W4H2wMsLWO0Mg2X7z+lMx+HnQQl4FjoeYOCg9Nuq/vz3XfjHEpa77qAL7q34W9xjAC7vMZzPgntnvrf5vffFgykpLsqi90Ptzi7IcTzmY7In/sKLdwz21F789Pb9qPZrj8L20N558/9N7WKa/9P8v2Dzf6qppppqqqmmmmqqqaZ659QjB4AiQs6Zruv4d//df5ePfOQj/OIv/iL/6X/6n3J4eDjaf8YYT7wmBIdvnlF2rysUoVIx6xvwcJjY0AxQtoJABamCVbdkdKvQBv7aLqqBqhFiQNVVgqpKVCUlJQZl1nXMZwkpAJUYhZlCFidvYoJIwJwstXYdQoYYkOKQbLDmM4Vsvl0QJQR/vVa3Ju2CZ+FFMULLlRN1qIPh21VHRZYCWopbn4oiqsyiYQUQoebioC9FghnSLFG1KYUozZJUhLAndBk260KnELvEpq9sSiVTiCkScZvLEIRqRuyUkCIpRMwyQZUYhNobIoVsRumNWgw3Gw0OHsQzJaMaNXg2YogRqdWVTBiC0NdIKRkQNiiqQhDQVc+6d6hW8OwxEWOTK5oiGTw30YS+FEot5FKozYJ0yPFT8XNsQDW3VW2DElSJKgQr5D6Ti5O3ToVaBdUGEgERI5hQrTZkKjv02fezHdVN5TeAPNq/ttWDNb7NSOlMx2t3h9ae2zgAZLdlqi1HsO1f/ASLhLGlwTL3cS4EbDYbZrMZP/MzP3Ni/h8cHPiYD65sHY5j+DeE8IBZgz2PSu23W2fl/sWW+dfNE6Hl/aXgCrW+8989my+1UMB2htu/sWXk0RSBiocH5p0PYHcKdShIjHTBnS1DgNAalB3XZKn+/0DAOrfWVPAcQA3Mduw1a3b5oaTgquNSkBAQTaDVJYEtizHsBVKGfpz/gU12gF5yIXSBztMOCRGfS7NATMHnf6moKkkClR4RjxwsG7BS2vwHHZS+goPFGBrIBK2uirYGEkMNlL5AyvREtMCVALePejatPwowb1agw5lcLbZZgKMlaPvP6XzAM0dRY2eD+pPVkhUnTTVXpyjcgsUJW1HOUR4+0PNnWXyeeO4MuDfafrbnF+33xSkb0EXargU+xGfARYFej6RZuyDH8YgasqfcwY9tTdku/v6fVi7Zo9jvY53/9lS65e05/99CY3YBOvidOP8e+77vsYOJ4U011VRTTTXVVFNNNdVUD1uPHACaGev1mp/5mZ/hh37oh/jsZz/LX/gLf4HXXnuN+Xw+qv/W6zWluI1l3/fcuHGDzWZD13XMZrMzIeAACjxDr62Imzb4V9CmhCrWzBVbjlYI6mvctakAm11iFSGoIApBg+cLijj864QUhHk3YzZLDgajOBwMRhHP6gstUE1FqLUFaY2PtWMNDq1kDF9z5aEgbksZA1rcdjMIzLoDUghUK6gaVCGgBFG02Y1qCqBCbLmAfS1odevHkCISoZTiFpwGoVRQIWNEUSQ4fZIAJgXRiIhStRI642DWYSbElOmqUrNhqlQVtMJ81lHMrQHnex0xKTVHV0gimEaMHq3itoBNydZnIyBUEaKIKzFLRQy384zRbVNrpdRKikrsErJRxLLba6qwBwTpycWQChojKSjlaE2fK1Eg49mQe7NEKcGVkc3O0zA2695Vnl3cKjQbjI7BlX2lOooMsWWqYWhwRWVtdp5SHWRUCmYBNaEM2XzSoNuJC3dt0E62l/I2mB8OSkGHgUZGG8AblH5m28y/bR5LHQ4faQo/oYIEzxTczRuUBpUe04dKzpl/59/5d07M/69//evs7++P2xwdHZFzRlXJOXPz5k1yzsQYmc1m92x/tYK75U6PQPl3Cv7t7cI/IMTUrDt7evyxHUHdVtG3+9ho99ngH9vnwC1/VZ3FhRAIQHelo4uhZfe5XWfAbXUHIadG33nEAwT7WlwJWAshOVArxS09K5BKgRDo8ew/1aYaVbeXFQ2IRqpmwgwOZnP/3Mg9Xe2oxe1Fi0Aw6GZzSnW709k8kaK2LEM3VDZTrFY0QJwFogWsFnf7BIr6cRiQq7/HpBBjyx9s2YWdgnWBsIEVmRIilMg+kDY9fW42pQlCmnPnaLAC3aKwlxfNyvNBVIEu/dyCPxw3p/niBFvj1D78pcsdCHgqf+/MAcepAzrruTPaWd7ntctdODg/AzT2O3+vH8ua7BNbtf2WXvx+yJ08sUVhe4r7PmfHTzWW72lbUb4VJdE0/x9Jo/aU5789tcH3lD8D3unzfyKBU0011VRTTTXVVFNNNdUD1iMFgKrKrVu3+Bf+hX+BP/pH/yjXrl3j85//PD/wAz/ApUuXHJDhMKLve5577jmOjo546aWX+BN/4k9wcHDA5z73Ob74xS+eCQE9lq82+8ZmCznIp6pnS1VzCFlt0E+ZW2MGpeaCYag6aHNrRCEGIcWAiKBidEnoUmBvPqPTgAquOgtCbDl+iI32myoOrFTVj6cWtwMVt5v0rD4HQQTBqnmen2jLJlSiC4MICiFFTCCa+mOdIirj4jpDFp0ZWo1sgoofp8fAKVJrA4rqujsFSQ66ailYBlCIStDofUSlBEhdpAuJvhRCN2MvCOuNuYpH3CKzGsxmkRgTSUFKJeAL97nfOPQKfoVqVDQG0EShd0tVCX6ughFCpORMNXM2VoSYBK1hvMAOasT9Geu+or0RSeylyNF6w2pdqRhG4GCWuMOGmsXtO6v3maaIxkDJxZWRtWIFTJVshuKq0FKaqrD0DGLA2kA1IqhBzS1bEQGJ9DUTTNBgWDHPGEQdvJk1IEIbjxVTbcAvMDBAV+k1ONmsEwcV4DgNZGvzOYr4djID/T/er64o3AWPnhnowFweC/0bcv9+8id/8qHm/4svvsiP//iPj/P/C1/4wn0hoNfykRz3AIGG/LgR/u3N6RroCwFiGNieq/10J99v/BegbIFfc+X0ccTJbaHBvwb+xvnftb2ogz/tHPwpo6DUrV7rhpK9XR8FDgOzBdRpnAO16na50lTIpRxTej8YDZ1bH6uiVEpsqueQ6PtC2J+hEljngpU6jtdaK7MuEVMiyc78L5BLTyl1m3tI8fnPjMIawXMJqw9HggZiU+c6HQzEVNASxvWtoK5Q3OSC9JnIHoTE0aZve+gJJEoCWNGvFg2b+RiZs8DdOu9WBt41plaLHUTmj/W7VG6Hyc1XQ07gFkIvFrsjs218nyy+Eyq+5QNsd9YUOK0MvJd96M7f1Le8CPlYVjaf8nE85I6e7DqsJI3P/KG0d+m7NKTnJMYrMaWDGNOlEEMH0iKDRaphpdZNzqVS6yqobErJd3Lf36453y59/3rJm9fK5s5vWLn164+key6SLexFsIJ92taP9xq3F2n+XyQF3IWe/5q6Kx/81OzK4kNpb/+52f7+Mxrjfuy6gxDjXEQG//lOVc1qyXnTr0ru1yKS+/XqVt70d/J6fSevV9fL6viN1bWvf65svvG/vx3n/7m7vCg2sBd4/k/19qsUw/x7PvSeH/7Ai89996V598zevLt8eLB3eGV/7zCGENp9xZpCSNmsHve53Dleb6i2AVmvcn/7aLW+fedofefG7ePl7dXmxpdeXf7vX/zqa/9o6t2pprrYparpxRdf/JErV65852w2e77rZlfn89nlGGNKKe2FEFKt1UIIXa11A5RSSi6l9KXU41Lzar1a31yv10ebzebGarV69fr167/xxhtv/PrUu1NNdbErhJC++7u/+w++973v/b37+/tXDg4OnpnNZgez2exSCCGGEDoRIcY4K6WUvu97oG42m+PNZrM+Pj6+s9lsjlar1fXbt29fv3Xr1utf//rXf+uVV175lal331n1yBWAtVY+9rGPceXKFQB+/Md/nH/pX/qXzlT0vf7669y8eZOPfOQj/MAP/AAhBP7D//A/5Nd//dfZ29u7yw5QBGo1atmaRKoKZtkXj1GHf3XwyjSHYmaYVYK2BQ8zSrP+VAJRowM2gXmKpBCYp8gsJbrYII2Ib1/bBdVAYYrvB1Gqi9Nc+dWOLdiwubirJDKu5LtdnzRLSqdqMbiKJ5eCpEAMETHG3EAzQ5OrCGMVihpCIAVfhDcDCYKGgBSjKITBVLMUYghYGBRlxfsyuqUfJg7CmjYttixElYSminURkUrJnicYVOiCNihQHZiZQ7VEoFa36QshEWIg50KMgRAESiXn6v2ipVFUdbgaHMKJNpjblESdKZIEDZA3GYqhMiOFzCpnqhNWVOfIakWfCyJKrhCjEBFy8PeJa6dYrzasjnvA2Jt1dCnRr3uMynzWNXtaoeBjqZrbq4oJMbnqEIxcCorbubpcSvzttJxJqzjtkIGK+FjFdmHeCdNP70wJW+BnupNpOcA/z8H02EK3BUWsZTfqOG/M3AZ3GH6Pc1Hg+77v+07M/z/9p//0CP/uNf9jjPzFv/gX+dVf/VX29/fPtAP1x7ZWj15vHgSehH+wP19sbT9jYj5Ye8II/fxA2Fp+tp8HA9dRFRi2Sj+G54hoyA66FWYhIOoNa8VvRKiFnAtVfRemIDGQUkdMEY0JHeZ1BQ0KpqTgXFlbbqlnYCqlek5ksUqMEY0Rs0otbrcbY0RDRKySNxtKaVA5KLnvXYlcHf6Jtpsdgtskz3bnP4B59mdKSq2VDZUQZoTgdqAxBEJwAJ5rG7dN5YgGsIAGzwqUgN/UkUEidNUDFVWh1wzZjzuGzLp4+84FXZvXr3bA3RwOwX9vw2fRKOCYAdjGwao9MF/s0rYt5Fvh4I+5W7VyAgJux9VylxTu5gJyatjeaxjvKvjOVf61N7Sc7/x+yiL0dCbh+BnyBBciH+NOnuoa52NQoUi4/P1p/5k/lPb2P5jmsxfn+/vvns9nz8QYrmgIV1Rxrax5hi8IMShUc3cAM2r1vwOl+o1P1Srh1Pw3E0KKaFAU25Q+H5VcV6gelVrvrFabm8fHqzt5s7leSrmZN/2NvF4v+/X66/3q6Et1c+0fQr71tlkMf4TH8jSUcI+6+6b5/+iO7VEeQ5i/5/dfes8HP7V35er754eX3zvb339272D/XXHWXZnt7V0OISZVoVbz75wwZn1b+9nMXUZEZddrYnuzmA228P5DzWXdb/oVVleb9eqoX/e31qvVrdL3d/rN5k6/Or6V15vl8c2br22O7iz7Ozd/d3Pjy/8ANtP8f4KNTDzvW78+9PLzv//j3/Xtf/i9Lzz7oeefufze55659K7F5YNnL+3Nrsxn8dIs0qlV1AQ0epSI4N+jo99MSvEboWstZMuAoTFC8GvK2tYLNEZEIfebzWa1Wa03+WhVOD7qy+0bt49v3Tpa3b6zXt+6dWd17fbR+vby+u2v3zpavfHVb1777c9/6dX/9fbx+sZ0xqaa6tHVM8888/EXXnjhn7p06dJ7L1++/L5Lh4fPXjo4WIQYLqvolVpr6nMm9x6FpCqEEDEzYrvRv5Tia5/4mmnfZ/b25qSuw6yS+4yZsbe/z3w2Q1XXfd8fm9mxqBxbtdtHR0e3GjC4tdlsbhwdHb2xWq3eODo6evXmzZtf/trXvvbLfd/fns7YVFM9unrf+973vd/7vd/7T7/wwgsfunr16kuHh4fvOjw8fG5vb+9wf3//cowxDZFm22s5u+v34d/huVIKOecTv/d9T9/3rFarTSnl6Pj4+PjWrVvHd+7cuVVrvWNmR33f3zk6Orq+Xq9v3Lhx49WbN29+49q1a1/6xje+8at37txZTmfs7VmPFACaGV3X8Qu/8At86UtfYr1enxiI4+JWywn81Kc+xfvf/34+//nP83f+zt8ZFUCz2exMYOCvM0opo6JOMcwy1jCb2xxqu7h120NtPoxmYEPuWPtfaFaPWo1uFkhtgTpE/3kW1W0gTdCmJkSETPEv1O1Ld5WKiluBEkIDaYJJaZdsioZIaMfEzvd0EF9gV7frrBRSCNDUXhrUVYQeS8fwPR8gBcd1KoaE5BCsLQKYOnASMtb7orpngikaBSwQo2Hi21cg4fmChZ6UEtUEK9kXF319kZgCGpr1qlXMPHdPawNN0UGlNVtTCJTekGAOW9vJSzFSMTabDCipU6SYgyoz+pbvGIJCVXJfCSoEnLTmCiGq55IFoc8ZEQjq8OG2ram9jRdGoXV4bWdHq++jlIyIsm5fiGIK9LmQc0/qIkGGzEhtdovZlX41E5OSomOeXAxt2YU6BPw1UL1deSlgg2KvYk0puL2sb7ad1Zrlp26v+kdF4GATursgIDtBcXnHFlQRa1Irkce6fFBKIcb4QPO/lMInP/nJu+b/r/zKr5wJ/4fK+Tzl1lutJanBv8ic0ODfrIO+HUrYno0xw2/4vZYd4Bea8u/UHjREgkKtcfvh69PRdxJcQZu6Pa5enhHUCWNoNwv4KCrUvCbXSmEHBhdYK6jrAP1UFweEpmC15V/GACG1zMtm2RkUjYlZUkKzsw2zSOxmrmqutY259poQCdGtZctmzXrdk2umFPz/1rPZVCxvQDsqmazqKsrBbrdU/3ypsGkdnFJAKlgjq311ZWyYFaiB3Lfcw/ZZVTS7ZWoHlEQobkkaIpT+JOwbKgH9jsXn7tPLJSwGX9AlrFg2O9gF/bjhgPZcKXgSAp6sRdvDchcC3r3B3WBvAHbn5QmeGX85PwUXdyDg8gEWEy+6+uY+O70Ii6Jv3pYxPRcPXvjM/PDSx9P+/nd0s9nL8735s1Fd0x/azUQi/re97M5/a2bP1dxNAHX7aXFr7faBS62FWjMhRmgLBYNCXKN/3+li7IJZlxTP++320KuXfKGw3ali5opljQGqkTd93Ww2qz6XO8VstVn1t/vN5mi9Xt/pN/2ylLLcHK+/sT46emVz59o/MLv1K49yID2t7LGnAb7sQo3Zaf4/qr4Uvfxtl77toz95+YUXf9/hs+/6joMrl1+e7e8/Kyo6OECIeOY048/tWqPdkGNG+4xQv8KwdhNYa8Da5wDN/t4zqW2Ef4KgIczm+2FmxpXZ/n6DiDbub7gZj3YzY3NkqSWXVXZIuCp9vtNvNseb1fHrm+PVjfXx8bX17dtfP75585U73/zqPyyrr/7DCz//Lwpwtos3xqd69LW4cvhtP/LxD/+Lv/eDL3zipcXVb3/h2Svf9szh3ru6ECW0GzZVhRg8SzuXSunbjbFmiBZyBbWAFaHo2qM1cvH5LmCWKWUDoYMU/WbT6pEQIQVCjHQq3TzFTlO4rDESZjNQ9ZuEW3qJVb8+1xiwWsnrdT1eb1Z3Nv3t41yPj1d5dftodfvm7aObN+4cX7txtF5ev3W8/Mqrb3z5N7/09f/1i1/75menMz7VVNva29t734svvvgnDi8f/v5Lly595/7+/gt78/13qaqWkscbxVerFX3fc/PmTe4c3SGljs2m5/jomPVmw+Hhod/M226cP7pzBwG62Yyj4xU379zh2SuXOTjYdxcylKPVitBFrly5zOXDy7MQwizGcPXw8DJXr1zm8uXLuIDInczArw3mM7+2PD4+rqvV6riUclRKOVqtVsdHR0d3bt++fb3v841S8nK92bx+88aNV1599dVfWi6Xn5vO+FRTbetd73rXe3/oh37oJz7wgQ984oUXXvjQYrF4+fDw8F2qKsN38NNwb4B/w2PDds4J7gaDfo1gxBiJMY5tDjFsqkpKqROR7sqVK1cvX77M0dERIQRSSoQQxnY2mw2r1QoRYW9vr6rqcd/3R5vN5tjMVqWUW+v1+vrx8fHN27dvv3H79u3X3njjjS994Qtf+Ptf/vKXJ5XhBapHDgBnsxl/62/9Lf7G3/gb46C864K3ZQB+5CMf4ff+3t/L7/7u7/If/Uf/Efv7+3Rdx3w+P/N1iND3G0rNiAR3o5Tii1+qfse7DIonodb2s/jkGS0VlTFPS4MSojKLkVkKJBXm845uFokqzWLUELVRaYO5cnCgf7UvEKUBO9nCSTOCKqKKiS9bG8Gt+IJ6fh8yqun8jl6/Sz/FSFUhmCGD+iYEKAUrBYme2dVYmOfuxYBacUAWPJNLcIVAQShAJFDNiKqotEkt7cOBgIQW8lWr54LlQi0tV5Ce2oRlOmTKDYrIXCmmUCCqUrQgQYmpgYKWUUfNTfXnOklXOEVQt1nNscmYBDqLgFIlU3uHjH0pdASyVGr0Bc6gEekd6yUxcigontt4iw3rTU/tjU11JVEtFcwIMTKfz5EQ2GwyOWeOc2F/PmMvdfQ50/cVizr6aaqGpuirYJWaaeNAUPUsQxWlVMfPjIsoAapgogiVag50TyK5IeOPrSyQ6u1Y2JEG7kLDIVdyWCgCszatpbZsQx3Vi8PrH1fNZjN+/ud/nv/hf/gfSCmNXx5PLHenxNHRER/+8IfH+f+X/tJfYn9//94ZgCGQ85q7acibuOje+WE38y8yZ28v0c3SaNc5ajbD9iNTybhsNlM3vYfQ7XykDnmAMYCEiDVkWPH8PgVCzcRZx/ygI8U9qKUx3EApmdJnn+vNzlMBsm9TNJCk88+S6FLBNv3GOEkL6lBSHczVDVgG0UoI0edehU2pUNasN0oXoOaecCcQUwQC0rJJB/vRkCJx1mGlUvsNUZQYI3QKs45SXHEo4ta7ospmvSFX2uJFppZKKb3z7goaA0kh73ikdtX7ouqGugFNsCkFckBCYUMEzcxiRNewAWIHqfSEw0RYwR1WHK2WsGpAsAX3ea4fsFiwYKsCXAKLpav/VrugbxhzDfaNhO4uu9CzascG9J4Q77whfV4O4PD4/GSby1PAcXnq30Xa+Zv91lY3L8SipD3947CH3EBnz/1Ud/nZf3rv8uWPdnvz96Woc6ul/V2lzX9rE7e2L/VAKQ7iRUkh+cJ9FIh+s1ARdr73uC24v86ovWLFCFqRMOTeGn0ubHJhrT1dEErORDkixuRtNHcEUb+w0OS5ubVUap81KvuhC/siAZt1lDL3GwbUtxURNptMKUYu9SjnfL2s+2vHx+tvHt2+8zvHN2/92urW63+3lpufe5hOfRrn3L7F7A3PfT9vl88AuxifQw87//df/L7/89Vv+8Afufru57977/KV98/m87nno7uV+qDSs9rcMIY8cRngm98eJqMTCuNnhJl/91RtLhPNWn74oNy9Lhu2GRSD/i3Dtp83wwJCcz0R2W5fa0FVNczCfkxxf+/SAVYNbd75tUFIs9r2A7nv76yOjq5vVuubR7dufe3OjRtffuOrX/v121/7nV8o66//2sN0rD2Fk2x8a83/qZ5O/cjHP/KZT3zkff/Ud7/vxY++993PfGBvlmZqZXQbAmHT90guSMnUwSlmk6mWIc2I2pEk+PfuqFQxpBNqUY9Aaa5BqpWchbL27wESDEIY7xddZ/Pv8UHczr/2aF2hcYNqbH//PfbCRHztoYLUipasl5LuH+4d7ItGaoFSs+eKB0W7CCJsVpnjVeFO3x+tN/nGnVvH177xxs2vvvr6zVe/8Mprv/bL//vv/PwXX33tV6eRMdU7oV5++eXPPP/c858+vHz598zms/ev1+vZzZs3uHPniOOjFRpusF6vybnnzp2jFhMUmguau3d0sxmz+QwRmM1nfj2NkXPvi/oxNiGBsOk3WM5cv36dEAIH+/t0aQYhsHzjda7fuMYzV6+SUsedO0fMuo4rh4d08zld15FCaDE4MJvP2d/fR0VZrY7VzA5S1x10qWNvb48QIvv7+4Tgazk6OAnVSq3lTt/n65vN5uadO3e+dvPmzd+5du3ab331q1/9O8vl8n+dRsZU74T6g3/wD/7URz/60U+9//3v/8Risfi2rutmAxvZBXjDd+3TUG932+HnXfh3uo3he/7ws89F/14+QL5SCrVWSikcHBz42ri4SGp4fa2V9Xo9rtHO53ONMR6Y2UGt9QQw3N33ABCPj4/vHB8f3zg+Pr528+bN177xjW/89te+9rXf/NVf/dW/9eUvf3myIH/CFU+T5UdRly5dumebAwAcBkXXdTzzzDMcHByM8tQzX4exWq3GDD6oWKlj5t8YB1j9tjdpeX3FXIMV2oWpNmvLoEpQh397846guOpv7n84B0vLKsET5ob8NZQofkWcrSn0xAGN2JDxB8FJHybS7tRr6r92p25AXM+iDpaolRQDs4O5K/8KWM4OB2N0u1FAoiJdhGwIcXSWVEpb/FeHCSKu/ioO9dwEs/qXghSwvuBJdMHbqN6BDpyUsl777yE4uBOHpsOtyJIzqhGJEasZqCPmCNa2E1cupBgoFKoJAW2KOt92NnO6YbXZlmR1JWE1NDRL1SjU4kq8HoNkhKbg64vRtfNvYgRTz2CMkKJy40hY95mce8Dvduirq/U0BA66GSmuuXN0TM2FzaZ3pWGMlFIouZJSoK9uuZa6wGZtbPpCqEJK1e+QFhkzKM2avekASmkWnA0fyUBT2nzwT0s/CT4nWw6gNXDq0qgdaDiYte6uCFTMFJE67mdghMOUsXYHODgQfxx1+fLl+24zn8/HO1G6ruPy5cscHh6y2WzOfU2gcHR0zKOw/nQQsoV/h/sOTbqYmO8n0o59Z8VBXyRSmw2oBgd9uYCG5L/vWIJqaCgwDZg/OjQksj/r6Pb23IS2LaytjzdAIWhwS0wJbqeZC0mDz0F18NVFV+BC8nzKCJqCL93V3fWhgjozIHWuQHbFT0BCu1OwVFKt4+daSErpE1IKtW7b6CltrAb6mmG1wRrclQY/a3E4KRIwelcI48LUIZ903iUsKGlvDzhAQySXSrXK0Z0NdXXk2YPqdqF+j4N3ZqkwM+gjUAN76tCvuHR5VEXH8RxBF/1Eux3oVrW3GuR6czhMLzNnxSuNAjpHc/XfAAH9Z5ivYD68flAJLhYPPN7u+fOu1edZQ/wuaLgLBc+AjGe9ZgnsIMt7Ao2Lbr151jFcFEBz1veX7vmfnj+z+GPd5cPv62bdc2E4AWasjtfIoMYd7mKqhmW37ZbgNl0S1L+bRLfLtWJIMkLLMLZ2E9TgiKCG32DUPqMcGCoSXdluOZMsOUwQiFHRPiOlUsy/Pxjif9eLIapQK+vValQYSFtkKMVvONGgzZVBWm5twwoizLq438Wwn+bpJa5e+j0anv9DuRRqtXp8vH7t1u2jV27fuPX5o5s3f/n4+lf/X5BvXNhF+Mc45p6UreE0/5/cudp74ft+evHB7/rj73rpxd832z94Ttxswx0rSvu+jt8EqMNcVqVadZtfkZY3PkA2V/AN11GCUIt/F2UH8o2WoOPfYjnlOjGMg+F2NL9oL6VsgeMO2BtuONPgVsN+kd8WIlRO3JbmysEwAsPUpYOYLh/IM/qeZ9/93EfMwD72vWDUO7duffPo5q2vvPGNb/7mta9+9bM3fvdX/yu4841p/j+JF071uOtT/8Tv+b/84O/7jh/7zve/+6PPX738fKeCVI/TWB2voBZCdOt9I1A2PbLpSSGiXUTUIVynCU0JsRlSBekMnQWkGlZldPWptSLmESEh+Pd/qqApYNFdaCRnkgm1udaEANYrlgtm0uIDttnmqH8uWS3YJqMYoZtRN4Va2vWAGibZP2xWG2IUsMo8KpcuzfaVvX199vDF73nfu79b1G9I3vTlL37z+u3ll7/5xpe//OryH//a77z693/+H/z6f3HraH1tGjlTfSvU+973vn/z+eef//T+/v7vA553271jbty8ya2bN7h9+zZdSn6jeYis1xtCUA4ODnj2mWeZdR3VKvt7e8QY/ca9Ftkx35sTY3Br/1oppdJveo8CAOazGTm709XVK1c4vHwZUWGzXvPMs1eHm3nY3z9gtTpms9pg4Ddwm3mUT1u33PQbXn99Sd5kDOhmHTlnVqsVQQPz2bzd+L39jjK0f3h4+SCleBBjfM/Vq1c+8sILLww3H9Xj49Vrt27d+sq169d+c/na8h/+43/8j//fm81mmv9TfWv8/f/Up/61j33sY//HD3zgAx+/fPnyc/69284VSu2ymV03jvOv5c5+/qzHdu1BB1g4AMQB+A0ujMNzw/bD9QYwqgeH/59ua3j9Dus5uHr16gHwEkCt9UeaErHeunVruVwuv/z1r3/9C1/4whf+f7/4i7/4X9y+ffv1aeQ8vopvBv4N9Pgsm87h+XsuhDUL0IFID9R58Kw+f7/GetWgFIZQqG2BerC4sWaHM7wtUf/26otqruKLIY52nSkqXYrMohKj0kVX/qkKiqu1tMEsGe+i9bastRuSUooheG5ds9NBJKDWbDOHFfAQiM0fUNvxGf4HcjbvmmWm+eJcLWQTJEW37ooQasK0OFisDS3sKMMEIcRAqaDFTQKrGpoNlQJdJANaCxIgmKDZms4so8WPvxS3zHT3TX9+ACIRBwelKhJ8gaA0dY8GRYhAJdcMuWK5WbSq96gGoVKg+l1KEoBq1GZ3KLHBvFyoze4yRnGkYJVkBkERafauFNz8D/paseLQJIoSxZHkjTuGWPXF0CiggdpXqlS3I4yBw/05q/WGWjK5OvZJwTPUALqklFyx6hdUfS4OQ7KD5GERxGpFxajiGseAkStbBartLKMMwHpcNPG7rKxZeA7QpcIWmg5qrKEdaVasu2sA5tBxwFhmjPNEtstCb+pD437z/zz7zt3KOY+y9KGd+72uFFitbr3lD71dXuPKvzldhBATXUgkWlZf6706jvpT2skB9IVILrnl+7WZ2BbstToW39/bJ3V7wzSl9MfUCiWXNmYKXdcR9zrcXU+pOaDBFwglKVH8uEJq9sBlOJ4G51C/CG9ur7VUcqmD6ywStN3B72Mr9xUpPaoJgqtErc8O73EC6gsHSq3qGYLtd+vBUlNqBiW3u4lK6QmqWE3tPPfYoPQLgT57VuCqNOCQEioFDYn9PWV/7/LYycfHmdu3b2EGaRZcdV2L23e2u5AVWGXviJQifcjUAl2AWJI3dRmuNTvQniVpRwkI0K9WpDm8vNjm/zkrXO5uxuGc0Qp0gIMDLNw+1l48Urdhy3vUeRag4++nrDxPw8Fd1d/Y5hmqwYcFAPdZULxwi/9P4cDutyuRg0+kZ178N/aefeYPhRRfEgwTKP2GWs3zNtvNLt0skbrk8wefvxpju5s3+I1AeMYHIlgxTOr4Ma5AHtwCxIF8zrWBBPEcYW1qdqv0paI5oxLc1lP9b24Y8mrV1YXaIITnjfnfvlpKyxL2v8XFIIhQ8qBL8s/LftNjJfvfo6D0fUEF1uP894XNoFH3ZvHde/PL7373c5c/bvKen1itv/Pfv3H99m/dunHrV2584xv/TV6/9jef5EC0J/xie4ID1R5k/l9ABeZFmv8Pspswe/f3PftdH//zi/e970cvXb3ykjQbzuFuLkWaUm74bmgjhhvVeWy/N4qOVzujNWhtNj51vFmsZQOO30d9/g/f+erOPqypizX4DXa+IKCjq8rwfU81bG9MG7K+R8shKKW2eAIZc4eGdobvq9qcMsz8oshvEGjf4VX10uXLL+xfuvTC8+99z++3j3/fn1off+o/uLF8/fOvv/rq//a1X/tH/5/NzS/+j9P8f7Tzf6rHWx94z3Of+ON/6GP/1vd9+H0/8tyV/RexQhWoec3xxih9ps/ZAdn+nNnBnJSCwze/IxkVJaTggG4W0C5iEiAL1tvunZ3U3I/54uRKzRXL1V08VLGda9RaC6HPBCIhRJCK9gXrjVqEEAWJPm9Lu1FRgxBUqFUx7fzOvhCoCAVBrEVuSKRWo+97jvMGoSIxkopvY71fh6cuomqkFPU97zp8/qVnLz3/Ax95+RP/HN/zE//mT/yh/+ALr7z+W7/5pW9+7n/8B7/xX332N3/nF6YRNdXbqa5cufLx973vfX/+6tVnPhmCvlRyYbVacf36dY5Wx1g21v2a2heuXL3CYvEuNATP5Fqv2dvb49KlAy4dHJKiZ3V3XUetlaOjY/rcEzWQYkBUKaVSqt/EfufWHVarFevcsz+fuZIvJaoZVo3VesVmvSamyKzrMIHcb/wm99SuRWIkxUSfe6xWZjNvZ71ek/ve7cQ10Ofs1wTVSMltBo+PV7z+xjVWR3fIuRCC0s1e85sMVYmxY/9gH1HhYP9AY4zv3tubv/vS4Xs/8YH3v/8nP/GJT/xfb964+RtvXHvjc1/84hf/m6985Ss/P42oqd5O9d73vvd7Pv3pT/9bH/3oR3/0mWeeeWngH8Pa52n+MvCP4fHhO/hpELd19+AEaDuLtezu56z2B+4ywLvSbkbcdQfZtSIFRoXfaQC4e3xDG6dtSXePc2ctWWez2fPvete7nv/O7/zOT/zwD//wn/zxH//xf//VV1/97d/+7d/+5c9+9rN//XOf+9zfmEbUIwaA1Vqu3YNeRzSbz/l8TkrpnsDuftV1HbPZbFQC3XshDY6OVqzXvS9UUTArO3e5Vqy4/Y2qq7vqoLRSa/AvEFUxEVIMxOgwsItuYde1PLcQHAB6bqBtL3iH7AvxfLYQfFG6tv1Rpan+GmypRpXif5zH62//Up3QEcFYzZRNJsw6Ypqh0pQ0ezNSsxS14CKwGgSdzTHLTiasrdVVGUPIai0QIqKR0ucGghrsWvd+F18JxCRQi6sbiZQqLS+gOsxQt/twA9HhPsAGEIbbiU3IfXW1kBlsHMqG1JFmkbxeUXpfqAxhWGhwGFGDNHtW3P9Tgi8btqzBWox+1Y+WKFb8rkINbj9iTSURG6QLQVtOozalYKGT2O5ghpusyVbZ5DqqGEtf6PvMsQS6FFARB3dtkbSajuHKfl2j9JtCVGHWJVbrDcV8AUQKxCgNtFUC5uokFBWjbPmdj9faAh2p7YpNRuWWq1fDqCZEdLsQNMxFsbZNs4kayOHQ7gkZOWOm4JD9ZA0dhYeYszlnZrMZe3t7dF33lj58BrvflBI55/tuv16vd/L/3qT152KLZdIcUoKYGDP/UmjTqKn5KrnxqHiqszIa4lYV2J4flIABoM/MLu8Tm71nyRvaECYpoMGVv40kpllH10WwilRIszi44bY1/oAE1+Sp+idcKfhnUN/mXQgYhdKkgNouClTUx5s6aFXcWlABqcXnvUsCqX37DIgK0S0F69CeqNN+a4rBqOSSxzEVQyIFxWJ0aK0OzSz4nI8h+TgUqFZY971nfOb18PFC7Bwepk5ZvOuZ9smjvHHtFn1fiHEUxEKFFANWC7FBkDDABzKz1lbZh5uscDXglo2tWMISXgEWi8Xd8K2NlZ1fWK3ayxcLDw5c7rS12B2fix18eJ6N5ymoxxmQ7zy70MXKwd/yjO13MwHvYTf6ZgHAhbbcs6e8f0DC1T/WLV76c3tXLv2TGnSfatRNT6kFVXcfEIYvxj4vU7u49r/JkEI3KvrE7yxCNVDMlTYE8dxZ8xtyqrULA6mU6mo8UZ8bnhmrUMVhvfkNMa72L9u/68V80bBWNKkv5LVMMcQzj63Ulh+khBjJtbgltggxBmJQTLSpCoV+43aAGkJbaPS2qlVWvecL97YZQUVMoX1Hk0vPP3fl4889d/Xj9qFv+5ffuHbrd66/fv1zN77x9Z/Lq9f+2uM4908yU9Ce9pyxb9H5/wQO8H7Npysf+j+88Hs/9uef+7Zv+yENYU90mz0+xjpbU8a373fV6mj/Wc2w4YaoFrinJ+4U3kJAh3/twly33xMHi58hv09bxrjhN0Jau2GPapRcOH0ZONyYZs3Gc4g3GPbpPufmNz8Oxybb75tuJcoI/WxLLf2GBLPhq4RnZ7e8b49yELpZd/Dce178vsVLL3zfd37se//l29dv/M43vvLKZ1/51X/0V1ev/9Z/P83/t/i+Jgr42Or3f/cH/tl/+od+35/93u98zx+4tJf2ai7kY7f00wbjVKJb34shpuztz5l1iYB/H+/mMyhtwR48A1gCFcU0YLHNa4sejl49q3dMnRcwU2q7UdmBvEeOoBmp2eNFrCJRxwtC6yu1FFAhElpOvV/0iwUkV6T6Dc8OB1v0BX4Tod/gHLG20N+Lfz75DcUdiFG0sql+E6KqECRjxW9GiHNFNXD10t7B7/+u937s+z/y7R/7kz/68X/5i199/Xc/9/kvf/Zv/8Pf+q//l1/5x//faZRNdVHrueee+2Pvfe97/7UrV678ATPbv3X7Npv1mpwzfd+z3qzb93lFRTm4vM9LL73E1Weu0ufMerXiytUrpJg8dkb9b2YInr05XNvnUsh9TymVvfmM+d4eXTdDOabkFifUb+i6RIqR9WbD7Tu3/W+tCjEESp9Jze3KnbIKJRfmZc7hYbdjH+gfKrVBgb39fVJKHB97BuF8vkeK0W1AY+TwciV1ieXyNdarNfP5nEuXDjCMzXrDarXm+rVraAzcunGTapUYEwcHB+x7BvH+fLb38Q996EMf/8hHPvJTb7zxxu+++uqrn/3iF7/4X371q1/976dRNtVFrY9//ON//A//4T/8r33Hd3zHD85ms4MBdp3HVHYB3S4LOW3pWXfm/mCteT9es9vubvtnKQ/rGDciJ2w8zzqW0zBvEHMMx7m77WlF4GlIuQsqBzh66dKlww9+8IPf+4EPfOB7P/nJT/6Zb37zm7/7pS996X/7xV/8xf/yl3/5l//6NMoeAQC8c2fNlcO9nXyw+yxsifC7v/u7PPPMM3zta187QagfpkSEL3/5y/z6r/86r7zyygmiffd1in/ZvHO0GhgapRRCuyiuzUZrsEYcgu5Rt8QARcNw+eoZdaI09Z/fPRMaxEvayHe7qK3id7YFrCmwmq2Vm3f6kdWWBSjWLmb9FjxVIwa/4zcMt8GKPy8qBHDLPwKSZmPQ92DXE6I2/+zS7ggOGK7qiTEiXaXkSq7VlTuAqvkimzaoJL54H2fJs8PWA8gTLEtbJIxICMQYoEKphTAT2tqAK4Rkm2+HQjElAJIMegcMmiDUwKb6QmdQJTojJEuzCauGxgZCG+TTthigKqMs0vfl0HAcA4PiTYUYlBwgVKH2PSEKtS+EEBEK61w8r0AgxcT+vpFL4ajvqdR2l0NT+BVhvdmQs6snrbQ7qXU4y0pKvt4hIkR1axQRJamSi6sbSq1Y7xarVq3dbenSP5GKVqG2O6Yxpbb8xq22clACusrU2MJnaCouuxuMS9V257edIIQ2Zr4wZgGe/gBe3Vlz+WBGedAPjBj50pe+NM7/GN98jOhXvvIVfu3Xfo1XXnmF2L6A3qtu3jx+Sx92i92fRvg3p4vJ5w49cbDzbIdSic24s9UIAYdHIlocCNYAlEwKMD88dPvNvGFzZ2trqiEQOl/k07ZAj7p9Z4xhtLhyJW3A/wYXh8wUV+badnEvdErNldrXceFPUiBIoBZfb4sCkvyzoKwrpXfVtIbkd+uq3wBRrGIkz7g0xsWGECCYuppwyPL0yFMHjQpanN6F2pRFURtkdxWh5wtVKL2Px+AWhhrCVqbd1gcLDh3LZo3lSoqKpsTlgxm2HykVbty6RV8LqQvUTctELYWgbm26rtm5KmwhYL/iTnO/PK3kA1guT5K/xdYxlDSo/+aDeNBtQRc7lp3Lpb/mLNi2wJ8/F/SdqB1YuAskF+cM6l1IeBpgnmknek4G4NvA8s8e2UaPZ9+Snv0T8+de+nPzy4ffj1isfU9er8f8LNShmTaD3NCs/QT/ruDfgfwGJGlqebfRqZgJm1Lac+1vUafUXCh9GZXdGpXYRUr2vwchBJ+PKHlTqZtMaDAxaMsKitG/eEdxC7JasWZrreKPlVKHvyrNGlAo5hBAxT+41PzvrPgXGaDlIJu5a0PN3qZbCxBDYNSmR784yc3+MG96yJUYAyEGvXww++Cl/ec/+OLLz/+z16/d+vwb31z+zTuvfeU/gP61NzsGnsoivF2QecIZANDe5vPfnm6fzt71kZ946Xs+9tNXX3jx+zXo1mGlXbjY8Hdf2nfI4Aof2YaXt+/cckJhx6k8D2xQ9Q2WoNtc7sHes6X/jTfnVLPtRXZx2DguSox3BLfPmwbh/LJFmlKQ8bOp1krQQM55aznaAP6OSHF7k6O5nemocKzWvp9a+36wY0mkfnzD61WFUkwvXb3ywf0rlz/4vu/+yD9/ffn657/ym5//G9/4R3/v/2F259Vp/k9s7yLUP/k93/ETf+wPfuynv/uD7/kngpDKZsXtazeouXg8Q4jM54kg5usXISCaoGS6ZpVZDCS0G39UUSvudWR+/WxWEGuWfFGwCrk3LNeW7+s3B1UJTaBvaCeIBPIx5ONM7By2iyiaIhqjeyoJmApinilY2w0E/jXEPw8qniri9//6cao5xKfvKRiWikcNtGv4gEeBaPUbkKWtswja4CRY8GuL3GxU+nWPHa/oohJmST/w7qsfeN9zVz7w6R/4Pf/c51/55m/9L7/yhZ//r//2P/y/X7919PVp5E11EeqFF17457/927/9zx8eHv4Tx6vj9Ma1axwfHYEIBwf7dF2HgCvzNhvEYG9vDxGlm3VoCCQE3duqZ3LJrrarru5T8YX/2WzGs89c5Y03rvH660suHezzLlXme3scHOwTYyT3PRqE/YMDRITr169z+/YRIQQuXfLHYlMW9rlnvd74d//q1w2huY3EmMZF/ZJzu//f//5v+g0lZ0IIlFI4Oj5m1nXNcUToUmo3Ohnr9YoYE/P5HjElVwWmDs883dD3G2qtXLt2jfVqRUodV65cIaWkBh949tlnP/D888//87dv3/78V7/61b/527/92//P4+PjL08jb6qLUD/4gz/4L37yk5/86fe///2fEJFUax3FDadB2C4L2QVo5/GSYf7t1uncvwcFgKdB4/ZmQT3x82nl3y403LUI3QWZAzw865jO4jynlZC7oHDYn6rqSy+99IEXX3zxA9///d//f/ra1772jz/3uc/9zb/+1//6/+3GjRvfnEbemyt594vvt/e8+MxdYOBetStffbMAcHcADQPjXtX3hVdf/SalFrefLGu3jgPP/7PqwdfmIMTvmB8Gll+0htCUfjO/r+3SLDHvEt0s0IkvtncptfvntjkcRlNJNpgyKMwqdbzLfciTkwa6VJUghroOkRBcahtCJKbggrdS0S6gEhz8qRJicgVR9cWAUgvFjBAECW4PRi2upLOKZLBS3J7fhBCMOPO79qWqi8sa8CNA6cGsR0e1WSB2HaqVJnrEKpgUokAVz+wbs3zEQYBaU+KFpghSgaBQPBdxCCMrpScAVYWyNkrfO0BpNgNj+pi0TDptfS0ODUpvrNd962/zhQGrbNqdSFbd67yYsckZDytS1lbJ5tuXavSbnvWmcOt4zdF6Q65QslEFcjHW6zV92War5OILEUkcEnddbFDGj6vPGRc9CLmUZn/iizGxKUirkw6/WlLIFjDz1RETRpA8QJ/BptM/FeuoYB3uEPfx5zl/vtpbmuqvvaptK2jL99vaTY3Wo+J3ia9X17G8Zv/gBd773qsPNW93Qd397kB5VO2UUvja1772lhSAC4DFgvncEchemrO/l+hmMCP5/O8iOwmKTQW4VQTqiWzAUbTWlGewf3UfNGC5UNYbaBagQaN/oe4CIbqVpVa32Y2pa9l8Pv9V3RJU2ufNILatTfE7AN3oETz0fW4X4LQ76CF06pmBTewqwW9KWK+zZ420/vZ//IaIKG7lR93aybIjUgWf4r6W6T8EaZ8v2tRCJTfFXrMfdS9Dh5H/f/b+Pd627KrrRX+t9d7HmHOutfbetWtVKqlUkkpShkBekISEkAJFQMmLhwaInwgIiHrv9Ryv3uuDpwoKInhREa+Klys+jkdFPHqO4FtBVOCIAiEQE5LwqFReq2rvvV5zztF7b+380Vofc6xZa++qFKlKJbVGPpW991pzjjnmnKOP0Xv7td/3V8WchcSG/Q3s2aeuAQbH1QYGMaMUQR2KOadU3HFg4iEHE1NOT9c4OjoGOKCUOn5fWYAshgOVCgzDEutqwuEqWwpeEwFXOMDBwa3Pm9m+i8b+vDNQz4Nz4vv2H67wNVDoxhUI3BTTebAl8J335zT372Zi4cHNRMP7AQBf+PxH5gBfFP0fxUQqXvnibv/pf3hx26XXgChqdQHLVfiWwRNSRIxk3e4CxBQQUwL5/CGkOBbYeXRu23ibNjoRATHYPbDkapADWHOTQMApjK5wJh//IKzWFSQKjzA19y187uHoQDS3Do23lVEpYm7kAvckkzessBUTaxWoz4tq9YxTEUg1R5P64oK8QcDEDBcUW7PPOP4r6lBQh2xzxbbgCGEUGFfL9bWDDz70r6+/79e+S+XkZx7py9NPwPP2N7KbeXryiwkfD+M/XXreG5/58lf/8at33fVq4hDZKl5WBHNhDiDP6TFRLgQT+TdUUHuM3cNN+K61ddLa61jDlQl0PAp048p5xH6O3cL+szMLeF90B8f/WGbnBhrRBERyVyLQHEQ05g+aO1A9jKHhPsWvJ2095q5FeOOaL+anNIHpvhrStIo4ZtDjHPwxUmX8HKpnHS5PTh9637vf++/f+5M/8e119YH//lQc/7+RXf3ri9LpR2V7xac854u+6Le8/I+89AV3f2bXpZCXBcPJGloHQK1phzkhzhJiF4Aq4Gouv67vrE4QLJuXA4F9bWurXmvSEVizD0SsoZQECoZUsjgNETAEigrqIsARAQyGNelVMIYBkFIRghiW07PhOVrTIGBIYVEZw3sDWYtqG+uqOpJJAsFiSwKb27BUVC0o5G3b6uvbannGKtWuiSmAEgGwNUoIBIpGZ9IUQTGgFsVwskQ9XdqnoGKN1CmBYoCQ4sHrJ9f+y9vf+2/+7o/85Hf8yvsPfvbiTLzYPhbbnXfe+cX33PPcP7K3t/sZwzDE5WqF4+MjHB8dYzabYWdnBzu7u5j1PWqtOD4+xvHxMeazuef3Rezu7GK+WIwGB6sX2nyh1opSi90byTCgIUasV2t86EMfxIcPPowrV27DHbffjpQSQIScM4gIi8UCs/kMIMLpyQnykJFSQtf3SCkhcPA5gCDn7Hm/Zj6AZxK3TL++60YHc3CBccgDYjSMqK0fgFoLVus1jo6PsDw5wTBknC6XOD09RYwRe3uXMJv16PsOIVjEURhJBjpSoQw1WnB6eorDwyMQEXZ3d7GzY+7D9Xp97dq1a//+Pe95z589PDz87xdn4sX2Mbn/v+IVX/i6173u//X85z//NQBirfVhOsnUVTcVu6ZCWXvO9PfbouEUrRlCMDPQ5HHnCW/TuLVp9NL0Z9N1QxMbt197Kv5tP6fVcdtxbWNAzxM/2zFsi5/Tz2BbrJyKmkdHR9d+7ud+7l/9s3/2z77zV37lVy7u/x+pALh75W6962mXcPnSHFUAoiffQTITPvzh67hxeGTuq7L2gHq1iTLURUCrVFvOla1oIzc3nd3k5l0HJkLfd9ibdegTIXae+0ds+DpVUDD3V8nFTlp1tKQjdlgt3FbZ3HxMGxGTghXToqO1QrJu91orUgroumAL6WA31NENRAB1aYPlg+d6MQHVJskKBUtDdhX7vSjirAdVwwCS4zg1EFp/faliZjSYG4jbfgWIyab2NQOpCyCpKK7pKVvxIehGfJCstoghRq1lRH61aiERzLEkjhgCQEWQhwLxcgWjAlFREaDFMxKhELZCYEwRpEApgkEqyjpbkVMUWQQ5C4gJpWRUMQxRqRXZRaVBFVJsEVKq5R2UIlgNGYfHaxyvBqyzInuBJZeMISsEm45k625mdIGRYkTX22QJClQpyLW2miRKbTytAIEgRVvwiQuz4os1RYKI4zsRRlGuOfQaghUqJib78n6aazlmCI5oWpOhxuINTZ2CBFD1x1nxNoaI9fIhaFnhdLmPF7zg0kfkAnyitxCAD3zgOu6//8ipi48d/zlz998izbAzT5hHIHXm+gsAuhAN+xkiGAVlsGw/wP8MG8FPKhz/CSwuLUz/9ky/urbmhJA8S3O8mAVz/Un1a5I5b5tQh8BIKSE2misMdzwiL72gHgAUxx6bm9lyNwMzpPoNPFiSYeBg1wUKMKqXZYi2sakNBcrm6q3Vkb6ugLaYscDB8sv8HPIEI39bPGJHiYCsts8qlq1acoEMgpqzC5J2nVS4G5IMaarqxxajNQGIoDqWJA8Fsl6iCECpa3ohiAOGoeLG9evQECHV8J9tbOYMy/WswHLIuHF0hKMM5NXBRoo7uLWk3ETA5PpdxlkRcPuU3D+rAp4R/A4wEe9utm27Bc9z8j0sK3BLJMTNHpeAg/cCAN70vJsLgB/Lwr9+DA/qI3kJ4p1Xdbff9U3z2698PjP3pWRr3Ml2/sdA5vgbkXiWD6xiGL4QzQVH6thxZsvQCNZM0or1YwOHi4A2tnycsyHNmyAnol58ByIHBGJUVc/y9MmzN0RZlrH6/IPtuiZWvG8vSlA7PiIom+gYQnSB0RoAKARUbY5zRVEBgSBqi4KaKyQb6pwDTca/Ox3H8W8XQvYihoqgDAWlCvI6Q4Y1iiooxonYwchVjw4+8OCPXr//V78VevqLranmSVPs/yg98aP9nm4lAF6M/0exNunvfMUzPu01f+pp9zz380MMXSvYNbdbw2425Jb6vQ5k990QAjZ40LNdtETe5Adz625iBDA2603dwC7bm1jHm4ZFy/wjfx6NAiQxTURHcocvNlnW2tZf9l6a+6At+rcLDOOcdHwfm25iIwDQmDvYGg+a07C9VwAu9JkQyGMuiYkhxGFsHBtxQdYEePyr73jXj773P/+7b9Jy/V3T478Y/zff/s2vXxRBfiPbc56+/7Lf/frP+DOf/pJ7Pq+LsR/yYLl+q4JQFV0XEFKwebI74zl2gAAhBcQ+2D1aLNMeMSL1EZEsu7dO0HuAk2VqAVV3BVa71sRkcwyWiloV1XHCiQJYDbcvcASwCiRYrjCoAtWKcIGizcbVmmYt38samFldDOC2EG3uPZtzIFhOoEiFQLzBlcGcwDGhrgtknVHXdv8PnXUPqimTYLa8cyWxfO8QLSakCIbVYGv8dUZdLpEBhFnvkR92/79xmo9/4ufe9aM/+M//85++/0MP/eLFmXmxPRHb7u7uy++9995vu+OOO35ryaU/PD5CKRmBA4ZhwGq1wm233YbZfOaue2u2OT09Ra0VfT/DfD7zZhjGfDHHbD63+3nD6alitVrh6OgI2cW2xWyBKhU3bhxCpKKf9QghoEs9pBasVitUEXRdh52dHfR9b5l+7tKDY7w5hLFBiYhQSkEtFSJ1vO8O62HEfvZ9j37WW3STz3XaMQWnQalYMX+9XqGUCiYyx+N6jes3bgAAuq7HbN67+9HmKjlnDMOAEAN2d/ewmM8BKFarNXLOOHjwAA+87wGcrpZYzBeIIaLvO8znM1y6dPno+vXr/+od73jHtxwfH//SxZl5sT0R2/Oe97xXfsmXfMm3vPjFL/b1f8HNxL9pRt7NBMBt8Wv7MVOHXftvKvydJwKeJ6a13L/psU5FOUzWItNj3n7+9uu09zh97lQU3F47TIXEW+FKb/Y+2n/L5fLo537u5/7lP/pH/+hbHnjggXdcnJmPVgC8erfOIuPZz7zdA+afPJt6B+lqnfHA+z/k3WoCyWtDT6iMwfeqBFXDTHgZ2rMNrVgeU0KIAbMYEFPAbJawSMnCaDvGLAWkEGCl+gplw1NCbdFriK7o9XebFFPwLB819xoFArcFeiAktmkycQD7DRUx+aJdEbtkmYRegA9EQKQRtUls+yzuyotwR11IYIFZ8YOJE8lqh8gVMEOOLbajZwJUsQl7CICwoOWJsT0IKuZ2nEXrTqykqKVYDkCM9jhrWzb3ElnosGX/2GS/+t8JhjFRUUN8saNIS0au5P90sQ286fSNEYJq6mEghC4B2bAHWSpkEJSh2jPZYEq1CEqxi0gVQVXrjh5qRvBg8lWugONT8pBxssy4cXyKo+WAXIGqaguMUh1zGBCiiaYMEyeJGYu+Q0zmgGzuLynFgpfVKjLsxVZiy0MzFbV1ThIEEQoLMbOPi0ejHoEMC6oKgjv9GCCtICXU0XtmHMpNzsNUEGx2qk3FQEksJ8oLCIET1svr0LrE6dIwhs+662qzgz3ptvW64hd/8QFg3xCLB4/Z/bfJ/psvZljEhBCBEBIWnRXdo4t9EtxwVpsYaKKXwMSk5g5c7PWGjYWhc8VdagEByTQsE42bgy5uAgYZQErG2GcRt/AxArGLWwIKCbWa2qhlI7A1462oOQFD5NFhp2L5WxECYoCF0cyW7B0BHBM4mWgoNYNDskwvFSu2SR1ppyFZHzG56KBqv2nXKHY8oPh7OAsxiEgpGu5MzDmr0o7Bz89qLmYzcAfLNI2MEBgBjFoKcrVckmG1Nhc4xpBGK4QmE1ZPTwacnBxZ5mAFFBFLRzCYE7Dg+DTj+vIIh0ePTQDcOAc3TzzXhLe/f66uNwp/t0J7nhH9POtv3G6BCL2ZcHgTAfCNz90IgE+Kgr9+jF73I954N16++8/v3rH/5bGLt1Vf9FapVhpjQ0Uzw8Qyn6ga8suL6FCkFH0OYddyCj5hdumfQjLRTsQ66NHEBDvvqwhiMBFRPIvPinxkBAJHjlsOr1/iicApORbUmmPYBT1WhZRiRUAXFDmw3e/dvWNORBqzSZgBe//VRLup+5wYMSVDbqsYztyt7hzJxz+N41+aUBGjFfiIIKUil4oqguzjX8iaD1TUMOIpgUPA6en6wQ+/74N///RD7/2fn1zny0e2M32Czv1FepIJfh8347+/evuL7vszz3jhC39XP5tdVrWxPF3gjrgbF97GRdfEFWgOQCv+K9rjbB2z4bnTGfxmy9hrjpyGCZ26CQk0aeY8uw+izeK+NtzPpIt3U3RoeFHe5Ejr5Lh8XdRez0gpdi2g1gno9JTqxc/m3LMmBRkFxbEg4M4nDpZt3RzJY3ebF0bbUYBozC9UBU5PTh5898++7e+872f+9R+5GP+PvP3b+y+KII9lW8y6K1/7hZ/95z/nlZ/05ks7sytDLljnjOxzzQCgj2SZ8JygeTDnXkqg2IEgCGwUnESek8E2mQ8cEFBBVCHc29y9WAOvifuAloxc1RxBKVgTEcxlLxqgSmBUIxNVQllXFKmg4HnxfYfQ21pH2xqHI4IAWguqo7oDWwNPJJusFylQqYAwiDb3/+JUHAWggWy+AAaHBI4dSi2AFGjxol4EOHiHY/Vla2Br4IOCoq2BqPrxqCIXQVmtUUTMBQgxtGoFwqxD4IAPPHT00I/857f9vR/4pz/+hy7O0ovt8dpCCHvPe97zvuv222//spTSFYVivTKBK8VoWd4+B9jb20PXdWMzjyrQhIKu6wyBSebuTyl5odwKNjElKIDlcokHHzzAyekpdhY72NvdAzNjtV4heoF96Q67krORQUoGMePy5Svo+w47O7uO3Ff0/Qx930NEMAwDYopIMWIYMlarFVbLpTWpq69fQrB2X7H5TEoRfddbwzGs2a9KHQtS1nBfkFKHvusw5AxVwenpEnkwDHDfd+i7HqqK05MTE0X93r6/v4+93V2EGFBLxTAMODk+xsFDD+Lg4AA5W/RAyRkEYP+OO3D19qtQ1Qff/8D7/5df+qVfuhj/F9vjts1ms723vvWt3/XqV7/6y+bz+ZVa7XzfdsZt/3leFt5UtGs/Py8ObVtIbALgtsh4s4y+qcuwHW8T8qYOvG1hb/r87cdOhcebZQVuH9uZ+f5EfJy+/tSdOD2m81yC08/q+Pj4of/0n/7T3/3BH/zB/+fFWfooBMAr+3drqYqrlxe4847LI3LmSSIBAmB84P0fxnK5Bge3q5bBMmd8QVrEnIDAiKkfcTMAIZJ1uPZ9h9QlpBAwSxGRgZQYs3mHRdd5MVwQRqGvgIkQvDOeQMbmh1eXyQQ/a4jzSorjLEIwb0uXzCHY8j/M7h6gpYDIHEdcAVBF6HrUWsabqIoxB5UNwcEcwCRwddK6coL34Fdxzr4twKOviC1DYzQOmROBMGYQUiDUYEHEgWHim+dw6AQ3mFLwbK7qmYe8cfeFgFwztIrd/MnETKkKqlbo0xShUhAQIVIwqKKuy3gMEAGSI1CYkUuFeFaZgkFsDoCheLpJUNRin3FRIA91I0YKIJJR2HCIeSXmCIKiFMWQC05XAx68foLjtU1aigt5okAW614ODEiuQLALWRcDZn0cu6212rmXSx2zW2zeZh3YkQHhaNMjZQdxWq4SKJrLDwxRQ60yef5LKw+rTlx+GDFN6m5CVrP6jfURk2gmWX8mfBoyVEbBkDlifXrDBMCdfeBghbvv3sPTn34F9UloA/z1X/8wDg5W7v4DHiv+swk4Kc0wSy5uxYT5ImGnm5nwV7eEvmDCO7uYxakA2SbAs53O3JxSbfJbASRbwFsRoFrGJ4/Rlt7Jb9J0YM/dBI/jrN3KyN3Mm2KQO4+b01iAosXH4Ma5x+78syuGeDaQCeXVO+8bUjTEBE4MrdnyBmP0GElz2MJRpOzXSxBskV/NTcieHSgu+OdcxvxCANAi7mxk1ADPEWWoGCJU1Z2N1RsGCAgpOa7QD7LaeyjZHi8uvjenbKkVw8mAiupdxB3AwMnREi5hYFhXFCmoAIqLgKfDKQ4eWuF05X68g7Oa3K3Ooam6tpo86eBc0Xn/XA3ulu4/3EIQnAqGB7cQ/QBgf1s4nD7XKn+vvwf0uN6+P8YFzsfjdcPOM75p52l3/N7ZYv5sc8s5VkM2BTxyv3Vkc6g2vB633B2oF9cSNpl/6khs9oYbm2NIQ2Q2bCDxiAdnphH1KcVEtnZNACwbLBCjZssKDmlkiiI61lq9aSE6F5RUrRGGNm6dLgYf/9Wyvjwb0Ma/NdEU7yYM0VBiWsSy/4ghQcfrmuV8+l/EFPxazf0fXcj3G9jodsy1+uPEW5oMjlZLxXo5uBPS8cqBcXR4+o4Pv/vXvrOuDn7wY17ov8WO9WN8zj8aBOjj8eIfz+N/77mf8c3PeulLft98d++Zm4X9xt1n7jbFmErOvEF3N2wnkWf/YXTlTlGfUwGOmnNvUgho2ZpNiIO7Dafdty0HcHzuhCJB7bVbjrrjQlUdOerorxiNVtLWVKOY6Dl97Tit6UAnCFF7weY0VNn8zq45rbt3gsBQjK7J5kacLv5BMMz3GZyp4wiJPNfbjvv6gw+96xd+7D/+2ZP3/cLfflKN/62df6zH/79/30UR5CPdvuy3fvo3f+FvftnXPetpV+8WFSzXa0PVVQX3PUJICFBEKmAvjquY4AdvtIlkObwp9mBOPo4UyoAKg4RAyIb4F58TgJA6E+pqzshlZWtt7kDKQFGbY3u+NqmAWMBKKMuCohmI5sQlYoQUfD7gDX0hWiZxNeFdvJk3JqPgwO/DtbRagzXGKhOKCHLJ5uINEUwRVCqoKogDtAOILZZENaBQBWkFcgEqQcBAF92V6NcuMuKPxbz4vd8FCAQjBuRccXz9BLkKUkroZx2EGf/j1z7wjr/7v/+Xb/svv/DLf//ijL3YPprbc57znG982tPu/P0xhrtrLWPz+XK5Qi3VkLgwcX82m2F3dxchRSPojIjL7ow7Zoriyzkj54xaq+fkmUuv/Tzngq7rMJvNvelIcXJ8gus3buCha9fQdcmzBgld32FnZwGCzdW7roO6mWFvdxcpJRyfnKBW2ycxY1gPGIYBgGI9rNF1M8xm5tRbr1bIpWA267GYzw036nODPAw+n7B5SXMXNaIAQBiGASVbbmDf9SC293X9+nUsT09x6fJlXLntNsxnszOCQc4Za7/Onp6cYDUMSDGi1ooPvP/9KCVjvrOD3Z1dXLp0Car6S+9+93v+7AMPvO9/uThjL7aP5vbmN7/5T37O53zO771y5cozp8LftmNt24F3npNvisa8VZbftmC47f672T7OEwDbtWZbAGzjdXqs52X/TeflOokG2X7dqUB53vFsf2btuNpxTI9tW+i72Wfcfvb+97//nf/0n/7T7/jxH//xH7w4Y28lAN7+bFXYhO+uO69gb29xJmvhYyb9eW7Ogw9ex7VrR457qpYxJcULwAoGoUJB6h2p44nQTswAJluEz2ad3VCZMI8BKRJmiw7zrkMK7MoR+VpUPEewiW8EJkGgaDl5EDAYkRlgw2RVLwAQArpkodgSAhKA1MXNya8KEkXqomf6WXG8zW0hZMg+ZV+Qs3fFMyIH5FJQc/XcQBfI6iZDZ7NMt07cwCYsSTFnHVscmBUlXUBEdZEieLYf2IQktzqFQBN1gjc5XhaCiDIMqIOCWEBufaqDFe0MbWhFg1aWMNEug6s1N8YUATb8RwgErYphOVhgeCAwAgRAGQo0AlLNEWCWo4r1sqAKISZzHtZqGJKigAwVGQW5WCEkl4phqDhdrnFwdILlupoTsBRDEYhgqMZaZ9bR4RkImPUdYuCxADJUE43dFOFOCHOGRjZEbNU4ZjyJ2pKQKYw1TjiaRVzpG4WgCcbMUKIyYkLbBZnIPgN7vIxCke3bhMKz48rGxHp5HXAHoG0rvOAFT8POpQWeLCpgCMCDD17He997NNE8HqP7byIAIgF7mCEkYL6T0Hdz9M386ONgzP3zUnpDgqICO7sLeAl7xEwqKkoFYuoM6cN1sx9bryJEE/9Um5AXkCL7Y2Qcu1bgZ4gUQwGz3+iDu/ByMQzwKCC4bu/mz7aILwWIHRAjGwIzVwR3PVvGKYOSuxNrNYEyBg8CdtG5ijkM/bPIFSOaOAbDeyoM1VtrgWi1wHAYvkeHbE0HwY7VMkYFRbO5AohN4Gv7dTcjEEZHboyWFVhzHc2tRQTVHQSr04zlcmmLrhhA0ZoS1hlYHi0RAAwoKEbWxdBEwNNTHByaCHgrIe/MudQwsucIgNvPba7Tg4P98bkHWwLgraL6bioA4hGEv+0Tf3sfEwfg655zEwHwSZBP9IS97qN9YNj9nNmdd3/73pW9VxGEqk6Y+Go46JA6RPbudWyaaSyD2GgAKu6sIxPQFZ7H41cAKwi08d+ce2xCItn4J292CckaCKQaypNcBICoFeoiISaGlAIpCkp+LfFCOzk6FLW6QOnOfm24vooQnE7g486mWsHucTHY/bwIxIshIUXLJsoCzdnRoXb9a+J/lerj34TE7LhTCoQYzRFRq6AURUiMwIRSzJEPYhQ1LGjggOXpGsvTFYgsY40CgQNjyLp+8AMP/qOj973rKz8m56U+OYr8eCwC4Mf5+NfH4cFx91mfc/env+bbrj7jGa8hZmoiGzm+ywprZzE3TbhiR3m14liLEpjOAdlzfjf73RwbOdZz0527QYlu9gEXBcd628SZtynCNVRo4CYCTrL/2mIbGwLLVFBsZBWZ5pN6sxrI5vctC9AEOcsRbPmB0Z19YwGhfUa6kUzbPPXMwr8h0X2fgI5oUxP/yhiY3JyFeRjW7/r5t/+vv/IT/8dXfyyFvifz+P8PD1wUQR7t9sJ7nvE5X/EFn/mtr37hsz4zRqWhkjnTa0VFQa1A6OYIHJG4Iqhn+ClALIhBQaEHhMCSvQGwAweFwsgBRBFEEYblKZA8QGD4zhATArM1nq4HqGbDfyBCxe7ZHJ0wMLgzPipiUtRhDSkAumRr+VKhKOCus2aAag1JnAKYA0SsMVW1IgZBGuf/iqoAU7B7t6P/axXUbMdEIUERIYOC8mBzjT7Y2oMiqgoGLagl2+sGNjJOCAALmB0FnNWuh9EzhNr1kwMKCopUMEUcH57i+PAYRMEclTNjJB8v6/rH/vsv/9D3/oN//TW1Sr44gy+238h2++23f9YnfdILviPG7jWHh4e0Wi3N2VcrTpdLrFYrc9bNenQujPV9h9lshr6bIXXd6ODv+g6zfjaKW6vVEiUXn4pXw2F6ht/Ozg5m8xlm/QxDHnDtoWs4OTnBpUuXcenSJZSScXh4iOPjE5RSEVPEsB5wujzFlStXsH/71VFkSylhsVig703A6/oOq+UKh0eHgAKLxQLR8/dUBev1GiBg1s9dwFsDIMznM8znC8xmvTfiFuShAATsLHbMnbhaIefB6VvVyoy1Ynm6xGq19gZiW49cv34dq/UKOzu7eNodd2A2m2FYD6ieGQqPY2LeIFGhwHw+x4c/9GE88MD7UKUieJbiHXfso+9n6w998EP/8Off9vNfdXH2Xmy/0e2lL33p57/5zW/+089//vM/YypUbeMqb4bfvJkjcDsjb/r7mznxps0Dt3ruebrKdo7fdhbgrbL4zhMSp1jS6THHGMef3WxfU0fhVABs/00dgtvP2caTbn9GpZT1T/3UT/3QX/2rf/UrLs7em6xpN5oO4YMHR0gxYDbrxs7Tj5X4x8w4PDrB4eGxX/RlRCmSIyehDblHqGoTbcv8s064QIwQaETc2OJQkVQRQkCfzA2YPO9v2mlPHLwb38rzDIUqw2FyMFq+/Z7gi/8YwZ65lToGSXHWdoCsq2UBsuE2E7N10YGwloyyLuj6DsFzLlKcQaQAQqhDtaxBMVu/oQQcKVkVCkFwEagtpqtLP8yKwgSuVlxXX6RraZ10Vsyv4rhPwAQvOIay2OJENSCQ4UCEgSIFXE1J1JqNGe7vVdVQJARAmFBRQZXHPBRxXFhgy1RkKUACtDJqyYB9bKhFAA4IJChQRPZspAg7HrEcQ4Ki6xh5UAS1fCMTUdWy1CJBqxVLigIxEqQw5osOV1Sg5RRSBQjmPCR/XtECEXY3pRVURNTwglBHvpIVNcVDz52lro4jDYAdv3oXtLUzeg6gdX2O48xFF2lCkL+mwtC3hgttklJ7Ho/noJ3FlsFkxZwweVwr8Pi+H1Y0mOGdDx3iU2JE3z85UKCHhyc4Ojp69ALJzcS/iRCSASwygAXQzRJSSOjd5Sew8QAz3o4oSwaAYYWwmKGfd4agrBUCD72Fm/9SMMcdV7T7Ejf0pzv/RkERm8xQQ+NWBPI8wOAZeS7ecvu+HLEZmFHyAJaAggxuB+s2w6xiDQodIAQMLdsnpfZu7JwN5tAjtdwdHjODqpuP7HwqFd4lbAv/KeJTGs4ke1ZRMFyoVIHkPJ7UWhlggQpQaracr0nxkYIXI6tlhQa2fEOuggIguA2TyK7NkcZDQuoCarVjhVgOo5YKRsDu5TlOj5cI1dxNhYGIAoEtdi4BwMrUtNX+R3qinX3CwXla28HmUQcP++UjvNzBIyiE+49wWOc5BrfvtfLkKET+Rl7oiXjNeOVZf2Xnaftv7VK43FCfqpsiOogRO3fykd13x4MT9S5eHh1tBLZOfVJILSbWEY84YW75OBB3A3phG4RAhFzNUVCKOcfHroJA5pZTgKOJh7narIVi8OK53d8FhlEfx3+7F6m4q4b9Pqx+3zF8oV1C7KCsk7BCPPuUHRVUqxhKFL7gEJ9/QSwnlcyF0HDZHGxwixTkdTVBRcwBUItCYzjjoArKY/NFSgHSR3gEIaRWlFJBxP0dz7zjd892Fy/60Lt++f+h9eQnP17PQX2cdnQx/h/ddvVFv/kvPuOFL/yqvu8vcwgm7Pv8i6i5+9jyMRvi1+ddJqLZXKHlebI71pi9ydCFNsNjyjiPx9Rh57jOtsBtSLEmgk2FO2rzC50QUVozXhP3HX0fHFO/YcnbjgLb+2mOQ+88a4e1tV5zPJA3MJQJSaYdMzNGobBt4VysD21QoEyTJrmN43BsloSOOYI6ds0ZXjTE2H/Sp73kq6487Y6X/vy/+Jd/oJw88H8+Xif6x834f0IH6SfO9tVveu1f/oLPeNFX7O8tLtcKHJ9my7dlBoOBkMDR7mOBKiLVEYUHITBHq0GIzbkDB4RuBpBhNaV4Xm/kcf6vwkCN4KogrRBZQ4ShA6C5mLgIAnE1vn2wxhgZfLxFeE6gNcSBA5ijowjgyPAKJnjOt4LE5hkkhIAA9WbEWlsWaRuLtn5tTYI6WMMyh86Kb4NFeVQVBAi0EBAZwl40VELgzqJcggl74hjBWlrEgrkaNbB1UKp4/Udtbey0kr4PkEUPteBBywoXwSzF/vX3vfitz3nG1U/+vn/47/7gL//6B3/y4ky+2B7L9mmf9ml/6ZnPfOZX5Zwv3bhxAycnJyZCAViuVpb7FyN2dhbY2d3FfDZDKQXDMOD0ZOk4XGvsY2/+Ic/Gu3btIVy7dg0xRBPgPE+vA6FUE/Rms5k59Igw62dY+Wuu12ufixAuX74EDt44Oy/Y3d2FQnHj8NDWvlWwXp8g5zy+jipwcnqC4+NjQM1hb3MDQdd3EBGcnBzjw8OHEYixmO9iZ3cHOWfEuAZgIuEwDCBm7O7uAkRYDwNW6zXKMPgcxuYry9MlTk5PDC0OxsDmUpzN5+j6GWotePDBB30/MFGUCH3XjfXCQASaYSQazeYzyx+sVk89PT3Fjes30Per/urtV7/itZ/52hf9wtvf/n+/ceP6T1+cyRfbY9l+z+/5Pd973333fUXXdZfW6/WZOeu24HYeyvM8Ee88TOZ5It6tsKHb+X/T9cH0tbYFyqaxTEW0qZg5FQa3xbvpti36tdedOhS3j+M8cfGRRM9tAXPbfbgtEPq++te85jVvfcYznvEpf+fv/J0/9M53vvMnLs7kLaH08u13KxmXBVWAFIC7n3EVXRdv+qU/3uJfCIyj41N8+MHrliUhhp1SCFTW3oHKkLqGqEJ88crcikTWYRsCo29YKwZSlxA5YBYJu7Mes0WHFBmRTR0hpbGrlgOhVAuYT8mEvcYXDZ7LxtGK/0wBVd29EhgpMCIxSMU42sU6aUMXDAFWrQDInWVonBydolTB7u7cJwo2ka2OCVVxdJgKVCqEAzQbBpPc9TUOfs/XsIyxiMBNyvNCRFXPAbLPzYqWAZqtA7F4ulaAIoWICoCiTfhj9Dw/KVZkEHPGCTEwFHMxxM6+J4K/VkCuxRYYfUMdWDGBFKhSHJ+kIEQUssWNQMG5Wg5b9ItNNNxBdaQQtKLWgEELIhHKUlDKGiEyiliuUC7VMANSocKoBOQqyINgKBWrXLA6XeOh4xOcriuKCwgCQdGGMIxjoSVExryPJuQRQSpQhox1rZ7jwK6u2OIsBAtartQZojEwlKO5McizGgJZnkFDiJIrgV5c0uY4Jc+bdLcgOaLFRBQ+I+tZscTcodMu8oakMgToGqfLqwBWwP5sFBxeetfVMbD1Y7GFABwervHOhz600S4OcAsl5BYSzUQkmc32kQDM0wx784TZIiEFE5UBgOvE9RciSi2QAeg6YLHbm9CXzekjKGCO6Lxjtrbsv9ghcEUzFNuN1Z1pfn1iX0g3N1vO1TI+QwDHBK8vbi7SIqCGA/bcSzPxVRStIAQTHwM7QgjjNQ/j39nESIVhhP0XIXmh3cU89usbAERKQGBUrxQzuQDgOYCGQgaqVkgW+10wkaG5YpugaJhkbyDI9lp2jTCRkNhyBkQqcinwsoqZsgFwx+N7UtnUsKoCks3dWKVCXJitPo6JgdB1OD0dUNdrgCMGAHldMAwF65pxcpLx4On9OFrhEV2AZzCgMxs6q4ODWz6+/d/BKOjNgIOzY+4j2m6GAn0k8fCMW9AQoL/97seGANWPQWHxiZ6NKABKl79kcdcz//Rib/FigpqwXdVz8xhdjHZ99yziGOyeyxMri1bL9+DAhsFSK7oTN7yN5WKGGC3Lh8273y4CbNV/kDtzpSqI7WfV8YFdiobO9XujwoRB1UnOmDt8zMxvyn+IYYOWFp+n0GZyDzYnQGskoYYWVxlzvkTMBU/w8c+GI4bSOP5H7DgHSDHkr03trJDJHEEhQrQi52K4U5/7CGzupJNmltasJdWyiksxfHOtxQuJQM3Zshj7DifL/MEP/vKvfmM5+fAPPJYT60lf4H+MuN1F+ii/nH5ijf/u6r2/41mvfNWfunT71RePnbZt4UzbXb2bjD7DgNKZPI0NCmuD0TRRjs5k65Eriiri7kLaCI6TvI22P25YUb/PN+Gs7dEe7/diz9ezxkQaEaDmyjtbGJgWBW6WB8LjegMT3OjGcWhOPncAmqXYYwlsjsDMNndyVCidWehv8J9nUEB+rZoeUq1yRkBt86f2nOPDow/+7L/78W88/NWf+4HHcnJ9XAh8jwG3+x8/eFEEudX26Z9yz+946xe86k9+yj13voRJMawFq7U4Mi9h1nfgGJEdBR5DREAxWogTrqkSYuoQOjZiiyoiqTnlxSIpRBgxdUgx2XqQrFlAaoXmAZpXxgnQYA05bIQXQ3IDXZ9AwZpeqxJAwYUyBZRNgFTDiAZWQLM5AJPl+0IdU0qE0NaabMImhTi59yq0FkCt4VeJjHqTTdRDIFTYHKllBEIFyhWckjWpZrWaAVvzI2AZxAgRpWaUYQCr9WJqJSBGUB9BVL2S4WtnYkOHl4KcC2oBah5QrByBslwhpYC0mOFD15cf+v//s5/4xn//X3/x/3dxVl9sj3a7++67v/hTP/VTv21nZ+dFp6enODk5weHhIR66dm10vUi1jDoiwm233YZLly9jPp8Batl9y+UKi/kcs7k5/oZhQK0VKXXIecDR4SGOj48xn8+w2NkFtF0TCnZ397C3t4e+781tKILT01MsT5fW5BKi1T5DQNd36FLCej2gePNdKRWny1Nr1MvFGqpV0c977O3uYT6fY8gD8pBRakXveYRwBw8RsFqtcHp8jBAjLu1dRuwSVAQx2ZpmuVyi5Iz5fIHLly9jNptjuVxivV6jlgKp1ec7Vs9aLpdO9yk4OT2BArjttttw+dJliAjWq5WJByHg6PgYeRiwt7uLnR1zLqoCpRakGCGiODo+wsGHD5BzwXq9Qt/15iAcBgDApcuXwYE+8J53v+eb3/e+912M/4vtUW+veMUrvvDLvuzL/sxdd9314iboVyekTV145znvtvWTbVHukcS7bYfgzRyE21mANxMhzxPPtoWzbQFwup0nek6PY7ptH/OtXmvbBdicf9NMxfMeN/3szhMAp07Bw8PDD/zjf/yPv/nHfuzHLsb/ZIstiN4WhNYl8sAHruPpT7uE+bx7wjIBW/dmYMbh8RIHD14fu2LHxbGKL3YJJJ59AR2dZ0a+qi6cmBPP5qSM2CUwAykQ5rMOXR8RPYfDaunVUBNo3XKEUHyiCgWTjBhKW9tHMAUwV4RWiYYiIgBVoEEBBECtwy6lAPFBISLQCKAULw4mdD3bw7PADDu2IBexhbFIRc21teAZhkMUwd16loGjUHKHATOEHAPmDb72At6VFwJYWrHQwsIFavhPf80aXPgLCSLZM7sqZK1AcgzPuvr7Ipvclwp10ZHEOvoIBA2eZ1IVJGIiZtOYiikPykDigMwVCQD6HpoLyqoYijMqNBEoqzuhTFAp6wYWVVS1PCF2dx4pkMXywbyaasi1ZBDXGQWAelwhoMoxyqoYbk3J/Xx+8WEexY5azT1a3GmhnsumXhieFoSqf74h2T7UHVfW4SlQR0KOHd8ASPkMlsnLPFA1pCeRZUSpKpQ2IuG4C22dGwGT3aJlwkzKLKZgYHYmT+wBPISnPe0qFovwhNNAAz764t8M+8AMhuJNMyzmCV2fwIjg4B5Ki8Ew0SlEE52XBTs7M8zmHaqjfuwWaOJfCBvXmRXaAgIs1646jrPhP8mFzcYF1TZWtNrz3Rao0sa/fx5siNzgCEzxTL5WNIvBvqNSKhgVrIbZy1IRW/YYrEt3dOlE79xhHl/LGhmsMaE0hBfDigF+IME770fxreYRFeqnHTjA3dh1dKQyWScywzM5HTdKHAxpmwVaBYQACgEpBn++fSc0FJS1IPYRoOCIYr/kOpO04QWLY0ItPByGJi5L9F2H2u1heXKEGCyyVRDNumlLPWB1P44mWtnBTbS3u3GANNtHXm0evH8T4bC5ALGPs9jO/XNEuZsJeOepigdb+3qY4Of5f+fuY1P1v5UD6EmP7vso7OBWD0+3Pev7du/c/8rZLO6UUiHqGTSwRo7o41/dRRfYznhSHe/bpIQQrCmJg+dh+fUd1XN+22PJulpZNwjoSIyidg8vg4lcFIMPRHXUns3baHTiGKozcDD3IKq5+MVQ5Qjkjltz+LRsMPZ7VtFqhQ2y63ETHoILFtIQIrX6YThwnBRMhggTz+5RFz6qn2hVxfIFmwCqDC12zyYVcAyIicb3xwyfAwjiLHoThYK1TbnU3QTmdi/ZsoZCDJAakH3B1nfdnc984fO/9wPvnT13dfDr3/ykLO7rEz9eLsb/zbfbPvm+73nWS170dSl1C0wX387aVqUzIlQT8jiEMT/TXLQblOaZIoGepTOYGZA3pIYxI9CbdciEPzTxvS2L3PFH3LIAeeLmozErb3y/4+Kfxv1PO29bbo+6yN5EPfU8z+lqsAlvIfBG7GO28T/J/pFRyHMCyfgcx/p5s4I0YdI/OyI8TPwbRURXPVteINFZwbWhQEUqdvZ27vz0L/i87337T9127/v/23/4hovxf7E90vY1b7zvL73htS/56tsudbtW/DOnPkNA0WkddtMGiaJjAmsFVKwp2SNJQjQqiCH2CRBbCNRsc3IVc8FZblbxSD7L7iOxzOvKjLLKKEMBdck7YGS8h6+Gas1F3gxgePxgNQIuAMk4R5AUEJMRCMRF/+B1IFWgkCIEQvAVMJNCPQKEqkBG+lC1ZigPG1Emj92w8RqJ3XFYUVRQJIOhqMLQqODIIIqQtd23ubNrZ4gJ5M5k6hl1EGA1gHoCpWj1FxVUEDRbg1XgCA2CYeWvHRgZjOXJEsOwxpWd3af9wbd8/vfedcdt9/69H/1PX39xdl9sj6L4/5fvvffer2bmnePjYyyXS+ScUUqx+SYBp8tTIzqpIMY0Nu6cnJyMmdqzWe/ze3LsZYRUwfL0BLkMCDFgb28PqeugIjg6PsZqubLmcQ7oug6AZeW158eUcLo8teJ/DBiGvKFqEeHk5MRqct5os1qvcXR8hDysEULATliAA2O1HrBarRAjo0vJkL5SMe9ntoauFTFG7OzteZ3VaGrCjNVyhVILSi0ACGFtQiIRIw8Zy+Up1itzSwUOWOwYGrSUgmG9hkLRpYTr1w/Rdwm7OzvY2dnFbDaDqmK9XoMAnJ6coksJly9dQtf1VmetwT+TJVQUu7u7Js6UjL7vcOnyJZRa8eCDD+IDH3g/brvttqd/0id90l/e3d2993/8j/9xMf4vtkfcvvqrv/r77rvvvq8MIewYzjY7GldHwa3NTbfFrvPMU9ui1SNl9m0LZdsC4yO5Cqc/326km/57WyRsYt/UATg9lu3X2j6W6fvcPra27/aa07+3320aHPlhx9fExZGSco7gNz2OliO4s7Pz9Le+9a1/6Y477rjnh37oh7754ux2AdCaunizCKWAIQve9/6HcOcdV7C323sH+OO7RGoInWs3jnDw0JF1y5MVmWwdKr6gbgl9vigGQaPB8kTEoZrmjIJGL7ybWBWZMesDUm8YjFyyZ+t1kEjmpgvefS/UVuFWmKbmkFFzm8H4+IDlvlVkdOhAVRyvoZ4FFEHJJZxqVEaODK1iDj8lL14Lyqq6aEkbAVOrBWAX+xPVi+VtQPmBVVWb7BOjioK4+GKdHCcGFNjrUREoApgVUhTiBbUQgnXdASiikDwgpYCSLVvImu8qKJiwWrJBL0kMW9pyfWwkW26ffcDO82cZswchFeRIksIFksVEPniIcrXvIoLBnDAsB9Rc7fN095QUMrGPFZILiAgpJiuYEEAhInaEmjOCF2gYQPXupgQBiNApwDvenVWOsFxZd1EkxdAKniLuwmSsh2Kollb0jAGhGHZRSt0kmXjxxDpBK5i7EW0EiZ5eqZ4lZyUNhYyFGStutkKNiZ5Vx8S/rYs/RrXQMiPrxPm3sYK5BxAjQ2VbdHDB7eDgIbzgBZdwaafHE6kBPnj9BO9970PmjsKYsvZR2VICZnMg9MkL2EvkOgeHCAmwrl0X6eS04NKVHZP7SvUuNqdspjiKlS7HW34Gb0QvE/RMgHMyp50DMCcgpH2XYXQdWj2ven0xjBhRQkXO1URIASJ3YLhAhoAQgFUegDXMZTyheXFMIDHnsDoyWf0YozsDmrDnIABIzVANiEHAlMwl6DhAVHMlZ4Mmb+qMbhustY7FT3Vsrfg5V6gAKBBlkBg4lQjQwKgFiLU6JrV1+rJ1EUdBqIb8DJ57KjUDSD5emoJrGYYq1a4jESAElFKxXg3oZx0uXd7DQw9eQxdn6FwHkwDs7SQAdyPjftx/cFZX29beVueJczdRDPe3H7KPjfuvie+3EvlutrObPX4ft3b+bW23vLfr43Gn/zgQFKh73uKZ9/ytvauX7oPq6C4l/x+bhd4c4SMuT0ecs47Fe+v4t/xgMrEP7riHZcgyPEt3LLCbw489Z9aK+4qhVNQiqFWRgt8DfPCFAKyHDBX1TA0rQiDaeCABtFZvLlCou2sDsRfPbPiw47XapDlwcKpBsOYVv3cRCEU3WELAjhX+XBMlBCIEEhv/dg2oAFX7+YixJiiZYBCqQrnhzRvy2nKNIFboa+K/il0rRK2hxz50KyoaHcAQqUg2/styjX4+m9/9gru//v19evbR/e/5qo/GCaVPtnP3I9zvxfg/Z/iHS8+9+7W/9W/t3/3Mz7Lp28ZF2xamY6beBN85WXmOfxBNUJpEE8FPRlw+TTCf5G685g7UCYqzvUKpitguPE4lGRGYpCPyM4xuOHttkXYMkwwP3fys1OrITUf8eTODutPXtAUdz5uNIxgjhrO1l9Vx7mrfQmC2zO72sZ1ZuMuYociTAsIG77n5DkZXNJGteba+afbXUWnz8AbUB/pZN3/Zfa/+Y7O93We9+z/8H19xMf4vtvO2p92299w/9ru/4O9+2r13vQYEDOtiDXYcEAJ7Hra56djPs0gb7L+IQjkZdYPL2ABIIoDY2qu2WxYspkSp1Sw2DTmt2UBrxjBk5FKRRRDVCjekTsUhy7QuK0Hw+oKIkS+6PoFqgZYMlGrZ2QgQJJBEEFlzEREZaQDmrimlIsWIxGpNNyEAsNqDiq2hbS0LbLAmvv70e7FKhRT2hOOIigHQ7Pd/a+azUoE3HQyKkAByfCrQI4QO1OWx+YmDAqwgLVAwlAQEi0pRquAuQHMBqaBPQKFozqCjJWZ7O7O3vP5Vf/TKpf6u7/sH/+4iF+xiO3fb2dm557777vvb+/v7963XA05OTnBycopSsuXSeV52y7trTTcpJcxnM1QRSK1mLgjszWkYHWkxRhAzSi1QBbrUoYY63pP7rkdKHWYzc7IxMdbrFWopUCjms/nYkFPF8jevX7+GYRhw2223oes6LJdLMBses9aK1ekJSh6clCHInjdIZHl+NCn6L0+XUFUs5gsogL7vbQ0gTVwPVj/NA0RlrLkNOePw8AipW2G9WuP46AhVDMe/t7eLw8NDJyeQ5yG6uylYE3weMnSh6PsOq+USw3qNyIzbb7+KLnWeD1YmZACvjTEZHhVAP5sBREb/gX0/eRjw4IMHYOb53Xff/Uf7vr/r53/+IhfwYjt/u/POO5//B/7AH/hbz3/+819r+Zwm/rXxsS2kbYte54lm08y6W+Eup7SNqSh2KwTotpg4fY1t7Od5wuF5giNNSCPb73G6j5vlDE6Fv20BcDRBnUP3uJXwOXUg0plscpzrWJwedykFIYTFG97whq/f399/zl/7a3/tKy/OdCAqNovSttBia2rDAx+8htuHXVy9bde6uKWJCB8dR6COneeMdSl48NoNHB8vnavviz8XQEDieBuFStlw4KzWg2pJ2x6kjRE/EZ3vFyBYdAl9143ds1VaCGJF8mKUSMvvUQhZpmDwLA1mBqNa3o/fgNhVgYAOKTm+q1hhz4p4jsGAjuIXR+vKocBW5BJYV68z9VvuRfWiHVx74xi8MObdrwpDADYsF1pWYgXUWdluQaJaHCFqXUE5rxGYEaKJpJYLIsiDYc5I1TrxYVlExIQ6FMMIeoe+1IJADA/FgzAQEG3Cz8W/J0Cy45RSQq7ZMr0swMg+l2Ah5AQ1nGqtyFkQBkGcJcRkIqwFrduiw9YOJrYyAmJHyLl6UZHNNUUAIqPTYEHqxg1DYEKtQBcdZxgZzMBi0WG/7OFD9QZWQ0aMAXG0NtexWlagOF0PmHfdpnBrV7YRY2hGi01B2M5XO58Vm3FkgMVgGrx6Hpu/Bzv1FRDv8FZ27IrfbOA6tWxcGuzpTg3PSKCz6DQxN8pmm910fL7znR/Cc597FVeu7CAEPG5uwABgqBUPPHSEg/uPgP0Z9l342z9wHeMjzmezJ7V3lwDM0gzzmNCMp7kCfQUQCrpWEB0ADgU7ewsoKkquLosBHZvY1qIX25lBCCYA+rVG3E7IHNxVh1E8tOJ/K4ZvvnPAcveUwmY/4/9hFMZitCxOVWtKqABIzIUsLSIy2JgwDcBwodXLYOzin7qYGKK5mokaPlTcFVIhxKhcUQcT/YMX3mvDiVXP6YuGHRMf11NpudaCZpumEMdQxKm7VQA7cLEO4zH/UzJCl0Y3ooqgDuLZRwylbOPCKyykAEJF8XOfebBclhhQh4phNSDNOly+7TbcuHaEFKOdfJ3hXudIuJrvxurg/oeZ67Z18v2Dgw0K9Cai3ZnfHhwA+/tbD3kUIiC2DmBb5LvZz3AT99+WePmEZIB9HGEBKe399r177vmr853Zc2VsaLG5SIrB5iZ+/WyQPSJDdLNj/6RVx31xixGh6QhML3qPxGbdiAJgRoiMVuuW5u7x631K7AK/IQjFi/QeXWrFN9icSkXsnkHWnc/Usrwso1fUxmsVjAV4rfafqNg8BSYacjDRUEXczePNWWKO4iYm2Pi3969kmcWG92OY9Vb8o3G6Adn9DGRFPaom/UvDIvfR8wHtulqHOuZ/NeK22YQdhx4Upd3veFOEkWzjP84iP+1Zd3xFTPHqQ+9+55ue6AK5Po4n9GN56uM+/j/OsMBh75m/7Z77Pvt7d69c+U2iishhHLtErZkQZxbIZxa6vEFfhsDjwrU5ABqW05oD2jxfXCzgscmxVkEM7BEH6otb9maCjVjY5n1TB6G3E5gIMBUPRzffJge65RG1wt64KJ8ImZbpV82R09YowOhsbBpAw0000RIT0VIcFaCbrjSbD08W8zrFXrQvV3V0UouIHz9trkE+p2/uS/G5siGQcQalbJ8R8ws/9cVv7eez/bf/8x963ZNSfNMnx1h4Km6f+pue/dv+5y/73L/y3Gfcdq/UgvVQzOUKgNRwX3FcSxXPoWOERKAYzN2PYuM5JoQQTSis1Rr92JzDSm0kNKS+QLTaeryLDXhkYlewdbpWizFRJc/u9Lx7d9GGQCCScT2PIkBSkLvj4Fm8ZKgM+z0TxLoXjRJUK/JQQMHGHEdAM4GkWjNAKTYngEKGDAiDYrIhJr4GJgaColZBzWtoJVCyz0NCcSFBQMXiLqoYqpsF4AxUVGjx+/hcQdFu8SoFsgZqCSBlKCsCqc0rahNMs7kKVRHDGoECUpcwrDJWR8foLs/5C1774q+4tDO/+h0/8M/fdHHGX2zT7Rl3PeN1r/mM1/ylS5cu3Xt6eorTU8v6q7VYE2Bgc+ulhJwz5vM5QECKyZGZ5C44mx90qTNXnbtl25yglIyjo2OIVCwWC5+LKWKKVrckc/qFEFCkGqIzD0ip8zqszedXp0ssl0tcu37NhEkAu3t76PsOy9UapyenEBV0fY+9S5cwrAccHh/h9OQUMSX0fQ8mtjqpKlbrAbUUiyNhm4dYQ43f2N1xTIA5ooaMOI82zxCxOXohn99XnJweAyDM6gyL+RxMjK7rkFIa50bz+dxrnYr1yoTO4+NjHB4eYnd3F5cvX0YMATlnHB8fYxgyVBVd16HrO+wsdjAM602TkWJEi8/nMwBXcO36NeQ84PDwkPf397/ila985f5//a//9Q0XZ/zFNt1e8pKXfP7XfM3X/NXbb7/9+avVakR+nofOPE8IO8+Fti2i3SxabdvtdjNhcPraN/vvZuLcI9Ecp6LjeUjN81x95zkIz3sP08e2PPQp1vO842vXiO3HNRHxPPH1ZphRwyKDX/Oa1/zunZ2dK3/hL/yFL3zKC4BWSPVK82hd8ag3EA6uHeP4dIXbb9vFzqJ3QeGjs1mclOD60RrXbhyjZLGiLNlkL/jicgy1J+sQl2JLUKbWhj7BgZLlyVihzgpoiQmpi+CYPE9DUF0Io9gkroiKTfaUiXDRCtJkxW3WTeWJgotwYARmxEiQBmvsGKzWKShk7rjgeYEq7rrzLECtrVoQEfxtWLB2+5DIs3PsZyTYDB7vrCUSY+LD0JeohtZiU43MAUQEIIBEEAMQZr0hAVs2CRMobBAiUQnqmE8tBW6WHJ0L5JOCqgKQQDJbPplWP4a2GLdAcBM9C+ATfSOlNHeduSuM+V9BUKRAqEVRxXBksScQEkQKarag8pgIsWWENZQmFEMBQiCId0yFFMDKyIN1PVlHlksPHUCZsa6KWReBS4yhFnzwoRvOGQ9+HjZhw/6XcwVpNrRr1VHAbW4qgN1V1W4MFYEqRG2ipeTMScXZ3BPQpDtaxyHZ0EdtvJJnpBAajsqEPdUmNcn0idBRcmzZKo9GxJ/hve99CPv7p7h69RJ2dvrH4RJU8eBJwdFDh66RzM7TKYCDj0wDnGozaWbuvxATEBKAjFrt76FzYQ4RQ11h3s3Q9QGlDmevVQAMOmNin51DE7SsZ/wpgDTJT6T2WKvtIzAju2M2oI4CHxDAEdhwSE2k8zW5ZY9GcxTa0xw1C/i+AlJqONPBX9uwmMKb7Dxz1AUE3rw2BXPWWN5WhROI7NsRGfMDM+oZsUIct1krnO/PKA05rEDJGZBqmp8El3oBTl50rDaOiQHWswxxgmNUq2erRkOdSrExYG4Mfy0b1P6xBRBM3FT/LK2IO0AKkIcKjsCV2/dweO0IqQco22vOuwRcSSjP3cfBew/ONdQdbImA2zl8+9uPuekZ2tC7s0fOADxPCNwW/g7OUSun/97/6AgATySi74kqaLbXCYvbf+9t9zzrO2IXbq+O+jB32abArO5MDe54M3yd4yzZBMAYNtdWdjy04TqtAG8Ff3eH18b7Y3+6u/rhY4OAUvzx0ZBiqC64kWf1kFEEIju0unoDApmLiLjljdlYptDmTl7EDwwKG6e6e/os36fdOVRRtD2HABHrsiVCrbQZ/9kQ2loVpRYjIoirEwig1PCjAMmm6E9jN8WGWa2w7uYYGZysi6F19jY3lvuQgcBI7Z5O6vO74HlLlv0rWZBzRYiKO55x+xuYX/hvP/TOd34RVI6fbELU4znW9GM5/j+CnTzR439+1wu/7rmf8Rnf3s3nt7fZ0hmAuthdN8ZwplN2c8ca43PGRTTzBhVMtBH/WuOYurjI1BqH7DWDYzRbLb8Jb80RZ493h2E4m7cHdx0aZVg999cxoI4l1KYYqkCmLZ0N9ylnMT5NeFPPCR4FCtq8942up5vMP2waPQ0GQuN7aB/UKAhQyxOcdBCzUT6mEwMVHQuO4zdIm1zE8Zo3KWQQT4VAxT0veN5vJ/rSf/Pz//s/+SJoOXmyjf3Hc6xdCIXnb2/4zJf8ga9702d/6+2XZvu5ZKxLQZFibjUoqhRbQXFAYEKMfo/haA2pXtxPyZqMmX2sOIUnMiBKyF5HiNFJLJWgzCC2rlVrdK6okqFFx3xg9mbQsjbnj0IBjSYakqIjE+o0D6hs1BgtAkT27gAFc0CMyTKEqzfjBICT39NrhfGB7P5fQGAVUN2I6ACjlgEyFEPyM0PUHq8lW4OteB6vNw1TDaAugHog9kYesCafYg2pZLxxYgKrNfuKFORMiCFYfqLE1i0IhAhWhWrxfAUb34kqwIKinilMihATOACrdcV6uUbqO3zWy3/TG3Znv+M/fMtf+98+v4rki7P/Ynvuc5/7dS996Uu/Y2dn52p1R0m7f8QYRydcy/5rm4hhMlNK432fhEaHnt0/GRxtHl5yRi3WnLZerXBUjrB3aQ/znYVH8rSmFh5zQEUrShXEpGMDj9SK1bDG6ekSeT0gpIDVeo0qgtuuXsViMcfpcul4UhMnd/f20M9mWK2W6PvOcvS8IB9jhCgQU0QIlq83DIPVLyLGeUCM1jCbS0FxkwIzI3UWlVJKQRXDjhoyETg6vAEmwmK+MOOBz0+6rkOMEXnIGPLgomf062gyV+Vigd5djTduXDe8aXDBUQVd6jCbzUFzQup7SLW4loQ0igHr9Rrkn3etFVduu/K6l7/85f/2Z3/2Z79QRE4uzv6L7XM/93N//5d+6Zf+mfl8fvtyuXThvz5MuJvm7U1zALeFtG0x7DxRcCocbrsHp9u2QHaee3C67+0swPMExG3Rrz1+it/cRoVOX/s8AXR6DOeJedv/bqLe9uttY1LbfqfX5JsJftt/n7oEzb1NeNnLXvbGb/qmb/r33/3d3/2Fq9Xq6Kl6ztPl2599k/VAKwN5jhsBu4sZLu3NsLPoXUjDmAezwc9sn5Btgeb4LF/4lVJxcrLCjaNTrNamLkV3vkkrnAGoJVvYrSO2pBQXjppKpp6Ltum6ZTbbffBJdt/36PqIPjIikQk6KpjNImZ9RKToWL7iBTzP6vNFP4+lAEUXyTCUKoghgNiOW4O5zjgQEhEoEEKwfUQvapELCMQuooqCikJiU7QV5Ci7tgwmZkiRjWBa1DAcajk3rTAJL1QSWz5iJPZ6uxXKYU1yiGLoP4rOk/SQH4Ytnku142Ju3bUCZbY8gOBFPCtFWGdkw3IEW6hLtXxBAqE4/IuLiwlVgT4gBlvoi+cUSLUCgJEFIkKKABVoywYU9bDyiFIVSkAdBstGrOqFGcslgAJl8PNCFLkUCAfEyCjFOzmIUGAORhVBqQG5VvtvKDg5yXjg2iEeun4CDgEpWdByrQ1xIn7ee1DytPMB5oxqvx+7xNukkSOqsguK0UWZ6gWe4PuwQiZNxmHbuermn/BijPtV7XtxZ5huWs395zQKmIEj1qfXoHWJ0+X+o75Y7N+dcHUxx85Obxicio8YDxrsDophqFit1njooUMcHDjmc3/28Dgz/50JegeTPMBH0Esm+X9pNsN8AfTu/mtumZ0+oZ9HRESgFvSzaGKRF8HFP2c3rcGNOe70BUIT6xzXSc6nYxehMIq3ASlizPvSyRU2uFAXPUOnSvveTVyssunNUDEUKRdY40LaIEbbaxHs+Md+DgDgCop+XlSgC2l6SjWz0njNkSoIYhZHDnBXtF1LOIQRwVeHAkFFSMnOZ3FEkLbuZSvYNzxn7DpwZCuUQFCGBnI29C0x0HURISTk1dquWzCHX+iSIX+q4T9HInEpnkNYETihVOtCzAJAKqrWscidxZqeLSvBmjKObxwBKaJUIHvOy/FRxvsPj/De+w82597Bw7W3W+hqZ35/5rH7+2cdgC2vb3/2yCf2wTmC4P6WqNgExVuqjwk4eC8A4HNu39ywdfoXevyqhU9kAfLRvla6cucfv/zsZ3xzZF60wryQO/zEimnBc/JSsrEU3ApMXukjbkJYa5PaYPFiIB8HXhgfC9kEouB5WGLNNY3EwGxPUaMRqIjRBSwUFNyZh9yy9hzlB8c3+H3OHDQ2htr8IaU4zsdMm9OJc0kNQeoTZw4b542JlJ59IBV1yKgqiF0y13+1Zh5xdCGaS9ibtFKKVgQMJoiWofi9jnyOQui6ZN2+q8GKIaSgEBBTMAxxJUjNY66Z5DIKKczRx39BERo/T/Gg1iKELIaSD45ze+jg8Cc++Ev/43XQs0WAjyf8nv4GnrQTb7Ef/fj5DH6jr7X7/E/9E89++ad9U+q6hTX3uHjnOV/tPyv8+XyObLxPF7MhmOgsajjetrhtDl5MMKAYkZk6wX96AdAPXLa7bmFu45b/2egfIYYxx70JjJssDRfdeBM4OHUvjkierYV6m9e2TL8NKYY2CK5xoqln0KHTfMJWOHwY1lNpzMwebzl+3ZJq6OTmNmhrSUPpt2IBthBBRmcZhb/Je5CRdWt/b1ilX3/Pr/7Yz/6TH3ojtJ48Kcfp47lfBX76xkXhDwC+/HNf8ce/5k2v/eZF6hYlFwxaMKg1bFJlQAu0FqTA6GcJgdiS77x7Tqzn1ptrIhgWaWFjgMEkCBCIKLLr/MwBDEKgCAoErTZXJrJ7GBjQ6nOA4JSNdYYer6CRQQubK9sL+7gUBXKxwnuruQQCkt/HBUixGzGhgAuAZGvIXAtQ1KI3gs/VvbHU7v3B5xgZebW2+JCuB0JALQot2esz3rwtBeSuXI4RcR7BnVF+ynJAVYWK3ctjH5H6aGjyoZFDFBQIsYvgNIPWCJXBs9YqJGfDAkJASKglo5Q1MnVQyRbJQfYGcyUMAogWdCFi1nf4b7/0az/+J//6//aGdS4XIsBTeHvxi1789Z/8KZ/8jSKyaDl7pRSsVivL84sRMSbkPGA9DIaonCA9Z7PZ6AaspY7iFBGNWYCtwWfIGevVGifHJxCt2NnZwXw+93s/EENA3/fY29uDiOD0dIn1eoWT0xN0qcfu7g66rnPk5iGuX7+O9WqF1HfYWSwANWGt73scnZzi8PAGFvM5+n7m93sjkXRdQggBwzCAXJxjz/0Tjyhq71Fh7sRZN0PXdwABx0dHWA+D4TeZUHJBLeaKLqVgyNnQiSrQam68y5dvw2KxQC4FtVYsdnaQUsTydAkQcPnSZfR9jwcffBDDekDqEi65aFlrxenpKQ4PD60uG8L4Oc9nc+zt7YGZsV6vsVwux6J/zhlHR0dYr9cjnevylSsIIeDw6Ogn3v4Lv/CmWuvFnfApvL3xjW/8o1/yJV/yJwEs1uv1mby/qaDUhP6UzPE7RXDeTOQ7LzfvPHTnw8SZLVdfExubWL+9jxGpe85+byZGTo/3ZvjS6fNulut33nNvhiHdFgtl0mxRXbyfuv6mxyJbjRltjLe8v6lb82YZhtQiwFLCu971rv/4Xd/1XW9aLpeHT8XzPo49rq0SjMZycKRa62AHcHw64PhkQN8zdhYd5vMesy4isE8ywTdRl21hWGvFyXrA6TLj5NS6Q4gMlQdHVzj1xRaILdNvMjYIZJNOdz1J60pXdTeOWFitIzYoWMc7qQk+wmHDzyW2nDq2x3OIVjCGcfApJRBHoPhiksjtMoYotSYgq54rGDHQZN8m1LVOoVIsoDdFoDGsBIAmy9mhKqjNLUMARUvQa7wdYS+SE0DRBYdgnYIolk9neXMBFCwsy414hh6ggM7xRVoVtRiCg0GgID6h1lGlqQrr/PNFANeWHFSBapNyCuZGE3axi8QQmKVCwQg9gTh5J38FYrQu/SoopjRCXQhQUpQUkHoTP4K6CkwBzOLuJIXkipAYNZIvYCYsQVXDrURAC5uNqRAoV8sZaEUXAoLa+SowRyQAqDA0MlIXcXlngfU64/g0AyrouwCK8HPWnRYqyCUjjVhHvyjyxNkBscwzz1tjEjBFEy10c/he/diszP1nRGyTlibuNLwnNucQHAsLGqPcXUinMU8CpJ5ZGTYOi4+Q5Htwf8YBMvb3gdneAot5xMwxFZOGuDPbFBtaa8XJquD0tOD+1alloWE2ih8P11lWtzQ1ParN3X/wZgJMREAOzTFXMJ9FMANFNgfcsvim4h978F/j+jPggmEAN/dMbJU6/6ilQiSccfuN++SGDvTiP6odE7f8IKCK+3DYv7sIcAqIESPO86wPAYhdamGbyHXzulY7NFtgKyZaRKRdNw1XZu4jVGtY4MCjGC25NYZYFiKhCXrelagbZVOZrctZgxU3yK6TqGIZrlxNqyyDoVY9WzSKICQ2KmgTEnIGc9qIlC3WkhilWgC6pgCKETJYBiAmUZhitGDEGCxPTSqCAJcv7+HGjSNEjlA2o2LfJ+wtZtjfb3mYE0fpwdnz8NYuv5sL1Ad4hBP5jAq+cqff7OGD4YwwOHv477bG0zZuVD6KWN8n2rHz0dpJvO3pX3/l2U//FmLq64iiswK1CXpAcHweh40jpi2mLQuTQV5YDiF6Jt50kguQbkYpqe2rNQ5QK4w3SYyaMG/EAHUrOBGAxOBo499wnjI2eZB3AsTEIx6s1Drixjg0d49j8oIvFNyN14oW2goYCJMFjs2h4GIFmivB0YDckrr8fqwcEFJrSGh4A3JRsAL+3mq1fMPGS64qiLE1mHlTWKmeibhpELNmGLZ8IKkIicAxoQ4KoI7NUFAa55QpRgzFcE6BgTvuuHxf4E/+t/e/7R2vg9ZrH89i3mPZ31Nu/J/z5N17X/Ynnv3yV/zJlELfCnXkrt0mnIWtrL/o9zxteNzRqaZjrEFzr455vMEQVewYLR5VNrhjbZPrp+TOnxDGrtUR9a+b9Y/CcZtwFy1t0JybTt7qmYA+l2wLc7sCjGs04CySk9jdgsCZNdgmf8evZQ3n67j5JmZumtPgTuEJMUF1zP7bXqgb1aDln7qQP2YV8ijoMfMZgbDhT1sOeXAcfxMl7XN3x6Q3J9z9vOf8ZvyOL/tX/+0f/+PXQ4YbH5fj/xZPvHD7PfL2ls979Tf8vjd9xjd1fZjlIhhUUdVRnQjW/KMEDj1iCubk97Odic2BrgrNlu2OJI6tVq9nmDzVXEEWVOLjgH2uLNViAaTYuqRxRm3hCyXrxqOgwHyO2DEoerOQk3xUzeUOUcTUgaLdx5vIxhwNmakCKnYUyr5mFQBVjc4DchGgICYGx+j37uoNfn7zTQnEYu5HBkK0eY74uKaQrAmpZkOPcgQQLctYitGcsiIPFSUrYq0QEnSzhNSxuRn9OiUlA5qMakJe02E7Zs1AqQNCJ0DsATEygEarj4hBihBDgISAUgmlrFEC4TNefM9n/9n/2+/4l9/6N//Zlxyerj58MRqeetunfMqn/IkXvfhF30REcxHBer3Ger02jGStYyPQMJiwVErBar1CGbKRaZxSlUtGDFZYZm/cz3lARh7rgC0Dr+979H3v4mGPWgpWwxrDeg2CIoTF6Pi3orZhRpktg3w2myGlBBXBerUGgTCfz7G3uzve67u+R+o6BBfFUooIHDDkwQwcUCN+qKE3h1ww63oT82o11xwsAzClCAWQSwbIhJBLly55DdZENm1RAj6fmc3nSF1nTsXVcpxTnK6WkGoGimG9xtHhDVy/dh295x02QXK+mNs9XBXr9dqjgUyYKTmDPW7k9OQU1x56CE9/+jOwv7+PruuQ8zDWnGstPg+wuVMTBGezGRbz+X0veclL/uXb3/72N+acDy5Gw1Nv+6Iv+qI/8cVf/MXfIiKzlvdXz8k7mgpwzfV3nkvtPOHrPPfctk4ydRFuC1fbouLUEfhohMTp388TAx8p0+/RZP9tv8552xTVOc0EnH4G29mH287A6f63HYo3Q6hOXYBNLCQivOAFL/isb/iGb/hX3/md3/n64+Pjh55q5z5dufpsHWP2sEENwl11mAhyraJVxdGKFJESI6WALtlN0jIlNgvMWgWlKNalIA8FJbsQ4UV0HheIbnUBex2o2Z0UigpGtdyaUiHW5gop4ggdy44zd1ZFDNEt70DXJ3RdQiLL5euiLdy7PmE+S0ghmBcr8thJ19SRhuxpTqvAAHcJicm65kURiCGt+9ZdfggJsbfMrOYcTGw5b7W4YBcDlAmkAAWFFsMFxBCMAmjs03ExK9Zcb+uF0Ar37Nwfc79AzYEHAKEzdWgkpDrqw9RIE4LIxQqiaGKcd8obsdALmp4vxGGTEVQrQMEmIg7csw5bBSqsyxCBxsIHQUG+T8lW6KuoiABKVZRVRq02OYgzQ5SkxCD2wql4aHokSDHXhEZzMzAT6spCl00ksS7Lmq3gWBypoGrvr7qg2s6vdtw5C9YqyEWwWmecrCsOTwYcHFzH6aqAE6NL0bqTxfAL8GIKefHFnA5WNBatG13ShY/AwQquHFAkokoCk0C12Oc9Ijs3BWB1EU+aktfQTP7A2uQkFRNXxkHs5SRHIbWudBOeIlbLa5C6xHK5/xguG6tRXdvfBzBLmCUgIQEpwvU2ZADIBTkDK2QcrPLG8bQtWEwEiv0zrzFRRA4enfjXnFYAsDcDUprBlp5GAA0AulkyJj0KdrodcMSmG102vktqGZNs446ijWtGNbcgAxVhFAINCeSThMhngmmTi/h+13OsMbxjLpvLjoHgK2r1A6ll8G87jF+v5YvA0cDmekvBESRq+UEU2Bbs4udJsGIhVbjYiGZB3HrTfumVDHanjBXXbHxIdRcC8ab4FjbRPe0zbI0lImsTHxPbsVRPEVEr7FcBaq7g6J9b73mHozMKGIYM+L9HB5Ujca3LbzDSUerMJVgMZSpSMeTqn62Jf9aZbKJpuwddv3EKxIhcClZDwfEy43iV8cA779/oa/tnTsVbam0Hj3BemgDY3HpNCMejsxbe6gXPU8wf9piNA/Cz9x450PeJKCLqrX6x7UZ8jO7E8x4er9zxP93+/Gd9RwhYiJ+05h6hcbHOjnZmx3AGIhDEuqfY3NxMJqAxe4NQtEKh6sbNk9jHtE8spkX9WrMXuD2/j4Ll/8JQu3YPsyYfUSCkiBAIkeyeL6Ke4+HjP3rTSW2JoyZURDLnvxTxZhW7CKkKSDxfNjQaQbE8khA8g1SQc4GI0wDcNjwW7Fvx3+c8zZFfZQBA7lIiFyT9fly88y9bs1FIjNjZxSQwT8Z/AXme3yjQoqGC1YoxwTDPIg2b5L/LZbyY5+qNRLVYGZYNlfrhg8OffP/b3vG5qrp8sgpi+jjsa5c/DkW9j2JG2uJ5L/qDz331p/+5EOMiuNi/6badLPB9HLRMurHb1mMG2sL1vByOjTuQfRHaFvs6Ogh5yz13xkUn+jB3XnsOMzmSSD1XsB2/XbfG/MEmwo1u3jFI0OevG9fd2LTpx8CBxxgGmYiFgRnFn2N5fA4TbaLmmNGHs4IhnXXvjWK0z5XEKQjERu1or0v+WZAXZsmxyeKZSC0HfcSrtsYLwtl96KYQICqoRfCB+x/4yZ/5Bz/0W1XL6sk8Xj/a+/tvT3Hf0xe+9mX/0x9+y2//zkUfZuu6xpAFg+fMitg4sYxdsfW/O9SCFHP5pQ7KyRtjFMQJHCM4RcvvgznqSdUaZLSY85U2orXWDCmWYRV8DkwU7f4vBTU75lIDVNy1n6wxllUg1c/zkKyJpxZQJIQYIdlqJAW2Zk9gaK5AdlG8YyPuwARMJQHY6g4khvM04cHE9FIt40u9/kDNGeiCp1T166EFq0ipEFlDiRBSB4AsT61kIwWIoBRBzmTzmT4gzgICKyKbaKdCyDmDOCKlHhycBgBrfipFkIcVYhCklFBzRc4FFYYizUO2xq0QMQijANC6QlDGrOvQhYD/85d+7Se/4a/98OfmUpe42J4y27333vv7X/GKV/x/aq3znI0EW0ppeVEQsXOq6zqs12ucnp6OTpPq+MvirrLVag1iwt7uDhaLHZ/XV6vrxYiu78b5cWssZJ9/ipgBoGQbF/P5fMwCXq/XWA8DRCr6vkPXdVgsdtB3HYZhwOHhIVarFfp+ZkKdN+DEGJHdhVdFxufmnM0M4U6aIRdcu3YdtQr2b7+K3b09iIttTHYdiTGMn4uoYtb3NtZKRakZ6zy4WDjzMV283sUYhoz1euXzKB7xniEESK24dv0arl27jtQl7F/dx3wxh4qOzshSK9arlecrDrh+4wYOb1xHTAmXLl1GLgWHh4e4cukybt+/3XITPf5nGDKOj47GOV3OGYeHN1CrYHd3d3R2itSf/Nmf/dnfKiKri1Hx1Nl+22/7bX/wLW95y58jokXL/Js6/6aiUXON2TkTzwiB52XhbeMqp4JdE722n3srvGYjkEzRo9tuwPPEwPPEuKmAeDNX4FR0PG8/j5QneEvhaSLsnecC3P78tv++7Q7cfu55mY3beYLtGhljxLvf/e7//K3f+q2fU2t9SuHA6fLtz/b+NFiwMm2KbuzikTDOVAnJRRRWslwYO6XGpcVYrNZquERjUIEgYBIvxdsLGL5KEMBmFYcgoi3kANUChoKoohRx8xxBtZqo0waGT9TJu85N2CP0s2g5br6eZgYSE3Z25+g7RgTQufvDxMdNISuSiSoEw2ZyF71oZI5BQBHJXCuBFOpOsGCqGmIEUrT3zi5karXionhxTrQgEpsbgDzHSsWxHyb4lFxNKHTxoeVpEMi/ow0X3Bb6FSEGCwuvBthDyyiAGeOCMmyKbPmDBKBk6/gLHloc2LqbtOqYc1SZgVLAnEzkq+LuHvLF+BgjaXlbZE5CCTBEiB9pOwuq5xvVlg0SLVSdXbAMnp9SakVMhmOSagVNEnczgb2QWK3zjwm56OgQVPYuSSiKshc2XEgUyyqyhZNgWQSrIjhZF6zXioeOjvHgtROsc0WMjFnfG6JMKmouKGKZCayY5P+RZSy488CcGwJQBFFEjAxBwCDJFdps5zvFsbDT8EnWWY0R5Tl6BHVSw5l0b7fCaJtoYrwRTARe7h4TAvRhasbBrcXBsyLe7IzIty1ObHa3ephm0SSTjwT/2WTEtAfMJ66n6ALg7s4CfYhYdEBKPeqWFUJQwIiG+EVASBjdOmxDCVbPC6MmweO/bUFM0R/TsvZYTHji0LTc8bnjuG7oHbetVRfqqlRDi7aCLcNQOSrQwRCfKUUrSNYyFnm0tvgtb6xgBkmAqmGdrbHYUKNaqzcAcHsJcwLK5trpZE07pwOgxTHJYbOogeuJWq24Zm7U6njRiY4jTZoABMHxXhvXZUOaytj5sMlXlNoEW7s+1DxABUjdxo0LAHUAch0cp2xNIkOtjiYdP0oQBxwenQIMrDNwMhScDhnXjo7wkOcBmn63vzmzDw4eMXLv4Xre/viPg3ZeHtxMEL+FIHhwkzG4/wjPs1ExCoD3zUCPx8TiYyoaPsqN9y6/+eoLnvM3uy5eqrVuhG/YfYWJvZBu7n5iBfu8IrAVuUwEt4tuYDLRi9hzNnUjWMHdfLVawZxpRHC1RgDyezp5Ri2p5exBmzPPXf7YIKVbUxRzsOwONkQuvPFEihfomT23ONg8T8VFAzLsj+N70XKEfVxUFc8M8/u735OUDAesxZ7H0S4Q473Lm2SkWiafJxZBq47OJWvCsXziqt7c0vIKtX2+AVqL9WbFJsKQ7b+FgINQi+G8UwxThgVqsfBvgeUfgghDUdRabB7r8xXmgAceuPajB29/1xs+HoW8x7rt0JNzbD4Rr5HuuufN9/7mz/r+btZfbnMlHlGfPCI2WzNhE6ObkNcKeC2/boPc5EmuhTcOsCEDRVu++ETI482clNwdqJtBYq7ZM667zeI7hOA5o7TBiyp8PbF53bEDVnUzX/QieltEm+NB7Drmzjv27MHJhHKco5pDmMb1R9tP+2wC8wS/uenk2CRSb1yDpVRr7hlFwLNIos3nKWeysltuoI7i3qZYUTyj1DqJsRE14c4osetdEy1+9V3v+ZGf/6F/8saPFyHvo7Gv/75+6hb/7nvpvW/+pq98/fdfvbRzecgFWQqKZ9dVUZCSZdsJEKIgRjUXnjBCMEGQOFkDrRplx2Q+BqWAkDwLs1QPKslQn4vW5m4HgaQA3mwTQkKMCYEiWAQqxZqA/f7v1lUoARwitGaUVQU4InYdiAU1r+3+xxE1e9NfNFIBI0CrB3ejIkRG6Ds77mKh20TVm488m1Ph2fPqzTME5WjOwAKLDEls5B2P6CDY+y5DBlhtDQ5v2nZnjn1mCg0RgujNCjZnklpBLBa3IlY/CDNCFzsEjlCxa5WKQIiQ12uQCLougQjIXmepmTAMawhVw5lTQNYIlQyudo2NgRA54l//zDt/9M/97R95w0VZ/KmxPetZz/qdr37Vq/8mCJdXq5WJViGMDpFhGMDMmM0Me1lyQc4Zq9VqvE8N6wHrYY2VuwYJhMVigcuXL2HWu1gttqaOwVx0wWNjqlQQTAzrZ73ROorljIYYUXLGcrlEdUGN2OpPTQTo+g55yLhx4waIGLP5DCqKk5NjH7+Ea9euQ9RQm7u7u9hZ7IzNR60BBgCOjo5weOMQs9nckZv9eA8VqU4/MwNDrZZ5yMQ4PDrCtYcehKri0uVLuHTpEqqYAF9yQa0FTAG5DMglo5aC+XyOvp+jlILjkyNDnC6XGPKA3b097O1dQt/PsLu7iy4lLJfLUYhlZuRhwOHREZbLUywWC8znC0N+KtD1neWhx4hZPzPB78YNdH2P+XyOnDOuPfQQrl+/7qJsD1XFnXfeifV6/c9/+qd/+k0XI+Opsb361a/+0q/92q/9/pTSpWEYRndpE5G2XWMNDdzEv+nfpxjQaSPbVJA6D/25PZ8/7/fbjztPAJwew7YIeLOcvm3yxnni33nOxkcr/N3KBTj9XLcFwG3RryFBtwXAbZHyvOeeJ3Jui4MhBKSU8La3ve1ffOd3fufrn0pjIELFRScekXHqWX6GnWgZYhs3nMX9kefOtJXIRiVs2TOsbjmjYEIV3OLSVn+6IY+qVsNQEFlHjSM6G05TPMieySaltWWsTbo7g+M9A9vPmRiRrXBVRjEqQIPjOzwzT9y9wmP2heNryBxboWXrGLgOidzbF4J9VgoIW5cceVdaYCBSAEKAiN3YGTD2fnXUV1AEscJ9jBHDUCBarPAYDIEBAThFMFtOALExsEgsD7G4oxAxWtB4NBHC8jVg2QUAYkgICCYOBLJ3UhUh2PNEFX0yN4MJjmpibIiQYEVFYiCZGmqTfGIT4rpoCxIx90DNBVDBfJ6Qc4GqISspAhFk7jnAxQ1DqHYxWKezd/QKLJJRBHaMLW2OTDhuuV4Qcx9ZqLmiQMEUQVEQpeUAin3nSmCZJOt5YaVKKxhaFluvBbUzEebKzgJ5nXHt8BRSgfV6QI3WNRlThAzmwGyZROR5j82lYEUZFz1FARIEF5GpVlR1DNMoRHiXuLtReFqUps2qn84UAHQshGKaiUImTJ6tFEwUqZtu54h0BzcRIB4mNkxEjAOXSs6gC2fnChMHWI37PDh4mFZyy0O5iQzoUscMSEDJK8uxzvZvAOgCLDRaKuCJlSb6hWaEM1dZmHyEzeWH4J+i58lxsGK1eo4HKljMDdQurQQrwotaLoh5Yu06ZXiuMl5jiVy0Mw4pQrJFQyRrgmjHZ/gbOyaFcS6Dbhx4GlqXURMsTXQzx7VdFxAYHJrTmNFIBEQBAYY2gQgoRHNPtiK7GjKzuoJJHAzbIwHM1kXNkVFVUMU+U+ZquZ/aBNdNhooNmQBF9aKJoY4xZhC648fVwVEMFVjDQ/EYVzassqICEQgaxqxKVfu+4AYmkYr1UBEjsLO3wNH1U/TJ6hqoCZjvIe8DB35SHhwcbJx8+/vYP0cE3D5Hz/7sAPvTs/pg9RiF9ptsj+QgtNaMzZXjcSwAPp4iwG9434v5Ky4//+7v6bp4SbS4I82bcJjN5UbqDpsRbgkSF5LAG6HQXbJK3gHjopk1gJBn8ViDRggBVWE4MFiuIBEhOp6vlcgtY5lGEYy8uB9IfaBQo15Di4CSu4vd/QNpCHSfR7G5GI0wKNaCQzZuwNbghIZdb0ICMZgCSs7ubggIxEijWwmQwKhENozJiAaqlgusfm0rDS3qor413liDADgCU7cS2T1ZHZs8Zo86It68l7qx9QDmrmD2BgNvaGKMuaLcuhL8HhyYLItZCUoV61wQA+Hpz7jtdcP6nh+4/ou/8jUfd4KfPmxS8Kj2pfTUHP909epLnvOaV//FkNLlltHccmWoqfHAiJxsQlMTyZqo1xbtLeaAXQQnLyQ2sXCUvejhi2FrYtvgLbG9KG8o2zPPw0RQwyTjz+eWmHYWbyGFfFy2Nsvq+x4jAPyzIHcbM9mYI92gOVuTZBWx9ziiSTcOwmmsAE1ez1zW7Xj1bD4hHGmqgpZK2FyNUySQeFHVUQVnihMtY7C5Gamt3xyrqmjHai4vIruGPOfe577+8PM+76+/50f+ze9/0o9/fXKPzyf79pvuvvOVf/gtn/8Xrl7ZuZzzEkUzlJKj+pLNkW0GaucxsznrpCDEDhw6gMwxx6wIweJCanYyjFRoUWgIVqvQavdcDiYqqq0LGdUb5xIgGVoLKtl6lryVhVOyRQhVUF2DDcFjjaOloC4z0CnQuZil1mxbRTyxxOINoFY3UKpALPb6wZyEFhHhKFNfJjJHq7WUYo75GJBCBEW2lnGyyAwBQFEnmfUEDlaAoxRQoSieedFISkQMLU5M8AJmc/IqKrRkr5NYonpkz/4E2T2LWr66eh3Do1YGc2Vy9IZrMRpKHacMHnfCFl1TS8FyPaCPwOe8/Pmvu3b02X/jr/+TH/99F+XxT+zt6tWrr3j5y1/+PcR0eZr5BQCz2QzSRDei0RHUCuvt3408U0oxR1yMWK5WGIY1hmGNvrccvhjCmNFbHa0/okVDxGw+x3w+Ry35jLNotXZU+AQ7GFyEGJuMRjddRIoW+zEMhsCMMWK+MBGsNTM1ykhrsFnMFwgc0Hc9uq7HsB5AbPuc9T2qCpanpxiGjL6bodtJgDvr1us1VCpCjEipQ9fNbI5EjL7rAYVhSh27CQUWix3s7u1CRDGs14ghYW8voo8Jy9USXUr+ua8B7IyCRkOAzmYzxJSwWCxGEkMpZZJDWNF1PfquH/Hp/awfM79F3GHdCGoAcs4YhgF3PO2ON7ziFa/4Gz/zMz9zMf4/wbdnP/vZn/qWt7zlu5n50mq1Ojd3rolq5wlU5tKnhwlu5wlqUwFw++fTP8/DY07Ft2kz3FRIm4p00ybEbQFwKlJOX2tKKdt+3W1X4raj7jyM6HT/txIXz/v7rRCp246+7c+pfRdTfOvNMKetyWOaO/iiF73oC77u677u+7//+7//654yAqC462zMXHDURMv/axi3MZ+PZAyZN21hIihoK15ri7JwsfCs5GATMYcXupPO3HzkKEMacTbs4qBUGRfGljNFlhtI7CjGJkoBkYO5srxwX6tgPWSESEAE5m5RYYg7XxQdp0lHqgkwgdnDvgGQmHgUA4qaGye5KjO6Y1w0SwmevaPQdTbhq2WGaJNqFIyIwAKqApUBrJYPh0hQMcGRmcBdBMCOnfTSY2JETqCQILGCPIeNpLgQCet665MvegM4ArGLQG2FMiAkcoynFyqrgpPdLOtYaFRERBeVAFUTOlEKYmDAFwGAdfWlGKBk3wExgWEFdfICCiUGiaBWhu8Qgjp2GhJabluwTn8t9mdWcBBo9SIFVxNXRHxBFS14vRUCYAv+5qxQmBOPfcHvrYrm4RKydD0iaIzoVCGxonYBly/tIpeKw9MBooQhKziL5UEwAeLOWZmc4DJx5UFHMVlUUAoQIyEGQKt1mbKtziDCni3hTtRNtWdSrXOFB5gUlZp7dDPo2LMalMby9bhAe5jvZ38i6h3MzhcV8AjiwsGj/Pn+eYLjwwWM/ckPDx6tCLI/kSD9LyUD+ci0v3laIWCGWDP62czY8DIV/1w4EpyJNA1jBqPjNHmTZ6OoGwwofG0Od71ZK645c7zRQie7buKfSstcFb/usjmmAyOEZLkXDKhkWPRXyyCs6ABQiKPjkEMCHIlrhqTg10XLuYQKkAUVsPxLaypGccG5evZQw5SmkFDJEKPNuVhrBiQgBXMQcmR/fETJ4phOc05KrQhm97NAdAJYI2ou7lBuaGNzHDenHvy6CjJUCJEJeXYGi7slLE9MixUEqjSnJka7ot3TKqpYBiK763BidjcHQgR2Ly1wfHKKLkRIV9Ah4crVGe4GcP/B5BRtQuAjaHT7W3p5ey7297GPFQ72J0L5I+vZjyz23Uqon8jiH+0q4ONdTPxo73/v3md+Xz9PzzRUc8u54rHore54IW+KCoFdMLLzvwl3TQSsuhHpiHVTmPfivhXRN9dvInXnn2EoteqIdSZq+VyeLxYitOEGPSPIWuoVnOyOySGAktMJNIwCoDUfuKvJM/R8AENgmC14cbO6U0ZGIcPmYDFECFszUBPoRCugZA1WgUGRR1GyVhnRg8xkDRZqSPJkF1JrHigFUnScdcXgAl1gzwtyIVQItZKj/zZuH2a24qqINSg4WYBJXVBsiyJ7SFUXXL3QSbBrHimQS0GMAc98zh1fMSyHXzt9zwN/6kkv+j2GB+rjdKAfb+P/mfd95vf3O4u7xqnVtiCFanNYX1uQuiMQG0ef+lqHfI0wHiN57vboFNw4WjcZey6EY+L6G11umwaA5gzEJI7hvOKB2mzZG9Em72PskqGHi7++RgneJCBNsGwZg75gqWLrEFGDkDeBz4qKXtj3OILR5+fi37TQwH7tQEMPt/svk+ejOtZe3UWkNIqAZ94vGS5QxyIAo9TqwqG7ruukqOGrVakyYkTHwo6a0MNMyKXiUz7txV+zOjp63wM//lPf+nE3/i9Ev0e9/ZEv/9y/cs8zLj9rKNnoH+SYa69VGNVFATKXnGXsNXJRw20Fb0YVc7ArIQQFBcuszKWi1sGaidCiS9icf2pNOAS/X1fLyeXozQhkArj3/4CSoQJJstFsKoGUgQ7o5gqKAZSAEAmBZxBWFKmofn8O7FjRqtBSIdnqH5Y/TNBcbPlO5vSzNQNbXmEAxN14o8XYjx8MCDOoCxbLEiq0+OfBEYHIxhhZw20ka0pSItR1Rh4qqBQEMqFOxCJCaBYgkhGDRa0QAlANb1hqtgYeX/NoydAsIArQwBBy6pGqraHY6jxV2aMbxNbc1DDmitWwxiIkvOm+F/2eB28cf/CH/t1/++aLUfKJu73yla/8vtlsdvcwDGMh2PL4ZpjNZhiGwZvy7ffNaVNrxZAzch5cACwwEljyWI2JIJcMuTmbW15frRXL0yXK2lx+XUqGF42G+61OxzBHe0GMETu7O0jR9tdw3yYA2twkBMvnZGakGB29yZbzR4z5Yo5a6kgrSH0HVcX69AQxmIuviXSz3nAwMQQkxx0GVehckboOfdeZM7EUDDlDtKLre9y5s4PFYoGU0qQxUbEe1nZvdmclVC1PsOvMEEFsWX7MOA5Hft0DFvMFdnZ3DbeYImKJ3lgk7po0BzF5/aTUOoqAQx48r7DHar22emTqUGvFycmp1RT8WJo7KwT2XMGC5z3veV89DMP9b3vb2771YpR84m5f8zVf8/27u7vPasJym1tO3X7N8dd+3hoEpi6888S/7b8/GtFtKkpNxarWZNgeM1JvJudvEwXPQ4Bu/3sqXG7jNM/Dck6Fw+2Ig1vlAN5KyDvvObdyIt5KCNx+3nmC5fbPto+1+vVDVXHffff9ngcffPDXfviHf/jbnhICoM3nBKo8IuiaC1A1+CR4Gr/DvogViHLrx57kvU3Wqzo5ISBjkW2qFqp3xokXqZoLsHWCibu4zobEWxeb5W5ZgS1w8JBZe6U2GEQBzdneh9riODAjhoDiYzAk3nT8wjvHMenshYKUIcFEFrUZpomI3q1KCCZINsEpRncpVnC1LjgKAVKKZ3I0OUaBYgvx1AcL/xb7OYXgr2MLEQ4bUUnB0MToOgDVBFtO1uHCCrAIJJhLkWFOF4a330VGykDyDvmGqQwkIKojz7BznaiqTTRqc6SJoMJztZQsU4BNTWAvxpkQxd7tXyy9TK3rn0Bj9qMboXzyrr6w9wV8aBhAE120eicy3AIstGGq+8LN0Gq2KNOmtFQT3tS0OkQld90JuFrHcWUFi6AiIAgjUAAHBZFgPu9x+fIelvk61sUQbqVagHkXoxVI1bpBVcVwoq7MMQGTpLQRA2WOU3GMY8stCe2MMOzTmdLNlt+PeFxAOr/WcyV0U+pxId4UJz9vdGydtD03VeJhQoG7AH/Dscizm4gZzWW4ergIuS2aHDy2lx2zCPNZFGkH4PJte6PwhwrPvdwIc8TWSND+Pm48Dn0zPXMAO/azarVcMNi4FXg3sEn5LmY1x7IhPKFAzcWdKpbb18I6Y0honMA2DuBcfYBHBCj1ybC5oflYLbOvOH6ZmRG8Y56iO5dCBIvlahEzaskwh7MNSPKOOfbThOvmuDdAr+rB3+0aI+6kqiDxJoRcMeoVFSi1OA6FTYxsaL42iYF9LhJgWWQKVBI01KrhR9v3IONprK5r2q7MhWhUx+ZwCkCxmz2Px25I5eqoYxFDJy/mC5wsT8EhAiiYzxa4tHc39g/uPzMcxiGzD+wfnK/Btcfs30ST+0gNfo9aCHxEEfCpU+zf3rrnP/P/u3Nl51XmMps6VDbZW835By/4+01ybEwSL7azu+QUJnQFdnKCP8a6bzwXFs1Zt3HWqFpGnSEGbXLexn+YOFy4Ib852PEg+Nyjgnpv73C7dwCBRZFVPQOWEVQ9f9aFhRK8MMeeDQZs4HwKIrvO2HgEqtCZz8juuw2R7u0K7gySWqw46ag9u1rZo0upNv4jIQu5QyHY83xxHwOhIniWrnkxQOY6NsUOQNBxHiHUBAeMGMBGQGAiaIgI3jhUa0GbXVq3shUE1DNRQqBwzwue+Ufeebz8xfKha//wouj/iTf+b/usz/ybl+/Yf9WYtTfOzaz4FuJGpCNygZ1c8GM/184syl2wQ2s4bBlYOt6TNtl6m4w+mWIrdYritNWB+NyxNWE2Wsp0AWvrnLOYHssD9UW7q4btutX+3TCaIWzQoDYGMTqBx8V/E9b80zJR35rV2ntvrrtpmHz1JkppWe6+7zNCIDavZYQMv55wQHFM4Li2bNmpfl0ZzxXPZ1HPH5CG9px8ru2z2sxeTNgMDBTPEmcKEKrhpa955R89/PBDv3D8S+/64Yvx/4m3/eEv/7y/8emfcvertBaIO1Ns/e4Nc6QIbO4zYrL7piqUGdVkMycO+YSekzUS69oc+CFBtKBoRvH1rtqEYCRTqHqvnyoga7snhYgQEyj1Y8MmcYbqAFS7JxMxKEaAIgJbAzFmPUgJBU7pCYbNXBMM04mIKGJ1jo6B2kFygsrg7HH2xjprPiT15mzHoBMDLflcoKiODmQUBLW5BWqAjoSmDK0BpFZoj9CR5iTS5lcKCUBMDOZk8xIRBH9NIYLG3mhS1oZo4si6OiY0j3MZizHwWQb7Am1SZeAQEJMgV0OiB812XS2eRxYjiju5ui7Ft3z+K//Qr33g+tt++hff8w8vRssn3vbqV7/6+69evfqqlvkHGAljPpuj7/vRaT6bzc6IgDlnI5S5YyylhJSiud1gja5JFXu7e9jd3UXfd2OB2QQwuEgGpJhGcSGXggggxjAK06qKEIPnb5qArzCn66zvER2H2fWdueHI1h855zGvkKg1nBfUUkyU7DqbPrM1z7b9ixf8W1bhbG5CaGvmi8EEQYs0EKexMRaLxSiaNtJZ9bpCSp3HAJjDZrlc4nS1xGK+QNdZHmiMCRwIs/nMr7+Mvb1L2N3ZQeoSoMB6tR4dvil27qyc4eTkBKVkpNRjIMLR0RFKzoghYrHTMooLui6h1oCGeez7Hju7u1ivVl6Hs2zAtWFcwyd/8if/vw8PD9/5q7/6q//rxWj5hBT/fuCuu+56RcP+tnnutsPsPFGrPXYqtk3n3lNX2rZ4NxWcpkLftkg4jRBof05/NxX/eMzDPiv2TY+xPbdlY04Fvdb8MH3sFLt5nujX8KPnORa3Mw6nIt2tRLvtv5+X9zfFej6a3MJbOQan39v0/RJReP3rX//HHnjggXf85E/+5D/6xBcARcbFrX8yE5EOYxeqrddccBC2rq+xZO4ZC01EZJvsYpoP2Jx07nKRNnGDgqR9KZtcCutmhWf9YUsF9xwtWDdnDOzGJ7MMMhRdMMRTLZZD1aWAECy7hwKjwsO9mUEV0GBourbADIC5wcZcntZZ60U0Lz4LxIKqXfksXojqTA905Id/BmtHgXS95efBxbtYkSIjzDoADKVsmT4euqVonav2WQeChXirILiDJ0abxBOzYwW9aODuNCbAtEUTB1LHUKkopEjKoFKABEgloHq53XK9ESmYOyjYYqB49ha10DsvjDTxi0r1oG5zPihF+547xlAGe0+1AlXBIYKTFUhLrqi5glMAVS/gB3ZXZUSGGu4sGhJMqouwgSGOINHqb774528t/+BgjsSg9s3ZxcHFB2WwVk9IYFQWUFSkCiQyr+q8T9hddMiHJ9BKJk7UinWxCYWdF7YIYVagFoi78ao7Sbx25OdqC4a3gkotES3iQb1SQ2Pv8oZ4ZgWPln02GVMNM8lwN+SmWxqObxrzT3SSwnJTtWJ2a0ffrQSFR8oma66nW+SV7Z8rpzya2DPP/nOxL+cV8gpYzNoPV7jjzrvcjhcBz8sDIib3LCu0h03mn/0ME9JxONNTb366iqKWU2fOjIEedAABAABJREFU1E3xRcXyvEIMQGCEmBBQLccCFSn0JtY3p5/3NrBnd20iVm1SQG5gZQZSiuYigAnQEB5xvSaCGVI4NDWZIzgCgs7HjFjR0wVEVLHO3/H4ecz4a4Jk9c9DKsBi7t1ADCkVsZZRTLSJu+f8Bbt3kN/IqVZDrMZogmjw/TFAZD+Tau4rYViXr78Fyyk1FyJzGI9NtI4ZK9G/hyruhIrVChlqbshipOIzWY61VKQYQBzR1YK1v9fFPGFvf39EgZ4nArYTc/8cERDTobU9dvZXNh4etVC3urmwvn+TwfEULvhP98/7V7788l23fxVaM8S0U2/SOMHsGO7xjGtu1LE011qhvJxsvoEqQExx06qkG7yeqOVcmWPWritaM6pWdLGzjF5H9TQngrmN7JxVz+8aHUpQBCIv9rPf18Qbr8Rqfc7LCiF46dIoBhwjapPvRCERLtrZhcfeaoP28ZhbJmqvaXiuhgq05wYiSCmItRpSDOYiDuRNMcGERlKBDAJWwyCFGCFquPlaq2OKzClhOPUwOngM/WXirNQCiDd/MXnTjzknmptJRR3/aznMhJH3DhSx64uLro0WEWPavfuFz/5zv3L96D9iKO9/qhf9P5HGf7rnOV965/Of/7swacraLBrdSec5lxx83uViXivMqU8rp89vYlYTw9oLT8W5TaFNfa7Rrg9NQCTPuMOZPL/WNNDctYay8quOiGHy2Vw1TYibvgY7sUW0iYE+IRXxAntbIE+OF3qmKML+HPHcIsPpykRUa59Fw3+qN0a0dZz9bIPo5PF1aHRTmmtYqk6cj9POY/aCgBdPmEe3Ya0VMQRDpuHs+2NvlKpijzFUsIuTIlZ4dTy/KpC6tPPyz33td//HBz7403rj8P6PR2H9QvQ7f/vsT/1Nb/6S3/Kpbw0cMAxw8oajvlyUZwJCTC7aM0QZWiuYFJEV6hm6pRY/j41xo1KRQZZrh+Knb/CGWEXVAqoEjtFRwwWo2Ry2ISGkBO26cR1pPa5tUVjMwc4BTGJrQLGRGCJZtImqh5TYzzpRDFU9AiQgqGXmUepAqYPAcsdUgBASqhSPpF/7fd18xTQ2QBUj6NiExuciFndA2SICUAaEksESQdxBvYYCJgiRNV2XDNSKKNkpIcnc1qUaUh2Wb1jVagCc2Og52bGsbBkIWtdgdIYR7xstqELIromRrNGoeKODFF+VuMhZpUKFEDmAu86ySLPgtp357te96bXf8e77P/hfHjw8+fWLUfOJs91zzz2/8957733rarVCznm8v8UQx7m6OfjC6LgJfs9QUeTBnH+X9i6BA2O1XI2uNmLCUpdIXXKkrWK1Xnn2XR2L8Ds7O1jMTbRbLpdYLpfgwJj1M5RakIc8rhmICfP5HCGY806kWmOM3w8DB8znRstoWFHopgHeyBaWh9fmGjEm9H0Phdo9U+z9xxjAnJBSZ+67mEBk2E0VMTdejAgcsFqtbF1CNB5LjIT1eo3T0xVCYMxm/URsMOFDVJDdbVO9GXC+2MVisUAuBTkbTrXve4gqVqulObFSRPHrQ0wJs9kcqorT09MR1Sq1oqzNnZmHAfP5fNP4QwQu1tDRpQ5Xb7uK1WppouBgx2PHfoq+73df9rKXffuHPvjBH1uuVu+/GDWfONurXvWqL3/5y1/+lmEYfDzJGWdd+3sThaYiUZvDTwWkbTFq2322/fi2z/Yam8Y0uBu1Nf+GM8LkVFScZgxO30MT5qaCX7uOtX1vZxW299V+146jiZTniXstJ3W6r22hdDt/7zwxblusm37W52UC3kygne7nvH+fJ86e9/xaK9brNWaz2c6Xf/mXf+c73/nO//zQQw+97xNaAGwTTUxQOOOaFoCSjqKYgxUmSgSP7rEpA2eTJbEpKm2Qa9UFi+BOQheofAHoipdh9hzf1lxTDRVqg2iixoeAKorI5MUcbp5CK4qTWpXXQ7GqiOXcBSvWt6bVljUxttx6263CMzhYIUJIzAhQy8tqj3TrfmBB9MmswMRFbo6VYIUop2CZMyYxWFxyJM/xCQEqjOIdqvBcESlWBKvu6FIB8lqtiy45ro+j9doL0LHllKlURAqI/jlBAUoEaEAoNpkIKQBMiEQQtsm/Gl4fFMhRlwqqtgghLxSCggkWbN8hSICUDBcCaeQvcyAGRp9m0CLQNaE65iTE4ChXRSEgJYZEQNYZLl8AoiZgRqBCzOUEjFmExAT1G3lVhVbP+gpe5PROH/LMBfUnVxGwAB1HrDy7AWzir4SArlPkwQCPO4sZVkPBcjVAChzDUHC6XI5IshCiZ8IxWNVxYzJiOdWxKszBCh6e50gso9WMJihRbWOwZRhoA8hadziRt5IqN+ro5ELI43hqmU6qMpaszy0THDxKQe/gFo85wC3227L+moAxmzx3Nf79ZlrIwS0Ex/39zS43Qkmr/Nkft+/tjYKeVHMAxhCbqWz82DZaYDvbNr0McMRkAUBljLFC9my+Ii40edesjcfqDgMTEoIjO7gWSE2GUiagOtIWqO4INacfmkm5CqRWzxo0d1vtLI+yfc8c7RxTFbCjeoKjBO16yhByka+dJjE6ftmEQB2pznZNUjtrHVdq1zgLNMcoltg5G6DBjrvr2Mc+b7CoLuqpd1+GYG4/+z681gFBZEbOQBBxxJq5jps4a12IwX9miFMNbHgjYMwMJQqjaBs4oGyibhEiMAz2HccYUMQcjUOp2NuZ46EHr2HeATLY/Wi+NzvXkbr97/2Gr73ZWLqZKncLQfzsNru5sH6eQP8ROACfiMLhxzIbbPfZT/sGIpqpF+LhGRutJt6K4+Q4cg/jHBsmbFFujyt+fTespaGc20I8eLf+yBTQ6oKZ3SsDB8TEkEKel8c+b1HrwFc10kAMhsT1ZhEVc9hBARRbbNQUkbqwGf8ULEtTBFTseh+CWo5wa6LyBidy0kJK0QubBFZx106718h4/wyewRx9bmFUM5uD2eBUaLTxH5M13YhUUEg2FxCBVjFqgJi7wiOCTVRkm7gHF/RYPDPU3ZTqVyJ1EUEdRUrBLso1N7yvo1eZHLlm+8ziTmwVKwp6o1oMEcUXG7kUXNqb3bP/yfd878HP/fKbn0pF/0/08f/0T33ZNxLTfOzKH5sbfZHMGxoIT/GVvMkBDZ6pu8kAdCF8FLJo/HkT+Zogx2RzTlUCs47Z420NFjg4NrjxIvQMQpNi2Lzm6CDEOJ4bUJcaRUU3bmXL8fScQWmPPPuZTTt+RTfPE8eC2mJtswgcUclMWzogTURFHleA0w7f9nltMqxtgtCcC2ccgsxjIWAsLLR9iPj3hjNpFO1QxIUPcwTI+FsjFvh1vjm/gwmQe1cu3/NJn3vfX3zHD//IU2r8f6Jvv/dNr/3m3VmaS1VDfwIIMZrbnYEiYhEXSiAWVBWgmsddvDARgt1vigpY1cg5nkFbRQDJCBoQNHhjTgFRgVavY7AiBiDOOqBElKwQ2LzZmv+ynfPVG4KMo2+rCVXUKkCp0GGwufG8M2efMsjn8JoCWBRhLSAZELuAGBNaoxvY1qIWpyFAihCNEPFip2Sba4A3Yw6MKOpwH8vus+tdGjN4lRMQE4giKFljtJJ12QkTYq3QQYHBG1MjQWP15qUKUAEhgNW6C6lUMHfmofSsZmsssKYkKdXW1CmCAlCzrV2kFiDauoQ9hJ0jUKgHICCxuYMMFYEApoSsiloz1rngec+8+tyvfdNnffef/3v/4ssvRs0nzvbSl770W0RkJt4spgDm8zkAIOdypiBPHsMSXbAfhsEFpwpRxXq1QsnZxIJcsFy2LDF3rNQ63m+bu46DITdbLl2rYXZdAkCoVTDkPDandNo59tPikvIgWK/XoxhWazUBMqVx7RJCQOp7FwGtUtTPels3a2scmtznJYPZXHjMhv/kEFzY28wDYjRhM0RBjAkpFW+CAGKMLp5GzOYzxBjQd90oBMQYcfnyJaRk2NFcMlarNUIM6Geek5gLYihIXULqEoYhb7CFzFaLUcsOLGzo5lKyiaCzObrU4eDDBxBRLF04tOP2fFGfX4UQxvVK11vuYd91tu9hwPHxMa5cuXLPq1796r/yYz/2Y7/zYtR84mxf8AVf8PVENMs+bqei0dQBN8VxTsW5ZNlUZ1xp24646ZphW+zadp41sew8Qay9Znve1HXYRO+pODl19U2PdyoiTjMCbyYATsXFqSjZPqPmXN4WANs4HxsRzhFIt0W37c9ymsnX/j7FkZ6HC93ez7Ygub2dhzNtz22u8CtXrtzzVV/1VX/5e77nez6hx39s4kHL7EPTycRxj0Sb9d5kAdecR5t4iuYGpA2mxvFVGwiid3C7C8OQk+aQ2ixi3IGo1bvLGlJSoC3kvmXR1ApugdSwiXkMjv6s1k1ah4LIDS1qHWKkdhNSa9E11J69OysKVQKT4eykSXzOjyR2B4znVAURgMSENXhejXiXWWATPDeldl9EFBMHm+MnWOFfBNAi4GRFd8o2MSciE37UcxDJitWoipAIaZbAMYzI1Ri6UdQMAFgM56VEoCJuiXG2vloAGCU2MU83OKOUEkqpHk7WGHs2+SdSZIGLkYxIDTlkQlYCQYpAEiO6eCguhmlgYO74Q4VlKjIQ+4hUA6SsgRAQ3EmhnidETIYWdMSmoT8Caq4gDeiIkH0hXEPDLBr+q+ZicLQYrHnSvxUmoIb2/Rm2SMTLh0SIMSIVxSAV89kMl3YqqihW62wCLTEYiiqGcRUp0GACX2DyiZS9Bxk7vNWcS2HifG04VQDKzXflRRptF2WMonnr0xbFpnjtRSJ1JqqOOYHuXPXcI+vEvknB4GYixP6tFLitn+8/gpjoAsaZh+0/XNA7eDRwxC1hY+boz+yaX1659peBmIDLu3NbHDbkZ5ggPsd7lrnW7NwLIDaRqV3hmFs5K4BRrbsvBitUa/VMScfWsniXruE8VapdcmuGhGRd7AoUAbi61OiZgBCAIttiN5j4p8ogJFTJgFYwJXdNi+XwqbnnlPxa6N3HIRI4REgFaskIsIaLmr2jlwHmzgW6AQ1Aazlb8P2aECcMdKGz5gCYgxyeRRCTn3PVPgSGQM3mZ9hDFRAXK2wIrIjiTQKVgZCsHiFqOaA1RF+o8XgNYmIo83ifKZ4HQIHBIXm+KACu5sykAFLLEAyjidG+Y2uwCChmWjSB1psmLl2+hMPjU3Awl+hinnA128l5qzPz4ODWOl/LADxzuu/f/Jx+2Bg7T9zbx/m80XO3/IQVDZ9M+4/PuvPb+53+JSoyurBtUg3HzvEEoOxJk2rgK3bRrOVLanPWaDWsJJtQZ+4UowWIqu9FETmODjWI5d8pR3ueKoooSKqLCzwWJ5ga2sqaWhouu9ZimbopOV4Ufj+xrB+AkPo2/u3awBwtLq9kcwMSUHM1eZMIISaIEqRkBC2AkjdX0VgAJAiECMzJxr8j/Sh4PlCKlpUolofMgAmCjvNlURAXw+v6vV+9yYtCQFDP/nKyQzMdtyxmbbhFNmdCgbmiqPjzQ/RuYzE3hE/L2EOtLXetOZLcYUlAqZt8afLcs/2nX33j9fdf/V35Qw/9/U/Uov9TafzvvvzTvn33tisvbQWthvttjjoiGoUsDhNkZlt06lR44xbWaXl+DUHpjx+XP9gIVrXKZNE5lfjag3UkdDSCw4jd8SZM8axLcxpibKIhpk22nYuaLd+mrdtasYEmCMPmtGtiXDtk0akg6K1QYs2bDDZ8ZrDCWiA+i/fx51oW30ZgHRfxHBzBO5ljuPPXXLh1zBGaFi3gomspXrSfopJU7PpEjjF10bN6kaWJnYCTCsizsVUdf2yvkx0JJaJ41vOe84b3vfiFX3n4C+/42xei38f/9rVvvO/PfvI9d75ERXz9SI7RhGf3RWhmhKDW9YVGU5GNbsbWVClCYIogLZA6QEKCcPDcb5uzV7L7E7FlXiu5sDYMUO3BcQYEW89WscYfEZ9HeDGMPVc7BENZ1Gz531oGhErg2QzKRrqw+UgEI0E5IFCHGKo57XsGhQ5a2WJIPJdPWvZgF6EIqARIYmg21z48f3jMDm6OXU6gNBvHGbweor26EOmoUyg0JNRA0EpgquDo62btUamgOD2FOjuhLUbEojY0KUQLINaAiGDsBaYIigGiK0jJKMuMkHpDl6O5hYvHiOhIMwrqsTCwayMn8oKj+PXbrlNVBL/l5S/4op96+6985Y/97Ed3/F9sHzPx79t2dnZeUmsdc+9C4BHzqeoNYJ5LZ7l6aRTz1qMLyMhWfdcBolivByxl6Q1EwZwkqzV01iFStAZ/p1aEYL+vuSB0jL7vvM5WsFqtILWiS2l0/bMXJ0QtbzCXYs7VVhRXJ2MkjI7AMJshecNLXVjtLEareZZSsFwurbZKhFqLvd/AmKcF4igEEKqLDDG0um6bPzC6zrIEh2JZiSGGsfF9seMteFJQSsFsPsPOzsIaCGP4v9j7s19rsvS8E/utKSL23mf48suTWVNWMclSVVHFKhYhqVgSCcGQ22q2RKFbzRbY6qYmz3cNQfLQg92S2uiGr4yG/wbD0JWgCwO60qVsw3IDbjRhyQIEiVKxxpPfcM4eImINry/etWLHOfXlQLUkZia/Xcj6zrBP7NixY0Ws9T7v83vIWQv7uwt9H81V2Pf6c+891lv6vme73TJPE947zVusVADvPVfdZSWY6LW8q8dyjrNGKyR9fil+qVc3d2erwxkMm+2GTXUUppSIKRJj5Etf+tKvvvvuu3/un/7Tf/p/eT16PvmPP/Nn/sz/8XOf+9zPz9XF+1gsWotQMcY1FnLJB32cJfe4YeAxYvKxaPXYmbYWGd9PrHo/zOZjPKYxhnmeF2SxtbbS6R6uJTRD1D54ncf70cbCGhnaNIEmDr4KgdoySh87IV91LN5PwFu7D9fv8fHxeJWj8FVi7vt9Jm1/165MgHmesdbyrW9961d/+Zd/+T/8e3/v7/1fP70C4KLmtSOpgdUYW4tXFdPSDtx6QWwWXVAz1Vo2zloUbK6m6sSzj8B5intpHfdS0ZV10kdesBYNxKW5TGervnFaLLfOLHF52t2r3eBahDMLGsZYRwheUZzUDnWS5njVTnPrNFTKVFxEEQPOVIdhQ3JUkaWG3Yuo86ZIJhbF75mS1HnoiopPtXglIrUzXyfupWjBipwJoVl4LbarAd1FyJIhQ0k1FzCDc55+o9b9pgR57zFWM7awYHLtYGx5IBVn4BANNw8FmTPRVIGvfcgNPRqcBgFjKNZi0cl5sYEuAEkFTqkCo+RUef+C9YoF0xik+m82dB4w9dTLms2jiEwLtuB9T6qcJQHEa+GhFAcknDV4b5ZCXyuqWmtxuTqGOoNJgiTAW1wI2Ky5gaVoIVWWE9wgWfANHSTg8YgvSEwEZ3ExI86w7QNT6mqnViIVIVgtLOYiFQ1TsNVJmw01T81o0UKXOksGizUq6pQm97XcwqadG3mwyG+7vOSt1A6vashVoUSkonPtIg6uiwWmBtZ/qJD3QaLbByog7/d3j9GF44fgPD9E71urLDfLJlX8G1T8g1ti/eUXnlxq1l8zerqG6ktY62uW3/lGaBbnz/rOonlxaihWt+hyPlUsaK7/E+swWXFh0groXv8uxipErUTHVbSo5krairJEMZ1l1oWwNJHSgek6TOfVTVrRRWDxXVAXalGXaUZqA4Wc3YlSMOdLR20wKHUc2joRP2P/UhJKSlgHYnz1Rer4s84uuNCGotX1Sc1DK4Uyn92PvlNBkKxdvUWgMx1ZEoIl1YBW6yKpqKCudYKs3fwOSj3eFi1kSOWSGmvxq/uVFnFdLfo4JOXlc26fuKlm2TbGSsl01uGB3nmmOYKHYTswvHMD3/3ggXLLw1xAPorAtxb0Hn/NRxgoN3CWvz9IEAy/Jwr+Dx7Ovnnx2Tf+QoXhIaLZfS0Deel4XU2HjHELflzahNacMWENJ1Vq5q3kllwMhUSpjkI1t2vhrIl72jksFSd+xpcrvlbHHqKFQWfVJV5iQUrNGKzFMLoOE1bj32lDgA+6GNcmn4q9rhZyi7p9jQjiWHK8tD8n6RzM+OqMUHSYM1ZFtZx00W0s3lS8by2masdYcxVbSjELbjNn3X/b3I99FeFyXXhV0SWXcs76A0SSFiitV9df1ou3q0gx4/y5CSNr15oxLV+1fdrnfjRrTe2eru7P9nnWLLD2WaecCc53n/3y5//jf/4vQQD8vVL0/9iO/657862v/L6/WFYNjIso1tCyy7z+7Fb3VXTGrZC/DU1Zx69dgrTrFKEiOGXBCp9FMFsbV0qRKlqZOt5WhYXVgl/WOYXt1/bclb8sqItZOvydPeM1dRraxlI5i2mcXXvyaAHdkPPSbInGLM48U+e51HuusbYKm9RxZJeMwZz1+igIOdUM4raeNCrua+FdKk2jLE7HRaRtKieskGxKRGGFKYXaEOo0P7xhPdv1WVB3l1k+v7ULgkpG0f3S4onBBd//7C/+wl/9f/1LEABfi36/u4/L7XDz7/zRn/9LzhSdr9sOV+dB1iXtcjeK5XRStMkGr466Ok5rvgk5pyogZ1xR8ahUZ2xrJkkyk42yM7xVWpCxAWsL5Mg8T7VJTVsAstT1iAjJOpztwRZiVpehMQIxQ/KI61XcClA2G+g8ImPNER+wRh0uzhm814bf4kxt0quJhGJwpnZ5W0drrjMlKrLbecRpU1CLIMixaBOSR3MIna+NNaKZfbZtu9YPSsv/NDDp/d+Jxp10gx7vOeqc3qFOx0LAYMix1jxMru69Xtf/MWJEUaRF9F5dpFBS1Pw0HxaEu8ErGWe1zLJGSFXss9IwilpjkhQpaPEy5sSuG7r/4I//4v/qtQD4yX/0ff+Zn/qpL/1PWmG8OfKcc8QYl3vHY3ReKw7PrejtHMFQ8ZeCD4E4TdrAmrROtd/fE/ueS3u5RFg4VwlcNdd2jvO5fFMfwzDo/TXlWow2i9tHojBO00Kyafd5VzP72p0heK+N8sZUV7OthgohpojJ1PetNKA4G0qQpalJiiwuxfb6Opb0uJSKSh+GQV879XpHr7ht5129Xqlr2lmrxCHJ2rgDdH2neP4Wa2Asvrr8ck4EH5aFe8qJuesYhp4YVSTNOTFsNnQh0PcbckrknJnjrJmefaeRK0XH+TTPuiaw+pk29OscZ6ZpUtypc0uW4nrW+LWvfe1//VoA/OQ/ttvtk+985zt/fp1ttxaumgDUxKcmfrUmnCYct2vG+r919t56m+/n6lsLjS2D8OzGPYvg6wa4tn+PxcbH22z73bb7IOe0XtO6rnuAGF3Pr9vrxBgZx5HT6bRcE7uuYxgGUkrLttZ5gu15McYHyNLHjrvHouVaxGvX3FchPF/1WLsY10LfWjB8LAI+dmi2z3Et+E7TRNd13Z/6U3/qf/PpFgDFrRCDq3wwUzsq6/JTHmT9yTnqwTyECZolj6wsk6+GqaF202sbfTnn2Yhpidh1Q1k590bZ+0YEYyqmwzntnhdRNnxFv5gW/J5LzVQrFcVlsN7ibRWlrFXHiEfREFk72g1pyV4rpSJJKxbT5qKLf43XUqQFQkCZ9qlifHLMFKMY0iIFsZq7RxKsUy4/tbsdB7HUSX3N07GudgyWigOsQo6v1XRJteuVAs4QOu1mS8Via6B3psM7dRU64zEeckzq+jM1Caco2EtdDZ7SBwYDaZ5IKRG6jiIqAnunTjaNyBA9ABUXaAWs79SN6BQf6kxQF521mrtoDXGedfGdsuYVea+YVBGKiQSnNWvnPckoZsVLoXhLTlExfjUzUowhpaKF+4r18t6TYqJUZ2lDHuIKcS4VJ6IiruRSkUtlKfZZZHF1uGK0WIq6ATGWLlhCzKS5Yky7QOx1ARJjIVc8GzUHs0hRjCKuFioKtRqsNwwxJM5YT9cKIVVAadkO1OyFJq0UA1bOGS0/eUk0i1guYh8IIOvny1ISMr/zK8aHiX+vEifa3yyYz+HVYuGDDMDbV//65gZub99HGzn/NI4qLw5VDLwMcHlxqe6/thhsx6NU7cfmepXLKgbaVc6fXdfgzm7AmDKtPVjINQfINVVKs6XqxdH5s9UwJ7WbaTetftSuBtmLVZyoKdqeIMnr1xroB9ZXV6FFnNfrV+3M19V5fVpzLaHjpLSmi+q6s9ZiOrvkjTWHkQ/qqhZLdfVpFql3FvGBnCZddKOF9iwFqcHfDTGKheBCLXZmUixAqm5GvyBDi9FMMItOspJ0mlmSFcWnWYQFjMe6Qp7re6hFvTaOrXP1tlTOn1c549GaKmlyqZ3WmiOLddiSl/uXs+rGpEAis7vYMr880rvAMUech21YTsMPFwFf+c3NRx9rv9Oxtxb/fq8W+19V/3/3s/9Vv+k+X0pesHst1VcwS+YXIrVArUUx6x5eKc0SzFUpnEkWb8nSqGRaFqsW3yXrRMDVogGiRXPJWVFURjNqbPXsixGSBtro+M8Gk6sD0FgwXhFbXrlWxSj6yxqzXIsMrUtQCw7W6n3NrHCkxll8zddbJuQYdSueLyJ450GMCoLZk+NcryPqWFRnUNEsZ1NbAKw2Ixhag0SC2pTibCUSaNuYOpSxhC6QqhhYQiGlrCi2Ov8zRWhchiz13azGP8tcVRYBQ6S6nFojWiUfSMnVxdWuk7JcM7Ooiz7nwvX19pvv/fTn/9rxn3zvb/xuj4/fa7jQf5nbv/oDv/Bf9NvN587YTLW5ia3uOc5CmBJQKnZSRLO463ysCX7WNETYWShr3zcEWLXw1t/JavHbNncW/BaNr66vGo64YUTLkhWo++IrGmh5bWvOONCi+Exr2/VsXWA4L4xTzSVqi+5lcdxE+HqNLFkefCCmYvdLKZhyztqEmlFYm3AaIlTdNnpdKqLXIKnYTdvchdUB2JyHtmIWxLYGgbJktkujiZzlShqBVN2Y2kiwiI2VQFIxG7XwSF3r1fddM91NbQAtNSrh6Vs333z7j/zB/+xH/4//5r/8NIl+v9dExP/ln/6j/+W7n73+XEpzvTs2F24VhfG6Zld+JJp95zGV/rAg8YWas6dnTI6CEbc0jZ0bLgXJSecGRVGePmhzXhJLitM5c8/WQlrJJLFkpw0p3hStVYghi8XlmUIEBpwJOA/ZBiKWUEQT7EO/ZGQH35puk6LGTRUSTa75vig609R7Z9ExiPQUK2QpmGBxrjYiOCB3IBGxOp83GmSCIeMKS365GIv1DocgMiMlUuaMcV5rMdZSjEWsYMTiTcB3HaUKA9FlJM+I1UYe67pKBomUpPONnOp1qygJSsgVww7GJIxYDF3lL9VchyIq2ta1l66LHN4YvAl1TeIoJpJz4We/9NY3/uy/8e3//G/+3b//X7wuo39yH9/4xjf+2maz/dy68LwuuAsaB2RrNIevrrzmzDudTsSK5gxBm+5TSqQYiTmRYmJ/f49xljfeeIPNZkPw/kFTfilFg+e9V7dfaSjNsAgJrYCuQlemCDWrUhbktbEGb1w9f+3SBJNyUnEwVSGw5Xsri2iZ42sWbsB7R+g6+tQvolgppUbymOUe214nBBUax/G0uA+tNaSYiXJ2TWqdS92N6jrMjOOIlImWR+6dX5z7mj+oMSbW2Afiq7pxHH3fk7PmGY7jSPBBDRC9pVTH5GF/qFnlKljO86yY0Jh0bVbF1NPxqNfV2sQ1jRMnH7BWRY6WkzzPM5eXl9/8xje+8Td+8zd/86+9HkWf3Mev/dqv/VcXFxefa4LYYwdZE3/Wwl+bh3rv6bpuQe1qPuZZCFwLWA9IGK8Q/14lVq0FyYVo8Qh3vxbS1ttf/zxVIbzte3PTrYXJJiyuBcgmhrW1RYyReZ4rajgtTRAhBGKM7HY7+r5/IK61fUwLQaM8WFOsj9X6d+uc8fcT6NaozrJqCGzvqaxpCY8ExfKogfBVQm37jNt7bdee0+nE5z73uZ//tV/7tf/8b/2tv/WpvP97jCyRDVrAbgHU5dxxKkZFL+HcIWt44AqUswZRWe1agXV1wauF6HR2DVYONVjELJDCunCuGXRZUUxWqmZobEVjaCG8OUBUpCzLxLtkWXIf+q6rBbqiRf2iWTPFW5IIvoCn1JwdLbaJUPE47QaqE8dSXSMB7VZPWW3ywRqKO+dcaAdvFc1qFp1kIerBIYvBKZkOVypix+q/ccpalHCK+ArWkX3B4ikoLkMnAB4Rpy6EIloIRLvbrGRKF3DhXHAwNUhXpGJNqzsseE9vyrKwD11XA7iFmNPikmuEU99pd44tWcUPY3Au1G6mgniDMx5bAOewXrsoA8LgewoQEYwzmnVkFOdhg8F58NkQSeTi8JT6HvWz96UgxoOk2rmXKKq+akexE0or/CdFgBlbO5XFauC3t0iqwoM3S9dWc3oWqx3E1TalCyUDXTCcsmDF0llP8AkfPLlESu0AFdvwEHqeJjLB+Jrh1hwkKnjoqerIVQ+3NiPFVcqKurWskWXRibFnd0pbYLZC0WpV34oYS6anyjSrTvTCKpnqo10lbj+q+NCev3b6jT/xdzc1m++VMYK3r9Y6zma/98MvPvxp8xaGqqJ89s2na11Ib0Q51VzO2vFfhcCm00mpeXLWkVPWBXfR72scn1436t/noq7ijAqJxjp127XrVSnaMFA0x2+o+FFTLKVEStRFaqmv7x3qdMuaLYmvzjog+E47Fp2eM64uuhvathTRxTVCLglnA847qNmioIsJWxmoTgpSBTzrHTkLqaIEdP9NFeEsmB5TojpuUCeyCp9aTrHGIkZdt8YarGSciyTrFeHjfC1+1GKssXp9WzWhVDrzGf2J4kKNoXYKa16fAZyoIzFXxLQ0LK4t2HLOOUxqzdIMkZYFWE8IY+tnmWp2YEMPWugcpA44gSPggYEbbm5uP1QEfLWY95Py9c0iV/PRnH8fpiXefBRV8tNb8H/wcPbi4u03/u0mjLHkyZkV8FOW86m5S8rSGWCW62bDAOomtLjcOllzaS6/KjRVQc4gWrwymt+bSqbkTO/c4opJc9bz1+YF4eyc0eYQyXirne21D0kxQVbHv94f3EJtaA6aUpFdbfz72rgTS22qsgZrPa37v+SENQHrPSln0hzJMamwh2J3tWmgp2S1MAsqDLb70NkpWV331iIl4bwjOS2E4G29Z5aza9BU1LAxS2Zua9iqw3qZ41nnF9HS1s8B62vDjk5mxYC1pX6mmkWU21yoEgpYObR0YaCOyZaOlos2k739hae/8U8/ogD4aS76f2LHv/e7p1/64q+15kCpzq+HqM61nCQV51tz71a5oNIIDXWeb9Y7bRQNpo7CM6K65eAtYlvJej+XlkEnzWSHxSwFd9BMMVczwGWZw9W8cWerG1nHexs+ixhZx3hz0eVSRe7a0IecXYEsCCRzzguEB/mIrOaaazRoc9I5a5asneX3RukaYs95gqzEyCV7sQqath5bXYizwlecxf6GAm3zhCaCNuRqa+5o13tjqA13esxiyoszsRVmjbW6FqifR8ln9NC7X//aX/qoAuBr0e/j99gO3fW/9Ue+/m83oR+husgqCi5LJXbUzMyi54aYRC6FlCHHCLYQnNYTxFhySvVc1vlDLrUmYTIQ1TWTa1NmEYqxRCzHZMnZsPPU7RTIMyZDsSPJFIx3BC8EZ0ACWKXiFJfBRnrnKV1HNg6TBVsCxnrA45qhD6N5ghSs8zjfrmFGm77rWsFYv9RcjAvgAjEmZBoxtQlHh7/F+IBzHVLSUhNo6wcde64SkyqOv86vLYIzDrEeOhVbc0la9xCnImQlMuSaca7RGIo1lZI1XkMSxniK1cYgm5Jeb22PcUoFkNpE1bLXxTgVCHXahzNBkerGgiQkJ40c8Z4SVUQU8aQi+CD8iT/y9d94LQB+gouc3l+8++67/673nnGaFod8c9r0fc88z4TQLXl/DZPXkHp3d/fEOJ8zJUWYKyoUDCkrOnLT7+i7nmEY2Gy31W1T87ZEGI+nRai7vLzk8vJycRwp4Uwb41Ml3bT97Ltene8Vs2mrSNZIFqYSDHJKei8rBak5gYIwDANd6GrdQhTBaxXlaYaBaZ5X29K5b55mUk46Z6ouwOYOzCVDBFPMIlwGr2sMQRt1+m5YsgH7fmCeJzC6dtH3p9eE5pBsd+12fErdd+/csvbo+7Igw5t4gdEmxb7vyCWp878KkA2X2oSNcRw5HA/kLOx2mwXr6CqBoAmwc3UNeh/46Z/+6T/7WgD85D66rtv8wi/8wr/7GCe5FokeC2hNEGs5el2n14YmAK4Fs1cJfa9yADahai0srrP4mgjfBMjHuNEmxL3K6bYWDB9jOpswN8/zA0FxnmdOpxMpJbquW+bU4zguYmHXdYvwllLieDwuX7c8xLa2af+238cYl33w3i9o0DZu2/Fcu/7WrsrH73X9ntfHs73vx9mD62P/fmLiY6F1La7GGJmmiV/+5V/+c59aAbAJfcZYSlZhzxlTnUznLtfmeGm4J1tFMS2k1gWjprgvYpB2ydbCmqnZVvUAq7xWlu7rhtZp3emliLp1THVuGe3jykW58ta4KtIVRVyJOvqM0UJcy7jICL7eWLV4X4tiUbP2tA3UkCVrLlUrCDmjghC1o71kihF8DZ+OWbng3im+RnPsqsDXKla5ULwjG6thuVkxqVOFBXYeGIIWsKbEWBflPmiGVvCOVKBM4FwrtgeC07KiDxZnPSUVcioU5zTny2aSZPKU9QZrDKGviFNxhCoEIJnOBYqFNI6K/es8U86QC7a0c6FgsyK+mpzkOGfY5ayORGMDLlTHDprNFQWc6zCqZCj7vIbypty8aFpQzbO6K3NuCMuKJKz5SZr9YaqrymBdh6SZOGWKgZyKdinWqr7F6gLAosJkRosRpma8WEOxQkpxcUG1PElTzm5LWxxdgD4lTknwXhGrvbWIt4x14DRHktMXULeCqKNREDpvtSPKtJbSlveiIneuXYotR7E1kcvi8JLFqYCsXLec/8aWKhPaVsb02sXdELsLX/RV6tvvUMx4jCt8JMG93989IBPenP90LabcvlK3uOH29vZD1JDbB68cgStg2PiV+y9B9jRtrsZXrARCp6jQJg6U6gwsOiZNbSbNRYv5VUFA4Z/no+uUQFNxlJmYs2ZW1c8s1/xRIZOTYgGxro5rq040HM5BLhZju0W+1CuoqlSlCLMxeKuOHqoDqYiK8Ri9/lnv9BotqjoH5+hCR4yRGGdMcISgYdg56STAiGJ7W0HEbXq6riMnLeKDZu81ZLCVcu6+l7I4foqDftuDhWwMpJrfUzt2c2kNHwkBYtJw8VSKOo5LqSI/qBHS6nFJWuBACs6oGzsv2Sn2fKbrJYq45Gg6dSQt4u2DEwCpRjqx1QW4v6Pr4JT0+hwGPcU/Cg23Cds3Nyocjosd9uYnx8zaHfsv8rj9EAHw017sf8X2wxfe/t/7YD/TulaXha49u8PsK3KIzxFe1TIiBuvNuVmpNtycL9SyoGsxmp8nTvBGkJKQbIh6O8AaS7YO4z1CIadEmpN2yHdOnbUFqNeCLG38y3LvkGozLKUQMZTO4q1vUcx6j7S+ooEdNihizAtL80/wOv5TnHHeEbpehbSan2FEs3sWosFG0cI5WWzO1Wlkz+7bmp/XXD651AYBMQzbDrFGx3/UHCIrSpnIWSuv6oQvdfwb3RfnqmhTMaFZ73rW1MxdRDODjDY3lCKL86qsFB6LENvCqqEKm/hbEW4UqkOQpViy221+3/DFz/zl8Z//8L/+pBXp5ffo+F+/xuW3fv5vhGH4TMvGW60OF3dcQ+CalX3XOlddprLM7/S+ZhbMVnOdNuF/6e41rZvXLe40xYw5Ws7UWRCzSxOaaR29dbvNJSi0rLyyZHSvkUDtmrPQVjjnabTnWGs4A1xU3GwY/eY4pI4F21CfrYhRr3mL4FjfmzFn3KepFINz4aNhOlUszQ3xCct2Wj5222dTf6dd/LK8RzE1d7GyLGTV5SyPBEmRFdK0fSarr88OyYovrZ+xrdebxW3plDZy/cb1l5/+oW/9lWf/7//2//R7Zfx/mh5/8U/+0n/6mafbz+SY9C4gcYkpKSZRjDbpNPpPEQdO73k5FWJUjKZbUL2Kt5YCc1L8pBEdW9k4pECuzadeCr0tlAxjykx4JlHRK1inlKEciftIPEWKdVgvMCeKdbAd8N4xFxUmkIjMCT90FAK2qIAZjSebnlAzjZtojqlNeMFgO4vHqUgmeo+2RXPAWg6HcZ2SkDSNFCcOk402rTqlgwQfkFydzm0eAhSp92LTxltbrTqM7ekGkOCI1iEpYbMgdOC04SfnSJkhormK0uItgiHP84InF9drzrHJ2nRo1LVpbFChVRJJXG0myhRJmFyv91IjAlxHylo3KKaQsgGrFCpT3b/Z6vr9Zz5385U/9Uvf+o/+b//3//b//Ho0ffIef/AP/sG/fnFx8ZlFZKsF8bX7rxW7AXWxGBXTxnGsIuCk53Y973NSAcpZpyYDEY7hQE6J+/t7QtcRQqdr5azF/TnOC8Zz6Kvw5LXYfTgcmOaJruvYbrf0XaeCRCnajIIQQre6l9tFCIsp0px13WZYGmiaY6+UUoULRf+1/PKuC/R9T0yxFsLVkZhyJo3jKiPd1AbHrPvrHIMZlhxAVwv8LTszpUROmWjjgk/sB0s/9Mt9eBEjWlfRSvhoDTntZ845fPDLc1t+nzSMep1rOe/pup5xHJnmmU3f0w+6n9M0M09TdXKmur9C16kI4Wpe2jqPUZ2Ilu12+5WvfvWr/9E/+kf/6PX4/wQ+/vSf/tN/4/Ly8jNNYFsLPuvcuTXyc424XLv91o18j0W/teD0WIRai4+PnX1rN98a5dleo+3b2uG2zvJrX7fXavvcttWEtyZote3f3d1xOBzo+57NZoMxhv1+j7WW7Xa7CJ1tmzmrk1frhfFBlmBrJmiCXtvvdszbe22CZxMq4ZwB3pyC5+XMGX/6KtGvibXtb9eZio9dfq/KZ1w/Z+2abL9rouzNzc3v+xN/4k/85b/zd/7Of/2pEwB1EdgOWs1rItcFWOuWEw1mrkg4kZUTSTRk+dy4vXbBZcVlGEXgWKkOkQp/ohbZWvd4qeHvhqIiXkXXGdwiJhoswbqFNb2EdLpa/MlqWWu5ElIxMzEq+mvTuwUh4zpw1tSFcUXfOAhWnXUFLUrPpeCMwXmDRQtzJee6YHeK8qwc/FxMterryTXHgstC5yxJYIpF8/mcY04GmcB77Zgr2VKs7r93lpgLJUm15KsTxmTDlAUXWgeyug+dtYSuA1NIScU7G1wNMWlUk4I3WiRMRgtzZS563Jyrk2UIxqnb0FuK63AmE7w5o/REsN4o/nNKOIRSXTVFpDL0BNf1uHrhKalgJWGdJRZVQYzx4ILabOKsAoDUnKUCOQHeqztVrVKkYklx1hzD1JRpq27HrFkjueQa8O4g6LxespCNdg06pwJKaYF6tByklt+kn7MWdgyUhDFCFzoNdxZZ+OreOYLTHIhGsM1GMxa9NbUDUcPcsqokKhjTnK6mOjdKxbg53be8ctlWYV1xidRJj62OlIpqxDXmHKU5dzkXOKmBxwomXY3TJjzcDh8sKNzyanVurebdroW/4SdFwPfFfT7+9e37aIe3r6Ao3tZXU2FlXP14uNEnvfn08izmkRQxW+8zauDzrHSiBQH0KBJQA76L/r4UdfyRIQRXa3juLMiWMxZIqZyOaZwXRyHAqTg8GvqdfZWsrcWGoKJAjKRJxTpLnZgY8LYoKth2OKPXZpFCbiQxb3W/upYZ6ShZME5q5EcgDB2b7QVxHCHFpfBYg3lqMc8oes9YSpmXQHLNUXVkM9cmEYusrjMqOCj2yDl1T0oWilFEcpYaKo4F31FSAlOvt8aTStKmAkCcXYp6GMWjlqSFnJJjdQT62mBBsw1WybW+nVJFz5JpUafOO3JC71FL/GleCep6HyQ6XACboXcbZk518gJxvNGgv4+AAm1fjDcf0U77KnH95hUC32Md8V9A+PvXWYz/3dj+5q3rX2sOljO6puI41xPDuqHS5j3UnM9SBYJ671fRLapohWjRzVG70pWYUCrZIEnUDnQM0xgVOGbr70vBixA6R/E1C9moa14QUkx1/GcsqXb/igrdVGSVy3X8CyWpux6nrgATltAwdRk4baBxzhH6js3ugvk0YnLS5iejnb7kgjVScTquOuNSFR50+946TJophUUMafnLdmmw0dyTVMe/ZiJpU1b1WlZBLy15uWKczv1KvXM5W+9kZRn/OZUqGiZ1+3ivnc+SF9HfYKg9SzWbV2oTQUHkHP6tjQ12cUuaijAtZHUMFjDW8/SzT//s96oA+Gkr+n/ax//1O1/408sCnbPo1Ipbbe1zFsFYREDTUNn2LBIteXeF5fqxiEycp1W2LooUM28wtaigvzuLetRMPG0WyxXJZ1bbMkuRa70gVvRnXaA3DHGR5dxW54EWyloeoTwqTEi70JlztmEjZrJGFXG+RkpFfwlnB55t+aW5LAt3XZu1bRUVHDk7CUvFsOqxN9WtwLl5qL2/eiwXfKpZiZIroVA4i5imokI1T75iQKXmGVd3galCn9Q59VkEpOYRKWVARPj8l3/q15oA+Fr0+2Q9fuUXf/bfk+rAUfxLwliv93Zjl/GmsSEFqfSfVIQ5z+Rs8MYixpEEJGXGOTHHQk6ZQMEGyM6SS9J5rehaPqLIP5OFw/2BVCylNi+n2RI2ltD3lMGQjK8Nf0LOE4dxYjyA8x221mQ8kd5ExqRNcGFIhNQoTsIo1R2HwfS+Ir17jBG8rbUca87z5FgQU5timyAvCSRqrrDvddzmVNtp6pzJenVRVvpSqdfFJUe1ZnppM2HN53WK/czqB8RYjSkRmSklU/BkseQipKgRG84roaDQ0JyGkhVXilR3kg+UFCFOZBuUY2WFVBOZc5n1c2oFReMx1mPR5+ADxKxtss7qOqLFbhSlHv0bf+j3//prAfCT+fjC5z//77RibsvxWqPejDHYVeE6xsj9/R3jNJNi5HQ6MU5jvfc7QlAn4eFwYBgGLi8v2e52uC4gudAPA746yV68fEkXghoQUsaZc4NPcxduN9uKoNOuU1/ztg6HI4fDQd02h7ULydevVayaxokisvzeVqR46BTBH2Mkp4x3Wosd+p7tdksXgu5DkcXJ2IS8RgoIPijtLJ6jU9YIVLvkFK9IAkXJHiEEfAiUokJeI06VfHYQOV9R5rVG3Jp5clKylrT6Ln6puTVhIcaId56hGyq6MS5owjnO+BAYhgGRbqEwNMFy6PtaZ6xNzFWobPPEJri0PLOf+qmf+rOvBcBP5uMP/IE/8GfWuXJL9ve6iWwl/LRrxOPsusdi0YN59CNX4doF+CqhcP1YC4HL+fjo9dbiVhPwvPcMw8AwDItY14TANk6a0LZ2BYoIt7e3/NZv/RbDMPDmm28ua4ZxHNlut8sYWL/3Jooej0dOpxMXFxcPHH273U6dxl33QKhrAmJzN7bvmyuxiX7OuQfZrG7tcuac99eEv3Vm4+OMwPa3jSzyWAR8fIzXn9n6ee2+8e1vf/vf+1QKgLpoUkTSw7PyjOqkOgIXkbC5UEzrtmxJU+fAbGO1EGZVHtK/qZ12ikB0i6BkWr6gtVqkra9jra/bqs6PkjHGa2BsK+bRFp55Wcy1bIlcMg5PET1J++CJMeOdZeg6TewymoXTBB9nawFILGIyUlLFa+kCMmWhWrpUKCpa0EsUpjktWYoOz0zBIRAtB0lIjrVA1pE1IpfQecLgtSvf60I+EbEzRBHKnBkGX8OuHZ2Di91Af3mFq9hWLyo95JhIOatT0jkCjjLNJKCzPc44klGkibVWO+gpWApd6BAv5DmSyBB6upwpDiwdVrSz3ganiMGa0ahUVcOKK0noO4pxeK9GAmu1QFcA4zriNOPE4jpP8Lr4Tq4jm7J0W2ucWdHcNDG1kGpJAFaQpN26KWuBwdWTSXGbmkGoREVLppCT4KvoYGqhRKpIKAJxrqgAq4uclIsiDrwuOlLS4+Q9MEoVfxX55H1HLjO2ZZ60MJKlo/yM8sxZRVhXsWSNj2upLlSxVZVqDkHzYFG/5ASui02te9roZ6G4unMmDVX4PF/0aqf4stXhfZib7yPe8QpB4id+N76a8YlqJq/8k5qr9r74z9v6xc1PqpIN+bn+w5FbnnLD9cVGO/eqxrM2iS/O5kX9U3Fo0QFbHqBTIUnIpKgZct46XNAcuVRQ523JVUxypFOmlBkfOpzNxGkmxYoZda46ArQpIXSduqltqd1slikWSqrOHBdwXU8Si+8GuosNwTsV5+t7yaWQYmI8ZgZrsUWFQs3qBOsM2WiWQJoNsx11Ym+duhVLRuKs549z2NAtTSEUzQW1DZVnAVG0sXWmoktULJOctfliOR91UVAMSLEVy1Hrjtng+h5Tsl5TxFKmoiK4KO6vnedZzlksMU7LmFJ0qUVswTp156Zcls+3SFk+L2NZMJ+Qa8Hf4ayKuuCwNlenc1WJS6YfdszjAeehaoAfaRi8Wth7Hw7nqzIyP0zU+50Kfjf/6ouFHydBwb/z1v+u33Rfbq6/c/5fRcaZFRar/t771tGuzpRacidLxYfXjllnrV4rrGcuhWJEC1mlioUpI1kd784a4pRIMWv7k9PClzUnNoMndJrlZ63mVTjnmGKi5KQ5vD7gjMMWy3bT0e02hOCxZELtPMmlkGNmmjUP2BZtaLFFKB6s10aTUgQTE9M4klNS3LT3SC46/otgnafzfc3yAqR7xPs35KLYdOscOIvU8V9q124xpqUiKsLLmHpNoDrs9Bvf9eSSFeftDGWSh+O/ih0ZgxS94cWk+Um5oYutNrJpU44lZe2KLiLkuogKK0SJrEPBrcHWpg4xRhvaSp1LoDSC3cXm5+jCT8kcf+vTVPT/tI//zTe+/h9vrq5+RqQswg+yFpTO+XRSWdpSc+pabmQ7T5rRd6Ev1Ny9tThVpCw42dZB3/7Wrhf1yxzswSRuuaeZFeayYYZbZo4SVVqknSxNDc67pXHGGLu48kQ7H6CJja1AUJRFcHb02UVEPLeQ1W7YfG5qZDkGVTS37gFHdZ09Uqpzv43F8wJcj03J5cFnalbCnq27DTrO3SovRCrqU+o1WosHtRFz1VGdc8JZFUKLyCL8NnCDOjsbO//8PqW6gATNJH369lvfYrd9Rw7H774W/T45jz//K9/5T9/93Bs/c86MLLWhWIW4InVemXTNl5NgHLrmK5ozJ2I0eqN4ShbG08g8RYL3dMFRJHBKhSlFYp6R7MgykMZMjiMhOCyF0/2R42Gk4AlhoBSPt4arC0cYAtE6rJkYnDpbjlPGjgecm3A+4MMFwXaYjWfYeCQY6B39ZYe3jpzheDgxpUTvHUiviPDWqECHIWpWXpZzYomvmS5iIEds0dgSN3SKBDUWm/QeqfOBok+3LStVswqM8+qSzGg0ASBZx7/ktAirxhgy57wwcUpnKcVRvKdMkMqoCBXf12ZxFRkla3xCSpMSGawl4ZXiYmOls+hcQFDUcTE1I8gpjlHjXMxyDTJiKaa6pZ07NznU5sNcIj/7pbe/9cbl9gvP74+//XpUfXIe3/zmN/+zzXb75Yb3U0FIFuyjoiJ7vW+UQpxnUs6cTiMvXrwg58zxeGR/v6/inCd0gePhhEhheDIsotMw9MxVKMulcH9/zzxPXFxe0vf9IpgZY5jGiWmceP7iBZcXF4qitEo+G0dd255OJ47HI4gQfKjnp2W72/HkyRO8c+z3B3UmVapFw+456xhPIyKFcZyWemmpWPN13llzC6Wca43VsNls2LBdalwynIvkSi0qy02nkX58zTx0tuYZek+oYutpjPVeryIAC4Jc6Ieh5nYrYjRGKHO9T1cBEwOdacKC1LkLTNOIsaaKDp7tdstut+V+v3+AdTTGMGw2DP0577DlBDYcfBGhzPMDF1jLNLu6uvrmdrv94vF4/OevR9Un5/Grv/qr/8nTp0/fnevnukY+PhZ+1qLTY3FoLTi1n7/KVfY4z68997Hg1+anj7Pv2vn2OPevCZjNnXp/f0/OmcvLS958803NHA2hXsv0tRvWs/3btj9NE1dXV7z55ptL9t08z4uA164N4ziu1gTlvE5a7YcxhmmalufM88wwnOtXTdBrouDj97sW7x47HNfHay2Crv97nCfYahRrx+ZjxOd5PSc/ka3YhN+1eJlS4p133vmF6+vrz758+fIHnyoBkCYQABg5i3llyUxXXrxpne2lNYxWLCFLMRWjzilrCklbyirLvVQBsWb9qQWL5gPBquPLtMB2wBuju1ddhZpfYRASMWnehKALupYXs5xY7ZVaV2pKuLpQb52+OReCVxSXIaiLrBYHEm3fLPiAa+/dyNJfbq12p0kRDqeZaUpaAKzoLckjsULngzEU5xDJzGPGurl2IVc3Tc3PIDgchuAsJujExBrLaRaMFfre4fqeGYs9TngLmy7guupYtB6bOsWcWshiSA2Vmi3ZNFdaJNpAEQt5xuOYZVYxMM1grPLCbSC37EesFkaLYtCcCxgpsLUwK9jQOl2ExJzJ88wcqxtOPMb3gGWO6kEzQT/z45wJzmlXoNWJU7GRNBd1KIq6LUs2mkIuESkQk3b8FslIVkdf8Aa8wYjDFjmfX0aWfIdMExdMK+9jjcOiGUwWo2KiGC2amoIVzXCyxhCCJXSOaVQcQkpZ85qqC8FWgS2JOj9NbafW/Im6D0UnQqVd6PFapDCZIrk6VHyF5MrSe11NUFVobJWSMwu0+mo179C0bhOpeJqHvPgHiv/NK5SMtVHphlercg9UjypcPP67Wz5cXFy5BW+q2nezEvRuH4iGtx+CHn2kdzw934wsqbYi+LOMmqG4BOXsAjRFBSzroGQ9S1RYV1GwlExnHabXxfX+NHMcJ3WPzolCBAI5a0df6DZAIs4w1y4/0K+dD1z4oJqv04XspqsddkAfOvqKCYlzhKwoy+Fig+96nLVaGhdVOGM64jtF+XoM8zyRC+RsKVPSBgdnKDGR4j1930EV8PIo5ByxBpzXSb7W7oxeY5JTcc8YwtBhizoiJRctspPV8SBoMWVV3jTB4VyoGWXqNLZ1wROzNjfkmq1iQ0/OIDlV3Cd1jFc3ARbjQj39s7plsZqRYAJFCtbUbu46NtQNTnUI5Sr0akZAznnJdqyXxAcFyUImBEc5RPoO5k1gPI2EAcbxX/TW+5MDogngH4gCvXksJvLhrsDHL3nzL28C8XF3D21urn593T5hWtF3cb2oQ6xlR0nFjzunXfKaB2tIJWPrSShFXfw2aO7u4TRzqs7wlHPN2fWUkgDBew2pjzGRYqlNGcJcO4K3XcB7VxtSoA8O3wWywNB14FTgSlFdrtYaht1GHfbWVOeb5gzFPOKdJXQeh9GmgyKYYpEpYa12wM5zIsU9fd9pg5XX5qaSKsqvOu9NzeSyzi/FN2csvu+wQd16UnT8ZwQjog1XNYe5VfSt127f0tw2tfiWixCLoRRDRmo2bwdZ6viXZselLH01itg2tdmlJBVrfM1GKblmeyV1+Jkm+FRhYcGf1Y5DEc39UdFBSDXbkAWJmHHO7YbPPv0fn/7ZD//666L/J2f8P/mpd3+jOdGkiX+uOdlr48iSh3lGZWJsLX7ZB4tFW7v3nTVLEQmjf29Y5QtWYbGU6jyWos1ddQ3SmhUbslMxXV5FqvrzUrG3LbtPWmppy2KoOZVLAaucsy5kyYheLYA5b6dRJB4viBcckVm5ekvWTtqK5loXNIzRRgdrl4TqB4ttdTZWUZSG3W0e3fqeWl5ioQoMug4tSxd1qa9fCysLhnR1rESWjMD2u1SxwLlo1IRRFZXyYP+rW7gWKxpy7YHzUQre+93NN3///+zH/8//5vX4/yQVAH/pa3/W2kLMFU8hei8zruJvU1bHudGO+YLFLtEnZkHFziVBnMlJiHNi0wX8puc4zzy/O/H8bk/KmXkaKSWT3cAcR0xJ+DAgkhhPE6fDpOPaw2GOBAxPhoF+05ONJdjEtnf4oSdh2Q1bhsFgpWCmCZcsORZMgH7bkeyO1PcYU4hTorhAFyxuCDg85KyOQOtJ2emK0rTGgYyzLA5cpoKJqZ7vFrxSQ4Q6vpOpDdqiCBWrTkepbnusQYxBskWKIVWikHEeP2h+oNSGPuMq8UMspXiyBKJYJYSYnuK2ZEkwo+vvrK+hlwAD1qugKEKehGI9nfNKKREhiSDNwYBV9DhCFqdN3VKwLuDR5m2s1/4Ix7nJoq4Bs8xcXwy7X/nFn/tf/M2/+/dfZ4F9gh4/8zM/8+utoNuK+zHFs/u9VS9zqbE0WlQep2kpLHd9jw+B8XhiOk34io3cbi8A4cWLF8wx4r1lniNgF0f60Hc455nGaRGYQ/DEWoh31nE6ndTUYHVu0Hc9fd8xzTMheK4ur9lst4ynE/v7PX0/8OSNN+iHQV3Bzi0kghjjgvzMJXN/d+R0PK7u24oSNbXBsa/7t87istbiqxuuNUOF0C3uSOccodtUsaKh/mZiTIu7z1qLq/mc3ns2m00VHrOKbou9pM2XKuGgoQ2NiplSNI83zpqpmnPBO89m2CyCQxMPQggMm6EKe5HTeGKOs2IP6xxis90yTiPOO3wIS95fCIGckjYi5kLf94pHjbGdB7uf+Zmf+Z/+5m/+5l9/Pao+OY/vfOc7/8FaKHqVKLdGUzahbS3+NbGpuUHb4zGucu3eezhHNj+xX2uB0a4a25oTr4nQazFq7U6kCuPH41F1gtV7WG+r67qaQ6qC2DRNy/598Ytf5OXLl9zd3WGtZRzHRahrY7iJn7HmnTZRXFG6Z8RvcxxO07TkBjrn2Gw2i7OvbbOhg9diatv/teC5PgZNTGzbedVn+jiLcP23r8KyroXI9t8al1pWGawhhN0f+2N/7H/+t//23/4/fLoEwNXJqfqAXYq2bZFRqMYow5KVURVBWBaa4Ky6+yjgaSdiLZpJrB0eYcmGMNbWQg6L1NH4zsZWp5Z6vvQ16wJQqoC39jBZ6gL+TCAlOLcsOK33OK9CS0oq/jmreAlyrhNjp7k0pnbFNkuQ6Ht1TvNwtKivxa/n9yfujxOpFMVWFJ1gtyKAMSrmxKRQUYrgK5o0iRC8p/euho3ru9luO1zwhFPBDR1bry6jKc3EH9/TBcNu17PZ7DjtDG6vAkAxEDxshkEF1xDwQXO/svO4lIiilmCHxc4Fi8NvelICsg7QIWihPhnFboRgcN6Tprm6gELNqlMnk/WeaT9yjJESJ1IUTnOB4BhqkVAnATvyeCJ43XaeZ8RY5jhrAbGc3ai+3xDnmdxyAgucplkn6UXAWRwWZ6pwljIzXnGq+Yy3zLXbL1hbC5UNPiaUosUUMU2os1VkVmQZzta8toKz+nwrmj3mnSNnIXmHKXnpBG8d5kuhonY8mjPbSLsiXcuc8efCi3E1f6B2oqPYXBGNbLR1DJzdC03d0C5V3WBBrKmZmM2l28bJGff0voLCh+kVr8IN3tYwNEYV8BoV8YFR7xZub6rA91j8e/RSt7fc3DTo5+2rNY0PciTWJ15yw5ObK/0sav7f2b98/teu/7VU8c8Rc15CAjXXQ4WgEDqwME2Zw/3E/nhif4osVjy9O58nChvF2Y7HewgDA0q+TQAp8jIFIJLiM/owMA0B1wX6zQDOkcdMOZ5Ixxnv4HjfcZomhs0Ga6DvOhDF+Dlv2W0HSuiIgAuhYgkLJanQFbqwHIA5ZVQqgJIjroiijp3DD5sHXbEZxW4YgZQsvh90HMUZcmY8zpRUSOPEaUpkZzG+Zzf0dD7grCeXzJwUtSPUsZ8SMSkiSJ1Iet1JJMgFSQULRM68fxHNU6Xkim1VtAheC/p55SzQDuLmVC9qhiCTawuAtbrYl5IXTCgryoNkNYHbHMgOnI/4MEAcFT37ETCgPzGWlnP15idP4dv3Efoef33zPsLfzfsIhJ+AouO/zO2bN69+o7/ovw66iGyXvtZSoeeDWZo2zp1oteiXSw0XprrDlB7gQ4exusjc72cOh4nDPC0NHbVraSlYu14XrtO4x1pP57066EQzZ+6nDhknJJ3wvmPoPb6zdJsdWEeUjBxOxHEmGMth73Wi3e9x1tB1Xs9bp006u11PDj2IwfnK2S9CSZlSRNFAtft2jhkXKi46RWx1Slnv8X1Y5WnqXGyOMxRDSoYwDFgRcoxIzozHURfrp5lxiiTnMCHo+HeOzmoX8xwTxukkbUqKJ4qpYJx2ZEup41+S3oeT4rUTuWabCiKuNrmwFDTjLBAsIlp4aNhgs7g8c21y05yiVuA1dV7bMs9ahlsTAKS6tbbXF3/4xA8/NUV/+ZSP//DuT/3G5vrq6020a2pbc4Gxyo1bGqRYYSRXQhqcF6GaYS0VP+0qovKM8lwjhqx1y7+tX2txwkkhFxUZbXWptSavFg3Y9rmgTYhLpl19PduaJ1f5g/o6Ff9eziK8Ls2qC9rW+WPbJmeR3LasM2trLEN1xBmzZHG2Y1bknPG35AU2CkulHCzCqJWF+NLEtrbgT0WW188lV4yZWcRDlmmrqY6+mlvYMkVqwfXB4r412K0KMgZZxB2pjQgNxNHWjyLa6CCrAmUuhaef/cwv/fhTJPp92gXEP/7tr/25r75783UomkvfBPvqpI0xkdIy0LDGUYzo+LOGHCEnoeTIXPHRwVl2F1twlud3e37wg3t+fHvHj+9fkqS5a7Per+ZEEfCXT5nnxOHF98B0bEOH94ZjHnE58vLwGRzPyeMP2GyfcHWxIWwNw9VTsrzBfp7I8TkyWTbO0wXh7q5jdzWx6bc8eeMacsQFy2bjuXpyQd5eUqzDG1HsYBbKnBBj8EEgJxK+5mBnpTLlCVdmHQe+w3QBnAZGlBS1AahEzR6nw3qnWO6izvwpZc05Pk4cx8TkLHQ92xDYeos3njknppS0CRGYpllR57mQrcd4pYqIccx5RsYJXwwmC9EWslEku4jWILwpiMmUKMzR0AWDlOmcseo9hlAbvZPmFJaEsUXzB402ZkvFlmNz61XXxg5jq2gM3/rKO3/kb/7dv/+6qv4JeXzlK1/5i0+fPv25OKvgF2ohnPkhym+apgfF6ZyzkjFq7bAhI6UUpnlmu9vRVfHo2XsviJIIweGcVSqQD6Sc6HzHPE8cj9o8k6RUd4ySNbp+YOg7gvPMcWIeI8YaxnEkhMDF5UXN5Es8e/Ye7733HiklDocj0zQyDBvmadL7cs7sLi5wzjEMg6JCTcBcGbbbLbHiRp1zbIaNzrOT1HWydtnGqCh+RZDqmEk5YY3F+1bEj7RM9JbhZYweq7u7e8bTyMuXLzkej2y3W66fPOHp0zfZbBQNmJpAWdGix+OJw35f5xGWvuvwzisNqDXs0QgnKsRgFC/a3JtKbrOahShoHIjReVWquaQ6Vzm7g3a7ndJenGccxwfij6/IxCagNDHgzTff/MOvR9Un5/FLv/RLf+Ezn/nM15uI28Six8695hQDFgfeY2xny6JsAnm7fjTh6rGo9yqx71Vi4KsyCZvQ1X7/GEnaBLWL6hzebDbL12shcy2qrfP11te67Xa7vGZzMjfR63g8LrhkoDY9bJf9ePbsGd57njx5gnOOvu+XbbZrQxMDp2nCe18RxmHZZsN9rnMVH39ODeOZUlrQv00EXD9ak8d6e+vIhMdI1leJsq8SDnPWpoWvfOUrf/TTNkZ8mxQ3iWAJUl+tEFTEaEKMqYs4WYLq1QmoRRrtytRysWlhrbXaXEquE049OZwVsBkjij9EUu04sXXR25SU8gBziChaahH8kHOGTe3edraiHkzLEdRsi1QS3ZKfVijJIJ3mDOpkT8kTmlajuYKVGaQ5VjUD524/8/xuz3GMpJwZY6yFZYNzpi7M1UaZpGHDlJffBw9i8Z12DM1zBG/pfaAI7E+JjQjZRMiFQ86kSXFdfR/YXe44jBO5vKwse0PvLD5YdhcdF5eR3W6DnyPbPjA4i3PapW+NA98jJRFLwVlldAermUI2dHRDx5hmfDkzj0xWJ0P2UoVYQxQLswoExRZkSqQ6ey55Zh6PjMM1Jp8YNj1jzOzv91ivF9DdpuM0jez3GozsgwfvMDjEWlzJeKddghTRIPUpUlKuBZoZ4x2dV2RmSomStJohTgUwRXyqmKNx5FZRh2KXQoVGlLT8kboAbHkIsWgR1WamKZEpOGvwFkZTcJaKX9ECrEllyS+RWujwtoYR1TqJMaJIRyp+Rp+JWEdB36sRRas0hKetaW7q1m3wJa0165gtNb+zKfnqdGz4lEUsr5mepmkcH0X0433EiEc/PzuY3m8jt/X3N2fd4masot/D597+5IbeVwd5pRgCPLkcsE4X4nYl/jUnn16EeJAJ2GIhS1ZHXSlQYgan4rr1MCU47WcO+3vmezjFyMhIjFTv30oLDMAJYhyJ4y2BG/3Z8fzcYRtwA4xxIB1Hsg90wJxH2AMkcj6Rx0jnA10f+N5775FH6IbA1cWOMme2lx2X1zsuLzd0XcfQBy6GQR19lV8W+g7Xd0hMzGlWd6jzBKNjpeuDnlBenTL5UbaOs5Zcxc1SM1ARIcdc3ZGQi2Uek3o6gybrDZ0nTzNx0s7HELT3JObm1CtY7zFJiywUhSRrZIdFMiAz8xxVLEwW610NNc91/BcK0yLoNlxuKuCdxQGlRG0isBoHs0zEqpBobOvqyosIWOpp4jvPlE/6NXAK+vn9i7gAVTh8tYh985hm+0EZf+/nrP2An39UTfCTng3Wv/3GXzLG2pLyUgxuhWHFe9bcCVGMrdSsOQFSkUVUzlkL/M5rtmXMoqLf/Yl4Spxi5CRZG2ZKwYvDmSoQWAPjSJonUjriw1Y96CLMMeG9Y9g4bOc45sA0RbILDMYQy8jxKFq0SiNpinQh4H3g+z9+Tk5C5zsuLwZyzuwuBi6vNlxcar7Hpu/ZbXqsYbmXh67DdR2SEnGatdFKLN5owb4fBr33uToHq4viJnA4a8hxxhiYp3MGWU4qrJeiqNRpjkySkABFDH2nOPJ5rl2C3oE1pKxd15or7DHO6f0yK2vCWd0XKZrhN8dEnAtkg/FWnZrV2R5TXpDmLBKOqeNfm3dKSTSvUi7UXCNq447Oj8RKvfZVXaOKF9uL4fe/9wku+P9Ot/dJH/9XP/3Tf94YY0p1ri3NgQ1rax4uxK01lUBS1w/ycE9LEYJ3q4WlCkOuCgprxOc5369eA+rPWkaeqdcbW3PQS9F5p7Mt85IFWbwscKsNVhe6shTI2j7kXGru3xqraZY1Xa4bc84u2zXNCV1ze1p+kOb5liWvqCl7C95U9J7d0FlG1lgddeCd/56z8zCfRcqWv9gKKW3R37KGKyh19dcVObgqFqy7tU1Fmxl7fs/n9SdnnGnRfdRlhKlXfFlwoNZoTqlIQYosGaLbq4uv8Hto/H/SH3/yl7/xGyEEW2JcYhakfv65ZGJUFLSK3io6lTyTExQrpLmQpqSfP+A7wfeO/Un44Y9e8MPvvcfxvRPPjnveSzOjKcSU2JRAZ2t2rw/Y/YHT4Y7x8EO64S3EgJuF/emIt5ntxUvMtuNFvGZ/mJn7a3anzP10xzPnmeMdTO9hpONie0FwnnE6ME2/xcVwxWfefgMpmcsnWz7/+Td4cyy83ESeXO643g1sg9GsF8B3A64ryGSQFMkVh2pL1PzhfoPvAhJU/GvnizNO3X6lkEquFJugTdPGnvOTs1DEMk6Re7Gk2TNuDKdgEGb2h8g4TvTBgoUxCXN1+pgQsJ0jYDBzJOWkVB/Resk0z5rJOAtpPNFtevqN0VThXJhiYs4GT9J9N4oPLcbgjccVAyS8tRRqlqBJ9b5PbYTwem01ebmeG3Q98tOfe/q112X1T87jy1/+8m+IiLXO4kWb/5vLbV3wbeuCVoye55kYI3d3d9qMYm1t1jZshgFnLPv7e46nI7FU9DaCr9cSdeB1S7PM3cuXxHnG9QFTG+ayKHL4crfj+vqKoR/IKXM6ndRV4zzTODKOI955Ypz5wQ++D7Vp9gc/+B5xTtqo6z0pRp4+fZOLy10txAd2u0t2221FfCpO/+rJFdvNlhijovsEFdFE8N4tbh6pQto814YAwuJqTCkDcUGHitTYEqsiaN/3vHz5kmfPnmvmrnPEqKLA6ai5hn2vGYbzNNdIEKHruwV3qqUuS987xYgWXTe0qKfmlGw5x7pvsjj6YlShchF6hUU8aPNBySqUqOvpnFXWV9eUMWZBmArC1dXVz74eVZ+cx3e+853/MOds15lx8gBDz/vm+62Fo7Uo91iw+yBx7/HPX/X7B9SNR6+5xpOuH01sa6LcMAyL6LaeF7d1ymNBay0Qdl2n1xjvsdZyf3+/7EfDijZUsKu5pmukqNTs0YuLiwUhujQghLBcI7z3i4NyjRJdz9+bsLcWPluuYdvntQjYBPu1+/FVIt/6Or/OVHzVf49zIdcOyLfeeutTd//36nyzSyZTWyS4+q8sKe6rBbORswuQDCZXzI0lGwMlKqXGlNpx6dTZVarQYmYMagOlUG33CWRWgcJ2WviRmutnFddo7RmdsywSpZwXsXkV4tjwOK7mTyHknOidXxaSzhq8Nzjnl9yfLNWZZY12zFbkHdYxRc3Xi7Hwo/de1jwfmJKiqqq/hFwMJus+TCnhnHbgGwHXeRKGaYowFu3S7z2D7XlxfyRnoes8WTwlFnI5kUQYAgzWMk+Z43TPOM1QZnoX8F3Aecsw9KTYs78/sdnu6Jyw2W7YdoaNcwx9R7fbkg1Y53CDIjr7YadVbAfdbqMYUhGiy5CF+XQkbDY47+mBeY6Uikm8HxVnuukCBEGOs+YnZGGchOBHpsNEzon93ciL46wFgqSCsPUOHwzOGOaK8us9zLkweEcXLNZp9kKaZpJJUCydLcwxk21hu7GUWJCSsc7QeQ8WzWqzTbMWgtTCinXaNd0cdbVL2lSekLVG85KKIkBLFR9txSF4q/kk6s7Ti6y3KmZooams8FDqJBVx+IbdNI2lbqszxWgBOuuCtNiKKROhSBuJZiliGxFFmVZMFdVhWOq2TW0jl7WKLw2Hqm5CeewCfN8sv4+oFtycI/q4faxCPOZ1qnz3UPO7/bDNf+D3j1XBgRuunmwfZv45IPuVAzBh8TXHUrvibdFOs0UtzPXvasE4TnBMMy/29+T7yMTIiVcIf/VxjE0huiUM65/p+42qBbKNQxUJIYZIIEIcOY4QBghhwAOHGPEJiJFTHNlE2I9HUhzZHi95cn/k+aYn9I7NxY6r3YZdsPTO0oce0wWysdjgMNmp68Y7SkyEzcDl0zdJOTEd9+QUMeTakW/phy30A8f9AUSbJuYpVzHFYn2HdeqkDkUdvrHAPGeO9yfinHj2fE+Os34mQXNGfLCK3bVWMz2LOv68s2w2Duc7AOYJ5rkKhilq/pqDoVPXkABpzngLPoQlF03IxOjwFiiq+CqdUbufS8NdF3VJWCDjKhjsjIrtB8/poE3RDggRjqOeazeLV/WD9fR23o7cqghYf3qG4MJtddO2M/l3NDDeb9zePhqnn7Ji/0+8hnef7S833z5X0Gt7x4I+1sK1s81VU50vFV9rkOrgq24eo8JWjIVTyjy/v6McIpMRpjKRamacsQ5TxYBihDFlyJOSBVxHlsI0V2Z+LJAyYy50XSAmoeREnpLis+PMPGWct/SdChLHKPigqN55OtKHjv10IKfMZj9wfb9hGO7pes+w23J1sWEXHJ01DF2H6TzBqHhms4WKQysp0g0DF28+1ZyA44GUokqiJSOm0G82+H7gdDggRXHv85w1O6Mo5tO6gBDosmYSx1LU/bDX8f/8xYE0K2YYb/Ft/Fe0byxS730QvGXoFdUDlmlS/FrJiv10TpHfQ9AOwWJgShlnBB+8NpaVXMVBg6fmHFm9t1Pnhe3eWDi7qRTzfv4dAl0fPm92wzflMP53n7ai/6dt/Jvt9osXN2/+Ylu3KFLSVNGpIdTPaM9WVFoACdURootLU8+Hh2JXaXM8ztnK1KaYJRPQsDRYlrrIKnX90RCbi4AlhpQUt9mEyJLVcdiysaV2sedcySa2XbNynaM0h1/FeRmDMU5fu6E0F/x2WYlnVJSnXQRL7YSrOevN6YdZsoikHYt6jEtFcK70xwd45drNtipqmFVzwbnbX0RqsdYti/XmSsSeBU5B13bNpdxE15bdair1wxhIuTWPno+3irOt68u0PoIzVrV+ZnosDduLyy/Yp0++UZ69+M3Xot/H+/HG5fazv/CVd/4wpVCKQl7FWEpRcksDREilooip4lUsZCCWmekU1VlvFE2finAcI9+/O/Fb3/su0w/37B28TM8ZZ3XQetfp7NFC9ob7FOF0wKYR311TKLxMowrLqVBwHPZH+hiZx8IshTwmTlPidPeS04vfxvXC5VWg84Zn44EQOkqJHA+3XIx3PJuek2Lm6dUT7u9G3vzRnn7ouLx5yttPL3lrcOycZxMCu+5CEdsIJidaqAkxY3pH6RzJheqWLGcOvhHog+aezjPGeJBAKpYstl4r67XWQsiGMEWKiM6Z7iP7/ZEf/OiO+TQrot8LdtvTBYMvgohnjBolICnSucLVZU+/2SHiOB6FeTyRxpkShc22p9sFtoPHOUsSwzwXNp1j6LYIjlwS2Wh9ydQM5XbB0lzCssIROgoGbxuyuM4PVSPkczfXn/+pz775C7/1g/f+P6/L6x/vx263e+fm5uY764JzCIFpmpZicXOKNLdKQ+vN08Q4jsQYub6+xnvP/v6ejDaI5ZKZ5knvO2g8TDCeIfTYisgzBuYceXk4kmOh845L64kpc3e3J6dCzIW7Fy85ng7sNltSVndfFzpyqq68nOj7XjGf9ZFiYjyeOJ6O9L3m581T5Pmz57pYtYoFvb665q23bjTPb7Ph8vKSJ0+ul4J6c7hZa5mneSnkI8JpPBGrQ765pUMX2IbAPE0YU3GAOWlsAIZhGKogsQFgvz8gItzf3/Pe7S2Hw4H33nuP+/09w2Zg6AYuLy65uNgtl5lc90vz+ga6EJRYggqS1irVxBpbXUCV2GSV3nU8Hikla2NhTMvnqMeoCYhGhcfqCmuCxzo3rAkic2sYzYXNZvP5J0+efPPFixf/3esR9vF+PH369IvvvvvuL74KFbm4w1sdsP58LUC1a8NaqHss6j0W9l4lLr6fWPiq7T4WIx/MU1evFSqet52vDVfbXIJr4W/tUJymiWmaFmxuqi7n5v579uwZv/mbv8nFxQXvvvsuFxcXdF1HqG7nH/3oR4gIb775JiGE5XebzYZhGBannjGaydkcheuc0WU+XxuHm6CXc2a/39fxWx4IiWthtCFAlxzPV+A7H+c3rj+LtSvwsdOyuQqtfdREWV2Al5eXn3/nnXe++d3vfvdTM/690BZ5dnHqgdXOuLYiMuU8UTTVnUTL9BPtKAWkWLzkuvCtTrFSNGPKOrAeY1Umk5IqblTFFO3EV+HGWDCuCRluwbg0G/jZ4aRChjOGMmVMLfzYJsJUSmnLBXTWEpx2fqlC7Sq7tqr+tSgoYhCbNXNH+XCkVMgxkaRwOs2Mp0QCtIZXUY9UbGgxmh3XbTAmUWKsIoJlmlLFqgpWFElZoi4G5jgrWqAYjs+POO81GDhnRAKHkinppJNzJwTrKCbjsqPLiTQn4hwJwfP8xYHNxZbrKRI7z6EPXApcWA+oUDVseoLVzL7Oa2ivINopXPQCg1eXQXMFCAbbQZqiFg2dZxR4fn9CUuTw8kQ3qG0+ZoNLE/cpE0/w8jiSM4ynmZRmZjG4LhAmS4kTc4rEKROzYDur2YVi2GwV1UEWrNUi6XbotDCSDON0ZOgdGEeZImOC3bbDOiFOUTMQRGpQee1WtCrqmVJFQGuwUoPfSxWWMajBoOIBG1a0IgVcw+BW1G0rdpRaVDCm2Y5dLXA24aniCEQzn4pIzWAvSNGOytycemey0vnmZTUP0cg55w/OhUpYRfw1Zb/t6jl9mUUa+yCc5u2HCQ6K/bxtYsXt+Erp4+bmhtvbV4UMfgRt4wMwpctWVj8fuGHLLZvuKaXm/qnrz6/+UsU/vQLpv+r4SZT6vX4N1nrGmOCUOM6R/f09z+7rCw43KvxVoQ4GIuOiBIYIcUCdf+dDtrypkVsVA8dFuVyEwPbu4ndviTc3hKFuO46L0JgYwAe810zB+yNMc2LTeWKE0ziytY7dJtCFmauqcAWrjrZus0FSxtQxcBqPOOfJqeC7DWBIadI8LWfVJXixI04TMSp2+DgnSsnqlBRDjNpdHeeZVCCLZzpO7O+PHE8zJasoGPNI2Ax4B+WUOM2Ju/HIdBzx2wHnA5s+sL3Y6QRtzliX2PVb+tDh0UzVwwm6odOxmjNJHIPXrMRK/aQwk4qjxR5JzUwsdjE8LLjr5TZYReFccyC9dZQMzTzqmz43/ve/EY8Pzvuhns7jB6uIHzaMPijD819xcfB3W1AIX7j531pvr8rKwSo0tKMKO9a2PK5zfpc2KNVcYinVFWqYU6akxDhH7g4nXt7fYYtDgseZgJWEdV4bL8ys9xPrcEU0B9cERdEZS5ak+FmjQnYk6XkqKh6keWZOc3WgBPI8U3LAdh05Rsw84xoJwVmyd9ig3Xn3B3XfbfqemITTOLH1hl3fEbqOq3rZ91ZRwGEYkFSU1mCpeSRt/A+afxhnSkqIdbhg6NgxT7OOf2s4zrqYLlEbmmLKxKzjP0uhSGA8zhz2R46HSb37U2TOCb/p6KwhTzPjlLg7HjnNEd93hOAVcbIdsFjilLCusB0G+hDwQJwiB2vpeo9zUFLGW6vuQHT8ty7lvMK8LthAo5lg52uALM6rGq1Gbk1x1rpwffnHp0cC4Ce56P9pHf+73/+1v2J9eLLOtDszgFeL7AXVaevnbc44yIb9FLQQjKm5gWZBVi37sUQPNDGxoturK29ZSlW+pxRRhK2RxV2g2NpKVclmwU+WWJamx1LRBa2LfSlgtW3UjPaU1dGrIlyu17vzwlfdz4+KFc38l8tCebEtyqC6+hqWVJZMds7jhZbPV8U3Kavei0ZEMYsLr82dnbOrFg0W5ObS8LaYfM/HqqXzYi2mPje35oFWAGgFn1wWwbNFS0idGjtrSWjuT3NCLnkuYhYHsM4FjL/84hf+zRePBMDXot/H7/Hn/61v/ydPLrprzfaqhSIbFCZkcyX9qPvN1IbQNCfKlEhY5pwZ46TCeTC8PBTieOL53T3/7Ac/5p/89m8Rck/eDHRmg8sHQn8JOIq5R7zH+x6fInPJBNvhcIgNxDwyux24iJmOzLVm4AoYvyGfTjyf7ojzSI4bwnHm4Aami554OOHdnt5bDI7UD6RhQ3cB4zhx+/wlU4xcX1wQxXI8nXgRDE82HZthy5sIT9nQ2YLfdHqNGGcsDmu72vhc4zC8U1RnyYrVswZ6r4jM7Cg4knEcStH5QRJs8Yxz4jRl0jyScqHIluNh4tl7L3n54iWpGE7HkX0cCbsNgwWmibv9yA9ePOfl/ojxjtA7rt94ytXVFY7A6f6ItScuNzsutxdceiHPI533bHc9w8ZiS6ZIh5VAMFTETiFTmNCcVestkjKuZASnKOR6WzBGMLbgigqawRqydSCw6bz71u9753/4WgD8+D++9Qu/8Ff6vr9sBecm7q0LwGsXS3OGOeeItTDe8rNCCBwPB46H45LXO+cZawJd8FhjcNZjrdZunFXXmHOW4C19FxhcXxvHjc7V54xJhVMcNRNwSuSiYyylyOl41Nfue+739wSvNbAYE+89e7a48Z3TBnnnPeNpZI4TL+8P3E0zb2x+xHvv3bLZbPniF99hHMel8A7q/Lu4uFDRo96XU8VoShGGfmAzbEhZ64rOuYoD1by8OM8UEY6nYxVNJ3zwi5CSUmI+KXr0Rz/+Ee+9957GCzjD4W7Ps/kZT66vuf2x4+7ujmkcOU4nxAc+99Zbmh9mHVeXF1jnyCmx2W5488032W53pDiz3+/pup7NRuNKXt69ZJ4m+n7AuXOGWs6Z/eGgGeau5i56T+gCOWlu+1r4W58bPoQmGvl33nnnT74WAD/+j1/5lV/5q33fP5mm6YF777GItxaC5orJXWd+P3YJtxy8x9lx7yf+Pc4DfD+x74Ncgq9yGbbrWMODPhb8mjjYULatAaK9h/1+z8uXL7m/v0dEFgzu5z//eQ6HAyEE7u7ulHyx3TIMw+KsneeZz372swsetGUMrh1z7fXX77Vdd9s+LJXYlLi7u9PmgOpAfOONN5Z9XouAazG3ifXr9/vY6ff4c/ogsXUtADZBcS0Yi4j7xje+8SufKgFQD4ZdGYXsTyjT7Wd2WXY5avQz1mjnKgjeFDCFYjQXrYU1NwSnsVCyCmrWVTW2CoXFKjKxLcLrcNOibM5kiuIrK5JGXSIG5xUPpVZzRetYY8gZfPNwiLoDW2C19U36EByGSpjUhUKVd3LtSNebYub+NHIaJ/aTZv6MVcjzzuH7nmxFcw8xlKxOP+csKarpJBXldBtnIaryNEvtZDdQrMN2HXhPKZYYkyKonNNuoTjVAONcO/NEXzsEgjjEQ28K42nGBcdm01HmyNEo1CxkdbpEEcRsGYLlkAvXlxfaQWwsXdDJTx5H+q4nYBDnkEHz71y2EAwEi82FdIrEnJlzYRwjRjJC4TAm5kk4jhM5W+5PBXtpiQWmOON7C2Ygnk7Ew5Fnh4njlGoHseaBxDnjgqfbBuS9FxgTNENECv3Qc7krBGsU1SZFc5NCp+QyEsdp5nqjHVlSFO0WixY+HSjO1Wi+UHPDxZoTt2jiuSiWqRiS1WxBaQ5RZ7He0BWLeMEWgxMVLI1kDRGXFubSsLjaTa1Z9AKuiucZTCl4p7hSLaLoQqxh5ErDQVmWwhSiWNuG/9S69nnkZLPIgtpZbU1FgDYEljwUCnh/oe39ZIuH5M3x7DC6XesQFfl5QxUB+ckswNv3ExhfLfrBq+POlg7gp+8Afsn+ozn9MlgS4LFuJf5ldQRqfS1VN6/m9MVx5P4UcWNkPo7cj7fNwMdwc0u8fIcQ1M0X46iCXrghBO2I43hPHOseDk00ul15vB6Lg01Vqs+/UafYgpqseuEw3OiLovmDHpirNOiBrqjwPobmDrBwnMDA5aZns/X1eBjsEJTznwvptMcaRx/6iqeFKJM6cJ0h185hayDlSC6Zw/FEGico2uQwniam6Uj2juHyijn05C2kKSsayTnKPPDyNDIfjhBHpqjH+zjW9zqoM44fP4PxljDcEAIMm0suthu2ned4GsnA5cWOi11HsJrBUowjAEaqXGccUYCYFStK+9BdHT5nx59OUPIiBLaCoYrC6vV0PkAY2UZ1cP5OsvZuqZjPm+YCPPv8xuX/B7gdPtj6+uEa+gfjQz8lxf5XPfo3Ln6l9T+0LLjFfYJ+37LtrAZLLoSC0hYGaC5cypH9ccLETDqOHE8zpzjhTaci4mZLsD1SMilpl6l3A953irM8HUlpAtuBrZjJlEg5Iqbg3bY2cwBJ5zDNLWMHjyTDNEdKnMmSMWnE+p7NsFFoQsqEThtgknWAoas5VvMk2OygRHos5jhigItth7Een2sOQq8NNSVnxtMJZxx919fz3pAE0jSRnDYkaUaY5iOlnDkcJ9I0KqprTEyniWkaKc7SXwVi6EiDECdtpzdDR5kt98eZeDxR0sycI6kYxnFmPkXoLOFuxEgmzSftKuw8/bDjYrth0weO46Q48d2Wi22Hd4I1mWIS3oAtLby6Yl3rPb31/Eudc5jWJNSw9/bsnKc2lBljCJvuq9Prov/HfvxffOYzf7y5+tYuttYwZTUETwUf55bcTzDqbqvZoA1xq+d7da3VDuFFJX5Fh7Bwzh3MTVxaPadIE84qVreKVc5Z5pi0UNjsfcv2G7qsXtdSXiHNZFk3LfjRdu5TaRPVsbfkQcs5+6+scf/GrLIHzdkdXcUwkZXtr64f1522RQS7IPVZMKF6DMrZhV1RnLmcXZjtdXW9qNeaJZNxcelpq06p70/qdbq91lKAKY3oYasYaFZYVbPgw4xZZQ21tac0BCirHEJhc331tRevx//H/vFHfv6n/0dYR6rieXBdxVVmbBGwoRa9ayRE0v9KjExZmClkA6dUOJwmfnB7hzlOHH/8nNv37ni+f85gr3AU5I032GwuyWVkOj0npsjUv8Gm3ylucr5lnJ5BuNaCsu3w0z3jfKSYwtC/jSszWIudAsUI3gUIBveZLbbsmI4HDi+fMTPj4jN8d8311VPi3OFLxu8CyRhOxmEELijkaeJohNB5iIVJLNyfMCJcbz3bbY8TS8EiwSFGiQQ2FZztsNWubESvdaU2CRICxjqsWEyJ5GLYT5H5cNSG3GPmdJw4nu6ZvWO42TBtNoyXiXF/QnIGM5D2wvPne+L9HWk+MqaJw5zZ3+25T46ytezuMjZ/lzQ+U7RhEIb+KU+v3uDtm+sahQI3N0+5ebrjcuPoSiTKxMYKXhIGT3EasSEx4yuhQcjn+aFt94l2f6j1FcfZKW7g3c8+/frr0fXxf3zpi1/81VbEz8s9hAdF/VZ4n2cVkpxzbDYbxfjXOcH9/T3WGI6nE6fTqHEXKUMIhN5inWPT9/gQqnin+fNd8PjgudheMI6jov1TRkqhM47i3AK4zrno3yVh2AVC59kfThSBru9Jc+J0VMdhipHD4cSu67l+44rjaUQQuhAq9nOL94F+f0dMif1hjzGW0+lE3/fc39/jnOPq8pL+4nIpoG826rbJKTHNU6Wi+Tov0uYkdQxpPVad95lpmpfcv/v7e8V8nk68eP6cFy9fMmw2vP3WW1xdXNKHwLPnL7DOMFxeqmPvcODZs+eM48gPf3TLW2/dQCzcPn8Pe+fIMROs4zQfub645vrqmuPpxJtPnwKGFy+ea73njTfoQoeUwvGgtJHdxY6+NhKOJ3U+ff8H36fvFJFqjME7X+cGarZoOWXN9dNEiOY42u12v+/16Pr4P77+9a//m4/df68SANcZf+vsufZvE5Ue5+k9FpXeD//5YaLe+2FEPwwtuv67JmA2JGb7fXPErYWytYvuxYsXGptVxc/TSdfYT58+rZmedw9cstfX10zTxHa7fYDbLKXgvV+aJXa7Hbvdjq7rlkaKdnzbPrZj3ES25rZ21UG9zgZ8P/flq8TY9v3awdc+t3VW42OXZFtHTdO0uCzbvrX1V86Zt95661M1/n3NgNcFr4iKH+feThUUatHM2HOGjkW7JrJop7UhUySD0QupbRgW5+oCUDvurasqrjTkoj5PGnS0aPaDVuPq4tqcUyQsouV5Y6pwo8gIY42+lkCWrAtaZxXsZJvDMOONxzrB+uXlsBq3VnM5KvdeMsYWxkl4cbfnFDPZwDgXEorQ6tsNI6ioOadISSrcxdGwqRlCpU4apBT60FG8JY1J8UAhYH0PRhSZlyF0DhtaNp/Fe8g51Qw/xU6KMSQRQimUaWQ/CnMIDF3AjzPWW3rXaV7WHCneIzLTbxQRGi43hE1gPI103UC3DRjvNSvMe+1SOoxkEdzQQc6L861ExWXhtMh+ignnDDHCjCXGmcM4cZcKTzzalVfdNjkX7p6PzFPCmcLL+5NmEboqmM6JOauQWFKmjEDKFKvPsaXAaWSeJqxYQme1y7DA0AUuLwPDEJizME6JTa9dWkPnmXJiPCW2vcfXTkfrFTeYU7shaDFYCyUFQRFprtSQ8DlV1Cx4a8lOUSnWaXbBNCuWoBUXdE0h2pmdbS006meorZRaSBUBZwzOgWRF3hYjNQfFVaFPC0ey6H+ydG2bRapvcp9Z9D1sE/2qx6F2whuRj8bWfKU4N/6EBnFbv1EtZPVHNRvw5uacE9gi/m5ubuEWbutf3dx+xJd/9No3D55wy/UbX12EPAsLxlMlpkXbqeLfyiXYnusgZYinRDocyVGFpnXs7HBT/y8+cmoNN0QGiBCJMJ6P1sCNft9y3m7gpqo/wwgMw/rwfrAgO96q6Dii4hiw2wbwgQLMLSQ365uxvuDnwtFEnLW40GHMhPeOy9011mRImUlmvDeM+3s9p3zAGac5BpseF3qyJMRkzQ+zEHxHCXAaI5FClMKMUwfgPCEJpuNR3UQ5kdGOxfv7IzDim+gZBhhvlvNFXY/fVafldoA4cn+6J50ip43mMaYI9y+ObDeBJ08usS7hbY+3js1GM0KNPeM8S8V8eucUP027/yge1NYmFwDrMzmrAVkyWAJzu3mGgdQ+qPGGm5vbV2RgfjRdffnox7MkfHuzlgY/RNz7FBX7//u+jnl69eth0321CYDngnb9QcuGaIinUpYidzL1euksKQtpnInHiVRzhLSfoID1eBvAd4hkdciWtEw4C56UNVsyp9pBjyGYAEVIcVbETt+RvCOUgi8WXKUVYMh4vRdRkDKpu8X6ihgspOmIkUIJgZwHvX8Yh3hHquPfGJ3fkA0mSR3/k2bX+g5jZkXtXl9jTYGUmOYZ6yzj/l7znX3A2jr+nWYI5ilpTrIYgjWE4Cml5zTq+4pFmMUQxZDmGUnCfBrJ86wIXwzTaebl4QglE6zRMecc2RrGObPxBt85SpzxXUe3u6DEE4fxRIoTp+CZUiZnw8v7A7th4OpiwDrN2PXOMfSeLjid29b5i2mI4SoKSsNncw7AbrhAYxsSUJt5wtB96eM0duT1+P/JRc2XvvTvby4vf9YuRT67CF0N0ymLlNeaqBrm054XkjX3T53CKhYsuXU56/d1sdmccAZ5JPY1fHudO1chyhjIuXaeZlm2m1IVtqyl5FQvWSsRcDEyqhuwOdra+kgXwOhiO6nLyQCxJC2GNuefMYgRnFECivdOkWbGnOeR9twJXXI+Z+tVBKnGhJ5F0LIgeTjnCq4W0A9xRuesQAzk5kJYLuJK51CM5zqCQpYjaoxd3H25XcOtCq5L5ONy7Hjw71pYlTqBLqksyCJ1BZ+FxyJCzoXd1eU7v5fH/yfh8T/4A1/597/8pZuv5VJIWUk51nkdbyLU4gPS8L6izv9SFFldrCDeME3C6cWe44+eMe5PpFiYT4IQwQ90bgPDBUUiJSYkndQB5D1T6cgnzbYr48iUI8Yc2LlLmAvzac9IIV9eM208Q4QhB9habCr4bPHukmQMtkRmRnKe8W7A2B6IxP2PdJ087Mj5DXrr2XYbMIZoYJaC5ITLYILDJMM4Fu7MhDeCDx3B6c3PGs0Cd4Cx1cUbZ51/OK/XgjSriOYdYrVxzmdDX2D2njkMnHJiMpkxCycJjMYR54jEmXg4ksaJkhMxw+lw5EfvvYctkd45Mh0mWKJ1nHLmiTX0zhGnvdJ7Lt8kTT/g5XggTS8ZT1vGbEml43s//CFvXl/zhbefsrnwbIZLvIHLnedyC10AZxPB9eRUCFZzVJvIb4yr12WDNQ5rci2cqhgoYsEIb17v3n49wj7ejy9/+cu/fnl5+eU14q0VyNe5Ue3r4/HIOI70w6D5dsYodv5kePbsWaVZZcaUcNlgZkNwjmAtwTsKhXEayUUIQbPjhl6ReNOsDYFpnvBOHciNOqa5gF7xwjljBfKcEe8JnWceI3f7PSKFu/s7rR/6nl3fY5zjOE3EKdL3KlAZDNdXV+y2O4pkjscT3jlO08iPfvTD2kDXcVfdMl3fY0dbM9AdRcpyHwU4Ho+LA65lI3Y1QzzOM2XW4xhCWFCpp9PpnPtrDOPpxHvvvcdpmjjs9xwOe4oIlxeXOOs4HA6cTiMFYXjSYYIHMt8/7UE8X7y6xhvLzW7L1eUVKUXee/aMedYMwtPxSM6Z+7t7RQaGwDxPHA8HUkpcP7kmBI+x00K/enH3nDeePK2480HpdPVmunZUrcWKJqb0ff+51yPs4/349re//etvvfXWV+d5fiD8vSpPby0qNUGpXR+aq6w56ZootcZqPnYBroXFj4L8fD/h74P2c/1+1kJXE+oa4vex2NVqE13XMQwDu92O6+tr9vs9/+Af/IOazdnzsz/7s8zzzM3NDSLCNE0cDgeGYWC/33M6nZbj0cbKMAxcXFyw3W65uLhYkKDr7L727zqDb+3MbuJhri7d9jtZ0VaAB26/xyLe+nNeH5/Hzsn11+v/GgJ27ZRe/3t9ff35T5UASO2ON6birir2pGFWjEjNFmsnoLRwwDphqthDtTUhxqIBSwZjvS4W2yKvKFLRWavOjCWg1dGEyIJOxl0t0avgYTFoaK51Rp1SVVSSrFk73hr1C9YMh7baWxbvDZOD4I3DLRkUYL06D4skrHEY0eV6wvJiv+e9/YnTnNnuNoDQBYsJdcJoLTFn8jyRgb732KzFxZhzFQRFredeFyE5F7AGWzTfw3WW+XDAWodQmMdUUUBCiTMp59rV63RfWyHTnD8KV2+6UYSYwR8iKWSGzQabhdlAJvPsvT1XGwuSeWvbE1Mhxpdke0lJkcF7gu8UVVaKdsz1PVILkxIBk6AWS0vObDY9czyQMmTnkLnQ9w5XLIeozqrpdOK4nzicRo5jpPeGu+NEwrLbdJScGKfImDRg3Fuj5+RccCHQOV2Ep5zIohcLWxJkT87qdtinxClFhs6zCY4icB8iQ7D0wWK9x6GTr93G01nN/Mmi5X/EUErNmcRqBEotFreuamcNOalQi9HQOJfBG0GMoTVem4pQkpo7WGr3sitNhNDiqUYhGeZUc2EQjPE6Fqy6Ut0j8c9IK17Jg+xOu1wAH4qC1NdZblCUn1TR1sjPm48iNjxkH66Fj9v1H9ycf7cIeSvF8Pb2g8W+W169q+vfPd7lp8ONNho0xc49VO5KBlzCZo/t9DKortCE7RTlMZOJp5F0ODIfv6uvEAZS0L0b3oHAAAFi/O5KA6x7Mn6X+8fva6heyGFQ4e8W3hlu+G4A7msq4oIHvV2UoYEbFRubI3Cs6FBU+AMWh2EOkex1MzFr/iibgU1/oZjhacKViZGCt5Y4z4SghZA+eIixLoQSJSZSivhBHc2+BXcnRWapvqiiQ+9hToreU1eiXq/mcWaaj5SYSdNMPCWmnNiPJ8aoOYcqpMGJW+K9vsd3bs5nwja8g98EEoF4HAkBToxw0gl/H+DF8Z5THJkTdB4yJ0WIdp7NxtdcQEewigcNtqqBtZABVMwv5xPGtgkH5IxmljrIU2RO53EQ0IzHf1ES6DBoTOQ4vq80+LsyOZBP6Ov0bz/5i8YaSyMDNDdIvTjWGUt1UFcXYEXE2aC5mFGqSHc4kQ4HxHnwAzkIYjIbsyG4jmKFHPfkuWh+sB9wIuR8YBa9t5gSmY1FnGPjPWCZ44QXi7cDB1vzt+IelztwAZsLtkxgDMEFgvcY57E+kGMklxmso+s2YDLzPOGMY9MlSIZJNAPDBIsMPX3XU1ImjRNTtngKztZFfVDcdh8ckiL9sCFFLWrmmPCDYDvNGvahV1xSFkXuYdUt7CHGjFUWsaLirSVOkWmOkDJxTKQpMabEcYpM80zOkRBqw0KKZMl477k2CZGMFO3KNn2giCed9jjnmZO2I3Xe0znH3d0943FmnhMhWHI54L1n6AObTVDB01k66xiCwVeXpYpDtUgkTZzR+VETW5w1dfwL3rs3fzfPbXk9/j/0cfXT7/4F0wL9FvGoNgzKqpnQ2CX7rTn9TKUklFILwHWRaJaFpX3YfSsLHnJxx51zyPXll4KAtdhKGlGxyhHjrCJeW1a1juScyLlm9i1FTF3PaHGtYI0lp1Sxo9p0llJaFrOlFGyxyiUxnBs50WYHU9dKTcRsKM7WDauCJwvK0xhDTioELgJbRZdiattodQoZU5YuYT2kUrGeOq/XgkU5Hyflji0o1pbn3s4QU13aS0F3kedqk+WS5XHGuC5iZcqrubFUQswq+Ldd/1tuorWklBeTozrD9dh3fXfze2X8f1Ifv/pHv/kXQjB2GnM10lvNe0uCybG6vlLt7hCkaIOyWHCbQOc8U84cn91z+MEtxx/8NilsKP0bzFtPsTueXjxh4y+YbWI6/YB4KCQ82V/iSaTph9zFmVwsnRw5djvKsMVsL2Dr2U93bMWy6d7ke50wTSdO4w/p0gX0l3Rzxs0/wphA8Fts17HtLrBhRxw3zPke1/Vst29hbeR03FNMx9OLK1xO7I8jcZoxvcM+ueJyu0NiIe4PnMbCfRrwztU868KmE3yl8jqvGUMyF0zOWh8KStjJgBRPKoaCxTjPgF6vps7gxGFjwriCcYbpGDmenkPMjPcn0nHi5TTy/P7A/eGeedqz2WxJJXI43TPnQN93fM4dAIsRy3bYEgdPtheYueC95ZQFMwlX2y3ODfzg+7/N8e7EeIrsLjqS/JAQBp5c9Fw/uWC37dgOPRehcLUxbDun9KoVYlhPFRUADXmJ8LA1isSQePN695nXI+zj/fjqV7/6lwDb0JXe++rMS4sYqM02Wow+nU7q/sk6j275cOM4cjqdmPKMKQaxFsTiNuDEKnGqCmOHw8ipRG6ePEFSwQkMfa9riJQ5nia6oJnTwfdEMqd5xudMJ4I4S44Zl3R7UrG0U5zpfeBiu6HrB4a+J86JueI3n15fkSnc3b/EusCLl3d0C9YSppjoOrPkH57GETHUsa8CnLGG7WarOcm5qOswJcZxopRMl/MigM3TjA+BXO/Ffd/rtiuJI+fMPM3sdjtijHz/e9/jhz/8IWNSxP9gHc4H7uWIMUJwnsvLS5x3dEdPMQVnBz7jOn54f0+cI5/9wue4vrpknmaePTvQ9T2Hw4Gu6zDWEZzj/sVLXrx4wdX1dUUaVsdkTjhnOR6PPH/xghcv7zSb7EEDkVXMadTCRQjqDmzfrwWIruteNwB8zB+//Mu//JdyzrYJ/k1wWotqjzGvIqI15boOaOJWQ2iuv16Lau+HmHyV4Pf4Zx8k8q2f+1j0e7zdZa6/mvc3IbNd79Y5es45hmHg8vJS6yV9z5e+9CX+8T/+x3zhC1/g+9//Pk+ePOHi4mIRPe/v7zkej/zDf/gP+bmf+zmGYaDve3a7ncZ0bDZcXV0t37cxtM7YNAv+vzxw2PZ9vwh7DeW7/rzWgmH7/v1wno/Rnq8SANd41yYmNiFzfT6sG0ja9q6urj5V498vXZzLYqedWDW6vuY3SF16WK2U1ixAq0UaiSCVpU+u6BmrohvaWm/FLFkZYlYnuXEYXMXTVJRNdUkh6o4yNe+miVAL2h2pXazKlVY0qC4eVSi0WNPUfI+p3bHGqZvLAs6tTySPSFYhC3i5P/GjF/eQhL4L+IpYTNS8DmdI00yp3Tveu6X7lJhJaGHPGRWfMjq5xKoIKilBzMR8qi4x7VgtOSNLUaBg63bbccmr18NqALcp+jqbLnCaRkwZ2PSOly/veXp9yW6j+3BKiT55hnHmRz98hveBq8uOkDJzHEkEgrc4CXQXW/IYiTETehXUppIoKRNTImU4nma8d6QJ4jSz3Q4c50iKAnHmfo668JfM3YsRv9uy2zkO+xNzKnTecjiORNTFZ7zjIgzkOJOSvnfJhYwlzbOKdaaBaEGC5jcYiTivHVb748zJCIN3mDlxLOpQtday8YHLqwGxsO0cwYEkYRLN9sPqfuAMUupnILJgIluXYC65YmNruGxFTdla8DC57qeDnM/OgmYtkCJMKTI4CMGRrFBEMUTWaA6dKe25SijBQm4VCVpyVU2eXGyBsuT9tdGyIJsq5qSY1Zh/jAh8LAI+UtduHgkTt4wrN98j/OfNo+2+QlSsQFB1fPGRKYoPnnfz6H288dbl+RvXRL/0cAMrYbCQsA5wXgvRcWKaE9Odoikz4ALkQKNtEoBjQPP4RlU5729UzNGn3cCoPsh3gHe4qQKPHtB36j5vR/jpEeIDAen27IjkLPYN3GqW4APtdWCz1Y3F8RbCO+ADOanz0O0UCZqA4BWFNU+F4GaOJ08IFiQwHfcU5/DW4ULQjmnv9fuup98MzNPENE7MOauwF1Ukkwz3+726o3PBYCkU5jQTcybFDDEz5cREWjnoaMGJ6suMN4QBQhiAG47jbRU23wEixxjV9ThCuHyHxEiqAmJ7pDppb4/9eOTle/r1ZgNDv+X6auBi43A4as2TXDIKrdaQd4NifFdSuWaCEHBq7axe0vHBSf47OYfHW0XIhooBfSz63dTx9UFD6CfU8Y+CBf0UFft/4tGFz/dX219uqDfbsHhV3FUEqH3gNpGWjWq1WJ5iYp4z0/0RmWeyKThnEKeNUn1xeGuZTSaVTJcCMifiIHRehbWcDDHNZIGdcQzGM2dhLiPBWAZv8QJ9zAxZmCSRrUeMkEtirHMmV4RoElYyQQy+BJyzjFmbtbQDt6NkoeSZ7DQXsMSMiKGr94IC4C1ZhDjPzN5wOo344IDAeNxTvMcZi/OKuM0ua2ZHNzBseqZpZjqNxJyYpsgc1bVTsrDfHxjnojg/o6JBzEmzAHPGpKSo8KIEBRFw3uOCR6zRJiejXdXOOyQHxvFEyRMxOoxE5jmSjiO+E9ywweXMVArOBRquPSYlURgjGGfY72dePE84Yxg6xxAGLq97LjYB7yzOqiBUakOZtVZxgkWWZhuR8/j3wV//6z6//3WICJ+a8d8Pn724efOX2qLTNQJJFZ+KnK/oRQRbxT9nG+6zTuXq594aCAtKfFgW/mc6J7JCbzaz8RJjIOdmmFKqEGXPuZQ++LpQ1uYvlsWnft2KUEhb0NaCNJAl1YJFeVAsUPFSF/opq5BlndImFE/sKXU9YWFx8LVrIZVoIVLntUVWImabU2runlQ0aq5OPD1u54x4EUirRXQT7kpui/jyYHGekmYnIWvX37lxw9QCxxkFWgXV2gC3NK7aJThwdYzM4k7AmEX8K0VWRQad07PqIBY554L6Llx9Gsf/p+Xx9Gr3+T/09S/9UsnN2abiX8xFaxtFtOZgan2j6P0pZiX8RIHjGHn+/MTdP/8x8f4lk8naVNI5CokL4+l9xx2RUzyxGy+wx5G7a9htMp0LzOOGTGTO8NQ+5U07sI+Fw/0ztibwdOjpiuHJYeRyLOxLZPYXiBWmeOR5F/Cpp4+Rk5nxdmYjhgsTkKHn5eGeIB1D37MZrim5EKc9qTfkzpFPE1Y8W2vxog3LxnvmFDHzkc5l7vqOrvdse0sp2iBR8BgUZ2iC145V7yoBQylGkjMpKX0DZ0nJcNqfmKcCYum852QNU8lMOTOmiBlHjnPkLifGoq5n3w9c9j3ZGcZpouDY9IHQdeR5x/HwksxInLfk/ZFkHeZ0wvUWd3mD5JHDeEfoBEkG2wWmMSISEZ8pFH784zu+99s/pHeeN642XG6f8IV3rnj7jQ257xiCxVkoJVEKdNYhRu//uvZujeP6uL7YXL8usX98H9vN5nNvv/32HwYWcUfFqrzcm9bYu5QS4zQSZ73P7vd7daqdVDCaU6oCuMUbg6tNPJjMNJ3A9GBgHDPdxhGPE8FZpunE4bAn5sTd4Z44zeC3XPSe6KKSewajZK3pSAgeMswk+jbpNGDFMUZ18hkMc4xa5BcVMJNkdrsd0zST5sTucosxcDwctDGGwmB7Npstm81GhQyvxfn9fr+IeNaok6/Uwrx1rs4P1FHUhY6WpxbjOQvMe0dKmbu7O46HA9M8M8eZFy9e8Pz5c6Y5Ms0JKYWLXvO8L3Y7bW6qhgdf52i5bBZqXMqZvop71hrmOPPy7iXvPbvl6uKa3cUFySYo0Pcdfd+Tp6LzuyL0XUe/6Tkdj7y8e8Hd/h4pQpwyb1zXaBaEGOe6zlenU3NIrbPAZJlDCF3XvR7/H+PHkydPvvDuu+/+4bXr7LEAuHb3NbGn5dW1dcNaAGwiWPv3g1yAj4W8VwmAj0XAV4l6j8W/B5Fsr3je0mxXnavr97Y+l9fHYBiG5W+/9KUv8fTp02W9EWPkeDzinOP58+e899579H3Pu+++y3a75cmTJwvq8+LigqurKzabzQMRtW27fQbrLMa1qNeEuJYluP5de69tG68SS191PD7omC+58CtXZHNOhhAWAfLxPmoN8dN1//eySrA3AmJrDkJZw1ZYOmALBWuk5iWAlaw5ETV7xlQnIKu8DKPKlnbbC0DEFFHYmrU1bD2dBUJR5IKp+WbOWmXpY5A6qFvnlkG0YETNnqjdrsvFG2W5B6euv2IU9elxS3EQKRWa6DlGLVwdpsztsz3BCaHTDvwpZeY5kQ24IuQY8VaxVcYYeu/BWZwTJiDFjPOWkoQUS51QFoZtTzzN2plqtYvXd4HgHLHEivgxFbGjiqU1KgR5rzdLipBE8FJISbtnRSKldOyGjikLIWW2m46XLw/YXLh+6wpvDGMStgJlP+G7hAvC0AXEeDCKGStVEMUXSqqM1JSwtbM3p8wUtQvp7v4AKZOmSLfpcA5GsRXtM0ExPHu5pxiLzzOn/YlUCl2oyM85YoeO0AVcikiOzLkO9jmRimCd5iIK2qmLy8wl4caoBbw545IwBC3OFuMU65gz96cEptA7y2gSkcJcCux6rjYBZ6x+X4RMVjSo1fKAGHUGlBoGltqFFuqislRtzRE8iNFCT0oZY11tMlbMoDeKWVB0raWkQghCMOqMlTomnDk7/JooXep4cLUQkuvoetAtUsekWVqXZemEllIw1pIFXRAukN9XiAi8v9qgT2mS1HgWJl6R/fdYrXugS9xWkauKgDc3vC8+8ZwXeH7SDbxKleRSL9KUnLBrsW8pQLXOB1+Fp7SIu4nEnCHOieN0ZI6jgiG374CHfAIfR/x4q4JaVW0ub29wNzdcXqpDMEX4J3Hkhhu+CuzqLqS6sx7ouGG+1Z8N9efpBk71gA0PBEE9ymOThsaHYlE66lehvkZHQxWCrRjT6Gf6IRDrNThnSLNmIYaghQ9fMZgxZbx32H7A1LykeY7krNevPMe6AIjEXEhz5nQ8UrC4vkOcJ48nppQZp5k8j/VYe8UapsRiE4x6vGJowp/mKMbmhBw0gzF+d5WZ+M6NPgcYA1weWTE0dXs+gH7EgcPxnuN4S4iwCTeM+ZLCJbte3YLOLipxM8QjRceupEwzBpYCvvNQQ8AS4/I2GGAYbxgr0vajCtjvnP/8FSIgy9nxoZu84RWD7MOFwX+VxcDfjWww/9mnf8UHdyXlnNskpSwZUC2by1WcXanXb3XrFKZUSKlwOk3McdbOsM2AMYZpSpiY6GIkSSRR6JNwEQN+40nbnuwNcym8zBkI3FjHBSospJQQA8EYOjxzVJy5MbCjI1lHlEiykWQNU80ly1iy1+t5JmunfkWX5jRjJOGNkEx1C4mpzkNt0orTzNwFuqFTpJg4chLSrMckdUISCMo+JSXB+YKrnXm25pLler/LMZGiLuxTysSYGQ9HirHYoQfbk8aJ8TAyThN5jmAgiqLDlxyx2kiVxkLxBtcPuLr4SHNG3BaD4XRKMI+1kSbDpsMk4UTi1MPlXOd+XrGNUgs/zjjECodx5jhOdINl5yOnEinmgl3n6b1ZXFUi6lJyCo6vOWKlWu/Vzem9232aiv6ftvG/+9mv/VXnw3WpbreCLPj0x4vo1hjlnDYrNvcZjzpwzwWChpFtTVn2wQLUWp0HtnNbm7kq/NNUMQLRwteSRQopF7yzq0VvqQQDq3PHVd5G2+cmlEmueFqqw7Bya1uR01mrBJVaCBARimniX8vPa/nTcnY51t81oW4RwarQtmT6rRbJOa+dfbIqYFCxpOXB59au0euOXXVSlprP1ppQZRE9zRJYYUiluQzB0j6LUhv2zIPXloVYwyIGt+zEJhRrI18leNCQpopabXvufLh4Lfp9fB+//sf/0F9+erm9TvOk5wCFVB3oxig+m5rvaY1ismOMxDgzpcL9lHl5mHjvx895tn9O121xb7xBwPL85RF/PBFOR075yJHI9SnzmeOO4c0Nn3t6SRwc9ynxz1LC2it+vwl8zgRSgWkaEePZGcuWDftjZjKJnRXeNhdMvmOUE5M/MFK4s46wCUTTMQePkUT2iW1RJ77JiRL3JEY2DqwfMEVwNpCM3qO9BKbjkcOhp3+zQ1zATh1xNuRTIVkom6BIDAFMQHCajx76ZdyryJ6BqCJAzpxiIY1CHCP3L16QXU944wnSbUinkcPLe+4Pe+LhBAaOuTawJsGI4odTysyHQgyBcPWU3hiOxz3TKVHcDSVlXv7/DvQ8J5uM+4yFp2/ji+GHeeL/23+Xbz//GpIyw4XDeqUB9bZj6LZgZp6992P+2cuXXFwH3tq+zfPpmq99+bN8/vpSI2FCQ5VBdpZiKs2qNgaZxQENu6Hfvi6zf3wf3/z5n/+rfd8/WTvxNbuu4V7LkoE1TROn02lxAKaYOJ6OvHj5knmamVPWXGwjOBzWWKIIxSSO94kOq/UgYDvYpZnkMB5wzvEyRXCH/z97/9YkS5aeZ2LPOrp7RGbuU1ZVd6MA4kiiQRCEwDHJhiBI2dgMAHJmqDHdyHQhG8kojcxkuhPHRjLTz5JkMv0LmulGFyI5FA6N7uzae2dmhB/WWt/SxbfcwzMrqxsNUUR1oaIte2dlRoZ7hPtyX+t7v/d5ifGAt55xPPPoYCjXjKaANURrQApjKkQbSBnGMuIrBGPb2rQiTkhLBm+JwencwlbGeSYtiWVRx9s0T3ivIvZ6f50fJ8bzyLt37zZawCrgrQX/w+GgyD3TGqNQB+M69ynSnP9Vm32mceJ0Pm1rrNP5RFq0dumdVwHhNJKTGgBiCFwdD9zcXOOcZzyP1FpZ0sKUC6HviEGdeSlnTK18dnPNYRiY55m7L36sjszHM9F3VGM5cmiipWCcJfiA5MKSFnV8Vr22z/Osx0kgRs0Yy7mwzDPD0LfoqPolPOxzlxhA1307/r/Ojz/6oz/6P3Rd93pz9T7L/tujPleR7CWX2Cr2ra6/58Lfc7TmVzkAn+eNfpVL8KWvl37/XMh6yQm3d//txcH9PHuP5EwpbehLEeFw0FNcx4k2Gb5584au67i6uuJ4PHJ9fc2bN28YhoG+7zfkZ21Ni+u21m2sX3tRbS8Krvu/fsbPPwu7Nf59WTh9SRh8/jntXbzP8aD782KPHRWRL7kNu667+gYKgOuaVy/8dcsZ251cbRFR6h5vmFtXjUUAR8HUSjW+YZRUjdB7TjvwkjVfz2gemmudsXqwGnJGijozLATf4YNDUmkCjW0IQ+3it6blbzRsZGv01IUvBYvFmXUBXhsKymn2j2m72NxAqWSkKLbxNCaG6DjEDpzj4Txzfxox1mlKoNfMN0fFOEfseoZOO2juH0dyqopTrQbjK8cuYg3M08x0/4hxHuOD2nNdW+hrsp7uv1HRSzLkJWGsUfFV9L2JIulb4cFAdeAMc8lItXSmkiY2ofMhZcKc6a3yxk9z4tgFhkNHrYZxHJF+oO86FUZrRXLSbn4Lp/OMN0YXU9bSHzvO7xec1wErVqg+YHwgi3p8ZimkedHshAyv3vTMp4mUE8ZqPthUKrGPFBHKMpFTYSlyyV6hXQxEcEYLm7RwcsSSzgXrdODa4JhSITidHM3iwRS8FRapJPR8+Xh/Ji1ClkKpB24OAe/gvKy4WS3661lmKVlz+NYCUJa1INHOW2sxIuosxWknuWk25tos2g2Z5tfuciuYaihZtGDpDL6J5dWoO1VrvEXF17V51axRKOaSiVIvKTCwOj4akrRlaW6dH6v01zBMXxmwd/uTxYtN+Lt7Lhg+CQJ8wuy82/3f7RNh7/ICt7dP9+mW2y0bbfppisotvHv75YgWIbHa+C4kaRW/9DPRY53Leg1Qc2AMPfiA6wKcEjw8EO8g3t7y2ExnwwTuFnh7TewDA1DSmV9p+XzopYWbJtAV0Dw77pBbSHfbG0WAwh3LHdzfom4/Np2s6UJ30N+q9DrdwXRH6D8nBCDcQoLiFQO6bRxY5oXp7Oj7g+aD5YIrAkXIIuRUdIFtNC+r1oprN0ypQimVZZxVhN51PxUqBSG3jEwbPLNAxrKkwrxMLOemyKGBfWVMTE3AA8WXBm5JzWH5MDUR7fYW/qQd3Ntb6O/0v6enJ+7D9CcqlU2XzyukJokm7bYM/S0EPep/+sW/Ycmf8wvv3kIHPuoJ8IQKJpfYyErDgVkdiqsjtBkBN/E19cD0s3gA9RCGz1cB8aVz/N8DAvSv6Ar8uhf7X3r0r6/+szUYdW3ukSIvTtLX/CrTEHW56JcUTQIO3mFCxMWAjAucE2EW+i5yCsKM0APGG+rrK0Lf0UumP0/aIJMz3iRChaEavFdEunEVawpCoUwGcQE6vb/XUpgLnIyjaxf1tXlAqoE8IaFHbA/zCDnj3IAPHudLW8hmqoViqjahYFimmck7un5omWAVJwVEEe05F7Ip2GCRKtjqGh2hTYSLME8LphEVbBMdCoIYITd3kHVOXw9LysIyL6RxoTqnN7RSKeOi2SimdQimBVs6nPcsUrQg0zDarlqQBCFQjwk+gikFSYniKw7DNJ8pUogEwFNF8cb4DkmJCsShw3aBWSoPP/6CVDLfffsKuqrd1xV1L1qhrA7F1lQjVQUDawzW2cPPS5bXNw0X+pfZxs33vvOHSvZs2X72q7E81pqni3qrwpZ7svBmyw1dcwJVaFPRqFK3LL8tH7Bqg4G1KsivgpkKzabdW81Gg3BVHWrSMu908V0wFtxuxrIuyhUhKuzlNO9tQ4fWllvVMqgRnL1QKLzTrD/Xcod8ywjMpajLwKggLq0AJlW2NHjbHJK1NZ7Vln2oH6fZYTjrs8JFQ4Bm2Yl07Ioul7w98tqhvbr2VIRjpVbU0pD8DS3aDs1a8LyItev82GzIVZCGJ1VxVmMhFFdactma5mjZj3XNDTVGhVY95t+O/6/x43/8D37jj0211KxslJoLsiyK+3am1R1aXILZYaVq5bxkzrOQ50JH5mroqccbXN9RfvyAuXvkcF+4vr7ih0PGiuVNtdjOkH/xMw6vXxHzzM2P35PPift5JHIiFsNnxtJ3BjER2xmiSRQzsXxwlHiEG6uFiGXhcYE/tx2vnKKHczWcTUVqpM5fkI+3pPgJy/u/oJ5Hws07hkPH0GeoQk4zBEO24GLEGcN8OvEYA8NwJPqe7DSuIziHYClit6ZSq7bozXFbpTaEr45U74UoniUkZhLJqhPJeUfoek7AbDypVMbTyPThRI2BaiGkwnw6MT5+ZDZZ0XvjGddfY2LHOU98vH9PyhbwuNnSf7dgunfkmxH+wuFzxpwX5iBw/oT5/EHxrSVwKpEyLwwhQ/8Gmqvn6vU17vrIQy38+b/+fzHLTPiNX8caw7UZoNoWK1OozjdctDrGVgEQYxh6P3xbZv/6Pj7//PM/XF0vpUXnlFJYlqUJWbL99774nEthGkdOpxNzmsklKw7Ta3yEBgwpASTXSukr1nmSEWwWQojklEinE2HwpPqBknvgwOgE0kLvIxjLOM3QCwMRiijGEoOkgneNYmYduWSQgsEy50zKWTNuQ093iDj03t11PTFGpnki54TGFCnGMwRPTpk//+GfE2Lg7du3zHPciu2rGJpL4fWrV8QYqaFlEjfc+SoWrMg+zCUaJ2dF+Pddh2vO6sq4Yf2mJbe6pqdWeDydSbMKBKZd38Z5ogJdP7AsC+N4RnLGBc9IZZzOWOvwzmsjRV5Ij7omDzGyzEtzK0HfH8CowJHywjTOnE9nQt/RHTrm08g0zuTli0Y4QN9zVSfkvMxbjuFe/NP1vyHG+K0A+DV+fP/73/9P1/P1JXFvFf/WOf9eUNoLaC997cW/50LgSzmALwmBLyFDnwtiz79/eU79smvwJfFsL2Lts1BTSoo4nmfFDj/DbK7fr5mBq8NvdUuu27PbmiVvQuJeZFt/vh6T/X49oWzAlz67pw2W9kVh9Ce5KJ+v+14SDvf3gfW9XZpGnoqsIYRv1P3fX96bCgam8gS7si5SpWFdNDejVUurlkbNmrNXAOep1W5/alrxtFaokimSscbgvQWjwoi0rtYuOrwxlKzFMNPg7HlR7GQp0hxxZsu+s6xuxVWfuSi9tolfUAlOJRzvLb4tOZ3TybEJhVoD1AUcfPiYcMYQvDoCyYbHcSGnQhcUF+SdpRqHRbM4ur7HdQYeR0LwxOjxVTP+FqkcugP9YHExUqrw+OGB8zmxzDMisBSY5oXgnRbRmpXdGoMLmlVg28mriDottnmv7zU4vbAtSSBYpBaG6BBTGI6RguF8mrFDJHoVXafiCUV41XmWUoii3fMTE8F4nLOICZojNi9kp25H74OiXmvFek/sIudSOMRKXWbuz4nxnHBZw74/nhesD5q9IUKpjmlOeAPDELX4uKS17q6Lctu6hnPGeq/ORwRfhCyVsiTNTnG14QYVu+mNsAhE5zGhdRy23D1MZc7aCSRzIn/UfJ8QDJ11GFPJ1eJab7RrEx2qRUxVQdqqoK2UIEORdkxaAdRbWIzDmHZxKwZrK87RiiluV2iAnIWUhNh5xBlwhpS069JZLfqmusE8t7FkaAIz+7qFoZqqLlfd3QvO6kulAfNloe+5U+glR6CG2MHddPnxGvfXRJu7ZxjRW/buvh0vdP3Jqhne3rJpKDsRZUNnfilnsG2i/UcP3N7efNn91+atdhMEweKx7uIEhPwkM7AjMOekuMo54dIDrr2Jwi0u9FwnyPwJH/pbrnu1nMXTPTH9Ce/uYLm9ZeghHnoCgb4PdIPHxg4pnyLjSPn0Aca7bb9ygvFzLT6PQJ6ga7s1rUJg04RWR2BgItDj0Sw9MniS9uv6QBdb1J0U5mmmWBDr8ENHFzVvsqSZ2aiIpy6coq7uZo8qpYARioBzHm8UJWZECH3HwSpedE7CaZx4fNDcP7uo4McAdIojPaVJHXn9LeHQQ/iclCZ4eJaj1z7v/vPbixZ2+5QruxfNpi1DsX1OQZXjgOqPuTkMQ7rlR/d/wlV3wNqeg92HROoJsCO8NYRkO4Ha+VKeaXSpnYA9PxvKdhNA+9tN59tnAf5Mr3X3swn5X+ei4l9lO+b11f+kvxp+a3V4wG5isFEJVgxoK+Q7uzmkS5UtJ6tzjpqFJAbmjJtG/DQBnmIMzkeuqiWXE/cBrjpFSnbzTBhPvJ0hBU8/eGLX423gEB1dHzHRIyVR5zN5fKDOY+u4cqRsCEUFhrkVr73RIuBiDbkaTKkkB0sIbYK9YHynC+RqoQgK19EcYhuauFFUkBMDNRt8H+hDEwDSwrKNf0NOhVrsJpDmUsDU5hbyOFvw1rEYIXSeAW2+mkvh8TxzejhRlgWTNHeQXjttxcA5z8zpjIsD3eFASh1pHlmmRQtwWKosSDqDHwjHK5wzuFng6hpTLXiLk4RJze2IJ4tQcsLkTHEWMwfFyltLFy14LUK4XPjiwz2H2OFtj7VuO+M2mcdczhPbcqwVd2i7r+tYql/Tcfkfajvue9/7r/qbm99aj1mb+jfk41PRX39/yfOQWgnNmVdF9FwBdQyZlsXcssK1B63Nw9eMKLkgJp21KvitghitIfFZXuB+iVWrOhFT1uxJ7xsKxxqMKZvo55zdxCldDzUsZ66XHEPjLrnVok06a95VEWl5p7Xt0/4Tr5tgZmxDX7WuXufc5uDTdZnRNcBuIb02Yq45H1J3TsvKLptk15m8fXZrkUSFybLLFQSh1RW217bWIm0yLHWX5SUVoWBD0O93bsJm/3uyvM0NY7zqj5rxWLWxdJdBuP2/0dTov6nj/+v8+P3f+bX/6m//0qffz0kb1iwFSZlaCsZ6jSKx++OpcwITHGTHUhKlZJyB69iTTonHbOFxxr7/Mf3H95QykMxA6Ae+WyxT+hF/Olg+vT6C9xw//gXxix/wq4+Wx77n5k3H1fVbou14e3Pg+tWAHTokj6T7H5M//Dn18Uf46qmmZ1os/aJz8nujY3Ggkgg8Ostcj5ilMHaWh5tXyLIwpzPx6jXRdSziMXMimkqpwmlZ8ENQok1KnMuZakG8Ib46cIzqGi55IXvFBBspYDzI6oiuDZFfFQloI50rJBGSB3fTafxGMcxp4Yv7kY9ffKA8jsQ58fDxHrl5hT0GsoMP6Z6H+Y54fMP1m8+Yp4XT/RdMjw+knFR8rBPM/xYT3tF/dkuVQnfK2HevMDVgD4FPkvAmHcl+wZlINpXHZcZMJ2otuPMDRhbEGq4PB2QYoBq66RX/7//+3/HZq1uGYAm+Izi9Jhep6v6v+t9mbSQQXbsH73q+fXw9xb9f/Pyf3dzcfH/Fe65F7ZTSVgRfsZ/rvSiEoMXeooXqtCx6zRAhbpFDliwabeS9JRLIwWCC4SFnemMhK/5+HAI3wUO64tVV4GFKiJzpr44EFCv4+k0EU1nmmdzyaUvRhvkiArJQbCBay1IrvloSWZuKTGAelxYDZPF9oNaRrosEf8nmW5YFZ12jn0V88Jp9ZwzzPHMez9y+u+XNmzeIVD5++IgB3r59i7GGZZ53IoXZivfee7zT1xIRzucTznlWZlWaEw8P97z/8J5xGjXCqFEGlKQWOJ8mimT6rufqeCCGwDiOPD486hrMWdKS+OGf/5D+Bj5798vcXF3x+Hji088+0TGaC6fHMzYunB8nUp6x1ZCKUtfOpwljLcfDQD8ctCE+a6TBkhYex5HhMHA+n5sLsuJ94OH+AWssV1dXT6gLLoRVhOi+HWlfz8fv/u7v/pefffbZ96dp+pJb7KXcvpeEub078LlYuP96/np74eqrBLrnjsHngtf6+31m3x5f+hyN+ZIT8Hl23nqdW8UzRfimzR25FwOXRYV0Y4xigXfC3tpUoXmqeXNQr9mg6xrhpQy+dRt7jOdLTscv1XOeOSd/0uf6XCD9qtd7Lgju92+9Rzx3UD4RzLz/Ro1/v88lM7AtqrY189Ylb1smRnMYrbkTQgtvF6opGAmav2J3mWTSciFMwRrNeFkX1VTBUOiCwbUsiVxy68y85F3AhcxTNNwHtyK9akPOsDoO1ZEYrWmB9wZXNa9Cu1Tshq9xxiM4cl5IpfLDj2fmJXEMjoe5tA4WfY1XVwOuZdQk0UyBQ9czHANd7FiWhBkGPo2OYx9xx6NOGGLE1EqaZ4bDkcNVpJTM/RcnHh7PnMaR8XHinDLn08SyZEJ1pLR21kXtRKfijW3IyTXbSLvdSxKMd8ToGrLTknImPWSC97y6OSBJwBvGKYG3hKhI1CKJEDqmRehjbbiu2kJ/J3y04Ay2FvwQyaNmAJUkwIRY2wLCF07niY8Pj8zTjKtF2erOEh3aoSSVeUmaf9JHjIVcBbGqqnmnDrpSinZSe4t1ZpuA6fE2iBFqzVhjN5fnnBMYRb4uJRODZppl50hF6I0lOM8sC7Zmxrny/oO6DF7d9HgPIVd1M60Ff6N42jVzEmNw1WApOG+wxbBkuSBZncFbQzKWSm4CXbvB5IpUo7lDrXAjKE4liGJBdROudXKDtyt+xWyLVtXga+vEbvgnw9a1aKlIw5SqU5ats7k+t6DffYUI+Pz3u59/SZS4W/+54/bu9rm+98wdqELf9l93cNs2smEQ9yzQ27sXdY6XtI2b/laz/jb35iYFIV9xAVyfJ+xyAkvCZXDnifM00fUQuVOnH7csPZQ0MU1wc33L9fU1cfDq2pyBw+dc/w8ODJ/c0B0HhugVr2lUPLPN3lzmifTwQH5QMVCWpGJVVr3skCfyAUqCkm6J3LFMkFsWYOj1E1DfS/sGICVyc6iNPhHwYB3Ox/WNknNhnjuGg4AJGHRi42LcOZEbdlC0KGmchsbW1TGUFkzVwmOIgXmcGe8/8vHjieW8IEWvnaXhOB0wNrEs9Ldc31zrTqdzQ35q8l3oId1eTr6wnhnt/aaJF2Sxp0p16G85p2nLaxwTpCaUvg49Jd0yzmeuk6dYRR7tBQDNsnVfOlmC6sPaTKIGw80FOE2NQvozqHbr8Ao7MfGv/PgbJPa99IifvP6vaxXH1rnV5hct39U2F8i6qF0ReFSQ1cFSVTS0UrHjwlgK0SdCzZjBYKojmUwqlSkXXg+Rq6uDFtmqZm9xNRC/c03/9pr+aqALnrAuGJzDriLyNLM8PJAfH5BxouaCL4KXSk9l2RyJhSKFVPRnpQoeT3AeE/Q6HyzgLbVUJOdNwJpsJg4R4xzOOyU01EoqwrTklh+qTntrDD4GGuAd17pHtvFvK76JJDlncspt/BtiF5nOM+PHR+4/6P1fiuYalxawbbGkNLOkhA8Dh+NVQ6DP1KqOjeg6nI+UEiluxtqoGCQRfOygQsqFmmawFVODNq15p87KkrFGC57TMivKGEOaKykveOe58T1inboTU0f05UlmW23zVt2nejk/a8UZeqy9QuTx6zCeft4Rnv8+t3Pzq7/8vzDgVkGnNiFw3cgF+dKC/pq7y1inbrKWJadrnVb8rZc5U5VKtWa3yDYXZdGwZeDtCwsrTopdVp9RC9KTjlTnFE3l7NOCmzGXHMJSakOMlnZvvqA0q2hun17DWuafqoo4U5G6kkLqRYCrtZEr1CVcpWKc3RomTFtjrMJh2+Qmdr7UmQxNVGOPH2pFD2t2mSC1OQ3lkj1vKrWhxuqWu9XQpsaQSyb40F43b1Qa15ybK0J0ExXNJa8QYzc3Zq3q+KqgzZYNBbplN7bMR54UkHS96oMbCP4NKb//po//n7fHf/mPf+e/dqa6cVmoOSNVneJVhGo0M55aNiQv1W7RIXNRHJ3kjKuVmIXw/sTdaaLvHznWGffWY3PgZE+Mc+LDlPjF1wc++c6ndK8HoiRiFOp33nH129/lV//Wd3n7nTccYiCiqHnrPb6L1ILm2n3xI+Yf/Tnlw3tYhJgSfam8ojIWGFNFFnX2XKeiESUCx3rgqjtiD9d0zjB0ntpH6lwgZwRt1jnNM6/cDXEYOBx6ypIpuTCmynlMvHmltQ1LK9559BqHxbR7vVAoptV3jKNWRXeWVLAUuiEQ7BXj48jdD+/48Q/fM96fkFxIQD70uN7jXOQ0nTlPE33/jk8++S7GB97PH1vWhuHKvyJcX5GWM3k64+0V1nVgE/7Np8iSGKcFW85UX/BGZ861ixhXCPMJ764xpvJwvtcMJyzjY+WUHul9zy/2b5E4cP/xI+e319z0C0TbqFFWM8GaGGhWCpFRN3If/BC9Oy65nL4dcV+vx2/+nd/83wJORDZXy+pACSFsqLvVpbIWffW56vxKOSl5wmiO/WZ2yZUyL3Q3B4yzeDGkIrxxmgFoMfQxcDpPSC0cjgeur675tZtXdF23ZYrF2GleXS7c33/ki/dfcP/xXgU7r41miDbFGwPBQ0qZzgaoBVkyNiphzQRdqc7zRMoLMUbSkhuxp7S6a+X1qwNv3r7h+uoa7z2n84mH+3u6ruP169eE4Km129w90ghc3uu8e71XW2vpGhb0fD7z+PiIMYYQgm47Jf7sz/+Mf/tv/w3vv3gPqFEi50IMASqM08icZq6PV1xfX+G94/HxkVQKMQaCCXQxMgWPNxZsJfrI+fGMMwYXO3IRPp7vqVkIBQxKZbFWr2EpZfrjgdPjiZwLXQycR3V1gmZC1obYyiWzLPrZFRHO5zND31OGYct9WzGIbb7WhxBep5Q+fDvivl6Pf/SP/tG/KKW4VeD/SaLbS8LQ3tm3F//27sH9vH7/u/1896Wsu/3f70XGl0TD/bx6LwruRbCvwoVu89e1Sa7Nt/du1pdEL+8V2/vw8LCJ33tB7PHx8ck+r6+RUtrqASs29bl4ud/WT8J2Pic0PXdV/qRj+FzY+ypH5vPjtUeUrg7n58Lu/viEEIbD4fDqfD5//EYIgNWAaaut1ep8kf/qbsHMriisYoysgckNmWIQpJaGVmnKbMMkVilaQV6FxGqwVm8uwam7a1qyop/QTDTvHbELmjVTpHWd6kLWmla4N1q8c7vFImvxv1a8swS3sl2NdqVKwrqA+vc080cwnJeZXAo3XWBKhTElahZi5+gPPV3f0YVALdpRW52lDx1dMPiux3rDdefAB0qGqzdHhr7DOE8XHJIWlnkiJ6HaSH8bePvumnGcSdPCmAvn08TDwyOShPOcuH88UxZBjLrLotNFbS7qKvNACB3GCpKzdu6ZgrUOa2HoAkvKmvEVHNEYJlQITCnhS6BKwLnI0Kk7wbaOYlsNsdM8kdhFJCdK0X0ppuCCOvBq1ZDkORfG84IsM94Vzid1N14fI957ptPMkrSLauiCos1SIS0aLq6+G9PcGLQubQNFu3Er7WJYMlJ0IVcaODF4t3VWi2ge0LIkFjJW7Xc8nhLWQtd5fV5eeP8xM6bKXODtTcQ7g62WJEvDrToEg0U0P9E6nMuYbKm5YI26TZzT0Ol5kcaFbzkwRjBiWqZiwxYJVGsxLfeliBZ6Y6hNFNcCz3rhDrYwi9vcLMZZXFUT7ppxU9fxZswm4Mg6hGvd8mcaf/QytPeuv58mWtzuVYrnyuHdE3Hu6UvePXmRu0Z0vAXubi8vPHGnv2vP7G9VyHmYnr7+l/L/2su/e3uNRXF5Kuqlp1at5u5bHxa/uQLzosKfFJAMJSeYwN/dwee3cPic+J0DXewpJZOXTDydOd7cEI4HfNA8ueF774jDgO8isevoQyB6hxHtpMG0HIJcKDaS/SvyzbXiQ+ZEzYWOQsoLQ4KaJvKYWEoiTbdIUMFpSbBwcbV1zebmmxzlmvC2vm9rHdY7fLvvOoqi9XLGEnChI3QDLngtwtWKcpiF2j5DFwJ51NwAqaUVB3WR5ExgHBPjnEjzgqDu34WwqZPLnMipiZyhh5yY0gPpYS/cPZd57zZxcD0pptUNegt3Pdy+JAhO+lph/6MEExMDcB16zUksbBk/wTnNP0EzEteTxzlHkouN1PkW9Jga+nMT8O7UvfeXFP/2GN10u3MBTs+fN3H3Egb0S4NhU4Bf2Fr4ip//fBb7v/Sw9qp/dfyDNfNPC/e1NY3onKLWnbC9TijXkOlcqK2Lt+aKyVnHxjnBjaFeHemP13QhUmphmRe6aWE4HgjHAy5YoofD926JfY/vO2IX6Xwg+oBtuBwa9lJSRmwlhxvyqytyKuQ5IyXRSSHlxKGo0z23nI+cMnlJ5GpItTJVS3VuK1hYa7XT1aJd/HbNQGx4Tu9aEbTda4sieU3vcSEQ+qE5Z7JmKe/GfzXgrCdPC7l1SBujcz5FKXpGFqY5tesDFBF1JAcHFtKyUNJCcEHdw7kwp5E8J2rO2q3csOiU1BpWKnk+bXO7GgJiE7mOZNuBt9iyYIuok68aFX5FcfKuTWVzRXOLijAYz7WLmp1cCpIVn65UB51L5rLmvRm9d9ay6j3WHA//pD48/l+/SUX/b8D4v766vf3HmuVnNjfZ6gK8LDgvTYGX4kDLvWsNLxuxxNQmeGljl7raBGscT0EpayNWa6S0KmaLiI6jtg1Faq+Y0EtG6erq29x97PMFm1jVum9TzjjjcK0Ir5e45gZsH3BG8YT7YoASViK56HzUu3VRa/BGmy/X1V+tZtVHL/L3TkSTNU91l/u3FgtSyvre66UAI2t+YG1I+/bZ6MuYdi1RgVQz49f9UCGz5rI1hKaU2+d0ef1SCq4hXKkN+WmhFiWwSKpYV3dCJIrfl50gC0gput9NeK1cCh21fbi1Vtt977u/P//3/5//y1/H+f6t4Pfy49jHV7/3d37x95c5UZZF0Xq1ICW18a/CtSCI0bUxVTOe05yZp4UyLeQEdS6YecaMZ8IPE/6XLHznM9588j2GMDCVhYcP91x9vOfdJ5/Q335C6C2HTrj+zV/k+vVrwtWR7jBwiB2DC9icKWlGjK51ZU7aeNy/JX/2hmUW8nmhppFSFpY8I6mQTzPLwz1pmRlPZ+bHMwuesxQecUjf4azlEDpcDFz5Sk6CyzNZtNnUVEX9docOgsfIgi2ZUBMmzbjBEWIkRIexQi4JEXVCYipCRhw4F7C5UktqCN2Kd4ILhhoGTqdFkWLThDQqzkyFodP1+PhIns8cuwN9HHApc7r/QHo4wTxzFXoO/auWKz5iaqa6TB5/BDVTfCQPA+Iy88MPOcd3lBjx+R6/JAwRKVBtJkrAOuitXovOVTjPMx9S5p2t/EJ3zTIV6rRQUgEr2BAUe9hc0DnXrelREZAQgrF/+xc/+4P/57/5s//7t6Pu6/OIMb7+7ne/+x875zbxby1O74ve+8L26ngZxzOn8cz59HgxQ1SNJzJYEIN1FXfsiCHivCVnaeND1w5dF7l9d8tvv3vH1dUVfd9zOBzo+p4uxgtOu0Ju6L2r6yNv373bxMfT46mJWGwOxvN55HQ+aUSPRDDq3ikmt6qn3sdyzWQpW+NMkUIf44biXJ2suaiY9fr1G0ouPDw88ObNG25ubri5uWEYFMMJlS5GShHmZQFU6JuXmdJobNLqq665Aq21mqe6LMQuYo0jFCGVRN93TONISkWjfCQzjmfyovttDJQqBGuZlxkquBhw1jGPM5IzNnhszpzHiR/e3fPmpgcxG7a87zwGS2oN4MF5Smv0cd6D5G2+kqUgpRJjIEmi73ut7bbnlyb6ee+fzDWMMfbdu3f/wx/84Af/j29H3dfnMQzDq1/91V/9/X2e3XPh5yUH2NMlhP2SA3Av2H0V+nN/jVnddet+rP+uotTaCLCK5nvB7Cft2154fO6E2zsDX3I77sXM9bHu6zzP2z6fz2fmeSaEoE0KawxAcxSLCFdXV1tDw9pE8Rwd+twB+FwQfUnkfC7WPc0Ftz9RuN03Uu4F368SeffbXhtEVmf4cyfoC8fE/sZv/Mbv/6t/9a/+b98IAdBsWWJaDDNr9+ylBfOy8mhiQq2Kd0FWZmrVsGTjNJ+vli2Lb/1Tqa1YZMAaIRfbCleGnIQkKhx6a3Cry8058qIC0drhWZuA4nxbyLecNanasbKhdtp70ZuTIwQVQGqp4G1b9BXVMqswLoXzaeG68xQxTHnBYqBzhOA5HjquDtfcvLnChwApQ80kQe3wOdMFz9t31/Svr3EG0gLOW5xBJ+U4bg5HljQzniZKNVz1jj4MSAyMS0auD8inN6QsKkKOM+eHR86nRZ1iBsRY5lSoUonBYr3HSKG0XJFqDGkpBO91+9aQpoSNETBcvToyeCgpUyUT+qM6/LoAVNI8Ic5jpeKtJ5WkYZHBU+eCpxJjJAO1ZuapaAahCNO80EfPaUxMs3K8rbWkpTCnQvAGbwMpCVNKLKnhGGxzmZYKbYFW2yRcRLBG6PoevCXPy+b2pIl+87zgfYCGbbDQ+OeJnDQ5suSGeVOOoTp5TGWaZ/7sTkjlik+uO6J3WOOpNW03hiraRW3av5ofWRU7JhWMx6JuE61cgGti9ib+NXFTmuPEGrs5NVIRQrB4Dzr/ap3aYjBOcaTbpVOyWnGbW1C/aW4X03IEV/diy0ysGwe0Ulo8Z31RRODLKNBngsPdT1QHNzvgVzzvjtvbi8nv9va2PXfvDrx4/NLE9uQn4uKzzV3rJKDhP1X42yM/V2FEIxXXLMCLW5DmHCSDXecPveb9cehxxwPd9Q2H64FD12Gzil3VOoz1eCu8Og5cXx+JfWgZWWCMx3qny8fooGQkJcVcRY90OiZzLq1Anim16K4sepOueSHMCyVnpseRMCfCADGr6NfIy412GjYBEK+LdhxILiCF2HV0saPkhEc0kxVw0WOMFulrySqcxAi1suSEjyogGu+wpdB1DrGemi2l6IR6mRaKgPW6ED8vDyw54VDBrGR1zXXhWpGm5wfOq3i3uvu4IDC/JDH3t9xOd0/Pq2knGt+i2Ygog/bA5yQmDdrjlutecZv3ANMtvod8PFCi35RSb50WP51ifm2b5DglK+qzdgJdWkXKv6L97nYnqa9uxeln+uO9sJeefXDPfveCdfbn3UG0bsN/793/yQb3bhX/FJF8QX2JgLV1c3dpkf5SmCZnKAUjFkT9gQRHdzSYIeCGA/H6muG64xA7bMlM04I4j3GOYISbY8/V9RWxi+rkqWDsbvwHB5KRtJAKlOCoXdRGlpxZ5oSUQi5CNbCkRFkSJWfyogjy+TyR55kohlgq4oJiAhtxoVi9X7oQN7ypMYr2plYVJaND8oJfG7MAHwMYQ14WqigSqUb9fFJJeh/3+l5tLsTOIW4d/1XH/5zJFYz3SFk4zwtLypp3LCBFc1OOQ6QIjPPMvMyIZAgBMY6posUMDOI9RpLmEXsPVgsAkhYSjoTD54VQBSMWsYZijRYLMITYUWmZSCbQG89SJj6YhCTwVcipowSvwmFFcesNA7jOWRWXaMjt/mq78Kvl4Zsh+H1Txv/h+9//70Lfv7NNfFvFP6m1uct2C0qzwwDtFoar5KvZzRWsusOcu1BIdMG4BtarM8025KczT91ia/afaWhQKbIJa6vXXLP0anMHKrvdNOqKFqNqI37oPvgmEu47fL33VDSzyFqnedPkthbSnxlrWJak+7xSVdQWqPtFW49ZnVpuzsl17riRVmiNlLLLR2z3xYYkXX8sOxzo5TVo68e6oVP1+dIyt1b/sTbGWRGNa7CuvRe7bUebc8xWnFeNcp2ca35ZyWWLqLgIl9Ka8fSYy9rcYxr6b21obe5LrSepgGgtdNdXvzJ/K/h/rR7/s//sP/qXb18dbtN5oiypNQBnXa9hMdWAFF27udYEVApVEpIWmCZ8yvjkWn6gxR473n63p7wdiG8/4dUvfM7N7ZGbbsDOEx/vH8l+QIwlMnN7HXn95jWHq15JQdVgfQTnwFbNyJaMzBNJFpKD2h/AOFIW0lVCloFSC3MtLHOiLomSPiHNE/M5cf7wgfTwyHW13CyF2l1jekX8WW91Te0zne8wrTbTB4uRQjCGq9dXdAFkOuFzwUjCOiH0AddQ/yW1NW1zKWcEG7TQX6vB1sxwEAyBKQeqWJYsLFMhVYfrOnIq/PjxkdM40g3XWIF5qYR+4Lq/ZpoL7+8feTx/JKUTXF2TXc+9MdpIFCPJRHyZoS6k7oCEIyHNyPnEyDX3ZmBYThxKxVbBGMc5eGQ+43Ecj0cyC8t4wjDwxg08zh/4d26kTtBLZjq/Js9HxHglHEWzXQsqFSlCdUoRUNKV4dM317/Cv/m26P51evze7/3efzsMw+3e/bcW3nfura0oH6OSnOd54nw+M51HihG8C5gi4Goj9rhWf1KR6+3tO25ubpAiPJ4esU0YeHVzw+eff85nn33G8Xhscw3ZnPrGqsO0iHA+nQDDMByUhgZM49hEPs2k9t4zzzP39/d8/PiRDx8+cP/wwOPpxDyecd7iQ6DrIj6XRk3TK3vKit2stbbsQ8/5PHI4zlxdXXF1dcU0TYzjCMbgQ+Dm1Q1DP6gwkPOTRp2SM74V/WuqFArH4wHv3eaeSSlxPp8JIfDmzVse7u85nc+b4Jay1ne73jEMN40utihZAIt3Gkt0XiakVMiFRMZahyMpxc1W8iLcn89wrMwmU7M289TiyVZwXk0eFOHVzTU5J/KyKOXBOW20nhKZxJxn+qGna1nQpVEDVuFkFQSeu7Gur69/5Qc/+MG3g+5r9PjjP/7j/7brunen0+lLuW3PBbW9WPRcYPvLID/37rC9yLUsC/OsYv75fGZZFqZp2gTJVVTquo5hGOi6bhMbV2HwufPsuQPxudj200TAvYNwLwK+JDzGGPmFX/gFuk5dytM0PXnOOI4bVnkd99ZaQsPjfhXic79vLx2LvYj30mMvKv6kv3l+XPfffxVGdO8CvEQU1CcZqc/fzyeffPKr35Rx49fVQF2DTxpXRnXAi3hhqqh7ZQ3fa0KhaSl/1hmQREWgKmazStmwN866trATRLQgF7zFecs0aSistxbvDTXn7cY457Jh+rLVIo1pQYWl5fqYklkbcNeO1fUABmcvnbYGXDAtU84T0M5wI5VpXBTzWCpffDxTqnBzNbTmdYu3QSfHy8SbIRD6QJWOBfAWRCKxC4TjgYBFsuBJ5Llq0awqV7JmFAcWHUvRwlVEKNEq+iov5OKIxjF4y80QWK4jea7MRcjzhDauF3LWgeWlMiYDg4pQ3nkeHs5k4BAUHZCXhauhx/eeg3d4IwSn7kTfRc2bKwWHIBbIC0vDcroKeU50QyCLIfQRO58I3vA4e+aU8WWipELBUp0lJT3OxlY8hmVOhBjwHvKctRCas2bteZ0AVKmIt61LGTAqGBtncD5oMPMCtRqqsVBV2BMUf5lboU5qVRRCLoShI08TWMNhiJScWHKm5EQXgqLhcuG0LMhSCOaa29cHjK9Q1LkVgBla9gpU47TQUCtGDLaiiBS0eOJFObmpQqn2kmWyYjrtzjVrrBo1mguwc4ZghKU6jNWOJCNrluaKtlJVyzYRchXnaxu71tjWGX4Z09IGtcFhNTlzw4q+aOa7/Wka3+0LouHdy2LgcwlwL/7xXPxbtbeLK/CrdmNvM3z9K58DeXP97cU/Ffh04W/btQSHovh22E+b1Z2mgXHAoee4BsgBVlReO8bIcOy3189FsCJ00RO9J8aGpclCLRlJszoHnCU6R7WW0lyarnHnqgHTRZKzmCLYIhQ7N8dZZPAOEeiGA0kKUmDJpblh9T0lIC+ZQtJuXac5h8FpkLnH4aLTDD9ncSKE2BO7gPMO6/TaK3mhVmHWSqdmt1aPRdFl1qtjJhhhyUIRIc0JKRljHUIhlcySwRFwXaCUi/us5MR01hzACaC/pW/Wt2m6+/Jxbo/P2+8+3/0ycEvaROdb/uT2bvu7xKSCItDvsKlpuuP+7o7D5zDP1/TR46LX8eIKpUE+bZNUDe4ilFzumjtD3e0m4j3X0H+WR5rgcM2TXMPL632FC/AlV9+XXIHpmWD481lM/Enbia+v/plZJ4st3H0rJe/+cBUHtol1VexnrYKT1hxiLMZC6AecVLX2YrGS8HQcu0Dve8yriq5VNXMvek/nHLHzKiyWSs0JSZOOf2sJ3mONJdeqOZOmbjmuXRdIRce/FCGn0vIGA857ogjx0JOLumdSykiWLbMri5BSpojVQr+zmgNiLR6DMwYfdMERbIetQohRu3W903tnTuqakMpcVpRf0eIXei+2QV8zzJU5LS1bMFFKUqxfrersb8X3GBwllw2pnUthTolpGlmoGB/wvoOq8yvQBi8vaE60gVArNo96D7QBMRUrhognUTGlgjgeY0ZWB2ONJCpFMp5K33XE6ik585jOHJxlXjJ9bE4h1Ckk9qlr1Gp0WHMDgg3uXfm24P+1Gv9X3/3OH9s1qoCLyXeFuK45c3vxz+wC7KVyoTbUFVepGGG3Q/CYVlhb8/OkytZUILR5IRcs+/qqF6al2eaD2z5avUcbQM1uzf3WIhG0E7cJ/FjU52uIPmg3vmg2T3VVx5l2RDbMJ9RScFhqQ5tuBQlntemh5fI5Z7bPuEglevckM/CC/SxNtNQrrC7y10xC/b1sv9cDt+J16h5BamT7XK21W56fc07/bU2BxmrjnPe+5RDpwty097DiT9c8RGnX1vWc2SOUSrm8n/Xyv7oI90UD5ywp5Q3DugqatVZ8Fz/5VvD7ej3+4Pd+45/VWikpaTYn0i7aSjwxrCK7xa4kIlsb7lHXo36e6JLBOo9xlqt3t/irRL7qERtwZeLgjnzn1RXX/hXy3XfMpXCeEibrHP3QBUKvbpOaCkwJyTMiCWOVxFGzICnpmsxplcUBNXiyV8ernxOpFpai53Z/daA/Gm4+ec2Stcg/T0tbSwsuOHCWcZxYsie0gn1wDm8sg3UMMXB1PXAMHoYO0szx+sjx+kiMAdPWK7bW5ipaBfkMNmC8xXYeGw2+M7gilMfCko2KqDXjo2vuqsQ0K1rveOxI84yNRikCuXB6fODx9AWPCPbqLf3wGpPPzKcPGKxSl4rWe5YQONRKmH6sjcb+QDaFz5PhiiMnI9i5QD7wJ4dHpIwELKYkTkbI+cRA4mZ4zbXpScvMD8Yf8S4EHs9n5vNCbx0FdQUVr6hgdTLn1mxBq2PBm5vD974tuX+9Hr/4i7/4h6ubYy3mrs0l+wys1RW4urvWnxUyHosRKNVQS8U3AVzrB+pMMxhurm/o+p7PWg2n1krXRfphoOt6hmFo99mk46A5YruuI8aIDwGf85ZdS8va9S3Tey1UW6vxQe/evePVq1ecz2ceHh54eHwgp9wa/CxdF3HWk5aZ9x8/YlrEjnOW4+GKw+HAcBiIMTbnkQoPXd/z5s0bbt+943g8bi6g8XzWjC8/a8W2FfZXoSKEoILm6cQX798zThNpWXh4eGjCYd3ENOMdJHXY+BCwzjLPMyKVeVpYxhkfNUcMB6fTyJQTh+CpVJZaEKtEOJdaIwMaNTWfMrhKydAj5HOmexW14UsEf7zCGcO5KC48hg5ZKov1uJwwteWttc/79Hii6/W6aZ1jWZYX8Y+Hw7fj/+v2+Lt/9+/+073o/xzf+NJxfO4ae+4AfJ5p91UZcquDbJomHh8feXh42MSyUsqWp7d3A67uslX424tUL4lVe5HruUh4acB76sbbYz/37sH1+xACfd9v72N9/tXVlZopdu69YRj48OEDoblk9wLlHgv6VYLfS7l8zzP+nn/Gz9/H87997uZ76bP6qm0+P4br/H9rEm3nwnPBtdbK4XB48w0SANdSB+z+73LgzFb92DotrdmvsNXJZKty543xKs6g7iRFwQjGaQ6eLmp1WWyda93uRrPTnEUkK25KmYqb1pilIqIYTKgk0UWea2hIpIkhzmyZ7jGo+805s2WlXZRv09jdMLc35ZxlXJIWzY1XNE4IWu/NmdpFcqksS2XoBuLRcR3VZVaM47oLWvC3KtiEaLAZZJ637tlcDTUljKl03mmeYS1t0VobesthnSBLxdWKD45iDEMFGTSce24W/JoWJAsHW8lJF/4A4c01y5ywqENQEOYpc/3aMy8LyUXe3HT62VSD8xHTsKu+Wg3VNV4LlUbIAjFH3Zda1N4P2DxqgQyhpEx0hpKEJBXfOYauI+VMHAIWw7wkpuac6jpHkcxSRTFbDiQtuhgygHN0Vt1yqYqeKyJE7xEDNdvmkitaW6yCFUUiSAssZlScQKkVYwrGWLxRcXFZ0pbrZ61jnGd+8IXmKVwPHprrx1adJOAULaTEWnXXrf3HRdRloVghnZg5pz+r+/KzNdiWx5dKUeQotWVQ0Qoguo1aWwdmbee5gTXTr9RWT1W7yno5bgWZ5vAzdcuyMVsTfNUC+UX+4ysVlz3H86tyAm9XuW6V6n7iE5+4/55s+vaniIbPpcW7p1t6/elhE8K0uMVTIdCteX+rMNZUnCYCWhdUPMxg/UX0c2o8wUZP7PR89CWjhlhPtRbrFDERQ9AiWruZWGe0iJ/a+M+WYk1DaGRdnODVbVcyVMEXUf6kQO/BKayTKg5TCtZCwFEEDlbfVMmLgnBFkbpZLjczizrZPDtF1IF3nhAtXd9pLlnL4bHW6YdXXSOaCaahULYMINOKqdbhTSFV3fcGU9RtlEz0EONAKZlC01FyYCHhAxy43Vxvq+QV2s+eS1yBO/p2EuR25DN3cHtHul2htDun6B3c7vIjV4cdoYdVYJtgCg90naYMuujbOVRaSUZPHKHg1yaUtkeRwLyT6SZ+4un708/pNsZSaruoyugmgd++KP79VEnxK372VxcBv46oQHN9+E+6q+HvVpFtCmO3ySWtKWItvut93hgaMs5v2PLtPuIMtbqWd9n4+cETo45/18aqC14FIWdw1ur497aNf51E5qpZmavrJCd19EnRuY1tAvvquvXtPoJUuqDYzaLmbiRrhnLwKjweDn0b/1pMKFLJWci7yay1hpoFt2aGNSHL+0hwhq7v1ZnQnOjOOUwVFSZNc8tUxeLa5kKXdh0w1uKNJdd8ycuqFVM0Hzl6j4tBEYCm4H0TIFLBW0PfDwT1Z2BroUpBrMNWsKU1ebUcQi+VkIHqkOowFJIRxBayq0xGWDhRjKOiXcvlXMFFqkAxGTEDxEDJDxRmpuSZ5pnee7qh03xD0YJPS8Ruhf/aCoJ633UxvF3+hhb9v47j33322X969fbN79Q2r3qC82x4qDW2zlijhTNrdovI1g5lvtzxubrl9tlxpjn2vffsACqK9SyGimIqaSST9d2sJAlrTVvXXFx2NDFRxar1fZjWravFA5GKd55impBQhWotUtWlWHLZMKLFtMYAVicCYIo6eNbMvJxxIbS8H13g+k1Is+rAsw1FbzSfaMUClZJbtENtuPqsnzEqBK7vYc0ALEW2fVtdhSsadF3gS1ufaWOUbVnJbbHvnnZe+9Ygaow2JK0FjN1UW/etIZDXHCMtlOz3hc3pp9e/VSQtz+bHpiGPIXTd6/rtWP3aPP6j3/rlP/o7v/yd35aW47LJ2LY1XjYctDq77eaIxRiqj1SbFXedE65WbWYOHV12+Dhhhg6uBoZj4MYZumXEidX7mxFcBBMCXQj4oI1CiGLycy6keUZKIpnKKKY5+hPFgG9rO0PFV82ez6I1k+oLpkPHe3XaPEylGwJiHby6xkoTE6u6G/NhIInGY3jr8M5QpkR0thFvNIe4C1d0V1fcXPcMvcMZvUY656guKjXAWnUji8FbzS63wbUGSoM3whCcUgJM1sYiY3FSMVK5OR4Yrq7ItVJK5ur6gOTEsowcYsDefsqNZBwWk0ZyXsAPmFTwi9aeWjWAkAqHuWJKR5YOzMJoFrKfMb7wfkg8mh8w20i2mTT/CccvJsRfgxSSG0n2Fg5H5vlPyfUjYTry8f6B0/EKFxzOaYZaspbOa71oxRw7a7dQnKuhu/q25P71Ev/evHnz9xVdyeboMMbgd+LfWqy/ZNNqXVCkKPHDaR3IiiBiW3E+kJYTPnhi31OppJxw2TEMg9aYjKHrOg7DsOGpVSwLGkOzLOScSGnR5r82/7fe46zlPI6czmemcWqmCb3/Dn3PYRg0wgY4Ho8cj0cO9weWZdmcOs47fKtnjOPI6XRiWRKlZLrYYVsEkm2iRgieEPT5r25uOBwOW2E/PBMk1jnUaqzY/8435884npmneXMBPjyeNvHMNIx3zgXJmTlX0rJoI4az2OjIknXOsog22opwP92D73A2YAtMWMiZ3mvt2KXCsEDtRdftiDYZPyZIFhkMp8dHQqdiZUpZGzSHjlQKZdZs9fE8brjW1cW1ztXW+UTdzVFaDuLNt6Pu6/P47d/+7T/67LPPfnuaphez8r4q428vCn7V11ehQ1cxaBX/xnHk8fGRx8fHJ065VTBfrz17UW6/xngp/26PzHzJ0bfPNlz3VzZE/8tC2WqM2gtv63m/z+tb9x0gpYS1dnMtdl1H3/ear+v9k329IPPrTxTm9l9fJdo9F2t/mhD7Uo7iS4LfXqx8/rfre3jujtwfr+Px+PYbIwDWNqsxq3CwLnY3x9Au6wKrEkOrBFUUN2ko1Lq0BZZTfATq1NPFpodqWzFeXWF2zQ4sDdfVMiCCtS2irOEVU6GuHSXQbtjqJDTGaqdru1HpQlaFRKQSWi6Ei7Y5bVQQtKsjyjlsqYgoAquUmegdNzcHvPWMc8I7R995hmHg9ZsbDtEjKTM+3lPGgB86Qq8d9pRMtTpBDsZTS93ciVW0eqQT65Z7UTRrS5oLQXKBlLC2FQyc36IYxRayCDk5xFS8QzMVbQeddqZJRV2BIhSB5NWRaa0nSaGUhXlZCCECmmPSDQHvbXMwBLwx2vGDpeuDHu+krrypZKgFbxR5hANvLX1fmUdDkkrXO+apEoLl2F1RcmFakuIULDgbtOM+6qJinhNzKYSGTLPHQK2wLFknS0V55gfviNEQnMMGXaCsgeZzyszjxJSbmGfWPI9L4VekklrOUG4YT0U7adG0VBVkPj4K/+4vLL90eyR2ioqsAoVKqULXUGBLKdvAkJYttbphS1WsgTM6qczNCVtQwdKh6l3ZuLq6ZC1FmnvD0NnKlC9JnFUbpLSjGzZBW6RqC3mtW4Fidb5QzZaOaZCtG145pa0ittfonqtsf2mq4cTd3d2G5dwcfjxP/9sLfk+fuz5UStxe9UWx8PmPPr29RWX6/Kwy2G4kWz1ccyFs+7nx7ulzvebViWsCSbn8Lh46rg4DQ9e1z9Ku0ah0zSGEqdRcKFLUJWcdLhhEDGQ9TBrOLSooNSEiV9E00pQwVQgGvAOxliEGimg2zZIsS3INa9UEYA/OxksXUFRBPAuUVDCrEOpA8kJKa1FS3YreXya6ugZyeBtJRXAxgIhew9AMFesdxVly0vFlXLsnrPcIUUd0F/uNS1qASMA5KCTIAYJ+3D3gEhQmHD2EaYtpLC3C8QgM3NJ9Di5AokeApSl/N9xxRjGwcMsDdy1bkiab3RK4g0ldgZezQbcxzmcsB9bTweM2l6g0UQjrNlSYA5acnpyR/XMhkJ/dBTg1lyLhq1yAP7PGyNNcwJ+cA/jzUOx/6RG/8/Z/b43xK0JuvWZqUZeGS24uW2s2zLlp2S6loTrxUVtwrNG/kXVQWOIhcnXoOcTY3GUq0llrCNFvIoLkjIiix3GKAJdiFH/Z7q2ICnKuBRFlEe26z9p9H0yluuY0j1rcLiKk7FgWqxPsdq13Xu+ja25zEcVWSa2kXNRB75v4UDI5LSzN0RJ93JCAa9HcGb1mZVGBExHNE2xYQ+cVs5mzovmsN5hUt3vOmgvSdx7jNJNrSZrRpc1BRZGgxuA7qzldRbOZjFFSgm8uoaaDYikMVDpjsS6QneLHS0rUOSHFcAbOCOCZveckC9VUogFre2zJ1PNCitowtlToxVBSZlwWjPObW9SvecIbwn7F4rfFlrPXfxMK/j8v4//m1371f2esVYY1KnCtGeSlLe4ui8YLenPN/7PWbcjNNUd6RYiurrF1QbohMQ3kXaaQc3Zz+dmWc76K/itNxWCw/oJj3y/M67awrZtguXbx5yw457G2RS2gDXeg17NgPLkU7CpqVR33RQTFedAwnzoJr6VijDYkFpHmdlSHXZGCbyKcOqPthkelfT4qjtXWdNCylVizCPMmrK3/6ky3KinBrMUNp9vyLXPcaPa29v25rei4ojoV2cx2XGzDm+ocrF1LW0MFK+3esWH82Igb5suucGPZg+LXxolUdH3aiKzakIfggr/6mzD+f14e/9P/5B/8N30IYT6lDfut54lcBGarjl+zfa84aiseOws2HLGHpMSWLmKcw8yC6R14y83tDZ9+8obrYaAzuq4HQ3QQOs3tQgp1GUm5qvhoKkKilFG78HCIWJ0jG0ekamNxa7QjJZyWJYiu0pnK0SvjppIYZ8u8uFZ7EZytqPHPYIyjGoez2mgtRu/R3oG7PlCrQWQhzxOLNfhoCSEy9J6wiulUrDhwBbFWJ+gi2GzwzjdR3mB00QFWGI5gbGJKBhc9ITquD5Ek15yOvd7Dx5nBe7rgSJPnPlaMd/TGUeeEXxI5JoyJeCmEnKmlMmZIFaIs3NTKG9tDPDL6IzOVZRop92fy4vgC4a4KUjseu4G/oKNU4dp5vPuULs/Y9yOPhxERy7kUXmfPch65u/+IiQFRSzG9C1QTMGFFRJuWBqyPYx+/FQC+Ro/vf//7/5tSil/FvXEcKaUQQsBay7IsW3FcG2n0XqjCmNNmdtcy+kTJG9aqG98YjfgJMXL77h3v3t3S9z3ee2KMdH1P3/cMfU8MoeG/1fWz5uIVKczzTC6FaZ5Jy4LB0Fl12K8udeuM1g9XLOf1Df3Qt7psZZ5mLd4D4/mMtY6+bX/N5Vqxn5ofeNoadNYieClqNlDMaNjey17UW1/Lh4C0PLPVxbRm4uWcySkRmvi4mKUVzysxREbTHFBZXbUuuIbWFnyMej8uTeAoBlcdxgkLOv9wqHtPG/IqRwtEJVv50EFXybNGFZzTB60w1IUMxP6GYCOFAos2GZWUuF806886DQlKZaGUTIxhc2TtXT8b/nWHTTTGEEK4/nbUfX0ev//7v/+/FpGwd/+95Drbi7h7IW7v/HtJAHwuJu3RkSmlbbytuaN7FOY4juScNyFwFc10fixfEr72r73PLX1JkNzoJTv33nPB6rmQtn9v6zldStmumY+Pj0+Qt+trnc9nSikMw6DXu2EghMu42YuHewHwqxyMe4Htucj3VTmGL7kf9+7Fl3Cdz0W8l5Cg++Ow7v/6enthcH1+3/ffmPHvd0eBJ27AZwsL0zog19WVmqCapbTmtgAzlLLmVogunKvBrPhP67bFlHWXBYuKeorn9DEAwjItTEk7yytVcwGNZqKthXeRBOLahL4tnlGUDa5hfURwxWNcJUSnOYEtf80ai7iKdwYZteB9aPlzUis3hx7jIQ4dvfMYyXSupxsimIYRcAbj9YaSl4VCRXKHOC0iC63YZxwSBJGCryBURQSKUC3YqmuEUhWRR0MEFaAW7WasRTBVi2aBogVp5xRrZA2eit8NkNR70pLpomPJhTl5KEKMW10AsxQkQ7ENKWkNUgudVVBkLploLTYXkIRv23J4JBV87IhpYawLpV1sfIzcGMuShFOaQYQhep2sDAUkYPHkmumiV5yAU0cV1iKSsFU/PecCoY8Ea+mcw3lLyq3YmArTsjDOE9N55OFhIRvFyva94+H+rAiUwTOfE/O8UIFsGrbR2ZYDRXNPZEypfHg883oIvLaWLjpFKyV1WTS8OM3kofvRgqC1u9RQywbdRGrDJ22YXXVqeBzOtEKydSoKV50Ueau8c+uhFItVa2BzrLTCc3NjVGswu9rFOnZt254YzUeo+06M6uCJbPOzCn5fVuQ2nOfd/sfPFMXV/fel7dyqo+9WFZsemKaXxb/nQuDtHbz7nZ9wPW4inhBompy6WewqBLomzmcVSJxveFDw0YN12OAYDpHoPN4oXm9zGqFduyqwZeYmnHk0j9RRqdZjom0uOatirvW6kG+KmTeRBJQs1IaddMar0GfUkRvtRZOsze5YxeGsw9m95unwGbJdtKDWOy1y0jrrm11Q2lepos4WtJhQxRCCwwZLFUOtBd+2veHI1nwjeznpBPDRESTSs2AzzMtEUAWQ4DzgOVyBddca1t2yF627AedxQT9P/XnGAjF6vNeFmLOaH7a0QyvjwnJ6y3B/ZjlPFHquD5/z9jzRDIckYEi3+OmOLxoGlNs7hvZZLhm8TzCCjc01ujp9bQsD5PIe99owz4W/n1H1u332TZrg0JTL1QWokvi0yZlPv//LPJ5lBP41Fg7/vW/LELpXx39odrlN++I6uxxA59yW2aX3HKuOGGfJsx7rahSFa33L1vUW4y2HoaPzGkrvXGtmWmNoa8U4g+TCXAq+64CKN2bLtzBOx78YAduaQ1bB0jswjmW9jzSGoTE6t7G2QGuikXaxlyLtXknDfGrB3ANUT86KujMG3f4u40C7+qWhfRQhWKQ16DSBwHvFBUsxsIg2GNHum9aAsZRaLp+zMVRT8d4Sei2mGWNYUiJYneP54KjBaRHWObIIkjTzzOjFR7Odm/pXsxY5vbd4bxXV6zpKNSRUpCxzIp9H+g/3XJ9mkutIneOYZrxUxDkyhj4JJhc+GkfXDxgqg9NsqCllvF+gBqimuUDVCdoqu+3K2sLM/4oW2q9r0f/nevw7N1x/+snvbwva54v2lle3X/i5nZvMrmuY9R4m69VidY097UJdm73W1qy1gLAuGjV3sIlt7Tlr1qAKVm2OWM2GnrQtc7LsFrDrkqxe4gsbFvSCv9y6VducpDZcZxXF8BsjKtbZ3UK3ORZzyvjgW8aV3RCXWvRSCoXON3dZhu36tG5/bbYw7bqwzwp8XjTZHJTtta0F21xF63476y/Hwlgleli3CbGXf81WvFBHZTtiq+C43QO0CW4tWmoTQ8P7tYbQ2u7kzvmGAapsrXkb9fRpN7l1bvhW9Pt6PPoYrn7vN3/pDyRnas5tjAnVeEy1m4MFq2QiazQLyjiruVAB8BbJleoD1Q6YzuEHx+HTntpZxDle3xy47jp6FwhGlCZjq67TrGZgT+PMLEJ2OkfonMFVoVsnCzVTjWxuVgSqZMQYqjekiu6HtDFsfGvqXHAidBSkJErW+Ys4R7GeECLR67nsXMVbFRqLF4I3dDFqIxIGY4PO80vGoQ2+ipvRWgno/MNaQw3q/rOiDdSuYZONs1TrtQm7FowtWKeI0Nh7rl4fqN4SzhPTOOGKwdlA7CJyFXn9yTXGe+acSaNgiuAC0AWcB1MyMmfqkvBW6KKl6z2HzuPDDULkVA1jLuSHE+OP33Pzp3/Kpz+8Z4zXnK48785HYsqUrmPB8m4C5jOPNnL96hZvKu+6Dlsd9+PI4XTS94rjKoBxHtu5dv2u7VrR0MvRD3z7+HoUML0/fuc73/knq/tnmiaWedbx0ZwtOWdijNv3oE3lmvF3ydurYnTtbSrGefp+IAZFSr5++5pPPv2U169eqYhkLbGLxBDpuw4fvJJ3MsTYEbwW+/UeLsxdRy6ZeYqklHBWBXhrHYdhUFFvHJlnfR/OaoZlCIHcHI1d17V9F6UFGK3hmJZhF6OKC4fDgbQk+mEg54Rrc4ZaNYc0Bm38i83Bt85huq7DGMM8z9rcECLiZasbqOP/IohJKa3hyrb1iiGEwM3NDd573n94zzTPiFXE/nAYyEsidh1915GWhfPjyLwkjQpyntj5J2s4ax0+qHhyPBwU2VqKEj5K4fHxhD8Z0pjw/QE7W7rQa2VbDGJQwoiFPFYYNOfbRYNMGsmzCh/WWbqon7FmJ7rLvHHXOOr9t+P/a3P/7/vrX//1X/8nK/Z3L/bshZ6XXH0v/W6P/dxjM58LS6s4l9t52K5FhBBIKV0Ede+35+zde/vsuTX7by+m7QWsvaC2Pyefozj3Atv+5/vfrTWAPYJURLZM1FIKy7JwOp22vyul8P79e7qu41W7/u0bB567/vauui+Va36KuPf8+OyFyK/Cn+5Roi8dq+f//TyDcH9c1mOyiv/P/05xz98cAoA3DSlIFcUEamJt63haczPMBYlEwbWbTqla/LLGQtUJEqZqRkQLiRecmmua4FfX7LK1M6Wt2GybNBsLy5yZ5kVFkbbKcc5gqyHTDE8qC2o2xGbp0YVqKdBHr66rJJQY6L1rTjet6Wo+tu7vIjAVUWHOCL7zDEOk7w/43hNij6+6YNZ9EoKFahpqQxypiKKpjLr7iq3qAmsMvpJbbkZeWKoiJXS5KdiqDrvqVFiqRZGbtarrTAuF2oGKEaR1y2JV3JEqmvGB01KVaAdwHy29j9QqxNhzqJV5UdSWpyLZkntPkcQxdDrJbZghvFBbBhiAlYyzisOwzX6UloU0L0ypkFPm4B3TUjDBY4tgTeGmjxRniV2Hjw5rOy1ClEIhaGEWdWPVhmLouyus0YVQsAYfWii71Q6gbAWxgh0CQk9KB0rOfDyNLLnlPFi4OhywgHeG+ZiZpoVxSopfq5Vpyeow8MKcCt5pISctmQ9j4tV1p5MsIy13pDKn3FBMDpst1AzVUKtthaa2j7V1kVOaEGx2EZtVHQ+0TJrmrTVUxcc1Z6Izldq6xIRKqboAQ6RBQx22NufJ1sNZt7GgkUuagYFZf7OKgObLKsTdVwiBt0+ljtu9mHd3cfNdBJAv+/72z3kxXnDLdIOH6cvOwK9yP/XAMAxNwEtPMKCXImHYoUE9OBXWViknS8vSI2lXcPT0ncN1ER+jCnlmFcgswfmGEWsd7RZ117RimhF17KYxNbdg6/Bv52I2lpIzqeV3lCoIBSnCOCaWeaFRMjBRcZ/BR7C2jQMwslAyXO717okopcJZ1HPMWmLQgkeVglBUCLSowF8jUp9XlWzLnmw4Wak4q4l4Itr9n3OhLosijVpemAWCZWuAiPaIRHVEOuewnu16LVLIEqlNwLTtyzTWpmX9zKELjth1VBO2AmNGCy+pvmYZM9PHR5ZUkBDJsmCXjAApqhNxerzmMOnkLITb1v3Sq+oGZM+GUnFN5XvqDVA7ZcmhCa07m96zsXP3V74lq0Kengl9d186638W8S/8Bxf//kMVJu13b//PIbhP1eFSm3uHrXFoc/s0Z8iK/3SrO9BURDJSElUKLnps8OqM7yLO67zEtwKYa5N611wErUFc8c9FkIbws6YwTwlbpXXwX8S4VUhPc6K2xbw0dN40LsxzZkmixbZWuPNakccaLYg7siJvbEP1im1jeBUdoAt+QyCG4LcsrfXeYi0tt2vzjF/cSRhMqRuOey20q8O9UqVQUkGWhGR14q9F92ANYi0meqJ3LaPLKmrYWZx3jf6gpAIx6oyypgkPaAaLa3ODdfyHGMHq+K+0/MVayfKKeXrHeH9mSYIETykZlxYEw+J1LjifRvKcKBW8H4hArRZfhJraz50D35CQTYitYjY8vjEG593VX9cY+Hlx+f2HGv+H7//mf+e77pN1sXtxql1mAa4592xziV0WwnbLmtsaEWvZHMSrmrS6/NYOEF2omifvdF3gGy6L7VVQK0U2OoNByLnu/p62Zqo467bX2RpONqzpKgg2dE9bxDrrmnOhbnM+Ma3TvznfGq9XXbWtMQDbcDdWqSHWSBMRW3Nm6/Vc0Zjr6m+dx2inrOw6aNeu5UsmoNmEtpblZyrO+dYgqi5pKaWhlO1OuGvyqW3FmM39ZzZhVHGqgvf20qTq2vVth/KkuRR12lyxT9y8PDlWl9e3WBR7mtpaYf88a23/TRn/P++P//kf/4/+j+9u+ts8LZSU1Ona3Lcaq+G26ASDbbmfawObNhGLzKTpEckz3fWBeNVzeN1zeHWleffGEmomGAi20sWIt1BNAlR0rC3zNmM0WzAvKrLXgqlJEdxUcDo20rKQJ43vKAjVwJIr57MwnjPzXNWRFgHniS6qK8c5XEnUZYRgERfBDdTiqViyaGSBd0K0lugDfe8ZjiparFQAZwxDBGsaEcYYsKIMm6rRIyU1p1TVOoORrDtkXWtELdRpIo9za1y1dM4i3kIX8FRScMihx1qDjZpzFjoVHtOSydWSjcP4irUqYCoCqOAKhCpEV+k7R9cfsfFKs45zZjGGWV4zyy9wuv817n/4ntM5kfqenCfc6YFiDGN/oJbMxx//mNsPJwqWYYDBWKQG3JSQcWIplhwjZTHQRVzVBlBTWx2kiSBDF47fjryvx+Pv//2//y+dc7drtl/OuUVaWBXkVoz3Lvu2otQtSaLCX1FhzNSKsQHTWa6urnh1c8PxeEWt0HWRYRiIXeTq6qq55BTzGULQzMycwXmsdaScmOaJ2nK5DYboI/G6I+fEPM1M46z37tagtCwLHz581Cy9knU7UZ13zgf6viMEz831NSKFeVYnoRSNs1nFAec8sVPRf21uWYvjK86vsuaQ6X06xrjNi6ZpIjeS0VYobs5A2xxDy7KQ2ry/lEJOCarWYmpXCTHQD32rHUPsOkUh7txRHz58AGM5VBUIwdDFjtCEzBU3uBb9vfc41yKXROdJDw8P3H/8yMcPHxnHEekrXd83B7bGOEgRfPTkUAg+qCPUrPeAzDiekSq8fvWam6trdTydTgyHw4Y4NGbj133rAPwaPf7wD//wX/Z9f7s61FZB6nm23HPxaf+z/b970WwvNq3NentM5B63ueZjriJ9jPFyPWoNgqtDd/2bPULzJUFv7+x77lR7CYO5F7NWkW/NGHwp83Bdt4jI5vpd1x97F9y6r9pkEDcH4Pr7VXzdi6XPxbj9Z786LV8SAZ8jS/eNdz8Jmbr/TPbb2+f37ef5+69VBH0JBfqS8Btj/MY0AHh1pZjWzaUT5AsWlJYzoSvC2pCCip8qLX+P5mqSBkpY05N0wXdxqIFk2Rbg+wWmMYqNMkZzLHLKraNTttwL08po1piWS1jbRbz1bDYHizr7WqHeewxCF3QfqkBxKHMew1Qqj9PEw+OECCxS6bzhuu/pj4OytX0gWHWvdH0kuHaB8B6qZnktRfMJq7GY1lFkrazJ8Vowt1rVFh8oJfF4npke0zb5XpJivpY5MZ7HtvhfxVGjRTJj6UPAWc3+MN42t5iFJvqpYKXlXleN/t4FncjbShcDUOj6iPNBw4dRJrDtAzZlzQ6MHm80e4dgGfqudTaUDaEImVx00YXxmDBhs8WWpIuPQ4QsSB83jjmr28i6BiE1DZEqW7edZJ0weQMWh826LectbuixUwLncMZRg0WGABWOh57TeUIMBOfAB1LjCD7OmW5IdOPI6aQLluBbd5UIxiRqteRsmZfMx/sTX3SecOsbPlbPVdu45pUvo4R0MLRiroA1glUdQYvFSMO2auHJVIug7FZjRJUPY6Bhao0oFq0lmVCrXrS9deR1ANV23tWyFax0TOjn6m2T7aVuaCpVdtrf3/0ksY8v5//Rc7cTAbenNSHwRQPUV+A+nwuDfd83RONXyyfPX/+TX7lVt9hOsNHutObwcxdBzDqvopLV84qGl5VFBQDbGhVi5+iHiPMR67wK12iuJ04wawMB2u1fk7SMPL8tcDXjFJzxG0KspMSUC9M0MZ1GzqdHLZw3LmnJhek8Mz2O5JwoKJKUGBQB5jyHrt3YLQgq5iu70iGyYizcJnDa5mQz7V/rgwqa3hOC3dB3zlnwzfHYsMSStWDpjFU3ahXNHCtCTgtkLbqUnFWYpOBNcxdHh7GR53AtuzZwNDqZkyb6yU64FYfximXpgopttRS8OIxrgkQtdC5gup5qhXLInDo4jwvGR2y4bkKiCjNLLjwcIjycGR/uNxHNAZxBmHB92M6datWFuZtzqdgqEEmMX2UCuvv3c2MOTeebppeH6N2Xnp1eeoU29FJ7/s+GAP26FSVf2k735vq/qK3oXEWvt2uTxeacWYu67mkGICtqI2VqUayu95XYe7rO44PHeq+YoHYVNs0d7NYmJBGkmjb+dYLsY2gFZIttSHRDJadMznk3/k96bTBKSci5MI6J6TSSl0w1zckTA8Z6nHMMvce71lhEBVkAR7Wu3R9swxuZ3fjXCbOzRu/5VtFHPijKqxrFEeMdxmpRoErV+VqjL6zjfxURckrU3MT/XJoTEkW4GwPR05s1W7Dh/GxteYwNIe4VWbpm09qW5WyMOgS9d3TB4w3UXAhVhcNNkHQeG4KKGIfEqTOMYwIXcDHo/FMKJUNKhYehx9w/Mp5HbR4zDl8qdZ6p2cDWEd3KRFUd/Otk1VijuKKvEAB/ngr+9Rsy/q+/+91/7r3b8Kxml8lnW66cutJ0arS69EzDRa4ZgLS1jvY/ms09WNu90GK3HLmLGCc7oU8bR9bCVM26CE3pKSZUdk65/V3RGkgtt6jK00UrO3zpigm9ZFnUyyS01rZmuGTrKRYJpOatGWi906ZFMArCRtq+setCllUpW4sP7TMpJTe6C1r0NNo4aLbFMm1ba7a8ac09bhNU1/11zm0C3yq+bfmMW7MasMtsXCMq1hy3FU9eqRsatFa5iJCsBJtLJ/9KMqitOLMWhvWzlQ1nrOdDc4k24dJ/BQL0b+r4/+t8/OPf/bX/ouaimXolN7xty3k0ba6IwVTbRGZ1qkMlp8QyTaTTSF6mRo4RXr3pubrpiUPExR7rLU6yUmqCJQaDR8glk9JMXiplMTjT03ceHw2OGSsVBKQ6KEqRyXPidD5z//HE6X4kl4o4i7GBtAgPDwv3X9wznyeKWGpn4dBjwxVddLw6eoZo6CMEMXg3Y5gooceYHmeCNrJYi3cQghCDYQhO1/xrs4PzOk/xDmyrqZgArnXeiWwniVlDlH3rgjRV2flppualZSdbIsLBaV3Cdp5jH0AKOVVKzWCau6pqk673jlyBmjGlQK4tt95i0Mz1Ywy4WvECIXuszfgqdFWwrqMOA8XDfO35eGW5/zhRQ084HMAUrCTyDONS+OG7N9g/+wu++NGPsK5H8HRikfsPpLMjdr3iUzcXeCv5r43xzU1+PHTfCoBfk8cv/dIv/fNLLm3ZxKxSiuLlWxOJiDYEOO81M1uEeZr5+OEjKS86Bqo6Wd+8fsPtJ7dcHa/oenXzXRp4tch/OAzNnX4pusfYcX19zdXhuJtDsDn4liWRc2KaJu5+dMdf/OCHnMeRCvRdJOfM+/fvmzBWORwO9F1P3/WKnut6Xr1+pT+PPVXqJbtLMvM8a43KOmKIrWivmaf7z2ZFeXZdx9XVkevrG2KIWGeZZ83yG8dJ/8Ya+r7neDxuzsfz+byhDzUrLGw5gquL5ijqXnR2pZg0R+a8MM0T51Gz99bPr+/6JjJGRat23fb5rxlrJRes0+zjNGW6LvDpp59ye3vL6fGRH/zgL/jxj+4I3nP96hrvte6ZSyLnzPl0JudELrk5GZ0eF8kwLdRXKBVBhHlJ+HARVauIxl2pYPCtA/Br8vit3/qt/3yP3twLQasg9VzweQlL+VwgfElk2gtce8FuFbVWt9+K+lz3ZxUBV8EvNDG967pNqFu/nuMxn+fo7fd/v9/PHY+rWBdjfCICrq+1bmPFph4Ohy0Ls2ti/SoIbk0D6n7bHID7a+56TVkRmi+5575K8HsJ67kX3p4fm/X97Zvy9s/ZP9b9/qpzQTNRn2Y0rsdifa3nQmAI35wGoJYB2BAHVifHpl4Qgs1u10SP1q0t69KsgHFaJNncfDsMi7Ft4WXIokKfg+YQrC0PAsxaJDMNR6c1sZaDATZYReO1fBmktrQXdVZtGB2ni2NnLZ13OGdw1tF1Ed86Qh0OTKEaQ8qJtGT6LoBAKoWrY8/x2BOda1jMSlib5ADTEKeK6lMHmaI8Ki6att9q8ZeaKdXg+gM1j4z3hfPDmfNpZpoWloLispyBnPE+UkzFRN+cKOoUSykzJ6GmhYf5jAuW43Wk814nLt7hvGt4sVaodo6aK8lVrFR1A2AIfcCawHA46LqaAq1z12LBeGxXsFvnayU6SzVBiw2rgtKyMVxQzIprYd6erIhBZ8EUiG4rIEjDhxlRmUxah5ZxFodpmSrqIC2lcHUcuHpzpCyF5XGiGuH61SvO6U7RZ73D2Iq0zJeIw9OTKrjo8F1HlUSahc4LKc38OBVml8gN8xOcYxkTZUkQnDqVsnYY/vD9ieMxcjMELYhW/bmplSKFsl7UTCvqVKM/L4KrOpZkdTQ1iaSapr01D+v6GkYU11mqFquc1XJ9rZBWlXuLmal4C3ldqBh9ddnXlWptGUo6BqytmpepntXLE/dqwu0Lwt9L7sBnBr+7/b8vpP7pn/RwO11e7rlzEJim6UUR5fb2aa7g7W73Xr9reawlbQLTptkUNDRuJ/7ZVqhbnyNJUZPiwob9DEGRmdZq/ga5KYPOaSeY1WK4SFbZK6vwYGObWPtAraVNPiu5wpIy87iQloV5SizTwjgDLuK9okCyLEiA/o3iQfMykZdELjAvIyXDI4nQHRgGTwwdzha8gPi1rqcuNWcVbbo6EhC0kOE0fNtEr++nLRBkXxgyK+Kr4LzZuuZpiFtDxSRDFr0oOm/xQB+DFv6ApRSMdSqeW6td+IDU0iBbKvRZCk60279IafkmRd9D1yNYrPXandxFFS2N6CKuCD5oVonPFne0DM4jFfww4LqIlEwaF+Ys9KHDU/hiVNTQ4gKxJJY0PUsAelqe1V8W8qom+0DJ6Xni5F9JA9z09d34SjsJb/pLCeEviXqpvX7g9plY+bNmE/51FA3/MtsyN8d/Gg/d76xF6lZr3pqL1jxjPW/tmt+2ltIbISAjKSMmYKPFxUCIDusUTW2asIg1ivFsVIJS1cFmjWZtWgMmKKqyC267TpeiDS8pFaZt/Os1YJoN+KhCo3HarBIswyuvhbMlk3Im18IyZUTg8V4ROl0X6LqgQqSIdvu2cWtbJlBZ7+mteL3hS73DeA9+vc65jcSwJtJaoy7f4DW7bBv/mIbsNFvWsw+Gkitd51lZESZr7p9txUVpDWIizUWkvVGYhgdU91UjQ+iECmcb1cA0cbKPhKACZcmLdm4Hnfu4bPHVcHCL5vsOPa4L1FJYpsSyFGIX8VX48TJjfSQbRxRhKeqyd3XFPO6msGu6YbufApsA+PNUnP8mokLdd7/7T4fXr357L/6tIpIWbOzWuKVzqhX96za5xzYspC6Q9WK/XjdWcbAKFCMbCUWFtdKy+tRtVkpRJGW7+NiWq1dpglWtm3NdasXVyyL/0m2r535t6EttRimbAHjphKUtvuXJemvr2DVW58VFX0cFTKWjqKio18jVJbe65rb/td85uy9+GFJqGYTts865bH9f5OL+0zmC3vNX/PBa2KjPbrKrw7BuuCUt2tJyEzFPMx1BRbwVKerWY+C9NkOhjW5CxVpd+IsxiJQN/ZpTfioUt8xFhC1TW2k26zq0XhoDjMFHzQD7mzb+v26P3/3bv/RHv/YLn/xWSbll67aemGq2/Mxq7ObKWaMWxCiCN5dMGmfS45nsrgjXHfFmoB/UqWaNxZSk2FAPrtdmIHXAqgBYC5RFMMWpMDhYYqfNrSXDPCdSNswpcX4sjKeZ8Zx5PFnG5UjtI/HQ4YxnMQnLyOu+g7wwPY4s88womccPH3iohjtOHA9Hbq473ry6YoiGmgv1ULF2wTt1vjgJuKKRKbYKVgRvDD54TPCYvtMB2JzDxmj+GM6ALTrnqe5yI7QWgs4ZaA171WiTad9bbYAWR02tEbGJHxjL4iq56HVUl8mVVEXnDzljq14/UhFyKRtxvx8GoCc6r/ShvqPvPYaCpLlFoLToFttxuDa88ZGCwV8fsb06jqaHiXkxHI5HQkr86/sPhKFj9h1DToxLRyqJ0vCwNDeyaY1krHNAp/OjQx8O35be//ofn3/++T998+bN7+zdGqad4yKtcbXN+1NKGofR7gdVKtM8s8yL5ue25t1Xr17z5s0b3rx+TdcNgBa919e8FPFju5+31zaW2AWOxwM3Nzc4a0kpMS8aO7MsC/MyM40j59OZcZqYFxXsDs1NU0ppgty1iuMpaUagVM7jyMPDAz+6+xGvX7/i9es39H3f5sh1cwqa9p6ts09EhQ37VyshRg6HA845uq7b3DxrZrLzflsnGaPuHxUHVPTcF/onJgZrGAYVKRVzOgO0bD2/NdykJbX5j2Yxdi27cOgH3Yc2H1nRrUtcCDFgjKXresJRxRPnnX5+80xsouHNzQ3D4cDhMHB+PPOdzz7jzdu3iAgfP37kdD6pWeN+bjELFh+gmkjKiVKFeZ5IKTdUbCKlRAh+w4Ov849vHYBfj8ff+3t/7z//7ne/+/fX/Lq9Q26f5fiSOLR3k30VFvI5WnKPily3sRcFV4zm+hxFAJsNJ7uKfmt+6N4BuBfDnotfe5Hvq4TA53jLVZALIWwi4JfiDHbuvdXV1/f9lp26R5IOw4AxhsPhwOFw2K4Za9bq+vnnnLevvUtyLwI+FwKflNp21/H9sVobCzaUcfv7vdtzFWH317398Xzu/lvf4+oAXF9/j4L90jxaRdBvjgC4Jf9tAh6X3JN6wRYqBalSKQ2p4ZoLr7maam0ZV+ukyWz5DdrVhbr8uCBjqmn5WwpIJNeW4bcbZM4p9kprzdLodLZhPhRSWlqBzq65HWvZuxSGbsC50DrmCzEEsjhKqUTnwaQ2abAcb66wxrCIZlm5/SBAC16ldZ7mkrSTsAXX6+/B1gTGkiRTBeZSOX/4Mef7E6dRGeRiPdZ4wnVkOPRIEyLmOdO/PnIlgxbsjWI1zvNCWhLeGMY0cT4vnMdMiaJOBbHUVMFkfMsTQlBhbG3Ya8UAkmA7Sy1JJ+zRUoxmES7LTDAVv4oJosX/mgtzzthi8L0ijYpUnawnIRqLWEsyhYxgQ0Od5UoptS3KgGKQUihFxTR1F6i7IjvbOrUrOasf4P5h1ABha+iOPaVUHt5/BFmxTbrICG3CIknZvcWii6DOI9kpuz8IvgTeOcfh2PE4L3p+ooHK78OJ8zKTi6j7yFqmnPhwP3K1OoMalrWaXXfk7saSNxej2SHVNrJR45Fvt6iti7yuBVAquRVRvLUUoystFbUUJ1px5GoUw9tGzsbWbe5Y0/hG63bLeuHbusTr1p32TKv7skqw/1dluovYd/fsz+5edv/dtb97Qgq9vdv/8ukLfUmheFmyeHsLwe2EvqKijN1rYav457zGuaHuU1gpNhlZEtYN2MHjOtccdEGbIqo08SpgseQCpSz4oIhMxeaog8YakDyzGL3pzXNiGidyVbTvOM88Pp6Y5gWLw/tIiD0ZgVywvm9df3peOmMpaWacJx6/eGBZMmmB83wmlcAhaj5eDQVpa3QLlIb6NNaREfyaX1FEhTdrVRhp+K9SCjZbbUSwF/dUlaJZl645c3xoWDHt5ncxqDZaFX9qNoSn3YXLWnISUlZRz8LmyBHRsHXTRd1WLi1XoBXjxoUlOGIccFZzi/oh0kWvDkYvOj6cg9gRuw5pOQPOgvWG6juy9fglY11G6hUyFyiZDEhpzo0pMWfwsXnndohY2d6J7pv1sKl//UWl+/dh/pua8BcCpKSvfzs1Ab0hQV+M0fwpIuPPIlD+vGSChdvX/8JpwMWG+BShFbSa+GcbetK6rYBvnGkCoObwUrSb3EWPb5m0em+wDZlbcS5ijNWO/bLgg855VtHIOi2GlbyQjM5D5nlhnCZK0WaNcZo5nUbmadFMvBgJMZKrgAg2dgzHgT765uaHkhamaeHh/SNLWlRInCZSu7dG76hBdH7kPBZBGo56FQkM6u4Rq7knVS6FkVx0/JdsqLZlJSFtCiiU0jKVK1jvkVyfjP/ULrO2ZGzDihpjCO1+TtXcsFUsMEaRRSnpWLfOEqPXeVxqTUHtxChzYnEjseuw1lCyjv/YNcqCr5fxHzpqF+lKpSxJ65jOUZ0nGE9wBZsSVQ6UlKEUEit5AMo4kaSQRDTn2OwXirQsqVUAtFdfdwdd/Zrtz/8/tnX9y3/rf+V98Nvcpi0Ca0Ox70PfvbebS88Y8D5sx3Z19a1Cj8E8wU2ui8dSq6JGWOko2t2uIqDZOn4Bcqlbmnre7ccqPK5ZnrU1LC4p49u+rzfAbTHf9m0VMq1trtr2hTHUJxkcl0VxLnnLoL5s3eCcIHLJ9Kwt29A8m9Pu8/7W970uukWkOaDZnIKmrfVEpNFkFJu8Lf6fd+e2awmN2qKY40ve30q0WFHGl4JAbXmLl/1iK4qsHSCVsuvqveSoWEqpO/xx24w1SLnkGlpjEaONqZfChOZOfZPH/8/L45//we/+N733Ps3T6uFt97eGbDMWcR7rGzraqPinLlZIuZLOEzLO+O4N/tAT+tBcol7XeyXpvdn11GJZirDIrKhgMQTj8VbrDzUIps7kGeacOZ/PPDyOTMmxiOM0Jn70o3seHxecHxiOV3TX12Crjv/rA6++8ylXnaVKoqSFdH7g8XTiR3/yBfM8cp4KHz/eM47XpMXy+hgpfSaVivWB3hfM4YBNegYEr83KkhfIFhPaBNb5XZckukBvDQXGtWy/0tpUjYritAYKjHaomk4Lnj5l+iJIhOQqnbNUq+vhnJQWMM9aFDRYlmVmWRQbaEzFR20WyKMWEIuoC2+KI1N3ZjgcNbPs0JOOgeHgdH5kBcek4zY6TLji6spAFoLV5iDxHbPpmWfBphn5zi15XiDNzMpA12v3+w+cU2KUyk21WyNEC2rXaI5Gsro69K++Lb//9T9+/dd//X/pnHNr0Xb7t93/nPdboXfFf+4LyM4qHth6j1QhdgNv3rzh5uaGw+FIjHH7u0umn3nictm7X4a+3zKFRYQlJT5+/Mg4nlmWxOPpxBdffMHjwwPTPOO8unSqVJakjX03N9e8fvWa49WRGDVP7OHhkR/96EeM08QyzTyeHsm5cHNzRd9rYZ5aX8w3e+5usq04HkKA1py0NiFpETw3F6ElJUWMdvEidq4F9nmeqRXG8cw0TU+wecGH7bOp7bWnaWJeFqsy/NwAAQAASURBVEopzA0fmlLiMAxcv1IH4iqS5qR1k/v7e4oUuq6nChyGntevX/P6zWuur67o+44qKk7c3Lzi3bt3fO973+PuR3eIFI7HozZxNlFY92Pm8TxpwyZKRalOa4TjOPLhw4dN1NE8NxUgLxnPBu/9twLg1+DxD//hP/wXpRS3ZuztRaa9SPeS+PfTvn8uFO7Fqv2/qwi2vxbEqDmfqwgoG5bebWLcXvx7Pm732Mq9aLaKVHthay8Q7vdpL/rvUaD7jMO9K3h19W05o6Vs36+ZeOtzvgoBuroFU0rM87y5C5/XyZ8fi72Qt/+8N/ft7ufqpF6256/bU63IMQzDExfj80zHlxyAa1TDKgTumyb2+7d+dV33jRn/fkV9qlekbt3em5vvYlnSvDouuB1sgSqEYBo+UdbAGFiTzVoxxbRF24aprJDFqnsK2bLQSpGGAzVY3/K0ijrPastoN86qy6zhFqWCFc1E0y5PjXGPRrvxfGcgVTBNDGqC1JwLeSpkKl3nCKVgOs+hIcBsFVzL8tPqnm4xtwKxaTw6IwXIlEVdQGTLdF74+DDyeFqw0TF0PfQD82niw/sPGAz9coAPJ4YYmObMnBY++4VfoKuLZv1liFYX2d6oaHF9PDKEyOO0cD6Pqt7HSmld/yKCR/O6MJpngzXaASgWsYIUy5wTwQhVAqkaXE74BYr3anaymqODEQTXcEoFKYrxkZx10WMrklRcMKVgRF11qVRqMZRcmOes3cdUSk5aYjEe4xyuCxjvMFIJLVS06yCGwMPHR07nCRsc52mCAuHecX3sGa57DVQ3TgWvhiCyzjQ3hGsWA8Ox88y5cE4Z2/f4WglJoLm0QvC8uTkwnB3348xZBLJgxfA4JkqpqoGIaLAwFmcVh2ispZasC8JaqcbqWdliFUzdZGvNgGwIoioqetO6xOuuE0XWTjZTWKp2c0mpa6lVX09UEPetg1rWDuX1JmbqxYViKrY20ae5ELdKzE9SA74k/jXFY3MHTrvfr0rFU7Hu9ie8+OoCfLKJzRq427G7L1sCb+/uuP3er+x+eHEAqutPs8/WTD/Lmpfndt0ml25TnF7OwOH8BZ25KkEiAs4iWbAk5gKdC4COF0FYlkwZWz5dFsZ5ZpmWhvgMzFl4/3Dm8WEEAvFQOOSCA+aP9xQ8r99cU677tpiB49BxPHYEesoygYVxXvjw4cRccttnjQpR1CzETrNXaXjNvDoUbcLaACI4qYonc4WSLc5U8FBtxbeCqLMeTMWi4l4qiZU0m6UqLtAqqnDFYzYDArXo9yUrKiSli0iZsn7uIThCF7Ex4q1lvWRZa5EMtWrGQLWFhcL4MHL6YaEbHP21dg32Vz2hdXpXKzp2jgNGREXQKngf1KnuLMZ7MpZlmYhL0e5PB485AYlcQtPTPaZ9uHqOZHUiAtYFHOlLxru/qrPuqwS9APTTxLQT/176m5+8zfTsFX8+i/0vPfpXx9/fCn/IJa92RYO3EHnNBLmEuK+l+dLw3NoAVTfEnWuYQOtMc0s395dV8cqQWUoi+KAoLae+obwkyqi5wDkXpmlhntv4d4E5F764P3M+jWAc3dAxLJqpPN6fqNVy8+aKcjVQ0SyywxA5XHU4G5B5oRqYl4n3H84sKbdreiVUgymt8y+YVoRXd31u+YjOaRMOVieyqYpmOWdDMZXqzZblo8g+27LLdHGTclm55CRpuEBbqEbdeomiaOtWmK9SKamy5EROmseJ0c9GSiVGj4tRcePWYPompLYO7SpCyYlqC6lWpvuJxx8l+t7TXw30x57h0CvdAY26FSr20GmDWMmYarTYYXX8ExwZQ5oXYsqNHmE4iS4gc8sXXAUMVnx21ZyYdk5dfZ3Gwf8vr/vzPP5vPvv0H29OPqvzwNKceRi25j0VbX3DVV3oB7rIW8PfZRMPgXbs955YXQuZJqpvYp2oqLCaZOs6z9u2su/KNdvaSVoBylrTiowGMWXbj5Rzyy5kQ9JdUKW7HLzW0KXfl62JzjRcXd0hPFdnYymZWrWYRxVE7K57eiegrZPEtqRzzrasH/2c97kkWyORveQKrc4ZaRmMe1wQq9vAukalaI1HW4ai3VyAK0KsSstOl7IVLvVYtWt7lTZXVme2WDYRds01XfGqxm7L2kb3qBehtAmPsqFEG6a5NZiuDsBvwvj/eX78g9/8pX9IrepIbzm71XiMV+SsGKN53z6uqCGkkYVKEXV5zKWJ1IKTgjWxzRGKCgg1ICVTsZTqmfNCms5YL/ThSOcCtisUqUzLzPS4sCyJaVq4vz9xOk+YcIUdXvOwOP70/cQPf/QeGw7cvBZeJ0Oslfsf3JGK43t/61Nu316R80jJiVdXAzdvjoQ6kB8+Us0bHs4P/NmPZu7PJ6wt1FJJeSHGA/YAfd8hEhBxZHEsSyH5mRIrvrOYGlC+f+USJG71Z+TWAKmRI+qoLYrvFqUFEVp3kott7S3YLNRcWpFGCzVlEaZT5nE8czrNlApiK/OUKKlFLVxFXO/ojIG+YlxtWeVKVkk5UXxiMYbH92fe/7uJ42A5vjkw3PRcv76mN5CpFJn12no8UqRSZcHWQggDxllEAqbvSC4wnx4p40QuBe8s70tBJJOqfuWi10Tfetsl59ao4Bj6+C0C9Gvw+N73vvcHz/OavPcbsm7t2Fh/9jRLS+s+wXtqUsy9acX74/Gg+LxOUZRrflc/DEgrcp/P560ovhb1wXA+n1nmGRHRBoCHR1JWMeDh8ZG/+Isf8uMvvmCeF6w1XF8dSUviz//sBxyPV3xy+xbTXIVd3/HmzRsOhyNXV1dM00wInoeHB/78z/6MlDI+ZKyzpJKJrWDPllVr1A1d6i4f8IJEpcL5nLXB0WrtUPGYOmfwzb1Ha67MDVHunMNZxzD0Txqk1kL8KorkUpjHkXEcGc/nZhy5zAPevHnD69evOR6PhFZ8VwKH4plPpxN3P/4x8zTz8PjIv/437zmfz/ytX/pFvvu97/Lq1Svevn3L0A9brmHXdRwPB87ns84vnMO/ebPN/9SdpEJnyekyV6iWZUk83N9rfqJ9ilBcSQXANwoB+PP8+OVf/uX/eEV/bg1pz7L/nmMfL7W/i9PsufC3z3vbC4PP3WurqOec28bG+trPXWWXRkS/fT3PGXzuhlvH0bovq7Nuza1bBb29C3Ev/j3PAnxJEFuvbSGEzdn3+PhIKYVxHLf345zbMKH7cbGOqdIwx0+zz8uLourz4/Hc3fdcZH3psYqN0zQxTdOl+SAEXr16xfX19ba/e/zpSyLg2sCxbn8VWV9CvtZaiTF+gxyA60FA2IKjtjctVOO2wnqlOfrW/DMjKtDJ0opmq0ihbkBqafx9XcTV0jo3NVhhC1d1zeGnbijFIkrDy1VjSGm5ZDugosrauam5hLp89M4p3s4Z+ugZolN8BIZqNSReHVOFJSddyAfDELtW9MkEP7SDX/Am6CLRNBFGBLEtIyppTlQwWnzMrTv49GHk/DizUMlYhiHSXx2gi4zvH/nw8SN/8ad3FGPwztNH2zpmVLCZH2ecb+8fw+FVzy/9wnfIKTPOE69tx3DV48NE8IHzODEtiS747QS3WVTNsHrMnFEBKzt14FQBZzTIu7Qun+odtRZkrkw5YSvELmCa3R+jCMHSeOkiBVutughlIc+FPGtXf8naAb2UwjItpLRsrj/rLIJiM8N6PLIQrVEjl4UuBrxz3H72VnGx2orIeEpIqdw/nhjnhS4Gjm8Geuc0wwkw3lGxW+eiFD3eHsv1MTAUWBCunGGcFh6nBLngXMOGTgZfDWedIzIuCz/+cObtq67Vl82GTiq1to5lB3VZEw23IrQ0gdoah6ui+BktVW/O2vWetJ7viNCiaBQD6mv7G98QZKZJ8boGu1Rotqtr2wfZ6jdOT4S1vRu3K1b9VCvR7U/+2UWImFZt7ole9yVxY+/4u31hE7e3LwokT19P/VCHOOgClp2It4ocLlx+Zt2WPbddzGWrDGIHZfvb4DaRUGsHbgt/LiWpGw7LOGaMK7ghEJxHaiYnRV+M48S0FEoTy21wGFSMnuaFxzHzox8+MLX3EPrb/y97fxZrWZbm92G/Ne3hTHeIG2NG5VBZY3dXVzV7ENhWCxTZZEsiKRqQZVgQ/SDALxYpEjYM0DYMGIb9YD/5RbYFAX7wm2DABiz5wTBAGhbEpicOPVZVV1blFJkx3Rv33jPuYQ1++Nbe58TNyOoqDlkDcwOBiLjD2efsvdfea33/7//741wFfUPfwNVqyaR2LHcrLBW3jiccHZ8wnRbMj04onOY4dMzqgqcXKzI1U9oSjNx9ozfoPP6DNygCfTSoCDYO+L2IQrr3vVEYXZJiwLf90N2AsYdMchHUQpSFQPS9iNb5/76XXKAUIn0vGOfoA10XaLYdza4B0+fzUlFUJmesFBmtqHNBUEsIeG3xXZTsEJOFuDbS654QO5pdoOvX9CEymUlOi6C/gOjRriAlS9+2JN+ilaa2WpCkE0frNJ1u6bsOHS1xPoGuH12iEY+Og+DHXijWBmPsvoH6QPo7/2cQAV+6wB/u9TqH5ACeZeffYY7fp+/nh2X9uX/29/hTUIjU9279D11h7x46sVNiFJDUmIM64BzYO0hI4vSIkLRGl4KV0c6MxWRtFMaIgCgF9OyGVYqm6TAmiSDsjGDLe0F77nYtbefxSSQ8rW3OtpNGmG3TcX55Tds1WFdI6P3QRNLD1WrFZFqy2qyxSnN8tOD4ZMG0LpkdHVFaQ4o908maZxdX0i0fElFJ842yWTwjSDbs0B2s5JlstRRMU5AbQUgQvCZoeY+h8/l4inAqQzOX5/MxCCGPfyUdcmEY/z4QQxSBL0rmc9d5wfU0jeDljUUpm8d4zksUtVHwglo6Eq0x+D4QYgE6ZwO3AZ8XFrump+vFWVhPK8yQ85wAHdHWkmxB33SkvsEoTeWkqKkmJa0zdE1L33o5v5MKOi95y9lFabKbaGj+ifnZoLWe/TSMh5/Wgv9n8b6qr3317xRVdUcPmNkUR2e7GpGRubFRSxSBsSbP39T49XHOPGb7mX3eXS5+SSOXOAtkmbQvYg370iPKdu/W83lxLfmbeuysPxQED9GlIUSKQq5hm5tNvA8H3eeM+NIQBXGZkmCKoxpID3kaOZIesoyZT0oYsuyUkDx6fEZsZnxpYsx/FxQwoxDqvc+5qTEXJMKYrbS/B+c1H3owCmVEp3opLzullB1/HBRryLEQB40cqDG+YWhcM0ZngTNxwNrImax75IbJc4pRMR3FUrlHyhorvXS9qpEhzZixOKRkxExGsNZUn4//n+z23/zt3/g7D24t7uK9FHCzqquM5F8nnduVrZP55dj0KHlZfRfod55oHfZ4SlkU6Mrtr0Ud0KqnqqbEYPH9hphKupjY7Xq07XHFHIoKCOyWL7i6XHN9tWK5adj5hFcW7AxLTWojV6uOZ1cN333/Ecv1C8pqwWJ2RGU1qg+EHXzw5DGL44rHzx8z0QUP793m/mv3uH084fTB6xTac7tbMps8470nl+yaFhNkDR37RGEMvumlYdgYYrAEnfAh0YdIkSJKFFCJ6AgdKVmUclKv6XtCE4iSf7LHYbqcgZ680C9SApfDvIMntjtCL4Sjrvd0XWC3bdmsWq6uLrleXhIIYEtQU4rKYaZWcretIyRpKNc2UbkCoxx9l9Cxx9Qivnuj6SN0MdCvPet2R9tHFsHjygKlRexVoSMZQ68dYbtD+ZainDArCqyx2JMZu0nBdrWm37ZYEjpG9HaHtgrPgJPLLiYFsQ+yljSGSfk5AvQnvX3zl3/5fzydTu8NThvvPdZZ+q5/KQdwKLAPRXAgF453oBST6QS12+GcYz6fS1NpWY2ovrIsxyJ3yg7D7XZL13XM57MRsbfb7Wh2gvUcCuLBe7pe8ucG0fD82XPeeed9trsrjo5OmUwqQtPz7PI5AO98H77+1V+Q10mRL739RV578IDZbMa9e/eoqwofPMdHR3z88cf4XGQPXjIAy7IUkXIQq3Lets5ihXOZfBAF17ndbul9z3Q6JUZxwQ2fT4Q+jc84U3HYS3O74EtfpiwMjpnhOA9Ov91ux3qzIWYyg7OO2fGM2XxGUZaYjOj23mON5KNVZYm1OYcsRvquY3lnxYvLS9q25fz5c66vrtjtdty9cweX1wzSAOk4vXVKjInNZpOdx1IHctYxm03ZNTs2fZfjrYSaFYI4MXfbLVVVj7lyIlAINSGLOJ+P/5/w9ju/8zt/ZzKZ3N1sNp/ImruZN/cq99lNp9nhvPRQODx04x0KSIM4dRMPevgeDl1jN11nh+LfTbHyUAAc9j0IU1120Q5ut7IsX+n6OxQBD783rEcOxcvRwVzXHB8fY60dRbVhX4NAeJgpWBTF+Dp933/CKfkq9OdN4W8Q826eu8NzdCjuDl8fjutwTAbxb71ec5gJ+alO6OxePIwnuJn9N4iYN4XjqqoWPy/jyI66Qc6KOaDOjrJfDpNCkHiCppROV5EavM8C21AwMTaj3EJeTNm8pgo5XJ1ckJdOvRQDMSi0kX35sOfSq5TztvLCVHJjvKAltckw+piZ15JRUzlH4RzWyYWdgoT46YwFwSpMSOhS8gHKqpBu9CH3x2X8V9qjE2PXi0CWiwgpJJQO+Oyo6nrP1cWKddNiywJbTlAxUExKltdbXlx8TO8969UanwWgpt/RtomUhm47UHotuVZBcHzVdsv6quHhW6/x1le+KMLVekv35ILFzFGVBVebNW0XsEahhJ8pLqZCozJCM1iFwew7YoP06UUVsX1P6C07FShiAi+db15FUt+jTD43Orsmmk5cDn0u/KWEj4E+BiKaLga6IBlGIUSCUvShI/mhG9hgnAKriaEn9JGdtsS+xzqDii02Lzys1ZSFwRWGwhqqxYS23dLuAm0f6Z4uKUtDfTSlHBZwKUkuQi6AhCTOVTToFCkriy20IBjKgl1haUOgKDzKasxSo5uOEKSQ60OkbQNFYVA6UqFYdbmAoJOImLlbcshhQiVUUpkgknJxKhFjxtOhB3nwwPodsxAujhOrNUYnLIlgDEpret8zBlzlMRvVvmM9RXFa7jNU9oWCNDyIkhp7239kUeLsU77OJ/P8zs7Osgj4yV8c9b8bv7N/jfNPGP5etd/Th2foAfEZIOJexn5mcc8aiyagMGLEE2IgkYCOBluAtiXKGGzOxBqSdWLsMegxP6TrWgIiMoVdR2JHJtkS2h279ZrdtsUb8AMEMwYigbYJXF9esdqK+AfQnDP+ezhSq/OXD/nyDG5v3uLWyZziQUk5naGiZWost3XBZrOj2W7pgmD4qAw652hYZz6BPBWerGToaSVjw3dQGk3fijDQ9hFjpJPYAy2SMRazgOz7nuh7AoObJ9J3Pb2PtD7Sx0DyknvgAzTB4+mhQ9yYBnwMbHYd7DoR3LIga7X8KU2B0uCsoZyW8rxAU0zLLHBpiDHnqbZU1dAYITlksW2x2tBH6LsGZzTaWAoNprQ4BbtowBuiK6i0IZpWkGnyToR6JDXf7EsQccSajDH9F/RQ7jNS1Dn5qOICnGfh7kfZa/+nfN39zBUgb+6rOJn/VS2tm2Nu2yDeqUyf1LlxRw0l6XyfHJ4JJCXPAafQxkoTU25QkUWyH/O4tFKEvpHnfZTFbUyaGDUqRXyzY7fZ0Ow6glb0aJKyQE9Ska7tWV5fs15v8H1HSoqma+l2K2yvWMdIVSbUDrgSfLayltVux6ZpOD1e4IqCclJjkmVqDGfasN60tLsG74MICdqgg6A7rVUZX5on5NndkjISXCkpfHkFhdH0TSt5YL3Mp6rK4XNgn7GKkAURGf+ewJDFOaA/Ep2P9EFEyb7z+Bhoey/OuhCxFGAVPnq2m8R22xLTvgHGGIXTikI7tJLzU04KyR5UBjeppfEs5xdtcp5yVRfU01oWOCkS227MPOm7No9/Q2mU5Lwq2EYP3hOdJamKqDuZ33BwLeXC/75jJmGMrj4v+P9kx//itdf+6oCmTDE36wyL5ty0LvN9lXNvTRa+8iI8O88OF/KD02twEI7SVxSxasi7i2LYE1HRSIHNimIlr20NKUYRFQbhz0gTlrVmnz+X53zWmhFFuhfYwihs9X3KhE3Jx9ZaRDFxC6px7DtrCSrmRWvIlAmkqz+7BGMI+R6YRrFyyO5L2fFGzkdNcehOjuP8cfBDxhDGLPdBTBuweeOx1mr8HZ3nvbKffYHAHHTnaj0kbqpR/BvETms0MQuOzlpxAWZH9riC1WZcs+0X/9Ikul/byr1pn3koYsaYM5Jx0krtJ85D4ZLceKq1mXw+/n+y27/6K1/+KzIGhtMvDStRCZUmkVDa5ftCFvS1NBwHrNQNtMXOpthKnD9kQT+m7GBRkS56nJUi9Xb1HG9rood2u0WbNSk5VJ/YrHouzy+4umrYYFjj6LHoPtI1Pevliqcff8THT56y2+zwoWC3XrO+/Bi72fLUw+kC9IVMNru2wJVHfHx5wZtXV7z58AG/+NUvMjm9hWlLTo3D65IX65Z+vWPjPSEaihpc06GNoiyksTgmQ0hK/kTQSdYl0sAdIcgcJXY93aqj34ib0jgj9yiTchyKEDRSiqgk2FN8L7EH7Za29ey6xK6NdE2kaQJb33HdNmz7HakP2HKKKhON39Fd9bDc0Ued6zkyR51aTUmJ1paidhS9xWiFSRo7K0laoldCVFwte7a7F8xmNbOTOWXGCevOSz5ogr7bUJpIXUworGI6K9kVmms8K+9JTMAa4nIl6xmlpFFJ7+8BKQaSAK+o3OcC4E96e+3hw3/rMGtqEJ201lRV9VJhue97tNIjwrOu6xHXPZvNmE6nzBci/h0tjjJyXo/PEVcUGGNommZ05QwFcoWiqms26zXPnj/j/PxidMIMCO62abh48YJ3vvfOS5/h+voF19dwm+OXvv7Bdx+z4RKA9W7HZrPh9EScbsfHRxSx4O69exRFwWq1YrVe0feeRIu1jq7rxwgBaVaXdcFh4XvItmzbdsQWdl3Hcrnk+voa73vKUpCmWiv8fMFsPkUpJTjPtmUymYyF8gH3d1isH5yEAEUpr2+NxVhD73uur5eSw9pJFiN5XjaIGt4HrBPnkXMFs+mMuqqFYBAjza7h2ZOn7LZbzs7OOD45psq/a4zBGsVWKdbrNev1huADrhCht+tauT5UHKkMysj8R/Kd9YgHHISCQQw0xnw+/n/C2y/90i/95cNr7lUC4E3B6FDoO/z6p/3+vqltLwIeNvDdzO07RFne/NnDBrNXORJvbjeFxeHeNgiBg6N5uE8d5vYNjr5DkfHw70Oh8lD8qqqK+XxOWZYSM5KbK4bXm06nLzmJh3vuYb7eTRH0VZ/9ptB62EhwUywdjvvQ5NHnhorDvL5BsBxe68WLFyO6+aYI+ir33/A6h7mHrxIOh89kra1+XsaRHYBYKcWXFr0vn7kb4e2jmygLcERxWg0r2+Fk5u6wpPNiF0G7DNqFQoQ8WeslUhyEFJlpCXIm5DwqwYTGEMecKpKXCSxK8q5iwppEXTuKwlIUJjsGowR5o9FWQuBd5QgoyVuyltIVWKOIWqygfYgUzmBMRlHlxe4gcvo44Pci26bj4uKKqDT1fE5VSfH6w48ueP+DJzigbT1N8Ox2jSDzQHBiUQRAj3xOkxRKF/jgUV6W3k2/Qn//fUwMvP2VhzQ+gDYEwDqY1xNWcUvvvbgBbEIHKJVGO0unoFAifAQMBnE0KaWxRPrkMV2L9xICXmYuduzFMiThvBrlAz7K4OuTyt1HwjrvfU/nofOyaPJeuugDIXcOS/FVY/ApEXsRAPreC5LQWJxVVGUxXj/ayEItRhH0CqWoJiU4y9G0zpkuPavtjvWuYzapmRxNJJ/NDwt8Kd8nnW29SXBFMecydW0n+E6t0dZijaGsC0KATkHoPTsfKftIWUrxpvWRbSsLjKQO1Itc0FE5Wz3mYkaMsvg0yqCULEajlpwDnfPhtBKUrUoxF0MTUSVM0hijUCEe3CyDFITIeX/Z9UDa5/6l3AKv9mS87JhNBPWKUf7DgsU+9euvCEC7aS86zy88oD7P9l96tdC4f4FPcyqdA18/Pc1jaP/1KDe0LALaUSBUWVgaMh+1hagNfnhAWIMrCsEGxYDGCP4pakmAixEfI6kPhJiRfhG2V9fsjNjk+21H160o6jnFdEb0gc1qxfryGW0Pyx6a5vzl43xglzzjpTg5Hp7Bo3MRSp/zLlfbMzDQp57U9VhrKEpLMT1leWnYXO/ogic2AU+gqAwxBorsAhb1WxMjGKdHJBghYqLHG432gWSyJV5buhCQmqSX601p0IYUvSw4jGCCQ4iEFOk7ER6C35+YEEPOZHTCKTWw6xribrhfZH43jsIOkFtwOLAithW1xRgRAdGgnZyvoshZiRHWmy0hIcekLrBKHEQ6j/82gBuzOzXWWKCVfSC5oZ23kmWWhWKZfAjeebi2IuIW3fbNKKP1rxC4/2m24XcfHmh0DqCqaJo+/++Huft+vP38LBT6X7mVxVeLafVNyZgYCuW5iGz2xfsh/+Fw/OfwB8nxVYK71dZQOCfOgaySD2vXmKs+IUSCD/Lc1IYUFJvrJTu9gwR909G1O1w9wc2mxC6wWW9YX17S9pFNgKbdEvseow3WFNlN5OlsSZEMhQYfOqI21KVl5xvWbYs/v2C1WqMUki3c97icH3Ja1yyvV2yXW/reE5Un9B5XOLyKgvNMWQJVRgqARuVCd8q5ywGvWzpvSEPHtNb0XlB7KXl5xGkl4z8EeW5rK8ckimjR+5j/nfbZehlFpJVGWQdG0bQtfid4LxEnDFYZEemIGGUweY5kHLhSOvcF7SrZPq50FM7muWFivW4IUagFRSXjP/ReWABK04aEU2l8LhqTm6G0xljJAok+QtvlfKE8/jPzOGXHVXYg1VjzOj588LNY8E8/4+NfzWdfnxwffXN0a2UhaCAzmJxVpQ6y41R+1qsx3zG9EuczCHspDQLWy4v/ESUYDrt8ZRwVhRWiidYYZ/fiX34vIvSJU1AbEQmtdSLGZ/FvfH9Kvp+swZqQXTU+Z9nElxbMQ6cqWuZ7ztnRnTfGNQzz0OxqIwm1RGsNyYpreOwU20c/pOyyIyUR9kIQhHfGpu6xP/nsZbx9yjntyugxN9CYIbk6i6765eJB8MNaI42ODj1i29JLuLEUU44l0y91E6csoA6/JxP0nEs4Fib2P78vAMm83GTcvtKHs+NDp6bBOlsznb7BZvP+vwzj/6eu+H/75Gu/9PbDX5HrOgBamomBqFLO5TYoYwX9nvNplS5EJDQRHy06aKyGorJZNAj40ONjgj5glaD1fNsQg2T6tn6HdROUd1w8+ohLd4kKmsunF1wvryiO7uKOj1GbjqvHz3j+wXssd5GnbeBq+YKw21IYh7NTYlAk9YQ/OIfb5QPsBDp/xS42nFRnXLcv+OD8OavVOc/Oz7FO06S7+NWSQmvmi2Mmp5rnz16wuViz2niS3dHveoyyTOohs16RlCGogqAKnNIj6jhFBT6QYk/fJrpoCDnPPA2YmhQJvawXrNZg8u0hBFLweN/TdJ6mS3S9wvfQ956u7+hCi9FgVAFVSbKGzW7L5rJl13fsuh0x1ZTKiRMytbhocErcP+XU4OoSqx1WG5LqoTBUk5rJpKJwitBFuhcbmi4xPQpM5xNKbdE9Ut/Qjl0A5YPUPIyldJqyaNmVjkJrppVl5z1+uRLns7U5R1bEBmmIkKzVqnT1bFK9tt42H31eiv/st8Vi8bXj4+NvDYXgw7ymwZUyPK9Hd0jhcMnhgx9dMD7nw9Z1zdHREVrrMZtLH7hjQhYaYow0TZPFIM/z58948eICYyzr9Zrr62tSipRlRd97rq+v+Pa3v/1DP8tZOef0wS2O4xHeJ1rvqWcTiGecf/SC2hY8ffKUZ0+fSSag74khYJxkDt6d3sW9cFxcXLDb7cbn7Gw6pUhlft8yDx+eu8O6dpgP+N6zXq/H7C6l1CjCpZTofWCzXUs1S0mG5yAOSEOsoT0QVIaMxAFTPmQpGi3IwPVqza7ZsmsaNtstMUgT8XQyxRqJbQHYNVu2uzXTyYS6nqByPrB1lqosMcZQVpW85nqDKwoUIvAqpWjb7gDBKGJoWZQYbWiaHav1WghAOSNSIkHD2Dw0XFOHaMnsfKrruv7Cbrf78PPR+Nlv9+/f//prr732Zw4z5m667gYh59Ny8w6FqD3+/mV32YC4PHz9Q3Hx0wTBcS1xQ2x81f5vCmKHXxsR/3k/zrkDcdyPjQjDdXkoAL7KYXhTADz8/iCkVVU1vsYgoh1+7/C1bzogb36mm4jTm7jVQ5Hwpqvy8FgOIt3N83w4Vr33owhYVRUhBK6vr0dM6uBifJUAe1ME/LRcyOH9WGur09PThy9evHj0My8ADl3OaVzgqDFPLWktAdDD/w/WhnvSikLzMvqF1KFU5moPSFASKTsB1aCQaCmyoxVahyyIqHEBLtlmWeDLC0Cy3pIS6CzvKC2d4ylBWZYY63BWY7XG+x5nBANyuKYzSpA+zmpZaFpNjImQHW/OKCyBECyJlF0rIigG35MS9CGy2TY8f3pJQDE9OcEa4cVdrbas1ztWqw3WOlxdslt2EjZsFE3GYlZWS1FOyXEkBHZ+w2w+p+t6iknNg7deZ/nkCd/79vf44J0PqWrHYlpyduuEui6xSgTGXYw0XY8LnrIuMwItSLFbRbAGH8BEj6m0IAADGBVpu46iKvCmRCuFw2CcBG1rlYje00akBa4wpCaOLsnkFSEvovuUSF6umRg9KUR0jESl6MJQrk1sl1u2bQNo5vOCSW0ojMYaJblAaIrCEFKg2wWoa/Adu6Znu9yxvFjiSsP8eMqkLqknlhfPrlk3DYtFTVHVGAUhIQgvD8lL3oHWGptz/IxRhORIMeK0olKKJkoXs44KqxS7Xcuisjit6ZRi2/aSMekMfQi5y5IDl0DuDidnvah9Pp/kBMZRKE9KCkKD6DdYZI2SLmjjtCQqeCRnUSlSMoJTI41ZMiq7s1KULM8URGyJWmHSIAim7FgbOrPUq0W+8x8i/L1CvHtJqMvOv7NPUQ/PDzmJZ3vn36CFnf0I6sTDM6jrl/GMo/vP2PHfgt+TiAtt8n1CG8KBajggprNpSAq/maupTA75zYIxWgr9sZer2Pce360k+wuIJmdNRfB9x/XlktWLc+rq7OVDNx6D80893E3WByvOWJzO2fU93//gY67WKwoDx/Wc48WM42NHmk4IfWC79ex2K/Cgi2Pq7FwUk6Jk/Vjy/UaL0BFiJCD5ra4wJG0zMg0KK0Io2NyBI0jOFEX4jwMKLEV8RpGGGAi+I0XoQhBB1YAtLD5AH6BpYbfrWa0e0QOL6ozjhWM2qUXwKyyDeuuH7ECRYtktGzabLRqYnyyYnkyY1TUAV1crQgwsjuYs5ge5AsIhIw5k6iRjyWpNYQsaAmbISwxy+tVg4MSP19eAWx2EZetA9Mvzf2ak5s3fd4OY7SqR+xqRGmXo/HDEJ/QHF9sNmfKHCP2fdWHwn3Z/9u7p33LOThjz5g4xfnliN0w+xXw9IkCVySi/LAIMOTdKpYO8CznR2joRzfL4V2h82xLCTlx0vqftN+J0j4HkiiyQQx8811dXbFYrinKGD4EmgMvd96QNdB0xWpLJIkOKROVAJTygraW2FbPjBV3f8M77H7PcbnBKcTSpOVrMOD6ak6Y1ofOEFNltNhA1i2MneT9aZRygPKMFt56k8UiBDxGLIphEMpJFa40I686Z7AqypBjxfSSkjhRixoyK4OeDUBtidhbGII1dPoTsOELwTBF8jLR9Yte0rFbX9KFjPplSz2bMqhJrdc7sy27DrpdYaSJJKbarDet1g7aaxdGU6dGE2bQmpcTV1YYQI/OjWR7/OQ/MyH0uDuj4JCKF1ZrCWZKPGMBnl1bK8918ieSmnpQLgQqllKKqvpXWmw9+ngr+Pyvjf/alL/13rXXTIftOKz0KuwPmXIZyvpb1QQes0aOYo9TeNQZ6zOjbN0Oq8b4wGM2U1lmoS6PgNaCFfUiURo2Fr+F+pA8wn+JQltfQWoR4lfPtxO0Ws9sw5lw6ETZdks7brtsLbuM9a1hAp6Fo4cWto3RexO/FPUFnCh44ZUfrmNWRc3PTwUIpJnloDlmC0swXpfkvhjFPSTJ4Bvxpbj7Tg9CqDzJQzJhbCmZ0YgzvRed7iFZKsou1GnH6aRDoMtJzjLwe5rL5b2OySBj2RJuYO6fJTkpy4wDIOQghja5DpROpH5BD6qUckiwMq+L0+JfbLAB+Lvh9tttf+9d/7W8ezScTfJfpRApl5HozQFTiVAOTXSgRpZPk2A0o+9DhQyIkhQ/gfYexOo/JVhyuoSAZJ02iQRrcdqsVvr+U6zP0LK8fsVtu6WJHX83pjIWgWW+3fPjh+1w8ecRk+oC2C6z6RBUh0aHTls07lwwV5Oftx5ylW/h0hHVTdj4RjeF2/Tb33n6b7faK/8f/95/wtRcPKFPkwdGC+2enPLh/SnF2zKMusdluBI0XHJPZnGMh+5K0ImkDOBI2h3QPY0aRgiYGqaYkm7vxY0JbGadD42TwoJoOUxhwNj8PpQ7ixUyP77Ojp2tpuh1ts4MUcGVBi2HVtlyvPJfLLc+eP6LpXnD76Bav33mNs9kxZVEJyacoiBi6tgVlUAZQnosnL7i8XGGrgtv3jjm5u+BoNiEmxdPnS8KzS87unnH37IRp7TBKUZQ2x8rkBgISOkUKbaiqUiZl0dMWBXrI++WgDhWj/AmKGAJWG/Xa7eNf/+77Tz4XAH8C21e+8pX/UCk1GZ4dA5JuKNbukXL7xp3COUxeDw54y7btIOfGDYVtEOy2MYYiI/aGfKuUkuAs1+ux4Nx1gr0N3oNSOFsIEcj3XF5e/un3ZivEJh/kvdvCEKLH2YLbXzgZUXtNu+P3f//3x6L2bD7j7NYZ9+/dYzqZsV5v6LqeFy9eSF5XXWOdExpb7PG+p+s6iqKQPO9+757c9Ts636H1HhEYU8yxTnp0y3ddx3q9lmpCFkl0zuSN6WWXziicxQM8uIK+7dk1O66urnn2/BxP4s7pLY4XU6bTaXYblSSg62Zs1jXb7Za2bbHGcnH5gs2uoWlaHty5w917d1gs7mKt4fz5c86fP+fevXucnZ2NzqjZbCaZw95jraFp2jEDUWtxNNtcP04R+q57KZNs+NN33SAiqFu3bv3qo0ePPhcAfwLbn/tzf+5vGGMmXdd9wrm3n0+mlxCQNzGfw/V52AhwKPIcOj9v7uPw536UjLubaM9XNjXecCwefn0QpQ6dfYM4PbgBh3E9NC0cin2H+z4U1l4lTg6/M9xPh/0W2QV9KBi+SmC8+b4PRcybf99EcN4UQw/3NXzew/0NIujgCuy6bhR9B3Rz27YjGnkQSl+VB/gq4fHTzk+MUb311lu/9nMhAJIY8ZpCZoljCLqsyeTGrZHCybioy6ikAdWYg1IEt6FU/lk1ggZ1duwNRdjB7aSJIlbk4ltMKcMRM14uSWefyrg6crB7lv4EoZgL+IaEUhGtRYGX31UYmy8uLeKKNgYfBB0afaTrOxJJnICFFJ9U6IkoVOoJQTprMQHvE76Xi7dvOy4vrkhGU02nRCJPLi/xTcfV1Vay+WYzbr/xGsuLS7hcUTnxkZRFjSWy6Xr6Aa2jYFZUlJMpoV1TaE3qIqf37vH6N77GR99+h+c/eI+2aZhWmn6zlW51YFJbIobkpYiQAFwWPpNkkKkAmEg0AzYxF8RbKCZiv3dJcBf9tsNNHKoEkhUXBY0U+TrJA4opjh47FaUXkyyGDbgdlfGYMSWUgdCJaNruGsrCUlUlRVVK54G1OCeiTSDRJk3XeSIeGzWzW8d0m47txQXBWJxRvHh+zap0nBzP8Enh+47+RWA+i8wWNTpqYuzF+aiHuo4U9QsNqqrQ3kPr8dETjckYMsAWaGUorKf3AR8h+UDwkSIjOTvv8/hQIuxlJOxQXFahzw7aNLoCTc7p6wgiLg990UnOiU8xizQajLgWba/oFWIZjDn4/gBLltKB9y+pMSBw0PSFYpYLXwMj69MEvx+WC3h283eyby2LeoffPjt7WVU8Oz8b9MH89/mog53lFz/UBz9NVLl3+vAlJKMWuiva2CzQWHGKjRKnQWkjGFj2gh8EYjZWtc0OVxjJ4zOgUhDRCMm+9EG6ihdHC4iwXi3Zbhr60MvbsBDbnnb5nFhMCEA9dRQnv4Ap5nC94uHHvJT915/BowPe6ajNHBw2V8Hd1+8wP5pz/uyCx+9+KOzQOw+xBmZ1SamhKg2Rkt1uR+dhihGsTdZFY9wLVyKsyb3aAEnHTAYNkumXtIj7nRQn0fviZ+wl16vzEbQn5DgR76OIdT6IwBrkPuKDjLUYPD2WtvN0XsQ/gNunD7l1suDoaM6kqmTR4iwJaJpWwrz7gHIFZeUIdsPOQN/1dMHj2o7GSsbjdrMTWJldAYzNEcM9xfdxRIbF1EveqMto0wDBFWCaAd7KYfxwDD53Jno0FttXMAHfNyLWfop+/k8jDDac4/ozrKtGSY/KQdO/LOa9cut/+Bg+++yLg/+891Edz/+CVgdCTS6yC2YvifsnZ3ppJR1Ch25AAQ7IRCQGyXFt24izBluUGf0oCL2UO0eDF5fO4ni+72LdbvG95OGhNKFtaeMFqa2ISTGZ1JRHx6hyirpaw/Nzet9mTNERvYXVpiWkDmJLwGCNxRmXi+4RW8C9h2fMFnMunl3w8XsfYGIiHc+wSjOrCwoFVWUJlDTbhs4HopY8pJgUJjt5ZOomzygfAirJBDDFXGSPgRhVxn4i4z8X8iVKTBEDtJ08DwUJjoh9XjqFow/4IJOLw3BvHxMBTdt5dr1nuVqiUuLWyS1u3TrmaD6lrgXha8fx37Hd7ATJUwjVwTuLNYq+D3Qx4bqeNqNImm0jc0QxclFXRc7RlRxG34sgmZTcm4yCwlqSkq/F7AAzw/UxLvKGeaMgCrVS6LJ4O6w3P/MF/5/F8b+4f+93BoeWyvmMIuzlRro8vxryAPWNHNBhMZnGZYcee6L2oqCcd5WFLWNUxmFJc1jfS9FPCgdyr1mvpZvd2okUBK3F2pzBo9QocsUQBBPKgCkVR3JKct0d5l3sMZpJ9q33r8OQrZ4k/zxElTuXzYgaDTHmzOchF1X2GXyQ2AYMKdm8IB+YKDlbLxfCk9q7AQeHXvQ+5+vFjF8ehDud56Ay8xgKCVoP7kr2Adgc5oPIHCWEgNKSq6qSOC0H0dRoEWTHaIaDLOshp29AdQ2T3xjiXtRl6K9LOU4i7s9zFnNjiHmNq/aZR1k4tUbhszhZHS++3n740X/xueD32W+/+c0v/wWT7+Fi7dB5DaVyzIHNLv2YyTMO1ECn6OlDL8j6tscrjU8G3zVUhcXVc4y2GO+JXQdWGmW6NpJUZHHriL7rubq44uL8Uubb2zXGlhR9Q7z4Ht3lhNBpjo+PqO+9hlncR330jPTd77BtVpK3U92lf3PBh+/tNeQlCWMEvZf8FqU3TI8s3/z1X+Tug/u8970f8I//y7/HhIR+4JkYx9nRhONSsz2poNSsrtasdi3bpIhFibJO5j5JmkxDbtRRKFRUpJQFvyHtpYcYBRcqw0DLfUIPxUJN6kEZBTqRMPTB4IOmz2SA3a6h2bXs2p7tdifu5aDYBs9q13C+6nn+9EN06njjwRd5/fXXeP3eHU6OFxSlw1QlKePNL8+vafuAKSuqyrKoStblY9rOs2k73HKFBZxxbFYNXQxQSM59PJoyrSxlURKTRoVA9B1JSxZ4bTV2NmGXEqbp8FUJRlOkhImyJgopi38pZQxowFjL3dPFl777/pPPq/E/ge3+/ft/6dCNM7g8Rtf+iLZTY9FaZwfI6FrLoqH3fkRYGmPG7MC+F8rN4HoJIeCc4+7du5yenvD8+fmYNzUIjkop2q4d5723Tm+xWCzou45333vvpc/w2v0H8vO7juVqw9PzpwA8eO0BJYaYAsEHUDCv5swWM5bLJe+99y4hBhG4EsymU8m2c46qrlkur/GZLFBX1Shw+JwROGQWeu9ZrVYvuXxiCqO7bxBBh8K4IJIZBU/rrLgpjZXc794TUxwL8SIy9nR9i/d7t2DKDUfXyzWFK3j74UPu37vL8fER88VChAytCcFzfb3k2bNnrFdryrKgKAqOT4548uQZXdtxtFjgrJMmxxi5uLigaZrxM83nc5RSzGYzUoLtdsNuJ2Li3sEo14xOhqRynEk+Xnss+mBGYXSTzWaztz4fiT+xBoC/8Gn4z0M337AN4t/h9w8Fwps5loOINDgJh+8NjrNDfObhGLkpLP1Ic7UbQtOn/f/QpTe8/uFn/TQxaxDXbr7e8PkP1+g3BcfhWBzu86Yj9vC1D7dDEXKYjw+NFIMr+1BcHPZ904l3KODedC0OzQbD79XZCDB8vtHBnXMCD3Ggh591ON+vOm+vcgCGELh9+/YXfx7GkuWgM3VYPMjiWg0MrNENOGSP5VISAyI9DZNvBhegla6zmIgpiMsqY0YV0kWdXlqpREJUQ950nrRLUWkUIDU5q4FR/AhZAnR64NJaSqsprbx+3/eUzqKsIPtikHerncJqA9FgCnl9hRonBaRANFKESiGgUn7PGVnXt57ddsv15ZqgNPXJAu97tss1y9WWtgtgDYvbpyzu3uXktXssXyzFwVU4ttfX/Hv/0/8+/cWa//3/6n9NtaiBxGbX8Y1f+CZ/63/03+F/9rf/J1xvNpgYUNbw9q98k4dvv8X7f/wHPP7Ou6yfPqfQW5q2pa4rikVNGSLd1oOCoq4wZYkOnkjAJoheitgxSifbUCgT3dcQey/Yv5ig62lcFg6sFDNQlph6ut7jEdxKjFJU77pIF6R7SpPEETgwLqMSh1QfabYtvm8pC0NlLdWkQBcV1WRKMXEkDOvlhoRit1vTbKTjMHYbYl2zXe8IRcFrr93Fdx2b1QbnNM8v17SblpPTGbayrLc7Qtczn81wRhTKTI+Vzx7zDVwZ6tJgSGySweAhBLzvaeNQGBB9O3g/op5Sgk0XCNldJ1g1wckFL0UHT5CA41xs2hOW1EuFp5BEBNyj59JIFTVKyfsnERA3pSza8hhSw01K1EOVz8voxuXg+yhx9A4PgeEdvVIsOHASfdrPnL0sXJ2P/z4b3X0wZPvJT/wwrOePIpecAfPF4iCXbXjKWxGKswg4ijjZ/Tf8cIriAkx6j3SUnzMYXQimLvZCVE1AENQVUc6Ac5am8axWLevtVh5spRulxRCgBGxRYSYLMIaAoTMI4/NMRL35pIKJw1Xw7qM9BnT+8Ixbizt0ux0fr96l55y6+jr37p5wupgzqWuePZqz2/VcX6wywtigpzNqW9BcbcD2aGvQ1grWjiFs16OCCOExdykWWhO0dO4axG2KSnShx5pcq7N6FJS1Fvd0Cl6Ev0B2A8j9eDA49T7gA+SmHMDiO8969YLVSjxsJ6cPmZ+cMjmaoQtHj6ZrW9rVFt8HmrZju96wa3rq6ZzFoiZi0MWUSUG+dxh8hM1mR7dpBBXoDKu4xXeR+cSh0dIFni8Dn8+Tyi6g2mY52EI0Vs5lDMQhO3E0jHr5ISNowrZvPinFHVzg5/88HtDDhdz3P5TS++rN/QiC4c9W4VGdzP9dVxdfGmLZUHoUAVPuWh3F2ywGap1dNznPS2uNsoakNEN5VyuFtYV0zCYvDrnschvyMlJMGOtom57VcstqvUMZS7Q1WidxiqZEkRKuLNGTgqQNEUPrpIHIlI6qdMymJSSHsYoX2wZCoLSa+bTm5OgWXdvy/PI5MXqq2nH37jGnxzPquubZx09pupbl9YpCJXHVTCfUE0ez3JBSkMYf63JRX55jIQS0NaiYc7ByHlhQUXJSMIRcRO9jIg7EQ6szGjS7qDPmT3Cf4nyKY4OLzLNk/Ec6L+MuIuj1zWrFcrmkMIaT02NmxydM5jN0YQlo+qanXe0IPrLdtWx3DU3rqeuK+XxGwqCKGZNSUdYy1jsUu/WGdrOTxYrzqLQhdJ5pzg8UlCGjYzSEhEoRZ/bVTe8M0UpxMGUBUJ4Z++flkJ2mC3s/fF7w/8zfh3nttX+nnEzfTjFirBmzs0kDXFKNQtWI34QxB1OcavL9OFJFVCaI5M61cfGsxp9JOWO0cJYYE86Ke9w6M+bolWVB23b0faCuyizWxZcWyfvsPxmTQwbduPjNyMybmTriOJL5R9+Hsdj5UrbJgCfKiBSt1ThHkjVdypAJmQ8OrreUEVkgDn6TDrqbh2aAjMFjuD94L01RIxJVimc6564bYzBWFt9F4QghYY3NGLGc3afznDRCSDkv3hh0GtClYY90ZcgrjDkrSI2uRJ3F3SHjOv8y3mf2QbxR7BmxbsMZySJhFIdh7/041rWW4rC2MjfPCYhUk+m968/H/2cv/n3rq//OF1+782WVcyuVtZiMJQpi05e8xiiuroQGY0nKEnopUAdAK4erhFwkBJeEqiqUcTILjp5wkGfddwGfPKVJrDc73vvgKU+fneN1CfMzCgO1csyModQRfbTAnU3pdUHjNasioQpPsZgwmxQcTRyLxZy6rni8fQK+ZV5Gbs1v8eDOl9iur3j3ybfxsefouOYbv/Rlvvj6A46OFnznH/0TVs2Sx08vmKhAPS1RR8ccV3PWjy/wfU+yBlyFdg6l5POFLNqHII1QBFBB5kQpBpKPJB+hj9LI02YUbmEJhWQkG5XbuaPk20c0MRppvk2J3kd2Tc9m17HaejaNwkdFHxTtbsfF8yc8fvaMo9Lw8O5Dbj18nZM7d3CzKZ1SrFctzYuGruu5uFxzvdpwuWo5Oj7h9ukxngI9ucfRDOqJRlewDpHt5Yp2uaWc1Lhd5Pziirjr4HjK4kjLPSjfw2JSdD5QEJkUJS4mFAXttMSXFqelaYpMv9pjQ6ShwCi4fTy//3kp/rPfXn/99f/GfD7/0lC0dc6NiLexSGvTS0Xdw+K/PGPNKISN7negKORr3QEKM8Y9Ys5aS11Xo5jWZcQkMOLnnHO52UYJdrRw+KLg7t07PH36TISpoxn3X3uANZbnz8/5/g/22YDTyZTTW6d0bcfTJ0/ZbLccHx8zm84oioK6qqXpoOn48MMPCCFgrWVxdMRiPufq8lIEu7KgLMuXCtvD+0bJ+12vVzgnxffe9wQfaNsWHzzBhwMRQXK/q7oej1kInqqsMNrQtu1LmMXee/quo/e9uAGDzC9C8FxcXPDoo/dwdsrrX3jIwy885OT4mKoSpOd6s2G73dL7nsvLKy5evKDb7qjrmuPjYwpXcnp6glaK4+MTZrMZSimen5+zXC5pmgbnHM45fAhMpxMKV1AUDu8LyrLC+8B0OmN5vZIGKaNp4zbPhfaCkGQA7q+lQwFpNps9/Hw0fvbbr/3ar/27Z2dnXx7G26E4M4hZh8LNTfFrmC8PQtAhItQ59wnx56ZjbRABh/m5ObiXDO68T3MG/jBh6YcJgIf3sUNhbBDQbt7/Dl/30Fk3fAby+qLv+09k6h2Kd0MG5qFoNghgY5PdK97zvuFyv99hX0N+6NC4YccCFy9lEr7KuXjoAkwpUdf16PLr+54QwktNHGVZvnROXnV93BRKD7Gmr/p8w+scHx8/+PkQAIcPpshd50O9OC/UtMyD1IAoZFwjDwScUVBQWqGS2iN4dF7chTzBVhqdd2CUVOWHhZ+Wln5ZsCUpWVmtCHlynkkfw1uQCysl4ctbCW12pWM6rbHWgM9h7nnBb6yg+aSALYvK0lpxpRnJmyuym1Cy1/Ki1xhxOwbJrOq7nqZtubhY0vWBal5zvdyw23Y0XQNKU1SOcjbj9O4d7KRG/ClWsI0WiImzu68RTqZEelAVJIUhYYzjl790m6PJhOvNGm015WSGSwk1mXD3tTco9IwP9be5+Ogj5tOCmLyIQ2bojgd0YjKfEVZLKVznokPoE6ZU4toLuWCvIPUBr0A5LfzziSPEQB+kq9qERMj4IHyUZXBI4vzxgh8TFxocejR9BJ9k391OuoFKk50OzhKRSdbzF9fYK7kxrTdbvAeCZ+ND7srVvFitMCiKsuQHuydEE1ncOsYT2IWIrSzLzZYueObTCdu2I/hrZkc11joprHQenzwajYkidhCkK7q0hrawVNNacoe2DV1GEBbOZiFQU5qcY4g4oMjXyoDtjCRiDIJcy4VTyUGTUPKkBtOsoBYyVkyOXEaUaSIqaYxUXDE6QNLiSh19tXEUEVVKRLV3KIxd4pFR4Fbiz92r7HyKEnd2IBqc3fz6DaHjxtfODr42YD33Jreb8t/ZK+GJP0w4OT07w5lBz9tjQA/FQCvER0zu1jfWYHJu3yD2oQ3KQsroYaPBKTvEBxJaYagqo0khEvyOEGH1eM3l5Ypl00PfYOqKLkDTQL9dUQPdomJ6XFEezdGuJPSewJVkAALOnVFMJ0BPvz1/6fjNJ3PObs1ZXntYAQ1Yq5mUBbVzoO8yPznm/ONnbJ4+IT76mLKumN/Oqkfo5W5j5DMpq8FnR7DW4srrpTki+YhxCCo2aMn+iGBMBB3pey8Y56jlOGhNiNIdF/pIRxSERnZKRqCPQc6KNvgg+E+Mpd95umaL72FenXG0qLB2Qh88ly/WWaBsWF9tafqGvhmkq3MaoHpxhqugduISrKuabQiUE1nA+F4KGiUetnL+wq6DMKOqA0VZ5meU5IwF0XbRUcRdncSVYZyF6DHOEEIukhj5W+fPaDQUDjb9p4vUf5r496O5AxsMc7CQQaA/pqjYv1rU/xkqON7cV3Hr+N83WmXqXm4OOjA0q+z6iUlhtBT6jTWSDxZyW4TKzmprpFkiyvzDaIPRSpCYId+HrSEGwdr6kFguN1xdrVlvd8TYYypLnxLdLtJvdxQq0k1KJqaiXMxRheSBhKslfeqBhCkqXF2CinSbjqgSSk1Q2jGdLDhZLNhslzy/ivS+xRjFtCqIzvLwC3eYnxzx/ONnbJ4/Jzx+RlEVLHJGnwo9Jkm2kdEKnTOQxO0nhfqUkuQFhoB2Jo9/cQ1GlbIFThy9RitUkuOVlMLHiPcB30f6fC8dUGAJwYEaJR0zfZR5mdaK0HrabUvoA/PZnMWkyovywNX1WgpzvWez3rJrGxEVfaDH00dx8dVliXWOwhbURcnW95STElD0vSIFqJSHHYTW4xtBkJdVpKyLsTg8uIZilAxmldHc1mpiYSCAsTYXDA+urSycGK1xZXG//wmNk590wf8nOf6P3nj939daa8FmJqKKGbWpx6w9Ge9mzP7TeXG872gVDO7g6jvsNL25+NN6QAQPfRj9QcHQMmCIjYaT4ykhTmjbPj/7Rr/x6D4Guc+gJDxB/pYry1ozihGCnpS5ccoYYxRYMyxQhwVpzPjQg6ZKtS8ExBRFAI+5AUYddEJnF9yQ8Td2xB/k8il1sAA+yMobhDalB8ff3slnnckZu6CdCK0248QHpzFjF/PePaFyI+ceaS+iXIhChRkFSZLEU+TGNhVl7Gb0hvA08ppSRMNwsHhP4u7OH2lfFFBjVqF0DefGhewcHJ3l+X270p3xL+n4/0lu/8ZvfvO/XTmtVfQoYwQ3GxIp9qS8ZiK7SWOQ60/Z3PzTB3mmG1DGYozDEnOxG5x12JyPJ0b5EmUkd67tV+waz5NnO9579wnn1y9ofIeeT2hjYnOVaF485si03L99xPT+gvLOfdx0Qb9pCI+fsgsbEhFbHTE5ndPHLVerp3gT0eEUrWsWs/vcPT5haXvefx7p+jXGKha147g6Jf6ZX+TWg3t8/w+/w8X3/oT4zvtMZzPuvuXAJEy3oYwGHXpIAaUL4jjfzc26PqA8qJBE0Ash55xLi5w2MieKfS/jKEkTdLCWoOWZTjCkjDCOIYkQqBRtXq+nFAlakWwha4S1p9n0xF7zhdsPuH1UUZcFXeP54OMLjL6g30lT9cVySdN3+F3HTu3YRUNVVhzNF5RlxbSYs6inmIWiPi5JWJpWY3ziuG/Q19CtLH25Ay/UqeNbc4x2OCN1pz55YgzY0GOT0IDK0tFPK1wCXRQwIqHTAfJN6lWnR9M7n5fjP/vtrbfe+uuAHgrzh1i6ofdjeM53++5TYhSE5dDUYXOhWNadITtJ9Fgcb5qG3W4ruXJK0Xc9zlmePHlC27RcL685v3hOWdWkGLl8ccXF+op2teHtt7/EfD5jOp2SgLZp2DXN+F5mk9mII7fOvvT5FosF9+7e4/Lykn/8j/8xAL/wC19nvpjTtR1VWdH3PVeXl1xcXHD54pJ6OuHNt77IJBfEy6oS9PkBPm94zvV9j4Kc+eeRbODIbrcb83yHYzI46QQvqInb7Scyt4wx+5xFV6BUT4opiwryesZats2O50+f8eLygtPTO5wen7BYHOH7nidPxEnbtA0fP37CxYsrEU5DFGLY0wZD4vYbx5RVgSkN8+mM3Xa7L9j7iNGOslBs1lseh8d477l9+zbz+YIquyGHP5vNhrquaEbxUqIbxBGox58/dFkdIkHrur79+Wj87Ldf//Vf/2/FGPXhubgp1BwKfcOfgQxx6P4aHMCH8/+bguHQIDCMh0PB7ObPH6JGB7HtZsbdze1mPt6hyHyI1DUHDuZBKDvc56vQn4cC1+F9Tmst7tyuGz/PgAN+ed3DJ9Cch8fhsKnuVZ/pUPwb9tW27UvH/1V5hTcRqq86VsPxKHNdb0A7D0LukOVaFMVL4uWhoHq4j0MH5OE68PCaOnRALhaLez8XAmAaWfBxbFFVe/NfZjeLuKCSdMQrZdE6IzgGNTDnzGiGxWFuwmOfgZHEi4ZKIS+Gff49weLonLkxOAAHZA0H2X/5FbNgBi5n3Hjf42xJVRqR8ZSmdBZjBR1jMo7U6pzXFhWqVFinpPOdQIgRqwxqcCqic6e7uIB6Lxl7q+WGBEyPJlijadct291uxDWqZDg+PmVyckwxm1EUFVVZYjOqpJ6W/Jf/x/8zzjqOJhUxgY+BsjBcnn/I/+4//b+w7hpcYTG2YHG6wPQeYo/ftHzp7df563/9L/Of/i/+t3zwnT+GeUWIG2xZUDhBp/abFWFVEb2Xgl7wIMvoHLSbEULBE4zCY3CASQmbj3EKSbCwQbrkdfLCE297kjaEmHPQfBCHXwqSo+WTOA2SCJo6RNrLJSkFJoUduT0hetqlZ7nr8L4nRCmudSHjD3Kv8oBQaltDYRxd13N5tcSWhssXS2aLCVop5rWhcI7oA9eX19T1hNA3YGA6kQynNAB9NETiKC77AAlDVRT4FLlebnPXsmTICFbOYC20XSQMxYwbFu2hODK4DlJAcv5yEJU0TGdMqj5cze8DBFMQQSUQ5JgaK8VsJZkVSg1IXcEXDggknRe+Q1jzQXKnOF2yOE8usnyqMvGjfv3sk8rdoSZ4fv6nSR8/vkfq5M78U77jD/sZMBYsIv45a0Tlkscgig4oZDGoHZghJNvLEcuZUMPjMOb8uRgR7GdGMZq6ElGl6WHbwKNzPLA9O8MczyinR9STiqpt2T6XB1UF9KtztgjesTmgSJ+fQ1WtmF3XXK22nJ/Dw6+ccXz3lJPj41xYjFRlyfGk5HldcP3knKvVC4rNBl2IO21a1NAHQufHK4sYRlcpMdJ1ffb7FQxxRjGxx/4guLOQwGor7uw8TiSnJ9CHiDWC1pTZQhZXkcNaOIPuhbnfbpYYxPlorHRabbMbcJevi55zmvOX9eZDQOoZoolWZ2c4VlCBm1RYHBaYVY5qUaGBrmnodpYemMaCWYSiKDHCF5ZMoSwC+pRzBjVoZ7BBBGKNuKR1gDhcQkPWYb7ats2PMHY+RWf/od98OFzRPQaH458GKXpT8PvxxL+fZKH/07ZiNvkNnQu8Se0r3urgFcTxozDK5EDrfL/TKo9qj0I659DSmBNjkIJZVJC8uFAwOWdKmjkisN1spZCgFdZWQjpoWtK6Q206Urik6e5gTmaUkyMm04rYdGztBSYElO/pNxt2Sor93abB+EgfIs+bjqraMKsLrtdLrn3LnVt3Ob1zxvHRMW3XEWKiqgqOpxXP6oLr58+5vl5SVBusEyx1XTnwgZDz84ySeVtM2c0aI33XyzGzOne4Gxn/Wh4kKRpxtaeI1SY3lSTJ9GUoJEasS3ifk30HfEhIKOsobcL4SNv0dJstRkVm01oKLVqxXi5Z7zy77MrsfUcbPN73EEXADMoTVaTvE81O8KyVnWGsQ5XS2W+MwSTFvLKUdYXRiW7X0TU9IQUmoSaSKIsCkzO/BpElJREtByFZZ8ESLdnYQ7bu0LWjsjtKO3vys17wTz9FIsOPur/J6emfHagHg/ss5caOYcGq88JhKLJpLQ5Aa/ddsjZTToa55dglOvzfiAi0n11lsS3lnDulCD7jNvU+f9RZqCsnOcA+5ssmoJTJSyVxKtmMLJUMuoDRmf7AvhgRQhgzBlNKOGsIwWONIzGIdFYEee+zUSWOjZkxRKzRo2t1dB9mh2CKEY0exU1ZI6ncSStz2UganYxZB8tNn4L9siBo3Jwp6pxF579DCCMhZnBRSwONiIFSQNA5T1GJk1lryfnLnz0ZnQXQ7NrL7yH4nC+qFEpFei/NeWQax3C/YlzkJ2kkHHGvcpxCCIKS1kLmGMA3isE9KoLIeIyMdI27qvq5Hv8/rdsvvf2F39DZ/a+NFqJJDPhRmNaDBIyzBaawKCPrMKUMSndIwq7CKotzNamGEDqS9yjPwMEgJk0yJTH0YEtsVbB8/JRd25CqCRN7RGcsYbkiPtmSzpds2x/w6PqXuHV2l9PFfe7ePWG23HLx7e9h+xbdbumuHFchCTbv8ooi1Wy7wB9drymL59yaFzy7eswf9Et+7Y03Obp3j9n0GO89R4spXyks948m/GBW8vy9H/Do8UdMLi8oCo0xiqOZxfoOv94QSkO04LXCJCWRFY2CGLBamn1VghA1IWqUFhdy0uKaJEZ0YXHODKZKEoHQB6nb+Jif/4qgNJ1PpGDATSisJ9mO7aalXb6gtIE7Zye54dVz+ewdniwLXkSL05pdv2PlA027IXU7ChPoLfRG5tnXV+LcnOs3KKqadKSZzKZUtqBEcW9eMJtXlDbQXG9pl5ZAoCeSNMynMyrjUNJ2jE8J5YMQAVSisIpiOsEFjS1dvm8fTCoPmiGO55PTz8vxn/12enr6G4f4uEOnySDWHooA+2J6GIvEAFVVUZbl6AJq25Zds6NwBW3bslytpFm9LEcChHOOzWaD957tZiNCWO+5enHJer2i3QoS/vvff4dvfvOXefDgAVVd8/zZM548f8ryegnA48dPOD09RSnN5eXVS59vtVxydXXF5YsXALzxxhv86q/+Kg9ee8Djjx9znosqDx484NFHj3j88WOePn3MYrHA3L5DVVUs5nNUxnUORetDt0/vHE0WJNu2Zbfbje6Zuq5yFFPEB0+KSTCbCvq+GzGiSqlRAOz7XvIPnaXtFNooyVUMhq7rub6+4sNHj/C9ZzabUxSOelKzXK748P0P2O62lGXJ1fWSZ88yVncxhyZCt8fsr97fcOt4yvSkJvSe9fUabS7Q2hBi5OhowdHRghAD6/Wa5XIlJDjvs8uwIqVE0zSUZcl8Psc4O55TIUMYykLck4MgeoiIHESBqqpufT4afyINAL95E/N5KNYcojwHgegw/+9QKDys2w4C2k2haPh7EMkOMaCvypK7KVod4jJfheR8lQA4CGxtKxE42+0WYwxHR0cHiOJ+vH8dYjJfhbC8KWQNjYyfJv69ygE3vOcBpzn8eZUAeLgN73V4/cP3PIh0h00crxLhDvdxeByttePrDZjmoYFvuAYGgfFQvLt5rm7+/xALevN6GT5TVVVHPx8CIIyeon0pTY2TaDUEyGdhTpMniUqyohJRSC4JksrV1aQEJZV/P6DRRmijKcj3Y0ZvqBQl1yHGjObIeWpDTVkN2FHB2UgvqEKrhDNZOU5QGnFwGa2xShwr1ujs/ElE4ohZFDOQcOJVAO2UZGGMKrAhJWFiSz0w0fUR33napqHvPa5y+C6w7FqWmwZlNJWrKEpHtVhQnhwzu3+fUiuM95zcPeHi8QTfNhSTKe/8f/4reh+YTmpCkuwdowquL1/wn/9n/ycmU/EjHj18jXtv3sdoz/qDx/hnT9j5jvf/eMHR7dt85fg3ePon3yNqMMYxqQzVfEa7bWk3a2zhMCE3+SEd/z4GNAYVBvSkIvRZxNM6L5YGIUXyc0IUlKtGHGlhzMPrpbsw6ZzJlPNCjMGVE7QPXD99Tt+2WDcEl0Ifepo20PhEVAY7nZJy5pegRrTgWTJwVucCTBN6mgBl4TDW4H3P8npJDMDRhOMHtyBE2r5ntdlQFo6w6yEpytEOLIUAbR0hemJIhCT4o5R/blJZtlvo+h6ndc6VFMznvq4+5Ifsu8zIOTNKK1LIjjwthYU+CQpBEGppzGNJudCi8riLGa9WKps7UaO43rQlxP3NfMgyGergabAaZpetyo5DBmF9EP7+aVf+BzjQm2LE+U034E2l4qzKXz9MTPvx5IwzYDLZc56HTLvBDTg4AZUGjcE4I3jgLIDtf9iMFRAVQVtyj6yRBgetSQQM4IMscHsf2G1b+q4fKJAY6+h8L2Kjq7BvPcQCxk2oFsdMb51wdDSl33VMrlZUH53RPDrHnUl2HEA1uCaHo9Gcs35R4R+JMvjWL3yLN97+ElPnaF9co22B320oNdy+fcqscqwvK9mvhnpyjKbIrMtOkJkalM3XN0Fyu3LotxQL88QnQDQRkwVQa6wUEgGnFFEnyRHNfr+27VF1RpYNnMwhdLAoKK0hrtaEzo/OSjzsdivaHnbNOatzOQb5o4/C36sMpsPWDK7A5oy+aYAGV0Fh58Q4pZ4WGGfYbVtWq42goTDUEQprpHFFa5LVkmXUSh4SUQRMpUUIyXGBI2728BKSdonmx1D1frytB+qsawfb4xzQ/LhIz/5TRMGf/kL/qzZ9++Rv28Ley+VkKfLu+4Mko0up0RE4iP/qoHJ9iDhPMQnqyQwTzUhSuShtEyopfPD0IdLHSLtt8T6AVrkxRON9wGlDLEpsWWPVFGOnlPMjpmcy/v1OcJ3uyZxm+YQyOULXkRKUykhOpUlYk4hdy+bimn7zAqsKHn7ta7z+9heZuYLuMo//7YZSJe7cOWFeO9aXU6wSGkI1qVHaylHJ+bTRKKzJE9oscvR9R2GNoHGVzflJUtAjCxzSRSxuKatkrufz80MxdNyVgLh00iDDaoUqCgqjCOstoWshCULJx8Sua+n6jl3T0nhQ1mHRdL1csaWdEJOi7z3WllglOdFaG4IKtKlB+w5Lge86IFFYS2WmQC34c+vYbXZcr7f0g5vH5/E/PBuNJYYg2b8gDVHGYjJyXvLHcgOSZu+qV2CdPv55KPj/LI3/6stf+ttFXd0dF4cyCZJms0HcyncEkx29+qUu3fTSYlBrldHe2S2WyA4gWfuYwUF2IKoN951xvpfnCC7vaxDanNVCJzF27yLLVBRSyugpkxu3xCVnjDTeyPMqZWxpQitDyCJfzOK9tSICCk7TjxQWIagMHdBaSBrDmM0Yb3LD5ZCJqBRYo0YH5WHH69DUJgJckPVZzlYKweMKm/MU0yjaC21FhIQhiVkpEWtEZI0HDkb5nPKaehQATV6/hdGpmLCmGLMK+14W+j4EyTSM4mAGMElexxrJEhpEWxm+cS/o5ka5Qenf5xfKewwx5nmAZNo7Z0Zx1JXFyeeC32e7/eXf+tX/6O7p0T1FzD0ZaaxdiLPfivtfVvdYLU23SQV6L44vZTToQiapSWHRRJ2b/ZSX7FysjJcEKXR0IdECy6sVbZcwdUWdiRjdtmVmS+LcYqcn1PouurhDded14tk9tosCbQvqh28w/fYDrj/+R0zLGalrCU3LXE0IXlOyZec6wrZg/fiCcP1H3DdQ/cpv4e69xSY6fFBEM8GoliOj+cpX3uLu8YTrO6dUtDjjmS8eYEzNdDIhbre0hcEuKqIx+Bjp+p4QO3SK2LIGbYnJymdsA0YJGlPi7A1Ky/rfJEOh5clJEnx463tAqAABRVQaHxOeRJrOqU2i78/ptg2GnqJ0bLrA9XbDenPF9arhsoXoFAbL8k+uae5smLs7dF3J9WVg8rCkUj2qk1z3Xm+4Vh9juop6c0y/W7PSillRcmJPcGrBZFFjbMP1iyseX3QEIs5YTNRgC2zpMIUmWYePAd829FGae5SrKEqFLTR0YeyIl+tNjVrgfFrNPy/Hf7bbl7/85b9VFMU9wX+/2t1xWLAdcn6HYq7P9K7h4TM4grz3dNnZn6qED4G+72ialmbXkACfC/IhyDw2BhEXt5sVXd/RH9bdyxmTyZTXX3+dBw8ecH7+nNVyyUcf7Lt9X1xecnx0QlXV3Dq5S4qBelbQ9S1PnzzmO9/9EwB+59/4Hf7iX/qLzKYz3n33Xd59913Oz89zjnjF2a0zlssldV0zX8yZ1BOm0wllWY1iRdu2dJ2Id0OhfHA+Dd9LSRoSfPAyv1GKsihzlvqQfatpOxEk6rrGGnHwHKJYZQ2mMaVFqZLV+ikff/yYpmmYTqcEH9htt3Rtz3a9pW0aqoxLn8+nBO6A0cwmEzbrNedP9wLg/VsnmFKyn3bbBq2kqSuEYf/HglWeTOj6jssXL7i8uqLvOoqMaRzmM2VZcnb7jO12CylJXSc7ASfT6eiScs695HSS2lzAOTf7fER+tttv//Zv/63ZbHZ3t9t9wll3U2QbsJyH4tKhS+4QEfoqN9jNRoJh7n3TKXZTyBtrs9n5ttls2O12TCYTiqIYXWmHuXqHguAgYsUYaZqG6+trLi8vR0HTOUdVVS+hSweha9jv8P4H8e1QyDtsCDh0NN78vDedb4fC4JDj17bt2EDxadshVnQQ5QYRdLxn3MB93ny/N4XJw+M2iLuHz4FDMfSmK/JmRuLhuXuVGHjzvA7/Lsty8XMhAGolws2AmRk6LHMdRxaiQ/uTTgzorRDEUaQzMgMSVuWuuRTRSROVRmkr4MHkIWmUThmFKBjQlPFLQQ8uwqHr2giqZZiAJcniUdpgUGgleT/aiMPPlpaisNJZazQWwewkjXR9ZwkQbbBaS9EtZz95ndBYlJV9RMCqiI7SLd4HycZrdltxuxQFu6aXjKq2ow+K119/DUMieU99ckI5nYkoWRVoXXHvy2/x4sk5H3//Hcra4aYlrpdBatAQNUprbGEpnEwE+qD44q99i6PTE3YffkivAsZprpodf/LO9zHbHWd3jnnhCqppQWkt9bTk9N4xTz54TrdrxPGSRVujZKkkbiaPyuKaLN57UgDfASZitXT/GRJ9SiQfcbWlqByV1qw3Q0dEQmEwWhbGsQ8EEnVdgrZcXpxDaDm9t2Cz3NJupaDaakMwjnpeMT05Yne94WK1xRqNs1awiTEL0SMWKGd/oGjbnhCgntbQdxijiN5zeb2hmE1wzqCC4fJyzfHxhMJo+hiZGCfoEu1xQ7svuehppAgU+kRRFJycTlivWnzXU5VS6CCCiVoyDnMBSrKnpFBKFkyCWCfRWlEY6L1IfFoNeKe8a6UhikAZD50WEbTKAg0ZV2WGbo59CUPH7FRNQ2F28MIMmUdautCTzkiDMdXqlcLen6bAvSTdjTatCmj2OYCjEFIdvGYjP3d2+Ms/3nbn4dle+PuUACalRQi0h1zQCFqHLIYZlDZZqNUYrQlEjHVopVFZMAs9Odeup4+Bvg34nbhTQo6CC00PNNTTUxbHUyKCuTWzY+anc8qqwDpLWRacvf0GT3dbHgE8Oqd6eM6EMxYVTM6k8H1aZY2secQL4OGv/AKvvfkF6qrCh0ifFH0AhUUHT2o6UifhtxqwhTgeiTKOQ+zQOoz4U2Oz09lLTlFVm7FzMnSRqDpUD8mAM5pYyKSfGIk9uMLinHQKFzlcNwa/R2xlpUxyQw2Fs3hncKbHVI7ew46etodlc46rHvLglxfUswndestz4Oz8PF8zwo+t9lfPJ65RV0E9meP7nu3qEcFVdF3AloAuaIPkCUSg1AJiJkg3oykdaAg+gjZE30nm3+D804fi8qBewkCSLaob+tpNxfL8k9/6sbYmf8BBrnYynGj6TxfnPzXLcxAD3cHfP72F/k+drBwv/ppWKufQpLGwnW2r8k9Nbv6x4mRDCjuaQFLi4hY3t0YjTp+YUnZZCx7KqITPK/qQBOfnW0+/k3HTR0GPxr6DlJjMF8xOJiKstR1meszsZE5Z5vFfFNx++3WeNWuu3+mJ6xdMjaF0jvnEkXpHSIIHtwZ6v2XVbjn+yi/whTdfp6pqfIz0CSlUKYuKntR4Uh+o6gpNwjmDtYaUFL4fFgh5zhbzZyXi+x7vA5U1GV+d8G0k6IjyiaQVzhiSk+45YqDrO2zpsE7jo8ZmQWCfHaDGHLZEQhlNWRbEtqXVCVVaQpKO6c4H1m2PqxfcPj6hmlZ024bLj58T/TbnOil6H3AYlHaCJlWAM6CkmcvlTuLQdTTbDb4vafuI8TJ/7EhstztZ8FuTRU6hV+hSBJSUc8yil+sDrQdQNkMLm9ajLWhEIjpnFz/NY+UnXfT/F7Hf2f17f+VV3aAqO8z2orWIgWoY/xnNPsyaVM6xijGOBbEhT25EibHPgVSj2zij7QfxEHG/2jyOOJijKi0ZzFrtu2fJzQmgXxIrB+LK8N5Mzk8fsuoEUZleQp11XStYrhhH/Gkkuw5TIvh9l/IgZGotoroPIohUZSFiW74n7tGhKa+7GMVQeT9CwjDajAWMobFCD8J/Rp1qPSzK1XgsB/dcGJCgudFgiIcYs6oT2XUo+cZKidAntEJFjGr87MNnDJHs2NxnP6WMVxvQnylGlBZCypAZG/L4F+LNvtCnDygZCnE17AsdirIo5p+P/892+1e/9bW/JnHUkss2CLZxiDjIDZBKGbQqBN1OJHaJGFqGTjhtHUkJQWjE6eoC4wq0cqgUwHhigK7dsWlblpc7Nldbdk1gG10uwDXQe47v3OfWF27Rh8R2tSQdPWR67xRVF3TaEmtN/NpXqFa/yYe/u6J7+j2OlWdqDbdnlrhV+GS5X1uqYse2/YjnG3j867/Nr3zxa/TFgosu0O4a+tYzDY4yVZjtNboNHC0WqNRRFlBVFoNFB4WxGmX80NlHStL8G1OPUyaTlKDvIpvLji70EBsKgriai9ytHyNBJ8rpBDcpCEqjYqJvW8n2jULECV7IPW2QDMK6LumLa2rnsbWjC4q296zajierHfXxl/nqm19hfueY1bMLfvCO5dmz7xMeWnRl6fiYo+szmBpSb9CFQVUWWwjdaT4/ZXG8oN9ec33+mG47Yd14rDf0pmCbWq7PVxilOa5KKqNQ1YSJrTG6JlpL8EniPHzAJyMNQDaOz4t08NwYiToJjmY/Hw6An6Xttdde+7dlja+lMf2gcH6zCL1/9ukRPzfk2r0K86e1pixKIViFgDWWskj03kOKrFZLlqsVxlqctaQwOHU8VV1y994dQog0Xce9O3f5whdeZz6fM5/PmUwm/Ku/9Vv8/d/93XG/jz9+zHyx4Oh4zmwxFZEpC9XNTla73/jmt/jWr/wKr7/+Or73TCYT5vP5SCvQWlCcdV1jjGE2mzGfzynKAq306O4ZnEvWWswB9nDvAgr4nNcHkaIsqasJupLohGbX4LdbZrMpk3rCarWiaRqZA2xlbAw4VZ3R7EqlHLsjc6GqrrPLXughbbvBFpb54kyyCkNgu9txvJjnxmMFZc3sjbewytE1HT71GGPZLNecX10A8NWvfpW6qOi7jpQCiURROJyzNE3D+cUFy9WK6+trptPpmAE5nU7HjLABZ7rd7QTLeoBMHeaHhxjFKILj4vMR+dlu3/rWt/7rh1l1N8Wb4f+DIDaIQMP/B8HppqAzCFM3sY+HgtohevNmZMBhA8JwP2nbls1mw8XFBd/+9reZzWa89dZbLBaLcQwPQuCheKVzXc17z/n5OZeXl3z/+9/nrbfeomkajo6OMMZQluWnvodDYfAQKXr4eQ7djJ8m4B26Km8ekwHreXg8bzorD1Gdr8KvHoqgN8/nzX3ePM+HrzU4AA/Py00x7zDj79Oy/j5RS/4UUTLGSF3Xxz8XAiCkMSPsoF8GchlEHWA5EwqfC5IJmWwP7kCxyefcCh/3mQ6DoJjSQdU+IyZNJBHEapHkQTEsOo1O6KQF05AFjBSjFO6VwhmXaYaakN9/Udq8kNboQjMGU5mEQ7pKMeIwVFaRsnuQAEpFjBPHlQ7yKROggmBOUw4hDEbTbjp2bUfvE1U54c37R5wczei2Hcu2Je4aihMoy4pyOsE4SzlTvPnNX+Ty+TPa9TVlLTYipbQIoyZhjMVYRde3NF7x5q/8Kl/95V8EHF4LDC5WRc6RU1xfXvLRB+9zclSDU2w3HSmCLdZYq6AQi1MMIuBhDMYguXS+FwSO0tL5FqVIEHxA+YS24ArJ8ZLTn90DMeB9zAt8wQGmFKWAmVGyystD3q9XqOQ5urUQTKgXB0Esa8rJhKkrKKoatOJy+4zge6xTLC+vcFWFNgYfJN9OGcV6ucYazcnJgmAVvY+U8wWTumB7fUUicn61oVw1TKaGZhcorcG3Pbs8acQlXCFdjbH1GQMn15bP3eClhU0X0Vici6gk2CJnFH0eC3HAiMW9d29wS/kgwrXOhWbpIpdA+qSH/Ba51mNKxKTFCTtglnJXZec9WE2RLFrHnMUw1Fx0xq7pEXuTcndzyqhPnRJJHXQ8p32+5U1h70dVKM5v/h7AWTN+46WX+oQjsPmxdnrzJyaLuYghrxD/Br1PZ/ef0gdurtzCYHQWAE3uRtF6fKmExugy3zB6jM676dlbwAwEHIFecqZoKFyFKyzTWY3Vhm0IhPUa3baYBFVdc7w4YXZ8yioElm1HAzkP8Hwv0VRn9EjmHQAPz3j9zYe8/YUHvHHvNh8/u2LZNqy3G4oQ8ZuW5nrH6uoaXRisg5KC2pp8EIT1jxYEmUacb4lA58XdaLWhMJoUEQexFuxsH6T72eBJzhK6LmejRlxVYEuL2nqchrYVpEr0WUf3Ad936AaUNxADGmh9z2YHHQ1MKk4XX6GeL5gczXEWnu+2cjxuCMTNjeuoOlDYVs05zlWc3DplOp+wefGC9qOPmSzmUMp1YnB5/y2222dA+baV+//hwz2KWKpiHjEB4mBbxKONFQSqBovDv0rp45Po2x9X/Bu0vAkN9FXG2f4Q8e+Hivf9v9AJxGdZYLR1+ctkfDK5YWmYo+lh4jdkgWmd7wWMxdwB46y0ICiNlntlGsgAupDiH1EaSnJu1vghtSIowWLSe2LwFKXDOstsXqPRbJfXpO0a23ZYoKpqjo5OmB2fsPSedevpP7J062t8uwPjsFqEwqSgjx4fe/zxXb745hf44hfu88a92zx+fsmyaVmvN5Qx0q8bdlcb1qslxhlMzhsz1mQ+Ws62UyIAqow7jEkczSaLfM5kEVAOHZ6ECkmeMwqM1fjOo1IkKrCVw5UGvROMYtd10rwSJEszhoDvexEbQkcKHqUiPga2TaSNCVVWLBbHTGdzJvMZ1hqe77YE0wpzuO/xBGLU9C43F7iIU4FCz6ToG7Y0ux1FUXJ8egu/mLG6uqb9+CnT+QyczkhXB9rQ9R7nZMRap6HtRfBTe+JFzDm+6sCN/9IzRmWyhSAOFz9tY+YnUez/LPc5OTr+1ijLpLR3tA1FvUMUTxZtR5fdQSbggLEcMui0VqMQJ7lvOVtuX++VuUKIoytvjxocsvbkmakHgsrhemZww6V9Vp8ZXPdDZIJmP/8bigle8qasNtmlKO9Ba4Mxe4TmIdJSHXQwK9Lo2BvOVopB3k8WBoeM5JdzOOTzpkPn68F9VmeHnlZacv2SILj06FiU96O1HedWQ9aQtSYjxCUnzEdk8R5TnpepjPExGc+bsEbWAPLslmY3eV86F0EzQjVGfIgj/jWlfvzsY/d2UmO25yAyDud9EIOGmr/SKk8CE3vvj5yfoipPPh//n+32lTfufcvoTPJRQwHHj/nm4tIS2pA89IZGSiHKKG2IupD8yCzGp3zdKFtg7AxCj9I+z2lFBFRRY40imUSrjDjf2obQb5nMptSTCcd3jlERLsKW8OIZ9fKa5BeoZChKx/T+HY5+7Te510Sa35vQPH8HvzNCynEOV82JKrLx18TY0Hzhl5i9/VXefHAfpTVPtg1XVxekF+ecxoi+3rH+8AlX548xpcIVicVCCERlKUV4Y5Goj7GSk4jRk1KkdKU0RvuUIzwiPZ6YAr7tcApcEMdk7CVXPJqInsywztE2gsjufJdzgT39tsHvGtrdBrV02MZA6Ejaswuey+vAdd+Spqc8fPAl7r72Oqf37uGc4k+untH/wiV61WFWS7rSo6pTmvmOQEksNkzLLbX6CoUuSP0LLl+cM50d8fpbX8c/fJ1nH7zP9R/8IbdOT/BTDX6H2UpjZ9M2NF1L4Sy215iWce0+YAJDbr7ItvCxQSMxzBP3RcDFpP5cAPyMt5OTk2+Nz6ksxhw6fIYC8HCvH763z9Gy2KF+6BxF4camEWctRVmwyzl3zhXZRS75dYKW1sTgaXuhRrUhYE2inhxz9+5dEfaePOHy6pK7u7sjQvLo+IgvfflL/M2/+Tf4j//j/834ef7kO99lfveU26e3RHBPihgCXXbtfPObv8w3fukbnJyc8uzZU5bLJZeXV4TQ07Ydl5eCCi2rasysc85RFiUxxVHgGwTQqqpwVqgXhy6fAY86YFW1ksZoNdR/9yVxQaKmxPX19QECUOI1BtRfiEGy9eKazWZL13a0fUeMnrIoRXgrC4qyoK5qjDJcX1/T7hpQEFKiaVpil6RR13pUBaqXfOFB/AP47ne/yze+8Q3KuuLp02fsmob79+7jyoIUI2e3bskxyMdhECt1RqzXVc10OsU5h26bEQs+ZsMdFP1HTLw4Hk8+H5Gf7fbgwYNvjM16BwLNzby9m3l4h+65QRS7icY8RFwebq/K8XtVvt4hXhIEv/vs2TO+853v8O1vf5sQAkVRjE2HA7pyyO87FCWHe9bz58+5urri8ePHfOELX3hJvLqJtnyVwHUTZTn87KHLcHA2Hh6LV7kqb4qMw31lwAHfdA7eFGNvYloPRc+bx/Lw668S6G46+4aM01e99vD9QzTszX3fFHBfcpB/yr/Lsvw5QYCmAaUleAedBbc0LOLUfkGUUg5Kx48LzzhIZUqJnojkXkRlRlFRZZEiJsnZGZxPOu8TIxPWvJIdF9Rogxom+NZiomTQKGNIZqAdJjQaZxxWKVSIqEIm/UonHAplwGTxRWILg4hBRMiLSLS8G7RGhURKXpwh+RE4KUoKa4nLFalylEbR+khZFmifaJZLptMp9vSYpmnpLy/oJyWlu0MxPcWUU976xi8TtOUP/+7/k93ynKK0GVeiwBg8gdAplJvw9q/+GX71r/ybvPHrf4bTzUf8/37wDo/+0bfpdkuUUnzcBTYvLkhodtsNEVHz5/MJSotbz5iCkJGceVUumR1J0BaaQOwjyRhUbbG1pbCa0mjwMRdNJG/D2kIKBkpT6MhquyWGDGCJ+fV0JJkkOK/tGoXn+NYxbe9p2kjCURyVuOmEEDTGapyDzWZLu91hlMIYx5/9C/8K7/zROzy92GbBLNG0Pb/x536Lru/48Pd/DzubSC5j33P2lTfZHs+5+OgjQtdw1XacLyP3T6ecnk5Zrhvayw3ThTilkpKJjlMadCRkgVoniEqBtqjQ0Xc90QfZT4jZkZdG5FGKiagEFYfKk4Ugg0KnODIq+xDHqEySISrJ8xOvkRRpEwoV8+VvFDHK7xmNiH8ojE2ooPe5N0plcXZIWpFucIMUm5LK9pikcgd7Rl7mYpV6lYBwzo+VZfbyduDXGpCf4+uLS/DHUUMOf/ThGdSlG+mdesR677P/BH23d/6Zg7+NKcbWBkKPNvJzOmr6fFyi8qPjK8RI8BAxIv46Q6wrSix00NFjekHNxc7j2x1FWTCZFEQ69IsLwsTRFQXBOuZVyZcf3qd9seJpF/DLOdvtiubROc0ZVE1mYWaN9PT1N/nXfv0b/PovfpHXbx/zne+9x/f/6Hu0z55TAn3niY1MbHGSeTgpJ8TFAlfnz2aH/D9RsyKCEkt9wJXFKHbFCBQBVzi0sZTI/VKZ3NFnLNpqilLc3MpHrNaUznC967JzSsQ/jQh+cbclaEs1L7B3bhEvljT0FHbCbDalLGuMc1gLu13L1dWS4RBMHj6kd8C7j14yi56dnTGp5AvbRr7ez6E6PWKujzDGcvH8Gctn7zKpzlhQUZ0uoLBjbh8+EGPIuZAQEOdEiCKAkN1/KaNM9ZB7iB0RoDEK2u2V2to/TwxoD7iGErGGVhWfoI6+eruZ/ffP5vj7aRAW9K3jv2mdOR0XpaP4J/ffweky4PlQSYp+2W1tjBubi1LwmNwBP+BEVZLnmMrNTIKGhJgMRsU8/ktqbWAnWXwxo81j3+ObHVVZMK0rYmpRly8Ik4LWFUTnmJUFX374gO5qzdO2J5Q1zXrNbrcm6p6YqQckRdKOszfe4Ld+7Zf4tV+Q8f/dd97j+3/0J3TPLygA3wd81xF8S1JSkK/risViTlEJLksbtW/KyY1eQwdrVVghKCCoy2QTrjAYbSkQTLXSuXPOkLF3BqX2479yluumzcdSxr9KKY//Hd5oylmFKU9Jl2taGkptcdMZZVVjrUMbTbPbsVqt2e52VK5mOj8iKLi+uqAJO7kbqQI3qZiYSIo924w36ZWiPj2S56QxXDw9Z31+zrSsmKea+miGdnbMeCYGUpeFHGtJGSUZcwOTUml8psqiRA/sCIYpKhGM0Yuf9NhJP6Gx+JPYZ/nFL/4NUxS3hk6rQ0FmKNKoAzFQHXZwvmSxyxmBSrCQKt8jxPUn+XhDoWe/CN4vJmOII/ZKfvcweyiJsIUeXYBaa9IBVpSBYhE/WYAIQ4OjFueC0oqUDOSsITIJQhoUhgV+EhpLLl5INIM0g6ksXIKIHVLYkuw85wRF5HLx4aXjqfQokA74+BglH0fcdhHnCsqqpOva/PpSNIxhL64NRVjBe9oRmUpMpJjdNSNWNwsy2dmwR6TK5xuEyeE8Ct4zZcSz/E7b9iLUxiiubZ9GIdiOmY6Mx2OfbZJd0nkfw/EchGTFgTA4dIxbM/+XZfz/NGz/5n/tW//R2XF9OrQlD80/gudVwID61rl+IRQiiwKr0KYiqkTfJ0LfYKxGWytrP5Q0GPseoyIqY3b7kIg4DOLymZ4ccaQc8WpDEzw+zXCuJjRb+s0l06rm1vECH1ZUzz8iLhzxwR1mpwtu1QXuzi3Kt7/O9XJDmJ6xPH/C9Ysn+BgIzhO0BmpwNSe/8Gt88+u/xGtVSdwseefdd/n4D/+A8vFHzBP41uObLX2/yfcUWMwnfOHBfc7uzpguHG4yRVsrK8MYpNIQe6wyFFYJ4rzzNBtP7z22BE1e5yeZjqAUyhQi+luD8o1kofqCwjhWTUuK4qD3ux1GR6yKxOUFvXNMzhbo+Zu06hkpLCn1MbfuPuD45BbT2QJXai7OL3j00WOWqyUTc49bb71OqxXevcMubUhxg+9nVEf3ODVbrN1w1XZsmw3rlDh6800mlcbYgne/88c8f/8dbkXH3T8+4/ZfepNqMcernj56tr4lrj1l12HngCnG+wVaC10iRWIm6qSUG21hzDlNMTKri88FwM9we/vtt/97zrnTw2KyNMLsHSaHBd2bDg/nHClB03QoBWVVYYwlJT+6brabjTwfY8zPWjMKZNpYClcR+p4u9igta2RtNF3fsV6tKcuSuqrZbDZ89NFHY+7cm/WbHB8d8+WvfIW/8m//Vf6v//l/Mb7P1dMXuNpSacfMVoQk88x/5c/+Jl/7+teYzWbsdjt+//d+n7/39/4eH374KAuXgeVyyXa3ZVLXLOaLMddvNpthjBmL+wMKsCiKEd834sSzSKiUYrFYMJlMRnyiNnrMwjXGMJlMXnIODaKiCAk9IbgR7dc0Dev1hqIseOuLX+Tx44/Zbrby3FJQV7WIblqz2zWsVivee/893nz9DSbzKWVV8/zJcz5+9DEArz14SD2pKYuC46MFVzlPcZij1ZOaROL8+Tnr1Zo79+5yenrK0fExwXvarqXve5mP5fn+4EIqioKqrllv1rLuy+LfYVPZocgiBBD3OQL4M9z+/J//8//hZDK5td1uXxKMDkWbm0624VosSxGdB0zmzXy/m6LXoZj3aa6yV4ljhwLVocPtq1/9KsaIyD1kTx6KVTfxlVL76Xn//fd5/vw5//Af/kO+9a1vcXR0xGQyGR2/NwW0Q3Hw8D55eFwGAXD4e3AID68xfO5XoZUPX+8wQ/BQPL0pmB6ub17OZI2fWP/czDB8lQPv8HuH5+zQ1f0qAXLY16uO9c3r4U8TAmOMlGX5czH+rcqZYdKEmkQAgdxlJ86vFKVQNogceY4kndB5URukv4wU9o4oks8/bHLZLhdYkaecMnuxb7xYkiwMpRsbwBCiyn68jPtIwqjXxpJSxBqDqxy1MxL8jWT3uAHfpI0gRQFUIISeIoHRFVHv35mKkv+Fc8QAvQ9EAzpZyQ+Ikel0yvxOzdWTC0zv0Uqz2zTsaOgTzGZTjo+nOBXpnz5jubrEn92jPD7G1hPe/uJbzKdzHv/gfT5+9x3a5RXB58wPranmU84efoGHZyfs/vj3eLy65N33v8f3/+CP6HcbSNm+GyOu0mLd70LOpXEolej6Dm0V1lkIiRR6glKS82FARcn+iyGBl4m+RlECZRb5koaUAiFKUdBZcQ9aBdFonCvoek+IYFE4remDWKWsSVitcXZGTFDNZ5hpQfCPoCwJ2hBiRvokTQi9CHBGEYPmL/17/xab/+Q/4/2Pvkc9LQHFdbvht/+D/wHu8o/4X/7u73IyPwIa+q5DFxW33jxBacXzdz+gNIHjiVxXqybgSkfTR7abThYxUbAm6EjySgLks31PGyNFouykEFRtFNdj7ogmC3YxHeA8Udn5l3FJSPEhBCk6SsU6O9DyaBmX8UpE9JQFSKWiiKrRjoKDQmGNFCpCls71IATmMaNyh3nMzg8y9nPAVkmxPIv7n3Zv/THFv1E3PKuyWNP8KQJh89Lvnv8pr31+IGG8RPUMgssDO2ZEyh9xu7mc6TZct9qKyzOFIA4vFeQ6MFAkcRFnYxAaccVEG+VGp8U1pq3B1QW7nWVnGnJsIDFAu9xA0WInc8p5TUFAXzxj2WxQ2/scnRxxPKn4M195nfdM4NmjgvWyZkNF3zSj829x+hbzRc2t+3dQMfHx+4/4vf/XP+If/N3fpX30nNJBMZ1gC/A4sIIp7XYNu12DxjLXE1xtRvRnQPI9FYHoA8YZCmsojNxLU4TgobCWuiqk2J3vv9KHUYwOSqU1qmukC047gu9wRW6q0KBtQVlJPmjnO1I0mKLg7P6c6Ymn9x1eGyKGGHt8F7i8uKRfPRrP+snpArCsaMYr4AyYV6dUk4pmW9GcPxovjOnEUs+nBK0JxnJ1UVHRUB8vcIuS2Aei9oSYRb+Y3WMYtAE/IEy9ZCWOjs/hmsrI2TELEKhqO0psP7Iu92NtLyvxFnBuMNveFPg+IR1+uhj4QwT+n+Y8MD2f/EU1IBhHvPHY+8+hMKCUwub7ubWCbzM2O7FD7rKIIePsxLMTVRqzjbW29ElQY5IXCaYw1FbjqoKicDRbQwpKmjW8p1muiFWFqyaUs0r8oRfPWDVr9O6ejP+65le+/DrvKc+zj56yXk6pXpR0fUsbO0xVM69KZrNpHv/k8f+P+Qd/93fpnp5TWo2tKqxTeGXplOQbN11P0/ZoLDM9oaytPMtSIAZ5xumkCN5jjKK04v4lJlKQeVVhCyZVIZ3IOf8KEkXOFBy653zXihBiNNFHbGEhBYxByAyVI0ZP33lSVFhXSlHyqKfzQcZpUsTYkbrE1YsX7K6vUH2DK+ecLmaAZnW9Q8UGpT1WT6nsHaqqYNtc4GOLMhatYDJx1LNpRntbri9eUKZAeVzj5iUh9iJ+JhnEIUGpLDoklFVjJpnggYamtix+aIXO898Bo5hIWGtmr1Daf6YL/j/N43927+5fGpx6o0Msi0RDfptSB/nGeQ2hzR6rThLs49BwqIcFr8349kHleamQqEgH+HRtRGAwRn/CRZZSGiMJZEGciwhxEO50RtjLM0WwmuTrSqONGSksA1FlsCAOomMIEWtlXjkg3tGSKaizZTFmasnhwlvmTDELnCIwGiNOaedsdu+9fAj2DsC0F12VQmuTBUTHbtfke+w+ZzHFkLuvIjHn7moFKmetxpDzxLUV0fPGol6QpjlrDPYCpNpTaqRTW41ooZQChTP0PuYmhzAKfkpBDDo3RAwLeTWGZw/Zhyq7AlTGvQ5C8oADHM51igrn3BStHTH+3Iz/n+btV7721p+3Ro1IOaXiiKBViFvzgPiPTqD7JOtdlzDG0fsoXVUhoXXA6QKdI0q88iijsFqjU0EKil5JgSwYcLXhuJxTLqZMZzOuzktCp0hOE9odq4+f4OcLivkJ9Z0j6riFR+/QrJ7Dw9eYzhd82RruvnGLx+ErPH+35MXRCXMzY7NbsolbYr3g3nzGrbMzbr39Bqd1gf7gfT549B7P/vAPqJ6fsygt1XxGLDS9Mmwp8KnjerflerWm1lMWxzOOyhpXVagkz7toIOmIQVE6i9MOPPS7nt11i1c9s4mlKizRaELrSXhQcn+0zmJzPm7qPbHTGJex+kkISq5QTKsKW5zRdmvaNkIscEXFa1884+huS5silDU+Kdp2SdcGPnr/B6wef4hptkwmd/jCnVtAydMfXGPKLUo3VPUpU/2LTGZTtv17NP5dtK2xRnFyOuXW/dska2mLCR+/M+NOv+H1/+BrzN44Q/kNip6kejqviCE3Pew6dD2gEiOoHuXEHRozSSopnR2AOfNVSZNIXbhpYe288371eXn+X/x2enr6rw2F9cGlY8wni92DCy1lWlUWa1BKSxxEjJiMzjzMp4ohN0+bRFWVY9ZV0+wwRmf3nDh4dtsNm90WpRVWg297nj17hnWO6WxKXdcAfPDhB2y2G5bLJffv36eqK37zz/5ZFos5v/+Hf8gf/t7vw1HJi34L2zVvn76FcyW375zyxuuvU5Ul/+Sf/BM++ugj/v7f/6/4wTvvUE+mnJyc4pxjNpuNqMPNdkv76JF8VhRlVeXmICnKD3lom81mPH5DEV+QdhNOT09ZLBYHtBS5v5ZVCYlRRFmv12Mm8YDHHMS1IWdvmHf0fY/Sijdef4Orqyt2TYO1hq7r2G13lFXJ1dUl7733Xj4XhuPjE2KKLJdLyGa/1WrDnbtnlEXJyenpywIgWQBMEt3T7HaslksWiwUpvwetBAVbFAUpN3EVRUHX9RhrR4IASK1H5nhm38SVaRIHWMm5tXbuPx//n8n29a9//bcH4eomJvJV7q/h30VRyNjNYvMgPn1adt2nIShvfu9QYLqJlVRKnLK3bt3iy1/+MldXV3Rdx3K5ZLPZvCS4Hf7e8L6GP2dnZ/R9z+/8zu/wzW9+k9u3bzOZTMb73U2x7dBReNgAcfg5hmM4CIDDn0Ox7SYi89DZePh6w/2jKIqX3NeH99bDrw2f2zlBqHddR9NILbHKLuZDZ+OnnYdP1IZuIJ0P3X6H2YiHP3MTafqjioDD94uimBdFUXddt/uZFgDTQXbLYeCxdEHrLAWm/QpEJemc14MAIh1z4OSBC6Sc05dGzE3ursKjYiTmQHhxUw2BG1JeTdKwSmmt4F0iGC3B7z7ITdhqhcmLfW0MrtDMKofKC2yMiFKFNqAVGi0dnloyBFXGAgE4BSnTQgMa62QhEV1JagT91iefMVqaW2cnhAA7c4GzJULpiex6z26zkYDYomReOLzuKQKstmuax7UMUuuoq5IvP7zLrRKuHn+M7zra2KNjYjqpqbsV7bt/xPPgefr//gcEEq5yVM7S+x5TFyQ0wfd5IZ6VbQ3KKqxzGGPxXSDEhI8B7QoRMVQSp5mPqGjQTqFMxiVZi3YalTRyBHO+lzFEEqFN6Bp8SLm7wmCankDCaOhDwpAwVjrlfIqkYJgoTb9ZCXbNaFAaQ8iI1T2eLBGx2vN/+J//J1ytGspKCgRDlsjqoz+mbs8F5ZI8MQQ5nosF06MKvz1l/eKK7fkl1hl2faBfbTmaV5SlZXO1xTopkoRoKQtFGixlgxs1RVIKRBKFMwSviNpRWE3vPc5ajJMFUohpv+jM+LmQQs5jGWzpgmnSSmXUomShjPkvSWOSCI1Jgc6Fqj4mbAiUQeF7cXgVubjkoxQhlMqie7Z5aTTxsMCRAScJ6fYcx68iy/V/2vanCQ034/yyDHLT/TdKO80Q7fajCYsHCuDx6cOXb/rmJZ1GJBJNLt0aYiSLgAFMIU5WwEQzqoVaI3mAgFGCu9H5FcXREimMxqsCdEZdYtARbPBEU+K7QL9r8O2WlgnRdFCKsBR3HX6z5OnlM84nc0pXU5aWY6sp799mO5+wrSe03ZY+3MEUlrowTKc1Zex45x/+If/wxQv65ZKpgfmdBbawaFvgCfQ+UHRW7r2ThWTT1WVWS7PxTzzAOe8uEANUZYHTWeT0ojCXdZmxX+BzoVDwsRmhZG0+aBFTFuidxypNZRExXxu0FrGkKAu8DdjOZDyXOK51tuG1QbJTDYbJbIapq1Hqe8g5q6bC93B+A69ZT16AnYOT66iqzjienmIj2N5T6wjzgplZwA40O8LGY4ygPHtavLZYDB1QV/J+lRb8pwwjaTUZ5wvDhcbeHapfKW2f0bz8jv/Z5L/shnRAcHJ5u3FMHv79pyE+f7j491kUFf957MNO6m8OFozB5TfmUmUhUGdboMoWaTPMbQZxQCGF6ghKS/FdGyERCAJT8q1kPmRI3lNajVeWlN2fBdIdb1IEZfA+0e08vm3pUCRlUaUU1GOzIeyWPL0656KeURQVZek4sori/i0Z/5Oavmvoo0dZR+0c82H8/yMZ/365pDaG+a05xll0URBSou87yt5CTMySJPoWpZNCO3lOlXtblBbxL8ZEXZZYI7hzYiL6xGTiDsa/uATNEP2sxK2vELHBlBa9HZwE0syjlUJpOdNF6fBRk5SROZuKGKfR0npLH3o2bYtWmno6xVYVISNGvepZNxta7wmpZ9vMsfWOomioqmuSq1Heo6xlUkxYzObYqLC+p9KJo3nJRB+hdms0HXEnLvpoDV2f0GHAfEI9BIUjIo0eAyXViFkXgSWgghodQNkxZplO/kLabP9vP2sF//QzOP7LxeIbgyi178h+GSszPrjzX4KzGvXAMYfu8Oe1JmfYqtEZmDIwQxyCIjjEELMAxV54GN1lZjSySYNJys1EahT3UIL3GrCVjGKaZKZLpl0YnYAqZ+PZ3Mk/fKrDrEKTcV7GmIz3FdExDg1oB1pmzO6/AfNVlE7EUbNf7IurcC98q6Reyj0ZWMH7HEy3/14i41FlQe3y8UgZRaa1YPFjFu7Iwl7hLEOmvDgLrbhw1R61qtQh4jTTaoZzlIQKk1LaN74Rc67R3hVircZEcQs6Z3MGYczne5hJpsOevJy9bQ5Ewb0IYIyxxf17/3r70cf/95/l8f+zsr39+v1vgeT/GjVEZ0TJNidfCyDXZzKoEEk+jHnUg3CojUUXCmME/WsKi1OJPgWUMzjt8hosEPpAtAZTFuL61lBFjf7/s/dvTZZk6Zke9qxvHdx9HyIiszLr3D1ANwAOBjZjnJFIUMOhTFe6Is1IkWb8bzLTr9CFTKa/IOliONQMhwAHQKPRp6zKzIjYe/thHXTxreXbI6oa3cB0AV0ztdvCOisz9snd1/K1vvd7nzeCzwuZwDQX3v/ixHR6zxnLXDo4BO33PD2yPPyMy0/+N971t4h0dJ3ls33ggx98wv2LWx73e6bxgUucwHfcDj2vXtzRmwv3/8v/zE//6i8w91/yqfPc/M4nuN5h+h2JxDxd2I+eNC98kG6xtuP21R3dzYCEoM68nLXp1YE1mc55ej/g8KRYmMfMPM6EPXRSkJKZl4VlnkmpuY69Nq7WnAATCmmOmEUYnOMyTUBRB2FvGawg0ZJPibioe37wgWgSyzLzPp14dzkjBcL+wCyOcb6wGJiGL3hz+pLTHFl2F/7iR5/Ch1/wB69+zu2towwfIpcTru857l7z2YefMkTYzSO3PvO7n97yvd3vsX/8KcMw052/oA/QeyEtF3JOzBnyMuF8wHbq/kpL0jnKdbVZqC5+rFBSdQG2uS8XOu/c9z/+4F/8yV/+7P/xXXn+m3/c3Nz8k9UhsnHfbMWm5nZrDq5SjQWKrVT0oz7HrIKYMYJzhSzaNBM6TwiaSTdOE3ZZGPpBm+WDnv+4LJTzSAiCM/oa52lE0gwW+q6ndz3v3r3jzRe/4H/783/Hxx99xH7Ysd/v2Q0D//gf/RGfffwp796953Q5kVPieDhgsOz2O5Z55v/z//7/8vNf/Jyf//RndMHz6vXrmim4B2CeryJgEzqcc0zzpGSTUtacLu898zwzzzN9368OvmVZwBhubo7cHI90Xcc8L+SScUaFBm98RXobnOu4vb1dEaDLsuCcW91AwzDocRZDyonzqYqugxb2Hx8fefvuLW/fvaXvO26Pt5Rs+FP+VL/TNPHwcM/j4yOn+9N6/u8f3iLyA5x3dW1wfYQQdP1eHV/N6fjFmzdczufVBdYeDXmuIkGqudGG4DyZQtf3awOUxsY8FQCr0OI++OCD/+JnP/vZ/+u70fnNP77//e//0+duvOfiXHO/tXVpu+5b1t5zTPAWIboV9r5OeNpiJ7fNas8Ft60I2bL+Xrx4wel0WgXoJuI18b7Na+0667qOly9f8s//+T/HGMN+v+dwOKzu3K1wtf3s28/3dY7I55l+WwfgdTzYr2A1m9vwOq9eXYAxxicY5ufnp31eEVnxwTlnxlFdvz/+8Y8ZhoEXL15QSmG32z3Be27Pxfbz/zKn4PPz89xpuBUJt9+lCaPbY7r9/e3r1H93f/AHf/B//Ff/6l/9P7/dAmC+sk1MAVtK7YCqOKS6UW0bwEaUX/nRpuAKWBPJxlDwa8D6NSQexGRsMSRjq7qYybl2VpqsKKbc0FPKgU65FrFqiLu1Bu+kOq50o+ysZQg9e+/xzleBUNRRhcHUTt1cKioMXcjLemFairNIKThn1sKfCHQWTDYE78lZOHaW6TJyejjR73ZYK8zjwtslcjw4ljGyxIQ1kdOyIN5yWhb6MFDcTFwSQxB2Tnj48Y8wCJ0RgjV0tnbTpYQEdaAV7wg9kGPFdFnEC3nOVatVkUec1VxDMYj1ZISUtJBnMjhxWFH3HilTkiog1tUu25QIg9VOfmspS9EWSmsxI+RsVPQIFucK1hTSqAULVUvN2jWbxdAFvZFezhPnhzOPl4jzHnJhnmay1Q1/yRbvDWEI+F1geoxYk3n3/oGYINhaiCuFu8PA//3/9n/FiuFwd1uLA4bj4chNcHjn6W+O9Ls9F/fA+3EiWOFymTmfJqw1lFQ4fbHwQSnc3gykFNVJ6tQSZ43BWQ01pxSscfSdZi56q3kx6giUtQiCyqTq0DMKqEk1RqBxNlOV0cUpdI5iMNYiFS+SJCJJYXRGruJTdpklZyQuZONXt5+pDsC0xXgWfV9TNm6YXDfFlXv/BNn7az1+nfywsYp1YxU/+l8u6H1FPPzlHsCnwiKEfncVYOxXhZjWgC5WxzTo5t+IxZSKbRQhN52w/r6p1/Aa82W1oJCT4IxgHdgsLQqGlBNOQA4d4gLTKfF+jjh2esQuE8F2TBkkJzKJ/JC4/NWPIS7c3gz0xx3sB3rp8C/3LKMlLqnJmIRpJk0zl/OMpMjLG900pFxZ+laFSHLChXbM6/xRdbqyvn/9rjlBTvSdJQSLE18FzYwLghsczglODDEBRlRYFtHu2JxxuTZTVBFbJDF0gfeXGSe6sF5yYl4SoAW4eUqwzEDi9HDhMo9cAqQEweqG5e72ltOHv8ubN/8O/wZi/5eK+Hx2QcQj7PYwXnp6wPueYbDkODG9e4dcJvx4IV8WJI4QwXYLwe4QItqrHynW4X1HFp1vS7YY0YxE0yx+9WIybI7jxgXoLGtA4bi5UP8GcZpPqLtfP7Le4HmFW8bNuFp+LWH+a8X8V8vf+DP+VhQWh/6PJfjP5VrfrwXu6yLdOrtma1nRXMtSM4FyrqKddgHV7F0tWpuS1+xWLfa38Z9xpl7rRkjKG1MHjsBuHxDrmC6JZXEEY8hGiJcRbwfmgtpqSyJNC+9/+g6WzM3twHDoYBjoXSC82DOPllyL/LaAW0biuwuXcUFi5sXtkaEPpLyo6x6zjk3xBVMczqhj3dgqaFexjdJcSHpPG4Kn8x5X8YU5F1wQfO9xztbxr4vvXB2XS8qQNPPPWj1G4lQw2QXPu8uEOHUUKZY7UijEmJnmhMxQiDw+nLksE3N16gTf4W89t7e33H/4mi9+suDnM8vJckmZudxrVnKypEshDoX93jDNFiMOFxzD4MjLhfHdO2QcCecL+TIhKWNyRPC44DG5kGONhRaLd3qjTZVY0YpIpoosKvIpPp4sFFP/rQkDIkjf/WH6DQmA36FCf/nDvHjxn4dh+P51A98cW80FXF3B0lgeKg6ujuG1i7OJelzPc+2L0szPUpGZZXUYXJ1w18aghglVAVDf3W4DSWvTzDpZFaVtaCaxeYKSTM1VUr9X3mApbRXgqC5CLcYLzfnWXIIN6zlNirkqdU6TRqmo2Z85Z4y0rmVbc/zMKmo/3fCyZiY2sbLk2jRmrtmBXReYp0mbC2ve9aZbdG3UWNKiDguRNb+6decao133LWdLz1HNkTe1kIuhVDxzyyhMNaPViGFZUj3OmfEyItJEvrLi4raFAS1oyuraNEYbJKivZ1ooKtssEm0IKDmCMQwvb/7xb0oA/M45+NeIf9/75L/48OXd56ZkxEh1+5Yq1Ne2xybOiyBiyVFXatkIORnEaoOHt1Y3C3U/JCnq/s8JxqnQJRgkRUIsiCt4Y8lJKClByQwezIsd4jpO72ce7ge62jA9ffmezt1ysQ5iJKeF5TTx/k9/Trofef16x+HlHn/3ghu/5/jpC84PQponjLEECrv5kfzmAfNw4ZgSrz7/HsdDR0onxnkhGUfGYsKClAWRA4PtNG/89UDYBwweSTpOvDMEWwjO0fuga/8kVRBYsIPQHz3eQYqZvCguu7KalFA0zszeEDpP7oRoEmbO9F2HyKjjufPIZWSeVXg4nybGSaNYcr7w9ot3vFseuRwGHi8TTgZeDDccX7zi7gf/Ced/+47D9EB89xMek2E2f85Hn8Hju1dE74mD5fihJZY95rLQHQbubjvi5S33f/7nuMe33L7/gnI5k09nzPxAMLcEO2BKYUmPTMsMMuDvPiSWSLxMpKxZx1QgfM6F1FDR1lKk/uS03nO8tXzy6u4ffScAfvOPFy9e/Be73e4frC4fa79SBG9F3OZu2zqAWu5Xa/qw9T6caoN2qyWFLqwCwuVyWe8HXdcjos2s4zhSChwPew7HPZfzyDhd6npDKLVRaJknzuczj6cTxRh+9OO/xIrl848/5eZWUZv7/Y5h6DmfL6Ss2dnTtHB6PPHu7TvmaWZeZm7vbnj9wQcVCV6IKVKKxpT0fc/xcFhdh02U2xa0m2tymibFfnu//k5MicNhr8Lifl+Pld77V7Rf1sZhU6MGQvAE73mYJmKMK50gprQKjm0NvVaS5pn79/f85Kc/5TyeyTmx2+/p+p47sfzwH/4+f/pv/lf+8ic/RpxwOp348v2XT64DfW1hmq7FgT/4gz/AYHh8fFxFCqkLv/adt2jB5nZaBRNRV+lut+N4c6O5kjV/2Ip9khm2FVhEhNvb2z/8TgD85h8/+MEP/vMXL1583jInnzvxmnDVxm4T+1ru33NHW3tuuxaeC03b/2/n+rnLb/vnrYC3/feu63ReCYH9fr86VLdi3lZALM8aG47H49rA0L7X14l71yzPK16ziXbPj9XWBdmyUZsAuP2drRC2HT8t17S9RxMR2/u1ueA5OlQRzGV9z1IKb9++5Re/+MUqlDrn6Pt+FfLbPPLLHHnPBb3nQudW5P06gfC5uNfuIflZDEQ7Xs8xoJ999tkffesFQHURVXSMFEzR4Ozrwbx2niruIVGMrZvoqjCYuqguipekVFZ6obqfFBGRc6kbspYFWP9cu13F6Pvr5lPWwPc4LxjTrLa2bmgTzgiuZkwUqRgQa7WrHbTrXGx1iqkQ4FBxTbwlLVHppDlRrKgrRixRDMxxPQ7WgeTAPI3M04zzGio+eMdDihyHXtsSmdn1O8oyEfqeMQFmwTrLaYzMCB+9fomJM5efvudub3kotVNx0eKzE4PNmTJmighj1rwesYXz6cQS6w3MCpHaBpsKc73Rl2yYlkzOC14Mzhm8LVgDrm5gaMWLrIXO3b6jOwwQM7ZYFbmcUMSSPEhWdCQ5E8dILur4y6W6+LJmEDiL5ialgvVC54XJZc6nL4lZhcuYC1GqINv1eNnh+57j7R3jw0QqhRA8kgulXjPa/Su8+elP6bzQDYFpKeRsufvwBcE7TDE4URHz5sUtb3/yc5acMFKIJeGNI1t1HGq0gaUkyCETs0XIOFEHgC4MwHjBS2BZJrz1SI8izFJUx0gdOa3De8UZFRVWSs2YsdKcVFqgzhVjRVkotfu54cVakclSKDVQOWVDSbXzVYCkTgxTQ8x1AZsQXN3CmDUXB2OwGXItYApcq8RbceBXCQpbl9/W4feGX+r4+zrx7+r++9USxKuNQlKH6TUDsE1g1aCVq/aFKOrSVodfNXSQY6YIOGn/sLkpYBWJ5R1iHWmJGJXYSFDFLSHFrMhbBzYMOqaAmDti6iAl8jwidDipbkEJIAk7g9vt2X18h4kT88OF3Kn4OJ8vxFnxnRAx1hGOOw7HoJtVZ1nizPnxrHl0NlZBSvMPY1KnsguOzlnl/YjV962beJ1TtWjnxet0VbukXSd45/CijRDBVsHDep0Djeb6lVz0OOZMqVNJcB7yrC4gsXhRvIeizc6c7i9cpis6c1YNjhQXUg85RizQdwO8esXy5g2MekVuhao3QP/wBkfP+eEvGetV2x0ODMcBOyXGmDiNnsXWyyQCyTOnpUX76TUTwEwOZMa5ACR8COqQrI5JkasOqC7A+MRxauQ6avp6hf86GNDn3+nXkeB9HZquab3j18uFXxHfnzj+lt/IguHvo5hojvv/Rs3RtQhbM5yo8ylQ70mmQQyq478KZVXoEXRTtwkQbGGqOv6dumJSVESzNHGx5nLlorhI53SusFYdCTH2pGzIOVKWpboUDFksSEBcRkZD2Hn2r28waWZ6PFNCAgfL+UycF3WiUTDeEnY9h30HYnX8L4uO/1wQmyioSw+EnGd11Xuhc45cDFbt5LXxI9c8Z8Fap12tBkpSsoJzunkK4jAl463ULFwVQKxotp/i+2oWTtLj553HoEU0U7MC5zkikklp4vQwMl10bkhALNqIUJak971lQYyh73YQDszzIy4rvWFnepZcMOi8O48Tp/eW8+VcXVvg93v64w47FcZl4Swd0RqsLJC16czEvF4X2gluGeeEMUpQKBScdxXhXer1Za49PCKQpRIvoLnFbHAfp//ICv5/H+N/+PTT/xZjdPyvji1DKWbNbttu8Ewt7rf9i97udYy3rMdC3dA1tbwWvRoNpVQqg6linjpAqguwUlIactNsun9tLQRSke6yCoOVo5ILueULVWGuFayaA7BhP1exc52mhJITKT/tVk0pMk1zRe5WwcvIOu5zzhVxpphfEd032dbpW91zJRewZv0MJW821i2ro84LuRY7fPBM01jRmLqfKxVV6r2trjyDE7cKbRTUvZhbnlvFogq1qFCenT8tSGhB3qzFzdYE0hx6KRWmaVodjnpsmhB5bUo19Xi3nE/FyhYlw7SsECt6bkSd1TW4vp5vCzHR7w4ffzdGv/nHP/vDH/43Xow16To3U7LexoshSyFt1gTGFIro+Ww4oxwjUiK2WLCOYrzunYqu/50VjHUY54jzQkkFyRlXKipYDEu0xJhx3nCzH7BisFm4vb1lOdySlhGXH3Cl7sVshwl7bIjIvTB88pKb732AzWfOb98R+4XiCtP7t8TLiLMBMZml8wwvbnj16gZxSv6Z54n3b8+MS0JcBGbSMpHmTI4jXZ/Z3/YYLywlMEWh6wqdg94VemvordNxiJByYZ4m5nnCBaELAUeBdNGYD++0ORoDcdH1e4zEWTSffiyQIvuuZxccp3FGnCPsBh7u35HLRCnv+PlPHzjdZ8R2zGT9mUfiZab4EV7e0Yll19+Shh/wcPoxMkGQzE2G8WLZd2+YZ7g8HPnypw+8Pz+w5EQpmf7VR9x9+orDCA9x4jF6TunEPH+JmSdtKr48Ys1CTidSTAzHHn+JGDnTDRmCx3eBQiHVeU9v/JWkIEIRUVISOo86EV7c7D78rjz/zT8++uij/xqQ1sAi5en+vQl/rYFLXfRpU1CnYrQtVgLWWW38mieWek/ouo5hGOhCxziNKxozhLC+dq6NNcNu4Pb2lmEYeH//jp/9dK4xSJodGXxXyQKZ4C0Fh8Hw8sVLPv74E1KK3L+/16w+b3k4Par4N04sSyLnwm7o2e937OXAsOt4eHzk3bt3iBhub++wzuKsx+21SH4+n9fCd2vwaWJ1Q6O272krxjzFyDSN3N3e0oWwotK7KoQ2t33K6bquaIXx1hBUC+MiVr/DPBGXyDRNPD4+8rOf/Yx39/faINWK8kXvt+dx5DKpqLMb9teidHDc+jt86Egx8os3v+B4c8flfCGlxI9//Ffr73Z9x263W89XzplxnpEqOnRdt4ocW/RiEzYNKgDe3d3pLvoyUlC6gQ9XAWmLWGzP3+123/tudP4d3P//2T/7b0XEfp3D7Ouy79r5UvSv+crPczfZVjRq4tZ2L/EcrbkV/Lai2dc50ay1qwMRWK/J7XW1FSG332X73bbZdc9RqNsmiC2W9LmLcYsabVmg0zSt81xbZ8/z/OSYfB1OtKH3WwNAe/1t5l77/M/Rmq1Joz2maeL+/p6+79f80vZ5tt9vu+d5jj/dXhfN3dwci+2a2OJan987tq/9HDm6/ezbc3A8Hj/6to8tRxP2DFAamvDavaE3zxqQhbbVV5omqQgYDb3XXC1HMer+MMbRYjU0t09fV0pWDKEIySRi3XyKMWtXbm0bpaSGe6lInYpOzClhjDoCW/i8swZrFeSIqFPOGcE2gSarCCZOkKDOjuBF3URWarT49TO2BlBT1L21LCMpzQRbC2qmdphbw/7YU3Km89UxEgaGXQ/jwt2Hn/D4cOHWw+kS8dbw/u2FHGeGQTuIcgEpmRB6vFERUKrTMUdY4sK0JGLtfgVV0nMTm7IWPCLgMTgiJgmuZuSYUirmzGKqeCtialeyOuBMUTwKlX0tzmnR3Krrr226XOcZ7yfiRUUAYyzidOlsrRAzLCkpsnS3IxVLFzzTOHOWBclgl8oJPj0qSqQc2Q8D5+Oe88MDVjKCwVpPMfWaKQVXu7lSSqSY2b96xce/8znu9kBeIswLnXhK19Pve073D+Aszlp2weNEGMeR8zjjupm+C5jEml+SjMFWllNwjsu4sIyzFkOtLnCa67IUxYRokaUWnGpxKJNUZ62FI2sd5LxixTRGsGZRmdJ4u/ocexXvclaEarJm7TpXB2F52rldUbpFilIai6mB5WUVgCiGbCrGyfBsklt+hRB4dQ89ERmq+PfmVwiJbzbyyKuNuvfmV7FA3+hzf/eVCnHN/N6EQPdMDBRrK4rSVrSj1Y5fWhEw6VxFy+DRzE9RDq1iw0RIzYVZct34anZgiQmbNQuvuZG8s3SdrcIbsFi6/UHzN8VSKnqzGyb64cDhuGc6PTBOMywzS05cHh8gwv7o2O/2mtHXBKk4M75LTClWoQ9idaKtCiX69xlHQj9HjgkTagNDVb8Mlt6Fis7S4r+ROj+WaxYrBkUEGjBOKEWwJSMVM5ty0U7hlLFW2PWWS0zVEWzJwNAF+uOAuEfC2xPjZWEBdsAUQTW5M8v799gQGGzH533PWLGX9HB8dZXLXta/i8u4XhvDh57bF0cOt3vIO6bdCIfM5S9/Spq+xMYRLiNh6Hn787/k5sPPOe52LBcQIsFbjMyAJXj93KKaql4jaLFVLOTsnjhOZUUHv2ke2F/r8Tdy3lUBb+n1mMQno+95tl//VZvtq7/douDvo4D4172n6bt/pkibuuAtWe//1QnEk049bXOQ6laztegsFWfbEOd6Tqvjuua6muqwSSmum1/TMrWSOuUlZ0LNVTXFaFf9UCjWamZr9HS7QR3vRlHpMWW6zjHsDuxvjkyP90zzBGlmmROXhxMUw24/sNvrPS50XnOs5oXxdGKMubqFYFlmBVZLXWNpAi2ZQCyCy9qcY1q2Vf3eIpbgnYqTLQ+1bT4aZaEWxF0VAcUIJRukqIBqqN2BizYDOGsYgmeMUTGpGtxM6Dr6ww7rTzy+PzFdFsgGZxzTovlcJV+ID48YHxh8YDfsiXkhGnBS2HcDF1swJPYWxOn4L8tELpmhD9y+uOV4s8OUHfN+opwj57/6Oen8Dp8yjBecC7x7/8DN7ZHDfiBNCVMiwTlECojFeU8xikqUiomiosCNGM3mlStT0Ypgg3/12zCeym/56/37vmd3c/NPaBv0puTWvUIuRfM+a4NKqw3qcrXxb+0176cOCCWKtGIWV9FtbehSsa45gkvbo0iNEyj6+s7V+2QTEOu8IVW4awXIqlluaAxV/Nq4zJoods0nLOjeWsWNmDLb6OhSCikm5mlhmWNtBNP1e8nlyYEtRb+LtQ3nrV0smuXrNkWI6pCsjZZrR1o9dimpO6hiMAnBY8SuBQHn9c+unhvv3BOBFCOrM0+LqyqyqfvSULIiuVgblzYFD6tZTS2nMKeyZv2peGo4HgZd26REtppHbp1mQGkD17UZjyqqanEjrefOYEj1fBejLk+ped5aCNDjE/rw8j/E8f/b9vidT17/p02AtSI1mzpqDaEpx6XSO4zV3GkLqv9pQ2tKum4U5zDOUkymkJUWIJGC08ZQayitqTAnbeRcFnIslDkiy0xXMpKhFKH3nru7wiKWvHi48XSHA7bryMaRRWMhhp1j2N1x8+KO6f0bxvmCpDOXy8z9m7eYbPjg1Y6b255hN9DvekqMLJczj+9GzjETU8GUzDw+EvOo2SXFYH2hGwp4TzQ9l3MkJHXk9d7SOyFYjxev3zJRC2RL7dq3dTwIYhzOVmexOL3jW4tPC94oXjUnRzyfSSnR94F96HnvRuJFo0b8MODdQPfyBaZ7w5u/esPj+5E8FSxCeRyx80IZH4k/6ZHDkYMb2A23XMYHfMl0ZuFu+B7vyoykn/G9DqSbyMsJM58oeeLli3/IJ//gcz78/DU23fHm7nv85E3kF/+/f8s0PTCMj8gXP8P7Hf/uL/6Mz7/3GZ+8/oDT+0TJZ4J0IBkpA0PfE3OBlLFev7OpIhLWUCoZxpRr0fnusPvgu/L8N/+4ubn5Z614vt7XNgXtJ26d6u4lQrZXJ0M2Sd3CFfuphKD85PW893R9R8pJBTavheOpFspjjHQh0PcDw9A3FxjTNOlclDLeOW5vbghd4Pb2BSlFYsrcv7/n8+99zocfvubt27e8f/deMwnJfPHmDc5Z+m7gcFA3TBcCS4qM48gvfvEL5mnBOcvOq9Mv+MDheFhdRq2o32qoIro2MaJO322+mDoZJ63T+UDXdUhtBNKmIIdzGulEgT50pFIUfbohFMzLvCnmF8ZxXAv23ns+/PBDvYeXwunxhPeBDz98zfv373n//h3LvPDFF1/ocfcdn/6Dz5jHL2s919fmTsOr1x/WgB7Dl1++fXJtfPrJp3z88cd47zmfz7x9945/87/8G0oq3NwcyTlzOBz4kz/5Ez759FNe3N2tLsXD4bDWwfb7PcsS17p3P1zzyJrA0UQgzQwvdF338rvR+Xdw//+d3/mnzwW5rVuuCXINqdn+bvvfT+oJG2HsOe7xubDUznn72QqMW/FwK5g9bc5LT95jiyneOg+3r9fe57nIuM3X2+b3tb/Xe/nTz/fcVQisLrx5np9kAj7/nfZv28+z/Ryg64i+77+Sw9jGTJunt3NscyS37MCGBt7v9+s81c7dVnBrc81WBNyOS7txhjcBcFmWFQW7xcO2xsF2/LZ/btfMc3fgVtgtpXA8Hl9/+wVAEUy7gRZWxAu5dmHWSrepTsC22M5cN9qmFY9pYfFNdqjTac5QMtYanBMtoBm4xMreKwsGvYE2sTCTKalUZIx29QmlboIzXb0grRj6zlW13143CW2T54xuzmv+TzE170muC4ZaV6v2fTAp1Q16wqVEKoWSIr60gPEqlBo47HoEIWJxvmceF0I/kIHXQwDf8/q4p/eZt+8XhkPPPO35kEIvlt5bjDeUwfPydtDuWWORkiixcD/OxKROMSeOWNoGXCBnUilYp52O4jzOC2IyrmQVFavoV1ABNNeuWls0I806r2Kb8l8R47G2ZtiVqMcuOCQBJSG7jjJl8v2sOYJ1/5VjwQdHAeZZXWs2dAx7IQaH+IAdCtPlzFzG6j6EPF+Yv5zJYnm5D5AG5mnSjD9kxQ5Y27BNmcsUObz+iD/8P/xnfPi9j7DOcZ4XcIHuxQ10ljg9Es8nLjmRULSJOC1I5ARpSZQQKcmRSYiV9fhgDMFZTG8Yi274KQVrNTA+L/X6ylqCL7ngxJBMFcRbF3kdA7lkXZjWok1p3Kkq3jmjpr7UbjzFVCdfFQJL0o2TtpCDyfV1zbXLqxZ6S9li8mqXgxFkvRFcQXrmiZDgv16peAW/1D30NxQYWq5f397tV4iA7V+G/pUe7xbfZ1XAqZ6oNc8vCwSa4GdV3K7ZmOSMiK9NBJmSpRbEAONVCMuZEkfMEhESVKQdNR/OVVEx56rGOAjWcjwGrPN1rjqCCM7K1Xm375k7CyUzXx6YTw8ICd8FPBbhSO8Dh9s9zglxruHa6E1pSdV9ZtXtJ/Z6c1Uh0OmHWcXORO/UjZdzImWLFRUujba+rYAu4zQTVclI+rlzu85KJhfBi1T0EroRjur8jVFxiMEHpvmihZU6H8xLYug67j74gGE4MC8z0zyzPE74xwsWdQPmhwfoPL3teX2z4x2vWEZ1ATbJuOcN517FwHFUVfjlH/9T/ugf/x6ff/wa3/JGTwtynsnnzNv7L1Uu8yNzhJuXn2PdjvN5ARaGcEOumFIrgZjUmWQEvAOLJc16fCPpqjTnq7PUrW68NzUD8JuAazYb39dhQH/dseififz+76V4+Ld9L+n8D9YMH6Nuc8Oz4rSt+cUNs1dd3K2houHbxDbhoHbX1SIhUiW/OGLSouPdaodb62SyRgX/nKnNL9pQdNh7dQ9XvB1G9PcwNYNIWILmT82ne6bzCUh0weON0/EfHMejiv/LsigSNGVF6lZhoxUZrBWKUbd/KboWMNbp/xvN+um9osVzzkpDMBp0r80hmWp5qmKX3mPFVnxq69wqmYwW5G1tnMAC0dTxH7Hi6Lxjjot2XhcVVec50vcDtx90DLs90zQzLwvz44R/HJElEzGk04O6HFzg1aHjPg/M80guhtl4kisEU1hESGSW6UIphZd/8If84T/6PT7/+JViS3MmnWfkNFMumXfv35KqGyvmzPHmBus7LpOuW3rvyCWyRKNZsNasqEHrjAKVTca2rGsxjVxfm0kK1tmXf9cF+W+z2Pe3fa+w3/0+q6uvrOhOYyqtYS0G1q1L27vU5gBt5DFrU4+jiQKloievG/jn6Jcmr8tm86sbRN1sr45R25oQzPpNdb7abJS4bsa1ecas2YEtR6/Nc23DGaMiynJqm14dm9rlqs6/kvOaI9j0xJhjdS0UYtRmAFfX0i3XcJ1fm0WiHq+UMs40IVM/b3q2CS4lrwKad5ovFLy+TEqZFKO6a0ttKmjFDWn5K7VoU/MTm1mrCattrpcVzy6bDMe8Hj9jhBCcijWVFiLGMi+VyCGQUqzrwZYLUjZd/aZO7w0DmutYvyJkxTT8Z3WXaDYF1rvbb/v4/zY8Pnl193sWzaFVk3/SZhS5zsfWCIgKvbmORzG6njMp12ZMW0XCVLE+Rv9bnDYA5xkznjDLgilFIzKWTMyJskQkJzpTSMmQLpkcCp333N05xDuM6Sj5hmw0qz1jSVlJGgebIS/E85eMD+8gzwydJXQD7nuvOQyBl69eEDpPWhb9KVEbAKM2ShdpWKuCdx1EwZiMHzrC/jVZelKKHELmdgfHYWDwQucdQTosFpIhLkkjB6zF9aJEIzGaFUinc+WyYNJU6QiO4D2hs4h3lKhX4jItxHmmC4Fj51jmxJKNxnmMM353x+vv37C/+YDT4yOP5wvnX9xzenOPHSdOaWH6+Y9wp1sONvA7R88vlgOX8T3LknhAmAbPC/mIsd8T7cx0fk9OhY/+y/+af/p//j/x/R/8A/rOcY53FDtz12fy28zP/uLfsNgO4xRL/NFnv4v0R37+7qSuzf0NUzrBHHHZYrrx2vburWIAUyNUyZoxoY3u2lx2d/xOAPy7eOx2ux8218zz4jw8ReKtTplNEdqIEDa/p8XtvDrcnXMEr92y86zrVCuWvuu1gFxxfv2gQrExQozLio/86KOP8D7gvb6Oqc12rQAdOs9+v4cCP//FL3j79i3LsnBze6NriKSOs5cfvCT4jnmaGKcL6Zxw1qkwuNuvONPdbsfxeFwRh89FPlM7ja4NK+VJYfxyOatT3lq6EAg1DkmbYWTN72sOGqn7hFa417xfdSU3LGMTC87nMxjwyXNzc8vnn33GzfGG0+nENI08PjwyjqM6EZ2npIXHy4m+H3hx+5IpdKS4YIrBiicD57E5MgtfnM4AfPbZ9/jv//v/jt///d+n73uMMfz0pz/lpz//Ge/fv+N//V//tNYNLX0/8OrVK7xz3D/c83D/wN3dnQoQGwHHOUvXd6tL64o6VJx4u+baMQ0h3H03Or/5x0cfffTD7Zjfut2aWLT9/+fYzK0j7jlO8jlK8zn6c5vTt3WSPX/O8xy55jhtOZsNa9l13eqKW5aFEMLqENwiRbefeSt6NaGqvf5WDNt+1q3o9twd1z7X81y79hrtu2/n2q1otnUhNpzncwG0iZHPGzSaoGiM4aOPPuKv/uqvOJ1OLMuyuhG3rss1mmPT5HA+n9e4A2MMwzAwDMNXcKxb9/Pz83a9D6QnKNTnAuD2GD+5v5TCMAzf+vHvTM2RSLU7tc6IetEUyJS1O9YYdRc1t9zaXY4KZw2poU9cENqgizjruOktQsIZmKPm4wQnBOmZ5lmLXK3LCs2gQQSLIaeo3dkYrNcbgxdD7x3BXW2v1tVsCzJZtGgvxqgLq8WjtRwwWsZHzXWjkKaFuEyU4iiVgp9yxIjFBnWBWKNF8kIG59U5kCOH2yNx0Yt/AjpviUumC6IbhRthfDxhHbz46Bbnhd1NgGVmnCLDrmO5RB4fLyxZHX82BFISZEnUdTci2q0OEZMKYjsE7cC1xmDFEpxm6FlpGSMKrLT1fFMMOP1OzgsYh7MB63TAUQdH13W46hiUbke7HPCWNC3aNWR001xImqWQLXmJVQAxTKMKMk4MyXbIYFhKJmfNWow5UVLCOcOLfSAfOi7TxLQklppHILYDI8zTzAff/z3+4b/4z/n8B58jcyLNk4Y0l6Kl7kVRbMdhx14s78+PPM4zITn2wdN5MKIuVc1/yxhNfqjIOMVx+iLkrtqoUsF5o50bwSkitWI6s+4TtVNb/Sek2mHWHFUmi24qaBOIVSxnSTzpTymlZvm1cahCY85F8+SyBt8X7DVihq3o125een3n2p5eTEGM1a7mJ10vXyMmNEHhzdfoEH/tYysUbuSbNyOvXvUcq5PJAZeq8Lx6pQjF8c2bXyqduN1xRX/quVDRS1gHsmbSVIVQGf9WBd2srjXnHaVa5qqPsqKJbc31UWxrnKcVrdeOq5MqbHUqjlPNm7m2QYQqRPjgq0inVYlsHKZAv+/44PUt54cz7989EIaeFx++IFRBeZouGt1nLSUlzmUmxkTKkLCYXq+BOKvq2ATAPMf63TuctzgB31m8UJ0D6vzzVfhzYjUbrbIsjbOrS9rogVMxsKI9YlL3DQZ1NDVnpY3VuYAiUUW7+lNWfr4VWOLMdLaErqM1WXYh4G8C1jqyfSCdFsa4YOMC7szB7bA3R+6rXuWBZvjz41U93v3BS37wO9/j9QcvEQwJw5IMaR6R85mjW8i95xIV0Emslwwq/s0RcorE5PTckUhxXhGfOdsnl5upYnLOVycpgPM9temx5gC++sZu1Mui76Lv1/8NnvlU/NNhvXyji4rfdJHSePe5MWZ16JfmzJGr3eeKy7hmO+g5U2eJrQKZ5oNtMsOMrS5qtOM+Ler4o2ZhVKQQUhDrVwS5rhvUNdJpFb2Of8uSqOKarhP6fcfu9R3nxzPv397T9Z4Xr24JziK1c9ZRdPznTJ4iKSZiUrSZCQ6Ty6bhxtXOWlUh7brRMfhg8aJ5xoqrMoo9RhHnWtQq9fjIiixU4UHx6FSsYE6pWmF1809FrUvFldNcSmJxYkml4EQqLi0xP14IXVdxoUIIHf6omJZkhTwqgswsE0Ysx9DhjgceL+r0sRmmmJBsdK7PCfE7dh/c8Tvfr+PfKL0hZiHNCblcONpE7AJjmhFryEmxhKbEWtioGUcVu21yJsW0usFKrojtZvgzgthCjqUiAfX3nLOHb7O7p3xLXtd1/adUWud2zK8b72y0eWfTGdzwnqtrUHTzaq3V9eQTrE1rEHj+Da77ntW9xtMcCNOw7KtIWNZcQqrrLuesxfUq/OkcpE4FU8r13bbZEy1zvX6+XMoT119KiXleakGu5guu37suSIzZrEHNmlPYCpT6WVtuXzs+V0SOiia1+aFmgqbUcjKvGYreuzVTSEUEQ1wiIxPDTtaGOGNqTETN9jMNsbfJdWzYYpqDs6KdU85Yo7lHYqhuwLQ2dFip2fD5KvBZa1kWxcGvDghr1fW7FjYq/rMKnyo8ir53zSApVpFxLUtVaq5313e3343/b/7x4YubTzWfGt0v5YK1HsRhTFS3vxiN+TB6/9GqhOLqjQHxneL4ja5pi9GmD3EesiHHREwjJZ+IU4aiYqLGXxRcAGt7denGFk0RibkQsrrTbXDkIoxRM+SScZDB93A87rk8jrx/e8b3hpsPXrPzXsX6eaITdcTGGDmNZ5Y5MUcYSyE5bThKSybNCes7/b5mpvie/uYD+sMO1wnDENgPhePO07tCcNo4bI02/7BkypJV3HeeYBT5LdhKUBFcSizzRIpzxeEN+L7HdgE6iylRhVNniSnRJdiFjkvQYmDsetKSWN49gu0xOYAE+sHiXwe60LP075jf3RPTQjq9IYSeT/c9g3vNu5Ni++yceBgnXAm4uMcWj+tvuPno+/zhf/qf8dFHn1MI3E+FS3LExxPDu3d8aE+kw5H7OdPd9CzjSJkj1qioepkNcyqMWZCoTV/FiwqizpBzIKcKZK8MaWO1gUtqc5mIsBu6/Xfl+W/+0ff9J02Q2RaTWxF6W+i+/lmzJ1W48pXskZg3LjYfAlKd62L1Pj1NE6fTWfcR1iI1Z886SxdUVGj5u4WiJA+g6zoOhwMhBKaKtWx4vA9efcAPfrDn/ft7fvzjH3NzvOHzP/yM3W5HSolzddN2nSIvl2UmJW04P+wDd7c3lXylxenj8YD3Yc3dTasTxq1NLo1u0IhZ7dhM08g4TlrCq/uGQrs/mkoPUKf8ViBoMQExxtX934V+LZy3c7MKA7MW5/t+WNcxIXQcb/Sz5ZR5eHhgmbW++ng6cXNzy2534Pz4WPcotXmoFGJaGGMiOMtnv/O7/Ff/1b/ghz/8IXe3txhjmKuAcD6d1uam0+nE4XDg/v6e4/GwIg/fvX+Pr4JLCGFdozUBRQUZ7Waapklrgd6va4MmxHwnAP7dPO7u7j7ZClHbZr0tlnMr0HVdtwprzzP2nmMxvw4p2V6v/TwX5LaiXBPjpkkF8YbXbCjKh4cHLpcLNzc33N3drS60vu/Z7/fs93v6vl8F/SacbcW/rei3RdpuXXrPcaFfWe9txMnnwue6N6pzxTb3fJuntxU62/dLKa3Zf21e3gp5z0XI9v0//vhj/sk/+Sf8/Oc/53K50Pf9k2O9Re9eGyIjp9OJt2/fatNhCKvzeOt83P6079y+3/Pjk2p26bIS/viKy3KLQ23HpOu6w7deAGTl5qvrTzcGpiKmamGIQhHt+tSik7LhTYFi1GFTchMfmouphj8ntboeeuGDvSNm4TxNPE4zJWtHqFQOszOGJUVSzO1VIDXkJmSjxaYWcu+8Y+gd3gmmFnNs7SZl/TwGU6q7S1gXcM6IYjwBm4USs7qwlrSihEwt9BhNwub40QviJWJK1rwAIE8LRYS+63FFcy9SUQdO3/dghHG85+6Dj8hT4l2A18ORXoR5PLNMI7EUJMP0OLLMUdFlzsOcWLJiV8UrBM6KJwIm6SbIhTroS6HrjOaVYehcFV+puXemNbGZFjKnpyomfO+wpZAKmBixol3zmqcIeGXgI6wZQORcM5iMdlZKoiTonDoGxzmTlsaAXTgvmRK1o04LhZYFxYY5R72mBIe65Q7HPcUIWSAuBdd1a7Dvh9/7kNvpkYf/5d+SxoU4jSwxkqeJNF6w44XbzhEdLHNCSs/DNBKXmZPJFDwShWXJGDLBuXo4EtbULEgyWTRLMicVsAuFFFmlt1xKFQH1uTlrhkCqOZZrl3XLkzFaoNbt1wLFXMU7067Wsu7M9fXNmh1TqutPMaJClpb4x+q6LbROi7V2qwjTWnjJZSsX/orHq6/78/jrCRBvVNxT8Q+OPXx445kjTMsDDw9vnoqKr+of3zzVHV8BoferIJOrA04sZCKSXb2ur+JT++9MxXW6WtDaIENNZeS3yavUInEuNddUVBSmzkW+005307JO61SXF5UBi2ghTJxDYiQMAzZ0TOcLXuCmH9h3A96psHh7c4PkxPT4wKVElnlhHheWaSTNqZqmU72x6TiUNd7PEklkq7x851Swcl5dvZ2rx8FUVnf9vtYIRa6ft+GTRYSSIpSajRB1frXO1AxLh6u5gJlCjCql+uCIOVMi9N5qPonAzgbOeWaZLyzjTMqwVNFAasd/sgNpK0RFFZCPu4H9bmCcL1zGhQdGvP+cm+OOYB1zguH2jpeHA8TC6XzmdJlZCjx+8RY5PyB5phuOzJcHiAvJAXEkjTD01cSUFlJ0ZNtV+JNdcyOb2Geq08+CZsVSxfh6DdmtOF7/8ObXGlR/E5fgq9/Aq1xFwN+UP/HvrHh43P+P1tldy+dqG1XdtFVxr86dVqhu9gpzK6zXt+bmXp3PYuS6vsmKkFNnSftmteCbdGPgO4cPfsVAGqPkhBSTNgOJwXtXN+ERP/Q4H5guo47/YWDXD3inc/jd7Q0mJ6aHe3yJxDnq+K8ZGirU61wtokJBFsiiLoaYE0UKzlXxT8DaQjDQOcFV90xMCj1WB69iorUpZJMvYKjj3+naK+m9XZwWBNesMKF2xWVszVhYqvOm955x0ezPnXOcCizzxDItpIRmF1fRMWMo1hFZataqgZQoc+Rm13PYdUzTwmWaOV20U/lwuMF7Yanj/+6wh5Q53Z85nWfmDKcvvsRcHjBpod8NxJOeUxFLSgtxzvSdU0xhTMSUsbUxCfT6kDovllwFC6Pu/qVilUzZdFVa+xstAH7nHPzqw37yyf8g1u4bAthU/mNOVcRrG94N8dKYtjk3FdtpVldZWxxt113S3L8tA6SZ4XiK5ik5VYSlrPMQ6+9d91GyeY4K9mbFjatgKGsTVim5/vcVSVRKdRqKipUpxauzLmkG9TLHNWJB6rpyjVzIqTZ6lRXhJ09wQG2XJ9f9QJsTuaI3W6PEWgRoouSKCdWmQlM7pfOzYmypXc5SGzBsjXCwdQ5r9kcdZ6zr0gJrfrbUOcc5dVTImrVdF2HNFboebbO6Q+MSay7UtdBhaFQZ8wTHamoERa4HUddEqa5/qEXR0uA4WiRy/vAf6/j/u3r87/7w9/7H2+Owd85oJm+qaGureEqqmGzJiFH3ZzEqziUyxYiSP5x2AzdBOyM1B8BAjJRpJMdZnbapICZqE9Ci+bd+8HR9FQBTohRDXiLLFHUNbA3WO1Iu5DxRfIfrDPNpwqakWXz7jDWOlG45Hno6MmUcSRfDPBXmx5HpMjKPo7oMK2ZfjMHngs2Z5C2uc9rU6Qzd8cjh0NOFTHCFG2+47SyDdzhbXbS57nlafqoDWxwlobQgKZgStc6SCiUqTtiFACKaGW4tOKfCfzbr/R9jKDHTOc+u8+SyINaT8o7HhzMPX37J/ePMeVrUWWsNyToW2zHbDmesNhgXg2TDZy9u+OT1HY+nkS8fHvniy/cMw47Xrz+j6y1jMhw//gd89vI1Phbe/+RLHk4Tl2yYfvJjwvufEMzC7cuXpLcjMUVC6JnSiTidOe4D0WoG8DgbOueVklTUNWqtkKOSF7y0HBilr5iS1uMoYjjs+m99AfC3Xvz/8MP/i/f+0Nwnbc36PJdp63opgLQajFFnqxhZs2Kts1gsZtF1ccppLdjHmGoNQPN3xstFUZ83N/S7nYpRtZhsjMFdHM6qSKBung4jwm63w3vPl198AQW6ruf1q7CupT/+5GPECA+PDxhjeHx85PF0qrmc8ypEhRBqUw01ly5cEdn1npxiIkVFYIcQ8M6ttbJ2b2tF9FT3M7Jx2bTcr2VZtCRYsXmaF2jXe7dm5V6dMqHmZo7TyNAP12YjYImR+/t7LpeRZZm5f/9+LZqMo+b0phg5nR9ZSubn7x/4rBheffCSYX/QfVfSLPbgLbvdC4wxjI9nXr78gBd3LwC4v7/nfD7zxZdf8q//9b/m3bu3nE8nbm6O3L+/Z6yuomkaGYYB7z3zNPHTn/2MaZ453hw5Ho8EH+hCWI9rOy5bR1FzR20caN13I/SbffzxH//x/9B13X6e56+gP9s5aTlvDfH4PGevPW/rTnvuSts2EGwFxa2rbisYbQUiddVedAw/PnI6nTifz6vD73Q68aMf/QjnHD/84Q/pexXOX758yccff/zkPbcCY/u8W5daE9zWXNK6j2ifpx2P567odj1vmyb+uhzB7bHaHqMmpm3F1JSSrgU2Im1zBm4xrM+zNNsxfvHiBeM4knPm5uZGTUf12MO1ea/dA87nM19++SXTNFGKivT/6B/9o/V8/zLxsx23rTC5/bf2ebfHox37bRNF+97e+923XgBsffVmc8JNdfO1XDMV9FhFhNa1qXtxReqt0Rz1ecWoiCLWsO8su07Y94HLNPNQNL8nE8lFC2ekwlK7LI00znImVnyoVKHQCmt3TN91hN7hrSPUhVuSAk67XY1Uh08VPUrFXhlq14zRwrPkqFkvGbw1ZHyjlgIQrENswc4Z4wRTBBe0g2gyGWMF3wWM6ygpkW2H9R47T/hdwLCjXE74buB4c0OJmltBirCq8SqCGmu08z9p/scyq1iWyXgnmjNUCpi4ikPOFgbvCNYr6tRkJF8Rkuryqe4do8V/Yy02gfMWTCHlWV1GUdsZJQSsq86fogXCXPFKac1zpOYlaM6KZg0ajDOkKlLmqI4FE0diTBQUW5qyhhgjZRUpMAYbqoNoWsB6cB37veeDD45cUiaPM/P7d7x5eMsSI75OyI/nE953VfFSh8OctfCYUmIQRwyGSGGMC240dDaCs5isJX11+gjWG8qiwtDgDKkyz1tBKcu14NMMkSm2kJdSsyNAcqnB9MKaWUPGGK8o0TJrwHh9qi7owJpCroUoSiHmRKhFHM2easUmoeRUizzmioiq47VUEUsK1TFaFzdPygFb99/y14oHLfNvK/L9UtNTzQZ89Wqk73sGD7tOX+t0rq6/Kkf4Hhjrf7+CVxsRsK9Cy2q8sl99q0yFga4OrfZrVgUArd4h1bVnTHXx6ZIWCnhjVYMygrH6+6mKQBbwRtn4igxiRQzmWfGc1jlMzdLxXl3IwVm6XafXSprZDQNyd8OyzEiamU8n5suZsuT6eTL4oA0MKUHNHFwyFJvIyZLrQsTUMSOi+E4v4IMliMXpxyehYYFGFOF3raoKFkHc1cFdqgsml4SkqMhe8bpZMjUrVRT7Q91IGLQT30umRK8uZAMuwE4C05KYZ80FnKZZczqpGY5zxOKVxOR0Hl7iQjpD13luh4HdcOSwH9kd9hxv74DM6eFE6Cyc7nm4PPJ4f+b0cCafLkz373A9HD/4gLALhBkuo14clp5QryNxenjnS9Rz23WK/PVBj1JuyE9bcwDbn/UiFDQv0PqnQ+HXe7z5teW7N8DnvGEZwfev6mgYv3ZsvsI/dfatY3P5W4uHvw1ZYGbo//eyybK7ltXLWv9dXT4V9a3rBb3ZiVFRkJKq26ZUIUAL5IZMyeCMJWaqO8SsmXhitBAerNTCdcOLauExLxU55mx14Qg+1O5SZwk7RQIRZ3ZDj727ZZlnTJyYzyeWyxmizkHFFAgqIppYM0e96HrAFi1MGKv40hwr4tLgbME7xY56sbh6r0nVMWiq+NcWd6a6/lq3sIof1fWXC5I1y8dap1koxihlWGAZI+SyOu5FBFtZ8aYeb+cNO/HMk2FaNGdpnBctLJbauR0TDqu4TSuUlFliZrpcCL3nsOvohp7DLtLvB453t1AKj49nQjCY8z33lxOn+wvnhzPxfGa6f08YhMPLl4TdQJgunC+Lzn/W4+sq0Nd75TTOikLvDN45rHfa7pZbPq/BSJ3rVrzi1YnlnN39pq7z38aC/2/D+A8vX/6xWQt7V6S6bd08bTNLUXdY1rxG57TL3NS8OVP3D0W7tbSRx6zUy6eZIA0Nud3nNGdxzYm0znLFQpqVmmKbEEdZf79hCnIp2khTi3B6d9kQGUoT4vRDxRjXz9AceilG7c6viN41r3LtZo76uzldP0+dD8zajdtclKz507nuF3IpSiOQlrWSn3QBbw55HSK1EOMdyzw/6cTNpTBP09qEkVLEB8W4Xd2ObF/sim6l4p4qrjylvHYZuzULsO5ZK/I1Z23ezO3vqxNCqRkt61QbDEV0fd2KoZpLX5taMes6UskbpTpEkjZJthxZkf4/5PH/2/D4/e9/8p/1g8dZ3RcJGSO+CrG1wNXiRgpISVB0P4+xUO/JGjNSNvsgSLFgWDAJPLZiYAXr1AWu4rxmjHbW0fmghJsuUIyhpJk4aSZ3MlYdxznjrCfniMcy9Co2WjF0FRMe5wWbLrDMMI5IcoAlyUzqLdbvKdNCnGZ62+NTgaC4auyAdwFjIpQFHzy7UBh6y2HoOAbhKB6PQ7JAVLevUPHnTvdEZG0GlASiQRaUnFguE/F8wXmP73oQSzAG1xeMXyhJ6r5EHZlSu60tlsF5Ukg4k8m2q2sOx1xOfHn/QE4z1ghLzEiEnh6xEyFo/WeaEsvDPfvbnlcvjuxvbvjog9cc7255+emnkDJv376j3xX6t3/J+f6n3L954P6Ltyxvv2R681OGO8dHv/tDdnc3XB6/4N35gvieLhwYcsHJjA/CsiROj2c6I3SDMASL3/dIUddnSqUSZZT3bsQitqKkja43d32347vHN/p48eLFf9mK78Zc3ZetILstcpdybbZp95WcFUc950xclrVukjYIPer93Rih67QGNE1akDZicNYh1uKsxgt4H1aUtmJJcy1quyqcBcQInQ8cj0dijIznC/vDnpcvX5JzYjyfOV8u3D88kJOuMTGGfhjoh2F1m7haPF9xhs7VLF7Ff7csLwr03UDXhdUR1zB/tjbdlk1h21rNvV5dPTGtDrl5mtgfDoROv6drAmpOxHjNDmv340bPMBUb7p3e45faSNB1HV3f8/BwzziOvH//nvF8xhh4cfeCmBaC0zl9nCY639ENHdYaHu7vubu75cXdS0opvPviS7z3vH37lj/7sz9jWRbevn3LX/zFn/Ojv/gRMSe+//3vE3zgdH/P5XImRg/FcLmMvLi7Y1kWxnFcXVveefo7dWA1MXTNHd5kyzVxZYMK/M4B/A0/fvjDH/7xOvY3P03QbnPDNuOt73t1dm4Evq3A9XW5bltxp73OVvx77gzbinGXy4X3799zf3+/uv0ulwvzPK+O4cPhQIyRH/3oR7x69Yrj8fhEaNt+pmuuJuv11t7ruUj3/Ptt3WrrHFKdkduGiSbCbcXErbi1xaE+R6O212ki2lZU3AqzDdPZ3LVm03S8FWyHYVjFPOfcKgBuX3/rLjyfz7x7946c8+oc3Doft+f4uZNy61Z+/l22CNHnLsdtc0N79H1//NYLgNCQLlrsLpu0ei2wVUDimqdx7RKtNbZ1A/VEYdcdL95buqDFufO0cLpMnC5zRfEYliUi+wGbC+cUyVUEKaVQUnXgWUV1NTHSicFbq53uXrO3VvGlOtQMWQs6JVZBsWBrR0kRg6moGEqk+Rylct6dyeq8A0JXlW1xirtzsgp1YoVu1xOCIC6wxAIV82hKIS0TfgFn3Mov9yVpeG4uYBKucxgsk0/kHDGTUaidaGdxZywxq2AoGJZs6ARYCg1U6LxVF5tYvImkRTfNAqsQaq123y1z7aJCm5waBhWvMkvKiZwWOm8gO3JMUDJhEKy3TOdpLUjQgsNFKERsMZjK3c4sGBJLhOANcbFkm5gXXVMHZ0jWU1ICZ1fkqE0qanR9wDjH48MZ2wWMu0UkYJZIJuKGA26+MKdC9hbOj3z55Xt2w0DfCefLollnuZBF6DvLkBY9Rw5CEEWarflKrXO74kCtwRUBydikG8NpjupiwuKC1EyZOkZq4ejaBU4VdYy+Xu00LvmKfypZnatNdJc2hhDNIKEo9qFAcnnFi+qkr93opeJdbS3a5Po8w1VQbOJ5qap2sbIpEvwqHOAGEfpq+aqSsNEAvyIqvBnhVc+uPv08LVwuC+exqhNVifCf67+Pb77mdV6t0XZYe3Xx5fTM0YetiM+rv1FU56s5pBAbqri64GTdPHgt7FjN3nTGElPNpUHFL8X/XS321mn+hhlC7Ui2FTNoyQVyWiDNWLLOPykS5wslRcp0YZwXzaYx4IagOSXFs6RMXHScIJYlJjyQI6SKooTqBNIRi3cVr2ktJiWNiFT5syJRG7Y4r8cLyYDHSFrzXFPKmnViwDjNEDVFM0WxOn6Zs274a36aNZqdah24ZGteJdjuqo6lDH4ITBcqyjnqdLN/Kj5751kixOkMyWOD5xB6jvsD3b6DnFnmkTw9cv+Ti+Y0AiyJh/u/Yj6/4cZ9TpxmFXPTppDcqwDgNwKy2Kcisq/CcZJrBc06S5pTzYi9vqC1mp/6G4/8e/Z46re9/tebJ+hevxH2qij4il8q8r/5e8oA/Nu8p+nC77QCe7vNl4qetJtGDBFLKVUEbAVxY9RFDphcSEUbknRdkVXIouBE3Sta5FXHV0wFsaW6azY/VTiztmIiva2FiRpabfS1ckqQl+pMsOS0kJaiDULzyDzN5BQxVnC9h1QwxdXxn5nNgrOWGIu6+nMmZktG6r1FnY7kTHBC1wecmDqPlKZT6aLWqHiZc83+NAVjdMEnptTcWx3/eUlYUwguY3LRH2vAGoqkOm/kilW3lQoQkYoYTUUdfdbbeqIjMQvdEBjHQl4WXRdag+m1manUgpoTSDkSxwsmRawLhD5wPOwIu6C4tGUkzmfe/2TEFl2dEiPn+y+YxjPW3xGniaW5RfOK68Rh8K4iv0vGmtpJbcra3CYUkslr5p+r14SihitVopIPrJPDN3HN/10W+3/bx7/r+99tm6+Wq9ua+WSzwddMOTbYl4Jv+X4VI1U29INSMqXImsHXHP2V3bliq9vabM3GrOKQbhrNKh62gmAuZcVjtw1mQ3CKYe3Uj1kFfWuN7lkabo5ydfaJ7o9iTGv3fspZcwHX4pSltTem6porJVZ6hDY0Cbq2aY2GpQr2zeXHRgQt6/PM+n1TdRTamn+nbmltkGjORVPzT5tYrsUTYYmReZo1q68TliXWLltFbopt+0mzoonbPjtXMa9lFqastA0jLdKAVVi9Nr+ZJ1dYqW5tpGWcKClDaqOgrpSzuktNqY5KSLk6y6y+V4qrF/J6bXr3rR//v+2PTz/84He9cziTkUqHMdZuBPBKWhEPBCix7r+0SQfrdewno+KV5NosVJC4aO6zUby9sR5XkjrGs6nXi9T8HocxDsHq/dNCcRbnQ83ZVRJOyoGUe1KcMSnWnPasgqQkglkwKUIqun4NnuQCLgtDsbgE05QYDXgRbNa4jpIWQtmD7/HBY0smT2eEzC4YjoeefbDsi6Gn4Ba9vzkv2EpAMsVQrDbtFtEGBEp1Eht19s/TQswJVxyS83X/4wX6RLkkVrS4c7gQENH5wRtLZ/W9Su90XiuJYg5clsQXX3zBPJ2R4jgMAXGWOBkw2sQaBktME8vDe2RZCH5gfzjwwQe37O52xCUxjV+Sxze8/ZN3+IYJjBNvv/wzHu9/Tnf8AfH0wFQbNWRJiC30Q88ORxcmprRgcsQZTy66L8wFnDhIEeMKRpxGIpQCS0MYa0OFQZtHdn33nQPwG37s9/vv2zXbXp1wz10vxkBKptZYroX85npRXN6yYpxjnFiWSK5NMmIEV11uInZtos45E5y67logbMsKbI7DrmLrQm1sWTF988LpfCIu6hac5xk/eXJRN1qKkbk6CftuqPfQlju11FWO2ew37eqcb/flJUZ164kwDMMqepRSiCnVWl6u9VH0PeeZXAqdczirRgsj2lTV0IJNLCx1reGdp+s7Yorkh6sDyHu//vnaW3w9LkyKR3XOc3d3W4VL3UNP84QTS9cPHNyRrhsZ55mSEqf4wGUUjoc9h+ORV69esd8d9DPOM6fzmT/50z/hz/7s32FEOJ/P/On/9qeUVNgd9oyXibjMdR+WmctcTR9KITkcDjw+PiK1yepyvih+Nenxmpd5gyBkFf/a9bRxAB2/G6Hf7OP169e/8xzzu3XqtbHRBKXVNVvnjC3GcSuubYWytR60cf49x1Bu8wPb3DDPM5fLhYeHB96+fcv5fOZ8PuOc49WrVysK9P3794QQVgdqy/Dc7XaUUlbhvTkVt062rdNwi+JsotW1Ka+suYJb8a85877uGD7Hmj53Az53vD0XBp+4rjdC5jbHsH2erXD7HLHadR1936+/txXztt/FWrsKhq9fv16d2C9evFjRqs8Rr9v33IqA2/zY7TW1fc/2/Hb8ty5QgBDCt74BwLVw9W3uvamYjCedohRKrgieoiHurXRaaqFY1YYmeuhrBAsHL8SUePd4Ypoi85K0Olu0mBeLFqGc6MJqWaLiWARFHtYikRTReEGjQpwVwZvrbdKLxVnNedAVr6lWILMKTRkUE0JFw2Rl62nQe12oFy2QB+9xnV8zLESE0Pn6mbSw3+/1xijGYEvBdCqopTkqqz90sERiBkQdcJrLY8B0xBzJLiKLwWXFbCajXUeGhSIFXzzMIyZTRcoMXcDkTHDgrOYQGklIVERkrrmHur3WokOJtYNNrHZLknTxnwMlQS4RGxSI1zKRclJ3gzLwtAs2p6TfOfhaFFOnkiIykzqSGpbHQYnQdaF2NV80O81q9lgyKIffW3zntAB3mXGddhK9uhvYHY8E57j/xXs6r+Xsy/sH4jTx4tUL3j+O7LoOb4XHy4wxPXf7wHmO5CXTOS0qhL5nSIVUkuafuYo2sYaUQUpGSuX/FcFZKMmycEU4eaeKhohbO7/XvBajLkEtIph13IjJax4NJZPzUsXZ2oVs6vsWRaGUmiPTuplt0ewmnAbfk5vIXdbn5FQwkmsXa1nF2VYdMLTcuqcLy6cZYb9KCNyocxuBYTUbfY0jsAf2XoPt394/sIxN6HuzPvf4XFDcOAA9r36p829Vs0TVHFNlr1rxUiEVdWe6iinOslbmtKtcZEVtIg0PimIhZYMKbNkzRnNFVVD3miGiE1nNEjDErM67ar/TzntVEyuqMGD7DmM1THyeFnLM2hHcnIkV42msiv8JHUe46m3MLZsuYAW8VUGwXA0HOmdRHXz1uslo568VB6TVfZrrqt/2PV4sor9MWiLineJU7AYjYqv4D+Qi2KwLMZNVjBXUlVjEMuaEF0vuAsukp8hZECLxquEh1rMLDocnzgvL+YzvwMuBYDLjcsFlzUIdT/e40BO6QPBw++JD8v4lWMc8Vya49QzVYegHj1Dd3PV9Q+hrQVCPjUVdBFYge1txnwkT9Tgm28rHijvuO/+3vO3+LVTDqv31v/IVv34sv+Ib1yq/kaKkce611vDLikleF6vmirLUhiVZ/279qefUGW11WnMcq0jnjFS3gJphbO0Q9jZT6j3UbKYaUwvhtmbg2IqGpqB/VwvV7Z5QrSIYaykrqtRhh6Aoz2VhnhdyTCsyuyAYF3AYxGa93y4LpgoNmh1mNONE9PM4sdiGgG73HTY5f/WeIkaLfVZVDBUKRGimN9d1OKvZhORCXiIZpwXxKgDEnCmCuiEoilgH7VauYAVrIIjRxoGScdYQuo65QM4zwVpMUUcN2RCLIpw7G7AkFfHPZ2QoeCkEyUyXCckLtmTG0wUfPL4PhAKHFy/YLUeMEebpUhvFHHgQbwlBM2F9FRh0/Ducd7RcSaE2M4g6JUwVGCWa2iYnGMkV6V1w9usFwO/cPb+5z+i67lWTdVLOOGkbt/ZTVkcZtXgndVy0dfvaBd9wYRuEmLo+W7tcdRKtMmOTpliFqGoXeJJtYUVWPKZUWkRDgTYxTarArs1yuvZrWM+yZuyVVRiDwrKk2jSW19y/luW3blKrw7lhS1NJVeSXWqjn2aa41Mw73TfoHLDNA+Hq0Kv3+/Y9cr7mC5bN5rk03LJzpJzxqzNbC4KaCTRr01SWihqtDZfF1EO/vWLMRjxtYHuz/lNuqPbafNdwpGYlaVRH46ZrWYv2ZRWLcy6rEJiTWfGw7bZhra6eYmr5hPmJSEoB7/3+u/H/zT7ujvsXgrr/FPddQw6M1Gu81Fz12iDcLH6isRVGgyNVYM5gcBhHdXkldbJLzQmsuGgjTvdsXjCmq5jwpIKxZO2BEYP1HchOm/uWueI1de9osPpRJEERCqk23KjggHWI74BCmiMlZkpUZ1NGMP7AEOrclGZyHJmjxXQd4i0uZ5zv8c6xGzyHrqM3EGo0iliLM5YgDu9avUHIkilSKNliiormOTtMWTSOpR8Q12FyokyRYhIpOP2dpKJaJlOC1exhXykrSV2AtkYq9KUwlcRgLUuAlzc9c7zl4W2hzBOdd+AzcxeYLzNLXhDfcez2hKIuxHF8TzCGwUQGM3JeLvRlZsmJ8/sHzOHA7vaAdx75/u/ywetPsc4znt+DQPA9h8MdfgjsDh29gCewL4nLWBiGnq4bMJKJc6HEcm3IDV738IWVXGKaq7ui44cufOcA+oYffd9/eBX0FC3XivVbl5ZIeVZoNrWpwxDjUpv9r402uWgzjTF6/8mlrFl6KelatD/0lYC1wQU2wcF7upox1t6z3e9Sda23YvhKRqvrghB6wt7jg6sCwKKCXUwsy6wOuvodzaa4H1NEsCuGtGFBWzH9+jlqJq4RpJokroV7wXvNRcy5okPV+YGIcHN7Sxe6WmdsNKtSY4aujpyGVjXGEFN8UjxvGezr/qJkvPfc3N6wxMg0z1jnOT8+cK7ZaLv9jtAHdWbWLMb7+3tubm70HBi4nC8UA9YJX3zxi9p45SHD8XBT8wnhzRdv6tyW13u/dw5xKqLubvY4p04xU3OFx3Fa3T7zPH/FRfYcY1gxod+N/2/4cXNz8/pJPeCZC7CJXNufNhZWpH8Vfbai39Zx9zyr7uuy9LZuu+1rNCfgOI6UUtjtdux2O/q+53K5rNfg+/fvubu7W5sEHh4eviJutc/csuie5xI+R1c+bXIzTxyO1Lnh60TT599xK3Ju59Dnx+e5K3CL92z/1nJPt5+tzdlbkXUrUG6Ru88f2/f33rPf7/nwww8ZhqHlcDIMA7vd7isC3fYcbgXA7THbOiK/zuXXRM4t9nSTZfjtR4AmUi2T191VMRXpuBl05br1MPUvyvbfFcwBUq5KA4rG3PWOm30gnyfuLxMz0DvLeV4oqE0+LdpB5lqeoHPEutg2STd/VqpjCwhGhT5XC3HXDiHFN7pQHVbGrvjAbITSigepZkvUj5qydv2ZXChR3R7S1O1UEGuQVFYXiKEg1tUsOFO7/jNiNR8AMWAd1ltNInNOVYWsCoR1UGIhpkzOWgArxVCs1U7mrJt45wPGJXJMSPHaxWS0MC+mIM7gravdfbluNMB2gk0Zh+YmWvHVIVEoTjcvpopIalRIZFswYrXrsAkWJGReyMYRa4EyLlUAQBCvm6oyqzhQKEiMWKpTIUGwilkUa0kFgosakJ4SkVz55ollUSEr9AMyBPIcOX3xyHDscd7RBcvLux1SDN2h48u3D1wMHG/3OsET+d6nH/DTLx7JOXEYOsKcOJ8vBG8pklfnQUq5OiuE4FwtomQtuNZ8qYLBIeh2zCqHEYOIw+aGBJPVZVdqEaauMhUpi2InjTE1l6KsY6M1K8ua23dFWZmibs1WPAIVr0pdBEssio5qE1upmZlFVlFyTUVp7OScr4Wtcv3zryf+PVcTnvqSVnHhOQ70Vc/u6LnZe/IJeBhZgP6VioCKCH2liEMUCwowvnqzioC+/xq9z4Iy6dZpuu35aT0LUrP2dBGda6abdnRV4yu5UPGOWgBo4lupmCnrvBaOigrvrp6IUs+Hta7icYGcaibjulVUF69VNCDGIDZQloJ4Q+d7pnkhx4Vp1oJWivrCgorPWKFkIclCMh5xiiVNMeEEfAhYIzVHi5qPYklVzNDCiWYWKdlXVp42oKIjKiTqnCJ0rfsoK6LYWCEm8Ah5Ttq3kTJLWi/N1Q3uEOaSVkHNAJ3V81NyojhLWSxR/XmIdaxnMWi3QBg6um7Hcj6zvFMU8HS6rGLlzWEP3vPuvXZiDn0PMdP5wLLM2mgxQ9g5YoY4Olxw+M5q4DtgcSxRXUGhsxUdRs07ozZM6Hfy2VIcLPEq/omoJu3rNfh3Iaytfr9eh9+bXyrgf91/8xQP+m0qRIo5tIL6ipxbxT2zjrWWBWTqGsE2wb1mO6WGCa3YS3UPiM7DWdG1DamtjlZF/bSKsjXa2Q5RnUNFy13r+C+aESVOhcPS8IC1E64Yg4gnloJ1Qggd87yQ0sI0J1IuiiTLGnxvrM4Z2eSaXQyS9D1i0oYG3/uKhUahtEnXMdmYFcdta1OU4k0NscS1sat1Qxqrk6E1li44na9SgrogTrngseQlYbI2EsXcBNla+KiFzVTS2gxmSlFagbWUEinWkMWyGFezwDxCIbdmFbG4EOg7YRlHHt+dWMaZ+XQGFE96uz9gQuDtvW6g+r6HWPDzTFwWYiqUNBN6R0qKLPbBEYKivlvjzTxnnHeEzkFaamauWZFmmgEtkBWxXFJWEbo+P+WCtbb/j7nY/3fx2cS5Y8mZYq3S3Vfnr/nK5hhj1pwrjQlQYc5VlOV63edcHXvUnLyiy11z3TiWupZ7skFeRcWt6Fe3AFzRui3Xb5sT2DCipairRp96xe7ElOpYapv4iqCJV7edrW5U07KpKhZ0PRF1vsu5NXDWQummkEBzLlJzqYu94oFLWWfUUqifqW6OU15dkgaqSElFjQrWotnetuaElSrSVBEyZ3UXhRAoOZHF6BrBaMOQHr+6dioN9Vpq85JZkZ/NiWOoWdql5s/XObflNjgnNMP+13Uzq6vTrueordtEjDpDVkeDOjRbQVPq+ywl4bzbfSf2fbOP3dAdLRlnqHt+bbxt+yMpdS+F1PW/ukuzuFWs19WaAB7jHMYWbFko1lZHq7radb4H0qy/44I2gSTN5BVTRUCjLW7WDJRiSUshz0IpiWwj0RhtmKHovrjUGkmpTlPROoBJjjknxhliNuS5wLLgpacbesS6ii635ByYM8xRkZSdwG6/ow+ezhp6k/FpxoYeOkUFWmuxzmtDj3MUsYjVQZFT/V6pYHJSfoq1GA9WMmUulByrc9qQo0XGQpkyeVaKktRGSNFqANZYbLHaLJMiPmd6Iou1HHrL7c4zvhPGaEgmkUWpAaazOoatxw979rsD6XJm/PEXXN4/Mt6/w/kICT5++Qr6HT/78kuMWPY3t9gIu3PNT4tg0yP7uz0xweX9meHYczwEJC2YmDA58igJHwJd32HypTbUOo14QdGvxgo2O4rLlOosbXOqAYY+DN+V6L/Zh/fu8NzF8bSxg684ONYC9nr/tohkJT1sCru2FnZzzozjuObkLjGurpR+GGohPq+/r/cXtyLi5nnRJsOK6PTOPfk9zd9u7sJM13ndtxq4XEZ15W0K962pqBXSVxxdc/DV31WUnq1rDlZny9aFs83/cs7R9926/58mxQpaZzFiGYaBw+GIDyp6NoSnqRSAJqKklNa1gXNu/XxbUdaKxqBM06xOH2sZhp7bmxuWZaHzHTeHA/M81+Nm1/UVBR5Pj9zfv+fh8Z6H+wcubmSaRl68eIGvKOV3795zPN5QSiGMHXFZmOKkaxVqLvGyMPQDfd+tzaJdF3DOri6ldn5XjGIVdprAsb2u2DSCWWu/G//f8KPrfrnLuqEkm+tvi+1sYlRb/z3PcWvC1BYB2QTfbbPgVjRq10dDcrYxGELggw8+WB20zYHY8umstdze3iputrpmx3HEGMPxeHyCFd02K27zTbff6+vE0O33XeedDWpzK+A10W4rCm6Fxa3I/VwQ3Ippz12AwIoqbYJaO77t72KMTzIA2/ttj/VWpPs612FDfjYRsgm/zwXDdryeo2C389VWlNyiXrdipvf+iYjZjkXXffsR4E5owZpl7ew0NDxOuQoQ7cS3vIyKilG8ha1d6de+2QR0zvBy17F3jsd0RoCbriNawU8T788zoW3EubrbTKmdWHUTbK2txbc1/Aypm7zBVjHQCtmArXKmqcW5mnCjKIpk1oJZydfAsJRVHFLEgCLvWuadDYpjtGJwQQWZjNB3Tjeys4qhmYzJgvVCRm/MzrkaIE/tRrLEklhigqhs8qXdTK3iJ6wt+N6wXGr+kBWiqWKGV5RYGWctLKJFe0xGsoWSVJit+51SRVUjlhp7BqZ+7ghSLAVDImLdgHinxf0cYdYFjTghl0TGIRKrAKAd/7Eewmw1BcBJUREkaQ5Csgs5JXxR91ofwJTAdF7I1hIopKQbMe+dZpAtE/4wsD8e6W8OpCXx8MWXnN69Z9jvOL44crg96ILLC4MXzL5jCkJ/2PFiSlyWBR8s+53HB81RHEIhpllRDwiXca5Cd8F6Wx2XBmvU/WBEESxzLZRk0ZDyhDrtglNnhUZP5VaGXnvIm/vDe49YYclZ8+aUi4ICWPQc53pNSkVIlcqsbGjaLFWFzwlwGxSRLnSy0dDr1sJsjKKSkHat10KJ1TFqtoL/31j8++pfvflrfvXF4Nlbx2k5Y4Fj3xP953hGePOGnqeAwq9MUM/Ev/zsz9ueD81ssBXBJWu2ztYVh1gyWtxut9IYa75mG09cM3mkzU+JirdryNE6VyUd4KVESkJFPrG4zuKtxfc75nEhzRdFaMyJnBPT6R3zkliiilZWHKELLFGQnEml9gug7j4rdcDlhGXGiXb4uiCUCCYvVShOV/GD6nZogqfU/oysBW1orsaEiNM5I8WKUU7VrSo6hhYdK3kpje+snc5GnT85gffVPBs1qtSLJcWZzliyU5Exewu5Y+VzWqoL0BFnPT4MluHlEb/rSFPCectymjWL7fZWw9hZKBk63yEF0ixkemKBeRxxQUXHSWZFJAcLeVaRAQhRhdRcmz9CsNVdK2tWaqsfmTWAsl1G2rQgT0Tov364/CZEwuWXy4J/4yH8636ev68C5FrTFjM0h041ra1FeC0QX9l91jrNtqs5fQ3lU66lglVI1DlYN3Qp5zUTzLY8r2qLFSuK3ckVKVkbCBTRDCYrTrKUTIkFRJHAPgScE0K3V4dvHf9pTuQUGc+jdpsukVRKxV53Sj/IhZTrOssUrDO1iaDAHBX7awRnNHsr54SkhiYp2hthZC3et/FfjDaXlFS0cN/cM5R6L1NEaUqprr0yJhm8CTU/RXMFqajV5qBxTsgRgtMxl5NmFXprSWmms2uLAtnXJpjqJtLsNr0nxZhq00HHcHfE94G0ZMQJy1kxgv6mo98PUGZShr7rMKmQoqHQE1NhGkd8UNFxPAveCaFzlBQ1w8VUBHnKlBgRKwRva/NMc5WWNQNGxCiiddOoU7PX+m/imv9tEhP+vsc/RrpWeKEKZKUIzftTNnlvOStZomGAm+MOqoNvg66/Uk9UDCx1nWRqhl/LGbx28F/nHanC4rpmq/OE4uQbvSFfBTtz9bC1fHNt/hLt6he7Ftl0nkk1U/qacbo61U1Zcwnbnqw0t24uOobaOrDOB/WfK7mlulqMrq2MbPE9pRYcM76ysluTm2IxFUnfsGusDsuyNmeUuke0Vt3B1rtNt7UWEW3N3c5tfmoCXaVftNlaX8OQYlqXqrllcF5bjNf7QstbbGg3Y/QzsEEmNaefCsmbLuCSV1Ss2ex3rw7KJgLWz0NBxP4HP/7/vh/73g1WtAbgnRbHjJgafdAE5NrVbn3N6M5ko9Qfk7X5V1xr5rAY3QHoXsAIpEUb5qxRskcd5yaqO3DNysyKxVZF21JiIaeFvMyQZsgzJVmMC1UkWjRDehFIRsWnJVOiEnRSmplzIRWDEY/vhdCHSi9xUHSP6axSNmRaMGnCpMwuCDuxdMHiTcHFBacSFl4M3grWqpAgTjBBkeW5FPICZc7a/ZiTRo6YWg6JibjMxHnS3AEjmGhIi1XqTTZIkmvmMmZFsVujuNGYdX9rABdnjs5R+kA8CNPNxPuowmNxQiYzFSG7nmWeyeMFuT3S3XzAx7ueNKlAcXl7xlnH7vUNw+2R4CPZWI7DHomZuC8UuSUmw3TZ0R8CUiL33rAbOg6HQFpGbSAvkT5k5iVjy4L1gd0u4FzRtb2xWJsxovtr66zGNeSNAFgMnXc93z2+YQEwdGLkSdF6LfLW+83WBNAK5kZ0H90ydPXekyoGXxs5UhUBUkrVlS/r62uDUEWDBktMkWXRjNtlVjHQ1vvJMs+6ty+ZUD9X3/c1e7YWxXOm1CJyKWl1DU3zhK3iW3vO1qm0df4U4Fzzxfq+p+863be3ph1gicuV+rQRTpsY0IrrS7x+b92vqHiCUSEx1uOiTbGLYkLXXC2tn+ZcVoGhvUdMKqga9BgsS1yFj2Atx5sjYoXT6aR482VW92PSDMJCdVHtd/RdxzTPGGN4fLgn5UTXfcxuv2PY7SgF7l68AArjecSI4TKOfPnmDWIt3gXOpzNd17E/7NUx1KlYJCJcxpHL5VIFG4cP4YoJN2aDK7+u/+BKnPn3yQD+7vHrPULQJovnmMp2vYUQ6LpudcI2Qao1t25FqK2jrQnZTXRr2M3tPJLXnOryRMhqc0bDil6zQHXgzfPM6XTizZs3/Mt/+S/57LPP+P73v880TfR9z93dHbvdjsPhwDAMmtk5a55nG6dbx+lWpNuKcV/ncNw+v4lX7bhsBdDnIurXuQGfI0G3mZhboa39bF2R2//einkppVUEbMdtK6y177I93tuf1gDRztNWpH/uDP1KA8Umwud5/mP73e311XDO7fg8Py7e+299A4BjtbZecTe0jVO9rWQ2bo8MxrgqEKoTjI0gWErrxNUClXGGKSYuMVGc0A2efd9zmwecvefhsmBSwVvLbt9jDZzHmXGaKbMWvkqD+2kQ4eqecsEqytEIoeWqlUzOVvOpoCJcQHCYujAga7E+pYQk5c8XUygkrPNYJ+QlY4PmUFljMLnmwqDF+Jha7mDCU3CD5oaJsVjX6WaiZsukkiHpAHBGS8mRQjY1X9HaWmh0lJgxxlO6WXFaJtcuO0jToqiqIahjpwZSI6x5HFJZ/1SUCTkipmIRc8GUqIVKNCNdN1GJFBeWlHBdwBTDPM3a9T50SNIOJ+lNFaWuW8pSnUPW6YapGA1Xd74wDI7poo6FXgTXq4vCW0vKMM8T0dVzGjN4FVLzPDPnxPHFLbcvjoynkfsv3zOdzrzLieUy4izsyaQlEmzWisYy0/UWTMJbrQXtvWWuCDErDlez3LyzTDkjS67ZQIqCM0UdjEZcA8JqNp9YxBbSsmAFnL2eN5sKEV3sibHgyipDq8AUa+FCdGO34uz0PVuRp5jm0qhmWtuyYwxSjIpWktQl2opaRovE2ZR6bmoJRWrHPGUl0ekwzZQqKP/68t9z6eFXrXv8Kk5Y55gTnBhJPQw7j+09d8cdvocvRxh5Q88rbo76un55xUN1AX5V33C1gzXqeNGvqgXy1lTvr3E+eRUHhZL12QrYar7nK66jdQtqw0ETEdUh47w2Bqhg5tawcR2IQui72kWqOY1d12vxa5kwy6ziHZqPlQtMcVHxL6ELUudr1h4sMWLmjJOMeNHzFQVvLEteMNbXLlXd5OQqhWaSCoAC4v16BZZ6LcS01M9RxcsqZJa06W6qx5aS9ToXLe7jtCAntqLwWuNEW6BYrSe44GseJis+McdE78BFiyWwOEj5ijvtSEwLRNDCyMXShcD+9obOe0qB91+8I05nzg/vIU7IMtINPb46jK3zFIFlSVyoeZHo+5ETwVsMQQVAAYlwmWY9Xk6RpK42ctAEXpPX3EURFOGcq1sSi7NJoyzf/PWC2t9W/Hv1tar7+Gz8Lb9krPpfKhu++S0pCv46723EhOtvt87eLcJh0x1sVnnmqchXnR1t41/q3+tC7srW10W34KxZ1xq6LlIXmDWlCsLq6tVOU50fgnN1PjBgLKHrcN5vxr+22jhgLjDHZc0C9j4oitBAEcXulqWSBnqnDUYx4Y1hKWDq2BbqumR1zOj6x2Zdd0nLca6F7JSizlGFDT5QhYtUMqmoMz4ndRlYKZq7lgwxUfOQTIu6VXGjVIpfzTJzrnbUSs1sKZ6cEr036kQwhugtOaYVm1hKYV4yUax2V54Xwl1g/+JI8J6SCvdv37NcRi4P95BnzDyxG3qCoCjU4CkG4qLiqLEgxtWcxEJwFuO0yukMdB6mUXNhrJOKlC/1nJqKWlSRuTm7RLIeYxoq0AS8+0OW+K+/rcX+3/bxjzFBsZ5mpURmZTxes21SRiTVzD/aruS6L6knrLn6DKYWryo2vI3/GkHQmg7XYHSeFh9a89SKp2xo4jUTUO+VpWwaKDcIzhrdSSzqnstZMZ+lIfkqArQ53rYKlxQ0iqGiq2hQiYYwMNdcwvJEsGbNVpfaQFmngM2mV3Fdbc8lZpsJv/n+FU/fDnETPJ1369+nlLWhsGHRav50zpk4z5gQKmIv0/IIjZGvII7082ybUKmCIdVpvUrBq+NTUWX1mqmNBsZcm+GsFZ1TN3jTdl9poqcp6vRqx671n6pjtBagrAT78u6P0pfv/ufvxL5vygEgna2Zu1YM1gnFFFIlr1gxqyPYVHy34kEV86n5dg5j9HoQm6uzXfGaUpa10UYbgBzWCCXrvVKbmwVxBkvUhlfRnO8yL+Rs1iYdkiDJIEkR0iJAEkzJSDKY4onWqrneTCyVL+O9Jww91hkKucYBZKxJWG8R31FiwmNJRRtHO9FsX190XUHRNY/khE8R33d01uMqqhxntAl6zuRJ3UQl14afkkhWaTQpL8RpJC4TkFacIuJ0UyoGY5VuY+o8bLzWHGyp5ylHPV6dw8QOlyNlMBQ68qtbnDXM46QNOKYw5MwUYLp0LMvM+G6k63pef/KSwQdSzDy8ecf8cOLx7c+RciLEkbA/MJiIDxnXW4wTllg4ecH6gjOCfbnDFRiCI/seI0JnMrsQeXyYSSnhO0ffe7wUcpzViWjqHtDo+k6ouHPM6pj21obbw+4P3j+e/+13pfpvavx3vqEmy6ZorXmxel+01q1OtGujzvV+e6WFNFFR96jzRYvuubrgMBof1BB+eg/Pdf1vyUmzR5tYUIo21A27Ye2nbvc/56wSP5bINE7a6FPUGLAsWiSfakbecNyx3+/XzKxxHGuxXlZxbZ5n5lmz6YZhoOu6qxCQi37+Usix0sOaA3jjcmsigxa309oMpI2Cuj+KFWm4LNX9ZwwltdqIWQU/7Y/MTaS5vl+yrW0Jax37/Y7T6cw0jerSCp6jHHHeczlfSKljmibGaVRn1DRxPisW9NPPPqPvemKM/Nmf/zlf/vxn/MWP/oLbm1su5zP7w4HgPdZZjgfF/z88PDBfJjAw7HpOjyfGcapCCyoWORX7pmliWRZC8FpjrQ7EFBOuc/Xc8ySP7CqcGIwxYb/f/8HpdPpu/H9DD2ut//ptgVndfzpWn7q92vlqgtNWxGqiUHPybeeU7XOfO9iaK6yNo4aLvVwuT0TBcRx59+4dj4+P/NEf/dGa9Xd7e0vXdavI34TKeZ4V6WvM+n2ao3ErSG1dgFs3WxP/2vfw3q8O5rDBFG8bCrYuuecI1F+GG926B6/10qduviac/bLnb0XUbXPC1mHYjkmbI6dpWl9zKxBun9NEuueiZnv9bYbiVlDdCqHP8xCb82/rot7ug6y1/vPPP//Hf/mXf/k/fWsFwIJBSlEky7MdRKkbSnm2ozAmP7mhrgHupm3FdDFpnWCNEOPMkhKdDxx2A8fDDQV13Xzx/sRpHLk97NgdepY5al5OVqRMzkWdZlaxH9rxXwMhKyariCGZisEyvnat1ryznDQ0vHYESi3wZiOYNFPKgsUhVkOvvehij6AXFRmM08K3s1qLTBUfak2pbC6H2MDQCWlM2AKSSnUaVUueWEzWYmIlAiLWMFihmISxhhwVH6LoPlvzuWzFl3lyjFrYDRZiJOeoHby1GG/FapevtBJ/qh2vdWI0njzNel4bKiAuiOvV+eKybmaK0A2DLoByIhvBeUNMhVOMKLwz6+bGq4CgljndfGsougpVwSkrXJGb0AeHiOabWNeRSi1kzJEs6qAsSyTGxHw6ccqFbjfw+pOXLJeJOS3M57EuPBzMJ4xY7u52xHFk6BxdUEHRYPAHIcwLYjy5uHota0VfUs0yqqUSW3MlRUx1gbYub6vfV1QETotZg+HF6IZUpCHV8oqTa+hNKge9dVsZLGtMX81MyORakClr8owpWmB1ot1qzXVhjKx5UtoFfy30GNFu0ZXE2zrFKYp9NWsT/HVIf01239/48eQ19Kba9yrELCkyLzD4nuN+4Hg4Ukh0Fvp3Zx4eXnH3smfY75inRZnvIzy8UqkiNTnDNvGPGvUXMXTatSlf85lyc/pCQgWtWG9cVtRN21CVho1+aEQdQTUDsCCIafmiNbexhgmKE83kCAFnDClG/XBR8X5kPZ9dF3QTUDF0vvPavFCgC13FZBVymQg4DflrQqWBXGbivGAcFFEBoMRldZWmVKcisVijIpV1XucgA7kkSszVyJabblczhrRJIedMrvOfre5lY6BYRS2nkomlZoDUZpqSchWutfOy1DFllOiHFUcyLaxZi5nWLaQcaMjvFJPmlw5Bg8uXxPLwiGfA9R3OO9xHr7icT8RlJl1OWBJlsixAcF5rpCYRbCZXx2TBMnSQFrDYWvBNFcsoFdULBS0eW1EcsqAoJD3HeoFc43AThZol+2sOi3/vLtg2op5of79c4PttefxmipDFlcIq5LUQVEXiVWSDkTXTjlbMq3Nfc9tQRQTFfQuC1ftnXbeYlnNMdf3K9XUL2ohkRdc0qdRGp1roF+dwXcCu418gxeroqZvkzpFiRIo2c7jgFPFbDKFT9EhO+vvGK7bLwDrPp1KIc9S1TcslTLHSGhTLbURheq1D1YrVBpO2Lsv52vwj1V2edfznpFmDuSGLrGL9dPwbvDPEisfJNTMP1FFQb5J1E5WreGB0nSOetFQmQwHEsSyR1PDhQGqh3INi0tKysNw/4suA7wO20zlgvFyI00S+PCKlUCZhKah7rwogxmay49qA0znSktWdYAWpOHLBrA0IuehaVKqwYUTF01Ku2W9WVAQ19X6rBnsDPvz+rxIAy7dmrP1WfiZPE35WBI3Uup7ZdGRvN5rbfDpWJ2dZCzes6Pa2VmtIz+YC2HbRt4JPy/IzciUo6PxQnhQQnLMVxyXrOqvl9qlwx4qTTRWlpSTivDZPKsVB8bhbioOpUQslb5xwdZ+0Zh42h+Cm4BFjrPOVNgmIqYjE8rQpojVbrrmnpmHua0GkHqNk2vsUpQVUsbAVZVsRwSpTGyeuuje1IZAY8fU4rxt10wS/KuSZmm3YRFSzFTuby1JzXU0j0rSc1Fa0qajPNg/bioGnCpwqPJrVWdgQss0R2q6nhibVJpKrmOoPh9/7VQLgf6zj/zdSoJAiLXzbWIuxlphmvd9ZweDrvVmx0sUk2qa4pCr+1+K2sRo1YqyFLBQzYUQd6Hr+EwVfiTlFXXdYMA4xBqt9tRSElErFCoM4g7E9UjxlSSyL3ktbg53WH+r1FBM+QDSBkjqCsYS+JwSnLtuomFHJSfG3Pug1ebmw5JlkLabrNQohjkiZKanSjXyoe1iPxypes8YjImBiUQdiWq7Xc9TvkV3LHhUsgWINWHUG2s5hnCJ3UyUmlIr5zjFRgkW8QXKNZMlCcHqvj2YgTgu9CMZmRAacTTxehHkuxJhJccZ74XDjyCUyXy4sb35B5Ab3+gW7456uGxjPJ0qciPdfYrOO7bmA6RxeCpYZkUxyGZsVGctgyQs443DeYlhw1mNsgGJrJnSmDxZnLXHRNaEzgkXIJmv2d1HX8tWBoXPbi5vDdwLgN/jw3vtWfJUN2nKLyDObppct7nlb9F3n7uraK7kQl0hM6uY2pVCWiLWOrutWHGBOmWIVn+mqW2crLhSg63q6voNSmKeJpQoLtqKzxRq89UqKqtl5LaYghMDxeKxOGKMuwhC0DrVx7uScGaeRnHNF4Olna5SDXLRxKDfEd3O11GVwqnl/ptalbM1IjVEJZPOsxXbFpQpd163NUi0PMFb3fyMFbIWALW6U2mBlLQQfyEPW94kR71VAHPoOMYYlRq3t1rz1YbdjGkfefvklcTnSve7wPvD6ww9x3vPll19yevxJdX3NLF6bzKXul1xFBBpr2O/3hNBxf39f8af9dZ1nLd57jjc3a14ihSd41a3rp33fJ2tQ4HA4/CffCYB/dwLg1vnmnI5VvVav4/25ALgVjdbS4MbR9lxY3J7nFQvb0LdVbNv+3TzPq0glIszzTAiBjz/+eBWgWkZgw3R673l8fCSlxOVywVp1AW/fdyu4Pcd2br9fE//aNd0EwK0zEp6ik5tDcDtHNmdkm2+3jsGvQ4Zunb/tPdr/t2O0Nkpsnr91ODeM59edr/P5zP39PW/fvuV0OmmjVAicz2dSSk9clF3XPRH92nwkG2zz132e52Lmdd9yRbg+b/7cXiMff/zx73+rBcAmIlBqR6VRoaDtAs2mPF5K2eAHCyWb1X1mNqLHE2mwgBPYW11gBaednykW9sFjjx0PwXI89vjQ8TadsWSGvmPOkcu01FwWRUxkUwjO0XuPE6l4vJoBlLNuRnF1zbuQpSFAI8QCxlMqggYR8qI3N+NMzbqIWNevLZ9SRUfNydLsCitVlDNGHV+hbhJydQLGhbxAMqjgJ45sNH9oXmalTDmLyxYbhIzX4nwp+CAatl1VvDjPWqxKmRjbBuSaQ1YEiAVnbD0Han0sBbypaKG2ia0LFowKUClBZxUt1oJ64xRrAV1FsNA5FQspxCWxzIuKecbq4puizp1LZN8LCV14F4CUsV5vrsZoccDlTKu8JwPeOOY5I72KLtmgnZDZsSyJuEyYc8T3nuG4Z+8d8fGsqIOKGzNFiMuC+EKOsWJgDeLUJepExdWcWi5Lu7g1mynXSpBvLtK6ELOiuYQLhSJgC2QR8AZZ9HUVzaTdlca0TgMw1tV8iswq6xmjnaemoW61K9pQNImzLS7a5FgTAtcObhp+8io/mNXVouKiSKFkeYK8KlIwuWbSlUKpnY2/ftngudhQlYgm+v01AqIk/aQHT8VAqAibEuxDD8eF4D3HG08Xet4mIC4Mx57l4RWOXsdyc+bbqgim68bWaiggKWs2XsqCQx0tYsDkJoeDsw7BroU3K/W4mfbyisMU61aRTAx4r+K0Ea7iQtTiu+BqJo0gzmohPWrxKptrdlwxmu2TMmAcPlhcdf7EaUIMOLFksRU3pLiQnKIiO3PGek+xQloqQitT3UhJhb9NF4yKf/bpWZanzs9VCM41X5G6WW6dvvqhSAXikpmnSFzy6ozMacFUBLAVsEXICXXeFGjuqRYrKJKRxTIvSecuox18JWoXpu1k7c6M48z9/AtCH+gPR168vsUamKeRdFmIsTJSSyJlu24CbHV2SAbx2rFNTCq81+YII4pUNnUo2YqS8t7X4r6ipCjaG7FkmurMqkJbza1smZW/vuD3N4FwPhMB4a8R/jyvWHjzZLx6nqJCf7OC4TfvZDCBhqeqdXmzRcAZvR9vC/0tJyun5h6pJINS1N2NrO493Szr/U7N1AUxFrFupR44AefVJWasqXXzQo5ldQDVpFvFRcVU5wadqVensVH0ZtIbBL4KW8ZAHOv4t1LzsfKKKl/Hf8o4bym1UNWyXk39n60Drd0TcnWar9G0xawFAcNT3J1ODfo6zhgtnomuf4q1xGyIS2KeIzHmtQO7pNq8VHGsWozI6/g3GG0moDqzpCBY5hjJ7djXxgFxuh4qObGMkWWcef+zLwi9ZzgeefHBEZEj8zSRLnEtlpaiGDUt7itOVajOC2u0AaEiPHV9WkU9J/VOahCjjTXO2zU7toVf56IIZGP0Hp1aMVeDxF78x1zs/8Y/i0gHZS0otYw7xWpqt3l5QiC55oU2IbDUTFxtCCxX1G9Fhjb8ZWuaaoXCJhYpZr82ObbQ+yYqloI0h8Iq8OUVJbrN29MC0xXVW7hiN3XfYlZnrkEoRpuFqJjPJpbX3VdtaNhGAG4RNWXTcZvX5rFcTI1TUAG7ORVbAXXrnNhQ5bVhoCpwbY3b8KermCpVRN847lIjsDzLbcwpkYxgvKmYHUupe5gmTK6OP64Fx7I5fzkXzXFtAmzOuuda2ZBV2E1pxbw21/LaL1KbGaS6fdcs7g1qWk1ltZGxZsblUhsM++7l+J3Y980VKKztSzsHzlCM1MK33pcxgoivYq4idIup+ZIl1ch1S0ZRz5Sga6EcNYLBaTZvSknv/SlibMC4XW0WTbpPqwV5vDZmMheI9VrH6kKzFIybMGmBlCl4FdJMRmyi2EwqhYJHxDEMHued7i1qRnuq85okwZaCMZkSF+IckVSwfUcOljhHJcKoxVGzvoPHDepc8mIw3miDrqsY41wx6OhaQHHfbY1UQ9GLqfdxh/VONz9dRy6WNGfikjVnt+GUU6ZEoNMMVGcdMUfd65hai7A6e3VekMFRyoCxiXGCJQtx9vgpgg+4oScnz/QVAa08AAEAAElEQVQwkU4z7+dfsDsO9Dc3vHh9wMqOkgr5rK5p4kJ2MBtHqOsaaf9LmaErRFOQtFREvHqGjQXnVSARKVhTMejeU0RrSnrqCqlyQRr5RIweSmuF/dB/+F2Z/pt7hBCG1qi2dWA8d2PkXJ5k1q41y00BP+dCigvWWmKN3okx6j3CtPvz1UljzLX+0grr2iySWZbIMs8s88xsbXX8mfXenGIi5mVtLinVahc3eO9hGLi5vSH4QIyRkrM2GrurCNCcf4+nE+M40nXdVRQsWRGl1q5uPC2CX8U/Uxuk4hIJXVgL4PM81/t4fuIkbJjytRBeG+JbMfx8PrPMSu/R9zBPMrVaM1Zz7KjQoOJmc0+Z6tD23m1EC0dc4ooEPJ/PfPHFF/zLf/U/UUrhs08/4we/87v8/u/9HpfLhbdffsH5dLkW8+s56vqOw82hNjgKfa/I6FjzDKXWBnJK6rJqriBj8M5rpng9jk3g2BIQtiKIMYau6z76bpR+g/d/57qt2L/NsWuCUMNvtjlii6587uR7It5vrtkmGG3Pb3s8x1A252ATq9pzm8DnvWe32z3BkDrnuFwu7Ha79fpuLsFSCi9evHjWcKh4063gtkV/bsXM9rytI7Lv+1UA3OI4m+jX5sR2PLbzaxMyn+cNbsfAc3Ro+3OoztrL5bKep+s44klD4hax2YTDdmy3Lsvz+czPf/7z9TP/5Cc/4ebmhk8++YRxHGt26eHJd97iYLfvvUWBPh/LW0dk+/12/LZ7l60Au9vt7r7V46t1VkLRruqabVNqJqApigAtpmbSobiHXPGTUovKa5WJa2eqoqRUsCvBkWqnzpKWNZ/KesdN55lThpjovGMcF7wTutAx1QwYUzd0ueJfrFGXIbko656qElTRS9GlQo4FXFZHogjFWV2wVneX7ULN0qsoGLEYL7pJdK6+tijWsejCuBjBlwS2PlcU+bksC50LiNMNv9QCYCzopsAIFhUAbEsvM8rtLwJ4zTpMkmFGc3dyJsfEMs3kUgheFxRzitf8A6dKg1ThL+nZwVoV/ySzogF0YisabWCpGX8V3WGk5uDUADJMDTnPxKKuvZKriCgGk4viARUegKGvbiMV9hKFtETEQggV5RoNg9OFdER5qMaLdhQWlbxETC0GOKQk3aQviTxNSCn0+45BOuIcSVPUAum8YIKvUpuiWmzFJ+r6w5FITLmCa63mIy5VkDRGrmKAbYWIqOKPGEoR8pLWzCgRwdUiUZZcCz1mRSOU9ppWcUhaSLA1R6SsBZ5cTBUlDKmkmhV5RRKtXdZGdHw2pCcQs25cTN28FAM5mbUTvIn1Usyas2kwFQFnnuoRf+1jeSZf9CpfvPoVzx+16La3Dny/4jiXNDctCh88d8GxpMiUIiE4LqO6AH0/fu3LKqjSsU0IvC75awdKddqts1K+Fn1y0gxAERWxjOhN2qOulyY4iNGuXC085ooc8uoQTlkFJCubIpNiW02xmsVj7LqpiEv9dwEnHSZGsBXhW6rwl5IW3mt2QcrqKM1JN945V+U0J9ISMWrCxaLXuBGpiONcO3/VqabaYUWG/v/Z+7snO5Iluxdb7h6RmXtXAWjg9FxyaBzdFxr5wH9bZpJMf4iob8n0oHtJGjVzOeTM8KC7UaiqvXdmRLjrwT0is6rRfc7MZR92cwCzPn0aKFTtr8iM8LXWb4XYh359jmuAsJeEssJL/KoPTSUnd+lqw1aru38PQiKxhPjdsZmO03Rh1IWymHEiiUBCuPVcdBwYKMe1zsXaiRnL2xllbqjrinK7AvoJy/QB090Zy3SPdqdY1w3tugKm4ZZMnuC06qqdeJrKMlAvxYesvKf3enqa4/cS4vPw4j7fOuXVEaM1aqaae6Xz4p/zW2h6R2nvp2W+j3+UCHjU1csXRcAfS4off8TMfd0T+PfrDPxvjQgkonz4r7G2+36gD/uZj/2mfZ9g+zhbPQXm69/7VIlpPxCqIrHfM0EW2g7HvwkMC1NIivVvkIx9/VdFSrEuhFG3NpJKavv6ZxBymkHNP0gMFwq9R7N6QtYsUnkNsAat7t5t5vsWaIGWMpLizOT3uFj/1AUI8X2a9v7C6LPzUGSk92KwyeSfe/F4M6w2RyvHfbMWw1YqatPR0sUALMq+KXesoD8Xs4AsRzch2K9xjBY9eyn2kClS9Y4kYwVYEpa3C7aloa03lNsVN/2EOf8O8/2C05R8/d8K6rqCtIHZHcRKwCRhwoGjUFMy1JsPh5FoN6rFvbjjJQUESAps3J64d8y5Q5OreoqqdZRiTn/W/jse9v8K1r9oUBD6+YtjsGWqMHIRsL+Xx3L33hdoFgK10BC0zGN5gXjf0ZavE3/dPMBE0Q9so+uuC22w/Trjw6jDHsxsN4F1XG9UFfTnYuP3dlHNe2iPxkvbjT2RVlPsYmdoHofe06OTWPcB4aHagQ7UF47H0vEQxyHr8fDs1w8aqWlmYCsHm4MZUtpTg8IYfUq9y1DD3KAaSSnydK3Yvu/tDtyjSalf5ztxRoT3e0HYIh3Vpi+SIQMb7bG90Q9LFCN9RqSfXqJafb9IYGNYIA+YCDX29kBDXpb/wf47Xfu/igQAS/Y+SD+zwSiEPvI6BfS0dtt7Md19CuYGhImSe2WGRQS3rEhCoDxDawUVA6m6QY01zJIdAWtgUe+6j0idI/gVFLMJqvHZZIKHaxnEGUaChgJWg7A74wyMxAlpSZCJwZxA1ff2wm4spKpuIEWBNkMphoYEMYaVAl2vEBhACWkiJJgbCpMgS6QSFway0wKsBULYBwyw6mn+xp1K42ZNK83NeGhI1QDx838rFdUMW7M4qxNGpWpf/mRuig0UryA5tcTcTMwsIK44C1CXM3IyFE0opzPW56sTEhr5/f+bBXUjtPWG+nxDgWGR91jenZHvBHjruP92XSG6IZEhpRNMKyZ2I0MigKcJEynqU/VqksnpOd4rV3wPEul/UiBlAZAiJdZgVv3xB9XgIAdAmHC3zO+/rtJf7hcRMTH9KKmjQaDgQ28fzDwNNga2+yygX7vREXbN08A55xhAsyfkoh4FIBeoUhqo8X7/7XvznpTrfXIyUPE8rt+qhlIdM+yIbASuWpCnGM6rQUNY6Eaj1hSleLJo3daBGdSmuN1WmBmmnL0+IAnQYm51uIcxEeZ5GbjBnpLpaaht2zDNE5Z5Hsk8x/PdwiDnv8dE0LXhdnMcX4uORA4R5pjEdDHSxs98LRqU4nNLkY4oJYg2qOaYWXrv4t3dHc53d2Bh/NX/8r/g3/27f4vz6Yw///M/x5v7e7x98wZPT094enpCSgnn8xkSj7+/Jy48Gu7uznh6ehqpTGZByhnTPDl+sdRxHnjz5s3Aq4o4ycGCjtRTocd/cs5f1/8v6v8b1v9XCFYeAuCxk+5LSa3X144u1B2TYv3fx73u8WcexcQyMLklPh/2Ir1WShnC0TRN4/fXdcWnT5/wV3/1V/jd736Hy+Uy0n/n83mId0cB8ChojT7zw2Ppr0NPE/f0cv//XXzryb6jMHZM4R2ThMef84Xr8Yvvc+wbNLMhyK7r6p2eZj9K0h5/3u1227HCr0wP/ZrXBdXf//73+OGHH8b79enTJ3z//feYpgkfPnzAu3fv8O7dO9zf3481fEzzdZHz2Ev4ej0fxdbeDXn889dpxru7uw+/aQFQe7dE38lFqKKjX6yLU7HJi9vuOJ0oXLSABlqld1JE0gLMmCfCxu6mIiha23yAFU77uyXju6cLQIRv372BqeFvvvsMU8UpizviA2fFFuJfZrDk6JDw3jzHhPjQ2QdTzu4nClRdiiG3KcD9AAh3nsdgXLKAzHGa3FOCMIjBk1NxWBZOPjifJ6A2tGuMZieCFkIzQU4CrBvK5tgPU3cHcPNyaTB5QrEqGhRTEpRbgWmB1gJUc4SqNiAJJHn3YltXsDaw5MBB+oXAcaUKVE/dNS8/REwh/XAy0pwKUkKFIou4yNUceymZkVMCa4W15shFInf/lUC++ocEBkNuAJ0yLDESOeqQmMHW0Jp/X4hvvJMQcgI4J9w2ALEBKFUjlEZQ89QQZe6taRAYrBVHrGIGzxnTIuCJ0RoH7oWQ54xEsUkLl7UlQClBzHB/9sShVVdGMxNaJBrQReVWwVMCSYKhuejRAnsSAMCZCfMpQ54ZqgkqNXr4PAlaTXciHe1YJT9UxIAJe/8mC3lnBXYuu/CeVui4NGu7YO+iSxeaCE1d7BvfIH4oA6PPhEbL2RdUBrxSL35GmHih8vU04GtFIvS4eUrYnvdBU20Nut08ZScJd8uM7z9XCBI+fDMBreKvf/996BW5a3ohWiHSfxXakqs2fX/ek0CmmMQd4T66D0EvHJwWAyjAryEdC9eTgEk40nAaSRK/NrC4oYDJvy+LC2SqDdYMDIYakKbJk0KtodTNH64IiAWTTNi2Z8gkUFJ3MRthbS6YccTvDRYHl8BqsaOIDYAVhWjzVHLqw7W90zCgw27QBUOtREtg3zx1QRAxIAlTBQA7oMs43NZdLKxV0aKrTxUw9oRl88sLiNQFzNZFV4XWQCqGkKoAFmYYAwmMpv6653l29F9ZsSkwn884vTmB3pxQyhm6rXj+9IDtWnB+M0OmhGVKMGFYq9G7BFQwBLM7t/v1EQpZgK1q4A19bJQEqOH8tObPp7t8bVAkPXKa2DsWu9eFBGF+OMhv8ZnvnYB/WN77+V/ffkmGv31BZR9c0D8kE/5YEPwNdIBxH9D3xE13n0cF1hjoc6C/Tb3XDRoMW9g+5IqLSO++YhZPzAUGRiQOBRTpavTeLe/Z0BpZP/I0oOTsCC4tUMogI6Q8+/Vdmyf+LX4OCfI8AesVnMXXQAzUff37z261wciHAqDoOgGBQrCw1iCmPoROvo8wjU+u9fXv/WU6jCV766lwF1H7+7Cvf23qg1F0McKHrVodN9Sq+nrvaSL27j81QyNC7uufNNa/Y1OJyc0VYMyJoORNbaqI9T9BSwlXNcB3jPPdDNwtqOUOWq54/vQZ5brh9GaBzIJlTtC4zvYOsFLM+0+juw+BaBSr2Ep9scFPAr9wQUfiZ3yYdO+0JhiSkF/7e+qLQ2QhOv9Whv32KxT4/tAvVet5tjGc84SpDOHHe/RsT3mZOroPh+64oDsgBLqR3os9w8DBBOISo/EJL74PbBcI/dvJEAj3/ZyOpOLoj+t/dnTx2uFV6IdL0AsxE9g76rrox8y+pnUXPGvcAx2x6X/WIuEzcEcwKDnOl3q3NAfWHEED6fvU+L7ae03HMMBNA033fsP+dWNAY/2vGIgjcReJGa9O4BfOY9QGFn8NiRzn22JAi4EBdRfXQILaYbAYr3XHe/XPRRLx7vIuHlO8T7TjY3sP4HiukTLUMJM4It3XfZCEXiQRI1L2m13/v/ZfWYSFLHp5E6wG0o+C8kKHD1z8XmBuvCvdaOz9GeZn0uod10QZknJ06Zqb99j3qw7+1r3x3ry6wSpATZHA4MxA8j5bqxuMyWkTmN2Ayub0FWYQzW4epIIkCkiDzIKUJhC8K6yCwJJhVkCtQDd34VlUPljE6qUpWKt36kZqPnGIf2TISUCTAFmAnGKz7jOPXhmhWtGsOqXEzGcebU8kSz83qgLbClVBMcKmvpfxqhDsVHaCm4AagVvyg1qt0K06rygHto0Z93NCE0VuhHUTzGAsSbA+PWK9PqOqId8nnN5MoLdnNxO2K8rzFSgEfr8g3QlOEyPlM6yVMACxnwkx+5woMywwqOVUUNYCphnCAiHCMiXcqqPRG3w/wMSAVlgNak8g293w4aayIzJ+mad3X8f0v7AJ4IBzG6mVQNq/7p/qg2SAwmxCLwb6qoZtW/0eaYYc4pHfQ9suHvYueEJg/3T8uUYCPuc07r1b2TBPM4QdrZ0lo1FDqXUgvaecQeTpvZQdX0hhENy24uZZZrQw9XlCpviZNe61ayT3VBVv3rzBotEBGOLfcYg/TRPmacIl0jj+eH3fVEpBnvL4u10EHHOwMDaaKbbaUGvBunpXGXfxLxJHCMz2eB9Gp7Ghtf78Y8/V1AlLozLAkFLGAsIKFzqfywX3b+7x5v4e/+P/5n/Eu7fv8N333+Hf/vt/i4/ffYd//s//Oc6nBefzHe7u7gZWVZuizrPvD0UwTTNqdB6mlHG5XtyAOflcYF5mMAue69PAuXYxZU+S7ZjAnmg6CpvMfP66Qn9RAwAdhaouwHTRqQv4NWokBu7XdsPcEXd5TL4d0ZrH9Orxa47pwZ5gXdcVz8/PL9KGzIzr9YplWfDw8ID/9J/+E96/f49/8k/+yUgNdvHv7u5u/Plf/MVfDAG7C5o90XY+n4eIdxQmjyLWUYTrKeUuAE7T9AKX3L/22KfXcZv9tXmNQO3PrwudR/GwJ//6ewBg/Nyc84vv21+jY49ff116t+kxPXy9XvH09ITHx0dcLpeRFDyfzxARzPM83pPr9Trely6K9g6//v52gfL4XnaTwusKieN7enxtj4Jo/5rT6fT2Ny0AemgjfE0Wg+YeBw/0DCmFq877znaHiaPfiBwXRd1dGnvwNg7fyfseCEgpQ0jwtCpYDKCG59XFr7fL4mP3OMhupXhZbXLBkWOQV5s59i+QXGrh6kID9SRZ8+4fSX4I9NQJwbbmg9zkaTfSnnaLjhh2dxhH0YNo4LSao62WU/KNwJwgmdBahZUKbAWyLNDmqcjEjsdDIiTyYQRZhUAgU4L6xNl7g0g9Vg+BwCCnMzg1XL//hEo+QJubOPrK40IQzDCr7uyVBKueFBLicARFX1Ek/4ZrEQZrPSrNmJIX4LZaMFMGTzmcPwLOU0TNtqHmm3r3mEnaU1WZQA2Q7KKCcnKhq9ROAQSlhAg0QwmYSV1cA0EwITVPZJRbQasKmSYEdTWkCxv4S4r3J4uAkwKWgeaMcn9fJ7RSIepqWYO4CAhB3RTS/HRT1V28SIx2q+BkyCkPoapZ75yrECgsOJwaWBARF7OMunhpOy6okQtd/bt18Txew+4U7yihjmMLaW/gdrlvQEKZ7wg6kHkyFS7+Kbphve1FfzHAaNh77o43x5cqQwgH3/6MMPhFUXD5ScHwtu/gkRLQqiNZBYJHdPWk4vkG5Cnh3XkCmqAnKsoNPxNYSp5QiU3nELjiM+mac++f4T3FFclAT/j5X/D/TkOo6g1SQrvbkymF81Wh5AJATicfhrcWn78b0pRRrj70T1miy8tF9ExAaxsSO6Yog6EaaZJwoVNBDLI0noc/liyM7ZBc7HKeReKUiUOoiGGniJsgWnQOYdeEa1MgVh5C5OToSByxfgHSlOF9a4p2cwND2WqIMeFwxN6xzjn5Bt8cP2rRN6gKJM4gYcySUJvilPz+UKuiFAVPCSx+wy5tjU7BQJLKhJYZ7ebvZ9kUkoCc4n41LY5pCr1YW0XihKqR+LIQgm2NNC6P/pYxf4X7Xzg8JRZCilcACiw+lb0L0Ndm+7LU9u0uAv5X+bUcFtPyWgRcXsmJx0fUxcCCv2/y71c0cOThKOoiTaRUhF8z8fuH3MVBCYRP78aV6P7gSHfQWP+OEeVIfruZ3cKA0TvCxDshST1rwowpnSLFUgF1wV5y9oRzrP/csXHV3fGtFSRWGCeX3jWEAo6UfhicNNJ8fXCfkqBEp6D3kIVTmSySQz609A477/cA+aC+D7MpuhBrT8LEAmDCWP8SfZ/E0VMYgkZTH+bVre5JKesJdtr3Wn1IYpGyhKEZkDmBmDELoTUDkiPAW1WU2iA5QTi7iFfLIXkNJMnQTKhpAwyopQaS1ZFsPOdReJsSwxq7yGl7EokjddWa36NtCKBBvVADxKI7lIYY0DGmGt2SjI6UHyeB5euw/5d7HAbLgAvwCo2hVBzMzQf+rTVImvzzqCEUHLRciviYhqgL5jBKRfJXdhrHEYlLccHv7zfLfj1g6oPzQHcGMaUj9Y7O4T2hsN+EOa5FbnjTMCTglcuUh8AJRFfuEBAR+2Dv0fIhWzwW1SH8qQbmLwZwHVPWA45MiHQjjX1ER6yK0MEkQGOtmDY3/vTDdn9/WnOTYgwm5Nir0fdRvFdE7C7r/v7Ez4/hQn+5OM6ovXZh4EFjU90G9jWwztHTXEs78M5DONUdjU+dNnJwO3sikfezbAyNh5HPDNrMO5UNIJbp6/r/BQXAlFgC8+9Cf4FpdO/ikNCNfWzt9BrDGDQTcYh+Fqj75iQO8TN5a5tXaEgGsX+vjnr0a0CGGkFVQFbBtsX9bvGjVrgzPTUvgE2g6PlkUpgAVH2g7oSR4p/H5qJiJUChoFohIE+opgQ0v3cnAlpmkFYwKhILZF5g8DMrC0MoIxMwB8EGkwApR8dBbNStBvazeg9vI9+7UAWb43Stz0AkgybxfZAZdAO0GuqlQCYCEqFphVna48PJD+xSCVQJVm/QekUTQZ68f4tEkKqiNoCtgUWxFYPkhCxvMCXBWi5ATphP3u2lTcDmhzqyBFOCQDAncv9TmnajFhpI4+yWF79emRsTxZqbZHEwV1kIFFXBkxvHrDFaK94VGcZKN5aHaSLOXZFYmvD11y83oEwpH1MYx1Q4vcL39QH1ft/YhZo+/K3VkyW11egD9L77POZTNAweLYxl3QjSdBcFppwxTRmlVFxvV2zFkXVz/5yHKMVJINXpHjllpJTHn005j/3LEBprHY/BB8/TC6rB7XZDqRXLvKDWinVbDwJYiz7rhGWZsSy9U8yTORxmOCgGjaCn+lPaEafTNEFSwjTNMYfdRqLnOGQHE1JOIU76wB2jBzmNs1rvEkuSQMm/JiVPV/Y0Yk8gisgY+HcU4bIseP/+ve9pWos+MH/PmGUIDkTAsizYts3v49HHBgDzPENV8fz8jJSzGyBqiEjTFOnKNjrJSiljn7ab0fRHwggz56+r9Jf7xcz5SwJgF2f6Z6av/aOQ9RrveRRwjsm/LhAdrxNHg9pRKOvJtM+fP6OUgru7uyGAvX//Hk9PT3j//j0+fPiA5+dnPD09DSHu/v4e7969w4cPH/D4+Ij7+3vknPH+/fsh+PUUW++1e42xfI0zPQqcXQA8/tNF0f53j+LfEWfaBb4ulB6Rn8ef+9pocXwf+rXjmAI89v29TtsdH8Oxc5CIxuPZtg2fPn3C8/PzeE8eHx9hZnj37h3O5zNUFQ8PD3h8fBzdh0SEZVlGQrQ/zmN6souAx5Tia8znEa16/Fwd1r/8tgVAHFBHHecQG5yOGwSZu88No/PGDmP3Xp1AvYMlUEn+beODQ1EQLYJZMuQ84WIbjBIyCN8/3wC7AgxkISyBnjt+8FQNkgW1+WZeiGCeDXMXPiE4bggBE0OASSSBDXGhjMQ751hcM5GUwFl8+NUcV9HTNb0wPueTH245EgaNHRs1ZVhOyJLctRddegCQlwxBha4FYA2MCQBltLVAdYNGuq/dCuq2okXMnoTBqiir8/6l43NY4sYar3uLfr0kkUYAeErQqkOQtOgyUXg/GSeP43D1m6ryDOTsHPy6olLCtJxBtoFIgDShtWtEZRRaCyxln+Jrjd68DDbHl5j4AYvVR+ekDTIvaCVwrHmCtYpqFUZATdlfS2LMcepvm3cnOMdcBgsoT+TMfnJcKxsByZCC887q7iwwe3qhhTNqEpBtqOHsbOrCTBIGEiG6jgOlqZ5kRBzAIhYkMDQmmDoylEE+4O3D6ebrSJjQ2NMaFG50YXEhjz2d4Zgx9YGEYvQEKnSgoXqKAWsbiUvHEaUdM0Udj2XRAdUnX9gPMHFQhgFMX7oUFLxQEl4Lgd/+gQ6xnxIIm78GQEZOUVSbJrxDwxUrFAkTEj4+3YB28cSgJJzygnK7QU5d6krj+5UGZHEMqFd+7gWBigYJaRRxSFD4OVjVncA9JUcsLg62Ep1fPR2mYEoYzE7EsE2SC2cU/Xdw/KZBgBSHzo7DMUBLdcwuGIbmyR0RME+o6mhQ4Riwm3nJeVwbeojTah3JpUxADfEhSUKxcDJHSpFVoeyfVSNGbRjITulDoYFDkcOUKETQFK5mIsiU/ODO7nCmZODCsFrQKmCJ/ZrC3t3TzJ97Ik8CkgkMfvBWn6yBjMGJMbOvnZQSWCpyil4jTlBRcPPUngVyME8JU0rQO0YKkTYnICXPaRJ7F6s2T+fyNMFcY0Cr4ehChdYIjPfSQ2NkiRSSuMg6jCuR+GQBRD31JAmwzV9C7xHoEtvHH6+dv3/NH35GXn+1wG4v/uQLY7PDOv1lzye/9KCRiTLREYfnn+kU3ZZmPd0c19TDgADw97AfclugHHtskALhjOa9nz4g75dRBuL3YI5vZskANRDVcV1h4ui68f1IFxsMhLY5/trHyQprzQ0BafIenS78xT2AtI+cj+u/RK+NxX3Iv7dkQVV1/C44ENauerQQOYr2A0xcPdXGQICYA5nq7n8mgEQg2e+zacrQ5GSAWstAnVptqM2gLHvXFwPNCNXMu4fMQOb4bUkRsot7lbvvPRWkKaFKRU5ulLHsAxNqsaerFarO4ZfsmKYsAiIX+nz9I9Y/QWuDiHq6GoZkLjZq87SCCsO09gfkvR8iewdwT1gCezegMFh9qMjsaNCONNZjvP8f6bD/F1//zGn8pBD+JMlIevVBIKIzuaMlOc4rR3Pn8VDbRTBE6q+/vzj0B7qQF2nf3gnUuznt2Lm3D4hed2f0I1RPjFm/d8Tjf1FMfxDD0L9v9EpTfBbdvWq7CNqTqmFAUG1Q9Wtkaw2lereZ8Z6u6318ve96f7j+ZxLpxkGAGcm4jsvv7nd68SlQdSjj8fnbMBrs+yKKJEdKuzvZQnzTGNrYEPni3Nf3eMfru1/yozMbow/QIr7vdQaIxnTa/z6N9O44+/r9oSf9WnfLDQJCT3j2PicmQTMFjc/nV7Hvl/g1p5QTORbSIu3iZ5qOxe3vq6O0++L11AwHcpMG9hVtCDc+yDEDtPr9PbshlJv5fqBjaI3ASJA0g/QKw+a9fux7QAWBs8T3BpQISp6CM4uOPXFMp19LZv8YtxCs0Jz+0twkRCAUxBpYV4AFE7GfO61CEoMpxzbGzzsTE5aYAdDEwDSN4nT/Wb6fbqU4xpuCfAD1mg0laN7PiDYn2Dz5nbBujvkoCpQNbVPgjlAF0Aw34Eo4KsXNRB0zI3nyWYY6Pj1PGQ0VjQBOZ0x5Q1k3VDDqOUGmDFwyFA1UG7h6SotnT+1kSZgmQpoYWWh0+Yp4558LDUFgQII1Ryxm9XPiujXvhA/jxpQmGBg5+VmQAjGMfs1ncoMFAxooeKZupQYGnuLrr1/s/t/THMDLhFvH3/X/b4f0R//gH3ts+0C5FE/VSRIX6ZiQQvwaXcKxT+jJNo10/kDpRf9dv09M0xQmM0d+a/P7saP4JtRC4/46z8sg/RDtfbO11jiDSIj0Jbq04MjBrWDbvMtSHEGBdXUBMGsafWRTnrAsJzfTlhIimYxZ6hA22RO5KTCn0zwP0/Q0TZhDQLzFz7jdrmitjZ/ZX2eRSD3mPLoWexqQQ4QrpYzkTq0VaoYlggbbunkVUhY3M8Tjfn5+RikbmAV35zvIPwmRIWfHn04ZTDwG9F0M6UJNT/iYWfx8HjhP/706+ge7kKTq9Lcp5xco02P/2nEviWMPzddfv8T6l2Ny6/D74z3rAuBR0HudljuKYMcEYRfWj3/viMM8ikW3222IetfrFQDw/fffj/XSRcgaqIi7u7shjInIEKS6QFVrxTzP+Oabb/DNN9/gdDrh7u5upP6O/XmvU3lHgfMowh0xoMfn97pHsF8HSiluKoikbO8JfI1O7UJdT2EfX/P+8+mAVD6mAo9o1dc40P4Y+j/rur7Amr575wH7nDN++OEHrOs60oWqivv7+xfp8M+fP2NZlvG56PeN12Lp3gurXxT9+r9fC6xHATr+zb9xAZBhw/Yah6Nhsh/tCy9xNJFYAXyQM+yr2Ds2eDhXfRzvL5i7QiGKpIxzOoOnhEzAWipaOMb9xt0G1gu2c7x7ZF3NvN8Phpy9w8YCdUGhmrfWgNoOBwUBzQRZnVNPjeHQOB8IpzR7UiAJWA1TTi78FA18JsCcYQSkZQI2L87mLNiaIRmjdpFqnlC2An3egBzDdQW4Jw5JoOKiZFsdxeFTcQYXCzdPRdscZSFJUKuhoTiWM7CP3ak4DuOhFxnc4cOBGDD1g7B1Y7vu5EQi8scnAs4hNxADAiT2frZWDUkYJQYSttemRMcce7KQAHCk2ibHYVoFWqlI3HwjQgxdK5IQEpILuuE+zJGMq6W5yBqFydKHfSJe2s0GEvN0JfuQTkPeEXLkKCGh+mjRE32lIU3J8WRGmOC9lgCBpwaop09ZOiAS42dC90Gp9HSnIRzp4ZJgAgVGxagz2RklkHPowl5sHL0aJsSO3gPTxabYhXLgl2pgyLqT2i9E/eDrj5bIEZZ9gOkpD+7GV4dhkr1AUv3o12vh4tujQPhaTDgIEd++Fh76H6UhyHHKLuSiIWcAfIbMAmHgtvk7hVaDX/nj/r+oqHVBsPUB/0u1UVjGO+eYWj+MtrgBWIh/oBiaE4PED9MsLiFyDPa7876/WhIio3hUxhEjDUjTAuLozQpxwTijlc2Hx0x+sFdzIVySD4+bYrtuaFoDXwSQKermrH8bMf+eTPTEXotYLRNgrfoQLF4f9b+AZp70a9VTgy4Zu1goge0MCFZoYT6wN/VODOtdBkyONwxDhwijbNWvI8IwbaC8pzAV0eUD73dsrfn1c6vR08ewBggqmimWlNASo0ZHoWUeAki93lB7UloSRKY9AWkVhgqR2S9XquEAdpexCMNqBaSL5IxpmkFYURqQKLnQHpuLoZmHkZlYxua/sYKboGqL9FBPN+6r4MXa+fjHtvz98b9eSn7LTwp/L3/m6zVbflODxTiE04suLA1H7piT847pioRQ34/YaEHFQMb16yxF0p8C5Wkx0Oa4VzgSlAbyz9BxfoEej64KU0OeZhAbtDbv1mWBkkC3AtUGEkJmv47TSMlEz8dtdcQ3cfQrG8q27us/+nlB5CnXon4Fo3A9Nx8aUGf5xwe4GtCa/wyooXWhL8w0OlKAeGk+sUgJdTQGIxIvfk9jITc5RXeOWYu7rg9Cff37eCzn7MO/UmFrccF18kEsV9+fzDlDxcVMCMMyISN7UnHd0LR4qiBPSOEw5jDOmMGTXxR7UhBgAkoJmT2RgUhQmjqCCQBq7fdtf09TTi/WvyQGaSChAt/EBNQwf3QFkFwBXf6Ua8X+xOvvv/X6RyCAcHCOttqGo5dJRiJOow+cIiUIckwt9XOK8xQc89k79w6O4D6IS3lH7pDwwU4QAnvb+zT7gL13bB4TB6Mv0HTvGuzCnwXRon+t7c/62G+qzYd6Hfe59+C5U2EEVc1Tf7W2l/+/d/aqgSgFMjMGB/3nRT96H5j2x6pdTOnPc2Az9+7Bno70g3TcS/v+dFQO2Egzo+M9Y+ACIgjtHX/aLDqF/TwykKy2n3E0hLqOK+yYb4rOehsHfonENA+xtKPHuhOaohIOMSB2gWZPI5p531ENM4LG49id2L4ttH8ka/JP/UsIxGHC9XNsG13r/nnaTbpAx8YG7Joc5OeIev99Jj87esot+T0xu1hGAr8/W+/QTbBYTyBFggKcYLTAxECU/TOYs59DSnVEKLmZ0IqBGoAskGRIgS4GC6oSatnQbheoNRAln5O0inYraJvGukzg7On5xoa6hlmIk6/jtmJKjFnczEYTA0sGOjZMFagKq04qas2iG83QWhn3Mk0EBaOZ+Wce/m+Yoa4VtcX1Vwj1VsClwmZBrcXJCABM2PclLr1B8+wS4+MKe7oB9wnplP0MclmRoJA0QeBzk0qENAPT/Ql13VAuF1itYDJMKYGmUxg+Yi/DvudoMHArsEIgniA5QyZ2BKl6byOlCfNyB6MV2jgM7Q2TEDjNsYeIa3RmaMyG+mfL7wWeMmTye7+pgem3PQD8tf8iIn7d43Qc2L8YkMdcpX9tT5Ht124f/veOuH4GmPLk+FjtA2reMeAdn8cuTqXAfnqnnhtN53mCmmFdV9StgMkFtW3b0GLI77MgGhQT1YZaKtbVxTEngrlx7na9jaG8m3gqrrebp2JUIVN05SXZU+nRp3s+nXA6nV506O6iAY9+c08Z+vNMw2AngeFm5GlCzsmvbzcXO+Zpxum0eO+eJJj4+WKedhFgjjSddRO++ZC/CybT5DnL6+0WA/qEFEIes78XyzzjGs//6WlDSsnTUimhFK8oySnhfDq7mSP5gL4LjcuyIOeMbd1GKszFC4FICuFlwTSl2MtwvJ5pvM8d+ecCKg9B8yjCxP//agD4EwiARzPZUZg54oF76vSInTwmzI7Xji5QHUWuY0LwmAI8in/Pz8+4XC5Y13Wk5frPvd1uuF6vSCnh+++/x9u3b/Hhw4ch+J3PZ/yrf/WvsK4rAOD9+/f4sz/7M7x58+ZFcq6Lf0cU5ct1TC+EvaPodhQAu2D1OuF2TDPebreRuD32eR6/v5+Z60j/9l7CIxa3/9OF/i54DnLgqwTnMQXYk8XruuJ282vfNE148+bNeOzLsuDNmzfjffmP//E/4m//9m/xr//1v8aHDx9wd3f34rkeBeDXwvGxv7CfA46Gxf4ZATBe1/4+HxGj8c9vev2nLuIR+uGPvDpn1wMPAzTEoRUxGJODAw/jENY9lwaAkoCygOcJZIycZgANDYqcGHNm3NaK0zJjqxWX6w3X5w1baftxJw603XDTyHvMpsRIOVwoIDQWT6CARweWV8P75paTd7Sl7FhSJzMyOE2gUIQ97aHI9ycXwZo77lrzhE1mz/3oGg9PDVq8iqfWAqXkIUSryAIUDVctCJL9Zn253ACZ0WrBdt1QygpIoKyaenLIvF9kumMfcmgDGCg3R1MIAWwyhgt+cHYMl+QM1eJ4j/4emaIZuRJC3oVALGAwUo7GlK1AeQaTIAkBVVHYcH28obTmQuTEoCbQ0sC1ouWEokBmQiYGs0IbDfFWrQGtjA8Pp4QsjKu5fVLMYAwXUFhg5Mm85S6j1i766OhvSSK7kOHzUSSPmcGqI0Joykhk3plAhlIAyiG6VEXKHG5SH6I0GBJltPi+WcRRq5EWohBcKNJNQIPQ7iRu6p97Ue9Y6ajPZhp9kTTQSYAPVykwne5Zdsc66fFgG0lE8teHueNsgRRdVTWeA43kiw+8/DGHezuSvf5nCNGYfn7b8u0fe/l4LUT8WGDgCcAi4O0EBjDlCWgNDYIpuzPtems4nxK2VvF8LXh+LriWo6wXNqu2/7en8XzIw7w7/Q1t5zRC/fXBLopK7+4T75kEh4jAyb8u0sFe96ijC4/dTIyUXFzrXYxDkFVfrwD70J82SGByVYFJCMQt3HwVpTas14sPuU3BKWGa044IEwalBDRFSo4wMlNo4xAZAFJBYqCDZsFu5qjx0d1C/BOoP+8Y1bv4py6Qir+W3vfnz6lVhSQFlFCboWwFrVVHGE0CKtqpyX3u4sK/x6NdiAkJPQlQivogxBwTyrPArj6c6EYMYjgqiRzm5PfVBalNaLWi1X79d+dvSgJOfh33GtjNu0ZDgJXEvnac4RmaEIPTjCTqr2FcYwchqd/Nor9WBwqUwfKyO5ME+FFF8qsg4M+LgN++/Etf+PURwD8/rLS87Cvsy3+7/Mx3K1/U+H/1HWBmQavprRz2orNrbMZ4v8al7uQld9X7Z6rjlCMxlqLLoX+PSMSZulBtZNE5HGkCeOrc7w3R/0g28OnWPBWCGA4TuZHI1IW4Ke3J7LpVlFpxu11D5HIE7jSlgaXkwGXBFInd3V5UPe0f+FqySJX39FBct3onZ6kuIgoMQoiEoosKdNjs9tfCe7Q8NSfNwKwo1fHkrTpCVbKv/xbrxwK3quTB9h4vl3G/JpQtRDMFOAsSJ9ht9fUPQgN52iLw2XE3HY7CWgu0xeCCCFPy/Qknv3ZpM0CLC35gGLto0rij4D2ZSSyQzABXH+CFG4pCuLQY7hmFeKEj5QcRiiW0t8JFN/DN/hutjf8aP+NXv/6bmqWO4bJeRX5w69swolF0vfXE2uBUH/c6NK4rw+3eZ7i9y09b87QdKMptMYQ2JzkEFjQ6pln40K1tL36Y6iF/Znv60EU9HWu9I0oHXaUflHk3IFCklTU6SS36u1TNU7lN0dQC79dQqzuZk7Dfd8lThF1kPPYidoTvwITajln7UaKP/XonwuDah6Qaj6MGSp2GoL536YRZ8YBcPYqOSQLROQxcgU+1sPbF3oTiGtuHmL07sSe9vbrdhdq++dvF2kC7xSDWaE95+t9xEclAbjolHuJm32PbeK8AM91+y+v/Vy8ABMIT1tOXundKUXSnCwNKoNbCCNn3CwpVGcItwCH+if+96Aa0eYZB3ETWKoQNSOZozJgfeD+X0zgqJj9vkwtQQp4iojTF/QKOKhUF8QTijMSEpM0Nfs1Qtw3X52dsq/dzpdOCvKRw4ziKy0QAYb8WqYJyAzR7xxUThBIEwESeAKQJoIVAcwrkSWxsmwK1QGsNIo6hbgWtFrdSpQQjQq2BJDeCiUJQYdqwXa9oyoBM4Nnvt56q8+5hq3HIQRrI0QwC5RlEwEYbdIuO4pwh0xlZgVq20XFP7KbynAVtItQ5Y0sZtm5h9kkgpKA2NCTSMD5PnuIsV6A2rz5obkI01DCsE6wBKWfMnNCsghoc8wlPFaoAVsO4nvwa36pGbU18hiIt2fuh1VPX/9g0+T+tAUDEXqevekplpDFoR2Z6j7e86Pvqwl9Pi+3pkwPqr8WgOESp0+m0p9Lj552Wk99Hot8WFj9b3GyWJHmkgt2IPeUcRIE4fcT9tqddHp8ecXm+oLaGeXZxTQQDhdexc32OgJgdMEXyMSoL+lD7tCy4f/NmPPZjGkmSgJqiVk8RuiBGyCEY9O5xJQKxU9Ja7B/W2y2SeIz7uze4Xm4hBnSDEA/xsCdunETgafp1XSPJaLh/82bgOG/r6lStlMHTjmsUTjidzkiSkHPCw8NnPD4+ujHLgGk6vUiAUpiKtrKhxHM7LcsL3xbgGNC3797hdr0O7GmNuco4Cwm/EAqOvWg/IQB+Xf+/4C9V1Z9CMx7xnl3U6QLRUfzvab7+vh4TZq/For72jknAbdtwuVyG8He9XvHw8ID7+3u8f/8ep9MJKSU8PDxgXVd88803YGb8h//wH/wz9/btMCvc399DRHA+n3F/f/8i8XcUlo5dk1963sevO3b/HcW/43N7Lf51wa2jfY8i67FLsf+MLtJ1NOeyLD/qUjz2EfZE4kgcd8T/QVjsX9tTxZfLBU9PT7hcLrjdbvjw4QNOpxNqrbhcLmitYZombNuGf/Ev/gW+//57XC6X0ZvYk3/9uR9/9pfE434POT731/2ROefxXLsYfExeqmr7TQuAXSgIT4j3W/SOk45sGYdbL0HurteoqBgDqA7mwOHAC/IBk7APt7IYSm2ewBLvyELzD1YmwkkSqjSc8oSGgqbBZWbywXufunbbZryh/fDe421UnOljMHAF0uIHAyoNZtVRU5EWYTbHasbN7HQ+IS8n1K0gEwOcXQCY/CANALpVcGJU9Rv2PGV3qpHz46sWsGRMksCS0K4rNm3+PVLG89NnlLbh+nDD5XLFu3/2O9/IMkHOE9qmSOTKxna9+uEn4umqkY4URq3hhJcQMzNHhwHBR//7ADyRocQwsMUQEOGEIhE0YnAzTywKoFtBJUWeXMNzccMTjCbsg8LUQOwYFQ+c+OCOzDwRRYRGCZIoDmEEkoTpDOjtilZiM0dAMS93d/eSuyU5J+eiNwMnjoLiFEJnoNKKYxGIMFKhhoLmLETvWVR38Wdh/+iwYkOgmTgGLmFDrpt3N7LbyRABrThIRAF6EuS8Ox+609q0eScJALY4eFJHh3AMGhvUooMSkXgKZyPI318yR5lypF5crWesRnHwxN7FhBhIRUcLH6ZeI5cbXTP2wnH+9zUv/P0SRD0axSzOfw99qLUGU+/HEhGgbKitIiHhJBklAW8y8Ni/QQNU6uFUcNggAIHE7V0xHbEV6KY+gEvp8Ocu4sE80dY3fqwKye64TdMc3TaOG2TJ3lPnwViU0lxcCFwWIVLI1lzwJz8gskyBeXUhQOEb6/VyQbnesNUVIEGeEhBF1jJ5GqH1Hk8Dagj9IBk9dSkQRBy9mo0BE+8qqzWSfU1duPfgNVrzpGKET304kSUwaj6oz1lcTCeGtgqtFdoqmjlWiTNDizuqJOcOLXSXFQWi87Bfa+x4TxIXGUGMNGdg9aFE3/zEj3dMs3nCEMRIgXdppWJaknfCdqUu8IYNwDQJSvNDifb+UdVdyGdf/9K8exDN06gcaT8/FAIphgjMEqXl/npLEtSbY1tb2RGgPyfzvQ7TfnzxJ9/+rCT47c+sqZff84jnzT+xTvff//gn2lz81zgZdYeVvXBoHbF1NobkFKmWgdgzG4lNlhQ43u4862mvfQ9BZpCUQDkjz/NYD96rm/zaEC7wWhVadSRZumBlkR4YfXySkdQRg+1QQH27XFDWm3dqMoOm7PdgNUgOFG1TiAmameOq4RdQgRtKEtEwn1isf4jAwGjFxT9t6kYpBsRsdIP50JtAnMJJzKMbJAdKHIGw1ubO4xZYXEnieHFVH471TjQ1T8FTzE9jN8gMGPfn57+R5wm4eVdHv/8rWbxvgKKF1T4hxTpspfn6Fx7GDTRDDlNDnhO2aoEojwu8Rfw7DgA5hnul2AuCgsbBz4OInioQ9oSzY5o9NbhZ9TRgDVSU6e3rsP8X/ZnURdoDmiSEqL2QtQt/XdRXM8fRR3cYjn2AISwgTCEWLnWO0snREGc7OswFpIMIGWI0UyTigJe9g0eP1ZHugB0rNES42Mux7HszF950HJB36gMPJ1RPzbVYozV6zlR9j6HqqQLvHtuHdF2gwyENOIYLh8d5dOp2GgGx9337PVMPA4Li+5v+Wqh59zfvtIo9heCvmWBPUUoIfcLRidiFPWIIe48qd2OPBrWD9qFIF2kxej0RPbHsSE/Q2CN6KlRHwlFHstz3ycPAF6ZTx6gHCrZ/LkIg1Fqfv67/XzABQNFQqxYgbfXPFXlCXzjWDWSsbUDjPQvHslHgu2mcewy+5yUhkInfv0uF8AROAstLYFMa2BJIouuOvOKiFu+x82qT2esoxKIXr4HYk/nCCaRznC03NAO2usX+/xl1LVAW0Jkhkn3dnXyfos3vMbU2tFr84pUkcsyEZITEjulOM4HOPf0n6F2g3jVQgLbBWkUrQNka1rKhaUOOIRzDos7D1xm3oINYA1kBVEAkjt6egBrXGILfm9G03yRBmZFWDtOx99bTcvakHQScJkznM9pjQ6t1oDaV4GZIdkEAllB4gpUCawYtinxOvrmIs640RQqjLTJgrLBWoMWnUaQKai4AGvveJoHQmEBIQ8hnrTCW0QsPApIkqDXfyyVGA4GbJ5YBQ1PD9bY+fh3T/4IDypSoCzw93dHFvU4Hw0GgeY1r7PPIgdkeKfZd9Nm2bcxx5mXGmxDR+gAZwBgwAwhU3Rbz0C4oEHJOaFMbaX0R77DsxpI+Ky5bwcPnBzx8fkAtNZ6noDthukjZUyfMntbxjrt5zD0pDPF9SH13PuPt23dIWaLDjsbQfJoyLpfrGPq35mSdNGYzdOi9Y9zoFgJIxfXiHYeO6Uy4f3PvZp8QA0YK65DK9MdL4+d1wkLZtvF4a62orSFN3oVoaihaILMgT/4+tJjzPj494nq54Hw6j32avz81Zn+EZZ6DAAWUEPa6ANTFhnn2uU5PM3UaQ+//C9EZpWzIeYr6oR1LfkyJGQz1v8L9/+uvn9//v8auvu6SGzSQAwrymPo7dre9+LwehLT+9/vX+iyojZTctm2R+vVezPP5DBHB+/fvsSwLUkq4u7vDP/2n/3SIRO/fv8ft5mL5siyY5xl3d3cD9dmFw/7ZPIp8L/Zur8SrY9KtJ9TcQHAaP6fjN48d5P116UnF6/U6ntcBafnicfR5xVEcO+JD+3o4impHNOvxvXktYh4f9/V6hapiXVd8/vwZv//97/H999/j/fv3uLu7AxENYbDjfv/sz/4MqorL5TLQwr3H8Ij47KLu8ZxzFPWP7/nrr08pjWvVURjs/6zr+vSbvr/ComvCfIjMZMP9ORjagUrZyfvc70GjHJ1ie+5GfB4HrNaTMaQA5+hXap5gYx8Wvz3PABRbUdgESFW8PU2YbgX/+eMDSASZGddIyxBlWBR+T0aR8HMWy0BTSuf+K9gjeWjd3dqyb3RFkIy9p23JyMaY54TldAKKJ+04zZ42UnTWpuMfSVBvLhQJCBqOGBWFlhV5XkCVodvmc6ymKLcrqiaUrcC0IjFjejND3i5Y3t7BtopaWqClDLWuflhlC9evhhgUfRTNEUi9hp6YkWM4X1sMKswTQo5P87/aWh3Dda2G9GbCkrwzT1WRmnmPGBgTM9rsJei3WiHJD9VNHY9EEfU3hPuXwzG3OQ4NE4NzOGui6FiYMRHBckZNk9/4DZhaRYOiNgYnQqubo/g6isfM0x0pA9x8WE8tUkf+nrP4IaaRoK6KaCALMbAPjNxVlU6MpjekjjKCu/9riHcW7X3CFHhKHygnBbZwdIl4IqEpYSM/IMzavDeAxHGoXWgygmqL7x0RKuLoTIrhDnuajMdZlXp4AgpDM/PNDWV0tCmOLmvb07eMQ/cKKHBZu4gP2MuY0rc/oWD8UYnALwsPpQGeL62AJDR4/tfd5RMYjHdvJkAaSmkAFuQNuP8mQ9aM5lV/ofslNAQiVDrWFJGO9XSkpJ9yEvt1yKyhWQOrgFNHR4XDVhiSBWmax6uXpwSQuAggEki81u1JLoqpJ0qaVZC26B1hoG4jWaKm6O96a8WTxZkxT3eOymUZaUU1v3aqKdaq/r1CsZMpxL0QJ9FTfFnQIvlsgJssmncCOeIvEL21oXm+FaLuehafqYzPOgdSrJbNXbnLBF0BK4p6GCh5t1gDk4x3vpiGyOufCCU3PFD/NNbqB4mUwAujlOZifvRuatwXfGgHVK2ISg6kqM/kjrotjmaS5IKCxXW2bo584RDHtflBLUegwxMFDUQCjQGq36hcKLXaBpKUwGByhCoHArQetOiUF7zBDeX2LW7furT27RcQoN/+pDz4h0Gh5ea6Xw797+MBCPrtz67B/MU1+l8LTfonGVz2hEhH6x4m7bsrsHdVWRRxugGlP0gayE8X6NQAUkPKL4VFR1Qm5DwFLixwkHHIlyQwpn3YZYRqDUwKtj689/J5I+/vMyuxVmL9U0dvOeKa8gnIKXB39HL9q2JrvdvIh+mJBKWFwcciAi8Gyg4vbWCYevpPmzvze8+XxvrX/ooNdKZ3dwl5J4gHktwIw0KYlgm2VlhpKNXGK94NsIm9/8/MUJobbdSAFMIkh0uXYLH+xXuMlglbaUg5RZLQ0eKNGK02v2uoFyuRhCEmjF5M7BQCOII9LRkGwpwUZaz/jkkMDHMID6oEpjYGQYq9o80TYHAcPXVxV/euMAoqee9uqe3Tr20I/9/Tz9k79XyN9+Xv72M3/fXrBEVX3y7uqRkkHPhuVOSX2B+LvOnhAM7MnsqNJJgP4yz2ToG0HFB3vw9L4LJeOm6xH5L65WgU/dEwM6Cn6gwv+j6IjgOJwGh2pCXFYCOMAi06AGuk/zo+bOCDae/LpEi7SZy/jsO73qfYMfj9wNxFz91W5iaCFoW4XjPm/11qhSTxrtYQI/pZr6cner9if84Wj8PFPTcaWaRsnOTgJAxPdFOkAF0U6p3vO8Kz42FpYMtVbRhWLYRRvMId+TXAO0Nj6z0wo6r+WWm2D5QMQC3t+R/r+v/TJADMPNka96XRvRYGyv6ZJJ85+GfRd5tqOnpxEZQQa+bGOop7dCTpkzCYJzBn0DQB6ilXJAMhxX1WYRKi2ObmOlf2quMg1cBt87O1JWjZYHqDUYl9eYMlTwcmVNiSQOczNE+QKfsZuTVHnZr3d27VUNXvnTlFWpmcFuONIYxpZvB9Ap1n7/6DwDYFSnXxT4v36ZaGslZszVC7iThSj/4S+XnWDZYa513DdHeCVGArBN2iQZ3Me/r6O9IqoBOC/xkJbZ+X5OXkOqRVtHUFISFLgp1O2LYCE0EyQo3Bm8gSa3kDCaFxAmkDGyNRc0ND1H6QNQib7//FKzysNJQtUF3mQmTvNkTzazdHtYChQluJgWq4S1tY4XtPslY36pLt/anmAuDltn3C11+/3P1fWP3YWF8Mpcd1m/Ai3XIckO8umd3w4wmYMoSAnvQB3NQ9TdPo6qq1C0cJyzJjOZ3GILqUsidH1L9HT6azu0yw1QLUbfy5JIGwYN02F5gk4TQvmOYphtoyEjoaf2ck+IQjqRd9ezFk7+mX8/mMu7s7vHn7ZpyZ1vU20IM9zeSJyCMW0O/3rTrunmNof7s5jo9C9GvWvNIosPjCQVk7CBE+H2FM04Tb7TbMT8c00u12AzPhdDrjdFpA5InL3olGYWrswl1/3q01T+RGX2NKCbfbipwT5plC9DihloLL9RoCp6GFyMjMmKaMWh2fuq4rSiljf3IUhHPOYSA/BFoOIsrxRltr/fx1lf6JFcFXAuBr0eyYXnv99Ue05zEZ14XfLrwfE19HY0G/PnTB600kWo+pud7tdzqdRkLtzZs3uL+/H79/7Pk7CnCvr3E/9/yP4t+yLEMA7Ib643PtYmbvMHx8fMTj4+Po8+zpwZ6M7MnajsHtj23btiHU9TV07GU9CoD9NXrdm3fsL8w543Q64f7+fnSenk4nTNMEIsLHjx/x3XffvUj3dUHwKC5er1eUUoY42HsCuxjbr/dHc0i/vvbH340Xx+tANw3053nsPYyf+5te/2lHDlpUQvvmjjpWinngQdHTRp2DfnDlGtmL/F8vszdrEPKLbjOgtJ3FCyHcLRmEhJQZ/+X7Z1QrmO5mvPvwFp8+XfE3Hz97WXwc9Dx1rkgTI1EM4Wv1+D31NGLy8gBTsDEai6cAk8GSAM2RMjkxWmlePH0toJRhGSiXzVnQib2zrKqzp+cJaNWTXUXRbu4CQt0wTQvUCGVdIfOEtl69u40N1Yo7BxmOqtQNU3a3Ss4VLWXoWgFrLi5shq1u7mgVhsWBl4Qd2qrs36+F0NcAmQScBM3aoLOS+sDON7+B5TREksfdbjm6yeptBSdBPiek2R3+BEeLypwxL4Tr4+ZYTu2HeIVCYK068os9HVeqH/xNa4htvlET8tFjrQpMORQc7y6woqjsH8g0C4yAbSven5cFmSZkuIiToEhqUIbzDgVQZB8RHQ7oS06o5sP8FGm8VqNnrQLlegULoUXHeZSwedIvsGAesepYTR98KIkXt8fFQM1cIDCgdoFWxMdEzpIcnTQEP7SBDBUKNRdRjTCSiNL7mNSH1WLwFBozoBVmMlzaagZO6m5Ga46t62JLuJv2zr+OXNr7On9W/MPPi38/7ht7rW2UuLF6UXSDD1Zb9XQJmHE3uziUsuC/fP+E2lbk+wXffnuP73+44tPffUJD8V6o4e+NwwH27jnShpwAqMAkhj6tozewC2UijruNrsqYL4MEEEpgmTx52kv/oseRSLwXLzOgDNSGbd18mBCBNIs0GglBuaNHmyNC+tiwi1lzDsE5weLPqSm2W4/ke2+dO2j7DEPRWjy3bm52+hGqcAiIjFodh9lqwWl280SCdwJRf924C35dRA2soIwPlgslTKAsmGWGXQuu6wZAhiu+NU/eUYgOyymFgK3RQxodW/BEUi1ufKhwHCxNya9lBlQ4ChUsmCRhu61oWkEpQQmYckJOEl4SxysG6ClMJhyIlkAdgSHJZzSlqsscVjERY43Pjql3JfbhIKtfUvqHjGQYguMz52lP1ebdpRkoj4dg3sc/rJ2/TPr9sQjQn5MQPfn38SeFvx//nV/7ELH/fIKZdaGr4zZNDwMAGinuPiBU875UbTFx70N4OE5LQGOobuoCG4mnS1i8B4Ii1krJE9pEDAvhSrUBrWG7bdAwM1FggKUjRoXDEtX2YXoYqYgIecpQTE4pYDcwkRq224rSufnk6T+IdxdR4KaTsGPu4sLTBGjMMPNPZynVU76tYZkEmQgCQ+04zDBzSVxD2Hbs9L7+wzQkAqSEiQVKBbauI8HjiCRHnXrCWQPTYy8Qo5IkBIOGWjzVh+gInDkWqJqPE4WdCiGC9bY6pisnR77P4VY2igGuRZrerTou2BMILRDFYTQwYIvEHqwhk4ulGqmhnmRyQcjTf2YhOjLBGrlpJpJMHGklVYM1/eG/x0H/r2X9m6nysdNP98OkBYkCsQ8S2g/27hLH2Af59YLGPshiP9gTwXs6D7t4FNQNjpvIPjSLPUcYtzTE9ZEUPA4pqe/fOcR434PsfX48/j9RxNR7uvGQWOj9611/8wGhjqHUEfmp8Q/D0+wpRfKPjwORQIGGY36g1A6Pj7in7EJYNRdCMTA6CcxtJLHMInUcfXtuxjr0txohJe/UFOEXr3nvFhTxfVON4d/udvZPhYuigR4bQx/CPv+xHZ+KHZVK5AaAEv2RLj7yEFH7UNT05aClpza0aYjFvsdqzQ1WZV0/fxX6frlftWytlhmmEnhp38x7n5PEkc32rlcA4ASW5mcB5fFZYCKYSGAnzc9LxZAbeT3INIHyBFAGrIISAVnccFj9TEcp6irKFfVpddNrIGSbiSP38/7YQBuIDUaMap7cJ1LwlJExQyRDJR55rdguV6y3mydsIG64S+Szi0gwi2TkKWNWw0kU6ZxA5wXIZ5/PVAO2CtQCWAG2DboptlVDiHNxjk0hWoHNzyxI3k84PvcU2Ozznc8aLg26tkCqetqxRpLIBUAFJvJDUIJTmAxIU/KuYitoN0bThGlmTNOClGeU1tC2Evttp/44eWEDqGBjAk8Js2RffWFUMi0AVu9wThOMUqCKFK0ClhiZCUwGJUaDAM3P7cTiRJKiYRCSSJVGVQhc0PHXyfePHfTsoklFa4rb+lUA/EUFQGI7Duz7ELcnz4/JjVrLC1HgtZFw3OeER8q+1QI1RSJHfJ6Wkyc/I102BurCmGIgXEvBxYDr9RrmoZgBhfGGxQWyUitabT5MZzfmNfMO09PpjLu73mHI0dvrXXmfHx+xrQVEhpSyG+Rib5FzChzpghTov/P5jNOyYF4c/9fTbaqK07IMcc1FSkZO2f/JKc7mdNiD+GtXaxmEj3mZIUlw4xv0+nIA3uL+2UW+lBLOITZs2xZkA/HXIp6fixcuXOSU0MxnuK0pcp78Oh0iYP+ed+c7nM9nlFrD9NQCOx7Gyo77Q0e6NqScsSwnrNu6G0nVk5lTdBVerze/nuSMNHqJ/escvyovBKNjAjAEkY9fV+kv96u1Vo/mvNci2EujsL1Y58frxPH3+me3XzeOxr/Xv7cjbff+0H5N6OJ7/5ouKNVahzjf0bddGHstXH7p8f6h53oU247ozy7gHdOqXcC7Xq9D9Ht4eMDnz59H6u6ITu0iWxfgjgm/Lo5t24br9Tr6ELsZ4ogkfS0Cfkms7V8/TRPu7+9fCHI9ndi7FD99+oTT6YR/9s/+2RAD+/M8okn7e9Gff0819+fZk5H990opL8wl/Xv2LsMjXrWLn8fr3+12+40LgLa7WWX07NB+aO6H6nBzgBhKvqka3WyRluqO6zDHo/PsyYDEglYqtBTfsIsgzxnTnH34WxXKCee7hKv5YP75esNpSXHAjq5C6/1Yjp4CGCriQ0BTGMX/h5c2U06QcH9aDL0dTeObvxTYSxFGnjOWLBBXEAB2JyyZQlPyw2tVNCWsDxfHaVwvQGuQbxiQhEyMnGQUfZ7f3kXybUNNPoDOMkNBKGuUildFrRtaURRtcbHx4aNVwNjdb7p5usidUT69T+xDaw6hoqlF9x9FEqCByL/O2AUtER6iQEqAbBV8miCzC4OtdaexgmcXU60RljzjIldYMlD1gaKAkBFJKlYkTqhFQYmhSj185pN2S2BVgCuUBLkPCQiYk/dybaqYcsZ22SA5gVpFK8WFyensHY/UAHOsLDRwpSSQ2nygqgwrBXSakdQ37OvWfPAAoIn3NFaRGNwAQIM1R5EYCGgEkehWjNQHxyGSO3KE3NVo0FCmoyfMOPonGtJwoRMy+yGyd1FBXTZTEcBaJGx90TGiV2mfHbvLux06cOAdJr5eA3UG/9le0+nTXDJPNvavtyP68yP+sGLxo18/hRn8knDoG7YkQNsqWtn8tWPxQ+CSQJpQmjfHnd6c/eJcgct1RQtxQxvQpI4ewNCOXdeLKKDfq/wzgKbRsLj/OXMYF0Kca5F864lQTuIO2M62FkFO2a9nTaPrQqBbxfa8YXu6oT7fwFqR78/g0+xdeJHQS3PCNAssuYBcmkXHDMDTBAZhLcXfU4t0TnN0ce+gS8IwCrd9YHv99fQnFC1CaOpioRZF2xq0KuYkSPHCtDDAEu/VfVkEiQMPygCn6CmI4WpQAcHEqLFOUmJsxVN+FY5AltYwJcFaAVW/yFZTTHH/0MivEkeiigNxGj8jJUHZigsbBOTEKFuBkK8ztYrz6YRJ5uhXdIEyxoaB3vX7UVNHnjVz9Kn3Mfj1qWlDrwWaUsJW1XtjzLsiRQCYDLooAv2pAxsnUDTY3rro8byfkdVeJwC/HYLel7N/H78orv8x6/FLazP/aoeIf+zPVbXa+7GUbCB/Olp5YH4s1n8M42pTt0EcNs6uF7oC33GPoHDux/pPLCPiyZKCE+/JAa0VUIauFdvTiu35hvp0BUMx3Z3Ay+QplUj6yiyY5gQTdgGuKqo2vw5NExje09maC/OO2tUhZKuaD7rYHC3dNLrsGEnIxX8E8tP8+bTaoKVCa8Mk7IaEGNj5Zzig0+RdsjmGFR2lBtrJCYjkO7Mn8kwdSUxVHWtkhqoGac33PCVw8sJo2sb90jHk0aWYYvAWgiGzHwJqq0hMUPY0RtXifU3kfSKn0wlzyuPv9FIU6u2ugf30brfYIyV/HftjaK15BTIBOQlK0ehEjf0rRy/o4XPT0/d9YAToECBUFSjl//tbRvj92te/mVUaAv4R99i887KbAQ7dy918CCMX3wijL096mi66X/2g6B2PHVWJwKz3jsDeISRh9oJaOMcxzki9b47BLr51pLX2lIAeehPC/8jiZADbaShdjO4pp44NBvk1CIhhXvz+tm7+3wf850Dh5IQU2M9+390PrwSRFHhQcdwt0xiC7Sm3WGN9uBICeDsMJ/pjHWuipyObwpIPbUF7upnH2TJSmS9mG/v3U9V4zcOkEQKumVchdDwrrKOGaSCH9UBK8QSgxuGdRsrQhaS41tk+jOnJQzM7CJQ20oNj0Ahge3z8n78iPH+5X6XU1mqBagYsRWXCoeMTkbpXR/5qJOA7qaiZp3EkPmci7EbaEH3RmiflIKDFzS7Yiv/+PPs/a/V+uaKwStDnivLDDevHZ5SPnyDtivz+PdL7e7+O1IImDFkYaXbRsKmBlFDVKRcpZ+/Y1oY6zKkV29aco8QAaZh0xHt/tXiqZT4zznPGKTOmeQLOJyDdgywBVWHbBtsKSD2B1G4V2wYUI7Tg2Sfy7y2msX7CqBB7o45PNXZyTWud0KF96aBpw1Yras1Itfi5ZxJgSqCpQJpBzKlSTOaMck4wBrbSvMcwObWIqhNKmAA2TyQ2aRAlzMmpDBOSG47EwGwBYvDzBsFTkepFwm62FYAnBlFyU20zGEe9BveBSFRsRHKYSeJ8HNc9JpCGEEgC4h3HXFXx/efH//nrmP4XvO6ZtdddVl8a5O/I5vpiAHxEge5JHx/Ee7+fQVgwTT7Yz1NGqY7PTNHVFUIPrtcLmAXXywXPlxh+bxskOTWsG1fK9QaDYZ5mLPOC5bQElttRniyM+9M9iNyst21r/FnB7XaDEGOepiFctdYCFepD7CW6/npS0RMzGSIJpRTc1luk51zU9s7BbQzBe4JpiBIcfcdhEuLAK1M/O4cpymLf699j9lkCe2KvJ31Oiz/XaZqGkVGbo34VXrEwTdNIA1qIFk4l8rsqi4yEY+8HG0mkdR3JRZHYWxhQyoZaZewlSDwFlKeMuUzYQgSp8bqcz2c8fn70PVSt0IN4wNhJEkfh44iT7J+xp6en/+nrKv3ltz7HZNbrNNnPGggOHdbHzsB+3TjihL+UUjsK20cB8Ija7J+NbdvG3vv4d0opI6V2Op2GuNQFqaOgdBQFj8Lb6zRj/7td/OvXgv58d1Og9+d9/vwZnz59wvfff48ffvgBz8/PQ/jq19X+Wrz+3B8/+8f/fn5+xuPjI56fn/HNN99gmqYXollKaaTrjsm516Jnf53v7++HkP+3f/u3eHh4wPfff4/vvvsO//Jf/kt8+PBhPK7WGj59+oSHhweY2RAs//zP//wF7rSLj8fuwdfPq4uE/bNxNJW8FkWPeFAiwt/8zd/829+0ANiPPLQX/oUTakdv6S5NhBMqBq89KRGlyBboSiKKr4nujkC4UKC7BBxdNkAlwjwl3E8TPkCQEuHxecVff/yE69MViQmlOLLDX/R+0Y98DQNJFdAGyjkctPFBTSkOAn4gJ6RIOfqbOyXHbikTpikjn2ZkyajXG1pdcbq/BysCGQVsDxe02wp9rrg+fQ40lzv3b7eM0/sJaoy1FC+1TRlTTiiqYJoclbUWyMlTRrCbH25bAcKZxzkhmb9uZbs57ZA9AbnWClFBygxLQDL/GbA2ImxWvStL1bBdN0/qJRkCLjEgQsjxPjIEKfnmIQl7ci1EVp69b2d9vuHy9AyVhJwZVtwVaeIlv5QZU8oQcRynxHvQS9abNqTkahZLhghBt4Zbi83EyfGFiRRmN7Sniy+8PGGeFxiaDzhLhZGiwm/itjYwVbSUQGX1jcjkXDeasieKiJAzoTSDVhcPJHo9hN0kCTQkMGr0vBDCXQ1PXVqoJx0XA5B3FVBC4gyh5t0PxCCJn9OHB+QDySyCKfn7ozGwyuwXodowhlU9eqR95Ri8ywaMquSItxhQsXWMaJ9PuMA3MFfdVR4Pfne6G/af9A8R+A5dYn9QNPSGtp60A8Q3jiIQCCox5iXhzTThfTjWny8r/vrjA66fr5Affa/qQ9sWjz96OvylkMGA74O2XhMgY+7mm8fuJYY5+hM5wVKK98YGaoIjYXTbNrAZSlHUzzfo4w1lvQLX4oLXPOH05oSUaBC/ZBKk5RRJuYaJGasUkCAY+v6isAFrae5GBeN0N8EM2C6bi2Ti16xWind6LRnTKWFTADyhlRB8S0UtK7RUCAA+vO7eg+jJNWYgQQbur4sdEALHpoUNjk5mFyasNu8VA5CyD1asOBqzdV9C79GzPYHpoefAq1LvIvJ7SqsVlBgMF/Nr2aCloZbih4A8Q+bZB74tEjeqLlT2tcGpK0Ww5mkjleSdHsqQ7GJRUoVtkb5lDjFHoVax5xQksIjHz5Z4mvFVHzPD8bYpL8jLDZ14gm+Bjx+/rIUvr5igy8eXQt9Pa/F7zs//c/mJNdc7APNP/P4fJwr+moaVEa5+0VY6Bved4maORxb2hF+HBRp3vDn29AtiH4G984nTcf079oqYvfOPXAxf1w0Mw7Yp2uMN7fGKcluBdQWYUXLGOda/qh9m05R8/ZtCW0POCaoVLN3M0dc/Yd2K93MSYblbvC/j6h3IPnBitFJhVZEXxnxKKObJZK2+GKwW1C16NckNXVYNSjvSSs1FNSFGFtqTNex9yNLXv/TOXYOWBisFWlv0DTsWyIqn72ozT/cHOq8aeedvM8ddR5KY2QVWvyZHigax/oUdfbQWtFLAnDDlGamv/9rcjNP7xEC+X2JPE1pTTx4ngUkCaQUs+gqtIolFb6onEB3j3KJPWcO8Fn3IIyWxJ6M0rgs2YOGEprbZtv1ff4uD/t9OejC6rMizVwObebwSG16k+YY5Ci7iDYtj76AOtObuDD4Wwcf8eDwTF4xy5hdGyC5E7wk9v+l33FQXJcf3BPb+5SCktC4sCg2BkjsKFMfujx0j3s2BrTaU4gmcVn1AaNq8zsAUSSg6lv2e64OGvSdp6GO0D1R80B+JXqbRf9P6689xZtO649c63pNpIDz74TulKVJEbjJAJAVV7SCq2egAswO6yV/bFOleGp2lfZAQ5hD086uLicdEIcZrub+3NNauWTsInX497qKffyisv6WBb6fR801M0Kaota31u+//T1/X/y/3qzZVi80eHXocLdZTx3u4WOPpTL8ekItXHQce60hkirR+9aScEWTKoLsFuDv7pk8rkAk4TX7mqBtwW9FKQbsq6t89YftP36F9/gx7+OQp5DdvIbNXiBgqlAyyCGSe/LMWorVN5j11/uRgBUAjaDGU4l3lp9MCqOH2+YatuemoGaGuDakqeFYsEzDdL8B8BtIJpMlFyqbAVkGtAltBu1VcN8PWDIUYjVxkS8JIbJ4AJPdV9pQkEfuGXnwdtMsVZfP+QIJ4zYh64UtrwFYU0wbwFBjQNAHzBtoUpA3UNEQ0Ny5BDKV6l5pa9IEnAjdDvd2guIBoQk4z6G5BI/PeUQPABmJ18c5iYOcYD5BWSEpAntBK9EQwgRKQzetAzBLAGWgd59dGqp/YOxiFKCg/kYJOAmoAtNd1+GdzLXX9/Q+f/y9fZ/S/6C99nRwZaUCWF4P7nu44DrZHKsgO99O4xmuI3ykwdBIDa4W6OJaT7x+bm2ou1wtqKXh6fMLT03OgKj0px8I4nc5Y2M+9vXvv3TffgJldgJOEFGg9/72CWgpu1xueL8+43W7IacKb+3uwCJ6enhwnOE0QYVwuFzcFJhfx3rx9i9M8YzktaK1Fx98N21YOSb4NZdvi93w/REI7sjMoUWY6Uv1ufJrHvbCGeLaVAhBhirlISgm11RBS9YU4Mc8Tti1jKxvWwPEK+9/1pFJCi9e1i3jaDM/lgnXdMM87ktDMcL3efpSk0rgfd3SoanEcY0poW0PThpMsg9jRB//CLp6o7T1hA7Uaxi05iEVHQfmImW2trY+Pj//3r0v0l/vVWqvH1NaLk8EXEmVHAa0LTl3I6Z/N10Lb6369I7ayCz5d1OpJu2PPXhfberdeT7GVUnC5XF4YF3LOLxClXZQ89uW96DjdjRAvxM+j+DfP8xDAjqjfntR7eHjADz/8MP55fHwc/X1HYa+U4mL8oQ/ztbjZBb3+szpS9Ha7jcfxugfwNZK1i2v997oI2r++f4+//Mu/xP39PaZpgqp6fyfR6GUEMLpap2nC27dvx9f2bsP+WPr72F+/I8r3dU/iUWRU1SH+lVJGt2n8+frv//2//z//pgVAon28ZkwjYaK2o7aG8X78Ty+gp0HmIuPA5HDcbAmNvFyaoVCtUFNkElQYUmZMKXB8SbCc7vFBBHV1B9zd0w3trgRawhX0qgnXraAEe59EvEgeCmN3sEmUtbdIBUpK6IgYCndgiuhQ24A0eYeMsaCsjutTNJze3SNxBm4V2oDrd59QNmfS2/MKOcUgdVMX9ObsCM3T5OjL6g70LdjVTQ2ynJCyH1qqAsobrFaA3VFrpTqeT6JvonjehNkFjTx7VyIJQ2JzyyJozW9+bd1Q0VCKopWGy1bAPDlaLDoPpSfIJkEWRp4TamqAJUyUwcl7/2yvF/OEY3L8JKr3ojVVtOqDsWoNYgJu4inL5IdxYYbVffOPZk7/au66k8mTOdtq/vmIbqNaKzhNYAVoSmiYIaV44kASshlymlAYjhOLovOcxZEMHMzy2wakDAHhBMOmDUgJjQDdKkgBaI1Bw45UtOpdUkQdjeipV41BE8Snzt3N7HhWCpEbB1dFJLlMYWxIlFBhaNp8GBQ4AiOBw1TJXY0Mz3Vwh3n6kGjTjsDyg4gRw+D9dN05zj3BYLtBtvcX9b4bPrpmvsWX//+XRMAviX3f/sTXfwTwbXaITQNctgXOLKjaQAmYMh/W/xm/S77+jRl3j1fUu4yn5/17avPhuTYn8wwlpouK7GhLjrmAD2v6TdQlMb+p8pA/RRLSMoGW2XFY5qKWu8cSrAD1tgG3DeVSoLcb9LYCJMinDJwyiIH8fgYvsjuCrEGyv7c+uHJBoRWgaRmpMr+OaiA0K0hSuE39cbZWwYH8a/CDO0lCA0M5YS0Kq0DdNrSt+GvksBs3L9QNxuIYPg2kT6Tsupk3Ph29aNKTcJPEK2S+TloFrELAMGIg+Uam9yFqa0gxqPTO1AqZ4GaP3sMn0acW6pqlSBuaJwaJPSVaqhd759Md5pzQAvQJM/CUXexo6qhWAqy1+GwDgth0mHegtbInHpkAkuRDvaogNAixI1b7JyJS0oCncq1Fqri5+989LwLVDcBeBrjgW9y+kNkbhN1vgYxvUaLB7/ilRwrvlzsDv0VePGz48eOX1in+CHGvHL/bP7gD8E89OIyr6kj39F6m1Ifv8Q9RX+s0BsgWqS2KhBcs8D8HASEJIy0ZPE++/rV5CjU2/FaBNtb/Bl03tJtjMPNdBs7iaJ5vFtAsLhqawrSBw5DEkSrPOUPLitrK3jnbpQoz7/8VXy9+jS4hNKRAUzpCjxP7Z5AEazVoVdTNhTOrdSTUWb0n2EIYpXGAcEMKBdaqq6g9TcMMcE7jsZF17revFxO/lqpGDxL88J7IvUg8OQZUMhCQtjEk6fcog+/fwH5fbYdhw1YrRDKm8xlzntACu40WnWJmsGb7+tcaaR3vY4aQExNUodsOUBRyg4Pf9mMoS4F2o6MhRqOT7YC+Jx5dio7Br6i1Pv5jG/T/yYUD0zIOo73wKzoIDm2U6Djf3iFLvA+JvNumI7ntxw5bBL42yQuBLnSDvQuuGwkiGae6Y0UtzEs90ddfqeOwwbVCPnTP0egz7I+jm+/6oVQCW6kRQ63NMdr932Ur2NbNe+0CXC9hcpEkSNEv2vd9vesvpd0ZSxzmvBDoKEyggCeWHO+5C3RmjiKm6EXm2mKA4eaHMVSIq7eqk1SY9pSBJBkJv+FQitekvx4jyRmirR1QxaqKJLJ3NXZx9uAW6XvlTqXhwHY00yFWqu2UG4pBYbeuNq3jPbHera2DkYNayvM/tvX/Jx8AmjaLpKh3fh7WVCBh+2WBwrzpgXMBicAgoBB73Xocor/5545zhpwz6O4OkOyGHkme/Msn4KbA84r2wzPqpwvq5ye0pws4GaZvF+CbD6DMSP/0BHmTwTnDIH4Pjn4pkBvVKM3eI6g3VAOUyPfSnfBRFEoEmfmAFm5+ZjDvwJ0zYz5NyOd7YPnGXXrFoFsBWYsz+gZbN9SnGy7Xio0EJhLXT1+L2SQ6tRnWiguDRt4HCCc0+YXPgLIBpUALQLSESCDDRNBAaIVAWwFVBvICpBtoakgKlMbeRciB0qwNrI77dlqAi4nV4D1j6w0iFdP9hGmeUBD7KZgnlNGx3BI0oC32PAJmf99bW/3MUdx4SGGpVXaTs+oGUjf+mvj5miW6yN0GFnYxigoahZknw/r1+7aWy9cR/S98/TJrxwH/cVjbzSsjvUFuNj+mTtyIE4QqIkhK0G0bwl2evFPqdDr5vErduNcxf6UUlM0H+Y+Pj7hcLjF8JpxOC5ZlgilG2q8PsVtrOJ/OmOd53JvSSXC7XrGtKzQeZwsCyHrb8Pj5CfM04e7uDKEUz9krNFLOgbZmnM7+fedpwjTPUDU8P1/w8PAwsJmBpwtEr8W//bXoRiDvGvRqELu7w5Qn2JSBQHTS6Ez3AMd228BJMOWEWSYwE9bN75ll25BzxlYKppxxOp3d0Nj7CHnFlL0/TeLe3lNM/b5eyjaSSctpwYf378F8HwKODdTo616yjhelMOzN8wxmwbZuuAbSuJQKIu8TrLXCNhvvwXHYLym96AY+YiFfp83K/4r7/9dff/T615+dD7xKxr0Wy7oAdUy2Hd/TLuIdu7ePwlcXprqQNE3Ti3683vn3/PyMT58+ear18HsPDw+4v7+HiES1j70Q/I5i2WuhuT+W1wJmv97lIabnV+u5Yl3Xkfzr6b8u/B1Fwm7W64JmT+7RC3ISjyTjoIvE63bEi57P59Gb1//5ObTp8Xx0fJ27ALgsC7777rtxPT8Kll3Uu7u7G0Lg+XxGSmkIn/3966/vMfl3fM+Pib/ja338/8fXpn+Wtm37za//NMZs1JFq7gjBscD+cLDqjlcL+BqFENhxn74/ioPecMGGEFIrSmmgGZhTRsoedU/LPaYlI60Zjw8r1uuKMzOu5D0+RIQ5+0B63WqILI7AEnJLoG/oyXu90B24seeMMzepeoeUMEotPgxPXsA7TROweTdZogWpTf6hKH6jQC2ol4a7/+Ee5VKQ7+/AWVBuN0xvTp7248kP7+Dg4CfHWCZFVEmhlYr16Tpu7rW4q96qghNQy4p6U2CeQKcJyRTWNLp22DvjCJDuwsmOzlAYirrroFrDWipapKOaudLLPvEcPY1dEMnwqH8FcGo+SKEpA1ZQiyFlwbRMePxcULYLWjPv2KpeemQgaC3QxhBOLsZEcoLF4/ikrkhYIE9yTv7miPP0PZ0XB/J5gpUW2CCChfg3nRbknFBuzyhrg+QJzSp0u7r4E0i3nBhWG2ir0X2YoNFLWC1QjoEQSyzAnB2dFmifoMo4WoR2L3gSd0OX5gipJDyGPxxDRWgU0BMN8aBvMIrDxWNQFd83NjcIzJGFgMVGjmAkH6JaHAYpxBqCb3gpib+m2rwHrR/5u7AfrmcXLhg8MgwvQKA/KRZ8Wez7A3/nIFIwEkKXc3Tm2sAzMKUJknz95+Ue05KQ1orHz49YrytOIniWHzt/tDnytbXeRRlXMZaY8PiGNSNwlhC8nPnzcHazMDgl8JyRJLngrF4GK+nkT2krsK2gXAqsKDhPSKfF8cISz00EskwQyTGQbrDa3zsXp5QAaxVt21DW1Q/OPanc4ElEKKxsuF0qIAlKCs6ejLHoFkkpYZoX3Cpw29R7CLe1D0t9vMGA1egEUiBPiI6s/jL4gHDKbgIgAXKaMKUEMf9sgRgphuBICa02JKq4rVdsDWjIQ2Bu8Cg5qwt4JhMsJTTbvKe1uQGELMGaopr66y29PqQNJCtSCtzpBi4JPLk5g4R6RScIDSXSrY7n3XFtZuYCQ63uAg7BQiuQPBPpQSWO3r/G8XnSQESy40jiAsC0Z3LFA6jxXUInfC2Q4yfwnR+B8u0fJ7t9cZndvGfwR5Wdi//Zx5HyKz8jBP58svfXMix89ThKH8L39M2eNNHOB/Eh9hj22ujmwEiT7HuXfk30oU8CTZPfTysA7SXzS6z/Cl2rr/+qntA/zSAJUUE8QSiTO09dkPZuzLCJRJ8fUFtB2zbU2+rJ2ugY60hJMoXVivXSAE5QMlB2PKYG0jYlQZ4XrJVw3aKHsNZAbCuEYg9WG0ok9lKmXfyL14GYMKWEJI67STljSuL9OBaEBo6BS0potUKYcL3cUKpn5geO0cKwooZWmh/qU0LT6g6z6NMgpRjYKSQ7Ul0JaK2CjLx7M3uir9WCVlZwTj6062llNTCadwNLILAt+s26gIk40JcCkA8FrUYWvWPuo6sRxBAhtKohUrD3KKtj0ZgAjc8Vj8+Yr/9S2sN/T4P+X+P6N5+6+ho+Cubqe6fWCD6z6fseGolxieQ8H84zHe/KYRqoNZC8o1CeBk2ho4K7mNR77jDIJn42kDAbthZ7OfK9hQV6dwhd2JGVLkhG34xZJHNpYCz7YbU2HU+r702bGloc8rd1DfxnTyQyWAyScuCLZGC+0AW7/nWjxy9Q8bHO6FCbKrEHEBHvuYYPJHUrQ3zt11bvPLlF97I/RssZOctIAQP+79aiy9TcDMgx3Gjq66y16CYxGq9LN7lpfzy640QRYmnf+750HROANjpLmQm1dhzynsokirRhdK2aEWrHM6uNQa42RVXD+kf0f30V+v5XCoC1bb3zUuOz4fv6MFv6YdMFYhCoNTd7MIchUDw5Tn3VRkIQHT01ge/uQGlysW8DMJ+AfA+sAB4uwOMN9tkTbXyawd/cg1LgQsXPH7KcwFlA6kl4i7QauPhCmhIMDbZtoNt2wOqqE2a0gXSDasXtMQzJULRE3p9HFfOJ8e7tGW8/vIecfwejjHa5wUoJwkkDygrbbtieLnj+fMF1M/Dp5C57UAzfPTEryN4/77dJ//Mw4VrifgEOXLihQFFvz1BqkOkEzpOnZ41RK0FuG3CqIFmAdAZygVQDrRVaNrRAieckkJQ9qUMGrQSouJl3WWBk0G2Dlgu4Zn+dk1+nxACU4unp5DMEMTcDjlYaBlgLUArQBCYL2BjJKpTU0/2uA8JI/BzHvv5Z/H1CUHlI3aBKwn6uC+HJQHh4uvzwdUT/y/5S1doH33sfLA8kdb9PEoUJG/YjAZCYYG3v9mXyzyExIecJ57szltM8EsbzPA8cXW0V19sVl+vFU32zfz3BTSwpJeS093D1gf62bZjmKfr3XIS7Xq/4/PCA5+fnIUyUraLUvUPr8ekJIODt27dhQBJcLzdIEpzOZ7x98xbffPPN+PvX6xXrug4UnsU15fl5HYKD3x67qdBrZBD7o4427z2H/nXs1Ue8Uw/mueJ2u+Hp6QlrSpjjuXUT01Y2UGAO3717h7u7uyGqleLPsSfuruvN5z6R1ulfp+b3/Ov1inXbPOFJMkQP7q9ZiBg5Z7AI0ugDtv17NcXtdnOhkMXJCH5UiJ5kHejBLoQcRZcuCByRgK+FjFLKw9cV+qczABx+74sizhHV+hr72f//MT16TPwdxbcj4vFH+5FXadeeNnt4eMDDwwO2bRui8u12G1+XUsLdnfdYns/ngRHtYlc/f7xOOR9/HfGlR6HsKF71dFwXJB8fH0ffXxfwjq9V37f3a5ccKgA6SvTYt/r4+Ijr9Yrz+Yw3b96AmfH8/IzPnz/j/v7+BTL1iDY9Ppfje9ef15fez5QS5nn2a866jq7BLmgS0XgMDw8PWNf1R6jYLvj3JHFPN/bn1x/rcf134a9/bf88dMRp/73fev8fEAnAjjZqkfBjo3Ez7J0MvTjbd7wGJg3whkfqqRcnDREw8G89VkIGbYZVC+444y77BjNNC96/fY9NN1wu3ztT2wznTHhkg5vJAzo6nKEanTRAYX+8fjAADC4UcixwbQ3GAkZ1p7kKCHHozxhFz1aAiTOkKKbTBDGgXla0W4WyguYF5wmY375Fzs6k9yEUYTqdcVpm1CiZxWZePDZFVwl82Fdrw/p8A6zCyDEYUC/TNgBMCSaKlBNKUdDEoJRhXMDhWExmyCkh3508lVJcTCxrRd02rOuGUtWxXHBBA1DILODo8BIGSJv/XvK4fl5mzMyOEemxIM5ALcgpQykjJ3fgXZ9XPwCRRmcgUA0gUeDmyTqZEyh50jIxYFShzDFYj8+TuasoZ+9f8vgtecorBFEzwzJnrGtBqQVigBZGLReAHd9AS8JWV0SeAbcSA8Y5Q2s4l0RGH6XA8TCcM7IAxUeGjvbZuuu/d3/t5fIuOFlgjxxLK+SS2uikYqC0FkdyRVN3hpM23Lq7MjYs/j2r91Z093f4Dn3wiJEMVOttZ4RGjrrJzGAz1GKBLdHOKYXFoIQCW+ppjz11AtA/8JLxR/b/fQTwbYGiDqFEUbC2Dfcy4S6nsf6/efuNr//nH7CtG8ScvjOj+o9aDo4R2UXA4/DDe18iNh9JAE8XRpciWtgQurs9nCRwkdCahTDs7xdaQ91C+C/F+8Huzo6qIUSqSMEs4JzjMArUUsGqSFlAWYBEoMYgA7btBqij9CiEShfvHYmXU0KFx/KU1IcGTcHYHOU1+XVnbYLbWvD0dEEtK+acIBydO+quQmhDLdEDcHixRBg5MSQE7DQlLPPk6FzyxGliQYvUMZOCORxGCshaoFuFoYEkg6kNHCupQkuBTgmaEihNaLUisSJFjwDYUZ3GCrQQyY187Yq/QzxNoAoIKUQVQgkaoqT1GzMUEi5FyYEBsmB3sjuuU4repKaQuCdRLGQmhtAMy26UkOSHBI1eRYKOFDSJjOqmCEKNYaggo+D24nP/UyjP20/ofx9/Svz71kW/5Qsr7iOyf+3tKL4f//2lXsDyo5/3px4c2t//BFBiDhWeBg4c3P4Nuwg4EHpqg0zQL3PHVA7FkF/V4Ao1w6rjMskASQRUT9GjFNTqSG+5P4HERWFYGyYCyT6kInaDD6mbTWhyrC5FemhbN1jzlC6ajZRqpymknNDgEX1li4udgs27itOUkNKETQXXdcPz8xV12zBlQRKCVnOTQXMk1sBZMMaQnoUwCe+Ou5xwmnOgiWL9i6BF0onF/5kBNCXIreDWittHxmHK739k5us/Z6gIKBFaK8gEJO4JdBdGHNkbG2zjMZDtxjEig5AjRH1I39MS3hdtpNHlwuAUWKcQEywEHUga3WvCPUsaIiJRXCMUzQySA91EnhVwDqj68xqiSMcl+WenlPLxT72GfuuJvn/A+q+j0i9SWMfty8B99h64gwi0s6/3w65FUtDCRMDcnaG7QcgCS4m+r0NPh9FAwnbRqff29WdHh/RZZ5MmEe+eiZQfdYZhCG2OpNHYD+qefgsx07oz1RBpgRW364rL5Yq2rUiB+uyCvEgM83ryn3ovVjzP6LvqvT8WKYk9K3s0fPrgu5+9WvQmdWFtCIksSCkwRnFd88fsCYMUJJY+iOnvF6EjSQ1ND0MADjNPvMZqjuNTjSRPDHM7IvS16MfMULbDUIc9IUX9I9HRkeT9bFEr6ma9/ub456l2XFAgUi3MVuv19t1vff3/6geAqkqwIRSb7O/jWIPSzR/w/vfAuvpMwK/ng+QQZoLeZ0VgPyQ0AlYFSkRFbw24rMDzI9A28DmB379FzhKVGxuMFOAEmmbQ+QSwwS5PQFGQGLDEcKUCJhwdvxusbX5+OFZ3mCtSkhTNKkzg5/8moLVhYsPbNxO++fAO0/0HmGWU5wt02zDNvvew6w16fcR223B7vuG6rqgkmASONYefxWEMAXkyzhAEDHMhrTbfe8QumMjAKSNBkNFAq+85FBnzNLvo4ltstFuDXG+ATKD5BMwFtH5GRoFQ3atkzB8DVfOzbRPfrzFDKCORd/zl5O9VooTWGOZOTz8v8Q2UDEIZDAazgVqDVYNAQHn2KhLVoFB10bgjYQUiJ4Crn9+YnaDAyek8aEGzot0uzYSmNBoCf//p8b98HdH/wgaA1gqAkbzQoLMcsZPHoXLf67dWB2K/d/O11sLc2ykxcX8BjeoQC/JSJwW06OUWSXj3zQmn5eQ0st4TzjzEgp78M1OczyecTqcxg6yl4fJ8weXiiEtESsjndQXEjPPJhYHj8NrMfCbKgjf3b/Du3VvM84x1XfH8/DzEK2YeQ/LWKkqprwbYvkfoCVZiQhYXL1NKOJ/vIvUobmiWXQBh7vNXxRYighunKPYCvUfL91nn83kkcrayBVKcx31bNx3o8KIFar5HEk6YZ/8e19sN27ZhKxtmnj1McBATuvgozMjzMqoftHk6qNY69l0d26uH3i+DjTRXay6kdiHlKKiMLmTTH4lCt9vt6/r/5Q0A25fX+I9FwKOI13GVr9OAx1Raf6+PqM1jGux1j+gxiTaIESG6XS6XgcnsnXJHtOXpdML9/T3evHmDu7u7gcs8ikrHxF8XpI7P7yg89u993E/31N/j4+MQJK/XqyeB43p1xGB2MbQ/jv75fo0GPYqpXVwkIpxOJ2zbNgTALmyeTqcXKccjhvU1CvR1x2Z/jDlnLNEn2sW4Lm7+3d/9HdZ1xV/8xV8gpYSPHz9iXVf88IP7cd6+9Wvk7XbD5XIZAueX0pVHdPQRvfr6/e+PSUSGiPr58+ff/PpPPhoPvM3oSDgiPxEbZRqHot6/ghD/OA7GGnIfd/wN+SC1leJI0ehwysmTHZITpvkMg+Lx8xW6VczsxjtJgnnxm9NaNkj0dKQo82rqB29lduwhHTo8yJFUQZ2Ej5f8WdXAPkAYtQCUFQnu2jcC2tZQ5eaudwb4zKgNSPmM87s3PgHmGCKuDZhOIJ5QCoBE0Lp6qE3CNWYVrRnKptCOmWBgU0O11Qf2JsjcUGBIeQY1Q7rzA0Ezg63RrZcEiSRYuA6gu5aG29OK8nzFWgq2BggbMjwd0wd6JO6QEzXkeQY1YJbsLmlyJ7CfEACIgCcCqwGzv+3ttiJnwXmZUDbFVov3D6oP9irI+xpVYUVxmgkJ4gN/GIgniHkiUJBglh0rWFv0MDA29S6T0zK7s18VExQgwcwONrxerjH0T8jTCWSEPBGm0wLdbtGV4lxxmRY0qS7hNT9stZ5wrTEYZz+9UHTDgb2jjSPZ1MXAPpzR6NkDMxCbPcCTqhyff8LuMItD7BDeGN4x0CdO3XE8bNfkQylDczHE6LCp9a9jQyR2He2gCDxWdJUEq8gHJN2v3jk5kR/8SSXi23+ACBi4z9cyxRLPt+nmqYvqLtWUBDS7k3yavCPv8+crtFYscfaWJFhOCyRfIPDEH78oBKzQlsbhrGlzLM240bj4yurF7RScR4MOJ72/DRWtFAin0RFTWwNtkVokgywJwgk8nxwHUza0siGJYwOZxbFBgf8imHP25wTTilY3lAa0YqjKoEAOW20AKUg9m6nCQ7ahzDAWbKWgNU8bLfOMigmX5xUPD4+o24rTaUaaBEkb1usWLlV/TUT2PiMPSLr4DwU4u4gs0UswLwumJEArUAJS9qSwNRfXmMXZ/ymDSGPeoiAWUGvumG8FrIKyOW6jTIwpMSQ8ICx7Opjc3e3H8sCONgBZkncK5skPI8kTN1QMpXfzwSCckIUglNGXY60NDW0kCpMkRE0rmnnnp6P/PJMuwmgVEFZ//KHwUQiy/XPUE9r6agjHB1Ht9kesmj96eX37cg19+c/2xN+XdcXyar3mL/z+r384aWY3wEZ33fEAoAc6iJpbvynUgrG5J/F+wLi+9p4ox+G4815rc0qAhoO4KoiKfzbJzTPCGTyfkLNAywbdHN8MZjeXhMHEMT0GSoI0CUwrtBbU5sJVdb5oGKIqwkIf5AAgURhVssCE4yCvEAHmeUG1hMtlxefPTyjrhtN5Rkrs63/b3PDUu34jBe3u6HAORmrXsViOt5KcMC0z5iywWmHcsVeBwDYCkyNHJCUwK2oYUrwzLzbWrYJZUEvxZCQxJkkQ82FaF1s69a/VFp1iPmBpZpjY0cYyRV+D9E7e5qTvGL4zC7Lsna8ihFJ2rFI/JFn0jTV1p6dW9etZoMJVK4S01xe6KGB7Pv5FCborfwg9F7fL+pf2G1pLv1FxYu0HxJRkvLeO4OzvjQ2slUYCvG/aJNICOKI4eTcC+fU9sEADMUmj05yw93f0PdsxoQe4IUgDz+WOYhokFbOXh15fU47hAxG0NfChfH700BG9QJY2NZTasJWK6/WGh8+PKLerp/hziqSzr4mOQe5I5NBJIinN/T/G3sVFEkM+bLD6XtUPyY7Aq62B4rxVa9sVTOyiWs4ZpjUGf2n8+RiwhNgpwsOB21N5GK+rDgPqeNxDMKSXA5wDAtqfUzck2I7yIhfuRkJcO3YZ4+uG6a/ZSD8e6VMuQvqeuoYgenl6+v99Xf+/7K/arHCQMrSXUtih/BfhefTNerx3u7BrGi5zkjjjWcwwDKQK0gJat3AKxuepNoBWj8alBtwJmGbgzQcfilw/A1enajjnWhzFaW5+NTRQIiD7Z9mKJ+NrIzRk2OTitGqFbRWsLsZJVJNQ8/O3ZsG2EtAazrPg7bt3WN78Gcwy1sdHaNkw3599zvD0GeXTA9b1GufUAk6MJBmJfa/L0eIB8zOkJ+cUJG4MJAOMGzjZsRvAySjkxsGcG0oLIJ84kYDiHs5WgMszZD7DeIbkt6B8wzRdMVUGWRiiKLo0qoLULdtGft32CosEyQtECMJe71FKw2aCLcy6KRkyExKJ9zoyUFG8XgHsFSLkA6BOjiDOQThAdAMmUKNxXXKvdB1iKZMNYxFFtUwNU2014D///oe//rpCf9lfpZStG3D2xM6Ph+S9J7inartIlZKgxf6RXgsBYSZptaFsBSyM2vzsmiQNI848zzidz3hzf+/G/7Jh3VZPqElQl6IXuLUagtoZ8zRj3VZsZcPz5RnXq3f45SnH13tPXSkFKScs8+IddsKYlxk5TT68Z8ayLHj79i1OpzNu6w3rusLMRuLm+fkZP/zww4tuY98LV4AY04RDB7DPBFNKmJcFp5OneVLQdxyrzMMEZbCYx5xwd3eH2+0a8yh9MaDv/zw9PY3B/zxNOJ/P4+tgjir0512HUOPPW0DE/trN8xjOmxnWbQuigq/DPOUhWvTnW1sNIxMi8QNwLfu+LUTXPuSf52V0n63rekh/HdCAL3Di9OL8eblc/vLrCv3FBcDSRZfD770Qcl4n9jrWsgt2x9Tc6z7B417yKMCNz+tBFO7fs197+td3Yep6vY6kWO+27EL43d3dQA0vyzJ65fr67Um7/r27mH/sLeyIzGPv6TzPfkgK8e/h4QGfP38eSb3W2vj7HePZ08PHZGvvLOxGi2HSO6ydY2df7xzswuPj4yNSSjidTk5TfCWsvkar9n+/xo2+fs27QNkTxZfLBXd3d3j//j1+97vfjde4P6dPnz7h7/7u78DMeP/+PaZpGq/5awPBUYA8Cr/H1+v4GvX3qv/+x48ff/PrP/VD7HB8Yi/VNuzInOHAD5FBA/PZSYNqHSvYcYM+lJlfFG4qGNUj55wxTyeADJ9+eMD16cmxj+gFvcCUJ5wmwtNFUavfTCpWtKrY1uqHN9rzTBY9F2TNHaW9s6Uhun+CypF4oKIc1+V4TRNApglKjFUVU06gnIDrzeP8QijmOLtEAjnf+eCqNS8pN/POq8lThs6/Jx84k6PqijppRMBI0wxKDaUEbmprqFtF2xrSMkW6wW94RL7Zlnn2wUE1mFUQ+VDr8nxFhXf3CEuIbs7LT1NGTuI4zmqoa8XpNPnJSRFuYQal6MiqhgQCZQbT5IPF3hOSE6Z5Qm3q7Y6skOo330sjLFNC3So2TT5k706d5mIBZ0apLhbkKSEn37AlABMIny9Xx5zlKOmtCrYtnNgKCJBQIGkB1UhLaUIyA2iCJv88tELA1lDME5Ukgtq8m61qjdJhd5MRFJoIKDEsEIBav1i52tx075Qjc9GmwbDWCmvWyWBjo0DwwagNhKBjiEC9p6ojyLz83HFGNnoNOhZppFvUD7hGFIk2/zsdZ2PmfQ69u6h3lwB7R00XHOUwyPop4eFntuQ/FgK//QlhYcmY+0ypddGkQliQecac3TX78MMn3J4u0FLHF5rCUTHxc0Re3SDa3tnUNPr/gNHh1qp3UZZaME0cvabRabmb66MHUmFCkWqNKrwUaCEAQhNSmkE5A1AoMaY0ARSF3nChtQtPxOKCY3UMXS0FpRi0+XpWjXQpU6zfSL4B2KoO1GV/QiIJy5wg0xnP14rPD0/4/PiIt+/eYDqfIK2irRfUzRn9Kcl4DWk48xPYfQ+QaOYT8UTwlATTlDAlF8TG4I8ISIa2RqeYMJZ5gTbGpXo61bv9gE392iZoIFVcrxtSPrsbmGr4Chwz3LuQRDK0VlAc2g3AVgooudhghDGUZVFwc4cfKSNPCcnE1yILyHZkoYmAunCu4fpv0aMS96b40EACxUrMsNbQrCO/3MriCYgwA6gLzX7YAGTyQcwfUv/+EPjzp5ChxwRg/72Ph3X68YtiXv7yGj3897d/xGP61QwjFbd+PY0l40PyQ5eXmg1Bq1scmmIM2HNy/I2qhU4X3a1959M/M5OvGyV37JswaCIkIkiawGka92OR6AyN1JyX0ZeRaGESoKqjOLfivbzR4+V9ntFPldy5ytFFtdWGnb/Q+18Z85yR5hMul4qHhyc8fH7GN+/uMS8zxBra9Yq2+drpJiklc8NRSiEyEIQc9dX7vpIwppwxzRlZGMr7/YrJ+/TaptG95K7kpoxrdStFa+r7IgVqM7A1cGu4XVbkt2dAspt0DOBAcIM9zZc4+T1YKzQSlZu5IJKmHNi22JSzQdGg1V38STKS8b63M3KBP5IgZD5o1KBPwAzN3K3MCHR0PCdtOrrCXABw81H/3Kl1BGBgigGUZiiX6//7tzTot9/AY/xRAqDWSz+E1SH+hXHqhZv0IAiGUOvCVYhKPRlK/OIw2oUyVQWntIsKvZuPxnVoJAP4BUKoVw7QwRW8i0jMjNoFrvjN3oWp5uuzdzN3vCnH1x0FTguRfVsLnp6uePr8iHly844LeR15yHs6j6MzhLxbOkv06MV+Rca1U0YKr/9b+mtCexemWTesHUS3LlaGESIlQS3q1QaLjs68Yd6O7p8u9NmxaLGfE+mgPoRZyMivXQ06XuOU5IDmpL2xwvahP+JrB5UmjKqI9TwGyzEsIo5qg3Fm7a//bjTpn7HPP3z6f/5jWP//LX/dtnbpxhGQ+X7OFEYScwaNnlnsqV+qUJW49lckwbjf74No37eTGUgbMCfgnN0BaxY9gAKcog+Cz8B0B9jmf0bZVxBP0ZO3AnWNTvlgza3eU2DVYG1DaxyTlYRGLnpR9uqK1HzjsW7Nz9bqay0xQybBu7cn3L35HZDOWB+e0NYrlm++AS8z8PwZ23ff4/r4BMsEyYIsMzgB4AyeZqQpgYN6AnWTi1Dzf0R9JqI+N9EufO1xZsAMiRmneQaYUXiGCCEJortesTYFLlfI3dVLKtIdsLwBrjc3XYdp2dxBDeI5cBrVL7AWaWcW7/oWr8YgaxCuoLbCqhuIs0yYNcVextPOygQVN+owkqf+A+dvkdzz78fgqqDspmjVLdCHQXWJyhQ/J8ZrARs9pCDCZWv4n/7yP//fvo7of9lf27Zdd0TzMZFmQ3Dqg2g+3Ed6WlB1T8z0a4SpjTQ+xz0ypeQEjltDKy4S9QF9T5DM8+xD6yzRvZVi3+i/ni/PKLUgxffcyoan5yc8fP6Mx8+PuF4v3p2LXcCcpuwJuf7YDo5zYu/XYya8e/d2YEkvzxcQEe7v75FywvPTM7777iN++OEHnM/nkXDugkVKuyGIyUlD8zxhXhbc393h7v4e9/dvXMivNWa5dOgv7rjMFAlFN0lv6xb335gDsONOe0eav24Ltq0A934/XtfN92cAJDoWny8X3G4rUk7RaxZdgTH00RAx1roOkWKRZewjRGLe2fzebjHEP58TSsnYtg2lbC9EDI7ag/46peTzxtoqztN5F4pZfoRi7ELNp0+f/l9fV+gvbgC4vE6SdfHoKMIdxbxj0uso+PcE1+uvH8SIQ+LtiH/t4tILM+jhv7s4WUoZWNneGdevHafTaYhjOefxNa+Fpv79Sykj4dvxnFOI6f0a2JGbPeX3/Pw8kojdHNAFNjPDtm0vxNNt2370evU08ev0W09V3t/fD4H++Hperx7MOZ/PePfu3QsMcxdkXxtq+3+/7mXs16090dzG+/fNN9/gw4cPQ9jrqev+9zrS9+HhYaQGewrwKEoesbDjOnPAvx7Tov2z8jp1+Zd/+Zf/j9++AHgo0D6idLqY5k5JGqidnb1hx+72kf0bf0buMufo4YEh8I6OpJhEcJpn1NuKhx8+o5WGVgsokk4cab/zPOH+VLFVQxYGb4QY0aJVRU2O21Lzro8OCVJFOGsyIC7uoSkaAFJPyOVJhgP1dMouuoGQFI6QzAmtVCwLu+hVCpgI+e0ZYt4H17YGWRiohlKrHxaqQliwXjZPHAU3fnteYYHkarcLlAjNyNUmzuApgRtBibHVipwmECfInHdWa1W02MS0raJuBbdbQRVGEsHUhYtQnigxJJkn78KZnCSBhKFTwvLmHvenGfOU946M1KLPjMHasG6MRSYYCcoGJNkwLRlrccGqZncT1lqxbYZ5XrxcGy6MTcKI8BpKieFJ8sdoYJTWUJ+vkJRw//YtmhWwZJAyGF6ObpwAa8jEIF58phebP4iiBqqsbZujVcz7H7I4LqJp9HpFJyXIO7+MPCmEqljbGq4hON6sdkEqBp0sPhw2F3u0I4FUIRIYw+Y9TDkRFOzYqD6UoOjaNPMBqHgKoWrpJjJPV7UYWPSuGgClKZRiIBJpFd/vShRce6n8Tr2zISJ1UXBXAf8h+M8voT/Lz6oaGZ76GlJWCMxTAiZJOC0L6m3Dp+8/o7UKLTWSIRqFz94V8Vr4A3YUaCkNnBzR6OhfHozQpu40F+xpFiCQN4S984YjETdlpF76Jv5eu/juODt3CKu7/kgg4ptGhIjIUCgamrnIWm7l8F4rtlZ8TQKwUvyyKLy/Z0JgZWxbdaRl9ptyTozl7g5rBT4/POO77z95F8GbN8gELzXfNu/7maZdDFUX3eK8DRaJNCBjyoy8TDi/ucPpfMI8T7BWHbEbqLUkk6OBJk9gzgTUzKhTglrFLUIAtTecKqDcwOuKfD7hdr3hPJ2QyCXSjjtUKFiSizFDkPPeQ0cO7reSVgI1IuyfH1WHPFdPbgFAThmb+exGA/HbvwEndoQj+8S/KcPED/mmGvcFhjFApQufAmMAkEho++/3tJECqFtFmhK6Ly2q+H6kox9Tf69Ft+Vb/+rbx48/qRh28e8G4CM+At9++2qZ5YMQmH9CsP9pbO+vtPfv4BzDSiSRGrNxHXMck2Gr1VGwMUAPihyYeGziOfqBfKjeXJyjjoHz6yhnCfNMpAhF0LpYxr6PMfN+oR5hE05xmHVlyNe/ohmDTVHWGhd1RkpA2w7rv9booQs0VcRYmQ1lbb7+kw/kUhIs577+n/D9Dw/I04zTmzskJuhlQ9k2kBByltHpNcSGfpAhN/EIE3JmTEvC6c0dzucTpjkDrYFhnugDkCS7AWICtPoesJaKWhVqDWtzA1YZd5xAe5YV+XSH63XDaTpBiXy4FmhsVUQ3cCSirA9ZHT3EaYR1HKnMDGU3aJBWcFNQIE5hbkrarIdDei8YhXmCUVodSSI1gXGDaAusKBwNF4Ocjpn1fT6NgX93TnczzbbVtX1+/N/+Ggfv9gt97X+T9a+6uuufoW1PdSHEuI6N79aevQqQDtgegQgNFGjnmVjHSkYK7+X5Zv+3i2Tk1w7mQRvYO4j0Rc/FS+fo7rwfFix6adIy83vy7qb3PYZZDWHRhbpSGi7XK54eH6HakPMJOU+Y5umAtcTAezJR4Ow6ZhMx8HbEnnaBLJTtacpDgOyD7t6z14mkrgXYwVwWZ0Um1LjesPqOa71tOJ0qUmtIOcfP3R3BxHsnmQu6nvHi8doxVJsbLbqwG6+HB7V0nEGdJNC7oOTQ522j89FTgPF13DFye7q3i/z9HBTuu4Egdfy4f12r7fb5r/7j/+63vv5/9QJAteeUJj+rmflahQFRQaLNYCnOVQFlB7F/ThECHDkJolmNfsDowRw9tuZi37RgHCSUAC1jbw9loN38rJ4TcDr5GZMY2Dag3oC2uaNQGGYEbAaDk4CEzO85GiJSqyCrAEuk1GPtsKfWy9oAVLAQlvOMu7fvwNMJ9bZhffqM09u34LdvgFrQnp9xefoMJcU0LW5WNHgxN/X+7E4mCKwnRdJvnv3eaw3YzO+tOOCy+wojRSICz4SUCFvsexIULBna3OggpqiPD5DfLdDSwPkEyhlJNrSqsEZoUKTshq0WVBY3WCTvHhQFicIgaFsDyNAYoEmQSJG3Bl4LdCswJahk2JRg2Wc7BHO6A/Ew2Ur1fUQDwWoDlQoyAYmBTWDDBBGmq9hCcAiT+6DLz/HfPV7W/8+/+6v//dcR/S8uAFyPCf/9XHDsyAoSRRcIhV+IAWN2YBYhg0h+jA5cjpTfCfPiXYCn02kM0Puw2yy6hVmQJQde22dB/b7f98HrtmK9rbjeri5gBQazbSu2dcPttiJPGcvp5PM46sYY4OnxEZ8fFUn8fPH+m29wf3+PWis+f/6MdV3x4cMHfPjwAZfLBc/Pz/j9x49hrnEjkEJfDKspUn/TtGCZJ9y/uce7d+/wuw8fkKcJOSWsW8G2bqgx+O+PKyVPNemyIIngcvVkIsZwPxCgRBAxPD4+joTQ6XzClDNUm+NOS8F6u/n3a36+ccFCccd3Q6jtVR+XyzNYEnISzMsMgyf2eqdZF1xYHENOowOSRgcyYG7OJMI0TwNlaLVBxNOeOWeU4s//7nyHHB3Kr/viDp/L9a//+q//D19X6C8vAPbk3jGZ9zoBfEzFHYWb/mfHf3ZzF37UH3jsFT0m/3AwDx1FrJ6qO3brbds2+vmOqb3+PPpjPKYWu5BYSnnxT+8U3E1z/rg9DewIzm3bsK7rMEN0wfA1UrTjRhFrq4trx9fk+Lp04Y6Zx2Ppz6OLm/36KCIopYx+vg8fPuDp6WkIjV0QPF6/++t1fL/6a91fi56u7Mndoxmj//yjwOmdqxXffPPNeE9q9f7S43vQE5rHxOZrNOgR73z8XMVrs/6bf/Nv/o+/eQEw9D0/eHWnTVcFXzls+1Cpc7V9c037HjFEC4rNoyQOASDQhkmQ84Q8CZCBujZ8en6GFU/KOJ5N0WoFiUHQ4sK/QKpBmfB0K2jVIzS1NFjO/3/2/qTZsiw9z8Se1e29zzn3Xm/Co8kGTSKJFBNUFY3FMhplVqBRqgkHUmlW+gGcyEwTTUuc8B+oJjLTtIzGorEkE6WiBlLRjKBAsESQIEgIAJFIIIFsIjIz3D3cb3fOblanwfetffb1jEgAxUIgMxknzS3S/d577un23mt97/s+r/b4aB+FcRSSuN8QB29NktzwutkvFMrQkSyYWqgpEUuBlARZFQLZVOLphHdywVjmhZIL/a6npMI8z/guQM3EJWGrpeaC6yxlWSSd1feYHDG+wy4TXW8pPmDmSDRWuquWzDxXMAuuD4IvquLiKzGRDZIUdML47na9iq0VOzjqMVITDMOOEAq2OhmsRek+7HdBHa+SOuiGQAge5zwXF3sOF1fsLnc4IJ6OggvFSdeB91Adb10V4jRyezvR7Qp9jqS6EFOWfgwdgHTekqtgEOLssb3XHg6zCi01JrlYo2kO7zBRYkexRKzvZFZdZXBPrRjn8MaSrRE3ZSmkOIKVjU5MEb/f4R3Eo2AArFfsmbNE7bh0fU/BkO2CnSKzGjWdCnq2M+RZpshGhwtYp11RWXtdRNArGGLJgn1QAXBNbBg0MWqZ5hlbDDFnGfQogsZaVsRELVkGpKXQvODSUeYUF6rDJ3VPtm7NhvtsiTFDpWhXETrcNKu83z41isP7YbePZRV+jJDwRzENg4hOllbiHOhCJ8gqD2mKXJ9OVBX/cswi+KZFhsBkeg/JeZVz0gMh0DkoSN9dLk677Th7gvXClkr7v1kSfw7Arp1SJatw5Jyaf51u/kTuKSkT9fPQTnfOOrKUeJL181axkMS1WwzYEMRRmg3FZILir1KOuKoDvyw9kCJWBemtxDBPs/T/eej3BzKW0zTx0esbxrjw9L135PwTZ0qK0sHTOUkEtBfJsR53ImDJ87Wdx+17dpeX7B8/Zb8LgklOiwjopTnjRZCjD5SciHEhpsqyFJLQfQWxLDoqPkDOjpIXutqTiiiPQhcu0t1lpZHDW0H1iumkIIqbdioiHaDGiDnDeAu1CALZBVKayXMiVXEDZ1+pnZfrVyxkLKF3BO/IKVKtJRZFgiretyjj1RpPJWk41+GLfspUnag4HSTp8DOruUQ+TsQIEy8Z3jgQBhXqnr38+Kzd8Me4OA9bOfHly48VEl9+rCAf3vj/H3cc/3gMI2spd7II20RIVAg0OvQtVdKdwQpeu+a6IuGoigKzQM3nlIhxVMXhtQ47572cT50V84U++pyyYqJ1HaOdISklPecaGTpUB7XgrZx7bfCrM7XmTNDflVLS4197jRTjbF3A9x2lJuZlpuaK9ZZ+P1CwjNPEy9e3nObEF955G9d1EBdqStrt6XC6aV0R0/oc2yIWa+T43/Xsri7ZP37Cbggi/OVImScloekmxVkqcvynGFliZlkyyRVJ/VURFIs1BC/nt5IyvgqyE3XOmSpIpqrCjaR1Myg4vuEWrTXYaiixrLhA2cM3J2cgp4WyzHqKczJY7M/HfzFG6ALBkqK81qlkvHNKr2BN/DjnqdrFbPX82ISRxparGheU5I/gRI+n6Zvk8p3PBv1/yo+x1tOaAGhDwLbmaRv3VaTbojnPCa81AYguBHQ92IyJxllFh7UUmU58xR2mqUHFxFXWv5/lwpYutue02Ya5sL1Z1z7Tdu2ws0b/zWp/WdunrM7crJ2TibvbI/d3R64eXRC6TpX0NvzcDD6RvVhLIVaQ9IG10rWnvy+rKGec1XSCoWhE1ujrU81ZvKybZGLrGpcORKM924jh0Bpx+68dOmgi52wdrZqwbMJg3X5oTF33dE0ltVb2F2wSf+g1oL3m8uWiBg+ziistGdh6gB6I+tWo2U5oAKxpzDMC3Bgj5xn9ubvb+2/V0+nbnx3/f7q3cYkn5wNOUB2K8JZUVsmVnBO1dmK0xGBsxVoPVgVCXcMVpI/SrVFWJ+tKRdGaoq5CRVtSk6bTiv5JciBYoDitgCiyCAxW3Y0ZFsX6Oyf7gSY05ExwDlsMKRdY0A7sQl4WEgU79PhdR8bKUDxJN+3+sCMMBzCeeTrhvCM8eYLpeurdLfn+iLOWbugIQ4+rYIug/2QP0GhB2ivoPPSDiJjDAZYTTPdwvIWSMcWuiSRsQ5YLHapPFWehq4WkxmXnHMYXUueBRBon/DJSfC97iODV0CPOH2eNvJ9FKlBKzXqtVcMWhrJU2e8XMfZKql/XdzYS54mUK654XFconVzTyxhxvsPvAyHIuktMPmI6xDqYZsGvg1BdKhQrJoZarZJ+5O8UTZc1tpXu/T94/vrbd6fp25+N6P90bymlqQ1k26310G6HyCGEta/Vu7NgsBnYEpPMGGUf6dcBfUyRlNOaKmlDequpuVyKEDZKkTmRs+sQuRFh2iD6zO4whC6wY9fqNAnBE+Oem5sbYkpiPK+Qdf+/3+0laJAyz188J8bIfr/ji1/8IqUUPvzwQ+7vj7z99jOePXvGMAy8evWKm5tbSi5cXl4yDGcE3/ZmjKEfBkER7g+8887bfO5zn+Pdd99dh+d3d3fc3x91zsU5GemFdJBi4u7ujtu7W+7u7hV5qsmhUhQfapimzDRNMk8pQuCqk4iipZRVoGjX7lKKIElVjKXCeDqRs3Qk7vY7jOmxRpDGy7xwe3tL1wX6ftAki6eYIobsCv1hYL8/yPWhIWCt7NtijMzLQi6LGpHd+njWrjVrHgz8QwgPetSOx+O3x3H85mdH6J/urZQyi/j+MHn3JuZzm/RrIk9Ll73Z/bc9n7z5949DVW7TbFuMbLv/ljQbhuHB72i4zbpZc76ZHtx2Fm5Rok3Y2/bSHQ4Haq3sdjuurq5WYS6lpGhktyYE33gN1/trImAT0m5ubn4g3diEPknOxlUsbH9vqM/9fi9pXH3e7bW5u7vj8ePHDMPA69evV7zu9vVux1SbS7TX33vPsizr693OS+19aGjgrXi4mg3UtGGtZRzH9XVsr2977FshdXtfLXn5cf2S7VrRbh999NG3Xrx48Yc/9gLg+obIFm5NbbXdRd3gAq16Z889gWYVA9umc7Xg64bUGavjeAPG03mPd+K0vz0dmY8T3haWlEQ0y4WYpMxZsDKe0EPYSfdN0Q3gXDKpRgyC4rDqGK06mK4YWfBVEQkMjmKyuuTt6uaxfQfGssQF4zy+ZmbAeq8ILE0VJhlOxyWzzDOeqsXdBozD9wGXEkuccaFjt+9ZsmwaS8mk6iTFYoow5kMnrkQri9NcsrgbvSMvixRZW89uF2RzbA3dMEjWxiAoywrzOIFJdMHhu56aJA2WbdU0jcNZKwjLNsR0Hm8dwXXs33rK46cHlld35JgI3og7eM7S3+U8JljmnOl2luUmUeM5TYV1qxhsgsdnSDEz1Ymws4LqpOrBUzkcZGCa50qpiVrEpW+cpunSAjGT3AzGixDsHCkVEUyNo5pE1k7DhnCopZAT5BKppidYK87BJVGriL4Gp4KlY6lRXOSKLsRJ/5IMWjK59ekVGRQ549fXvBRZGKZS2tqOUh25ZqxTpERw0ok4auLJyFDaak+VN5aAoGZzW6iufTGb2ZGxLLVQjZVN7/rPZ2SUacfdBoFhNi7u1Xl+bjZq46iPPyt8oqj3J+0PC4J+3PgNfBBMlBz/p/PxH6Mc/0U6nARdLwPf1MSsvB2kiSBYivv4Z9Ii5YBbBUC3imGtx6lhQUvMTONEFwQrKek/p87ZosM+caLLZ02xEdZigvQHliYwWDlf4aQvLB1nShTFMnSBulTtvQnytpUi2J9Uxf1qqg7e5RjzwVGq4XiKvLq+x/c7wm4nY7QlQS74TvDAxsjzSTmBFWxwtX7tuDPB47oO3/W4YUd3cUW3G3Bk0niv1jtlfXeB0Hf43rMskXp7pN7NmNKqUK1095Ui6ewSsLZImCdH/G6QbpDQycbJS4+paRgWras0zgtiqx0L1uu/y9faZzbHJAMF70llkV5GROCoHuacqXGhs71sGNSVVHORpAGSmLUOcpSBSF6HwtKzlvRDI84o+byYLGaWKca1h6x3MOoQYdgeOM9EFQ+DyGzTDzmsAs+Ikuv7obcJJPn38od87yrGh09W4/9H7P/7tIaPJZeblm6pmzRWSwO2nqZ16N0em6bAdO6r4p1bO4BK1d5NqqReY2IaRzovx23V9EyjGZzPs2LYSDUJptoa6cIFMS4ZCQaEQcgDOUZynAVvbIUqIP1lRTF7gqMTd7zA+YytivGW5xa81+N/4dX1PWEY6PZ7OefFBXLGB48fOjFBIY4/jMUFT1XKQTVG1jUhEPoe1+/oLx7RDT2OTJ7uZdCeFXMaAmEQU0KcF453JyqTrBN1LeFVOPAqgBrtxrUp4fc9qVQ5/mOW3+3V7ac9fKUaTfjIG5XjIif3CkbRpe0SlqMktZpY4dTwhTFUB0tO1BgJimc1zlOXRE1FElx6/DtbWUzSHmVlr7YUVpLrvmAbz0tZaw1pKYJxrjCepm98GsfAj+qQ/9N6XMs0vtrzZLOBZE3ymarCH22zzkagOqfdW7qmORVLETPJ2WRQz5QENTkaXdfW1gFlz1iuViJqtgOjht1U01UtbZCgeOla1+Ra+13lDY2wqrmyDTfl/KCIs5KZppnX17dUIIQO6z2h63StYB4g0FCzWtHBHEi3dHMJQyGZgnV5fU2Dsa3sbk3VlVoxuZ67cGslJXX9p7Sm5uQ5iWDgbdD1kXvQnbN2iio+1G2wo617aJVOq9naTrGK+pH3yq5oVhnCNNw3q1jQ+oIAFVq1u7PROOoZr8r5itLudDV6KYxjxU3lLK/D8eb23+vj/9O63Rynu6r9lnICr9TaDJNZqzA8q13HyHqdFuitIqaLoGNl7221k93omrAY6pwwHOVa4IIyovWAtWJIpRhxE86LOMG8g64H38t1uAB2huCgD3KuSIkyTqSlgNvhgwcbSclQa9BEWabESpkLxiepD7EWbMUbQ+89GC8pu3lmf3UFhwtYRjjeYeeRfnC4vWA5bRyhnuR59BeSWGxJRufEMN11sH8EV+9AWuD4SgTPNMpzlFJ76APsDmCDDCuOE76MeBLJd1RvkKRiJQQRL1kWyt0N7uKxPG6/I9tbjBd0fzVWzDpVaRvOUq2RTsRcZU1gHNWD8W4V3kyuGOvBZUqwGG8x2YGTyoZYF0oa2VWPtR2uc5TTvZAXgiQCHUEcgD5TXYAglR5UcMFSkyEWMQOcTQRlrcGRPmr4ve88//3PxvOfwvV/Wa63w/rtAL4Nrrcpm6Ki4FbUkWtqUYOAWRd1Rq8LOWfGaeR4OkrFhQpAIUhnZBseN/pI6yBuokKn2Ln2uEII7Pd7jDXc3d1xc33D6TTSD738u/5P0MawxEVmHjlho8xgQ9cRs1TV7Abpqru7uwPg8vKSi4sL7u/vFf83cnl5xePHj1YsYKWuIqeklCQNczgcuLq85NGjRzx79oyf/umfwlrH6XTiw+9/uIqlLUF3cXnB1eUltRamaeKjjz7CWMuyRHa73SpcyHt07hm7v7/n0aNHgKHreoy5l0qnfliNTe3afdjtSVnWN8sSmbR/3Oheb57mlQQy9MOK/fNeEpoVFEk6kXMWEdc5+r6TU3VbO2IIXkQH7xw5pRX3CtD3HVtCQ+soayJSWzsZY7i7u/uDz47OT8EANI7XTeDZHodbVGQ7BzQhqeEiW2pzm+I6jwftGxUCPBB8tsJhE/nazzVRr912u90qUFnt65znmePxuIqR7TjcIjibuLcV6JZlYRxH7u/vmSb5PG+757bddi3198CAsHme7b9NwJvnmWEYGIbhQc/m8XhcuzCla13Om/M8r0JaS88ZY7jU88d+v2cYpLd0K6qllDgejzx9+pT3339/fZxb0bT1IL4p0NZaJR2sr8/xeFzPKcfjcX0s7evAmkbcJvxaD+n2Pd2+Z2/2KW77F7fi7PZasv3MPH/+k3H99w2JY01hi3RpE3VTNm7YdVeiRe1r8k/7d1pRe+u/AIytZEVduSC7Ke88FMc0TpiSmJaZKTZEm6jZ45II1mKw7LqObugkbXJtcEacniXLY89VBrcGcCVKV5M+vmIF42asDJqMlX8z6O6uGKr1xFgJ3cJSheRx2O/xfU8piZILvutlEzlOYJRBPM+S7uu0v2qaxcjWDaRsoS4yWDwdOd1O2N3AMPSUlKhF8FYuWOrQk08zNUaSN9rVUen3QTCSSVF+zjKfhLWbciTmQiqFLkjSzyjqEFdwxmOsvh9O+v1qkj1AFj2TOBesrdQlSe/WbkdJM3nJpDmCgcu3DqQlcXlxydGMjNe34oR2HusTLlWqdfjOYslUfy5mr6VQcqXsBDFgcwabSLHI61YyMUec9+QoSD/jDD54WYBbSXakmklxBnp86LHZ4sJAXtKKTqwlU2awJojwV7IM9EvGlEwsiWwFb2axuM5TTSbFSs5N3JF+IkhkHQcYzsMDwSVZSTimRQSpYqhWkyFGXuuul8RiyVl6iIrsOepWbDfSjxiLoEQtgrGx20i6ltvHxawu5wcTgSq9gtWc8U9WF6jokKd9mwFJVlDIZi30/B9+5viB9N8PCgxBhbusZB7nFNJj9PifR0yJTHFmXATVVctCzjCnjLfg8czrWdtjSZLYy01SlPRM5vyUzMZNLsEhuW+rgqrVpM95yGKlhycuZBx4QUd0gyOmvHbrlAwlRco4400hZ0e3u8AYqy6+SiqS/sR66ZQbZ+JxFKd9kMGCKUXE3rYX8cKaz6Vq4b2Id6HvcdontiyZ0zgxjjPvPH0sz6VkDEkMuqEnDCIAlpzoK+TiwFlssFBEeK4IqicukXlKnE4zXT9IWtF7TAiUIgt6FwJhv6fbD5RxwUVL142c7CguYluoUfGi1lJqxGMFmpsK3lvp3TQGH4IgTYCaE5ms52/wVmJ5MSaoIgKKg6thwIokcXIhdEbQuX2v/WsiDOSYV4d4rVlSpWsvvAxBBfUliSITvKKdzoPlrA2BRaefbx4dRlOkuYiIyNIEumcPZL7L4Y+W24Iicu9efsIh9Ub/38uX+rUfOO7iJ4j2H/cI5N9e/pgMHHVgfLcO1xHjRdWh8+pcK+WMtSvrDHs1PBhagsRoIlWTfpI5kz+lkmMkUaB6jPOEviflJMNtI2mZmhJ5mgmmkLOn3+/B6AZBO+KcC1TrxN0/zcTjJIJSp8DbkjHamSy6pMPZ1iUsnaFiKupWpM88Z07jwjhHLp880dN7wpSM92BDhx967bSLuGrIRdIM1nvp99W1Xi6VZUnMc+R4mgl9jw0d1QVsiOQSBRUaPGG3p9vvqG7BJz3+zSh0gCLHsqlGTAql4pUmUXMiOCcOYQyu6wjW6hwyU9I5qeOcx9RKTFF6iLIKNDXLuTVriqggnUjOka30c7qqvSVJBcQKvmZqytLra0W1LaWJd1WRz177kLIgUktWw4xVQecHjwdj5PqZCoz346/9j/k5/1ER737Ujn9KPTp77syD80C2iXcNRylOdENorlsd/DVXedV9g3PnwcBqBKgbjKTV32HtipCknEXAc1eEDMuss2vSrCUPt0OG1udsrVk7CdsTrOve6nxOa8m7rD+bcyUlSdDfH08c9oOQFdqmufX1rP1HdUXrFt2/GatpmGqp2sNujMElRd2YTKwV5+oq0K1pOSNmSRm6ZJaYSDGJuVFd/ylmzkYNEVxd8Q8GJ1sHcNXnZxVLDA3ZrAKevkDS3WjW6/SKSq1mTQmCkeGp3SYwWc2quZkVOZtZt4jWM/qnngXZ1nHf3odaHojMd9fXP5HH/4/a7W6c7qrWKJQCtZFWqiTnsy3kkjAuCKmBc4WJHFtZZxhiJnFBrjdkhExitc8vA/NJ0ny1CPc6dCL0oXzpXGE8wfVJ+v6GAfod+E4TgoDp5GedhzRTTzPluBAz2F5Q+DVFSIKgLMj131ZNz+dZjEShw+06uk5IMBTLHBehfRwOGFthuoP5DusX/G7A7HsgQVdl6eeAHnlOeHn8VQuxU4IlQawQdrB7DNNrmAykKMMCY2HYwaOn4C/kPuNziBO4gB8Ei6huQDmXFkPyljqP61CNELBdoLNQndNld0OotdRPpZZIjbNULthmwLar6YZS8IjIX62kn12q1LjIn1oFQ2IKJJkDFSsJK5ukxkD8goWwH2RNZyq1tPOLAzV71lokwUkzA9TVjrCkwm/+/vu/+tl4/lMRAF+/OaT/eBTf2fuyTZU08dg6p9ZIoV+ZlvAz0rEdF8HXpb30SPVdTwjdatZr/zUgqMwYCcHTd90qDLUBunVW6oNS5nh/z4vnzzmNJx49eSK1J4r08yGsw3shg0RJ193fYSo8efSER1eXdH2/Ps82dM85rwmXYRh4/HjH0ydP2B929F2vnX9Gnqs+tmVZtHO4Sr/WslBLZX8hYsA0TTL0nyaMtRwOe95++23efvYMA9pJVri7u2cYBhFkFkkgBe9J2smYUl47wVJKaxfgbrdfxYFS1EDURJhaWaLsV+X5SrWTd5IIcrre74KkNHfDjq4LYvJNQiea52U1XE3TxDDsROTTx3XuixTzUS1V9ncr0u5hz9c2Qbr9/8YYXrx48S8+Ozr/9G/39/cftfekiVhNNHsgzG+O+yYAbvGt23PCFvf5pgi4TRWvXZGaJmyYy5YE2/7uJgq23+m953A4MAwDXdetybtt0rCtjVvf3TzPa8puHMdVmOv7Xrs9BXd7cXGxGiHaPqaJYE2s2j7HJmz1fS8UQf2+9ry99+ux3zCapRSOxyPzLNPXq6srDocDzjkuLi7WPw3F2XoSmwi67e07nU6klJjnGWMMwzCsIuObQms77pogeTgc1hTiVghsCM/W39kwpG/29jnnWJZl7Sts71FL9G0RrGsf+AODwkOBsp0HvvnNb/6rnwgBEGuwRVsxWoRdu/RMZUXJsEIQmoghCSuDIWutvG0bKsQ972yVBKATf551ns5brINjzjgDscgQOsYig7nShmSVuQguMgRH33kePz7w/OVrjqdpvdDEWulqIRew2otmNb2TlgIdBEWGUESIXE8ERUprTbA4K7go03m63UAxhiUn7dHx2E6Y/gyBcpqY7ka63jPsnWAj+wKuYKvFkZmjDJdLqXjrubqSLpxcIjkLpsx3PWlZqCYThp6SA/MyK6rDs6SK73wrpZCy8lKozlJiIk0JYyFYQStWqxuj6tZtXvaQTRG3dIEJQ40V4wqnZeTVd18wP3nEbtfLgmuWhbP1jhgzCzBcXGC8x6cqAoh2pFXtT7A5If4f6S9wXtj+SwTfZ7z2b1hh7Cg6ZaE4TUjmtIozNQtWE99BjaS5iNPHiVtS5nmJWD2hl45GnZzIZxJDsF56jBwkb3ARehfIOakioGJBNrIryI2TXGQzYAy2NlGprh0sxlhQ7GlJiqApRc2iIgA6xbxIMtGwWLOmL6CuBeOGypQSS8wqCNbVxd2GLwF5z0orUNROKhmGCZ7EGiN4O4ege5vTHBUVG/IGLUhGqiHUZv1x0sQnSBft3zVh9OyP7gP0CCqzVbpZ5yX9tz3+a+J0t4hQa1uaL0POzJmHyb/cJM3290RaPNlncXS2zruNemNbbKc4FSFl4O+cpDFbnxfGkqugfJ01mjKTYbF82aslXrrsYsmYVLFuEbRVEUSRuO8kUVSXhTzLBVHuQ/5bs6RXUpV3BaRz1GgvXdHuzmotLvRCIkqZZUmyr/cBKFgSzmZs7wm7A3irSVEZ2GWJUarAff6TskTd5/HIPA6cegf7A+TCMi/YrGnsxeHUXZGqJ1VDLLCUSnbyGjvty0ox4TNgzuhNU1E3r8WGgKkVlxJxPfe3FKaIM8Z3kBb55Dqrbv5EiQgeSJOD1nvtFZWkknVgcyFmiygdVkq/jXxwihFcU4oVXKZmwbwuS6IkSfGir5mEGES8x6oozZkERXFMS2Y/eO7uE3F6+Jkf3jhihmcwvfz47znxwxN9DSO6UkSfPXsDA9oyhJ9wjK7/fYjvfcYZHfpnMQz8E3WU1XqsmLMDe9M9hQ6kU86EqsgPp2sVVdetHFTSY4zR41/Oz7IZWB0ZlCr9nd6JSJhrWRPD1kkvZC2S3l1ywrqyduVKv2zBd15WQ1HSqGVOiq7R31chFVkXpaIipQHvNbFWsszTvKVYiwudXGdSZlkiSZE61CI9Pq7iXIff7SSRYAzUXgb27fgvzRwhV0gxACzM44n5dMepc3DYQyksc8SlJMeMi7gix3+sjlgEpx1LpWx6EE0vSceQkyCqQ09eFk3QaAePF5HPZkl4OwNR3f6tA9EosQFjtNdVjD01VZ3Hi/HMOY/TDkhrLUGP/1QExWaMIaaFuqgoi6Tncyxg5XrrnNXreFk/V5JmkvcpK5a8DQxqrWLQqIYl5hRv7v7+n+bn/tM6zn7Uj/+S8/WbMM0mBjanfs4N79o8UptUV9vgb/CgLY1XFYlZpb15vV9bZXjWNnvS7yxfM7Vqb+fmsRRN61XpByqKxG/7o/b7G+5Tpa31cVrtAjfm4RCi5LJSHVIWA1CKSY4lJx3E5sFQgU1Coq1by7om7LogPaZG8PhZaSvy2oSNeaz1AK4yigp8YhxIMRNTWdfM29cCTfZJALmoGKkoTnPu90PXwG32Vjava3tdjOLD2/rZqPGyodrPg2Chs7DpVWwm1CbGtse5pjxb7+om2QiaftC+x6w9gvJ7bGuOJKWUrr/znZ+I4/9HXgA8za8zlmqkp1FW0E76W2uhFEPOckyczVsWcjMNZemNxeCM9D250KnWo8emVeK7kZ48nBXspe41BUXhJdmXikT8lwplhrDIXrVEMEnrSIBppk4jZsk44xi80ToJWUgacSfIwJpK6DyWjpQ93izQO0znJblcpRc9TlFoOV2QzsF4hzFH3MHD5QF2QcRMdiLilSzJxYY2NV6c0qWKgDneSHrxcKUcf68vhFQbYIBuB8MT6B/DOEF/A4sV8TPINR1rYB5x8x3G7TCuw8wzxIgZBqgOF3pMLrIvqi2Vi06NBE1u/ABJdt22C1gvRqIajaxhLFof4nTIYzG9wYSKrRVXnJi7DUKHiioIq8G41or1Cy6ADcNqOj73fmryuSWKVfy1pj7wy94cp/Qvfvsbn/V/fQq3UsrorHtA0nbOrtfm9t+UxPDdrg9BU3kt0SFVzw7rJAXW0ujOWUFXG1jmhaHv6fYH+r6jFiETGWPouo5aKtM0cTwdWZZFhtiHC+nK01T/MAz0Xc8yC7rudDzhfWC/2+OdXzHSLf1SSsF3nXTQaRee94G0JCiw3x+opTCOI6UUdrvdKoY0jN7bb7/N06dPefzosYhj+9058VKl/mgcR06nE8uykGLi/v6elx+94vHjl3R9z263k8c+9Cwpyp7Fe3bDwG63k12kDtu3PcvDbmB32JFT5v7+nqiYzIYvlE60WUTOWljisoo48zzJviaKk9Y7r/8VY4b09opwYNvQ3gvm8Ez0kb2FVdPUPM9Mp4nXXK8pQWfdKgSsvYEqWixxke5ATT5uUX9NANimiPT70je/+c3/+rOj80//FmOcmgjThKYY44prbOJQe8+2ia2tmLdNB7bzxieJgFsxsf23IWCbUNV+viVgU0rr19tj2N7XDzMxbPvu3vwv8KBPcL/fr5/lLfpziz9ticn2e5pYuu0g3GIunZME8DRN6/HRhPt2Ln369OmaGmwI0sPhQKfnrib6tT8tMXt1dcXd3d2acmzfvxXctgjQJp42QTOEsIp77XE3sdRaqUVr39Pup2FJ2/Mbx3H9+U96DR7WAtgHx3/7mU06MP2zf/bP/u5PhABomjuyuVFba9hm92DqpuQPVjRV1Z+xq6OyLZQyRl21LXxtQ08x4mZfMhgng5i4ZFLMpBSl1N0ZXeJrqTziAsE4gsuyTm2qeVRcoJeBcSkFvNWkEORYsAVZ+GofgNO+mZSls0NcJRXnBLNZUgVfIHhyzbgqi8uSBRdlq3bOiP4gj3nwlJK06LejuootSdj23uLMgKuFXCt5idodCMlUysy6sbTB07lAnGcRmlzBpYVcMmmRoaZ1ZaNsSBQq7Hqs81SnJ7ZYMa4KExth58dSSFk2wpaICYLZurm/xwxeNvppJk0T1gZwhpIy4/U9/rEnLpXj7YlxKUw5UUBcjSpImJSBjAuarkuZJQu6kpIJ1uGDJxWPDxZrLMs0ycI7RWw3YIIjjjIcdKLm4KwMeXEOQ2JZRoaux2Wx90kC0CmvH0KpVKIkQLKh8146y3KhFivvqTPUasgxE2OWriUnbsPmKDfGYGuVOkJkiJJqQZ6lIQHHeSZlSRWWqoOZUgne0QWHxbB0npyjuqnPW/NaMmM5d4409EAbWlkttV6SSGKtL8ZoUXnR4XGhLYblYKv2PATBGKoRZqExde0G/OHjgfhD/j38Ed/z8JaQ2XsJDtf1ZCTptlQwpPX4zykT87y6dBUeTCRjOw9KhSutA1AFQfFsCgY0KfVniYUuWN0kCH7VYc+MUFn5o5QLvFWneE14bzHeaX8H8lmhiGtuWXCtDwi0E0yTR6WScsRLvFGc/trb4zqPDWenybIkrPdixo1JhtsI/spaTzIW4+R3kzKpjNjQMUfZjOBkKOAcGMX9Ohck0eadCFUZYpVNdEUScnFZViG2aPepNROn+1u6vpPhZV4wRTBXhoJ1kdM4YYsh58o4ThzniSklkrUU46GT4aS1Frwe47mIdlYKxYTN514SV0IaszhfqCkr9tOt1xSDDEZqtvLZzYLqtJ30PNSciSjisHNYK6i/HukdE0e4XLAd8vrEbLG+rL2DZMizpIIKhW1GoFLOuEf9sDkrJoyCJCxT8dyn0wM5rvUABmAIIvPF6RnTx8l8Lx/iQX/gpkrfdNb+JAX4bNjcW+TlA8E+/pBj9U+/++9PY+BYUn5hkI49SQDlHxjkruXg1RJTkbR5W+BtUh21VePpYDzVivdOsGIURVHL8V+QZKE1FW8teVl0HWI2mDxF1lbpInK2GYykWLSUIsJ3cEpJgGWJOOfVeS7Y76rmEmsdqXo5/ksCEmmSdcESC0tD4DoRFI0mzAWtGcB7YpFheqwWGzpJR8fEEiNe12rFiLBup5HT/R1d34mwVmbB8OainaCO0zhjs4ht0zRxnGfGlEjGUK1s1MX1ZyCIKJFLxSSrnbb+jKKuskI01mKsw9ZCzZnUEn/t2kehVidY4FwhVYqpeD3+S8mq6VoRa4OnzpEOeU+LprdSTnL8e09cZO0kR7pcE/OSqVkGy2VVl+ragbp2hqHoxyrrvnGav0+Mv/PZkP9P/7HkZXm9vjWaDkN7ItuFxZ6VsxX/K308bDbZWTfn596+VSVqwp/+bBMWzo5QEZmC94rwVIOIinkPRcd6/t31jPu0Sh0put6zDZkJa0KtrTtZxa26Ju+osnYvel/eBxHWKqRU1tRiLoUcI8uSNLWgeShjpQdd0wYYQQvnIh3Fy5II3q3dX2JaaufWSimZGBPLLH1JOZ/7CZ11ig4S42E73o327Vgjz9F5t3YktZRfS961PtdqWFOAkvw/C7dlTehWXWOVM9JN96e1lrWT8E1BtSGkjTEq5p87AQVVymY4pL1/uazvcK7yWoyn8cN6d//Z8f8p3G6P4yvpkPcYp6wPU9fZA8WrcbOswg1GBCJL1b4M2T9Yu/mcaf+krP4T1ch1nxAEmWmriH+tC7BmsJ2KVbIuJWUR2tICZRFnZalQF6myqEkSaZ3F2YAxYjLGFEywsBRqjNSSsL0grw0imNW6wDKTbaXYHuOzCBZdp52lE5Qj2AShh6GD/V4eX1KSjVUzdYykJWFyxVUnAmauwAjja3BVzEM1SbI/iAGTLkg60MoaiTqLKc5LjQi+E5dnXURQ7Bes22FsoOZFXhfnYdbzKtpB7gzYjmIsJrU1uZNZAY5SIs5UwYMmKEvB2oL1QSTdIps9Yyw+dDjX45YFVyLF6GAXSzEFVxPGdmQr1BVjlXoUIZ5k8Gq80ZTkeZ1iasXoOVjO+Y6Gl/jOh6+/+9HN/e9+Np7/07+N4/ih07X/eWB9FqGa4Nf62UopdF1Akn5uHbS3t7Yl4pKKCBgv5hFd+1nr1h7AeZrPQp/ed0yRZRYRK4fMYX/AK02idWN579eUStf3PH3r6Xqdj/MivZMqKLRkTBMbQtez22Xu0718bVo4jSeh46gY0AQJ7xx7FSufvvUWj68eEYJfjTT7/U5ri+KKBW3Jmmmeub+/49XrVzx58mRNyOx2O2JKYuRXUaGJrNM0cTweub+7Y5qmFXXqnGOeZ/q+X9N6NzciwO33O6ZxUlNNWZGG8npmxpQU8e1F9IgLMUWGocP4wDzNzMtEFzqGsCPnvP7uJsz2IeA1dem8F6FzXrjONxwOey4vLxUBzwME49qdrOudbcpv/cBszU3639Pp9L37+8+O/0/l+n97+3Lb77dNaLVEYOt2a+JNE8K27+ebQtPH9QFuhbnt15qo1wS3baqufV8Tomqta49f13VcXl6u3X5bIan9jm3a7DzX4IGQ14Q4YBW2GlLz49KKTXxrZoGGJ96m3rZ4y5aIG4ZhFR9jjOvz6ft+RX42o8DV1RX7/V7OQ5vzYxP62utyeXm5okybMNjeu4ZMflN43fY49n3PoCaElBKn0+mB+WOe5/X1bvjS9rtDCGs/YUuCblGp7fFuX8M3hdvtZ6A9h5ubm+9+73vf+/pPhAC46npVtmZlU/iOpgCxrZdBE4CmSkrDtN4Ks9IJiwpmIBuxnApl8ATryNrVklLkEAaWUohZum9iLhQWTHE6IDK4Iu61VGTN6Z0nOB0UaQ/XOM94awlOiwudXUMC3eB1kwjVWXyQx5xzVfSLokPK2iaP3Yn4lceJpSQOF3tSjNhFnPmysAbfNSeh06SkdAxam4nZ6QfQM85JNs+aHBJXb5Wy8iS4wBgXwdgVccF564lTBBeZ5kkSeUHcLyUL2tEYgxWYpaAFk3ReFOOINclAX1NfKWURMJNslKbFYr2w75d5ZhmzbAbmCUqh9yJy4eA0zcwfycj55uaW63nhNBdi1i50itQt6Ou88x7nrYh2yGfBWgd9J4KMXO0p1WN8lFSA6yg1EZdEzJHqHDZmvHEknHQ+YOj6gSUnpii/K+WF0HcaEtMUhjfkpJ5uWyHqsFJVMWctpmbqUqixMI8LoQuyYTQWo91fs2JaWwdYLoqgMoJJikvmNCdJEVTpM3PGru/vYRdIKbNPgXkqmFpw1LUoWTCsWQV0FXetOlDRRGqtxFoxKmDDSq2V76sN/WlXXjq1ncCk9B4jiNLm5pZzmj376RtS8OVD4WErVJz/7Y/ZIfZS4IXxMkrnohXhDwvVS1rs4OW9jEmxERkyCZtl/44Dnx3FnVmL1nmppnBpraiQC4+ogiVJsqvRUtdn2p6uusbQz2ux+rPG4o1IC7bIwhQrXV/VyGfY5EIpct/Wi8Pd+oDxOvCuSCLF1fPvd1IIZqrG4lPGqtRkO4OxnrkW1fGjDrg81sj35rTI4GyXMTVQCwTncF46VL0DW4IkBZ0hVsuSCtc3R65f35Lvr9lfXLJ/9AjrOk5xIVjYdx1TKXhfSCkynU5YUyk1ClJQjRFTzrh5osZEzoXT8Z7TeGLJhSVbipUkc/BOujS8iBchF5Ysr2+t8phN0aSDl+5Aqs4niFASORYN5yYVBK2KApqQck6ShooFFKeudKdW4zGKhnLVQJFhSy2ZVBI6BlHkoGCYcsyUqKXhXkRJq5+LVTNSGpTRz1hV44l1sJA4joi4p8fIVorb7QI5RXaD/Nv0MXL6y4/X/FRM3Ih/bxyOP3jb/uaPE+nb19/8nh/9IWNZ4ncbks1qJ5ZgLus5nV3Oi/KG96sr1cVoytes65WqJoBqRKTKpqjAqJjkIv1vpRaxWFSLaWnvKvOwbBFUdfAqAnLu9VPHsXFWDBlVcYExr1jS0DmMM8xT0dS7mlbwmkA15CWSy4LbdZgq3YHOOxH8rMFVWZhiHNZZIoa4Of7T8Y795YHD5RXWd9wtkeAM+07WC8FXcpLuQ2elP9e0Pj9rmFLCzxNlieRcOR3vOJ2OxFxY8BQrwlnnJXVrnMc4iy9FELxGRvty/Jc1Ae001WAd5BSpOSqyXfqaSpGLgAthFVS8a87+vOlbK6SSJYWsQq5DccfWCIK1CCK7tjS8Ui6a+7+UAvp8LWdnqFEBIeugOBVJ3edcOR6n3/s0j4k/6yH/n+Xvz/P8/bYbKaWuSb+Sk3brsW4sm7jXcJyyXN92/+Wzs7dKqtZaXUc7o8KSmho1SbLtEGmCmt10SZw/K2/KgGdiu9WO2aKd1WXtKaznddjq2mIjeqlxYRWqeNBb4TTxa6irkWCZJsZRrhzDbkASa5GcE2WqhC4wDL1UImDWDblz0o/dGC8Na4qR9VobeKSchLwSJWUoApm4hnMB79WcoOJkS287Z9fntgp4q3hr1i5Aq8lLa8xqSN26tJupI+czsaYNNrcJ0TXlWeFNdn6tIqxuHeLo52s7LK7N+ErVvZP8ntP98ff/fTr+/yxvL69vv1tyxrpBRNk6azJLkNBUJxSHUrTGgbXDUQR4ObatV4x/qZiqKXQnn0tjRdjHevlDEUFPTTgUENdykE1vgNoZjBPTjeA0o6Anq5ZEI6KaiF6yuKxZDD+S+FPDaXWC082RjHQZOmOJEdIpYs1CsQXXJ6wVM8uKJpZNkYiMIQh6NBrmY+L1deZ7v/vb7PeF/eVAvxvYHS7pw47gBsGi1lGEu3iSpKDJ0A/awZtFWHQJ0r0Ir9M1LHfyOphBN1ZJDq/dHnYDmIDJHrMALlGR9c3ao6cdvii+26UopIISlI4SIS+Y1CvuXUwU3sl6Kdt8Tv7YLP2JdLK28PIUDE42yYuRz0ZNQgFQdLDNFeJCHBeZ2YSGRKuroczoPKytG432lBYMv/PN7//eZ6P5T+d2PB4/bO/3VkBqOLftn3NCwzxAyrUUbUN4PiABlDPmrV17lnlZhbk2OG4Co4h0gVwKFxcHLi4usNYxTdNDcUmNZ9ZKwtAaQ1miJvJFyEORdtQqCT91JTdk4PHuyKtXHzHsunWQv2IOrcWHQN930qflpXN0XhZevnzJr/zyL/Nf/Z2/w//+f/e/5Wd/7stcXj2i6we8d6t4kFNmnmZO40n6zEuh73sudS/VKd70dDoCho9evuTD73+f6+vXGGvZ7fdcXlxIB6IO9Y/Ho6a0Ft2zO0IXpIMQmeFaI2uL0g+M00RKCVshZRnw55R4/PgRfS8zTWvcKtJO87ymgLa9X12n/X0Y+r4nxcg0zasw6b1fKQwpRZYlrlfWNzvktmuArShTdS/y+vXrz47/T+l2fX39fCvCbBN87RiNMa49dO22xX2+2Y23FXi2/96O9Y8Thd5ME26/d11T6jHQRLRa64qwbP1+TbjephbfxI424at97loCrola2/7Aba9dew4vXrzgH/2jf8Sv/Mqv8KUvfYmvfvWrfOELX+CrX/0qu93uQQKSNtOydu0VbAL7VkTb7/erALjf77m4uFjxpu2xNfFv+/o0QXSbamz3ue3be/N1aO/PutfZiII5Z4ZhYBxHOSdME3d3d6sIu+1/ba9ne0+bCNoe21Z0bL8/pfTgd7evt8f74sWLn5j+X7/2/lmDKVXEFEUgomLfilSxBlv1YDG1mXFlY2zq6mKt1kHJMijKhZoNOEPQLg6JpYUV0ZaoMpCxrXPNEqhURUIFb+mC/P++l4EbsRI1Tl/IUD2lWlKphCSFHomMqwbvzeoAqbpptNWAq/je6bBYHHhVYPYc44wPPRRFVVRBd4Q+YH3PcooQHLbzFEXulJK5uJT4v+08xRmwm6G/tdQYKRhC6HEhk5K8rjVnaszAIgdPH5hPI7UkOtdJKsBUGa6lIgLSUnBeBxMqcsVcmJfCMp7ISbqufOeRPFoWjJmDtGQ648hGHEG+M1jncQ5FCRpMSsQ0EbNnjonX1zfczzNzTsRUcRhsqsQM3V76FWRIXuTzlBOOTBccJUXwPTb0MM9McZS0nHUsKWKKw1dLto6inUxpWaR9wTl5jb1E95eYMKbivaHOM5MRUdgjWFLpZqnUZEhYbFmEelKL1hVYEdu8Zb/rCIMjF+lGM0b7E1RgSlmEX2eBXMjJUDCCZSwyIK5VgJsO8J1l6CzBOrCSOPBOUhcxF0XYGJYiidDzpLquYl67eE2pUIrVxGJdU0qmbntkzk5WEebrunGp1ayl1W2QJG0WBsPHqA8fpy78sbrF3vyZAV5OxBhYcl6F1M5Jl4U8kUC1sqjOQF4Sxcn+umRPhyQHKZBzou/61Tkj/X+RQsBlFf8KqyJYSzlDwJyYCIy1q2NfqVjrcMX6IC4w7TIV/FMStKfVng4QzIz3mF2HDXKRcX0nn80k2BwxK8uC1XhHnud1EFVb5ZwamX1w5NJRsmAxS5buKuvlIhZnS55GUrDiUJbo8/k5YOV5Oc8YK3OcuTstjONMvL+njIkxP2c/OJ689wWW8oT33/82+WDZ955OuzVyzkzzhHeccRiAs4bTPAMzJWfu7m65Pc2MGZaSwHoRz6vHmYJ1RfpLiXK+VSxTLQXvJGUElRJnqFbd/hbnLRXp5Kv6+bbS7E1MMugNoV8HB+hjg0pJi3wgjJO+0Vop1mGNfHZSTFQjYkRpn592JDntENRB8bnmVrKlVRN/tWjyN0mq1Xde8NBbWa+JgAMMATofVLae4BkMbyT+/uj0nxyQL18+49mzP86lPHyM6PdHiYQ/OsPFT3wcKX23FEl/5qwo45LPC98Vcaeja93UVwUe+7aIax1ZDY1TZPVTkc7Z2jpBEOxMSkoIsE0YlM+F94G869WQE/T4z6uzv2CUBOAE47ksYhxRzFzNmhKwkpjJIVCcXANLStScReBzjmWKlHkmBOkgNJyNHPKCKfLSOaaYmWLi/jQzTpHleKTOE1OZOAyOx08eE+tjvvP+d8gH2HWekA37KufXcRolTWf1OSNdJqdp0nNu4e7ujrtxYUyGpWSqc+I4rg5rZBPtnaGmdvy3RFDF+k4FuEqJyyoOWGfx1VFbB+/GuEESsaE5/XGavliFgyLrCuWDteO/WlnTUQw5JRkSGkEhyZVS1Xznsa6QqbohKCsmueiGZO0/q4JkTAWO96ff+EkY8tcfg+M/z9O3i3bFWXNGNJqG722lv3oPZxGvaWpVTQNNCFSxZ+0ENU0zEGKHcXLd32wOZbNuSUnE8a0zvCom/ExxsGuKbr3wm7P4XDbupCa+VX0AkmTI2jWpPXq1KCuBtefPOrum5NDXplBJUZzGmErwQTfMsh6OSbrMx3HSlD1nMd5IP3cT4DCsj6OJXjkLgnhZJJWwxMg8RTnHKpprwAjFQB9v0vVu22yLeKuI+5IVvWbIJQs2vKXttMvTaEpg7cTW16Rqf1h7H1tqsm466OHc5dmEvVrRYW7eCLrn/j9rBTXYlMqiQlP7Hrn+wO3r63/94378/7iIiq9u776bq0T4rK+UeL4Wy2xCqhhKydqVJ4biWqQ30DZUrgqA1Zz7A6t2e+O0oNx5cR42fKZEhnTIoWlAZ+BqENKm60QkWxbqNAsCVHuGsV4r2nPrURFBPWVc0ZBi56nFUp0jlSTml7ioYGFYpgp5oRw8DjGv5ijpHNPGN3YvmE48zIZl8SS347u//xvcv3jJkVu6TvbKYRh49rN/gUdvfZ5huMIWC64l4rMIifZS6kyqdqDaAukO4hGmo1xTwyOSOC3owyCvEUW+lyJiaFehQ+YdKYHpZB5SFxEXqyBRnbeU6ik46eEtamzNlTIvYiQ2jq4fIFiZTam30hApS6LUCes6arXS4ecc1goGPc8T1SaKN9SaKclh1Ejih57qKngrr7lF1i6t0MZUDT+WtRpnjpn/3++//xPR//PjcLu5uflDMQC4B0PubXfTmwaRnNNqlHGK92zXh21PWBso+yBkCR8kHXJ7d7ui8Bparn2v806SMvPC4XDgcLhgmkZiXEgq0O12OzGw6lBZrnVe6RVlPf8G70naMzieThyPguhs3WH3t/e8fvWKZ2+/Rdd1a2Iw5yzrg9ZzWCvjeOJ0Oq4Jvf/q7/wdAP7r/9P/mf/0f/03eO/zX+TJW894+s7nsF7SgEV7beMSpfdP00YNn2idrIlPpxPzPPPixQtevX5FBYa+5+ryisePH61YxhgjzjpyTkzTxOFwkPW3GpdSQvGlYiiyzmlPX+sJNszBq6FHBvunacRUQZ1a53BW6hk6HfRvk1htQO+dk35AawWVmCW5lVOW9yklvJe0Yy55/f1msz80zVykiMa2xgB4+fLlv/nsyPx0bt/97nd/byvSNFGmve/tc9dMbFsxbivy/TDE55vnkq0Y1c43TSRuYllLkjUhsiGHtwjQJji1+2iPtd22ONE229wm2LZYz/a7xnFck3Mtkdaez7IsHI9HPvjgA37rt36LX//1X+fv/t0zqfJv/I2/wd/+23+bL3/5y+vPt7V9w2k2dG8pUmd0eXm5no8a/nObBmwpwfZebDGoAHd3d8Qo/arNTNle49VUqOaKN/+tvbYtedmQx7IXkb1OE0rbOarhQ5sQuBU43xSRP647sr3ub4qFrX8Q4Dvf+c5v/KQcX97oBrjUqkNVHb5owfrqnNbpaC5p7SljdVWDUWHQomgV41gKTKnqJtXqBitj7CBO0hy1Q01SVDkZ2Uwrwkk2/oUQPDEmdWNrnNcpj1lRe2DIFoI11JLkYuMM1epwGbM6TxtesV2JnZPeCuOM4HOK04RKIaaF4D3gBdNhREKxO8vgZViWlkrJiZIiSwoyqNINprdGxI5cwRuiiyJaZMjkdbFr5QrIMicRW4v2dCCpmWAt1kjxKMbifCAMkGd1OTtLppBjYp5P3Fzf8f77r7lfMoeLgavHB548PnB5ucM7Sy6VUjPFeJZ5IQRJBWItOVUsEYpsrlKeuR8nTseZ+9NCbBvjpWCK9BUGLEmHGa4UvDqfUpXSbEqh8/Jex2XG2CB4x5y1QL1gug4nVUqEXvqQUsyUlCTl6BRn4APBQ06VJc64vpBxVAMp6kCmJKaY8dZSyKTmBk8Z18mmy3ojIkzNbe6A9R5TVSjQPqazHUgwSqUWlizdU1QIztBpl4yzlqvDjj4YqJbOO0abtRdGNqW1VkmEVjleKlVRRjKIkMcMpVqMCRLmq4qiNHbt+ttCe2vD2RiDqVV7OPVzVbcdShVZPn6MwPfHERpexj/e9z0bmIB5kc+6QxJcuUSM7UlVLha5iJu/IMQY27Wrow6JrHtwt5aGFRZBIyOpwFqyIEb1fVtncDqQqwWMKzQJ1hrB0FrvpV8Ei9PzSV40OeitYLEUgWOsPAfjOoxTpJUp5LgQ54ngHNWHMxKsKJoIK91SzmF9htY1p52PBdtOGRQKtYogKD1jAYxsUHe99HSK2NhjjKCHpRJD7r/vO8abW8o4UfKJ4zgxfvOO5x++xHYDrz96hb18yhc//x6h25Ow5FrxtcoQ3hiKddQq/UC1CiY3LYnTOHMXLWMqnO6OnJbIMOyZphNvvfWYZ08OJFPwWl2EM5i0GYK21Lh+3ToVeEvraHLY4gXvo47EWhN1geI9wXsVDSFoh1dWx2W1MlRobZc5l3Uw1IThXOWaYK0DIyJ9KSJItE9X1chfroIiRi9HVZOhy5K4OPQcl0SMZ+Fvi/98dHlJ34k52gcI0zPiM0kKDhu98JN09nZfvHy2fvPLB9/0JvYzfILo9/Ei4cs/bpL3R2DIWMfpXxiMrv/0PFcaqamuaZrVeWudvOdVsLrVSl/xqhfKgacCgsEGwX0aKt5IL1bOYqowFbpBNpJVu62MAW9FtPPOYRCjSpoF8VHXgtWqg+qqiVc1cnhJkujZWjcAVbr01uNf+41LlsGlkUXoMHRYxQKKP8uu/VUipEM3DJxu7ijTTE2RU4xM3/pDXjx/Aa7n9c0Nrw6P+cLn3iN0gYTZHP9yn0UTBktMch6IInAex4W7CGOsnO5PnOaZfr9nGkeevfWIt55c4Cm4lkx3TtDgpYAzqyhTFLFp1eCVS8OqWkHDO4dR114tmVoSxXsRaqk4Y/Be1ikpawrAnq+LBu1+yVVEPyM9RVkTWM56sIbgvFzj46LrWDn+2+fKaqdy0fcxSydMma9v/+8/TiLfj5yo/ye4pZub37Cy6DYi5Js1OddQ6SL4y2dOBJ/yA2LQ9lHl3JLCeuwY2Wu0ZOp5XSZPoh2jq2CoolvOBe+cDtLqg/TaOnyw7dom923cOZ3WRKemE+ZccNasBIGs/VRr8iD4dQOr2wVNQ2daUr7vOzU7tv3aeS2UcybFyIu7e54+eSzkg4bEQfw6MS7r38+O2Na5In3ty7yQq6RvSy7cH0d2Q79iuKx2ZtcK3dDJnkA7B9tA1tDOe0ZNV9q300xqLe3t3Pr+1jcU6y2us5E1qoqy7bUtKha11zGlfM5p1nOH44pF4tyl2Og4TUCUwUMqr77zwT/47Pj/dG7feP/7/zJlBbJaJwDwuk4mFPkqx0D1esxRqTlScHKuR5EipmGvrIqDBttZ6LU7V3GZbT+K03Sds7J0au60zoPbo6xu6jxS51Gu1V66xrF6UBeDKRajZBbjNSFY5GuC2jUY43DOKGlEB5s1Y5ynKLbQOU9cJkGPOivrOSNrWcIA/SXOOj74ra9z890PGe9vMP5IiIUuGPxyx/K7/5zTT/1F3vnpr3B5eAqc9OWpK9p8PdCUlKCOACiWOTzlfsm8/t5rTHfB537mGfPNNVcHh9t1UCPkSZ5/7ynjSF5mTRNr31/W3Y8Lasoquk+zYig0Htv1MgycjmI67zpMdhJ01HNfySLYlTqBiyjQCmqm5IWUCrlGIXtUKKYneI/vwAVHXz2FSi6zzoMkBSl7CTGLn68eMhy+Oc7l//ubv/8PPxvNfzq3169f/9sGlW5D3O2gfSsGngW3syjUBtQPBv9OEJpNSAohkLIYZJI5d9i1hFnXdVxcXtCFbhUHliVijSEuC8fjifv7o1x/u46+79WIWHQ9YNeB9BKXFZ1tjQQblhjXjrOUFI2XhXLV74Z1DdHSNCklstIrWtIohEDQJNwv//Ivr8/3OfD3/h//L/6TX/g8X/6F/5j72xsePXuHw9Xj9WdFFOvoun4jQOiaV4ftt7c3vL6+VgNR4Rvf+Ab397/Bl770JY7HE1/4whd469lblJoxGHbDwP5w4OWLFxTFCKLhgGWZdT8zrE7sqn3uDTXqvSeVJF3l08Jut5MUMUID2u12qzg3LzNQVwHCOjmnzvNMTHE1T0UVJ7qu072cpH2O+bgmS1vVjl3F5DO6UP+ev/Wtb312/H9Ktw8++OB3a63VGGPOSV27ilRbAXArnm373LaJt63wt02cvSlObYWhbZqtiXstHdt6+rbpwJZua0J6E8dCCOtj3WJJ29qyPacmYjVBsD2GGCOn02k9bps4dvZKy99fv37NBx98gDGGv/pX/yopJcZx5Gtf+xp/82/+Tf7W3/pb/PW//tcZhmEVStvv3CbmhmHg4uKCvu/XTr5Hjx5hjOGXfumXOJ1OfPGLX+Ttt9/mc5/73MbQeBZPX79+/SD92M6p7XVphob2GjZE8dbssE16bg0fzaywfa3b+bG9ju2z0gwc23Rhew+37+vHJQXP9U0LQPm1X/u1/9tPjAB4dgI3dJ1RDExdLwRNHGnJo2q0F9CIyCDb87J2axQMxVTpo0qJkhOuDxQrQ2rfd+K0T1Fdt1XFm0LNkdA5qumxxtKHQM2WVDL7w8Cw63HWYbWTIUZZrKUiqC7XBAJrVjSpXRV3IyZyHUJXKy1qMSewQZx/GZJTnGMUl2AJsjnw1UDO5BoZdjuImZqSdBjGSLcfhBpCxdqCy5BShWzwVKYl4jrhh8U0U7PRnrRETQXjPV3nFAmqroauk14xjVtmCyYLYst7S54Er2GcJWfDPCdO9wsvX1zzwcuX3E2J+tzgnefiMPCln/k8X/5zn2MXDHMtOAPJZOZ5oieQFJlkTaXkSEIG7fd3J+7HzFKzrN9rJRYxTQZbGOeENZXOF6pM6BXpV0lLFGzCLAgEG3p5V2wlz5VqBdfp0ISerxA8JRrFqmiqIxVcyVhnyYsOEkPAmYKzWkauCy9xZcuiwjoRNy0VN3SEnWUaJ+kAM45SDcZIwi4VzQcZS7aVHEszcFKKDmtSZTotLEvWk4UTBG2t7Hygc47Lfc/Oe8YxQl1kyIQMH6IK7k2Ysxs3vtW0nnQ5CZpQHpFgd889nDrkUEyRdNicnea1beDMBkxVzUbc/x94e/aDgsIn3iaIWRC4rndk63A+4LsOiiXlKB1rTis1kmBAewcFj8XRhw7HiZxlgR9zenNESFERsL2OTvt2ztF+SWYazgmTqntRGRyp4LUk2YTKZI2SIPm8wVFqP5xRhB+IA3VZMBmq4kdLzri1E1XEP3HSZ7XdC3s0LVkdslkS0qEnG1ks1LxgTcEEyNbiDPTBs+vcyqMspWBzASsCedd5TvdH8vFejt0EcxIFaUwvKQkWnjE+/y5348R/8D/5c+z2A/0OTKqkmnDFEjyKSpLjMWUYY+b5XWTULsE4HjndneCxvN5xHjkdLeEQiGmhYFky7EikeVT8oQis3kqnay0N6aeeD+0lsk7EQ5vFlS37H0nzeAcUSzGSGrIaZfC9I8aCKY5cC5VMWmZySSs2yWAEF+i0T0kHi95J+rcl2lPVzWRpA1iJl8aYyfoWHseROJ3Fv6DMziEM9C5wuRvYOz3+kW8cePmJyb+VtLvp/mui30v9hk8K6f7gMRg+4ev/7h2An/pAMefnuZQF6EUsl9FfOwu2HqeWBGnHf0NHNnNTp2IdauRc3Z7aTVVLEcGtagm9EQkgpQxdY8MbKlndwk5RklEE5NIEZMVhG228bO7/ql039jxUzjFRYyanCM7SdT3JFuKyUHPEGLmuFyPXhaEL9MFpqkBRVVn6c2wnyPHT/S1lPFJzIuXEkmcqhdM8UTAsxXFzes79aeYX/vyXZU1VYcnt+K+EqsiMWikCPmBaEs/vFsY54ags45Hj/Sh4P2uJ08x4dHT7jprS5vjPpHkmp7ImerwmL6pik9GkkTPggh7/VhN8WRz7IJ3EzhmqMRRjKVgJBJpK3zvighoqJNEQ4yxJ7uDFqKRobeuMiBd6v85ZUq66DlA0obqfNbSsG6zCOC3fqeP0yz9Kw/afaBzhPH9QSpmtc0PdHPmrwadUfOfXoZ91luDtZhCwfdRbDNC5py/lLOaSNU1WVyKARlXPz3+dk9d1sCBLq7qiqZuo2LZP7boiaeLCuSfQrLjgM79S0PxNdGxilNG90243rMO/Nqd3itg2odPUslsxufO8SBZaBbklRu7vjtzd3PKln/tZ+i5oX7KRvcoqvpWVHJEUAX57c09MkcNhj7GWm5s7jDH0GN2Ib7DLFWJMPLraq8gnA/X2OJpYu3XnbhG9pZY33jt5XNsBzXbNvKI+tU/VULVb0axYuPWh1fOAKGvPl6Ckz92LzaKRsxpJqiQZ5nl6P7/66J/++3r8f9q3m/vTh0tMC9S+yX65GFyLsJq6Gjaw2qVbpR+31oaRzXJtLhmsiPLNvCdveqSqmEeqrJ6RAIRyFvRKhRzli177gGOEJVKzw4ReDW5Z9jUVYYUXQ02FYhLF6rQlF9IotRcpRmqwON9je8cyjZR4EvF+cLrWlQRCLJKMc4O+8SlC9IK8TJXTy+fcfvAd7m+uOU13ZHOD84m+dwy95+AG3OsP2T96m7D7PMPhEbhF3GpsNlHUc4K5GsiFyex5fXvk9sVLXr28J4Yj3f7AoTekqeCcbmYFCQTdJeX6muV4JCX0HGZxJuB80D2Mpi6q1GQEb7HBiJiaHW7YCbKzAkm+Byt0qFIEBx2CIQyGHC0pBzCFnCLzPFJKpPM91hicEWKBDygRQEydRtPhFSfnCSPmz3aGaYaOUivf+v6r97/5vZf/7LPR/Kdzu7+//07OZfbeDG1I34bl24H9FhXXzD8PcY5m/fdm6LAbQ1HJ5QGizqxJe0Fd7nd76QWcZwC6Lqy1GDc31xyP95J4y1n6AXVg34gFMUaSJkia6aQgAtdxPGGt47Dfc9jvGMeJ++ORamA3DHIo6nHSEjUyVI+Mp1Eep7FE7/nO+9/h//3f/Xc/8Dr+yr/9Lr/yb/9b/uf/0Z/ny3/hL/GzX/kq1tgVc5qzzNnOokSllKSdezO3t3d8+OGHXF9f8/3vf5/f+q3f4tvf/hb/2f/qP+Py6ooXL55Lj7hzzMuyYjdPp5MY5+aZaZql0qgW9vv9+hp3IUgKr547DjEVl2VumZyIpSmlFU/YkI+1VvrQ0/c7MFb2TsA0jtze3ZKT4AK70JFrwRovra9JxJsz3lPXUWrybMuxlM/oV/08fvDixYv/z2dH5qdze/78+bdijMswDP22j0/mepIQa6JaOw+07zFvdDhuBcDzer4+SINt08R2k+J9UzBsItm2d28rOjXBuwl17bG1v6+m3U2/YMNkyvnljNZs+4xlWVbUZROktqJYSonb21uWRQTzn/7pn+by8lK3UfOaLv4n/+SfcDgc+Ct/5a+sj6NhdLuu4+Li4oEo2FKIh8OBr33ta/zDf/gPiTHyla98hXfeeYdlWbi/v6fv+9WI3V63Fy9e0Pc9jx8/puu6tTN0K7y+KQBuk5jtvZrnmbu7O/q+X4W7w+GwioQP9mKbXsVthcMW53nud68PBMuW9t32JbbHEGPk9evX3/7617/+E3P99805uTkklJO92SgrU79udhx6KT23ibWQoJH/Y5V3V3JdL6RWKU/zvLDzXtl/ajJr3Q61YoqgJQ2CSfQY+qGn65wMpWMEr87bJEmVOVf2XpMAmoSyVHAyELJFhkq5GEkFiAIoQ7wlE2MheEfw4naLBsIQJIW2SJKvOHUDtsRBLeeieuE8UnJqERViS67ZmbwkcaYtWREVhjlGaqoQHD50VIoMtwGbRlzOApZUZAmbLpzpfqY46YxLpWCSDECWGJmPR+I044xh6L1urAupJN7/7od0O8+f+9J7gr/LiVQsY86kGYnW++bSE3TQ/f3IaYpEC9V77u5OXF/fM40zcc7svOXZ0wseX11gdh2ub51JGdMFERNjJBph8nfBY0rS7oYsA/ZqybHSd0ESe0vEVYMbelLKuFwFwWKMOKa8o3hLyVCKl0FggYAHL8MHawq4hLdGO3zk85lPM8ssQ0rrwBVJQWBhGqMstqyFbAUlZwRpmykkClOKzEs6D5SqlIR33tJ1UlB9XOTzUY3iXor+HiCWshlcGClF14ENxjCnSiwGY3xrr9F0k1v7JWRQdUZa2XXJUlfE03kA1uZY8pdQzgO0hx1/f9Jb/CO/ntNOtF7rsF4u2vOysHNe6jX0HLDeXxIB3maPZlpBTbXtQrEVOpqkV8gk3au3EuyiWpuxgnFr56tqEfyNkd+dl6w9D9LTkSlUZwVpW1snSBYB2FTt3lGzQ8kiNvqA0VRQRRC0gropOCwxTpJW0aSxsTLoK0nEPBs8JgjiIifp4jIqPLUuqy5YLi92vPjwBZ23PL7oCA7IiZoiOUeIsjgoKTKPE9+7e0l8CeEZDINoQAmYXp148fqa3aFnf9iRjcFXiyuVXLauoso8J97//g3TdBSM2GlivLvl1e2JOSceXRxIxTGWxN4/orMW03dMp8zbl2ICKEgfrHGCW7YmS/dfyup2dJrKbAMUOf90wa+faz0zyrk35TYBUiqgXNhjqpwJiRZnvOJjLDbI8V40eb4k6WyLpajgI+KfJADlM0vJWNsS6OBcYoyeZYo/ILn5y4EuyMf5uCQKaf1oN6l82+33ybq5oD+bHvhyFQmHjznuwp/gmIw/cJ8/qgPE7WOqpZ6g9mveebtgbyJgqdrZZ9d+K84zdRmm1aoZ4bpGiWuBHJPSQaVXKGc1peBXMxQ1klWkNtrp0ZyrrcTeKG6sDRmkq6jiTCHNi/RR2i16RM9p1eB8wHiHt5acFoxk/6XjqBRMTQRnuDrsefHhS7pgeXzoZNhdEiVGcl4gTtI3lhPzPPH8+pqYItbDcHGJcXtSMYy3J15+dMNu17Pb7+ipeCfXwVzSik3KuWyO/xM1J46nienujpvbE0uKPDocSHlmqpGdeySBiq5nHiNvX4gDo5hMTnUduNgqJqacMzkVQSZbpz2cMow0iEO6CQENfVpqleNfzUpCrpDusUXF0aomMGe8CMJGe6WdIZeFnCsxtX4/VXUM6zqg5LoKINY50pxIuTKepj/8ScP1/cgf/7WO1pihmabWjZsuf7IW3Bt7Tq5JF7OYO9A+urWzXIcH8vkw2kcnn61cJR1YVrwmq4ikzsdVPDTn5ZcIdq17bCP+6W6EukmXr6LUubTunGpeN75tyJFXQa3vA5eXF9zd3jEMHX3fSZJe8WWC15L+XmMNMSZZJ694pLiK8NfXNzy9vqHrO2CgVhUPV+xnwVhDTkWdvDfUKiZM52Vz3/ednCuDiBPOW2LK59cXuLrcy+/3QbsT9f3Ta64MLw0pZ6W7mAcO6arHI+2cyrnrDzWsymt07mORYX1RubiesaP1YYpQEsZ1ff9FdGz4qLP5tVQlCpTC8fb+9z/DdX7KHoCYxlJLL+s8EauboXdlPrShvpOdUC6emgvVybWnkVdMVrxjVTqKMRiTpTyuVmo01CnJ9d9IIg+bII+yODSI67VxhvV6Y7ym8ZojjUqtUdbwpVBTJlMpWkUiQmHSXjDZP9guUHPCmoypC97JvjJmmXl4N+B94P573+Py3WdY18ljWSa4uyPXkdNHLzhNI8fxntc3z/nN3/033J9g/xh+/hd+ji98/i1+7umBahzjaWS4eAu6XjsPl4+J2Uqn7nw7cf3RK07399yfRq5f3/C7z7/J8+vXfOVzb/G0yzx5euDwzhPIBvaPyCOU0y3LNFOsp2SPx1NdoGYocZJEVAZrJJFlq6y1TIkYHF3n1/4E09Z6WQgdVa/N1kkBRzU6d9Dj1nUeXy3BB5zzWN/jO0Nmln1HlXNSoWB9RymCUi66lxBRUmZhxUi/8te//eHv89ntU/YA5gkYHp7fG91ogwHVgfw64N9cQwTJ6Ylx0boN6aQONTDP8yqEtWtH8CLwVV1zNEzkVnxc+yIN9NrDZ60Y5lOMMv9zjpILt3e3zPOMc34VsErJTNOExTB0Hf0wrKag+5N06Vknc8SWDrq+vubly5crCaBSub+/Z55mcs5865vf+qGv5S/9+tf4pV//Gv+H/+K/IHQ9Lz96ybO3nxE0TWM33YoxRuZ5ZhxPfP3rX+d73/suL1+85Ou/97v80i/9EgD/x//yv+R/85//51w9esSrV6947733MMZwcThwfX3N3f09O00ancaTCqIyA14WTTLFRKkFHzyllhXZWQrsdnuc85t1ltEE5vIA6+e9oxQvgkBMmuKzGG9WA7dDUKWtr7EJR9ZYekWG1lKEurSxia3m71p5/fr17352RH66t2majpeXl33bN287+1oKr/UAbgW5rbCzxT1+nDC4Ff/e/P52X+2z1kSuN/GiLTG2LMuD9NhWSGvryyYKNkRoO9ZSSuvz2/acNgRlQ3y+8847a0qu/Wmf7RAC7733Hn3f8/M///P0fb8mFdvjasm5JsS381oT8bamivZ4/sE/+Af83u/93vq6hBDW79n2pTZc6uvXr/nwww8ZhgHn3Cretfdnm+J+43z/sSJgSwZvf3YYhh/oNNymPLfGkPbnTUFw+x6337f9+fb7l2X5ier/A/DiuBTHZDVNEX+4/VjRKkjaz1TpALS1oQdlOFuxikyseE0uTSlTTHPQV6oVlfV+SZSksdeGicpFyBbF6RDIMHSex5eD/FyRYvZqDakUUszkICnAXp21czkneow9o3TQPjFbhPnujLjaUnKY4AgWvDGUBBkZMKfeY5wlGCN9UNaADRRnWVISUbEKJ94Gjy0ZP3TiMtQBlJUSQ6ZxARxWHwc2cHHoJD0ImK4T3N40AwVvwe47jA3kcaH0DbEvHUUyXTDgArGAtwVKpcZEStLN0TlLrsos7jquLgf60LHcHRnvZy4vB1KpzHPBekfyC6lmQunIRRCgec6cTpFxKSwp8f53n/OtD15xe3cS3i+Fi+DxNdJ1HucCoUfFGO19RHoeqQZrPHHJVCNg1loFI4qD6iHZKhP0CgRDVQcuoSoOUoY7xRhqrpgs723D9OXTiaSJHix0vhOnH9B1nkndWeIAdaRpkTlisJRUsFaxtat7GKKojCu67bQsHCfZLHkj2NphsFxd7HFUpli4GmAXPGPv8LOIm9VqiqhIMqysnUNGP0eeUqQrsBqv6T9FJp6jKw8uYJVzn8t561bPIb9Gum2JNAmknl3Oz7byxB/z9sNEw6Ys6NeXJAmVtogy1pJS5D5GcooqACXIUXrnUEEwSyfg0HX0zhNzxnZgM2wvFxb93uIoZApn5v865JFs6YqCyZoQrang8YrfRfullPues4hVOjCTjbnBuqAPL2PUlWc6DyWvPWPGCZ/GOHGy5iVjvcNjqU4vStYIambfU5zDhkDMWe8H6dezck51RqRQ72A39BzvR158/yXunadcHTzOSIm2yYkyTyzLxHGc+PAPX3Jq0s9LOHzli2h9In4fuLkeuXk0Muz37IeOzmW8O6cnjLXMU+SDD14ynm6Iy0icF/KcWJbIR6/e5/b0jHj9Ci4vuXzvMenU4/cDY4SrUHSoKshOg5V0Xk4UigzyswidpqD5WPm7q1YQyVaSm8Y6EVmMwdasqVjtRcuV7Cp5KaRxFsyXl7SpGFyKiOlOFjpRF1m9lw0DVYTJ1kEWxTeydgZWnfUsS6brPMdl4u4kMl7DdQ77gYvDHkdkniN959l3ntMucIwTcRIR9u7lD8d/sv36Jv3HD8iNf1Jh/nyM/1mIf/8uvyfnPOZcnjhn1vRNw7e1JKAsylde3hnn1tIBBZwOt3NLBGDwrbOrFcsgcdRcpSPWId1vtURJYHsR+FJKco6tRY7/XBTV01zF8pk1TvpNrbf4LOhJo4aokgrsoFiPDXKOMzWpiOAI3konmXGUmvX4D9wf4cX3X2LfecKjfcBVNUiUQl4WxRIdefHqmvGmYuhhb7l4+ng1RwXjub478eh+FIfzEAjerJ2JqCA6L4kPPnjBeH9DjoLyyHNkXmZe3t4STifi7R1c9Fy6p+Sxo+wHxgSXQd6PpAnMhhWqNSuet1Byxpq6pgHaoM8phhcVSo0VXLNVhnBt6Gzt5jPWkmIijct6/Hvf6fFfMUZSh6VkYhKxofNWN2L6dU3ap1xXBOH58wRLzNzfTf/qR+34+Hf5nT8O6cEcl3vv/RPTzD1rjKstflRQU2Pe2mFj7KYfUAU6NXbIZlVMhKacXd8S+qursatUMTq6VklQzdq/VxXhvd2kts160U3wOlDXz3FVMa6sG9x6Rrgr2rCsPaZ1PcdZa9SFu+d4PPHq1TXWWq6uDjpU9JRaGXYDBlhiWsXx4pxC1FiR6l3Xc3t3ZH+xxztJG3qvxgZjVvxtSpnj8UglETqvw4OzqJqSDl01FW2tJOdTkvSfiO5OhwJ2XYubteLBkHVw0O6z/bdUed3XPJ49dxKy6f1racmHXS6sHXGW8zVjm8CQzX9dxb32mrPpPlzxv/o9d9fX/+Yn6fj/cbjdHqdjjPlx6FgTtoWKq3Y9hlqSzOhi3lgnXYCo8bNkTDViurNZhJ8ixhFLwXq95qkBpRQD1eGNESRoHmXj1O0EC1oQNAYZs3MiDtYqKVcj9RXGGGqoSrEx2GKpxmrKzuBsJnQOfEfte6pRBGmtGCs96L0L2AIlTZjaEYJnPmbuPviQiycHXNhBnEiniXHJ3L1+xUcfveb9736T3/4Xv8HrF7I2WJ7B7n/2lwgXb7N/9I6c+3JmGmeG/rLFHbXrUHGd1oHxnJ5fc/v6yOvjyO39ifu7e55/9Ipf+e3f5sl3vs13H13w1bc6/sNf+DkGCu7RBYRLys2RtCxi4jReqhSsodQogmiJYoqoWVHFAUfBlQolYWzBuGYI0J83hlqlb9lah6syI0jZUlMiH0UIKX2P63qhAznwoccGeY1zGhUlDlVLJeVcoLQfK++TLbK3l9RZ5TRFfuP33v/XfHb7VG8xxiPwuJ27V+OdF4NeS4CYdc74cJhfSsEUmWtaa6k5U2pmmWdBeJes/fRy/ykmDEaxmpJUnaZJEPQqjC3LstKVDhcXdF1ce/OctUwqEu52O6LiREHoJEGTNiUnLi8vMZeXOO/ISSotgvcMveBqD4eDpokqu/2O169e8+rVK4wxPHr0aL3feZ65P95zc3vzJzr339/d8fr167XfbJqmVeSIMXJ3d8ev//q/4jd/8zf51//61/nv//t//gP39ff/m/+GX/xrf42f/ZmfwXvHkydPKbXy/PlzGdLvdlgrGNSWZKq6/qrlnJCqgVV0bQlOSRIGri4v6Pp+xaC32ZYkLpdVIGliaK2VvuvX8In3sj7K08T9/f2KWKy1qkDT0fDwzUBYN4nIJvq8fPnyNz47Ij9lA9A8j28mtdp71/CQrbuuCUQtofemmPfgHPIG7nN7v9t/3yYBt0jRbTdgE662wmT7bO33+wd9dk3Mb5/7rXi1Ghz037bY4/Zc2/F/cXGxJgebCNpegy984Qu8++67vPfeeysGuQl2pRTefvvtVRDb7/erALhFYrbnfn9/zz/+x/+Y4/HIe++9x83NDc45Li4u1vfgzW7DlBJf//rXH6Qpt12q246+lgJcqRybbscmjAKbc+H5NWqJ4Y8TLdv/b7+rJRy3n4P2+JogukW9bq8p7TF95zvf+Ym6/vt2ORBBb+u6FQHEmLPMYLcFPK3TQvEq2gqHNTKAr0bQd3OWTaSwoWUQuR96xmlmjElELCP4mVhEeAlGHJcd0q9GyZiSWWb5d28tsSS9ijlyrZSUqEXcr7qXJClr33vpXiu5kIHOq9hpHC5XqpXFRIlZMZLoRT9RTWDYO2rMkCtJ8Z7WO9KUsNbQ7RwlCfM+JXDeSOKPLKiQUrBBMIXBW8WmWmq29AePz4Ifi8sMOdMFx1QcJoP3Fr8PpJLxtrIshRwj1TkqkjIz2cpAXd1IUpZrOARHFxzDYcfhck/XObquh2J4/tEtpg9c9JYSC0GTNTkaFj9hq6VqiuC4RE7LzPX1iQ+/f8NxHHFeBD5vPKFzgkqLGapgDWvQgb2zIuwadU9byNXgFZlUMNIHOUdymRl2e4LzggOrsOSE6wIWEX198Djl9RgsrutIaRFMIoW4zCIk9TtNMAgq1nn5zFZjKVbSDjVlSJkFo05xK0kEydyJCK0uwDYsizGTkvShyFDWswuei2Hg7atHBF+5GyeeXhy47BzLlDgeI1NOZGSBV6s89jZsqUa7LXVwhIJr5bvUKY2g4LaLt9q6WtCk4WYwsgnAiPinT6KZ2M0fKRj8kNuzHyL6vfG1GRFQ12Gq9ex3O8ZxZJ6zpv+89MwkKEQCgeSgQxJ83slHizfEv/VC0Jzy+ifRSJsi4OWUMR7pBEH6aLZOcRkKelB0aFoiphaScwQs1RislT5KZxwmO02wZkJwhP0gQ+ncEDoqahlL6APVJRHxa1bhGR1IO0LvWIp8RimZlGRTMuyl9NsacTJTC5bCxS6QH1/x0Ue3fP/5C3j2mLce7QSHi8X7jrxEbv5Qmt6ePoNueIbbD1w+ecq8JMY50e0Hnjy9YhpnjvcngtXPl1VR2gjO9Hvffcn16+f03nE6LiyLDENu7u74Q1WnPNA/e8mji19g/yiTrGUeF9557HEN56nph4rENEsVddsFBzky3U/UGun6XlMJYEo6n0NUm6nnq78sFioUW3Cx4foydRGBEe1Nlb4RQzVWOyglSyhASc2FahCZ9vnI594g9DM0LondlSeOiThJUm/gGftBhJl3r67wNnM3z7x1seeicyxj4n4cYJo+8Sh7gP98+cmH3Ms/keD38eLfj+MAsZRyWgd/pT6wPkg4THvx9NyaUjv+ZfjXnGmlgvPn/mBJBWRKtdoLJ8dmakJ8tpLcsRZLJsesQzEwRfDfIXj8rltT+kZdBg3j57tAdVaPf/28I65U3znCMBD1+DdRcGDBO+quF6HKWj3+K85UDoOnPLrgo9e3fPjhK8yzK55e7RShK4SAtCzc3kyke8vjdy/pdh2+67h4csWUMqc50Q87nj55xDQtHI8jwVlKrsw0F5wjF8P3v/eCm9fP6bzndJROjRIn7k4nXs8n6mzxryPD1RWnw579VSEay3yaeftJEEOXU6yhgWpbis9ol7Gj5sh0HKkl0w+ySK86tLXe6fFvN8d/Xc04uch9lhQhV3lfFkGNC55UkvLGi+Cbsjg3Wy7LII+llkJTSQT/ezb8yM9lpjnG+frm//rjNGyvP6b3/aYBgDa8a2Vw5izkrUigKk6ylBPe+LX/uGidl1Xhp9as4lzzVNXz+aSe+/KssULDQHBx0htYV5Ok3XSHFB1CtuhfQ4mKjtYSQaxDQ9M2oLQBt13pKWgarQ2ijCbUjKn44Hn8+Irr1zfc3d7L+cd7jJEe4bbm8QWKK8Qq+59Sqg7gjlTg4vKS3W5gmmaGvjs/FyPmharnzdevbwihcHV1ide+JNlYy2Z+maMgtlFMma7zUkw8efKWfi8risJpQko6562Y8bR7UQQ7HvSxNHGwCaMrzb60/akIiMaYDdpzYw6o5+9t99fSm7mc0yStT7I0LGGpaiosa5drziW9fv/9v/fZ8f/p3u6O432KYuQqtUiqthSKsxjt2a5FENGEsBqYa21JoUrNVdEfrKJOjULWMNVSXcCoYawYI117Ucw3xnVy3c9R14kWlgjTJIvGyw5TDHXJIqAloCQxAIdANVn2mjhNm8oH0IZAcIFqLKlGcpwpy4wxlW4XKLXQeYMzgh6tywnre4bdwPHmntvn1xwOQUSMVIlzZJkjdzev+YNvfMDdC/jSf/wXefen3mL/6BF//ue/wltvPeLtZ28x7Hr6/YG0RFgy9J4zjgkwAeg4vXjN8++95nSaef97t9webzldP+cPPvwuv/3Rd7GvPqLcvyB8/ku88+gpl5/7HPvdgXgqEBdNRcvayPm8dp7masAErA+UMktvcUkcLnp2u73QiZaTVIlYeWxFzZDWIEnBLCnf7CsmJWwqmBypp0XW98HLNdxaXAjgHDkmwApqPBtkZis96OK01b1GqdobL3UQOUVe3hzTP/nXX/t7fHb7VG/Lsty3AW8b7rZu2+3g/eMQcivaLZ/730qtmOWM3ZP7dOu1u2RNoQE+ePqhF/zkLF1zOeU1RTbsdjx+dMGyLIzjiFNTUc5JTGtq3PE+rGvL84C6k74wFQziIt1XXd/z7NkzNep0Oh9tnYPyPff396SU1qG4JI8iu93uE1/Hv/aLv8g7777L5eUFV1dXPH78mHEcV0GhmZmcF5JJSpFvfOMP+Jf/8l/y4vnzjxX/2u3977zPkydPKEW6uV6+fMk4nui6fk1FtnXDKrKoYEo2vHz5gpQSl1dXDH2PsUZRogPeWfp+0H7QlsjP2tee1K9gJHW5LEzTKIKjppvWLreUdI3IKhi2dYhZMeLn9cA25aUCTPrGN77x9z87Ij/d2ziOxzcFsnZctwTgNE3s9/sfSH5tO+m2SbCPE962Ytv237ZEinaOaeeOTxIBjTGM47gK302ob8JhMxHM87wm2Rr2s93nNsnY/kzTRNd1vH79mpzzisNsIlzrq3zvvfeotXI4HNbuuyaWOed49uzZ2lUYWg+qCpRbAW1ZFn7nd36HR48esdvtVtGy6zoOh8OKL53nef3dALe3t7z//vtrh2oT/t5M/m3TflsBsL02p9OJ4/HIOI4Pknqt5y9qf+o5CewfiPvOufX5dV234p3fFHq3ycWtuNvuV7sX06/+6q/+X37yBMBaVBngAeqzrjhBs+JuKtLBsvYBqmPSVo+x5010c+ktOUuCSopVZOhSLIfgWZxhLrJIRJnsMVUwUUQLLweJNZmcFu7mSYZsij+MqRBzJi+JpbPE5PBGYvPFQEkVF9qgQIe7vVuLwKtFhmzZ6pBYHnOaE8Y75vnIxUVPxlCsbAzjMjHsBpZ5Ji0z+8MBXMC6KgN+IhRPmmdc58F7yjzjgsH34hSsxYA3DH3PkhMlTgTjwWaKibIxsAN5mqlZMD5m0YSDB5KSSJdCnGcRKIykBQzgfWDoe0oxDE8uubw6sOs6vDX0B8/xbuFuzCzTQuoctkivIbnibMC4KomcCtM8My2Jlx/dkGPmyZOB43SkJOleccCuC/jglbeoggzgQktCiOsqW+0JcLIgIEZBNnYDuSzUeYGhEoIjLomSolQt1Iq30tlQSxQnJ5IwnbN8rrCQpszh8hEndSzjPNQkyc5qpXMpS1chWTb4xRtC18uCokAuZpOok6GxNZVcKjknlhw5HmdJ6ek8uO8Dvg+adPA8vbjAeyPDSX2ssqEopJpp2RSrPVOyCHHauSRphLXHRQdBIrg3adJou1xDF7Yk7nkRVyir+7kx5KUbpayDlo8V8P5ENxUWnn2ysHEZoxz/yPtkEcf9oQssAabTjEh2EIksEQ4Iso4FkkbXP1700CRUhpITtXSyaZO3XfpdvPSC5iRavHUWo5ggqgwPpOMDdecWJfskWKx09IUBYwLVyCChlgw5YnKmWDDOrx2otWSIiiNBTAcl5QfuwELBdnIhKlnyiTmqcJ7kQyVuegTB5cBXSyqF3lsOfSC8fcX1zZHnL68hFy53PdZAMZZwccmjr3yR3Wni0dNLDo8u8X2HGw7cHifsaeHpkyv2ux21FpZZnHPeafdVEUH0/n7kflzovPb1jYl5SVzf3fHiTj40X3wmp6TdO1+kv7qErufm9sQ7jzoR6ZyVU9Yyg3MY5xE6quKjrYUSsFZdRNbiul4Ez+g3x2KhVkldWR0GL1EQm8VYypLosIJXVhqTkp40+akCTS069LWUkhT1285Y8jXawkS7VVOEaZGelBTh/ngSjGdDq+4Hui4QyXSh463Q4SQURkHOkSApzJc/7HB6+VBhf6bA0Jc/VPALfHwiMH7M///hQuCP6rCwpHzTZshKyzu7zUxz+JY1BeiDpMJyrnjTFuYFr+htuyZzytqdaox0AqMpkKwL4RoXPf4dlSxYsZKley8nsjUEt5MhVzMiJEnjGwxFCQeVKqgqHQDaIEP7mqW/NmufcM1pPf6NQzDZVtKLphT6YMlDwL31mOube56/uIGc9fi3VOMJhwuu3s7s9ieu3nrExdUFbujxw8DN/YwbF548fsR+L2ieeZq5tyqSqAHKWK+9v2JIqLkS58w8Z27ub3hxc8Noe57hcLuO/vEl3dUl9AO3dyPvPOolNa/Hf14WEVK9Fwx7EQlOUMgBayKxSuLXdiKo2qjfsx7/IpA4I49ziUnzwoayFALy3jpfMW6b5jLnRBWKBjTy3lRjOTOoz87fnPU9VJFinhPHcXqfZf7Vn9QB/4/q8V9zGbeonqYEG7vBZq6JsDNRoRRBe5830WzQwLKm814E+VKKIHzN2WUlPZCsidj1s1TPDqt2f+fuGPMgQc8WWanf39LJrauuanowZ0m8Uc8Yd6PpZmsMIXhFzA9YA8fjiZubu3UDG0LQui4Vv72XXpwYcYraNFa6Rq8uDvSDdJalJNUBQU0LVQW28TQxTyP7/QHnBbNlreydvA9ybVUMbynSpZ5TJqWF99690jWWDNjEEFpXIa7tHW3DNZu6JjnboESEVEni2vbzm8LE1incPKpGhb/W7Vl13dsGkGzOBTmLISHlsxjbrh9m07Nd5DRAKYXxNH6QX1//q88Evk/3dpqmMZeESSpOUzGmkCv4qoj5yjoUtk1M55wstyrGG2ewXgkcRRJ3tVrZNHgvJBILMUXq6YQ/7XCP9uB30gMYJZ1Wp0kEud6Av5S9dxkpcaZmJFVs22ZY0b9WBLBioBoR/kgFU6JsUOaJmiLWOXovyGBPkt5a5PtqrDgC+93A/d2Rm/nIEMBTKXMC07N7+hZf/Av/Ie+8+4qf/coX+PwXnvHW59/l3Z9+j4vLS7xxDLudGGtjJi8TznaaVEQWz8Wx3N3J0Lxkbm+OfPT8jte3R37/27/Bb/zB13luPsf/1PaYy57up77AxU99Aff0GdPkCK4wLbMurSvkmWotuXqKUdpGrnjncXbA2EjNR6r10A+6jzKy1zeVarLOmaSOxRhDzJnFQDYGtxR8MRjfUbuK9VVeb8QMbWl7sgRezMmULO5SU7XvV5xjtlb5Ws1YE8BCXBJ/8MHLD77/0c2vfzaS//QFwDOamQ2muvID/74ZJq8pDs7XFRmCO72PUYbW3q2D4ZaCmSdBTE7TxKNHj3DOMk5RiTGsw/bdbkff92vqpQ2u52nGermWp5h02N3Q+oLPbsn1nLKY4LPsgXe7HRcXFzI3U/y0904Qo86v16tpmlg0XTgMA9YaHj9+zC/+4n/CP/2nvwLAV7/6C/zlv/yXeefdd/jC5z9P1/Xc399xdXW14v5ubm4epJOC9/TDwO2tYEuvrh5xd3fH4QDH4w++P5977x2ePnvGe+++y8XFBe+//z7Pnz9nv9ux31/I+nmaiErbsIouLbXQuUAIkgAax5HHjx9zOBzWdJ9zssirFDF5NiKd1SRmXCTMcaor6rz1A7bEoaDRI/M8EZeo64u8YiPF4JUF96nmPxEKz0JCzpnb29tvX19f/6vPjshPXwDcijJvmINXAXBZlhWpue2Ye7PTb9sBuMVPblNjb4qNb2JDW4KvnS+2QuA2hdg+P+0xTtP0QEDciozbBGMTrbZJxvY9p9NpfQz7/f7B72miVevaa/fXhLiW3BuGYUPPKD/Qj9cScQCXl5crRrT92e12q6i5bGa0xhg+/PBDvva1r63Pbdv5tz3HblN/W0GudX1KSGRmmiZOp9MqzDUT4psp73Yebl/fYj/ba7ntG2/ni+1npaX92mvSfkaNEt/+gz/4g1/7iRIAq9m4KptYoPgnkSdsq71YOxfWtbWpqw9fxD9taVqTSRBTYUlV8TmVXCDGGW8sQ98RR0mPeWcIiECyJMhETDAs84IjUGykM5ZgBe9pFRGVayQWQ66Bok4uIztTrJFUSE55dQXa4rDBbkQY7fcrC8Z4rHEsdSbenjApcwodPJJS6FoFUZpTYpkTnXOUvFCyxVfF0GhfTDHAMpOzbDxC74V7byuhc1TnfKpWjgABAABJREFUAYuNFU+QbirvCKZnSQVfpRswxUhOis9JmWAdJkCKRXQLZ5hnGUxbaygOrLf0uw7jPVeHCy77jr739LuOUiy5h/0eqnPEOdHgVwCOLAkJLDEXxnEmLtJh0PWeUj1PLi9Y5omaCiFYdt6x3+8IQ4ftziY6STupsOwMwYkDMyvXUoZ6sgbf9YGhuyT0csILQ6DGcg6zeSP9iCnTdYJLSMr6lwcfKHVhSZXqjPBSTcXgsLWQcqYkSWZgoAQRAJzRkGaCFLNsVsQCLu+XCkVZB9DLnDgqpiU4cXhJd5FhnCauhgsuD71w5otgSJ2zFFOJpVCqEeSpPTvZvSKUaOgn7dI06vrGWk37bcdXZ1a12QyWGpoKzCo8YAxudV6ZN0ZS/y63+MOFQYRosywirjr91xgnPJZ+6FhGTxrB+0ifIDMxRTSpJ6z4siR5H7JXcVOPZWSf5lzCMpBiJvgMxdEqTO12WCK0mTVRZjTxlkvBKjIWHWQt04xjxlC48EAIKg5lbBWkiPSISL+XMdKbKW+riLZpnmUgUMT57n3ABodFxD3BFEkRojdAP+ggMGl9oIhe1sh5NThLtoXeS9rv6lKSlK9vblmmjr3vSMCw2/HkyRXlsOfq6sDu8gLT91RviQUOu4HDrscFC9USUyIthezEYVsrpDjju8AuWDIOUqbfeVJO5DvYA1/54jOugKcBnr37Nm7Y8/rmyDtPdvTOSsrJB4xtdEVL9QGTC5FEjhHnAl3o4LCjyx3OixuzVkv1tDCsLkjSOuStFJlTqMhtC6R6xgX74KRvJQtmEJ1t1CIpzYb6yUWvJbms7kBBRpXz9ZBCnLN0SCyJuzgBLxmenT/vFs90nHnUd1wcOpacV5dqOw4/qfvv2Sf+o/zEs2fb/r9POgbDQ1H8gdgXfqQGiH/S31lKmXNRPDjrtFdpnVXTPTxYiIuwpGmQci7xLqXiqmIljRW0d86U4oSAUKsMluaZOM/S3uWALkheNCfBnefamr1I8yJDR8XbiRJYidNE1lodb62I+t7LYNvJ78+aXHTGyGZUUyqlVGouOvwWg0cXJGmUncEEw+PLHcdx5vXNkTgt7IMnFdjtDjx5lKm7gcvHlwwXO+wwUKxjzobDbmC/61T8EAxmnCE7owaASkozwQd2wZGrDMuG3pITpNHTd1f8tPc8LpVHwfH2e89ww45X13e8+3RH5xq2UI9/K68WzoOpch5ZIsbLRme42NPnHust1nnFAGmaSkWHrNP4JuVZB6kUbHXYIoKOsQ5CJfROBo1F6BCUKkm/mjFW2lWrJu5bR+yKjCna26QJrFIFqTiOy+991v/36f/OnNJ1E4+sDn/FiFNWIaiUKn6vWihFEZZms5nXdGC77jehp2gCzap5LueiJgERnox+bu0biKCWmKsICaMJjA/oAircaQvdir5cP2O6/jXbJOGKMm5F9pwFqiyI7hIcFOnsm5fEOE4477k4QF4pKGbFJDsn3TdWBwFvvfWE3dCvw7WiqViMUQRXISURK2RTbfHO452Tni5r6YIkhJ2r5CQ/sywL8zTy9rNLgiLfW2rS2obZbe+/Wa+vDQVasrwXstYVsoykBNwZx13q2vUIqIlOcN0rupUz/rkNZrfXgDUlqKbXlvhT9V+P+UpKRQePIizd3979zmf9f5/+7e443+Va8XKiVguH9HXaqiJ6qeQkw3bnJeYnx4DsB5pvwFRDzYrqdkYS4zlB6YQSVCpLitzc38meoGT27ilu6KDrqVPCTIU6R7nvDMwLVEeNQHaSSqxQ50Q1kiA1pWK8lJmbWsWgWiumZlzrvHUiPFVjMMXq+a5iXdJuw4hJkRpnvAnsB8fd3cLdEvE5E8cZGytPnzzj5764wNWez7/3jHc/9xZX7z3l4upAv+sxuYoQlg2mVtKknXsePTlmUpxw1hIcBAO9WbgcFm6uI3cvHnN5+Cq/2A/89Hjiz1084j/4S3+BJ1/8PLkGBm9JcSTFiHEeazzFZSXROGo1lLxQ5xnre0LouHp8SY49rnc460Uc7S5kjqMzjSrRQe1cNjpnEJqSSxVrHCUIAcoOFtNLyo+cKNNMcRmQxHLVOppiEFNgUZQkFlMy5KyvvawVpjnxO9/6/tc+Oxr/TATAU61VO/TcOmhuaZVtKmeL6Vuv/aYZPtvewNB3neA8l0UMAsbig8dgGE8jd3e33Nxcr0P5y6tLahXUZqsRad3U8zyvguCaxCmJ032EelznM9JxLwGKlBLe+TVR45xjtztQ6wlQLLauIQTNHSi+rDi/lCIp2XVAfnt7uwoS7777Hn/tF/8aXd/xcz/3Zb7whS/w9tvPNKGn6xsrCThJ70yMp9M6a5M+7lt2ux3GGJ48fUKMkf/Ff/q/5B/+t//PB+/Nn//qV7DG8eUv/SxPnjzhW9/6Fnd3d1xeXhJCYLffSSKnNnNOwG0Em2Zcevfdd9cUV9cFSqkMXc8So+wjnNefLyvSb9EOvxijnGuQ9cqwG+i7Hu890zTJ65KSfL+iEHPJqyiQUyYui/SENgNUfYh1TylxfX39Wf/nn5EA2ASbN9Ni7b1p4toWLbkVe7Zi1Bbz+KaQtD1vfNy/b78u+Nl5PS81hOThcGC3263HW8MGN1FL5qLS59c+g9v7efvtt3n06NF6XmjPp2E2U0qM47iKkDtF7DbE5mqO3ohb7f+3FFxLMK84XXiQPIwxYq2cXxo2s/2Ot95660FacvscP/zwQ95///01mddEu7a3iTE+SGK2n98KiC1N3VKF7edbMrD9vaUK38R1NsFv2/m37fJ7831t//5xnY7t9TydTjx//vwn7vj3pkpnzcrDaRN2Ux8kAY1uxpqgwAP/a1FBR8lsVqRAaypLtkxLJpVK0NF9jgvOB7wz7HZ7ME4wndbglshSIfQdu8GTS+Q0FZxPkIMkr/S32gI5VpKXTXOqhVgMNUaCFWxHrYWMDPeMDo9KlE1EGIIOAQvLbBl8xgXLMs5cf3RDPEamceEdMpePLinGy8K5LOyCJ/RBCn+niYRyR5Wtn5cF5wzeZsFjlooNXrrQSsEQZfVpiyJLK37nscmy3B2FZx9lsULNWHSzvSR5/AlsLXgDGUPMM+OciFWecxc8rjMM3tFZT+g6+mFHcWD2gTxHliQ4y7kgWE0DyUKd1WRdoVpP8InHTy+xtUre5JkjlUuOr24xZHaHHd3QEazB5krNkeGJbKi8AR8sMclVtaSMt5ZEFd99RUQGW5mmvKIBahZl0OSiuJ4MtsNYRBC1hs4YqnHEKmkM5wWDQBjE2Bccy/3Ikhb5LBjpWhInhST8qqYRc1UBtYibdFY0CFW+lrO0js0xsSwFUw0Xu0DvnDyOVAidZR/kz+QtJjuGfsLbE7lIH6Zyc9dcg0FP0lYWfbWByapVDG/rsbFr2paqf6v65XruB1wXcVU2Lq3XYqOAnDF2bYzycUjPP1Ya8GMSRS+BZ1HvdmLS/XEuWcS4kkkqigZn9eK1aPoM3CzYUN8Hhp2nFO0IdGcBxAKFQCFikU4+q52Bgs3LOtxuz1+c9WI8FbxH0H6/NQlYC6ak9QJ7ur4mjzO88zaus+yvLuQzpMKOw+JCJ5mSZWk6leCIm208Z4pD06sW67WfsBSWaaEfDkivmZPP4lLwpZOOvFIxqYiO7eRYt4A3hcGBTYXQWwbbMS6CJ51ZRDgt0AOu8/ShY3/osV3HlOHq0tKtKnJiSQVyZplb55glxiRReixDB5me0BeGTmoS7c8+pfAUv0TsdMeTdz9PDh2naebpo559L45lrwhOIS8JThEDxjtstuSlUGvGmkLfexFoNTVASw6vpn9zlnPNGd/pMSKkmILzllwUrxoC3lliiuRllj4RH6ia1KgUkl6zqoq2Watoa85i2tYOtiUnTuOM7+DuPhKjdP9dDeDDQAewJHzn2XWw7zymeGyB3W7BBTlKfmj6TxmfLzfH0QM06B95HH6c0Bf+GGL9j/6QMqd028wLLQbY0h1OPyMyuJfBtXMO78TZbYzV7g+zdjuVlHHerIPnSl07iEGMIKebW/I4Up89wwXL7uoC45xcl3MWFJXvJCUe47oWagteSpHhokVL7DV5aM7iYNfvdQjv5LwfLb6r1Gkk54LJBVt0CKXGJm9hsJJkC4Ohs4FxNixZzq/WGGwp9Nbi+o7ee/b7HbaX4//RxUDnrArciZiSpPsWERdwlmWR498bSx+gmA5vC70XpKa1TyThHyN+HHn0zjOK7xjnhSdXHbvOYZGBrW0RXk36VANWj/+KpKmtCfS9p2QVS9r5WBGJLbHbutTkFFBW8wxYiinYIIl9Exz4gLeGOEXpdLEW48LqTjJVeh5ra7euZe37kjWAYgiNIabMaYwcb+//xU/KgL/+eB3/J3R9topAumZqHXvWinCNF/HO6N+zorixDxOE1mwfvCBeg/EPC5XN9pseOoC3XczmweCgrucCQRA3nGUR5/umv7SJ221fVXJWBHw9n+e0S0zEdLd2BDljKNXT92puK4V5ifR9hzF5FbeqOlm7riPGxONHl+vmuG28Y1zW5KH8jBgOfRewKt43UdRaI9/LuSMwxcTrVzekHHl0tRdMv6atzWavKJ1+7kH3obHy2ldj8d4p5vO89zSaym4DBOekO7BsEF1tyWA2iNgm7lPPnSbNLJdVrC2NfLNxda//TktfSh90yoWbj17988+O/0//dprnY9F9kWkGO+P0MwDWigCYcsHEQqkJY5xscypYslJV1BCyJExbV7cqiJipLlJzYRwXXn7nA/L1a/jyz2N72L/9RKgsNlGJuja8AJsEB5oiaMpU9peVuoiJWboHUXQF1FQpaZZOwVJwNokh0Gyws7Vi1BhkXYG0iCEhV+xSMcnSd5ZkM3dLZMqZAviauaiFJwb8ruNxcFxdDgx9kDNYzpgqM4tSKzFlqvHESRKLRpH5VhGlNUeCNxz2lref9kzLwl/6j77MuET285Gr21f8/F/8Kj/z8z9H3+/ovYE0UeYRU4qci6weTc2s6pwmMBdKLNhgCIOnBO1IrlmNek6IHl5EQDEAse5jnbeE6vDFYbpKMUItqj7gd4P0B+ZEnCdyyrjhQhDsel4tijo2tqrhpyGZNTGqjzPlwvX9yK997Vu/+tk4/s9EAJy2AkAb5jfk3DYJ2ASiJpRZa9VAJgaTLaquCVNJr7tF1//TNPG9732fcTyxzJKw+yn7UyIQGis4TmvXTsD7+3vG06gJvkSMC3GJTOMoQlbfMwwDIXRKrlg4nU4Mw/D/Z+/fliVJsjNN7NOTmfk+RGRkJdAYACLsZg+fABf9Dv2IFI4MOaTMzQiFF3yAlml0E5TpGemZJqarD0ChCqiqrKyKjIyIvbe7mR6W8mItNbe9K6sAcAhkVSJdJDIi98HdzdxUTXX96//+vTCfYtrXHs32GKOIHsJswpyKZUNoHOfBztGehThNE69fv+b+/p7vffopv/s7v8PrTz7hZNEr0zRxuVw4ny9cLhfWdX32XCGEZ+jAV/ev9nP5z//5P+fP/uN/4vb+Hh8962Xl//Bf/pf83u/9Ho8PD6yXC6/u71mWhdPNjeL/QqCOXOaguX4DqVpb5fbuTnMRzxNNGufLhd6EUou59Ka92SdOUTGu5pzEdaaUdvLCcOzc3NxovMvqWC8rOJiniZQmughbzvu6y3ln0afXdcLAth5RhT/72c/+h+9G4zciAD6+dP4dRZyBoBzX9p63eciYeymIjev9KD4d1/fje0cn8fjeMZtvCP4xRnPh6vV9Op32NfbI5zvm0Xnv+fnPf76LhqfTiZ/85CcAvHr16pnAOV73KO4NBOa2bdRa99c+Ou6Owt6YH45i5HAEjrlyHNfx/x8fH5+9h5QSNzc3v5STt20b79+/58OHD/sxjflkNGYc3/vI9RvjaxzfOL8j+28IpjFqs8Q4tuHWG+fypcPzKA4ef+alu/OIdT1+rsNJPFzE67rygx/84N986wTAffc08iYsGH0X+NwLiI27dkmOjvfuHBU/JDDdRKGYh9o65yoUEZKd8Fw7UBRVeRdZbiZKXriVylYEUlS7e4etZPKa2c6NRiVvm3aEasoTuTZOoh0j22VFQuL+dqHXhk8B58U6WgKuNUKMbE8XUnS4OWk3GkKk46PnactcLloAa+FiWBlF6USqduY5oUohSCD6AHSq04J/zysueO0mmSIhBSJRdxtWbKAJrVT8dCItM5I0i6D3yrZdSMkj4qEXpHV1C9ZKswDxMIxvEVJ2iO9wSsQK50thK40inRQjaYlMdxPRjtXj1TJvSE1vPO0aAtLYHYF4SDExB0UJ3QZHy53kPXc5A54PHvKamU4LpxTVhVEa93cLt7My8Jzr+llY95+SfoTgItIr8xSI04zvEFKiSSWkwPp4oQftNMZ5Ap6WN3zSAPZSMs1BTEnRf7OnNA1Z9kFzhRBoXrSbUCDM2n21Z+Y5UaeReMOLqiip5BbLkjRBUCzLciuN3qw7OiSWRZ1Yt8uJGDVroIVIMuE8WeGkNNHOVXcoLDlH9KOwZfkjTotXOC2CdusaG46FHTE1ijXssTHXCJln+VjW1Lkjez2ue0tA6s+FuyE2/E1RoG/L1wuI+1MufLbCQ6tkgUQj+ECpetNNwXO6v+d0WyhbYZUbcgViIMYJj6IXny71a5/fm3N29CyYvkitzRbM2vTvY7Tuc2+arqIpbfWnfwma8VkrNReaNBXkgy7IGYW40RARsM1pUFdpq1dcaxdCSHTvlKfvFd8RkrMcyU0L0HnFRc240ym36AHgca5okXK8X1QEVLduY47qiIkp4IHioQwBrWVSgJAip7sFHyI+eKbgSaKOW3qlrCbDO+s2rGhGHkJ0HtcrU4wQNCKk1UQKE/e3J6ia0biW75GBU5y4u43czkmxvnaJSmuG+NIFlR+F0BDxyTqLkuaY1KrIU9crXRq1qAgYJm3USFOg1IaMMWj5III2jHRQZBGeGII6KUW7HOM8qTvdB3CCFLtXOUW9teafNbK46HEuqBtszVxy5fXtotenWfliWjid4PXNidvTTIyBkBaqC6QA0IgeAonCj3+l7vdrBcHPXv5M+t9wu/+bZQH+phUHu/QPWnA3d+ZePGbPKB5Croio4GPzOGEUcsKOMlcnTbCOdO2CNxsJpcjeGZuWSUXlapmAhljuTrRo5HX8+338qzDneifEoNmCMRB91Gsj6uyRDUUrZTV8uKP3gGOj98aoFY57RTdHkLfCVPCdZR//Dt+9UhCaZiE5aSTfCSmy3C346AnBMwfHlIKSukVdjt2Q0N5QaqVqM0NyDt+r3n8jzNEhUySlyN2N3ltT72y1kfGag3ubuJsjwV2zxMS66rGsLu+161BRvbpxD1HPTylWxLDzqeQGj5sTeEcKE7U0RXlL1Xk9BKQ7Xd/gkFIVCbaPf0UbxUnHfwhRxX+jQnSs8NmGEMihcBSohv9ccy71w8N/89tUaO9/T7/zd/2Q1j4MZ5ehE/aNhuYmY+tLmwuk050w5oxnEt4Q1kwsHxvkaJt1Z5mRo83QdxPf3bVAH8L4vX7N9LL12CAxeBOq9oKB8+a0u+6rwBoSRPa1nNsbUszd4tS1qgUMHccOc7tjG+DqLX9PyLnYJnksMfW+5pxjnrX7d5kXu9a7/bxXh+7Y6Aebq3onJa97qGB4JJttty1TqxJCPn54IE2B+1cn5lnH8shI1HNqm29bFzg72D7OofN77uI4L1fxUzOVdtl/YD2d13n4+uPs6Yo2Zzrnd+fg+Lz6YYx3uQqe4zMW60IaYuzAhdZS8oef/NV/920f/7+Jj8fz+l5w6uzdXaQBaHqPGbkTrUMRjeIISvfxwRF9VHSei3r/RMyRl3A+qTm4CbJu5K2yXTa6dObXJ6VktAZ5gzBb0bhprm1aNCuvbOCybiIsYxTncFNUl2E3GoEJ8iINWtb34B0uamNMF91za5S4kilcbxobQgdXrbEQnETCJtz6DqFx7p3NKWo8to1XsZLuAve/c09YkjZ0t0KrnkqhrhfyqoQiwoQPyZommq7/PbRpQQg417i9iUT/ijhNfPapsIjj3nVubiduP33Dzc0tyQN1o/e6C40iTdGpYvNhzbjJnI0xkXzQPVIMe4SMk2ZY1IJzk+7zfLAmXmi5IKXgw0L0iR4cPagA2KtmQLgYca4hdaXVAmHSuky0vXWzHNeg0TUiBbpos2kf+0Z9vVoqn7/9WP6Hf/+D//a7cvw3IgB8NUS74YKh80tOoCEAOsezInZwen0118zB1/fCMNOEtwL1KIx/+PCBt7/4BW/evCHGRGuyu9W8u5olYtSmgrKtXNaLOdK0yD6lWYk/JghEawLs1ryyrRtbztzf3RFT3LO8Fk66LjexPISgYvwLPOE0T89EiZTS7kT03nN7d8f9q3tef/KaeZmtIVobJpMJgI+Pj5wv550A4J1mK44i+8AFzstMmpIKlj5wf3evz2V5W69fv9ai+TzzOmitI1o2sRhmV0XYcI1CCVYXmWZOy0ljF5qQ80arjZwL7z+8p9bKp2/e4L1nWU4qyNdqSMDGzXLDzenGmhdU5E1JRcBWGlvOXLaVkwmwTYRaikaxmANqCDVHx5g6s8Ix46z84Ac/+L99Nxr//h9PT0/vjwLSS3FrCFBDADyKfUfH8DHH7/g8R2fhUQA84jeH4HQUkqZp2jG64zXned7xmaWUfU4Z/z+eZ/z+u3fvdgfg7e0tn3766bOcu6NIdRTIxnse7kdgFz+P1/HLfMBxzPM8c3Nzs6OPXzrojs89xMajQHjMRRwZfeu6PsvkO7orj+d24E/Xdd2PaYib4+/R4DG+NwTVgRAd72MI/uPnRvPH8fP/OvTrUQQ+XkfjeVNK+2d5Pp/Ztm374z/+4//rt04A7IduV3fsdLWNshw2t/uuzVBrfe+S7dfswJFrYUW1WhuPl8xWhHn2eGwD2wDfOd3OBD8TmgpPqapIELwoNq5NbGuhuRtqEyQ88O5xYyuZFKNu2J1uykvrLFYfza2qiBUSXToxqQOl1qq4/5N2+3olXtCc8HAuPD484ancvF64fz3x+pM3nJYEpSDeE6RpcP2U8F07UAieGBy1rer0CRN+CpZxFXSR6xWH2tV6hkedgkEsP0Sc2s76wGeqM6g43dQ2H2ynG4i3EWlC2UCkEFK0RU9kShOPl41cheXmRFy0E7I7R0ZIQd+Px+FCwLeK91UX58ERQ1LMoUOzAF3Fh0gME+EEKc70GClr5WaeiWCIAuXq3dzP3NwvBOeoXjMV6Vq4aHQITrGsrmvXY0p7ILqXRuyKSHv1yUQum+I3pWtzZYyWfFcV7+P1M2wOglOBI6NFP0Kg5IKzxV61AgS1UXNlup3IxStZtKtw0KURJCA4kmuU0jQ7BHUyrDVzWdWCHL0nBpjixJQSt0sE77XDCO2c7FJ3Xn01EYd+zdP03mu3umUBji27+v66ZWZeY096B5W+3SEvxe0FEnWS9cN4ddex6DThrDtHcPJc/Ps6JeLXuQB/3fc+e/5zbz+D310rpTTaHBTJCtQq4D03y0RgIpwqQSA2IQZPQPAB7tsM0vjJe+NlB8VQenSTZo2i1gVX8T7QRN3BIU4qplnInxawxHAg4JO6QYJlPbackVpxDu7evOF0mvUmf5rNlalu0Ogti9HyHF302pSQTdwOWmgTFDWSQkJ6wQPbdtFM0tpsHlUBquSKUZSJk8dJonu9Vpvl0zk8MUHrCeeFXrTAPkcVImJtOrb8iTRPhCngl6SYG1EXpE9eC5jicQvgK1HEsHuaaykiiv6JXp3TblLxcYIUI9FH8tOZLI0e4G6aWCZIXvDmtlRnVqVK3It1XaCXjc5MCA4/JVJMpGkGOslNRN/MnRQJXjGhvVTEecI0aS5iL3qcophYdXOZdmqpYNIM69dUKBCngv7Aszqv+WoaNnnwd8iuzSt6t2nuGQHWUtkuD/sAmIAl3jBNkbvTtDdN4Cd6y5o54pUStb79NUPlbzKW9sfXIT9foj4LX+/+K78kIP42FChbrR+GRue94p+fYY9tjVLM/dea4IOo294pLnfkzY21ikbH6vjXPg9Febaq9767N59wOk3M08x0WtSJZvei4LEs1qpXTlCxSErFOW8ZWZGOZ7JrXKTiHWzrSsBT+hAGOt7Qss4Q63EKFkHj6FvVfApr5IjRI12tDZLVFbikQOiKw+wCEj1hjoTkCYs2IkhvBBdVDPTOsmk1bzl2dneSoocbKer4d1ZI9whhmohxIrmV7elCEc0vu0uROXmSUyTqcAzp+bq6CnrvOp5RpCeTLuCnScX75CZi1fEfQkB8pZZCz83Gv+U7Fx3/Yu5IdQUZVtGpSNpbRqrmrvgYEOfMSdls/DttNvB2beDMSd92cRmnboAtV87n7Ue0+mfftuL+b8X4L+VhFGjgmh/nzAns/dVl1gXEC054hvvpYsANc9w5N/LEnNanh8jXr1hp6UNosp/teg+RJs82k7qR1DXZyLR75jo7/K3u05FTdz0Je6aRdH4V7mgInvjn6CLNM9cJUo/Pjsu6cHRTrw47xZQGc/HBPE+HDt1rHl4IunmuJSNdGyZG3qJUoRbNDVzXlftXN8SoDsUYw+5wHM+pBQXZBbyrw8/tOM8RqzjWqt72kn24dPto3jCE/yjMWBr2+IyduzosRdouyjYTdwe6uYllaVvBWOcTzY8rrdp6T3+uVuFyPv+wPz59/ztx7+//8eFpfd/3nM6oJJdu7lDLb6utaYOsA+kmhAVPNOd9CBoM7dE1mQsdpnjdXAnUbSVfMlN0/Bf/+/8dp5vIab5lvjvhQlDk5wCy0KCvun6cE/iOy1rT8CEQut+dqA6n2fWuqvuw6frbB8ElIAR6dXqPioKLQvAOVzrkrghLtJEU73HJWRNbpZfK5D3+pNm3mwMfX7G8mvAz+NevyCFQc8HLhRAKuEarmVqL7pWcNsy53mllo9eVGLT5DSYTVD2n2zum0xvupzM8PbEsET9N9NLol1WF1EUFzeChOK2VSPc0HL2Nfbs5pOeJKQRCTNcGg24+zxBotSK1wCqITLhlxkdHK1n3Ka2DaxAjLiQlPPWzrnNHtqcUdTLGiBq8r1mgYmsv7ztCxRny1dt9YuS9bmvmz3/y9i8+PJ7/03fl+L//x7qu70SEaZr2rLqj8He8x2qh3TFN7fk9uh/2C47dIRJ6pxnq7nw+8/D4gIjwT//pP+XNmze8fv2aN598ovdCu36980iX3ZESU2SaZ4ohSYcwkKLGW/igGXStNi7rZY/HCSEyLzN3d3fQO5d1JfVO8CeCGQuGa2fk7g6hQR39hcvlsjsaR47etm045/R56azrZXe1AVQjlsSoRose+i6U5Jz385lSIsTIlHQP45yj/k5lyxuPj484555liY3jHusuESFveXfrOZvDvW6gSDFyd3NLmlSsHUX+Zo6m2ipPT0/mulQUq/OKaB2ZX6fTidNpsfUQ5ixSkaCWam5NcwYa7WsIAIpXVQEhxbhTHUK4igugjqWHh4cfPT09fTf+v4HH+Xx+GGLN16Ech7g2XG3O4jSO4tDX/TkKTUdR6IjM9Hs+d3smGA885LIs+3x0FOVGFugQ30YO4MjSG6/56tUrLpeLXccnXr9+Ta163dda9zE1xtVRBBvPPf7+VRmHR4dkMWzuGK9DNBtuwDG/9N53YfF4vOPPwA2v67o3HuScn4mnR+znEDPH+Rnz1mzu6MmQzGO+G0LpOHfj3A/xccxnx/f18vhfir6/zgF4FH7H9TPO+cePH/nqq6/+6vPPP//Wjf/dU3rcoPbRUXvEgh53HC7o//rOFYLTd9RgP4oWIjxdMo9r5j4GW/xpSbtXqFvEnSJhNpdOETwaRJtSZDJUlzjPetl42ATvvlJXTNSFXBMhZ+3KKx2yqD8wiKnJQN6KITACy+1Jo2i8dfR7xWZd2kaMjuQT8+2JOE2cbm+sWgh4R3MNNylStEoFF4lo/ldME8yemhtIVXSFOEoLSFLBIDjNAvAp0Z1uUmptrKWogBQirTfdWPiIcxVKIdjGtgVvXfVC9I5wm6g42qbh5Z3AzZw4LYF+ikBga9rFO08BpBOdI6RIunG0op3zMQoxzdQqSMmKL5SGoEXwUfRIC1SJujiXZo4zh/dwe4LXN56UDOXpPE0cvRc6ikF0DUV3LIlWHWmKhGlSXNKmYeg+RrKHOC1ILeT1rAJnXKitEHGID+YqqDSsYNMEyYpncYIVPyIhdqR1zVMKjhi95v05R26Gf5PBiW905cbQu9MOSRrNwVqErTR8CNxMEzGogNfRYqIaHTxTiuSBFgPOpZCl6mvYptUFR/BBi7Dawk4faFDnrWStXZPqUnFXh5+1Uod9WHq66+aJNSa+ljf2oihiIq1v7ArkrxP1fp0L8LO/wc+M779d+bjAw7pwm05MXpE8AlA9Za24JRIm7dAla1B7SpEUI1NU0eon739mboCrG3CIgHqDrqQQqdKILVjWZNPcvNquztlg5j9/6HWwecubr3hKiTRFpmXC+YSPyajIitlrgiKLKXrthEn/igEXhqlaXXRSKxUI3kLAe8OFQJwnFSi8iY+l0lrFmeNUcyos69MrnnIXgSd1CAenroDSBY+nBHMZCOCTCqRYxkUTUvBaFEn6HsOUON1CbRWHzkP0SgwLzgTTIFCG4Iq6bGsRRCB6xZsGaUQCpwBLwrBhhuMxtGbrMMWg6EQP3gW6CeY+anFFihZrunO4GAjzRLlk6uVCu2zaTW1Ixz0XrAtdFKMIYrgww74CPXjtDPbauNJbO0jt/oqU0tUSXdsU9NYnQqnCtmXmKXLOlUvRC/vVshDSNWOylAZBO0KnGMkiEPU6v5Ty67W9rxHU9X8X3rLCr8z/e5n3NwS+9CsEw68XAX/TC5JS21vvRrHvKtcO18dwbgQ8takAjYi56LUQrFmB3bJj/HN3kBEQnOWuTikSp5l5mfFenaoaW9sIlhkV7ZrtNta6jdl98d0hmPtdx39XJ3FvuJBIbtbr3sa/WE7FyAULMSJO0WRBo2/2eT1MYc+RDdVrDh4O34TWVKTU8e/095oVRKO3DuCoLpeUWO7cvhlptekaxSsi0TuvmPXW1KXTIVehFluAB0Xwhi5EhFPwzFHXAtFDE73njrymZOu/YPmnOO1GdiEq9qtrU1L3XjOXmXCXjXK+0C5iv6NFfmebjCrN+tesQUqauYw8wXXE2/gfVf7D+DcDqIk73dyX2rTkujZ5NOlsa+FyyX/691l0/20r8P9dvt+aty91E6gED7FmFucGKYFDE8dYQ7m9eBNjfJ4HaOJecH5XnkZeH9Hv2X5+IDz3hqtDNswgphgurzOcxOrmGW7h3QoPz3L+rgKZiVnD6Xt0NZgw6INmXzubs7RLVcdts/nuiEbr8hyhqctFjzeR7rhBbrUyz8nyr6wxzakA3rs2M42mGW8ZgbVWams417m7W/ZieYzeum8PKCI0u1DnW2943ytGdRz7vgcdB+6uOHA3HJmHvMDxPdUT27NOXjFxbwh8AxftnDbL6b0gWkFX5ylnJjIVBLV5qUnfO6cfPjz8h+/G/zfkALisX2kpoiE4urM5AEdHaR3dKULbBSGhkQzdsPFtbwSz9IOgWXx4Q716zGXf8DTubibScsN0WvBxhpTM3bdeM+Kd07VUL8Bk3UmaPe561w7nJjjxdO/BNUVeStM1RXRKsEiad207IhP4PTFpRqH0Tt9WevOI99Y060AcLkecH+tpT6ATmt5nXXhFnxzFRfJWcb4SYlOMoc1r4gM+aQMjQXerTdT+1qz+I73tOdn0gA8nfC8WEdOol5WSheX1jTb1iR6P9ro2BKE1vzdYeITQG94rPcnHqPUQZ67MgeBJXrEjl4368ZF+yUxez5enGc7bokGao3tza7QNHzqeiOuemBJMGvXhesVV3X91axp0XfSPCPSqJCD7HBXH2DifM//hL7/4X78bid/Mo5Ty4ejmGG69aFjJo7vEfp6cN6Zp3jNgjwVorPnPW0TFjuAWrXOdbk7c39/z5s0bbm5uuL+/3/PkroKcusbWbdP7pYPTos567/V6zzlrU07we8E+50yaJu5u7zjd3HA6nZjSxLoZhtN5YvJM84x3nlwy27rifXgmPmhtoO7FeDfWNDvCTwvm67rR+0dCeNqL/QNJPkSSI/JwOCxPp5OeXxMQRMRysq+ZXEec4RA+h3jgnGYMFvvdZgWMGLUheIh90QhJTZqtTWZ6nzR//ObEw8MDT49PPD49cXOrePFO5+Z0Ik7JMpqvRpSjE7Q2zU69Od3sImM1MeIoAClO3u9NZEdBYVw7X3755b/7biR+M4/379///IhnfJnRN5rBLpfL/rkdBaAjrvLl98Y1cHSAHZGhR+zw2CcPgWu4god7d7jbnjmMD2vS8f2npyfWdeWrr74ipUTOmTdv3nB/f78fx8PDAyEEXr9+zSeffPLM8Tbe+3jOMW5fnp/ja48/R7H0fD7v7/U4N4x/H913Nzc3z8TXgcUcWZ7H5xmf1Th/ozFhiHkjO1FEnomfQyAVEZ6envZ807EGH+/p6NY9fh7jNY8OxJeuzZfIz+Nnfrw2RlZia43Hx0d+9KMf/dtv49iK2pJp6mi3UGQ3uimvqEINpL3ic/YuT8eVvzecTH0IirpRvmzCw1r43t1MotFdGAlwWnTK4OK0d3mnOCmCKmjRb3RkzS1wWqJ2eTrlu0uFFhytqGiYK0Tr/iJY1oN1vcSUiEFFBAkqEjXbaEqpnKZEXBbosneFqGPP4eKMRyilE7ti+PBoQdB7pGQ8kKakmeN5o2aP0AixQJrx0WvhuwtECD7RvWIrYgys2wWRqplBgKMSa1eBr6swFIMzdJnQgtCqKPYiRnqtVAd+mVRUEC16tVZZwgROz7poirZqQb1zWhLT7aIbB+mUVqi5sG2KHCkls7WVLmMzNbrkPDFEphS4P0VuY8S1Ts/mHvQN6bqz9hRa94R5AR+YveccRjZLxbkZP0VENPuQCHEOSJrh8ax24ZRw0SNVkJ0xqEW/Ek0AMOSmNO3ulyaqr3VHl0oXc0r0gYPUQqqMnuSoX3OWV6Y5erqYOz9tNIG7+1tenSKzU6Ra8notdQc1V0UopYBIYc0bH8+rbjaG+OdGLhx0OebM+D2rwjlFRXTDnjgMI3OtjOh1a64xdXRcsYZ707gz/4u335Hrse7iwy7WHYSIr3P5/arv/zU/u67w4VL59KYxxYYwxr8grZArVmT3+CmoAOc8w/Q6z18jgIThlARpBYIljDaovoHq6UhM2u3dDAVreKoY1Q0IfhcP8BiqwxCQPuiG23MQTGV/AzLQPqXqOY5+d0a3vFpnXoJ5wk22MPYmxM4TmDOn5UxtRfM4hrvaJElFiel7bV0IIe7CxWZNFFG0W3fHWiQrZnnDajWYl7i/99Yq4ElzwrvOq08+ZTndaLfg+UlFy6o40i0X1cdNXNCcBGFeAp1AzY3g4TR7kvNE51X8q2rDHM0gKagzfJoUNeSDnqfuRkdgJzhoW9UCvwO/zCryrxfquuKSw0+TCgdLpFleShNRJGsXnCF11d2hwqB+b49fwy4TyxZV8X+nQKLipHQtyeStsGblnV4eCgV49ek99wssqFCcQjAgFZRcwKmg3bJ2Xj08rM/y/545/95+jTT42RhCR/Hvr8N3/v9P1PtNKz5KqT/tVkAa1WHvRkH9WkR2Tgs5rTUKhoDraDaQCcWKe4Zo1+NemLdiYYi23glRBaeRi7OrhcPJ3bVjX4RWCwGPC34v+LeyaddqiIR5xtv4995yCOYFgkN6pW02/pveb3VT63anXBMb/9IJURewo/mjUwldnS2h2/iPjm5h9iKaV5tisHGlC3CcU1SO67z+5BPm5RbobJczrRbtErbsABHN6quta0NMF6bJWxFCP4ObORCDI3pHdOyIzdEEloK6CAeixHlnhVFRUbbr/bblogU5p0ghnNeM5XXTpoBJc/zSrJ8tQ6CM7LmBLli2QzfsuLsKRG0Ue6zBpjW5CglWCwohWB4vbGtmzZWnDw//6tswvvpv4fivuXyh2wt/aFR0uzNMzXe20T8440S65fRYrpZ1iWuDCM8EuODVXSNNrPO7P2s0ELvYQtBCkjYB+b1o7v3woll3eWs4H/YMvt2laA0MXV44GA4NY8+bEvS1Bw6sNW3oUq3Q4X203ErZ56mRGTqcfh1ISdcd7oV7kKiIsRD8LohfVztyQBEdnBZ0E/38FWnEwP72PVLi2u3f92LrEDS9NT7sBZexTt0Febtfo59Xrwe3r1wLvrvY6a4YuB0fZMeumXHaKCqG/mtizRvm0Gp7/l+3Qmc3pDK01vn47st/+Q9l/P+mPb788PGnzpo4NKtVE6Wl65iTWsDbdRACLnoiAQmdJp4mlV6rNujNSQWi4K/IfnO57zgsHGGZlE4zhP3RMChlF4ntQlL8Z7O6h2XV9prpWfHXboraWNaq4vyCw00Jf9JGRczJhxN1NsZASCpCE4TuAtKqivkp6V6/a22h96Kv23S+KzRabFTvaM0r1aTrvjZ2Xa84P7BoldiFYLhMnRsbPQaaoY+lZS2Yd6Mu9IyTzDQ7QvQ8rpWEMIWm6P/W6AQdo6JNAk6cov+9uoq8M/IJke4Fgq7PvBc1Voo2qfnlhPOe9nRBLhf6OoGbDQeqjdvUrqjvpPWSlJR84L2jVYcL6i4Ec4OiOeHSDRNM1Y/O4hacWTydF3BCyYX3Dyv/4/d/+K+/K8V/M4/Hx8e/OmZvjfvjy0aaUcwtubCu214EPmbmYY3iXTpiCOlSiiJ/p5l+p899c3PDPCvy8ojGy1tGuuyZfbUUFdSHOygq2eurd+9YLyu3t7fc3t2amFT24vrd3S23t3eEPUes7ijOlKIhOx2uOLy3grY5/waaUDPHr4XqnLNGZvig2eQirOsVC7q7HkO43uG78PrVK5Zl2YUUkW4OH6HUi66dUGzp4+MTAK9fv96Fj0HxGALFLnh4T69F81Btj7UMkdQiWNZ1Y5pn21qZU9Dqva/u7/He8/j4xPn8xNP5lvv7O+7u7nYSwsg38z4cGkKv+MPgg9Vd/TPX1O3NrTZNmHPyKAZpVqPfxeTWGp9//vmffDcSv5nHu3fvPj8KNhzWyEdxa1zjR/feUSw85sQNcW483AGz+/LrL7MAXzrKjhjZ8Z6OzroxNs/n8y6w/+IXv2Dbth2fO67LcQ1eLpd9vluWZc/NPLprj+dgOPuGU3GI8y/RqUNAPL7eF198wU9/+lNqrfze7/0et7e3fPLJJ3z66acsy7IjTY+vN35/iH9HoW28t9EsMYS+L7/8chf4tHlRnzPnvAue3/ve93Yk6sePH7lcLjZnsJ/HWiu3t7fP8J4vP9ujKPjS4ffXuT5jjHtzxHBifv/73/9X38axFb3TbWcfJ8IyEHbap3s2GkyMMNwMDuluZ7fbMz0vlrtO642HS2MrnSVACrqhFd/pvtFcINgG1seoGB0fcb1TeyUGEyDp6rSwjaPvUGsnB82ymE6J0jKPD5mbZYFJUYO5CdGBl46gi3KxorF3HppQOiw+ESeHVKcFQkNiuaCF6t4FzNGTUsQ16K7gk6PRaM2RrCAh0lnXzM3tLSEFkjP4oXdUiUTnqKIYj9yUHS65mtPQ8HSGLSAGovf0kSESk4V+V3Iue9FKN7eVbfDRW2ear64k8U6RqG504Jq4Sif2zqQ9f9TcaLUbtrTSSmPMl3lrQKM2YV4mguuE4Li9jQS/J3VokR+P94YokoBBWBW/1Ru+NvNdRXXduUj1Adk2vHR6WPA9cHN/g/iuGJSuEEyfguWFyb6Iik47/rrr6sCpTQslqNDmzUFUqh5nFz2ndE/3miPgRbFndeQABP1daZ0tqwPsfg7cLjOxK3o0mcMoADkX/DRzczuzXlY+ni9ccjHc2tV1qsx1qLZgsXQ+mneK/xyYpH5wuuxlIi3+hJFLw9HQZgUa+0lB35wis+Rqzf0lNeKFoPd1wt7fClV4fKw8rDcUwzYmI++YQQfn0PEfKiEkKxBHnAiVSpw0z8lPEesb2NGfYv/vTdjyoAK8hyqBaDejo1uwd+2Aa93jqdAMIxsUndfR/Ie9+NcEH3XD37UWRqudZMH0PoILcXcR9NooW6XmzOkWpnjCuUSISYvmbSxcGqCIv9axz0rRha1rnmWzjWh3kRi0wDCEbe+1s7WjG2dEdhSmmMgZQrKypMcbMle6ojPLukKvTAGqF2JMfPrmE57OZx4+Ptg1w45s7srJQsmKdpInuJsTadKMPpuozQHkdY41zG1KDuebFfE039SFQMurBrJbZbZb5lo3QXW6u8P5C91yBF0K16zLqp95F+sAignQxggxt4/D7Zlqu+hn4tDutDhmRXnNDO2tsV4y51x5NUW2SyEBNwvcnE6kpoJxNPEvYBmqE9xOOv4/PF54ePv2l/T1XzeWPvvaLxfe/q1EvvI14mD5rSxGyrb9mXLfw96AJOi9q5nTexTdtbBsG0ARK5gfmvYNAzQK9w5ThZ0tJmejBoRgxeErGk6dQh3fHa13YlRHTIxAVHdJ6Po+ci7UrXC6cUwxgFd0bu+O2oQuTZ3+vamLvWseXe+F4JONURv/XhuZolcc4T7+nbNGJoHWLctq1CJ1ExJiUEQeWkjQY7iO/94byZBdMUTevHnF09OZh4fRjKDnuTQtuNIbSssJY9blbomkOej4t6p9DJpR6Dr4qPfdGB3eawaoSEVqx/dAQ3FAY5B2abA1ugmq890t3qszWLro3KzKiOJCQfOhvLNcwU4tzca/s0Y09saCQeOWo9OKkQ987Q5tTddw57U+yMPD/+m3ocDe/45//pt4r+Xx8T/s4Xhcxb7gtXmHQ5evrustb9tpQUmLaX4vEgwhXp1gfkeJDiFqOMK74ei6XTuaE6jiV9gxAv2Q62frs4GblKs1se97qmbFu+vPjqKbyO5Nvc5V9vzeK74qRi1Y9eF0dg6H7I0FYk63YGt85x3xgE7SbNQxIXpduB5ciuMkh+AsH1sL9601Wq3mLNDxJLb29l7zgzQKwPYivRs+uKvryhrgFNVprArn9+M7Flj0lNhxmNvymJl4LGooAabvn4sbxZG9U9hRm+1Nx7FYTpP0/ixLamREDtGwd80KbbU8fPiLH/7X38bx/9vw+MkXb/9MuuyfrZjA3EwAKLnopTziEVLET12bXqptOoyaI8mCwZ3VJ8bir6vrPM3adKZD210dq13nAaXxm7t0t9nKYYB3XBNq7dQsxKkRrWbivDr2ug/aEBgduIKF/pnrrBuhYNLmz9Bpvtr1HXAuIRIQE6YVYNOMVCFcslBCUEEsdFuI6/2/ttH5LuaG34ihQHXEKWmzcGlUFsSfdN0gFak63/jgiXIhRnU+VPGEFHh9isy36kzs6P5HGjjpWruJRiyJECfLZm5NBTjRPV33ztY2Qt8KvWzaKBAm0v29rcc60is+GXqjCc7IOj5p3nJwi+Yr56rNtT7hsAJhGJ+fIPXoELF9lSHPx7zSpVO2wo9/8fHhf/z+n/9X35Xiv5nHhw8fftAOWa7HQv1REBgF4OZN6MmFEKI1reo+UB3g2hTf6ZY3l5WQkRK3UR1mx2wsMQEshKANuUXdZdL071E0HtdMzoUPHz7w4f0H/uAP/5DXQV3xKU57VJI69cWw5J55nvTeMwwZO0bc6hIxssyL/hywbXkXCI5F+XVdyVu2xunZcoPD1fHUtbGltcrF3Dujbhu8Z54XRAq5bBozVIs1wjRq1f307e0Ny3JScaNWpnne0Yvea45grdpcMKgM3ls2YIz6/VY5X8602ggxME2zNRCps7GUB27v7ogx8umnn3JaFsUUo3i+bvOeWJ53jOZA9GF3Wg4k4RA8hpNR0aZhR6mPTDFdZ4U9P/Lglnr48z//8//jdyPxm3l88cUXPxwi7UtH2/jz0gl8dPgdcwCP33/pljuKQBwaBI9r05cC4Jh3xmPMU0OsA/j48SNffPHFjr68XC547/md3/mdXUT7/PPP+fGPf8wf/MEfcHd3t6M/dayrE+6lcDWa84aQd3QgjhzL43scwuHAZ97f35Nz3kW3jx8/8p//83/mn/yTf8L9/f0z5Ol4nqOTeYynozvx6DIc2NNxHkspPDw8cHt7y7t37wgh8MknnzBN0/45DkfgOP7RXDAcg3umquF5j+LsMf/viIv9us/OH5tJD/ePoxvSOceHDx8opTz9i3/xL/7P30oBcNwYr6kM7CajkbNx3Fn4gVZxXQUkDK8kI5vsmNMRrODcebxceLwsLCkQAxCDIqpcx0sjVE8a4oc0fZoAk1N2ey2V87lwvhTN4XKOKs1sF43Vd6ZLJCQtJNWWyU27QoIh5by/HifitQqGokLiMiN0WjUB00XFJQan7qIi1N61QNi0sNVxSIMqnaQhWBTpSNOCfpgD4TTtOVPalaObhFIKpTdl2Euj5oafZlovSNHgXHrAJY9rRR2HTgtfaxGkFN1kL4nUoRRh642ydXp0ZIFlDkzLRKmK7fNFKJJJUTvc8XBKCfFOEalVRdGK8vW91+JfpNN9pHWhiSI/RnbG6W7hNjpOc2RakhYOWkNqsVwhLdaLdwRzt/lWqc7RemVyUTUDp67CiUB1jnxZqaUTb066+Lm5VX63KTnJe1ovV1fUKNy3StsqrWqGnA/m1JIKLmhu0dCmk6JGpFTLBtG8j1ah1Upl5IQ0VnPzeO85LQtTmBTDhmgxuHUyDXGVu+CZfOD9VvnyqwulWhaJOSKcFYssEMWyZ0ah0tOtMNJVeX5eSLJOa13IKlIF73STA4hze7F75Dw5c2IxAj+Vj/qriwVf60z6W4p+OyZUMYb35zMPTzr+g5jAFjzNC76Jomu8fz7+IyQX8RFS0I2iHF+j7W0G0AqeRDFBz5sgW2ujWwanNv2qg20gNK8d9+DN9fkckGqilC1mu6HEQgzUrLleMrpHO2CYUJ8CSzoRl4kQJy38d3UTl5qRPoTwrgWAMIFkpGtuZfTDhaLOP6JucNXNrNmAtdYdCRt8oFs+UZOm09twJQkqhJRqolxUR1ET5hipW2a1jsL16UnnqSZ6jY3psovl5ugYFNOSpzmRlsR8ioSor+nHAijqxsVH67oVE0+lIGWjNY9rAT9Bi8GwbootLB+f8FvGn04QAvH2tGewqUDX4NDVeayA1SyW/WkYt2PB3+vc35qoU6jrcaojWBHFXQTpja1Uti0TAmy5cimKabmdTsxhNvynOgWDQJXGSubOeSbveb8VfvHu4VcPmbdfM97eXsfM16M/X+b+vRT5vk70e5kb+NtVdOzr9j/haJ0erji9a26XiDY8OKdNANocqsJsNedvCLpmGFleIjqPusNzecuD07XNmBT87i5RF4JW6jQfq6j45P2OaKYLHkV4xhgV9Zts/EuzrMKi4z9Yt5xhhJFC79XEDXX7dLrOEca6b13HVrPxL8P1Y39UANS5PThDajYtFrpSqeJNSNXNwBzDYfw7tqezpmiOLunhmJWuYgt9z151zjPPjmmJTKeoxT7n8Zb152MgRK/NOrLf7hAp6kwQh0gkOZBnHYSQHx9xWyacThAi4fZE720f/11EGwUsBWzcIF3vimA3N2AwgWCILAMVNDLB2shd43pfVvG4sxkF4XK5/EXv/eM3vVj/TS3u/12/r/rw8f9Np3XXg7ecL+91jeQPm/u9DfGZI+Ba9D4WAoZbdGwiw8gG9CrQxxiedRp7/J4fNDJmVH8beyRF3z573eHm7dc128gIbKODd18DOnPndo4xFSOTptbRpa4/n5I2KrVa96ayazFCBTHnFfm9Z02/WNyE4A/5gi8KHWMNGfxueh6Nl6PgQHO7gOpHrlcY3mT/7LVkoHr9Mb9a9gL8y07tI+KoHZwe/eDa3hvkbG0sNl92G+cDP+oGOnp3U7o95qJJ29fUtam41K1IOgq8Tw+PP+y1fvXd+P9mHj/4yRf/ptSt3SynUEW5HdLVle6cozZbQ/chiCWC73iZNAtONK/dRwc0ujRd7/VwcPdrPvmIfxhi3mg062JioY+4aGiYXC0PYNQSqjauiaiuPgdc7LY36BATuIRzTVUw6zrrXssNOEV7O+dx4kwgd4h3+DTRU6KFhGShbYWtZGpw6j4WaM1xqZ5NdC87hYSPkVqEshbd90WtbTjbHwWXqLnRazEBIlC65vc5L3gn0Gy93Ko2GLqqh149N7Pn9CriboISP4oSjXrR9U2ICRc8TnRf4Ls1F4iow7FWupvoXjO0u1N3nnx4QhqEV6/xy4RLlt/rPC4EnFTNa0cbPjTDN9BroeeqjZRJXaDeqeux75twrWu4FJXCUJs1XQSQgvO6F2q1sW2FH3z+5V+V2j58V4r/xgSA/1ettfXew7gnpBj3NfvxMVx4vY781mp5oHF3e+1rQWRHQo77GMA8TaRpJtqa2zlHLVfxaNwDSy07YtwP4oY5cO5u7zgtJ+7v7liWxQri2mTbWqPkgnfXwvmUJms2tJWo1/iQZuJlipFpnvAhsG0bW96ope7N4Tv2sjbWbcU5t+NFcZCtIO+sQW78fEqJy2VVEhvsBfRBFFD0Z9sFNL3Hxz2Pazbxb4gVQ4hstZFiYp7m5/d1ry7cWpvF0+h9fZqSrk+6Rma8//Cey+XC7Z06/m5vbnRPY4JmKZpB9gzdsVOx+n5soFSe2uz9m4BwXAse0ZDj8z4KOR8+fPhha+3hu5H4zTy+//3v/+taa/Peh18lAA7h6ej0G5/vQNMe0Y9HwfClcHjEXB7xuEdB6eW/j+LYeO7hIPv888/5wQ9+wOvXr/evf/bZZ9zd3fGjH/2I+/t7/vRP/5RPPvmE0+nEq1eveCl4jlzP4fY7ZvkdxTBgz9Mb3x/C5jzP+7U90KW9d169ekWMkTdv3vDpp5/inOPm5mbfT7zM88s5P0N/DgEwpbR/fwiEIyNwuPa897x7944f/ehHvH79mt///d/f3Y05Z0opnE4nlmXhdDrtDt/x93AcD4H+5ef0MifyZZPIUex7Kdq+dHRa9ie/+MUv/nxd12/l+I97GLto+snAz10xW7b5cKPAbW5BZ/kY/poAaGTO3U3I4KvTOa+NXzyu3N9OTATdVPZOiOBDJRJwxN0ZpS+hIqHW9yuPDytP26odZM7hUqRXwbtOlc7jubBM8PqThZgmSu4EhDQryi8k3fi1KvjkFcvR9YbkbNEsTotLeJi8YQJ7VpymC9pe3wxnExq9dHUH9aiil9bbCTEwL4v2+bZCs+K9i46SVw2ndYoRwAfiIroB3YTgo6IaSwEHJWc6XvMTRXOytrXv3fXSO61UXQSnQDGhqrXKx4+NUrRQPpWET5GbuxmP47Sc8FMkAJNDBYoNphQgCXkt+qksE2vN1M2yNnpjlYans9RAPN2RJmua7Fpgl2Y5j3Rl/gevncPNrq3omYJ2DBMd3nWid7gpIm2GqiG+vTUkaVZAdFgHFuRzJtBxMVJt4VBro4perFMKiDPcpzQVLPpw4ZnrbxSYSjGMU8TRWbcL1RwFrQm5FtY1k0vj7kYDkaVVdXZ0b44OIQUNp++10avwi49PfHg6j7KUIphGkcRpoXZkxSgJ1OMJNJRZ6NTzuDepap4be05LB8Xmditam/1CkafX4svenOquSNCvzQB8qVJ89recTb4WBbrCZ/Cwwi/OK/f3EwntYEUgJMH7QrR3hT+Of1PtgDRByXUYzK7C3xACAwgmApo7MEojirnSDPFl0xK9accwI8dRVOSiWIfqaAzulS7qZu32NEiniQp9rmOduYq4oze6ZVuFGHA+aDg4KuZVu66lD2SXoi+76ALdx3hd1Fpp2zvNEWm905q6ctWZWyAlcycpmkgEcm6IbyYY60K3bFq0m5fEclpwIbLMiRQjwVAoTdDOWbSYVkvFmv2ZpkgpldLaft67h5C0szekiBH96FW7coeZXIudVmwcJlQ8k+WfDCyZ8wGfoOeKj4laOy43QmJ3IjrdJdFzRUrBxUCzcVVr1dcfhdegjQytCdgGzYYZwfn9ntab5hTqNWCLiirkNWPxkZxzoazw6n4hhYi0po0sKH5VWmMKAVBcUy/CLx6e+Li+/ZuJ55/pfz5jsaG4/NLQ/NUC39/GGZh++wqMIl/WUh5SnD7Z36kJdKNjlt4tStU6XINQW1MMhlchr3t3bW4SFY56cPgYdrGr17oX0wdyrMu109bvAlHb51jvLN8WAamabTmlHSNaDKEldB3/VV37rnW6jX9pReeEEMxx0A1RzJ4lVkUMz6P39Fq1UUiJXloc1+yRYpZwy7lBsUj0znyy8Q8s86QZHJav1USQXnZkYi3W4ABMc6SWRqltF9QcXcd/Uue990ZZaLJvyq/j3+3z7nCrTykifSzctegRYqT4io8zpSohwe/jX+8NSKeXipQKMewC4D7+W8cF/bwVNdJ3PP24xwS7f/reKYYGlK4FmG45YTlXahOeHi/f/4dQ2P+NHf/b9kFae4w+vcZAm0N0610IezbkNROi704uQwGPjC//HIszNskj2ksOYx0/sKK6xkbAh+HKM+zljtN7niUouIO45Xe36Y6clZGFN665ETTOoSjhDkid/qyjWTvglRaAjd1r0cPvxI4Qwn5/xbr8hyjpDmKoD8eO2EOmkp3H4aYrtV+LCpZ15EdnrW0Y+8jptYtKf8ZzfWrLSbL103AADiFwvAdFfNoc6B21tmcb99312Z9nJ+6ZgrYWHthRXWRfr4vxmvSRw2guapE9/1c6PD08fP8f5Lj7DXk8XdZ3j4+Xx9e30+vRRNms0TZ4kO6RVuhN9/I9RLYm+NqYXNTM2RRx04icUJKH7xpW66Kni7rXqJUuVeeTYIHhlvU77h29W852a/onBnPTdmia+xWjhxRsqdLBB3ocuxfLau/2b6co3m5NxUE6lKxzggmPDU8R3atK7eTLxlYKfZmYJ31PVRprqXzcMt11ptsTISXyKlweLrRaWe4TN7cLN0tgmhIxRLzT/UnDI87jWldCR+9Ecz6PNVIulVKbOui842bx9OToSSMGJBeaOQY1dFGbEJ1zONEdrscb+pMdZSwImmLo6X6ihxPSHFKr1j2CM3HUalWXjJRMnyYIUeM3asUXwZWOnwJ+SlTpih+1mlNHRVDvB0KwaySMeBv7jeDUEZpzYcudf/uf/ur/890o/OYepZSPtdbHEPzr3Qlo9x+952BxG8HqTGEXA5o1tvrkXzQAHbIALaOSHafntKncXG1dhGLF/R3HaVSJGCLLciLGQMmFXNQd+8knn+yulNaOGYTqNjwKCiH46zEZLScGrQGlpPg96Z2SM9U5tm0jb9t+zMP5o2vdytP5CWlXAcx7z/li439Zdqzf6XTaG6ZGQ5Kz9zkAG94pqn9k710uFxU9Q8Sf/O6mOwqjGjEAMaizD2Bd1x0FPhw687JAV9FxCLS6jlcxIZfCZFmP3lnWsnQTWgpb3nac6RB6vdO9xLIs9N55enxUt6YJRM45Ykq7UDnWRqNx6YgELVVrMl9++eV//G4UfnOP8/n84enp6TGE8HogLo+4y6P4N8bVS8TnPM/P8MEv0Zi/tCZ7kQ/3UvQ7IifH+Bvjfds2zuczIsL79+95fHzkH//jf8zNzQ2lFJ6envb393u/93ucTif+6I/+aBf/xvscmXgjNmOIi+u68uHDB5whdYdj9SUedLzfY37i+P5wDo5mvoHmHAL46XTas0+P4mkpZXcxDpfjOO/jM6i17ufgfD6zbduhmVGFtWVZePPmzbO5erzvWivTNDFN0/574/WOrzGEv6Nz89ehXI8O0Of7rBf3BPtcHx8fqbXyk5/85Pvf1rEVrwU1h3dhRyWNTdTVEeiukoHtmgYWo9vvO2cdmP0aJqF9p0Jp8O5x43uvGn6CSGNOgSkkUgzEFPHB4U0UKaWSohZpahc8nktu1Ko342YXa7WstFYVF+hv0p751rqQa+a03NKip3S9KWnmk1CLEEMCKg5PCA6aFuRcNTHQAVJxLiC+KxYUKD4Sq4Zju6hda/v+vQkxBcXRWdeMC55WK+2SrVs4InmjenVRIpab1VV00Huo0FonxUTZMlU0KFukQ/BsF4G14BJUc4H5BOcPWTuT2wytclomcJG8btylwDxFlhiZlkicZ3wVynaheWPldxVVQ/KHgabdiKUJMXpmAsviSNHx8bJyurkBQUVCB86s9M7p1mLkDtAyOI93UTGbQ3hLUbuchzh4OhFP2pHru+U8SEWIBBrVQSsdF92e6SFdfXAt6GdPd/S1ahez97TS8EkLvtK1q6vmppgI3xDbBNZSrCUzEHYU2AY4bk4LMTrKqoqaNJ2UlyUxJc2Oybmy5sxXjx9ZS7WFnRaMXNBrvdnXRyFFF2IDXzcuJX9AQQm4wOG+dcWXmLTR0I2ps+I1jl24GkXzkdXy14oSn32dcFB+veD3KwTDz4C3b2FZCt+7b/gEITaW6Jn9TAqaJemDx5t4U0pRzj5C6cJNCnzI6sncA9eGAHJAgYLuuwFqazgyc5yIzuNCUscXfhfqfTfEpxtdPyryNROSdF2o4rw2BkczDvcrbsyKAtIbTioxzcQp7nmAtRRCgO5Fsw+dGCLTxCfLxhHReU7nIQvftmJ2M3Gij/1PiDg8VcwhSKBGaEU0S7A1em200nRDXtVVeXPzCfMcOS3a4RhCoLei49AJPmnGYN8ypet8O7IxerPcr0MGqN4JtEPY+4hzol3YTcVVrKM5Bbefs2HJU0xgUKewKAqEFFju7ygp4lu1Ip5tTrqhuRpQNbNEWscla1DZGzYcxIiMrj/sfXhn2Yg6F/fG/tzqVJc9d6gJnC+ZrVXSBF99ZQulUyJOgXrZIMxIazrH3s7abQmUUllz4d3DR35J//sMFj5jTwW0/wdYv0bs++zXioDHcflyfKZfIfgVPiPtz/dNFR//tq/bmjz0zifDpbN35NsapZkLUAwjPjKfSi0EP4H3+BBt8T8KxN1cqXJwoHDtEDbMLqLFNc2dCER/LWwHy6ORLviuDoAQZoLd+3rv1FzwodN9t/HfCcOZ2hTh3KUb4tvveKBam17f3lN71zFtAoKLOv5bb0gRvW95R8Ncz6LjPqVJ3SxV3//NbWKegxYBQlAXUFMKgbdzN8Z/7007/8211Jui+6qIFsn8EEkVazyZEK/5WYr/UoyaIwVv+L5GLSPTzIFcNy1TjEiKLHe3lBhxUndkYHfsOFbEmmxEkOZwMZoT2n4oKDZdCwViDnudH1rX52rDzbBj3Nizxca1c7lslNpZH5/++9/m4n7/DXx/f9vXzdv2Iab4uhu+offhertmAw281u7UM4FHDuJYt3tlHw021hG7Nx4O8VDU2z2cfD7453OENULuAuJAUO7WOcsP6XJw0JkT1QTmo/tN5NrSNL7W2guH3AskUfBuF8DCEEXddW24C+vmDnaG0xxOvnF+/J6NqGj0kdcnZvNXcdBrn5VhR5tlbIexaR7rWPt7Lwx0a0EaTm3rrmojd9HEnCFQ7tfGcPo7myNtsz/yBb1T9+5wVWqWdjts7GXPTpQxb/SrE3hHgNL3/N/eryjWKkKrij98/+Xbb+34/215PJzXj63dv8ap0zaPXO+m9/BWQWrdr+XclTTTHSxp1tyBpLWBtncBOrwMVdrGtnilA/njRZHt+2FvPexG8tlxoVTNruvFssODXcfO8go0E3tHwTiLE24OetSGRDHEiXRqqeRaaUXnOoInt4or2nzQ5zsqhVYKrVVac5xT4CyZy3mj1A3/eEEIlLKxfbwQg2e5/R7zvGjznzXgDrehw5yMrhOKRn80oydJ0BbGJt3Q3dpIu9bOWgVfOtF7WusqEAo4F239qU2GunDX7F0fkxKWinXkWZOeC2GnfojTtR5Sdf1G1HFdiwqNrUM0tLAZKsV7QgKWiYruIyff1LnpI4RrAwDmbpLWNItdlCjgQ6Cj+M8Pl8K/+7O//Fbm//w2PbZte5zn+TUvcHzHwnRrzfCQ/RkaLtjnefyd/X5i388l76jQa4aw7PWv3oViwtd4Ph9UAFtOM106l3qh5MJyOrEss431boX62YQ+txexR375wHle8/TMcdM1wzgErSuNXLArylx2UWAUx2ut1NI4Pz0irbG+emWOuWJ1Ks0TS9O03w9ba+SSabUx393tbshS6tW5192eo7dtmwpsoyps9IBRhFdnEDspBVCB1FyU8zxzd6+Yw3W9EE0kjTHs7y9OSZsWwepxnjDyHFvTpv1W1UQS4r5uEzoR3UOt64V1XS0P2dN7tPfb2bZN3VguElN8hkocxzxcnz/96U//xXcj8BsXAT/e39+//lWuvzF+hlNsrD+H2224uo5j++je+1WPI170pcB0RIiO9zL+fblc9jHXWuN0Ou2ZgHd3dzvmcrjrPv30U2qtu6t2zEPjNY7HNjI9hzMupbSLasPV9zKb8JjLN1CkOWc+fvxIsGzRIeAP0S+lxM3NzS7uH+fEMX72edSaDcd7XNeVy0XH3zG78IjcXdeVp6enZ+7B4+sMQXLgTMfvDffjOH/jHB7z/16iXY+NB0cx8GUWILA3Trx//54YI3/6p3/6L7+t4yrumwTbtCol0FlH6xgFfXcGDlyhIgr134x8sb5LhupecrrgVVdd5ekifPHhkXkJvL6ZmFIkTWo5dzHhvHZi91rpoeG7o1ajiiKkGFhi1Ew2K4gly+YCRbjUomi72gVaYWuOssievyXmNMqlkuZpt4wzuPXdEeZkmLuGdHV1IJXgIjV4JhHoldodpzng50jEUbPuHcCDV8efd9qV1ERoUjS7I85Ib4YE82w5I81U69EZOyVybqz5wpQSfu7UIqwlk4AwJdzs2NZCvRSasQi3IqQ44X0Hn1imZAJZ55QSp5vEaZ6vGCCBVjZKruTSiMusm+mWEdShU3tTF1LTdLlSM1upe4i3IIolrYr1OE2TORwa0xR0E1Q6RO3Ms502Mer23G3V8sUaab6lBZDN48U2Ta4jRAQVJL3TDVFDkJrxPipq0DtkzfSmXUwtBFpgx4P6qJ91qR2HhZonR6vqnqg1U6sj2uKoSmXrKqjkqvjB5bQwpwmnaw9yrZwchJ6QKkwp0qXy87fv+PmXj9ap5vbQ+SkFoo9UJ3smUbAJqTTPng7jmgl/3nwLDi8H/JFz+3cH/MDb+HUjz8gdKtqGquz9uo39W/bh/fWi4deqfwNnuLKuKz//KrEsgddxYkqeNNsCNykaR5ogWSBUvHiqZWOEFHbnmSciVGjlV7zPaIVqdemV3Ag+afe9AFH0svLe8uNMnCu6qa3iWZaoi3UrzCn5L+42tE7HedT9a9ZXaQ0/Msak4yxrW126DakdaZ4ujSLNOs/7sMkhUhUx6BMCFPEI5hQIkBt6bfuoDQA5s14uu7tNTOwNU8Cj7sPgA8v9DBUclcnGyfXmqOdhWy90B1NKmodmzkhvuUd1q9RS2baq6CUfTCQTettoFW5vPT2MSBWdx+IQCc1Zk0sFhPl0wk2JULVAUkolBIcPie4joU9QtSuv1aLd0A6oHnrV6zsFc/boZmOIeNI7LW/WFQghGqJBbP4SczYFFKdkbowmbc9ILE3IRbMKCJFaVlbgdHNiiRPZROicKzdBnY9SGimpmPnFl2/54st3vzRWFiAtsK7Xr309mFMRoG+/dgweXX/la8Zn+ntZPPx9FhZbrR+vU9khs8uwcA6HSNuv7SoqtnkHxXImmu+aD4c57EQ79cfzyGjz91gWkGWMGf7Teb8X8Ho3YSx4zMKreRaDjDCaA5y6/qWLorFEi9VV2i5OjKKfNFGR0GkjSu4ewTYf0VO20Vmv64Qsjctls/wjdR11nIqPPlk3bGA5afe+7yqyjUavUUjvDrZc1Ol7HP/e41NEulC2og7AUrRhIkR6h/NaEcNmczNr05bzdKfumWhZm6MAv+Ux/hd8itD0XLZc9vEffETouBb0e6UoncLExC5N3Zw+2bF3Q4M5em9I1xzjWrQreKz9WtM1qzYwaBG25kYz1HGzz7+JiqglV9ZcHvvT43/1m1hQ/4eUNybSHs1Lc21FdJiz7NicaNe15V1eN4DXnMDh6tNinGba+YGmpBsp4oqVHaKd694aGod46A/ClYrGMQz3odsdyjtSyPLEhmv5iCA6FiLkkF16zcjDRDy3xyEOMdTjcfH6tWDHMsQ/xWZFrs7pq6NvCI2qtfUdDexGF22/Fg90k38tkHXLgg/mVjh21e6OjFFstWKoyLUTuFlj4XBV7wdqG01FOpsrcTT/HFCvmItRWjcHpNuRac5yFGUUWtsRucp+/qXJjgcdzgUR3UfW1pHWnh5+9Jf/zXfj/5t9fHy6fByf2bjXS9OGEmlCq51Wsl77rVM6+CZI2/BE5uZozauA5YWENqVoIoJhQdtITW/44SwzbP/IcNd1ZtDsvgD4pFhNaRaUbeO467VN1DUnzmaOrmKX3qewvbanbY2G0Lo1pLrAKp1cLN9mjupszxUfPJuPfCyZp4cz3QsuREqPrLUjMRKTIk49jvlm4u50g2+Zm3nG+8Vck9o2WqRp1qHz9KQ5wzIaJJcJ8YFaOufzxnY+E2pjmRJSO+u5UC6NT+4ct3eJ4ALFa5N1cJFgWeHeqaOaAC6KCoAEJawgSkAIKvq74Alx0n2qd7ix9u+6zBWpNB+QlHBTsnVYwEdH7xtVOlKKYZNBUjTPpe4epSu+eRBZWm827YjFFni2vFFy44uvns7/65//1f/luxL8N/vIOX8A/oCD46M1rUs12iEHyyNyRfENUS0E3Qsf72VX14w2uOWcn7l6eu+UWne89WicGa8dLCvKO89aVractRF9R/Gl3Z0zHEJKBRqNQ+GA7qxXBOk8X7HeB8d8LoVsbhrvPdu2UUo2AbTuSL7TzYnltJBiZJ7nHaU3BIYh2o17fK2Vy/lCNQFV37NYBljchcanpyeenp52UUTzWIVeNetr4ExjjHt279Wl459lbN3f3cMdfPj4gXVbuawrzrCEKSXubu9pS6VJY1u3veivU2uz8zvt66oUVVw55qw9PT3Se+fm5lbn1K7rxUFEG7jTr8uMG0LJtm2PP/rRj/7r70bgNy4APh7Xy8+uwcOYHtf5GAtDRBoi1hCJjmLvy+c8fu2lW/DrcuWOAnzOmfP5vD9fCIF/9I/+Ec453rx5s/+8955lWQiGGR4O4TFGY4x7FuA4xqOY5px7JqCNOW7Me+NYY4y7eDiO/Ti/HQWyMcZentOjo3KIkeN47bPRRghz3Y7MwnVdd1fkwId+/PiRd+/ecX9/zzRNXC4Xtm1TN7K7knyOv3tErY7jO+KHr07q8Esuz/G1IRJ+Xfbfy+McgurDwwPOuac//uM//m+/tQKgQ/GDxw1VZ+CRTOg7ZKMcszPo1/wVzRtze4ec69VylWRfN4tUPjw9sW4zb24m7RS1rYxUxTkpjl8McTgcI/quPr1b+Op9vHae2Cbb7zfxTjZ0ndCJ0ZFXYVtXTpMnN0fLmTlEQnDMC+StWBe8FtfzJRPSPckHunO03nQzLc4Wo0CIiqZy0HugZKHJhiMQ00wK1pnQKhIU+5Fz1m7zGtjWR7XcO09vdRdWs3U2O6cL2JwrpQqX7cK0ROtiD2xb47JuXJ5WnvJGTJEUPTUL883CzewRPHGeyFslJs99DNQnFSAfny7EpPZ7qRdqzkiM+NaIXl0Aa830LsyTZgyeH1dz4elGuYvw8Wkj4egTyOfC67uF29cJiR6XhbJVRQMO8Qlw5qrwvSPjwisrPSQTmbuKqMkRJNB6oFKYAtSetKBbMs5BWhaKaAHSG8Mp28bQB8UG+ZRotdFyVXyjMgTVFQXElMglUy370bum2UBNiwalNEpTBxh06pZptZK8I7dG7A66Fht9cjgfybXx43fv+fC0Wvhz0O7p7pjniVYUwynONol+VLOCCouYY+Hg3nMuIM5cjs4bSOYqBCoyTje04hTppkK99ZWPTu1+RWf+0hT49teJen/b/LAV3i7w2boLIOoCPPO9deHN7YT3wca/0EuhGUYSqjkX7UYkXnGrY3Yx8g48FzNN96W0ykwEAaEhkuk1UPfuXQ8kJq0/E0bmXRNCUHzo7njuQgWS83QfrNNM+ZaKBAoWeK+d/j140/OaZnfEQKvdnGIqRkqtSK+6CTc8JqKv02kE58EleuisRYX/mHTDLt3TSmVrwlePj+Q1K4IjBpxPODy3pxvinAhOnY4heILz1C0rQrVZIHozN7V189vp0QVDU5xoSB7frUDQGq1k3ZBJY1sbVDh7uLnRa3k5RctSVFdlF4+PDh/18/HO42IkhkTJKlk2qaQ0U2sjEBDJuN6sicEhPmlnhQgpqe7bFqcGQ3NOgSKbqgitbazbClb4FLzlvTVrNBDEDzejjH4ExcC5AE4XcsNVWlulFh0gLX9KrZkY0PFvF17LESaYfCDXyk/fvufjw1tz+LEn+t3cf0YpL1yA+2P5JX397deOv/QrxuWvw4KWZ8P8t62IKE3eXwu3sot2bmT1WEN+N0TmFMOekdWco5WA6yOHQwNGU4p6r3DDWTqK4qMRQ09Q69rB2g31K13n24A6+6V1G/+OHobYLHTvcSnQStUCtCjGWHFlQ3QyZytdXX4iNv4j3Xu2Vii1kXrYczRbE7ZWeP/wxLZmYvSkFPFeN/c3Nycd/5apHGIgOE/bst53mhVRWyc3LVqoO0h5nyJVnTAmJmgPjroIa9bOl41KvhR665y9YzsZJeEUTVzzhggcAoR+LtpUEIkxkYuOf5FGSrPdky1/RNrumBcHrjd668TuaWP96U2gbWKChzqia61sOSve2fvr+PeKA6eb69JEG80MYRchnIOcC01g2/Jf9f53EJz5G1LY/20Z/7WUd2MT64Pf3X9jUypdiN7y55x77ih7sYmX3hWbTt+LBt6F3R3sgtsRo0dXnYrIWlDQLMq+Y612l2y/intqdh94zyvmUu83bacOPC82mKlosLe5ioCjHrh3ySJ6vzo4mDjgM3XjG4aAuqPnR/PCfuz+KnYqJTmYy7rt51LPt0YmNONiu84Bs+p2V6H33jIV2fMaebHmlNYMDchzYRZz6psT74j5HDmPwzE8xODh3N9dWbZ/xfaru6t75LiaYDjwsMPpPD6vWrWw2VrjfL78qDd5+k7Y+2YfXz1evsKZi9zoHNJUuJNSaM1RS6NR6HOlT0PMLUTnKZdIz03XmpOH04QTjU9wtoZsuYFr+NBxftHrqKljWBt9ogp4fbtezIago1QQr7ntlrFO7Lh50vtqRZtdqu4hFQPuaGZdE+kUL2jbp0fizFY2Lr1Q18JMVzpS8dQifCyPfP6LLzl/fGA6JS1ye08Qx93dHWFJJLv/xxRwDerjk1FrPN0666uMnG91AHoHjU6p1ojsPc53et2oW+X88UJwsLbG+Zyp58Lb6Pnsk8zvfe8VN69n8IkYdE6FpM8chO4CLrgrA5xJmyOl4USZgzovdd1feSAkbaTCnP9GSo53CUlKdPG4HXVcmyfnTr2cCfMEPtJ9MkpDppem+xEXqP3qFB6pCyEl8J2SK03gBz/58i9qa4/fjcBvXAD88ojk895RyvNivTpIgjWONM3aM0fLuNeNv0cu2CggD9Sn7I0uwfJnG13cXkwf7sFxrwLMFaf5VG5k8PbOPM8sy7K7YTraNyBN76vNNyOsXcWE1hpbzkxYVmAtexNRLYW8ZdZtQ6TtOVvOGfXD7vvf+/TTPe9rCGUDHSii58kFj+vesv0aaZrwrdoY0mbfJkJK2sy/5czD4yPn83kXLKo5rsc5iTExz9NeTD9+XkN4UIfjtK93TstJ63O+7Z9Zq1aTcJBCItwE1suqe3db3yxLsCikFVpjniaW04nL+cL56YmfffEFvQunm5urSyhoFMJwTc3LsucbjrWRO8QJ9N75+PHjX4rI+t0I/GYfDw8PXx6Fm6M4J8eMaBP9j2LWEADH5z7wkvua80U24FEQHH+O33+JAB2vNfCYj4+PXC4XlmXh9vbWMi6nfUwOZ+CxkWE4CEspTNPE6XTasaXDbXdEW5ZSOJ/Pu0vt9evXzzIQj+9xCGZjfhnnYzzn8Xe6zVvDsThec8yhwxE9RPZgmaTOOT799NP9/8cxHYW58/lMzpk//MM/ZJ5nPn78yI9//GM+fPjA7//+7/PZZ5/tc8QQHEspzxDHI0NxZAQOEX/8zlHUfSkMHoXf48+NPeQxL/LDhw+UUnh8fPzL8/n8rc3/jd1sf931HTfo3DUAu48ClcizwXfdzPVneBpMcpDRibsHl+n3LpfGulUino7XbvxtpeJINzfE5PEhKX7FFXXUKIWO0xKUC9+uHbzB0D+uQ4qBKeiivdaGjx6xDrPaxLrp4dIab+4XaunWARwIoYOPBNFCcsfhO+Sihajd0t870pWLrc40DcmWBkxBtRxveYGMoHm15XtDXeRabPMSKFKJkw703irnXJlSJDcraDUtZpWsrPCWhSaNx63w+HQG5zTgvDt8CpplOAWmlKhrwaMdQdFHWoVeMqRGVDw/kot2PCN0H9Cae8GL0Jwn10LqjSkFtpTUxeg8uRee1lU3NtEhS+XmNvL4AeYbuJ0SNKi1MyctBhIhdMWDVTtN+KD7Kqk0r91bwSuCJeI0pwFDAWXLHwvebtbqMKhOC4YhJmIK1K6ZgoKZJaJ9Vq0Y8i3igi3+S8UNEdaKnd45Ko2Oih7rVqldiBbMXLes0ZS1k7ziDnOrzF5D3FfJrJcVaZ3kVZyhNmWix8RTKZrF54Jh5RRvgnhDRgBiWBMrACm66lpccgO7C3vHujWLafczIyPwivLtexfr16l/v0b8ewt89resgb4dIuDz513XlS3XvTO0CrhyUZGNe/ykok0zkczbgn2evt632LQ6qLhdCq0mvOUFpilqYbeZIJf1N9w00Wohi7L2e1AnYAiWI+RGoHffUVXNgXNa+JKqzsLutLA2XNA+WlYGnYoQui5mnWFzWtXmhFIytTQ6lnsXBGKkVm0SKEXwobGtmbyu5Fxxq9/FzrUK7x/OPDw8Irlydz+zTHeKLp490zKb+0fnzTRNw9gEXVGmiunSosmgKaYY8SHgumbiSRekqMDlWrWxFMhZu4YfP56RDNNppkWYc4QEk+V9dtT9o+fKEyZdgM84tstGmmdyzeTLhX4rnG7v7d6jSJ6Oo3dPjI7a9N/dCQS9unt3g9VqnZXQbLyHGgmzpzZbAHQt6skQOw3PGvDUA2a0A7UolkUvsMLFSEULn9Fqoear8DcZfra0im9ap8g5c86XXdJLy2ewviXxGZGFwmqC4NUWmDBX4EEMfPsrBLxfLfLxNQLh/68C/m9WYbOW+vNrmftaLB4oJ2cZPK0JPmoRN0av9bquIlMp6pPzLtLMEZTsWvVOXdrOmkT6QF62Rgge8R7XND9GmjAS5aSJZgH2Tkg6/sXWQL1rFqwT2V0Kip0ulKJZoc6r05YQtHNduo5/38hb0S7fXFhXbRpxzrHmyvunCx8/PtKrcHc3s8wJ73UOmpYJFxSH7R17168aFRVbHoIW6Wupmn2J4tFDtC5pW+hLAaTiLW/Jh6A5QLnx+HCh1c40z0h0TFuG6EjB2fi/Gnq688RJsSVzcORLIc0TpRS29cxy0znd3qkrvmtG6hAXYvSa0dlFx781vdC7fiYjY8yDeO2y9s0TpkgTR4ge10FK3TGrmDPRW05iPzSzlVrJW6XjeHxa//zbVtjvv43jP+e3ar51u0Nt7FcA3aD2615Euuyo8yHYj9xkd9jMhxiu722IeVbAUzqAoenc1TEg/Yr9dGiO5xC7Rt7gQNfq+9VV3I6YHaKWHYdIPwiackV+moPtGm1nOFLDB4c9z/BahPMjS9rwn7to6q8uSHUjPRfdBqJz0DJ073I9bm2OctrEYzlq6ugTXUP1K67U295MswYxNGADFyxryJw+VeMm9DPov7QwvWLSRoHC0OJ757LuF4aUK4aP185kf7jeTPAbn8shT7G2ur/vPUdVhFaU0HB+fPrRd+P/m3+8fffxZx1tvtN7gRXSW6PVTKuBkk1IygXJi3niRTO4SkFqQ1rGE2kxkHsnOM2D9XRcUDx0j1Gx9ltBcsZ5R5wnvBPdtI6IE4sHoNg8ET2kUVhS134PXpdd0rV2URrbWpTcIxpNEeZAj46tGSmg6HV42SoPj2e2yxPho2cKkSkmHgt8/v4Dn//0C/pW+N1/9JqbecG7Qjh50jJB9CTUmZjipGti52nbxfY6Gkmhude6mtEoikDwiucXGpIFJxu+FGJQ4sFWNFPwi5/8lLYJ080defaky0KdAlNypIFSLpUUIi4ETdUY+9XibHMecAjBXJJabNqUgOOiNjgM4RVUnCVY5r2eV91pOPBCSI44RcR10inRicSUiE6o62o5y7Ou76RbxujBmRwDtRkRqTn+w48+/7Pvyu/f/GNd11+M4q2KM1bRsPv4aArJeduxcQN9bQLi3uzSBtq/d3LHmue8xthwdYYN1N0Q0YabZryWdNlztKQ1lmW+4ujsHnq5rOS87U0vI3trFJtHMX6413LOXM5nts3bun81LHfYBbLz+czHjx/Ytg3vHNM8XteR0rQ7i45Yy/F6OWdzywdz/ahwGELYEYLeOYoJqo7ruiGGaJl+VxTgEPZaa6zbSpNqa4Wx5ji4boAQ0y7EDQGz2/p9fJalHNGekLwKEa223WE51kJiDXzOMhmdc/ijIDByoS3Kp9tnOZyGF3v93rtlh7vdyQXw/v37v/hu9H3zj48fP749CjVfJwIehbsjGnRd1x2reXTIHcWgl7lwLx2BL51xR/TnGNPn83nHEI855ObmZhcAx/zxUnADdnTxwG7e3NxwOp32vc24HocoNhyD0Vy+t7e33Nzc7Pmex+M6Ov7GPmEcx2xzh7Ns0W3bdhfc6XTaMwYH3nOcn1orHz9+3OeAeZ5Z13XHZx6bLsa5v7m54cOHD7sY+OrVK7788kv+5E/+hH/2z/4Zp9OJdV35gz/4g10sHaLoOOfHJoKBDh3v76UD8CX2czyOWYjHr4+GkNYa7969I6XET37yk//8bR5XEaeutt767kTyo5veZATnLLb6IPz1IRTufZh9R8Iw+qv9FdPlrPtSpLBtilaMRbv06lqQBvfzRA9RN8pVnX/dm0Omdi6iuKbvvV74cF7JuSHeE52+Zx8jKXladxqQbZ07IU7qGOqB3Ar39zMER94yHXXqpRC4eX2rXSEq/Sj6MTdOU6LmingtbnW0wEUf+RVCXPQ5pRcGP0M89JrZ1pVSNC+oNb0BFxlnLnGugidS1kKVTmkFWuHxaTWxVLPP0hwJzdECXNYMIXKavRUFOsusrhrJEBucz5lldmwPG5IK8+LxfaKHwBQguIbEgNSOWzPidYM+E+mnhTU36rpxuaz05EnzRN06BceWhcvjxirw5ns3vHlzyzlrl/6nU6Skpq6fbYM4EwVCj3oN9UZzwRx5la00fApMadbiabloh56LKvHUhsQEETzqLCpb1YVV0K7CHtQZouYORaTRGxK0qJBco2DuoVbxU8R3z2VdbfPvqFVUcOzqFCi9UaRz2bJiJIOiXkUsa6oJzuv7kdZxk2EjcuFyWRE6U4pMKdGlk6JDWmNrQgzKVO9oETq34UCSHaGoBW63Qz6984SOOSKuDpVugp+M7ncTR4Yw3um6f+qWF9Ov3dvPRb5f8f+f/S1mlCH8jd97C4e4M3gL+XcrWRqxFvCJulVahVdLRVrUTXXTASQ2/hevWRKYjw+eRwG2qn9CLEhLtuA2zCPXbD8rBwGRWsVypDzTlCBEfIx0hLwVzQBD9OtBu3jNM4DbO2IK3m5A3Y+sz4Zr3TCEog6gagzubjmp3tPEkavmfriR+VUrzkWkb+RV8zwaYosKnVe2vFFrJniYb2amZSKlkccn5HWz4yqEkDjdaMej80ATguuav0WnN8VrdmE/JnUNJMWfdL1NxAlu46SZIrKxPTzy9P5CrTADN/cTpQlPTxttmVkmdT73WhXv3D3eXBpSdcOxrRu9F2vU6LSWdSFvaJ5k6B6cJ3qQ2JSy1DtSsmZmtkYPDt+1G1ybhmcUeKYicmsecR53NYgoltAyzaTJLoJAY9sKreprERL56UwxAS8A0ioZjTBRt6p+zaELnbxlLg+FFbjnM1IC1s9Ii46Nh/W51y8B57/1rTv9CoEv/RpxUL/33Fn421E8rKV+MRgDw+jh3XWx7swtPHI3RdTpKw5a73afHosenTFr1QKihOP4127zkjO0ZnOwLSwd9GpuHHP61VaZXNRr2Ls9p8L1rmhJOi0XujnMpTe66/TgEHHkorY+J5Y50bTwJZIpW+Z8viDAPE/qXOzCVgq1FKL3hCUyTxMxKQNQ6OTNxn9thKiFjZQma7zvOv6t075Lo0s1zHCwAkjQ+bFVvDg6gZgmbuKEOE99XNkuZ84PF2rVee7mfiKL8HjOLHNkmQOuK9lhDhOtOx3/QVFm3ju2NSOS8dHTaTQpWmygWyZIUifmnpPbdUw2oWUtAjXR8e+6ozcVSX2aiM7Gf2vU6ncBpFne0Rj/Km6MTDC9fvJWKEUdAOeHp3/321JM79+S1/i6x3a5/FjHtqjwZW9muNf6oQv4ugl83t3pLKNyFwWHwIdGIAzX4I7RNBHLW6OVitp9X3u5K4n0UDzgQElxewPREAW9V8HZGU5s5A8OMXAI5n6IZLuwqK8UrEClKE7D1tpO4tp173YnqzYCXdea+jV3Fcyc2z/Vkck3GjvVhdh3ZBnd9lOWT1SqjlFHv2Z8m5AYbC/ZTXwbx3j9PHTf4vzVNamfw3VhOjp/RxG3G9YTzJ3INQPSOuEwYjPOWZHj0Je6xz0MJ6a9r1YbXbR55Jr5pOfq4cP7f/Pd+P/mH1++f/xCDCPTm2JMunRoOseLKNUFcfiiDSzVJ3xwNOcoNuac83TvqK3TWsFL1ViGaSLOCy4GWi+UvGnOc1Nni268CnhrokpKN6IY6WiKuhf1XVHf3YFMuBZo20ZZG8rHL4jv9MlTcyB3RyuV1mBbV8229Z1WM+vTmQ9fPVJa5XR7QlIgS+PjeeV82UhxZl5uOZ0WFTGCp/XO+fxEF6GsG9477l69ZllutAYTHIFK8JPtWxu+D/qNw0WvDcWh0yv04vHdEdKETI5NPOu7R776+JF3P/sFrVVuvgev6ys+lEb5cOHuNHFzCvSudIEeZ6aYcK6TjMBjXeXa8Bp03DvfbdwqceRZOKfVlHTT19Rxuek6yy0eXDYxMDAtN7i54KJmhYlUSA4fFbeqc49eR93cf4iSpHB9x51fMvz7v/jJv/+u/P7NP87n8xfHAv0Q4sb6/4jAG6JP733P4j4KVkOYAjT7r+v+eFmWHYU3MrIulwvee25vb/U1gyd4bZQbYqSIXJH5w03Yr5l9Q3w8upWuDvzGtqmQmHNWwdE5mmHwLpeLIjHv7vbmlm1T9N+WN6aUWE4npikptr5U3r9/b2toYZ4m7u7vSTFd36vXWJpOp9Wqex27/3vD7oE5HW1tcVoWppS4vb3hg4mP58t5Fy1ijKyXCyWHXdAcRfXxOWljTrd7bduPdwify2m5NvoYBqvWxrIo3QRAipgQqrmM67aRYqS1yrrqWuP29pbvfe97PDx83HGE47OZ0kRK12tlYAxbk/0OOhCHvXd+/vOf/y/fjb7fgPv/l1/+5EiaeOnae4n2PQp4Y2yNMT9EpCEGHcWjl66/l/8e69KjuHTEbQ5s5fF9jmvq6MgdrtRjHukQtl69esXd3d3+HodwH2Pk6enpWQPBZ599xu3tLZ988gmvX7/m/v7+WcbgOB/HYx37oSEejoaJ8T6PyNDhiHsZUVBr5Xw+8/j4SEqJ3/3d393zCYcoN5oaBq5TRHj9+jU5Z6Zp2o/lj/7oj0gp8fbtW968efO1iNfRKDE+v6Orb0c8H/CmR7Hv+HiZAXj89xBOHx4eeHh44P7+nh/+8Id/+q0XAH0XFas64MSSxdhdRgNJaDR7ujms6G4XCa0XFo/o4o3RLNfxqHPGW27g45o5P2W0JJXwbiJM2tFRc0Wb6byip2xrk1uhi+fuZmatdzyci+I5S2OaPXGK6q4hcrqdmUKwjMJOrsU29EKcVIzZckdKx4VOFYhBBaDWO8E1qqhTLSWIybOtmZvThOsqkvnoSU5dJ3TowRFax8eoeV+G/MuIov7UykRznuo7Ic20Jnz1/pFcGsQntvNKmiakNcpaWGuDKtzd3DC9Wgi9I5eVIo5lSUzzRC+d2qsWFKvb8wW+fP9IIxCnmSBNBdDsgULsnVwSvgtpnnHBk5g0/NdD6Z1WFK3i58gUTjSgREdYMzxoQbWHiKwXHt6d+Vxgvj3xvdcLNRdW2h5mvBWh+Y7PjeBguUkkAqVpRlNwEY+F/TbAB2qFKVSaM5XHa+5Q2y6U84WQ5j2va4qOKhqELn1MqOqUVOSJueJCInQVpmsTWhdyFlxwpOgoYgjRABTHthUuuWg3sPkDvHd70PJCRyYtS0fbgJXWeNw2Pm6FGBTBVEW70adp4lL03C2zoWytSCF7Y/MQ/kz4tnLQCC8GzQyUgb4bxRGxkej6LgjCtRDlDhgk7YJ+8fiMvwYB+mvEwl/x+Ax4+9kv/+jHy5nzUyaap80TCXOwTbwWXpOdB/Xm6VzSWn2O/FT9xYTA8uwbfmIXAatvBJq6Oy1vPoz1goCYA6ybGKRd+NX6IfR9SG30qJ2i3llARnCEFCA4elRBexSWpHVFAXnUNda0W9hFyxAJwnrprDlTilCMXxq9p0umlsJ6USEqLYqyEaeOZoBpmbRTN05MScXHjr6vVirb+cK6Ze7uTyxzojev56sJvlS2NeOCugSTOK1NSKVVzSnppdBr08xUh6I0B/6sninnDQEyBd8Sl5yZp4lc1MGQ4okQrkjUUiq0TgyONAUqohv/qsKjC5q3GM0/pfglcEFoxRwXdg+SVg2Hqm7AMGkeKEWsa1gz3PKm7kBdhCgKNKZIqfYZ7ws6EMO0lSKsa6aaq68BtazPROfSKnWDEwWZk4qOU8QnxYI+XTbel3XP+7MGJmJauNhzpeVli+vfRPD7dS7Av078e6HR/4YXDV++r3rZ/r06ZQZ2z+0FXr87OMaYF1KKI1oTLyrGdbGiu2DC9hUzLiIq7ooVm0TzPJ0/jH/XtVd94O2Ge10HoqKux+K1yZ5L2Vo1ZPEodnkIsJ4ba67kWqm2EY3eIZKppZLXrPjfJTF5RZBK1aLZtESCd6QYSZOh/ZSzTiuV9elCLoXbuxPzNNGDp6ptAl/UWei8Ir+iHxlbTdFk4rQQWRrNqYswWPdiiJFWhfKUFZHZG75Wtq2wTomS1VE4xYAEcEER892Ezhg8ftJCpTOylzeHgIjYOlNn/i6WyVrEhEFtcGjtiih13uOTuhV67Tu+cJpntk3MFVpxXsd/SFHP9TVETbHiTe/RuVTWrSCtU6q09vT0/+i/QePgH4po8PJ95fP5P3HI5nPW1X1V4HQOCJZbq7k5es0EcwW23q6ugD7EJ7eLiK1pbACWixe8Q8Rw1sHvDjkVrFFkcPLPHGRH4XHfVI/7zEBX2vqryyGLYs8m9EZ0GPsxy/zrB9SmZe6p0Od3DKY3AVF61/3TyDXsGC7UXfnyQ9A0BF4wJLY/dAq3pjSO4TocbIlStIs5DMF0iLEmPu6bbFs/DSGVdl2P6r3X/rasVe/9VQg0Ac4fnJ66JnY7Nl2F1ueI+26b+oH3dE73cce8k2bZjGICQ3/2WWlx0pyK8tVPP/9/fpvH/2/L469+9vY/igjeagtK3VANaXQE6WfdaFUIIkjXKIdShRwKHo+PgSoORMV1Jb40fDQniUCrjbJdoEJMGlXQq9BpuCmyq/I+QTRHumW8967NNDvbuzZqa7qqDY2QHG5KtNx5Ko33DytP24XLpvmFUwhIL6znjfXhQl4b6W7mNN3Qp0jOKwS4uZtYkieFiWmxzD5zudS18vjVBx7OZz755IbTslBD1NVObXhfabXD5PHRE50K4mJ5wK016laQqiteibrOCM7jY+Zy2VjfPtE48V4eoBQez4UPp8z5sVLXG4I7EWati9CEdinE7oinBEvUhlRz4DmD/DAiz1zQpqtum3+bI/BoRnKvKt51cJOH5BBXcHb/DyngUqDki4n7mzZATRO+q4O7704My4N22vDQaiVvRWszj0X+9M/+8r/7bvR984+vvvrqPwz39r5eD+FZ3uxwoUiXXeCptRJj3IvsiqNP5rB3V8fZXizWe/+6PmpDngilF3UInk4sadnv2SmmXWwcrzEw8gPzB85cfFo70mK1p9bG5XJ5hioVowaUos6/gdK7ubnZ866kiaFGHcEHbU5A61mYQ/6ybjw9PpJz5tNPP2VeFnX1lUIueizrtj1rQOoo+WLLBXCKG81Zhc00PRNdWm18+e4dn9ZKPuUdbzgK8Dc3N8/EkRgCa87qPhx7iINDa4gR2uAUqbXpnrtDjIo3HYV9aY3L+bITe5xzxKTiZ2sZTIC5u7tTAXVdOV/OTPPEzXTzDKE4EKZHcUexq3WIIPLjH//4//7d6PvmHz/5yU/+41ijvXR6jb+veZPP87WHQ2/83hELPLCQHNaNY34ZQtjLTLzRZPhSSJrneXcEvxSbxr/ned5F56OTsbW2C2XLsjxz5o1mhzFet23bcabDqXd/f8+rV6949erVLv4NQfN4fDFG7u/v9+a6ozg5kKNwdQYemxqOguaekWrHekR0DmTo6XTaz/sQ8d68ebM3WAC8evWKN2/e8Pr1a3rvPD098e7du2d40pevfxT/vk4MfHluj4LtUSAcXz+KuLVqA4UJxvInf/In3+rxH9mlDRXyZN/SddtYjatHO1+HY/DYRau/0Z51wjrrpN17N7voAlM87x4v/OzdR+YpWoctTH5CiubmdC80MRyXGAI0RaLAnDytCrlaRkzXDb13kFtllUbwjnm+JflIb5XLZUNa5/Z20W4TPxGjuglD94QIhMjjhwtpTrgEtVRC9MTlxLZZ3l+IWuyTTtkaLkCcAjEFWiu4HrSbvBRzY5mpMkDoQhYN+e4E1i3z/qsHPjyspCly/vkT092Cm2B9LOTeCKjtfq0NaTC5bs6wyHKC9ZxxDeIpqWdRiuVoCS4EJgK3c2JeZqYY2LoGoc9J33N3M/RGaI04TfYJCtslU84bl6ZYs3TSbv7Q1PG0tUoplXQzQdCifY2eWDvvP6y8nhNhuqV7T5oTbWuI76xFuFmS5qY58FXFOJ8U1oLA2isRR3TQaIhTgWWvMkSveyunn03DRJWsN+7d5iMdqooEPvg9z0uzWsy96WCaLTfPq3GwNmEr2klMh8uTBq+KuT23bMKICD4GQlPE5zJNTDHQpHHZLpSi3WIDJxWiw/lO7Yprdc4KEHRzqbgriqkffbUcxphuVDRU3u140NE11feo8z5GrzlwrQCkR76Lhv+bH29/vYLx9u1R/Hu7K4LvWPn8y4/MJpo575lDoGehBSvyBnN9Nb0hne5O0KCF57l/x0eIR2EkDi3ZCgWGj7Xfzq3umI5gN0GKfq2bCJhiJJ2mPe+vdYgMfKQiXMVpsY0u9IYWly2fBGc5qj4QPWwFvAvkLnx42Hh6ymybzkOtCiF5dfFuhW1btVE2BqY5WqalIoWm00yQQg7gCfhoogZaRHNB/z/MEzd395xuFpzX7MAOtFyRVEhxVvSs14UwIVBbo20b6/lC61r4j1MkeM0BqHmj5Qu+VfycaBR7v41taUwehMi2ZcJpIXrPVjt1zbaJSkRvXbhNcD4RoydET60bpTTdsMSw5/s5K8zJ4PN3gaD4RAJYGCAiDVzVjNY+Mggx3K9dDEZwopmGq3Rew4th7p+8Yz0v69ny//SqyrVAVcE5xkRsBR8S8zQTfaDTuOQLqvNdr/60QEzrLgbyQs5bzRP4q9155deIgunFz/z6DMDfxsJlO5//WEQ6HhcMBzOIxuPFvCHnrhHF5gYyR6Dz3eZWT6ntmlPl1anTS1X0VdO1RUqBkKJRECwTz6pVisDziLnpNBfU2fjXAhPOMm18IEyOLReCj+Ra+PjxrOO/aKNKq0JMkWnSTIG8bvSm4tg0J80m9A4XImmZ8RIoIeNd1LEt2j3vg9cGhA5+mrm5u+N0q0ULqYr7rbmSpkqc5x2d41Xlt/Hf2M4XmlgHdfKai1oKNW/UbcX1gl8iba3kWlQAXCpzcHQnbLngTxMxeLbSFEc+xr81TmkOWCIkr+itUsilMc8nvWermqH30KZZfoO6sI9/ryKj5kIp7t3ZGsHj6VItz6zrDcIp2rX3pvdla9pxTl0h21Y0J6TDuuWf91L+p++K+t/8MW7v3//LTu+97+X3fVO5Z82ZK/fakKjFXTGxyu2Cz7CYhQOi8yqgDdTnaL3CXZ1mzgQx/LV40EzYHpvpUUR0XBGWw+Q2MgCvSzBnxSzrfJexb3D7c/tDUaMfihBXkbA/z75wbu/cH01rcM3+G8KjMyyp5p6qGNft54frtu1FFaVcVGn7/4NmrHpzBI7f07Vot0yxq2B3PR6/n8vxb8bntH8ehmPnej6fZR1ycPG9uN56H9EOntb0eZ135vTvL67TbmPfmjZRN0AX2NbtZ/X9++/G/2/A4/s/+Kt/nUvtS3ROhV2d8/WE6mhJMdJrN3foIBB5ShG2oFmAKUBzHudEG2q7p+EUv12KYT81ozdOiTBPOMuV78ETnGbVO9GGIGLbcdQIivovXV1qIviY8CnSA5TaaSFxqYWff/UVv/j5Ix+fCmteqbmx3N5yuo2Uy8rT4xO9CmGaWW5PugaIAZGJ+bYTbpVM4XrExUSWhpPGnCJuijQc4XTPq++94f6Tkxb1s+WSlk4vDTfNhDATnTJVawiULuTzxnY+08Thp4WYkops24V6eULWJwIZ//qO/Lhxzpmnp8zDfebkCosEtuwIacH5gLTG08cV7xIuRsIp7Fl/TkNCcT5B67hucR9WmaJXawCe6SEBG905JCVIEVLHcB+WWVrM5ZwILhGckh+cG4STgG/1GoVA0GYnI+3krVByo4njr7746qfvPj78z9+Nvm/+8fnnn//3ItJ7724U6Uexem+eMwfNKGiP4vnzfDAhxiH4XIvrw1UT4xXTqTWFQK9KdYopMjXF6XqLHAiWAbq76nvfHcn7Ls2cK8NVlkvh4eGB9XLBSkDkkvf3vK4rT+cngg+awSddcZ/m0BsC2+PTE9EK2tm+n1I03GVjmmfu719xd3u7v75sm7oaQ+BkeL+R4BQs228z52FrTRGAJjI+Pj6ybRsfP37k7dtfQO/c3d3RgWVZuL+943RzIpe8H3ewgnwxd1BtlemQfzZwpcMFONDpQ4zovbNuK1NSx7JGlnTDfAZiisyTiirruqoDy4STGJP9XiD4a95jPTZc2jGPvEfNH9TvPT09/ezDhw//9rvR9xtw///+9/+V6MLQvRSjjuu+l7l2Y00+0JZDJBqf+XGOGP/+uuy/KxXC/ZLDbGTSjWt65Ase0ZtDYJrneXe+DjTocAwO9ObL7Lqj2LksCznn/XvDuXx7e8vd3d2O7BzOwiF0H92S4/2ez+d9nht7hyEe3tzc7O/leL4HonQ4DZ+ennaRdeybxu/d3Nzsx/r09IT3fhc4xxw2MgNLKfzsZz/j4eGBTz/9lKenp/3YjqLe+HMU/47uy6Oot8c8vPjZY21ofH7jHD89PfHVV18RQuDjx48/+4u/+Itv9fiPtGuw6p4TZZsvdRNZt/y+gXVXcc8d8Tda/Nw7L7susrTLUhdbYvibtgk/+vIjy5L4/e+9IgWHtEwkkRKaP7c7TzriHEkiuVWWmLidomIruqLhS6mkFJjnCdeFYhsAxXQ6WtVAasmNBsjUaeLoXgu+0xTIblWMFrBtQq/dusW1CBWSpzf9fYIn4NV156FIw4untYw4GCEFLikWhK4d5rULpQbWvPH251/x9FS4vZmR0iB4lpuTbj4nT2odJ07Z/QFCXdXRF6JmYmVDtnoHTiir4Fzn9hSQFnjlddN7Mt51jI72sDGliV4r5bwRkmieX+1AwwVPySvtouiy5CH4Tq2oM3Qr0DpziIrrDLpZLlvl3iWmqAXDeL/o51IbPkWaCFuudPHE5HBFBZboHZN15pv2qIckKiiLD4poE92o+QiLn2m3UEojhhHDIKS4UPIZJw2sSCNyzbHEgzNlrRt2xDcNdld8QNOObhJeVtZSadIppbFVdYROs1PhVEaepGJqYwqk4ElR8WHnVTchKarg5rRWTBGoaLdo71qQiPbNZj/Xuwo5zmkRc3S4a6HHW1nLOp4t/0D0MjcU3ogxFugqUPUhRA08U38h4n2dm++vc/j90u8t7Jl/v6QRvlVh4+1nhy++Y5kj/0X6hCk21iZEIpFEQGhNGwCCEyR4kkTmSbF0+8P+2YBAek4IbRCm69wkTfUfQV1BMaJuGb2NE6JhIYu6xlLQ4nKpojg5L0wDA4gzMVBLbK2Jim5NqK0RugrIVYSQEuKEJuo0zpfC03njy1+8p2bNI9S323ThmiK+N0Kb7Pi95oxK3QPKXYiqifdVGyHahPcwOfCTR4DTMhFS4v60cHua6V1F+tZU0KQLkjP4uLssW2m0UpBaaVXnBq256/XoGrStcro5QQzI1qgPQDZGt4dpDnQnlCZkmXCihcfzlmniyXi6U80ujiwelyzTpeJ6VeEjQfeOXrU7Sojm7NBzUp3HxUCInmbugSbOmlKqlm67Z5o0z2UIClZyYADErPmT2oRcFP0ohgNtFLaycl5V3r5fNMOg1aL3kVogJtIUmSJMKfC4NR7WQuLq8kv2n7Ucxolp5r/kBDwMq7e/UvDjawS/rxMM07emQNm3/L/U2t7PU3gjg2X/LMRZ3R59D54TwugIGDlWonhk6Z1keXhiN4fQdW4tRe/divr21NZ1rDlhilcBWWTgrFSI8HiqCXm+qzNRx796WqsIVeByHuP/IyVX/DyhUGKdc9ykLnUfRfNQd3GxqqsYcwA52ERRwH6gR7zm/InzLKeZGBP3NyduFh3/LQaaTNpR34SWVZQL4ziqjv9em+JRbYGn+dAOWkdy4XQz6/jPleo1c6nT8QHSrOvG3ApRIs6QvectI91TtDqnGFJn2R0u6twr6hLsSbMM6V3XXK2p8zKMBX7QJqDgDR888IlO8WEO6IoFTSnp/S94c3lbrpkqJRTLeG5NLNuwmmgA5/P6g9/G8dK/4d//u3i09+//Xcnl/TTPb4bgM1xrwYSnsSlRxFvbxfFxUM4s+s6wHdJ0rTgEMr93DnsTF8MBv9kNL2zrKSsADpGrmltOhcK2n8faZBfFWpPnjr/dMcChqNANc9yve6s9W89fYxa8CiDOmh/Hc4z3GEOgNWGaAsfOaS14Xuet4dQTac+7qvshY9rmV+9lpG1Z0QRiSnTRfOzxHkahZHjyjpijkSs4HJuqdyrWVex8ebVS6+/Y+t4NhL19TYbryw+3pqdKNZemZZCO82s/3/e8IGfoVHYRU1fMmok8biuPD49//g9x/P8mPn70s5//2y/fP371h5/df6q3JW3EdTYGXfD4IERX6b3hbAxqf4vbx56v3XLgjSDRKj4kxfoKlLUipZFCAJ9o3Wtzr7MMeK/ifHcBejuI1CDdUSqE7sAFbVoJKsatUlkz5K3x1fsLf/nnv+Dh4Yl4e6eNt9ERlsT8+lZjIUoj3UalyATBG2reewdhwjd1+5W8ESclzcyu654kTtzeveJVjHx694pXp4kmhRId/XSLFyF06GtGQqCbk5ci9JIhV6RqVqgPGOveI7lRLyv3r+/py0JeM+dfeNx5BX1b3J1mOsLH9QnmhHeK/H66rBSp1CnRI8yxEyx7zIeEc5pFhjR1Qcexx7Xx2EUbOERJBz06fAq4SbP/XB0NQ6K5wK7jm2NOCZ/GHC97TquzCITQu+ZBN3WC5a1QS6UR+Iuf/uJHfPf4jXi8e/fu310ul6+WZfl0NP/sRW3bx4+i+Cjij4L+EHSG4FfMBUeHUssuHIr0HWOnCOy4F4hHs4q0RjmIC+ORh2AwCtW4Z9g/RV4Wajnz4eMH3n75FrrmYnnnd7zo6XTCOW8IvWsO1uWy4nBM88Q8T3ve4cfLqhhu55jniWWeqVVdN6dl4XRaOJ1Oe8F7miZyKTtidJ7U4TwahEoubDlTDDk48HpDhPzw4QPTNPG7v/u7dNF8tZwz26o40mmeyJZbPrK/QtCmxrFP0vMfdiT6KPC31vDmUkpTUvHvsqoYE7RBcjktaqLoqLHBMgvVsVUV4Z8zT09P1FpYlpPFJ4RnQoYYmv0oftSyO/8AeP/+/Q++G3m/GY8f/vCH//Pj4+OH0+n0yfFzPP4Zn+UQ745uwCEwf50T7Cgujfnium6UX3LRvRT/huD3EqV5XGMPkeqIwz0K4OO5h5B1JFYcsZ3jz2gIGO7b0+nE6XTaxb+Bsb1cLqzruovdR/d0Smk/3nFOB2rz+LPjmIeAeXd3x2aNBLVWnp6e9ve1LMv+J8bIuq6cz+cdwzvmhHH+hpiYc+anP/3pfrzbtu3ZfkcR9Oj0O85PL3GsL7P9jlmA/VA3On4t58yHDx84n8/c3d3x+eef/+W3fVzFYwt9t43ZlaxzDZinq4fIj9y/oaxYGIY7dLb6sY21xZvDK6Kuu73zdF0LP/zZVzjn+J3XN8QGNXSqeKILeFZq8KSu6IkcKmsuIJ21FkXNBd0IuxCYUySdEueHCy54pDRWySzLRHCKm9vEini1UcPocM08VXi9JMCjueJCiIHgHeeHlekUWWLUYpg0QnCacdF149wrTK4hvVGbw/mgRcAKaxWq65y3Qr5ktrXxtGUenjQ/65RuyblwOa8sd7fc3GmOX2tqXUkx0GuluUoKUDZR11+IeCqtVtx0x+1tIwXwzdEj9NhZTonldma2BUJ4pcdWs4Yity0jKMaw1YpriuhMUyRON8RgWEMal3NFxHOznPAxcXe/8OHpgmuak/d4vvD6/g33dydch/OlEJOnOb3pbwWkFbZSuKsnbifHKp05Cvd3Jy3ImFBM9zTviTvypxuacaMWzUsb3MzaNRcguGbd/dZNLFcMba2d6B3dObbSaLXSPdQKvqt7YitNi71eE+JagFyF1p26YmvnH336it//7A3v3n3F+WmD6JhuZm7miWCZZ5d15fGyGdpUNy6jM12q7qW8g14t+ymGHR+l408Rurvg1y3rwnkVMIFux+oOeTKj4xoR29BZKqd0K/Cqv1c8RMe1a/qzv4no90J4OGb7/arcwLdHCeOzXxIz3r6FP18+4kPks/sTKUGJkJputD2NGjQAOnTITkgTbJch6V3z/xjiH1z/pkKLz+yC0ppi/gia+SbWNRqhVE9yWhQIVjkQY4yK89pM4AK1iWZk+EDr2l0aUEFaulBzo1mBUJsoHK17tlK4XArnS+bD+weevnqPj9oNo6Hch+KNCcaa36MullILMUAXj/NCLoWyNjpwOumYTQjBCUQIEpgnzxQgGhas243fiebv5XPGTxMhKkastwZdkSm3r+6pXVimqKx9y2mNU8Sjcy1PK7Jt5AzkiqcxpRlH4FI25KxzsZ4Hz9aFtmZwE7NToeR0mgzN6vn/svevv5JsaXof9lvXiMjce1edOtU93c2eGZI2RmNANAwDFCnApA34f+AnAgYowBDk/8QwrC8S/NkQIJGWSBuC4MsnUTJImyZFejicGXqu5/TtnD5d170zMyLW1R/etSKj9qk+00NpxOrpk0Ch9i0zIyJjRaz1Pu/ze5T2WK3QVj6r2nBMEoLeXQKglMXqXh/IbcIjWW+KlhFTs4hA2pJ6Jhw9XrI0lIpgQFOFECVDJsa8uYXzI2H7m//jW7778ce8evOSh7OIf36aGMdBULBk1mXlcnnXDdsaKMVJ2PP/vmSYXbgmA+6/5isEv/dgQb8kzHch8Pq3e5fhh1As/Fm3IYTwhXfTR9fUUyW48SYqyfVSGmG6CFiVvmLwatkcPx3nt7k+yjVXSFMFQ9WcvEqBdkbQ1FlyZpXRIvAZufZ29G0MghvXbfsqhlQza0wsS2rj/57zm3u0cwzT2Fw2V/ICO5SeuBoTKRaMcdSqUboSQyKFJNmy3uKdxVFFDLBShPRO4ZvQXmrHc8gCIywr6xwwzgkyC0VNSYgATsZ/rpXBieiwLoGakWKDdbipUM8rZW1zsSTHbXAWhWEJkVIXbrVQHqo2cu9dIijwqqBrZRod2jpZjOsBaxXGCDa1VinO11qb4FLa+G/ucKSJBi3F0Fxqy7MuG+LTGCPujtyPruSHlIZpLrU1ZkRxYW8ZYEpzuSy//6EU0+vP2ev+aWxDivGLYfAf0XIhSxOepCNcbR3yPcuxlCKXhRZsJ7jJfX5foyVU1eafV6xlKbVlCgvVQ3eMTSuGVVUoWqOKjPvNhcsON3l9i4a4VFcEe7kuQLNMRHbHoTn4Nlxm72TVlEJDk9Yd4rPTWXin09cY3eYWus2J6zsiXy/A9c0szW14zUKs29c55Z1YeM1b7DERW8afUU0sVFsm67U4g+T01SunQnKpW8Nabzx9hKjvc9tGON4aP2q/1zcXiGpr17pHfPZ9bWuG/rsr5rTdP9o8+yp+Vi6Xyyd/1sf/z9Pj5Zv7F3/u+e2zq4AuTXxKQzUO3WJGMglSEhFQN0R/E9VTKtKfKx1eEjsSE8rJfaogc9WqNTlVSllQFKzXYFwbp43GYqSJmJSpSVCjMRWU9q25RVH1yJITpzlwvmTuT5EvPv8Jrz9/gXIe/9RiiuDuTRs7xlm8d1gn82HKTAoztXhKMqAzcUmEWcaMd5rjNDCUhFOFbCv2RjEYxY0puLSi84rCooyjYgjLSj4ntHcEb1FVyEWUiPMGMz2TOBST0aqS5kRZFcNwgx6rUH/englvziwlUVb52XE8kBI8nM4UdcZONxhrWdA8hMD8VtChH/nKoCrDNDCYSUQ/LZmOSpUWAlZbM4WSgPeGE9bIuljlAkmoQLW0fN8iQqaqGVWqNHUbI4vvKrlhVRmZL6QrCSAlyRuLIUkzYDb83vc//4OvR92H85jn+YthGJ6xE9X6/azUq0Nnj/Dr7dBd9NPavfP7dV0lZsO5dt8v19zeLBmSWmucMWhtMMZugoLqudQpNzSm0DC0uhapnXPEFJkvM5fLhVevXvP9732PH//4x3zr27/Et7/97Ybjy3jviTGS8xVZCIoYAiknETob/vN0PvP61Rvm+cLTp085HI+C2mtODWct3kuxfVlWaQBu2ww0gSy9kxUWguQhTuPE3ccfY6zkiyuleHh42Fz13ZnTi/ulFGKKG/Y058I8n3l4eODu7q6Jq60eZwzWGEIIzYXFdvy64OEHj2BIAzHFZuBQjMOIH7z8LGepT6prjENHis9NcKi1Mk0j1lmZz7W1XkqtbtqcYF2Q6QJRd5e+efPm6waAD6sJ4PNvf/vbT/dZfP3/PcKxj+/9XLfn1nXhbKN37HCcHSm8R8KWXRPZvrntcfZfF5r2c+s9EnPvPusuwS6I7ekdXdTav84ee9l/38daFyCHYdjEv3596iLd5XLZ3Ht7pGcX47oLcC9m9gzUvq3TNG1Y0L2zL+e8vU53Bx6Px22/usjYcaN9/O0Fyb7tv/7rv87bt283d2Z3bR6Px+3z3B/3xwjQx8jVvbC7//z6Z9M/43685nnmzZs3pJTw3vPDH/7w9/7MC4DXSAjFO8n2baJVt4VaW5aqFqbdvr7CXSQfcHtGLSICbuJDveJeGo7w4RL49MdvqBS+eXNHMoLZq1q6PG3JlFRwRtwma85clpXTw0qqGZWlC3icHMPUTm5jMEaREjhdCTnhqYATbrxui8MMThsSRjSDrAQL6BXeO9xoWFvRu0aovu2rFldVSgGt5GamrCJchM2flMUkKcIXCTMjBsFqrg+BeU1c1pn5HJmOAykK7q8aRVxnXq0ra5DMMoWIjbotrNcgFxSvLZCxyjJMmnHSeOcgRErO2OOAsx5VK7fHG1wTEXJWXE4zISZUDJTcxK1oQIl4eTM6wYz5gZITtiRiruhcSWva8g/zXKmxMhqDGxTnEIlRnAWVwhoz1SqmWshJuiYzIrQxB0bryamwkvExolveB1oTckQrR1hl8VGUla5NaUTEYDCUJphBSYlSelaK2ooJLXVSJmntRK215a1lIwtBAiElQaCEKCJ0LqQ1bEHDHRV2d7zlG3dH1vnM5bRS0RymiZubQfJdUiEW6SSszdUHCte6wktVFGPQklUvuIiaUVUKxbVPYmvDV23N4norApS2P6q5mbpiJFkofYyxWXP1O0zs5vWqjwoKL94nALp3BYcviXvvFwzf/ZOfpijKi/3gBwuOVxTu+ObtbSvAQ9EiBFsrn6Qzhlwz/noL2Yl/V/SnNg5ypCA4R5MbDpLmIEF0oZLEySuHNYtLrbRO346JpAdDQ1RgECFJTAGtKyhp0A5FIcf2ufd3smC9J1WY18jpNLOGwvk0C8NeW+wgCN2cMiVlFCu5JGLM5CUwjhNGO5SmZVNcoBimwTJosMcJbTXHmyPDYFFBivRu8oIPaRN4YwwlBeZ5IYaVdUmkVAgxU0PBed3Gl4gb9tbjvJPrZk00Bid5TSiMjNVc8FoaL4pP7Uw3OOuoaAnfXhOYRRYAGmrOzGtGVSiDxlPQIWFcFZfzYFsnbhT3T+2O2IY47RVVI0K/clLcTTlTUxNRGm6sF3878avk7v4s22Qw59Iy/iK5ZELIxJRJOVGyJFQmFjq+9snNU54/vWVdLyIAAofDwO3RgxaUUMyJtLzHVtuHUtMTYzcCblrf2EbG8hUY0J8mCH6ViO9+ytc/f0XJMK+fcJz+DWqfHLfxrxRVyb2/ltxyrYoI1rYVdkUJ2MQ/cQRwxQSWAjmLcK81BdVQwOJEtcqRimRYKtXEYwrKWFSRYlJoiN1aFNYKPjTVyrImTqeFNRbO54XLeaEqhXJOMvJyoaSMVoFSpOiQQmTwI3oY0Fpc6mFdoSrGsY3/aUA7y+HmwOhdu6dX3Chj3hvb3P+GHAPLvBDC0jC3lRgrZc24oTWhJBn/k3My/msb/yjIkJaEQrd6WmHQmtEaqhWpUyPYnaoMeY0sa0QZyTWuulJK5nKW+93BaxwFHYqMfyvNBRTJbO5UtVpFTC2Fa55tRxMadS0gtPEvDTHy+ermElUtG6kieWClFFJsQiCVmDI5J9Yg195mkGQ9X/6bP61z+c9CQf+/731YzudPb25v/w1x2Uvucq21odabVFRbUl1zrxptmiO0Z8L1uVHPkLtm37FlgCDj11xRlVsTUXMGlgq2Ofs2gauU7W/rljHY3q/l3HXpq5R6Fava32xOuX58d7l01hrJ3a5N6O6iW61coactDsFK4XDD3LR96+93XRhv/QYbXHNDFilpGOtzUt3QyFLA0Nv46tfPSsOjtq3JpYn2vIsu7Z9D3dLjr+9JczPKvLa8s3+9WHMtwrT3bQLv9T3qriDcjnapV3pNmydvgiVyT0jdaVzKJtrev3r1T74e/x/O4/ufvfj03/wLf+7XuoiuqqIWhTYK4yRaQlWoaZXsr8gWa5Jp8/pUiLliW6NoRebfKuWW+d1fS5FSpNRWNHe2uVwrOi8C0cCIWJgLNUgTUK4yHzFWY5xjQXE6Bd68DZzmwpu3M/f3M8U6xtsbEeAWQc+tszjp1mVlvn/g9vgEd7xBO0VOK/Nlhqi4OTqeOMV0N2GngbtnT7gdPepykozv8YBWCqcUXhtyCqyzoO1ziIQAcdXMC1SXMUNzIKzSRHwcPH4cKCmiSsAoS4qFdApo6/Eeapy5NZZl8Lx2J0pcIIEykgWWTisPc0S/OXM4ThQjDcBvXgZsVXDruHWVqgvGdfpBRRlLLavkA1YFxbbLp4EqTbyqo6qcRHrUKDnhtTV/lVJQKbQWLCuZ5uXa2FHIhDUTQ5T1V5U5RIgy98oV5lD4rT/8wX/z9aj7cB7n8/mHd3d3v15bMbhfq/v9t4s5/V7R71sd8VkbKaaTQfZusL4mrK2JtLtoQogYa1pBW5Fyy40rlXVZtjy/lBPzRTInrbNM04HjURx8gsx8wf39PZ999hmffvopOWZ+6Vu/RCmVGAOXy2UrZJ/OJ9Y1cPvkCXc3tyJ+LgtrCPiLZH5ppXj60RM+/vgZz58/5+bmhpQypQi20zuH957jzQ3WWi6XC/f39zzcP/D6zWsu80xOicM0MU4TpRTZH2vx3xywzkmzU3fHpcTlchbhzbqdw0numW4rustxu5zPLKtch4+HwzYvMsZsjsQY47Ym6yjEPsfKpeUitibdPndTVWgee8dVFyO6yy/FxOFwYA1ri/xRzTEZcM6xzMsmFHWxpeeq7QXAL7744h99Peo+nMcXX3zx/W9+85u/vhfG9ojNvWD3vkzAfs52sag74frP9s1zj4VAHs3J9+LSHvW5b0LIW86s2txsexdfF8gev+7erdYf+/y7jjDt+7cXDft1LITAPM/c399zf38PCN6z54n2Y9azRfdC6lWcV9u29zHR3+twOHBzc0OMEeccIYRNKOxNBT37r4uM5/P5ndfZ40W11tzd3TGOIw8PD8zzzLqu2/5JHeMqtO7Rn/vj9Vjw27tF9+Lf/rMppbAsC/f395xOp03M/L3f+70/8/d/24U/1btOdydj3dLn2yIN6VxVVQn/fhMPK0p8U5Klg/yNugILuVpxpLtaVVkcv36YCSnz9i7w7O7AYXRMXlCXIYHVhVVFcq6Eknh1f+LhfME7wXOVAjGKuOGdZfBOGNxKsuUohZTBDdLZsySF0hlVLbFmtJUu37fnmcPgUMmQDfiWA9FxPCkn/DBuLsCilLgJm0NNUtdkJZ1rQaVMNQ5V4PR25u2bi4R0l0SIGT8NDAfJFwwh4a3i9ZsTyhrc4Ikh4YxFq4oxMuM1urbOHoe18PSJQ1WNmTyDVaRZUJ7Hp7fULPt+Mx5kuWkgnGeSiziriUEcKVmJgJZCRFVHjBXrM64KEnWeK6TA6CzFBO5TZHADxSmS16xKE6LibnLkkqgth+ioLMu6clGW1Lok8yKosId4AibuDgO6FJYlM00G1RCNaEVJCV21IIGU5KnFVBE2CCgtp67XimXJmzMjaUGgdSeg/K10iUs2QxPSciKl9rklKejmmsmrFA7WRVyZOWdqrlgr7cdrLChltuKk8Z7D7S05ZZa0EHPd8IJddSxa8slyE9WNUg1TWhqyrGOnZIaz3XLq9UImOU3dxSBuwyvOSgpaqnemorY+ctq4VbqNWwqo8m4J4vkfIy68T/z70u/E0vTiZ1Iurm/4Rz9YiMvC62eJj+9GjpNnshLkbhIYnVm0NIAWkC/eGwLYxI0mAm4FuyzPKQbpBu602QKalgtYWpRce4IyTnIpGgrS6HbMq3QPa9U75yVjLqbcXCfN7alAW0HhpVh4+/qB+/uZ3DCAaMNwvAHviAURnuaZeUYCt8mUNUPJmBvBDZcMRhmGw8Bx8gxTL0gohsNB8udCwKAl20sbnJasT+cctWRGd+LhzSs0MzVeqBGyMhQcJRXSmsnW4D14xzUnqILXEJBuPAZLyQVTYHCGPFlZOAySm6Q02JZLOC+RNUi3XgxJFtdRCgVVFDaYV3IyuMnivKi+NV/zklJzR+Rcru4E4SFJpts+c0F1JKD0C7QmcYrWbTEh4kUugmstQE7i/gst+08bSwyJsESIXaN7DjmzxiK3zQjFgnGew80TCY5PF0LejZyly9UyUCLPgWXDfkYg7gbXi6YQvvgp5/bz9tfvf7zHDfhTswDdz10hsgIxxB+Ii6UXkkEVtRX1Beuorw6P1hlaiwxuYwQ/W2qRfJvm4s+lSCdUlY5z1VxyKHGnGHQrSouApLYFh6LkVmzIcj3WpuEEjRSpUki8ffPA/f2lYYArymq8P6K8JxVx84XLzKwUxjspYq0BUnMkOSMOAa0YvOdwGBhH21zJinESnj4hYFCYJhpaLQQB6yyUwuJPnF6/Qq8zJS3UVCjKUpEO2bQmsjF4p8CJmLCNf1VZaTlZxklTDBXvDRmHsQY3iPivlYz/UuCyBkyURqYYMzlX5riijCDEyRU1B3I2+FHyRqlNfC1yF0vdvZPrhkGsDX/ejJ6bw0dy1EQczEi2cG587dJcQTnLPDXm63Ulp9LEPxELUspLPl/+3s9rMb/+d/x3H8L+rPPlB7kUnO0L7m7+bQ2GjVai9x2fXXTSV2eZbn0k3aUmxQDEZa711nhVasvD412spVAATHuuLGRLFje+uPnqlifYF+XvOO92olfeXGpXhHsXB/dZJu8WImTfBX3di3RNhLwqnDJHqZWUq5BEtq5pESK1MpvrWNZjdcPQg4inHVGqG4r8ihGV+6naxXMbsyW+S+vdJjbKOjG3/dtckVTB/at6dSl2V2EXUZVqIqTs94Z/LrXDUhsOlE3ko72PNPs1YaB93wtEpZRtP2sp7+BCqxQg1zeffv8/+bM+/n+uBMDPf/JJTu1eQMuzbGskazXFOKouMItjNcdALZqkKt44/OgoqhJTaoQOcX/ZCja1hYBgLlDaUk2BrFpenSB1q2oF6ZZZX5WhZCXiPEVcfLagrKLawuUU+PGPX/Ly5UxIlTUXaYz96Bn6MBFqZjnNnN+eeHAzw+0RKKSHGZMU3lqGyVEzjMYyHT1Pnkzc3XiMrmjnONw9ZTAOzvfUWLHTEaUcKhdUyaQYCM6znu8Jpwd0mClroARI0VGTJxdFXgHvyEPBu4jOCVUDtg6MCiIBUqA6aamejOXmdiCoG6w3jAe3YROPh4mQEw/rzBwSMgWplJx4iBd0uCEriBQKM2M0+KPFjhaSETZ/kbpRpUWq5Hb11uL6wxshNcQgeYuqN/1Jt6Byg+QEKtOaA2kiYCJnySNDGVK7969rkLVE1bx+mJd/+Uc/+I++Lrt/OI+Hh4dPv/Wtb7W82XY/LVccZ7+2P0a9dfrLugaGYZRaTLuH7RGd0jSYW76cbdEtQgrr7qBeGL/OLwRX19Gh0zQJmtKJEH65XPjhD3/I9773PebLTEzyN0+//YTb29vNhfjq1SuWdSXnSIzyHiFEnLUcp0nWIdpwc3vL3d0dtzc3sv0obu9uGfywxaNM07ShBLtrZ11XhmEgxcSrWjhfzoQQCDFyiIEYE/f3b8VpDzhjca3obqzZiuYdJ9gFz3meKaVswgJUQZ224/nQcgO9FwHVe785l7qAEUskJxEutdGkmAhRRAjd6mTzMpNywjkriG8ruX65iLuoloqx0ixQTBXTQ5tP9KYkaabK5Ee48xhjExDtXrBYvv/97//tr0fdByUAfrrP5tuLPI9xn3sBsF8DHuf4lVI219z+s9/m6XuS3E/BR/brwl6IfCw+dtzmXqja0MI7YWrL8P4Z3Gx7RGfesquvY3RZFtZ13VyADw8PjOPI8+fP3xHhHotlfR96fiCwOQGHYdj+znvP8XhsDQGW0JDB4zhu15wuADrnGMeRtTUE9PfbuwP7z7uL0Dm3uRy7a7PjUvtrdxHxfeLf44famjvLlzCvIQQeHh64v78nhMA4jqSUlr//9//+//HPvAC49Y52VE5hy34p9C7W1hVTlWSKNWtFn1CpJkbIEk1v6Jv+vKpaJ3nVgmOgdWRKpieXOfLp8oafvDlxMzmeHg88uRkZrJEsnrYqrRTWJRBC3laVUlhKnM8r0+g4TI41G8IlQLIYA8u6SlfOaMjGElJsRaSRZc2EmLg9jLiDZ7k/ocis/kDRGktpxXwtTjOtMEbhjacUSCmiKxhjJa8HRamSjVNz5fXbB169vGdZM6UoqmkOOq05xyCuNGV4OAVBMzqLUxrjxYWjlbjijIbBeW5uJry3mMEyOY/OmWosuhisWVE54BaFtg7IpIdZnIqDxaG4GUaKrRAdJRdizuQcKWUkpoQqgjMdzIgZBmJRKO84TAMHaxjXhewco7G40XN/uuDSijEDtzeOabKEJVN0YRodlzWxrAnTXFShCCLh/iGyhsTkDUefWM5gh5HxbgAUNmfBK7YiTdaKQiaHltvipXUvZ7PhaFtEkgxupVBDuxjE5kLVUvDXyrBEmaSgCrl1TdeoSSmSaiXkSiyZmKTAMDqN9YZLyKQsOWshJSkkY1jiyhwiyxoavURQMUq10PVaKNaglAOTMK0z9VrAlMJUKUVyJBEHkuANRDos73RNNyWrZfspKqrIZGfLqYCdeN/Ed0B6XdX7iwTvywR8Hyb0xU4MfPHf7iL0gxfwgxev+O5zONyOfDQdeHI7irvUGErTOHVueX/5igA1TWHRA5sVUBtZx8vf9nwXrgGnnfEoiiLaQq1O4lBLQjdUqjYi+iqjKS0rROvWTYzoqDWKW0VrizWQa0IrQdiFELi/n7l/c89lCbIf2ohwpA0oTYyJGANhXijAeDSYyXDwXhx2g8ZYh9EOby3jNHBzIzdIqxU5iRwsrmwv59Ii+5VMhbWSTWE8jkw3TxiHgXj3hHVZCGGmlMQSEzVnVisI4IGILYFxOmK9R2ktTH/buoM0LNGhTCQRGLBMh4nRWyQKqDRxAkIugtXRTXArmbJCioXVaY4jxFgIgFstw80g2a+lYJQINq2Nn5pbNqRpiLFOoG7jQdtCik0YMrrhPhtOFYlmVVqKtC1OhJQKa5R7Sk6ZQqJgOa+JlYW4XOU16w1ziKR2boUUiQUUlpjOzCEwr3EbFBtwc2kDZOf0e4cBulyH1otHQ+3FTox/wVcI318S/9xPFfVf/Pc4wfjvshAZ5/mflVZ8002c00oQedpItmrTgFsGbN7yLatSlF6gzh0tLfmW3toNpUyJaCUNE6Znbu3EZ21Ua/QRJHOtScaeFhqALC4hlUS8RO4fFu7fPnC+rIJmNkZw6MIRJsYoHazzSkUxKMUweobjkcEYhsFincWMHu8s4+g53hwE060NOWVMm7cpvFjLF7lXJl3AFLIpDIeR6XjH6D1xeUKYZ9YwU0pmiZGaC6HhvgYVcdkyHg5Y7+U61cb/GleSUqzJoYwhlUwhMx4ODF6ySXu+b1KyfWuMmGTavTRDkGzVwWqOA6SYcReFG3fjv1asao1mqjfqZEoRh6be3EaSs1uVZCPGIIztXhzOpaHaEGRcxzCWlj+WciGskTWm1kFdqBjmZf68lvyjrwv6H852X96+/afU+rdKrVtuZaVeMZdcXaJbZl935W2Zdmq3yGdzCvZ1Tt0Q6r0I0NSr/rwuJm6NVoKnr00s3JzFleZI2SM12TnaZG1V2nWli1xV9U5ctXMJXjkrVxfs1qEpomZ/j1JJtWyI9+7061mEpjUu9XWyUUrctLqNoybkdTGQwia49dxCpa7b33P4lOrNetdmjA3HWq/Hrrbg9pxbxuJGl2HDs5Ze1N19ZnlD+qsN4XuFl9bmJJCf5Vp3DsA2J965/fqcWLqlc7se1GthSWnCsn5WU3zx9fj/cB6///3Pf3MNkcHL6kYbI2OoZHQVl6yyE6kWckykHLFYas5EV7GjQ2nFWjI1RVTNlJoYtMErJZjoNOPrNSfz6o1tmZNGUZUXFH8tEqORFco4vDNUEopMKoXT25nPf3zhJ5+/5vX9haQ11VmUKRjnKdayzoF5WVkezhQMGMvtkyO33/iYG6O5vXWMk8c/GTkOjuPNxO3TW4bBySokZHQBFRQleOoC9VKpdUGpiqrizrH2juFGk0hMJG5MIYwriUhgJWWIOWGUZQqeYT5ghgPaj7jxwFNl+HhyhBII3nKKihdvV9YSSCpzuLvh9mZq6NPM4BU1Oc5rYM4JbwZCKOQcYDaEWLgMhmdHQ1ojLsL00cTx4xuMtqgk261MBS2NWT0DWbXGJ3H2XZsPqjbUokDn3VyrNYgZJd3BZGm8pZIR9GqIiWWNxHWVtZ9yfP+LN5/HlN58Peo+nMfLV69+49feg3TbF+T3ebdd0CutyNIL290l04v3uhXmBWWZMA0d32kReecO70Xz/n1epZDsnGMYPN6L8EetnE4nPvvsMz755BO++MkXPLkT0e94PDKOsg68XC48PNzz9v5tm0PA7c0Nh8OR29tbPnr6lHEYUEpzOEw8efqUp0+ebEXyfYHb5CsKr2eMidBpOBwOjMPA7e0tv/StX+L+/p7LfCGl3MSCRZxBbR9zKXx0c8Ph2J7XsH4PDw+SzbcslFw4n0/EEDfHT4yRteE3vXfElLi/n7f9dc2ZuAmsSmO0JsSIfpBMsJ4dlrNgUXV73dPDiXEaOR4PaNVRrlJTsE4Qrb2wn9vnLtnG6h1Bogs+QgESAbafP12IOJ/PP47xw7n/f/2ATz/99P/bx91+3O+xnF0Ye58AuHez7sWgPTq07vI9H7+G3pFA9qLZY3HwMZrUOfelPLu9c3DvFtwLgO8TI7vA2be3P6+/9rIsnE6nHfJYxlTP6vvRj360bVN36knu6LsCZoyRh4cH1nXdhLee69fdd9M0vXP8ujOw7+v+OO1xp1306w0KXeCLMb4jxvZmgT0+9DH+c/9Z7UXU/XmxFwX3GZH9un4+nzf3Xxcs37x58/nlcnn7Z18A7F2TVBHadOumrHQp79p52RZgCihKbSHYvRcTffUeldYRt+FDe0C80vK8thiWxaMU8U7rynldefn2xOAt0zjwxNuWUVWpuXBaIksqFFUlh6/hvNYgTrpxGkhrZDpYuflZt3WwjNMNS8iEorkdHcscSCEw3o4MgyXHTFKCmFJFAmidrhAz+u6AmwSrVdtFJAHUiDJOkISlogXmT1oT95eFyxwbCkcKZTEraoniAhpHKZQtifFmYDIa7Tw3xxGvJOvLWIt3gjdzyjB6gz/e4pyFnMmnwHqZSSGQ1wJVYdQqXXA1I1KV4fj0DnMwmFIZlEO13LTxqKk1Edcood9FkH/GWXLRfPTRx3JuhIg+wuGjj1jDQrhJ+EWElDUqctIchgFrDVEH4iXiB0EmAsxrwXgRU8iKNa4sQeE/viVnTVwX6lpIRuG9IZaC05VpsOCgBsmT1EbOlxQSyqiGC2wCXpZFgpAhBPeBsSwlo1vnX8hJiimqSv5egjUIciBHQYCFXFjXKM6wliHlvOfmMDG6gZO5QC2EWDitM28vA2VdWNaVNSbBoCoZIwrJLJTChqVqcbCU0nNJpDBSyFRMc+d1N98OWVWLFHebm4+WrdnV9oro67pJ8FW1YlIpIjQWMN2t23M83/d4/jNeOd5RK5YvP/fFz/K8x0Lgi05bZHz+HDeOPD04TIvyywnJt7JtvFm6vYqSI9ZYEQEfuQSb6U6OO/kaHphBm0wpRkZJgVwzpuiG/5QJptGG0jBjvcGhNOug0uIwck18VK3LrFQ4nQIPl0QoWdC11rOm1oF2AO8F+5qdwR6PuMEz3o4cDhPeWoxG0DhK8r+MsUzeo3XL8QiZugbKHMlzpKZELVJMpHU9Oq3R1uGPE26yWC3F02l8wu3tx7jDQFhPUErLPYrijFIaO02g+8244MeJnBKZQigVd5pRGgZ9wQ4epw2mQMqSY9DdumioOIqWcVazdCVXBDXkgGVOxAxRaaxTWAWTs1grIkBORXLMkF4SYzUlRUpqOFatBR9NEWGnituwiBouY4CGbtSaouRzCrln/wVKTtBQoSFdRC9rqE53O3J7nBj8gD5JEGWIcFln3i4zdVlY1yD4wkdy3FWiG79iQC286G+24UDf5+r7aSJf/9uvdvz9PBca8+nyn+ec/32jrZMutqtdpRbBBktWV0vpUQ0Z1ecmTfwRQ3qGlpmXS8s37vlQPXO2OQK1qtSqr/lhqC3rotepXWtsUihyThTg4Ry4vwTWVMBqjLaEXEi5MHiF95ZSZcFtjoc2/icOB8ntNQpcC2y1xmKMZfS+IYxE7KpLJC6RNIeWK3vNwKrUbfwPxwk7OawuMv6np9zePcdNnnU9yz0+yz1Qa6ha48ZJGhZKxfvMME6Cx6Wy5ow7LyijGE4KO1i81uhayEmKr8Lo7ehBQ1WpITeLuLRHxzD6R+NfYb0WpJDrLsfacJ2C6q5Z8IIltsJMlnlkLg1Lv6ESC7VKDmv3jaTcINpKkWttDVCZGNPm4qoVLvPy/V/EYv6HvG3zj3/8d8u/Wf/3ulRf9RVZ2adIfWznIl2p+7w63SgQlYqxZpeBJ0VkmeZdF+45i9OQ/rqt2YrdwrxfB6RR6JpDV2ptGbX77l7eKQ7k3AQ2WlZI7zLu17rmTqXU7bol4pVsf3fsyaJYbXhMtkyHnYCxe642UnDb0KVaobXZuSibSNbmOFtOXlvj9fPj6rq7Cqeba7Efw5TRRrcmt94Qp991bbTiRWl2/+7s3FyFVgn+uzkq05YJqraMP7WLrajUlpuqyTW19xZBsMgEQRzg+Yo3FeF/JzxSOZ1On3wt5H1Yj3/6//uD//N5nv9343DjjdFkI5EKNUqmk1NK0HUlbJmvRSmMtRhnUVbm+TlEim450SpjvSYrJd1iuZLJaBPl/hBXnDU4rzF6wurmFs+FWqLMGavGqIJudY5SE2vKvHi98OM3M+eU0YPDoJhjIuYIh4nj5GX8TxPjc8VwPPLkm0949uyOm2HAa/Amo3XBu5FpPHBwA8PoBck7L8RXZ/LrE/HVmXReSEtDGYYk9KBSsH7C3R2wTwwqJ9xaUMngmCiuUl3Lx3Z+axa204C9fYL2t2grqHH1TMZOMbAomN5csA4OtuLGkaMVNHmIgZRXlJL8LdH/J6pOjQZU0MsFpUYOx8xYLPEhEUoi2BU7Klyu3Dkt8x8tzeYlB8CiqmTEE4tEOnRMC1CqIH5KLtQQ0EWhnW7CbRP+lKbaVu/JmWUNkpOWAsZYsjH80Q+/+OTrEfdhPT75oz/6T//Kv/Vv/W+11sM79+9W1L0W1yGldp/tSMB2f+1F3154r7VitNnEwF4kDiGSkjjDuoNlnMat0USaDtu9rDUWGi331v66HSt3Pp05Tkc+/vhjye97OOG9k2bcGLHW8tGTp0yHA7c3Nxxvbri9vd0K9H2/vPccm9Nu70hc11XiR+oVf4gS56L3nnEYW0zIwOA9H330Ebe3t3KdQDJQhYgjTrpxGBjHkcPxKNFCiKvwpj0n58zlcuHly1cMw8DLly9RSjCa1Mr5fGFeZon+qOKYLlleX7Z3oZS6ZX91RGlKidP5zM3xiHP+mlmmNDhY9NLcegFQDdsrLidn3bYm64JPCIL1dNZuGc79s9/cYu182ONHjTG8efPmj74ecR/W45/9s3/2X/yNv/E3/v1aq9uLS33M7vPhusD02CEmc+v8jlDUrwldXHyMBn6MrHws/r0PHdoFsC7+vQ9V+VhQ/OMQpP387Y7VxxhQENRmF7H6+x4OB8Zx3FC5b9684cWLFxsW+Fvf+tY7293dfnvnX3fJ9WtB358uDvbn9jH7WJDrwn939l0ul00UNMawLMt2PLoQWGtlHMfNLdif39/78XHbC3yPEaqPcxm7yCkNGA88PDywLMuGG/3e9773C5H/aXvFo6re694RLfWKaumL44a3qd1f1E/g9reCGOwZDApVRWyoSlOxZAWqCCCmqLbo3vIwWuZgw7aES+S0JF6q5nDZK7hVobUsoENONJIUqSqMM7CsxFSZRitOKaMZvSPmzHpewChCsJyXwDg6Uobz3HKnsqZoWM8zMWYWBYNP3BpDVYoUIlVXrHVtAe82gbSk2JxJmjVnjDOUokUUGh1pSdQYUM4xjQM3Hx2JS8AFz+Dg7jChjWO69Xg9CE6kJskZNKMs3GOgnjP3yxtKyKRLJTycxB1XmvBTS8u7qpALCs3htOCdwWmZCA3OMIwDZhrQXqHdIAJKlm7Kkgp28gy3E/H1iYdXJ4xzlMuKPXrs8UAsJ5594w6tnhCWRSbfStyKxSguyaBKwjsLSkSBlMBbg7MQ14IdbUOROqaDJxaIl5XjcWjd3eKuVLpSYm5FkbyhLSvNJagF9RWSIByg8vDmwvHJAVUKaxaeqyAYC1UpwpqxCta4cr4s+NbJnLPkHsZct8me0RqDoENLDNskbz6fmY8TBkVCRMqilGRRVHG/dkEulYKqhkLZ8lSEYV8kz6SKUCQ7mbskiG4y7tbJ3sX6ur2JOKDUDjHVqw3dvdtEQq12WWp7se75v8LV4zEW9Gfpl3rxx6uKL+Adluh+07753e/ivyHdrzk/FgETuomAujn/MOLMs1by9kqUjjEKWG0o2TTNsJCJGA1JyceQYmxB8XCwIopJN74Iw6V9NmhBYqjW9KCsJqEIRW+CkPETuQDrDCUzPrllGjwMnsVpvJE8Peut8PudTJ610s1VB7pAzZI/up4vpDkQL0HGRUqyEG4FzRSLoIpLxmrDYRoYpgEDOKuxzuKGCX/0uMljjaPmCNlIvqqT7LOiCnGNqJKluK7F5edd5eOPLKPXXG6mht0TFTrP8nVu/E1BqEDsRgYN8RIk18NqsF6Od5WsQ6MkW8yrLqyAMhllZcGvkL/rWZ+luY5qdwG3AmpqaMBqxMGdm/iSc2kYyEIMkkuYYsOFSiIsKbbTqkUA2lvRlGtKlLACCxm4nBbm46XlBUo2ZXx0wvfvl6WbAK/Owsci4JfFu71m/lgQfCwz/mwi4F6D/9ddkPwTvX/OP4gxfTZ4+ytSSG4NSLkVfUpFme6OFpefaoty6wQZXXJu2D0tWVYaHNL5mZHCfapt/KcmClVpOuh9GKi65V91WkJKGVUbbs5qMppYxOGrqBjvJU94XaAWBu+YBgeDY3UGbxTeOZwT9M7Qguu1vqI4BaRQxDF8nknLSpgjBBHuSstcrkW2h5IpDVc4jSPjNKBVxVtxK7pxxB8G3MEL0jDJRCo2V3TQcv+KS3NLAFVbtK4M3vLMOwavmY9jw+7KPWWZC9o4cm3uTC05TWllc6yndZXCiTUo59BEcpX7YoqFai0emktI5kHaSJOCqoLxFei6iH61zQ0FwdgXS60gYkQETFkQrq3O2/JXEktIgjZujq+C4nS6/MbPcyH/5wUB+id6/xB+vM7zj9zt7Z+vzeVlqtk+f90FJa2bsWyfDbLDUTY5S+su4InodM0EqZL1XQpGd49pd7GJqHz9Xq4pcp0xm/hemvOwi2ZdWL5iLrsw1bLy+oJ/V9ikuVRrKltzEUoKX70IYYwmxowx+hri0J1zTczqzkPJ1MtkJc0TsnCXNdn101CyZqu803XcGz9p191tndidkK35s+wzUnpzZy27Qs01z0fQRQoxTNRNpDVNNFTNBdkdkL3YsV/sXzu8Za1Zcm3bsCsIdAG0JcL1okptzRp1wz9f/53uH377ayH/w3q8PV1++MXr+88+fnr4Va011iiS0eikpEEsFYzXGOPQrkoDirPY5s7RxhCWlbgEjK4YK42jsRjWpeX9ZVBGqDIxRi7nmWEaGCa5ntS2JhRnEVRjJKM2FgiRQiKbylIMD0GzBiEK2GmghIp68xaN4sk08uzJSL0duUyKUVduj0cOh0kaAI1rIr246S0KW8GkQn514uHlS04/ecn55YX8+kw8n2XNWiHFSl6TuBxTZnDSvHa8GzElYkmyzHQWRoOalKwzlMEahY0VoxXmZgJ1hDlTz5HqLWr0WF25GSz2lwamofL2diIj9Q6qpjwodNGUalF5ZXAKOxjSRWHwGONY397jJ48+HiRzUS2EmklhxWvFwWqy0YL80w5Slg7WjgTJlUqgVEU1jqpkDldzxagmANZMKRGrHSiJJEipkoqR7O+SWGPkvATCssgqWztSgd/99Ee/9XXJ/QNrAJrnzy+Xy49vb29/pRfDdYvBaB25rbBu3inO92JwrLHl+oXNsWKdOPpijMQQiCGIs1gJwSeE0OaV+ZoTWKTY3eudpZTNQZ6bg27Lp4sRbQzH4wGlFZfLhXme+c53vsPTp0+ptXL35MlWaO9FbuddWw/I9zllme80V9/r129Y12uWXdnt/14syDnjnefm7pbj4dDuyyKqWSsYPT9IU2G/7xpjGLxnGAcheKzrJpx1J58fBqbDgePxwMfPn0vDb8vSFIdSptSVGCWL0w1+cyUppXj58iXOOX75l3/5KvS1+tYaBNU6jtJAYM3VrReC4EKjlnzAGCOlHecu+jSE34ZU7wJFPx7745NilKaodlz7MXz58uVvfz3iPqzHy5cvv/f69esf3d7e/upj7OfeBfhYqOvjcd8A0MdL/9z7OO8u3/63fU2wR30+zvHr59PjbMIuXHVHXBcA+7x0/39/jf1Yfoz/37uX+7WpOwn3guhj0bH/TXcOTtPE3d0d5/OZjz76iPNZsj2nadqcgTc3NzLOvd/G/P39/TYOe45nx4F24XXvst47Gp1z74iB/Vhd3cBqQ45aa7e/6b/bOw/3+7UX9/ZuzceC6mPXX88k7OLf+XzenNzOOT755JNfiPu/LVxhgBo5abOq6KLeERI6ArS2H3T8kgQ0W2j5MJWKri3ssrbF84br0YILFWYWWkmxujbEU61qa17VSv621iKFpN5JXgpGNxRiUVSDdOcZRVgC8WCw1rCGJIgskO6dcaAqQ8gVbzTzspJaATmsoSG0EmjD6aQw3qKNFL9XLMsa0EYY2uPkO7mmuRDb8rwqqlHklFDGgs68ef2aeckcn1pUqawh4dGoUTF6h2/OnsGBx+CnA8OoqWuirCI0WGvI88yagJgJywPL6UKKAa0M5Ezimi/WiqWCuCqVXAJLDIxay83OGQYs6u1CoTJMnmEchX/e7LZ6MJjDgPrBK2JK5JwkHw8Yn06MB4+iYLVlPBr84IUPbiQvKetETAmCJRFRBqp1LBjCEvDKkk3kdFp4+uTIGtbmyKrMby9gNE9uRmLnIlknVbsYJfur6NYhbK55HvlaRFBGMd4eGhoRcmq4NmSxF0Mi1sqqKiWK+Bt6gHQVt1EphdSCIFURl4IfILaiQsqZ8yXwcJ45HgeMc7KwarikXAu1KiwVY3sGjRQgS0N+diySFK1rE/v01shda3Pl7lB2tDwTrVpmDLRiaEc/XQtUtY3pnr3SEl94JAE+EhLiTxfv3icUPm/OpT8JMOH5HycIXmWK/Z/cLgu3+dAy+963rVfhb3tog3ZmQ3/Kfw0Hq40IVSlsUkn1BlVEEco5o4rk3aQo+ZlKK2It4kzWWsKyY5ZsiXZkY9ENRRRFxJ4Ea1NLZhoMgzGC8jWGoZGwnBHxryNHJaMLUBZTYZlXYgiCN1ojKURSlB2qmoYQEuRHcVAjxJip88z9+cTBSOHfGuHn28FhvSCGaAJjg5phRg/uIsjYECEnrNEo7/DjgD0YjDcchpHjdCCWSCqZNSQR2+aEyokSEyVFyeyqGbTBKMeST4TLTFhv8EZjBi3OoQp1SdRx5DApcgv9FvEtk/LaMj0sGE2J4goqiTbepOGBDQknRdSSCzEVYkzkLJ3C6xoJKRBTFmG/XcpjbsPg0jL6nvcFaGYYYEVMpCnCw/nCzXnkeJzQdngnnrLLeWN7uYWF5ae6AGUMPX9PBuBV/Nv/H98rFr5P8Hv3ufFfGQH6IRQVQwh/WKbhV8xeGNsw5fXajNQEuiqtueje4VsF9ap0z0XVpFKoqeFBasWjNrxdTmKd7pNGZw1aK1KtGCfOGWMkp6aknt+qiFURSyGlSAasd9RcqKfE5ByD1YLMNIbBKEF1aVn4K61F4EqSNYzWmArrvHIOkRSS/FsjKfUsK0Gz13aPr6afo5m6LLjTiYNz0u2sDdZorDPYwTOMbfyDNKJQsONAdRe5X4UIrWCinRXBcLJt/E8cp4lYMikn1pAoypDnCLlIDlMuLa9PrFbGGELOxHkhLBGnNdY3ga4Uyio50Ucjrl6twVhLSZmcVhn7zdJdUm7ZjEUcgE1QqWjBfhURM3LD/cWYSW38L6tkoIQoHcq1Na7lWlgfTn//QzjfP6RC/oewLcs8f+94c/PnZU2iWrZf2bK33Q4D9i6ip894rmLXJgKWKmnoDa0gYlLZrhlV1dbpr5t4JfMptTVcKfRWALhiOrfv9TUOoWyL/bqJZbkJZBKJUJvoJc0N1w5gJQ7Dth/9vUvRjzIC1TbD22eT1CaCmebQs1ZvLmGtvow73I4hgvHs7kS16Z7t2tszd7sZu2FCez7jvpihjd65psV5UXb5fjJO80a12Gc5li46bk7EfeGkbjVgpRW6Ctp7I2O0G0Ev1naxt/fPbcbJ5hBWwKsvvvh6/H+Ajx+/evP9/9Gf/6Vf1VpcHdpqdBKXekkRUwTzaZRpc2eNdg4/jSLexZllXrCu4LXDVEsqhctyIeUKJZO0ZdIyTwihoLys6cO6UmzD9RoF2qIBqx0lrxL9QSErx1odgUXIPKViDiPGJczryt3keXbwPL05oIzmyVCxpTLYkXEYsdqiYqSGKI1/1kIsXO5PrA8PLA9nLm8vzPcL8RKJKZFqImhNcXJfLgdPjpl4WainC4eHtzx5YXBYTAGjC8aCHh1mdGg0FpkXmNFgbkG//AnVvqbOKywzdpxwd7eMHx1xzyb8kwPPjk94cnNHILOkwBwSxSXKKTEvK8RArhlFENeesWjnqKWyPsyEORG9Q90olpiJCbhono6Om0njlZEai1XokMl5lQ5W5WVO0Qr9cn2TaxVolLMoY1BVaA6lIo3la6JiSLmwhpU5BNaYyGvEekMqivMa+Be//71/8PVo+/Aep9PpkydPnvzKvij+2FVT8jW3q2MfuyDXC9hdIJLfZy6XdcvMoiG4tbri8NZFXGa98ByjCFDaiDvoKizV5iAMnM9nTg8PjOPAxx8/p9TMj374GTfNjTcOgtQbxkHm5E2o6DjNXgD33pONiBQ93+tyuWyOO631FZFtjDRAUVnXwOV8YVkX9Oeaw+HI0AVG5/HeMwz+HQGuuwcHP+C9a469QErX4nx37XjneP78OU+fPmWeZy6XC6eHE8syk0thDYE3b95KI/UOoWqM4bPPPuMyXxjHke9859vbNpRaef36NQo2AVIrqbNIWTMJFYQW0ZIhrpEchazkvd+EwGmctnzkGJKsxUreBMV1XUk5M3j/SHgpfP755//V16PtgxQBP7m9vf3V/fz+sVuv/9vn93VRb4/67GJUz83b59Dt8/H24tseM3xtONDvOIp708FeeNwyv9t14rFjrV+X9ojTvWtxn2faRUnJ3ORL27MXG/t7d6Gtu10PhwNPnz7dXIF7p2N32+33IaXEsiycz+c2DvM7guNjBOpjkbRf0/o+dOG145S7GPtYEO2fx15g3DspH4t/e4F1/7n0bQ4hkHNmnmdxZ5/PnM9nYozviKW//du//f/8hRAAu5OKntOgetiy2vCDanMCqm3pp9mJdpvgkK6CBkWyAqvgWNCtKCNlliZ+yIJRRJOyW4A2h+EmXMjCWxAxrdNe2W01WjJSHIqJlCSHwqrGmlWIjV3YNlijKblufxNzwSGD7eE+4AeLPzriGhmswjjLaQ4cl4B2hrFlZlTdAsK9xTRxEi2d/6HI37788Yn7hxl/mDjcTSijuCwrgzFYJ84FXRR3twNWQUmKYXDoVLm8XaEk7DSS1sD8dpYcscLWoZspxDlTKARdSbENYmUFZ0ZH6CiWmqXLvxZUhKhyc2Aawpw5P1zIgKoZrQzKanhzoUQp3td2QTVGkXIizo4EmMGg64Qf5aIRSsF5xyFDsoqVSFkVVltSgbEq9DQQciCtgfsHyzgd0EbyELQyhJh5++rM5B1+0FATpkoBsaqey6IFA1uhhkQ1PQNFCv5KVazT5NYVWWolra07c14JMaGdI5dEynLsqlLyfapbTJzWGm9gGlzDCJWto7qUIoHF88LBWVKq4nLaZVyKLlkxtaJVITU2Z6aiqahayVUKTtDGiNr8evJ5FYVWHReq22/U5qbYGLuY5oi45sdsWZ5c6b4N+HItLjz/aULCTxHtvkLA+OnPbcLHi+WxsvFThL8X733zhxcv+PZ3nl0RnzsXYOlSRwsIzLtfa/KWJVhyQmPlmmBavam04lOGqKWj3lpwg5NxnQsxBFAe3dCspjUxKKVbrldDCGUIIbKGINs0jHjnyKZgntzQI1MVWvIikazSHAtLXNsVULLKak5ybuZMXKSzLudMM7QK1lTmwWjTGhI0eG2p1qIGQ1pF/EzOU4Algy4ZW0AtBb2scj3OGVKmCMUYpQ2xBDnfumvIOsbJ4QeLnUbMzYCbPM56ahV8oHaZoWpytBgyKYn7VStBgZrB4SZPDJnlIh14zmhiTsSciUshBTgO4royzekl1DG91Tn7z7TYzymVDQGinMZqLQJJEvRvyRCWiNKayxbcLvtbWqCkNrDOy24YiCR3cI6KHPf9MMkRwrwwWk8qmfCe4bO8APd8N0KWDvp88UhZH79CnIuPxLyvEu/dHyMI/nwUGN+3bWFef1c9vf1fiMPFQEmt0ixOHGNlEld7Y05DeipVeruSuGFKQVfdmijkWi1if0UZg7EiJmyCXJEGANWbk5TCoJogoKmmYUKLNHiEVTr0QGG9xzuHNQV9d4uSG0gb/wqUQavW5RqLjCEQpHXK4kJOUryShUJzwnUhQF97kExzL1vnMN6hvSOtAWohGkNqWXiqFmwBvSzX8V/kfcil5ewpYk5yn7UGayzWGqbJ4QaHPQzYo8eNA95KQS4aMDYzjAabpOM/xUguqSECDdY77GEkrpF5kQ5pa1puaivS5VA5DHLOmpbjs4EIFVt+iOQ8XjOrcxY8vLIyL8spU2IiJunODuuKUoZlEfEvZnlOFfUArRXrZX1T5vnv/SIU8X/etu3ycP8vPnr+/K87JUUv3fLr2KL6rh3wqn2etRZpimlsScnzFKGqNGGrZOnIMsZuTWRal7a+Ke8Nl78WBIrcj1vTgbwnG/mhFwVjyq0IkZur7V2Bq+f1dYGtlmtRkd4s1jvDNnp8aYvouuFQuxu2ZxFVwLaimWSUakKI298ba3brtp6LqK7KWbs+9nkk23aqrQi6R5BK5AG7gsC7C/r+2eTdwtwYI9uizeYafuz0q+XqNqTWq5Bo9OaK7Gh9tR2vep0T57zDfMp5URqeTObQMuc7PSxvzj/80X/2tYj34T1+93uf/cZf/5/82v9MKYPSDqMj1RpKqJQcqMVjtKJaJbSHmEg2SfOnNtTmJE0p4arFaDnXSiqsyyqZXsahrcVbw3RzpGqh+Gi1kgdHNZIjb7TFGi0UEO8IRVB6Gc1ymZkvC7FW3GHiMHrq4Dh86xs4DU5ptBZkVvFHiIFwmUnnBWsUrhZUjKRZHIt5TqxnEQBiiOSspWYzObJ2Qs8AvNZMTjLDqzEsKRLmCyZFotaUqslrghjRtRFmUoFUUCmiYoGk0G5G2Z8QykooCe0MwzByOE7cPr3h8PTI+M2nuG8+xd7ecjiMaOfJLJRpoerC4BzB3bDOMyFHjPF465lGT352R5wTp9OKdRZNYlkXLjER5kq4u+PJwTE42/DMzZmZBYcizU5WVrGJJtgYcolkMnYaMH6kxkCMUY5PqayXhYolpMRlWVhyJSyBmhLaCm/ni9cPb3//+5/97a9H24f3ePXq1W9/97vf/etXpFvCWveO26RnwfYC9oaNbsXjXojfiwcxRpZ54XQ+URp67nCYcN5BZcPu9aJ7zlkQlubq7ukOm3VdWVbJ4nLO8a1vfYubmxtCCHznO9/eUHnWSXHdDW5DWO63qdbKPM8sLVNvw/5VqTv1onkvovd97MX2sQsEqm5ziC5opiwNeyEEtFZbo0+McXPibMV5pRiHAef85hrsTplhGAQzOB16gybeD1uRP9zc8PBwz/kiDpub483mKvrJFz/hsx99trmOeobg/dt7Ss4cj0e8Hza3pmliaBdze/5yjIkYIlorcXKVyjAOTNNIjPKZxHh1fxpjGjY17jLPgqDQtWael7c/+tGP/tOvR9uH9/jRj370W3/hL/yF//ljkWnv9toL/3s32l5E29Mt+nygC2E9E68LW3vx7rFzb78ueJz9t3f87bdj79bdNyU8Fv/6a+yFrcf7ts8C7GOuv+7j5oi+PV30TClxOBzeEfPe9/f7Y9Dd05fLZXvfDZE8jnjvvyQGduGvi6q9saFve0rpndzDx86+/rvupHzs9Hyf02+PV+0/69fwdV15eHjg/v6etdUB+7Gz1jLP85t/+A//4d/5hRAAVe19ng0U2GzTRTXUkqo9VYxrO2tpIp7eCk+gJXi5iYfU3JY+PehdAqm36i0iuNT2O92yHza1seYmQqomWJTNdVcqmNIKevsMEK0gVfzopd6pRRgI64I1A9oY/NFTlkBYVoabIzkmnDN4CilHTAKslo4f7zkMI3EOnN+ujKOjDr51iSpGYzGYDStTFYScqaVy/2omLomnv/SM6TASc0Jby5Nnt5RllWKYc3ijGAeHShC1JqVKXZJkGGTF+WFlvQSWy0JMUTI7jKYmWQBnCnNM5ERj/0JWEVMrKIuuGnIRBBcyCdZksq6oonG2Cp6VinGaGGTBrGKmEIi9U8pKFmMNhZAzeg2Ukhms5vLixDgZ7LMbireSRacrFkOdJHcBDXlOaAXHpxPx4ki1EpVjOS/kVDAG5p+8wTpHOJ0YH0aeqonBQKV3ADuKqmAkcyGG5uMsilJUyx7TpKpRWTKRSJmYEnOGEhNvL2sr4EaWy0rumLBcWZfMEhIKLVlLSQoczjusM4KJa93JGWSRmTJpjcQcNyxcrU1oa2JhF40rjlyT5PAVtYk9qokbteqW0SelA92QbleXYCv6NPGvlUQ6JFQyNpVkJcqPFKr0dJS6IbC+WkD4V3k4eP4VLsAX12yzdzSP9wqB7wsKvLoB/wfd5NfeVxMpVoSOnG2bGIPJkEOSiS6DuABBMKEIMtN25aw5mCkbTQStHc5oUolECg5BZMRccEYwdMoZEeqo4iRCsqjWIDd1Nw2YjvNpr6m0NCzMp4t05Leuc0q5xhfWTGpYo1oCeRXxqVE+5SraHM65ZBG+14AzBqsNOAQnai1Owg+xXkumV+ohiGUrGErdX4MzUkCMgZhmuQw7gzIGrw2kyOlhYTgbrD3jTpJJ4oYBRo8bDElpsLoJERPLEiBlktZY5RhHjdJHTm/OLHGlvE1Mw0Ahs+TCfD6TY+T+4NF6wltQ5OY2F5WzFBFINYijy5o2diCWgiq6XZcTIQZiglKyjMMsTsxQJPsnheZ6boLyaWljwI3C7eQ5ZhT3VMlNSnPiAMwspHAgr4GY03vO+6sE16Xv5SvP85/lEX/KmN0Lfe6Ped7Pp4iwnuf/Mpf6v+5NFgolSGPVs64KShkpQqtMzYVUI0HJPUyyALXMRWptDvHumMmUIqitWjXKWKxWkhVZwVYlDrFcsbpj/kzLt2oO1P34L+KkNW3iK+NfXAMlVebTLJkhuXm+SyFnKcpRJJujZMGN5Ziba6gLHmrD8qWWe1uz4MKwFmwV4dE6bGsosW3/Jd9w16iyjX8FrjmDciKGVRoUjBWMqnCROT8EhrPG3BvcwTGMA24cYbS40ZC1uO80GmNHllVDLFglx2sYDUpNPLyVgkHNmXFwVGBJmfk8k0PmeBgkx8RenT/aiEpfWq6YVuJy1M5Qizg3Uy4Nx1wpzbkZkxRBchYSQClZRMFWJO7uplphntc/+nks4NdfgPc9v379X6u/wL9XqmTZllrRDS19DbKXDv6+bb3II47BL4fD65aDd+1s7c4AJIO20xTa+9Q219fabI4/0bzUdR1TxQ1cN/xkKzS0hXovuO1zCjsyVGkhofRswC7i5ZTb/I8NrWm0aQ2BV/Fwu9qnjG1Yr47b3OM4+75LdiHbotm0ZjrVxEujJS9TazkWtSFPu30ux9zyWFvOUsni3rvaAjfs6VWsvC7SW0lFnPotS1DyHFWbs6oNbd+PZXdK9oKuOP+v3sDahN7SHcCpFUhVb97Lm1OktHtB/4zmy/zJz6OI94sgNP7G7336X4Vc/jfe2pYxLe4QpSs1Zcm9Nx7nDWpdmWdxpTkKw3FCOy3UmBwp0WFGg1OQqKS4EiKYWKnVYr3D+cwcA3OtuFxoPYIYIl4pvLIgoQ7EmklVsSyFh4eFJaz448BwnPBOQVa44xFdCmUJLC9eEbWWpruwUlMWEkEqQhSJiRJX8hopSyJnJdmFRmG8kAgolZwqJYIOCWMqVlUGrzDOcxgGyjhIlIgXV1yO0lhkyJIR3+gYKcn9kVLJMbLMZ9ZkKG7CeoeplTdpZXhx4fBScfjihuO3njLe3TE9fYb5+I7x6ChmpeiCHTR2OKAHC3NkCDAoze0Tix+f8eKzt5zOMzlGDoORKJa18Pb1a8I58uzuwGASU1U4U2TOph3FOBEAa21NkkUyCpWF2Ik4ekM3hrCSijRbxZShKpYws8TMEgvxMkvPaJFi4/c/f/l1/tcH+vj888//67/0l/7Sv2uMaYXb+g7WcSs8aw1N5NNabwLQFTcXvpQPdnXzFUFg+gHn3dZc0gvwXVDaO1+6aLcXFFHw7NkzDocDzjoWu2zCgmTy+Q1XuhcZ4s4x1wvb/T33zsVrEX23NqjSSNcL8sfDQYryWjM0YbAXxPdzoB510x/dZdhzuOQ46c0J2Av7e4SfUlLkPx4PjcIWUFqiDc7ncxMbpZD//OOPmS8X5uXC9z79lG9845scjgdijJxOJ96+fcPxeOTZs2dXwa8JB8Dm1iolt5+bqxOsUbtyaXEJrdmpix79OHYRuAueplGjHh4ePv16pH2Yj3/5L//lf/nX/tpf+/f6uN07/vY5dt3t1nGZ/Vztf9s//72QtizLJh51gXsv4L1P8HvsvmPXeLBHYj5+vy+NvV0DQ/9/f2163IDYX6uL2tdz2Gyv17f/sVi6H7/v0kP40r7sG/D6cYVr1mCMccOnsms8fOwA7MdqLwb2honHCNO9qLff/v1n8viYPEYf77+/4oPD1lBxOp2Y53nbhv6ezjlevnz5g1+U8bRx8voCjS4U1FZ0aY6zDb1SanMdmTYRbivjKg6jlhTTZD7dBJE2WJpgIS/QHB2tCFe4drmqlu0iJeqGH2187R4mX3VhQFOKohqNskbCuVPGUrGjR2vFss6kBM5mYg746cB0HFmWmWWeqVUxeemg886itaXkjLcOY5RoA16QEbloMoUUMt45cf3klr0DrKt055RYSaUtUKnM54WiMjc3tzhriQbG0TONI0635WzJrOczZRERqcyBlCvxskhnTi7EWihBBK6YpKvZqsJ5DaSQ0aWyOiOORK1xXqNaUbqslThkxtESY4VqsVahUyEryTlaVxEc/GjFMZQypu1nKZWaZVF9jlFY4UqzWoVTlkuIuKUyfTyhBkMpCu0s3kItnlQLbqikkMlrFreNcuSQSSmA9fKpK8PDmtClcv/mLI7IwW5gTK2lsC+OLcn/qqlgnAQFk+3mIy2pkEQDpmYIoWC0OEKNUywhsmQYB01c85YRFWNq56kUbJx13E4jkzGsGYrRgmarkGphiYmbhh60zWmam7tPlR4603IBSc29ockkcTBp0EpEbxlqakMsdUG8IsVn1fOneiGoFWpaRUrcka0Q3cX1HulZZQMwm2T+SKh4Ht8vYDz/iu/34sJXaRnPxy+JIj/9779aFJnnyM2t25x++9tXIeHM2HIgV3JIgnQEPIMU+kx3fSWKNW3xJ/z6Lq6VJqmWHKmlkDWkYpuYDiVrEXSLIAhLKzaFWLgsgcsqorzWEGkBc5ugh+CH5+skdutXKRmFkfy+VgAsBcH90sT03ATxDCEkwjqTd6Kotkjh30hAb+v9x3iDcx6lJVvPaMlB3CYdtuGGlEHVAZsavtQ6CllcSClTi+G0BsbVYFPGzCtez/ibifHuiBsEaZJNIZWKV8CasCEisV8abx3ae7kehIyuGTMMxFSY50A6B46HOwZnqE5jEKePMrZlkUkDSmzHKGUpuKaqxdmR5I4SQhLkX2lifRbBdAlZnJoxt+xIKNmiPSyXh3fORTc+54kfGZ0hFCgdL7tIMWhNkcIohlK3E/kencbiALzKfwsvHgFBH4nkP5NA/1gM3AuB7xf8PqQMwD/pI5/OfyfG9B+awT9rM4N3ck9rrYKq1WbDw5RUibWiJr0520qqkjdpW+G/1EYPUJvTrLZ8r1qyZMxWUFk8qHJtqFTdFv85U3Ib/2tgXqIUunXL7CoJsjjsYq3EmFGL3EdrKRsOmuZSqs3JUneT2F4Qr6X9vlZCSMQ1UFLdMpeN0YIrsg5n7Yb1tVbcd0YpcS70/0273xiNtmYTIExq9ydjxC2TMzFX1lw5h4gPCRsTdg5404qdTw5Y79FOXJQpC1IVJZ35WoEzmuI82kVClBwOVRNmGEm5Mi8r8bxyc7yRLESnsGQUDe0CVFXQKGm4ohJyE18rO8Gjj/9KLq0AUKRreImJVCoxyHV2c31ZxcNp/oN/HePiF+U9/1s1AHz22f8ppfR/8Np/1BUvbfS123UvqKnmUFMKtNkyQ69Cod4wnaXkTQTswl538imF0DNKcwRq3YZpy8bTaqOZiDDfEJ+lvNN5n1uRbfs/71A/WmF0E+Tju7ifdzI1lG65pNf8u76AVq3oZU3LzdSKsBUV+oyyNqHyiuJRWm3imTF6hy1iQ2jJ9sgraGO260+tIgaKq1K2zXTBteG3NVe35OYCrHJ901qjW9OEOISvz619HruJupuk215PHL5dJNRaU2K5HutOumgFQZCc8J5DmFtOqFKaQsd/wenh/vd/EcT0n8fHP/mdP/jPfvLm9Pq733j2UUVRlKJiUKZlcKeCmyT7T9fMel5YTpGHnKhaGtmss4S4EJaZPDmyLcRSWVZpvBVyiJyTRgJ1WTWs2uKT3D/kBilrz5wjIa6sS+Q0R96cVl7fX4gxYZyhtLwekyo6y/osrAvhdKYW1RayGVWyRBcXRc3NydrGfB205FkpQ88/nsPK/dsL57cPxItQDazJOKvxfmIYbuT+nzOlRtzkONwc8FaiBkY/MDhpGA25ECoUI2jtlDJ+CYRcJP+4VkJYmMPCZQ68DoGbNzNjqgy3M8NnJ26/9Zzpu9/AHCamwZB9xRTJ+a3akLVkCR+8oZQJ3IVlWYnzGQ4WfbhhSZWHhxPxzcwXz77BcRrIOTGpFVstysr6Bd0Q6aWj+ysVQ1VGHNZrlLlSyqSsyBhSzsTSjl2MrKkSLgtpXlGDIxcYlOF3P/3sD74eaR/m45NPPvnbl8vlPzgej8/2Dpl+j927/TryWeb3eSusd/xc/6d296dxHCm5iFhgjIjjITSsZi9Rlq2YrbXZkJQgwmJoeFC/5X9ZUha3yzAMgtDUUlNUuXwpn6r/24sLe3Fw76Dp2YV55wbSRjP4QRrz7LVg3p17vWC+Hb+GOzXGMPqRw/HIIUbGaZL9GPx2b085bRhvYwzLsrxTPDfGMI4jwzAQQtjWH118HUepSQzjyMfPn1NL4c2bN4Di2/bbrGHldHrg9evX3N3dNUzpwNrEQ7vD9PW5iaxXrs7J/XGKIb6DgO2/78e0ixnd2amU4s2bN1+P/w/1/v9P/snf/Zt/82++NsZ8tMdIvtvUpt/J9lvX9b1iVBd/uiDcBcAuHr7PUfZYiNtfe/q1qGMzHyMquxD1WODbZxbuRbDHCNC9i7FfD7qo1QXAfdbeXkx7jM58/PqPswe3cuTj9cdOEOxCaRck9yLk4yzG/vPHGM+9S7KP32tT3+NGTc3ja/7++vgYk9o/w/45L8uyCYAd+7ldM9u2DsPAH/7hH/7+L4wA2B0gG36mH3SB5m25FbUKeYVWiKF9vwXGsyl922vQlpyl/b1M0zRoJyJFafkTdZfLoTrhxqCk0t26cyD34leVrJrSsIo1ZYqvTINtBfLC8W5imSOld3nkLBPpmuWmZEeWsDAOE1krQoiELCw4nx1WO2LIhLgwDSPzeeFymlmD4mYYsF5J9p6SInrOhWVZqQoeToGfvHwDuTLdHaixYAaLspJlZYcRYxRxvZCzIodEWRPrHEhLIsVMkFCrlm8jwsaaKssy4wYrXWxLIJ0XUinEtp/WiMATW5exaxigsATcOHGYLMpoKcIby+Qc1hrmsBJLYjyM5FAwaPzoyak7LDOhOeliTlIsBCIKpyO2aiwr4VVhuDlgvVROdCsmmFyFN64zJRSykUzvcbAiWpGJWeFGx8OLe6iaiy8klEzAlAKVMEourGkL78giwjpDiGXL+4k5y4KvOQSKEuzZ+RxxY8PE5IUQVsLc8lkqLGsSbJgWAVEX+Ph4ZBo8OYt44azDaU1ognTOmZQrSleMalxJEkZrUsOA2i5nV0VCY5Csks3dZypWK0pBMi+3epJqGZlNkG/7Xfo4rdfChd6L6aqXx+WL3KR09U6+yyNV4H1iw/M/qRD4VZpeEzi211y+SjF8R0HZf/cQH7jh2U9RCPokQPobjEmUEIlBnH/aIY6/nEQ8LBCb2JZCQnuLJZNrIaeyFa9q0cylMFRxsfrRMmAoObEGKWznlLicA+dlJcQowfXakBFRr68TcsqkIgJUSq0ALdpfExcEV1naz3JOpCQCXWmZYjlFQnSs8QEWmNl7vl5gec4wNo10kdw6O454BxMwTQeOw8jkveRzZjlDjAdnJRPMGoPxDlWynNFFxMtIBmeYM5iYMSUTdMYDIYObBvxRHMNG067xrSM/Z2q25ARWOZQ3kAKxZJQxTdiDuCws88qcJ3nvnLBai0hpel6PjGsRSZLcW6oIff2WkqOI+BnJeszkFugun30JkglIOy1S3vnp2un59HDLYfLUiLjFjcEwAj8g8ZyY4ub+22cAjs8F//lVj+WdM378Y+TvP87BF/lyRuCXMwNf/ClPKv60i5jrGv5gHP2zaxeecC9rFdwnrXgPGqMVqeW96nY+ayWZfTQEXMiqLRYT1koORa5ZBLxWQM6xMNfEUCs6VYbBScRcToTWOCBojJXzGgirNA7QhSWlpIhQpfs+Zem2FwStiNu1XrO78pZVVYkphzWmB90IgzHlnHLROeUac/E5J1dyNVrLZKzWwmBssVoXo9SaksorpVpnpsnZ42CUPgxDG/+uOX1SQ4aLSNhxfNaJY1mV3gRUxDFvtTQH5IJZCqsujLUQioz/4WDRVuMdW55iyVncChlyrDjjpM0iR1IR7GhuSNW0rsxLYk51N/4Vxlq0ESxjTK0xRrOJM1QlCO8WaJravbkg84JSxBWQi9x7S0rSMIBCW8G7X86Xf/xnuXhff85f/3I6/b796KO/bLkujhVqy8KRYp1qGd3SaGjqY4yn2uZNHWe57+QXMfGaiRejYKhoTYs9OK4qNmfhlpXetkXyqKQzXzCzcs/KOUs2Z1s4a60bgvaaSZiaE7GWSowxzJf5QWlVvXM65VyNMb0FzBijvVLa1tbC3xbnWSlqyWVFqQzUwftJG3N0zuqCuopzubQCnSGmhG2Oh95Vv89QVEqaMXteIo2IUZv42J20qh3fnuNnrayRUNd9Vs0tqXbuzdTwrL3DTRvVxNS6O7l2OYCip4igl8uum7nRN8q1cNILl1KobbhyrdrfNDxTLrz8yYt/9PX4/3Aff/jDH//un/vms79SW8ZfbTm5GsnyVbR83jLg7YklLswPGTOMjLc3ODeS1UKKgTUlyI4lZubLiraKVAtrjph5pZZMLpFQLW9z4ljAqIIfLLpkKfivgTUGLsvKi5dnXp1nLqcLNQa0t6A0o/PcTiMGyQVPqbDGSlgiJSZUQwb3poXcaAApVc7LGt6eL/daSTFkXTOn80WfL3N9uCw6xjjkUMzofC01oFKuo3HlYE2l6HU+6fhSzdpPbvrW3fHwzaPXH98+4Zu3H/HkMGFNJcRFUMmDwQwOjcFqyzBM0hRYMlY7ks7EURMHzykVllSw9zOjywRVORaN/+iO6aMBPyqcUxhjpfEpzNRYqUlT1sRgRowLVAqpZ4RacXUub0/cPwTerhWTZd3qdcaUiCKha6EWRdGaVKCGKJShogTrnSrYQkmVVBTFIPECWeb/S6qEWAnnmRoz1UnTxBoLv/G7n/5/vi61f7iPh4eHTw6Hw7N9Tld3ePWmWdr8tTRnuOLLTpruyO+NKZtDp60LchMT9w6hnKWB2zf3X19o1lJJKfLw8LAVnUWEKKzrZXOsPc4Cy7m09X3aBIKOB+/FbiCEEO7bNqtaa9XNjp9yMjEEn0o2JZcq64ZalVJVa10UKtRaknxvDtbag1LocRiZDhNDcwfWWppLanjHKeWnEaMF8b2GdRPW+jErpTR69rV4751HG42xlnGHU4whbnntzlpubm4wWhNjIqxhQ6MeDgcu82VzF9EaLPvv90LCdr1sv6/IsTXx+nVvCHtXWL0KH11c6HWxzz///P/99Sj7cB8vXrz4/e985zt/ee/+29C/O2GqlLJlZnZhrudX6nZO93Hd8ZBdEO7/9u40ds2Fe2TlPvOv5+f153Wn3F50f4zafJ+bbf99jHE9n88PjwWulJKOMWrAW2ut1rruXH0lhFCWZVmBaIxRkzyOum34+97z8Xs8diX38d/H4L6hYMMLt2vfY4fm/n32eXuPGzj68/ZNjvscx8fb+xir2l9r3wzQP+d1Xbf81MeNFt0l+ju/8zu/MPm/ti+CUfUqBG7uoX6drOh2V+3NrlV1MaEJhApUVcKerwVqYvcC29v1nAjQV7eNFsehQkt2nTJbJ3wXQaSzVjCKCoVVoo9ppSgpEXPLcKuZiiEEKardHgZO80pcE9Z7SILWMm1/nZHiwXleyRimtkDNUQpH4+hJGU4PF6ypuDJQBikUaRTGyi6uKbVOOvji1T3xsuKPE5c1c7CawRtGB8v5wrxmdD2yLGcIgqNR1VBiZgkLlznS22dTqcQiTpxlXsXhGDOTc5CEdX3rjUyypWK4pbupUjBKUFz6Tj6LECMhJmKANc9cjJRR1mXGeM/pLKLpYRqxJ0VI0rVUambdONkiZuQc0VkTWsHVa0PIEMuCI+O8BIyXdvIoK4WSojTOWJgqI4qkK+t5ITeZzDhDiVUEkyKOCe0UqhhQ8jl33FLRGjUMxFSbEAdhFY5iQdCIocASEjG1rsCSmUNmWUQ0nWMUkGupIhS3VEvBaVae3k48OU6cLheIvVArRaacCzFmQkx4aySvsnPVaJ3ODRcqhSVLLO0i2F6f5uTTG8jz2vncC0o9E5Am4GmpeDfsoRyTRM+AUq0rki3byWwXRnUV279SzIs/XZfjK8S/5+NXCHvju897Xy7ge178+SMF8OEHL/jms2fkDP6RyCEYxwROzlNtrCBCcxSHlzObOJgQfAYYUmlZoiFRpiyL0kxDHkNek2RnHC2Dd2ilW1dhxSrBgs5z4LzMhDWQQ8OSIKqe9yIcpRKksSG3bLwgXXUxJJYldv0SgzjvSGBsF/0cOcHBOtw4oUewTLKPLcswh0RJz7AWBj9ugiiAMrCGxJwkEPvVHDslmTnGd7Rfj+PGOcajxSAZHdrIOWX9IGPUmS0/T/JXBLGZQqBEj3UaZS3KGqzyOFMED2osxhTGQZpB4ioCpAirAxfjRRrTZTtPjWnF1yxFwqq1lAG1JsXUsMyCMuziX2oLvFqlvz/EKBmK5VqELTm9I9qtIT2SwJ/z9Dhxd5w4zzOs7zpOWSA4cRp5Y6/n4qMxtex+eP3V9aT+YxI03xXlv/T1H/eIf6aKgZfz/M9vb49/uReA1S6TSjc0nnyr0cagVJIMq1wwVfDIJStKboVlg+B2i5xbNidKNYR0FfBKiGQVYfIMg2sFZ3GNGy0NRvPSxP81koPMB0qVjEI7eJxBGldaF1NOrSswyT1kCXErWBtjRMgoFW1QSutnCqVKTNwMPjljs65KW6Ws1lpp3VKYY6SmgjUK7x0UdWyo9ILmPqT8yRJjWkLIn59Couqaa7FrDUcDHymjvTLaeW3MjXGMo8Oa5vxRAg023kuB1WpS7bm7gbpkaUYKQfBqDR2sncFpTzJZaBLGYExh8IIk3ca/hmFyzPeWygwqdwggRlu53+VCzJWqNFVJw0BKguFWSjexT+aLuRQRHJvAF6I0MAmSu0rzRSqbyFOrIqS8hPuH/+gXpYD/8zj+zw/3//zuo4/+sjjnjThxmpBlTEsnrwVV2wKjFkoR5++7HbWI4F/qO4XE60L4Kgba9rqlVnTdOdy6YIVG6WuQvTQ3Sj6n6RtYQddC3+DuEuyYlJTilkfXO+ydNyiV9TjePjPGtmi7mnLOxVqjtNbWihjIngFqjTgTtNbH5uQrtdb7ZVm+F+McSi4lppxiTFnWvvZ2GPxT69xYa7VQTb++qX5dRQkVpQmCW1d9lhzffuxyw3iS2NDnlSsOVSm9ITolr7VhU6kSM9AaJnK7Rqpe6CuyPSnlbXf787aO4e4KbJmGHRXaUaA9O0hrQZF2NCrN8Z1zXl/94If/8de5nR/u43c//ew3/+2/9Gt/BSpKG8H9NfeqUoqak2TcWocbJoy+sIZEmFf8dMA4hbGGNSxC7fGFeU2sa8ZULQX5ElmplCxkgOWysNQTPLvjeHDUqokxoLKsl0NYePXmzI9fv+X0cCGfZxn/RjKAD08dg2uUpFBQ2ramV7jMmct55eE8s66JSmWYDmilSJeIdkXHqj42CZXPF24PLj07fpSnw3NtSrXWGuW8QdVCXlfCZUFrhXMWojpSNVWrMlPu70P4o7fLnH/n1Rf5N9ZXydSxVFPcfb2fvKrPjDNTtco8c5P58zdPuX06MHiDJqN0oWBRfsSPjuplnZpyYc0rPGRiqQyXE+l8YDg43GHCjSM39kAdMotJKOfQJnB3dNQ7z3I2pGXBkBmOA9oP5PqGwiydR0ZTsiDCa67UUKnWNBxokWbKls9ci6IqC0Ya/lJIYrDUWihKORFSImZFjoF4mbHt+qGM4/X9ZfnN3/vkP/66zP5BCwD/9Bvf+Mb/1Fr7TkEeeMfdJfQbvX3dC77i2jM79DPbc/fukf1cIMZEjPeC7zwecd6Le8hErLNUVQktQ0waXqTWuYa1zUuEIPDw8PBO9tw+F2xfHO8iRQgBa60y1nyslVYpRbwf0jhO2VqrtNHOWqtyqcQUN8HDGiM1PGuP4nCsOad0H0L85Hy+hNPpXF+/eZu0VlUpXErpUOGp937wzjnvvXHO4QfB8Pfj0ovkfRtre9++z977TXDpPzscDjjnWJaFEALDMIgg08SD8+XCYhbGaWRSE2/v5Th3jKIxGt2Q60pdRZjtflhlG7oQ05u0JDdx2e77IYTtc805bXO1LmI0pXX53ve+9/X4/4AfP/rRj37rl3/5l//yYyF4LzZ1sW+PjO3Y3n5e9Z+1z50Y4ztCcRft92P1fY69/jc927JjKveZ1/3ashen9q+zd6N2bOnOLWi89x8751Rz+EVjTHHOaa210Vrrfe7f/n1qrccmrJXz+Xz/xRdffJpSirXWnHMOSillrbXe+8PxeHxmrR2UUhYw++MQGsVg7zTs+/pYBNxvxx7Jukd69r/fu/0eOxAfO/8e5xE+zmPc/99fr29zF3j79XHvbNyqayIaL//gH/yD/+QXSgBE1Z1occ2F0e+sNlrHBKZl7ojturZFmW4VZsF8toyd5nhS7T3kdVu+nxY0Xc+z0NpKYSwLRlPcMgZqvzHK/0ZbGiOrORFlAqqLYDIH5zAF4hw53IyC7VojIQVxrR08tA4BtUbiGtDOY7VF50gupqH2Mtk4ioI1BgbXUD+liAjVkBJVKciS91ON5fWPX1Fi5O6jO5TWrEugOBgHT5oDMSTGwWDJskDOkJMmhcgSgiCxcmVZF1JqRUEqzlhKydxOnnGYGJzFAtPQAr8RjKhYyAraGKw3qFSoxUBzLikjK/I1ZOZ1xQ9eQoUXCQNNtVCqodZMWqWr97zGrXsOI8c8l4x1huk4yClTK9EbhoXm2ANvPdqvKKukq9A7KoVqKmRN1VIaGIwiaynMHp8eiEviEs6UkogxCIZUGSxJcooaAqRkEQByyeQouSwFyYIsuaI1hDmwpkKtmcGZ5vYqxCQdgescsZ3T3HJl0FWwobUSS+bhtKC/AYOzzEuiBMkjyECpSkTamPB2AGNIrTsRoylkdAFlS4uparlRGIoqaFVQDThZat461xrl9OoKYZ+D2JwpWm/jU1URjEvDpGrVL4ai2nfArwxdvXVof6WY98eKEcCLnUuwC3rvFQGXdwW/PRL0+U4CefFY+nsBz991A74A/nwCbx+9hdnlnjX1U3srCk2Worz1g/y840NzokQj+XAkHJYSJaNPMvaK/L1FnHBmQBtLqbrhAiTLs4bIWsvWYaoaWtCQMdbgD7KQ5iFjtMGPhiFkZh1Yo1yINeCMJYrBjpgThUgBQXkkEQUPhxFnDM40W702TcTKJGOAAesNfvAQZcjqVhTsEa4hBtYlgDEoMWSznELDH8l7p5R4OM88XB4IiNg6uZHBObx1DLcS+pvIG0bVsBDCQlxFgLXDgDuMFCOuAeM0yllUCCikAJuzJseA1Ro7jCyHicvDPSGLs66Ydg6n3kjQkGfakkqS7I+G0xXnuuShlfYvNJRiLYKCCam7K69in9xuLKf7V5u0Jrl9L3g436KBwRnmS6YE2d8uq2UW1uzwZgR7df0t70rf2/fPN8znsv1u//1zxp/i0ouPvn4f8nP/8/eMV/7Vkwc/lGLl+nD6u+Wbz/6WNVqxFYGvOVyCz2zXQSsiFFGc3SYLIkcbLbm5OQtGrBeMa8Nv5UrVitRCjrUR93V/bqmCCLNOo60c21ArMSVyc8grpSV7x2rcYWD0huV0RquBqgzDmpjnQNByv9S14qwj5ow1hpwSSazAzhojDm9vOI6DdcZapwSJY1reJqWQoogL1gvmq+aKVRqtlDZaPVVKPa2lEKJkY6I1yogIsp5XioIEJbau5/vLmfOyEnPCacXkHK4Jg/4w4gff7pvSCJDKgkmBuCq5Lg0edxhbLrChOkGDpxBQFJl0J0OO4vBzw8RyWLicTsQkuZqlZRfWLEV8bUxzfRhiboh6VRtGUJxXgmRtHYBZyBIdyRh7NljOqFpa45ssMObz/CmlfP514f7D3efXn3/+9771y7/8t2qVdsSSRSRi597bF4dUW69UZD7bXWkKEZN6t25HefVC11UYlnPLmHfR6RU24WtrdqxXlKXWCpUbprM5zWyWQiCDCGDS9S+L0JgU1hppUDQa3yY4Wk0WWkaVAq2VraU2sVMscPI1G5JUq75obnQIKRU8vbu7eWpat0Dvnu9Zmb0wllKuMWVizKxrQxkrmuuv5SsqmZOo5lpUSeGsJfesY9NcF/rqksi57OaydUOV5nIVb3oDhK5X1D21Njclm1iby44O0/Cu/fciStZN5N2ci03AvRYJSnNf9v2D8/nyaV2Wz74e/x/u4x/9i9/7z//G//Kv/juj10rm5kKUoOV4qVJRWebvZhzR3lPWM2kN5BiFauFE8A3rQnGeECKlZrSw/qmpULUiVk3RFuOk88tYcaGXqllTZNCgB0sKmvsUuKwz63qWxiPjUAScK/jbiTpp5vszpRq0d9gAXitWXRmdQg8D5nAnzlxreHh4kE71gFXOYnLGW83d4WgPZrQTcr0YBodVQgcJWpGsxU0O6xx1qaisMEZpo3mqUU9TlmbeJS5kozGDp+RvsNwnCpVQa4k5EZaFT3/4mrfrmftw5uAt3zg+YXIDh+PA8eM7/M0NMQs9gFCJ+Q1LeMt6GhjchL89MHz0FHUwWGs43I6oYWK5nMEVlPfkYEjnzGAN9nDH+uw5b16+JqaFkFeqHmS92ggkQhWyVG2bC1gL8kUpNA6NOLdSyISQwDhyKoIDT1nygCvkNUBKaKdBaYxxfP/Hn39vXsMPvx5lH+7j008//b/8+q//+r+j5NGyXfUVx9/w0D1frxf2e1G+u916AbgX3VNO1CJu9X4vEZe4NGr3jLwuInSBaxgGQfTvHEHWOrnLFfDec3Nzc3XCVFq2oDj+LpcLl8tlQ9BpI7ngy7KQU0Yb7QYvrjpQOO+ttdY67wUzOniZx0TT3Hae4zQxjSPX/JdqgI+U0h/FmDhfZk4neU9nLTFE7t++EUTw4Ksx0uA4zxdOpxMhhO21D4eJYRgYx1FQpDG2JgzeyVwstfDk7sk7bqCOKOzOomEYOB6PXM4XFIqbmxucsbx++Zrj8YZvf/vbWGPBtGxk3nVS1Uffd9GgixfrGrDWioC7y/3bYwy3jEHg4eHhe+u6fj3+P+DHP/7H//jv/NW/+lf/V1pr1UXAvMPi7zGR4zg2527exlt3ke7zOvcoyD2Od+9e2zcI7oWmLlJ1B2AXtfa5eX38dJfcvklgJz5zPp+5XC6Cz3WujzO7F8Cste6xG26/bfvt3SFM9fF4fHo8Hp/uxbINg9xcum0bSz+u/Zjt8zP78enjue/nfs21oZfbc/diW9/vx8LtHtO738afhi99/BnsHYP9/dZ13ZzE8zyzruuWWbjPY+z455cvX37y+vXrH/3CCIBV5LrNY0SpghzsnZtVUdtCzNSd+09ddUFFEzfQzb6uu4eqJzZcc3pUd1d14aIVZ/uN6rrsFpGvyqSvF/o2ZEuRpnawgkOsUugySoGT+WApDftlNetaUTExxUQ0Cm0U4zBQ44KmUo2CNaKcJBc6oylaNadJ5fbJLWiIUVxlMVec1mhlyFWKA/PDhfly4e7oGQ6OtGSSURwOB+xxIJ5XtHVMxwGrNPlSSGRiyjycAw/nB1LreQ9LJMck2XlWXEfeDhytxXmxHXpt8LaheEppbHxN0VpEBisiWwxiyDTOYnXD8zjwesJ7hcJQjhN5jlSjyE080miWGJlTJKZCyIkYMktIULXkj8WEMvLZjYMnHSreWlxVrLmiisEbDSFjhogfLblo0BGVKgKslED3Uoq47qogDnMemS8L7lY6+6nSyW+VwShNVYWQkrh+NKQoWS6VSioFHaWj4hwyGCVLg5TxHmzDRC0hMkxu6xYzVjKJcpZOkFrgflm4vyyM1uK0xhk5OqUdc+kshFAKa2pCoq6SVdjOZV27RCNdZ3UDTDUXim6idzXNaQG6tGQWJUXtsj2rGzpk9PZ8l55FU5oDRrHrrhY2aHv+V5QiXjwSBbtd6fl7fvcnFQ8fC39f/cf7lr8viReX+wvm2aGJbHsRUAQsuyWUGoy3lDk20Uc6AAtNBGxiYReAtGHL4+uQKxFMAdPEpSLYDgCn5LVyFdSsAcw04ezQzpEVbWC8OUJNeD9gjaMWzcrc7HOG6sEiWQEmJUqCNF8IQI5wvHM4C8dpZDDSpOCd4Das1eQUASOYHAxmclirxf5aeKcwajXoYcQ3l6SxlpwSh3Ykq0VyCMmEklniU0LO3M8LLx8iP371wDjCk3TLNDpiihgcN7cjBzzWGWrK0iugI+kCygLWSjYLiTVEUlgbptcRi0wsRm+Ybibiw0hcAsscGJ3FlIpRZcuV1RpylcyW1IU8JT+DQsmtm6rI/ShnyYcVw4W4L0vDwNKdjcAaF5HReojfC7gfIw/zzKg91mS82ctwL8jxOSVB8LAzEH7pcRUBr1l/4/ZdH2jjn2BAPRb7fhr+87Fb0P1cFyXLZfm/L0v4/uEw/orqOVxdvNvWu21SqESwS1EaZGqW/M/a8iQ7Ko4dRlBxxZjXraGiFaKbIJB6dgi2OU+r5PIqxXgYMXZAoSkloDSMNwdUSTg7YAcv9566yH27FhwapwwpZnSGmgJhuRCLONOmwwFrNDeHg2QVV4WzBt8Q3jklFBpntMyDBvl5TdVgoYUAAQAASURBVEWajGrZ4fgsRmsGZ1BGY6yhpEKg2Qit0n1xvabMmhIhZ96ugdfnlZ+cL7h55klMjKMnx4TWipubIxMW3+5IusgcKZ8XlNXgDNUaKoWwJlIMVKVRpjmwS2Vq4z88DMQ1MC+B0RtMrY3aIBNTrSGV9E6mh7iBMwoR/lOUzL+qpEkspUJp6PhcCiVlyXTrbngF9w/zb/+8F+3rn9LffiiP8MUX/7flMn/veHPzq91ZZnpzIaq59K4LQiEmtGzNCpgm+O8Wrns3WX/k0t197ee1wi6xQNERl0rutS1brxfDpEHIvOM+Ky13TpBfzeFeZZHsjEFrcQtb24sYbR5XJUs3l4IzZttKrdUOYaM3HVLcjjJv0VYcd1aLS7E5gsXF14ro1ZqW1aNxtqghZ/SNZl0DMSUul0Uc9FGiFLS20gvZ13RKkWxCKY21Bl1ad2/KTYC95pZ2wTS2LKPScublWKsGP5GCqzFa4q3756oVOZVNMEwpyxpi56boI7of91yKNMeVfrzZYUUlpKL/7O2bt7/1izT+fx4fv/kH3/svfvSTV9//i3/uG7+CVuhqMEoaMnt8iWoOUeOcNJ9eFCUG0rJgvcbYAT8WUo2UJLx9rQ3OyjpQlwJGGk+sdbIGy5miBSGdCugawVuK0lwSrFFhteXm6VOsO6KqpZQLblDUw8glLtRVcRiPeDcy1YBTCq8tZagsPnI6Bc5zIC73vHnzYx7WRM2Kpx99g8nCx0+fcBgnHIrBGMbRy/UgJSoGMw2occTdiPsh20RehFSCFqiGb80BzgkRxQ6WkiqhBrmeWVoAqGTZJ6CoyueXle+/PfPPfvgZTw6KX44rz56uLKcTyhi+9c1vctcaitcwS1OlLsSa0cuAuTlg3EiNiRIS82nBHDVVa1KR3OHjwXP37AnL3S3rMvNwDtx4i9UVyLhq5NpoIVXJXc6tCV0a0CXvUGVNDIlQKkoL4SHGLK7i1ixdlhlrW2FVW7Sx/M4f/uC3vy6xf9iPH/7wh//Xh4f77z158vRXgXfEt2sx/Ooa2bt7HqMC94i4FFMrbI+teJ1IqeKHQWhTqmyFeuedoC61JqXEPM/MzeF2OBw4HA4bvazn4qWUuLm54Xg8YozhfD5zPp9Z15VpmlpTjN2Eq1evXpFLxhjFk7uPmKaJJ0/ucE7u2UZr/OBxzqOVRM7Ylk9/czjiB09OQr7KDXWvlMJ5z1QVSpmtiB9DkOiAwXO4Oahh8HJvrmVzI8UQuJzPvHnzlhACpUhWYv/9zc3N5n6apmkr3O+RgZJdKJ/F6XQC4Hg4cj/eE2LAGsPt3S1+8Ny/fcvr16/Fye3sNqfpjU1doFzmRWpfWup/PQcyNSrb5v5smNW98NJRkX0e+OrVq3/59Qj7wO//v/mb/4+3b9/+4Obm5pd7tuTjLLd+7o3juLlSu4jVrxfOuc3l9zhv7nHuXRei9r/f5+v13L8uLO4z7Pq5vxcc9yJYv4at68r5fObh4YFSCofDAe/9l1xvXTzf55g/Fij3OM/9vn2VcLb7p7sgOAwDt7e3m5jWt2+P8X/f8ds3Q+xd1Xsk6v64PHb4Pc50fCzw7wXO/Xv377vQ2l3HHf/Z33+fEdi3Y5omPvnkk1+o8W/7grE0tx66d11eMxZA0BVdtBMxoi12m+CwsV7a5LsooLZ5ZM8s2yQPcdNIubxZUkrdCjG6ZfXVUiglkWuWAOzGuSsNR7Vf6MQ1MHvHOBhBdzoruTJK4YxmGAZyzixrJMbEze2Rm6NiDoLeNMCqNX6wpDlSJg8xQTaMShFTJtWKR3F+OJNvDmjvUMYwL5GYJXD25u7AxsozzTFjrSxateZ4tJiKlA1rIQXB8FknN/MSIusimXdu9FivccZgUXgjnUfWaFmsaLuJFLZ1xeUQsV5htcFqzbrO1JTxo2ewDkoCDKOxrShQ23MhWUclC1ZSCx7LGcdBj9QYiUBGS3B3KSwxcF4Ca4zMy8rlEnCXFe8s0zQyHMDOmaWCGwc8lcs8g7ZoK25OpytVW+xoSUsiLAk3OepbcSFdgoeHCzejZbAe59QmzZTNtCodwpXCvEaMtaRS0RTWUqi5AI4lJZSCrDWYzLpEUq74hoXLa6QURcVRS6CWys3gGY3h7fmCO07y/FJahpgI56mK+LfMK69Os3Rjub4YFSwJKHJNqGrQqlCU2RYsmoKuFXQmYckolLrKh6rWJsA3ZGjDotU2plRVVCXFzNLQsao5/9RWDKN1yPcsz0cC3+Ov+SlC4Pu+7t6mzeH3s1x6riIIL0Z4vvwsUuD2uF9+wFN+DdOcfF2w23L0MuwaYdDGCQY0QGLENvGrbDeSTQuUR4LiuwtaRKRKIc0rixcn0TR6lpDJc+R8WphPFyDj3RFj5JpqGoaw5oTOBe8dVlliSBiNdL0eJ3LKZJdZFkMC0jqjJ4cF3FPHaEamhhHtxUerxdFHKRjd0aaC5/VWcLKlQIkF7bSgPNpx0tqgtEPblu/jHUNDqmjbjM7aUdEyhlLh2e0N3/0mLPGbvDnPPFwWXj1EMhHvIM6wZGQ7nWyfK2BKwWRN4/NKVkeQMYkC4zR+cqScCSGSciSWRJ7h9LCKkDhYBqVxumCxKCXu8NidTK3ppMREzpGEIcYiua5ATLllBW7lXflsvZw/xVg57vFdme72+XNGB2/vL7ibJjzkPVn1OQlYEpwvC29ePfzUeMzlPYNs2fn93nUJ/qwuvfjo/696uCZZ/vwXJNc1/POb4/Qr3WHSs6Q2sHF91/3T0XIdFWWcQTu3zV1Kywjpz6+lXgWBIojlWgtpDSylYmyG0aNiJi2B83lmeTgDBWNHyZiliBPH6JY5mhm8NJukNWGUuEqtGgRHFzOLTli1kkLlMIxELV3+k3VMzuNsmwhTpVgpfB/Jx1SKquRrZ03DIlZxPjaUTm3YdJl4exn/WoGvDM5s3dO5TaoPShGKOOo+yoXvPlesMfPmdOYhxPL6vMZSSvHWTum8sCTH5C3eihDgasDkjM4GlbSIL0qK+CgpsGqtcaMnl8IaEjG1rJ6lMpxWrJLx77XCKY2zSnjGyPiPIW7o7ZLl+RktmcU5A1KkqbA5gChF7p1Gb5kruSge3j78v/51FdD/LBbu/7T26Xw6/dbh5virfZ1Se/5eux6oJiaVlq23z3p5nBPRs+i6mKbaWO9YyG1BDe/kCdGRXe29dO9Qb4Ki3jL0RHzMvXGoigtBKRmL3llB2rHHa5rrgn63oO4YrFoK1hhpGNpETCmMKd0djmpDnQm6U205g2zrrOa403I/tVaw3g2khneCO7c3WvC5zQUxL4EQlhpTDqCzc+6gU8N3mt7Ra2St0q47tZZtbacb1ivn0vZVGh2MkWPeX6ci+T99u1OSrztOtLYgw9I+p1pE3O+fb94aNdoJ0uglVw9oaUjSSK3w+uWrf/z1+P/wH7/3/S9+83/43W/9irhwEzorWQM20lCpClMVqIJ1Fu8HckqspzPWavxhYLq5IcRINYZCImkj50kFskJuPBWd5RqypsTlbSD6gaIV0yRNvpd15sc/fsv51VtKTtjpgLEWtMaUEWU0aY34mLk5TtxMIyZpsjWoweKVJvvKYJzQwfPCHAJPb5/iniic1Ty1Ex8NI4OVOb+uFWs1qlbJEKQVP1vmttUalSslZHJIKKdRylCVsGCM82g1YJzCegMu49u1U2vVMoulYSc2V/2zp4pf+47l3/6Lf5Ev3r7mi8ul/uFnDyGkJd1Oh2N+e+KcJ57ceG6skXGVsqxlyJiaUOtMMYoSEsZ6cTprhT041hRJl4WQEpeciG8vHF5c8FT00XJrleDIm+tT5UpaAmFdxRWoKiWsIjhyIKQiAmDKgv/OhVSQuda6UrMg4YTs4Amp8k9+5w//4dej68N/vHjx8rdubm5/tV/ju7DzCH+3kT32bpKKOAaNsZurRYSAayZVylKQF8S31A9VEw9DCHCq6Nu7/z97fxps25am5WHP+MYYc8619t7nnnvvycqqyqQqSziKoseFBBRYEbYQsi1jSxE0VliOsLF/+IfDCv+SgwjLdtiSJSQKowiFpJCBwgKDMEZYIDAKDKZJKIrqwAayMsmusm/Ovfecs5s15xzN5x/fGHPNvfNkVy5E3WZVZN199l7tXHOMOcb3fu/zcnd3x7Nnz3jrzbd48803qFV5/cnrbNnBOeNL4fb2FhHh8vKSy8sLi6Jo7pjufCmlsK5rcwM2d6Efuby85HA4cHV1hW8CobR1sziz+Dfc99ZAE0MwKldaWZb17I7ydt0fxwEfwtZEWFrsDw6GJv7FIWzHIi2WxTd893dRSuHF82vmZdbT6ZRyLtmLHHMuhh/diRvd/bN3RoHbhIXDNBFC5LXXXqOUwk0TRHtkw1e+/BVyyrz62qscj0e8F2qV7TXWxZw9oYmiWnUTJ2q19YZlOBsCcC9MPBRzRIQvfelL743/t8HtC1/4wt/7gR/4gV/Unbzm8kz3RLC9K6+7vnqu3ziesy73wuEepbmfQ/bnSv93F/w6+rMjRx+KdWz1edkEqL0w+FBQ3ItT29pwl0XaRauXCX8v+3kvEu6Fsj12+GXZhA8zFkMIXF1d8Z3f+Z0sy8KyLLqu67IsSzkcDhcPX2+fzfgwW7CLnl043b/O/r0+zPx7KMLunZoPxdru+usC4Lqum6OxP7Y7C4dhIMbIRz/60R99VwmAXUDpeE6H6xpD6xRt17IOb+lIQq3NfWQbz83Rt/1/13IBzRloP1R6i+qWddZyOlzr3KSJH33DqLXnbbQLe20ZP87eZ67Fim1VzeHRqry1ucvGw0B6YSdd9ELKK8V5hiGynhaCKn4ayLcz3sFpWZBhJAKn25k4Bo7ThCuVnDKnXLmSiUsvVFdZ08rptKIU5tWRlwosrD7gQ3MIuUp9cct0GLi4POKrI93N1GwFykDhyjuGw8Cdq8wa0IYzE7G8PGlFvWiKqhXVpeDwSCmGAc0ZqYWIZ/B2TEYfmLxhDz3gQqAUZRRv+SSDJ1QrjIUIQU1RKQRSVQ5TAAdpCQwlswDCSM6JwxA5DiPzmlmPK9enhevTzO1pYZ4XjvPIMEacOCKJOQVSyba5CB4fPRfTwHGM5BYivN7csWZlHCOnOeGZGf3EUoFSGaI35CrmBJWiZLUCfxeX59kuBKU6Toudb0LhbpkpWql+oi4rOSVicASawJtagHQvoCg8PoyMozmQUi44Z92SqeSWN2Cv82zO3KbEzd1qeJEMIRiKKaGkHkZdC85XVD2qgoonuNq61AvBFZYiW3e59pbznQC/G7JtbPithOBaQVsrG7LC7d21zuyF99I5X6ZYPHT7PXmoxu3dR9M3cQLupI2nO+Fv/3zfoirR7/a5p/CB78by6bx18dTSXH1Nf+9aT9cBK1DKGbd57w9YEcD+WSy7L9sTRjHXSppXqkDVQqyVHAOuFaG1JIboKcWTTzP5dAsta8CHiGixgO1gWXZkwcVIbF/vms0FGOPKeldYh57tZ8LeUA3zuc+f67l/tE78miBG+1iu2udca7VzrmUUmTvHXNHOByQIYxTL2vTS8ifbhdpq5wQfKaXisyF14iFyGAfed3XJqa68eHHH7XLi7vqOF9xxiJHLiwPTEIhDgcXEQBqCVJpw6YMnrYU4iGFUa2FdchMHA7nCsiTWNbKaXo4gBOcs368qWiuaKkUq3gWyWnaj+pb5kc3xV3KxrJBi3dt5zVirM1QyAtyc8k6YnpmAx1cTh0NEMGQwxVNLpqSZ1MZNBN5Kibu7xOeefu3Jem943fvHy5P/vn2B7iV5gE+BJ+klYmF8RxQdb55f/6ePHz/6rVvRi17Y9Vv+m/iOELdNb6FsGVvSGpYcYsgt15qW+tqmVnJSK6QFvyGlirONaRgCMQayJlLOaE4MUSjFkeeFMp+sABgC+EDVwjQMxCE2e7fDRU8R0KCsRdFBiTGxniopepx4pIl8Aw7RLnaqoTs7yrlNCqVWBt+uHV27LBWpamOnOYNQZwU0EXwQhsGOUw7njFnD6FVw5irMxbKH11yIIXAYAk9KkTmX8fntXbk+nd66uZ3Li5s5H8b4+GKK0zh6xhisecUbitWJtPdiomxeHWGISDSSQ1qSFTSdpxTlNCemsY9/Zw0f2/g33HnNhepMxCil/V58ExJ7kLnlgZaWIVqSuZWso8dw2vO63qwvXvxH7/Rivb4DPscbX/zin3zfd77/n9/UttYW1TP5zP1ViS5Yo6KT7dN2NKRzD5E+ZzHQuXMuXN98b929m9eQTWh0GH62zytdZO8ZtKgJWebmMwpE8HLGD2/uQ2d5g8qWWShbBrrNcZbFZwWvYRg30d5twv7ZmYeD4Hbd85YHaBvz3qEsfhMBcy6IDzjXN+qluWTOhQ2HFRhLrS7lPK4p57u707N5TjnnWg/T4VEchqmUwOrMmeh255oVN41QIN6acqRNWD2jum/otRU365Yf6O4VFCzP1b7rWnVrCLQCwfaKu6JOa+5oxY9STUwFWJfl5quf+tS7avy/XW8f/rsf/X/8cz/0q/87wdkaXLxHSm0OcUdR44BQqqGlQ2i4/0zNmeAnfHQg0QQh35pKq5pzrSRYMx4hRBMKTtcnSlmJhwViIIZXKHXh5vaOuhgh5qSOfDeTb2/AB+I4EEJE3MrVxYFHhyODsw674i1aICnkEJiGgWFwHPzCzfAY4ggh4GrmkJWY21yk5jKuNIRvUVwBzWqVlQi6GiK3ziuaKi7EVnXRzRXjwkAYHDE6nBaqd01IdNSs1GL3Gw8TFXPXr6kQLw+Mo/Bd+pqbSxm/9PxNefrixbOvfPkmffmrt+X1R8dXvuPV6fDaa0fLaK8JPZ3gdiBMg8UpSDDn/6nCEBgOI7UUyt3CerfgCSxz5vp65upi5C4KXq3+MSpG3Cm2JstrwqkjRt/WBSDBseTEki1beE2ZXKvls1dYT6c2zwVcWfFh4Ktvvbj9qY98/P/8Xnn9F/7t05/+9H/6wQ9+8J/fC02yZcXeL6b3OICtWN6sBuJ298eabnoRuuRCWq1Z0LUCMZjrrBeTp3Ei5cS6rKxpZRhHUko8e+stvvLVr+CcMMTI8Xjk4uKC119/3dxtcUAktWtbQLU2199yD7d3cXHBOAyM08Q0TVStlHWhqHIY/Ub0KKWRMKrVr4ILjSoAa0PeSUfoVSsE+hCIgzAMkXEYQJV8PFqtLth7qqqId4xuJMeBnDJOnFGHfGBdV7emNLz15lvy4vrF89vbmxWoMcRXxJuNsiNSOzI0NrERYBxHfAgM08jjx4+3nLHb21umw4Rzwrwu3NzdMk7j5ujyHlKyYn539pRabG/B2XW1riugm8jb3Zl7VOQeCbosy82nPvWp98b/2+D2Ez/xE3/ql/2yX/bf3rv9+ne5w15ajnZD9nbh56GA1xsAHgp3e/Gv/23vGtsjPrvw91BE2wtUXXzq76u/t+5G7GLg4XDYUKX97y97D32NvMeBPszYeyh4P8zOfCj0dUFsLyzun6O/7jiOxBhdrXValqW8ePHirZRSBurV1dWjcRwPDwXBfTbfPmN1fzweCpsPP9P+tncV7l+jP+c8z5xOpy0DsM+rXUjdi7DNyXzzV/7KX/nD7yoBsCNmOkpdq25uPt3tGDZoYc8H7Bvh7vprG7uzP4mGaxOgtCwKYQP2aTVRr21I1dnkjeiWz9C7dzvWhyaiCN42ba2jVVuORGm5FeVgDsWiyrG9XF4L8RBBhWEcrQvXC+TMYYy4deXZqVK8xx+EnBbwQhxah4EPDLWS1xPiJtKSCVhx4TgJIQxU7sjDQFqE27uZ5bZwfBSoZeHq0cgr73uFQ4jkJVOWRAyVsgRGFDcKmqFUK/rXbMVKy5Az1x6F1k1rQhQKrJkYzG1AgbFNagFHKYlpipSsZrtPBRlHxFtHvwdYMlWqYU9EoAoSvYWhk6xT3gnFO2oV9LQAatzwUlpWCYTqCfHIxWHi5nRiXjJ3p5m7NZvrYckUowe1DLSBoRRO3jGUiJeB4B2nXHANzxUkGkKkFK78RC6FuyRcDG1xlxwEO1a5bf4DjlQLKp7cBr46R0BYFrN/T9PEmgov7hYujyPRO063KxI8y7qwrhYsPrSubI85Fu7mFXzllFbmZHkJtjFS0rpatpA61AlZTUAybc4KUyYkKcEXqgoQzW0ovZCZid6T3WBCdnfMbmOxdaduCX6uuVfqnlBlI7Dn0jQnYR+btkDaMQwfuvr2yM+X3Z48EBSefKP7TGeH4D3Ro7/OfM4LfPKyDMBvfHvr+o73P350drX5+3/PybK0GgkU2V9UjOPaBCDojrAWJUPZrIGGDLU5zLCY3lkhuzOwohf8YeQgB27nzM2LZ6R1RcLAMHnLugqRw3GyBcpSrDMeoSBo9eYYLAWXbeE+lGDvxRujsvpin6NgRXDMueyk9OkUweOSJ0SQaq8ZJ9ChXcBr3myRrnXBC0JtaKCAbXbMSWUuxRZD3HBhhgetteKCEAR8HuCycDEEbsfMvGSuT4kvPXvBIUaGgGWUNLzqMIzEsWUuVY+nUGpDuFQIknFaN4G2YkjeHATvhOwCLjUNtRrqT9tXUaksKVEUNCfWbHmMWpuom4rNq/Z1m1Bcelxk4Ob6uuE/Z2aeMrWT1rfz4va0gA+clsy80+3uZpjneU+q/VpN/eke9wnz9tO0G3j2ml8/A/Dr3dI3Gaf37/uE+I/cBfiPusiYnl//4WVJ/5shTh/qr2fdnmxFrlysOUicoK5sOU/OWe7d1qqkmOOtd/g5Oz1ElVwU51tHlAANSydOTHwWy+GT4wGc425O3Ly4JrVGokFApBJC5NA2tWXNlt03KDkrWl0b/xXJxYrSpRWm23qsejH0OhWPNXjUtvDt+FOPdQOH6JBSrbt3Cq0RxFCD7QpgubTO46pSs403364sruWJJc30Grp1TEOsjcAQPF4c3gGHwV8M8uppzdwthdt55StL4jB4YhRiCFZc8TAM0Zp4xJqNihoSURq+UMRy+Vzf4FBJOZOKUQ+CemiNOqVlfKqztoVaK0syUoOWTCqFnBtivm88sgkF3TFErYYBdcL1ze0/VNUX7xXsf+G/59vPffb/cvol3/+/u7i4/N6eV2MON3ONaa2tW9xEbHZd3rWN4S5GdSFQm/uFJhh3JKWq2xCR4syxZll7HbmpOPEbqrOnNJdSzs1bG7qnbrl0trl1bTN8zmbW7ibsBb6WRVS0ueR2G/RS2QqZ4j1O7O89h3Db9LvuqnPb2lJ2mCBx1qQ5DIbw01pwxZ1FUhwqDa3sQESR4gjeMw1DuDhMj2s19P6yrM0pcTKE2mBNJ74t0HzwOFeaUGs4+1I7PtWEUa3apvG+MVW8OHJp4mUt23diH8dt3dGlZX2ayEcTMu370lJ356gtmrVli714cf1RTenN98b/L/zbX/3pv/cHP/ulf/Zf+8UfePI9ikcUvFaq01bcb9ShVuAZo6ckUG/Ie9/c/yJdULNFdKmVrJVEW1NWRUIl1YWCUYniEJAQKTkhVAYfePT4yjCWtytvfvUpy2nFjYHjYM71w9QcL4eIrBWyNa8KjiGMqBq5yM/CmpRlVmpa8UMxwgtK9SBqDb7iHFErUkvLvvC4JEiBqIWArX3CWFFfqW62NYVzqPN2fa0VKa2tUAu+Ngy684h3pFypqdhFX2z8uJoptTXl5AJOee14iK8c/OM3b1Zu7hJPn17zubdu+eBt4tHlwDQOjINHYmIomcPoKW7GBU9NQj7Z6kOL4pmRNBsWfYiUupBzYimeIVROxRPWgtRELtW4HzHaCrg6lqwkBZ8yc8qsuc0BWNEvLckQ4KUyDBNSMhTBx8gnPve5f5hyef7e6PqFf/vUpz71h37lr/yV/9prr732vd0F1N10exEghLDl4e6LzhaVUrbi7x4F6sVbTaXtEKxQb27VjhL0wZu7rxX/Hz9+DDju7m75whe+wJe//BWOhwNXjx7hxbexb9l5veFGtSE/a9kEqtJyq0s1w0HP0islE5uLOefMcppNJDwe2/LGqAeG9TXXXgyR6XDAh0DqGYc9HiGviFhzoezawZ2aQzK2+bG2Gkcv0nfGShyM2OFyZpzG8Mg9euV0OlGrZRdqul/oH4bBhMBp3DCnvRjv2lqqiw9xGNo+xfYtqTl4TPyzNUTH+82neXuddVlQ1Q3r2ddbHbvYq2ZdNHkojDx79uyjKaW33htdv/Bvf/2v//U/9Ft/62/9Xz969OhDexFr75TbO9e6O/ihu83tcsMf4oFfhpzcC1YPXWt7d1sXsvrvuxst57w99mFmoKpyeXnZnK4vFy73bsT+fvYi2UPM517k2jsb95//oQAnuwiDh2Nkn//X90zee391dfVqF9qur6+5vr5mao0LexffHjvaf7dHgcL9DMGHrsb93/aY1v6d9/nGe99ditu+oL/3/pgurvZrwBe/+MWfub6+/uq7SgCE8yZL79mCdj2bHaVlhx12uWPnRDHX7Oi1uf3cVjhWHKLS+s/c7mk3q6G5/qqecY7NEWjIpmr2jw3Xpc35Yu/LexMEU1q5O81cHgcWyeYMVHONlSAUrRAi4xhJzdqvrQOg9iKC95bvFwM+VLQ6lryQD9ZpMx0u8NE3HICi4ohimXyvPr5gXirPrm85UFE/MInDR3j1ySN8hjUvODULflEQX6AYjnNaPD54y8dZV1LJZBXb3LRsjRoEKYZ4lNI6YNVkVhMVwGlAtCLjiFMTED3gp9i6EgRKoYoY5aQAWggXAU3eNv/RMVRnxXQt+OpQ75m8sGq1zmVbc1tGQvGILzhV/GHgECJzysxrYl3MN1iBIA6ikrPxysuaePH8lmlYGIeR4xg5pRNryqCFq0dXpGXl9tpz+Yp1YaWiDbtUUWeCJ+IoqbCsmXlJuMmTsjKXlRgGspqI6xrq8/p2JgZhCKE5x7xlnKx5E9O8eMSbM2EuGcWxnO54dndiyZnFObTaRaM25Cbe44lbB1VQR8QhCpZOWAmuEl0hV4eqnTs2pAy1IlQUK+bUDUXXkjGV3UQJ++uTa4gjo33amK4btMoeUCypsyWfvEQweJlw8JRvMetv70Sads83fe3zbf/t4uD8bVuf3vzU53jyq37Z14h7W/wfXeQLRuT1bcrzfpvFcnkgDDb3oIlPvchmQpuIx+GJ42iiX2tyMFebuelKCKx6hZ4Wgo9EEQ4DHKahFeXsbblBqEkQIqWyiV5liFxeXTIvJ3MclUxdZzLgDxNhMCegLxBKIcaWRYQ5hswtbGJd6MJYrugOWqkiaK7AiSxQF3v/PsRNAFUy4tqc3aZ0Ku1x7TpQwZXCIB4mEzFHD0OAU7bzwQcIPmzHG8GEOAoVDzKQ17V1XzakKYU1zYQ4WT5ZraR1YZouGpnJQtJrtuYEHwLrarmCy1IpWhA8BShd8GvXqQrUNYNv76vkdk7AnK5J89N7Z7OPkZLhjsxIYFlmnr24446nzDvx/OnXqG9Pv2ZozbsBMPFkJwJ+ff3u6c95LD4cl2eh8Ok7pLh4fX3z4Yvj+CGcEpyhJdk6zdiwfYiYGw8FsWt3IyLb+e4UadgD2dxE52Ym21xbIcmFQBgGG//O5nXnHD4YDrz6wForGqKNf+8YB8dhHCzEXjAc3yDU7Jvo2BazTqhD4OLyyHJayTlRaqEuyfKypokwBLwqUh1BleiL5cE6jzhP8AHvHMGBd4aE1pobsUFxPlgRMCfIK8U5VBTnAr6N03tNXs2h7BQTC2tt50zLmVXL+Rv8QHDC4DOjwClnQ307wxEX1W09WEtBsz1XREkpE4M0rJGN0pwSfhzw3kHNpEU5DMc2tbvz+BePd441ZdaUWFOm1JY83XBfVbVrCK34V2ze8IKuSm2NZC+ub3783VakfzuP/2dvvPnh48XF9+7KV/c6VUs1McnBPbSnc7I5xUz8Pa+lOirdxqUJb10kPCN9Gm6wVltUNMedtAucNtJJKbVtms/4my70iZw3uucNtwl0dMTobs233zeZIOi2psva+xNUUZXt7+L2qNLzXsFvuBzdHI/dZdfXvZadqubKKQXx1dbCtZBTtucUm2MAEyKAQZXDOFCrsqwrKZVGzog2v26dxoZGt9+F7X3249Cdjx316Wi5gC0bsB9P3eGfOwLUctlTI2HUrei5NZW2eV3b66hzlJp56623/vZ7It3b5/a3/8HH/9ov/sD7/ocgOF+RaqQObY3DruXLyjDgp8JQVoqPiPHpqUlRPCKF4CtBKlmtwSWpBcu7hpIudUUiSJiIh0tG37K1ixIRwnCkek+eMreq1JsjMVxwHByXh8Kj48QwBfxg+YIyWQSGrg6t3vbwi1IvRx6tjxG547QuhrO/vkW1Eq4eEadIzIW4KqM6oi+gC2jA+SPivLnanOXTq1fKulJzpjql+pEqAmXFZXMHFjLiIiID6vpxaYhdD3VZKThKsWs1KFWtaF9TJjoh+IFXL4QpCsFVnmWra9TFMVx4bueVY5iIwZCby2lhdRU/BE7LQhTARwaXURLz3Q3D1RVhEHKaWe8KjI/QEMhOcMmaf7yPBC/Ma2ZJlp+ICLHAUiAlpdaVOBrJSJ0jpRUfIyEOcLvgfAQn/H/+4c/+xHuj6u1z+/KXv/zhV1999XtdI0pp1c3Z0dcBPQduKx63ZrOOiOtOoC4q5Wy1r36tzyU3PKhuBXvL5bICvni/Ibp7tu0rr7xCzoWh3TfGyOFwMNxsw5JXbQVucTiVbQ0wTSNXjx7hRHj+1jNyqXz16S2lFF599TUuLo7b3qXkzGk+mcARAzEEpnHC75qRbB2SLQNQK7U1MVreYWae71oT/8gwjNtGtT+f996w2U14VDU0dzdlrGkFB+M4kHNiXRO1CZrTdNiK7PM8k1Li9vZ2uwZ3Z6CqMo5jo7PAxfFoBf2Subq6QlW5u7vjlVde2ZyMW66jOCSY2+/udEKc2wSUjlTtYqOZJ86ZbQ+FlK9+9as/9d6oevvcPv7xj3/4n/wn/8kP7d1r3R3XhbY+vrso/BAjuRfJ+u8fuuD2zQUPcZV71+C9PPpecWlCdc/7XNeVw+HwNWJiFyzHcaTn73WH4kPhai+M7c/fvVi23wc9xJp2gbJ/nr0ot8/tfPgc++PRj+Ve9Nwfi9PpxIsXLzgcDrz66qvEGDf34l6w7O+j41j7d9ZxnffW2A/Ew/1z9TG+n9N75t8eEbqnufTP3gXAT37ykz/5bhtDQfXsLlK3l/30vKXeBc33crlubqQG9Gzin9sVzzY6TxP/TGfUtpmuVlRud3JaqQ0/5bQXmQRjW7SilPbMhi5ptD84R3WQq7KmzO0pMamSxZMvDgyHidu7mXXOTBeB6pRlNRRlSZk6BCCgBdKaSQc1V91dcwM4OD07cXVx4HAxEH1A18TiYDpGcnYUFJ8jdzc31CUxHo7UkpExMHlHXgu1Jg6HiSEaGqdqxouixZHWwjAOTHVgnRNp8dRiGLLScj7CEPFBDOm1VEIQE9ScZ/AQx2jF7JyhVPwQKTkgk8eVForuwUXBZ3DenGMeKAG0iB1ONXa/lu6UaA6Bmske6wzOGalKoFLUnvegHomQnRKdcb+Px4GaHbUWYhCm4wE3RFJOVM0EHzgMHvFWZdS8oqlYt5MWAkIWx2mZeczENAllacygqNQ1U1q23elUuF0yORWm0QoVnkiuLQfy0px1aV65u1sNfeBgzZlaionNzYnknDkZcoXDMOBIIDOnVCz3TWPLEztjcjckbnNSVi0Nf+bIqrhq2ZUlF2OxUw0713C2AhStqKZWLDXLlzYUlbTxpK77a5syU13Lvdihn9r4dFtOYpfsH1Qrnr5Edfh6asQ3vX2THLJ77sJ5J2Y8RCF+a0rgU+BDOTM0Ya8jPCHjC8iAiUy+CXvd9UWhFk+uzfUn5jwRD7lkKqOhsKRf8NqxF4hxxPlgGDtvhXDLoK9UF9A143PlGC1fL3gsR0cMk5xT6TVDG6tSLcOvYOJ+hDpG4sneX65AKrg2/kOAsFakmtvXBc8QQ3PumatQqonItYJ6KJLtNUJzLqnxt1NeaGRlc/S4hv6omVoLiAlpiDlyS63tZ6AWtBhas5nAm6vJjlUgsQLiA4MH5wPDcbAxRyGvls/lMTSnVvABc0M6E20BojcBwbCmVjCoau4fc/bZuCsqLMVwLIinSMd+gpaCH4ceGwbe3NvVFEIgsKz5a6S366dPScBxmrZz+26e25n65J7jj29bN+9/vY8APacPTrwU7fnkZWL7tyMEpp/XBcQ/zsLnzZvP/oP1tce/c4gydHded3tZ09J5fSBeDAsq5ph2KuZ82zlkvIdczD1SWu6U4UQdHrVc3mFsaN5zllYtta2BFM0FXyvHweO8I4pjiB7x1tahqbkSg8n2FlOkSLX1jcSAjgPDEMilkotCse7eMESCd/hk89sQLcMvDt7cfGJOCFFr8qiq5tiVYI6oe+M/kVMy9Lo6c/370HKXC1XLlnEmuA2hCbtGrWpjTCrgXRNFPaLVxnVDbA4iSHCWQzyNUAt5zaRaDL1aC1rUyAfNtenEG8IxOMs6bIKND97QZ62wXxtivqpjTYVlzuZWcGo5gs0NFMWOjxPDpEkQQ3+q8SqWNeXrt57/8bdDIV/fey8AfOUzP/sfvP8D3/3bvffjJtir4rUL2NxvBmgidCkFj9xrpDLHXWuHbAKCOQgVEaVkJUS/NQUE3+LTxW09k+ZIK1un/OYqdDav9HweI3j015VNKJQmUlsOnhXa6uZE3AmQrmMvFe/b+1Tb/wTX0UBNSPPSxqqe56stxoFt7VrKeRN/zkXWdhx8o3fYCtcc0RC9b8QYtnykjQzTjnnwCb823LILDOPQBNjmVtgVLXx7r/09dzpMj4bQ1hh6jqSw76rjQdmJfFYIOu9lnetuwzNyVdWKCFqVWjV/4dOf+RPvjf+3z+0///BP/Af//A/9mt/x+NE4qtpe1bUxKFvTniE8awyEccB5DyIsqbDOK7VCCGJNOV7Ros1xU5CWE6vOUatjiMIwvWLCEQlxueFkd40xa+VQK+NhJAzC6CvHKRAGh9q0QDyOOJ8geHRSSspoqbhR8EfLJpqOA6UqKUOZCyEK04URBcLNHdNaiW7EH/zWG60aqGtBl5VSVrI6cnUkOaA54V0FPFWFWuw+WhRxARcGnMbWKGR0Jq+NTDNna07qhKfiqHOhUi1b2znUO6KIZQ1eBMIKGcVaHAOvXnmmw8g0jmhJtt9ZFxyJsppIE8dCmkGq7SBqrRwGmILDVyV6iFNEnaA1IWrivXMD1cHNfOLuemE4RBgcuVTWJaNamA4jhIHqzQU1TgckF2quhOPAs5tT+Ws/9Q/+2Huj6m0lAPyHH/rQh377MAxjKWVzmO8Lwz33a13XswDQ3P9dJBiGwYrNzRkWgo2D7mhZG2YyxsjheNxIIb04PzeXSQiBeZ558eJFI17Yuv9wcWjoy7xlAd4vyts1axgGQoxM00TwnjFGawCs1VyEjx4ZvQw2tOg4TkbVGAeGGHFOGsLY6l8uuZazGwjt76q65WLVWqm4LW6klELJyYTP5kJyzgTAlOwYSsOPW17hLVqVEMzJ5KUQQ+TNN97EOWGajHo0TROXl5fEGJlPJ65vbjbMYXcCDsNAqYVhiEyHkRcvFi6Ox00kNFz5fRzhECPV8J3c3t7iRQgxMjQ3UM9+66LKw+y1nhNfSimf/OQn/8h7o+rtc/vLf/kv//s/+IM/+Nudc9PeifcwF7SjNPu8sHeyPcyN6+LYfozu79eFqpchKft9e1Nfw8pyc3PDs2fPeP78+XYedjF9//xduOr/62LY/rX2AuNDt99L808fHI+9AN7F+f68e0fd3hG5f70utvX33B+3F+b6883zjKpuzQ9dmO0O3L341//dxcf98z7M99uLkP3vexxwF/Z6k0D/TvcCaW/6AHozQPlbf+tv/SfvOgHQfc2GohOydxjQXWaG/aIasrO1n4qIFYk2xcGBC9vjNu+Fa8ic3iGrrlkQDaWoTg0N04pMKuCqsKMhbmYpEctea1wa66BTAzaWap1qXpSUFR+teL6sineKOUwU70zsEaC6SjwEMq7dxzrcxhhM2Ekzh2kgukCydTResQJ9SWiBt+aZdbXF/N18zeV0YDx6xssR5z2D9xwuInVJ5GVBfcSHkbJkXCnE0ZNTJcSIb5mMiqMAwzhasG91BAouZSQOTAHCMIIWCh6vUOYT850V2LRhQzkIvuXFBQc6gadQs3Xxhimic6HkFZzg/EjwhbTmZrwsSACyR3Vt/jHXWImu5fwp6h1ePZTezeyRIeCcKe3T4WD4RZk41YRoZZgsA8AJrAtwObK+MbOkgvOB1y89KVuqm6ohF6tWci7kAqVlQJ3mFSrEi6l9BmXRgmaI3rUMsMq6JhQl58rFceB2zW1CK1R0KwKnoixz4mbJ22ltHj6Po+e9GJpW1dn5qw1L64SKCTUiTTZ3IM4Km70Y7TRRxTM4Ty7VkGpUkhZbmAnm6msVri7+ubaYzZzHxL0KgTuPY8+5ZiK6u8u3M1PsEaH3dRJ48tDz9E2ExIc5aU+a4PHk23cBvvGVN/ngL3rNcty6yFcgkYklNJHOb+RhuzpBZt0yA4MMVv33+xYHGvrTxvggHpFoYnleDKcTo6HxxOa2otUs58stpcJwGDgOR+I4oD7gtOfhGGDEBcvD8tVcAzaLCnVeEQqjmNgIzd0bg2H+imXWBWfomk509S4Y4qpkylqsGJIqHKZuTt066GItTOWIto5IQ5hBSYWazN1o3dTWrCFiB+a0VoRieVrV8vUo5kAUMdfd4DPVm5tQgGmwDNIocBgjIYykkG3qiIUUVgsej5FlSYh4xssjabljHCKH44EITcRpYnuplsWnUFoxtiSbE8Jg33mthZLsTcQm9ObasmG8b5ONZbS99cabmzQ2N0vfU8BUvie78/uBrPctnfi8ROSDiafM7bkiT0j3pPD5Gzz9z5+Q93YpJr7sfZZ5+dHb27ufGF+9/I2lVoKYyFdLRdXyKsRLo4gLzp8dJprOC/UgASfBJseat4nR7m/OGK8eCeZoyylRs0OHgJcmNDSnz3xaSPMdtSrDYWA4HBmm0ZyH2/hXK0Y31xtVGx7dERHKknBaGcSy+jqGyAdz92nJeAUvbfy3i0sQEwxcy7N1zf3LYUTEGbKzdT8PtViTj6o1DojHtU7fmnPDDbIRGZwHRDm191ZKsftUwxy66u34O2XwggZBU0FC4DDYHBU8HEaP9yNpsflXByUXiKNtSJYlWXbKxURaFsY4MB0nIooXT6kV70yYqaWYY0MEVSFnbeM/bCdNyWVzgyAmqG4bmbRuDTvX17efrMvyV99txfm38/hf33zzbz5/862fevId3/FD+wVQVWsWUTmLUfuN6ba5f0l3qXN73I0+yATcb/QrMYbmApR23yY3NaefVm0EE90+Re84zbm0wpph9Ls4aS5Yh2nt99+79uayPn+095iSOei3gkU1LDGubm5AmjvQubMg1hG41gDRnYutSaa5Jopd5DeXsomVjX7S9nuuOQx9R6K2zzxE2V7LnEMZh7dIAB9xDaW87xwOse0b6cjV+4Kda+7L86aQ7fWbhEluuZ8dvXo+er2DuN4roKhWrl+8+NT89Olfe0+ce/vcPvn5L/3o3/3Yp/72f+PX/pJ/umLnuVZHLoaNDzhcDLZujoGSPIoVi9ZbQ9U653DxCPGIP2RkPtnvVJHBA5FaC0GOTNEw9Gk5sZRiJCCEKtlIQiLMd7ek2xtSzRyujlxMVxwuD8RDZAgDU/R4V9Fq++JSCiRD3nrn0eKJ4oiu4ILl9IkEQrRivFcllJWhVLyCGwLirbm0ZCXPmfXmlnQKLLOii6MeRqAQyVsevNZAXWNzwQq42JqisrlmfTwXfGqhiDIEmFueVspWA8IVazjSiPpGgRoD6pTb5Q6vgSiei8PAdAxMxwOn5JlPM8M6gi9MY+VweSAMI7enhALjKwdKTgxh5OrxK1x5R/SW1ygOpDpyTkb0iCO1eua7zLqsjFNAcM2JtLS80dj29VbwCz5Qbu/MdTAMfPzjX/jk57/6xl95b1S9fW5vvPHG3/jyl7/8Ex/4wAd+U8mFQtmK9w+dJr2oHOLZ7Vdqc4b0ojk08pdH69mFY9nSpeWDWjPsvMwbVtCu5RYD8dnPfY4vfOELePG8/vprfOADH+DxK4+JMXI6zVvRey9YmCgVtqK0A46Hw+Zk6yLlYZo2PKb3wjSOXFxebgX0Lmys68I8z9zVO3RVhnHAiye0z9ObdUrJrbYQtlpHakVz1brhv2kOy6qRvMycbm+t/pYy87y05v6eqW3Hdi8kdNFkmiaurq4oV1cM44jDEWLgNM9NnBPKWhiHifd/x/ttLI8jr7322rZP6QX+jmzta/kYgol/uzy03tzjxN3Laev3KbUjYYVnz9/65Jtvvvnh90bV2+f2iU984m995jOf+cnv/d7v/U1dkN873bobeC/6dmGpC0N9juiiWF+f93nkYe7fXnTaO+C6iL13B5ZSuLu748WLFzx//nxrIujPt3/u/rwPxb+94LV3xT0UBvfvay/o9QaIjsfcC3BdAHzoDIw75/Le6bg/XntXYp9r92jOlBIdCWzzid7D9/axuD/W/XX65+/vdS/aPsR/7r+jeZ6Z55nD4YCIbO6//Zyw/37742OMPH369BMf+chH/uq7bQyFRvPcdYXqFnQv3UZeew6EiXWKcGZDtQ0ppe37pPdmGgVUe/D9GVdYnRW6nRbUFRNPEMt+wYppThxS1bLU1DXM3blrHmmvI5a75tWKwvOaGNNAzhCDcjrdcpimljuhpDmRgpCrY15X4jQy1kTGc3z0Crd3dw0d5NFBKR4G57h68ojRY66wXDmOHjcIywoDjuMrFxxeKdyeMi9uVsK8MB0Cx4uB8TC1jB3Hcmr25MF646DA4PBhoqojaKGm1QLCveCnAarDE4jTwHA5IrWia7aiIhjGzkfqmsiloAFKEJIHrYlSMxTrHqwOvIBHyc7hxwDBI7lSg0PVN7yBBae5OCK6sK6WFaYOfLLg8rLmlum3QxJpRb0nihhqRDzDwdw3tVRzCQTIzsqdOGWYPHEcqCVZUTREhqtLhmWmpBV99CqXF46yrpzmzDSOSM3UJbNSKWWgJDM+zuvK0UM8TNxUx3I64RE0TDx/diKMFsA+RI84IeW6oV/LXMmpidNVcdiCpnbcoQiOwGajc63Luv1fz8Q0t55SELJaEmbwjlwrCTW0oGudzWJdzMVZJ2opleCUUgtFe++zbTRt+LXXdbZgFZVzvp/28WnLyHr29trfK6jT+2WKh6Lcy2xLX88luLvv028od0z3n7e7/p7uswG/ffEP4FNPn/Jd3/1ay9A616+ksC1wH2YDpmIOmtKmwNqwnBIGQruzSHc/m/vEi9+yJHRJ7Qhb960fgonspTIdRsvPypmL48jx4kicRkuLLJUhBFJO4M25EvCte92+Ldcy6ULwhDEgPlhh0HtiGAhjsO+7bTrsnKzWuVwrpSS0GD64JAsGr+3Ld4APkRADQwjIEPDDuGWOamq8/2iYUfGBUjJaCrVkfAUnK2le7PhUcMlbTqmZXhticQQfGEumDiPT2LIQmwgYWgbYUD3Zm9A5HUcT+C0ehePVBc+XO5ZT4tErrzAEQRuOpSKg2QoAzrPWTGriX64Fj4dczMVIQZotMS3m+DQVt2yOUIA52Sk4P0B3dtHv6fabb038O6f6tUc8uO/U7tUBoAmIE6T5LALuDbNP74l+6YEYyEt+z7fw+7d/EfOtN5/94VceHX8oBnGl6hnnt4k/nF0mbT1T28agWmhsQ+95JEZCw+dIF40QxGkTEq1YXNbU3NUT2QuHg2GoSqkcDgO4S1IqHA8Dh8sjcRps4VmV6IVcduNf3IY8R888vxCFOARcDIYI8p4QInEcbEYvueV2tQam1txSSkZr6+DtOcKqrbnKXLqhh4uP9rPfMoctYNTGv9s6grXY5sFXRZywLou5GKu2187WkOVAnWdo+WVxVAgD4zQwDB5ECUCMzgTX4slBGWXgcDGaEFptbXG8uuTFsrDMiUevXDEGQavhBKurUAspJ9R51lpZm/iXS8Grp2pDjfaNh1NyauNfnM2XWe1nB89e3Pzk2+m817fpc/98377yhc//yKtPXv8N3nlXimX+movFb9nlVc9zABsetG4oTGmOMxF/D8m5FwatS/+MmXTBbSKi4TmbuCfS8F5yHtfbvkoQZ+PRRL7art9sApyqa2691hywE8CC95S2yBHv7HwWaa/ZHHDZHK6ry3jpgmJz1om0RiDZXlfENfRWuVfUcFv7oeUJGcbUhMLaNvytTXJ3rLjHUrU+NCEE2zhYzKBSSyYGwxU7aS5COYuFiomJltnZCh5ioow63farZxdwwxVqy38Tw/+qloYOZcsGqbULmGkTV1WVN99468ffG/9vv9uf/5s//R//xl/5T/zXhtFWuALNxVdQl6w7xypIG/M7zXeU6gy9HyI5KxIH4vESfNziNkIYUBW8KKP3BC/UvLLeXZNW8McjEj3jYWTwDklweXWg6Gu4deXVq5Grx5dMVxPjGDi4wBQjqrMFMahYdEAc0JKtaW0pVKfEQYgXkXg4QEMETsPEeHHES8Hl9SxqlwQl41PC3RkCtWi29bQ3JH6lkqnbesg5QZhahrBdy10Bn0ZEPSIDLk5AxeW5NRg71rwyL3cseBb1xJzI6WRkmyj4eGCoB8YlcayJ4eKCy6uJaRTG6BmDIHFkySO4gXWCi3jJ49cuW2PRDVodl68fefGlL7HcZfwwcTxEnFPmJeMGI4ykvFKrsiqcsjIvC6kkQ7xrJc9WADxcXFA1My8rtIKg5oyuhhnHB376Zz794++NprdhE8AnP/kjT548+Y0hBFda498msDmrjfSMPx+CNcaANeqmbJWb5jQfhsGuKbvicvCBODSCj1bSunJ3d8fd3R3OOcZh5PLqEu8tHuLVx4+3dcWT15/wXd/1XVxeXZFbEby7VYY43HOiOGd7ktxQm3EwWk4IsSE2R1555RWuLi83AS/G0HLxLOc75UTOidNp5vb2huubG+7ubq2Q3q7fwzgwjRPTYWoZXQe8F3IulO6YCueMsi0CwVlW8c3NDev6FutsDsLT3Z1dg0ermfaM48Mux+zi4mITKYdhwLfYJbuOVw5NGAR4/tzW7E/e94TPfu6z3N7e8t3f/d0Mw2Ci5t3dJg6klO7hCsdxNNG2fce11lb3tUbQLkB08aGvXZxzPP3q0/fwn2/D24c//OEf+b7v+77f6Jxz55xKNpfay1xy67pu99sLTzHG7fx4KHr1JoKO6tyfd/vb/n5rmytub283IaqPgy4QppQ2EetlaNIt37I5drvo3d//Xhzbi9v99/0zdkGxO+OWZeF0Om0iWW926G7JlNKW29nnqD1qtf97n+XZXzOEwDiOlFI2zG8fc/vmjP180D/z/r1+zZr3gRuzi4A9d/R0OrGu1jSwruvm/u3f1d4N2M+FLnR+7GMfe1fivzcHoPRur5b74loHpVNQ6UhBNba8E8NxOhM8KmooqeY16ps0p1DVc9571y1r0HCGvukoBXXVnr+LFs7hvMMj58K+2iYQsS5X6dU+3W1Oa2FeFnwIVC3c3QgqwQKmg1047u5WE1ZCwKPcXZ+Yhol4GLgtypoT+cIK8stcmA4eKR71DucSsVTKohQ/MRyjde4hpHnBrzOPD4F6eUVQGI4HcxJ6RYu5Cg7jBWlecdgmhMEKUiIe5xNzXnHRCn6+QqEadsdXW+w7ey+ZgquK5oXqAoh1Ha9ayM6CzGcSxRU0KZozzilFhaDKOETiMOKKoOuKrxBFkBC2zmQ3TKCeAVgqhhoYgwmAqaJksjYUJ1jREkinEw6PTkIcR6bjwHI3s64VFxrBs0D2gvdDcydF0pJYlwQhEmphWQvzWrm6OLSOHVuIFfHmGi2VTOZuSVSpzKc7SsnIMLAsibIUlMqdJOvWrkocBpy3459zIYgnlWwoEz2LSLXPQZ1xiCHNpKNyOx+5Y0AxlK1qoao5FdRFklaCvVtSrVQv+Orwvo2HVgyyQpXlSoQmtJfmlrVCkLOxUnu3+LmgVfset7IJlO5eeWb3eTaJ/iXC3svEvydfRxx88hKh7+Ht6fS1j3+6k0Gezi9/3W/j9vTNN3n/+177mt/XNcPQMgBLboqf5WF2I33ZOiE8IXpDXjbXYDM7b9k+7QygOG+iMkKYBuIQcRWERCUTh8g4jkxTIEwjMniktNwfqiHq8M1ZKxv6S9RRtTS8aCBMA94JJVe8qOWcNDunOkPzVi3mwnXYFt9DFqFEoXhYsrl4cylWIL+93T71EAZDf2JIkQB4hCCe0Qcik50qA4gbCAqHIgxTYC2ZVEHrSC2ZPK8UATdZFtjp+pZcPDIeiFNsWUwVbUXIOEBKJrw7MYejqoCemtgeGONImldKyrjhAFTyKROjfROlQtFCorAW25yVYm4FrTT3n8cLlqm2dPQu5DUjZMRP3K4Z4nw+jV+q6z35+qL5y87J3Z2f8vSlp3fsA6IJf2nu3j7LCHzykkd8rZiXvv54/QVcSPz5et31+fUfuLk9/c8fP7r41bYKsPNsy+DyghMr2m/dZDssYM2OTMZjG1jvpbnFpBX8tRXLXashWkepEMAJYRwIw4irineJQiEOkWEaOQyROI7mFFBzg9ucYihKrVhGESZuuW38GzLTj4Pl+OWKiBq+0jc0Xu9c7l1xTqmuUkUpYkjvKo4lKymXTRzrqCMb/4b9EecYg7fCJ2JZfiESbeCDOPwY7TI0CvE4kHImlZYVlFfSYt34brL3fLq9s8aaYSROI8Gf15fOQYzC6ur2+t4ZUkFrBbV/j8NAmlfrsB6tWaisGRdsEqwKuRRWpY3/ZA5QaPj0sqEF1zmR19JQj87Gv1PEB+6S6vWzF/+3d2NB/u0+/p//7M/+gesPfehfefz48a8wYaduopb2DXXPjRO2jv+2dLL7NnRlaf/dd9X29WbHanYxqmfKOfrFW3b5ctYIt3ceNJ7lJlb1XMBeWOz5eP249NfomYHaxExrSjgjO+nNXW1NV3LHiTpSSXR0Zs8UFOc2h7O5ka3Zsn9sL1Y0lbYW7tjNnnnY3/cmdrbGM5GG4+2OwxYJIQ3l630Ap2dcKi2/Xc5Uiy3DsQuvjg3XVlthsTsM7ZhZJIRhCmz/aE0QZUOl7o9hd3HcL7AotdT6xc9//k+9J8i9/W5/9e/8gz/49z/56/8X/9Sv+NCvyiXjJOI0Q0nkxRqUxUlD5tpYMK6m5eYWYD3dEbDmgXEcUPHgPLU04dwFggS8aGsUDPjicRLwh4EwjvhSUT0xkJkOgcPlxKOLkenywHg5MgpMYbTG0OyRIW5YYYsREGp2FgkweHwciMfJ8L5zNoKBJFxIhhKNbZ2TErUReRQok6dcDhbpcVnRaojRebXmmTUlclq3OAovQvCO6GAMQvSeEc/gDDkuXvAy4oPDeRMqc32FuSgntX1AXq7Jp5XkBP/oSPDC7VvPKVoJF48YDhPeZUKAKI4wCUcdWTBcv3hB3Ij3iugdFDtW63hkvr6za/WjC4QMuaLOMrtzWVlLYa4rp6Qs84mai6FP18QynwjRCoy3z29ZbmbGwVuj7fUdQRxhGHl+u9S/8Xd/5k++N5refrfPfOYzf+j7v//7/5XXX3/9V3XEdReGNodLSlujWxeyTCA8Z+12PGR3rXSXeKkFKbIV9Huxvhfyr66uuLi4aBjgwuXlFZeXlwAm2F1dEVpOYC9qe++Jw+79NOR4Fw5qq1GN09RqhGUT5HwXr5y5be16txqis73HnG2/3xuHlmXh7u6O092Ju/m0FeYvDkemcbIoAS/EYSCGaAjOaeJ4cWQcxiYK2H3GyRDFz58/5/r6enM05ZwpraD+6muvIs+FkkuLAToyTdPmtukCwfWLa2toco55WXA4TncnSsOoX15ccnt7i6pu2MScc3Nu21pDnZJquufoAjbHU3dpukZR2QsCO2GhfupTn/rj742mt9/tr//1v/6Hfstv+S3/y/e9732/Yp/x19fdXTB7iLjck0D6ednFp30G4EMM5V7o2mN8H7rRcs6cTidOp5MJ+s1VN47j1miQdk0BwD1M6V7g6uLf3gHY3+v+M+yFv734t3fsddFtfxz6WHj4+ftr92PV3+M+P2+fr7jP2DscDqzrSoyRq6urDbO8d2T349GF14fvYe/6exnqdO9w7HPceQ6tGwK2N3z099MbELY51fv64z/+43/q3Th+Qu9qPfdzdlHNGtLPckj/t5yxnq1bs512m8DHDjMo0kTEc7JEE1DkvFkGnDqcGGtGmxvRNqfe8qz64h1QFbQU8LaxqyoNzGjFozVlpBSqF0YfGNaVtCZu58wQlOg9eUlEbyePeMecF1xyzXGTrAjdFBPNmbXOMIwc4kgYKykpcQgE8dS26HDeUJWaK8MBgrfnC9HhfMBXCxZP82yOmhjwLjSEpKGvdBjxh2JZPiImLPQQsiiWVVUTfvTtuGI4u2gDUr1liNToCbVyuLgi18p6s7KaIYLTdSIOwrPrW3y+Ybj0pCpMPhKBGFYGEQb1hJqhWgFOmzZi33nAHQSpmRHHuhTLKhytu47kwQdikCbuYghTVgoBiQ5CIV+fyKKEMKEiDD4wr9eIenyI3L11jb6yoMkjIZqzsFjhL6Go94Y6K5V1TpZFNEbWdQUqh+NIypnbu9kmF1s54EOgNMdkLcK6Zity0IscXViWs7Dd0UHVGV6quiajuXPRp09SarhPJIBzrCwMXonZBL7qW0HXZbyPpJYFI02AF1eIzS9YFDyZKpZFQc/+07OIJ32w9jBBdfdwn5x1wW9NMHjZ77+hsDB964/5Rq/39Nu3AX7sc0958pq5APczVu/jT5v4B56wiYD9VkomRMufohom0y4wxfKqxOPFU71YF3sIhtIdTBRMOZm7smTrgCvgx4AXG9sejx/MVZPWbKhOsfdQOxI0txyy6FGCuXu8N6wyQrE6vCEs1RxLiuBctXwOBQkHE6BDoeZE1YrUCZ8zec1oSqRTJq8n8rIip2s7d0LAec/Uug4nKqeaiGUhehPvfAwmTPiAGwKUjEuZQqAWjx9HE19aYcJpZZ5X/OSJY2xoW8tkjIPJ4aksrGs2gc5BiILLhu2MUeB4IM8recnosbQFiDkXSoUqnlQs529eEimtGNgYcrZ8lxg9JRXysiA01MnmoghU4K3bEymZAPdyYe/J11P3vqn8d37805fYAoHpKXEnAu5fb2JmZmp3T9+aQfbbFNLfCYXLN954/keuLg+/WsRtbQ/aF43VMHg0bNzZDdh90R1j6c84y0ArFto6JFcrlHVPjIQWWB3NHZzTatNxbuibosTQciZaBpgPYRv/VuiviFO0OedL+zL8EJqLxeFathfB8ndE7LpHcy1Zk5T9zcZ/xEWlhkwtyfB/qkgqkDK6ZvKykpaVvCy404pDTYQM3rr1QmDyQkyZmBeiD/jg8CGaWDd4nAuQPS4VilNqFvw4WrE1WGOC08KyrPgxEkdDp6ImyoTBow7WMtvxcLBINYxhrdQ1EyIcDgfSvJCXhB4GUCUGEy1yVSqOpErRuvH+FUdRw7RqrYRxIKdCmpM5HULDuLRjWHA8v7n9eD6d/rN3o2D3Thj/X/7c537klVce/7ByzoujCVhnLA/nqIAtT9w2k66Lgu4sCnbkVKeXmJ5kM0YplRiCdcaLbo/dlDXdAPntcbITve4LcuesQDaBrovUtYld3gu5GGLLprTaUL6c14xt8y3iqKqWf92LX5vQle2zVhPecy73zgAH9zqFu3tQtTbBUTcqoDTccs9PTfn8OToedJ/fJy2nzIkVLl07TuL6WrpnG9YzKabheg2l2jf9Dau6oUat863uftWbO845Im5DH1pjSDumyYofz1+8+MTzz33+T78n2L89b//53/g7//Gv+YFf9Hu9b3m9IaB5gZqpSXDeU5K5xQRPEMUVtUiIZM51CR71luWrtVB1JOeKpgwykIPHB6WKIOMF48GumeqgrIvlSeaVlDMuq1EvwoB3Fj8xHUYCQk0ZcQFqRqj4weggNRUb+35qDdUBhkgpkIJFcDhN5Pm2ZQj7hvlVavDgRmsMPih6TGhaDDleHWEp+CVZE8zdwnw7U+5uqcsCWpAxEsfIYRg5xsDRmZyo9Y4BwQ8eN474weH9RHSCz5WYKysDKUXIoHjCMUBdGTRxOiX8FJmOvjVQZXx06Bi5kAPX68I8r6QCaQkW+J0L9W5lGIRXri7Ip5X5+pb8+IIhwjhaM1VRJXtrRF5rYZ5XlrsTTgKLKvluRmslDtZEePPmc4YYGKYjmhOsCR8CEkc++vGf/eQnv/Dl/+y9kfT2vH32s5/9o6+//vq/vcfFdfdHd6I4bF+/LIu5Ab0nxDMS0px/Jg6ldd0ygLv7pheLh2FgGIatgaSUwt3pDq3KMs9bTt7hcNyQg734f784r5tQaVnaefs842TOv54b6NTdw3t2GoCLseViB7yXrfF4nEaGceDy8pJ1Tdzd3nJ7e8vN7TXPnj3n2bNnvPnmm3xx+QIUO0aH45FXX32Vq6srxnFkXheWtHI8XpgYCAxuYBxG3Ctn0WFZFta0NreVMA4jpRX6b25uiDFuokcXZUMIHA4H3njjDW5urkkpczweCSHw1rO3mJeZq6tHvPraa9zd3DIvM8MwbN+DfZ/SIqqqRQHsMtUMOX52Su0FjHt40CZgPH/+/JNf+tKX/sx7I+ntefuxH/ux/+u/8C/8C//mHq25F+P2mMo9bn6PCd6fH3vUZN6Ny70QuP95j5fcI0a7YNcxuPeaEnbY0IeC4/7fJngvm8jVc0v3+YBdkNsJ2vccgg+F0f3/9o/Zz08PEaMd69vnrI7p7Mch7BoT+mdYlmVD/+5F972Tss+p/ff9vXeh7qEA+PAz9Pm5u/86+rM3BIQQmunrbhMw+/vo4uWbb775iZ/8yZ/80+/GsRO6fNHRm+wMdW1v1X7sBTBDI2rL6XMbctD35EB6J+7G46K0PD9Plxpzewnr2rFFnWtdm+dNdyvQCVCs+1012Ea0Z3toAW8d4+oKqbm8cFByZVkzUy7gpLk+rCiYS8WnTPbC5AecD1Q8azoRfbWQ25yQVjSYDiMDjqqZXD3DGKDCejKW+HAwzvzqomUIOsCbQOCrglRKLmhe7HhmExYCBaLDaSuSOWEcBnK1DL2iSkkQWleteodEpTSNykehhoiqB20dLzGgWSnzieniwHI9w5DQeqQCh5oQKYgX8lpAnGG/ro428WQDhqwiJEBKRLyjrslyE4NhezSt22bdjcLAQC3Zsu8OA6UoWdW6fwH1IK3LUdUEjuFitIv6WiAYBnOIniiRMAneHTldn7gJgddfv7BFULa8PglwtxRKrtwuC9fXt0xXR3zwpCU3sdq476fbFfVqnVKr4sWZG4nmDK2Rsq5GVKmVgje3a0cK9Zy/UnHSsiddryvv+Mu14WfUOqu9tBwpAsUpITg0Z3Kt+AJTCDhXDeTnwUlkCHZ+F6Wh2TyqjiCgwZC8RaE0bFwvam8SvvYMTdkQVQ5tmqE099g30S+efAuCwjdyG937W0N9Pp1eLhyyR4H+HELVgKfXb/L+x6+1mWonBJZsbp0u9pGJvjkCgVKs6G4XSpBaqAmIDa1XjBWapOBjywwV322B7XnEcnwQcjFRzot9667lOHa3KbXiNJO7O80JKWegXfgk2nO3rvlSoDjLN9PWcV9LhWpZodrOQ5xDvUdLIYyeIoLU2syrgvOCD4E4VHIeyUsCbE5CmvNpiLgQqC1js7tgi5gAqSnb83lpzm976TAM7TwzkUUruBiICBKF4O1bMQRhAIUwBGRNSLVmixIK3rduIkBCZZyOnMSTlxN3t0IM4H0wd49WUrUcwpwqmgvZvopNROy5ButSqCsMB8spXNOmBlszQUpEJlLD0H4d+e7ncHvCk4a7fcoTnvCU6QnMT+1/PIFju2fsQ4H7UM95nnmyiYDfpga5PWDvHIzvuKLj/Nbz33f7Ha/+Tx5dTL9sux61d157p1+T+6oqQZzFENPy7Zzl3ZRaEa3UDBLE3PLZHOQiDh/6+HdnXF5z34oIhECuqwn57TUdVqB3GLKPWnG1UlI23Ka45sozt0vw4eye8eZCLE7NIescFUetGbSPf+i2YBWPukrwnrqKYb0Addac5IOhtnPK5FYgqaWAGGLUx4DEiG7jXykNx16doiVt84mKo4qRH8IYm3u+bm4rP0SC8/jo8b43c0lzBDl8tDlTUoZqRfkgQgz2mcTDOI2cBPK6cHvnicG1HEClqJLsUkjOVkAt2fDjubv/2nHJ64qWQpwsi7msuU1Sgarw1vMXf+O9Avzb93O/8YlP/J9uv/d7/2cXV1ffj4jRSJzhpcTJOU+uCXuopfB6J22s6Xmd5M5dvx2bed4nu038yqUQJWwqXy19vJo7LfjQBL8dnrJvurd90Rnzs3cY9kW1eNdIK7bmOAtzfsOFivRwBN0wpaoV13CmquaqLe01SjGhwYpobqNqeNl80+fu5tKdirUVO23dfHZayiZkqub7BRZ6E2nf9LfGqta8ZK5GPe8T+y6zo1EbqlRrbQ1xhjk9N5Lqluqn1Tat/dj3YkLPhKvamvqamNhFQJwjp8wbT998b/y/nQXAv/nTv+9f/K//4P/01/ySD/5SRXFBqNXGssUA2Di0a5ASnMNVR8lN0PYBJ5FcEi4tIIIPgznO04pSCNHhozEytAtwQSglU52hs+t0MAeuZgbv8CSihyFaunfJBVfA5UzNCy7Y9ajmFe+FMIxQfcPsroCQnVJag0EJdr1ya8LVSowOcd4wuhJQjAxEHJA0IBVChSmsyOCJk2c6DuRHR8pyQW74L3UeN0TiNCDR9h+qK1oSWhT1QhZrkCoo1Q9k8VQtSFXiwZp3cdXQ6wX8cWLwI+EQGSaLMNGGHq5VGYeRYRiJ8wlwrFmIfmCII8cD+Fi5PFxw98xzunnBi+sLLi8Cx+mIFsg1kZ0jlUrOSrpbWJdEvBhYUyHdzYzDiDjPzfNn1NPM4ZXXLWf85tbE1jiQ1fFjf//j72V/vY1vH/3oR3/vL/7Fv/h/fHl5+cs69q+7PEotzdRgl5ieC9bdNg8zuKw5z5pUugAIbu8W2dxle4d/rXVz3fnmJO6F+v3jUko2D4izbDwvzPOyNeX44DdcpXj7OSrEOLR8PXP5hWD7hMNh2kSF3qgTWnNAJ34cDweurq5Yllf5jvetzKcT17fXzPNsGFSxmuPxeLE9H+0YmgPf8PqlnLZrYHfqdCdkymmjf1etjOO0Of32GV+9uamLB7e3dzx//pzj4cCT972vfRaHF+HJ66/zIkaWeeFGbqxWsRPxTEjoBBRafAL3hJQuCO4RhBupoYk3X/rSl/7We6Po7Xv7c3/uz/2eH/qhH/ofvf766z/Qx/JeKNoLYP173+fe7Z18XTg+53vme6Jif3xft+9fY6sxNufhw1zAvWjWxb1+PorIhibtYl4XLrvztbvx9nl9/b2/TJz8eqLZy9ClX++2f/59fmAXImWXu9nH2P75H7oT+zHeo0D3wmE/tv35+hy9x7n2x+5Rq11sHYZhO/ZdWOzuycvLS2KMzPO8PX+MkY985CM/+m4dO0GaaKBOG0ai4z4b7gq2Tej9TZBD+mbM2XasY0S3zk/tAqLDq3Wq78yD9lAV60LrqrNYAK9Wey+G/ez3744Y2/x2l6JvgqRrm+dSMiIjKkKulXmteO+IU2SeV6izdceKMgwBFyMhCmuprHczborc3dwQwkBKttD2mhEiQxxZl4VbChHjTjsgOkdxlYsLy+ibLo4MQyA6GLynFpjXTOi8Px+ggAaPVDvBqw+IFnwMG37MV0XGQNaCb8JnrZVUTFxwwcJsaza2r0RP8NYBs54y8+kW8UpFkJSIYyQHSAgXjwd0LaRirkElUWoLPo7e6F8iSHV47yheWqcuVLHOG6fmQoiTiQJ6sk5A8eZALJphdKhUnAr5BJwK1RfkyvIRtwJBEMbgSfVIHIS7m8TlK5ecXtxwezszHQfiYEJzStWcPqfEaa7Ms2WuxeC4u7kl4xoC0Nn3H4LlNEnDrTkYhsB6MoRCatiEZhqhWqm1FVCLFQzxW8HDzv7eFS2bvU57ZqWFw6ESQAvVNSefVCQ6XBULrM+VIdqCxzvPqrbg8q1TumIiR1IT9KKTloHUsFZtQNU2ztrQtWJU63J3DZfUwZ/OfQsXgG+E/vz6esfXeY7p/t9f8nz39D+ewNOn35bo8uannvLkV71G9GwlIrknBuam+YTtb/aNtgUj1oknJUPJBBltU99kQzvbPFqFuiZKEArRukwnc+yJCGMMSDSkpQQhhgGnLTenFJvXir2DEAZKzW1+c1uTRQwB6V37wfIMfWw5kFqBSq4gWg1D6hzLWiBZBp5zUHKmZnPHaLVzOUglilAkIOPQ8LJ2vregQ+smbJhOceZMEu+hVDwmoFc6hrfiagsR90IhU9dKodo8FM35533LKnSCFssOFVoewxit8aHhF3U6EA+jCSsiMAVyyizzCSbLCSxq819p53oPZm+kVnNymU5BSYW6ZkN/BvuO65rbdx44rRkDJbf8v5eofecz8du01z2Bp1ui3wQ8McLok/MLpNmy/0KEAJyaFTDGqcnjM/O8f1IT876pKPlkL/zt8Sjpngj4j7ug+fP1+l/9ylt/4OJD3/nDEXUd5bwhkHuBX+9j9tCO1GtSXbWGC+eKFQm3LDBr6rAmJ8vLy1XNwVsrsTnaRRxDDPhoCyvxjjAEW1/lNv5LbddQwftojpfNJWTvO0SPOHMYqQOR2ormthaiWIaZVBO4vDjWNVt7QykgNv5LrltRXFBCc9lGibgpmoOn7ZvVLva2SRHLPXTNTaTeQ3MTWoOPXUOza8/rw+ZWLClTqBB7t6OJlx2dXYu28WeboSFGwwD2Ysc0MRxGas3WrHKI5DWxzjOMEaKJOalUcwFXpRal5HMBp7Z8VAmGIcprbvNx6ygsxb5v5zjNeX32xlv/4S+kwr6+Q1/rH+Vrf/bTn/4Pv/+X//If9lZhsgYoDBHVXX442Vxq0oWrWtvv27ZH7bzv+5TasgJzyUQXmntArBGl6ubKjQ2J01dZ5tg7Z3No66p07bpa21xkYlf7vZezja2JlbbZLm09YJk2lrPjGkIztHXrGXFVClvDg4meEMQe13GltM/pOYuJ2ty0wYcmGFozmWFSm1iCNUoEbw5A+0xyrzjSN/X9O+6betBz5uH2O7bj0u9/LryyCZd1V7jouX/dbdgRaob6dNuZVUv7LvOZcFMbxtREzEwpZf30P/zEH3y3jv93yu1P/79/6kd+4EPv/z3jEFx1obFlW5Nwrfd4Q9IaWLyrFAIuBNS3bO45WeNejIQ4NNG4UOrSahFCSZmaKxo8aV1wg+dwNNS8ThGJnmmAYfIM02Drg6yQK2IXW5RICAdrKG2UGS1tDTEN1OpZ19JqMhVt10i3YYQzWiz/E63kvFiciHfgYV0S65xNbHAVR2bQSgj22ZlGlLHBnhzFOzQI4sdWqDyAZtvhumC1nmzPl1RIKZMkQ82M0wghUnyhnDJZwV2OHC4GfLR9h48m/ucM5ZQgOKYxUo/mtHJxwAVhevSYQVfQFT94pE6UdeX6+TO8uyLGAa1KLkqqrRExJ+pqQo/znjSf0FoIo60dlutbLo8j08XRCofJipcuDHzhzRfrX/6Jv/cfvTeC3t63T3ziEz/ya37Nr/m3VdXt8/zSmrZrcHd/9Gv6PtOqF7WXZcF3d20vTmOCQC9wz/PC7e3N9hrTNLUxYwXlnrPXxbFeyL67uyOlRPAB72w9P5/mRqsy0pdhPhvaD7bmeVDSmkgklnW1LO9gQmMvePcieKnmiqltfS9iQuQ0HTgcDpSrS17Lrxouv1/DxbXnDOccMWevH3eF/e5s2gQP56wGKsK6Lk10rYzjQIwXDS/udoJdaQj0szAytAZi5xyPHz/eCvzeew6Hw5ZVNo7jJgLknDndnTaxNKdCrYVhHE3kbd9rSmkTXvr76OdDE2XXj33sY//+eyPo7X378Ic//Id+22/7bb+nj/9+/vRbXxvvnXV7d99DHOb+MXts7F5QPK+3y3Ze9f92sX9/nu9de3pvPXv/Ofrj+njrP6/res/J11+nP18X5F6WT/jQ0ffQ/ffw73vxrzzYX3Rhcp+rvXcA7l2J+7y+Pr/O87x9nv3z9NfaOzP7e+q/2+cF9vv277K/dnf89jl9nme891xcXGyP3bkM17/0l/7Sv/euFQANXdgFPSs4Ody5Y7JN8q6Jg7Xdzy5JzjLoLNCvHdxWTd4yBaHqeYPdsTfi7m92tNazc65LjJuowubmEOwC0p7FunlrwYkwDQM1WzE46QLeOP1DzqTViuCli4ajZ0mJWhMTQo4jaypkVULNlCyM0VEF1qY055yIoaF5sh2rpNUW1M6K/3U9gcRW2DJhJmWIwRNDtCJ/TobCUiuk1Wqt7IpSnbaFr+EIUXBeiSqGMnMOqiBSW46YUpZsSLBaWJdCak6clCprXZnGgBMh1RVfHD4A1VFP1rkYgiE1KFBv7pinSBgOWKesQ2JAW0HTVSXlbN3HU0R6gHgriLgo+GCigRdPTuZccpIhScP6WKexLgkRQ5eVai4n7x0+DNSc8cWKrBePLigFTqcVH4/GNS/2PiR63KoMIVBFWBfrakoKS6pMQ0TI+EOgzBmyYxgjPgjrspAL9r2nfEbXtmJNd8TSu0i9QyTYCeRs26a7TBVzgxmewIkgBJOlneEfcdWEXOfxUXC1UEulhMaFF4FSOeVKXitDjG1hBkUrtUARZ/YIXxB1qDTBvbodfXeHoGoBzrjzpL/3Bb5UkHuoLvxcXIDfplby9CnNLfX138Y30yuv3rzjg+87NozvGfvZxT+T8qz4zD1hMGxYyJ43mnNhuAcKbYWnhrIjVdYmjkk1SaUNK8u78+amU1rR3gZyW9xmFEPmqlZ7XGVD5LlWjHdYwcBHoWjBNydAcQXVzJoTY4zkrOTVsrK0CZtaM2VtxfquTzdMshaTrr0TqkD0AaSSS7Zz2AkSB2o0kYIghOjQnKxRQKFWMVxzzqj0zxzIZMhimCORVnzYghShVDSZUBEO0VzSLuKj2Gk9DLjasIoO4sXImvzmxFLBRMbSxk4FLSZ8dh2zluaY8JAX+30YrFGj1nLvO33jzRecgDQ//RbPsm82GPZnb3e8Tl/zqOklZ3eIcEgzJ+AuzRwjRCbm3Vh4wl7Y+2ZvLX1dsf3pO6zYeHrr+e9/9uqjf+n1Vy9+nRexDJ/W/dvnc1rB2Hm3UQ+6oK7VhDhtThKXK2GQtubp65i2HqlKqJW1OQFrN/w3pF0QDyHYdVNle17DmQulps19pyiesyNRhS1Dy2FuweBtjWPd/kJtbrtUEkMcyCmR12Sb6+6MKb17seUpt3lL2t9wJhwqjtgcvaUWytIcgTGg4nEhmjjvHFoSEqTlnViBtfbxL7J1C/esNefOLvrN1VTNnZdzJRw9eMscdVGQ0MapKinZQ6IfWWOg5rzFhNlmom0AqjmcaqnnrjKtm9CQV8s8dA33VFunMuLBOd58fv13a8p/+9228Nd32Ph/85Of/P0vPvjBf/n1J09+rW3EbaHv97lyLWTZOT0TRhoSHhe2+9Wqu6IVhtIV92AtcHbw9XxRrQ0j2t1vqmecfH92vb/5NpoEm/i/dcDuilVebM8h3jfR0cgW+w7fvl8yvGUrdjjXGtjORQy8nDGnXdRrSE73IPfEEPPmlutFjNJQpAqE0PZkzt07Zq4RCWo1qotr+OSeP+hErNGzCXneaUN6ue149c27tDW4OEcu55z4jnc18dCd57qW39QFYMt+q7tGjrZWr5laKm+88dZPn95842+8W8f/O+X25370p3/vf/M3/Mp/6Tf8qu/5QS8BhoGaEr40BHi1xjBF8MGcKAGlaqKWjKYC2YgfKVf0LiNXgepsDYv3ONeQn7lScyKPEXWBwTQ3i8/wHucj4TARjhM+RrwK3oGLozXvlIpItGagUi21OBeqU+rgjD4AOJcN/SmWk6UO1HmK85RqtYuAh5xZTplknbw4L6R1Zb6bbcwEcwgLxeoK2gZpG4fShMWyVEqdKT5Qxgk/DWgc0NakI2VFU0KrkFMga7U2WG+ofT96klPq7AnOE+OIknBUo6xUWN9aWV4sZK2EVzzRe8siH8UaJ4cDro6U9QbnITwaqeWAq7nhlq3pOCWjOJVaKUlJ64qEYASFujJMEyDM1zdQC4dXHiHek+5ONi96j/rAT37kU3/n6bMX7zmA3ua3j370oz/8Pd/zPf+Dx48f/1c7em7fgLMvSq/rypqyCc87d0x38vX79f15Lue8LlVlWWaev3jBxcUFh2lq4uKw4b3FCSHEVqx2G6KulrqJkB1LV2s1CklrRqq1Epw5+kJzypdi9ala7fGomlDpPSEOnE4nbm5uuLu7a45+c7b3DKzpMNErAG7fpIPb0IRWZD+j9Hs+19iQp9bwVBGZN7fjMA5IspzhGCzupNeUxnFkmiZbY8j9rLSO6HPOcM2H46E5Lv2WFdjdRtPh0I75shXtc87My8y8LITgG5L17OrrgsTe+dX/vV8vee/5/Oc//3feeuut98b/2/z2F/7CX/i9v+7X/br//gc/+MFf23/30KG3z+Dcj/c9IrQLVaUUhmG4J4w9FMT2z78XsTan7w49+xCtuXeh7m/dNdiFrWVZduJ53sTs/evux0sX7/cC4/519w7Bvfj3MrHwoTO6r8n3OYd7ga7Pnf3+e5zqvnlgnudNmEspbfmr+8/dxdiH773/bi+A9mO9dxvus/9qrTx69IhpmjidTvfQo1/84hd/+lOf+tRPvGsFwLMw0EtirXe0UWoakLPl/xlGsGN2zhg4K3K1Utluk3zO7HOUFiLozaXRdyGbyNcQHb1zd3tH7iwuNmHLbY4/3Tb23sFhHFhIzLXim4hZc2E9Wc6foLhaKNWhuZKTsiwnEx+95+5uYVVlbG/tlFZUBS9Kro5c4VQyKWXG6Btm1NxauRS8RnPvAUUzwQ/Q0B/dlQUw363WkThN5GWhFhO/ck3WuZiaW8kHsma0UU2lbaxxsK4FvFJXJVelLIspucVRat7kjhAcaS24Jpyuy8oYxfQR79F1xTeXQikQLwNpWVmfQzxElIJ3jngYycudvUaM5kDLK6qte1CVIQglTBbQpZZT54JvSKZAaZjXJWWcqwy+uSNWcybGyY68qwXNicsnF9zdJsbgObx6YFnTpg+7ajmEWhLLcmLdsikNfbDuULBpWS3zRCuxVXKnITKfGsJUxXLUam2YIdeKwjYInN9ZobUXg5tdeTvH2bJdxDdc6yZ3m/PA+dAcF5XqlCCVkhxSMPytmpsqUFjWwlITLgS8U4J4llRICqI9P/A8oTs5C+4Ov+WjNGPZlouizjKqtk3gN1LZXiYCPsSDPv0W9JKnwJP5jAB98o1FwKc/B+CiPeXMukSGkbMIaMPgbPUrJvqJt58FTPjqfy65YSYhSxOL2nxVMaRvrQJSid4TvBCawNYFKNVWTPMCIoYbFm9d/dUuWDThl9YwoUB1BXVCCLSCvznxUjGRwoXYCmSNl10KczUebFpW2+y7lm2XzSlXqVAaZgAM2+POYqb9N1OLzas524Ij5YyrAy5CVk8YouVmZsvsqq7gxgHX5jS8FT9kgFXtSEkUilbEBXqjyVoyOVVrVD4KGZCSCNOIj4FSzb0kWxeWIH6wY9i+Q2kI21IrJWMo0FRMePHt/AfKcnb/heBRigm83i59y7qXhtuJ+vQfxWU28pTUZL/53gBIdtoSmqYXYnMMXsPdDEwz0wTzbL//usPvyf3X2wTCJ994WL+TCoFf/eqb/97VxfQHxsEN1vTgNiHAuYajU+vAd+JwrUvCNvr77lBz5pBrc+y4ttqwho+q5gmORrG2fMvWWGTzuxpesDnfcql459vFIJNTboXq/n5cG//OMmrtaryN/174Fm9kgN4wpVpZis3n1sxi7118Q5PVYu4+Z6KdqM0JviNQtc07yoYZyynZh8keqSMEJYeKb0WAUmw8VafIEHfj3xFaoZHFiiAShNKRhW3tuJZCSYq4SnADxRWomShWLC0N3ykt98T5tpEI3nLEmjjinLmVSq0NT9RD3VuzWHWklM0N2PJedHP/WDF1SZWvvvHs//5uLq6/k8b/Zz7xyd/36NErfzgEH/diljTHW6l23cH5DVPpGqrdcvt0Q/HuNif3RD+RM1PAinZ6Roz6tg/w3taHvfhVzxvXquWeI7Dn6pme2N5rF/b6xpdzXEJ3ve03+a7liG7Z7MqWP1q1uwDkXrSDVkV922Bjc0w/Tg2lsjkToSFDWwOTF79rINPdBr27HR39/+i4UWcTTN+gd6eeVnNpngPN9R7KyDlzX9b2WbTq+flatrxWwyyn5uz13pNanuu+eauUytkfaPvDz/7sZ//Ue+PqnXH7Y//Fj/7wL/0n3v+HX73y0RFwAZzOuNKdt2rXejG3Hl7QXJnn24butHFREJaU8EuwuoFYE2eVYOehRKorDMFyOEPHiTT0P87hfLC8XPEUBZFo+4p8oi6JkjIaBacOKXZdqkO05ygKteBqQTTjWvNndnZdTEUpKSE+UZ03is+cyVWhVMOKFmuYKw5qNiFcasGrZY/b+khQVyw6oOXtaE4kvcOPK249omPBjdVyAkXQ1jijtaLjiDqhOMWLEv0Ao4mjoh4/CkpozjxBVMllpaxQUsJfTYisSFmY/CV+nFiWRC0Vr9Y0GwYjOYUgjJM383KxNqdcMjmXDQEm3hODEGRk8J71biHd3jIeD4zHgxEYsjm+fYhcn1b+8k/8/T/93sh5Z9w+8jMf+eHf8Ot/w4947+OyLEyTufB6Dl+MYStEq1Zr5m5F917AdtJxkXaNsDqCNZv2XKncsPXj2MQx8T2Fo11nCrhGxtjlEeIgrYl5MQTd4XCwehFtvdHyf7VWy8tpzYu5FFJamWTaHC7zPDcHTKXWwvX1Dcs6b+JlLbWJgIk1rVtzTC/O92J5jMGyMJ1sLsKUrSh/OBw5Hg8cD0cuLy8JPrD0Yn87pij2+WolhrgJhb0mZSKft2idhkbcXmOwwn9aE688foVhGDbBAyyja4gRDoctO7Bj/WqpG42hCx/7vDBpkQ5d8NnjQLswoap88pOf/JPvjZx3xu0v/sW/+O/+rt/1u/6g9z52UWovGvV190NRqQtJfb+w1dda01x3su3FxH7+7BsM9iJWFxQf4jr72nb/XvZ5hQ+Rn90d/BCTuRfr9vuTvZPxZXl+D8W+vRC4/9/+2Dx0K+7zC/v73+NO9/fbi6xd+K+1cjqdtty+fS7i/rjuxcq9oP8wA7DP3/uM0Y5UXZaFYbA81D1utTc4/NRP/dR/+m4eM0Fo2X99m9mKUrIVzBoCdCdnbCeg61sp67CrDpx4nNWcrauTs3Bl/y6t5iXbU7h2sdDW3UnDgnLeYp437NL/DmCCjasg0S5mqYtnrSOFCmtaISlDGBHvOJ1OrWZlgllKhXVZuLu5papyc50Jr0+gwnwzc7wIJA9+DWhsh8E7Kp7LMdom1Hk0WbeboUOqCXEuIAplWXHD0Fw9raNHgqEB12QFLqv8k5ogWELBSyDVzEZmbV1veS3gK5qrbQpyxQVD8jkv1hGvBcFwHTkr3jvu1owj4NThh/Z8S8YFb3GKg1C9o9ZESo4Qhfn2tgkHasiRXjDV1mEVvOXNecXbF2/dC7UiwSOlQsN1yODxqRKGyPToiIvW/Rh8ywRC8P6OMI5MF5cEuQWJ4DyQWddEbWzHnAspZcR7dK2GcMmZu7sFf4hMh5HTaUGCJ3rhdJOYpoFpiix3Mze3J5bUurTFQWmZK9KQbTTnXDXRGmfdm67lHVjBQ7duYyt5eBtP0hwHqohYBqWZFCwPIpdCdd6EnVTIQXCDbSgvxMMgLGtt74MWEO8tE6pUpLlqlS4gnV259zq93DZMW1uMOzt2+zj+uujOlygGL1feuEdJ7I+/lyM4fWPz1F7NePpzS12LceIrX7nmg7/oNXNtNhyoNMHHkylNA+zaXgVYM/iOpbPcvS4NhQ0Dyuaug8acbxZDrSaYxSCtAGAZWtJAstKKVjhHyStOISuQ8yY6upYhhlbSUoyD74NtakXI1VBjNWdKsvw+5xqGqzRUVjMTCBW8OaRdrZSc0AwrFY/lbEoTyVzr/AMhUw1dS0EolGWlrpk4BFItNpYB1dKQe7IJAGvJDC40dEmbA2rd0Kh2TC0nKTQHrgyBQKWuC+KEcTyw5pW6rs1h0JwGEoyYXDK5VNacKbWSGtEs5eaWDjSXlX1Fy2qbiTAEnIeynB2eAG/cXlvu30tPwm+man+9wfHkJWNq79YzIW++93pPiemJiYDAVZy4nmbSbFrg/cfycwWSvuOLmuv17R996/nN7/iOJ6/8dz0mwlfO5lOhZduV2uaENncrIGfnTVHF1YrLlpNrOVbaMHltzhXOTUiqpFxwwXJanTjD4HakelGKWrdBLdm67auNI9eL62IZnl6VtGa8E8vMDZ4gltWVS7GsuybSObHCvavmUjJHnzZ0UCvEt87BWrR17JtALhbWges8fYTUi/lqYmFeFlhXhhhtLAffDFMmutFyUkBJDT1qGwC7bmY1Z4+5pKwKL+LwY8QHh9/G/4oIDONo3XxtDdfHv3cejS0PIGfWbPNAKXYcU8sBEW/zT1+7ltW6tuMQTSDI1fqSmqD7/Obm0/OLF//O22nBru/S1/5Wbi8+/7k//pXv+q7f8Z0f+O5/0XNGPWnJKMGctOVcFNKqDQZg67QuBtaG4bQ9iTWz9Mw451qxvirFWcFQmkhXq1rmYH0g/vUNsbaM3IbC1L1rjo4BZvs3LTcT1c3c2r8EcTRAPVumnza0pTWH0a6dfmundH1jv228zk1twRtm03IM7bqN0ybmKT40cb3h7l0b44bSbDnZ7bh4f27Q6c6LLfLByb1MFdkQYa3gIrJhvR1GvkA38+/mxi4NI1bbZyrte+2ZgarmrPiawkhvclXl+ubm01/42Md+73vj/51x+1v/4B/+8f/Xj33kd/y2f+YH/0Wr3wthmCBlayyOHl0TNWdz12vFaYIl2X3Emi0Trei+ZGIUJFjGZa3OmmlYQCrOJTwOhzWu+GA5tjhBfUWlUrVQskOK7bdrSZs7p1SHVNCUGi3DSEu5rJYVLLavprlY85qo60xZFpSCBGeI/7XlX6LmVgRz3osiRSmpklOlVMPkj21P4ZytU0pVasac/qJQTcRbT3eUZaHGQJ1GymQNf6UWUipkHHGIFJSkhVDrtgd23lNbvqoXb6KdmrvRH0eCn6iXI3kGt8yE4BgPR5yszPkFBCEOnjgIIpHhMKGY4FdSIVUlVUhFmdNKyYnD8ZIYpDU4V5brWwQ4Xh7w3qIbelHXhcBHP/7Zz/zkz3z897w3ct4Zt8999nN/7PMf/Pzv/MAHPvDfSykxz3Nzh/WCMU0QzNv1IoRAqQUK93LitK2Fg7cxaOhtK6yLFy6vrjhMB3ywdcSazoXshpZr5VTL5VuWZXPxAJvz7ixIahO33JY76FrNx2Hr5lIL1zc33N7dWgxBKqTV3C8pp7OTUM7NOcuysq7J8gmr7b/7a3sR1tVchrYuOBf315S4uzvx4kXk0dUV67oyjhOpuRlTcyP162splWEc8A8ENnG9YYh7mWpePOPFyPFw4Nlbb4HCNE2s68rtzY1FCIVACPGem7Nfx7tQ6JwdF5St8O+935CivRlq74aqDW/+7Nmzn/34xz/+w++NnHfG7Ud/9Ef/6K//9b/+d/6KX/ErfuvXrJtekvv30L32UAjr4lMXmPfZfHsx8GHeYBfD+ut0AfqhWLfP8NujMh8iNvcZmtbIcB4TD91xPVdw/7h7RhF3H8n7UNh76Bx8iCTdC5R7tHJKaZvj9mO95/3tMZ19PHaBrueE9rnx4Xewzwx9KCruXYq9QWCPcwa4uLhgmqZtno0xMo4jz58///Sf//N//t95N4+ZsMFp9JzDYPkTmwWwCYHu3KXSo9hrQ665hq2iq9o9j+/sDNxSt9ScNGi/RDXh5F5XbPfT6LZBVa2cYTrnweraZla8FbSG6FmyUJLxchc1P4Q4WMvCdDERw0BeEwQbuGsBPycET/SV67uVi2VFDiNVYDmteBGGQVmaEEbKjEGpyZHFczw6/BCbM00ND9kLjS0bR1EkBPw0Gs+/ZnCO5Byi1qHra0XFk3Pr3DUIz9apn06rFSi95cYVUXIqeG+CmHiPa1309viAC7bwz1mJ4pjvChdTNDecmLOxaCEIhBqQccKV1ToNKfhSWG5O+MPIEM1Rp83hFodWFMyJrIJgi4HaoCMuqcFHcsUFiIeBOA6GJZm8FeQEXBAkZ7JzDJeDoVvSiveR0rr5y1pZlkwNwrwkltU29LkVe52PPHvrmlMqvP+1S/KSmNfMq69dUBZzgUbv8ep5fnu7uakQh66lZSvquQTjdhkmqpZXue3Cz7kmtMJIzwe0LskzQ16dGD41FyqeIrrllHknUAtrUXx15rj0losgquTazjcc4gZaHZVadCvAGDnUjnMjJDcX725MckYzPewC+Rpd48nXEfn4OtrHk29wn5e9zrciJH67tydnjeT5szteffyIWrIhYaxvz+S65vzrwmAtqS0CIviM78JgOTsIQ4EsKx6QMOCloOo5071MkTZcmICH0DbSWjpBtuLEXL01gg/SMscyTqxY5tsYpzpyURMDc9029VQlr9kQft6QmVqtG65qbVS7s/PBVfC9UaJW1lQQ8eRUGX1FxN6H1opK3DLCamUT+mpJpJMJ6+EwWS5lE1FqrQxDoDqsMaAXJGPYsIglV4KClozzYm5jL/hBYIgMwVyAqpV1OeGdEMbQBE67b2k2vZRhPi0sqVJypWhpjsECZJwf7JuQlglQ7DsWseaGXOx+QmAtcH13vZ0+c3P//f9nAHxyX/A+S9NN6kttmE33lL2ZM0KWNBPiRIyWD7gfnE+Y7r2/p19Xtkz3XvtrcKH/JRUU/3EUK7/8xa/+r64uD//U1XH6TnPlyLYm6cQ/VM3x6rQF4DVagT8X4M8YPHOn5NVtmBovuq2PtOH7erZYVW/owT7+FTS3TGVRa+KIivhKbfhanJqAF3zDgTtStYzhXGpvgTL34G78WzG9tkwww4fa3N7RYnT2IVoLy5pxzlOcufW9s2J9VcMTe2/Yoc0xWRXNmVQSmjPxMJ1xPtmK7zIEilPrJGvXTD9EG//NdRPaWsiJ241/D0Ng8G38VyXNCyKOOPrWoW2IspLt+pdS4jQn1pTJuRr5oJoTAG3CQ0MM1iaI+IZUtqzAVsARR87Kl9949mff7QV1fZs//8PbJz/yD37349de+6HDYXq/eN+KXuecu97N65yjloKoR512zskmimsf+2r7n+6oM+dYsUavvtlVy8e0rLzaMgTPjjZ7bu7hP/tc1KMWujOvGeUM0+ndOSuvPcB5E/IAayxSm2O82LrDfnZNfJOW/+fudfVua1rO75e+9mAzAG7PtV3X5fzfjlYWcW3esQfF6BuO9xzn0F0AtbmW91naHQPqWhZZx5W2/oQN09pxn9t8y9m9aHvEujW89fnQ7R7XG0P7XJ9S4rOf+dyffU9Qe2fdfuTP/bXf/Wt/6ff80H/lu7/j/SkXJAZ8cJAWHC0zr2ZrMuno6GznWAkOiRa/UUq2fL/qYc2sXg3NFwPOJRA1h72Yw602BHB1ARcDEoxkQ3GwOgiQ1Nb6/hgpK3gcZclUbAyLViRDSbbOd6I4L6izZt6aF8piOcJu8LavLubuy7WgrhLEQbJ1txYILdd4XVfulkIlMHrHVYQxQJRiueaieBkYhkBw3vYipVLTTFoKdR6pV4/wQ2TNhXnOVBeQKVoTr1iVBxHkcECd0UJqaghwCuo88ThRnMMNnnIYGL0doloq6e4OEcd4DDhnGekiAXGeosK6VO5Od6TiKMWx5EKqxfCfKHEMtoYJnrRas+Q4DoyHsTmz2johBNas/OUf/3t/9r0R8866/X//3t/73a+++uqvDyG8P+fMaZ5xylZoHsdxW6/3AnIMwS5XLYO3C1eVc7MQmNOtu1HGcSQOgzXSNUKUFen9huBcxFCkPfMqhMDxeLznAtrch1qJGrfaTEorOSec2LXLrnMLa2quljjggmNZVub5RMppcxUaRSOhWKPe6XTH7d3dhtGcpolxGE2oDGdc+DCODMNgmM1iiL6bm2uWeeZ0mnl0dYWqMs8z8zJvQqJzmMvPscv0U8s39+5rUJy9LhZj5NVXX2WeLTvwxYsXJnAMw711j3MmwGoTda+vr5uJo60NSsG5s/Dqdt1STkw82AQeOkEg8KlPferPvDdi3lm3P/En/sS/+n3f932/7ng8fsfLRMAu+HWhuLtSNz1hJwr2JrU9PrSLzPsa6kNBcO/se5iNt3cWyo5Ssnfe9TlnGIbtOfYi4MMcwD16dC/w7R2zL8OB7n//0Nm4dwB2MbL/vYt53XXXxbaHKNSO5oRz5qL3fhP8uri4F/72At8+k/Hhc+6Fxv5+9+6//vgYIxcXF5sI6Zxhj4dh4Md+7Mfe9eM/dJVj69DsTiLncLpz5W374SbZnfPbWydp3XaN1TmkbeRo3d+G4JKzI6mJEoag81t+jt2sM/5cPehiYOs81R76Lht21OEYguPVR0dqqVzfZdsmFqX4im/s6HVdWz5b67xxgejh9nYhBBgOIzEraUlMFweiB4pjnhPjMeGLhXEzDOCEmyUxjGbjr1mR6qiDuSA9sK6zddSHuGVsWCecuf8cjvEwkntmhbbO2VKpzeIO9rN9O+ZAC82ZUEsBNfRILtY170Kb5FxgGAPrbaHI2nCH5pYcR48uK+IDQ7BvWEbfLr6ZNZlbMXjAC2kp+JzxoqTM5ibQAjIG+z7V2JxuiLilonlhqRXmSjwKTsWyeLxQU9m+S4nBFirPT0yPRvw44nxBRUglty7qQFFlVqWeVlI2HGZOmXXNDF5IakLp8TCQa+XF9R3jYSSKR12xTD0vFLUMRj9MpHkhryuldia0UvSci0kr5lQFr27rWLaiSXMUdNcTrUNU3bbhEbUu8CpqCJrmIhEXEDVEm6iSsjINhgJdVrWOUL+iWcnt+YRMcKH7zlo3s5jjyzmSWod07/5uxpZtodSzPK2YvMum+WbRZi8T776eWPj0m/zupULfBE/nBw/79l2AU4RXr674ypvXXJajieINWSf7O3ooJe0yArdf735lGYKliUg5g/jCGIqldjkj3WZX0AKjH3BxQMUwxrVAXZOdS82G5AeHSEQGoaTcsvFCy8kCfCu808S/JZsDxje3pza0bhPuDENrbjiHCQrd7RQQExqrFdgJiSEVci645uQbxATjDOAKMkQLNm8CXy4Nn9HCJbVUqmuZCKt1E9ZcCaGJf9paM7xHM+SOOhIIHiQE3OjRXKwgGISSLPevFMss9CHgJFjuZZtfcstwTTmzNvEvlWJuzmzdmyKBIFDFUynW7expriB/L/uvAtd3M4fjFaeUSNfzz0Fp/ga/68jbTQRMLxHudjjQp09JT+DQHIBzU/4iT7m+98Tz14iA395oMTHwF1IG4M/362vKP/OFL73x+7/ve97/bwbvnaHt3DYP9uJ21YqrG8O8rXFarlft99StQJ7XZALg5Knq8E7IVXFSoRQGLxAHVASpBc3W4eYruJYZ60dDgkk0h7nr149gECDXMklqNZfguqS2GXAbvlSruY99kFb8L3Z/ugPJOobNSeMQ0W2+zzhSqSbAAYM3t5xBFSxrNA5h6+gtObcCXCvWl4JWtxEIxHtqKjb+W/HEioABzYYlrtmcgd6DC4NlppY2/n3Dow2juXvXRIh2jEKwBgttmcM5K2ktLftHNwdQLhVaR6/41jKl2pCGdkx98K1B5pwdfXN39/T5G2/+679Qhex3igD4X/br59vbj376Ex///T/wy3/5/9E55/aIHrzbnPi1lJb/U9Eqdo7KfXda7XuUag7eELroZ2jbgKGCO4aqNgcMbZ/SkZP7fqtzQeH8u44Z7sis3rl+77bbsPe+swrEEM6OuV2RIXjf3Im2Tjgj7DnnQSubaF6LEQRqUVxsyK7a0MM7ZGdv9Dxnup87dYOXzfVnGaNsGFFt7sjt84qc8951F/PQHZOVXdbKDqfU5sBS6pbJas6+Xow5i46lmDOqXwNy0Q2dPJ/mr3z87/+D/8O7ffy/025feevFR//I//Nv/rv/6r/83/rXx2GUUhqlpfM7pMnHrp1DpdcjbC2tWpDWjEkt1BLJrrK62dCSOBwBdRYLUnS17L9hRA+XqDjL2VsraV6grFQCyTviRWC4mBDnEQIlFaPiHLzh+L1Q1JpVSi7Uas5ASw+o1Fw255KzMFxKzq0ZTi1DsAqu9DEleFetsdeBz5bznTyG1RRHxHCj0TtiqEzT0MaUzVFOhtZwIOSUKLmyVmW9Kzhp+PAi+GGktP2yixN5VtbbmTQnkmamSXAHTzhOTM4ZxSeIIT6zY8kLS5ktCmQYiLEhSqtjTZWcTpRcWBYMe14hayK1/PNhEIbR3EyIzcvBO6aLiTCMbU9T8CKIj/zDn/3SV/6LH/u7/9v3Rsw763Zzff2Rj3/84//eD/zAL/nfi4jruVlDGDb03D6rtotiPTf7Ya4uyr3f9YJ+jNHcge0a2ovPvfC8rutW9IZzJt7l5RWlZE6n01a4HoZhJ0LYvNQL46VFgYQQULThNrswUbi9u+X6+gaoxBjOzrvmFrL3HAk+cJtuWVpUiHOe0PIE59NMjNGEwXG0Y7G0PPNWUC85c3eyzMJ1Xbm5uSHGyPFwxHm3NVqrWk5haTmBXSjoLp4uanQxIcbI5eUFJRejKLXntOZ2t7mEpmnasgDn2XIIh3EkNrePF28i5G4tZI7PuOWGixgZzTnHixcvvvKRj3zk33hvxLyzbl/84hd/5i/8hb/we3/7b//t/xa7st9DV9ke77nPAHzoxttjI/cuvL3QvBfw+pjuf38o/N2bW14ivO3fV7/v/rn2IuG+yW2fydfHf/9M+1zA/hkeiqL95y6+3WsY3B2zh5jSLsZ1R+D+PbwMmdoxnXt06P4xD3MA+2P3QuQe7brP/Oxz8/67Ox6PjI0s1K8FMUZOp9NX/syf+TPv+vEfUL2XdqFUE2q2jIdWDGtdmr1AbeHyvTFV+xm0uYx6Ma1iXaubJUTZHC2GAm0oOwXPLpuM2sS9hppzTQTkvCHVau/B5BfHcRx4fHlJKpBrYUnFcqLapq9UZU2FYXCsRdGiOJdw3kSakh1uzngxmeR0e9sQeIN12qyFR5cHtCYohSpCysrhaHjLoooEc3Qt87rtb8cgRGuTQapajkDK9pm9bbrVW1dtcX2TWjbxVGmdgLW2vL4OF3T46K1oVhUNEVesUBGCxyGsJVM9DH4gBs/tvOCPI8Po0egJPrCuCw7HNFjnncQR7zNLTYzRE0Zhns7IHRUYghCAvNQNeVSwoht3qyG/lsxpXljvZl4dH8PgGYI3vIlaOkDxggRPTYqOjowyUNGOJShKSpWqK8spWUYAtBw722yJOG7vFnNqOuv2Xk8rWRy+feeWRWTdy7enlVPO3N3NrGs2J5ZzVNeFaUdt3cVdqHZNbMMJKsFyGbQXXczxRMMm2djwJni33ENzgFix1bX79qJucQGvlWXNXF1MLMXQDto3eW0Bhaub2FhbN7QaxbanYbZB6boZg32WTbv8bEL81wpx36L491B1eMI3FhKffCPFYoYn00vcV0+/bQnwECKvXl6xZvjMF97k+37Ra72fYMN4tpg48LEJfMlyvEiY54YtG9CK7z1HMDRxzW/HUmuliOBbhh/VClhQKRXL43C22ZYAzgebE3OmJhN/nfH6DMEFlPM0ec5QpQl7FUJsOEs196iqMDhpWNrmIt4c16ApowXcEInDSGpZP2MwZDIl49YFHyJxGhhitHysNTFUMeHbCy60XDQ1/OwwmDjnSqYUyx1banM5hghrIa8rWmAh4Q4jYs2Slh1AQ5IA1VtzQKkZT0Cdb+JeIuVMyhWKzTOIUKg2cZa1XezN2VibINhJauJBov2+VsN/CoEMvHW6I6WZvfb37bv/XnLCP9mJ2t+qSPfEHnRKcHWcyAlSms9S3dP2Wk8APvgtDc3zLX2NCPgLNQPw5+u9XL/5/N/+6uXhN3/nk1d+C80l19OfxLlW6LfBprt1zhaSpQ7Z5WvZ72RzyjgnG/KvbKJ7cwSWYo66ei4odIe7a7jM2jBWJti5JlK18V/PwGG1YM6WQ9wK/kMwx7AqwTtydfgWVk7D63nOJAUtyXoGhkAcBhMARRijZ/AeijVFhSES2/8AlpSoQZoTSZDWLYka3SAOwQoRtVBXG49Fa+sGjtBQpVqMmjAdhoZV+trxr404oaWAetRZ1lLJmVSsMKCpbjm2tU2IPdPEnJ4e3bLKuoXKIcFvc7UWheaW//xX3vwTWvWr72Rx7e34Hn8+3s+XP/GJ3/P6d3zHP/v+97//N7u+8fWeUq1jdYNuNpKCCy3CoDVSuV0RqWrdsJeKiVI+tIwt6c1e97tp9x24qro175mrTbc2S7v0+4aq1A3F5VozAA8y0F2vWnaRb9uQ6fZasssDNPdzJTi/OfZoc0zwsmXhOaCINeRVf6au7Cnx5kZszytsuYKWS1h26xTZFQ26Q5KtudOamdzmOrC5VLes+cbcb41P3TW4K7K08W7HSdt6y23CoGUm97nc9iWoGsJ1cwgqn/70Z/6Tuq5P3+3j/514+7Mf/jv/1g9+//f85t/6m37lb5aGiCsaUJIRcsQRUHJad9EWPcrE4au0OA/LnBOnOCIu9LxNadh9O4e1N9k0mocqlmNbq9EnfCEMEaI1ypaUyYu52EUEF5zhPJ2jrrk58m39b855pboKovjBGlLVZ2v2FMcwCLU6MzIqeJebUx9KzWhNxOB49OjIXMwpP4y256BkJGd8EI4xMAVbXywpkR2Wb+Y9NFJAbtSdOHpcUdya0CSULMxkIxMNnnKXSKeZdcmkuuLixOi9NULGgNfV1vXV4WOgaiKtC2EIZAa7VtdMwZlzL1mcihNv+2nvcDmjNQNKPBxBfIsEsXXAcBiJxwMuBGpacFXxIZKq48//zb/zJ1POb743Wt55t4997GP/xmuvvfZPv+997/vngK3w23Ha4AjBb8XnXpiutfYMjV3jzblBp+P3ek2lF9SHYWCIwz2hqYt13SXTha91XVoGXia0Qv++wJ+L5Q2WWlkbei8GQwzHELi8uGpkDDvHD4cDwzDYe/SCl4D+/9j78yjbsrM+EPx9ezjn3BsR773MDKUyEUJIWFiWZIQwqlpdrlVlystVtrvBrnbbvdouud3lrmVh0OpaZVwYm1626QazarmMwVA2GFFCBjMWgxldNBiQCiEGzUplakylUjlGviki7j1nD9/Xf3zfPvdE5Hs5SNgupNhaTxlx4w7n3rv3Ofv7fpOwWZAStpsNBMBqvcbeeg/FVDHrvTWGocc0TZjShNhFDCvN+yMibKF1kveaERgWdqXq/KPZilOaEKJZI6bm2uGQ7b3nnM80/ZcKqgaU6h7BInWcQ+w7sOUcbrdb5JzPZPd577Fer1UZaJmD+t79/HpLILSBfrK47aMf/eiPppSeuFgtn33jF37hF/7hq171qj/xyle+8k+cBwAbmDRbxS4sJM8DeWf2cgaINQCprdv5NLHI2Fvacy7rgvM5e8v7L4HDJUC3/L0Beu1xO7Vwns9jSxDsVu+trbvl8y1BsyUgt3yd8++nveYSxGv2mucd5s6Dn+181z6/pXLxPOB3q5/Pf54N1GyKzvY8mmO6AqDq7Ubc6LoOb3vb237k+Pj4yc/1tRKM4qogmyg7WmhuQe2aUUsmDKkSbQYZZAcewp5OmaLaedeGDJ0JZdfJZaoxs8BQ8HEJW5h9jrE5yEAPImV6CRU4y7bwwWG17uG8w9BHxOCRUrHcKsvScPb61siG1xwOLgVCDkE8pm3WZj0B08kIIcKVIcJ3Hp1zWvSz5vpMdbJGolpuchLIIBBWNUvsI3z0c/NPzF5ArKhVe1BlqTIUGOUMuEAgCyIWs7OJXo1Ffd8DnFGZEGKnKk1OoMroyIFrQBf0IlyzA2+28EPUbBIh7K+AMlkO2LBCnSYFQFxQFo3lB65iQHfgldHrPfbXHfI4IU0FISpb2jsPoqo9Ca/MxTJltSAhtdzwtWK1P4C8B5E29VAEsbPFDgHVAh89BhrmBgdXQZkSCrTwqJzBJaNzhJHVmqhUAMHDMaE4AfVA9EXVijFizzlIZoAFwXm1KqmClCrSlDVPqbIBdcZQ9gAXtjluVrQ298kFgAzEkWqTtK0XdybPRRo7GtogIVZmYgO1NSfNQ5yy0RmCsRTEWhFjwJRVoeadQy7Fnl8gnEEUdOmSZVDZszrskHxVY1oTSazFYg0UGJj+NFTiuYaLPZvd561AwVuqB8cdCPgZjgGHWK9XcN5j1UdEswK9fGW9gMNmfG+n9vM7YMTXBWhSFSR0PsB5zMoUwJwCK+ZigasW6kWSMeoVrSNyKKYsgDHhcyqQUi0/Uq1hGdowKDnBcWu4KyhQKyx/xyF40uByYgXBBOhCRCA3n4cqZ2vOeQAOIzPiEDTMnALSNGqGpFfVjtrnm6oQmsHpvENcOZRSwQB89BDFojGNGc4zfOwgXDRzFKqgyLlAUgGibiYCAakBUGR5bCLINatSGXouJLACINUYjMiqoDQVYmXAS7NBRYPiUe1b9LEDgkctmpPmqoGCs/2r2n+q5Stw9Viz/1Rot5uszw44H97+5ueqoj03a48AHB6NGA8BjEcY4+cjRGCTdzDi2dUx2ssNz+H5zf5zPra8uP3ff5Py3+ZrP/bo0dfsr4d/s78eXoRdCpblc+qcldmmTv9GLdPWvH3Je73GObW4aaoV7xRQgrh5/TMzatLis+2fyDlUUjtnMovckgqkFGtW79a/WlwXkKiiSJm7qjRq6z86p9cop3ZhABB9t1v/zKhViUfOa1jxNDK6Ts9jcB5pnCwvUGV5zGXOOHSa3gMyK9BSVIHsYrtOeaQpw5HARQ/Uak5/uhHMU4HUAkQtPDwBSaquc09gciAR5FoQglrDS1V7cgp+NjuXkjWStzKKCvxMxUhntpBzxkeMIO9VtWjFvq5/P5MiSqlwRGAhXLt5+vDVJ4++8QKA+/f3+guj9X8rx/DAe9/3tQd/9OB/HVarF5NXBbj3Ctw558BOXTtoVrTRTvFnR9ayYtpgU/txZWu0GcnR8up82GXPVGYDBGjOqCNqVja2/3duzqlbNidd2OUDkqNZ3UuznfFZFnErrOfjlR0wCOcUfFvYiHpxc/ZvyykMVoxLVcVBrZp/OpMigPm9tEYCERZ2RztLNWlkz1nN2Ir/BZDZ9mJcrWGie+h2plZwXxY5H0qcVLWfmDq4NWyMmAiaG4nM1vSYGzAy78k3p6cPP/D+D/w9uVj/n7Xju/6XX/nql7/o8Jf/0Bd9/ouFsxLNxM8sTOcJwepBMCNAraZrKXCZETiD/IDgI0Ln0K8HdDHq3rxmmCO3bga0JASnhGr7/1nx6hy87duZgTxmlO2EmrIC+eSQK6HkjLRJoJz1/kRwDpYn70CkzgGOBVkKirkkxeARWLNNc0qQOqmjCA2oEubegu86BN+BtpPFiRAyKfDGnEHigcKQqapDkPeITjPI3BDB3iMlQakJ3gmGIQKF4RlGOK1aW0wTYlfVWQAFQkVzBoNHIafnRNG/BzKLFQZiFyGaDAOuSbPqBUgi4CLoyawAKcBR1fM3eRAKutU+/HqtziTTZEBuRbcaEIceEAbnbPutgA985FOf+vnf+N2/fbFKPnvH+973vq/9o3/0j/5KjPHzGxDXsp+WDfWcMiTuGtfZSGsEmlUtznVzjldrWjfLuxgiRhlnBZ/3DRgwFV4I6IdBbTVLQTZli9Ykft7DMjNu3rwJIsJqvUIMATV4CKttsSNSC9Ohn63/iQh0QGfs8XYAXW/XT7UXHfoBXdfh5ORELcudXr9TTmeAhVor+r7HwaVLM3jQ9T1EBNvtBrLV89re3t6spvROa6M0JdRSESyvuwkG2EC5puBrrgUtJ3Fu3me1890YWFfsM1XyVssUK+f2HzyDJLPtn8QzmW7zfw1suX79+qfe//73f/3FKvnsHT/wAz/wxq//+q//5cuXL7+oAWnnlXythjxv3dnmy3LNt3NHs8hdAnO7+UhnLDqfNv+wU9HdDhhb2oK22xto1wCwJcDWQPZma7oELhtI2cC5BhCetzVtIFw7fzQQrQGeS6BzCVq212/HtsxLXCoWz7iwAGc++/Yc7Ts5n8V43g50+f6Wx7jMHW2fX9/3cz5hI2LEGHF8fPzJn/iJn7hQ/wMI0jKs5sgKsvD3XWA8CXa5FsCuUOWWEdgKO7cT8IkqX+CWKsFZh4NdN9cbuFG08JvRk6Zp0qZXtZwHBRgFflZDwdDegFWMmmtFhNXQYTMmUAFct8urKLnAsdOLlGiIdi5AiAThipQzOtdZUzqgDxFTqrrhdfZZsAcHACzwRJhyQb4h6DsPygwmQt8P8NHN9llVAC+1OY4BQVlIuTKYdRHfePwaQoi4dNeeFtsuGHhJyEUtKDkVUCAFtKyhDudRtxksGf1aLTy8U7vNVReQsnpx1wrUU1XHeVT4jjHe3GBYBcQ9bc5RUNuf2K3gJWPcFsszU5n9MASUmuf8vNhHeEdafBQrinq1GKRO2X1wsIArteWJ0YGCRy2NHeQ188zmTmVV+7AIijAKM+pU1dKHAMlq/1kt4LcURhc83OCw2QjGMYOKMiljCOj6HkDBdLNABMi1zCyrWopZCZl9rc29ZtvWbG/VbpZ0Hks1K1YDhRb3WWZCaUOjba48KmNudDjyc06MkCCzg0PFdpuwv+cRfcCYioJ17UQtDKGs6wWy6KTILjlTdiQ2MUWG0LlWw6wyoaeDf88E4uE2930umYGHtwZAdrePt8QRnwmKWWKLcQBWXYALQPQBq/WAR64+jO7gpdjzcQcCVgAGDHlfUGs0FWBWsK3dZXHN0+Y5VJHDFcyGJLFmOhL0HBJDUKDdaQMqegeu1ux3ATkXeAPLmx0wnNOMjs2I8fgUPjgMeyusQjez+Al+Pj+TqWOjiwo2Cmu4/TRBhNENHUK/gncBNQs8mY0uzErv9BS1VEgXEUIPQoYnIwQEQCRDigOFiBgdSskIDnAxomSBBH2v5Jr0yeknwKLs56pghotuPnZyADu1CONF45Ng+ZWWdxpaYdDmsRU6UhkF+pGXwqhVsZd2CXFm/ZFrVcvB3RcHOI9S0nzFKRXYbLNhYS3379MRAtjsO4MaNrhuOAvA2c9H2IFwh4u/HdnTjABwPOLSnYP99egWL/l8kMZ8m7WXP6MG5O+HpmXN5SOffPTom/7AS+799r4Lg6rpdDMiUOWK5vjIrJpjVqKF5s/RornuTekiRthhU4ALsgjQeeSUgRhm+zsRIHqv618YHQWULPCOjAxDjeIHLgXTZsR0fKoZHfsDVkM3Z5HM6984HUKEzqu9jza3CiQliFR0fYfY93Auggvr+i+6/kspyJsTcKmQGBG6HpAyr38fCMzFSAABsYsoJSN6gosBOauKruSi10Fbd84ank0llUqBDwqeOlKnArZ9jEAzzphbJiIpOCe6/hlAMOWVNHsTVhJLFUEprI4JhFl9RV7JUrVU1FLn7EMytVHLUIHZAn7i0Se/W0Ru/O9pvsrvs9eV/52/73x68sCHH3jgm1/1JV/y7UyuJ2d5lMGjTVQhU+o6RhUyoKzhVWzkLZvXVc4UmVqM0+68QApItVyfBii2xynQxou9oakFSGseMRWrNytdcs7y9/QzUpttzB7f2jg0VazTnxsgN78PqIJnadPZLJBVfWcB5ZaRCQCRvCn5lJgmC/ZvK/LPofC6F1iAkCCZwdRloT7nHope41Wk62b3EDGlIDcQsb15A+6aGnC2QJuPyaOURY4LaCZYMVfL/2rfDeNDD3zkezml6xfr/7N3HN04+cj3/sz/9k1/969+1T+5dGk1CG+VhMJAhdrp+QD4YLm6pQKcgEqaxRfUMtg5h9gNCDEo1kdau0upSIVRitr6J1T7o7kaWSY4pwmhKlBXi4LV4ghuCHp9g0eeMjbXTrF56gacI6wvr9APAeIYIh5OvDlYGHE5eHQ+as3HDM4JdbuFlATfObguaI5vEo0YCATxHjknTDevKYEh9uBhDakjvGewFCTJ4CkjFo84KJlaaoJjQdcPIPaoTvc6RAUUvYFwThV7kyp5ihTEvoePETEKKgdQjBZ7onsaIQE5gQ8VdcxwcBj6QT8bO6dNogReYXUJYNH9eykMeILAw7sIv+qURDklSMooXBHBCP1a7dunCSgM5wNOthk/8ku/8b2l1uOLVfLZO05PTz9y//33/71Xv/rV3wlg2Nnl7RQi3tTASxVgAwvbdbypXPq+n2uFRuSfpgmbzUavsURYr9dYrRwgajvfmTNHa+Arlu/Rd91sHeq9R6oJ165ewycffhjr9Qr33HsP4v6BXguNfNhIRbkUdLFDjJ2S+ABst1ucnJyg1IL9/X1cvnwZMWqsRrPUFGGcbjZ4+FMPI+eM9XqNg4M9TOME57xahgNzXuH+/h5ijEjTBG/ZgiGowm6z2ern4v1sExpCQPb5jIKoARoKSgpCUIXOaOBp13cIXhVVAsDVglILKJORKqsRnz1YBOM0YRy3MzGx9X5bzlnOWdV+C0ClOSO0i2yVivvvv/+fMfP2YpV89o7HHnvsQz/5kz/5d1//+td/l3Oub/vt8yqyBpQ1gGkJbrV53RS87eemYDuf23ceXFyCXPM+bwFsLRV45zP+lvc/f2ztPZwHKkvR3M5x1F5q13VIKc3Zpy17rx1fsydeKv+Wlr23yhtsYOAwDPP5kmdwPp8B5W432nOcB/jOqxXPZw82a9D2Wc/RA7bGG2Gj3d513UyMaNatXdfhl3/5l9+02WyuX6wSqIuMnLHtxKz2k7mI2+VaNLCBSRmX7oxakDAzLUmA2p7WGjbWwNYEPjLOOc8QBsGBmBX0kGrMTiPtMaNasUpWYFpwFkBOM3is0I7R48rlNVIuuHbjFDXzrKQTUduu6D266LHdKHjoAOSStVgsFeIdht5jtb9CyglclUk3bhM6UwFkAH0XUVkw7Ef06w7CgugFZSxgCchpg9j3GHr1oQ8zu08ZL0QePgDbG8fY3DzFpcPLKJU1b44KyEWARJvspOoxT5rVFwzcKZsNxpNT+HUHxAAPByoMHjfIJYGF0FPAdrs1uy/tsOdNgusCVvsrBeGmBMkEb5kIDh5DFMBrBor3Tm3/LG+PrElXWTS7yDFc5yHewQsg7FCjsvw9NLcwEwMhWOPCg2JAZQJVzaZjs2VShzZGngRlzChpizETtlNRhVyt6LwyODkzpnGD4Anbk4wqgjpOIB8x7BNECkoukCDYThOmSZlEqRS1GmRtlFLDxggAOcsBVIWfZok1W0ZrzDpjlBItFGY0K+9anpTaHKkNnTMlbAYjNMDcqUUTV0HKjCklRO+RnEcujOCcZh41BZ8UOFKbUcCBucWo0GzNO1skiRh4tWsyiFJLzzYdlmDfrVR7R8+AwN0GG3naf2eg79nUS88OyJzHLWPUZroDED1w5dIaJR/iwfd+HH/otV8ME++B1VsSMCtQvRYp3OIN/fMwBY0PC4Wggk3MqjtzTueK1wA6y8tQwgOY4Z1TJqswXNCsLdrFCqg1kCmuAUYtE/J0ApEOghUymkLIGRCmOTelVnTkmukoAEGetphOj0HeYW+9gvcdypTBSYkFDGBKCWlKmKZkdmeYN9dxWGE1dHCBwDkbgMyaIeK1uehJu3YFAgeGY1MQWu4kW8ONYlCA2+vaGYbO2H47yzOwvX9ycEGBeOYGWu8igZQIYLcxkBrbCRVgf2b+5impYjHpd+ugoK3eplggA3ji5lUUU/+NR8/H9vMWKPcMbg9nQe0l0PY09V2bt3kBAtpjjg4xHgJxMyLGAXk8xNisP89N+MPD8TmqAG814nJKf/Y2AW6c/PNHnrz+mi+4966/7p2386GybysTPFkGFsvcvG/h8+S9WvY6ZeBLy3KtPDfmGQocNoGNczTnimmeVgakapOMrHffGvOWccfmc8A5I09bcNehw4Bs1xjnvFkN6vV2KspkJuzUU3naYjq5CRcC/HqACxF1UkVhzmW3/scJaSx25A7kqtmBdRhWPbwn1KI5SAQFSrxZbToIgmvr3xTmjuZmiCruHATG/vN6Ieq7HgK1K1UrJW+5YqR5qSSad9w+d1P0EGkTQIzRUgVIhVUpaU3Ulk9NUGU1lwrJBdws4huL27KWBcDjT914581r1/+teP//fmzifzav/yc/8Ynveejg4A9/4cte9jVUW9GoLD5VqFo4cMsH9e6MbTpBsya9zVm2PfGOMezOmpqYPa2qBOtsSXM2yF4JXc7IlSDM9lpEMhMVW66gAuyzTFnjCWRBJHOYc0ppV4LNqj+ROttykchsx9nOHS2fb6kqbMo576MdfxP07c6PO3tPs0FcsnOJdudI3uUPuoX9Z8vtEGjtINwiIzCDf3wmPwRz/hlIr+tEzQ501zhox6vAn55DmvqSmfHUU0+986MfuO+bLoC8z/7xq+9+4E1/4Jd++7Vv+HNf8de71RoYN8jjBIeIKgznBSGqlXWu1XoTRhzpetBqgOsCXIh6NqgMuAIXxFT9ZrdNDO8YPqh6XiMuVOlPyAh+pR0Pc15RJa/aXlcEiFTk7Rabk2ug2MPv93oNhDXfiMBSNXqEgIiIIM4ybhlT2mDaXNVs7/4OECLqyMhjUXUhEaZpQhoz0mhNQ9H3En1ADB4xeIAyas0Q8ZAJCF2nuamlgPIIxwFBVFGkJ5JGwgG4qv2n69egLoIiwSGic7rx72KAI4GEAFSndp4WveDrRs9ZzZodmlEmVd14IEAlh5wqttsJBRmOOnUygdbFeUrg7YhQCwAP13UgAyt5SohOXaPe+s4PvvPX3/2Bv3+xOj77x0MPPfR9BwcHr/2CF7/4a6YFsAcpszJ8GIbZzm5uHlO7brkzShcl6mO2rmyNZR88YuywWg22N19mg/GscA8hzvaB834ACpofn5zgiScex+XLl3F4eDg7FvQhwLuAlBPGaYtSErivGIYBYdD67+bxTXziEw9hvd7DlSt3oO/V2vPk9FSViszYbDa4ceMGrl27ZkpErfOHrsMdd9yBy1euIIao2YW1qC1o7MAiSClrniA5xBDhfTJwTq/JKeedRaIPqFXJ9z5oxBAzY7M5xd7eHrouohRnJCSn1sbWI573S0bwGScFMvq+106xAQAN9Gj2fz6YtXIjHoYwR420LLS2D3n00Ud/+8Mf/vBF9t/nwPj1X//17/vCL/zCP/IVX/EVX92Ap/M2nG0OtTW5vK1Z/i6zP9t9GljVALKlteV5C9DzYN558HCp/jsPIC7zCZdj+Rrns/NKKZrlaaBYUzcvgcslaNdyNrOt4/Pv4/wxtWP1CwvjBv7daizVkUu15HlQdvk5nc/9W9qOtveyVAW2v7XHN/JFU2Y369ZHHnnknT/1Uz/1TRerwwBAE/ydKV3a1+iaPB079ijt8EA4EitGab6vKlXsCyZl2M9MUEvrU6uWBuBZThqgdpbU7N3IjBIVfHJkqiwxNioEsOKPIMrSJwKXiugCqA+48w7GzdMJNbMViqoqqaKvH4kgtWASxhCjgkliTF2qiH2vAdpDh+1pRpkKWCo4OLWqgoZsX75rD/1ep+o3CLanI46fOkE3RKz2ekTvFQhwChIIgChAstBsR+p7fde9VxDXK0TngeAsd0Obk+z0dwoBXhykWoB45+GjQ3dpBdd3ag/JDuN2gzRNqDWjVGCcJmyPRwx7A1aDN1ssYO9ghVUgVDj06zW8E0ipIK5ACMpqDB06z5CckYvKb/ouopaClBnCFUSitl2hASUM8g59iJDi0Ai9QUxB5zwIXj9vswGT5u9fGdmyU7anCZkZfQxA0vt1vYdkzQHIm4RaEvoQMI4ZXAq8B1IlDGafVFiw3RZsc0HOFanqfGCmWdk3m2l6UXmRgdb6FQWQC6Y4XeayGMuT2h5GANLMsZZ1KUSz/YAXVTIw6VynhgoJm7TUo4pgyhXw1iSFg0gxFYUGmYlZ5yrL3MLhpKlldV0KW5N36bFFNCsUQc8Bczt8httvBwIePdvjh7Mg4S1e+/lm/wFAwKBQWqkIPmDtA+64cieuHh7h4Sev4vPvuXMGaZ0Bgd5joc+MQM3tlx34Z9Z5zKbedapyZdcuhgO8j/CxA/mg3xHUDojIIUaH4MOspGbL0FJFkqp8Vf0WMVy6hND1iL2y+5iLzU/dvIZoNsDk4EJACMoMdtFBOofQ78HHiDSO2ByfYnu81aPxHowKqUC/Ws8gsY8Re3trdH3EYBY81PcYNyO4ZLigICgRUHIBhBECARIgpExfLjb3mUFRLURbXl/Lq0RLYBPWNW+5iGIWuo6UPMDWkCymyp22qtTVDL+MVBiVFQiFqwruGSmauWqeic0GboBtqnOj+3Q7YsxAzp/m1fLw6VDg2Xl6C3D7ueZkYpxvV2vS24cTHuEIh0eHnyEI+O+2YfnvqzH6+KNPfu166F95912X/lizwfPNQq414Q3E0xO+Klud92DntaHXbPsYECYwO7NbprngDJ2tf52MajlLDtH+3j4DzQXU6zdILbYYhNAF9Af7iF2Pru+10W/XVTJAzAcPIYK37IsQPZgzcueALsD3K4TQIW0nbI9PsT3Z6nU3OFRR1L9fr/VKR6qc3dvbQ99H9H3Q2wbBuB3VvhsB5JtK1zIGvOYhChhVKmpdrH9P8D7o/qkBqmb7CWvsUwSYGzih5wZHSgNrW8JSKqqo3XAtrPnKtSKXilKLOk4INEeVGVWAmtUrmBbzTUSsgajXu9Nt2n78U098E1/s+/+drct/34DIR97//jfuX7r0yhfcffdXgFlBZQOtnLPrVdsbGbJGjjRLlkhBbbuWKbAki+Lc9lnOEuyscdXIBGz2lg1Qo7kYxoKBTLM61Tk/A3GqpLO6CnK2aTDDkzJbiQLm0mLK5IYEtqY6QUzRU+GNUOYNwG/b2dmqB0q+a5EAzdYzNIBQF5d+PsBZWx77/wYqEjXFogF7vpGlNJvNkVmXet1P6zHoA8iIgGyNjF1TteX6NVVfs1TCDBQ2tUbLVK1VkHLevPe97//7F+v/c2d877/61a99+Rfc88o/+R//4T8GI5VQKZrRrsxOkLO9Kgd4V7X27jqgX4E6D3YEloKajfxifQPyah04rHt0/QrO9VpDSMaUEhw81sMKsR/U6lvUXpyEIKXorthHeHIIQ8T6rjsVABwG27EygGp596wAn/U5tKGmptkcMmpPcHGAIKBMBZuTEdvjgiIE6ZUwS+LQrfeUQE26L+j7AUPvELxo3mFQR4KSJ71suk7Vh5Pa+xCcEiW9oEhVVSMLgArXd/B90Pzkqqy76COEqhKa4QBH2n9hgbDGgnhnOajUbP8rUAXjtqBmRuiU5DrlhJxHwCyS6ziqCtoF8JThsroVBXKm/mXUNCGIEg4/9cS1zb/4xV+/AP8+h8YHPvCBN67X61feeeedXwFYbWkN/WZzPWf12vVvPaznpnZKaW4et7yrdr+u69D3Pdbr9RlgL+eMnIrmjXuPGPWKvcz6a41q57T/NKwGvPSlL8XBwQH29/fhSIFF7z2q5dz2XY8YgwKJXYdhtTIl3YD9g0u448oVrFYqWPjUo4/gkUcfQy0F635AyhmA4IUvuHu+Xq9Xe7j7hXfjyuXLCijGCIjg5OTErq1ltjMdx3Fu0scQUNkhp4yck/7zQbMALee4VlVOuqBRQWohukXXRQSvdooCa9znYoSgCBFgs91AWHDz5k39jDtVI58HJGqt+t3NtQZZRuPO/nBpuThO4/YDH/jA/+diVXzujLe85S1fc++99/7BV7ziFf/ZMvNvmQm4BPKW6remGFuu1+Vet4FgDQi7lQUoFvvjpWpvabN5K6Dw/HmiAXZtNPCrrYWlAm61WmEYhhkoa5al7XHLffR2u1VyUEoYx3HOFdWMTTqjqGu/L0HA87afSwXj0tJz+bksLUGX4OXyNZZg5lI12RTZS9Cv2aAuv8ud6nqnUAaw+bmf+7lvuVgVy775EvFbBOBqkbW72Zwsd2xQmVFCs6cygK0tFFOF0Q79s0bRjjE/x0PMeITBMDJ3cACnijQWZbH62W7UmCOWtdVYrRQCfCRwrui7HutVj9M6oVbL+XMOtRRM46SgCgu63qHYRdYHnawHQ4fVsKeFdhAIJkzbCQeX9rS5ZXDmsPYa4J0ZpVR0pArDvbsuoQ8e66E360jTC7ACgBlFVXOigFrcGxDWEcTqkUPOWMLMoKoNtRgHeHSoSPCiChyxfLi4t9bQ8gLUMmLkDBYHyR7OFeRasDroMSCCKqOyZvt0Tln3fQwgr5andagG9BVl2QnDw0EoQjpW1MQJPDx8KUii4B88IXJARjFvb2tvOG18lmpsHbON5VrhxGnRYVZpUhljqhBiSBbUnIEYUSuwTRNCrxuNbaoYNwWnp6M2KoLHdtwgiUAm3tlrFqBIwWnOmKaCkrKxC3RuVQtiZ7ODIgP/VK8X4Mgbc9nszrw2jVgUfGBpWZbAcrIrm9saGdrGUODDAHcSBSabsrZKa6wSpokBr5tTckBNoqDf4qQJMkYoZMcQV98zgKs1jaEsdQPkzzS7b9eeO3yOgOCt8gJvpSI8vAXQePgMj/s0wL/dFRlwrkMXFAgcuoCD4RDHDx/h8Qjce9eds6JPSQYBgF5Ud0Ag4BBNJThoxhdXZdrb38l5A/M1ny8EZbM6K2C5qrJ0iAFdbH8z0K+pPtuFXgq8dxgO1uhlrY1JaxAGswNrdlrEQAweLnizvFM1TxhWWPuI4Ht4ishcdV6GiAZJcmVEH+F90HnltTnnHaF3Ctp5F+G7HqAIrhmlZvig75fZ6VrxQHQMchGUMpLZ6WrciQINDQRtDErNVncI5CHQ/EGGAirs2M7hCgaWXNTmk4GcstmxerA4lDqimpdrKRUy1RngtBjD+ftlqFpSv98ArgUPP7lBNnuE8XnNssPFT8MM2B3N83k8C27f/uFnfj4rsB2AoxGHhwb9jbe3+jxsjz46PAMc7o7hWY5nMf5dNEPlHLHo3zUo8PGHHv2/9V34N3dcXr9CnLPUVAcWo36Qns8JAidKyGGzoSJTmokVtgKZ83nI2L+aD9oU12y5G4IYA2LnLW9DiS5q32yfhwhIKoIH/N4a/XptDQEAUrXhLjC7XF2HMQY4ayTo+heEbsDqkmb8OAqoRlaAMWEFaqMZfEDwUde+U/vC4Ai9d6AqSiroIoCAylmLeK/ABLMSclTloM3CKRVIzahmZei8Agstc4vIz49VtVKzV/VKoGKGUJ0BAhAh54paFNTLqajNd/A7NZ+I7h1yRZ0SxHL+YOQa501RCQMtLUutVMGDjz75A+N2868+k/l7ofD59M8B/74+v/e+612v/w//o//oVw4ODr64coWHB3yz6CwIFOZjEwBUz+61CAAbYO+dZuNidvD1cEaSpFbYu2aZKWqBSztVG9rtjubyCURnlIcN8GuZgXO29Awe3uKTlZ0lfLMlbecdZyrHpbKO7H6l5QCKnLMc9WcdYGaFoGVKi5uJbTS/ppJ8muIOIPgFAW5nCep2isI58mEHNLI5V9RStflpteguRwUzMCi8ZHPz/Nk4543RDCP7VXz0Ix/9F09+6pGfuVj/n1vjm7/vp//SC+48+JUvf9UX/EEc7COdHkNqQCkEogRyFS54zbSums1OlpGNoDm5zAIEhxBI1WR9ACoj9h36Vad5s6wgWQYD3mE1rLEeOoRIc94tSdAyTYzYgwnkKlaXDhD393RfUgqYk+XeWia9aI598GGOoeBcICigbkCgDo4DJAFpYkxM4NjZnNVa3kOtA10AxOl67z3QkaijBwf4voMPApYEoQLyDPGdRp5LATurP7ySa0qu6hDgHcgTAkiPS7T/4+FRRS2WuQq81xoic1U7byqWZd/WqVp81ypIY4KQR7A9W6lFvQu8R0kZebMFOvvsRRCIFQCwfDMpCb5W+G5AqRU//L++44c+/ugTP3OxIj63xnve856/9LrXve6XL1269IdEFLRv/8256D7YGtitmd1ypRoQ2P61v3ed5gLu7e0ZYU+JgmVx39VqNVsHzo1vp015gbqJsOh8vueee3DPC184Z5Utc69a7t0wdFiv1/raIczK+CtXLmN/fx/r1QoxRpxuTkBE2Fuv1BLfETwzur7HahjsWFUhtxpW6LoewcCO9WqN9XoP4zQipzQr9WDrsykBQcApnSKlUUlVBp6U2dqwAXVKXFyv1yilIKUMdIQO3RkVFizPj2yfMk4TTk5OcOnSJf3sKmOa0mz56cjURG4HKjSQlhfgzhI0+fjHPv4vn3zyyZ+9WBGfW+NNb3rTX/2bf/Nv/uu77777i5cA4Hn12a3AvbZ2ycDlBvQ38Ou8LeitQL0lcHj+Ndo5Z6lSbaDVEnBrj9U1lFBKmYkJDezabtUet52b2nmsEROWNpvtmBpA2IgL2+0Wq9Vqvn0JAp7N/96BnF3XnckBXL73dj5bPiaEMCsGz4Oh59WMs2obeJoasNmPLv8tv7NGBGjn69/6rd/6od/5nd/5iYsVsQQAZdGZa6Hui5tMpKaWgQ0JFmtSw3IosCt458IOu8w/1UyZfQzMLpRm5x2o4Zxa62m4k+wAHG6FuZgyj9SWzrJ6FGTURjYBGJxHdYROBA497tjfA1fBZsszC54IKMLYTqMWjBUzYOKCQ0kVOWogLcUeHZThL2BQcNhf9Ti9scEweKy6CGIBS0FhRtd3cJXRr3oEIb0tqtLMhFpqB+gDHBTwYthF2kUIAyVlkCdIVXsLHx2oApwyfO8R+k7ZwlAwrhIQieAoIEFQyWFvbwCtBLVGSBV0U1YwrGZ4HxA7UluOFi5WqmV3OHgfVY1GhPUQgSwYpZi7pUckAJGQxgRQRR8IuZoUt1ZI1fxE3dRX9fH3wJLJXLOBhCKQpExdhoCzmC2Tw1gSsjisvcc0JYTOIUOwGTVMeZpG5FLgg2CcCmotSJN+weshAtFhKgVTKpimMm9QcmMMVz5rOTZbGAlI1DIEToPaAbUJddZQ3YHjPIN4uyZS61DwbK+7VNm2Rs5so2Q2Zp5Iw9nN4qkzy7jGHxdrH6s1leYD6lpbeFJbwHRTXOnJXm1kHCmQyGdX+NMButsBf0fnQLzbPfbweZyBjvAsSONzg2eCRnSi9x5sYJ1DjyuXDpA/H7j68SMEDHjBXZfsUWU+BXq/2yQ2JFAfXwBWNZkz28oQvLl8VkTfwRtADAaqFMv5AYYuwAc3W4yJWQFq3qnT704YLNWUnpqVB2bUrOAvSFW/UnR9ChGo0/UpUjX/i6F5gJ3mhFXLwulXK6xWqkYotWruZSpo0V3iHboQ4EnVit4FPY/GDggduPMIErVJb0x6Hz1qqgAFtSL2HsFrJiE7yyipFlvpzb602kfARQkJleEtL6y23l5toF7R7C8ApTIqGKA4XyuYVckIBmRSBaALncUxlkWyrIJ+qGVGdR872s7AWAP/jp7z7Hqu0/qcAvBZ18NZKeLh4YCjo9F+fmb47mi5EI/0/kfzMZw7nmeIDazPofH5+33UWh//0Cce/auveNnn/djl/fXnwRTUs7W5WYFKU/Q0KQmrGlAaZEjWgINuioN3s523ZgMaOxhA3wWEsNvgkwFfhJb/p2pDNos+gTYQiAWlZC3SnT63VAEyA67CWUNBzPeZKyG6DiG2ZqFeV7vVgGG11sw+y9bgXEHWSBRPtv4JNenrOXJwQpYvEsBSALOersLwIWr+n5EYvHPg4OBYbbKZpcmDNB/EB0g1hZ+onacWCTKfY1v+GciyeUUBgMKsuc/OmwXaLt9WWFCzFgPkw/y9tXyxllUtbOQYR3jq6vF9Dz/25F+72PI/vzV+K+COfp+dH+p2+8h73vWu/+eX/wev++FhWH0eQcFqLRjVrpOct4xvMUtvOsN8VRt3WdiItXNLAUELaSadb2yh9jQX2roXc5ZX7V1TC5Ip4HegX2O3etcUfjI3C3j2p8dO7mbZg67Zly6P29aAWOZfyxRt5LydEpJQijbTZhbt4svW8o/sZ5objzvbUVU7Cu8aci0rVTN/rbBXOxl4yw5dqhznYzZS3nJ+laq2g2Kqv2UTopH5RASlnmV2N/BPAFy7duMD7/qdd371xYr/3Bs3N9tHv/V//tm/9s1f8+f+5R982T2fh9U+aBxB5LXOqx6EgCLJrtXQC0kpmicgDBKPLqzRd53W7QzEENGFgBA6u/Zm5KqA1v6qw9BHzfsmsTrb6WZ0tr7OEJkACHwkgB1qLhDOZgjjNeaBGZIYyALXaQOBcwVqBQkhooMXrX9rUWJ0v+qxGjoAqrQNOYMyg7iqK4d3iN7Dg0CpwlFVd6Wo6kfqOlBI0GQwj8zqEiSsqecUWoOflXRqJDyuFVwKYhfhfIQUBmpB4WqkB+sdcdW12XpLEORizjyoChoC8CGCTK1VmcBO8wbHky04Z7huDWLA16JZxUEJr95pppgPAd4R3vquj7zvx3/1Hf/NxWr43Bsppcfuu+++r/mSL/mSH1yv1/e25nBKCUTANE0zWLe0A23X/qaUaZahS8s/5xy87Rdac55ZLeg6y9xqDXfn1A0oBHUKYTbbSq91hYiCXA3wc17J+c4RpjFhu9livVrPpDol6Dms9/Y0koa0pxVDxN2HL8Bdd9yJUgvSlLEdt5aTS3YMmmvmHGGcJrMiDwAJ9vbWWK1X2ogvBSknFUw4UsJ+Z6ofH7SXaApHBe8ryDnEGMymj+fcxRjjbDfo3GI/5RxQq8aTiPYO40KJtbMqnNQq2LIHicnI/0HP1djlFJ8HD65du/b+97znPRfr/3NwHB0dfeLNb37zV7/hDW/4gYODg3tFnl65nFehLVVsDfiLUZWrDTBbAoBnSXpnwb9lLdHm51KNuFTZ3c4CtIHZx8fHuH79OmqtCvqv13o+secdhmEGD5cKwCWQuQTdlgBmU9Kdtxddngfbz83Cv53fmqJ6CfYtgc7lY5eWq8v3uIwgWOYRNoV2AwDbObqpAdtn2J63HVf7b4wRTzzxxPu/7/u+72L9nxszHb1ZITYLmDnbj7BrASxuYzRLtwZNYA56V4abKQPnb9kAPdrFDVLzfMNOObhDIhvwYs2fuZg2dRcY5BrTHDPblZ1AGOhDAKRib91h6FQCS2KesyB48la8OmRrrvvoLI8DyLViO43YbpXhgqwWOD5oY97HiL6LSKUdMYFyxfb6FpwTiAtqlflz1PfPsKhCbf4DukENUb8IA4mcIwRi+ADAqb0pgjbZ0Xt436EWQHKFJ4cuRlAWbf5zgheBYwCZ4ZjUbtI7lJoRfUAXAhw5baJlhlQypR8gpSJvRnhXMXQRJJp1512A+KDfBwSci80Tk0KBwYmRNtPMuqeo/v+Fq9ocEqGmAslFwTQS1JIw5YyclU1YzQpwmwpSFfjOq5LA2wmJgWmreQbBOQxDj5yrehiLwHtCjCYRNuBvnIqqiSwkuLAqIqQ1b6k1YL2yPylq5p/3u7+TzfN5DrKqIAlzQ7TlEc1qWVKlBDXJLKkNSuvdtH9qOdoSUMy+BKQqTWNSEWAMbVULijjNYOQEqQXCBU1BS/PC0/w4mpssdhi3Av8On+W/t7rt6DbPcXSLvx3h1nahh783JzKPCMCDnSoz+6iBfvvrFdZxAA4P8cTHH8bpze2sevJoij+9GDkfUT3ADZip+s/NbBazD4WCgU3Nx4q5mnqtzPCqMyBLzw9uJkA4O//NbqxBzyvBCmPvoMpcs5mF2YEImWq15eOJZkyC9fzEKavCFWzzkuf5R4arExRwI6iij6ugwpR7nDFtT8F5C8kJHppP5MkjeocqgOuirsUZYNbzlGMFH7iqstmFYCxqZQ5LyyXSkB+1/AH0GATKBjZAs2UntKtBy/+qrDkMtVSkUs0kqcJxhVt8Tw0Q1C8t4ObJiKtXjzX3D0c4Onqu6N/hLX4cz4Jsh3gGgHB8nvN7PPPa421e4CyuaFDgrdZbgxAPgWXu33KUZ/hXP4v+bcbp7R996PH/13ZMT+l5lxaWFQ1s11zKmavBork/xthXN1ADuCxTRotO3RSVonNztvqb17/tq9jOz8sePhQs98EhmNo4kDbniNriVSsdhtpeVyKUZgcoAmIBCqMmZR6zCLwpz52p/ZpjwezCAFK2Luv1toqAq67/mkdwmuBBtv41v7dC4Lu4Axvs9b3XvFwuFVw019iFoNsC1/K49DhmYoyFe1az+9Tmn+GurTBqOz3bj9XKqFVQckVORXOUqoBqheOd6uhsHhlwfDqePPDQo19fP8vm9O/Fv/IczgHlNo/5/fQ+r169+rb3v/d9/21K01E1K1BueXFmsy8L9aowzwqzeo4pzAvGblvDM2HRAL+dDeeuKbAD/chIPwbEtcxBc/xozTFtlresjGo1DiyP0ABDUiKkZt1VtTheNBCak8gZW6JZFacAYK0Mbxmd8x63Wf1YrrpzLebBWMNGhGp5ni2vDLM96E4xyI1caa8vLGcIaHpKUEUEZGl3il2uR8sCbp8v67mggaJsJ49aWclDBgayMKZxOnn3u9/7DRfr/en/PlfGhz756K9/y/f97Bs/9tDRk94Hrd8tuytGbRL1qzXC0Gs5VhiSFDQLcIgg9MToQkUIghA6hKBuGSQOJISSK8qU4YWUZCNsjTZ1LnKi2nTfokDImYMFWfREAXGGJ6jK0AUlI3gPCg7iKpgK2DOYqjqKVIYrAkqMOmrEBUNJ0j4IXLT9BQV4OASQ9gYs0zgzkOFRCRCewOMx6nQTLp0gCuApqGWpCAoB1fYBtQqk8LzHQBWkcUKZsub7xQ4UnPZjjGXlHMBFwKYaJIg5AwElywwItkxhcVobgQJKVVKQsGDcJCUfwynZcNygqwkxqK2rgxKLvXMIMeKTj189+Z6f+tW/fdHu+9wd165d+9UPfOADf/309PSoAVCtgdyAqQYAlFIwTuPccJ6vrdjlyrXrul5jdxZ8tVZ0XcR6vUbfd+a8pL3TZuk5q2qYNSbAGvQiMluUk0UDea+Wn86UNCqACAbs88KSXJBSmvP4nF23vXOzfab3QffqtGviK9ipe5lcVAE0TuNMQowxwrtdkz/GDiFEwBw5GrAnIjg9PcU4jgpE9MOc/5dSRq11fp5xHPV1tiPGcZyFHc6iF4I17ff39xFjnAFAjUEJM+DawAI2MKMBje07bH/POZ+8733v+zsXq+Bzd3zwgx/8N295y1u+ZrPZPLlUxi0VYl3Xzev7vE1vA//6vp/vuwSalsDT+X9LVWAD+JZAXCMOtFzRpm5r/9r832w2ePLJJ/GJT3wCjz32GI6Pj8+cw9brNYZhmK1L23/bv2EYMAzDDGIuj7mt467rMI7jnAm4zDBfAoMNxLwVOHo+y3BpDdo+k2ZLuvwcWk11/l/LXG3/pmnCNE3z+XaZC9re0/L9icjxT/zET1xc/28xwrIIa8o9WVpz0q5xTdLgPplBrwbx7SL9GlK8S6qYS9xmQyg4Cw62xvRsE0qW8yK6oTOGmEBBFeEK54Pmn0m142tMOw9xCqTkqjaXly6tcHO7gRMH4p1SiryzJD/L6wgRBI/Ya6NrmgqGGDBOE2reohsGOGbkXLDqA6pZ2WgOnrICgwj69QqOIpxXGwwgglzVznTNEHtdMQQ+eqjSqKqtR4z6tXCpiD6qxZAU+NCrBSFVRK+ZXiVrw5FLRRFl7FRxcGwFgpglljF8vHPIWVC5AmBlFAaHLngDMSZAGFkcYt+r1Z4oNEWe4AcPTIxSBbGLQGXUmiDVoYLRhYAaSe9LQEaFHzpEr6oDh51arrKDoJoqjQFSu8A6jZDC6LoIB0GaEkoBxpyRpqrHKYIABfnG7YQkjCpOs8BQsUkVtQr6dWdZRdrQqaygSWWGkDZZhWTOlrSgSGui1HneUfsMRBPNBMHyIArqnJ1CM6qumZN+Bn+YRNWOy4ZQC4aDAnq6gdE5xcIoLArmktfPx6ymxGkOWxU29WLRIEJjr4NadqC1fEkg0DzC54R33E6A91xAk2cS7x0+z+d6vmwGV+HQzUhQqYDzAZcO1rh6rGDMgx/6OF78xS/FpUsrNHvImaMAqPq1gX++KcuCFbl2owPIvCabQ1XNPCsumyq5Vs3B3J3gmiKT5yxVChFoWTs56yZZYzAVyDZwHUULCIbAE1vmnREhqt1lnFDh4L1DSQl5SmAoGAeodW2bAlwVYBtzwXrVI8SAIgwUfT7nDWC298hQ+1EQIFXBiODstQRgLsinE9gD3d6eznNmEBih7xRYDw5EMoN9FPR1qmV3af9S7f8Kt1yfCs6MPI0oKaFWj8IJXFXJyMWy/3yz/QTcbAMaUFLBo1evGrx2pGq5Z5x+t0Hsjs4DcIP9Oir4dnhu+h8BOGwavojzar8dIJfnvzcQ7/B2i+7odsuxeecePh2In58sf85vdm6cbP6X+z/+SPiDX3jv/7RedXewFeCy2wApo80axx5O9xrO697Hiu1GqtBGujbSilTL99P1v7T8OaOjMuVu2yv5oBmjzjlIyTvbXxaEoMptZeYAPuo53xNDWO25qVmvs6BMo65/Z1ZE4wQmBx+igogtm1kUtCQRTJLhVj18ywksvLP+NGBQpO1V1HqYSVXJwTs40dzaUivSZoQ4QhdXds3U9xn6aOvfq3q9Kvu/qYTrXMA31ZBY7oluLGvOKJNmhVQm2/CrslBKBrjCWa5jZbZMIQUScqnykU8++U9OtuPPXWz3P7fHI4888uMs4l77R77snxJwR+yiNqbMklo5Wn6XBYgduY8tB5Atd5yd5VjJLjsP0Ey7Obu7OUWQLKqgpgYMszLOm21VA+wgbOQCMQcWI35VVrDN7Y5Nma9+tvVs4PdM4DT7zTmz70x9puCmm9/LsigjAwfrvC9uKtumTCQic9+VnVLQCHDmsH/GypRZ5gYkC89KweWo3Gw9MQO0tfLc7FRwQHa1qqkr2W5vSuPKdp6pIg888KHvfOSRRy6svz7Hx7s+9OBPfvOb/lX4f//Vr/pnn3/PlTsYFQEBwABOIxyTkizHpE4TqPCSEBDQEaFzhOAJ4oLFWmgGe60CqmqH7b2Sg50jkFQ4F6wu1HXtkMxdBnqN7QbtmdSKUCew43l9qnKXdR05BjxQnMY/gDO8VKXjMoNLRZ1G3fx6D54S8ngMDj3E91rDtGgKaKRKzhWQDG9KRY8MlAInk/ZRSK1CGWQkJTUUJxHL2xVEp64ypRj5OXqsrxygSoWYW0BcDfBxQA0OJSfUDBQG2BMoeECy2omas41AY1ScI3gS1JSQtqco04RSgWlMIClw8MB4Cs9JbcwdQbggdJ26t8YON0+38qaffut3feyRxy+u/5/j4+jo6KcfeOCB/pWvfOV31VrvagDW3v4epimdyf+SetaesjWsl2BdAwfQCEF2Tev7frbRS8goJSOGOANi4zTOIF8M2jxv7hghas/JmfuHDwG1FMSuQwxGwOed0saTA1gdOkZTKeZScHx8E8c3j2eVTzvOGYwAkJI20XuzDCRgztLyzqOGqq5aKWs9EoPurY3xHM36D0JIKePo6CkQAXsWZVC5zkpBgcz2pwoKJoTggZbRZX0xrlX3W55nteXSenUJznjvZwCkAQl93yswucsfk/vvv/87Hn/88Qvr38/x8bu/+7s/1XXd+vWvf/13DMNw5/lsvwZ0LXPylvaXDVhqqrcGii2BsSUxoCn8lll4y/sZOK0g+CLPb/nczd5zmiYcHx9jHEeszOq3AW7NqrOdl7qum5WBS6CtPd/SVhS25tsxtczDprRbrrOu6+b3cF6xuFT4NdBQRM687vLzOZ/FeP6zOg8AjuM4ZxQuc1jbfZa2zeeAXfmlX/ql73r3u999sf+/JQAogNA52xcD+YhUgq7ZN2RyQQXbFDTZoXaGocxgXAM2lPzF86aTCApWNO8twdxMI6sidbL4uYgm8Bwm7wQgJ7MHNFv3jqCssVorxAPBOeyve2xFLeruPNjDtRvHmEo1ex0tqMUZo8b+2w0dSvGWRQHkNIE6h66PKNDN/movAknZ7lokQzfOQwe38gh9hA8BwWxxGMqwFTjUzIBU+KiqOgcgQNWOPnjUJjEydSJEbTtC18GLqnBqzghNaekEnhz8EFG3EzwcKBLqpmLaJpBz6IYAYQcHj5IzxHv0fcTplLGtjEvOAVyRpKCLnVrsMVCTsmpLTYhdh9aT8DFoEV80owe+hw8ZfDJCnNcMJWaMOYMAdKt+BkJ24J9aIinol/X5WG3/qO/QRaBkxrTNyqysjDRmFClwvkNwhJyVCTiljG3KqELo+jhbD5AnpKlg2k6Ysj5ubsLMM9mpDehy/rvWsm2AnrGiiebHgVQJOc//1hhBBYufbQsJpA0fe9WWDdhscVuWibqeOogQPAgiCvY4yaaaVbVDtZd0IIA6y0+w43fB1pwDnGVFLNjWs1IXcm69PwsW8kxg3dEC9VgiK7cCIY5uARDe6nFHz4Yk3vqvzBWcKzgCneuwv15hUyvggbvvHPCE4kD45Ic+jhd/8efjyqU1vCJrQNU8wPnya2o/VYLuMEHNAfSAc03Uq7Z4Rjroe7ULDl7v3K7nbI7IDrphDdGa8sGDnKqRKURTILFhhWyFrjFhndqElJQQnId3AKSqCsYp0zeSWgaWqSBvJlDfaxMxOuNKMBzUiiRntdwotcJDLQAJ2nBwcKhZbQ0LK4jnnVokV6jVUeGqVoDBIWSg5gkiZnnCjFILQuxmhZOQQ2ZtrQgcnDiTSjpwVaVgrqpmUICVUYtukqYxoeaKwhVc9XNUrH+n9OOlChAK3n70qZuq/Dsyn8zbylafQwE5/zSc/f1wOcXNdvPM094KfMtP//kQwNEwg4qHh09fP0fP5biPht8zZe1n27h+fPojDzz4CL38C+75joP1cDgvUplPrCABvLSp6Y1cpGBYkGZj5U3po4SgluXVdxGhi2pTvmjEs8m9iW39BWX3Ox+UMIC2/m1zzTDjUYaDgmW6HwDKlBBNFUjGGiYSs+fWfVGdCvI2gboecGZxCm2uu9CyzLKt/4IQLUdZGGTngpIruFZd/0OHaOeYiopcGLlqs855B+8AzgniHUBrZfZzQYjRFM5q5VmYUNnU6FB3ApASlNjORdUUioCpKnLGtJ0sG1TMZtXywmpBUHmRNg1pB3BUFnz8kau/8OhTVy/YvxcDAPDYo4/+6Lt/953yh1/zJd/h3N4LKQTUxpgngtSyK+qtGG0gmjBDvFOQWfwC/HNw5jxSqaKyKucb2Ld0XHDG7KeF8wpIs/IgMjPhGyDo5hzC3bPMlqLUmt6q5FsebwPt/OywIrN6bvfayx2gPkcjqFWz6GtAG81ZEOaCYM/TLGSc96hctQ6E2s23rEOec99pPhc2RaQs9qOzva+x+pvLTLYsz/Z5N1BQbtVwsMZKLXq/hz/1yC+85z3vvWD/XgwAwG9/8GM/9ve/96fwt/7yn/qul77o8DC4CokeggDOmnEXO7WVpuDhXURwQffxRACiAXxO96tWtwpXUN9h6AcMQ49orDw9N2AG9KQ2Ja/m1juvWcRVdK/BneXtFiV/AhUk1VotHrUKkCtCVYCA2IJWnNUqrgPEI21H5E2GrAa4VYBzQfP2rN9Cps6tEGRb2qRyfTgGhD1qJjBnMDFotULvFF8sRXO/q7Tg7QCHBExbFA4AXUZNBaVs0a8vwa86uM6jMlAqoTpn13Eyl4AARICnjFyKkS9UYcClIo8jNsfHyEmQWcAlo3cEqgVUEkIQUOzNlt0jeCU9lcL40V/6nZ/7xXe85xsuZv7FAIDHH3/8R4mIX/3qV38ngLtTStjHPnqz/1w2wM/b0qndp5L1ltecpkAJPqJbRazXe+i6OF9zHRGiNc83m42qbWaFToT3ap8XYsBAw5yp1V63WoO763rtQ5SqCqQYZ7V/rQXeeQiAnAvG7Yhr169h6Afs7+8heI8pJxBp7cFEmKYJXDU7b7Xem0FCtQ0XTFNCShNyyvNrdV3EOO6yuFrUDyDYbDZn9jCzfZ+XuWHfALqm3A8GToSgjlvTAgwJIWpck32+SzABUEUiRP9bSkFvlqvNhUlE8KlPfepn77///m+8mPkXAwDe/va3/0sA8hf/4l/8tv39/bsbUDfvghdgVFPItrW4tP5t9z2febd02mhztj3XUgnYXqeBW7fKBlxmhzYw7vLly7h06RJKKTO4dz6Xr4FfzQ50bmnacc/kZHuN9h5zzrPCsR1fUwJ6703V3J8BFNtztrrDLdTQDbRvVsnnRzuOdi5ZAoRL8LMphlNKZ+xLl8/TPoulKrHrOtx///0//+M//uMX+//bAYAKXLhZkSczUGGgBi+Ue5CzGWeGIrTCy+FcLohUBXjgQGQWTaLg4az2kx3U0mxA1S5vUfA2QBIAN7UWq2Wlg25eHTmgEmoUdPAIBFDnURJQyWN/f42bx1uz39wpzqQyiqvwISLVilAyuhhxerwBSBC6fg659aT5W33okNME1xFQCor3EO8xiFOFHutGgYktZJENVFNTK0cOjrzlb0AzfmyTH6KHI4+UKxxM7VYZnY8aMrwdUZmB2CN2QXFWEWXqOwIFhyF4bJFQcgHioPaduWDMrI0+qJ/+HXccYBonpFzg+qAZhFXzCYPzmmlWM8o4AY7QhRVQCthYhyUlA72CAle9R3WmjWMGgm5wXND51ex5UCooauOzlmrsYTcjUs3VUJiRpGI7FYwpAbUgMaFzank2booBMx5iOYpwDjkVpFQ0mDgXpKxZCVKLZbHZSbi9YNv4YMakTW2n2S8KRcymTJA52A1zN4XNOsqR/rVagxiyVMhygxNn0FGIQAbA66JQWxhiVo9cpyfX4LxGSFQ7VmIFyakDmrJrKTZZgJMzqC+66fK3gv6eyc7z8FlAwqNnAQdvhVfcDlx8jsrA84flASB71B6I8Ahut/4zPA721rh59XDOf/vkhx7G9NJDvOCuO+GqKgG9PZGJzzQD0HgSWmB7jQVjxVg9QRtlqHACU/OEXcajF7PXcnOTTH1tdF6Rc/Bw4FwMVAZcJCviW55GVjWSDwoHpKr2wa6xBLVhJoVnW0LN0XNACGbHo/l+qSaYiyBCUzRURqqMUFhBQrHzNbQ4r1PFuD1BrAP2wj6oiil7dT5XMGp1gA/o1j1qm36sayVY81/VeQU1V1Wngk3V6gA7L4g9Tt28Khi6QUhjguSq5zOctfp0C6Umm1KTDcx9+ImbyMfj/J0/3SfzuY3DW4B/OPP7eA6/HvHMCX63G4NF+g2AZQHi8HZrsN04PF8c83kmbH42goCbH37gwceOX/6SF37npb3VS5xZ0JDZNLfCvV279TzbGvOmCLIsm2ZXS44U1Lc1qFFbbf3bxhvK1qUz61+JNGLgowu2qRYt9LlmPaUb+7fkrAp2Z9mjTpuPXHm2M1V1rwP5qFnDRnBKzSKQgSiaMcgVyJURK8MFr4rhph4noJYJ0+YElVcIYR9OPaRRbFdWYWo97xFXPaqw2QjqBckHb+ufUYvYGnazmr4Bec2yT63JmrWRZgemKaFmtVQXsTwlAriKAQ5mBSh6/WfW/epjT92872Ofevy/vtjmX4zlePTRR3+MRbav+dIv/Sfr9eol3mvjDMVC6y3/UxZNgebXLmZ52/IDW6Gcc0EImhEsc8G/24b52dZz57bCs3qXNe/TYhgqq3LQh506HgsLTW5KvWYuYPs9YSxUdfo7PO0Kc6jaD9LIBaQkHiFzLCh2/tC9dNvTim2I54aGPZ8SQ2Vu+jUCZ8t+3wGNzZxCwUDXyIDUADxevI4xp60RWQzIYyM6zEWnqSsLsykE9fG5mHWrMK5du37fb/7G219/MeMvxnL87v0P/tjf++f/6uTr/qv/4p+++mX3foGniuodvAvwTIBjcK7wjuFchfcRLjojABK87/R6TzC7rhFCDrFfgUIPPytVitb40GsSQg9QtTx2p80XFpSc1RZTKnxUu1CpDjVnzQSEQHxUAvGYQLUa+RdgqZa/qSRjkOYCCzzYr0B+AIUeQoQkBQAjkId3DtVp3V4EiAyI1S5wDs71AAg1b5CmLbwIuv4A0Wk2WcqELIIsou5CsUO4tAYgCE4jCYAAHwNcILBU1CJI42jOP2pdrHU5wKLX7ODirGaG86ilYtpukLcTatGayJPWPpIZgQvIe3MUIHRdRIiaffjWdz3wwe//+bdeXP8vxpnx2GOP/Tgzb1/1qld9597e3ktyzlitVrO13DJHq2VjtQa9QM4oY1JKZ+z+WsNb7Nro/C6CZalWifZvCTZ679FFtdesXGe7uxjjrCgcN1uUUrBvTe8GEFZTwgFKPgohmLLP8sagFp0iQNf16PuIadKG+rgdUUrBYGRh7xXoy7kg54IpTapu9G5WGeWSkXOar8neeVy5fHkG/dp+RfdTjHGrakO2HMX2M1v2n3dZaybaWYsOQz+DMc3Sc2cbaNntwc9ghnNuzmoUEZycnNz3zne+8/9+MeMvxjkQ8Ie22+3Nv/yX//J33nHHHS9Zgnft3xJsanlzy3m2BPFulXt3Huhb/t4At/O2lsXyQBuY1ff9mfPQMAxnwLaWWzoTBdraW4Bot1IUNmCuPU977vP5pyklXL9+HR//+MdxcHCAL/zCLzzz/OcB0+XvS0XgEgCcz6OLz6Qd//JzW4KL7fNZKjLb8znnZjvWEMIZi9Ynn3zyvu/+7u++2P8/EwB45reW0zIXvpiVfOeNP2fwz5R8PNejMheXTUqlBaxbFJKLOm6eFGZnpZCe+Wo7U80w6k57pc1x0eYxESF6zZsS79D7YHZW+jreOZB36IaI/ctr4GSLkgvyWOG8Fq+5Muomoesiivfoe92geieYpgwfImoEcmb4zsMHBx7MlocFN568AfYBd9x1SYFJs68Aqi3CJm1XS9J221wv064p4DQsB8MQwdOIcaxwoQchIKUJKSdEIqAkMKvCLxUxGyyCeIfNdkIBYXXHPsatfq61Fhw9dYI7X7APVwR5M+3yRsiBMkM6oGj9owooR0il4toTN+D6DV744rvgfEDJak+WnTYLuCbAO4QhwpvtmVS9OJvAB5WrKgWK2vTAAaWqbRpDUKptMJxHKYKcMjwFBM9wUUPYt2nC5qQgXJ6jRsC1qu+5NRLTZtJmIUELqypq8wllFfdmo6gNHQa3LCgi61kSSNR6TWZmpMw5f3NbqPU4AZAoAAlWgNo52Vk8Gr9ZFao75rfMDdA2igF7zno7lkvjCE5Ulq7hx51tSDNaDqYsQqU0n5NMqWLrbgb1LesN8szowDP9fqu/HT4LUner+xzhuSkMn8tTHx4CAWAPrKJazVksH5zTTWPXDbh05wAMhxhHy4H7+BG2GfiCF9wJ+LK7UPodED0rzKAWvXCafaMJg/p3znp7VE4BHFRxG6Ip3+x8QGjAwM4yWbjCAcg1my1Qk+xbw6EYE1BUgZTGCY00W4NDnrLa0tr6EWMdx9UA9p2quwlIteA0TboeM+CTt+LAKaO/CNgr4aOLUGUiaS7l5upTcP0Kvou6KTcSg5BD5YIqCcF36C4doNailsbVIRe1OeKW58diWZUAKGh2GheUqmoiLSaMjFIViphqNssTVUKWVBTQ8EBAsRxAZT/bEgSj4Oq1LZ44fvjpU+75zrmn3X+8LQjYFHqHh7d5+mfMwBzP2YYaYPk0IP5w4TEK4PDZwMal1ehntNw+q8bN083Pvf8jDz/0xS+59813Xl6/VhXYqpjRzSXbNcWCwb1XoKsyXGhabwBVVXLK5LdruK3XEBX8QrODJtJMPtqd/0Xa+i/K91isfwKQatVrlzXF0zgp8Sl2qOJQ62L9G8hAziEMA9hHyw0FcinYpKRZoDnDTZY7aPl9tVQFKQTwkUxNIEgQbK5fh9tsEboO/dDNryGkr98ICv2lPS1CvAMqUIqbgYSWrYbayA7msmC5XbloIxMtO9oYws0ulNn2MZk1h1lUGcmsdozknD6vgQU3TsYnHvjEo1/Lwk9czPaLcX48/thjP/ubb3/7Q1/62i990113Hf4REC8APm/53Dhjz6kWWs4UaG2HsSuumRk5NYBQFhafOwJjq7Ha36nZc84EuMZ037ljNgImYackbo3JpUUoLTcWdFYxuIxqaKqEyryzBao8Z/Sg5Q3tuhlnbH8a6VOYEYKqktr/2DIBi1kEiuwQwAbqiykCea4vMW/oS90xgnMupq5a1IwGkFLL+mSZs+FrMdZ2rjg93T7x27/9u3895XztYrZfjPPjAx//1C/8nX/6E1/137/+T33/f/Cql7zGUUGF2lw716FQAphAUgAuAHpTAWvz2QV19Cljwrg5RSWPjrXhFj2BOiDGoArcavuCECCuQmoxIpHuf4UzhCtECpwjhK4HYkBiRk0EVloxUq1I44TAFX5WHWfUpC4gejIwVvRqD9QpMVm8Qy4VN3OCsCCkjDA5hM4jBIdgucZMDmQEQDgPFwAZC8ZrVyEnG4Shh3dm5+09yBM4T6hIoDigu/MAUQQ+QKNWKJjzUZMdM1yZUIpAwqCXegP5c6ngKoghGqGnzM4AjgAnrFm/mRE6r7b/VjsJ0ewy0PLR7vvYI098+4/+0htSKRfb3YvxtPHEE0/83Ha7fejLvuzL3nzvvfe+lojm/KvtdothGGYAgBfXyUZO8aZwa0oXABiGYQb0iAjDajCLTGtwC2Z1iiplWPPqWcxWU612Y7MQhvawmsJFRHP+AjNKzkjeI5eCZHV98MHyeQMuHRwAwjjdnCKlCeM44oknnwBXBQCHoUflir29Pa1lSkGpxfqWQAiqTJymCbUqYLE5PZ2zu8n+l1JSZd/Q4d5770XlqpaEzRnAWQ/XEaZJgRRnoACb3WjOCTc2G80oDA7CMjf1G/C3BDVmVwbssv6oKRpt35Jzfvxd73rXG0op1y9m+8U4P9797nf/3BNPPPHxN7zhDW958Ytf/GVtri4tPdvabhl8zR533pMvlIINnD6f+bcEtbRdoEq77XaL09NTbDYbbLdbXL16FdvtFpcuXZoBrPacywy/dk5qdUo737TnbuSDJamggWlLtV67fXm/JSjYRkoJDz74IC5duoQ777wTBwcHZ+w55+51y+peAH9LEHJpm3oeNLwVWLoEL8/bhC4/4/N5hw0AHMfxiR/8wR9842azuVj/zwQAChF2bp4y+0TvUAoAqArGGetdlllm0ib52S+/ecQ0a0SyppjVpvNzN4sZxwaWGJiovwWQ07wbhzJrsNQ6Sg+wNcYws2B3do2d8+pFD2C1WuGOSxXBBRzf3GAaM8gsaNjsPmotyIWw2QLeK0AVQoeUM8pJwZUDZdKrMUeAd4RxzDjZTkj5BAXAPYf7kJzBW6AbPIgFxEWDvaMyY2opFgwO9dL3JicqotlWDgBXbRSQQ2BGLVuUlFVy7xji1EffOcCTQxGei2TnAzwxtpsRXAqmFFCjgqrHN7dYRY/TSZCmG+j7iIODAxQvCGUC+ajNBxB816EDID4ijQVpMyKGDgyg+g4kAtfOFU7gfFRQDYJKHkQCD2X5OTKp/yqCxWMqjdmscyXnCTIBYdD8IOcJtajVmEDZfVPO6DttjBZRACZZRuGcGQQgQ1CS2QZZc8N5h8vrHsF53Dg1mwFyM+jXQA1GsNvEdFDV7HDVltCSXazBIqpgAoxFTZZniAVUvsiSsSwnEqhyQz+42TZppnTP7riNDW72R3AQb96URdcDWdaKkNnhCsF5anFzlhHYPmcDHWWn9b2tJeftQLrDT+PnZ0IenhGQea5ozRGAAzThaTRwrnMexen5a7XucKVeQggRxwCO7DmPHz7CR8cjfMGLvxjR1H/RK4jXMgKbIpBVcKOAFEw9XBJq0ryQ2nXwzNjmiH7VgUKnBSozKgO+t7nCjFwZHgHOMWII8BTApSjgF2UmBcDqeW4MuOCVtUFQmytmiAFnUpW9p815VdilKZl9oVoV1lJRS4WUiqHrsD7oMfgACmzgXECumg0aYkRcrxAOrqBsJ+RNtrnrjCVs7GYwqqjdn48OtTBCVJBU2DIrSYuAYIVPRQEhgJ1+aVLV5kCBGJjCh62IMAA2jbZCClwNhsDaBsTAP1eBG8cFD179+Nlpcwi8dDhEBHD14WeaT8M5YG00kPlZZuLR7nFHzwVMPLzV9B7O/H6EQxwuVYtHhwYQjrcHFZ828jODkJ/DY0r5fR/46Cf/2Mu/4N5/efedB3/aE5GwIDRAyQpdvb6oNNW1pjOUfFJLQU0FgCD22pSSUjCsIpxXW00wUFHRdWEmQJVS4YP+HIKDj2p3xaWocterHbSufwLbddD7CG+sqlLqYv2T/V0BBnEEBmOasjXklShTq+jxFsbQB6z3V+hD0PelkiG1BI4BLgaE1Qp+/wB1OyFt0mL967nGlZbBVdUaLXgFE6JdLUV2edKilj8sqpoWCjPzTLggp2LWhXareSw3pZCUorZojAXYYfaf0qy0CafbdPLBBx/5G2NKv3oxyy/GbUkAN2689zfe+rb/7Mu+/Mt/4J577/0/dV0kFoGUosWwNe9m0AuwnOagYBYJ/FwEK8jv3C4TsFZBjH4G+xrpr6kIQVp7eKckGW+qXFjkgixsOSGWJ27ZQUvLnMqijfZmvzUbhjaWra5BzTuVHaBIpmI+w1LGnG0423YaSE87SxaQb8qmRsy0YxXL92074DO2nzunillBaIroagq/Zg2WsxILdlZMdW6awvb7u2aIqoGrgX9TSsfvfve7vu7JJ5/89YtZfjFuNx45uv7er/uOH/k/fN1f+lM/9p//h3/oT/e9I4YCddF5SClg8SilglyGiw6hFgQWq82qKmQ2WgeUlBHKBJf3IAcdQjfodblq7q8LgPjWBFSQjEgjCggOlGEE4gpxCsJbpD1YKlCrxobM1uMK/HFiU+xbSIsjVAekUlDGBF8DcqkYU0LOjDJmyFiwv9fh0qUB/TpCRB1zQD0qCdgJQtfB7e2D1xuUzYTxeFKSUhfB3hQ+5CFcwFIQ4qB7AhKQq1qkW+ZvW/Mx9iBMKC6jQh0THFcwJ+RcQCLohtb8U+q3I1UY1TLBlQrnAScEPYU6hL6Di3GOFPnkY0+d/KMf+tdf9+hT1956Mcsvxu3G8fHx+972trf9p6973et+4GUve9lXrtdrijHOSsCmXmmjNeNbs3o7jhi3W1y/fh05Z9x1110YxxHee1y6fAld380AYJomOO/R950S63OCr05z/qyhXYr2moL3CN1wNrvLrtcHB/tmK+yQUsI4bjGlBO8d+q7X3MygCl9hzQUspWCz2eL45glONyO2UwKTYDV0ePnLXgbnD+1aWwE4a+YLhqEH84HZ8G0xTSPGcYsQoqlw9Hqfc4FzA9Z76zOKo3b8vNgj1VqRW666WRB2XYfNZqMA3lixGlZz4789Vt0J/AzItizBWtUOtQEXtl+4+b73ve/rrl279raLWX4xbnv9f+SR+775m7/5P/3qr/7qH3zNa17zlaRjXnMppaep9Zr1ZpvXTR3Yfl+CZ0t1W5urSwBwmiaklHb9iGnC1atXsb+/j/V6jRiVvN1IA+31cs4LklyerYqX1qRLgK79ra3Ndv5aHk8jLZy3Il2v13jRi16Ek5MTlFIwTdNChStnrDqXYN7SbvR8TuLS/nSpHLzV59e+ixjjnAW6BP+GYXga+MfMJz/2Yz/233/wgx/8Nxez/FkAwGZFuPvQz/5ixjHz31qewywwWsBy2uRhKx7dDkNsWXbzE+/CsUSUSSvk7TnFcjPUZpGsGUxM4NmOVC88YolcJM2YUcNwHSwfKwBOHPrOg7kghA6rNWEa05xZ4ZwDSdUNZhbAMcgVdD5AKgBHmFLC0EfAE/KYIHsRvgtAKbh57RpuXD9FqQXiHVaRMAS13QssYAd4FhO2CDwFkAXpEnvUzsPXCi8KVjpRMAnVWZFbUaqgpKyb3ODBhZGMrUggUABC51FFUE8ncK0Yp4zNZgspBTJFdOuIOw4ikgAnmwljqnBDhyvrAYSK7XbC6mCNlQ8azF0zHDNi6HDH511GnjJSFpRxgjuIoDxaFg+U4dx6cV4tCF0gzXokp6xJYpTMiEHtlpRZrbZdjgihiyipYBpHJHbog0OqGWUcUbxHTQweGXHlkaasVowQjIXB1lXQXJCKnYhVWccMYH/d4479AZM9VtUCNOdVKntZVQ06ldksWHfsbSJtYtiWZAbq9JUUTCSp1vBkaLpjy19ZrCtn87v5Ts2aMlYlJ2nBKGbV5E3dUMShitOGDnmAC5iy5lG1dUUAVWeAfstdXPRKsctcuSWicXibn58J2Dv/9+fCuTwDfixz08ZPQ6J0CA8D52oFw6s9TgQcPLreg2vSjM9+hRjzGWfF8Qj4EK7ixXcf4NI6Ip8BAe2MVQuKB1ATiFfISYGVWiqK2fUWJIwO6Fgz90IJqshjaEaWqTg1pwZgUslgZcxNcphSlUQbiCza4FdQ31vTjC0rlOF8ROhg64xRM6NMGZsxIaWCkjNisNwickhcUUrV6Rs8iDxSKSA49M4QzgrUKug6wrBe49LhndiebAE4VUTHAPIMsJiVEfQN2jwLZvkbogM5m9cWAk4hGKFDP1MXepAAoVMAMFc2codDyWyfr4F+HuDUriBlp/yb5ZjAte0Wn3ri+GmY1+cPh7hy6QDTNj/HuXlO1We3Hz4bVo1Pc+7P4N/4jDD3bp0dfnpo3uGFBehyMMvxAw8+8pWn27u+5UV33/HG1dDtlSqqjGuZr2KWzLVoniVH5FQBUvu5UiocGEUYE8hUdB7ebC1JWhZWK+aVrMEsgHeostx4KxuY4FCqWmGqUl8zg4VUlViJQE5Abrn+RdfLmLCZElLKqKUo6FYZHqTZnWYFKvYetfHm0HtSB4iqDf9IDsN6jcuHd2FzvAHgMI7J1n/LODTykqN5/Wv+oX4G5HapnM45sA9QUbK+D/KdZi5GBtm5FPZ4Xf8824M6ywnUy7JZEXrNUgTrNfp4M00PfOKxv3fj5PQHL2b3xXi2UWo9/q13vOPPvPJVr/wHX/QHXv61McY97xUEV5DKMgGxq2e0oe1BIiilorPcLp2YTl0biGYlYAPiKutezhmJ0Fmotu0ud0DfnN9n+1RTILT9trpP7HKrycgyIfgzORytMG8NxAb+cVWXjpmnCVL3AG4qveYEQ6Z+IAM2DTwUnoE7WVjcL61A2zHMygYDF3dNEZmVFXPxb7c31W/JdVYIN+C07X+aCrOR//Q8KSglp/e9931//xOfeOgHLmb3xXj29c/jt77l577yY48cfetf/M9f9zWHdx7ssRC8E7joQFWz6pQ4l1FrgRSAnZJM81RRcwVyAnPGBN1T08qjq5ZlOWZ4T3Ch5WcyuFQI4s5xabYYrKg1gQss85Ytl9eDXK/3kBHCRdeTB9zK7LLZQzKQx4yTrDV+KYK+6yy6gFFSxnZKIGasfQ8WIOcKVzL6YPv6ar0WF9GtPdZ3VUz9FlII05jhSUnHIgJPDvCd2po6AUgJwKFz8DHoeRKkNYwL6FZruBhUWZkYHDRTqENFqRWlZgRoHElJGZKbK4DAi9qkUlaQg5xHt+oR+kGzzXzAo09en77th3/pm97/sYcv1v/FeNZRaz35zd/8zT978+bNb3nFH3zFG4fVsBdCwDiOc+O8XbOWipucM4o18o+OjmYrupwz9vf3cenyZSW0GKmlEtC5fo7pEC6oLefXHAGYq/WhGhgH2y9YJpip+5gZzpQ+/dBjvben11eouOD09BQ3btzAZrNBTlmJtAyshzU244STNMIFjxdduRtd7FBLwThuLY9QQbZpmrBarbG3t8Y0jig5I7uMzXajwoi5we/hve4FQgxw5EzgQDNQUsouTzGEgGnSz8+bTSkAHBxcwmazwThuz4Aq06TqRc0nc8g5z9lo2+1WX/NsTtp0//33/91HHnnkYv9/MZ51TNN0+o//8T/+s3/hL/yFf/DH//gf/5qu6/aXoFVKaQaqSilIKc3AXAPj2j52CVq1fXh73BIAbM+3VPGt1+v5vksF4VINt1TCtedoj2n3afbFYbYhp3NZ3ztwb/m+2vG0fw10Ozg4wBd90Rdhs9lgb29vfh9LgsTy/Tagsa31pT3yEhRtPy8zAJcWn+32BvY3AHR5Lm7gXyMRGDlj/Jmf+Zlvetvb3vaWi9n9HABAtbraAQWtCaXhfx515/oyF3iqPDLgxAKxdh7ZZp9lqANJCxJUlQoRgw0QVKmHFdbW/CZRFwtVo4jdbr5ZMMsHJxBrmjliZYJ5h2K81wDAk4eTgD5WVPHYTAJQQQgOL7jnMlJJuHk8ah6F9rLhPCGnDJKKuBcAckhj0uY9W7OfGbkSgq843o64ef0Y149Vvt6djMgHKwxd3H2MVuCLqLqPCHDEc4aHtzdfM8N1AcQqxa+VUKZkjXMBQkCaCvJmRKmM9bpDCCsgACVXkOjGv1he3o2bW3QdwCEog6AAN5Op05zDlTt67HUrgDOubSasPbBaVWx5i6kILl/qUBiolDEMA4YQMU0ZWTIcE+BZWcBVm//sdqpPFAGJg4tkzTplOZNXpq+Y5DQ4/T1VZTc779GRWgRtxgRHwHbKkF4ZkC4o079lnuVckCYFkGsuqI7gPRTIhTZiUCq6LuKgjzhY9ai5gptVGEHzBIhQYXlp1MxsW9Zftby+lpPJc+6QiIEP8/rQL1ikgqBqyGrWTMKNwYwZIFSArq09e12qs4UuseyaPWa5SE3ap4bpCqyLAklqdarN2KUat+UtNc9RZjpjYXpbtOFW6sDzfz98BiDx6BaA4S0VgcNnbAeKEBVK9br+O+dBEtBFBrPH6dbDeVXhHN59CTkf4ujhozPv8ZNPHOPuA+CuK3fCiLeqCmwXTQPucklwBuKzgX8OgOSKjAoftGk9poJIdj7yAQKP4AIYrCpfsxpkZrOyUeC2cNWcr8LIxdR9hTHlrHmdDhiGHnvrHsERkAtySshZ1T05JdzcnOiFMkTE1Qodqw0gAaid5ocNQ2/KuwJUwEcHcEEVBixbpOs0x2N1sKd2JcYO1DxWndvBB83+I8xKb0+w/2tWvdo08V6VrmqvoBanmtunVs1UGbWYSjIlcKmoDd2r5zYxdmlot+da8KlHjp82Bw8PD3EpDrjUR1zb5mdQ6N3C2vNwAQIeNdxtfPq8xRLMG599PR0ugcZnQvuew+3PEwe8AP+ePh5+/Km/fbIZ3/eFL3rBN1/eX32hOguQrq8FSUrXS1Kii2VvEFclZVTdP4Ro2TWpIJBmBWkOh9PzAIuC5s5pw2xe/woClMpAVbXenI1ZNasjt/W/6rFe9YiOIDkjp4xSWO3Np4TjzVbZxCGiG3oQCDkpy6/v1DJ9NfSas9vWf3CAlDlDi5kR+wAfAtaX9lVlUzQJSa+ZZFlIfrf+qa1/+8Wyfpg1t9Z5y7ktptBH0X2EOLuGsVoK1sZuZFP3U4s206xGkJILXFNKCnLh+pGHn/yOJ6/f/EcXM/piPJ9x3wfu+4Zr166/85WvetW3HhwcvFSz/EQzZirv9nkNtGM2txJGLtnsc51lh2pecyl1zuBRYuPC8x+Y84HPWgbtLDF5UXPNCjxT7dUqtrwIznLVAS3CK7cGneWamiMKZocQq9fMspiN/dtsQxvRswGejfTZ7MEa+14sw7CBlk0cLOJ2mZ5YkhvojO0PDJTMpdpr8pxpVEprcMisbJx/Bs2kumKvk0vBNKXywfse+LYPfejDF+v/Yjyv8aP/v3f8rY988vF3/bX/8j/5lle//EUvhSc4eDhXIbVaLr0SccdwClSP7WZEmRKcJAgyZCQUn1CHgJJ6jKkicIVjzQcns/IkD8SOwRaNoQ16U7YaQF9L0SiMwhAhVCEcbydspwRPBXvriL1VjwgGJkKZCkoGSmKM24Rr2y2KCLq+R+jXcIgIXhV2Q6e1+GoYUJhxuh1RSK/DRJvZAQdO4DuHftXBdx1q0aYhqtYnbJvwQF5ti2zzT5Z7qO/ZzZt1htUEopEjvmUsB0LXR+RUVC1ZHFgqslkGssD6Aw6SKggFgEfoIkLf688euHk61n/2E7/6j3/jfR/+hxcz+mI8r+v/fff97evXr7/3la985f/3ypUrL+u6TkGvlBC7brYCbNe9ZVbWarU6o4Qhi8aZUlKCvDWrh9UKXReNPNPPZJp2rV02ylNKKFV7gcEyyW5sNsi5IHYRB5cu4fLlSyAA2+2IzWajiuSUcfPGDTz55JMgAvb3D7C3t49SCk43W+xfuoQXsT7H/t4eSIDjk2OUWuBDmAGKlDJEgMFyyIbVYL0jRspJexkhYLVenbEUdOTUwcQctdQFZcdx8F7ViTnlGSjous4AFFMMGyhxXn2pzyFz9qJzDjHEGfwTkfrggw9+x4MPPvjtFzP6Yjyv6/+P/ug3PPTQQ+/583/+z3/zXXfd9dIl+J9zPgP8p5TOAHrnLT7bHAXwNFXb0saygVrtHOK9RzH3kfV6PSva2rlladPZgElgpxAchmG2Cm0WukvFXTuO5bG3118CbjITExxWqxXuvvvuM8DdErBbZiICmF93eczL+yyzA5d2ye04m8pvaa/c7I/LIue02X623D/LSyy/+Iu/+I9+/ud//uL6/1zb5mzMakD91mFFnTq2i6maMEudiDEr9bTmtI3f4iTfcjJaPcvAwtbQNXdonGmtC4NEm0tqMcqWvUZnMiAKi+b0iMwGi2yMVI2d1m22A+BqAXttRvU+AIMgF0E3dNjeOWEzZXhjkitKoqVlKYxpSqisDfVu3UFyxsnJFnHoQe4UERUnpxscjwkpV/QgVecxIaWCWguYg+ojPUBBPfNBgBQHCgQXvTH5AuB1I+DMziYLAd6hTBnbqYAhuPbUTVy/fhNd1+FFL7kbayLUIpCSsb0+ohoYN0IQhghxDEcRly/voVbCpZVZlOUMH9Wu6KnrI7ZjQby8h81JBrDFVIE+EsapgEiwGjzQd4jea8PBBc1GErUK8SJwrKqGCm1IQCrIRaCwWa22Bh+swGFVfTZFqWjOkjYRlCG5yRlFBCvvUIPmshCrnOpkkzGNmv2HqipJnYBqQeKc5h6GEHD5YI11FxGCbSJAaj2igW16XKIzHjavNEtvNuW04szvcvuIAKoGTisypP0YawyZ9SxhJ4UWVJDzlhkoaK+gzO8yZ0IqPiwAkuUUegB6vLUBhpYrg1ohmCDoABfMsg5mk6ZAPKFlDyow2tjf+sKLDLFbiYrO33YrQPA8EHh4C8Dj2UCKWQ316SAbZgEKwMNbmQ24whATiAxRmWaOgVW/j+224HC05z/cvaknPn6Em4cLS1BTAToP3Yxr8BeKTZ3CCvCxTRSqFaUk5OxAIagKzjuQ2dNk1so5mmKusOZnKYOvmvUgaS5GzkjjhFQZuQLXr93E8fEJYt/hnnsOMax7nZdTwnjzFLXq8WRhuK7XzUHQi2TLVvUrwAUHig4Eh5s3jzGdjhi6Dlyd2uwEhwrGIIxSPELXIQYP9kBxANcMEafP4/TcPef6sKVltkiSlq3k1MqwsqllmY1jovao1Pb/Zglaa0XligJbY1DVn34PltPod/asUy1434NXF3Da4Zyhd+fBgPUqIvpwbmKfm+M4tx5uNUXPANqL+7ZIvtkCdAESLu9/eDvAb/G3o90r7lbA4Vlg8vzifFp+IC6sPp/nuH58+kPv+/D2V1/yeS/4n+59wZWv7IJ33JwNyCkwJQUOypIHAC5KQGI4OAu1z6XA5QLqAoJzcN7AKnJ6nRJBsIK3Vtb16dQ9gYjApv4tKWPajsi1IjPh+vVj3Lx5iq6PuOeeu9CveyWZpIzx5kbtPVmQhUFdVDJUCGrNCQeRjDX1cEHXLsjh+OYxps2EIURwJZSc4KK6CfC8/vUcIt4a8TWDRRVOzqyG2oaeFzs8okZssSIDBDa7a+a252p2g4vHMCG3AkVkBkqVZajOYuQUfKx23U1V5IOfeOyfPfbUta+/mMkX49MZjz7yyI8dPfnkW1/7ZV/2PS+8554/FYL3Iqq+raaEI7A2+OzCI6LXwBaNwCxqay0E79wMXKsNKFqRYfnkuwxAGBt297tVRqREg2ZBKsb+140ozc4BjtxMvNkdb1P+0RlyZ1PyNTmhgoY8A3xz5CGsFqSmWpY5/sF7Bfn0fTnL7NTjaHnG0tSEMwmS50JRrOlAVgIWs/LnyqZE3Cl/WcTyUuWMVVBlVVjUyii5yIc/9JHvfv/73/8NFzP5Ynw6450PPPgjf+PbH/u1N/y5P/bdf/o//pI/vbdyPsSA4IAqWlXUPIG3GRw8pkkV9gQC+QhIhdSEWjvUXFEEiD4gUIELHtX2sUJes9vFGm6mkBUnhgN6cNHafhozxlKwKYRHH72Kp566gdh7fOFLXoh4cAUODvVkxHgjoSSPJMAIBx7WcFIRYqfZWhT1uswBvuvUwQgOV69ex3iyxZ7r1IyGR3B0qORQJSF2HnE1oOsHcHBIWZ1zRDRDHK4awVvr6JaT6p1D8KSEIob2DIRU5UQEqWJuR2p3Cu/QBY238C4gp4xaJuRKYKeZxFrgCcRFrUkGtVOMnpHZ8ff81Fv/+S/99gcu1v/F+LTGI4888sNPPfXUW1/zmtf80xe96EV/OnadW2YANvVZa8JP0wTnHC5fvjwr3qrFAjSrvKEfMAwD1uu1Emcs47YpekqpCCEgxrAjGYqS4NI04caNG0b+ITz2yGP41KOP4NKVS/hDr3gFDvb3QUTYnJ7i6KmnVDhgIOAwqIXoer3G3v4eRICuH9D1Pfq+Q+xVffzoI4/i6pNPYTUMyDnh9HQz25+LCPb29rAaBgUonPbratW88K7r0PX9Trlj0QQhaDZhqQWRwsKpwKwBh0FdSIwQ1MDDBmQgZ3UpstFubxmItwIGaq388MMPf88DDzxwsf+/GJ/W+M3f/M0ffuCBB976V/7KX/muL/mSL/k/Oud8A6kbUJZS2uVvL4CsJYi1PGcswbR2//Z7y7istc5gXdd1umb39rBarbBarc4AeUtb3faaDfRbrVYz+BdjPKNePq8ezDnPgNryOVNK89pq7321Wp3JM2wg6BJAbCB9e38NuDwPALaxdA+Zc8jtPTUFMKx/QUaAaPdt4GmzZLb3zL/+67/+z3/8x3/8Gy9m8vMAAEG+IXNwBviJAXsN7BADAxs7VLPOGrq3u5MsGazYFbtNtaQFoFvYhTa1YJ1D5akBI2xKsUqq9oNabinWomCNd8EmFSl4WBnS2cuawosFCHBIrEWpdw55nLC/7vDCw8u4fvUYCQKWAoHlWhEhp6IyewfkKWMYepAnpHHEKSd0fY/tVJAKIzhBDIS46jBOE4L3yEXZ+wosKchaWNtgAQIqDkgJLnaIUVm5EEataslBKBjHgtPTCYyKkhK22y22OYMoYrutuCHHWK06lLEiTQUuEHKe4FitNsgnbE4EN49HrNcRZczgtAV1Hi4DJU0oDAx7PXJlSE3wHsjkMdWCMjKC1yZDZEYXAIkOJauNoAsE70gz0JzZFlkXgp2HE0H1jMoEV8UsDz0cPMQLxDmUrHaWCiYzbFuAKoJNYnTrAQhOAU51J8N0PGE7jgjeobBulsKgIO2Ustl0CkgYXRexN3TY3+sAT6gtM69Nz7mp4SxDXSCuAuIhUJCSuJ7J0mvc6GUgMpzmYTZ1n/Zx1Ba0YRsQv5BJKTAnNqcbGwxStZDkAhGGA6ltpIvIbGpaWMPZ6QaoSgFVgMhro4UA54yhAW3ezEGfFgQoDfFuKqZb5ffdTv33TLl+z2Qbejv70MNb2X4+T51SAWAXZVtmYMeWCeiROcEBiA5I2y32VwGfd/dLcfWJY4NqjuZjGwF86JNX8eI7D7C/ByhuHGYQSpmsQVvbFWAPsEnRHHRt+AL4ClTtBSKXqkoW5QNgFFZ7j6DEAXHaDCu5qK2OONRSkXJBrowxZVy7eoLt9WP064jNwR7GlBEATMenmG6cgHwP18eZgcOszcpaea7Pm00v2CGZhYG4XUMO0NQ4z0CurOcsx3AhIniAUFErwTHDk9p91qI2pd5HkJH2WBQYKbXlxe6AdLVv3p3vXHDIVe2cHRe1WSvVMhHs+WqZKSMz+Ne++gp8+LGrpr07izwPOMTeKuJgvQK8TpOnWWA+Tdm6BAHPKfoObwNaH6qN59EZEPsc2Hc03DpTc14n460P6hlzNG9jBfqMDqH5Yudzm1ErP/qxTz7+X55sxr/1knsP/+Z6iHd4T6Zc1U0qZzZrSwW0SEiVQabCyYXhK8MXsTwdQi5NWavXg4lF2bHB7bK5bN47k2fXWpFLRa4F21Rx7eoxtjdO0K86Xf9TQQRjPD7FdGMD5yNcHxBi0KZ7syExFWEDzbzlC+aUkZOSi9gsCqECflVT2/ofXFSTau/gqKIwqa0pRNe/qDJQr1ONZKMqQVXoYFYXNbAQYtmBrISUWuw6alaCtbJaoLbGv53DGJrPSM7ZeUWQK+SjDx+9+ZEnr77xYgZfjM9k5Jwf+613vOOrXv7FX/wNL/uiL/obw9Df6b0gxACuqmBn1rmdS0G0Ih6LPAxAbXeFWVW10OxeIrfI5SAI/EwmW9oILcHASvpaLLtkdG5uK9Y821kVtxzwHXFy54cvcNaAdM0+l3ZZgo52Suemd9Y6bZeB2tSKzFbbLAp5aU0G7M45uyxPwtmgibMM4PZ7rapGZlEVYHvdVlUKdgBkNYCwMiPnIh/5yMf+xbvf/e6L9X8xPqNxsh0f+4c/8It/5v5PPPYNf+Ur/+jXff7dl+5wqBpzAY+Ss8aReK9uMqLrzzvAxQo4dQ6ohVEzUCMhEKFwRZ0qhIE6ZpScUIRBwSP2AxwlcEk636tHrZpvn6pgKozj04RHHr2Gm49dw+U79nH6goyxOIAzyiZhvHYKwQCse8Q+6p6+Fo3a4AqiYv/VdZjGgpQqttsRRRjFORRbk9kpiRJFkAXonMMqeITgELwgJYJMgq5TZSNLQc0aseJjUKKEV2KPcJ17NNovKnbtb/WzkZPYI3gPsrqoUEBlVUgCBCoZVBniAlzs4LsI7wNiIFQX8D//9P/2L37y1373r1/M4IvxmYxpmj71W7/1W1/18pe//G+/4hWv+BvDMNzRmt6tYR18OGvJZ04BRITtdovRsr36vjeytVpZtsa7xmTs4jz2D/YV+GqZtk5vH0e1v9xuR0zjhI9/9GN49/vfAwC4fPky7nnhPRARXL16DU899RRCF7C33kO/1yuJRhix72a70BgD1usV+r6DQLAdtyjFlHjeI2cFI5R0JHOeYQgBkUzVY++nlgLqe0TLA8wl27Vc+1UwELSpp8g5kMjcm0hpQs43uRt5AADRQUlEQVSqogzBz8r/theYphEpEfq+n20NU0pKRFzYnJuFoXzqU596y3333fc1FzP4Ynwm49q1a5/6tm/7tj/7Z/7Mn/k7f/JP/sn/brVanVn/LQdvCcAtgT1Z5Gmfyek2RVtTvDUgq83n5eMuX758SwXgUj3YAHOi3RoZhqEp4Z6muLvVf5e5gM3WE8Csbm4gZVPatce1TMTtdnsmw68Bj8v31+qTW4GAS5vUBvYtldTNarWpFZcAYFP+2XuWt7/97d///d///Rfr//kCgNSKMa0RjRl6DsRrf8ci+88yV1r0AyrmvD7MGX7QP+xSAueikEzlp5gEtwpPBYVGGZF5YcmOloodoCbWgHPkdhKSdn+znGioeYhVN+ROL9hdHHDXHQ45JWDjkEpGLVVBFK8WVRCBJ92EilQIE7abBIcecR3gQsB6GHBaKgQO4/GIvcNLCJ2DVEHNDHFAcEH3vpWBWrE165rgCb2PsBxw1JxQjT9fp4xpk9CvAoKLuHY8YrsVoDowCHmckP0K+3sBp9sTbLcjVnsrrEKP01S00YYA7zIcHHiqOM2TfisTq9/+mLHai4gOkJxx6fAycmEExyiiFoTDEJEKgAjIVFFFGw/TSUJcOcQuwHmPQgp2tuxGiGhjkJXtSKAZUC61okDgnX6HwozCmhEICMSRZiiBkMYMyoTxeMQ2FYQ+otaCvJ0wtRwC71BzmTNDwGxWq4QQPbrOoeuCAkRmb9LwMIZOODc3MPR9aHNGkZFqzUsHgA2sZFIwhLArZkTcrKZVBR52jRSoBVqzRBNTQ87WusIgruBaABR4qVoYBQdQ2OVwtsxNs+iFjwoyswB11GxA52e7T11H9maFAFchDfE5DyosbT1vh7/dzqrzVgDiPM6pDJ8X1vccAwXD3MEH4NEiFjVvMsB3FS7Z6QgV/dDjLh8wbjNwfKjA0TLsDUf45NUjHGwOce8L7kSPAjQWagVQiwnTVIXGqKow9R7OdZphVfRbCwT41uwWIFVWNafXjFKhihCsgWdNLS6qYCUfQGCkPCFVACGi6wYIA9NY9LyVGOwjQh9BlsGJqgo75/V5UxqRLLcAmwipCo764NGvIobYIwYHFzsgBlRmJDhE51DEIYAwTXpe4VKRxhEhOMS9Ts/wog05b9aGDg4pVQWaTdXIEOWbsNrVZi4QV1BLQMlsrEAYs6hCTNHIuaqau4kBF+DfVIEPP/iEzbKjczI9IA5AFyL6Luh39oxTbXwOc204C1wvgcAj4NDm99HRbcDwWwLl4xnV360X3bBYS+04Gjh5ePb4D+328xajF6rA5zyeeOrGt55uxre/7MUv/EeX94fXdiKq3rZmOslOyaKkEm22k/dwzquKN+s696TroopeW7gogOhM2cLEiB4zCQoGMnKtIMsMzTkhFc3867oeXAVpylp4pwoJQVV/nubmu4iqhVgqchrNJrQAzoOL6PkhEIbVCqsuoosBLnRA9KgMZAGCd8gCRDiUVFSdWyrqdkKJQFz3qC3jtjI8KcjI4pCyrX+zppaWhagMFSUOMEMyKWGqWLYX63lQWFAqgFJU6c4MMfCPRTMQcwF/5JNPfP+Djz75Vy9m7cX4vRof/tCH/sFTTz31jle9+tX/4+XLl1/DzJo3I6o6hTdHhqobvWpXJGe5f0yC2IWzzYF5L9jYwm3viJlc4J2fLS8tJWBR9zQVoCnzTOnnnTJ75iyOhZ2ouvLJTllo+aOzNee5HD9ylhG4APbICu8GLjqvKiBVL/i5qdFAyfY8St7UHHc2m3/hs8SERk7S5mg15xTN/9PsRKf7IHKzKgEglFwVMJwKf/SjH33L7/zO7/zXF7P2YvxejZ9967v/wQc//shv/Ld/8U/84z/yihe9xrsEUAcRhzKpXaYUzPMRjkCB4GOAjz3IBaRJa1EXBJ0vYCbNvzpNSJXBHojkwdnDkQdXj1oYnAokMVKqQIhq311GjMUj9vvY3z9A9ANK8hinETUB3O3BD/3sCkNVFYYgQikTprxRQCFNEOpQJgEXRjcQ1ntrrLpB1X59ROw8GIRR1N5T4EHFwdcKcEEZC+rpFrwiDFf2IUGdaYgFgRitWmZRMiqZUwCY4QMBTKixw1QmEDNIXUXhyCNEgSMB1QKpVmiPE2SaAGG4vkPsB8R+QDc4JBZ587/6jbe85eff9v+4mLUX4/fs+v/hD3/L1atXf/NLv/RL/8crV668pjWflZSX5+Z4A6ZaY34YBqxXKxA5lGxgQVV1XGtkhxDAElFK1h6jV7JvA7VqKcilIE0T+q6HCHBy8wQ3rt6cj+/61Wu4du2aWoPeuAkI0McOMcSZAO+EzA2gYnO6wcnJKbabLZx3JtbVpv0LXnC32eh1uOvwEDFExEW2Xq0FzhFSysgWMaBZgIyDg4Ndbhg5U0A2Uyx9v13XWQSCKotYGF3XzQp/Ed2jVFP9gDBbgLZjaMok7wOmaZyBhZSSPPzww2/5wAc+cHH9vxi/Z+Onf/qnv/n+++//9de//vXf/uIXv/hLmzKtWWU2QGvenS/sLnc51zu7+2ZT29SrDfhr542moo0xzsDfeTvNVksszzvNQreBb0vrz2XtsXyOpeKvHWOzEG3rzPI0z9iXtvdbSsF2u8Xx8fEMjIoIrly5gnEcEWPEarU687jbAYBLpWRTVjfAtVn9tpzF9hznAE9+xzve8QPf+73fe1H/f7oA4AJX2xWCOoXBcHMx6RpW0UAFszAkpvmCsrtnQ8DN4hBs+RmYX0h/Z8vGEGPFyiInTTSTbV5Ipv4jNpWPqr08RZAPEBBKyuiHaNkYMmfGwYLpHRcAhDEXgAWXLx2A3BYnNxmTs4w8Y9uWUhA7beZPY4H3ExwBXR+QJ0YaVZbqDaV3HcEbK8ZHwsk2o4+EEAlenNk2OrjK6HuvipySsEmaKRa85XcEh5NJlTCD99imjMePTzGxsmZidAjxCqL3uHH9FDlldKuAsOqw3SYwCranFaELWB30cC4gp4Q0TgrKQTCeFnTRYb/rQa5H1wN+1SGPE6I4nG4m1Cro2Wm2HjHSWNSW1RFqKiiVgCuqqgN5eGJsU9aNBwHo4txgYEdgqpCaIeTBlRS0K4xpq5akXBksFbGPxrDOqLkgs+DmSUKWCooB2ymhVgGDQd7CWFMxszG1VFt1HaQyVn2H4NUYkqk1WI19SFp4aU/GA1ytZWIWtlD5HhEBBSgicFRV7AiPSq3FgjlTj83eTL/pqixssgYxO1XrGUuchGcgUqQCnODF8ibIgSiqyo/VktFpfILaTlEzWgsaJu8LwAnECSSNqaU5hESaL8dOG86BgEw7A96nAXdHz4LHHT4DRnernMDbgX+fae7fAgrxmoaBXCp6B8Ar2AZmVC52IfJwNQEOmMYKRsEdV9YIEcDVQ4yH5z6AI+D4EMif/BC+4PNeiugxg35z9lwtqA0YdEAXPdhpJhanDMAjOKdMvJbjmYtmhsag4Nx2i+KdAojkkKcJUhhs59/tNOFks8Vme6zKwvUlhC6CkyqDRSrEAEQqCtAVa5rFoUM3rNRGdDthOyZkTsjbir7vcMcdB1jvdYghwHuH4HUNTWPBlAvWewMQPXJmcC5qc5gZNTFKnsDBgYKDICCligBTBsQA/dT9LEJwBFRWNiB7gF1BrQBzQS3GJIIylmupJq/E08A/bbQCKQHve/C++buaMehDVf4BwCoO8JYLybebyG2OLgHA8/a2C4tQ/XWhEGwK1kO7fX6e8Zx97hKYu9Xcvw34dwRVFt4yN3A4Z5/bggpvv94OcZED+FzG6Xb6tfd96KE/8kUvfuGP3HN4+f8cvHjv/Bl7O2mkparNdAcPcQFVCLAmtodHHCJ88JimokSjQOiDB5iRNxtU7+GjqoTyNIFN/coANmPGyekWm80pHBh+dYDYR9RcUSfdHIvTnFxflLhTtKOG2A2IQ49UBakmbMeMUjPKVNHFgDvu2sdq1aMLAd4TQgAqBNM4YcwV63UPBI+cBVIqnOWe1qyMRl3/2iTMU4Fp0EExGD3Gz6QyzQdsdmcRlVrml4Cb5Y9u8lCLXTtVBrADQ6lZiRNS5fqhh55400OPPfmGi9l6MX6vx9WnnvqVt/7ar732S1/72h/4vBe96P8qIl6izAW7WluTcRzFQHcBvNkClQJHBBeDWmUSLAaAdhEJaGo/Y75aVnRbCk3Z16IOWg2lYOEC9HOmQl7Yd7pW8Duas/xmRK9VYTOvUis3JUHSTF5r0QpzU0NEz3VQZ97ZzoxbdIMd5wJ8bBEOXCvMk15zh22oEkDt0Gq1DFCzICbscgTFDGdKySiVkVKuH/7wR970u7/7uxfr/2L8no+PPvzEr73xf/jB1/53/9V/8UNf9Z+8+v/Sh+QFAc55JaZVB65aOoqGXgN+AHVrVDjwZkLtA4Y1EIcOBIftZoPNdgQ7jz52oFqQpmPdJ3QRDIcpb1GnBAaQhHDzdMLRUzdw4/pTcKi45+AudOsVHBNKIiRxKL3liueMNCVMqUA8Idx1ALdeYzw+wWne4uQ0YyqMdJIxBI/Pu+MK9vf3sOo7dNEhRgYk4/jmiMSC9V4H7wdspQJTgmeGTAzeJl3P6w7OD6gIqFNB5YToBX49AGGAC71ys7260sAHEHsUp/U5VwGVCrDoHsQ5SEqQlJXkOhXIZgS4IK4HhG6F2A/oVxHbUvl7fvKtb/qhf/32v3YxWy/G7/V46qmnfuWXf/mXX/u6173uh++5554/55zzLadr2dxu6hhAsFqtsLe3B5GmsCuzBWjL/Gp7B+88tuMWp08+ga4bcOnSZQTvcbo5NatBbYyP44ibx8d46BEFAF/96tdgNaxxfPMmppQwbrfatE8Z3ieIYG7gr/fWWA0Dxu2IUjNONyc4PT2FQHDl8mW88N57sRpWZvdH9l4IN28eo9aKS5cO4ENArhXbzQZpnJBLQS4Vm83pbBXYbBGnadSebNura0cXRBZH4B2cOPT9MNt+l1JQcp73EhD7XE0B1FSEIYRZpWSATH3ooYfefN999/03F7P1YvxejwceeOCt3/iN3/hlb3zjG3/ky7/8y/+cc86VUs4AfEuAbKmqm21xF8rARgBoSr923mj3ayBYs7zV9eJvCZx571VhbK/Z7t/W49KOdGlT2n5uz9tsPEMIs/0oAGy329lic6kAbCBmtvXazjN938/A4WQK6AYCNivR8+9jjjy4xWfXzgsNAFyClKvVqoGk9W1ve9v3vvnNb/7qi9n6aQKAImfboiJOcxksr09dYGRW+jmzYdRvze2ww5nlaqwvU1mxZkkDragVtYeqZLeTA1ANkGkdNf1nMRfYJUfsiub2M2k6vYJ2oiw7MFBFrTc8GFNR5VdwHq7TViklbbD1PmB/1SFPmjdHpngsou+/Vm6HjpwLSIBxO2F/3aMLHrLuTG0GdKveQExgsy0AeUSBNuocwQeHlDJOrm+w2huw2hsALxiPTxG7Ad1erxaX2wLPGRWEq08d4/Grx7h68xSBC0LscXDlEhx5TKlimhIYDh0YG8sB2/PAVAVSK8px0jy/nDGmAgfBOFYU53HHwRplFAx39whEGE9GOGJsUsLp8YTgHa7dYBxcXmN7ukHaZvz/2fvzcNu2u64T/oxuzrnW2mvv0+x70t0bcgNJIBLA7gVFEWlUXmPzWGWDzfP4PKVlvfJYUoCIlqKFopaFqFAvqGUpCmKUAgK8AtIkgITQBJKQ9jbJ7XPvOWefc/ZezWxG+/4xxlxrnX3PufcmEJLA+j05uefs1c291hhzzTE+v+/3WylJNalQTZVzC4UoMC4RY2C9aJkcNhitEWV1FEZRZhLEpAlSEHxW6yUig3VZb6cEwSZiyFlKSEUSnn7d0zlHM2vQQtC2A0pKjNK4UOCBkAUGJ2bTmmmtcFExm9UomdVHaTO8cgdz3qSIJBTFkxMwm3GehM/dj1sT8wKSS95f2iZVlhjnjeXnCJGzHWjK1qJkJVgQEplizk4r6j9JyLmBIiFQJGnyYqlku5Qtl42ydudrJ2e3CJ3nbAgkcti7KLa3UubMQyO33dzsnIhvYw93EyDtMpOT5wF4dwIcd7I+vKsi6SPFExkU5etriRLFbtM7kGCkQtUV3bCRAlIpzbSZ0jU9fb9zMCfbN6QHHvzQkvuuzDmoDVp5RuUfZAjoRijlAloWgEUZT9WESLb3XK3WBOeZTCfUVFkRa/ts6TqZ5KD7ArIRkrbtuHHtlBtXr9MtnmRy6V70NMPE7JWdzxcpWpTOiYVCyBznESLKRhKOro90Q8D6AsJ0hdJj+HbuxvdFgWi9Z3HzrAC8sDl327anUpLaVMiDhkBFkHLTMBK8Z+gtWknqcsGPlGXjEnzKcDymmG1NXdncL6RDkvf7vQ/b99ZmRaxUGbqOmYzLrueRJ27eNlzGT69pjjk00NEwnU9Ro13rbaPrDpl6xztA7XzG32337c8N5+Z229DjHQh4G4vr7yL0u7vc9vh4ZyjeJZtwCwX7LfzbPG2/USU+6/fd1wvbCHzi6p9cdcPfeMVLL//1phKHSpWFbSyb0zHhS2MMPpJkwPuIINJQ01Q529a6QLts8c4xmU4QtUYk8M4SvUCIPP/HeDwEtOueG9dPuXn9Jv1yyeTiAXpaI7UuEC4y9I4YPVppVFEG+ZSIPqFdIOLohkBvPc5npTpKI40pi/Rs40mBbtZ5zm6eFYCXM3cFAtv2GCWpjUHPJkQRiFLmCCCR520/WIwSVBKUNiDkRoEUYrYGDiFn/A15FzUL89PYKUluNhi/9EL+LlNagVA5PwhoB9c98Ogz3/j0ya2/vR+h+/po1jve/vY/uzhbPPApr37VV07E5HCzVhIShczW9vnyA5RCiDGnTkJR6Ynxe7A4pWSlftrEI7DJX9/CwRjZWPYJyY6rCltIV7piU4z5Slbm59VFSZjjGrIyL4N4se313IGW2TJ0m+MRis2pENymBBRCbJ+LbTbgzgoyxwKU7v6cX7S1/Iwl549i87OBeiXvM6a0cQKQYmuzlpsDszLQeY+1rnvfe9//De9617v+zn6E7uujWd/4Hf/1Sx/90Mm7/4c/8rlfdXEujyjz3oeILHmaPngSmugF0SZCtHg3MJNTUFOSkAyd49bJTZanC6YHBxzMaqSIuH6d4zPULDtlFOFbSInFsuXxR57miUeeYnH1Q1x4+YtR8xqhJb732CHSdh7nBrT0uUEnJZyQ+CgwNhGEZ9UF1p2ntxEfFdHUqMaQkkbI3LbngidGSz9YTp85wckKIS+gJx4IhHWHEYKmqtEXD0EFrDR5KRUTYRhI1lIbmBmK8mdr1Y3SpbFR4aPHo4hhQKOotaIyihQcw1AaESIIZ5F4zKRBmRpT1VRNxc1V237zf/7xb/zBt7zza/cjdF8fzfqFX/iFP/WqV73qr7/61a/+G8Dh7ib1aHm3u6EdSg64955UJ6q6KoDOs1qtSClxcHDAwcEBIQTOTk8JIXFwMM9N5SlbjkshuXF6wuOPP8FPv/1dwBnVPffwSa+4j8uXLhFTYhgGTs9OcdYxDHMO5jn/b9yMX68zTFwul7Rti/cOIaEyNXXToKQq1w8JW5oHnHc888wzWGu5dPlyvn4RgsXZGcTEZDrh4sULtymJRmjQdS1K6ZwbJrNqf4zzUEoVgCcIwW8AxbjRvwV72f5Pl0arUfkzZpaFEOj7vvvgBz/4TQ8//PA+83NfH9X65m/+5j/5R/7IH/lf/+Af/IN/ra7rw11wtQvZdgHdedi3Ad1FATg+fheKjVBwV0l4HgCeh3kjWBsfdyf1H+TremBjpbmryDtvZboLKHctRcefjxBuhKExRpqm2czR0e54F4DuAsDx57vgczye8X2z1m5AYoxZMbyr/JNSdj/8wz/8T777u797//3/KwGA2WalLCZHa0BRGjXHxWJKI/so8C9BCkShkWOa2NgxWrxE09jVuvNiI7tLSW4XvmlUQpWOz7QL+gqsQYIsykBCeV5x28I5/12RPehAkUqnjUAbjfUR8NSNIYr8ZSVUhQIqIhcvHuJvnGFtnqCSfAHunKOpzeZ1IoLVeuDgwKGVoKokMSgG6/HdgGscq8ERhGLWKKJqEDJvyC9PW5a31hA8iYCZNAQSKAUqsu47vE1EJTGmQqXE4rSj7TuMqiAKmmmDlJphPaAOp6QIbd8zRJAxUtcGGk1dT4kxMXQtXTsQIwzWly5/zWRa0w8e3TT4YSCVi5ZmWrNY9rSLjqNLB4SYGFzpyrceS2R2OEUcaqKIBJdyA7TtiFoiqyqrPmMsTpgFzkWZrQ1jYLCeEPMCyrvcRd1aTy0laMPaBtZDZOgtfd9jfUBXhlorVqsOH0GpchFRoDNlvFZaMakqDuY1ziZmdcW0NigELobC5XI2X7aqzbaa2axRFmAnCywc84wkoDfj10eByqF7SMaTudqoY2XpxA5h17gTknB5gyTmiRJTKFgikmLxWS1ABmny44QsgHIXhG/6oou9Z7GLSjpDU2RWT4mUH58EIkZkAfox7RLEAi6OnwPk3dEatL8zSDj/mDvdfrILHPtf3dOZoeiPY940ihJTmbzZjKWeNARJtvJVNVJBBVy+dAlu3mR57nBOdmwdr19bEuYNR5en6FCy6ILfZAEOFkzI1hdI0EYhZU0Ikb6zWOvo1i0ygjcaF3MWQJD5POl9IFqXs8JKRl4/ePrlGjxU03upJ4eAInpPROKty/kiNqBsh2gm1NM8jobO0XcdbdvhbaS3HdFlKZ2uFaICFyNYixISKbM6tBscfWtB5yySbK/rcV1HVBJda6azGTHlbEJnPVLkzK6wEzepRM4xiTHmeWEULnicjQyDZ7BDtkiSmiKtxLqs/hlzHKWCGDL08wGk8lw7XfDotf7O4Oz4mKlpmF4w6AHmlWYy0WgUNvgSf3duYJ70d1Gq3jkHMA/tvtx1nAfn5sJxzgO8jYWfH/vPCbqPt/c4foHA7uS8TegOyz7eu3/+Surqyek/7Af7wCff96J/Op8192X1TbG6jqNjQd60jzEg5DbAOsRE1w046+naHhEjpqqxEYzWBOkyCCzzP+d95ScbBke/7kkuUdcH1PUsAzsfCEScC/iQCDYQCDSTmmpSIRAMg6PretK6x/nA0A85u0MolKlRJmfoWueQJcZXCRh6R98N2Wo3JILNqsU8/xWmMkzmE2JK9IPFunH+h5yJGKEquMIFn7MFyfPf2oizgcE6hsFBCmX+50YCZ8M2N7DkjIYSYBrLpefpqrv+wGNPf+2Ns9W/3I/Mff1a1Ac/+IG/t1qv3vNpr33tN164cOHlWuscYVCsMJVMWWYu2FlgRxAhz9cQN04qSqSNW0qIWaE35gretsAvVsN5kSw2GYJC5rkVS6PkaPtJ+ZlSsmzalbVbYtONPx5ftuAs3cQy25ZKKTaZezkHKGzOa6mAvKzGy+eKWJSHqXQ7byzMQiwgIxb1YT7+fG7MNv/eB2Lcbkg4H/BFCTgu7DYQMcaNXWiIifWqvf6ud73r7z788Ae+dT8y9/VrUd/zpl/8+ieu3nz/l//pL/6Gl7/k0idJkTPwBCE3rYWQoXmA1HcE4RFSc2QOiUmwWLScna65eXKK7weqyZRBZEWM1wMiBGI/YJ3Hh+xS5GOkb3u60zWpTRzMX8JsdgmSwLUdNkl6GzLU6zwOS1MbzDxfIwytY73uYNXTDo62G/A2q2mUqZG1xKfA4B0hBbwSKCHpukTXeuS0AUx2/HAOt2qhUkwOJtTzGUEEehvwfXa4CSE37qiYc401WU3oQkILk50EQmBoe1ZtR9cNyOQwB5qqabLVad8zWEdCIGPAEBGNQZkabWp0pXngiavXvuk//djXvu19j/yr/cjc169FPfTQQ//7crl8/2d91mf9s4ODg0+KMTIMw0b9Nm7Id13HYrHYfB/WVUUIgdOzU4ZhoOs6ZMnhnkwajDFMp7NifxfwzqKkRBWLv/VqzY2TE1ifAfBJly4xaRqUVnmfoeyAdX1LTJFmUjObXSIhuHHzJlevXSeGwHq9omtbfMggbtLookhM9P2Qo5DKplDXtVw/ub7J3GvqvIdx69ZNalNxcHDA0dERQmZFc9cPkKDrO6x1NPUWWgx9f5tlYtd1DH2PD4H1ukVKsWM1WvYKSBugMKqdRkvAruvo+/7aww8//L89+eST++//ff2a1Pd93/d9/VNPPfWeP/fn/tw/v3z58n27GYC7sG+EYiPYGsHbrmpuF3jtArgR5N3p5+fz/M7fNgK2EbiN8HA8N423nVfhnVfnbXJOi83oCBZHOLj7GkopFovFxtbYGLOBkLswND5rfRBue8/G33kElF3XsV6v6fse730+B5V8w8lkwjAM17/3e7/3b7/5zW/ef///SnfMs9NmCe8TO1HtxaplNx+QXStQwTYqXuxE9FE2gJO8DfqNQy6Wze38nBGRdtV/kEqX6kYJKLJKizErYwSCGxvSMjHEKBuviMWrVCRBZXTeUE8ChEFJjZUJbSrqaU202V5HGstBP2EtB/q2AyGpKrA24XxAaUPnPFoqKiU4W3Q0WtFMK0AwaWpwnrOzZcZFUjBrLiK1wPnIctHiBkfdVNTNDKUVichi7VEBhEq0fcQA0TmSMXjrMAJe+uJ7GPqB5WKNQOI6S1KCqtcoI2BQGA1KVSATej7Hrnr63uFsh1IVgwsEJemHHmNqfNcjK8lhNcEOAwFNY2p8UNTNNBuXVTVBaoLrMRIGEk5ofJLlcwM7OLq+z+58qcoWpbVGyrz3EWTOAjMqQwDnI33r8THnIHa9ZzrRuNYSjCGmgHeOW7c61qsVXWfxsZy0YmDo+401grUuDxshEUpSGcWkqaiNYlLXVCpSGY2WWQ3mfO4wjgKEUGXDpVh+ovIxbyyUsgVoKkksSWZonQrt9iVXT4ypLrJkAkZysqXIj96oWYsNwqj4y36hGQAmIUiiQgkDKlvIkfKGaByViSl3T49JMLIoJuQGumdIno9Hk4pSKmcVRmRK+CiyaW9S23nNOWB3t2y/58oPO/+451IT3vaz/jnhx4erBJRKYcb5X0BvZWRuUI0RdIWREiUVplJUswlxyBtQqtJM+jngWPZPbpVbJ9vfveeEDy2P6R0c3zPFFOgYAwQ8Knii8kQLdaWRFPg3OGQsAdtaoZVBKEPb9VjvwTuUlGiTM7GU0kXUHFFCMrt0kWo2w7qyWbbssqq5rpGVQSRQEUTMquYgJT7mzDHbZ0DoY2BwBaoRCM5SNQofHSrk96iqJjiK8qCqqGcNZlIjRMznbSkRpiaSVUohZhvkts3de1WtEZsv/3JhQsq/o8hZYl3nsV1H17vsYa4VVS1REqzNXv/eBVKxMS3dHPjsBsoHH19ws3/y2cOjZDfO5w2NMUyqCZUCU2m0VCgJWPB3HXPPA9mOmy28K3Bv93HHdxjPx+eO8fjcD07uNu5H4HenuXhXwG7g2G2P6VnK256TDUg0+yufj6DOlu33vPcDTz30qk968bcfHkw+w+hsB0rM32shghQBhoipNIJEiIHBslGqCyUxjQEl6TrLqXPgPVoKtMkNLVLKvKFf8gHmF46oJhOcCwgBbtUz+Iioa6TRyJBlNCKFjXrQx0QoXfneB3yCIWSFnySgRE+FzI04Pm8imLohIvBJIKuGaprtQ4UcmxoUQhuiyCqFEAJ2cPRrCwJMpRBaFUhQFinFVhAhcEDfW4Z2oB8GBps3I6pGoqTAWY8dXLECdMSiChJSElL+nZ4+Of25Bx975q8Mzr1tPyL39WtZ165e/Z52vX74M3/zb/53ly9f/syslhtz/yL4MeMvIoIAETZNlEptbdtzTHW+7suKvXKtKcp/dzMD5a7DStpZU203A7bLs2LjGUK20ktsoOK4UTjCO2LM1qJCbDr8Y8ggcbQL3d0QECXbkx0lXyqQblx7hZDh3gbiJTb3GVUCI8SLJQswlMzj4EOxLvOb58/HFIrtZ1YKXLt28rO/9Etv//IbN278/H5E7uvXsn7hPY9899d80//zyN/8C6//t592/0tep4pNne8jwxCJyZOw+NCja0Mzm5II9MOAWyzo1pZm2qAOp6i65nSRwVzolhiZm4FcyN+VigTBY4zm0ktfQnN0CTs4Eonh5pquD8jpFKoaaRqUD0g35GZYJYlJEoVg6Ie85o6JTkqCVIjoUTHgpcAhGYYOpxRxeohG4YjI2QWmFw+ZHB6ghMvqQKmJqiJKlRWKMdGvB7qVR2mJaRTKVGV7RiOEwoeAG3w5N1S064HurGW9XjEMgWZSIZVCKInvHba32Vo8DIgwoCqBNjVSGWJK/ODPvOvn/sX3/ORXXrt19jP7EbmvX8t65plnvu8tb3nLBz77cz7n31+6ePGznMtr2Ol0ulH2jBBQSrmBWMMwMAwDzjnqqmIynSKl4uTkhLbN2ZyVqbCDRWvFZDrJlt5kpeCLX/ISqrph1bZIqbh165SU4OBgxmw6K9l6VW5AkGqjrnfOcXLjJouzJX3f4+xQjqsGIZgfzjfWm0Pf00xqpJS4suk+nU65cHSEUgrvHJWpqJssaIgxQQy0bcv169cJMWBMxaSZoHQGD0ortM0gcxcA3rhxg2EYuHV6yuH8kPnhnKpYFzrvMQU8jOVczly01nLr1q2fe9/73vfli8Xi5/Yjcl+/lvW2t73tjVevXv3gl33Zl337fffd97pdIDaqWM8DOMre4676b6wRio1zY1ftdx747UK6OwG8XRi4CxjPW2+ONru7FqW7DQwj2KyqaieK4PZMw6ZpNr/TaAk6WoiO+X+7SsTxNc8rIXcbA3RxNGvblsViUdTKfmP7OcK/xx577Gff8IY3fOVDDz301v2I/FUAgGPORJHX5Tybku0nkaPGaBsYsckOUxtDmu2g395n16pzAz1GQChEARw+2yCKYgGFLIb6qVgh5kVq7oTNt+eFriyudMUrR47WNAmlwA2WpDWV0qSYbUFVKpFdMUAKTCqDFApLQJVNtKMLc+qpYSEk/TAQUsQYzeAd3g45+wOBDQn0QKJG2pi7ZV1g3Q7MksCniJ5WGC0ZekeXLDJ4LlyYgdKEwTG0Ayc315yteyZGMdESqorpxJAgW3uue1ACm7KaqKoMSUl611Oj6a3DVBrTNOB6ohSkkLh57YzKKJz3KJPh3+ACaIE0UwQJ5wYmzUHOMfQ9qpmiD2r61cBgHUJE6oMJolb4xRpiwgVBqiQ2eKItQcXWM6wG+iSZzxWVkaw7y3RaY4QgkG1MCHmBE0vGXddnH/EhRZQThJTo1x2RRNf1DINFV5qwsrjoIEJHsU0i4VwomxTZfnQ+bZgaRYxwMG/yeyUDWgkCESJE78umisw5hKPF2dZgFkTRtMaNtrDcLDdIcJwustgjBmSRxqoNrJYijTLazXFm4FfGuAAhy0WOkIiigEpCEJO8TS2b58z4xREQQo1HQWQHNLL9NTZ/GNUpY1ajHFOaSDwPYHiu23eByXnYcKeMwJPnAIZ3py4vHAIqIASkBNdbkg5onRejIeazVYpF8RYDTV0hZZ7/pq6I3nLh4px61mNO76Vd9hnnHJ9kBdXJyciYuNk/iTs95iUXLqFUtqe0Np9fVABwOEAbTdeumVQVQuZDlEqRJHTDwHrd0666DK4nFdWkQWqDIubnSQ5VSaZySmgqurbDDZZ+uUDFGUIqlDZIpYjSIKUiEiDk+ZJiJEjwERwKK0Gi0DGgCLmxQSoIDilAVjUiZRheTxomBzOmBxO87bK6RxiMrvAR1m2HINK3Hd2iJRFIR/PcCEHesFdoosyqwL6zGXq0HbZzeG8zGJB5zhLBdn3+ecz5jJTZGQMslp6nFzdx/TafcXdk3NscMy1c6+DQUFcaAiXTMNPDGPxdGHNzO0jDPTeX3oz//twUaDaw7TaL29uA+PHzg0buMo92bUmf9TTuOY51B2DuZYC/ouoH+673PPzEF7/m/pd+1+WL889TQmwU495FpIgIkc9DyejcTFRXucWkdP4mKemtY7Vc0K17KpMbieqmRmiN1hKZAiLmhoHJfIqZGPq2w3WWYbVEx+m2+1griCbPXZmymjxmVVFAEITExoQTBkREp4ghK/acFyRfVEVVjUwZ3tXThmY+zfN/6LK6VyhMVeECpLZHpKxQaJdrYopML8zz5gKCmARR6GyHGj12sCQl6doB2w14V4ColDnzKybsYPHe5fzDmIqdfP7eWnfu9INPXf+3T167+ZX7Ubivj1WtVqtf/rm3vvULf/tnf/Ybj4+Pf5fWGiGzWkcVS01NzgBGQFDZbl1F8CFbWGkhSFEgVHFyKJeKxLLu2VnEp5ib1rTOGdlKqZ3rOlFyNfP6SEq2i/uU8vVAiqgCKEeQuLlmLHajeeGf1Xykbdcu7ALEYg8Ut/ZFYmdZuLX5zc8TY7H59J6RB27hX1YKxZjtPoPfdv9vFpIpbnMBY6Jbd2cPPfyB/+sd73jHV+9H4b4+VvXE1Zu/9Nf+6X/+4r/1F/7QG3776175+RKBMpKwjgw2ItKACytgSqor1rdu4qo6xzHIiGlyRviyG7h29YRbJwsaIzi8eEAzb3L2uxToGJHBIZTi8PiIZt7TLda0Zyv6mwvWYY7UGmVqktKgqrxXoyIpDsSgECnhlcIGQZcSa9GANFRxwKSeED2DE0g/oI1GNXNCynN0Mp9ycHHO5MIMv77F4B1OVuh6whAgrXu8s7SLNevTFUkI5i/KDXhIgY+CIPMxWefwbYcIiW7d0q/WuL4nBYWYKZRURJ+wbUvf5ZwxvM8OKtqQkDxzY7H49h/++X/1xp/8pf3839fHrJbL5bt/8id+4os+93M/941Xrlz5XX3fb1QswzCgVFbCjNBr1+7OGEPdTKiqiq7reOLxx/nQ08/QzCZcODrCecfR0RGmqjaPnUynvOxlL2M+n3Pt5ITrN2/w2JNPEsq1gJkf0DQTYszZuIlE3/VbC9IYS+RGIAeX5IYlpSTOebquJRYbzqo2Gzvwyxcvc3h0yIte9CKGYaBd57y/yXRKjJHFMit/bt64yaOPPsats1u8+tWvKXAzW/nlTLHJBo6MCsjVakXbtpydnjKdTEgxIlUGFWPe3+gMMEKAvu8XDz/88P/1wAMP/LX9KNzXx+z7/4knfvnv//2//4Vf8RVf8T2vec1rftcuIBvh1gj2dkHfCLx27T93G+zuVOdvu5vS77wScASD54Hi7vOcf+3dLMHd89butf8GGu3YjU7L+WDXivS8HeloRzw+364CcFcVuF6vOT09pW1bUkobu8+qqogxLn7sx37sX73hDW/Yf///6gJANQ7TvJIrtoekSOLZAyUldgbTOAiLbeKGQ2S7mC2wi4xKQ7EDBNMIHYVEyAw7khRZ3RRH9DiujtnmmbEFjFJk2wolJYlALHlwoy2ki2zzBMlWNhqBl/k1lZZEn7M5Jk0FyRFnNVJL2rZFmawMG7wnpUAKOctK+0BU2QKv0pLVco1SOdvGhcRUCNrWk8JAM6uYH81YD45utWK97FFTBS7RL5ZMX3QRMWtw3UBvwXmoJaAV695ByIHAzlqSUkQXMEIweIv12RJ1CB4RHNWsZmpy3k4SihQD1nqs9wQPAsV8YkgxkmJi2TuE9xypnmtXbb6YGBzKRJKUqD7ggmDwnsE6ppOGJASLxbpApIhPiWAHfFBUkynKR7q1Rc4rRFJU2nCrW6PaLnf81ZpKR4aQg9SHmPLzdz1JaDqbT5LWZeVSJCs5/WBxLpVuwlDsMRNGamZVlbMOh5ABXEigspJCI/DBYd3WEgkSccxEKQrYmCCl/H5Kse3C3gXkjPNB5A2OzVyQcqM6EyJv5IyzZnTWzfAuY0WBJImQoWIqitYiq93kvmyEsMUSEiAV+DfKzHfmx5jTkkaiXh6VUAS2ir+0i/5uUxv1OzaC3FkVeHI3MHEXGMgdoOLJr94J7BgwTcY2ETYWl1EXS8kYIUpUyeGRIafIBZnntTZgc0Qg02kFeJgUkrTsyTlsO7SpBLI54GlaXnJhmtV/gPWOIrxEBRicz8cSLXVTEQhEa0FWOUT7bInrPPKoIUqFDdkyBydRxCzFy6fibMcVijVmlTPtOmupZMkq9T0xBqpKUcUMvIWUhBgKLA/ImAGgkYoKwAf62GUbZK0Iy3Uedz5Q1aZEvEr6zrM4XWLqGdUsd//0ncVZhx08tigMFQqTjWazolfkzU8fwFlHkgpvHcFbXLEAkzGDk+Ad1luSC+OvXX5Hz1M32kJfoD+58xiYmobGQF84mMzDAClVRnou4OwdxvGzGLO7+2DbnQ/HdwKH5fHHzZ2B+Hmr0TvZ6J7cBaBvnqPZQ7yPccWYrr/vA099/qte8ZLvv3Lp6PUUWO1jRBU7dRESg80WgDEM1E1FjIEwWFAG5wLtYo3vLXI+JQmBDQESDK7AhOTL144ghfx9nQQklc/nnbNUMrdrBedIMVAZhSnW51KMNuaeGMaUWkGlJFoKCJEhWDwRoxUhrfN1UswKRllyvvresThdoScTqukEmSLrtcUN+ZrAxYSPEY1EAyrBurPUZTPTh4i1gSiyut97jx/zv8r8j8HjrCW4UL7XsiJqsCFevbn86Q88ce1r22H4qf3o29fHurz3N9/6lrd83m/+rb/1/3fvvff+v1OKSJWz/vDZPlPKsvAv41mNGwIKohAIJcsmV24IUqPqrWSQ5+u7uMlsHqEeBeSNarzNekxQlHfbRsv8/DtrN4pCMe2u49Kmd2xUJpK2dj3bDJOYv6/LNXMqTW1CjLm+2+vLbOeVNo4ywefz2GjlGQvcCzu2nta5AhVlsW7Ptw+9C9euXf+5d77zHV9zcnLjp/ejb18f61q1/bWv+abv+oL/9S/8oe//vN/2aa9PIaI0hMEjk0RKQ0xgnSAtB5T2TGYN3vesVy1D1Kxbz8nTJ/RnLeqei3gBQ8hr6ZgSJnqSt3ifSPjsiOE8SQqoaxyJ1vbZIjuBsz0xeGZKUpMwAqwUdDE3EzvrcxwKgkZJplKSrKdzgSgTTWUI4lbOKHWWyazCqLx4Xa8dN66eomZHNEeH+JRoTzu6dZ8ziAMMKW/mTaRCJcFi7Yi1Q1caFxNDZxERXJfBITGhVFEch8TQt/TrFbYbICWU0TkapPfxp9/x0Fv/zQ+85Wsfv3rjzfvRt6+PdTnnbv7ET/zE5/2O3/E7vv9lL3vZ6/u+36hfrF1vcnSdc9leXwiU0kDCOUsInvVqzeliwWq94uDwAK0V1g4sFmeE4KmqujyHxYdITFDXFfPZFDs4gnf0XYuSAqSg7zu889lG17mS4QvEiBbQGEXQEq0UB/MD5vM5pMR6vSYEj1KK9XqF9wEpJNPplIPZAcYYbt26yTPXrjKbHjA/PMR7z2K5oF23rNYr2nZN23W5kSkmnHcZRhYwqrWm7wf6vqPrus01xcHBAVVVbTJ+dy0KR9VfXdfx6aef/un3vOc9f+fWrVs/uR99+/qYf/+vVidf93Vf93lf9VVf9QOf+Zmf+QfPq/VGYDZC7F213ZhjeV7dtwvhzkPAUZU3Xo/vwr87KQDvZBt6HiJCtvAcj2tXhTi+7m4j4Hjsu689qv5G4Dg+fgR/u88dY9xAwN3nH9+nYRhYLBas13kPcjqdjufU+Nhjj731u7/7u//W+9///v38/9UGgGljySl3Fop54yaNi8JiY0Mau0TzhxiLAE+U/JZtyU12xCaiT8RMQgoQzAqPgJBZEZWKj+LYmYqIO7NAbLIFx+EcSr6E3Ax2lZUwRCqlMVphlMwHKRlDKzK0UQobQ4aBOsOfbt0SdUKpiukUlJHZJkeCdx7jNP3g8+JURPrWEnykriuc0kilcNYTwkA1mxBSUfEFBwJuRkGKjqEfkLXhwqUDzq4tmc1mKG1oO4vvHUJKrPX0MWCqivbmGbKuQQpCSCgRqaZTtBT07YCoNLVR+AjCCJyNTHSd7Yeio3MBokcjMEoRbEdvA5qcUWKdQ2vDygusHdBSIonoSUMYBlZDyDlEbQ8hcuEeg3OeZeeIZZPRWk9Qmg5NFSJ2bUky0t5wTGdV7oaWCisSs6bG+UDCoJQjDgNdn7OBQNCuWzobkUTOlm22PRQCL8CGQBwtY5EIAfNpthzQRtPU+bNUtUIqSa01WoAk4p3a+NGWbY8ydnUe33HrUytS2Wgt4sCNElakDeCLhQfK6JFC5w0VWTZhRjvbzVm3vK5QI6Ir80VtsjC382WnU6OAylFhsiXfifH/tzo+sbEHzcLGYl86qnJHfjlCTFGSBG+DH82dod3xObD3QgDes+wKz8OOO1kxNtzdFvR5Smmkyhmhxigqrah0tsJEQiyAViERGlwMRB/QBRR2bSAGMErDdILSW5tE445xxQJ0/N37k5Lw5nquXJoTSntd8OTNAEDabLsXY8jd+DEUm4+ANhW6qdFNTVXnOeKsLSrRDOpiDMQCwQlZQaArja6nSKPyz/suq+h8wAUwTUWSJiPfYcANlugDkZBzvlRAohBKIaVi8AFXIHUVAW+L4NUQnOf09IxbN27SnrbML1VZ6ZRg3Q6s1j1KqgyYq4qgJElI7GDp2oHBeUxVEVLEJ/DDgHVb+BfJGYEydsQhKxIl+S3wwIdOFty8mceDabZo7jbl3/ExpgFtDJMmAzhT5fNxoxVKgQz5dywi23NDuDkH9Z4Dxh2fmwPHOQPwhOa5weHm8c0dxvsdaOZz/eyFwr+TO8zjuwHGfX1E9dCjT/9h58N/fPHxhT8RYxTZui5u7Pd8CKQh53yKMv+9dWgTUVphaoOpDXpSExB460jRbq37ijXeZkPcZ7cC01TISuNjIA19Pt3HhPMJU9ckoVEpEb3DDRbvsouCSimrhMj211KIbCVMIkqostceojTVhOA5PV1w68YZ69OWQ1UBiZAEq87SLrucN4YkGIVXOX/Wupx1WPuALjkjPmbFoR1cbkgoVqWpdEwGm3NGC2AlxMSNs/bBDz51/RtPThd7r/99fdzV23/xF19Piv/hZffe+6d07gbb2FhlJaAmiIBKsthzZWVshnNxY5tZfCPKBpgocE5uAJoYF1tlM0EASqjtdSO7a63xftvrxTF/cOP2slmljc1lW3C3WWWV3PcR7m3ukxIp5I59RN7wGx8XS0NaKnESMZQ/ZSGZFX/lXBZDzjENuTl0tNYfQad3npOTkwceevgD/+fDDz38/92Ptn19vNXX/+sf+MOLVfcfv/h3fPqfSCCUFgQfUapGSoH3kRA9QnqS0LRd4OTaKn/na8Ns3tAcTGiO5kQj6XqLt3mPYQBC8AxtT3B5HvXdQDVtaA5nKKOwwUK7zHPPR3ovqKcThJxQAa3v6Jar7EwQIzUJLRKGiCw23TYmhghBQ2MdorcYmUAZrOtYXrNcffKEs2dWXLp3CiIREJyuLWc3WkylQVfYSmGrioikHxztck3nA4cXDgkxZ9F757M7U4rZxUYIwGO7FaGz2MEiAWUUPibe/YEPPfjv/8vPftNbfvmhb9mPtn19vNVb3/rWP/zbfttv+0/33nvvfz8Mg5hMJkwmk80m9jD0KKVomgalBMNg6fueyWRC3dQcX77MdDplNpuilaJrO27evLWx0ZNC0A1DaXiHwQ4oKbl04QKH8wNC8HR9h5A5Iy+GgCnqmzFTzweHUHkNIkNESKhNRV3VKKU29qSTyQQpFWJn39Vay4c+9CE++MgHuXbtKve/4pXIAhUWiwXXr13fuAccHRwymebfI/hsDdq2LbPZAUIIvHes12uWy+UI9sr7ojbKvxEAjpCkbduH3v/+9//zxx57bD//9/VxV9/wDd/wh/7yX/7L3/k5n/M5f1IpJXYVfrtwaxfmjT/bFVaNzXa7QG9XgbcLAcW5nPDz4PH8a+0ezy6cHB9z/rZdq87d3L7x7+PvOALEuq5v+/eunejufXch5u7z5/PkwHq9pm3bzbmhrmtOTk7e/+Y3v/lbf/RHf/Sb96PtowQAQW7hgBhlqYEY5cgaMjQogGMLNNhBhlttkbjNMma8dZRAjXlmcRtMXxalUoyezyGrEHM7yVYpVRbOkazQEmNWoNgCHSkUUkh8iEgfGNGmSBBEIqSUjUuNQpMY2kA1UQgTEQqMynZe0kyg7emMQytJm0rwvc9B36F05MQh/1cqT9M0BJWzKpQvEleZsAubF7eNxg0ebz3HLzpE6QqhFZXWJO/wvaN3CV0ZbNcjZd6c80Kg4wAobAioGDDNhCEGeus4qAzeFVWbSwwiZ27JEIjOk93ANElFJFAZGIIl6YaZ0bTWEkkEm5gojQdcTOhRpWAdw7JDqMTB4ZS2G5Deo4zm7NaaighK4IxEdo5YCTrrcpeS1PQ2YBrNuss5Zz7kHDBiIknJqrUkD1WjSUi8j3R9VywN8qaJDYE4eAYXs+2RHE+UgnsuHdJaz9GspjGS6BJ4MEbSaEWKWX3go2VUpqbijylGG1uRCvDOYCyleNt4v22TpHRl79opUWAiOydSCkAURYyXGDshNgwQQc5REIIdq1E2uTFpVIFtDiQfa7bFldtZl9LmwmxUiUhZ5keMuxwdUpkTt+H0c4DhvGXnyV2AxAl3f/z520+eB/7twpGTXRD4PMSxHEskq72EUngHSgbC5i3NHfnjGQGjUYBvA6ZRiCogFUgFSipqo1iRodLWir6n7/OxbNjKyQnL42OWH1py35V55kt6tAJ1RFV4noVIl7twA+gLFXVToaRi8DarXLsMJMmGstnLH7D9kDMMg8cFmAK6rohaEWwgOTA1oLMy2FnocGhyPoGPAV1X5dQa8L7FRQ+hxmgFMqvj8KAkaF2RCFjAW8e6HXBRYQ7mKGPyOUVKvMxQuu86ooIUK7QFHSypH1gue1oXmU5zIGMiW7HG8qfEGZY8wpIxVj7Hm6c9Ty9aXN9vR0t/slH/He989vdcmTN4x4VZtv0Mua+Eqs5djymGrFDcsf/chX+b0XUMz7L/PH4OsAbncvXuct+7QcXNf3fA+PHzPMezFIjn72PgxG2Vjc81N/f1q1KPPnntS53zN198fOEvKqW0KPZ3QoCMEVdUOV2fbatTTMyrnKWhpGJwOR/H2jz/RcrNL1LJDNPKhlkodniNFOi6IildsnIilTEIJQjOY11CCY/G4+yQA7rrbCmUQiD6AesjSVZUSJAR6wJJZBVDBnYxz//B0nUDLkrM/ABVqWzVJ0SGfgjcMOQ8IF1hbMRES+xdnv82Mj0AkSIRsc3+IuciI0CmSHQ7ICAlztb9M088c/PbH3365K/vR9i+Pq4h4C+9/c9Y607vf+Ur/6JSSnvvUVJlE/CU3RfGzD4xulGIsLk+UwLyHsG4UC4NXylu8gAF2aKXctUqBJvcvtGyS4liC1SuHTNszPEEueEsnbMBysBuqzQsDZ/lehQghqLELdfDGzgpxU7OX/Fp2RwPxJBtO0PJHI0hZAvhkOFe2Nh+ls7ocu2bbYEiy+Xq6gc/8Mi3v/Od79zb/ezr47q++Q0/9qU3z1Ynf+T3/tb/sTLGOJFI0UKUJO9wSYL0DG7gbDGwbi33HBxw4eIR2lSs2gHrLf3SE2xEJo+ROcvLJ0nXOqx32BAYestRpamVwhuDsz3SByqjUVWNt4Guh5V2NAx0JUdH1xOMlERviXZF5zw+GaZNjkgZQiI5ga4EdVMTJThTEQbHcrWiD4bmyj00s4boLDYqBiQDCbteE7XEhhlVH2ljT1p2XL26YOElVjVUIiCUyc3QCECX9VpCBIdbOVKUSCFRleSxq7eufc+b3v5t3/lff/Zr9iNsXx/P9ba3ve1Pdl33z++///7/T9d1ejaboXW2AW3bFudctrBLCR+yDaBUiknTkGLCmGVxyQj4EOi6jsVySWUMxlSs1yuklJiqIpXczulkgpAS7xzaJEzJDVwv1/iQ7Ta9dzhnMUYyn18q2YQ9bdtu9ozyflyg7TpIiUnT0NQN/dBjnaW/ZTk7O4MkuOfyFaaT6UY9pEv0yHK5xPvAdDqBkuHbD12GoOU6RQpJ3/d4HzaZY6PFXwaPOSdRaz2qga4/9thj/+69733v/vt/Xx/X9S3f8i1/um3bW7/n9/yev2CMMaN97a5S73ztZurtQrZd9d4I8M9bd272e3csRsd1wHOpB3fvdycl4e7rj7UL/84/fletOP5sPKbz6r5d2DjePlqijjmCY27qbDaj7/vrb3rTm/79G97whr3d70cfABYeMQY6pLQFfQAi5myZUfiX0hZUlHVr2uSTxXwht/P4cRE7Asac51c6RYVApoQkIpIjCQVJIMgqL1mOSwqVF6k7nbH5foVYqwwVSaCV3OgZA3ljWQuFVhIXShZcCFS6QjaOEEEaxfxgytB7XEzMJ4bBG+YHNUkITK1ZLsugjdniIsaw6cpPMZCMQcS8yZ1CtsC5ebIEAReVwK0dp6cLTGVYrzzerREq22tpFC5kBZCQEwICU2mCg84ndAIpHLZ1TGYTKqNZW0uS4GxASYlQicElYgpYnYjRE0RC1hUMEV2BHXqkrIkhElKisxYjFe16jVIaNWmoYyJVFRHFuutzvodRHF6c0UwMi+tL0AZTGUyjWJ92GAVDb3HKYMQU7xyrzlLPDV2Em9eX+H7gnisXCF5gvSeFwIDAt9lGJGJIPrHuB4JzCG3QRtO2PS5GZMmBTDHl3MPaoFFUtaaZVFw8muFT5KJRGGUwxVM8kBAyg2ElFVkGtLXUjGXcF3NFRJbG7XRKl3+PdkvkMRgReRynSCrQWpLtO1OCWNCgZKvei0kgZCrKyWyfKoQoNp3Fmmm09Bw7J0bQV44rbybJogQUWUEoClVMOUNQbKxBC/Db/D4ii3ATO6ra5wAUPA8A+XCgx3PBvwJTck7ZC1cBHpf/N4YsvYs1WirUDi+NMc8PJSVFYEIMkVppZJNhlKwM84MJ/WBxEeaTCuMC85kBpalqw+IUmr6nP4bREfSkQECO4XQB82nDpJkCLueNWodSeYNPBc/YDBSLzWWIWXXoB8tgc5agKUNUkrP7BguWDjBUClAa7wI+WOJgqYxCxAK6+txBS1QYnUe0NjkjLGOIQPS6GBbm8eqGQN8PxCqrpoWsSKbONNQ5JIpmYtCVodY5289bTyBnmQw+YNse1JDHe6UI1tINoHQgDAO6AOtYzo8u5EYJCcSdWL6+83zoxoLO9RiTodiyz292f+6Db5pjDFDVhsnUcGk+wwOm0lRaYYrCcVQfS/wG+j07u28s9/xjexfUnTR3Ubc+76C9c5bmc82zE+6esXm8c/wvVMW4r1+1eurqzS+zzl+998WXv6KpqsMMuyOUTlZrE8LHciGdF/upKF1STDg7YJ1HyOxakJtRJDEU69rgSQJ0ueDO1yGRYC21NgSVCNFj+6F8TyqMjAQBsqpyjk7KzStBZLWREDl11g2evrPEOlFrhTCaZCqCUATnIck8/43OgD1kNV9AEJWk7/JGQxR9blwwguACnY0oHQn9dv6nWPJIfVYCSQHRbxXz3eDWH7p+9v0PPvbM3/AhPL4fWfv6RKj3vPvdX9Z17ROvevVrvqau68MkExqFF1ldK4UA60rvY+mW1SWXzxiESIQwxhvkXOqUtnEHMaV8iZcSQspN+1ragD22Kj/yPB8tOT1h83NI2zzAspgfDV2kZGdTQGwa3Tb2oOU4Nnl/O9erQggiYpPtF2K29BKIrP4PY+ZfZBgcsVh+xZSvxYTM1wND79pHH33sje94xzv+Zt/3+/m/r0+I+g8/9LN/5dqt5dN/5kt+x1dfPDo8tE7iXFvcXRQulAiKoSeRCCmDcaWyU8D61hnLdY/UNdNGo0R2NAoe2iHQOgsyoWuNkgJnLdY73KqjkSqr8IeebtWiiKyFImiHFwnd1GCqvPbD41zCCgFaE6XEtZH1aiBMPAeVQDUNYjrH6RqsRUTF7LBiMq2ZVhLnA84mnNAEpWgXKwbbEVVNReB0ImHwrHqPcwHd98yEZ9LMy3aTIpRYCxkhDYEgBErCuu/bH3zLe77vX3zPT/61Vdt/aD+y9vUJ8f3/nvf81WEYrn3yJ3/yV61Wq6PpdMrh4SFVVRUY5zcZt0pKYghZsVe+b/uux1qHENBMJ0xymw9DNzCsekJ0TOcHNJMJWit8CKzWa5xzmCarjUNItF2Gbj7kPQ+tNRcuXKZuaoiJuuowRlNXVWk+z832XdditMbnixCkUiQEw9AjhODo6IjZbMrBbJYfFwK6qH+WyyUhRobBcnp6Stdl6CmVojIGZx3DMAA5/9wYs8n1G+GftXZU/q2ffPLJN7773e/+mmEYntqPrH19ItS3fdu3fdnNmzeffP3rX/81VVXNR6XcCPjO13id7UtO52iduQsAd21Cx+eJMW4UsyN8G6/ld7P/xn+PAPFO9qR3AoHn7zPW7uvvwr7dmIDdrNNdUOh93nfTRUkxWiOPit8RAJbjb3/pl37pe7/ru77ra27evLmf/78WAHC0hRkBYP7wikZIlFy+HCjFhvONjIINhyg/l5vcstHycwMidqBhFAKiKI9NJeSKbFuJImux4tamcONdyFYqNS5qJQipCusoykMpN+pAKQswjAlViKVMAu89QsLgHNIblNJIE9EuEqWkbiq0lCSh8OQNezc4hmDRUuau97FrHUE/DBlA6vx+td2A1JpIYrnoaSqHSgIlEtF5OhdLaKaiX3dEP6DqScl/CzinWS/WpK6jE1BPDAcXLzA7nECK2HVeTAxujZ5MICac91RFxYepUC4wbTSLMND5iBKSdb/GVA11U7M6a4GQwYSMuVsHQUKxWPdolz1/o48ED/1ZTyThbWDVdfRLS5eg6xw2Ci4fKvrWMnQ9KImLHt9Z2tUaaWqUUXS2x3UDZ53DhwIEUmRYWWLwdJ1FIvE2dwN7H0kp4jJyo641B9OauplgBEwnhkuHhyBz5poUBqOy2oCYUDGPikEqksgbqSkHHSFCIohs6TlCtgwEZXkf0u1auY1L6I5qL0lIIW/aiLTJ6BOUXMsydMW4gQLFULTgcaHKyXaT0JJHsiz/LjBwhPRjzqZgm7GSDz3tsvm8UVPmZizHLilOUjJuNl1vVyPdAXS8EMXQ3WwGP1y10Un/ERDHZ0OUJFVuYih2d8h8flEyfxnLKHFEpITOW6SvkFohnUISiDL77RulCMW6LwRwrqd/8s5vzbKHZd9zqYGLlwwb4X9woCAEAwFUpRlcgHWHvK1hx2c2rTRIhUcxWEu3XhCAg8MJs/mUpq7oO8vQWqIt4EnanH+oPBFV/lSgQRXoFgE7BLzNNqJSgR8C/WLNEBxazQk+YLFQrMmEjyQfiDqgtCRJTWc91oZs82cDa+tpO0ejHE1d5+7gzmID6KjABbwPICuIAddlRZ4MY1qRJwJXTxcED53LY8C5Htdv3+TNkDyGS80xejqnBuYTzcUL8zz/bcge5OUzIwZEDGhgUBqUv33Mjuq7434L9I5fwDjn3PzYHNw5EPh8MO655tjxC4SBd51L3K4E3IO/j2pdv7n4urYb3nb/vVe++WA6uT8lkTOvxjytmDf7tJJYG1ith7zpXrJfU0ogE0Lm3fiAxDrHetURiBwcHnAwm1HXVbbt6Qai88gahMpZf6k0WMUkiDJbGGs1Km9Ttup2AV2ZDAeso1t22arXSHzwuYFEaoL1COfzPAoxb1YiGKzDuqwaHFygtZF2bam0ZlJbbNL03cAQEiYohAs4H5FSk2LK5yAfStNNGjEG128u3/rg49f+3tmq/eH9aNrXJ1p98AMf/EfL5ep9r3vd6/7JwXz+Su/L4ryqiMlSVxXOiXINmEhJY4zeLJy1yZt4OedcFrXdFvCNf4iJSAaBxLJ4VyrnZkkKFMzkLhULTym3ykHvC7BLsdwnO2qEeM4KNOU1324H8aj6Syltz2vnrH7CBgJmhZ9z2eLXF9VfTAnv82s757P6oQ9cu3byC+94+9v/1rXr1390P5r29YlWP/qz7/kHT1279b6/+Md+zzd8yn0vuV9IQW/XED0pCpyTkDRawdBHlsuOJBJKa4yZIESPqHPTDFIwRMly3XPz6g2s8Fy65xLHly8xm01p25b1co1b9cjGICvwKZJUbh6IGJxskA0YlxtubAgM6x5vHWbSoLXB9Y71jTNW7UCl54RQ4aPJa8d2QA+5GTdqSawVQU4YOs+6d3Q2sraRW23k7HTFQeW5dNBiRU23bFm7gBJzBrtCo5DCIWPE25DPQQmUKk29xPT2B574xW/+Tz/xN979gad+fD+a9vWJVg8//PDXL5fL9772ta/9BiHE/aPFpdY6K1z6Hu8clanydbB1WDvgnMM7TwzZLn82nWaRQ+64IQRPTIn54SH33HMPB7MDFosFy9WSEALWWqqqKvl/OT9XCEFVVTSyyW5pUuaGw9gSfYQ6Zwu2XctiscB5j9KaECPJWoQQdH2H854YE8NgqasaENmur21ZLBcM/YB3YWPd671DaclgB+qqRk8meO/pug5TnEVGm8Dx36NC6ObNm29973vf+3ev77//9/UJWN///d//D5966qn3femXfuk/vnLlyqeMVrbnId0I5kb1m/d+24y3kwW4a8+pVHbeGefOaPE7qgfHjL1xfu0+/jwA3IVzu9f7dwJ543/HP+Nx72b7nQeKmziAnbm9a/u5C//GtYNSKj3++OM//73f+71f++53v3s//38tAWCGBsXyUMiNqk/IlNeAUEBDJAlV1ErFclKMqqnxQVnzlKlYBmEiyQI2ZA6zLn9HCERyGzg4MkKxa9wnsk99hpMqg5eSk1H4Tl7gkm1pQoj4CJXKtp/EhJai5E0ldDk8tM5d7ymgkMSQrT5nkwZrPK73yKqCShH6LI83lclSfK2omooUIut2KDY2uStGigz0QsjWpThLDGAbkZVhEUySqCrRtgEhIpXRJKUgVYTgOTtdEq3D4gnW5glSaybThqoxCAnrpSUUuzAnQCaHUg0IiVIC7/Jr2d5DZbCBbMUpEs4lfHJUVYPWsDxzmIlBCo3rLUtd4/sVEKlN3qyUQrA+W6MrBVGwODslSokNIauRHNRTjZlWOJ8IKdKtB3QIdKuOpUtcmc3p2nwx0K4tvU/UlaLzCRtTtgSKMQPGsGMPJCIpJqSSzKYNk0ozmVTM51OIgekk5yMKBDKCKuRLjeBOlv8WyJzSOLYgyDwgSgJL0QXmHLM4Arqd8bmVBWYCnq2LcpcnKduTbndqxu7peBv8Tmmbyyc2tk3js2bkKEc4N0r4ClWXxYoWIbZMfFTFbgx5s8okbSxJd8BYvmWT9yngznadzwITz6NwOin3Ge0QT+7G7fodYPdCs/6eTUh2ucvINaTKHWw+Ql3AV4xk65sYKZ9SbnU3kq7zpJjz8KK3GK2YzSY4b7FDQJoKVCC0HRGoqtzB0hyDaY7z4Z8UO9ATOC7H2B4f427mXEAY7UAhkNWABPAl6k+qnFEXlEKqbIvjAmAHYoCu7WjbnnraoCtNVVcIbQBbMlQhhh4fZxl2mjpbh0pFGiGYzEfhB1iv1oBDVnN8gDjYrHmrJshinepzGiHBWqTLGYQoCDZv4FnnGHqLd2AJWaHYO6YXD6knE4QE21mG0EOX1dUuADHb+sawtfoEz7rzXD1tN5+tK8Ok3xmU4+fc3HvM1EAzmXM0n0DwTKd1UfiBiqEoIAv4JVu6hhDGt2Gj8TsGTm5T4X2E2ZPH5fEnLxAg3g0CvtApcFf7zxf4WuydQD9ate6GH3zfB5567yvuvfKv77l0+AWUb5XxglkqSSTmDMwwIJVEaVUaFvL5xcUEzuGDpW8HbN9RTSZUxlDVFUprGGy5gI454yOo3LlbGYTK8z+iSKJYkRBxIbBuu/ydaTQxgnUOnyKyrpEyW4ln42RLGBzCe4IP2eLbeUJIZf4POJ9wEXqbswcns5pqOkFKcOsO5x1ikMhQ8gyi29gBjt1mAlj1w7VHP3TjWx97+uR/24+gfX0i1/Vr177vrW/9mXd+5md91r998Ytf/HvG+aK1Zhhytmc6Z7yeoxYEQoQShSA3Gde71p2yrGNSAW+7ie0Z2OV86tvtgUrWRhgtQVN5/I4lUByb32LJHswqxWxDtM3vGBfy2wW9vM3CM5X7hJAX/jGMmwaxKCDGbt+wcYRJwNnp8pmHHnz4X7znPe/+uv0I2tcncr33gx/63r/zrW98+//033/+//25n/Xq3yubOZ1tUc5hpCNVgiRyLMWtGyuE0shaI6qaqpkRVWRIkDpL1665deOM5eIG84uXOGgaZtOGqq7o2nXu6iHgY8QGQ9QV1UGN1hqhK6KUpOAQ0pFEwPrArcUpMiUuzeYIoeltT58CYjZFqRrbJ7wKIFv8ukcPQ96g1NluMPhEbwe6VUfnoPORbhAMTnF85SIHx5cwBm6enjH4nrBeIuqIE5pkIyolRPQoITEm71Vcv3V27T/96C9+63f+8M/vv//39QldV69e/d7T09Nf+C2/5bd8x+XLlz8vb97nTL66qjb7lDElRFkH37ZhD0QfsC6vla3tUZVi2sw4PDri4sVLTKZTrHO0XYu1lvVyiVa56byqKqq6pq4aqqraQIdEdhdbLBacnZ0RAVOZrPAjcXzpEpNJgx0GfNnHXC4WCKnoy8/6vifGgHOWs8WCrm2RQuHtwPL0jNlLX8x0MmE6mxJDxHu3UT8OQwadxhiqqtpcQ8QY6fv+mUceeeRfPvDAA/v5v69P6PrFX/zFNz766KO/+Jf+0l/6d5/6qZ/6+eO8HqHZeM2dr5O36rwY40YJuFsjIBvB4aj8GwH6buberupvVwU41nl7z/Ovswvwzqv9RvC3q2ocVc27P9sFguN9dp9zdy0xAsGu666++c1v/tY3vvGN++v/j0HpUc032iKOORKpKKcQcZOjNWrsRoXfRhEoxoVhhn7FCRaRMkCJIpFEzGomRFEHjkrDuLUsHJ8ryQJPshVWDo3OoGQbLJ/QQiCSRklNZTRSiREvFsXT2HErsi2plHiZX0MT6V0kinKbyh70tdG4zuG8w2hFFwMxJRSRg4OaujGEkAjOo5UDAimBDxE0WBc2C/fgPFVdE1KkHSLBJ5pZTWcTruvxNuCavGHnbEApsFIQPHjXkXzAxfzF7gOIPmf69EPImT824IvUSNcGFyJGSZLMXluRxNBbZHI0OtGtB6SRGG2w1uJ8RE0UuqmwfWBSwdB3OGsxSrByEL1HG4lbBg4uzWjXHetFy+TCHG00ZzdWSKOYKEWIhfKLhBscfe9ZWg8ukdxAbyEisCkSYmDVOzrnsM4TfSSRc5LyhmHC+QAiYYxmdjDlnksHECN1U3M0n5J8YF5X+KISrSuDLONXRQHkLBJfsviCLIhNSGIe+jswAhCybM+kAuHSVs23a885nsCEKFZIOeSclEHvVn2XkIntho4otxcatz1pyqIeLIqIHevoDbQrUtsk4o46t8zVYkc6ZnZuusA3IBG2wYWjijCxa3T6LMj3YRGC/g6PuYMa6uSFwJbnl0mdPOskZjCVRqoMgmQ5XamdL5w8/zVBjI8JDGNOqATI0vq6qrBdh3cWbVRWqeJRwPxwjp82+JFSFTvQ3aPuy01P3Vxyz+EcVTIBKQAqKAcB7I4lqFI623sGcHiC9XR9i3c9GFDNFFSF9wEf858YsrWo6xx1GFCTbH8ageAtbsgwbwRhMYasLiw2PETwCtREU5uaGGEYLHhABrwbwGZ1nlS6qAwDbrB5viqdj2HosnCxKsrjmN/TkT3GELCDJ46Zf0rnbsHgubbs8J3Due14yLF/J+P/8qd/DPPmmCv3XILgaCYTjuZTYgjMmypDyzgusgKgMgAmEGKGwgBRbYfTyZ2A9gtRyZ3c5b4frlr2ueDdcz3uhcLD8yrc449wau/rw6oQ46MfePyZL1q3/T+598WX/yel5CSOPR4xkjv0Ez6KPCdk3iTQUkFM2JSI3tF1uVtfKI0y2YrYhZxB7IMjpISPidBbUpLIqs4q3RgJzmGdxceIGi/KfcyqoWKDHVP+3lNNha6qfE0z+LwxIR1hcETviQJUkFkNRJvtSq0jSUNIEG2PSBGtFTElXCj2oCnbU8eQsu2fz9+vWmYbbO+De+bk7IcffOyZrxycf3g/cvb166G6tnv0Z3/mrb/301/36f/8k15x//8AaZpizBEBzhKCgnrnAUKjtc6W2FISRdwqgssGYYZsElGaxTKYG5u7SoafyJA+q/LCxi50LOd96U3LVtwZ9BW7nrBVGqZis59SKLnqstgHp9u6hyVbu58YIgmBL529IcSc+1cy072PWOvLhgBjDqB/4vEn/ssv/dLbv2q9Xn9gP3L29euhFuvu0X/8737oC/+7J6//sz/6e3/LXzicz6YdAySLxOKTxydLbxPLpSMQMVWFlgbZS4YYGLqe01tnrBYLVD1hcjCHyQF9jNh2RW8HhhiwIRDWgUSFntUoo3NesOvph0jnHCJltb10AaEUShtSUqSU18PV0ZSpqSFA22cbf2EDoRsIXUtQEhMUqjMg13T9mm7dE8yEGBK+PaPC00wqlBb4lONQpPdMFJgE/XqFTIZKG2aNpqoEIXj3pl948Ie/6Q1v+srrt5b77/99/bqoYRiefOtb3/r5r33ta//Z/fff/xeNYbJp5Ckb+Llxb5t/JRBUpiJrBizLxRmrdZe/a2OilnmTfyiZ3tlSM9dytcL7wGQ6RQiBHSytarE236euaqSSOO+RSnFwOEcZnRuFEUxncw7nR3k/br3CWUeMkXbVEhP4GJFKsFwK+r5lvV7TtR1N03BwcJCdA2SkqgwIgfdh8zvGolB0zlJV9ca2sMAO//TTT//gu9/97q9q23Y///f166Ju3LjxxD/4B//gC/7sn/2z/+wLvuAL/seqqppdC+DzCrldG81RMTjuL48QbbT9HKFeXi94tNYbCLh7++7fz6sA71S7jX3nAeCu+m9U743KxfHP+azDXWeQXbiplEJrPYJK9653veuHv/M7v/Mrr169up//H6PSQuTFJWnj+rKxj4ER+e0Mns3P5VYByCitu+2eG4tCsQmTUEXhxwaobFRRKZHkCDMAWULpU7ZBTCUDbWtpmK1rkCKDFqEwRiN0OQgpQUKMAq3yEQop0SIfr1OKZBJGKVTx0I4xYRqDrh3BBgiJyXRK8IF+GJjNM4BaLVu8hMobQh+RSETMg95ZB0miI0Xqb0kCKpXVlTdPW2a95WBW0bYd6zOPNhW1Vhit6Vyks57YB0JwWf7rE77OVpFhuSIJmdV/LuaQYRqCcsWuE2zfgdQIpWjPOnSKecOeQEyK2A5YmTckm0mVs36kIGpDPwzFIjXiE1RKlQwhQb8a6Pse5wLCBvxgiTEyMQYpYL3sUEbjbGQ9eJyPdD5wMM22pcvWE4Kn73Koed9bfAjEkOWcISYGHxA7nQ/TesLBvGFaVzSmwsfAbFIxaTQiSrRUyFQ2TmK2QhnVn+Oe64iXlRhVe1saJoqP7PYcVgJRd0b2aN0p2D7XaE2bkthkVY5ywazOS1vohtwJ2SzPkmKGMxuPUAlj7iUlH3DzqmKjFMzCwFSyCsVmDo2ZLLed5zdTdydfEPIGEee/EO6m8LsbyPswHzvaLd4V/p33LPwwyuSzT1WrkmpK3ugu1heq5OYgQEkQKJRURA1G5y/P6CORSFVrdK0yyI8wmU6IMdD2loP5HIJn1XZ4Aw3H9IUAbkDgyQnHx9D0xzzRL5k3DVcumR1CkNWAAME7Thc9EwPT+ZxKZbVu8C6r8Rw004ZKaWIIrNtAtEPOFwye4B0K8HhAE9SQ+R0ZdgXAbN6QEch5hhU4lZ3DpNI5zzSACx6FhhCQaGKVYZ1WRcnnciegCxkcBoqysTFIqXC2Y3C5KcEUxaQdPEOXMwyN0qDg5HRJ66FzS3DgdofEyTnV3/Exh/OGemJolMYpzWxaM2ly9qGSChkVUQZSBBfJELDYnmYauf39717NR/YNugvYjj+Cx20goOE5Mwh3YeHdIORuHd/hMbtZgfv6qNYzJ6df2fb2bfe+6NLfmh9MP02MObIhImK2onY+sFp3GK2ZzaYYo/EhZ2x6F3LD0NSgjMHHhG/7DOWKzZ73AZUiUjg0kuASnogWiSgEAYEWcvOdJMnZxUPbEZTKFumq2AalhAsegc7XM0KRdFajKyVRWuOdz7Y/EWQtiCFb/enKIJTEDn22+YvZ818gGQbH0DuE0GiVv61OF+2Dj33o5B89fXL6bfuRsq9fj/Xud737r968cfNnPvW1n/a3Dw4OXguCFCOVAWttWWCb7PQVItrofG6QbKCbkDJnGyOQY5NlzNes26yN0Yoz7m6ule+7rOrLWWOxgL98UahkcaqIYXPN6H3KTQTl+jfGlJsJS37oLgAMyW8UhJvNi8TW9jMkBus2ikDnXMkBTNy6devB973v/d/wyCOP/Ov9SNnXr8f67h9/25e/75Gn3/Knfv/n/J3f9Ckve61Rmt4qettCctTaccOteezJq0wnDVeu3ENTTxksdO3A0Dm8TcwuTqmmEyKCxXLA2x5nPd7DYLPFuOkHktBELUnC44XHpoSNoNLYCA2Nyhm+3XJNUAohs1WglAIfszOBtBHlAyIp0mSKUZJpVWGaBu89/XqNDQJZS4J1WNtRzybo2tCul3nBLQwXjioOJgcMncV1FqMN9URjjOTRD508/B3/5a3/6Ed+9j3/Zj9S9vXrsd773vd++c2bN3/60z7t077u8PDwU8fvzl2FjnOO9XqNQDCZTlBS4ch7kc45lNRMpzNm0ynBe65du7ZR13kfGGyXX2wQSJUdf6y16FNNPckxP5N6ipLF3j9G+rajXa8xpsqKPFPRdR3e56w+UfaQJgcTUkgsV2uMVEghaduO1WoF5PNGXdccHh1ydOGIe46PCSGwXK3QSiKlwjpL27ZobajreqOGGobh4QcffPB/f+yxx/7v/UjZ16/H+o7v+I4vf+CBB/7bH/tjf+zv3nvvvb9ptPEclX+7NpvAbWo7IQS2uP/tKv/Gv5+Hf7sQcBcA3gkCnod1m63itHX72FUs7gLAsWHBWrtR944WpufVhuPvNz7XqFjUWvPMM8889MY3vvHrf/qnf/rf70fKx7bE0aV705hnltKOsUzmETkkXmw3UXNO3wgptjloosAVKXL3qChd5vn+YrOgTckXgFGI4wZKUOwa82I3js+dW17zYEwJISKxdLVVJg/2y/MZL3vpJQ4mDVWl0EJgpEIZQ0gehUAKRUweYv6ybKNntbJoLfAxd63ElDDVlBAdbefwzjGf1TgX8CkhEfR9T/AeJJzcWHC2aBGJjbVNjK5srGmST5haY4xBKJApb6zNZpr54YybN1eI6JhUFUJJjBL4COve4dsOWRkIifl8gmgqVIo4G7K1qdIMw4DRkqZRGZpJTaMV3dCjlUFr6FyAIMBlTJCjhiJmNkEOFuoq53mIRD2dMaw7fBTUlaTRCakMqq4J1uGDZ73oSEogtKJdDiBFhnFKEnzAVBrvIn0/sFx3dEPkYDblRS+6wND3OJ8YXMQNA8E6eueQSuAieJvVEclHlBJMpobLF+fMZxOkSJhKkUgczqY0RkPIn50UApMDUHAxkEKxeyybK4Nz+BDp+p5Hrrfcaj0JvbXoLDag+RMW2zzMkpsSRcogOhaFnsz5lpR5MKr2RshUJkrO+hPjVsxov7kx6SwywS2025ybi7IvqwzjJnBTCEEUMasKS1D0zsTcKAJHe7Wx03ucVzHvIKGkYGjPiGGg6y4/N0A4//fbbDzv9rhdaLjz981tv5I6ue2lOIZL83t5+UsucTCdYCqFkaClQRlJiBGFRMox2yaHXK+jo132KK0IMWz+a6o5MTrWfY8bAkfzCluUtlLB0Hb4kDt1btxacO1mn7HmycldAMwxTQOXpg2TJoPArFHLe3utzwSsnjSoegpAu27xbX6fGtMwmU9RlSYEsEO3eQkFVDrbeaA0MXhkUdrFO7xzGRy6HDeoDXWBdDFslX5S6c1z6wrAU+lptggNlnW7xtv8fHZwWO+YHB5ST3RWDAby8ypw1ufnLu9dDHA2OLwH79w2528cVaOlKlv4d+nKnKPpBKlGqOiZz6ZZ7efzfFcyW30ChBhIfmcaxpxV5lxg3fU8er3lkf55LG2fb+gdf5i3vdDnu5MN7+59X2ju3ws63ie3J6p9fVTrZS+6/K33XDr8M01lDkpKH1IIfIgM1hFDxNQVVVMTEvSrFm8dMSQmkypvDtQVMYTcoRuKLWAKVFpiKo2QWSkkEogUCZvvprLPXxwdvN9eP1SVISfwlOut0l1ISEgl0Dp/X1RVjZCKEBxt2+J8KvM/YF3PdD6nbmpS8KSQFftSZAV/9J4QBTLnjp1dvXH2nQ88+vRXAd1+ZOzrN0J95md95rd+0v33/xkl5EFMEa01dV1jKk1lDMZkFeBmwS4FSkpiiujSNT8u7FOxcJBSlT42sbHfzIvwfC062nzK0gS1e10KaXNfUVwssopwBIlpcz05LuY38C8mhCznk+IkIUhY5zeWoMGHknHk8SH/PcaIs+70gx989Dvf+c53/C8hxH0Xyr5+Q9Qf/+LP/pdf/Dm/6U9dvjCbO2fphpy7u+osV6+fsVj1TA9mNEeH9D5xdvU63aLH2cCFCwdcPD5CTyb01tGtOoKLKKWRvmPWaJomX/97H1EkdIoMKeFiIoWyX5MyBHQ+IiLUxtBMJkgiNuZAAakkRtfgoaoEVSOoFEymB0hZ09s1N2/dZLBZgbw861kur3PPffdx8eJFNIFKKg7nBxxMNVKAH1pE1MwPJoToFz/y1nd957f85zf95f2o2NdvlHrd6173rffdd9+f1lrPR5WPlBJrLavViq7r0MYwaRpCCNy6eYtbp7dIMTCdHjA/PGQ2m2FtT9f3G4X90HfM53Om0xnaGAZr896kyPEiVVWhtSlRSjm+Y7Vc0nY9dd1wOD/EOUfwHqUV0+mEusruYFLm5vRbp7c4OjqirhuGYaDvuwwnlaaZNtRVzcULF5hOJiyWS4Z+YHYw28BNgNlsNuaYnT3++OPf/s53vvN/3o+Kff1GqT//5//8t3zu537un6nrer4L0/J86vGlqXcXzt1N0XfeCvROf+6mArxb3c0CdLztvAIwq3q3WX4jjMx72bk5IKuA82O11jS5gWjxlre85T9827d925ftR8XHR2UAmBJBipx/NjpxirxNnaFGhiQZKGwtQUf4MToj5oUnkLaQcFQ2ZWkhpOiJ0SFFti1MSYw3leXpqGoqcidZ5PNpZ7ASIEWMzj7yF+cH3PviS0ynNY1RaKVRlcTIYjOayCo/soVoEhCloLMOLUTehCsbZKbSkAR98AxtT2U0WikiiYDA9QEjAC1YLJacXF9i3UA/eCBn2Qkpc95G6dKtakNMUGu5mSyV0azXHWbaUCtQMiuPRAos147Yr4lolDJMJ2oDhawHbwMHBzUp+pwjZCS+cwipmU6bvAkeIzHljl/XDgQSQsn8viPQdQUxIpXE944oFYJEXWt8SFkZhSclSd002XZQKla3FggpsxVgTEiZN/zrpqbrHZXOioLlqmVwhSAjOJxPqaRg3Q10rtgDWZuPUSpCitluIIHWgtlsyrSuuXS5YVI1eBdpZpqJqailyMHFomz6F11eo9VGlRBDzoYMGwDoWPWWx056zlaBiCrZeXFn3Oa3Oe6MxDLCN+//qBoc8/424tbyqBGKRwSyQMEkxcZONEPBkuVXbJdEkdumHXvQrZRvBOTZqjamVKxGs/JV7GzqxJLvJ8rxpN3Dvm3z5zwAvBMQOQfu7gQo7lS3Qb7mDkqk/lfhtHWyPawCAF925RLzeVbSKl1hjEQX/3sRSxYcIUdnkPlt6zwGmTvVi0elKR71nQ90XcfEqI21pgf8ELKmzigWp0tObixwrmfZn9z9PTo+Ht8N7rkyp9qK8igscWMTGoC+W+Jc1oQ10walRwWhY8P/DNTaMKnLbcERPFT1BFllGBh2bEaDdxvwCFDVhlppvPVY7wgaKjXBFFCnFUQ8RkHVNEQU3gUG6+najuAdQ5stSucXLlGpDOekAqM0zlKOIf9O+dwAbefoCvjrzxHmk5PtZzqf38vcGC4eT5jUNX4INAcVk6qikhB8QDHO/5yfVGtFiJBiyJaDQHKBIVq88yw7z+MfKQD8cOw6OTdfPlybzju91snz3P7hHvceAP6aVlNXn/PSK5f+5qWj2RdpJZtRjx1jKnbrWZ4cUsK2Hc7mRXZdV2ityqZ7zMrAGFFKUpl8O+RrjegTps45QNkqNF8HEHOubkzZ0k8KMEZhjCLYgHWOpCTGmHytE2LOK40erUSZ/9licBiyBVFwnr7vEUpyeOEwA4yUuxe1ljnT1wdiFMSU+sWq/fFHn7r2datu+IX9aNjXb7S6ePHS73z1a179NVeuXPkirVUjhMBUFVVlqCqT1wVa5etzIcpCXtzWyZvhXM4D3AV4I6Db/inZ6CWPelQfj//O9qBZvYcoikNiAYHbzMEQiuovhmyPn8ZckBEw5k7lVOzsvc+bBN5FhsFmNaAP2GHonnnm2pve9/73/oMbJzfeuh8N+/qNVi+7cul3/qHP+81f89t/0/1fNJ/VzWB7euto+0DbWgafGBCsnOfWM1fp1j2VqZnP5zSNQcqE9Y62HXA+oLXiYNown08RRILz2C4wmc2p6orBOoayuZ98oBssMQmkVBglmU0rmloT+sCy64haUU8n1MrkxmUdEVgmlWJ2dEgUmra3nJ61rBYr3NBzeuMawsC9r/xkLhwdUonI4UHD/KBBoxDRI4RCCtG/6+Enfvw//tDP/sOHn7j6M/vRsK/feN//Fz/31a9+9d+45557vkBK2Yyb46OaZvy3c47lcsVqtUQIwXQ2o64qQDBYWyw/PXVd0dQ1B7OsDrTOk4Tg6PCIuq7xwWdr7hTLXmBRGMXIYC1NXVObinWbI3+0VjRNQ1Ub7GCRUtL3PYnE0eHRxgUgpVTigxx1XTM/mHPx4kUQsFquMoSQinW7xhhN00wIIXQ3btz4yfe///1ff/PmzbfsR8O+fqPVp3zKp3zOH/2jf/Rvvfa1r/0CrXUzzvXzarpd+JY5jLjt72JnfTD+OW8Feh4C7gLA8yrAO9l/jjBw9+ej+m8XAIaQhVPZRSC/njFm08wIjH/v3//+9//4G9/4xr/3gQ984Of3o+Hjp8TR5XtTXhxugV1W9bGxHCyuMWVgyk3G3m68WEqjfej42FDwyW10D4Illt3ZrDxUIFJR943WoNlSVGzyAvPAlMUXd3wRYwSVksxmE+578SUuHszQJg/6Skl0ZSi/DUrnPMAQEx6BloohWEgSJQTWWQafs2ysy7Y4q3WHQFJVFUkLGi1ZLNZoJLoxeO9Zni7ou4HFasAT6Nd5YqRxcU7O8QgJKhKmNvgISoBRgnraEJLAAFVT4YOjtwnbtpgysSYTTdcOaCmyCsg6ZgcTtFb4GJkYhR1slu7PJhADAYN1ASMjfWsZYmTS1OADUkQms5qkMty0y45F52gaxaQxDC7QlDwBXRlMpei77GPcW0/Xe+wwYJREKMFkWmOMoW0t9awh2MC67fAhoqXAuUjdGIRUtKtVznDMpxdiiEUpmj98LQV1U3Hl8hECODqcYipNTDCtDTOTx19KOe1LS5E3MGO2WQ2F4lnnEXnzER88PmYA8MgzKxbrmP0PS+fz+YC8XZG0GPP5dk6YQoiNQjCD7x27zgLcQhnLmRluwvnyRm4q2YDlIWIz12JREsr88xEUjq+djXfZYD9Rtm3SOGHZWIOOAPBZQYApoZSgfxYAhA2wuxtweD4A+CylYHOH2z9SAHjng8j5cPfyipdd4sI8zwkpQUuFqXU+v5AVfilmABgAJQ02OmKBg94NDD6gtMk2vhKWyw6kYmIqooaJVpyerTBSoesMxM5OF9jBcbpY4oD+yZPnfF+aAgMvXbodBI5li/1nV6RxBtBm933MP9c0qEnO1bDeEbwDR1YLKk0IWz/x4B22qP6UBuUd1dRk+89AAXo5IlDVJtuA4iE4lDJopTdOmtZ6bi1b2uWTGGB+6V4OZtM8nTbSxvxXOzhuLJa4HqbzBjC0y+XOb3Fy+8dZxtu8OebypUso4OhiQ2UqYoDJRDGrcs5jjCpbnCpwzhIiVDKHoUcC3gZEzDmJnkDwgWXneeiZBU8+yUfkNPthDdPnu+28uvbDsff8SF//tmm0B4AfizqYNl/0ouMLf/XwYPr5WsnZeH2fraazhZ/znmHIG+taG1Rp3MnXQSUbTKsNOBi7eFOxLM52QOQZWzK5nA9oo1FCIpKnqg2qNMx0XU+I+TpFGYmSkhTyxoHRAlXmf0gJaxPL5YqubRFScDCfcnAwQ6usRJI7SiHrw/Js2b35qWs3/+ly3f3k/tPf12/0uufKlc9/9atf/deOjy9/npByZrTGlHlsRggos0uJlBIldwFg2oGCcgP2xm7bMeZAlIvQEfol2CgKIXcXx1iea2cTQJRGtY3aL1/wbm8XcpMdnVLO9/UhbnJAht7ifMA7j3WOvrerq89cfdMDDzzwz05OTn5i/+nv6zd6vfwlx1/4+t/9WV/9Ga+693fOp/XMeYf1iX5wrNuB0/Wa07Mlt06X+JhomhmVNiiZ16p5kxCqyjCZ1FR1jXMuW3O7wIWLRxhT53noLSmE0vw20DQTaqPRIjKbV1RVRXBwenZG73LzYzMxaKMRPhJ9YDJR1HVNSAIbIquV58kPPcXJ1SdRWvCye1/K/a98BYezGpkSB7Oaic6OPP0Qlu9/5On/9j0//gv/x4OPX91//+9r//1/zz1f8spXvvKvHB8f/26l1Ay4bePdWst6veb09JQQAlVlNuDOudKsFyOHRRVolOLW6S2WyyVaK+65coWmmeTcz3LNEGP2A1E671kuzhZMplOapsZ7z9Vr1xHAZNJgTJX3z2yPdVm5L6VECsl0MqWZNDiX84SbpmE2mzGZTHDO0ff9xurPGINzbnn9+vWfeuihh/7xzZs3/9v+09/Xb/R63ete9/v+wB/4A1/+mte85ndXVTW7k7JutM3cVeal267Dt2uCO0HAOwHA3TpvOzqeg3b/vXv7rgJwhJWjVanWmqqqNuBvzPgrit/Vgw8++OYf+ZEf+efvec973rT/9D/+Sm/UduzoiBJFHTUql8QmJF4Uy8R0m8ncFoqktEFujBBC7MQIClmsC9OYl5Y7T6UYE9bK81G6ToviSiiZhYRlQZsVUBKfRkstbst2CymCL/afUpFQCCIyJkxMiKrAxhQISRBSpKl1DsgmEEPE2Rxeq41ASIWQGQb6FDe///TgAFGs83rnSCFhLbcFejqfZThOSqLNkydb+2hUCEihCCLR97lrdrAeEUfLyIAdBK53OCXQUuBDYBh8fvd8wkuBVIbBO9RgCS4gdEKJRAiCKCCkmO24nMdUKifMxYgdfD7u6EhR0rU2W17WGt9HhILQDvS9A6kyQPWeRMIGT6VqbATf9sgksP2A67NFQQiR4PIAiEEytD2DzWHEIaZijElRXkpqo6lNRVVJjM7ZjFpme1MpJJXKMFlXWfljyLajIQSMMvnjz9c66PLujcaeUkiUyBFxQmQryLA1SduqTMVOVt+oai2wrvRfI9OOum5nF3176hSotGNtK7gtYzAzwTFLcISIWZkqhCwKv/FkLMuTx42VixgJfRJs/yrKZk/aKAvZvLvbRMNUZtzWQvQOoO5OQOI54V95jtvu0/wqn6qO7/KzE+6UK5gIBJetXZWSUFoBRAzo8W2N2Zw1RPAx0NSGlCQDgA94O1A3dbbClAakpK4r/CirA6YHM5TKgduDd3B8nJVtO+/F6A56DJvbPsQJDdt8u40yT+csuAk5A9ABzt3++7kepk22HrUm5/CNZ5uub8vZN8M+yCpD7xy4rALEQLBQVXm+BO8YXA+uoQYqncHfmEs32AwQKbCxdRkemeaYqjEoxUZpiHWseli2y9uy/bLdZ5+tUo/vQJOPj5k3YExDY6CqdLYhlZkoSqUwOr9L2qj8ASIJ3mfrYV0xRiZJ8jxPKIIKyJAVn6r8RhzfRQH44ar8PhJV4J2G8y4EfD7Q/nzqwONf4XHt66Naq7b/sdXjz/xYZfSnv+j4wtcczWef31T6pbIodbTKav9kTLnQ9oQwqtApnbyROlSQZG6mSTGf00Wi7/KkkypnIucGmID3Lm8ElO+GKAQ1glAu7q1zICRVypaEUsqSHZRwgyWkBFIz+EBnOyKBpp7Q1HXJUC6NWgm6wT1583T9X58+ufVPB+veu//U97WvXNevXfuJ69eu/cSFCxc+69WvefX/cnx8/IV1aF6qpMRUZtNRC64s6jOQH23cRcntVEURrJTMDUuiWIDu2IHG0qGbikJ4VBwrlQF9lNtr0qzuA60VY2MeJS89xkCM6baNhHHT0trcueydx7mc+316evrEM08/8yMPPfTQP10sFvv5v699lXr86ZMf/5b//GM/funo4DO+6LN/01d/+qfc+3kvvefCvQfThroyGCOpFBgtWKxyNlc35MbFMfc3xMBBNQEvCIMnyJDtPkVidXaGkDmzV6lsC26DxfseOyS8FfmcUum8to8eHzx932KdIYkpEzXJ7gJKobVgvWoZAoi6ZuUsZ+ur+LTi+PIn8bKXvoRLR1OUSDQq0ejIjVvth9754JM/9H1v/qVvvLlYv2//qe9rX+X7//r1H7p+/foPzefzz3jlK1/5V69cufL7m6Z5aW7KyVlZs9mMEAPLxZJhyHnBvuynee+zkCGMUE9x8dIlptMpQ29ply3dqmc6m+ZmQCnwPtJ1HQjo+4HVuiUmNo1DSgqGIVsRTpoGUxmkVCiZ83yHrqeeTNCVQWm92X+tqgptzMbSsGkajDGs1+snn3jiif/6gQ984JtXq9Uv7z/1fe0r17ve9a4fede73vUj99133+u+5Eu+5Cs+/dM//YsvXLjw0jFTc1cRuJu/t9skMP5XCLHJ/D6vCBwB4LP2Re8AFc8r/mCrPNwFgOMxhbLZN65Vmqa57bUXi8UTDzzwwI//4A/+4P/x1FNP7b//P45LHF1+aRJJl6yy8sNzmWS3/zvuwI7RQnHMj8ioYbSUodxHyFjyBQUieUIKm6yauEERYw7FjkR1zC8bVYVl8yoUGCLJiqp7Ls545b3HTCYTjMzwBCkwQmE0OcdO5pBcKRXOW4LMIdhhcEQgCQ9CYQMkKenWFmctk2mNNjnAE6HQUmKdJfiMj5ASZy3EyHrZ0nU9q3VPINGtB7yPRJntTvMCPqIExJiVWtPphEaBrCu0lrgh0K46lBIIk03uQswb+EIpiB7nE5XRVCZDsrqp8S4W0hrobaTSholRDLGo7LxDV5JYMhCNUjkzQKRskek9s7rCAiJGmjqHgwspc9ZXjOjJBNt12MHhfcLUOW8txZL/2DQE7xlWa4LIkEmP3ppk2z4fEyFlEFM+YpSquHx5ipSS2hgmk2zPWVU1GojRM5lNmTUVpnQXKvLYsbYgtRRIIRJGL9qUiBFc6YB0ybPqHI9dW3O2jiQUcWO5WQBg2UTdqGHTZgTn7mkxWt4WOIgoKryi7tvedLs8dmdiyZTfq1QkH2KEdsWOKbEFfFtr0O1kTGLMdRo7tFXBeiM6H5+XMgfHLpC0sTgVWjGsTyEMtN2UOyr14Pkzyjb1PJaKt+WS/epZgI716vvv5ZX33sNkMqGSRYkswaDQRiKlyR3wpZvNeUeQCiSEIUfRBOlAGFwApKRbDVhnmU4qVKUIPoA0GCkZ7ED0IZ/hpMKX80G7WtOtHcs2q9yWRQ14cpe3ArIicBT4TaYNU73NCcQ7goPe9RkE9iclKy8/0bw53gAzhSk2ollBWBuzsQ61vsWfS9zRJsPGAITO4UdloWkKODTl9Xs8oCfZinToHV2bJXSXD+dUNRvF362lwzlw/ZP0bG1Pt6PkLjapx8dcudSgMVSNYVLlPEIzzv8QmB5MmDUVykAlNYpIIJLFmhJiBhwpFglizHuh1gV8DLhYMgCfaXmkf44h9ULVe8cv4D7P9Xx3u//d5t9dny9D2ueYHnfIEjRw8gh3OEPt62NQxxcPv/poPvuS6aT6jKYyF/NXQ8oKm2Lv40PAls67GBNSKWrT0NQVxqii8Mnf9cEH6rrC6NwBMFr2CLltnlLFriMVK5KsGBYoLTOEFFkF6EvTgGkqpFY4O9CtO6QQXDiaY3Tx+g/Yxbp/+/Wbi++9fmvxj/ef6r729cLqUz/tU//6i1784t83Pzj4zGbSXJKl0VApeVvuh9Zq09GrtdpYcYrNNeHYtJY23f/j+k2I8frntgtSNinWZW01Pi6EfN8QY8mT3ukajrnpINt7WpwLDP0w3Lhx45cff+LJ73rwgQe+Yf+p7mtfL6w++3Wf8tWf+eqX//5XvPT4M48vzC8JAeu2Z7les1iuOF2uWK57ztYtbT/ggsfoivnkiKODA6bTagP7vPN465lNszKHlFit1vS2Q2hBLI2itd5mjvVdx+AGpFTUjcGYCikU0WW7b5sizdEMNTH0ywU3rz1DpSs+7VX3c+XynMYYYsQ++tSNX/7Jtz34n9/yjgf3839f+3qB9cmf/Ml//Z577vn98/n8dVrry+Nm+6gIstZu8sKytXagaRoOj+YcHMxpmgatFN4H+q5nvVpRNzWTSUMCVqsVfQGAiewSUJmK2XRGCJ7FcsnZ2QIpJdPJJKsOSfT9QNd11FXFhYsXy/0D/dCjleLihYtUdTUCBLtYLN7+5JNPfu8jjzyyv/7f175eYL3+9a//6s/4jM/4/S9/+cs/azKZXBzn/2i7GUK47c+drDpH1d82PkDeUfn3XMrCzargDnahu5mAY+5f0zT53JP3GexTTz31jne84x1v/IEf+IF/tP9UPzFKHF1+eRo5cRpVeLvjYfy73KT67QC/EQXG8hg53q1sKxYFoJCM1EOIRBIhM5pi5ykIiCSzFlAExG0ejM/enxyD55XIC+Djiwe84t4L1HVDJcdFbN4ormqJUAoR8jEpCb33BARGVyQJcbB0PufVSRJJarp+gJgIwVM1DUmQ4U302BDQssJ5n7PDfAQJPnjWbUuwgcEFTs+WDDar4VLapsNlteOobsy2jrNp7ryx3uNtwFQ5nyvJnKEYUiz5ZAnXOZTOsnxlVM7dSxSlHHS9R2poTJ0Fcd7myWxqUnCIUCQxZCASYgZIxmiCz0BXKwkhIY0hCYG3ligVwTu88whl0EbhbPYLN0qRpMQNDhcisnwOhJgViKV7SWzcMBNCKCojOZhOuHLlCCUVzjtMZZg2FZJIigktNdNKg5YYozEaRBQEn/MgtVL5mGKWdoVywgrB433E+UhInnXn+MC1lrN1UZ+KkPWBO/Q7kd/DLLoTO2B8Rxq9o5i9fZ6kHHl5m7cnOzmB4vxAHoWGGUKytR/dnISLWi3uwMhUYORGWrh5gTLPRNzZ4ClKUpEhfCLDlX59qwDASzs70eW/d8yx2/n7C7UE3X3sbYCjf+GPfQFPfen+Oa98+ZymnmBktvRMZEtIXWukVAU4K5SEzjsSEq0NSUEcHJ3Lc1gBSUm6boAIPlrqZlJ0pEB0DD7Pf+9DVgPGADIrfdvVmhActoebN5fPUgPereb3ZpjX5nA8pvOihBuBoHcMDrzraUcQCDRkgGgADLjCgnatQ73rwTRoAxqT1YClfIGLY8pgfky/UR8CTAzoyRyF22QWVo0BD4uFo+37AjGbrPLjTomSd34fmmOYzu/lRZcP0UozhJ66apjUqphHBzQVTa2QWqGNwmhZ7D3jzvwPm884kHMAnQ8EF/CR3FHZ9Tz0TMuTL5RBf7hZe/CRKwjvBu2eT/H3ER3zHgB+nJa5eDT/K0fz6RdMm/pTK6NeYpSaQO74dd7jfKAfLC7knOUxO0yVC/4xUzB346kyxz1K5fxhISXBxdyQlMjXMCkgNyHj4zVgts4G0JWhquvs+xACQiQqYyAxtL176GzV/cz1m4t/3w12n++zr339Cub/q171qv/5RS9+8RceHMw+eTqdvryqqnoDApXEmKo4sZCVgNlqBwFUdVXmf44y2L1iZez436zhxmvd0pBW7EJjsRKN479jus0KKMZEiAHvAn0/2NNbpw8+c/Xazz3+2GP/9uTkZD//97WvX0H95k+9/8tf96p7v+C+F1169eWjg09qKlMPzrFuWxarNTdOF5zcOmPRrokpUVd1tgJXKjdHh0QIMJ1Mc3ZYyhv5xhjqpkZKje88yUaEyA1yDodUksoYtJak5HNWmBsQInFwcMj8whG1iiTvMAauXDqkMsZeu7F6+IFHr/3Mm37hfd9x7ebip/af4L729ZHXK17xiq+4fPnyF0yn01cbY+4FmlD2D0fA3w89zrnNJnxd5wgeIcac7r7EJ+XIJGctdVNvlDp+tB20jq5tOVst8c5RGYPRWeUnhGCw2dloNptyMDvYgABTGQ5mBwgph+Vi8cDp6enPP/nkk99+enq6t/nc175+BfUlX/IlX/G6173u9125cuWTL168eK8Qoh4tN0cg6DeNwPGO1p2354GLZ1l+3gn63e2x48+AnUbEfN6RUg4nJycPP/rooz/7Uz/1U//moYce2ud7f4KVOLp0b2Inc4xiMTXagI6uiAUvFK6RjRXTOLjSGP4EUsRiSViw4paDbP6dzRQTMQlEioiUu8/z0jOUjDe2/onsKK5SyptXArTOGRn3XJxx74sPqRqDRqJkVkU1SqJrQyJ71CmtiDiiy7k2QWSrrKQlwWYFiYsZrC2WCxLZbrNpaoRWKJEt5oahzxY5SlFXGmc9Qucu3MF6vHW0646TW2d4l+i7gVTUjlKM2Yb514sxlI4cjTGa5AOxdPbGGFHGYIcBBEwmE2JRAyBAC5GPK6/uc0ivj/nt1RItRbbniinDLG0gemTwhJBtKKXSiPKZq6YCn4jB5ZNEAFXrzDdTJMSEK0HAevxcysZiGGFohJBk2ZQE6zxKCVxvcSGiZVaIIgW1rnJmQKM5OjwgkPAhMj+cUiGRKmc2KiR1yXarjMZoQcpuZpgKosuLHkH+3YPMFqwxZKDW9ZbBezrreeKk58YqlKw+WcSCI7grmyObLMoN18sqQIpN52iaK8bNFJnZWyqa2LK5KsRWTp3Sbuhfgeli+wLja8lRDCgzEBRZxLfl8OX/87zcHGGG8TvKwfH+aQMIY84zTDk/qm9PSWGgOw8AP5ycv83fn0MB+Cz4N/6lh5OGO9l3vtAqcXpcuTTn5S+ZU9UVBoWUCkmg1gpV1/lOIcc+BiLJgVKSIEFIA0oSXB6/IYEUisXylEi+WG7qrH5RUhJ8pO+67LQlFU2tsENAFoJmXcANlvWq58bNm7iebHvJ87Cc4wzz7nRrzwnz5phJIX21NgXEbwHeWK6/M7015z4eV6SEu5+cafLrb2HgqAjcWpS2nWOxvD1EzzTcZve5ec4G+j7/vT85uf33L7/vaIF6YT4n4nEBDudTKpWbNULM3yy1zorNqqqoFKSY50ll8mcSQkH/Zf47H8AHAjAMlsHl+f/oDccjS3eXD+Eu9VwSzud6zPFdnueFvNbxCzy2F3oct/0OewD4CXFxJsSFw/nszx4dTD5nUlevrCtzj5TiWEt56HwQvmRwpRgJZSEQyt8pm/uUjn+l1DbbK5YGmZjtxKQQaKXydVNpqspwMWd5aKVG5ZC31j3RW//A2ap728np8g3O+b3F37729VGouq6v3HfffX/iwsULn3NwcHD/ZDK5Z3Ywu8dofaiUEtroTe6fLGuZzQm9LNpVUfQJuW1ai6WDd1TzsdPkNjYQjNeOIwCMuQHBrZarx0/Pzh68fu3kbU888cR3nZ2dvXv/Se1rXx+F+W/08Wte8dIv/bRXvvS3v/Sei/dfmE9fPGuqe5SU89W6FbcWa1ZtT9cP9MNAbzv6YWBweeNeyJwVqtU2ZxQk0Qu8Dzhv8dGjlWZST2iqGq0kWoFWgro2HM0PODyYMc0ORf50tX7s+q3lw488deMX3/KOh/7j6bJ9z/6T2te+fvWrqqoXXbly5Y8fHR39vyaTyScbY+6pqurYGHOUUhLnc8HG/cQMBbbK/5wXltcCwXuss/RdT9u2tG1LCDHv1xXlkNE6KwibCbPZDK3NuM/k+r5/vOu6BxaLxTueeuqp71yv1/vr/33t66NQh4eHVz77sz/7j///23u3JtmRLDvv873dHYjIk1XV3dnFufTQROpmokhKJjOJfBQp6UE/Va96kJn4D/hCySiJpjHRbHjp4fQMs291zskA4O7b9bAdkZFZeU5Vkw+0mcIy687IiAACAbgjT+HDWutv/I2/8d9+/fXX/8n9/f3Xd3d3P805f9FaCzsM3IHgLRR841rCtx7f/nwL+r1MH4mEEMqvf/3rf/nLX/7y//v5z3/+T/7xP/7H/8vPf/7z49//f5mvMX2xOwDD9b8BgQHxdtAgTlukR7rsANBfZwd+o+xP2AvkBxAECMbeNfjirtTwbFbaAwx7b88QxrqDi901JuIAEIcwEj0K5+sfnfj9n9yjKTLHAQAEpiCkHK+GxCBKHZBKVEEDKSaaesTmumx0cWfjtmwECXwoG/OUr3GN1qFcVuidNM8gnqt9Pk2Ebg4AigGNv/izX/J+WVGNlGVjWVfqcKmN+249vjE4FIsxQu+02gnSmecZa41t2wjDZWdmHqEZ3E0YJKAIbXQI0TzTW4M4dAzd4zy6v9dGt6CMiM4w4JeooDFTl8Udh7YDsI6Nf1xgDTSiEggdNCeseV/iZu626SEgBJL6N6zVD3BpRoxCikKeEpHOPE3kqLy7P5HHVf0QMl0CKQg5BlqAc06ju0+ICaR3UoxoCNRSab27e3WkoFowWvW7lYt1qhnruvC0VP7V48KvPtruxdxJ882MuHXs3Tx502O5g74rc9svuIy7qhmRTHuk7b58x55p+r58H44+HNAFN2ay9xL2cHvyfpnJ685FY/cZBgK2R/TuEPnqPO3PkaYSWS+/ptvC5ekn/uRn3X+7Y29+G+hdf9/Rz9sesNeBkL+Ti/CtzRrb/Ac/vuf3Hu6JkzLp8/zPoiPOYr8oJt4Naj7eESWmSFNoW2VbV7oIZkJZVoLA+3VjPmVfZlTsbJcNaOTp5PN/9ahQrLHVxlpArfEXf/5vef/k7rvyfrlCsNvd/fILvTwG8/iC3pu3A8Jb959Du8RMPCema+efA67b2M86CN0t+tpdg2Oxq2NQYbgNobAwTInsNOkZGI71LW84/F59lxegc34gAac0M6XEuy9OTNljRJVIUx1dhIopnLJHISuKZhDzHsCIXCMK9z9bfgtJc6eiNe8nbR5ldLlU/sW//UQE6Hfpd433/F3X/eZ8+vf4nM8CyAMA/mXW/d3p79/fnf7H85z/VkrxZ1H166j6U5XwVe+EvaO0NWNPdNgBoXUHhkHCcP15HChwhYQSwmK9v2/Wf1lK/dOttn9xWbZ//ptvPv6vl3U7Mv0PHfoPqK9+9NXf/73f+73/4asvv/ovTufTXz+fT1/P0/x1TPHLlFLYY4CauTu+j6uBqkIf8fCE4DcxwrVPZI9IX9dt2bbt/bIsv1zX9Rfv33/4F7/61a/+7z//xZ//owP4HTr0H1Z/8w+//u/+zn/6R//TH/z0q7/z5bvzH7w7zb9/mvJPUtQv162Ep2Vj3bbRyenOgWbGVotHCtbiFSI5kmMcN9VGckrMUyaEsDTr36yl/Or9x/Xn75+Wf/3nv/zmn/1f//zn//vP//xXx/w/dOg/oL788su/95Of/OR/vru7+8+nafrDnPNfyzn/NMZ4BYPPl6Vue3v7SMXy84GNeO/9wv/eJSYiC/CNmT2Wrfzi6fL0J+/fv/9nj4+P/+j9+/cH8D906D/k3/+/+Tf/3t/+23/7f/zDP/zDv/PVV1/9/v39/e+9e/fup9M0fdl7D7cw8FNxn7eA7xb+iQittXVZlm+enp5++dvf/vbf/Pa3v/3Xf/Znf/b//NN/+k//tz/90z89gP9fIYUvf/zXe8BGcVYYfWIvkAiB0XcXvCDejU2N3vUK654XGFdhcQAV8GhKj/6U68X4Hvq1F2/8dXKI06PHFfolLKR3b3sbkTR7V1sQBxwpRn764xO/9+N3ZA1M+51uIZAGzYki4y5Z78Yo1rHemaP3ZLUAtRbWVgmitFqxDpfLSu19OMUcoEiM5Nldf313Z5nHZ9aysV5WNGdSClzeX3j/8UKKyuXjhd98XHn/zYXaGiqCDDDa9jjO4HfsBQTVQE6JZVmwbk7g2V2D+x3+gsQIvXk0l/jxEVFkgC/E7+irtY9YTv9+QcW7s+Q50DIEobfi/T/joiH4XcQN0BAoZuj4h8IegRiA2gzrAdURRTruPqy10MzdBHd3J6JGvvjqhK0bX9yfaGbMOZNyBKtsxaitczfPfnyzEgiUpXB/jkx5QjQwpUCtnbY5nO6ho0Ewa7TursdSC8XMXZt141KMf/0XF371YXzH59HnrssbCv4qFZnQvVEvhOc+xx76NWphLDbsrv0ZSFzH8svP4zplxvqCu2rhiut8VWE8cxudOmy5I6ztGkkqfcTxIi+LO8P1W4y7wR0A0haeLj/5HqeJAe9eAJDv6P371vK8fP8nY0DnN5b7hB58k77++p4/+OqerDBN2aPvRMnjbSoKIuhwn5YBuE9J0Dj5/C+VxYqP9WI04PK0UFtDVBmVlUjynoyyleEC9OMcs1K3je2yITGTJ/j4zYX3HxZyjlyeLvzmm/e8//njt9jMmzxpAL/dPfjmAjAo6OML4DPfUKRvH6XPFspxu6K9s2/m4QbtPl6disvtxjzyLYff6+fvf/YAaear+zOtFr48n2hUpjwzTQq1sW4Va3B3mpAIKTn6K+vGu5My5xNBYcpCrUZbx4GhoaLD1eQOwVI3SnMX4VJWLhv8q19c+JOl/O5/KR+/5+57e1f+u73v3+X5N/b/0QH4w9Bpzv/Vj7989w+j6B+KhEwIebTGJgIpEJRADyH0VlsLEnrvPUgIvdT2uG7lTz5e1v/jw9NyRPkdOvSXTF988cXf/frrr//h3d35DzXGk4SQAQsis4gk8auBI1yl11EXSO/Wt1L+/P37Dz//7W9+80+OKM9Dh/7y6T/6g4f/+r/8j3/2D378xbs/Ugk5hKAhhCgSUgAloL33btYbgdCtt3E1kA9Py1/8+puP//Jf/+KX//SP/+Uvjii/Q4f+kun+/v6/+dGPfvTfT9P0B6o6iUgOIcQQQgQQkeyXY3vtve//ESxmVkspv1jX9U/fv3//f/76178+/v4fOvSXTH/0R3/0d//W3/pb/+AnP/nJX1fVrKp+j39Ks6qmEIKYq/ZBAkVEzax++PDhV7/4xS/++M/+7M/+3z/+4z8+orx/IApf/ugPew8e/RT2iELxO8WvEaBvdAIGmt9FOqIUX7xHGK6m4XILI9cQvcYf9u4ZmGEHHPQRKephi4H+DD16g2Avo0HHneunHPlrPznx4y/vqevCPE3c358IQdBu1w0K4u4zke4X7gmkFEHd3VarO9RK7dSO3yljnWUZpbt3M7/5zXtyTJzuTu7SU6DbAENC3QoS+ojaaNRqWDdogcu68PThwlYbv/rVb1lHBr9ZJ8Torp3eIDiY06h0jLYZQZ6NY3tkZZRAQJAotNoozUjRo7pa9/2tARAZd/13oiiGR3mOyY+O2CC7ugX66GwcUbDB3YRRhEqntkYUwXp3d194dpklcfzUmxFkOLG0Y9U4nWZ+9NWZu/M8HAedeT5hvVG3jbt3Z3r3/S0qJBWm00QatquIg5w5K6c5stZCWQZgHq67Th8dJkJplbZWKrBsldIq29b5k3/7xC8/bAT0Ocp2/EeQXl13DtL2wM0d9skAcgaEG1ddGAfHxkgOveLBpQ7Hr418VyvqcxznXuOH+XtlZOY+twfuC4dr9+V1ntIx4abD8GVPYbjG6AIShtu2EzSyPv2a3haeLnd8C+TtkONzrsDvFfu5vPodXjoElzeeu13/d+gBfsbMT79O/OSrr2jbypQj91+cEFHU2jiKShBFo6DqcZEg5CQQdcCiRorqvXG4e6aYsX7cqDROdyd+86vfklLmfHdHrYZEYHwG4gBQYHRvNWptV3B4edr4eHnPVuFXf/EnLK8h3uPjt/fhJ/f9t/f1rcPuxXJvgaAXr33CqvcKJs0jivSt9Xynq/HR3Yw//vqed+fTNU70dDc5sN8qd+czRuOyNlTd/TedMlEUrJHG/J+ScjpF1lIpA/7ts9TPYI2A35xQto3WYK2NrVXWDf7FLy78yfLex9r3AWb/Lnq8GctvdWe+ucwb28K/53s/5Sw8AOChQ4cOHTp06NChQ4cOHTp06NChQz8IRWTEGQ6g53KgF8blc+dtxg2Tg6AYzR1RmEMTc5DoJsDby7L7MnaNUpTQR3ihf2YPBl1HZGgfoM9jLYVID923cUDD7kWDtOEIFBzsbbVgNSNx+Bgl0nonB4OYaGZI6A6+hiOoARKHw8vZHWWrqCoxCec5Izlxf3dmXTa21WNBLTgoELzXz2olTomkYKYQAx3BQucu3nE6n6BXzufEv/k3v+ayFUQDdEODOyxLMwgeq2ndOw5DeN4XHY/pgU4LDau+r5OGkdUr0MBapWNYa3QLBAmUWh280jEJmHWP9QzDVbinU1onBHOApIpJYFurHy/pVPNlrRvaBe2drmE4b9qoueukrMxzJpjxxRdn3r2b3GlqnSQJEcAC83SiFQOBqAIWCEnIMvaNjghAEQQoa6V3By297dYswAwN6l/CAk0j1sydj+bxmFETaZIxvhzeMtydezyqQ295Efl5lQkh2Oi2lOcXd0AIHn8rL5eVHq6+wmDP/Zh7NaAMR18QJ4kGdPG4wx0SBhtOweDHn/4M5184d53hj30ShrN2hOyOz+F5Vg69AfQ+C59eQ7ubxy9gH68iQpebx5/SG47Bt97/CMvDApwRGqXB2ip3tUEc3FOUBkRpkCLNBBFDRwSoBO8C1DjOVNGBU1kLEhNxUk4xo2ni/t07lsvGti1MeaaLUa0hA2lZacRJSXGf/4AbW7m7P3E6Z6Bxmv4z/pRfXR12tzv6yogevyeLujUIPjy79b5F5149fgQeHj9xkL8FmG6ciK9W/cCn3YzzwwPpfoZ54asv7nl3f7r+VRCiz3+UOI9oZoHk7BQiZAHMnc2KRzjv898MVBO0cSOjgrTnLloz6JIxGmINGaeJlBIPy71v53XDy6vvy7dB52cddW/MjYfP7NPPEdO3OjY/B3U/p4c3tu/h+EfPoUOHDh06dOjQoUOHDh06dOjQoUM/FEXYMcDwZXQbXWX+imD0cNPRNxYMAwZeYdz+eFSehSuNuHU6eexnJ7zoNvMcGrluybMrEAjiYK6Pzror8fDtEglEDcQofHF/5861EZlYgyLBoyslKMHM8+DE+y8Uh5igCAETgW4khZ4iipJOkR5AFd5N3nknWanW0WAkjdBh2zbvFwPoQkgB23DYFaGa9yIGg/v5jrvzBUlKb0Zrxlad2EgL7hq0DjQsuENJ9u+KDKAH0s27zKxfkyKtgVV3JVnb96eByc2BEXfhda7uQHpHo0NIa93jTQMoHSt20y3nUC7gHULOoYJHkAbIOZFy4jRn7u8mAt4VGAMjWtGY5snb6qyzlY35dHZQh4MwoxJDojeYJiWL+vaJR9S27n13NHf79eClx9YVMw/FbAyY1oDu3YeEACoOGQPX6MzemzPDATC1N3pj9KWMgXwl3+Zj5cqux2d1RkSt/9LDi/RNbI8O7fvjMfNCQLpH4vZboNcZjlC9djEGCQ5Qr5PQNyrsMaDdwXrfo0LBB87e/xfCt8JNn3UD277V6Xf7+xvvfw3nfuduv+Xl5z0Aj/Ordc3f/qwHfz5H74TLyQEbA8C28XPvjxMbTlcZdZaAjZscBDD1+a8oKScUIZ8mmkASOM8JKz7/mxlKI0XvByzbRrFGRsEUiVA2wCBFKNZAFAy+PN3x/v6JVJzGlAUWp3E8PH6bFb0Vq/kC7rze14/fvfMfPvfC91zfm+BvQMjz/czdKfm+/+qMMnoWgfk0+743KMvKdD5j1nz+g89/MlZhnpUY/G+TirvDqw2+3gxQTNpw4Ko/RXvurh2n5N2JSQLm9Or7p+fvsBSgfH9o9vA7PPf4mWP2qTnzue14CzI+/A7LHzp06NChQ4cOHTp06NChQ4cOHTp06K+04g2i8B8jgrNfXXZ99APCFRKCu/lwh1vvtrOMZ3dRuKkv21dzBVA7fHEgGHoA8chL6w1tfYCLG/dV2Lv4PDpTUXqvjmOCw0GNQh7OnhgUgkMtGTxzB5ES3C3YaWB+AbkDaiAxEQKcYmSphUDgaatoUKx3NARa64gUVPUZvEjgNE/OZ4JRN+Pp/cLd/RlToBoxBiCySuF8nriPM9/8dqG1RqmN0jqqeLzovq0eqkltHiq5x3NqiESVK+jpFrDaaHR6b9d94ntaaSEgvQGBFL23ro0uwTAcYhIUY7j/JCASPAZ0dAk6fvOjhxnWjK4ynHkO1u7vz8QYeTd7D2IzmHOmbpWny8r57sSkQop5OBKBZpzOiQx8+FjRNJGSENXHQAudOSlWPb5Rs9BbxysMBIISesMNokbtwXvfzOjNewqtua1OenPAqYFAdIY2AHGMch3eVo1q1SlFa8/uOhsOwdFLuRvt9hnkTHCP2xy6umndwelzQUZH4LNr72rAHWBPkYEyGHGle4yoXFfccUdg6P0K3xmAvQ+LoXjxk8+d/txR6J2D39XjdwsBX7/3U8/zCUD1Vuzn63Utn3StXcHgFYQtL6BGTJAkg6gDP4EQBR1dlt7zOKKNm9GdAGKDqWoD0UzIcE6RpVQCcCnNbxQwc4ZXQWRDRNmRlQjcnbK72qRRtsbHbzbuvzjRon+tGAEyF71wvk/c65n3v3kisbAsvAmAXjC/x5evzA+jk+8BjxR95MZV+Gkj2ScdZN8FmF7pdv27A/HH9w9EZs6nRJ4SrcGcZ8pWuawXTucTkyo5Ktu4UQFrnO8yCfj48YLEiTQpGv3vTRM/H7d9/qdIN8NaYce7WIMK4B2AKopZg9aoZQDABpRyM6TTiz+FDwmntZygwCN1AMHbffI9+gM/VfL4+vfXY/vh1QHjM/PgLX32eCXGlzpA4KFDhw4dOnTo0KFDhw4dOnTo0KFDPxBFumMiG6Do6uDDAUEPzuL8GrpfPB+NffQebjrYGGvZoxHx/EKgd3kGR/vSfX8soxNth1HQwzOXDCM60Q1Ttnu2riAwjJ66HWwECVcioyMKUYK74awbEsN1HaW4gy6qePegCKKCtca2VayDqUc7qgQ+1obRyTEguDPPgJzl+h1D6NQGy9NKTNHXZ0ZISlLh8rRBEB5+/8c8vf/ItFW2JziljMaOtUIavXq9G9Y6ou58NPPnCNBLoQaHOw4iDethGMQCEoQQO2aNgKEIJgzX3iCy5tAo0BHVZwdhDwhCa91hyhSpWxnHYAdgHdWARB3MSbg7T5xzIiZlvouE7o5FcBAbozvvWuvE6I6f0zyTo8eI1to5nWeaGd3wWMCgJA2UzWjDZajVHYBB1R1vQKnu5rL9oGC0OgCdKJKA7vvCaqObIqH4fg7dI25jRDUSNII0cnfnoddZ+vscJPv4tdY8OrU278y8zQrtHrd5peJ9xNoOt5kP7jDmWxhg0efXPlOuQBEbFD3cwL99FfIcl3szv3aAzDhWfUTl9t2le9VtH98nAN+b7qTX8Z837/9kxOHyxuNbEHjz3FuQ6taZeAsyBsij4b18zwmrqNmeDkuzCuka2DnmfyRG6CYEHfO/V9a1YrRrDKsm5amuGM6IBB1RrUaeIuZ+QxhjcblspEmR6CBKspJEuXzcUIGH3/sJH3/7RDw5hLpfHigD6D3cRGx+qorx4fHxea99Auh80vz1OafZW/bDtzoKeVUhCNzPD8xpRmPidJ+QFj3Sk0pS2OLYP60RI4jA6TyRVVGDWhun04lm7txrm8erTgrbVmnNzxla/W8QmtDxN6cAjXZd1oBeR5OnguQIW92PEI9L4mFEf/rXLEAaADBCGl8txRcJoXBikEZYythdb0DB2wP38Dvs90/CveUl/H7r8z63/L6NB/w7dOjQoUOHDh06dOjQoUOHDh06dOgHo+hxgQ6V7AogRhxh2GGdA7YQAiEYIzFyD84DboMIX9AFByXYc6ynCUgdjsEBAPeEQp4jCnv3aL7nvEMbTX+NbuZOHoQoiooQQ/SYOQzpUDsDdAUqDoGSBESiA5zQvPOtV+oKon4h3poNd6D345WtoBLZ1koIMGVlmifWdaUbpByIqmy9EYIRNVCr583Np0wIAb26tgyJgjYhamQ+nQghUs+F+1JYSuPDhwsQWNaNWh1AhAAibQCtAWzt6kPz3j2BZnsfYrg6yiQIQQKttrE3OwWP8fSQRKV3dzUS9jhWo1v1ANjWsBqeXYXdIWcISoxKSkqvxvTuxE8f7ok9DCg6oUGpZSWKYpqG0y2QhrMHUe5OEY1Cr8bWm7swJWDFQdXdFNEOtTdU3BMnOLiM3VMAzSq9GmE4+RAPdtQY6KKEKrTSkfF8M4d17dmQikm/gj0ZWZyKujM1BmIAug5n6ghEteb7p9kAto1eK92enwt0QpcX8bX72BYZcZ0jK/S5N9NBuO9v9xg68B79hh32wsFuA4rvAPpmHvXbDFKep1IY0P8lCLzVKzj3eAMIPxnv+QmI+PiWg/B1x9/8ah18JkJ0eeGgmn8GSvTzgDqaEZ6jH8GNXyJKFkFE/GYGgVYNxKirOfwjYWzsaZEYlHVFJbGtDqymrMyniWVdMYOY/Ry0mYI42GrLzfzHncWIn50kgaxKjJnTGUQj5Vy5vz9zqYX33wA/81jQh5siwIdXlX4vYeDzcy/4zudiQl/rE68/Pvp2vE4d3dc/j2fT/c/4+idnMtEr/HIkiVKWlaQRU+UEoDCl2/nv5xF3L/s+D+IuSwPuJo8Rrb2goigO8REhjqRks0Yf5zdG5yN4r2MURVAq29XAvkO7l6wz8bC7/a7GwEEsz/sIHW7D/RPOzQ2BZQeL7hh8fPD1f0ufg33fGe85f7sf8K3j9jlX53XZcvzL59ChQ4cOHTp06NChQ4cOHTp06NChH4DiNYIQAMPMkAEjehdGidqwEzmI6AwnGTZgRgd0xE5yNfrtiYQSxhNd6AJGHABvxHB6hiUdhfAcM+qvP1/J773hHWzDwCYdiUIUAe1YEGQAMFEHIao67CD92b1o3j+nACFQm9EuH9GckSQj6i8i46L1Wt0RGHNCY6C1Ri0dk04UKKXQakGjYh2CBPL55NvZGuuyjbhOb6dKk2LFSDFx+jKxbY2tGnlb0RBYSyWou8K2tbJsGwFB1NAgNHNIJ0Gw7h10Yg52bHQgtuoAKqVMa8WPq4TR4be7KvvozwsOkmQ4B0PA8OdE9g46P/5BISclItx/eSZI4OnDxhd3Z5JEck5XF2VrG0EUTRnpnXXtTOfIPCnrWshTQgL04hfUcxrdbWbEOTDFTJKI1co8RYeUVa+djK13mjVCM490FMVk7BPPaQRzUBdwQCsY9M17D4M6Rg5Kb41g7iCUZqgKNUAwd4lWUUJoaB9diiJ0EUQiMu1zY4zRVqllw0rB6jZg4D4XjN7Fv7fZDfjbgfcY+zuMvc6EEfc6HIV79OjuxvXMUaFfMeA+Z/Y+T3l20rJP0tf6XMffK3ffW518n4wTfQ0GP9cr+LlI0je6BknoSOJ0n6vHAxMHrhF36joRlr22ETMb8x9KM9rTguaMpgi9+vwXZU4TS6mUbSHmTEhCa0bbwKQRQ2IrhVY3n//jMObTCcU7JZd1I6KgUFsjT4ptjZyU8+nk879AXjYUWGtxM9rwpd3Ger5l4Loa9XjFfx7H+x+/f/XcW4zq8dXn7ODvix/7sbo8PfDV6UzWyJQnJI4e0tJQjcQpYwbrBlOOnCZlXX0/CGCbz/8UdSSqKjJDjpkoQq+VeUrUOv4cCagYzfD5XxtWvWOxD9Daxk0RjE5Aod4EWL9ykDJzBYKLm+1eDsPoIy+1m6eVBWVOwCn775UBBbdhA6088vTtHfr6wP0uevg+8+vf8zMOHTp06NChQ4cOHTp06NChQ4cOHTr0V0JxDwANYXSSybN7KNBG8uBNH99wgI16MSAORwaDKXjM4w7pHBaqA75g9OEbVMShSNgB4LODyd1mu1OK8aGK+3v6iJwcQAoIoljw+Ms4sKPh7rd2E8u4maG9o6po6JRSwdzVtbZGe/rI3WlGHCFATvQeyNrROTHyNVm2jUbjnGa0K6sVSq2EqOjVdNVY1oaN+Mc2QIwVh3chCCqJGN0dttUNEeHd/Ym8Fb4QZdsKTx8X7wDcGoRAFHettbGTpUNtldaFHuTa2xhDQEWwbqiMIM49MhWHodZHZGbvqIq7Cnsn5shWNiSIQ5PubriAO3vmOTMlj/ysLSD3kZSF3hpRJiBQrRFVSSnSSqPSydPEXc7ezVcNUqOZEgmoCkHg6VLQKJynRNSAYGj03kMZdZS9d1oLNIwg7gYSDZh0FN9PHe8AtB6owzepBFKMaMzUskFrtA5d3N2IJGhGtzL2p41ISCWIR7H6/vD+QyR6/yAeRUoPmCqiCYkzfe5YXWlloZWNVuo1SpcrYN9h3xjSNkx+t+mhPMP0HeFdOy2RMbd4nsfcLievV/D8ub3z0rl3+/NzYO+N1z7XW/Ywf96B9q1lXzsEPw04Eu6iM5z3xpvXxmhgnJUc9HdQFTQI1QrW3BW4WGP5+IG7uxMyxjop0oEcjSQziJ+znraVSuMuzwSEYpWtNXJ0oOXcqXG57B13DgtHjSC1uFtNYkajEmlcyoYofHF/YtkS9xrZtjMrT/D+gWXY/GZG398ndvXtLn3r99f86S3Qt//y1jI8PHA/wynNnOdEq4l4TuQJaOA1mkppjZQgp0wtjWoO/95N2fdHaZAaZkoEP3cKPD1tSFROUyaJx7WGGGEA2xCEbkYDKo2g3uOq0bsCw37EbfQC4l48v+mkMid4YObxRdfk8jxOBwh82BnhPFaQgBJZ0j5DGlcIOFyBMwpx/C/BcoaHMkNZeHSr4Ntz5FNOze8Cd49vzM/vRYjT8S+fQ4cOHTp06NChQ4cOHTp06NChQ4d+AIreFSYef+g+M7zLz51+XQRh7/Dbe/oC/WqvqPTwfNkbBsDYnUd9gBocRvjnmfv49ljFDj2MDrVeri7CQKcHvfqZ9ojRHoTeKzpAlga7uqECDgL2rrTSHHCJBBSltRGZGToi/tlBhPP9mVbc+ZNiJKqDQZOIRGGtDUKjbsZpzpxEgU5rlaiB05w9XrAbMSZsW70fThSNQk46AFtDorv4aqloiGxbo5QVhrvvfHcmSOR835nnxN27mXWtSO9sW+HjpVBrBQ2UdUODIEm9F4+Of+VAUIgBokbMusMuhGC+3QHQ6MjURixkkEBp1cGEOEA9383eY4hwdz9zmiKtGmma0GbUVunNyKc8HFWdPE+OYTtYa/Ru5DmTp8S6+AX3gDvsEEGj0KqRRbi/OyNi1HWjxUgIgvRO6OEa64oEtDu0rNZBQXqnmPgolOCwLTiFljE48pSZ351Yt5W2FUKtmBV6M7BGl+bwzRQoECOi0aFZV+hC0EAY41IQWhhFmcEdsja69lQAFSTP5Fap20LZLthWsN6QICM69zn+c3fkSuA6l67/b1xB3wiU9f7LAabD1VX7PAf9a+8uzjbm6mu9ju+87eV7C/7Nn/n9jXV/Nn5y/jaI4VO/v6HEFbrt8x8ZHX1AG3G8XcY+rs8dkUEG6A/C+f6OUgoiiZgczqNC10iMwlZHyWAxztPkVXAMt2oUTlNGxPv+NM7YtmADEkVRd/1Zg9KQpNTReacC26VRy4b4iOP87g4dMblPp8j5/sxW76FCLe4JXHaq8/j4rS6+126zeTxY9hcfX7x81cPN8rfrvJ8froGWX5xnpjnRKuR8oilcKLQG8RRB/HtNU/Yo1jZgH5AnJc2Z9eOFcZgc0omSotJqI4vy7u5MEGjrSkuJ/WiG6/0gfrNKHIuX4fZT/PBeV74/tmdvrc4n5vt7HuaFx2WHcnvs7A4CFx53V+CSniHgPioTgL7C0w7+lgEClzhmUTzB6cTPzo2lPPHIhTfjQfnUwXjjuL71vsff8f2HDh06dOjQoUOHDh06dOjQoUOHDh36K6/YQ3ewAddowdD3tjigdyzYgICd0M0phVOW4TiyEc+pI+LQV/ccYChXGHT9jFAJxNEL5xCSYHQbMX17MSB7750RevDoxNFH2ANoMCx0rDci7nQjgIp/kI5YuVYarfgF99W4xpwKIGKkGJlSxIZLzFbvdYpTcrDWG2Uxso6oR9UBtnAQR2BbN0JSckqsdaUVQ2MgpTQgTEVFWbaNdbmQ04nSOlhFzPsLU56IMZGiX0ynQZwaXxDIojytF+ovfk2q7nJMIbprU3DHWzPScJKVWr2jr0MPfcR8KhIDQRNBvLFRDKwbTaF1oBbOd3dYNd6dZt5NkfeXhZQz59PMlISFjSiB1gPnORNVUB00xjxKdL0sqGTm08S2FXQc8UIgRiGKR2kGEZoZtTXO5xkR2GpxnNlHhKyO2kIJUEbUaTfMFAsOprsPXrBAM3/Oeh9xtQqhoSqk+Q7TGYlP9Fodjq4XWnnyyNCQIDgk7g1st+i1TuidjiIah/PU4YR1/Lsg9OZOyjYcSB7RGYmnezSfqdsHyro4gLxxqD539HGdF7szsOtLAGLcdnTa8+dcwfkO9oezEAeBY4c+v/8K8L5PfOfyxnN7NOh3dQR+br0MMDE/Q5g33/8pVQwl3YQ87pxTRREVh3u1EAS2ugMjBQwViCrk09nnVNrnfyXOmYCx2UZbjaQDMMdEqwXpbjYDKNsGUZmysH6EskJKEJPve6MhqixlY31aiXliawq1EZv7m6c8kWK+icOFlBv3wBSVy9MTFUjFSU55eCDNN0hp4Qp5HGM9XB9fd/SeC8rDzRF4fN7DjzD/7AEWON/P3J0Sv7m8d9ffnUd9Xrh49CpwmhKqkXTT7ScKl6eVpBPzObOt7eqsVpSYBiAXJYjSrFFq4zTg31ZXdy2bjfc9G8yp3sJpvdFNGYZWB6z4ua+Px9b8nO+DwaOD0+nEkjIP6QlKgp+deVyebkDg2JEPN0ObV+wseewn8RkEEoUZYanmdYDPbZLuFDzd85DOUJ54fD9A4MsiwpePb52BnwG8LwD6440j91uljRyRoIcOHTp06NChQ4cOHTp06NChQ4cO/YAUb/vCAm1EBIZrhx84cHPPXoCg3k0mA7hgA1j4xV/rdu0CDNfusgE1dhDhBNAdTTzHFfYuI8JteHmCObwY9KMzYMxoQJMQHDxJRMZnbiH4Zf3W3BknwX9GsOY0JI2I0lob1iF1h2EaFFV3olgtCJHaHLzkmIizf6MC0Ay1AcxaJ9KpwxfZeyFmYQoTKXnEXQd3BoZG3zoiQsrRIzKrM5npdKKZYXRKLbTaaHROOaMxUpaNIJHf//2vKXVl+7h6910I6JRYlpVtbSBGL+YuRu1Ug1POlFrp3V1/vkWGSqBvBjERRNiWAklJMSMK72b/OcfEecqkKGjK5NbZtg2NkdNpZlkWWu9Y7WjQa+xfcKPk1R11KRu9e3djTspajM0atlZyzgTgw4cL0xTIU8Jqd/dhB6ERTB1mNqP2jgQHBEagtwC90i047AKs+0X4NmxxEjpBBEmJEAJVLogpMWa2BepygV69T6zz7NQLRg+C9ECoQg9lRI8mCMFHuXhvY2OM9b7XW/Y9LxeNEdUvUD1R40dKWTwOdThwfT4Mx1/neS7ZiP4crj4brt0rPO/2vHx4Ocl3MHiTsTsmYuDtPr5Puf5uQeAnev0ev08n4Bt6AQ3nN7bnbQDoZqyIoBhQxOdbsza6AB3K5pho1UZ/nEcQt+rYTC1CAhVBQ/So1lKQlKhlIwB5xIEGYAOohpqyeaarf2ZraFS6GWmCE5k86RVLpphp0uC3IArTlMlRqbpRBe5PJ6p5bOhWNspwL56mTIzKtm6gkd///Z+ybCvb0wXO/uEaE09LoaaBAstCWh5gwMF7HihjF6YZXlCgBZgfPOVyAMSUZlKCu1NCI5yYOc8O/1KOtJbYtopq5HyaebosmE3XJstaGtae4ahEB6DrttFpSIKUlbLBao2+baScEeDp4xN50jH/vZcWQPf5P87vDRBpA+OO/7OGm889lvNqAhwGToUB7fIYURu+NyKPD6/G7wsQmHik+MMSfbmUgQwvOjzt+peVuq+oQRm7OWaIygMTlI/P0aBvzYW3YN3rzNYX0Z438O+z8+vQoUOHDh06dOjQoUOHDh06dOjQoUM/BHllkwwH0c4Fdhtd7wPeBRwBDtiAYt0cyIA7sAbsCFe7kfqF2OBwwwB6uzr3jICMFFCHjc92p3C91C7D/+dg7QpD3OqFBiWqErpHg4rItTtN4Gqjat1I4q/bQAWlGTknajGWZkwVau8EMXfiTZGAslVDR8+axgjVSBhLqwPWARW2rQwAE+jWOZ0zk0GtHXFzJMtS6Rin80yo2bNKzdiqcTrNYJ1tKcSkiATIyiknsI6VxpQj51PGmrG1RPjqC0otUA1JysdvFL4IlFq8/7AZy7JSW0d6ICelVEO9Ho+cZyQKNhk5RbZS6GacThOndxN9M6IG4hw5zRMiQhBlTpFljAe6YM27IstWyTlhvVHNgdSUI6U2SmnkKLTWWNfC6XSitoa1Ru0djcp5zvRmWO9ESUD3/j8MisNaUQgRUlRCbWzFQU/oOIAk0IZjtFtHgiDq7scWvPtRaUjIkGYfwW0BzWT5MZ1f0y4foXW6eP9hr14+GEQx8axBbWFYJ81tRUEG7OMZng8g2LuP2d46DXchxtNEnCZiWanLe9plpZiN9srdDCgDlt/M2CDPEbnDiBu6z5UxlUb8rodihtCeXYDDFrcH+ob+uVPD6xjQ28evAR18G/a9BRZvn3+jt+zx9rNm3u4jvF1sJib3/YmO6N/9a9rz+zpGDCDJuwIV7wNM00QpldUquUYKBRGj0YhTQhC25vM/dEM1QjMyxsUarVXf79Uo6/aMgMw43c1MJyjFEBMQuCwFaMx3J841+0ZbY2twPp3AYFubz39VkkLOozOvNuak3J3e0WrjVBT58T1b2TziMin5N0/Aia1VlDOtwba4Y5ACpwSX4q5EWIhpJsZEPRemmFirx4uezu70a2shx4SeIqd88n1MZJoUYabu37c56SpbI2UHfa01IDJPSm2NbW3kpLTSWNaV8/nsN1pYozSISTlNM9a8J9Pn/36zgkEto7/R53+OSt3nvyiYuyWBcQuJg0BRHU7CRtWIaoXWgIk5nlhQKBdIEw/pxzzyq2+7UB+f3YAvuXcenyb7X9Ib6MczBNz5XnFX4BxhPnk06MP5Ak8fhwPxjUH+GgI+vPH842eWecsF+H0iSA8dOnTo0KFDhw4dOnTo0KFDhw4dOvSXXpHgPXueVtYIEtiteVfT0AB0DuvEL6zuHWW9E7pecwv7Tj9uYkD3yM4wCs58nUIIfqnWnX/9OSYUd1sFuFqp+tgC2UFGCIiK17JZw1qnq0dc9g4aFOsdqxURAQ0EdXeQiKJRnd10w0qlFveRWG+IKKELGgM6YkJ7wCM2AyzFaN2gdlSFFtzRNsWMxoCNBax7rCVd6LWybStTyqQQuBSD2IlBuL8/U9fK5eOCTEoIwWNAk7j7JQa6dlQD67JSLoWY3bV4/+6MlUbtjfsv76jFuNMzKUbaWniaFpoGIoIqrGtle1qIcyKpUrZK/DITeqe0ma9+Iqi4s6qc/Fr5nOOIRXVHog2olboSorozLuC9isEhn9VGq0ZJFQkQNZBPCTDe5cz9NDu8pKMG93cncvQEznmafYw1I6hRmkPjnJQoEcTYNqMUd/OZdUpt48K/EMWhTzXQ4GAQPJY0MmI31eFrjBFjotdKD0o6f4mEQLl8oLeKhdH317s379XqIJuAqQGGdMAbKd1JCr6PxsgVq/Q+onF7gB4IWVD17yMpY3lFlveUbaE371sk7L5bn2zPTtnxqA9H04DqYcSihpuev96FcBPLSxjA/qoFHm57+N5y231XF9/nOgNfv+9GD4OmvOlO+gR8fNhfm/czGK1VrOXnqEiDLD6/qcVBm8q180+leeek4T+3Qim7f2v1+a++bkWuNymAYQLr5p2WVNA4gFNS7mImREAFM6F1o1mjGZhtbGVjTpkkcCkeQxoV7u9PtKXx9OGCTA6sYsykPOa/QI+KirAuC9tlI8aMCNzfv6PXRrXGF1+dqaXxTs7kpNS18XGJNI0kfDesl8r2dEHP7ubbtkq+v0eoLO3EVz/6MaqjX+80UxqcsxKjYqs76mzUKMYGmj3UUzJARSRTSsNapWywlfF9VJlODszuT/fcTTOtFGDz73F35/NfhNN09vlvdeerdCClRFKHqdtaKQWH8qNPcdwWQhRoNAeJQB1djEIjAak2N/Eh3tdHhuLvebi/hYA35OzR54mbAt0J6DBvxHxWd5t6DChQ7WbWtPE/oGSPA41ATMwk+CLzkO5gfgUCPxXV+fjq5+ciPm+jRD+3zkOHDh06dOjQoUOHDh06dOjQoUOHDv2VU7SuI3BzRAgO11wYHXpeIMdOAa+AznvGdmuSjbcEBxdX+Gce94ivs3thHoI5Ywx6vbDuzqY9AlT3lM8RZ6gEAZHgF+eDf4Ym5S4rSfVKJDV4TKmN7YoCIQaadbQ36IZ1QaMSxLctxwgi9Ga02mmCx3tu7pQIQYlJ/DJuNaQbIpEwuSPx6XIhaUSj+kX/rVHqRjOQ0b+3rBvbthFFWTfzaM5S0ZzZSqWtlTxn0jmTcyKp9xZac6ekEbzTLSlJlG2rTJqYYuKpLNzliTBDtU5UxarxEZhj4Hx3IklgXQsxV6aUiUkwOmmaOJ/dCWXdu/mePn6Arnx5zrTeWbaGRCENl8v6YSUa9FDdhTknrAQqhlHJc6L89kJrfuV+ypFuhVAa+W5inhRKJ4ZAC0LQgPZOaH6RX6yz9uLOoALWO2EUjplVzAQrDSW489AKe+jf8KkCQoydZkavYOE5bFZ6ARtRsx2CJESF2jakZ+K7BzRllo+/xdbNHXO7847mTYah0noj2HDbyRjHEh1U94JvYaeL0pt7aIM1d7+WQKVDjGjOSErEaSYuF3cE1g2rr0oBd6dtkKu7dceMDPjn4Hw4D68ZpHJ15+5z0Odn5yWAeyPS8ztjQT/t0Pv28q9iQx9fuQAfefmeh29vlwdVpvF04hwjk8bnE9rolTMEKA4F1WGc0sCMhs9/oUEDGYV01nzu9uy73AEVEITkS9Oqu55jEJh8PjxthRiVEKOD57VQqgOo3Yy4rBtlW4mi2MXhX60bUTNla9R1I58z+TyTkpCj0rZGw/wmA0AQLCtJTqzrxhRPTCnyVBt3eSacoDQjaaQ14yMLp3Tm7nwiqrCuhRQ3Sp5Ik2/XNE+cT97RN+FOvMuH9yiR+3OmApfh3suj42/5cHFXMxVBiWfFyuTxpbZxmjIf31c32pnPd2sNamM6Z/KUHJ7K6GgUUIxgEFNEG6xUSgMt5ufROOZ/M1oT73Mdx7zaxnOjo4M2QZHo8JXy/DxjDr+wiMbMTGMpvp6H+586jPs5vCBnj8sztF6A1FgqA+aN+Y+M8ble59nzzwECRxwoFYeAcWa+z1BPPKQL8BseKd/u1Xz987U+5Qr8VmxoOv7lc+jQoUOHDh06dOjQoUOHDh06dOjQD0DRgcbIzOzPRWG9dwI6OIPRac/FZhKGI8+zBb2KbACHsb4REOn8YY/uDIEdFt66/Nzp5xvUh98pqLjzSvDONhmQL1y9iGhyF1VQdbeeOlBU8fWoKvTuF4E7aBd66L4FpdN7vRamdTOCCnfzGYbr57JutFoIodJ6JOcJgqFBWLt5p1itYIbkPBBqIIoSZ3cidoOtNGIQZJ6Q4eTRZhCg9YDU7uQiKVY8Em/68oyEgBVDYmBdCr0VYvCes5A7xRpqgft3M3G4nGo3tmXlw9OFruLwrTWQCesbSYV8d6IDmiKhd2pdoTVa6Ygp7+Yz03kmJ/jtNwtijYjSraECMQaEBNKJ6l2GVQP140qM2V1oUXg3TZxPacSvzqgKokpvHkPZgNM0kXRwZhXoja11pDvwDRJIAqoOoKvZcO4pbWxzMAHa6Kf0fFNVH8uN4cIjYNpRCSgboW10zdjYEomJKIG2Xugo6fQVQYSl/4q2bYTQETrW3aEZeie0gmkiBEXc3DjGt8dvaoAmgW4y4kAdcoADaUFGgmAiaKSnQNKITBNt/Uh5+khthZ1pdpOXcaA0LIAEIfQbcE4ffZs7WA838xNC6M/Zuy+g3C3Ie6v3b9dtPOf8ieXegoKfcQe+hpCjd23Xw/xtaDGniGpEVNH0DImCjN5R1Z2NcsOFvRlu2/ePP2etIhp5d+/zH2BdC6Wufj7piZgmGJ1zm7nzkNrAGhpnHNNDEiXNo6vOPBozivr8V/W5as2TLQGpze15UbGtUKuSv3JIpwWISrsUzFZ3tIkik1KsISbc3U0kdYip3aiXlY9PHzFR5uzzFo2Y7SAvAyBZEYNaL0CjrP7N76Yz0/2JlIRvfvsRbRDxbVZxN58MS2FESdm7DeuHCzFlnwYauX8XuTtlorhTUKN6hqeBDCQ3T3nPoR6Ru7CaIcNlHlTIyZ2aBCitgjmotNZoGwQbfX+idPOuUY0NwWNBHcspov5cZIW6QJw9ApTGErOP2nLxeXT+goefcQMBB127/VEqpPbs/ruZl+4uhCWOeVl2B2C7HdZXCAjR3YP3ieWUebhceOQ917jOT0G/h1fz7vFTr9/qiAA9dOjQoUOHDh06dOjQoUOHDh06dOiHoBh2V1+Qge0qgTjA3ogTDDJ69+waRuh4xXv7wg4TLBCCO97C7hoc2plD36EhHageZxgG9JMAomiIBHH7X9CAIAQJA2oEgvkFfo0QotCDtxEKMOEXioP5B1YVUgcNHkPaJZLo7q7pfaw/UGt1SKidLt4fNSdlUcGsIuIXloNCMZAd+qQEa/Wevt19FxwBNd+tqPoO0Ag5K+ta/UXt0CpdgruFVJAYoXfKWuihk1UopVJqhR5YngpBG/PdxHzKTDkxZaVsGx8+PqESuXxcWbfGF19kUlJCiiiBk0wkVZanja14W54GobSAxkSMoDkiKTlI2DzY8t39CQ2By1opMXB+d6bXRqn12vlYNiOKEHpluxinfGKKjI68SMruSmqlodPoOMQv7seQvEMxGCZCjAo9IMHdqRoaJh2I9OpX9Hsf3Xqj40s7tOAApFmjSRg+VSitEXpACYgGlEavFdKEdPUx2Bs9COgOTCNpusfeBdZvHrG6Yc2BBK3RpYAptAoxg40I3LC/J9KtAtXHroURlevOWCxgwVvEMHNwGSJBGjrNqGYkTITtA229YHXAqr1fcLhtFRsmXV+3DNetw/s9PnSPBlU6bXzft04H3zfK86333y7zXY7ATyx3hRVpPEw3mxGfwcngFymBZjBRGmMcoA6Oms+npu7m1eRRviaJTPOxaObQLAjNip9TRDExsMaUFHTCxnmwmxFGJKXfkAAkYVr9GHqkaHx2gwIigsYGqzOiKSvrZcAgYfTRDUhleoWYba1UHBy2rVGrf+nLxw0RZbrPTKeJOWemKGzbxtPTBRXh8nHhsja++jJ7n2CM7kG7O5MFlktl3RqC9+dtxbtU4xliVkKeiGa01YjA9MUJEf/sTZS7+xM2ej1lmNu20hwM0tieGqd5YvaCQIhKmrL3ApYGk4w6SiVHIYqwbXUwWiFGAfMo4oD6/N/ddebRvTtcDVGRunNc7x8Ua3RTytivxRz8CYpqJTLAbRRmZIzExhIVyt7rp8yfhIDLM6AuG5wyV5obfRQSk8fPvtarMTwnfEDd9AjO8QynzAMZyjdvx4I+vDEXr+6/5dvz95Ej/vPQoUOHDh06dOjQoUOHDh06dOjQoR+YYu/6DAOCxwOGrnQDQiOEQu/DUUMYYLCPWEK5xoL2EHbjzNWh53DvmlY4YkbxDjTU+WAYTi9VpAtd3cLnOK8PAKnjQzxQz2gEyagEcuhogDjyQo2Amsdmgl/07RitB4d7BDqC5EBZC20ppOguosCI/RPx6FKJTElYixDMSDljAnMQ7/irG7V20hyx1hAzaG34Bzu9B4p5N5XERAiN3sVdL8FoPQ5YE6jNLS+qQoqKjri9VipiRugBC535nAkBYuho79TWqR82yrJQWqdLpQM/+eodX315x+Wy0jZ3Ok6nCWnNwQdGb4FCQ1UoWyNnpdRCMI93bQOETefM+vTEVlfm6Uyzxrps7jwzPx6lFFKKhN5I0V2B0LHeiCJkES5rxfbutQCnYMTgn1mtkVSxBmurpBhIEYd5taMJglVsqzDAIFGfI2tJDlMkoFloNSASKBi9NroGVDIiEQ0FaxvSTohGWh2dbj0gmujiUaOIkuYz2I9YP/6atm3snlVrFavmcMdtruz2vN4qDgEgVN9GkY41cxA3HLNox/ZJQEEk+/xrFTQQT2dCjrR0ol4+UMvi1GNMNAthuB93326jhzDCUHmO6N1jQ0fPZujpZr7fgoLX8O9TIO8tSPj68RsQ4jX0ewEk0k3i561F6jne04vb6nh7hIjHVspzyCLIgH9XBOfzyJ5X1VEkKXUttLVAVHRYOFspHgfaDQkO7JfN92FMHlM8ZYEutLLRKsg0OcBv5uNmyAzqAIuSdJzRlOmkRGmY6TU0slSPBdUYSerAEoReituIxzE+3eXrXlFrlGK0rVIuK5t55LEBDz/6gi+/vGN9utCKw+M8TQOQr0DDqgOzmBzg5aRsdUPGRrXhTJzuJtaP79nKyvzO5/+ybsjY6zIiTOOUwRox7y7DRmuNSTJRhLJuPmfH+if83LDVSm3Nu/tMqKUSVRzgtkY1IyYIzbBSfI4AJN13DUK+7sOQlV4ZUbANSsU0IhGkjTFUNojmg6cCDCffOO9SNpakcL57GwKywJIgjTFen8faNeozwlyTj/qU/TPLeG0f4vEaZHoz1n275tMdy0m9H5CPPPL00uH3LVfgK9fubRzoC6fg/fEvn0OHDh06dOjQoUOHDh06dOjQoUOHfgCKHp0Y6KG7gw+lB79C6xWA4RrT6RABrlanvufqhQEDRxcgwx04+IMg/nYcZBEEEXdKiWZkB36jx28ng2FAtM5wV/VGx518QSJROirtGm8Ye/f3dIeGOhxo/epwlNFA6DGlOSXeLwutGfmcMfNevhyT94pJYMoTgnC5LN6l1gzUCAgpKD204XZ0q1/rBRu9hx5j6Rfks4p/3+ixpb0WQg9Ms9DMu8g0RawatYFsMCWlAu9Xd+rd33nMaLcdbQSiQkhCjjPnLhjG3X1mTpnaAA1YA+2ddzmxbcYU/UL3uhVSTiOdstMF6mLkbCBCWVbS+YRVoxU83rMF1mUDAjFFeq9YL/TeyDmjJmy9Ebq5vXREAm7FaN2dbwrQGwThaWnUaqTkrqCAcY6BpO5q7BKIMUI3tmosayVG7woLI+5yh8spKbYDsg6tQ5KAzZOPkNoRjKwgfYH2DjSiEmhdBkAUJESsVfogldPdF2hMXN7/krouhNYIAawVzCbUBhAP7oi1cdwhIDHQu7p7LHh0bheHO9JHFSHdHZHmTj0HnAG0oxrQmMnTzLY8UdYLrSxY2122XGN6fY5cKTxcZ+M+r9xF6TmkYw6/cOR9l+vvNRj8nFvwO9b1sP84j7fegL5b/vfCRFVvHqu/TQdQYQdsxd2QxDH/2U9CiHtA/TyEA71l2WhViXczNFjrQmYmqzj8ijOBjfWyji5FGzQRsgibQMMdZl44CGZ2RUE25v80Ij4lClEFG9/rNEVar759KWHNKE1gLcw5UYBlKago853voza6BZURfRqEGCdOXWhm3N0nZs3UjseKmqEd7nNmrQtTVKaorNvm/ZOSsA+L9xKukJPvz23dyKcTrVQ3uqYJTFnWzf94JIXWsLbRgHMCNaW0Bq2hCjo5sNyK975i434Oc7j4dCm06tBQRAhUchRScOdzF0gxQoetVpZlQ2MmZUVMPM4Vh985635o9qpakoBN09Ux6J2v+9gtwMQchaXqdRxd/anFx+J8vuPhZ/ElBHx84PGhPMeA7iCvjg24OgHNf9Z2M7aVHVkvg/vNt0P8umxjZob72R2Bl5lHFthB4Gdh4Kfm3cwRAXro0KFDhw4dOnTo0KFDhw4dOnTo0A9DMYTd2xdGYqfd9Iy9KBxz59+1H/D5HQ7ldtB2s0B4rhUMAZDsF3lVBuNzALhHiHb0xj3oXU9+4baNzzZEFcnn4W6qDh01gHiAqTTvXsMCnUgQI0gfzi2oweFf6KASOJ/PtNZIEglqbAG2tfiFbVWsVVJSYop8XJ6Q4BfZpyho0GstItYo1lGJSG/janNDLaKhX6FGCO5feaoQaSyXxloqKUfMKkmFlBTpsLYGGBo6rRtra5znfI0fTGFEG3YdKZSdrVQul8ZTWdEpoTkx5UyUTpBA1EhUv2A/TYmYI5eP1aGlwbu7E6Gbfz5K3QpNIOVIKe7oubs/YaVSW3cHXTPmUyKqoDEgJnTrSHKnZCkVSeI9aBI8YlMhBEVDIM/R41Q7SHBAWLZG6EpEqK264bQ1RIODwn2/gzs6gznYCh1aoHkxJb0HRIVejYo7hKYkZKk8tY1oo3+LjvWN0Bo9JkLKhFYdjGonn96BKMs3v6QuH4aDMGG10Mo6oLaPQ9EINhhH8O3tAWxsuDDG/+jMpEM3pWGodIKMGMkB2IMCmpjyibitlMs31OWJtm3Xbk53zO6ExTwi1PQ5exefi44ew7fm9qch3lv9fq/1feAhAz74RHiA4fSLt6ej54flFvZVTzW8ruJuOLW28brPB6NBhRgdvCljP4oNPAhN3EGm5nGfp7t7WqtkEae2AtuyYHsnnzVS9Hl2uVwQ8fmfVejybJ62PiJA5RkCIg2x5DDYOdgAd54arDQul8ZaHV7ZWohRycnftQ2YpOJO2M0ipzmRJULwPSlZ0C7XFFqf/xee2NA5EmLkLmaiGiikHolafP7PmZgiTx+rj1WB+7sT3ERm1nUjSSblzLZeqPv83xqtuLOxGpzOmRRH197oN5QMmFK2Bnn0IArQyjhkERUhn9LN/Pe40lKMQPTOw7o7lhsSfR1+M4rvH0MRaZ77Ov6E7ama3Tyq2XbnnXpiZ6Lwvm7Mcbo5Kht7H+D196IsCebzmYe/8Qc8vgced/r2M6CylI05qq8n3hzlAfOeZ5E+j9erfMwuMUGFORowwc4j9wfxnvn+zM9OK8vlg/cDPhZedv/dAPoH4PF1tO7zr4/Hv30OHTp06NChQ4cOHTp06NChQ4cOHforr+gwb/Tj7T/7DiaeXXx711vvQgh9T/6kj/dfoWD3psDALeQThz3RIUkPwzG4RxK6PccdWMONRm9Yc8cfZvQQkBiRNCOi9PJE0IrKvNNFB4BRntex1RFF6b1xtbt7L4rSOvTWyQksZaw1NEfu8kyWjdobsUPvRmtCjkLvQiuG9u6QUBoSA9KDf15wp6NKYAN6gRC6d1oFo3WHL7UVlIKbvYQ83GwpRmJUymVDVHBjYCemyDwlckwembeuWAjocO8hRm2drRp1K4QG+ZyprXnU5skdMNvTCggxJ2K/eixJyaP3pskhHk2otdJaQ0jUrcEAiN26x6qKja4tP+iRjpVAPAkQvMORwLJciFHctRMdvGLdQUpvxBDo2lFx96kFj2YFSBqptdBGrGBokPOEhU6jsRNnUQjmkab04LGa2tEQsOpcwKsmHXKrClH66OiTgc1GzGJrHm2qEQuB3gzrjRA7eToR3v2ITROtXrBWaNuKxEhIDg2kd6AQNA7QpkjtdBEkeLSs74LuPZJB6UF5puV6fRgQejd3rAWP39VpQvQr4nRivbynXD6OHrnRUzdAY9izEQG6XXGfIYRrpO+u1y7A74r45NXzC9/V6Qfw8Kloz/0tO/Qr4FQEHm/cSg/ziFxMCuUJqCSdB08Z/W9xdPMZtGIDprkNz7GXL96Abo0coccJs4Ym5d00sYVIwyF475VmkRwVM4/kVaDUQhGFJKjfmwDD6awqVAxzY9+L+Q9CaRVlc0g23HgY5Ozzb7tUNBrN74EgxsQ8CSlNRIRt2eiCu/cqEIzaYW1G23y9ec60Vn3+z5kOrJfFu/VyQm+GR86VZjDNM2nM/1ILtTQkDYAnvm/Nmkd/SqOrx5jSIGrDNu8RtBG/CbBeLmhSUjz5uQXADBWhUYnBQariUM8UyuIbl2TEA/dCTIkg7jK2AI1ypa+quKO4+X5sY3gFhtn16gJ1OBk1klLxOM7rsB7wcIDCOeqzK7B4ZOecMg/z1zw+zN6z97jw+AAPRJaUmQfEc9cfwxWoz49L4yX8G69fY0Cf4319c+Rm4/dpMzGflIeUYX5yMP66H/Ct/r/bXx/S8S+fQ4cOHTp06NChQ4cOHTp06NChQ4d+AIrPjrt+8/Rw+d2YhJ6BgQ3wNxIFu9v7Qt/hoUfSiYr36oURfadxOAGHZ9AcjjmniFgr7vrrgV7tRe+VBEEkoXFG4kSvG7Z9RHNAOCG90/GYzBAc6Eg3zARKQ1QxAcwQPH5UDNBAB7IoXfTaVZhzJJEJowuumV+cPuWZJoVaG9YVUY8t/bAstNKY8gQ0SndYFnKk10rvoD0gYTjTWidOmR4gmrjLrHeCQV0rSKDikZxta6hGJCqqsK0bpTaPN5RIwB2SVrtHjd5NzKI0K1gxYvKIwfVjQ61hblKjrhUJgYqhdKYkbOsCkoiiIMLd3YzRKa1hS/UL/XOituKOx95QxC/iR3f0rav3IHaFSGDOkWmaSBI8XhO8WxBQNVoXEomkQhdBrcGU6L1Tt0IP4/hVsC4EcToWBKI6lAGHK96nt18wH72RwRDttOb9jyCodFIKyDrGWVCPQaXTrWHN+wNFHHTSAzbiQHW+I8cJKx7Haa3TrCGtOsgLDvCc6Sl087kiSoidYM2jULt6Z+WIiw2ei+jvrw0Le4+lQ0qucaeBoHm4LSMlRrbLE61sY05BsAHu9zK3sfyzw9e4MVAOvQZ4y/c8hXwiQvQBHkg4OcE7+8r4SX2VQhgH/HMA+HjNX7yuCuYTpOmmS+1CTCDcjejPhqLujoU9WxUqiMiY/wM0jdGxs5akAirX+T9NiY48z//m8/88RepIim0WHTwJfFhXbGuk7N+/YQQRNAu9Frp59KgO9yAV4uwgK7WI2YhOtuF2E/FvL0bbGhITkpLP/2Wj7vN/RDW3bvTmEZv5PDOL0Kxyufj8r1ZZLxVthS4JCY1WHBg3KgGYslKWjyAZFQVR7t45ONxKcwddgXhWat3AGltrRCCp0iMgyro0sIZJI6FMkzLPJ2Jwh6UCre3OxkYziERfhwraDWY/fN7HWlCUXo1m45zb3aUede8A9PU4M/PjbjbgnTzHMO+MT3GXKKUNYPfKkVc2PAhWWcZCS3HD6nw+85AmmD/yuDxxHWQ0FgrzFfDJbt187gJM+/pfg0Bh3gdjHWP/uk3t1U/vFp3jHcTMQ4ruBqQ8d/3tP2+dfy96AI8I0EOHDh06dOjQoUOHDh06dOjQoUOHfgj6/wGgGWy5RIbqLwAAAABJRU5ErkJggg==\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } - ] - }, - { - "cell_type": "code", - "source": [ - "" ], - "metadata": { - "id": "OY4gLAOFAdi6" - }, - "execution_count": null, - "outputs": [] + "source": [ + "#run the optimization now \n", + "optimizer.run(imagePath)\n", + "#display results\n", + "from IPython.display import Image, display\n", + "from IPython.display import Image\n", + "display(Image(outputDir + '/render_0.png'))\n" + ] } ], "metadata": { + "accelerator": "GPU", + "colab": { + "name": "demo.ipynb", + "provenance": [] + }, "kernelspec": { "display_name": "Python 3", "language": "python", @@ -217,14 +215,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" - }, - "colab": { - "name": "demo.ipynb", - "provenance": [] - }, - "accelerator": "GPU" + "version": "3.9.13" + } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/image.py b/image.py index 83f5ea7..11fe5cd 100644 --- a/image.py +++ b/image.py @@ -4,7 +4,8 @@ import torch import cv2 import os - +from PIL import Image +import torchvision def saveImage(image, fileName, gamma = 2.2): ''' @@ -14,10 +15,14 @@ def saveImage(image, fileName, gamma = 2.2): :param gamma: gamma correction :return: ''' - - import pyredner - pyredner.imwrite(image.cpu().detach(), fileName, gamma = gamma) - + print(f"{fileName} = {image.shape}1") + if ".exr" in fileName: + print(f"IGNORE SAVING: {fileName}") + else: + image = image.permute(2, 0, 1) # Need to permute + image = torch.pow(image, 1.0/gamma) # gamma correction + torchvision.utils.save_image(image.cpu().detach(), fileName) + def overlayImage(background, image): ''' overlay image on top of background image an image on a background image. @@ -56,30 +61,34 @@ def resizeImage(image, targetResolution): class Image: - def __init__(self, path, device, maxRes = 512): + def __init__(self, path, device, maxRes): ''' - class that represent a single image as a pytorch tensor [1, h, w, channels] - :param path: the path to the image - :param device: where to store the image ('cpu' or 'cuda') - :param maxRes: maximum allowed resolution (depending on the gpu/cpu memory and speed, this limit can be increased or removed) + Class that represents a single image as a PyTorch tensor [1, h, w, channels]. + :param path: The path to the image + :param device: Where to store the image ('cpu' or 'cuda') + :param maxRes: Maximum allowed resolution (depending on the GPU/CPU memory and speed, this limit can be increased or removed) + this should match no matter the resolution to the wanted resolution ''' assert(maxRes > 0) - print('loading image from path: ', path) + print('loading image from path:', path) self.device = device numpyImage = cv2.imread(path)[..., 0:3] assert (numpyImage is not None) - numpyImage = resizeImage(cv2.cvtColor(numpyImage, cv2.COLOR_BGR2RGB), int(maxRes)) + + # Resize the image to maxRes x maxRes + numpyImage = cv2.resize(cv2.cvtColor(numpyImage, cv2.COLOR_BGR2RGB), (maxRes, maxRes)) + self.tensor = (torch.from_numpy(numpyImage).to(self.device).to(dtype=torch.float32) / 255.0).unsqueeze(0) - self.height = numpyImage.shape[0] - self.width = numpyImage.shape[1] + self.height = maxRes + self.width = maxRes self.channels = numpyImage.shape[2] self.gamma = 2.2 - self.center = torch.tensor([ self.width / 2, self.height / 2], dtype = torch.float32, device = self.device).reshape(1, -1) + self.center = torch.tensor([self.width / 2, self.height / 2], dtype=torch.float32, device=self.device).reshape(1, -1) self.imageName = os.path.basename(path) class ImageFolder: - def __init__(self, path, device, maxRes = 512): + def __init__(self, path, device, maxRes = 256): ''' class that represent images in a given path :param path: the path to the image diff --git a/morphablemodel.py b/morphablemodel.py index ffa8b5f..cd535a7 100644 --- a/morphablemodel.py +++ b/morphablemodel.py @@ -6,7 +6,6 @@ import h5py import sys import os - class MorphableModel: def __init__(self, path, textureResolution = 256, trimPca = False, landmarksPathName = 'landmark_62_mp.txt', device='cuda'): @@ -147,8 +146,8 @@ def __init__(self, path, textureResolution = 256, trimPca = False, landmarksPath self.uvMap = self.uvParametrization['uvVertices'].to(device) print("loading landmarks association file...") - self.landmarksAssociation = torch.tensor(np.loadtxt(pathLandmarks, delimiter='\t\t')[:, 1].astype(np.int64)).to(device) - self.landmarksMask = torch.tensor(np.loadtxt(pathLandmarks, delimiter='\t\t')[:, 0].astype(np.int64)).to(device) + self.landmarksAssociation = torch.tensor(np.genfromtxt(pathLandmarks, delimiter='\t\t')[:, 1].astype(np.int64)).to(device) + self.landmarksMask = torch.tensor(np.genfromtxt(pathLandmarks, delimiter='\t\t')[:, 0].astype(np.int64)).to(device) print('creating sampler...') self.sampler = NormalSampler(self) @@ -188,7 +187,7 @@ def computeShape(self, shapeCoff, expCoff): :param expCoff: [n, self.expBasisSize] :return: return vertices tensor [n, verticesNumber, 3] ''' - assert (shapeCoff.dim() == 2 and shapeCoff.shape[1] == self.shapeBasisSize) + assert (shapeCoff.ndim == 2 and shapeCoff.shape[1] == self.shapeBasisSize) assert (expCoff.dim() == 2 and expCoff.shape[1] == self.expBasisSize) vertices = self.shapeMean + torch.einsum('ni,ijk->njk', (shapeCoff, self.shapePca)) + torch.einsum('ni,ijk->njk', (expCoff, self.expressionPca)) diff --git a/optimConfig.ini b/optimConfig.ini index 8ed01ee..346c2d3 100644 --- a/optimConfig.ini +++ b/optimConfig.ini @@ -16,7 +16,7 @@ smoothSh=True #smooth the optimized environment map saveExr=False #save the optimized env map as exr or not ( if False a png is saved) #image -maxResolution = 256 #maximum allowed resolution (if input image is larger it will be automatically scaled down). this limitation is here to allow the library to run on hardware with limited gpu memory and also to maintain a raisonable optimization speed on non rtx gpus. this limit can be increased on decent gpus/cpus +maxResolution = 512 #maximum allowed resolution (if input image is larger it will be automatically scaled down). this limitation is here to allow the library to run on hardware with limited gpu memory and also to maintain a raisonable optimization speed on non rtx gpus. this limit can be increased on decent gpus/cpus #camera camFocalLength = 3000.0 #focal length in pixels (= f_{mm} * imageWidth / sensorWidth) @@ -24,7 +24,7 @@ optimizeFocalLength = True #if True the initial focal length is estimated otherw #optimization iterStep1 = 2000 # number of iterations for the coarse optim -iterStep2 = 400 #number of iteration for the first dense optim (based on statistical priors) +iterStep2 = 400 #was 400 number of iteration for the first dense optim (based on statistical priors) iterStep3 = 100 #number of iterations for refining the statistical albedo priors weightLandmarksLossStep2 = 0.001 #landmarks weight during step2 weightLandmarksLossStep3 = 0.001 # landmarks weight during step3 @@ -49,10 +49,16 @@ weightRoughnessConsistencyReg = 0. # consistency regularizer weight for roughne weightRoughnessSmoothnessReg = 0.002 # smoothness regularizer weight for roughness texture (at step 3) #debug -debugFrequency = 30 #display frequency during optimization (saved to debug directory) (0: no debug display) +debugFrequency = 100 #display frequency during optimization (saved to debug directory) (0: no debug display) +debugOutput = True # generate outputs at each debugFrequency saveIntermediateStage = False #if True the output of stage 1 and 2 are saved. stage 3 is always saved which is the output of the optim +saveTime = True # if True will save the time taken in the txt verbose = False #display loss on terminal if true #ray tracing -rtSamples = 4000 #the number of ray tracer samples to render the final output (higher is better but slower) best value is 20000 but on my old gpu it takes too much time to render. if u have nvidia rtx u are fine enjoy :) -rtTrainingSamples = 8#number of ray tracing to use during training \ No newline at end of file +rtSamples = 16 #the number of ray tracer samples to render the final output (higher is better but slower) best value is 20000 but on my old gpu it takes too much time to render. if u have nvidia rtx u are fine enjoy :) +rtTrainingSamples = 8 #number of ray tracing to use during training +bounces = 1 #number of bounces + +smoothing = False +rendererName = mitsuba # redner or mitsuba or vertex \ No newline at end of file diff --git a/optimConfigShadows.ini b/optimConfigShadows.ini index 468ff0f..1abc177 100644 --- a/optimConfigShadows.ini +++ b/optimConfigShadows.ini @@ -2,16 +2,18 @@ device = 'cuda' #'cuda' or 'cpu' #tracker -tracker = 'mediapipe' # 'mediapipe' or 'fan +lamdmarksDetectorType = 'fan' # 'mediapipe' or 'fan (mediapipe is much more stable than fan) #morphable model path = './baselMorphableModel' -textureResolution = 512 +textureResolution = 256 trimPca=False #if True keep only a subset of the pca basis (eigen vectors) #spherical harmonics bands = 9 envMapRes = 64 +smoothSh=True #smooth the optimized environment map +saveExr=False #save the optimized env map as exr or not ( if False a png is saved) #image maxResolution = 256 #maximum allowed resolution (if input image is larger it will be automatically scaled down). this limitation is here to allow the library to run on hardware with limited gpu memory and also to maintain a raisonable optimization speed on non rtx gpus. this limit can be increased on decent gpus/cpus @@ -22,7 +24,7 @@ optimizeFocalLength = True #if True the initial focal length is estimated otherw #optimization iterStep1 = 2000 # number of iterations for the coarse optim -iterStep2 = 400 #number of iteration for the first dense optim (based on statistical priors) +iterStep2 = 400 #was 400 number of iteration for the first dense optim (based on statistical priors) iterStep3 = 100 #number of iterations for refining the statistical albedo priors weightLandmarksLossStep2 = 0.001 #landmarks weight during step2 weightLandmarksLossStep3 = 0.001 # landmarks weight during step3 @@ -32,25 +34,31 @@ weightExpressionReg = 0.001 # weight for expression regularization weightAlbedoReg = 0.001 # weight for albedo regularization #regularizers for diffuse texture in step 3 -weightDiffuseSymmetryReg = 1200. #symmetry regularizer weight for diffuse texture (at step 3). u may want to increase it in case of harsh shadows +weightDiffuseSymmetryReg = 300. #symmetry regularizer weight for diffuse texture (at step 3). u may want to increase it in case of harsh shadows weightDiffuseConsistencyReg = 100. # consistency regularizer weight for diffuse texture (at step 3). u may want to increase it in case of harsh shadows weightDiffuseSmoothnessReg = 0.001 # smoothness regularizer weight for diffuse texture (at step 3) #regularizers for specular texture in step 3 -weightSpecularSymmetryReg = 300. # symmetry regularizer weight for specular texture (at step 3). u may want to increase it in case of harsh shadows +weightSpecularSymmetryReg = 200. # symmetry regularizer weight for specular texture (at step 3). u may want to increase it in case of harsh shadows weightSpecularConsistencyReg = 2. # consistency regularizer weight for specular texture (at step 3). u may want to increase it in case of harsh shadows weightSpecularSmoothnessReg = 0.001 # smoothness regularizer weight for specular texture (at step 3) #regularizers for roughness texture in step 3 -weightRoughnessSymmetryReg = 300. # symmetry regularizer weight for roughness texture (at step 3). u may want to increase it in case of harsh shadows +weightRoughnessSymmetryReg = 200. # symmetry regularizer weight for roughness texture (at step 3). u may want to increase it in case of harsh shadows weightRoughnessConsistencyReg = 0. # consistency regularizer weight for roughness texture (at step 3). u may want to increase it in case of harsh shadows weightRoughnessSmoothnessReg = 0.002 # smoothness regularizer weight for roughness texture (at step 3) #debug debugFrequency = 30 #display frequency during optimization (saved to debug directory) (0: no debug display) +debugOutput = True # generate outputs at each debugFrequency saveIntermediateStage = False #if True the output of stage 1 and 2 are saved. stage 3 is always saved which is the output of the optim +saveTime = True # if True will save the time taken in the txt verbose = False #display loss on terminal if true #ray tracing -rtSamples = 4000 #the number of ray tracer samples to render the final output (higher is better but slower) best value is 20000 but on my old gpu it takes too much time to render. if u have nvidia rtx u are fine enjoy :) -rtTrainingSamples = 8#number of ray tracing to use during training \ No newline at end of file +rtSamples = 512 #the number of ray tracer samples to render the final output (higher is better but slower) best value is 20000 but on my old gpu it takes too much time to render. if u have nvidia rtx u are fine enjoy :) +rtTrainingSamples = 32#number of ray tracing to use during training +bounces = 1 #number of bounces + +smoothing = False +rendererName = mitsuba # redner or mitsuba or vertex \ No newline at end of file diff --git a/optimizer.py b/optimizer.py index 21bdc0b..f274b24 100644 --- a/optimizer.py +++ b/optimizer.py @@ -39,11 +39,16 @@ def __init__(self, outputDir, config): self.debugDir = self.outputDir + '/debug/' mkdir_p(self.outputDir) mkdir_p(self.debugDir) + mkdir_p(self.outputDir + '/outputStage1/stage1_') + mkdir_p(self.outputDir + '/outputStage2/stage2_') mkdir_p(self.outputDir + '/checkpoints/') - + mkdir_p(self.debugDir + '/results/') + mkdir_p(self.debugDir + '/mesh/') self.vEnhancedDiffuse = None self.vEnhancedSpecular = None self.vEnhancedRoughness = None + self.rendererName = config.rendererName + self.pipeline.reloadRenderer(self.rendererName) def saveParameters(self, outputFileName): @@ -151,24 +156,33 @@ def getTextureIndex(self, i): if self.pipeline.sharedIdentity: return 0 return i - def debugFrame(self, image, target, diffuseTexture, specularTexture, roughnessTexture, outputPrefix): + def debugFrame(self, image, target, diff, diffuseTexture, specularTexture, roughnessTexture, outputPrefix): + """generate a debug frame to display the current render, the difference with the target and what each texture looks like + Args: + image ([B, X, Y, 3]): input + target ([B, X, Y, 3]): ref + diff ( [B, X, Y, 3]): difference (only on mask) + diffuseTexture: [n, resX, resY, 3] or [1, resX, resY, 3] + specularTexture: [n, resX, resY, 3] or [1, resX, resY, 3] + roughnessTexture: [n, resX, resY, 1] or [1, resX, resY, 3] + outputPrefix (string): path of the output folder + """ for i in range(image.shape[0]): - diff = (image[i] - target[i]).abs() - - import cv2 diffuse = cv2.resize(cv2.cvtColor(diffuseTexture[self.getTextureIndex(i)].detach().cpu().numpy(), cv2.COLOR_BGR2RGB), (target.shape[2], target.shape[1])) spec = cv2.resize(cv2.cvtColor(specularTexture[self.getTextureIndex(i)].detach().cpu().numpy(), cv2.COLOR_BGR2RGB), (target.shape[2], target.shape[1])) rough = roughnessTexture[self.getTextureIndex(i)].detach().cpu().numpy() rough = cv2.cvtColor(cv2.resize(rough, (target.shape[2], target.shape[1])), cv2.COLOR_GRAY2RGB) res = cv2.hconcat([cv2.cvtColor(image[i].detach().cpu().numpy(), cv2.COLOR_BGR2RGB), - cv2.cvtColor(target[i].detach().cpu().numpy(), cv2.COLOR_BGR2RGB), - cv2.cvtColor(diff.detach().cpu().numpy(), cv2.COLOR_BGR2RGB)]) - ref = cv2.hconcat([diffuse, spec, rough]) - - debugFrame = cv2.vconcat([np.power(np.clip(res, 0.0, 1.0), 1.0 / 2.2) * 255, ref * 255]) - cv2.imwrite(outputPrefix + '_frame' + str(i) + '.png', debugFrame) - + cv2.cvtColor(target[i].detach().cpu().numpy(), cv2.COLOR_BGR2RGB), + cv2.cvtColor(diff[i].detach().cpu().numpy(), cv2.COLOR_BGR2RGB)]) + tex = cv2.hconcat([diffuse, spec, rough]) + + # Concatenate vertically - combined image with textures + debugFrame = cv2.vconcat([np.power(np.clip(res, 0.0, 1.0), 1.0 / 2.2) * 255, tex * 255]) + + cv2.imwrite(outputPrefix + '_' +str(i)+ '_.png', debugFrame) + def regStatModel(self, coeff, var): loss = ((coeff * coeff) / var).mean() return loss @@ -199,7 +213,6 @@ def runStep1(self): optimizer = torch.optim.Adam(params) losses = [] - #for iter in range(2000): for iter in tqdm.tqdm(range(self.config.iterStep1)): optimizer.zero_grad() @@ -211,15 +224,26 @@ def runStep1(self): optimizer.step() losses.append(loss.item()) if self.verbose: - print(iter, '=>', loss.item()) - + with open(self.outputDir+'loss_step1.txt', 'a') as file: + print(iter, '=>', loss.item(),file =file) + if self.config.debugFrequency > 0 and iter % self.config.debugFrequency == 0: + # save obj + cameraNormals = self.pipeline.morphableModel.computeNormals(cameraVertices) # only used of obj (might be too slow) + saveObj(self.debugDir + '/mesh/' + self.rendererName+'_step1_iter' + str(iter)+'.obj', + 'material' + str(iter) + '.mtl', + cameraVertices[0], + self.pipeline.faces32, + cameraNormals[0], + self.pipeline.morphableModel.uvMap, + self.debugDir + 'diffuseMap_' + str(self.getTextureIndex(0)) + '.png') + self.plotLoss(losses, 0, self.outputDir + 'checkpoints/stage1_loss.png') self.saveParameters(self.outputDir + 'checkpoints/stage1_output.pickle') def runStep2(self): print("2/3 => Optimizing shape, statistical albedos, expression, head pose and scene light...", file=sys.stderr, flush=True) torch.set_grad_enabled(True) - self.pipeline.renderer.samples = 8 + inputTensor = torch.pow(self.inputImage.tensor, self.inputImage.gamma) optimizer = torch.optim.Adam([ @@ -240,12 +264,15 @@ def runStep2(self): cameraVerts = self.pipeline.camera.transformVertices(vertices, self.pipeline.vTranslation, self.pipeline.vRotation) diffuseTextures = self.pipeline.morphableModel.generateTextureFromAlbedo(diffAlbedo) specularTextures = self.pipeline.morphableModel.generateTextureFromAlbedo(specAlbedo) - - images = self.pipeline.render(cameraVerts, diffuseTextures, specularTextures) - mask = images[..., 3:] - smoothedImage = smoothImage(images[..., 0:3], self.smoothing) - diff = mask * (smoothedImage - inputTensor).abs() - #photoLoss = diff.mean(dim=-1).sum() / float(self.framesNumber) + roughTextures = self.pipeline.vRoughness.detach().clone() if self.vEnhancedRoughness is None else self.vEnhancedRoughness.detach().clone() + images = self.pipeline.render(cameraVerts=cameraVerts, diffAlbedo=diffAlbedo, specAlbedo=specAlbedo, diffuseTextures=diffuseTextures, specularTextures=specularTextures, roughnessTextures=roughTextures) + mask_alpha = images[...,3:] + # gaussian smooth the render + if self.config.smoothing : + smoothedImage = smoothImage(images[..., 0:3], self.smoothing) + diff = mask_alpha * (smoothedImage - inputTensor).abs() + else : + diff = mask_alpha * (images[..., 0:3] - inputTensor).abs() photoLoss = 1000.* diff.mean() landmarksLoss = self.config.weightLandmarksLossStep2 * self.landmarkLoss(cameraVerts, self.landmarks) @@ -260,21 +287,37 @@ def runStep2(self): loss.backward() optimizer.step() if self.verbose: - print(iter, ' => Loss:', loss.item(), - '. photo Loss:', photoLoss.item(), + print(iter, '. photo Loss:', photoLoss, '. landmarks Loss: ', landmarksLoss.item(), '. regLoss: ', regLoss.item()) - + with open(self.outputDir+'loss_step2_detailed.txt', 'a') as file: + print(f"Iteration [{iter:03d}]: Photo loss [{photoLoss:6f}] landmarks Loss [{landmarksLoss.item():6f}] regLoss: [{regLoss.item():6f}] total [{loss.item():6f}]", end='\r',file=file) + with open(self.outputDir+'loss_step2.txt', 'a') as file: + print(f"Iteration {iter:03d}: Loss {self.rendererName} = {loss.item():6f}", end='\r',file=file) if self.config.debugFrequency > 0 and iter % self.config.debugFrequency == 0: - self.debugFrame(smoothedImage, inputTensor, diffuseTextures, specularTextures, self.pipeline.vRoughness, self.debugDir + 'debug1_iter' + str(iter)) - + self.debugFrame(images[..., 0:3], inputTensor, diff, diffuseTextures, specularTextures, roughTextures, self.debugDir + '/results/'+self.rendererName+'_step2_' + str(iter)) + if self.config.debugOutput : # Generate extra debug information + if self.rendererName == 'vertex': + lightingVertexRender = self.pipeline.render(cameraVerts=cameraVerts, diffAlbedo=diffAlbedo, specAlbedo=specAlbedo, diffuseTextures=diffuseTextures, specularTextures=specularTextures, roughnessTextures=roughTextures, lightingOnly=True) + albedoVertexRender = self.pipeline.render(cameraVerts=cameraVerts, diffAlbedo=diffAlbedo, specAlbedo=specAlbedo, diffuseTextures=diffuseTextures, specularTextures=specularTextures, roughnessTextures=roughTextures, renderAlbedo=True) + debugIteration(images[..., 0:3], inputTensor, diff, albedoVertexRender, lightingVertexRender, self.debugDir + '/results/'+self.rendererName+ str(iter)+'_detailled_step2') # custom made + # also save obj + cameraNormals = self.pipeline.morphableModel.computeNormals(cameraVerts) # only used of obj (might be too slow) + for i in range(inputTensor.shape[0]): + saveObj(self.debugDir + '/mesh/' + self.rendererName+'_step2_iter' + str(iter)+'.obj', + 'material' + str(iter) + '.mtl', + cameraVerts[i], + self.pipeline.faces32, + cameraNormals[i], + self.pipeline.morphableModel.uvMap, + self.debugDir + 'diffuseMap_' + str(self.getTextureIndex(i)) + '.png') + self.plotLoss(losses, 1, self.outputDir + 'checkpoints/stage2_loss.png') self.saveParameters(self.outputDir + 'checkpoints/stage2_output.pickle') def runStep3(self): print("3/3 => finetuning albedos, shape, expression, head pose and scene light...", file=sys.stderr, flush=True) torch.set_grad_enabled(True) - self.pipeline.renderer.samples = 8 inputTensor = torch.pow(self.inputImage.tensor, self.inputImage.gamma) vertices, diffAlbedo, specAlbedo = self.pipeline.morphableModel.computeShapeAlbedo(self.pipeline.vShapeCoeff, self.pipeline.vExpCoeff, self.pipeline.vAlbedoCoeff) @@ -308,31 +351,53 @@ def runStep3(self): vertices, diffAlbedo, specAlbedo = self.pipeline.morphableModel.computeShapeAlbedo(self.pipeline.vShapeCoeff, self.pipeline.vExpCoeff, self.pipeline.vAlbedoCoeff) cameraVerts = self.pipeline.camera.transformVertices(vertices, self.pipeline.vTranslation, self.pipeline.vRotation) - images = self.pipeline.render(cameraVerts, vDiffTextures, vSpecTextures, vRoughTextures) - mask = images[..., 3:] - smoothedImage = smoothImage(images[..., 0:3], self.smoothing) - diff = mask * (smoothedImage - inputTensor).abs() + rgba_img = self.pipeline.render(cameraVerts=cameraVerts,diffAlbedo=diffAlbedo, specAlbedo=specAlbedo, diffuseTextures=vDiffTextures, specularTextures=vSpecTextures, roughnessTextures=vRoughTextures) + mask_alpha = rgba_img[..., 3:] + if self.config.smoothing : + smoothedImage = smoothImage(rgba_img[..., 0:3], self.smoothing) + diff = mask_alpha * (smoothedImage - inputTensor).abs() + else : + diff = mask_alpha * (rgba_img[..., 0:3] - inputTensor).abs() #loss = diff.mean(dim=-1).sum() / float(self.framesNumber) - loss = 1000.0 * diff.mean() - loss += 0.2 * (self.textureLoss.regTextures(vDiffTextures, refDiffTextures, ws = self.config.weightDiffuseSymmetryReg, wr = self.config.weightDiffuseConsistencyReg, wc = self.config.weightDiffuseConsistencyReg, wsm = self.config.weightDiffuseSmoothnessReg, wm = 0.) + \ + photoLoss = 1000.0 * diff.mean() + textureLoss = 0.2 * (self.textureLoss.regTextures(vDiffTextures, refDiffTextures, ws = self.config.weightDiffuseSymmetryReg, wr = self.config.weightDiffuseConsistencyReg, wc = self.config.weightDiffuseConsistencyReg, wsm = self.config.weightDiffuseSmoothnessReg, wm = 0.) + \ self.textureLoss.regTextures(vSpecTextures, refSpecTextures, ws = self.config.weightSpecularSymmetryReg, wr = self.config.weightSpecularConsistencyReg, wc = self.config.weightSpecularConsistencyReg, wsm = self.config.weightSpecularSmoothnessReg, wm = 0.5) + \ self.textureLoss.regTextures(vRoughTextures, refRoughTextures, ws = self.config.weightRoughnessSymmetryReg, wr = self.config.weightRoughnessConsistencyReg, wc = self.config.weightRoughnessConsistencyReg, wsm = self.config.weightRoughnessSmoothnessReg, wm = 0.)) - loss += 0.0001 * self.pipeline.vShCoeffs.pow(2).mean() - loss += self.config.weightExpressionReg * self.regStatModel(self.pipeline.vExpCoeff, self.pipeline.morphableModel.expressionPcaVar) - loss += self.config.weightShapeReg * self.regStatModel(self.pipeline.vShapeCoeff, self.pipeline.morphableModel.shapePcaVar) - loss += self.config.weightLandmarksLossStep3 * self.landmarkLoss(cameraVerts, self.landmarks) - + regLoss = 0.0001 * self.pipeline.vShCoeffs.pow(2).mean() + regLoss += self.config.weightExpressionReg * self.regStatModel(self.pipeline.vExpCoeff, self.pipeline.morphableModel.expressionPcaVar) + regLoss += self.config.weightShapeReg * self.regStatModel(self.pipeline.vShapeCoeff, self.pipeline.morphableModel.shapePcaVar) + regLoss += self.config.weightLandmarksLossStep3 * self.landmarkLoss(cameraVerts, self.landmarks) + loss = photoLoss + textureLoss + regLoss losses.append(loss.item()) loss.backward() optimizer.step() if self.verbose: - print(iter, ' => Loss:', loss.item()) - - if self.config.debugFrequency > 0 and iter % self.config.debugFrequency == 0: - self.debugFrame(smoothedImage, inputTensor, vDiffTextures, vSpecTextures, vRoughTextures, self.debugDir + 'debug2_iter' + str(iter)) + with open(self.outputDir+'loss_step3_detailed.txt', 'a') as file: + print(f"Iteration [{iter:03d}]: Photo loss [{photoLoss:6f}] texture Loss [{textureLoss.item():6f}] regLoss: [{regLoss.item():6f}] total [{loss.item():6f}]", end='\r',file=file) + + with open(self.outputDir+'loss_step3.txt', 'a') as file: + print(iter, ' => Loss:', loss.item(),file=file) + if self.config.debugFrequency > 0 and iter % self.config.debugFrequency == 0: + self.debugFrame(rgba_img[..., 0:3], inputTensor, diff, vDiffTextures, vSpecTextures, vRoughTextures, self.debugDir + '/results/'+self.rendererName+'_step3_' + str(iter)) + if self.config.debugOutput : # Generate extra debug information + if self.rendererName == 'vertex': + lightingVertexRender = self.pipeline.render(cameraVerts=cameraVerts,diffAlbedo=diffAlbedo, specAlbedo=specAlbedo, diffuseTextures=vDiffTextures,specularTextures=vSpecTextures,roughnessTextures=vRoughTextures, lightingOnly=True) + albedoVertexRender = self.pipeline.render(cameraVerts=cameraVerts,diffAlbedo=diffAlbedo, specAlbedo=specAlbedo, diffuseTextures=vDiffTextures,specularTextures=vSpecTextures,roughnessTextures=vRoughTextures, renderAlbedo=True) + debugIteration(rgba_img[..., 0:3], inputTensor,diff, albedoVertexRender, lightingVertexRender, self.debugDir + '/results/'+self.rendererName+ str(iter)+'_detailled_step3') # custom made + # also save obj + cameraNormals = self.pipeline.morphableModel.computeNormals(cameraVerts) # only used of obj (might be too slow) + for i in range(inputTensor.shape[0]): + saveObj(self.debugDir + '/mesh/' + self.rendererName+'_step3_iter' + str(iter)+'.obj', + 'material' + str(iter) + '.mtl', + cameraVerts[i], + self.pipeline.faces32, + cameraNormals[i], + self.pipeline.morphableModel.uvMap, + self.debugDir + 'diffuseMap_' + str(self.getTextureIndex(i)) + '.png') + self.plotLoss(losses, 2, self.outputDir + 'checkpoints/stage3_loss.png') self.vEnhancedDiffuse = vDiffTextures.detach().clone() @@ -341,7 +406,7 @@ def runStep3(self): self.saveParameters(self.outputDir + 'checkpoints/stage3_output.pickle') - def saveOutput(self, samples, outputDir = None, prefix = ''): + def saveOutput(self, outputDir = None, prefix = ''): if outputDir is None: outputDir = self.outputDir mkdir_p(outputDir) @@ -363,13 +428,14 @@ def saveOutput(self, samples, outputDir = None, prefix = ''): vSpecTextures = self.pipeline.morphableModel.generateTextureFromAlbedo(specAlbedo) vRoughTextures = self.pipeline.vRoughness + # update the spp + self.pipeline.renderer.samples = self.config.rtSamples - self.pipeline.renderer.samples = samples - images = self.pipeline.render(None, vDiffTextures, vSpecTextures, vRoughTextures) + images = self.pipeline.render(diffuseTextures=vDiffTextures, specularTextures=vSpecTextures, roughnessTextures=vRoughTextures) - diffuseAlbedo = self.pipeline.render(diffuseTextures=vDiffTextures, renderAlbedo=True) - specularAlbedo = self.pipeline.render(diffuseTextures=vSpecTextures, renderAlbedo=True) - roughnessAlbedo = self.pipeline.render(diffuseTextures=vRoughTextures.repeat(1, 1, 1, 3), renderAlbedo=True) + diffuseAlbedo = self.pipeline.render(diffuseTextures=vDiffTextures, specularTextures=vSpecTextures, renderAlbedo=True) + specularAlbedo = self.pipeline.render(diffuseTextures=vSpecTextures, specularTextures=vSpecTextures, renderAlbedo=True) + roughnessAlbedo = self.pipeline.render(diffuseTextures=vRoughTextures.repeat(1, 1, 1, 3),specularTextures=vSpecTextures, renderAlbedo=True) illum = self.pipeline.render(diffuseTextures=torch.ones_like(vDiffTextures), specularTextures=torch.zeros_like(vDiffTextures)) for i in range(diffuseAlbedo.shape[0]): @@ -387,13 +453,13 @@ def saveOutput(self, samples, outputDir = None, prefix = ''): ext = '.exr' saveImage(envMaps[i], outputDir + '/envMap_' + str(i) + ext) - #saveImage(diffuseAlbedo[self.getTextureIndex(i)], outputDir + prefix + 'diffuse_' + str(self.getTextureIndex(i)) + '.png') - #saveImage(specularAlbedo[self.getTextureIndex(i)], outputDir + prefix + 'specular_' + str(self.getTextureIndex(i)) + '.png') - #saveImage(roughnessAlbedo[self.getTextureIndex(i)], outputDir + prefix + 'roughness_' + str(self.getTextureIndex(i)) + '.png') - #saveImage(illum[i], outputDir + prefix + 'illumination_' + str(i) + '.png') - #saveImage(images[i], outputDir + prefix + 'finalReconstruction_' + str(i) + '.png') + saveImage(diffuseAlbedo[self.getTextureIndex(i)], outputDir + prefix + 'diffuse_' + str(self.getTextureIndex(i)) + '.png') + saveImage(specularAlbedo[self.getTextureIndex(i)], outputDir + prefix + 'specular_' + str(self.getTextureIndex(i)) + '.png') + saveImage(roughnessAlbedo[self.getTextureIndex(i)], outputDir + prefix + 'roughness_' + str(self.getTextureIndex(i)) + '.png') + saveImage(illum[i], outputDir + prefix + 'illumination_' + str(i) + '.png') + saveImage(images[i], outputDir + prefix + 'finalReconstruction_' + str(i) + '.png') overlay = overlayImage(inputTensor[i], images[i]) - #saveImage(overlay, outputDir + '/overlay_' + str(i) + '.png') + saveImage(overlay, outputDir + '/overlay_' + str(i) + '.png') renderAll = torch.cat([torch.cat([inputTensor[i], torch.ones_like(images[i])[..., 3:]], dim = -1), torch.cat([overlay.to(self.device), torch.ones_like(images[i])[..., 3:]], dim = -1), @@ -408,7 +474,11 @@ def saveOutput(self, samples, outputDir = None, prefix = ''): saveImage(vSpecTextures[self.getTextureIndex(i)], outputDir + prefix + 'specularMap_' + str(self.getTextureIndex(i)) + '.png') saveImage(vRoughTextures[self.getTextureIndex(i)].repeat(1, 1, 3), outputDir + prefix + 'roughnessMap_' + str(self.getTextureIndex(i)) + '.png') - def run(self, imagePathOrDir, sharedIdentity = False, checkpoint = None, doStep1 = True, doStep2 = True, doStep3 = True): + # revert spp + self.pipeline.renderer.samples = self.config.rtTrainingSamples + + + def run(self, imagePathOrDir, sharedIdentity = False, checkpoint = None, doStep1 = True, doStep2 = True, doStep3 = True, rendererName= 'mitsuba'): ''' run optimization on given path (can be a directory that contains images with same resolution or a direct path to an image) :param imagePathOrDir: a path to a directory or image @@ -419,30 +489,39 @@ def run(self, imagePathOrDir, sharedIdentity = False, checkpoint = None, doStep1 :param doStep3: if True do stage 3 optim ( refine albedos) :return: ''' - + self.rendererName = rendererName + self.pipeline.reloadRenderer(rendererName) # load the appropriate renderer self.setImage(imagePathOrDir, sharedIdentity) assert(self.framesNumber >= 1) #could not load any image from path + if self.rendererName == 'mitsuba' and self.framesNumber > 1 : + print("batch rendering is not implemented on Mitsuba") + sys.exit() if checkpoint is not None and checkpoint != '': print('resuming optimization from checkpoint: ',checkpoint, file=sys.stderr, flush=True) self.loadParameters(checkpoint) - + print('running with ' + self.rendererName) import time start = time.time() if doStep1: self.runStep1() if self.config.saveIntermediateStage: - self.saveOutput(self.config.rtSamples, self.outputDir + '/outputStage1', prefix='stage1_') + self.saveOutput(self.outputDir + '/outputStage1', prefix='stage1_') if doStep2: self.runStep2() if self.config.saveIntermediateStage: - self.saveOutput(self.config.rtSamples, self.outputDir + '/outputStage2', prefix='stage2_') + self.saveOutput(self.outputDir + '/outputStage2', prefix='stage2_') if doStep3: self.runStep3() end = time.time() - print("took {:.2f} minutes to optimize".format((end - start) / 60.), file=sys.stderr, flush=True) - self.saveOutput(self.config.rtSamples, self.outputDir) + timeMsg = "took {:.2f} minutes to optimize".format((end - start) / 60.) + print(timeMsg, file=sys.stderr, flush=True) + if self.config.saveTime : + with open(self.outputDir+'timeTaken.txt', 'a') as file: + print(timeMsg, file=file) + self.saveOutput(self.outputDir) + torch.cuda.empty_cache() if __name__ == "__main__": @@ -492,4 +571,5 @@ def run(self, imagePathOrDir, sharedIdentity = False, checkpoint = None, doStep1 checkpoint= checkpoint, doStep1= doStep1, doStep2 = doStep2, - doStep3= doStep3) \ No newline at end of file + doStep3= doStep3, + rendererName=config.rendererName) \ No newline at end of file diff --git a/output/defaultoutput b/output/defaultoutput deleted file mode 100644 index e69de29..0000000 diff --git a/pipeline.py b/pipeline.py index 57d987e..fbc27b1 100644 --- a/pipeline.py +++ b/pipeline.py @@ -1,12 +1,12 @@ +from renderers.renderer import * from sphericalharmonics import SphericalHarmonics from morphablemodel import MorphableModel -from renderer import Renderer from camera import Camera from utils import * class Pipeline: - def __init__(self, config): + def __init__(self, config, rendererName = ''): ''' a pipeline can generate and render textured faces under different camera angles and lighting conditions :param config: configuration file used to parameterize the pipeline @@ -29,7 +29,7 @@ def __init__(self, config): landmarksPathName=pathLandmarksAssociation, device = self.device ) - self.renderer = Renderer(config.rtTrainingSamples, 1, self.device) + self.renderer = self.reloadRenderer(rendererName) self.uvMap = self.morphableModel.uvMap.clone() self.uvMap[:, 1] = 1.0 - self.uvMap[:, 1] self.faces32 = self.morphableModel.faces.to(torch.int32).contiguous() @@ -95,19 +95,17 @@ def transformVertices(self, vertices = None): transformedVertices = self.camera.transformVertices(vertices, self.vTranslation, self.vRotation) return transformedVertices - def render(self, cameraVerts = None, diffuseTextures = None, specularTextures = None, roughnessTextures = None, renderAlbedo = False): - ''' - ray trace an image given camera vertices and corresponding textures - :param cameraVerts: camera vertices tensor [n, verticesNumber, 3] - :param diffuseTextures: diffuse textures tensor [n, texRes, texRes, 3] - :param specularTextures: specular textures tensor [n, texRes, texRes, 3] - :param roughnessTextures: roughness textures tensor [n, texRes, texRes, 1] - :param renderAlbedo: if True render albedo else ray trace image - :return: ray traced images [n, resX, resY, 4] - ''' + # generic render method + def render(self, cameraVerts = None, diffAlbedo = None, specAlbedo = None, diffuseTextures = None, specularTextures = None, roughnessTextures = None, renderAlbedo= False, lightingOnly=False): + if cameraVerts is None: - vertices, diffAlbedo, specAlbedo = self.morphableModel.computeShapeAlbedo(self.vShapeCoeff, self.vExpCoeff, self.vAlbedoCoeff) + vertices = self.morphableModel.computeShape(self.vShapeCoeff, self.vExpCoeff) cameraVerts = self.camera.transformVertices(vertices, self.vTranslation, self.vRotation) + if diffAlbedo is None : + diffAlbedo = self.morphableModel.computeDiffuseAlbedo(self.vAlbedoCoeff) + if specAlbedo is None: + specAlbedo = self.morphableModel.computeSpecularAlbedo( self.vAlbedoCoeff) + #compute normals normals = self.morphableModel.meshNormals.computeNormals(cameraVerts) @@ -121,24 +119,13 @@ def render(self, cameraVerts = None, diffuseTextures = None, specularTextures = if roughnessTextures is None: roughnessTextures = self.vRoughness - envMaps = self.sh.toEnvMap(self.vShCoeffs) - - assert(envMaps.dim() == 4 and envMaps.shape[-1] == 3) assert (cameraVerts.dim() == 3 and cameraVerts.shape[-1] == 3) assert (diffuseTextures.dim() == 4 and diffuseTextures.shape[1] == diffuseTextures.shape[2] == self.morphableModel.getTextureResolution() and diffuseTextures.shape[-1] == 3) assert (specularTextures.dim() == 4 and specularTextures.shape[1] == specularTextures.shape[2] == self.morphableModel.getTextureResolution() and specularTextures.shape[-1] == 3) assert (roughnessTextures.dim() == 4 and roughnessTextures.shape[1] == roughnessTextures.shape[2] == self.morphableModel.getTextureResolution() and roughnessTextures.shape[-1] == 1) - assert(cameraVerts.shape[0] == envMaps.shape[0]) assert (diffuseTextures.shape[0] == specularTextures.shape[0] == roughnessTextures.shape[0]) - scenes = self.renderer.buildScenes(cameraVerts, self.faces32, normals, self.uvMap, diffuseTextures, - specularTextures, torch.clamp(roughnessTextures, 1e-20, 10.0), self.vFocals, envMaps) - if renderAlbedo: - images = self.renderer.renderAlbedo(scenes) - else: - images = self.renderer.render(scenes) - - return images + return self.renderer.render(cameraVerts, self.faces32, normals, self.uvMap, diffAlbedo, torch.clamp(diffuseTextures, 1e-20, 1.0), torch.clamp(specularTextures, 1e-20, 1.0), torch.clamp(roughnessTextures, 1e-20, 10.0), self.vShCoeffs, self.sh, self.vFocals, renderAlbedo, lightingOnly) def landmarkLoss(self, cameraVertices, landmarks, focals, cameraCenters, debugDir = None): ''' @@ -167,4 +154,23 @@ def landmarkLoss(self, cameraVertices, landmarks, focals, cameraCenters, debugD image = saveLandmarksVerticesProjections(self.inputImage.tensor[i], projPoints[i], self.landmarks[i]) cv2.imwrite(debugDir + '/lp' + str(i) +'.png', cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) - return loss \ No newline at end of file + return loss + + def reloadRenderer(self, rendererName): + if rendererName == 'redner': + from renderers.rendererRedner import RendererRedner + self.renderer = RendererRedner(self.config.rtTrainingSamples, self.config.bounces, self.device, self.config.maxResolution, self.config.maxResolution) + elif rendererName == 'mitsuba': + from renderers.rendererMitsuba import RendererMitsuba + self.renderer = RendererMitsuba(self.config.rtTrainingSamples, self.config.bounces, self.device, self.config.maxResolution, self.config.maxResolution) + elif rendererName == 'vertex': + from renderers.rendererVertexBased import RendererVertexBased + self.renderer = RendererVertexBased(self.device, self.config.maxResolution, self.config.maxResolution) + else : + # check config file as last resort + rendererName == self.config.rendererName + if rendererName in ['redner','mitsuba','vertex'] : + self.reloadRenderer(rendererName) + else: + self.renderer = Renderer() + \ No newline at end of file diff --git a/plugins/__init__.py b/plugins/__init__.py new file mode 100644 index 0000000..483b0fb --- /dev/null +++ b/plugins/__init__.py @@ -0,0 +1,7 @@ +import mitsuba as mi + +from plugins.bsdfs.rednermat import RednerMat +# from plugins.bsdfs.mitsubaBSDF import MitsubaBSDF +# BSDFs +mi.register_bsdf("rednermat", lambda props: RednerMat(props)) +# mi.register_bsdf("mitsubaBSDF", lambda props: MitsubaBSDF(props)) diff --git a/plugins/bsdfs/rednermat.py b/plugins/bsdfs/rednermat.py new file mode 100644 index 0000000..6b93023 --- /dev/null +++ b/plugins/bsdfs/rednermat.py @@ -0,0 +1,150 @@ +import numpy as np +import mitsuba as mi +import drjit as dr +import math +from typing import Tuple + +# Redner material implementation inside Mitsuba +# We are assuming all component used +class RednerMat(mi.BSDF): + def __init__(self, props: mi.Properties) -> None: + super().__init__(props) + + self.albedo = props.get("albedo", mi.Texture.D65(0.1)) + self.roughness = props.get("roughness", mi.Texture.D65(0.1)) + self.specular = props.get("specular", mi.Texture.D65(0.1)) + + self.m_components += [mi.BSDFFlags.DiffuseReflection | mi.BSDFFlags.FrontSide] + self.m_components += [mi.BSDFFlags.GlossyReflection | mi.BSDFFlags.FrontSide] + self.m_flags = self.m_components[0] | self.m_components[1] + + def roughness_to_phong(roughness: mi.Float) -> mi.Float: + return dr.maximum(2.0 / roughness - 2, 0) + + def smithG1(roughness: mi.Float, v: mi.Vector3f) -> mi.Float: + cos_theta = v.z + # tan^2 + 1 = 1/cos^2 + tan_theta = dr.safe_sqrt(dr.rcp(cos_theta * cos_theta) - 1.0) + + a = dr.rcp(dr.sqrt(roughness) * tan_theta) + result = dr.select( + a > 1.6, 1, + (3.535 * a + 2.181 * a * a) / (1.0 + 2.276 * a + 2.577 * a*a) + ) + return dr.select(dr.eq(tan_theta,0.0), 1, result) + + def eval(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f, active: bool = True) -> mi.Color3f: + has_diffuse = ctx.is_enabled(mi.BSDFFlags.DiffuseReflection, 0) + has_specular = ctx.is_enabled(mi.BSDFFlags.GlossyReflection, 1) + + # Calcul contribution diffuse + diffuse_contrib = dr.select(has_diffuse, self.albedo.eval(si, active) * dr.maximum(wo.z, 0.0) / mi.Float(math.pi), 0.0) + + # Calcul contribution speculaire + m = dr.normalize(si.wi + wo) + roughness = dr.maximum(self.roughness.eval_1(si, active),0.00001) + phong_exponent = RednerMat.roughness_to_phong(roughness) + specular_reflectance = self.specular.eval(si, active) + + D = dr.power(dr.maximum(m.z, 0.0), phong_exponent) * (phong_exponent + 2.0) / mi.Float(2.0 * math.pi) + G = RednerMat.smithG1(roughness, si.wi) * RednerMat.smithG1(roughness, wo) + F = specular_reflectance + (1 - specular_reflectance) * dr.power(dr.maximum(1 - dr.abs(dr.dot(m, wo)), 0), 5) + specular_contrib = dr.select(wo.z > 0, F * D * G / (4.0 * si.wi.z), 0) + specular_contrib = dr.select(has_specular, specular_contrib, 0) + + return specular_contrib + diffuse_contrib + + + def pdf(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f, active: bool = True) -> float: + has_diffuse = ctx.is_enabled(mi.BSDFFlags.DiffuseReflection, 0) + has_specular = ctx.is_enabled(mi.BSDFFlags.GlossyReflection, 1) + + # Compute the probability of selecting the diffuse and specular lobe + diffuse_pmf = mi.luminance(self.albedo.eval(si, active)) + specular_pmf = mi.luminance(self.specular.eval(si, active)) + weight_pmf = diffuse_pmf + specular_pmf + diffuse_pmf = dr.select(weight_pmf > 0.0, diffuse_pmf / weight_pmf, 0.0) + specular_pmf = dr.select(weight_pmf > 0.0, specular_pmf / weight_pmf, 0.0) + + if(dr.neq(has_diffuse, has_specular)): + diffuse_pmf = dr.select(has_diffuse, 1.0, 0.0) + specular_pmf = dr.select(has_diffuse, 0.0, 1.0) + + # Compute diffuse PDF + diffuse_pdf = mi.warp.square_to_cosine_hemisphere_pdf(wo) * diffuse_pmf + + # Compute specular PDF + m = dr.normalize(si.wi + wo) + roughness = dr.maximum(self.roughness.eval_1(si, active),0.00001) + phong_exponent = RednerMat.roughness_to_phong(roughness) + D = dr.power(dr.maximum(m.z, 0.0), phong_exponent) * (phong_exponent + 2.0) / mi.Float(2 * math.pi) + specular_pdf = dr.select(dr.abs(dr.dot(m, wo)) > 0, specular_pmf * D * dr.maximum(m.z, 0.0) / (4.0 * dr.abs(dr.dot(m, wo))), 0.0) + + return dr.select(wo.z > 0, diffuse_pdf + specular_pdf, 0) + + def eval_pdf(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, wo: mi.Vector3f, active: bool = True) -> Tuple[mi.Color3f, mi.Float]: + # TODO: Could be more efficient by fusing some computations + return self.eval(ctx, si, wo, active), self.pdf(ctx, si, wo, active) + + def sample(self, ctx: mi.BSDFContext, si: mi.SurfaceInteraction3f, sample1: mi.Float, sample2: mi.Point2f, active: bool = True) -> Tuple[mi.BSDFSample3f, mi.Color3f]: + has_diffuse = ctx.is_enabled(mi.BSDFFlags.DiffuseReflection, 0) + has_specular = ctx.is_enabled(mi.BSDFFlags.GlossyReflection, 1) + + # Compute PDF selection + diffuse_pmf = mi.luminance(self.albedo.eval(si, active)) + specular_pmf = mi.luminance(self.specular.eval(si, active)) + weight_pmf = diffuse_pmf + specular_pmf + diffuse_pmf = dr.select(weight_pmf > 0.0, diffuse_pmf / weight_pmf, 0.0) + specular_pmf = dr.select(weight_pmf > 0.0, specular_pmf / weight_pmf, 0.0) + + if(dr.neq(has_diffuse, has_specular)): + diffuse_pmf = dr.select(has_diffuse, 1.0, 0.0) + specular_pmf = dr.select(has_diffuse, 0.0, 1.0) + + + # Compute masks + diffuse_mask = diffuse_pmf < sample1 + specular_mask = ~diffuse_mask + + # Example to do specular and diffuse sampling + # https://github.com/mitsuba-renderer/mitsuba3/blob/6105dfc1057a3bc204393b8e9557bcb26e08568b/src/bsdfs/pplastic.cpp#L243C9-L256C10 + # Uses a lot of masks + bs: mi.BSDFSample3f = dr.zeros(mi.BSDFSample3f) + bs.eta = 1 + + + #if dr.any(diffuse_mask): + bs.wo[diffuse_mask] = mi.warp.square_to_cosine_hemisphere(sample2) + bs.sampled_type[diffuse_mask] = +mi.BSDFFlags.DiffuseReflection + bs.sampled_component[diffuse_mask] = 0 + + roughness = dr.maximum(self.roughness.eval_1(si, active),0.00001) + phong_exponent = RednerMat.roughness_to_phong(roughness) + phi = 2.0 * math.pi * sample2[1] + sin_phi = dr.sin(phi) + cos_phi = dr.cos(phi) + cos_theta = dr.power(sample2[0], dr.rcp(phong_exponent + 2.0)) + sin_theta = dr.safe_sqrt(1.0 - cos_theta * cos_theta) + m = mi.Vector3f(sin_theta * cos_phi, sin_theta * sin_phi, cos_theta) + bs.wo[specular_mask] = mi.reflect(si.wi, m) + bs.sampled_type[specular_mask] = +mi.BSDFFlags.GlossyReflection + bs.sampled_component[specular_mask] = 1 + + # Compute PDF + bs.pdf = self.pdf(ctx, si, bs.wo, active) + active &= bs.pdf > 0.0 + result = self.eval(ctx, si, bs.wo, active) + + return (bs, result / bs.pdf & active) + + def to_string(self): + return ('RednerMat[\n' + ' albedo=%s,\n' + ' roughness=%s,\n' + ' specular=%s,\n' + ']' % (self.albedo, self.roughness, self.specular)) + + def traverse(self, callback): + callback.put_object('albedo', self.albedo, mi.ParamFlags.Differentiable) + callback.put_object('roughness', self.roughness, mi.ParamFlags.Differentiable ) + callback.put_object('specular', self.specular, mi.ParamFlags.Differentiable) \ No newline at end of file diff --git a/projection.py b/projection.py index 28f0e33..ef8a897 100644 --- a/projection.py +++ b/projection.py @@ -9,7 +9,7 @@ def isRotationMatrix(R): """ if R.ndim != 2 or R.shape[0] != R.shape[1]: return False - isIdentity = np.allclose(R.dot(R.T), np.identity(R.shape[0], np.float)) + isIdentity = np.allclose(R.dot(R.T), np.identity(R.shape[0], float)) isDetEqualToOne = np.allclose(np.linalg.det(R), 1) return isIdentity and isDetEqualToOne diff --git a/renderer.py b/renderer.py deleted file mode 100644 index 438e1ef..0000000 --- a/renderer.py +++ /dev/null @@ -1,157 +0,0 @@ -import torch -import math -import pyredner -import redner -import random - -from pyredner import set_print_timing - - -def rayTrace(scene, - channels, - max_bounces = 1, - sampler_type = pyredner.sampler_type.sobol, - num_samples = 8, - seed = None, - sample_pixel_center = False, - device = None): - if device is None: - device = pyredner.get_device() - - assert(isinstance(scene, list)) - if seed == None: - # Randomly generate a list of seed - seed = [] - for i in range(len(scene)): - seed.append(random.randint(0, 16777216)) - assert(len(seed) == len(scene)) - # Render each scene in the batch and stack them together - imgs = [] - for sc, se in zip(scene, seed): - scene_args = pyredner.RenderFunction.serialize_scene(\ - scene = sc, - num_samples = num_samples, - max_bounces = max_bounces, - sampler_type = sampler_type, - channels = channels, - use_primary_edge_sampling=False, - use_secondary_edge_sampling=False, - sample_pixel_center = sample_pixel_center, - device = device) - imgs.append(pyredner.RenderFunction.apply(se, *scene_args)) - imgs = torch.stack(imgs) - return imgs - -def renderPathTracing(scene, - channels= None, - max_bounces = 1, - num_samples = 8, - device = None): - if channels is None: - channels = [redner.channels.radiance] - channels.append(redner.channels.alpha) - #if alpha: - # channels.append(redner.channels.alpha) - return rayTrace(scene=scene, - channels=channels, - max_bounces=max_bounces, - sampler_type=pyredner.sampler_type.independent, - num_samples=num_samples, - seed = None, - sample_pixel_center=False, - device=device) - -class Renderer: - - def __init__(self, samples, bounces, device): - set_print_timing(False) #disable redner logs - self.samples = samples - self.bounces = bounces - self.device = torch.device(device) - self.clip_near = 10.0 - self.upVector = torch.tensor([0.0, -1.0, 0.0]) - self.counter = 0 - self.screenWidth = 256 - self.screenHeight = 256 - - def setupCamera(self, focal, image_width, image_height): - - fov = torch.tensor([360.0 * math.atan(image_width / (2.0 * focal)) / math.pi]) # calculate camera field of view from image size - - cam = pyredner.Camera( - position = torch.tensor([0.0, 0.0, 0.0]), - look_at = torch.tensor([0.0, 0.0, 1.0]), - up = self.upVector, - fov = fov.cpu(), - clip_near = self.clip_near, - cam_to_world = None , - resolution = (image_height, image_width)) - - return cam - - def buildScenes(self, vertices, indices, normal, uv, diffuse, specular, roughness, focal, envMap): - ''' - build multiple pyredner scenes used for path tracing (uv mapping and indices are the same for all scenes) - :param vertices: [n, verticesNumber, 3] - :param indices: [indicesNumber, 3] - :param normal: [n, verticesNumber, 3] - :param uv: [verticesNumber, 2] - :param diffuse: [n, resX, resY, 3] or [1, resX, resY, 3] - :param specular: [n, resX, resY, 3] or [1, resX, resY, 3] - :param roughness: [n, resX, resY, 1] or [1, resX, resY, 3] - :param focal: [n] - :param envMap: [n, resX, resY, 3] - :return: return list of pyredner scenes - ''' - assert(vertices.dim() == 3 and vertices.shape[-1] == 3 and normal.dim() == 3 and normal.shape[-1] == 3) - assert (indices.dim() == 2 and indices.shape[-1] == 3) - assert (uv.dim() == 2 and uv.shape[-1] == 2) - assert (diffuse.dim() == 4 and diffuse.shape[-1] == 3 and - specular.dim() == 4 and specular.shape[-1] == 3 and - roughness.dim() == 4 and roughness.shape[-1] == 1) - assert(focal.dim() == 1) - assert(envMap.dim() == 4 and envMap.shape[-1] == 3) - assert(vertices.shape[0] == focal.shape[0] == envMap.shape[0]) - assert(diffuse.shape[0] == specular.shape[0] == roughness.shape[0]) - assert (diffuse.shape[0] == 1 or diffuse.shape[0] == vertices.shape[0]) - sharedTexture = True if diffuse.shape[0] == 1 else False - - scenes = [] - for i in range(vertices.shape[0]): - texIndex = 0 if sharedTexture else i - mat = pyredner.Material(pyredner.Texture(diffuse[texIndex]), - pyredner.Texture(specular[texIndex]) if specular is not None else None, - pyredner.Texture(roughness[texIndex]) if roughness is not None else None) - obj = pyredner.Object(vertices[i], indices, mat, uvs=uv, normals=normal[i] if normal is not None else None) - cam = self.setupCamera(focal[i], self.screenWidth, self.screenHeight) - scene = pyredner.Scene(cam, materials=[mat], objects=[obj], envmap=pyredner.EnvironmentMap(envMap[i])) - scenes.append(scene) - - return scenes - - def renderAlbedo(self, scenes): - ''' - render albedo of given pyredner scenes - :param scenes: list of pyredner scenes - :return: albedo images [n, screenWidth, screenHeight, 4] - ''' - #images =pyredner.render_albedo(scenes, alpha = True, num_samples = self.samples, device = self.device) - images = renderPathTracing(scenes, - channels= [pyredner.channels.diffuse_reflectance, pyredner.channels.alpha], - max_bounces = 0, - num_samples = self.samples , - device = self.device) - return images - - def render(self, scenes): - ''' - render scenes with ray tracing - :param scenes: list of pyredner scenes - :return: ray traced images [n, screenWidth, screenHeight, 4] - ''' - images = renderPathTracing(scenes, - max_bounces = self.bounces, - num_samples = self.samples , - device = self.device) - self.counter += 1 - return images \ No newline at end of file diff --git a/renderers/renderer.py b/renderers/renderer.py new file mode 100644 index 0000000..f7e4edf --- /dev/null +++ b/renderers/renderer.py @@ -0,0 +1,4 @@ +class Renderer: + def render(self, *args, **kwargs): + raise NotImplementedError("Assign a valid renderer") + diff --git a/renderers/rendererMitsuba.py b/renderers/rendererMitsuba.py new file mode 100644 index 0000000..102fc43 --- /dev/null +++ b/renderers/rendererMitsuba.py @@ -0,0 +1,180 @@ +import drjit as dr +import mitsuba as mi +import torch +from renderers.renderer import Renderer +from mitsuba.scalar_rgb import Transform4f as T + +mi.set_variant('cuda_ad_rgb') +# mi.set_log_level(mi.LogLevel.Debug) +# mi.DEBUG = True +# dr.set_flag(dr.JitFlag.VCallRecord, False) +# dr.set_flag(dr.JitFlag.LoopRecord, False) +from plugins import * +class RendererMitsuba(Renderer): + + def __init__(self, samples, bounces, device, screenWidth, screenHeight): + self.samples = samples + self.bounces = bounces + assert(device == 'cuda') # 'we only support GPU computation on mitsuba' + self.device = torch.device(device) + self.counter = 0 + self.screenWidth = screenWidth + self.screenHeight = screenHeight + dr.set_device(0) + self.scene = self.buildInitialScene() # init my scene + + def buildInitialScene(self): + """ + generate a placeholder scene where we assign default values that will be updated at runtime + ** make sure the mitsuba_default folder ** is properly placed in the output folder + Returns: + scene (python dictionnary): mitsuba scene object + """ + # generate blank textures + # [resX, resY, 3] + blankTexture = torch.empty((self.screenWidth, self.screenHeight, 3), device=self.device) + bitmapTexture = mi.util.convert_to_bitmap(blankTexture) + m_bsdf = mi.load_dict({ + 'type': 'rednermat', + 'albedo': { + 'type': 'bitmap', + 'bitmap': bitmapTexture + }, + 'roughness':{ + 'type': 'bitmap', + 'bitmap': bitmapTexture + + }, + 'specular':{ + 'type': 'bitmap', + 'bitmap': bitmapTexture + + } + }) + # Create scene + self.scene = mi.load_dict({ + 'type': 'scene', + 'integrator': { + 'type':'aov', + 'aovs':'dd.y:depth', + 'my_image':{ + 'type':'direct_reparam' + } + }, + 'sensor': { + 'type': 'perspective', + 'fov': 5, + 'to_world': T.look_at( + origin=(0, 0, 0), + target=(0, 0, 1), + up=(0., -1, 0.) + ), + 'film': { + 'type': 'hdrfilm', + 'filter':{ + 'type':'box' + }, + 'width': self.screenWidth, + 'height': self.screenHeight, + 'pixel_format':'rgba', + 'sample_border':True, + }, + }, + "mesh":{ + "type": "obj", + "filename": "./output/mitsuba_default/mesh0.obj", + "face_normals": True, + 'bsdf': m_bsdf + }, + 'light': { + 'type': 'envmap', + 'bitmap': bitmapTexture + } + }) + return self.scene + + # STANDALONE because of wrap_ad + @dr.wrap_ad(source='torch', target='drjit') + def render_torch_djit(scene, vertices, indices, normals, uv, diffuseTexture, specularTexture, roughnessTexture, fov, envMaps, spp=8, seed=1): + """ + Standalone function that converts torch computations in mitsuba's drjit computations. + This wrapper handles the propagation of the gradients directly. + We also update the values of our mitsuba scene with the values passed as inputs + Args : + scene : Mitsuba scene object + vertices (B, N, 3): vertices tensor + indices (indices number,3): indices of the morphable model + normals (B, N, 3): normals of our vertices + uv (N, 3): uv map + diffuseTexture (B, resX, resY, 3) or (1, resX, resY, 3): diffuse textures for all our images + specularTexture (B, resX, resY, 3) or (1, resX, resY, 3): specular textures for all our images + roughnessTexture (B, resX, resY, 3) or (1, resX, resY, 3): roughness textures for all our images + fov (B) : field of view + envMaps (B, resX, resY, 3) : environment map for the scene based on the shCoeffs + spp int : number of samples + seed int : seed number + Returns: + image [B, resX, resY, 9]: image with 9 channels (3 rgb + 5 depth) + """ + params = mi.traverse(scene) + params["sensor.x_fov"] = fov + # update mesh params + params["mesh.vertex_positions"] = dr.ravel(mi.TensorXf(vertices)) + params["mesh.faces"] = dr.ravel(mi.TensorXf(indices)) + params["mesh.vertex_normals"] = dr.ravel(mi.TensorXf(normals)) + params["mesh.vertex_texcoords"] = dr.ravel(mi.TensorXf(uv)) + # update BSDF + # https://mitsuba.readthedocs.io/en/stable/src/generated/plugins_bsdfs.html#smooth-diffuse-material-diffuse + # RednerMat + params["mesh.bsdf.albedo.data"] = mi.TensorXf(dr.clip(diffuseTexture, 0, 1)) + params["mesh.bsdf.specular.data"] = mi.TensorXf(dr.clip(specularTexture, 0, 1)) + params["mesh.bsdf.roughness.data"] = mi.TensorXf(dr.clip(roughnessTexture, 0.00001, 10.0)) + #update envMaps + params["light.data"] = mi.TensorXf(envMaps) + params.update() + img = mi.render(scene, params, spp=spp, seed=seed, seed_grad=seed+1) + return img + + # overloading this method + + def render(self, cameraVertices, indices, normals, uv, diffAlbedo, diffuseTexture, specularTexture, roughnessTexture, shCoeffs, sphericalHarmonics, focals, renderAlbedo=False, lightingOnly=False): + """ + middle function between pytorch and mitsuba, we take the tensor values from our pipeline and give it to our standalone wrapper + + Args: + vertices (B, N, 3): vertices tensor + indices (indices number,3): indices of the morphable model + normals (B, N, 3): normals of our vertices + uv (N, 3): uv map + diffAlbedo (B, N, 3) : diffuse albedo from coefficients + diffuseTexture (B, resX, resY, 3) or (1, resX, resY, 3): diffuse textures for all our images + specularTexture (B, resX, resY, 3) or (1, resX, resY, 3): specular textures for all our images + roughnessTexture (B, resX, resY, 3) or (1, resX, resY, 3): roughness textures for all our images + shCoeffs (B, sh order ^2,3) : sh coefficients + sphericalHarmonics : SH class object that helps us to do envMap conversions + focals (B): focals for our scenes + renderAlbedo bool : render only with albedo + lightingOnly bool : render only the lighting impact + + Returns: + images (B, resX, resY, 4): the renders based on our inputs + """ + envMap = sphericalHarmonics.toEnvMap(shCoeffs) + assert(envMap.dim() == 4 and envMap.shape[-1] == 3) + assert(cameraVertices.shape[0] == envMap.shape[0]) + + self.fov = torch.tensor([360.0 * torch.atan(self.screenWidth / (2.0 * focals)) / torch.pi]) # from renderer.py + + img = RendererMitsuba.render_torch_djit(self.scene, cameraVertices.squeeze(0), indices.to(torch.float32), normals.squeeze(0), uv, diffuseTexture.squeeze(0), specularTexture.squeeze(0), roughnessTexture.squeeze(0), self.fov.item(), envMap.squeeze(0),self.samples) # returns a pytorch + rgb_channels = img[..., :3] + #debug alpha + mask_alpha = img[..., 4:] # only take the last channel ? + # Create a binary mask based on a condition (e.g., depth_mean > threshold) + threshold = 0.9 # Adjust the threshold as needed + depth_mean = torch.mean(mask_alpha, axis=-1, keepdim=True) + mask_alpha = (depth_mean > threshold).float() + # Concatenate the RGB channels with the binary mask to create the final image + final_image = torch.cat((rgb_channels, mask_alpha), dim=-1).unsqueeze(0) + + return final_image + \ No newline at end of file diff --git a/renderers/rendererRedner.py b/renderers/rendererRedner.py new file mode 100644 index 0000000..4125b6f --- /dev/null +++ b/renderers/rendererRedner.py @@ -0,0 +1,200 @@ +import torch +import math +import pyredner +import redner +import random + +from pyredner import set_print_timing +from renderers.renderer import Renderer + + +def rayTrace(scene, + channels, + max_bounces = 1, + sampler_type = pyredner.sampler_type.sobol, + num_samples = 8, + seed = None, + sample_pixel_center = False, + device = None): + if device is None: + device = pyredner.get_device() + + assert(isinstance(scene, list)) + if seed == None: + # Randomly generate a list of seed + seed = [] + for i in range(len(scene)): + seed.append(random.randint(0, 16777216)) + assert(len(seed) == len(scene)) + # Render each scene in the batch and stack them together + imgs = [] + for sc, se in zip(scene, seed): + scene_args = pyredner.RenderFunction.serialize_scene(\ + scene = sc, + num_samples = num_samples, + max_bounces = max_bounces, + sampler_type = sampler_type, + channels = channels, + use_primary_edge_sampling=False, + use_secondary_edge_sampling=False, + sample_pixel_center = sample_pixel_center, + device = device) + imgs.append(pyredner.RenderFunction.apply(se, *scene_args)) + imgs = torch.stack(imgs) + return imgs + +def renderPathTracing(scene, + channels= None, + max_bounces = 1, + num_samples = 8, + device = None): + if channels is None: + channels = [redner.channels.radiance] + channels.append(redner.channels.alpha) + #if alpha: + # channels.append(redner.channels.alpha) + return rayTrace(scene=scene, + channels=channels, + max_bounces=max_bounces, + sampler_type=pyredner.sampler_type.independent, + num_samples=num_samples, + seed = None, + sample_pixel_center=False, + device=device) + +class RendererRedner(Renderer): + + def __init__(self, samples, bounces, device, screenWidth, screenHeight): + set_print_timing(False) #disable redner logs + self.samples = samples + self.bounces = bounces + self.device = torch.device(device) + self.clip_near = 10.0 + self.upVector = torch.tensor([0.0, -1.0, 0.0]) + self.counter = 0 + self.screenWidth = screenWidth + self.screenHeight = screenHeight + + def setupCamera(self, focal, image_width, image_height): + + fov = torch.tensor([360.0 * math.atan(image_width / (2.0 * focal)) / math.pi]) # calculate camera field of view from image size + + cam = pyredner.Camera( + position = torch.tensor([0.0, 0.0, 0.0]), + look_at = torch.tensor([0.0, 0.0, 1.0]), + up = self.upVector, + fov = fov.cpu(), + clip_near = self.clip_near, + cam_to_world = None , + resolution = (image_height, image_width)) + + return cam + + def buildScenes(self, vertices, indices, normals, uv, diffuseTexture, specularTexture, roughnessTexture, focal, envMaps): + ''' + build multiple pyredner scenes used for path tracing (uv mapping and indices are the same for all scenes) + Args: + vertices (B, N, 3): vertices tensor + indices (indices number,3): indices of the morphable model + normals (B, N, 3): normals of our vertices + uv (N, 3): uv map + diffuseTexture (B, resX, resY, 3) or (1, resX, resY, 3): diffuse textures for all our images + specularTexture (B, resX, resY, 3) or (1, resX, resY, 3): specular textures for all our images + roughnessTexture (B, resX, resY, 3) or (1, resX, resY, 3): roughness textures for all our images + focal [B]: focals for our scenes + envMaps (B, resX, resY, 3) : envMap textures for all our images + + Returns: + images [B, resX, resY, 4]: the renders based on our inputs + ''' + assert(vertices.dim() == 3 and vertices.shape[-1] == 3 and normals.dim() == 3 and normals.shape[-1] == 3) + assert (indices.dim() == 2 and indices.shape[-1] == 3) + assert (uv.dim() == 2 and uv.shape[-1] == 2) + assert (diffuseTexture.dim() == 4 and diffuseTexture.shape[-1] == 3 and + specularTexture.dim() == 4 and specularTexture.shape[-1] == 3 and + roughnessTexture.dim() == 4 and roughnessTexture.shape[-1] == 1) + assert(focal.dim() == 1) + assert(envMaps.dim() == 4 and envMaps.shape[-1] == 3) + assert(vertices.shape[0] == focal.shape[0] == envMaps.shape[0]) + assert(diffuseTexture.shape[0] == specularTexture.shape[0] == roughnessTexture.shape[0]) + assert (diffuseTexture.shape[0] == 1 or diffuseTexture.shape[0] == vertices.shape[0]) + sharedTexture = True if diffuseTexture.shape[0] == 1 else False + + scenes = [] + for i in range(vertices.shape[0]): + texIndex = 0 if sharedTexture else i + mat = pyredner.Material(pyredner.Texture(diffuseTexture[texIndex]), + pyredner.Texture(specularTexture[texIndex]) if specularTexture is not None else None, + pyredner.Texture(roughnessTexture[texIndex]) if roughnessTexture is not None else None) + obj = pyredner.Object(vertices[i], indices, mat, uvs=uv, normals=normals[i] if normals is not None else None) + cam = self.setupCamera(focal[i], self.screenWidth, self.screenHeight) + scene = pyredner.Scene(cam, materials=[mat], objects=[obj], envmap=pyredner.EnvironmentMap(envMaps[i])) + scenes.append(scene) + + return scenes + + def renderImageAlbedo(self, scenes): + """ + render scenes with ray tracing (only albedo) + Args: + scenes: list of pyredner scenes + Returns: + images [B, resX, resY, 4]: albedo images + """ + #images =pyredner.render_albedo(scenes, alpha = True, num_samples = self.samples, device = self.device) + images = renderPathTracing(scenes, + channels= [pyredner.channels.diffuse_reflectance, pyredner.channels.alpha], + max_bounces = 0, + num_samples = self.samples , + device = self.device) + return images + def renderImage(self, scenes): + """ + render scenes with ray tracing (only albedo) + Args: + scenes: list of pyredner scenes + Returns: + images [B, resX, resY, 4]: images + """ + images = renderPathTracing(scenes, + max_bounces = self.bounces, + num_samples = self.samples , + device = self.device) + self.counter += 1 + return images + + def render(self, cameraVertices, indices, normals, uv, diffAlbedo, diffuseTexture, specularTexture, roughnessTexture, shCoeffs, sphericalHarmonics, focals, renderAlbedo=False, lightingOnly=False): + """ + Render images with redner based on inputs + + Args: + vertices (B, N, 3): vertices tensor + indices (indices number,3): indices of the morphable model + normals (B, N, 3): normals of our vertices + uv (N, 3): uv map + diffAlbedo (B, N, 3) : diffuse albedo from coefficients + diffuseTexture (B, resX, resY, 3) or (1, resX, resY, 3): diffuse textures for all our images + specularTexture (B, resX, resY, 3) or (1, resX, resY, 3): specular textures for all our images + roughnessTexture (B, resX, resY, 3) or (1, resX, resY, 3): roughness textures for all our images + shCoeffs (B, sh order ^2,3) : sh coefficients + sphericalHarmonics : SH class object that helps us to do envMap conversions + focals (B): focals for our scenes + renderAlbedo bool : render only with albedo + lightingOnly bool : render only the lighting impact + Returns: + images (B, resX, resY, 4): the renders based on our inputs + """ + envMaps = sphericalHarmonics.toEnvMap(shCoeffs) + assert(envMaps.dim() == 4 and envMaps.shape[-1] == 3) + assert(cameraVertices.shape[0] == envMaps.shape[0]) + + scenes = self.buildScenes(cameraVertices, indices, normals, uv, diffuseTexture, specularTexture, torch.clamp(roughnessTexture, 1e-20, 10.0), focals, envMaps) + if renderAlbedo: + images = self.renderImageAlbedo(scenes) + else: + images = self.renderImage(scenes) + + return images + + + \ No newline at end of file diff --git a/renderers/rendererVertexBased.py b/renderers/rendererVertexBased.py new file mode 100644 index 0000000..fc212d5 --- /dev/null +++ b/renderers/rendererVertexBased.py @@ -0,0 +1,183 @@ +import torch +from renderers.renderer import Renderer + +class RendererVertexBased(Renderer): + def __init__(self, device, screenWidth = 256, screenHeight = 256): + self.samples = 8 + self.device = torch.device(device) + self.near = 0.1 + self.far = 100 + self.upVector = torch.tensor([0.0, -1.0, 0.0]) + self.screenWidth = screenWidth + self.screenHeight = screenHeight + self.gammaCorrection = 2.2 + + # Generate colors for each vertices + def computeVertexColor(self, diffAlbedo, shCoeffs, shBasisFunctions, renderAlbedo=False, lightingOnly=False): + """ + Compute the color for each vertex + Args: + diffAlbedo (B, N, 3) : diffuse albedo from coefficients + shCoeffs (B, sh order^2,3) : sh coefficients + shBasisFunctions (B, N, sh order ^2 ): formulas needed for sh calculation + renderAlbedo bool : should we only render with albedo + lightingOnly bool : should we only render with lighting + Return: + face_color -- torch.tensor, size (B, N, 3), range (0, 1.) + """ + + if renderAlbedo : + return diffAlbedo + + # shCoeffs is of shape [1, 81, 3] + r = shBasisFunctions @ shCoeffs[..., :1] + g = shBasisFunctions @ shCoeffs[..., 1:2] + b = shBasisFunctions @ shCoeffs[..., 2:] + + if lightingOnly: + face_color = torch.cat([r, g, b], dim=-1) + else: + face_color = diffAlbedo * torch.cat([r, g, b], dim=-1) + face_color = torch.clamp(face_color, min=1e-8) + + # gamma correction + return torch.pow(face_color, 1.0/ self.gammaCorrection) + + # predict face and mask + def computeVertexImage(self, cameraVertices, verticesColor, normals, focals) : + """generate multiple vertex based images + + Args: + cameraVertices (tensor [B, N, 3]): camera vertices + verticesColor (tensor [B, N, 3]): color for each vertex + normals (tensor [B, N, 3]): normal for each vertex + focals (tensor [B]): focals for each batch + + Returns: + image [B, resX, resY, 4]: vertex based images + """ + B = cameraVertices.shape[0] # Batch size + width = self.screenWidth + height = self.screenHeight + images_data = torch.zeros((B, height, width, 4), dtype=torch.float32, device=self.device) + alpha_channel = torch.zeros((B, width, height, 1)).to(self.device) + counter = torch.zeros((B, height, width, 3), dtype=torch.float32, device=self.device) + for i in range(B): + if verticesColor.shape[0] != B : + texIndex = 0 + else: + texIndex = i + fov = torch.tensor([360.0 * torch.atan(width / (2.0 * focals[i])) / torch.pi]) # from renderer.py + + # Same code as before, but adapted to handle individual images within the batch + projMatrix = self.perspectiveProjMatrix(fov, width / height).to(self.device) + homogeneous_vertices = torch.cat((cameraVertices[i:i+1], torch.ones(1, cameraVertices.shape[1], 1).to(self.device)), -1) + vertices_in_clip_space = (projMatrix @ homogeneous_vertices.transpose(-1, -2)).transpose(-1, -2) + + vertices_in_clip_space = vertices_in_clip_space[..., :3] / vertices_in_clip_space[..., 3:] + normal_mask = normals[i:i+1, :, 2] <= 0 + mask = (torch.abs(vertices_in_clip_space[:, :, :2]) <= 1.0).all(dim=-1) & normal_mask + vertices_in_clip_space = vertices_in_clip_space[mask] + + vertices_in_screen_space = vertices_in_clip_space.clone() + vertices_in_screen_space[..., 0] = (vertices_in_clip_space[..., 0] + 1) / 2 * width + vertices_in_screen_space[..., 1] = (vertices_in_clip_space[..., 1] + 1) / 2 * height + + verticesColor_single = verticesColor[texIndex: texIndex+1].squeeze(0) + mask = mask.squeeze(0) + colors_in_screen_space = verticesColor_single[mask] + + # Convert vertices and colors to an image + vertices_in_screen_space = vertices_in_screen_space.long() # Convert to long for indexing + vertices_in_screen_space.clamp_(0, max=self.screenWidth-1) # Clamp to valid pixel range + y_indices, x_indices = vertices_in_screen_space[:, 1], vertices_in_screen_space[:, 0] # create two tensors for values + # Perform scatter operation + add alpha values + counter[i, y_indices, x_indices] += 1 # count all the pixels that have a vertex on them + images_data[i, y_indices, x_indices, :3] += colors_in_screen_space # add colors to pixels + + # Update the alpha channel of those pixels to 1 where we have updated the color + alpha_mask = counter[i, y_indices, x_indices].sum(dim=1) > 0 # create a mask for each vertex where there is at least one pixel splat there + alpha_channel[i, y_indices[alpha_mask], x_indices[alpha_mask]] = 1.0 # put a 1.0 to all the pixels that are in our mask + # Average the color and clamp at 1 + images_data[..., :3] /= counter.clamp(min=1) # average tje color and clamp to one so that we dont divide by one + images_data = images_data.clamp(0, 1) # clamp values of color and alpha to be between 0 and 1 + + # Add alpha channel to the images_data + images_data[..., 3:] = alpha_channel + + return images_data + + def perspectiveProjMatrix(self, fov, aspect_ratio): + """ Create a perspective projection matrix. + Args : + fov float : field of view angle in the y direction (in degrees). + aspect_ratio float : aspect ratio of the viewport (width/height). + + Returns: + 4x4 float matrix: perspective projection matrix + """ + f = 1.0 / torch.tan(torch.deg2rad(fov) / 2.0) + # right handed matrix + projMatrix = torch.tensor([ + [f / aspect_ratio, 0, 0, 0], + [0, f, 0, 0], + [0, 0, self.far/(self.far- self.near), -(self.far*self.near)/(self.far-self.near)], + [0, 0, 1, 0] + ]) + # or flip on x + # projMatrix = torch.tensor([ + # [-f / aspect_ratio, 0, 0, 0], + # [0, f, 0, 0], + # [0, 0, far/(far-near), -(far*near)/(far-near)], + # [0, 0, 1, 0] + # ]) + # or flip on y axis + # projMatrix = torch.tensor([ + # [f / aspect_ratio, 0, 0, 0], + # [0, -f, 0, 0], + # [0, 0, far/(far-near), -(far*near)/(far-near)], + # [0, 0, 1, 0] + # ]) + # or flip on z axis + # projMatrix = torch.tensor([ + # [f / aspect_ratio, 0, 0, 0], + # [0, f, 0, 0], + # [0, 0, -far/(far-near), (far*near)/(far-near)], + # [0, 0, -1, 0] + # ]) + # left handed + # projMatrix = torch.tensor([ + # [f / aspect_ratio, 0, 0, 0], + # [0, -f, 0, 0], + # [0, 0, -far/(far-near), -(far*near)/(far-near)], + # [0, 0, -1, 0] + # ]) + return projMatrix + # overloading this method + def render(self, cameraVertices, indices, normals, uv, diffAlbedo, diffuseTexture, specularTexture, roughnessTexture, shCoeffs, sphericalHarmonics, focals, renderAlbedo=False, lightingOnly=False): + """ + Take inputs, generate color for each vertex and project them on the screen + + Args: + vertices (B, N, 3): vertices tensor + indices (indices number,3): indices of the morphable model + normals (B, N, 3): normals of our vertices + uv (N, 3): uv map + diffAlbedo (B, N, 3) : diffuse albedo from coefficients + diffuseTexture (B, resX, resY, 3) or (1, resX, resY, 3): diffuse textures for all our images + specularTexture (B, resX, resY, 3) or (1, resX, resY, 3): specular textures for all our images + roughnessTexture (B, resX, resY, 3) or (1, resX, resY, 3): roughness textures for all our images + shCoeffs (B, sh order ^2,3) : sh coefficients + sphericalHarmonics : SH class object that helps us to do envMap conversions + focals (B): focals for our scenes + renderAlbedo bool : render only with albedo + lightingOnly bool : render only the lighting impact + Returns: + images (B, resX, resY, 4): the renders based on our inputs + """ + shBasisFunctions = sphericalHarmonics.preComputeSHBasisFunction(normals, sh_order=8) + + vertexColors = self.computeVertexColor(diffAlbedo, shCoeffs, shBasisFunctions, renderAlbedo=renderAlbedo, lightingOnly=lightingOnly) + imgs = self.computeVertexImage(cameraVertices, vertexColors, normals, focals) + return imgs + \ No newline at end of file diff --git a/replay.py b/replay.py index e83c4e3..0561be0 100644 --- a/replay.py +++ b/replay.py @@ -1,5 +1,3 @@ -from _nsis import out - from optimizer import Optimizer from config import Config from utils import * @@ -10,7 +8,7 @@ outputDir = './out' def produce(optimizer): global frameIndex - images = optimizer.pipeline.render(None, optimizer.vEnhancedDiffuse, optimizer.vEnhancedSpecular, optimizer.vEnhancedRoughness) + images = optimizer.pipeline.render(None, diffuseTextures=optimizer.vEnhancedDiffuse,specularTextures= optimizer.vEnhancedSpecular,roughnessTextures=optimizer.vEnhancedRoughness) for i in range(images.shape[0]): fileName = outputDir + '/frame_' + str(i)+ '_%04d.png' % frameIndex saveImage(images[i], fileName) @@ -47,6 +45,7 @@ def produce(optimizer): config.fillFromDicFile(configFile) optimizer = Optimizer(outputDir, config) optimizer.pipeline.renderer.samples = config.rtSamples + optimizer.pipeline.initSceneParameters(1) optimizer.loadParameters(parameters) DTR = math.pi / 180.0 diff --git a/sphericalharmonics.py b/sphericalharmonics.py index ded3da4..df7cf6d 100644 --- a/sphericalharmonics.py +++ b/sphericalharmonics.py @@ -107,3 +107,28 @@ def constructEnvMapFromSHCoeffs(self, shCoeffs, smooth = False): i += 1 result = torch.max(result, torch.zeros(res[0], res[1], smoothed_coeffs.shape[0], device=smoothed_coeffs.device)) return result + + def preComputeSHBasisFunction(self, normals, sh_order): + """we need a matrix that holds all sh basis function for our order, it is expensive computations so we save it in this class before + + Args: + normals ([B, N, 3] tensor): holds the current normals + sh_order (int): order of the sh that we are using in our system + + Returns: + [B, N, (sh_order +1)^2 ]: functions used with vSHCoeffs to get a better color approximation + """ + numCoeffs = (sh_order + 1) ** 2 # Calculate the number of SH coefficients + # Pre-allocate the tensor to hold SH basis + Y = torch.empty((normals.shape[0], normals.shape[1], numCoeffs), device=normals.device) + theta = torch.acos(normals[..., 2:]).squeeze() + phi = torch.atan2(normals[..., 1:2], normals[..., :1]).squeeze() + # Compute SH basis for each l, m and normal + element = 0 + for l in range(sh_order+1): + for m in range(-l, l + 1): + Y_l_m = self.SH(l, m, theta, phi) + Y[..., element] = Y_l_m.squeeze() + element += 1 + self.Y = Y + return Y \ No newline at end of file diff --git a/utils.py b/utils.py index 1547b45..b0e0289 100644 --- a/utils.py +++ b/utils.py @@ -121,4 +121,136 @@ def writeDictionaryToPickle(dict, picklePath): import pickle handle = open(picklePath, 'wb') pickle.dump(dict, handle, pickle.HIGHEST_PROTOCOL) - handle.close() \ No newline at end of file + handle.close() + +def debugRender(image, outputPrefix): + """generate a single render of the current step + + Args: + image ([B, X, Y, 3]): input + outputPrefix (string): path of the output folder + """ + for i in range(image.shape[0]): + res = cv2.hconcat([cv2.cvtColor(image[i].detach().cpu().numpy(), cv2.COLOR_BGR2RGB)]) + + # Concatenate vertically - combined image with textures + debugFrame = cv2.vconcat([np.power(np.clip(res, 0.0, 1.0), 1.0 / 2.2) * 255]) + + cv2.imwrite(outputPrefix + '.png', debugFrame) + +def debugIteration(image, target, diff, diffuseOnlyVertexRender, lightingOnlyVertexRender, outputPrefix): + """render a vertex debug picture to see how an iteration looks like + + Args: + image ([1, width, height, 3] tensor): final render + target ([1, width, height, 3] tensor): input picture + diff ( [1, width, height, 3] tensor): difference between image and target + diffuseOnlyVertexRender ( [1, width, height, 4] tensor): render but only with the diffuse Albedo + lightingOnlyVertexRender ( [1, width, height, 4] tensor): render but only with the SH + outputPrefix (string): where we save the files + """ + # Converting tensors to numpy arrays + image = image.squeeze(0).detach().cpu().numpy() + target = target.squeeze(0).detach().cpu().numpy() + diff = diff.squeeze(0).detach().cpu().numpy() + diffuseOnlyVertexRender = diffuseOnlyVertexRender[..., :3].squeeze(0).detach().cpu().numpy() + lightingOnlyVertexRender = lightingOnlyVertexRender[..., :3].squeeze(0).detach().cpu().numpy() + + + # # Adjust colors and clamp + image = np.power(np.clip(image, 0.0, 1.0), 1.0 / 2.2) + target = np.clip(target, 0.0, 1.0) + diff = np.clip(diff, 0.0, 1.0) + diffuseOnlyVertexRender = np.clip(diffuseOnlyVertexRender, 0.0, 1.0) + lightingOnlyVertexRender = np.clip(lightingOnlyVertexRender, 0.0, 1.0) + + # OpenCV assumes images to be in BGR format. Convert RGB to BGR + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + target = cv2.cvtColor(target, cv2.COLOR_BGR2RGB) + diff = cv2.cvtColor(diff, cv2.COLOR_BGR2RGB) + diffuseOnlyVertexRender = cv2.cvtColor(diffuseOnlyVertexRender, cv2.COLOR_BGR2RGB) + lightingOnlyVertexRender = cv2.cvtColor(lightingOnlyVertexRender, cv2.COLOR_BGR2RGB) + + # Concatenate images horizontally and vertically + res = cv2.hconcat([image, target, diff]) + ref = cv2.hconcat([diffuseOnlyVertexRender, lightingOnlyVertexRender]) + # add a black padding so that ref matches size of res (res is 3 pictures ref is 2) + if ref.shape[1] < res.shape[1]: + pad_width = res.shape[1] - ref.shape[1] + padding = np.zeros((ref.shape[0], pad_width, ref.shape[2]), dtype=np.float32) + ref = cv2.hconcat([ref, padding]) + res = np.power(np.clip(res, 0.0, 1.0), 1.0 / 2.2) * 255 + ref = np.power(np.clip(ref, 0.0, 1.0), 1.0 / 2.2) * 255 + debugFrame = cv2.vconcat([res, ref]) + + # Save the image + cv2.imwrite(outputPrefix + '.png', debugFrame) + +def debugTensor(debugTensor): + """display a tensor of shape [x, y, 3] + + Args: + debugTensor (_type_): _description_ + """ + import matplotlib.pyplot as plt + + # Convert your tensor to a numpy array. If your tensor is on the GPU, bring it back to CPU first + debugTensor = debugTensor.detach().cpu().numpy() + + # Convert the mask to a 2D array if it is not already + if len(debugTensor.shape) > 2: + debugTensor = debugTensor.mean(axis=-1) + + # Display the mask + plt.imshow(debugTensor) + plt.colorbar(label='debugTensor') + plt.show() + +def screenshotMesh(names, meshDir, outputDir): + # display meshes in polyscope + import polyscope as ps + import trimesh + import glob + + # display_meshes = ["mitsuba_step2_iter0.obj","mitsuba_step2_iter400.obj","redner_step2_iter0.obj","redner_step2_iter400.obj","vertex_step2_iter0.obj","vertex_step2_iter400.obj",] # replace this with your mesh names + + # outputDir = './output/test/bikerman_512.jpg/' + # Get a list of all .obj files in the directory + # obj_files = glob.glob(os.path.join(outputDir + '/debug/mesh', "*.obj")) + obj_files = glob.glob(os.path.join(meshDir, "*.obj")) + + # Filter obj_files to only include the ones in display_meshes + obj_files = [file for file in obj_files if os.path.basename(file) in names] + + # Define a folder where the screenshots will be saved + # Check if the folder exists, if not create it + os.makedirs(outputDir, exist_ok=True) + + # Initialize polyscope + ps.init() + ps.set_up_dir("neg_y_up") + ps.set_ground_plane_mode("none") + + # # Show the mesh + # Load and register each mesh to polyscope + for idx, obj_file in enumerate(obj_files): + # mesh_name = os.path.basename(obj_file) # get the name of the mesh + mesh_name = os.path.basename(obj_file) # get the name of the mesh + # Load the mesh from an obj file using trimesh + mesh = trimesh.load_mesh(obj_file) + # Register the mesh to polyscope + ps_mesh = ps.register_surface_mesh(mesh_name, mesh.vertices, mesh.faces) + # Reset the transformation on the mesh + ps_mesh.reset_transform() + # Set a color for the mesh + color = torch.tensor([0.5, 0.5, 0.5]).numpy() # set a fixed color + ps_mesh.set_color(color) + # Reset the view + ps.reset_camera_to_home_view() + # Show the mesh + ps.show() + # Take a screenshot and save it to the specified folder + screenshot_name = os.path.join(outputDir, f"{mesh_name}_screenshot.png") + ps.screenshot(screenshot_name) + # Remove the mesh from polyscope to prepare for the next one + ps.remove_all_structures() \ No newline at end of file