diff --git a/docs/en/annotator_entries/AutoGGUFVisionModel.md b/docs/en/annotator_entries/AutoGGUFVisionModel.md
new file mode 100644
index 00000000000000..0d6a6c086eabc3
--- /dev/null
+++ b/docs/en/annotator_entries/AutoGGUFVisionModel.md
@@ -0,0 +1,202 @@
+{%- capture title -%}
+AutoGGUFVisionModel
+{%- endcapture -%}
+
+{%- capture description -%}
+Multimodal annotator that uses the llama.cpp library to generate text completions with large
+language models. It supports ingesting images for captioning.
+
+At the moment only CLIP based models are supported.
+
+For settable parameters, and their explanations, see HasLlamaCppInferenceProperties,
+HasLlamaCppModelProperties and refer to the llama.cpp documentation of
+[server.cpp](https://github.com/ggerganov/llama.cpp/tree/7d5e8777ae1d21af99d4f95be10db4870720da91/examples/server)
+for more information.
+
+If the parameters are not set, the annotator will default to use the parameters provided by
+the model.
+
+This annotator expects a column of annotator type AnnotationImage for the image and
+Annotation for the caption. Note that the image bytes in the image annotation need to be
+raw image bytes without preprocessing. We provide the helper function
+ImageAssembler.loadImagesAsBytes to load the image bytes from a directory.
+
+Pretrained models can be loaded with `pretrained` of the companion object:
+
+```scala
+val autoGGUFVisionModel = AutoGGUFVisionModel.pretrained()
+  .setInputCols("image", "document")
+  .setOutputCol("completions")
+```
+
+The default model is `"llava_v1.5_7b_Q4_0_gguf"`, if no name is provided.
+
+For available pretrained models please see the [Models Hub](https://sparknlp.org/models).
+
+For extended examples of usage, see the
+[AutoGGUFVisionModelTest](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTest.scala)
+and the
+[example notebook](https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb).
+
+**Note**: To use GPU inference with this annotator, make sure to use the Spark NLP GPU package and set
+the number of GPU layers with the `setNGpuLayers` method.
+
+When using larger models, we recommend adjusting GPU usage with `setNCtx` and `setNGpuLayers`
+according to your hardware to avoid out-of-memory errors.
+{%- endcapture -%}
+
+{%- capture input_anno -%}
+IMAGE, DOCUMENT
+{%- endcapture -%}
+
+{%- capture output_anno -%}
+DOCUMENT
+{%- endcapture -%}
+
+{%- capture python_example -%}
+import sparknlp
+from sparknlp.base import *
+from sparknlp.annotator import *
+from pyspark.ml import Pipeline
+from pyspark.sql.functions import lit
+
+documentAssembler = DocumentAssembler() \
+    .setInputCol("caption") \
+    .setOutputCol("caption_document")
+imageAssembler = ImageAssembler() \
+    .setInputCol("image") \
+    .setOutputCol("image_assembler")
+
+imagesPath = "src/test/resources/image/"
+data = ImageAssembler \
+    .loadImagesAsBytes(spark, imagesPath) \
+    .withColumn("caption", lit("Caption this image.")) # Add a caption to each image.
+
+nPredict = 40
+model = AutoGGUFVisionModel.pretrained() \
+    .setInputCols(["caption_document", "image_assembler"]) \
+    .setOutputCol("completions") \
+    .setBatchSize(4) \
+    .setNGpuLayers(99) \
+    .setNCtx(4096) \
+    .setMinKeep(0) \
+    .setMinP(0.05) \
+    .setNPredict(nPredict) \
+    .setNProbs(0) \
+    .setPenalizeNl(False) \
+    .setRepeatLastN(256) \
+    .setRepeatPenalty(1.18) \
+    .setStopStrings(["</s>", "Llama:", "User:"]) \
+    .setTemperature(0.05) \
+    .setTfsZ(1) \
+    .setTypicalP(1) \
+    .setTopK(40) \
+    .setTopP(0.95)
+
+pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])
+pipeline.fit(data).transform(data) \
+    .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result") \
+    .show(truncate = False)
++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|image_name       |result                                                                                                                                                                                        |
++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions]               |
+|egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding]             |
+|hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats]                            |
+|hen.JPEG         |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] |
+|ostrich.JPEG     |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to]              |
+|junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out]  |
+|bluetick.jpg     |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.]              |
+|chihuahua.jpg    |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]|
+|tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with]                                |
+|ox.JPEG          |[ A large bull with horns is standing in a grassy field.]                                                                                                                                     |
++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+{%- endcapture -%}
+
+{%- capture scala_example -%}
+import com.johnsnowlabs.nlp.ImageAssembler
+import com.johnsnowlabs.nlp.annotator._
+import com.johnsnowlabs.nlp.base._
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.DataFrame
+import org.apache.spark.sql.functions.lit
+
+val documentAssembler = new DocumentAssembler()
+  .setInputCol("caption")
+  .setOutputCol("caption_document")
+
+val imageAssembler = new ImageAssembler()
+  .setInputCol("image")
+  .setOutputCol("image_assembler")
+
+val imagesPath = "src/test/resources/image/"
+val data: DataFrame = ImageAssembler
+  .loadImagesAsBytes(ResourceHelper.spark, imagesPath)
+  .withColumn("caption", lit("Caption this image.")) // Add a caption to each image.
+
+val nPredict = 40
+val model = AutoGGUFVisionModel.pretrained()
+  .setInputCols("caption_document", "image_assembler")
+  .setOutputCol("completions")
+  .setBatchSize(4)
+  .setNGpuLayers(99)
+  .setNCtx(4096)
+  .setMinKeep(0)
+  .setMinP(0.05f)
+  .setNPredict(nPredict)
+  .setNProbs(0)
+  .setPenalizeNl(false)
+  .setRepeatLastN(256)
+  .setRepeatPenalty(1.18f)
+  .setStopStrings(Array("</s>", "Llama:", "User:"))
+  .setTemperature(0.05f)
+  .setTfsZ(1)
+  .setTypicalP(1)
+  .setTopK(40)
+  .setTopP(0.95f)
+
+val pipeline = new Pipeline().setStages(Array(documentAssembler, imageAssembler, model))
+pipeline
+  .fit(data)
+  .transform(data)
+  .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result")
+  .show(truncate = false)
++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|image_name       |result                                                                                                                                                                                        |
++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+|palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions]               |
+|egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding]             |
+|hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats]                            |
+|hen.JPEG         |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] |
+|ostrich.JPEG     |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to]              |
+|junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out]  |
+|bluetick.jpg     |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.]              |
+|chihuahua.jpg    |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]|
+|tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with]                                |
+|ox.JPEG          |[ A large bull with horns is standing in a grassy field.]                                                                                                                                     |
++-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+{%- endcapture -%}
+
+{%- capture api_link -%}
+[AutoGGUFVisionModel](/api/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel)
+{%- endcapture -%}
+
+{%- capture python_api_link -%}
+[AutoGGUFVisionModel](/api/python/reference/autosummary/sparknlp/annotator/seq2seq/auto_gguf_vision_model/index.html)
+{%- endcapture -%}
+
+{%- capture source_link -%}
+[AutoGGUFVisionModel](https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala)
+{%- endcapture -%}
+
+{% include templates/anno_template.md
+title=title
+description=description
+input_anno=input_anno
+output_anno=output_anno
+python_example=python_example
+scala_example=scala_example
+api_link=api_link
+python_api_link=python_api_link
+source_link=source_link
+%}
\ No newline at end of file
diff --git a/docs/en/annotators.md b/docs/en/annotators.md
index c5c21707b80f8e..541d151533c3ce 100644
--- a/docs/en/annotators.md
+++ b/docs/en/annotators.md
@@ -47,6 +47,7 @@ There are two types of Annotators:
 |---|---|---|
 {% include templates/anno_table_entry.md path="" name="AutoGGUFEmbeddings" summary="Annotator that uses the llama.cpp library to generate text embeddings with large language models."%}
 {% include templates/anno_table_entry.md path="" name="AutoGGUFModel" summary="Annotator that uses the llama.cpp library to generate text completions with large language models."%}
+{% include templates/anno_table_entry.md path="" name="AutoGGUFVisionModel" summary="Multimodal annotator that uses the llama.cpp library to generate text completions with large language models."%}
 {% include templates/anno_table_entry.md path="" name="BGEEmbeddings" summary="Sentence embeddings using BGE."%}
 {% include templates/anno_table_entry.md path="" name="BigTextMatcher" summary="Annotator to match exact phrases (by token) provided in a file against a Document."%}
 {% include templates/anno_table_entry.md path="" name="Chunk2Doc" summary="Converts a `CHUNK` type column back into `DOCUMENT`. Useful when trying to re-tokenize or do further analysis on a `CHUNK` result."%}
diff --git a/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb b/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb
index d4152e51194c25..8d00e9d3b1a291 100644
--- a/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb
+++ b/examples/python/llama.cpp/PromptAssember_with_AutoGGUFModel.ipynb
@@ -264,8 +264,7 @@
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "pygments_lexer": "ipython3"
   }
  },
  "nbformat": 4,
diff --git a/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb
index 3a76bdf5f01ece..09be6b85ee1083 100644
--- a/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb
+++ b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFModel.ipynb
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -320,7 +320,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -335,7 +335,6 @@
    "source": [
     "from sparknlp.annotator import *\n",
     "\n",
-    "# All these params should be identical to the original ONNX model\n",
     "autoGGUFModel = (\n",
     "    AutoGGUFModel.loadSavedModel(EXPORT_PATH, spark)\n",
     "    .setInputCols(\"document\")\n",
@@ -355,7 +354,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -389,7 +388,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -415,7 +414,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -619,8 +618,7 @@
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "pygments_lexer": "ipython3"
   }
  },
  "nbformat": 4,
diff --git a/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb
new file mode 100644
index 00000000000000..a33d9c351ba094
--- /dev/null
+++ b/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb
@@ -0,0 +1,805 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![JohnSnowLabs](https://sparknlp.org/assets/images/logo.png)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JohnSnowLabs/spark-nlp/blob/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb)\n",
+    "\n",
+    "# Import llama.cpp 🦙 vision models into Spark NLP 🚀\n",
+    "\n",
+    "Let's keep in mind a few things before we start 😊\n",
+    "\n",
+    "- Multimodal inference with llama.cpp was introduced in `Spark NLP 5.6.0`, enabling quantized LLM inference on a wide range of devices. Please make sure you have upgraded to the latest Spark NLP release.\n",
+    "- You need to use your own `.gguf` model files, which also include the models from the [Hugging Face Models](https://huggingface.co/models?library=gguf).",
+    "- At the moment only CLIP based models are supported."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Download a GGUF Vision Model\n",
+    "\n",
+    "Let's download a GGUF vision model to test it out. For this, we will use [Mozilla/llava-v1.5-7b](https://huggingface.co/Mozilla/llava-v1.5-7b-llamafile/tree/main). It is a 7B parameter model which also is available in 4-bit quantization.\n",
+    "\n",
+    "We can download the model and its multimodal projection (mmproj) file by selecting the q4 GGUF file from the \"Files and versions\" tab.\n",
+    "\n",
+    "Once downloaded, we can directly import this model into Spark NLP!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "EXPORT_PATH_MODEL = \"llava-v1.5-7b-Q4_K.gguf\"\n",
+    "EXPORT_PATH_MMPROJ = \"llava-v1.5-7b-mmproj-Q4_0.gguf\"\n",
+    "! wget \"https://huggingface.co/Mozilla/llava-v1.5-7b-llamafile/resolve/main/{EXPORT_PATH_MODEL}?download=true\" -O  {EXPORT_PATH_MODEL}\n",
+    "! wget \"https://huggingface.co/Mozilla/llava-v1.5-7b-llamafile/resolve/main/{EXPORT_PATH_MMPROJ}?download=true\" -O  {EXPORT_PATH_MMPROJ}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import and Save AutGGUFVision models in Spark NLP\n",
+    "\n",
+    "- Let's install and setup Spark NLP (if running it Google Colab)\n",
+    "- This part is pretty easy via our simple script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Only execute this if you are on Google Colab\n",
+    "! wget -q http://setup.johnsnowlabs.com/colab.sh -O - | bash"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's start Spark with Spark NLP included via our simple `start()` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sparknlp\n",
+    "\n",
+    "# let's start Spark with Spark NLP with GPU enabled. If you don't have GPUs available remove this parameter.\n",
+    "spark = sparknlp.start(gpu=True)\n",
+    "print(sparknlp.version())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Let's use the `loadSavedModel` function in `AutoGGUFVisionModel`\n",
+    "- Most parameters will be set automatically. They can also be set later after loading the model in `AutoGGUFVisionModel` during runtime, so don't worry about setting them now.\n",
+    "- `loadSavedModel` accepts three parameters: \n",
+    "  1. the path to the exported gguf model\n",
+    "  1. the path to the exported mmproj gguf model\n",
+    "  2. the SparkSession that is `spark` variable we previously started via `sparknlp.start()`\n",
+    "- NOTE: `loadSavedModel` accepts local paths in addition to distributed file systems such as `HDFS`, `S3`, `DBFS`, etc. This feature was introduced in Spark NLP 4.2.2 release. Keep in mind the best and recommended way to move/share/reuse Spark NLP models is to use `write.save` so you can use `.load()` from any file systems natively."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sparknlp.annotator import *\n",
+    "\n",
+    "autoGGUFModel = (\n",
+    "    AutoGGUFVisionModel.loadSavedModel(EXPORT_PATH_MODEL, EXPORT_PATH_MMPROJ, spark)\n",
+    "    .setInputCols([\"caption_document\", \"image_assembler\"])\n",
+    "    .setOutputCol(\"completions\")\n",
+    "    .setChatTemplate(\"vicuna\")\n",
+    "    .setBatchSize(4)\n",
+    "    .setNGpuLayers(99)\n",
+    "    .setNCtx(4096)\n",
+    "    .setMinKeep(0)\n",
+    "    .setMinP(0.05)\n",
+    "    .setNPredict(40)\n",
+    "    .setNProbs(0)\n",
+    "    .setPenalizeNl(False)\n",
+    "    .setRepeatLastN(256)\n",
+    "    .setRepeatPenalty(1.18)\n",
+    "    .setStopStrings([\"</s>\", \"Llama:\", \"User:\"])\n",
+    "    .setTemperature(0.05)\n",
+    "    .setTfsZ(1)\n",
+    "    .setTypicalP(1)\n",
+    "    .setTopK(40)\n",
+    "    .setTopP(0.95)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- Let's save it on disk so it is easier to be moved around and also be used later via `.load` function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "autoGGUFModel.write().overwrite().save(f\"llava_v1.5_7b_Q4_0_gguf_spark_nlp\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Awesome  😎 !\n",
+    "\n",
+    "This is your GGUF model from loaded and saved by Spark NLP 🚀. You can now use it on other machines, clusters, or any place you wish to use your new and shiny GGUF model 😊"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "llava-v1.5-7b-mmproj-Q4_0.gguf\tllava-v1.5-7b-Q4_K.gguf  metadata\n"
+     ]
+    }
+   ],
+   "source": [
+    "! ls llava_v1.5_7b_Q4_0_gguf_spark_nlp"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example: Captioning Images\n",
+    "\n",
+    "Now let's see how we can use the model to caption some images. Let's first download some images we can caption."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAHbCAYAAAA9P0KxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebwcVZn//z5LVXX33ZLc7GEJoCCC4AIuIBJlExAQVwQcQRYV/QHCuI5+Ccgo4qAwAwoiyyig4IqCoqw6CqMoCILLEGVPQpKb3LW7aznn/P44VdXdScAQQFTq83pdQldXVZ9auut8nufzfB7hnHNUqFChQoUKFSpUqFChQoUKFZ4RyGd7ABUqVKhQoUKFChUqVKhQocI/MyriXaFChQoVKlSoUKFChQoVKjyDqIh3hQoVKlSoUKFChQoVKlSo8AyiIt4VKlSoUKFChQoVKlSoUKHCM4iKeFeoUKFChQoVKlSoUKFChQrPICriXaFChQoVKlSoUKFChQoVKjyDqIh3hQoVKlSoUKFChQoVKlSo8AyiIt4VKlSoUKFChQoVKlSoUKHCM4iKeFeoUKFChQoVKlSoUKFChQrPIJ5TxPvSSy9FCMEDDzzwbA9lo1Ecw69//ety2eLFixFClH9hGLLFFltwwgknMDo6us62j/d3yy239HxWHMecd9557L777gwPDxMEAcPDwyxatIgLLriAiYmJv9FRV6hQoUKFChUqVKhQocI/LvSzPYC/Jfbff39uu+025s2b92wP5RnBddddx9DQEBMTE/zwhz/knHPO4Ve/+hW33norQohyvUsuuYQXvOAF62z/whe+sPz/lStX8vrXv5577rmHd73rXRx//PHMnj2bkZERbrrpJj784Q/z85//nK997Wt/k2OrUKFChQoVKlSoUKFChX9UPKeI96xZs5g1a9azPYxnDC972cuYOXMmAHvttRcjIyN87Wtf49Zbb2XXXXct19t+++3ZaaednnBfhx9+OL/73e+44YYbeM1rXtPz3hvf+EZOOeUUfvSjHz39B1GhQoUKFSpUqFChQoUK/2R4TkvNFy5cyBFHHLHOeosWLWLRokXl61tuuQUhBF//+tf5t3/7N+bPn8/g4CB77rknf/rTn9bZ/rrrrmOPPfZgaGiIRqPBtttuy2c+85medb7//e/zqle9ikajwcDAAHvttRe33Xbb03m4vPKVrwTgwQcffFLb3X777fzkJz/h2GOPXYd0FxgeHubwww9/ymOsUKFChQoVKlSoUKFChX92PKeI91PFxz/+cR588EG+8pWv8OUvf5n77ruPAw44AGNMuc5FF13Efvvth7WW888/nx/84Accf/zxPPLII+U6V1xxBQcddBCDg4N8/etf56KLLmLNmjUsWrSIn//850/beJcsWQKwTpbfGEOWZT1/3cdw/fXXA3DggQc+bWOpUKFChQoVKlSoUKFChecqnlNS86eKF77whVx22WXla6UUb3vb27j99tt55StfyeTkJCeddBK77rorN910U1lXvccee5TbWGv50Ic+xIte9CJ+9KMfIaWPfey3335stdVWfOQjH+EXv/jFRo2vINSTk5Nce+21nH/++Wy66abstttuPesVmfBuKKXIsgyAhx9+GIDNN9+8Zx3nXA9BF0KglNqosVaoUKFChQoVKlSoUKHCcwUV8X4SWDsDvMMOOwBeyv3KV76SW2+9lfHxcY477rgeM7Nu/OlPf2Lp0qWceOKJJekG6O/v581vfjMXXHABzWaTRqPxpMc3d+7cnte77rorX/7yl6nVaj3Lv/rVr7Ltttv2LHu88Xbj6quv5uCDDy5f9/X1MTk5+aTHWaFChQoVKlSoUKFChQrPJVTE+0lgeHi453UURQC0Wi3AO4EDbLLJJo+7j5GREYD1OqvPnz8fay1r1qzZKOJ9ww03MDQ0RBAEbLLJJuuMt8C22277hOZqm222GeADCttss025fNGiRdx+++0AnHrqqdx8881PeowVKlSoUKFChQoVKlSo8FzDc7rGu1arEcfxOstXrVq1Ufsraqm767nXRkGGly1bts57S5cuRUrJ9OnTN+rzd9xxR3baaSd23HHHxyXdG4K99toL8AZw3Zg2bRo77bQTO+2001Paf4UKFSpUqFChQoUKFSo8l/CcJt4LFy7k7rvv7ln2f//3f+t1Kt8Q7LLLLgwNDXH++efjnFvvOttssw0LFizgiiuu6FlnamqKb3/726XT+bOJnXbaib333psLL7yQ//mf/3lWx1KhQoUKFSpUqFChQoUK/+h4TkvN3/nOd3L44Ydz3HHH8eY3v5kHH3yQM888c6N7fff393PWWWdx9NFHs+eee3LMMccwZ84clixZwl133cW5556LlJIzzzyTww47jDe84Q285z3vIY5jPve5zzE6OsoZZ5xR7u+0007jtNNO48Ybb2T33Xfv+awNqcl+PNxzzz2lkVo3ttpqq/LYL7vsMvbZZx/23HNPjjjiCPbZZx9mz57N+Pg4d999NzfccAODg4MbPYYKFSpUqFChQoUKFSpUeK7gOUm8C9J66KGHsnTpUs4//3wuueQStt9+e770pS9x6qmnbvS+jzrqKObPn89nP/tZjj76aJxzLFy4kHe9613lOoceeih9fX185jOf4e1vfztKKV75yldy8803s8suu5TrWWsxxvRkxpvNJtCpL98YHHnkketdfuGFF3L00UcDXjZ/2223ceGFF3LllVdy1VVXMTk5yeDgINtttx3HH398uW6FChUqVKhQoUKFChUqVHh8CPd4muh/QpxzzjmceOKJTExM0N/f/2wPZ6NwwgkncO655zI6OsrAwMCzPZwKFSpUqFChQoUKFSpUqPBX8Jyo8R4bG+O6667j0ksvZfvtt/+HJN2/+c1vOP/887n44os58MADK9Jd4W+GpUuXsnjxYn7729+u897ixYufUtnD3yN+//vfs3jxYh544IENWv/SSy9FCLHB61eoUKFChQoV/vlQzIk21qT56cbChQt5wxve0LNMCNHzNzQ0xKJFi7j22mvX2XbtdYu/RYsWrfNZd999N0cddRRbbbUV9Xqder3O85//fN7znvfw61//+pk8zH8oPCek5nfeeScHH3wwO+ywAxdddNGzPZyNwlve8hbGxsY48MAD+c///M9nezgVnkNYunQpp556KgsXLuTFL35xz3tHH300r3/965+dgT1D+P3vf8+pp57KokWLWLhw4V9df//99+e2225bb4vAChUqVKhQoUKFvye85S1v4eSTT8Zay1/+8hdOP/10DjjgAH7wgx+w//77l+vtuuuu/Md//Mc626/t8XTBBRfwgQ98gG222YYTTjiB7bbbDiEEf/jDH/j617/OzjvvzJIlS9hqq62e8WP7e8dzgngvWrSo7LX9j4r777//2R5ChQrrYJNNNnnCvvXPBcyaNWujDRkrVKhQoUKFChX+lpgzZw6vfOUrAd+R6VWvehXPe97zOPvss3uI97Rp08r1Hg+/+MUvOO6449h///351re+RRiG5Xuve93reP/73883v/lN6vX6M3Mw/2B4TkjNK1T4e8d9993HoYceyuzZs4miiG233ZbzzjuvZ517772Xvffem0ajwaxZs3j/+9/PtddeixCCW265BYBPfepTaK15+OGH1/mMd7/73QwPD9Nut4GOBOm73/0uO+ywA7VajS233LJHUXHLLbew8847A96Ur5AZLV68GFi/1PzKK69k7733Zt68edTrdbbddls++tGPMjU11bPeEUccQX9/P0uWLGG//fajv7+fTTfdlJNPPpk4jp/0ObzuuuvYY489GBoaotFosO222/KZz3ymfP/Xv/41hxxyCAsXLqRer7Nw4ULe8Y538OCDD5brXHrppbz1rW8F4LWvfW15vJdeeunjfu76pOaLFi1i++2353/+53945StfSb1eZ8GCBXzyk5/EGNOzfZIknH766bzgBS8giiJmzZrFkUceycqVK3vWi+OYk08+mblz59JoNHjNa17Db37zGxYuXMgRRxzxpM9XhQoVKlSoUOHpx2OPPcY73vEOhoaGmDNnDu9+97sZGxsr33fO8cUvfpEXv/jF1Ot1pk+fzlve8hb+8pe/9OynmEvcfvvt7LbbbjQaDbbcckvOOOMMrLVP23iLrkbd86ENxac//WmUUlxwwQU9pLsbb33rW5k/f/5THeY/BSriXaHCs4zf//737Lzzztxzzz2cddZZXHPNNey///4cf/zxpcP+smXL2H333fnTn/7El770Jb761a8yMTHBBz7wgZ59vec970FrzQUXXNCzfPXq1XzjG9/gqKOOolarlct/+9vfcuKJJ/LBD36Q7373u+yyyy6ccMIJpbTopS99KZdccgkAn/jEJ7jtttu47bbbntDR/r777mO//fbjoosu4rrrruPEE0/kqquu4oADDlhn3TRNOfDAA9ljjz24+uqrefe7380XvvAFPvvZzz6pc3jRRRex3377Ya3l/PPP5wc/+AHHH388jzzySLnOAw88wDbbbMPZZ5/Nj3/8Yz772c+ybNkydt5557Iea//99+fTn/40AOedd155vN0R4A3F8uXLOeSQQzjssMO4+uqrectb3sLpp5/OCSecUK5jreWggw7ijDPO4NBDD+Xaa6/ljDPO4Prrr19HqXPkkUdy9tlnc+SRR3L11Vfz5je/mYMPPpjR0dEnPbYKFSpUqFChwjODN7/5zWy99dZ8+9vf5qMf/ShXXHEFH/zgB8v33/Oe93DiiSey55578r3vfY8vfvGL3Hvvveyyyy489thjPftavnw5hx12GIcffjjf//732XffffnYxz7GZZdd9rSNd82aNYyMjKyj3nPOkWXZOn+FL7cxhptvvpmddtqpKrfbULgKFSo8q9hnn33cJpts4sbGxnqWf+ADH3C1Ws2tXr3afehDH3JCCHfvvfeusy3gbr755nLZu971Ljd79mwXx3G57LOf/ayTUrr777+/XLb55ps7IYT77W9/27PPvfbayw0ODrqpqSnnnHO33367A9wll1yyzthPOeUU90Q/I9Zal6ap++lPf+oAd9ddd/WME3BXXXVVzzb77bef22abbR53n2tjYmLCDQ4Oule/+tXOWrvB22VZ5iYnJ11fX58755xzyuXf/OY31zmnT4RLLrnEAT3ndvfdd3eAu/rqq3vWPeaYY5yU0j344IPOOee+/vWvO8B9+9vf7lmvOOdf/OIXnXPO3XvvvQ5wH/nIR3rWK7Z/17vetYFHXaFChQoVKlR4JlDMic4888ye5ccdd5yr1WrOWutuu+02B7izzjqrZ52HH37Y1et19+EPf7hcVswlfvnLX/as+8IXvtDts88+f3U8m2++udt///17lgHuuOOOc2mauiRJ3B/+8Ae37777OsCdd955PdsC6/371Kc+5Zxzbvny5Q5whxxyyDqfnWWZS9O0/Hsy87N/Zmxwjfet//sbpBBYBEpJpBAoKQvy3k3ksc5RLBH5Mudc+f/FO16h6sr3/V/+bqleFUjp5Z5KKZRSpbTVWlf2ubbWlrKLQh4KdNYXohyTH4tASVF+jnMu30Z0xiv8+1JKpOyIA5zrHJO1FucsCEFfo4Zzgsz4bR2WuN3GWQcOHK5nrMWfMQZjDJm1OCwiH19xHFLI/Bgoj09K1eMw6M+H7RpjfrRSoLVCFhsjkFKW2zkhes4/eBlEsU+RnzeXL3eA7bre1lqkEMh8feccNj9HUhbXTgESf/c4jHM4axHF/vP9OSj3Y63FWFt+lrMWVx6XQAiJEKBlfjxS4hD5tTFYa8rrVHyO37fLx+av56te+TKeTbTbbW688Ube97730Wg0yLKsfG+//fbj3HPP5X//93/56U9/yvbbb88LX/jCnu3f8Y538OMf/7hn2QknnMB///d/881vfpPDDjsMay1f+tKX2H///dcxC9tuu+3Ycccde5YdeuihXH/99dxxxx28+tWvftLH9Je//IVPfOIT3HTTTaxYsaLn9+EPf/gDO+ywQ/laCLFOJnyHHXbgpptu2uDPu/XWWxkfH+e44457Qof1yclJPvWpT/Htb3+bBx54oEfy/Yc//GGDP29DMTAwwIEHHtiz7NBDD+XCCy/kZz/7GYcffjjXXHMN06ZN44ADDui59i9+8YuZO3cut9xyC+973/v46U9/CsDb3va2nv295S1v4Z3vfOfTPvYKFSpUqFChwsZh7Wf/DjvsQLvdZsWKFVxzzTUIITj88MN7nvtz585lxx13LEsHu5e//OUvX2d/6+s0s6H44he/yBe/+MXy9dDQEKeddhrHHXdcz3qvfvWr+cIXvrDO9gsWLPirn/Gyl72Mu+66q3z9uc99jn/913/d6DH/s2CDibeSnugIRA/R6kZJ4PLXUghKJp0Tnh6Cl+8Tuole53WxqXPgBJ6QWluSpm7ya7uImRQCgSfdBWl2znWzeSiJdvdYeom3cw5jHcVhFP92H4MnsJIo0tRqIc5AaizGWEBilCIxiQ8SWE9hjTE5Ye8ivDkRVkIjpcjPd06qHTjrsM74oIZz2HxcUkikkDh8wEPkx24RCOnfE0ik9MfWTdRL8g1lsMQ5h8sPtCDFJdle65oLIdBK5fUKPjDg/Any5No5hBMIHFJ07gslBCY/8yX5zu8xKTzpLoIlAn/dkbJrnD4wAWBcvr61XePL74E8cOLXAZsfgnW28xnPMkZGRsiyjP/6r//iv/7rv9a7zqpVqxgZGWGLLbZY5705c+ass+wlL3kJu+22G+eddx6HHXYY11xzDQ888MA68nPwP+iPt2xkZOTJHg6Tk5Pstttu1Go1Tj/9dLbeemsajQYPP/wwb3rTm9YxOWw0Gj3Sd4Aoiso69A1BUQv910zeDj30UG688UY++clPsvPOOzM4OIgQgv322+8ZMV9c37VZ+9w+9thjjI6OPm5dVCGBL9Zfe59aa4aHh5+2MVfYeCxevJhTTz21J9D094SFCxey/fbbc80115TL1v4NHBwc5CUveQkf+tCHesorFi5c+Li1f7vvvvs6E8W7776bc845h1tuuYWlS5cC/vv5ute9jmOOOYaddtrpaTqqChUqVPj7w9rP5SiKAGi1Wjz22GM459Y7RwDYcsstn3Bfxf6eyrzlbW97Gx/60IcQQjAwMMBWW22FUmqd9YaGhp7w93rmzJnU6/X1Ph+uuOIKms0my5YtWycQ8VzGhruaOyAn3CW9WSvzWZA2QSdzWZA45zxpKoijFOVOS4IIa09YOpMC5z8wJ5yeFHZnRcstc7Io8ixod7a6Z0Ikev+nJKGuMxkpsvdFZsxzwQ65c66TpXUWajogCATNJKPtMoyzJck21pEZl2djLT457Y9fColSgiIvnHPO/LzmGVsJWHDWb1+QUicEFok1BmMtUvpgA0qhhEQgcM6T7uI8rE28KYIOxvRcge5AivMfv85ETeXk1tNrfNYZmw+WPGLhcNjyGhafbfJ7piDeBQn3X36L7L6vwJ8dUdw7nWskhfDknEK5kKsUcrWAcpBi8/vPegK+nmN5NjB9+nSUUrzzne/k/e9//3rX2WKLLTj33HPXqfsBX/uzPhx//PG89a1v5Y477uDcc89l6623Zq+99tqg7YtlG0PobrrpJpYuXcott9zC7rvvXi5/JuuQi5qk7nrutTE2NsY111zDKaecwkc/+tFyeRzHrF69+hkZ1xNdr+Lczpw5k+HhYa677rr17mNgYKBn/ccee6wn0pxl2UYFSCpUKFC1lfn7QRG8WblyJTNnznzc9RYuXMiiRYue0PTxHxnNZpMzzzyTRYsWsWg9/YL/WXDppZdy5JFHcvvtt5fkprgHCgRBwIIFCzjwwAM59dRTmTZtWs+2j4ebb76559zFccxXvvIVrrrqKu655x7Gx8cZHBzkRS96Ee94xzs49NBDy+dNhWcWM2fORAjB//zP/5SEvBvrW/Z0Y9asWU9LAFQpxete9zp+8pOfsGzZsp4670Kh2W08W+FJEG/rLNLJHrLSnfm1uXxYSllGTRxAl/xZAEpQEjSLQBWy4Tzb2U2OhZBrfZYFXG+2MiddAlFQu5IkSudzo71j7RC/7qx1sY7/lzKTjrXYrmy8yGXfzjmM84TTOIdIDa12CxHoPIPtSJOENE3zbLfN9+nJdJGxBrBC5CQ5d7sr5e+51Nq5Mpvs5fWFvN0iHJjMkMRtjHVoHRIEEVEYoUJJJxMtu+T0a5HOQo6dvzTWdikC8uAJ3X85De7Knhcnvsh4d8vSxXqyy2XpAR3y7AM0oryGnU8T4CxC+HtJ5TJ721WaUJzM4t5SRcZc+JIChyM1tlQudAc3nk00Gg1e+9rXcuedd7LDDjs8buZz99135z/+4z/4/e9/3yM3/8Y3vrHe9Q8++GA222wzTj75ZH7605/yhS98Yb2BhnvvvZe77rqrR25+xRVXMDAwwEtf+lKgN1L711B8xtoPjvVl258u7LLLLgwNDXH++edzyCGHrPc4i+/s2uP6yle+so7L+JM53ifCxMQE3//+93sivVdccQVSSl7zmtcA8IY3vIFvfOMbGGN4xSte8bj7Kta/8sory+sC8K1vfatHqlahwpNF1VbmHw/f/e531wl4/DOh2WyW5POfmXg/Ea677jqGhoaYmJjghz/8Ieeccw6/+tWvuPXWW3uecZdccgkveMEL1tm+e56wcuVKXv/613PPPffwrne9i+OPP57Zs2czMjLCTTfdxIc//GF+/vOf87Wvfe1vcmzPdbzhDW/gjDPO4NFHH12nfOwfER/72Mf40Y9+xHvf+16+9a1vEQTBsz2kv2tsMPEuMsvKuZJY92Yj15NB7JFjd2qMhSik1dLLi7tl1TmxZq19+omzwFrTI0tXUmCQec2wKOu3c8rp6bgraGAnUNA7zPVJAzs+AjY/dq3ytHO+d4Enws4ZEDA6PsmE1kipiJOUdhxjjS2z/z4z7DyJ9CzVE80i4ytySX0pARcgHFb445FKI22HfFtrSJOYuN1kcnyUqakmUkUMDExj+vQZ9PV5oiGEJk8Tr3PMZeDEWjJb1F67kkB3af/pocL5mLO1arW7JfTFfhHeF6BT159T7vyfonRB5OMpzryX0gsQFvLAhMtz6kpKpAPnxDrH4q+e36fLlRVrX2EpcnL+d4BzzjmHV7/61ey22268733vY+HChUxMTLBkyRJ+8IMfcNNNN3HiiSdy8cUXs++++3LaaacxZ84crrjiCv74xz8C9HgQgI9Cvv/97+cjH/kIfX19j9tuav78+Rx44IEsXryYefPmcdlll3H99dfz2c9+lkajAfg2E/V6ncsvv5xtt92W/v5+5s+fv97WELvssgvTp0/nve99L6eccgpBEHD55Zf31Pk83ejv7+ess87i6KOPZs899+SYY45hzpw5LFmyhLvuuotzzz2XwcFBXvOa1/C5z32OmTNnsnDhQn76059y0UUXlRmEAttvvz0AX/7ylxkYGKBWq7HFFlswPDzMaaedxmmnncaNN97Yk9FfH4aHh3nf+97HQw89xNZbb80Pf/hDLrzwQt73vvex2WabAXDIIYdw+eWXs99++3HCCSfw8pe/nCAIeOSRR7j55ps56KCDOPjgg9luu+14xzvewVlnnVVGmO+9917OOusshoaG1rn+Ff46iszSHXfcwac+9SluuOGG0nPgC1/4QqmkuPLKK7nooov43e9+x+joKAsXLuSggw7ik5/8JH19fU/4GU9m21/+8pecfvrp3HrrrUxNTbFgwQIOOOAAzj777HKd++67j1NOOYUbbriBsbExttxySz7wgQ88rlpmY/C3aCtT4anhJS95ybM9hArPMF72speVqoe99tqLkZERvva1r3Hrrbey6667luttv/32fzVzefjhh/O73/2OG264oQziFnjjG9/IKaecwo9+9KOn/yAqrBe77rorxx57LEceeSS//vWvec1rXkNfXx/Lli3j5z//OS960Yt43/ve96T3q7Vm991358Ybb+xZ/lTUnaOjo/zv//7vOsujKCp/h3bddVfOO+88/r//7//jpS99KcceeyzbbbcdUkqWLVvGt7/9bWBdddRzFRs8WytMwDJryXL5NHSZV3Wt203Auq93xwxMlpljymWFxFrkme7eG6VDtmVXPbRESYWWnsArIdCyME3rkHhvtFWQwbVHm4+ZvH5ddjLaPe/lyzLTdfzOIZwB50jSjHacMjnRZGxsnGaz6TNR+X6U8HXbuqjfzok3zoDNcDYGUoT0UvqizjvUmppWRFoTBpp6PaKvUaNeC9BK4rKE5vgoy5c+zJ/u+xO//d0d3PuH3/HoskeZak2RmgRrTZ4571zL8npmGUmWkRqTBxHygACUCgIJKBwyl5B7o7LOzePwgZmsqLXvIt50XQfnivcsXYn8QpNAERjxpHjtK2XLc1mqEfyLde6T4r4q9uByyXsZjMmDBk9fB8Snhhe+8IXccccdbL/99nziE59g77335qijjuJb3/oWe+yxB+AJ8k9/+lO23npr3vve93LYYYcRhiGnnXYawDrkEeDtb387AO985zsZGhpa72e/+MUv5vOf/zxnnXUWBx10EL/4xS/4/Oc/z4c//OFynUajwcUXX8zIyAh77703O++8M1/+8pfXu7/h4WGuvfZaGo0Ghx9+OO9+97vp7+/nyiuvfCqn6K/iqKOO4oc//CHGGI4++mje8IY3cPbZZ5cEF3y2+bWvfS0f/vCHedOb3sSvf/1rrr/++nXOzRZbbMHZZ5/NXXfdxaJFi9h55535wQ9+AHR+B9cXrFv74TZ37lyuuOIK/vu//5sDDzyQq666io9//OM9fdKVUnz/+9/n4x//ON/5znc4+OCDeeMb38gZZ5xBrVbjRS96UbnuJZdcwgknnMBFF13EAQccwDe+8Q2uuuoqYP3Xv8KG4eCDD+Z5z3se3/rWt1i8eDHf+9732GeffUjTFHhy7fHWxoZu++Mf/5jddtuNhx56iM9//vP86Ec/4hOf+ERPucKGtB18OlC1lXn28dd6AC9cuLAnmHrLLbcghOCyyy7jpJNOYu7cudTrdXbffXfuvPPOnn0fccQR9Pf3c++997LHHnvQ19fHrFmz+MAHPkCz2exZt91u87GPfYwtttiCMAxZsGAB73//+9cpHVq4cCFveMMb+O53v8sOO+xArVZjyy237PmtK/DQQw9x+OGHM3v2bKIoYtttt+Wss84qn+kPPPBAee+deuqp5TO9ON4lS5Zw5JFH8vznP59Go1EGqH73u9/1fE5xTq644go+8pGPMG/ePPr7+znggAN47LHHmJiY4Nhjj2XmzJnMnDmTI488ksnJyXL7Bx54ACHEeuX8QggWL15cvl65ciXHHnssm266KVEUMWvWLHbddVduuOGGdbbdWBRqkycbELv99tv5yU9+wrHHHrsO6S4wPDzM4Ycf/pTHWGHDccEFF3Duuefys5/9jEMOOYT999+f//f//h9TU1PrGKltKAqj5m40m82nJF3/xS9+wate9ap1/tZ+hr33ve/l17/+NTvvvDNf+MIX2G+//dh33335f//v/9HX18eNN97Iscceu9Hj+GfCkzJX86TMYnLGso7UGP9wNsZLH4XoUCcppa/RplMXXcqDO3rhHtK2vkymdTY3DBMIKRDO5jW9hRlbMZ6ODHltiXVB8Lv3LQCpZFk77p3DZfGheaCgMDbDy7xzuXOaZSXh7CaCAk9eC+fv7gyyd/Y2CDpu6kUGXyqNr8nOncvLHLA/LmsVQoDJ/MSw2ZpiZHQFq0aWkhqJEZLG6hkMzphBo6/RyXbnQzDrZKZ9Jr8YuqVwdJcFU/U54+Lwyv15klxmqAGpFDgw5HLznmuYu5znZQGulKAXWxfXa21K7HLZPbmWoWPAVri/07WX4pytff17lBdu/eqHZwsLFy7koosuesJ1tttuO66//vqeZcceeyz9/f3rlZp9//vfB1in1/faePOb38yb3/zmJ1znkEMO4ZBDDlln+eLFi3smIACvetWruPXWW9dZd+3zfemll653UrO+fW4I9t13X/bdd9/HfX/BggV861vfWmf5+uqPTjjhhJ5+2080tmJCvL6a+N13353bb7/9Ccettebkk0/m5JNPfsL1oijirLPO4qyzziqX3XrrrYyNjVVmVU8Bb3rTmzjzzDMB2HvvvZkzZw6HHXYYV111FYcddhif+MQnynWdc+y6665su+227L777tx99909Lv1rY0O3ff/7389mm23GL3/5yx6zwe4azpNOOomBgQF+/vOfl5mDvfbaiziOOeOMMzj++OOZPn36kz7+glA75/jzn//MSSedhLWWww47rGe9H/7wh+uVEH7qU5/iE5/4BKtWraLVarH55puvs87awaru7iQV1sWb3/xm3v72t3PUUUfxu9/9jo997GMAXHzxxU+43cc//nFe+tKX8pWvfIWxsTEWL17MokWLuPPOO3sMm9I0Zb/99uM973kPH/3oR7n11ls5/fTTefDBB8sgo3OON77xjdx444187GMfY7fdduPuu+/mlFNO4bbbbuO2227rmdD/9re/5cQTT2Tx4sXMnTuXyy+/nBNOOIEkSUon45UrV7LLLruQJAmf+tSnWLhwIddccw3/+q//yp///Ge++MUvMm/ePK677jpe//rXc9RRR3H00UcDHS+PpUuXMjw8zBlnnMGsWbNYvXo1//3f/80rXvEK7rzzTrbZZpt1zslrX/taLr30Uh544AH+9V//lXe84x1ordlxxx35+te/zp133snHP/5xBgYG1hss+Gt45zvfyR133MG///u/s/XWWzM6Osodd9zxtPpvLFmyBGCdgFiRQOlGxyuHcs5QmVv9bfB485cjjjhiHeXhkUce+YR1+sA6xpUF1jd3WnuONTIywsjIyDpmbRs6932ytdk77rjjX/2NqvAkiLcntnn2Mq/ntush3t1y7u4Mt5SeKGO7LnhOftbeT0Gquglzd8spv3P/52zvDdRZ3782niV3tQ7zRLObjBUEtDBiK/ZRkjvRWVdaS+Zc3ubKljL0sp6ZbupPSbRtNwHNM/Rpvq0FtJAIpVEqQCr/PoUyIKeq1ll/vLIYtyWzGYlNsFrQGBwiigaZOWs+06ZPQyiFEAqtNUrrznEZ26tYKI+veN1Vp+86png4i0MiLFgpUNIHCgQ+o1+GT2TH7Kw4j15ant8LQng/gDxwIeh8dufaFRl6l6+XS/Lz2EVxvlWXXL1ob1eQeZ9Z71zftUsj1s6W/73jtNNOY/78+Wy55ZZMTk5yzTXX8JWvfIVPfOITPbLOO++8k/vvv5/TTjuNgw46iO222+5ZHPU/L8bGxrjtttu49NJL2X777env739GP+/666/ntttu42Uvexn1ep277rqLM844g+c///m86U1vekY/+58ZaxPMt73tbbzrXe/i5ptv5rDDDntS7fHWxoZs+3//93/8+c9/5tOf/vQ6Dv8FNrTt4BMFnh4PVVuZvz8cddRRfOhDHwJgzz33ZMmSJVx88cVcdNFFTxiwmDVrFt/97nfLdV796lfz/Oc/n8985jNceOGF5XpJknDyySdz/PHHAz6AEwQB//Zv/8YvfvELdt11V37yk5/w4x//mDPPPLMcy1577cWmm27K29/+dr761a9yzDHHlPtcunQpd955Z+kXsu+++7JixQo+9alPcdxxx9FoNPj85z/Po48+yi9/+csyq7fPPvtgjOH888/nxBNPZOutt+ZlL/NtPjfZZJN1fAVe85rX9GRujTHsv//+bLfddlxwwQV8/vOf71l/hx124JJLLilf//GPf+Tss8/m+OOP53Of+1x5XLfddhuXX375RhHvX/ziFxx99NE95+Oggw560vvpRkGoJycnufbaazn//PPZdNNN2W233XrWW5/vglKq/I14+OGHAdYJiPkkWSc72k3WK/xjY+XKlaWxLrDepEmFZw8bbq5WZidFxyBtLWJcvF8QnSKpLWV3xrFD+Dp9t8v/9MiJyzyos539CoG0DifAYnsIlciNxDzRz3eV99guiSVdcmPX66hdkO/u7HhBGv0xFdXCtpRum9x1XLpuOTxA78OxOF/kBDGQEq1UpwZaFwQ58C26pKQ4A2XrNuODFOSSbXCgJLX+AWbMWcDQDEl/Y4iZwzMZHBiir95HLYoItCfzxZyvIMlF+zGlBDqX92cOtJIorRCAMQ5jM1zmAw44k19DhUAihetxS+9ukdad7e6u4adHTWC9W3qZnbZd5QnFtZEoVbQTy5UEpZTdn13Xde90lvv9mbx2vTCq6w4Q/CMhCAI+97nP8cgjj5BlGc9//vP5/Oc/v05m9uCDD2b58uXstttunH/++c/SaJ8ePJ6su8CzOVm48847Ofjgg9lhhx3+qlrh6cDg4CA/+clPOPvss5mYmGDmzJnsu+++fOYzn3lcwlbhr2PtlnpFi7aRkZEn3R6vGxu67Ya0w9vQtoMbg6qtzN8fnqgH8OO1IALfMrGbmG+++ebssssu3Hzzzeusu3bA6dBDD+Xf/u3fuPnmm9l111256aabANbJ0r31rW/l3e9+NzfeeGMP0dxuu+16TDqLfV5//fXccccdvPrVr+amm27ihS984TpS2iOOOIIvfelL3HTTTWy99daPe3zgOzmceeaZXHbZZSxZsqQsCQEfzFobb3jDG3peb7vttgA9xoHF8u9973tMTk4+6SDqy1/+ci699FKGh4fZc889ednLXvaUDabW/l3adddd+fKXv7zOb/1Xv/rV8pgKbIia5Oqrr+bggw8uX/f19fVI7Sv84+Laa6/lmGOOYZtttuGKK67oMWSt8OzjSRFvnxH21mVSii7i3CGqBXntIWD0kvQiS1xE2zqZSs+q8hxoLm/2xLbo012SYSm7srY55xIdUu3RlamWsnwtxVqS9lyWnBmDVLojV+4iiwXBL3uGl6Zens1L6ck3onMeirFB7w+hzOvRldb5ex0C0d173J+nQgKeRzHy7LSUCqUDoqifadMljf5hJAH1Wo1GrU6tViMIAsIwQCnfL91CSdhFLgUXeQBA5jX3wjm0UmilQIAUFpF513nrCiM1T4ml8AdcBjBcp5bbnyefdRZOlPeOdb3rl1eqm6x3ydJ9VMPfD5Cr3J3LBee9JQrgsIWxXiGbd95Rvlta73cpuuQT/xj42Mc+VkoOnwgbKg/6R2jxsMcee/DTn/70cd/ffPPNn7XjWLRo0eMSr8eThz0VvOIVr+DnP//5077f5zqWL1++3hZtw8PDT6k93oZuuyHt8Da07eDGoGor8/eHJ+oB/ERYm6wVy9Y2tyyCS+vbtpBHj4yMoLVeR9oshGDu3LnryKgf77PX3ufChQvXWa8w6twQafZJJ53Eeeedx0c+8hF23313pk+fjpSSo48+er3nZ8aMGT2vC3XY4y1vt9tPmnhfeeWVnH766XzlK1/hk5/8JP39/Rx88MGceeaZ6z0vG4IbbriBoaEhgiBgk002edz2nttuu+0Tfn8Ln5MHH3ywR4a/aNGisgzq1FNPXW9wpsI/JtYna6/w94MN7+NNbqLlQAlXGpFBl6FV97rddbVdy3pkv/ly61zex5uyDtp1/X9R/4xzpft1h0h1apO7k54F0cZYOr28XflemcEv64Od77WdpuVxeeLYNXbbIZQdI7BOxl5C7qLdex66j6U8J3mf6e5zJ2WhGCg+2+Gs62mT5v+VSKUJowb9QhPV+koJt5ISrTVaa5+9l7Ik9uTnzB+/N3Arrk9J/vN9lH3YpXckt06ihcrr3buuSddxloZtJvOZSmvLOm6lvHxdWoVQXs5ewBqDybJOdjOXuweBRirp68aL4A69fLkT0HHl7SK7B9aVTl87c1rVGP7944ILLmBiYuJx3/9b9Lus8M+Nyy+/vJS2Alx11VVkWcaiRYvK34iNaY+3odtuvfXWbLXVVlx88cWcdNJJ672nN7Tt4LONqq3Ms4vly5evd9napK07uLT2tsWy4eFhsixj5cqVPeTbOcfy5cvZeeedN+iz197nsmXL1llv6dKlAE/Yu7zAZZddxr/8y7/w6U9/umf5qlWrnlaTySKzHMdxz/L1BQdmzpzJ2Wefzdlnn81DDz3E97//fT760Y+yYsUKrrvuuo36/B133HGDzsdfw1577cXHP/5xvv/977P33nuXy6dNm1YS9scj9RUqVHj6scHEu6jVdngJ9NqkpZv8dNdjO0ePyVbv/kSZfVSyuzbbFQrxHsJarrBWxrqQdhdZW5Nnwn1PcYlDlLLqPIFa/AcnvGjaWoekk5HvlszbnFRmxvh+3OVB+A8vDL4KJXV3RjcXhJfHq0RHOr72OfGq824VQUcx4DP9ncCFUpookmgdrrV+r0O8Vx/4WniXnyvnOmZ0opBqWwfSB1TMWi3CoDDDk3kntW762zmG4lwZa0lNhskMWIMQoK3CWo1SDonqKTlI04QkSYjjGGMyBD76bG2NMIy8Ol25zrGU176MioD00nElZFlSUBynthKnKPuxlwfeRf4r/H1ibaOcChWebnznO99Ba81ee+3Fvffeyyc/+Ul23HFH3va2tzExMbHR7fGeTGu98847jwMOOIBXvvKVfPCDH2SzzTbjoYce4sc//jGXX345sGFtBwtUbWWem/j617/OSSedVF7nBx98kFtvvZV/+Zd/WWfdyy+/vKzxBl8OAD4TCl5tVEi6P/jBD5brffvb32ZqaqrsuFHg3nvv5a677uqRm19xxRUMDAyUUtc99tiDz3zmM9xxxx098tevfvWrCCF47WtfCzxxhl8IsU5w6tprr+XRRx/lec973l85QxuOOXPmUKvVuPvuu3uWX3311U+43WabbcYHPvABbrzxRn7xi188bePZWOy0007svffeXHjhhbz97W9fp0a8QoUKf1s8qYx34UTe6Uvd+bfjTm0xJjdgy8mrFeCERXURaCEECplnKHsnBAJwhW67C91S9cL5upN9FaVM2+R101L61mPdraccYE3xOUXG3kvFu1G0vrLWltnY0rm8kK93nYtiRyIftS3MxPL9qrwPNTkJRvYSW+gyZyvPEWVmujgXPedcSqT0tXieSHe3cStao+XnwHXau3Vq8S1ZZvKAQNGmzUvMnfLS8GJ03W3WnC1qrIta/iKr3pHMF5/nBAhnc3G7KMsOimy+sYYkjmm2m4xOTtJsNgm0YqBvgMF+n9nv3HM+IFLUahefVxJtOnXbhau5K5UZ+Y1WbFtI9ytUqPCcxne+8x0WL17Ml770JYQQZe/sMAzL9ngnn3wyhx9+OH19fRx00EFceeWVf7Vu7slsu88++/Czn/2M0047jeOPP552u80mm2zSU+tbtB0sXMRXrFjBtGnTeP7zn89+++3Xs79nsq3M2liwYEGPTP69730vr3rVqzjnnHP4whe+wNKlSxFCsMkmm7DLLrtw44038rrXvW6jx1Hh8bFixQoOPvhgjjnmGMbGxjjllFOo1WrrlCiFYchZZ53F5OQkO++8c+lqvu+++/LqV78a8JnSffbZh4985COMj4+z6667lq7mL3nJS3jnO9/Zs8/58+dz4IEHsnjxYubNm8dll13G9ddfz2c/+1kajQYAH/zgB/nqV7/K/vvvz2mnncbmm2/Otddeyxe/+EXe9773lfXdAwMDbL755lx99dXssccezJgxg5kzZ5Ztyy699FJe8IIXsMMOO/Cb3/yGz33uc0/okbAxEEJw+OGHc/HFF7PVVlux44478qtf/aoMUBQYGxvjta99LYceeigveMELGBgY4Pbbb+e6667rMb087bTTOO2007jxxht7Sk+Kz9pY3HPPPeu4mgNstdVWpVLhsssuY5999mHPPffkiCOOYJ999mH27NmMj49z9913c8MNN1TBsAoV/kZ4Eq7msiSb9HDNdWXmBSHyHDWvvbUir9WVXTW2RWbc/383CV3bzdzmMnOKLfL9O/K+2F2ybS07WXlRZKW79pdXi3dkya6o8+7N3hpjyNLUE++CLHYRbiW7e353SCgCJAJvQN5VUww4k5t8md46ctd1jMV5tjavy7YOrXpbovkxUpJJtx7pt5eVd/hlj2y+lIZnOGd9GzPpDdOQAmt9vbkorz1euZ9P6KwxOBxSKv+nFEJItPI9vpUQmCDw7uWdq5qrDgTOGozJSPJsd5pktOOEqTihRkTdOtLiXJUHJspygg7pzpUYBZnOYZ1vm+bPl8wDIr5OvWhp9lSl5mfP35WQmreZEzV8JzWHxaKpoYRDyQApEoQUOCNRQmERCDIEAZCC0PnIM2KX+HoOHEpolFAofEBBKu3b07kU4YQ3u8O31FPC5X79AVaAIMO5tGzBpmUNgcGKBCU0khAhIqRLsdIBCc4JJBKQKEKccAgszgiUsCBCjGvjhEEhMdYhhUKQ+aCR1GBN6SBgXEaIApEhXQTEeTAsQDiHExYpNdgWmQtJs4zYtbD5CBwgnMC6BOEUQjoylwEahwWncSIltYAzFKaHTgicM/5YRP49BFLh+9W3bULqHKlNMc6PNrUpqbOYvFbEChAuQ2AQRFhniQGBwVgHwhEikEJRy7+/qYMM3/YuMxlTpNxjphhzlvvSFg0peKGs46RAIxlAM0MGNFSAFgGxdWSkRELRLzQNGYJQODIclkhKlJA4IXFO5udaIqTFWk3mHJlLENKrZ7yGR5CKFCcM2mmME3g7Q4MUGuP82c5cihAK5xwXjC95St+LfzRsttlmZeu99WFD2+M9ldZ64N2Jf/jDHz7hWDek7eD69l+1lXlu4NOf/jS33347Rx55JOPj47z85S/nG9/4BltttVXPekEQcM0113D88cdz+umnU6/XOeaYY0qXb/DP1+9973ssXryYSy65hH//939n5syZvPOd7+TTn/70OkGcF7/4xRx55JGccsop3HfffcyfP5/Pf/7zPdnyWbNmceutt5Z+JePj42y55ZaceeaZnHTSST37u+iii/jQhz7EgQceSBzHvOtd7+LSSy/lnHPOIQgCPvOZzzA5OclLX/pSvvOd7/S07nu6ULRuPPPMM5mcnOR1r3sd11xzTU+deq1W4xWveAVf+9rXeOCBB0jTlM0224yPfOQjfPjDHy7XK0rxur9zRd/0pxIQe7x2VBdeeGFPK7bbbruNCy+8kCuvvJKrrrqKyclJBgcH2W677Tj++OPLdf8W2GfRKxFS44AsTdFa4YxFBwH1/kE/505SpPbz0CzPlgU6AGdJ2k1EXoKYZQaTGazNUEojpcImbXQYMT41hUky6vU+ZJDP/5xABQFCaFCOpNnCWUs7iQmDkFq9Tprv02QxLksQMiRs1LDOYppTNAaGSE2K1iFKa6+qtYY0SX15pM69ojDYlFzNGeOEYHBoOo0owLXXkLSbhMJR66/RP1hnzegEv777fkanspzb+ESWzr2YAqWp1yOUViChHgVoqXFCoHSAMII4bRFoTaADhFLErSZTzYQkbTPQ6EdHAUkmUdIiMEilyJKUdqtNWKuhA007iYlbMWGg2Wq7F6N0jYnVa7AmxWUZ45MTICRSCabGx0kzQ5q0CWsRUir6h6YzZ8EmNMfHGZ8YY+a8BdTCiDTLqNUaGOfIsgSH/zdtJ2RJhgoUNp//1vrqCAHjq8dw1tE/OIgTfo4tEUjnsNZgnCUzGZNjY0ilSJM2JssYGBzwHZySlNRmvpuUCjDGkLZbTKwZKdtRWwf1qI4TDpSi2UpoJylBEBDHbQb66kwf7KfdSnDA9OFZOOd5EAgajRrWWqIw5Ic3/Oyv3v/CbeCT97b//U0Pye52BffZ1Tzjmmt8C0l2d2sxRG581TOCDiEu183bbRUmaPjpf56pdF011p11u+ukRb7fktR2cTdr3XqPo8xm52MxWUaSJGRpkku084ywUgRBgOrO0IuixrlXgl9mY7uILs6RGesl7kKWxLKbgHfy237yrASoPANdZv2Lc52P12fT3TpqgKK+vdtFvggqpFlWyruV8PJE72brCUXZRzz/s9YHIlLTJstStA6Iojpahci8pryUxxfH5UdCIQv3n20xWUJmEpI4ITMZaWpJ0ozE+B+CRlSjHtWo1SJ0EPhgh+yUEhT19UXgpch4F9fFOJ/RJw+uyFw9YPJAQHEeX/Hyl/zVe//xcPa83dBCo1SId3gHKQKcdIRCoX0KHoXNCWeYB3r898CqGGdDlMt8EElaEpeRWRDWIKUiEhKkRqOQCozLPLkmBedITO4q73KyTYCUDofxP0wIMmPRWhMAzkqUBCsVSknIMhC+Bt8Z40mvFQhpMQKk0yAyNBpcETJQWBK8+sAgXd72TmRIB8blPXqtRWtHZh0SiZYKgcq/yylaRiSmScuCNRkOA1ZgsGiZqzT8N760s/d3uvEEWQhw1pvnYXzLOedjUQaHEhbhJEaAdYZx06ZlUqxLwUkyZ8icwQmBcRbhHMZ1eVJYf/8kWDJnUT48BygCNA0ERhgkgrY1ZEUw0DlaNmWJmWLCGn5vW7RtxmYqZECGaByzRYiWigBBv4oYECGBUKTO4VAIkREITVBUdzgf/NJSEwjwrQz9iKSQZEXnBzKcVaRkuf7IB4IcOn/lXwsnAUviLFL67gy+WaDhy2MPbvR34h8Jixcv5tRTT2XlypVPSy3l3yO628r88Ic/5Pbbb68cbv8Jccstt/Da176Wb37zm7zlLW95wnWPOOIIvvWtbz2tDtYLFy5k++2355prrnna9vlcwAknnMC5557L6OgoAwMDz/Zw/mZ43S7eU8M4iZYCoWXeptj4OasKkUIRhApwWANZkvjElxJgM6wxiFwBmSYpUgpUEKKUIk1jtApKfyIhQCqFyfKnovZz2iwztCamULpIIOXGxflcX0pBFrcxmUPXIlwW46wliEKMdfnnhWSpwTlvhpzESemzZLIUZwztpImSkulDw4R1hUomSOOUUAe0WmM0appUSH533yOsWt2iMJgu5vxaK2pRRBhoAt3p8FMLPZlEKrSAMA9UhJFGSEUcp6RZjHM+GZLFMSKokRlDoATCGk90JaRpmvMHH7g3JkMC9f4hZs1fQF//EEJr+gYGWb1iBcZmTE1MMW3mMMI6RpYtI81SWu0WM+fMZXjOHIQUJHHC5Pg4UofUanV/fbUkayfIUKOcI7MWawytVhNjHY1GI1fLOuJWjFQKKT1HAfJAiyGzCelUzOSaVcRZysD04fz+AKkkOB8MQQifMHH47ZKYsZFV4DIQEgP0RzXPW6Sk2U5JrEUphckMWju23Op5BGEdhEArTWJTarU+z+OMRUURgVJc9fWv/9X7/8mZq62VlUaIUj7uHB15efE2ebaUXkOstfdXEPRCZt1NzGW+b5l/nstrwIuMtaA3ap9lvv1XIXmGbml1pwa9IHHWOazxF7HYT5YZ4nabOG6TZok3MgtCgiD05mVKebLnCqO1jly96FneOQNQuHw78glunp3Nm2D5qXyudS/Oh3WFWZjv8y3yunN/PkVXeXOH0JJHgLprzLvXKYh34SpfZOJT68iMIUmz3AHdZzKLmnm/DzAmJUvbJIn/ctQa/SilUbLjzl5ktbtd7L2RWu8YjMkzq0oiZUgYCPrylmYuJ9lh/iOq1uqvXpQTuLxUobgPi57o+ZnJs+L5Pj0zzfefS+LXri94kkhxWJEirUWLEC01wqY4J7BKkQiHQuGE722nXIoRGVrVcFYhiRACUpfhCMGCQBHgcFJhXEoqJNpJrGjjrMRJsDbF5WReuQwjHBaDRIH1pMpZB0qgnAVlCEUda0Eqf+cJlwI5q7P+2vp4TYqVgX+gWfJvsyLBgJAIB44EJUKfUbeA8A8CYb0cwTvPC1DWS+CkwuZRRUeCEwqcpJ3FtLPEm/AJiXUCicE4iXPGPywkmCxDygjpYh8hdxpJmgeflCfNQuEESBxS2vyxFdK2CeNZi5aN84CNQYmAxKZkGAQhzmY5aZcYslJVYYTDujwYgcMJTYBDC68LSJwhJQMnKMwCM2eIgRUuYblLGXUZbWuoCUlDaJwFLSQt4ZiBpCZDjBPEwqKkpE+ESCfyEhKvEDLCofzX35stKpln8y3GSbD+98yU3z2TX1aLdIUvhyFz3ozSCoESDuMynz03Eius9154St+ICn9vqNrKVKjw94ff/OY33H777Vx88cUceOCBzynSDZAkKUoHhDWNkpI0TWhPtctuPZDghKMZe3WYUhInBGmcYK1BCEkYBmitqYchfQMSlysKJsfHCes1VKBpToxTiyJi62iPt6jXQsKojpQhOKhJQTTYj0HSipsIo2j09wOWJI5JE/98V1qRtFsoqRBKYYx/RjtjSLI2SebX83MSC2mLJAFjLJFWKKkYHJpBo7+GSMaJ2y0yA7VQoLWmlaT84YEVrFjTxDnKZKJXonrDZEGeoJARUvkuEiY3JhbCIOuhT1ZYh2l5Y2OlQnAKHOhAEMgGSQbK+RJcrUOwCc5YMBaTl56CF15aoN1qMja6BiE0xlompyaImy3arUmGZ8/DpAljY6MMzBoGAxaDDiJazSZZljI+soaJ0TGmDc8gDEOCKEAjaKYJtUAhdIDMUsIwIggjkrhNs90iCEMajQZRrebVtmnq5/FS5+pSC7FA9IcMRgqFwAnfOtlkST4vAxU6/zpNybI2SJFnzm2uwBYoCVL5AEAQhsjEeE/mPNAT6ICw1kCHDQQWm7SxaUpteh84y8rHVjAUhVjhHv+m78KTMFfzN1EBB2UmtSC6hbTTAU505OOFVLm7xVa3cVkhre4h3vl72CJ76vzEX/QSvAKdNl+uTBkXLdB65fDCk7M8rGMKsppLgJyDpN1mcnKSVnuKODMEQchAn0DroJSZ++PJs6p0svo+y1zUXXvCaW1BRHOWU57TPMMtOrJ350SXgZsfm8/a+ol4ce6F6LQvK5bZLqJdEN9O//WOU3oxXiklURShtSJNM5IsJTUZ1qT+nBTqgGKf1iDIyLIUi8AaWwYKikx393no/H8hD/c/MsYYgiDoZObxxEVIH2GU0suMZd7WrLfNmD9kJTvno7iuSor8erpy34V/gHWF2qGzxYbKLB8PrdQQakUgpc9iO4vL+8cLk/gvvdJY4RBG+2yjBDKDxOQBjggnNJlLPJkmREqBMcbfD9ZgVYogzGXfFucUuOJYlc8JO7wkG4lxCiUM0ngJlJBB/rDy2dQMsE4R5ETMWYkQBpzGIHE2A6sBL7FKrERKgzK5dMQJnGpirM9sG+EQzoDzxNMRI6xCWYVzEo0n40Zo/75t0coMxmWY/PsgnQOivCuAJbXOy7yNQDh/HmLrDRStSEicQ7qUzOWKlzzwYISgnWZkzjBh2sQ2y6XVXgUAAZnx969zkJGS4V8rBInLAP8Qd1gQikD4IFuILO8lJxwGQSoU0vpccoZhEsukMfwhazJuE1ZZ32N2uggZcxkDwmf9a0gSLHUENaF81N46JD7TrXMVgROgnfASKGdwTtKyBuEsAdq3+xNeHSDRWKeR+Oi7E5IsD/IJa3HCZ+4NFusUFoWzBrxgAochsc8dw8H1ScP/2VC1lalQ4e8Pb3nLWxgbG+PAAw/kP//zP5/t4fzNYa1DOMf42CRRTqDDWugVj/h2sTazCC0xJsFmfq4shSKK6rTiFlmaoKT2SaPmJFNTk0S6RqPRIDGO5kQTHURMTrTQ2ifMyDLQPuDcjmOkdXkWFkIdkcUJralJhFZYY0hbbXSgUUGe8AKcEV5FhyOO24RKoZXG2gxZlKs5CLSiFiqSxNDfP4gWKTIzxHEbZ6EWBDjhSNttHnhslJWrWz4pJJVX8iqJkAIhFVpLapFGOD+HttbhjMhL0XxJYNKOMXkXIqk1WWoQ0qKUxqQJNrZoIRFa0hgYQiBoNcd9NllLlBJIY2m3WigZMNA3SF9/P04IBqbPoN4/SKA0SZIw1D+DyakxJiem6OtrENX6SNMUrSUmjmk32wRhgHGWxrQh+mYM+5K+JKHVavruSFqTxAlKBsRZ5kuRpSAzKSJ317bOocgViVL4JAwCJ/2yIIqQqUHrQQoPK1+6EHkuai1e4WBRgLOGJEkwWZ4gyuF5Xd5GGYlxeZmuv+LI4lrkc3JH5rcXAiUU/X0D1HW0wZziSRBviVL+C1PW3RYk21FKIgoDNpuTvu4a3YL0FESs5NP0UqiCRHs3dIvJnbG93ED37mOdkbq8ptMTWGNdJ2MKFH2wbe7cXUjErXV5oMCSJAmTU5NMTI4hlEI4sDVTHk+WZZ26Z7oInBA99cPd60gp/cl2yp+bLpLqRCEr6Zr0Wk8XhOjI9Nc+U911692S8O79dBvS9WyLN2cDCAJNFBVGZwntNKbdbhMnLe9MTtHbW6Cl/4H0MvMGWkc+AIPrIfl07b8IaJQ1+LkSwTnbMT4j/8GQKt8fuXmcb/3mrC0l5r4MoXM/+ePMVRAuzwrmZQl0Zf5xXmrb3QbvqWDKTmJtHecyQpFhdB8KgxABqUl88McFaOllzFblpQVkPuubOpRMyPDkzAmFdSmZS7BGgzQoEfpMsvSEsJRkOy+5Vi7E4jA2D5AIhbIGpxWp9bIqaf0viBAKZzIQeR1yanJlg6KdGQJhsUL7+hkynAuJrfHX0UoyMnAyJ8SBj8A6cCJGWUHqHIY2EKCF9kQRQ0YIBqRokdqYxGZ5qUCh+AjAJVg7hZQR3gBBY53AujQvyfAZaqz0UWBnEQRedO8MhozUOCaymNhmxM5HoKX0pN5JiTGaDIcrpOZY/AgNkJI4jXS6/G5qFBKLsv5H2eJbChogzc0DU+fv+bY1ZM7SdpY/ZVNMuYyVzuCAGp2yGZPff1oIQhFg8b8HNSnB+cxzSyRYp9FOgXB5HjpXyYjMP0BQWCGRwnhFhfXE2Qh/7pw1vjRAgjEuNx20PjiE8NJ0l6txHDhXhECqnHeFCv9oWLRo0QZP+i699FIuvfTSp/Xzq/7sTw7333//sz2EZxXtJGYw71gzsWaMsBYS1QJC4Y15M2tI2wlRFFFv1AmiiImpKYIgRIchot2kHtYYmDGNZquNabZQKkJorwqs1+pkgaTdnKJWC4nTjHqt7lvDpQZp234uJQSZiVEy8q0PM4NWEh3VaU1NUqtH3qw5J35IRRAoBBatNErW0TrwdeZpTK0GzVaKySzGpCSZYWhgmKHBOtLGmDTGZhlRLUQHirTdZNmaMZaOTAG5ybH0qllvyJzXeUsNVvuaZpGhgxCl88C5yzs6SYu1mc96pw4n/PvOgQ4j0lbLz0tjR70xzdemO4E10Dapl2g7RRT1EdbrDM6YyfDMmTzy0EMkrSb1eh0jIE5aNFsTBFEdZ2LipkHriLjVxAUBQmmiuiRutYnTlEafJAAyYwmjCC0UQvosvFISa1N03vrYWUej0Y8NM2wuPXRKoEWAMwaZGU/wgwCVJ+V0ID0hF4Isr7lG+muE8ARaWu+PI8MAhGJidAwlFdZkgEBYz1OCQGGxvoRSeh8jJWTenllg03buW6W8stBkoAMGhvqZmhilXmts0P3/pNqJeTIFwnVlM6Gs25XS3zQ95C93GC+y36VEPF/Huk7dcZmxLftle8OELK9DDYMIHZATae++7cl0Pg4pMbazTIoik+Py7He5IF9aEO+c6AuRk3D/pclMSqgFWncy9tYYn22Touw97vCyD1G6iBcBgU6/6uL8FQGLos64cF7v9Br3kFKQGZdL2HNHcJEfcEnaoSNn7ziZd+T4lEGGYn2RZ9ULtYKX5Hek3GEQoZOQKPQ11u3Em69pJYm0KvuDS+EN1ZTyBhnW+PrX7oCDMMZH7fJzYfMfgUIqr5SGPPMou+4bmZu6iUKt4A/Q5y3z+6RT/98JwhRZd+9I7wMrheqBQpmR78sTkaeW8V6ZNpkuHE5GOBVgTZtAaJTwX37hBMalZCZDYpAup1AyRYrE12o75VuoCVUa4RkboqXwxDCXDRvj5fQImZuAWVSWkZFihEI6h5QhmXNItI8SC5AuBJcilJeOg/EZbSIkEucELZdic5KorMKQkEqBdC2UCLF2gsx5qZcmxFhP/nV+rxvTJhXay9udBqG8oZfUQIawhsxluMxglUAq/4OXOJ+tl7QwBi9JtwmZMHl218vHTZ7xdsIHj4wFJTxpTjG005SWtbRNO6fS/v50wp+nFPKuBBmWIvhhPOm2JpeoRygkCEdg/aiEEoCv/4kB4TIy4RUBGQbrJIm1eQ24DxKM2Ixlpk1h1iiAupBMuJR+JFpIX30tIAAC6Ylv2woaQiCdQuejU0oSonHOPxSV86oJkZ8Xi0E6Lyf3lnZedi6c/3+DD0IVhiQI38ZPOYFCk5Dg0FiXeum8patMpkKFChUqVHgGIDTjk1MgHC5QpBZMyyCwSGUJg5Cw0UAoiZWKOLOEUZ1AapxzRPU+UpMxOjKCL+H0zzAyQxonZCYlabeJY2/clmUWM+VrfYUIESIAK2i2W8gBjQhACEtmE7T0iQCBL6VzRqLCCKUtcTshwVILQyanmmitMM7nQYJajSTzRqZSS9LEMGfWHKbPmEaQjDLenABjEdYns8bHEx55bDX3L53AAEr4+ZCXl/sEVRgGPuGJBWG85Fzl3ZKsReHrkC3eJEwo7efWgA40yAgVBL47kDUksfe7cVrRTlMsENQiBuvDZFlGnLZRWtPX14+wglZzijnz5qPDiMxa4qkmoyMrwEGaWWo15eepxtI/bRpC+XLEdhyD0gz1D5C0Wjit6O/v90F+a4jqdUASt332X2tNe7KZK/cAIYjqNR9QwCtAMRYZBmgrPa3MLEpL2nGbLElQWmFS38bYBxV8NyqEIEvbSKmROqQeKqYPD7N6WQu8kLqjokaSGW8+q3MjtiDU3txYSCwZQgomJqZQ0isRZa7qrtUHUMGGUeonVeMthETkrtCQ98kuMjk5KaXIepfbdLfM6pDEgoRKKXM5QKf2uJAV+7piR2K89NqSEOKdDXW+vSoy2TlknkEuPluWn+dw6+NZzstaXA+REwRBSBjWSsJrpTd4M84hbF4rLm1PlllrRfdoigxwKb3OpQlirb/u+uXi8710uiD4nfSul6cX9d6F6ZntyLHp9B8vggXFdt0GdD4q5G8mnRsyFHXPQghCHVALI/pL0t55rzx1kEucyaXdea1EPlzv7mzKe8Tvx29o3bqBmHLfzvlsd3GOZOFKDqZ016c8bl9n3xWAyKVKxWt/HSgDFkUAphDJbyzGTBtSidMSXAt0DUtMQJDfewHWxl4Cj8UKH5EUGWhROIXnpQcCAiTCOgJRmKVpT/acwNfzZuCCXDKdkeR934UDISKMyPLzkpFaixEWZVOkEziToaVAor202CYoEWBsQioSf24sKBEjZURmHUJYZNbyZmQCNKHPuOYu8kbkARfrDeWsdUid+WihFWQuzU3YIv9gFD7rLETiTT3wD1GVKz4MmVcpoMmc348ixLgE53we3pFgrCF1KU1jadvM1zkX94eT3iTMCYzoGIX47LbxTve+FgDnRPE1QOXX1Djhz6lUZLnMCWdIhCGxvn5LCkdmIBOOJimpc7RsxmM2ZqlNmXLe9EUACkkGZM4xJRyNnBTHThIJQWQtSvqSgNiBE4ZISAKpSZ0jI6FOzQcInMM74BclJQIjBJnIEFZSfA384zTzBN8KvB+sxQp/rhwWZ+Pc48DXMll83XdRolGhQoUKFSo8E6j1NSA1xEm7VMqqIC8txJDh8KJfiTEGgW+BpyKv5tJBhFL93o283SIKajjtCGt1b8hmU6JAU2tYpDPYzOKcJEtTkjQjTVP6+/qw1pK2YrI4QQeaem0QLSVJq+kz2alFSYdN2nn5my+LbLfbZGlGlhl0CI1aiNSKZtJGIEhTw8zZcxkcbNAftBmbSvx8TiToQJLFbR58eBVL10zlZm7OJ8CURCuJcIIwCHJPHgiEN6fFGZQOsCbL5deaAIOWEim15yWiUJI6rElJ0jYqjIjCwNeDO8fUmlU0BoZ8UieJabnMN9NBYjPDtBkzCMKGz/JaS2PadFYtX0mtMUA0MYGxCWGkSJPUz/uUYXxsHC01KtBe2SoFUlhqUQ0jHO12Cx1oan39njvmEnisJQzq6H5NkmXEzUlw/prrIMSYjLg1Wc7fm80pQh3iRJ5gcX5eJqxAKV8Lb2xGlrZ9Vty6PJtvcCbnbtYb4QkBTgqvNrQGIQMKIzonPLFO0pR6I/QmdnijOzuymvrQICrwCSwhhL/vNjBv8aQy3qWkuYuAlQnkgoAbg+0i3536XB8VKmqCBR1zL9u17+42Y0J552UfvehI1m1O9H1bKt8fvNu9W+TSZ18m4CfSuXUbZX/nIrvuOgZvBZTW1Bt9CKVIM4MOvAOxzmXQQnixZ56+9QGJXEJdKACsLQIHnRrw4qqosja+N+daJKo9dXS5nXFRV+CloUVNusiDAVKosne1l6qIvEVQkdHtkvoXGf/80wQCpQRB/kUpSHCQX29vtNbbqs2Yjmu6sbZg3fm5pfyTOcMuaqu7J/QdF/li2L72vcj4d7vMlyUMUiDQaLwzefc9aXNC1K1+KGrLi2PtVgF0ghI8JUyaJoKMCIdP7vq2Dxa8PEgYEG2sqyGcQ1rfckvlmWLvuJ3ihERZi2EC5wKvchC+dlpKH+gRTtF2KZCghMMSImWCRCJl4MlYTiQTazDOeOrlVG4MpnDGgYwhU0iRkbh2bmQWA5oM3yZMmjhXbTiE0ARC5vlhMC43rcDhjPK3qPQ1RkoKhNOkpo1FYDLna7hVG4XEuQxc5u8jZ9Ey78wufMsxX9UNzvj7WzpHRgtQJLZJ6ixt2yYxlsSRU2mHxld4YxOkFKROAG2sE3l7MP8d9LFUXwqg0BiR5feA/76Z3GyDXO5m8iWZcyR5bbQBUutokZE6x6RJWG0zlrmURAr6BvqYEwQMNQboCySrJ6Z4dGQlAZLEwUqX5kE+ibAWIWvUHdREHsQU0HYWbQ0BFic0LdFGO28mGIkA6zK0CLwRnPMGc86CFW2E0zjnA6BKSFJpS7WHdQJLmgcN/W9QVvoeGEB6GX6FChUqVKjwDCFuttEqN7g13oFaKp2rTx3WWFAOWVNeweUM7biNSAVp4ttQ6TxZJKQ3RMZBOpkRRRrhXWC9LFn4LKu3qLH0DfahtVeGBibEGENfXx9plpGmCSgFQhK3YgIlUGHNt+WabGKzFFIYGhogGIpothNcmhLVIpQWJIlmcmSUmbPmMzStQWgmiMdjWlMtnDFE9QCbGVaMNnlk5RQqDNH48RXcx2SWehhSU94s2iGRIT55ohT1MALnE3Bp4tuA6hBcmmKdIKpFCOuNYZPEkKWGyAlSKbwCzgLCZ91VoIjCuvcSSmIajT6E0siwTt/AIEGthsky2pNTuKRNLAVBFGBbMc4Y6n114jhlaMYwcZxg0pQgijDGMDU2itbTEdKXSCZxwqyhOWRxQhCGZDbB5O3dWs0mtUaDSGsa9Yix1avAOdI0IUtTnPNycqU0QdjA5I7jKgyxxqAzgQ5CALRTWOMTUrljMcLlpNg62kmSm3D7uZKwfg6L9BzJpQKtAgACrb0KFZBBgA4jBJZ5m25KnMZlEtM5fw8/7TXeXjadE5o8U1pItYXIzXuKNV3HNK2Q/1JIIbukw8V+fSsynyZ15A7mFFlMbwKFK9y+e8lqQbKK9YvssUNgZRGh6rTdKUhdUbdBQcK72onpIKAuIAzCPCoiCIMQHWjfq5jCVK0YAYg8uCBkd19vm/fTzQMPRWa657S60kDAGVvuO0sz2s02aZIyNTnBsocfZXJsktZkk9ZUk3qjhgw0Woc06v0MDQ0xY9Z0GgMN3yc41NQaNS/9EL4utiCipQldHrxQuTQ8M9Zfh/KcqpLAFqTY11z76+PVBi6X+hSZW2/6he0KpOAQQpWtzgrpO+T9ksnd8MsseIc4OyfKbHx5k+dn0JjiDnL5/eOjpKIrvlC65uPyzHCv4/pTwQQZzoLKWmTOYpUh0AENkaJsiBa+xsTbiTt07jqOzFA2IMHgnEGbCKsMpiCGKJzxphNOeKdtZzNPqBFIkaElvlZGKBLrcC5DOZ/nzEgQQoP1MmspHNamnhzb4nvr5cm4JHf0TrASApuhVOQdrl1KZi2psGinMDImkr5Po/+OxzgrkNJhncS4hNgIUhcDEimcz5Lb1Ge38VlmJX1EN8sMCOfl8cJgrcSS+hqlXIJvnJfbpzYltgnOKSwZToqyjj9zYV677NtqCSQ2d6uUmLy3t//9EUIiybcVFvAGJxTBDwGGPCgkfBY6db5+u+lSJp1lwqaMW8salzDpHG0stXqNmdOHmD7Uz+z+PuYNz0TajJHVI0yre+fVTCgeWzlCmiQsS1pMWMmgy5hmQ6apiFBIAqkIhM+2CyGxWAJLfm8okrxFnnUZyikQ/poaaZAy8N9pIzE2Q0rrv8PeSi53pM9l9NarB4TUGOdQ+fnyTec2Hv92zE4E6QjLHliFyDSzt17A6GMr2eZFW5LEk0xO+mBRX0My3hxj2lAftWga6eQq6vUEG83lRTvWWPXg5kzfenN+d9MVhJGkVlvE9oteQSMcYzL9M3bkAVaPZDz68FJmDW9O08zipXuexB9/ezXJxAh1MQitn/DHPz5MO5vL3m/eicmJpchgKx5e8ghK1VA6RMgIpQIfudYhQtWQKiql+bVaDSF9CZIUFlTof58tTMUJkRLMm9EgCjWZCxEuRdkpsG2yZBzSURyQpgHtxHck8A8DQ9yepJ1YUqvRSjAxFdNKMkIlaUQSrQXD/Qmp60NpRahVXv7QHdi2JIkkaAwx1K+8TFFYTBozObqSuDXGmlWPYc0UURDSGJxBUBsmCEKEdH6CIby8UWtdtmF01vi2j4WMQuRqNF/vUzamA4ewkFpLa2qSkdEJ6o0aGoMzcd7Nw5sUxqlBOJH3ulVEgQ9yW+PdiFPjnw1pasmMIc0MWWpJ4sy3mmxntOOMdjsjjTPSJCNODO3UB18z41v+TJ/Xx8jKlFn9U0yfFiB1HeMEtbpmaEDTiDS//rOlf6CPaYEhajRojk/RbI0ha8M0GgOsWdPEOsfYmlGUTHAi4IKrH92o78QrFi0izZpMTkwha/00E0Fzcg0zps2kNjSDmTOm005aJHHG8MxpDA/UGVv1EDZts2z5I4T9M6lFdUyrzerVy70ktNViYmzU30eJIbMBs+bMQtJmaHAaQVjzNatIVq96jDVrVjEwOEgQDhBE/TiXEUrB0LQh7wsBSCFpppLMhDhSlFJMjo6QNMfQStJqThLWa9T7QgbqQ8TWkCYxkQoIA//73p6cYnyySZIKbBghlSRwlnpfneE5c2n0DzPVatJuNhkbWYkUBh1GbPeS3QlqNVSgcEYipMOk3thK6wArIG4m3P/H3zF9Rj9h3zRGxlPWrFqJbY0yc/ogmzxve/pmLKDVHGdo2hAPP7KcyVXLedFLXkxY68vnbJbJpmHl6lWMrl7Bo0vuIW6OEU9N+OdVEBHHLdK4SdJu+99TJwgDTX9/DSFheM5Mb5ibJMyaM0yzlZFZP1+Lm1OMrl5NHGe0E0NfTRCGGukkfUN16o1+bNJGBQFTUxmjq6cQgSaqBV4B6hIQgkALkswwbdoMHP6ZOzDYR60xxFRrkubECrCG8alxpqYcMwYCFmw6B+sy+msDuLABWCbaK+mvT8OREtaGWLNmGeOjTdZMToL18xeBQbqMSEk0GqnrxHGbvsYgQaSxLiEII8LQG7NmaUraTrn9Z/dv9HNCCQhUSCYSRN7a1FrfslMFGrTAGkOWJpD4+aXWEilzw1rrEM5ijH92a+09Z0TuiGWzDGMNcZqQCe8JY4zFGAhsC60E9f4++ob68ppdiQ4CkiSm3ZoiDEKieh2Hox0neflWbrJlPeG1QtE/MECr3WJ8bIxWswXAvHkLGJgxQNAeJWtPkGQQKkdtcIBmM+GhFat5dMU4Qc2XBEoZeufuvGe3kgotIYwiZGZRgc6Vo7m3kTXUappWnNHfX0MrRTw5SasVUxsaRElBO47pG+hHBd6MrNVqI5xCkfl2yEqTtGMcjsmJMbT2SbykPYV1gomxNbSn2jQa/UyfM5PUZax87FEGpk8niGq0JiaI4ymieoM0HsO66QRKo7RCaEUjqoO11Bt96CgkTQ1RlPp2XCREtcirEVNw0hHooFQ/tuMEGYaoIPAGz0BUq/m5buJ7i1ubz4iEJCUvTTYZYRiSxBk2N8VO4tirBpzNDXOF96VSLZ9Vz8+pcz5B4c2c8+SDkPje8HkmXXjjZ5N6c2cd5IpNr42nUCFvCJ5kjXf+/3Qkw10r9KxbZL+LlQpyXDoDdkl/y4wqnczp2sS20yKryFLTkw3tdlcvtioiSEKqksyX2e6urGrREqybFEulkblsQQjKtlY+OJAT6WJdPJnN8gL/or6zbF/md14GKmwxrjwIUUxOTJoytmaMlcuX8/s77+Hh+x8iSWKMTWmlLdaMj9NstVDSmxIkiSEMajjjSOOMUNcYHBykr97H7Dlz2fZFL2Tr7bdm1vxZiFD6mvRuSXcxbuPHbUxXv3Hy2vI8od3pAd65xv7P+drerppxr1p2eTa002rJZ8x92zXnfO2pFpKirVqB3kx3R2Ze/KdTn+5bn5UBnrXu2bJ+v7gXnma0rENICyYmcZbUwZAzSBWilcM4TaAEGQUp9uMXTmFc7HuA4yXR3jjLIZ3yJhHS51dT60scRK5GwCXgAjLXIrMhZS7a+aZXxhnAIqTLg1T+HGjhe1RL18Si869rgMBi8YQWo7BOIEQLZ30bD/89cqD8ZD+hjcgCLAmZdRgDVqRepuSsb+cgIPdTxwoLRtASBucyBJaA0JN9vI+Dw+StK/L+3M6Sunbu9I0/Hsgl8iDRZA5EPvE3OKzwWd6CXNL9nvSSNWnx6hp/M3pnfmKU0xTicCe8HD0GWllCk4wJm7LKGlbZBKMETZdR62vQ6J+FGB2lTwjqUYgWgsF6jVmzZxHUIh594CGmJsfZepPZDPTXGFkzyWAwjb56jZWPjTEy3mJps8UkKWNZm0ERMaBCtFDUhKYhQoSAFtZLyTC+tt8J36e8UHIIgbApVvjSBvLzblwedHG+9Z2UIGzgt1O+FZlElNFzgVdZPBUkaUK7ndA3Zx7zpkuCukYwHZMJ2oljqtVmwbzZ2DSlf2iYNVMrmaVS+mZIZm4yn5v/JyVUKwllxjabbIeKgAD6B1cxa/58rDOsun+ceZvPZZKEmWk/iWrRsCHISVprHkRpx3aLXsPyB9vMHr2G5shq/nLvEoLBiPHxCdCzQNWQUeQf5jjfIcJGSGtwWZPVkxmJsUjrDelsOoZzgkYgSDPr6+dUxFQs+cOfA2bPms7COUPUAgdOI1WdQPmuA1m8hiwZoSYt7UzSijPiJME5SNOEWk3QaEyjHgqw3iwRhG+vJyFNDWlsiNOizUznN1HgCLSCeJSJLEKINlrJvDwpxODb3ySxZJPNNkFH07xhaB7Rd9blAS5JnKQ+w2K8gaixWT6hsWQmJTOASUmtwWWJH6XslHMpYYloQeoda12uDEsSRzueIk0NzgrSJCPLLGm7TRob2rEhjjPSJMVknvDbXFklhC0fOk5APQJh/cRF6vy5kQfOQg1ZGjPxaIx1kmAaCKkRSiKdJNCSWuQnmKunHAvmSlSakZm8rjR0WFIvHe2LEDKiPTlKaqRnChsJIwSJGmKz7V/E4MAAa5Y+xNIVkmmD/TR0SrL6QbSU9NUbyPYaVo8v54EldzM+Pslks0l//3J0EJK2fQvFdpKSpjHW4FsJaoGUFqlDBvsaCAlhpAmCgCyzRFFI0N8gHJqBEAFhEBHofoxJaLcmfM2oqlFv1Jhop1ilECbz7YWMn3/UG4PErSlMnJBpQaIThARlDca0IRjEZo5W6kDVqNdColpE6jImR9fgxmMkKTaN0Y3phLWI4dlzGB15jNE1Yzzwx1+xyRYvQIR1FI40aSHDGrJtkTIgSf2kmno/f3lwJbhlLNhkU7bZ9gXUB2awZqzF/Y88wMzxVczfbCtCpZk3azp/mVjD8kcfYv6CzRBBSBJP0l8fYnCzzZiaNYuZs2by2LKHeeTPf6C5aimZbGNMM5+LerOlNLWkxuByU89saow4tUw12yTJOFpHfm5oDRMT47QzB0oybXrkW9MmhiSNmWy1qTcmyVKIAoEM6wzOGCTNLFI66rWQ1Crvumx9Pep4K8WaFjZtE8khwiiAbJx2mpK2m9gkAWuo12uYLAUhGZtYQ5yuIEtiVFgnnniM/oEBJieWYm2ClIbhgQgZ1bDGIbVC6QbtuM1jj4zRHh9jqF+gwxShBVIGaFVnqtVEBwHNqZg0zjb6+wC+/3SoHYmRJCbzCTfh/UmSVkYQaPr6GrhA0261IcuI4zaBEuhQ0F+v+WysBWeFL8Wyhjj2LUfrtRqBU1iT0G6lOGew1mEy3zLKCZicahEEygdelUKHXk5cbwySOZ91t0mKSA3WGYxwhFGNRl8/qfFBJmUdYRiQGsv0gQbTZs7ycvdshCydot32deFhpDHW8NCyZdz30CqUkNTqvktSqINyTqzwwXfjHM12Sqhk3hbMq0K1jsisN3BDKkwGadrGiYCBmf0UKtxavYbLLIHWmCzx33EU6BClJUmSIGzmVb1xijOSel2QpC1Ak8Zt5i/YlGXLljOy4hGSuElfXz8Wx+ToCFFfg0Z/P1Ir6vUGabuNDkLqUcOrca2hf7CfIAi9/5dw1PvqtFttrLOoRNFqtQiigCj0v21BEOKAMIy8n5GxtOI20jmEseioTpDXUAvn/y2SL0IIkjTL53W5iRqASXMXcufb1DlwwrePLuaIzoHSqmNHZsiN23xrtlYW0+caft4ovcJChoFvcyd9WalPrxfJ4r+OjSPeojc7aV1BHinreXvrqruJst9Hkf0tJOJFDXRBzK0VXWSvaEnW5ZJtXS7zLohdh/SVQ83JrulyIS97ajvbIWaukzm3ZYbUR1Ok7MjYC/Lms+Wdll1Ffbg1XkZqC3LvzxaFrrk709o9vTXWsmrpUu6+7Zfcv+QvjE+NMTYxxuTkBKnJ0IE/P4k1xC4mbad5YAMC08akGXESe5I85k0azO8N/3PbT9ls/ha8Zvfd2W3fV1Prj9BhWJ5DIG9ab0qS3TmfHawTRKAT2ChuOtW1TdHSLb+k+T2Tf0kE5f5VnhEvpeV5IKLTAk7m5gpdJ0x0bu5OwKaT0S60FfnlRwjhTcDo3Bdr378bixGXYKz0bZqMLQnOAIY+Z6gLhSVE4dBKI0hRBGBTjNNYYVEOwHrjLGWwJBjnDTIM0ktxhEB46oRwktgZFA7jEoTz7SaKmpVMGgQaZ/Iss0sAQ0KQ/+AInEhQVqGFN8SLXc5ohSFE+bZhzvoe4ggQKYn16g3jHMZNArlZm5D4vKyvIVYuy6XfGuPwkyibInAo4W3DUpP61oMOHF5q7/BBGe+jYHJHS+PJolMY18Y5nTu/u7yWPsJgCYQjs34UPg/X6bxgCtduwOZBHv+ey83vIgw+ou0cJFgmrGHUpqywbVbYlKYUCC0Z6OtneKhBf6NOamHVyBj1KCQMA+qBIgwUfUqDy0hNH+H0eaxJDGuyKaSRtIwlakQ0+gNe2D8HEUSsXjHFo8tX8djqNYw6y4BJqUtJXSrqQtGvIgKncvO0DIUmkBrtfOs2Kx3CZUgcqU3wMnNDZvP2J85ihcqPFYTIPLFzAuEkaU7cZe5l/5SRCDZZMI9Va1KcmuTBB9ew+dzZ1GoZE01LqDWrVq4mVHWet9VMTGOESesYDDNacYuXvXgAK+rcc88aHjr/qwwMCggbTLXvZdVD3yKdnMBoxZ03/YosnMbUYy2cTFHBJFn2J/pqbYyd5M4bv8DAzGEWbDWDR80oK1eH0FqOrL0A0Z6iUWtj2zFWREw0W5BneJ3Nyu4dEy3LREsQRSF1nfrgVV2jVEBzYg2pVVihcBk8Or6M0UcNc+fOZ/r0adSCgGZev69EHSstcTqBZBLtWsSZZXSiRZK0mTt3E8YmWqXXiX+2+UCIDRxkGVpKIqWJajXCKPCdIaRvwVgog/wzSJK0JnEK+vr76esPCDFMhCEmGCY1kMYZNmuRmQybpbTasc+m47w7b5Z5V10tyrKoPIwGUhAgyKQmSQ1ZOyGJ22Rx6if6kWaTTfsIAp/leOiRVTx43yNokSIwvuOIcBibZ82doJ06JhNBoKAWOOpB7hMi8z/8z1OaCfrqYPL/z3IDW2MFWaHmEI7BPhAZBIH02QjhCJQgCiW1yGdUhxuWmg5ot5ok6Rj9IcjIQW4YqgUkpuWNDxPDtP6+jf5K9NUlg0rRXLaE9jLD2ESThlZMrl7KmvYEGHBKEjWGkKbN2OoR1oyOkhqHzSzt5rg/UKVQgcbYDGEcSIhqgiyDMPAT87Q1QV8jwqaaJI2J4zZCSeYt2JwZ0+aAkpjUoASYpMXYRBuZGWqho5lM+vd0xFRzlLS1GoNgYMY0tICgHtBKHWPLVzJ9Woso0KWiLTOjSK2RgSaUlv7+GlILhKyTTLZInSXOYLLVYiisoYSinSaYLKWmBfcv+TMPL1nCtOFhnE2YNm8h9b5+psZWo7RGhxHJ1BRpljJzxmymEsEDDz7KTrPnoaXh+VvMw24+k7HJJqtGx0kf/DMLNnseUdTHQw/cz8yZw+i8TVGgfXvIeGIZfYFg3tx5DM+czcMPP8DSJXeTTIziMuvLjEyGk5I0S2lNTNCKM8bHJTOmDxAFmmbTYN0ojSgizrwXiVYhWhoC5VVbOlAEkT9XTioiLUBm9A/WEM7Q118nMwLppqg1QrKsj1VjbWSaEAYRGAijBmvGJ0jsI/732mYY52inlnqfVwVkxrtlJ7FPAokgIo0zolAxOTlFuzXlu+Uon2jRMvLEGkkkod7fz9BW/YyMWVy6gkBprMzIrEAmTcKgRmJSpOwkYjYWqTOYRJDk81YpM6IoIIgCVCCItEIIQ2sq9oZqShM2BsBZX2OLIjUOHQbeiMwq2u02CIdLU9JUoFRAGNZxeIdtKSw6DAiiyCeckpQorKGCCKVDdOhb3TprEYVfVRBAGGDT1P/hiNstXGaJahGJS3HtmHaSMWvebOqNPlw6CtaROU0rnvTZ9szxf/93P4+snPCeMoHEZBAEvn1sFAZeTWpsPlfK/XOUN5PNMkMgFYQ+AO+AQChCDci6P49JAtK3Fo1qDZI0RhiFNQ7loDbYz8TUOGma+M4/NvPHqgRB5JMuWkUYa2iNr+HBP/+Ren8/KT4IkdAksBoTT6ECRa1vOkMzZrBy2TKmDU+nf3AQ8ITapN7QVypFYmJvPhdFDAzUyrm6n+d7aX1iUtCKUAT+ftC+lr+/b8Dzm7RFljmU8uWuIp/HmTRh5LEVDM6c6c+P8a2h46ztvZXiNr4TsyTLvON7oaxGSJ9yz82XpZA460lCEGjSNCMIJdqG3k1fhWgZYAORS9BVT8IZNtyc9kmaqxVx9k6G2OS9oQtHcoToyi6KkuAKUThM92ZcC/JUyIl7CVHxWWXOs1zfiQ6R7RhzdcZF1x6s867GQvh/sywrx1xOKvJ96IIIdh1PxxxN9BB3a23p4i5ywk3u3O3w8sQyK55nbnXXcdpcFfDAfUu47Sc/4cE//4FM+r66cdKmnUz5faJJTQZSYtKEOMlQ2pOIdqtJmv8gSCnJTEbq/GRpResxVv15JQ8ufYDUpLzk5Tswf8sF/scJz2FNd7s26SU7HdO2Tt9r5+hqDVdk/PP/F5266vxoe+7HQlVQyNG9ZEaUgRNvfibLTGS30VrOC3qCSWtn7E0uUcQ5sq57RMuiPVnneIp7xLtcP7WHx2PWkElH5gQN4e+JJEvIXI1EZsQyIsRRQ6OdRUmDFM6bqElLbJ33npYqz7glCFFDihSc8fJopzEClIgQwpHSJMlbhCnpDSAS2wbnRcVtU0hwLKltkwrjyyDyFmbSOowDLRJiYb1EHJcbc1laThPYIgjlI5XCxjjqaJfl5DUD643aBFlOcA0ByrfnyOWqSgjfdiuftme5vFtYSyJsRwKd11L7HuOJl37bIoPv67nSPDhghA82KHzAwzrr5W/k9dou79ctwAmLkw6sD9pZIHUpFoWwjsxl/tiBzPnM9hqbstqmjAiL6G8wODjMljOmM3faENMaDh0MMYVjzdgkSvcThYKZ0/tYvmoCKTPa7RZLlybMne940Yt3ZMGquSx/5AHWTIwzbVpEO3O0YoOuSbbcdD4L52tmLV3NL357N61Wm5E4IbKCIRcQC0OCI/QCQGoiQAkQpo30xQDI3Kleo30A0fkHl8nd/F3urF/+nuHN1bI8y+tQCGsQQvuSgqdIvkXgwBmGhzXJlGP6jLn0TR/CJKMESjKVZEgtmDmvzuj4BNMHI9prWkwqRdSwTLUnCIRgqy1qWBvRGm/TaidY28fPr7yW2uy5iL6UwTTFTq2iaQT9uk5mV/HQ/36Rqal+VF+Dx/6yhLE/ttliS8W0zWcSTSTct7RJwy1BB3NJraAeKPpqgv6oxsRUi9EJ/1uaJhkSS10aopphfDJmZStjsD9i1UqD1tAfBehAUNcKFRRmiZKxFVOsXi7pGxxmxvRBAhUg8p6f2oVkpoExGYEaYzBqEws/MQok1BoRtShAKF8aBJIoaBKYPqSToBTOQWwkbeMwWYaxMSpvmyKEb6MZhgqyZh54kfQNDeBUxOTYCGlmqUcaKSAQYBTUo4AkMSSJdwJO4zZp0iZtp5gsJcsSbGJ8x4Esw5i8bEWDlBal/O93EIBtSu4bHUVFdZoTU4yNjmKERYeOKHR54tiRJ1R9Ft9KlLSFpQn+meKD6V4BKEql1VQL4lSSpJY4FbSNJ56Z84HgWu6toZUP8IaRILWSMBDUIkkjUrQTyYLZ/SAszdggQtDSl/MIYpzNiHSKM4JIa1yUEer6Rn8nRlc+gpARMVGu+JIMNuqseXQNY6tGoKbpb9TJ0jbN5hTNdhsXGGoDijSGuAVa+wSCy4wvb9LOZ2AVDPZJ4sT/Xq9YPUK9GRHoMeqNIWr1PmZMn0ljcBpK17FZBiojSyZxStKo12k1p0iSlq//xLF65V9QylLvaxAG3lDIZlMEoULIlDjQjKyZoB6EhKHKVW1tcBapQmpRhFYRQVRDIHGBYObM+TgDfQN9pMYwueZR0lYTaxwgCWshxjmmmpMILNkjf0QFNXCCsFYjSx2N6TOZnGwzOnof8xcsYHirzZlsT9HX36A1PooKQ4YaEUON2UzNmMnI2Br6647appvy6KPLULaFM2PMWbANKuqn1WqRxi1q/UNEjRqbLphHX9Tg/+79Fc3RpSjhEC4gSwxOamInULU6qc1YsXrSe5T42CatyTapcURBxEB/n39+S0sgajiTd4bRhelqRljzaqYwrKGDAOk0rWaCMhmBjhgc6GOiGdNstgllBkGNVqJprVpFX98gcZqStZo4vMoK4Wi3U5JmQuIsgYaBvgHG7ASTzSZKaUIdMpm1MYmlFgqcNmgCX3aUhlgjsDZlqAax8gEQL3+2pM6SJU3SzOLSjNQ8tblT0jK5zNo7d6dZm6lmzJDUNOohzjmarRhjBSiI6nXCIATnmGpOEYYBEpDGZ5S9SsYQhgFEXkadxV5KbXPlZBgqQhXitEKrACfqCOFdwuv9fTgB6fiEr8Wu1UnzOSXOQuDlxkr7eZeVXpWTmpgsMQzPnkOjbwiRjGDaEzRjS9qO0VaiI8VfHl3OyjUxoJDKK5cCpdCBolGvewUssmwtK4VCCYPKA7C1euTncXn5XRjWAEGSWgaHAoQ0WJP/VgpLYjLCUGOS1D8HgoDRNav8/F75OX6axGAcUnpVh83d1rMMpO6jNdlibGQUqUKytIUzKVGtlrdR0xiT0mpOIKRjanwcm1nSJKPVaiFwNPrqPLJ8Of3TpqGDgDROENOmIfBGcFnmHedVoKnJGia1CO2TL5mxefmBITWJD+qJvDtR3tucLEUozaz583HSfxmFMChjCQKNMRm4OggfiMqyLFfI5vPtLm4ppfLvKYHLTdgQkkAKkJIwDHC5NL1IOjopfEmtlD2q6Q3BBhNva4tabFvWbxcTvNKFHHzGV3TaZXm4rkx0L+kusslaekJqnM0l6vmWrvi394B6XxeZ5I57dve/3a7fxmSd/edkWtCRNENOknOJslIqz+Z2XMKLNmf+/30f6iIqT14fWpLv/MAdvlC/IN7WOaQ1PPSX+7nx2h+wcuVSWi6GdoIOApCgo4CpyZY3d8prVrxcz6GFpp22iZMsz/J2H29WngvrLCunHuOrV17CIw/twTuOPpTaYFRmik0eRECAciByyYQsa2jJZc4FuaYrXd9bk52f1K62aL1BlFJyLju1/saYvKWcKGUynfsjP57iDK/1ud1BHaCLXPjPM87lpFOU+/OZWn+Pdd9nG4PEOVYYQ0tAXULdOCIhGLAZgzJkUKY0rKYh6/S5iMA5ApGRCeUjt+Q1Oy4uD9u6KaRQPtMNKHyJg7EtH3l3GUlRb2pyeTAOa9sg/CQpJSPJHC2XEQlvWCacdzm3uQO4sSlG+Nrsore9M85n1vNJq7Q+Mg0CJTKsNF7G4yQOXy/kp00gZIDBqzIQBolG5oaAQpAHF9KcYBuEM17OhQCnkC7xonkHzkm8i7uXVltiLF4FYBFETpPIDJwlc2BJ8xZb3pzM5g8xa7waIwWENaQu8w7fwpsexiIjtm2mnGXCxoxaw5gzJFoyf9NN2GLhLGYNzWH2zEEiZWk0+mgmGX2thFqkmTFcp1FrUAsjZs23DNQGmBwbJ3awcsVymlNrmL/JZgwOzmDViodZ+sgDrFo1Ql+oyagx1pxi3uxN2VRrXiW2ZsXIJPc99AgTUy2kdUzalCjLqAlFw2himRJK7a893oytZmtk0qJtRiDAOukDuQJ8rZLy0XeR3wN4cuaAFIMUQekgD47sKZqrzRjsw7aW+Rpv4Zi/WcRE3KY9ljJ3k02wSYtA9VGLaqiwDi5h3jTJstEmM/sTstggXEDUFzCzv8GDk1M0BvoIRB99L9iKqWQ19cZmNFp/4J4HoQnU59ZZM5bQxxSrpyT9QyuZt8nz2bxvmL4ZGRpIkoS+Wkh7bAk2mGBK1AmjIaJag3oUEGjL7KEaSewYn0poNpsYE6OcQdqUukiIpyRRAKEMvGLDBljjv6VWeBYbSI3Wmqy1ilXJGGFYp1GPIP+eFAq3uKlJEsG8uXOQwQAuN49sO3Bx3o/VGgbqKc0kpt1uI4Wvr3T4DG4gFToQKO13LILAmxRRR4eaKPKt/aQaYGL8MZqTTdY8tgyTxqRJRjuJMSb1ZhkuQwiL0s4TDuEz3vUA0A5qXnkjZeGz4nKvD0Gg/aRFSkk7dUxMjTC2WtBMrDc6VPi2gDb/1whM6shST7yn2pZ24iczaeIfMKESaOXnGGHg7/kokGTGMWtGg756yIqRCepRwMy5Q0RKMjLeJG4lPPJYjBGGMICBRsB4SxAGkkZNEwbSE/c4ZaC/RhSGWOFQIia1jtXjlj7RJhQhWjumDUasabYIwo33PojjNsa1GegfwNqMuJ2xZOn9jE8lCCUZagxilaVtDEYKglpAmtnCFwgVyLI1qpC+FaZQvrOHUvhes0FIo3+QgDGchVq9jyiMfNeSqIGUIU74jJHNDNYJ31bSGpyUWAxCBQQYglAgjaMWeLllnCVkJvFkQAaEdY11ltimOGOpqwib5X4mZCSJw2UD3rdGaWbP2gQhUprjK1ENr1rKEsP4+ARZktKOvQLKGUdWixAKVBCASIgijZECm8GaP/3Rl0nU+/jzkr8wPLyGOZtsypi0BLUatVoDJQOsNQwODVGf0U8r6+PBBx+gXwsmbMQDf17KQ488wGYLtycxbaYNDjO2Zqn3cnCKWgTzN38+S6UliUcRWYrUAZjMT/6BNHYQ+HaqzvjMdrsZ40jz55FEao2wCY6MzFoCGdIIaxgpwPrvmrOWrN0k1CGhTgkH+mmnbYzJqGlFMFQDETA2NsnY2DjKGfprIVZYJkanmGq1CALJ8lQiw5RaGGJdyvRpDYxSNJvjPnCVq8GMstSCkKmmTz6lWYZzAusypPLmXlqHOAxKKdqZ73ihlCcmmYMwUIy3UtLsqT0npk/rJ3OQZgaXGUIdlFLjOPZ9qqOgRgbeJRuf3XTOoqSkOdUE55WW1mZY4UiTFEzmjc7QOGWxeHVHIDVS5tnVOKEehdQbff7zncSalDTNqEcRraRFkjT9PFUqb7qFRP3/rP3Xr2bpnt+HfZ600ht3rJw6nT45kEMOSXE0YhIl2iRBSPSFAerGkGDf+Q/wra905QsDsi9sGZAg2YANwbRkgTKH0jBM4Mxwek6f06dzV1fc8d1vWukJvvitd1f14Yx85rQXUOiq6l1vWPH5/r4pyf1bW0VmLDF0pN6wNztg72iPWJ+R6uW1DazparLScXJ2yZOLLTrKfdJqUU3FpIZAWgF0vu8gabJCrAtGG2LsscYIE6+GhpbOk+goy4wsk6Fi0yn8EDgmlWRWCBEirjDQB3KnpCpLKVxm8V6wjzVGsEXosDZjvrfPrfsPOH3+hOn0CGUKXr54zGg84/jmHboQKKuK3BUo6xjP93HGyv3KaZIPBC/n2L1yLFkR6zW+b7m4PCUvC4hy7TQtZHmGoC1oOzlG3ncURU7TtBhgeXFJ09aMpjNcVpBClOesl4BZayxoNRCr/YBtJDwORBGqLMQUhTwySo5r3KE3sdp6H2TtNBCDPkVRg2lNCJ60sxzDjn8cnovDMOD/38D7dYC1807vFt07qj5eT4jSUGGjxB/KVxn5HeDevW4cfhklHs0de6oGWfHwdsBXJS4x7ZINBRi/+qwC1V4HWGkAkSEKM6a0Fu8X+vo7XSen74YIO/Z996F27xt6ur57BUaJqJShNeI1AUhDiBW7FHiG7zKAQBLrzYo/+N3fZnF1LtIbpeh7jwmRZI2UuadIChBjwIeAHzrH+9gPsvhXgFvYiHDNIIvSVIKlruoF/59/8Y85unOLv/o/+XWKKr9mudWQjK7VK9n/9eDilQ6fnQ//9X2zk6DLabA7rgoznISBXQK5gMgdfk5DddzOoqAVXz0nhgnSjrVTOwQ3LPp2wHt3Plmtr5Oar/fxMPB4nbl/dS7/YpKQ//FNzvOr5LmKCjPUOhBaMl0zUYa5t+ypjH2TM7aOqSpw2qCVJSOhlcNojaXHmDh4n2XKmrSB1GGGFMqEhIps5YRApyHkUEUiBu0V0UBMPT4lCXxTMgU1IF4oPCH2pKjwWhHpsMqQlMdiRH7spQnAKDOAcmGVdZQKtESPUhLclobJYQwtQT4FKXmCbjFJzoUU1RAWp4mxFxY8JfokNV4qWZIa6jaQ9PAUu2sLh0UYaauE8dumWuqz1ODSSYmoRGQuqorBi4fCx4BnAPkJOkRq3QTPmkAde66Sp06RNZHxeML3v/U2P/zuN1mvVsxGEwkrCYaXT75gudpwerJku9mQZZrxyHLr4IDxbA+nNbdujSmrPWazghQUP/3gfUbjkoNbt7hYb1CLLavtBqIiJocaTYg+oE3g0cNbXGw3lKOKFODs7Jxl3+Niz1g7xikjD55CGxwRh6XWDSkmWiImvhqggJGQrYTIz5M8ZPsUcFqL5QCFUS1eeYjCIKivab9YPXmfbtUS60jTw+eLj9l/dMTNO8cYY8kzx940Z3t5QpZPGY3OOelyQud5/NwzmijyUrPatgR1jpsY2NbkBzlvffeHnJw8RkXHjZtv8tEffYa9ZVg1mlLNePCtuxyvLjhfWPZvTcDU/OEHj5mPZ1Q4JqXm9GmPzZZMZhHjWxYnHacxZzQe44zDmcC4NEyLnNW6Z7HY0G5reY54iLmFLEIyZE6hrCXTCm0sxhicE3WFtRprweqW1PvB7xxovcaaMSYHmwLLWhO3a9oukFmxbRS5BBaOKkeoT7HZPmXmicGgrDzTfJdofUPsPcG3RN8SfItNLbmRKpbpzTeZHNykXZ2xef4euemY5ol1DJhcgKnRwqYaraSuRitA7kMaBquHgD1R6Q1VegE6H9nUkc4rJhVkNtJ24Ay4PJGnIXgmJYwyjHJLvQnEYJlUhoP9MaH3XC1rRtMxbz084PnJFUZ5LtYNWmnyIse5AqKnrByXi5ZinDGbFoyfWWYHFeeLjrPLLdOJw/YelCiK9qYaa6SiqMgNZS4ycq0sewclRmfM5x3bFvJiS9sXJC3SfJUS1sDag9WGq+X6l74mnnz+Ah8jRe7wUUxDSimKakRRuIFBgXJU0ClP20PsBRTHILJbVJBcTqUwShb/pZP1hbFgjWK+f8jp8ilZnmGUxmYleVFB9GROSzBsUmy7LQB917G8XKCdIZ+MCGicyZjlOX2zHQaUPSr29G1NXpa4csJ+WdButywWS3zwtH0vib4RTEqkkFhu1iJjVgWVNVwtF3zx2RNOXpxQlDnogq5X9P3QOGMMfd/TLWswifGooByP5FkJbJuGrU/0mzV7ZSkMZlGyXV3R9S3j0Yx+NJbOXZNRry9EIeYjb969wcnlFbOu5Vvf/DbPnn9KEzRNW3H+6RdMCuiLiqg8fbeF7oLb927QtUds6xXttqNbr7A6EiJYqwltjdVRqjXRlGVB5zVoTekMtsxZXHaAHZKYNV4rqTUyCqUsSRfE0JCsIbQdmWvJNDQh0TdbqkqY3+lYkVczNmvPi5NzrNlgCsfsaMrBdMyoKtEWdNQU1ZhtU5N8T5ZpVs1q8GhbUuzpfC9KuWBoNh1FljBVRh9rcjQ+JfmOKhFqqdjyQZG5hMtzNsua2LXM92Zf6zmxXK9FXq0Ao4haY6zYWWwmCdZJTnhCB1EbvG+ktSeGQd0ZidZgDOgUyZyFzMl5G6Vv2SDr0EhCG5EGm16Btqy3NdZIFsF2OzS5WMhsLp7oOLTykLB2WFsN664+9iSfmFRz9o+OSO0F9eKMIs/RVhFDR1XmPL+84OOXK0BjnFRokRJWJ4yxMiwJCR9l+FQWYp8jJbzvB62gMONdr7G5XPO9j/jNlrw3LJdbEhptNc4m2rbD6JZda3Dfa7quBxTGSW2b73tRHw1VW/moIq2E9BjPZxhnqaZzytGEzWZNluc0myWnzzza5jz9/Ir5wREoTfQd1WhCTJ62aYkKbt6+C1Ff208m+zO2F1fU2w1xsMj5tkZpS/Se7XaFRjPdPyQBWVGCVpSjimazxRYjjvcPIUVJqncC3GVfCrBOASJRwj59O5w7XogHL005XdsSkqLeNte4QPDEQO8pmRJbY6ibhqLIZKCDJhvS7VMQLKaNxhgDREL0WPWv23T/pO1PlWoeB/miYEh1Dbpfl/4KC4mA19cA8zW7/Rqok59PMvkjEGJEvS4B/xPY7uttkKhL0rYY5YXpFaAqoNsP7MErEK8HCbIxQ+DYMPOIvAKE1wz5ddDYEGijjMgk+g1935JSJMtyclegtcKHMPjupIUwaYNBYa7tALtU9cAXn37C8+dPJBhKI9M1Y+l9j7EW7we5qFLYANhB1q4dPooUWWuQlOKdBH5IEx+mPzvGmJhYNhf8o//uH/HdH32HB2/fFTbfGF55qtVroFtdew6RPw0s/qsAtpTE87vbzCAJ3HUIqkFNMJw+so93w5DX/Pu7pPzdeSIyfnndXRf6zwPl18P0xKrw6nPvXmfnE9+dY8HLhSrd4/Ffe81fdkvI4nRiLAWKQmscUlfRJ8+J6jmLW6w3IhtWmrEylEaTq5xcOTKlKbVFa4tVCqszVBDwqZKcezH0GG3pwpAoniIMXYYxWUJs8UFuNHHwY8awCzmDTFl8GvrAFaQgoWVeecAMfuEoNg4iKcr+y5WTgCkFRstCKQxVEJEwBLJBSJ4UpYdTBN+79HCDwqMGJr+NEpqUgAy5J+goixg1TCSJHoVGxhnSmd0P51pMgaiCnCfKiPpEydRYQuyiAOw0AAQl3rtGebaxo4mRLZE2RdYx0JKICt594yHffPsdDg7mxL5llCeUbvnZx095/PQ53bamzB1Wi7dqvaqZuClXZ2ecPj/BZnDzcM63vvU2j+485PHzC1yWOH/xjImO3Ls55+Hdu/zs/Q+Y5IajO2+QuYpGr/ERZgdTRlXB4fGYSXbEx1885eJqQbvdcNl2rFNNHqGKhlw5Sh3F64kWqTPimbVJiR2AXa6CPFBUkhDHmDSeOKgtgJTQeBlkXjea/3Lb5Ysar3KqgwkKzydfrAlfnJPjuTs+AGV5cXKFdZbQLYlFwrctR4Wl2is563vmU8fFssOEilh0FFqzXK+5Wr+kuTxjMpvz+emC/R/e4PJ8gSscRzcfsOw1p883ZBk03RoVNYfzKYuzDZ2rOf/8iiJE1ueXXDxXaFcx3d+jHDX4zZJVl9CmAK0pjADJ6Rgqp1gsA7ZwFKVDaUPmLMYknEGuWStptGhDiIroxVPfq0hSwqZYnch1T9tIpZ62lhhqFBqrosivCUSluXFjys13HvDZ7z3j8GiOLTIWL5c8+el7XJy+HBZuEtKUZYEqs+g8kWeKcaUoHBD/iPbpj8lspDzWBK/QGwEOcVBnaYYAtwh9D75PEKWus/dxGJp5fNB0XpEbjTGapvUkVTIuchoP9dZztlqSuUg5kvtxbrT4MJXClnsczPZwqsOWOZfnG27dO0B56ZmNKmPZ9IwmFe35CceHc1Z1YH9/jE6JMjN88ckFe4cVpxc1603NnZsTnr64ovGKg4OSug/ceHDE73z8mP0DxWziaL0MFfLcUJT2+pmXuZLkG4qqwFokVE9b3GhGSUOwltYE0AV5saXf/vLXRBtk8LVat1TjikxHGWjoFucK1tslVeHY+CUkJSoL5eUY+STWByuycmtAJYW2YKwiLwr6tqcoClJ7yWxvf/BX5vjYUpqxqH2CWECc1vgYCb5ns91wfrUgKxwYUTSEKPeBZAwBTd+LHDv4iLKaoii4Wlzgyopx7Lha1LLYTUkWoVphtAD2tt1SFPD0+RNWixplEk3vSXisbQb5RxJA4hyZ0UTf0/nIcl3T+0Q5KahMzvHBHkXpOT05w8dAaD3Pn53gmw37+2OagwOsSuByyqLi/OwEazzj8Zj14gn5aMqX5xckX+Oqiq49Z5yV2JHFB+hXl8QYWG4XZHlOZo2oBvKMbnJFP52yXdfE9SkmJLF4MVSvAjY3aOl8YrleYeo1xo5IyVNWBb7fyrPNIwMJY2lbj9JgN2uatmVbL5jPxnQpx2a5VIKmjjQQWAcTTW7n5Bap2kJqs1abNSZFJGGmYV1HcqPwPmeUV3Q+kbTGe0tUijyXYLgQEovFhtnMMxrldAr6zZJ224OKbOuINY5y6qjXiemhHsIXpAr062xWKVFJaDOsLRPb9VYImC4MncmQmwzrMpq+pe9a2qQpshxrDDr566TyOLTaaNK11TXGRBdk0KC0Qg9qMaWd5J1E2Y/JGHIzKOpSImjEvpMi3ovyzmh9zW6mBNEHppM5+0d7xM0L6sU5We6IGowHF3u+vLjiZ08u6YORQUtSBB8kF8Y5MufIy5y29Zghy8c6ixqqxWIPSouNz/hhHecVMYjaQCVD30WRv9tcAGxbE6NC5RJsGbqeYjRC6YDEv0iTTtu0jKcjurbDGk3oOvKyQitHlpfk1Yizn/4EYxVWW6JvyKym3izo+oAxlnq1whhFvVpzdfJy8L935PkImsj06JA8yyAWaGuZ7s8Zzcc0XQc+8vTkBTfv3BP8ocH3gd57slxycrTKQSnKakxexQFoA0lsNcoOaeVKGhmapibGSF5mkvkTAqEP+L6l6+WZ60Mvak3rcJnYjYwe8qqQHnWjZQ1UuIKmbrG5JSFDNWUsvu+F+DJuwHkyaFH2F8cTfyqP9w5Uv47qX/fjStn6ALWUHpLL48C2yANQa5mMxkEGvbtAIF6/x/DK7EDq7n1ese6vqq30wHZ6uAbfUknSDSDPf0Vqbq0AZ2dFKnQN2nekttbC+rxGs19LrgdWIGU51liWq0vqekNmLVVWyEI/KayTKb22OcbKa1gjXXb9YN5v2ponX35BVRXUdUHbDz4VEMAUI37wJBdFTh0807LC5o513bCtG7oozy6lvwpMd4nyr0Cr7BNF5MXlE37/t9/j/pt3MZnBWjtMbXY3q/ja8dTXAPfnQep1Ldcfe54IY727oe7qYnaDEB8E+In/egf8d+/HNegeXu3n5Oxq+Lvd54DXBz+v/bNhgOIJPtB3HW3b0PseZ+1w4WV/zKf/xTf5NKIBMEpzA6kEmSlNoSw2KYwyGKWwCQlBE+hDRNH5xFZtAC01YWiCCtfJlrnSZEpSqJWSqiejFOhICgMrpTwRRZ+0BH2wA88a5cWvopUhqEShdg8PkYv3qccPXmyltPQfxoDRDP5ySTeqEa9UH9O1VHz3uy6BZ7A1SPEZKokIPRKxymC1IaYgckKtUeWE2fSA3JbUyxPq1RkmBRQJB+ikJTxODVLpFIbQwiSvQRok8AYr7m4ZTqHwKuKHG3NLP3RwJ+oY6Am0KdEQ2EbxOfskk/B3Hz3gnbcf8OiNO6jQUU33uXj2gt/9l+/z/MVLVIK9/TE3JxVXXkL17tw7YH/iGNuKtulp+y1+s+Hy+RPufvsNbt6+y723Kr785ICweELvF0xuVXznO+9i2DDbmzLN50S/5t5b7xJQHNy4j4qXfPed2xzPK6q9Q37/936fetvw4bOXXHYdbRK2s5DZigx7lMFipBInabknDtenCYB6NVBRyZCI13Vk4pkXXavi66XVfhkrJtMRJjOsFw2P3p6wvuh5+tklVr0P85tM9woJrDq6TWr+gFsV+H7L5irwkw86Hr4959bNErKembV8cnZBlo34vd/9MWXmab54TtQKneB4fkDsYFQGkt+g3YjjI8XLiy2ViRRBMa0Cvi4pzBkmE/BStuD9itXzBS97i81LqumYatxhUFy2LTFocpcwFrzKCEHT12Btog1QFY6kLV3XYjuFM81gA1A4l5PsrktD03cdjfcsvWc2r6jKnD4onn72CfgNJJF7G6M5undM7464ePaY6mCEqgKr5RUXL35GnjfcPrKyYB+AmFEGa3YD10SegXNiFyoqQx/scK+Wmrlt4+m7hFEZYOVZ0isOD+ZEn4ihI6YWrXOm+/tsN1uy3NC1HdPjY/Yqx7Nnz5jOb1LNSi5fntFcnnN5bphWkUmZ8Ci6XNN2wtr2yjKZj9B1z+JyxeH+iM8/esKDt27ilOPJs3Pu3b/Der3hzjv3eHFaUzrwdUdSPVfPlyyfb5hNDLdu7rNsJBDPGU2IkavlhjJ3LBYrrImMRwajLT6KZN5ZQz488yOWUWVpN4aQArlRxGTQGDZtwFaG2oPJHEXZ0XW5mOF/6S0SgwDnvq3JC0tuNVH3NN2SMre4Kmc+mnNx8pKrbTMMiBU6A2cMziXWbcIUltxAUpHMZaSYMDpR5BrCinGZszUZ2mYYV6JMEoa93TCa3MA4y8h3XNYXIuPMMvzQuetjQGlIWtKVY0KSgmOkDZEybNCmIi8NoW8oRlOSHtFs1/S+IUapizMWUIG+7+i7jrLKWG82GAzWGvLM0ncBlMZYGepbm8hcRtuA0gFKi9UOhWJclUwnFVkR8f2Wtu/Y2xsxrjLaMOZiseLl+x+Sl5HDWzfYrnOaZo0isTg/Jc8zxrM9ptNj4ugAtKHvei7qU9qrMzJT0WtN27Vsrs6ZzeYyrNHgTU+hA1YnnJ2wco7m8gWyFBfrDn1L2waaRqxtPkWmkymVS1jtSNHTdp4u1ZTVmMJmBJUw2mNsRtAa7XIqPafpPVVl0KYkpRalegia3Ej/c55pmqYjz0UVmYwZ2kcSXas5vVxhtQPt6bqa6f4e1mrqWlQxEjSrKUdj+q5nPpnT9C1Nk+i6NU1d46Mm+YTWiVZr2A6hbXVNDEoY1vQ1bXp9L8G5qhNFoxLgbKzGh0Doepw1NCmiupYQE3lekJLGOEsKAZs5Ugz0TTuAak2KAWXEk+tDJEPUH53v8aHHkkhorDUkbaXqLfphHWDRJJzLMFaOsN9u0F6GSsaK5FsnxXQ+Z29/hN+e0C7OaetOLBS+RfuOq9WGnz6+lPSVQapvzaCudZaoDDYvSUqRZVrSupNUJMYQSVahcwtRY1KQWtkUqRtPkeVkw+0oxoDLM5p6K4OMqAWQDipWZRNd3YI2GJPog8cpS57nNK00BWw2W7TSjKYF5XiMCp4vPvyAajrGd57l5QXOJdyoQvUFme2lp3txBhiMG3JJoqgOyknB0d0b4oNBU1SjIU9B7IExiCr4xu07XF6eo2JkvVxw59EjUoTzZy8oqpJyNGKzXlHkBSlB5z1VVV2TZjElqUALXtaYMeFyJyogY4m+H8LUDNYmQuiHuk3Nwa3b+OCpNyshLVMQub3WzA4O0NaQuRwNYvMyZhi6RHwMlOUIlWR9rZSiKCrglWr3/9f2p5OaJ2GblE6vAe7X5NPDAl7pwROuRM4oDGYYfOLiPSC+khnvfMVfpelflzKn679j+HnFILMdZCS7z7hjuuPAAMe485drdr3assJUX2F6B8GTMLRao4W6vf4Z8VzItF9lTjr2tGG9WYvUwjmR6aoMk40oykhZKQol1V8h7DqV5Ztcnp+wurxAKcgzS+Ysi67H9x6jE8n3GBKz8Yh8VFLXDetNQxmTSF26XmoA4NpzoPWQ3PdzoWHX6etEuq7l088/I0ZeY7zNa8fwdVl/+IraYOfrlwX68N+fk3Zfh5glSYfsvafrOtqmoetbfAygpRe9zEv0MF2St3lVIfYK8L96b/m5wUMfkZHlIHVWu/Td4bySChxP1/W0TcNyteTl+SlXmytuHh5z5+YdRr/gRfInbQbIFPRJUWIotaLAMR8Y70w7nLJk2ggjoIycX0p8tihhlKKKUuOUhN0Ng7ckRpFje7z8N7UEJYAZuK7F0KjBvyznsEDxVxVu4kJVuCR/Nkr6OiOeSMRhMDrhkIWOjTLI6lJHmzw+JvywyBDZt4B3P4SbJcUgHzcEY9F0VK4gJkMgUuQV23bLrQdv8+/8e/8Bb33vm0yOj5hNx2xOL/hP/+P/Lf/qN/4hMshXQ5K6sEQJTUwC6M0w5hjGCzC4/xMyfGPw3ESV6FNkGwNNCnQp0iD93P0OcJOQ8AzLo0cP+M4PvsXNvSP6ruXug7eJQbEYr7l96ya976jXDfNxSecjo2KOrSyxC2BzVGG42rTsz2ewVXz5YsmNt2tu3rhPnk2xqgDu8Ozz97l995ucnZ6iouNicU5jLyhsxvzoNtsukU9anj7+DB02vP32bXR2zPrqEhV7WueIeWS1qTm/2PLk9JQUI3mWk7otmVKUxlG5iqNqzLpp2DRrNIksyrmqlMYi3j1NFE9pkvR5RSKLX++aqD28tV9ijGKlViyWnm+/c5tmveTyxTn7RpHtPeTssuHoqKBLGYVq0cqQuo6sV3z6B5d072qoWgoAa+hD4Ob+lJfnK46P91hsE81mzabtiDHj8vHHqD6QlZbsKhNPe6awJqN9sSVendJ0isUisL9XYk2H0Z7cwaT3NO2K1csFJ18abJFTzSpmI8dsMqIaTXl+uqZvPevNmsyKBFrjWW8ZLB/gvSTleh+IXYeiIQVhLyUkR5jk06yinM9J/ZZx6RlNh0FwEmbLNJesPvodulHJu3/+bS5fnrH58AOq0BFtImiN7wJtH2naRO8lKTwGsSaN8o5vPXJoa1BWshZC0FytMrzdQ7FgNDNgK958cI+nX3zI5OA2rpyyvrzAr05pdEZeVGRZwd2HFX29JqnEpu0JWcWb33iHT5+cwFUgG48Zl4kvniwx1jMZKfpgqbtA7jRNA8pYFpdnZJcXnJy23PjVN9k/GGGNpusSpU2cnpwyGVWsm5ZRWfLk8gX37x9TFmNepsQ3jytcXnG2uOKN+7d5/PlzLlc1RZ4zmeSDlzMnd5pxpWn74T6h9GD3kid823q6tKVtPcV0hvZbYu/Y35+yDBWKDXVM7KuIqhyLTmHsLw80UlLoTGxSISbapidEjXWK0UgzGZUoBW2zZlQVoOHybEOyidnI0vZi2CpHlqqwUnHlOwkPVUYqknzPbLaPTg6jpEUi+g0pnw4VPJLw3rdbttsrFhen1O1a7qAGlDXoOEh9rSHESF/3GJeJYtD3bDaJEK/EQmEdVjlyV9Jkie0GNtuNsPFtwilL7Vv6EFBRnm3FKJcwXgMuG5o8EmidwGSSRWIt1kHlMnyQACMVG7qoqPKSw8M5eVXQrbc0dU1Snsp2dFYT0Dz74gXWiOLYGEcIge22ZrW4oj7YMprO8UoGj33fslms2K5OKPPEeH/GeD4nktE2W/ruCmWlJcCWFcZERqMGZ/ZZXZxDH8mdo0se5SNZkYCCSSH1VH0MaBWww35ttx2Z2tB2tYR1YYgksiJHW4dvezZbj603zPbGtCGDkGjbhiKL+OTpfYcPkDaeauawrkRFSW+eTSe0vsR3DfVqw3Q6wuBZtR6VAqHdMpqOQCfauqUwmnq7ZLXtaDedKCJyx3IpYXBloclHgWYLjp7kHMZlJAzVeP9rPSdIkRAl2Ms6J6ornai7ntBGysLR9T0EcJlkHlSjHO8ls8Mb8Ycbq3FFTkBJXlFU+JCgk+RuTIZ2mqIsCV0n+UdKqqfGo4kkersM3wmYtEbTtjWpTRBkzRy6VlZUWtGHwN78kNnBjLQ9g+2Cto9DgBto77lcN3z47IoehdXD9aUU1lqKAdSjFcYa8jyTNVTXY4wlZBodpdyUEPGxJQ5EgiGJT7sP9F0kcwaTWbbrmtw5ynmJKwu6dkPfejabBqUVuTG0XS8+ZK51wUTvaUMk9AltPdurS64uFmSjCmMylpfnKKso8gLfR87PLog9WJewxkEM0nxhho5zZyAGmtUVH7/3exibs206bt1/yMHxLUaTCaBFQh8j2/WW/YMj+r6n3m6kTjIkpnszWf/HhLXZ9Vo+y3LpkG/FFoBR6KTAx8GzLUqSNATtpR0GVYJlGBS5x8d3eXD3LS4uTvlk9WP6Id3dWkdKUuucEhK6mTnm1Yj1es2O9rPWSCPRzp+vh2rOr2DV//HtTxGuFq9xkHi/Xq+PglfMpEgfBcAJ85lCFJYs7XxK5lqyrHa+3TT4yZTmqwznqzcZopi4JkSVRO1HKfu9Btxf8f6+0ni/kiLv5CKvsbuKV4BTPFeDf/u66uyVD1xpRZZllMUI53Iu10u22y3OFlincLrHpQBqkHMqkTaHmAgK+rblo5/8hBh6dAoUzjGuSraTEVeLMISjicQMq+lWkibph9owlAD5kALOZjhr2Tb1a9//1f571a09SMODpPu88sarr/z8K7/8n3wCpSQDitf93rv9uBt4pBDouo66qdnUW7ZtTes9ZZYzKkt0Zq6T7L+SYp5enUcppaGiVb2SqXthzXeS9l0qekzicfe9p+972q5lvV2zXq9o6g3r1Yqr1QqfIrPRlOhfdcz/sptWimyoqKqMxipNiTxQR8qSKWFdskGmIimVGqcECqOCMP4o0Gbw4mqUioThDinS8JIuJYJSQEuXcknctFIBEVKPH+qxkpKAQvFpyjjJE0hJwGw/pC/0hGGQBq2WpHEfPT2SYBpUIkZxXHcqCvsteeA0iMWh0CNsVlCUFbeOH5LnCa1Lls0WpzxFWbB34wiT59y9/13+jb/2b9IFQ2tH3Lhxkxt7juxY89Zfeot/9I9aDJK0rVQkpSF4DsnhlsA1Bgl7HHxbcnHFnSw+KZGZp0gzqAr6AaJ3achDSNfjOzKr+NF33uW7P/ghNnlu3d6j7RKXm0v2926wd/MB2BF7E8dHnz8j6IhF4Wxiu43YrOD0csspK2pvGGU5XchYbyXFuswUXb+hzDJcPuGy+oKYEtW44uTlAtZnbFLH0c2bVFlOnhc0zTnPTq94/7PPuX83EM2Srt8wGmXcmE9wJtJXFevZjH++WRJjJCsr1itPXo2IZcXtd9/hzo1H/LN//ps8e3JJij0a5LMrRSGldjglQXUFGgPkSlrhv872rTsZZakpMrhaFXRNxyfPLtkfRT5YWr7lz3Gx53i+T4wtsYtkmQxPchUY7xW0i0Tf9CiTYWYzNosNdjLlH/9WzeLL59j8DIXm0YOKcAyL5Zpvvjvj+cmGL58sSP0YryJXOufoqKBtIXaR9TZyusy5/ca30b7FhCX4NZvlBc54yhy6rqdue06frfhoa3lwa48f/mCED5HPny0IvScECbvUKVHqQOUCRabIbKLMFG3SjHK5Fk2mGJfiEUzR0HtEF1Kfk08yRqOccakIXp6RoOhCpNvW7N8+ZvnlGT6N6HpLjDkoCQY0znH79hHbzZrQd9x7+BaXywV+ec6zLz6U1gFjkMe0IfqAy0sqe8itW8f4vqduO56eXnH3ne/w+MsvGMWAyTPm0zucXGwJQxvAybPPWHz6hP3btzGjjJZIaiKpXrGNBalzlNMKZxNFBlUuw7giF9l9m0XW2nD/1k0+6xp++M4DlldbJrMppbGcLs7pY8IQqaocHXtiaXh454jNak1W7AurP6k4Pd8yqiY09ZaD/YKoLCazjDPL8ydn7N2sUAqq0tD3cl/d2cp80DL8VIoYIkZHiqJAbzpCO8LmjnfulqyXEL3h+KhidbXl8nLFKP9TiQO/so3mBUqFAWhFqaqKgdglVn1D7GXBPxplaCv+yyzXUuGYQDtD6AO5lWT2lLhuBbGZxrmcvBzR9AVFblE60bUNrlD02yUqJmYHe7RdR71esFqcSQijy7EhDmBbE/uWPkp6eoySBp1ZzWbdgxlUHMFKzZnr8UbjjKPtIEaFMRnQEdLunowoH1HYPJF0QquhUk6LTFMrTeiGyp/Bc2mcRRtL7gyZVVgHJkW27VayXOo1bVuTlxkxWfJMfLNN12GqGfXyguVFC0qRlZaqdHit2DQNl1efIinqUq3qsgztAst1Td2+JB9lzGd7xGCkksgYtl0g92vyKqBTpKwSSk9Zn18QQ0vE4UOHccUQKtWSu4kEWeqegHRlbztP3UvA6nSak3BkWY+tI2g3hLDJwGi73aCynNJW6ElFjC2hGYJVneHsNFA0S+bTSJbnzCb7YCHTcH66JPiGLDkWT7ZMJlPW6xUqBc7PLjHKoLUjLzIwltXVms1KGleyUogApTXRFtR1YnZ0QBdbXHTUq5qIBLN9nc0DuTM4bYgEUaIoyFxG0Ej9lLZY5zBFTjlI0vNcwLfDoSsn62Etq1GVNC6XtHi0ZMLsmF9rRfVDF9BOsg52xBwSBUtQknxtreQeJZVQ2krHs+9Q2jAu5xwe7mP7K4wNLFVBGzrhAHzLYrXhZ08XNH3Cao3Smaj4jJGqNGvInMM6cy2xJip0Jsx8pRjY10iKgRA0NskayGlDEz0Sn2QxWuygRVmQW3cNelXSZNaRKkXf95KCPsiljdaMKkvfbJmNx8LmTsesa7HjOQcqBWLfUpY5vff4pgVjcUYS4GOI+EE5GhP4rkcT6b0M8LUZKpYHH3QKPdv1krapaZuWvJCEemMVm80a5yx7RzfAQzWuqBvpi5fsrcTV1ZLxaCyvhQznNHKPQSVc5ujaDpDgSDNAU6U1pICxcgyzouLOm+/w7/6d/xnz6R7/7//y/8rL86e4rKTzDevFuYSvpYSK4H1Plucoq6km44EkNhhTSEDeaxh418z1izYl/al6vNMg8d2Z0ne4eOfJ3YE7rb8KaEQaICmoKcmJs0szf8VyvmKgd97k3fsCrxbNuwU0DCz6wLKrV8MAM9Su7DzAO28y6RW4TEoRYrpm23fyd/iqqDoNlWEMQwT5bcJoKY6fz/aIMbCpt1hTkGcVLi/Icye9hM7irJZQjZQ4ff6Czz78iJPTFxincdbQu4zEhvG4ZNs0+G3EGEWTOuq2pek7mqbDWjlcbd+LXBvwIRBJkjL5c8OEr+7DYb+pyOLinO2mxZXZNejVQ33Nbp/F+FWfvbzOq9+/3mW+S27Xw99739O0DevNisV6Rd02ZC5nXI7Ym0woi5Isy66PUxgS5LUc1K+Ab40i+Vf2AR86QvBIfU2G0Q7vPU3bsNlsuLhacHJxzuXygqurS7q6pnJW3nvvgPneAQf7x+T5Dm788ptTilxpjEockFMpw5EpKHVGOYCb3GRyTLTGUsIgJQcNOsOys2YkknIiG0uD11OeCYSUSMkSVCBESR0NycifkyKlHJmpB/HcKz1IwQbv9cC0yXDJD2eC1HuB9EEH0iDTjvQkOhJJDwOt4d8LiI94ZZjMb/Crf/3vcuPOEZvlgu/9G38ZX5+wOL/g+elTPvr8Y954+C2ysWJ/fJub9x/yyWfPKO/cIxrNnQPLVHUsFgve//Ef8iJ1oqaBIWlyuP525wWiStllz13/fyWMoxr+f9wNg4BrLUwaTt7hvyqBsYZf+eF3+dv/079D2yz56P0/4o9+/wneQzQN3/jG9zk8fosb3/gWn6nADw7ucH66wDcLmrpjsbhi78aE5CvyAkrf0eYVq3VL63tePvsUqwzZ3hEmGzPaO8DaKS8f/5Q+bNisWk5enjEtE89eXvDg3k2izri6PCcpxR99fslVk3BWM5tOuFgbDkYGlQLF6JAirwhdIIbEVQiclxN0prhxfIsHd+5inOP4xh2W6xU+BJr1ki55OqXZpEAMAcn77MhQZFqGRu4XDAf5k7ZMBb54dsXRpODgaJ/VxQXj8ZRp0fHmQ+i6GR98cs6d2ZL5asX+zZ1PSjrbU7clhhwbFPemM9YYqnwPHSP3jioWX4xZnF7RNYE7dxy/+Y8XxDDD5nc4mFzyxq2WN24d8MXlC8JC0y0CM9vRlRqXaapxRlVY3rj/XS4WF2TW8PSzHzOtMs5OH5NWS7Tq2PaKk01gdXHGH/5YcXa2IvU1Tie2vQRiTYvIpBSQrYwopbJcoYLCGjndcgfWKca5JrOJwlm23tBGg3UZnc9IVPShxuUzbt64Reo3zO8esXfv2xTHP6TdPqYY3aFfrSF10hHeNmiTsXd4k957FqsFxjjykWE6L+l8L5UpSXz/MSbazhPUhtMPP+fibMNbf+4HNM0VfTtCNRs2IWFsRlHMsDpSN1vGx3Myd0gVW0aH+zRRMZkd8uzp5wQMqWvYPxhTb2qMTigNbgBLLkDTS87C+mIFt2+yN58Ss4w2bZnkhrZvuHtrj4uLK45uHXN1csZkf0Lda3zXcP70ksnRAbdu77G8vGA+n2K1BAjN9idsNhtWTc+m93TrltVmTVkMfuFoZTFpDM4YIqJw6XxPlgl754yl6zrK6YyGjJFSXKiS+XyMSh2ZUdy9ecyXL1a/9DWxfzgjJmGN+3qDyjV9a2l1QsXEuomUhSK2HWNboKzBFpFuOwxgg0bphFHCxsizVkgFA1hXiEzbSzpwUtD5htRZskzRty3n5y/IhsRvZTKS0Zg8o7SO6FucM7iiousbfPA0jQDXbRNRNqPKZY1lrZaBhndUowl5NaGsZpydf0ZcBdpaJKBd22GtAwLGaJKx8gyJCqcVCUmqzqymjUb+7MRKpG3CJJHQlqXYYdabGmWljUUng3Il2hmslkyc+d6Uk9NTRkVku0yERvqJk4ssztaUlSGGyLZuCIifNnOWqiqZzqfYwyPqpkXFjvV6LUDFODaLNcVkwvJyiTpZ4EYSOmWVohxn1KsGQ2TbBVSU4FJrMkJbk4xi3WzQJlHXQ0q9CtRdoutajO1xmaLrdtk8idWmo6osioDNC+o+YcqM4D1d29M2Uu+nTKTIM2IytE3H2mwpDWzrFUop+gb6rafICjbrlq6WRAdSz2wywRUFTV8TPVTjjKgbiJqqTPRRoVJCm56gA9urM6yN9CpHG3C5ZtNcfq3nhE4C4IKSnCWNBLn6FMicGcD0QBcH8VRqk2GQUEKTZ2zXSzKtcHkupN5g59NJEYJCaQhB2IUUI0oHjJOWgBQk6M7ZHJQdFJpyjnd1K4M5Z4gpSaWecVTliMPDA+L2FFSkVrBtOkLf45JnuYp88mLB1kvosyhmwTlDXuZkrkBrQ5458W4HIdd8jGRGU4eWFNJ1MnlSYj8kScBb23t8iNidDVBbkdF3LfW6piykh9zlheQdMLxuHyQQs99SZgWLRYsziaoEo6BZb+i6gMtKkjZYW7DZrEgp0A9zeBeHVgtlsU5qh0mB9WYjCoMY0EZyS7K8RGnDdrOh7QMhQVGWkkaeJP8jqIRvu6HpQ+rR+k6aE4qiomtbrHNkxZhJgrappfHKi2JWD0pqrRVtvSaRKKeTodI5DueD2AqUGp4BxZiD24/4w/d+ytNPfsbH7/0uwdf45SUQ8W0rbULWDWHTBq0MRBiPR6QhFydahTL6ek2peA2n/nHe2z9m+1MAb2G8XoHZ15bECgRY7yq3XrGuOyib0K9A7yC5kh/esa/q+ud/Hnzvkq0liTcNwOQVItz1NKddwMfuPQeQLjL5IVhNyTRm934CIKXaIexY/eHBFlOUf5M0gV0IxMAek8hzmY4akzHpGjlQxpFlBVleUOQZeeaGcAfN2fMX/PPf+A1ePn9ONSk4PNpDoWjqLavFlTD43kOCetuybVuU1vQ+yARSiZQ6xEAIIrP1wWOVvSZvX5+8vGK7XykLYgx88eRzXj47Y7I/FoZLAUH+nR18yCCBFWGQm9vX2GkZ0r3SpAu4Eb4mxEjb92zblrr3YCz7swP2plPGVSUVJ68F8l33ew+s9fVx37HeQQB351u6tsH7jpSgrEYyLSfSdi3nV+c8e/mCk/NLNvUGQiRzJZNyzKTMGFcj9vYOmc/3qcoxxtmvye3BGE2FogYmRoLT9nTFyGTkSqojcq2I0YqobADaCalwMckBHQEFyZJogSBRwzIuxylhylVSBOWIKqDjMBXG06dEJMMkT6/MkCwu1URRdOjCPKSBy0wZ0m0ZCUkhrc6BEDuitoSk6IZaryhZoIBUBHrk3Bsf3uS7//bf4Ft/7d+gGJfQBvYOxvR1Q+Faiuw2TbPl8O5NPv38DzicZTx7vMAefJPV4iV3H5bErmFRX/G7v/Wb/P4//qccoPCDFF/JXkC8868rUuRhpHaDg+uTHlri0EstABwl569CboZKgUXjFfQKHj16yK//lb/Gqq55/w/f44vPP2Oage/h7nHJyedfMBnto5XmwTd+REiKw7s1z55+xMnzZ5SN4uGb3+P2zYecnT/m8Wc/IbPw/OKUTBne//gJ0W856u4xPv4m/XZN6hvaZskHT56T24peWboAT05eYE3g4MYjPJo+wna95sDPoE+s6wV0gbyIaDKm5oyyusFbtw65e+OIlM85Xzb83ic/oVcdy5VM45URX1y3XkkQo80gDZK5piEiC50OhU2JFWJj+Tpb2wbWNXzzYUabAnmp6Xzg4f05+oUh0yM+N4qrECk6TbPpiSNHCgrlDW0f+OLLNQdljrqpuf/wbT782UeM4iXzsUL/+o/4p7/5CXVzxm/+VofpFb/yo0P+3LcKlqsJOYdgMrLQ0uuWotjHNFdklSyCLIrMwcvH7+PKMV3MefjNX2G7WTEzY1R5ju8aCv+cG+OWUgfS6oQsJYpCZMtNglwrpqUiLxRKW7qoCD30QVMWEgjUdp7jo1t0IeDjmnp1QXVDs200XdDkWpNVc45u3WNUOZETT28wv3lEfucR22fvUZ//BJPf4Pav/F3Of/pb1Jefc/bpB1TTCatmg7txn9XVJTEEvI2M9+/RPf4Cn/RwrM21QilzOdX4kLVf8u7Du6w2W27de8Dy8pxl3VJgmU736dotk+kMhWG9WlGVlnp2zKpVqPaKNK6YT3J83bB/4wb9tqWaVcNzJuKMGRLapRPWGg3D8zXPS14+XXDnjVssTi/Zm2bgW2y3Yvuyp7tYctp23HvzIY8XkYffvotrl7x8/wl10+ODIZ9aJjfmaCa4ImM+Krm6vOLht+6wWQcW2wVghxQKTeY0ucskb8IaYurQKbHZBLJKgwdbVKhe8dlZZK0sk5FF2hwyls0lyvzyvcVVVQKefhtpV5qewLTKyWHIm3HivU0BHxPjUUnTDH26Gmwu/tU8y1muaialrAmicvhUkNOR6g3Rjtg2kcx4nJWxWr3aYnJNDtQh0PW9ME7FGNO3ZHlOCo6kogQL2QSM6MMF/TB8z6wQCtaJrUkljbJGbE19TYqBwo0JZUO7lRyVlBQuRYrMoouMvutweUkf5J7e1g0xCNC2WQla1lZ9bCm0JcSAzRTRd8SswGQZuVPXQZ7OjgihwVlFiArvPZMq58mTl/g+oqykqzdrYSPXnaepN9hC0qXxItm9WjW0vqeslgSfaLtAkWf41JNnibwaSXDqdI/LS8fFF2fcvKmx4xLjNFmp2LQNfQxDCF2grls2ZqgsGrYUoO/idUFO1InYi2orpl4q+pIfPkNL00aM6WSgt5IXaHyg78RT2m8j/abF5TXWajZ1h9GS3rxa1aQ+0lMTQk2RG/peLIjRJza1yI6NNqSYWG08oZfarb6V9Zc2CpNJj7c3HYVy1N6QGj9Y/b4eaVEWJSnICR6G1pq2kV7vZJChknYkIjH0+Ah56ZCbbCQkYVxVbmm7VnKZYhJ2M8+IbYAYyHM7kEMKY/OBbFM4IpnJMFkBCdq2o2tbiNIQkEyG0opRbmm7jtzmHB4eorolYX1BByhbEH2PwdP7xM9enrNsFEWWSUe3tTjnyJ3D5o4sc1RVQZ7nLK6WxF66tukTmZFGAfEhisRdoSVQTCkJs4yacQEqdSQMGKn7y5STGlctgW3aWFKU9VCZW6yGrY8Ym5GCH0L+etpVkOq1osCnBu97fPJ0TY01hqQM1kq7VNoB+rLCugzfNARvaboVzlmp0ooS9tt2DTYrmB8c0TQeg2W72jCeWpwRfLG8uGQ8m6MHRUHwPRho2laeV8YM8DASgxdM03uUkYFjjImmliyM7WqFj56scJJtlATMh6HyTulENd/DuILL54+5PL3gxRcfo02iLCa0oaNpW2KQ6ziFiDHiFRenkmQdCdeYrj+XLNElqFvElwr1CwpB/hTAG3bsNLxip3fhZLsez9el3jAkYysl3ttBNqx5BXzTNY06+IdfY1F3k4TX+75DiJIcrrSkICt1DTb/9a5vXgNxXGv0GWTku/Ty4CUhmSQgMCZeLfh3UughKfpaBh0jxliqaox1OSEIeNdDH6Ee/OBuYKkvz8/4nX/2P3B2+pST0xdM2ylV6dCxp9tu8F2Lj1BmGdvO03Qd14nvvpdzehdch0jG1eDNfl1eDmCtpe//9Z5FuTdFtv2G58+e8+a370MyQzL5MOS4HkqIb2PHle+Y9N0vZ8SPvPPDX0v2nSwirLEiD0mILD/PcZn7Chv/eqgevJKphyiWAp0SXd+y2a7ZNmuIEsBSFKUw1kZuiut2y1qMhNzYP6LM71HlBS7PJX1QSZ9fNsh5rctEtpx++cUUQKUUpTZ4InPjyJNianNJJ0+SkKiSwhknU0oSSQnU1WREBaQchUfipYvrQDitLQaNT4qkv2oFSMqgBpCZK6kmi0phVEKcQMNQS1kCHWqQv1jRQxFDIkVPjNKdbZMlDUWxUSny1KG1pktJpsEukY+mEqKG4f7f/JuU/+Gv8Xyv5OZ7V9w83semNcrB3u0jPv3yA2Z7Ix4/eY8vvnjJH/zu7/Frf/Gv82i/w8TIASvaReTjDz7gP/vf/yeEyzVjNUTECGGPJkrjQFLXN7uohhGeVrJgkSmZpNSroZ4OUQhIlIOMDXay/agStVLcu3+XH37/+/zev/znqF7x9OUpzbbDzTJSUGx8hV7XLK4umUwPKef7dH3kmw+/wWg0597DNZfLF9x/8BBNwWis6doNfrXAt4qoek4vG4w6o/GBw6AoRxuW9RUndeTkbINmxTfeeki3bSnLisfnV9x4wxC13OC1yXh6coVzllEufu2yN8Ruy2zdgxlxuliyf1QyK/d5e3rE0d73Obta89Mvn3HanLBa1bR9S/Ad5XhOVlSEvqferGUR4luUUpRY7piKbOiS/lrXRGFQG8OzkyVFOeFqJVLsDz98SrNpeLYwfPudPS4vPF0+wpZrgk/EaKSuKsE8eTbPT1lXa9qrJ+R1w3rTU7sp+XHND98puZoecPPggP1Dw/6NOV98/h7mck01qui7tzi69QOak59JKJYS0J1ZAaG5dYxmB9jQUquc1XaDjom9+R4haTLnGM+OeNguePHlM5QKXG039GimRcGExHRUcLg/pveRposc74/Is4KitDQtHB4f4LstkUQeNSOjOek3XCwD2zYjKgtGk7pEcoarl19STib0TlPc/Atsn33I6OhX0WpDs9oQe8303jdQ3QvsjTlFOaEyd7DW0Z2fYGJgVE3ZLE/QAzNpnRXQq8Bmhq72kmJuC2K1R789x7cto6rkcDqinB0Tmy3lbI/We/zqjK0ecXT8BimeU29qivke682W2eFtTs/WdB6Wzx5jxjmVg9lIwoKsAZLCWaCNVNMxhXE8+/RL4mTG00+fUeiWi+cLLs6lH1Wplsx0jKualy9fMBo70uU5T7684NkSTF5x43jK4mRBtzzj6nRNduM2ldZ4b+gCPH5ySdNFFIq2h7zUlLkhy4wErLmCulmRmzEub3BZTtCSOlxUI+JmCyhUDHRtJCpL0zj29355oNGsl6Js63pUEpY3xci4HBFCoLAOZYRdrrKMlCLeGQ4OHCqKtQ0lQ/DZKGfZKcrJbdAZSu9Rd6cYu8RlBT5GfNgOWXCJNkX05ooUOrZtS+87yr7CjUbkVUVIXtYVSSry+qQgdmRW6lGNcoRosVYyNvq2x2orXm56YheGELoRvl8ym1Scni3pNRIGkjxOS5WkGQa+xmhMkUv9oXnVdNN1LRhFmxJaRZyxaJ3Ttx3WedqgQXnyQuOj5NtoY7HWEvoObTPx0jdgS4WvB4WUSmC0dG20ERs0RW4JSmJO22ZoO8GTZSPqrUV1Ha1aE0Jg//gIpWBvb0o1rTj5/BnucsN0L8drT9KRYmIhyLBkMCmiBobfB0ghYJwwZSrtqhzl+ysNySfptg8RlztCGsBykwhJurRjQipBg8JkGp0ZtHWkCOvVhjzL8EnWOhGFSo6s0DRdh8bQR8hKSUKPMSGSmIirNNbLoCIqIdSiSuClDipZRe8VNg4Klg5U03yt50QXBoAzZLhoIs5ZDvbnotbRYhENwVNvI2UuAJkhl0jsrIYYEpnNcdbhY0/bbEitkFdt19N0HZmVijFtNKGXRqG8yHHliL5vsdowGo9RRuMHMNy2LVZB6AN7832msxmx36D6C5Z1w3g6IcWezCWajefxxZqmU8N9Rtb9ZVnhY0BbLba/pOh7Ca8MvdjRkoaiKoh9ku9NRGlFkeWSV6XEe5wl8ASxXUZDH2Q1prSRqjAlXdY+itKjyA1lWeI01K2mX9cENJihOthrLND3gaavSdoSvCdzhtH0gM1yLfYorSF0JKNpt2uInhbQyhJ8wBkwKmIzQ0oWlMEaR16WZGVJG7dM92dsNjVZVRIHi0LT9UBEG8O2Xg9AOTKejEkJuqZF20SW5dw4uo1Rms16xbrZwpDPoJQEIs4PDkUi7kXRq42+fj2tFUkFNotLRnNNmWcshxyL6d4eeTFmtV6D27BpJJNFKYMP/VA9PdilEZtSSmCVJga5znZV0TtkplT640/4n9t+4VXWLvBq97KvlzFds5fDr1dE1KtwtAgSxDXcRF5JzV+9xg6Dx8EbtGPXX3m9BxA+sNqvh6PtXuOrfmUkZVOpayAv2xC4JqZnmaogAF0xNCYMA4ZX8uqfl12/YtgLYwYmHFBy0RitBo8trNdX/Pj3f5fzkyds6xUxeqw1NF0Lscf3Hb7vaUPEOse2rfEp4n2g73u8F9CbgkxfYggyuRsS9cS3/eo4heE78dp+2VkFSJoQe5598SXd9kfYkR2Ajgwbdt2J13VdvA7G+erxUOoa1OlXO4q8yCVxMiW0kgHEV2vLxKeoVBwk7uo6ydzoXSBfGmTrnpgizmYUWc5oNCXLxMfTe48ymiIruXGQcTw/QqXhwa7sdS1AGg6qGaaQZhcm9/XIPWbKDs3TmqnOScFTGSchZcajUgY6YnRHihaU1GOh5Fyy2hAxmKSuO6klcCYXZkbnKFuhywlqNEaPZ8TJDDuZ4qoKRiNUWeBKh3cFJrNEq4jGyo3YCiDXMZJiL4A7RELd0i3OuPit/47LP/oNbAzXAy8JLtR0yYMtObx/j7s/eof9u3eIOpDCmNGvfo/nh5GX4w0cbjnqClzeklTDVGtWqxW5tVRxyZ19R9uM8H6N375Ehchn733M88mM3/0n/z0f/v5PJFBNycLODte9Vhb5JMNQT73qEdYYvFLEQU7vtSR1B2NlsBE9IYnX2wwDQ5T4vLODGX/tb/w1PvvkI758/IKma2i9ZpoXVNWY4+M7TKox2WhEk0p6XXJzMgET2V494egwx9gxs5eJUZ4TfaSh58Gdu7w8zdg/3iePNYbIYt1x/q++4P4qcOehItmScjQjyxy5kWCU1cuXIllcBLrWMK0OuH8LLi5OqKOnKCpGe1Pqcwnhebk8xWm48p5nF5dMvoz8hRt3SEbuvsdjzeTNe1xtVywWa14ezHhxdk6IcL7asu5BW0PCEwIQoNeRfVdwz+1hfkGP0p+0Vfs3CKcvIWXcOJgzmRiajWI2GWNDT24U51cN203L3ds3UKbBqAgm0ieYjxU/VhmZyjhtK/wLz3QyY2EDyo5pFxvi6pJfebDiqu6YxBHbzz4ktqAPH/L5Zx9xY/U+5fweV4sV+XhMRUCnhPeRqtQ8/vQxb/zKI9o+MjKBpo50foUpS4xa0npPc3GGmZQ8fOcBZycX3CcDa3FFwe3c0WPAwzwPbHKLzce4MuPk8RMObh+xvbpA5SOSX5PyGbqa0/fPxf+aFAFFUpaiqtifz0kjw2z/EDu+RT5+BCGhrcZkRxSpwqgMPb7N/MGvsDSW6BNue4nCMJuMSaGncA7tDngZE2WuMdZgnEZHREbpa7reM5occvbighv37nN59pKxCaT1BU3bgZfp/62HD6inR9yYzVh88h4nj5+yqQNFYZnenDGaTHFlRdutqO48Yl54Tp6cUOYKN+R3oMDGiFGJ1G5Zrhruf+9dPv3ihD215uLxBV9cWSb3jrlxWPLyrCfUa5oXK4oXa0ye09ctm3zM9E6FJVDMR2yVo1I9zfkJIXxG3BuxpyNqZWCzFpWOMsRoyDLx+JZ5Rp7lZLmhzAyYxF4xAxxRG4LS5NWEqkx0rWRMdEFsEOOyYlz8YguqP3aLmhQSfSc6vTzLkOF9oCxK8qJAVksQQkfT9iS3G7xKpZPCkJkepXIMoHWJtmNGVcV2NcHaCL6hcBWYEdZNsM6ydmuuViuaridFjxtNSSYRYs9q3ZBXJX2/QgHZMHxVxmGySN8FHAllxa/plSUlS9+3hD6Qkqca7cki1FpUMmACNjcYo2jbHmVLkXUPNWY+CJtZWUXft0Qf0HmFD4q273HJSJqy9zRegpy60ND7hjwvUXnCU6CCpBV3vsX3evCoyxNDZUNDQw7GQeyUgAgg9sLqdm3EWTCFsJF1G4b1aQQlrF+bEtnATpbVmEwVFM4xvzHm4uKcq40cT99E0hDiK80+Q+/9ALCtAm8UmVOyUB9YTTOsp8Ou6lRBUVnxO+/ILCsLA6MVOmmikSBHl2npON42JK3IcieDkqgYj2Z0XcOkKuhTQg0hbrkNqBTItMErIAYJNtMBk0kOwnrbEhM4bUhAVeUkK8qEGOQzWQspfL3F02RSyTrWCybIcgsGQpI1cIiaFAR0HhzPyLNClHDRE5Pk+MQUUMZKOLCWJOtKj7DW0HdBBjLBkztH0kjbijZoBcYZQugonaNrlviYUeUlW5XwfXedoVCOJsz39zChYbV8yuJiSzUZUzc9qdnQtC2fPVuy6sV+arTBWUtR5BSFBeWwTmyVWmmMFUKmGo+uyRNiQLkEQy1akeXkuUJFWK4k0Tw3GqV7nMkwOSgvvxIBshwfAllRUF8s6dtAvVHoSUa0mmXdo6zBRU3bdnjfUThLygpckdNuGugj1ggptF4t6FpP7/Ww9o/4vkcbQ4gBowxt25NokdprwSZ5ntH5xN7hIdVoxmp5xY3DI1KIHN++SYoJ6zJUktrSLHc02wbfdFJlajO6bcOd23d499vfZjbfYzKdUhQ5Tdeyubjks/d/wpcvnnB2ecXJ1YqkJBBQGjsCXddK0GgUMtX7hEkyeI99YLte09aboTZaMpS0MfjOCxGmRO0RQiL6OJzzgeg9yuUS1KbkHpbiEGJsJOdJJyGVf5HtF2e8UdfJ0QLM4BUqTYOMm2sg9YrR3P17kavvgsp2LDbs/o1sMQ7eBjUEJiiupdNhSEG/lj1fv/LOz/waAN+9r5YUZz2wtq+8y1JxtZOTq7T7PK8AdhreQ0jzwYU8TDd2MF7rIfQpvUqRRgFGFjzresP7f/B7vHjyKV2zoe06JrMJWWHxbYvLDEkp+j7Qe+nkA/Dey0UySMo1gwpgB5CG7/x6kt510NhOZr7bF7svpETmHEPg/R//hH97+zcpxxU7bDJ8EWLYyb4HH7c8sob9oq73j3xN/ZXPsZOd75QFOxvAV84l9Sq5XOQbr5QE16+pBDC7LMdYh9aaPM9xzg2fweMGn3fpwnDRdWw2S+pmPVwEImMqq1Jex1isdV+xJnyd7UDnKDR96qhUxVY3TOx08G1HFA6tJMxOG4fSOSF2JBxBO9AFxjko5qjZHvbgBvrmMfr4GPan6OM5alSiRjm10eQW3LjEE/mjnz3laFKxILGnHZvQUmrHpu9wxtB0Pe/ePsRVVjxOSer7UlTEGPB1Q/nd+5z/777k9Cfv4ZIiUwqLIaSe1mhuvHuPH/ztv8XBm49Qg68sxMDmy99HP9lS/+AGz8djHr64ZKwt2h6QVMvx7Yf8s//hHzOuNP22Y6Q6Pnj/PcZFzoN3fsg//H/+F2yaC376W++TvMcQsUOlSEwBo2RRIoAbHE5E77u0NaAQSE4HZDZn/sYP2Hv4XVQ5pb064fnH/4qzp+9jo4TMrVVEHxzwV/76X+G99/6QbatZ9YoyG1OOLG+/8YgHD97g4Te+x3q15faDR2wvLpiMcmLbsHj5FMWaPrRk1lBfvaTK3+GzTz/mxenZwIouuHvrJu36nNj1LBYbfBdZXF4x2z/l+O47oODRo7fp+w2FMcwPjuk83J/n7B/MuH3ve3z4s/cIqSctazJn+cYbj7hz3GIyy+X5GbZUdI1isen4o09e8P1vrbl5cJPHF4/58sVH7M3nTMeHFLeOOTaWH3zrEaGPnC8bPvz0U372+ZdcNGtSlMVeTFKxNtKGkRl9rWviz/6Vv8dHX/4fhI2ILdpa2s6Tz0acL1YcHJXM90Y060suri6pTMCZhB0WptOpZrbnyIuSN773Ll++bBhNDGm7QCvN5Tqh98Y8X3Sk4hZ//t/9X/Ib//n/hlTOqZQmv3mLD788x+39HvOj24T8EONXsF1xOElcXQWmt0qqck6ja4y1jFJNjyzU8tGEsXWY1XNilrHebsUrqA3dVUNdRyZ39zk/r5mMK8r9Q1Ynl0wKTYgtBxXMJ2OK0YhnFyts31OOHdqvsdaQuUgKhqgkoTpzYIoRk9u3md96B1PsYUePyKq7EGtSWEB1B6VzYfjKEeW0oj37lM25pe9axvuHLE5P2C5O6OtzRiOHy+T7aCOMv3WRcnaMHk24+vh3iLbi+Wcf4jYnfPB8Q1FOaf0VORv2byRefhaxSnPx8Xs8fnxF6w7ZuzljdbWifbag3/4u03uPuFgk7Fjz+PkV67qj7TV9l4hO7jldD12v0XlBffGS5fKSqms5ayNnaQx7BeOJ5dNPnjKd7XPw6JCffZC4WSXe+Bv/a578k/+Yyy5nPpaAsidfPiObHGD253iviX5D87yl27QkDGqrKJUMmK21lIVjVBVMpyOcHQK9tCHPLcoaYUVSQpkhWdloJqOCvq3pU8Rqxf6sYjr95a+LUZWxWKzpWrH3OKXIcgnoWS1XPF9IAnffR6pcKn+mhQSxlaMxShucsbTNWsKmmhZjS6KPbDdLCe40GeKc1vSxJ89G+BRRFm7eusOmqdm2VxQuo+9qQtiCsvh2Q9KatvVoZ1BFiU6B3OYENjKkjkC0khKeNiRjcSknBE/XNgK6tST353lJWQXxs6NABZJXBKVRKuCUpt6uJIl7WFM13VJyXPqOqDQ5Y4rc4KoCbTJiCNTrFdgtIzXG2FxacYiErqGtO2Lfsd7UpCBe39gMKqmYICj6MHisGbJ8YqIPihg9oROSQ6Hw9UZyVaLYrULnqeuWerPGZnKONMsWnStan+j7KElhSE6QMkrSjsOQrp2kk3lnFSQklAqoqCXXRoHbqY+GhpDQ94PUVw+tJ7ICtBp89EQjpFFoRJkgGUtR2iuKgpAiZZahjcM3NU4PFZsoQkp0MdD2QYpDNh5XKEzmZChUVmitsUOlrdIKp2WQpbVmVIzZhkDY/vKZBwDNdjuoATUxKdqux2UGTydDoKxAO43SkdJZiioXOwQZMUFTN6QUJdlcJ7QWy2pil3sk/cxi8Q44ZTCZEkl0SqIgCAFdlORmLgy0BhsSQcugfzyeMT84grgh0zUJQ1aVdL4j1FuC7/noyTlXrdgKS2vIXEZW5ORD65FS4AYFqA89zjjKqqRpGny9HeqVJfysyMRH7LuepoOu6/BBerxjDFKZpgUkGp2RZZH1ZkNKYm9KvmVvVuJRECLJWLYxoK1FqUDdCPs+m8xQyL5bL7eABmslMExBSAGVywBOE4Zjb/HJ40Ogi4G+jxLI6ix114PRZFYk4BhD5zt86Fmt1hTVmEkQ1UmW50QfmO/tA4lG9eR5RZEXvP32N/j2d7/D4Y0jyiIXZUYSmfs4FMzHFeOq5PDJMR99+JGEKQ/YKyJMt49CvKVBbp6QYxljAOdYXlzQNlswMgDznVhXBZtqgveDPWtHMgsu6fuOoiwxSBiyRrPZbhhNZ6/ZeYUY/UW2X7xODLlpvc5U7yThKcqH1AOolv8HEK/B4A5Q6aGWS/q0X33I3QkYZQw0gMQBOA6sKYRrv/IfFyD2SlUu9V9x8HPIgHGXlh6vgd7rr6XSz7G5r7327vchRZSSG+AuGCwOXdtp2EM7QByC+Ci++NmHPPv0Q9ZXFyxXG7rGk1XCMl8tLhhVFW3b0neeumkJA8DdDRlCGhLlVRgkDeY6BO6a3R7+/PPVX7u/uz4xZLeSiOAU1bgk7UxHKQ09v/Kd/E6+vpP5vpaY/tUed/lvjEMA11cUB3IMf34/pjAAwRivP//1sdhJ17VIiWSxtFNIDEoHBVobkfejUKpHefFQNc2Wp88+Y3F+SYqKoprw4MEbHB4cvuYt3wXufb3NKEOmNFnSOAtlr5maEqUkUVNSATKiioCV45kdkB59H/Xum9gH91G397EHU/qxJWrNsmuwzvLidM3dowlfPr/iyBk+ONsy7j3VwYSbVcnDGzPm8xEHSlFkluATmZHFjNYQvSLPET8eMuAIMRIDODT4Fj+eYt79Fs/f+21ypSmHoDjciOLmEeHBPu2koLeeclRSFg7f9SS/pvnpB9gnP2bznbdYlA+4Uz5iMp5Rb19w/8Ye9s/9Zf5v/81/jbMBX685W9Zs/1nLO4uXHN085l/+w3/F+bbBJU85nE8qigJCJT087BV6WHhYiRlBJQXItRCQ4MN7f/5vcfvtb6PzKdoo1O0b3HzjDX7/n0558bPflHvJbM6//w/+F3zxxU85uay5df8tyqpiUhhuHN9mOpvw5//K30YrTdv0FKVlZB2+u+T85Amf/Oz3mFhPnlnWmzXj8YwX/TPqbY1vrliuN2Bz8syALimnlfiUwoR6W/PixQtu33jE7aNb+C6x3TjefHSfYnSbi03P9uIJj+4fMJvcwOkfsX9wk7a+or66Yq+Ebz96gxcnC54e7TOfjmh6x3JTE4uEtT0jp2i2K4pkmZaW2dhSzY7ooqNRgdxV3Hmj5JvvvMvzF+e89+EHXFxestnU2JC4Fxy60djovtY1cfDo+xyNHa4YMR/DxaLjo0/P+c6779IGRb3sGc016zqw13XUbaQ3CWfBqURmFdpouhj48P2PeHrW8m/9+g95dr5gYjzjpGi1ZnLzFp27z+TGI0YZFFOoVQ6h463vvsHppx/j/JLixncpSk20Bp1BMc7Jyozt1VP6oInlGJtasjKj71qyYgJ+TXnnbbrLU3zUNG1AqcT+XoatxiRtEIIq0DUtRwdT6tYz25sQi4rFYsmd6ZTKWiZViUczmYwxROZjRR4hKMVk7ChHFucy9t/8y7j5n0WpHJLI3UgegiXFFpXdRm7UtzHFG1TlR4TL/4R+s4DimKwa02nF0Y1jXnz0WyQ7JPqSSSWTiWin2Zw+5/gbP+LJxx+QNaf8+NM18zv3aXWkNA5b3KfbLolNB6rgDz837B89xBlY1Q3HBwds0k0+/fJn3Fu/j8kNamlR65pMgzYiczdOFriFl7DV5uUL2hZCb5gcjPnJecd3fniH1WKF8jVFXhKt4/T5GRjD3p0j7n7/32L9h/8Zixcn3Lv/Fo8/+hjnAB1p6pYXFyvu3JtyePCAzz58wuz2EZsvVzxcnZCUJsshyzSTccFkUpAwBC9ZNe32ivHeHfq+xmY5JhsTQkJpx7y0NL0md7KwVDgO93954K1iYDItKZxILK0xNF3HuNScrTVFGQWQ6YIuJEaVpalrytGY3FVoW1BvL9AGQmrFxylCb+aTKX3fgWlwroIoaqdkHc4YqiynmhzgL19itKGnocgm+LZGG4UPwqiV44qiqIixE0sgibGaUNft4NXvJfU6y+lTwCqFR7FZnaKUgJbtumVyNCFzhsvVlpgUXdPibUfTKkzSouyKAlLxsubQStZqPkWKpLgwFxJ8tXHkWUkXe3zoKMhJCdp2g8aSYqBuepaLJaurhq6RaiTSsCLzXK9tJDd2RwwwhCGKEjL0XjgHNcRx7vKAhhrYIjegJeW4qXuKiSFGTVh3qMir0E/EUqkRVlryhCQoVwNqAIbBRwkYjojU3CiywmGNIpCIXZAkaiN939lAEjVdpG+8rMecIWQdRSZ1tTq3Ekqq5DnZpUjsWnznkUrOOMhghdDKrSaaRMoTWZ4JG+uMAFSFhIzGjpgifQ+jIuNolpNPjvjyxUu26ut5vLPMiurLKjqf6H3Aql2WU8DEnvF8j4vFAtM2+BgoqhKU4AStoW89ofMkYxGVnJf2A+XQRjBGoRNGcz2cSNHT+0joPFZbdNdLjlDwaC/J7hbIqhF7RzcI/Zb26oQWCQhMcYvuOlCBD58uuNz0aCtZDcYYstxihuFLmWfMJiNslhNIdF2g7zr6ZkvspOGnHBWsNms26w2rpsMqRWbBakuhLWvf0kYZBJmk8HWHshGjc3CGkCQzKSLPKWcjdduik6JSCR88bR1p+o7MWbSC5XJDVWRoY+j6miyT/Iuu71HWkYyl953UdMlZTd95UgxYZ9HG4XTCZpDlji6JAiIEOfdJiNx86Cmfzmds6y0HB6Pr2jYfPG1bo0h87/vf41d+9Ve5ces2zhghWHbNPCEQvJdfTqOPD7BFhs1y+q7j06fPhHWPg2U4BKK1+IE8VIjF2XuPAtarNWiDsg6bZaQEPQlchjIZKCfXv07XKeogAmwF18rQpGA8mQru04hdR4sq5BfZfmHg3XupnDCvAdMYI32QGCSlXkmSr9H/cJG8YqJfATL1+s8K7SIL7aHSZvf/xHHCNSi7ZlNf23Zge/fRduBQqciu0XjH/u4+y+ux7ztwvmPxtVID4BzAK0Mye5Lu5p3XVn5MJAsx7QC4bDpGTl4+4+Of/iGb9ZKrxYrLxZKsLCEl+j7g+yBdlGjG+3ssnz/l8nKJsXJTc86SCLSdJyXpIdd6kDQNVWDXFoA/Bny/vu3A6242Mp1Uw/fcgXHphd5Jxo3WIoGKQ6AeEigQv3I8hweU1tdAVg37TyslUXxqqBZIA+hGJOS7JPzh07GDwa8D79eT73fvl5Bpr1bS8elDvH5PpRJtu+Xs/AVfPH2GThn37rxBSgqt7Vfk8um19/xltxwotMX5wEhnRBUGH4jI1oJiqDyQlPE4PqL8D/5XqF/7BucEqHuOb0zoA3zx8gpfJy6XGx7dPaCcTzjtIv/9b3/AP/g7v8o3buaMRzlPFw3He5ofNT/l97dvw+wA4yN17PFdoukjKgaufM/D+ZxqZEg6oiOYBJ2XREyVGXAKdXDAl6lmimM+mVEcHPHwO29xWa9Y2sB/+5v/Nffv3ePmzfvcOTpmMp4yufeI782PefLFCadfvuBT94Qbj/YZzQ6I7ZL25Kd8/8/8JZZpy//x//xfMM41RweHXG3W/PZv/RaYDGcS5XTM4uyCIoFG7i05ArrVoCuxSsvNfEjptFh2QwyfEtnxPe5+81cJWhEN2L6lN4YiJr7zZ/4iP/vsd4ix4y//pV/lrW9/i2QTF41j/2iPA3ebfLzPzZt3yWkZj3NS5xkXju3lFW3bsF0veHnyJYv1iqu+xgRP5ztujY5ZXZyxOH9K314xHk/IXEXC8PzZFbOR440379J3mrOzU87OT/j8yYd8480f8M4bbxL6nvv33+bw+ICgHJ99MOfmcc5ktk81u8M763tcXa74wz/6F5juiuPRlItUMx5lvPXmA97/+AkQeXR0wNF4zmpzxp2jEd2+59bhTbbeoFTNpMopKFBZzmh+i+rBhLfeNfzFX/t1whC25JsNX37wEZePX2I/Pfta18S9B99kb2/ETz9dcLC3T71uUCkS2si3v3WXTz9fUdBTOijyjD51EMRL1UdR9hQu4kNkPi14cVHTtDWLZcNoP2f/zg0uLk+pN0vGh4r9wzsc3DzkshOpWhM1l1c1bv8hT84uuFH/Lgfv3sI6kYE9f3bKW/f2qGa32WxXLD/9bbp2QV033HjwbfK9t+jqRFw9I5tMmWvPyIz48nRFKCqUj5Q6MR1lzMeTgVHO2SyecnzzJs3mivlszHJ9RT46ZLve0Icr4lgzHjvGZc/IGJLWlCOLKXNi0oT2ikxJYwF4VNKktAJ/CvaG3FOUASxKjaF8Gz15QPPR+/T9E/TsDrHtOHl2ObAREggjw9thqNqsUI3i7I/eo73Y8sllzuzWXSalYds0BFWy3QRuHj2guvlrTOd3+Hzzf+GdNy0//vFHjOYlbfRcnZ7SV/tUD6b88z94yp95Y8zp5TNspiT1Ohh8CxFF70V229kRxWROoWF2WPLd/cCkylie9ty8MWGzXXF4MOLmbM5nn71kdOMvMNr/Blm1z9vfjDTtljK3ZG5EzEqOD/eYTzTbrmE6n/Dmmzf58mRDDGv2plZYO2fJMsd4LHkfMSZCUKTUsj85IiTD5WLF7UlBMIYQekLwZNbhTYcz8swzmZVO4V9yW663ojLqAzaz9ClRFhXOKYos0LQJRQ9W4wxUo4rFpQQ99TFQJIUtRiS/IQQY5YGLq4/oOGA2nVBWI0J7LmuSGEmhBT1GW6hMiQ4tWaYlvyAZyQPJS9r6CmUkjyaoSB9bUl/j2xoJE9KU+RjfbCkKy2a9YFSM0CTauuHk5YW0YhpFaINUWmY9bSuD+9gKsNRRhi9BBYhpaHgZGOChOiqlRPKJOiVS3WHRbHRPnnUoepzTdJ0i+EtcVuF9z7bu2dQ9XZekNi4TeWjaNaJGSRZVKqGcHRbN4v8XvT7Dm8vASCmx4cQA2ooVTFtLMiL1bpuWvHKYzNGvpL4IJcA3dMKo68G/H4zBmCHTJQViMuid8qxPOC3vpcxgpzKKGBI+ejl3cfgo8lgfAlpZlDHkY1kT9V2k6ySnJXMGehl4tX1HZjTaWZSyKKskLTolMuuIToYcxg51fzqDKH3kk8mYTd0RUWw3V2ROo7Sj9x196PnirMUtalIS4Px1tiovcUVO09asN1eMqxFlWaK1IYYORaRuG/reMx7vmgmk911ZhW9amtZLgFmWoZTHty1KS8Aj0VM34plfr6+YZQX5ZEzwaeh5jtiqoGtaiiLHKitDF2Nx2Yi9wxv4ZsXF089omy3VfE7sPalv0Trw0WfnnKw6jDIYJF1faUtmM0bjETa3lGWBT1F64DOHdVbIS6UIQWMKQx89SjmsKyiiWD2tllo1ZWCsLSk5QtLoFHBDgJ5XGuMUeTLUXU9Xe3Kb03cNKina3hNWkrtV5Ll4/nfKYtWTgtSMaeWISQ8e+4EASSLVVtYRY6LICxItySuyPBdLiDOkKEn7Vst5V9fgRq987V3fU40qRrMZucuHqIVICIm8ENXPr/2bv8a73/wmRVkMeVgCJGKM+L4jDdXEMfZ0bYdveraXZ6hmwa3DOevtkrNti+87lBVw84rIEwwaQo/SOXW9pRqPYOhyT0oTU0JbSzWZoZO8jwZ86K8V3goZksUYpZPd6OshnUaj4xAKrZSoCH+B7RdnvKMnRXsdhZWub2Jc92orvcskTtdMZ3wNCO6AWhrkzLstpvQVCKRfA0jx+t8NPdqvvf8uHC3tfMb61U5/HVjHmL7yOj//i+E7pEEuFFX8qpR7+Jnd/Xw3NdzddFNMgzQWQu+5PD3j5fMnPP3yc1aLc+qm5mK1ofGDZyoF6u2WzXpDoyGqnL//H/0D/sv//D/lJ7/7Icoo8iKXHr8Yrrv+YhQwLJg7EeIuSf7V/trtm9f3+eteeKUkzfKTj3/GZ+9/yjs/fBOQhNI0oHI9sI0mRjqE7d5NemT+Jb83Sr+yHQyS/l2C+85XH3Y+CBgY6jhIXNOrY6peydevveLp9eO1i+5/ZRfwXlI65ZhJL2rfd/S+wRYFx7fvMa8OuH18h9l8Tpa/SlPfnZuvWxx+ma3AMlbiZcywVMZQGE1KmYScxX6Q8jqMHuH+3j9g+qP7PH3/MeGbd5iMB6l5FjiejcgPFffVhFmZc7LZcvJsy7/39/4C/+yjx9xWGYc/fMBentBVwb9y32eTZXx2uuEgN6xT4qCwJKslMTdAMXGDf1+TtCR72ig3i+QsfSZsWJ9l7D16ix/9+e+jteLF6SlZbhmN93h4/IAstzx+/oyu8+zNtux1HYcHe/zgV3/Idr2kXnfUyyWPP/mUKmspbMaTn/4eb9+7zf/83//7/KN/8hsEIzenEBXL5RXjKicvC84vF7RRUSD1DYpdsJrBYQYQLv7vIZ4H0Pgk58rB7Qcc7M8wJicZCVhJfUenC/S4IZ/OuXP7kL/1d/8+6/UGlGK+VzIZHZHnPd94901C1IRNz9mTz7C+ocoyzk5ecLo4QwXPqu5pu0jwlm3jsWrEIQUvTp9x+uKMw3nF3f0JJMvjZ8/JTaKuW66awM3ZIbnuOT445sXLF6T0AfNpzjff/bPMD0bktmbkFMU37pPFLePKUqYtdcjIfMX9o7ucn3bU2zNc1nJj7rh/PGG9uMHDg4q//evfpQ+Gk5dPcXnJeHyDNiROzpY0uuXmLUgxZz59SPKiipyMxuhU42OGCrIovPO9d/j2r/9Vfv//8d9+rWtiOr/F/PCI6UWgC4Focg4OezbblqefPue818yrA2aznJs3DrhanUhWBQEfxA+sFFRlRqs03/jm21TjMSEourZjvd6wXq0p2hpDRjXbh3yP7upLZgdHNFXJ7eNjNrXHH9yl3nxCSpowyEwnsWPx2UeY0NAnRUqGVfkA2PLy8c/Y15rNyRNWF2eYPGd+922uFksIsFl3TPYqurrD1mvWvkaXFUe376Ju3ePyy884f/4M52A8ypg++gHj0YjWzjlfPcEYRVUYkblZS1FakouslxdsNy/Qm5cY3YKZQLrCuDmoKZh9uW/FBpDqG3/1E5r1JefxBlnzKeHsX6BToFk3NBiUmsgzKgkbQEy0ywtWl47TZcXxnTe4d1STjw/IVEu6MkxnexTlnOgrpg/+KrP9Aw5u/A5t+IKRy5ntHzPSPUezEVfNliZoZrOKPisIWjPf02SZYdslUKKyaZtE20fc2JIFz3xesFoumexNWK6uyEcF48M5mw833NAdn//kCeumY/zg+9iixFVjOn9C63v2j/fomoarRqN0Q3t2iR6PuLy8YFwWdGnJ3pGl3njKQhO1YTLOqaoC6ywxQKcTfQ91lKfSfJLLgBnphXUu4ZOhKCxa9/goi3jzNQi+lMD30gmc54U8X6OnbSN5lmj6jmgKDBrtEk5ritJSlCOKfA+TejJTotyIrltTlXOUueDp0yecPO2YH+wx25uhYsnV8inR9Fh1ADFR1+fYbAo+4dsNIXbYbIJKitgHQtdihmfEMkn/s6RaO2Ln6bY19HLvbuqa7aYhc46ua2m6gLJpaH2R4U7bJuptlPVKSpIBE8TjbqyRYXzkur1Fowm7tUAm1UkhRnwUomfb9ZJ30EqYlNUJTCcKriTSYesUhkSnIFoJVVIJbJ7hfUeMQdpElNTdCTCPqKhFvmy1gGSESLG5xeYKayyph2CkHzgbchPapiV1MlAnyZoxeQaWTMJUQ9wxrZJPPUQtk5TC5QbtFFonbNIYbelTJCpP5ixKaTovTS9KGawTwsQ3nXScW6nC8l7e32U7S58hM5bkPSp6YlDgxS4hy6s4qDpkDYhOYhEwFm0UfVfjjGFbd8TYotQIrRPOSttIVRagtKSNf025oDKG6D2x78ldRlmOQEnFqTZ2aJ0xTKZHZFmO1kP9LxKWm1SCZJCxfCIhQXPSbR0kubvv8Z1nZC2WSOwajAKdO1Q/0Eka2rYe2oE0ZVWyd3hEDDXPv/yMbrnCFpYQGQZOPU8vljy5rDFGYW2Oc4Yyt5R5jiKwXi0YxynR5OTj4tqy2dY1KiU8co4vr7ZAEsBrIrPZmOhbtNE0dUtoA22bsEaUdihYNV7sqVH84NoMCmKTM9+fEPqKpmmlXckZFJGm9YyGarTee7IqQycZjGZJ0QdJzI9RQg0tnswqmq4jJKh9wDlDE6JY97wHJ9e8TvJzxoGOCt81NJsNmSlotzUuc5w+e87R8b5UP2s1qAMcP/rRD3njzTcoqoLMSnNDAmLwKCJGy/kQvKdZrVk/ecLio49ZvXiJv7rEZIbb64Z131L7njKf0el2h86E+B0yMlxWYJR4sX3X4X2kUBprFVVWsFpfoYsCNZmQUmKzuhLlitaSuZAEu2glmYRig1bXuEhbySRSNvuFzv8/BePtX5OYC6hVQnNLj64admqSEyIOjGaMgzd5kHPvWsQk/l9k1eJ1GcDtV1hzhRkY2lfe8UG6viPBgBSDpPmpAfTvyn7ZKY1el0DLATFmJ+GWg2SUwsAgf47ScTwMBNRQDcUA2nx85R3YMe3Nas3jjz7kwz96j4vzU8pJBSrSdzXrzYaIwljxaFhrWS6XNE2Hyy2rxYL/5v/0/+KTnz7GowhdR1XklGWGsRaf1vS9H27ksn+8l2R3YcBf/fp5ufzr6fO7/QGRy80Z/9X//b/iP3r4HzLZG/1/SfuvZ82yNL0P+y233eePzZM+y3VVu+lqM90YD3DgCIgQyQhFKARdSBFChP4F3emKCl3rSiFe6I5UIERKAQxBEBCAxgxmpntM2+qyWenPyeM/u81yulj7nKweBshC1+6o6O7MrPzO93177bXe932e39NbAFIovOpjCqKQqHBFqv+sZP1KCRCv/0ZBiq4xWl3/uR6PBwRCSP4iISOm0KhreYhIUVm+z937zET9inqebPR986B/3RDD9eQ8ec1arHOYfMCtm2+SmZLZaEJZlJgsQ+mrz6GfpYr4S5/Tr3IJAYXM8WKDEJGhLBjqAh8sAonTqcPpUbjJA8q//y260yViWjGsNKulY0dHotMs6zWd1xzPl3zt7g4PzyxPf/KYf/D3vo2mwBiBzhTlaECQ8K8va+66jm+8tovQfXSWCNgugV7CpsV2FlVlvRohlbRa95+rVri45qP3/pTp1jaxVOSjMV968+tsv/yUP/qTP+LmaJdJNeTTT3/Mxjmev3jGvZv3udW0rC6XnLx8SjUwzIYDpFlydrLBTzLK6W20UPzrP/4T/trv/V2GO/v8P/7L/ztFaJGiQCmFi4J121IMhqw2NVmALNo+Rzr5aBJwrV+bUfZ2lr6xJEEEze6te1SzHZTJESLQeYfC8sII1qdzHrx+j9/5nd/kxu07zE/PWS4WDLILcuU4X9Y8+vghWVki5kc0g4xpkQB17cqi/JoyG9I0DcIUjCZD3OqcKstp/IoQLe+8dodCG0b5iM6vmY1yJpMZp8dLpoMJYMkne+S25SC/S+cCS0YczwPlk1PMniQfwEQLlChQjUXZjrzIcS3cmG3x7MX7PHr6iMV5S7vaYO2Grj3lO195neFom8efPmY6lrz5xtep7YCf/vw9fv7RMcNphueSspwiBzVKR2ajgtp1ZLHDGUE5GJEVFe0yYz4/ZuvLD77QmsjyAbsHb9L+9ClaDjB5ZDyLLC7XSKFxrUVIRV07nj49YToJZMahlURESfAOLT11C9uzLRpKbNMQvUXrgigUW7MJJyfwxs23MXlOPhxhnwfOzi+RzrI8P+H4+Iz7b7/NqikQ2QDXRLSShMGEsHWLZRwBG0a7t5DHJ8jRNl1suTh6jCin+O0x58dHyJMnlNUAosRGweL5KavoEMMpYWmZtHPOnENEwfmqZnzzASeXNUoq5LP3kJOCLmuQy0coE4CczIDJFXkuqV3N8tnPWW5HMF+iqDJMmeIi15eHKOZkw+TB7OqjpAhzJe35M1arS3x3CZMHLNoB48kWl+v3uDHbEJB95GM6wHsHw60ZbagYm5bpzdd58egXmODIxxPcReTscsO0E+jBHca3HlCYHFXeJK/mTPan2E1DKD1PPn2G0yOqYk1nI6accePuFt6+xHkIPp0F0nM6NVJwLavDFQe7B/hS0Kw3eBvYNJKmtlQDzfZEoRc5k6FmdPA2ICmqLfz8Q2y9xo8LrI+YzIBzBOvY3RnQqQEyOkLd0Oo2xbKVGpRmNi3J8wxtDEFGpApsT3O2prucLmpcgIHOsb5DRIsxKfYHm0BOkKCYUf7qEz5lMiIp3jI3up/KKJx1DAeKED1NTMXfsBCgkvfc2hXzk0tUDjvb++hyhshmrDenDKstDvbOmdcvwUt8HVguj5kvX5CPd9CrBZHAen1Jpuf40LGp18RoEXKO8x3BWmKvnEOkNJToHc46ouoQQRBEwFrfFwypib6xbbIsjQwxhWFiSklnA5vaY22EIJC6V8QJiB6cTdFISbaZih7Re4kj9DFKr6TeSiSlpZSS2KucrCNl6wqZaMomI7hIZ5sk+/b9oTCA61piny3vvaOfEyDpAb6yn8gbdX2+FMSk7OyjtpwPaJmk5llRUG8sduN7Cxe9hFsg9Svuju0Vm2kwEnopYPJvSwRCS7xLe3CIEe8sPkYykaTmMaQGQ1Uq6i7Qtum8XZQ5KIGU4Jy4HhxY5xgOikRLlxErwjUsNy80RIEVpDOjjEgJUUVCVEk9KNM52Ebbx515lMqT7UxCmRnKqkpZLFlB2wqC7X7l9QAwKDO6vqbIM50SGPKryW5P+JYpSztKSes90Xbgu1Sge4gqUNuajAyT5XQuke6NUgilkwLHpDjfziW7kFIR6yxEqNcNVZkTYyBXClOM2LmxB74hbk6Rbc327ozOeaRvqBcLHh+d8/w8Ae1CSFaE3ESUAGME47JMg6esAJUmx7ZxdF2DdwEfUyoTSEQM5IWhsbBZd1R5pCwU3ga6JkmsszxDas1yvUFJqAZlUlPi2Wwa8iLDZCo1w1rLpm5ompYiL6lrj1bQtR2N8yip0FmBzoaszs97NWayRei+GWyKInEPfCCTqRbyMSQ4W5ZsAS4IpPPYCLZZo7Qhuj6GDcn+zVuU1ZAQOnb2d1Ey4/nzF0ymE/JyyKDIeP3NN3n7y28zHA7JtCHdyqlhBwIlDU3TsTg65PThY7oPPsQ9e8nJ6TPOQ50YTiolJd3JI7U0KSqN0KtcUs3oXExqEhEphmO69Ya2S/Fk0XuE0USRao5ms2G9WvXpJzENzXxvuZW9NIdU/yqhr9d7iBEtUl3hPyec9nPvJs4FwKL6aaiQSQotoyDFtaSHVuhnUlfFE6SfV/WxEdfT1+tC+rM/qPiMWJvPFHmvCucrWXu8kkjHlAnuvet/N8mw1dX0XfST7M/8RNdTVHp/Dsmbcz1R/aWJeV9Eyv4FSfIzF1OhvpnPef8nP+LZxx+wml9gQ0cQguFoxnK5ZLVec3Z+SWcjxSjJMNouUlvbezQEta35o7/8d6zqDdWgSF6szlMWGcZICmPAh/Q+YyRBqFO8yP/UdSXVvoJ7eO+RQiKkwAXHTz78S370g5/y1/6jX8eYHkDAFZSk3wzjVen82StexyMoIdDX8vKr5sYVXO/KTx/671Mwno2oMp38VzJyOV/1skqSRwOZAHI9Nz+EPmJK9NFv3vXRdPH6Z4wxeeGRGVuzA3KTkRmD6EmSkKbbsp/Gp29VfFGlOYqIkeYzUWugpO4ntAZDB0JhkcT9fdR2hTwYsh8Dy9oxKnOUMhjh2J4WNK1lMqrISsV37814MPoa/+JHz/idd/bQuSFGy+PzNV2t+evDCVoKzlyHWFvOO4fZeF62gZmU1FFwZ0tRDq7sEBHbtqyXS5Ynhzx/+DE//v4/5+1b9/nGa7f4/p98n+OTM167twQ69g9uk+kOdGC6fYP18Qve+dI3qIoKj8aqyHIJwnUsj8+ZVhWDrKPZWGpZMJtovvnd32eQD3njwU0mo4J6XmOyyHoR2a9yGhfY2ZpxEiMvV2uCNEn6EyMlryYFOmokMcFKYoo88USUiGztv8bTzQIVOkaTPd57/BFvb2/zrG74+KM/5bvf+w3uvfYlpBSYckw52uMbv7bFpx/+DCU6Li9XyLOIdi2DfJcXL88ZFoqzLvmjVm7B1nTCYHsPqYeMliWKwM7kBmGxIoaW6c6MUTUhyC1GO3fQWcWN/XPWqxe0rWJktpm3KwZlwY2tGUWW89ZXvsTq5YIoSrKywuDQvkXSMh0UrFtBQ6QcVUSXs27mLLqapdX80Z99hMCyv73F0+MjHty7xcH2lK2DbWS+w+7BbV770rf4+MNHfPLph3R8yM75S4azPXSZYZA0XU2xpbF1hzQ5zrVsDQccfPXWF1oTWmluv/0dwh/8c5TKaZdzOp+xWK9591t3aJ+ssK0HnbGzNyW60z5+JTVZuy6SmUgrMuplw4VtCZVge1QwLAzLLjKpDOPpCFPsoJRmsvsGmx//OYUU1B3s7ZbcMnsEMrw0eJFhgyIi0EWOGk3RRYXUO4TNBQjDzZ0h+tYdnjx+H11O6Jafku3c4uzoA7amDapUxOMVUnr8dI9oLdn2PiaXfOdb3+O4zTn54ffReU4u14xu3uTwcYcxntX5I2aqw682dHvbZCRGRUAQAqx9zjqWjOIJTS1YLp+hkbSbBlNq2tUcJ7bI8xOsrajG99J0ovNsTXewIVANDY1tKaucfFBfN6Z7F1aqrULH8ugIOdomeEtsGxolMRtJxLE93WE8GOOLaWoAZAaTlxyfpwmGEjCZCLq9Ma3X7O7c4LI9Y35xhqstlQr4oBEKtIxYD9eUTBTDe9t4mTMaZjx5sQClGI8laJNUL5nm5XDGlu/YOngThKDaeYPF6b+lbg0TZTA60LnI1s6MxfyUbn3J7oM7vHz8MGU0B03rHFJpptOC8bhCG4MxGi89Qgl2tit0ZlCyQ5iI1AXEJBF21hJDBwSENAg83tacXpa/8ppoawtK0caA8H2MkA1kVYUxmkyvqZ0j6BR7FoNnuXJ03RwfIA8F8/WKKsjUtGo7VosnLOdzGi/p2lPabo0SFUoPCW1HLZYQk+Wg7jy2a+hsQ3AOH1PqiSTJMBMnJeJ11rN0NNInVWLt2r5wlKmBkKIlyPKIiBpChiJNhGRosZ0nOI+W9MVn2qPDdZM7UaxFpIfX9ioXpVKsYExnMilksin0//E+UZe1TqBNrTSIwLjIEFJyuQjUdoPIBdH24FSRiOxEgdDJd+qdTdPanoGg8wyjJM5aQnQoY4jC4KIiRocusn7IElnPO2znwCdyudSpSAeQpelBUBBDosBfu+R8rwrtpbDep6g02waiEnib2CadSEVODIIoEn1dmYIoE/9iMJrg8ISuJdCBlAm85bg+W/uYBkVSRnzweA+ZSVP4SEAjyfNUzNLD3AjiWtabZcmGV2aKvMhwPQPIOYeSBiPBqUjbtL/yeoDUCHHRofMcozV5ZlAmS+dqqYjOIGLsmQ4RGSRBSILKiICWAiEcNqZYstA68ryEYFNakBCpYdKDtozRaCXoOkuZV0QETnuIKeJPm4rd/QNkWGPcnFW9xAwqWu+xtsE3Gx4fnvH8wpE48ZAbQ55nDIs80cq1QRYVeabpmhaNwQiNGZeUjcCFpPiLEYJPakjnPa5rqAqdbAe6ILgOqTUm11RlyfxyiW8d+bBARDCZwgRFXgxo2ibJsr0nBoGInirPEVqSaYEgQSYHWrNcNgko5zvG0wFN0+GcAxIRPSuGRGVYzC+JUSFNSj/JpEZK6HAIIRmNBgjv0cBoWBA8eNcwGg2xXbI1+uDYPbhJnlW0nWU0mlJkFVpq9vf2+da3vsl0Nkt6hRDS/UjfyJKCtuk4f/gJq6PnxK7Dr9bMX77k4fKYf/7kOe/ujHiwdYvpdsH4wBM3jg+PFCnNIjW+XiUl9bwRrahthwyeum4YjicoZXBth7Ub2nadLA5Nh+oB3lLJq8dWL4tOaSOyv6+QAm8dWimQr+zO/3PX5y68tUpFsvMBIWWCR/VSh1eu61eTZugLXClRQGbMqxgnXk1or7K/QwivgFn9wz3JomWSKPQSxM9en5WVX03Vr36Mz3rEr4ruX4oeu+q4xvSQd96+An355GuOV3+OkKRNpO6rQGA3NT/76Y/52Q//FNcuQEZW6w0emG1vJzmg7Wiu4BYhdRNVZmjbFhB459jU6ySBlaCMRAtBkRk2bUt31vXgC5F8RMETAoTgryX8vyQr7xsXvzT17iXbV3LDrEpFqXWedVjwz/7gv+Pdb38dNSvSptQXOErp68Jdxdjfc6lNkYan4lpxEPrpNjHli19NyF0PRgjR9x0RybCqmJYlm3WN1IJN3YKXyJgWoA9XAJQr+Xm8/vwTHCNcKxWu3nnysZRok6OURKtELr8uzq+sDFJdcwKumlhf5DIoCqlwPYmb/kCQ3m+KZfNRIKJDFyWJhZhIly5E5osV43Gi826cZ2dSIOqO1nvWXWA8zVk1LUrBw8uWzdk5t27scXO/QP7hezyPGef395hmijzLmexotmVAC0ddN6wvnvHiwyPOnnzI048f8vzJQ46ePGR+dkKZD/nf/q//Eb/x176MD2usu+AHP/o5o0nO6699jclgyQ/+5I/Zv3WbX/vKN3mtzDmbP+flS0fEcOf+68yKguXmkp1hhVcldrNCG4eLHV2ccOtgxu07D/jBn/8btoYDPj29YNXU7M22aOoNmTCcbxZY69CZIgwnrCXY1QZcZBAVeaoYSEFs4lr1oPEYU7F74z7PdUauhlTTKTfsbaaDKap7zvag5Nu//j18banPV2zdPmCx3lBWA86Pn7E/vM17772HcBsKNvg45Wy+oYsjPj26ILqaajbF2xVSWswkstmsOdjfQenAuDRYt0FLQetqqvEON2/cI4SOy+MjZtu3ePzhzxPtenLAcDQm1wO2toZ0Fy/Zmk4ZzXapsoJQL4j1CqMN0keitIRpRcwnfO+7f52nLz6m5RPu3L7LdlUx2b6Dk4Zm9ZyDXc3ubB9VTNms10x2Mr514wFff/cBi9Vv85Mfvs+P/vyHPHn8PuF8wfH2gHI65nb8Klle412Sto1HE3z++aRS/75LILj1+rs8OBigteabX7vJD35+SjQFD58csrqM5NMhx6cbvvy6pnOgJJg0VEJGSWlAjSe8fH6Ens7IpyOWy5YittS2Y3gwwciSyfYBUkQme/fZm+QI4zjcCI5P14Su49Z2hgyQmZwNCRrniUTbojQsomarGFCZkvOTU2Z7JTcObrByhqndowuadrbH2YtPWK8jm1hQ3bqFkQI1KMlkTjkaMH3tN4CcrYc/Z5hZ7NYO2+Mp47c1UVWszi7x7iWhewGk6MkQI8H5PpfXc/L0EHv6j7Fesfv6dwnOklrulwiGdOK3WZ0v6c7+Jctlhxm+xjAEXj78kGo2o2lqMHkCvJCe3UqrPuZIoETARs/4/hucn1kGVc668ezOcorRFtnCY4YzTk4vGN0Q5GWBiJ5cdKyAca7YNI7FfInTktVqxZ4osM4zGY3ohCC04AJolQ771qX4KB97tofMWNYNM6UZDTKELghRk3lL0wq2dg8I8Yy2eZ1iuIMQgnz7PoPSsOUVVZ7TOM/FoqaavE5RvqQYGNpmzWg8Zq8zrM6f4XNNNTDs7IwYDKokQdVXz37HfKUYSEumDPP1krwq+/SQiIyJ+FxqTYalc4YQVoyLLzDx1lB7h/Fp8iiExzuBig7tE1B2vVjQIsgzUFr3RRW9PFSQeVguFnS+RYjAZrNh0xmGsx2MMTif2DDi6pzQrhEx0XiRhnq9pHNd33BO34eLDqM0zvl+baQJl4iRq2pR9FawEBO4TF7F6yAIQmFM3u+xkkiSdat+rBxjsg9JERHq1fDlCt6ahgIRJVO8nuoFGj4keFG0CQpYKEWeqVSUi+TR9m2DNJrFqoEYCK5DKUleGlpviSbFTyotMJkGH0CBzDKUSskoQaQ1eDUBK7IxzregFEWWE02Jay3YlqbuwMWULa77NBuSn1ySDvcueFrrwCYlp/MBrQVoQSYSST8IkCEdPjoX6axFSYUHvE/TbplUxWTaILRCRU2mU/GoyGi9JfSvK6LChQR6jSpZ15EaEQKeRHgWSqXCM88g9BRnehJ+jMn6IpMS1HYd3lqarsEHTzUYpGZOlPhmw3ozh95v/EWuuq6TRF9GNssNdmATcE5kSJODlKkxpAWZKehii7P+WvmY3lekyEcURYFQkq5pcC4VR0rSf64Cay0gqVuP7zxStogAVWEosgLnFZO9AwQtpbRcLC7xXYq+ujg7B+94enLJs7M2nUOkJNMmxdMqTQiBXOdkJkNnmo6IyAxZmVMUGagMpxzt5QIpJOv1ivFoRAwe0xfSy/WaIDS6Kqi7JgHalGK9XlNmhrwqCLZDho6uFkid4WODUIpMZ30SUCBH4qwnRAEYtA5keUbXWUbDDJA09QbnAi6ks9RwNKYYDmk7m/ZGGejagIuOqqroWgd9IlWmJNF2uChpbNefozVaSuraIpQGCSeHR1TDEbY7ZXtvl9F4SJ4XvPbaG/zau99gMp4kpYwx1zUg9CpqHwnO4RbnqZFmMvRbD+DohK244W/c9exuHSBzQTZtyMZwbyg5W1oO54o0JuztsKqfXkdwroO+ftFaARHvLU29wXauXxOaGCNap4iy2EPeiJD4K1xHlUXSwFGbDO8sQr0yI//PXZ8/TqwfL18TpoW4agCQJopXCWain072EvHe96t6ifWryCv/mUnhL//aVZcU6G9ulbzDVwXl9SQ1ldVXkVbXsnH5SpZ85e1OEWRXU4DkGzg/O+foxXM+eP99Vqs1os8uFEJicoMUmulkxmQyZro1YXdvl0xrnj98yE9++Cccv3iEtTVFYWhaRxcCxWDAeDomIFg3HevG4YXE5BkxRDKTJqTRrbCtvc5vjMGSS0mlDcbIFCcQIu2mTgRHn/D/ofdA/VVSeP/RXxfa179H2sRCn89tskSwjKHDEXj45CP+7N/9Bb/9t7+H9SmiQevslbRbpE1GhQSqQyaJBaKndsb0eX/25/hsQ8TF0JM+IfrAyxcv8dMhMXratqPpAjHIz0DrXt0PV3/HL0/QY+8TUaj+ta7U6ZlK+bGib/CIXnLiXMrbTA9MneQzfezAF7m0EAxlhhNpw/NIZIQoFEomz4oX4HHIYFCRPitUMCkNw0IjgyCLYArF89MNR4uau3tDnl1uePdgi3/4d95GisgiLLk9OmC2XZBrsL/1NjdCYKdpWKwuWTx7wXufPufw8Qc8f/QpJ88fszw/Z1jtUmaRQVVRCcd2kTPdO+Dv/8f/gC+9NaGtLxmMB7z95tv85Y8+5IOPnvH6vbfY2xsyelLy/nu/4Pzskvv3b+MDlOU+N+7dIVeKxfqcsix4fnJMaxvuH+zBZokf3MIMKoaDCYNBRTXZ58XZGS5G3n7rTY6PT1j5lkk14kXbooi8fe8e3/v2r1HkBcuzc+qTJaePjpBnl+TSIGOKrwgyJDpuiBTliGxnj/X5JeMcolZ0jSUOAuOwYmM8sdtwcO8B7uKCUjS89vodpBYsL99iPB7z8vSM2J6wV8yo9IThqGE43SE+O2JpG7JoOK8bilJRHx2BnfOi6yjLEVKWZHrDZFyidMl4d4/BuMJvInfv3keNb3D04gWbTcOw3LCrx1R5zmR8g3bxlNHelGEWUdJhvUdFUKYAXVK6dH/pUYmQBfVmyfnRe7y+O2W2tUO5PSWaIZeHGe38Z8SdMSEY8nJAJnIKA8EYtkZj7vwv/wbf/e3f5Mf//R/yb//5H/DR/CVllfPyy0/YefMWXsGdO7fATnj2iyfwd37nC6wKwc7+axzcvMHjw1Oiz9idjfjk8XNub88wylKNNEZIZtMJm/USE+YYBcH36QB5wJoZOweeVbYNsWU0qahGsDXYpdls2JxdUAy3EVIy3buPNAWr9RLhIsPhPqOtEYNcU+xto/OS3GS0Oo2g9nbGrNqMeg1OrImqYqg8WhpEWbB59pjOJsCPyHLYvUsdl5TlEGEMo1wjsgG2FRR5xezWm4TaovMhxchTeoHHc/LwMfnOGKUmzHa22JyvcSFQ24iTHuFdD99piUvNbGuPuIHVy5/R6SmVAEFHF3YJ05yXT97H+DN07JDrmnI2YHrrJjIqRF4xXzYURZbygnvpnpQx+fhJPsB8vI26PKZrG6ZDTZ6NiELy4tkFxWSLgzsHtMVeaoS5SJnB9tYu9bMjogxsmg3buzeo/Tq9XjWkVIaLxYYiT/uBJPkhlUxnAaJA6YzcGHYPRqzOLxmOZqw2DS+fnjAcHXDrdsnJw8esFqeMv/6fXANGs8EeAklVVixXLQMT2TQd7XoJTjDanlK30DYdTb1Gio7xcMjO9oDJdEhW5KkRqzRKgxdw+9YtVutIqx1aCayHtlunCakTLJoVmQ7YaAkhyZtX6/NfeUW4GGmWLZ1yUGkClugjLjQJ6hQ8nRNYBDqDUgm8SdYvsjThbboGIfuJEBFRbDMqMozWCJeKcWKHkQVBKQQq+bCbDc5bgktJK8lr3dve+mhN3Z/hjEq7mLXJ6uCCSJNrZBp8SEWMEqLCEVBZkaxvUuJsi/c9j4Yr9k14pTV0KRWmCxGj0z6ZqOYp6kvIgI+SFC+aCrJ0XktTYq0EiIwYPZnJsb21TIr0vrrOEYXEdjadDwQQRW9NSh7V0WSMlzne+WtwrPM1qiowyuBsA1KRG5PiSS9q2k0N+BRjKmXykwud/K1CYTKdVBJRpKxskxOkw7aOGCQxSrRJ3lLrA5nRiXIawUiIWqc84CCQWhGDIjMCVOLkRGKKccNjXWroiyj7gi9Ne5ESG0j8AKGpTEYTPANpsCHFdhGT1cbLsjedJdl/8KTcYudxrqXrHG3bEkKgiQKlLDpaolC9Pj8i8MQvOLQI1iXoVTGkGmYMByWi9/4KpWisA5GaQpvlnDwvKKqkupFKpohgVeG86wdOKVJhsVijFeRZanBeJe0IGclywGhs2ybQbN1h9ITJ3g1ktNCcsXEtTWtxROrFkkJ5Ds/nnMzra36RVAqVaTJt0EpSZMn2kLQZATx4oPORbl2jZUuzWaWzoRGUwwF5lffKVU/Y1rgVMwABAABJREFUrBnpCU1Tc3lxiZQKqQRZlhG8RWqN7Sw6dGw2DdV4jBAy5a1niq71+JBsMsELfKAfZmhCByIjeZCtBZGk4lFIqlLjo8A6S1yt0nqWgqKqGIwyLi4u6NomDdQ6kDiCT5+lsxYpBJ3tUDqidIIBllXZq4dAm4zpbJsYI4uLBb//t7/H/ddfZ7a9hc5MqoX8VcGdBnvOBaztWF/MOXv/Y7LMI4oc60E8uMHsvGBsb7JuNlj/CfOuhdMxerCDzkDImNgGIt3lCYKdagLnr4pSjTQe7xPfIASPDH0dGURSrfZcqQQ0VfTS6aQ4MHmyu9DXWgKUNggfWCw+X8zef1AbN8Tka76KBeuV3Om6qrSvr37ySurcvIpyuvJRp4c7vc8gWb59P/H8jGQ5hN6rFq+jyNLLvSruYkj51tdScJ86snVdv3pNH6CXKy8XC37wgx/wk5/9lOVizmq5JMR0cw4GQ6qqpGtb1usl0QuKoiDLNF964x7jzHB59ALnlgg8eZVTVgOayzloSV4NGE+nrBYLLudz6rrppfmyl9xrylJywTlt8LjoqQZF2hyUYjwsqDvbqwUiziWZv+s3i9hrq6+i2z5bpHI1IQ6R2IM9lFLXk3wh0wbQWXsNPavtkvc/+JDv/UffSf57mY5NVx2jV50o0FIm6bZI9HkpZQ+4C59RLbz6ngXp3wn9zxZjZLNueL5u0h0sknSOq3tKvKK0p+84bY5Xvv/k9bryjb168l+BN6786UD//lID6Ar0dpXZLuWVauSLac01GoWmjR4hMnIhGOiKEDsIMXW3iQgMcXFO2TpEmeGFYGUjRy/WTO6Nkgzewu3tAXuziunIcGuvIu/hEK5zHAwFm+UZz3/8kvPHTzl+9AmHjz/mxbPHnJ4cslhc0tQrgo/kynDr1j3+9u/+Xb75zW9zcGubTFqWp5c43/HxJx8yqCQ//8s/xhO5e/MWUjTsjBRPTs+5OHuKUPDa66+xd/M+2zu3OXr5CKkq7t27y+XlOWY24PD4GZkueP1gh6fPn+DXC+7dPGDTSYTy5FpzuVoymQzwNvLg1h4HO0PYrMF3nM4vUCIRYEOAs6NjDmZ7vPj0CN22+M2CguSnU1KT9Q8cHwVBCsJwxGh7xo0Mbk8GHNYWISJ13ZC5C/amU06ePmI8LmF+yuHyGDlJIKL92ZhyZ8rv/N7v8uLDh4jNU0y5TSkU1c4BB294ukcfUE132JrOOD95TqFh1UhW9YqVl7i25eZWhpAVWmi0srR1w/L8mN3dXZaLDcOqIlbbFIMcKXK29/fplifkwoL1hK7B2gZpLSK2SDFNm4VJHetBlGyqHNc2zC/O0WKH6WQfXVX4rqHTkrMmEDoBokPlAt9Ba3KUUVSzEYGMvMrY/Yd/ky9/7x3+/J9+nx9//9/gfvwM/VIzd5YfhUc484fYk1P+D/+n/+OvvCYigrKaMdu7y08fnvD67TFBSqwvuHFjm+XFMatO8uabY87OTxmXllxDrhNoyTmBkVBWGc+OLilmOWHLYLKEIU7qJ8HegzcohkMgMpjuk2mDDZ5yPMK5hsuTS+TuLVKyhkIqiVSC1WKN1hLjIjEohtUYYbax6zmD6QEhC6xXvyDLRigCwXgcS1yfBVw3jsloiJQZwwKqaofhbBebtwRZ0rgWBFTVlN07+wymt/jo6VPq9ZrlqqUsMroYGKgEmHJRo6o9Np1j4yxOSQod2Bz+gmznPt3zT9m6/TainFGObqKaZyw6y1YB9eUF+XBCaFvqk1OqYoKoL9NEMtDHfKZixruIC5758UuEibRty3LlaMWcB1vbjLdLbFtT1zXF9jRNlYyhGE54/NE5sm2Q1ZQ7BxUvHz3h8EJgdgRtJzibXyBjS1UIhqXAKMj0FYSTxPc4WfLiOGL0GOVtomx7x+z2Aat5zSgXKR9aSaZ3v9Wr3jTF7BYyBKpRwXre4hFMtqcIIq655PylZ7h7G6klJjNsTXI2UTOZDCmqEmPydKDPkxrAZKlBWpYG7zZsTInUEuE0WljyQnA+XxPGppeprkFoFutf3dN6MV8TgUxGNq1FqsQ6kJ1HK4v1Aic1BEHXRjrhESH0dGGHEAoXWoieGCVt6xE6FZAx2vRnVYsSHq07QnQJpKkkbS8nVUqCD7jWo6TppbIZresQMe2dgtSk7jv1CcLpA+BBJ2uVUD0QTaaCUovkrbxKt7lKW1HIa/ovRLrap6gvkZJIEGnPTn5JkcjA/VlOinS/CinSZCoIBCkiqGk7NnXXTzQ1QSgckuA7pIoUZZmm9rKfpLs0/RMmI0SNEgphTALDIgi6QGhNjAGTDwhYXL2m3jT41l4PdEJMqQlt25LnGmN62l4UCJmlRp1QvYpOE4VDSnHdgBCih5z277lzHq0UmZY0bUjfkQdpJJ1XaBLLQGqD9zFZEnv1m3M+gckIdD4Quw5XaEyM5FqTZTmmP5nb2uG7FaPxDEHOplujhCPGNMxQUqKlootpmpzO+Co1vnSKOkvDDEPr1piUWQZfsPAeViXoRFEnGDoLQnoM6Yy5WW8o8zLFDgOhq5Ovure2ZiZDGFgvl6gY0dUAHyLVYECMnouLOZnJkNJj8gFt3SCxqbkUM4RRSJMx2jlA0qHcitVmSdN5GieItiU2HYeLmk9eLtHK9DA6SW4y8sxQZpoiK1IjSUtkpuisRwuQGEQQKC3IdQZZATEgleLy8oLlxRxtMpRKue0pkk6CSkqIKjds6g1FWdK2gWFVEjvPeDJj07Ssm4bMZNi6pRwMWc6XCB8xmURnqlcECHQ2oNusrgnYLvhrDoKzHY31aSBYGHIhsRa6tobgUSqpLqxPGeJds0FmCSK2tbfNerVOTbIQ6JyjrEqCjyyXS4bjMWVRMqiG3L13lzff+RLT0ZiqqhgOhtdn/atzvPcJmNw2Hc47lmdnLF6e4D/6BK0V/iuvs3SOjbfY5RKhI4vtb3DRddhVS/usxaJ6QNur6OTrYR4Rgiczhs1mg5SJ9t9hr1W6iHDt2TY6Tc7T4DLFSCcYX+/bItUPV7XO1XKoqupz3f+ff+J95RX+zD9XL55o4qkojJ8paK6ytUMIr0b+pAeP9yEdPMJVVlxaUFLKa3/Q1XUFXnPO4uIrD7IQktViycOPPyHLkzxlsViwXi1p25bjo2NOTk5wnaXrWnwIZH0O7/nlHG0USgmsc1TVkK2tbV5/4wFb0yl5pjg8Pebp46dE3zIbDbDLY043K0QIaK2IfRbk2fklm/UGMxhRFBVaa3z0aGMQsqXIc/Iip2s6us7iXYrPcSFgQ0C6QJEncuNiXdPaFFHmne8J4ToVkiEVkUIrqrIiEOk6i/P+Oiz+upYMEaHkL02MCSEROa+6gMJB1Hzw4S9YL2omO6O0YMUrL/5VQX3VSEFKdE9STJNvkSIa+i//yj4g+yI4OIcFbAiIKNJhIsZEGRYRRX9v9A2Wz4LiYkyyM6lfNW7kX2m8XEXHGf3qvkxsgPgqCk300SDiVaMgBk8QX2z3yIQmkxktYFICO0oEYrQgDQSJwINw+LNH8LMjit+7Sx1hkCleuzehE5HoI3d2clxr0XXL5dNDLl4cc3b4jOOHH3H85Ckvnj3k/PSQ5eKMtqkJNjENNImuPpWGKpty88E93v72b3Dn9Zvcf/NNRqMMGSzVoGQ4myBj5Pb92yxevmSoz3l8eMr/5w/+KVooVnXN0eE53/93AYIhH1a8+dZXuXP3DrOtMX/4b/8Vf9FtuHNwD9sNGQxuouOSTX1GYeDFi2fMRlMuwpwL6RkNBeGs5uXxc4xSuDbwe7/1O7z//gf89//mT1itLIXOaDdLsjbQnXc8e/6IxeELyrZlGA1DWZD3IYqGXlUgoA0wmO0gByXdPPlFR1VG2NnFNCtuZAGbW5hfEF48QkfH0ek5Mhti3niAUmNis2Jvd49BWfHkRyva7pLbb76FyQbs3rzL/t4Bewe3UQrW+wc8/vTn3L79BoeHR7y8OKZe1gyrMS9OLjm4cQdlhrRtTUCxqQOXh+9TyprJeMxge5vRYIIZjlgd/YLx7i7CdUjbUoxmbBYvkTFl5cZ+YiVjSWgkvlsjKMkwGONSh90rTo4WtPUlw3FBqBV1e0Q2nqCrHKUEpqwImSHTOVqUZC7y+rBisLfN7I27fPhnP+H5B4+pWsHbo9sM/Yy5mX2hNSEAIQ0Hb36b7Id/xuHxnKzSlBl8/OkTwnxBJ4a0WjAuLMNZJFcSowRlGbGdIi88Nq8YlxV37t+nXj5hVBl2t0ZsWs9HD8852BkwHhUIRIrtqtPz1grN8mLFdP8GRgpqGwkYAoYYYDrO6eqawBCpM86PjxFbY25s7ZMXFeXODluDP6YRU46PP6UQmqaJDAYFeVbgPRRZxWhyA4smygGmHDE2FYPBjEHeIOyGvBrSjLZZO8eoKhhWnm6VpgLCJUlpivmSSbkRGhYbze5UI3UgZgVNe0413WO1eE41W1DN7tCe/QxlPcsLSxFqfMypm47Odsgssjw5Y5in/VX6NJ3yLvl1gwPn1jx73rC9t09eZgSjefrsCe2qZXS7ZHH4gq2v7fQTCDB5hree4WTIxaLh9Khm9849Tlafst44ykmCOx7c3kGH50yGScInlQTh8QGaTlBMxkxu7DHMGuoVHB7N2ZpoOjIePzri6+/eQo+GbJaWyd13idEnVdNwGxkCJ0+eYwc7nJ2dc7FoyH7tTW69+Tqr0+eUxYDj+ROk0JSlIvicqizJyxKdZQhpkGWJUAanWtbrmmGhiEIhVUnbdRhlaLqG7SySqzQ9rJsaGSMuaoL71QtvicCFgHe+j59LhzzbRRqfKOqRAFEhaofdBFzwqMyTZcmG5QkEl84dnQuouEZIAyLDhxqTsnoI0RGjwzp37fnUWmO0wYt0mL6K/9xsNkkVGAIdLk3k4mdAqvg0w4sR14Ykg5caF9Ov+6Ymipamawk+IPv0GHnlRlMKJQStl6jc4VubhjBaJ3+xdQT8NTMnuBQ9EKQgK9TVh4d1Hr9JUuPgI9LoBBlD0HVtUuKpjCBTsZrJ5JMPBIrhCFOUzAYjzpYbbLDI6NDZMCXCFAkOrLOCdrNmfX6RYqN6q1j0vZEy9vnhUmN9j5kTAmLKB8Y7bAShJYPBJEnmvbteCzFGbAx0ncfINFByzuOlTNR2CUIJTGZwLvbRd4FIkvkqIj46nA10LiTFABERfKqDYyRTJs1+RVJZaCVROsEL22ZJNdLkMe9J/cn+F3vbWwLEKVSb4G+J2K0xeUExqJDC4OyGKod1Z9P09AtcoihQwqBcpG5qXMjJMp2I9NKSm/TZ1m2XGhQmx+QZkhRDJwSI4KmqCi0VTddifSQ6j9CK8XiUIFl4hAhkSoFPqseoDNIUbG3tE30DYclivqC2oHWBEi0+Ck6WGz44vISQlFjjMiOiyDJNZhS5Tud6rSVlWZLlOZlRtK1FGYNWyW/soqOuV0ilsGtH21m01pSDiuA8IiYLVNv5fmIcAcdkOsR5z9BomtojZYHwIUHQsjRAM5mmXq4oK402BavFmhCvCkmFu1iQ5zqpZQK4zhK9R2c5dRPwQuK8p1k0VE7hrGc0HtB1LmVtd6kGsd4RhabpHEJpwmJDbjTGaMqiROc5xWDE/PKC1WpOVhZIDV/7xte5/+ABVVlQFCWj0YimbRiUVQJHWwsxQeicc1jXsVmtaJZrukWLnk1YXyxYX17QLhvaTx5TlTnLd17j0ikuF3PqzZJiMErUe0laA1JcgwSFTM0jJZICQmlFZjKQMr1mZ/He4qzF9vL5GFJz7jpymaSylVKl9K7P2nmFSAvpSpnzOa7PXXgrpXrvz5W8twdmwbWMGxIx+aoI73XPKfzc++vJ92d9t6+82PGarqdVepOQPMPpNQN1XXN2+pLF4pLzszMuLy44Pjnh8MUh1jrKasT21gxiYLOpOb04p2s72qbG2iQbcz6RFL13SBUxJkm7V6sFUgguz8YMjOD0+TkqLxgaxXA4oKs3rNZLjIh95zdHkIAJQgrK4ZDhdMqgKkiRB6lbWxYF5WhEU9e4riP27ymR1dOEp7Y2qQBcymyM/Wcc6QttITBSMRsWbE9GeBvYPtjl7OyMy4sFdQubvuERriX44npTvSpWQwi0bXsNDhBAlIGjs+d8+tFjvr3/a2jdG4xI34sPPsWJ9SoEKSIxeGLfSEkRUb63cCt0X8zKPrLCk0CFoSdJXlHpY98QUD3k4zqSTvzyjXs1Cb+yKVw1dXz85Tz3vypL/6XmDwJpNMPBEC3A+3T4+mzU3a9yGQl1XGODJxMKpU2SRaMRoiNKlSSeQmLo6P7L/zcq+89o3pqxrjdcnpyxPFuyOj/m05/+iPnzJ1wcPef84gXtckO0DTIGdIRSwL5U3Bc5QhZUpSEXGYVU6QE4GFLPcu5+5xt87Xu/xWg2AOEoM4WqZvhmg/QduDUheKqtIeKRY7sq2KokP/zFM6IMjHLJT37+CcNRyaa2nFzO+fjxx1RVybAaUm9WHB6fYwlszbbxjeTw+DHr82PGlcc1K2pvyMuSTz55xPr0Ew4vT8mlw+QFUgfOm5ZNvcEoweVigbKWuFoy2dplcXbKvhdkMiOPCiVSg+MKDKOJOKlQIjDdukEtIp3vkNmIy3nH4Yvn3DNz/OII3x4zGUTqhaCUBpolF6s14pPAG9/8DYTJWW8u2b6xxfbv/D6HH/yE6tY+y0XDYDZgPPpyAq9ojR0OmExGxAhN0MRyQplptAxkeZkmMNmAnVlBsxhx/Ow5Lx59QNOdQ33C2SF8/eu/yfIwcnn8M/b2fx+lIlopNJIiy1BMEd4kInBWEYIm0BJch8kEN8ZT8ghGllgnWc7PePbkfQZjg2wLfFuj1o5id4w1HetQs5M74hCkzlInvMy4mUkO7v4tfuM/+T2e/vxjPvrhe5z85CEXR4fczqZfaE2k6MXA/r0vMxkYDk9r3nljlxu3JhR2yXg/8PRc98/zDVJE8kz1Td1AdBJjRKL4jwy2PkOrkpPLOTsjR3t2xt1bW0xHOwymAwCyasR4PGYQHJedQWUzdFFQtx7bOrQ2aWKhklrCtZ5NSMXHYGtMyAuOHv6Yrdu/xWBykyIT1F3LzniAMkOU3HBysaG2np3xGLvZsK4EuJaD22+QlSW+bRmNdrGbF5isJARJ2wjq9hIvDC9fXBBxbGmN0pFMQ6YErXO8fPwh3lSMvOGklcy2MnShcAjWG0s+CJx++E8IomJbZSg5oaoatM9oVhds5sdkVU7taqrJGCHOkxpNKgguHVIlqCxn4w17OxmLl+fYmGEXCzbNEl1tUdc1Wzsz8ukeVw3LclRhF3PsKPD0xQV7X9vi2dEpnaq4uVeyNjtM/IaT8zk3t0hFoUzkZR8E1gk652k2NZeLC3bf2cHWAde0bD3Yxp4uCRjKLOPi+JDB1jcZjKf4YJEyorIhWblLtX5GV86o14eM92/w8tljmvkZd97+EtF1tJ1l7+Ye0p4jTUZeFmTVEKWHyS9ajQnaYLKa/b0BqwVsOo8DlFHJR11MiO4S6Vqcq3BohiZDOkvTfgGYVEiBnd6mvZPWgRYYrWhdgpTKfrKiVNrHjFFJFUYgRoUMgihCmlYFENqSidTsjcqmxJPeiygiKXcW0Uuns5RYopPMOIaOrqlx/gotS5r6Q28hU+nXXbiG5caQqOZaaYiOnulNU7tkQURcg5Eg5WYnEJogzxKkTps0ndPasL68ILqut6slw7I2CXrrXMpZJgqkioie/h16UV8EnE/3dFEO0VmRpJ4mQ0uBUanQMFqxPRoQCCzWyeN6efYCqQU6k4gg0XqA8xatc87mz9IZLfYVaT/g0jp5oFVM6TZapHixIEXyhl5N1gIEGdlsLpFKUg1LovXUNk1aBamm8s6hdZp+45IXmx7Wm8jM6Sx1BdERQiC8gxiwwSGjTw0BmQjeyhha11HYjrwqeok/2LZFBkdeDBEomrpN303CmqfiPgQ66xHCgg8p7SWmol8oSeZbXLOmsw4ZWzonwVvyL5KvB9RWoFWCdWmd9QyGVBRpZZAkKbMxiVfRNg2d6yjzKtH1leqVDRprLc51aG3wRtCsFhSZom0FRS4otMH5gHXQBY+ROVvb20g6hFuynl/QdYEsH2JUINJwOl/w8OVlb5MRRKnRSjMsM/b2twDBeuMSP0Il9YSQ0MWIytN6a5sG8ITa9clLDknK1U73g0dnGqGS1VJlAdf1a0JI1ssEYPO+JUaRko1EUm45n2osgSQqwaZ2ZLZJsX9t2xeJEm1yvO8gJAWSznRqYKiMoiyxIWBtIFhH1zaoLKO1FucDwUXQAS1gNJlQr1dsmg1Ei4yatmkZlAZtBFIEbLvG1hvqENne3uc73/oN3nrrLaqqQoikHDbG4G1M0EIX0tnKJu91OsMLlDLM7t3G//bvcPlnPyBYyXoZGH/4lCJEzg6mnHjBarXm8MkTfHDcuFvQUw/6RK2QrNki+biVMmzWm1SzuS5FvwmZ0qaERGqNExJtNLYfal0VGNY6guwtM/RK775O8S6lLkUpr5M8Ps/1+aXmIhGs08PjFdDsKkdbaXU9mY4xRRxcAc9S1nTqtGqV/pzv/30ALWQKr+9lSaKnpF+FoF8VUUVRcOPGDWazCVtbE44OnxJoGI4ypFQcPT1kdfYS59NkfDooKfZ2ODjY48XhEU+evGBdbxL+vq7Js5IiL1CyZbE45syekRnDIBcMjeTl4VO88yw3lq5uMEYS8EijsTEmCEdZonQkivSAGJQlwTpcmyiRCAjuKu7KUjdNutm7Di0kUWtClmGt6/3SgtZaQuh9Rf3XPchzfu+3vseX336DwWSCKiXf/2//gKMIp4s1p3WNjYBQtM7hwqt4sav/vppEXxenIqUg1nbNP/+Df8rOzowHb99H6tSYSPnnqSki+iK7czUxOEIfU9PZ9PDJ8/RZSt3fUjFtWl68sifEQE/tTDnpqamQ3uFVs+avTrWvuudX98Jni+9riT3/44Kd3uN1JQHIs4LtyZjYNmxsZKMt2M+H/v/3XVoo2thgpCHHUKoh0ii0ExAtkDxsSkR8EBTHn9L+F/83VgPN+/Upn54+Zd6sCHGDbyyF1DxQkq/IAZNiSjXQZMJQCE0uZR+vpfAiHYhiDHipUNNt1LtvoL96n1gaqt0dBltjTg4/4vj9l7z51a9RjAdID5cnJyxOzqGsGGzv8/DRn1NUA2rrWLUdhdG0tiO3kjs3ttidjtieDTg+OuNoY/n6N79FJPL48RM+fO8X7O/NKFXgZx9+xN39KfvTT7l0h2xsRVXC2eEn/Oz9T3lxdMEoy/n4vQ84fvIU03/P06yg6gRlExAXK4p1RyYERujUtYw9WPFauVAwM1scKMP09le5tTtjXJYMCknnXlLtTVg//AFhdUhbr1nlCtSKcrzLdmkZ6BmUKQt1NB2TacVisWI4LLj95gN0WTEZOEJwyFFFmVUs5is2tEgzpMpHTHe3eH54QVVo1vMFwypnefGQYjDl9PljTs+OiO2c3YO3+NFf/GuePjplMsn46peXRCuZbr+DLvcI6xVmS0OTni0qFkQcKqsQukT7iAgdoQvU5ye4sMLHHVrbsFlFzi/XtGuDvWhYPHpOzAPRRO7EPSZmH7de4e0xk21PNYYsy8g1mD5CZZxpvvo7X+PeN9/i4sUZP/r//jl/+o//W/7hF1gTV8Kr/VtfZjaq+PDZGikU00lBd1nzfOW5e2eHnzy6wPX7m1LpewZFFAItJbiWo/OIaB7DYMZqVSPMjPGt+zx9/JxSWKrxCCEEmcmZ7d7h6bOPwGc0neDOjTfIWaL8JkEXTUauNUUuWXvFYCBoGolUQ5wu2bn7JnkxJBts0bSBYnyAUxn14pzOG04vG0xW0drIeFyhTEnXbqiGU5TWZBGyakgQY4TcIKXGyJZYFmyawGSrZDFfpyag1OhEaMJKhZ7s4uYX5CgWL+csVgO6TcNHj1YIW1MNnvHud/8Wt978dRYfPmOzfExnL6h0IEzuo/IliALXRZrVhlHeEmPKj00FUiqMvLNMR2OOzxzTXJK7jJ3dCU+fBvZ3dxlUAms9+XAbSOqk0d5dygxMXlDiUFKzvz1G+FN0rgnNJh3a25T/HJzE5Knw1gp072ctB2Pu7D+gKh1yy/Jg5wab+Sm52zAcFmzvT9ipYD34Gkprmk2DVAGdl2STfW7N4OPnC/Zu3uTx8wV7r32D1bOPEpV6NOHG3RWb1Zw8gyLPycoKXY0QcpA8teUYoQasL5/x6PExmR5yuahTVFyQPfjLsbxsGBYpm/divSKXOu19rvmV14TzoZcY91JskRrQ10c5JZIiiBT/E3q+iicSvUh7cezTV1xE6kTSbaVAq75Yoi/sxJXHMTUtpUgteKEMRlUE1+J8mt7HmMBpMsY+6jXty6E/hymle6sX/arurW0+3SfOuvQeJKggCMgkC9eiT1JJKqXWNWido7QBqbFdh4uemPJRU9KKurK3pRixKOT18CHKNHUyRUawLinLZJLlZuUIkxepQa80opcm53mJEIrn54t01sgMTb1BFSWT6T5ZVlHXK6ytaZo16/lzumaJjClXubVpaqbzvE+CgemsZGM7XOeIUhF9QJo+QSf2udxa93nTCUqbD0poNG3X9p+vwBjVe8bTebqzCaRoexCt7i2WMaQzoQyOztoU66YEmdHoMrFqQvBkugf+tjWrGCiyCCo1q5EGFQ1BiEQCj4HgHT5EXHCpSSNCH+1qUVqipSAIgZES5yxdd44PiSSudIYxJjWQvsC1mF8wHo6wNiXVZFmGMSnGNkSPMgqhs171GJAaCIKmbXC2o+aq/uiRtVIgpSU4hxBpeFQUOTFEWucxWmNKSRYNs719EB7ZrahXK7yDrBgQfEPTbHhxcsH7T06xTqGVIMsMeWYoBhVRatZry2hUUVZ53zBK8EZnfcqz1iBwZJnEda5PVVDU9RpvQefJ6iGFIBCSskZJvPUpc9qk5pPQV+dindg1AaIKeC/wLilF15uGPMsIATZ1TdazNHzwIDwqK/BtR113WOdRJkNnObvjKT46RNegZCRWFaorCQG0UWyPRuQm5+L0kPF0h1W9geCoisR/GowmvHh+SL1peOerX6VuO9p6RVmVCBT/m//9/479vRtkRic1shBUw9QoL/Mc4dNQTyhF8GndG5MhhKLpn1k3vv1V8q0RL9//kI1b00wGvFyvOc3TGTXqwM1796nrNVpnOOto6wbbteB9Ut+EFHcoosS71NRqrcNkOdVgwLAY45xltVxiO4cLLqV5mARgVFISer+8kBCJBBdSVGKf6nTl84a/4rb+n7g+/8T7yqvLK1+3iMmHI/rchCt/bhqGX+Hce/obqXhyvoda9R7lGEI/JSFNREPA+75u4mqKe10/IWRGXhgGgzF37tzna19fcXpyxOGLQ6osZ7WYY3TOxeU5m/WK9eKMT9cLbt68yeQrI+rWsm5a5peXSQbdWaqy4NbNXYRQVIWma9YsNg4RLMJ3SBXI80ime52/Sg+9LMtp6xYXJLrIyPMMpQSr1QrbdUiRGg2+7bBNm+IMWk/XtjjnruUKxpi+weBwNl7LtAAyqdBasjOe8rUvf5mvfuPr7N68RRCO5vFzHpUFDz9+hCbgpEEVOSerFRer9S/1Xj4rjQg9jSxGev+1472HP+P/+l/8X/h7f+/v89t/67dRuUpE0l5W7l3Hpl5Sry+x9QpnO5SAl6fnNCLjzu3X2N3aTVNspZKEKphXOZdCEmUP3et/pquJ+dX/VioB+ICe6OpRKj1UrzZlrdX1z+2u9JBw3dhJ953nCnYiRe8Hjx4lA7JQLLu+S/85F8m/7xqpkgvfMJQGiEy0QTkPMWKDSYAakR6YQaZYFuc7xuuGd2Pky9keQe0gREBPksdGS42SESMMiK5vPqQoDRdrRBQ0wbH2jkYEzqaawe9+ib13v8rs4CbFoKQ0miwTZGKfP/3g53zw3o958MbrzLZ22bn9JqvFn7E4PaSuW2qnUTqjqjIuVjXrTY3WmuPTBW0XeXo05+0vf5mvvPkO1Tjn5PyUi/M5W3t7jMc3+cUHP2VxdsqDWzNWl0uen5xwsLXPs7XkdFHz6MOnNGvLrdkQVzc8//innB+tuLm1y3hY8fGPP2CEYSAUm4sLMhHRif2OjBIlDEM9pdQ5B6M9hkXFON9l0W6Iu7dwoePh08fs3dzlk0enVOtjMrfEhTW1b3BuRle3zOM5k8kEIyznF5dcPH9EFJLZ1i55jFy+eMz2eMpABspxAVFwOV+T5YHhsMI2LSjPaGtKc3LEvRu7rDYbyv0dBoOKW3duQlNjtGFQbLNWGcdnRzxfdCznHV8ZlWADQqxRmaS9eITKDd6uUMUuLSCURpkKmQ2SWsI78J62lWzWFwzLCqG3sE6zuax5+uMntM/nuGWNCIZVqLEmcPLxBdNbnzK+vc3B/bcJXaCtG7JBxXhYkSuFEkmCPZ+vUarhwVdfJx/e5v/3L/7NF1oTgvSsqUY77N+6y97LDTu72zx79pTnzxve/bX7rBYrSpV4HgENMXkYvfNpYqoA79i7c4vcnqCHE7qTFavFCmsEhsBo6x55WfVe5JzRwVus3/8Ro1mF94KuWWGkxamMiMYFgw8RrcAIRZaXjFROXuXMLy+BlnK0w2i8w+nRGUNxTF6MaP2aunMp1tAGsrygI+fk8WPu37rDYLxNJKKMxgxGLC8OWZ6cUJUVPttC2YamXrESnvW6Y2dWJKsUEesjjfW06yUu5tSrOe1ywSB0hBb2xmPOT3J+52/+I+698xW2Dx7wwcN/xeXqPYpCIasZ68tD8qxAm4LBKOd8maR1gt76k44KvSLJoIIkN1CMJjx6/gm7+zuczY+Y5C+ZZROcvIEqyt76JSjGM8YDTTSR8VjjvCPaDfViw8X5GcObr6OHksFogNZz8gKyTKJ1yhBWJrCpA+eLDU/e+5jJr+2wms+Zu8DNvQyzewP5yTmb02e0z47Y/l/8Ouks0SHJiMqgywm4Y5rGIUcCnZXU8+cou2T17JLq9tfwwjCaTRiwwJZD9GBAHM6Q0YAMxGxGjDuowVNu3/8q67NTjGpo6g3zzYa9rR0IYIbjlKdsW2ob0dKT+SZl3v6KlzT9/ufS92D6CCrvfKJey4AUST4shMAgeqVZpIseD0kOLSPxCioqIkqkKanrE2Gsi72UXSCFRyudJsEqQ0uNKQf4UOA7QyRiY0vsPFEKhDRpsheSJz8Gh1QSofrCR0REiLSbtp8ICapqgG06fPQgBVpcEYT7WDBHKnAItF2dng9NgxSgVAZoiOl9htgX+CKCSnLRqNN+PxqW1E2L1BlRKVprEVIzGG2h84JMGVAZWZ4nxZ+zKJ0lyJqGYZ6jtWZnehOjweQjZuOSk6NDfvGLJwTfQPRkeZ6eXWVBJWWCcJHUnsPhiOV6hZE5RZWxqevE6ykMy7qBKNGqX3tCIYxOSkYcXdv1haFEy7TH60ynSMFgUSJFZA1yQ+eTTcDZXr0geyumjiiSBDzTKbpI6xwfHVpJyrzAek+mDK3viG1Nlhe0dSqs8qJEhESRDyFR4I2WdI3HtmkSnuUKI2VqZmlNZ11PPVc0Tds3GEDq1Dz8Ipfuh2vWd+m1Wov3SZ0UYkfTJWZKnqvUmJACbztCkGTGgBa0m5p6tYQYyfMMk+fE6LGNRUXNoCoAUKpACYkLntFkjygDcXmG7zYEMcDjUXTkRvD48TnvPztLYEGTfsY8S0lAEpmUCjJj3XqkjMi+/+CtQ2UZMUjspkP33niEog2OtuvoGoeUKnGffBo6ee+QpNQo6wIbW/dwYE0MPsXVRZkUDNZRlBUIgbMbVquGGEUPOku54C52bOpkqy2GYyZbu1yeSWx9iVaRTGuCFKw3m9QAcx3j6QSdZezu7bO1d4Nms+b89JT5Yk7rIo2zuC6lI6ybhiKTrJZLBLB/9w7SGNanx0x3dtnPK/7eP/hPuX3nLs5biuGA6ANFWSTraUiqGdef+0Uv/ZYoooi41RrVAwfbrkFuDdl696tcfvwxDTA/O8M1DUoGCi0JpaKscjrrWK/WqfayjuBDYrlkOTJAZ9dopfv1J6F1uFiz3JyyWCwIOBJvMFIWRW+b9SmHvesoByXOOori6hmrkuc/pvriykYt+HxFxedfPTH2+co9xTr2OvrPFHSql38keVR6CF0VWkK8gm7FeCVFlp/Zzl7lLAuROnj9rPWaeB55JWV3PuWE5mbMvfsTbt95jeWXL3n86UeslnO+lL/J4YtDfvH+L+ja9HA5u7jAWsdwMuXb3/oGttlwePSS+eWCybDg9OQE4SIqlHT1Gi08eZGaBmhJ9B6HwLk0je6amnXj2Ll5j6ww7GxN0ToVqVoJMi1pG8/p+WVfqGsIPsVflSVd1yb6Zd9t/qzy+Qpgp7OMItMMy4r1fI3wgItsbW3za3/tN8iUZHU2xzsJVYmcDFg9sVyuNz1cJ15PkH/564zXN0sEutBwsjriv/5v/itOlqd897e/y8H+DaqqhBjobMtms2K1uqCt1ylP21lW9YKYjYkhsq5rfIwYnWRmnbFpkiCvAArJx3Hly75aiKEHoUltMFqnhktPItciSdZDn0WdCnVxfT++ilX7jOci/Uqi60p1HWNycj5HEOlsD5D5nLKQf99V6Jy626CEJJOKoS7JZIHAYZUEbXFREaJGyASxQEis1On9CQlkCNlAyEhOH5t6UjGRiBE+bd4xItG00dJqsHtD6nv32Ewk3TDj8Kd/yfDhB7zzzpe4decBje0QUXH37Xf4+Gc/xP/sgje/+VtsbY8Yz0Y8/vhnzGY3+dav/yb/+vv/gqosCeEcInRtdw0R2ZrOsN2axeqUTz895ecff4JAM93aYXtrm29/8zucvHzIT/78L/j2O2/y+p17LFqom4bt3X3+xu//r6iE5b/6x/9PBtJy/iKws32Tj54+5/nhKaMgGUtN7gM6RiqRUWQ5pRiwW2wzLUbslltIDCYDo4fIWOAw+NkMh2YwmVFMR9z5zjssf/gCXMvlqmV/Z4AlkGdlio3Z1LQRVvMNpgyUuuQSz3Awoaxy2ounFI2mUwZTTJjmGdJJtAVNkrTrLFJVQzwGF2pc5xgOcrxtOH/5KdLDoCpYnSzo6lOCSxKmajAk2BohA9YFZDEjGzuk0ImyKXWCCWU5QvUyYSMJUWFEZGe8x/OPD3n2Fy/YTALLZ0sGnzbsM8SUYzIqatfg8Swedyw+eczL/CM+vfkBwzsTvv5b32XvzddQnaMxisEwR+QGKyTjrRnZbEx13nLr7be/0Jq4urQu2LnzZcIPfsTHj04Z5pKzdUuVaz6dW0ZVzkwLsjzH+UuIAecFnZVICTK0SD1kPvfc3a/YNB1FWRCdYGEFr+98CWVeUbSH+w9QKBbnF4RsF+Vb2ugZjXb6zzbHugRMMVWGVJqTwxNubt1jezIkI2c4mVKNZty+e5d893WWixVbOwcsTx8jgHJYkemc2DnKokSKjJ2btxAiKXOmwwl1kRGLLGW5DwXzhWToIvmlxaoEkVMqSdycTfDR/Z1dLuYrtrZ22KwvGOnIvJO8faDYbN/gm3/976DzAhAMdl5jz35KbE9ouoa9nV1efPI+rdEUgwnDYYUUC4RMe2wMAGmqGGzL0Ue/INu9w+JySV0nSm60gRt7I0bDjHrwVmp+9uPYbLKNUY7zOhXSPgiUraGD0dY263rBQkVGw5wsUyiTMoQTNVtQREFVBHLpCdqxvb/DfLFC2JaLk5owLNnZHTHYNtgLwfjWm8lWIl/567Lpa8ST9wh2Tcz3UbxEC0UxUMjZTYLKCG0NsaUYZWTDIV3naA5fsH37bYSOIG+DvYHJfkqnl2gsq7pms3F0eLQItMEjhCHLNEeXC4wxyZe7WFCOzK+8Fsoip2s7XOAVdFMlW0aKL43YXv0VPIkYHhNg7GranOK/RAKG9bYyERM7JURovSdLAzgcgSgNUahEF5YC7yOy96mH2GF0ic4km7BJe7EIKDI8qWiWMsnNJVe2v4C1KVXF6AxpVGpmmwQ+y1Wir4fgE8emiXjl+6muTMWNSorB3FTorCB6T9essMLj6sSpkVqhMkWIIilhEGn6R5LMt7El0znVeILJq/T3FxWZKfpmYjoTEx3RK6TIaS2UwxFlnrFsLcv5JcdP3+divkbgeeP+Pi9ermg7S2ZMP92SUI2x7aYvpj1CajItkEowoEzkb9uhtKTKc6TJEjVeJfJx3XVkEooiS5M4ZzEyJeYYrXEiop3qwVoQhU+FUYx4F7CdIxpFpjWZ0FgZ8SFB23SmGQ+GRJk8ulLp6+QPvMKJlEueaUFVlbSdx/s2qVBDYty0zhMsKJXy3q8UqbkS7Axzll3Gukm0+kxHJqMRWZEjMXT2i+V4Kylx3jEoqxRz5n36NefI8xzvAsG32C4Vv6DJByVBG7plg69bpJAMxmOid32UngAbkHmSrccgyfIU8eU8jIYDRPRktqbzDcs2IoqI0iCi5enhBb94co7zkcJI8sygtURJyLSizDV5niOVpm0tmYbBaICpcqKLdM4ivMPbDuslFo9Ugq5JqQNKKtrW9/WBJivKHuzlwZgEX9YFQgqq0rBcrmitx/RNJF3kzC+TgiwNME2C+QWHVCI1cEJEmwJFwFnL0eEhKgSK3EDnEcGhUQzHIwbDEVIIbNey2awTtC8EnOt4eXjIejlnZ2+ftmmY7exSr9Z07hhtdJKhx0hVDjF5xWi8jYjwvd/6TV7/0ls4axlUFZnSqEyhM3PNf7qKJBb9PRdkQAqJtR1GJ9K5B7TWCTqoNVFIzudL2s4mxcN6ickyrAvE2McWh5BUun0cYVIJBaLSycKQ52htyLShbhvqrk6gaQWj0TaXZ6eYLE3OnXNIp/Ax4rsWH0aYLA3YRExshauB8ZVCSMTPX1H8B8SJpfF/kkuJlJNMvPYSWGvprCOG2JMH++6YlKlgfzWcpG+KXk9HQnxFLJdXGxBX0/WIFDF1ea66JP20PMRE/A4hfUk7OzfZ3d3n8vyYTx9+ws07t7h9/x4vnrzg5OSE1x7cp7OOo5cvefLxx9w9OGB3MuGNe3f4+KMPaHLN7tYI/AYjHVlmkCIigyD4QBOSTzlFbCTw12Rrm7I0ZJlhPB7QbDbJA5Np8syw9Au0iCkzMqQHIUrTtB1E338QKsnBhEDGHgSmUhPChUBbt0wfbDGcjtmsFrTrMXE04tYbb7OYz/npn/4lo+GAam+XJhMQYk/3DkkSzquJ9y9Ls3sSeYxAAcKz2Fzwh9//Pjs7ewwHE5TOyExaIFlWMBrvMxikDrWzNaJcoU3BcDjCZDkB6LzvwUHpFovxlT0hxtQ8ETJiXYKPhF567py9zp+Vgj4/9FWB7X0CktArO66K9tRECIkOfgVhS0/3z8TRqWt5H1wV6V9s5J0Jw9pbmuBSFIoseuphQYYkotEEQhQEoZHSAQ6NJKgAIuHCQlDEvpkVyfsolIinIcYcRCCLDUJa2nzI6NfeYfrdN1D39xBVhSkUznX88ff/JX/0x/+Or5xd8tqbr2OqEXfuvE69OuXpL37OwcUFTWiReotq7xaffPoRe9MDbt3ewvw8UhUl8+UqqRQCnJyesWlrquWQi8sVL4+PKPIxX/n6l3nnS28zHU/w0aIi1I3jbGk5Pr1kZzzh3qTg6cuX3Nw+QI738K1AGcmffnLMUf2U0Dq2hWJH5VRSMzQV23rEvcENRvmAnWKGj5Yq0+hYYYwmowShetlcjhxX6Fyw+/Y2j3Y0j56cMLNrFs+f8fRsjSnGZDrgB2M2VrHuLlFZjpWOF4enkD1k5momb75NiJLQtFxePEIXGVZrpBliRcFgOGb98hlqsk+zqTk9fIY2ivXZOVmhaC48jz74MZvzj2lqQ9ddMp93nJ+esr8/QZ5EhuMJxEg5HOPbS4wSmJCDSzyI3ORJytk7bqLr8A2sl3Mun7zk/L0nbD66RLYLkJcU0nBHbaNVhlKJVDxyGSFGtnMJsaMOjosXLcdPn/EXj+Zsf+kuOw9uc/Du2+zuHaDyDQPR0a0UK7/g6bMzvvTN219oTVxfAm698S63dv4bXl4uyHYH7OyNePThQ9qlY/fODi8+ecn9uztkebITKJlsSJkRiHpDNbjDwdByNl+xVRlGZc5qDrdu7rJ/7x5XS1gg2dp7PfE2hGI4mmCmdyjiCmsDw+kMuxpgK8lokBqmW8NIFBm1NVwszhm7OaYcYXTOePcm62aO1BW+6ZjduMWmeUzjklzN5AqlMgZ5zmzvRq/ngtH2LpdHBWY2w7qO+vyQRbdhVM7IpwWOgs5LgoA8SrSG4AVPP3gfXVYsR2NC1NTBENoFovHcu/862uRpwhQj+eyA9qMlMjNs1pcou+DydEm1PUTkHh0jsY9lSkEeqej2gAuCgzfvcb401I199RyVOVRTTp5+yN7v/yOuvL4AwpSUxYis3SR7lc5QVUU2WSFji4gaGS1t2yKKmBRbIaJ0gKCSPFpE1l2guvMaLz7+kM2lZxMM1djgXaDIHKF1rKp3GEx3+mJTJSuUkOQ33qV98V8ToyIvSqqypJOSZj5nazilGiqaaJlWBUJ35MMR1kuy7bupeM1vQbwHcob1OZvVKhVowVPlmtA5NpuaF2cLXrt1m9XqgsvlnK3xhMvFOZkSlIPdX30pXB0ISXFDXQ9UIojesiVApZgvYmqW2BB7L3fyf6f/m4omoyXOgSVgkGnYIcH7Dq0zpIw91T6Azml9IC8KfPQ9Y0cTRYc0mjxkfW52z9yRAokhBkuIgc6newopUl60lAlKq1NRH7xL5HGZ8nyjS+fDIJKiAy/IckVhckyWkWeDZDeLgRB7eXiAfDBJxaPWQOzPXumMpY0h621xSI0LPX1dO2bFALCEusFJgY8pWcaojOBbtAhs7eyC1NRdi21qVvMTusW8b3AHHj87Rak01awGWeKK5AVN06JFBhK61jIYVFjfJTWmSvTvKiuxIeJCRFnLIM8gM1Rasb29y2K+pm4bTJ5CthOrJg1atJAEKcm0JASLMRlt5zCp0sMKj1YSRMCJgJaCcTnAaM10NODG/j6PDk8QQiFjYGAyvA9sXENpJEWRzhJN00LwiBgwCKxIn3+ibKdnRJ7pFF/rHLVztG1HVWYUecZ81THKc4ZZhtCSdd3SdL86bBDSedAog5Lg+4mq9Q6tMlCRrrUopWk2NVpootjQIEGkYVRVlQgRqdcpBjBEh28Fw7IALSAGvBDockCIgszItObckuAaNq0naEVYz8lzzfHlhp998hIhJZXpfdtSgjAMRwOU1milKKuKwaBC6ixxLHobSFCattkQncd2nuGgQCnBet0QQsQYhXUB65L+18VIaFucdygpqRtH2zqMVljrWC7mPdtI4pFp8ChSIelCT/zPdC/5z9KAUkqss7iuTfYVYxhNxunjiJ6ToxcIETBasN6sGI0nCSCoIvkgZ2trK2W4b1refOttPn34UVJ2CMFGLTg7OcEUOVlW0Lmagzt3Gc1mnLx4RlEVfPNb3+Wr33g3ZZ0rRVVV13bZ6EP//fax0lyJntMmniwsydgqlcB2qRbwIZ3r667Bdl36XomMplvYLsWjtV2TfNZRAK+SjbRKSqOiLK814NF7Wp+AccE7gvfICPPLC4RMPIe6aQlECp2GwD6AVlmyMCASf0RleOuwtiEvyldpTuHzKaP+g/QiMlVD/TT2akO4kpQn37b3qey/noL3Xp/Qy8xf0aglr2ofcU3OjogkNRevPFBJvpzkFmnCKa79wEnqnmIGmsYhJcy2b7G1fYPDF5/ywfu/YDYbcevmTR49ekTbNNzc36etax5++jHBBww38esV00FJJiNGG0ShMTpl/jkf0NowLAo2mxohFJ33jCYTssEI5yzDQZWooH2+nXVp2htj8nPbkJoHg7LErpJfwihJZhQ+CkRUKX8zT8COGCJCRLouvX4IgvHWDjIr2GzWXJyds7W3x3B7j8ZFTFlRTSdcHB9hW9tLqRP58692YX6JyNf/vve+fzhYLudn/Jv/4V8xm2wz+uYEKwLGZEwmW0D67r13WNuxteMBidYGKVUiifeve/WADZ+5GWNMXWl6ENrVz9APN7DOJYJ73ySw3tP1U/JEK0+Cjs8C/dLfyy+xBF7R92VP2O1f46r5QwK0fZFLElmFli54zro5d0KLlhopPdHnBGwi2gpFiKv+e9ZEPLKPbInCY4TAR4+ggZi8I1H094TokhBKCFY+srk9JP/mffa+dIdsmJNnhkxBJzN+92/9XT752Y9Zn66Yt46dYUQaxf7t13n0859zfvqCibxJu2wZlfuU1TG/eHbEZOcur7/xNqv2F3TOsl4n0mwXA7LpcG4DSO7ffYPpzhijHI+fPCTeuU3brvmD/+5fcufObX7/r32X3emUxeVLXt+NSD3gh3/65+zdvMvv/43/nH/xP/y/OF7VSOc5kDn7Mud2Pua1Yp8b5RbTbMysKFBkZEoh1CDF0pChlUCLjEAGwSDECjUwPNeBvzRr3n0EF3/yHsc//UNiqAlVxqOTlnfuDIlqzGa9RphAFqHuNMMbdwl6xGC6g5YJfjRvPd35MUbAaj2nGAxp24ayKuk6RX1xxOnJS46ffESWVQjv6GLNz18+p2tbqjLnj//iMS/OLiik5p17M7711pc4v7HkrdszymFFKRSMdigGY7RqEbFOkz0pEcH0B29JcJaudSwO55z99CPsR0fcaAcMdUkhdCLYSg8yIoVBIhJcJgZM1IAhw1KpnJ0wYXlqOTl8zNM/+oD24oLsN38XMR0RZct01CKbjtkWfOVbX2zifd3ci3Dj/jcYVyWPT2uQBSsXyLb3GKoWgmHnxj4q69cyEZmBEArrNKr2iGLGw7/4t0xv38UFwdnpOefnjkE5ZvvGfr+Qk6pnPLvF9mxKoeHFckmWj1HNguFkhlEGofJUNKhANZhwdDHHNZZqMGPdLpHcoBiMQSqybMh8tWI826bZ1CxWLScv5xQTlQ7G1YSCQFXOKCbT9GwhMtnd50kM6KxEKUlhAkNKThZzdk3aC4IXBHX1HJP4EJkdTBGUCJFRtxY9v8AUY1wITG+8noqT9OEy2L5NjEmKNxtXmKpgq3FoUyCNop63qGEPulRXoEl624aHckx72aDdhkFV4q1l3SbJsxzPGO1/6dWUNUaEUIxuPKA5eYxXkhePDvnON+/x8miOygfcmE2puhMSeqtPGzEK70gHzc7TtqDzCq1g5+4Dlt0zdvOcaWH4+NmKnb1dpru7dLt/EyWTty4G16uSBGr2FlKPuH13QLfaYLMRanib4c2WbLpNFwI7t15Ht8+QekA2nIIqEcIg9ASh3gVxQCSg8jGTG3c5/fBnTGcVthbUred0sWR3UmKkxRpDVQYWdYtyLeVozIvz1a+8Jq52P9lb81ACPEliLdIUWyuRIomkwHmBa9wrv51KU7fkOUz7Wp5rfPB428d+IVGmwNm2PzfJxEsQEDON7tNKiFcZxzm+6whGE/poK60NnY8oVUBQICShqwm+BZ+GBqoH3yaej0foxOKIoo8kExKvJEpFsIFAYGtUIoREZwUoRecEru0AQTmaMjIFmUmHV5QmRN/v02moYpQgCmg7T728oCgMs509nNdsmjmjQlOUM+ouEH1LppMlInQt49Ek+TqbFZvlOTpaCh0JeWLyZLlOU90IuZbkQiE0GCOxncDolA2utcK5hsIoNnWLkGlSLSJkStITXehCgNZiW4/SDVmm6DrJZDpFZwqpcqxrcV1MqT7eYa/iXTvITLISVEWenjVaMRiPEAI2tSVGS4iwqTs+/PQJIkqCUMToadsmTT6VxNlA3RfczkessylDPELb2WsrytUh21mHUklNIYNHZhWrjcWY1NRZ1w2eSJaXgEbpLyY1VybiQ4fzULcddtNSDgbklaDedFRVDoAPBqEN3cYTQksmFULppIcNDi/AukhsPVIKWmeJIcXTSaHoWsdwPEIKj63n2IsTnI/IbIBvNxgtODo+4aefHNM5PnMPBqRQyb4gVIozLSuiVHQ+kGmPtTFJ0EUkNJ5CaVDp/FfbgLD+er20bYOzyb7ROY9wXGepayWRGqRK7JUoFG6TpvWdTzC+zGikjMRUHKXi1KdzZILQqcSlkYAyuOjBBy4vLtidTdks50iVUTceG1oGKkdoTZmXnB4fMRgOabqO2dYO52enCK25cfsuTz95yKpe09QNRgZct2HtWlQUSK359KOPaNcbvvmd7/Cd736XPMsJMVJVVRqgaUGwnqbegBAYXSZ2hHOpmdAP3ZL9JNnNbNelgltJtElQtPl8Tt3UdLbFmAzvQKoMpEcHQ9c46JXUEvUK/h3T8LHIi8SlCGmQ220aTGHQ2uBch0JiTE5nLYLeuy0lqh/yKp1gh94HTJ7jZUqXynSVZP6Q9qvPmZT0uVdP6L3YKVvbI0Pv7RafyeW+jp7qi2WZ/rmSAyafbsT51H1T4pUMORXfoi+GXsViCcF1fJXqp+dSqV5y3u/NV0Ueqcu/2Vi0Fty89QZb2/s8/PgDPnz/F5gMppMh55dzfPTcvHWTZr3G2ZZqkOO6ls16RZ5piiLHugQg9R6iEuh+ehBC6iZJZfA+xZ4IIVgs10SXKJfeOoJ3PeUzbbqjcoCSgtzolKcXk4RFKoVz6YFZ1w0O+mZG2py9jzx7+ozT58fsTKdIIWmamvPjY4JUdNUQV3dY5zh8ecrlpu47ReradXCdrf0Zn/dnJeiJCJ6m9EIozhYv+Wf/5J+ws7/D7fs3KIsCIdIkJcSAVJrM5Mmn2RfXPoT+cKtAXJE508FD9q8tpST0E3HJK9jb1WHv6u/57M91zRboC2lIERhKvGoi/I9j7tIdkZpQEdlTCUP4bFzZFyu89ydv8a4ZMWsuqPJdfJSsOtcXEk16HzEgRCRS4GkI3icqfC+FjyJtgFKkiBIfI1IEfHAEAXW0NEhO/JzTgzHFNx4wzC3q8pwZFWJYIKskGYreMZpOyEJOXiXQ23qxAAI3797l8uIySS8nDeuLBucjt2/c5ObNu9zdHVPksPzDxB+IpJzD4AP5qORgfw/vG95/7wXvvP0V9m5MOTk55M/+/C+5uFwQecqPP/wZv/7lrzIZDWg3K7r6lNNnH9JePOfics7J8ZwHDNkrB9wyIx5Uu4xVyUG5jVGBKitQoiTvacyyh6oZFZFCo8iQIRB1hwgWbxR6p6A9PGNxGHjx5BDdtUx37lOpivX8BFGNkMNtBnqLvFS4Yp8DE7nzzrc5fvESbybMNy2jTOG8Jqv2WZ4/5PmLEyRHdG6F9QppCuYbiy5GxOg5v5hjCsnHjy/Y1I7X7m9xdKJBj1C6I8/gzv2vQFHx1mSPnS3QsUFkgZ2916Hb9LIqhfcWE0uQJt3rHgjgNi3rw0vs4QsKCwUKQU8kQ6FF1m8MMeXeCkUmFUHlECMmCnIjyIDK5Ix1Th1a5v/sE37woyPe/s//Jm5QIG5O0ftjIo7Vx+dfaE1cXwKq4R7TG3eZ/+wvcV3g1vYWjb1gsjXm5eWSUQQXVPrDvTQ6zxRV4VCqIy9HGCWJIlmSghJUOwcwXzIaj5NvWUCMknw0Q2VDnj1/gh9UdOuXLNc1N0e7dC4pUmxIflXbdIy29tnPFUVVUWwKBtP7FOM0dRvN9jk9OcIHwfbuLR4++oCt/W2iLJAmTdx27z2gHM1SMdEX/6PpNkoWVOMZmTG0akHmDFn9KXmm0QNJVYHJDHmuUEGgFNg4ZHHpKOs1w0GFcB3VYEbszii2H/zSx1pM9yjKLZw/JcjIaDzj8nRBs6nZHk0IWWreSJUa0oQ+QpFIiJKzo0uKYsDlZcS1nqYT3NiStG1LlDNGWzev96zEVxFM7rzLw09+TNd2eKmZHx8zX1qktXi1pD45oZrBOE9TUR/TQ79tHdYKWhtZrTucWBEf7FE3kVwF5ss1dB039l7n6P2P2P+P/8+9TjhA3BAZgjCoagsRBVmpmV/UDOya5vwZo0GGazbIwQjNgmg71PY2eryLyWeo0evI4W8B/3/W/uvXsjRN78R+n1t2u+PDp6/MLJPVXdVV7R2b0zTDHlGiMBBkrgXoRqP/QPoHdCUIEiBgLjQ3I2FmSA5AihpS9GR7U10mK31kuBMRx2233Od08a19IpLdnKmp5AISBxF5Tpy9115rfd/7vs/ze1LhhwwcHN+g28Kz9/+U48M5whwT7z/kdLUEKXl8+oTJ4ohny4KpXiMDoAyV/uknfC5EdGaQIsWn7kJCUpEkqHKdJNUiYpREq0gfAj4AIo6bUoVzDu8hxETuDp7Ri7+Dn0qsHdcfEcikwnlLFgwiOLwQCB9RSjCblCxXkegtppDYmABzpVYYrdn0CRueBYUbN5RypNVLnexkXkAMMSU6KAMi4JGoMBb8MdGZV01LnmcUWcYkU8zqgqtVxAWo6klqGmQm8WTQRJLdzLsBJxzgyVRGVhq6qhr3thItHJNM0fuIZqSPo1gUGYOzhCyp+Pz2nMuzpygZkbkh9B4tFLM6wwVHZhRRKrxzoHWyOIaI1JrgQ5LKAkIWBOuYzUqkGItkrdluthxXGct2SGwfKZmXmsO9CVFlFOWafnDJC+o9BJEKcinAQVUaltvUjHPekRUZMQpyrTBC8LV33+FP/ux7aAWD1SBSFnyeV7TrS2J0DC5FaUkjmU7yFL0WxSgdB6k13naYLKNUJblWOOvobIeK4GIiZRuh0CbDGEmCmibbRxj3F7bvkcLiv6RNLzcFV6sVvo8jUE4Sg+PyoqEocjar1AzKc00IA0KkWDwpFcPQM/QtMXi6PsHLtNK4GGi7gekkIytT9FiZm5Rk06/oL58gyCgXU/pmjRKe55dr/vzDU7ZdRBsJpMn4dFInor3RCViWaYSI6b4Lkb61yUtcCTIl8TEgsiIpW2zDfG/OerVhebFMFgOVqP0xQLQjfC9T2H5g0zuEjORlhnWethkggnUW70FnZowpG3A2kf6LSmO3PVFneNvjokiNRSEo8sQRIESCThn2zrkEuywVRa6QOtIsz3m63tButrh+QEjN6nLJ2bNTLtRTpnv7lHUNCLRR+KGjbzYU9RQzqZFKE0NkMpvwq7/5G6ASHK8oCrIiRyiJtR7bD4QoqKsSkxUJJOd2NQejYnrAe4+1FjsMRBKoUI9NtNNHj3A+sSUg1bfWWVarK2IMaJliGpMSm/R9QqZnkI94m7z0jMRzqSQESVYYxKBSw3KsCaTapayIxBYgjranMF4fCTwqgOACcWwMXku5f4Ljf4TUXI7FWtKn+VHimwLQ0zR3Fz6+i4lSIkVq7YonjcAH8VIhleatQoBUaYwfrwutsW8r/mKRlGTF8sX7FGP0wljAhRDoB08/ePKs4O13v8nR8QkfvP8jHn32GZNJzXbdMjjLo0enzKc1uVF452nbniwzdG3PYFuEUuR5RiSmi8IHkAnwIEcJs1AKOziUUhij04PLe+xqjR8sRiuMltRFwWa9xiiVIilEImGS+AnXXWmpVLqAxnMWpeTZ1Rm/+7v/mkpL7r3xCvsnB5yfr+lDxGUF7aah6Bt6b3HjdB3BdUD9y4X3LnYrncuXL5TUJCF4Bt/x6Nnn/PN/8k/5T/+Xf4dsbw5RMDhHsD5JpUYfeggeHxm7SWnRNcZcSz58GLu7zvMiai5d1Kmhn7p+MQTsLsz+pdcMiQAZd9fMOGESUl4X9LuiPkWg7YBupMgJ8YLoviO8G635SUEI/77j3uJdvnL0c/SuoyxmxNBTFRXRZUwnZbrWbUtWFHTrc3SW05NuOjt0ONdgfcDbdE30dksuDb1rUNGTSYWSgTYOPN/P+fyGRjz/MWbzGYv9A2bzBXdu3+H49l3m8xpFYHN+Rd9sKZ/X1PUtTCZ5/ugxXWeReYGsMmI3oOsJe0e3WJ4/4Px8wvHxHr/43V8gOMEf/en3uVg3bIeeZtsytBsePHxM0zbsHx2js8hnn3zI97/3Ay4vriirGmVy/uv/zz/nd//oj/md3/hF3r73NkpnbH3P+3/6ETdjxrfyI94sD5mqkqkuWOiKwmRU0mCkomCc+MYeyRh5EiM2OogWoUSa6IqSQuSoScm9ieIPgmG2p7g5q/is7bl77w3mR3e4uHjOK68e41vLndfuEXNDtXeTboDpbM5sf067vESaHOe2qEKTF0c0V88opwdcXZwSg6IZJB998JAYBDduLZFqAiHy5OEFm6WlCwNC17x66wbZ2ZaBjlvzkkikrDSvffXbaNtiN5fUB3vEwVPoCqkNiFFW7iIquuR/yhLEcbvuWD34GL+8QocU61HJmkIZhIromKCMxNR193FIjAXS8wRfIqVGijQZz7QldxOmDGyeBJ7+V7/Heq9C/uIriK8Enny85uP/17/iN//3/+mXui8gFQRKZdx49T1eOf5z9vb2aKznBz+44u4iEjONMBOyosK5JcKntcAHMdKYHaY+YH7jAGsS9MhHg/WSN97+OvXe4fX9K4hkOmM632O9uqQ3Be1mTdd1XFxeMJ/sE0Ly+RWFRppIs7ykjUds1pc8e3zKfHoXqRJ9tZgdUlYl/eaUmO1R1QtWFxcorahUjrPQ9pH50U10Zq5fxXRSovIJy7PPUVXOweyERx9/SFnNOX/8gP0DxaQ05GWGzrIETAyR0wtHbz1ZEeg3V9igqG1DaTKqgze+8Bw0ZYWsbtA+fUi/vSSXgvufnrF3mLN89hzl/LUyzbk04YwhbfikjAxDy+VVoMo8B8eHfPzZE1574zabxw+ZvfZbZOU0xV2+9FlOb7+HiRF5fMizz89BaKpScrZuODkpOHzrFn5zSlWlTZ+Uqd0r4i5eJaJFROc5j9//COcjBwdz1ktPPtkyrDcU936J6cnr17J9IcbNDyCyKbq6wUwpHp13HBye4C6XrFdLysMDyslttClZvPIV8kmNOfh1tK4hfxNBzU7VBWDqCq0mrJslhZokW4NUICs21qOKOU8u1imWjIAxJWdrSSF/eqq5VoogAiJKtFVE6ZEyef2V1mRZWidFDBCSBy/LNd3gyUdg2DAMqDFWMXk7JTg/UtJT423oO7yNEEOaHnmPkhE/NAjMSABXDH3Htu2RKibfdXBJXmsM1vok11bJ7tZ5ifAgdY4QyYIEkGvNQES5SGaS/Lwf0p7N6MQwyY1C6CT1rIoyGduFZmsTOVyGQHAds+mM2WxK71N0miCSlwbhPevtNsWiCYGznr3FQaJ9+yFt8k1GiBItPJEU8XX6/JRcBiZ5xFlP7wNVYdKwwwZctMz3p6lBZT2Hx1O6TUc75DjvCSMsThLRuWRvUrHtHU0/ILQg15Kjg0P6rqPtW2aLKcI79uZTButSqg7w5PmSqsqAyHQy5erqEiVNyvAOgVwKehEheGZVSVEUOM8IXNMEqej6jh/86AOE0LTdNjUClMBpjxm2FGVJVIYqCgiOTENRVZyHDTIkOJo2OuU/Z1OIgTJCZ3ti8NT1jKF3KNeSZcknH4Wit54yM5hqRvAdQz/GfQk1FktfbuLd95ZK58jM03QBZTIEUKgcozSOQN+3BK+oJ3OybLQpejD5SBBHU2SCrCohRMo8p+sH7OCoq4r54hBlFK6/ZPXsMd4OzA736NoNXdvw+NEzPj9b07lIVioyrciUoajSaynzHOssQmhCVGQqUbfFGEupc3B2YGgdVTWhG9I5LYsC71KRZvEYKann0wQo3nQUmSIzhsEnD7gQEjt4hj7FzE3qgn5w9L1NzAdrqc2Eosjo+i3aGPomEBxolYrIdN2NXA88WgkKLXF9x8PPH5AbgQieEGATJHVmaJuB6XyR4uialma1xsXIya07lOWE9WrJbFYym9d427O+2KLLDCUDigDBon3HO197j5MbJ0yrmkxnqUANkegDXZOginmeo0eveogBH1K8tNrFEjtH9GkCLoVA6uQJj4DrB9qmJSrJ+dNTZos9lMlQWtNuWooywwfHdZzYyNHa1SDapBpUSJnAdTER+2NIkaYxJsBb33aEECirCu/dKE+XY+0br1XEcbQHvZwaBaRGx39oqXlaPEZjfNxNl9MUPGnpUySGFHLMqRZoo1OUlEokaqXCmB2YQFOCJC9QSo8yKImLDsb0SHnt+U6aqxDjSPxLfQ81Fm6RMMoCuC6wfEhwgba1WCVZ7N/kZ78z5/jGDT7+8fu4oePJkyuen11wdXHBvTuHrFZrdnnhERiGwGJvQZYnqZ8fIlIGhFa4EZShVCoOttsNIgbqRU00Bu8s3ns2my0gmU2r1C0eC26jNcjky/AxYmPE9T3lSJR0ziUpyTj5lgL+7Mc/YnVxxa9+9zt8+5e/ja6yJK/XEu96+jZgnU0kxDFv7uXj5VixlzdzQiTvkVIqdYR8wNlE1P6DP/w3vPrqHf7a3/pt8jwtTL21SWqg01Q7jHIXrZInL30G6jp7W7hEa++t/QJYTY2APaPVmGkOjNfO7kivNeVnMt5a8qWJzL8bkQajQi8EopTX1PS/EKdGmhx8maPIDjASKlVhsgmZhjzLkLpAFxlaZ/R9T1YolJmRVYKpqfC2QQlDu7wkKw3rzYp6umB5uWZSGzatxYhAUAXWBIYbgTe/VXKobCLDG0O37SlNztPTU67OV9x96y6zvT2O37zD4w8+4cnjh8hcM11MKRbHTJym3Wxpz56TzXKEE+SZpIuBxaTm8vIZ69UF737tbTbblkePntA5z5OzCy6Xa9q2TY0OJXjw8CEPP33IdtNwcvM2f+U3f4HL5Rk/+MGnPDlf83f/u9/jt37OsTi+ye3bN+C84ZWt5F624EY2pSQjk4YciQoQhCNGiXWOITbpWSEEwTdkOqfQGToqjJ5Q5DUiakyhsFXNvof/1Z1j/sHFluqNm3yteY9qNuPOK28wnS84unuCCorzx6e8/vY7DEFS4Yh2iZGRWRnJJyVu7SlmM3IxY9CfcHxzH9f3rF3DyY3bLNU+uW/QdkvUJYdHE9recqgCm05yfHybxf4c1IS3336PcPWAw8Uh1f40RZFM5jRe4C8vcTIQSonOpiiSnFOplhh1isrJIA4D68fPaB6eInpHLiWlysiVGCE6GiEyRPQJ3CcVUhpwBcTkITU6g6iSzFjmFEqSq0BvG4qiw547eHLO40/OWR19RNfA/OzLQXN291qMEYTkzru/zq1/89/wvR9/ztfeuMH+4SFvv1lxdrkm9I6hb9ESMpnkXREFUqGFx8uCjz56xptfP6HMJIvphPuPHU1rKMrsxXNCgDIZ81vv8MEPv49ZWPqQp42+zNOEuaySlDSLXJ5eUR0dE7sLZPVVivIhB7ffGtM5oJrfJNieg7s/z+rqGSKf8vR8y2KRYfciWV7T9Y7F8XHqqqehI8ZklJMDjLxDt3zC84efg5BcrVbsT3Ik/WhxSdntCJkaxW7NdhOYzCbM9m9wsbzE+3Qe8unxF86pVIpi8SpXy/topXBCowwQAqEq0NIkH6CDKBxa7NRTAh8Fy8axvzfh8emKqt5y//Elb7yyx2w+Y/raLyNHWFMU8bpBWu3dRpOx7hytFQwqo7OSyTRDBEHTBTLhMUai88QoCR6EDCgJRgryyZRtZ/nquzf5w7//CXfflHgysmkGuaF883cwphgb+CL5kNOcMUXrLd4ifPBfsd0eUwxX5Lffpqr3IbRJISQ9+Y1XKY5/CcpfA7lCUKa9ATHZdrwFt2T56JR+iITVkudXgYumZ9kO1KVKSpGw4bAUWAwmn7HpMuos/6nvh2GwOAsIidEyxUXFNFUN1tEGjxIpB9aFNDhQWpKZ1DxWQhGVpiwTnZkoyI2klYLJpGS52tAGl2KgVJpOZdqQGT3GCgWEdxhSlKc2elwj05Qv+jTNizEp9PIiw4/54lWRE3TK25VENu2ANAoXEwzNxYgM43Tap8pIS4koDYXJKUoNQhAwhGjxdkgNB6OZTmt6K5FasV4vsUSMKrB9wySbpYHNsEVFT+ccLkqiHRicRxtNVc4o65paGa5Wl0Qb0FWBaAeGoeWij8ynNbNKUNU1z04vEldGZUTrU5poiNjGMjiYz2q22x4fA3WZjfsvz6YfECFy+3DO+dWarvc8OD2l0hKUIs8EQxQYkXylhSmIIlDnBUNI/lYhJTqvOVgc8PTZU8wI1xMRglC889oJl1vL6ekzvAcfBqZVDcIkuTNbjC8I0qZpoFEYbbh3MmfVO7aNJ8vKa0VpVWQMXUTJwN07d3nw5DHJ3KLphoZcG2yMKUHFGBSevMxHSa1M1HGdLIV1VTGbHRBtR11XLNdb4peg/EPaN3o81gqiyEBqAmnwMmx75vMJk+kC8GMMVExN5BjRUiNyyXa1YTadoI1hu20olCGfZvjBMyknGCOJbkO3PKNpeyaTmqZZ0207Pv/8EacXLW1Me/FMZxQmgRWLrCDLDbkxdN1AXU+YLvbJy4LV1QoZAyZGbAy4wWGyjCzLkFKw3axSJJtRbG3PvC7wpNz3tB63OJcK4xgSQNGFpGLrO8+gInmek+d5gjtam/bVSpFlimlVJouD9CkWWQh0DFR5ybYdaDqLEAoXA0FJitwgNfihQyWKXFImu4AVFtV19OsNyhiWyyu892xXS8rJhEwlD/lmvaZZX1EVGmM0KssopzOeP3vG4f4hf/Vv/m0mkzllkYCD3jpClvZ0dZ2uyetm4Vicml12OySrhQ846/A+pTEIIRgGmzzT4zK/WV8xWywYvGNaT/DWMd9bICR022ZUt/rx+koRhXmRj4pXhTSa4D1JqpP+TRGTeqcbesQ4UPXeI0c2lIgRPwzXTVGxg5WJZIMSAnxwY/SiTxuBn+D4iQtvKZNbOIzE8hhHqWz0gL6WLe86uYzTcMkoRxqLsChjynz8SzoDEZ9orCHBRCBcS4uBsahLRd61FH38T5Lec/QJyxZ2hL5hoHWezQbKMuOV177Cyc1bPH5wn3/4d/9byrpgXpfXEIDB9hiriUKh8nyM0koSCKOSXzjEAFKhhKAsCqKA9WqdPMnDQLvdJH+NSN04N3hmswnKKLSCddMRhaGa1Zw/u8T2A0YrJlVJFJJhGGijR+oc5zxCpCiBIQR++OgBj/7BGWfPn/Det75K4yOliqyk58NPn3C+bMbcydQJ36kCkkUgvJBk82LanYrf5EH0PoxeLYjB0fRr/vk/+6e8/c5b3Lh7iyDA+6RScN6j4ouMZSXVdZfpZRn7LmLMmCTdSn9ODZsizzFGp65XDEgvv9AvSNdNaggQr0Uk1znwu9ZLHH9KC4mSCh88bvye66w9XnjO/Qi8+TJHlWXIcdof/Rbrc1TUZFnqZKI82SRDxkg+LVNsjNYoMyOGgXJWp8iFah8pA5O9BSr45G+SEfICeQPE13NuvzPnnbJikB4fPX0EIyMXz2s+//QRV8uBcgLRKQ5u3WV1dpEegEA2WzDzge3FBattw2Gd4cOG5eqK87Mr8umSRTklqIbnnz/kW9/8FgeHn/GDH/yAV44W1HnGtk+b5xAFn3z4Gc46FgcHfOe732K1WiGC5G//zd/k8uqSuyd3KLRhWuxjfvgR+2j2tWFfFZgItZZoYM/UNKFBohEh4FQkI0dqiSYSFRhhKM0cowoylWO0ITeaBo0qCppBc2jg663lX/z4z/jO219H5yXFZEI1P2S+yFBYXL/Gt5d4oei2DjWcM5lnKDXBdz06U2hREbyiPHyHQi9RTzd0yy0qNBzt73G8uMXq4pyehhs33+PTT0+5cecGX//2r6CFo19ecHhzwu3X3uXpj9cYtWbv4FWUMXSrZ0jVI1SPQhJxxBBQIk8sCN/hrcHlEb8eiN1Af3ZBd7WCPqBVngCBAVCJLxBTxAExjM9bP/otZYKKCJHiY4SfgXCU5EyzgtbM2PSX5L5nUtYIZYhXKj3r5pMvdU+8fEgh2L/1NnkxwYcteT2l8Rue3r9PL0uWG8vd2xMGH9DZKCdHjJCUwP6s4CtvHVFNa9re4aznpFK8+81vo7Ps+vfE8R4/uvNVykJwdPOA56ef8fpbbzCvFVlRUU/n2EmF2TbksymrrWN+6w0G73l0vuIX5/vX/qxq74QHH3/C1179DTKd4aNCmAIimGrB1hmmomB2eDy+AEZrjWBycMKT5UMePj7j9bfeYP3kEcG3UE6xYUM3gBUeKQNepOSCrc9BWVbrSAwD67Xl+Aj2b7+NKr/4eURgfvNNfviHf48Q1vSdoaVm3xh8yDm72HIwkeMzLqbnyGjJkgL2ZhPakCFdg2TGq6/c4eh4n/5iwyv3vpnUbDFtMIQYG7XljOnxGzSrByhzRbPpk8w7m3LjRsny8UO0SZM4peUIX41kPsnGtQY/NEyn+6xWHaKqObxxjHdrrpqIrO4xu/Hd0RaVnudC6tTUGDGr6vCb5A/+IQpPfXTI008/YP/1ffZffxO7bTm4+yrZ0S9C/dsITJKpI4j2DNQW5B1sd8Wwfsr24hlHJ/foN49ZnT+nHQrKLLJZXjDJwPgtrfNMZnsse4lSOVebn36tiC6tgZkWKUM5XS5oIwkWhEqg2OiTrFzEiLPJ3+tDHO1KgrZtCSFNYrejd3/bdEQZISZPd13lKCRFnpFAQ4bgHd3Q4lYDUmXjpnJstHtJSHlGKV9XRFywCBGZzpKXcru2GJPTWUsm0zNGqyTBVESctUzLmiFatEqAVVPkZDpBkkyWsSgkrTNj7rTgYFYRpcD6SGYUy95SVxlH+wsePLzi80dPQUKVaa6anhglMCCkosqT5S3GHqMmSJUaBF50CN+icogjRTlXgq7pwVkQDm0kdVYQCbz1yqs8evIMGT1CeYQfePX2Pt5ZHl2s0t5GGzItGbxjvWmpy5xIR56XxBAoyorNdkNpEulaK0MfBoyQ5KWh33Z4b8F5ZlXGdnPFdFKyWi2BiNaGKCIffPqIsqxQJqkaqkojg6cuFTIMTCpNiJZAifJDytQWgcfnK06ObzH4NW7ocDGMz/1UG2R5zumzJ0gZ8YOnDynmVipJkU84nE/pg2QY+rRPKTNETNaTwVmUlEzqKU3bIHVGMziKqkxNli9xRJEAVyZXGCRFlaOlZLXd0q62bDeWsk77SK1liocTOhXZzYa+D0zm+6AiV6sVEkmuFdW0JMScfDLF95eEdkmQOcY0BNtjipKL8wueXg6svURGgdHJktk5i1SCsqwwRWIfREDI5PHt2gFrU2PJ47B9h5Ya1/actw1CapSWKQq3aSEEXG/xCKrcEKLHGIEbBP3g8D6S5Qbl7TiNzbHOYZRKE1wh0ZlBkQrFYduhRrtu2w4onZGr1Fjddtt0XwtPXhY0bc9y05JlGiXk2PBN+2GjDf32Cus8FxFc8Jgs53DvgNVySb03I1jL1Xp1bY/QeUlrB3pnqU3F0PbURclf+52/xa17dyjyEp1lqFFVanSKMEwKHTU29tKTTxCvo//cSCP3IQ00M5FfE8q7vk0AtOCppxPWzYau6+i6jr4bkgxeRFQYB4CAHLlaya6UAM6pKaISK2+kT3kfQCm0VMk+QVJTpmm5Gm1sSc2tZLLMCKXSxJ4EuYTEm4oBfBxTt/x/4Im3G03wL90641RDjDmP4hoAo77gJ04LhHOJ/rfz78pRjh5CYBiDzXcTWQHXqPZIWoiuf3l8Eb0V4bqL4r1LMRohEnygaRu6rqNtWzabDZvthm27oS5zvvWtbzLfO+bgYJ+r5QUGwXq1xNkBPcY5KJNxeHKEiJ7V2Xky1WeSKjdkpkgwJJEIo4OPqCyjKAucG0ZQmaEqC6aTmuXlkizLyQpD9I7ceoqywnrLYC0BybyeEEKgbQdMXeKJtL0fI7d8AqnEiBeRZ+2a/+Zf/Vv+6P33EcpQ7y24Wm15uuoYxotQSpEiFSLXMQG7AtuPdPGdDD03OsmXxu8LwWOMHmXkgedXz/nX/+Jf89f/k79BOXpfdsqHEHYT6h01ffSmjR3KlyXueZbgHrtJtVJqhEYoBmfTBfnSVJqdJFykzqtzYZSOj/++eFFIg0ieELXzz4+kc16GrXHdEe6t+8Jk/ac5apMjTWIdeGsRMikhhC0QoSerK6LziDpDioDbdvjY0rUNQkRs9GnCrzMYJFldp4mfdaAjXW15dDuD2wVlrilLj4mAVDRd8uTsHx5Tzg+xLnB0OMN5w8P7D+m7LUU1R5gME3qC7WjbC87XK6Q/5OLsE8p8gbNLZDtweHwTYTd0exXbvuOXvvPrVDp1at+//ymrwXBycov3f/RDtNJMFnP2Z/usVpfMq5pykpNrz9Bu+H//t38fHeBv/fyvsfd4w824IJeWShlyARM9oc4KCmGY64rBhxEapDAyx6QLgShSAWAEFDoj12kyo6LG6YipJc+2gSKHxWTKjcURxXxBVpUE17O/N8W6DcF1aLZsnzzDTA+YlSd4VTE0DXndU+UZq80KFQKDjZRHN1k+3rJqe65WPd5veesrb5PXkXp2jKxK9vZeR//+v+Jb3/55ynqK0Zqm2bI3n6PiimlpkGIgix7j27QOqJx6fgvRt5TKowXIOOD70S1TTIh4uvOPCZuBy88/Y3t1xoQsSbuiR+hi9N7JUflTjJ7eQEAT6ZJChAwVHcgSo/pkexApMGihK2qdc9m2WLfECInRGiUqtPxyG6q/cI9UC6ZHbzB9+Mf8+KP7LKZz1mcNap6x3nb4ocQpRQy7mCSZ4oxEhKh59HhLefl9BhtQmWH1zJLn+19U7Ixf926+RZQ5/XqTikkrRjgNCFWiM4NRko0NFEYQXEdhco6nJYd33xll+ylaZLq3QMRIsbhHv/1dYoDFfMp8tgd9znzvkHqxlyTV4wuQUnBw8w6PPvhjnI8sz8/JtGE2K3DrDlNyrQQQSmJUeq/Hi5JnwVNlkuXZkr29I8q8YnHnvb/wjBLA5Pgu1WRBv15ivWIxMdSTAmEyWAlykySZ3nmETgojH0BIRZll9EOPzAzIHDan4G8SqjeYHd9L3sPx2XsNtNSS/Tvvsvn0gvkko5jU+GbNs4s1l9U2WVeKiBjJslGmvOG8Cmjj2bZQ5YqsmqMrz2LvkvNHj2m6kqLKOXj7f0JRL8Z3mPYUQuyUbWlt0QdfR5UzpgcH6AKqg4JqkSe41fSI0K9hWCfKr4zgL7HNp8Tu+/RDoDz8Cv2mptteUi1m3P+zH3BQGrzv2aOni4Jp3o5WJYfOJkgik6yjZsD+ZMycv/QQOuVt+5HIK6JAS4HzkTzXaRKFYBiGROdVklyn/GCBGDehAz5KlGKcRidbl9EpT9Z7QVnm6GiJUmKMpG0tcfSlQqTvHNpEMm1wMfnJMYnibYxib5bz9HyJxIL3dFtLb9P0Z1JlbM9b0OMG3gmKPKMfBpyLRBc5OZqnuLEiZ7laMasqQlmw7RybpsNaSz2ZUlQVVipkhN52SGHYnxZoE9lsrphOD8jMwBAiXbvGmCzFiaJTjnJ0afqfZTg/oNwWN/QMfY/SMkWzEcm0YtWn39v0Hu8jRiuKOieIjPc/+gSloMwyMi1x1rFcb9h0fWKL5DmgQAUqU4yDJ01epOSVOjcQIp02DNaN+w+QGJz1RGeZVwXLmAZB/dCBThv/rMi4feMmF6uWodngBHhvybUaN/6SmCmCSzFmnbW8dvuIk6/8Kn/8z/4+Wiu2nSXQ0z28z62DE043GyY5WJvYLDE6+iHtiVMsnKDKS4wQaC24ceOAbWNZnl1iTMrAVjEl8JgsI69KpMwT3DZEMBGlMtzQJY/slzgiKQmpLlLRa/uB7eAIIaJyg84NRVkRRgAZMQEg81xDrMhlT9+v0UXFYrGAEOkHy4w98tmcobmguTilyGuMkrQj8Xp1dcb950uueotUSZlJ3FkVFUVRU9VVmvargDYFPgTOnj5DCoXKNCozlFmGL3J8EMTokb7DukBelDRdixGaojAoDf3g0pUjVFJqlRqioO0T8yfLcgY70LUNWhm0iAlMGQOKiI8C7xP0K6mL07NRKUkXHJkRlFlNUWSoTUNRGVyING3Eh4iLgUxLiiyn7TuGoQOZJx5H8ETn0Jnh8uqSECW2a2nanuj6FNHnPFEERAQXYBgc0nj2Dg9552vfQBqD1glGnaK/GItUmab843g5xrRGXq9pMcUPxrizoEayLMNJSd9117ZRbTRt06SiXgiyoqCeTEHJpCYhKYTiTkktkjWaGInB470bLbaprSuVQqgkH/fOIZUaZf969LLGNO1WEhkZm2GCpumY7+VIpdKAN6bfFUcFbnC7gfH/8PETF979kGIUpEgT57DzXY8nx4mUufhiIp080bvJZyR1GfyuUBsLbB/jmGWXwAC7LO9rmJpIxO04yuWE2OX6ATEk7/AwjMCFnt72bJsty+Ulz87PuFxecHV1xWazYtttkFLx4ac/5td/8Veoq5pZPWW7usANHUZLpNbMFnOKsubkYJ+syLjfDQzDkKBrRmIyDXL8Giy2s2M8SCp0fQhsmxbrHUWZ4+wkbSaVJCsLzGDxLtCsU9Z2ppOkxfaWalIjFVyuNkDq2AzWjdMLQQzpPHcx8NHZZSpoL6+IeGxM3rjr7GwRr4tNEQJaq+tmSepaJyhcmadpmo1JpuG8T5IzJdFK4FzPBx98wLeefJc7r+WJaDleB7ub6uX94c7zOJbjL0nAk1VBiBfFsLUOITyDTw/3l4nkqduprgv6F/C0L0rMxdiZSj7w0YtBRAmZZHXjz6XOWoIAip1f4kscWZ4RdZq8ZUWN7wdkZtBZjq5KVJbAeVQGXI/MFXa1QbSe7XrJo+UFdVaSZTmKyMztAZEhCC7dwOmdnm52zJ4zRJ/TunSeLIrVaknwOXv7c/amAq0yMukRMUNXmiwvaNdLnn3mmO7X6HKKjZbN8op2sYCg+ZM/+l2cV3TdKQ8fRHThQXb84Pv3+fqbr3L79glSGb736WcoFXl6dsbTizP6oad93uJax3wxpV2vuFhd8kd/GDg7X7FtWg73DnjWrLjx9m0u/uxjKhQ2OIyZJJeCimilKZQh08mfrGWOGkFBxCzRbeWQfJreIxTJI4cjyooVmv/jP1nzv3i7J3dXiPYS281Ynj9j8/wp/s030FiK9hHd+ort1RlHd9+AO4f4mOGjxTVbmv5zglIYPEIpus7js5Ly6A1uTU+oM4WjYWL2me6fEJAEJTi4cZv9RQ1ZSVg9YjLJKGYlvhsSMdOcgEiRPqiO0Hh63zLNikQvVjB4ixYBXc1RuSZ0PaFtGRrPsLoAa1EmRxiV4ldQ5DIS0cSYJoqCnIhLgL6giOyieCpEtAhp0uY+DFg/xtPJnJuTKcshsGmukrU0+8kXjp/oEAKlDbfe/XX2fvyH3L+Ed2/mPDireXMx4+GzIXX2dZLYRguDhaaLCfCXZeRVRZ4F+q5huV6xVy3Yv/PaF2w0O+vIdHFMnhesmo5++YTD6Yqjw2/RDx4tNJChRaSsS65WPd35Y4Y7b7JZXlFkYqz5BEW9x41bd1Nue+i4+crXeP7wEUEpmqbDOcF8fkBR17zI3kjH/uE+eVmzODhJsvbzx+A3FDKgVI7JBEWWoUd/PzGyWS5ZXzRweMQgC4xtuDxdMb31xl/gUAgE5eyA6d4donY06zNWzy4IXeT2q69TVeMmYJxygyCGOHbmA48+/JT6zj3aQXGxsrx+d44IsHf3ZzGjiuBlLkhSugkWd9/mgz///5JnOQ8fPkYvL4miJsiS2a3b+O37Y7EfYbSJCTluwITH9S0Pf/gRN797zGrdprxpYTmaTDGzd3lhjUpqB0Rq9EdGxVZ9F2kqChnww5b100uGXLB99gn7b/0yQ3vF8PR38ducbP+byPZ7nD/4E+ppRXP1I4J9n95/g835UzbnAq0crTUMVhD8FhWTf81F0Pmc/cMTvB/jiyTXsZw/3W0QKEyODyPwSsq0SdeS+aRg2w7MZxOaRuJsjxFJym17m6Y3o/xeaSiVookRAkgjkxQzpKmgIaCUJJuUFEawXG/IjMSYjLYFpRVZZshMDkojtMZITfSe4B1XV57SaIwSNG3A2oFqUlLmNWdnl2nzTfr/wVqsG9BSUs+mWOe42LRU2rCY1tisYN2kiaBRmiA1WW7IZGSvkhRFwYOnl+RZTl7kKY52SCwPpMDaPjUUR9uhQDCpTWomiTTRV1lBjIEgDJWeYLIeZ3ukBG9bAlCaHCUkdugxuUYiWG468txQ5hnBW3rbo0gRaS4kCGGIgWldIYuCfrlKtOgoKDLJ5OiI9dWStu0wRT1GvCU7pVSKUmsGE3FIok2WxEF6nA/kgM4Ktk3L48cPKLIcLUNSHYhkwyzyPMWxjiBWlRlMgKfPrrj/5O8xjOrHPMuTtFYEHl08QyvF1TpN7xL8VqEyQ3A+AYJFJOJxQtF7wYcPniZLFxHrekIQDOvNCD1OXtxZZZjfepunDz5EeNL/05KiKH/q+wESjM9UBUKnotJIgTLJzuFsUoD23WbcqyYbWhsjee4Sr4JAZgqMEmSFwvnIdHZENp3gmwv61TOcMOSzBcFtMZlhs2353ofPOFv1aJl81sZocp2T5Rl5WVJlCq0iuTHIMnE4TKYI1mNtoBssth9wfUSIQFXXKRljs0JYmyjmMdD1W7q2JTOgpaFpB5SEsi7o+m7cv0I2FqxFkbKlFYpusISYFMZ+VHNG5xLM2UYKEymKbKybIv0gCTqgvEOKFD+cy0g0EhsCvfMU9ZQhepCK6AJCpoI2F4Yw9FibVC4BaLYeFQKB1MBbDQFvx/x3EZnMNL7r+Su//dtMqgn5WOQmgVVq8gjSvSCVRCv9ookr0vM9xdmlwjdJxEclrNZY51DGUFWJz7HZbKmrCcv1kr7vyYsKISTBR4a+wQ1D2kNLhZAqKayVSQoseZ2vNDZYkrBtZ2GOXuBiGKF5o798VOwmYLG/VlXnRZ4WpNGiEomEcXkOIWCH9hpM+j90/MSF9863zUitFiGQAsDSAr0DpkXGbMqXNnBf6HKMRRcvFe67N6lHGBfw4vsR19L29Pe7v0t0uq7r2G7WLNcXPL844+LqimbokjneB7Qx7O8fcHRwgDKKxWKPo70jzs8u+ejD+zx4cJ+bR7OUCygl/eCRKA4P9sgkHC3m5F95ndV6jRKwvDgHG9C5wg0Oa7cEJG4I+NKPcIPk96umU7ZtB0icD7TbJhXPIlFnvfMoBMFZ2sHRD55yOkkTd6XJJGgh8Nst0Y3yCFIHXYyocCEY4VNpk/ByeJgUaVqupcKTJOWIROTTUqKEJMsyTJYxOJe0iCL5o+3gMMqQGxDRJQ/vn/+AG3dPUqdQqBcKhdEyEUOSBWoS/TTldPtrtcMuq333Wca4y/IeP9gRxrNrFoQQcS4V1t4n6Xi6XtLDODMmFd1CjA8hf+0TSR1BfS1z3/0+MV5bX3baPX4QiBDT+dACnReIqEGXqGKkNZcaUSmiqxBSJPiEljR9z9H8kHW7xmiDFBovAt5FlrHh/fCQPz57jvqTnL2He7zx6tsc3jxE5oqynnFxtuTyfEV443Xu3DjECEtvHZu2xQ+aanHAMHiwHY8/+IRmCCymN4n9Q07v/zkx19SzmlwXnMzn3H/wYy6WG169fYuvvXmLf/Df/SN+9Tu/TJFHDucF9x+teHr1FNsNeOfJy5K8Lvnsk49ZXSXZUlHW1JOa145v8OZrN3n/8w/5/z2+4KuTY/7avTeYXklmMacUCi0MxLQo5Dob5XEB7wVSBIRwCBSaanxSZngkIkiUlohKc3Sg+T/9VsEd/YjTP/4vODOvcvrh+3gZWZ894vL0Q27f2KMWPQ7Ptg2YZx+zn1f0VuCHLQqLMFNMKRD1gqvTx2y8QWRzyoO7zJRBiUCZKWI4p6j36IeOqqz55nd/k835n1HXN+nXSxbHdzF6xrB9SF5lCO9x2zVX6z9BV3fwMuCHgI49XRzIBYgiki3eQpoKSB7ebHKH9ekZ27M1WpUU5GQxQ0aBkj4tyioQvR2fpxBjDjItYkakTrcgNWLS5HCEYMakDpIYpI4cVrdRvuKifULGJcpMv/x98fItguTeO99lkRue1zWzUoMyrFbbkfWRHCStA0TABUE7CIL3TIucvqiTH5EVZV7SUJHN9v6dgjRNRPJ6zmQy58cPznjztdcpp4c0TU9+64BoPcgSJQXEQJ3BkM3YXFxxcutViune9TPBZAW6XOCdpfdbmmbL1dWGejJn3UfqTHHj5s2xAfnF91tNK6QuKeZHNE9/yHZ1BVqQ5RPybIAoCCSuhyBF4QjfIYOg7yM2KiYTwzzPmRy+xotpwfhVCJTR1IvXefL8c1aXK1BpCrNtNgg7rqcKVIpXTlPosfC++dotQr6Pff6Uvvfsvf0Gjz7+lO/+5ne/oE7afZXjmjG7/TWEdSz2T7DbHnJBc+Xptlu6xnN7lpgr7DY0o8UpuEjwEakVr9w7wntBVRVcXG2opsccvfFLlPN77KKuRrkbCe2/a7ZHRLZA1+9S1w/oxRQVn5AVC3R1wLC8ZHNxCu0DGvWU4uT3MW7g6vP3ka+8ht1mfP97P+Cdnzvk4tkFuTpgOyi8sNSTA64ubPJLIpmUNVLPiEiCksgYaQY75kv/dIdUCkdMKjJi2vwyUFcV1kt0nry1i2nJuhmtXKTMeCElB3uHTOsp9x9+BlJRFiNLB4ci0g0p71lpwXSaYqAKNSEvc7RMMWVZVVBmOUKk2DChFBKwPk0ZRUxrtJLg/G6wIugai7MtSqZJbpSpse9FQATFdDrBO8e920fEAPPFlMvLS/LMcLg35XLVpua71GN8kuLh+QYt1uk8+I6+ddh+oKwqNus1HkcUkjzLKacV2zZNv4YhcDifsO1Sw67WEhclmdHYoSUIy+F+Tjc4+mGCVCnXONek50NhEFLhez/a1BIfR4TUoPcu2TMyk+TCXdvg2xbwZDKD4JONzfa0YzRUcF0C58lET06zdkduNDEKTF7QioBROcokb24UiqyqUcHiUXgSOE+Qps0ET2Ey9vembK2laQakT99b6zRtTcVanmSv3rHYm3L6/CIxAEjJCfM6xwVJ27YgBUYaUAYlPdshEm2TfOyEa3JzJPnL4zgkabqIf/xj5tMZ1gkyA/vzCccH+z/1/QCgtMD7iAwCowzWO2IMDL3HyIjKIjorcDZFS+V5iRSpSPfO4oKgLA1FVVAWGdIU5PUU3zXEfo2SkmlZELGE4GnWW37w6SlX22EEEqaoOEh70iI3qYjPc4TSNP0AvWNwDik1eVESg0sgxPFa1kqj84K261EiXTMiRkyRjUWloesdSnm0BK083nYMbYokzlSkLAo27YAduUmDsyijETFJn6Uy+BhRokxeWm9p2j4lAGiTbAzBY3vw1hKcS00XFVlMczoLahhY7E0QUvP44ePEPnMRHVJ6jfOpUetjUvzmMQ3EQgjgA7M8SwT2AC5IcD3f/eVf46tf+wa6yCkn9fV6nADbHkVKSZDixX5/d8Rx2GrH6OUYk699V3wLKRNsuOvSdDn9FEIkWLdtW3YhjUO7pppMkh1JabT2BA9ZXhBG73wC9qZ/Yxf9JcYxYJKSpyGlGtOYdlNvIZPkPy1JYyRfzNJ5EaQIrZhag4KYuFg/4TTvJ15Nrv3kJImD1KmYDGNRrNh1p19Eil37vkU6eWpsau/o0iGE6yLw5e/3fvdgHKcZo59pV3AlL3LKP+z7jqZtaLoepXMODk64V1bMJ5Ox2/FCo24yTVFWKCl5eP8z1tuGqp5QVhVds0lSxwBdmwimJjMI7zg+3OPwcI/lcsnq6pLgHME5bPQEFKgMrVUqDl0gzwqUcnT9AC51d4Yhwc+kToh75/zoYSN5G5Qi6kDT9njv8C7lV0utU1dyPGdKSURURCVJ+PyRZOjFdSMkjMT5l3eFL+frKjlukkK6YLz3CWhjU2GbIGup0A86eTxcGPj84WdsNw1Fsbj+DNNnsqOXj+TJ8cbyIYzv80VzZkchDzF5rAWMufAjpChdYdfvId2McvS6pUm9IF43cJRUuJA2aenmEtcT/VRwxyT/fqk434Xcm5caPT/NEW1P1CkGBZ9efxTpgZa6a4poPcJniEpDOxALgWgMk8mMuNmwr3OkgHI6xVlByAY+XH7Exzcdi9uvAZYgFI+ePsXqkjuvn6CNYTqf0zYdvY1EmQAvgsiz1Yp+c4lrLFpkCNlR1zmPP/8jPrgK/Mov/AztUvDRpw+wTcfFZsnBpOBwOmVaVhztLTic7VGayKcPPuYrr95ib3LAqfFstk+JQlJUFULA2enjsZYLKG04uXMHJSK5yfijP/8RXdtyfHjIcqH5VzzjzVcXvLLV3O1zhiYS8BgEuB4jdCqsSRu+QIfUOcQKJR1RpGshakcMOXFa8Ke24Z88e8T/4daMS/1zzPcD5w8ecfvOe6wKQX/5hLaJhOGSLMuw/ZaLSwP6AUL2XJ5fEv2Azg/QUjDZP+Hxwx8jqpKbr75HURzRuQFtKnywKD2j9TZJlFRk/3Cfp88UwQ/M9m4gtaRZnmKUwVlJc/4x5xdLimqCDBdo3SCdwu3l3Dp5G5nnmGJK1DnRW6IoEOS4UHP6/vdZP7vCBIE02fXzUSARUSJjInRKkXK/pUj3FiJDRJ1opzJAyBDBI7VAxLSZiiIiREN0KQ/6YDbHCc1qex8f11/qntgdO9WLFIH9o1eYLm5j1lecPb1irhV5PaXKLFEaNn2DDKkLbYMnBEGeCapMc/PWTdrzZ8xyzaSecHj3Xab7By8WpHEsKoSiyCuO777D6fkfYbJEQq/riojCR4kXBT5Gmm2LQ7O5vM/05FXmx/cQ0rz04iWT/bucPj2lWryGwHF48xB0RZSGkzt3Obl769piAy+er0oqyukCN5zxMAgObtzg2dlpiuIqIisPOnomwYGMOB8RkzkLLbnaJFXOEAWTvXtk9f6/M09PG7soJAf3vsoHP/4XTKY1p82ae9UcY6px09ajRgm8AIKIqEjifhQzni9b6iLBPdvOoSc3md1888Ua8fLvG5Vs2fSQvZPXWG9PGZxE5gU2rJnVdYKk6SShJ6ZJAD6tBy6kNSdKRaymPPj8Y6QAaWY0F5eI6TcQyrCjmY9PVoRI8uidCkFITXbyq1TP/u+0YYZSBZ8/PuPwZkHhJa63iO4C0GweR54+/JCZFJznC+5+4x1eHRz9+TO22yZZRXIo8pLnS6jmt3A+0g2BQkWG/gphxml/BBE8wv/0hfekLNFSYGMkjUgCRufosuLeyR7Pn1/Q9gOZgiwzOBfYm5aI4Onbjs1qiQ8DZZaB0uzNJ0yrimdnz2mH4XriFEXE9j0+eJp+e+2x9F6yN9vDZAkAFL0ghJQdHX0kV8lDK6Ue5ckDk7qkc44yL2i7AZPlaKkZfAJdZWWBAA7nNatNC0KwGQJn9x+jpEJrycW6YVLXKdUkeKQ0lLlhFgWbtsP7gFaJx5LnghgsRV2CgMFatNFYO5BpnWxzCIahS3JbJZDCURpF125x3iEFtMOAEpJJJRh8inRVEmRhUBI6OxCjHy2FyY6n8ixNlnVKZCkzRYwSKTSDTSAn6z3WpsJjfbUiREHnBiQpWtb6RK9uXER6hyBcR5dqo9HKEKSEoFECqrJOw6EYCW0gzwzf/ObPsmXOD/7oHzOtap48v8AFSwjJqnHnlVe5uSjoLHz6+RNEHNg/POLTzxNTQoqAEpF7tw6RusJ6WC8v2FvUKdPaC1ofcUFQZJqY5VSClCAiBc7Zcd/lR4vsMG7YFe2oeI3RMFj44LOnP/X9AGn/WeQZ1vZYHzAqQxpBaTxRRtrW0l1dobVCGw0ixYtGH1BKo3JFUjE7jJ6R1XNsv2VYPkFFi1QZbkj2v8tnZzx4vuLJZYsSMXEopESgKbOSSZ1T1TVlUaZ1IwbqqiYEUDFFTQkieV3jB48bLM47huhwV1t0pqir7Hr/N3QW5zxZnmBmdnCURUZZ5ixXG1SAo1tHPH9+xuWypShz8tzQtwNKS0KUKTpLKXwkZatriR06ciWpJiV1XY4KkRRL7H3AhkCeF3gfGCLgFdt+QMuMaAUnJ4fsV3Menj5mu+nw0YIak6BcwKTRM3ZokkVTifSsl4JubJILpfn2L/0qf+Vv/g4mz8lMysKOITB0DSbLyYtiVKMCIxPsxUImrwvvnZV1V3g759JALS/G+GpJnmWUebLwttukgCjLivVqhfMjY8KvWewtErRxhDXH0a+NSLF4hIiQL1WDISbQ2lhnBpH2H4xrjdQSpTTL1TOuVksWB0fMpntjdHJSaKfVP1yvmTor/sNTzUVM9EoIOB/SEErKFHdF8gpcF3I7KXoIqN1CPB67k520/S/j10c8u0xTT+d8KrYYsVki5Wi7UZqwky4YkzGbLagn09TxGDHyRZ4n6Zhz1xr/LMswJgE+lFYcHu9z+qhludzirSUrC4rKEF0CmwSfupq2H1hvGjbbBiEMNri0IMsU8B5C8qt0Xcrb9EOPBLq2p+sHoiABllxPt9omn8Eon9ZaJxkpAq3i2K0drj313trRo5Mu3ORNCBg1ygnHjz+OIJxo/YvPbOzehJC6QSk7WpLr1I2KpG64dQHvXygQxAhl89HTO0GmFf3QcPb8CZ/8+GMODr8zyv3lOFlOcnDNWFSHmGLHRtBdkWXo0VOxy+4TMS20iTqevCFcS1FA7G6Y8X0otetTjXRfkiR+lx1/vWGMET3K7dVIt09RZikDMKadHEoqirL4SS//v/SIhDSdCRYxvlelazBJZokctYudQ+hdkZDy2rOyoPAO1w9InY/ZhgOP+jPar93gG7/4Kod3jwiu43y5wveWopiQ6YK8NOzZkn6xIDeJAF5nOZkUzOczPv7hn9FtAyaL9N2WaVnTDC3/8l//Hp8/+IRf+bn3mBQ5tl2xwdN2nr2ZRNvAn/3we9STQ4KHt+7dRAB7+3uE+88Z+p6ha0dJkEHrHGdTk6quJ8zne0gNjx/cR6ocqSyff/6Q1WrFwbe/yffsio/kOb/xlW9wc1mwWEriJhBsi4+RXKRr1IWAQiG8RwhL8CUy+pQfKyM2WMRRwb16yq/Pb1D8wX2uzhfosuVw/4BSOx4tN+zljno2J263aKlYtT1BTZjcfJfl00foQnBxcZ/MWKZFzUeffUQ+mbO+uEDxGYc3JXk5SxmetmN2cJv11Rnd+gpdFsS+ZdN2rLeP0fFjCp1T1TnVnW+wOTtniDlmesRmdYYfznBDy8Gi5jj/BsLUCGmSd0mt8Pkc8NhNz/bhms2j57huhBkRKFR9nSCgpUr92hhS1A4WogafGk4IjVAGnAPpUdLjyZO8Kgpk9HhnQG2IlBTWcHO6h4iwbO5/qXvi+kgPaSICnZUcv/trmE/+cx4NCya6ZHl6gXU9IkicFxBSBm0IyeKSZaCCBTlhu/yUSGC52qCrPEWNwHXnmnE9EEJw/MZ3kN/7I/p2QBY5RnicDTgn6J1GS7i4XHHr9gmzg1cZNituvvneF6pbIWB+eJOzs2c0bct8cYxQhrIu2VscUOYTFifHf6lqRhC58cprXDz8c5TMeX55wd5kSnd5icxqNtstWgaUtMmXH0GrKc9bR7td4qxgVk85fONXETp7sVHYqYvGv5mf3EXJCh8Uk8kJV9sN+1FidIEP2xF6CSJEfIAgJER4cnrOqvXIaNn08PzZlFtv/RJFvffv/SgjgJScvPFzfP5P/5+4bUNeGCaLKatnS5hCzALOJuhVJuLoO05RknFs5jZd5Oade2yfnlObjDO3ojr+2shwuR53A5EQK8CB2IFuQB++R+49YXXG5fOOo2+/SvSetos0l0smxYANHa+89ybdk6cE2ZGLlnB5Ra0Nz8/PwDsullvyckKzWeH6FWWR0TZbiNBtJZu2JRt9ff2Qps7+J4Tm/GVHXdfE6CmkRGqDEgLnUqTWar3CuUBVZNSzOc1mlaZfLvmr28GijcINPSY3SASXyyV916GUpMoLzMxg7YB1gSANR3tV+rOyzE8WHB9OOX/SUJU5zbZj2yYCcGYUZBIFTGYl89mUR0/O0D75IqUAQqDMcwbXUxhJLjKEUiM8VrJsLQJYtwN70xkXoafIckBS1fUoQXUYVeCcxw4WpCQzGV7HZDsapcMuOFQUTOuSrgOtDZuupzCK+bTk+cUVCIMfOqRRdI1lFytaFxnb1tF2jrSzSetsXST/rEekPVXSKRNjYG82Z7lcEoUd9z5Jot00dpzqDxgp6d3AphvIlMENPQRPjCOPBkFdGLxXCAR5SLM4MT6b0951hF/GBF0tsoy27/mZr32N9z99zGzvEK3Sv7m+fEqudbouYiLLIyKHiykqBj769CHOw+BThJw/WzKdzGlUQ54VuKFnO0gyBGWheeYDoY0ola7jTCoyk6OzHC8EVZ7gmlIalJJp3+a6RB23FusHCANaFxid+A3OCmTp//0X/E9wrFcbiILJpGIxnRFIE9Z2SEOn3tpr2a5zfiwyYVYaZtOMerFAiNFHXMzpu4Z+/RjXNRhjMLlidb6k6jc8en7Jx08uMAqUSjWAkoppUTLfm6OLnMmkohwZRFWZo5Tm2dlVggMag0ShhSIvMzrhkXqCMRneWa4uL2mbQF6WrFZbilwymdT0nUXE0TKrBE3fEwNkRc5qvaIoM7p2wA0OyIhKJ7WmjugIXohUTAuNJMG4e+tYbzrWmxYhNM5ZJInj4ENk2/fkuSZKQds6vvrOe/zqX/0t3vr616jqmugjbdfy6Qef8s/+0T/ks49+wCAHBmCwabrrvECoZDkanMUYjffpeji6seAXfumXmU6nZDrVWcky2ifwbZ6jtEnDwBAI4z6AmHK5I+N6oNU1iKwoUsGaor8MDJYhhDFyLdVgSqa4567vcdYn2Xdn6YeG6AMTP0VpjfKO4D2CJHmPcQdRjoTwxQSkF4rdhFyT47QdlVTdMkSWF+csNyu6YWAixpjMUeWbmnoKGXcpSalB8pMcP3Hh/fj0PifHN9EYsOnhqWWiUyeK3M5fu/OIhes395KG7PrPXyiW4HpCKYVMtNcYr8f8u01cCMl3tDtZxqQPeneEGK+hbVrtZIBjISclUhkgdWPbzZa+bSknFUeHC1Znzzg6OmS+N6dbb6iqAmJktWlwztF1A85amrZNxv82Uk2mZFogohthJg0xCrxN3WllMrbrbYKVSU0/DCitrz/84ANSBdA6gcIGy9C0NF0/NifC9cRXjO8NmWJHxDjeFqMKAALBp/OcwCsJUOS8IzPpY06qAYXR6oWsyLm0QfIvQAeJJp8WkuTnh+Ajq9UlH/zoh3zru99Cm11s2M5z/0Jq4pzFWjf+viR3zHSSE107DmIEra8jx3Zy8BB2Od+p+N4xA3hpYh9iTFEciOu4sFSIpyZLei1mLNLTexpF7CkWRar0819Sbq50jhs8QZV4PyCCJqqAxBPDWHybQHQWMSiiStejyDTSazJfJqVEEAx2YEPP2QHkX5lRzCccHM0wMqc6mKAiKV/VkGweWnN44wZHs5J5qYjB0dqeKCSHd17n/T/9t8hNi84mXFytsYPkZ372HT7+5Am///0P+PbbJ2iZKJPb7QXrJsF9hDTcu3VMsxwoCs3l+ZLJZIEdWoa+SwALQGqFzjK8U2gjObpxC4GGGLhx8y7nz5+xulxSTioOTk4423ZsNg3Dessnz/8lrxzs81t33uPtZk58HJC9xfk+XUu7pkWUIwRoAOlBaEIsEjzp1oKDTDJdLOiefsTFakV5BJuLK5rzB+ReoIyhDEtkKZH5EVMn6IVmduMOykxZn31Et2no+46u2qPafwuMYH96h+3pDzm6cYe8EIRhRZkXYLdsn36coD3nFZkPtF3Hat3TLB9z78Y+s8UruPUlKq8wuuD00Q9ZrzZIBm4e1xwtTjBlCTKjt4r24ikMDdVc4QOs7j/n4gePEOsGgyKXEiPzsRnZo1VBCJYgkpScoJDKIJEoEiGXYBHWgsyRCIKXqDEhImqJD0m+64MkRs8QoZCCW4sFUrovdU/sjpetQVHAKz/711n84/+cpyvF8V5Ff9Exmc/SRmb5ZIydFGRBJviPgWg7ZHnE5fNnKFWxbgNffeMbI/tDfOH37I7F7Xfx7ZpVs6bdfsTh/BvsqwzpPUKW5EYy29/n2ek5sQBPxq/85v+Ul+Q2IKDav8XQ/EvM4SsI0+KcoB0Sk2RvVlPUfzn9XQjB0c2bRJ82kZfn56j9Cd02MAw51gp61xMHgZLJJ7hdbVmdK7KqIPie9dPPOfnKz1w/s77wlBrXtHpvj/39V3neP+Hxww+Ixxq3XrM/FTzeBEyR/LJGgA0xydG1YOhTFNiNk1uw3rK9vOTVb/7GtV1o9x525/Zl2fnJO7+M/Kf/JXo65fH9h6zIUbOBadR4F+m7SBsCdQnJDpfm2EoEXNtwujnFbQUhOk6vLjl+7WepZifjmwrj12SJ8KFPMVcKGFv3cnYPRUEMLfO5YXOxQZTg7YZmecEwh0EG3HZJGDxXQ0O55+iXW7bNwGa1pmt7dJ7TLDf84Z9/yuvHHR+fTvFRcLQ/48GDhyi1RUdLEBURQZFDVRl+2qOoCiZlBTEwKTWXqwFrPDE4BufJC01R5swqTaknnF+s6dxAiJ6iyJA6RfEURQkxYrynMJrgHS4IwFOVBYjEXvFE5rOK1dayuRqwzZLpJElNhdbUlUHLNE2OEoYu0DY9XWfTBtkovAvkuaKucrqmZ1KnYvpgb0bXtskXPl6bxaTCDpbNZpmimYxBCEFpJE0/pOGKFPjo0XmGEgofPSI4ZASHpyg1zTYQA9jBYX2SGysp8CHleVdFSec8QudpQJOmH6mYF4KyyAhdKnCFUOzvHbNZn5MZTT+0KBlRmaYuKpphYNu16DGFxUefMqqlxMaIj8n2E4LHOiiUARFHr38gU/oaHmW9JTcjtFBr3DAQg2d/fsDWubT36ds09RdJThwIfPDjH2CdRQ4apzSbVQZeYvISaVsqUxGItNZyue1YdXFUExiUiGRF+hoRGO3wfgACxwcHXFnDqrmkLifcufMGTy/O0v93jiAk62aNihHbbIDkH1ZaU+YFg4t8452voQ9f5ft/8M8oVMqcjsFRZgWmyijqLyc1t86zv1hQ1wnqNnQ9th9SBB4SlWfkRcXgLO22QYuUfa60QSqBlgad1witsf0K0V8hCQw+grDofsuszvj40Rnv3z9P1huRQG5ZpqnzIuXNi0CmBApHXeUIMq6ulgx2QKmccjKlKDJ0pvHO0Q89JkvgNykEUQvM8SGryyu26y3OOi6aAaM0MdjESwoS7+0IIDNYb+nbJFsvigKtJOtNihnLiwypNNb2eJsspA5LZgST0jD0HqVTA1kJw7pxiBCxrhtzvA3OR+o85+/8r/83fPc3f52qTByhQLJw7e3vcffePX7+136BP/3dP+AP/vXv8ujh5zx8eJ+ub+gHSyYNRa7H2gC0BiNz/vrv/A57+wfpHsiTXbDdrAjBUc730jmNgRjEtSotWZ/UC9WrkmmwZ21qqCqVou2UGhW0ghg8Rgm6mJgHfdvgY8BkeWpQLa9QOhHa7RBptw2T6QxvJYPfcZzEONxNNWoSVMeXCu90LX6hAJcgVBrMPX/6lNZ2vPHmG5R5wY5NFkICFhLBDjYpfqUgeIsUP1lJ/RMX3h9/8j7boeG1O2+mDGYh8cGlLOTdJmssxABkVONDKmLti81cmnC/2Cy9DNIyJuXpdV2XXtlLkundT+wUhrsp68snTrJTxqi0ZRljteRYhMexoxFJ+eNGaxZ7NyhKhd0Yjg/3qWcT+iLHKIlznm2TbgiTGUIfsc7Te0/f9WwHT543zKY1VV2yXHZYJ4gh+aaQAusc222DQlKVBWVZ0LQNPgSyLGM6mdD2Pe22Zeh6nE30bm3SIhCtTe9qN4X2IV2YuwsnxjR9Hz8DKRNlfheB4INP8guTssEF4jqeQCjJ0Lt0Q47nOoakZgghohQvbbzAE3j+/DnOOeb5BCnB7Sbl7KbdYZSuj00DEhgj5UO+gJzFl5oKieq6uyleWA52E3J2+fHj9RNDurG1UdegP4RgcAObzQqpDEZnKVNbCEL043UX0CRq6C5e7UsdMWBqCaIndJ5ASEAORGpQSVK320PoLULvJu4ZUgVMCUOUiMGxabec73vuTx7z9OMLfvkrr+H8gCQwyTRKkh7CI0xlWlXUWUGZBcDT9J7zVcvyfEPXtBwd3aNZX7KYl7SrU+7cPGI2rZhoePh8yR98/xNev3mD6M754+99SNt5fuln3+HdN99AZgpzmDE0W5abgaBKlEhNC+8c2iQ6fz9K+KeLA6TR+GiZllM2qxVPHz+mns2498YbHB4csV1fUGQly7jm4cef8fT5BdYUPK8P+EYxZc9KvJeYoAhYFJEgE1yHmOTlTgRMdPROkb22xw9PO3LfM/9Pfo7m3/6Ay4//jIPtEpVvWRy9gqr2qApB8+xDls0F5XSfu698ldBcoPOBxbSCPc1mmNA7y/HRIUOAq+XnlOU+Q3MK4QIZFY3v6Vdrhu0l5WyPMqvIFzcR2nB09xZPY8Hz80fU5QOymxUXjz7j40/vc7VZkomek70Ze/tvMVvcoChm+JCxWV4ShzUhLmguLlBDR//wguazB3QXF9QxySMRPS6kjnsSWWiECECKYBEYhMiJMiRNi4xImUMMSAweneBxIhJRoFoQJQRFCKmY7C0UwnJzfvLl7om/cAgQkoNbrzM9eYvmsw+JBxknd064WPWcXbYUwo9+5ERtvmoU7tKiTh9xfO8229fu8PjJEqi48/rb1827v/CbhODw5C5RT2g3jv3X36TpkwJHSMMgprSuoLEarRWb9SW+fI2je2+lRs/1K5bMD25ytVyxWDg8EUQgKyfoep/jG7eQ+i/ySBLkLTKZTpDFHqtO0YWS7VCzfjTwx5+e4W2LVhapM64aTzQ9s5M5Op+hswVZMaOewuT4NUBeJzf8O2cUpRUnr73LgyffJ+QzLrcNbZRcfO8jFAODS4W9yaCLivsb+OZXDU/OpsyPDnn49IppBtn0hINXv3n976YlZXzWjg3c5BtVVId3mU4WfPzojGg0/SZiY07XCbbCk+URFxWdlMm7P04HuiHQWklUhs3lFbffuoG1gdntn0drNa5t6RmeDFOefrukVBNQBaOfBWEq8pOfYfPgn5BNap4+PqOrJZO9fWYnh1yeP0TtB7qrDXkhaB9eMuwt6LIj+qan6QC1oNus+eSTDziZWQq3wQ4S21medGe4fA+hp4iQ1srNtuPpJrLof/ombZEZYnRICdu2pyo1dgjYqAFDVtZ0mxXLdU9AUM0myHaLNlMykxgNLpKgaN5ShIj3FqkNuMBsWuGtI8sL+sGT55pMCXReMgwDmYrs71fMK8P5mef8sk3RVEGA1Nw4nrBaXjCdZJRFjneeR2frcdLoU6EyzVGZ5vzsEoUixET+jSPYNDcG6wZEjPSuJ1OGpmlApaGBDX5sFIKLPUJrhqEnupAmlCLJ1p9frVOjXFjqYkrwIrFbXEDpeA26U9d56A5hBEJ6BufJZIJ29jayvHoGRKqypLeaIDz4yGJek/cGHyJdn6baPkqkyWi3G6SU1GWBxxNdAlSF6Mf3mWNxySuqkzUGII6WuujtmL5hsK6jUBqdSab5lFuvvMKf/+CH9H2DjGBDsjIEmSjJnzy4T5GV5HmGjRnW96O6MXlNIz1giC5SGM18WoBSODRlOUFlJU3fctkEol8zqWecdU948Nn3WezN8cqgqxnSFHgXOZzmTPZv8v6H7xOixbVbejHQdR0/+tEfMD94zNCsMHVFXU+JaIIfCCiUb3/q+wFg/+AArSKb7TbZEqMgz3OkFqgYaZqOvncp3UhqtAwspoaqzMiyEmMyIODbNbG/hNGiVOY5kgHnPJ89fs73PjlDK43RCqEUCEWRZSijqaqSTBu0MuTFFBtN6v+pjFwbMm1ou56m8cgmEdVllBBgs1ph+44YHXmeUWSaXidAXxVz2qYhywuE0QyDo9v6xFYQED2YLA2VklJ2QKks7WEHSwwDRVkk6J9MXvjeRqwHN3i0giKvaLoegiOiiCJDyHCtqnzvm9/m27/8HXJjqCbTFK1rLdY5YoyUsqQsCr77m7/CL/2VX2cYBu5/9AkP7n/OZnXF6uqK9WrFj773p1xeXBDwfP29b/DNn//5BF7zLVm2j7WWGNI50MaATFwMGKOAR67Tblh2PfDzjuAHyrJiN7YToxoaGG2sCpAUZT3S6TN8THL0bt0zND3VbJ/1epvUMioN1UQUiJhAysBYcCeFYIwvYMy737XzlacGQVLxuqHn0cMHGK2YzhZokxOjHJWGSbHrd0riEIg+JI//T0in/YkL73ff/CqOcL0R8C9JxXcnV8R4ffKuI6akgrjzEY/S8Zd2Tn40qmshUlSUSScmBJeioVyCZe08w0ql6JuoFLuM72RNeGHMh3EDMf6d1nr038mxaBXMpjOePD5lGAZeeeUGN0+O2T8+pGu2yUcXQpIqeJ8Wk7ZjvdniYkwPSplgLG3XE73l/Ow51qUbpJ6kTmXwjmA9RElnLVobBrfBBU/TNEyKEuUsQ9uOEWbm2pdcVSVd2+KFGOEKqbGgd5HWjCCOGHF+52VPTQ2tkhRCMgLrdtdCiAgZXwJpjGS+yPVnGcaQ+OTbjdevRwhwzl5PmCF9TjHYaxjc7tg1UuRIFEz+6kiik6ZNVth1maRMNyhxVE68vJFNgLVABKnSFF54hEjX0uCGUZI+Auu0Qeo8yQJdWrzTZ5+4Ad6la0oqz5etuQFQBkGGVD1WjioOGwlaEJRDWIWoNNE7hAtENIiAkBFpBCpITJ7RNisu/JYP5GMu5MC9229g20s2l4JiWhCFZeg9VTnFB0vbWbwHN4u4qMmNwgJCF7T9OWdPz1ivLrhx8ybbzQPW6w0+KjZXl6wuLnj66Bl5pjiuCu7c3KesCrbrhvW6Y7ArbMiZ1Td4dP6cwcOsyrl9NOfs4phHp0+JKJQMWGcpigSsunj6jNv37vLphz/m7Okpxzdu8t43fwaZabbrFXmWYjo+/exj+q5l77VXQRm+112g72jefiiYLw0haJTQ+BjQUQCawQ8ICUpZPI7OZMzvznj30PCPP26Iz55wdv8TdLtifjSFrkdqhcon2EwS8gWxa3B+Rawl68srChXwXYu3PUpAUexT1Y6ZKlk/Pmf/5ITgFetlx9CcUy4W/PjTz7l1csj22TPqwdNeXjCfHOJkhsxzlleadWdQp/cRuuL2ndcJjz6nyjreev1NDm6/RRYl2krCcIkOA6KYE/UM32n6x1uGZw1x2ZADQmlc9MRgrlMIjEyqHSUFIpaJLxAjSupEKpWa6NP8OyiBSMno6T5RlhAVkgm7hUiNz4NgGyQZuc/++674/5HHKPkEhCq4+zN/g+Pv/wBkxunpU5Su2a4jk0WSefY2EqPkchlZryXF488pXnuPTz855e3Xb1LMFlSLF77nv8yTXNQzTl77GqvnT1k+/ZzSvEnfefog+OjhBd2znkZYusuWW6+8gi+OyYqSL9LJI+X0iOn+CSIrGbafMfRpk3BysODWq/euv/cvqGZiAgcdvfYukw/+gL6o0MWE9cE98qzm537hO/zpH/xLDuWa1dklun0CQ0e2uIlA4ZtzbvzMf5RAjeN0W7xUfL94z4KTN76O+6f/RYqlmkzor1Zc3vwuh3sTbh0dMak1m8FTfvbH/Oh7n7JaDSzmhr1JjrhsKAS89p3/mKwsdy/9L5xPXhKsSV3wlV/42zz8e/9nrrZw+2SBb55wcbHizlc8SmmMkhiTFAsJUOU4v5I8ehpYqo6fefsGZTWhed4zef23IAwgC9LalZgnBAuxIUaNYJp2qkBEUbz+N3D/6L9EnNxkQBOFZLXpiXKD7QLlLIG6osoQxZS+9Qwu0PWWZrPl2eqMKDP2sx7VXTKse/zWYUTAZbe4f6HRyrJPT9AZS7eATDDVP33hPZvNeeXmlE8fnKfoLRFxMqRopyzn7s0bPD97Sts5ZosJB9Oaz588YwiCxaTGu5Z109LbMO6nBnyIVEXGoBzRp+a584kn0zQtbUgbQWU0XVA8fnzBqQwooRKcMSqU9mPzvUVIiXPQdKmwunOyz+VqPXqUM9arniiGtM9QEpPJMfM2RU6qzHCwd0Sz2VwzVaRWxOgxmWC7bRhcGKFfkzQ0KNLeIniH9YGu73j3jTss1y2nZ5fkCjoZ6ENSSRQqqSytTc+VSWUIIsf2A8OQspBjFLgoyIy49omuG4vWAqMKumFgtd0QYyQzOZNqwma7xHvH8d4+fiTJOxeS/UEbjH9hU4shqRsZvfNKRqJSOO/JlKRzDhkDarTKVUUqygSRUkfKzEAswTmqTNMPjkLLlBMMmDGHWBmDFwE1JrEorZnPD/A2IJVCYfFS44eAySMWz9Bc4W1PiJ4sK3BSc/vum5ydn3O+vMIOV0jpUkSn0Qybiuzqgqqe4kJEV1Ok0pg+NVC2PeTVAqU8IKlyGKxhWheshy+nFsxEQGUa5zXBBbwT9L5DVgkIqI0muJ5pmdMZRRw8hZEUdUU5PSBqTbAt0l0iomPTdokm6S1u6Lj/7Irvf3ZJDOBUJIswyXJUlqFkpMizkXkCJs9TROqkZL1c0rcNuVEJYiwjdT1h6AdCiFR1mQYqdoykGtqkFBRcA4d76xgGOxbJQ5L4G40Yad5KGYLvwXkkkqhUGui1PfNZjY+RtuuQ2pBnGuciLkDwKVJNqsjghzQdVobeJTqOyTJc8Lz+5jv89b/zP2dv/5iingICg0OaMVt7jO4iRnJtxnvB8PpX3uDuq3fpu/76sT8MHR/98Mdst1tuv/IK8+ketm8Y+i2b1ZLZbIHJc6TWaa0fQdm7dKrdqrpTrUJ6H9ENY752UhLtIJ67YjmEgFAqyceN5813vsInn3/KbLLAeYs8OGK73eADTOcL+r7h4vKSV+/dZiuga4edxvq6FoxRIKJK7IWxmftiQMuoshQEG/nwgw8YbEdmqqTeFSS157gW+RgI3o8At0j0ES1SrPBPcvzEhfedO6/QDQNS6gRVc/4asCViMqoLIZCjaV6KF3CXVAy/yFve/Zz3ATf6r7VM+ds7ynXwIQHM7EA/DLRdh3UDeabI84KKCVqPMvNxirqbiyeJcvpPKXk9Ed99tYPj93/v9zl99pyTkyOyLKPrHOfnS3zfUBiNDxLvEsjBB5uyINsGxp8fBovWqSC9vFzTdz1FVdM7h+rkmNNp8dHhgqUdLIPbkBcZfd+xWW/TexRJBphlBpUZnp9dEmPE9sO151nsJvpjcyMBkhTBxxeT2zT2RmuBFslP3fV9amqMoAMtJS6mzbnUimFIF8kuk+4FkE2gdJJdpDivBMOQUlFVNVmeJT+IZYSm7EAK6VBKoZS63sTtiveXbQY7pYNSKX/PhzAW8F+knu9uQq1zhEwPrECCkgiZfl4pnTLBs9SlHIb0ee1+Z4olK4lZGBHQQAzXJP6f9tCZQihBDBqhPMLGBOIwGrQHWSRvfqYI7UD0qeBOMpwkv4nBMgjBY/+EH/WP+err3+Fi+5SHv/cRb7zxVW69egdvW66uGm7cvUNWGtq2o286Wms5WMyZTXKaPnlhylmJQ9P1A10byIs9nl9+jsBxcnTA1XrJ0WLA+cBy3bA3Kbm5mJIdTblabTg/W6GqmjzfUmhFyCXHB8f87Ne+wfzwJhfPn/P44or1as2m7XE+kBU5PkSapuH56RMOb9zml3/9VyiygvuPPufJ01OOj2/w9OlDhqbl7quv8fbbXyU3Eud7/nyz5JNuw+9M30JeRYTwSYoYFdClZ05cIXxGFIpG9cyEZVpKjDQ09pI7R3tMxTPuvfV1Hv/5P0WLnsXtO6yfPqQ+vouRNf3FM1ynYHKL5bNTJnv3CFfnaCOZHt3Bdx3n55+RiS2xOWNy8k3mZcmzR59R7d9j/65g//iAH/3p73LWLSniU/b2DxCmpJaO/LDm6M7XiGefUeSBSQFF9iqL2ZQbN15BS2jPn+DCBlkc4sUeOua4jcU+6+nvnxGfrTFek8kcN15TAjeSN0cAoQApUxNHhSTRDng0mkBEqgSnkjEmj/PYsAohR+HQWhFiRlQDBIka5eC97xHxy+WzfvFIS58UkT7A29/5q/zR3/u/8Pxqza1phjQ5e+YKLaG3yRdsQ2rPDS7wvR98zjuHb/HKrQWNC7x6+x0mi/mY8/3FInFnc9JCcucbv8Yf/N3/K7fufoU6kzhZEIKnKPfwxRy/HrhxVCGC487xIXlVvnBDja/bGMOdt79LkHMqI9B9w9HxbV65fcz05Pi/Z+oORMGrb32FD/7NnD44ri4vOPrKdxAIXvnV3+H3v/cntBHUUc6sjRyVp3SZwRPJQuTN7/xVxHUr4IV96AvZ5UKwODrhxsnr2PYM5waGrqV+528gTI++eZuzs/s8XHnevf0mJ0/OODi6pLWkyWO/IWY3ePfX/mc7k1Bq3caXuSsvfYzjcednf5vD3/t7eN9TyI5MQ31bMZ9qlEn0dKUFUiWGpZIKZSAzcHuvxEhwvePw9W+wf3hA9B3oGTEGRPSjpcghZCSEHhk8EZeUQ3jyGz/L3p3vsO4f4gdPyGbkMhA2DTpLE4jgI27wPD1dk1cl80CKrSwO2JOOZ2uH6yy1HehD5K03j7k6a/lsveVkYnh01tNlPk1vTCB4iRvOfuq7YLAdD08tUlccLDI22xYXJUWRcePggIvLc9re44Pn/GpFbyXzg3ugNGFoKKuIixKUxSiDloJhaPDRkXmNEikTXohk89JS4Ud7GiQ1nJQSSYI9laXGWpeaeTJRmoVOOqO2d2jhsG4gM1miTQMmN+RZgZGw6VqqsiZYRxSpuN2bzpnNJjx3HZ2NECUxDhitcSGg85y8TCRhGzxD36KkQSvBbFax3jQAfPrwMdZ5tDKcXy2ZTkv28oLzpcfopFIMY5M+qWQCrbcpJSbGVCyRaM2eyN0bJyxXW9abNb21yBBp2gSR7dqWmyeHbLeBSOT8/BkpHSagFQShqMuMZpBoqalURkRgh45C55RlzaTKcboA73l2eUbhW6piApK0Z+0t3kYg8MP3P6TMM6pM0bYDUkRUPhbtGiDR2pU0BB/QIU33jFJoGXDdmsEmW8Fq0yC3G4zJ6DpDlmdJGWZbIoKt7ZGbK9YiYrKC+WwKYp9mu0EESze0XK1XzIkUEvKsRug8+b9VTplLmm6gi0l91rVXuBZUlnN5vuJLxnizXK7ZY0qe5xSFomsdMUhW6wacJS8MMcLVlWdWZWSTNHWfzPdBG5xtUG7N0GwYXEDpDGyP9wP3Ty/50cMrQowU2pAVOcZolFYYo9EmkamNBiECtlmzGlpsc4lRkrouiMHRbbYU5ZQYEmg5OIdzA513EMD2A0YLEIZ+GJAqokxOrhRGG7quJViH67pR6qwSp0YbkDnNZptA5QLkCE3bdgOZSSwBITVWJF96pnyCNUvQSpNnGc457BCZT3Ls4HHO8/brX+F/+5/9ZxwcHWCyPHENgsD5kXM0qphQqTba+a8F6d81laauJwQiwzDgbM573/4mITi6JjUYqnrC/v4BWZasvqm+S6ra3d4feNEwji9mfy4EvLcEbzG6TNRzknomxBdDQK31uO/XeOP56nvv8f6PfszZxdnoB08+eu8jXdchRKTvB/p+oC5z8IHe2pTuEneraII6S5JdFyHRu+hlmQZ9IkR+/OP3Wa6WaCMghlRwe0dQ5gsTeTHmqXs/sIs8Vj/hjfGTw9VU0vw773EhFcsvR0Ndf594YT4XMHZFU7TS7iTv4sSkTNKMJGtOspvNekXbtLRtQ9e2NF3LcrXkcnkJ0XPjaMFivpc8T6VM/uN/x4uWqN1J3iDGiwrGrDXnWF5d8smHH7K3v2BvMUu99rwiRImWGUanSb31A4NNE13rPc5HrO2JPtG6g08AsdVqQ14WNF2HkJJm22DbDjF6GYSUZJmh6wfWlw1ujA7obaAIAW872nZD33f0/YD3nrZNeZQCMPpFHJaUkiiTJ1uFUR0gU1dHxCQ1ZzfB9unCNeYFGV2L9CCPjJEBMSkNdnFxUo3nkQTKEzFJt6RMBXReFAkENsLfXv7Md/78SBw/a64LeqUUWkAkpLzXEbrjnEeI8NKGT+20Idc/G2Ok65qkcBj92lLIBDUIkSASDObF96fJ/66w16NH7mXmgBBylDX+9IdAIzOdXjMQwpbgelyvULJECo9wHmFGRYJgzKNP29xAToxbrsSGR4uWn/nV/4hXv3qHZljz+f3HKF0itSaESLNZ8fTZOTduHFDNU9Y7gHcD663ExkCpJTZEbty4zSSruNp8SqbnzCczYmzZ33+N3zo85OHpAy5XHUWZk+mCzWbgZFZxcjBndbXl+x9/yCu95OT4LkdHc4TKOTiEp03Pr//8b9AMHc+ePkZqxeOrc/74z37EdrMhIJgtDlFa8cMffAACNtsNy+fPwCtevXub1++9Rb3Y5+BgwfLqkiI41stLwu0D7kfL69tA7DWoDEFA72jmeAYCIfYI1/Mn/7d/ybv/u9/kt9+e8ah5jT88PaWe5Mi8pHGCmgT92Lt5g7IwdNRs5seIzKCQZAdHFHVGPb1F/epXuDx9TD05RG8dbBc0mxX7b9Yw9Byf3EYUFXdPbjO4LW+99+vc/+wTmvXn7NcLFIauPaOUUMQOrwdyBDrX7B/dwYQMk0n6PrBaXrA5e4zMz6jLfar9V7CtwX12ibv/kHC1RjtFSUUvLVFBLguQGqOqNKkiSZ2UhCgtQdSoOOYLktI/RfREMnofyfWAj6PMTUq81+PzYlTSiEA0JABZ7L/UPfGX3SWK9Ayc7t3h1jd+javf/z3yWydcnD7l3h1PlQu0hn5QyFzSuuTfnFZQTPZ5slpiygl69irSaBwkeNh1IRpxgB4lue9+/ef5N//1/4OnDz/jxq3XUkqiiNj8EOsFdRWhbYm6+P+z9h/dtmXnmSb2TLfM9sdff8MbBCwJ0AEki0Um0ymrRsl0NNRXp3rq6QfUD5B6UqOkjqQsjUplpURmJplkMpM2CQIgAkD4iOvv8edsu9x0asx1zg1UskZFAbUwAmHusXvPteb8vu99n5dbL72GEOanCukEbxRs3X6Do4ef8I3v/CO+9M7XEOuH7L7+m5h88B9Puj/3+wLsH+wzvvUOnzz8F+AbytEMEyqyTDGbDSirikfrEdvZlNHghKePHzHau8PdOzfYuvslkj/6p7oB//F3UoJXvvptnj78PkePP2E0HuG6NabIWS8v+ezZOW25Q1QFURkcitOzDVNZMhllvPIr/4DJzh7QIpKZOkkSf+o3+fwVMIMhX/n13+HJf/19YntJtjdkMPEo4/rDmyCGjBhapE8NEiU9ThiaTWB4sSBswWs3bpNJi3cOlZMKbwGgCa7BtoGYd2m/CBZEjm8vqE7+lnvvvEm9hvuvbuMWl1wcnmNDxVYpQacmvJSBrW3NsMgTXC5ENlXgwaMj2tByy1aMBwGTZbT5fbLxBXvhiPNqQ2sFLRIfA7PRiqgyyrj5guv9P74yleSmzs1RMU82M+mpNiseNxUyLzB5SaEzlJbgAx5FpgwhWupGc+fGFlvTMUenl1jncE1SefmQWBZV3aBlxKic4C1NHwcUnUMZSVmW0KeMRDq0kiA1znVElw75WkkO9masF0uqNiAUqD7L92Bnxmw85OGzEzKj0CZNlhGS2WyHulrz7HgJRLQ0SAUiprgjKQSDzBBipMw0OstYm4y2XuC85HK1YpjltK5DIpGZpLMWpSWrqqJpWgpt8N7ROI/zDqVgU6WzSZnnhCgwuqBu19fJN5LA2ekpEZF+Zp/2X6FUevZpweV8BcRkSyMlBhDS87VUimk2YScz5DonzwtwjvFslxgC+7fu0VnLpm5olueUs5JB0U8pJTS2ZVMvcXhO55doklSY6NBS4oPHkHKiG+vJdcG4zPEC6iYSpKWfWWBjxHWWKCJ11YBIMKzOtQzyAV5FjJTUMalDpYiYosTbgO26ngUUmMy2yMoxeEdVVQjSJDfYltxkKX4tz1mszom2QQRPzDNkDOTlACMFaxfw7uc7Ow3LIY2LRNeBijSNS3J965OkumqZlJpypMlLzWg0QeYjpB7gfItoVxRlxnptsL5JzTdneX50ygfPFsQoMVogszRkyrRBa0muBKVWGJOhtcR5j1KSMtMMB0UC/0nIVYFtW3SmCTLibcBrKIqM3CsQkjYdaAm6t13EQBQe6wMCR2YypJEQNSjJZt3S1C0m63AukOU55SBZws4vNphCMRikxuFwOGQwMMQoaVsLIRUDw0HZU9k1XRdwUaF8ZFzmrKqOX/r2LzOejhlOpghkSn9qW6yzqV4LqVawsUGJiCkG10NKeFFjIHtaf9vSSvCdIJ8anPVoYxiNRtcpU2kvTFDra6WziDTNBqNzpNJpONuXikJIsiy/tgRf2YxiPxVP0OxkVTHG4JylHBa88+Uv82//5N/ibFKg+BBSDeMdMQpu3ThgkA3pmpZBVqKCQGYpijiKVBuJHmAXQiAq3fOp0vsnkMwXcxbzy6Tc9hFpDKYYJFuOEInsTkyyY/qM9dg3PPt4ui9yfeHCO21mMhGjr/xtkWti+FX9fa3X5wqGFfHx6mPSB3nfE+z6qejVx9XVhrPzE548fsDh0XMuLue0bYo0GAwK9rZ3MEqT5SVS6esi5mqCegVWu8qrln0xmHzFV0HokcNnT5iNcm7s3k2m/z5/9PLsnNlkgMkGKWNbpqzoqq5pO4f3qVsVcslqXeGjJ4bIeDZJMDjn+2D7wHK5Si0frdHGYLRgs27pGpsKfSW4WCxBglRwfrnER2h9wHmfUDM+tYqk1CglejI3yB6WpnSKXBEhyfoQCWwXgscT0msgZQKcCYHoqYKtTVIw5wM+iN4GkA6nV00RQVpknQtIEfrXUbK1s309zY70i7mX/Pvg+4lbygiXMabvESMiBEyWvJVdm7IZr4p11UtSXAhoKdFa4ULAWdv7sK86VSmfu5+bA5Lg00b8328AfR7almTwL4B+gV768nNeQibPkDIRKZNXxbn0EAgxIJ0lbEANC0KmEM4RW99PydNDbtl4LrLI4M27qIHBDAru35yxd+8GrrEIpagaic7P2cw3hBt7zAYj5HCA6zqcB4Qnx5MRWJ+dE3yknA4Ico/PPvuQg/0Zm7OWbvOMLjQ8PjxHxowsyzm4OUMVK5ZVyw0zZHua8farJXvbbxFUQZDpPhsVU4bFjJgVhM5iQ8eg3KPsOrZmo/S+doFf+43fYjSb8P3v/xXz8yW7O/u8+mtvsa5qXn77K4ho2d29xWp5ynj3Bm21YJQpBkLyw6NzsmnJrdOADGk9RnIUgigSq9bHDo1i/IP3+N5/taL87W8yn8DFwx9wcH/K5eFTVqs1szdvIbRBGUXnQMqG4SCS5yVZJlnrFVm3Rt2ZkY0K7HgH6yqK3dts3X+b+vjjFMNVFGTljM3lKc5eUCpJzBXjzHPnlZeQoqRZV2iZg9T4ao2IgSwf4rua2DzHjO4Rg6RrKi7qNVLnTMsJMmj8aYM/j4SzQ/xiQe40EgUikKHQKqJM2mhFbNM6i1fy44AUKf4kypwYEwE9ipwoAlL41AyTkhh1sl8kuy6K5BGPIoGIRJRoyReWSv2P3hv9/XU1qTUaLleBl3/7f8f3/uhfcXxUUPgOL3MC7TWrwXnJ9x/CN+5kbN2+T2EyZNeyYcDdl9+gT0Hsn1fpe/WoC6IAB2wd3OblX/5tnn/vD/AyT945J3jvwYJRvM+QQ2xZknvB7de/zLXEuX+mhaufW2c4VeIR1NWK3LfYrqMcDkiHi7/7GXLV8Pul3/wdHr735yxXp7ig8E6xahxWjBFywaZTtLElasnuwQ1cvea1r3wLZPxc0fti4v351zP9HV762q/ywQ/+Dd6uOJ+v8G2DECVdu+HGWLAWls36MiWRELh1fx+nh2zt7PPOr3wzNR9jilWJaVFd291DiNdAmqvHawiBW3f22BlJGlPgYoGPS1yErols3BbNRnB3f43OBFIoxsPAwY7m7NJSak9rbrF364Domv5re2LwCZqIJIaWqCLB9TDH4BAyozl7D7n49+y/OoD8F5Cxoz18yMfv/zE7u4qms7BpsVOL7RzT2ZCyoJcWgjSKIrZ88vAp91+XlJMM3+YMxQfMW8tIaC7Xp4yybd7an/H+haPbrBmMSsqfA642GxsWtUAbk6ZDvkNJyDONl5JJWZDlQ9A5bb1hMX+Kqc5xgxlGK4rccHFxyrPDxwhh0CZDCoO1DUIIsigSXdgHhIl0BLIYCQGCECgpCK4jy7N0jvApA3lclJyen2O9pSwNXdPRdZKd3SnxfJWinKSibjtOzy+4nC8IUTEbj9AqomdT5vMVdbVByUimk40vzw2BFG2WmvQ+AaB8YuCIaoMQihhCT4+PCYrqBUEEAklWLITEulREShlx1iOk6uFtfVSXVgipid7S2gohU3qN9wElHAhSRrMxLJfLaxWG7NNvvHeUmUHKjP3tW0hrybKSYTlhMJgk2vx4m8lsiikS3EoXA7RMzW4VIsJkLNZrLs4vCF3DZr3C1S2x9Yz0FptqzX42Q+WK1aYmSoHH0dY1ddcSnEdIQa41VdWm84H1aC0JNmK9xfkIwqOFIkhJnpWMshJEygrvnGVV1ViX5MMqHyRfLZbheEQ5GKPyEc5ZunqBq6s+dik1InKt0DhktFBXRNcRvIMQaOqazlqaukqKymzweSTGz3St65rOeZxPE/zgHeZ66luDh2GRs7U9QpoRqJLBaEYMHdJv6LoNq7bGVgvyvKCrKlZ1xQ8ezom9CkwIlaLSXMRLyyjLGWlQNGAjWiewWYiOGDPaxoJShNCATvniwbWJpaBSrGfUvdXVeVz0aJmSgRgMWK8rFILBKKPr2n7I10IUGJVqkkGZkRearosEZ/FdTUCRFzmdd+RKQ/QoEelai5QC13lWVZPOlHWHEJHhMMHClBAUJsO7jhADf/3nf84vf+dXacqcqmpoqhUEjzY976o/ExfFkOA1QvRDT5FI3jFErLUE23OilMCYDInA25ayLIgRnE3PEy0Tuymds2XahEnFdVmkffKFbgsUAqUMUSb1zYtze3+wRybYYW9NviKOCyV45bVX+PDH73F+8hzb1HibrLxXUZDi/CJFCEqJR5KbjBgiygfqpibLMrTRtNZhlMZkKR2lcyn/PDOG3BimkymL1SrVQD6yWa/Ji2HPr3LIKPpkhMTXitdVr/rCKtr/CTneLzxmWqWc5atC8MWhIG3MwfueYtcfwPqDErwAZ8HV9C/RtL3zLFdLHj76lHd//C6np+eURcnu7i7T6Zj9vR0OdvbJByPycozWGVL14Jz0xYgRbEg+Cu/9NYBNyhQHkoBfAikigzJjubjk1TffYHlxQZEZaps8wyGmrrmSqdhNBZsjqbI00ccUpyZSnERQEtu0BJc6MN515GVO0zqa2jIrBkgZEpjDAVqz3qxZVzXdFb28B6oh6IPb0++VYkxsL91LxbTu5RtKiB7Ln7LQg/DX8nTVk/akTAV2COlglV6jiPAuqRd8TF1gkeQXV4R6HwKRgPERrxPFU0bFwY0b6XB69YZGgRIvgAVG9VECMakdTP9n6X0XSRLTNxSEFNdr5MqDr7VODwAcQauUWY4gdLaX67zwjbv+5rwCr71YW+Ja7RCjT2vkugnRkw4/lzf/s15tvSTPpoROgNHoUQmrFt+n2ocIMkRi0yKLos9eV8njgqdrLbXxnMUTni4a3hCvMBiUDEqF6jx1ppBKIVXB1vYWniRNz1TOpAjMvcVajxKezlqO5hVdvWS9cYxHU/Zv3qZdLXny7BMyKQj1JctqxaZes1Nucfb8OTd2diiN4t1Hz3mM5o27N7m99SpFMeLCOzarFYuLS8rhkHGW8cGHP+T45BRbb+jEEYPRkCIfcXa+YHtnl9FowuHjp5w+fU7bBX7nd/+3/NKvfYvx/k1wNR+9+yOiMKzdivnlESEUbE2mKKPYcMr7w5otN+L5sxPeKm6hTKLneikQ0eNiep+39Yz44Bmf/T+eM39lj3K/gXbE+fnHmK27TO++lfIxhce5isLk+D5poVtfoKoLysEu+XSPuhNs7W1zegFlUaBCoNi9hd9sKO4cELqAVDmhmyP1gGcP/5IoPKrbJhsMacSSWa4ZDA0yWISTPHnwMZqOW/deRYxqpOvoNi3LecWkSAeCWOUsP3tOOOswbY1sUpSfkAEpBCYrwDoUOSKkSDCwIDJEUKkYV4IYSpSyqCCRWhKRqJiRfCYGRIrRcToQvEG4FG/n+0jIiCSxEwxG/+x5xf9DlwCMiGx8RM5ep3jp67QnP2F2sJ2e1z7RizuXCNKfnMDL2yX7suXW21/h3WxAOT7g4P4rXFGvX8RPpe8QY3o2Op8UNQoP5R4ipumWjwIbJd/74ITvvA4LN+Lle2+Qb93gKhYwFe+CNkREDBw//QDfNhwfH9KeH5G1xzA6ZDAeobXmf6i7fbUfHty5xe6dVzDHsKhrDGsuVhvWMSerGho3JsQWHwTZZAfjnzPZ3SW6hqA9MqrkS/upA8rn92JJXgzY2Tng2UOFlAYRKmKYcPDyVxCx4/D8lOrBQ2xMNg0vDCdHl+zceSWtr2CTb+2KHu79NSclxABB9nv31f4ZqDdpv+xEidEBRcR2kUt7QFu8w2A4J27dxi9+gNSQF4rRJEOXEw6fPuHOzRFERbBrojBEYppqR5koxbYieIm3G6T3EDoiGevjHzISNbSqb8A6jNGMhjnzVaDZZLhFzXCrJssNQ6vY1I7RyCKFZLOc8/Gh5aySqGA5eh7Y/fq3mJqOh0dPgIbnC8lwD4ph5KDz4Dxl3vHzJE/WjcUQcMFifdIyKBEhdOQm5VYLLRE6YnRqygs8nV2hKPCiI9eS1bqhLBRKCbZnI5zLWa9rEjTcESUYlSEUjFVJXTfYToCI5HmRVDJZxEVB29TUmwpERGmdpqICNut0oM2LlG2dnkcRrTOC92SlASFYrDco2RKjR+oMKXRKTrhan9FTliWdTY1Sbz0ipIGCMSn+TCuF8x1GpUK6HGiapmWQZSDSxGm6M6Ht2pRl3FsNffApH540+JkODE0naXwCnBWZoWobVH+OCRHa1lFkI0blFHzLbOcmg3xCdX7CsMjJyynBrnFmwu72jMnuXbq2JriOqlqy2awoJ1O2J1PGoxJVDFKsWJCs1wsKrdkZjSjH+yznq8TRUYrjoyOKzZJIkrZrKlxToQvNor1kZzqibi1dt8ZtVhRS0a5bdJTMtnc5X12iY8SIQFGUVNYhvENrzchIRuMJs50DDs/m5HpOHBUEfzX1BlVkSC1pqwW5rWi7K4VDSptMsQGS9abCzdM9HqPvByEOCRiToWRS3sWoIHQI+fPtEwGPUYrRsEhTy86hCg14CqMYzzKGkzEqK/HkDEcTvGuIzSWZFDw7PWdrVGK0olouOTxf89Gzc5oW8kyQG93HUuaUhWRgBONCMsgdZa6xMqOykfnlGqMEMkTKUQExrS+jSqx3qABV1eBjpBhOiEESpcY3Na5usL0n33vPeDZBBUe7XDBQGp9JGGXYLtUQKgTqEGhdoDCKy8qSFSU7O3ts788YT3cQCp49fs7xk6csqw1N25ErTZEX0JO+kTAwhnldYzRMBpJ1pcm14bUvfYmHjx4wW6wYz7YpByMEEdc2+K6hsTUmyynLCTrLSQ3kpKpVUuCipxcoJ69QTMWykBJhDPSNtSQX9wjzIpFI0tfdV6rnqPsJ+1VNkqKNf4oBJq6ayfT2T/+5P081gvOePM8ZjkveuHGTH33/h4SmwjZtkq4rgXaOaAz+eJ6I9cMSNRyhJyMYj2jyPCldlERU6fzvmzY9R2RSl3Whw1jPUGdspOiTtdK90KMhk9e7rzUDgHd9LaP4fLv8f+z6wneP7mOwIrwYNVwV1lwV1jHB0oBMKZSUfXHEtSRB9kVW8J5AMqtfFUfapBtltr3LcLLNzYMDbuztkWWavCgo8gF5P+2+gnwppcikxFlHiKkR4FyKw7qSFFxJj5xPWv2qWlMUBZPxHbYmIwqdJmFXWZJV3aTDhLe0tkky7JCw9y4InO0QxOsoB28dddP1BXoq2E1m0Bm0q5rVsiLLDFJptrYy5quq91cL6jrFhkgpES7BNRQS6z3WJTmDSvV4Kq7j1cJNfm28TJ/fS+4RSSapZP9JnwOUaaPpnMOHiOwXVYgRIa8I8ZEYRZ+fTk8N9USforuU1IzHk2uFw9Um21l7XTinSIDU5fYhFRBZ79eIJPgenwMtIAS+hz1ImUjuQkoylWGiwXlPZx3IPoP4qqkg0lTZe9+rAmRPK++/fA9qi/2UW6nk70nTL4sIkbZrvvCN8nddEYnrOkyWYTINQRAyn7qt0RBFIqm72qMEeJlAEQigcXTBciFWrGcZb779JmXhePL0KYeFZjLKMaoAYwnece/lV2jaJYuVY11VZCpHKsF6fYRdtYhsgHUbZKjRHQjb4CpFCAu8bwle8fTikuPjE8blgLXY8MbL91gvzhiUJbNScjlfkMl7xP4BqbxlfXLC8ccPUbli4x1n7ZKLusJ1LUEZxtMtWhu4e/seezdusKgqDo+eslmt2L1xm3e+/CUGW/tkwxIdCm7ff529m1NeXd/n9//ZP+PZs/d56jxvvvEK0+mM07PnPB5pRgNFHWp0AKMHEDTIiigMNhTk0rOjR2Ad7x89YfbGLsv5U87Oz3jtm38frSJ5cOjCsLhc06lVinpwLbnwqBhobUXjA0aXuOBx6w3RteR5hoyRbDbFDKdUF09xG8v8vIH8iPXlM2Z7r7K4OESvFnTdht079wirFSIbE2JHXszw/pKsGCNVRusVz0/PWJwvGR/coqsN7uGK9vEpuoooMozUaeqIwkjJAIszOQFPCIqo0tRSiBRDJVSEoEhg6DSFiD5NnbyIpC0zNegQMkHrZMThiAQ0BhkMCJ+eCZpeQvU/9xUxgM4V1YUnHLyBufyMzud41xJMomA7LzhaBY7nHY/PCt50a3SWs3P3HvVJi49JURPiVfhULzePCT6jRKQJAldVuMuHFH4O0VM1DZt1xc39GWcfnCLFGBfA5CWrywXj2ax/VKbn3rKLGAFLl/HJp5/x40+ekBvFW6/fZfHwUw7u3EGpca+64XPjdwEERN/1X6yWnD/5Cccnp7Q7u+CXPPn9f8W6MRw9O8dmns6vaFrHs9MjbsZjLp58xN5bF+RmhhCaGCTy7wR7pYmmaxsOP/kb5hcXuNZSjFZIDggxUC/P+Ou/+BNuxjMu1hWnq8DF6oxBkXF5scD6QPAdXsQ084/gQ4cW2XWz/Co+Ke3T4IPl7OMfsj58zKbcpV5v4KZGxDGNHNE6mGxvcXn+GVt5iYyerm2xDvRgwMH+iMHmAdXmWwzqJTEbE0OS6kkh0DLDtwtENHT1CjFssW0DoaVdHlEMHb6pUT4CLa6qyAvJ2YlhsTbkoeP0tGY2NDx4LigGHaPtBKhqm5btkeTL98bslWuW0XHx8Id87yTn+w/WvHl3i8Oq4+u5oqo6tocSyYjKObqfw4GRZZroPZ1te/gQ+EBi1YwHaJkjhQdnWW9OKY1Ca4EPTfK4O0GHYDLKEQRst6Je2kRfzhRKaFzsAIFWBiUynOuAEiGSR1HQRxspQ3A2NaWFTx58nQYIzjq0ScyUTElMkbPabPp9UzIoeuBfCAzLkrbtkj9TyPTMJCncXAgYrZmMh5ye27SXaEWuCoosZ71Z9Y2ydO+E4FBakxnFbLLDpmpw3qKVwLUVwzxjMhziuoxN1RBkxmLT9L5dyapxEATloEzxdTJnkieQkpGGe3feoNvUuHpNPhghhGTnxh2izlnqkv0bt7i8XJHlt2najmJnl2w4Ybi9RzYo2NvbpW49MgaOnz/j2Y9/xN7BAQLPdLaL1gZUZLi3S9s0TKcTatvhWsvrb73F8eEp9eISJdPk3Wzt0tUb4iDifMtsNCTEGfV6TtusCVLinOXyfAEoyswkP++mo1CaclggpEJhcE3g8ugE5T1TkyeVSlGy2qyT0jPaNBTygc4nuTF92o1WCeZrvUObHGOgLEt8kNTVCmLy9xfZgLpZE/AQRcqIp/vZbwhgMhhgY2SzqZIEfFCyaWtubk8IbcNoULC1s0PnIoNygoge79YE19CiiL3V07aW84s1nz6/xFrJqOgVDTEBdWW0uFYyGo24sZ8zKBUIg4uGW7MdLhYNx88OuVhsWG1qskHRy9I90iiqtqNrHXmmCa4muDYVwX5D9MnrH6Sn85F6uaYcDinGY7xtMAJ8pgltR9taRAQVIkYqoowIpfnmr/4yL718g2wg0WoAvuX1l3b49LMd/uRPvkuWRcZlwaa1tJuOSTlAGUnop9fDXCNiwBB4/Wvf4Lf/0X/G1u4ueVGSGYPqtyUpU5Orq+tUu+gUU4iQCXwcOpSS/cBR9jtZUrpKJYlBEUKW6qjgEELhvKOzDSYapIqEKJBCp8/t1cBpKNoPPxMV+qeVYv3HXIGV26ZKgzShyLKMrusghGQpGY557Re+zo//xR/iVw2ESJBpaEmM+GBTQlNXEVc1WWkZrwGl2e5fC1lIvDWE6PEyQllgV2s21QJvFKcnJxwMSvZmt3BNhyei1w2UFSjTA2tTjZT4WrEvxtMA84uiD75w4V0UqeV7TSeXEhU1yCtieXrhlEz+Xx9j8vYJeS1HT69zgBB7YFl3/XlCKvK85M7d++TFCJkZ9nZ2GZZFL1SQ15Kxz/u5k4xRpQOcS3mOWmXXXb+2bdFaXVPzhBCUwwG7B3usFpdUqyX7B7vEGBN4QiiqqkZDv1DidXxFhmGzXNM2Lc45pElVnvdpkXkfccoThWK1WKVNySiccz00LNDUHW3X9hmQuv/cq+5O8oKHEHFN+t6qx9vH8GJCHHt5gw+REB2h78okQnno5duglUTElMMdpUje7qZFhIBUabocOpcO7HhivOpCpcUlpCQQEyZfpOiu6XSWNmL3Qq7tY8S6JPG4ml53Nm30WgqsSP6/4PtimPQgSDL1qwPrlWcz/Q6mpy1a55IvrS/ipZBoLfsV8WL5XvlUko2hzzlPf9Ar/nXv0QjX67Btfr5IDG1EkrrEDjNM/iA9KJM8ScnkCyFNDJLUwAIZMTo8gsOmZrEv2fvKa2RbBS6umD+7pLGgB5piUDAcjsnKjPF2lnLtveXZ48cc5SWTaUkXc86WJ5w8/gHajLh74xbjuxmu6fj0g3dZLRa8eeM2Ita0dc1bb77KxdEJShh+/OEnBA9feuMlXr/zFsM39iin+ywuT1ieHVJfLlg/PKJYVGA7hmjMuETWFetKsDUZIINicPcOKEHVOT758D0Onz5htnPAb//9/yKB+9Y1bRDUwlOt1jxen9Mtn/DVN1/lyWfv8957H2C7NV9961Xy8ZCndsMv3p7SPQm0wSNDg1QZ0Ru0yiE0uJCn/Gov0Kslzx+sgTXj8YBikKOMYpgJgkib3Wa5JHRzRHdOMTxgffaUye4+1itiPmFR1bSbOTvjt2kuHiO0wfsB4fgpzeacznXs7L6EX73P1ngLI1saK5hNS1wuqC9PuL23j682NNEynE0Y6G2GozFab3E+73j67Dn7O1MObr+M7gYcn/0YtfIokUAnUqTcYhU1UgQMOUKkCZWTJOkkRaKnkiOj5qq/FqMjCA1BAYEoU2ygFGmTVEBUCiXB+kj06b7U0qNkgVAgRegnID//9dPgs4RtKLM0NaFtmA4Uy/mCkfBM83Q3W5uKauMjbrNCCI8kI4gC3x5y+OEPmOz9A9p+sysUvbYEGi/QEhqbJOIfr3Yo7RGHR8/opODk6Y/RfsL+1CBjpIsDfvw3f8TB3jbDW/8HjEweM61gZSGPMJjcYnP2rygne3zlV/8hu6oiqhLfVcTBKMUkOc/l2Tld2zGejCmHA/LMpAOAszy/dLR1hV2dIWzFB4/fZTwasXy2wJWBZVZzWlhWTYPoOk7OW15ePkPnN0DkxCiQMcOHgP6c5zs1PgMXp8/5+NERm9YSugRxvCEaVvOnfPTj75KLNaURBO/oOvBCc+f2NpWLeBfoujlKD/tXkSQ7J5G3Qwx458my1MQWMeC6mrPjc358JBlM18Sq448/stwzEtwjivwpKgSyQrBGsz323L/dUrklbrCEZUOY/4RueYbdvUTIAUSHdy1RRKQ0NJslPu7RuQrRtnRtS7M843JR46zh0/ffRbgVm6ojuA3zkw21LZnnr2EPf8Rk+4KtnVe5fSdiijx5g5uWQdkxHpe04ZzxNBDEBM8Q6ZasVmvaJdyahpSekhds6oq93R2oHfPVz27ByIsBREEx2kYbQ5lnbDYLRoMMa1M8ZK5aqs2aYaGwrQXheP21+1TVhsVyQ+cSQTwziio6hPTE2KB0jtESHRRt1xKdRRjJ1mSEj5KLyz56DEfITCpK8hxrW7quJjMZ3ltcAK1Tfm4QAaUC3lmGw0E/OFFIAcPRiNVyRdc1FGWGdyBEIHibzna9qkwIxXIxT1JWCc4lSXFTb0A4lBJoIcD0MbIqo7MWryXeN4mDQyoAhoOCqqlQZgTFgGY9J880JssQaEqhkDYyMlNiFGgUpARZrJecPH6GMIqu6wiLJcpkPD85ZjwcMp5OmV8cMRnPuHX3PkENsHVFPsiZ7uyz2Wy4XCzSuUcFvvbNb+Lt13l2dMLTTz/j6PlHDArJrfuvUVU15aikWVYM84JiNqNuO27szuD2AfWiom43XJwcIxAMRmPWqw1ds06sA5GR6SGRjLIMKFMQfUpBcT4BxExu0EqhjcG55NNVCmQAaxuM0ogQGWeJW+GCxApJ1AHrk3Izxj4hwxhC8JSZwfqIVjLZ+3rbYYrZGtA0Va+ayCFEXB9R+/NcOze3ODlaUBQlUkrqapNkv01LZiQ6z3FOkhVjoncoYak352xWDYv5krCpqGLkomr5+HhO2yXbgjaaPC+JzpJJSZ7lBNugcoWQI5QUkA1oqgYp+ntDCWQIDAYTOm+p1nNKhkx2pphRicsdZTlKILQYqasK1wWMUTS2TWdN71A6Up1fIiQpn10l9eZ4NkWvNkQBq1VFJNDWHb/8q7/A/Zd3mUwzYkz2j846fG256x33b2zz2dNj5stV8iBrCVqjdODurREP6g2SQGE03/z2P+C3/sn/htFsK9HCVeJp+VQYEEmNFj3SqZZQKsUsk2q0KNIkLcuyXmnre4tuYiYJqcizNKCz3uOsxbkWa20/CEsy9RRp2iuOpUbKlCoUY8Rbd53CctV0u7ZSIfrBnMA1G1Q2SvVFSF541zYYJZkc7PDlf/wP+Ov/5v+Fc47GezrvsTFijEKbHC0NJmWvEeoq5bcLiGhClkH0iD6gPCqFq5YE19J4SxCRfLxDNtlFpccT3WpJuGixJ89pZUBtD8m2pr39Nv1uTZvscsWg/ELr/3/SxPvqMGWtJZIo16GPFbsiYl9PtfsXhKsJd0i+bu884HEuSZ0F8npaqZRhZ2ePyWQr+QauIqnEi3zoFxPsVPA7Z3FW0HYNMYKSupcNuuQbQhBlgqUpqdFGslluePdvfsjNmzsp29ZHzk6PMSplS4bg0JlBhiTHEUTyPAORitymc0RpsAHapqFpOlqf8ii1MXS9nFplKpnuRUQZhQ2Wdd2mKb3WeOEQIkJ4YVy01vcyjXRY9cERnQAkeaHwLgHdktQuEPrXPJBk6UlWHQgqNQWUVtfS8zT9Bdv7rtP6fxG/FnrZ+BUAT/YTbGT6XmU+YP/Gfk86F9f3jiLgfZpmX71X1jliCLgg+o37RV676ovudNOnm9s5n6TpxqC1xlp7DU8QImK06kn5qQ2jddLDXOeFiysfZLxeK1cTcBBpLQRx7XmQQpJlP4d+EJDK4KxDUWC9QKuQDo9FjgwiTcSUAWmTKkFJgm2JUtBaR5VveM9/gDm5xSDucOP2JEFmLhds2jWHh4/JM8NwfMCr7+QURUE+EJwdPmIx90xnY9bVEqkzKEYcnjxhuTrj5sEr7GwVWLdgNNQYVXB4csqwuMnX39zj2daI88uGs5PITz55RFlMePulEbOtguA76mbDs3ffp5h7BrVnT2coDLVTtJc1ZaXQccqX3AHNUvL/ffBdPmmWkGXMmxXvvP1VJjszQPLo4UNu3DjgYLvk937vn4MLPPj0xyAqfuXr3+R3v/MtDp885sP3PmB7MOC1V2/QrRsud6HcgJ0HipC8f1JEfOibJWGJixlSlli7wtWB8d173PnKN5H5FNs6GpHj3JLO1Yh8wuGDZwi3YlQEZJScPXnOcFbA5BbnH3+MHGcsN0uqRcXm8gnbN1+mOXtEVoxRRGThiOo+o+kurtqwmT8Ht0CHFh00kiXFVkFudsjyXXQe0WYb7wUh1Izymlv33yAvtoidwPgCWKOFwgjQCGS4SoTIUCTCeyApbqyPKGUTDVcECAOCSLJUKRVCKwgeXOr4S2K676PsG33JK16icU5T2Q2dazAhomXWq2Pcz3VPhBBfKMD7QXB6RoCWiqIs2ColUlpGQ0lnxli7BtJUUsjkcfvafYFbPcMvVzx9fMZ0dcbhe3/Fa9/5e3Re0vqIKKHoC8bKRXItaDwUIkMN9jCZpguekyfPyEb3WD494eXXXybaFs2ALW1YyxHz2lMoiDI1NM8WgRBaPn10yMHtVzg6OuGzJxeUL99hfvKAUbxgtxjz7p//IU++929oj95DC08+HrNz5xW+8b/+P6JHezRywLCUDPSU4/U5PgTe2pnQxRU39g11DtNihzsvb7FlB0h/j0wWnD17yKidINQAmY2RKqftLMNhSfCpUSO0wvuANgUvvfEOH/3kL1i3jtg1+FBTPPv/8KV4yGi3QwXLO18x1K7kwnouLhYMD8bU1YZi/pRseAOV7SGEoK4WDAaCGIt+Ypb2XGcromux6wvyQhGHU1x0jHZKpu0FM+s5P6uhSM2PBjjPFDeGkufPIlWMZPkzRpOCdusbYHK69SVRzRj5FmfTIRIkdXWOL7ex1RK3WdK1FYODLzGiYDAa88OP/ytWh4f80b97SBsjv3RPYKb7dDqyagKuqWmatmcaWaQcp4Je3eLj5w/4J7+yQymecikUg1jx8Nma7XHBYCgx2TazsSJESyYjz589xijBzvYXO1D9XZfSKvFOQo3dXCCdQQaPkVsc3LnH0fOHnF+c4r0jMzlCpbPP6dkZSgkGgxHTTNO2NTF4ikwTQ8ewKJH9Ibuu2t6nD62zuOUSneUUg5Jq3faKgkTQljIBFY1JANlBOUp0X6WwXfvCzy8CmQKN7GN+JOvlgtxkQPJfG6PJM4PtUopICAkcduV9HBaaGGWvHGyQAozOyLMsnQdtGtqEmKKSWuuJ3pObROruWsdytU4xVyaijSHXgqmZsb93l2Kww9beTQajKUJpxtMZ6+UlRud89ulD8rJgsViwPHpIVowJtmY8nVE3Hc5Z5hcrzk/PeP2tr/DoyRNm0xmTyYzb918iM4ZBVrKuV1TLiov5JbOdGiUiIgjuv3Kf1eoGz5885eHDx4zLnNGwYLq/R1etOJ/PKUxO0zbMypztl++zurxkPJpy+PQxwdaIqiLLChq3xEiJKYaUUtF2NXU1T6k6zjEajBOUttoQlECPhkTf0XYOUV+pHQNOOEbDATJA5xzSBzIA2Z85Y8DFgBAB3zVENNa3RCStTYpN613iqhiF8+l9NTpLZ0KjwHUvvKM/43X0/CLFmsk0HS3yEm9bCi0YjDOiNOhskIZHoUOJro/Dhf2DXc4OT3hwMudkXrOsUtRcrqHIMkaFITM5JjNYG/A6UnceMxhTixYVJV2f55xlGqE0IVpEVtCsHT7AxbqjdmuCSmfWLZljW0vbdlRVRbNpkQTy4YDoWkalQYtInkeUylG1pxwWdK5FKo8zkoBgNEzy68mt29y9f4vxYEBoHJfLJX/x73+PX/vmO4zHOaOR5ms3Rjw9PAVd4q2nLDNCsBzs7XF8vmHtBFJqdrbv8+3f/ccMJyOy3KTUkh4Anc7E/RRbG5QxmNykSLprMFo6N6veTx1FqtVUX/Nd1299s0WLq7O8wLYbmrbCmBIQKBn7pCGF6GtEgCtoW4qFtmmwJ0R/VujTmkJiQS0vT9i+NU6RqSIxG9quQ+U5Lka+/J9+hz/+5/8t2rWMsgwd80RANxmZyZFSkWcyuaeKAXiReD15gcwLgrfpedX2sWlCJ8WRSckZq6MnDOo1RT5ISpG2odjbIQiN7VqqJydkyyWDm/tp2KY1ZZFzxSr7ItcXLryXi2UCVvXa95QD3XuBQy9njvRSZ9Lo/3MgmBfZzSSJQARjUuEjEIh+AguglUlTc58IgfpzEnetdCLdeUfTNH2AewJsjccTlITjo2OsS4X4ZLyNIBV+JtPkWhEJPH3ynOPDY77+jS9xcXaOlirdhMGBTdmSTdsSvE/gicxAjAyGI1ZNWtBnp+ds1hV5njaRPMuwNrCpapCKalPjXUCIDq0VUYL1DhmT7DlFqICMSfLtXEiHKZ0KUxUl0UeQsS9URX+YTfIwjSSKJBG7gpWp3kttlL7O1BOA6yw2vkDsy8B1lrWSoi9KU47elT8/eE9wkkwnX9d4PGYwLJLvQ8lr/wah/xoiwcXsVYPk2oaQaOVpTQquouTSWyquJfqJDtgD5KTsvwafoyXGPnIgSaG1SgAF6+110+Gq6L66kvc8cAVqSIfJtH6zLP+iy//vvFShyLXEdx0xZCA1BAcmwcBEED0wKIJLNgFiJLiWZ6tzvtt+xGamefnGPrObO+zf2UKieeVLkvXigk/e+wlPD08YIwguoLRhMsrRb7xD1XRcHp8hVh3ryxMGwyGvv/QW1eKSs8MPsMstmlVNEC2fPHjExcWSmzdu8vSp4uh8wSQ3/PJXv87r998C37C9/QqbVQ3a4y5qONpgloLtMsd0GiNzpliqrmRHjDkoSu5k27RRcREumLSRygV23vxFdt54i3cffQBtTRSp4XXy/BgtNH/wx/+M9eUZJje8urfPK/du8Fvf+Qb/9J//a9776GOcc3zplftcGEuxL8mbgG1STqWMaWKbHPIAHhkrdkYjJq8csP3qm2zduEVTW6JMU4/gM7LxPodPTjBb+9hmxsouGY0GdKfvk924xeb8mJhlyPIWZ6entF7z/BLm9inb4y1Kt2I4GGBGM7r1Em8dnjUurrGdQOPQxqH0FkYZVGkZ79zEB4MzjtFom+yi4c3Xv8xkcovV8Sn1hwuoGrTJ0CgEBYE0rYnSo2KJ0BbvPTqqpCrpm4la5gQkQhrAEPvJuIwSKQzOKDQdyCw5k0RSyoQA+AQ3yYxCZRNsO2CxWSL1hkyU6J/Tu7cM4ZrbIESaHIu+AlcqMpyMEAdf4fFf/f+4eTBgWVvOXZKNXVQ5NnT8o68Idu6/zepyQVtvGO3tcrE8490ffcivOo9HUHWRQU6KY0RQ28hAC9ZVpNMBJQy5yRiNttm68Q6rzpPPayZDQz66yfLxIafPT9lut/nRdz/FlEMwJZ2NrNZLzhdzzv7mD/i13/4nTPc6Pn74gMWn7/KK+X1+uJwzOvgGD5+fET7+Y0QQiFLiaknVvcv3/t2bHItvsT55yIwjhKq4t29p3ID57q+yuDynDgXLasXNl3Ju77XJN+csuEuO3v1TVvN/SlmUDLdus7icMxpPaZs1MVhMljPZPuD89DllMeCmPKW4O+R7H55yvrjko0eRX8/eJzQev0keNkFN6WE/G/GoEZwfn/HX/+r/wmtvfRnlAtnwgK3dG1wcH1GMd8nKEV1TE5sFi+kBxkDbNkTfYmvP2/cPcNU5UZe8fMMznluU7CgKgV90HJ22KfrPRnRpuLwMvP2lKdJk7N/eSYfY5TGmOKBrlrTrcwwBBhG/WYDuqBenNPoE11UEM2Zx+ZzmYs39O7uovTcRTcN/8++PGM2G1F5zcr5kZQvG2ztIJXA24p3kxG/zxte/wRvB89pOxgd/+wMeULB2A379O7/FP5g+5eGnJ/z4/Q/IBx2jfJtq3XDrxjYq32e1qlgtlz/zPTGZDFlfHhPaOp1xgmVYDFisLjm7OKEwityolL0dAkprDvZ2ubG3h7c1TddRN5bd7R1Oj89oqgpTFJgsxX21LmCUYDIcUDUOF5OHPMWvFpRFDjGBxJztkAK0zhiU29RthZSS0XDYT69Eyv+WkTzLcc7R9ZJyEBgT6bqKGAO3bt/k29/+HY4PH/G33/srvHd4EqTJ9LGeddv0+7hMMNgIO5MZdVVdTxuVTPt78I7GtkidJkldk7zIeV4QY2TL5ExljhntYPIhOwcvM9o9YLy1w2x3GyVyfvjuezx+8IDxMGO16WieP6G+OAQR0TiMFqxjwBQjxqMZ6IxqveTi4pLt/ZvkwzHzTQOffsrWzi7TnS1kI9msl9hqw6VvubhY0Kwqatuxv79LiC2qGPP06IjlasWd+3cohhN2trdoVzWDIme9XlEUGdvbY0IIvPL6azx4+Ihx16Uhg3NpsOQ7IKCAyWiLTVXRNRULe4GQfbSUyFieL5AykhUDjBEMxjsIYeiqSwQaowRGxeTZDRZlUgRsiFcKR9BGE1XGql6lAZqS/aBGJuhbENCfTUW0CKnYmu2xXJ6TZ4Ofa5+o1w3aaLyzZD30V8hIVJIQCmbTPSKCrppDs8JHi2tbJuMxvmuQmeB807DqkprUIehaz6arqDpLZnJyWTGZTlg1kd2DUbIl1BoZHD5o5osNbeepm47WpWjjnZ1t5nPNcrVhWaU4QhHh6OwxtnNMRmOmWzO29gdUmxWTyZTD58+pRMbFZY2tG0aT1Pw4vliC95SDgrbZ4Fzy/buouPvyfQbjAcYM8aKhzBPb4ex8TlkeMBobXhnf4KtN4G9++Al72xM62yGjYH65IMSUSkSIfPs/+R3ysiTTKllR2uZamXwFEZS9elULkdSu/Rn/iseUtug+ehnRg9VeRAJfMb1CCBADEghKYcwA7y22S3T8Ik+Fr4gywYf74dhVDSiEwDlPcVWokqxxKSBBILRhvHWAUXmKlO1l73lREENgmufMdvZ44xvf4kd/8q9omxoTk/rWdA1BaTIkUco0+feBmOWYTBNMIAqLCB6dG7ySqa4bFqjgUVKgfUfz7An+9BSrNEYpRPB07QZVlJRKomyLiAXplUrqAGcteZH/z194P/jsY8rBgOlkRlGWPVGblLXtk0c76d6Tp/Baev45wFmiLIp+IJL+/6rA0lqT5zlN0+BD8jcLmRYSMgGplNLoK2J5v6C01tfe4tQhrdnUKz7+5AOMNgwHE4qiZGt7yp2bN6COsJrz9lfe4OMPP+XJ46eMhxlb45JBrggdNDEQfEyeAAmm95DHPo5DK50C7pXs5RoyUS67Li0uKel88jgTI2WREbxjtar7AlEk6qdNmPtE8YsEn4pUH5IXR8Q0maXH9l/JMq7y9wKB6Puca6Mwfacr+bG59tj74JKkDfAuHcR8jD21NmGOpQClJdaGvlgXP1XEKqnZ2p4hlLj28acrFd8hvIj+Ct732eM/DdO7unmTujwV6lL0UVvEn7rJgZ7AqHuQnUrZrhGapsX7SJEXqRtmG6qqTuR6cfVaCbLMpA6bf5Ebnh4sXP/957ocIPvcWhcJsUu+mdhD8nKFcF1Czgjf2yQkm9bzWG4Yf/ll3v7WAeQGUSSVSDZMU3SEYPv2PbbuvEamJdlgwHg4ZJBFvFDkw4IQoSgNx48eYFfnXFycMB6N2JltYa1FZ5Fnhysa65iOMhbLmltfuc1sqFmuLvDWsbe9R2aGRCk4P3uKFgPC/JIbakZhGsqQMzJDjFBYp5nlkVwWbBXbjMyAoe/4pdkb3C13WHYN86cVF8+/z6ujAcVWTtyaYGvLeDYmxsD84pTzo+cUZcl/+/v/mnu3bnB3b8qtgy2eHZ/xXtuymm+4f3PK4N5t9MSSt4KcvI+oU6mx5wRkBTG0iMYipcZZy9/+u99jNh3z6rd+k67pyI0hCMnuzZtUq0u0EqyOA0ZquvIm8/MFXa1Q4y3e//EPyLMxy2rJg4efoDS8/Mpd9kZTlvMVW+M5XgjsqmagR+T5mKfHZ9zYOiDGjs2mIcs05WifohjhpEGZiCmmZNMNW7dfYn26oD5qaJ8tMNYlmTmGGFukLBJMT4LAQZRIaSB4pOrShhiz1KGVWd+Qk+igUTLgo0CoiAqBiOojPCRSKPARoQTEjhgz8ILc5OSDAshYVCfUrqLMhz/XLdF5EoX4CuFwpXQBBioyzCUHb36D+WBANtqnmV9gRtO+U77NqMgpzFOKQcHuDC7mK1a14+XX7jO4cZdny0jlI1XliVJj8Dx/tmETMy7HmkcfPYPCMH/+ELt8zkZv8X/6f/4hXddyeyLx5RaL8z/jzqvfoK13sX/6+7z+S5pyuk2z2dA2GzZW8dmzJ2SLS9x6RbH5gG9kx6xX72L0ktP1BSc/+K8Z3NljXlVIF1ABVIRubWje/+/4YHPGHX7Cm5Of0KyX+FYwdoGd5z/ioj7guxf3MbNdbkwdl+fHaOnx3ZrBcEhRzHA+YIqcj37yXWbb29TzR0x29um8JwN+8oM/ZXd7h6PH77M9hmJxzC8MOmIQlGZAIaAGCBLbJauRrQNipgjFkKcPnsHqAVNxyqAo2N2Z8fEH5+R5wdp5ynLG6cln7O0d0BmQxZDNYoHWGbtlwVu7z9gedjSrBW47Io1gevdVMCOOPvwJf/VnkWefdlzMFV9+fQuRJcn4rDSY5hknH5/STQaIz/6E59O3mWy/RKyeo4a7zJ/+mKX4mMwew7wmuCX24Q9Ynh8y2t5h0LUsD1fofMzLN1s2rmTv1isMd1s++vCIw6MVg+E0EZNzhTs/4Q/+YM6qtdy7u8vXf/cfkndnPPnsId//67+myScU2SmvvHOTsSj44YNTRGgpBobReIvZdMyjo5+dfTDKJNYIui6glcRay6ZasLO7y3Ixp+vSIVmrpJJSQrC8PGcxP0/y7wh5ljEbF7zz+n0aF3j6/DDt441jmI+o1yvWVYcpRqgIrquRIpBpaNuO6XhCs6loYt+UFgloJwUoAc5Z2jYxTyRpn+q6Bil6dVoIxGgZlkNqOjrXsl7N+cs//Rcs5otEcZBpsl/mOV1riSGpcyIx/R7AbDTiH3/rV/m9v/z3VF3o1XWpUed9isR856V9ns9rTi9W5GVBGQQHZkihx4S8ZHrnLWZ7N7lcVBw9P+Kjjz9mMp6wf+seF0ePmA40O6OMt197jUeffkTx8m3OLhd0bUsmLMVggpKSyfYOk9ke66alWl5Q1y3PHz9kb/8mzkfee/8j6s0Kkymm4y2InovHT9nev8FZZ7lcLnjvowf4zZI333kbpQ0dAx599oTbd+9gTIY3ikJm2G7JowdP2N7bQsSkFri5v89n80uUcMy2JjRFxnpxTtt2KT0nRobDQYqNDI7GJjVarTZpUKQNsqnI9YRqvcG1NZKI93NGk1myW9oWH11qYgiZMq2zgrpZYztL8A2lUQSlU9wcKac8k4piOKSyjtCtyfMSoQSbzWUPKv45Pd7jLPnMjUrQYhlxGPCS6c4e2pS01Zz16VPKQca6XmGcJLqW5XrFh49OWa1cooqrZFdIr1kChHWN42AvZ7w15PRyjbOW2jk6B5988phCK/anQ9bOUm9amtayOL8AKcmLrI83TjG3m/WaQV4ihwIjBXmmWVye49tUCEupqWtLVVm89TRnS6o6KSp2ZgNGwxITI1ZZNnXLaDZjtr0NPnJ5dkimNMV4zG//vV+HrsOfH3K6OUHpjG+8tc/zZ0fEaCnHGa6LbG8VPHhyntgtKnLrzo1kIXMW4Vx/Dk7DOaVUksg7hza6j5UT1/fcNahTiuuaQvTF91WhDOljlVJEUpSxiAmcHEwig4eQQIvWpXVxpZAW4trEhBASIWKKNuQF5ikN5VOMpVKGcjChl8xc81PyoqCpa5RWKCP59v/iH/H+n/8JMtaIEFERpAcICfDmI9436XOEpIm9lF2lrG4HyGGJbz2ytxNHQBO4JyQ2xl7N7bEx4OqOZrPCaonfHlNujfAxwToyY0CKPnngi63/L1x4/9mf/hGtc7z6+lu8887XmI0n1zLySJICqxCx3vWeYEkKAKI/TEpMT85+MeG8+uoCay1Wql4+7lKxFGNfWAsUqgd2ReBFNydlT6trJL4UmtFwws0bd4HAYr7gw48/oG1X/NI3vswURTU/45vf/EW+/q1fZHlxxlB7JrkkBIvCIgQ9DCEVS8FbhJTXE/CursiMwmiNNJIgoHaeQZGhJbTOo0XKCRMiQdE2dXPtbbYhEHy49jBrY1Kh1tsfnAfnHVL2sVQxFd26z3QOPsmrlRZJYSBkKkr6zo9WOi2EGLDOXt9AiW0Q+kI3FbtXRfaVP1yblGd35e3gyocdBAc37/SvR/ic3zy9iV3X4lyHUiYV07L/OfqPsa6H7PWNBoTsC/j0IPD+hbxda9NP6JKfKMGKUkPAX0WC9VYD6zq8s9fk8izLktTd2t6WoPqvqVEq+e2ttclv/nPKpWzXobISqRUhghYpMzLSgxZUr/KQGYiQpo8ucNyu2cwUg4MBQmc8e/qEy5VjuFWwM5sxng3RuUHJjKracHpxiHUlt195ldEwxweBtRVaKkSomYynPLl4TqwDIbeYmDEeKPLdfUQURCvRxYjv/eQDHhx/ysBMmA7v48IaazuUyMmyARcXl7Rnz7i1Nox9RqlzCpFTYtBKMlERI4fk2jA0JUpokJI70rCVGRrvsSGysR4bAt0nHaK2tOsPaLYK4uWK5dkZwXuaqqapaxbzJUezCe+8epvnx5fMFwvqtuXsbMjt2RYntmHidxjKlkTzpn9AF4SgkTHQbGrq0zMqN+ejH36fYQ433/gSk92buJiI1pkJqFEkz8aIsE9T1wwmb9OeHSOHhpOziot5i9KWGDqEEHz4ow8oZGCzdRuw7A+HnB89ZuvWPjNl6MKUB88+YhMz7Pyc1WLMm6++hNqfEKUjz8cUwzFNW3H7zj2q2kG3Jhy2xPOul5X3zwilkeSECIoUOUjIkaT4lthpVARPi7eSkBmClyjlQTZIrVMEW0hSMUGK60hpBYkREWIgBtAqbZw+WLTKmYwHZPlNLpYXVNXPnlcMyU8vgk3E3xgJOsPkivlqzeJijZweMJ4dkOUZQhtGcc3Lb36ZKDX/8l8f89UDhZAlO1v7iHLCD777Z1hbIs2A5fETfvDdxzhpyHRJvRxhjOXTP/tnyNkvcLoz4fxv/wVOTFg//iFKnXO2/Fs+e+9dMin46q99hSfPP6BeLdF3bmCA4DWrxSlKSqqTnxDskvXlOavnZ+wUiu7ZfyBTK7pgqasN2iiKoeKihe32El0q7MJhG0FuPL6NhIsPCcsptrigUQucjzgLthNcLGrOnj/ixqxiUXwdfEFZmCTVG08Jrsa2a8rcsFpcYrQjBs90e4eLo0Oy0ZjLaoNWmuXRGetPHzIPDhmhqZPgRj2tKQYiCXA0GBOJLbhO4qzh6GKNN4autYyHI+z6ks8+OELh6MoZk8mE+eqcGAKbziKbNQ+/92Mmu9vk0fN80/H802NujgNGwnCcSMKXlyvk/XegHKOyBiUjrb+KswoMjObsYk1Xb9ifXrBaF0hbU8V3cXu3CZsnRHLml2uOV4LpqMTyZ4iYsVwv2FQBOd5lvdnm5JNPePvX/lNuzc54/vghDz9+SGclhxXcuLXD14Yjjp6vEC6wqgpCY5k//QTpX+HRJwGpJVkImMKStQ8herZFhxQV33pFgRhxvqyooicfbKX9/Ge82rYhRsFoMLy2XbVtw/HJMcPBkCIPdDbB5aRKET+BtHfVbZfiNmPk4dOnfPKgpXOOcjAhy3K0KSB6Io6trYOU2+ssQaYmvbUdRinapsUHT1kW0DsqnbPkuabrbMrN7hv6qUmdoK3ImCS7LSgtaJoGARipCLbj8qJN56/URSdGQdd1uBDonEOrFCmnUxeeV+69xKNPHyGIlHmWpngyTce80ygj+cnjE/JiyGg45Ms37jAMOQz2KHdvM7p5j8l0ytnpGU8++JT92Zjp7m2q5YLPPnqPb//mr2OyAc8ePuPi+Agpc7yzFFJy76WXiNGzdeMeJ0cnbObHbNYXTHbuMx2PMAPJ2eEzoj9mPC7Q+Zjl0ZrQNNhZRTHeZbFyVNVD8nLIy/dvMa8Cf/WXf033vR8gspy9nRHb+/c5OjpnOttiupXT+ojOM0xnefbpE4ajnOl0i/VqxWx/n7baMD+/QMTIcLKL2izp2g3CWTrnMH0zXwjFIBtgg8PaDT4G6rZOCj6pyEyBjxalDOv5JeWwpG06sAlMqTKNaxuEWhNiTNM+AbbpiCHJ+I1MCoSAx3cN2ll0VhD6c6ZzjkxrlP7Z4/Ugkf6js6hhRmYE5WCMUJLJ5CYmz2nWJyzPD+maFYgRuSmIvma9XvHuR885u6zRQpCbLNnxBldReQobJHVnmW1tM28DRVaw6jzFac34xg5vfulthoOCZ8+e01YOEQVFoQnA8fFZGlh1fRGpFEoIBoUgeMvJRc3R0WVSfRqJWTboXFPmGUWumDcp8m6xadFYNCVt1yEzhckU0gdMJsmMAhEZjAc9KVTinOfikyc8fvCET4+PCUFSFJ/RNJ5SkNQjZJyfO+qqweict770Kk294PwsYzLrkCpPRfXVFDjLMHlxnQYUQ8A716uA0zPtqgCXXDXMr5Sq8afqLOCaYH5lLRGQ8tCdStDpXu0me7vMlVf8SpqeOFIvvt51KtHn4MlX0LfgU83jQ0hga6UQIRA6y8tffZ2dW3e4fPxpkqnTQ0CviGAqyddlP3FX6Z8S4ymKxPBabRIjRiSr79X/kus3EAQ4kRJ1POClwBUZcTRMkcy6RcmU8CWV6gd6X6xB+4UL7ywvUEbgveDy4pJBVvTyQUVZFGQmS1Iln6as9FOOlO/2wtN79Sb6kP782h8e0iTz6gdPBWFaCKJ/SWP/Aish+uirVDjFvlviokNqze1b95hOZ8znF0ihcc6z3ixZrdNhICtLijxn/949jHyF9ckTqssTqk1H8IG2adlULUVREGJAWMdke0zmPfZixWBYopTk4uKCQW6omg6pDK1N01yPoGkbjEqZ503TYrRBxEjVVjgfemwIPUn2CjCXCKGdT4CL0EurCaHPvMySTEjS3zhXaCGPlGCtuy66pVIEa/uFnrrKztNPDbn24iefxdV7kD4vvSdJhXD1l0RycOMG+iqvT4je90UfA5bIhyk/O0mW8izDOY91DiEjRe/rSpJ0f00GREik7N/LyPXk+mptfD6uLq2h9No1XUuoLUobjErUfZ0ZmqZJhbl118W8MYYiy2naGu89VVPxwUc/4ju//qtf9Bb4jy5b1UQXUUWGzlJUmPPpIYHoHwZRE2WCBgkfcL5joxyP4zG3hm+hRgX7d+9xUE64PPuY937yXXYPXuHG3V1E0AiZsV5aVDbk4/c+QpuCQSFpqw5tLI8+/h4v3X6Nr37165w+/ojo1pTlkHZ9gqbl1YNdBsMD3nv4EbGt+eCTJ7x+8yZ65tjfuo+Nka52eNdwMNvm4kmFuHQMY0GuIJcSrcBgKJXByLJ/rTUqpvWnspwsH+DaDg+EIsnTPJFwHlifn3EZHe9sOUba0DTVNXBRmpT3uDWaMs4yzpol1dpikDw7PCNbOlpXInWZlDRCoIVECI2Mifg+KgY8mZ9y9ug5mV9zsvI8ffCQwXCX0TSnVIJNu2JajumI+CjJxzNskMy7JasmY3bzBr/+yn9BW29obIv52+9RVRW+tXzw3o8YjQc83LQYZTm6WLJplnznV34FFwacXzp2JjucLDzDwzlGD5hOI1mWkWVDtM4JYYC73LB50NIethjnkBTp2Siuci4bBBnRv4jnEMogaXuVSNs/6wQhrhFiAsGQMnHztHESQOp+g9GJrSAtIRiEjP2BmlR4+9TZNlmgHBQcmAMu5vOf+X4A+P6//L8ifJvyYEWJ2Pstpi/d5ejwIcff/bfE29/m4YMPie0cIQ5gMOD//P/+EZvKYb3kjz7e0DnHv/4P/walJHdvv8Hy8pydVy3ldMbJh3+BjYbRaA93scdwkKPaEy4f/hC1uMnm5CfEYKE9wasNN7bgP//ObYLZZjDZ4a5Y8/yDhgeffsLNbckPHgq2b38JNR4g2mNsPaddHuGqFeMsEp6f0Ng0kR7GGuFzTJlT7G5huzW2KFiFDO0kflWRWcv54QmPnvwe1Uxy4xdEembHmKT2JZzLwL285e7LFYvlktHuiOVizng6I88HtO0apQ2ZEmhVMhxOkhd3MkJmBeDoqg3zkzntypJn4EPEaNGLcARtF7HrSOMUe7cinYVQTlE7O7jVikkxZDoZsDhbMplmHIxGtDZQZJKqbsi0ZbI/xbsWGwS7BxPK0YTx1pDv/94PeP40sPtKZLSVoHYxRGLvsTdScHScDmY6S/tzvfG0M89y3VBqgQyW6CO2cXRuSSUbgqtQMqPZWEIjmTcVUmuG+2/w1TfewlAxXw34N//yb1hd1KzkiP1pwyzPePSp56ixrCv4k//wnOMnl6npJiWv3PMokzMa5WQqkmVp6ozKyOWAyUSRsUbGgHMR6wLeC+q1pTQWHwX3Dn52C0ZZZsy2XsI1S+qmSVmwuFTUao1WkrLMqas1qb4PCFJyR5RJLSVIkFqlJDuTPQZlznLdoJQieEemJOv5KXlZEENqrWdZUk+lOE+BNjoNEUTKE175iiIfsLs1YTQaUlcNJ2dnuBgpCo23kOc5tnNg0rPe+7Rnay0TtEknvsSoyHAI2rZDK42vbeJQEMmMIYRApgyGwLNnJ9ze3ubJ+uK6GJB9rrn1lkxl3BlvszV+meH2LdRgwMHdl4jOkeUlf/tXf8psNuE3vvOtpPKJgXrdsXuwS5Zp1sslJ+fnvP/jH7MzG/P0+TEheGZPDtmdzVhcrBjs7HFwcJf18pTVxXPyYoQIbbKOtUvOOoezFxSFIeghjQ345QkueDpP8v9Kxf3bt7n5v/pH/Plffp96teLpoxNODk95/c03kfkQITucc+TZCIFmU1u8EBwffch4e5t23dC2GwaZZuMM7eYSpTO062hsjbxSAQJ5McTZFi0ixAJCwHpLZ1tsZymLZF3qeulw6HxfYOdkUuOjQ0hBORwjUKzXCQQ2GJYIaWjaGiUV1lqc7SiKJDu3ddM7ESM6V/joE/z357iyXFCUBYPpuLc+aPJyCz0asllccPbsM6S3BKUYS40InvNlw4OjBcdnawQSJTXeR1rroU7RgnXbEERSex1fblg0lnFW8NK9u/ziL36Fyc4AMFjv+UrzOueXG37yg/d58ulneJ+i9eq2xdlAcB58oMwyusUJUmUIJFmeqNg2SJqqgkZw4QNFnlEOipSPblt2x9sMRhneg3cWrQ3DoaEcD0FnKJMRfEvXNsRG0HWO513kz977FCUzRsMCZxN41cnIYJihVM756RlGZ2iT8+W3X0frHKUl5ydPE5SYyGA4ZjzeQV0pgmXiQ6UBXbg+318V0vRxnFfF+H//7H1VPKdqIiUc+WCJBLRQiD5uMITYq3o9RE/brCjKEVKWve2T66//uX9Jo8C+nuSay+SvyebeOZSUicGFICs0b//at/mLRw+5ihMWsVdT98W86JktIoTUyCRFwRHT+yr7ApuYiu8In5uy98U3IkWRCgha4XJDKyJDH7Cdxct0TxlBGna6Lwbh/MK7yd7+Htrk7O8fMBoUNE2F0hrv9dXP+cJTIEVvrBf9i6lTQfq5UHTVdzgCAXf95r7ovqR/7l/EfqHIvmuSvMPJP5smxP4Fbb2/ynJIluWMx1Pu3n0J7zynx0/YnDwkk4lsrqVBosgHY6rFOU3T0jaWznk6FxA+FfnG6BSJIRMJUkXBcr1KHUDvsZ3FBcswL1i3NU3bMRgknH+1qYCQoryaRL4Tsc+HCxGlE/DEuxdTZLhqUIA2L8Lk27bj6oge+tgv00N2kmw8Tcid86gQryfKWiq0VnjXXa0sUtepjyr73Pe8gtZdXbK/GQdFya1bt9JEvPeFyF5HYkyKpQhFTE2XmDZ9Y150RZXWjIZDlFKs1mti6Mi0xGiTrAX+6uf46e8PfTZ8D4ZLm75G6+STF1na1NODWF6/Vsro1MXqPad1VdO1HfTr8PnxU/67P/yn/Jf/+//yi94C/9FlrcPHmkwleBVKIGVGEmzpVOBIR3AakaXD0yZEPlCPeS6O2Dxw7Nz/HQYzjTECofY4evSA93/8p7z3rmFr/y5f/8Y3efWdryG0Y356wcXxOYYJZih59uQRTx495snDz1hefJ27d14imozpZIuL7pLFySXTSU61uoTQMRxI5ucnLMohu7MJOi8wSLr1E0ILZTdiupJMfcrAHKocIzRKagwGrQwZERWT9QMVEVIjY4IwKWnQQhJCgw2O4B0ueEzU7CuNOO+4lU25VGukyhjNdllfntB0FQHB2zdv891NhY8QouXTT57ybb3HcJRyYtOEP0eKBNlIQJ6St/a/xUebP+PjT455837JeDikDoJ8OkTEFKGxM55CntFczFO3ujC0p+eMtnfZmd1ClUPaNuWhH2xPyL/5y4wnAz5+//v4UFGOCnw+5PT0HN0saZzj8dEpd958lcuLFYOtgoPZPsMB6K1XsE4hVJ68TiJnbSs2FzWnP/xbWB6RY4hYQtQYL0BJEDpNq1WRYIvUSFGifYETESUG+NghRUCEAUHlSXauUw537FkZUkiiSpmoePAuQ8m+e02SjMagQFgkEmeTHzAfDNjPf3aIFICpPiRGR8rkVLQPT7l4+nICOq5+wPl3v8/y+JTYNlxcnnNvV7M+PufJWcvXX81pVzCQDu8qDg7GmGnD45Ml0itqa+nOPk1JFZMR5ugCqU4o24/JrES0N5kWLSuneftGyyQuGA/nfGVb4dUcL+ccbo8Z2EA+khwuPKPxkNDVNJtjgl1i2xXCV/zm/nPGck3zeAOZoCFFoidIjWBxHhFDwfaoYSAil2ZA1WjsOhKC5Es3JdOJwvewurYNaCPIssigkPhqg/AtxkxQesZkZwdr12RZiRJTijInMyXFzBHtks3yiMZrMpuAoR05XVOjM3BO9FEukmI6ZrxT4L1jc76hvmhYbiRPz6CbGWal4u5M8/LtXW7vDqirM87Pam7dGOKqNZYJewczXLMgBMgGY2RTJ6/9uMAuL1mf1xS6X7Iy4jwYLQjKIPyark3xUzIIopTYLlAOJRcXNZ2wuCYQvMB1jq4RRGGxdbInBeFoa1KUZheJyjFTAk1NKSv+9nREKBSzGwU//v5fcEtaLpaOx8cOK+CyAudrDuuGGs/4zdd49OgSM8nIYosqGpwRZBKGmef2ViSThnYjCcGTGUDINLm1MK8DWndMRj+7MUmrQFfNe/uXx9mO0ajsbWXJ15tgoKlBLmWaBIvoybKUcCClIJDjXYftNtRYjDYoGRFCYbViOhwSRSAHYlbgQmA2nrJcrcnzjPV6g/eWLCuwLpBpQ/AdVSOp2rRvF+UQHwKDIsfKjs4lT3hu0gQ8OcQEznVpmq1Uot/34KvgLZumwvtInhtiP2IYj4bsbe9w9+5LfPCDZ/zmd36by+/9IQvXJUCRMpQmZ6eckIsRazcgm+5TzrbZu3mbyXSLy7MLDo+OabzCqiHzVc3q7Iy333kH4gajFFle0jYnfPVLr2JCIi9//TNakEwAAQAASURBVBe+xXiyxXvv/gghIts3b3Ln1k2ePnzMdLZLXtV413F2/BSvBqwuDilmu5Rb97g4fc5oMKJrGs6rBT6oXoqsqBZzLocFVdXxa197nWcLy5/90R8hoqMoHnJPaHKzS71sGd8as7KOfJgBirptqR4+YDDdZnV5SVNvMLkmUl5LdpXKcK7C2poYBcI5dFYQo0+DHJHOdk2zQUbPer0mL4aUeY6LIHxEmxEIj84zMgFd2+C6FmuvFJVQLVeUwwGSXsUnBDEr6ILHdxYtE6TTeQdWI7M0OPm5LieIWqFVQVYO0SajHA6w7Qa3OWVrOqFazZEmS40y53k+X/Pg+cWVS5EuRf2gAhQhIq0jxsjeUFLkhlqmGLZsaPjFN+8zylNc72A0wrtAWzTs7mxz4/Y+P/zhDX743Z/g2g1lbmgJoCVaC8ZlztA7VhaMNpTDIZt6w6wsaZo2NQ5M4hqUmWA8LpjPN5yt1nQxQXEzk9F4R2YK8ixna7aDyUAEkyy05IjZkFVTMNn6MfViSfQ2gZWlYtM5OiLDoSKqDILlrVs7TJRh7+ZdLs6PUEDwjnwwpijH/RQ9xQZmWbLDJlhzuK6vpEyRWFIk+6nkxXAUPlePkfaXdHiSRDT4mFIQoocorxWlV3HCUmuKcnKtgoV+SPp5AOvVFdOUPqlkRZ8kpa+h3F3XobWma1ti8Hgh+MpvfJu/+Lf/ks1iSdZC9LGvbNLZsIuBTOUInQCUMoo01AvgY2okXcVOR9IZFgRBghfgYsTFiI0SJwVdlrFSiixRWAGRGiBKJx6Btamo/yJ7whe9T27evM3F5QVHh084N4bcGIajEYPBmCwvaOoMrTUmSwtLXU39YsBZn6TFnyu8RV+0XRWbqbCS1xPWF3CAVGhdyZudtVTtBiFSEaylRogkVf98FvQV7E1necqsE+DaKc0JCGdZnR4RNhVZpujaJevLFfWmToCAoqSxEe88QivaGHGbFp3nZCZFL2yqjovLDaPxgHJQEhDYuoUQGOQZRolEIY1J2r1aVbjgQSaaYIgRqQRCKfA+yUITQqqXcAeCB0QKZpdKpvD3ENECuF7IIFB9BqfqvVIO61Im9xUF/DpvLrzwc0iVutjBe6TQP+XpzrIMrRVFXqCkZDyZMZmNe492LxMJfRY4abqn+45V8gCJPkZNJSBeliUifNvgug4p5DXZFMc1VO3qRnfO/fRa4UrGIXtbgein4+H6Y7VK732eZZhe7n31+yShSaC1LSEExoMhb7zy5S+6/P/Oa7m+QJqCcQRNktJHTHp9dZLahJBkvfXGcRxqPhyfcDHL2bIDThdzPv3wQ5r2HOs19+7dYmv/Bp88/gkfvvchw8NjTJGzs7ufNoP1JX/7/X9HiBn37r7M3v4+3/jyN/jssx9RGo2KguAFdVdzenaG7SJFKFisLigHJfcP9pibhvFkRDmc0toaV0PsBN3RnObBKUUFQ6koY0EmchQGg0KIiIgKh0LKgJYG+ijWEAPOt+mBa0GqAikt4MiERAgLYsjMDfhaeYOnwvPaL/wuwmi++wf/Nw5Pzvl3f/Mjvnb3Ln9/9zXW1Zpc5rwW93gn32eWDTDCIEkyKqLHiCERy/TGG8hxwcMfPWFvUrBqWsrJjBt72wQbgYAOHt8tibFAKM1sZkBoNhFm+7cIcoDr1uhYMBwOGWWadXCUReQ3fus/4wff/zNOjk7QpmNrNqFZOJ6cLPgP33uPr7zzFlHBg2dHDMotDnZfxTNiUTXk1YZiMCJGicoK5E5k+603WV0uobnKG7VYcgpByoShoHUpKs8Qk1pCRWSIqB7UJ0TsqcQBoyQx6mRliBnOyxQjJtMkCpHiodK9pXqZVSTIZDpxISJosTbDGI8pfz64GkGgVY5Sut84I1RPqJsKIwM5l0Q7T+AV67i8XDDYKvnqzpSXb3nmN24w3h7Snj1gOoh8dvmIiV5xOs/Y394ndGfsb/6K8vgzpK+xGSiVZGC5+SHTQcFEjXkwnxNUi5MQpCBqgTI1+96wjhtGseZI7DAMJd4ucHWOdzVt27La1KxEh/QVizXs70QyBd5KTBYIFjbLSC4Enz2NrCpH61uCh9EwY/8g441b6bDSBoNranwQRBuJQWDySFdFAkPyQYl3DZs6sn/3Fc5PThB4qm7DaGToOkee7zN++RcZiAltExKzQFqa5/93utUlHkm2nzE52GW8HaFb0K47JkNDuT9jEyaM/DOWwrGOmkEAXEOzWoMaYPIx0owYb23TNhWLxQajhuhiSggelQ0opwOcj6wvl9RtYG8aUTo9q5sGpIlUekRTTfDdgq//0g6Pfv8Qh2Sz6bjYpEa2KVTPdWkJTtC2ATKwNjFVIp6mSdLDtgMvBGVukcIS7ZrTnzxhednwwRnMJi3Oe7rO8vpBwQ8edWnKGiOfLSLnNfzSa4p2dcLZpeL2y/soKdisW8QgIIwj+kAIHRFP8LGXDYJAomWgbT3CeGL82aXmXVvRtRXGZAgpKIrsWi3onUt2M504Mkly3aF1Qegb82l6BMSAyTVCKCaTMT5ErA/MJlPKg1021ZL1uqNtKjrXkZcTmqZGSpiOBmRGsZhbQugIUfXy0+Sb9RGElAnsKkSKCysKsmBYr1corZEkMG0MHmNSQsLu3ks4H1nMn0BQfZO857igUiM2BmKw1M0SvMV2jrOTY+4Odlm7DVpoXr/zDqNsgii2ePDkOednR8h8wnxVJxKz1pwvVmyWl+zszPjWN3+BpvPU+zcYb89wIbC7v0+1WWMby9nygpu7W8RouXXvFuVwxLT8Onmu8SKnWZzz0t3biK5llS0xBEosF+tL4uSA+ekhUmmyfEgAVvNLqq5mOBrTVmuGky0ulnO2t8cYnXN5MedgOuF/+U/+IX/8Z3/Dpw8eM79Y8faXXqOxEhsCUQYyAsJkhADTrR1Ojo+JMeWYt11AyEBTV+Ai0W3QWYGzHSG0CCVo6zUmy9AYhIkJLCEL6rrDSHoQbiQ3CmVy8G1SVVYtQQmCcxAVKpLid0Og7lo26wqFJxsOUZnBmAKBxEwHQGq6tLZBSJMGhv7n83jv3LyB7zqKckgxHKOMANdSXZ5QLyuKYUbbWcYCqsbw4aMj3n9wQgyKTKchh7o6Q0pNZgTeQ2cd6w4SciAwNpq//42X2c3Bxg3aC2yjaG3KLp+Mh5ii4Mtv3SNYx9GDB2zqFjuAumr6c7ChbWvycsT2eMC6rTFKYrsWrSWDQlLkJU3T0XWO8/OatnOEfpKfZZq8MEyLEY2NHNy9hy4m5IVCiYYst9TrhsFwh9fe3OF3/jH8m3/5e8zPjlFVm5oSZU6uBbbuqDrLziDnF77+KvnePpfnJ4SuSc8Uk2FMggYLkjIlL8rr4ZhSfbxzTCraFPv1Ysr9+etqENd/sf5j0n/XaSoKStO2LQl5GwjBEoJExBT1d8X4Ev3XinCtVv48cO3zk/XICwZTiDFJwaVEKIVQEte1ZCZn+2CbV7/5dTbNJd5Du6xplxs26w1xU6M6y5BIbjuUjylqL5J+dxGuMqEIKql3g0iwVge0IWCBjoiTgkpp5DBHZwbRNxZijCCSbVaIdDZTOvtC6/8Ln7Jef+0dqnrFYnFBtVlRbVbU1ZKuXqOVxJiMLMspy5KyHFDkOZkpaLqWLkCWj/h8VpvqC0cl1LXEQPT+ZK0UHfZaypze34Snj9LT1C1N2zEcjXpiX8qQcyGgSPm1Skoykwz+1tpepqXITYawDru85GJ+Tjks0EbR1jWZ0phMErpAnhmESNAGpSWL+QJ0lmK4QkBrge7hbmWmWSxXVHXNdDKkrhuiTyTPwSjn4mLRSzwjwdr0E/bdlM8j/Z13CHqSYP9GhpDUAVKmjlXos8UJ6bW0IXWYEC/kIC6kbPB4VVxHeQ2+i712P8nNk486BoHW4voG00qTZRlFkZMXOVoqbt66hSkybGeTPFal76lUmm6ECEZrQvDX0/cUHZa6ZNfNlZAaKEZrQozXBMarPO8rb3kIVyTyJGNPXu1EfL+yL0CaXltrE/m8B/XF3tcde/m6lBIlBNZ1lHlBCIEb+zf53d/4+190+f+d10VzjnLTVNzHKWUZUUqQ6wKhE+TBu0jbdTxpFnxffsTf2AccPj5ne7rD/dffom6XLDYbNIq//u4fcnYy5+D2Xf7hP/lFlpuWk6MnfPD+X/PwwTNm4y12b2zz43d/xA9/+D5f+fKX+J1v/xpaOJ49ecSDZw957d4dVKMpyx3yfAm+YW97H9c5im3Ja3d2mO3soWXJ8eFzVidzZibDnm7gqGJqpgx1TkFGITOEBCNz+kR3pMgScT9oUBYfBCE0eCLOabRM0h2tCooYsSKglCYKyQTDb0zf4U/sMVpazo8fUwxG3H31yzz+6G/57PSE//ze68yOA3tyzHYxZjcfMTAjcpUjY0TQpc6ocJT799i+c8Dhs4ecXywoBg68YrWyNDYiQ6DqNgwU4EHJmkJplk2HKgNag21rLs8eonRBGzSroweI2RZHjz5jMN2hqy95581XCK3ncnmCbS01/bOhzHn348/YHs/Y3hrz8GxOPlohx3tsj6e0rqNuN+TZpL9fK9RLJdlnE+SzFSJEpE65q0omHoKIkiTWaIjSIGOA2CWZlo9JASQkgQxPjnICLSNCpYaP8AKpIgSFdxlR2nSvIoneEUSaUAkliF4QVcB6UKFCNYEofj5abTnaAnxvY4mo6FBxlWwIPhBcx2i4BzS0jSWanDvyAtWcEh9GZuacg3KfYniOwvLyjUi8BZlqkOYDjk6esDx8CkVgOEzPLNdBEII2BKRokcYzmBjmz1oaFynLiMlBtQFdRrqgWC86DkxFlWvc4lO6QUFVdzx4PufJsyWTGxHVRuYNzIakjV8ADoQheSNruDN2yIHAxkjbKdaNQ5Kz7gxPn9WMtwN5JogWtJBIEcmMoMbz8V/+JcsqNVKDkIThD7gUisXaM92aIKXg8PCYd16/xde+fJtMtHhyhFQ40ZLJYzYWwkizqiJbw8hmfomraqpOs1k0PD6p8EqRVRFzy3B4uubm3RRDt3XvbS6OT5kNFNJMQW9RDOD08AHbexNCEFw+e0aWl+h8B3TL6qgiDd0To6OuUgPUeMmF3WJbX/Dk6TkfPQis28g4ONabCDKjzNMzhCBwFoSING1SW0iRssOJAufT4atrBXJgENGDb2nrinXr+OvP1nxyDr/yizeZmpxffk3y9LnlvA50TrBqIm/sCk5WUOZpunN2PocOjsYNHzxZ8ParBX/vF/ZSIkrPIJFEOhfQMWXap30qvWeEn33CFwkpr5hIORzibc9wEBKjNVlIQFavXZoe91Yxa1uCv5KjJ3ZI8B7nPXVTJV6DMTTNis1mlSTbQjAoSjKvGQyHtK1FqQRd1CIwHg9wziOl7oGlgbbpUFpjeiaL9x1SKJq6IsSIMulgGWOyDuos0XuVNqzXp8ToybM87eMy7fXGGGKIoMHokghMJges5nM26zkyn3D3/jaTZp88G7H78jd4dnLGfD7H2o6dm7d562vf4GIx5/9P25/96Jad6Z3Yb017+uYYzzzmnEwOyeRQVaySSioNJblbUsvqltGA4SsDvus/oH3nW98YMAw0DNhoSN1oQHILrW5JFqtKNbOKzGKSTGYyhzNPMUd8857W4Iu1Iw4LXQ1kk/AGEkmeyBPxxffttfZ63/d5fs/e0QyhUrxbcenSdT7+5FPuf/YJl2/cIe8XrJZrLl25zLppefJsHyED9XJJVTdkiUC1M1g1FL2cZnqGCAsSD7pnqJRgEjy+raiKPiJ4clNSrTOq2THZSNK6BCsDrlqzDILeoEdVrglS8ejRE65cu07TWAb9ATrTfOvrb/PHf7Zk//iU0z97ny+99Tqbb7/B4YtDjqZzNiaKrOhzcPACW1VU6yk2SECTZAYXoG4sqe6xmB2RJlkXeVUjZIJvWywB6SQehwSGgwFN3dDWFcb0SXVGCLFoa9qaYBK0isR6Z2OhHxAEb0nTlNW6jFDguiHxHqVThPARutc0eBfhXFpLer0RR2f7v8RTAtblklTl+BCb+ratOX7xjHo1JZESZRR1WaF94MXhnI/uHxG8J9XR+qa1wkhNnhuUTvA+5jinJk47g4Wb1zb5+muv8MYrOcvWsb/3guWzjO/+4Uf8zW+/w1e/9RVC49DSMxr1uH33Cp98/ID1dE0QEaSWiIBzDR5PmkikVkirSVJFkiWAp6ltB4cOOK9ApNhQMxxlFP0eRS9Fi2iLOx8eahR52iNJh9i2xtsjbLMmy8e89aUvoRPDv/7//EuqxYzWg1vVUVLtWpxr+dZ775Jt7tLIjIJoTgE69KxEqYS86GPSJO4tzkVoLwEp45AK6LhR/qXdlZeR0Od0c+iK8q5wDt1/p2SErSllaNsIz2zqOTIfgMi6mk5dDMkuimxCtEL8XAxwzBz3qK5OAiK4WKmocNMaYxJUZyn1IaASSdbrMVsdkRhFvtMjubYRX3eIXnapC8qqRCuJCopyXbM4OaEty1iEe0dTW9q2IQhBv5dSVw2tVMg0weQZeZEy6V73unWs6wjOjjX3+TCEjk31xRq0X7jw7vV6JIlhOBxR1xWr1YK2bS5G/1oEBB4lAk21jIAdZ2mtp/YCVIsUuiNkBhyuK54610Bn/vfBE4QiMSb61Gx7MTlN0xRjEsajDaqmuciolkrhhUD6l75kIQTeunjIFBHVr7Qiz1Ok8bTVGqRGaYFr20hq7yjggRbfj3A0b1vmixmrdcmyshcej36vYN1bxwJcSaqyIkhJ4wOtC9S2IU0SXBdW37btRYFsg6NubDTkuyjfkkISRCxapKK7USEEhxAGibiQXANRyiEliEgG1VpeFN5x8kqk+4ko61BSIFx4GR9Ah0YQdPFlEqkkyiu0NiRJQp7HHMVUZdy6/Sqie/gHwssmiTF4iNh98fI1nnfXzqn13nuqqqKua5zzF+RxQQQhRAK5p2naC//v+e9yfoUATdPStvYiYiyEOG0HqOuYkd7a9qJwh3hYiNLbc+ZAVFRsb+x80dv/r77CirZdsAgDHC0TRmQiHmiUVMQzZmDmWx73Z3zkn9N6xbVbd5hPTzg9O+JLV77MW++8jdCSe5/0KIoTtjcHDHrbXL29yaPHP+WP/+h3efjwBe9+49f4xrf/Nn/z7/4jnj99xOt33+TSWLE96XHrxnWOjx5zcHJK4Td59OARl8cZo4EjSQ3rxZJU9RgNdsj7Y6r5DOUdsxcvWJ829M8CGzKnQJGKHkaYWGyYgPA2grukiRF1eNCOGD9Xx4LPG7Q20ZcsOyK9SNDexhtaJ4im5a3hDbZfSH74h/8K5wP5YIDUPUDy6GCfe8mEv5+9zqbssZkWFLrASIUW0TMkRWzAFRs7bFy5TjNb8Hj/AdVqyd5+xbVLQ45XC5xvOHr+KX3TMi3XiGDRaUrTWqrlCSYvOHzygk+fPGJ2umRj8xInh8fI4Pg0kQw3tin3npApx9b2JXw55Z1XXmFZNTx58YxFWRKCpCxbHs8PqJ3l2eFBPMSnKdfrQGsahFsz2b1L4xPWqyUfPvmUa7sJo3YbcTIlBEVM2ZGAQYrQJSqIzrOkgCZOw4NCy0AiJYlUJJ0NRKsE6PZWOkCK1DHKLkR/l+1I48FH9YcUMk5AABEibKW1LaL+5bx7wbvY/Q0hTuFpkW6Gq6JE2nvHcnbA4bMTcrck0LCtPY3xeCugqakPXpBtK7y3VA2gAyHxZGHGllnys1IgrEAEUBVo092nAqrGY2iZDD2nzwWJg7b1WCvQQmBcYDhSrA8dR8uWJytwp2fsPv8xw0JifMNbr7yKXX9O3c5Y1IF1BSoL5BloE2idwKQCZwM2gGujgyy/dgcxq3i8d8DzZ57tEUwXCf1BQ6gh1wFhxiTX3yS51NJSsO090q5RBBon2Rr1Ccrw5+9/wPVrG7z92mUMLU8eveBkLSkbifQ1ifRslUvqNjb30s0R1XqBLUumh4EgHQfPPU0Nwkz59DQwDynVasbDB0uu7vbo//CYQrQgJK/cHCCakjQV3D+0FDJw9KIhtwtaC84DUqCloE8sulsv8DZQlhJfSHauG9ZnxwQJP/u0pJIBZwWrtWe+rjhrPTtbGTZ4bBD4JlA1EMzP8VwEWAvWB05msDNOqKoGb5es1mtefTXn9z+dcz1tODo8ZWfSsFp6PnhcMy2jtF16T1ACKwRP7h+Q2hU2BAa+RC4cN2RFXwhW65JRDoqoDpNKRJsE4oJNYhKBUQKtfvE1kSiJVAbvLevVkiRJ4qTFu+i9DA4tFdIk0dYWwLYxISXI2MTyIUJY0yKnqqo4eZYC14FfpVQIpQlAZgzLpaWuVwiVoZWmqR2L1QpnG4zWBNExcUJCmuZY73G+Js8H1GUbnXwq+ia9j+k1QoA+T13opjzBB5q6pJcXtE0nS8+SuA+prhnuatJ0iGuW7F66wsnxlPlyxrf+5m+z9/gJTdbnT7//PqPRCCklt994hzuvvMpyPufatSuU6wqtE/7sD/+QN995m7feeovBqM/x2ZTtjU1CCBhjcK3n+pVtDp7V9HcvkdiaxNR88of/lpO9E7Y2Nrj77q+g8xHYlnbWxPXTrFFti05zNqSnKANu3Oe0LDnbf0RjxiATTDHEecd6vWY83mA9n2KFYO/FC3Z2d7FoltMZ2lv++re+xV989BHr2YzWST790Qe4EK1oy+WS4AOD0SZzeYZratrVnCAalBnFCauQ1NYjkg0Ca5o2EvGVljRlSwgxESfP8qjUcJ7ESIRIuhznFqTGW0tRFLTeU6+W8dkQPHW1jqpSIfFNdQGuVVpS1i1VfURvOEC4GHub5zlBKCSB4+MXnKuoftFrc7yBSApSrairBacHT0lDi+llYC2ybRkNBhzOZnz6YoqNB2kqF/dx2QaU9NTrFhlaBkUPVEzXUVKSJ5pvvXOLW9c3qO0K5WvG4wlJyPj2u3d45fUr0Dj0YAxYstQzHg259cpNfvbDBUqBEpI8z8l6BeUqY7mqae0arSWTyZBBL6M/6NG6KGFXsmNH4CM0sBts2dbSehdjTpXGpAV1UzOQI0ySXygz2/IEqRT9/hY3btzmr//W3+L3v/tdVssF1jqSNk6LHYJP7z9jePU1NoaS2eyUNNGkRR8pow0zSRMQgaauOQebxUZbhCx74RFdEtP50FOpCLBWPiYpwUsF6kXF7V9+7udW22iSjr9DnhdxfxOxAXCuVj3/XnQ1Ap0t+bwYj43In5t2CxGJ8aKLSPY+2lHyIqZL+Vi3bO7sUIdltLY1LUKDtQ15XiBkhvIZjbcRhKdT8smI4e4GeIttS3y76m7ljMWqZrWaMRlkXL1xl+VszWIdQYQSj2tbdJCosuZstuzyyjvItI8qLa2+WEn9v0JXeE6gluR5Qa83ICAuiql4qHOdzzZGUzQ16LRHoZOLQlB00V/eRT19bNTEiWmiNYJYHOVpipKSVekvPNxVVUUggFakIu2kUh2Rm26y2RHUQ4gdlBCiL8PagJARdkaANE/JigIIVOsSoSTeWWTwpFoQvMQCwiiKnU0G4xFPXxyRZRlSCgb9PnUdIwPWVQ3KkHdSb5MkrMsSS6BtKoIk5jqLmBVeVmVsMvgoB/X+pec6ZjVGb0Z3LwLE38XFold1sJQoST+HEkiE912Hqcs9D+dTc4cNsvNWnEvQZbc4ogIhTq9VzP3MM5CQpAbhLb004/qN65F63nWczqf0sbb3lGXdQc08iUnj6/b+LxXAsQGgIoEzSSINVXewCmtZzJcXRfp5LNg5G4Auufm8GK/r5mVnvVM1tG3bZcGLi/cuejskbQc9qOsKQYwuOX+Pf9HLeYELHu+mtL4BKtIGNgMYACNphKRUluVQMUx32Hv4gJtvfJm3v/Q1jk+e8eFHP6G1byMSyfH0DEXN/LSmXjckRcatK6/xj/7RP+B/+v/+Hm++/VVuXLvGZJRwc3OHN+9scTybUS9PKNee8cYtdjYuc+/pQ65d2mZ7YxPhlihnGeQJRiZ419CcNcyOjrDrgJk69H7NSI1JlUELFadPqkSIDNmqKDEUPuZoaxnVKiFGVkmVIIMl0Uk8rEkQwiCkx1ndqVEijVJoxXa+yf/h9b/D//3Jd/l8/yGr04p7iz8kOIc2CUJmaKEpjMIIg5YZKjiU13hfolWKHG4zufUqbr5kf/8hH558zKyuOVis6fUNB9WKf/nP/hnXtwtevzphNp0yGfai7Lh2rNuGha15vLegdIJEJlx+ZZObo22mtWVjdxdlW+Yf/ZTx7iYHe1P6YcWHH7zP9WvXGBYDru9YhmNDWlzmswcP2d4csiobTs+WfPrZAz51n/LNV9+kt7FF6jTz9YK9g0P2Tj7n0it3KTZfpfzefViddjRgTyAeIpToE4TG+zjNdhQEW4OsyNUQI3KkTPHOkSQxclFLT/DnlNI0OlFE3B19cHh09FmpWEQJH9dvEFGCLlV8prb14pdaEyHENIq4MUSCaGIE3s3BJ1EF0jYoGyhcRZ60nK5gXQocnsYLMmmRpo+3DpNakiRgZaAMHpPAYCJZHATyNCY7+OARFlZryAuPEBphHcVIszyqyfpQZAGVeYQKbEwU1Zlkd+dNRvnr7F6+xNZkC2M004//DU1dYze/Dj97xnYmSKWgbcC3AWE0UkHRg7B2cSq88JAa2vWCs1mJb1s+mwtsMFz68v8ee/DPaNwS2wrcasF8XXI5HMTnlm3YO2lpakvq4369u6sZjYZRxrdYM28dWaZZrBq0Mjw/nPKt1wKqbjmtQeSSjVFKuZjia5jOBUUaqDsQVjoYIGqPExNOVyWXxgPubBmWqwqTRGvQjz48IHiYTAyJhtGmRA8rbhSd5E9AVXtWlWA2E7Qejk8hzaLC4mSl+O/+xQOu7QhuDqHpGDnzOpBVUDQW23qYWVoPMwOZEcxWgYGJ7aVI4Y9Ft/WCeSW4bAwPD2qUdtilgHTEaztnfFrW7CQ1z2aeg5ljbgWvbAWOSpjXgmdlhkss3tfEAIvAQEPdeI6WLbeMwDvJ0XTFlXGKVhJn7YWdqa4dVeUiqFB0Texf9BIB21ZATB5pXYsSqvt9FWmakCYxShXRweqCwoSUtim7xI4oAU+0wSctVRkjJ70LOFHH/GyToVVKmvVI0x7ew7psyfIkNquThBAcUhusbSiKgsl4TFmWrMsK5wTb21dYlytOjveIDYg6TurOrYEqNujb1uK97eI6LbPF4oLpE/x5ZFFUsQkFvVTQzyVJPuLy1oTnDz/hz/6kz+jyTWYv9lAdVE4rwztf+Sp12ZJkOVJ4rl27ygc//AsuXbtGfzBgsjlhvDkhXS7oFynzRctyVaKlQGvFnTu3Ob7/MzLt+OPv/TG/96+/y6gu0UrzwZ9/n9/+p/87mlZTDAb0ipzF9BDrJd4oMqORQlP0h6RFzEY+mU1Z+wEYjXASWy3o9RIWM0Evz6mrFdPpDJP2IHhUnlBWjpEO1EJydHxA8IJX3nidxdmCXg6NE6wWs27qRox99C2NrcHWsTjyMSZzVUeLYZxBRguX1FHbaV1UILauIdUSZKAqy2i90xHaN18uLmydBI9z3VkeQdbrUzUtTbUguHjGVFKhkpyqrjEG2rpi1O9RbF7mxZOHMW4q+WKS2v+lS0pFIgO2WbI4OaCQDofGt4FxP2e1XHNWlnz0+AzpAxv9lKaL21XSYLTqOEIpRglGwyKqLqwjSRW2rpmuLf/h/Z/SztdsbxRcvrTFaHvCl7/8BnlvSJL2OHj+hP54gjCGRBtevXuDIk0plzPacsViXtLLMrY2xigFJs1ikelbEBohNf1+HxcC5fwEZ9fgfExuaVqa1rIqG0RScO3m61y/eZO86AZYIURbaLuiWc8IPpCkhl6vQCrF2fQS127f4pOffMjm1hglZDf0Snl8sOBv71yOqhwT34fBaIvWtrRdrnZb1119IDFJQpoVGJOgExNrCF7WFy/ZWrEBI7riIriu4o5TPM4HpRfZ3N2019oarROSJOsamJEyLqX+S+f/8xP3eX1yQVb3ISaIhThIFKHbbzqmU7ARRqmTFN1aQsc6MTpjNZ2SZUmU1RuFICVISW6GhESTUVMvj8EXWCejGjD4+D6YQbQbBUEqQWcbSBk4OTzEeo+1TRwQpSmuG/SOVHqxd0sZB1TR2x1wtvpC9/8XLrzP5nMCgiJLu0lrlEkR6IpHjwjQNhWrdc3BwQGttexeukJ/oLtOaXyTzz255/p9ISMk4sKP27RMhmOapo0fkDjP/ubCYyxlJ2HwUaIdoPPU+gt/+LlU+Tz6QAuNEoG038M2NRCziZIk7Qq8FqskvmnIFLQhSjC8CxipKNIUqXQscpXGicB6tUZqQ1k7XIg+7dDpuJ21NG2L7zzaaZIgRHydSsepge8OqbFwPl8IP4/ej/A4wctOkOtizkT3O0sRp1hCiihXD6Er5uP3st53k/Pzd7HLsPYx6g0RF0CWZiRG0xvkSCXilFNoxuMJWzubGK2jMkFE/3bjPdVFR01yfHLIar1iOJywtbEZ/TGqm/7yUtYC8edaZxkPRwyHffYP9iMUTUcC/nnB/vORB+dydNNRUtu2ufD2t9ZB8J1XPL7fSVeU27bFhoDoYsaaJkaYnM5Ov+jt/1de3kd1ROVbVDifKBqOXU0/bJHkGas05VlY8ePFQ5I0Y2PnEqdH+1y7fp1vvPIrHB8fMj0+IVETZifP+L3f+R5Xr9/gzs3rzFdnhFaxfeUy777zDt96711ef2Wb5fEeQnlWqwRp1wiZMNm+jJcKsZryzut3Wa0ForG0ZUtdWXS6gTaak+kLUj+jrSqOP3uEPluzkxT0MBQqIZNp7Or52DlVGBAWKXKUCkh/nijgUbIDeqFQUhNUjLcKISC8jEAvIaOsWZpIaPWe7+hXWV22/DfJgP3VIelgjAKWs1OGWUpoaiCPkqjQknRZ114EiuEVxnfeIFQtJ8f7vL//F/xo9hlHdo5HUtrApfEWqfLxwVkO0IMeqpex9+KYxaLlZLVksLnDq+++RdsI0rzH1duv8+jxfW69chOBYFgUzNdLXn3tyzz96R9QLwzlvKRdH/Dml77K6dkG86MjholHXb9Eb9SjP9rh+aOHTA/2eXx4yPbWZW4sa5LslNa31G3FqIDBwDH50phi9A1mv/tj3PSIrhkMQsXUAi9QwhJEAqJBSY8JCiMVImh8KEHnOJ8gVGygXaQUyEAIEbLmSWJjLlhA07W7QQYcsvN6OTwKpXyUyv0Sl+gOFEEEgnMQ4mt3bo5tcqT31Nai7JLVomWWxq5xP3cIFQ+kj+aCS25B1oemlDQB1BLSQtAfBzbHgv0ngmIZI0dEAokSCBlwXtCUIDQMhzA/Ud06jZ1+6QVZ4tC54e7VDfzl9ygGY3q9AdODh9jFc9zilDBfIVaAC3w2j8UgAjLZsplClkr0QNLbmhAGAScz9o+X/PTZAmmi6mq/TmgPVtwKOavVKtoxZeDpsyds9RdY4RDCo2swQbAzgo9PgVPLrF9w1lSEeoE2CV4s2V8Kbm57ylVNWwfqdaC0gvEgJ0saljNHvQgs1/EsUNcCLSXt9nsgA9dGW9x67T0uy/sU/hPOjlqGeWBZe0a55HQJgwLG9YqnPxNc2fDUDbQN0b4gYgPC+sCqFggJrQskhSDLMr7zZYOUjrL0PAiKVAv8OjBbBVQbmSXq1GCd5uhDwaVRhAYNco0MNYMsSqLnC49XgsMzR+8G5GbNKJUcVm+yOj1le5SSvSo5Cz04bihdzdUNwaoKJE7x9Wt9Dg5nDNOUXMVDsAASEaKftgl8/LBla6ui1zgWWck4lyxLF+W4LuA9WNd1El34osycv/JSIoCE4WhAuS47qbe8YJSIjmmS5Rn94Yiz0xOkEFza3uTo6ICqqZBEFExVrSjLVYws7byckfMSD33eWc7O1ggkKIUQGWXVxOZB8IRgu3OFo65LTk9c9FCGaDE7PHhE01ogkomdbWOzX2pi5rbENg3rcokUmo3du5wc3IuZwp3QRan4/FVSXXB3MJ5lueDw6QOu3bzD9z/+BHfviJ2dSyhtGPT7TDY3eeOdr7I4mzLe2GAw7PH+n/8Zv/vpv+Ha1Wu8+sqrXLlxk+nZCXbQQzpHU1YYJTk9eMHlq5fRaYZsWzZ2rrB6/EM++IsfUy5X6LomSw337j/ig+9/jytXblOVIza2LyHbhvl0Tuvh1LWkRR+daEb9EVpl5Dpw//kJTvfom4TpOrA4myKERyYJ9WKKXMxQ2iCCZNAvmM1mJMZweWvEw704sHny4AHKGLJ8l7Jc463A2ZraNVR1FT2s8zM2t64yr2fxrCvpZPYtHoevKvI8pW09XgR84yFxSBFBp0ZImrpFJymuLVksozoiRtK5OA33IaoqtaKqa+qyIs372GaGtRX5YIjJc+pKsa5rUiVpvaBZzhkOhrjQUtX1L/WcUGmCCJazwxf0M4XzKbZsMLTUpWdWVfz4sz2cBaMlGo9OFIlO0DpFa8MgN7HYSlJMElODVJ4wXZSs5qvIoMl6nB3NeHDvlI2nc772FcX40hY6tbR2gdAGdGC5mNJYy9bWiNu3r3E2m/P04WNW0xm0Ua1pbawtnA9k/Qn5cEKS9zE6ReA59jA7qmjLJYtFyapsqFtLkvb4zq/+Kq++9TaT8YTZ7BijNEqlEGScvArHaOsqo43LBKlIkpSdncu89fZb7D15jK0bVJrE9CbruHvnFZQxXfSJxiQ5Uki01FjbUq6XnVo0dMMycM5ggiJ4SVACpU3kIol4lj2/Ys19zkcKgI9MlnD+tQi7jgRvSdtUWNtS9HpxnwjE90rbrk47ZzKFi58jiENYiD9Liqi4ixJY0VH0Xxbe5zbVGJesXtaQruHg0X2KfoK1AusceVHQH44R+ozt7U1SESNug2xxZUWvl2IbwapqSIschYwRiEEitMK6Bimal3uZNojE0JMZdVOj84S8l3A0fcnwijDJhLYuv9D9/4ULb22SqL/3dB+Gu/ACaCFYlmsOD/a4f/8zPvzoJzx+/ITjkzMmm9v8vf/oH/LWW2+zvTEhSzPg50nVAaynCRGupTqp+Gw2Z1XGaBkRoqwggsNcJy3qJFDn36P7gJxzXX5znH6fP9x8CEijOolyQ5qnkfLXWrwLWNuAtSRK4FKDtC1NFWXuUmnyLKdXlFRljTI5WsBwOMRoQ1UeooiU8dliGjtMxtC0LXUT464So2mamjRLSbME6x0uvJw6n19xsbiO1B2hBCKEv1SEdm8gIKJHTQgCUfIeffTnhfvLOIALyAHEIlUIrLcYodBSY7Qiy1KM1hRZjtGS0FiU1Ny+e5fhaICXXCzmuEDFhQXAe8/25jZZmkdSubVYGQ//oiOn2w5I4JxDOIv3nrPTKWenZzRNixKaNIuguKaN3cL4sNAXCzQu4BhTck5b9CGgjca25wcn1x0CogQLYDo/5Wc/+wmffv45ey8OqK0lTTP+6T/5337RJfA/u/JkwKq2+NDQuCVN3VIFSyG3WS4tWdhmIRsOrkt87TCm4N2vvoWVJUfH+wx6CeNRzunBir3nB/TGl7n15k0Onh5w9forlF7x/NkjHj5/wN7+IcP+mFd2N2jFkupwQZoAos/VKzeZr1a49Zp50CynkGrLsprS1GC9py4PUE4gmhKHhVVLmFcM2pyeKshERqIUicrQCmRI0Sik0F1n71wKGgAFCoLrvP4hEBQoAcIbCIIQQ6dRUiE0nVVCgvbsSsHf119lVRj+7f4POSynnE4PyU3Oji0YqIyBKSj0kMKk6KAhKFS+y8bd18Fa5sdP+eTwh3x09oi9KiYMqKCo28BvfPvL9LRGVHtsTkZIpYiNzgVtCm/e+Ro33v46jUuoFlPGl3aAlERCvdxH+x5P958zSDSPfvYhq3LFxtaAS9NDtgYG7SyvXb/GA7/AtQs22iV26TFpCsHx5Okjauc5Xkz54f37TB4+5PaVbYLOWQvNqlyg1JyNb16H1Ruc/c4pwdFRnTWSluDzKB09hzqJ6KmSqoBgokzUaoRySKUhxGakD1GVHtUivussG4TXOOlRShIkeBzCK4JwqBBtLl4baH85qfly/hxnK4KvCN4RgkfiyXTJ6ema1mlWTU1tUuoq5ixfniiUFCgClQusWsG0dGRBkCeBupFoFWXdSEGSe/qj+HBvbXdvyoDuFHHOBxSgcOhCQR2LPh8gyIDA0etL9OoxOgkYZQn1jHs/fZ/9v/iczTQQwjFPS8GjFaQikCfxeSNF/CG7WeBy7sj2T1i3MNoZUC1KjBxQ3HybW9fvcnD4gqQ54sz3mdYLDA2ZEuTVlNADFwJFJtgcBNZNYGEFUgZMUFzevYuQiqpqEazZHpRUlcVVLVk+Ye3mtJWjDILrWznV8gTXBHwLjY0N6QAEpTiar5mXEl+k+GqNrO7zZL2CIBDzFh8Ei6Vn63Kf54cLZo1jXgluhsCyihnkSkWl0eky7uVlC20TcD2BlbD3tGa0E/eLUWb5z391gkShVUys8N5Fkj4RYiNsYO0gMYay9lRtQts4WidolKcKio2xp5d4hoUiIXB2MmU5mzJdWLR0DLOaRU/RLjrbgZH0gHW94OqmIl17ahtQLpB0NoxaCEwiefvVEYNeQi+BXi8luDXIaB+QQoLfZOJXkGYMeqbz8v1iV9vF9p2dTZFSdekoSSf1jVa3QENrW8oqRgd651kv19H3qBK8b9EqoW7WURIsZGxkijgECd5hVEKEmjqcb8jyPmBJkj7eeVwXrdnrFVRljQ8xPzzNUmzb0u+Padq6O6Sfszo0PlhMorsGukAESa8YQYDV/IAs6VHXS7RJLrgyaRKzg5u6xlYtR+slA6NR5gSbT7j29rdp1zOuXL3O8uyInUuXuXzzLpPNHYIUPH/xgtnJKT/43p+gpees38c830NnOQ/ufcb1xZQ8SZmua7Rw3Lx9l88+/ozL166REaeP//a7v8ujpwcsq5aZExTCkwnYf/6MN976OvnuZbQyeAXD3PDiZEZdtxyenjDZ3sK3DqcCk63rjGYz5nVN4xRCJZyeTS/UmYGEtg1427KsakaTAbatGG9f4vjgKRujPvsnp+zuXubqzetU6xIP0SrgFanJqdQ6KhWFZ7k6w3kiZM8IqqYh1YY0K1hWK5aLFQGHSXJ8EJSVIzWCVlikUNi2xPnIBYlqxxjx5n3MmBZK0QqPt5bEqDi4UQqdZlEd5QLz2QKCRac9dDHg9PQUJaeYJPJa/C/BPABQyrE4OaRdznCiR20tOoBzluenp3z6fBp97kphFBgdz5lZmlLkGUWRk5p4TwYtsUGwXtX4dY1Qiv5kxHS2YuvaJsJ5pg9fcLhqIB8SdM7ZyRlGSvL+iPm8jmwhF1C+RDQVo16OvHOLj37yEVW5oGkqghTUdUuaj9m4cps0zekVfdIsAxFjhJ88fYqvBEEnqDSmM9y6fZe7r73KZDJCCkGvNyRLo60EYsrBxu4dBuOrpFmf1kWFT9EbMBpv0RuOefH4EUkbE5eC92xubDGfTtnc2SYIhbUtVVV3MMaWqqxj80sb8mJE0RuS5hkmSVDaXMSYym4Ydx7fDOci5PNC2UZLiW274VdH0eoUs23bUNclSjm0jH/mg411iYt2WiVf2kKD76p32dndulot2lM7RpR18TB5vr5CQHVDNCkF4ue+Ntmc0Otp0iQgjeBk5lguFggseZpw3EzZ2tzkZO8p6xoaa+kVCf1C0+sVlNWMQNw/18s1pl+gpUYZTWoMIoBXuqtdGpQUHB2cYIxEdwkyIElzHW057outiy9ceI/7A9q2pbbthYG8ripWyyVnp0fsv3jGg3v3+eTzT3ix94LZdM6qqjmbTvmv/1//FW9/9av80//sP+fy9m6cnHYqc6UlzrpYoIkOJCYEzscoIuc6A75157YDvPeUZRlvBBnzos+lD3Seb6CL2To/fHqk0sgkQYRAmiSkiaGuSmzTAHGSBB5T5LhKkglNY1dYG7CrJb1er8v2Fvi6wQfJOetsc3PC4fFp9Js7j0kMq2odpVmdxKfqICZSCpROUCHezN51k3Xv44NZ6YsJ9c+TvWVHCIVuUh2iTJSIK4jZg52c45z8fS4TU0pFebCPzmrfect1Nxnu9wqG/ShxyfIcnMXkBhE0b779Ni5ERcO5d8O52CjRWlx4rOOqleRZDp2iQXX+8aZpyLKsa4x0xGUpWVU1shvfO2ujpN6HjrIalRBGaaSOXS5rHc5x8V6de3p6vR5lFYnlWuno+fIW6xyL5Yzf+4Pv8vDhQ3a3r/Dld94lyzLefv3NL3r7/5XXKBthqfDW0lYNa7umcjVrV1GIa0wTjVVjNt+8xFcdfPjR+3z00xW/9rd+k6s3KvYfP0fNc26+9g7pw/sEacDVVLOKew8/5OzklEcPHyGC5Fd+9W9zcvyEf/Gv/jnffOtb3H3tCuPhNvl4yNHZCWdnp8iyYT4/4+OfvY+yK8bDMd5FgFcaBOPBFjs3X0XR58n3v0d7JhiqjIFOSKTESEMiQaMwOhZyMkS5vgAkHhminE2iEApQHhFMXM/KgHDgQuTfimiHiA2jGJVliHK9baX5x/VrvLW9ySfVc8pJxdAr3it22VEjBlqRiQHGRIgM/QGju7cJ1rE+OeHB0QN+cvqIB+tDKt+yqTJmBIo8YbefMJ0ecvfWDXq6oGxrDqZTRpMR+WbBpZuvMdjcRaqEqtejPx5xuH/EfHpEmlym1Z7Bxg4nh5Z8lDMoUqqDJ9x49RVSrXj67IDm9JRbuxv0+3f52c8+xSjB7mTEZOMW89kaZ8ColKP5nJX0XLmyi8kMjh7T5YKWNaO+YPiNyyweXcV99iz6oUWfEFK0bAkhAm5kyJDMo8xeRJCKDTpOQEQkn4vY3UBLEXE7CrAywkiwuC7lWxBVUVEiFiPgnLNoaTEonPhlJ94JaRqbNxHI1BJCgzaGF8fPeP684vCs5eCoZNNKJtJzMvNc31GEGlofM5QbB3Ud76Fh3hXWecBaEK1kMJQcPhGk2hNaCInAOghlwKRxotP6wGhTcvJE4BYQbEy6UAay1PHw888pnv2XUaXUQjlt2F8E9mpY1oFcB272BKYruoyCVBItRF7w+SKwaAOZhF+5olDBkqmANVsczDyN04zzMU/3x1y/cZeqXFGVM4b9R5zNK54FSXUaJX/SZGT5kGxcMJ8+ZWCuQLZBlq+57b+LKE8ZpgLXKq4Mc1QVaHpRZZJnlnZmCU2gaSDJIREChMf0ct67qymbHNrPWa1nlCbF51uEYDEiPnsG0tFWjtppzqbRjvCT5/GOKSJzi0JBbWPUinLgJfgGcLDv4eYoMkmqeY1WimFP4ckRWpCaSLh3AbJcRrK+i9NgL6FyQNuQaFhWsL2bc2VX8tMfv+DTexVnox6sHuNbz+VRAvSQwjKceGZKcu/E0ys0GxpOFgFrAoMs2sbWrSQXcVhga09/y3D3hmGYrBkPJEYFfBtiuEhnU5uu17hyzmrZ8Nbb72BY/8JrYlAUlHUDtpNqhoC94M/EfO00y6nLOp5RhMAGz7qpEULjXUUIHkfn51YK786f+nTQrDg1j0RjT5r3cTagTKeCEwqT9mnqKqr0ZEcHTjKCi2Cg9XreWVOitzsKaQQiaJx1eBnQyqCkRifxAB6IZ7NAlGUKAYlO6CcxYSJAV4gX3Lz0KjSCt7auMNrc5um9+5ydTSmuXmf76l1uv/YKUkQI6h/83u9yfPCCIpS89e636e9cI89ygoDd63f43d/7HV5/4xU2t7b58U8/YXp2yitvfpWz02OefvQjHv7o+3z/hz9hXZasbGxCrhvPbk9hW0i0wjhPc7qPKedMEsk0cmgZTLZoXWC2WCJCw2lTkuocd/iEZUgxxRi8R6qM2fExKs3Q6YS6tYz6fY5O51QOBt7S1i2Z0dy6uc3nn95neXbK177xHvcO7yNVBMzm/QHONqyrFQHBdLYgkWBMSlNXnWJTcnJygsTGZrd3NG2UwSoJIclJ0j7T6Sm4SGlWMtq3UqmpK4sPlnU3FJIqRsQWvQHH9oyqLvFK4axjtl6S5GO8S+JQarXEti1OCrwM2NaRZr1feD0AzI8O8YsZRWZYzRf0ehlCBKZry4dP58wWLY0L+ESQ65QkURhlcCg8Aa0VOnk5FJj0B1R5RmoM3jsa1zBdlSwfvkC2Ddc3Jkwu3WBy6SqDXo9qeUbbLrG2wZgiJrM0FRKLEIYsleRFQfbt9/jzP/4Bp9Mldd0ihOHyZIhSmiwryIqCvCjQWpOlGcvFGfd++gHSKVwb2Jhs8s1vfYvhaEzbOoyW9PuDLlpQ0to1441bCJlhdIyiVVKihCLRil5RMNnc5Mm9z+OAo+Mi+eA4Pjsj4Ni9dJUgAutyhtYJRutYX2gdY5WzXoS4nk+fibFjSBnVuFJ2hffL68J/3VnS4Jw83k2/u4FX09QEX9Eb9LrJdDc97859MU0p/CXLaWdAif/74odGFlcstLvp9nnWsYxNxp//+7FB5EizlOGwAByrhSXViiSBvJ8wHPbwPg7FLu0MeHG4Iogk1p0EvGtx1lFXnuEoQw80gRbb1MyXLf1hj1RFa0lZRxB0rzck9RV7BxVJ0Wfr0hChzMWARH7B89MXLrxlR9Ru2xYpoin/4OAFe8+fcHZ6xHI+5/T0lKZu8DZKlJLMMN6ccOfOHS7tbqG07CBeCqM1tmkijVAbfOgAawKW63XX9Y3dHR/NwWilLqTK5/Lmi1zvTtZkrbsw6MdsTBEx8kLidZcrqbIYpC4NynR+YqXwRhN8iw81qo7yLdvaCLkwBqNlJBlKGb2KqwohBJONMdY6yqqMB4+ywYVAahKM0pH+WtcECauyimRQo0lEdxhxtrNjn4MP4g12QfaWMk7EVGQe/JyK/GIS5qzDutAV2B1giZeTcu9isRs6v4aSiiRV5ImhV/QYT8YURa+TSSpCE0iNYWN8meu3bsaNqbY4BEYpghBRXgZdMR1lJEpF1H6SpOBcFy0W5S62td1notjY3MCKwMnxCcHFrwsR87Cd8HBOOu/kJvh4CEzTpPse52qByAooy+qCzJgkGYNBH2sblssFwTu+/fVv85u/9lskSdrBH877e7/4NdnYQcwSTtf7tNZRt3NWraXBU5V75FISdgZMl55se4MvffUbLBZrciPZ3BozPXrO9/7ou8znU7a2rnDn+h1ka7h16w4/+OH7HB0eMRltc+3qZW7dvMTf+e3fojo7YKM/IB30CIlm/2zOowdPKaeHzI+PKZfHLGdT8rzHYLDBtWuvM9jYiP5tZahmc1YHpyTWUARDRkYiMzKdolQSFRAolPRI4QjETmOM6fF46REk4BukzmIjRxBjRoiwFqUiVfL8z6OoI6C9wkuJ6qjbV8UGl7NtvjO8jXMxeiIVDrzHyBYpFa5xqOGA7MZVCJ7mdMazw/t8dvKIveoUAVzLhqycx/kVovXc//FHbF0ZkeYZzjYIv2a9WnPt7ptsvvJNhps7CGNYLZbs3LjOelVi0oyk16MYbTDeuMHB8yckEgabmwS/xcbmLjLLsGczDj/8AYvymJt+wOLsKXfuXqderbiys0MZxmwOCpZVyeHzB7z61teolwueHexj1JDZyRHF5SEhhbppmeI4nkAqPH2XxQ1ZNXgylKxwATQCrRKcF8ScFAHBImSCII0HryAgGIKw8XDm+1EaiicqFCTat/GBhgAszilE0uBFgg0NKgj+0tP3F7isD5ytKqbzisPpiscvZuwfz9k7mPH8qCSRgUXruDRUHIkeV8SSk9azWENPhCgHD47KCapWMEgjS0EFaMuA1xKdwGQQeNIVgnkK9SImCogeQMA2cc/UxlNaSaI8bSuop5E7553leC0o1hU9E9AmSpEl0XvsbWAnh1EGWoE7LzgFJEEgDSQKWEVZ/8NPz0g3AiFUvLKbIU2B3L5BblKmyynj3TfRSYH3sPzJ7zJ/+OcUV95k6+5vRJBlp8Zqz/Z48sEZNwaCreEpdVOxuj/HViEWuaJBasdGbsgzT5E69GqGsAFpoNawrQXTU0/rJL7NaJpeLDSybfqDSVRQEQupnIAMFk9g7QJHL4457VVcGmUcHM45ma3ZKyusdaSq5UofBr2CPIFGKSYDyQf3Km7cHmItLCpIB32ubyucEzglcVVUZxkDhYoAGoHHa0VwAREsqfR4GVNDtBIkRY5JEiYDxZduOoTJ+L1nK8bjhIqEkXZoUcd8VyO5vQ2lhcIErm5KbOk4m3uenkXi/J1eACspW8d4nCKc6+JkOm+3i3BY5yLAcVYG/uQjx9qtWIb7XL1y5RdeE23bqd4SSZYZzk6nhE65JZVGm7TzbkdGS2ScRGZO9Hh30TXYjvob2QniopmmkbIjA1uHEIrhYELTNLGQFhqtEqq2omkrDAbhQemUojehadedkk3hfB2foyF6N5EgXMD5gBYdn8fHyZUnYG2FVtHKJ4Risyj4+3/tH6H6N3nx9BFHixnWx/1LhgZb15TrmqIfuP76W7xajFHaUNc1Dz//nL39A374Fz8kzQqqs1P6o4SqWlO0LddfucVoa5uf/OhnXL16BeEDt2/dIAjFwfM9nn/2I148fc6jH/+IvRdPeHa0REvH2ntGuSER8Ux3ZXeLMD+LzRCitVChGSXRXlfW62jbElA1FWVdIxNJLxGk+YCQTlhM92lcFeOTSosa9CmKbVbzM0yWM+z1mZ5NEdIwHhYcHe2RmpRiMOZHP/gRvV5G4wN1WSGCQpgU3ayoqrprsmiCbfAClLUEHUAqmtqifNT0a+1Rne0ySXNsU5IaTSss+JjMgxA0revOjAJnm5iDDJQIGh/wApzrFJXSRPixrSLk1gWEisBYD4SQILS/GAD9opcr5zgfrYKjIkcmipOzJT9+dMzZso5WVhPTjFa1o7UwyBVGBsrS4toFWW7wxHvy5HQVm0zrGpmmLCtLIJLJsyTnvW+/y+Vru4yGQ0Rw9AcDVLqB0hphUvb291gvVuhej7a2pD0B0pGngqzf4+B43sV02u6sGWLcXpqRZjFy10jJ5Ws3+fzjD8l6BSof8Wu//hts7l5CSIXRCXmeo3QcxBFA6wGETj7dtmAjk0V0pak28Tz4kx/+EGtbhoMRxWiESTK2d3bRInB2dshwuNFNhWtCcBRmQK83JITz4VvWndHPWV2KyJw4r6ckHeLsLymLhYhW1iC66VgI8RzoobEV1ldkeY4xA6RMcK7uXnfyPwNjvLS6+s7ucu4XD1jXduWM7or+c+uKvxg8ChmHtKEbeMbCvyFJE1bLiqLQKGXp9wu88DRNjbUBH5bgAt5JjAn0hymDXkJZN6SppqzWMU3Ce4peSukt41GO6yKYXVshQ+jAgscUqSITNeWqRrAV60/X0tYNz58+/kL3/xcuvGfzGQRoq4rDo8PoPSoXpEKQIGirmrJcsVgtsHg2rl7iq+++y9e/8rXoR5Apm5vbpElC09RdFFcMRldS4doW12U5n8sPrHVYayNEQb3sJFzIpoUk+TkcvvchUva6YtMoFePAVPSPK6VI8iGKuPkEYdCpxqkKaSzC1TRVnKxL72irijxLyLShbj1N6zBJSpZnJHlGmq8IPtDmGWVTU5UlSknOWNJ6R13HCADrLN56lDJY23ZZmZ3TuluAwXc3uXoZ3fHz0vIgz70QEiQX8oxzsBjnnSspCaFTEXTT7POIMUTsNGkdgS69Xk6eGob9AYPRMIIjREeklopEpnzl698gG/SobYR4qO7nxPfbUdcxR1Ub03XLA01VcXp6ysnpKYlJ2dneIktTpIp/TynF0eERrjOFCamwNhbabdN01EOP6z5PH0B3v5ukgy10PvZzn4gU5zCXuLC1igoAAWyMtxgNxpGY32WbC9EF3v8SV3/nMtLkZNWQ9qiiXlfYxlO3DYvFCbMAzvY5PfK8duUWN2/skCbQH/ZBVGSFZrrY4wfvf8rO5h5eCG7ceANVJJR/8if0+wP+8d//J3ztnS8xWz5h+uI5d1+5w6WtTVarKeV0ysZoyPMsY7GsseUxwa24e/sOWTFh99IVdq/sUmQZwjp866ldhV0tKV8syEhJugmGVBlaCmTIeAnOUyDbWMiRQkc1JdD5k+DcWxx89PNI12U2ipgkEGlrCqG7GAkBUnokEi9D7Bx3f8dj4yFExFgsvEZt9Eh2t8A56umU/f1H3Dv+lKflc9Z2zZVkQmYElbeERrFUgqUVbMmU+WxNPxW4YChbycc//jHjo1N2b9xmtHOLnZ2tqBpBMtnc4ivf+lukacbpyRnDzV0WCIILTM+O2djZJBvtgB9g/Y/I8wFP9/fYurTN5saAsH0ZJwJCegajTZ48/5idG1fpqZZ1MWHRSAapQOkGkynqVvBo74D3f/Qxf/TBn/Irqz7vJjfQIsMETRANLnRqlhAIIkdJG6WlPkRgnRBdcyQBbQAX3z9lkDjcOZnee5QKeJkQXDxsWusQ1HgXFUDCCTDhl627+T/9X/5HZqsVTePIjMLoCMoc9nrcubpDLx/Q7/Xp9wqyNGf9+Q8ojh5wvBKoNE4dlZBUPnC0ClwbS5wHb2Lh2wFOactAr69Zri1a0kUueqqVpGkCJgmkaVQLjTcUm72EYpThQhL3ExW4/qrF2wYpYsOwdIZ7e2sS1bK20HguohFbAlrGSbARcZquZAel0fG/K2uBTCdsXX+H4CQiWBZ1iZMZx0tJZWusbUhsQuPhtErI5i2GirY6I0syRu0Zq2RCtvpdNvue3jgl++aYxkHbCJbLmqPDmocPS56ddY1PWoQUFEbQS+LBbVUJknxME3KyYhCtVjrGBQUPQQlwojuMBaw0rK1ADwt0e8Zgc5feZst152Pxsqz47OlzpPRsv3EbKT0iOLRvGW4c8eadS1jb0DSefiqi7UYGaEEngcaGKH1MBMF5Ki/iFMMHWitwXpKlGgh4K5Cijw0CJ/pUbcPxacVpFSi8p1lbpI60777WJG3LMkg2ikA/C0w2PQ5BvpD8d+871ggsAp9KFpVDWWiqkn4qOmtGxLOGELkqXsAoa7m9Bf/+c8/hckl4/vQXXhOrsorpA1pRlStEl6xhO7tVWzesOvuXFBEU67zHWwDJsN+jLFf4IGlthW2iWk1oSWIk3rcEfGxEd1Oj2fQAk+QkWmN0hhBQV4vOK9YV+CFEibgyWF8jlSHvXWY530MZ1dkVBEgfc3tFtBuIAOV6FaUjISrvlDYYlXI7HzMIhgZPf7jF5be/SW0dWZYiEMxOz8iLjNE4ytrvff6QP/uj3+fFwRGz6ZTtrS1u3XmF5WLJ+sXnnM4WFM8fYozkyWdrekeXGaaSm7tb9HopzeyMV27u8trd2/zbf/Xf8/izTxklEerphcdjSAwIpcgHOaNBzp3XX6dazGlmpyBUjIzKdJzu1jVpWrCuWqxtscGjXc162lA2gX4h0KlgWq9ZL9e0JLTtimI4wBFTV1SaslrNmWztMj2ZsffiKeOtK+zYfe599jN6wxFaOVRSYIxmuVxFK0Sn0Bz2UqomxqTiLDrNsPUaAhidYtsSqSK9WUnD5s5O5HUgWdd1PL8ZTW09UsU1jgTvoroyKEcQmiAc89kZKEMQAi2SGMUlZUyYsTF+KjMJoQP6hhAHHU2nePyFL2FxPuaO61QzXVa8//kBJ/OKTBuyNE47pVRoqaJHXXW2DampHDSlR4jo8xVEO1JUebYEqTBKkaUpX/rqe9x87Sb9VGOrBb51XLp5DZPFSfdyXVKuauanB6wPPTdeu4mzDqXjAGh7dwukoG0didQMhmPyoodJDGkH9VIieoF3d3b5zt/4e2xubJHnOdbVFHlGlqVd06plfja/YEz1+0PyIuHpkwecHj2OU1gvSYsR29t34rPHWhpr+drXvsbXv/ltijzDKNkNHOPQcF2tMS6hyPsIIbFtBHE2TWy2uy5xwHfPrPMY4cibEh3Y7BzYfF6gn8+649eklAgZ0xici983MSlapwhMHJJ6hzYmqna7YdxLUPLLug1e+sqtrXHWkqQZnpdZ34homfJdqlXoBo22aWIUK5JgPfN5hB1qpcjSHKE108WavhLYumE07tE0liSJgOkijbF9aWaw3rGZaOq66YaymmLwklm2rmLWvPE1aQqtrRFaMewbZOW7wXCXmpXn3Hzj7S90+3/hwjtKfC0HBy+4d+9TvPfsbG0gg+fgcMn+9JBpvWS8u83dnXd47+vf5K3X3mQyGJFlOd55GtvQ0D3oO3N8CDHn2HYTTq31BSRNCUGiJLapCM5idJdVSywMhZToJMG2bfSH2XP5s+4OkKGDrkX5gtIamfXx5SkyBJx3pGmKMhqCxVUB0ZRx8pCn9ACpElrvOTtb0DqH0X16RU5/PGK1XlGtKk5na2QQXL58mdVqRX/Qp6prHtVVLA6JD9IQwFlP7duLKfHLyKxYOCZGIYgHFa1NJAwCLpx71yN8DB83BWW6w4qLB5v42A7ELD+J7jK2lYiZpE5EH/1kPGQ0HJAYw3AwIC2KCPcAnG3RSjPoTXjry+9ERH4I+E6WeL4YzyfMIQhOTk84Ojrks88+4ac//YhHjx6wmC8xOuU73/lr/KN/+J8wHBZo3U3ku8y0QLjwfl94x+nekxAXWmsdXjjSJMpnrIsS8uDDhfw+bggxVkQKwfHpGc47siRD4GnagAyqI3rGzafI8y96+/+Vlxn0GSQJeV0hlUcdfcbh4pC1XVKLmpUZkO0OmVyZRDvG3hPatuHqrTtsXxlQDHa4dfM1To9Lti/dJs0HKC0oMsVvfOs99g722d3s8ejRj7lx+SaJashpkK6J2b84zuZzXjy6hz99yDBLEJMJg942Dsnm7hXyQYHxltYFbGhRIsGWHtF6VHePoDRGgAwSpXyUl8soDdcixlpFpkOMtBIh41wahIw5t14IhJbgFJGcmwAigsJkIASFx4NwSFKEFKhcgu0mK8Ijfey6elKQDXLQQ1+9DGtLNT3jaP8xn5x9xJPVIcumZiMZs5kOIvyFQK4KPvEtl996F4zg3sER67N9RsMxvckAI8esVlM+/MGfIpMfAprhcJPxziXuvPFlfNVQ+5bhqMdqekoYjynn+6Sp4uzwhNOjBb3+gFdvX2f+4qdM1xWXkj7VumSwuclSGFYnR+S9jNZbZid71JcvsX9wxJGv+c63/w7LVc3+8Yx87wWffL7k9/78z/n4wQNehIzBRo83e7vRiuLBC4UMOjLRRIsIUWIY8CCiwqDFYsQAYu8/rsz4pqOk69aYJ3hNCBbdPfSc0gjnoLFIE/dKug7vL3N96fZVtre22Nne5dLuFSbbl+kNJ+R5n6AyVlXkUFgfyaWPX3uXj//r/5JT57EiSkKVgCyB/VqwLkP0LmcC4SWCwLoVGBMY5I4Pn8Ir2zGqq0jOvUigPaRCQBDcuQ4BiZQOpUqaNsrZlUzQaY+qsZRNTlXn6OQ5CS1zC9sOShsnpipAmghqC0rFSHVElJ/XQuA83P7qf8RZ2fLtv/FbHBydcf+zz/GLEzYHGdXpA7w0CNdgQ4lOCjKxRJ/dAykYmJQ8BJrllOtXbnG0WhBenLE5qNmcDBlPhowmBXm/ZLaY0x8KrtBQNZbGdY0qPFUVybdawEoVOBT3nx+Tao0MHmlE1wCNTR0tDEFHm0JTe0LtqMi5f1gxW5ccLlq8q1HB4ZqWUjjsozPGhSbNU/JEYzSsSwde0zMCX3sWXqGBfh698UrFaFCvoGkC3imkjpOUUnQRMw6Ei9A2FxzeGcSVX2Hy2jVOf/AnKPEB2hpmLRS5JsNxYgUrG1DCYYLj6sSRpoJJmvDdTyxWS2QbOF2C6ztC62FtOZ0Ffvy05j/+VoqXcZrRcXiRCJpGsKyjjeCD+yVv3c5+4TXhbB33R1nERnO31s6jZ87VhEIYECpG8uERSqAw1G2L0kkErHkdC4IQ4iETgXMNECm7zscGUWJy2jbm0yZexZhVpTFG4a1Fp5FuLISgbesL+XJbz7s8WgXKRyl5B2A8F4k2tsEHLjzlUmlwgq+MdmkOTvnoz76HG10m7Nxg5/WUZjpjNa8IBGaLGQ8e3CPPMg5OpiRGM9naYXP7KqOtETI43nv3a+w9e8a/+ucnPHtyj+V8Sjk9pC0SNnY32Nm+it7JsU3DdHHC/GSfFydnKNdyevCco+U6Rvd5MAkUWcG8XLOje/yD3/41MulZLucEpTheLBgUGdZlKB8VA3V9ymi4icrH7B8eUTuPbdeM+pOYL71eUgzGrMoyEsD1iOV8zmAxpbGe5d4+t27foqlLNnYmrFdTmqairdZsb28xmy1YeEdvEOgNx5QBgq3RQmOUoFrNaB0EEffzqq5i2oUCa9s4dHQeRCAt+qzWa5RyKKEwSuKITRx1rgSVcZgjhYxSWKnxPp6nm1ZF6j+emhrvmghElSqmACmJC6DwKJOBNAjh8faXm3hjA4N+DxECK+f4i3v7HExLzuHEbYBUSFIdgZRaRnuFkoG6cRijMSrQekfrAlpJWhvIsyTCDAPgBZeuXObOq6+wvTGhOtvDV5GWn/cnmCzGeiVOkxY9gjII0WKdp61qnGlBGC5tb7G9u8OLJ3vsXL7K7uUrDHp9kiRFq/PGgEAK2NrYYGO8QZJkEf5rK4qi6CJsKz7/5Mf0hzl5olHCc3R4jHce6WYM+5rWqsguaWc8efghutihbRtevXOXX/+N32RzcxfrKiBgjO6sqTKqOGW0jiJEx3eIRXLTxMjXIGLNI7v0HyUVaE3rZOfP7vYr/xJOfb4/0alwzwdeofPYap1003OHO1fGGHEx/Dx/DQi6NCb5UjLeDdCFlJg06RqfkREhOyCzEIK6AzgrHc+kQghaZ6mbmvU6QvTioE7gnCDYklER87iNFnHN+Kj2UEpgdKxnldYoqREqoBKQPUXbvox39s7RMwnrqiIfZCTOM+rlLCtLkiaMtaRZr0iTYYT0WRsblF/g+l8BV4t+FOc9RZHT1hWrdYwS070x737z15mMJozHG4zHE/I0pa4qjo4P0SaNxEcRCeh5lqJF/NFNa2MR3k1iZdf5a9uGuipZL89oqiXFcEKvP4nTTjpZeoDFchmLwI5cGnNt483oA6RZhpGS0His1Zgko1wGbNuQ9QbIzg8Mgdbb+EBMPCotSBbz2AmxgsRoisGQ4eYGeX+AMgkqSdi6vKZs9sjynPHGBuv1mnW5oiqXyAD7+8d4F8gyKOsmFhzqZdGpVaQAIqMfGhGx+qq7yUNX6MZ886jeUCFODoXuHqha4VqHUBHwJkLshiUqFppBCIos7+BrMOgP2dzcoOj1SLKEIssA9XKSriTBBu6+9gZZkVPXdefLFt35PFoATqanPHn0kE8//ZSffvRTnj9/Rrla4ay7WKRCCL773X/LsN/jN3/zN8jylOFojOCcxCw5jw17SayXBC/RIi6QOPWOxELRNLQ2Uux1B144nwoSQgdmkBhtSESUSTsfUMpcENC7xllsAvwSl0w1GE2SKSbyWuwK6wJfHVLXK9i4xI2vvcrWKxmtq9l//JTpTHJ8eERZVly5ucHXv/3rvPHGN2i858HDB0znx7gqsLO1wcMn9/mLH7/PZOCxp3P+3j/8bYwSSFpQmhenJzz+5BOq0z12dgYMxpcZbW/RLzZpRaRdL0uLCI7UQ7NqmD1fcfLJM6rTlpwM0UnKvYgdRBB4YZDeIlUOIb7XUU2g4r11kUOhUEaBi3KvaPCLBbwgxo0plQAeKTwQs7+FBKlVjHGQDVIkhLYFofASJAqVDpC7O9BYmtkJJ4cveHhyn/3lAVO7omdyBqYgVZpcJ1Te4Yzlju4zHr9OUCtWDn782U/oZfu88dbr3LzxClmxxc71jHQwZLl2PPjsZxwe7fPpx98HLymKTd5572vkgwmpVoRizHz/HpujnBUpfnrMqj7myp2v0pYnZDuvUC4OUKsTitErzJoDJA2DPOHp/gnF8D4bu3d48uCU+w8/Yzi5xCdPDtibf8Lnj494/6cfcrZccRgk3795hS/d+Cr26bLLLRf4UOFCGteL13hafDCI0BLQIDTet5igESYW1dECIuJ0PNhOVOOQOJRJIu8CQx0iVFIDQhjaNkr8f5nr//hf/F9JshxjMlSSILuGnw+C2joKJHW9BmtxtuWNd97j82tfIn3yAaVXKGDtAtvAl68IJJI0CQgVaJXAdVTyxkpSE0nnrYQiE3jh4jNhpVnXitOZpBgoyjahGKSoRGJUglUZLhnQJENU/xaDq19j685XmD27T/YX/2f87Ck+BNYhRAm3kyQqTm9nDYxzQaV62Pw6l1+/jXM104/fJ08McniZ7/zGV/noacXxQc3Jh/+evU/eZzlf8+6v/nVM3mfZjHDDS1y79SqqmNC6htA1E2cK+llOkb7GsPcpt28O6PUKvHMo4ZmMUt792gT59QnlYsl6seb0dMknnzqeH0ZycRdzwXhzg/lyRSiXWAVGCRQS7TVFoggmJbgWKRoQCXkKNlTkZk0iPBvM2ZVQtRUI8Hh6omFzcBihTEFgbcL1XZgeHzLo95nXAq8NMggQgdKmaBzCSMapoa59zIc2AuEFto5i6XV97seOedqeAucdP/jgU8rslOXBnMYr8mFKNm04nnnAMs4kyyawMcpxviKVAekz/t2f1+zrMdd3Wz59Okf4GJNDIjhZW/6nH5eUradlwT/8RoFvoi0KIXEhwpGGKWgNSQiM9NkvvCbimeU8wjM2lYN4+cySQuCCJUvS+DzUgrpssG2UHXt8l8Ero/zY1iAVdVNFSWanZPMhKoi0NjRtFQ0l1pPmKirdjEZbje+GF8EHQpKyfekmR3sfd2kHFutagm+idUybCzKxtTbG97nIWiGskFKRmiGvbN5ifv8JD56+IOuVNNkZc/8p89WSyfYuz1/sx3OB1CghqWvPW196i0F/QJJoDl4cMiwURa9HnqfkvT6Xrl+nKBJGhSb1lm1ZMzKGxdEh5bMHzA6fMZoMMUazeviUcrbm5taIe6tTjqY1WaJxbYMBvBVMsowwr1iVp+gkYTGfsy6rGFtoDNQVQQgWtcPOT1DVkiyReFEQbEmWGM5OZyzalquvf4V6dUpFxnq1wjeCJw8/47W3vs5qfkxbV4ikx+nhEZ4IqfICVCgZbV/mcO8RaWZoqiX9Xo+mUrh6TttUUZUiFIEWrWN8ldEJdbXCtjXe12ilyYqCbDBgPpuxMR6yKmu8a1HS07hIgHbWXjyL8RYhFT60GBOz1tNeTt3UnfVO4JW4MChJGQFg2iS0riEvChbrkqa1eP/LPSd8a7G+JCQ5P/xkjycHi3guEIIgJYlR9LMUrTWJMRiVRIVG6ynbFu8dqUxiUkQaoWzeC6yNeefWWzKTsH3pKjuXrpL1MmhLnDumGBbU9Zq8GKL7PWw7I01T1q3FZIa6qdCrQDEaIaVm2C+4ducGe08P6BV9VAd61lqhdaeqhfguy3g+ClikgnF/jJBRyfLhj35IZmBj3KeX5yhfMRwpluuK2fNDsl5U067XDWU5xdua+clTtrc2uPnbv81ovIEPLXmeo7UhTdOuphKdWkZ2yp2o3okJTy3ONXhvadsUYwzamJhSoxWB87jec8BapybvBpMC0TXjfRfPHIvutm05T5fSKto/rbV43wAv94zQRTr/fBF/YaEVMiotZBd76iF43ylr/jJM2rnYTHLOXQzrynLN4vQIQaxLQysgOExnB25bT90EpDKUZUlZxRi+pvHRdhfiELL1dRwehTj4tNaxXtdoLRDCkWeGtmpBa1wIDIYZVdUy3OhR+gGWaFHzXXPjCz0TvuhCkVJhDPR7Q6ZZznA0Zmf3CkanZFmOSUzsmnRShOVyyeHRPnVdU/SG9PpDEpOiFFRVdSH3bZ3H2i7uQMWYqm4ETFmu2d9/RmtrrhUjnBcIF/1pIXTxVB0kLFLMJVpHOImQUZJplCIzhrJcAYK8P8Ku4jTUFAOCcwiVxMzGvMDVJbatWa/m8QZdrbDTOWmWkBQpeVFgOkmEFIrx5gZV2SDRqDShKHKaekBdV6T5EKET1MEh88UyRvfQ6SW7yf/5jQgCpcRFvNh5Z8hIGf9MyY5a7HEuxCg3EQ8tPkDSSeqtbXHduVsrFSnqScJwMCDGgiiGowGDwYg0y9BppNW71nYSOIUTgqLX5+133iEQ5SJt216Q4k9PTviDP/wd/uhP/4jjvWOatsF3fm4ISKnRJmZ1D/o9tra2OJseMp1NuTG+ybmRVHcEe2PMX7onXnpR4iLXXVEnpOwWXqThms5mEP8eHaSv24Q6uFzbth3JPmbOe+cjTEr/8mROITQyAXTAONjYuYwNArtwnNKS9gpkKlEmBVGRmoIbdyZMdgY0bcCFmjQpKC6NEUbT2DX/zT//f7OczVnMZ0ynM/Y2jvjGW6/znS9dwTYzUDnO5wgp2Xt4j0f3P+SNGzcYDG6yubVJkifkecpOMUZlKT4I1ss168UJPigefPA+Z5+9YNDkmER20nCNCB2h3NuoJiEhUOMQEX6HicWfOo+Ui/I9EQRoEzd/CSKViFYQnESJuEkKEdkJP9/h9NbFrr3zBGVBRBK9FBpZ9JHbQ0JZ41ZLTvdfsDd/yP5qj2VdMtJ9sjQllZEKKpCYEBiaAWspGQxGrH3g/v2P2N3ZJisESmr2D55SlmtMMuH1d97D4PjWr/46LYbZ7IwffO/3efb8Zzz+/EN2tre4cfMySW/EeOt1BqOczAYW/hRjdjmdn5EUCUE61OAylT1Feol1FYUM1GXDelFzMp1x53bKi2D5/T/+PcajnI3JFn/2hx+yd3zMyXyFbRt6g4Iv//Uvcf1Xf5Wjf/mA+rPP0SGgiLmTQSoQLRKBlStCEDivIbQEMpAQZNyTEBLRxXo4oh8vIEAoNAKTpljnETZA5y1Luh6Uc1/4kfBXXm12maAkjQdRRfq0qEq885Rt9K02bYu3Hh8i8u3Wr/8TfvrPP2S+FrGodQ3eSZYLhZeOtAqoaDCkbGBeSb56K7Bp4Js3od8L6ESgjAAtWbubBHUdKQVZP4+gRSQ2KKzyeClB91DpEFlsItI+09Mzfve//X9gly/QHq4OJbdG0MsVSgl0cKAU2yYnzweMX/s7vPkf/xdsXs750Z/8B/705BnL/ees+p5/+d/+93zvDz5g+umfIxefs7V9g5/tf8qvZTnDfsqBaNkYj9GpJM8DNhiqNiXTDVcGnq3k+2TMCHXDyYMjykKhE4POUrJcYuuW4BqcDXgL/QJu34TP96KrPzRgjObKsGB7a5to6BVkKuCDpNCaLBHgBSutGSQRZl8YsD1DtQykuUKOCqTwmCSjXjWsaotOemgJeRoTQwKwXntGI0+iG9Y2oUFgo02Tti1xyiOtom4CBof1Eq2gagWNlzihGfSjHUWFjuyeFGRF4Nu3Fvyb73+IbxuezzxX3YC5n5MJS/CCF6cNRjr2zySbmaOt4F9+r+bhwvPlt3PKk4bWQw1UVlEn4KXk+kjxw6cNq2XC/b2a3cKzqh15GjCJobKa57PYGL97NSUJXywm5q+6kiSJ6SxYAoF+bxL9sz7giFwWSQQRecl5yikiRP5LzBmNGdcqSWicRYgoB5aym06HLvnMNt00xwAiFsrW0uCoqzVta7uhhY/Nbec4O3yIEIYgz+M4fw7Yah2EeCZT2iCFotcbxuhUofHOkmjNydND/vyHP42pA4vA0s1YBMG9ZweYLCUgeO/dr5H1+uzs7HDrlTvcuX2LZ4/uc/zsELzg/uGa3Ws3ELMlH3z/z9jc2iB1awam4lY/ozye8h8+/tcsyobxZMDlnQ1mlcefvWArsZRhzeF0HxEslWuprUMES1NZ+kpwdHjGk8dPuHL1KpnKmVc1Rgjm5Rp72DDuFQghmC+XCDFkvaqpgohMEgzMT2isw6QTVvN5jG+yC3p5j1W5ouhNePr4HsJ71uua0RiWqxXBeaxvMVrRlAFbzZjNliRSRtVD6wmujlGnbcCYJE4qraOs1qRKsCwdyBbrIDUJvUGfpMiZn80JwdGEQFWVcQhTtzgfSPKsg1LF53aQKgJrVdegNQbnQSgTGwMdvOtcjeghpmeEJCoxOqsYQsZC/pe4tPJUreP+wZwHeydRfSdktKAaRarzSH0PCiEMKtX4xtPPY3FVOx8tjmmKFg4pdTwb4wk2IKRgMBhw5+6bbGxdIi8MStZU1QyVWMrZHqPhFjIdkuQ5V668Sl1JXFOCneGcI0lHJMUI5wJvv/0O3//THzFfLC6mvm1jSROPSKP/wsioOBEddyrN01iTqIT793/E8f5TXrn9KoN+Tmok9VlLgYU8YSEVoVxwdnrGn3zvQ95+601GW5eQ1ZKBGdPrTzBGI2QgSRKyrMDaJha2RDZUnveiHQAHxLivJE0pyxVtuUTVK5TSDIYTfJLGIci5SMz7aEsTL9OQotqlA6N1KVbWWlpb450nTbML2bjznnW5JE3juZ6gLpoAUkoSExWQwMXP8B14jU5+HhPLRGcJfSl3l1LiQixurXO44HBtjEybTo+QStLUIHAMhhn5cBvhLE37grqG1aqiXK5JtWJZRvVsnhfdsK/CNxYvFUWWRQuACBgtKesmqmKFJ0sVZWlJMo2UmtZZPBKhNXSqoPPEii90/3/RhdI0Uc402RhT9N5CnedZi0inDsHjQsCISCxP04RLu1eQMhaGUd8ffSKxUyM6SJaPebXRhhJvghC9vVIbtq/cJk1SiqJ/IbOOnZTQSa/j/9cdPVsphW1aGltHsEQdCatKq+iHUoqgMrxYxQeXEHgEQicRAKIyQrXEuHhDp0LiECRdXrgkIM7hB1KQmJThaIQQGpN2G2ZjaZockabYEBfKi2cvSJIkHng7sIr3gXVdddmKPhaIBNq6Jc8zAtDYFiUkKnikkDE3u5O1BCJALjEGrTqIXJpGZULwKKno5RnDYZ/xZAwi0iDTrEdisphPJ2Pn+5w+brQiqJQ33/kKw41JzEgP0ee4WMz40+/9Mb//B7/L0cFBB7ITpFmU3BgTM7+v37jN9vY2W5sb7G5v0S8K0rzHxtZO9LZZGxeTiwX9er3uOmLiQn0gus8yNQatNXVd07Tthcy9ripCR1OXnd8lFhgyqgRse9ExazsvdyBGmukuzkVceMJ/wct5YrWpUL0ctGQjBGods4vV3R1m9ZL2yYpqXTEe9xn0JfPZkqTfJzMpiZ5gtCFLFMp8iTe/fJP/4V/8e4w0XLu8zd/9znu8ce0WV6/fiNYDnVJ7TaJTLt18HeNhezhgcuUS/d4A6yDX0btSrkrKdYN3FucEnugBejFbMzQGKSyOnBhF5XGhRsmEEBxBOKQLKJXEoi10G6TqeAR0XEovkCpCioKQhNBFv3UPaCGIhzyZIGQHDQptlEM7fyFp8yE+PNVogpz08FWLXc443nvO3uw5T+fPmLYLkiSlkH0SlSJEixEGiaZRgVp6Jm/cYPtawff/8Pd4951XybINhuMd6sUzVuWcajVlOd3ngz/5H2PHebKBGl7B6Iy7r1zDvPYa62VFuTphXTnS3LI4uY/kJkVRkPcKhpe/wqPPfsSTR5+zs3ObtnFIGbOa55Xgo88fM1/PYhe+KRG2IUkEyMDhdMY33/sO+0clH95/iHeWzKT8jW/c4je/83XyHcPor7/K4YsD6sUhiRcIYTEIfDAQaiQDCCsCtjsAxc8jWIlIRJQSBvBNBA4qrWOEnLP4ECdnkowslbjyFGsVDouR+uUm/Ate8WO1KCVomobaOXyIE4rQ+RCljjRk4TzeaQZX3qbt3cBP73PqBA2waGFoZLRI1DZ6cQXkwDoIXpzGwm57DE0jiVyaQFN71u1D7j++H8nAWdzX2rplWgk2ckGWSXpZRtLLcbpguk6Qw132p3Pa7ArN+jmjK3cRZomRCzID+BYhFCaRqMTQ1msu7xYkRSQat6Vj7+QnPCt/zMc//Pfcvn6dK9euMRp/h1Ub2H78DGvnnB4e4JsptauQ5SFFb80kN+RDxzid46op1UKxrHo0K4VtG5LE4V1FllUICSYVCO9xVtBUAi8dR3PBkzngBEYFNvspRZqhtCA3irb1aKNRONqmxgWByhJGOtCGCBZrvMEYw2BrG+kqvI+5sSbxZJln2HosAa0lRjpqF/3aqbIUOrBqAsFA0pZMJgU2GOomIDQkIj7XZWIi3Kl1SGERaFxwSFuhVEEVIt/knN+xsTFisz/jg3tH4OH+wxeYrGCGI/GxgWOUoGpbfnoauPfM83ytMEYwfbHPuglYBw2KP5orTGMhF9wZGF673HIytZS14V9/1PLo1PJ3vxK4tWXZO7K8mAduXe+RJ4re+Bdv0joh0TpByzhhiiChEKXePpBmGda6OKluGlzbRs9omiFdTOc4b9C7tsGo8zifaN8RQqONoT/YoG0q2raK5wyp0MrERqe3LxNRzg+HwZ+7UjpIpn4JUpIgfDwgK9X9HA8hRIirEILg474/rUp+cv8Fh/MlvUSjbcLUtuyXFq0T0jzjtbu3mc6XXJ1s8a1vf5vhaMijx0+4f+8+eZqzXLds7V5mOa85PdrHVSuWbc29n33AtXFOk/R4erDgZLFmY3PCjWuX2B71KLKC2VnD7OwBPR0Y9wrmtUcExeHZEiMFPs+QOmVVVzzfPyDpjbHlGf2iQKYJ9WrJcrlmua4YZQnr2jKbHjCa9FG9CetqDcJhSDAm0NvYYLZakA+3UctT6tZFOF6zwBQDJpduYcs1ra8JLlBWNW1dkmiBVJC4mkG/4OjkDIGnPxgRZFyjzlmUgHI9iwWzUFgfYaWvvv4WG7e/yWc/+i7l7JRmXhKE440vvcPxtCWcTSPkazjsvM7Rxpmkmrpx6ERjA4QgMYmi9b6jMHc2AhEIQoIGEaJ82iQ5jS1RyrAqG7RJ8aGJ/JZf4pJS8+hkyscPjqPFrGtCpCbaIYTw3aAuQRqDdQIrAlXrcUFgFGSZwQVHYnTMqrcWowzLuqTICga9IdduXCfLU9I0oU4y+qOUupySJD0W80NyBKF1DIdj3njrq/T7fdZ1zdnhM7SoyfMBaT6k6Ft+6+//bf7d//Bv6N8bc/VazdUr1xAqUJZnJFpS9MdIJCYxHYcqWr2c9VSlZTS5zAc/eJ/cvMvG7gZJsNRHz/GbVznYO2bcU+wdH7FcLSj6OcFbBJAkaff9QKuENM+jAkYEtE5jgSs9PlgSUyClwTlH3ZQ4Z7FthbcRupYXo24a7gjexohM2TVnEAjRwdO6WGYhiJ5/71BSd2rXNsbPKRMha01DVZe09ZIs68fvFTw+1Eih41lbnKtT4Ryy9vOzYd997Tzp4S8V3krRNm3XXKlwztMrhrRVycnBM9ZN5ExtTQqklGxfusaTTz/CSIVMJbPZgqzIqGYNDkeSavABZSTGaIKD1llWyxmJiZ79c2ZUWdXk/RSpBCbVWBsj4rSKtiTnulQZLdDi/w+Fd/Rke5QUZFmOEB14pnsIQPywMHEyaZK0kxtECUv8UOMbbpIkdkU6iNZqvaJpu5iyTn4lhKA3GHC5fxnbWlobMy+TrkgNIXoRnIfESJIkjTeZjZK9uqlRWmN0QrgAg0RJgukPCO2atmlidJaU2Pac4gc662FCwHmQrSUfalyAer1AqIA2CqHTyERtLXkRczJVYnCtIOnAEEnbsr29jXMB6zzT6bSLR4uNita2iIXAOY+zNnY6nSNIh1YqFs+cB8ZH30GamOiVELKT5kTAnDE6blRG47zDO4uUmiLP2djcoD8cIFX8XkLqOFnsbhKHwxGbIkoaRqNtbt99pdsgoxT86bOH/O7v/w6PHz+iV/TZfGOTXq/HxuY2OzuXSLOUQZGztbXF5sZOtCZ0shHRTeUvMvm6f59Pq+OhIvwcNO/lP1Vd4cpzkuLLhbter/DekxcFQkZfHCLGqgTfdeyC4zxr0Ll4sFGZegnq+4J+jP+lK05ziaASHCJJUEWfermJeb1g9OYup7MzPvjoKbs7l9ja3aJ1FS8ePkakY67cuASuRcoVZ5VjuS55792/RU8NOX1+nyLv8/Zrd7ixe4O8pykbi5QxRsSGSP4dX7rJ1u4mqZLUwWNDwrQJDLVACo3OJKvVnHrd4JYNSvbJkhTlDd4naCMINAQt0EIQvI4eMR+LZYJAhhixEYjDF5kIZBAIJWM1RAT+IePU3LsWoVWUpwaJUB2B13kkupt4B0QiLrw02vRhMESOM0LV0s7OWBzss3f2hP3lHmfVmsQU5DIhFUWUuqJBxYaLDAqRKC59+y0+/PAvePrgHuLqZXq3N1DlGcY7VO3ZGO0y02eEdYUpBhyerOHsEdPZAqklRsTX2u9ljIsdbBXQ+oj9J/uk6SYbG5doexm7N+8QfMvPfvojskSxvbPBcFRgrWFdCZ49nxGE52t3dtndHfCnP14jZaCnDJvDhP/0P/nHfHL/U1gf8fd+/TX+wf/mtxiPd0HB8I2M9a9/iZN/9ztASyJ0BK2de498ifUKKXyMKBECZxRGvexgO++wISCFRQoDIYn7o2+QwqCyAF6hVA/rZnEt6l9u2g2wriuksPiyxduSar2C1lHWDbaJr7VuHS7eHCQqHgKufuPvcP/f/Vcscez0JGUr8MsGYwKpEmgRnwmNBakDD08CpVcMNlKCDsymnvmZo20ctfdkHYRNtg5nHdMqxoM9OxWMU886W+AOF7RW8HQumbyqOXz6FCUtPW/Zf3wfOzCc0pBpzyAV5AqUrvFhjZu9z7/+f/7fePzZT/jk4+8zatcMM6hbyXdeu81ke4LjjEQYGufJuyLLCsGNK2M2zDG3r8zY3Dgjhu1FyI0PCu/6KDMhCEG7KmnrknJdc3rcsJjWPH7cojVY51nVkf6e9wS/9s0hRaEIrWcy6tG2AeEa6hCQ3uJqkCZatVaNQLWONHUIoxikkkAZ9806SkmdbfE4ylaQGEGmFXkaEw9c6ygbR6qIKgMfIBUoC0JB3VaRni9MNz2TNK2nKS1FpqM0TwRK22CdYJgK0sQyW4GQhrJuWaw0VYAvf/XL9C7NOXjyhJ/ce8q6WtDvJ2Q4jteeYxdIFJSVQOYFl/qedWjYLiT7QrApDVtGsVKCSgbWbeCj5w1eeLZ6gtms4Wd7DUKBFoJV6Xn7zQnf/YsFez9b8Y//2hXuH6W/8Jro5QNsgLRrOljbdJ5PCwGCa/C2pbJVjDfSmtCRBEe9AWW5JHJcPJg0yi51N+UmSk2lDFTljDwrECiqukLgcNKSpDLaVjoPpjqXHhPiZ9xFksbs55eSeIGkKLIomd3eZHo8JbjAalVjbY0PFm9tnP4px9o6NI7aLrFyiAqSZdngheTRk2eYJOGtQY9A4PP7jzh6/ggRLLUL9IcjBHB2dsrs6Amz4z0e3/uM6dERg3bA49UJ67qkbFvWrePw4AAhPDvXXmF1/JRbW5rM9Mg1vHppzHRZcbhsWS9nDIqEIhvSK27w9OQR/c0Zy9Oam5cFpsipm5YQNPPlivnZGTLJma08q+Uhk92riGJEWZW0MkFqQ7JeUlcVWT+eqVxToaRmuZyxXKzI+xusF3Oc9fQGw6jwCYFl2eLKBSE4xoOch89XVNZxQ0RaemsdIUSSvQye0lZomZAmPfLRDvPVmqP3v8t8ehghvcaQZYrVfMpqWeO8AxzrVST2Z0knK1YSJ10cFEjFcNKnrCx1vSQxAofGBhchk1JFgK+QaCO5dmWD+bphNptTtw1GROmx0eaXek58tj/j44fHeB9BWkbHiaeUomM7aXJjKK1HWUtiMpRRWNGyasPFmTEEzyBPcCLG9Ua7qKCuHVev3aIYDEmSBKUVzlt0kuLFNr3BRvSsC0jzHOsk2iiQitFwTJoWzGcnrFbHBJYYXfDt977JqL/B5mQ7qqmSFKUlVemwXnF6cszW1hZSBUJocK2n9THLutfLcLVkfzHle3/+I7713hsMg0XaFYcPPsGVx1RtxeboEr/+a9+M6hIi58r5EkTeqVwsSmqctaRZjzRJsdayLpdU1Zo0SdEm66J3LdY2uLaCYFEmJ+9NogJTKlwQF/bCcK6uAQguRvu2LUmiabtpl3cROOicJVEJSIVta2zbxHspERid0baR9q9UIM1zLmC93eHknJgeh7Jdwd0Btc/P/fDSqnpepjvXdpGJhun8hPnJGVU1Zbls2RjpbhTkOHr+EOc8aWbwrYuqrTRS3JWWpFKyXq5Jco3REmMUJsuwjWVZlmT/P9L+q1nXM0/vw353fMKbVtx77YSwkbsB9HSYPD2BIw4pU5TFsqwqkyzpzAf2N/DHcLlUculARVqkaNqiLVukRJrkDCf39HRGA2jkDey08lpveNKdfHA/a2FYHrrA7reqDwA09sZe7xPu//+6rt9VaEI/ZEE5Rjabjrq09G1mc5VVQTkCwQciQ2gxSoKR+PjF2Af/foM3iRivAGgKpXP/ox4tv865bGUardKZdC3GfJO4VrkHN4xfcK69UkpmhOzo6xc657NtWaCUxoUwdjpniMA1zdvnvFRMiabrss14tGpbY3J4XumckY4p13N4T1HNCe0aJbNFQobIMFabKTV2ZpsSXY12C5EpqCkklM7VHFHkC3YymSNp2aw3uWw9JLTR2eKsDMko9nb3gYTRYqS7asrS4tzAxcUF7WpN8J4hBFLMeZEQclZPW4ORCqsUxmaLg0BiZLZAFjY/WIuyxpRlHvKdGxX1yGw+YzpfUNV1tqGM+c+s2GfVMdMK84bTmpJXXnuNxdbW9c9SSsnO9j7/i9/5j0Zbe/7Oq6pkMd9icH4kGGYK5tUNFEIefPkL9vGr6ySOdHM7LmGuciApZhU9xmyVMcaOgIR8GBTjJmoymeZBfbw23ZD/mRiXPUqprIKPdvL5bIbRhrbvcCF3JaYveJP8Oz8ykmK2Pgk9WuFNYlMlzheS1dNDtuY1r7z8Erfu3KSaKVYXA08Pn3B0+mO+82d9to1qyXQypa4s0a+YVRPMwTPMC8N8soupSoSqUMqzXnf0VpPkQLvxKDWlmmxRy4E+CYSdIIg0XUtVlPhhoG8GYtT4dsPm8AIrSrTQqGTz4G8MpCo/BJNDyQIpXV6AjfblpLI1FZUHJrTKoAutEWTVOsudAiEMQiZIJr/EVQTP+P9JOR4iEyLZvAira+TWNlhD6nqG81M2x8c8Of2U0+aEs2FDaStqXWBVgRF5iQKCJD0pSgSGWFnqe7c4f+d3uX9vn/n+Ae78hKduhQueyfaMmzeeYbaac3j8GClq7HDKfHePoiowQlIvFohB8OT4Ux49fIqOD9naXaAnNVp2JBe4PDthPplR1Qs+OzzjwaNDlu0lr70woSg1XUqcdQ1fenaLr77+Gq2e4bzi4vySN167jTGJ2zf2+c//47/Gjj3kzddf4NadV0my4LJp8atD5l/d4+ydZ+k/+4zgAzZ1CBq0kISo0brHB8OAxyRPERKRfH9L1SHi2LIrFYi88IhSkgi54SEOKKHRUtMnSRQq70F/xmXU8Sffxbcd69ZlFe+qtEkpTAJnJLYoAEU/9JQWvBuY3X0BMdmnbg5pmkQIiTZA6rJTQAmwNruMhI4IBLsLmEw9VkmqucXs1vyLPz2H3rErwReJF/YlqY9MheC8T0wKCFryWZuYlYqbVWTTRd755BNk50nGUkUBIiB1QSHy730VZ/HOY3QkrD7k49/7P9GmDBfMrAOPA3bmmuACb737MT/3ZsnZcmCmA+3ZIYtZ5JX9BhufkNYDl02uzFFKUEwMerQOy6TxvaPvOrrG0a4G5ADTqSBeKP7gPU9ZCRY13JnnbO8nzV3oplg9sL1zzEWvKSQUwjEEiRUOEyJWCvqQnWpCRRYyMbhIkhIpQl7AWY0goIsiL7Z1Poz1g6PpAu0QmZmIUtD3A+edQImEQVCVmVLuiGjRkTyjhVpSGYNIkdZDE3Re+IpIHyM6gA9g1QByweADTS+48/W/yTNo/v5/899w507BJ48f8tHhEqLgVi1IPvH4QnDuBP+H/+Kv8ssvHvDOO+/z9KP3efj9Iz5bBbanHgusNpFkNBcbR5CSF24KKp04mAsenSf+/CPPLzynmIkz/tYbiaEQPD5ccuvuzk99T/gxZ6mKBSkluqEnSEVhNLNZ7tbuwgiHleCG7AAUStO1bXaQyKxGFWWJUgU+OPKwnLC6GDkoiWZzifMeq0ti8uMgt0FpnXk3MSvoKUZCgBAaGBfIpFz1CqCUHvuGC9zQcvTonKoo6LxD2wLXZLupc56yLHnm2T3akzWbp2dIscGT2DiNMBWbdmB/d0FZ1RS25OLsAnzDwd07HB2eUk+mTKYzjg/PUcpwenTIxx9/wqePDymD43iZc89Nu8EJgR8OedxH/upvfJOfe+0F3v5Rx7d+8BZ704IbOzso6ZlZwcGs4pF3uBDwKfLmc7s024Jbu3u8ffoZk7rghV/4FcS7H/DZg/dZb/oMtlqdcHPnJuuN4OziEt8M1LXJTSkhcXh5ST94LtoeJXK2tSwNViW6duDs7BiREkU1o+16JJHsn/QIKeg3HUUFu7OSTRc5Or1gbyfDy7zLILdEpDQ11Xyb7Zs36Xxg6Bsm85r1RqNJkAS+9zx59CiDZQtLP0YCY3Q0PWg1IFSR63tToh86wkleyqbRXi6UZDbfYhh6hr4hiohQiiEkPn7wkL0bt3PtXfSQAkolqvJnG7x/8P5RdkCNFu1SG8rSMvjcm5uUBhTzWqF0wbQq8SLQrhNO56FoCAkpEsvG49z47oqSlDxVWfHmN76GLcq8mCIyX+yit/cRssjn3RGuFYVkcJ5hyDGN4DtsYdja3uU0eC7OjplM8vL0q6+/Qtf5DNccs/eL2RwhxSj89XjXo2Tu7E4x0Pscdzw/PeWNV55ha77AOc96dUxVlHRNyzpUNBtPWj2hmC1ynLLIA/Tc3ECIiHcdQupckSoywRtyq5ESCiEjbhhyJDXmRV30Pg+k0rLYusF8a4+qrrmqEQP+QhZ7zHB7j3cDiMB6s2Y6nee6YucJvsmQapnnMB8Czrco6ajqOSlpUsrwO2tLpNCjMCs+H6SvhmspkKP4lmeEv/jflCMPzg3X5/nsXE30Xcfl5TmPPvmATdNidIYCB+/pu8Tp2Wfs7c7QJj+7jBREn50SUkr8EIhJ4n2uFDYqoiU5NphgtWyoCk302TXUtD2FKTA6NwNIaRDRj+6lSFkUuGEYhcMvZhn8woN3DBEEeAHlmMsl5W3VFUVcyqxYpxTRJtsd8r/3ubdfjIMfCUKIuBhJSWJtSSLT6q76uV0/4LoepBjJ5J8PbzFGrMmHb4B+BGflyilJWZbjFmdU5REkqZExQQwU0y3SsCGSLx6ls8XFB5+puEZjizpf6MHhfEAqh7I2g9W0yXlLn4ve83Cfw/re+QxeMAqSIFUluzs7FCZv8qUy1JMS7wbms5qLkxO6pmPTtiQhcYW+7iMPIVKOQCRT5t5TrTVaStQIqZLKUM0WTGYzNpuWdpOt21prthYLZtMZQuX23gxqG78LBIyqZUJiTcH+jVvcefYZfMwFFWm8MWbzBZN6QkJgC5v7gAVAvpiLwiIVNG2bM/ZCYK0ljbEBP1q/r6rAchb/akCPIwjCj6CHseZgVMCvlHM15vfduPUyJtvWBVdVYiObNn/FeUsXPSI6/NDQNxkKI6RBVxXS/owK3wDo0QMbYeh7Vq7n48UasVszLx2n5ye88NLLLC8OOT1K7N/c4Vd+67dYXh7z3e98mx/96Ls8/Owx63XP/u4edWk52Kt48ugz1hc9W8Wcmwf7CGnoW5+jHUSEUywvVkymi/wCKGtqYzhb9xAcIkVW60tC0LStw617+seHHD/6lMLlmhEpIlJaSJYUElJatEhIhgxAGrsUYzQ5ZyXEuB/NuWOh9djxlFnkUokxT+bBxzF3LJAx56+Q6fOFj8rKnK5rxO4WTCysN7iLC5bHhxxfHPGoecr5cInRFROrKVWFkRolfF5+peweCUrjkqTaWpCqiuVm4IUXXuTGsy8wnU05efQeTx68x/nJBT7A3vZtorX4qNk7uI1SgRdu32Yxn+W4SFJ04VXOTjccPvqY0ycPKZaOYdJlsKF1+POSnZuvsrs14+jJAx4/WnNr+4hY3ELJxI2b+9x/ZpvpdJunx47l5TGTRcn2zk2afsPaDxTVlOefvUFVL+j6hj6dsz45Z1ZrxGJG/Tv3CW8taL73IWHZoqRmSAaRPMIHhhTRYoNPChcSSswIAVLUuTZmHLzzgUQgCBm0liJ+ELl+JUZEytGXEFKuLPsZPk8/fYSREhcTwTnEbEJhcvwo+oAWCecaQkjE3nPeRKJQWCHYfuUbvPfH/29WCWqTIzBaSO7OE1qDErmb+qwBTeL8PPLp+5FJJRE6sBHw6r0Zw9kZuoGVEXy2TByvFUWpuXVH4pxk0yd2pgW9XnB8uEKpU1YXDbVQHA+B/SIxeMHD4w07FezVEmUSUkFRShSC2sAkCLooUMZweelwneZXX3uVi+NT/uTwgi/fmbFMko1IhKIiWEO4fIenP9lgdM5UTxeJbpXjRNOdjiQkxkqKSmMLSz8Ijo887Qo2TaTroOsCX76Zq8N8FEgvSLXl8Dig04qi0PS7kth3IAW9z7nlwhqGlIgpYnTiYFtjk6IRAqMLFJ4hamLy1EoRbI52GZk5LBfrlK+lkL+futB0XeDMje6rKEhSseoSVuWfl08BhWBwkc5JtM6H1eRyZ3s/SFJQBC1IwdIlQanA6IQQFq0D3/tX/3c+efgUuTrB+pb7Nwzb5Yx1Gxm8Y5MCdqL4m7/0Jf76Lz2HHFruP7vN6fE2Xp2yO1OsvWN/Bh9vJE/OPUlGjIW3Hlh+9LHnYBqRBESSfPo08f3vbvhrdyM4x8cPVrz9yfqnviemZUHvM6F6jARm2JEXDK5n8D3hKgPsemw1IwVPIL/RjMouBTSIKNHWYGWJNYblak1MGQ4WQiAIqIuCqpgyDC0+Coahy+TzsUVlWs9ouhZ8GGFc+UyWhRWPUmasDGuwBUAmnzfNOueAYyao28IiEAzeIchE7WYIqBAQVUBJiy0LqqrAKENoL/GbcxZbU4ZB8+jRE3b29rl1+xb5zK149623+OjjT3nrnfdpmxUv3lhA8vTtKosKEZZDQ13P+L0//H3+4T/9n9ktNdO6YPl0zarpOdjfodQSlXqMlWihKOc7PPv8i9zftnTNJYebyMnFip3Hn3Lruec4O3rCxdkJg/OcbTYk0VAZQV1XNCg2rR9p4RJbGJ5cnjGbLwhCkHyOSSUE1krE0OGSRqRVhpyFkKN12eCJVIKm7dgqE5vec/PGAVokbGFo3ALvVsy3Ztx47ssY3bBputwdPTii1Gzt32JzfgopQ4gHH7CmyE4/ofMSNSOoICkKvWBoL8ZoZ85tBzKTJVv2YLk6y9nVGPKyPA2M8xAXy1Pc0KGUHOOIks168zO9J/LcF7HWjCKdwhaGyawGFFZIhDJ0Q4Do6FwGwxECpVb4GAnyc+uvTCI3NIxxxV/+1V9j+8YNtM7ASe8TZbXIAle7wnmHLaeUZWY2TaoCY9TYBJDjolIKtrb3cM5zuTxmMqmpJzvsbM+QyhDT1bk1XAOItc6iXAgeF3sEVw1OASSEPtD3A08efYJfnvPMs69QbO2jG4la3EJLQYqb7PwXGuc9ZTnFVDXdOtcB9n1HVU0JKV4zIHzo8/wz5vfd0BN8T4j5fDyf71LVU2xRjrPOVfNTFryMMTliGBNeilGN9nT9mqZdI4Wm75b4Yc1i525eUPmWGBySgCwsWtckoCwqjCkQZCaV+Atu53+Llo7I0Ybx7185YFOKf2EZkOO0KUbapkEIQd92XJ6d8dmH79A7wWQSiFGDiGyaLJ6m4BEpu5K9TxgjKIymNhppJKW2eJ8yPLuyyASDCxRWsWkT63ZgUhhKI3D9OC8pjTKRrh+oqoIUDb73KAnGVtcx2C/y+cKTx2Q6yXZwPu/RVipbS9XY+2etpShM3rSEhBMel9y1vVhrjRuy7cZ5P25n5HVHW4phVDo9SuXDWrZXiutMsB8rw/q+H7u5x6w5aaSZ53qtqy86u6nzF+1DQKrcbVvXe6wvEsm3ZGpzVmYlGdDjrkBdSLzPDzShTL7hhITIaKv1hLFnThiDVAqbPH7oGfqeIHJOoihrbFmNau9oUbYaqwWzqmK1XLO8XOWqjpgf1M65bC8vLMF7pJJobSjLIlfDSIhCIqShmEyp6glFUdIUBgnUVYkta7TJNmFGVVlJ8flfCzkqOorJZMGX3/wKZV3lC96F8bvI2QVlxbgRzH/vish+1ZPuQrzO5l09kMy4HMmZEHX968UYmUxqiqLg9Px8BJ7pbIUXksl0gvd5C5lJ9Xmp0zuPi+D7MGa480FSq9yN7r2jbze0lyf0mxP85gxrLOX8Bin2xH5N1w9cDlu89nM//0Uv/7/0E/uY7dYxDy2t8zwqep6agbbLlRRFaTg7PuLRkw+oqm0W81227m6ztz9ne3uL2WyLTz58j+985895+ugh0/mEuzdfYX97jydP3uHho8d84xe+jlKa9dklykzQ+zOcDCgj6FYbmmZDqaf4qJgUJZsmE+CHWLDpOnwMrE7OefKTn3B5dsktMcNogdYSKxVKeURyRHTGciSDCDa/eKUa381XtOFsExUydz8KKUEqRMYBIVICoREykpRGuETQCSEiwnVEYUcCuiRNSuTuLtIKYtPgLy+4PHzM6fIJj5ZPWQ4thcpZ1UIZJBYrLUZ5lEgMWLQsRp6BxRVT5nVB7wXHZ4+598rLTPf2GNqGp08ecPvei9y4e5+qmnDDrbk4eYDoHKW2zCdbuPUZKEdMktQ3bC2mTGZf4uDOTT56930uT4+JseXe7T3KYou4PuLuYpvHkxr8GlNazvpAXW3RdI6u6+lZ0LlTdnbm7Gxtcd4nTjcD5vycP/nh93l6bPgPv/kG2+Yml6fHPHz/B7z4wvOcfXLB5dED3vj6r7D9zC/R/OgRw9FTWIO73BBDTyca5ODHAiRFSh2F0GgJQkailxlWJSSoDErqg6fWOWsNZc5PJYGgyw9LZX+me6IwkeBzzZbUlvXlhoZIVAYp4ULk0jMlcx3itNL0MceIbr/0ZR59/w/wzSVWxrzJJuIDNEN2WhgZGQaJIXHZ5s7nxSRyuUmcxTVbOxM+OZK8aBKHAzz77C5ffrljg+V/+r6ilJ5CS75zpDherXmjWHNLC3wEYxKLacl60xFJ2dI4LgY3PVRaoOVIC06JIQkan1gOA8nDDZXozj5lLQaWq56qEbi2Zt1NOVwN3A2Rx0drLhAsplBpMBdZqbEycbwUBJ8gebT1SDqqLUnTwiefweEShqjYnyculokmSAoFz9ytWfeJV+en9N5QmEi7UczNOUrOKCYWLRNKKOh6hIRpJcE71jLhNg6tJYVRV1QvGhfRVoCIrL1Dq/HA3QyUOjGxkmUTWDoIyaDjQFJjl7pLDM7RC8lWodAyYDU4DxqP6yN9r3FKUyiZYdrG0PUBmXJuTilDSvld+cLLL7JVD3z4kzP+xdsX7O0a7i8SN25HtiuB94rNIJDdZ/z3/8d/yFFqefuR52LpGEhc9AJRCt5/IljIyJ2F4GgNXZvoQkKmyLKPGJnYKgIXmxzRMZWi9ZEhBr5x/6evE1tulkg03gWc7zHK4OJAVZYMfU/b95RFiY8BY4ps/075PdqHnulkm7a5QEqduSQpYKUlpMR8scdmc4Z3Lj+LUz7IagUb70FmYGoMPi/fhcSPsSsBBBHH5bpGqcju3jN0zTnd0GOMprSGthvys12Qa51GF5t3A977EaoaSSIQEXTeU4RAUVjm05p7t2+yuzXlxmLOtC4J3vPOj37I7Wdf5P79Z0eGy0BdFzx6/IjTZUMfcuWoCoHVqqFtepzMIM9pNeNo1fDZssdIuLm9RQodg4tcrltW/RGzqkCqiJUSF3L05nTV8Gtv3kd0c3Ze+RprM+fRRw95589/n6enxxxdZHBWOySerjdMNXjdkIwkKs1q6XI+WinaruVi3XLz5h5t0127I2PoMtVc1HQIpFaYosq5WClwMRG9I/kBrTWvvfAMf/1v/S95ctLSnJ/y+NEjlo97br34Kim2rNvIei2Yz3Y4PzlleXI4nrlz9lUahUgJT8QIUFpSFpa2jySRgXiDW2XBQyQSuf5KkEb2iydCzvsLT1XVhFEkCRF2b+xwerZGIXM7kEh4H7/4hPHv+EQJIuUGImuKrNL77GZC5POeElBWJbY0tMPAMHiCTwSf8nJS5/vT+QxxTWMjUPSRqijHSkJP8FkAUDrihgsGt0apMtPJ1V/gRQGKhDRZifc+UBY1N27f4/JsghSRsp5gjc6CRPK5sagoqeuatm3H5YckxETwBd45QmgzH0oVNMMx/dGK5AaEnfLh+Sn7tqSwCVVEyskt0CXGFEBiNgtsBkHqVliVAbVd12FMQdM0BN+zWZ+hlcXakrZpMAuDlJohNkipKMsJUul8vajcKpNSRGtz7U7NA3FexigpScbQtS1aVnTNMp+1w4AxJSAzR8L3SBHz0sSUaGNRUo/Plnw2F3/JhXI1eP/Fv07x83aiPP9oruLJ6/VynEFyJNgNHY8/+oinhw9IKbt7lFTXVce11fiY0Cnig0COHK6zs6e4lPChyPeCjBTK0m0crnMYmRubqlKzWjuoJcpkp3HbNVTWUBjL5aajnhsMNaLJS8iEyt/7F7wxvvDgXRS5WuBqK3HlyU8p4VMcg/8akcaqipT7p8uyHIP6uRorhnDdaX2VK9BaY62h6z4vWw/j8Km0IiVJiHGEa6XrP9pVjuFqQFBXtOVRSY0xjlveDAXJ+a3cgSeFRdkJLjjSCC+ROluXcyZcQgIfBmKEsprSj2qjDxElc1m8INv8jCVTI7UY0ff5v1GQu/XEmKc2WuF8yBdlzA+Pqqyp6xllUbFcrzLsTAmUkpRlQVlZhqEjxYg2BdZYFPl78FFmnKnWKF1mUFeRq9+0MmhbjDCsv3Chjxf5tcUDidEVd595jv2bB8znU4iJi+Xy6t9AGz26Ga5gD7leJHj/b9tEUu7dVipvrLwff14qE8yvNlkAk9mEtu0QAsy4xAk+orWia7sMfhsdFDHGnM2OuWdaqUR0+UAQ4sDF8RPWFw85fvAThuURJg4Yq7l57xUo93HdOcSWTz59wJ989xNee/M3eONnzCm55RolaqTJN32j4HwSKGcToMMqRYoF9WzOL97/TabzkqIwrNsNYg1Rlrz02lewZk5R73F+8RApDa8++xxVvOQX33iRSTHFMVCIgt0bCy6biEuOylrCYotSgk8OHwf84HNvuYaTsxXrpUMkS3fZc/npUw7fe4j1mqJUFMqiVeYwSFEhtUakmCFWMhEV5PKhEbAjJCld3V+ZZi40CJGQWhCjIvqIMiMtXiiS60kYZEykkAd6rTQoiahnyO0phABtwB2fcnn8mOPLhzxZH7EKSypTUimb/1tRKJ0HLyHyQ66ShhQVShUYXcH2HFtAZSWzxT7V9h3CANOdA27cvY+yGu0C0jhkGDhYbDG7VVJpwcXRU9b+gvWpZLXccHD/Tcr5guZ8xWz/LqwbXDvl5OyMsydPqG8GUquZzveZaQhCIUJHoQqa1TGTumLZOELKmbm9vT2OHj9FG8Hrr77AkycP+ezwmAefbnj24C4///U79KtT2mFNvz7HujUvPH+LaHuq1+/C63f55HsfsnlySHrX88c//g7fOnufg9mCryxe5DVxl1fls2y3E2a6IEadS2G8gqJGqgi6outX+HbNQub2gUywzQuziKVSP5sL5Hy5QZJtsZO6wFbZgp3IQ3k/eIRzmMoQYuByA75zdCERTcHk3mv49/+Uww4WOrJXZeXbChAq17LslIlLJyAIHg+RsxZKnXPLw8XAbFsiE9yb1TyIuzx+9wFPOsX7Dx0CT+6kh9IqTCmJHvYmBXcqgTqY8fG7S1T09An6CCpBcIkhgM1RewLQB9g4wcolQhDsV7BuLwla0ofEB08Tt+05F63ABcfHT45ZnmgmIjBfZcW61uBC5kgXFoxMKJ1IXmCsQJ1E1hF6BwfbgtokCgMvfnmHIUoKHXEUbEamwNx0KF1j7QRtEyle4huNQyHqOYWBmBRJCwaRl97BCqKI9K6jtpJNnzuCcYF6nr+n6D0hCaYGpqWl27S4lBdo9JFIPuygNEY4pNXsmNzXPniBFzpnH4XGxcxlcM5DdBTGIIKgcwnfR1ZO5Cotn4GaC6uZG8Xh2SWljTw89yghuHd7Cipm0N5kxu5EEIZI89Dx2fEGpMQq2N+p2K4EYuVZe8OidOwLwZNlYKuWSJ+XBUpmF0Kp4NFa8U9+EPjG85KDncTCdD/1PVGVNcE5fPS5ISR6pNJcLM8RwKSsPhcchCKKiDEFg3P5DDK0xJQHttlsj83mIp+FIgi5RIpc6SNEbvMYhpazywuMLgluIKYwQjJHRSv67DBMOUbUtRsQjhAiF+eH1yqTEA66BkYezKRejMpej9Elccx9FkVB2zZsH+xw9GTJ4ALN4BFF4rUXn8+d2mFg8B2mKPj27/9zdm6/zNb2Hj4GmmXD97//Fn3XUhYF88U2+7tb9OeBVetYXq6pTF7kbU9rpC3Y0hXKrDEit5kIbfC+4WRwhCQ4LQqMiHiyYDJsLvn004/54EbN7tYCMxyzujzixa0p/b1n+PjTT0hCEuNA6wIyOtah53jTUJSK7d09ikmFi5JHp6dsNg3K1KTjE6zV+NNTBInQN7gIttL0EYypoW8x1uL7Dud6hqFlcANalxRlyccffUg75KWb0gI9nfDowQe5TcEUCO9oz9dYGdCTCjFG+jIALyGUIEqZGyx8ZB1bhJY471GocSWeafZJCJqhG8/H/tpunet4syjjhczQMmsJg8coz/ZiwnrjiN4hjUKbn34RBaCFRClNVZa5A5sMCwODliK3KiiJT5Fu02Sr85AIImbeR0xUxuADrJsOmYmMMKbh1stzkg84N+BdSwwN09mCql4wm9/InCNlxvdfPr+K5PHJ5Spek2OqgxsoraW6ecB6s6HrMtyrripEHPChQcgSa0v0tB7V8gEtJW5ciCs1QUrNYusm7eocYxLRDNmWqSvOVhu0Kei6DsQ5N2/dp6imJKGRRtNt1izPzzg7W2KNQMQzqvs1m+UlXbPEaBCFRJZ5zmjbXCVYFDVlVWF0kWGrcWRJ6bzAux64Y642hnEmi4mu7Ua7ORhboLWAkJ/3w7AZF3UaYxVG23FRcMXSGo0UCa4Goava3xjDqGhDCJ/nu7PTNfs0QsxR2RRh6Ds2qyWTyZQQBJvNitXFij/+/X9O1w2UtcntHjLQOc9sWpGUIjhPM7S0Q890NqHZ9Nlp5EO2ipPZTDGEEaaWXd2RSFVa1k3uOod8LQw+orUl2zgTYRiIpkIITYwp17/GiPyCFcVf+JQVQs4dpZjo3XCds9ZGY6syD0XDQFAqA8LGr1KS8fJt09K7IVuGlSKFQFkWqFFpvlK5rZHEFK+t4zHmUH1ZFCitQUjqqhqHOk/wOZuttb6umqqrGm00wfnRmtHg/IBAUFoz0swlUUikKoh+LJQ3mqQMgQxh80OmaCtjsFVFkorQd3lACWF8kWarsdSKMOZXgwv4EQChtUaEiEKOF38m4MWUiewxSJKMVGP3uC7G4VRIjBKUVqO1IIQqb6ZltomQEoIxzJ8kQTBm9EDIYuzkzEp1JA+uSVz144nRFpF/HyUNu3v7PHf/PvWkpms7uq6jafMLQ47VJflmLjDGjtdDohzhCX3Xk2LE468tSUJkZZsxDzOMdHFrcv3U5eXy+meUIRIRpBgXMwni59aUwlqsNSAFRgc27SXf++632N66ST+sWR99wIc//Babiwsqk/PnhTFM53e5fes+Qgf+b/+vf4Uu7vGf/O3/Pbdv3aKof7aXx3p5wcQGRKzyz38iQSums5qJLTk9PyMBk9mUqjas1y0fvf8JDz7+BIShqhUIz6efPOCzxx9xfnbE8899ic8+e8ib9+9z69ZdjAW3dsQSVCEooqa9bNg5qNm9tU2IDp08wg9oXXG+7jm+2HByvMYNHe1lw/GTh5z94H3kcsO2rikwGCnz2TqFnPOGrEpn70iOkWAwOl2rKIGcRU3ZL5frFDwkHcEFhEpElxgtFCRyRziebHVWGqENYmeBqAqIidR2dGcnXBwdc7p6zOHmiCY0lKbCSk050jOVlBgMha6AiKBGqJzXzLZ3iaznFMawKCvOjk4I3jObz5HzCS9tf5PLo0P6y0s2h5fEcMrtHUutSobNOZumpV3B1CiinGOLbXb3btFd/piwuWR7e4dHy1MmVcW8VkzLEm0tCtidVVyuBqZWszvbpXntZT56fImPHZv+kvlEcmv/Fp++9wE78wkxSHxMLNcNvms5PG3wcpd6nnjz9TdRIiKCprASbRKmTAixoby34H/47u9z/+U7tPoev3PwBi/d/zL/4B/+Iy63jykmM9qHF2y1Fi0nlMpS2QnBtVSqRkmNlQYfHC50RAqMtgg0Uiaskgjxsyne5+drFvOColA0m03OLhuFTzGT9UNux9i0A1pC4yIpelqhadct5e3n6T/5LtIPRBJdyCC/kCD4eD3UuwSnfUIhOA4w0aDKioObuxxd9LzzpGW6avjW2Sd8407gbC2RDEzr3BG7W0u2J5qbMrA5hsoIklIsSkVSChXzO2zjISRB1HkwvrJfRg+FzgP4AKx9xMecARtSYioTny4l9tKxt514bmfO5eUJwSbOWzjrx3qUlLWBEPIy0YpIZSSTbMzi3rbgYCuxvISmjazWiqIy7ATL25/kBlGbOto2cGPmoN5GpIKwSRTJYKRjq4qoQiDlCk+Vf54+YDOalagVRitwCRc8VZkhpglB8o4hCdouYFROhHRNy8NLQSqg1hJJwJaGGBNdl8YuXoHbBEwhwWjckN+pITisFESZqBUMXqDEQOsGUszL2UjCxeym8T5xdnGOFmCV49aWoGwF33h5i0mRCEGz6QPeCopQEmXETBKrYcVsAksP4azjkY9YBKJUbFWS/blh5XoKGWm8Y2YSSkl6l5NDN2aKbz0MDEFyZzvy0fFPj/t3fW5YKYwmxnAd45LKEP2Qz0WI3FoRPCkE3GjnTiHX96iRCrxeHyOlQgtDkHkY98IhlSZFiClXGSmb1fTMXBEgDCkKhpAPoF27IaZ47VqMKdeDDUOP0gXWVCiZbbLaWpAj6NTnHKn3Qx6GfCChsovReaS2ROFxwfPqvuGlF+6CG1hdXPD8i6+QtOWVr/56pmUPPd/647fYbBouL5dMFwtsaXnm2ec5PnxCqzou16eQ8lKm0gnXLsFVKKGZVZakKiZG0l4+zSpllAxScnq5ZlYVFCpRy2w9vbi85NHxCeu2ZV6XuG7gJ48dBZ6DnRkPHz/OdvYk2ZlYUBVdn4fki9WK0jlciISRoXO2aTBWXYtCZjzrhcTIDIKirDBljR/5CCFEwtBTVSUHz79JlAV941H1gvX6lNXyCbZUpDTJnAksqp6xuTzBakvwPRm5m0WNfL/ks1zwDmEsMTgMAlNWpJAX6WDQWuGjwiAQSuCCwWiFMgXB+fy8dQ6kZHe+YFJbNm2gsDMuli3TSYUPltLA8/fv/0zvCTFWD7sQ0MriU45V1KUmoThftQgklVHYsgAkk5nFp4QfK4VXXU83+GsSNmOc0vnAECJ917JeC6rCopQgBI1SdV5myCzwCa4UX0XSEm01wUd8jMix0tZ1LcZoprWllZKm2eAuLxAiMriIMZ6EoywyERtsdpWgs3tARIw11NM5ZbWF0QHhB5QU6HofWy/IPDtJ1zk26xW2qNm9uYuP8ZoxkhAcPX1Ev1lzcXbIZx9/yLPPvcCzr36Zth8oJ4HCVCAEWhqc78Ya4Fz9yJjjvvrk5VoejON4zvbO0bVNhqj5ASWhquY5yjJa5rt2ibYaWxQZWCwNWts8YqfPB+0s0spxAP/cYn7leIV4zX5CZBH2qgHF9R0heoYuN8yI5Gl6x9A73n7rLd794GM0npnIM5XRihBAxjwg28k2Z0dPMUVF13uKumbTRGbbNYjc5tQPHSqJ60ivd5nynog5SjwO3kpLRHSjGSw78WZb+5xdtIAeoxkiCxjui7Vf/HvB1cqioGuuvkxJ8D7XTQnQVR4+riorrpTxYRhGZTZcfxFCgi0K9m/u0SzXDO7zeqmU8jYsV0TlgS+qXEyP1vkAbgxFkeFkbQP9MBBCtkyFBJu2xQaDHm2CQ7ehXx7z6aOH3HvxqxRlhXNDtrSUU1wM+AhW6gw0U3IkTOYasb7v2Gza3J2tDOJaSVf5wGo0KQ0QI857tMqKXLbRQ0p5CySVgCARxGxnRaBFtmQQAroW15agK5S/FmOvqcl5aSHlSCMft1UuJ8GEgJByX6sQmiQUUZAdAiKNtWlc32gZeqYQSTKdbvH662+wtb3Au4HlaolzDqEM1WQK0dP3/QhCM9cbqpxdycp5TBmGNgw9VVVfK+De+6xsjDec0hofAlZltdk5xzBkkqsQAjt2WDrnruMMVVVdg/ukVCQVaNcnvPuDf82trecQFt5769tcHJ2jhaSvcmPq1t4BN597nqK0/Nnb7/LyG3+FX/ml38STB/t+cF/08v9LP6fLM/qYKBcJppYuGFKlsIWimEtkoem6SN+teeuH7/L+Rw+RGOZ14uMH79G0PUkpjPK89/ZbXJ6d8eG77/Cl177KxfER//FvfpPJbIrWcPT0AfVil6Bytn0YBqaVRxcGooU00KO56BqODo9x6w19H1mefszlZ095+t4n3BUzykqjdEWu+vLEaAkiEFOJM45zmTuTpyLiCJRUVIAmUCSJ9AKlDASP9CG/7FwgxBzTEIAMkSBSfuHLDKpCa3RRIPe2wVpS1xI2Df3ZCavzRxwvLzjuzxlEoi620CpgRYlFYqTJw7fQKARClRANUhu00JmuKSRta2m9Yfv2M3z44XcI6yVxNif6DNOr6m1cH0jyBLPRrM/PkbFjb++AnThnv1xza/cmh4ct+uAOF6uO1fFjKpmYVDPCcMEPf/wROiZ+5Rtf4fmXvsbl0QP26wXLy6fMjQGRWExuI9PAl569jY2aTed5/72PuFhecPvWhKqw/PDtj+m7hi+/fI83vv5VUDOWy0Pm23NmViLjaL+TkfPVMVpZptbxW7/yCzR+zWLrq7z24gucXlzw21//Cv/6T/6Y3/zPvom4Kfj4d79HkRJ3pjcw6i6khO8lymRWQs6kgaRH1VAoyxANhbU58/8zfKqwhEYRBpmhalKwQuKFwSeRN8y2oDJZe1amwCWFuWqFmG5zsfss88fvMySRc5EpD6lWCZRMFEj6lKiV4LDJO8YHneDO3i1+/4MNy/M1W3Lga0XEqMTDJeyXjuef0dycaqpCZrBVoQlR8MFRQ6Ul86lkZl1W1l0ehrWGPkaIgmFIFEFgREYlBRfpg6DxsAngY+5TjSLhvGSdJHY6pTCJqjb8+JPI+VlgaiXPThOVJgPJRnBWBJISFBq0EsxsYj5JPD5XnFwmvDD8/M9vcftWxe/+YMP7Ry3bRqCkYLss0NWErYXBykRhFPVEUtmadpC5OsUa6hESN7TQtB5jQQXHdMcSdO7MHbxnEAETwUmLlp6i0OxMVe5G1pKdAoLPboAoJN3gUUYgjMIIaLtIlDkGNHSCSoPWBT6A7xocGo8gBUAFYh9Ytg5dWkqp6PsBrxzOQ9+2TLHc3puyWgZ2yoLFtKSwA64LTJVj7T3rVYPUEg3cnUlWMaErS5kCXZ8wKsNPpVJoLTnYktRaUM8Ed2rQBiZWEQuFkAajEs7lg++Dw5/+nvAh24ytteMCw2JtgVY6q0fSZldXygwGNcY9Qoy5TkkIymLOenOG1RpblHR9l9//47tdjJnd6LJ9WJAVpZAS1marc4pQVHNi8PihyQye+DlTxWiD8w6SYxg6bLmFDx3N6pKimBCDJyaBNjVtuwIStpowX9xEdhs+/s5DUjKYyTZTHXjhubuooWG9umB7Zw87WTDbuYkpKs5Ojzk9Pubhwydoo/mN3/omi8U2f/6tP0UieHcyz7CzboUcIXJKClwUKNejU0OpFCm1tMuedvAEXRGMJcYOoRTNMKDLMtf+uIGuG3hyeMrq8gJlNbXybN18mVXX8tIz9/j2W+/lyFwcFw5SsDMtaWJ+BvTe03eZHt53LSkVnF6smE0slbEIpdHIDIwig8s2bUuIZB7NGJPbufsKX/rqL7J79wW+++0/AWNp1+esLo8wpmbwLX7o0BLMzND1a4y1qNKSuoQfOmLMZz6pDf0wABFpDJPFPqdnT3LuPII2OdObUu4/TiiiTBhpKPTneWAhVa5fElAUuUElJJGZIYQMtwoOkKy7yHsfffjT3xBkd6wZo4VKZDvvoi6uQWfWKGRMTKwliEQfIjKFzIUaF7A+eKTk81YcyQga0xlYuN5Qz6Z0XUtRZSemc1ngk4xAYZXP3wmRXSEp4eVIefSOpBUhamIYsDrX9ooUGPoeKRUhRNp2ydmZZ2s+ZbGY53N/yjHUsrB4P9D3Hc16zf6t5wFHbE6RUjDdf5aimqNHxTjE3HZ0eXHJ+ekJdT3BKs0gFZO6ZHtnj6Oh59NP3uPJw08w1vDi619lGDxv//DHvPzyy1TTmqgG6nrO4Hu6rgUEkzAlBD8uhT7vyAauh92+a3EuZ9O10RTFBK2LkalUMgwtSptRyM7NB1e28GtRL8U8wKZE1lX/ot9WfA5SToxsmezKid4RYoY2Dl1PjAMkiVWJZnPBEBR+iPzZt77FfHtBjAKMYJMSpycDJNg4z7ZQFE6x6gU7tUYIn0GSIrtQYgoQJDEItM7z3vlFj0RQWIHrA4Ux42IrVyz3fZ9bRzzEqHChQ+TevRx1HN1DKX6xmeLfw1eYayaQ2QIdY/5ipFJM6ppJWV9bg/uuv96mXPVPXv+GWnHl8L+8XI12EHfd6axUtqAoKSmLir7vgbGLOWXLdEoRbTXb2wuODrOVOYY0Xgw5u9J1Hqt0tjX4DWwesj1VlIXBmvEFg8AYi5pukaRH6GypCimT1o0db+iY7X/ZHq4ZfI9UBlsUuKFHJkE39BniFjPJUBmNjiqrNFpnmz0Ro1VWvkdieIaBZaJsDu6YnHEYM+9XvXqZy5gp4bl7kQy00jmLgxCImK3aUmqiFCOAOg/5QoJM+RFDAiU1CIU1Na+9+hrbOzt5SO6H66WJILFZL0kpooS8tsNdDdtXN5tz7rqb29oSpRRtl615eXjOP0c79m77EBBO5AowcjWFHLeVMX4+qF8N3k3TXD8sMt0wg2KmVc1nH/0AKTTry5bFzk0WW1vUsznVZMbi4IC3Hp2yfu+QL7/5S9x75vmcA/Ijef2LX/x/6We5fkgXV8zlHbSpWc+n9CpwdnZJHWaU8wIpB4Z+TXKSL73yJs++fI+dRcHx8UM+/fgB3/nODxAi8c3f+A3e/8lbPH10xJNH7/Phuz/ky8/dYe/Gl1B2QZItR48f4SjZne8jFgIXA7QDbduwtdihS4LLkwtkbLA24JYX6D7SPzqhdIrSJnTU6DE7IxB44RFSc2gveCdc4L1iPqnYhECSoJvA1GsO7JS5mFOJii2tKYTE6AIZQfjP7++UICSXraqhzKA1qzFbW4jZjDQ40nLJcHpG36xYXpxw0ZxwPFwSEBS6xAqBVRYrDUaUKJX7xDWTMdsmIVm00mhV52yd0DTrntXjJ7z+1a/w2bt/wp/97j/j9Z//dbb3bzHZmVDNC7TZYXXmOT89hbBhty5ZTG7QPfyQqfScP31EFAU3txa0q4DvPWfugq45YmtWcP/ebYSM7N+4Tbt6SLXYxy0vqHRFTB5hLAWJSgRu7R7Qrs75/o8+5Nvf+lNu3prxa7/2W9hyl7PjP+LZOzf5K7/9m9x69g1UFMhqi4vzQ8K8oi53KekJQRFkIJUVupJ86eUZb787sDsboHtMd/gOIp3wq994keXmY156/is8+t2BWhgcHi96hLAE0ROdQMSBJAKdl1jd0ntFWViEm6C0QaifLX5BIejxtEOk2fT0fUBIKJVhUhtIgtBrmOa+3CQk3jkKYIiBdkjI6YQQBTfrSK3yY1FcNdcxVpDEhCHx3EzSB6i6BJtDNAZrBoTNC87X71jmE8vCKKzJJGmjBUOIDC6RnM9DvYjIpHlwvM5gQSnG7CMoBISUKyWDIEquF5kpCGSKGCHoIgwBjlzJS7fv0W2ekIQiIOj7yAvPVPzxasllgp8sBdsqMrMSo+LVqwsfYF5BkSKizvnlN762iyqyZfTbH7W89/SY5DW3q2zN250aykIwKy2KkOs6RaRSgbpUaJNrivIqBOYTRaoly1UezqoyH76R2XlktMEQSaYi+UxA3p/k98nlxrMRAmMlQ+eY6EgXJNZGvAuARxSSnUXOBsckMM5xOQQmegAtGayicwkds+JRKMPWfsHqqaPtI8FmsJJWEll6Ls8eIaRHREOjSu7tWMpCAJrBxVFVctRVwabvkQpevDfj7adrCqsoVEGsPUdnOda0O9foIJjU8JWbieU6oZVkUYM1CVVpfnIuKKv8fdYCkv1iFsK/9CM1Umn6sYtWGc3gOkTKfbKJbB2OfkAqSVWWtH2LkgmtBFIVCKXQSuLDgHAKxXhD6NwKkMZ8Y1nUdH2LkBKlY25tGRkdSQliyH2+ZV2iQ4FkzOzK3AASr88aksE1ow1dosZYiils5tiUBUPX58zpxRlvfftDlk1AyIJ6VvLMTm4NOTt+xGL/Fjt37rN36xkObt3m008ecfjkGEHk/v3nmc4m7GzvEsJA27R8+N7bTGwGaUmpsJNtSiuxoQNVMXSbTI9eN3lQiYLZ3g1MsY3fLAndQAqRKPOw1etAZWt6FzhdrblYBpzvqEvDfV2w2LvPaui4feuAt977BCE1hdZs7+7h3Abdtuiq5nLT0ofIZtNkXobwdDExmRRs2o4y5QYESY/y+Tk639ljvtgluI7p1ja6rLGF4b1332J6eMT54UNWZ5aDW3e5eXCP05MnebApE5XqqBc1H7//EUlC6TSz+TaXriNpwf7eTeziHg8+/B4pQGUMewfPc3R+gjUK5z11MSWkLvd46zLHFWXB3s6C5eCJQ4eQGUqWyMpsEFAqwRBcZi0E2NmaYmzN0ekxgkTfDT/9/QAjHDiv6rVRVKPS7FKksOraaenIg89sljKJ2uU6KyQoIYCIrQzORYwUeAneJz558DEvP3nEfHeLICF1EiE6uq793Ik6CgXialgUXJ9vjRYQyT+bmBiCZ+h7oosoETAm11NJOS5cvGfTtAgBi8UCpXJmOkaBDCMfQWtm8x2M1Sj2iP2KcmuXsppmxwrycxCxUrhuwPssQPmQf95du8YNLUVZEoGjp0eQ4PT0hH/y//jvef3VV/hP//bfZnVxztBtqCdbDEOO115enuRFQwy4K9I4jHVgbf69iFRVRVFUFLZEao02GqH09XldaYMQMbO1xghtGqPHeXZI+f0ZQ37GjcN2/uSIrg85bpuXf7kVqShqnBMsV4c4147Cq8ANK7A79E3P448+4ujhT9irPD5GtmaTnCaXhpAkO7sTJru3saLkqVphjEaJEh8S927NqCYGW1RoabBWkLSnsgZb9Ax9BynSihYf8n+b1ZbBZ+dz13uMUEgVicHRu0CSuWYyxyQSUn8x4eILD95CSNquJ5Mb7TUky2iDFgrnHVVRMvhM97vCwSuVyXZ/EbAmxgCA64dxkE7jUCVGNXXIloeuJ8aYwSPe0w0DZVHgY6CoS6aTmpOxPkqofKPkgb0kjsS/fGsKqumCfshwL8TA4HK2vCxLSIohDPgApVEjVCxXmCmTc49d10JK4zCeK3mkMkgd6fuOMOZjpBAIbUgy4pxCqsBIb4MQEDErv8Qw/pz4/OZnVMhFrqjJYnjK9jGZB2HSFcAq09vT+IXHBAhFvjVEftmOGYtEVu+llIiYK3ky7KzkxZdf5s69u6PFO4w57pE6Pm7DpMoE+6ve72EYsh085iG/rmqcH78vEl0/YIzJyj+MubC8iZdSoWWG4Q1+XDCEeH1tSCmvXRJX11nf9blGbZyUtc6buK/9wm/y/W//PsvzDS999WUum55Hx6e0yyU3b84p7yxQquCNl19iNp/Q9m2OCPis4H/wwfv8/M//3Be9Bf5/Pt1wjBMDrQVxcB+/IwiVZme+zXyrZLk85+TRU87Xnt1bz/Pim/eZFpHHT084ObxEmT1+87f+KqqsmJaGZvkfsLl4wlvf+QP+1e99i6OTU7xTuM1AFyOr9ZKtRY1UAd+uaUNHjD3NJrDsDXI64+jRI3of0LZE6hoRV2yerlgojbI52qGlwCO5sAbft5ybwJ/FMzotsKVgvXpKUCFX/C0bJkljVWARC75cHPCl6T22dU2MYIwkRINMkaSyXSwRkUmCUahpjdzZztdhs8E3LcPJJc3qiGV7xFG3pgk9SglKmWsKjShzXZ7MeSQjypzvFhKJRukCparcJ2rM2EOaGFYdy08vWXz9Dr/823+Db3/r3/A//Y//HV/75l/n5Vdep5halIrUhcZP55x9+iltDaujh0xnFVx0PHrwMU9aycEbvwZKcfvel/nh9/4ZTBVClNw4SEg54c7zL/P43R+ymNRs0iUHe/fQ+j6NKzk5vOTZ/WcIK8Nnn53xx9/5AWfrJW/s3OFg/zl+8ON3kXLJ3/ibv8FXvv7NfNBqG27cuMEf/n/eojJL7tx7HhfO2b35DElAXWwRfIVLA3dvH3Dy0RPK6Yzd3VdYX0Zev7XL5Upx9vQBMSWqcsak2EWLGikVQxBo0RGIiCQROGKUhOSpKotQEwTZLvyzfJRW9F7igUEoipmnUBLfd2z6MRYkE8OQsFrSDx5NpBeRRKQO0JeCYwnnTtLFPCyKmAfunOwRWAlGCZwQnLuckS5Dx/1tyfz2gkJLzHnDnRsTUlkRQmJuI7bIbpG5SbQ+0QaJJ+GlJBCYa8HuliU4x9QIksgDjRd5cdmliIxjGi2BJ+fPlRIEEi5oXjs4IMqCs1XNvnUs5hNCgtduOG4vJmhTsagDZyvHoyeO1SqQiFSlZDpV9H1WdF5/c4thCPzJTzzrdYMQiU2EN54rWB313N/WzBcF2hbsVganTc6bSomKIKygawOCSIiCgURZKC5aSINHaoVSkSYkJmXCDR0xeqRMtIOgdYLVJnBnS9B2Alxi08KAx4ZIqTTVxJKkp3MKXQqIOacaAG1LhgGKOmbgqBNgJMkLCgPKeyjzUpi+p21hKgNtM0AcUCrbSJvlJdQ1hU10m5Zz4zh92iFEpNt4+n6gEhFrbgCSZSvxwnNvv2TZRdrgsgssCJZtXhAvV4HJVFIWkjBkd5iSKQP9jGS1iZQm0fUCO4e+/endUYUtcN4xDAEXA9ENuZIT6FMkOp9daeTMbrO5HIGVgpQEIQw415FSxOrc/sJ4XcYQR2Upq3Y+9lhbIaWka1dj80pPSvnJLKVAaUOMefnaDz1SSFIII3BJ58V+cvihQwqZh4Irt50yY0ZTU081W4WlvPA0N/d4+ed/gXfPAqUNiH5J17Xs33uZcrbNjXvPcf/FF7BW024ukUowm85JJOaLrMx9/9vf5eLokGHTcH6xJKSEnu1ihUT6FRQLiNlxkYIgqQIxmbKYbaGKGat1CyFfMwEypVsoCj0hyEyGF2XNJ598RCCgRMAWBUHNaPoBpTVO5EHhfHWBnU6yEic0ISZc6CHkn3nTOxbbW/nn3DRYI9l0jps3blOaGXsH96m397MIkkMlmS7vPClF2tbRxxNal5gVBU3b4y4vCG7gxsEtPv7oR5x0LTxJ6MJQGE3vBkTXUEznONdzerFh/fT7aJkrwYSp+PSzD4je045n6rPlKcbkc5SQnpACCs3Ts/Mc+YRrXpDSmfkwDANBGlJIuDQgkuByueLe3X3KaoNM7meGqxmdo4PWKJTIDKdJVVFbm6HAWrJp2nFAg26ItH2DFiqfjROURUlI4GKkdz3+SjEOnsePH/OtP/pDFlsL9m7fom0bUhIjtBHK0ubGG1EhYhZ5Ilek7Wz71sYQ+h6R4ljnp2mbQwgRISxKaUKMCOcJw4APns16Q1FarMkDmFLgRaaGxxiwRjOZzIlxoAmOsqxz3GN0sooUsVWFAAapcb4f886Rtt0Qw8DQrunadW4qEAnnev7kj/6Io8dP+UGz4Vd/5ZeZbk9xFxua5UUetqXAdRWu77C2QEozJkDzrGZsrpwryoqyqDEm83+uq8BizK7ilHlNSmuE1EB26hA/vyC0yUBeKdV1dlxciYUpL4uzKh7wPqvd2aGj8hKgOUFqjYuGoVvTu0BMgaFZ8we/+6+olAOfRnu4yyBuCd51uF6CiBS2YnADxihCt8bUU2IK9H3ixt4eTdPn3vPa4FzCh2Eku3sqVdE1A5NJQQxcO4q0UJ+DsX3CRwU+EVXMS5aUUH/Byv//7/PFB++RSp1SQoyDmZIy0+SCZ73pOHenFKVFScPZ+TlSKRZbixF6JkYbQlZLtTHXN7lAjFS6vDm4gqWFkGnVbhjGfLNkcA4dJevVis8+C2w2DWEc3NTYCa2kRKTcq5dI6HIOSlF4gfMRH/tsadd6tJpkup+LERNBG4MbwW1uGMatTMrBfC1R2qCtJYx2dCHyAkJJBcLhfIbAXSvHYw+5QBDcQFGVJJ8ymExmIEoc7TPXmaw0wutCRAqduQXpysqfrodQKWWubBufhMbkf4ercnof8qA+bp1ytkVjdN6y3n3mGXyI+feR4nowDWMFRlEUpNFCfwXTI+U8nAuefhgoyzL3SpKzbFff8+BcjgH4ccEgBJAXHt7n7WJVlojxJdH3Paj8wEsp0Y82dGL+mchrknoEM0HNb7H/4tc4/NGPOTpccefOPf7aL/w288U2Ozvb+NDzwYcfk8YtWwyfuy+sNTz33HNf9PL/Sz+dHwhqjVa7EBuqyQ5maonKcXp2zuACojJsVzP2bsxJvuN773zEH//hv+GDd99l/+AOr335G3zptdeY721x92Af3+xxMFG8eOcmqcvb1rOTw0yxTz0mJYpCIEVAeuiD43zd0J04Gq/4/g/+nJPLCxKWnbKiOj6HdUNht3BSkLTBKc95uWEzbHhY9HxYQSprNqFjaC+46FuG9Rn9ZkWKEHyP8oF7cou93ZJ7eo/SliSZ7WhGOJRJhEEh09iPub2F2doBKyEm4mqJ21zSnpyx6Vcs2xNOhw1oTWkMxkhEihSyRMsKLSKFmqJViRAFdsyEGT3SOW2uihDGoIOn3QR8bHj88Ypzc4adHfCLv/2/4sGHP+YHf/6nfPDOO/z2X/sP2d6eok1NYS1oxfHxkoJPmC9eovcbHp4c8v6n54T/5/+Vv/6f/KdM5G0ezWd07gItBGVhGXrD04cfsj4/oipu4dclb337A85fnTLUG77zve9Rbs348z9/h2J7l0efPcYoxZsv3ME3G0J7zM9/7Q3e/Pqvs7xYc3HxPjfvPU9RTbl1cJ9/+Y//Mcf3V+wdbLG5/JTF/g2E2aZdO5rlGmsUezv71PMD+mHCfV0hm47Nox/z3g+OuW+22JveYlbsoURBDB6kpnctPoKQEUKudVLSImSBLSVEjVA/W7f9MPS0nYcEM2uwSiC0IjjJRGfHTEwSQmQzDGgSLR6dEoKAi5EuZNaAtYbJzgKtMtGscw4REgHwQtPLvHC5WHbsG0932fP6zS0KLSkLzWUQWGBiJT45KpuIMvujtYSZAoSg0opUZmjKzqxgp458vFT81sKxN0mjLpBVw5Dyg1iQaxlHlj+CxCfn0ERQxS6nZ0ecrk/YWu2wt1UzDInLZc/JqqJNNc4HTOm4exeeVTk7d76OnG0SN28KfuPLFa+8tM1/9U+e8vZhx9SCITGvJKvLgflWSdSa7YXCKg2ywCbF1GqMEoSRqzCvFUEVhJg47xVnfaQShltlRJcFrRcILZlKx3Ho6QcIJKxINH3k1o5B4hlaz/mgc6UV4IPEiMh61aFipLL53RUkKB8ZvEDahK0LdAoEJzAiEYPLsFVtGWLCEqhMwWRqmZ63rBqfrfe0RB9zrZZzHJ+s0W3iziTy6HLgpgYjAiKnfAjB07ceVUpOztfcmCs2XY6/pC5w2nRELdjbNtzeqvm9j095Za6YTiSFknQDGCPGRbbi/LKl1DmDn7uufvpJox96FvNt1usLSmOJY2e3J2bA0lhDlOGBCihAWISK19Ar8AghcSH3xV7ZPLMJRBFiQAiFkoaQBrrOoUi5zpGcqYwhIIS5dhxKqZEiZzm1NkTkdYTQFnOgZfTkoXRm5mjpkUIwuGzfvcmErb0ZC2PZu/UcW5uWd37yLn3y3Hr2ZfbvvsTBMy/w7P271EXBgwcPcwvJWCtKSpyfnPHhe+9zfPSUh589QJK4cWOPe/ee5+HREXGzRMgJwSdEzM06wif0ZI5QFjHZIaqSLRwXnaftBzAWrUoGPGs3IFIgFBOWF4fYrV1Ojh7hXeC0j6w+/pgmKJLw2OmCrms5aR3D2ZrFvASf6IaGrvMMMbIZPNiCYrpDGFpu7N7MQ7g27O7doK4ndO0aQkfTJfqhQduCne0tdnZ3ee75F/jgo4c8PbkkJU/XnPH4058gGIhJcnT2gEIbdFUQHAgVaEN2AQ7OE4RjtR7y8iVlGLDRln4YiLFnMpvjQ3a5EAOz2YxBFDTLIwprUUbiXLxmMUklUUpitaUfFd+27dHWEInZki4UDx5+RIzZPqx+RgintRJUrpOKJKwyKFswKQ1owbpr8THQNj1JDBijKZSBFHMsQubYEQhCClSFRkjF5eWKEBOexLvv/4Rn33qOej4lJk+DwOoyQ6BJo4sWijLHulzfXbt0CeSstBLEkX0SYoYGBwLaFMSY8N6RiFk4c9C2HUPfQvTXOWbvPJtmgxSJpllRVBUi5fPv0PfU2l6zFuQIQitifm/3/ai0B0/wjrZZ56YgAVVlScnxz//Hf8oPvv89Ugwslyv+0T/4B/xn/5v/NYu9PZTQpDigtcXYOrcCeYfVRSbuW0tdzzPrReSoq9IWoRTIrGjnCsGYF1oxZnFE28ygSFmxjjGBMNlunbILyZgJKcVrwS4DtjO3K2fNA8ZqhiGgpSCmflQhFd4nIoFhcEg9Yb1e8+n7H/Dhuz9ESk85s1grc6Rcjk1KQdB2nruTBa4ZMGPUCaERCoySOBc4fHpIQBJlQvWZmBp8ICZHSg4hDUPvqCaZJ5RSuH5mAhBy1/ngJbnYNJFG4v8XPT198cE7RYKL+QsZqZd+rLi6sizEBMvlmqosefedt6lmU140L1La4hpbL6VCa3VN1Mu9gFcvhtyjHWNCl2WmMkpJWRqGwSFcyBAQoN20tOuGRB7oiqK43jIxqshKafrO4V1AyAnGZmVeSjVWnxU5cy5CzomOVsF67CnfbDbXyn5RlHShIbi8JZVK0tNfUwExo4VaaeSVIi4V4K//7MiU6ZMhXsMdsl5N3limrIorcfU1585jcfUHGj9XdvHr70aAGG1OEEky5QtyVMOFyJurXAmlkNJy4+AOz79wH/icUK9GhduKDLiTIteHMS4RlqslVVF+Xh/mHD4ElsvPoQmJTBkNPt/gMTHWvKl/K+uRWRjy3/r+u8GzafrsNkDgvaPr2wzoUwprDMV2yWw258nRIft7d7l96xlef+OXxsOvpu0Huq6nGx+itw5uobTKDgdj868tsoNjPt/6opf/X/rJPgeJmBbUz+3iFoZ6LphPLSEZeh9B3yBiuFg2/NEfvs2Hn7zPk8On9MOa937y53z0wY94/Pg/4Ju/+mu89todhlVLcBWvvPx11iePEUoxDDCsT7G2IKaWEAaS07Qozs4doUtou0Y0K7angZOzlsMnT3j78Jz7XcHzYkLUsAwDy8JxXJScxJbHNTyVDjPZpm9bmvUFZxdn9M0Fvevoux6RAskPbIuSnUowi4JVf4pMPTO9wAaBVQLrDUrWTHa2KPZuIAuDIOI3HX51SX95Rrdasuk6VuGMJiWUnqNwaKUoVN6eWlFSiBnG5q2ykRIlLNZqhCoRhclOD6VRIhIGRzc4NkMLYYV70jHcuUn/6DvI6YRnXngdMz/gT3/vn/OP//5/ze/89d/hmedfxokJerKD61Ycnx5zfHiBNTr/jN2Kd77zB/zOr/8au9M5z919lT/41r9kXrUUusLFge/86bvc2Vnw4dvv8fEPH/H46WNuvvoaZ08/4sbOHg8fPGB5cYp79JAZCeqSVw7uMhWJN7/yC6hqQfPoEBF79m7vYRe7dJdLFvtTbs9vcfKdB3w8/IhiMqHctXzpG78MsuDJo0+oS8mNO/d48OMnCJEwGk4+OGLzgw/4xdlrvLD3DLPiZgZTxoRPPWFYZ9VrjKQorSh0QWFKlCwIKuETJPez9Xg7F9AiU8Y1DSJELlrLzu6EzWpDEpJCJqQNyN6xWXeQJLpWOW/sAmWhAcn0zn1cPWPj2pxLTwO9lrn+zDlS26OMQumCTmm89px0CgJUZUIGUENEuZSdOF1gCIEin/lYhZznUiLQR1iuByZTC1LToPCDQ5UCrcBouHqxxJTt7yAwOuF9XgZMjGTZR87P3mNrItDdHGstkUjwgY6SkDzHZytOHZy2sGpG1kTwRAUqDdycC9bLgdnE8PRJy0J7RBQsioR1gugtksiOiNTKsHYFFBVGBaoSvDQUlST2PZ0LFDHSSkXbRVIUzKVj4wPpoh0dDoJLn2ivBuiQaFxidyaZ25gVeGkoZzl32W/yYb0NEl2AtJLkBpSMzCrJ4BQ6DpRWs960iCIvw7shZMaCjsS+oRkMVgfC4Lk4tkwrmM4Kko9MLWiRGJynMJFmqDhZdixbSdNHNoNkq5bEACF5QoQKR13NsLVmUioGF7EqZTCbgZsLyWsHBbsVFAa2pyBTJPgMbFJCghG4VLFsNmztSbxLEMUVM+in+kzKkovlBaWtcL5DxIQkZVVbxAydzLY3pC4JYcDYfLAN/iL/M6lzJRgQfK610jrXQwmRBQCEIERHiD7/WYTKoDsRRvVqjIeFgDY596ukRJiCGPNCPCFRWmILhXcghUTIrJhm+Fse1EmKImhk7zlpG7yUfHB8ysOHn9B7mO4/w+2Xv0E132J3d0FVFoQQOHz8mBQcznWsLs+ZTKZU9R7T2TZaKo4ePUROA//5/+5/y+XhCX/wp9/nw48+ou962vMThqGnSwqPwW/W1LsH7N5+Br9ZYXXJ+UVBNB3G1ihtiX1P02wQRnKhAzNdcbo6pu0jLkTe++QxL927SyKymNW8cb/i+Kzn4ek5UcK697iuGSvYFPVkznMvv0HXbphMdlidPebmbonQgcENnJ48pZ1WLCY1IRUUpaaotlAqCzM/97VvYMsJ7z+6YD4ZWF88ZrU6Zt1cjJs8SUoeUWuSc2itaAZIYUDbmqKYkLTn4O4dDo8e5+/EZYBtH3JUM0SPtQYfoWmyM0TKSGEtZaHwCIzOQkw+s2XYcJLgQnY9WmtAiByBUhkGmmJiOq1ZrRtC/Nms5gjJVlnnOruUAcvBDwSfqGxJVRna1kEhWDYdyZsMEpYCqyUpSmqb4YTJObTQ9H1PpRS9CAQfGdzAd77zZ9x9/jlu3L3LutmgtKGoSnQyOccbPGLIgtSV9flq+E6kPGSaXHGYnEeJgqFfYURNSGLstBdorXAeXDfkeEbKg3nwGQi2Xl9gbIGQis1meT3sd92aqp5cn++1VDkzrGVuetKG5vwcrWWGTNcVzWaFSJHkI0NsOfzkPZrVEkay/cNHj/lv/94/4u/+F3+HG3fukCH4Ced7tCnQJlNCjS6Zz7bRxiCuzvxK55njagExWnJTisRRxDOmgKQYH0xIJXBuRQg9RTGhWa1z9l7kWIoY42E5ypIXr8EPCDFGU4UdHbHZnSXthEm9R9s19D0ZltYt+e63/wijEqeXHdNJzum3fWBRFIQh1yk2XWB1fsrZ4XF2JAuJKi2+cUSfsEWOBgQ3UBibW5j6XM1HcsQg6JuQ6+DcAFHQtp4AmHEBm1QGR3sfQXsEChJEn9Dmi0E4v/jaKib6rsuqYz6F5B+UlBTWMJlNCYNnvVrl3LMUvPv2WxgtONg/oKwnlFU9fgGRz2ewTOu7+qKN0Hl7ixrV3IAb8tAkVbY7XEFBvM81NVIIuqalFx1KK9q+p6gqrM692zJlUImWYhz680sojPaqvMWTpJR/yEM3UJTZ+ty1HcGHbE8fBpSUDEOPkIKhd3jn8H5ASJXd5CIDaq7yiGqsrNJa03c9mAwiI6axXzNcP4jGPww+pPwgTNlOJmG0gOdfM8/lESlyf6OQ+bAkkcQk8uFaAGG0hwk1QlvyNmt//4CXXn4VqfV1bVsGReRNvDGGylTZXTAO2VdOBR8CCDFm5BOTqsqbMSRd19L1PVLk38toQ0wJHyJS5SVDjBEfHCFmFdr5vKEOIdH2Dhdy958UCTMudXyMhOjph0yp3vQ9IWbasO89dTWlbVuWmyb3nBcWIXIms6omFGUeuFNKLBaLnBEH2qb9wpf/X/YZQoee3qY62MJYgdj06EVBCvmqbjcNax9wCM4uI1u7c97Y+gqvvPosR48+4Lt//sccPnnCT374R1Q2cnL0LMPylOdubLO8WLFVVkRhsIXmyZMz9mcTUidpVzUdMx4//RitDVpFylhQmYIXnv8yi9lN/uVn/5r6smPPLKAqOCexTGuacoum7vl0uWQpBYutfdbrS87PTnH9OhOThKBtNnkhkyJlVEyV4qhf8bsXb/NmfZtXJ7eJxcBMThHWUi5usn37LqackuJAHDpc09CfnNFtzmiGhmXX0cQNUbj80FUOo2xeqqDQqqLQJTIZtJEoNMoYpC4xVTUqLxlgJYRk6AeGfmDZb+hCR7PZUB0NqNk+ioY/+9M/4Ec/+h73X32TX/zV3+St7/4b/s2/+p/51V8b2Lv5DMbu4GTiwbGnOX/K40+fQt+h8dgwcPLge8wOXuP9B59ycunYNI7bu4o7t27Rri84uHObx++u2JydM9ueMbvxTF48DpG9AK4NqCS5QYUWluXjjje+dsAMQ2sFsb+knu3TOQldT9fDP/2DP2S6GHjpxj3643PCENl8Fvj40beIeNauZTl0bOIfcO4akozcKm7wC9uv8TcOfodn5nfRMhFChog4v6ZpO4gOaycIsktpUkyw5QSpCpLIlYLRD5B+tsF7Jlv6CH3SbLxgajUTGzk6POFglhhSoNQCHxyFCJQzOarwgaYJxGFg6FtaBMvNiugg2IpVF9ARRHK4EIgO+ihZIKinBZaBuheU2nPROwofUaFn0+VaoxggDIHBJ5YKrJYEJQk+UCiJqyVHl5IdLykrkQ8wvcA4CS7ifM6V91FQW5nBK5IMe1KSQsPjJrNAnn1uRqonqPUpB3sl3TDgiVjVsR4MTkKfBEFE9qvIUEhE0rgUqYzmzjTStJEPP12iZeTmJEOO9nc0MyS6UpRWs71TEYXFSk2SkVIL8AmlAiIFep9ryKySuSPa55fuauO5MRes+kzXjkZnp1nT0zQw9IKiFCwsuBA5WXm8Aul9zgSLhCZhlaLtBKbKvbzSZuqyjJ7KgutzF/pMZYdZQIDM76eYJNMCogssNwHJwGUj2ZlmBd5Kh1URSeJgO6FICNtj55FpGaj1VV+8wBaWoiq5/8pN+kHx4Wlia0eSZIdPHZshYHVgpxLMS810Zrk5hUpGfMzE9igyUNUlidGJYcjD/3kPnYPxLfxTfgQ7ey9QGTg8fB8h0rhwTxhb4aMb1SOJLaZ0zSXet3lZnnK2lZiVZkRe0EshiKNFNPgBkSJ4SCLXQKVwVdPjR5Ej5EO1UCiZHYbDMGRHG9APDUZp5vMdurZl02ywtqDrOyoj8nlESIjgUoTkEb1hIyIX/YbeSzZ+yWa1YrJ7wK37X2Ey3+bV115ja3tO8IGT0xOWyyX1dMbu9hSzbyANtOtLjEhMZwW//stfZ761xd58xr3b93jh9Tf4r//Pf58PP/oIaUtcu2bo1hTVlGfuv4pPis3yjL1KUdo5t90+0+kUZQs2TnB8ds7Qtwwx0rQDw7Rg0zlCSiQkiMTjo2MoCg625rx0y/Da8/u88+icP//gU9Ztz9zWvPDS89zYv4GtS779rT/i5t6colL0paZNCh0SO3v7nF4uSSFx9+4B873bvPPOR/R9hzXw+tffZHd3l9/70+9z+NknVLXl7R9/h7ZrkRKquiYmSQSMUcTkmG/NuVy2FJWm6wPIgd4FTLcBNCI6jLFIBdHl77UuNfVkwsVqzc39m6y7lpQ6yqJk07dolTlDRmefotYKozWBPPtrqfAhjEJOwvsM31La0DRtrv/9ggPGv+tjjaX1LscmCCQ09I7B9aQIEkfvPEoZSiORCEIfCFHhXGJQkeZiiTUaIfMArYQg5K90PGvCk8NDPvrJe+zevgVCcXz0FNct2du/ieAmtrSkoc/Lh1GZzRHLfN4dhi7bi8cMfBCwXF0yExWDB+e6a5BY327ww4auEYz8Zbx3tF3L+dkFdVFRFNPx11PECKvLU8pqirHmmt0khMBqQ9QhR1KM4ezsKTEEjMy1ayF4YhT4IdA27fgTFCiZo7yPj474L//L/4q/87f/Ni+9/hpx8KNDN6v8Sgj0RI8Z7jyjyCSx1o6OmlHbG+eOGPK/e5VFd95nWDQZEO36DoGD0BKGhsniJjGl7DiCURnPIEcxwkSd65AqoWRJiGl0lElMuQVSg7TYapuLoxPe/u73ePTp+ygDToDUAmM0/SZe93cbI2n6wPnTh4TeY2cVznlSLsOi9Y7drZq6LtEbg1QBNwSEzIumYYg4F+g6T1EahMzXgHOB+c4sO0GaHmMMypTE1KLlCAkUkeQdQXyxkfqLU83HLtZ+zDKUZYm1lrKwOTckQGg9Qj009194gel0yvnpGYNz3Ln7HCHlKqlMsP7cvh5HcNaVikpKCCGp6iorwdc2aoP3LYeHT/jss8/43ve+x9HJMcE7VssVbhiw1rLeNPzSr36Tv/t3/i6KDPVyY7ZGqdxxLZQa601S/mspM7RhhJEIxfWWeLNe5aorMSrQo00929A93jtMkamEQmlkyl2ZAUhKUpUTkndI5XLvYsgWq6xKX1mws81NjIy4RM6ZZC9RzkFLMsU0/7N8a4jI9cUcyf9LIl0P7Rndn7OXWhu2d27wzPMvIJQZ4WU5l36V7TY6d9t54bO9X2dbzlUOZRgGfB/o+4Yfv/0jHn32hFe//CYHB3dHiENEK0lVCrTR+H6g6QZkH7I1KoZcs1EUWdFOjq4bGAaPi9myIaViYm3ulAxX2ZLskPjs0WF2ASU4ibmDrypMzhtbS2ENg3O5ezZFijHXrIzEFgWz6ZQQHMv1miR/tqCSlIJhdczJhxJxckSqS6ov32EoPb1OnLdnnLQDXlrqrdvcunOH3e2KcibYXLzGi8/f4R/9d/8tjz57wNtvST55/y2+9OrzbCrN3iSQdMF63dP3BmlnnG9atN4G1YPYsDcLBCSPHj/krfcfMJttc3v3NmG5whz1vGEPmNmaYzqWyeOnM8LtXT579BM2pqKa7uKT5+TkiBiHDJwaOvrNaoSq9GhpSEryyG047FeoeANfOIbYEMOUyc4+B7fvU1YLhBWEviWsl7h2Q3dxztA0rH3HJrS0PiFFRJLtsVpl1VWjRiDUhEJplICkLUYW6IlBmhqhBApFUpLQd7h2Td/3NP2Sxg9432MLy6LvOP34lLht2bp1hwefvcvv/5t/yWtv/By3nn2Ji5NH/Nkf/Ate+vJX2d7Z5fJkhSi2cLWnMUve++wp2/WUvdoSbOLt999ia6dme+eA05OPsZM9JtMaKWqqnW1++be/wcVnkfT8Lr7ZUCXNpLPgJmDmNLGjROD7wNvfeZeXX/55FrfnTHanqL3bXJw+ZbK9DRaePDniJx/+mFszw2/+yl/l8g/fZ9isCcHTOs+QOpqoqJVinaBUEiUkX1+8zDf3v87t7TtIoQleEOKG3vWsNmtCarEakphS6ILSzCiNReoyd3iGhBQDQwL8T99XDCD8JSII1huJDpFTqbNSoiNSGNzguFz2yAhDCGglCNHTdAGVRiXOVMwObhE2K6azBefdmm0hGOIACkxK1LXP0QRj6GOPCB5Pz+b8jMXUUEvBpu/Z3i2y5S8mtMpVpBd95JnCMwAdCaMSVfBsTyC4jmQLDFBvFfQ7cz45WvPlA0sKiapQudLRDfghqzWpsKxD4oZZ0y8HLntFDAOKxPHpJTd2K0qd+OREsV0mqlJxt/fXz8q1I2duk8hL2zRQq4SRMCkk0zIfKrZnloTGFIZaQhMsXmhKq/JztQ80SKRwNJ2n0hEtFDoqJirm6jKlsAWslhFlJcaQF9sxU8hRAiUE+4ts4+tajyw0hEBKin7t6REMMVKUkWFIDMqwcVDFnjYl5jZXZE5soJKJs6WnH2BIAqlHmu0AUjm0zAO5UJIweE4uYHtmCVESpUcJKHRidfSUZu15dBnYmQkODmbsbM9ZbE+Zbu8wn9W4vuezJyve+eiMl+7d4abNQDAfM65iSIlOCIYh0niYGEhRYIykc3mJsrU1Y9NlxktdCs7XKS+Gfha22uQGN24+y8fv/l6Oi5HFgqtO2JybTtRbzzKdzGmbcySKFAZEGpDSEIXITrbg87JkhKzGkPOPIgqklSAMGY4WkUogVCY5ay0xpiSmvBROKS/Dg89DKAlc8BydPIUk0FqSosOaEh8iQqbx8J3zmhNjMXLC2ksCNcv1GU3Xoso5O3ffxNRT7j7/DNNZzqterJYIFK9/5XWGwfHx2z9CuJayLLBm7BsWguHymPPzp6T2kjuvvEk52eIXv/Yqq9UJJ6Hhxp2fo2kGhqHh/PyMvmuRCl7evYPvHfOJobQqE87XPUorZGHwbsApy8YLFjv7XFxeMviB44s1l2rDZFKjbYkuDM/NHPdu1Ey3v8zT0wuSjCy2tzk7PWT56QofAsdnS+ZOsr27Q9MM6ElJ0zuUkGxtb7HuBN3hKZNJiTWanZ0Fzzx/n9/7k+/C0FOWmk8/eTcPjDqrzn0/ECUU2mCtROkJk6Ji55kDzlfnuHDK0GUxpO96lAjc2tvm5t0XeHrWcPz4fYQEZTSXqw0hBpbrJUmClQqrLUYLOufRCbS+ikkqykLReo3SjlIrBt+jVcKngLUCW5Zsuo7sfRdjvven/7gYqLTJWXyVwZFt77BGcXK5wSiVBzTvqWxJ4wPKGFTM1vqEoI85bicSuR4tJULKqqkeGwx8TPz+H/8ht+/dZffuLYpqxun5Kc4NRKGopnOMMmiTFwACMFYTY841pxQIMcddQhxBzii6vkObivVqld2Zoadt1nlYP97kfHjIjQZd07NenjNUFm0L6tkC7xymrOnaDc1mhTGWup6iTGYqhBSy22SEjzbrJWU1Y1gvIYSc95cGpRMpbrK6LiJN11EWuad6uY78vb/3f+Gv/Oav8wu/9suIlFXheraNKKqRHxGuXb1ZfOQalAwiu7UGl90xSiA1BD9cg7C1tgy+R2mNUQUi9chygjTlyJmKo7V8BDKnHKexdoLzq+yo1bkRyXsHSaJUiRscXdtxcXbKJ+/+iH/2P/xj1qs1hRXsTA1uyI1PKQXatmc2KbFWU1UWrQzFzDIEx6SaMLjMAZnVJQpN33pcCISuHwVf8M4hkQxDIIhIWed6xqEb0EaBD/S9xzlHWWpWTZuXRSlB9LkqNeb37Rf5fOG7px/c5wCCBJv1OltYxAxjLMOQ875SSnRZYouCxWKLrmt5epTJe0IIgs+b2xDCmBfI3dNmBGl5n/OBxuYh7yoH/vDhZ/zwR9/nrR+9xQcfvM/FxUUGRsDnWeSUh/dh8BweHvGNn/9FXn3xeUI/5pev6OpCjCR1P/bC5l7WTHoG5yPr9YBWiThSuZ33hJSoqkx6Df5zLH8acxxX8rSQ2Q0gRc4j+yHnMwRiJP5lqviV4i6vuu5GINq17WMciLmmiGdkfRxflDEGrnsIyR2eSoh8oXO1Fc9WEK0sN24ccPfZ+whj6Z2jKi1X2W+tMtjhCobmfVa283c6ZmtHa/gV0GB39wYpKlJMtG2bAS8p4FOkbTvabsCFiA8gyFYt73tiSKyabtzs5Z1YplUrhhhHeMmA0TIvG1Lue+x7lwmLIi9whFIMPuCDI8bIVOTqADna+PNmI5906roCKWibBjsW8l7B437az7SYctk3rA4/ZPnAoeotDqRj/tXnqXcLyqgJJxs+enJK78+Q0aP8bQ7qXba3dnjh5S/zN/6jv0W/WbG1tYdIDpsc0UliOcFRsFqf8+O3voMfPLf2t1l1A1oKpnPL0ck5N/duUZqe3p/wrd9/i+16wjOpYN4p9qr6/8vafz1blqbnndjvs8tse3z6zHJdrhvtQEAgGwQJEBwI9DNDcSZiZiIUUsxcSCGFdKMr/Se6GoaCisGIQ3IggiQIELYbQAPtu7psVnpz/HbLfU4X384EOBKDTRRXRHVHZGVl7nPO3mt97/s8z+/hVLbc7Zd0o4rDK9d41q8I1QwRoK7HHD/7NCup6+U20+2RQiGNwWpL8om+X9L3a2bSMJYSlTS741d495UvM98/AG0JTQvnG9rVgtA0DM2KzjU0wdPGjiQ8WmXHiaWkMAVaFRRKY6QlSYXWxRbuk1C2RBqNtDVIRVLgB0/sevpNR+c2uRYnJKwsqcodijRg1ZzDt97iY7NEPvkI7xWmFPze7/wmr7/xBrv7M6rJnI9++G1uvPo6pTTUJexNJ5jXbqKU58bhNWZ7B/jdVxgWH7N/6ytcWYAJZ9gUsLrg+Kzh/R9+yPW//C5v/9RXaHbnDM8X7MYZz5szai8xdszGWybK4UNk83TJ7/7jX+Nn/9Nf5NatV1izYefoBrqqODn3/O4ffYP5VPFzf/mn2X3lHcS9hsWnd5E+U4xdzJ3WSiiMSGghuTW5wk8efJHDyQFGKaID51p8TDTDBheXxCio7RyraiZ2hCosQtmtuhIRdAihiMOGGD/b4B3bHpUSt8YFfQg8PGkZFXC+ipxsFEej7MoZvEMS6AfYeEmhFHMLjc+OBqtBTUYkIjuloE+KaVkjo4NhoC4EEyWotKOMjmocuJgUNF1ify44WSWiEhit2Cx6pAYnEzJGDozER5nbJJIkKFAycDg3RKlpXcQWimUf0V1DkPDDi4hDUSpIWlAbS+MEO4XO1mEJerrP5vyY2DgOSsfMOta9IVwM7NSCXSkZy8TROOEn29ovDeBRqqAZAiFk9ds3jk/eH3jr0FAUGpEkplZIowlCo7WlKDL52yTDqgkErbCFwAVFrQUiBoyWiBAxRUA5UKXEBYhyyJGoLsMGUYIiCM7XsFODiJHkB4Yo0Aa0kgx9pJhoKhJDhBQSpUoMzcC1aY5ahaRxQ441XQTBpJTUc0W/iMguw/XitjpUxIgLidk4E2nnVVb2Wy+oinz/jkJkRaLwWJl4ZZLQBoJLTHYmHN24xmi2QzkZkTZrQh/5hS/vMzWBReexOjGvFe1guGgdyybw8HRD1ApCZLUJpCiIQVAUeUGd5JwhnaCy85x24M/Ev/7Dr2bxlPvNGSHl2FZmpiYQkT44dDKAYLP4lH6pgLw0NsYSVK4lEhJETCB1VgllBvwRXQaOKcvhtXdZnT+mH9Yv43ZaKtDpZSY3BUdEbasfZc7z24KhbzMFuxrlnmLncYNjvpvtDM47yqpms9lQIqldyXJ1STQTMCW99whdcO21n2Q232NnPmM6rreApcjezoym6fnkgx9xcu8Ddg6PmIyvEl1Ei7wMWB4/ZnV+zvzqK/SXKz75g99mfPMtrh/t8w/+9t/g0Ycf8uDxI771/Y84PX6E7xv6EJiWGt/uIUVgZAusHNBlQTfEDOdUFc57mr5jOj/iYO+IDz/+kFEyXAyS6e6c2zduMt/ZQabAp6cPiH1LQjJXkUFKus1z2iYvQY3MeWJEpC4lKVlm8z0Cidl8lxs3XkHYfF+4cuMqr9y5Tdsnnp1v2NvdY3l5htCGoWupxlO8a+n6lointBVozbrvmZiCdbvh+PwMCMzGI4SAqizpfKJf9jxfbFi7j/MAXRTEMOBDQluF77sM5VUZ3BtCR13a3L8sAr0LhBRzVCNpvvgTX+Fb3/4jZOrQNjCvS1o3YI1Alh4bQYQCIbMd/rNco8JkUKYUxJAFJa0Edrv8C0ScyyLTqu2RQqCNJSWPVpn3olVF33eURpPkFuYVJEOIecCTAhc86/Ulv/Fr/zN/+ed/niuvfY56vMumW/H88X3q8YR6PKcejfAhAxStNVuuSD7bR+dg2+jTDgNSmdyh/drb2LLi+eNPSX5ge5DGDR3eJdquoWs2NM2CZn3JnduvsR9TBiQLgdJlVo+HYVtXpSlEjkHFEPI5VgjqukZKw/LihM1qgVCSqhrj6sDF6RmXl4utOi22MrUGGVBJ0Pc9dz/9mL2Divl0Tj2ZoGSOLrSmyENlrAgq19NFE3J3uFRE7/DRZ6aXyRyAlIqXMGxQpJj5JFU9wpgSks8uWgy5bnnLhYKt82Zr7t2C7qSUmfuyXepJIRn6hrZtaDcN3/nDP+QPfuuf0zbnDC5SGotVsFh2yF0YlZrFqmdU19mtofNMsFm07OyOc5OEyk7JwQ9cLs5zDa0SeQ5TOa7UtnkeHTpPPalyvCjmpet4OiZuyeZVbXMeHQsiz5Vp6/C1pX3Z3PTvu37swTtuw235RqYoRhXONRQqInEMIeassxRIpTN51mby3+1bNcYYZtMZ6/WKrm1z5ZZSGKW3BPKwpWmrlxCwGAN3737C13//d/iTb/0JJ8+Pcd5l63fKBFJrchWCIGechZR4CUPf8i//9b/g1Vv/+20FVYaSvbiUTts6g2wH8SFbTZTMQ3Y/5FoDqSzKWKTzuVrFOaw29EOHDwMx/KmKHoYBIQXO5y46sc2j+21dGttXiiAP9EK/VPP/1IK/DRHG3A+n5YuhOr38XAmRyeps+7xJOeMteQEBynalKHIFnDUV+wdH3Hn1VerRFLmt6IohInW2w4sthGUYhpxb37724H1Wobe2t2x9i1hb8OZb7/D6a47FYsngciVAiNlB4JInIjMkISW0lLS9zxUNW3uK0pKqslijaZqWrveQBN5HpJUMPrsUYgi4kEEicQgYs61dCAFCpiQKoWjaXJ2kxDaPojQheozMHZbOJwprUF27VdH//IcpgOvTN4mreyybJ7Tdkr47Y/Mjx940UfeH9IWgLgvefP11JvM55aikHNWE6GiHgclsl1/4pV+kaztc4zh5+pw//uZv8+nH7/POa6+xv7PL85MTNqsNbn3C/txytpIc6YKnHz/nfNEQ2xVSa96+/QaffPCci3vPOVATjop9YlVwd3PKvW7BdGfM+eaC6XwXXVcQImfPH9Gsz2mWS5zz2KpGCUXwjr5f5fetH3BDT4HgFbvH145+mr/5+s9y++gVhJEk1+HXC4azFb5v6NqG0G9o04YuRvqYkCL32BZaYZhRFhZrJDqUCCXR1uTtrTW5t1ZrpDZgDMIoko8k1xHajnbd0rkOF6GwEZMMxlaoosQkhRxXTP7CbR58+w945fW3aboFj+5/RFlZfvC9H7C7u8uN63uMi5pPP/yYt995i+DXjKs5S93gUkmrFddHimUUFEd3ttnUM3Z3d0A4+q5B4bg4e8bzR9/j5le+yvFTx7I/o3n4HJZLDrSlRzJWFh89Q0j0RJaPnvPer/0R+4c32X33FpvYEZHc+9FdjFrwd//e3+bVV95BtJLJu9cZTs5xl2vMtpZKCo9MHo3l1ekOP3nwVW6NDqisIgwtvVNsXEPfNnRugfcDVTGjNDMmdY2UFqIiyZThTYMjCYdveoLvX8Yw/rzX8XLD0U6BDA3N0jPTiZgMpVYECV3fo4SgNAopFFUhaTyYFDJ7YhTZ+MBjL4jtgPUnhOh5+8o0k2GlYViBUp5CeaRPVKVkVEesTcSQKAuodeASTSE8o32dGzNSpA8SbQWXjScJgzWCSIH3iRWGHZWwJcz2Cj55sGG/0Mxl4nmTuNwErIwk5ZFCMisUQXtGSjF4weNNz6ASt1PLZeM5nKQMAJIDMiZ29i3eR6KQ1CNFbRNNn9gpDa0T1EpjREALQznXUBqGQeRWCYCqoDaJybSg7yU+KDa9YjoRVMrggiO6fAANMVCUhtZ5ZFEBPUlClTw2JYLRCB9wSE4v4WrtWQbJQS3Q2jG4xGYItC4hU8APklJLKp2XuaMIrlDEJJEq26arQtIPiRdiWCEFcQh4FyikYDSzdC6y6gL1yNC0gbKItMaiUPQCjPZMbCaAG5WXrSkmSiUw+G1WPzE8WzI0H9N2LT/x+bcgbNhsViAadlizPz5E9wMu9qy6hrjp6dvEk83AQ1WzbiO/9/7AtTFYlbuwi0pyu0wslwM+JTK8ORPeBX/+Z0UYNkTXbE+cWWkWW8VbkEgxILXNFt+UxYR8DMiuDvFCfRIeLTWInJlMwZMQGF2A0mzWF4ToKK1FIlluGmIK+JBIyWdQHQltC1LY2j6RxJCBR1LkaqEY3PacItlsNhn8hsL1DdOyJK0Cy8Wa0c4VlpcXLI+fUk52Obj6OvO9feZ7c1555Rbz2RSAbhh4/OAhy7NzlBT8zF//WwgpOHvylMWTpwybFc3ilMvlEiMV/eUZZjSi7x0Pv/ctuq4jDBs+/uQ+T45PuTw+wa3XBGkgOtIQWK7OGU9mjOsapcZo4pYfAWVZIQmUIhJiJkx/4UtfZf9ojw8/+Yi2bzi/PGax2hCbU7xrmc13sfUEZRI7lcFLw+BBhgFlKkKKTHZm+KCY7e1hiorYdyijuVit2D/cZxCSZTPw0ccPkNYCmbb99NEDzi/PaPsN0W8yGFiDEjJTpkOOEbpuTZA5VpJrCSMyJjZdrjMrjEWISGULVl1PCgMxQdM1aJnZF8l5tMziiPMDzRDRUrKzM8EmgVE5N925ge/+4DdJUuKCQwhYdS1aC9KWCK+UpBsGKmMJf6ZC9M9zFUbTuoDaikr94EAp1klQerCVRKgcs4hJbiMWAaMV2qhM0iZQW0NdBbrGI7QCLUgxnw9LqZDk3u+PHz1i8av/jF/8hV/ic1/6ElIrpBLsHRwxmuzggkfFgmaz4uzsnOj7lzW33eaU6ALK1CShuDg/4f7db7O+OEWVFZcnD0jBMZrsUU320MWUJD3SBYZhgesczWrNx+9/xHyyg7QaWxVUxYjxbM7y4hRbVpRVsbWDZxXOe/9nss85FjWZ7rJcLZFoUgj0q0vavt+6ANRW3HIUxuBCoCgMb775ObxzXJ4fE+KALSzD0NO3LUIkRtPdPFSHwKLr6IcuZ62VxNjsbEYWaF1nIJxr8vIw5gXUeDyjsGOUVsSoEDFu2Vn/tqM0pfTSvu6954Xol9J2boiRwXU0bcN6ueKf/8//gv/pV/6f3LlaMp+WrNsNgURtRIaAOjClYjypWa83HB3NKYrcxe6GwPPTNfNxsY0j5LO4ExmQbZTAx4QpNM06z23KWmZlgQ+RYYCuG3LNc9sSB3ApUJcFkBu+SBLXtggJdVln27n6j6x4V9a8tJgH77YgiWPE7pjbN29ilw3n3oHKJObO5f5tpdS2F658SctOUlAUde7plDLfWENACYnY/ppUkmbTsLsz59VX7vDs8UNUDHRtgxaw7ntmu3OMthwfnxC3mRTvIz5LGBRWb3PRadslnW8WL5Rt9VLx3NpKZK41SCnfnCFn0bStMT4S44boPWm7WFBKI8hvIK00LnXEIW+AYsi5ZSHkdkMIImxL1mH7WvLQG0KAFHNOXEGKDqFEHg63+XexHcBfDOpKZlU88mdqw1LKUTSVc+CSbC+7duMO167f2H4w8pZGkrZ1ZjovHravSSm1rT7I5NEMVsuqu3M+qxohUVUmW4JlhkDkm4UkJpW/3phYdS6/PiEYgs/0eZHVjoTCpO1QJgRFWbFuF3gXsNogUu503HQOLUCJ+BLrn4d5v6WixuwyIDI4R1oNaJ2XPkZKuq6niQG5ybTtru+Q5N7WJD6b4r03uQHKomUF3OORu2TRnTHfnCPkTgahFDWz+YzeJ7o+sVpdYIxGF5GdnTHLswUP7n3KD773bR48uMvHP3qP9WrF6dMnfPHdn2DdXdK1HXeuXGVUSQ73Sio1MDe7vH3nNpgR956eMatG/PS77/K0/ZgdV6DHIx6YjrsXl7RpwA4ddA0zfZVudZnrKLqIUgVSVxQmsLk8Q5AVZxfIP+++ZYThl49+iv/urb/DV26/g7E20ynXa/rVmtSvaBYrfNjQhYhLCb8lllo5YGSJkRajLYWq0aZCKok2kqQFRmqwZR7ATT7k5QeoIHqPbwZ8v6Hr1jjnkQImdZ0fFjqibQEStCyRxRguW964c5sfLB9zMKlwB3uodMpsXHG+WPLp3Y7bt66wU1meffqIwzvX6LonnK9WlLMJVkaWF+csjk85u1yRUV8Dk7KkbxIiDfzVv/QlPvjRRxwfHzO/vWAyTGgeLAgXZ4yUBjQ6WWoSyebPWuN71lFx9ukj/uD/9f/ml/6v/y2TozGfPj7mzu0Rn/vCf8a1K3dYnme3gP3qVfYGx8Nf/wb90NAHl4erFLlSjfny/he4Nr5NoTTOeTo3cLnpWTVPGEKDSpJRUbJT7TEyFlGWEAyI3IM69D0hOFxsCYPDueYFNezPfU3H+b2xaCXng2Y+hoMqEHzAK41wkVrD6TowL2Fwid0q9zZbmWsQN4Pg7Zs7lKHicuMYgsSqgEmRyvb0B5qp1QhhWG1y/vq08RQiYY0jhYAwhqMrlkkJXQj5QOAHep+HqJ26zlm7JFjZxL3nLQcTh1JgokbVkkmpUAmaoJiUnrFNxJRpqlqBj9CmSOcSU+vZLwOlgKNpYOO23eU2UljBgGLRJZQG4xxV32dbqhFMSsW0yPc7YxQXXSJEuGwNV2cS5wVjmw+bVpf0K4FziY5EkI6yqFCF5u7TgPUtVa1yLlfBvsn5XZUSwipCErRJoKUnWIWNnqszxdIVjOqIlD0+SC6XjmWUTCYaTaDxElkoZCHRMtE14F2uHlOFIiwdDQJls+IUUJQiqwEDsNx4Ci3QtWR/qui8oJARlzShk4x0XraPRwUQOT7vOJznKFGOIwRcyPAc5/OiedMN3H5HMz08whYlY9eweP6UK9MTHt59xsFuieo6iujYk4FnWJptlV5tBaeNZLiEqQjZumgii82C0mS4DlFQWEHbJkL48w/ek+key8UFyMxuidvls1ICETP4j5QVl1wZmi3wAdAvnGspH2YjvLRsIiVaqC1cNTI0x4DCJcHuziHICxarBVWp8CERhcYkxdC2mKJgMt6l2SzwoccYTUqKyWQHAB8ipbYvAa0pwkgZtJe0MeGFyRWf0nBw9VVkMWayeyVX9c2m7B8eAoKua/jwg49xQ8/htavs7u6wWW34/h//EevjZ8yMxIrEatOwWa/xrufqkWTjOi7Xa9aLJc/PLnnw/DmPHj1m6Bt88sQA2AlGFWgVWC8uMNowrfbYGU9xrmNqzplNSsrpFYQALSI7u1Nu3r5Gs3lOt3rMzaOKx/eW6PEUqSznXSSkiB96ilFNnwTr5TJbgUcVIVX4xYppPeH2rTc5X1xkzoo2TGdz6skcoUtsNcaoAulbdGEpbElwHfPpLu28YTrbYXnxiCdP7tN1G4xUGGu2UQCB1BmyJcgk81z1ZRBF5kuElBtxQhKcbxakkKuqpJBYUzIMjkhCmkBZ11hTsNmsQUp63/L4dCDGwGRUMZ1OkUJglEVETxSKF5nHlBQuBsImEXwWPYQG/+dv1wPIS0AriQh6H9FGUxqN2QpvCUFRQlXVeJ+bbYYh4oJDojFSURiQRaQPma5daYmI2f4bk8e7SIiBsI1pnp2f8eu//i+RInF4+xo6TTG2Ymdnn0B2bSplcS5wsVxwefEQwrBtK4L14hPWF+csVxueHz/j3o8+YL4zwZYl4/Eu6cWw7Db0rqFZrbk8fcbTR4948vwUZMHrr75BPd+lEYo0eEJ0dJsV6+KSGDzj6c7LTLV3jvVmxaZZEsn1xT6m3JZjslvViIgPOTqbJ4N8j/Ep13UezkeUlUZLiaSnbzf0XUNRTWjWCz5+748pbcX68jjnv0WgrGrKas5otoMpCspqws7BVaIpiTGQQtwCxnKlW64fMyiVCeVCyJcR2hcR0bidqwSZt+Wc2/Z+5/kihPiSIdV3PZ988DG/8j/8I1LoWC0jB7s1k1rR9wGjBKPa0LQ9ZWmoCkPfSzbdQDkaEYaBslSURUXbDqyWLcJqZqNcxYvKME3vAuv1QBCZqj6fVsSUvy7nI+NRbq9yg2MVOibzMVarbfTWkGJH23acnZ6grWH/YPRj0/5/7MF7VNd0ffeSRP7k0WPabs3j+59greXm1Wu0zRnLoYdtLgFgXI8otMa7IVMStaaQWYmNIeZcEJJxPSIRaNsuZ7+l4A++8Tv81m//FqvlirZtOdyd89rNaywWl3x47yFPnhxvqw1MtiM7h3OZcGoKwxuvvp63uNscg5byJbEPeEnzzg+dvHkLMeXKBbkddreZpkrlrZ/r2kwVjYGiKEkx/qnF3lha59BCYUxJCG3uBBSZmJqUIJGQSSPJ1hWl82si5toaKUFomR/8pC1tERRZ5Y5x+2dt8SySbTJFZGgNKf8eISVSCibTObduv4IuLEPXbemEUJbl9s/+0w+G95nG/mfhCkrnnPYLNT4P5hZjcgd633f5a9cvOtsTSms2mzY/QAQZ5mIVznliSKw3PcsmoJVkOjI0baYte59A5Hy83B7CSy1y3mdbZfAiky+V3Frbs1UppEgSHqHyIcn7iLGJ8WRCCD2r5RoZPF4L9HYRIj/jkDE5nGFWucIFYxDtfc6KAdcGUlMyu7pHZ+HyYsWi2fDxvfd59OkDhB7x5ls/QV1G/HDGH/zhv2Hx/IL18hQ/DHzhc6+zdzBi0Z5Tl2P25zOOjvYoCjg7ec60MIynI1bNwGgy4+bNN5CF5dV3forwyxE2PZ8+fMbTj75DuLxPbUcMbcP+0W0uzp5hCosNY8rpmPOzJ1xePCXFyHi8jw8drmvA9Vjv+Cv7X+K/+9zf4Wuv/CSjIn9OQrOmX25w61XeyrsGFzwuRZyIeJHftyZatKnRaApb5oWILpFaIaTNUA+hkFbnhZstEEoQfdryALLNy/cNQ587UGurSErnnnIp8ntAjIHcB51WA8vf+ZSz2T2O5jssRxPOS831mzd5/8OPqETi3HV8+/2Pefe1q0x14OSHH3LtynVKo1ltLtm9fkjXr3j86BPQE0R0NN4xqfdRFlpnuXnzVcL37/P05ITJvU8QD/ZxZwtKWSC038YcDEF1KFS2PQtDGSVtEJx/+ITv/cpv8MX/6q/z6tUdnNmjT5ZN2yErgwmWvl0w/0tXmZy8yfPf/yO8H0jCczga8fr8Da6MrqNkpAkDXTfw/PKMVf8cnzomumJUHLI7voGxU4Q1CK+QyhGkIrkMi/Sho3Uu052lQMbPEGYFLpzhQES08MxtAmGojaBVMDOJhVJoHbmiI15Kdo1ARMHadXRtRBqYK/BeUEw0ezrSLz1ea6oIdSW4Mi0IITcqnCxSpo/LPOBZaWijIooIUuJedNQSkV7BNtoSJXRtJHqHNoJrV8eg8hDTdpHFaqAqItENvDKzeCfohMbF/IxQMrEzUpnnEVpiiBQVPN5Epn3kaKqZTCWKwKJXGCE4qjME82AKQRiCVMgQGZUC5xWXC08tBLWDIRl2ogMnQRlcgt2x4aSVGCOIpaG2krrIdr+27dmfOMQgWQxgfGDhIrJSxC5S25B5I0YzLRIyZQfSqlc0XeBgKggIVkO2BvtRgQ2RLimES+zPLUrDxUagTaKXiroOKKsI3hNHFT56VNrWDYlECgMKRVVAvZOXLMEkep94eBY5LBLzqeD8oiMkCEFQ2IRSsDvRjApY9zlLOJoUnIiGcQU6Zmjc/LDgrbduMdvdoZ6M2Zyd0tdjbr12ndM/+Yi275hMDW4YiIOgWDnO2mxdH3yid5FVkoRCMLN5sXu5GlivzgkysWgFVkcu3b9VIvIffN249RO8/8PfJpIXPWLbjxtSzKyWkF7axePWvYVI29+TnXIv1CFIpJBp5CEmAgm1JQ8rM8qpzOBwbkMkD2v5cJvryHzIuefgB/p+nS2pMWX4KJGuWRNTJkuPqgkJx3h2yKg65L3f/zopCkZ7Vzi8vYu2IxyWyWyX8+OnBOexo5rJdELbtBRlQUpw9doRxhRMpxNWyyUP7n7C6vSMZ89PWOvE3rik6zseP35EWeT7hZSSk/NTPv70Hk/O12xWS7p2k4dAXWQAk9LEJNh0HYWS6NU5IQXqqmA8qvncu1/EnfQ8PT5lszglkVirlicPLlEqbgWSwI3r1yiKkrZpEH3BSid0oamqitgNrNpAFJFCabSEG1ePuFguUfrFmYjsYmvOOdyfM0SH8G0Wlqwluo6Hzx/z6Sc/4vTsGO+yBRwSShvqeoJUuYO6NBofsrN0GPLZSul8Zq0LyfVr13h4cooTEmU1xEgSmZ0SYm6U8d6xu7vDEBJuaElCEpJnPK7wXkAcMFLQ+Mhmsya6huvXrnFJJG67ipsthE2ZfEZUNuKkgAA6SfRnPDsVVYlrO6QwqOSZ1BapRe6l14boPYc7M+oq0feSdeexRcB3UJWKZevYDDAuDT4EVr1n0XsmRmVQV0ywBaYpBYnMCXp6esI/+//8Kn/tF3+BN966zXp5SVVPQObcdt91eBfxQbC6OKffnJG20DIfI2eXl3z66X2iTywXl5ydnTEbj9m/OqCKKgPqAnTNgo8+ussffut7rNY9/eBRUvGr/+I3+S///ojgHc3mkpAaum5DPJUM4xbvPdbWQObtdG3D0PWZ3UJ2z+pts9Ty4hKp/hRUnYRAECiNZDrWzK1mVGqCc2AqkCXe9zx78AFFOYakSMnRLE8QoUcpw3jvCFtVeNcyuBJb1iSg3WwQMnOhrNUURUlRFFTVKItcxuJ9FgVizG7iF+JiCP7PzFcB54aXXKss6GVQc4zQNBuWiyX/8L//h6zXK+bT7PZarQfqWtMOjmEQjAsQBSyXDUdHO+zuVDgU58eXjMYl2ghEMjRNl9/3MXGxbCAF1FZ4FEoxGhsIkrYd2Kw6EhkmaApJNArXNYSQ0GV2GLiYWHceYXK1bKnA9TXRtyQcKf5HHrxjfJETSozqmmdh4F/963/NarVivHuAVAX9MOB8BmK9GN5c8DAM+cGgFDEGiiJXS6yaJhMcrcQHR1lanJOIlFivV6xWlxijsUWBc577j55x7/7jbJ9KAmUy3K3v+kxCV5LpeIeDgyt89Stf5ae++pM0bUNKW4I4AkHevFibe+tyuF6jdaJpNngfGI/GCKm2Hd8vas8Uo8kujVyQgkOhtzYvgy1Lgg9sNrk33MectZZKEUU+bCmZD4Nh21GLzHnqF27nHOfeZrmFRMqsgAskECF6BDHnvQGh8uLiRWw9bh/KpEyAtMZyev9Tlg9O+PwXvpJ7BBEYMiCOrQ39xffAe09RWLx70T+Y6JqGoigRQNxmxrajOt57VuutHTnEXOe2zekXZUnfewrD1pKUlRzvPUiJKQv00DOqDEWhtra6hNL5w9p2WR03VmHUi5ozQeccziWkMCDSFoqQCFsonBB5KGfbr6iNZbNugLxRNdqiFYDMN4nPCJKys2nuPJSWajzBLCw2XtJ2PYNbsr40LIF2W6tQlmNWmzMWx+/x3nf+DUlofHeSgRbOszuf8Bfe/Bx/6We+QFHs8L2PP2SzWuUPdOcpa8smOp6dXTL1guluifGCgytzzPQK04M5ILCF4QsB/ur6F3nvvU/4V7/+L/jdP/gmq8UTSAVHV24zOdphfX7C/Y++Qz3ewxQlw2aTb4pDx1/e+QL/u9d/ma/d/DyTUZnrbPoGt1wRVhuadkkYenxIuNjjhSYqCEFilMWoiLUj9HbgVEoitc7/bzWqKBG6QKoyg4tUbhsgOlIY8hJo8HjXEcMAKaJVhS4tUlfoQpGSBpGXMSIqoosoESg/XsCNu9z7+Cn7t9/hotvh4YOH7B3OeXj/OavlCmNL7t4/55Wre9y+fUDbLrm8aEj9Bp08lZ4wJEEhA4vFGZVIoBRe13znO9/B+MhsWvPe+3exuuCVUCD7jpFQJFPkPKYAH0cI8hKyECP6kO3PTYIHX/8uh7eu8s7f+xrL2GJsINmSlBKdkFz2a2IhuPq3vsKTx884+/AT7oz2eXV+i7HeZYiOtfNcdJecrI9p2jMqY9kdHTIrrjAf7VOoKbbMlupAbigYeof3GwY34EKHVIboBUpa5GfIsgLsWkeQAhMF81qQTKBzER/BEZmJQBKS0cTSD57eeZaNJ3lBUAodoA+RkZa0K4V3BvCYoWd+qChKTXSOGDzRC/bGBQFJZWFkcqZvHh1uEJkM7OHpwlEVAmciO8ajdaasTkxgMViGCKMYcC6idGJcCnasoJ9m9aUq0xaGlQ90SWx5GsahUmBUZdv3eh3QB4abBwX7BxalEiIKKi8RfSKIxEjDEASlzTRVrM5wNRJoQwyKqooY57loAvO5pPd5ObtoQs6+S0WhI64PnG0k0QsQgRgkQmZXVVAwLyRYzWUXkNaiiQxOEKNEJU9MibNl4Oq+QKbIch0Zl5FFF1EGKiNQWoDRbIZAJSVWBnwQaG2wOiF1ro+ri9wLv24cx+eBw1k+oCUSIhmCElRWsEZiVOCVQ4HGo0RitisIfaRAEhIUKec8q7ogSskmNNRjhZGCOIAUibKUvPbOFa5cv5brQacH2OkecRh4+Mk9Lo7XjPYsO7OKdgmdTtwpIgcKFj2sQ2LQmZMyMwKjcpxOm8TgyfT1kLClohsihD+/tfa97/9mfrYrRczxbGLKfJe0Jf2qFLMdPIK2JT5km/RoeoVufbL9fbl7O0RP3Fo0tZLbyi9F9P32bCFZrJY5SrZtYWF7ICYlfMjVYF2/JHlPURTI5HPtkIhcGx0gekdpr2CrPS5OHuP2FFdvf56TkzNUuYce7zMa7RC8ww0d68Ulvhooq5LF+QV1XbFc5uFhd3cfEDz45GPKeoJIibquqYqSRMSWFb5dcbG+xJ9HDBGjBPefPOfZxZquuWSz2bB0ElHNmUx2MtBXQhw66tkOtrKMplMOD68wObhBWVek0HJQtlzQMRAR0RF7h0gxu/uAopyQVEHSBUJtCERQkpAEZ+dnoASjcYFQFQiNsQZsyXSWf60aOXzwTOqSyeyIi1XPl7/4EywHyf37H3L/0x9yefqcwirWTYPRBl0oiqqk2WzY3xvTNI5mGDApq96+yzW5SJEzuNuBZdV0vP/Jp8Rt44sQEVNrNps11ioCEkegMjaLN64BranKkpGRTHausLw8I/gSKXpU0yKJWF1g7A62V7iwYXc6Z90tiXisGlGpQJIJHwea1uF8pPgx6c3/rstoAybnnaVNVKXFI4jRI0OOGF6s1rg+g1etVHm5ESNmCMzGGudzHDEMCSUMtc0QxdYFUhBoWxC9x2hB3w95uZfg5PKSTz78iNdev8l6dUlRjVCmwPtA1+Rh9+LkMRenDxF+Q0IwdI6nx5ecnZ5gR1M+eviIdtVwfW4Jm4aisBxezZCyMLR88sEH/PEff4/jxYBg2wiUEs8fP+UH3/om737lq0z3dol+jQgEjOK/AAEAAElEQVQtlycnbBYz2s0RZTVB2ZIQ8kySVfseJTyJSN+uuDw95eL4OVd3DbPaELWhKkoqa6hLiVWw3jhOmyXXVw3VKPMWBJBEpB8aUoiZHyEESShQBmsrhLKU4zllPUPbEbaoQLCtqStzJ7gpsbakeFkv7LezjMytDUlswWpbpVtk7tXgekII2VUbYBh6Ysw8rKZpWS9W/E+/8j/y3o9+mAFzaOpRyWLZMxWCnZFi2SYGFHVpEA4uFh1FMeHK1SNOn57y7OkZ09mE0ng0nrKuUEIzKvP7yvtciy3EdhkgEmVV0Q+O1apjNqspjMnU+K6jT4LJWKEMdG3PaDSh7xPKt6AVV68ekIcRT9Ne/Fjv/x9/8E4h++CVpt2sUVbysz/7V5hMdrh65RBlxoiiQ+HxPiPXQ4ismwaleqzWL8nlw5Y+rs2f1k3FlKB3WFsilaYoCv7O3/n7/JW/+p9wfHzM8fPnPH/+jOfPn3Fy8pz5zpw33nibnfmcR48eE4JnZ2eX6zducvXqVY6Pn/Ebv/HrfO5zb3Ljxo3cI73dMqaU6PsMbEhKsLi85L33fsCDhw957bXP8e67n0dpte18Fi9pf1oXTGZ7kDxD31AYnXtyved0cYx3Odudot8Ss+U2fR4g5Ydm3IJTSCJ//THlqVuRe7y3g6Pc2jReWMZDEoS4rUnYDs28GMp5sRPP0LbRbJ+Dq0c8+NH3uP+D7/KTP/fXmF07zH3iUmC21nAp89Adt4uSDIrLXYZGaZRVVHVFEXOOXUpB0zS86GB/sdFKKTIMAyFEyrLAO5+7eFNElDqD9/pASjKDG4ymtJFRVVJVOVPvXcjfu8S2izIyuIh3AbdFV/Y50p2VlJjz+Sn9KbQBkf/8vCTKioCUeZsvpWA2HZOiY7Fsmc1maP3ZtraiMMiUmFiDXkiMfZNRWPPMXLAaso2wnkyY7+3RRo+pDFf29jg/P+bu3R+wODmjqq7TNpd0q453Xr/DT3/5i+zND1j6AWUKolrQ9RueHvese82j+w8oy5JxJ9l1gr29MXrZU+mO0iemo5K6qGj7wP6u5at/YcLutGY2MvyP/+RfEMgPfdNoHnz6Iw6v36HQFavVJQTPT5TX+T9+8e/yV29/hcnEgBckN+A3S4bNhn69wrcbXAr41OZKN6W2DgVJYTRG5UHbiqy4SKWQJvfHCxS6qMAWKGMRVQnke0voAmno8U1HSAHfDQjhkMpiywKBQVdVfrOnHEtJbkCk/BkLQIyOsEi4ucBvjnnw8ZJXX38H1TZ89+O7vHLrCGEFQxuZT0d878O7PFsv+KmvfImbt+dMC8GT00tGleXJsyVvvjZhPq6o9U4eKH3Hl7/0Exxd+RwX5+8T7Zwbr95BfzDCxgKlPCLmRV5IiVKqTGjG4yUkabC6pAo1QQge/fr3ePUnf4LxK3OOl+fYuaYajUmpwpbLvJSYR9783/wMZ/+o5FpfUosx/RBY9aecthc8WT1CEZkWu+xU19ir95mVu4yqKaooci0RATe0+DDgO4+L+XAnpIIo0UqhVfps0h7QdIHdiaRQCWkUVkW0UQxDzMvCPlGbQBoadIiUMmJKQ2wTFFlZ6F2iqmFWWe5tJGMU66Fjc+HZsx0CSbKKQnkm9BRFIkTJciEIPsH23tCIiI2ewzrxfBWRIeXMsxWM6uy46ZsECkoiwuaMslKSaDRjndBCQIr0EZyQFFZSWgExoq2kElDWeYE5GwnqumRead5/GqmKyGIF+7OERaIQOB+xSrDuQSEQfsBOShSC+UQRguJiExjXgoNRyUBif2qJ60CbNHSOepK4WCuEy00RMkpkIVl0kdJA6wPTcaLvA926ZzrSzOpcBbXsHM1FjzCKtpfs1jl5EKxCJM+ylxRji5aSfhMpCk1MITNRYmBSCrx3nHSJMESMTEzHmr73JDwpJKal5/lCcjCWuWO4UDTRELQhBMHOOLJ+3ma2R4jISjO1gWdPInEk6YWk87mFoypApIr1uodEzisjSD7xyfcfoeXv8eZPvMOd8Yhy7zqzq1cZmo712jE5ssxnJetLS+08V2Nk1UFpwLaCkcnK/OATTV7JM/hsgzVya/mN4LzgMzjNmU13GIYeHwIxOFKKLxffSYgtJdoQkwIcg2sRgqwGijJ/JIVAoDKMlQwmAl7+u2yATNTjCWEY2Gz5KM512/wm+fC8fU0x5kYWgWJ92eIWDtcltEksdQ9SclvNuXn9da688WXOL86ZHdzgyquJTz7+hNF4FxR854++iVufURSW2f4NLi+eEz5Ys3h2l8Yrzi5XdK5HCPj8u+9yYCzXX73D7t4ehZWs2w6hDTMtKD75FCUSxpYZ7OcGur5j0SUaUSENjCdTRtMJZZEBSc3mkkmlUSkQ00DTrVn3DW1wrFcLmvWCvRq6jUCqgrIUOJ/PYNPdI1RZMh7t4rFsNqfs3bxBOL5g0w6E5Bk6j/KB0aQmCTBFhdIFtkwgJUorlDZUVY00iitXb/J8seaHP/oBT+69h0gDMSW63lFXBmNLpJAs1ktIsF7lalpiQGpDCD43/WydgikfHLdnnNzPnch1XkIJGAI7k33W7QYRwOqsnK9WC6RQaAW962ibNZerk2y7FrmfPiZHIQVGJLrl2bZRyLPYLBApYMvI7nyXzWpDZRN9UNSpIKZE23420SL0Xbaxu0BdmK0LI38uXACjNFYGWi9oXRbu2j43oiSVqeMxJHzIzVP1JOfOjUgMZmuTJ21BylnFDOlFVa1kPN3BFhVtc8HlucFWU2JMrBbn3P3kfR59/MekZoGIgcl4zPc+eMzj5yu8j3TdMes+UqQe6XMO3YQ1sblgNcD3v/dd7n3wUX6+WXIzzBYqNiolP/je96lrw/VX7lBUhkTmcqwWx7ihZ7pzFaFtHhJjJoMrIQiDp9ssWS9OefLgLlZGQh84mFq8KlGmxChJlLBoBlyE2gruffg+VflFprtzQKJlRQw9Qm7dNKJAFxMmeweU4xnj2Q5FNaWe7GK2EUBtDErq/I8yaK0oy3Lrco0vORGCFzXI8eU8Adk63w99fn9rQwyJrsucLGMsbTtwdnbMd//kW/zLf/FrhBi2s0gGro1GluWm59p+jVKJrg9UWjEdW3oPm3XDfsjE8evX5iwWHSfLgdIItA8kK1HakGJAyJAdvHI7cwmN8w7nIuNJhbGZxTG4QB9hOikJMdIsOoQxjAvNcrNBFhYtchxKClBhja1GP9b7/8cevI3R5Cx04Oz0KffuPeCNz38FqwxGF3RDQEiDMRn29UK9lUK+pJi/UFf7vs+Dr5RUVUVZ5iqu/M9W9ZUSawsmkzHGGG7cuAkpMQw9q9WS0XgESDabhmvXbmZl3Fqk0mgluHJ0xMHeDkplGINSOXfgXdhCwuByccF3v/MnPH36mDff/By/9Et/nfF452VX+AtLutpaEJWSpJj7voVUdF2HFIqha2iWCxJ5oI4xZjuY0jnTTO6UliFmWEqKL77UF/+TMSsiK+sRIIktrCxuwWpZmc9KmvpfnI+zoi6UpRpN2T08wpY1N996m7vf+QEP3/sR86uH20F1WyUi1TZzkZjOJkipWK/XDIPKarPJ5fPOO9wwIMWALcxLW8t6lYFc2phMopYS73NUoK6rl7VxIcRMIBc9i3WD8wGlJDuzisKqrPqkDM4Q2zWFfalK59ebk+451y5T2uaPtlA1cv1YEoLOhazYpUjwiTK9cF9IqrKiqivOLjqawaGajvls8uO+/f//XkJrhM4QNzudMnVjglszIGiHsD1USZ4/PeaTxw8ILtKsL7h2/Rb/yS//50xqg0ob+s0K38LhlRmh6dicX3C+WHCxPEZJhU8Vl+0FLipsOabpPf3FhrNF4LJLpMk1rk0V1jniYFgNLRfLJQyONESq8YSf++pP8fD+p/z6732bx/c+ZDKesTu/gR82nJ49Zl9N+T+9+p/zD177Goe7e0gliU2uBuubNcO6Zehbgu/xyeGRRGFIity3rYbc3R4LjC7REqTKD1RlJDLlnxGyQEiN0JKkDLJUJHJgVqQO1w945xAyoIoCpQqENOjCkkQeqBAyg4VSIEqRF10ikuSAjIqVPUfNHaqvWZ6cE7jL3v6Yo5M9Yuz54p2bCCVp2/z3LJuBb3/nPW5c2eeVO2/x1Z/5ZX70w+/x3R/9LuvmDl/94pdZ+xWFaxHthkG0+NkJpxenjMaKvhFwvAYRESkDNpIQ+fCeBFYYPANl0niRmRDli6hEo7j3K3/Al/9vf5vDnSMeni44XZ1w9WCXyf4Bq5Ml/fI50ztXiT/V0H/jmGGzYdmdcH/9jMv+gpEomRQjro3mXJ1fZWd+gJb5gOhjJPQeIVq6PuBc5ml4ISm1ReuQeRVoovvTRd6f97p6UFDICEHQOfAycXHpUFoynSiM9yzbSI1ElBVRwKgANZWsu0BpBMoJJgUInZgbjyUx1hqHYT14YgzoLrKWguTAHntMEUgRUqGIUhCCZG/iiU5RGM+OUIgg6KJG6YSRjqFLTKUjDB5rNblNGnRMFCpbye9dCjQBpOBoDFokBkeGisWIKDS1jIzqxKWQGfCpYHeUF4JmKhlPNMtljgaVRa6ZqWyg3QRG44ppbVgNkcvzgDYRKck/C52wSjI4j1OZh4FKnG8CkYCx+ZlpVaDdeLQQ7M9Ufg0hUBhgkfBdTyN9Jpz7gC4Uy1azPxPUOqJShphdBsO6cUxUpHGBIkqmdmDw8LyR7I00qxYKbdmtPVFKkvcv42dN53Ebx6bPC44wMjijsHRMheB8me+H6y7nlx2RQsPIJhaXntIIXNejeuhLS4pZlSisoq51hrc12//WJ85PHV//N5/w7T+4x62bv8v+tUMOr+9jRpo33p7mPHvTMyoFwguUz5RyI2CsBBDxQmB1wsb8jG2jwI1AJRg8FCYrNup/AQr6D7mWmyVKyJe1pVIIpNAobTMtvMg5VqklbmD77yWCyGpxPwsWfkCbzI5Agg8DWmVoVkqZTp2A5TIrLinmjnatNEm8GN4SWuQlaYoJLRVDG1ietCgMScht1M/w2ivX+cIXvkKImkd3P+TbP3if1954jd39I2azMcuLYwwDr9++iotXGKLkYDbh1etH3Lp5C3e54Ovf/AZ//J33+PwXv0LwA3/yJ9/j+pVnfOmrX+b6668iUmTx/DF2PKd9prl59YinxwvKoqCe1rwqJU3vuDavAM8QJaebFtdFNllsYjouqQoBlFTzA/RojppMclVpv6YoJK7r2R1bOu+JKdK4hNSSp8dPmO8cMtp/hXa5JiVP2zu8FCQt8EOiGs0wZZ05P8YilcFYi9KGRXOJkYZqMqVPEhMH7j55xOmz+/h2g6BBaIPrcgQOL0i0xBRzlFEbgkikbb61LIu8nEkC5zzKaIzKy5kkyNGClCuLYsh23pCgbzoqU4DMzJYYA4OPIBxCWfABUFR2TFHmaOXJ6SWbvs+g4iFS+AVBSiZ2Bslz2bS4dWKz+YhKa1brQFXVuL5l8JGi+PEGjH/XFZImpIi1OXLRdpnNEYWkb3uclAyDxBQmE6l7l3PeMfNSqlGBCwOty8KUFAJHdsZlN4DKdVOFZblqCCp/HrzMlb0pQDneoawMrl/nlqME5xenvP/DH/Hsk7vcOBhx5ahGhQ1d3/Ps5BwpM3tpbCXvHI053Cm4c+uIonB88uGf8PUPW04WDftWUFnFVa2JQhKEzIuWCHpI/NEffYc3Vmvu3LmGsRahFUpbpJZsNqcIYZDKkrYgxb7rCMHRdwNnx6esz8+YlprzpmMyGrFRueXHx4QSiVFdbYOojo0f+OTTu7ym32BUl0iVMlFeKEh54WNthVYFCUVRTRlPDyjrcY6Wap3PcUpR2BJrC4qiyE7VraKd4p9174qXbU9C5HqyruvwfqAoamIQONfRDw1FUTH0nvPjZ9z94H3+8f/wK/Rdl/lRUWAKxXrTszuzxGg4XzoOD0rcZeJs1bNvLPNZQdcMPHnwHKUTRamZTErKUrFZ9Tx9dEE5KrFGbd8bIjdSJYEPCSUFZampKrNFRukMT5OSybgk+pDp6FoxnY/y8kZZSCLb7Qv7sonK6h/vOfFjD96nx08xtuT05Bnf+e63eX6x4PDOm0yqOiup3iMEGK1omzXGlrlXWUmUzFvGsqxw2x7wmBJaaaSAoe8YXHhZV/ViQM9WhbwZVlssvS0qdm25zSQ7xpMRSigSGYjmXEApiMGjUk+7Htg7ukZR5OoBlwJuGPjDP/w63/rWt/mLf+lr/M2/+bep65qUMhTsRXXXCyt2iIEUAymZlypxSpHF2THBeb7+279LP3g+/6UvYIsif8NSppUmARC3CjXbCqusT+ft43YCl2I7tOcHYoyCKPOmK23X1VKobV83GbayfZMrZUAabD3l9Tc/n7NBQvHK597h/euH3Pvh9/nCz30NoRTWWq5dvcLl4pLNJm9bu657aTd3Lnf4KaUY+oG2a7HWYq3Z/n0A+aBlrOXPSmRaq5cVXVrpLWDBI5NkZ5ZV0MvlZqtqZ7tn2LZSWJ2hM0oKvA/ZAaEif5oN2VLiBdsqCUVIgeDzocRHQT80XJyeY41mMp5RmJLJpKKuSoZh4P6Dp7A9yC6XG05PL/nrP//jfgL+fy+hBCJFfLu1cupcueLlGLsn6EksFhd8/OAxdx98zGpzztBc8P4PJ/zMX/wFfvZrX6IqKuRsTlkUPL5/n4tnT3n+/Bmnl2eEQTGqLBstsKNDguqQ0mf6tBAM7Ybh5Ji9q6fs7h+wPFEs2FCPK1CeoVuzenJOXZfYouYX/sJP8s1vfY/T82e4oUPE5xSm4Od2vsj/5e1/wBev3UJbRQqRfrlguFjiVgu6wZHcEpfUlpafPwdaimyHQ6GUwagyL7m0Rqpsd9N6+/DwniQVyiiSyTVxvFB7EoTe5fwjCmsNUSqkKSGBMkUm+KdA9AFCdkBkq1TIXAQsVud+Yf2WY7JXc728w+n6kucPP+XxszFJ5Wq9w/1dfNNz62gfqSLn644//JMfMTRrqrHiN37rDKMEf+tv/DVc74kyoINieXHBnetXeePVt/nG732HG3f2GC9KYn/BcL7AktDKZseKjChhcsaMhJVFjqDEkpQGjCqwOqH0jO7jNWe/94D5z97h+pUpsjKUZc3Keh4+WBCaE65cu47/mVc4Oel4/Psf8Hz9lHZYMVMjjqo5d+avcHXnFUbFDFRJDILQNTiXvQBx29wgJLmZAo1RJYKA0rn2kBj5jCYQDAOrTjD4iAmR3kNRKEoiqY0ErUheM1gwWxZFVBIlNLrKFWc6eaJ3rDqHUFvyc0rUJlJrAV6ybCMhGUzTQ61xiwF9WPF04dmd5n7o55eSaRm3HeYgS8X1OrLYRC6XiXaIhC5wbd8gSstyCfPS4YdMRu9j4nAiiVhSEkxH0DiwybEJgsLkA8lorOhCYD5RaBE5X3maTY7rCOBZl1h1MBlLykqgVcJ5gSkKnI88et4TgP25JSWJtIpxpRDR07nEqoHeJ6zWjMpEXeQ4VueBEFm0jugl1uS6lbZzjCvB00uFMJn0rjvP85XHJ5BRMJvkLL1MgrZxPF8I9DixXwgK7ZF9ohwZhiBovefJcU+xb0hSEKPgYu0QWiFEQMkSI6AZJI0sUFVifwz9EOhiYCgkba+QOOgCXgm6xsNEEHqIPTxdW3Z1oJSClPtutge3HI2qCs10qlmci1zraQVGC+odgy4MIg2cPj/h8vwUiYQQmM1rmj6T35vB0PpM9c5u4oRPgkJApQVD/mXKBJdCcHWcGLqE3NpTP8PcjdFqS9AtUEKglCXE/PwwCnrfZfuzky+hqSFF1BZMBAJT1IDfKuF6qwjlZXSu2JRU9RHr5RNiBBcHEoKyHNN3mW6e8+UaJQR+cEQfOD/e0HQRkQau3Tii2/Scna+5/+yMZ7/+L/nyV3+WIRluvfE5dqYVvltRKEcQDjc4XN+wblYc7u/zuaN9roynuGfHXIbA7itv83N7N5ntzJhPapp2ha3naFMhhOD6629Q1jUPv/37DP2Kq1eOmOxdY382ZlidMW4u+Ol3buVFfMjK8f3jc+6eLmljHqTXQySJyMHhnGI0JhnJxfk5IWTQpO/XQMKlhJQaKT31zh6X58+RtqIczfFu4OzylIuzFaNpxaIZCD5Q2hJTjBBKMxpPcS5gCstoXOGloBomtMPAxbPHbNbnpOgwSiIluBARZBW3tDrzZFLAb50GUmW3p5WGQFa5Q8jnsHFZcHDrJpum5WJ1RgoDRltAsTvbY4iJTbvJALZhwBjBuLZMxxOen57jHOgiL2mSjAxDT60VSXguLlu8y8TundEYSWRSl1itOZjMWXee4ASlVqAt3vUU5ZRKCbQS+JTp0G2/+UzPCZEgOIfWiqKypJBwMjtMbFUjpMRahdHZqRNkBKkRIWFKzf7+Ppfrhth2lKOKZrmi0pKyzOJU2w8IH2hdT1VbRroghbxoW686Rjs7zGaH1BPLcnFCt16wuFzw3e9+l9/7xu8xrNaEfoej+XWEDZxeLhkVFiUStU28e23EzcMRN27vM7Q9Hz9c89vvL2iaRFFaOhI7pc1sEVvj/4x4pGKgLCWP7z/g5PiUd7/wFjHlauOynlCWI3SVobdKWxKJ6D2Dc3R9x73795FCctEGlh4OYsdoYnAkQnrRwR1JBKyWDN3A2cU54pN7vPPu2zm+oNI2JipQJFyMOO/RMUPdYsgVX0rlriQh8pk7s5UyOV1tqw4RYitI5p/ty2E8BWLwbDYbfHSMRlNC8LRti/eOsijpu4HTs2MeP/yI3/rN3+X+o/vIDK5CEqmtRipN00f2pjVnF22uDN0dsW57mrbHWkVRWLRStF3Pct1RFAWjuqYsRyhxidICXeTIljEaY7LTVmmDjNtFhJL4BJu2o6wMRuVWplXTo2xegq2XK8p6glG5IUGrAm0sg3PYqsK8aCD591w/9uD9a//o/8Gnxwve+vJXmU33OLr2CqUtqKsyQ818wGiNd2LbMVqQyPVNKeVcmFC5X87ITI6zNtsVlosFw+Bynnj7hEtbinaMaTsISrTW2SYUI8ZUGGPou5Z+6IBsgavr0bYSRxKFxlaG9abNdhPnePjwLn/8B7/Phx98xLU7r/K/+pmvURZFzk5vVVvSC+J37gcXCRxp+2ZTCLaKOILnjx9x/95dHjw6oajHvPLabcpRhZL5MBsAoXT+Rv+Zg2YIfru5DKQkcgVMCC/J3VJKsiMtZSv49gCSXgTDo0BphRSGarKDLmqKcsRkMqXrLTLBfDbm1hc+z3u/9U02lwv2b12lKCyL5YLVckVMIgOthGC9XtO2Xd7qSolzjqqusIXdqtkO7weapmEY/MvlyIvrT7McGcBW1zU+BkLTUNsiL0WCB1L+AEtJPwwMzlEVGh8cXZcHqvy9385liAyYSblbEGC1atDKEokUpUKkhPc93/i93+HJw6ccHl7hS1/+KlIZ2q6j7/vtASaDa/qhJUWofkxbyL/rEkbnPFjXEpxAWii0YlxMaNOCi75n2XQIW3DnzS+xMx/jmmecnZ5z7WiPs9PnLFcNN68f8ODxp/zer/9TPvzRPYrSsrd3lf29MUIn4hBR2nJweCOD+VbnrLc92UObePLwHoICoSX3Hp/w+Xc/z9XDeWYjSMVHH3zAzmzOzt4tfv5rP8U//rXfpCwqrND8Zzd/jv/D23+P6/U0W7fXLe1qQXd+ge8bfGgIrschwZLdCUKhURgtcvWXEJmgL8n92zrnGaW0yLImDQNRZ/Ku1GJ7CJGgEtHlaAYkkpSIssg1PlKAMHmolmTVZvAIH/MyS8pM9VWSNAy5BUAo2leWrEfPCHFgXlmu7e7y+NEJT88v2ATB80XDV38qMa9rPnnvOQc7exzc2qFvGw4mJWbZEstz+lKwurBYO0FGwVtf+CqLpwd88N2vExrN0C259uqbXJ2t6O4nmvYMSb6PKJ1QqUALgdYjhAjIWKClQxhFCBqZxiQVKbXBYnnwT79D/eYhO+8eMETJs4uWzsMHd59x62hKlJBUx82/+yahcDz4tWOqUPHGzh2Oyn1m1RWEMDTOIZxCRo+LHiXzQwUhkCpilEHqEo0kyUSK+bMoosCrQIifbfLuk8SFwEh4qknBOgoGBDuVxMSepvWMJFTjklWbWBcWmSKTYcAkQeclUiV6AtNKssGgvCAqSyVdPkh6KKzC9A4zEwQRmN2U1FVPSpKi0KzayNVDgyUQhUF1nkon8ImJclRjQTkoxEQidaLvHMql3HkrAp0TCCx7Y+i8xLnA4BXReaI07FYSLyRKJc7W4IPmMkYQKufKCkmMkqQic5s4nGsu14LNeU8h4LKJjMvApC6pVFZbhet52lhmymNlPpg3lLi2ZzbRiCLHV07OIm/cBNPBpons1pJmgKQL7p8prs09i7WjEI42ZAda7z2FEQxNImpNXQSWTuI2PUFIJtPEyaJlVBrEkFBJM68FMiaqkDiawPPLAW0kdRlJLmBtgdCKxdohXGA5aGZVwqiI6wK60GgDndPYyrLxJbpwXF4OWDQ6KSZzgUqgVp4gJcZGGh+pRKTv8yCidR5Q65GiKhIy5kVE7wRiFbgyK9g5GDEalwxDzMp1MzC0A95JdFlTuAFvwLyw1g6CZkishgzw1CLhAe/JVlcNK5+t7S6BSX/+ydu7vEjWhcwdv9JjbIG2NePRAX7oaTYrfHCkkOMeWuktEE1B8hCzoygEjxcea0fEsO3ZjaClZbN6RiKRyLnjshhlIrSUiORJMW5rSgEE63Vg0yTWnaMoR9x9dEpdjVj4gfOnJ4zLjvOvfx1PyY3DGUbc5vvf+l12JmNS6okUpJABnzuHNzg5vqB3kTQaEbRhSA2IxP1PP6b83NtcnC15df+IxfkzlsszYt8wHk3YuXab00++iyJwOB+RYoMpNLt7u2zWHV23YtX0LPvEo8UGW1mEMIghuzDV9iGhtCSSuLw8o+/WaK1pXI9IHm1KBJGDw2tIo9jdv8KdV1/jxmtf4nvf/SYRwRAlqcngp6qeUBYV1XjObDrJ+fyk0LbEVDWF0dy/9zGb9RnBb7KzUwsKa9l0PVJElFD5Z6hy73UKnhCHvPwgorWgC5nSLmXCygytne3uctae4oYe6JjP9ml9i4qJZXOJljDbnTP0DkGHJ7BoFjlapwUq5LOyNZYowBjF2NqczS5LCg1VYdEq18jOZgcslyvG9ZTF+hirA0dX3+X07AmjvevIpEEKNs0p2lhG1YSbt65/pufE/sGMwTmk1Kw3PUpCVUikNpmfobbnSynYmVRcbDa4Tc9kXGGsYndWsbNTMJvOqSY7XFw8o7k45+DoGsve8fzJI/ymQyrohxaBpGnWaFvSlAYdG9aLY6IraM4fc352zje/+31+/xvfom16SIKnp0sK8xrBRHYKwSs3SuYjyd68YndWMZuW9G3Ld957xpAKCm2w84K60ggUxkamCpSyDAikZCvwwWS+z/PnT7jcrDm/WLC7d8gwbHj88ftIIXnj7S9QjQuizDnsoW+IPvDxhx8xLFf52ZAU48oSjUXgIfUYaxnXZW54ciHfR2zC+cjJ82c83dnlxs1rbDYtCrZwKEUShriNkLqupWvWIAUxWoI2pFhm90zKs4H3DoFHa7l1EefKOxK5IQoIoadt2rw4LUcMnWO1uURKSVmOaNqG89MTNs2KlAp+8N4PttFe8DGCkBijGBWS3kVa79nbG7FaNyyS4HC3xgOrRYcxgem0QheCUpUMXeDk5JJ6VKJKQ3AOK1V27cqEkBZl8uzj3EDX5B71srQomasdg/N0/UBdW7TSLFYt090x9WiECz2JRFXVmKLK0cIY6F5sH/491489eH/rhz8CU/Kr//Sf89bbb/NLv/w3GFWZ6p1e2BbENvOi8otQKoMhtLLE6FivVmitKWyuPXjRxyeExDmPEO5lfhjYZqsz7EvoDOdSUmK0oR8cw5B7Z31KTKe7hKHbqrKSYQhsmo6irKit5fLigj/8xu/w0fvv8bm33uLv/v3/grfe+jylLV9WjeXhMeeWtc51YrPZjOVyydC4lx1xYQtEyaCilqbbsNms+cH3v89kOuHNq1/ICrIb/vTPkzmFFWOuNtBaZ2qzD4StgidlLnMnZXu5ZDt8pphz4VsaqpSKGLcUQ1Wwe3CNiGA6nmYSeFEQvAcBd978Aj/6xjd58tHHzI72WcUVUkgm0zHD4F4Oz0VRMR5PX+bwnXNsmmZbdZZtXULm+gDvm5eq+ItowJ99v/V9n03gMlvdYopcLhbEGJlPJ4Tg6fsB2ELRkPRDpB9CzkoohTa52zEEEOS+cikVpjScX1yyXLYUhaHrE2mb89nbO+Lo6BbHp6fcu/+A07MLDo+uUo1KRNpSsrd0SxK4IfBZLqGzA2HoO/p+g7IVZlYwKio2KqGGM7RM7O3OGE2POLo24ZP3Wob+km9975s8vv8R48kc1y44OX6O31zS+R7bWYIw7BzscrCzj6k7euep5m/Tu3Pufu+7zOZ7zPavEKNk4w1/9N3vstks+cEP3+OH3/8O7775Ll/9yZ/EELjcnPH07JS3bt7mp995kz/85g9Zr3r+08Ov8H9+9W9ydTIjxIBfrhkW5/SrJcOmxYUuU06V3eYQLZIMtTMqdyEaLUnRonVCyhJpDVJLiBFRWEShEQRElCQ/5Oq3BNH3yFCQfERGlYduPNgXG96YYYL5byTFSNhmvaQyuVuenPcX2hBSoi1aPvTf4ezBMaaytGHF+mJBrSVzK5BNz1BkQNNlbKmmJZNZxTD0/O1f+AWePXnOB/fucm1nn7Nmxf3lQ2azGcO6YBwdT+4/R3vD/fcf4J5vuPf8Q67M5rTvewoUGkkpLUqqbOMWNZGAEFWGJVKShEJLSFJjRELpghg0i4ue9//73+cr//f/NaouGdlcPXXjzj7Xrk15+njBbm0gCt79e59n98aUi1/9AdOhJsZIMyzogkPrglqNc7wnSaRQSBJJJEpVIFWRibpSAgpiQBG34ElDFJ/tM3F84TmYW+5Ugoc9TGvNuotMlOPRKlFWmkiijYrLpFBOkZyjjQFlJEbnZVsFCO+pTcHSKQrpOO4j13YEPkVmpaQxlqsTjwuwWmR30a15JEnYGwmaZiAokEZQGIEP0G4XnXUlKEYqMydSRJcwnUSOe4toNTYFmhBpW0GhHYU1lAZIhmkFbQeVcFRa0kfJtBaEZDlbB6IqqMqALgQCjdq+50dCEETJaQvzKiJT5HIY8EEiU2Q9RLRxrKIhXQamdeJgMhCOFD7kto7LdUBEx6ePsrJWIOmEZFIJgg9ok/uKxyMYnGBUwMJZLjYFhR9QlWScPDFkBa7rInYExxuDS4KwiexMstq0uBgoywwZO5wV1KPAtBQkawhrh1KCzcIzO9Ac92CrSFSCrnXUpUDZxOJioJCRpne4XuAJOJ+dZdcqwXfue75wM99PFoOii4qZilx2ktvKklLORAspsWOFKQVdm3iRimibyOO7qzwsVTb3siews5pHjxzrRc/OnsBLgNzvG2MmrEsBYwuKSJ8EMsFkaihaz0gnThL0XhBFpof/ea8XkbMYI7ackFJAxETqWtrgSBHc0BO3Hd+mKBmPx6yXl7h+QKkXec8MLRII3NCjtUZJg0QRYs4JK1OQhoRSETf0OccoFEpootieNRCkoNlsMrcgKotLjmbd4ZXlzXff4pO7n3Lj9ud49uwZ+IazC8flaskn9x8wn04olCCZmlE94tHpPR4+fMjf+nv/JeXudYpSMd/d53d/+3c5PT7m5s2rbDYrPvfu55nPp6zXa1zfc3G+ZHV5Qaktm5BYDj2hOWY+m7L/ytsMzx5z5+3reBH47ve+iz9dIDvHF9+5ymULP/jBPZAZVta5Hn9+ihAZHofIUUGlBWCRRjOdTJns7rK6PEeZ3Cl/dnlO7wO7u7scHEwRMSFsBRh677PFO3ic66hGFTeu7LDqJYvVAlsUyFRB1KzbFuc8A5G6rgl+IMmITRYjYTyqOdq/ysMnT+i6FX0Y6OOQo4dshQwS1khInpGd0vpzqukUrSSvHFxnPL9FXY4h9ay7luPzY/pNFouqQrPa9Ft3SIFDMARHXY6pKsP+zhEiBbquxw8dRiaOrr3C8cljbl9/nXhnQgoD5exVHj/9ETf299jdu8n9T98n+vPc791dIHXFYnnGyenTz/SceOeNI9rBcb7s8UIwOLh+7ZDbr7/G6uKY6FdoU5CiZ1waAvvE4JFCEVWBcH12QhlFs3rOSEdG+3Ncv0R6x6wS9CiqyYTnp5F5pdFW4fqBG0djPv9aRbn5kOf3n/DxvWf86NMzHj45wSSPrRRCCPYnBXv7exw3l1ydGkZaURjNuBozHRtWK8fvfOsRjxYJZQXVeMp4VFJXJVEkKq2oKpuFuqTQWiCTxPUb1hfPSa7fimuavSu3WTcLTs8WPHn0jHr8jFuvVMiYQGiEqnn6+COe3L+PkxopFFOj0AZm45IoJJOqyBl4sisobHfoShsSHkLg0/e/y+6kJgromiXVZETYRnhVk8A7hm7D6vIk11QaQ1VPmewegjjYznOSoV2wTA69daqGpDDlCK1tvj85h/MdVV0jhWC1uKDtNhTlCC0tl2ennJ8/R2hDZSf801//ZyzOT1AyQlJIAWHrelLaMKuh3URamTi4cp3z83OenTdc2Zsy2x2zbnpOzjbUVrKzWxNtm+sPtWIzOJCC1WZAtIGqMKTkt66hzM3QVlGWBUpI+t5zcbHClgZTlsgoaNuO+bQmuchytcYUkyx8qvwgEsogoiSGH+/89GMP3vefXSC1JibNH33zW5yvWv6b/+a/4saVI7TWeZBMCa23VVQJpMzWaSGgqmsmU83Q5wdG7msb2JmNSVXA+VwXBWTVWcps0dli6dM2pp+3JSVdd4n3fmsNl4QIpS1Ydy1KaabzXcbTGSEmFhen/PNf/SeM6ppf/KW/xTtf+AnG4wlD3yO12qrqattjrbfDbbaZn51fEEloY6jrmrZtAUUMjmdPHjEMGdKmteLs7Izzs3PG4zllXdO2m23+Ifxb/W7eDXmIiBHveoLPnYqQcvY1CWLIOb6UElGqvK0WGlNUlKMxypY0TcfO7h5CZgv5dJKH2uh9ziEJyfU7r3Fw8yr33v8hn//aX0TJbHvqX3SnK8Wq3RAi2651t30ICNq23ValiazkTsaoUtD1XX6YK/WSWKi0IW7JhiFE2qZhPB5lO5p3tG2XOw69pyhKdnZ3OL24YOgd601Lt61kU9tqspQy/EiQazLYquSr9YblqkGrMoPtnCeFiNSKnYMrDINj6jyXZ+c8e3ZMXU8wJqsHIUZMkW2jSmSHxGe5Ut4SoJRmtb6gFw17ap+dsmJtFOPxgCmnXDJm9/o+zeWSp08fcnlxj6ePHvD08V1SEizOT7h6eMRf+4tfZRE6Pr77mMVqidAjJvMb+MUTWr/k8fFTZgc30WZGjJLzswWjyZznzx5wdn6a6b5acXx6jg/fBy25s7/HzTu3ee/7H+CaFUfzPW7t7fKOucp/e+dvcGU8IbQNw7qhX6xwzRLft5mkKRNJ5iyZQG0BexGTJEpYtMm1f1iD0BqlLGiL1InkBWprj0vSkuIKH1qUMwgi0XmEd0gjQYHUFqJCKEdyAykmvGtRukDJDOpLUaDMlkbJQHRki5OC4Aa+077PDzcPGBWRdHbGeXuJJrFbGY5mE+qypKp3cdagRxbhDbosOL644MOP7nJxccbh/i5War742heIJmG0QfmW7377B9Q4Pv7kKeNzuCV3cQ/WLEuoVUFtSgpdUuoCqyZYpRFi262ZMoxLaIPEkkIgqWxFj8kgNZRp4ONv/5D7X7/Naz//eSZGIV3iL375DqenPUtOCLpGxIYgEm987RWWxVWe/sof0PYd0fXYOJDimFCUJDTGJIT0yGRAy7z8SwmhtgyO2BOkJCRJJIAy8Bn7WSeVoBsiH3iNlZFh03GlhrMe5hOJTJlnMQyOGR3rHsaFRKGwgFSCUjnoMrDF0iKkIjS5nmeDZhUFtRcI6XlymRgZwajUpBCxlaBzmnUbkMoTUramz4rIWTvgAJkUq01unxDSZDbFkKt4yjIxMZJCBYyPHNaSNlqSETkrGQLLZaJMkagVax/Yqz0yKvohslNpqiJR6ISxknWfKM32e2w1pRIcHlrO1pEiefpg6EOi3HaLrgZQWjC2Bcak7eLT07YSqTyzGs6avOg00rERmsonBmMRCWqgafNCmwjLPmDLgA2CWCju7CRS0uiYWKwSjSwYV4mZzHGoTZMbJjZdjzWKbjlgEJjZmFEccIPHbTpGVmJtoO0ll2uXoTM2q2uDiiyHiF30aARDMniRmJSR3nt2RH6PXKwiR1PoWzhferwuOJhKlkkwigN+IL8vs12M8aRiMlKo6ClchiXFKLAlnD9bIwvBqzd3GZwnuAGVAtIkVuuBFAPrXtAP+e8efAaSGZXQGnQSuJg46Q3GDLmaCYHzZJX4M9D+Y4gkEYgorLB4H+EFcNV5hFTb001e1NRFTTUqaPoChpCrvqJDKpPVUpl/vrkhJeFTylWagB86chTMIMhniKIoaLouu/qUgpDofa5cPRiNCUFxfHKOsBHnGh7efwhKcbZ4xMXFghASF8sL3OBISPrBU88K1psVxJbVsmcjEv/6N/41b73zE1y9fotPP73HenXBaFRx5fpNhq5B6UxPnu8fsF5vUJdLUkpsho7i8BbzvZvs7OyQ/EA/9HTes3z2MWfLJYuzM4TU2KriclA8enqCqQqq0Yi+d5RVibIVTbNk8C1+20cdRdxmZxXCFIxm+/QuElzHpmm5WtS0myVCRvDZuSmVxVpL1AXTyQxRWFbLHq0ki82ay3bg2aO72VpeFOh6wpXD21STOdduvkEYlgxJ0q6WXJ4+QWnD6f0f8cmDT1AysLe/Q5cUz0/uU0uD9wkjFFpKXOs56Z8gSVR1iU4G5weWqwtG1YyByPWjW0yk4fn5Y+pJgbGKrukwTiFEiUsOBaRk8L7FFgVlEZmNEiJVPD7uefzslE2/hhT59g/PQFpAMh2PqEd73H18j03n8N0icwhskQW04JlPJ3TtZ3NGmcJgC8lovMOd6wC5IaU7e8hkPGG1lIztltgvBCrliJrSFh/jdnGd7wGm0mhVbCu7NFVVY7UljAMu9Ny5fp3l+pS5mvH653d55+YOeMfdT77NN773iE+frok+IFOirEoE2fm0N59Rj3dIyxUPLjxD77kyjcyPRrx3/4wnZ47i8HVeuRJzzKccU1iLtQmrLRKRYyNDnxlPMtG3Pdoa1JDvryEEzs6WvBEjMkQePjzh8dNjzi7XXL9xh/HuHntHN3j08AEff/whwggqaaiLEqkl1lrKKp/1y1FNEok4eHqfnTNW54huqS1D73Bty+/8m9/m7bc+x/1797j56k2u3riKlCUxes5OnjKqRtjCsEy51teYMbfLCm3LPDNotRU9wDcbpEgkJH5xSUoesaWjF0XJ6nJB2yyREsrRPDtmu1OGfqAoLYmC97/9fb7/nW9SVRbnB4QIuABaw3hUbs97kslY0/p8P7yyW7FaB56frtnbGbE7GRPryGqzYbluScFTjUqUNcy0QSpwvctSjhRYUxHZxmOFoFk3BBdZNi1IQT0dMa4L1uctq7Zl93DEMDiCUuzN5vhBoTRIVWb2FIKgNdL/R854r5seRI82FqUsdz/+iH/8T/4p/9v/+r9mVJUYo7cQMoF3DmV0hnX1A3v7e1npVTIrpltLdbFVt0JM1FWN3vZpd90FwSUkCSVz4bpSOtcuhUjXddiipCgEWuuci7aGFLJimmLYLgIUse+p6xG/8Nd/mcPDI3b397cqK0ynUwbnGAbH7t6cZtNwenqBlPkh+6f91nkYbZo2K8Qp9wunrqFfL9mfjlhWC4KQTGdzxpMZIJhO7dZ6nb833jtG43Gmg69X9H1H02zo2oa0BX/YskJsbfMxRYIPuQZACIwtMLZAaUNZVvR9fu1am+2wGhmNapo2dxGG5KjqCddffYMf/v6fsLlYMLt6kG37KivW1uZYQNf1xJS/byGEDHsRUFUlWuUBQmvNMAzZuugGBOQqku3rE0Juh1nx0q4+DH2mripJDBm60PcdSWRlnJjj7XVhM/QlQecd3sVMdJcK593LTVLfO6bTMSkaUop0w0Cz2VDWJUZqUImqqEjzHW7cvIWyin7otxYWQfJbS7yW2234n/8SEaQ1mFqB6jlfP6NbRkZ7twml5GB/l1MSh6MditLCfMzX/spf4/Likm79nIeffo+njx8z1pLXb7zGrStHfHz8hCfPL4m+Y1SMKOqKneJVKE756KNPcHLK5979yUwO1wqB48033uZyfcH5yVM+ffApJydLbDnm9PlD+mbDX731c/j+OzlHXY54Ne7xX9z8ea7vHhG6jm6xoF+tcf2KkCJDHAgSvCyxIhIlFEphVe6ql8Jgtl3cwsjMVFAmfz90gbQG7Ha4U5lRILxCRAU+EIQnOYdyjmQKZG3ym0DFTKQWihQCeIipz/eVQmIqjTAFoe8RwpJSDwJi15IUvL/5lPvhnFnhmY40Vlpu3TzgtevvclTeYf0w0AXH9J0DmrLjbLmkGTpme7epHz/g1eu3iXGNCoqQGqZphk5gQ80Xdme898EJ0+PEq2qPo2LGfjGnkGNGtsRqRaV3KESBkhGjsvVKkrPpmbKqEElke4aQkBTIrEykoJG94Pv/8F9x9M51/Ljmou8olWY6qhE3jtB+QEZIybP0nvFXrrD8nw2sWqzJ3IsgHM63WF2SsMiYAYYqQXrRrxkKYgKlAZe2S73MY9CfUfGuVF6aKF0QB0dRa043gnEJfuMZoqcuNYUOVNv3lEo+56y0ous9odA4kRDCUhKQImAKhRcwXHQoFdm4hB88o1Jgu4gvFW7RMyxBT0pGtabtsw0OEXh2HlAkSp1IIXGxBITHGGgdpOg5mAjqMuGGQGUll63lsoF1n0eYeaUoa01dSYITCBGopOBkJRn1jmLXMrQRXGS9DhQmoEYFba/YnyUuWmhJzFLHqKq5PPcUNlIahQsxLwmQTGuJ9ZGIpcKhSskmGqzKLghVg04OJTRHE0U1snmoInKx9HQbaBLMK8O0MjRNxBRwVAVCE8BIeidYBslsAs+e95S1oneSoz1D1wjqImbVBIuxEtc4VKkZjfOSW3jH6nzAGEXrFM1moJWJ2U5BGDxIRZSZlL/qBEFE2j7wrfuJW3O4NpHsTAz3n3lWLjAbFYxHkdk4c196Mo+BmDLXAYEUCdfn+jKhBDYJohTUE8Nsljtdg5xx583XOH224OmZw3SwuNxQTyyV7hEB0AKlEu0AnUts8rcEpQU/ut/waCn4uTfBReh8HsA/C9Y8EHP07EXNpcqVbkJqJtMJl5cXJLK9XCBYbzZEEehXDSkKEAlty5cgtcHnmJsUmZOSRYIc+Qlxq54m8L4nhsBqGDKN2FRUZU3fNSQx8Nb1mwx95PTsEqPGBGacnl3SDR7Xd9w/uUDrghQDQ+8Zj0YEH1m1a9p+k5tWFjkatre7y4d3P+b9j97nK1/9Kd5658tcv3UdbUpaN1CMZmyanseP30ep/PPc2dnbZtNLZrN9LhYnTOspH/zgW1SjMdd2LM+OF/g0cHRtl/N1w3ItefLsDI+gns9ou4FIwhGROmHqAi8GSlnQO0c7eHQUSGUYTTSb9SVlWXG6POfq4SFJgLbZldK5zLNJ5AhVWY9zzSni/8vaf/zclqVpfthv2e2O+9z14U36rKws05WFbrKoUlvKNSCQPSA4kjSVRhppon9AgCDDgaSBSEoEJy2yIYkNNct3dZev9JmRkWFvXPvZ47ZZVoN17s0W1BQCHdoI4CK+G3G+ffbZZ6/1vu/z/B7a5QKhNU/PHxJCzyuvHGG7E9AVs9V9qqphfuttXDZcPf4ptcosHpxxfHLGxc0VbnfNfv2EFDKLZoYWdRm6TFuEFmWNIBIAqyRWVggKkC9mjzEdu2ED/Z5ucczH558Sww1ZpqJE0w3kCaVAZAUoYoq0RhNF4tHFBR893OOCZ9w7yJ7G2qIe6uZ87d1fpe5u8/z6Gfv+Ep8WpOERymZOlitsdQRxT1SK9c01/eS+0DrRj4lKZCIDWZSEH1NBUoEUembzGnLCh4w2FHAxmbFf03QNbopkqwtsF4HShk5qsk34nFGqUM/9ZNFacmt5n7vHDbeWFTeX5/z80RU/f3ZDxLDoDD7WkEtC0aypmc0qXr+1RKTM2dERb335DZqqQqTIqCu2ouPs1ZaTs1soqQ5KhWJNEaLYIn1OBB+YZMLkTI6RYBQ+JZS1dKqAEq+vnrM5/5Cb9Yaryysqo4oaNcGtO/ep2jmXV+cM+w1tZctQsq2Liq2rMLpimgbmWlBVLTs5YocRW5chk/OlqRxzYsoSpUcevvcDHq8nnlxvuf/4Ob/0ja+zXM1ZX24Y65HlaoGyGj/tIW+oH84Yt1c03QJdGaq6QSuDNhZdddh6hlSK4EfcNJBiKlFo0ZV6L0tSv8eYBlsv8HFNJvP444/5g9/9r5jNFKaas9/1+BCKlSUJDnh/cgIMtFaR/J71EKiNwc4tU0gM655FV7GYd4QcSMEwjp5+LBZoKQRKFvX1fj+QO0VOEAZHCIHNMKK1oW5NgfCFyM16ZBwm2k7TDw6pLCerI8I4oesOYwrPS6sylUdWME6f6/7/3IV3ZXXJ07MWQQYR+PmPv89/9B/97/m7f+/v8+1f+uZBGp7RRtE2FcFPBOdfxodtN9tDoVyEjcF7xrHQzavKoFXm0acf4PcbRH2EUUuqtiKMCX9YUECg6+ogy37hx05458g5U5kSyVByfxWma0hNRdvNS4SZNlijESIxDH2hoBvFdrtn6PtClD1M3qvKlqJel2m4sQbISFsz7i2VNRw3Df1iznrW0Jzc58vf/BbWNgdCpT/A0yIpg9amdGerqkzjb2CxrFkdnxJDIPiAVIquK8X5fr/He1/ywA/TaQB5WKDrugDOhJC0TU1dV9y7d4fNbsfTJ+e4qZDLXn33K/z0z/6Sxx98yOL2KSlGQk4vs8wXiwVN49ntdoyjK54ppTG2+ldACZl+3yPkC8gbL1UBMRYPW/DFq6uUQkqIh4ZFATIUCW4mEULk+npDSC9iBsoGLrhAjIGn5xf8/GcfYVTF1775dZLIL+mIKWXaui0ghBBQqqU+WABSiBgtsZXl+PgIpCgNAiWxqkwJXnj348Fa8EUOoWR5+LdNkdSz5/H6E5pes3taMUTJNGsJfs3ufCLuJSe3F7z2zmu47ZxX791BhAEzeYiwd1vOt3tkjNy9fcpi0XCzG7h75xW2+4GbzQ2q3nD/rTcherQUZJEwQvLgzm3Ojt9kefQKnz36gPPLHjl/HYnmr7/3PhfnG56ZSy5/9hn/vdWv86Wz18luYLfZ4ccd3u0ZY8ILVfKFRI2RoJWl0gotCkDN2hphJBKFrCwIhRABZVpElMWHqiU5lutciCICVPHWUBVfnshFyaJTJEcNMR7uKUESCeIIsfjiRN1AVoXomkFqQ548QkIYB3LwTCky7+FIdbxxd84rr97htZM3WdlXSesG/8EG/8GaVDc8v9kz+/qCuZkRLh5xff6EeaqoOsPy9A1sq7GmwjQ1Qhr8xcRf/PHHHH+S+er8LU6rFXNzRGVaallTyZLsoJXEHt6nTJKkJSILZLaUilmisiobxRjRovzcuZ6c9tiUCB9vCf/8Eeq33iU7wfnVxzx44xWOFx1SWNJQsen3CDUixJ7Tf+stPvy/vsfCzookN4/E2JGFB2nIQhV/YZJkUdQBUk+kYIqflAxSEWJCqrKB+SLHat6gY+bZLuGGTIrjIT5L8PFF5qu3BS4FclAkpZmGCSEktzpNiI7oSqHdxEBtPL2TZKXQDez3nug9rYJVa2iOFNqUyfq4Gem1ZQgJtYuIPOFjQgrYBIkQhUy+R6ON4OgMalXo5T5lYijJCjeDYF4ZhLZUOmF15mwlaWzx5m/XiSRlmWrYklhxb6bwSVOpiBslY8rskmK4ytwJHjHXXK0TXReQ2tBPAkSgmwFJoHPAKoHOGTnPpJxxQqLEHrRgnASNjgiRcQ5qm2i1wlrNOGamHWid8S7hsmbWCeTo2UeYxsw0Ju7OU4lPGyImRKZk6GaGqjaYaHHrPcsm8OxZxqXI9SZw61hy1GZSVKici/c7RXyqSFoThKYygqOmXAvbaJSXbBNUUjKlyH6ErfMcN4l5J/j6qwY3BNoKoi+RLVrA4ALRGuIU0L1nedYwDf2BCVOsQUJlbCUYQyrNkiywi47/zv/if8ntu6e4Z99j88nPsFVF0x3jnOCH33sfkSOX1z2VSFRa4BzMhGBmYJcPEd0ik4LgnVOYMlgJVmW2vjzC0hegq0khSelFmkjk5Pgul9eXJBKb7eblOprhEIEpWF+tEULh/EhTNdiqY+i3RelgamIq0yjvizXM6BKfmXOJH9JSFZCQfrGGl5/3+7LhzSlwfX1O8I6UJiqbiTFxOvfYeoULNTHAdufph4GMQeuaYVLUaJASQ2m4RzeS/USrBevdhp+//x6X10WKbUxNW9f82m/8Bsl7xuGGi+fPCSlhq5q7r77Bl8++Qt005CvDBx98AH7k4unPmXbPuHVnyTv3vswURn7n974LKiFSZL29KgkmUPLEc+Tqeo0xqZCtdbHEaW2wVUs7X6GF4ebmMY1tOF52uDTw4c/+GpECq9UxuVui6goXFcZU5EM6xcNH7+HSnhihtpquachS0jYdQ3Dc3HyIjwL7/EOEgLabYesjri4+QSaP3zyibeH20X2224lsW+6sTlisznj46fdIQywecQmVVKBE4Sdk0NZy3M45e/AON1dPMbbm5x//OVXdFBp+HEkpEPwaayxCZCpdEXMq9gNZojqFKPGZIQs2Yo3IluNbx2yu10giHz/+MWdHW45XDxj9SB62LGYLdtuJzf6GOmaIE7aqsAYq/cX2TvOmrE1aaGIuk0erJVvfH/zvpljQRGYKDqslptKQFce332Hye/aba7qmY31zTU4KHz1SKppKkb1ApEAz72grQyUUlfU8e/acjx494tE6kkSFjwGfJDEkTk7mNF3DctHRysT95ZKmrrl5/imv3z5mmjxNM8e0Fe3qhKPVKUaDG4fSlzvUJzlFRIKsYRwnWlsgddtxxGRNzj1NrQi+MJ/mdeT1+6f87sefMl/N8d4hyQzDFaFf8/HP3+cv/uif0RpJVddIrbBNTWMMVVuiVpPr8ClhuwWni1O2V49Lk8AfopoRSK1YNoY0eS4nT9XNiCnz8NEFnz39A7quxY0DZ4uKd955jeVqiRQRbWsunj1l2m9YHK1YnNxF67L3swd4rvcOQhm+2XqOUkXdPI0D2pZGlhLmUNCek/zEzeUF/+yf/j/ppzX1rKJB0s5b+t2Otm3YbXeHlCIwlcWPL+qJMozcDJ62tSxnpsRcT4lpDBgrqGtTYNXAMCZGX2CSUo70Y2Szm6gbTaVU4SrMO2KIDDt3SJxKtPOO7tZtNrtrFk2x7262GxaLZbFKVhUixyKxVzUiA+bzSQY/d+H99t0jjlcL6tpyvfeoZsab736Fb37z29y+c48YA+NYulJNU5UIDqVZrlZFS59zQfYHX4q4fk+M8QCBMLhph4wO7a/43p//Pu89XGO7U37513+d1958txTRxmBNyaCepungLy8y8WkcS7yUgLqyRYbOwSceIzH6w/nBKGG7WzONjuXqiIK/L5t+snhJMJ0m9/J3phSJoUBLpFQoa4vJ/ulnNG7g3tExr//qr/PK669jrEJryTgOyOxZzDq2vStynpzwwaNUhdYGIWQBj8mJxaJmGEZSyqxWqwJbO0jtxcF3Lg5esSLxLp7IqqrLg8taVqsV1zc3xU8iKryfOL3/Cif3z/jgh9/jnV/5FlJZUoK+71FKFT/3fn+QjpcpszxMw0uxGwrkLIaSRZ6K67oUuiXHz/lIP4xY+4t4seqQF14m36EQ2UPZHKRcio/BTfhxxG9GHn76MT/63vd5+OkTvvzVb/Abv/mbpbiaCvpfiIyIBUwjjcT7Q4xanhApgYRMQObAMOwZ9w6ha0yWNIt5kfMLUKo8hKL/N59iQJGaC60wlWU2n6M3Hfv9J6w/S9T6PkNUfMrH/OzZp4y+5rVXH/DxBwNVW3E8W/Kld24VpYGbWF/eILQmDD2bvePB/dssV7d4/vwx6+YWSlXstpd89vF/jcx/ly+98yaz2QySZ3P5jPWTRyhlUdueN5dv8mpnwUtk8lw/P+cN/RavPW75lXSX+7dXxGHPsOnxo2OMe3z2BCGRSqKlRWJpTIW15aFmtCrAE1Mk5cJUxXuUFUIFsPrw/VEHQJWCVOK0ZJBEY5Cm8BeyBFmXAi/liAwBUdvyfU6H6BtTitQsSySdCL5sYLMkZQ+xZLGSIzF5KjT/8PS/RW4L0I2+In82EsZAYkPaw1K3pAjXH27ZP3lOPzn64Zpq6JF4nNlxaSeizay++jqLWxW7857xrz7kremM7vYDatVQSX1oRlRoRElu0DWCAkAUKiNzJsWyoZaaA5VdQioKARGAGMkIFDUy7Thtl6zmb9L9pWJ9dU7+dsXJgxVKKNabnpOTFjG3pKEvXuOTI27/WstP/vEfMaY9S7NEiQUylwSBnAM+gZZlA5OYyNTIkBDCkQ4JBYniMSZbovhiWvPdzYTOmSOrEMfFyysn0AvLV0xGMZGS5GYs9NQ7x5IpZ56v91SLmhFPKzLJNGziRNfA1c1A9ok7KvKsU7Sdxo4BW0n6PnC5dsybQJUTtYyMIaFzCWTeukIJsLVipiW1iQwRRpcRnaK2grmqGMeAoUJqVfKCZ4ooPVJE2krhJ8Fu4/G7xJgU64uMqCXWBPTCICNcR1GUHEpx61ijHxg220SVAgHFsM+cHIHTiplODEGycYKmFlQ5Q1Z4JMlFjAEjFNuhNEdSTnS2kMJPVxadQaRM3QmGwdP7UvwfVYHdEOlmBhMEuyFy7yixWtZ4H3jvecJ7ybtvCPZbhxo9DZJHo6IykciISpl5kzi/gDyLzBtJQjKbSbabQJa50N0lXN1IqlrQGEWeRgKGrgZBQsqK3TDRdYLBgZs8K1N85TFrLtcT984MT57tcbLj7aPAdhMIACIwuYC1Ep8FOQsyAmMkWx+JWdAYWC4zZnhM5SCmMun96fd/RBaKcXQ0reH5taAfM1cRjlWiMQCC0ZfoyiwlyMyUMyczxbcsZeNlYF8U2gcm8b/hcQguKaqXxNPzpyXBQyvIh6zmnLGmJsby/QvBHaSrNT5O+J0np4yt2gM/p+wl4BAZVpJMMbamrRucH0pjWUqMqQ754SCUYXJToSWnSCJjTI0XJZd5NqsxVU2THVoZ7typGab+AGrLXK574jQxOIeboKoNOVmePvwYHyK2suw352w3N2Rh+Pav/DrBDzjneOXBK/z8A88QLrl//z5HR2es1xt22z1nJ6e0bcUbr7/Jp58pfvqz93j69AnLq+f0f/keuqnQVcdrrx9xdfWUftiSybjJkdMeKSLRj4xjiX3txx1VtWB1fIog0/drPrz+jDfuHHHr+B7Hpw8w7ZzNbktODokkqor1eo+pJYPz7PsbsJbq6JSzo6+ilWW73TKtP8VvHEE7bt97jXHcMbeS0fXE/ord1Rq3fo5AcLO5YppGko/s1gMQOWpWfPjB9zFVBWGgNhZjFMd3XqOfwE9rpCzKprNbr/D86hyzvuTu699ks7lgYQT9/py6UrhQ4/2OZbPAdDU3u+EALZNYZamqgcpK/CTZO0dOgSgiVinc3nO8OKJtW6aYGffP+dLb3wSludi0XHz6Q4Qw+ORR0UHI9OM13eyEWffFGrS/4P8UFYcU4PyEyg6lBUoFIpacAuaQDCRzpGs0m6vHbLc9R6sVVxdXSHVQDUlNpS21cCAiymoUAr/eopqam92eT84HfJqhjWNwE6uT2xydHpFcz2tnxyy6jtqa0gjykefba350vuHeg1exbWLc99w6voepaoSAse9Rsih5hSr7p6EfCrguBxqtubpeUzdLoqwIakKJksSSrWAKiVpJajvHWENbK+SsRUSBzh63fcy/+MP/F8mN1F2HshapDatFS902tF3xVXvn6McBCTg3HJhVZc+ulCElR6UFKEvWhlYHRO+ZvCOKkj7i1zusiEzbifd/+B6bKHnrzfsMmzVvfOnLnHz9l5gf3WV+fIeqXqCUJnhH8ANCjGXvqEsCTUoDbtwRQ8RULSFmpuGGvt+RyIR+4Lt/8ddsd1dUjSanwq5qhGDZdYScubq6wk0DqMw4FJWPC4mZ+sUAUyK4uNrTNDVtUzHr2sMQMDJNkWmcEErSzFr6rcP5cp6NNVRGkWIqIM6YkSrTNZbgIz4pxtGT9BqjLcMoqNsGJRM+JLrFnMoUPpUSmnxI6qrq6nPd/5+78P4P/4d/m8VywYefPuPKV7zztV/m/v375UM9xF7EWArs3XbP0A8UPNgvct1eFLRCSNzk+OM/+n222zWLWcvRvOGjj37Ohx99yhQkUhkqveGn73/A3/yt3+Y73/kNlBQ4lxGhTM2ttYes6EjbtZTlsfix0zBgTFXOCVG8mlrTdcWnbW2D0TXeORCyFLWUL3hdVSXLO2XkITrM+yJJSDlhjESoiu7oDBd+yHFV8+BXvsNbv/63qKqGnPOBKlo+xO1+xEdBluHQ/U4FfkYBr+TEgSauXvrIt9tdKVBTaWBYqwkhMk7+4EtQpcBVBTompUYIePLkCdNY4iKkFSS/o9GB2w/u8LM/fY/d1TWns3skEinFg/R7Ypo8UsmXNPoYIvGwkMrD5+e9J+cylceXpkRdW3bbYilQ2hREv5QIIRFSYZQgRk9KgX6YcM6z2665WV+z7yc+e/yEzz75mE8//pTr6zUnJ3f4t3/7H/DqG6+hbZHcpATeeypboA5aZZKzDOMIIhFDz7Tfs93uuLh4xsXFE67OH9OYI/7mb/8DpITBTYRDJBll4MTkvqCh1SWyFdBUVM0Ri3qBHDL74Rm+X5FPW4yEe/fOcHnOfnfJZ5+9zzDs+NIb7/Dejwbq2nBrFvnw/Z9QyzljcjBGthtPN7/Noh+I/Yb15Wckn+g3z/jRX/4OWgleu/sKy66h9S0PEOiLHXN3h9ZZTpoVlW7RUmDPMnNhMT6iholxfcO039JPkYEdLgu0ajEqYaWmVgara7SqUVWJw5HaAgLZVOWzzaZkk8oMxiKFRqiDV5gSM5RyABJoVSAhnSRNAVlVZB0Kpf4Qs0cAoRSCWPxQpiJLXbxEB5p9lqp08KdEkrkU3yKilMHHjKxqZN2gtpH4fI20FpUiMoKyghQ0Uks0TQF32JZ9bgn6mADEEA7qikx4X9I8GzmuOqR9m7opGY1CyPJ6WhVmgCoTfikUJItREFIs35EYQGaykCQJIqaSYS4SIknIHnJEy0ynWmam486dWyjTUr2/5en7f8Xb//PfwI2Zi/Wa9bTntdu3aKSlbTXroPn4aU/12m38+YbWnFCbZcG8GUOOCSUSmfLMUVKShSMEgVAUWb8syQlRCkiBPH0+qdR/07EbdogI80EhVxUVEl1l3HbEowgB6hbuVgmfBH7nsLUm5YCYJoRPRB3ROLLrmVygM4aTpuS1zoTCIrG15OH5hBSZwQtqGRBK07tITBopNZbEvEoECUczQ1tpxmFkyoamlmgRWY8WYyTKSbZKIqJHC804QtNJcjRc9xlVS7pWoWpYLUpW6oSiSZLJeUwjWG8zSid2QbG5GqmzpBIRqSVKKBYmcXETeOYkHZFKZ2ZLgzaG4B0k8DvPvC2S+7rSBAlaCJSEykpqW2Tv5xeewUXu3WmoO0kOsMixgOKy4GaduBkSrx0r5m3DMHiYAg9OLcFalErUEqKGycMvfUmwDwazgQDsLiK37hX/29UYebZW3EkemxSNSFSqbB7PDGypeO+zzOu3YdYI/Ag3Q0DlnnklCELzyXUkhIlmVlMrhfdwsR653HlUFpAmpo1AoUBDZaC2kkxpruYM3if6vlz7mSl53rvNyJOf/HNs/CbPPnyfzdVT+v2azd4zTpKsJCcnHel8ZH3tuKRs+msNPhVndRQlNkxJwetvNvj9yHc/gdoILjaF0Cu+wIDP2O6lauxF2klOEy94bYW7Igg5kmKiaQqcyyePlgatSpasspoYJqQSGF0RYy7PGUrqQ4mv8rhgmaaA9466bg9T8oa6XWBUy3r9jH5YF4jRC7aNVMTk0JUhxh1SV4SYcOMlStVM/ZYkFItWM1UR6yUxlIJ1OTuC4TlZakIo8XWDS3SLBU2jQViePvqYadySs+TOnTt0XUPdNGw3G2xdc3mz5pPPHvHO2++Q0DzfDVzuBrxoSNmTbzzb/RO89weVTD7ESFLo4WSkSJA8KEPTLGmaBUIJ3LRDScfR6ghbHXF0eo/Xv/xNqqbj6vw5jx99yK4fMVpQVZp63vHRD/4YlKZd3sLOjjDdipPVKfOTyA/++MecnZxwduuEerYiSo8YN/jtYyopsfWSyhq23uFSUciMTLRGo3WDyDesVh0pJJb33qQfJ5AKVZ+xVD2TMUi2VHbFzWbDnaMjjDF0yzOE7VBpxbCfM7mJ7eYCF3r6MDHt9whlEQdeg0+OOs+IwaOMpZGSod/T6A5JwvmBadoAK/Zj4MJtUD/6lwwpc3Hx8AD5DYgc0UIimzmhTzjnWC7mX2SZQNczkndorYhJorXAj4kQKXJmLfHTQG01Ux+prUapMqGW2SHSyMXlE7rKYo1ks9/iR0FtNU4V/sF6e42UklVT8XxYs/OSZ9cj0XmOTha0zZy6mzP5yLKVzOvSjPJAbRVWRkIyvPuldxC6xg0TJ6tTlrOG0QfGXYlyq+YNQlliCLRtg8gCYzSZwDQ6Tu69xjQM7Ic9Rkvq4xNiLHnjs3nHK6dLlIbbJyeoZgFKcPH8kuVyToiOKYCsW6q2o20L8GvRtSyWR4RUIJ1GFsXEMA1EF6nq9mXDzwfBMBV7R2GBJdpaQdb4nBA60krJspbYODG6xPOdI2XDT99/TCM8w/RjVrOOVQfb5PGLU6p6Xiyj/Q1+6qnrDlO1Zb8TI94PpCywwSPQ+BjK/scHfvDd7/PRRz8DAd6VysvUCmugaRpM1XFy6w7b7YauKpHJRgiEyQgE+94xhcDp8RHD2NM2c25uLslKQcrUTaaKubCycmY2P2Jtt1xfXTJOgawtYwxUxiKFw2hJip7rvaNSEmMEWhlGF/FxpDrEXAQiq1WFiBFBwti6WGdTomqaz92e/dyF95Ot5Eo23Pv6v8WXlkuapkNJwTC6lzCyF1JzHyIxFa+DVEVuWQrvUgDnlDg6Oubv/P2/zzhMnJ+fc3lxydd/7RX+1t85ZrFYFI9GhuA9m/WWTz/+hDfeeINqNQfkS29ykQuXh/A0Fqqj856cD2Q9/0KeUAjc2+2u+K6lLt4Za3+RP5dLFnghe5d8Ou89KarScc8Ff0JOWG3plsfcBEfXLXn7138T07WkFNhstozjxN27d0G1ZeHOCSF+4R2PMSJk6bhYa1BWkmMixvRSUp5SxpjyPquqYpomQiznj4AQHdlHjKlQUjFNjv1+j7UWJQVCZppKETdburaidxve/8EPOHv1PiAwpkzGQgjEmA7++emQ5V0KESG6wzUJNE2N847t5obtZkeKkf1+z9XVmrfefYeu6/ChTLi11my3O5SUODfwZ3/6x/zoBz/k6mpNcBMpRa42A3XTcnp6wptvvcuDV9/i1r1XUVriowOvit8iBrQu8WHtvGN9fc44eK5urnn29DHXF5f0+4G6nXFy6x7L4zsM/Z7To9vYpiaS2ey2RZ5yfc1isSQrhfNfTC6VfUKYEmVSdy0n8yOqmxWJHfm04eT1M05m91kLy5ACTWXZrd/mxz/4M7brC2Y20MmW4brn3vyYm8vn7B5ecyIk/tkFYYBl1eKGSBclr5/cZnx6yfEUsO9/gL2IvPXGl1mlGbf0XRrTY0OgXVSokMhOIbUm9o44TYy7K8K4Zzv17MJQoIFK0zYZi6KpZmghsaZCqpKhmaVB1RXKlOklSiFyAaIJrckyF+m3FGQfSrPt4BkuSQe6THRUDX5CWl1yrq0GnxBKUPpziRQyIqZC7E8ls1uaklubTfFLez8iRTrQfSW6MvgpY2Qm6YwNmWglMhYZZBYGpAdpkbUk5kitDQgDaGqlSV4TkEUtIS2yk8QhU83n5F1EHtWo5FCidIyJobwuEzkFdPXCjycQwmCzIMQBaUsTTqCRuTTupM7kXIHYI0xCBo02gWW1oJnPMfOj0tiImatPn/O7/8Xv8Bv/4Le5ddIhqprzp+fcXlVIvWK36fngn/8pn/34L/n24lVO797DsiKEgI89SksCJX5JZYUgkFAkFUAU7kRKE9HH4tPPnizsF/pONCKxM5qtjxy7kc0k2GdY2sjcKExNyYYWihQcaJiCp54p9rtI1WmMEAz9RK0lY9Cs14ELMo2RWAu3X1UsGjg66fjZw4SNjm00dJVgKQUxZZ4NpcBqjWZlM+tBUrdgKoWZBJlAraBdGra7iCAjY6Y7a9E+sd5L2IG0iRQVRyohmkyeJASYXFEN7LMmI1jODEYF+j7TdZkr3+FR3GwjSmV89OxaifOGs0VCJnCiEN03QyBqTX/uqKrM+pljFJpbZwkrM1lJxjGSxCGDWWuOTyAExfV6xNS6SLedwCiJnWl268hbdxSNoLAQSAwusw81y06gW0urM48+HoganuXI+mrk9Lbl6aNEu9S0lSC4hCZzdizY94ZrY/nKXYkKjn43ISs4zRF9O9LUBpEz1mg6QPvM+V4gTaZSnleOLJt9pLYCayWyUjzfBJTPnPvIdgunc8lm0Mg2s2glyIDMkRdxCJHSgLYKlMjoFPj4r77PzbNr1OyIRbvE7D1MF8Qbx3rjkLZCiog14CdB9Jn9BD5DSgKfM52VHJ3V/PHPA2c2cXZLIy4jYzwkdnwBuJrIkZT8IUJzRBtL3VQMw+4AJc1M43BoPEr6vuToojXjOCCk5gV4VciSFDN5VzgfykCOSKkJwZFixk17UozU7YzV6hhJYr/t2awvQdygpaRr52hdIw6RjNfX1yhdMQ17qmZORhK9Q1AiseIhDUCZGolGialIWGVi8BPd6ojsXQFfCU2bJMpIHj16j8rUvPvu3+OXvv3rPPzkEz766Oc4lxmHS+6+cp+UM6vlgtdff5M//+73+dlPvsf1zTkuZJ5fXJQYSlWi2Oq6RXcS70eEUhhjUboA53LboLSgsnWRqg6bEru0v+ZkdcSX3/4q/dDTLY5YLGas9yMxOSpbI03FOJZmx5NPP2CzW7NYnbJaHjM7uQOqpWk7VIg47yDsmavEuL/iaHlGffY6i+O7bNaXzLtjuqM7VNs1pr5F9OX5ImRmu9+xWT/kzu23WSxOEKbCe8/m/AOkmlBWwCRJvmK3vWByjrUvlprtXz7BVBXeTXjXI5REIDle3kHLjst8Q3Rb2qbmeHXEdr+lHx0uOBa1YN2PTMOemAMChY8BLWEKJXLNaMX6+n2WRycsugbnA+vtBms0Whu6+ZJ+2FDZmv4LNmglJY61ZE5LfCqQtCx7XPTIkJnVDVN05feLjFCZ1mqUbhFkmvmS7W7PFALSFnXffhyYrObxswuICpEmhs4ipGTvAn0/YrWgrVuWyxZTzVneeoWby2dEt6OpDfvdQESxDRnEIRpZaWzVIIVivfcIKYnSEGKkERYXwdqiKvKhPG+FqljdfYOUBNeXn3Cc5rS1YXKRGAVGJZb1ETOZkCHw4M4SuQVpMrXInBzPebbe0DaGowe3sVWNlpmq7kjANG7pp0AKmeNFhZJgtaY2Bjd6pNL4OiFCASlttlPxsYsAQRKyQ6uKel7RmkROnu1gCUogRUIfArUnBHm/p5If0fiRiw8/ZvXqLxFmZ2hTIbIkJ8HN+gIowwmlDFU7p+lWWF0xOUcYJ67Pn/Enf/B7PH7yEKUktjI085qUJVZLmq5F67JHtJViMbsDJKRSNNaQ/J4YA3fu3EEpi9GKfT9ydHyLFO+To0dqhZ9GEBotwYdUgMy2qASPV6vSNNQFSrjZ7JlCQgnQbcfZ8SmffPgzrAKx2SFceQ10GXZ2R0ccnd3CDSNDv6GbHTPuB8LoULb+XPf/5y68f/lv/QMqW3zLUIA8/gBJy1kQQsAeMqBLoZZfepcEvCRoxxSx1pT/hkwjFPcePODu/VdeQr9KsVwkz3phODs9K/FaUheQ16Gv4JzDuZK76NxEDAFtNEoZhOBlrvSL4ryuK7yPhRRLhoP3qhTuqkDEDv+fMYacBZMr+Zl13eCcPMSDlcirQnsLHD94G9PNC5U9w2IxZ7lclInyi/zpVMRq6kB/L5C2EtoeU8DKGh/i4XwD07BHKgOH9zablUxOawpMzrmJTCxZjalM5LNPL4FwOSdmsw6naiZzzPzOG2T9L/jBX/w5v/F3/jayUgcae3lPTV0of9M04b3HaM1uu6eum/LgyRHnJj764H3+5I//OZ999BFHZ3f59q99h9ffeAOjVQGvAZBx04SQgikmpITXXn8TISTf+95fc/l0R2Uq/t2//++wODllHB1CVlRtiw+hZJnLcl6JcpmnyWOM5Onjz/jhd/+KHCk55FJwdusu3fIUZZsiras0RycnpJj52UcfMfY9+82WRCZFaNsZTdvSzGaf9/b/1x8Jciz3ojCabjHj9vw2VzEwPHnK82XNvpXItuPo7h1eebBgs2h45d4dKiOwTIwXV3z63g+5eXbNySh5VVYs6jneJW49cZimY/d0zWLT8Ip8m2/fmdM4xavmDc7yKSdPNUdHiwLmUZ4cEqGPhLAnOUkiMU1b+rBj8oIgBnyIaGXptKVSlsqY0uGtWpQu8TNCKJQ2CF2XvGdZQGBSSVJOiPwLVkOOJapNHpQvQooiN4oeqSXCgzCJJIo0h1SAa1KbYm3IsniivCf5WBgE41gid4RFNBpSLFaSHEgxg86QDSIblB2QUaMw5KRR1hLHTckTT0BSZJ2L2iEJhJUlgk5JjGlIjUZ4KKl1GroKTCxTiCpT8KkFACeigLoieVHuvxzKlCFnFLLI70lYPSMHR0CB8IgkUZU5vP+S7ZlTIstM3c2xukF3DcLUJfHAbTFT5Hf/k/+Cd955na9+59f46FJy/tEn3P3WbVLQ/OSf/pTrv/ge85Q4bZblO2Aa3PWONBmcCxiZkcYepm2WJDQ62mIXkQXUbSSErNDRgvpi0JwYMjIFlEgQBMetpEsCZRXPdok8ZV6/Z9n3EREkUDZToy9FpnHFNnJrJnm8U1Q58O5JpmsEl5NgJgLWJ3ZDYoiBMOVCIreC9c4hZSIhWcjEbkosOkNUGUdiNyiWdUVNpjmkJPQ3jlzWVOqFpK1KU3SuPaNQKBloK0VXC3Z9mShvR41Lmq7K9H1ESMnVxUjKiigM0yiZ60wjM6arUUYSk0CLMuWUlGgyNY2ELLAGrI7EuWKYItYKXrGO0VVcTYGTo4pcWaacYApomzBCsO1hEoYYDW7nGLcBjWIvPa/fBlIkCEGrNZurwE4Ymllgu0tcXE3cWghOj2A3wbNrydVl5KIf6OaWzeVAIy3bZDi/ESxmieVMUquRvE2U8O2MSwKFZlEXCOrNEJCxqBAak3EhMleZZSdZ7ySrI0ulYb0NVEJy98jw9JlDZoFJmYhA61QUCVqw2yeUPMCScmJxakjK0dSCFBM+wPV5z+Q/oVeX3L/dIMKOSo7sRaBrM/ux3NNaQqUyYy6xXCkVm4NEsA+ZRXK81iX+7BP45ttwZ6FIuVDJv0iLNiGQungOq1rhpoGdc0ipiAFSihhbE2IgU9b7lDMaMNbifcAYg9EtSgmmqX85qSZ7YswIUaxhfioZxEdHZ0TveP7sMS8iVoUytM0c5/Z4f4iVqlqGodjAEJnj0wfs+w373U1JYpDqsEcSGFPT79cHlZKmajqgyGuVrZktFyyaGXdf+Rqnt1/n9P6biJi43m7oZh0ff/Aznp4/5bXX30DpwmGZdwsmF9hsDvLqMDKNV3jX490eQSrWHCFYrY7RQrLrd0hjEUpTzY7ZbdaQR6zWvPXm60z9wNXNNS4EtBDU1nC8nNN0swLhlRWfPn6CFolusSSrmo8+fZ8PHv4MLQL7fsfy6IT5yat0J/e5df/twtzZrPn5T/+crtZcra85Xm+wqyVHZ2+i6pZ6us1stWOzueLDD95jWD9ksbpNZTRnJ7eR7YwwOLDf5mZzw8npGSFl0u4x1+eCzfVzrIq0bcMm7OmnvvhnAzTdESknpm2irjVCdOzHgRwnLBv2YiTnATftkUSePnMIpfDB4Z1DxJEMhQI/9tS1JUSB8xMuRLq6RRIQqmY3BIahZ4yuZEJLiRvXzJqOW8sjjk5fL2vlFzlEifMTEoiRpi4TY1nVaKHY9hvEdkJqQdu0CK1JxZGBH9c0TcNuGKmaFW3TMuyvcHKHk5mUYNY2XN9c0bSWrXcIn7B1x3x1xnLZcXxaM29n9D7x/MnHpJyptSROkfmsK5nsumKaAsX9VjLWQyoRt1YZKpUJfgQZqLTGqGKFq5oO7wJWZuLmGSEnahmw8yNMTnRiQiXQQjF6j2MihkijNK+czti4wOq2YNHVPLm85vT0hNPbZ6SkScEjVUJoTYwGaya0sozek0XCVuZAU3fs9ntCAqRCajA2Mex7tNVkGem6hrbJOJcZnCu8qzohk0BS1KFCFCZT18Bv/uo7HJ3M4KMtP/vBH9Es79CsbgFlb1TXHVJpkBmhRYFJjnt2wyUXz5/ysx/+lL/+679gcANKCKrWYpoVOZVnvrWl/pJCYOqSXmONICZNbTWmskir8WFCKEXVNkQfaGcto9/QdcekOFFbSy9e3KACLQJ15THVCl1pusoyDLIAaJsZy66ini0RSHb7LdOw49XXbjObrUgxMgwJTy6E/RTJOHKG2fIEWy3wYcsUA5uto6r6z3X7f+7C2x7AYsb8KxFfWR2KvuI1Kv7nIld+Ad16Ad4q1Gtx6HDBOI4EHw950C+myZmqqlhfPuXxo0fcvv8Ky9Upwtqy8FiLMWXy61yJ4ArBF3OTENjKolSBQEEp9l9MsEs2uCRG93I6nw4gEynFgTpe5K9KSqRSuIOsO1NI3IICXjOm+JjDsEcCcn5UEPtJkQ5EdWP0YeIeXnrZy7kVT7VSJbs8BIfWmvXNGsh8+MO/4IOffJ80Bb7zD/4hw36PNjXWGOJhEu+cQykJCGJMpTuOQApBiIfsayG4urou/iIsi9N72OWSp4+ecPH0nNNXbjEFTwjldTLiMAErTYkYI13XAhJrDP0+8Oizj5ECvvlL3+Lk6JhX3vwKq+NjmrbhRR64EIU0XwB84HLEh8jxyVnx++fIe0LSdgt0ZTm/uCAlxdFJR85QW4MUoizCQhw2PLH4h4E7d1+hWyxwQ8DFF38vSFkWyWxwPHz8KZ9+9AE3l9c4VyLMcnTkHItfL5X7tapq4H/1eb8C/9+HC8WjXN4qTT3j9vIWj58+Z3p8g6uvcQ8qTFcTQ2C/dyxOlzR6wUkHn/z8EdurLXdPX+M4zxjPa5rmmLvLY6pkaJ5DddaSfUC2x8TdnurBV1FZ0rZLskgwTsSna2ISJYYrTPixZIpOORCiJ8mEEmWjPK86KlEjpKDSGiWLjEdpg6qqQtA1kFVbKPCH+0rqAzREK1QSZFLJkUeStYQxkkWRLudUVCHC2BJdVbaeSHzx4WuBoIIQEQdJdMLBOBKnqeTVJlei2ow8yKIzhIQIhfxMjEijKLSBQk9/ARDJsUTrSKHIukCLhJAFJiZSYRzEgNS6FMxSk5VACkk+qGPykYF9meAXX3ou8BRN+VNOyEhZ1IQq56QSOQZyVAglQarCHkilISGzKq9DLh7LOKGrGtEuSyNPS5CCMDn8FKlT4o2+4/f+1/8Yf3PCbH6fyz/+jPeebrn40Zqbf/knnE6BW4t3OanfQgqNaiosknwj8X6Dczt0ysi6AmVRovg8Y0iI7Av5NHmUMBAhfrG6G10JToQj7zxrKkKAgMFvEl0tMSRuLiPOg4gRFzI+DLx6XHJWt33i1nFFXUemG7jdCGatQkrBysB6zPQ3CSkkxgSWMhO9IAyBpi0KoqsxsyByNldk5xkRNCKSx0zoKjqrGadEVJrOOAaXqBS4KfFsH9n0ZVoeUmbZCk4rz+VF8cwpm7Bk4t4w+j0egXQG3YBtYRwEHsEuSganAIF2RblFFigfGbMkzQ2VqphSIPeBWBm6KnGyMjxdK/bBs5+AumE5y/R7z5PLwNEsoYRkRGJVZjZG9jITI2AyD9fwzqlndylYrsAIydX5yDpaXr0dcS5xsc+4BJut5GxVEbMjSYWqlpjoWGpPMxNEPEcqcPeBhqSoTUJKXRrEwdOGiJOGZ/vMYqkgFEpsQpO9JxhJrBRbSoZ9qGGY4GYDp8cSPcBm53ntpOJ+KtE32mSoJctaoJSgMhmpRJkYi4wWGRaWsweLQsJH0B4teeMbX6ObL1g/fcbUr7l48ghVD1xejkzB0TWFL7IHnCuZ3UZnFgmGAFOQ/F/+LLGoM//dX2n48Lzi7dOetlHcbBPxC1DNMwGRi1w++iL5NLrDWEuMJZkkU4ClOZdITiEkxrbEGGibBSnDNPWFs0F5rRT9S0BoTiVrPCOIwXN9fVHgaqYpZ+AnohvoUy4kYmXphy390COVQSrF0dF9JtczTQNKKpz31HVHcLEkUyAPMakDgohRib7vkdrgw8TlxuFCRG+v+fT8Gbz/U7p2wdX6ivXlp5zMNNY0dLXms/NLjo/v0DU18/mSB/cecLo65jf/xt/g3bdf50//5A/5l3/8/+Ds+JjN+oYsImPwaCG5vVpwvdnitabfXqNFZD5f0LYN15drvI9oXTG3BUi3WC652e+ZUuDs9j0CidA7XBh4+NMfc/7sI1z0bHebIimVgjj0VH3Ddt3RT1ustvTbNU8++R7K72kXp/RTz+3TM1CRoS9xa9FPJQrMGES9RAgwdUcvG8abLbO2o1vcYqktsmpYLW/z6JFkflcyO77P4w//JcQJH/NBATmwi7AbehrbEt1I13a46IuVEtjtBpQVGCGRdZGAa5E4Oz6mdxPX11eEGKisgZxRunyHJ1eskzI5Kllx984dpsmzC54pjNSmZl433Lr9Ck13m3U/8ejpB7jnD6mb5RdZJtjs9hwf32OY9tRGE8eesiczGCUJsWMUAa1yia9TGq0tJ3fe4NmzT9jvt8xWd+mHK5LJBLen6Y4Qckf0E7dv3+L09JiYI2PvGIaB5WxO1bRUVqBNYUeAZFaVoYKfJmxtiMIyW96l1ZbLJx+RhWB0niwylZJoU7gyF1cbbp0elUmzMfhYhgZWaWwjkLJQxWfdDDcWqGyediQkI4IpRGwccPsNj/rIqpuzaiduVxLbHqEFvHbvNsq2uCRJQEoVIUSOjmZIqdj1W6bBUSuBmxwpKaQW6OhYzpvCWNGGyTusGYjOs1zNmCbHNPnyvJUBn0uNpDRl0h0y45TwKVErwde/dpfbJ0dU7Qn3X1nw45/9Jb//O/+MpI6xlWUx78r+ozLcvXMHY2qQkuvrNc+fXdCPe7JwHJ0taccGUqRqK5qqIgnNtr9hNrtDYy3NbIbQFkMmpMC47fFh4Kw9I2OpKoukpJPMFyu8H4u0PguULRHGVT3Hu4ntfkBJzerkjBgzxiiUUMy6Y4Zpz7Tv6ZarUqeFSF035BDIGKSISG05PmogeQY3UtUzcoJxGg/x0yBEy9HxjNNTwc16/bnu/89deM/nc0LwhOAPnmJJOuRTC1n+rGzJAlSqUKMFFF8h+VBwC5SQCCDkTNPUVFUpjHfbHe//7KecP3/O17/5DZbHJ3zy/nvcvb/h+NY9YtURYqbvCwSk61r6/Q55KLj9ASghKJtca0sR/mIqDhBjoK5rKmvLhPwQUSXgAGmTh5tPo7Q+FKGqEMdDaSq8gLyFMDFeXzCtd7Rnt8ur/CtytCLjLpCBlxf7X5l2W2uZJneI7io08M3lZ3z20z9n//wp737z1xi2V3zw4+/jo6JqZ2hbHQjeiYNY52VDI6VAOCzCKWWsNcUrYTTr9RZrLX0/8uziCf/J/+n/yP/kf/Y/pZrVKG1RssjNffDM57MCEJmKLEUozc16jQ+R07M7eJ+4+8Dy4I13mCZH23bl2qbipxDikD1LIvrwkrCaBeQkefOtL/HgwRvEUDYJu36kHzx125BSJIviu8uAj7HwYyjTDikkPmbGwXFzfcN213N1ecVuu6ObFTjF+cVTPvv0Y4IbySESUzg0XcrnHFMkxfIZBPf5ulP/TUecRvCSKIt6INeW0+Up7/ZvwOYhqVdMqmKQgjyNXDyZ8K7l+TTy05s1R03CRs9xt4TTlvEokx/dULOglWAvexqxQMsOvEY2BjGMSCRhvyXlgB82+Jjw01QimGUqfj9ZCr/alEmw1aZQyrVFaYHQhYAqjUTmjJAVQperJGqFjJasKX5kqcvtjaJwgIqNIYdcIsBiaaZlEqLg+yEXz2qWCowqsRDSFOVHBHQqtPMcydGRXCBOQ2lmKUVKusDIUEW6Xv4pE0OryVmAUuSYXnZJs7QFYhYdwqgCMxIZqUzppisgeLIErSQ5ebJREEsOo0CBKlm3OSZyzAipEDGgtCQhCDGhSKgsiRRibEkIE2QMInhEJcrDO7sycRcFHBKcL00+XeCTwmjMrCmfhcwkKUnOE13AuZEcHa/VR/RP9kz/h/+Sb7z932bz2Zq//mf/lGMzYyYl1t7iqLrFzHblPSRQbYtxkWr07PzIFEYqL1BIhDSgQFVA0ofmQI3IE0lI8hccZZx2iXAT6CvN801k8hmVJo5mglVFmRZogcCzmzK7oJi8xrlIEIqYBBc3nq6DozaziYLddaZrQUiDrCMiQsiJJgzoLOmNISpD7ANeCk51omkMSWRubjLzTpSseam5vInUySEdXC8NCy2Yy8yn+4rGeB6v4f4ykRzMW8G0yzxaZ4LWLKUnpwhKE22mHQyLeaSSkcuNhiSZkoLJkY2hYyRpy/TCW2dMKUTHyCIprJtYNoLnO01XKZ5uwF47Tk4kKsORge1u4uZ5RiRFJcBtMqJK6BqySez3CfodLmqutoq5dVxcBJZzyc3WolIgJsVqBRdrxeShnGLk6Fiy20zkKrGqBU1SdHWNCxUffzaxUhOnXWIRIMjEeq9BhmIFyZopW64GxayC1ULRj5EjBddjQqeM84JVlRmdQqnIfpuxRxarIlYrZktN12mud4n9daT3sL/JJCN4kMq0XEiK3zMkmtqyMxOJhBCa09sL6vkx81u3eeVX/wfYs29xun1COP8zlj/+ay6ePSHrJ/TTJS4GKitwPhOBIWZCOOShazBa0lWJyz7zJ+9P/NYvn/He+3vsIR+bLwJXS7EkNSDQShQVEZBiprILjJFIUWJLJ7enqiQhJqxtGYcdWRwYEhwGDXi0KaDVfGg8IotSCZGp64aY3CFezFOZBiGKmi2SyaHEjJqQiHIixUwMgeurR4SYECKBKGTpEIsdSNGg65qT1atcXz5m368ZPYQE43ZTzi8ndoPg8aMP0Eozuz3nzW//bb7S1IzDxMVnPyauP+OvfvgnJNlxfv0MUy945e7rfPb8ilfu3uH+7Ts07Zzf+I3fQjDx9NHPCH4k5iJ7LfGqmaaxnK7ustuvETnxzpe+wer0LR4/ecjm+jOePn1I368xWnGzvsEaw0/e+zN693XOr/eIumXf79msnxDDhLJNmSj7qchTo2MYronPNNO44ezWqxyd3OXOnbtcnj/ExZ7L84/Z/OkznJuoZw3eB+bdimZ+RnegqIfo+PTT97l9x9HUc26ePeTn3/8d9vtnVPUcW6+Yhg05jhgJ2W9R9Qlp3EHMzOpjdv01KXnIRUW42d4QEVTG07YLKqsIObMf92WQJRRCa85vLkuMkhX43cDOD5AyLpb1TyTPnZNTZs2MGCLrzXTww96jqwtM2doWHxyfPPwulzdbnBtJ7YLL7cUXWicWizl+2mGlPMRPebwLLETLNgf8VNSYkpEoJdt+whpPHHtmR6fs3RbXn1PpMqhRqqjpcobZbFFi9bKjrmbMv/QKV+efEV2PQL8cEAhiaZArRSU8tlkghcT1Oz75+ANOTm9jjSJlQbso0+b9bmC1aPAZXn/9S7TLjutnH5NExtYVwTlCtmircX1PSg6lISZJiCPCWtrFEhsFdtiTdz3bZsGX79/GeI8f1uQocHHPdj1hmjMetCM3IWPmLTc7x65XTK4wHASC1tbc9D3drCMnSGS6uiQfxBgZXWTqI9pWHJ3OCE4gSJwczUkh4n0go4m+NE1Joagg5hX9tufdN5f8u//2u0gTEKrso6qmgez56LMn1LYMRYVWKF3x4UefFUL/rCkxjDlhG4uSDTkluoXB2gpjNUpKFssTvnb2LciZ3c1zYghUpibkQPCepqlYLM+K6ikJpKpKI9tUbPuAVhWxHzHSMMYJlzLdbEk1m5F1zzSW1q82hrqq8X4oRbjukIuaFD1VrXHDiE8T2tbYukIbwzQ6hqknpkjXlOfobhpo6hnOFTh1iglbWaa+p2u6z3X/f+7Ce7VaMk0jl5cXaF26T1Dk3vIwIX5B7hRSog6jeeCQZV2m41KURaWy1QGMVjoNSMHrb7xBv77mz/74j7j/6qs8efyIrtE8f/acL3/9V8kUeZmUknHoD9L38HLaGmOmai1SQPATzgdygq5tiKkEr3sfSDHS1A3Y9LKgttYyOcc0TgxhpKosRhv6vofMgfhdIjfGcUSQif2OqpvRntwipkRwrsjpY2QcS2H/wmP+QgL+Qn4/TdMBnpZomhoBWJ2p24qv/+pvsrpzh3F/zRtv3OcP/+jPeO8n7/HOl7/C3Tu3sZWl73tiKhFl+UCNf1HUS6mYzeYMQ89uvy9TaKXox5Fhcnz3u3/BH/7OH/Cbv/03+fTTj/j0k4dFvu79y8+j6+asVguatitKBgHWWLSx3Ll9m7qqmXUdUkqGyeFiIb7nVOJNBFDXVemqxkCIgWF0aFORhASZ6FpDRpJViVJTqviDvQ/lWulS8I2jI+XMvu8Zxi2f/OwnXJ8/ox/2bDc7tpstxthCM4wBF9zLa8LhuryU9wMIRbc45fTWnc97+/9rjxQT2QlUk0rueG0x8xmzm2NeF4ZxzFw+g3BPA4HdbuT8+Yd0dcXb7zygk4lhc4XOmstPH3P+ow/oNoI8gFdz6h6mfkfdtYRtpFKKODhCKB7oSCDkiJKpZNPqGqsESpTceyUbVI7oWiFEjRDFQiGVAp1RokxYcxSISpFCycp9wRAQiFKE5kOBLAXETC4VNegi3Vc5lAl4gGzLg1toUyplVabi5UmjDh7uwjvIArJzJFeyj9MUi2xSS4QusXVSSvLBN5RzAQAmIrqy5FjI8pDJQhUpt1CkIZNFJEeBlPkAiIE0BmL0yNqU54i1iOQRWZGkRBoNMhU4jS9yKSFMOU8lERGKwySSZCz0dSkQKYIowLKsipQ8I8nocq1SiYhRFUWKnjKqqpCVRhpbMsyzBJ8J/YQbd6WRmANzXXFWW95evUVlK07sjFvVkoW0tKYj56aQYGsItoXJoyuJqVvaRSCEPdvB0U8bINKYGVJLoqIAzFJN8aNpJAajvkCBAfzsacRFy84ntkOkbTWGSD9m/KzYZPzomBz8eGeZpcS37wQ4NDMNCiMlV7vSKFVTouoU/ajI0TFflJQKKs12ajAWTtqSydwriUowJk0IgcYIZicNKZQc87srwc2kUVnRj54z5aiFx9niqVcucWcpGYIkpMxwnREKmk5BhEFUkKFuFLGPbIHRaWodcY3EXUy4tqKpGrQKTElSpVLIqK5mmARNDpzNBG3esziV7KLCCTgmE7LkVMPDx5m2Ssznip03VDojxwBDZNSZTTSsomAuIyFLBDVX1xPaJM7mEjtr6PeRKg2MXjCqyPd/6Egqk5zg7Ejxxqmh94rLHvTFgJlnJj+xNxIRAl2lSG3NaBKjUJAk86Vg30faY4MLmToGKjWRsufiuqI1gigFVgvObkkebiRWQaUdthJ0dWnwVha2e8GUI1YmbA60jUQJgbAKBygtqWzhSWhTob3Hh5FIkaimmNGmZjmv0dmx/vmfs4wK1SxRTcfR7VuEYcdyfs11rRl7TwZqDcbCFKGS4IEQJUZGXr9d8+mVp59gt75kORfsguZyV3yU/8brRC4gVWvL3kQriQuBnDI+7NGqJmaFVBVNXb5/RzPDzX5AKYsUiq6ZMXlFpi8tQmkJfjyA2iIuQ1MVZYhUkpwUMZam8+RHyNB1CyZXfODTMBJTafg3dc2u3xHCVKCEpka3GmtaStPbst7c0PcDm82PaOqWum4YxwFb18Tgma9uc3P9HFJJnNmMG262f8Xjhx9w761f5cHb32R+/yuks7c4ysf86F/8Y7bbZwgp+ez4PquzV7kev8GjvePWyRl1gtff/Dag6fvvstttsbYi5sDGC2bzO3zpK7/Ok89+xvJoyVtf/g1iCrRtzU9/vEZpg9SOyhb7Y4yezbYnuonT4xPe+/n3aDXUjEQF2Y9olfAu0nQdX/7yr7LtB2xtub6ObK6fooRGOMeia7C2Ay3RRqFUh3dbVK5QpiUO1zy6+pSpvyx74Cnz8cXPC4ypKs8QGT0ir9msnyO1xQ07ZrMZ3mcuLx4x64649+rbDONEP+5oqo7JlcJ6eXKGEoYYB5QWSCNROXHcHbHfe4IfGKcSQ1tXls7OOTo9ZZj2IBW73Tl3j28RckbritFLetdTaY3zE8PVp1TW4PsLkrBs95fU9Yxx7JFScrk5J4T4hdYJnRRJDAhRogeb4xNubrYFGCgV1iZs3SBEhVIl2SRnxcXVk7IX0DNi8qQcGa+fUxuLc2turq+xp7eQzRw1rfHRcf7Zz6kqi25ahv2OnBTGSnJyGG1ZzY+4WV8Tp31RzWZJ12T8dFWYBjkTMmQUutJse4cxlhB2xDEwaysChhgl2mq07BBKoePIFEq6QhY1MRhOljOU1CRd6hY1q8muNBm3eKjmTKPjtBJskkXFQEoCHQN6cpgkqExRZPkYyBE2bjwUkiUxRSIZpwkpFS5BwjDrFDGM9PuxxChbzRgiVpfkmlWluX1yC7JkPw2sbza8fstSccYb92asLAybK6QohWqYNqxmklVbUmhm84osLVkeGiAJ+l1AaYVWRapf1S0heZq6oq7a0iSSAkHm4ukj2qZCm4q6Udiqhgyp6WjbCqVq+mEk5gn8QAwTDo8QlpAlo3O0bXUYoBqm3qGMp7YWTVeehcnTb/fEQwRYTpoYQSpDItLMO2yokXICJakrC1j6/a6k+mjLNIxUtsL7seSMizKo7YeJIuf8fKakz114bzabwyS5fllEAy+zoIGXku4YwwG4VrqxWv/i13hXfEzGSDKJYRjIqUirqqajbiuunj3kB9/9S54+v+Z3fv+fUzcVr/zZ9/lH/8F/wKKboeSBon7Y8HofSjFfFRBCDAfgm5DYxlAdCtUXkvLbt8+4uV6jlX4ZfaV1mdQPw8hivkDKzHgIQ39RaPxCKl+mu9k5ZNXgpUT5UKAp1jKMw8uGhDFF9p5zuQ5Fdi4PcvMiddFG4Z3nyZNLbjYjZ7c064sLlrfuI43l3ptfJgEPHz7EVoYQAloXGq48wIRKUWWp6+olPd57XxZpBT/54U94/OgJY4i4FPnP//P/jLe/+mXe+/CH/Gf/8X/Kdt8fGgGFCCmEQmuFMiV8XgqBlpq6bjk5O+Vb3/oW77z9Dnfv30dbc5hOJ3yIjJPDe1Bqj1SCfIhq2+wGYDxI1STHac58Nudmf8W2d1RW491Ev+9xPhaiu5RMrkzOQ/CE5Dm984DV8Rn7fsezx58h1FOOj4653tywvVnD9CKj+xebpRfKgJwzVT3jl3/tt2gWX9zjLXUguyKHzn1EysC8aTBSsouZMzHng7pi13psJfnKV79OdI7aSHLfo01D3I640fHo/JyT2CKDBePwDNhNzbR3aKXZD2UxVYciTyOoZIWRElXXWAUIi9IZqS1W5DIRsRYhAkJEpCySY2Tx75CKX4gsUarcR6QCFkQU2XixDdiSiEVEZAGREht28CnnfJBju4CqDDllRFUixbIQpcOcc4kXO1Av8+RIOZbClpFEKFJKkRCy4oVOQWRNIqJETUoOKQopFzMhXKFcIgVCmpIfriVCVIWwnj2STEoFzlLuR4es1Et1DEojzOH8pSx5lEWVThSxTHNiKbgRxR8KCqU05GLzEEhSLBCT5DOIovKQsjQYil2i+JZUXZcCXJviPydDTETviWFPnrb0rielQJ0Nd+u7HC/vk7PEYrHCUlnLrJqhcotzxZPZtGuEtaWj3zSoVNO6Jd5Len/FLuygSVR5hU4aqeoiThWZA3adlL/YxNu7UD6DKDm2GYLDHmTb482eShcVVG3gOycTT6PlxkEnEtOYqOaZ2ijsFFh2knqWuZwyWiT6mBGhZHAem5pAIcY/uta0VSYJzaINqCwIUdPvUsmVHyKukjy5ySSTuF8lgk70u4FqDgTFmRZsc0McBlLMGASiq4iD42onWFQBmpokC9NASME+TLRVhQgBqyKsNDZFKibmOaFrwX4XMTIy74CmNMgQRZV0tc3sdonJK8Yx8focempsijQ2048RIyTbHl4/0zxba7oQWVjFxiVMqghDZD0VK8lcJfq1Q4uMSbCdBL3PzNtMXUmcC7SNIA2B5/sS/3X/TDE1LWHvMVqgFhY3SpSQbLcOudAsVCz5vxc93cIi9nssEic02mQeP8nMmolJFqtY0wquR8Oqy/gQ2AwgjWKMgmFInNyi+J0xDENk8oI+SU4qz51GkVNG50RO5pBaMQFFequNJEWDiwpZzajPXufsK9+A1ZeLaocK0qsI9QHOeWIIWFti47Y7CBkWTfHNulIPU+uERHBLjoyNZDFrOD7p+Oj9nl//cuTZTWb8AiDOrl0x+YkQCmRNqVyaTKZCKcE4rPGxTJnVwbYSQl3WP62I0TG4UqQ0dUfwnkwsDI4kSSlQ1S3WaMZ+IPjS6OaFMi6VtS+miNEVHo8QGS0Eg09kPEJorLHElIkJ/OAYxlDo6XkiRHdgeiSGaSzWvJiAhAuO680lUivadsZ6uyELSMGT/CUw8fpbb4PQjC5w+fyIxdk9/LQtjfHQ09qK4+MTggtc7gbGfovcD7z6xlcQZD58769JQtPNG95662v060uSH7h79x7Ht1/nG1/9NonMxcVTlt2c65srnOvpJ4ei+KYlcH31iImn9MMNo8zUtmN0PW+8+g4+Cp6fP8Unz3y2QqmGadrS2IrZ3S+xvXmGy443X/sqk4/s9luQknG65mx5i8EH8u6SIAWdrFGyw017jpZLrK6pbMNmiHi/RWq4uX6GUTVJlCzhYeyxlWDWHaNVy/X6khA8J2e38CFiqhpjFeM4ktTEcnlEwtG1C/pxx9Bv8XlEi7qsOQKcC6WBKfYoJZmmkRAS6/2O0U2M01Tk8NpiZ3OC25OlQArHrGsO5H/Bvu/xIZHSiDUV89kXk5o/f/oYXXVIlZjPl9j6mNr6Agi+uWS5nLHf7UBBrS1NWxFSYnNzg5KF2O29YznvCqAuBRpV88q9MxQCrSNBVciUGOOAC5QIzwzOjzTtHClrhFT045a9F4wDdClQ2nGJOAS0gHp2VJ4lEnRlMCIR40Q/7BAiMJ/dotKqxGopTb/fIlJAyETTNNxsPU2l0LpEAkorMaojpi1VPUfbkXGMtLOO7Byj3CJkoJufMPqRqjrFhcDGe5LKdHXJHT86qsgx4HxFztAPE8pYtBLMZ81h2p24vtlTNRV9n7l9eothNaGFpG1LkSylxPlErROrrsGqwOy1I45XikG2fPLdH/Dnz37O177xKk13zNRfEsOG4xPF5VCx3gt8KmuGNQotKdk2IrM69jx7HIvFV82YtzO0tcUKKBVtW7Hb7TC2MKZySqhs8P7Q3IgwuoQUe5bzI8ap2FxsCoWNoUui00w0yCzo3cR+N7DNA0pLTldLkp8I8bD3E4bJCZLraSuLMpaIwpqims4xIqRmmjyCVPZ0yhBcZD1tSNlTVw3TOGKshayIsViHY/T/H7Xu/6/jcxfe6UA2eFFkv/BEA//Kz+Qh8/IgXT5EiIVYoGH2JXRNMI4jShWfdYwJiLz/3o/5vd/5HR5++pDv/K1/h9/6O/f5T//j/zPPnl9yebVnsTzi3/tH/14pCihAt+KPKr8/hMButwc4FLaK2axlPNDOW2sJMSGFYLaYcefWGR9//DH7/UhVGeq6xmhFXRtubm4IIaK1Kn6rg7d8mg5d5lCikurjM7BVkeg0DW4aDx3WeFAGqEOsRwWUzMIf/vBHPPzkIcvlisVizr37d3FuZPCRi8sdlfiA17/8dWS9QNmWN770NT799CFaL3n8+Al1XTNfHKIGxpHddsc0esaxdLOcd9y9e4+j4xXzxZzJ7fm//5f/N9xUqKMhJm42l/zB7/0hf+8f/jZ/+Ae/w3s/eZ8YMzGlA4TMFZ/RRJGwSokUArZrnpw/5oc//D5WG9p2xsnZGUcnJ7z11pd498tfJWvNzc0Oe/Br5ywRonjRlTrklofIk+drzi/XTCGgrUZqQ3SBmBWDKzmLMudDPFn5jKXQZK1RsmLRLOiWJ9x+8AYiZ+4Cm/UNl+fP2a2vi4QplTg5gSClkgU4m99hsTzBifB5b/9//WFLAQklHirLTI6gjKFRCiPAZcvp0YqJ54ybwOXTK97/0XusOs0MwXzYMdczfv7976ODR8uEFB4tLRqNSkAqUyWtFZUCJYuqxKoCPpFC0zQWYXRpOBmJFFDM0YKsFJJSkBN18WTLkgN/+MISk0cJW4BhVpFzKsUnqsjJRZGGiyQOTb1M8gfZuZAl5itCCcal0HdVeR2ZEhkNsUh1k8vE0Zei2EgyEqkbpAikUtOXHHqgGKmLhQF1oKuQIUUklqwjiCILjykUX3o4lMIqkZKEmMpGMBafIkaVhoLOkEyZqguNEOqlMiITQWtEKmAlIYHgyFEhVQJhD1N7DVoWkHsSJZf0AIEr16U8P0T2CGUQqFJwoxHosjk+eMPiOBL2O6J3TGFAyoQ1huP5MVXXkBMlLkrUBQCpairZ4cfIzfUNrb7E3L1LepF73lnMNKcJmbj37Ptrtv2OnCR1bMm24dBHRBBJoixOX+SoBNi2ooqZjKeTkZtJ0Eqoq4QVgm6uUZUiJMnbUdJPiVpmjlaaKDLZe+oqY01i7zS7MTKzgdOFOtgcFI+fO7TRGBlIRBZGgI+cbwSaxPGxJVWKy6uIJdFViuk8YU8MvfD4rFAE1k7j+kyzkIwhM2s1KkiMLYWKnJdpQFYWfKK2Ce8CRhpeuWMLUyNonFZ03hGlZAiKthJ4N5GVZUgJeTPRJws5gtHEJFE58txpVtZxEy3y8Zqz12bstSAlqIzG5si11DSVxwpouwIcuz1X7KfEBJyewMxrLvrEuI5UNvGzjxyTVeTKcD8G3r5tcM5yeRVZnVTMZhnmJaIr+0iuMvsguCUjyiR0rQhB0MpENy/RbNd2xuaqJ0rNfkzk6Kg6kFoyDBltBCI5hJQ8u0ysVp4YCjA1m8JDnDWZ801E1YrBB06qzHNnqG1iQnFcw6aXZAk5jgj1QkItC3BTSqSVVLWlnTe0sxapLNJEct4Dh6aaqgkR7r7ygBBgdJHZmABPGakLREjILHE5M8bMzsHPzyPdZs/rp46z5YrPzjd843XNn/z033zCN7kSo2O0LRtvqeiaJc5PTONIkpLadsQwlDij6JhXK4Zxi/MBclH/pJyxVYWpatqmox/2TMMOqTRh6ul3E4vFaVGdpYBQFeT0C8ZFEsTsiTmgdYvSlrpbkhOElIpv0bvDI2kixiIlF4e9X1Wp4uNUFqEMu922eIfrDkSJf7q8eoaS5e9TLg2GD37wh9x59Su8/dVv01SKV9/4EheP3yeOW3brc6QyjOOap+efsFzeYVHVnD/9hDBseO3el3n3q38DKyXb3Tn7/Y4YPSFl3LDjV7/zb3N6920CkedXFzx78gmffvwTXrm7Yr97BuOA1Zr9bouRiufe8eprbxBPTrE5EMyM49lXuFo/IcuAMCC15ZNP/pq6W2Fsh7WScf8IZTvqtGKzd9y6+xbj9AFu2lGbCq0qTuoZ23HDbrfFVJIQyzNKiYrHz54Qg2e1PMKFHXfnLQ9ee4vn+8i+36Db27gw0syOGPsrum5Gki1tc0p219y+vWK3vqZtTwkisd5s2PeXpJDZXj0j5tI8Ch5MJairuhQIBwJ6DiPCKESIVErQ2Bk+eNq6RqiimhymEZck3k04VyKojLYI2eLcFikzUmic78lfcO9UL44I08Sy1XRdUwCrFJI1iwUQWXQVo3dkCdtdj58Cx0fH9OOAUdCdnBDDiFY1KMs09DTGIA3s9ntqXTEmCk8EhyDStAuapivDLh8xuuXipif4ibbRNJVmPwZm3YphCgw+EDdbXn37azx9/pxh+5zdsGG1WrFoW2xd0Y+XVMoglCZFeZjk1ux7gYyZuqmJCQSmsKCkIMVAbRQpeIYJ+rEMIaLLhdmcG2bywJJyHnJAZvBKsd6MiJxLbFhTk5JndbRiPhNs9yPrzRYpVFGcBkfT1ighkKLwdPzuBqPLsERrfXi+JHb9xOgE47DjpElcrgWPzx8StyO33j3m/PwKNXuKEwbvFI3VfOnNimGE83UiuISRPV1rqepEbQyrxRm1u0JXBruoiLlG6MLVAc328F4EgeQVMfR0p+XzlLrG6pGT5Yzrmz37YUvbVKRQ+BZKCLq2xY8TIme22xv2+wmpG6If2F1eo+NA2x0z+om26jhanbJdXzPuLgjOHWpaQ8pl77jrR6ZpJOZMHHdkU5d4aZ0hV8RY4N1Gp1L0K4M2DX4ayZHSQP0cx+cuvEMo8mFjzcsi6EVR+gufcT50MiQ+FTn3OE0Mw1iAY9oilCz5yzkxm62QUrLZbPjTf/GH/P7v/g67fuRv//3/Pt/5znfY79b8+//o3yek4k1s6pboAy4XGXsqo3KM0S/p5saYMkXPGX0gbcdY5OXuAFi7uLhCacm5LO9rGkdSikzTyDQNPHs2onWZlJf3Vt7rMMTiJ1WSGDJxt6M9OsG2NSKLQ9EtEEId4jci0+SKvNJ7Uox89tmn/O/+N/9bQigRGdM0YawpQCw38tadM06P79GePEDqhnAw/L/77rsvJ7ZaG37+3o/4J//kn/Dw4SOGfiw+jVRi3DIJoy3HyyO+9o2v89rbD3j2+CnOlb9XB1/qT370Pb71N77JL3/7V/j4g4/IOdLO5ozj8NL//jKO7UVcXDrMIQ95xdt+y+7THQ8ffspnnz5jeXyPZjHDh0QIe6QUxfsvfjF19t4zjJ6QBPuhRJc5H/BhT0ip+E6cR73w1eXCz0sHT3tOseR2ZoUWFXWzJIZCFz5tl9y+/wY5FPr+6CbcAeIncyanTF3PiCIw9NvPe/v/a4/yPVCkEBAql3itBFWtGXcebQXCBZbZclE3bNIGPww0duDZo09YjxWv3zqF7TWbp084yS0zZRAqQQ6k2JOoqTRoDFJmVM6orKlMjRASazXCGIRukabkVSML6C+LIoURQqKlJOsMRh0ItiByAqGJ44RCHSLvAinZUiAii3omJKQWxactRMnrFg6IyMSB5F2U5VKKQgaXIPLBN60l2QWy8+RhIMRM9A5TWbKUaGUKrdPW5Glf8lijRFhTin9VGg1kVUjnwQECTCb5VDblOb+EDiHLZKZsOBU5RrJISJ1LER0OE/VYiORZFLKxFBxo7OngkZcQQplaO0goyIGcVckwVwpJKkoRYpnQZ4AXNgdAiUOkokVaCVKD0gXglguQLo65dGXDUBINYkkpEAla3bLo7qNMw7gNGCnplEVkD8mgqpbKTuzdBZvNBd1shVlYhDvEX8wrGhpymAhhYnBX7EbwOdPKIllFZrQ4NDLiF5MQCg03Y2TZAimT6wpTSyodCAh2g6Afa+7X4EKxRRw1mV1fpsF9EEWhNAWGXaKfMgaJjhNyzHgDpjbUnWamI0rAZZ+K1zRFmrp08vcRLm8GSAJrwa89uhXEaeRhn5irTFAa9pETAXmcWFlJUIZpDEiREMJQtyWz2ubIMHpSrGhqiXcePwnWuaLVgVM5MqbEyUpxM4KwmUk0VERqA8Yo/ARLAVdRYGTCB8lJC0LX1NERZzWPnkWWFQgj8YPjMmjeuRPot0VivfWQK8HNleM6GxazkhVeac/xUpHristtJC8ajm1gVImNk9gbz+VOcdRp+pxZpoC0mkUjuEaz30aaVhG3I8oYbK2QIwwhMHrB9jJw/MAwW2kuRsmwnpBWsu8FtYF6WcGYSCazvfHsnORUWEQKBBe5GRwyJ3KItCeWzdVIsoLNJLgZPY0SLDqJEokpKmIqUNN4sKVIqQtVVmY0ASMC++sN/c01ndRIe4qgJk+fkfcfs788R5pEbTqEsAwTjEHQtQohIvMk0FYw+EwIoGQmZcFpJ6iamh99HPi7v+74nR/V/OqrI3dW/+ZKEK3NS4uZ9w6pdYH3KEHXFdVVIhFEeb6IENgN29KkKVlmhDChtUXLogjabm7w0RNTwmhNiVhV9P0ObRSQ0FIcBhsQc8BUzSFasNg6vBuwVU1OhcashCGrXHLNkykKp5wLVKquICW0sewHR4gjwbnSWFVleqVkw8IuuXv3Pk+ePGW93VK3C1595zuMLvLos8/Kfiwlbr/6FaQ2fPSjP2B785Sqarn53u9z++1fRzVz3njn6xAjn1w8g+Rwq/tUWvDlb3yHjz78gMkPXO1Hwvf+nOHP/gVGKT579AmuvyCkzOnRjK9/5Rt8+PGHTP2W2dGK7W4HRJKbuLi+oNIWXUWyqskkGt0yO71Dv70mJMlmc0k7V8zbBTn0xLQjVC0Zz3b9GK1LQ7mShufrc27NZ1hdo9WOadhitWLcbxhNgzaayiikTEze89n6mtYZ7PwOi7t3IY3km0/RErRp2Q17ZE4M1xuMqXny8JwQPJeXj9FGFntUzMX7LQSVskxuYtHNDoMGiQuOyla0Tce4vyzcoQx+2DIM15wsTwAYxz2omhihlpp+2BLjHihDkBgP8VnZY3SNPexLv8ixWliysEUWHQPD+Sdoo5A5I+s5TSXY9T1+iLRLgcoJTMLUGtknFouWBPhYhnzW5jL4SwmJwwiFUIngQbcrGpMI3hc+joRhHLDGgowYFWjrCqOBFGltTaVrtM6YuuL6cs2w2yLxVEaznN0jRlVAhtEznx1j6xmTL8OvEBXTlHE+07WWlBN1XSxrzjvIgn6/IfECMndGVhWkjKpKtnT2Higxuk3bMewUPnlk9hgFWhmiLVZdW7cIXTEMexbLGbPlnGE/4P1AhSSnipwCy4UhC43zjtoIXEwkqUlhQhuF1osCj841zzZ7nrk9y2rDg3fvoZvM04tzqG+43qx59MFTHrxWk+TA6tYJD87SgU/RoXRDjILgDTEbnJkxBUHsN9SzGlu1hZouqxJ5Fg5xhVYzhZ7tZs3x6R2EzBhZsdvsUBRLbl137Lc3jFOZOCckLiouri55+tl7HJ2ccPnp+9xcP8fUBtkIdNVgjWa3GXjy5KdM05ZX767Y73riPtHUFU5KlK1KfSvB1DVtO+Pqao0U+fCcM8X6AwjpaboZfvDsNj1GC/rdSBD//y68U+Tk6IgQSjZ2jLFQgPNhGiTKxHscx/IvGYIPjOOImyaiPhClcy6FrLE4X7pQv/df/1f84e/+LoML/If/o/8x3/zmtyAGUprxpa//Ek1TsqSnoUDSUio60EQuJO8QUEq99E4bU3Ivy7QVjLEH2TsHCXwp0Pe7AtcyVgMJrS1d170ErdV1/TJzu0ywDeQS8bEfh3LzVHWZev6/WfvTXsvSNE0Tut5xDXs8g83m5kPMkRk5FlXQLaClotQtQZcKGhpaIH4AvwD+CF9b8LFBQmqgaVFQVNNUV2UWOURERmZGZIRP5jaeaU9rekc+vMssEymL8gpnSy53N3c7ts/Ze+31Ps9939ctFHomtJcubvl+GfBOAffec9zfIaNjnDy3ux0iCxZVxQePHmGbhv/p//x/xqOnTxDakIG+78rzSLlkQVPgzZe/4g/+yf+Rt8+/pDWWywcXhJx4e3VNDOV5dqPjcNjx/MsvmHxH27Ts2ZfcQk4EFLvdHa++es6vfvUZfTcidQG+gZwp4oK6NvPPUyByIqeM0oaqKheN1pr1esPF5QM+/OT7oBXBTeTgsVah56Hbe1fgTkIwOc/xVAAHPmW0Kh3IxdJfACoFyle6xGMuVVVCyELIB7QoZOaIBFkhdQZiqXBDErOaF0UaZWcFyZry30NkGPZ8+dlffd23/9/6EDmTXFnGxJBRMjKTtrA1RFH4YU1IrDYrlBGcrQStSfzi9IpNrWl0RYwDDWu2tmFlayq5oTUGgcXKWCwsmFLHpQxaq/dtAMZoMKWOQSBLt2dUJD1HIwTkmMlGkefDdk4JMdvJpUyg5JyVpmw/EeXQFcsAW6rdKL3aoijeKZSBs9TjJVIUM308gS0RCmaoXZ48eXKEoSP1rljASYjlAmktaIVQIONEjhKkKQ4LNavpQiGURsRU1GWhCkSNcggt1OOp9HZKRXrvblBkPyKMAd+ThEXqSIwTSntykiASAgMiEKWlUM+BWCzFiEwikUUo/45EUmoNi4WzDAhSmmK7T/MiACDn0nogKIR3LYGqANmUQkRIUyDFieAccRyJLjB6j88DSmbO60vqRQPSIpgKjVloAiNJzLl/W9NPiWP3llW3Ydsui2V8SohKo+qWqhXUMTPGiegP9DmSUqKya6yBKMrzl/KbFCfB041m300MWSBtqd+wPuAHAWvD5RpkcLiuxAO0SjzvM9Il3gwSBo9cWuosGJVCisy5DSyB3mic0HQnj1GRqokMuSxFcs4s6gofEl2AxkQen0u+ussoo3i4hp1suI6J33400XWSu1GQAkyN5Ojh3HpWyrFYgTWgVACpcD6zHxLTKFnagE3Qec2U4fKsZ3zjSAtFQpJCpomeNGTunSde9gu2Y6BzAlNpdAi0ZFqriLKoPErOjQs+Q5QolTgExWqRuRCKXR/oBsUmDhyCYnkmeDsJlIm03jEIw6PziioodpMHaWhWCtGPbFcK5xL7XvHwviVkcBFe7oA5KRFCom4rXr/pefiwQokIh57zNeQsOe4cQkbimLnKFpUTFxeW69sJqwUqgs6RkANuSvRZ0DYJo8vCr/fQtJLjHaxXkuwzzVqzqjLXO8G2hTMTMFYQrOEsBZoqE7xHV6Vx4V2llTYKEUvkw/sRNw4cf/nHrMOIqNbEwzXHL35Kv7/BdxMdE0Jnzs4q3DSWz0IgR8GQM0mUzHcNeAT3Wng1eKpa8Rdf9Pzw2Tk/fj7wd7/76/fbv7NyIyRKqRl6FpCywFaXiwXOh9KukAOZkZwCSpVsojYGY+b8ohClkaKuEF4SfLkXmErS90eaukFpi/cDKYE2FVIEEOV+qpWhrixdfyhVjkKTRHEBTuORLIp1XZDKz1yW6Nq7ulZ3PLBZn5NiQtuK7fqCU7fHxRK/m3zkzdUNKINtKkKK3Fz/gru7T7m9/JCm3ZCT53AcePn5T+gPV6Ub+fo5Fw+f8fjRMyqlGfs7quYMu73H7s0XTFh+9enP+Yu/+gnH4w1KFjDTqbshpInt4h6VrTkdHAjB9c0V58sFkxvwfkJ6T1svygJfKCpdk5PHjyeGDPcffxdVLZimI6vNGaM7IkTF/uYF07ScK5oSlV4xhIHj8S1pGlisNmAbnj78iCQkxjZ0/YG1bUluYBINx+Mtdb2ADP000rRL7j/6IaI+ZzjeEPs9IQ40dkGcRkJ/JONRAibvac8e0rnS255zwo0TSEllLMvltjhKc4kwGmXo3UBd1aSYGf2ETplnT38AooZ0ohscXXdNP0246LFC0lQNwmxBb8n6M4Soyz1PKvKUqNtzxigZT68hBSotv9F9wuiyXKur4sCbElC1JTKlHM4Xyn+1rEketLJcbLfgM+2yxQuDTOVaHvsTyqyoqpoUE2OoECpj65pvf/x9TL3kFz/5fxVxzPe4ybPvjiyalvOzM2oL1pTzupKFCj6MA1Wzwg+JRVMx9Ce0atDLCqKbF4IGqS1ZVsV1mxKVMQTvmKaRtq2oa0XKRRTLZEKIrNYNwlSM/cR225Tq31qRCaSomZzHWIkLibops1fvBd0YCFGBbGmaGmMFbVtjlGG3v6E1knUrWSy3HPold7t9mVsEVDpCVhx6R9NWTG6gXTQQMn1KxGzQWrBsG/RY2EsP2pqnl+d88dlrYqiQQqONpneKP/3c0U2ej55t+MufP2e1XZFNy2ppUJXlrk/IymKsYL25jzGG9XZFCIkpRJRqyEBT1bT5nVgo0ffOAE1TZ2y1QmpFfzhRGUgu0KeBSEVWS9rNJfVyCXLPh6sFTx9fohTsHnyAdwMxCrQWNM1Mgt8YtqsNOS/JKbLZFBh44SEUR26zPqNNCSkmtIKL9YYcHTe7CR89Vs+RHavou1NxnlpDItFsNwWi+jUeX3vwrm1V+p2NwWiDn23eKaYZcFY6lWL07yfxyY1AKlZhQIpMIX9npITbqzf83/7z/zN/+C/+gMk5vvv9H7JZbQv5rl0gkPjokaKg8hGCSEbl0i9ZzepdTsWKlXMi+EiYYWkhJnTONFXpH5dS03VdsUxTHOsh+PcQkhDCbCs3MyBtfJ9hF3O3tDa6KMtTT11rmu15oW2nzDAUy7oxmnEsVR/vSOYlR2749ne/y+/9zo/4ox//BW4MfPTsQ/7BP/j7fPTRMxbbNZW1mKYpuQvnaJqGlFLJs0fHi7/4Cf31K37nR7/N7/29/zZNu6BqGzKC169e8fbNW67eFGDHhx9/zEeffExIjv/kf/uCTC79eU3LcQrcHW75z/+z/wtfvX5BQhelL8/qsFSsN1tCiKyXK377t3/EarWYKYRbpNIM41TyGcZibFuUOjcAGmM1TdMw+ThvtAIxJUbvCTHPWY1S5ZbzO4AXkMoFiDV/nbFPmcC8eJCiDEw5E7Mg5tmKOHMNMhByURYFhawvKPVOKYPUGhccN1dvkV8ThPCvekhtyMoVFTUm4iCRViCzQtaa5AJJJo45EhJcnK1YNZGbZcsHj76N6gKmqmGKtEKzMRWNWtKaNY2OyFyj4D1krFQoCSQWYkZoNSvXulT7iYzy5cZRuu5L3U4ZjmP54cwV9jEVJ0eh/ej37AKVim07xVwUbwoIr/TQZ3IKkBQSTUyzVSfncrBMvli2Y6kdI5UKpjw6QtcRJ1cq+qpcuu1zqdxAgDCCrCukTeSYME1ZNOScS22YLAKQFAphSu48ZV0WcKnktHNypLlXPadMzgFpbcnpxAqRJ5ACKQ0iFnVWyDTb4mcyenyX4U7M0IPCrEiSnAOCgBAVGYWImTxT5CUGZMlwCTxCWpAGWYHMCqFK9VmZ9RP4clBNMZDdgPcnwjQS/FRs5iJQ2wXbzT30YlFcHtEDEa1WxDSW97vQKFWj1Ro39dze3dK0W+r1BfhibZbWYBaexWSIfs0xZCY3EtMdMWVILdaA1JkQfv0BA6BioqoUl41C1QItJYdD5DhkxpiIMdEozWmQiEZhgifHjBGZvY9cLBR3SC6VL4tMWZ7/VapZeYepY/mMaKBuJOOUMU3mZhTYLrHUiUpkbK1ZbyqarWA/wNspU1nH723heicYosR1gdOUSxWfltxeeYQV1A2cvKRE/jNxyozKsmgDUiuSiJgUGJcrmhryyuBOE+1Z5ngIVEqhKknVVMhjYvCwWCj6kEkB+pAQPmCrRGxbHi0ycUyc6jKYu31ioTIuZFqTOFsLpqWi7wzxlDjcCdqlpFGJJCuakBiCYOgdY5JszhVnOfGVathsJV9+5nh8Zti00I+R7Vpz9TIzhkzCk0NCnBzCCoYhklPmdvQkbVk2IBaaVUrs3gz0debphSEjWC5MqcOKkm1yrGpoa8kXzxP1heBqNzH6xBfXimuv+E7rWFSCZlEThsTtMaK04JevYfVRUYls8IgMWpQl6vVVz2rZoJTi2A2kGAkho+uW2mqG0w6hwNhfIWyFSp4YE0N3pB9GhsHRn3qICREy45gQCayI3AyCKUAXMlYIjg4Ooyh05fuaN3eRp/c7hGrZTb++OyrGgRgVKZdloMkWY4pyqnWF855F25BjYJwcwQ0EcqEgC0XwpU1GSImwFcFHUgYlBDEMoDVDX2I0zjusEmW5Hka0WhaokQ8oYxjdBMmjtGBV3ce5snAXArw3JKmwoqKploRYomnee4RXIDRWWEKeqxxzYnKOGBLBjwilysE0OOp6RVWtcGEiUtxlcmfxpyuub17hjgesMqjFhnE4kSifheM08vjpliwFJ3eiu9tx+/KX5FCqfNIk2Cy2jFPPommROlHpCyY/4dww51V7Vm3L+eWW1dUKmpphtwMB1bLF4amswaiqZIjrDfcff4uHH/0Wx75jcj27F39G9IHgOrruDp88WgisUZhqS3e6QhpDUgpbN8TcM40T3QBTOqL0kvrsMXZRzjDN6pz1g4+x1ZLjzQvG01v67prdm79AIRDC4YTk/PIR2lim0xVJKGRK9P2BkqUfMNaShcZIAeldxZzlMFvpsy2ZaK1LlWYjFJebC5arLd/5zt9lEg1vX37O55//MSkMrCQsVw85dXui0FRVQ85LJpcZxj3GSIyWVCbTDzsIhQVhzTcbvDPv3HHlM9G2DZMfWWhJ2zaMKaN9iWJ5H5BK4FOZH3zIWBLNekGQGpE1MgWcCyw39wjugLIGSNy8/oyYR2KYiGGiqSqEVDxqm+JcTZBjRBlJSO+AdC0+JoZpQgiFUlWJgoUeIyUxB3KWTM6BPxFtRV4sgUzKiqaqUbKo0d47rNaIShOiQElJjILBQUBzd+whRZSIrFZLrAXhMkZplLTEKDgOHWSJNRJbKRabBwxdV7rWRwdSzmJI5O7miqo+Ui03c3TOgSpiRcqRFCe22zVGbcsAjMP0iv3pyHq7pbY1i2WiPirG60953k3oes0QBi5WS+5/8JjP3kKsVrw4OD4UW37ztx8zuQNU5/TyAUlYLs5qEApjCw9s0a6RSlBrw1oqdjc3LJeLYs3OkhASPkxk6ckZFk1N9JFhmNBKEZLnuN/hE0ipqSpDnPZQSRRuFkUESrdc3jujOx0wdYWtFwz7GypbmFHSNuz2B6SqsSaxWp+xkZa+u6PrdgzdiVW75LA7YRcS0EzdCTeNhfiuPW27YBg9tq4QQuL8iUCkUgu0+nrOqK89eOu/0Rtd4GqZEMvNUStJCA5rFJ//6hcMQ8cUIo+ffkTdLpBq7smOcVaoHb/4yU/4g3/xz/jLn/2MkBIff/JtfvNHv8V2uyGnyGq9omnr91A35wLvqsrIoLTi/HyNmwbGqTynaZrY7+9YrjZYY8kkgnecgp9z5EWhg2ITfjd0Q7FUQ3lRoVjL3w3N0zSVnt256y4Gj+8OxZZydkHVVMRhJDjPNBWbaAjhfYe41rqASaSgqlv+0X/4P+G/9d+543DoePzkKU1brEjvVPvy55fn8a5uTEpB9oFHH31CevYxWZlS1QTzYA7b8wu+8/1ILH0vhaSeEz5kqndKpxBloBUS5wdevHxe6MyqFN4rqVgsllRNBVmwWp9x/959Hjx8UhYnQFXV5fvThrOzc1IWpe4jjOXDpndYa3E+EJMkek8II8RQOppF+V7fXZQpF7hUIpf6hlTo5H+z4m2eyQmhQNOkVEQ5ww9mdVNKXfqehXqvRKYQibOCX0BSAiVg2dZ0N39d9fZrPbRAVBXSe8KUiC4SfKnPU9XsdKggGUXyjsWZYn/q0ap01vZxRIyCtV1QG0MlGyqzprUGlSu0KgMnWaOEptVF+dWVRaYC0xPSQip1WKVxJc3djeK98pxjKpU08/s5z3YYJRWZ2VItUrGSa0XSCZkC+FIzI7UuQalKkkNGilSs2+9o3EKUfFzWc71WcS8I70kuErqBaTyUTKUSCN2itCqLESvIRkOMCKsQrgzTWWiUtsRpgJDJViC0IE+pdHMLRQ6eHD05C5QWpCBAzBV0utSAvdutyFogvCVlCYzlNVJNGbJTRFCX7yOXa4RYFgBF/fEzqbxM6ylEpFYIVVRjkQTIOEMiFSJVxe6vVCGaV6aI/1ohciSjyCEToyf6nhATeYyQIi4HPBOSio1es1xeIlVFDLlU+yCxKjFlRU4RQ4aqpXULvLujH99y2G2x7RqpJQSFMBFV15i2pX4XeyHhwkSfDuSYCKmizgbJNyvyvj1kvAy0dWY6KiDQHRMPz3SpthMer+H2FBAx45VB5pGkNGf1hETQxsAkMvfryKQMRgtq5RjHSBUdjYY4Sj67E5gUqK0sh9fsWZ0bnJYMY3nt65R4XAleHQM2JG6RvLiThf6eAirAnWn5jg18KRTdPmAPhmgUaxkJBFZtcYusVWSPZT8JzqWjjp7Ba9qLhNy0iKPDVzDdBDbfrTl2kjQFRBYco0CFQIgZW5WWg4XJZOWYPPz8UPHQeIadZ+9gtYCaUhP16WtQaWTRKu52Aakz379fDuA3t4U1Ihz4APVKEmVhpzy8UDz/wvPtc0krIv3LkSkpPnspaJrEo1WkPwbk2QI1DGihOROOvRSsl3CYPLsT3BwF96qAD+Vw+noYwSjWKdMIQaoVnRe8unWsF5mjMOAyRglOkyLpit+5cMRB0S4NZ2eCf/kHnifnkTMrGLzkl1fw4T3N1dFTy0TOlpymEn0hEqbyuRZSYnKZcYrFLeUdw37HXkmW55d0vWN3s2d/6NjtO66uTnS9x48DKUemIOinTDeV7PLowQeByzCWvRaNEtzuRn70RPKTzzp+59sP+Kd/Nv3a10Rja1IufcQpeXLWxFQiZjDgveft27cgNevVBVlQOppj6fwu1nFwfsJ5iKH0qWcpsVVTqObBYWxFZQ0xCdAVViikLDDWmCPBJ3IKZCFp2yXTOFFVhnEcGJ2b7/+6KLMzwVopg2lr3DTSDwMxOXwAKJl75zuySjSmoeuGIn7kEgsbxp7t+WMefvh7LFdr1uszsqy4efMlctrx4vOf8fbuJU+fPuFwPHLx+Ds8+fC7HJ3jtLsmjkd2hyvOH3zIcLrig+/+Ltk7fvrP/vfoWM6TYQyQb5FGc3l+Rq8T45DpuoHPv3zBB08/4sWLX3H+6CHatBirCUmzqD1vrl9hrWEcjsThLTfXL1FCkNyR7fYe3iViylw8+C6n/UtSTgQ/YUTmyZPfYHV2jw++83e4Oe3RBNrFluPuFTcv/xJJ5tQdEcHjg+f1619wdf0r1rpFa83oDuwOb1lsLvng47/D3fVbpuPnDG6PVGsGD1KVz2LvJ5CghSJ6V6KMs0CRUyAgqaxhmkbGbiqD8hxBsHXLEHr87Uu+evEzpKw5v/cJZ/f+fXKG0+kWP/aszwLHvufBWcsXr06IOLEfHIe7HYQJKV6WP9M2pABKfTMwbelaVzgfUSqVEstQKNgxlzOLFMX1hra4fsSISNssaFuDJzL1E7XRHKQhoGjqBSkFpGpAijlOcTfXeklssyjQYDxNY+mHESkT/eTYdRMhZLZLTWUybb1G0KONIsaMVcVdGULEZFeqraQkzHPJ2J3wUZEiszW/nL0m59Em0NQWlyxawPG4JySB1oq2qbFaInEzoCtjTYM0mghUWiH6DqsVbbOEHKiFQzcZZ8+4u9szdAfaZUMWhiAnjBIMbsCNjlXbcP/ykhAGptGRI0xTaTlorCIFxaLWKAkpKoYhcbe74/4qk6XnV296mvWqMFqkIcuHLC5bfvADxTD2XOea7GtqAY+2Ldm23JwCdrGcIYwatKYfPWfn50ghqNsVKYCxgm3TcHe3RxtNDJqUE9ZYRlfuu5W0DJNj0TT4ao9wA1oKNJLke+5uM3VlSL5HCk0XjigKYFI3j1DS0qweEKYjzveklKm0YvKOk0t0wysq06LICNmgtWKKgWZzD2uqIhrWhoVZ0/UTXT8idEBIyfHUsd2eMXlJiJ62ye+ri/91j689eEtVuu+UkkxunEFFpcpCamDquXl7zeHtl9zeXNONnv/iP/s/8fSDx6zWSz754e9y/8FjDvsdP/3JT/n0s9J99+zj7/Df+0f/iOViiVKKpinffIxFUbdzHYRSfs4rxfnfJft9oWIqbd4P3sU+aWfLd6nwKn3ccoYaxPc/nDj/87u/v/u6SmmUknNXeRm2x3Ek58z+7o63X33J8nRN7o78/Md/Snj+isVmy3a95vzysgy+89d/N9CXr1Gy50JZLi8f8Oixparq0rs8Z5/fVa95V+z8KZcBJyXQukJvLkllhMQ7V3oDYyS9E2/fIc2ZM8g58/rFV7x6/hKlDbZtuLm9JQs9dz4KtK1RjUJpzXK55tHjh4Tg+PnPf8m3Pvke9x8/4dQNNJV+P1CfTh0+gK0ahBIIkWmqAk2LORXAiG2RspDKcy7dx8X1IApYLyZCyMQc58Em4WcCdUy5ZHNTnm06pZ+QLAg5I1JAElE5k0uLfck2qaLuClE+xArdXqBFqf9KudDZc0xcXF5+3bf/v/LykTaTyAgXQWbiNDKNE7ZtUXWpaEpKIYzm+s6xWjTYWjP4E3eHGz68+GTmFChMstS6DOw6SbQs35dCUVmFkhLTVCipEdKgbTVnrkt8QBZ5HGKx5ONTIZCL0ocbwoSkXMcoVRTTHBBZkubaL6kzKpZhGinL1tWNpaImzgAxEUFbyK44WGLJE5MlhDKwCitJPhDHHn8cCM6hK41t2tKJnUtzdumaUJAyUldk4xGiLH1SLHZ4QSEdkzNZCGIIKKlKxUgo10yIFhEdMRf4ksi52M1jKNZ1VRYRMgSiF6AL/AcJylggQZBIcnnfyLIsyRFI5b1FLNUt5AmiIMliVZZalhqN6AvBXwkwBRZITMwrnxK1cRIhMsk5YnTEaSSGSEoTKUVcLO9tqxvW7QrTNIWm52bFW3iUNEhpiOL9rgQpLEo1hNRx7O7YDA+wS4vIkKeAqipMs6SKmegcSRQGRQiOUzoQRUvILQv1tW8Jf+vjl13CAneD4skGdCVYNIppKHnUSkhqkTlblzx+DIksBccpMCTB9ZSorWJhK0Il2R0c6xTwZF6dYFkLvLBUJkGVUVnS97C5zNTSIETi3kJwmjTPrzyPWoGbBEOWbFvBT1/BExvYG4Vw0CF50ARYGC79xPrMMsoa3w8InckeahU5eM3BCUwcCULRVQblHd3byIsgqBqBFQEbBXsFnBz0A8lVVDLw6qT4YJNxUbHJE/VCs240TB61qtiOcJok954u2Jwy/eg5CDgDzokcm4rbO08fEj+6r/n0lwPWFNjYSkdOvUAvDd4F2irTO8G6yTS14E2QrIxAtaosOo6BKgtenAR9rqluEo9aw70zSSsVoofoPbq13KslF7Xnl1c193VCV4nlQtD3kd1YWAs6B/o+YGtLY+B0iqyNpp8y33lk+OieY5rgpDOuj9z4wG9/R3P3xiOzZduWRaRLGUHEnyIhlB7ptrXFlioS2gEi4n3mdOzpV1sWlxvOnzyFqsFrTTi9JgXH4eTLcB4Sp5PndIShL/fhmEs2VIo052EzMUlOPnOaSoXc6Ir7pZGS4/6Gy82vP2gkUeOGu/m+V/LX43jEOYU2BquLMhW8Z7d7Q0oJa5rixAGkqSEX0n7JuhWqcQwFaPluWRhDwIsCeFytt4iUCUmR8kR2uZgNRVlQn23u8Xp4iQuJxWKLqRzTVOjxtloiheRwOhRLbZijcqHUFknhgQJNrW1D7zw+pBkkBoRiXTfKMnR3vP7VH2DPnvLDv/vv0SzOeLS6QOVIri6Iv/oj7q6+wPmJ6y9/yk/cHr1+hDEN43Dg4vwRC5O4untRrMTHt3z3w+/y/PWvmJzD6PI50o0Hrq49dbVAKM1isWaYJq7319jFBmUMp74njAd8TOSQWC0XrNYLmvqc4fAG111xfegZ+x1ttaCqG46nHTF6ls2Spl0z9keCFlhbI8wz9revQSj2+2vGu2uur79A+Y4haaRZsjg7p2rP+aRtOA0dqn/OusmIvMLFxxydRg1vuVxK3k6G7eqMZM8xywf0ty9orCzDtqpw44GUc+m/NjVGCYxZMLrAFCIX23P2xyNGa9xcd9Q0Ld4NBBX44z/5J2jV0PX/KaZqePr0e3zw0e/z8PFTqsU5f/XZZ1zfPWdRbQlTIvnnyBho6gWL5TkIye5wjRIZP32zjHe7aIkp44aBer2iGwaUAB8Sh+7IdrnEGImqyjmli5QIlzZMvjgIJ28wUdCY0jsd0oSlQVd1If3bM/xiye31z1mtVshcWmd8ipyOE8qY4onUEpsD984uqFcrvHOcxmGuLCxxvGM/0jQt1ghCAG0b2tUFu7sryJLJDQVQtrtjGh0CQ91a2tWKD77ze5h2wdB3HK7fcDh1aCnYrJu5DlgTU19gwM7hc8YHw+XlOX3fIUSNtIrDvqOta/Zh5OQS+9s3uKknpoDSEje6EilpBJU2ZANnl5cgFDkekcJSNw1SlIVSzhFTGQY80ZUCVPDcu2ix9Nwlw6OPPiFMGZsyh+6GmzevWTUND59cIoXm6dOnrJcNMQZW2yUvX7wlpK9QYUCahhgdm21NRrNZNxz3PT4MNG1NXRm0hsvzBUjN0A2MLqNtRWU0OU+lxSZHop8gJSQSN56YhKBOLU1jIAm01hyOO5RdIOuKRtlS8+p7JuexRrOsNvTDiPceFxxaV7TtGtDk7Hhw/ykJjevvkMTCHFAKyUQIgbpuqR5ZxqE0A9SLZl6caE6nPULVxYnyNR7/RlTz4EYmykApBJxOR/puT6sycThxd31DTInl2ZbrTz8n+InjcUdlFC8+/5Q/+6P/N5XVJAQ/+P53efTsI65v7vjWt75NDMWuHpJkvVmy3x/eq9TvwF7va8tyoZG+U4iFKP3e1louLy+RSqK0xlqDc9OsmsLsZX4/UJdfV+TsEaIM3FIqlCq28HdkdDXbB3LObM/PCX4ghxPdGOnTgde7E1EYvvXJJ0ilsXU1W9cjORfFuwDfSt68suXFE1LQDx0pZYwtuelhGIpSHuIMhxJoXawkeV4CVLYCYOi6AoaLmaqpmbyfc6YlRy8knPYH/tP/3f+Bt2/vOL93n6auOJxO+AhGqNIpOva07YLf+OFvcHnvPs9ffMlPfvKTQkHMibPtirq2WK3Lm9a7Umg8W7uVZAZTZFJIuFg28szUxJQSGUsMoeSMcyb4UsPkYrGMqxnOl3KaLTGl6irHeYM0w9nKUBrJBLIvdn6yQmgg62Inp+RztVBMYcKHQA6R1bLFWg1C8eTJU/rDzdd9+/+tj5zm6ipri0VbRHzfkygHAR1rxOaMXgVScowpUCcFclk26rc9ShpC7EpthxAgW4wQKKmRueSbtW1QWmOUKQOW1gXaVVVF1YyUzLBUiERZ5GhJngLCzn3jUSJTKj3ctS1qtNRlCDcCOduAhdDFeqrLdYEs18S7jGWea/pSmAr1LOf3PdSiATHONu8p4LsBP54KmVcXAI+0Fiivt6rsDEMrx9/EnIWeKeTkotRnm5BKk8b0/rMn+RF8JE4RVWmkKMsakSZEaMrwreysMLlSNZR1qdqqZ9eLUkjkrNrLAgMDRPLlZpVB5FCyu6mQ1oUsYKQMiCiQJMgJ4cfyGihZbPTKFOeFNXO85h3fogCj4lR6iZMfyfN163ImipKpX1Q17eYeaj5IIssiTuRCSNbCYrUqmTRpEapGSINKCuf3HO7ecl63pZs8ZKJ0SKOxpoKmLo0FmVIxxsQ4eWKOSNt8o2uiqTT3FxBF5tUQEAf4cCvpM7x4FXnrBM82mSdnmcpHpFKkFLhnJQmIK0tGgUncHDxTyrweihsju4wymrUsy9fX3vLgDJarjoOLhJjRtWJ30tQVGK1ZVBmPRE2J+2vJ+ajJbuKDleDlnWEhAvtTxDnKMiVGKr/ncp1xGc4uLPsTZOfpkqe6XOFvB0zOdEnjfEINmeEUmbRku0o0UiB6Sd9LkvUEpWm1wHjPiMYrQd9lXp8iboRlH0qO1mf2g6euoeoC0wTHKNGnxPEwsvOJv/OtmrYRHCZFmBJ1nuiDIEhJDIJalBKCnGWhxj9SeC/oXIIwsTKwrgJeS+6LQG8t52vJm9cTrR35/IsIQfDhY4UYJtYJxpXmR8Lx47uK/9pGs7saaFuFlYZ+Au8liwwyJI6d5+evE7881bSNxF4HYi7D+bKB1aXFS9jdBkxbcXeMGCk4bwVxCFyqxKGxGCsJE/PivPS9phTIMaNUZuo7rq9eMfY3vPnsF0jTYGxTIJchcby9Y3ecOHaJYSxDQiJzGjO9F7iUCQkQGZcEwSeIECIFDJQztwNsFpmffRH5b/6m/7WvCWuXDN01QigWixXeD4QARpcaoK7rQCisqYplG0GM48yl0RAd5+stypyxP+xxvgCWjFG4gmwuS0lEOdcg2O1uqExFCA5lLEqXtgmFwkfHZ1/8siwEpcJNHRlF07TlhJRLPKxuWoKb35vThNEVpBExO6WkkvRuRArNan2G0YYUHf3YEbNEG4sPDjceCG9/yR//X/9jvvc7f5/N+QMckgfPvs35w2e8efEpX/7iX3Daf8Xu9Rc0fYdenPHg3hPW6y27N19QS0mVRmQr2N3cktI0dzvDMBwwui73MpmREbKMdP3IoTuipaSxFq0yVkmauqGAVyPXV7dsNwGkJSRP6PfU2uJ9z+iOWF3RVgsm5+jvXhY6fDbcXv0V/f4lCElIDpkgEub2n0DKgmZxDutHVKam3nxE0h03pzu++uzn5LTD+4nF6iHj1BPGY4lxGoE/vSaEEuHqesejpx9y9vi3GXZvON284eb2K5JPDDEWGvZcnRpiwthSJVbpCoEsw4jSaCI5e8bJQU644cDd9VfYesl2+2+XBqC2Yeo2ZK+59/ACZQ2721+UMyWRcThRN0tCiPT97hvdJ2KQkALagA8TjTWlWSUrdGVx40Ci5nC3o2kaQjZYI5kGT5ohv0oU15wLico2KFMRKQtzYuLekyfsuyOPPviQ4/6G4B3OZYbTCSkzbbNCCMlZ2yK1ZehPEEq9VJYZqyXenzBKUdWlzmwce+racOpP+ChRZkWKI7aqmKYetGZzsWUaT1RVxRQzv/zlX3F+/ggpBbfXb5GycJRSSDjfI5WgXdYYAwOwbFr6buTYddztj8QAdVCcny/JSIYp8PjBfS7PE/3pxNif2B+PSKO5f7ZGVTUXD+5T2YbnX35BW2lyKGfkPAXaVYMbHFLWOO9Ytoa6XuJDoKks09jRHztSfY6UGqUTQy/ZoHj18prv/OgHPLidaC+fUtcbshAYnamrC/7O3/s2u/2JF8+/YHCR4XSirmv6U+Tubs92u8XYwqzJJLQILBZrnDvRLjZIs+a4vyO6I244EuLE1HVcjx2NbZn8RHfsWK03HA57jscjTdNCTqzPzrk4e0jKHjdNjN4hrWY6XlHf+4Cbm33JkrcrKlGo5Cl4bCVISdEd7og5E6ahdKfXFX5y5OGGGBNaWeSiYr15yNCdSkwiJoTSVHZJynl2VP7rH1978H5HupZSljfUNFHbiuGQCNGXHK3QhCnw6fMv+eL5K3a9x98N7Idb8vMbvve9T/je975LRGLr0r/38NGTAosQmcWiRedikysANYghsli0xJgIIbxXq8NMwjPGzDb2gLUWa0tGsQysxX7zbsgWc/ZciHfLgzLIx1j6R40xxYqbMyF4uq57P9yXwbl8nXa9pn9rmAQ8+83f5vuPPyBTuq7X6/VcozGDvlKcDw9lK13XDU1T40OgqmvyOJJmpdt7X4BsgDUWN/dw11WN9xM5Z7wPxBBIMRDdxIsvnnNx7yFCx/c59RhTuQmmyM//7Me8ff4cIRQP7z3i0dP7SCCriuXmjLevn3Nzfc1w3POzn/yYp88+YrFq+fDDT/jBD3/E/QePSxYmBsZYFPaCiSgU1cKJniF7FJWUnAoILUWCnxBkQkjFJp4hScFf74UEUpbO43cqZZyzr4ICwxOy/KUoiwAtJd4n0jtbMGUAypSixpRSySjLspzojwcqY9GbdSGkJ0ghUOmvt536Vz1yFAhb8ubCVpg0EtsafxpwXjGEjlAveetOVJOhWVusyTgtCQHadkmcwWwuKpxU5CxJGIyCiMFo0CpjrEUqi7Y1kJDGIE0Z7pgBR7kSpDDnp5kp8HP+WTLT9lUZ/kTOCFPAa4JYfp8qUDKUIPk0v5RliJdCkJ0vdV+Jv64LSzPSIQRyrEgiI1QkeE8MI8lN5fVRZaEllUKhyO+o4SkhUolxgJhV+PmLincdtLpkxUX5bwVCFQh+JIUJoVpyngGA2iK0Kbl/4VCVJUVHDgp0eU+ImOd6vDlDrkx5PcM0cwKKpV3EQh0nFdeJtA0pJ7SC5Eo/t2CGNhozH2TlvEARZaGXbIk5iET25QCTpqJwR+/KcjEkQsyEHElxROst62ZD3a4Q1pCFwrvyZ8U5cy+VKLT1eTFiK4saDClKJt+x63csTnvUmQahyU4gbVl2qLRiGTM5e6JNjCngo8ZPB8I3bNjz3hGjJAmJ1YmjU+wTaCWo64xVmUomhi7TWIEkIoxiH8AgGQePz57tUiFd4NEW6gcVN1eZrg686mCREsYFLuzE7m0m2YQ3mvOFZLUQvH6b2PWezukZcBhZbRVvbye+d+75yyvL8DbwaJv5Raz41jJTNYKvOokMCRc8u1HwcJNRnWfdGoI2rJVmGgYmqxiEYWEiSyPwDUy9wBuJbARfHSJDjLRLwdmyYteDHk70lzXjKZDnKrEkSp90PwVSkGibOXaSWAlaUSB04hTZT4JOK75/IRhjxp0EWibsIiC9YN0uEGGiHyKpUhgk1DVLc+QYDMe7AZlAVrLA3VaKZATDLmDzwN2XjhHJF1caFGxXkZt9oM6Z250gmsS9+4r1zhGmTNVmhBaIpaCpNVZINpuaeOhJyfB739Lc+cxCQ58Vr3qJHDPjFPjs2uGT5DefCW73kbtdZIgS+pEoNddYegfHLtEYhQ9TGUBVKh2xShBDJLjAeOoRfqC6XFLbitv9LXe7CS0SY98xDYmhK865cQoMHqYIY8xMCSYPYxS4SKHupozOlAWeLou5pS48mk9f9r/2NRH8DlNXxBjmCtayaLdVAS02dc3kBlarc/ruSDcUuJYA1us11rRM7sh49FSLFXW7IMVIXWvGYcI7z/FU1FDm2laVBM6XjuacSitFzoKYEjlHtBIkdOkC15KUPKPzGG1LNWW2hFTOGjFFhNHkqbgQKmuLIu1Gckw0jS2QJ63phlKLpGS5I+cQUVrhXU8tA8PVzwjH17y+uubs8bd59OwHfPDxD6jXG66+/Dm3V7+iP1xT+4n26TP62y/xfkTXDfv9W4KfuHpzhR8HQgjFWiwlMY/cu/gWw3CEOJByRiqJFoa6Mty7OGPyE5VdMvqAURbRHbHLmmM30DYVfd/RtM0cfQOSIMYJYRUP79+jH0Z2p1sm32OVpVqdERPIKFDtCh8d52ePkGZBdD1msaGqlthmzeHtp2R/JHSvidMBKSIKy2n3CoXj44c/4MXN59zdvOXi4pzaNnjfk7Nmd/MlKkeUFIR8oFlIjLFkIRlOPZYzTv2xZFhJZdGiDCDRasH59hE5FdEH4Oz8IfXyDFOtcWheT5G7H/9zxtsv8MERXE837AnTLW29IsvS2rHeLMiiYZwGzs/Pv9F9IqWB5Dy2WbyH6GZkqZw1oBYVhMxytSAT2djigJNK4aIvPcvSEBPEFFgsNDlJbLMli8x0uuKLT/+culnQ98VVNo4n/DggrcVNAa1H6kVLlhpdGZZ6TU6JSgiyCCjdIM2yLNe15tiNtM0WiKzXVTlrhyNKa/o+ABXnl6ti9e7A2hZdvfv/btgdDmyWmimAlpoQHJBZL1aM/VREI2WIMSGJNLZBn59x6AaGYUAPjmaxwOqRpiqNQEJDFoEQI/cuVhgN27Vh21i++urV3ApjWCwfse96gphojeR8e4+b2xvOt2f0hwF32mOlYuw7UoIoF1SNIeMLjLayGHNBAKyUPLxQ9HFkpTSRyBAsb95esdvvC4cgJ9bLhrPlilO3o1qtCZPjeJqI8TSD1VpMJcjNijBp7nZvMOYK7wb2dzelQlcJYpiY+pEYBba2CCUYxo7KCoJzOBEx7YJT33PsPmO5WJRzpTbcHnZoU/Hy+VdkoTC1IY8B1+9oDAQtqOw9YhDYukCDm6o0Y6mssErwh3/8R5gqk6Ri3dTc+/D3efv6Jd/5jR+UGGB0VG1LItF3Xy+S9G9QJxZm1lAkZ1cG8HbB+YMnhFD+nWaL2VwgFyscmlU/UBuLQHL/yRMePX7E+v5TMgKlzJzzLECQnCM3NzesVut52C01HFprjNEcj3dAUUWN0e+H5nfEcCi56HeZ4DLshXkbyPzrZegu9nL/jp30fqHwTk0TQtD3w5ytlu9Vb60MCBi7jtsvf8Gnv/gc+52eldZ4H1BGo7TCSMk0HanrqlSreT9/HY21FSnlYn2Rcv4QShhj6PsepYqt1jlHItPUDcNQlge844/FyNj31G3Lk48/outGjqduHtDjXP0Qcacdn//sxzRCsL245O//u/+AqB3+cEeSNY+/+xtM/vv87Md/zPPPPmc4Hfj05z9nsV7z6OkzutPAoTrSrtrS95sSJT6eZ5VbkpUipbkPlszkS4a7LE4Cwf8N2FUqW3kl3r1G4n32GigbpJSL7Vi8A4TJ9x3iPk6ImGakf6F6QxmAEMXym3xkejc9SEXbNmzXDbZqiMLyzrRuqoahP3zdt//f/vCOJA1SKYSUJG0xy0ydA9PJkSY4iYlpFNiVZlEptEp0pzv2xztkiNQqIkKgGzpSc05KJWuHKpAylVRRdLUuCwgjINfF3pwlSkEmk2qDNGmuYMtkUZ6TTBQw2Aw21BlSzKhKE+fqrxQiWUFSBpkdKYnSmR1mp0fx6TOT6kjeo1VVlG/i3HojET4UyFxIpH4iOk/KAlNJdNOilEFqTfIJZQxog8zlNc8hgfeIGEtWG0AmVKVK/nxMxOBIIZDDUBYUeR5k3YRua4QopFvmnvLSoa0QqdjFYohz5kgCcR7uBTkEkGXwJWVELgQ6H0t2XAlJEsXNIQ1lsMYjTVPy4bL8nvewO6Xm6IouPy8JOUhyDPP3kOalQSCGQsJPCEJMSGlpjaVdnBUau9Lk0SPyMGfMQVCWJ4iyNU7zoK/lgsAdOXmG8YpxOKNeniFMgeOlCNJKdDAE21KHQAwz3CSP5KDwuftml0SQnHpJqxNdlxA68+nrxLlN1K3ggU30WaON4G3IZCewIoEUXN0Fzm3G1rA7OFqh8EPhNhx2nsulxAuPWSle3zg+vxM0RvFoJVhXgrdScTtJ2uDYLizeOV7dCh4sFa1O5MZyd0rcqzyyitz0AhEjUsGVN3SnyDpNNAvBaqk5jgldS4ah4nv3PW4XiIvMWZR4K4hTYIilXs+aiFWZ6BXLRcUnDxJWRN50mSaMPHhgGVKAtWFZQX+KVItM32RCyNz0cFFlooBlzPTRs2kVu4PgKCNP6sQbL9n2CSMCjZFc3XimbLhsSy+2yTAG+NUx8dG9kd1kmXpPYzRhGpFJoatMKyZubuGnB4MMno/uWYyIbLJHWUWztZxuAv0UsBuBSIoXN4LHS8+XB3j4UNNMgqkv159ZwtUhc+NrBIKLjWK3g7O1R7jMxypw6zNnS8WDB4p//MeJp5cCoyT7kPnyKEkazjaSmEvsoNyvZzuryARfFuVKS4Qs13OIkcMJhnDgYozEmKhk5u4w4gaPGxzHE4gYMTGXbnBdrjXvEo0prRP9BFdDuT5czgQBygu+us0Y4NEW/uSrr5fd+9sebbtgIc/Y79/gw0SKESkVfXeHkKWBRamavj/My/2Zc5Iix+5IzidSiizaM06HOxAGJRX7/QRIjFHYuib4d8KEnM9Yc7OF0kihCCSWiwUCwbE74UMg+AlbtawXG459j/cTqRdUtsHHgQhYXXNv27Bdr7jb73h7e0dMnu3mEqPLgfnq6hUhB1Isjp5Fu8a7kaZu+fjZt8ihIySFWjxEyQUX9yq2F4/RVctwOrLaPiRlRXd8Qx7ueHC+QY93nJ09pq8swiy5ufqMut6yXF3yVz/7L7BaEpMsCm+1YBj35DgiVcmsejchZMIHx4tXLwDI+Q7nHFVVI60h5QXaLJhcnPvEx7mWqiiiXbcjJ8Gx61ivNpxtl/jJlZqtOdJ2/94TnBDYas0wjgipkfWCmEYmn5FVQ2Ub2u0ZznVkf4TomdyAUnDqT/zVVz8t4oDWTGNPyBPO91ijWa8v2R3ezI0yEqsUwzCCKPHI0TkQEaSgsm1xRVaG4CNdd4c7vEQoTUwJmTPr9t+hPX/CYn3GWG3443/5X3D44r+iri39uJ8diSNGCw6HN8ToMMrSicT5+T0utwtE+mYQzmaxYtQTk0+lGUHO1Ui6KlWbQMiJZWtxweFCYuh6mgaGydMuaobekyUs2iXBl3vkJAJCVpz6CTeNjFOkH27ouyMxlYaYBdA0DT54mhTJ3uGFRBjD6BIhOiotMaq43VpbE1OkaRtyKv3fMqXSkz0GjGlpLpcIkfE+oXSNMGsEAXKkXbYF2qzOyClh61x4RdEjZcZNQ2lB8rBabunHE7ay9ENPbS2tlYhUnJpDPxIDfP7lNX3XoXWm0oYnDx/QnY4Enxj9gbdX+xJwSxLRlFmrlorVeo2bjuwPR5p2w25/KNDX4FgsatabM1AVp1OHkpLJ+9nlAs9/8ef0X73m4t4ZDx885Ge/eM3rF5rlWvPRR0/YO0MUgv7UEbLCdSNNbWnaikXbMJoifvYT1FahZKYfB7yMOJ/RKhOmE6dDcScslosCloyJ1XbD0E+omGjaht3dDTm2VM2amAVhGLAWtmcPUMYQfKAxmlPX4bPF1IVgHmNxbMqqIcz1etdXd1SrDTpk9My4iNlBLCpdmo7kEBFWc3XzhvbyQx5+9AGnbmK9WRUeEuXcXtX/f4arpQRKFduwD6Xioh+muT5HIaVC1y2N1CyHie99XxF9wNY1T559yObsAmsrnBuZJodStmQdU6kWiiGijS7VQDlSGTPDBhK3t3dlmyclxmiWy0UBisVYPqimEef8e7VaK0Xd1OSciNG8J5WP48C7vvFiq52t6ynhXNlU/M1sd1VVbLfb+YO6InjPNA3sv/yMl59+zvOXb4l/9FMuP/42utKEELi7u8MY/V49Lz3i8f0An1LE2kKdTDMxNMwAtfLnl9FJSAkhvs+tG1O6QLWSsx0MpmmiahoSovTvSkFjaoZu4OrNa/70v/yn7L54wbpZ8Lv/jf86dZXpux6ZHC+/eMXjj7/HxeUjfv/v/VsoU3HaHQhjycm6YaTf75AxsFl/QrNczbVqofTYlXJlpFL4EHjXMZ5lxIc5jzvXj72zQklR1MUCtppJ8Yj5QCWYpoyfIXRSlsNFyfTGYh1/B/MiIhTEqcdIiChsfY7WtmSUJYQkQGraxhRLSZa4VA40WmWU0qzvf/B13/5/6yO7BMmVAVYKlDUklajkhiZAyntu0omh82zuN/gISmRS0mhKxkia0nPt0oCbLX5ZNbgk0SKRkinW2yQKJTsrUJECHJ+zxZRcosiaPLu/RUokaUAWuBOUpU0OEVHZopyS3tufBUAKJKVJ0SGTJJsMvrxGpcKrdKgrJUGWA2xGlhqxHEhJgY/4qSP6kZQjpq1RqkJVFdIYcsjklEiiKOCZBLGowMKVKjkpFWSHUDUoTfKlRSCOvuTLvSkW8hgQwhb1XRQVPksQIZKyQDZV+fpaUtrTBBlbgE1CFRVbaAie5AplNYnirJFCI1UZWN/xEITKiFyUI1lVxVGAIYsyxAtpeNfoULofZXFhJAUpEPJE9JGcemL2xcqfMik7Qk4ImbCqom3WmGoxxzVCuYa8gOjIUZKJKGHKIpBUrOcohLYkliQOxNBzt7ujbs6pN1syhZBLlqVibNIoU1NVGYLA50hOkZB+fUstwOgzf3n0PFpD3RqmPkAOXCw0J6nZ6oTTgtMAgxd86zLx5V1ibQSLZWbnEmsvuTnUPDaeZpPxMVE1isVGc2YUMnnWz2pGD2tdPvuCLMu+05QZpGUxCM5rgzCBicDVjeTyDEwjeH4t2Go4jJKztWW5FeTeMzCx3BqWKZNyhUyeJmSOPvDP/jLxcBPZrCqGoLjtExsjcBiyh3UDXVY8PYfzMbHrMvhMt+upNpK7IaAUGBMIUxnipmNg0yhurkcuG8NhLNfHWwcbkUgu8nw0fHwGISYuLQgp8ELx8suRSmSaLbz8amR5obBRUgvBV13ilZ0/TyNsdeT8rGa8dgxR0AVBNpGPLooNv7KRvgscjx5XW85fO5ISxFYyZji9HOkHBwuFaDQqK17dTry5CygpWYyK+48UN7c1sk3oOnMaMt068+Y6UU2RafKkSvPZ80iztCwN5ACLSvIwJpTPbOPIXWzIUeBCuR5iyKTCXoQscFOJFCwqSdMUFoOPicOx+2sYmMj0M6m4soVZMZCIE9z2mW5uW1ASZBZsTeaNEuwCxDnz7RJcd3C2EOz2meHdMvDXuSamkZxPxa2lFLo9Z7l8St+9hTSCrEojQ85obankQF1VdH0592gpiD7iXIcUGqEkVdXAVLqJyaaoUkoTUiQB2lYoqXDjibmwgkVdk5CcxgFta2LqyBnc2KGlwRhDVVmcjwxuR8i+3EwQXO/vuNndMI1jcSJGgUt3GLsgSYuqAirr4qCSEq0UUlhC9Pzqsz8vTjcE3/rN7zLEolL68cR49Zxu6jGmZVFpnn74G7wi8uL1F+xPR/Lnf8Hl/Y+pNo84v/cBu90NY3/Nx9/+HcbTa0Jw3O2uETnSVIr92NPUDYKEZ3ZsiYRQ0FQNKcJ6vaGfusItMppFu6Rpt9ztrumPb1GCUkGaXbHoC8c4OkQeEcBme0HfdxyPO4ypmIY7ci6utH4c5sVJpKmXODegq5qmWXG5vSQjuP+tf4vsJ8bjFW/f/CWL5ZbgTqQ8IaTBx0QIPZCRVIx9N7/Pj+RUEfKEMYZVuyF4xSmNLNpHHI5vCW5E5ISPDqMNIvdoo1m1K+q6ImfB7e41N8cT9x5+m3ZxznefPqb++D9iTILT4Zaxv+bm9i37u89QSbBabhHKMo0nUsw4H5Dim2W894eOptJlwK0qvBtoa0VSmpw0p+OOzaIhxojNCmUM1cUSKTUp7tGmQrcthBI5qBrJOAhkEux3d4RYzhVTjvhpYrtYI41guT1nHLrZ+Rio6g1StexOAVtlmrqizrFwj7SFVM4jKRb4sNYarQvgWWtD1G2JaCWBkAElEloGsqoKk0cptNUMfY8SgiwL60Urw3K5Yhj64iixCww9iYrL+1v81LO7u+X2sIcsUKpid3cAUaIzWQisEVhT4VIk+0CWpW1KSgg5lxnESE69Bw4kPzGNkUiibbZI27I5qzFKk7cN+5u3hGmkXliMUSghaNoFcVwwhoBtH/CLr244/fEX/MO//4Tzhx+T+8Dm7B77rqNuLYMvf64WhsCEzJn+ODCcHKtVQ/CRVWPQtma53nIpFVPfMw5HRKU4nBxKnZdoxzBijSQ5wdQfMUoTsydOjraqOPVHpjBQ24rVYkWYSnZeZVnEoywwtsGIBm012lR47+gPO/ohUDcLpLGYpiKExP64R5FL+8PkqLSGlHj07e9xuHrN4CY2HzxjitBOjmpRczxck3wq53Hke+D1v+7x9evEmppxLHRvo0yxhrzLhc4xSak01goePP6AB4+fQs5UdYUx9ZyfFuVCquT8ZvYopem7jqu3bxBSEUNitV5yd3NL3bTU7YKMYLls5sw0DEMZoDebzbxlmqhrWzoypcRWlqoq28PVasnx2AESrUOh1k0TVVWRUpp7q3k/HMI8vOsyPDv315TfECP9cc8Xf/pjbvcnboaJV//yX/D0N37Ixz/8biGKxjhnmVP5IO6HeVNZXpDSc57Run2vyBcYnKKu6/fPRWtFJDOMU8m3zqp+FJlp8jhX/jqdTuSUWa0XSAVffPoZP/uTP+FP/8UfMu72PH32jN//rR9hKsWf/D//CQ8e3ac/Hdjvd7x99Ybt/XtcXt7nH/y7/92S957KDdxWVbEryWJPK9b5YpmvTLHm9qNDaU0DVLZ0eveT59AVGEHwHjd5lFQYcqm1Yq41SAFmWF7KsGwWCFncBxpNplR/ZQEplxo0WxW8TIwRGTJOCpq2RlULtF0W3TxntLUE5Jy38uUGGxK1lLhQhtacM+Svd5H8qx45RHw3IaVGGEUyAVUbYg60q4opLfCxww1xXrJEJIEQPNqskDEhI/NwqklZEEhE4VDRFueCjHgX0EJiVS42vlnxF8qUgL2CHEIZ0KUk50RyHrQgiXdIntlXIEsmXKrZlh8AXWo7Sj9uKsCed5A+WSB3glTy3rF0fguZyCGDSMRQcvXRjYRuJEwjkYxtV1TLuqjIujw3ETPKVKBKPo9U7IiCUFT5GfEhTYOsbcmXuUiY+jl+IEGW7HWW5UAltEYKObtVFFFHmECL8hpHNMhZsZelc1uiyMKXjWaGTCA5B7EA0TBQLCZF0Sw56/i+pzuhCkTIqPI6yGI1F3N8IWeKvTyVqrwc8kyJn0gxFOVeJITyxAA+CZSytKaiblfIShcAnCu1YzEmfIYkAiErMg6yQGYxx1kESpRaIJFKTvM03XI6nGGbGmEacnjn4DcoozG+LIqEyMScEFkx+F/fUgtweSaoToJKZF6+noqNTwk+v4ocXWCzUNjGc9dnjBAMtaRK0HWB80ZxfyPwWNQyU9sKnOOmz2xSYvd24uQFWkk2S83ZQrGqEm5UeA9Vo1Ahg5KIRnJ9DBw7xTgEbvaJBZ4hGQKGVioerSRnW8G6Dpzu4Ox+y9IFopb0IfLERJxWrCuNkoJmYzlNkEkspWffw6LytLXhbCuphsDdradeaDYrzfWN4GoQjEf48GLgYqP58g5+9AxOKnN3J0FHpBG86BO4kbubgK4FJ6WYRsGTy8jBw4UfEbXi+q0gpWIn1uuWaRpQteJqL0hI6uPEbz2SHKNkOQW6leHtaEm3kSkYzs4FaqeIK03zuqfeWvYeVkqRG4FeKMaQ6Xyi0ZFqhHpwhKw4CsF0F/nwPJN9xCxgirHUGGZotGO3i6zODOdt6as+2wjGO4EYFWqtWCbBv/2BRArY7SOHIXKhAq9Hw90x44cDdWWoTItMHqkoKs40zvU4kawyN7eOxlKsqrbB1DXKGqLzjCEyOU/KYFQZaIUUGJnZNmAdnFz5rPEzC2VpMjeTIFPKIGoB45j585fFRXBv8+sr3oKi1q+XG0KMxDhxuP1FcV9laJdr1usneO84Hl5j6zX98SVFoRnRssZaQ06B7cUTztZnvHn9GVpbFlXD6Dwy6/euMmvN+4W4qRvaugUS4zShdKkuynMriRTvnAWBse/JQhNyiY8pKUpO288wNUpOPseMrmpEzvhxR4Li2knlLBiTn5ezpWuamQZOhs//8p+i6zWriwf4QZHjGcEN2DwyTg4jEo8+/A0ePPqEl1/8lMP+huB6Fqc98sPfImAw7Tnbex9y9SWcrj7HmAaJwA0dlVVomTGmuC9CCGilWC0WDNNAyJGx32ONxSqFjI7jzXOG4ytCTDTWzNDXaa7wjERfVPwujQAchxNaFTeT9yNRiLlCtjBsUvIkwLlDYQVNe1y/47R/XSJbX/wZaMNm+wStFzNIVePdCBhImfX6klO3R0iPNCUOKZUgeFe63TPcujuIFVoZlBqxxoDUJYblepzbUesSC5C25nq3Q5CI8RYh4Or1j1m39xBmja3X2HoF2mJ0xcX5I87OHvL67c/p91+ybheEXByDgxsKg+cbPKScXSxKgJsQwjC6iK4SKkU2m3tYozgMA+PpxGqt8dOAaQrHwdoNmcAUJ/IMexu9x1iP1InazNWg3rFcLsvnd12zqFtEDEgBSbRkYXAxYqqymG8qQ/CCoZuQ0iMUTFNACUjKUhtJXZVu7snleUAvMNdumDDG0vcRpUaEVgxhIvUdo4v0g2MaHXVlONsU0FfKmUrXLNqaQxxwruPtmwN+OM5OjjVd1xFCj7YGKcIc26owWrFcLpm8mruoA1WaiCSWizOEtPSnE11/5HjcsahqNmfLAqP1mRA7tDKEOGErxdm9x+wPJ968uaaua6LRhAnGoStxj7bmN370u+QU+H/86Qt+8N2n1FoTxwMxBWxa0LRNqVILHh8MKU6storJeU6DJ3hHs6jIWA5HVzgVk8PamrE/koWmqjIffvCMVzcHvMsodU3Y37FcbkqtcN5jhKVuW0bXo4RmcAEhNLubG5SpOQ0Tzz56jBILdrtdIf1XFZvtGXV1wWq9oR/uSEkxuUilDVMIVKsFMmVWiwpMg7SWj370oDhnfCYRieMIRJxzeB8ZTj0ffPiQw77Du6+X1fs3yHhPszpWbMIxlDoARKnyMvMwVvqq9ax0lnxRXb8bcsdi2dYaRGZ/c8vN2zf8wT/753g/8ctf/pJn3/kh//3/4f+AT3/5C54++4hqrgCw1paNr1R/bf3Wmhg9Wqt5sC8D/bus83K5/BuDrkKphmma/ob6XA7/7zaUQgiMMbMqnhjHkRjj+4FeSsXh5poxOK5ubrnbHziGE//Jf/y/4X/xv/pf0j65T4yO5Wpd8mhGz4r3O5BbxrmJEPzcGS7eZ+bf1YallEquKnp0coRpRDctbirPz3nH0A9IrcpzkxJTlYH/x//yj/iv/vE/5nRzw+HY8ezZt/n3/6P/MdsHF/zJH/6X9FPP27sDfTbkqiVnqKuK1WZNVdfFwk9mGIayUEEijSbnRHfqyVIQ581fnhXtOFeQZApZ0CYKcTiXi1sq5sGtqDVKSULIhFB+7qQC/yIr0uxgyHlWL5UoB5VcQGtki7KlTkt7yWLxGKMNMQqU0ghRHAMhFcBQ+hvKBrK8H5WQ+JyQWcxHiW/wqCV4WWqhJoeQknwYqVYLhNTUdcX+8IbdbuIDnhFyJPY9IikylmwcSlrSrac1FSE6nJ8IttRykS06J3wMWNcTTVsGxiQKQC1ClpmcBMKLUrOVIiJEQCNDKgMnmpxL7YXI5bAfx0LfLhVxBaiUdQHmpCmWYTMXEm6W5T0AouwqHORYsvwpZHIM+JCI3pODI5NolktMZQqpXIg5Vy4QlSRlhUqiZJ2DR8zZxBzLEKm0Js+vf44Z78dih08gbekMz5iS4TbzczGS7CPJj8jVAvku5y+KgwJhELm0MOScEKrQ1HPMCBH/ehim2ONFDoWCqutZxU6IWJYcYgavKatBqcJOy6kMyoSyBJhjLMJHiIGYPD46UnDz+72o3T5SKkqMxFBRNxVa27IgUQJBIPlMjtN7C7yY63yUVPgk0fmd4p+JuiKGJcnfMvoju/7IYhhprIVsZhU+ASX3aa2BkKhF2b9E8c2uicM+IGKkk5K6kZybwJvRchMTj1apqNVJ8nYoS9g/PCVWreSi1QSl2UcxA+Mcz+8y3TFT1YLVmUYSkc6w2ijGLiHGhBAJpQQLK+hCiVc0VpBOIxdGIBaax/cMz06JN53g9nVgs4CblJEJyJmVLANYqzNtEPhK0kfJaBQcJy7OA6bWvL3LnNUCJw1VJRmi5/4mU5sClDwcM4s2YxW8ufKsxMi3LhOfHQz3VoI7V7qPX15HzKg5TYHzeQG1yYJRZC4vFENQdH3m43uJi7qA0w4Hg5oy0WXe3ETOvlXx/MseWwm+9yQxjZL+OnD/Uc0xB7KbCFowdIk0BjhX9FJx/TZx9IK/dx9Olw2PzgXyzuEmePSh5suvPGmIrJeZfScQNZjHlrMk0MBdjHT7CarMOmVaE6nwcEhcOEeL4M3zwL27gOg0ohE8emYYe0WTIjYlsi81QkYKHIpmY/jAJmQo186nk0Lg0aosiYRUxFzNS36JMhnXe5SQhNjzYucIqqeqBJtWoUUsRQC9x6pS7WhV5piKrT8nUJTrc6BArO41cDWBnD/zyo4u4SZBRNL7X1/xXjRrslAcTzfvQYvIMPMrBK5/zd10RcyZlAIiWpCaGApozXlf+JVZcXvzgsPhNeQC++n9VOSC2QFIhsl1RZkzlml09CmXg7GtkaoqTQvSQ0pU1lC3a+5ur6krzeQD0Q0oJFEAtkbPEM4QJXVTI6WmbWqMruiGE/vDEW0MKZYccmUsPkQm7xDJ0buRytSk4FEi0lSWYX+FUQ0rOVEpkNUSLQZubz4nRc/FvU/45KNv8aXoOZ5O5P0L6pszzh98h7s3f8WqXXP/d/89/vk//l+jFSXCEx1aKSpVGB+JiCCilKF3DiU1VaWoUwAlmFyPNRapFJVWLJctMYBz0wy4CxhbYYQgZYEPRUUugF5bFhayMGq0MdRVWyrjXEdOgdXqHDeN1LVhawPHZOi8YHJlGTQcXhGDB5F5dP8Rz558yL7PfPX8Z8gsWVZrQqLUiuaE8wOVtXg3ILJiHB2VsSQy3akv58noIXRoLYAlUN4XQzcgssRoPefYJUN/y37/Emuu8WPDIRYHXIgJpUBVZ/THG0LoeX7zEi2LGGSVxpjqG90n6sWGfndFIxeEEFFaUlmLQOHRDPsOazzaamxjmZLB50T2kdHD8PYVbWVYLRckIRiGACLi/EitSj2XUJajG3Cdw1YW101otQAqbFXjgmQYHVJkVosFp25kv5/oxp6pnwhSs2oMi1ajdIMyCjd2NLbBKBh9TwgGYyoWiwY9OjKKfuppKs3p2JOJWKM4DRN+6GnbhlPXEYLg8t49vB/Y99fUpx2mqhiOHVEEtBDUSnBzuKEyNTFXhBzxYw85MMYB0S7ohswwSbyPGKWx9YZ60aJyoB8nYvK0VUXbKISQ7A4nSJFxKrVdWZZznTaS9aK0EJmqpm4X1ItikRcIap/JSdEPI3Vd2phOLiF1IqSI0gJrJWE44bXGhYxCsGgXNMuWpm057k+cjndkMnWtqesF0XtkLg5GKw27U4mC3Ly94t7Dj3jyyXc5ne749Jc/53A6QopYU1HXDTEF6naD96U6tKqaQkSvGy4uzrh+/YKqXrNe1Qg0bW1oNOxuj2QhOFtvSEGwOzpc9NSLirat2e/uih/UeYZ94Hx7hlaS6DzGSMLUEVKgrhuUrDi7eMg0DYgssPbrXRdfe/C2tqhPabZPC5gp1FAZ814hLhkZTfCOVNDETOM4Q79cqXkKjul05M0Xv+JXf/kX/MWf/Ak+Zdabln/+T//vjKcdIiWUbHj67FslVz16mnYxd4YXgFh36sikmUiuaNv2bwDYBMMwMk0j1lYslwv2+z1QqtG8L0ps2zZMk2Mch/fD+LvHcrnk7OyMm5ubYnvOiamfuP/oCTdffcmr6ztudz0v3rzklz//BWf3zlkuV6xWK/b7uwJOm4fUd7VkUNTWcRzfD95lc+LRSuHdRPARORPPmauUvA9ztUD5PTOmvSwFlOTNyxf8xY9/yu/+/u/z53/6J9h6zT/8D/9HPPrkQyDzg9/6XV69esW//MOf4JNAC0PV1iBh6AcEkkXb4n3Z4khRsnRGKUZXktHaWGxdaq6kkCxSws+ZLoHAx4I5s8YSc6bKFVrrkr8BULLkbFLCmJqUii2N5DmdemIqwDQpyqIjAlqWHLkPETnnw621JD0vNZJ636CWi4BASJFMWZRoXYjXghlw5yI6y2JL/5ro/3/VQ7UWJEx3DnDlglUaN3mqxQKlDa8+f85fjUc++uEP+fDeZbmB7iXVcsVKadQxcRiviCmSksMogfMKpSUoXyquTMn3p1DUZaFysbfUvlR8yZlEHiNIRXIRUSXIxTlAKnVzJRccEZgii1LcBqQy6IuUIWaEkkgDKRYVOcWElPPAqxRZh/n3zQOrD/hhKuqJVtRtg1m2CKGQpkD+SAJhFJARMZW4B5lwGhBaoqwBygBOFjOwLRHHQHKh5CKVJiuDQKNqTRr9/H0VOJvIM7Rv58imKkq/nJcHORbQloGcil1bZkXMRSUqDQqyLIh8LNR+I0p+OgtkTmAyYMsCQEqQela2RYEXCUBUpOQgFJXNeUH2kRgS3kUkiTCVeE70jkgBU1ZSU9U1tt6g6kKvz9FBUiQ8cba4pyTfZwtLaDWTw4QQHiETRmmSCESlCDlymm4Y+kuqxTmYjCIgskJZXSCD0SFzjZpdIEvzzVwgfUw820ie30oI0AnNUjg+HyzfPYfDIfNGK9rsCCJxpgW9zxz68p5erxX7KTMOkVUrqGxmv4/0TvHhAqx1/PmXmm9dJF4PmrWWHCf49kXmenB8+7ws3vqsWcTEgzbzy1v4ZC05hMR3tpbWZA59IgJjcPzh54qnGzh1higk97NgaRMvnaSWCfc2IlvP0ina85r9zYQg0orM7nXk8SOLMBIvFTkkqiyQwvHyAPVyyeMHkrveodeabRMZnWI89qyM5u3JshGJS5W4soYqSbpd4rv3MttKEXQmjoKVMgUuqCL1heT2xcSiEahKcDg5DjdQ58z1nUerwDRmzh8v+OlfBH70MOAOEzFalFEsh4nPXxo2K8fhqHj+3NO0Eu0ibYJky+C/NpnoLZOKfH4X2LaJRw8L56TKsijlW8vdm8DlUiANTDeZN53k4T3LKgSujzVZRB5dKN4cLffqnn3vUVNAYlhYycO1oBMekzX7UXOpNE1dI7InDIWDIEWJelSVpR89gaJGiixZ6YCUjkqKsoSiLOGmIRCUxIjI6CSTh5zKEG6UoPOJHAR+/rVnS+i9YHSZKZSIn88ZISPTN0hg2FoxDT11bQkps2w3VLbm+vaKnAMhOKLzZamgLDE6pMxYUxoscopAhXcTi0XD+fYB11ev5gEuzpDIspQQcztGVS/Zbs7ojgdOXaF+ezdBnhtHKDGkmAJj16G1JISxOPUUWG2J0aOEmJkVYM1MfE+pdCCLklO2VclPWmMxKoM0oDN1u6Trj1hjShNMLk0Kw+mKlMFpw83+JS46quUlWWnC6S1aatz+mn6EqqqKbV1XTIcrXh3fcn7/Q7Zn9zHNCl0vcd3Asm2LCpo9i3pBZRtevOrwSGJyqCSQtiImx2a9xcVMiidSClTGIpRlt9tTGUmlDZVq8GleiipZSNe5iDDehwIY9gNaSIwWaCkQaaS2liHKQoQPntWyYdUssCbQHTsWtogU/dCRwjC7tyQ3t1ccj3uEMtSVImPwaUSRCIMrn/9OIZuasR+QwlPbluVqy6nryUJS1S0Pzp/Q1hv2hxv8tGe/L8O9lgUSODoHbkDbqoDMlELKMtxPfsQoiRaakMp5YNluOHWxKMTksrzO4IL717zr/38/NImqKS5FQaJpKqbJFVU/jVRthfeaOEbatkGqjFMWqyqaC4uUiuPg6cZiZ9YCqqWZa/ZGlFQMznNzW2IILWelueD2lnZ7ye62L5FXWaOt4jR1BO8xUqI0tOslRssCCpOWEB06SipdMbmE0YkURg6Htzx++ATmI8M0TWxXFd00gUk02qCl4qKqmRYLlMw06zWH48jbmzfIDGfnG+q2ZbWqOdg9i9WKaXRcX73l8vwCP3WkVK5xSY3IFPaMsWhjWWjwLpZ4pfC48USODmNbKq1oawPCE0bH2dKSpeJ4chgJzXINsgB+F41hdxgJGPaHke54IidHf+yZxo7dvqddLdmsLgg50w2gdWazbsiMjMOI1IpFY7BR8+rFa3b7Hffv3cOPHjdMSARaNySfcOFESBmhE227oJtGbnZ7YoLlsmVzsUHL8tn/0SffYTjs2N28ZHc4cOwdDx5e0FZrnC8gtaqyRJc5Hu84DHtqs+C4v2I8aZCCuwyVNYw+4n3PYtGCMEgM69USlRXZTWyWC2IE5z0hOKZxZAieEDztsmaYPEprhsmjcYQ+oaoG07S44esxcr5+aWvKc4632KCbuiqVUB78fDB+l2sOPhS7r5/o9jumqWfZWO5ev+bs3oOisIqaeL7ldtFwsVzy6nrHsDvw/Y8e8Xd+94c8f/mSkAMxBqqq3IDKvBln9a1scaUU7/PFf1OhDiEwjgNaa5rGcjweCTHMcLKEd56kypBdQG76/4t0/k7lPh6PJXOsBI1tiq03Jh49fcrNbsebw8CUM2q2urZtzd3dDeM4zV+7dHeqOTc+Ovf+197B1d6B3ZxzZcAQ5ddV3eBDyf0KKUoH3/x1YowoBMZWxDTxqz//c/7hf/AfYJcN7fkZlW558PEzEAo/f9AOLrHZrLi6ukNWLd/+zneKU2Gu/RJC8uDJE3bHn6NlGXCffvCEP/uzn/Dm9RvqesFiseT8bMtytYQMp+5EnjuzY0wEMpVRWLMg1JF+GJnmCjekJESJoKjeUpY+zHHI7zfMShcgjFYCkTM5C1AS29ZcXJzzrm89pvJzKr2iRT0TSpfssJYFLDGbrFOMZagkY6sCT1Bi7rP+Bg+pLWJRAIHjfkJVmv2hwx/vqA9Lthdrpq7j088/Z3IBiaC2FdpkWpVRJGAiqYgLsfRCZz/nAWtSaggiIfyAluUDE+cQJKQyiBiKAyUVC3bOs21bq6KMyzR3txbRVmrNLJrOlWCFGk8Kc1YEcqGDkWNAZUMWuXRXp9IdK5Us/bFZEJ0n+kCcM6u6MehaF6q4LvbcJDICTZpzdjkKcnAkBJMCfF8OFKq8HiKV/LiQkjx50jQSnSNnhZAWo20B6YkMuiH4qVSUBUGSESEMUOrkjNbEGTY4F+lAVKV3PheSuygV4ohUcuE5ZUQlSLlkFkvVWSqLnHd1ZEoWi1wuS7wSWygq+bwPKwqUExCH0kIQenL0uORARiKxVKwljRAGrTTaLshKIW1NTrGo/DGTUyBEX9T4FDCikO/ljNKL0RHRuCgRaLKUiGTIsWfyd+z7Het0HyUNKchCQxeAKu8JYio1dRGs+GbQnDGVhZnLia2OjFERs+V7jxWTAC8imzZzW1Wc3vrS3SygkaXyJsTM7i6QScSY2bSC/QgP68SQBKdd4nwZ+fG14sMmoLYW5Tz//FPJ9p4hvgncOfhwlfjSCRZLxbPzxDhCu2lJ/cTVkNgYeLySXN8pLjeeZmVwCE4ePj16GgttzOVz2mRkzkQR4DSRp8CpaTApEVeKvRTYGFkzobzmxVXAJDg7r0kiM/qIXlT4LLnbJ560UDeGI7DRhaDuUmKlRn6+l9yrA3KCaCV5EqyMJkvBr547TtqyWmfqyrJsivW07wSXC4vRiZcnxbkQVFsFB48PECZP1RrCGFl7T99ImkoRdonryaBMuf8clSY7j64kZ+uMD5GvbjxnwTEOktVDiTlFhtvAXilOjaTWcO9Jzeu7TD9EtheZD4eE9mAaxXpIMIH3GZEib24C25xwC8VPXgseVAExZFY642pN8IHKR27vIrXV8zVWeAylUaAwPIYIwlRIKVjrArXrTg4xZlzIdF0hlk8+c7EERYGnjaEsaK0WXDTl/vDVSRBSObynXP455lw4EWSKOebXX9JeXb0qZwBdA5nD8XZeOlNAorLEBIw2RZk2lsmNJaUcFaAQc5dI1x0ZJ/eeA6PmxaBVFSmWxYwyS4RecXv3FiU1xlpCKECxpq5IszV66DpSLCEkIxTLxQWn7ojWNVoVLs7hcCyLRCHK/5tBSzVnnxU6zp/dypBjABTej/PytFg4l01D1x2KkqotOQxE19OFDqHLksXf3tEPPSEnjDJM3S1CL/ABhtMdOUcePf19Fut7+HGPEJmqqtFinvNFxk8jznUoBMN4ZLNqEbpmt9sBASjiRlkcHFm0dbGVJ09O0FiN1XXJQosF7vACIxVC6/lem2dgLrS1IoREIiHVgpwjx1OPYF7kerBmwdvrW97MFZCgsEYX6rgQ8z1SsVpuSEic61hZyxRgmPZoVcCntjJ454g5cOr2aFm62t00kuqR7WZVIpNCkNLEh9/+Pb784uec7r5gtTzj5uY503RACc1yvaFanFFZw83tG/puR84C7x2VXZYlcoZaWHTVcn39JX7clXOCEGUBQMSY+hvdJ+SsBDe1RaotPmSqqrgHbCrvkx4/t7JIfIw4F4iqXI9aBKwQNOsaN7mylGYkywpRGVJIWKs4u7ggBTC6xmwbdFWhtCacepwHLT05J9rG4McBlCYGDaKwce5dXCBFZnKJEBN9NzAOHavVmtV6hRCKYfRzx71E6jIX3Tu7z/7umroSnHqHJHGx3pbKM2HZbjX9qeOwv6PSNUoaRNYs1w8gFxfx/cuH9P2B06lnva1RwbPcaJDNvOAvlYM6a4QOmCxQWv9/2PvTX/vy67wT+3ynPZ3pzr+xJhZZJIsUNctix211w3ZiJ04QtBvtIEaMAEHeBf2n5E36HwjyLgEaSZBOnG4PmmhZoiVRoihSJItkTb/pjmfa03fKi7XvLTJuGwWWDQfBXUSBhbrTPufsfc5eaz3P58EUmqaeE1KBtpo4juisKOqSqnYMYeSNN56wubkgZcW8WeL9wGJZ4ZNhv+25Wa+xeuRzn3uDS31OvayZHwZReJQlh/MVagz0w4ZsLU31WAYeVvqMnEdMYRjHQVgJpgQnvJ4UB6ytubh8JbZCHXFFRVXMefLkbcnPzpnalvRdx9htKYqCZr6g96eczQ8xuqR0Gusc9azCWs3NxQtSCsS4Zxw9+66DHPDRkYjMqoKrmw2z+RJna26u9tTLGavVjDEm4hhwBkIMaGXYbVuuNhuW8x5rLFfXN5jrCUR6dIAxFcMwsNtvsOXIbDYDPp0F41M33qP3xPQJPTxnKIqSslTiPwyevp+iu5QhhcDlBz9kbLcsjk8oSkdKiauLVxwcrzh5/XXOzs54+rm3ePfXfoPf+8f/Hdv1ml/567/Gv/rmn3HV97z5hV9EAFBJMvYmabDI2WVDJipVdbdVvpWJxyhgMln9S2MW/cjQ79hvdyRT0DSNbGQn2fdt831bfScydeccSSViiox9Sz94msNjTh89xP34GTYqDg9XFIVls1nT9wPj6Elx5Aff+Uvq2YJ33n2X2WLOOGVP34Lgbo87hCBvnFkmk6J10KgUsU6aVqUU4ziip2NNSS7Q/XrP229/npPHTxj9yJe+9kvSTDtHDPKGFWJiVtf8+q/8Mn/0h/+Kuj7m0dPHJBUZeo/WMPQd/X5POakXytKx2635sz/5I777Z3/JGDRPz17j63/j6yy+9PnJg1LevR4KuanZbDY0TUPWivOLK3ZaJsfWWCgsown4mJg1DWVZsNlo2nZg9OBMgbWOqq4Yh4G6KClLS1UVHJ0cs9vt8GOYJqOR3U64A30/SDaxUjhjp7gGP/nTDLNFTUyeEBJG60mW/tk67+wTOIeeQ2mW8uHZeXZ+zeX6ipddKZmi2VOUpfjjUqCuC2L2pD5gtMVWBSMjOht8CjRWpGBJBcBN9O6EMVPEVbZkFUnKom+vAZ3AGHT0kn2dBS6Xg8R5ocUHrpx40yea2uSLV+gCgYwFi3aGnDRRKYzOU2xYlKzScUArQ0wDJI1RBl2BsU58yc5gioIcRNCssiIZ8Xaj5XxOY5qGdj1p7FGuIkdPzg5l7OQ7lKOLvhduhUIGAE7UFnHMoDJKW4GeaU2elBcpZHSRSTpCEKWAyorsDNl7yacXzQ5plNdRwGsZpTMJabjIt8ciN8nJSGSgUlGGE2l6GrUMeiSLLIKPZBI5elLwJD9Mvr8gWdFJfOxKg9MWqw1lORcqu3ESU5cjeBlGRT9CEMuFDB8N1lUkVRJzMV13clM5miyDMK1IEYLvabtrSUGwS9HXag3FZDvQGWzCTAMPrT7bxvvESTTWlxrPtndscJwsZTPfJ0WsHE4n2ASWOlI0Fq8sej8yloYiKhZLzcUrz1mR2a0V7S5xgaWMhsODgrlJLKzClfDh5UjOmtNF4IOLTDtLfP5MswuG+QLmBK73Fp8VrvcQIjZD1oa/+ChzFRRfXBialWZegPdw9qhguwmkuaHbB5pa8d7LyINSMV6MVMuKMWVmJjIEzTBkhiFilcWESMZgiYxdYlVmUlMwdAMUJVWjSLvAOml0P/LSGmoiTx4WfO9jzdPjwEnpSErSK8aYsUXm/LznJikqG3i+scxs4M1l5DxpfK+oF6CKmtPDSIoGxsC5N3zpacWff1jw+eOBRa3otwp3qKlUx1CXjAYal3neG1ZZQ7SoQYj0H19bmgNH6xRvHXm2F4m81LA0zIfMsQv0g+GHH4/81bXjsEnUC7gZ4SgHsnXoB5lSa7JVDEPi4bHDX0SayjBEifDK/ch3PkqcPY4UWKqVZb6oUEkxdFtSLqdEgjyp7CL7TrZ3i8ZikCSBajkj+MBirtFFJNwExiDbajNZjbog/7/ub2+Q5D0uB1HHoDLWgtUK7/ME2gI+gzpKqSkmUWRCFLakKBay9TTCnFB+R56UWIUrGYOn0AaNZfQ9MaUpVUWRose5QqxSSkBCGTDOEnwkx1beb1PGR4919fS5qmm7kUwgFBU5i1UwRcnq9n6gdBW2kL+z223kRv6OEiL2HdmEa1EgWYWzjjEGnLNkNMZWLGaHeL9nt98RUsAUBSYrrDOM+5blfIlSit1+x9rvKW3J6fEpm+0Nw9gRQiION6SUqQqxV12ef5v9/ogYRr7x//oR1eyY2J1jrRJGB5mqdLT9GqMdXfJkdlijKYoZIXTkHElxpNASpxhixJpSBp2T6mzfR2K4FruBkfdWZzSFKSmsIgWI0aOVnENjv0erTGGMsFRUJkQ/KRc0GSu+15yFl9OLF9iHAZDc9cEH/Dhw4QeMdlitCcOAsQrvNSl4KlvS+hGlwSpHjJmb3QbdtRTacLhaMYxr/vhf/d/4hV/4T6ne+hLX6zVlfUJIiYuXfwnKcHVzgTMlOWtmqycEPzCbHZIRAOroE4U12OqQm/2Wrr2QxB6jMdbhyuqOWfTzlrE1RiliCkQV6GMiRzBaoVLC+z1VWWKNKCbRBfNFyX59gR81IWmUCgzRARWVs5SVRRtH22ZibAk+YFSJNpIUUJUGZTRD0LhySWIHBLIuuLi+4uRkiY6JbEpiSDSlIedbVaVhs7lBq8xyVYstzXeAZugSo2ox5Zw0GhQjNzev2G6uuYyJZrZgtVyx6XaobUsKAVWVbNYd3nsu40hVNhiOyDlx8lAULSmMxKHn5PgY5Wa0+x3ohsJVjGPCmIbrmx1GR8ZhQ1XWVG7BvFnhyoI8eg4ODkkx8OLjnzCbL5kvT1C7a8bBo+ycrh3ob/acHK8Yk+Pq+hWeyPHDI85WNTE7zh68hlKJ1cGCrGSpstsNDF3HUX1CxtF3WxKKmGTxCYbjwyOMUxwcHGC1Q5kenUuGMOBKS90scKUoKfuuI8RIJnLy6DUuXr7iO9/+Y0iW/f6GedOwPHrI8dlDUIbkB7Y3l7S7Na6uscbRhcBiXsOuFeBeWaBiJQrYrNl1ETeBrWfNjHFo2d5cQvQcHT9A2US735GyJqfI6nDJ49ffYH3+jGHsOD1dstt0XF7vsWXBbKGY1SXBFoTkib6l6/8db7y1VnKTO21rM0qaHCeSpRAD1hZ4P6KNyIdpN6RxZLftqQ9POPvcF+RGWxuZZDvHgyev8eYX3uHB41POnz3n/OIl733/XLXzpQABAABJREFUh4zFktPTB2Rgu93Sd63IPY0WGNdscUc3d87JUGAiaCsUPniZPhJp2y1h9ISxo738mMvzLWdvf5EYI7vdDkBgAlHgSTll/DjJo4GODqUVIQ786DvfZvPRC17/wud4/vJSNo7R80ff+D3O1xfMVyvqquLFy+c8++An/ME/+x0Ws0P+4f/mf8sXvvLOtOXOxBgY+njXhItXu5CvK9nixxQmN2aW7O2c73KrY5APy4xsxJ+89TmGYcSPo/hv1ASFUlCUskF78uR1DpcrMgUPH72OKx0hKWZzgdHFGOn7lsPjFV3fMfqWv/qTP+dbf/LHbK52zOojPv/5L/CFd9+hqBw+iOTVWoM1Fh9kqDCfNyxXc4krCQtmdcXovUzBAT96XGGZzWc0TU0Mh2x2e95//2NyMlTNXIBzqwVPn5zQzCwpZIqqYjiq6dseHzwhQVn0oBXj6Oi7MBHs5fxKuZwmw5nXXnvIEFtefnRFXZeUdSl0ys9QcR8wFVBozKymsQ6lLf2LHdfdNefXL3HW887T1ymsYrPeMjjoN0Fkj31PoWuUsgwEurRD5Uayo5UDP5BMQTIWUiSOAVsKiEypQtY3lROP2xgxKpEME308oXJAaUOIEaP0BDKb/NTKIABGifJSadpo6ARRk4NHlxBHxFOsLWQBHCmXMVmTS412hUwKXQFOidQ9yLRYZYcyabpuZbWcfCLlSOg38reTQgVPTg4wIkd3SC74MAq9HoVramxZTZnammzz5OGefKClRvVJBhYk2VL722ZcSL9EQIsqJycgZLIPoBM5GpSOd3wBhbAecpyijcggKAKUKad8c6T5R8lQIcsNUtaJ4JPIqQZPDBKXmGMkaclQd1qRqLAFOF2jncG4ajo2sXZkMiHIwFNu2RMhQ8LiAJUTVg3EjFzvVhF9idIFhBGjFWPI7IYr9kNHnQ5IRuBgKhuUSSQPLhtCRpKDzWfzeFud8OvAj6JD1yVvnRpKYLeO7IbM8zYy14qKRFNm+gBHc81gLDpFrndwtFQcnCrq2rLAcLhK/GSTuNl51iHz+UNDVA6NSOTKCuZzTREz22gpKkejM2OGLif6IdBY8G1i3SZmCj560fOLb1oeO8e+V7zaa/IO6kLx/KVnVoMKmYOcyUbzxkPL2EU6BzUDNzeasci0nef1CN5pSms4rBUXbWZWZkqXqXLisvXMS1hvRrqsqPrIPmRMYTnMAbvQfPhC/NJ6UJiFJVQFlxcDxweZVxeJB69VxBcj2zCwDAP+BvpDxfZS4+aOo4OSss4U3vNMzyj6TJUtmxvPW8eZ0My5JrNYjVQocoToA1Vtic5ymAKhS1xsMldbkXV+YRY50rC5CHS1o9KBdgNFaehtZB9h7+HGO5oyc7xQfOt92d5/5UlBGgzNPnE1BkxMFENklzXNSrPeRt461OhR4Y3l4AiKEq43mTk9KgozxvuEjy3zWSG2ipwxJqMLyF6xbSM2Z2ZFYGBkCFbUb0HsLKtagc7EkEFD46AfFUOGIWZ2YVKrKIknrN2kZHGi/ukNaKcI6jM03tlhNJLEkCULexzWVNWCmBSByGz+umhyQk9KI6vla4z+hsoYhtiIlzd49n0nQ4a6RGvLdnsjVhumRAhrZJCq5T4txcgwbIk5Ym0FJCGoD16unxjE9kUipIwf9mhfosgyBMwSsxWibNnrSkjTiYxSsp13RYHyYKYYtJgT6/VLyBFjBAAZhhbrSnIIEiW1vyGEEWsNq8MnjF1L1284WC5YbzxGK/oQUDlijSGqjFOQhjUpeMrCkdqBqtT4mCShIkW8H4QPg0DVbm15wXfIJ4m8lxstaQhOR06Pzogk1utz/DiQQsZYsUgVpqD3O4x1jEGae6WVSNCtY7U44mZziTUF1lkZ58ZANyrImapu6LodZTkT4r61xKTohx2zuiGmwM1+jVYKV0j2dkyB5eIQkHhMa0cKd8zlbs+4EahxSpN/XQkYVWe42bWgFKWL/N43/msMkSev/zKz1SkPDx/z9ju/wcVmTb+/pB8GYhjI/RpIjClTlCuMdZTRcHp8wIurD6iqAY5PMEaGwtpoQhxx+tOLZf/7KmSFc4btZk/TNFRFhbOKOAzYomYcR7qhR+kGpQSWNvY9GXkddA4MvScWmmqusZWwfsI4kpMVLlRZ0fYXNFWJNgVJF5TKkNUoKsrKYYyAeA/np8yakmFEvMtFwivDzbpHW8e+bTEZnC0prGU7BM6vBpRxhBhwxYy4D1TlSFVpiqrh0Fq0jmyvN4ztRjgIekDpTOkOMGZg3wrYMIVACDsOjg74yY9eUVhDjJlsLDfbLUUxsDpY0Q1wdbOldIaD5TFX6zXGWRbVITEm6mZBUTq5V4mZRGL0gZwTDx+eAoqmmTFmzXI549GbC5yuuTh/hitK6mpO5yN961nbRDErKFIkZIXeRw5WtdynhD1Wa64vr4XhlWEcIloLb8pZiZ0uTU233U6sqEjWltXBMVYpZqWoZtt+T+kcm/U1j548Zbfe4Izl8OwR168+ot1fcXX9nAfZ8+TNN9h1nmpxSjIlNx99CPs9pMx8eYguFxQzTzFb0sxqgu+4utiQlcU4ARRXrkS5imoZqIY9/dCx2aw5Ojxm7IzktiuNH1u2lxdcrtecnh6T/cjOb6nKgsVyIcvfBB//6HskM/BrX/9P2Vz9O6aaa2OmWCw1+XYDYfSkGKYGSyYdUYKeuX7xE3RhOXnyOWwzZ7vdsJw3mKJgbDs2IWCdJQwjfddycHJGVprLq0vK5SG//Ot/nYePHtG1LX3fc3N5zublcwD6ccAWJe989as4JxujFCNDv5+2mYLsj1HeuEmRcT/5HqqaR5//Ikn/rJ+7n3zoWump+Z3261lugFXOvProfV5+/wdsrte4+YzLizUZjbWZf/7b/5R/+nu/jS4KFvO5eFA2a45XB3zhK18hW0g5UThHjDD0A+PwieycaWsPMiEPIQlVfJJgT3filEVByonob78vsjw6FpjJZsN8MccYKx8uU55wUAqjFrzz7i9wcHjIm1/+CkppaciMmXLGFdKZRNp2zzf/4A/51jf/hJfPXmFtweOz1/iNr/9H/Obf+I9o5o1EQWWR0+dJcuuUY7fb0TSNyN+sY7WYM5aBqpJYt3EMkBNVVUyPLaFLJ81yilhX4YqS1XKOs3B8vECpzEcfvkIrEdf60RNjlDi7mLG6gCj+DWstTVUQQqCupMG+utpTOY3WJY/ODgWSMXqq8rN9eHTnrygWc1xVwUzexOvDFQ/0a4Ro2Pk9w/CKtx7+ArOm5MWHL5lVmWH9gri9ItysmVWHogZwitCN7GNkHj0h9pjCUOmEvdWKMxGyfRJgmZv2tnnasGYhckvmoBaZcjZYlSSOTEHyAk7TjBAV2cgwJ42ZZBwmZFJq0UmR2ijNqI6QCpFf2UK2KYWBaNA2i6/QSgOaYyLHhCocWQVy0mjjBCqWIA4dvu/IUTzXYus2+FFTOoUtnMDjYk/yEYLA+xQFShVklUQKZKbICCNvqCBZ5ymJpDUFi1Jhuq607BVyQGdR0MhHUhDugBcZobGaOMQJbOely54yRUGjpwGYXCdqkuWLVF9jp62Wlsiw6ImhJ6WBlES6lKS1RekCrQQi5myJ0gZTNjKEQDLBg5dNfR4DKQYyI1EVoBNOSWSiVRofRb6tQkARcaqgVyVBrYnJotNIO+7Z7a85XJ6QXYHxCWUTOVus9ozItayV4jPCapmPiV4bnreWtw+g3QUMifVocKPnczONCRGtFJetYlYm/NCjEhLTUWvGMbIsIY0JVyRGnwhJc2MNdUi8GOTmSYWMGg0P54rvfpSxOvH+1nBgR954WJCBdh8ojSQzyIbf8mMPb50kel3JuV/AOCZczgzdwEHjeNlbjmZwcGgIObMaPR9Ex5ceGMZR0fiO+qjm/GrkZsxs1oGiVOx1ojCZVsG+CxQpM5/BttUcNJmyT3QWzmziHM1Y1uyGjGoUhxlmC41zcLNLxDazv9kSMLyfS1yKVMBHrUH7yPc/SnRtz1G2bIuMSYExa2q1ZW4SQzmn8AOn5Yzr52vmj+cUlaUfEtc3mvVGs74RafUqWbLVFGXgbRfQtWVWZ1YzUM4w+sRMQ+gV213ANJa6jFw/G3l6BvMjww8/VrRB8fpRYruBm4sBBkNlA0/fLgkkkjVEL6kUfhgZkuOpTZwsPJ12HCwV0WhGL1LaMWRcWUxSV5GP1sGRcpCEBDVdiQkKoHaS7bvpoNXytdAjfrKYBQ6qwGq5qhOyie5u4ZtM74cpk61c3oIG/fmHtGHsUIWcjzkn+r5FKej6Pc41kn5gDJt2I9FESonSBsum3zFfHPDW67/Bq1ffJakNRpf0446jgyOGfpTB3CS/kYhBCMELCCxnUojonBi7G0A+K/QUBepsQc4DhZsz9FuKoiSRKLSRZYZWgBDQZQgYqOuGkMTC5Wwm54gzSRRw1k1Wv8kSpB3j0KJp0EayLn3wlGVBXRUMY2C3fobRkj0+jonTsydstxt86JnPV1MShMFYS8qWIY+TLdCzWB6SyQx9iy4s+32UYaxJAgOb4klPjo7Y7rYE78nJy+dCkhjIi+tnlGUFOeKcFX4JojyMqRNYXJToPD0tTYyRJrvtNqyWC0JI5ASLxRE+edSupe83+FG4RiH0jH4HrpEUADzWNtisSFGAvzkpQhqwRrLRi7IiZ0SRmScFWQJXOMZxoHAFBwfHzOszfFa8vPyART0DYwg50bZbPvjgz4Uc/fYv8fjsiyzmBzC2VLMTtrstbdCM/RXaGLoApXKUhUVrS/A7QughCxcmkYUjk2Hf3fzc1wOASp4QoKwa4SelSI6GMSpUVuz2Lc46mhpQmuiFHeWaJeevriQ+OCYOC43VCZUTaMMYEtoocnHK1dUlXQdNVTGMhjR6vB3kU1xptEpoW7OoKk4fPmXbevrrl8RxT8KgS4N2mpvtjqasmS9XJJ/QNrNYtPhYEpKhW/cQhWa93bdoM2OxtOy9YrfzaFvjmgXWSBzivtty8eIZxhhmc0dhxL6QVWboRnb7HUVRUc5mJO1olsc4AzkNzGcCLEsJwtBSlZY33nyTrhsJfkQbh3EzsWBow2ZzQc4DB8s53W4vcLK6oVSOOI7sL6+5Xv+IGEZJynCKh2eHOFdS1xU5RoZ2YLPZ4oqKrutJu4GYJG2oKAt8CEQUWWu6rmWxbAjDjqOTM6qqoqxKrDW02x1ZF+zW6ymFSZTIVT3Dj4HFSmOKClNGUghY5Xjri7/G4cM3GPqOwlhuNnsOj05o2x2EwMPjY4EPlwUhKo4PT2lcwcXLZ1RFSSDK4MWWnJydsus6/DigXcnDB6/R9TtWOFIeGAMknFhPcsYmxzj2EDzbqwvWbRTVc+gZ2j163mCS4vEbr/Phxz/m8vyCGD/dgPZTdx45xynDzuKHcaJwj7SdQInsRAM300Z3dfqYEBNFM0MpTVFU7Nue+Uwkv7v9jhQTzWyGM5put+bi5StevNjy9//h/5rTp08YvciIi8Lx5ttvsTta0rctl69e8vH7P+G//a9/wNnjhzx+8hhtDDkFdJKJ5BA8L549Z3+z5Wu//IvU8yVFVWHLmm3f44zImc00ULhrerU0KNPdtpC4tWEY9nzr93+PH//4J4RkeBgTD197Aq+u6BV88OELvA9UWqHiSFM1HD19KPTNhycYK368qioYh0hOkvuop800cCeVv/UxO+fAiWRaKz3Fc40orSirUvyk3mOdxcZIUZbUdY2f5OzW2jvgXNu2HJen8j05UzcNwQe22w3aZC4vLnn24YdcvHrFn/6rP6a9XDOfL/jqu7/AW+98gadvvM7nvvA2ddNMNyaRonCYZPBeZP3G6Dtpf98N8nUtMLayKMkovA8slkvxwCaZxqWsUcrw4OEDyromh0hVOnL0nL94xTAEqmaOD56b9ZYQMtY6mlqz2bYyLdaW+VI+3KvSYo2+ywF/7WmFUZrNJnF0dkDbdfS35ufPUNubLUU/UriKYlFiZw1mVrI4PuIJBk/CXxe0D99g17e8evkRT04PJMJBaTbbC0I3cnm9pTwuCB+M6DwwpganO+JYEMqMUVZYaDlOd4oapTI5amL2qASqLkmj3GQoFDoo0uDBKdlwahmIqZBQUeRwqnTkOJB2CWUNplDEkMg+kIyCoUdXJXn0ZGSbklWQY0mgCBCm6yWIbDnljM6aFEFZM93vJlTwEBMxCEhQq0QcxGPtTAFBtvcpAilKfF0Q4qYuQVcKZdJE5JWbI6UjOVnJB0+GpBw5jKhcyCAiBZQrUCmgM9KAxzB9DWlqp+tdq0SMCmVFHq+N+Kt1ViSthJKbQSuRE6I1yhhUFCtDilk2ETGTgyfFRErjxD+TzTVT5nnSGucsJmtUHnFmIfRQIzL0FDOKTAqBhCcz4lWE6MnKYCxkKqLKmDwxDLIMA5QKFAaC1mSVGFGENHKzv+RseI1SG7E85IQylhiCxKR5yIyf1qL0b6yugOttotSRfZ9li0ZGqcw4s5zvE6eVIwPFHFyjMYUihMzTOqOGxFgVHFeetsv85aWh241ULtMlOFhYTgvPy9Gy9ZG5zuzPE283WrbMDfS9ZuylEfn4UrEsM2cNHFQZXyueugBYwhhJCqplRVxH8IFlY/nOpeGkjhRj5vk+URtYnlgWQ2C912xbWC5Ejniy0MQIrx9p2j4RNVyNmmFMnG9hVib0LtEpQxs0wyYyoDkoFXFW8JMrxWoeeFLA+x9HPl8qolIsS4jDQNoHdqVipRI/3lSM65HlCWyDwirFgRthiveMPoOV97l9DuRqYHeVeO1zI82RJY+JUSXUfuB4pTlrYEgZX9QMO7nZYFD0gzyXTYzcnHt0iCzmhnpVEEKi7BX9q8SL68xJnWgvPXkXOCxKZkeJs0bx/ecRZZU011nx42eek8OSByuNNxbWcHUzYE3mG+8rTko4sJ73O8fgNF/+osZYg0UxzcHveC7WWWxpSIPHKaitwupECJnBy/U8K6BUim5kUs1kCgt2egv1KHySQVplkXSBrHAmU2boAhRWfnbMijH//J8VpihQxgnAzAfG0AuLIXpQPVV9zL7rGIe9bI21wcdu4tloNpsrvv1Xvy22lSARTK6ccXH5Md4PAns0BlHCebF9aUdMYJyjUBofBH5ZVSv6cUPwnXBVkoAyQ1ijdAY0BvFBF+WMoReCr3MVOcvAe9+OaG3k5rxq8CFMsamJIe8pqjkxeZRyJKCabrzlJrum76URj7HH2YAxDW27Q2lFjAPrmxeQoLSWFAcUsFod4sPIdifbYWPle/f7a1CybEkho3WeFhYywMgatFKs11fyOaiUqLMy+NCLajAHYuhh2nQJvkNNTBMDKqNVQgFWF6QsrA0huDeMYyfPYYT+8mOC77CuoqqXtP1msr4pQlT4GDg5OWa3b2m7LYSEcQ4fRLZcVBXeD8zqBlfW7NpWBtoqThYp+Qw1WsCg65sL2n6g70eM1ez6PTrLULgoanabF7hCc/FyRUg1y+MnqKagzIk3X3uLy5sVN5c1pRrAGNq2Zb/p8PtnnDQly4evEYaOq5sLZuWCLsDl1TP80H2mz4nkOypX0eeB3fUF1jm8q1lv95yaA4qywCpDYatpXF3RjT3WGh6eHFE6i3Uy7N9fX+CWc0Ic0WGkGzqMqahdwU20XNz0AgouHIv5AkgTyLYQu0SCzdUFWRkK5zhYHWJNJE6q2UcHFW3XY5ih6IAK9AwdPGeHhxi1w2lD3ZREYNd6NuuejKYsl1MKkCXFxOrgAOUstR+Z1TWWRN+1KFewOjgh+MRyuWIYeqwtyU4RfU/hFIla2DzR46NB2YInBw8wqiL5PXnocY0iDWvON3uMVmgUzfyINPaY0jH0PVcvX7JcrtDO0Q8BkwKFFStJWZUYU1BahbNwtd2Tsuf07IB217FHppHGaUrXULglwxgYhwFSZLfZ0bcDQ9dSlgNVPWcYFLaoKGegMNxcX/LxB+c084qT44dcXd2wOj4RjlXTsN1s2ftICEDX0jRn5HRDjK3YjcaBWTVnt39JM29wwVMUlnbf8953/pTLyxuKqmI39jx9/CZNarBWQMBVYYCCxfyIruvodj2RHm0sZelksZUVzazBasN6d0nMCZ8jjx6dYE2m2w+QM0PXM+5vGIJndfKUzst65tPUp268Xz5/znx5yHwxn+LBMihHiplu8DgrkRNkIYwHY9AhklImhAEQYmfbe5k0JtnoYAM5DoRo0QcP+cXfeltk7Dnd+YeHAWngnKOez3g6f5uX5xcMl2vWuz1fOD6VzO+yJAMvnr/km7/3e3znz7/N3//P/wGvv/tL9H1HCCPeB0mmMooYRcB5B4ULYfJLiqRNK5FsjWPHN//5P+fP/8UfsukDr731OocPTinqkoOnT/jc13+J/+v/8f/C+fsvqKuSN54+5uBYTmyVCp69/xN+8L3v8zf/zt/h9c+9KR8czt7B1WKMd9t3iWVTU8RZ4Dbi7FaSrrTCWsfBwQExJZkM+zD57vPkaRZ41i2kDWQ7HmOmLhvZbiuJzej3W777Z3/G7/7u7/LRBx9DVLxxesb//O//Tzl58wmUC+YHxxRFiXX2DiRlJkm8D1G23xMMaj5fiIw+BKqqpO97nJPsdJRA3LwP7HatQEwyOCfRW9ZZrHNsbm5oWy/gLGOYLSTzMCuomgadJd4p5Uwza8QP1kSqurx7vqwVwJ7Skkeak3j1V4fHZHWOsYpxjHyWGskoH/DDlrZvKW5aZkeHFAc1i+MFb6g3UQvHd2Yl43bDhx//ABve4Oz0gGwrBlvQbq547/kNx+MU5ZQQWXku0bbAMkdTYW1DUd1GiSmSH8R2oAtiiBRWT5AwTcYTB4mBUNGT8gSXk9OdYJLcSPgkOc5abr5SL0O0HKdtb4I4tNOHU5Im0kOKGTs1T6Lp15LfprQMAZCIMaVKlMoQRlIMxGFg3PZCSA0KrRNWa9lYmUQOXpr+EKUBVwGMxRalwN/I4te2SqwXyIY73fq/g3jZkx9RxgoYzjih3scMabr2SRCnazyHyd9ZyIPTVujvONmg5zRR0zPKyo0PKUt2t8pkbSYIoOSah+CJY8QHT45RHlMWqbgxSPSeYoq/s2LLMSXKSBxPzlk28FqT1IBPfoIDSqNfTNN6pcG6Ch+mHPKY7943UxrQqiCZiAo9MQ5s25fs92usm8kzlxLJZPIUjZayIUfN6D9dDuW/qeaNWBjOPAyl5WLI9D7R1KKGsEXig/PE2UKjEwzR8NHHA4eNpgwKk+HgwPDRGs6vRyKZ5UFBZTLtJrLvPd/uDYsyUu8iu5iZV5aDmPkwGcbR8GieCSFRlfDuY/Botn1CGcfQZV7sFE9XcNMn5hjimEjeYzL0SiSrV9FwdQGnS8vFM0++GnkwA28SRc7ktTTx88KRdMQphWssh1Vm7jPdLhOGzDhmPq4coU88O8/MnGI5UzxLJeqVJ1dwEjPr88DRQvP+c8hO8dYjuGwcp8WMo5XjL34QCCZRVpGxtTAYNkXG2YYDo7h4NhIe1Sgf6feRw9caNpcjKSXGaCmj5yfPOmanlsOjhv55y7ZNHCw1L36y4cFbNem8pzWKPinSpiM52EQYt5nTGNluMz5ndGlxVWJF4qAxPN9mbnYKbODpInPTQU1msJptVBw0cHCo+OHHI5e7zFcfGVSvsNagfeCrrxtMLohtzy8cJzYoiePUBX7b4r1YM5QWj3DuI7OZwYTArJze1LKicpm2zwwRukEyCgqdCUpjksTbGCVwtkpAt9IsZUVnxLpChlUFZRamwz5qbFa49PNPpLQTYGHdLNjvtlRuASnS9ZGQEglL1cxoSvHu9mGk6yCM/bSddzit6aPIvm/vVWQTmZnXC6pyxnp/TSLhJgVQjJ7gA65oyCpTLR9Kw5FqjC6meyxLVS7o+2tilIE91mFSwPsOV1TYGJDYWDtFLgZiUqTkGfr9dF+SMabEh9sBoADhrDZTMoaHnOj7LdYW5ChKRNKIcjOcFWWRRDVmyvqAdtiQgjRbbbch+RHrDLN6wTj0qEJNAwb5LFTKoiYORkoSXUrKKG0kZjYGwpSzbY1waQTQaydeiJGhtdZYW+JtL5Aup8mulgztPGCNqLhyTPjk0Vok5GG/JyePMUp856mjMIbZbAFZMcTA0O+4vr4Q2b5zvP7mA9a7wPnlOdY5gc8lZBDRt9PjCwJH1VkUUmQqq+klRoa23dNUJShHUdQkMn6U5J9ZvUKljplOmLilv/wJBwcnNLMTuqElpgEf9pyfv0ce1syXB2x2Wyqr8X7GfnfDsqlZHb/O+cuPKApJt/HjZ2u8227E1YEcR+q6wlQFOjmq0xOsKUGLAnVMcs07Eym1oZnNuW57al1gCkk4qg9OQRXs2i3X6x1HiwbvI5eXz1mWhm6MFOWK48MFpVUU9ZxukK3tMCaaOuG7PbqZ0w+JsmywJlDYgq7d4JXGVDNGv6cwJd53KONQrmI3inx6s98TY2R5cAAMDF62o3Uzo6hKlErUdYPCcLBcstt3xBAZxh6NYtYcsdvtp8QBUev6MTGGEWsUIcgwqJktiGS08VhtSeOWXd/RDR377Q2r5GnmDeP2Cu0K6uUhu82O+aIUi5u1PDg74ebqpSxwTEnUFp/knvnB8QkxBtrtmnFomZUV8/mcjOHw8IAQxZK4XDakGImhx6GgMgx9D2pFQhR8QxzY7SUpoduvUVmjrePR4we8eBbY7264RMCBN5fnkBXXFx+grOX0+ITL85fMZyv2+wFbzVjWJ+y21+zXH1E2M1IIxDRjefiYOOw4Pj7g1fk5T95+Ha1rdts1m5srQsy4xZKsQWHRKfH84/cnmJ6jrAqR0mt5H0YFSluTlGe+WlE0M2KSRCs7k0Hbdr+WgViK2GJB8Im+27NanXyq8/9TN97/6nd/h1/5j/8THj48RSslZPCQQUVmTT3FeH2ysZWbSJlC325flcoTEKySDGcyGkWKNSlEZkbw/SklvPfi3Y7yRp6yEHh9P2AKyzvvfpknTx/x3e99n/d+9CM+/84XcUXB7/7T3+Ef/zf/GO89q4MVT996g67v5MZZWYpyah4nydCtJ+FW8h2mzGltRDbxwY/e4y/+8Jv8+Td+n+wjX/jyL/M3/7O/x/ryGR/96Cd0Eb5+9IT/0d/7e/z5N77JzYtznCqpXMP11Q3bmwsOH51SWMMf/PbvcXx6SlEVWG0Iirvt9k9D4bQWiqvQzsM0vBBflTYGYzRXV9cC3ZoytJwRMFwmY50FJFPu9vUAadjLqkJp2O129G3HP/l//D/5w9/9fbQxHM2WPDh6wN//L/4eX/vNX+DiesPLi700XmT6rscVTmRIMRJiustN74cBqzRlYfE+Q1lS1eKbd66QyfoUP5ezSKStMVhrBBSjFMEHuraT+JHgGQbwPtB3W5pZA1pTgjQlKU1SN8nQjDGSYoRJwotSOKuJKQtYL0VcqVhvrrGFULY/CzAHYHF4RAojY9/i/YAfWsbOU++WNA9mzJdzntZv8F65p02t8A8YeH7+EQu3RBcVz26eM6AoKoVTk5Q5B5R2lHZGXS1wukRb8QErlHjYUiLngIoD2hTEzoMtSGoUkFpMmMKRxoAqJgAblpRGsWt7mQACZGvIPqCKRB4ioFEukKyWLXoSD130Hu00OkfIGW1Laea1gjTRvXUiZzl3VR5JQbzOwXtCHwGPoUKZQQZfRqFMKTfBfcRokUwrCXpHWQ3WoJIiDoHsI8YZuXFTYCuDVla+lwSZKdlAoW05DR6Q9x4fSNqQh0hWsjmPYXrOtSUHublBFeL7NEByqJgl9xv58AONipGUNaBQKZKnPO4cEpGBHAMxQnaaPAwYU8iwURmKwooPW02QNadlSKDFCpCVwg+eEMXvHUMkZyHJo6Xhd6ZESOsid/cqyDYmRAKWqLyQhrMhJs22X7PpNyzSY1lq9wndJNCZrKMQ55NFqc8WEzNvKmrreXadWbcRmyM2KlwHO1PxcD5yWgqc7vxmJOxaKidDvMudfE7sXo180Ck228RRDXOkoV1aQBletbBA8Z1ry2tPCqra8GL0NMnwYJGoFop47dEYLrKcE28eKm52iaKCw2jZ9In1leeth/BX55pHp4qLDfQvEm8/TlxfeI5qxW6b2faJp2cFl0NgHMF0Ad8lVseO+iyw3ln8AvousQ+auQNrCh4djXx0XXD9fODoAH7x1HGzHWh7zU0XeLxULKtMUppUGY6bTG4sjUp8+GpgmYCF4dXFyOmZYlYZzm9m1BreemOETaYbFTGCri0hK6raclBArRXVY0sMBbrvKRfwdm3oouLi+x2LFeiZou0zZVYUGrqF5sXa8vpjS+gD2XtqazlqR1RZYIbINjrK0dM5mJewy2CT4ktHmb/cZC4GuNwmzn3BWzPPqzaxqKHYBdo28f5OcZwCthafvrOa772IrFv4fK3Q68CfD4qvvJul2VXSLKMSeoJJGhOwGqLPdF6hDSiUNAVqGmA6IRH7oEApQpZ7iBjBp0zMYusAAWgVEUBNucmZ2kE/Nes+SnzPz1vOaGbzx2AWzBZ7+u4lMcuGxVrFfKHYbF/hu5E8xX3FFCnqGcF7Ykr4TuSnPoiSozAWayriOLAf92z7HTlFlDa0bQ9atnXWOvp+T/AdOotagJyoigKtIkPyjMNa7Ep54lWkMCnyLCFPSS9KEkiUyyhTYIxjOV9R1xW73Zrtfov3nlJbJPlc7kVyEnm60QhYLCaBsxlLUR9ycnrI0AfsEl5evIdxJX23IfUXOFvgEyzmc/Z9j08KlRN+mCBpKeG0pSxnpBSmbN0KV83o2w1aKapyzvHRGdYZXl58RNvuRWWIkN2LXONDJx9jWuBeKWe836B1TdYRY8W7rlSemCGinCJH/DhIQkpwk3RZUddLum7Axx6UkpiusqYAkoEYPFlBTIYfvv8RxliqssAVNcOwwyiFKWoAQp4AqOmW8SH73xFNWZSElIGBfbvDuRqZe2iUztSV4/TJ54hBCx1+ewNZ8/zD74gVKgVUHIneExkxiIrPmJpxGBiGNbuu5/zyQ7RypDCgjGZWrzg8OPy5rwcA7UoqZ3B2SUgDqMSub2lmM652a+piQTk/xHdXxBAobUlQJettR1E6snV4H7i+ucIoyy6sufjoxyxPVlycv+Dy+Ye4ShPsnLo+pDbSpxgrDdZyOWcYeqId8b6jKCu0TsznEtvng0Ijn/F1M5dUoM25XJ9krFI08yVjgstX1+Qs6l9jHXEQH/fBoqEoHMOkROwGTwgtZVUweiMAYd9RFguGYSCEAa0GUgw0TcO+aynJVIWkqYSUKbTGx1HSjLzH2AJjMtYojh48IUaPq1dQbFgeLAnesB89hbfUdcnN1QajE4vVgnHYUVYFziwZYqYbI1olsW0oUE6sWO2up6oN7aZjcfhQ+ohSs990XF7eELPYOouqJuWBkCBoi7U1l+fX9H0rXCXn6Pdbzj9OaBLGivpku93Ke5axXDy/YnVUY48bFIpx2FLWFVU1J4WRo6NTut2N3GsqWXacv3rJbrMlZsh2RsqOo4MzYUFlSR/K2mPsMcpVpLxhoSo2nFOWBYUz9L2X+1Dt0aYUwF5UuFlNZQxdu8MY8PuWtt3iLFROMwwBnVtQc1H0VO5Tnf+fuvF+96tf5sHZASkKKdRaexfbNY4DMaZJtpOn6eNkSoZpA2lJaXpzVxoz5XFXdU1ROjbrNWGaOMcoWYHeB7qupSjEH1w3C1KMdG2Lzplv/9E3+da3/oL56SmlKzg5PePP//RbOFdgjOVv/u2/zcHh8k7C/Un0DxTOUdX15EMydF179zUfA9v1mt/5b//f/MHv/i55DBzUM568/hr/s3/0v+LhF17nvb/URPMtdvuWZz/6mC+9+zWePnmNZ+9/gCtrZrM5Qz/S7jsePH7Irt3yw7/4HqREnvKv0QIbM8bcEdVDEP9Q/qnnIXiReKGmZnxq0HPOFEVBWZY0dcN+v7vzfVsnDemtRUBrLxA0a4lJMlVcWfDVX/9VUhh59PCM5eEJb7/9Np//8udZX1+xbyOubFAK+q5l6EeOTo7ED2ss2jDFiEXmzXwi10fJ4raam+s12hgssuErCsMwylR9tVpQ1ZU01n0/QdFkcpxzEpqqtfixx1pHXdeTEkG+5n3AT4MHP46S7T0NLwQeJXTzsjAkpdhsN4S+p+tabq6uubi4YLPe8r/8L/6zn+NjQ0pbhykECOaGkTT0jGHN/tWOerdgvjqkeOgY/IhBNu5Ns+CHz9+DpaXtdrzabPnRjy95fPI5au2oXYFRBYU9oC4XOFtRugJbOFRMqKJCk0lOiPb4Ee0qku9BxUl2B0oFYggYK0MyrQpSGGWzrAqUkRxtpcTXj9GTAkUkeyrJrZMyCUwi64hO4qVP1kAy6CzNrgKyiRAUyppJrpzF65wMse+I4wBqJGLQJkMu0EpiVvIkCcza4/c7jLOyzUgao8VTHkUiI5AgXQIGxh5lS3BGfO9RS+NKkmOJkK2SjUsQPzi+J0cvUj0ixgiY0agRZT1kS8xa5K1ZtsuYKVroNnce4T6QIzkJlEkn8SWl0EESUnAOIylqjK5kk+IkSk+pUs6flDFlBTnJ85oEFpaVbMtjSowxEJS8T9hCTyqYElQSpYAOkAe5GUyQVJ5yvgeSUhg3R4c9Q/Bc91ec+Q6lK4w2KJ/JyUKOxCzNevqMVPP/wz+5+Uw/f1/39f9v9b/7L//P/6EP4b7u6/+nyhUlm3aHionVwZK2a5kvDxmHnq7zuCKxPX/FsgZTNrRDpl5Ks1m6ghQH9sOO2mXGYct2u2E77snnO0ZjqBdzqrKkqFdY21A1FePYsaiOBa8XBq4vXnBx/orke7R2vPX22xg7I+fE0PUyaCIxqwyz1YpXQ0u/viTkgKtgd/6Sq82em8srjhc1vnCErChrRwzQdhJ9BpGx79HOUrhCiLXRo3NF5UqKqqFwmsFbrIrsdzsUkcVyQbfbTYk0knWNUsxmS9Ca7djiCllehT5gCdhZjdaRZnbI9eUa7RyVzjhbYWxFswiA4uDkmOvz5+SYubh6n8VqidMFQ98T0Ni6IcdEv1uj9cg4lMwPTqd77wGNox09tnCcrI5p254xBoqyxKREbFtiDNQzQ1EvUVnx8tkHbM8/xI8bDo4PefT0TfabS7GVpoBpVrx6cQ7GUDYNRb+lXa9RuqV5Ij2dTz26KNlfXaLoWG/32HlNtZjR9yPDbiTGRMod89WKfndJitC1ipyuMZ3BlA5dFixWKwyRMHTowrKaF4yuZLO5xm8uWR2f0syXXF+t0cZRVBVxjCxXh6jYEmOPTpltv8fqkWpWc/ny5ac6/z914/2Lv/qLKGPZdxKnZYylcG6SNqZp2yhNpFITEELJSWGMmeJ5BGmktGYYB3KGB48eo4jstjsq52SqKLsrdps1KnmyrsE5jLXMl0Lva6+vuXj2krOjY2aLBdfPX3B0eMz/4h/9Q169fEVdNzx4eMYwSmi7TDidyMetRtsJrjZlYZZleRcldvPqmn/2f/9veP+7f8lcV7z+S1/i3a++y5e/+gucvfYEH0aq2YKjx49R9YY/+P0/ZL484MHjB3yumZOzwroC5wQ0MvqRpT9kt97fDR5EbqrvvNy3kWLlRDYPIQBCbUYptDHTQEOay5TiRDPN9G1HjIlmJvKPlEeck+zO27iy2636drsTGYsfsdbxzhe/yJPTE8a+Z3Zywmq14sXFmmFIUNQUmSlDtaBpZpJHDqSUsc6hdcJoCEpRVbVItybfurOyKc8gvioAxrvzQSbsCWs0/fCJLx0yhXMs5jPKoiCmLB5yrSnKAm003svzJ8MJkdiLakH+W4iRqiiZL5dQFVxen3Nx/ow/+9M/4Vvf+jYvnp8TQ+S/+q/+95/2EvjXKkWR+Ltqji4jfijxO0sIG9a7S4bQk8sV6wcjx41jvVlTr+bM1kusziyLBadHh/zev/g2637Fcf0OdXHMQX3EvFwwm69QKVM1tUink5pUIxpbaZEamrmAg3SJVpmU4hRsqkVObQ05GmlATQHRyybXFeh+RGmJ5QMtlNNswCBbixyICaY9E9k6cg5oJWCZnCIxg7YasgMd0SjiHewNom8J0aNIRJiyy6X51q4Ak9Emk6NsnP2wIwWLyTXaacyUGqCUwo8DrihRyRDGQBwVyglQjmxAR/woTWsqPeiGnLVs4dMtoFCBtoSsUSqirMZkSCliTU0MWUAtKU8KEyYJfZDnJukpYkzAQyoFyIrQT6ToSeGTsyeiJY4tR4xrRDZqCyHEGzBZNkkES1STlcREyUdP4ONAzgGTI5HpOUa2R0yuhJAzZIGzhBDuNjIxSwRkyCNoTZ92XO9fMMSR2lgSCoPklKekhAHgI5rPJjW/r/u6r/u6r/v6t1Uc9qimRNUrdoPGuYY4dFileXS4YLaquM6DNNmu4fhwTg6B/dBys26FIo+m9YbtbqBbX7NsxMJwtjxgM87p1ltmM8usLnFFSVHWxOjZ7DZcX7xC58TQXVHXM04fPMQ4w/rmGp80TVNhixLrGhKam4sLXj57H2ctZ2dnaFtwedVCyqwOFrjSURWael5jrGO7b7m6vuLiouX1p49ZrpaElCkLhx/31LXYIpSCfneOXSxRWRNQzA9PcFaLL3uxIGXDOIwYW5CSp6xq+q7FFgVxjKSYqGZz6spxs/F07Y14lqsKlMG6Am0bdm1g1hzRdzfsrq8IPtGOgcXRY7QpKZSiKCPrzZayXIAKzI+O6dodq6NTUo50+xtm8yU5wcFizl4phqFn3K9JaLkf0YqTszPa3YaycAx9BltQNQ2vZg3t9hWr5ZyQHRpDu9nRDR1PqgNWx8fMZo797hqfFEmLDfX5+y+pq4xxThp1At0oVpnaltiq5PDgmKvLK1JoGYeOUmU2Q089X5JVw9gPGB1h7FguD+ijZt7MOR8GZlWB3++ByNnZE4Y+8uKjH5GOvKRrGVEOFmWF/6CjV46qmdOHS0oVqWcNViuG/fpTnf+fuvHebHa0bc/zl5e8fHnBF774DgdHK6yxkxTplrId7qTczumpkWKCmAX6tqPd7+mHnqpqePXyFTl5sZ+mSFUWdN2e7/7xH3Pz7APefOMhplxw8voXcIcHFKXj8PQBoPlbf/8/p+87VFYCDWtqqtmcqmooSvEsAFg3rf/1JIPPkIN4YI6PT4BE36dJ6u15/4fv8fYXv8CDB6coZfja17/O8lBkVTlnxjBSNTWzxYLL8xssir/81nenqBMlAe2FRJTdbrJNafjSV78CClxRTI21qAFuG2o7UZlzFnn2bNZMgfACm7r1nhtj0LqUiIuh55u/8wc8efAab//yF2XTPfm9byX7twMFazV915FyFCmJ1hhtwThmBzPm8xWXVxtSgqJwU/TJJ69fyjCM4a5xDt6jtQwPjJm8dnA3TJABQhTiej+gtJy4KYpUOfhITmCNpa6NEM61AtTUSENVViQlUBKDZIaWlTTxPkAevEQTK42eBhkgVPuUEl27Z3/5imFzxbMPv8+Pvv89Pv7oI/rBCyn3M1RGiPCuLEha4WYNtdJgLO1+g1eezkcOjo95cXWFVTVnj8+46XvytqW0BxzNtjy1S95VZxy6Y1bVIcerh8wWB0LrDhHtrIDKjJEmLmuB7GaDKjSMfgKJOXQS+0TKARUUEgcjGc2YiV6eDEZltHOgII4BVVrAQd6howavwBhRrhgJYVHIcyyEYQUkia9JgB7AOeIo1HCVM34IEBMpZKyx2KxJWuJ0crCgAypXQkHXMgzLvWfsPGV2WFWS1CB2Bh8F+1NWpBzIMQBRfNZZgYpEj8gaFaCFP6F0FH83WrK0lZEmU2VyEKqmLcT3I0oTOfY7i0uQ7HRjmR6zQORUFqonKZCjJtOREijSJIM0aBMnzoLCWEi5QhkE9mYq8tTkS8wQQCCMgTEkEvLmHCkZU4cmEXPAOINRlqRuz0ElVOQU0TZBtvKaDCWKDSFHopZh1m7c0oeWpigkXz2BsgpjJF8eDEqXn+mauK/7uq/7uq/7+rfVq8trnrgznA10oyeQSWnAuoZu6Eg6UtcVfYhk72k3G3K8Io4taVTUB4/Y+ch+3NINexKJqj6k7zdELAeHB9T1CVop2sFT6owPPQcHBbvdNTfXL3DacXRyhq1WZN1wsx8IU9Z8M6uxRjzlY7+n73sePX6L2XxFzCMX5+fsdh3GRLrW0+4GqsLwqGy4ePY+lbMczOfMFo+42Xa8enHJ6mCBzonlwZHYi+JI329QumCMSiydPhC1x6oaV88Yu5GxHzHWiJQ6a/ww0g8Dpj4g+ojVGVfOOb8+x07k/fbqY7qxI/pE4zLj8hBFiV4eoZ3CljWORKm1qABRzJdH5Az13GKtYjZbMQ6B2WwF2kyRs5FhiOz314SxJaNxeSShWB4eEMZAQoNPFK6U7bMC325pd9ccHx1weHRAVVicLeiHkaqusKZgGAeWjSP5iDEl80pz1SX6MVM0hs16jTWJoagxtsBh8MFy+dFHnJ2uWB084Wy1xI+a0e8ZxkDTLNDG0DSWrk3s2i2zuVg6hv2e/W6Dj4n21TWL1QHOOcauIyXF49ffYrfd8OMffI/Tk1PKasbN1ZqoFQ8evMbu5pqzB68TxoF9t6OotCQmfIr61I33x88v+PAnH/KD937ManXI+uqb/Opv/hqnZycYIxEwSulPcrUn2bTWmqJwlGVBij3Xzz/g8vkLumHk+mpH+bf+Nkdnx6QkjbrSive+/We8/OF3+dyXvsDs+JT5wSlFXQNa8pt9oKwbHr7xhjRxU/NHlhvpYiHk7dum8Geax58ih6eUhPY5eYYBtjdrjo+Pefq5N4letmTW2TtA1zgObF+94PwnP8aEzBe/+jUOH5zxF9/8FmM/cvJQyOEgx5KmRjmlRFlX03MkWaR3G/FRfJXOubtNN9yqBphk2PpuK56i0DbN9NhOHh/z0Y/e4+zNRyyPlpLnaWTDDdwB2bTWKK1RFKQkjX/KcHD6EG3EY11Ox66UyPKdu7UI3Hp37c88XzHIVv7WdkBWaGWm4YC+IzprZXDOUFUlm81aPFPoaehgqAqhRSvEYzWO453tQOAUihQio/cM44ArCqyR7OgYPc4aUIaUhYTtnCPlyG7fcvXyFWEcqOdLnj1/xTiG6fHkT3v6//fWkDImRdCSR5qNpV40pCw+/LbrMPueh8/nfHP3IU+evEkuF2zayLMXG059T6Ee8j9+8ht8ufg8x80ph/MTFkfH2MqidUEmkPqAclaiZnSBsfkOsqZQZCueO6USKRZoncmjBpuE5O1B52kwoiQSME1RcsIFQHKfXUGOjkwURYUt0QFSFoWLsprkRX2hNbJR10rixJRF5Uia4GO+78QnrQK2EB9mDg7tsmzdEWpxHD2ojB97jHNonRliwqYArpRr2ie5JiQjA3JC4Qmhx9klRMhESH7Ku2eKfpFjlAzvRByDLLyxKAyokdvoPldUZGOFaOunpj7K5lppRw7TuUoiaSAaeT6TI6dRGucUiGRiULgi470iWYdJipydxOEZB0Z8YkKTEOp8muCEYxxICVCBISUyEseFUlgn129CYXLCxxGyPM6kJA7JKiicxQdL9BWeK2IMRK0YQkc/DsTaYrIhDoocDFlHYjQoFQj+sw2j7uu+7uu+7uu+/m11eLSinpUoEsenx1xfXtHUK4qiJKQkSkc/SqydypjC0e+FOj2GxH57hTIljbHMTk7JnFG4Ch89Q3CyET9QpGHPag6b/cjzlxfkBHU5o6yWVFVD1cypZgswDTEnYtoxWxyANlij6PY7Li5fkuOI1Y7tdk83eGarGeQ1q4MDTk9rtruB4FtGH9GV5eTRU4Ip0dlC2lA1BT70lFbx4sP3MGXJ8w/fY7mYc3j2lDaBrWu2245F7ejMwHI5Q+VEDD1tu6cqC/ZtS7e9wirH6++ekWvNxz/6ARsdCDGzu77g4w9+REqR1WJGN24YxsTnP/8uQ4TFqsZSoJSlKmdo1eP0wG69Ye1HdFFgjSRgdCnSzBvquuHFsxeYwmDtit2+pSpnZAzLRU0OHldacjSEYcfNq2csj09ROk1gxYw1geVqjpoSjvp2jx8HWSRpM9lga0bvMQra3Z6yrpkvCsYh0G47yqqkcI7dfstsVmCN3FfOFkfsuxFlr1g2M4buBlzJ8mBOGCV+NmfPyaNjyq1l7HpikNQNR6KeNVxcXNH1LcrMSVmgv3EcycFzdLDg/PwZ2TjAUFQ1VbUi5A3Rj1SloyhX5JhR5b/jHO+PfvIxm/WOg6MTfv03fpUYA2VVsLlZ81ff/T7WWt79hXfvyNdKcXeDv910rC9fsbs5xxl460vvoKzh5maPstJMO1dgrWG3uSHt9zx9+21Onr5FvTjEVdXU2I13jfQ4jvgQ6dsOY+3U3NdkpWTqoxXkjA+REKRxEPr3lBlNnn6Xo2vbO8CaD4k33n4bjBay+NR8aqXwQbyq80WNeu2M49ff5PTpG/gpk/zk9AQzSaVvG2yV0yS/v2324128WlWVhODJSaBpbtrM54lg3vfDJEdXP9Ps3jaMcsyaz73zDv1uz+WrF8wPF0JCxBJDlHzyGJnNGtk4uxKl9QQ0Ex+9Qk/bdEVZ1tPfkAWfcxatoZ3k7Na6uw16npo5pRRVWRNTnCiqlqqqJgVBmjzm4j3ebXfEkO987SEEUo4iabaGENLdcCTlREiR1PeTvF7yR639RHZvrMU6M0mfPzlupTLe97TbvXjYnz7huz/8Prvdnswn0vvPUoYgeab9QDYlVQ0YS1FqXLkSO0PX4f/whxzUex7+3a+x7jJt5/mTf/lH/PXXf5EvjUe8sTzmUX3EyeEJ1bzEVSWqkHNBZU245RP0ClVkkhdCs8qZFAW2o61FeVBpJGclDVpW4gt3hhS8/LsuxEccElpLzivWoIkQEjkbzJTBrTHkYkSJ1gBFIFvZ4KIkA5yUUEZL89mr6bwY0UZk2CkprC2IYRTyeJJhgMScWZTtiV5gG2n02LLE9Hti6oi+knzX4MlkzEGBYNkzYRCpOVGRrcjXc0yghFKbooAbyZmcRvwYSQlcqSfvNhOoLKBjIGOFtVdYAZn14oHXEYnxKR0WNeUHW1AKlZGsci+KnYhkixoTUcqhdJYYNVsICM0o2bQjrw1ay1ArWWLopQVP8o/SWSLZELVAVhqDxoeI0wIvEaNGJqQ4XcOjQO+yw+qCulzQDVv2cUMbezSR1nekIP5vrTKoQE6GrISwPOj+M10T93Vf93Vf93Vf/7ZyCnabHaqoGG5eUc8XxJjYtb3ci4YeXSwIOmIy7G8u6fctppmTladPhu7mBVVZoYzB2oLOG4wpUdaj1SiKt+g5X2c2N1tCvyP4OdiK6uAxTeFYrhYo5Rgnm9Zyfsx81jCGgfVui8qRunTEKEqyqDJ1UeG7geMHjzBasd/vicEzDJ6qcDx89BbNbImtZgxtLzBpMrtuQ58S3/qD3+bB6QlvfOkRP/7hx8TiBG0C82ZEFzW6mOFjJOqKqql4dX5OacFHT7NYoArHOEbGYeDy+Ye02+dUVtMsZjxfv8JZATTuhjXkxOHjN6E+4MnRKdoKU2u/viYpi7aWm8s9bd+hbeatN1b4EOm6HUEtCLtI3/WY4oBMJHjwY2Q+m1H0nnbdYYqS3WZDiCNNM6Nc1ORxS1KWslqh8kgYO4w1uNJO90AZcqYqC3LWhNFDCiwPDokxE3zCOseirBiHkeVqxeA9KI2LgaJUpFhQzho2u0j0YnHdty0+JmazJft+T2kUxjheXmyw1SHWHDCwZrM+R9tM6HtsBQdHh2hTY23B5vICrzO2rIjFTBoLW4vNNSeM03RXLxmtIYyR3WbLbHGEqwuaZvWpzv9P3Xj/ytd/lfMXF/iQePz4ISEG2nbPX333u5x//JLf/K3/mLqeYZ2l79uJqJ0Zh5GcImEcKYsZx48eYIqSfhixzQFaGXyI5Iz4JrPitS+/S7VYMvpINpoYxMeQsjRMfvS8evGCb//pn/Lx+z+mrhx90PikOTg64Fd+6SscHS95+fyc5y8u+fIvfJXDoxXOFVRVRVEUeD/gnGO72YjcdJKELw8OUUao3Sl6jJbtb9f2eD9KXEVSlPNjdDVj9CNKaV574/XJS33rX04/tXU3kw853MnRb2X5gDSsMRJjwFhDWTRUdUmIgRjlZ35aQWCsvQPZAeLV/sWv8J0/+RMwEDLcXF3z3vd/wHa7JgWPzY7Pf/ldPv/lL7E8PKAs7R2EDkTmXxYly6ak9x4fYBiHaXOtyElTlhL5NY6jRAlMQD2tNWEiZP+05UC+TzblRVHI4MEKYd0VbiKi7qbfowWY5gM/vYk2E03aGCORHV6Iq3kaQhgtm9OcIkmlCbIt2/ckwcucPno0NUGB2pbkZCZA3GcDSWllyEoUC5pAGBKGjNF28uTPQRW82VvmyzOu5485f3+H/9GeL60PePeDQ16zR7y5PGY5d1TLGW4+gbMmlUYeFaaUCDddK/KUB52JIjcPgMqkwaOzNM4pRNARlSTuQBQU03Y1y2bTNIbkR5J26JTAOAF3iQcB4xxkMLqWN8kY0drJgENPkTHGTNdlRmHIOgkhTBm0MVNjLR9oupAoLq0sEMhZkxOQxMKQk6gdtCkwbiQMgeQDykGKoyhixko2u34kxnHa/EcyBTl50jQIsTriskDfYoxklSFmjBrJ0aGMRutMDFlywZUle/G2kwK6sJAsyo9ElGSXZ0hegZK88xTTXUqDGGskQzYpeY6Z0ttk+25Bi/c6J80dxSIJqdzHnQzbAiiTybEn+IlgDxP9XAZ6BktOmZgDyhiCj1gFY5JrKGhDyiPGZCIls/KQzdDh4wYfA/uwxuc3cDGTikRSGpWSpK2lTM6fTip1X/d1X/d1X/f185Spl/iQyUPH4uCI4EU1V9UFZeHIUXKhwxi53q3Z7lpKp8i7TPI9q2XNbDkjefkcDzmSGSkriw4enRJZWdx8Rr++Zt7UBKeYrUpmi0Oubq5xtmBIltB3GJWwVUUxRZeFpKlnK1JoaTc3kMCWNXXdABCKSFXPSFqz60YOT1aEAAeLFcrArh3pr16yXq+pXERlz+FywXrTwfyQ7djRrjXHTz7P8uCI5apkfdNitOXV1Q0PDhfk6NluIs38gLKwlEVB3weq2RlV6bCuADfjhHe4evEBIW44PDvjIB+x23U8Wh3zztfeZb58g+cfPRfQcIrosmG5PKDb7ljOZsyaRvzb3SD36D6CNhwsV7hK4G8XV1fM6hlD12Kc4eLinMF7VB5Zzgpi9MQQQS+IOHZRYLhedRAi3gsceuhG6qamLArGEBhHT1mV5JgxpWO3k9z6mCLaQ1WXJJOxpePRa2+TxgGfHrPZ7RjHTAgtzaxi9J6qtPhxYFUfYXVF9B3tds92u2Xfb/nwhz3OWXxMFLag9yNKOXIyDH3g5PSQ3b6lPDzD5IxSCZss1y8/oC5KiblLsijdtS3aapw1pNQwjj1DH4jh37HUvG5mPHmtnrbA0hCWZcHXfvUX+bXfrLDOEmLCj+NPRVhBUZa4osBVJaTMmBRqCJA0ddVMkVlxklFHEpp6dUQmU5RWtsA5M3rP2A9cnl/w7T/5Uz76yXvEsWU1L3nxwY/53nvP2Iyytf72Hz7kK19+m2/+6V8QU8k4BP7m3/2bkkX9U7FmIQSGYcDaYtqyiqRbBgCy3U3R07Ud2/WGDJRlKZRiI1mRxEn9mplgcm5qMuPUiFvmc8nO3W53jKOfiPDy1Hs/So74tNG1U5B709QM40Dfi0/7E2+3vlMU5Jzo+4H19Q3v//iH/OE3vsGH7z9jGEe2+xZrC5bzGTpF5q7k+sULnv/oJ/z6b/0WT956SjKyWb/1RjutefjglFdXl7w6vyHESH+7AFMKVwjEab5Y0HYd9LLZBNnSa2Moy/JnotGMMZAUi8WM9WZHWRaSI41AquR8kgbpltSup5gvrc0deM5qM2VtauEKcBv/YTDW4H2a4GqWePdalvJaTJLdx4+f8Nd+7de4utkyDCOfTWgulGnfj9Jw4emjww4ZazOVTTinIFmsrqkGWH1jy8lmz4NnJ8xO/zZlKliWDWDQusYqJTnYZTl5uCNi57bie6lKYi88hZw8WE1UCR1BqUjSkINswbNRTKIPNBlSJhsjP2fk0teF5FkrkEbSyd+XfMdbuwGkGIWXkCJGWxJMw4+M0pBzICd9R1TXxkzwMdDJkE0ix4gpCuKQBS6WE/heIlJGj8qBoq6E/FnV5LgmjQMqG1FIaHm1Ug5E7/G9+J1zCugkfvKUpPFPygnxPgQUgTCOGH0bBabQSoFWGO1JdrJ/jJ44WhmKuRLlZhhVgepJt5nccRQfekYa6JwIQTKE5SLQ0ihryTF3k1BcRY+2kr+b00iett7yITcNIVTGp4zKHrRDk9A5E5OSRl0pkioIOcg2PEUBE2rIUQGeoLQ05ZKHCDmSXMm8WbKNN6z9JZt4STCRTiVsMhgqQh5J0dPHwBg/61VxX/d1X/d1X/f1by7jLNHvqOZz+n2HxnN4eIarF9xsd4S+xWrF5U3PwcEps/IVi3nNetMRQk1RzOiHEVNnQisxpz568UzHEeMWxBBIOrFcLMkxU88eUjhDVhVHR4+ZzS3oit36iqvnH0JsGas5bWdxRU1OiXFMNMszjIGxG9muO8rKEXwijnvaYZB8amVZzAXQXLg5KQ0MQy88F12hbMUQPMoWfP2v/RbBJNabjqJoaIdAulYURYOzhSxzqMijAm2o5meoNHJzc4E1WiC5Wjg9VilurncUzSFKrTg8ep0wbGn7kZMHj8mD5cXHl3TdjsPFGUP0FHWBytDnxKvzV5RWJNxHh0fYckY9H+n7jsxIGDQqDyybJYv5nHWymAbKouDi/JJZfcBiNePVqxeUTUldF6jcMA4jIWQMnjENYmNMHldWjG3H9eVL6tkMYx3DGBnHAd9G6vmKNIFrI7DebtAKYuw4//gDgh/AWLEG+p6qcGTlOH3wkP7qmrE0aCxXr16hcsd6fTkt6zyjv6HtYL46YowDSjmwFT4GQk5cX73g4sU5Rw8f48qG64tXmLIkO0vIgZtXH2OUsLvGCCpYiZ8shf2V/cjF5fmnOv8/deOdQmYYRpbLBa6oGAZ3B/u6k+zmhDaKHNWUR60m/69FR0PW4JycnGVdTgRvRd/LNjnGLBu3adOT0nQTOG1QP3zvRzz76CMev/aAL7zzmP3uipcffMDN9UuOlwVVH2iqgjhs+e3f/5dsu8jR6gHL+ZK6biiKkjTJs2991yEEqqoGMjGmCRxmiXGYJJ8iM6/nC2mWJ8+1AtkIWncnfQ8h3m3PQ5Doq6ZuODs7pev2tO0eY0SqWxTFJCEXWXS330tkWl3jCov34528+rbpBqbGW/5b13X8i9/+Xb7xO7/Hs48/xocgW0NlqHRFVVYsZ0senhzy+uuPefD0CUenD1gezWVLmoIMDKJIh33SXJ1v2G52hOBR2nCbb661bOlimLzRKVGUDmP0JJ8X2bezBV3bCnhqKoXA+VLKxCCPy2jLZiveaINhGIZJpqs/Ibgz5cGnjLbi2TZGY500GDknuUiTvCY5BXwMcv4lyU60xhByoC5nfOFLX+Ho5AHb7Z6+G8TD/xlKGILT40fhTCB5SNkxZo0tpkxxXdCYjHs1MhsUB+VDdIwYHSmcw2q5lmIfULYAIyronCcPN1rWpwmMmcBp2ZGDxwjRixwVOilSGMijl2xo48gBkTUTwVu0E4CfSomUPtnGyiQHIGAKJdvoSZmhkmRCx5xJGnSQBjt5Ty4sOlty8ihnUXkiZAfFLZU/J7FeyMkWIGZ8kGY7xUwKicJpIazrAm0zRTWXJjr1cqGpLBA2ZST2LEsOeQqZrITIrXwiJyW0d1tMcnoDIZGMgEkMnqycvMNoB1GUEmBEDq8dKor7OuWEKQ0wyY1CwA9eKO9ZXh9BtyOy/yQAt6xGrCoIocNp+4nPXok0XRsj73UKeU7DOFlTPGQlx6MyMYuqI0SDzgmlB1SCqGQgQwpk5IZDKQsxYUmE0IMqUXSU1pKd5XR2RLvtudxesz64Yud7roYtc1vjsJzvX/GifZ+r/ppf4x98puvivu7rvu7rvu7r31RNtUDnCusyKfcoH2h9II3XEHqRfpvEyWGFciPtaLneRUxZ0zQlu+0elMKYkqJ2LFdzNm3PoqiIqmO73jGfFbhixma9ResGZw1WldhZQUyGNPZ07RUoj24qWaTpilndEEfPGHpUhu1NS8qebd9CUCSjKZylrGcoo7Fa03aRfbfFWctwfY1jpJ41KNeglUEnRb1YkNuBsrEcFhWnR8KPkiVVxpaW0Rtid4NSGZUDVVWitWOz3QhcVRX07Yaub4nDnjEqttuW+eIAVyZRK2pNWdbsrvdgLR+9uCADq2bGk6dvsO/27NYbhn7P6dlDjC0mQNzIQXE4xbF2bLY9SV1TlXNiHLl6GenHzOnDpwzT339x9YKy+gLHJw/xUbHrRoZhoN17FJmSjnpRYGdn+GEg+ZbkDG6+AKsZxojDgnZkoN+t+eI7b/HyXCK8vB/ZbHuUyZQmQCHxq223o3INqES7vWJ/85Kh3XL0+heo54dUw46+64kxsd9fE7WiqeZUuifuL3ny+ruc31wzhJG+3bHdrDk+XPDo9TfYrndcP/+AajYjjR02K2KEan7A6Fuen1+yXB2hUmTbj9SAioH15UsCn86q96kbb2M183mDdXaiVk9Zyv6TGKjbbewn21mFcyLhVlrLpilBXdUUhSWESAgJYxRaVwyD3GQrJf7bGCMpRm6ub7h4dU5VVXzt138FVObFez/gh9/+Lh/+6Ef4YWBZ1xR6oGoa+mjIO3jjtUf8ta//Jr/ym78qjcLUaCafJx+womlmP7Whv6UZS5yXkLUFClYU5d1jY/LQmlu/K0wNtdzoi2zdk3OiLAsuLy5476++jykc9WxGVblJhj5FrWlNv9+yWKwoC4NSkc16hyuquy03cLcRFnBb4Nn77/Ph97+PHhMPjh4xn884PD6grkUSM1stOHt0RtM0HBwfMlsuJm+3Ff99SneP+xZ29vzqQmjmzt1FgH3yPTKoCH0vr7e5jYqbtncxMcSB9FMye5GOy6ZS5OSiiMCqu41hjHnamE/g6Ol5/sRn7rDOEaJQuscxEPwo0vy7LbsAtsahQzbIArKyVp5frTSz2YKybKRhn4YFn6Ue/J++/pl+/r5+vpr9hz6A+7qv+7qv+7qv+/q56h/8o//yP/Qh3Nd9/QerT914T/0ew9CL1zYG+r6f5MT2k6YUPqFpT5Lj221tSuLTrqoKrTNt2wotWck6L6U8+X0zRVGglOLy/AI/jrz+5psYJ1vqH/7lX/Dhjz8ixZKnb75D4TSbq2turndEVXJ6dMZv/Cdv8Ll3Ps+jp4+whZlitQT2BNzBvgRmhGy0pj4shCmfeYr6upVBS0mI7m1jePu45PFK1NIwCCm9LEvabk+7b3FFgbLmZ5pYOQ4BvTV1JR6M6Gm7QTD9RXFH+c45URTFdHwy7Hjw9Cl/4+/8D9lcb9HGcnCwpJzV2MLhnESZhRiEKF4Ud1AyaeDlsUi8ep48z45q1qAydzC328HK7d+Fn5W83z5pMSZiErrZLVgvZ9l6xhBlezvFd0lTrAWiEAKiALB32d453z5m2TrG6bXRWtH1A+2+l6kcidQlum4PJOLYQ8zUqwNcaXHO3vnCldYUtsSYcGdruJX739d93dd93dd93dd93dd93dd9/fusT915DEMvecA5k/JtVq1HgE3y38zkvTXaoO5k5tKoOufo+x6lMn3fUVWyjcwZ8XanODV50phqLdvYupmxOjhAG33XmL3z7rucnp1yfb0meo/Tma5tGUNmdfqAw+NjykpisW43srIllt99G/X1CdlaqOKyqZYNbdd1U4N42yzraTMvueXOubtBw09vZ2+30TmruxizZtZQVuXP/E3v/ZTbLf9tsVzRti3DzQaUZb5cUlUVfdszjh5XOJyT33f7e2azBa9/7vOS/zf9/VsQm3UWrTTDMFJNcVy3XnGRsMfJ824mmnuQ7G0lTa9S+U4JcLtpv/3ntunW0yZZKe6i03KKE7gKlJ42zzZP3no1DWHSZDEYp+Or7qLfJM9dYFg5p7uBR4qBmEaGoWOzuSF4T8qBbrPDWCvb7nGEEHn4JJKVoaxqnDXEkFiuVlRNBcYBHqXSZ7547uu+7uu+7uu+7uu+7uu+7uu+Pk196sb7/MMfEELEJ4WrKoqqIfggUCutmS/mNE1DUWgUFmM0SmVBxQfPtAzFOTMB1fIU8SVfu22SZft9m2GtKKuKWyl0jJLtXDULTp/ULI9FT3/bTEpW9S1RXH6nZFJPUvJpg3pb0gTeys71J4CvFNlv1tSzBdYWd7AvgaKZn2ogpYQ4nlHKTJvicHdcMaZJ2vzJ8cUYIcdp2ysRWSEnusFTNXNcWaG1oaxKxn4QnzAwDP5nlAU5K6wrPsljnpphNfl1Q4xY66iq6mdI4RJDduvxvpWJR6L2eC80c2vkdUwTFfunG/DbKC+lbsFPn2zHZZAhnmStNGXpGMdRqOTOYawhBM84iFQ8xvBTP8dEf/eEKOTsnG833R0hDOy2W/7kX36DFx9+jPeeYbeVcyOBLgpMFso2SlEVDacnD3jw+BFf+tpXOXpwJgOT6fHcUuXv677u677u677u677u677u677+fdanbry/981/xns/+oifvNjgmgafNevrLV3X08xqTo6O+eVf+XX+1t/921grhG9peCW3N8Zw51UeR4FqpSQRW7ebWpFqp39Ntp5SJgTZkhqj7qKizOQxjvG28bZTA2fumvHbTSoIBTvG25xofbdxlg1wmKjDkkVtXIHWhqoqf+pY9M80nQDWFLgi0+53UxxPnrzb+meI7bcNpVKyrU5T3FHOacoQVDSLJdaIdzqlzGq1IoRIMUZijoyj/5km9Xao8P/tVb59zpSSjfRtRvntAMI5d+dh994LvM572u2OsnDs9y0Hh0fUsxmZOEnE1c889tvnVU+KABk43Db3kzR9GO6k7c65KcbttumOd4oAGarE6ThvXyN5nnxO9LuB6Ee6ruP5s4/Z3qzpu47tfg8pst+35GQ5OmlQhWa/WRO8x1eZ0weGctFws16jbcHyYIW2t8f/2Tze93Vf93Vf93Vf93Vf93Vf93Vfn6Y+deP9T/67P+CDyy37EIkktHFoRHLtU8+w23G4OsLqv4OxZvLPigRbpN78VIOY70jgSmXKsiRG8d3eeovhE+80gLPiU9ZG48fhznucUoassc7+rAxaaRL5rkGUTTVoHYkx3zXjn+Qb36bxgnGOo+aElNInMu8p5/v2+O/gYSnRLOfkds+U3Ht3zLcDBGm81fQ31fS48vSYwyQ7d1hj5XimY7k4v2AYPPP5DGMUu107bWk/kXzfboXFK68nmXuaaOnSXP60TzvGiI+B3XbLbrvn/OU5F89f0u22xK5jebDg6OFDFIaQMnVTTkOSdPeYbqPCZLOeMVpjq4qcFf0w3BHjb6Xtt69BjJFh6MVe4MOUfSxU8JzlnMg54ZyGmNjut1yer7l4cYErLInM5cUVp0+esjg+or3Z0fU7Xl1comLB1371l8HCRz95n3HfMZ8vefLGazx88oSirESuHgO2qO5sDvd1X/d1X/d1X/d1X/d1X/d1X/++61M33vsQ8GiUzug8bX7vGlpNVS/45V//VfIUHxSRJlWaKelwPpFpS4OplKKqKlJKNM2MsirZbjaTF1zdyZpvf4f3kTSOEjM1xfkoZXCFoywL9vvd1HgDaqKoT83VJz5sg9bpZwBwd9tbLX50YwSsNvqBru+nLXOevOgJ81NNu/cRpSVe6xM59y0xHG6HDD+9Nb5tWo3WMAHXiqL4qQ2wRLHtdntA0fcDReHuNsK3EmnZ2N7GucnAYRg8xuhp465+ZtgxjCNXl1d8+JP3+cH3fsj7P36f9nrDwXzB2dkBq+Mlp48f8fD1N5gt5ywW8+l3GJRKP7Ntv5Wdh8kbbowhp4T9KQp7WZZ3jXdZltPxFsiwQIYaOWucK6gqIbiH4InRM+57/vgbf8R3vvV9Skr+J//g79Hh6bcdp2fHLA/mbNdr9ps1+rvfR1PwxhtvMT+acXx8TL/rWB2sODw+ZL5Y4AonUn9jJ2K7o227T32h3Nd93dd93dd93dd93dd93dd9/bz1qRtvZQrJkcWgs+Rt39Ktq6LmN//613n3a18hRfEN30qSQ5DIJ+scMHl4QyCEMHmfRVa9WDqOjg7o+5au+0Q6fvczPhBiIN9tXoUI7qyjLN0kQzeTvNxgnXi9+SlPsjS+0+OZ/uVWjl7X9c94pWezGaqD/X7H5mYttPUMKSbmiyXzgxXGGrSBfr//GX/17dDgVnYuhHaBhXk//b3SYY18X9uPoBTWOaGDD7IFF4I6tG1L1ykgTRttafBjDPjRY43BWDvB44QenrklxMvfGPqB81fn/N4//af81be+Tdt1HKwOePcrX+Cdr36R5dEKreS1PDw6pG4aiqlxVspMPvZPvOu3f+dWri0SdovNkgn9yfMLt0oAyTf3FIWbJP5RsqSn8+iWdt62A3/8+3/E+QfP+dybb/L06WscHh+yUpFxveNgtWJxsGCxmPHyueLxw8dURcPhwYr50RLrCnJME3OgmPz4+o4KX1UNw9iR062C4b7u677u677u677u677u677u699fferGe9eOoC0aaWZjykQyurD8+q//Ov+D3/rrFEVx5/m9lWUrpf81Sa/IwzMxfZJLPfQDV5eX5MyU/fxJw3wrzS6LYpJ/j6jb/xkhYYusGUCyw2fz+i5A/aebYe/D5PFWP3Ocn9C+Rf692WzYbtZ878/+jI9/8gHL+YInb73OfHXI3RZbZ0khU58MIW7r9vfJc3C7ddYUhaZwllntsIVjHDyDH1HaTpnnwyQZT9xmjd9Gskk8l+SFA6To2V1dYIuS+eERZoK/oTNt1xHHQFaKvtvxZ3/0TX7y/fdoqpJ3vvg2KMXTN97gtbff4ujBGTFmYggsFzPyFO/2yXM2Ts/ZFPGVFKJy13eKAXmgeXq9MxlFiomcBF7nx3D3nPR9fzcgyfkTCbts9DWFK3j9c2/y/2Hvv8Ntu+p6f/w1xpht9d33Pr2mkoQQAiG0BEgogQByERUDRrFgxav4FeG5tAcvAuqjXkG9FlBAQLn8KFIuUgUTSCgmpJzU08/Zvaw+yxjj98eca+19kpOQhBwSuOOVZ+XsNdfsa645x/tTd+zZTVSu0BhpUK3V0SYlOHMPQRAShgFaZwRRxNj4JEIoqrUapbCEJ/OifUp5hTEkvwbjOEH5Hr1+F1O0RnM4HA6Hw+FwOByOU80DFt61cpVeq41UgiwzhFLhq4C9O3bzhCc+gXq9hu/nFbTjOMZs8L4ak3u5ByHaOss9oNroQrgJjDWkae5R3SiMNzLwIvu+zyA3WxUh5caC7wUM8p/jflIUNssFfJIkw3XDoJe0KkKgJUkSD4ujZVmG1pp+v8fUzDTlWoVyqcKOvXsY5FRbLGmSndAibCCSB2J0IOoHuc4CQRjlVdK11pi+pdvt5RXexSAffGBwUCcUMgOKsHuFMYIsS0j6PTprzTwnW6yL33azxaE7D9JcXMHolE7S5O5b9zExMcHZjz8fLwyRCErlMkIFxP0MIRVhqYpQAVGo8ITA9wXGSNI0HlY+z7Qhy0xeTd3zAIVNMiyD4mh5Ln0uvC1SgJC5B37QMz1JYpTyCmGch8wPc/OVR1SusOuM04e62PfyfupS+VSrleG58TyfUkmgRAASZBFhIYQg8AMgz/1XKj/fWWqwWucN5aRkvS69w+FwOBwOh8PhcJw6HrDw3rp5K2JhBU8pKrUqYRQxMjLKeeefy8zmTdTrDSxQKkW50CSFwkMrhEAgsQYQoHwF1iBMLqZV0UN7UG17Y851LrAkaaqHYevABoFb5IJLQeD7w0Ji617V9fUAJ7wPw7AIT9dkWYLWdpi77klJWVZQSlEfG8fzfZJEb/Bq66IS93pu98Y+1xsZeHoH+d09relkaS6iAak84jim0+1hjCUK857duYd7PWw7N0ZIpNSkiSHtJQSlEn4UFXndHkanJHGM50nqI2XK1TKtXpXVuXl279nL1h27sDKPFsh0Hhaee+tVIX4FcaLJBEiV4PseSgiM0SRxn14vBqEwNj+Xnszz/tM0ZmVxFV+FjE1PIJXE8yiEd54WkBstMgY58EEYYo0oip7p4hzl+xKFJfICdBptcs+5V/RyF6ihkMcKfF8Nw9vz0Pf8esvFusTz8s+NSZFCgSgMMK66msPhcDgcDofD4fgh8ICF9wUXX8zuZptGo8H0ls14oUelUqFardBo1JFCDoWY1bYQjbn2FkLgB/7Qo6yURAqF1usF1FQRom5hKFCzIhw4ScQwXHgg1KWUw/ZhA1E78FSfsD5ri2rm8oRl8pZkZri8LXKTERJPCqwxSC8vyLWxONzAM2s39AOHgSheF+Abe31vFPuZNgwsEFZ4KCnIdI/V5RWO3n2UUrnC1t1bCcci0jQ3NCgpMdZSnNFhq7DySIPKyAh+GOVV0T0P6ysmpiYZGRvNK5onMasry6SdmE3btmAQRGEZPwpI46QIyV4X3SCQQuQh6okh1blQjpOUTrtLt90lKFUIotKw77rOEhbnF9j3nVvYe+ZZjEyN4yuFJyUITZpmaE1R3E4MK7AHfkg/jjHWYDOD0RZrEsIozIvnmTy/PO8WPhDa+TkY9Gn3fT/v211o6EFBOaMNFsOgx7hA5BejLPaDe0dUOBwOh8PhcDgcDsep4IEL7ydfhCmEjkRgbIbnBUUbqEF/5hSddcm0KXK9C9Ht+9TrdXq9XhF+nYvvQYXujfnWG6tl6yzD6AypJH4Q4nn+0DsOedXsQc73xpxq3/eHglrrrPBUqw1txcQwnzsX4QZQw3xgpSQ6y3Kv/IZCaYNlB3npAEKcKMAHbbE2Cv+83Vfupc29x7kYx+Zh68ZCu9lmZX6ellKkaZex8QmqIyNUGzVUFKLTdFjtXMr8fKhhaH2xbcAPgtxrH8dFSLakMTpOcHaEkHl4eVAq5WHZIjvhnGaZLirFS4QU+UspEJZSNT9eP4zItEZgcm+/lCRpxtrqKpMzM5TqVbIkxVceBAIpPcDkod0yL34njEYJOUwtEIWhg8IgknX0CcX7LCLfLzlIXaDID9coJYfh41IolNpouMkw2iCkwFiBsZZBLIIxeWV8h8PhcDgcDofD4TjVCOvcfg6Hw+FwOBwOh8PhcJwy5PefxeFwOBwOh8PhcDgcDsdDxQlvh8PhcDgcDofD4XA4TiFOeDscDofD4XA4HA6Hw3EKccLb4XA4HA6Hw+FwOByOU4gT3g6Hw+FwOBwOh8PhcJxCnPB2OBwOh8PhcDgcDofjFOKEt8PhcDgcDofD4XA4HKcQJ7wdDofD4XA4HA6Hw+E4hTjh7XA4HA6Hw+FwOBwOxynECW+Hw+FwOBwOh8PhcDhOIU54OxwOh8PhcDgcDofDcQpxwtvhcDgcDofD4XA4HI5TiBPeDofD4XA4HA6Hw+FwnEKc8HY4HA6Hw+FwOBwOh+MU4oS3w+FwOBwOh8PhcDgcpxAnvB0Oh8PhcDgcDofD4TiFOOHtcDgcDofD4XA4HA7HKcQJb4fD4XA4HA6Hw+FwOE4hTng7HA6Hw+FwOBwOh8NxCnHC2+FwOBwOh8PhcDgcjlOIE94Oh8PhcDgcDofD4XCcQn7shPf73vc+hBB861vf+r7zXnrppVx66aXD9wcOHEAIwR//8R+fwj28b3bu3MkLXvCCR2TbJ+MrX/kKQgi+8pWvPNK74nA4HI9KPvOZz/DmN7/5QS8nhHjQyw3uyR/96Ecf9Pbg5M/HN7/5zQghhq8gCNi1axevec1rWF1dvdey9/W653MijmPe/e53c8kllzA+Po7v+4yPj3PppZfyN3/zN7RarYd0DA6Hw/HDZHCPXFxcvN/57qkpTgW33HILb37zmzlw4MC9Prv66qvZuXPng17nD6I9fhjH/OOG90jvwCPJe97znkd6Fx7VXHDBBVx77bWcffbZj/SuOBwOx6OSz3zmM7z73e9+0CL62muvZevWradmpx4Cn/vc52g0GrRaLT7zmc/w53/+51x33XVcc801CCGG8733ve/lzDPPvNfyG58TCwsLPPe5z+Wmm27i537u5/it3/otpqamWFpa4ktf+hL/3//3//H1r3+d97///T+UY3M4HI4fB2655Rbe8pa3cOmll95LZP+P//E/eM1rXvND3R+nox48/08Lbyco7596vc6TnvSkR3o3HA6H48cCay39fp9SqfSou7c+/vGPZ2JiAoDLL7+cpaUl3v/+93PNNdfwlKc8ZTjfOeecw4UXXni/67rqqqv43ve+xxe+8AWe/vSnn/DZi1/8Yt70pjfx2c9+9uE/CIfD4fh/lD179vzQt+l01IPnRzLUfN++ffzMz/wM09PThGHI9u3beeUrX0kcx8N5Wq0Wv/qrv8rExATj4+O85CUv4dixYyes5/5CJP70T/+UXbt2Ua1Wufjii/nGN77xgJY9WajHW97yFi666CLGxsao1+tccMEF/P3f/z3W2pNu+3Of+xwXXHABpVKJM888k3/4h3844fNB2Ms9GYQCbgxB+chHPsKzn/1sNm3aRKlU4qyzzuJ1r3sdnU7npNveyMlCza+++mqq1So333wzz3rWs6hUKkxOTvIbv/EbdLvdE5ZfXV3lVa96FWNjY1SrVZ7//Odz9913P6QQS4fD4Xi4+frXv86znvUsarUa5XKZJz/5yXz6058eft7tdnnta1/Lrl27iKKIsbExLrzwQj70oQ8B+f3w3e9+N8AJYdeDe7AQgt/4jd/gr//6rznrrLMIw5B//Md/HH52z/vg0aNH+eVf/mW2bdtGEARs3ryZl770pczNzZ0wX5qmvOENb2Dz5s3U63Uuu+wybrvttof13AwMAwcPHnxQy11//fV8/vOf55d/+ZfvJboHjI+Pc9VVV/3A++hwOBw/LA4fPsxLXvIS6vU6jUaDq666ioWFhfuc/77SNQdpre973/tOmP6tb32LF77whYyNjRFFEY973OP4l3/5l+Hn73vf+/jJn/xJAJ7xjGcMnzeD9ZxMfxhj+F//639x/vnnUyqVGBkZ4UlPehKf/OQn7/dY3/Oe9+B5Hm9605vud777Stl95zvfyR/+4R+yfft2oijiwgsv5Itf/OK9lv/EJz7BeeedRxiG7N69mz//8z+/T43z48KPnMf7hhtu4KlPfSoTExO89a1v5bTTTuP48eN88pOfJEmS4Xy/+Iu/yPOf/3z++Z//mcOHD/N7v/d7XHXVVXzpS1/6vtt497vfzZlnnsmf/dmfAXn4xhVXXMH+/ftpNBoPep8PHDjAr/zKr7B9+3YAvvGNb/Cbv/mbHD16lDe+8Y33Or7f/d3f5XWvex3T09P83d/9Ha961avYu3fvfQ5i7o877riDK664gt/+7d+mUqmwb98+3vGOd3Ddddc9oHNxMtI05YorruBXfuVXeN3rXsc111zD2972Ng4ePMinPvUpIP+xX3nllXzrW9/izW9+8zBs/bnPfe5D2qbD4XA8nHz1q1/l8ssv57zzzuPv//7vCcOQ97znPVx55ZV86EMf4qd+6qf4nd/5Hd7//vfztre9jcc97nF0Oh1uuukmlpaWgPzZ0Ol0+OhHP8q11147XPemTZuGf3/84x/na1/7Gm984xuZmZlhamrqpPtz9OhRnvCEJ5CmKa9//es577zzWFpa4v/+3//LysoK09PTw3lf//rX85SnPIW/+7u/o9ls8vu///tceeWV3HrrrSilHpbzc+eddwIwOTl5wnStNVmWnTBNCDHc7r//+78D8MIXvvBh2Q+Hw+F4NPATP/ETvOxlL+PVr341N998M//jf/wPbrnlFr75zW/i+/4PtO4vf/nLPPe5z+Wiiy7ir//6r2k0Gnz4wx/mp37qp+h2u1x99dU8//nP53/+z//J61//et797ndzwQUXAPfv6b766qv5wAc+wKte9Sre+ta3EgQB3/nOd06aIw55VNbv/d7v8Rd/8Rf83d/9HVdfffVDOp6//Mu/ZMeOHfzZn/0Zxhje+c538rznPY+vfvWrXHzxxUDuZHzJS17C05/+dD7ykY+QZRl//Md/fC9D848d9keMZz7zmXZkZMTOz8+f9PP3vve9FrC/9mu/dsL0d77znRawx48fH0675JJL7CWXXDJ8v3//fgvYc88912ZZNpx+3XXXWcB+6EMfus9lB/zcz/2c3bFjx33uv9bapmlq3/rWt9rx8XFrjBl+tmPHDhtFkT148OBwWq/Xs2NjY/ZXfuVXhtPe9KY32ZN9dYNj379//0m3bYyxaZrar371qxawN9xww33up7XWfvnLX7aA/fKXv3zC8QH2z//8z0+Y9w//8A8tYL/+9a9ba6399Kc/bQH7V3/1VyfM9/a3v90C9k1vetP9btvhcDhOJU960pPs1NSUbbVaw2lZltlzzjnHbt261Rpj7DnnnGNf/OIX3+96fv3Xf/2k92NrrQVso9Gwy8vLJ/1s433wF37hF6zv+/aWW265z20N7slXXHHFCdP/5V/+xQL22muvvd99HTwjrr/++uG0wfNkdnbWpmlqV1ZW7Ac+8AFbKpXstm3bbK/XO2HZk72UUsP1vfrVr7aA3bdv3wnbHjx/Bq+Nz1iHw+F4tDK4R/73//7fT5j+wQ9+0AL2Ax/4gLX23rrgZGNoa9e1xnvf+97htDPPPNM+7nGPs2manjDvC17wArtp0yartbbWWvuv//qvJ12ntffWH//xH/9hAfuGN7zhfo9vx44d9vnPf77tdrv2v/23/2YbjYb9whe+cL/LDLgvHbV58+bhs8Naa5vNph0bG7OXXXbZcNoTnvAEu23bNhvH8XBaq9Wy4+Pj9/lM/XHgRyrUvNvt8tWvfpWXvexl97LC35N7WtvPO+884IGFzT3/+c8/wWvwYJY9GV/60pe47LLLaDQaKKXwfZ83vvGNLC0tMT8/f8K8559//tAzDhBFEaeffvpD3vbdd9/Ny1/+cmZmZobbvuSSSwC49dZbH9I6AX72Z3/2hPcvf/nLgdxqB7k3CeBlL3vZCfP9zM/8zEPepsPhcDwcdDodvvnNb/LSl76UarU6nK6U4hWveAVHjhzhtttu44lPfCKf/exned3rXsdXvvIVer3eg97WM5/5TEZHR7/vfJ/97Gd5xjOewVlnnfV95/1Bnm/3xczMDL7vMzo6ylVXXcUFF1zA5z73OaIoOmG+f/qnf+L6668/4fXNb37z+67/E5/4BL7vD18PJXrM4XA4HinuOe592ctehud5w3HvQ+XOO+9k3759w/VnWTZ8XXHFFRw/fvwhpRIN6mj8+q//+vedd2lpiWc+85lcd911wxSsH4SXvOQlJzw7arUaV155Jf/xH/+B1ppOp8O3vvUtXvziFxMEwXC+arXKlVde+QNt+9HOj1So+crKClrrB1QJdnx8/IT3YRgCPKCB0w+y7D257rrrePazn82ll17K3/7t37J161aCIODjH/84f/iHf3ivdd5z24PtP5Rtt9ttnva0pxFFEW9729s4/fTTKZfLwzyVh7JOAM/z7rWfMzMzAMMQzKWlJTzPY2xs7IT5NoZLOhwOxyPBysoK1toTQsIHbN68GcjvYX/xF3/B1q1b+chHPsI73vEOoijiOc95Du9617s47bTTHtC2TraNk7GwsPCAq5w/nM+oAV/4whdoNBr4vs/WrVtP+iwCOOuss+63uNrAcHzw4EHOOOOM4fRLL72U66+/Hsjrnvygg1WHw+H4YTIY5w4YjIUH496HyiC0+rWvfS2vfe1rTzrP92tldjIWFhZQSt1rv0/G7bffzsrKCr/0S7/EOeec86C3dU9Ots2ZmRmSJKHdbtNqtbDWnlQT/LjrhB8p4T02NoZSiiNHjjzSu0IURaytrd1r+j1/HB/+8IfxfZ9/+7d/O8H68/GPf/wH2jbkfVIHA66TbftLX/oSx44d4ytf+crQyw2c0Jv1oZBlGUtLSycMzGZnZ4H1AeH4+DhZlrG8vHyC+B7M53A4HI8Uo6OjSCk5fvz4vT4bFOGcmJigUqnwlre8hbe85S3Mzc0Nvd9XXnkl+/bte0DbeqBFYiYnJx/RZ9tjH/vYYVXzH4TLL7+c17/+9Xzyk5/k2c9+9nD6yMjIULDfl6h3OByORyuzs7Ns2bJl+P5kY+GNbByrb+SeY/XBffcP/uAPeMlLXnLSdW00Yj5QJicn0VozOzv7fQ3AF198MT/5kz/Jq171KgD+6q/+CikfelD0ycb6s7OzBEFAtVrF8zyEECfN5/5x1wk/UqHmpVKJSy65hH/91399SNafh5OdO3dy++23n/CDWlpa4pprrjlhPiEEnuedELre6/V+oP6lg6qFN9544wnTB4XNNm4bOEGcA/zN3/zNQ972gA9+8IMnvP/nf/5ngGF1w4HQ/8hHPnLCfB/+8Id/4G07HA7HD0KlUuGiiy7iYx/72AleYmMMH/jAB9i6dSunn376CctMT09z9dVX8zM/8zPcdtttwy4OD4e3GeB5z3seX/7ylx/26uQ/bC688EKe/exn87d/+7d87Wtfe6R3x+FwOB4W7jnu/Zd/+ReyLLvP7kj3NVa/Z0XxM844g9NOO40bbriBCy+88KSvWq0GPLjnzfOe9zwgF9EPhJ/7uZ/jwx/+MO9973t55Stfidb6AS13Mj72sY/R7/eH71utFp/61Kd42tOehlKKSqXChRdeyMc//vETCmO3223+7d/+7SFv90eBHymPN+Rtvp761Kdy0UUX8brXvY69e/cyNzfHJz/5yYdFUD5QXvGKV/A3f/M3XHXVVfzSL/0SS0tLvPOd76Rer58w3/Of/3z+9E//lJe//OX88i//MktLS/zxH//xvcTwg+GKK65gbGxsWKXQ8zze9773cfjw4RPme/KTn8zo6CivfvWredOb3oTv+3zwgx/khhtuuNc6/+mf/olf+IVf4B/+4R945Stfeb/bD4KAP/mTP6HdbvOEJzxhWNX8ec97Hk996lMBeO5zn8tTnvIUfvd3f5dms8njH/94rr32Wv7pn/4J4AeypDkcDscPytvf/nYuv/xynvGMZ/Da176WIAh4z3vew0033cSHPvQhhBBcdNFFvOAFL+C8885jdHSUW2+9lfe///1cfPHFlMtlAM4991wA3vGOd/C85z0PpRTnnXfeCXlrD4S3vvWtfPazn+XpT386r3/96zn33HNZXV3lc5/7HL/zO7/DmWee+aDX99a3vpUvfvGLJ0Q8wQP3wp+Mm2666V5VzSGvrDuovfKBD3yA5zznOVx22WVcffXVPOc5z2Fqaopms8mNN97IF77whXs9Kx0Oh+PRzMc+9jE8z+Pyyy8fVjV/7GMfe69aRgNmZma47LLLePvb387o6Cg7duzgi1/8Ih/72MfuNe/f/M3f8LznPY/nPOc5XH311WzZsoXl5WVuvfVWvvOd7/Cv//qvAMMw8P/9v/83tVqNKIrYtWvXSb3uT3va03jFK17B2972Nubm5njBC15AGIZ897vfpVwu85u/+Zv3WualL30p5XKZl770pfR6PT70oQ8Nn2V79+4F1jte3B9KKS6//HJ+53d+B2MM73jHO2g2m7zlLW8ZzvPWt76V5z//+TznOc/hNa95DVpr3vWud1GtVlleXv6+2/hR5UdO/Tz2sY/luuuu4/GPfzx/8Ad/wHOf+1x+//d/nzAMH/RA5wfhKU95Cv/4j//IzTffzIte9CLe9ra38Qd/8Af3snw985nP5B/+4R/43ve+x5VXXskb3vAGXvrSl/K6173uIW+7Xq/zuc99jlqtxlVXXcWrX/1qzjnnHN7whjecMN/4+Dif/vSnKZfLXHXVVfzCL/wC1Wr1Xl5oyD09WmuMMff67J6DtEHo/L//+7/zohe9iL/4i7/gl37pl4Y3BsiF9ac+9Sl++qd/mj/6oz/iRS96EV/72tf4wAc+AORhhw6Hw/FIcckll/ClL32JSqXC1VdfzU//9E+ztrbGJz/5SX7qp34KyO/fn/zkJ/n5n/95nv3sZ/POd76TV77ylSdEF7385S/nF3/xF3nPe97DxRdfzBOe8IRhuPqDYcuWLVx33XW84AUv4I/+6I947nOfy2/+5m+ytrZ2r1oZD4TBPd1aO5x2Ty/9Q+Hnf/7nufjii+/1+sQnPjGcZ3JykmuvvZY/+ZM/4ZZbbuFVr3oVz3jGM3jFK17BZz7zGX7rt36Lm2666SHvg8PhcPyw+djHPsa+fft4yUtewhvf+EauvPJKPv/5z9+v9nj/+9/Ps571LH7/93+fn/zJn+To0aN86EMfutd8z3jGM7juuusYGRnht3/7t7nsssv41V/9Vb7whS9w2WWXDefbtWsXf/Znf8YNN9zApZdeyhOe8IR7Rbtu5H3vex9/+qd/yjXXXMNLX/pSXvayl/GJT3yCXbt23ecyV1xxBZ/5zGf4/Oc/z4te9KKhd31Q8O2enMyQ+xu/8Rtcfvnl/NZv/RYvf/nLybKMT3/60zzlKU8ZzvPc5z6X//N//g9LS0vD9p0/8RM/wYte9KIfa40g7ManssOxgU984hO8+MUv5nvf+97Qynb11Vfz0Y9+lHa7/ZDW+c///M/87M/+LP/5n//Jk5/85Idzdx0Oh8NxP7zmNa/hL//yL1ldXR2GLjocDofD8VB43OMex549e/joRz8KwIEDB9i1axfvete77rNQ3P2Rpinnn38+W7Zs4fOf//zDvbuPCn7kQs0dp544jvna177GX/7lXzI5OTkML3mwfOhDH+Lo0aOce+65SCn5xje+wbve9S6e/vSnO9HtcDgcPyS+/e1vc/311/MP//APvPCFL3Si2+FwOBwPmdtvv52vfe1rfO973+Oqq656yOt51atexeWXX86mTZuYnZ3lr//6r7n11lv58z//84dxbx9dOOHtuBfHjx/niiuu4IwzzuCDH/zgvfq4PlBqtRof/vCHedvb3kan02HTpk1cffXVvO1tb3uY99jhcDgc98VLX/pS1tbWeOELX8hf/MVfPNK743A4HI4fYd7+9rfzqU99ile+8pX82q/92kNeT6vV4rWvfS0LCwv4vs8FF1zAZz7zmRPC63/ccKHmDofD4XA4HA6Hw+FwnEJ+5IqrORwOh8PhcDgcDofD8aOEE94Oh8PhcDgcDofD4XCcQpzwdjgcDofD4XA4HA6H4xTihLfD4XA4HA6Hw+FwOBynkFNe1bxU9rHWYq3FGPN95z9ZI3aAk9WAu69572+9D0ctuQez3QH3td2Hsq6Hsp0fdN774oHu/4Pbr/v7cLjle32UZd//+nI4HD88RjZ7VKqKIIJeNyXpC6wBIQVpYgkC2LSpzN7Tpjl8/CiLSwnGRmht6cYJWSwAAb4hqhp2bK3RqEiWlnusrGmUgpGGYM/2cUp+mYOHVllr9ShXQ8KSj6dCpBT4yqKkxlM+3X7CynIXYzwW51r4ymPL5s34fsDqyipLK6t4YUgQSGbGKmyanOAxj7mA79x0EzfcdBsra11OO30zi3PLHN7fplqv0FyJSXoZYQiNeoWx0XGOH1tkda0HUhOWPPxAEvcypPVJ44TN0yHnnL2dqYkpbFjl69fewIG75zAIKuMeYd3SaaUIJZmYKBOKkKXjXVrNHqMTit17arRWW5hMABLlQ6lawmqDMRkjI1UajSrVSoNer8fKyhJZZpDSY3p6Gk8FGGNYba0wOjpCP05ZXVtmdbmJSRNSY7HKUilbZmYaVKKQVrNNHAuWlhJ6vZhaPWJ0rMFat08n7mPRVMuWyYkafilmy84ZWt0+I7UML0jRGRw8GHPnHTFHj2pq5YALLw7Yu2cz9ajEWmeBiakpbrv9KIlOIfPxvAxV6lGvNLjxGy0O3ZagU4nyFHGaECegraXeUARKoCz4eJx1zh5uuf02hBBEoWLbpkn68SJjEyU6HZ++lRw7uMbhm3t4RmCsode3pAa6qXuWOByPNn7qdIGxYAxoKzAaMi0w1mIRWARSWZRn8TxQPviexPMUgeejJCA0YLEW0lSTxJokFnR60E0MvQQywPcFgQ+lSFL2IAwlnmeRQoO1SAQCicQiLKDBJmDS/F+dGKwVGGPJLGgLGYLUClJjSA30yI8DBApBICxlBaEET1ikAIEYaihgOPQdyClRPCJF8UYKgbIWRTE+FwIBSCkxxiCLMbvA5sPpe4zhU2tAUKzH4AGVkketEjI6WmdycpTJqXHGx8cYHRujMdKgWq0SlSNkOUBGASKMIAjA98EPsEqBF6BliFABeBGoEngR0i8hvAhkCEKR+4MVAom1cnhwpjgXg32/JxZBLhA2vvJlBJKTaYZHCtdOzOFwOBynhM27IpYXY+LM0hiLyBKPONbE/YxMG+JMs7ba4+CBo9QaFZoiQ+uUUigYG/HptDJq9RqLzSbNHrT7AqkyurGm1zZMTwdUyylzx+dRtkHkV5htNVFeShhWSTWkOmW00SBNodfr024nzB7tkaWaKFTYTDB7fB6lPHwvQAqfzloLWfXxvYh6zWNldRalPPp9jR8KwrJmcqaG7wW0mhnL8xlKWcbHauzevZ1bbjpEqxUPB0tJrMkSi0nB2IQoEhgyer0VfFmh083oNNuFUULm4lmAUJJquYyxlpFNVY7PrSEjSWoh1RndjkGnljDyCSIP6RmMB1nfsLS6RKbb9Dttuu0+Wgu6nQTP94m2S1ZWFmm1Ynbs3MPs3DztbouFxWW6rZRazWPztgk0KZVqwvkXbKe11mKLqnPX7atkWYixBs8TxHFMvRZQqmra7ZSZ6TKPf8J2FpfWqDemyTiKpsdEo0S7s8JTnjHG6LRm9dMLnH52nTPPL9Ff9bjppuN4PvTiRfo9jVJ1jh1dplyRHNifcu5jUybG6xz3lkEbuq0UYyWlSFCtl3nCk/fQ68SsLnSYPT5PP+kihKDXgb279gApaRYwN9+nUg/pxT2012die8jcgT5xHzwFYfDoGaA5HI51ZAYYCl1lEQbEQHRLC8LieRI/kCgPpALPE0gp8vks+cK2EJ1DfTb4zQ/Em8AM5J2VWGGwAmwhAKUYzJX/kS9lEYXIRazrWSEEEosp5pdDKWiRxXIU0lAJgRSghEUV4lcM9qPYaH7oFiPsCbtui/8P5Ka1A9GZ75OxAmOL7QuzfsTW5tsptGwofawFqy1SKBCWVsfQavc4ttDDHpilHClGahWmRhpsGh9j8/QU05MTVMfKVEaqhOUSQbWECANkGCACD6IyXlgBLwA/xCofm3ro2AfpoVWE8CI8L0SogRD3AQUoJBIGrxO+s/VvbngmxPAiKZZ/dPEjLbzv6UW9P+/ro7Vr2sb9+kG834/W43M4HP/v4oc+SdZDao9mWyNElg9KlIfyFRiLRbGwENPrGapVweRkyOqiIclS6iVFvZoRluqY2RYriy18akxMTGD7LaYnKghWMcJSDmssLXWRASjfp9vL8KQg7icsxU2y2GBtjLEKgUBJxdhonV7bsrzSIQxCsAaLwlc+YaDAKuYXVml1M0ZHp6lUwShFs7kKWYivfBZnVzGJREiLEJLjRxfRacrkZIXZ2SbCCKwWZFYghUJJje9LOv2UhZUmI7VVytVJpqdGWVjoYEyGNBGetXiepdOOaXYygtosp11QIe4o1lbbtHoZGRKkQHgS4Vk0isWVNqVIUglDxke20G91IUvJYg3G0u20uH3fPnxf0esZvvGf36LVSfBCSVTxGJ2MKJcFlZrA8wMqNY9KLWR6eoxr/vNGVlf7TMxU6CWWTCeYvkIFBq0TAhEx2hin31KM1rbT7ydAj+ntEWtLMXHf4/DBJitzGVs2KWoVj+u/sshN1x1j86aIWiNFZz61EcWRg7PUQo8nPmEHveUj3PrtVaSR+L5H0jHYTBJFklpNsH13lR07J1heXmBp6QilquL47Dy9bsLMzBRLC8scOTKHFZpavYxcWSSoKbSxCB8q45LWYUOWQihdBp7D8WjEM2BN7j22hRcZAGFzpSstngJfCqSwCGsROp/RityhKnK1jrACoQ3C5PPJwWrIxagaiNRCzG4MthyK7qFQz8fvlsE4Pt8fYUXhh88FtchtA7l8zHd36KlVIvfzeuT/KkAVnmw7VPH5WN+KfK/sBi/wiRrAYoq9z3clF9a2EPHCDv4CZcXwMASASckd5TI3NiAQUoHIzQdKG9KuYanbZPn4KvvVIaLAZ3S0ytT0OFNTE0xOTzA+PU65XqFcLRNVIoJKGVWKEGEIYYgMAqzvIT0P63kgQ2wWYmSAlSHIEOFFSBUhVAkhgsIjvi7GT3R8D9z+EqxkXXgPpj96+JEW3o4TebhEvMPhcDwsqIxSxaPdzLDCo72WUipJkiQDC0Eg6CWauCvodjJOP6POWWft5dvX3ka7qem2MwSSbq+H7Wh6iaXrGyZGIsq+ZvbQGpu3lrDGsv/wsXyA4hna3Rh0RKUsqZQbdNs9SmGdWt1neWWNTdNlVlc61GoNlhbmWF5MyeJlrBVIBY0xy/TMFGtrKTr1aIyWmRgfZ9fOzWiRYrXh2OEVNk3NMNdokyV94jhj7vga5VKXickapVKZhfkmEoE2Blv4PXxPEvfygU2zZbj7yCxTE4a9e7ax77ajpCl0WjHdvsV6IDxNUBE0Wwm9nqHbMvQ6mm6kqIaKNEsIpSYxipH6GHOLffo9S9mPWJxr01pdwZOKuJ9ihaZUU5hU4wU+tUqFhflF0thgsAhPUCqFJElCu7WGIWVxUXLw7mVq9Yg0jdl9+ha27NA85ZmP5VMfu5X5uT6pMfmAOLUcuHOOucNttu6uUZ+ICMKYbr/P7bcnzB/SJF3J45+4CfQcy8eXOHyn5pxzKuw9o87m7VXCskIpy44dHUYain5vha1bI3SiWV3pMzVTY5Ee/X6HsckyL3rpRczOz/N/P/d1GqMRQgk6vRgJBIEkKlmOHpoDFEp5rLVislVLpZvHaoYRlCo+USWl29LgwswdjkclQhfCuPA+KwppJYsQZAHSGpQuvOEDz7OwGAFoiyg841iB0hbPgDYGX4AvIAWUzL3OgRwEPoMsvNJyILmtKDzUA7/1+vjbDuW0Xfd4W7Eu7AtBr0Q+N3bg8c5fXvHKvdMiP96Bx74Q3ULIe+hOgbUGY2zuV5f39AjbwgtvhyaDwb6awhiQb8gUp6fwikuBFRKEwbOSMPVA2DwKQEJiDf04YXl2mQPHl4mC/VSqZRojNaY3TTIxNc7YxDhTk6M0RsuUqhXCahmvWkIGHvgKEfp4XgmCEkL5WC/E4GPTAC08pCqBipDSBxlsCE33yIW2NziYDccrB3886nDC2+FwOBynhCTr44cSYyxWZ9TqEYgMz5dIKTAmJu0r+rEgSS2+N4HNphBmjsW52TwnTQmayxrlSSbGAkphRq+zyhmn7+R73+2T9mssra2ytpaLKKUCktgSxxnddszERIUDdy+D7TM9XWfuSJux8TI7d25Ha8HE+CayeIVOOyNLDZmOqVRCVlfynOQtjz2TLA256cb9HLp7kVq9xPjYGBc89jSEyEgTzcqU5tiROXrtFOVJtu6Y4ujhBbSR+cBGAEIjlY82Gk9ZqiXJ5s0TtLtrzK8s0OwkhB6kmQQhkQZ0lmElmEwQypDmYkK/ZRG+otcymB5s2VynVle0Wj2OHlqkVm0wM1WnEgriVp/VZUiTmEa9QaYtvf4qY+MR0vMReOhUUqt7WJXh+5JeK2Z80kPaPOy920kZGQsYHQ9JNax1ZpnKKszOH0QGlh2nN+i2+6T9lCgI2LmzwuhoiU63S7/VY2rbOCsLbVqLfaqliMQIAtWgXusxPiIhXeEx5wds21OiUq8zv7hG3DW0mwl37+8ghGClJWl2+pQaBlVuM7VNkKQhmY255bZbufnmBeLEEKddTGJpNg1nnVOjUfM4eqCFzkJGxyOWVlZIEoHveXSWNAhDEvaRwqfe8Im7GpO56DGH49HMRvE9CB8XFqQBaU8U3aKYWUqDlLaITCrWoy3oPHrdCNAK8HIPs/IEfpFr7QuFT14/Qg5CuO0gFHzdq2qxw3xsawtBbcHYgTd9PeNYFuHmg7vNwMOthEBR5GhbOxTq9h7eXSXWPbnrOeASK3JP+IlscMpxbyedBUxhKlgPQR94wC0WnZ8zO8i/BityTz5CIYrQeKwg0RCvtlltdTlwaJZS5FOtVhgbq7NlyyTbtm9lcnqC2miNSr1MUPJRgY8slRBhCYIAEYSooIT1A5RSQB+rgzx3QHjoNECoAKF8kD6oShEj4BVn0suPdHgiHl3q+9EhvIu8BSEGeQkb2PDG2g3vTzbf8Fqy6xM3Ln/vVTpOEfYk7zZOO9l3YO/j75MhHsA8DofjkaW7BlhFrWbR2lCu5tb7cqVEa61Pvy/wQ4nyFe3VlLmlFv+/j38VqzUjk2X63RZROaFaEUxOjuW53WmHXjOmXV0kiQ2HDqzST/vEfQ/blkjPIjyDTS2rrS7HDnfwVQnPg2PHW9hUoWyD6645SJIkeJ4ijCLGRusIIZmfX2b2aA9ruxgDs0e+CdaSJJpMp/iBxA8WqVQOE4YZnW5M3Ie4r8H4WGvo9TI6vTgfHEoBQuJHksZoyBlnbaXXWqDXbDEyUqVWH+XIkf1Am/HpiHQuJk70MC4xiBRSWWySMDNZYtFmdHsJlXKIMPDSn3gJN33vG9y6cCcXnH8eY1N1Ot0V1lbnyVhldDIi6Wv6hVc+KlcwWLq9Plu3jnD2uSNkJiPOYqzVRKWIKFSYLCVOBb4K2Xv6NvyoTZJp4r7H7be0mZyY5ornncvN+25jfi7h3IvPY3VlERWt0Iz77LulgxIepVKV7167QliK2HvGCO1uyl13LnLk6CKTMzA6o4jTlJWVPjfedDteSXDG2TsYGZ/mmq9/h95axvat43TbGV6YsWlzGV/59DptxibLlBqWPY+pcfz4KquLhtH6CHZ5jSjyecrT97JvtMm/fewW+nGCH/qEnqZcClhaaSM9RWwMYWgoVwT1hkAnLtTc4Xg04vs+xhqM1Zgi3Hzwr1eI20JFFl5Z8pBvYZGSQniz7vk1+bym0BZW5YIYqRDKopRGCoE0Ng9JJw9NlyIXucKaXOhaizW5R3pDGvkwb3qj/BvoZTEMNaeQKoMDEqDsIFo9X9bae4yZBXK4sfVpgxVbcc/x9Pq8eQ66GkZhm+JzUxScE6j1EPlC0MtiwQxLJtNh+TNlBVILfCQSQSZNse8WtEYJQdLts9aNWVtc4dD+I/xX+VZGx+rMzEywacsk4xMNRsdGqDVqlKpVgloVVSljwwARRYgggCgvwCasB8rLw85RmKzIxffLCOkjRYggQogAS4AQHpbCK77hO1i3WJzkIvshCERhT3FycLkSDCuan1CZj3XxVGQa5KETxiLFoBSBHs5rrRjmNQjk8EIcXMDFXINsB9aLDDCM+98YCPKDnNuHs6r5w7EPg3U/kFDzU7kfJ2znhMCb9et7YFiRGyeKDdeBAGslVnhgiu9JkCf2IACDsKaw0qki3wVAY1MnxR2ORxMj230sUCrnz4BSRRKWFBaDziBLwViLTjy01nSbFh1bAt8ysyliekYQd6DfyXjSk89iz94z+drXbuQb/3k7IGk1MzxfsXPPGI993BkcOXCQbbvGqI0EHD++wB13zHPw7i5JP++uobWhVvLJUkjijEajxvLyarG36yF9oIoBlB3m0Hk+GKuRSuEHijSL2blziiRLWVzs0mtnmMwipaVWL1EfrbK80kIQYGWXM87dwuR0ndNO28Pi/GHazTbTYztYXW1z47dvwNqYemOE+YUuK2sx/dgQ1T1Sk2GMIAwpasUI+okBKxipKp77rEuYO3oH7bUFqtUaYSVkZW0JKVPK5YjmWkqvI2itJZTKIf24R6msCDxDo+EzOTFJq92k0+kwPtEg8EscO7xCHCe0WhYZSFQg6XZTHn/h2Xh+ysHDt7N7107SxHL33UfxQ8P5T9hBszNPs5kwOlFn+/YqSmSszvdpNkOqdQ/px3STPsuruXFh6+Yap5+We8RvuqFFL4nZ85g6U9sV5UqJ1eV5fEJu+mbMof09PE9SqVk2b5phamaE1fZxYtNj684KvV6fm78ds3y0RGetz+SkZHqyzG03d1hYSPDDfMShbMDk2DiH988ifIEWGs+TKCUgk7RWUxaWXLi5w/Fo45dPDzCFnjCFJ84UAlQV3u4Bg7HjRs+3kIVHefDeWIyBxEJmITGQGbBK5qq48I4LBUpJhBh4zEUh6CVgctGdgU3BpiKvap4aMAIpc3GbVzYXZEgybcmspY/J89QL73kgLJHIq5oHEpQUw/zswVENOzQNy78VhoUTnIzrpdsGcwu7nvMsNiggW6itPOTc5pXErVgfw9vBfMVWpV0Ph0cirShqkAu0zHKndDHvoEa5HEQmCAnCoosQfC9QlKsRY2N1Nk2NMrN5ivGpScZnJqiM1ig1KnilEFWugiojwggbheAHEITgKYzy0aKCEH7hffdR0gfhIVBY4WMJgDzCC6sYGinsBoPHUMuc6LA9FfzQhPc924lZWBdNQmCHJhqLJxRDO0xRsVDIwrJRfHm5FahYXxFiMTxf1iIL0Z6LOVHkQwysHPphFd4PReT+oKf9ZML7gfDDFN5womc6/87zlxTFxW8N1prhjdECwubSXBb5NUIIPLl+s0xSjS4snanJC00IaTGJGyw5HI8mKjMSzxMEUZHr5kmklFhSrIWwVKIx4rOykLK82CcI8gEMBrZs9ZkYl8Q9y+jIJkrlgPHRGf7jKzeyMN8kTSUzWyqA4fEXnk2ns8zhw0scP9Ll3PN3cfzYInfdtkKa6NyYhxkG+lmrEULgBz5JP80HBHYw1NgQiijyti1CqLwwnMyNwNIXBKFgcrxCWFLsv3MNneb3Id+XJIlmZusYBsviXJNKwzI2XSPLLElqmNzm0xj1MLFC9wWz+xfxfcPExBhJqlhrdoitYW2lj8aiQo9SOWB1pU1ltIQqG5JehohhrFqi4hs2TYyQxD36vS5BycMLBWmasbqSsbZqCAJFqeIR9zXWaKT1mNlcohxJorJldGSCwA/ACJrLfYyx3HX3LMvNDsIX1Eeq7Nq9nV5vmbASs7rSYmpihNWVhC27PXac7tHrW+IkYnUlw9qUtcUOUWC47PnncteBu0FqjAmYm2/ieyFjI2UO7VumGpZZWDSEdR+vktDXPeojVWzWp70s6K3B9m1lJqY9ur0+UTBNqTzGXQdvQ8sOvi+plgPKQRWlZ5g9vEpzdZUdW7fx3W8f547bFwlLkiy1tJZ17q0J8vDKVBv8AOpVSSX06XU1+26LH8FfjcPhOBm/cpY3DOHOdcX6v8papBmEea8vM/Bw59XCZSG8i/GkMWAtWkBqQRetv4wEI/KyaFYM48uL6OVcjwzd0dZgDPlzKwObykKA5/siVC5sjRX5upGkOt9WTxqywZgYCGQuvkOZ55vnxdXyY8zD2iVioH9krmPylmP5GFpSjLGHPul8TJyrn42ux3uy7q03tlBfxb/5e1F8np+H/FyuC+781AiENEPjBtYgKaqzD8byhQPUFu58O/DOG0MgKZ5RIWNTI2zaMs3MlimmNk0xOj5BVKsT1CqocglRqUApgtBHlsoYGkgvysPOvTz3Wwg/d87le4EgBBsgpF9cGIMoADkMSc+NNadeeD+CoeY2z10rQiyELawoEpTIkKKwZAkwOreQeGJQzVCve0eLUImcQa82MdTkucVncGEUV7jj1GKLohBmw9U7yCMx+Y9OF3cMYcGTAo/8Vx54gkaoCDHUqgH1eplKuYzvKawxZFrTig1G+DQ7CXNLTZq9PrHLy3M4HnXUGh6VSkS/3yPLoNvKUJ4kiBTaWloLPdZW+oyPVwh8ie5AqWQ4+7xRRidSuu2UkYZiy6ZR5o63aLdXscZHIwkqIPyY5krGDf91O91umzQJWVpI+I8v7gMEaeEZlsNmpxZr8/6qCIvRmmHIDYNKqLqwgKviIawLTzgIq8AalJDoxJClmqnJCpHXJBVQH6nQbLaJSj7NlTajY2UmJiN2nzXK1l0jrDabHDw4S6MeMj1dZm5uDiM8pvZE9Do9zrrgDFYWe9x8yy14nsHXApsKtEnITEJU9ejEMZ6QkIHUlt2n76KkPHw0ayuL9NtdylGJbdu2cHj/YWTWZ3qyTGIT+r2YWqWEpzSdtuXQ/h7lCmzZWkbKFs1lKAclAuUTKsVMrYRIUvpCEHqW5tIswtfMjI8xNjFC5AWceW6EiVZZaS1SLiv6y5qjh5o0piQiMOw6s0ynd4g9p43TXIKlecGxO5cojQpGRn2mphvQF+zaO4INFHcevIOwpDhydxMdC9bmwLOWxz92O63lRfbf2WZqW0xjfIVNWxQrS1UO3Nbh2KE1qqUu551fJu1n9FqKm248SLeT0Wh4SCXpiZjamMVmljiFNAMjBVEkCX0B2jBSix7BX4zD4bgvlFqP7sydOIXILvK6pSyccxs+KyKq10OtB1ZVW3izizxtWWgJjcAUjj5TmGuzgY8PijDudSGei1OLzQRokT8+zCAe16xvGE70RJFnIxub6xoDZMbiCYHOB9EYijxykUvovGd4no3tWbFBI+bt0gYV1fNCanrdETnQWcV2DfcozMbg+AbnIRf7hrwPeR6RX/jYi5UYux5KIApRLkwuwLWww+rtWuQmAEGu7/K9LYwHZkM/9Ay0trSTmJWl49x123GU71EbqTExOcqWHZNs2bmFya2bqY2PEDVqhJU8J1xW2hCUc694UAe/lhdfk0ERNl98FyLLHa/CYsmKM1rJjSnDK2VgpDh1KUePiPC2haCWxRdT8gT1qqLsS6phQCkKiaKQdrtPr99HSEWcpLmHMzNoY0mNJTOazEI/tWQ2r8pqRS6+7bDe4eAkDjyw9qQXnOPhJb9BDW4++Y9xENEggEBqpNB4EuqRpBr6VMOA8ZE64zWfSKQEgY+SkijySXp9EII4sYyGAd3E0vAiRqKQo0tNZlebj9zBOhyOk1KKQpSSRFGNlbUWIlD5fRqTF7XpCboGojBB61zgTkyU2HvaBL14kSioksQJR48dYWHW0l5dpNfpMFrL+7VWQ2hsLdFu9fCUotlJUVKgNUV110HIXD4AkmLwBBAEvuLsx5zFvltvJ+7nz5dBnRGEREiNlApPBWRZBlZhdT7QSPu5ASEMQiSCMFRILalVyywtdvJBncwAwVMvOYfHnH8aX/zqv9Pu9NCJJG7D4859Al9rfZXFXpznwK1lfPkb3yYKSnRsRntJMz4VsWfvDtqdPnfccZBavQy9Pv1OQiQk0xM1quWIOO7R7KzQi/uEUUQQKm658Q4CJTnnMXu48eZDJDZmaT7BmwyxOkVnHvXqGJ4nmDvaY2F+jeaKZnK8RtrrM1NJOW3nJL4M6doyXjlkrb3MRU8+n/p4yC37buO2w4cZnfUZm6my/64uO3eUSfuWx1+wjdiuEJVLdHodrvnaKhc9qUwganhGIPHptA3f+MoyFSUJfZBBh8qox2mnTWCIadVjlmY1njGMT0gI+uBHRCN1jhzTiEjz1AvO4yuf3cfi0RatRcH47gZpAnfeOUsgqywutAkChVQaIVImJst02glZIvH7mjizRdi+ot9JmJkaod/vP7I/GofDcVKUt96L25pinGmKFFQjixzv4h5uGOZda8BoQBaeYTGoFj6ofW2Q1mBV3s7LUIhhm3vAsSp3GBUhmwM7rRjEsxuBLQq12Xto7ftjGPRtcyGbYkDmTyuP3FM8CNcWFH8XRc2EtUWOeBFmLtZDy9dfdhiGLlg3LSMGddfXGeakizxN2xTPQqPyiGRT+M/1PfKl81O9HpYurC1C48WwEry2Mn8S6/wZLIVAWYkwhRFBeSiZRwhkqUVJH6MFaWZZ6LaZP77KvpvvJIgCxqfqbNo6w7Ydm9m+czuTM1OUJur4lSqq3MCWuxB1IaiBXwLl5ykBwgOhCi+4KMLpFVkxNhi0fVMbU5pPEadceA/zEQprzCDUWdj8y60Fiq0TNTaNVCgrS9bv4/uKKPBpBhmJiPCDgHanS6YNquyDlFgJ7V4fFYT0Yk2rl9DuxaTakFrok+cByw2mLsGgHP+pPur/txlkDWgpih+7RRiDFIOag4bpqmKsFlEJPapRgGc1tVKJyFNIaajU6ggh0FmKSVJKUYjOUqwUmDSm3WrjeRFlQsYqIUtrj/BBOxyOe9HuxPSXNH4IQuYBXzqzpCkoKamMeFgriEoR0kqUsExMjzI/l3HLTW0EHfwoRYiQQ3dl+Epz7mPH0ammHJVZWl4mCiwtm2CMZO/pkyR9n1Yz48ihebS2eYRUEQKl9XpLFa0hDH127d7Kvn13FxE6ubCOypLqSECrmZL0EoQc5HwPGsEITAbHDq/SaXkI6ZH2Uubnl2jUy6ytdZFCMXe8yaH9yxw9cj237lsi04akr2mOSW76zjKriyVWFlPi1EMnltW+pt9dxQskSkrSRLO4tEB9dITN2yaYPbZEKTCoWOIJy+7dM2RZxlqrSb/XZHUpRqYGD0HcjpGRx759d5AluVchkHlIttEhrWYPgWZtVXP0yBphSYLN6HaahEHGaDVk//wKK21DZvs0fMHU5DQzkzN88xv/QS9rsefsMlM7Kqwuhfgi487vdZiYKHHr944wvSMgJebA/h6RGmNxvs+m0QhMQn1EICLFcgzdVY0aK3Pu6bs4dHQ/c8dXCEuSfl9THVEEkaEyKphrrrK03OPYkmZlKWP/QYFN9iNNhM0kgSc548xtzGwXVEa28K1rFtBkdHqaet1HCEWaGDwlCSoKpc0wBa3XT/FCxfT0NF0nvB2ORyXKW09XRObe2KLkE1ZahmXOjRhGww6EsJC5AB8KQwm+lAiV+1yNBqvzWkIDkQp5rWx7Qrh1vg6jzbC9lzAgzD1EtxzUL8+fPSfmaucM1meFJMsXwgKpMSib560Har3SuR2knov1DO48vLyIDrb53ntivcv4xteAjZJyuEsDIwJ5HrtF5nVRDHkBucKFmYl7Lph37Rjsg91wXNrmRo68LRpYo1FSIgVoq5E2D//PtCETef9wI8AYgUEVYl+A8VDWw3Rh4dAai4dW2Hf9bZTLIVMz42w/Yys7TtvDxJbNlCZGCUZGUJUyqly0KAsipF8GrwyihLURiAhjLVIkhU5dj40+1SLxh+bx3ii6B5R9ydaxKpvrFcKsj+gnlKRAZCBlQgmDMBkyhXqQV6azxXr8yKcsDFIp6tOTxGnG4vIKrXaXdpqxmBiSVBfWGNarHxaGgI0GgQey7w/1mAfcczs/qn22H+h+G8GwuqHQhkBASQnKgWLzxBh7JkrUooC430UCcS8lEhnSaoxVGOGjswzfj/CUJEsTekm/GEgbAl9iMGibESjw1I/m+XQ4fpwJy4bqiKXXhnINkp6kpzXCelhThPIZWFltogREnmRxqcOdty+yNJ8wMuajeookien3PUxkmV/usG37KEoalvYnRJmlVA3wA5846RMEIVmWYIzGmIGvYHD/3XhPhm9/60YmJkfxPY84TVGeRQWweXud7btrGKs5cOcaa8sJ/a7O86PJ87iz1JCkgpWmRghNllp2b5/hrLPO4BvX3MDS0hqeL7jjlkP04gzPD0jTlCyxrM4nfPn/fgfjpxgh6La61OsBvW5C0rSk0qACSdzKw/PSbA0hukTKIIVF+RLPLzE+vZX/+q99LCwsEHkZumfxlcATktAL6LT7eKGkUauhU8FIpUG5VGJ+cR5jM3bt3kmmoRvfwuJ8Fz8QSK2pVUbZd2yN6ljIxMQMxBlHFueYkn3uuGs/nqixZbrM5NYeE9sDlCrhyxGO3HkHQqcoL6SX9UFn7NkbEXdSer0Eb7LE3j01EushyopNU2Vu/68uKE0q5pC+ZH7OYEjQxjK1qcTM1hpHDnbxwz6ZMZSqhlLJoxqU2Lp5BwvH5hmfCKjXqtx+x13YcolNW0d50U8+i09/4qvMHlmj00molCuksSHLUvxAE4YWKyV9o/ECiwoER+cXiCIXau5wPBoZOu4oRKcs/LoWDCYvumbAiFyk2qJIGEURND1wvBVpvVZYtDUoIRBKkVlBlulh+HruuBV5nrgxeYjyCQnkueAeeHoZ5i4PQthZrwt8EqmhC496bAyJBVukX0ogQBAUFeF8kQtXI8HoLN+mFKgiHF1JlRf+LLz51uT57koO+oxTVGKn+JsTdmh4THkGVu5JF3ml87z20nqGuGJDqi8DW0fRMjMv2lVUSBdYmRuptR1UhQc7MH4X0fpSmDwCQeWfGwuZzb8XUxi5PXwUARKZRyaYBIugvdynvXKEu+88hFf6FrWxGpPbp9iyZws7TtvOxOZJKuOTBNURvFIFEVQQYR3h1UHVkDJEyKQwr0gseVG2PLbg1PGIthNTEuq1MqWSR7rWRwmNH1WwIiCxgqASkam8ubsSEm1Ba4OxhtAPGCnXSJOEUmjwpCGYKJONhqx1+pS6KZ04odPL6CWGDEj40RW8P2rkRS4MPpaKkkyUfbaN15hqVGlUQsrKEvf7xGmGkR6oAFmqkWmNkHnVRyEknhdidEqSZEjp4QUBwtP4GtqdfhEOI0gHSTgOh+NRw6WXl9DaY23FZ+54xsHVNv2+IPINHpI0sWgpQUniVJMpQWetzebNIZ7SVMoBiIxSqcJi0CfOAo7P9rBeyuRkjX4KoQ7wlKDbsxw70ibur5Jl+QiryN5jPddOIGVevNNagc4Es8eXAQhCxdSWGuWqZXpTleNzR6jWS2ibMT7jIWVA3IN+L6FaCQHJ8WNtEqPz8DxPcuTIPIvzTUqlkImJMs1WnyAAhKDfS/NwRAOeUkzPjBBUBRMTm/je9+5kbW2JUjkP54v7Bt3TiBCUDan6EbPzy/jKJ+4kCJ0xOT1OKaoyOTPN4uoqQdkS1QWVsEan3SYMBd1Y0mpb+qoHGURly0qzifQFzWbCtdfeQqkSUh/1iGqK086aIDVrdFsZdraEVIY4a+L7Zdb6Gr/TZv/RY8wfWGNyOqA8EzGVTbBt62l8+Y4vMLmlxNJsC+nl+fA6kczOZZS8iKmdJfxSiu9l7N46yZHlFrt278WXqxw+eBgjE7o96PcN1UZAp5MyPtLg9D1bOXrnrYyMRfjlmJWwx9hoHmJ/0403ctctbXyl6HZ6dPoZiexzfK7J1ulJxicnOLx/DY1gYrzKSM1jfm6BfidhYkwQ2ww/gFLJI1CS5eYq48H4I/RrcTgc98e65hUb/s0L8SLASj1shmQLcSqK6mpmo/iVovDIasSglxiiaC0myLJcBEpZBBxLDYXnWViLHoRlU4Rvm1zMasHQCz+MtC1Upj1JuK2VeRX12FpiUwjYYq6Sl7vlBSoX1NKiJIjcokCGIDN56LZXeLplofQ9JJ7IPdaYfDlZRABLIVCcOF7eqIukLdqHFcHoSg6SdQtDQhE9ZgfeaYp2bINjMhunrxeWy78/WXjHGa7DFkYAqfPvyZIL70EleASEaBQxBpn3Nxe2qHpa1AfLJHErpddaYv7oCjdffxt+5DM1M8au03ez84zdbN6xlZGpCYJGA69ch7CCiOrgN7AqQHghQpawhMNjPVU8osI7MxYtDCrw8Kpl4naTvtaElQCswEhL6JdBSLSx2EzjmVyQyUASRiEGTZLFxEmMpySlQGEIwPNpdQVlTxEbSSc1tHoxcWaHhQNskaRhbRHff4Il69Er0E9xIfoHvG1RhNkMskry24tBkl9YNV9QL4XMjNaZqVdohIpIGJLmGqvWgvKwMqCbpJTrDTIVEpuUkqdIkz7lUglshskyfCXxowAs6DghSVKSOCGo10jjPol55M6Jw+E4OaalSBLF3IEe83PQWtIIaUmtpdu3xD2D8CSjmzwI4fEX7KEaBRw9fJRtO2ReXTvzwXbZsjlCBQH9OMUPDdJI6pWIY4d7SAk2FXTagwGFwFo5vCsNpgFonQ73TwiFlBKhIM0ylpaaZHhkxzRaS6IS9PspoDjrnBqdTptWE7qdPn4QcO4TJ2j1Mo4e6RK3M7KuRpuYCy7Yy9GjHZa/tx8/UIxNhKyt9EFImqsZ3U7MLd85SKkacKzeZnR6FG1SUtmiOiURqxm9JUPaNhw6cIyjK5aJmRK1SgmSmCTtsn3rNOMjDSYummL/oduI6j6+b+g2eyiRIYwiqoHpg0ky/NAjSWM0hk5TsrZmydIOdrnDaWc1eP5/28N5T6zRSyr813Vdrvl8k0gJTNqiqduEEXT7hpSYY2sZK2nM3t4I//nFgxw8cBuLyz1So3nMuRFRlJL0BO01y8z0JEqm+L7CE3VGG+McPLiP0cYesn6F40fvAJty7EiHbldiDXTWEkbHqkxOjLM0t8LEeIW15S6lOKNe8Yj7hgN3rtGo1dh5dsCx/X0mKjW2lkIWV9vcvpBx63dvYHTUJzOWtCM5eniJKMxb/0QlnyTVZBp8v0SWZiRFl5WgVPph/kQcDscDZFA0eRAanKew5t5VKXPvMEXxMWELzzciz8eWMq/3YYuITMDqInzcCoy2ZFkegYXJHYN5ZXGbV0z3RCHEBWJjz24KESpz77cu9nP42eB/hWd42OBLUBgFwAqDJhfhea0RUFai8PCET1CtUIkC6pUKo/UGQeCjDRhjCPw8K91kCUkS0+t2idsdsjjGao0wGo0Bq8FqlIVACITVqKIalhAU7ZolQuSl16zYkOUsgHuI9UFKqSkE+LConbRFJfS8ZRoIhMzz78VAgBfL2Q1/YzywsljOkFlDanSeDiQ1SmRom7cwUxQOWVkYPCxIUfQSTywyBd0zHFtZ4Pi+Bb5Vup7KSJ2ZneNsP30n20/fw8z2bdTGJhG1KVRUg6gCYQ38CogQ5Kl7Djyiwlsby8pKi7GSTxBrKqUqCEmWpqggQqJRKu8DGyiJr4qUd5VXuBYoPC9ESIkXqLxyrZQESlIReSiCkgKigLq1VH1Dq5vQTC3dDKxc73UnrUaSVwF0vtMHQBFjIqzCClVUX8wrzwfSMBUpzpiuUC5FhEEIJiVJMxIL/UQjfI9SFKEzjS8VSgpMEuOL/AfkhSHCU/mPW0KvH5NqjackQifUggBZVsTKZ7mzysYC6g6H49HB3XdHNFtrLC3EtFYkaccihaQy4lOpCnoqQUT5CMb3JIf2H6cUpuzcWWJqYoJjIubQ/jadvqav+5RKcR5Kt2YRsk9Y8oiq4AURJhG0O10GcX3W6sIiXhRLGaYXbdxDg/IUlWrIWrNN3IWWhOXFLjPbJFHFMD6tWDye0Gz28/aYQpMkCe1WQqu7zKbt44QR+X2sKlE24tvfuZvFuQ7K92g2Y4yBSjUvFOkrgfQg7lt6nYReZ5HFpUWius/mXRMkSY9O2kIYSammCEYg8zKEUPi+x/kX7mRtISaKIv7ja//J/ruP00/79LuKUl0TGkmtVKG72iGMPKJIocoenWaCkZZKtUSz3aI+GtLvWlSQcdrZDY4e6XL3wSOMjkd855ttDhzK2LEz4LJLzuc/v34HrV6TpzxlG9VGidtuXkXHljtvbNGPYxaWukQ1j60zIXtOCxB+xtqaQZuMiUmfqS0lVudajNS3sv/AGrfc3uL0x81yx61LHLqryxlnjlJtJGyaFmgriGMDJsSkKXG/ydR0hV7fMDe3Sli2pJnk0P6EMGhRjQy+XyEqScYnJZ1uwKGDCUp0Edrj7LOn6bUE+++c4wkX7WVxfpl+skY5GmX1yCraGEqlAElKr2fpd3s//B+Kw+F4EAy8yTAYsVuTF07zBKCKQmAm71yhbV7qSw1VJmgjMEIVkbSWTEOSWdK0GMfmjcHz4l+eh+9LpMjD0H1ZGAEMaF8U/a9zJ6wpmmLoDLQWAwc8tujUpLHDquloi2cgFAIt84JxSuYG4WpjgtP2ns3ZZ57OOWedhRSScrVGY2yCdjdhcaVFuVxGYDA6pdtpoSRUqxWWlxfp97sEQrF5ahJlElYXj9NrLXP86CFW5hdYmztKb+k4kdV4UFQmFwjp5cYLkRsajMnYWBHdDku9rX8Tg+JqFoGxedMwjc3tIOQGEFHk/VryonDGihPmNxisGLT8zNu8DVIIEpNPDYQglIPsdgM6N5ZaVXTBKuLXi4ou+TViBGk7Y7mzyMLxRW68/naCcsTkpil27N7B7rN2sX3vHkY2byEcn0CUK1AqQWXy1Fy6PMLC21iIU02SZJg4xcMjjAKyoreekALP84o8DUGgJNLzCquRIU0SrIUs0/i+z6BXuFQSpQS+r5BKkmEphyGVwKPsdRHtGIEh0RmpEUXe9+DCOTX8ICHuj6SH+z4RgJBF/rxGUoSVe7BposaemTHGAmi32qRJXFSQ9FBSIjwPLwwJSyVkmqKUGlY0VkohBPi+j7GWwA/wPA9jDLYI6dRZWrSak7R7PbpxmufuOByORxX7vrNAYzyg3ihh6BFVI5qLMf04xWpBFkOtUqa5lNDDsmmsTBSkjI3uII4zlteO0Ir79A0kAspRldmjTSqRz8hIGRmkPObxY8zOJqwu9glLkiTOBz15pxOdJ6yZjaJ7veANWLIspdM2WG0JwgAd559WygHWGjZvqaNkGyGg2+3QqHvoTGHQWAVCrLB1m2V1KUMpwdiYwCQeiYGkZyHw6fQSGiMhSZzQ62h6XY0xIJUgikpYTzM2VuXpT34id95xO7aT0pUZ7WZGe8GCBwtrLbLxhMfsOZ3zLn0idx24i2PHF5EmxfQMndQgRYAXCWYX2tRLZbqdlF63x9hEjUykgKTb61Ef82iuCjKj0bHHFz9zMPcaeYqpzZokzUt0tBdS+qsC00+ZngiZ3lzllpvnuOSSXRw7sIzKSoxWRlnrHuExjy/hCYWNI44cXqHTi5mY9Oj3M265aZlQSa5fu5EjR9us9jXH5psIT5PFlgN3rnDu4+pMTtVRXpk7b5+jWq7RW1bs2X0x5XKA0ocpyxZxbJnasonJ0grfvv4WyrWI00+fptoQHDx4hB27RqmP1Ll93xFWF/qIHT7ddhcpPEq1jCeeMUmrVcGTI6iyz/79C5SiiN5ajNSCalh5RH4rDofjgXN/Q2oLSJnrAKMsqdYk1pDljSZQUiCEwlpDpi1JZkiKFoMmg6zIARcmd6J7mDz/Wsmit3aeq2z0oH5V0VLMFOLbyKEXOe/EVLTjsoPe43lOuEfeoSkPAQdfeew+7QzOOvscHnv+E/H9ElIYtLBUGw0q9Tp3HTmMF5TpZhkH7rqL5cV5jM44duwQxqS0Wy1avQThhXhCsnfHds46bRcXnPsYzjlrD+3mKs1mj6Vjh7nxG1/jtm9fQ29lltBkeDbLw+3JK75bsbHkWOG9VrnhYmMcmbBFQTVhCxFd5GsPdVWR+17kfNsij9wU6x0E4ZtCiykEGoNXnENh81QBbQRpUX690PEoe5Jr4R7vZZFuIAGTGdJ2n0O3H+TQHQf4+pe/TqlRZXrbFvaecxannXcum3bvZOJxF/9A1+f98ch6vC1045Q4NfjKox8neEGI9HyMhUD5KOWByD3TxoJUXiG2E6RUpGmat40RGqVUUVzBFl6MMsZY4iTBUwqlNTLw8eqSSj9lrZvSSQyJyXv3WfJflHOefn9yK5bAWoMnLZG0jJY8dm4aZevkKNXAo9dqYYUgCEMABAqlPIQXoAIFQqK84hIUIv+uAc/3EFJSiiKwll63g+cHWKNJ4z5plqGtIc4ssZYYkXuQHA7Ho4uxiYBOz7DcTDFIwpKlOhFiYkNrLUOnliTrEoaKWl2xMLdKuRryb/92Yx6GJ1O0gU43t2wruUpUFfT6Ce1jCeVIEvfyx/bunVWSLZLbb1qmvQbWWIJI4fmKbivGWrGhyOdAiOcecU8FKOkRx3E+CPAk7TXoNDVp0qbXTehOZExNeyBiGiMB9foI1msxOiZYXkiwWuBFitR0ibVgx5l11hYzvJKPzTIEmiiyhH2B18sru1tr6XV7RDUPP4Djc8eoN+rUGnXmjx2n3xYIH6RUmEySxII77thPp92nudoj7fY5bfcoyyurLDQzfDzibooflNh12h5u+dbtNOoVpNIEJQ8pDIGyrHU1KMH4piqry3nqjsksaEOnZWiM+wRbM847v0pP3kUv6dKPJV/6ym0cPZxxxQvqlBs+d++bZ2qyyuhISGcpY2xM0GouEKiQ8mQNqQSHD8b4QZ0mfUqhJmpENMoRx+ZW0D0Iy5Io9FlrxrTjY4Ql6LY1y8c1Z+89h10Tj2PP7j087rSYUjTGynKb5eUFjh49wIQaZ352jeb8Efp9zfJKj8bYNFb3SXqa8YmA0XGNJaMxMsmBuxaZm9PMH4+x9jitdsrU5CSTI6PcsXg7Jd+j4oqrORw/0uR+oVwuSplX+cZaMq2HrSYhA5OHJ1sBqc1fRlBUGM/FsJIQCIMZ5ImLPK86H7/KXMwZg7S5sBYahGb4nDE2Ly42yHe2A9Vq8/RWT4IWih2btvHEpz2Txz7+Irq9hEOHj7Jl6zbSuA82RXiS+uQ4MlB896bvcMedB5mbm0frFJ3GZFmM7+fdMLQqkcSCyPO55e4DHJ2b5a5DB4jtZezatZ3YF/TL4+y++HLGd53J3d+5liM3f4uss4Iq9k/aPG1UykG2d9GMTGuEzFuC5TnfA1G+XmxNFqHgG52ZVliMlMOq9KbIk5ciN1qI4nwPRLtQEp8iP3zDM1vbDYmtIvesS8OGLeVGlwGafH/WK6tLPCGQNi/Gp3uWbtzkzvkmd95wK1/42GeZmJnkrf/+cw/vRbmBH0o7sWElwg1/5wn00IkN7V5Cteqjs5Q4SQn8EM/3kSpv9eF5fh6WYHIvpyisMFFUKn5AOYOKhsrzkb6PNabov2rwlURZD6UzJIJKo8xISTO32mGlq4mtRQux4atbZ9AK7ceJh5rObgvr0qAhvcQQSpioBuyYrLNppEKg+yTdfP4wigiDiPxHm+dcCmOwArKiHYO1Fik9lOfheV5ujZTkN8ksQyoPKSDVGoPAD3zAIjJLP0lpxymutprD8eijY2OaXYG0HiOjEc1mlyQzZH2D1RIVWDZvGyPJEnpxTHsto5LFlCKPfi9BKIFUHoGvSOKEMAjpd1Maoz6NhsWmhtW5Hv0eNGoWYzOUN4gmtBiTkWVmGF44fBZJ8ANFllqsMKS2z8hYCbsmibsWkxnmDuUh4lmagQBPSbZss2QGVpb79HtdJqckcUegY03ZV6x1PFKjMang2LEWo6M+cdalHETofoYSGZWawQsVzRULIk+ziZOElYUW3/72rSAErZWYJC2emcais4xStURYCti8fQvlwOfGb95GZyEj2wTTm2rMLa1ghcEawepiyo2du1ld7JNZRWQU9ZESWZyRxDGVsiIIoN3WaBEzNlVC6xghLJdf8TiiUplb77iRXReU2LN3M4trB/ivaxZQDcEFF0dUJtpc/91FRraGbNpsaDdTZg8kNOpw1vmjpNaybce5XPeNW5ld6RIvrxCUM1atpjoi2LJtE7P/lT8P6tOWbZsDGpOWcqnB/OEuI7WQ6e1ncelFL+SMXY+h1+4R+FNIWWdyVFMJRtg8sZVLL76ClZU1vn3D1zk4extCHqTXkyzOLyClx+Rmnx1nNNhmq9x4/VG6zYy7b7V0upowysNG++2E244exJceUlrSJH6EfzUOh+P7ce9xeVHPQzCo2JVHx9qisJi1BEpipMUU3mptzbDuppD5yxT3XCUgEwItwaginFnmxZ0lAim9PK+4aPFlbN42NxfWpsiBzgU7Ms8hH7Y4U6Kodi4YHxnlnAsv5snPfB6pjGh1EzItaDRGkcLS6qyRpX323XEzN9+1jzsPHOL2O+8iTnUufq0h0wlK5nWzMmPzcblXwmR9jJC0my0OH2xxw40NlIpJY4sRIUu9PrY2wfnPeQk7zjqXo7d/j7tu/A6600RZjY/J26kV+5r/p5FFxffBqP6EMuUMvOR2XXQXCtyIolJ54eAcRAuse9SLaAUh8EUuuo2wGCuxdr1eizYGw3p/cl8UofDDSvLrAscW06W1SJtXjdc2z233hEIic2uLsHmSfavPauvgw3ehnoQfip/wPlt3CUFqLKvtHjVfUBGKJMswcZ9ASnw/Qno+SJV/jVYXfddyQZ6m2dBLaozB2rwvJ5ZcyPkSQZrXBZSq+EJ8Apl71EueQliN0R1aSR7KGOvBxXNyNfpoEOD33IcHE4p+srZuDw1LKC2BhE2jFSZrERGarNfNrU1CgufheT7aglISKRRaG5ASP/CHff9yq5rMBbbyEMIW6xD4gQJriOM+2likUgjPo9dP6KeahdU2ibYuL9/heBRii+dZ0skw5YSxRom5uS4mI/+d+7DUboJnUSVBGApibZCJYWK6RK+raa1ZGvWA2DO01/q50T3RVOoeI6MhQknibsRdd3cYH61QjgSreg0/kIyMWfaevoXF+TX239kkSyVWWKr1iJHRiKXlNRqjdbTVjE5FbNpZ4s6bV+k2NUlfD43oQgqiKAB8FpeatJqSSrmGTg1rK326LctIvUyzozlyV8LMTJXx0YDZ2SZ7zxpj19YtHDlwmJWlVcbGKsRJXk27Wq0gpaHTEay1Aa3wfcVoo8Jqukg3NZAKrIa+SQlDybHZZXwbsXg8D1ufXYy55HHnYu0Kvd4Ck9NVvnPdEVYW26RY2hko4TG/2MJDEfoWehqER6fVAQypTvBDmNwUsH1PlTvuvBsrWywsJDzm7MfwvBfsZH72k/zEyzaxe4/ijjs7nPGYGuedu4Napcvc8RbHj/YYn4mQkaG/2ueOWw5BZlGqzbadVUZGI3p9j7CctxczXc22nZM85rGbscyzsjbP2nLIDd9oc/qOzbzop36WTePbOHZ4ntW1JgsrPRZWE7wopBxJfGVI4h4z41M842nPJdVP50v/+e9c+62vs2miTClImdxU43s3HSXJMh57wU6SXocv/tsc/SWJrxQCw+zhNnFPMzoqqAYBpXL1EfzFOByO++J+x9+i+NwybHHFwMtpbdEh2yKFzUW0AGElRuQtGgfDVptaNKCRpMaSmFyPJSZvMiWgaD6Vvzybe8CVUkgrizaWFivsMILWmNxga6TACoW2inK9zI6duzn3ggvZvvcxrLQTMgmVWo3+6jLVWsDq6iyBMmzdvImFpaN8/etfpdVPSDKTe6K1RpsMrM4NtFYjpUAZjYg7VKIypSAk8CRbpiqcuXuGkoyRxKysLdBp9ulrDyvG0aPbmL5wmondj+HO71zLodtvQaU9QvSwcruQxXHbovq5zb3JSgwV94bvQxbF3dfDznOvti3y3XPjuDZ5pfj1r1bgMQwKKPLiC4MItqj8bvJ1FE7ArGhVJor/ndAvvQhvl4Awxfdf2FvydLTcACyxRY/39RZsp4pHNscbyBC0+2k+EPFAaE2KQAuJ7/sIZfDzWvooTxRFvBRKaZK4D2zwYgy84UKiRJAX6fIkSvm5JQvwhSDy8nL8vSRGiDDPUW7GNGNLRlEa/5HX1486rM3bKwgh8D3FqG+YrJeYqJWJpEUZgdWS2CiUkniFDUtnGiE8kPm5lUW4iVQevu+TpilSSnw/yL9zYfG8Ikcmy8h0hpQKzw/QWUI/iel0+sRa0U+zYfEKh8Px6GLluKIcKlSo6bYT4r5GKYiiAKM1WWywvsUvZwRKUa4o4r7CpIK11T61ap2+jJk70iEMLfWxgFq9hJSaXlvj+TA3n5H2+vQ7cLjZYdPMJH64xqYtPpObYXJzwuhEhcWFHmmsQUnGJxXN1R46g3LF49ixNkIJJmZgenOd/c2V3IBfGCqthdmjCSpQpBasNSwe6+J5GbvPDNBCkeiYmWmP1SWPowe6bN8+ho4VpbBOs92hH6dIJQlLVZqdVaIqhNWESs1n1FTp7Vtl/njM6OgozfYqlbqH71uayxqrNUpYhFWkKRw4cAh8wdhMDYPgC5+/Ec+HPadHBI2Esc0ey6spSijKNUWcpHlIvZcRVQX9tiXrZ1Q8n7gV01nRzOwK2XXGDEvNY6hoiQueWGdqqkYgRmivrXL5c3fTqLfpdyz9Zp+yn9FaXiYKFeXRjJ0jNbrdHjffGDN/tE+5tMgTn7qZ0a1rtJpdmh3L4QMazw+plwN2bWuQJj2u/cqtbN8lWFmzdFa6lKIGlzzpGWwb38rKSotvf+cm7j40y7477uLuuw6h/IDnv+hKzj77dCYmR7jpppvpdmKeeOHjefmLf4Gzdp7FbXd9g2Z/jbsOH+WG629FSkFr/i7OfOwIZzy2zuLcCjbVWCvI+oIwyHu3pomkVht7pH82DofjYSYXYwMxbPMcbwGeBA+BKsqUG52LTKtg0M85NQZlBEbIvJ3YsDVX7l1VMhehkI9rlQGlDEoLPGswUpBZi1WKkfEJNm3fzo5duxmZ2EpQHmG+GXN0foWR8XG6aY9OZ5W010TZhE0zU1QiQegLuu0mSZZ7gD1PIKVFGI3nyzw5HUsYeAibEnoKRR+dJmzfsYfLnnUJ27ZMUS6HLC+t0ev3iUSfNNXMzXYYm96GicoYJKc99XLOfPyF/NfXvsD8wbvwrM5VahEJIOy68cEjLxQnBnnfRSE1Qd4GeuCnzgW3hsLjPai0ImQRLp5/S8Xchc+8iBAwWExemz3XFIXoHmSH26Kt8MBQvlE451+ryIu9keftSzHoxWQRg5D6Yh9kUTX9VPKICm8r8tLx/cQUDdPBkxIhBDrTJElaeEAV0vNAKpSQea6EKcJFbF4FTymJKkLFMHkrmby/n1+0ErBIawiCAM8agqIynjGaRiUE5eF1EtJmQm+97s5JnN/3rcrtvb6se8/3kPX80Et9EsvSvbb+MG13w+FYMbAO5TecernE1obHeNlD6oxIevhBCSF9MqPy8630MJ9Da4OQKi+eJiVWCJTv54YULxfgUimEUnnlcgxpmmCybGhNhLxoRblUotUx6GRDeoAzlDgcjzpsCr1U43uSqekRwkix1uyzvNKlVFK01iBrCYgFyYohLFuiikUFHnHqsXT3Wh7cpi2655Gtpmgh2bx5gkrJ0ppP0F3Jylw7j16ykmPHlsgSy+yxHq2mwvOabN1e5unP2oSw4EUhjZEqt3zvKHNzLZB9jDa0VmOEUHTX0iJQbmM0kcXzJa12n03b6rTWOsQdTSuFg/stU1sUmciIMg8lNMKD+YUu2loOHVyiVoNaTRHVFPgJRmRYCXgpKihRLZUJVEAtSnjcedv57g0HSEyP0ekSzWYTz1PMbCqjIgP9Dr1mizTx8D2fudkm0rP4ARw7GjO9a5ozHrOD2SMHaa52Mf0I6WWMT0REoUZYTdbNc+7KkaW8pcxaOybppBzev8idt/VpNQ1j44qnXlolEKvcetutTE1ndFplVhZTJmfGqI21iHsZs8d6BGWf+fkUKzVjEw0wFRYW1jg0e5jyCCyuxgRK0eoYQKOMxqumdDoxcWxoLjWYnzVs2TzGeFjijL1nsrq4xvLyKqvNDp1e7m5pry1RKjfwlEeSarrdmNHRBq3WEvtu/R7nnHEeuzafzTnnPA6iEscX9zMz/kluufl7HJ09wlf/bYEstQjrsX3LNJ6XcfjQCl6gsNKihYfnu3ZiDsePB+vj9WEi6SCKaZD3ayk8nYUnl1zspWnuCQ+UQktBZgYyPPeeDvpig80rqhcp0NZKLHlhZ9+TaKUxNqNc8imPj1GfnGLHaXsZm5ymbyKEKnPk+ALLzQ6dLCEKLZs3jbLUn2N6osHq8nFWlme5+859BJ4kA3RiQGe5YzHw0FmCMRlSWLKkD1YDHgpNpVxFBT7aWrwwIENSGp1EdvqEnmGls0iWSVYwdLVHqTbCpqktBP0qFz7jMm7+RsjBO/ah0xRJ7v0fevvJC7GpDV7mgagWNj+Pg3OVi9x1pSKK6fky62m+g6G8QuStyYzIhXeRC26KKAKNHQpxpHdCKtlGZ5zd0MJsKJ82pClIsqGhYNCAVNpTKyh+qML73mEiFiMMsYFWqmnUqkid4gmQRue9NWWKzgxBGCI9hZAKBBhrhon7FgvGDD2p1uo8Sd9IEBYlvLxStucjELkH3WqCqExmBVHWJaiGhEC/l9DN290h8chbZuWBJ2Kowu87DH0Q9JxX7rODVJPcOPBg4qGtPeFCFMPiAkX5/OHFtHGb6+d1/f8bevHxIMLS7XpISSbAFpdKSRomS5Jdk7kBgzRDeQohPYSSSE/hW4FQikEvASv1sNefVBLl+yjPG14P/uBvIVCeh5QSrTOU5+N7CmkNOk3QJsOzBpGB8iLW0g6tNEMIhtZGh8Px6GHPnk2srCxRq4VU6xELcx2SNKMxGpDFGi9I0ZnFplCteXlIXl+ANlRqEbpssSiUZzE6Q/mWVqvH/ruP4ElJ0pZMTcyQtWF1tYUQkl6nj7CSpC9IY5g9DJ7QzB4+xvkXbOHss3dy+OjdJNki1RoIUWJkQjE6VmV1qUen1S9yBC2+76FNnuKUkRCUJX6omZoK8WzCwQMJqyspYTVipAEz0x7dfkQiPLQRjG1q0O9mHD+aIbZVkLJDVOkzOhmB9TGmTdpXzC532LI9YufOEM0s4+MZC6swPhbR29QjTSzjUxB6Eq2b7N3e4O47O6wtdyjVoTEWMXukz6JnuO4rS7RXlumspozXq5x33jak16LdWWV5MSHuKKyRqEDnPVuV5vzTN3H02Bxr812sygdTfqnOv/7zYWqVec65IGR66yYCOcbCynF6do1KI6MfZyx2YrKlgHPP283EdMC1Xz/Igf19Wk2J5/ukusfoljqZFsRJmyi0VBqSqJxRHoXJLQ1EWiPOFKftOZ2xYIaRxgxZz2d603amZ45wbH6JKAi58ElPYnrTFmamRoh0j5r22Dw2RrkUYYHluUP0en1anYjq1BSlYJQXv+Cn2btjD+//5w9yPG5ijQcm5fChJfzAIjzL8mqMCAW1RkAvzb7PVe1wOB4JjDlRRxiz7hDCFuHdwPro977H65bBwrmr1prCO5orsHwpbcnijNQKAk8UqaxFoTRhEEUYs0EiBmrPWIxJyVILwqM2PkpZQnmkgV9pENbHafUsfk/R1RlrCwdI04y9u7cSKI20PepBRjBZw/MkR48f4+Zb9zE3v4QKI4Q1VEKFj8KahCzN0GkCwuYtkkXeGi3WGiU0vf4yN9z4XZqr8zzzkqfhez5Tm7bT63SI05illUVWWj2kv0gntqRW0T/tdGySMlUfYe9Fl1Gb3MRN1/8nutfCy08LiS10DeCZvNe5Lfqr56YHil7hg8rj6znZDIRv8ZyVIs/lBrMemWB1Ic7zZderq4vCKSrzfHEEVuRKaKC3bBG9YLGFRlLFBwNHXZE0MOi7XqxXFOHsD6rw1UPgEa4FnYtnDax0YqbH6kRhhIk7CKkw2qB1fjWnaS7IfaXIdIY2ehjvb4tqgXIgKovQQG118XkuygcCT8m8b5/0AkplRRiV6XQ6GD9hshbQahfiWwzK3Q8sW5zU4T3IK8lzGXKzlx3Y1040s5y44AkieP0GcU8NObwQim3bwcU2XCYPlxAnrOseO3qvfT7pF3KP7eYoIVDCEnmSqWrE9tGIugdJakEopPSwQuYFC4RFiOI7KUI1lcqrlAtVvLx1U4DneURRNDQISCmHA11rDMZk2CzJC0gkCd3mGjXpIYMSy90lMnt/phCHw/FIEpYyZBuWW00W1lrEfUO1EpLp3IPghQJjckNbp2ewaAIjKQvQzT7TowF+iTwvLvPo9vpoI5EC4r5B+oL5pXnKtSph4pP0kvwevKGWxeEDXRaPZdRrguWFVb773W8RVmI2bfFYWbKsrCVMTpcw2qNcBSUVhqKPqZJIT5Bkmi07Iya3SrIkoVwOiIIas8eWsEoxf7xPZ0VSig3z8wndVJNlGhV6VMbLqFCytLLCGWeVCIOAbrfP2kozr2hbSalXS1ibstzuUAojGhMJQVkQt1colyzjOyN8aSgphe9FtNoKz+8gFESRpVrTnH52lU43plpWmDgl6xkmJjziuMPxwwtkWczo2AhSGVrNDgifNNEomdHudNi7d5TTzhnh+uuPIsIIqyRRVeBFMdPbKkzPnM2RQ0ssNpucNj3F3XfeRT+LKVWr9LrwjWtuZ/vOOtLPGJnwmJzYgifL3HLXTezY6zN/NMMXivoIVGqa7lpKtV7GZBUO3L3E4oLmhs6dvOpllzM5vZ1qdYY4bnPRRSk7tm1nbnaNW2/fz/TUFGdunmG8pPC1xsaa22+5jUNHj3Bo4Sgdo5ltt9lxZolu0uPA/hVWl2OSrmGyMc7KSosMQ7uTUhKCcq1Gq7eGryVbt4/S77niag7HoxGjbR7KXAi8Qm8DJwpywSDEGNZHsoKNU4ZOu+HwvMghLmb1PAh98BVIadGZRhqNp/Jt6UJbaIpq5oUgtIUolIFABSVEJaTRGMWLKnjlOsKv0ulnRHGK9QQL80dRwhLsmmBytEq31YIsxpiE/7jmOvbtu4NuP8N6PpnJEMLk0V1G5mHuSqKioDAC5EWJsSCFh5IgbYY1htFGA4VgtF6j01zm0ME7KVUqXPy0J9PpZdx+xyHm5pap1GrE3SZJYlldWWXX5ik27T6dSiT5zrVfJet1iyLjAm0g05ZMWJSl8K4VIdtFuzRNLp6lBZEV3vA8ezjXVUWlNSHM8Fsa+L8Lf9zwuxqM9QeRCrL4zGz4HvN20/n7YWX5DdpL2EEgexHVlvdEznuNF7aAU93C+ZEV3gPRpCDODJ1+QmO0RtzvkMYxSngneEetsWRZLrqN1mith727IS+wljd9PzExfjB9MF+WZkVf6UGfcEsQBCilqPk+M6FhMcto6pRMFon3Jq+KZ+R9SzxhJWIYolD8yAv1bUVuIbtnOMXwVNyjovoJktyue7qH+QwbhLc0XiH6B1Y+u75twQkX3QNlcGNCSnxhKSvNRNVjy3iNspdXBfSDvLWbN/h+CiOIEAKt83wMKXOvh+flVcst5MYUwTB8XBbpBXlVelMUyrNYY7Fag7VkaUqcxKRZRstoVhNNkmbr19CDPkKHw3GqWWkt4pUEYSNgZLyGlJosEfSbPv1uysL8EtZKvFCiwvyXHAaSsZqP1jF+EcoX9zVB4BN4IdYKtEmIIg+rFSsLffptjTV5Uc1h91ABoxOKKIqYP9Kj3YEky1hciNkUTdJurRJGggYlbtu3Qnutw5lnTzI13ePYoQ5YSOIMoaBUVmid0W5Z0jQjizMmx0ts3VVmea1HP/bRccC+W3vEUuBVPHbt2sTIaJnFhUVM0mFywidN+swe0izMJvg+TIx7xO2UhW5KZi21RpXEJlTKinIZxifGaLZb9GLB6kpGN+tSq5TBC5C+odQQnPPEiPP//+z9d7Bsa13nj7+esFLHnfc5++R7bo5cMpJFviMDOo6j8hOxhEH/YCjH+hoIZQAtlMKSqWFM+MOAFDPOlMow6vCTQRjAS7zEm/PJZ+fdeeXneX5/rNV9zuFeQMHLxZnzqeq9O6zuXt0r9PN+Pu/w1DWaXRiOBuxu5Nz3ZYvSguWjgq2tDayyjIaCSZrQbEtSAy43+NqxtNwEWTJOLHmRcc3V+xiMRrTmPZ7+jOMIleB5VUuoHz/MdTcvkcclpx4yrK51aXabLF6p2N0ektk9pBIYA1ubJZsbGcv7Q3bOZzzwxQmLSw2aoklom2g/YbGzynx7kd7cV+htD/GVptuaIwh8hAfxcEwc5zT8iGY0IvQNg71NNlsCtbxAt9kl9Jscu+Z6bnry0yilYVLG7A56bOzcx6nzDxEe8rhrcJ7Tu7v4UuOKHCU9RFQifEluLJ1uSLMNg8EOZ7jc8b5cl+s7sUpTj/fqBs+UKSmoCJbTcT1T9umjhr4XwPfssccYHtsaQCOqzG9fK0JfImyJLavfF1c5h+HElJ0qcULipMSYKl1JSMVWr8f+aI757iJha5mVAweYW17g7PoZ7rrrDtJ4TFmk7G41ufeOsyzOd7ju2qu474EHeOiRM8S5pXSiakRiCEIPi61o2lLU2eD1eBkQUqGVQAqFcJYobLA01+Gmm27h2LHjaC04c+4UjYZGKssXv/g5ktSidJs4niAlHJifY/X4IXp7Q8o8oVQeq0ev5MrxkHu+/HmKssBYC3JqS1ZRv50TYGqTMhxa1IZ09X8tLso3stNnTreMmKEaqKjmFwMmgauBerWMq03anBOXjP8vdL2nmN5d0vR07oIRm4DqO7SubgPXlPnHGVA8ocB7Ctasg7yE3jhhZb5LEDXI4vEsasqUZfVlSYk0FdXcXAzQnJuB7UqDfAEE2hkFvbquVOVuXtGZDWVZVm6EUqK1ph14eKKiduexwWIxrk6Bq3UgX03/n+XCCoGrqShiOvWFqzewxZPVCWN68Btz8WuYOjy+vn3R3+m5QojpfWJ2cVTdIJy8iGZjZ+87e6V/4AzOpU14iZSKpmc5NBew3PRoegYpvYpaLgVu+p3WwNkYMwPiWqnZd2utnckBpifH6XZJ07TujKvZJa+z1xEaV1oKazFliQUmpWV7MCLJywt9/ctU88t1ub7jylrH8toCoyRmZ7DD6r42w92UrXO24qshQBSVGaPywEIUwMFjgsnQZ3OrJMsszW6EsdVvxXAQ0+r4VcRYUdAMfYa9ApytYicR6NDRXfSImo4yz/AiQZYKen1B2Gry2duGFEXGjU/qkmU5SkGZCTbOJiSjrFLJ2Ppk7yqPilHf4TcCWq0IKUp2eylpkbG83yMeK7bPJOyl4HfAKwRbJ2OGmwmr+0P2HdaUZZ94Uhm72BJk4EgmCpwjaCj8yCPOcqzJsWXIwUOatSMh3nbGyVNjdChJxlDYkqgR8eRn7Ge7t8PcYsC995zm0PEGWQbxJOLwFQtMxkPacx4L+3ziScCdX9li2CurQZsyrC43MWlCt2PY3S7Y2ipYPzdkrutz/Y3zLMyVLC9qbvvYJoHf4ORDn8DpIefPKg4dbHPwwDx337nL7uqEsOmYX4KFeR8KhVoOiLRkebFN0Ajx5ZBrr2ojaRLvwgCNBpLQY290Hr/hsbQcsr+5yOLcPJiMeHSes+dOsb6xyWhvyN7uDmmR4gUR5/e22RnvEYUtlrorRCpkNxuSFmMKcspkQqQXufJQyOpKhpJzxKMJUmgm2yVZUo0nlrs+YRAw19EMBkPKTBO75Ik+bC7X5bpcj1Glrcd74sJ4WNTgSkzpzFLOZKFu6pbtpkRle4FaLqbjZ3cR3KtKXiCT1t3jCjB6qvKCKI2rMr9Li9RUY2EhsCiM8HDaIy4scZLSXlggnFvBby1xZqNPLy3Yn4955OQ99HfPcPXxowjXJFQZ+1e6HDiwxl5/l0dOnWaUZLWZ2pQ8KzHGoiqLbjzPAwRFWVa/j/WMgTOViamUgpWlJfYtLTAcjhjHKVpZsnTEkcP7KYxjEif0TpxDKseRQwc5evQwc3NzjJOCTruFpzpkoz1i6zh+05Ox0vGFz9+OUHIWtckUMk87dpbaHbymiiPQwuFPgTgCJUVl1EZlTDdNOZp99VJeygMWF/5Nu+BTcXaJvLjXWP0XbgbKL9660872lNIuhKqksNTU9G9DJ+8JAd6zSKvaut24aifujTL2RhMWG6qesXJ1d1QgVQW48zxHSInJi1lW2xR0T0EdXACa0y73xffpi6jO08eNMQRBgLYW3xqKZkBiU1xmyVxlAuCExImvJdR21QybqGdXKv4CSoGvFVppNCVKSMIwQGtNmmZYaynLym8vyUwVaSAESlc0EiGqKK5pjp6xFfm9MAZjKoN+I2sdtpvmBM4IM1Xe4Kx9/XW2BVOqzoUFtRQ0tGOx4bF/rklTGYo0xWsHaD/CYSnyfLb8FEhD1c12NcD2fL/6rnH1xIh81DabgvPqupgBcSmriARdG7ClaUYmBLFxZKUDVK3Bv1yX63J9p9VkbJC7E8J2QCP0yTOL52mkSCmKaqa50dXYsiQeJGglyaUjMxIRaKwqyJMcBglSCcoSosjDlJDGOcIJisLg+wI/9JGeoygtTgrCVogOwI8Mh44ssr0+4ez5PvPLDXp7Cc994VXEkxHnzmziySadrmB7Y4ynFGHkkcQZUeSjNCRpSqMhKfKMNDWUuSNOChyWOV/ihynX33gAlGAwTjn38Ijd4TbaF0gjcSsaicVkgkMHFxgPdjG2YGsrxxpH2HCs7PPxQ0WZC/x2h5d+34/w6c/+DSdPZkCIcxnWSLbXc6KoR9D0yZKS+77Yw1rYPm8wQrB+skfoe+xfC/FUwN5gRLtbcuSo5qwxHDm6yNoBzZEjc3S7AXd/5TR56licn0OQIShphi2iKMH3Fbfc9FROnDjL/EpGaTusrB4l8gNE2SeIIpwqOXioy8mHT3H+kZR2o8O50wm7OxlLq3P0tjNuueUQ59IBn/joSYrCccUVHldc0WTjvhFLRyImWwlHD+xj/+IazhZMBj2GoyFnTpykN04YDSYYJ+h057FSEmc5OY6SgqzYwZaGssjJy4TSpJRmyF5/nTvueICyrBhyTsNOf4wOQ3RZEGgJhUTonCIuCKTEb2iGo9ETfdhcrst1uR6jZkPZi8a0MyA+DYQ2djaOFmIKuGuKc01UdnUDzEmBrT2SquWrMbe86HrlIVSphCu9cQUohYXSgTN1t1lZ0AonffqxYbs3pjPf4cCRK1jdfwhjQjpdiw4Eg/4mWdJnruOTjne5/porWV5apNXtUCL52Af+mnMb2+SlAqkIvACwlGUGNqcoCpRSWGvwAh/ta4x1FMZSGovUCollcX6eski46+472Nw4y2Q85MjBNcqypN8b0Gi28D3NwQP7cYRsbffZ2dnCYfH8Jnt7OyRJQrfVQDhIsoLWwjJrR6/gzKkTlcS0rGjvpanQsC0tVTNcoGrGsBAChcMTtnZDd3iuwhiemE6U1AZ3tVFbWdp6O9TE8KrdXTfaasZDTVOX1E5XU8nqFAfWBHXhbA3qL6SFX/DsqvaX6Tz7FHs+nvXEdrzdtGsrMcKSlI6d/gBlNKEA36tA2bQrDRXVXEhxEV1AzC4zsD0F9TWVfNrdhgqcFnmBVRdAOjDrjKMVJnfMhT6Fk7gyZiIEiXOYx4h2m76vEAItKyM2gcX3FEpA6Cmi0MfXklAEYB1hGBAEAdY2KMuSJEkJPE2apkBFew+jqHZ2z6tOvadxTpCXJc5Vs2tZnmMtGCFJSsMkzUkKRylqw4B65sYVF+bzvnEOeb1zC0GoHPsiwUonwJcOayx+EBIFIUIp8rJiHBhjKqBdfw9lWeL5QUUBqt9v2gFHVA6FF4P96TLT1yjL+kQoBdJVeeBSyorxoDSTJGNvnFC6at/hMSlFl+tyXa4nuspckOeO1YUuyrcMert4nmR+wSObCJyV4IPvt/FUSZkZstxw/90pfkOzu5MRhZLSOaRX+Vh4nk+SFFQKMk1WxPiBxkmL0NBoSKxw+IGgP5gQNWCQnqexAEErxFBy67NWaXdhb9dSZA1292K6cy327Vtib7dPkRuErKjqh45FGNfCkLO8fx6pCnZ2d+iUEutCpExpNn2uvWY/9z50glY7Qog+na5kYUXRbTu8WiPYaXRJRilzHUtpfDpdRZpa9rYzxv0MZ3M8X7LLgI/+7Vc4cPip7G38HUIk9Icp+/ZFFIMCZQW+EowSj9D3aXUk58+lrBxcYK7Zo9NRNCJFtzvP1dceZxSfodVtcfMNPtvnx9xw/RyTtM9d944pnYe10NvuE3g+aZbwxTzmpddcwf33nyEK57ji2jlG+TnGfQnMcebMDnnWAzVhYX4frjAUsSCbLDPoW3YHY7rLAcPJkDRz7MU77CVjlo9EmLygu6/g2A0LnDgxIp4EXHn86Zy65xTNImcw6HPivpPEw5yzO7tMSkleWso8xuQZzeY8re4cSiuyJGUy2sPYHN+ThIHGs5rTG7uc3jlJ6hzDvSHdVhM/aOKHHlIIfBXQanvcdNP1/NAP/SD93oT/8T8+yMMP3Y+YPNFHzeW6XJfrscpcrAKpQbCo26RCTMOlpvjLzQC0o4oNQ1yQZNYtU6oYYnfpC0//ihlUR7oLFGolQCiJJwRgKM2FvG+rPNa3B8gw4sixa7nh+ltYWVljY32L0XATVxhOnzlJo+kxmIwx6ZhhfxFncrww5O4HT3LvQ2cYJ1X8pO95aCXI0gzhSpwr0KJEYdDCoZ1EewrrJM0oJEtzsixBYLEmodmZwxUNPA/29rY4dGCVfSsHyIuCJImJgojt7R7ah+uvv5r+KCbOC7LhDlIJtFYEUYS1Ba2oiS3G7FtbYzQY0NvdxiIokRROUJYGY6jZvA4hDKJmzmoh8JVECVA4fATaOVT93UqmOd91R1zI2mW87lrXjdaptlvULOCpq9YFMD1FMfV9XOwJ4GYzNTMsVANuOWMVTO2qH796gs3VYAq8HYKSkqy0OKFQXtUNcc7hex7ABbO1Ktit6uZ+lZ77YkCntaasaeoX081xhrIsgAvd8im92Qt8ykIjckNbCNaaDdbHCakzGCnryIFLuN8IIfB9n46viGxO6Ht0WhG2yNDS4SmJsAYlKtd7LQ3S1BnkwhH54CuLNxeQ5TlCGEJV4EcB1iqSJKn3NImxupoJ0hoTSayDsjA44ZE2PXpxTmwdcWlJSkNhpjoINzsZzaYIZ38v2hoCRJ2hPh8KDnch9MEZQ4nC90KwkGUTMmPqaLdqu/i+j9bTXcohZUUzx7kqKkzK2X9r7Gx7TQH79H9F+1doKbClqVgBxpBnGXGaME5LCle5HYMEJy+cTC/X5bpc3zFVxIKBzGn1JyiVIkvHeFDFREpRUhaOPLfEZeUkrrQhbGpGoxyTZBgEzkCzIekuRJVcx0iGo4z5+YADB9a4566zZJmgtBnOCdKhJQp84iJHIigLTTqpcloX5hsQTPCaE9Z3+vT6OZOhoMwNve0Jc/OO+bkm/d6EogArDd1lmMQjlvd16XYMngyYby7i8OkNU/JU02oHWDFAqwSH5IZblkniHRqNahBRWokTimuuv56W3+Fzt3+KcZxSihInDIcOtmg2fJJhivag3Wxzx2e+SLxzJU0Uk7ikHQlsKgiAduQRtgzIgPF2QkNrVucle+vjil5XwHDPceCo4uDhq3nXf/oSg37O2mGfeJwi/Yyrb1ikOedx4v4RO7sDJkPB3lZJnsOx6wP+7n+dotEtOHrlkFFcsrR0JTvr5xjuxggBO70e+/cvUVrDF750mkmvTZpAwZBjV0UkcUqzG9JqhQxGE/rDkn2HfJxVTMaO//2J0xRxg9f9u1dx6sTDnD/xFa5cgmySc35ji6QQpMaQjseMRjEOS7PdRAU+pswpy4yiqLxTpBIYWzKOx5w9t84jpx5it7dLcy6i0VE4Y9nYHHD9jTdVk+MqIEtSHj5xljvvvp80dzTmlsnNKQbx4Ik+bC7X5bpcj1GXcBsds3HfVG44HQVKKtKpkJYpkdNWQ+hZFxsqOVHVCLr0faqGEBe63+5ipFItP+2YakGVqS18UuGxvj0mSR0333gDL3npvyYb7zHo7SDciGuvXmFne51OuIbvBzyQlywvztHr90mzlL1hyqe+dA/b/QSkwrM5tigokLWpWo7vQSMKWWq3OXzoEGlWEEZNhsOY/mCEBxw7sp+DB/dRmoIsSSkXOgjhsK5kMBgw11wkzy3OKfq9IUJInLMMBz2SAnTUZjgeoIVGCcn999/HyuoSSjSJGi2Wl/fRjgI+8dGPUlLFBlsnKBwYqszs2uMNsPV36fB0pfP2Bfha4Mvq+pRBIOttKWfd79qUDYGsm2ziIvaBnFLVZ9v1AuN5im1cLUGYPj7dttPtXMVPVzFlF1Ko/pl3vL+etnjW8p+x6yu6dZ6XWCmRsuqoFkWB5we1gQC1GN5gXR3iPtV3T//WX2BpTNU1lRVte6ohqPj/Fwy9tBJ42seTmqLMkFqjjSEwhm6gKERIPIwpamozYrqDOHzpCH2PVsNnKfJp4hF6GoHBUrl8KwllrTUxZYnEEQQBAEY4tJJIUU2XibLAUe3AgVZEnkbj1x15gZR+7VooMFZgnaWUtRbe82h5klwoxnlJnBfEhWWSO7KipCgrh8FZZEJtbeCwdXi8I/I1WkIr8llpKrqRpShKDBovCHEo0iyv1kVIlJI1/X16MpJIJSmtRQsxy+wWdcd6ygYSsprHmur0p4wE3/fxPA9fa6wpKIqCMssxpQEk1inGpSHOLUpXzvcIHnXivFyX63I98VXm0HCwfXoXpWFhoc1knBKFMJlYsrgkbHoIVWINCKlwskQG1cx4q63wPUmRp9g8IbXg6wbxSJBOUqw9x/4jHU6d2qbMIZ8YhBE0IoVQBemkpEwMsSfQVhBpSzYxFEZiS1CeYn7FEoh9HDp4iCLPSOKEIBRM4hE33rzGjTceZGVfhzwf8+CDd5NkJXFcoH1DsxESBgqtc/q9c2iR44Ti5qfczPo5wc5mD2M07W6D0WjIgw8+yGBTsr2eEbYVYdugnKPZzvCko5/nxBPLaJAxHpScPXkHrYZiaaUJZcokLUgGhskkJegLcpPje4K9oWNxtcWNz+rw0L197v7ChEJk5PI029t9rrtuH61OxMbWea67ZpWbbj7MJ2+7l42tPQ4cWObYtR2SUU6WGtYWBC94yRKHrikpSo/1MxM6rSXazSXOnr6LsoAjV0UcCSPSNGZnN+Hc+ZxQWp7zgifx4MkvkRUpW1sl+5YEvXXDFz49ZG/HELYkx26SHDjQoswcE2n4yh1f4Auf+RxKZBgKjFGkmSE3JfEkodffw1qHkILxpMBiaDaaaOXAOFxZkJoJw3SH0+fP8eUvnibQFo0haAlyZ0EXrKy1OH3yIXZ3MsalxWSONE55+MGzrKwssLMzIJkkKKme6MPmcl2uy/UYJWvN7pRpPgXAzk0thV1NHq4ad6JSZgJQUoO1GUhzYC2mBGMryeuUbnxpQ8oha71wFdZ9oeGGA+UETimc8hnEhq1+zMHDa7z4ec9iuekxKhxlmREpi+eVLF99hN3dXTzP554HHuD8+fNEgWR+4Tj3P3SW7e0+nheQZjnOGqSzhFrRjDzCIKTbibj66uM8/dYnURQ5u7s9vCAizUruvudBdvf65EmMcBYtJBmW1dUVWu02cRLT6nZxUhNEAaLI2L/vEO0s5sFHTnHfw2dJSssNN91CHCdkk5TQ88nShK2t80ThAa4/fjVb58+gleKKq6/j3rvvw9WxvkwN36zByCruzUGNEapYMa3Al+CVDl9CoAWeqrPA64mOqeZb2Iq1oKjYrxUor2nsTHPX6+3sKv+U6jXkbILkgvKbCzFnojJ2E6IyyXOO2QSM5dII5sejntCOt61pHKrW6FonSMsqpsoqA9pQFAVSKZS1lW196UBWpj0CW1EEjKhN0y7og524oB+eHpyqjqpCKKyoSMpKakxpCTyFVB5e7eI9LjN8z1XZfY2ISWEwo4zYVcdeoASRhLmGx3wrIPIEkSxRRYEWBVKBDhVlaXEWPB2glKAochwgFYRBMOvIl2WJcRZjKq1BVlhMktNVHmEUkeVxBdCBIAgQVpDnOUp5pKXECkFhLNpICmNoSIdqRSSFpZc5xknO3jClADJHZQxRz9hJJMoZGlqw1NQ0taDhW1pK4KyuYhQUYEpMbSQnPQ+BxExp4UphrCMrSzzh1RFjAld3uau4t8rsYToJImqH+Iv13lLWzvCmmo0UUpCXBaWpdCR5AaNSgqfxHDglcE7V63W5Ltfl+k6qKJI0tSbwBO1lx9y+grABoRdxcK3LmZN9mq0GTlgGgxF5UZLkBmMcnvIR1iBNgY8kQOOQbJ0doaUiajQ5esUV9OMN5lcjhsMUkEhbxY6VscEPFZ5wtBo+2nicOdGnudBgbzfBGMfyUkh30bFvqc0znnoNm+f32NrcZT+KRnuVOBny5c+eIWpodGODvIg5c1KSJZIgEnS6CVKmLC5LRn2DFhGDUcrH/teXWF6VlEVBaUr6/Zx2O2LzfB/lmigfersJK5FGYOtJVGh2m2AhDCVBENPbzUAW5MWEwPOQgcK2BenYYSeGoOHhhwoZKLZ2Y+b3t7jpacs0u5ozZ1OkLomCkDKPOX9+B4ckCC0PP/Iwc0sBC6srFEVO7jU5ePggx6627PROkbuMJNacemQPZwPmOil33X07USNnMNhh81zA6v454lHGmdNbHL8upJw4tvcewLghg0FJd75NEGqyXFGMLTaBq27uct3Vc5w53eOuL0zAKynzz7FvdQlPVGpL5QW0W3P019cZDcdkaQbCEYQhWIktHPFwhCWhNBnjdMTm3h4nzp9DhCW6XTLfWGC4M8Y5zXe/bJn57iof/9uT7GxP2OsVpKVClJZWyyNQkt7mFo1Q0upqhuP8G+3Wl+sJrle96lX8xV/8BePxeHbfC17wAj7+8Y/PbodhyNVXX82rX/1q/v2///ezccarXvUq/vRP//RrvvZXN4s2Nzd55zvfyQc/+EEeeeQR0jRlZWWFpz/96bzqVa/ipS996Syh5XI9vqWnwNpd0OQ6N9XzigsUYceF9uXsrrrraafdUoE1AlM4CmvJTa3ZpmpGTTGbcxVYR4IRAq18gsAnCgLKvMDEMamV9EvJQ1sj5tdW+Ikf/9dctTqHzM4xt1Cd19JSMxwXnDl1Eh1q9gbrxPEAYwquvvoGkixhe2ePJM6wWLQAIRTtyKOh4dorD7O02MHzFQsLC6STmOFoyPb2Fu3uHMsraxy/8gq6O0OGgz2GewOMs5zf2ODhR85w9IpjLCwucXpjk3FcokWALaEz12KSZGzs9Dm3PSIpEsydX+H6K68nGZY4AVpakmSEDg7x5XseYrC3QzsKuOXpz2Nh+QB//7FPUIwqjFIWtto+gKllr1ZU28dctO1KBwWO3Dm0Ay0uxJDJGq8JO03hFsg6MrnKBXdIJyqgjUCISopcRZiJWpN/QYaAu+i1JWgHnqic762s1hdXt4CdqyWsj1992zreU0rxYywxm8GamntNNwz2ghajKEqK0lTOfWZKHXAIaykx1Un1Iv3yzDlbCLC2NioTKKkQqur0pkmCMxacw5aGMAjwPY+y9JDCrzKnpaalPJZbEUVRoupps4av6IaauaZPQ4MnHaosCDSVoVqgiaIQU1YTBkr6SAXO+hc67VohAo0xhjg1CBkAgtLWDuF5TjKx+KqJMWZ2wqn0D6rWpVi0FGjPpyhLcld11EMvqKjdGALPJwsbNPWYUVYwSAtSaympnIV9JQiVZL4ZMNcMaGqByRJsVlDgVzNJUqKkxAKlNZDV9HAuzB4hBLZed4RAcuHH6Ku3v5RypumeTpB4nldPlFiMpZo1K4uqI24dpbMVxdw5osCvFAfV5rsMvC/X5foOrCAQrK00OXJkCdksmdBn/43zJIMQzBxZqvDCiMNH9/HAg/czGo8II49zpwb17HUVO6ZQ5ElBkUukUNWgyZWceOQsulFSliVaQeT7aOHjmjm9niWZlLTnNVEIw42UKNCEYUmRWEoHm5sJplQko3Xi+O/obcbsbqW056rzUZ4WpJMqk/uWpzWxIqBIc4JIsruTYkzJ2kGJpwULC3NIGdLvbzAYWvwAWqEApcFJ+v0hgwHMzxuEXyC0ZTIWrKx1mCQpOEjTlMFuQuBpsJKscITtgCTNSZ1BaigKB7oyhc+zgkazSaOpibotrrruah55+E6uvXkFo3aJgjbb5/bQYZ+bnr7MV76wx//v/X3WDgcsrHnc+ow2ebLA3/7NKfJkgyc9bYHRSHDtTUdohODcHkeOL4KVKG/M4WM+0i3SarXo7fTZ3U1RUlDkmp3dmFE64vDRNosLPo88sMegjOh04SnPC9k8a7jyWp/1h/fYOW+YDAwGyUmdkBUDJjsZq81rmMQ5/f4AZwRpnJLGGTrwMHFKu90m0h5SC9KiWm6zt82ZjXO4wBC1FS0nyZMh4SKEizBMEjbOnyZseywfiJgklmSo8JRCyRJjEsqs6rp42tBpBk/0YXO5vsm64oor+M//+T8DsLW1xbve9S7+3//3/2V9fZ23v/3ts+WiKOKjH/3oN3y9z3zmM3z/938/zjle+9rX8sxnPpNWq8Xp06f567/+a37wB3+QP/iDP+A1r3nN4/aZLteF8mpjZOfA2GpcOOXLzsD4dCx4kaRyqviFC1RzIRzOCIwTtSN4NZ60ziHVRc90UNraBMxBGPoUacokS4miBssH1xiW8PCDm8x35vmhf/Uyrj56kI6IsXFKqKuJ0dPrfQZ7MckkIZ9YDDlrK8uURcbRw4e4884HGI1G5HlKKRxSSeY6HVbm2xw7uMqxQ/spywxjDXGScD7bZGtri+F4xGCS0BulBGGHI1dcQTJZwZmcOE2YJDlnz59n0B/hkCwuLpCmQ3q7Y3AepVvCCz1uuP56cnOCM+c3OH9ul2TwJY6s7WNvZ4/hYI+oHTLsDYi8Fo0wZDQaMN+KOHDgIC944fP58N9+mDgzlVt4fZkyESy1YZmswLgUFdt3toXcBX1+BZDFTMcNAk2l0ZdUmdzGgnR2Rk3HVu+r62aecHV++HSbU4FuV+u9L9aST/cJqLruzl283zw+9W3peE9B19cC3tN/DjBOkFtHVlo8SgKY0cqNqQBZ/S3OvhopphndFzqpStQ06vpgEfVyugZ3RVkigDTLKvM2KSnKgjBsIIWH0g1MEYMFT1jmAoXoROgkQypFK/Ro+pJAFERSooUlijStMMTaAj+ogbGUOFvRrKPQpygKhBDkRV5RXgArBc5onFRIEZCbykAoTca4MqdI01qDXqKlrCh20qF1HYPmZO3i53BS4CuvMnmwhqZSZFlOIDVeM6AVaNqRTz+Oya3DF5pACbqtiKbv0fAUZTJBWYOvVHUwKInUmjTLKKytZwD1LCpMaDUzUptFxFUbDPNV7uVToD29XPzYTJ+Bw7gS5wyeUhRKMS5yJklKYQ2+VjRERQ1yyCqD7zLwvlyX6zuuxsOCXT1G2pKT50ZkEq6+2eP+O0+QjCw6FAQdOLt9gk6niRMpSZpTlpUercgt+digMNWEo7ZoT6C8yml8cj7BbzoaTR+bKOJxxtJSiCPE1zl+VyKFpL+b02orlhZ9VMMRph5xahkNKsfrpX0+zo3QvmRuQaM9QRIn2EzTCASlkpy8d0xnwePYcZ/d3ZLQ80gnhjSBxA/AWbwwYGl5niiakE5SitJnZzNFB5LOvE+zbRDK4DU0C+2AdrtFq9VkMulx7tQApXyGPYGzhjBySKkZx5IkFTQXBH5kCXyJ5wNSUsSQTBIQDhW0WN/Y5iuf73FqIeHZL3gapx4+hzEJjcgRthRrR1tMdhKajTk8f0SSZmxtZBy7OuKK4wGHjjX46If6PHDvOW665SD7D7bI84SH7jvL6kHH9TccwFfLSBa4796CPOkz6lmGkxFBy8eLAnq7I5p+iyuOrtAfJmzs7nH9TXNc/2RJOp4Qei0GO0OOH2+yNyrpjzLs+R6TLcs4ribXpaxSP8rCIJwCK/EDH2Erc6E8F2zsDLn/xCa9yQ5xbljqSFaWO1COSCmI85JxAQ8+ACfuHhGGjiKRaKk5uL8FoiRNEvzAI1Y5Tkh0EKDtZeD9z7WiKOKZz3zm7PZLXvISrr32Wn7nd36Ht771rXX8UjXmuHi5x6p+v88P/MAP0Gq1+OQnP8n+/fsvefyVr3wld9xxB7u7u//0H+RyPWYpUXUwbY3ShKyaPcZVnU/nahA+SzO6MC4UNVN8SlGfYQ7khSzsusNtbd2lrf8XFrQBXwGmwBQZQsB4lNFPJ3idFZ7+zGdwxTU3c81VR1lbUIQ2wXgCLSwqVJyzGcKWKCXJ4oz2XJO5tmB1+TDD3h5aVakZjdAnaIV4Hhzev0qoJfFoB1POIZUgKwrywjIZDzh/fgMnBIePX0VaWNa3thmnltWlRaRWzIUN1gpLUVo2NzYZDoek8YSVlTmUrIw0d3Y3CVsNkA2e/uSnsG91j1OnT+LKCec2zuBsitSOZDJh/dw6nWaLpYVF5roHCKMIm6Vcc8317G33+NRnvoCgnAFa58AKiXNVIpSt9d6m1lsrWVO9VTUBIlzFhJa1DHVKO9CyAquy7oprWe0LM6d6WxnflRd3vGtJcO2YVpm6ucpIu4p+k3XHvJa/zq6LS/abx6OeUI33xWHplS5bUlpDmpeUWqFslfGstYfSFRHfWouos7i5COgZY3BiyuOXINwse89RnWi10hW9XClMWaKVrmjbQmCNoTAGm6Q4q8BYXFEZACgcobBY5TChQmhFoMEXJXONgLlmhMQgjMXXAtAoVQmPhZIUWUngeQRa4gmN9jTGVC7mxpRIwNcSK1T9rVS68MD3MFgajQZpYQCLp4P6s1TrAdWOppXClgVSS/wgZDSJyfIcKRShlChPIlyBqHfiUAUIrWloHyWgGQYIa8CW5FlC6GmCwKvMEpyjTBLiLENrDy8I6pOcozRmpptAVLNUVfRX1fq/2NX8q69fDL4vNldDCKScTshUzymNpQRQmsCXSFvNeDoh6lnOf4q99XJdrsv1T1nWQJFrdncMk5Ejw3HH57ZQEuYXPNaORuTA+fUR3bmAxeUGvV5Ca14yGjnKwqAjgbSQJw4tFaW1mNJU0YlGkI3BJAVl5mhojzGOwha0ui2EdgwHMVEYVXIVp0lGCXFqsVYyPx/QOerTmTNIociyhLAZMhkapNAsLnfZv7KCFJpBb8hgss2+xQPc9cUHkErTnGtz6uEJk6WCqGG57+5T7D/iMTdvkaWkt2fIco9+r6QsCppzAi8M8Jo+yg945MFtFDt4KOKxpciqzrcXCErjsLlFqIyitBQjx/XHFjFpzOb5BOFJmg3N2uEG2+f32Dg7Ic7PsbS0n5tvXeHaa1dptnd56H7LfXcbVHuPdjfg5mdHbJ4es7gvZH19SLMVcf1NVzEab7K1NeHolR1GfcP6+jqNVsSB/YfoLQlG/Qn33LnHwqLgzi/ez/xCk/lFj8WVOe4/sYGVljQpWF1bZrA9YXFRsLDSYPHAIo6S3PVYPrDEepmxcNDi+4qVNOLEKUtZFrT2Kfbva+BpiecF5FmGs9SGnbL+LVBM0hHDZMzfffwO1ncHBG0wpkTIFvGwh9fISR0kOIbrJStLHgtrAfF2TkN7FIUgmcSkeUajqQgbEu37NCKfeJLRbbSf4KPm/4y67bbbePOb38znPvc5jDE86UlP4hd/8Rd56Utfym233cYLX/hCfuZnfobf+q3fmj3nPe95D69+9av5wz/8w3+SLrLneTzlKU/hz//8z9ne3mZtbe0f/Nx3v/vdbG5u8ud//uePAt3Tuvnmm7/ldbxc//BSdeyTEheBI1nxmqtcblFLFC9u+FWLzQBafSqZjhtnGdlwUae2At/GgpVgnMJYKF1JPCnBWYQCJxSp1Cgv5Korr+TpT7kZZSaIrEfULLHGkE4SnFQ0A0083qW3l3F2e4du0qXrNxBUOMcZw1y7yXUHD7Pv4DKnHrmfpl8y32kReCGj/iZxmhG1OswtrDAeb6F9jdSKze0tOnOLrG9scOfdD9AMAwKvYpyGUUCaxKTJBE+BKTPKIuX0qZNYp2l3W6iepMglqysF+5aO4GsfLzA8/OAdZOkQTEmr0SSZTLB5RpomrB04jJAG5TRbe0Ouue5Gtnb73HXPAzOqfzXJUUlhEbLaVlRUfkSVzoSYTnjMIHCN79Qs9s0Ki+GCqZoVYkZNr0CzRMiKlm7c1JRtShifSporI7yplts4N4uJmzIgJGLmrv541uOtIQe+NviuKAYXjBIsAiskuXEUNc28crQusdZi3QWagLUOZ+3MUdsYU+fJVTqAyjfBVfmd1lYXY2ozFoOvNa1mE60UxlrSIifNMtI8qyjOruq6O6kq4C9AuIJIQ9uXLHUi5pshndAn0IJASRqBV+XS6SmNTeApBc5SZBmmyDFlAdaipUQ4V+n2pjubVPhhhJOKrCixTqC0xtrKIdCUVeb3NF6tOvdUAxiBJQg0SgLOoCT4vsb3NUpLjC0wZYZyBb4rmY88VtsNVuYazDU8AmUJNLiyIAoDwijEuNoUQVSh80EY4gU1Vf4iQzQclGWJtZUmvygKrLX4vk8URTQaDcIwnBmnTS9a6/pzXArIq4Oy+tFUShP4PkIqCgdOScKgGiQ1o4BG4NMIq8vl+tr1qU99ire85S30+/0n5P0/+MEP8pa3vOXb8l4nT55ECHHJgO5jH/vYRY6WlSfE6uoqP/zDP8y99977qOd+rctjfYa/+Zu/4V/9q3/F2toavu/Tbre59dZbefOb38zp06e/HR/5O7a6oSTPcra2J3QWIm645QDX37zMtbfMcfCKJqWJaTQL9u33UWQ0wspXY2EhotVReJHA64DXqhIMSusQ2iK1oEqYtNhMUCYCl1fU6yROGeylrJ+esHM+Y9yzpOMSrODeuwY8fE/B+omS7XMl8SBncT5kb3vM7nbOODHs9hMGoxyhNZu7e5zfOs9XvvQI/cEYnOOuL26QDCT97ZLRXoZJNTvnYGFuiSuv2k+74yE0bG8bzp+zDEcl2ne0WgG7m3D29Jg4KdjZHrK4EtBoC5K4JAqbdfwNeJ6i2QxxWPyw6lQfuyogjCq6fW8HssIjKzPCZsbCQshgt2Q4zPjXP/o0rr6hybmdT7OwP+Vpz9tPXghc2WJxaZHWfMjhKwOaTcnSqkfUjvnyl+/hQx/Y4bYPOSJ/mbUDq6STJoPNFb70uW22znk8eLdkuLfMsO+xsNQlK8foqCROdgmUwyaWhc4Sw36GsXDq9B733bXN+qmM4a7HXXfFfOnOc5w+v01jUdJYkCwshMgCAhQrSwphU4okpRkFhFEAVPGbOEtZ5AipQCkePv0Qk3yMk46g6Wh0JeNxSpFa5ubbtJdamFLga9jbS3BKEgQeZWLxtGZ7NwHp0WrNkaQgtUCqysskKy7neH+r9fGPf5zv/u7vZjAY8Ed/9Ef82Z/9Ge12m+/7vu/jv/23/8ZznvMc3vrWt/KOd7yDv/qrvwLg7rvv5nWvex2vfOUr/0mp2w8//DBaa+bn5y+5vyzLR10udErhwx/+MEop/uW//Jf/ZOtyub61qppprqYJT5t3buZw7UmqJKHahynQEn9q5iUcmkrjLdwU/DicM7NOdwUUL3Rrp4DQWEFROkpjyY0js4LYSIzfZPngVVx3060cXFvBxNtM9k5BMSBPRlXWtjG4OnI3yzI2NzeIGk3Go4QoanHmzHk8L6DZarK82CFSJeXgPPs7itW24qbja1x5YJmGcix1W7SjEF9JDh1co9NuYMuclaUFijxje2sDZ3Msjv54yF6/R15kzM23WZhvs2/fEp4SpEmK1prtnW3Ob5xByJIiH5GMdjhz4n42Ns7S2+uzvHIQRIiUAUmcIJyhNAW5sTgdcGpjlzNbfdZ3RiQlXHPNNTz5STeiPa8C1DisqCbJjbO1Q3ntUl53rGUNjMUUd9cKeyNdNekh64hkAaUQGCEwAgqgQFAIRykFhZKUSlIoUV8kuRIUAnKqS+Ygd4LcOTLrSK0jtpBYSA2kpro/M49voNgTrPG++LaoZkiEpDQGJxTa8/AuynA2tjZhs7Zy4p7SmgGtFErIC2DOVcDciekGFjMtgaTuqipFFEUkaUomKs2YyHNCbSr6uqxMyEQdm6W0wnMWjcWXonbcc/ha40mBsxalNA6DcwbfUxS5wQ8CjKl2Js/3EFJSFHnt+F3NvkmtmeQGJT2ME2SFAWfwlcTmBUUBWgf4vocxOXmeI6RFSYFxpnZqdHiBBiHxfIXNLaU15LXToPAk2gmUg8D38bVCS8fEZFXnWmiMs1gpyeroNiemJmfVBISQCikVQihMXtRTRRdtxZr2XxQFXlnOAHfVBfcu2S9m8W6X7CuVVEBIhzMGLessv3rApZQiFF4lPbDTSRvxbZij+uddn/rUp/jVX/1VXvWqVzE3N/dtf/8PfvCD/O7v/u63DXx/rfqN3/gNXvjCF5LnOZ///Of5tV/7NT7ykY9w5513cuDAgdlyP/3TP80rXvGKRz3/4MGDs+vWWl796lfz3ve+l5e85CW87W1v4+jRoyRJwu23386f/Mmf8Md//MecOXPm2/LZvhPryTcssjcW3P3gDqPYYLa2WNpPRfF2HksrjqUlnygwDPsTfHyW5jzOnk1oBgHjvkE1JM12g7g3QXoWP5KkscUPApR0xKMCicKIKhIED5qdgOEgoRhZBIK9NK+NHQVOGLQn8bVDOsPJB7fRvs+pEylBSxFEAhVqDl3VQYgB5cQyGGY89PCAMFI0W6ClTxhKtA2QNmM8zOitO2598lVs9O4kdyXX3jjP5HAlGQq0ZG8rRyBotQJ21hOS1OH70G765GmOKUrCyCOOC+KJJY6TWaqHxXL0qibpxLGzaUApooYgiqDXS+ltVh18P5AM83U2zj3EyUcmKO0xP+/znBd0WT2g6ffPk2eCbGTozmuW1ix+QyBwHD50iKXutdz2959lOEwYj8fsbUm+519ez2B9xK1PO4bfzHno/nPML/nsPxbgDCSTkgNrLU4/PGb9kTGFcTz7+ddhi4iP/92dFMkWaTfCKcviYoMiClk/k9OIBMsLEU96yhpnTu5STgweIS43JPGELEvI8rQyEsbgeT5CWnr9EQ8/tEueG0xumQwFc0uK/QfbKD2hN0hJtCFsKcgk0imSsaEhFaXVPPxQjDOOZtdjc2fM3nbMwQM+sSvptBdoaO8b7NWX6xvVG9/4Rubn5/nYxz5Gq9UC4GUvexlPetKT+Pmf/3l+5Ed+hNe//vV84hOf4Cd+4ie47bbb+JEf+REOHz7Mu971rm/pvcuyCnve3t7mP/2n/8QXv/hFfviHf5goimbLTCaTS8Yj03rRi17E3/3d3wFw5swZlpeXaTQalyxj64bPtC5m7l2ux7umOdzTkV9lsOVwaGercaC84GbtHJUblxMIJ6jIzpXhl6lfr2r6ARfcpnAWnKxSlGbab1lHZpUOPIXfmuPAVdfht1ZYXNxH6FtEuYMwOzgbUJQaZxXCD8hsjtAeq/vXuOOBTba3tgmbEV+58x46nQYq8MhzQ5Gl5C5lKWpw4NACC+0OC/MNiqJkvOfTG6XMzS0jlKLZCDl6+ADK07S787TSgkMHVhgMEkpbcvDQAR566BGsMzSaAZ7Xpd2q5E3WSnZ3JyhPYV3J5uYZFjrLhL4FW9DyNK1WG4TmwJpmb+cMw91zLM23GcQJRjc4vb5Dmjv2tnbwcQR+A89THL/iAI1Og7//3JdJ+xOQgtIWFTW8diNXtfmZFqI2kZumbtcNV1Fdn27pyvurbtBRxZVNH5NUQHzqF1blhEsslQGbkBLpZLXlbSUucNTyBFclqVTu6BW7WVd7wOO6F39bgfejH3z0DYdgOtlgS4P0PHzfpyhqczFjKhApK/BcOdpVy087qQLAmJmZmqcrUC7FBS2xc448y1BS0Wq18MOAOEtJJzFpFqO1BxKysgSpcAik0vhUpm55luIJyLIKeMvAw/MCEKJyAZcKpERogclLhNIYJ9A1gCwycFKTFwXWQmEdaWkIvFrnXloC30N6CowhyxM67YDcHSoAAQAASURBVDba01hbIKTA0/WskhAUpqR0Bql0HemlMK4gyQsyBFEYIfHJ0wxfelXH3VaO6+AoSkOeZ0gpa0+76kvN0uo7ihpVtzoIwkrvneZYKTEXTUpM33c6+THdMJ7nzQA4ULuaV917Y0qssRXLwFSMBScteAKMpchyJpNJ1V2XCq0DlPSrjrubhkfIxz3w/v+mSpLkkkHKd3L9Y9f1qquummn7nve85zE3N8drXvMa3vOe9/CLv/iLs+UOHz78DTWAb3/723nve9/L2972Nt74xjde8tj3fu/38qY3vYk/+IM/+Ed8mv/zyhQFeeEQGtKkYOWgz+K8hxcatvdydjYl2Sgmi6sfyXI8ZGEloDvnM0ksi/s84qwgNxPCpqHV1kglKVKYjEt8v2IU5aZAyoqCNhxkdDqN2vuj0u9JJM5IkIZm26PZVkShpCgNk6ElLwryFErraHQ8isxw4uQWNz01QnYFvZ5k1TXYPJdRlhXoHfdipMgIAwh9n83zEx45+fdccYNP2I5YXFglCmKSNGHnvGVrvUA4y/KKYtQvmewoxs7Rp8BSVgYxwuGcRMjKfLMsHM22Rjp44EsJk5FjnBiEstiyQKHZOGOIRw6Uh8k8Pn/7KU7cs8dkpDh8TY7SOavLSzTCgJNndun1C44dmeOmJy8wHO+ysztirnOI9TN91s/exuI+wSSR+FHI3JLhuhuO8OwXHGA42eCRk0P2H2yxtnYIGfXY29vhzEnDuQdHXH1Vg8PXtjh1PmU40mxvbjC/HHPosOb8VszSUpvdrZTBVs79d2Ts2xcwWXFM4pIzZ2KKHUnw4i7z83NM4oIwbNHpZJRlgRASa0r8UDPZmTBJSrSWOGPIY4dWiqDpOHSsgwHuf7iH8SVYj+0TKUePNIl3E6TXRHgxnlZYWVa5slqiXIAvfYoYWp3WE33Y/LOuyWTCZz/7WV772tfOQDdUEr8f//Ef5w1veAP3338/1157Le9973u59dZbeepTn4oQgs9+9rM0m81v+r3vvvvuSwC153n82I/9GL/7u797yXJRFPGJT3ziUc/vdDrf8D1+9md/lne+852z2y996Uv5m7/5m296nS/XP7xqJyPA1anOF+5V9di8En/XT6jHspU0smrsOeEwOHJTm3epClBLJ2t6ssROu+BcMHKzxlZgTYLyQvYdvRLnN3AioBE1KNIRvckGcxHkaYE1TZwtaDUDirTASc3W9g5JmmJLy9r+fUyGOUrB7l6ftX2rHD24ymJTc9XRBfavzCFrUmlsS5a6bdK0ZHtjnUlmkUFlAF2YkjNnT9PpLvKUJ93MIyfOsLXbY2Ghy9xcxPr6eYpszIG1JZaX5jlx4iRFIdE6JM9yluY6mHLCaLhHMS5pzC/jtRYYjQfMzx3giisOsLq0yOmTkkm8x/bugPG5HlFnxNz8Pkrh0d/dRnKC5z/lOI1IoKOA7248i0994U4eObOFUqClRLnalVyIivpNHQlNRQG31IlUtV+Xu2g7Tm87phr/asLYOlFNuAuBcLZmuVeabyFA2krv7RAILWbRYdUGtjhb7R+SCrQb51CPs3T1cZ+mu7jTfbHJWnXXhUy8qqouL86hhEJLCDyJdBYlKjP6SktdVhpsAziBFAolNVKoKoqqzn7TSiFVBQal5yF9jdCqMmQwlU4wr7UVvvZoBhFhGEKgMRpKW4Ks6CVVd1WhlQLnMMbVa+MxyR2J9ZikBmccSlTrIpF4qsrFFqKksCWTLGOc5hRWkBsorCTJHUlhyZ0jyXOMg6Ko0udDL0BLTRCFeKGH9lXl6JqllCWksSNOYRgb0gLS1BInhjiTjBNFVvo4Uw3g8tyQF5bMWDJryawjz0ooQFhZOQfnpso1NFAUUBoJ0kNpH608lJD4QhComtujZDU5IKsDRtVdad/ziTyfUHsEyiPUHr5UhNrHV5pQaiKlCYTEF+DhUKZEFFmlIZnEZFlMlo8pTYbSiiBo4vtNtOfj+QFBEBIGAWHgEfmXuxRfq97ylrfwC7/wCwAcO3ZsNvn0sY99jKNHj/Kyl72M97///dx6662EYciv/uqvAvC7v/u7PO95z2NlZYVms8lNN93Eb/7mb1IUxaPe42//9m950YteRLfbpdFocN111/G2t70NqOJbpgOfi2nbJ0+eBCon5ze96U0cO3YM3/c5cOAAr3vd6x5Fi/966/rN1hRcnzp16h/1vDzP+c3f/E1uvPHGR4HuaWmted3rXvctrd8/9/r03X0eODmkLB2+B7vnS7bPQtwr2L8YYlI4/0iBNLIyTNEemxuGfj9lNHGMkxI/kAgpMAiiRkCRO4SyaG0xpkBogdaVP4bvS5ptTZLkGCOwrvLGsJQ4UeKwBB1De1EQtjzA4vua+cUGrY5PGGiUA09rxgNLo9WAyOC0YWEhwFeOvCgZjkosmklmmWQB272Us2d3yVJLlmr6vZLbPnGKT39snZP3ZPTXLZ1Gk2ZDsrTQ4JX/n+/jiiPzrCx3OXblAmsHWwSRBlFNWPqB4uDhiO5cwPJKmzQzbG5kjMcGjCVQGs9q9jYNO9uO0iniOOfEPX1u+x8bnH/EEY9LDh7xedoz9/Hc5z6b73rWDxD4SyzuV3RXJGmm8P0ITIMvfeE0o1gSLeRccX3AU54juPbJkmueHPGlOz/L+uY5cAHJIKS/objnzrOceGSXcycLtk45FpoNFuYP8sUv7rHbS/nkJ27n9P1nmfRyNs8bpBPYImcwNGzvZRy9ymd+xbEz6TOIYwZbFmUck+GINE/Ji5xW0EA5hykKysKglMaUBXujIZk0yFDiNaExp2h1BL3+kAfv6zPZs6y0G+jUke2m2Ink1L1jRnseZ08PEE5TFA6TQxYXtOc0RpeM0ortNTGX48S+ler1ejjnHlMXPdVYTw3JFhcX+f7v/37SNOV7v/d7uemmm76l9z5+/Di33347n//857nrrrvo9/u8733vo9vtXrKclJKnPvWpj7pcffXVs2UOHz7M9vY2cRxf8tyf+7mf4/bbb+f222//mtrvy/X4lK0jhK2rfLKVqAC3Eg49vY5FiQozaAmeEmgtULrSiEsBSkgCJQmlIBCglEAqgZJVPxXq1AgryGzleu5cLQ43glCHUDrOnlnn/NkH2Vx/kJ3Nk5TJmHjUZ7CzSREPEGVCPNhFmpLxYESZlYyHOQfWljh6eAmv4RjGfZbm5xhurbMQwdWH5jm42MQ3KS1f0PIloSdZWpyj0QwpTI7wJNILGE1SJpMMicJaw+J8kxuuO8pCx6cTelx15DDXX32MTjOkt7vHZDJhbn6B9a1thoM+B/evIXLBgcXDdBsVAJ8Mz2HSbSaDs2xvn+KLd3wJGc2RuC4xCxjVBBEgrSSbjMniIToQrO+t8+mv3M2ZjQHjSUYz8Hjlv3kpz3vajbS1xqOKbxaAFhJPWpQw+LqSByhRX1zlaq6QKKuQViGcqrO5K124ndLNpaCQ4ETFYXDCYYWjxFEIKpq5cqSqJJWGGEMiIVWKXHuUfkCpBaWyFNKSYcmcI32cgfcTl+M9m8m4YJLgsNWslKuz22RlouZs5TwrqZqotrYcdHKWfF5PmbhqpkMwM//SWqMv0hNba7FZgVIKz/dxgionujSkaYqQEpQkCAImg2Hd0TV4StYCfDF7HYcGqSgt5IXBl2CNRalqdl6rytnc873KSMA4styQZAme9jHGor0Ak5WVkY6TlAakUhVV3BjyLCbwPIzwCQIP6wq055FkOUVhKHKDqTPAlXBIUbmOx1lBbqs8cKXA5abK10NikMRpQasdYE2J9DyaYcRoPCGPU4SstgOipngLSVGUmLIkVxJblpXDvKwnNETVVdL1dzM1V7twUaj6+5N1Brur8sIq98JaFiCw1UmRKtKhNAVZGpNmJUnq0OEcfhhVJmvT3efrOuZfLoCf/MmfZG9vj9/+7d/m/e9//2ywcP311wPwxS9+kXvvvZdf+qVf4tixY7OOw8MPP8wrXvGKGSD+yle+wq//+q9z33338cd//Mez1/+jP/ojfuqnfornP//5vOtd72JlZYUHHniAu+66C4Bf/uVfZjKZ8Bd/8Rd8+tOfnj1v//79OOf4gR/4AT7ykY/wpje9iec+97nccccdvPnNb+bTn/40n/70pwmCCy7DX2tdv9l66KGHAFheXr7kfmvtjLJ4cVVGT/D5z3+efr/Pa1/72m/p/f9Pr9QJtCfw/WlMB5w9GeOFijwrGfQKPCnJcoNUgrmFDqdP93FSY/LKXC1seew7OscDw10m46ySCfmGVkMzHhQVu6gKtSBLDfOLTTzPIGRGkYIx03NDNeFbZooy0UDI7saE/ftDdjZGZIkAYdk66Th4ZInrbjnK+olzqLBgfh4apmS47LO9l9Pohni+z9bGgCByNFuaXq+gt2c590hBsyPYt+RTGkNvQ7GzFdNsehy/psXC4hLX3XgNH/vEF3ju91zD2XOnOXN2TJJb7MBVE8oI5hcaBGHK2VMD8gQQAq3B8yT71+YYDlJGo8rZNww8Fhc9hDTkRUl/WNBoaw4cWGBnO+au2z/L3s5nObe9wwtetkoQRAz6EZEfkacZSsLtn95g7bAkbFrSkeTeL8cs7W+wMLfKtVf9Cz7w5x/hM7ed48AxjfFSzFaJLNtYq/Ga0J/sEaeWuWaD5nLBYrfAo8kjD0+I5hTDgUMqnzIruP7py0TdjC98dgcfD1eUCM+RZglKS5qNkCAI8P2AvCywCDztI4VGq4DSSjqtAL8JzisZJTG+rzATy/i+Hklf0ml6iLFitD1Ga8h0TpFZjHA4KwgDTW+nwLrKFK7bDImaAZvbgyfiUPk/pubn55FSsr6+/qjHzp8/D8DS0hJQ6ah///d/n6c//en89//+3/nLv/xL/s2/+Tff9HuHYchTn/rUb/r5F9eLX/xi/tf/+l988IMf5Id+6Idm9x86dIhDhw4BzFh8l+vbU+LiPl0NHYS48Nty8ePikoUvPCYRM7ato6Ymi2m81DSmuPICm3lQ1X+EpWrmCcX29jYbewM63TZf+MI2V661mHQch1Y7dNoNJsM9Oq0OSgniJCbPCh546CRBqFhdXWFrexMpCubaIaEHOtRcd8VBjq7NYbIBtizJTNXBz+KYLDNIl2OyCYVL+eKdD9DuNDl8+DDNdpvdvT3Or2/gqNiwJx85QRD42NIShRFhNMdoNKHV6bK4NM/udg+tJI0wZDIaMx71mOu2KF3J3vY5wtZ+1tdPcm5jyGA84sDBg4zTBD9o4HlQ5IZhfxff94CCRjNklOSc3dyl2woZ9nbRnub7XvI9POUpT+KjH/8U506fRbhK4iUReEJDKRBU0Y4IyyxYzIlLyAtT/5NqW7oL2/rC5qy26ew5Yva4qBQIyLpzbp2lnGrMpZ1pzaUTlNZNPeAet3rigPdjlJAShcDzKuCrlavjt6bZfdW3IeoNIKfqXuEQWIwtEMKh6o5a6Ae0GhcG5rasQGr1XgrnIM1zjDG1gZuru3mCsiyJogiTZzhr0NIHIWdgfurA7XneLENcSEBJnBRVJJnnIyRkkxIpFdr3GI77pGmO1gYQtLwQpT2yJCYpHH4ga1M0n0CDpMTzBcIptJLgPKwAG0RVpJcT5KaoMrkdNJpN+sMRuTF4QcQoTdAocmOwxqI9j7JmHCR5QajADzzyvCC3BUVtgFDl3SkkCs/z6HS7aCXJkqQyNShT8txU+Xraq3fuSsOhtUbX2nxVX2bbWAiUlBhpqSQXlizPKIq8cqYVtQ7HGUxRkpeOcZxhVWX45mZmbF+t6b4MvL9WHTx4kMOHDwNw6623cvTo0Use39ra4p577rlkth/gP/yH/zC7bq3luc99LouLi7z61a/mHe94B/Pz84zHY372Z3+WZz/72Xz0ox+d/di96EUvmj33+PHjrK6uAjyKvv2hD32ID33oQ/zmb/7mrCv/4he/mEOHDvHyl7+c9773vfzUT/3UN1zXf2hNAXVRFHz+85/n537u51BK8fKXv/yS5d7whjfwhje84VHP//u//3ue85znzHTbR44cedQyXw3Yp2D9/8byu5ogUNiyJB2X2KzKc8kLQ5LmeKFDahgMYXvDsbM1JE4MXmjxI2iGkqanGe0MCZWmKCBsKYrUkKWOPHWEvk9eZJWxppWMRwnziwHWKqSAZFKd06n/xn1H0kuZ73ooJ+jvjkkzRZYXlbGZBlvusbczod3tstDpMCr3OLpwgHY45tzmgCuuuY5jx6/jQx+6jYfvP8HCYkiagdAwGVlGezmj3YLmHCRZBRxLHI22pjca8P/9w//G6XObFGqAKQsOHd7PeHwWJRWdjmZ+PiAeDlg70GHUG2OMJc0cy8sdgsixtztgOCjozge0O4rj1ywyHPVJ04KFqENnxbG8FvLIA4bTJzaxWZuTD+bkLuf+O/foLLTZ2TjFtdcsYGzCgaMhVkbsbBSUScRca4lbbhzT7EZ8/oun+L0/+DOyuOTJzzqGCsfs9TfZ2/KZDBOOX78P7Y3xg5S1w4rdzSEHr+pyYLXDx/7naXo9xbWrbcbpuJrotbC7FaOGFpv5ZD0IAov2oT/qE2cpcRrT6/VqGZNXsdLCEKUEUcPRaMFOb8TxaxdwyjIa9klzgSgEpJZ0GxqlQ1rD0SNNpFQMBinGaKRv8XyFtA6TWgwCAsncXIvRaMD2VvpEHjL/7KvZbPKMZzyD97///fzWb/3WTApkreV973sfBw8e5Oqrr2Z9fZ1XvvKVPP/5z+fDH/4wP/iDP8hrXvManvzkJ3Ps2LEn+FNUE9a/9Vu/xetf/3qe/exnX+5ufwdUHXoziwOrboAT8oI72mOWmyUcWSqQDaJq1DE1bKs75VQNIimq2CotphnSDimh026zuLzMyEK77RiOUga7MV1fcHh5hTTJsGWK7/uYPENrn0JJdnYHBIFmpTFPmpXs9rdZWZgjbCiWOiEHjh9g30ILX0FiDJPxmCTJmYzHzM/PE0jNcreBlpKdccrWcpOg0abX65EWJcYo7rv/FKVxHDt6lIMHj/GlL32hwjG2atI5Czu7J2m2W+jVBTbXt5k7dAjf1/T6m6AcvvKI8wStLUU5oT/YZnjviPXNc+zft0ySJWRJiu+FCOlIkgG+J5FhRG6gH2eEjYig2aEsHc4abrnxWp765Js4deIRPnnbZ7jn7vuhLCp6v63wnFXVd2xFnblda7UvjPfFzH18uk2nD0314LOdpH68ul39MRcB9Er/7S7CkWLW9JNK/vMH3l/P0dzNzAymy1oQlRu40hpHUX3dUuDKC4YWsxxoJatl6853ZaZmQVb08sALcM6RZRlFUcwGxM5BmmZkRV4NxK0lzzOU52GBLM0xSqKFIApDyjyjKHOidrsyTCtytNYz3XIURRX4NjlOWEpbdblLW+mZg6jFaDTGSIlFkxYJTS/AGENW5DglK1177bRmjEE4QeBrpKusIBpRCECj0azcBSNNWZgapIL2PAIliRoRkyTGCskkTVFaoLVHWZZIVYHiPM9pNBo0G020NBR5UpnVacn8UqcaFMcpRVHirEEqSSOP0I2IVqeNktXenpeW4XBEkiSVpttYhKMyTZASX6na4V3i6yraAGswRVE7tJfgqM3YqtxuKSWlKSmLjLzIKAqDk4qg0cTzPazyvmqfujALdrm+ubr55psfE8h+6Utf4s1vfjOf/OQn2dvbu+SxBx54gGc84xl86lOfYjgc8u/+3b971AzzP6Q++tGPAhUd/eL64R/+Yf7tv/23fOQjH7kEeH+tdf2H1lcD7GPHjvEXf/EXj4qF+Zmf+Rle+cpXPur511577dd9/X6//yj33Ntvv/2frAvzz63mlwOk9Gg0Isb9Ib3dCdnEgdR05hXaq/RaQbfB7vqE0aCg2QywBrJxhnKSeFfS380whaIwBpzA93x29zKU0ihVEDUFo77EOUGRO4b9nGYrIkuT6hfmoknbsrRINGFDYwkpioSizCvQHSiWlpooWZKlKaW17A5LlhYCwrbH/rDL0ev388Uvn+NLd93N/ErI0eta7Ftpcf2TQpK04MF7thiPAQTSWhoNx8KihykNe9sJxsScO1PQaPpMRimeL9nr9VhYlszPL1MUE44eixjsFCwvhYxHHkv7NeOJYTScMB7DcFBp2YJQsP+IonA7eM0cvxGyvd1jt+c4fVqwf93SnYM8zhn3c+aWPVoNzd7OLseu1nRXB/gjS56NufnWec6fHkERcfzaI6x7J+kNRzRCgbEWP/D50N88yFU3QrsF3XABT5XI0OCHGSbPufqqVT6/s8Hnb9vjDvoEWtFtBzx0V5/5Nc2BtS7n793mri8OGQwMvlYE0nH4igByQVamtNpt+rtDgsCn6RrYiQUlsc5ijcX3LXPLsBREBJFjfXOAloIsNuhSEwgfpQ0CR1qULC136O+OCQJJmhbMzSmW9nU5f6qPH4HUlmbbw7gYlENdVi19y/W2t72NF7/4xbzwhS/k53/+5/F9n9/7vd/jrrvu4s/+7M+w1vKjP/qjCCH4L//lv6CU4j3veQ9PetKTePnLX85tt9026ya/6EUv4uMf//ijJjS/md+baVlr+cxnPvOYj916660EQcDc3Bwf+MAH+L7v+z5uueUWXvva1/LMZz6TVqvF7u4un/jEJ9jY2OC7vuu7vun1uFz/uFJT8OQudDadmOKMSy2xvlrmKqW8yIa3MmWzU8UkDl0baxlRdbulAK3A1+BLNwPgeRZz330PkiifTHnEpUTj+MrdZ5gLLUdWQjpNiYsMaZzhBQ1KrSmNZWFpid7EMpqMCaOQhoIrDq2y0G6x2GnSDjUujymLAlMadrZ3icJgFp/WCoKK8WMcB9b2MYir3629vQFRYw6pInY2txiP72f/2jL7DxwmyxJ2d3dIsoL5+Tk63TkWF9sMBkNM3sXaEuckyysrFEVCK2yCGwMGY1KQBeM4YxRPMDanGfnsDfp4WhH6Hnky4fChAzSiEGd9CisYTFKOHTqAJw0PPPgQ4/GIW590K8991vO58bon8aUvf4XbPvEJTp94CEwVc4xzsw73rJktKnNUhKzxcw22ZzMv1bJlvR/wqL2gvkdQZ4Rf8IN2F+PyCohU5m9CPu6Y4tsAvKv/j/4gj/HJHEwz3YwxWGHqgZWinALvaR63EnU3tcpds8ZihagZhwotA0xZUuR5dQCaytGuNCVZbsiKAu1pgshHKcVwNGISx5TOVYO+siBoRkghaLUaeFKQFyllWa2Pc1X23tTNMgxDGmGIoIrUKq1DBz55miKdpLCK/nBCaQxF6UgLg6c1eVl1voWsdIpSVvnW1lYnDc/zwZYIZyiKDOv5pElGXhjKOr7LD3wQVAeoFISBj6Wk1fIQSY7nhYxHY4SS+J4mCgOiKCKOY7QsUFLg+z5+EFCUJZ5vaTWbjMcJcZwipGAcxxRFjucppBD1j6Km0+7QarbIsvSSuDcBaFXljStVHTTV57IIAcYasiybxcFVM1mSPM8p8ow8TymNoXQO6YX4UROpdeVS/9Xcksv1LdVjzeSfPn2a5z73uVxzzTW8853v5OjRo4RhyOc+9zle97rXkSQJUDnHwqVu3/+Y2t3dRWv9KKq3EIJ9+/bNtIBfb13/MfX2t7+d7/7u70YpxdLS0owy+NV18ODBrwuWpwyCr9aGt9ttbr/9dqCKGftWNej/7EtY4jTFDxVOp3SXFWWnwXBvQmtOkCWSyaBgVIwpModSEi8oiSdQ5IIisWTjnDyzsy7FYLNAaUWoAww53fmAPCuZjByu8igjHhusSVHKo/Kvrad6xdScpURow9U3tjjxSMz8akDQ8HnovglxYtC+InBN9h9sgGfo7w658/6HsCUYBH4zIjMp0hPsv0Iz3N6j34dmU3L8xoC8bNEOQ4p0D3TIwtwc93x5h2QERVFww/WrrB1c4c67HiSfFORZyvyKx+5wi2RsCZsJnYYkbCjK0tFoG57+/P2MR46HH+gRNsdYo1jaZ0B6bG3lBA3D8as6tLqC46rLJI0xdogzls5SSPtpbUaTAfGgkhlddW2EkyOOXLHA9jl46N4By/sF8SBF6BGDUZ8s1fS2clbXDM45jh5THD3UpdXw2NjM6O0kFHrIrU8R7F/cz+a5Al95LC2FbJwasHw0ZGGhwdl1QzbMeGB7m2TiUBr272+wtKqgtPS2Cw4cWebQ0TW07+EHAVJVk/G+72GLkizPkdJHEJFngtzkRC1Lq+XT302ItE82dgwnFg0kRYGVTVrzAYO9MWlsWFrq4nkZ8WSMiCy+cKweiIgahqX5CBO3mIy2nrjj5f+Qev7zn89HP/pR3vzmN/OqV70Kay233HILf/VXf8XLXvYyfumXfom///u/58Mf/jD79u0DKor6f/2v/5XnPe95vP71r+c//sf/CDCLi7244ji+RIL0j60kSXjWs571mI89+OCDXHnllUDF0Lrrrrt45zvfyQc+8AHe8Y53kOc5y8vLPOUpT+Hd7343P/qjP/pNr8fl+seVqrvdF0y33Ax+1WqjxywpRGUmPAV2davUCbCy0hV7ruq6Vk+oqMdaVTFknqi04gpXmTz6PsM0Z3N3QrC4Qn80oWkt9z60yWL7KI3Ix1iFpWJ3WSeZJBlCKlqNkDif0G01ueLgMgeW55GmwGRjJoXDFhl5XpBlJUr75KWjP4xxSPxmByckaW6JJxll4fCDJpH12dkdgAopnKRMMsbjmLm5BYqyJIyaeL5mEifE8ZhWUzMeDvF9nyzLaDQbLLSXyIoEypJ4NCEp1onjkjSPSYsq5jfJCrrdLqWBskgQtiTwNMP+AMoqqUTqgCxLmCQJx48coD2/yPrmFvs395ifP8bC8iJPe+YSV157E5/8+7/j85/+OHtbu1Dnpgs5NWCbgvCK0SyEnGELVzvZC3eBAf21tr3lAg6d3oYLmFRMrc5ULXGd6gsex/q2ciAvnqF0sz+XVhVcX2dE68qsS1BFVEkpUZ5XuXnjkFRudUI4ELNsKXAVPaEsyqozXgPyKAxpNltIP8ACSZoihGCvt4dxDi8MMFmOdeBpr+5qV5E1jdDDLyRpkuJcBTzzmqYeRRFJkmBMTqsRYJwjCALy0lBaQRqnZLlF6ZBJOgapyfISzw/IyxKlJY1WgzQ3ZHmBVBVVHqFoNhpkyRhPCawR9Ho9jJWUpjJ9c6JyTddK4QlFoDS+lPitJlZptEpIkxxMTrfdRWuPoigweYInLVEQYK1Be5WWuxFFKO0xnkzo94Y1hb6y5s/LgjRLsDUtX0kfKSRe7TzveVX7ypra+EKJmZlF5dZrsNaAsyhZRb+VZYGzFzvfOzytMIVgnGZY5RE2Gwjt46ZMB/tYEzmX65utx+ocfOADH2AymfD+97//Ejr1l7/85UuWmwLms2fPflPvvbi4SFmWbG9vXwK+nXNsbGzwtKc97Ruu6z+mrrjiin+S7vNTnvIU5ufn+eu//mt+4zd+Y3a/Umr2+lON+//NNdwtKUtDNslpttokyQRBwspBTdi07G4WJAOHlA6cxGEpckdRQNComEDteU0SF6SxoEgNnoRO06Pd8dnaKRj2ChaWI8LmhHRoZ92PNDZIaamm6qaCPVNFFTqJEgmHj4bc9NQDZHlB6QzjOGZ7PUGnTdIsZ1KUEFrSxLKyWL1OWjgOLivmlhXNjsKUKdJzFIWlOddie7fH6to8nrK4YYTC46GHt3BacezqRe69+zwPPLjDXffsUNqqW+9HVe63Hwja84I4KXHGoYNNrr1ljTTLaHQLWosZ3eUmNz15lQ//9WkCP+LMIwlZIbj1mYu0Oo65+Yjt7QGdwFLkmmRckCYZvm9xY8vJ+3Oe8oImRRnT6FQGnY1ghRtumiNOT9LuJGTuJCJI6G0ULC553HjjPOfPbhIon72NAd7BFmlZEoSGyJNEUQgyxbmCZz9vlTyTbG3Ocd8d5yl3d1nZ30CWLdLEkGUDdChpdnO6q4q5uYD2+YD1R0b0xwOKoiBNcpKk6vxUoy1LkRd057qVpInqRyDyHfMLXQbbhnziGG0LkknB8orPgcMdjly1hpN99h1e5f77N8mTHGurTvi+KwMWlxVPeuo+ensb7J0uya1Ee5ejof4p6jnPeQ4f+chHHvOxt771rbz1rW991P3PetazHmXe+bGPfexRy91///1cccUV33C5x6r3vOc9vOc97/kHLQuwurrKb/zGb1xynr9cT0zNupXVLZwQ1ZjTWax9dKzshfGCuwDauOCQXRmtVRdPzpquVXKSqGjmnhQo6SoDsBrgCxytdpNst8fGZo8w1IS+T1wKTq/3cabFvpUuTkl00GR70CMpqhefjIfkxYTG4iJL3Q6+gNKVeFoxHo0QDnr9MXt7A5KsoCgK2m2YX15lsxdTypCMEFMmWGMZDCYkOSwsrXBuYweDYK7TxVrB9vYuSkvCqEkYBpw9e46lxXnOnjrHsaPHePiR0+z1xozGOciSdqfJUrdNK2qRS81gsEeWVTR2IQXDccrcnEN7IYEX4vKEeBITKM1kGGOsAKXxgoDCGO6870Hm2g3WVha498FHUNEK80urGCSFbvP8/+cHOHDgMB/+4F9z4sQJpKg631VEtKglAKKWsdbj/qmqwE33BzeTIz9WmXqbTeurYWdtfF9dF/LSdvjjVE/cL8xjfC4hBdY6ytLiaqBdmZi5WSRVEAQopWbRYNPSUs2yvKUQOGOwZVnFjaQZntI0owZFnrO+vsHp02cZ9Idsbm2zubXDaDyhKAzGVAO1MAjRShMEPo1mo+qwRBHtdptGo4FSik6ng+d5s7iroiiI05TSWCZxQmkcSA8/aJAXhsI4tBcQRE2CqIHUGj8K8YKARjOk2Qqp6B2V+ZspHaassmeldISBj3OuNoLLyMuSMIpw1iGNJY8TyjQjUJpWGJBPJkhbojE0A81CpwVlhi8dwuZEnsJkGZHnMddqE3oentJgLcI62s0GzVaLotbEer5Pp9tleWWVxaVFWs0mUkqyLCNJEtIkIc9zcA6tNFrpisFhDEVekGc5RV5gjZlRgKRUeL6H1t5swGxNpcWXUlUnjEYT5XkIKZBSoJR8zMvl+to17Q5MO9XfqKbH1sVdBecc7373uy9Z7ru+67vodru8613v+roGd1/r/ada8Pe9732X3P+Xf/mXTCaTS7Ti30nl+z6/8Au/wF133cXb3/72J3p1vmMr6RnykaFMHZNhSpqWqMBw6IomJgtIxqIyyiw9bAlYRzqpQHjQCAhbIANL2FF0lgMa3QAnwbgMS8zCkk+WlgwHJa1uiA5kpfYSgHAYayuOmaj/O4FyigP75jhyYJWzD404/eCERujRaDhuuFXztGe3UX7KwWNdnCwxtkRHkvMbBZ3FFjKwPPhAj8GgxDrL4kKLQC7zwN2GncEY7UnSScKgl3P2XMLW7pi81BTGsbmzhdSaJLd0liSdJYlToAKHDgSlg7ApWT4Q0FnSyMAQdAqGyYBxvsPqEcn+w3M8cuI8rTmLkgqE5cnPWGJpn2Vlf0iz67jpaT5PfXaLa65fZe3QQZQXcMU1y3zvD6zxrOctkAxjyENs0mXzXE5vb8L50xsIo3HWsbM3pLNQcv1TBLd+V4PRoMe5hxLyUYz2HWfOjdjaHON7luXFBquLh5gMKprewnLI3IrjyhsCrrq5iQp8JkmGo+Dgof3oAGQgcJ7DSUdmMhYOQWfZoXyN8gK059FqtqvfgqJECkGz3cLzA4o8w1OKYc8w6hm2zm/RnXc0Wpo0LfAD6M55bO+MGKfnmd+fs++qnGd87zyHbw25+lkrHLxRc+h6ybGbLRO7TlZasjJnNBnh3KNNFS/XE19ZlvHxj3+cN77xjdxxxx382I/92BO9Spfr21yqBmCyZlZibcWmFFPd9lfXrBs3A97TRtAUptfhPLUDeuXx4SuBrwSelnhaouUFhq0QoHXluRQ1NYW05EJgvYBeXLC+PWKnn3F2Y0BaaE6t77K1N6I/jhkOR3RbDZbn24S6AvZ5mpHEEwbDQWX0bKF0kuEkZX1zB6FDnA45vzvi7kfO8ckv38u9JzfY3RtjSkmWGYRQpGllPBo2Iubm57HOsbO3x7nz65w7v06SZjSabXZ39/C1RzyOmZ9bpNvtMhyNcU4xGMSMhgnt1hymdCilKApHaUAoDyE8fL+FUiHOVPnmrWYb3wtpNdtgCihzsJbJJGGnP2Jjt884M5TS8fm7PkNKSntlhcbiAcZFi4XVm3jBi36UI4evxhiBKepwqxIoBdKKqtlWe3pJV7nXa3GhM675+heFuHARYpYpLsUMcTN1YXMIlPf46o2+LR3vr9WkErM/VUkqmkEuBBMrWfE11hSIUqCkxtaOdLJuoyp01cdwDmGr2SgJCFuBU0TlmA0QhCFxktAfDBjHCWmWY1ylHSusoSjzatZJaRq+ohn4tFsRi/NdPC1wpsCaglLnVRSZMXi+Qnse4/GELM8wBsKgSWkMSvpM4gxrBVGjVek8ipQw8sjSFK0VvlYUeU7YaJDlOba0NMMGeV5SZCVew6c3GhFoSOJKoy2kJM4mCCXRUqIFUNO/nRBMkgQhIB9PwJT4UmIktFsROEMYaLIsRwmBNQWB72ONZW9nB88PiBoaLSVeu0Wr2WRzbw9fRZjSkcYZcZzi6dpkTnhVPriUxHFcmxtV3W7hXOV8bqoYM1lHuzkpcY7aGA6EKQikjxAG6wR5UZDZEud5BH5I2Omiwghbu6sLKWvd++X6x9Q0puWd73wnP/ETP4HneVxzzTVfc/kXv/jF+L7Pj/7oj/L617+eNE35/d//fXq93iXLtVot3vGOd/CTP/mTfM/3fA8/9VM/xerqKg899BBf+cpX+J3f+Z1L3v/tb387L3nJS1BKcfPNN/PiF7+Yf/Ev/gVveMMbGA6HPPvZz565mt966638+I//+Nf9XB//+Md50YtexK/8yq/wK7/yK5c89q10x0+fPv2YGsDl5WWOHz8OVAZs9913H2984xv5xCc+wctf/nKOHj1KlmU88sgj/OEf/iFKKRqNxje9Hv/sS1iUJyoTxSxDBZUE5Suf6VPGDjf1PXMXhkimOnUzGRiQtuKOC4NQCSKofpAzJbGBwQtgX9hkZyfBGJ+5hTa7O0PC0APlSJMcU7pqchLQgeSKo0ssLiwwSQbs7RZsblsOHFlABSG9nT5h4Ljh1i7bm0OOXuWROcvmZoELHadO7JHlJWVR9dF3d1Kagc9oGNNoBsQjR+RFWNcmiQXD3RFDWZBnDiUC9nZKhPNxLmffgQa9nqF3MibwFFEgCNsZV1zZxQ8Lrrp6Gd8veejeHk9/Xpe5JZ/+IOP86XMIGXD0qgatZsQwHdLvl0RdDxkOWFo2NFtNpPQxxuczn9wlCHxuuOVqzp2/mzQdcXBtHjOZozfKmIzgofs2abc8mv4hRtkmjoCN9TGWgiuv1RQuZXsnp0hg9aiktBkLS4q1Ay2ituLTnz7JZJCiEOwNMq65eQ1nBFvbCaOxR6MrOXl2yG6/YOlAi/k1S5lnDIegg5zt7ZxmZwHPtySTFGGr39xmo8kkTTC2QGsPz/PQMmRuzuPINStoYvqjEdYVDDMLWtBZ0aioQAVQiIzBxBH3HPfePaQwgoVFxeJyk7wcMIotrgxpR23aHcs9nxnS33t0XOLleuJrfX2d7/7u72ZtbY1f/uVf5qd/+qef6FW6XN/2qsDRtClZMSkrCZFSFfUY6t8S62aQu6KXc5E2vAJYlbmWQNf53BJQFoSsQLmq9d+edMg63Fm5WgpaWPYtztNb72GLHGkijPDZ6Ocof4RshiR7PXYGQzrzc3ieYjgY0F1dpdtocvzYPnxPkqcpYIknMUWWI6XHeDImTlKEDhhnlq1Rn7sfOEdsQTdb1eSzAatymo0QhyNoeqSZRPoR2vdwroH0NOPREF8r4vEIXwmuvOF64v4uYRgilcMUOWv7VxhPEoIwpNHqEI9HhL5PkVYM4NJZlMlJ4j5lkYAtUMJRZAnSF/gK0nhMu91ga3cX53mgA8CjN5ywvr3HoQMHGQ62+fhH/ydPe/aLWNl/FX6zg5Q+8xae88L/h/7/6LG3vYWzDqFcrS0QaFflcVdDOoeQYuZsLgCvoiEwNcyDC5nfEoFwU+X3NMraVVneojLGdg60CgjCBt25BVZWH18jxccdeMvHnoaqv8CpcL76hkTtTZcjGZSWtCzwBURRRFlYitLgSoMVYgZChQNKUx8kAi1VbaBTOWQbKlfhNK00yPPz8ywtLFZu6UpSOMt2b5feoI/QFej0haQV+sy3mrSiEGdLpFZ4OsLaigKXZVll5IYB4VBaogRgIfRDihLCMGC3N6S0MV4QonzHeDxkYb6DKw2B75PkBQGSJLeMxxNarS6BF1GUBVI6pAdIWTmyG4cfRYgkptNukcUpWkqsViitsM4RNSLiyQRjSrrdLnlR4oTCUdFxPN/HuorKL6WktFWeOUDT9+tZQ4fvedgs5eihfQxHCadOnicvLHlpZ59Xi5LSszQaIUEYIADfrzrmaZIilAco/FAhpUZ6HsJRUeSdRPsBTBtRNqUoHaUricsC4yTtTosgamCkrBkOGgS14+Blkfc/pl7wghfwpje9iT/90z/l3e9+N9Za/vf//t9fc/lrr72Wv/zLv+SXfumX+MEf/EEWFxd5xStewc/+7M/ykpe85JJlX/Oa17C2tsbb3/52fvInf7LSgh49yk/8xE/MlnnFK17BJz/5SX7v936PX/u1X8M5x4kTJzh69Cgf+MAHeMtb3sKf/Mmf8Ou//ussLS3x4z/+4/zGb/zGN9TxuXpfnhovArPc1W9FA/jbv/3b/PZv//aj7v+xH/uxWXdeSsmf/umf8kM/9EO8+93v5vWvfz27u7tEUcTx48d50YtexPve976vO8Hxf0N5vkR6lTzG9yTJwJIOHNLK+ufPUdujUG1GRxh6SK+KjMyzyvE6aFSavNIphO9wTUHUpZLYhHMMeglJPAFtaS95rB1aYGN9l73thDxx2NISNDx6owknT+3RacP8YsAwKfjM5zZZ2h/SWeqysz1kdS6gu6CwpkQISeRrrC4ocyjzKhfWUxAPYbxQEnULrr62ybmTQ47dskSWjcn6Ca0Igqbk1MMFnoJRr8SUFj8QnD89xNMdnvXsw5w6uUU8gmRi+ezHB1x5bYQ0SUXRZo3Nc2M8b44vfOY+Ou2IW5++n9Wl/Tz88N0884Wa8WjC2dMpN0f76A37eH6Tv/ufZxkNFQUFx69a5e4H7qIRlhy+YoHDB46xtRWzeW7IYBCzb98qgR+xtnYtp88rzp3vsXGuoDsvGe05Dh06jPqenC98+jRZmtHoeuQYzm+OacTQ6CjWlnzyCcSx4cy5HfxIc+h4h5tvOsJHPn4PfsfRXDBkxEi/wXDPsXumQDgPpEP4lcAvCBtk2TnKvMSUhjRNUIGHLQxlbtFSM9gteOTUOY4fCfHbGosh6BrWrva57uYVhv1dpA4Qns/eIGX/0UVu9A2NpsCZNnPtOeL8BGnsuOcrI8bbO/gONs86bH5Zx/SdWEePHn2U1vty/d9WtZFyDbZFnTRURRCDrD2iHGAlM1p4/czZrWn/29bgXcvKyVpj8Wu2lKACd5W7ueP/z95/PEuW5fmd2OeIq109FSIjImWJrupGd8+ge9rQMxADGrnAcEEDjTTjgmb8B2bLBbZYc8XFGHekGWljgA0JckiAAwJDcIwQBNCoqRZVXVVZqUK+eMrllUdxca57vEhRXQ1kdlUb8lhGZLzn7tfdrzrn9/sqL6PxmgqeFAmdJSB4czGjrltSF0CBU4qttXxyec3ZySymFvWWokqpqozFLOV0XjAtMtphRze01OsNfd1ijGO1qUmKgnQyp9t1XK5aHj9bUs6P6XcNi6MTrpcrhE5RWlHmimmVU1RT5rMZl6uawRl2bcvdO6fM51OePf6IWZVyMjtCeIu10Uvp5OSUl5cZSgQW8wnL9ZqXlxfMpyUEQ6JVBDylwLkO6zu26wu0sLihJteBVHqyJNCYlt4MpEVCb1qSkXIegqNpe+pNw0zmXNcrXjz9CXU3UDeSvuvpuzV3Hz7gt373r/Df/eP/hr7ZRuM7ouZaIlGjh9S+S78vuqUAvXc4358iUhx04NaHqO8H7MiAk1JGV1cB1WTO6eldjk/ucnx8l8XiDvPZ6Vd6FovwFQcgp9nPpgDvUalXDoSRTjxNJb/xYMbJbEIqNEPXjaYKkRdyoOI7T7AOLSRaKvIkQask6gr7Ppp86YTFYsH9N+5DgNX1DUWe89a779CbgavVkifPnrJcr+iHgSTRHC3mnJ0cU+QpRZmRKEG92yKEY+h7jLXUTUMQkrYbsM4hfMAZy2yxQOmEtusx1mGdp5pUZHlEu/u2ZTabYQfD0PVIIdg0NXXXUxRTvAdnPVmeoLUgSxSJi40CL2BT75hMJ7R1w2I2p2kalE4YhoGjowXLmxvyoiDPMpq2ZdtEem+SJIQAw9CTppG2nkg9uoqbw7HYZyMvTo7ZDQOffPKUlxcrdrUZNRbR9W+SZyRSIog5gWmiUUqQJgnVZMp0vmAyqSirimTU5ssxD0JIgRk6gutxpmNX77hZbVjvaoYAxWzOdDpH6ASHHI3zFASQ+M+z5uN/+3/8B1/OSfv1+HM9/t7f+3v8zb/5N/n7f//v8zf+xt/4RX+cf6+HlAlCx8LZeY9UEmsC2IAUKlLKxkaaGBuxXgiyIuXswTGr3QVFKQg4js6mdG3g4mWNkPDtX58zdAbhJaYN+L7g5dMNdT2A8mQTSIsEYxzdKhC8JJsqXOfQMvDOewvuPjzmBz9+hqdncaJoO09ZCd54Q3M0y9msLbt6YL12tNuAtwlCBYQamBQF7a5D6kBZCu6czBFBkZWBclLw5JNrpvOE4HtOjh7gXY93KS/PN9y7P8cFy09+dElaOapZxsfvG7Ybh5SCX/n1nOMTePmkxrdzjhaSyVHASks1gaz03Ls3pZop5qeWzXqI9289INSCLDnlhz/8GCUSjLVMJlOePW75zq/eRemGk+kZ9U5xddXw4YePOT5ZoBPP1dUVbSNoO4eUhrIM/O7v/g7L1Q0//sOfMi1KPvmwZn5nQS1qqjmcLAourzuEdAQrWF1pvNjx9nsTMl3x9OMtnzxpOTlJYmO78nR9ws3zDrOSiESgZz0pir/w1q/xn/8v/3Me//hjLl9GeuRm25AWKe3QsTg54eXmY7bqE3rXo51kuW158mKLrnrOzs4YXE+367h6PjCfCeYnCacPFsikxwwt3c7yrXfexdklqbjD//e/fcrHP9qhRWBzExgawa7/mm7+9fh6/LKNv/Wb+rWUCuDwcxgLskPhDSM5OQ4VGKnE42wTYu0VjYzFwbHtdkkkhIh0Ziw+GZ/iBVkx57L1fHizox1E9AA5LUh1QAnD2WlJngvefusN1qsNd+/fQwg4Wky5d7agyiTTIsXZgU8+/ITttqFtLNfLmovlFlUU1HWLt57VuiXNS4rJnNnREevdluVmzWZn8Mbx9sMT7t45ZrABKzNIK7ZdZPSuV0veefMh2/USrKMsUoo8IbiB+XzGrm5wAZarDU3TIUczZInHB8GPH1/xBx+vMVIhvKPUgvv37lNlmlR4fF+TyEhJz/OcdhjwUrOte4JM8UFQFQVaSh6cnvHdd9/henvJnbfe5PT+N5jO3mC7q9nubihEoBCBf/z//K/58R99HxkMWoFQkOxp5SoW2uOhjLFvMh7bV6ljAqHG4y4EXgRcCFH6KyRSK9I00vHv3nvI3Qff4OT0HmlWMZ0cUZRzlMz4q/+L//lXdh7/0gTMilFA70ejrd56Xqx2VJPZqLmKQnuhVNzTAoKPSJf3PmZbj2YLOtEkUuKNwQwDvTGYPKNM06hVFpBJSRrg/htvcDKfo5wjF5LVbotINUWeoxNFXmSUZU6qFUKESH0HlNJ4BMvVmr4fcD5qw5VM2W5bstyhtMQ6R54rpLB4G4tSP5pJaalw1uGcxQaLlJ4sU9S7mJEtBFgDwic42zGZVkBgVpZopUnn84MOPpVQliVCREMipVN2TUfdtjRtN+aPG6SUGGMYjGUymdD1Pc5alFIopWL2oHNMp1PqpuWmbtB5STm12NCgtI43Lx9IEk2qFISYgx4daOMFqNMk0mG8xzuHTDQyRH2GFNDbjq7d4Y2hbxt2TcPyZkU7eBZ371LO5gil44UiFfuotSAC8nPL7q/Hv+/jgw8+4Pvf/z5/62/9Le7du8df/+t//Rf9kb4egHAK0zhAglaE4GLHWkqC9DFxgrFzLcCGQN/1NM0WMQq48gJcaKhrSDOBQNNtOq7PBzZXgfk8o9+t+eZbb/L8xTUX10v6jURJCFZEh2wVsN4SMkHfBzb1DvfSoAvD2VnFe++9wR/+wWO8gSKfcXG5xPSKrvPIoJnNAi+fGxyeYq7p1cAgJJO0QClHWpS88cYJL69esG23lDNF53bcuVPxze+UYAU3V9f8lf/Rr7Kqdzz+5IL/wXfusphN2TUt3/gVxfom4cnjCx6+nbPZrsjyGdttR5neZVZ4Hn3zlNX2gsVxSTXRqKKhbXqsgWrmsCbBdDP++3/5Mb/+F8+4OD/n3vGM4Eru/cU3efL0Q5brG777K8c4F3j/wxe8eF5TzhLu30sIouSPvndFVWYcHeU8fPOMm6sl/+Z7P+ZoMefeu3MGmfDsaUPd9dw5m9DWLSdHb7JcdkjlmU4D1xeW5z9tmC9inNr9+zlD7+h6Q91B0wyUacLkWOJEytZbtAyc3T1DKclgevIiQ2mFQGOcQYTAerkiSMF6vWF2OpCguVMV3H835+Mn5zx9dsnN0jMpElAKi+Dhm++xaVY8fr9hOodplbDeXnFyZHjx4QcI3+MGzVvfyvjOb2T83j9f/UKvl6/H1+Pr8fljr82OLClxyPQOhINhlRev6vK9CVv8wb9y5Iobg3ALKWVf0InD84SIjEwVRIyjGqHWLEvIgkMlcFylqIUgTSTO9rz58C737h8RQk9dt8xnMxKlGIaWu3eOmVY5XbNh5Xq0h6axPHm+YtfBR8+u2XaOpJLUtUEpgXMpYRsImxWcL6kmOVVVsZA90ju26xW+b3nj0VtstjUXz16QT2astxvKPOP68iXz2ZRmu2G5qtlpwdFiwnq35fT0lLpp+PDDa46OF2y3W1rrCc6QZCXTqkDLNSaE6KElQQpH37VMFpOYyiSgN4YkTxlsT5CGyaSg7Q1CaPpui08Szq8vKMuSO3cXXJyfc3r2Jlp4ZrOSpr1hs21JZxO+/d1f48Xzj9neXI6oNwQJyChV9cT5PPrqje7makw9ESIarQmJD6CEJEk1VZGTJDmT6Zzp7Ijjkzscn5xRTeYUs7ssjs5IkhxkSghR1/5Vjl+awns/9heB9YGrnWG2rnmwmEYtgXfkRYnWGiEFjhAzu7VA+Mj79wSMcxRSUZUFvYqF5uXlBU1TU5UVd0/PuHvnDl3bcnF+Tt00JELy6N59slXGum/IiwytFT7Ewrj3Bilh6AwhgDGOvjNjzFlASoV3IubMEpA65sUWZQyZPzs9ZrncUtc1dqTG75qasijxLuCcpaoKiizB9g43uHjCWYfMEgIerWPXCamiQYQSbLYbrB1wVjFfzGi7Hus81oMTCqUzrIvUW+ED3dDhrIumcE2LjDbyaK0PKLi1ls1mQ+ccjXWsNzsGY1AalJaEIBFKorQCCabr4w0s0aRpSVGVZFlGohIkguB9DKb3FtP3dH1Da3vqeoMzhu1ux67paHrL4uQe08UxTqvIbhCK/Y1Tji2t1z0Kvx5fjzj+9t/+2/zdv/t3+Z3f+R3+zt/5O+R5/ov+SP/eD5k4vHm1SCryBOMkpo8U7uAt0ZBUIEKIDBoXMAHWVzUhDXSN4M4DiRQaa3qOjktePuvp6xjfKERgcyMYuoEPfvKU+w8X+DDhelXDIOkbh9ACoQVZCtM7CcFatFSUZUInWpargaefNFyfO+qNJdgbVOIYWsXq2nFy1zOZaKqZoG0F25UjSIFMNctVT184kuKGzjXkRYrwnl/7xj1s3/Jit+H8xQ0P791hcax5uXzK4n7Ff/Dmt/j4o4/ofcf9RyeIZMnL609Q+cD1qmO3a9isJFVZEJKOVb1l+GhFUU54+fKS4+MJSdlSN2vmi9itP3+65Ob6grPjKf+X//0T8mrgN347ABu0XvFbf/E/4r/7J/+aP/7BJcd3ckzYcPeNAhcMq2Xg8mLJb/zWezx/+py+M2AaVus122XMEL/YGE5OcoyBUlVsLzwDUHcfs1o5fuU7v8Inz56wvjAcTRRZUORTgx88u6XBBc/x3RRJYJppcqVpBsNROefixQadKAbTobVm3Q8URYrWCZvtjjzkNF2PSCVpNmN5c0WzXSOSLdkkZbd1NDvP3dMHBAYuLq9YNwH3Rx9z9+yEN+494qcffMS6CFxfG371u5pH3yx49PYDjk9bBrvmt/7SKT/+6eYXes18Pb4eX4/PH1qG14tpGKnn+38z5jXHQjki3+M/xL4Qf/3JYW9rfUs7jrj9PA7PC4AInjzVVBJmU0GiFTpEg7aymvLuu/dJEsF2Z8mzjLOTY7bbdfTxGD2VBhvX81070FnJ+U3DrpNsTUJHinUpLYKuh2Ew7HYdxjmUVqRbx3zqeXhUcnqUo51DBri+vKE1FhkcqQq8ceeY1WpF1zryVLHbbfHe0niHsT2TqmKz2fLo0UOOjuZ0Xc3J8YKiKFkvl/SDo2m2MbrZK/CRjZUlAuElznSw99wSULcNKomyXoLHG0s1mTNAfN/B8Mn5BcU8o292fPDHP+Q7v1ZhhKAsM6q8INeaN999l9/53f+En/7oBygJaZqQZxlVGeuKNMvQStF1HXVd471HCTMa3wkEgizLEUKRJJqsqCjKKZPpjGoyJ0lL8nxCWU0pJ1NEmiN0irWefnBYC007fFWnMPALKLz/JMOj/eMuwM4GzpdbFnlOJiA4izdDjMlKNUoqhIoiei/iQsgGD3ZASkmWZmQyQ6WKh289irnexhAULOt11IVuASGYTCuSJKX1A+16IE0TZrMpaRoDBKzpccYcHMWbpsW5qEnUKon5b25AKnWgPFhrWa2uOTk6YmhbtJAoBJ0x9H2kBnqibnvY9iQ6pe8HzBDzsrWCpEgpypRgHJOqZLNeU+QFKk1ASparFRC1D2mWstnVOKDpOvJyQtMNuABVVdK1HVIlGOtxPuB8YDqpRhp/OOhl3cF1XOCGgTLTzKYlxjqapqftLEqksSHRDQRvSXRCkibkZUFZlkzKCYlKCMEjXSBYiwmO5eqG1WpJT6BtG0zfs93uGJxnsjihmi/wUoOMhXfsPu5viOFQfN8eX7Fa4uvx52T8aWNivh5f/bizSHGDBy+YTib8lb/6l/mDP/gjfvqTj9DCorIYF+l8VN2VWYKxgc7F+5PvHKEL2OeeLrfYK8n15Y5JllKft9Q7Q1VIkkzRSkEwPRcfXZCXCbkM6BDIZYwvFN5zOsmYTiXWeUQ34DdQpor1buDp6pzFZEaeGXbbBkTAB0fbaswgubnW3Htjxma1prQeoSLDp7E9Lggurzq6YSDXkjvTwF/9re8yr0753/wf/g7P2oYsM3zy+AVvf2vC9pOnbDbPubjs0Kki+fA5qS7IspjbvbzumC0KlqHnk8cNbee4/8jS3jiGl0vaOrDdOXTSkxcp3/mV74CBYDreuJPx4tkNbz/KSNKMzE9ZnCY4YH3d8fzJhvnpCU8+3nH37C59f8N2ZXnyQcf8+IgkL9k0itDXNLuWIDoePJqyW+X0247z65pf+863ubi+xMuWs7MS+/Kau3ePOJpXCNkzmQu6LUgzYfuiYdNsydKSy+uaEByzWcL6qqdRLarQuLqlKlM2myVd3+BDwAeBsZYsSTk9Oeby5oYgArvuitliyrv37/PT9z9gud2h0hwheo6ONKdncx4/ec4wSIZe8pMf1ryYtSyOIqtrdWNpc8cHHwfWc7h5+Zjzpwm2H/jWdyxvPKy+1Gvgf/W//h+yWCxixOgwcHR0xMXFBZvNhjwvqHcDxsS1ibWWvu85Pj4myzK22y3CBybllExlmMbwzsN3sb2nXu6YlBOMclzcXLJerw+MtSRJ2G63QCAkARNiLNFms4kGdVojhKCqKpRS9H2P956iKJhMJoQQGIYBreMS0VobF71pitaapmlIkoSyLLFdw7yasJjd42hxn7KY0zRbHj99n6vrJ/SuReYxFcZaSzfGuO7/SBkjSYdhIE1TyrKk6zq2222UC0qN9QnbXVxkJ0kECIqiYLvdRsCiFExnE4wxXF9fI4Q4xJzqJCErctwoqbM25jBnWUbbtrRtx4snL1FCc3Z2xoMHD2jb9rAmevuttwlGsF5ucM6R5zlCCOq65qOPPoo023mGk5AmGVrnnL+4YrNuIEisdSgV0weGYcAYg9aaLMtwzrHb7bC2R2lBCIE0TZnP55yenrLb7XDOceeNexjv+L1/9a+ZFhVHkymJkJwujsmShK5v2ezW+GDJcs3iaEqSSrQOHJ8s6HpLbzSr1Zo8z2mahrZt6fs++hVZkD4nS+MxVkpRVdXhuZdXl8hUYn0EZW5ubnjy+y+/1Ovk5xlKvr7W29v97OOlgANK7cbH5IiRv16rH6rrT2/tM2bQnoDj1vYC5Ini7qLClSDI2C7XVJOc+aykKhRpltJ3NTpRFGVBVabgLU8fP2UwlqKc0HQtzhjqQbBsLFaUeBHQWhCcxRmLsYJdPdCaQFrMWNw54XJ5RbMztO0Kpc/YXV1xVFXMZxWpVuRVxundE3ZNS6PAmh4zdEgpOD4+RUjBxeUlu901WivKsmJSlXhrqLc1D+7fBdey3nTcv3vGH30c7yMigJKCPMvACaxpKYtortyZHX3XM51NyfMcZwyKgO3b0Qk9o7eSm13DJ0+e8Y0332C3uuYHf/A9fus//k+YHE+5ennF0MeItF//zd/mm9/4LmmaI6QmyzMmVUmWZkilDrHIm9WWtmsRWKQMscZSkjTRBO/GaEJFonPysiTPS5K0IMkKGNcdJlhsbxBSxXVCIsncVwvu/dIh3vsRhGAQit1guVlvWEhHoaKRAiHqugk+OtYpiVfycBMXY263xaOzBE2Kx3P3wf3RHt8wWMf16pqqrCiKnE1TU5YBlcSDXBQZSaKBMHZcNE1dR2TbwzA4dvUWpeLPfdeRFRHdNmYA4cnzjOAUbd2SJRn1tsMYiwgxU3xwcbLFOZyD7a0btZQCKRKqsmQyScFGSnkiJSJEBNl4R5olWAHBe3a7HUJGmkXXW4xv2NYtaZrRth3ee+wwkCQJSikm0wl919O1LUqpgyFdMlrpO2cps4TF8Zzj4xO6oefyasXl5Zquc/R9h/MeNd6pkixjMpkwnc2YZBXKCZwzaCmxw8DN6orNdk1elmhVkKQVTb3DeEGuNdPjs0P+eBAqNiHZM4LCQdf/2Rvm1+Pr8fX4ZRzf1o4kzdBBY4eBy3/6L1g0W35nppE4FtMSrRRt18FIITRBYHzMqPDGgrMMdSANFpdreqOZ5hLjPEMaI16MafAKkkqRB4cQkse9QktYnKRkPlAWEp0qVCIwhaT1nq4VICtmMtDLwKpeMThJ3TqOz1J2zUBWRbvbdtMhQorpBbOTBOs7JhNFP0gW84J6bamvO2QGg4SnLzb8wx++z3LZ0wcHySUPHz5CKcvV1YoQFEnisN7jnULLgqHf8J/9T76J84ann/Qsqin/7PKn7IaW1mQ8eniX85eXiMSSlXH6Xq97PvrpljtnJzz7eEOaeLwTVIWmmqTgDRcvVgw2cPHC8s679/nw/JJnT2r+2lt/gfuPTvmD3/uE/+x//Nf41rd+nX/8T/7vONch3YyPP1a01iGQnE4yzh6ccH3zku3mKWmpOL82PDtfc/6i4Xf/8n2cuWFS5Tx+sYZW8Uffe05ZKLZeMD/t0BLajaRIAtNZivee+cmEq8s1AcFmfQMjYpFlOcY2pInl5maNtQ7nLcb21JsWIzzT4wkuMzz+eM3qyiGCYnnzMRfXDThJmnqcK2g2HVUlUbmI81EN5889WaJxIcGYnqPpCf/0/7Xi/MWX62qeJAlt2+KcoyiKQ9KBUoosy3nz0THL5ZqnT5+yWq0oimKU3flxPtYorcjSjEk2YT6fI5yiXu5omgaRKyCaPWqtD/O41hpjBrIso8xiskJVVTRNwzAMeO8PxpRJEh3jrbXsdjsAjDFkWUZRFBRFgfeerusOxbfWOsaeCoG1DmvtoXHQdR1SyWhw6TwyU4cCW0oZjV2tZRiG1z7LnnHXNM1hf6VZzuNnl/i9vC2NDZQQHEJ4mnYHQpNmsaEwnU6x1nJ0dESSRIdo7/1oyCVQSnF6esp2u2W1Wo0RsoI8jxTeYmwQXFxcMJvNuFneoHxy+Lz7xoExhrIsyYuc6ckUr6I3j7UAAWsN3gmUik2OMB4jpeLx2mw27Hbxs6WpoppMODo6OqxhrbWH4zL0Axc31zR1Q5nlvHhxzr3Ts7GBIkfJokdpxXx+RJJIhr5FqQRnPVonbHddlFomCd7HJkDbtrGBUlXUK3M49/ZZ6k3TYK1lOp2w6+uDH9AwfLWI4BcNpT4NusDeqTp48SrfOWpRcQfa+Cvu+V4fvI8T268vv2gEwIpYeAti4d3udhwtSqapYls3nB5NyEuFUo4kDVy8fIYxnrfvvstgeqosQQpNV/d8/PEzZFrRG8+2XSNUyqbzBGlJswRnBhIZQPZI56imJcvGMQjH06fPefjum3zy5AnlJOGN977L9579U1Y3S775tibJIREShWU2KejagjSbY4yl7RqSLhubKxXXm2u0dKxWO9pmR55qJmUJeIo8A6G42q3RStK7uH/UKI8NxpDphL43pFmGsQGpM5IkRyvom4ZgPVpIBhdwMmAReKm4Xq44KhPeffQuRTXj8uI5tZtRpglSJXglOTu5SzjTSF0SSMnKnDQRsenmY8GsXcCpGnY1iZSkqYqApQwkWiCFwwxRSisCMYZaa8QIlIbgR82+Q4zJWDKAdwYl/pwX3vsT+k8f7SNAakxw1P2AxhIiiR8nI6qsBBFpVSpOUiOdMaruowlbGCcgoTV127A4OiJLEzJiYb7bbpFOI4WgWd0gpKQsi0NeOMHRdV0U+QuBHO3n86JAbHd469gbKlszUFYpi/kxRZpHI7Wuw/QDZoiLQWtspGgryeAcvTFY5yjSDOklbd8DgsEahALjBgYjKXQ0ZlNao4QkeE/AU+Y5rQctE7abLWlZoaRis2tJihjdlSR6nMjd4VjErnWLbVvKPHZerbNopTEmasEHM5BVJalS5JlCioRJmXMj17Ez5eNEFkIgy/PYLZ9OmU6nFEmO6BzGgvMGFyxd36FTTTkpEckcYxwhCOq+RyYJWVmAHjX8jDfP0cRQHJwmx3Pj1vn17xIb9fX4enw9vrrxYA3OtGihUEJgb3acaEGWyBjTYnZIGb09YtEdYtPUR6pgpqK8xhEQFgQOJwRi24+LKYnrASLlzbeGVAR0GLijJC/XA0cyZYIj7wyJMPSbAAnsrOD4UcVPP1oh20A5gTd/fcbzTvKTH69ot9BsJdWRp5zmzOaGJO/49q+VtH1P02ryqeM//Y1fYbl8zvljyfLSMl0cc7Vd8V/+1/+Gp8936KkgzwzbTUu9kXzyyXOKWWwNDx0UhSYrJzx68A7+Xk9bd1xerPnxH19SVpbpmeDoFO49Srm8PmdXg5SGprMo3SGzwIurp/z4/Z+wmOa8+ehtvBMkmeXq5jk3NzuGQdC0CW+9e8a77/0m//z3/ku8D6yXnvNPBi7PDX/w+9+jG7Z8+MGH5Jli1zdcX0Xp1nd/9U20SvnJ+SfcuVshBfz0x9f0vWZwljffTZD5C97/wPDssUG4HCkcXkpMENx7oACDTiVCVRjT8eDNOWU1Y9fWSAKrmxatMqbVjK1qGMzAYKKzbl5mdNsGqSRtZ/jhB085vj9nsvA8ebaiKCXlRPL8Y0vXOoQEpTxFljPJU7puYJJNefLhikml8cbxcJ5x9bxFh4zZRKCE4+nHa07ufLkSle12y507d8iyjN1ud0hb8GOzfOgDfR8L5NPT00Nh6lxESifVBGc8y+USYSVVNuHBnYfkec60mmKVp7Udu93uUBQVRUGapvRDz3q9RiSxsLSxKjyw24ZhIM/zAwq+L5733jkhhEOxuC+O949H3xjNYAyauF4YhoGuXXN9fUGSSY6OjjChoCdud7+tfXPg9vy9R+uNMa81CJyHs7Oj2MBTGh88xli6ruXoeEbbtgc0WcpY7CdJQpZlYxEr2azX6BFNz/OcsiwPzYMsy/no/U8ospLZbIYQgqOjI4QQZFlGCIG6rlFCHzxy9vtuOp2SZSmBMHrk5GiVkuiCIr/i5fklfW/G72EOKHrbtocmxunpKZNJgQ/24K8TQmC1WkW/HK25urpiOp/y5ltvIjzocoI1hq7rKIsi5tuvPM7HWKS+a6M/glDUdUeWl7Rdd2AVSCk5OzsDYvqHlgm7okfrJKYBjak3xpgI2IxMSCklRVEwm82+1Gvk5x3y02u9vcZbjEZqPpqqIUAEMVqr7VmSYfx9fEJkk0eNdxgf/twh9kZtI3U9QNd1TMucJjSIsSE0nVecnB7RmyEychOFcYaiGM9D5+jaloDCGMl629E6z65ZobKcvnNopZhOMoTtUZ1jUUmO797hR8/WbLoGYzybywuS4Gnajv/HP/hHHCWaKkt5681H/PGP/wjrCo7PzkhSCcGhBMxPjsfjGtjuapyTFGWFCI5613DvbpTebrctL56f44NF6py66REhoAJoGRteHFJkNFLFmGepNGleHphrQkissxjn8WLUTSNorUFmnuvlillxwRtpwdDVZCZHJoq23VGkJWVVYY1ms3M4wApB03mCbzGDYxiio3zb9fS9QQYoi4wsEwgRE0REsFjTo4Ul1YE01SRCEegpspKAoOn6KIWVmr7rcQiGwdJ/xY2lX1rEW0JEOnzgpnfoNEW5AIMjzR360MgSJGJv3GVRVqFTGSnfCLQQ0fEcQd/3vDg/ZzabUeQ5R4sFk6o60Hl8CCRSUeYZCoUzloCNXdZM4Zyj3bUMdqAfBiazCqEUTdOge0Vbb3G1BZXgvIiO4SqFTLHa1vGGOwxIFzsvbTfQD3FyHQZLohSOgEeCTmkGT1JbrOkg84RgkUIwYCgnBUWaYIeOVOvxYu7wbY8xDik1iUrw2kWti7NoleCExxmHCXa8sVqa4CnKAryIUV/eI6RA6+QQOr++WrHa7nhxseRm02B9vJlJJEpIUqnJVIqWUX8fNIRcgpGEPuAHR55mBAGJztBFgVQ9UgUEliyPLuxeCOTeoRION0PxNcr99fh6/LkbU+OiEaNSKBHwSiIFSO+RPpBIRgfSaI7jx9WNAxCgQtRwk4j4jKBGh4eR8xfCaEYbkMEj7Oh8GhyZAJlJNrVDTCWZg9QHiia+V6VALzseJYr1qufGKZ78sGaZ57geVKZIEstsmo8on+TZ0y3JuxqVKqQfaFtD36xhMCg5kFWOJjRcd5ZKCvJpiswc02PN7A4s24+QKmW3dHgLVaXYLi15rklVxaNvvsu/+tf/H6RMePAooetqoCNPS964+y1++ze+xfd+/5/x9NkTXNiR5QJnSn7yox2nZwnLTc8nz56zW1nefOuEJC2pa9juLJN5yh/84A/5yU/Pmc0kp/fmrNfPqTcDp3cVrb3gD394xfl5Q14G2tajdIkJNReXK16+2PHgzZSXVysmWYYOEEKGFR133ihY3EvpDHRrTzLxuE5w/sKzaQLupef4FHTqQfUMzcD5s5pNu6TtHW5rKbIUM/EIPME7gofJZMakzGjaBmMN1kPbCa6vDR98/Iyjk4LFWUrtBvoahi6Q6gmpNgzestkYnO2ockm/a5E+sFt1CC24ehYwvePoaOD4RGC6LadvBN5692cnsfxph9aatm2jFvGWNvH6+prNZgtBk6Y5WZbFbN2x6HbOIYTg+vo6Uv5NoNAlfT+QF0WkUmcpZZmy7XaEEA4I5Z79F3zAWEOiI8stJpuEA7V8j6pKKWnbFiklaZoeCvQsy16LZ92jpU3ToLUmhIDpWlKhIiPBWkCOhbyLmklvScvIbtgXu8MwHJD//edI0/Q1RHlfkAsRSDJNkiqMiY9PqgohU2bTKXXTUNdbgAOim6ZpLMiJkbbT6TQ29Kxlu92itaYsyxHddizmcybV7EA/DyFQliXL5ZKhH1AhYVJOmUwmOOeo6/rACAgEtFToZExQaGs2m4abmxuurq6AyF4wtj98Jyklx8fHBwmC94ZkNLfdf8abmxvm8zlZlrFcLmmG6H1w5+SU9dUN/WC4ubkhvXOXSTXF2XO6bqDedfRDwxsPzpAqsNtucV7F4n9kFezZFPP5PL7feoexgsvLK7TWzOdzylFTa4xhuVyiUkVRFbHhM51+qdfIzzs+U3jvncpDpIN72KcTgxLIIPAh+ofsC3BBNOXaUyp92M8oX7TGfMVj9wg6Gangm3rD2aTgdDbBC8Xk+JTGGIQuqOaRLbvcbOj6CbNCUyZQFIqyTLnaDmzaDjdY8BKFRKtAriVDW3O2mPDoeMbF8xveun/KxXXD0EruVznbtsF3hjxLKTXk1vCr7z3kG2895Pvf/0NcMHz80RO+8a23KFNNpjXTokQuBB9/8pTdtuFi07GYFcyrhKN5RVNv2WxbjJO8++4Dnr54wstlTW01mZQoD044pE7xzjD0PUkSSfxllqItJInDDANeJzg8LlEjQ9gzDDUmdPgg2Q2a801Nnr9kPs948NYpxvS8ON+w3qy4c+cO8/qaB8cP0N6zMR1t2yGcZDadgwx01tI5z6ZtsN6RSRiaFtELEA4tBZnUkULuayZ5jDzLE0dV5pAFlC7JVIrFQYjN/7bpMNZj7J9zxPv2+HmQycNzxgWYx9OZwKAVQSlcCDjvSZSKLntKIYXAeocUMrp962R0Ngw450lU7EZ6CdYYrq+uIiV6OiXLMqbTKdvt9jAB7ScUhCBLc9p2x67uSJIUhEAnCdvxxhuIF/1iMWNe5dSbdSzYdXJ4bDAGYy3GWJTSICP9yBiL94GiyBDBIUc60l5LUuUFARG12dYghGc6mdA2O4oiQwlBIhVeSzZ1H+lBQpGlKdb15GmCINA120NnO/hw6Lh3XUeiNc47ttuaECBLU5wPpFLHiDIzcHN9zdnZGe++8w7vffM7vP/xU37ywSes1ztkCJRpOlJ84g0qTqQGJSRSCpSU5JOKvMi4vLmiaRqmaYXwjq5rSNKUspoi0xQv9dhQCZ86L+CXjWL+f3vpYnQR0T2REHUwezrSfnzap+NnjdsLjj/V+AJqzG0t3Ss6lR//HW4Zjrz2qtd+2hc2Itx6NIAeKXNCiMP3janMt18f30ccXi8P248kBosQAYvCCRWj48IYHSEciqjrd9aNjBMIxBQDJxROxKg5PGMOZzx3pIjoaMDhBHgUMkgSJ+NkLMCqeLWpYEl8wArBINVn9sftffdq6v7sfvr02GeL384cfX3IcU6/zeAY32tkeOxbUF5E+c1rx2X8TGGkTf28J9m+/+95db/da96SJOF/+ujLmxbKJBYRUtjIUtIxm/MQAyKITKaxU67HryBDNMvc72IlAiJ4vI+LJiE9YVxleRGL77jLBMi417QzHGuNcXCx88hSMsehXSD1EIJEWkuG4V6hWG0dL55bLpRFAm++OcEEzcvLDdYHtJJIlfDyRWC7bTl94JEKHn/4FN8KHjw4ZpluaG08v1bbqHObZhl9L9juJDcXOx49KMBKlCt49vEKKwODu2ZanjMpNV1rePb0gnv3p9y7lxDcnDund1lddYThHOO2/Op/WLDbeKwPfPR+wxtvz5GqxtvAh48bEg1Xv3/BvTem7LYqXjN1x+xoRm9WdJuWuvacP/GsLi2JVjx61/LuW0cs8oRmG5DeYXzNgzeOuDjfcXasuXc8Y32VcPF8R1Mrzs/XpFPB3TZneRF4/lHLJIPjRckHP+jYXEoGAvNJSqY9gxUs5ifIWc3N5ZqtFUiZcfHYkynDm7OA6x2JViRpQlVN0Vrg6hqpNF1Xs94MVNWEtJpydbGkHRyLk4T5LOM6MayvdsxKReciRTQrEobO0SUt0xlkZcG2sXSNpMgyygmUc4+bBpxIWK6/tNMf4GBWOplMOD4+Ro3N+o8//hgpFWUxI89L6rqO57pSB+TXOUfXtAQfmE1nCBsL46EfuHfvHpvVhkRkdF1H3/copTg+PgZgGIbDPcKO/jZ7tNeMaKlzjuvr6wOlPIQQzZGICPQe2c7z/KAFb5rmQD8PIeBGhDTLUrI8R6sCqWC5ekHdNBjf0tXrg4HrHlFu2/bQIFiv14fCUGt9eL9hGAgEyjLFWIv3A0I4+qEhhMB2F6niTdNQluUB0RYiAi0AeZpTdy2pjtGpdV2zWq0O6H6RFwckfrVaxXXdiMTvtdhDYw/7cM9E2CPT3ju6ziCDwRjPerWlbSLl3jqHkrHZECfAiHhPp1Pm8zlJkhw0xUqqsQiP1P/ZbIb3Pur8hWC1WnM0n6O1pqoqfG+o65oQPPP5giQp6DrDzc2Gu/dOmUyO0VpQFhN6M1CWjqOjY9I05fLykiRJDueAc46PPnzMarXm7OyMvu954403KMYGT57n0Y9jpOrvtf9/1uMzAMxehrh3IJfslzUHtFuKcY49zOHi1Tx++7WIA3X90+NV2R7fwFoHznI0PSIkmmpxzKYdUF5Tj0yNO3fOOH92jc0DroXizoKT42Pa3tP5ntUW6i5Q5CWDjair95Y8zVgsjhB2YH4y56OnTwnSsmk7pospi8Wc0hjwnmB6eq84feMe//D//c+oigSlwTdrXLPk3tGE9bZBesN6eY2SsdFgB0vbdExzRd93LOYzXpxfMdjY6Ns1PS8v19xsHFJAphWdN6hE0nUtSRJZK7PZBKXVeM8ySKlRWtM3bWymK4k1hhAEWgq8A+cDvXG0Xcf5yxc8fPttJqdzNtuaAOzaml2zo8629L1FqgytRv+DBIq8xHtDu9kymAaVJNHgDTDO0HQNSgQmWYH0AWuiv0WRevrE0fcDu9owm5+RZCUCyIscnaQMw5Ku71BSfTUn8Dh+aRHvV0Pggsd6T0iih3zwDoKkyHKyNImagxAISiC1RKcpOk2QgOmGV4YaZU6W56OhRuyGdl1LluVjN1qOdAxL33cYo0hShZSQ6JTNZst21+JcNCezLmoDlIpawqTIwVlCiJNWGLvAhDjxheBH+lIOY4GfpLELbXpHGKnxQz+AELGTpATWONq+RxAoynyM6PKoIEllQj8YtFRIIcdudouUAnB4Z6Ibukjx3lFVJcMwjJ1uTZpouq5lGDU9fhjzvqWgNwbnLGmSIoSkrhvOL57wydMX7DY1XW+ZjKYlzjuCixowvZOkWUKRF1GTrhWJjhnf1gzU2y7qkoKPF3FekpUVqIQgE4JzyJ/TufwXSTNvW0PXNsSbe7yJy/Fmvi9ExYHh9MVcpv1vxfiCPcX+879Z3M5hS/uJQnzxvpDydsG3n/xv7d/XXiZee+arX4XDhLZ/QO6Lengt4u1Vifqq0H+1mX3ZFx8XADIweEuQmiBi00viEcEhfIyJEEISgjgYpXgRcHIgCI8MAe0D0gtCEBgpGaTESRDC4YmRF9pB4iXaJXg0Rgq89Agc2juCCDjxeWF1t77L7YbK5xj9wb6IDWNBfGuPfFHhzX7S3xfBsbkgxFh0A2H8d7j9dvuPtG+i/LxjX7Dz6pzbHzPnIoXsyxo6OFQA6aNHQ0wqGNsvo/ROAsG/QjNCeHWuHRZah9gXjxztauWt7xBGmVEYO19BgPCCygfuSXhpJXVrKUpJ0ILExm2b3qJDIBGaTGo8PToN3L8zIc8Snn64JKiYKjFbaPJ8QTVJEZctWkl06jg6ywidZrnbYbylrVtsExsESSnYrHtEI9nuBrqdJBEd9+8c8eLJkiAzjO/Ji8DzF+/z4ukTNsuerguc+5b0ektfS/7FP3yfstS8/Y1zjh40JFnA+p7HH0kmswlZafB4Li4D9c7z8C2B6xRN53j5siUrEtymx9GSFAEzKC5feEJwTGaKo6OcNGnYrsC0Dh3idz46m1DkGUdHPc70tOuOF48brq5hclri8p5t7/j4/YGHu5zCT1gcD9h24PjkiOefXIKRzLKcQiR8/ME1jz96ybvvpUzKlMsXHdb1+MFjvaDfDXjr6LqWPM8ZBkeaZPSDpWlbkjSlrlueP7thejJFScXQKnZrh+8CQ6MRwTMYS99DOvFMFwJcIIiUvIp0yxByLi63FJOB5LigQJBmUMzhwx/XX9r5DxwKtb1h2Z52Hgu9Nbttd0CY9zRuYwx9H5vpiRyZcN6jkOPjA5NiwnazPWik97pwYwxKKYoiopPbPsHyyhxtj6puNptDYX37s+7R8D36vS82tdaxmLT2YLBmjMG0NclMMplMKIoCMwTCXrO916nr5KAJP1Dsx8bA7ebfntq+95kJIWDswHa3RkiBkII0UzTNq2MU11uvkHyl1IEmDSD2lOlxrbbfLxA179Y6sjzn5cuXrFYrTk5ODt+7bVvunN0hEQ4R5GE/CyFo2xZrLfP5jNo20RTQi5GOHynaapx7YxM2HF67R833yLtSCh+inGDfhNgDQUmSUE0m+AaapmWz2TLJ8kj3LiuKskQIxfHRGZPJnK5vuL5akaYJJycL0qwgCEluI4X26uqKDz/8kLIsqaqKo6Mj8qQgEPff9fU1x8fHr5nf7Y+bdfbACPhFjC9a4+w9gOTYyJaM82gYM3BCOHDQD9puRpp5iKyIOI2Gw/xz2PZ43GR0lIpzs4tsrarIaYXnxeVLJvOTqDPuLeV0wuZmyyQtuL64Qp9MqIqCo6MZDqiHl5RZwJssavOBEBxaKhIteP7iJQKPVCkhKdiYNcUs4Xq7QUiNkgKsBxE4Wkz5p9//IzIxsEgD948qZtOCjJa37j3kKtM8vzwH70gSxYM37tP2LylyzWJxRJlLBmtwfmA2WyCVpDcOhMK5Pl6TIqBkBEridZRSlln0s0JHHwPAmIBWOtY9CIyJjSeHJ4x0tjKf4F1P2w/UTcP777+Pfn6JUCmDd+g0IckyrpY3XLy4RpdT8tmMTOc03YpEpTjXkqdQFRI3suKMtWOsccB5R9fVaBHTpbZ9T608s0Jhs4Dfbui6wMnJGUlR4Jwly3JmsynWRcnGVzl+eQtvMaIXIyLiRIjxLSpSAkQA4f3obH4LKZQSqeKNItWaaTlBCUGW5wzeIqSMDt9de6AnTadTtFbETtaA9yIWic4SBktR5DRNhxkc1gW22y1hvJGWeUZVFpRFgTcR/TSDidQIqUd0Rh4MM7SORilN2yKkODiHKq3Zbne4ILDOoaVk6Dv0JKOYlNihQSlJ37WjVqymzAu6bqDretK8hFDT9x0hQFFVdF096roDWZYeJqS+7yjLaPKy2WwICKRUh8+IuKW5dJ66bbm8vok0sSTlrUcPsf4ZzbCM+X1ZinOevu9o64Y0USgl8c5ifABrSYRgMD1D37PbrMA7UBFdTMsSkaT4UT+/jwTYjz/pJv+LKr7FWOwK9oj8SHNyYyG8R3b/BMj79qffP/eLv9Orsjb+tC/qvqBMP9D1XhV1n4++jtt7bV+/KhgPzKzAAdMWt770a53o1yr2Q1l563fitcc9cXJHRR8CHyJVSGtJolO6rsd5jxAKH/T4co+MJThSeBLhiEs1iSc2jryMsgVkQMixyrPRGyFWeoogI4V5X4rKL+yPiMP+frWvv3if7/fz4ft/bpE+dlf2IrVb+0jeerq49Vbh1YbHTv6rxcPPPW694PZ5I6SMHhZf4ogLt4Dw8X7uxwXSXmeHfHXOCSFGrV58fiCi4nLcPU7E4+RDzASXggMzRo2Lpv1+8m6/Tz2TIJHaUgfwxtOlRD24CBAUOniyYFjkKX4buP/WhO/+6gk/eX9JXRtQgnKhaVvPs+c33H2kKGee4ODoaMrsJOfjD7bcXA0cn5ZYaUhyi7MBKTU6y7HeUq8MAbi4sJycnKJKz9Bf8N47M+6/WfDD711ga0NVFSihOX9uuXevQjPH1C+5Xvak2Yp6CMzmZ1RloG2uqLcN3703YTA59+/B7Js5dbvE4Ll+uaTeOYz3TBaO5aXndGwQL697js9Svv0bGbNpTt+WfPz+FV7Cdj2gMkF7Y7EauqGlTFNerlp6r+i9Z/l0xW/89kOePb3CDY73f7jizpnm3v05l9c7NruBO6czlucrXn6y4uUzSTtIOmd4jOXkDFIhwUNVJizSijxJqXc7rLMoqUiynLTIseOxDd5hrafeQDVJ0crRdw3Ly8BF3eD7wN03jhBqx5vznF3bMT1OUDpwed5ibIJOokbRSdj1gReXPR2OSZ7wn/7lX0fw+Eu9BvYu4xDNqq6uriiKgocPHzKZTPnwgyf0fR812X3Pbrc7oJqz2YwqL9htajKVkatoftUPA3eOSpSMxoT7grXve9q2Pbh2p1mKlYbBRWq3EHHNkWUZjx49OuiX9+yc24Zrezr4/trMsuy1xsBe86uTBD0W1lJKvLcHFNU5R1CRtbSnlO+BkD2Ffe8Uvh8hhFjQj38GO9C7BpWoQzEasLfuMRF93u2ag1lZkiTRrTuE2ABLEuz4vfZ0/7Is2W63bLc7jmenBznA3jgsz3Pquo6Iry5o6/7QgNjtdlxeXh4YAFYZWjsghSJJ8hHcMCitcaPxXIyE1Yd9ujeQs9aS5wk+RMf36+vrA9U9hMBsNmNazikmJRfnL3n+/Dmn8wWZVKggDv5GZTEjTQe6rmW5WqOUoKpKlCqwxuO8p21bbm5uePHiEqXCgf1w7859ptMZ11c3rFYrptMpamSU7teN3dDdbvn/Qsan1zm3GzfiU3OuFCLqj0OkiEcGmWeEydkvaISI/341h4bXpmoRYlNcHlCUgFCCcjJBJJr1eonOS3SaMvSe+eyI9c2S7XKNDIJ7J3MePjzjeDGjLDPeSE54/PQpibSx4PYBJQWLecVmvaYqFxgjqduOfrAYs6Oalxjdkk4z+s4hg0DhEVIRFAzeUBWC40XCew+P+O633yKfFAxORLfyJqXtG/JU8+z8nEJHCvryZkmTwWRS8va7b+FdoBsGAoq67el7ixKC4C1aR4YgBJIksnbyPKProjeAlJIQDNvtjhBAJwl+ZJYNQ491A0Ip6qZmUhUEJJvtjm+WJcd377Dc1KyWO1SSoIuCKs94eX7Jy8vnnEiLnMxjEonKEN6zmE0oqpTVdkuza6L8w3mUTsjTlDyReNMTHHQ20HQGawODCWRKIOoWrVckpifLC4oyNqLzPGO7a77K0/jPpvB+nc742d/f/vnwB4ESCisA6fAw0swD2gvcYOjp4g0iTWnaFjm61oWxSxc7dVGD3LYt27ZGJwlSQgix02utpa53TCaT0WU0i6H13mHMgPeB3S52dne7ht75aEUfPFqCFqCVJDhzuJHuHSz3neEyLw6GGj74WEg4jzX2QCWSStEbhwsCrTT4aIoQrGW6mDJoT55l2MFQlRU31zestzu0TgCDGQzBebI0wXqPVtH5Twp5MH/TWtO0TWxKZCnBB4qypGmaEYmSWOcIwkUzDe8x1kFIqcaJPdUaFzx5pkFGg7hIo4/aKzsU0XDOWvquRSOQ3tM6S93UOGvAO3a7DTLLyasZ1WwBKpp6iOAPtJ/9OfN5588vg6GaCK9Qun25IhFRKrB/Dj/fZ/15O8ifd838Sc9/rbjaTx4/z3sdqpjXyeP7ZgPE7/9pjPizmLG49djrP3vhUdKjhCMEg/OOTEGRpPyT//YfI6TkP/7LfxWnBGZsdsmgRu2WxgmFlQErHUqFsQAT0bjLeRIbcDLBq30efHQPDfRIGRcs2isSJ/FSYMSnUGVeHZtP//+L9uPtffz68TlgzPtvf/g54MaCWMSFgHi1LUF4tU6IH+BT0oE/5fUQ9gX8q+tLCnFAn7/MsUenIZ4XcTG0r6ojRVyO3/vwWYjN1rCnZo67UwY3ohcg8BGp3zckiOiGAFQQEKLoISDwwpOJECMpgXaQ9ApcppDSU7m4iJkIKJQgyRTToyN+5S8s2DQ/xTsokoTdquXhexMmpxasZ3vlWS4t1y9r6p3FW83VZYNOomTCusCwCqRZT15ompVCJIFBW37vez/g7LQiCQnnT1uaztC0gebasrqouffmGUfHgcuLDU/ef4a1gjt3SqpK8PTDDuUHkqOeaio5OSo5f9zx5pvHbFdLdkPL5QrMzmE7idKeb//6GXW7oZgIVGF59Nacd965z9PH5+zWWz552bJZW7xXHB8nTI9SLq57msFhXKAsCjY3NdeNYJbmnLyRohtPnhj+4q/d4+mza06+9Q6ffPhT3v9pzdXLge+8d5dHvzbl8Q8Sdm3g6WWNCQN5JRFKsdkGkjJKwXatxV+vuKoKBhubM0p4skRhA+isIE0TetORplFmdnWxQqexGU6QJFIRssB6u6PKBfmJQU9Tzs9bzt5IOTvSKGd595tv0LaKf3T1hKwSzOYJtoeju/d59OAdvv8v3v9SrwE3osd7RNZYy7Nnz8jyjM16S/ASMxjyNKcfehKdkGc5eZqTpTnWWHbbLW1oqFLDyfQEZwayNEHJmF/P2Lzcm36NV8ToAm+wwRIIB6fwhw8fkmUZL168oK5rhIxNLecdUkXwwjrHdrc9NAGkUmghXhXOQDWpmOQZZZLR9wOJ6ghBRVbe+McFh3Hj9Tjes/bIewhgjRvRSSAInPfsdvUB9XfeoAuBd47BjazBkbIe7zGKMi8jC69to2TPeYYhUs2VUhwvFux20QVeCcnx0RG/8ivf4Qc//CFFUQCe6azi+GTBzc2Srms4On77wAhIk5RBjgZxIhqMnZyc0IyRXNtmR2d6lEqYz1KMsSPTQeBsPAf2OjSpFEmaYtuWXR2bTHmWIGQ4mMPtQZC967jYbEjyjLwoaMyOruu5Xq3xxlFkOXfvPMJYw3a3o+8HvIeu7XHG03cD211NYxuMcWidUhTZuPZtubleUhVTjo+OuLy4PGjg959Byoj0msGQZilFURzkin/W4/Y895k1kwgHZlTsT+95hlHqdmhyH5rn8fdBhBFIewWgvL5dkOHV870QFFXB9PSMJ5fXkKdIJO1gqeueqpigpaRIU/pmx3RaMsk1iYJESYwNvHF2gu0tN+lAU7coKTk5rljngcEMeBGd5M2uZVoW6DJnaqY8e35OVmhMN1Bk0c8qy1KmZcW9WcrDhebdB8fcPZ0i04R1PSAxZIlAYlnMFyxXOzQBYzp605Ekk0jzDoHjxSKeO71jve7xIUZ0STxSCbQMzGYTdCIJQY0Nu9iYcC4QPFjnyPMS60xkJx+4azEBqTOGzdYzT6dkZcF6s2ZydEqiFe9+410miwUiSVjMjjlZnvBiecH19TkSz9HsCKV1ZDHanllVISkJbqAzEteNa0QlmExKhNd0xiLTBG8tOE8fXKxjhOXi+hJ3DfP5gsVR9KfojR+bMV/d+MoL788ibp+DtIz/3ndk5Yi8KKEQSiKEBSUwwWGMj7TCfiAXKmprx21Y7xisQWpFTnboLNZ1TT8MiERhrIUwRmGNFDAhuNXlkwfKjbWWtu0Ok5l1FoskSdPoKi4ijcUMPXYImKFHiEizzouSbV2TJCnOx45uzGv0I3onxyI93ty6LmbBOu/RSYJzFilFLF7lNNKmpGA2mZCkOVJrdn1HIRUuQN/Ebm0qJUIJvB9fPwwMg2WxWBCCxzk7ul1CN3QY4xBSIRWYsfu8p8FLqUk1eByr1ZqyyDk+SZEi5n9Ppi27bRMpHtYeYjn2dYMgLqqHoafd7Wi7hr5r4+fwUWtb5iUoPWZ2ezSeuPyXrxXdt8cvS2635FXhvTfv2BcO+xrrtfP8Z2zrM9qlL/iK4tZf4rWnfgE3Zn8shHitW/3pEvCw/QOKfetD3P4stx5WYn9DfbXVuBu++JuGw9/xOV4IQhiPNVE3XhUZP/yD3+d/91/8F6R5zt37D3jv29+NzaixAItb8MgAyguCkHhiISbEqCMOiiBSgohqb0bNOON7SR+j96TXyKDwwX2qbbLfJ/tCNRaRe7D2s/dmcXsXvb4B+FxYev+9X+2czx4jOX6v114fws88n/7Ecbs5sGdB/Lts7wtGcOJAmbfEe6aQAsmYC+qBvZZ7j1gHDs2H/S7Zn/ex2bU3Ybt9f4gLLu9fvfZw+oZxGyPSXgowCFaDJYgU7yVKWjLtuT9JODeO/+Yffp/JieZv/M/+I+6d3mVSaT548q+43L1kW8PFM8Xu2rO5dAw7RzmRDNYxOVF0baBvoNsFtIR6HTg+Fbz56IjVuqY3PVVREIYAGjZXgstLw+CgKgVmJ3j+bM3QW8oqp6x6msETRMfx6YR7b8755IMl9+5KFmcJ64uWPC1wxjOZa07uPOLJxWOW25phB+0A/ffPKcvA0amm7wxZFpBJzdGxZn0hmBSaoyOF9ZrdrmPXe0QqOa6m1LuGXoCQFSIMrG7g6H7g3fdK8syzur6kKEClFwQcjz80lDNFcQQXyxd869ce8fvff8z8qCQUiuW6RnRAG5iIlKywmCGQBHj46CF5kWP6jN4ZwNO1NevVksFYvHBYWrJCUW881kh0ljAMPYmWqCSgc0lQko+eWKRwiELSrAwTLUmc4jff/SaXqxu+f+cZszuKe2/MuHnRcvn4kn/wX/1zPv5B/6VeAyrR9M6waXbcvXs3ot+jZvHk7IzleY3ve0KqyVXKtt0iVEowmrrtUXhSMhSCTCrC0GHbHV19w3yaYuSMdd2xXtVoHRfDAUegB+FRCpyXh0K4bVuapmG1WvHixQuMtyAEfR8Lau8cVVUxmUxpu5a+6xicJQwdw0hjT4uMpm642axpG8XZdHFAuM1g6dp2XDM5ggwEEXXr+7uWk5K0KsFrWmdodlHLHXxEqAUwGM/FxRKdSKa+QCpxkAN2raGsqmj25jx905EqjZWKdltjdM9kUpHnBQhB11sSkTGXEgbDmZ6jGpgXC5K0oO+WpPnAo0f3yHJP1xkQDp1IlssbklKTBU2WpNFQNwwMNlD3A91gsE5HqZ8XbLYNQsBkUkQAo3D0NotxVDIm47R2oDE9JBpSHeV4Kq5991r3vRnefn24aloynZKXUxSS2eIEnEelOTpP6WXPR08/YOh7bN+TyFOSkDKRExrX89EHH7FarwFI9YLgBnwwtLXk6qLmZBG19d/85jdjU6FpDnR4MxhsZynSglkx+4W5mv/scbvovrXa2c8Ft+fQQxN7nAql2Nftn2GQxbVOODCykjTl3ltvcFU3dGhKXdH3juvVFUNnuDQXHE0n4AaOpznvPLpDOckhGNomUrinRcmb9+8xNB9x7+iI+XTCbrtFeWiNoCoLdoNgLiZY4TDdljunp/iuItcldrDkpWZSJJzOCyrtOZ1mPLw752wxRaholLyra5qmpql3nBzNmJ0cYY2l3rZkRcnL6ysmizkvXt4wqwr6ztE0HUlSYKxHKEWiNAFHkgiUgixLGAYTddUh3jeSJAKGw2BBxlVhjEXW9P2eoRYgeJyLLuh123E2nXPx8iVtb0jKKe+dHHNydkY1myO0oihz5vOKwUYgVGvJpCrZuh3e9OR6htGKYWiwdkDriLJvNxuE68B3DNYiZEpZzhEyoWtqrIIiT0AFTNtwdX3Far2hKGN99eVDEK+PPzPE+3YBEgtrcViQSikQYkSoZXQklyI6/SUJBGHQElTwBDvgXXTdllIQvD/EWhnnEMYcXDO1VAgV3QVvbm5ozcDRyVGcoEdqufMWFeLnMaanH1q8N4A4FOVxsupiJ1Er6DqyVFNkFdMyw5uerm1GUw/FdlvT9ztcCDRNS1oU8TMSv+fgDD5EN1EfYsErlUIIjRnNLoQQ0SFUKZpdTYLA9QN6Mk5gQtBbS7PdkASFt47pZILUEplqmq6lKFLatkHrmG8XI0tip7jvO7yL3W1vXhmH7HPOvQ+gFNYHgunBDRgzEAI4BLumA0E0VgivjqkYj2+iJKYfWG3WtNsNQ9fhvMMRmw5ZNSGfLsgnM4TW8WIVATEWVUHEpsmni+9fpviwQ5E9jv29+lAk3PqYt+vY+NpPb+zTW/+i5sIta69bBfgX9yJuoaKf3tLn7Edx6x/7gt0f4Agx/hf//2lk+zBpjdXpnnL9auIbC+OwxyKJlPcxHk9JgfAOhsC//Gf/kmADCo1WCd5LBDI2OITDSwvCooJAhgQbEpxUOAEJhtxbEgJeCQYRcCM1MUZjCETQWCnxIZqzWSnGuMK9dvjT3XReTd639s9nx+uNxk/t8E8fknG/hXGfvnYGvbZ9GUYn1s970z9lH+rVu7x6n5Ft96U3tdy4GGJczITxO6rxz+EL7Ruy41+HHsS+0XNrMSSl+Oy1tEck5GcZC4fn7RdZeIQPTIPketcjqwynBE46hBKYznJyt+D4YcL7j3/KkxfPuHtvQtt1rJewfGkQjYYGkjLDhJ6+deTTeO8TwVBUOfWmI8sSEmHZ1YbVzZKilFgbMAIa09D3Bi01UqVsmwEzlzRXhm994y7rFxe8+HiDCyAsuEHgVc3dRyUWKKsc8MyPPW8+WvD+H7/k8pnlj3/yIevaUe8glYoHb0sS7ckSmM8Fpw9mlJlgtVrCsODi3PDozYz5saY3nqbXiEGR5h7ftuDAyMDqqqZtFdNJXKgrXaAXDS7xKD3h+cWOpJLcfQTrVeDD99dktuHFB3/MJDnmzvExH//+DxBSYBpPmib43uFCIFMaIR1WDATp2Gy2ZDpGcg7ekCZxLpOJwPga4wZm84Jm1HZjI6XbBEOhNPks5du/+gDlMp48e8Fut6E8yimnOiIvueNXf2NK00kev7/kV9/7Nmt5TiULzMp+/gn0bzmCILqQp2kEAKSkrKqIUBsPvqbICtIkZbvdYgfLoIaxqRu9C+TI5hABtps1J9NZNCeUYTQCknHORsQsWy1x3uK6Aa9UjPsZ87fruubyMiKbTdOQlflIII1oLEIglIomsFqT5jlFVVFVFcABiUaKkWkSDtdl1CTHgnGz2dB2K3SuGTzReG00rrXGsds1kYm4rUnTdLyWxUHr7awfM6gViUojC0KqUfdt8TYQZJSVeD+QaM1ivgCisdykippzH+CmbsEGqqCYpBWZTDDtwNAbrPCs10sIA13fgojMgKauY2pBa2ELs2JGXpVsNzvqtmG727Fcb/AEdJIg9msWTzwWYrxXaUWRpljEgT7fDz2DjY0OOcRoxTJ/lSG+2+0OjMxhGGKErJAY6+K8mKZMqwn1ZstyueFmucS4gd70OBe9eZxx4CO4MStn9K2l3nWH/TwM0Y+o6yw3NytW19c4aw8eBLcz4SHOP2VZjT4LXy0V999mfC6bL9yetF9vyN4qQcZ551YO+K05RDJ6zghBNZty9uAN1Kxi2fboqqQ1AeEkdd3TNS2zMiN4w2xScLrIKbJAVSgmswlIzc3NmlRrJkXOu4/ukmeaTCtK1XN2VNA5Qe8F5zc9w1WLFDEq6+GdY1y9pcomOOOoFgW+33B/CvcXJbkK3D+uUGlC3RleXq+QSUaa5RwfJzQGzp8/Y7fZkSU5RS65e++MXddDiLHINzdLdo3BZyVVldH1Lja7UOSZZraY4lz0h7ImZscXRYFzAe+j6VwgxDxyFw4723sHIeCsRekS76FpO+pGI/KU3XbLRCUsl0umpzuO5h2TMmGz27Be31BUU7x3NLuaTCbgA33Xsbq5oTcWpQVSQtf33Nxs2KyXzCcJ0yoZ2XEa5yHJJuzajroZGAbJrEqYTies1xuePXuKEJrZ4pg8L7+q0xT4s9J4i9jpEwikCIcCe2+WoWSkgx+MHA4FeDTCEVKSC4/yHt17tPMUWYrSkrqtUTrB2ijil6jonGcDZhiQicN5i0hgu95ws1sxm0xQYj9BaJJEoyQEP1DmGdY5zOBo655d3dEbQ1SGBjAWpSS5yqNw35gxEiN2c+OJBy74g6FG1+zQSYYfRf/OB3wYHaBHsykXor5VykjJkPjRGC1j27QUWYa3A3lbo6UkwWGI7oBBRjc/FdLRdCWNxj9C4O1AmhdIEZhPypjdbS2IaNTWDRarBVpnZHlGXbc4H9kDCoXxYG0gT3JUkhNCdCK+d7LgaBG4Xq2px3zVIOPrvDP4HvxQM3RbjDcYERebOi2pZjPS+QlJXoLWjDj5iCaqWIzdqjB+WVFvEfxBZxvjkAL4SMk5oHS3UOPXCvEvYILc/t3nvqd4/fG9Sdqf1Iz4LC3r1mdgH7cReH0z8XuoT3cRxu+zzy7d6wP3brwH3a6APXPhdsEYrRvG0jsQjUoQSOdRIWB2O5588CGlTnjr/hu8df8uwTpkiC75XobRNt4jvEIJjQ8pVgqktBSm5dTsWD/7AJfCnTffZmUkQZR4lyFFjpcqUp2VwxFlFQkSHfYmK69P4QEOhfnhN69B3vE6frWfBXsd/X4h+dpTX3vl5xTr4/N9eEWBU0KMrvFx7A39YqNDfHbDP2t86njup8jPxLX8Ow4tJd75V2se8eqj7htHhz0TXlHq97J38eqhw6Lc+89pjOzXV7fWWAdw41NNEyFAE6i8RyhBZyxGASHBd556sNxcw8unPcm0QZeK+ZnE9I6bF5ZMeu4dTQkeutqx20TzPpUGfDBYBE07UB0rvB9wXmAakEHR1B6VOa6XO9wQ0dC692Aa8lyQdYrpNOHeCbz7zpt88MkFT5/uaNeBLE1oO89HH9fMTiUXLxzb7cCde5K2u2I6vcviOwu+94c/pMgUaaKZTgIndxzffG8K3vDs5cDQWb751hnBKn7/e+dMTwKyBF1oquOE7XbJzZWlaQ2VEJzMz/jkxQasZzEPHB3nyDxw/8GU66sNpFPWu5Z+6AiDwHQCMXiWz5ckFujh481zKC5561sz2r7h5TNDMQ3MjzRX5z3WW3QG6/aG9XZJmqRIFIvTOat6w8VFLF5ra/FCkpcpk6xie3U90gIDPnh8kCAUd09LjmcnXJ0/x/aG9TYwXVja0PPPv/eHbK3B4GP0mBBsrrasrzzL9hrhv1xH2zt37nB9fX1wh764uKAa0dqu6dCJIE2jbrlpt1GW1jmcH8izHClj8kikc0ZTLueiHjhNUpLkdZbOPi7KB0cIEc1WOoIft3W7e5MxJwJ12x4Yh/vn7TXcezncXkd+2wRNKRWBjFvbVTLGnEGkWAcz0BpHmmUH9qAQr4rQPQq/d8veF5z79xnFNnjnD7/f69APKPsY7ZXnMfpvn5ee5znOB1RvsCNKN5lM0DpqwOu6xiUCM1jyLKVtevre4ZwA7+k7Q9N0yADSK9CKvusIIWrB26ZBZxk6ef2Y79kFMSVHEqQGxOEz72PV4nGKZqfGWrQxCCFGGn44xH8BSCHHot3QbgKN3hKso0hzlI77Ls1S0JqgXx0DrTVlVaETfZAj7Le59x7oux4tA8NorpbnOScnJ4djJWQ0OR6sYVPvaOov14DwTztuz6f78yRALJ6JjKhxRfNqHtgX1ex/Fofn7JMw9mU2RKBPOI9QEBKJykpO3nqXNkj6ncUpydB0qGLC1flLhHfkBCZKME0hVbHZqbREySh/UxLunMwZJpabmxtyNUHg0VKS6Slt21FKzXK14cFJyXRWUTctq+2OzdUlD+/doWs7pqcV81LjOsu80EyKlDsnM7QODN2W3bohT3M2TctbD+5ydXXD4+dL2l2HDQVaSo5PT7m6vmJ2umBe5JyfX3H//imrneWDxy/R1lEET5lIjNSoJKOue3RwFFVF0/ZIlaBThfNDpJtJ6DtDalLafiBIg1SaoP3I9g0IoocVUrKte7SQJNpwZzFFWkPX9Czmx6yvr/jRj3/AxcU5WbriZNEiBkOz3ZBlBUIkrHdbhNKUeYqeTlmGmiUWrcE6iwsJ00mBN456u6S/WeMcBG+wXUKZnaKS6AHQDgNdt8MEz8nJ6Vd6/n7lhbdKojGDlvtoqZitLVUsqKWKj6lRR6KkHB26BUIJ0CAVJAKyEMh1QmodeSpQWjIMHdIYvLW44Eh1QpXGE0uEQPAjMqYDaa4Zmo7lck2qE7SWlEXObFKhJWSJRsmAGexBuyCVxvYDQscIMGk9ZZaT6wTvHP3oYJkkmq5tcS4upqSRIGAyLWPnt63xQVGWFWa7BTeaoQwGIeLE1XctIkQjKK0lwTn6IU5My7pjVmacSol3A7OyQPSWwRmatoumVF1DnkeDFmsMwVvyVDObTlAC2maHMxYlFOno5O69RWvJbLbg4nqJcZ48K7He0/RDpJsQUCrStfCBssiwfUeRJhxXGdp7jBP01rDartEyEGyGVp4kTbBC4JMM7wMqL0lnR6hqCkofdDhxCCL0LRGfU0R8nrHG5/3+z2pIsS8bXnX2xM+Gn28Dpnus+tXrDuOLXy9vt2x5VVT8aUxP9thidKv8/HAsEcLtkugVkf1WYeMJUf89bsN5i9QjbVzJkWrEwQlWiijj2OtnfPDxiI+0S0I876+ur7m6PseFnsXRhDTPMCIuJBEghUEIi/IeGat8tPIYLIXoOPLX/OQf/V+5V8AnV+dsXnyXd37zr1HbgA0JQcqxgz0ghCV4ixISJRKwY9eb8Jl9+ul++uuGcYcp/NVOCqNsYqzR/eecF4fzQLw6Mge4N9x6j30hehsY379n+FlnzM839mjaly1tCiHqvm7LLxAg9KgpPTAfYN9vCyN6fVgwjXT0iK6N2xR85g4RQjxPtXi1Pw9RMyM1RQSBcoCMTq1FgBAsvdLIPrDbWBrn0RPNyd2KwRusddw8MzgnME0gKwV1axBaUG96ygkURYlQDYtjQVrM+fGPYlxRmklUphgGh5IBN3hsA855ZBa570IHylJz91izPu84vT/lxz9a8s637rGYHfNRW2NdQBQxOs0MApUU9ENgt5O0nwQWc8e7f+kd/vjHn9D0hqrI2GwGNjuHcRLpO85OFQTJxz8ZaC7PqSqNCBmnd1O6YcCJgc5YTu4phg6evD8gBcwLRZ4Izh7MWRxX2GBJSs/q+oYyXfD8kw3ODBSlZrPypCJlsoBh19FtAtWiYvAdO+fofcPkKKGzlvuPMt58Z8azj1oe/2iHlPDet95Bquj+nQhom4bgHODoO4MnZXU1UG8H1i+v0FKQTxS9cygt6I1HVwpZBqxybPodTnl0otltYFrA0f0JqtmxWrcIueO9d095/sEV9S6wuuxYb77ci0CN+cyTyQTvPXfv3j3kTZ+dnrE53/Ksfk7TtIAFAcPQ48NAmilC2BvKxoJaBui6nuXNDW8+epPMvo7Qd12H85I0FSRJih+bo13XHcy19lGqXddhw6vG6b6Y3juk731v9nPtPqLrdvSqVvLgqSOljKaCIuZUJ6mlGWqkCyNlOmaYF0U0d83zmF++j7faz+V7R/J9Uzsan7mDuVue5wc69r6Y3TP29oX73rgsIDg+PqHZ7MicIC9iVFlrDF3bIUSMrZtOKoJXmMGT6BwpUoRwEAyJTrFjBFuWZygytF5G9l6WHtDh/bjtFi+lZPAO6zk0PPaIctd1SBmjlurdjvVqRZqmVFV1aIAIKZEjO9I5R9e2+MFgVIJCYEwsjifVhNl0Gu/hNkbPSikPHgOTyZTdGIO7z1TP8zzGqg09EJmW++bGvviP91CJ8Y7zy4so4fwFrblue5t8pqG9L7b3U2Zg7PTu59JRthW3BIx+IvvJjzjvS7E3R5Ux/lcJQplz+uARNRKvUopJhZQBY1o26y2pTplmCcr1TBI4nmSkmWQyyaM/gow8uqhzBiUt00lKu7k5GNn1fVzLpGnKneM5jROcr2qaXJCJwHqzAy04npU0zQ33H7yF9AlHiylaOMxoI+CcocgS0nLC/GjB9fUVk8QzywQagUPhpOb9Dz/mzvGc1dUlSZpydDRhud7Re81yM1DvLLNK4+wQGTFBInxkoHRtT5aXtL2l7XqCt0hCNFsb6wZjPSIRBByoyAIJQhGCxbuATHIGB9YK3GBpd2u0Smi2O7z1VGXO8+dPuHh5wb179ynfuE81yxh6Qz8EqnJCUWgIUTufJUlMjBKCdpijtcT0Ld4ZrDU0dUuQOWlSkKUVGuh7R5okKJ1SlBXOh7Gp+efcXC3VCUoJtFIRhVWx+yOleO1Gr0cjB8UrQzQpAihi0SshE5BlgcRYNAa8wbrocuqdpygq8kShRUSMR1gZLT3TIgWmKCnYbhq8NzgrydLJ6GTso4OukhHBbnp2TTPGbAXapifgmRUl0/kUrTWbzSoa6QTLYA1ZVoCJN3upEqSCputjBqxOaHYteR6zJre7mEM5DEOkKUmNkpI0SUiVRBLjK6yLtKreeoo0YbnZUaaKIslIs4wJCW0bEXElJfPpjLarqYqcLI/xITpR1HV7iKbougGEZBhi7uTsaEbTNlgzMJ/NUDqLHeM0RQiLc9FIpR+L+RA8VVng+gFj7KHT2Pc9dugj4qsCZZmhspIkjUZ5VZqR5DlSpwSlEeMx/yx9fH/j+2yh/bn06F/UJMDrhfTnFQP7IcXrRc0eDf+8BsPPHp/zGsGfajuHiWdEvfcRXZ86Aq/9rLjdXogvT8Ysz72JoAhhlH/EIjpLYkdfJzp2oV3MC0ZKggchJZ6A0BJno6me9Y6NqfFZgksUd95+QDLJ6AcPKBwCISN9yDtHsOCxWNcjvKXfrrm6ecH59Q3l2TFX1wMbdc13/tKC3iSIoBnMMOqLHYKA1jl+iHEXB+dSXsVVBV5fZ7wqt2/BqLf2y6vC+9azPyVL+NnH51VmuhxR7riJfZvndoHOq5Pv33Lc3syXfSV1o3+cEmKMsd2j1pEtIiUkIsLg+3Mw+LHRc1gVcau59LrZHK9+c2ge3F54HRgiYXxQxOWWk2O8TwCNoHMelwjSwpM1EucsV0839EYQVMwUzwpFmkE5VdTdjuPFBIFCqhDnIJvw8onh+F5PWWhuVp4QPEUhEKXgaJ6TqZSbqzVSe6pZQZZVfPTjK/JpTn6UMIQBPxE09cAf/+icd96+T6IyTNJSHEdHVukkl5cN3npmR3mULmnFP/uX/waZJEyqkqunW3ZbiVeOqtJMsym23zE/vkO7W/KTlw33H0gePpzQdz1vP7iPTAKfPPkQ8Ox2nixJcLXj8vwC4TzblaNtG6qjwOms4Mm5pV5fEfrA2UnK5tJz+dxy9x6keTxovQXvDWcnFd3lmjxVJInn/kNFVhrOX1zy3d885RvvHPH9//4Zi+OcIk3p9IAZBnQyZ7e6oa0bRBCY3lEvAafHyCpP13uSSsU5p0oYpOHpzYCVn7DuO0wa+O63Frz33jFPP3pG3ex4+80jBneX3/sXL3h6fsVQB7RKyaaKIpgv9Ro4Pz+nKArSNBpT9X3PYrHAWktZlsweTTg5PmK73bBardlsNlhrSNOMxXzB0MRGkApgu552W7Pb7ejblqPFMc4nSCmYTqesVjcoHZjOpkymBcPQ0jmPF6+KwX3U1oFObKKj+t7t2xhDmqYHcy2l1CEfe7fb0XXdgZ1orWXw0QFcq1hIZmmkpLdtSz8MpGlGjjxolvdF/9XVFW3bMp1OKcuSvu8jij++92q1OpiNaS3w/lXhLqU85IAnSXIouLuuO3w+ayOqmBUlWkaq/b35Cb6JcWlZlrFYLLiqV9jekmo7moUm5FnFcrlltdzFdVhwmG4gK0vi+sRTTSaEly+p65qj42OGYWC321EURYyKTZKDUz1EhqVzr0zn9t+zrmt2TRsR0XFNnCQJR0dHbDYbNpsNUkkSFOksoUhSbDeQSYVpO8xIR0/TFOdjQywREk1swvRdT2cHhID1en1oduxd5vu+x9mBXMe17z59xxiDlDJGnG03NH1HWuRI5+n74Uu9Rr6MEfbzwlhs73O5D43pA8Mv/r2fTeKPcU0hg0MECzLBiBSvCyZHJ+TTEp0VCCXIJhXGekJQCAryBIoSjqqcxHdUuSBLA9NpznQ+Jc9zkiQ2U/bNoD2L5OT0hDzLCEBW5KhEk2hNmmXQ9Ew1lIUmsQl3Zyes1ismUpEmgVQYyipjPinIsoT18oZ+cOikYFFldCayXU7mE8S0xDrB+8+WNJstUh/Tty39dEIQCbvW0gyO85sNFxtH5zwyAZ2nMY6vayjwTCYlbmgp8pKb1RZUwma3o8hTEiXHeT1ep95HpmyIqAzgDw2NvcTWy4S275iWGZv1muvzG95N5nzy4fuIoaFrawbTY72jcx1BemaLijKboNBYY+m6AS0hLTLa7Q7nzBjLptgsG9rdKsYy2xhDW5YZs3lOMJbAQNP0WGepqhJjYirEavVZr58vc3zlhXeRJ2gVd0IsuiV61AJJLcduqRoLbRH/PyLkes9r1gKp4uI/QSCtJfQ7wjBOkCGglYLgwBuUiuiJMx04R3AmxohlCWFSoKWmbXvKPONoMSNNYnyYklFX3XYd601D14/6calROi6iAp7NdktRFBRVRfAeYw1mGBiGWEzvJ7V97IdSkWaU5wWb7ZYkTcnznH4YKIoCqRSbbR0R/9HcDTHmdfqA0Cl4gwmwbXuCyLBtj9IpjNFLBM9kMqUoMurdCpkl5FlKlqV0XUeSSE6Oz9jVLXlRcXl5jVSaO3fPWG5WlOUkuvAOnrZt8CHE72Us8Zam0FJHJNNDN1iyNCEcFtJ21HDDum6xITANMF+UFNMJIkkjdWE8OLdpuPDp4lkcHvsimvnnmfP9WY9D9zXEG/ihCJef/TwRQf7s679ouz/r8Z9nGz/zNePfe7R1jzi++l3scO+7xOH1F8YimoC30Yk70ubiOdx3DYvpIka5+DDmycvorOsMQ9/jgseOlMPeOwYfaUh2sCgR+OAnP+L+W+8SdMJHz875P/3d/zPNECeG1kqsAzcM2KHDmh6CwXctoW9JneF3/+J/yI+e9fxX/79/TX29ZnZ3zXDvn/Mbv/3bLGYZmQJrLDiB9ynOSCQpSoEPw4GJIBD4fTPlgKLuR6SlfXrPhgNave+s7x3If75jdejgi9sF5fjeI7PgdeR8fI4Qn9n+ZxCBLxi3X/V5Keb/LmPYF71jN57xnEiFROFRbtRlH86y2w7u+/ZUiMoC9k2QvTQijr0Z094BHrilWd/fL169vidgVfwcwgSkEyQE2hOPlprcJ9xsOwggtUJWnnSuODrOSXVPsJZqouhNg0wlkozrqx5rHUMLq2VNtcgJTpBWiqoIbOpAV9cMWIpp7AgM3YDpLQ/erLhZDawaCFWgSyyh8PTNwPs//YSySnj0KwvKk4SPP74i057BQVcrinLCxc0lTz+s0TLh3ts9x0cascxZ6IK1XfNr/8EbnMwz3v/jjjSVLF+2yFSw22kkE9568A7Pnz0mhITNhSKrMi5e1ByVAlFKilnGIB0vnwes7Lm58TE32825eLHm9G5GYz3bzjG7m5BNoSwT9GDpEk+zC9x9oDhNSmxwSBfYbTxeCb75KycUU8XQb6iO4cWLC7AJzg6U0wmDc/SDJfhIx1TKMTtW1DcCgyXJNHceVTSmZ7CBYYiZrtZJmrajnAa2teP5syWLo5o33z1iebVBKoUfMoSveP54i2k9J/cgyT1V8uVSzW9ubrhz5w5d19E0zQHh2u122MHw4OQu0+qYyTQny6LWXUkVncVNLMD7xlA3LdJHvWTTNuSj7r06uo9AHPKVb9PFpVSYro/riFv3CDOit/K1nOlXc+ttVHFPT97Hju214kmSRNry0DGYgX7oCRakiAX9yekJR74A7RFpcSjkiiL+e4+qnp2dsVwuD59/XxQmSYL3nqoqyAo1psx4+r4fNcpDBDmkPOjPb9PgjTGsViuSpkUPlm+/+02khSTLyLKM8+UVbddGR/cg6doIshgTmM9KCC1SJBwdHVMFweX5OVdXl5TzKeVsSpFHinc95nlrrZlMJsxms0NxLYSIZrnWYZ0/fL49JX7fKBjGwuQ2BX9fAO8RfK8EqU4gSZAuuk1bIQl+/7g8rEWUUljr6Iceaw3yU/T1vXb8QIkXkqIoSfbN8rGpvpcWCCGYnRwRpMQMA959uc2pL2OIce69NYUiiQFYh/WZuMUiew02URH0I+q5LYK0mFHeeQtVzKI7d6JRmSWogDOWzbKj2xnOZgXH0wllEii0BFdDsFgryNIj8jzGy223m5HtkOJ9jK1KkpQszw8Nl6qqDtdmqgSnZQpCUqqop859wmJRkJfHzBcTABIVCC5GJSdpjBBMhCfPE1Z1i5QeM7RkyvLuoxMuNk9wY3rCrm4YjMWh2HaGVR1Y1ZbOx1rMBUnX9ORFinM2RhFnGav1BqE0u6bFWcukKqOvwD4m0ESzZe+iRNdaDz5GR0ZSqwRGDympKCYTvBtYTCYMzY7d+prN1TmrmyuM8VwvrykuE5CB08UpybEmzStwAYWjbXa0ZmC3a7HDgEySKC0RUfpS11vaoccLQdtt8P6MWVkiUNgxHhH2KVc1k8lXW1N85YV3VaSx+5DoSDcXoEbkW6pbsV9SvlZ8KyHQIurAUXI034o0QpXnJInA10Q30DDGjEmwwdN0DdYZJJZcC/7/1P3nt23rfd+HfZ4y66q7nX47LnojAQIESJCUqGJJtCV7OHHJcOzEsUfi+C/Ii4zENbKdxH4TW7FHMlIcj6hYliWKEmWSFgmCAAES/fZ2+tl91dmelhfPXGvvc+4FBTn3CvZzx75nl7nmmmvW5/v7fYsWEHpQiPckUiDzlJ2dMcNBjjENWicMhwXGOmaLFXXT0XQO6yVCaXSS0ZmG1nR4H6M5cgoGgwEDPeLk9DRWDnv9TmtiDqlOs5jzaAzeR9fmtuvQOu2pWpFG5pyLes4mEJxjPBoSpGLdNDGD0kPdebRMWFYG5wVpGo2vRsMBbdtSFhld25AmCQTfd6zpM/gGrJZLrKd3K4wh9fPFgjyL1aZV3WC6gLFRdxRdymOPzXuPCSEyAEKg6SxFFrvfIQS0VrEDP5mSZjlplpEXOVlZINOMIGWf0Svf1f37BwFQeBxsX9ZF/yS13htCfAihv5HwR2zPYxD2v3Ox4MKI6wmA/q7m65PbcblzeLEN4vG/bruGF+vYaOzEY61RSbwujbUkqebNN97kP/tLf4mzw4c8/fzzXD24wosvfpi//bf/NqvFApWmdF2HaVvojQ29swRr+s8UDQIxFp2m/Kk/+cu0jx7xw69+lVe/+U2ckFG7lggSkZCLHJ3kiEIjMlB07CQJA6X5/ne+w3nbsTSGX/rcR3jz/gP+0v/xL7J76xm+8st/il/5s3+GnZ0JlTG01iCDxnUO3IaS3H9mER7rej+2S8XlffTuItCTp8Effbg3k4XLnILL1fmL7zbA8zFPgD8SLL/H+fgjT9H3/2FzbP1WbxcLE4HUC0oDu0qSCxcZEo+xBPpvN0W5/vVeXALoPajefPZosLnpaD8+Qo/kNwWxIECmGpsr2qZDdwEhFOet4J/+l/48bnCN/93/9v+CMzHCSHpBMYTRJGbFTwZDlmtHa2qmU42WOSp1rFeC5amnXjmKUjAZ5+jS4gwUpUIKhzENMiSs1obd6YC2cnzo47d47fU7LKoOL8EYjwtQTAKZzBiWQ+p2xieeewHPmuFozPe+c0KZa6p1RZmWLI8aklG8t9dVQIWAsx0f/+hVfu4rn+XV77/N8ZGlsedoWeCdYX4q+Z3fusvO5ISm6hhNEtZry0c+OeXWDUFbNahRQA40q0eB+awl31XQSe680VCOoomXQKF0wrMfGdO0FTujIbJ1SNMxCY7Ts455VbM2HtM5ROWQSSDrBJ23iFww2vd8PNvlmdEeSU/Bne7tUo6mLJc1w8GC1XqFcy3FwOFODSpVjHdSjI1xPNJLQuNJtGKoE6qZ4ZM/VTAoCx7dX7K3c8CVayMO9q7SNitefeUujQEXwEtJ5yRt7Wnr9/eZkqbpFkTGZBO77TpKBMcnh4yHo8iAMzWr1Xz7mrY15CrSmK21ZH0Rf7VcIYdDqqpi50Zv3NZugNQm25ltsksIYavBhtiNNsbE/GwVDV+fXGYzNjpqYAvUNwDaGkPTNv37hl773HJychTj6waC1XxBUDV100QdcprivWc6jU7ox8fHWBs16xvQPJlMtrnkAU9d1WR5yv7+PuPxmCRJHtN6PzkuZ4Z7IFea8XjM+vCUMotd3aOjoxgrqAAkVdVhTQNB8aA95Ox0QdcahqVn1TYx9lVr0jSDHtzmeU7dz/uSJKEsSwaDAXVds16vt3MD52Is36b4sdXH911xn2Uxl/kSk+Ayld62XZSm6AQpFULr3nslFmLiHExvqembZ8SGwZANyq2vwCar3PRGxHmekyaK8WiAusSGuMxIVVqRFTl11+IE6J9QnBi8e1742N8ud7jpIfV2ngRJmtEZQ2dsz0AX22eGQIJMcASy0Q7Da88gx1ewIiM4D4lHZ5b54oSmarAtFGnOMEtRIVCkitCtGA4SRsMxoqdXay1xTvbXUED2RsJXr16hrlvSPEdrheqLLF3bkQ9KbN2y8o4sSxkWitOTE/Zu7ZMXRZQ2pRrrXS+nVWRpilaaPMnQ0tC1NblOotRABA4mJcX0gGLnCt999RGPDo9RcoiUCSotUUaSFC318Zq2c0zKLHo0XJJMFEVBXVcgJW1reilsZOaKQDSPFII8zwitiOAb8E7281THxujFOEuqNI0xNF3HdFowrxoyCdJ1lFrQtRXLqmNRr6i7Od45cB7bGkbliDItSHWKw1O3NUmiGE9GtJ1FAoOiRAOr1YrVcs1wOmQwzLG24fRsSaI0qUpp21hoT9Lo+dV2zQd6Dn/gwLvMskgx16rXeRO73ipSykVPK7+s7Y5d76gJ3dxEIle3z5sVgiTViCJHNg3r5QLbtrGy0tRUrkMSSBUU+YA0S6LQvrMxPzKLJhQST1Wt2NkZk2pJ11RUTYfznrYzrNYtKs3pmhaUQCfRwGI6GVMUA1arFQJFludkWYn3AiUdxsZqYNTPKopiwKydEXwgSTMc0fgNFWOznHO9y7vc6oTmqzWEgHUO7dlGkGmtaYPFGEuWdCRaMB5P0FISnKVer7DWYI3AmS5StdKENM04OjknhHgh6CSJFXQZWK+raKKBIMszfN3SNS1CSYKNN3XbP3itdTGyxHlc1UYZQR/FsLt/wI1nngWdxIgyQW/KEbYduwtwoX4ksIYfDbrf63c/KfAttpTgsEEBl+DRpfFkgfXdSzy2zGax0DujwgUYlheLbb/bLv+ulXmefFNx8bLHPkPMuey79xHdPfEumxYi0ZREgiWgtKBI4W/8lb/MerXg5//YL/Cdb/0Br738Q/7wG19jNp9z/fp1XnzxOcaTEXmWImQSJxxZwjDPyBJNmuSkWUFZFnzz69/AdQ3das7/4l/45/jSV34JkeTINEWnkChFpkq0zPCJxKsQs8CDpdCar/3O1/krf+2vMzrYZVnNuHp9l3/6f/4v81/9+n/Lf/1X/zK/+jf+Oj/7c1/kT/1jf5qnn3seKT1eKqwL/cOxL6j4qFUUsKV7h0vn8LYI8uSBFE8ekcsnwOMFmA1Cj7/tCx3i4vcXPegN5Hzi/S4XSZ4E+/gfeW1cXssF5S4an7yfY7U3wEuB6yc53nlCbUjXXTS1VJJkU+DYUMzpP/52V17an0KAD32e92bStOEWPN7p9mHz2BCXwLdEB+g6R5XDuhDkWuHqwMMjy2v/5Vd5+mNPkWZQRxc3lAp8+tO73Hqq4PUfPERIy961knyUIZ3lndfXtC1MJkOGhWS96kgGhspYqqVHhkCWO3QeEInCOks5htotMU7w+puvMd1R7F2TnJ8nnByamJc6GbJYrEmFRMjA268/ZHbqeOfVY4bDMZ/85It4r1k2hnvDN/CuolkbbGIQFlRi0FnHt7/9Cq+/ckblLNWp4bOf+QRXxld58827lFcm7B/sYt2ael1zdvIGo+QFhjdOuXP/NsdLw6pbMRgPKUeOwZ5jb5hz5y3PclZja8fRuWX4kQknq5rDRw2D0nHzaspk4CmComwTulriuppyR5KUKdYaMp3gu4T1usZ3Hd45yqIgywqm0118iKBqPl/EIp3wON+htOSpF3Y5vL/gZ75yk53dkpd+eIcHd9eEFIZlggyatm1oW0uuGz79qWs07ZquCdhWMB7s8tab7+Cs4uf+5PMsF2e8/daMNJNcf7p4X6+BZ555FhVn20ynUcc8HI5o+gzowXDE1evXyNKEoszZ3Z0ym805Pz9HEHXueVoyKkuwnnl3yrpaUeYpTV1BCJR5TpamzOar2LPzAURMiEmTFJlAmiQkaUpV1bRtR9sapFToLOZOe+cpS42WOrJogkAEQVtH6vZwFGNN1+v1VsZmTK+5zvLeADalLAecnQlm8xlSD1itK1q37A3NGuYLS57llIOy12Z3Wwbc5lrdNDG6rqPtapJMkmxZQzFTWmxiZ7XC9AXczdjMqYospxwOeerWLUzbxdflgqquWK3XFHsTFtUKiaBuLE3TolWKaSOjcHc4jfGxXdt3s0cE51gvl+g8pcwLjLUXBsEImjoyG5bLZQSxeYYXMY9+U9ho6hrTtX0CjEIPShLVG5H2GhnvPao3tzPOkyRpvB9JSVAK2e+PuJxiNBySaI21BpyjSLMtK2DQFwmi1LDZMgqKIjaP8iyhzBIE0Rl6Q4OPRsfR8LaqK9ZNDQiKIn9fr5Efd2w68JvxZFxr4KIh0nt6bh8f3nm6tkOnUdoZ43PjvpYhNhc6kTHcPWB6/Sat0DFmTAR0kqKSgLMBfEpXLfCtRdDgS8+o2Ef6ht39KXlK31RUZGlMNCrLnLbtYuxhqknSFAGMxuPtOe/7opOQAoWi2JngvcXahtFwTFJolosFo/GA0XQnNsLatnfAd+R5gQC6uiIfpLTW4TrLIMup6jV5nuGMZ31+iHQtRSJJgKppODtZELIhh4dzbOsYpJJRkeC6jkRL8jwjKzK63sm8bQ1NaxFKIWVguV6TJ4o8yzDW9EzH6HTug8DaaKEcwW2CcRZ8jDxrhWe2WrI/TLi2v8+VvR1SGVhUCxItWa2XCJkwyBPqVcWqXKNJydOCtW+piAyYdVVTjPfYGYw5my2iIz8C7yTj4S5BCNJSMxwNCM5iHSyXC0blgDSN1wVBUA5y1h+weeAHDrzzVEd9d081lwK0jJVyKWPm9IZenmy636Jvb4s+nkXIaKK0uchEpIDKVJMWBSHLME1Du15TdS3KGJT3iDIjaI1MU9KQ4kWLcKF3h+ww3jIoc5q6wsqYT1dXNfPFGh8CWZZHN0rr+xgQEFnMBV6u4zI2eHzbIZDoJKWjxXaRDpUkdusKmhUFiVRUVd1Xsmu8c6RZjNigv+h0GrU1bdNFkzal46RVaIyH1gaCsZBKgm9RIuq7nLcgsv6GGTVIxnQYa8izBKckeZayqpaUwynW13jf0LQ1QgSkVFzZ36WuTJwIed+7rF/kfyqVkGYa53xPyAkIH+mYWZ4yGo9IswzbU9LxrqfB0t/8wuMz4z+iU/fj0nJ/ktFiMgRk6CGZCD9ye7Y2XVuqX6z4bWH6pjDBxZ/EJj6Gzb9P9EC34JhLgDp2aT0BhH8MwG3WBbFzyIb/S7hY9yXa/2Y7fRTobDdOoQCBFeCEoUwTzg5PObl3l5/5zKf5X/4r/zInf+Gf4PVXX+XrX/0q3/3udzl/eJfFuORDz36OP/ZLv8hzz72I9Z71ukbI/uaMRMgYe/fmO29w9+23qLqKgxvXuf70M6w7sEhE8DgCKwBvkVUAF4+BVx6deuZ1xYeffYrje44fvPUaX/6FX+Bnf/GX+PSXf55XXnuV3/qNv8/vf+Mb/N5v/haf/Zkv8Et//Jf5zE99kXKQs6wqCOCsJVUJvu9SyCAuy437vSF4Urm9yeXekBAenyRcvHpL5bzMgrh0SDfHw4uL4slGsxz/LrcLXrzHZZDdR7a9h1uaAN7964Ag3p/fz5F+/HqM/AkW38XKt5mf071lUcEjnQAV0x1EgCACQUiUV9jgCIq+Uy164AUgscEjQwJYEhkvAH+Jgr7J7O5LJAgZiycieERQaAvl3LJO4UEBXSFIWsmdV494850ZQadceVpiWktSCoYDzWs/fEBWapJUcnZcMQW0yMmloNjPOLh2wM7oJkqk/OC1P+TktUcUpSIpY8ehmgu6xjIaDchLMNaxNi3zVcB5RV0bVmuPlJo0E3jjmAzGfP7zP83bt9/k/t2HJDJBeon2kjtvPOJTn/oczz21x9nRGesgsN2Sg70DQtExGUp2plPu3TmHds2f+KUv8P0fvsL+zlVW8xm7uzk3bzzNjVvP8off/ibT8QHL+eu8/faK2eIBDoNQCZPJhJPTNZ005CJwtG7wWcBbT+iia7IJnsMHNd0K2nmHbR0f+/iQyq4Y75ec3G24caXAJTBbNxgHo5tjPvrRZ9i/sebOnUd87xtzPrKjozlukhBsYHZ0hA8tQQZsCBhgtW64+tyQg2sjbFjwzttHrNcdXnuCEqzmFUknmOwlPLjfYvYtN28JzMrTrD06tTixZDBOOLzdcevZjN1rN7j2asYr31vw6Pb72+2wHdQ26pe7rmM6nbJc1H3sacNJ19E8POTatR1C6iFxZHlCmY8QpsO3nmAsy3ZNa1usrDF2Sb5sMdWYbnHKCzdv8P004bzr8DLFO0kgIy0GlBacbVFKo3XOdLKP1ANaE9MchJdkKkFpwaQYkUqNtw7loVnXuM6j0gSkI0szRCbprGU+q/AESlWSUlAETZ5ohGk4GBQ8lJKHZ3NEIvC0kcCrBIkCH2oWy0hdD16iVb41cdvd3cX7GFOUJAmrWuMTQes9tjO4zuM7SzCWQVEwnowxfokxHa4zeOsY5DlpEOTFkGduPMM4HXLy6JREKZZNzb2H9xGpxofA1f0rvH18wlJInE4QztO5jlIKUmkxoUXlCtElrBZLdhzsDocolXPqBdViSSYU5SAnTTKSLCV4z8PDR3TWQhL9B4RSCBnN8YQPKC8IzmEXS6QWJMMYYRRC7HqnKnYMY447JBZGOkMCh2ePYmc0z+mcpV6tmaQF47zkoZJ0Ak7WC/a5QhCC4+MThBBcu3aNk5OTrSZ8Y0wnVYnIcrqmobMe5wXzswXBOhKhGOkipj/EyQOp/8nMuzZzk8tsx+28y4f4/Ngkk8joVr1Zxsso42zbjjyPEs+m6XpXeYtQGeX+dca3nudoVSF1IG2WZGnCbGWjO75WdI3FNo5JmZBKT6odeRoosxQROgiKRBXopCBNS9puQSAhLzKstbFZpROEkDgXDRCXy2VsCvZyAO89xc4uKstxvkWrQLJakI8GZEmBQZAOBmTlAJWk1Os1wRum4wnBeVaLM6wxiJDgWos3FuMco9EOt67uc3x+yPlJg5eSIi0pssCsafDeRq1/JshkoLKGYhCvQ6kSqnpFU7fUjUGmGaaXG1rrEFmGTjTGmtgpRyCEIvjQR/55tJIxPjDPcN4giUUjREw/aZo6+nO5jrOTQ0JwKK1I04wyLVBBEVycJLetZW27SHHvGqqmY2AC070obR6WJWupWc5rtCrZ2UkwoaKuKhbzGcE6tNB0utsybdq23WrwP8jxwWu8szR2NZTamqZFqrmKGjslUFJFqpiIXe5NxrcXXHTAL0VMBQRBKqIDIeTjlHLkCbsW13U40xG6BmxHaxxZGmIUTwhYb0l64B+CxlmDFipSUJoaZw1SaqS0mNZSdw3WeXSq8NbS1o5KQJYVKNWDUG8x1uGcRStJonXvVBlBq+4rj6rXXa3qGqkUzjpWq1VcXogYadRTgYSK3X6dZDFmQhArwxEVgPMkZcpwWJLnKYEItMfjEcvlgjRNKIqc9ekqRjDRsliuKMqCxWpJaz2dc+TlgK5rGAyGtE0XTdiUQidpzIyECCqJ1XNr4w0oBEcQgbTIUVmKShOyogAZl4uX3QbIsT12G9z9JOh+vNv9RNPwXff4nxzYfmxIFb+2o++qPUl/2n72sK3sX/7rYx9HbIBy6BvMFzvgMjC7/I6weSDFjqwAQu+iidisUjxGLfebLvcT/fLHOulCItl0F+PfojM5SBFQIjJX7rzzFld2dvjw889hjWU82eHLX/4KX/rSl1gt5vzw+9/n7/3dv8tf/i/+Cn/5//X/4WOf+Sy//Mu/zE9//mcYDMqt465HMB4M6aoa4aPMIdUZbd1ivMQKjfDRZ8GLWECT4fIn6OnEIrC3P+X1H8659fyHKcZ7/Dt/8f/E/rWrfOGLX+Bf+9f/Vf65f/6f42u/87v82t/5u/x7/4d/j6ee/RB/+s/+GT73xZ9hMp5gu9j9SPsYwM2+2e7vIB5nEFw61ht8vSm2cPnV4aIzu6nOv+fogXuMEIvLyBC21Li4uovXbmLl3rWa9ygEXRRxnlz2/b+yFgKC6OI9RECSSFSRQZogbPSPkKHv0Km4d6UCbwPkkr2feprD4wXdwxllG3rNnifzIL3Fao/rtd3ax1zf93L43xQtAgGnHc5Fbfekk5gQeJR7znY8NkiqzqAKQTHM+OgnJ7zz+imvfuOIj3024/kXrnJyvGKUBl57fcVsNaNINEIK2qM1r73+Mh9+4WnKfBfbniAGPd3Xa+qqxhuFzSSzI49QilSXNE1FVhTozMGqplk6vBG4ruJDL97gzbfe4fWX72JaT5JZykHCix9+ltFghz/4w28yHA2ZjgeMVcbtuzVnj5YIHMGmnJ8dkeWKnYOC51+4yXq9YDG7y1O3nkZpgU48P3jpDxkOB+zs7HLl+jXeePsOq9UaqeCjnyrjcycEnr51hXW3prUNXScJKlDua9ABUUK+k+FVy/VrQz78sTF1tUAagfUdjbWkQbBeO1aLgM4Vb71+SmdnXLul2DsY86lPfZTdvSGLxQwpVHTIbRZIGfWqidYkMiNhwMvfPebTX5iCC7zwkR0mVzv+4FsPaSwEq5kMA1kZC/6tNbz88iFZIrl6c0zbtZzO5/yFf+ojvPHKGVk2oJo57r1eMX9kMMv3d9L18suvbruLRVEwO18wO19QliXD0YjZuiIcdQht2dspeXj4gNNHM2wtGWRT2lWNMR2tMBhhKPOEJFd431Ivz6kXM37qi59h+Qu/yH/xV/8yXWep1jXGeAajAVavaUxD17Qs1y2dF0iRkGYZAYkzLc60sRsbNJnKSLSiq2qWyxYIuGBZmzWj3SmDcoQyHZ2LxqtIhQgK5SGRUFdr2nWM81p1Fk8gy3qvn35+M5/Pt6AvBEmWxPndxnDO97pLIQRFWWK1pG5q2qrFNB2hsxRJSpbkSBE7sl3XgfMMi5JRUdIsVzxz6ymu7+3z6PAcjCMfDpmvlpzMz0FLXFMzr9asWkuHQEgVn9NKYbylNQ1KxTvmsqpg3TDROTtXRiTDgkd5Qao0wVps28YOsVKkPe08DZ58UEamlABnLF3XkApFkqQEL3tzySgx3PKapEAKtvMoEQBjwTrSPEdJtZUKGOewxiBdIFEKqRQiUSgRmWnGRs2wzqIGfUPP32jspYweLNVZg+k6bGfYbzrGxRCEIJGa0HmW53O6EFmjwX6w5lM/asjLUaWh998Ml5/LffE20JfF+1loiFG3IYhIk+5iqkDR66+9UuSTfQ6eeYG784pVa6HpCO0KLQNepCido2SC8I5BVpAry7hMGOaQKE+eaVzXYK1nMpmS5UOUhoAiUYrgoyGfNb0O2nm0jnTu4c4UZy0y0WQqGgc6Z0kHJUrmmLZitLcfDSd1CipB+YCzjjRLqdcrskQTnKFtGmzX4WzMDFm1FUWSUdUVqm0oFBxMh2TqFg+OTsjLhGQw4p3vv4VHMCxgmCmE8KSpJM9ThBSslnOkVjESTMrokyMEwfneCd5HLw6tcD6mOxkbDTCt9b00JCBUvM4V8TnvZGA+X+F2x9TrNbapqVcrCLC/t0c6muK95NrOHmU5ZDmf07UG52E03qXIcnyqEbqjqmvM6Sl5PmAwGDKZjGiqLhYItOVsVnM2W3B+dobrDGVRovBkaULbdThrcVvN9wc3PniNd08nVEpfUFd67UhkX0VDMdnThi7rVnWf/X3ZFERsQHkQhF4rLHvw4zGIRMbejVL4RtL5ELM9g8N6Q9etMSiGxYC0z++WwYM1JAJSpSlyibF1dOPOUrrO4GyHJtrx16slwXum0x2yrMC6QJoFlsslXdeSZylpmlOtVmANCI8WjqauoiOzVKzrPhvcOURwpImktY4iz6nr6IJpfT8xF4JUe1rr8dYRnMerwHA4YFDmhGDx3tGZDmMyhBQxD3AwoG0NQmlaR6TNB6itoW4NTkmWjcN0nqaLegeERCUZtg2suy5q+ISMdGTn+jz2HniH+GCwwHg4ISmHcdYcQg8+39ukZgMEtz8/AQ425ZXHf35yJRfnxE+Kat6zYS82afsl3pNLHk2hNktuXvNEl7KP2Np2V0MP8rb4TV5aNna443vKLejzlwIrNw+l+JwS28LHBso/RtO93HbffvdupC9ELCLgLRpFvVzw3DNPM5kMEULgrGfVtSgZyIsRP/9Lf4wv/dzPc3R0yDd+7+t87atf5T/8P/+HjIZDvvjFL/Dlr/wcH//4J8nSFJzB1w0pEDrLIC96p9meYRDhP55I4ZW+3+dS4r0hIWF+dso7r73K7dt3+Jf+V/9r/rFf+ce5/+iQew8f8Dtf/T1+/xvf4guf/zzOe770sz/LwcE7tJ3lN3/913nnrTfY3z/giz/7s1y7fp2mjRFmfkP7D2K7n38kSA0/Yt9tdny4XE750eu4yFlnW+G/HHK2baD/SDr5e7/DexVwPrBhOhwdIUi8ESSlJBtk2Ewj3Ma4MSDUpignMN5jE4mbKA4+dZ35PYc86Gge1IhDT9pbpdu0LyD119Rm38RHRPTOoP95w+AEkF0sTHXOI8uEfCAp2paBC0wmAtPB/lMDOrtiZRQ6V1y/mTLZKXjj5XPu3V7z3Ed2uHJFY0Lsgjx8uCZvQFlFmU/59rdeIkskKsB64QjesLMzZm/nCnVV0dQdDx+dI9No5qTSDt/HMGntaBuP95JXX3kHhKVbCqQGkXmQmsOjc+phS5K21G2N8SU+eJSH+dkKhGZ/7wrXrl/n+z/4Lnmh+NrXv0aeFOAVTed586U7fPSjn6VrPcvFGT4Ebj1zlc6tqOolxnUIqcgzSSJGZHqf73//dVxqonaxlCADSUiZHVpE4phekzz78R10Ljk5Muwe7JEExcmjQ/KJQAZNJwRCgbOOw/uGsxPLJz8z5FM/92H20h1SpSE4ECHGbx4fk2U5Zr1ksVww2pUMn04Z7tbkiaW1S4qB4sWPZrxUG9YLS9XA8XGFCArTQiIM9bLj9tuGfGCY7ApMDYuF57d/8xGDXEPtqI8t7n2W9925c4csy7h27Rrj8XhrThZCYLFY0DmPc23UM4cyulmfrDg+P+XcrCgp8CHQCkMXOoosJ0kKtPc0TYfpWrAdzzx9k/GwoDbR5Xe9mCGFw3b1dltWqxWdE0id9ckimq5tsW2DSNNez+0ZDkq6KlLhi1GJyjWOeA+yxvYFeBdjTJ8o+kWKeNv/FLPHHSFGxgpNniXkVweRSed8LBRUkQa+oWhLKSNY1JpBopFqo1uOE/jpdMIgzenqhnt37pKOUxSCNMsZFgWDLOf6zj7PPvU0q+WKs8WMNC9wwTNfLcjKgqTIcQS6ao23DhH6Ro+SpGmGa7oYJZvmvdbV93FNEXRqrSmKgtF4BM7j/MWXEIKiKEBJZKJj51tE7pjzHnrKuZSqB88G5y/A7JNzmuA9renoum7rAr9YLLZ67dhJvchTtyFQ9wyLsigZjUacdfUll3i97Xo3TcNqtYqZyD6gRHRfz4uCJAh8b9K2Wq/QeezIdt1PxtVcCt8D6/5ZKC/2U/zeX3S8A9t56uaJG6TABonxsextOst0PGIpRlz76Ge4++gQR8C2Fev1iraqUQiKvCDLHGWRUxaaUinGqWScCkaZQPgKfEmSpownQzwG55cIJ5DB442Jvk5eQJB0rSXJIuhGCLKiINMKbzrauiYZFDhhSBPAWELb0lmLThKUBOu7GNsHeNchZQAFJhjmyxmubgjWIYRCKU1QKSJJKZKUkWo4GJeUmWIySdi/+Ry/+ve/hQ3QWMmolGQaWuvJRwOsgkQJZB+5vCQyCZIkw1R1j99ASoG1JqrBiMxEGyzOg+gt7pyQpFKTJ0k0svOBRCaIkHDv6Ixnbl5ndnrK7njM3dsPuX/4kC5Ypjt7rKuU5Woe2dF1TqI1eVqSliOK4ZQmLDk9OWR9eMpkssNyvSJPE5AeS0MwMaJsPpN0TTx/V+sV3WpGkUe2TdM2KBUTpj7I8cFTzbNsm/e4MVLbGEj0su3t74HHAPZm2Se1v5sIpM1EVoRImUUIUNHIwJt4A7TBY5xjPMjxOKSWkT7lHUqnZImiyKJruLMGnaYIKzEuYHzLqmroupYs0eSpJtOS4Wga896spaGNJmRKbW9mxlp0TxPPswzTtdHZ0kHVGPIspzGRHuuCZ2cyRgjPel3RVivyPKVqWnSSUXcWgidVIdIzLNjOgFbkRdQXSaDpTKQM6QTXNGRFQdW0BKGo6g6pA8PpLt26pqoaGuPwQdB2FtO15IlGF7Fy3PYaoKiPsFGv0Xc6+6NAQMQHr4tZn3kRGQAX8Qz/4ICrdwHuJ/Q6j38Tx2WaL1zQjH6SJmubIdg2rC82OzxJJr4EmOjhgtiwA/yWGhx6MLHp6MqwuS4uv+Flp3R/gbB9/9TZHIN36bU3v7vUTQ9PHi9JdOb2UdPdg86w7b96Ehmp38J78JYiTZAiIGWM+olFeodZ1CRaMt3d58/9E3+BX/5Tf5pHDx/ye1/9HX77t/9bfuO/+XWef+oZ/tSf+3P8+T/7j0HXkauEYB1FlkHwEfBK0QNfUERmgSSC8eA9MngKJckEFEnCX/jzf56f/vzPsG5aRpMdPrF3wIde/Cjf+Nrv8pf+4/8ErSS3bt6iSBOG5ZDd4EmC57d+/e/ym3/v1/k3/91/l8FwSmNtlE70x1dsZRKbY/sYFP6xxo91zoZLMgUuio7bI9Rvxh+BvX/ket97o/4h1vFjDp3kiJBHmU/WMRgmZFVGo2ZIL6LPHiBEQARJJwJumjK5PmX/qQO+/VvfZrVq0EowKTVi7KAFEo+Tkj5gFIHue0OGWKYRiD6+ZEtJ9BCkwHmJxSOUoG1aOmTcj0IySDztOBCKmr1Jwul8TbELTVJzsvDcvQ9Sldx+u0Ynnk9/4oAfvnZK3RkQc24e7PDmWy8jpcJZy/kjh03h4OoYhGJvb4/k6j5vvfMaaeapGx8lSusWYwLe+UiTF5K8kAQXMA10zqETGA8Krt4cc/LwnLt377O7N+T0dI7p5njvyAqBlgofAnfvHHLv7iGLRc1kOmR3J+Xk7Iz5mWexVOg05Z13XiFNMqSA737nm3zp53+axkxRacVsFjg5WiJxnB0HquU9BIrdm0O6bok1ULceVTY88/yANJ0wX89466WHnB87QgL7X5yyPF/hE1g1LrKjMklTW9raMyhTBqng2rUpb77xJk9/6mkWiwVFPmA0mnC0PqWuWqRwaKXpnGPdrfnFr9ygaVfUM8fZI9i/kfP0zYK7r9zDrFusE4RO0LaBopDs7aZc/9RVhKo5OZ0zO4v0ROc00/0hR7eXXJ+OyHCo9P29ENI0xVpLVVVRR0iMedrEWcksRwjLdGdCU9dcu3aNJGQEm/Lw9gllOYy6ymZJ21jqqmMoJYnOUDJjcX7G4cN7fPijH+F/9Bf+PH/9V/9r1m1Fq2A4yPHWohNJmudUnaNdxu1oraezsfCvCCR9kkrTNgzzqHOXSjEejxnujBBacbqYcXx8RGMNKk0iBf2JWWSaJGR5zvpozbqrkKnAVA15HiAoRK63XW0nHUJ4pEipREVVVduor7Q35FwsFyRisDWulVm8PoqywHWGxWJBFhKuXjlgVAwIxvH8U89wZW+fxfmM+fmMJEtpnMEt55wvF7TesVy2BAEqTRE+yuaUlH03WlPXHb6zSB8jXYfDEWUZGxHnsxlWx/NkMIjvqYQgyzKSLKOt19soTWdddJBXEglkaRb9jKRCiwiEfeuwlzreTxrc+RCidPCSIdpG370xYpNSbefSWsVn4qb4mKYZqYhZ51VVbZ3lz87OotGeNdRdS6I0SaZJ0oQ8y8mUpq1qnHPRkXsQz4u6rvlJDCFjBfXJYupmRNAttn8TYUNLlwhkP6+N+7AzhnQwoti9xtUbL/DmgyPOF3N0nrFaL1kuFr3PlALXIXunb+Git9KkLJgOE0bDlLxISLRCyBBZs6nG2gZrIdEJ1kcmrRCx4Oh9iJ1irUFKvDUoFXO8N6wQFYDWEKzDtR2JTmJ7xYvIehUSoRTlcIBWCte2rBdzTNMSrAfnabuG8WSK0poUwXpdce3ggN1rBQ9O55ysDedVx6qOLNqhgkwrklSxbBpGo5TGGJbLFVmqWKyWPUslOpenSRoZISIW0WTPNpBSInrTP3om88U8NMTcb6VIU0nwHdYLOqOZzZfkWc7J6Sm7e3usmopltYxPdtMR8MgQcYo1XfTxaDqG06iVX61XnM6WGOM4OztFEnjm6afouobZ7Jw0Tei6bnv/zbKE0PtIbDwlkiRhON35QM/jDxx4J0ly4YzYd7o3AEtKtmZp8ecL8H0ZgF/+2vxuAzlC2OhUo55RCkEiJaQpQQowLesmmoClWUZCRqpzgnO4EGL4e/CkKlJrlda4NsaDtU0ddRJ9b3M6mbAzHiIlLPtc7M4YvAuYjbu68/hE9NQKQEhG4ylt25CLBKRhUdWUecpiuYYA1jluXbvCIjln3XZ0ThJYYR2YntLaGcugzOKFayK1saoaEpnQtR1NG53Wm86SlyMGgwEPHjxAJzlKa4ROMDYwm69YVW186BpL25k4TfUxIsFYR9c5WhsNIhKt8MHjnMEQ2MSchRBIRWw3aq1Je5dRHwOa+zzki/FBAeOfpMb78lA9M+EyrZywyZUMW5r35W7+9vvtORyB90ZTDKFnGGzAXqzgXtD1Lz6/7N87hNBTkiNou0QuB+S2GxhXvyVivauDuxF2+BAnORH3X1QBBQElQThHt16zmJ2RJDH+JgSFkBrwhIhpaF2M+fEhOurfuPU0/7N/9V/hn/0X/nlefell/tZf/y/5j/7iX+Tk3l1UCHjT4a0jz3N8T2dECNC6LxJ48GG7X6SExEmUB9d0COf57Kc/w2g8ojEGhMY4g0LwJ//4n+D73/oWv/e7X2VSFAwGQ9bLWfz8puWf/Md/hf/8//2f82u/+qv8T/7Ff5FubePnCD2k68G/JxAuGZiJPibvSQ3ak2Pz98t6tXctQ9/lvvSai3O9FwlcWs+mE3Txavrz5ce/7kQQ28LR+zVUOkF4j5ctSWopCklmxzEjVVR4H5BK4J0gyEBVgBgn3Dk55eHtc7R3jDx466lFh042xAOFsgHnBV4BxImz8JFqGLsdvexiQ+UMAd/rJowGKwPCQbEMLErFqgx0ElKluHEzBVkzHue0rUOVlnRU8lNfvMZ0fJXzozkvfecNDu87ZnNPkmUMJ4HdG45MQD68wvoHa4xxlEOBSiwhKO7evc/e/hAhPXmhIu1aBbq1BZkhlcBZQ5ICTqCExil49iNDktxz9coY0zXcfGbK3TsVjoprN4ccPqz48EeeZe9gRFtJvvXNH2Bbx9WrE4q0IEkTDh8+Ii3hbN5hzCNuPp1ycHOADI6j+4aD/SG//42vc3i0Jss1V68nXL2as15alrOa8b5ntfacnFQEYhfk2tMpO1cD41FgcXxOElLu3e5o60A+zvjhN2+jZIdHMDnYwwTLujqj6zzTacqgVAyGisOH99gZTSmLAeNsh/OzJc5FTb+QkuAjrVkIg3eW13/4ENMl/MLPf56/9s2v851vn6FTRbASESSp1iTa8/TTO/zUT71IkXtu3bzKN771TQ6PHQ9uw2gn6qxv3LhCqUvuvvKQID2mfn9ptHmeU9c1w+GQEAKnp6dkvSv06uFD8tGYokw4O41a0b3JhNF4zPPPP88430e1KSfHM06O7+KVZzpWTMZT/HJFCBLbtpwdPuRwVPDHf+nnGe+O+Nt/99d4dHTIIFMYnVO3DV0TwZIQMXps1bQEBFkStea2bbl1/QapjAklna6j87qIGeGdszF2qiyx1TpSmi/NyTZzPCEEV69cZSUdJ6/8AGtAOoGzF191Zfq5oIpOzKNiq/HegDqtdaSrzytmx8f9cxFUEBg6zs9n+M4wnUxwtNx56x32JlN++Rd+iY99+CM8unuf4wcPaTtDGA6pupauWoGO5maNs1FGZDryLKdeN5i6RipN8JBKRZ4VZErjnaN1jqIckDriuQhMplNO61UfFQZ1U+P62++GLi/7aK6oG41NI9V3nlOlYzxXz6h6svG0mRNvngVKKbquo67rbdZ2lmW0bYv3ERxPJhNUkZEoxTjJOTs/o3n4ADkebOPLNpFim2i2cjAgKwu8dX02coMPcfubumEymVCljtlqEYsLSfK+XiM/7oj+RcT7u3iPgvMWdEdpKT4WVEOI9xFnLco7ghD4NKPcu04YX+MHb92lNh11ZxDeUdU11jkSDTrRKBHnyXQGZywIHen2vkSKhDxNUTp2fAlhayi9cbtPhSTLC+qqpulMLBwVxdYEUARYnc9I8+gPkOU5tm1wxqHThGI8BQJC69hwyHNEogjGIgVIF1jXNc2qYj2bY7rISjLWInTCaDLF+Q7vDWenR5SjEhE8p4uar373Nj94+SHWwN44jyZmXcf+/pSTxbpvtQSatutdzEGKpGcaR/M5IWXPfBH40BcUhN8yDaTcSBdFZBmLgJSONNWkiUYKS+fg6PSM0WjMcrliMBxy89YtjOvojGU4HDMYlFhraGrLlasHXL1yjapqefvOO6g0Zzye4Ik+IQJB2za88847aC1p2xhX2HbNVnKhlMSrKOONc1NwOBz2Az2P/5EA74tMycep5OJS6+9JoP1e4/GO6AaIeLyzsXPoPdZ0BOdIQkCnKVbESbwJglxn2K6NVSwd6ec+xIiBREtcn58YnEXJ6NyYFyXWWfDxd9YakiR275fLJUlWxHiHECkjeVHgnaNpO0ajAc16TdM2NHWLcYEsz6PZXJLELO/WMF/MmS/mDPKMujU0TU00gWixQpOkmjSVKB21FjqJtHnrPUonlPmA09lhPPlRrNYts8Wa9bpl72BEZzqq9RKH5Hyxpu08nQ90DoRKECFQdx2JEORZSpJklCg6a3C+AwS+fxD4IGJDlXicfK8XSpIErXXfZ+ICbIofHwT8UUDlYqHNGfPfrw53fCDESqyIp8IF7BUbUH7p/A5w0fbeAPaL4pGQql82RuvJ/jWXTR82WqdABJ5xjRcOmaGnqG/21LZ73W/ZY1dZ3NALc6rt2ja9wyjt2O77AMFZnPXgHXmiKYsCpRXOCoIP206s7uUHAXqzNon3jvPFmkRLPv7pT/GZT3+S/yjN+LVf/Vv83Je+xHAwRCnBdDpmOB6gg8AAVvSGjD7SzLnUfc5krIo2ztF4H/NWywJhPPT0OS0luI62WjPME26/9Tpf/tKX6aoVZTHg5OyMm9evcevWDV575WWUig8NFyKw6/dSfyz7I/zEPmPLHvjRXe3t3g88eSQ2p0T8N4TturbHfXtmxYJj6Gci77ptbgo/7/n+7z02E733a+SZYjJOOV0GVk3DZGBJSkc69HQrj/UKicBoj52Av5YjgmfcSXzlsULiCoEfOJyUuMpRSgg6GrO5sGFXuK3kCCLVzXsgiKh+6c9lGwIhVZTPDDk2Feszg68DTS05Wluym5rJlYyPfXgHKTq6LuHb3z7FojgTSxbecP/uPaTV6FRQ1ZCg2BkKBkNJ0I6qOcT7awyGBVZ1qFQxmzWIYDis5ty+LUjSGKE3HGl0GtCkeCPQaULbBbR06FSzWndkpeTgZsLujqbMPCcnLcJ3zGeBW88JAi07VzWNOyMtdjmfrZlMc84Oa44fnrIz3edjH34W8jn3D++RDS1P3RpTDFuOH51x5VpCmpd4L7ly5YDDwxVZ5rl6NePFD93i9MSxrh7Q+panR1c4OWo5PjzmxY/tMBxbbKfQIueF5xK+9Xt3IYE8K5DKkqYeJz2ukzw8PEdngIRyCOVAEbzBdI6zY0W3XDAsxyRtynq9Ji8zHhw+xFqHkoEsz0h0YHcnZ31u0alnuiP5p/7ZD/HKq2f8nb95n3rlGY4EV2/s8uWvfJ433/4eDx6ekidjXvrBS7z86iNWFdRtQA8C+xPBa6/eZ2+4SzZUVJ1nenP6vl4Dzz77LIvFAqUU8/mcoij46Z/+aQaDAb//zW9uY8akqLl+MGW9XqOk7p11A8FJrAkYA1mWk+icyXiPJBvw4K13ME3Uv1frOev1nJ/93E/z6U99jL/3m/8Nb7z1Fp2XCK1YVRF0tW2HdTHHORBNUBWxc1sWBblOUUoRAiRaI3rad2MNbdtEbw0pOTs/JwiY3CjYmU4ZDoeUOoMARsaCg+2p6zrQJ6i0dK2j7KOtsjQhTRKcj4y96XRK0zRYa0mSJAJ+b1mcHkcpXdvhmw5TN1tWVFOt8d7wsY+8yD//z/wzvPjcC7z+0svMT89QQTDIC87wWAJd8IgsQfkMaQVd19K1DcqD7wy2aQm+JVcJSZKSCIX09E2VOBnfmD2laYpIJOPxmNOjI0xrkEmM9NLE+VIAZE8B95t7eYjzgGg4rHv/or5psZ0SxAxvIUQfX6ZJdLw3V1VF6DujG513NL/VJDrBB0+zWhG8Jx3vkox30TpBDsttxjjAYrHYzs2TJEE418fgSpztI+R81IhvCioxKir/wM2nftQQ/XNucz8Xl1zOLyjl8QcJfYNhU9TwschLpDyLfMDCaR7dPsYHh5RgEdTrGhcCaZbF+GIpIBhs22E9FJlAhYxgG5yROJswn0WTL6UEw3FJkgjKwQTvYxReWQ7YxLs5D0mq4nWuJZkEgY/HN3iUEhjTohIFicRrjZMWqXUs+G+8UTZsVMBay2q+YHZ2husswQVUkrCuG+q65cHDR+zs7lMOR0jh8b5mOpmwfHPOg6MVrYGdYcYkV3TGMBwNOVusUSpGOwopsV2HThSCGF1nTSw2pWlCwMYUHi3I0pSgNPKSD4Dom3Fa6dgk0aD7Tnmgx2pGgIdHRydkacqtmze4++A+Dx49RMjA/v4BSXKd3d1dsisluzu75HnGalmxWCwIcs3u1RsMh4K6jg3VTfFrNJqilKRpYmd7OByxWi2pqopBrjGmpaprgg8UZcFyvfpAz+MPHHhfpou/u3u9cQAW7wJpj2m632NcAIP45a2J+dreY9uWEOJErfd4pvMBF2TskFgPwZMlGkSs8EmhCS4CWWtr2rqi7VzsrCjFoCwRBNa9aUhg052PF7vWkVou++qoMbGKOd3djZ1zG5it5tRtC94zGo+RSNI0wVhH0xryNOlvJBGsuNCDWO8IqL7aJHA+IL1H6wStE0yIevBhWVI1hqOj460r6NlsSWc61nVD1RpaG2gd2CDQaaQNZYmkTBVlkiCI7uU+CNZVRdMKWhMvdKQEH6LLel9xlH1MRZblPRMhXALHP96xfHI8GRfx3uDlJ9/plpchU08Jj13Yi8KSeEJGsTU425RtiShdbv5OdGCO5dwnDAeJpi9bzL55c9l3Dfv9Hnw8OJt32Czug4+RTSLwuBmXYGvz1XcVLkB3pLmF/m8X12x8nTMGfCDRSXy49K8RGy4YMnbNZczu3h5PuTmdAsvlmukg56d/5nN8+w++yYOHD3jxxQ/TOsvvfeMbpIMhXmusgFYqqqZGe4+tW4SIeiMpJcEa6Dru37mL6Qx/7zd+k+z3/wCLwoVA8MTuq2159PA+P/ezX8SYjp3JAG9aHh0ekWjFf/sbv8G6qsBa8DGSKn6uC8B7wWK4LCUIl47t+3eGbngJl4/n40f2wsjw4nePW+c9Nn5UzUq8/8yUnR3Js89MGK8sL7/ZEVJFWhqe/ugei/kcWzlUAv5qwmliMXTkBsa1RyFwGeTXR9T5khsfntA+bFh8s0GpgA8OEWTvdUCMn6Kn4BM76AKB7eluzgeCEpjgcKamngjaQc7q3PHg3BASSRCeQjecH844etRx755jvvLozLN7RSJDy/Vpwfnxgg994gXevn2HG7sps+OOUUg4ubOgzFO0O2FnJ3BWB6pVR5ZItHJIFZ3STRfICs/V6xlIS54MOdi9xeL8nEcPZpycrvGiQSYxq/X1l8/46c/eZLw/4O7tOT7U7F5R6CTDGU2iDUePFty61ZIVjhtPZ1y5KpgfebCOtmqYna1YrWA8zEl14Lln9hFKMJutmC9XVHWLD57xOGE6TdkZ3aStUup6zbWbB7z00tsoeUxTCYJ3LOcrFjPJbNaipeTW1YIbT4+gaDibx4mYTDVtZbn51IimdcQwy+grsjhvmIw1znqqpWaUZCgKzk/nTKYjAj6C7baJE9JUIFPD0y/uMZgkBGH57ne+y3LWYJ3mM5+d8sZLa6xzVN05v/u1b3Jww3Ln3px777xBs/QEFRCZQg891sNibiiLjEcPzigyz+SqYH///Z0WTadTiqLg/PycpmlQSvHKK69so512J1PazmBMZK0NhkPqWcN0MiF0NfXS9x0chVIpIUj29g7YTTIevn6bs+MjskTifcd0d8zDu+9w5eYN/sf/9D/FH/zhH/Kdl17i7qNDzmYLhsMhqIzWzlCyw/qAtZbxZMz16zd6w6kiapb7bl2R57RtS2cN1jnWdU3btVTrNTqLeeNFWW67tFprWtvGbmnT4ERgmBQINE3dMWsW5MuawWDAeDwCIRHCvYu+vFlXmqQgora6rmt8a9gdj6nmSzKV8KEPfYg/8ce+wp/85V8mWMvL3/8hd95+h25dI3x81qyqimVTY0Ms4ngRTUO9jCkfoe2QAbSQ2K7FaUEQCqwD5fA2NhiEoAcP0RBSSMlkMmZ+dkZXNygRPY08EdAGGc2DpYo+ORJQ4iJWTPWxulonSKG2N+wkSbZfg0EZDYJlHgvxSrGzsxMLJyHEPPXeiVmpGPW6rtZ459jJhwwHQ/Ki4KhexMScnp15eQiidNB0HePheLu/8eD7HHdrLUVRMJ1OP3DzqR81tqkbl5oXF+y+sNV/+/5Tbf7vAyACQmkar2jlgEUtmK1nUOwwyAts19A5i/GKIBKkktFnSgSUCqQyoERHqiQiOLq2Yy3BdA3j8ZDhcIAPlmq5ZFjk2LomybMoJeiZHEIIyrKIHW1r0VqS99dOkCImGeU5pq5xPmCDoxgMMN6TJnGbpE/BGHwbm4im7VivVlus1ZmOJEkRSqGSiC8SF1hXFUonNE3FaFxyer7i9TfeYb2uSRPJeDwgVZ5EaWZNG5mCfaECH2JT0Xt033CIhQYdJSPexu5171/R9DGDgjh/DQqkD2Q6zpmiCWD0U3DOslo1pEmJMZa06bh77z5d17AznfD2229jfYeUgjxPGQwGFPmgz95e4EPMu9dZNB3sunV/PTjSJGU0GrC7u8tiMafr4rl/fn6G956qWoPXJDqjbWMyglQpWfbBMjr+kQHvJwE4sAUh76Xh/gf9DqKDngg+Uhe0whmPddH52xlD56P7cRBR651nGWVWYkKgrtaE4FEEWmu3nXPfdgzLkqazNOdL6l4L0LUNGk+e95p1lbC7u0drLNa6Pvu7IQiBVgpCzMo+O5+hlaQYDBh0jrquYod5vSIrBqyrhtYYjk5njMYjkqygs2vKsqBdrPHWgINKSIq8xNpA1xmmg4ym66jqhtoEVJojdMrp+ZyqNw4wrkLrDqEkxoGxsfhgrEPoBI/q6b/RPKrtOpLeZV6rhGFZMBhk1G3Lcl1Tt6bP5etPHn3xcIhUktjZvUyv/u86kf/R2m3x2D8/yaFEH8Ueot0XXFRcLzY7ZhcLIEixNcuLf4qu/CKAkPQxehGMxyV832WNmpqwLfewBcJSRi227w1fIoSOlPL4cBLb4pAPEtc/pvwGiPQmJfENe4O2vizfY+toCEKfCt6DTYToDc08TV1jraccjPrictRehw1g3fKXI5SPEY8SEQIOkDrHozi4cpX9/f3oLuk9q2rNf/Z//U8hiU6zMktpO4f1AdF15EgG4xGegJOxM7E7GnNld0q1nvP2a2/RaYVIchACpRKCd2g8rmtipdZ1/Jd/7S8zHk948PCIT376c8zOZzx68ICDmzcxXRcdO/t4jIvOcg9rvUf0NGYhN6WYC8h72QDwx7oSLhedoNdGxc6J227Be77w0vfvLmButuHdS1x6VQjvO9X89skDDmdv41XCqpVcH15DqYJH7esk012avKF1a5qBxAyjqSPBkQTISokfJsiJZnEMk9rz9Gd2ePDqQ0RQJFYijUAoiZcSJSA419834vs7F2Iag3eIRGMIHLeC8k6A1LPeCdT7GntDUBI4Owos3/Dcvt+Q5I7BZIfGrFDKIkJGVRmqQrFoFE+/8BEW1RmsU/7cL32B4OGv/M1fY7GE69cDw5GmDimLFUiZ4DpL17ZM9zO8i5Q9hGdvf8yjew2Ls9uMhinrKkZSujmUk8D+fsL+fo6pBe+8uWI0nvDln/85Zos1f+uvf42bNyc8enCfDz0/5bmnR7z+5pqj+wuyPOPpF8Yszzvu3H2Hs0WNSBzlQDOZDNByxGDsODo7JhtInn7xGRbzM27dGvDw3hm//VuvMxoNMCFw7akh02mCacB2LVev7lPXNeumJi0S8kRwNFswKBOu3Ej4yKev8earD6hPHevjwPQTJeVYc+/+Mc5Ghliu4eq1hNmsRqgawYRUDRmPJIv1OVonRAMlT3AB7x0uON56+5hbz0+5diPl+9+vUUGyc8XxyU8N+MpXrrJaOpZ2wXqhOTmb89nP7fPFn3me/+ZXX+f+nYoslSgFw2GGrRqGw5SVrFmvJUmuSO372+24e/cue3t7aK2ZTqdMp1Nu3rxJmqY8OjykcZ48zcgzaJqO5WLF8nxFtbIsFityvUOSpHgPbWOo647JZJf9csDHP/YJXv3ht1nMzrDBkA0yqnbN/qP7fOLTn+Lnf/7n+OwXvsDt+w/5zve+z3d/8DL3Hp3QGY91bDXeu9MpVw8OsE2LLAXBhniv1NEJe21qNIE8yzg5PwMpeOrWLcY7Uw52D6jWa05bS5fmeOdxCqyxmLYFpRiMS/I8Z7FwrBYrTo5PmU6nOGOxxjCZFlhjefPNN5nuTBkORxhjWa/WLJdLRIBESoo0i1Kl69f51B/7Zb7wuc/z4Rde4GA64vZbb/K973yXk6MjTGdwzvfnaMORbViYFgekRU7rLV4KpNaUgwxrbOwWq5Sq18cGF3WroS9COO9jaoiSsZlRrZAixsSWeRHd1n1kKookGjRF4C3RfZSVCHHeIDeGwlIiVcxJ1vnFdFwpTZJEtkFZFlgDRTYCEXXk49GYs7NTrDXkeUbXtFTVOhYGtCLLM8q8oChysiylLAsGwlLkec8wcER/tAu2lHceY2yUQQTi5/ds3eedt+TDktF4uPUq+Ec9HuNj9bX9bY2//9ezKZZv4DgoAi54fFIyawJ3ThtqIdHDgkxbCJKmMXTWE4TepjBpKUkkKGVQGPTmGRNklIJaSZZGx3KtJFKlSAlNU5NlitAGysEYj6BpWjb2qF3XRfO94PDWIKTAWRtzvr2jWq0iqA0Cn7ut8bFpDIlOCMYjXaCplrT1mqauqasKnSQIrWhtTG/a2dklLwYs12ua1qA8VK3j6P6M20drREhoVi3jQRmfkxKMtTHqVSgCsk95ElEG5UNvfGi3DaWu6xDS90lVkYHQGUPXpxJsE5oIZEmcFEoh8C7QmrieujGsWZKqSKXXYsDJ6RlJqrh16yrruuqlLWBMy2K5QMqUujbMzldsHPqtszRtQ6IzppM9BB7Ttdy7d4+7d+/QNDVFmWFtlLoEHzg/XzIcDtA6w1pYrWo68z/wOLE/GnSHx3/+sUH3ZhIZnSadNYgQUDKC3hi7FZcxzhBENGCSUrOuanxfuTVdQ5GlJMmAREusgXa1xjRRpzEaDvDEdaY9lVprjXOOdR3d71yIGXa2n5h7oUizePK0rQEhOD07J88Lkl7D5LoGbw1SQJqk5HnJarXi0fE5SZYCHq1ThoMCM1sQw2ujA6L10cXdGEsIgnI4pJqtqKqGuuli/mOaY2w0X/AhGkIURYkTGtcYlJbYALbtos4+VSy7BukMmkCZ5+gkIwhI09jB933FMz6TQjQISS7MPJz3WOd6WnV8yFwGz082uzcT483vn8TXF7rZd/FnI/z4gDTj/zBDEnrf9k2Xv3fdFhcU34u8ZgiO+ODuvy508GHr6LwBDe/6dOJimc17ETaPFrGtLopLy0t/UQ8WIoLhHl/HYyQ3nfAIszexYRdvvtmQCJg3FPmwjTyDrm0xrWFd1SRpFvOVe5ZJIGrDxaXV9mvqXx/Pzc53SBSDwRDjLFiLC57pdJf//b/1b6DTBJWkpKniu9//Ab/2N/4myhhu3bjBl3/hF3nuEx+NDw0nCF3N/+P/9v9EkPNv/G/+bdJ8EqMH+xgRLQXr+RH/wV/8DxBKkZcFn/rMZ6MGc7LLm2+9yb/5b/3b/NW/8V/xw9dexxmDkDICbDZ6u83+8b3E4PFz9OKU/REn/R8xLkoUl/dU7MpIH/k7l06b7bs8vupwsQ7Rsx8unVSbycp7jfe7njVzJzy39zS702t8dLzDdGePxbLhhV+6wTjAzetjXn/tZd648ybDccZwd4JvPKe3z/GdxuWOpz+xx8889xR/5ze+xvdeqig/9hFQirT1jLOSyf4u906PECIwStO+WBVNcfI0dhua1YrOdHgt2SmH3JxOmI5KZr7m3uwhpWuYr1tGQ8nq/Aw9kAhpSWRBXniktORIrt/Y5Xh2Shskb7z+kCB2WJo5P3zzB6Sd4PregNcfnfOD1xqSAOPdhLYNpFlMmjB1oPGOclhiA6zmgkf355gqUs/lM5qrT+3RmWPSTLF/kOA6QyonNE3A01J3htmspm5q0tJg3CKysZYVb7z6Fs5LVnOYna1wbYwbcsLzzDM3eOuNe3itee7Z55nuDKndCTod0pgVb7x+yPHRjGBO+dxPfZKf/8UpL73yJt/8/bf58p84YDTM+drfO+aXfvFLfPu7P6Q1sRh09UrKMA3Mz1I8gvmZ4+z0kEGp2S1zZoczZqenGFMwGU7ItOD87IiPf2LCzk5G+kDhjObq/hWGgzFn51EPfT6bUdVrAjFeE+GQwvCh567x7T98xNnDjI9/co/1Au7fP6du5xyPKm6/ZtAy5ZkPCc7vWp49KDmbv8POjuDkOFAUlp39HFNbQi1ZVDWjtKBTnuc/fhORvr/GUTdv3mQymcT5SC9nW61WWGs5OzuLfhghIHzJdDjh9NQgZcl3Xv4WtnV86uaQ6W7ey4kSqpWnXnvO6gXXb9xgNj/mdHHGfDZj/tYbFHfv8sJTzzD2CeNVYOfWNfae/xCffuEjnP3iglffvsMPX32TP/j293n1zbeQruFKmnI1z1lbi+4a8IFUeqyzpIlEZkPmiwWDJOejz77AZDphNJ4wGo8oVQJVR7VaU4c4CTbekTr4yid/mrLIuXGwT57nzOYz3rl9m5dfe5X1YsayqRH1Dlpcw3cC4RKESxjm0Wju/GRJIhTPjabs7kx49plnef655/jc536G0WCAd5bF6Rkv/d7v8vD+fVbn5yyWCxZNQxcEd85OqI2hRdIah7GG5axGJprBYBCvoSwjT4ekScbs5AwXZKSF6wSVZHQeXCbRxYA6CyjlcKua/Kxh3I0YDQfY0QjXZ7UnApzpSIwly3MyrRklBUhP2zS0TYvCEYIiCE1aOESmkMklDxUJaBOjmxLHIE1JcQigTFNyZdkZJPhmzjiXDIdjlLekWqC8xTUVxXDAKEvJlaBZzCgKxd60RIkptenwypCOBtEDwwuSVjMqhggbUE4wSAdoBKJxrPWStPTIwrBmhhy+d2LNBz3EEzOjy6D7otgNF3OXOD8KImain69b7s0C574gpCWJDdj1kqVVWOtRiSRNFVlWxA43McHH2GhyTLB4XyN9gslSQDMeJlR1RdvWTKZjdvcmDAZ57MJqjbGOcjikMxbTdtRVxWg8ifNp05BlKVVdo3Sk8zdnNfmgpFlUDIshfrZEpBpVKoQNmPmMerFAJzImJ3lHIhVLE53SkRLbWbAxYlP0ng0CRZZlCJ3z0it3uP1wxhtvHJMpzWhU0HkHWtO0NVLFho71DqlUlKdYyLMU6zxJomM+t4/MiETJ3ugv6qYjsI3pU1JIlNBoPEoGrPUYG/BOYPuCamcjlgtp9ChS0wld29G2HcPRkIOrBwgZ4yE3bGnnPc7C+WzGarWmHE0QCA72D9A6JctSZudnMTrMGYy1LBYLqjqaJ5ZlQZJmBOewNmCdQKoo1Wi7/4FrvLXqKbfbGd1G+xt/+qNN1Lj02njByb7L5n2MrNhY9du2JVGSPEmRSlOFOmoJiBUYEWBdVygpWVY1puvAGYwPZIVhONxhNBzijEVaR9VaauOxKNrWoKQkTxSmbVBaowVRA16WVFWNkIpFVdFZT9c0pEmO1CnBW7yLfUhnfaSi6xRQWB+LEsM8wzrLyWJBmqSReteuSLIMlSa0xmCCwvXd7lQpVJYRVOyEeedItcD2ADnPY/zFaDSiqtekKQQ83jVstEXBCYxxGO9wrgNrKBKFAEwXTaissbRriUwTkjSDzsRulIRU9bU7EfWvUanh6JMVt4UPEFsdymZszKAen+ZvzI9i1vVGr/meHfP/HnS7YdMh3ABg2GiJ4D2Ajbgg/4begdz7noJONFGL52lvztWvKGyKUxE/9b+LrxKbWICe/raFal5sjcc2FPXIs44bFgDvXXy6i1iVd0HE3M/Qd2d7R9QQehAdVN8Z31yjEiE8TdPSORcrmmlKFzwyWGRQeOG3AHK7EzYPww0IdIFUpQgEiU4ZlgOauqJpO4ajEc899wJCghaCe3dv8zt/91d5+fd/l3FWcPL2G7z0w+9w8Nwz/Mv/2r/OC8+/SFNVtBjUKGd8ZZ9gE4TQvcwkGpmUo11UmmG9J8typnt7jINnuagZ717hyvVrTCYTurYF59jouLed+81DXgQEF1IC73+0odo/9LnV77dN2UZspQlsUfaFM8Af/Z4b0P2TuGzmi4Zqp8Y8us3ylR9wfN7SCUme5Xz8I8/z4eIFblcrTl3H2CmaeoY1Fae5Z9lIju+d8xs/eJ0XX7jH8dmSB4crBqXFYSh1ivYJ6fkxS7NCJYqro92+0i5ROsGYmGlc1TVCCcY7U57a26EOHnd6iE4V7zxYcL4+o+4sVSsQypI4x/Vru5ydLbAIMIHlqsU6WNUBlUpee/tVBoMcrUteu3dKJlv2rhR8/NoNvv61RxQjgcwUIXSsFwbfSRIlaSrLZJrzwvM3eXR0zHzeInRgujegNTVCdjz34SnzxQLrXdT1JhmnpzO60DHdGfObv/EtVus5qI6HhzEmxSnB8cxQ15bxZIi1ltP5HIRmb+cKp0dr5icOj+HGU0+xWLb82q/+kMVyxc2ndrl2bUoqOg7vW5xXIFLmZyuyRPHqSw+oVpY0H3B4fsLx+ZrOeJQG0xpEOiDVmnxUM9zJuHPHcHJWUYqoeyxzjSTn7HCJzGJh7dt/OONgv2A8kQwSyWc+9imuXj+gq9dkWULjAnm5wDZrjFmTpIovfeWneP3Bd/kTf/I6H/3oc4wGGf/3//TrHJ6ueP4TJbLwHDydcvSm5fXvVozHKY5TinHHrRcL7h/WUbO8Bmx8Nu1MBpRas1613H35AUq+v5OuZ599Fucc8/mcqqo4OjqKk+7ejXoy2UEIEd2PjWDv6lUWiwWjnV3u3r7NM89dZ362ZjDMEXpAvao4Pj4jGRfs74/52S9/ie+/8hLff/0V6sWCQZrz8MFD7qUjhkYxPjtmsD9lsn+Vg8GEg898mi9+6rP8yp/4Uxwdn/LaS9/l+NF9iiLnkXdYa/DCkyWS0WBIWeRYGanSPnjSNKPIc7IsI0eRBonvHbW99/FZIAS7RcmV6S5ZotidDhmNRnz4maf58ud+mqZruX3nLrP5jNo63nhwyOH5iulgwkdf+AgvfuhFsjxnd2eHg90JT+0NGI2GlMMBUkhmx8fcu3OXe/fu8fD+PVgvqJuK86ph3XWcrdY8nM85nq/Y2T/ALBtsazGtwVjD/t4+WdAYA94aWtuQTiKVWyqFVrGBMRgMSRKN8QuMcHgFVni88BRFxsFkQioUbdKRJ0mchwrB7nhKPV9QL5aM0xRSicUilSTJNFmWMygSAlH7LkLcb5shZei9KTxSBRIpUS7OG5TwiGAZDXIWMwG+I8+GCO9IVEqeRN+ek6NDmtNzrhQD0jRBypxECYbDnCyktKFlWa0RWpHpgvqsRiJwrcF1BtM0BCGRAQZFzo0rVwgZyDRB6p8M8H6vsZniODasvIDs5y2+/7JBc24S3j5rmfscEgXBYILEqHL7aNWZRucamca5VdtZcA4ZDInrCNjIaFWS0bikKDLyQUGqClbrFVVTM3EjrIPpYERajpDFEOscKnWYumU8HiEI0Q3caYILdHUbzfayDKkkvrEkUtK1NVlR4NYVrmkQ1iAD2GbN/HTRSx9E9O5xjq6xEFKWi5qszHDKIfIOlWrKYsBqUXH/aM5pV/LS3bucVJaDq1NqY9BpTtNY5nVDMSxJrO+bPYq2i/P8VV33XfCYIy9EjP8UQdIYh0Sie2d5JWUE0QSUcJEtEEI0cHaezgaQGuMix1MLQdNZlIB1VzMuMx4dHfLJT34iduHrmtFoxGA8IU1zXACZpWTDIaVQrKuabl6R5CW7u3v4EDhfzHl4ckyepug0o3OOxrToRKGzlOFggFaatmlomhprW7JMkef/A6eav3fH+vFu5nuD7sdJlZd14SH43tmuJniL8iFeHEpim5Y0UYjBAGvNVouyceL2IZCVA7wQ2MYTpGK2WGK7jslwQDkYMDs7o6rWBJnHyWoIONsRXOxxLhcLhJS0XUfWxDgxF6LjYFnm1FXHarUm+IqmqZFS0bQdaZpF6giSzpkYU2EM1nZIFTvyIURtUGsidTjLc9ZtR91ZAhYhJUWiMc6RFwVV3bBerRBBMJmMqKqY3Zj0OaGj0YjBQHM6m5OmCTY4lssK4yWd9dE1WwsGgxFFmlDomDvoTAdSYVpP21Z43dNs+xtGlgjSXpOu0xSIlS+VRJqz77MsQzw0jxnrRYAdowY2QGXzd60lIH9kc3ALcP/7MMLj1F9BH40nLhucbajnEbgF3GMd5d5rPFL4fYhdHQkQ4xekiJ3abZPT+y3wiz5lYvvem/eRyEj9p4/dEpKtw2TwMT+eOImyweP7UC6/2dZNoauPK5M9Xd314C8QaYhKBLq2oW1rdnZ2ep2174+PYxPrFIit9c20QkBfsCAC+CCwnWE4GAAC3RvEZFkE5DiP0oLf+ju/hn30iD/zU58lcVA3DTNreOsPv81/8u//+/xb/85fxBvLOE0pxkMynbJsDFJLbJ/bGaloGpVkvPLm24xHJVLQu712fPTDH6csI+0quMim0UqhYu3s0h1pW2YnWmnLx4qLF+Nx9s4ffTpdMIAur2Kz17dre4ItEr/fnGfv8R7isn2buET9f9eC/8Bt/IcdNiR853uPoDbcvJEjU89kPKZpGr7xze/x9W9/l8W5QbjA7oFl/2pGUZa8fc8gfc7RwxXrU8P9t95BaIFIJcv1DKE9Comp4jU22CsZjIY8tCuOj45j5ImArjIorSkHBc47Hh6f8vD4IbaDLJcMh0PmiyWtWbNee3zQqNShVeDZp4Zcvz7ih99/nUSCEYGd3R2E0hydnpJkBau1JUske9d32Z2kLBczTg4b2tqTZgKliaacIeag6lwgleLk6Iyz0xlSBbyLApBqXZFo2J0MsH5NmktmJx07O2Pqhca1BUeHZ1SLhqbrUInGC8Fy0bE7zQjjgvOzOV3wHExLrl4ZU04S3nr7jCRZcfOpp2jblnI85mtf/y5f/8Y3cU4wKDPq1YLkoOArX/oiX/+92/zOb/8B77wz5drBFQ5+akLnTykTTWdG7OxeZzh5iDEthMCjBx1nouNzn3+Gp18cU4xGPDp6E3usmFyZUk/XfPrTn+Hv//Z3OLhyQDqoqO/MmJ93tFXD579wlcXxiutXnyIvBwwnY8bjMbfvHaLTnMQ7jK2w3nJ49JBi1HFwbcRiteb8rOPpF3Z5/mM3UMWadGCZpQ2JC6xmFZOdMUeHntMzQz7KGe/nHN6vaFqLaQTPPa/52Kf2mOQH/Prf+DbzoxYh3l9X87t3726v7TzPeeqpp6iqivl8znq9ZjIZUQ4G7O7ssLs75ej4kAf371NVS9qmYv9gh9npghAcy8WMMiuoqhVN6mkaxc7OiE98/OOkowE/fP0Vzs9n0DlSC4vTM8bTnPHeiOs3n+baracZ7eyT7+xx68qIg2HCJz50A5mlNMslp2enPLh3n3t373ByfMxqtaYoCyb7V7HG0LQtXddF/a8LtHWDCUTDM2Oi4ZgQW71xLC50DGxKWC/xIqA7RV3VPPfMM9y6+WUme/ssXeyWaa0ZDIeU5aCXrwGmQ65nmK7j7PZ9Dh8+4vT0lKZtODk54eToENMuaV3H2njWzvHw6IQ6wKQo8U0XAYt3SO9QwVNmCcJ7RkWOMTYytayl0Iq9/X2W5zNsXdFKSTocUqQJiZAkSKQPOOtQMpqSeevQUpHphKY3Y2vXNYlQDHd2GeQlXWhRUpDKFJ/EfaNFNB62yhK8iF/9OaOkRpMghCQRKVpqVIjTdSkTtE4Zjcak6Sl13WGLaCKVDwtGoxFWCYQPmOWaNI0611p6Eq3xMieRgrE1GO+QiabMSh6YBoUkzTVFmRHwvY7ckmZRTui9R3QWzPt7jfy4472Zr9sfLr7YzC9izKQJmqPKc1QFKhkQviNNA0LHhoJOFEkKaf+V6BgXbF0H3iKI/lHSO0ot0VlG2rNTvXeoLOPq1WvoRJIXJWma0XUOS02ZD7cFnfF4giRgTYfpGkaDEW3bxogxHYGuVhtjxRjbZk9PKcqCRAnq9RpCoOtaUh3ZvWlWIIhz7nVVU60byjInYPCtQ7iMQGDlKk7OF3zv5bf42psV9446rl6bxLhUqWi7lnXdkGY5bWfxPrBctyjdx+s1LQHQPS3+QioM3jocAoPrpbdcNIRcn7QTApaAcTb6V4nNHHRDwYtsPqkFjTGM9QjTOt66fZeyyFmvl9y5fZsr168xne4RSMmzEXVtMcHjrcU6CMYyny8YjAZY78iLHC0Fi2VN0zYgAh5PVdeRnm4MTdeiEw1YJIE8/WALS//IgPc/6O/voqH/iJdsLzQhSNMU07poFmEtOEuZxGgFnakLu/6+klgUBUopzmbnvfmZi5V9pUEo1nWLEhlZmjIZDTlZVJimQUsYZAOGZUZnfaRtO4/QseozGI6QSuER1F1HnpV437FcrkApmq6FLsZ3bcGmEHTGsF6tIu3de1SaRn2UsUgh4gUp4rYb56IbuhA426HTDGsMD07PaduOohxRFgUCxXK9QkjV59RlKA2DwRidBfyiRtWOuu6IHleSMh9SFBmjQYmS0DYVTiraKhqjGE8MnO+jodJEkyUJSiuUjlnlGwdOY8w2Pu7ysNY+Dix4XIaw0YZsjvGT2PoyIPkx1bIf+PB9XNamSyxCQGxMMKSMx9WaWJQR4qJlDVzuAkeYSh990WuqRYxcQESzqCB7EL4tSG1cwyOQFr7f3z0VfEPx9my63hKB37ql09PTg91kh8ZIs1gwuNhEQaTTS28QMkSTGNHnTQZLMDXV+oyDK9dIJWjnI8AORJpzb9rWl1e2n3xrShYcSBU/d5KiiwIXojlMmmjSRNDWhvm65off/x7/03/yV/jwwS5H9x5Q1x1/67d/h9Ms4ezkkK5ZohwU3pMJhRAKpOsLCpsOtUAnGT/zsz/H177695mvGoKP2ts0yZju7DEaTQheYq3Hu4CWekvl3+6aS0UkLh3/zTG4QM6XAPOPHGKzsy/OJS4lePesuc19I/Sn0haEX1r5Jr6DsFG3bZz1L/Y/7yoXXdqS97ktXnUdMknJkzGvvzXnxrMpyjUcP2ywpkPmGmcCiRRIMs6OPaenc1aVx6zXDIYp3hmkhiSTCJ0QpAfp6awhyVOsd3TWUh2fQQjkeQ6SGB1TaIKD+XKJkrGYcvxgSTnK+OSnPst0Z8RyfcZscchbbz6krhzBSqy1vPy9N/jEpz7CsEipV5H+/OILH+W3f/vrrBaC5bwhSSErOuarYx6kCe0KTg4t1sJ66djZGWObEwiWrhM46RgOMjJdUq07qnpFtGmQjIYZn/jEc6S54ns//AEEh04U3gS++83XcF1AqsCVvV18WDNb1GTDDEJDtVozP17iLJR7kus3bvHmG28wnGYgHEcnx8zOFnTrwOHJisadMRxLbJvwx//Yz/GDH3wDb+CbX3+Nl753iBCC+3cWvPGDc55+LuP6zRyl4PDhA27ffkjVWHTmGA5iB9YpydHpDDVwHJ+cUq0j+2qxWLBadZydn3L16gEnJ2f42QrnBFImXL1WcPhwxjAZUA6i0dZ0Z4+6bhhPdhjMa6q2JklTpA4IPWDdGJZLx9d+53Wee/ZZ8nLKpz75Gf7aX/3/slrULM4Ef/JXdnnhQ9dQcsLvfvUtbr9tefWVU4physGVmMBQVzXjccIbb7zD4Tu3WVeWGveuKMz/f0ddx1iug4MDrl+/zr179xgMBly5coUQPFW9pBxkDEc5SSoIocO6hkeHD0EGxpOSoky4dv2At+8c4oJhsTjHDAVKjfDW8vTTTzHYm/Lg7IjT8zOWbcXdk0MW8zm7o5TyoebBvbtcu/M2V27c4tq16xxcv0FeDvEqQeohqQw888wtbt68xuc+/1mcddx7521+4+9/jTdffY2DK1cYDEqEDyzrGmMsxhi8sbguNjiGwyFlWTKdThmNRjRNw/HJIXcerPj0pz/NCy++yGQ8Ic0LNAIVAkhJWcS0F7SmqSrWZ8fkeU4IgWYx5+zNNzg/OeHk9IT1asVyucIHz3q1YjWfERJLbRqWdUvVWXKpaeqGwSDFB0GeplgpaQFrJYmNZna7Ozv4PEBWxu6mgI8+9xzLyTmr8zkKwSBNCUrQBYHyoHxg3bQcHx1BayiLAjmImdeJkKgQGBUlu89O+PCHP8wLLzxPNiwICtq2pW1amrahqiqOj4545/ZtDk9PaN2FYZkOCYlIkTi0SFEiRfUsQCVTlEwZlGPSpKCpG5yN0VGlUgyGQ1SZMyoHVGdzhsNhZFYOSxrT0dYW3xvn7e7sRsPJxtCZhulgxJWDXZ66eYP9vR2Wsxmtt2gpUQgynTJMc7IkfV+vkR9/vNfcL86HJL2xZoj0QB91lBAUs1XHg4VjZhWtEAjTkXYthfdooUArdCKjGZ+TSLKYJOQ91niESOjaChXAeAhE8+M81X2udUD1uv0kSSKlW8SYqvVijneeuq6YjEfYrmN2doZSkrIo6NoagSfP0jhHQ+BdjHqz1lFVa2zXkiYa5yL7NvhAcAJFgpIJq9WSJE0oBzlFUWJsgyJOwbTxWANr72nFgIcLx9FZy3ic0xmDcZ7J7oBqPifJFF5KbBuzxhMdWRl11aGTlM7Y7fQheI8PYWt4J3tM1vXRXHiJ1hLrOqTSWONweFzMqEUK1c+r+qYVgTTR5MWAIDWLqkUJQWfh2mSKlB4fLE29xpRD0jShbRtW65rX7txFJwXPPfshkJLjszOqukILye5kjLOGOkvJ0mgu54KjXq/IU40P4IJjUGQUuSbYjqI3nv6gxgcOvDfj8kT1vR3OL5a7+Pnxi2wDWqOOOSVRilQryjSnWixYLxdY1SKVQDtNUeRb0K1UBKJFUWCcoakrgpTRRU9rZJJiuo5lVbMzKNnROYtVzShPyFLNdDRgNCjIygk6zZnNZjgP1geSNEMoRdU0DAcT6tayOJmxqGqcswRnydOEto5VFe89WuuYs+djlrhMEtqmRfd6Lx9CjD3YUISROOcjtR7BoJzQNE28aKY70FPq66aOmgqtaduWLC/6W1LC2dkx54s1q3VH5zw6ySgHI3wQzJYV5/MlQsUqlJQChUAh8ULhfNTRayXJkhg34r2PdBIVAfhGd+x6F8wnj9kmUu69Ios2oDvGVDze8X7cZG0DGn4SxNnHR3RGvWThIS5036rfXOtj55h3AW/oSeaRVn4Jp3khe6pUPA9ccBCirOByQSNc+i9GlWyQm49ulCFqzkO4cCgXAoKUMduy77JvY076zZBiAwJ7M5hemyNSiU41QihkgFRq7tHRNAsGw6eYDkq8k7hwCeyiiA7rguhe2297TwVz3hO8I+BRiSbJUoKPN/3hcECqNE4pnFJ86EMv0C5nlNfH7IwEA6V44cou33/9dZySBNOxWlXU6zXF3l48zzYPBTbFnHi0/vSf/bP8uV/5M+BdBLnBEZwn0xl13ZKmGSLEHGUcMbrs0n6/fMggHuLNJw6XD2Z4/N7Wf/jLXJ7HNeHh8l/C9td9DYZNhNxm/ZsiStjkvvdve0n49jjO3rzu0veXPgXv99g/SFnODId3DN3Ko/QY2zRMS0GaFpxUDelVSZlnrE4aUmAoJSFIzjuLaTrGe4Ldgwnnp0vW67qngiqkTAiul62IKI/QLkE6Sds1iCTE3NvWINJYsHAhIAM0K8t3v/1dRjuSolQMRjk3bhXMzj1do9gZl1SLmpe+/To6SWkWkmq+5u/86u9SN3GyUgwTskJTVw7vJCet3RopKiWo14LjB8vYme8CaRZZJctVR6siPc91KkbUa08IjtOzY9I8wxgoigFPPTVhOrzCyf05zhusDbzzxhkUAbJARkeeJwgrSRJLnkvateOtN95mtWhZLQ0eSZYLgrfoVLA7FNRVjXeaTCvWs5bT+4G3fniHgys7ZGnJ0dEpMoXxJGaLr5eOD31iDCrj1VdPaRtHmmlODtdkqaQYJDw6XPHgqAMUzz1/g0l5Rqhz7ruah4f3Wa08VdVGn5I0RaqO5aIh1SCLhjRLYzRlmuJ8YP/KFV574zZtZ+g6Ry41qzm8cadClYY3X11T5HPqZsarL73Fo9uGG1eucOP5EXffOmM6banqt/j05yb8zJdf4G/+zTepVjn1esXZcU2iPIujjmBjfNJPfeEWw2nGfHn8vl4DGxC6Xq956aWXWCyiu3SSJJSDgqqeg7AMhzm50+ztT1iuzkEExpMh4/GA555/miYoFtW3qFcVVb1gZ/dZdvemYGMn03nPZHeHbDjAdYaVN0gvWR/OyDQMz+dUbcu6WnN2/IhrRw+4efMmxc4Bsm2iq3W1xHtPmmXgHNViRrtesZ4t0EHQ9TFguUxiYTjYGE3adXjvKcuyn9tEY7OqqnAEumA5Wcz43O4Ow7xEWodOc7AW37WQmMiqWteY2ZyuqqjPHKenpxw/fMj83l1Ojo62EVjOOVarFUIIprtTvvCLn2cwHlK3juPzOfNlzYPDY87ma1ZVhU5ilw4gTVP29/dJ0pTJZEKSZexevQFSo4Xgyu4+o3JAMA58QEnN0resu4a2qumahvnJOVhHlqTkWUYkbP65AAEAAElEQVQ+GhJE1J0qpbhx4wa7u7vkeY4xhtlqSescbdtwfn5OMAJdJGTXcnbH+xyennDn4X1msxlCxNz0UTECYJiNSXWGCIqmabbO0QSFUhmmq6LxrrGxIJ4kIKKG/dmrN9gvhjx8+ABfx644IWakD9Mhy2pNUuScVScURYL1DXmZoDUgLWkqwEqskIyKAUoEdvMBB8PJ+3qN/PjjCdOr7bOtB94S8NHNRkiFQyNEwum84nDpadMBTmUI12JtTVdXICUy1QSlYyNDgNcGdEIiAkIBOiWYgvXsjFJn1MaxXFeU+QjnHGmaRpmk91u3+SxLUGlOVzdU6zVFkbFazEm1xllDkZes5vMoEfU+drHTtC+KaOpqTZJosjSJkbKyZ0JISa4TEhWbb66L14JSmmJQUlcd68pgug5TeyajkuNFw2sPZ7x1VnHv3EaPlLyg6VoGoyHrpsYEh+18TAcJkqbpECpq35M0x/lAkmhSJWgacyGEC5EFm6YalST4rutjY+O8z7hoPtwZG/2BRHy+bxqsSkZWWCokWaJi9914pPIkSjCbzfnYR19AS4OxDUU5oCgyhJAxNswbbPA0zYrFakGeWs7PzzBNwe7uFNsZZucn2LZhVOQooky5rVdUiYQ0xdqOxECZJUiRID6AudDl8Y8MeG8A97uild7V6b4MvC/A+uVuaaQqRzG+kHGdRVEQnKFdVQTjcY3FmJhbuKFADQaD+G9Zsi4HWGNItSKRkiAlKsuxXcu8aiMYERCcIUsLxuMR164ckA+nnM9WCKEw1tB2Hav1/4+6/3y2Lsvv+7DPSjudeOOTO/f05IBBYIJIkSBlkCwSpCyWJVeZFuXwwv+Dq2yr/EZlSS9kFWXLLlk2VRKpskwShAJAApwBBgMMgMHE7p6OT36em07ecQW/WPuce5+eHnBE9sxIq6r7Pvfec849Z++191rf3+8bKpz3VFWDF5pNa7lYbfBIXBAkOqUYjfC2i/b10IORgJQqmrT5GCuljUElkqbpcIRI+3COzkbDDhUCJk3Jk4TNagYIjEnouujiGXygaRsypQkh6rVni4rzixkXyzVlY7FBIJQGKVms1jStxXobQRABpEBpSZEkDLSJm1ynwUenRN3TqV2IToKJMbRNE10jt2dOiF1kxgcN9j5sbnwwFzJ8CGC5ZEL85EE39A3dvtoKkWauhNwBJO/87ncfLNR+sG4rhHgGUF2FcK7XXO8czcXl3wwiAu/ofn2FkuzFrlPqryxWUsSsyNglD6ieRi76+DG1xYZ9VVJpTaEUWgFGQG8mJnwgMQrbdVR1RTEokDrOZYXEBb9dCuNc32LIXpceQiwUKREjnBKj0SphkBesLi4I1nF0eBSzSpsOMxjyS7/01/jK3/tP2NMNq9kJL964w63DCX/8U59i9NrHkT5wPpux7hr2lYwOnIFItRbxfcd7ice1kYoshIPgkSIgg6BtGkwCq8Wc4bAgS010nA99VjuhN6OLZljbaSquAPEPmeHxPPjdQbj8Tf9+dk7cW1zdn+MdnJaB4MPVfUb//CvBKTvQHi4fsy1yXQHf26n2YXr0j7rbl0hJUwrGe4ZZV7Kc14wzyUBImnW8p7etBzpEYjFJgrWOF2+M0I83TA8NQrckWUcxzbFdwqPHM5o6QJA4G7vhSmts3dEsWpp1i0gEiTLYEDNCt/EDQgWGWlIMJQfXDEJYzk8qnjwoGYw1y4XFWajnHc2mI3iQKsZFRqJcPEZpqtg7yHChA+GoK4mtA1LD0VHBZt7QrB3LRUVqNGmSII1gs4l0vcNrA4Z5xsP7F7z86gusNjMuzte8+eYJWSFJUsmTR2sWSUtXPaLtPEEGVJZhBoouVOAU5dz3+jlP17rIYlKCzaomOIV1ljRLaEqPIHDrVs6d5w/41refcH7RkEwMv/eV1zl9VFHVFmdPQWlMHmdRngs+9dljXnz5gNFkwJd+/SucncZCRtOAd5K2ClSyw4aANJqbdwrOzp4wTDIePdgQrGQy2ef06Sm2A5TGdiC85OyxZTSWjIsI4rLU8PT8jNFoykl9QdO1DIdDuk5hjOd7dzd842sr0gn8zM99ii98/hPMlnf51X/0Lbomo6py3nzzCcVew7XbBVJrmifn3LxtOL6e8ztfmbNZVjQbx8F0QFN5Xnn5Fg8fvc/Z2YLZWnL9hfYjvQbu3bvXd7cDg8GA4XC4i/scDAsuZi1KBZyrsTbGcx0d7/OZz7xCkWUkaXRhz3PDcJghgyNJFXluGI1yzh6d4TrbA/kBo4M9cpMwNCmFMLz/xvdYbhpm1ZKLVc3jkwtGRcb+dMzNG9c5uv0CBzduxQ51E+UDo9GIqqo4efwA6T17w1G8rzcthujCbYQk14Yus4yGQ7SJusgtENmy3IIUdCFwMjvnm9/+Fq/cfo79YoRdV2gPznUsTx7RWstysWA+n1NVFU3TcH5+zmI+J9iO2eyC5XLZG74Zbt++zSc++Umee/4OVrWY1LBncm7evIM2RUzxcDFmMx8arG0j3b/I0Ur3UV4aoRSbzoGIdPFUaXzTIbyPBdcgaBMDRsfYL6Xi+gi7tcXbCHqFlAglKVcrqrJkNVtgbUfTtLQuxOaJV0gnsC2ooBmkQ25dyxgMJmw2a7IsoygGl+Q2Ir08oGnqhq1HzsXFjCK7y4Vb0nUe3VfWpRQ75s9LL79M2nnOz89otvsAsd2fxIKJSgxVVeJ8Q/CBJBGYROB9g0lEZNNZS54kJEIy1Rl7MvtIr5EffnxIx7snAooQoreNuPyZ6uOwBsMEf97Q2rhfiuu5wgdP17YoGVAyYThI6doNdV3ipUJJjUky0sGQed2w2ERjvFQHFIZRYdifTHcyEiHDZf58W+Nsh/UW7yzlqmM4LFjOLhhmGa5uaVwsJKdpgvCO1XyG6Y2c0/6r71qCd9FpXcTrK01SNBoZYLGaY3TKcr0myQocEvSApxctigFvvXXGm/dOebSyvHu+ZuMC16ZjTJpSdi1OCpomGrN1VY02hqpsdl4/sWEWY8pSbS5/JgSdjVniRmuM1ggR42N9CATnaTsHfcGbrdxUiF3kbuji+VIChkWOFIK6afuc8A4VQPiGPJEcH97CJBKpNMPhAETCanXKw4f3YwEiCE5PHmFUSls1JGoP/IDgOwZ5RpZoEiPJM81isaCqLCLm5eG6hjo4FL4vLHy0a8AHx48lTgw+2Ml+VvP7YeA7DvEM4L46tNYEFw3FnI8APM9zhAs41yF0ymazxnvPcDiMWpq+4lnkBaPhkKoswQd88JzPFkSXZRDOUeQpWZajpGI0GjGZ7FG1lvOHT7iYLVjMl9HJXMQ8R0+g3DSsq5aLTcnGeoKKGy5d5CiTkqWRhnHZ9RWIpkEbg3fRDTBNU4zSdL3LX9s2MRevtRHICodRAq22lSbNcrWiyHPW6xUhxG46xGB76zzrdUVZW7ou+m4nWUqS5TTWU9YdjRA0NnY+Y5MugPV0tsUmnkFiyJM0mtHEWmKkhmzjpJoGISXK6GfA9tVz90FgfXVc1XrHOdDThK+MZ+fAB+mx//yxZf+io5+1kSEgZKSzBnoZg7sEQOLZLv2HszouUdwOQO9we59N6XtKeN9Fj8+IuaGyb8MGIXaBZCFcAvbt62yV10JAonuat9hmRYe+E+4jbUprhI9RI17EnOQQIkWwcZ5yU+FDYDgYU1UNXdf21fjte4v52cHHgg4+4s7t51JSQ3AI78lzzWc++Uke3nsfG+J7y1NNtY6Fm6OjY37+T/w89dO3eO2nPw9Nw3t3HX/5L/4C/+T1d/BBsG4tXkpyk5IjscpAP5+CEDs2SfAuLtZCEnxkpRA8SZKwWM54/Vvf5FOvfYzJKGe1qmOxaVc0CLEwJNTl2QuXsWziyrG+epb9lfMbY962buNxwxbJCmHHHNmRzcVllFvgShN9KwsI0ZCQSwJ//KzPvAtxuSEhxqM92z3YciI+2hiNB+/VWK8heHQiWS9LygvBXq4QJgrBcmMI1kUvjLqjGCX81B+7w2tVi9Qtd+8+5OlJQ9cZFosFWkuSicI6KFcW58HZWDySRoIEZSRZnuP6uDsvLEJJssTwV//VL3JwHHj44IIv//q7nD1ydCtYnzYkgyjkL6sWoQNCC2zn4mYjF7Q2OqAqL8HFqzI1mspabr+4T7la8/heRZ5qpJaRfSQ1125MuH//AiUU1lsePZyT6ngff+ftuxSjlNWqQunYfW1lLMQ0ddTSKmVAdgjdYV0gWPANBBcoxglp6mmlZ70JtM4TOoNWUFfQVS2jvQwfHOWm5MmDlsFQ09QKITsWF6c0VaAYKpIkpW492cBwfCMnTzN+49fu8gdfe8onPnMTaVJM7lBpoBhAKwNZIugaByL0xV+Bd4LH9zouThpGI8P9eyc898I+VRl4+GjG+UXDZE+RpzmLs5L5ecNqsUQIR9dVzOYdaZ6wf7hHVVcoUVBuzvnUZ++QHFygjKHtVnzrG7/Lau15dFdx9rCmXM345Bdv8Oab7/Ff/4OHfO6LOdfuwMMH59y/u6QoJOcnsZjV4vCt42I5Ix14NqsV3TJBJx/tpms2m5GmKaPRiOl0uktGsdbStjXDYRHZDK7FB4dJcqZmhBC38dZSVWs6W5Ek0dBJEshyw8XshLORRkpNlmYMNAwnYwaTEQJB0znatmKDoRjvkaUJTb3m4dkKFeYUT055+PSM5+YrRg/ukyQph4cHHBwcooiZ2eVyTrVa0jSaNMswSkUX4KaNaS9JSq4K1k3F+fk5vjd1NcbsKLhSSbJiSNCSb3/3u2gXKF54BdlYEgTBWc6ePuRiNuP8/JyqKgGYz+dcXFyw3GxY24bxdMr1l59nNBpxeHjIjRs3mE6nBBlXwNlsRtuek6cDJAajM9JkEGNdn5xR1Ru893GPpXVkk7nIrrLaIKRGC4lBxAZDEJG5FgQlEqcu9zc+xH3jdn231vaRk5FZtTXOCyF6C6m0QOkUKQTTwRTlJSu/jokxwiOFxaae0Hpsa6ldFSOmevag9xIvom+Pcw6lNNev3+LP/Jk/x5tvvkmzWiJDpCErqcB5TGLY25viFhtGoxFJEqi6hmbd0VpL691O4heNpVoSpUhSQ16kSClIk4xOQLup0VIxTnOmSUHhv5+1+GMZ4o/4tpdhCQQyEN21sRghOZhm7J15utpRdjXgsNKBltjO4+kYFI4knUTpWVXiiCZ2snGIquPJoxO8lzg0nYs573VdY53dHUfV74m7riXLMqqqoalbVN80asoSoxSua7Fdh9SaQR5pzUZpZJ4jiFjF6Fg41VrhrKepKtLExO1DsHgPUnjyLGNdbjA6JUtHGKN4enHCO++cce9pybwOLDvJRe1ogkIpKIYpi80SkyU0bUcQkrrpkDoWvk0Ste9SaRCCzrakiUJK8G2H8IFiMIiFG62RQmB6NqbzAetClKb6rcFu3D8FKeg6C4T+eZF1qWWM39uB9uBjPGhTkSrH0ERwPh4N+t9bTk/O2axL0kQzkVC1lrZcorIBWsJycYrtVuxNJuyPJwyHA56ePOHctajpiDKJ2C0xGh0yvHd9BKKj+oAh9Ec9fmw53h8Ez38U1fzy62WH+/tNFWLVRRhD07bxRtd2FEVB29YILciylM1mw2azQSm166xa20btgbXYtiPPc8bjPcoy3vA713I6WxJs12s4PK1zdG3H6dmM+WyFtZY0L9BJinOOzlnyPMcLg08ymsWKddNEqoYPLNdrRnmGSTLWqxXD0Sh2iV0AEfUlUsX3hPNorWiqFhug7WKMFyGACigJFxcXSAFdZ5FGY62jaiJFVkkZtVc+oLygaRxdFx3HtZHkxQC0ZlEuWLcdwiQEownOE8IlrRWpsQRa59gbDgiNQIuYW9x27U5HXhQFaZrigo8W/z11Zksx3567bcHhKvPh6ly4Mmu4mtj4weKN/zD67k9gCKKbJD07QrKl/Ybe4bpfBATxPf/At3rZ4b588ehgemkyGEGV2wFvECJc/l7KHcVYCHpheNQdB8QO6EbM56HvsgohItDuz4kEhFLQZ9FLHyvjPliss3gBBIH0AWRg3V9bR0fHtK3FB7GTGdDfcLdu38H3OvWwjSYLBG/jJ7eWtvY8/9zzZEnKarlGK4WzrpdsSbI0p6oa6vWG+QVMi4TBUPFbX/0SNz71M7z0sVf42ndeRynDnWs3MC5gEAQRjero482UCASh8MFG+YRJEUkC3pIYzb//7/0/eHLylH/7//x/IthoDELYGoTs7kpxUyXkjsrve8C8PSfPRJ/sntfPlyu0ciEv57/vPQN2x6d/ors6f3aGeoKg4t+8tLzvu+t9C946t5tZO1O14C9pYru5t/39R1vAWp0ZrPAkRcCkAiUDde1Z1g46qPt7skrifHedwQwzXv/eI9ab6DA+n2sePagILqBTjzYQgqGzTSwaoWnWDhyIVGAyidKSpq1oKkdwDqklrrPkI8N8fsrR9WucnbWUm1ikUkOPawW2kYBDZYE0UzFmJESNHF3Mk8cJmo3l8XsbhnuGNFdMRynVqsRbmI4n2NqihEeKaDYYQkdRaMqmITcJtva0a0/ZCdJhhykMX/jp13j/vXepykC9chghqdcW3wTwNhqzEWhXDdh4bQ5zjWocwgumk5iVuqoEWsrolNxve3QiGE0GKKfp6pLVugWvOL5lOPzEHt/42gnrlWK1bMmKjHJe4fdHvPSJQ6QvePjwCd/81n1uv3iMlx3eK9IkY28IrnNc1Gu6VmKt5OxJzSBPEcEzPdR87OPXWG8c737vnLzQ+M5GCvTcMhpJrt3McXX0MLk4PWez2sQi93yNEIEsM7iuZX9/n6eLC157+eP85m99k3fefkCapySDlqNbhtm8IdtXhHRJWXmef2mI9w1SZjx9VIHVaOX5+KcGPH1gWSxL9iYFTduQJvDTP3eL771xxic/+dxHeg2cnp4x6DepbdtyfHwcfQiIAE3ogPcW8BR5StrrRp977jaHe/tUixIlYW9vQpJI9GTA9YMp0+mEW7dvMk72GO0dsJ6dsDfdo24aTk5PKXTCC7eeY3h4g1s3XuITH3uFTMH89BHnT+5z9uQhJ7Ml8/V3mI7HHB0fUW82bJYrJpMJVVXx4N5dzk/neDWma1uaqkJrQ5Ik5HlOUeRorXZSsu3a7lz03tFak+YZIgm7Dfz9e/cogmIvG0BjWS9nPLl4yOnpCavVKlKz53OstSRpwrVrR7z63C3Ge1OyNN05p9fCM6s3SAGDRICUhOCoy5o0EUjX0XYlVko6v6Gp4r7N1tHUTPRVUiEkdeiL1z5eV1jXM8L6gt5giu/1rpFlFmWA1rs+TkkjEDh/Gb3ati113dC0DV7EjrUxhul0SpZlpDrFibhX0jIjyweMiqiL76ztc7U7utDS9G5ViUlofEO5qQjhnL3pHp/59Gc5f/yQJ3ffRkoV/+vX1aau6aqK8XhEpT2L1RLEOoL3RFMkUd6ldQTceruSeYfUmjxPUMGz3ATapkUmOcqB634yOd4/2BgUPDLug0TfXBAODQRhybUgDR2ZkLQ+rnrWO2xsktN5x2yxRioZs6aFZrXagIfBSHNxfkrTthxOJyAcOs12DJau7Xb72uC3e14Z862FYG8yZjGfI5UiMRpvu+jpJCWD4QDf78Watu4p6jGqN0mSiD3aBq8UQVuM0YCnq9t4b1MK6yK1fTjaYzarmC1Kzh/PMT5FqY6als5oMpUgypa8iL4f+SCLclYXmC8qtDEEERA4pPBoLZBa0FmPVNskHGJnH3qnfNk3MOK1FOWvcf/nQiBYF32ptjsNIfvmTf87HYtZSRL9snyI+zUpANeibMPLt4+5dTTl2+/fJYRAXkTWUFW2vPHGOyiVcuv6Md4FZvMNxWAIQlA1FSaBul7jBwV70zF1teH05AkCOD46oqpK2sYySBKqusY5T9212Ct+Cz+K8RMB3h+m8746PhSIx292G0sBsWvTd3270NB2LW1dIwS4xpJlKcPhiK6/Ac7nC0ajEUKA7SxKx26Y1EmsAHYd3jnW6w1KQKI0AYUQmsV8xWK+YlPWSKXRytB58DYgZUKWDvFJQOcet1pypBRqtWa9KWnTDIvibL7AKInQmrIsYzdSxk1S2USDDIvASR0BjPd0PhKFlZC4YPFSkGY5qVaUVUVQKnaLlMV6j2+7aIJgHfW6Is/j0ZJIUq0QiUEbw6ppMcUAV8/RInbvbB9XIYnxTSJEqjEummuYLMHZBqkVQsVsxM45qrqOunCldnrv7Wb/g+f/g1+vzokrM2B7xp+ZLx+e7R12C+iPe8iYDs+2q+tFzLVVoW9MbzuNP9SrPbugCHr36Z7WvO1kxmi27Wv6K9r4CMZDCL2+3O8A4Y6i3n+vwlaTfgmA+wfEr85/gKkg8f3DhNyauHmUkjR1g+0c48m0l0uoHnhvu7CerVmeCJJtJNnu0woBzhKERylDU9d9l0Tx4PFjytrhEXRNQ5oZstEQNR6zPx2yunjCwycPeem1T/KX/+bfpJOG4CAxsRgkBeCjfru3mQP6qriI8WkEgessiMCwyPjNL/06v/5rv8q/+bf+LW7duE5d11HLSEBsGQwQ2/Yhpp9vp6PcTdtw5b/Lsoq4UkyK7+nKYRcfwvy4ch0oAmHLItl2r2Enydj9X8Q8din6v6v0bvZsnfZ37zGEy+dt32v4aDve7bpBDWIUYld5vIwSgKo/N/kgRSrDYlHGSnnbsTwr+St/5WfJsiG/8l//DmfnHcVY89wLE2znuX/3grZusJ2I+mjlkE2klJqhQBuBtY62jfnPUseilEGg8Nx97ynapLzzvWgChgSdSoQIDHJ49eNHdF7y7juxg5cUAqXitZAkA7ABZzqU0tSriiIxFHnG+cUa4WG9WhA60NrQVh0dgfUwGu7s7U04O53TWY/RKW1bo42mbRpOny7IzAiZdNhNRZIoqtaCUxActgbR9mdKARKyVDIdZVhbYlvPeAw616xLaBtLmguEgsW8YjAu+PSnPkkiE/7Rf/NlrO14+H5HphV7x4bWd6xXUFYlAsl60fDinU9RrV5HmJzx/h51q1gvHLZtEdRMJ0OkAtdJEp3iXUOiNB975QVmZ0+oKnCi4ex0RpIUHOzd4NG996nLjjQTTO5oXnhpn0dvl3jr+epXvsZ6teL67dtY59jbm+BCR71ZY5RHLQe88eZdvvyPHxKE4Jf+jecwgzXv351hBhneat59+4I/94vPUxSGxWnFw3da3nx9zY07KS+9nDM7CzQbS0rK4qTlaHrEpqwYHQhe/GSCSj/axeQzn/k0zz33HKvVaqd73l7no/GILB8wn5+jUKTSQOMYpSl50FzLpxRpih1FdtrxL/4ii/mC3GiGmUEVE7wesukCx4e3KcYH3DqMrulPnjzh0f1HDJ4/4i/8hV/k+TvPsVkuqTcL8lzw5OR9vvQb/w1P7z3h6WzN6bzk9m3HraA5W1Q8PXnKkyeneFkgtCRoBUbTesdmvaT2HSpL0EpGN/LBgKqqaNt2VywPIUBr8XWNSBIGSTS/fXT6lHI45unDR5yfnTK7ON05oSdJyv6NO6Rpyng8ZjAZkx/soROzy0Cv64a66o1cpWSQRUahNCm289RVg8SiZI2UguHQkOeDHf293q4zMkZqtkFince2Hc7GIpCkXyMQ+NWqTyZQZHlGZ23cb/a57DpJ+1Sa3p+nbz7UjWW5LFlVFTZE0HKxWVEUBcPhkOFggDAG2zm6DoRMSVJNoKG2DQiioamtqKslzkZa+OPHT7DWUuQ5165fYzgZMjg4YrkqMVKRth43W2CXc8rlAqUUg2RAkhZ4taAWDV3bQfAUQbA839DVmsF4RLUJbNaWa89fRxNoaSBAvbTUwlKaCrofbc7xDxqXTMhni8QR1LHb0wjRy6YCgGM8yPn4i9do3j3FBklLwAVJ56GrPbJneFwsSvb3R4jg6OqaVGmKkSHPC9IkwXuL1KHvGhcIrcmHQzZ1jUlThIimySYxbDYrjDZ0bYuzHUYJ2rpis45NhSzPCD5KR3Vi2JQlWmt0kuKt7fX4nuAsznYRtDuHFFFT7b2NEqvS4qxgdrHh3btPeP/+CatFy6J0XCxq6iCwsqOqHTJAqhPKaoNKU1obaG3sPredRUpFkmoI0bXce4/tbPSQcB1KxWtCybgmCeGRfYJS07bUXe/vIyR4j8PFPUiISQBX542S0bNISxF9kYgA3clAcB2Z67g1TvjY80d4X3Nydo4Uir0gsTYwGAyZTies1iWr1YqmanFe0NRrqroGAlkyZphnSOFYrpfMN31DNDgoLTIE6rLcSZDLpkZ7ibvcnv1Ixo8NeF8dH04rvxwhhCtg5cq/+41pCFtkE7WtWim00Uit6WyNCIIkSQFJU8dFwLsQabHOY5TEaMNomFG10fCiKTfYptpVao02uM7hVeDCrUh1RV3XoA1SJQSp8EgaJ3AtDPKEJDUMcs2qqSgAMchxdcN6tSGgSBUYoxnmWTzxwdFUGyTQNR4vYkWzrhpQBusDjXV0nuju5wNtgMZacqkIXlA7R5EbVpsSISWu84TaxoVApXghKIoMSdSy6Dyn05pZ3VJM99CLNb61IBTGpHgbdQ4xq1uQao3wLYQWKTweh9IpVoBONGmRMRwNMcY8U0jx2wLJtqt6BTR/2DnfPubDwfUHijF8kAFxdb78GId/lkq8ZVRsvdSkiKB8C4S+b1wBvc9oa4VAhCv68Kujjwm73H1fWXzCZX56BP5bB315RVsdO3hCxHzFqC+O4H5rxgZ9zvYOfEdta5BXurUi6g67Llb2x5MJzoc+LvwyD/zZ07jNBIdLqvX2OgYkdK5DmwgWZ/MFf/AHX+ezn/ssrrXUXcuNV1/hH/3mr/Du6wty6Xjh+Rf55a/8LoPn/jH/k3/1f4arWrTSeK3Y2AZQ/bGPHYropBmizHpbmJAKrSWPHj7kP/6//8d84Ys/xV/7a3+dpvU4Qp+vuvUIv3KapCBsmSjbSnxfTd/a7l2e0ssYr21H+9li0yXgjT8PO3XCtqGtxPb76OWwNVqL3fNL8PyM+3p/GuOrh2gy568C7m1hR/TT66O9kkQbSMcKgafcBMoG0AGbgzLgm44gfCz6GQ3KMTkY8o9/4zvUm5r5siHJMpT0rNcN49EQrQ3lyiK1YjAxiGC5c/0mRhvW1YaziwuslwxHKWW1IXiNUQptPMoIHj6oePLobWbnbfQB0PEzDyeGT38u5ad+Zsqqarn9yiGJ2OPJo1Nm5xXD7Bp5scd3v/VNMqNZnLU0JTxZlMi0IskM+MCwSBHSU68dfSMT2yjqpiFVBV3leeGFGzx5NEO2AWkkXW25+9ZTFIpBltGuo1TJdzHdIADBCURQSONIJpJ2E7jYWOq2ZDDQuADDwwRvWzopyEYZXdtSbTxOwGxW8xtf/m2GWUyvcHjaBr733TVSJTQNFGOBTgJNCUcHAx7dPeM7X3+I1xXvvbugCxK9zWsOUG9WHN8aolTB4wcrPvPZj3F68ojVYs7DBxeslw4hS2TQmKSjrBakmQAZ+PinDrl+RzGZKI7G13nz9TcJjaIqG/YObnBwdIROJav1LBr3CMtyOee9d+/z2qdv8vT0KXs3PJt2QUfL3kHK17+8wlnNN3/nhC988TU2s46Hj0/QJspiwlPPem6Yn7UYozFJoPMzDg6H3Ht/zvH1LMpOPsLx2muvsdlsaNuWvb09Dg4O6Lqul01optNh9JLwcVOsgmCYFITWcvbwCS9de4Vrx0ecnZ2RBIlsGiaTCUmScD5fcO1oDyk1CsX6fMXhcMr05ot87tVPR9MmIMkKpHMI53n9O6/z9nvf4Wxxn8MbY/71v/Vv8ujtp/z2V36b9x+dcL6qSIxhsVjSti3pIKFtVhiTcHBwwGg62VGgN01NUBFk13Xd06DVM0aqQgaMSFFCIUO8Zy7Lkvl6zXv33qdcrxglGWkezW+TJCHLMrTWSGNoHbBpMF1k09km/nd1r+A78F73TEaHEBJHoAsW4QK6jXdw1xOEhNK7Jg5EQC2DRKhY7G4/II2TKu1Zg5awoxM7bOew1tP69hkHzi3rywaJDXHvFqTACWicpV2vqPs4ryRNiVtx1fuHgDYZmYgGuc43DIZDTAKz+YyL8xOePnmI967vrFbcunWHfDzFLRcoPN4LqGuUtfiuRoQEHSSJTnAINl1H3baEzmJ1S7NpwCdoOaCqHOWmxZiM0DXbI0RddrSJpUNG1+qfwBBim68cDTW3K1iklPXyzb776sIlW1IGxyiVUDsyZaidi6atDsp1QxABpSFJJZunGyQehSNTDseM6XRAYqAr56R5glKWrEjIhgPSYoiRULUdUgQGRYp1lrOz6MB/eHBAkecYnWN7pq5JEoSQhCComhYNiDSNINwkuLbDlxvAkmeGkOi45vfNxtSkhGwbRmtZr9e8/d4D7j6+YFU5lm1g5aCWGtcJrI8Sp/FkQOktrXVIYaktrMvYmceDMYqm6VBK0nURW2Sm388aSSJgkBratkMEie2lFHVrqZroXq50LD6E2Mejw8U9iQ+9SZzAdhbhfQTdShOcI8VQ+5bK1xyPcl4b73Gce4pccP/0IU4ZutZRlS2ShKpcMZlOUFnGk6cXNE3L9WvX8NYievai6izZCJpmwde/dZeT2ZL1piRPFIMW6Fpap1GJJohAmphYDP8RI4ofS5zY1a8/rBZ3u319Bl490xGKWhfrHa5rd3nd2hgkkcK1pT5tHTeFEJjEILyL9HQvYre7s3R97Ji3Fheg3pQoBJ3WtK0l6ynlaTak6gKVbVg1LbPlhtWq2nWzkiQ6840GGePhgOODPR6fnNFWa1Si8UaTJIbM5CgJy+DYrJYoJcmSLHb9mo7QZyZuO447SocEax1ex+JDCA6CQvSPbzuPkqY3bxkgtCI1huA6rO1ITELZdjRNzeLpE1yIUTxSGZROok4ZgZLxIhQ46AFl6zqss2AtlhCBd5o+Qx/fUcj7yu9VmvnVeXB1LlydI/Fn3+9q/mH//kmPndP0FVpwz0q+xMPiat/yA+PqZ3zm5xGM9njxQ3rmP6iLvj2Oly/+rGnb9gWjoZnbgrsrz47Vysv3LAJ4L2J0Wo/tRBBI72majtlszmZTkWUFQWq87Sn3/XvY9Xz7DxO839HhdoUKBc5bgkjYlBukUjRNQ9u0/MN/+Pd57bVXUEpCcPxXv/zLzGZLfu6l2xxOBhy+8Cr2d77Hf/i3/594s8/TB4/ompZiNMAS+s8YIgONmGkuVd9od3HjUtcl43HBf/6f/+ecn5zwf/g//tuYJKXpOraAmx78xvPd42zv2C708dj0po/95NjmotM//vuB+IecV3F5XWz/7jPVnZ30gB6RX/n9Dk5/8EmR9RC1/z1Y/z7pQ18046MdeV4QfOyCpmlP8bMSV3lcEzfH6TBu1jtnSQeGYjyg6haoDOwcmqrGWcFq2XEiS+oyUqe1VmyWHa7uMN2Cpo33WJUGbOcpCo0SGThNVZXI1OKFpm081dpB0CgVu1uf/fzzPP/CgL39jpMn55zOWp4+2TAetHS2pG09ZWg4OX2LYqA5f1LSWoExgq5TCC9oNh0IgVSBvDBM9nKMdnif0TQdm0WNrWLu7vBjY37hz3+WX/7lXyV0EjqFraNrua8anA14LNGE0z8jP8iSJHosdB1eCpaVo+wcP/Uzn0ZlDtk95PkbOacna+pVwZN7G1wlaNaBLNNcnC+JPhogpCHJFJuqZrhneP7VEdlAEboBf+0v/XX+7t/5Bzy+P+fn/9wXOF2ccHpxggoJlW9JkpSyapEKXnot4+BAc/NGQdsozs8W5NmYi6cLDo9zRuOEg4Mx775zzt51wQuvTKnXK77zjZaPf+aQ65Mh779/l1G6j7Nw7+4DHj19ynR/TDFIcV2HTATPPXeL15aHfPanP8/f//u/wXe+/Zh0pLl+4wU2M0E+eI/H73VU8w0P3vkDvvAzz3Przj6rek5wguVZzdlZzeH1jE7CYCD49E9d485zU7LkBt/41tdJiuYjvQZOT09j0R52X7fO38vlkrqZI3FkSYoKMB2OCMFzcHDAICuoyop3zt7h0aNHvPrqq7z88su7/czh4RGjYky5aQjBY4zk3Xffpq4rJpMJH3vt4wwmU1arkj/8xtdQSG5dO+bwoGDVvEw2Tjg6usEL11+jrFv+4T/4B6w21S6KNB+OsF7gXDRArKoqduV0XPu3Wu5tJ/kySkns9gRKx32W947ORW+JztV0XcfewSF70z20jeZwO8du2HXcfNfRbdakLtJ7u77LvJW0+WecpNP+vv5sod4Ityt+f1DqBgLbd7i01kgpI+Dd6as9UmrazmP7TuTuvfX/WRfw4hKMXn3M9vg4wjNFibIscc6R5zlpUqBUunv+9n1sfYmc9QyHE46OrjMcTHn86JR79+/hnWN2seT8YsnLr7waM7ybCpck/T4ijhCi47aRCu8cm9WapusIXUfriHFhWQJCUFUVq9US1/ueSBnB0mq1ospSfKpR+kebc/yDhtylusSmRr8hgS3zEXFlP3n5PKUEo0EglYpsMKBabuLTVWA8MlS1o3YWV3fkeRqNUD04IVivSiQtqQocTjIO9sfsT3OmkwlGKdbrMubCE+i6hsGgYLOpOdg/Ik9z8iw631dVFXGJViRpTAZCSpLEoIwhyVKUknjrd0u7NgZjNK6zWOuQSDabDXmWYbIcKQ3n8ye8/r33OJ83zNcNs1XLKihON551EwgmwYqYWS6NpK2jhKNz0DTb6yaLPj7ekaZp75Ie51+axCKVUtH1XxsZcYYSGKFpnadtuni8gtsle2wNmGOCjegbGD0DVkqUVmRJzELXWiO8xNUtR1PN51++yU0Cvl2TDqfcv/eQ4eAa+V6GazqatsP1RtICz2CQIIQj+AatBHmucdYxGhcMBjnnFzOc7eI9SmukgDxLaUOUUKQEVGLo6gqkQBrDj3L8WFzNf1CX8+r4fkC+zbL9AY/tf6G1Jun/a7Wiqxuc7XBu23ETGGN25l7eedAxSqmsajwt1llEiF1apTXKJAQhaesW21iskTS2ASE4P1uwqGrWnWVe1WxahwvRMXk8GpMJGXO7ZctwUHDrxjUSrbj/4BGNVRgl2awlg8MDvG2ZTsYE1zKQQ8qmpW3aGCEWAspo6GKuaPAOqaJ7b910OJ2QJQbXWVwbtd2t71BSxQUsTbHOYbRCakmaJtEgSEvsqsEIATrBeYdU27TmSxq/kAEpPa5p0EQqc9fZ2CHtLDKJi2Saph8KoK+CzQ9KCj7Y7ftgV5wPQNX/IYHtq2MLTLfzNPTgauemveP7RrOPZ8cWXF12Ny/13FwCqqvPE88+V37gOF0RIP/Asf17O3j2DPDuz8+uthV2P/MBggs7jXYI0LWOum4ZjsYopWhciGaD/TG5pJT3Gedcbni2xjvILcCMj1+tlqSJwbuOL37h82xWK+6+8w5SCH7/936H//I//f/wv//f/Vu8ev2QwTDjjSenvH+x5GRp+fo3vsX8YkawjnK5JjUZlbOX9L8QO9FbQKxE1AQabbi4OON3f+dr/Pm/9Jd55WOvMl9scL6ny0vJNq7rap1f9+d3C4xCuDy6IYjLIx2eLSF+kAES//mB+R64YpDGrjsTu9vbKSAvWeP9S4grj79CjWD7F3bblSvTbHfmw7OFmI9itLQY5QmhZXKYUK4dbgmjQUFdNjgb70lZrlmvoVtbTh6dMTmKnYO9iWIRWjYbj9YZ9TJSR+kCZdkQvIBWcVIu0FlA5Y7pSOM2jrOnM1IlKBJDIi2jImU2d2RZjreOctWQKPj4azc5Pkr5xh+8hUkgCMvD+y1tEzg8dkwnGdDRdk+5dfuA994qEUoyOUgJNjA/q8nzIflgxPn5BakZsFpskKolyySutZTrro82a8AHvvn1N7h/9zFd3aF8zwzz8brxrosxfsKiZIibFyEIwhMUtE3AV33nI03phEVq0EVgvlrhhOWFF3NkcNxftFy/PmS1aBgNJ3ShYTWrSVLY2884PDzi9p1r1O2cwdjw6OkD3nljTVvO+Nt3/988ub8gH2pOTh/zqc+9ym//1orzsyX5MMN68AoWi5Lrtwxt0/Ibv/oNkkQw3RtRrR2udVSrCq0Fb50+onGWQmtMZihSyfHRLRJ9jYQhZdPxZHaCkobvfOd1bLAcXzvCh46D/QlCOiq3IE1y3v7e2+wd7vH6O/fINlPemj2i3DjMMEHmjm7j8EIwvXbAn/r5z/J7f/ANvvql17l+cJ1y8YCDo4yuXJMMMq4fHiKD5Vd++Us0NnD9uY/WOOp3f/d3yfOcmzdvMp/PWa/X3Lhxg6ZpODs7QeoWguXo4IDpS6/wysuvMDs9o+1aMpNx+8Z1JpMjbt66xY3bt6nXa2azWR/fleOD5cnTB3jnGQwG7O+PmS882giEsHS2RisYFSnjrGC9WIKw3Dy+BamibgJvv/s63/j26zw9nzMajii8JCvGSJOhXODm8QFJklDXNZvNhuFwiHORnhtCTDfZAm8pJVVV7QCmUJKwtdlAkCSGICRl23Ht+BpGCKqLsxhNeiX+FaK8w7tA0zX9UhqNp7YAuOu6nZ56a/b6wb2kEKBxaHWZtLIF9/0jwIVn/vYW9La9f1DbWeq63en0tdbP7Ges97gr9/CmaXa/i75CFtsb3yqlohFw3xQyJkErh/fdTiu/BexSRsPduq6Yz9ZonXF8fIOXX3oVpRKUlDx9+pT33nmfJM342Csv93G7Kdjq8hPGsGKMkAjrqdYbWmvxTQt1hxISnWUIIajrmpWKxsUqxDVQCMl6vaEejQijIVL9ZMzV5O68Xe1w+O0iG3H4VeZlv+9XwlMkDTcONJ3OuFhUKAKVs7z60i2CSfnWm+9TVS3eO7SQsTnQM6JC17G/P+Vof8BkVDAaZDhruVjPmQ4HBBt18WW5ZJAXDAYZo8mExCS01Toyc1NNkkVQn+QZVVVRZAVSyGhM5kNM6ZAS7yKjCxGNykIApTRNV6OUxiPY1B1VWfLkdM58XbNuA4uyoxWKWeU5KT1lC9pbOheYTDPKOmaGK6mot0bPovdlcg6peqmgiE0KApHNGsD5juFwQNf0xn/eIUQsCkgRE5ykiMe6F+HtDNN2167z/esGEi0psgTb1mSJwdtAruDVoxH7qmWkJKPrt1nUgXXlMGFDtSqZTvaYnc938yDRksO9IW6cc3Z2TlWWDAbD2BRUUNYV89UyekYoickjAxhimtWyLAlaU4xHrKuKpsdTP8rxY+t4/1Hf/6Au+DN9mw88Jkb7SKLzd4vtWgSgtIp5rn1Fua5rhIjB7kLEG++WhrJ1JFdK0Vkb/ayCjwsDgWI4oKlbqqZlUAyw1vN0vmLddaytY915rFIgNTdu3uLll17mD37nq+wPc1oc8+WK3Cj2RgXrcc5sWVKu16Ra0LVDlIhU+eFggFSa5XJN23ZY50CqGC0mY9fNWoeQMffYC4HWkoPxgPokZoV7b2jbFoTBGMOgGICQtNbirCUrMrSSlHWLElBkGT5J8Vh8ZXeGCELEzGOtopFPcI40T0GI3Q1AWI/RcZHdUsO25/KqJv8HAeZ/Np38+3vE/0ME3xKuAOQr4LsX7Yp+w/yDx6UB1wcfJbev9Szl45IJ8IHjvKWWf+hfCW7Hht5hvCh03r5Y3xmP4PKyrhUXNxUuqcuBbSSEpOs8dVVzsH8Q8xutR6qoQ9pGZoUQ3cPpNyc74zEZfQf81vVVKQL9ZgNoyg0ff/llyvUGHSJF+ne+9CW0g9Oncz794quUieG/+qe/zLmVkOYcXb/O+ewc6QS//aXf5PatFzi4dQvr4jLgw/YjxeuuczYm3GvN3bsPuX7rNl/8uT/OumppnUOIuAESvSnb9tj7EAsJrneMFyJmrIfdtO3hbX/yroSC9cfkssB0eVu7PHe762P7ff+3t+Ztl1Pg2VkTtyBXWEGBZ79eeTfPdPKvsCNC+GivM+sdOiiUjkyAtvOoLOCokTJ2uTczj1i0FMMMTIvdtDxeC9qmJi8Mo0kCOJIcjMhYLTY4G5kY0gS8iFGHXSMxmcbWgefuHHCwNwVXQmg4ebLEJKAODBcXtjeKCaS54WL+hMYJyrqhWyv2j1KmB45qJRkMDM5G/eedW2NG05rbLufe2w1tJamrlsm0oO4aFrOW4CRlVZIVMfJkPiuxVcDXMcd7Oh6yWZc479jM5+Ra9rFFnuPJAK0VXeeoNzW50eztTxgMR9x/+BgrA03b0dQ2sjcQHB8d8vjkCfvXh9y4vceRS3j0aMU3f+cxx0d3+Nf+tZ+lKku++c0/YDI94MGjp4ynx1RNRZZrhiNYrZ7y+OEFXQN4zcn7Ete2zNQJo8Oc0dRw/eYhv/aPvsrivEYmEpMG6jJmAqdHQ95/v+bR3Yaugiwds56X5GnC0cEBf+JP/ywPnr7FH/7+u+xfT1gtGp6+b3np+TFnp0vOH224ObnGgCK6KHeWb3/nu5g04d79h0wmQ+YH+5hE8Ojpfc42Jzw8veAX/srPMB4NGe1NODvraDvF4qwmzxPaYGmd497jEx49mfPuW49YXDSc3nsMVrBxNcZovvDpEaFueffd+/zcF17knfcfUC3Kj/QauLiYI8SCwWDASy+9xNOnT6nrGq01ZVUx3Utx1pGYmC+ttEJphSAmtaxWa67deJ7xZMLr3/0uwVqm0ymbzYb33nsPLRVVVXJxfsFzz91hU5a0bcVyecGDh3c5uH4LhWb+8AnvzZa89fr3WFYbOiMZXjviE5/8DL/7la/xjW98AyGgvJiTbirmmzo6sU8mfOrWLY6Pj5nNZmw2Gx49esR6vWY8Hu/W/S1Y3naKt13pICQqz0nSSCGXScJmvWFVtuSbBkOIAPDKWjAejymKAmMMj58+oeyaHeB1zlHX9Q6cbp+zzUY3fbdq6wAegmfdVUjBzgzWWrvrfAspQahdmkcIMYprW0RomhbnYxGgaZroON1L63YeK0rjkbv3tO14hxAoyzJqyqVAa71rBG3Zgm3b0HUeo7Pd+98+dwu8tdZsNpKz0zlCwOHhdY6Pb1KWFev17/L+3Qc8ePCAG9eOOdwbU6+XSAJn5+fgY6JDKnX0n2k6XNWQpgkdkWaf5Bmt64sdzuGsja7bsndo7xmkTdPE5oL9EYtgf8BQysBujbvsdu+A+AckAts10gWLEZbnb6TMS8NZqqiwpFpx8eQhPhtw69qE84voH6AVJFKRK0GewPFewuFkiAoO37UIkdK1DUWeIWUEq5PxiMODvbh3VhrvPHmW01Vr2rZlMBoidWQLaGPogqeqqzjPlEILSVPGYkmSxOafNhqlNV3d0DVNdB5HgIMnp2fcvfeYd997zKa2rCpHGwRtAKc0nbBYGYi+fLHL7H1LlkYDusTEuE0X4vVqO4u3Dt+AlPGYOhdi19sk1E2cA3WI3XPno5cBIeCtRaJijn1vLhcdyolGgbEbE61xcOSpYpQnpNKTakGmAxebDceTlKlyuOUFybVjRgeHvH86Y3pwnSLLmc/XPHr8NJpSEzg6PiRNFG1Xc3p6iggdIjiWiwvG4ylNV7MuPVXdxGasj139znYkKkNpQ5anOO+YL+aUVWShXDIrfjTjxw68/0Vfa3tDEr2Dtnd9fqIQyH4DDLFqmaYpWZaxXq93IHzrRLgFBk0b6dNGCobFAKMjhbFtO06fnrFeLplO9hiPx3gUd2cbSuvZtI4e6qNNxr/0Z/48f/Wv/hX+t3/4b9I4x9F0inJ1r+uT7E0nIDVt26Fk3FSmWtFaj20bAh1pkrLclDTWxkqbSTBG463HpAmtcDhnUZnBWccgT7l5NGa2qagaF818bCxECCnQyvQuj3HxsTZSxdLEYJKCs9UGA6RK9vmAcTueJQaNx7dN7BjlKW3XUbeWNDX4EKMaRqPRblH4sHP9R535HzQvth3Af9a8+e8rXfjRjL6z3xupxXChqxZaH+jcf8grPNvQ/kCl/soDrkZIQURilz/7Acf6mWMTrmiLr7w7ceU9Xn38lS5s2LqQ9w7eIYQ+qztuKpIsITEat2n7jPHt87YZ06IH2pE5saW/b/+c7TqEglQb1sslInh80+K7lpvHx/zdv/N3WC3mnD95gkLx+vfe5eDwiF/50m/wB+/c42zZ4evAr/23v8oLrzxHng757Oe/QFVVCK3wro1d+p7K7fusz0BAGcPFxTn/5J/8OkmW8d/96q/x2c/9VATdCFDxa0DsjvfW2T2a0PXH9koRIwLly69XjuSHnKJnes48e8YuT43v73vP1F12Dxa90+7lzz7IKLl85OXTxI4D37MfxPf7cfyLDq00w2IAVAjhMQl4G6lgjQ80lcLZ6F7etA2hDZFBpCRKZQTRsXdQ8Jf+9Gt8+5sP+L2vPEYIjZAOkwpMKpBFh7AB20ra0hKsINQLHr93wQsvTDk4hpt3Mkbjfd5974RUBUb7BaduQ1V25COFbgNJpgl1oG0s1QYGwzHPvzhlMT8hkCLVgAf3Vrzw8pTZ+TnvPt5AB0Wm2B8OmJ2UoAWKgA7QLEuoHIUPJIOU2zdvYpRkkRgIgWvX98kzQ5okBB/jGK1ztG3HarEi1bF499nPfY7mC5/h/oOHPHn8lNU6Osc2tqHbbCi0RNbwh195m/sPznj+pRv8S3/uT/KdN77Bb33l65yfnvFzf/wz1I2l3DxkPmtJBjWTgwFH1xrOHkvuv1fhHdHsx0DoetmDEyzmLV/+9e8QaijSIetNTWMsQnqUFiwuWmrXIY1Bp47Wlrim4drxiPF0yMPH7/Lk5JTxYYIlcLifc7CX8fDuhv3Da4hpzV42wPiU6f4Bdx885OTpKSpJmexN6ayn7eJm8PHJBStb0mL5/d9/g8985mN89Wtf52zW0TSCrhL4ssU7AdLx3W895MndM2xX8/yL+9RrRyoFz10f0LBhPAmcPznjYJijwoLPfuIOT54+/kivgVjch9lsztOnT6mqiidPnjCZTLh96xZZAdVmifee05MT6tWayWBEPp5Q1xVFOuDNb3+b3/rN36TrOv7CX/gLTKdThsMhp6enPHp0j1u3blLXCcvVjBACh0dTkuSYk9NT7t59l7ZsYVnSzVZcPH7I+WrNCslg3TGbtzx8+JjR3gEhBObzObUNVIsVZWNByGf2ToeHh0gpOT8/7z/fs9rm7T1k25H2SpNkBQqNFxovTYzXSjoePj3j5ME95GaGCD6aJDUNt27d4vDwkJdeeil22r1lsVggRMxL3nUy+w3yB4Hwtvu9ZQ+1bRdjI/vu/FaDHbvbiqDkrmjuvY/rWpLsnKW1ZQeKt/Tyq/dK2QONuq53WndjzO79aa3xgt0+dFuc2DIGvbN0yu/e21YmuR1KGSaTg/j6VY13sqfNBo6PbjK7uaCqVpyfn3N8EPer1fqC1WpFkSVo4cE6VBDkJmGQZKzrirasMTbgtYjrGvGr857FYoFrKtqqjM7/Wbo7tj+poWKkRWSZ4a90vXvQLS/XvqumvDIETHC8eOOY9x40vHi94Kzc0IqUk9mGerViYyFLU/Jhhncd0rUUacLRdMCkkOAatFYoERgNC/aHBVmiSKTA9FGVy9UcM8gp8oz1ZkXXRgaq6uUZ2XBAkmV0tkO0DTLEeK3g1sgeqFpnWbGmGOYoLVEhYJKEtmm5uJixWi5J05zz2ZrFfMVquaFtwVronMfLBKUVRjuk0rQuxpxppRBBkicpUqe4psPaGiVjsVdrjSREHyyj++u9IIQY/yWlYL0p0TqlbhpcF2OcjVE7sNq5aAptrY2NDhGN2JyLr6ElGAnTQcY01yR9HGdqFCoYxrmiXW5IjicMDo54strgZcq4KBjkCcZknJ4v2KwrJuMRznZgQOIoUoOcTlgpzXyxJE0S0jQnhC5msSuNKCs2mw3OOVbrDdPJhMSkkTnTdnF/5Dxt8z/yHO8f1OG+enH8UaZaV5/3DFW538BLKehaR1PX0ZDK+x2gaJpm1+3eVkO39BOlE6RyKB2pp0IKTJKyNykItoY8xUhBVW6QMjAYFgShkEnMnA2dixIaH8B53n3zLX7lV34FJwVlXbNcCw6LhL2DQ4TtyALkXdTuehddYbXQdLZFAm3T0PZVXCElMtF01uGtJUtyfAjU1iKVxvWtu+EgZzTSbO49pu4sEk+WZbRtF3ULoxyUYFNVhK7Dtx1KQt22DMd7yOUanCWVEiMVto++kdZCcCQSpuM8diA7u6PgBwKj0YjxeLLLL/wwOcEHz+QPr9X+/o73D3zkT7QT/ixo3Ub3iJ6OvaU97RqPuznef/+BVwtXkNMWdMd9w44EvkNOon/C9jlCyB4Ybk3Z4mNFEL2beHzcpZ2MuKQt91xlf/Ua3OHIqO+OWDOaoXkCSEnT1LRdx3i6j1YKfIzEC8KyhZIydCR0JAhMWmBVStl2VFWJFobEaKbTEcE52rplMVuQmRQZAi/cvEO13FCtNhwd7PFn/+Wf59a1I4RzeGf5C7/0N/j0xYrvfvstchKOrx/w8OIRp+sZ3/rud8hGU543mtDZXewbeKSIWiQpYw63NJLT1Slt6CjnFS54hFZ9TnPoO82SrXkLIiBFYJgXmG6FaDbUVtOJjKCS/jiLZ+nm0Huqf3BuX8JgrvzG7356WV0J22rFdv6IyzkTnnktntmEfv+4VIFH+n+M8BDiR7Cp8o7NssJ1nq7tMImiKCRpIpFBxMxqFzCZRiqBtdDaaLoitcALwb2HC6p//AZaKa7d0oROMBhIlsuG2bxjepAhhGe5aAiVpGs9nRXkhSEtBlzMn3JwUOBcTLPYPxyynK25eT2ja2uMglCBQ7FatbQ2kA0Ez7005cHDU9YLy2recnH2lBs3hvzelx9z9sgS2njdzM4ajo4ztAoYD5lOOJ4OGaQJe+Mj9icxiinVCaPBMJrraENTl4yGBVVZYi2kWUHrYjqE7VpwHdVmQ71YcfP2c9w8vM7r+ZsUeQ4E5os5rWu4uJizqdaUVcPhMOFf/rNfYHyc8fQ3N9x9/VGfzf1djq/tIxR84vMTvvAnB0ymEx4/WPHgvZLnXjqkbmvOTyrSDPZvDHh6f4F3lhDANg7hFd4FhPB0FQit6NqATDqkkbzw4g0O91Oe3J/z3hsnbKqG+w9W6NRhChhMMx49WDPIBOuZp6oUv/e1+1wb7vH8qxldGeP9iqIgSVPKuqVtHSG0WLvAuo6qrpGDNb/wiwdMjiR29YSXXxryieIm8/WGt/7whEdvbDg+GtP4ElW0ZMZzcgH61pA/+fM3+e0vfZ3HZxv0QPHt7665eW2PZVmxWTXcuBMwg49W35fnMXKrLDe88cYbHB0dMRwOESLSNeu6I0mS2IntU1Vyk/L48WPef/s9Pv7cJ/njP/Mn+eIXv0iSJOzt7/P6668zGAxI05Tbd27xwvO3mU6HKK156623ODnZcP3GDZxrKas1tmq5MRnFruXsiNWqYnm+ZOMTlqWj8z4mwHQtKsl2+6RN0/DOu+9Rb9a8+uqr3Lx5k1u3bsX87HDpDr710dlJiOBSA42ksR7fdNgg0L1JWhfgbLbgvbt3uTnQ0UC2bdlsNjx8+JCTkxOqquJjH3+N4WC400QrpXZd7e3YxTmFbTa33/0cAUFGxt6WPr6Nl40aagdGIqTede4XiwVZlpHn+U6nXhTFjka/7UZvaenohK1Q/KoOfEtrz0SGDX7XNd8WJbZa+hAUvr6kz2+77duhdSAxBVqlFIUheMl8MSdJEl599RMcHh9y7+E7AFxcnHMwGRHSLGaL+ygRc21Hpgz7kym3rl/HC0G7KdEOsiRHFiOkEiQCMqPIsoxNU+/0/Ml82RcfEoz6yey7jEmImuFtWkmvIQ6BgI115A/BEwJBIjRtteRjL97kWhv49rv3KH2KUQPunl5Q2YbOlkgpKHLFwf6Qg0nOZJDhqg1GCoyE1MQkoaLIMQpcUyG0RqgYfTgc5iAcg0FKtdlQ1TV7+3u9iR50tos6Yq1wXUBrTbVa49oO5z2ts5gsOp3nWYQYSipWmw06SXnu+ReYXcxYzpeUqzWpMayrradAiK/tPeNEsVx3ZFqjjaarWlITMMpQd11MpLExJjaEWNQIzpGkmj6QBqkk3knqpukLUjVpNqRtQj8vEtqmZlAkGJOwKhualrg37aV6UkoSrfHBY2RgUhjyBISt2Z8MMcGSGcloMKQr1wyylMnRdSpdcPfxGXq0j0EAnslkymg8Yb4saTvLarlkNe8YFgkv3HmOurU8fnKCc7BeV5xfvI0PgqqNNPk8TZmOhjS24/z8nNW6jJ4pCIosg5BRyWonFflRjR8D8H7mux3VdLdhvNqm4Y/69xXQ3VOLoruqxPXGapvNBtd1MVNRhJ3hx1avI4iVR2UM2iTIutnpb5CCpqdGmd6u/2A6ZnEQjUmc7ViXa5yPiXQRaMa36JqWb33963znO9+i9jXadnSdxoUIVG/eusN7773HcDiMulBvMVpC8HgXI4raJsahQdSau9ZikhTXOgQBa7udMZVSutfiVKQJTEZDVBKYLxdIpUlMNGkoq5IgekMX55A+oJUiTw2+bcgTTdu4GKeE6B1HY073IE+ZjHMS7Vmtq/7C1FjXkeZZ3+1OnjVU+8BJ/6OA94fPlcuu4Q8C3h8GJn5S4PvSADBSoXf0YsGzHci+dfns+4w3ksufPfu5vN+2pQU/6OPtnhEEeE0QDq8dXtpYaQwG6Qwy6BjrLV2UFuAQvdNkBPGXHeoQAkKpnirk49/v9Vxx3nsIDpkYFutzZvMF16/fwnUS6XV0YBYt1mmMVEzTQLJ4hy//o/8fJ3Pojl/hj//Fv0yWGgoPT57c5b/4z36V3/u9b5Omhof33+ePf/GnEQ5+8x//U/7YF/8Uf/Pf+F9w/Nw+63aFcJ7V2ZxMTzHFiHuL7zHeG/LJOy/x9t23sGHD+dkDXv/m9/j8z/w8rQg4L0iJpooqWKwIBGOwSLJEcr56zNPwgGIwILUDdKZoyq4//AHhPFKkOCti8U15Ag3/5d/9OxxcfIfPTeCFn/3L6Buf552zOeOjCS2BLmxjP2IB5MPGtiOzq6b0JzUayEcX0x1wv/ISl1A77Fh2H/raP2iIvuDZl3Xkjvnw0brVhiColzEzOniJs4E2SDLj2D8YAo5OCiwdXQfexXtQkgSs7xiPYj7u+9+9wLaCPFcc3DRcrBqGk4Q9LTjan7K/n1CWjqrp+N6bZwjt8Nry/qMHFLlEJktuP28Z7xucT5ioIeuLFUUuGA4kddOx2FjGk5xs5BkMJW+/eY+LRw7fBPJUMjwocDNJbjOOhgIxlLFb0Dhu7B0wff4W09GA9WLJqCgYDgbkeUGWDyirGtlLC6wNECzWCubzijxLIdQ8ffyI5XqNJ3Cwv09blnRdx8zNmS825KMhq/WS+XxGU9coIRkMMj796is4WjrXsKjWvPHNb9KJklGaMZ7W3Hn+Gr/wi5/Hi1Oee/kOm+YBlXvCxXrJYHyNOy9mfPN0xpO7K7oGWi2wg4Y0V4QA49GA4D1d66lWTfQ88AGEZzhJ6GpPJh0nd59QXiQYVXDtzoSz+Yq86IuQTrBe1mQD6BrLal1zclqzXik+/fI+Z2drlA94znh8coI2ChrYlBuSJGGxXEWDRQGDbMTpSUUnGm4eTciSlPEk5/bzYz7+wjV++598l9QUvP6tkvUTyeHHJX/m3/jT7BU3+Pv/xX9NZ2vufPKQybHg9HzJb375KYNhwo1bh7zx1orhdPORXgOf/ORrV6ix8Zrc0qiFDHTdhr3JPsfHxwzznGFacLS3T7VekyQJFxfnPH36hKIouHb9OtPpHp/93OcIwfPtb30rdkHbik21jnsg39G0DcUg49X9l7lYbXj78fc41gmH4xHZKy/hgmbl7vNgWbJqO9JBivWrSDdFkCUpJjHYrsNW0dDp8ePH5HkeO8A9ZVZKSZ7nVFW1A41t2+6aHgBe6OgAHlpa59H9PqtpWhwCZVKqaoMkMJ1OefGllxiPRmzKMhaU+z3c/v4BUsZGStzb7e4yu+K/92HXdd/uTaTUWPpEDxtp4FLFomvUtnqUMEh9CaS3n6mqKopigFIZRaF3EsYteN91waUmSMdwGBNeyvJSrtC2LZ2zMRWkB+NSSrquo65r0jRFyYQQ1E6/Hk3mtnRXQds4GsmOqp7lAwbW09QNUiquXbvBwfGYi7MTyuUcO8hJsxTvLD5EkJQlCS5IijQjNQmbqsR1FuGgCTWrTRWPr4DcKIpUxtRCIWjaBtP/bWPMTwx4P9PxDooQXC8P6MG3j2t2pJ1fNjpEkDG+MtEIt+HWtSM29pDf//YjrB2RmYyxiCy1vDBMhgnDQiFcTbWuKJI0SjTznMloSLlZs14VZJnG1RuC0xgtGI+GKB0TTLxzVFVJqg1JlkVGmVJ9XrYgKwqMdriyQhCoq5oszyMD1WicszjvEdbhhCdYx/7+Ht7GpoHwnq6uiWmpHhEERik8AR0chZQkkwInk6hlXs3JBgXBB5yLjGEhBNpovI/SUdvvQ+I65fqM8ijrgmiyaLvomh/C1kQQjBGkmaKswChJSBI65zHGUDUtSgmkh3GRMEg1uYJJmnJ9b0RoKkJwkdHrHcPJAbVPePed+0xv3qKsLaIsWS4qRhOPUr0BYtvSVg2pkSRacnJygklytNIoqUlTSdNuWK7XWOdRUmCbJhYMsozRaExV16RKkKcpgzSLkbgumhD+KMePxVztclzSQrYZxUL04Fv0FNQrXcFt1BFswUdPIxKR3hucx3YtwXmklJHSIWWkcndNJP4qEQ94P1nrcoNJNZMiYzjIkDJwWm9oG4uajBkOJgx0wGgoyzW3ru3xvdWKqqqRKmOSZ6zKiiTRtDbg+jRnGxqUtWg8eWrIizyaownFZHrIwd6GkycP2B+NsE2J9BYpooFB03Uoo0h8wto6QlAgFcFDoiWJBCslhUwi6dV7MIayjTqlUZ6hlaVceZxvESalaUpwsGkaOgmZjmZrmTZcmw5xriW1caPZOajqNtLYhSY1kTospGJZttSN6yvMljRRDAcFWZZF0x+IdHZ6UCwu3ZF/sjTwH/14xqWaqx3rP2pR2v7+2WPzfYYwP+yb6K8LEVx073YCgto5cCMcro/dEMEj8H02aYzVImzjsthedETTrrjpliFSPJ21CKGQwiC9IsFQbUqEdIz2B7TB4XWHEyCEg5BgHexNxnSzknb+gNN7JV/97W9zUTv+N//rv8nv/9Pf5t//9/8Dbr/0HH/jr/0St24f8x/97f8AHxqSUUIoFP+3/+z/RZZKfumv/wKf/8yrjLRjVEjkaEB3cI2LakPWBa6P9tn7+Gf5td/5DW4fv8CnXrvD2dk8RnDhccEihUeGuCnzweEEeAlns6fs35ygyTCbAqlMPH7OI2Ws2nrnUQScayhyzRtvfof/9h/+Pf7GJyfYrmFIiVaB8uKcwdBg8hHOCQgOg+oLhu7DT+wH6zFsq/bbSv73UySemUHfP53+WRNm988tS+OyCPTRXrMSEankMjrAu07RaUu9gU06xwcJ3tA1UAwMs2UTY4esYlRolAt0TUB6wWAi0KnH2kC97ug2jr09ze1bE07OTpgtKrrgSQaW524foU3LbFHhnEeoFJ0kWFdiK8EnPvECDx++hUazXpWYXPPc0Yj79xYkLuXO9JjN+w850IbReMT+ZEqqNEZ68hcG5Mk4muQkUY+6vzfF2RbnHGcnJ2zWJavZEt8G1st1zPglFoNXiyVlWSKFIktTxuMhRW64ceOYO+YWzseIy7lrMKmmtZ7Ot1TzUwiO0bAg0zKCorbhyePHaKOiwZpQ3BkdcrG8YJiBudVx//1H/O5vrvjF/+kLXL91xL3HHfVCcfrOlN/+x495fG/DZgXBCkQQ2C4gc8Ev/CufYTIdcHHacv/hI95+6wnBBQie45spZeupKo8M0C5j3PjybI1Il7zy6YzXPj/ElRlvfGPOeJozL0tybRiPPW3dUrWBvEhwrqa1jnE+YrmKx0opTV7kyCTFdo7leg0CksQwCAWvvfoSa/9NZheWb339nKxoef5jY+bnCyaHOYdH+wxGQ2bnJ3zqky8yP53x1T/4fY7Ghs0mo6sqTp50WG8QaCbjCX/pL/4rfPmf/gbnZ6uP9BpYbs6jxnMw4OjoKNKNuxV2XVEUGVkqenOtms4G1KTADBWTg2sM9wbM7p+yak8gHfHobM2mm+z0tunY43NDcpjyynOvUtc1d+/e5dGjR5zUpxyOjrjzyed4dP6U9x4/Zu4NLxzf5POf+xgy98x+66usqxSVXmezXtJ1LVme0AXLIBtRDAxLq1hvGqoHT+i85PDwkGvXrzMcDEBoZJJhEFgqnHU4IfFK4WxPmVYS77reJbtBqqhbNlrtdNehbsmKjBdfeY29/T3KTYmXGq0NOilQKmGYFH2RP8ohtnRtF8WbhCBwLhattVZsTUClCKASZBLvdI0N2LrrpTYgiGwtb4n3ChEIQaFV1ucYx4QBpSKYHwwGH2ritt2DbptDW9q5dQ6JwJhkZ0LXdZb5chX1r50FUYFU1I0izwusS3vjqyjT8kERqEiSlMQnZGlGMc6obDRJy0PCMB8jDwTrJI2GYNIhjcOnBitBqoZMwiiFUSLoLKi9Aq0NJknYy2Jagg6QC8H1vRFDk0BnWa7XlI1lfzxGm4zuJ7S1E0kaj71z0acjyLi2BB9ZW6EH3T37lZ5lsG0OGSPY1HOSOmc0yBlMcp48WdCFQJYphpNhjL9LJM5aXOtACmrvSJUiVRIjAtqoPsFEoqUiMxoRIjgWWnExm6GVYm/vkEQZui5QmBxTDGjbaBCqpEZQ0toNVVtRexefLz1DZUgTg20cSgfWqwW+rViWa9J0QFVWfRSXwNp2t6wnSiO8wuEYjhOcKThZVlQuQC8n6JyncwGEJuAIQqFMlA4qo+m6Lu5thaBu2/g+bEeRp1G25xyKaCAsfOxsextibJ8INLYl0Uk02RUCLQISjzaSQqbsa0WewbX9AVOtqFrNhQxU8wsSpdi/fZNvvnWfte1gPCXLc86X85gCUT5iva4JrmMw3mM4OGI2u2C+7nh6tiBNNEeHhxwfHbBYlwil6BBsqnhvdV2HMYK6LdGpwQvJoq7IEoVOYp74plwi9f/ozdV+0M+3m7z+a/jB+8ctCN+OLTTYmg3BZW6i857WWoSI+gMhYoRYlqaslkuQsFmto8Ns29J1lkQJhE7p6obT01OSwz2kEIyGQ9brDWliODs7ZzDZZ3+QczGbA5JWeuqe2oESCAkKSaIVSirapqXtOtrOonVCtSnReIZZCi5u/n1vqhCsQzkwaYp14IRE+miAkCUJja1i1JeSJFpQDAqqumFcjGIRoO3QMuaXCx2rp03X4q2jsg3eWDQm0niVREnN/njAWBiCULS2o227XZXNO0/VttRNh9ZmB1a0NmgdNR1d29Elsbu6o5x/3zn+YeeJ+MC/L7//QXrVn/S4KpP4YYoMYUsd34msP7zb/WF/Zzs+7PMHwEuH9KCcRDrV0+vAKge6Z2n4EDuvPvbnpVARWYu+8ymIIDzE601LHUnJoUbIDikyhJPgQUvD2fkZTloOb4ypWeJSR2c9WoAm0necUFRCIUf7NKIFWpYnjzBtzX/yt/8j/vW/9lf4xb/yS3ihGE4M40ITXMWmnvMz/9LP8tInPsX/9d/7d/gP/91v8Od/7gt88YVjurbmy9/+Hhf5hKaRHIoh13/2T7FsK5p5xXlZMtrT3LhxA9n1fhDCY+WVwpAQ8Q4ioG4r5hcXLE7XvHz4Sbq2i5s2FLaLpkfeWZQUECzKdyxP7hPqJWl6DZFneJPhsTSbBfV6zCTbQwiFczUQcP35+NDCzFXR/W5sJQOxI31JJb+EylcaPs8Q0v/Z2Dns3M23c0rstOYf7Y7K2oCQAZ2CDx4tFEkO6UBxcKx4dL9ltW4IXqMHhsQ0ZAk0mwZtBLWPVPjpnibfU8hUc35aI5Xi2lHK3l7Cu2+9hQ9xrgYXuHE85exkATKgM4/SmnLjeOfNObY0yG7GZj5gb7zP/QePqCrL3l7GwXCf7HjM/nhMWgs+eS1BHEbTwP3pMUWSMxoIEmNoK0+SpnS2RUho1wtGwxGmGDDKB6zXa56enNG1HbeOD3ojrdjBS+/cJPjAeDSmbVpWqyVSx2iU+fIiJnUkGu876rYjH02oOk+mMhIV/UGSFJxrKZIk5gs7CE5GEyjnuDG8zmy1IS1y3BRuHKRsFk/5g689QSYZX/0nJb/36+eENtBZkCh8SJHScv3mHn/sT36Oh4/v8tXffJ3ZeYX1AqFBJgpjAmjJ0V7GelNy/fqAxallsxTUsxbhBIOi4OaNPVK1zyA74OnpOevasl41LLpAlht0atAEVIj5zWXVIJUmzTR2ucYjaOs25jrnOdY6lssN4kQxym/TljO+8tU3me4VnJ8sePiuYzqd8vVv3OWl1yo+/dpzqLDPu2/c5+3vXDBQmvFEsjjpmD1pCEP41Odu8bmfEpw8fsR/9w/+Lut1w+07Bx/pNZDlMSO4GAhGY81gOOjvPwKCp1pd0NVrujalyBQuNKyqBa2r8MIxOYqxdCqzJIXhdH5/122VaYtKJaebU2QVtdhiIHj+E8/For5vaJOWFz/3Eg+Fx55uOFue8oVPv0ZW3Ob8fMp7J4LzqmGvKFgsGpR3YC0iOJSS0WhIJ7TOM19XDKeBtBhh8oLZbEbdXVAMMoJS6CwDrbEl2NASehfx6NbvdkDW9B4xs3NPVVVIIBuMyUcTOi84vZiTpCmj4RiHJJXRwDUyyGU0y8XiXdubol094pFa3efYAFFKiIz0dBtiIseWCi6lJNjAVbaPczZSqk00V+tsC8LuHl8UxTN7Th9cNJPyl0BvS2WXvS69KArSNMVaS9M0bEQfm2odrWsIamvO1tK28fNuXdCDjF31loaEFCctxmgwMVK2cy2bdVwfhsMxzneU1ZIQLE5rMhGwPhoNZwZGRYJTjs7EiFtkQND0Ro8CjSIzkMkIYlugSA3DQYHUMZP9JzGCUDvdlrj8IUL0hZA+EUgEH0Fl6D13+iaR9x5vO3zXMM4nDDPN/lATVM5isaJczBBKYVON9JHtVmQpeZ5SDEYYk6CU5uhgjHMdgyIHFSnvShvOZjMGgwKTZOR5hkoMeVGgkxQEdHWJyVPapqZcr3B1xXLV8O79EzaVwyQZWWq4YwY0tmF/nFBuSubnFwgcaZqT9lFkOjGMJxPaUFH6BmkDWkFtLaNBhswSnq7WMVNbmrgfDB4jNSHYnd+OlArnHbZrY4rGlm25JQ70HkbWxevIeotWms45Eql6MO9onSNNDCGAI3oetF0b9e9GMTQaEzq8URijGWDovGflG8pqg3eKWy+/RC0kw4MphdL4vgHRdh1N0zIYDKPuXQkuLs6p61hYV1IiTYbUktUmMnRX6w1la6Opr1Tgo5zS+xilu1lUOALOO8qqZVhkkYliO9ra/kjn8Y+5430JHK4aH/xgMHXp4vxBDbEIAoWAJN5MlZIEn9M2DVVdYrsGY1TvsCdIkxQ5mWC7jtq2rNZLxqMJaZKilKYsazabFU21ItNRx1FkBik1o/GYk/PHZMWAQklevH7A9x6eMVAxP9uGeEKdcxgl0ULEbryPN2/vPfPFjK5rqSuPCgnjURFNCNoOiJUm5QXaehQO2+s9RJIgRaRvSKVQMmZsa6UosoTBaIQSAT9bcPPGDayQLFYVTePIszS6ozaSzabGESMPfLDkaaTGOGfxwdF5R900dM5Rd23UnrUdIQiUMpE9wGVEQ9u2+HAZeRHPgXrmHP/zzIv+O/579Hx/YuPDAPcfNZfhaozUD/83rr5uCJeK78s/GrCij/ryErzo4/Hin/Xe4XFoFctVWBcjH4THC4cXPkbK9ZUvKbYdgGio4eQGryxBNlgXI/mUKVjpNaWqUCNFw4rGV+hEIR0IWdE6y+989zEX77/BW0vP004hckVbP+b917/E+f1vc3Py1wnVCtKUzaqiq1qSZMCN8QTdlrz3xjc4nuT8pT/5Z3n1aMrs7re4cXTAq3sj1lrz0ide5SAdo8Q5bzx6h+HxgLd/6w1sPuZvfeJ/RVe2SC9xWmEJCKmQHggCRSwSmNRw48YNVqdvMpmkZJmgqSqMzPFe41pIZI7rOlJtyAgsT2a4jePxuaWQBenpiv10wXx5zjTcwPl4XUHT37suaYPb87+N7vI/AOwK0ceZ9bMnavCv3APhylzo48Z+CNy9fcxOILJlqoTwIbF3/4LDOFSiyEeCwVCjpEIZz3AoGUwM6blDbLrorOoth8c5SgnKyiKNo+ksWSqRBpouYLvoSOo7Qd3UBCeQXtDUFh8EJikYJCNKFzh5suLoliYbaXzXYDtBEmA8lLTzGV2jGYUJLz+/j/QCuRxwfX/CMC8YD0eMX57StR3r1QIRFLaLLuvL+Yrr12+htaR1jouLBQKBtV1PY9UcXzvm1p3bVFWJci1VVXK4f50gJOcXMx48ecS3v/VNurajyHOyYUaSprRtg+viJsgkhvFkyv0npzw+m2NMSpYY0kQTXIftWkZFzKLXRmOtI9EG4RyL0xNMMmIxq0mC5sk7JT4I9q6PEEYwmUz5+b844NWXXuE3fu2bnNyHsyclw2nO//Jv/c/5e3/3/8tbb71PQLB3PKazNdODDCkTfHC0tiEd1/zMn36RvWmBa/Y4ebLizTfeobMdo/w6f/Db9xgNaj7+8U9x/fqrvP3uf4fCkRjFxbmjLB35MGWYjhCtwyOxNrAuK5arMvos9D4MQkm6uqFp4OJsya//6u/h1ZJBMaZZBYq84s6tlGs3h7z0sc/wwgsv8tVff4M3v/2IXEKhEp5//pi2XaHzlPXSYVvHt791ny/+iX0Orme09YJrNws2q/VHegm88uJ1nHMkScJgkBLCJU1Zy4SMEUWWMyoGDPKCRCps3eA7ixaSQZKSmhTdU7u3WddSSpxzLM4v0IlhMBhEA8teqgaAgLQQDPYUn/r8yzz+xlu48wUf+/hzSHmTz37xVd5/IvlP/+4/5a133sG2NULnJGmGE5raSkxWkPmOzWbDbDbb6ayff/55QggsFit8sDH3O897GnlzqYFWChl6h4t+/7DdM2zp1nvjAiEE9+7dA6Kr88HBAfv7+7t9xR+1J/DPIm+6Xn4YRwBhkfIyKgx4VuONRwp9CcQDz+g8Y6KLi8kxRKnA1jvIWhsp61y6u3vvd9FlcEkR33bEgR0ID743Cg5+1yXfPm9r8KaSDGEiFXbLhjLGEKMyPWXZEtoNSsFkOmBYDGnaDV1n+2MjcUFiO0dARLdtLanxNDi8tzjbIBFIEd93lqckvVO1aEDpGCmFcORF8d/rGviohkCAVFG2IyJ1n77zHJGi6zvevVmcF71DjSfCLY9SEQBPRge8cDhBdAGncw4HKY9Oz1g3La21SKEwJqVqIW0t8+WGQaawHtabkjyVrBcX4CxFlrLalCiTkBUDBsMiOn4rhRnmGK3jPsxb6nXD+ewC76EuPfceLrl7UjNb1JzPnzIsEu6dbvjES7cY5QWhtXSdZVgUEfB2LVmWcuu5O6QXKzbuKXa2iQFZJiEJgiQz1M6iRF8ottt9pKRpO0yS0tgGIcJOvx36Y+eiwpA0SdBG03ZdxDVa4oSma3vBYnDgY0Y6AuquJTcJ1HFuOuehN2cuEsVYgXQWmwsGgxHdxlKpjrPNjCzA9edf5LwJdNUSVMK1Gzdi3v1mxXQ8pWktaZaRZw4pFKenZyyXS8bjCflggGtb8jxlNrvg5OyC1oFKCxCapinjvTTL6doWD9R1hdhiFhmZMlYIkJogPlrJ3QfHjx14wwe6mzwLwq+ODzo7Xh1SyL5TpxAm0OEj/1yKqD0SCXmaotU2EghGoxFt06Ba3Sf+eJyLzugCj1aqn1yg04TFasXZ6RkmLRgOC5bLGYeDIft5zuc+9jzfef8ROEsnDJ6oh8l11Mj4pon01uARvkVLx6uvvEyiBNVmRVVtsN7TukBQmrrtWKxLNnWFFSK+Jw+CSC83Ku7U8ywj1XHBlcLQth1GBvb2JqzKirOzc7TJSYwieEGqNYVPsMYSkDTWYtcr2s5QZCnOQtPEjElLiE6XziJ07Ipq1TuWE+MItovVzrH0ionJ9lxdXdj+eebEDwu8/1mGfD+u8cN/zsvHbbvfP2h8kP3xRxeo4jO8gE7GuLmtqZqwksRo2tDQ+Q6ZeFTh8Kql8y2Nbdg0a8qyigyQtqVcl8igGOZj2qbmoj6llTVBeDrf0dkOow1t1nL8uQP+s1/9T3ngH5JkCQSLJpB4TWclT09OoN3Q7UlUcsS0akhGipP2Ic9/7hpfffsr/JO3fp/i4JAkMzxYnnJweEzZdLz57jt86Wu/y40bdzh+4eM0bcUfnsx5Y76iWbTcvDlCdJbz1QnnzYx76zPSg9dorSXYmNtc1THaLIaXRbgpJeAt1ta8//Y9PC2VrQhG8NkvfBaVQDFJcS00ziJVEguASuGkoLYNXVAcX3+Be+ctp8uSX7n7X7Kp/x4vvvgqn/xTfwKnBV1rkdLiRaR1gWK7+dw6ve+q9B88myLqo6MsR8SCyAf60WL7/16uc5VD9EeNbff8+2TnQvSu9B/dGE6TuNnRAplYhGipGkmSJaybkuMXFNdfLljPBPW64tatKZ1ruFh6rNM0i4AzAasCwykMhAFnWM0qVjOHchuCE9F/wju09KzmMz7+6k1+6vMv8d03Xmd1VqONYFJolNVMxsccTq5zfHiEsNFYqGscMiQYIyibmvPTOY/un5ClCaNRxt7ekMQMkcJwePg86/Wa2rb9MZOsViuePl2zP52S5QWEEe+/+w7aSMbDIcvNhvlqjTEJs8WS5XpDNhhweDwgMQld15JkKWlaUG7W1FWNUlBVDUIq1puSTb1Aqyin2ptOydIBSxujp1xlabsaEaBIMwbDMV4rpnt7LGZwct/x3W+es3+z5rM/fQdnOqbHnkY9RRdEWp70/LGf+wL/9De+zPnZKZ/89C3OZzN0nlLVDWdP1tgWTKHYvwkISd2c853vPODdt+D2nWP+7C9+gnfefI9qteSlF17la7/9Nt/9w6+ijEZmgk985hrVesOmqpEbgfKKVAXWdY21is47Hj8+wQkwQpPlA5xr0cogREsgbkJtN+PoeMwb33nEMMkwCrwtefDgAUmW8/Tukm9+7YTFeYcZaV7+2BTwPDqv0IOUtqw4Opzy/v0Fp//onFvPaz716SNcU+KrjzYq6XOfeIldYQxIs6wvmPU/sddQUmO0QWvNeDCMgCl4UmMgsDMFC71edxuP6rxnPBhgkjRmentPWVW9i3D/B01DY2fcuHZMdy3jq1//Hd57/3V++l/+04zXA66/9BxeHPDv/F/+Xc579/Ch1tiywQYokmjSJYSgqirW6zXz+Zymabh9+zbOWdardXQy7h931XhMKYUPl40TIWIW92KxwFrLeDxiOh1xeHgYkyiEYG9vbwdufxjDx233eTueBeIB6FBa7oAxsDNi2+4BlTI7cLylim9jv5wLOxC7/e8yC1z0ADjeO7ef+SrIdy6CdiEEzjk2mw2r1SpGpBlD8B4bopv61pto6+Ce5zlJ7tC56DuAYacD34J8azt852malqIwTCZDnnvuOYQMlOWarq7oEkXddngUJkkQXUViINEaITUaQ6o0uTIMTcr+4YQkCJqNolWOieiQwdN1NdZ9tAaEP/yIzYNtQRrB5TqKZ7sebh3Ot6vhNirOh4gFFIHl2QnP7U2ZZjlPFyUqGzBOFY9OZ5StY9MFsjSPkteerlzWGWWtkbTk2aifNwpTDFBKkmUpNkTDUCEEyhiclKSJgZ5ZVM6XPD2Z44Lk4aM1s1XH9x4s8TLHDI741lvv8fhsSZGkvHB9H5xgMjpEyYDSEmkUmfNYLEFKbF/IyvKEtrRkWRLlEtZCiAWeZVsSiN3gYZHR1TVdF3O4Q1/MsZ0HBVLFLriUkq7tsLbFqK0xnEUoHeWxKhr6egHOdaggGWYpWWoIQiIzg8AwyFNyIxH1isP9AjkaoYOkISC6wFAlHF474OG65t7TC46ODplOUzabkjQxrJYrWusYjfeYTvaYz+e9KWFCVdU8fvwIpQ3j0ajHe4L1pmbTeFTq2dubxhjCpsNoTds0WL9tGApc16HylLqxhGCpWtsXa3504ycCvLdDwA59fBBYiH4DeNUx+1nAHrmbWoIwGqkVdbmO4njYVSObpomOjtbS6ZY8y8jzSPvQJsE7z3KxoK4qlIqmFTpJKJuWdVnvLPGPjva5/+AxdVUjtaYYJPzsZz/G08UamQ4QKuVgf4+7b73Baj4n8Ypb16+RCM9qdsKNoyld69isVqw3a5LE0JU1y7KiDYJVWVM3LUKASiVa6ljA844QNEaCSROMinRz712MvJCezMTvBTAeDnFIqrLFWzDakEiBllDZSLvwStJ4R7fZkOgch6DpLK2P7qYOQXABo/WuQi1EzE7fLjbWWspNGd0uk2S30F1lMfzzA+Jnn/eh9Or/EerHrxoJ/osVC55lghBEzNoWAYfraWMC5RQKgXcOlTlIPfPunJPT93l68T4XyzPW1ZrK1nSu6enmklvHtxhmQ/7we/dZr1eIAbS6JsiANDIamjhPqgvUHcHp6Tlffuu3GAzHtF2N62pEabG1p+0sChc7igxIRM7yYsO9f/gGaj/lrfIEb0aE+Ya2rDj7/5P3X8G2bel9H/YbYaaV185nn3DPzalvX3SjgUYDjUCAMBhclKiyxBKloiWXn1xlv6nKVS69+cXFJ5WLNi1LKtkUZUqiSxRJUJRAECLQCJ3j7ZvvPXnnvfKMI/hhzLXOPvd2o5vkbYC2R9WpffbaK885xxj/7/uHakETac6KJV977w2SG3u8dzrlb/+Pv0VSVJwtLjCrgn/v3/i3+c7Xv8LXvvMhaZoyl3MuJXz2+U+TKslf+Ut/kcgrCuGRiECzhwBSnWWYxfy9//d/w9//J3+X/u0++maXJMvopD1++7f/CX/0la/x4ouv8ed/4y+xWpig+W4zKKWUnFzM0N0BlXIcLy5JD8f8W//OX+ZTL76EjRNqE7zgI6WxLYVR+qtn9mNq9/pUeDIuTGxkCR/L1vbhkWsqevhNsDZ9/JHXhmhhgFg/z0ee+hMcWzuKwXafThJRVwsWy4Zlbri8AOMFT7+0jYo8X/yF5+hIh/KhqPfOw1NWy4ZFnlBGOS4DgWXyoKJYwv5ucJRd5Xmgs1cN3X7MwWGXXhSxnJ1R5udsjxOyVKHJ6MkOrzz7EoN0yHg8DsYvecHp2SmrvKLfH/HmN9/mYP8ag36HW7evMx4NkNIxm13QFIayKMnzCXm+ZDzq4lpX2E+//hrL1YJqVRDpsPZcv3mLpJNSzKd0TZ88Lzg+PqPX7/Pcs8+xXMyCBtEYpJABAEgorYE4wiK4OD+nqBu2twbIZcXlZIEQErnKcR58HkBAFCmyNA1mXPM5y6Jg2O2EKMvhkCTSdOKEs9NL3vnDM/rbY756/4hKXJANI3audYhlxKqa4mL45b/wOrPJkvv3z1k+OidOJSIWCGXBQyQlt293GY97XF5UPP1MxOTsmLe+VdJUngf3Z3S7NYtFwWrp6PZjXnjxOsvilOXcMOimUDZ0dZ9EdWhSKOYFVWNYliUoTdlYtIpCJ8I7nA/slJ3DmGee2yfKNCf3LGrXcnA9Js8FX//6lK3DmmoquHxUMurFbB9mFHqFFDHPvDJAKKAr6QzgVryDVRNk1FAa6A49w+STdfa/tjUKkrcoartIEcvFgqquiXSMIAP/mLqb6phOnFLXNZ1OB2U9pqopy3JjYhZSRQZopehn3dCkcJ6mquklGaqj8D4kthhTcniwRXl2yXgr5dZTu3zz21/l1tO36G3vUucFWgn6vS54QV1byqqmlgonNdLX+LIMmvIkIYoiZrMZb775JsYY+v0uOgpdr6sRWlEUCglSa7yXG8dz5xyr1YrZbEZVVYzGY4aDHv1+n+FwuHncGqAnSbLpIAMbqvZaZ73eo3xUkvVYBuYQ0uBRG8O1NVBfg+S68q30sNkwCvwVkOudeGIfWtc1xpgNFdxah/WPmZnrIsTaPX0dI1aWJU0TYl3Xr9c0DaaVI63vt+7Yr6PH+jpGJq0RMI/17etccxuCxvHes8pztv2I0WgLcPT7XRaTCePxDvPFjHoxIcbQ9QlRFqNTjRAOTEUv7ZBoTSQUo60+GItQjq60dG2NayzC2eAh9KcxxFqzFYJbhWyRHy7kW6+N1WTYw67LXX79z0uQAmcs1hXkVcifHihLYywvHm7zzPUDji5mPLqYU3vJKs9JtQ4JStYzL0p63SFSx6h2Xy7jEKsrIo23pv1dgQxm9xZFvlxSVjUXl0smc88H9x9xdl5wfLFEpj0uZxXDgWJ3fxtZlWiZIIjJVwXbwxFKehpTIQjmaFVVY4xFSUmaxDSFJ5ICYw1CSDppDFmCq6AoJsgooj/she/IumDAnFcopbFNg9ZhFxH2+YqqqvE+MJS01m3hqG2yIXDteuVbjKSkxFuHViGtQSlBpBXCFHSyLtnuiDQCtaow0jArFuzIhFdvvcA9t+TB5JRlVSMmU9IsZTQcMp/OOD+7pKwblquqTW2qubi4QCnJtWv7eO+5OL+kzJfonTHD4QB9dEKzqqh9TbRaIV34vKplnpR5jfehWy9VaFIWZR3imJ0P/gE/wfGnBrzF493mD759M37IVrClmXgXKH6mabDOIpVEiAglwK+NN6Qk0mFBMMYQxZKqrqirijhKyNIU4QOY6XQyZssFxXIF7YYoX+WoWHNwbZfzkynaOerVAm1qro9G9AfbDIbbdHsZA5dj62uM+kPSWGGqJa4pKBYzilKQ53lb9XQs84K8rFhWhqK20GohtIQkiom0xhqPaQyx8kQyGF3VZUnSSfGE70BKyfbWmNJayqNTyqIKZlhO4UyDBjpJwrJaYoQIsR3W4Y1hWRgaFy6m2hgaY0FCnCRESoPzISLKuw3VTYgAwNM0BcJCuI6/+EFFkn/BM+SH/uVqkeZfNQD+ozvTj8cfd7c/9lN95I/CE4CtlDRYhCJoeGSNTySNyLl78SHvPHyTh7P7zIoLnGiQkcJSI7THSNvStjzvn71PPi8QToRNj7TUNIDGN8ElHEfQIRYl44Mxq3rJxdEMKSKwjris0FWFtw22zjGNwxiNsTGuqtDWYn2KYYKKAqVJW4k0FpynFBViW7H/zB71h47t/j6v7FxnezDg//Wf/RccHS9w6ZhvPXgXEUe8/LnnWB09wi5K1PycF28OqesZtU+JdIx0DglY4Ym1xFYr3v3+N+l0BMPdHgsNWTrkb/3N/wKHpzYl3/yDP+LP/tIvk0UZ1hhUpBA47j+8zwf37qGymIvFlGR7l//gP/wPGWYditmKsrEo0UErFWhbMjjEizaub0PtbrVU0v8oL/Ef0sf2V+ZLEUxOgNahvL3LFTDf3oB/otvtNz894MUn28n41T/zHEdHJ9y/u+D4pCJKI3rdLsul4dH9isuzE67d7FJO3kOYhk9/6il2D2JezPoMOrv84Vfe43hlGA2HnB0tsHNNt1NwOSnZPYgpGo93imFfsTVIqRZLJkWDA/JZzXNP75KREjVdru/cZNQdkaV9nnv2RRprOT09RUVZ6EhP57z4yqv8+q//Ons7O7z99vdZruZoCWnXUOYVi/ySurZs7+2Grkk+ZXt/j9PLS1b5KuTFNgZnLXK5YPrhFOdgf3+fNBNknU5wtI4VWg25vLhogYGirCpkpBmOxpR5gakt164NKOqGR6fnxNq2Jm4W01RcXCzpZB2kECRxh363g3OWcb+H944iz2mkoGka0jRmPO6RJBFNUzLUXb7w6ku8de8BlSp47pWbjHdS8qXhwd0F3/jv3qQubWATSEmcCj7zhX08joePLhjtOOJY4JqUz77+GebTBd+6/IC6COagpnFcXizpDzrUzQLvDPfef8gLn+qytJ7j+w3VouSFV6/T7yZ451mVDfN8RbeXURlDnhfkK0XWyfDOYmyNVJKmNjx16xqNz3nltSGJ0mzvQ1GvePFTHWbLhlqA1hIReY5OZ6DhqWdg7zChP+hh/AzjCn768wfoNOPe3TkX51Osjdja+4S7ebkDAXEvYxj3gxyhFqQuop8O8CKhbix1GzN1Mn9Ev98PXeWyYjwYsL+3vwFjgd49I8/zQOk0hn6nS5wkVKsCHwXTVec9WZYyzvqMxh0WtWI02KdnIr78e1/h7/39/4Hpsub+o5y796Y8OD7BeU+vl2GcAdOgE0VVFhSzOU3TMBwOGQ5DjOh8PufDDz/k+vUDRuPBFbdxv9kTaK0RbRdqHfNV1zXLZXBgj6KI4WBIr5dtKOxroLr+twabG2p1W+Rfx5et73d1rEGzbU24hLR4/yTFXSnVguwI7zx1HVgFa1nAem41xuDF46ixdZd5/Trr199oY9v3tn7+9ftcO76vwbbWekO1b7wLDaSWVbguLFRVFeJloxTTUuHXMoM1fT1JkgD22wZJvlqxWuXY45oXX3ye1157NbAmKsdbb71JfQQq0wzpMBh1iDJFU5fMzs/ptywDjSDrRtS1R3tNpjK2hMdVBooKqp+sBvaHDYFcr1TtLY8jq6x3bffWtRI7v9H/B1/TYHDpvacJnmlYUwRWg5CYsqZpCvrDHfafvc7h3piLZc7dBxXQhL2dhNmiYDTsM13VDHtJ8HMylrTbxXoHStP44LeUL5e4xpJPFzRFxdn5nAcnc959cMFb7z8kTjIqJxmkHTInWS2XxKZmv9fhmZu3+PD9R1TLFXZPcHi4R5rE5NWcpnEh7st7Rv0Bq5WhqXOMAGtqvJPIJEUrSb5ahm9OKfKiCqlG3lNVDVmWMl0URFGIimRTbArXh3eeNA1df2MMaZphGocWgTkoRZD5CgGRUi0lPaKqa5wLSUqJhE4cCnOVEcRVDd4x1pJn9w+5mJbME03WH1IbRxRJhDPEWuGzDkJGOB8YMu+//wHj8Yher09RLEFYXnnlZXxleON73wNT0+v12dvZZro8onaO1XJFJKGbBPZI1TJZIMwpWZqyXJWUtcGrKKQwuPIneh7/qXa8r44fBFaudoI+/kdgTe8RgV6eqg5SVQjviJXC1jXLxYKmaQhmrI44iijLiiTRVHVDVZUoGXQQVdVQNzUqiRBKka9y0iim1+thfaCvqizlcrli1O9gypx5kdPM5iyOjokSjYxAWCjnltpbTJ0TR4EGP5/VXF5O2d3dpigramOwXlBWBnREmqWhOygsSoboAms9+TKnk8VEUYLUmooQUxQKTZI4ilnMZ1RrN08C/UZLCdYh8fR6XWZ1Q1kF/bZoq1NOasqmxtWupVmFST1SoeMuW7qUa6nRUgY6TbfbJUkT0jQlbTstHz2e4iMA4Icd749rpa9OrDymFV29xz8HwP1Jj6tdxn+R9/SjaOc/4AWfhGECkKFwFIk4VMCFQfYcj/L7/OH3fo/3z9+h0SVWGZwCSYSpa0Qk8E3Ijlwbcyk8UZxQV4amsVhjaQigNW8CvakpDbI2yMbRlZq0qtBFxWp6istzYlHSpaCfKQ62eyRaEmcRDTVx5KnzgqrxFMWKk0dTZkvL8lIzkDeI6gbdFJzc+z5qNOL80SWdbsm+7/C1L32ZQX/My596jV+4+avEh9d4eH5BKZe4KGE2v+T281uYtKbJNDQp1omQIkCr5pOS2WzOw0dHHL58mzuTU8ZbN1ku7pFGkr/+f/o/8o//h3/A//Nv/k2+9/1v8OlPfZ4o7gAS7wX3Hp6yLCzKWVaF41/7N/91dkY7zM8vUV4RiVD11lJgfDCjU0Js5DHB/IUNUEa08WFtdM7jLcWabr7+7Qr8Fmutf+iMOz7KGBJPXFebQtUT552/gunDc33ShaytkULYDlUOi9yzWBhql6N1h26WUa0Kju4VWCPRwN/5O9/k6VcG/MoXX+Gb376HSgbc3utzflIzuwfKWrSLSSLHg3slsVZ0+x4VSU6OczqpYLzbJV9ZtHI0i4ib24fUi5rDvWv0h7t84Re+yHK54qtf+xrXrl0jrwzeCw6vX+czn/0sL734Infu3cfFET/3uV/k4f0H3L93n8F2xk9/4ZeJtKbT6fDBBx9w9OgIrTWHh/skseLd779JvloxmZ3T7fd47rnnOL+YcXYxQetgROOlb7WasLO7x6OHj7i4PEVFEZ1+n2qxYj5fsloULJYrkIraOpRQLGcXZFnKoNcNGavGUpUlaRzR7aTkqxVah3g0KSXdfp9ut0uer8jLkrKqiOOYyTznub2neOkZz9e/8y6//5vfJ+3HfOpnt9ja1rz0yiHLWU2kFWenE2bTmu98/ZTDW0O8i4giibUJH7xzyud/5oDdXc0LL2yDG/Peux+yNe6QLxV4zcXxijKXjMaSy5Oa1dwiRcXujua5p24gncT7Bi88Uayp6wrnYTweoYQkSRMuTo6J4oTFbB6caE8TvvmtD7nz4Yy93W2+++1T9m9FDLY1sdTsbGc8f3OHD9+95Pj8DJl4DsqY5VRRTBfsDrdYVTknD+7RG2uu3xxgZc2Hdxzv3/uEM1xLFTrPzlNhKYoaYTRpkpDSpXaOWICOEpyKuHFwyO7ODscnxzx6+IgiL+h2u1xeXm7c0ZfLJUVRhLVXKmKliaWiXOVc5jmj4ZBev0+Vl+TzBXFjyXxCTMT+3g2++MvbrBrFP/3SV/ng4UMupjky6SCa1n28TYSRyiMI5ztAt9vdgL2qqjYgOs3iTed5DQyvUsStcxsGYlVVWGvptEWofr9Pt5ME/5or8kLXPmYdH3sVjK8BqrV2A8zXYz3vPQbmFm8bvJebx61lcmsjV+fkE1Fh6yLA+nMEzefj+fUq0A+11DBvXs0Qv+p5c7VAsP7/1Z/WO2Qb23n1s0kpqauKyWSCKqqN5nsNujudTigGtAyoqqqom4LFYs7P/Owv89JLz5MkEXHcIc8tncGYa9KSZqCihn4/pm6WTC7O6YkgLYziiEi3OlcJIpZEKuag26VaFlSTOQ1/Sh3v9Vgb0vjQ7XbOXznuFt9+1955nG1/uuB749rjpZVvqecWQUM38hizopg2aGHZ6vZJ44xeesh8UbAsK2azGc47js8uaZouSm9hXE7Xg04qlJJYZ5gu5lyPDwHJ7HJOUwbvjkdHU775vUc8nBTMyojUGca720xmM8bjEWfTCaMk4Rd/5lW+87WvUxUFg6xHOTcs5jlxAkJbLBVNY5EeVMtASpTCRgJnPEYKKmex3tA0FTpSeARaRcFPwDmSJGJZVERakaQJVWFbDbkhisO5b10oZjRNDXhsY5BOboyedSTbrHhHpDTOGJwKLL40jcEYellCJMFZOF8U9CPPda14qjvk9Pyc757PEHuHJElCN0u4trPF1nBAvpgjVBz8JoJ7RTCRXmMlLbi4OOO9d9/hlWef5ebhHvP5gnwxQ0lHN9OkIibLMuoqxxq7mTukkBhraOqaNI5pGkNtHCQhJlHzk5VS/MSB92bj95Hfr4KHH2yydrWj6VvalG07NkBjgjTSW+JIo+MYZ2pkrHE2mNNYaxDySp4jYWIU0lOWIc9NyaD/VFITRUlLpRb0Oxn9JGU4GARad5FjV0t6WYL0jsV8RqI1OEe5LOl2e4iVwAlHnKQsrMfUJUkkGPYTTF1RVQ1xqlGxZjGbUVlHURuk0sFgyTbEkaSTJmglcHWJFJokVqRJFiK8rMUrRZZmSG8pKoMWDolF6IhBt0tZNTS1oWrKEAeFYzHJqcoGa4JGTHqIEo3SCUoI8qJArquHSmFsqFzHbZUZHFIGR3OlFQiPlookDp15AR/b+F9Fkx89/k8c6bY6f+WsCVXLjRHVk4veR+UJ/yp1vf+4goD4CLX36vv+ccH3OqrtKoLyeBphEUKhvEYIjYwiJuUlf/s3/zaPijtEQ1gVK6IoRrgI4eLQMZUC1y76zgXTPmMdpQtGKyGWI7ja2iCJoTYh3kT4BF+V1MUSuZwwiB1ffP0FPvX0DZ47GHJtK0VgWJw/JEs8IpZ0xkMi5YhoKCsfnEMNnF7GfPd7Jf/N3/kWtigZJZoXDvp8+9036fseRw/e58NvvUeseqQq5q//X/4Gy2pKNBixd3iTnZtbRPqSh/c+4Kde3aLT1xR1E+hlUtA4h0aglMYJ6AxHvPpzP8MbJ2+zRDIoIx4dP+LZ27f5za//Ju9evom71uG3vvy7fOOtO+QrmM2WSKVZLFY02QiXr+j1E+aXBd/6w+9wY3+HnfEWrg56Qlc3rV5KthKY4Bi/zs1eG7QKESxanQjO324Dvv3H2A3eB204EHT8or3L1VqV+Mjv67+LcP5IYJMS0b4fIcPWTf2AIte/zPA+4+Cgg1Ke2y81TC5XfPDOKSfHC5yL6WSaqBu6NM88nfLMyz22bo65+cLzvPFuzsPJu5i7gve+uUQrgYoFq4UlzhSxgMg6qhkslgXdLEI0jugi58budXaubRP7hH424tZLz/Diy6+ytXsNFWvuv3+Xp59/mX5/wLJoeGpnnxdeep40TfjSH32Zk9Nz/syv/gpJkjAc72FMzE//9E/z7jtv8sGH73N+dk7W6fHcK69y4/p1YiX4zje+jlQR1nqclBydnTHNc0wdtIXLfMXx8SNuHF4L3cHG0lQ1xjqGwyHOO+qyZLkqOT+fUDeO2WJFURm8EBgbzHlIYrxzKK2omgbnQl7sxcUF3W6GKUuyJGG+XHExmXN0ekESx5RVQ7fXo9fr0hkMqH1DJxqwFffobXUobMWjd1ZEscCZmKr27NwYUqwKZtOa5axhclEx2HYYV7NchfzXxXRK1rNMFvcRYsqimGHKlK3xNvfunJIkmmdf3uezXzjg9KjiG2cfMBwIdocpn3n9ec4fnnN0cRZcdgnXi7OeqqzxeFQUkURJuE48VIXjS7/9VXb2Y7ZHKS+8MuLplzWNzVktCmZlRTGTdHTOS6/dpHssSbKIz332JZrZlO9/+w1298Y8/amf4vazBzx8eMpv/sM/YLwjePl2D+c+WeOoTA6x1qBdgjIpmYxRWYie0l5jfI6UIFSgs0ZtUTzWEQd7+wgl29xsjStL6rreSLwE4I2lLIrNY0SWoZXCG4s1DaKCyf0pumlwaY9iUZP0tlksPd9774gPHl2CU1hnsN7iRZCtCRtcnbXuoDvdDehbg8U1zbooSy4vL+n3+wgRWFJr87h10olzASCvadRpml7RqhPmvxYQrGn56273ek1dU9XXHjPrfd260351vrsKdJ1zmB8BvKWIN6+Z5zl1XW/03lq3sUs/BHiH8Rgsr4sFjzvu7onos4/+C91yi7dy85nW322WZZsOuLd+Q5Ff6+irqsJ7TyQ0EYEOvFguODuL+OCDD3jq9k1OTo6I0y5JusULL7+CszmLxQlC5Gxvd8nzCRGWOk1ZLoMLthGeOm8wzmKswTnI4lBw84lGmZg/ldG6loddT5vn3brKt7byrYlZC8YdoenmReto7bEt66zxNuy7CDFk7ZmKszWX5w/pmTFSR+xlGQeDbVSUcu/RMfNlTr2quMwbMlJ2r3WZTC5QkpY5UYXucNJhkGSYRU1TVtTGsVoW9Lod1EVOOV1hE4EWgsY4ziZz/tJvfIEOjgcffMib33+f2sFgMGBvz3G0LEi142B3SK+joTHoxqOtoxfHmExQlTk4iWh9bWoLy8qR146kF4zycI7GQlnXgbCvQySZVMHHSQhI4sCkURKsaYh1DN7hrQvRae1mVQNZtxOSCZwPOuqOwHpLJ8no9DsM04h8OWW5KDBGkl0/oGkc37xzShlH+HGfZTkn0ylNUVHkOZ1rezjraBrH/vaI2liKsqSoa4RUFJVlOi9QOuP+gxNwkvFwQNLrMT89oyhyIh3YvbvbffKlYDFbMl8uqSuDQ7X7bUVZt2wVAd414BzRJ7sN+tj4yQPvdnL7KDQKGORJww24Akb82sZ+8+umegmgpSLWMUmU0umkSBxlAc4EHYJpKSehehsutOAKLvEi5DvqKGQqmibY+KVZShxHIR/VGaRWqEjjDXiCu3cS1+A00qcsFgVaK5IkonKGSEXEScqqKCmKsPnZ3dqhyRes8hIhJbvb2yyLCoOncT5Y9CtNJDypAmkblBMkUYRHhCqol6EKpS1xovFW461FRxpEsPJPI0lRFKgoZBzWVYmOEyQO6RwRisRKiqbC1gYRK9I4wjlLKkAmCcY7hNboOKWoK7yzISJNB8S11pYb0zz5vYoAJP5YE5SPAuSP0MU/So8NGv/H+tUnI5TUx1DqxxfCP7nxUeD/gwsB6/P86h3XN/sn7vPjvNbVnrcX4FswVhuDEqGzNpsuuDiakA26mGVJRg9RBid+pVU4fI1Hyhhf+yeOoTFNiK3QCuES+sMR54tz5nWOcuBq0I2GWtERXWp7QaY156enfPXihG+aGgV0uxlbPU++uEDFCVaN6MQdVN3Qyyx7WyGaY56nvP/hhLIxVI3h5vUD/tpf+Tf42ne+yd/7zX9Gkyk+86uf58a1TzM5njG/OGY2O2MxWTB9cMqH774brp0tz/XtMalZ0U9SltZQSYuLG5yQWBc2OzIW/Or/4i8w+V2Pn17w8J37LOsVl90F/+yDP8C7hmd+4TXuLi/57t0JVa4QQrVSDIm0MELQs47/x3/6nzGbTdjd2uKv/tW/yl/6K3+ZpiyQkaAWksbUxDpqrV/kuk+9KVati1TBC2ZtGrkhf/PRbvTmlFnLQtsO+qaAyZU59Yo+fNNhp/WA9Y+N3mQrW4k+YeD9X/6tr/PX/v0/z5d+/5/xi7/yOnE04/mXhrz4cob0HU6O53SGAiFLbj+1je6voLtikT/iM198Fv3GjAdvrdjZAp1ZOuOIVd5QFwZfWEZpQtlYJoXHGEhTzTjZZT/ZYa9zwGyx4ODwNi+//nkOb94i66TIKObP/2vPY6qKfn/Az37hiy2ByvLOu29jEbz8qU8zGG8zHg+JsyEvvDym3+tzdnmOeniPW888zWc/+zPcu3ePP/yjPyJLYy7OTjm4fohVkpVp6McJs/mcRMeslis63Yzbt28Hnw6t6PczyrLCNAZXF4GyJyOOTs+5nMzIlzlOCOJucHxethnXwZm2Zj5f0u/3aJqGyWwWZFZApGCxWDCdrzi9mFJb13a9IoSKSDuCpnZUy4JXXniWTpJxfjHn/fsPOD46RSmQlMxWlouzC156fYeXf+omi2XBqqhAWcrCE2UW4R1vvXWHbi+m092irDWHN4eYynB6cs58bvj0p17iL/zPP8e946/z8NEHbO8aDvZ36IoOFxfnnF1ccjGZMs8Nk+mckFcSYm2cD67ZUumgo20c3Z5gZ8fw4gt73H6mA+mKyl2idYdO1KWawsN3Cvrdhr1rMc+9cMjx8Qlbo4R7xwWLi5qL0yPuz5Z85+0tMp3xhZ/9HP2+ZzZ9l8bVn+g10B+PmUwmoDXoCCEdSZYCgkWxQmbBMMkaw6ooWBQ5l4s5zlp6/T69fp/ZYoGTMNgeUxSBHiuVCmsysGwqSm8h0USJxgCNCaAsTruYoqSyjrm0dA/GCNVlNjvjdD7BRQrfGtshVYiUFCCERhBhrKNoclRdEbWFdrTCNYJlWVCYCoNDJRlxbfAydN+LxqKNI9aglN5oo6/K0YLpmKfWofC3XoOkAlpgZVyIy7SiARFSZJZVOEZxFJHECZ4QAwTBQTzE6hHOIQd17TBW4JxFa4HSUZBEWNUWvQ1xrFE6RuuYvChw3hBavoooDvdbg+WrHe7wojFeyI1G21r7RKf7KvNoXVBYP5cxBuOCs7povR6kiNBxTCcbhMdVFZULn+9qQWENvL0OQHJZFhRVxcXFBe+/9x77O9tYU/Ot73yXZ194jZ//hS+QxIqHD07odCK2Rnv0uz3Efo86n3P//l2qehrwLQYpHFJanDXYChKtiQcpJvrTYRsK71uQHPb3a9DtnQ2Aod33b7rfPgDw9THwrdr7CnUs+DgRGm5ehtQfgaPOZxhriJOYKOkwGIx5bq8LB2PqBibTJflsRp6ULJeXZNaSpR2aPPhvHH9wjwdFxezBMSrSFMZyMSvYu36T8aeeof/OQ+Z5ST/JeOq5HQ72MvY7gre++z533rsfigVCcDpfcZzfx1nY6sW8LmK2OjHbmQQjQia9MUhniYSgl6Q0IhgvSjQojREG0QQZIjgq4/BCIIRHtAUIaxxOukAfxyKVwHpPliQhJcdJtPCk8eP44DiOUBIEFu8g6qQIKRnqhNQLfJHTiAhPw872AE3GvXsXTBY5ab9HJ+sy2hlgl5d00xTb7TObzbn/8AH7u7tIYG9vD2Md9x49YjIrWCUVi7ygMRDpmCjp8t6dB+ztbjPsdTDOoZVkPOyzKiqqfEFTl1R1jXUrQGKMa2MOJY0DFcckwiNVyEZPo58sNP4T6Xhf7QL+cVTc9eS0MbWwzWYz6VyodNZVjZCSWDlkGrrDUsoNSo8iDQQaTlUUNHUTrrF20+mcw3qDEH5DOwiTod1Qm9ZUqKDFMWxtbbG9vcNkMqEoSrTWZJ0OcZJSVTWLRU6kFWWl8XlBWVZYZ+kPBlxMZ6wm56SJpjfsIESYrL0LG2GtdRvUFd5/r9ellyVoFRarVVnRzbKg7VGKOIqxTY13wdXcmIa8LokGHeI4oTJhURgOh8F9sCywtcW1x2Ctc6+NoWrCazQu/D1JEnSS0pjgkrk+Xle1TqLtmq1NVK7++6Q6zz/wHPnoTf8KNLmvUnl/nM8u2oLPRkJxpaP5gy8Lz1WY/USHfPOcgb2srWg3Sx4vGqRzPDW6zq34Jr//O79DWczJyyVbh4dML47xTYGQwVRCygjKGtntIgU0iwUoGO7t4KqSYlnS3dmhqgryy8sABZ1AEqGyFOqcweEIdWObaeWwvkLaOuh0VMVAW6hznKq5d3pKpFJ8XiB9jXYgas+NmwdohqzKkrrJmc6mfOl3v4JMM5zN0GmHDx49QOpdrHGcVVNEpuklexxuHxCnEW9+72tkySN2rtd4/YCHD76Oj8fkKbhucHqnEaQqZlk2NP2GRTznvDhDmor+sEMy6iAzgfEG10hOji5olhnCZiAahPJYE2jrc+e5+/572Ok5SaS5nDj+xv/1b5BsZ/zF3/h1prMVZAMEa0nMujsdfn9SLhCAr2+xst/QyNfFqcfU8KvnytX5Nfz8+Dn3sfOzrfLL9bnlRehuSYFwn+yGSnct33r7u+wdDjh59CHXn9oib2aMhgNMkXJ6cUR/q4c3EZ1xxqTMqc9z5OqcW8/t01Hw6VcPka9sMV/NWFYz3nrrPoMtDZXgqYM9nC04P8tZXDZc6+zzqede5Kn9W1SlY7h7i1/4td8gyjrs37jBcLyNEDCdXLJcrji7c4d8tcI1hq2tEQcHh3zq9c+Qr3LOL0JXe7y9R1U2fPDhh1R1TX845Kc+/Vl6/SHL5Yo8zzk5OWZnb4fe1jazvGRHar7zzW9hq5rdm9tI4dne2aEoVhw/esB4a8yyXqKUxljDcj5DItg7OCSOIqw1WB9iW1arBVprtA6aO+c9aZRgjef8YsLBwS5ahYJNkiZgLY0tieKY/nAYUg4ErJYr7j14iJQSU1i6mWI5n5PnSzyW0ajHbH4RnHkbjxeGyapgcrngF359j6eefpo7758xmzjOLisKP+Op2zdZnNeMtyMWxQmTo5puN2Ewlji7zex8RnfQ8Du/+1vcfLHki3/2Bh2ZEZkd3DLj9P6Us/MFzsfoJEbIAtNU5HkRVkQZGFYmD/FUcaLZ2tH8zM++HEBLfsLW9oje9ojvfvdthsNdmj1H86LiqecEWzuKr371fQb9fX71lz/D/1Sec3p3yCyv2LmxQ43j+OSE3f0Rt559mvfeXvLON9//RK8B2dF0ZZ80SZlMJxRFwY7aIc1SjHI0ptn4PfgorKPz1YKyLDlfzMLGs2mQSjEeDcl6XVzbtZ3P50RZjNCatR1QU9cbk1kEFFUo/HWGGXEnAIDVYkIhcmqf46Wl9h4nCZm4IuwzhIqRKsJJiW1q6qbGycAgMtZgBVgBTWNQZUPXOIrG4FUobNraoGqDjNmYIq0BUNM0dLvdYNrkLNalKClBKpAhM9h5j/Qh6tJaR03QnSIlVkqqsqRoGlLrkNZRbSLUgreG89B6jtEYAcYHMyrl6XRinBShkEoAwFnmg4t4t09jw/6waiy1KRnoeAM21jT2qx1tJw0qTp74OzypQ1/T6D/WAXchStE2LtChrcDaEOuFj9EqCa7YvmiZaQHc53mOUioY0sUhzmpZ5ljT0Mxyjh4+4uj+Ay7PTrk8Pub84pJOJnn99Z/i2sEt6rrizp0J29tbCIZIIRiPbpBlI5T2OF9ifYm1Nc4a6kVJr9sjiWOM/dPReAcNst04lK//732otIgrx+YxAH8Mxtf72avGe+EnrJmWUrbrpXBkWYxzBlPPuDyfIVWEkBrnJdJ5ujGIPGeAozo/43K+RAjJ5WyBl4J+r8/sckqcJlgnEKZifvIAqTIOR4Kb+2OyTkK347j/3pu8Nc/pd3qt5LNBe4/yntI35KXjuGo4XJbUDuqqYXc8IO15jJBYW+Azi0sklQflNNN5jakqFLJtRAbX8nWzyxiLag2TvQh52MKHecB7T5KkGGNJohiBI4kjpGxCNJ+UpGmQZ2RpRF3XpNmAbpwgqpxUGIRo2Ikidvpb1I3gd779iFlT4ZKIKImwWqGkYtwdUFYN2zvb5AsFXlDVDdY46uNjkjRjOBgxmefMF3PysiZfLdnZ3qLX6TC7PKcuViTjHqKboQSknR7WS86nMy6nCxob4vCU1ISQOY9vmYhaaxpnwmfSmmGn+xM9jX/iwHtN5/lRTtcfBd2hs23DpNlY6rphtSpYLXNAEEnodGKk30NrCS5QktaGX9PJhMVigRCCTpYhESHDuyiom5q1LiQYBzzeuBZlhcOjtEY4x6oosBcXZFlGp9djMBgwm845vzgn1jFZp0OSZsznC4qyZFU2NNaTJBHHZ+dIZ9jf6nNwsEO3l1JVFqEilss23xePkoI0SZE+ZHrjLQJFHEXoOKEsa7SSaBUWQFqHPrxvDeSCRtEDq1WBjmIaG9wtrbVEOgZr8M4gfDB6cV7ghAoRJh5sbahNgwHKMkRGddIs0P7aiU1rtaGbXXUSfUzZenJ8khrsx8BBfOz2jzqa/kmNdSd+o8r9KNX3yTtf+Sna+8hWp39VrxSeyAlHq9zdPN1j8C2C/iq0TEOnwMl2MgVjQtW21+lwvXfI2I4hHlKKiq7pQ9NQl3OyLCFOErSK0J0YISRlXnKyCFRprTTGJiReky00u+kB9+cV04tzvDGkSYKIK5ZVyWrWkJea/Vduk7NC6RrVVPSlZmUNwsXkRU3cH2CdRmeKMjc0LkZnmu9+cMzl/Td4+uBZGm84vljye199BxfFzCpFtz9gOlvx9a9/GY/CupqmqNgfX6PbGfEX/tyvUJpLLh+8z4uv7vB7X/7v+Ov/0R8h5RB9e49Xfvl1Tk4ecv/OMS889wLDQUbTl1yYmspYissTosiRdRPmzZzRYJvJuwvM1JB4gXUNppVcaGnRwjA5PaVYXCJ9g60apLDoJOX//jf/Y55/9jlu3nqGRW3bRc+31fp1/3pzqDc/1h6syPYeXjw+VdrqPZ5NXuzjx7ZV/KsdchHAetgAXil6CpA+uJKuH+/Wz+J+vALSP894+bWnuXvvhGefHmGZE3cGZHqPy9OCPJ8TdxPuPSiJIsXW7T53z+7QLAyz6IzF6l0uThYc7vbRScPFowdUpUPLmJ2dEaPRgMtHp+gq57Dfpdc/YH/7Or24z2JZIZIOn/2Zn+H67ducXU5IOj0a48iLBd9/800iJdgajzjY2yJfBkMiIRWLxZKz09MAanRMkVeUVcmjh/dp6pLXP/s5trf2uLyc8sHDh9ROcO36TYbDPmdnlySdLiKKGe7usjve4pVnbvK1r3wF09Q0Vc1oOEJLzWwVYvyapsE2NaPBkLPzC6TW7O3vU/lzmuWS4aAfjqB1pElKYxqsMVR1BTguzi+4dfM6Saxao1FDURTEWZfDayMm0ylSSSItmVxOmS3m7A4GmKbk0dFDlFTMJnMGgx7P3L7Gsqi4c+8M6wUKWC0a3vreCaZyrBZLHtwtefvdFZ/9hWcoVjCZVEzmD7nxdMytp2OGvS2+8ofvcPv2AVujPv/WX/lzrPKH3J99FRpNvx5z/NYCYQRF0dA4QVUrVlVOXlasljkWj5SKpjHEbfasaQxJquj1I3qjlOFgm6z7HN9/59tMzgs6SZ+qLHn6mX329xp2dhLOzufcuNbhzgcP+cMv/Tanp3fJy5wbt/bob4/QSURTNrx/9y6lKehmu3zzW298otfAfD5/IhNaCEHd1EEyIiCKI4oyxzlHp9PZREVBKHafnp6Spil7e3uMx2O89yyXS/I8pyxLjDFXsq6fzKoOvajQYS2rEJOzWuaslpY8rz8Ww/Xx8YPXcCnlxlC1ruuNLnpdIKzrQAVvmmYDPLXWG636E5FjPnTvAyXd4Vwwkd3sCUW7vq3L0O0+0nkfTAxFDc1jqnlZlj+AfSc2QDl85vyJ/UlouNT0ej2yLCNJEuq63mjSgU202doV/TGN3FE3JRpBHMekaUqe5xs6+1Xzt4/+/sNGAEnBX0W0SRqdpLM5HHVds1qtiOOgYU3avZoHrLO4tsjx4osvMvrcT/PdN77Dh0cP+M53v0Gnm/CZz/wU9+5d8uDBfcpqycnREflswrPPPk2vN2Q87oO0zBcXSOnp9zrk8wneWZx3RO5Pfr8F4J1pv3PTyqV8oEB7u3F1f+x2H4rU8mqsWNvE820nfH0M16fC2tUbKTbgTHiHEq6VrRqkDD4AzjoirVA2wjaWqsgRTYP3gkw5jIdEe+JEoaRHS4+WGuErTFkQeUldwnxuMZ0UX+TE0lIsF2yN+qwWFo8JudwodKSZLWoenE+JblxHVBV+UdDppAyGCWmc088KmqpmWTuwkqxoENYTRYLGe5SOcM4QaR2iwXi8XZVC4F2IVVYywmND41KA0yqYV0tFFAV9dygkWZSCKBJoGbMrQvPugZ8xswue1pLPdAdcs5p3ZzO09MSdhM61XQpjsDIEd+1t7VAYE6LJmoIojmiMRwrFYpUzXaxQOkFHMRezSUhncg7hHWmSsL+7xc54RDdL0Tjy5RxvG3rdPssipTEepTRxFLwknA20fB1JkKG4ooQA6zHeYKP/H3E1vwq6/zjn66ua3aDnsRRFyWK+YjZbUhRlgDu+CdWWpiYvRoyGfTpp+AJXqxVVXYeJUgiqqqKpapwNmieHfUJvG6Ijgv5IyJBNZ52j0+2G2IemCbmHrfZme2c7CPMbS54XbeRFjFAando2Dy5k7u1t7bE9CCYiWjqcFuSFBQRJlGB9RZKlKOHBSSKt6GYZMrgvkcQxTd3Q1BUqSZBS0OsEDZc1DUL40LWXEmMsXgjyvAQZqr51Y9E6RkgPInSsg5hX09hQUTbCY3FoHW82/kkcNGTryS0slI+PzXqBuWqk8uPQvX/YMf+hZlAfAwItAXdTsfRPPO5PcgghHwMgvwZAj2ngV/2kw11cC9QDKJKtZjHQg+Xmfo9PTf/Ebf4KQ+oJIO7BC48LnHO0TGiaUMWNuymNDBOs1ApvHKPumKUL3ghxElE3NcZ4FDHG+RCpF2mkSKgbh9cCJzVadVCqi4pyGrtExwnduEuxMEQmYXmx5GaUUJgqaFBxjHoDPvfKy1BXLFclX/v2d5lVNVZKDBqkp6hyUB08PXZ2byFUxOXCYM5KapUTxWkw9MsNbtAl6wxYLab0h7s8//RLTPOC//Yf/j3KiwcMPQw6PSyneO3RnYRsu4/oemS3pIqX+G0JAyh8hWksAsHJ+X2G+31U5LEqYmVgclaS1QkKi8NivSCREbKqka6gOrsAC86HLEwpLa4pOT464r//zX/M/+Z/979FloGh49cHfXNUf/Dw3oP1bcHl6nnk2+MdCj3OrdkSa7p4oCq2ZybrxvXaI2N9e3g+ifCBfeE/cpbKT3hDNbs8I9GSh48mbO1G/NHX38PUKb3uiJ09Sac34p13jnn5MyNcnCOlI4szSBwPju5y49YN9ne2WS5X7O9t8/b373GwN2R6seLy7IRq3nBrtEs/2WaU7rBallgXcXhjn6deeo7P/sxn0UmHF7YPyNKM2eySsiyQCrJOzGo5xZmct996h6ps+KVf+TWG4zFxGvHq6FMslwWNNUS15vn+s0ipKMuGh6enzBdLdKfD65/7HFuDAWmsWeYrtra3mcwmvPDCczy6e4+zk4ckUZD1RErTlBUXswlCqc0GPun0KI3l0aMj8rKmqBpWVU2v06XT6VCuClxT41xDooPZ5bDfZbVaIoXi9PiYl158jiJfYY0hS1POz8/xXLK9O8YLGA226Hcz5rMZhpqL6SVJFNNJO8FspsyxVYFtDP1+xuVkhTWexcRz7x3H+cNHvPLqc/Syhnz5NnUlsLbhu9+9w7VrPbxf8vKru/R7lp1dR5xecnK+4ve+9I948cXnmE81y8uSXVvSE12ibEjesSzKivqixAnQcUy3JyjrOlBupcQFHQVSCpz17F8fcf/0PU5m77M12qFslijviWPFs7dvU+UNwmnm0yn9boRrJjz3nKFYPuTo7gxTpRSl4P0/vMvB9SEXJyuOz3JsFbM9Vsgr0V6fxNjd3ePOnQ+ZzWYAGzdrAKEEvvGb+CpjTDArS1NGoxHOOSaTSct4CI9brVZcXFxsGgvwpNRqrQ9ej6zbwTeGvJwymc6RUiFEGoCo++dfO6+6e0dRRBwHfXSapqyjtK7GblVVtYkF297epigKqqpitVqFWLR+L2jS207wR9dzCXjrWEPpNahef194jysbkrZYUdc1WZZ97D1f7T6v9y3r4b3fgOW1fnxNBwdYrVatq3NKkoRM48f67NA1e8zOfAyur2rNr+q+f9R3rpQmiROSJEXrBLRHZS2obo/1+jOudfD9fh9TF5TeIKLAbHzvvff4/Od+mhdffJ69p3aZTCccn97lgw8TJpMJaSZp7IqyWmKMxxrBdJLT647IOh3K1ZQ4iehkeywXC4oqOEJH0Z9Ojrdpmic62aE54aD9P4TYW+fW+8j1+eI2hWhrzRPHw7fZ3kK0Si8Jm72XN0RKgRUoIQMjzHlSFSEjcNbS+CbMUd4GpzMHKvJh3ceQxCLU0h0kUtLUNbEChCN2QebqTU43kVSVwWDBlWQJOOOR0qNwCKfwRFRVwXS5pNaWVd2QLAoOtrfodAPzocpzqA156UiihvVUoJUO56q17U4UtI4AH1gMxlCWDZGiLZq1zcw4wvsQD6a1JFKSJI2C+7/WoSBB8IyKascsn7FQK8a+4bV0m5dySTldYivDeG+b/b1t4vGAk2mQJ2aJ5vr+Hqum4XwyIc26rFYr8rIJUpI0BWOpG8tsETwIlNYcXjvAVAW2qYLfVBJkMLqT8cGHC+qLGZ1en7wJe3RrDOjg4+WlwBiFaEk2prGkaQYIylXO0v9kzQP/RF3NfxDY/jj147FBRZEX5HnBYrFksVgFCrcN3VXhGoyBWCsGw/4TNCApJZHWmLYi6n1Y2CwETYi1iBZENk1DEgdTE2sttmmQOgonk7EMR2MEgsVyyWQyY3d3izRNObh+yOnxGWVVo+II3wj6nZDfqmRBFMeMh0NG/YyOFoz6HYpiRlGsqCtPr9NDRw4vQGmBM4ZOmjIa9sEZjAnufXiPEsH0wNkG4SVCJ0hBMF3JUqRMcYBxPhhjVRVeSMq6QUpNURuWqwJr24uIQLGqEEjvaawJFz+exrpQYFAqVP78Y7C9XjDiOCZJgqP5egL+FwXd/7zjR0OXP7lhvMF4C6zjmdwVvHx14yA2oGkNvPF+jZvWtxAKHAFQSSvbbnYwyQjZlbD2mVvDMk+gCNXCIVqDNCkERBqZRNSuofYNWRLT5A390Tb1SpEvEpoSmkagog7OGvrDDNs0RJFi0B9QNybofbRGeNlS9zzWOFQU3DGllGihsJWhmTc0q5JkmNBUFm8UJ2eX/M7v/QHSWqIoZbGsQtyGcUiVYJzFOkckJN4EU8Tj43lwsfXBlCxGkK+W5PMVSMFitqLfyXj+2afpdlIWdYn0nrIsSRxUVY8PPpxh4ojujYxrr/aIoyP+V3/55/i7v/n7EFfUeGZFiVMJRhaIkaV/OEQqhTYx9aymnJX06YYJW0EsFZiaREouTy9wRR6ulUhhTaiOJ3H4rn7/93+ff+/f/1+jCekAdnOE//jhxZViytU/bE6sq/rvtpCJbM0JxeMnIRRj1q7oj8872g5B85EnX3fJP1mN9+d/4TonJwtmU4vqVnR3MmbTmsVyxuyOo1rAjf0+N26MqOYL+k5TO0+cSG4/dYOqKKiaCXHk2dmJSX/qaao8pZi/wyDq0LveJTUdFhPL6EaXZ56/zeuf+Sm8h2s3n2K1LOnrDmWZE2tNVdYoCVvjAVpBvzuiqSuEgldee4X9gz3miyXTyWXojq9qDm9cw7gIvMEYh6fkm1//BsenJ/z8L/4SWikipfBYLpYLalszGvS5yFesJpdcXp5TFCuWiyVvvPEW+SpnMBxi8fT6PZIkZG8fH52yWizRccZwa5uGBUop0jhmmGTEcYTUgroJ8/V8PiPWAiU1s+mMOx/c5ZVXnmc6mbNcruikYZ7uJBFFWaKE59r+HtujEd46orRHbR1NVdFNE7xt0FKz1cuIZUmqNccXc1Zlw/0Pp6Sp5Pjed3j5tae4eWPMYrbgmedvYI2jzC2Lac37bx/TH5zwwotDhCzYHqcc7HVYLCYIO6CYryhNwl53n/PzJUpHNLbB+YaT07OQidwYOlmHxjqW5YqqLp9wojXe45RnXl2SMOFyVpOmXTqdmMUqJ9aK514ecvqwRivPL/3SbZK05vzuhOWsYf9gj29++4jp3HLn/QlRDxaV4xtfe8CnP5Pyymde/ESvgevXr9M0Nefn5ywW4ZiWZUmWZQxGAxbVHB0HedzVOK6iKDaAVUpJWZYsFgsuLi6QUrK7u7sxGluz9tZd2TVoFEIEVlsUE6fQsymmMTSVZKZNcNq3DUKoDaBeg9QNeFzLXHgyP3ot04uiiOFwyGg0arvd9SZObP1Z6jpospMkodfrbTrJvV4vyOecC8kPVzK2N11iPNIKnJebTvka4JdliZISaXygyV4B2PD4fes1nfYKFXxjutvuHa9Gna3vv2bzXf2O16+x/rs1FtFKBNaFhvV3sH79q9T09R51A7592+F2FmtAoEmSmG63S9bJiKMMtMOqBuXVhra+ZhSs91VpmjIcDokl1MWSqgoGwmVZIpRn72BEp695++23ee+DNzg4OGA8HpEkCaPBc7gi7PsePnzEbLbEe0lZgFYxk4uCe/dPkMozHo0Y7+x/otfIjzu8DfstCCZr3l8pOHsPom0SrUmEnlbW5bHG4tcFatGyJIUP6gZAEujXoZkVnkAQgLGO0gDunWsbIO2ezwnQIGTQR3sXADeE6DHvDVoEl3VJuGacFOAdSomQlsQ68UTgpEd6AdQoBS7YLaCERXnI4hgrJN6sWDnJykO+zLl/fMn+zhaDbkYSZ0Q9TS+B+qSksQIZKYwP2njhW9NkINKaumnwNjikJzokt4QM7zWVX6EjhdYSrRWCBt160dimodfroRA0dcOxmSKk57Bs+OVsxBfrHtHK8K3lgu9FHpcNiGLNIIvpd/bpZSm+rlgVC3pbW9x5cI/5fIFHIZXCIrmczkiSlLq2LFdFaChFMYN+HxMr5pMLhFaUdUOSBEPKbu8h5/ePaLwkSjqM+z0Wi5wiX2FsgpBg8CgRCgnKhj2Vw1Nah/n/pzix9URU1zXTyYz5PGe1WlEU+ePwdiWRQtAf9Llx/ZAk0vS6XdIkJYlVCG2PIqQQlEWBaRoEIlRUraOpK4xTOGex1lGWFVJopAz5iE1VYY2l08mCvsEGi/0sy6iqkrOzc3Z3d+n3++wf7AfAOp3jPTR1hRSe0aBLlmVkaUQaSSLpaOqC8XiI9ZLFYhYANII40jgsUaTIspQ0iYllQqQEyzxHCojTiCo3rPmjzhpklBDFSaCBeIvHU1U5RVnSmGCNn2Y9dBRhnCNJM2xZ0dhAUzcuwMSqMVgXTD0E6wgMSSTVle5siPNIkhCtto6wWC/CV4sn67FeHH+c8c+jk/5XaVgfKPu0koFN17p1jBa0oLvtivt1c9xfSaL0geYkRdt7FOs8bZAuGNJ4QRBye8Ha+2rt6QkEF1oRpBkAOOh0Et74zjf57//RP0ALz3I6QQrBvQ/exzWe4EXiKOoymPT5hjJfEklFoiOaqkBKRT9NibsJo9GY80eXYG1wwSxr/DpuRYSYCrOcMT0+5fqtF3l0tMR7UDohr5uwcapLVNahrg06SSnysGlKIo2zNbbtKEymE6wzgcalJflyBbJmcnrBcBQRJx1GwxGr1ZwkyRgMuhw9uk9V11Q+4c4dy9e+8YiV1+xe38b1Nc7nuLzBLUrSQcRlWeNUBxnH6J7jhS+8Tn8wpmgsXZFxcnSByAEVStXONSAUsdCYvCCfTNGKoH8zCoXHGUtdeDpZj5eef4FIRRgDttVROcwPY24+Hj/iEnh85jymP2xAuCcYptCeM2ue+seedt0lWN9nvQEU4fZPcLz34YztnYiOdUzmJfvDPdxwRT73DHoRjagAzapYcnR+n4OtIZ1kiNEx3/7uHWxZ8eLTt1nM5yzzhtXKcOPwKbJexlPjQ0aqj5l5hocH7B3eZPfmdZ5/8WWOT05YrFbUTjDc3qfT7VHVDfPFnDt33mN/f4fxwR5xHHF6PmVn/wbXbj5FYxq6vYys8xR4Rb+/zv+NqZsw1zbGUDY1+4fXqEyFlAnvf3CHOIm5dXgITc373/8el2fHnJ8ds5zPqeqavKwZbu/g5JTCtFTHRUV9Mae2hvkyJ+4M6A1H6DhlK0mpiiWmKpBSIEVCJ+rQHfSIkoR+r8N0OmO+WCJ0wtHZlPjDY566tYuOJJ0soqxqOlmGUpJ8tWJ3vIU0lgcnp8RZSlOXzBcrFnHM9taQLOlgbcNw0Kc36JOlKY8enaO1Ios1i2LJcr4iTeHy7JxUK3b6Emktr758Ha082dgx3HVk3T7Cpni7oKo83//6A7bifcb7u9x7dMyiqMktnE9zoriLFhNwYR6taoMXEuEV3jQ0tsFbiVASZEF/S5D0a6JIkfQaFrM5w/HTnJ6XzJfnNH7AVnfEB3fusH9tn4wOiZ7xc5+/xh9++YyXXh/w4GzKMpc4PMtzS1UY3vz2HX7pz77+iV4Db731ZpB8tQBVKUVRBInBcrEkHWRUTblx0l5LudYd5XV02LpzXJblBuRprcnzQFPvdrt0u13quibP85ayngQadd1gXUGUiADOogG4GXu7uxw/vNtGeYXF5aOu2751VV+PNei8ShdP05Rut/sEjXr9GGMMUgbzVyklo9GI+Xy+Abur1QqUpJtlm0L+k4AVnHlcnpZS0ul08N4HozlrGaRdqqp6ApBeHWta/Po11z4+cRxv2AHrn2st+lVwfLVLvZYCrJ/LWgNC0rjHEWbGmE3nf/15rnbQH0v4HtOdG9vQ1I5IC7SONkWUKIrwymF8szkvPvr9rz9TmmVEwrPCURcLut2gVd3d3WZaHzOdHTPaynDWkpdT1MIiV5K6NMhG46zHOsvx8QPyYozWMf3+iFW+YGvvGnm+wMqY5hMu0P64w3OVEeEe081bWvkTJidtsdq7NQuhfSzrbvjjYnUA3YGWHhRZIelFti7fXtTgffBDcUHi6X1o5AkECo+yAu/aLnt4RoQLYN95gVRReD2hQlFcBX+V4BftUZJwHa4/Z0AuCALVPcJiXYWXEOmIBSnnFwuK0mKN53RxiscRx4pb+7uknT4NEhRYLzHekWmJEoE27j3UrdHfupC2vt6MsehIbfTuwVTZ4lyCMZZG2U3RqqktTWMpqhrZUfRnS/5cusXP1RmiqHkrEnwvi/hQWbyvkPmM7Sbj5uE+aRbj8Xx4/y6sFOBYrnLK0qB00IE3tiaqAoW/rEqUDmzbSCu2BjtkkeTR6QXHZ5esViu2tnfY2tnhfLYAoRn0ejS6AeNw1lNUVfCqUALtBal3oVHrDHltyI0lTf+/PU5s05tbT0BXr40WPjha87QQ5XB5eclsOidfVUGHnWSMhkO63Yy4Bdf9bpeb16+TJBF1VaGVIIpkS4dmA77rqsY0Dc5alnmOsxalRTs5hgUiz1ctbThMcrVzGO+oTEOv2yNNU1b5Cu2DS3jQC4VoouFwiHUhhgsXUxVLcAaswTaQ24qkn9HppBRFQb4K1PXGKqq6RurWYV1KpPcURYlRkm6WIlXEKi/CZsN5Ot0OUga6TV1XaJW2E6VBKkWaZZjpHOchSlJ86+DuhMRLifOhOmt96HjrJKVqapQSGyq5Vhq8II6SVotWsnaSX0/ykdabOJMoip5YXK5SxT9KG/+xzhf/gyPCrmq8P5J0fOXfn+yQPNbKirbjKITcVEQfLwRrp2rfghu5/iiAbGnBHiHc4z6mEDjh8WLt8B6Ga6u0688s2qqs9B5hPbEMlMUEzfTkiH/7X//L3LxxQC9LiVQExrJcVfzBl/+I//Q/+T9jMAgPMk7IkkP+Z7/269y4cY1et4P1QRNUmRqc4Hf/6ZeYnJ2HzywEst0ANE1DX3WpasHycopWEqkk3krKVuMcRxFVWSGdQOqkNblRCBcqrd57vLPUdcVytSBJYkaDPnlTULmCxWzGeDxmZ3vEdF4y6HVxeI6OH9Hf2UErQRwnrCaC//xv/RMeHReQ9RBxl4YOxxcL/vp/9Hfoja6xfy0htw6RpOAcSaZJuh1WdYO1kj5d6oucrkjw1uFVS/dSDuqSa7vbPHOwR21WdDspSZJSlSXeOXq9Ea+9/ll+8Rd/ORwv50NRwpmQJvaR0/TxpSE+co5/ZPiP//L47mHj4YUIjq/Cr+Xhjx9x9fECQjJAeyWtu+JC8Dg3/JMZd99rePfNM/KVZbgdsXety2svf4ph930GfUUnURTLkkU9YziMcb5H3XR5cO+IvLFEMuXh8YL5ZIGKNcY6Uh3z/P5trg9v4gtH5S1Rr8urn/0suwf7LJYr4iRle3ef/nCLfr9PVTa88f03uLw8Y3trxP7+NQaDPtPpFETEy6+8Rl3VnJ6eMxj0KYqK+w8eMhiN6HS73HvwgCRLEUBZFDz7/HPcu3cPvCPrZOwf7DMa9Dl99JCv/MGXWE0vUN6ymE5p6oa6sazKAiEF12/dRCCZLZacnJxyeXmJjiKE0ph2Q3d6dkYUSXpZSj/rUBcF1lqmsxlxkdPtdrHOE+mw6W5MDVJwPplweG3I9nbQrQ8QwafEWnZ3d3h0dMTWaMR4POJ8OsE0FiUly8WSTpqQJgl1bcjSDpGCa3tb2LoCKTHO0O9kjEcZ154dM1lOee/9u+zfFpimYrgd8fQzh7z97lucnxXUjwzjwR6ChunZioPOkMPuNSZnc1a1pdPr8+DDB0wnM5LOoDVGhaYuWsM3gXEmFBsDtQehHI2vmcwrrg0hy1I8jsXcscwrLmZLLi9XvPrqHo20XL91m8YYji8su1s7DDqOKD2m9gVpN6aoNFpGmHqCsY6mMXzpS1/7RK+Bhw8fkiQJWRYiQUMRO2iIy7rk9PSEvAxGWYPB4IkIqbXue52dHceBVbcGf+PxmE6nw3Q6ZT6fs1gsSJJkAxS10shEYpyjrEq8UFyUF2hZMhjs8vzzz/HmGw/azf8PHlprZPzDN6LrIkCe55uIsKud86ZpNrFcaZpuOrPT6ZTVakUkHtOm12DyCQadD2ZPVye0daddSkmR59gofSzDajvKV+/70XE1pgw+Hj92Na7saib5VU38pvMtWrakfUwvv/o51ret5/erTYvN393jWDF5xbNm/V7wDicev/b6M673ZOvPlEQxOkmwaUK5mlFVwZSwN+hyeV5hXcHu7jgwyaKIyXRCVVUkOqGjQ6rP3v6Io0dnXF6W7OzsUxQLGlNxOp3gvMEKyaM33uT2zd/44SfNT2gECvmTwHuj5RYSIdd08qvmdqb9/h9rv4PnCo875GvgLUJzIyT1yE1X3UuHaBst622dd+2ernEIL4JMyxP+HzZ/OOPCfWTopBtr8YSmjUCADA3BwG0MxmYhVEBg2+cQvu3IS/CtZBRfY63CeJBxhxqPj2LKqmJ2MmG6aLh545DKCoyjze62WLH+DsLedX1teqCxpmUcuU2XSGmNFxYVaZwNEcVxEgMCrCCKU8qqoMiXJFoyrBq+kA34qbkkNSVvqJrfdQ0nu7sBwNua6XTKMI7Y73cY9/cpbE3azbj/4CHGBn8t62uqsiDyJpgrliVlaZBSk2UJ3htm8wla9Nna3mZeWd5//31OTho6vZD0kWadNt3AUBUrTFORpgmFsRjrEFJhrccrSLOMyhpoDDIWCP2TLSz9xIG3kMGmnzWFUjzWpnpCXqSzwWRlPg+ge7FcUFcVwnmyNOHmzQP297ZJkogQdu/ppAm9btAZiEgECkQ7AcZxRKJDnvfMzLDGIKQkSmJM06DkGmjaoP+2dTuRKZTSREoRS4lwnulkSpymSKmwFrCO+SLH2JCvFyUpCEGURPS7Y4o8Yzads1gWpEnEeNxDJAk+jimXFbNFRV43oAQyDROFrR2R8ChvyHOD8YLzedVWvxxaBQqIjsJEX5QFSqsQi+YcOEOWZoBEJQnWVSgdUTQNMRKpNFrpNu+yRLpAXa8bC1rjnKUbS2IliFXohFtnA7XYWrSOQmchCfqIdRzGuqK7Bt9XwfKaovWDuuEfO0fED8px//hYVyu9d+3Pq8/5pwC8xQohqlBRpV3ghcTLx3ZXa+At2wk/+BMI/FobTnubIGwsN3FTFuFNmJxdG6C9eUALusX6V4l2ofOMBWcaVAKj3pCbL77A0f07RGnGdq+H8J589ZDnXrjGaz+7x+e/+BpHR6f89j/+NkrCv/tX/5ecnNxjPO7x1O3bLOYl/+x3f4dbt29jcsNXvvwVlJTUzmGbhg1N2XmEg+pigm4LEc7TAjlFaRwySqjrBi0Da0MJGXLEaxMcSaVkd2+H9+6+CwJWiyWNrenHGYtiwnj/Js6U5IsZxw8f8Wt/5lf42le/TXV2SaebcbJcYQvPt944wQ/6CC+Ia01UDDg9mXA+S7n5yrP4WIFxIBZ0ZUFfVZQuQ3b6mEpRPloQVxCLkJccVj2P9AaF5//wv/8PePbpWxRVG7e3kbkAIkRVFGVNbVyIMDMmyAD8x7vJV0/hwIZYXyubM+jJIULhxl+pNXnf0srX58W6+73m2q3P1yuvEzYv6+cM544DPmFTc+6+N0EoR3ekiDJFWVQ8vDvlwf0T0g4kiSROLWkWMT03PH1rxMlkwft3zzi4uYURNcvCsrXVBxKqvOLy7hkvbL9I1GQYLJfzc156+hVk1iXtdEnjiNUq597de4x3CkZFxcOHRxxcO6DXS8mShE6nR1FUbG3t8fDBKW987/s8//wL9Acj3nvvHd59732eun2ba9euMV8saFpgkZcFnU7Gg4cPGPR7xFLx8OED6rrmG1/9Mo/u3aWqciSWVArKIkTLLPMVeVFyMZkiLqdIpTGNZZHn6CRhe2cb5wWLVUmWdUmShOV8StM0lAL63X4oKhNA9mR62dIBwdQ1/W4HYxydTsr29k6QljQNdW3Y29/n4dEjdByxvbNFEicY7+lkGafLC8oy0IAnkxn7e3vEWgcvFQ/9Xpe97TFCKSbTOav5ije+ecrlomR8veGXf+1FGnvBvQ8nrJoLcitxquHsyGDKDnNVMuhpOk2fSA6p54bp+QoVx8zmOXles1jmLKuaogiU8rKqaYwhjiMi1YLxtlvV2xVkI80qB2fHHOy8wsP+h4xe8zgkW1GF7qbce3CM1hGj7oA7dyacnZa8cDjimYM+158Z8Mb7OQ/u1MymDf0tRW/YQakCiacpP9mLYG2ytaaP9/v9DTjrdXs8/+pzNLbh8vKSi4uLjYZ4rTdummaz7q5WqyfWybXp2mg04uzsjLIsSdM0nDdtrFW+ykl1xHZvG0TYK5hGM+zt8KnXPsU/+R+/zHL+w12qPU9KyT4qGVwXCVarVfCyad/rOgd7TR9fZ2SvKfFXadJXKdjrDu7j8nrouK1/X38PUkqSJKEqyuDfc+X9XN0bbBoDP+CYXG0aXNVkbySL7ftf3+dqnNhVcG+tpbaPgftaA7/WgK8fs+7Ifyzfu425dDYA7Kud9oYWeCt3pVsrNkkyUkp0pDf56c41m883HA5ZLpd8+9uPSLcr9va3qKqK8XgYGDe+g7MpaRwRC1AyItKW6ze3mU1yGrPkzt0zsm4X4xyj8ZgXnn+B49OTH37C/wSHX0vt2qZFKDqswXjwgPAuSCSdD/HD6y5uYCQGOaAUAuR6vWxZh1K0AF604Hz9ooJ1zWO9Jq/X3PALeBx2U/B+3FEPBmAtoPYOuWY4ehAmnCsaD84jpQsEu3aEYoANZqtC4/FYT3DAr3MwCuUFy6piWlhUEooPcdZjVtXUR1N0b4CWGustQgmcDAV6ZfyGeWmB2jRtU8cQNxpFiM9DCWQUUTtDLAWVaZC6phttIyrNbFZR+pLMlFxz8Asi46XCIpee99KU3zY5b/ZSyqYhIkIYTV5YlpXlLC+pzycUTc3p5YJlKZgvc5ySRB1NpkKKh6kdzkmshf4wpddPSDOFrUqWq/DdOSeI4w6res7xyQU7OyMG/YzZbIoUCgfM8xKVeIQCLQKZ0RlLLRRRDK7xxF4ilMbbn2w88U8ceEseT26yLRWtq074oBnNVzXn5xMmkznT6Sw4zGlBL43Y29/i5s1rjAY9Ii3ABxdvicBas5m8vZebiTSJQ6TKqs2MhMcam5B9KZBObExI1hNi6ByE7EYhfOuc6IObahaBc0gZ7n95eUnTNMRxzGAw4OLiglWRBzAep6wWS/LljEdHR1i3jXMG0QiMcehI07RRYiocfXxTB7BiXcgyVRHdTocs1jjrkJGiqZuNbsqvTVECDyZUwRF0ux1q56nqZuPkjjHUZYGA4Izug1FJcI6VRDpGynaSdx6hYhrTUDcNUnhUS7mJ2sk9zbLN4lrX9YbWtabIwePO9Y8y0lvf98cea5r2lcX1T4uiPmBCLEpqa5BRRNUYtE6xQmC9bDVpKhhaeIuSbAo4SqqWfqTxDtT6upC0i0XQrDkXQHjomrcV0LVLdlvp9l6CiIPOWIBSEcZIpExIkh7DrR0WiwlSwI3rh3z+85/j7/2j/4qf/cJL/Oqvf4Z79x7x7vcfUU4ksY5xjeNrX/kydz68w82bz/K5z3wWaxxFnpMkMculXe/GUDpQsVxjwDh8WSOcRQuPE8GJ2wsVAKlttWlAohV1WaJEiLWy3oO19Af9UHnUksnlJabI6feGNKvQ5f7VP/Nr/M7v/AEn53PyoiLJukxmSzpaUlUNzoKOupSmQQhD1yrqO1PE0rN/4xa7e1tcugmxMsTk/MbrN3nt9g5/97e/y935jEjtsZwviIwglorKhZitOIqolgtefup5bl5/mvPTAqccFhvOSREKd4/p3leMe2RwRl0XT66yfsL/1x4XbOZF8LB29vVtcUO0RZsgBCfshVvTKWxb/Q/GMlcr+xsWCTy+Xaw3tgLWxwiBFZ/sgvPM7T3uPDjl1deewUdzPvzwLrtbsFp4VjlYVdAfGZ7u7/HU9Wd48OCMs5MVnSQh0Z7T0wUyGzDeHbM7OmRyf0JUJ5Qrj41Knn3+RW6/+FO8+KnXGY63sL7i9PSMP/yD32c03OLlV17lcrrgvffeZZkvuHa4H0yuhGc2m7JYLPFecPPGLeq65u2332RycU5/0GNVLPnGN7+KUhF4x/vvvccv/OIXuXP/HrWx7Gzv8e1vfYv7Dx/y7HPPhvMkTdjeHeOairvvvsP5xSVlWRFFCdZBtz8kLysupjOaxhJFmt29XQAuL2cslwUnJ9+j3+tysLeNwPHg4RF1WZCmGfv7u9y4foCQUJcVddOwXOZYBFtbI5z3HB8f8dwzzzAcDsnzkuVqxWq1QmnNcDDAWhOiKXUU5h3nGI9HWOs4Pj7i8NoBddNg6oY0Tdje2aHb6/HMMylf/vq3uJwteffb5xwuNa++0Ofeuw/Z3ely6+aQfFUwGveYnIKmS9JEjOyYrhjz4f2HKNlQFZaeijg5u8BJTdUYUi1DQoezJGkEDSRpjPVQFiUIUCk8++qY0W6Hd985YTopuf/ukmefeYGTs2OOzy44OsnRscMOB+wMBxyfW1ySIDPDw/MFOrLQ8aA1UQqNzZleLljHCEmpqKtP1tG21+/gfIiAWiwrOt2UVREAdJxqiryh2++zvRXT1IKqDPrgfq/H1rhHXs7RUUgUcc5RVzVVU3MxuSQvCpLWRHY8HrO3uxv8cYoi5G37UNj30pFmXTw2RInWhsyuuHl7l529IavlBGfDPgofKJ/eeayrQgfMtQ0UAvNtvf5LKQOLUAgSHWF1hHAeHWnSKFBChVTUNqxpxkJZGxrraWwo/ggV0Tjbbuo1XoRCy3qEDuGTa/yaHquUQmlN0TRo54laWWHTGJTWYZ3FUzZN8PcBUBLrW/8f04TnbjO4rQlgrW5CdFnqBbGQj1U57V7Grgv/7W0GjyGsd9Y7hFChi+gCc9KZBonHucf6dGtrnDN4/5jWv2Y+WWsxjcEr1R6PViDkQwSSkLJtFEm0ipFCIWWY252Fpg7sjSgRLFanPDh+h307oDcY4B08eHBCEmekaYckitBSsJidBh+FZsbu7jWef+EZjo9Pubg4I7LQ76ccPXrI1niba3vXP9Fr5McdYf1aswvX69vjSLB1As8m5/uJIvZ6L/p4Td2kjMgn96ruSmW75YM9ySB73DVpm4nrV7j6Xtc6ctEyIt0GlEvhN8961ePq6j55TZZcvxOBQEiBEqGrnnhBGgmmeYlzoQBrGkOaRIgo5vhiwk4aur7WO1Qa4/AkcUQUSeqqbj1lQozYmidv9dpryGJyT9ZN8cbRSRKEAiUkZVmzqlcstUGamtfTLl+oE3bnNdOm4lG3x7up456VmDiimi3RUYaRgYFbGst8VTJdFcyWS+bLnKJyRJHGuQbrHP1en+2tXUzjePDghF4/Y//aLnEqME1ON8tIZISvHc4Ysiyl102R0lPkOcNBF28bIpVQVUHaJdrvOFDrW4+rxpAXVYjIk5JEa8qm/kTP24+OnzjwVsJuTq627b0Bs7V15EXDxcWUi7MJeVECITLl2rUddnd67O1tMx72SWLF2urfNMGFbl3tu1qljCJNUzfki8Umk7soilYj3lYJr1Rvr9J1hBBkQmIaS2MtSazD5Gk8dRnyuxFstEFrGk8URfT7fc7OTimLgkjHdHs9et0Op6cPubiY0OlkjDtDojjQff2mIyzJ4gSPp6kbtsbbSB0xnc3I0ghcsMFXUhBrjRSCJIpaIzhDEscIHWO9JU4ShEiojaeu5uCDWYRUCp0meG9J04R5XlGbqq2EgG6N5pwXQberJAqPdBLRTh5KKfr9PltbWwyHfXSkNxqu9aJRFMUTVev1z6uapE9iXDXiu3rbn/Swq7u4uqITpSgRMe4nFPmCvKqIpCbNskA1TmMcDus9WsWQafAq6H9b9oHWiqqqgoZIy9bhNWjvpdRAML1wThFiyATShmtKyjA7y0hhbYW1DanOkFrRHfbpDTI66fOMhz0iJYhiwd7+FvcvMqrCcnjwFLGO8WnMeDzg1vWf53OffS04+auYSAXQ94/+8W+FBQpgff62KQBKq9CIbwyYBi0FtbVIESY7KQTWh+tXeBdM2yTggvbt9OiY0XDIYrlgtpoz3N8i1UE31xQ1IDg6PuWtt76PjiRZlvH1b32b5cKgVIxceCKpWZia0tU0sibrZ6jKcdDvce1ajw+WH3J6/gDblXS6nqGb81O7sG1PqSfHZOlTeCdZXMxQRoMPE7EUElMZpBP87M/8DNY6rPEEQ6Lw+eWaRi4EDr8hKAjhN9mryrcr6VqAIwTOtxqxdZdnTW0jxKOE49tuvFxbdLJh3pAiGO8561CalqYVpAHrTbq1BqXCJlnIEAPSmGrTgVcybDJMa5j0g7ry/zLj3/lrf5HvvfNN0r7m6KzEnYYc3ayTsSyXTKc1zsEDM8fWnvfuHNMfRLz8zBZeei6bFU7XiCbi/MNL0qpLJxlwMZ3iRcntF2NuP/UMWZbxwXtvE2cR169d4/DwkCROuX/nLtPlipu3bvDU07fodFLY2qIxFZOp5dq1A7KsSxynfPDB+2xtb7G9PaI2NToO8ojVMufe/YfcuH6d5WLJ/Xv36PcG3L13F6UitsdbFKscYy3Xrh1yeXbKB2+9xfzynF6nz3S2oDGeTq9PbT0iSsi6A3q9HovFnKLIubi4wDnBcrlk0B+wWMxxJhSb+r0uKzx1bfjgw7ucnh7z3LNPs7e3h1KK3V2YLxYUVc14POaD99/j3Xfe5bVPf5qirHHOIpXi9OyMLMso8hznfDDzahzb21tYZ8myhKauOD8/J89zpIKHpzm1rVmVJXGU8PRT1xhMlhyfKlbHcz741inKdUlHCeV5RmEK6kax2ztEiJj8uGI5M6zknDQaUFUWi+fo/IK8tOS1w5hQwNWRxDpIknQjlaiKKqx/sYS04cYzu3i14OBwzO5OiqgN3/zGt0nSmHzhqEvYO7iGdtu88fVjzuY5UR+euhGxnNR87+0JSktOTy1RmnDzmS2OHswxNWilqGuL/4QjiuN+HAz4Ko1cCaJeRKZDVzpvCmZ3H5IkHbJOhzQdolTD8fExUhikMlSNobY1jQs68ShLGMVbodjeNBSrgnyxBOexwwHWWqSQ9DrdcL03DbPZnLyOSNMElGS0neGo6O8onnr2gPt3pjijET5GCol1JdZVYGrAIOiwhhVXzcsAIqmIvcDomEZI4l6Prd4AHUXUZcUiLykddLtd4qRDFGVEsQFCHvKqKIkyzaoucSoA58o2fyyHba3jXkeZVaUhThIyqXBSU1YNXR2johhnDUVTBdCiJUrGyCYKjRYcxjYINM77QMm1nqJqUNrhVYTXDq1FG/8W/jXO4a8UB5pWMmZlCKEyInxPlTMUTY10DQr/xF416GwNCIu1IXZNykDpr+uwb40i8JFEogJl2LZ0dOFIkmBuq1WMtY5VPsPGXTACrVPquuLy8ojd3Zjd/S7L5QohIwb9LdJ+RhL3eOrmsxgjcLZmGXVxzmCNoa4t77//HmVVoWPPcnWJNpLldMbicsJTB7c/2YvkxxyPHcrXrubraLDWOb7d23sRnM5D4foxQ1AIvzG7pWUfivV6HR4J3rdA+cptf8xYR8peZW4+3o/6do9wtRAQHvX4PYnADmRt6nblLi0TDUIu/QbvC0mkIJKghcBbQ209VdWgdIgijtKI2jaBlYdGegnOYuuwv/AC4riVs7b0eiUlMlUBGlQObYEypOIQC6STRFXEXNWIrmW7aXhBRfycTTmcGWyccT7UvJU47nU1ue3S0SkUBmNqahWK0411XE4XzJZLauNpjA/Gk1oSR5I0TfBOMpst6fVGJFmX+apgOs/pupg4iji4dkg/yTg7OoHpgigKEuR+v8PZ6TFlLsnSDkVRgQ+RarZl0ngXrp/aWKz3WO9wIrAXdRQhmp9sTv1PvuPtA3iAdeUmbPSKumY6y7mcLJhezimLCu8d3U7KrRvXuf30IVtbCVkaFi1napRWKCnw0mPaHO4Q5dBWaASUZQEehsMhzjlmsxne+41RRZ7nFGURTrJWa7N2AV2DuSQO1BvnwXiHwGGMJdIBfMZxjLWBpr5cLslaU5A4SWiamsYa5osFaRIzGI6ZzS5QKg4TrfOBGiU1aRyjpcSZGmscSRLjnaWXxuC6eGuo6hrvIxIVA4GG53x7EQqJ86GrbZ3HNDkNIffc2QB2OlkSNpBFHnQjPtDW60hT2TARabHeyCuEVO1G3CCEJ4mTVpeVbAw/1pqmq1StNX0MnqRkrR1Q14WN9bgad/JRKvqPAtH/KnS7Af5v/9V/Ql2W4AxNuSKNJJ97/VNc39uhm0hmqxn9NKHX6TArLE3UxxrB2cUUrRKcU3gfcoPTtMP27g4ez3DYYzTURNLhvcA24IlJ4h5ORAgStMowRuJbSlAtDA6LjmXQ5IuMLKtoyinf/973yVcrnr19m1u3bnL79iH93jb/4O/+AW+/eYx1ggf3Jtw8GONFxRvff5tHDx/R6fYZjEa88tJzQXfjTADQpgEXikfe+6BfUq05oamwVU2iIiqzIiJM4iFuq6VAX9HRKaEZjMaUgzn7wz2+8Y1vIKUk7XapyzwY3OBQSObLFb/7e79Pr7fFsoLuYIvecJvlbIkpPbZu8N7QHXQoTMPTT98mkoLMCw5vHfLo6IRCaSIZEfuCZ/uK57cS3n3nXXLTRegxzdRSzQt6oo/zDUrHeOfJRIxKJD/3+c+jtGQ0GpCXBQ4XFjfkJnVdqmButmYvNM6ERW/NXxOts64P1DDnLc5cvQ6CAaLzBiEUzhlAhS6KJ7idujDneR80sLaxRDoO2aIywrRdOy0jrPFIHTZn1oIgQVgXOjBNW7x0DofiE8bdfO+Nb/DcqzcY7+3y8LcesL3bQ8eOrszY2u1TffA+nSwmja5RmR7jkSfrGMbjDtOzU15/dpdBZ5/j9y8pzw23D5/h7vED6qbBqYh7D494+uVXOTs7QdiG0WCL/f09vlKsGA5HgOPawR5eSTqdlLouePTwEdPphKefvs3x8TFHR8fcfuppXvnUy5wcHXF5ecmNWzeZLeY477mcXOBsw4MH95ktZmAts9mE3uEh/a0Rx48ecnF2Sq+b4aKI+x/eQVrY6o85OjkiTlKKquby/ALjgytDmnVY5jlCyGA2qGPKsmI07JOlGU1VcrAfvAtMY7AuY7ydUlc1eEteFBwfH9Prdtne2SbNEibzOccnx4zHY6SQvP/eB/QGfaq65trhIe+88y5HR0dcPzxkOp1ivWM8HrBYrEjShGK1ZG9vj+VyEbSIVhCnikWxJC9L8B4tJUpF3DrYoz+4CauC4bjHU9uHLGcLiqlCyy47owNmxYTV+QLfWFTqGAzGTCdnOAln8ylZNiK/WKJRVGWDJxTRyqreRNkIgluuU4rxHsxWx2x1u9y+fYvZ5Jzj+xdoKdne2mOVX3Djeode1uM7X77H3bdX/PyvP8V0dcSqLClKTbMYMRpF3L6t+da3ToKkRyiMqcHZoHX+hK8BEwmcFKi4w6DfoRQW2U3o6C5RFBPplLox6EgwHHZZLpckucJHhnk1xbuGrPVcKcuSbre7oUBHWuMaS9brUjY1fhH8MaRUNM4iTIhTlZFiuDVCSsVyuWRVFhjT4BHcun0THb0Z0l58y8p6ouHzZMH8owkmUbuPWsznKCnp9/sbd+/lcsmyKIk6XbAJSni0FPSyNMghqhIRZRuNs3MuMMbcH38Q1lT9QMU3IZNYKrQOJrQf1VBv3NDbRovW+srfPd6ZwCQiFJPjlrYd9i3BO8h5u9HXPxkJJpBJihfqCWD9ZIHiilSMK3uk9ee2Fmdt6G7LsN8MTELN2mDLyivA7YkmRgCSjTGs6iUYgW/ZZVorDg72uZXtMSnm1I0DH27f3tmi0wkZx2ncYWsY0kOWy0UbWZcH/4G8IEljYhOzv7/DU7dufiyu7U9yeNbu8LYF3a1pmntstibWdPRWfiXFY/ZtAN/rby0Abb/2Gl33sq/g44+2iz625xTr1JonO9ZXwff6mcUmaaTteLcsBbnusD/xYq1J6uZpfJCX+uC/jbXYxiIFmKbGidCYE86jhSdLIoRz4Tora6yx6OAIi2xd+LWSLdYJjBThLGrNqMXjpaQW0Ol10IMOsVT4eYWvK57tZry4gM+amLSuWaQRi60+R8OUt4tzykTjl44ECeMes7qCyoamZJZiTENZNWTdAalKqOoarQQHezvUVYVrPGfTCQ+OLihrR21cyCJPt4jTlKpyKBuafVWZY+qKQni6WcCMSmkirVk2KxrTBPNIoYLcsW1eesAKgfHg2yaGr82PqrX8S4+fPPCWAXAZ56mNxXhPUdZcXk65vJwxm+fUVR303ElwVr15Y5/xqEsa+xBc7z2ydfxbV2XSNAHERmscRXpTMUziBFc/dj9cT35rZ9DHHfhgHLLWLgsh2qxv24JZFwxXbNA7u0i37n5m4+S5pltprbl+/ZDL6SXTyznOhdRm03jipBNo9KYhL6tgWGBBS0WsgsMgShHFMbFWRFFYoFZlRelCp8OkGfO8pqqroFNXCic9jbOY2lPUFZW1lNYEWooMG3UdxSgsWgmSKMZ6j5AKYz2mbFBCoNsqrReSom6CBkb5ALalRmu1MXjxPlDko+hxVujVTMSrY734XKXSrBkGH81r/+j4qDHb1S73nybYvjouzo6oq4rlcs7WaMDl5YL/+r99Fy09aaxI44hhr4tzQdNC1OX8fEZRGfr9MdbCyckZ3gv2D/a5dnjIarUk1oprW30+9fyzDAcDEDAcbYFQNMbS7Q1QMqJpLHGaoSNN3IkCNag0CKnpp4fMLj7kv/zP/2P2d28Q64yHH94NjvQxvPH29zi6m/Po6Ps0xrC/s0ucZPzD3/z7YTJHsSMkOo54863vs1jknJye0pgGZwxKBgaKUBIRaZxoC2vW46xHCdWahYiN86cEnAsyEWPDhjfpdFjlOVJrTk/PuZxMGD11jabt0HoP1jhQEcZBbTzzk3OywZjB9jbOChCWqqyxjcU7y42b17HJdXbGOww6Xb74xZ/nbn7K9GGN1QnDNMKYc7Z6EVXT8OFlTplsIXyX/PwcbUMXIXSbAStIZUyv1+d/+qe/RT7P6cVDfv7nf47+oEfa+f9Q9x9PlmV5fif2OeKqp5/LcA+VkaqyskRXVzfQAsMGOA1gABqHpBnNuOJwxQ135Ir/CM2445qLIYfGGcPMEGKmgW6gC13d1aVThw7X/tTV9wguzn0eHlmFnsZMFgo4aZ7h7s+ffvee3+/3VQOUjECGzOHWtCHCZPtZ7zf+LZdc9vRe+ib7plCQImx4feIChKiTIM9xN5yzQBm3N0YzQU+Z4m3NtsCTwiOVpttSpjxhgGgNkY4RLpybjWv7WYBHyeDa+lWuxfKCotjj3mCXxWpNNhQYDG2nOHt8zuHenIO7Q65frXn5xRXTnYw0VZSmQ6gBh/Mj3DJClTVpnLDZ5GAsTdWiRxGzyRC6gs+fPOPg4IjNesN/8f/6fzObTXn3/XcoyppNnVM3NVeLcwZZihBwdHSHJ08ek+cFu7tzdnbn/OQnP+LoziH37t9lcX3NF48fgw9ZxOcXFywXS9I05fjoiMl0wounXzAZDnj62SfszufEo4w/+qf/mNhLImBxfU3nHft3DilOzzi9uMR5QToYcH61CFINGVDuqjaBHSMFfuzIYkWZ50SJIt+UWBvOgZPJiDjS1FVBsdlwcX6BR3BwdAfjPc+fvyDPc47v3OHyPGh+y7YmyTLefedtTl+dcHl+wc7unLppyWwSUPeyII4jlJJkgwypNZ0V6CiirCqyVJAlCbZt8c6ipUWJiDTN0CiWJ5rPfnbJZp3z8GGKihTaaLrWkm9KRNtyualY5SUHdw7QUYrth1LpIKXdNCBARwlFVVM17Q0d3joD3rB3GHPneIj1nuX6kovzc7yIiKKEYmORbsDjT8+Yzir2DmLadsR0PObegwnf/8sfU+eS5x9d05aCg+OIOjd0rehZHh7bBiNYZ77a/cUkmq5tEU4QJwnWGJI4Aq2obYMrN+H4c4pquQ6oXmZQqaZtWlxlkDK7abxVP+TcLhlr9ndm1FXNerMGJVF6K1kK8jhjHJuqIo4j8rqEnpJtrOWd9x4ymkQsupqmtCTxiDc6jy+tL+/BbdOivSBLU4wxlGWQ3N27d4+DgwOkjmh7Z/MtE66qKor1kpOTU5JI3RhgbWu124j6L1vby9u2pe1a2jY03Ldrktsa6ratA/LXAwDbuK/AGjAY49lqhm9Hhnnv+/pS3AxMt3XNzetB73It3rzf2w7vX+q7f+Hx2V4L7rFhHzeGtmvBq9B4e4uR7g125hurB0OqokJ0Ai3CQGEwGDKZTNCJY7gzQ8cJZVGR5yXedzx+9gmbTc7ufIap1nhnbvaevf05RbkGHIPhgMZUON+SF0uMgXt3H/yV79GvYnVdh2c73NjW+LbfH32PcruembfdV+kZdkGWFfrx7d/3zTu8RpNvvabhZRa/tBF7jXC/vtYv+gsEKrfYash6o0jRe7lsEe7bANZNnbu9jS1BXbye3QcXfHdjRjYaDWmD6o0s0cQKIiGxwjOIJJvCoOLo9fP14XEZ6xmNB4Fy3w+ycG3oeaRERoF9ZBQ0Xc1iUzBH8W7r+Y+c5N06RneGi4FmcWdMdbzLuTesa1CNxa5K2sxhdzOS8QR9HUDP2WzK9eUlWZpguhbbdMxmE4ZZzCBL2ZlOubxeYJ2jtQ6ZpBwe7tJ2DUVpSBNBUbU0rqXarJhMh0zFCNN15OsVSRQhCbFjg8GQTV7fvLHb86d3DmNtiGezwWPI9/3fXyce+X/K+pU33g6Bc1A1HXlZsy4qFusNq3VOXTaYtkMJifcOrSXz+YjxOCZNJEkS9Id40RsUiF4b2xeyApSSKLVFWoNDuLW2p+q+OfH03pNlGc50NwPDbfTD9mBxNiDbUaTxbRfoRN7RtR2Luma9zhkOh8zn85uMxLIsybKMJA3086ZrMa1jvcnJkoTxeEDXNaQq6LS89EgT6CzeOtIoDnFEzlEWOUmsiZWm02EyKXVM1XmMaUJE2taxVAf6e9c6qqaj84HWZL0jjRN2plOMBSEM+7s7IUrNhhNymkQ38RepjqiMpbMe40LRnsYJO/MZo8EEIWA8HjGdTgLV35ib6JHb65dltN82INluWFt91l/XfO2X3c/txvzX1Yh/9713Ob+4wB/uMxpPiNIBq82Gy6trzi7OqYyk6UZIrahcgWo9ZQcP3/kaTWOQQnO1rnjrrbc4vnvMcn3Ndb4ijWOK6xWf/uhzxpMhxrZko5Sma7C+IxtmN66r2z5pOp4wGY9QkeblyRnHR2+xXlmePvmM7/3L79N1MMxGeG9oupayaWhbgWvBS8Xl6TWb6zU//9FPgxukCQhqnMTMp0PSwYiL6w3L5TXemL5x3O5HjtZZhFagFVtDNSUjvLFg++OvPyZlFGG9IIozOhOKm80mp7ou2Dm4g4gjvAJbW4TzKKnwbYeOErxQZIOEyf4u2WjEarGgsyXSEjI2ceRlySCeUS46ZLUmSof86Z/9CDvOsHEEscTalvtvvcvCDflkCU6PSFxMedmSyhHYwKyRWBJiMhGxvrjm//F//7+xf3DI3/m9P+Dq9HOuz8KQyziY7MwZjqccHh9jHXS2d2x3AeUOxPHQXIdtONBspQxykHDe8n1RHbLbw7G2lXS0vT5J9bQpg5ThTXA2p3OGtu2CxEGAlBFxHDZw501v3iLQvebcOxgPItq2ASCJo5u4uq9qff74gvuPvs4/+kf/Nda2VH1cTpLsI3zLd7/5DZ68fMEoG/OHf/gOP/jLn/Kdb/82f/y9/476oqKbZuzGu6yuCobjEWVZUqwqZJyQporTV884PNzBGMtqU3Dy6gXvvfs2UksWqyVeSdJBwsHhHldXl6RRBFLRdR1JEhzpsyxjsViyM9+hLEp+8Bcf3fh3JEmGj2E2nXJ2dsJ8NiFfL3n+xaesViu0FEyymMX5CU8+/imm2KB0TN12NKajqmvc5RU6SZhMZqyLEmM91oZztLMtaZLQdJ66rZFR0Gru7+6gtWS9XgVWhBTkZUVZlSRRxHQ8ZmdnirWen/3sU86vN7z33jvcv/+A5XLB9WJx4249GU8oewr7aDjk/OwcJQV3jo5Ik4bFYklZlnQtnF9ccnDnkDhNUZHm6mrD2cmSvb0Zw2yA0IKzszNmkxFSSZouxfoBs2HGf/R7f5uL05dYZzh/ecWmatlUgk4ITNVCpMmmu+S1wTjPenHNpigCy8r5wNpyNVaAUiHeJiAVCfHA8M4Hc9Is4uxsgxQpB4d3Ma1neXWJ1JL5XkrrR309Lfn6t/dYrl6RZPuYWrNaV0RDAWiW145q7ZBRH6DnQCrCcdV9tUWXEZ62p8Na0w8ivaUzjqosELZmPpsipadsNmEwJzpUlDKME1qvbpotKSVt294gvkJKjLMUTU3VVKgkIe73h6YLzW6URDS2Y7FZkSYptQmDeyE1HY6Dox12dgcsFyuMhcjH0DMKlQ8Jx4Fh83q/vR0jalwYYMxnM5RSvHjxgpcvX9J1Hffu3eP+/Xts8vVNwZumKZeXl5y8SHle55QyyBxsrxu/3fQCNwP77ffe+xtfGdPvRdu6YhsFtjV3C1JEQ1HkgaLdSwONMWwjuKqqIsg7Q5b6NsbttUM5NI1H6QCwbL9eN+FvItm3GX+uH7BuwZ7bfjfbvwmPpc8ddx4rLKpH4q11/XMEI18/J3gNeAQZU/i3riqkDe5RW71z13a0tkWLFIdgvV5xeXXJnUOIYklVX3N+ucbVNdYY5rMZu3v7dF3L17/+Puv1msvrC85fXPHq9AQlEwQJ9+7+ra/0OPnrrIBSvm68Q4PUO3X7UKtvCxO3BeyQ0Cf3iH4ojd9GaoYv4QMbF/r+bKsq6CHvMOwOj+F2cww9SOR/sene/u3tIVZonLexYwIvvzTiEtumfMsOvqUdv3XTHmi9wCKxzjMaDiiqBolnNopJhKcqK6xyDBUkIkgYa9PdsAiD1CHoo23viB9LiTWAkDRCUluLMIaoMAwiybR1vDWE340mvLUR5K7l84HnYidicmdKMwygXpYkmMoEU1IlSFyKqDsiqWnKijSKuH/3iGfPn9M5z6asyLIhw2FCUxTB8wpHksa4RDKeH/Do7a+zXq/p2gphK1argvlQY61hNMwYDoc0dUO+3lBXFReLBQf7BzfvQxxFNFaiej8Ht/WdkJ6490xou8BCiaP/wOPErBe0nWW5KblerrlcrLlerTE2nJA0YfqUJRFHx/vcu3eHyThDK3DWofsJ6VZb6gxoFeOEpTMtXdfeoKhRFBphqQKiutVibwuQrVto6wxxH2+xPUluT2JKBVdpKQVxrNE6oqwrEGHS2Bl/ox231lLXNU3ThBMgwfXRO8lmU6Kk6jfK4FaZKkmapbiqCwi9MZi2JY4jnHV0bUskBbariaIYCHSQomqo26o3MgnTqrbtgHAQGQtKxxgALeiahq5s8D5HScnewSQgKb37chxFDDJBUTc4b2ibmtZ4autRkSZOIqazKft7e6TJECmDkV3T1KRZ2secvH49t2uL/m83l9vI9u3f3Z4Yf5me89dZ4QT11SJz/2PW/fmE/WFKVddUbYdpa6aRYnJ0h0fHRzx/9YqirHjrwVsM4ghlDVpKBqMJJyenKBXzW+89JB0OuL6+RMeGB998iyiSJCpCoWhNS9N2lFVFXkqms7sMR2NWq5y6brlerBgORjS1YCNhd39K3VxwtShYLRu8UgzmU7ROe/qNQImIsmjIyyVCeTpr2Jnvsjvd4bNPP6UocsbjMUKGourzL77g8OguxkkiHSGSFNuUvd6s3+j65pGt+ZcIOZbe2XCisy78LBSdDe6cksBCGciYew8eUIxzRJRQeoMzLsTSdJ66aYiyAY/efoe68Kw2BZ1xSCXYP9whosHnHYXSNEISy4jZaA/RKb748af81+N/wVp0pNOEylqEl8TZmM8vDV9cLjmtp2ReITYVdmXIdIbABQ00ghhJLCRtmYPwPHhwyLe++Q7l6hQhHFGUUbWGrlmxuExYXp8xnc6IohilY5wL5kA67t3/8aRpipYKIQxKhqgO6YMpUV3nFHnNaDQJ0Wze0rYtUkCSaF6dPOfk7CWr9TVKCeq6Il8vcdZwenbOZDIjShIm0xm/9dt/kzTLkEpRVhWdsZy9fE6+uKJrGtJBQhTHjEYjiiKnLHP+4P3/y1d2jNx755DPn3xO1S2oKw8dDMeB0vbWg7skXvP24SFGxjx/8RG7d+HZq5/x8osNrBV3hOKkLalMx36SUNcte3f36Izh7p0Djo+OGY3nPH72c4qi5G/9/u+Qr1fkRYUFDu8ek6YZ1hpmkwnDNOHnn3zWN6Ypbdvy3nvvMxlPuLq84tNPP8YZQ2faQPlNM4SU5GXB22+/TaQUn370c5qiRDqH9YbluuX89ARhHKPBgOVmTd117O7uc2804uxyyWqzYblcUneWwXDEaDhkmGUU+YZYabLhEBA0VUkaKwaDbXQmtJ0jy4YIKemahuury74ZCA7Wh0cHnJ6fh0L5w/dRSlLEOaZpWSwWyEizWa1pqvD3Sko2+YZxMWG+s8s777zN2dk5m/WGoig5OTnl4cP7WNdRbK6I4pamWXF55dmZ7/He175GUV7T2JpxPMFZT1FtePZqSVvXXFxcsdzkdE6w2pQMxxmdhzqvkI1DSBhkKTqqUVJQ1Q1ehgG975GcKNKh4bAe5xvi2CNUR1kqylwz39FEacTjp89wrWOzPkdKx3gWMZnNePbFGU3tKGvHRz9/wv5Bxt6BZ+8bO7x6XPDs4wIZSfYOBizXOaaWOGNoRWDsfJXLth1xL7faor2+N1lNo5hISXYGU5arFe2mJo4jpAdbdoymUya7Cd6GOmU8HgfUb7tvek/dtaSTEY/u3+2HmBtWRU5VV4zGIwyeKEsBaL0lGqSYzrCpC5I4YTxLeO9rd/nii2cMRhli2zgai44C4LFl+W33761ETylFEidEvems9yFabLlc8s/+2T9jsVjwnd/4FtPJAKXUTQzaRx99RBzHTEcZddPSyNcxW1/OuAZuzNxeI9jtTbMt+kL6tlP51pcGArJHj3I750iS5Ia5F8cxbdMioyCh2Eakfrk2NMYEk6q+Ub79OhhraYuyN6gMRf4byLv3wRDrVv2zvW7IWG+Dn8v28bqtJjkwnYzpsHiMcDe3/fq598CFeE1fF14SxwnRdErbdmzyDTrxjEdDTl6dsFotMbZlk18FT4v9AXfv3GV5ccmL5y9oTUUcB1aabRuktEynQx6ouywWOfcfHGPNryfHOzSLrxvv0ILectz3N2TxYJbYd6zeeay3gaq9pZ/31w3cVPkGt0Ns/wt8dSy/WHLeNNp9V/5lBudrFDvcIogt6e2GMo58k1OyRbpv3OsJ5rWBsXbTggMy+O8MImTR0dYt3gYz5MhH7IxH5F1LpyVuNsEKyXVd4SNJ5x1RHCNtOOc5Z5GEmGKtFGmSUrQtTc8kjlrHXgu/oVLeGcUc2Y6kaXllPT/Vhh/5ljgbcQdDUmzojGEax1QqpsVT5iWjxuIbS23A246r8zPee+8R3/jwfS6uryibhrrrUMIzHqXEOmY0GTNGcZlXTPf2UFHMcDwlS/aZjxOK61Niag53JxRlTlmUOGsYj4bgPOflGXle4JFUdU2SpGihKeqWpm1BgFQSazydsIgoREp7gvnxr3L9yhvvtjIsNwXnF0vOrhZsioq2j9eRMkzylfccHOxx9/iQ2XSIwNE2Bq0ivOyQwpGmUZ9lFyaYrgtRZMnNBDCcpLIkDRb0whBFCuckcaIpizZQUvAkaYrWEdaYPpLF03Yd+ID6NF0TToTIYLhhHUoqbGdDBFff8N529mzbcDvDwZDd+ZzpaEpTNywXSy7OL9FKwjjpCwhBXRa0bcMwTelsQzbMoPR0bY1WCi81ZW2oW09Rd6FYTxKiJA409n4i5hFEKmi9tDN0FtAhKmxTFaSlwvohnQ2mAlIKOtNRlRVKCnSaUnWWzoJDIbxGqoQkGpAmGXGq+7gw30/+LGmWYExHVVfEUXyzAUf9lGjbWH9ZA77998sb0JejSm6vL5/Ebv7u9ve/JtT7N771HuvNhrpueXlySpoFzV7VtGTjAffuzulwjGZT6DoGUgZGQ5Kwt/MAITSj4Zj1as3B9A5pchdjKqxrGWUDJtNd1mXNYlPSOUfnDG89uMvZ6QllkRGJjEE2QQpN0eQsiyXPXrzkO7/xAeN0QBoN+PnBHv/NP/nXRNEI6z359YYsG9GYhs607EynIDxKWqouJx5ovEwZzsa0dYsUimwyI86G0Dq0jOicxFhJEoXPhgRiKem8CLEYN5qzDrXdwJzHCwkimFggBc4YpLM432HjBL03pjEWbX3wL2gaIh2xXl2ikzG/9Z2/yfnl9Q1D5u133+Xu/buMsgH//B//M/7bF88xG8PF4zOalaM2AUlpFjnXixN2Du8jpiGn8/Kq4vvmEq00jUmJRES3aYiNI1VgrQcfZC0Ch4odZbuhLnOmoyFVtcI2a6SQzJOULItRWmBdzdmLz5B2nyhWAc0WKU1r0XFgsDjvaPtcXGdDI7Y17rFCBVQ3z/FuSKRUoEJ2liiKOVnn/OAHf8n55TlCe6zrWKyuSSLFIMuwpiPfNLRXhsszzfXFc8bjcdjoCcXoRz/7CcJZNpt1kB5Iwd7+HsZ0pGn6lR4jRbnm+dOc/bsRxkratsN0Fe8+HJJo6FxG3TZcrc9QicQ2LaIq2UlSpocHaGY8f/WM/b0ZaZoxHIT89g8//BqCMBg9Pb+gqCsePHqLz548xnY1X/va+3RO8PHPP2KYphTrJTu7u0TZEGMNjx69jVQRpycnaCl4/NnHvHrxjP2dXb54/ITPHz/hvQ++jvOCfFMwne2yXi15/vQF4/GUy7Nz8uUCYRo2vY/I8eEdrq6uGU0nHM7ndMbxxZMntJ1Fqojjo0OKssZ5QmEcBRlCmsZESYKzFlNuOD44Yj6fIWVA9GazMWmcMplNWSyviXSQB5muC7IG63h47xCtFRcnzxmOxsSxRinJTrTLs+cv0DrCIXh5cspoMGQyGrBertE6Zmd3Fx1HXF1d8eL5S1aLFadRxMO3HrC3t4e/vKSqW5p1weViw/vvPUIpTVMXGNeRqojPPv+CQapZrwouLpbEWYJOEjonEDqlaSquFksGoxHznRllVTMYDGlbaLolSOhaS2s70EGHJ1zY31CO8a7kcrFif1jz9rvvkJfX7AwsDx8c8PTxK4Q2SB2zqR35xRl53ZJfV8x35xwcJUzGEcul4YtPziiXAt8qsB3GWiTB0KfxChF7iL/avSRDBQmH8YAlQzGQGi00VsDucJej8SFDO2DjR8znc/I8D7nc+ZrJ3hwZqTeiqG7rjKVW1G3L2cUFbRdMuox3RGlC1Evy3qBue4/QikgH3wkdSb77W9/gT//VX1KsocprbqgvW5e7LwEU26H6TTPsYblcMp/Pmc1m5HmOMYZnz55h2prd2YA4jimKgul0ynQ6ZTabUm5WbNZLEGD7hviX1QC3Ee0t8HFDyXUeY7reD+N1jOlr6rpnkA1ugJnta7dFxSfTKc6CEOpG1/1l9HKLXG+R/jekb0DRdHgRIldvSxdvhgimuRkMfNmc7vZzDO7koZ511oacZ++QsUYreTM8SNP0Brn33tNaS2eDDCFRMVppdJyxv7/HdDKiaNZ0XZ/9vjMDuuDH4kqygURrw97ejEjL3n1/Ec5RscT5CBnBZOeYe/cV3rZo/evReNs++lf4PgaM1yZrotdQb+NZb3zIHSAFnTV9M97Tzdn+jeo13/4G4Ra3vjwQfKqCc3qgpm8b5K2MPNQ5ARa/xWwQDiduqIGB8eZf/x19+x8+av7Wf9wYv0lvw/2KrSQ0xokIqROyKKU2LetiA2icCKzK2oCIE3xrmeuI4XjM47Lm0hic8ESVRHpJh0RECSISOGMpm5Y2BkvHzHuObcfbieD9LOGe1Iiqo4gEn4uOJ7HlWSxZZilDJ8kbhxGOqirY2dnh3nxG3rR88ukXWOdBht5KSc0yb1huSh69dZfxJGGTr1mvK5aLDXlRYDPB8f17OJ3QnZ0zncwYjKbExjCbjMgij6nXdHnFMEtJbIvtWpqyom0NkY5QcUretFghqYxlpAXTUYb3JqTfqBjpBY1vwFsUMZGOsJgb1/lf1fqVN94vl1ecXVxzeb2hKFt65jYSh3UhlmEyGXOwv8dsPKEqSurSMhikbBP6UOGgUL3DMB5aH07Cw+EQ59wbE0qUYJCNuLq6ojMtaRpjTEvTWOI46XPDwwl4u0IhFFEWedCcExB0JQVRpDDG0jZdOBkKQVVVwGuTsLYNBdDyatEj7QnOhpNpHKdBG+5AeYi0Is1ihsOUrm0CfTSSDIYDWhVs/tvWUdYdRdXikKQaFJYsToM7tJJ01uORRDLkRHcG8AInFUYGt76qa+mMQ8UaHcXUdX2zsaVpSl5VgRbrIa8bnG9CxiGSwWDIaBo2LKnCicfaMG0fDDJMG+IvthvVbcO1bZGw3ZzhF5vnbfMNrw1bbiPhX1630fPb638Mav5VrJ89/TlN22GNRSURjSsZjwcc3Nulc4ZGlSyqnJ8+/kuODg5YdYY0SYkGCTjIBgllvSGewvHREd4Z6nLDIEvZbNYYXbNslwz2Z5wvr0HBs9VTSrsiHoaM1OlOjLMwjifMXMxb3zhC2oTIO1KdcH59SjoI1LNivQnRLl1ACcajKYoI5wy1aajaFiuhFZ68NVjj0cpTdB1pXRGLCC1kGPr0xn7COoQLsSxYhw9OangRNiclJBgQXvXvqQAZ3Ee96UikRCpBIzxV7wAeNYrOtqAVTdmgBhmig+/96ffYPdzlH/y9v88kGzLKhuR1jWsNh4eHZFnG0gl0q9gbTfnRZz/nvW99SOzh9CefIu8nHBzep7UlVQ2rYUwsFVpGeB9h64bIepR2vYxFh0JIQe1L8mrN7/7u7/Cf/L2/xyBReDfFOVgtwrAkz0Ms0WQ6IV+dE8UG0xVImSCI2JQbmqYmTmOkB2MtcRyRDYdIFeJ6qqoOcX2xpig7nLE0VQ1eItC8fHHO088fE6UpTd5QdRU6Ctqk5aIM5zEl2ZmOubq6Zn1tWVycsVhes7Ozg5BQbpbEUUSaxCgRqHcvnz/FdB3znflXeozsTPfYzBWr1YJkIHGNYD6fMhnE7Mz2+fiLxzx8+4jz688oihbfpmhvUV6RxgkX52eYtkF7Qb7ZkCYp3/zmNxmORzx++oy8abj/9jvcv3eXvMipqpx337qPdx1d6yg3G/bGQ37ws5/yre98h2GUkA0yoljz+edPOD09ZXF1QRpJ8tWCx59+TFG2pINBMAAtKuIk4/LykmePH6OloCsd5SanyDcMYk0Ux0RKU5QV4+mUnb192s5SVSWPHr2DUqGRPLu4pG1bBoOAbtd1xXQypMwLnHdEWrMzn+G84+T0lKIoycuK+axmOh6z3GxYLJchmUAEFpLzntF4RKSjG9nB8nrFZD6l6RoWiwV3ju7gvOD6esHu/j7FJsea0Mis10s8BhlpDg4P6NqOZ09fcH21oKkbpvMZWqfUdYVxOYM0vCeH+7vEOqZYb1hfXZMmCUIqLq+XyCjmw299myfPntN5SWcNL0/OMc4y3pmhI83iOidSEUpr4iShtQatI7xyoCTOBNdnIR1oyf69EUf3FYfHE9I4pW4Ur05esr93zPH9CYtFxyZvQVm+/sEdih343r94xvmLEudbur0Bd4/uo0zJJ69e0dQtUSqpugZnBLYzvZmQQMdfLdoxRN3UAs45Bj2TpytLinVOW68Z1ClKKmZixuLxNXlRhNohjbk+v0JmmvF4zGAwuKFZW2tD/Gmi6ZyhqwzOOoajEcPx6GYfbprmDdNES2C9KR2Ges61vP3uPX7zN7/OH//RT5BKEkqjbXsS9v7t478NOjgXYtJUHMzfjDEcHR2xs7NzkyZTVQVNAlWZI4Xg6HCfR48ecXJyQr5eYtoGr/RNPfbL9vItot00DU3T3OSBq55l1bYdQtg3UmpeDwocRVkH2V4/uNhGrimlyLKMOMoC2uX9DaJ9e4XG+DV9fFvfSClRUjKbDZE6vqGqb68T/t5St3XwDfqy9vvW83MepAbZywq26C5SEqsEYslyuQympP393yD9tBhfkUQDkjhFyj4H3hjiOEHoIVXXP3Yp0XFC5D1Nm9O2JXm+IGWAEpIojnoPHxBSImSEtlA2JUJEVGVNWSz4xgdf0QHyb7FeO8m/2XyHztX3TfNWb71lDwDWBx8aT4j3pGcmbBHlPt97K6d4IwJXhP7jBov2Pcq+bc7Eragx0QeJ9vpw30cT+xuteH+720hQHxzNt4/39T31gFM/ZPAEICA09TFCJwgn++GSI0QgB4PXqnNcVzUSR2NaosaQEfHuzg5qseC8a8ldTedBRQpDA41BdB5tHHc6z8M04VCn3BeSXWqk7yiVYzFNeCU6TlrIhyO6SJMIibKKalGy8R2Ojr1DycHuhLnxmLrh+atLlI6QnaGpG6JO03Su9/IQjEcDbOO4bC7x3tMYy3KzYTSNeXjvPiqbk0wmGGtIkgjpg0Fai+B6saKsVgjvSZKUy+UFUZyQZQMaa9nUDZ0PPgzaOyIZ3j+JYJimGBV8tLQEhUIL8PwH7mr+6ekLFssNZWWwViKdQDqPtuHDFGmJMS15XrDJC2xX0tmGu8fHxCNJUVZkqSaOIrrGUhY5TW3QMUT9Bpmm6Q3FaeuuXRZFmP4lyc0BlGXBoCTPXzfN28xk7z1FUYTM7iQh0nG/EYRcXGMMaZaSqRA7YYy5aWK3mh/626jrYHKUZUOECNFHxnRUVYH3jmg0Ik1TsjTFmu514q83pGnCaDikqBpU3YHbZuo5pAi533s7+7TGslytwEOsFHhPWXtMG84HEoGwFmPB9tR0g6czNkxDtQ70WGPwaKx1lFWgX6w2OeeXV8x3Joymw4CwO0M4sQmcCxu+1hFd273RaN/Qr/rNK+Tl/SIt6cuN9W162S/Xybym4dzwdX7N62m14Pz8gr2DQwaxpCo31JVENSs+++Iz4mHGp88e8/DtR7hJxOXVgkkU8dmrJ3gniZVECMdsMuT6dI01hq41xCrCC4fFcZVvOH/5M1QaMxgOgiFM0xApzWzq+NGnz5iMxsRS46UNOmijGA9SfGNYyRw1EWzyDaXN0TpDGsc0m4CxSC+J4gRFSmM6WtvRWsW6aknjAVk2oFsvQbkQeSIM+A5BcH70rkYog7cVQjqEchD1LsF4RK+1Ej4U0lpK2qpDGNMbegV9dEGLsYKhjIiVxklH2zXISJKOMuaDOR987R0+/NY3kUqECbY3tF1D23aMJ0Pme3OeP/6MTZXT2BbfdSQ64nqxQMgI2QmkDU7iR0fHCG/xGIRW+MpTrSskEQKJVhJNb4KoNF3XIIXk29/6DZq6xtZQbFYoqUjTjMXygrOzM7rO8nYUE0cZB/Mdug6MrTg5f8751RIQ6FojBURaU1vNuoam7UiihLyqwnRdaAaDIXcODhiONAf7h9y//4h//kf/ks8ef8SmKOicQceaONGsFhucDcdRnluqsgpZzLZjNp0h5S5C0CP4Ah0nNE2N9J7RaMxkNuHFi2dUbfmVHiNNscG5jt39HS7Orogk1KuGO9+5ww/+8kc8fXXKycULQBGnCdks5fokZzQeUm0KcIbd+YgkhCkwGg/pupaPP/qIxhjWZ6ekg4woTVksFnzjww9YXV1g6pLj+w/45gdf44//xR+RJMlNxKNzlu9//3u8eHHKh1//Bnu7cz75+U/5V3/2Z0wnU6bzPQazHaJswGJzzmQ85l//yR8zGQ2J45hnT5/g2pZhNiCOFEpHOGNxDsazOTs7eywWC4xJaZuG6+sr6rphMByxvzMnywaYzvBqs6IzBtM2TOdz0jRFSkmSplDXvDhfkCQZl6sNZ5fXOBeYWUcHO2AMgyxBSMlqXVBWFVpHNE3DfDojqppAMzaGoqo4PDxiNpvz5MmT0NBqRSJSyrJCRxG7wxHD4ZDp17+GtYaz80uKsqDrWlQUMcg04/GspyQ2LC4vGA4zxtMJ2WiIVArnDSrS7OwccnZ2wauTM5Iso6xbHAKhJHlZsVxtsF0w9myajtZaBqMhMnL41tI1LcKHlI1sqvnu37nHqj2l7Qyma9k0lyxXV316yFNsO2CzqXn33eNg/lgJjvaG/MO//13++X/3EePJHpPpgKOjI376wx+wWRnSkcZFhnikqRpP7DVCe+rGwVdMox2qmM4FzTXGkMYZrnPkq5zVxRWqjnhmI9IkJUkTNpsN19fXrNdrrLcMj4cMpkOm6ZBxkuHrDjB4C9ZYSCKEkD2iGeGtpek1zF3Xva5P+iVFz5DTEd446q5EZ4pv/fa3+ed/8lNEpMBsGwSNd6I3fAxfX0aFYx0xHU6xzrBZLIikYzIbMRwIRkMFxtBUFzRNx3Qyp2tKPvr5R3TGUdcOYyXWBBMl44IMySFDBCc9m603td1GiNV1fVNfIGRgUUqJ9ArVD1A652hteB2qugjJNqI3+rWOpu3wvqWzjsFAIsTrgcu2bnRCBBmEDyafIRnComQ/lBVBG4r32K6ha2q8D3T22xGRzrtAF/c+fEb7WDDr/U0+t3UOqYJm2TnTN8kWJ1u08UihcaYKJp6dwqkbK24632JoSaIBUkl0rFFxyvV6xfkqwvqKaJDSuRZPMOTtTIl1Hc53eNti8EghiU1MEseBAm9CjWidRWURSnqGsyGVWX6lx8hfd92g2z74pmybXrnVYd9qWulf13CdnmLeN8BK9ORy8Xq8dHu9wdQUW4R6exlbGJytceov8zfaouVe9DT2PtHidfkqbt6/v8o0eAuQ+/7OA1tYYdswUKqqrh8whPhf5yxlZaldYA8Jb1kXBSOd8s7BPvOu4ZSW5TIn1Y6plqjWMdKKaaL5wEkOnaYyHh2DmUy49i1X6YByNGDFhlXusYOEurW4zkJjiLTFx5oOwWpT0XaGNMmYjccss5zaQpJK6qqhaT3r9Zrnzy2SjsEgwRoXZHFxzGA44+69e2TjKR7J+aphtbhmNB5hrSHScPfuXV7UGy5W11wtcwQwSlKSwRAtJfPphOVmxfWqxhOO6Zto6T5GNYkikl7aGIZhwSXemb/a3PF/6vqVN95iVTFwEuMlm7YFqcPm7R0aUNbRNh2XF5eYqqRtS3SkUCqhrlryzYY40tw5PKCtW54+eYo1lqPjOfsHc5wLGaBbdBUgz3O8cwwGgxsDtCzL+ulrBT7E9QSKuCOOt5QdRzZISaPkxtgixEcEZNd0geJuvbuZmtZ10M1NJhM8EMUxremQQpGkKVW9pGoaBPSusYoojhgPh9ieJiT6ODMtBUKEtyRLEkYDT151GNvn7boQWJRmA1Ig36wQzkJvi48USB0RDkCJ8AbnA0KfDjKKzZqqqjBeIKTCC4tWEcaGeZ+KFNZD5x3X6zWnZ+eA5d69uwyHA8AHrb0ImeNSStLeyRS4abC/3IDfRr/hddN9+0TzV1HF37js10Ap/zctNx2iMSxFx9l6TSQVzkZsrtbIacZHjz/nm7/xLZCKTd2gsiGVM4x2Q9aq7UyIfRskLOoa0zZEUiFjTRKnLC7PEcIxnWR4JZlMxpjO08YtznnqtiUbp3jlehdHjYoSKtNxvb4miROMtNRdiRAZSgmKpmCcTokHmq42GN/g0ZR1AVLgfXAQ7mrLdDgmjRWxDoRx42zY4SIZPEmUw2nwGoywYbMXkslszOpsg7AOepqU6yfFkZAUZRNYGkqB2KIQwU1fE/IprdCBDu8tRjcE8wABAABJREFUtXL8n/6v/2ce7t3l2YtXIAW1bZgMpqzznK5rGA0HzPfmJPMx77zzDr/53e/y+eefsL+7S1u2eOOYJCNUJ5BRQO014PvGPxMRXWWIZRwyL4VEOoXxYTJqmoYmL9FC0hQVO3v7CBuowK9enfL4yROqqma13hDphKuRIkqOEXKBUBv27kQk0zldF3whhoNBb561QemI0U5GFMdkdaCiRVHKZp2zLF6SpQkfff6Ui8VTWrdivq/Iy4aybUlSwbPnH/HOo/fpOsv52elNFu3Ozh5CtlwuV8F4pKmZTifsHCQU1RoZd5RNRXFxglaCu28dMp/PvtJj5D/+B9/h//tf/Tk6Fjy4f4dyXfHND97hvXff40//9Y+oG8NiIUgTRVm3rHwNrWUUD1FxhhWepimIoilKKabTKcYZjO2oq4qd6QRTlVydvmK+s8Pq+hKwKOlxXcu//P6f46xjtrvLF0+eYp484/7xIW1ZcGd/l0hJXr16yedPnuCVZu/oLlInjKdzLq+vGY9G/PTHP2R9fUEqHcVljalqcJaDO3d49vIZSRKm65PRmDhJeP78OUVRMJ6MQ8RJkYOQREpQVzWxVqyXK4ZpjFIZ6cE+XgYF33K9pnWOsmnxKqK2nrrpME1oNLLBIBjAdA3rzYrZbIfVpgh/j6QqK/JNzng9ZDYb44E4zWiahq7tuH//Ps+ePaPpAlU3STIef/GCJAqGiuPJhP3DfYwzbFYbrHFESiHjmPlkgrUdm43pB+ENJy9f8fDhWwCs8w2j0ZST0zOSQY+AXy6IU0maxbTWYKylrGqkF2TjEWXV0XaWpJeBWRsSFSCcM1pr8dkFj95LSZSkLWG1WmM6GE/vUDYFZek5urdHU1dcvCx5Xp8Ta8FseoiOYLqT8v6H7/BH//1f8Op8STTUpFFGXqxCnOHE06wNHgd1aPy+yhWrCIVAITBK43rEcpRlMJ+TqQHOOOYHkzD82B0x2xu/9qtJoKxzBlITdR7VWlIniHXCUEUsuxbnDdV6DVmGSJMeBQtYtfAOb7ueRiuIEkXkBdI4pHHUrqORgjtv32V+tMPp0xxUjBYajMC6FiNfI7U3hl79vq7R1OsG51qygcC3GzaLS6RqETLIiXxjQGiU7Pj0MxjPjrA+YVVCaxOEhcR6auMR1tP6oPl3LgAfrmlom+aGar6t+YwxwQjKGYSXKAHSeawTaNPiGm4SNIrGBJaIDWk1Qie9rE+SN4HpJ7e1ilMIKW8QVOsF3r9m6DWNpW1vFefCBYCkX03Re91AACvCpBUElGXIHgdobQBErPcY4xHCIEWL90HuuI0Ea8wSJVUwExaKrulwRt34CLm+qW91SxtbFBIvPWtTY1LNYpUzyQzEgR3oAKkyvI3x1iAVDOIBSRKicqu6QaoodH0u1IedhTSNqIUhGv9qzaf+TUvc6LrpcSAXJKj9c9oCM7cb2dcGviFdJfTrWw31Frj+5QzLmwb8hli+Rdb9Dc98G5P65nX75loEEGzbNAed3S1qud/S13/x/nsG+w0rPTyePpa01ycb22KMDcMfB1ortJBkUUzkYy6bAuMcsRbYpiI/r7BG8CDO+DCekQnB0HuGiWXgPdoajLJ83OYslaKLIx4+2KcyLedFi0gELRrfReg0hbaXxcmIYZwGyYWC84sFiZbcPb5DW1dMhgN8WZOmCjPKkD4c13XVsri6YD4fM5/NGAwGxM4xnIwwpg0eA1pTF2uMciSxQosEC+hhho4iHNB2hPNDY0m1IkmTIO/sI5tb4ZnNZlRFjq/LMBTrQnoVNtR4znmMbUnjQDn/Va5feeP9lhyxMi3eFFQ20Fit9AgFsVRE/dSoLCqavKRpK+IkoW6fooSna1uyNOXVqyvKomC9WjIaZWRDxXgSnOy2B9nWDt97z2g0ousCGpskyc2JbhuL1V5dIZVAa4mxHdYZkkT3pkeazTqnqoKBVMha7cIJlDAp2VKqt7rmoijCCxpFJElC03QsFovgFtuF/Lyob/a1CsOArm3o2pZhlqGEIEviQGcyttcHCbSkdz5WoBR51fLRZ1+QJTHCtZg+61hGCWVjOV+GTVNFGtHT2pWOkEozHI1Chp2OMVWLEBrvTW/gYTEeLALXdZAbTi4uSOIw2b5pvp0HSR+J9tpM7bax2va92E58t5v1Vvf01224/31fy7zgar1iPJlwtrhmOh3jCkFnKiKlefudt8myFO8Fp+cXVHXNw4f38KJjsVgyGU7AJhR5jW0N68WKJJHM7h+DdQzTEVY6ZFNR1BWRlaQqphKCZ6+eMxwNmO9NAwV3ELE4v2I2noXollQSjzPy6pz1YslIRajaMZVJ764vMK2hbWuSaAS177PoA4UQJ0hjje8n740JU34ijVeKrRBqS7fzDoSWxOMh4+kE9+Ip2nuUF1hsn2stA6WzNcHsR0iMCZcpFwouYyqWTUPjO+I0oTYNjWtZ2oKjpiSNNFerDU4K4jhByaALlgMVkM9hRjYd8/NPPmY0m7FcLCiLhiTJkIVhKBLQYQOPELSYEEnWgm8NsR6gvUbKMJmOtWaYZVyevmJ3Z87+fI5vW5zp6Nqax0+es1isub5cU1YlO7tzTk9PSTLH1z68w3AaU3WGlgIfCyyGySRFCYtSMIp0z5rxWGoiHY51ZwsO7w/wWLytSMeaonzFYCfi/W8dYD2oSJMOMtr2a2gd0zYGa9+m69qepeLJsgFCQFGUwZSoqRlP9jAuUBGd7zPZvUFrxXg8+kqPkR/87C+wrub8WcXd43vs7w3Jy5rFuiCKMyaTKRfXOctViXeOcRrxzvF9UjNis2jZ3TnEtIGuH8cx3ntOTl9R1zWT8RjhPY8/+RghBBcnJ7zzwXscHOzxwx/8gJPTC9JsyHAy5cnzF9y9/wAVRVR5TrFa4onQUvP4yWNMazg+ukeWDSnrjqZpyTc5py+e8/zzT2nrgsvTmp3JHNu1jMcTLi6vgowISLOM68WC1WpFrCOyNCVJImbTEfPpjM8++4ymqphORnjnGA3Sm3Nj19YkaYrQmrIomcQpV9eLUMS4QKcEQRTH5EVOrMfgPVESUKlNUVO2hs46Yi0ZDFOOjg6p64q6afEIpJDkm4L1ak0cx0FbniQ4Y9ndnbFcXREnB5Rlznvvv4OOJCcvz6nKCgHMZtMg81IqDDLmO0g8o9GAqqo4f3nB/Qf3ePHyCVeLNfvRPmXZ0BpDLNIbmmYURezuDDk9OWOxWGG9ZzqbYLHEcUpdBfM15w1COu6+PWG4I0B7qqoiHSkGaUbbRZyfF1hpuL6quDqrGKcC6SxpGtFiuNxcc/TugPnOkH/2J3/Ci1cV4wNNvXJ0tsEUkrWpuX9vTpev2D884qS7osi7r/QYePIsxDhOJhPG0yHXV1cM4pj57i6z+Q7nLy+Jkoh0kHF2ec7B/gHTaEbaNhhrEAmISFCUZTC86vXBSiu0iohNcE0fjUZh+O0Ds+Vmef8G1T3kRYcBeVVX1G0VBvJtwmQy4IW9QoowFN3SW2+vN3xZPDSmxbYdWntSkSC1QiqN9S22M2jvA4vLK5wL7J71yQnGxVStxSGI0XgfsqhV272hh3bW4M1rpLuqqptUD6UUXsgbk89t/veW8r3Vhd/O3d6m29wABLf8aKT7xcguwbZOea0M3rqib5fWBCZWv0RfA23N1awAoV/XQzfmcW4bIxbWbZO48JhivJc9KzJkVZv+PbT93iulxAmBu2FwhttsTUNeFEilmM6mOB/QeNenjKRpStQ/NxFExFigMYaqrVEqGAImwwGZUlS2uwGctnKHf+fL2z4eTCCFR7jgXB5iO7fI8euIztfocp+XLQjDGUD0dGPRN8dv0MtvbmvbvL/2PN82xPQ/iy85pPkt7b2//OaB3Cp1X38G5BuN9xuO6TdX8T04Hp6A6z9bidaMBgOarkG0YTACwaB1pFOGQrFuGhpa4tkYX7WUVU3lO66KjvEwYxRHCNMwSjRZLIPn1e6YZ0uHaTyx6Ri6Bhd1XMcbBllEWkpm0YCytkQdSAd5W2HxOKEYDjO01pydXYB3fRSmIstSrA0NrnBbA0Qd/EIaw2q9ZjyesDufoaIkmA16Qxol7M+nrBrBZnHN0nYc7O2wcDVX19fkecFgMGK9LjDGkpswjKjzDapnGGwHVMPBALlZ4a1HiEDV96Y3APbcyHiH8VfrdfPl9StvvHfjAU1tEF3I44Ybr4Pw5QMd1ZqQqWasQFjB5dUGKSwSQZ43LBY5WsOjR3d5+PAuu7Mh03F4g7fN9hZx3eZrV1XFYDC4yZZM0xSt9U38F/gbRLzrWpIsIU1jinVJVVWhEYlDc7CdNLXGYvoT+XZt7z8bDEijiOFwSNt2lGVFZw2bYkkqEpQOhePl1RXDLGU4yJC9lkdKgXOGJI5xStN0IZRPShG0WF7SNJar1YaiMswmCXdmI6T34URsLKeXK5alYTKLg/bWGrJBejM4EHjiNA0O5k3ba30V1ljqpqM1QKQCdQvHYr0mVYq26Wjqht29HSaT8U32YNTHg2zfg9uOol9Gv7faqe3v4M0T222zEvjlOq/+gl/yq18P7XxzucJUHSL13D08oq4rlldXzEZj9mZzijxnfblgNB5z8fKUJB0wiBPOLs5YXJwwzTIkMcvrJaaxREoxiGKKzQbjJFaoftqZkKURy+sNsYrYbHJmwwk6iZE+YjCcYJRiPJ+zN91ls16zbgvOLq6oO4vSMZN0Qn1eI2xHGsN6cU1V12RZihKKSEdk2YCibkGEz+H2VbVS0nrPMNbBobsz4MJxKi29SZAHLZkcHlKb4MKuhQyDYefxvRauWW+IhCKSEZ0LZm04QdK0YByR0kRZhmgFdJZkkOImE54uXrFrFLYUYGE4HJIkKdBxXlR8/tEnlEWJF5BkGdrDt7/5bQ6P7/D85ILB5Sk//ZPvc6RXvPcH36asN1jvcDh0lNLmDaKDSGmUC06+IVJNopXg6vKUR/ePGWUJqU5JE4WQHc+ePcGYiCwZkqUJ+3tz6qakqK7J8wWDeUQyzKiMA9uRxIrBMCbf5HTWI2NJkiS9g3ZKVedEcUzd1BgqhPSsVwuUkiRxiu8k6WRI1XSUdY5tG8qqpDMlo9EI4ywiESRxn0MuQob1aC/t/TEGlGUOVrK7OwESmqqibUJB42T1lR4jz88NbZfgW8/1ecFHl+eoWLCuoWwtd/YPSJIRZ6dnTEcTUhczlft8+P63mP7miMEw4fLiiqaoODt5zmq95vPPP+fBgwe0XUdVFCjpsW3H8dExSZzwFz/8ETs7u0zGY9569A5Pnp9ycOc+TWe5ezCDcsPps5dcXV8z3zugblsWiyW/87u/xw9+/BN0nHJ0bKg3G2bDAedSMhiPSKMIIWC5WVF3HZ21DEdDlNJcXi4QePb2Dlgurrm+XrBa5XjfobXEO8/19TVTGyJcBoOMOEpYbzakaYhvGqQxbz04xqEZjMZ88vgZXdtRlTnT6ZDOONI0Znd3TtdUpGnC6eklFrDekSSandkQ5z2vXp2gtWYynfbNR8PR0RGfffY5VVUFRMFaIikYDoNR0tX1FZPZhLZt2dvfI9+UFNu9UknqLki5pNZ89MlndK1jNMqoq5rRMKNuDHXboiLF1WLNpqjx0lPWHXESUVctzpU4FwxWWx/M/nSkcJ0nL8qQtawNAslwrogmhmSQIpUB5UkHDk9FZhNenpY0PTNtPo34xnsPmQ4jvv/nnyBTz3iiefudXc5OciQRaeJQ0pPtahKV8XLjwDjqjadYw2Ro6VqLUl9tnNiq2AQab6xxUiDiCBlrvBJY75nv7ZLohGw0JMo3FHWF1hqLp+wjnnSsaNqWeJCGuEdrMSZE34zGY6wIoELTNGw2mzcG2ltwILD3zBv75bZZKYqcVEcc3d3nZz98DKIDFPCLyM+28d7eh+wziY1xRI0gNppRlgWDIzUllhLtBdZAlI5ADbh8eUFrFaPZDlIEne2XDdS2JmTeGXyv7y6Kgqqq3vCSQQa/kYCQv+mGLoSgaZobUOC2NvumMe7vF3jj8tsSOeX8G+OH2wy+8JqYG5bB9na2TbQxBiM8MgqpFrd13lv6/va13F62/d3WtHb7WG4b3N1+PiiJiJM+acRinaQsK05PT7m+vsdwHLxUtizO7efi5nk6R1FVwfFdgowiVKRvZIlSSVKvqJvgSTQcDv8tj4KvZkn5ZgMtVPCUwZrAGnotu8b74GxO31yr3jBQ9Hpute1Bfgli/aZvkH8tBxXgtxzy/uIbHfnra9/cxtYA+aaR9txIW3/hWl+qh0HgBD1TpU8GkgIlNUJHjESKVhmm23DeFHSmQ0iPdJqiabAGusYFY0YdYSKLUAlEoadwUUSlFV5GMM4oIsFadOyrAZM04aLLabShiTSDBPZkShJHmNoyiOKQUmE8iU5wQlJ7T6oEsZIc7u9T5gvKqsFYMEZSdGsaYekagxaKrm5oqpJYi6Dbloq2bbm6umI222X/cE6aZeRFhQQGScZqcc3V4prl9TnHhzs0TRMYZ+mIuqhY5xvKumWzOUV7yOIkvHvCURQFSkASxxRFBU4gvUO4MKyweIQIQ6tfdUfxK2+8nxcLztuKtehodfggKQ+RC35+Skm8dXQ9FUrpFGsJehcZJrfOWpSwvPXWEe++/za7u2MGsUL3TV4cxzcn4q2Oe71a3Tj0Nk3DYDBASklRFJRlgRAh0qcsS6ztGA4z4jimqirKqiLLMqIopm3b4FRd1cHIhFD0b6PEbtwoe9pTMM8ZEMUxujXoKIJed56mCZFWOBsQcAgxGVmSIL1lMhwFWqIPRnLj4YB1UdE5g/GCsnEUrQuTTRHROUiEwglBXne0zuNEoJFnSYR2ntkoQ2lNVZVIPGVV03YOqRRKC+qqwhGm55GSGEL+sPeeZJpxfHREURTkRYlUQa8+n09vXD6bnv51m06+fU2+7Gh+u6n+ck7n7X//bdevCzVPWolpBdN4TDpMqVRJpRKyKEZ6xemLM2bzGd55Dg8PyJuK8+tzirplZ/+YH//8Yx7efYhONUJCvl4h9JB1nWOk51u/9V2ePnvF5fWSw71DmqJkvVnz4N4xeMfVcs2nn7ygE457bx8TC4n1BqUFAo0eDNiJppjsh3zjD34H+a9/SpeX7N3Z5cmrp4xHoVnc5GvQoBOBczVaWNIIIt+hkMTaobUjigRagZLgZIjzMsJgpKGSFjnOePjtdzhZLymNYSQjOhPo6ZLgbO5qgzaO9fqK69USEMieIqiVDnOVNMJ4w3gwBAmHD++xbDZcyCvkWpOmE2zT0lY1+5MZsVSsrxcoJKPBmEjHSOvwXcd0NKKYG+qyodtUbE4XJESUPngzWOdRQmOLCu1Cky1DNYpUEiU9pqvBW/7G7/w2k8kQ25RcnJ9wdnWCsQ2L6xXvv/sQrVpiXeGNxcWaTz/7lFbO2DkckU4mnJ48JYqCR8QPfvgDju8ccXh4hybPidOEvCpBSZabNW3TMpoG3WTjHIMkRug4MFOAKBswmu1wenaG1IrNJicexERJhMPTuBprHVrHiAjyasMgy4Jxo+tYbzZUZkWaJEghsbSMstEbhpNfxYrVkGgqiPsC+M7RnMvlhr/8i48xjWN3OkCnkkf39+mKFlFq3r/3Dv/H/+w/48c/+j5OGt7/+iN+/Bc/ZbO+5tXLl2TpgDQZcHF+SpoktE3D8dERbdtwdnHJbL7LgwcPiJXi808/4ccfPeZb3/ktbFfRFDnrszO8cyyurkCEOKssHfKv/9W/4uzyikfvvEuxWpBIwZNPPiVWOniRdC0XF+ecX11j7CV7e/vBGKzt2N3dJV/nId7KdME80DoODndROqJrG/b39ynLkvF4xMMH90Ps03qNEIL5zi5VW7Ozs8Pp2SXLdQ62w3YNgyRGEgpFL7Z5yTusN2uy8ZB4OObk5DywqrTGdS3JILwuTV2HODXjOD097ZE6z9npBfP5lPFwgNYxSknydYFbeKLohHv377K3s8vianFzfh9PxlRVQzIYIktDU5c0qwqJYzD2LDY5mzJQtp2wGB+alaJqaJoOIUNkTVm3JEkU0BU8m00evEZcQA3rzrF3HPPb/9EduniJMwTTMyXZ2bnDSpU8fXbJ4tJw750hxabBdhE/++kL5hONjDyD8ZDRMOHTj5+QRvvEQjOITKA4WsvONGIzF2TMuX/8gLNXP+D5ixPeef8A41df6TFw597dG78ZFUfEWga/lboi3xQMdUgdaS7OyasSXxaMx2OMNVytlswPp8g4otiskU2MtgYlw8AukgmFaan7WNW2bd8wB7PWEvUsvO2AfNtshTithDiTwdw1mvLd3/oGP/7zn3N1UiPx2M4g9S8zGnttmOpkyLg21pDXNd2iY11KklSRZTGp1ignMJ1F1CXokDhhvEdGgV207XG2TfBt1Nc7G8xje6R121hvDdSsMVgRzuW3jctuG99u/RNux5zefi7b89624dqax72uTQTyVmOk+3i4bS3TdQ7rzBsAwlYGaazF4BB9nfhlg7XwfoCzr6+3HRzcfgxa6zeyyrfXVUohtpp9H4xLtdJMp1OiPk53MNB0psD3JqdbU7zb0WebsmAsJUma4K0kGQxw3mF80NhvkdYsy35tjXeI+3W9F/iWfxCifP0NO2PbNN+KsRUCtaV+e3nTcEteU8K/jDy/Xq8/n7C1P7v1i+A9+MZ6/bkJj8vTAxB+Oxz4q2vWrbN9z6cP9yvDc4njGBkl4DTWOGajEYt1hTGB5u1tMMTNa0ODRTlBsypIVEiRSrMUG4c6vXMdUkEnfBjkKY0wHQmO2jS4SFBLxW46ZCyGWBnxWCzZVCVVaxBKM5lk+KKg6moiKRkmMTuzCWlESMMo6vBYbHA9t8b1Zs0OIeDwcJ+dnSlFWdG0Lev1hroKx+xgkLI7nzK0itImXF5e4J2lKErqasD+/gHlOkJYz2w8RMogNb5abJiOJ0gr6YwnSqMgQTYdLlK9GbfAdRbZH++t7XA+eIWV7qsdvn55/erN1fI1lbPkwgfregI1QXuQwodpt7FYL4KVu3WoSPc6DYV1gBfoRBPFEZ1pUQriJMa24YXSSgYaqzFIFTKDsyxFKUWe50SRJssy8jxHKdnrKyc0fVzRzs5OH0lh+glKzHQyo+sMQtAXHgKlY0AGKnxT413QpYUTHhRlSdM0XC0WaBURxTFKR8zmc8qy4PKyZpClSCkYDwd4D5GOAg3eWdK4pek6lIxwzpEmMVkUsbOzx8H9h/zJ977PsLVIpRlkAcnurKE0Ha1QJFmCiDyTYUYiPcoqsjjGW8d4NMa2TchVjjxNXvZUU0/VNJSNw8cxWmsiLYiVY3c+5/DOId47Xr58SZ4XvHh5grGenZ0ZWnpGw2G/URqqsiRJktdZ3fzypvuvQrr/B9ebjJ2bk+Wvo/c+e3oKSvIvPvtj3vv6+xzfO2aczMmLnI9+9hOGowGfff4Fv/03/waT/QxzfoLxjtF0FmKlhOJytebDD77Oi2cvKLqW+4cPGY4yfvrpj1jk55ycv2A03KFzHU44zi6eM0gND+/fR+sxdZGzaSqk6Dg+usvixSXGGjZ0FMJy3QmO/2ffYrXjGX7riAeH+0hv2G3vMBmP+eEPf0hcgo4jJjs75KOWfL3h6x9+i6effk5V1wxkzO7umKurFVVaYscGBhKbabrDGJENGO5PmL39EHV/zmeffxpkHz7gJcKBNwbfOjZnl1SXa9qq2W4rwRRHyWBoocBHEjlM6dqOpqk4/M57rIs1f/zZc75z+A1inRHLDFs3MDAoIZhPpzw/ecn+dE4kFF0XcrHX6xVCS7I4o3Sa+mpDs8yJhxHWllgf4n5s60hVRCDRh23Vi2C+0XU1uztTDvZ3+fijn3KwM6coN1xcXmJNy/GdKb47I00M0lrWlznzvWNsZegazw/+8iccPtwnb0o2mzV3797l3fe+zsX5Jc9enCGluBkSWmcZDIcIFbEuS+q6ZDzboa5rBkkKWD578gKBYjgaMZtNiWOFpcM4y2Q8oTMdRZ6TjcYhs3m9IU1TrhZLkiiwbg7v7HF1fUVVGQ73D1m2DVdXV0RR8pUeI+evLhmmKeNRStMUPHx0j+JnDUXTMYglrqsxxnN49y2qDqTT/K//4f+Sj3/2I/7L/89/yW//3u/ytz74Jj/48x+wWC2x3hPHCYvrBfhQmGaDjOvlgtU6J5vv8NY7b/P86VNMXbPcrFkVhnv33yLPl4i25OLVK64uL0JygLXszHfI1yuqssJUFRrP+uqS9WrFdDKm2Gx4/vwFg+GQk/NLrAOl4+Cq2g9aV6sVm03BcrWhbSqO7hwSa03VNMR9fv2mKNnfC0h8VdVcXF6yt78f6JvO0RpHvVjirEV4x3iQBIPAODTuTdUQZylCKZqu4+J6ietPfFkWMx0N2d+dg7Uc7O+xWi7pOoPq/SGaXm6VZRkvX53QNS3XTYvUG+bzGePxDK0kL1+8JIli0jglUpqq3NC2DR7PYDjCeIfBoRJNGkVkcQQCnj47xTiLF6ER6b126WOJ0UoTJzFe0A+qQ3JI0DqC8IFGefBWzDf+xpjRfoOTGXlTsjcf0NRrOuvQCUx3PPFTzdVpSTYQ1E1NLBUXi4qje3Ok9uTrgmojeXF+QlsLirVjmE64eFkyzjZM9zyXj5c8f1WRDMEYxeG9jNYXX+kxkIwGFHlBvqpem5wJ2JnvICJFbTpSpWnbmrKtcd4T2QRrLesqp75sGIwHVG2DamsSkZCohMYa6qLGq6BNruv6xgdh2zgWRfFm3nP/ecnz/KYZNaZjd2+HctXw4Tfe4/d+/7v8k3/0p4hWYGuHUhreSCPzb3xZZwj6M0HrPG3VIBtQhUBHNamOGMUpxjk622LJIYqJspSiLYm0RrotNdjfNJhbNFgKGCWvhwaTyYTFYnHTeFdlBVHyRjO0fZ5bxHj73G8bxN1m3t1GyreN9w06bS3aB0Ou2wBD3NdLdV0H2QqvndS3LMumacKAV0DXvWYTbRHtKIpI05S2NVRlGJpsI8K297/Vs+/s7GCtpSiK11FyvSmt8B4RB3227dmenc1DjRtFfYylvqHge+9vHh9AkqaMZtPgKRApVtc5KgkDOWMtXdtSlSWRjm6af3a+0sPkr7WkAvwWQX4d6YXokeVb1eFWZy37PG/Zm8dtBx2y/7x5F6Q84UrcQrO34mp/Y8J289ubH7ZX6P8fHsyNxZvz/ZjAb7XcvWa756rfNoIT4rWZ2zbw7LUxXP/ghEBFGhVF1KWlqWuE18wnI1pvqUxLaw2r1lDYAGwm1mOaljiOmE4GWEXwSek6bOtRQuGqBtO1DEcZVWLZiAajOlIf4TcdlQ8GgiZxXLcVizLHG4mzHSkCJSSjJGU+zogVrJZLpJboOCUyAlusg+QJaDsD1jEZDZjPxkymQ9I0wrpgluucwRP1+2DQrQ+TlGpVszuf4F3XywOCDFjrCEGHFHBweEheNlxcBGPSJE2JbINWAuFlAFqNxRH6RS0VsY6I04TGGDoZZCLG/gfuar5sJFYES/1IhE+dsOGDrETIt1QqPIzWBk021gUdgFBoqZBRaNKzNCbVMYlOEUisd4EisKU89d/rSCGFoqpqIKDLy+UVcZwwHg+xXaDHeevZ392/abgXiwWxjtjf36euayIhcD403LFVISvSC3QUcn6n02Gg7QiFdY7UZ9jOUZcNWlvKsqYoQ1wXQlPVFdAxGQ0xJlDrDvf3kMTBrbVqcC6EvSulEUCqJe1mycsvWj58dJfrxZrFat1zaaDsBKXxyESSpRFx16JNCQJG4xFxlNDWLZGQwRzOejabTZ9H7kGBSiK0dbQ+GBQoZ5jPBgzjiLYp0FHE3v4OZ+cXFGXFi5MzkJqj3Qk4ixYCqYMNv2lbUCroM7abwr9BN7Ndv4wq/st+9/p6t3UxHu9/ycjx38G6e/wQi+fd97/Bq7Mzzk6WRJHm448/Zjof89ajdzk8PqbqDNI42tZwcn7CnaM93nvvXR4+fEASj3j85IQ7B3cxxrNar4hixzuP7tFWG7o2xw/GnJ6+4Phwn7vHB9y7d0jT5igRM0gVO/tHHN7fJREZ3c6cdbVC+4hPHz+hUAnZ3UMuzZorvaTYrNgdj6i7gut8RTUyvPObX8dKQYfnvW8ehWIhTrn/cEAsJKwrRsmAk4tr8ralcx7jDFoL9vf3WKxXdErgtOLFi6eIHkXGgXcC7SBBc3F2yvrVFb51CAODRNNZT5YNsbGnWBfEWuMEDGczrAzZkq8+fYIaxOBa/qt/8o/43/7d/w0ffP09TNexXFzSmZqmrVheX7J35xDfGdqmQSsoqgKjkkBhF4r2esPli1PGj3bxSqCVQjtBW7YkQofGuwd4nHVoBetVcHdum4bJdIqOIgbZgK6yZElMJHL2Z55HD0Y427I7Sji7LLg82fDONx5w795D4rHCR4rhaEZVtVxdXZMlGcaEAsiYDa9OXjKbTTm8c4eHj+6DsMQ9xRQhefrsBXu7dwhkE0e+yYljTVlaRKQw1lGWVaCRIWi7jrZp+eTjT5lPphwdHN0Uckob0nhIXTVcnF7x9NkzIhWzv3fwlR4jmRziu5bRYcLhnffZ5NckkUMPIdMZrmsZJxO++dZ3+c//5f+P/+Q//kOca/kn//QfMZ/NeOfR11lclpy8ugw0Zq1RCC4vLpmOR5yfnXN4eBgcuK0lMYYXz58xG41ZXl/h8bzz1iN+/Jc/4Nmzz/lP/8Hf5dmTZxhnSLIQ83hxcY4zPiQ1KIntai4vLhgORxRFQdO2tMbRrQuE0CRJRJImaKUZDsNAF8B0lqYxHB7eYTqdBJ2t8NSdoWtaRsMBrek4v7ykbRriNCLJMjZ5yYuXp6hIc7C7S6Rjkizl6fMXJLHGO8toMGAymeJ6F+XLxSVV8zpZwzuLtx1VXmCdZbNeA3BwcIcXL54j1RWj0RDrLMtljXcdWZbRWcdytSZJU+qmJUsTkjjjk08+ZWc6ZZDF5LnDmGDQBYGWfHDngPU6pyoKvJAslivqxhKnYV8yPbrnPWglwTu0VggBaZpgjSFLY7rOBpdnL0Juber51u/POXxgyOKwfy0fXyNERJokPHn2HNM6qrLmG9+es162WF/RpZLzVy3H98ZcXDZMxhm/87u/yZ/9q49AGgbTmN2DBIFiujMF1zBIB/zm7++zuLxAjzSDkWC8U3O9/mrlFtloRNW21HWJaxt0pIl0hFcSmUS9JM0TRZpkNAj06N6Ne/fggLzbEGdZSF+QkrJtKJsmoHTOMRgOyeIQZbVt+m7vn0mS3AIVkpumtqoqhBBU3YpsGGNdy2gw4A/+zu/y8U8e8/STK3Z2D7hcXv+VlaLDBzSlRxyNhbZqSZKYVGhwiq5u8YQoM6ckAVuxSG/AeXzd0fVo/TYybdvgCTyJHPZGY68fSNfHcwkhMLebJ36RBfflOuQ2krz9+cv669uDCo/E94DCli2wbbLB98Zs+kbOuFwu37g9S0j1uL22Q4HQDEd4J/u9wNywFrbotzGGnZ0dhsPhTbN/mwof/I0MTdNSVxXWKpAdy8UyyCYTTVltbhDy7dcNK1EKJpOQv74q8p55tWI6ndE5y2K9IouSN+Lafh3L4kLEmes1zzd8b4+XAH3MWN8oS+GDg7kEvW1nxWva95bSHWAibujc2+9v/pWvNf6i1w1vG//Qeofb3Bq8WWTwgvIC69UNyu22U8jt8+nTgl5HmPVN/c1t9/cHGE8f7yaRWlOJik1bgFcM04Qdl3K+MuSVwRlPjEb5wFBscWjpGEWKTEtiqdiUUEmB6XulvGkRScxQjomMRTQOG3Vc5Guc8tg21BbkDbI2eJXQWssqX5PEEaM0Y5gqlHScX15jhKRpDMZZIq0ZpjqYazuDNR3jUcLh4ZzxKCOONEk6YzIZk8Qxp+cXXC6uiLKMUWOIkpbV1SW2NqRReB+61lDkBVma4CNB0dQkoyl3Do44Pz1nMIgRvkX1Pj4+GdGIKMQgixAz2HlLotIgAUxCmoOxW/bEr279yhvv7QcxSBx8fzCIQBn50olwS8PZnvTiJME7S6Th3v1DHj26x3icYW2L0kMSkjd0wzcUIhFE+4NBhlIh+7Bt25DXGEdUXYVSkul0CnjqugsW9ZFmOp3gnGU4HFIUOVmW9hNHUCoYKURRjNaK1rw2snAuRC7UnUFKRdMa8qqibjviOCHLMryUdF2DBcq6IUsjus5wuL/HerNivd6QJSHPUyDwDtIkwdiKMg8RI8bTmwB0dNZTdjXGO2InwflADzMdcZKQJUnImI3C61o3DeBJ04xlvsDJ0Pi0nQ3FQBTcb7H0cSOBers7m+ClZDjIePHyFcVmyfOnLcrc4c7BfjAH6d+zKIrY6rlVry3bvre/bH3ZbO3fXq/9xojy3+nyUtPULauXl7TG86Mf/5BHj96iqyQ//OJnXF1d88E33sPS8tlnn3P3+AjalofHh9T5Cmcsm7JE2IQ//95P+OCDR6RZx+nZc9JhglAxd+/e46OPH3N+vuatdx7yYP4+QjnOL66YDKekkxHz/T3O1iXPX75gU7Q8ePc+VWsZTQ/wjeX0xUuUyMiyjDR1SFdzb7rP9fWC+jrnR3/+Q2bHd4hnY0xb4yNJW5SkaYxyhvFU0dEiH0yIvUB7galbZNsGWvSqwDUG7wRD48ikIhIJrmvJkLiq4vLlORfPX4UtR4LUgbKmOkuSpVznS5AemSiiOCYeDLDeM5YxiUqJhCQ93uPVD5/QdiWb9SWPP3+MVgqHYzwfoiPBII6xbY3SAust1rWkw0nIGbYCqo4ur+nqFjUKunNlwdYdA5mghOyNPxyIwMJpmobJdML+wQFtkZMXOcUmZ3Wdo2XDfGL58O096E65e3eH+NEef/K9Z1xc1SxP17z73bv86U/+iGg4Yjia8JMffcoXnz/l6197yGg05uj4GCkFP/zLn/Lu219jsdzwSAj2D3Z5+eIFn3/6KXfu3EXLmB/+4MccHh5zcLhPW1d88dln7OzM2L+zx2xnh6vFdTgWpaC1lvV6Q6QkVxcXZDpBAJ1xeBtT1x2T8ZyzkzNOni84PDji9MXyKz1G/hf/8Pf5x//0v+fJ41cMJ9dIn9JV0NWevCw4nu/yrXd+m3rV8I0P3uO3fuvbnJy9REWC4zuHFOWKH/70p1RVx+GdOyyurzl5/oKmrrDWUJclcRwTpxnr9RJsR6rHNGUFXrBcLLlzLFheXfA7v/1b1EXO5dUV6SBjOt3h6dOntE3L0Z07lMuKtx++zWa16OlsOUpqBoMRefGEIq9IkhRrLbFzmC7E/7VtiIGsm5w7B3t8+OEHxFHE5198gcezLgq6qiKJNVIIoiRGek86GHK1WHJ9fU1rHHcP9omjCIOnqmvmsznL1ZqmbUiHA4RQbMqKZy9ecnp2QdMatFLMpmPa2mG7jixNWayXrDcFUmmWT55zdXmNljCfBc+Tq6slHsMYidIRWZbhXDCgWa1y6rIiGyQhsq5tUFJhrWM0GJBlCXu7O+weHPPs6Ss2q5JXy6veh0sglCbWmq6rsP2e7x1IrSirFmWCn0nXdQh62ZXUGOtw0jPek6TzjtF8iLIJTbNmZ2+ARHJ0eAy+o8hLurrBmIa67Lj/4BjEiEcPNSenz8nrgrpy1FVDUTsmOwdsNtfktWE+V2QTyWbRcXx0xOoiR44Md/YyJuMIpRp24q/WYHCZr6lNi05CcxxqcE/nLVXbhJiprsF4S5ZlbPIC52xvdhkzn+0htWCxWd1Q1tsu0I3jOKZuG+IkIYqiGx30lgq9lcMppUjTlNEoDJO2aSTOOdI0xdoOpTw7O2MG0YTf+/2/wdWrP8K39n/o6YEAt41q8gKhIpI0GLpap2isQJqQ3uKjcAXjHMJZOh+MjeI4xrSvzXC36LNzDm9DQ7ltVLdNdF3XobZQGmftG4j3Vte+XV/OzbbW/gLivaW4b4cUb2i9pcb1Def2ekWftR5eax9Mv/q/b5rmBl0PsWRvPoYt5X2LeDsHUkQ9/T/ufYdeG5h1Xcdms8EYE4zw+rSY18bC9Dr4Gikiok4QJYarq0vKsiTJgv57W2tt9edb9DwqCwYmDEdW63Vgt2SDXuboELea9e3Xr2MpPcBun7uz3GR4O9ebpoX6f0stl702euvuf7tWfEPi2KPNt5vtm59vxZDdfPnXyPcb7E2Cb4Pz9DFxIU6VG2bmmwOh4Jf05v3S39VNTHi44AaEdz0LQ3iHEmGgI7BoJcPz9Z4ISCNJHOme7m5pu45NUcIgI0lUAB3ombxS0XQt66JivjPHdOG8LZBUVUedOdoqDMFcZ1FSoaMYhKOumyCjwBEnCcPhgHaZs1znbMqKpm7Ymc/YGQ6ZTIa46QTnDDvzCXEc0TQ1i0VBazxCaowJEc9d21AWG5wxOC/C4+gco+mcpgsxd85Dkg6pGlgVFVfLL8iSjEGWgTNUVU7b1ugkwbmQThWikHUvUTY3wG04tgX6ZlDyq1u/8sZ7ayKw/f/WrTscvPIX9EK3NSfWNAjheOvRW3zzw3eYz4YM0ogkVrRN0DBuN5/XmqWYqiz6E2toBEPDkfZ52qaP8wkT1LIsg+7S2d44LJwMq6oiSeIbKpaUgbqlhKJpG4TUITOT4MQplMJJS+ckVVXTdB3Og9AaoTWtC47C3hqqtiWN+uzsumaxXNK2IZZsOpvRVA1d3VJXDQhBmsQ4oWg7Ez6MnaHxYISg8xbpwbVd0IYLgdKC6XgUItPU1swjHHhlXdM6j4hiNnlFB7TW0bmOrgk6+0ESKEnOGNoyR8ynpFFMPJuQxhFfPH5CWxe8eP6MWAdq22038xBvwQ2la7u+jHzfXrcp6X812v3vz3r6/BXOwZ/92Y/5u3/vD7k6XVFefcb//v/wv+M//y/+n2gfc/LilHQUIwTsH+wy20lJkwGXl1fcPbpP0yh+/KNP+OGPfkpRr/jmtx/w7rvvMRnN+KM/+pdEaYaWmt///b/JxdUqGJsZS9dYRqMUpOFynXNSVTwrLJ0e8vyLF2g0o3hCFnl2BpAOxmRpxuL6CU21YufhHarcMzic4bRi1eWQd8gsps4bojhinXfEQrLKGwZqgBOKqnWYqkM2Fnu9wa5LKDtsa3AOhI5QUlG3HaZrWdYd5fWKelkglCQeBqpsV1bUeAazKZ0Px3E6HSFTHRgySjNUEamwNGXL4vqae/d2Eang+OEhe7tT2nKP8+tLloslH377A/74j/8I4U1wzpSSzrdYHFoF7atEQGsRxhIrjUpC5q3oPHQO4UPGrXcO7yBSMUmcUeQVR8eHNHWHUhGj8ZTl9ZqXz17y4ft7PDweI9sVKTXt8hm79ywfvJ3y/JUgv9pQrgq8cXSt5ec//wQdSf7T/9U/YHl9jZYRm1VBmibcv/+ATz75nPe+9i75Kkd6S1sZqk3DmbsmjUdk0QTbCM5eXPPF55/wjW9+DaXBtIb1YsPZyzOm8xlREtF1HWmccP/4PqvrJVUe3PaHoylV2XB2do7tLPt7+yQqRGjkm81Xeow8P/0Bu4cDuLJEkeLp4wvqpaQuBKZxfOPeEX/79/821jruHN4hTh3eev7nf/h32awrXp2+wLiGo+M7nJy+4vJ6Qd11eOnwUjKdT8iGA754/Iz5dEhTVazdFcY6RuMJQsY8f/aMWEGd57x8csEmz8mLgs5Ylqs1s9mM5XpNNhxwfXVJnucMRmOk8uzt7/Ps2QsWV0sGwzFlb8RpbIfWEdcvThASqrrGmJajo4fUecHTi0uqtqGoa1arFfcOD1BCkg0HiChisrNPU9esrhak2YCBlqSRxHUNwoFCcLB/wGK1QkjJcDSmM4Z6saBctmilaVzHZDZks1oxymKOj47Z293lYrmkaA1V12CMY5AmzCcDYu0p64rGWpSStNZiGktdtzSdII4M69UKKQWN9eRlzdGdferFmrJybIqSvGlYrNY8eXZKkdfUTRfiMF0olkRlkIMQgSRdHwdGGMA7QhQSwmOtx9vgSJxkEunh6K2EOx847tzb4+p6hWlOODyc4RvJJ59ec3XR8Du//R6uKaFqGY8GzL6zy3Ihef7skjJvQHqmkxlNseF7f/Jzzlct682anYnsB+ISHRv2jga0XFAJQ+UtWTokmw2IYsd6/dVqvJWXRCIKxXfnaeoaHUVIJxmlQ/QoZb3asFqtWBZ58H3JUrLRCOssVVNzMN8nTpPekyZEmmItUgfDK6VKnPeUVUnTBu084rUJWAAd4psc263njXMOpOPy/ALpFfWkpqwc3/0bv8n3/uQnfPrRK1QS9XnI2yingC7f3qZdb1AkUCRx2jsVd5jO4J0nlhqhVUDMVI8wG483Dt+zKPI8v0Fyt2k1xpibuC2hNFqGYUJnHU0XBgexVD2wE9Yb5nH997fN1oQQb+jgb1PQb1D2vo7ZDjCM8ggfdKneS8qypWlaoHdI15LOtDea7khrTC+3s743wPWvnc5D/dtr7OMkHA8u1J7D4ZCyLMnz/A2t92azYbPZUFXVjXnbzfO0gOloqxLhJLYLTVi5MXR1DS4ijuObGN0tVX77WiCCmeju7k4w/O2bk64NWvvhIEO50MA5FxqhX8f67nd/n6ePv2C1WmBNi5KAN2Hgs0WwfTBD0yJE397EhX1J9rj9fltz3m5+b/sAfBnxDiB5j5TfIOah0bZu23SDdVsq+79ZTrnVbd/czxsXvr59gQ91vnfYpsXZEqxjEMc0ncMLwSBNQrym81TUaA1JGiGUpLOWsq5Y5yXGWJLpIAyyhKDzrjeR1T1AZ2lbj5Ia5xR50aLEBukDIyyKUiLb0XZh8Lu/O0dLaKqCrusYTibkBuy6QKgIGXmKuiEuC6RwDLOU0XAQBk7WUJQFZ+endF4jVdzLS4LoPlaSYRZTVB1KRwyThOFoSuKhs7BZLvCrIhieOsHyeom01yRagNNoSf+ZVzfDNtGDdVEUYW1IWdgUBRJFrOOQwvMr7jd+9Tne4jUmeQvX7A0PJP4W/WZL8QkUtZCLOBhE3L93yM58TBqDUoHI0XWOKIpvpn7bk2bXhYLftg1d16K1Dm6//XR3s9mgtSLNkhDVIkFHiigKZhGvqUxhSty2LdYFUyLnwqRrNgt0U9NHY5RVRVFWwUlcBjqM0oHaLZXEektTh6Y31ZpNGaZOkU7xDoqywnlLpiM2eYFwnmw0xPZuiWVZQdOSRJrWGoQxoTkQYXChkCR9xmMaxwyyQKlPogjVU1PqaksB1xRlgREadDC/sl4E1Np6EB4tNUrKoLGtKkzbkKUpURzjvOfu8RGfffYZRgouLi56I7roZiOXUvYoSXg/thqr8Hn45bTyf9MH/Zf9/t+XHrwocqI4pSstZVFxsHfI7mSXv/izPwfr+4J3xLpckoxjfv7pz9BaYSyUZcNPfvIDHjx4m/FswN/+w9/h7v0D2m7D2cWacumIXcbmuuJr737AYDzmsltSV45PP/6cndmEtx+O+OiLnzM/OubVdcXSaEyc4CLFwEUsL2tSC/uTOVGa4YTgwfEDOmu4MDmD412SwzkohZWe1hmKrgKZ4ZwjEgOm0ZDPv/czZBrcr9fnK1Yvz2ku1vh1Scil8sFgREfgfIhmsF043q1H97IIESlEEpOMh4g0pmsMtYa6NQzGYzrp8DrEFRXrNdFgxKsnr0gPxvhTePTtD5jPp6xWV1h/n+E4RW0EXno+/Tw0tB6LNYHOiBR454m0QhLMQ8DTlQ3XF5cczY9CwdF2SCfAepx3CCRCOIQMLrBVVXOwv49UEokgjRLKImc4SDjan9AWJyyrFfcPYu7sZMzHFdGjXb7/I8vpZkGxnvP+u1+jAnZ3D6iqmk8//ZhvffNbVHkwctRa853f/C6nZ6fs7O5Q1y3rxYqD/QMe3n+PNBnx6uUFR4cP+G//m39Clg2IIzh9ecG77z2kqWrOLkLG+f7OIadnpwyHGZfnFwzSjPt37xPJCGcsTijMcknbVVTlmsko5d79gLaOhg+/0mPE+I4oHXL66pJ335vzO793n2efXPLxz04R1tPYiqJc8/Wvf4iSgkcPH6KV4OkXn5NlCd4b3n3vLdrO8tkXj8nLlsVyze58jnUCKSN++tOf4/DcPd5lsVwEA0njKKqGqm7YlCVHx8f87Oc/C0WltWHa7TvSNMGYjiSJEVJS1hXWO/I8Zzrd4eXLVzx58uwmf31bvO7szGnqlqvFChVJlPC8/egt2q7jxz/6KdPZFBXFNHXF8cE+77zziLZrONjbJ80GvDo94/mLF2RZMI9Js5jV9YIsyeg6w2gwwgKDbEDbhSb/8vI6SK8IqRRJEkxFZ/MJ946PqYoKi0RHKXVzSWscWkvmswmjQYy3LVIq3t7Z59Wrk6CpULBuWlwddKSREAgTjgOPp3rygvlsRjoa0VjHYDBA6Zhyve4peT4YzFUVIDC9ltE5i/e9GZLSdG2LkBpB2Bet8QjpsFJiE8NkL+UP/v4D5LAlXxWcnlwzHiZ8/ukVVggW11DXa/78B1+QRB33jiasVyVXLwvaMubipMHhuDwr8ULx4OEAFUkmQ4FWLTvzGKksDx6mpMmEut5QFCVZ7dg/2EEpS5Q5BumY8WTy/+fuz55szc7zTuy31vrmb885nXmquQqoAgosECQlUpRkSy212pI7Ouxo2+EL39kXvvGV/xx3dEQ7WmFJ3RrIFiFKJEUCHDARNU9nzjn3+M1r8MXae588BYCkrQLY9kIcZFaOO/f+hvW+7/P8ni/1HBALwzjJIYa6bsiDCJyjPl5icRRiiQgVvcmIcA1A67oOFyjKZYEK4fT01P8wB2Hkhwl1XbNcLv39s3S0uiOMvF/RR4wGxGmKWf+8TbzqRmbuJ8sWJSXjXp+uFSwWFV0bMNgd8crbr/CDDz8ij4aEJsVZ76O0ePDtxj8rhKStWyajXaIwIk1TTk9PqYqVnwirAKciIgRKrgndxmBLf41NBgn0gm3sV1mW24LXb44NMvR+9DhJWB0d0hiQcYovhb1fd/t8f2E/4Zx7Ln5MSklV/aSdYBOVZYzxJO+NSs85HOaZ11eCs440i4jWEn8tHHXRUuoWZ72E1cGaXO9tZlKF/vXVDSCIwpQ06a2nt5ogYDshz7IM57wtENgqCZ1zW7jvZQCdcgopWspVjYk6ojggEAqdB9imJpJDtLD+sa6HTxvpvgdNeajU7PgMqSQBAlt3tGWJsZY4DkmykKJcUVT++vnXsW7cuMPNm7e5ODvm6dNHnJ0eUpUFQthtHrPArV+qdawY/piw/GTBvVmbw+fypPtZMb4ZPW+/am3t3tgQ1ipUi1f5ON9sMXbt6/4ZoC6xnaLzU/fHzm3qJ189eU+6V4BYOpR2hMIfY1oIenGCDCOqsiIwmjgOEcpHhysZoHVEV9d0naaoG8/XEArdGToHXdeCEMwXK8qyRQYxer3/6ZqOQR4TBo4QRVlUaOvIej3SKKCfxVy0BfP5lGw+YL5csioKkAFJmmz99FWxoi5XjAZ9kkiRRDltXWG7jij1e9Q4TomjiDjyqR911VB3DiNiwiyk6QxRmiNUzKJoObmYQwhZf0hTVNSLOYEKieOIKAyotUEFAV1n1yDHy8kCDmcFdemVXYEKvDpC/mSd8mWun3vhjbvU1Vkf7J5AuPa8rLt/m+7dpsu5Kd4kgrpcYUyNUjFGdyhC4ij2nfZ1h3IzWd14b+q63k6sge2FIo5jwsDTkzvTEYZ+cr25IG8uSnHiNzXadGjdkWYJWZb5kPrQS8StEPQHfeYLH99hhKCsakaDnKqpSbOYqvZerLKsMc4xL0uGvYx4TT536/y4PM/X3e2KLMk8vE146JXqOuIw9D7yKEIEAbF11NpQ0pCpiJ3eYE18dOR5Si9NUYGk0x1N022zxztjkGFE0xhqbam1xQoFeEBHqAShkgRK4tad5lYbtHUESpFmGZ22pFlOlsRrmZrZSq42dgGk2sJPfuIid6m7ePljl9UPfyFwzf1kFMNfx8omCcWq4qW3rvN7//E/MBr1+Hv/8Nd5/PRz3rn1Oq1e8ObbL9Ab9phVJT/+8GOe3H/K9YMXuf/R51y9fg3TNRwefoqTjqu3J5ycTtnf2ef9D7/P6698hV6teXz/CefTEya7e9y4+iK/9+g/MkgHfPDuJ5yczHj3w2Mmb38VQk2nOj/lakM+/A/f4246Jrq5wwcnjxFRjC4awiSivzvCtpBEGTKMODo7pL/Xp399RBV5yAQypKxrmrnl7HSBk4KdwR7yvOF4foqoQSqFVeuucWcRgUQoQRAlbO5ZpuvAOrLJCMIA3XU4ITCRYtGtUFlKFPVo65L+cEQoBeeHR5wcnWHqjqAMcccBzWcXvPPqm5yeHvPhxx9SFCUPHz5iONrhvXffA6n8dATfiAtkiNOKRIZI6+P5aEE0jnI2I2wmKBkgRci01gSRwOoWZxRRHCAD6ExLXRfsH4xRsiUPU06OjlitpuzuJYxyxyQIUMYhVcXe1QlhVJDkA27ckHz+7kMuphnDZMznDz8jTEOu3bhKnkv2DgYU/ZjVqkKkHq40uDKgsjUnTw5RRuKM9/3Vcc10fsxoZ0Ta8wXdSy+9Qh4rHt9/TBBJ4iBlvlxy+nTKqDcmDiVqPCaQgqZYsGg0o8kuH338GTKImc9LXnrhBcCS5yHL+YLV/OxLPUdMMOfk4ojdvRG7kwMWyylXb05QoeTo8ByChjhW9HsZV68eEEcRUrh1tEiNlJDnCeePnjKdz1iuSgajHTSCYlVwcV5R1xXXbxxwMZuxKKq1aqjAiZZVUbC/v89qtWIy2eHk+Gi9oVn76SR0uiOOE2azKVq3a2iSoqpbPvjgE6q6JU19jriQklBtYJ0FMvDXuOu3rjGZTHj84CFhFHJwsE/VNownQ+5ev45xmoOD6/R7A4QTPH74CKUUo+GIXq9PWSzJ8x7LxZK21ezt9ZleXKCCgGZVsFgsMUZTrFaePmssdVORJBFhFPPg0WOqsmG6KNHW0Bn/NyZRRD9PUVg655/Xqq7pjEERE6URQi7B+KmlCeBgb4csjZhP5xirWVQVg+GYvatXuHfvLoeHT4kfPMIYeHD/MV3XEoUhDm8hW/vJUFLRNhqJ8U1k2+Ev7w6EJMpCXGQYXk/JdzUPzx6TdTGrWlPMNFmYY11IXdZcO+iTJj5J4WxuGO5IagN13VKtGtI85NGjmmIVcvVaghCGuu24fiUhy4YYBIvFkvEoZ7lY0TQKnGRvr0dTFwxGKbuTjOPDBbuT61/qORBIRSCD9fsa455N1ZwQdHQ4JVHCT+2iMCJLM6IwxKYZKrDbCE9gXXRX2E4jnU9+UUKhhCQQErcuioUFZyxGm+3gYZMCE0Uestg0LXkmSbOcWmi6tkXKgLoqeeMrL/PiKze4/8kxctOUDyQOhdYbT7V/XEoFpEn6TK24VtlZa71Em0uDl0tTGOE23y+3U/iNTHyjflRKoY1h1O97Sbo2RPEzCORmz/jcc34J0HYZnLaRWG++7/K67PvePF9KKYyUW3/z5uf4BpyXpjpnUUFAsPZrb8BlGyiav9YoLxO2jjD0pPEoij0YSgjCUGxl9Btf9+b3bQB5lz3ZX1wbmnkYeEq8lyNDXfkYNrdWlV3OQo/X9oQN8X7jHW/qZiuB112HWO/H/cdi6rqmbZu/6uH/pS4hLdYa9g522dkZ0jT3ePrkEYeHT6hWBWsasy927XpaLP0Ef6vd/qk/WDw36X7ued7ayJ9NuS+T660TGLuedsNWXu62/KGf9us2v+N5+8HzXwSXnewbhzmBQgYhSSgp6g6LodOapirQnUPoliwKSJOIpuvQzhGpkFDg/0kfGWyMRQaCKPBDNiEETdPRtSW683VCZyx2rSaRMsAYjWsNXas9R6auWc0N/WhMEkLRai7OT1iuatq2IoxSsjT3fA+j0boDaylLSV0nDHupn37HVwmzHnVraJsOkCzLkmbaoVRA2zmsiEl6LROZELuAKO3TG+9y/uA+0jryKCYMA0QSIYSjM44giqg7Q6LMWrX8zMps10Bthwdy265DJQLhLsXH/ZzWL0Zqvr7RIDYZdniZuBME8lm01OZg3HT9TOfoREdd1XRNQxNAHETgvOesWV88NhJyIQRlWdK1zdrPlG8vgJsL4nA4RAmxvikYsizdypuk9L97Q0Q/OztDSkGvlzMY+HxTGfiLYZxEhHFC02rfWYkjKAvGw5z+YEBZVswWS5S0hFGCwLAIDTiIAsVssaANAvZGQ7CC5WpF3svo9XoEKqSuatquw2qz7r64dYxASNAZYgSZdUjtGKQZg9yj9HEe0uKcwXRebr8qln4zGYaYqsIKQdV1LKuG1srtRUdJCNdxDbrr0JGitY7OruXoZY1DIIOIJOtTlUtGQ7EtuDc0Tim9XFeI53O8/zL/9nYz8oWi+3kC+oYX8Ne/4r7gq9/4Onma8tGHHyGRBHnBjXsDdnZHnM8uWFYV86LmB+9+RJIl9JIJH7//kLPjBS/de5UoD7h69QbDnQFnZ3PKwjKjQRvPCTg8OubKtX2qpqSpLZ99esTywqLrlLoO+OjdpzQyIH2lpreTY11DEEe4FqJRj1tvvIqJLb28Ays5/OAR9mjFN77yFr/1P/wblhcrnHLs3rrKi6/cwSjJyrR0RpNEEbK12FpjW9/lLesp7aoiH/RxmfHetXVOh1x7zTrpEMp7iKRQ6Lqhni6oZguGkzEyTqidprQaVABhSI2FJGBy/Qq6WGIOW+68dovj0zMaJRBdzR//1r+jefU19scTvvOH36VtNa+9+jrf+/67SCcZDcdo4+i08dKi1ufybi6kXtYIuur41td/hf5uxGy6QIUpbi19jcKIbi0lC9dgq2vXrvHyyy/iupKzs1Om0wt0VzMaRiSBYXeYU6/OyDJHlDUkYYehZDiETpe+yOrHDCdjkl4E0vDyq/f43vf/mCtXb/LhR5/xta+/jVQOrEEIw3A4YJSNePr4Mca0XB/3eevrb6CNYu/KBCUidnYnxNLx3rvvUlUFo8kEhOIPf+8PefnlF4hDyc6kj1UwGo04Wp4jOkFIjG4lL915mVE+pi5mzE+mFMsFJyenX+5JojTjScbJSnP49Cnz1RRpcyAgjAMmOyN298YkSUQSR2RpynI55/TsnK5tMM6xWM74wQ+/T5ImZL2cKFCcnl5gtaNc1aRZQpgkXMwWxGnOclkiVcBiudxe9zeTQW28NLRdd/fDNZl8Ojv3EKIoxCFZrEruPzxEG+sVUVFEpzsQgv3xPlEUsSoKjLXs7u4y6I94+vSI8/MZX/3K6+R5yigYevBVHGJRtHXN0sHx8Sknxyf0x0OUlJydnqF1h3WWcrkiDEMOj464WCxYFAVJmtJqTVXV5HlOkmQcnZ7jRIcKQ07OzjDGsiwazuYFCA+IUVLSzzLGwwHLxYxqDbhaFQ1GWFQUslgUSAQ7O8P11KvDWMP5fLqOYYq498ILhHFOlEbM5ktmszn7e3t8/tlD0iQiiEOQktncT+fq1keWxaECaQjjFOca/zeuFW5SCawz3H415/prERerGUE/woiAx4+WZHnfk9Nlx/y848ZXx9y+ucO7733q7xMq4daNA+rZR/T3Mx48FiyLBf2JIssUQrZEQcj0uKSKCla1pDMC4Q5pdEPddQyHghv7V8BmOCtwMmLnSkzdXHypp0Bd19v3n1Gm1/nIQYA2cj2N85GLPuc9p2tblBMoC7hnG/RyviAIA4Z5n0oqjDYEwgOTQqHWEkPnKwBnSOIEkudzvDfKNLlWrUlhyLMBSqasVjP2dm8QhTf5J//rv89/99/8D1yclLRtR6c79Davep0B4cRWIr3xSm+KR/97/hI/sAMpFf1+fyvv3uwjNsXopqDfFONVVW33BRvZ9GZtqOSb2K3NYOeL4LSfZn3bvN0o+La+z/WwZlN4b9QvvV6PLMtYtfVzcWeXwW9KBSgVYI0v1Hy8V7aV/18eNlyefEZRxGCtvijL8i+Uv/oC0BKHISDRukVrKIqKZn38BYFPFdgA3TYKiMv7s01TYrOv3vy3EIKmbdY2iHRLQ/+FL9UihPXlqLJEScS9F1/kxq0bTM/POXp6yPn5GUZrhBM4673AKvBZ5Zv1E4MfKbbT0MvHxgbge1la7qek67fOYS1fkJivjbXuL1Z5+nd++p+5naWLZ0W3XNs75JrzIIVCIjGuoexq6qahrg2h9MwE48BoS5xEoCStArluIIPw8ZOhojXGx8VZswYiOyxrQJ30FHWpPAjO6A5lJFgIowCsh2728xhlY5ywgKaXRrQ6QQYhwmpCKUmThH46RvjeAf08o9fLSeIx/V6ODALOL2Y8enrEqmy4mC7QVjDZ3SNLE6YXS04ePcEEGVkHcZrRH+1wSyjK6pxiekY/zxChYjGbMVuUEEVUrUFKfy8T69pvMxT0sch++In1zSvJ/x8U3kL6DvimAySleI5VsCnYNhfITcQCQBzF3LlzhZu3bhLHCc5YnASjHZ2u2DSTNk/gZpMVxxHxOg4izVLfaXTrx7IhbUs/vQVI0hSArvXyvSAIqKpq2zVNksRLuoMA2xnCKCROEowTFKslq1VB1zVcPdgnikLmiwV5GiMwhOGY+XKF7WXIRIET9OII09TosmQ6XxAKQRhLZCBpW02apHS6IwwjDGvCZaB8BJsDIRTaQioDXGs8tRFQQqIiSX/Q85mayyUy9M/DYrnECkHdak5nK1adw6wzwJ1z/jGE6yix0He26qalbmNOL2acL1asVpWXPYYR1hhS8fyFbPN8CeGLNOvWhbd1z3Qz8Pz7/OR0+2cX3e6nFN2bn/OLL8XfeucrTC8uKC4uuPOiBz8ZsWK0O2S2mnH/4WOuXr/De+99zMnJOd/65jt8dviQP/3O93nl5ducnl7Q0znLecl4Z48P3v0+ocpplxJrBEmeU7U1Dx8/4tU33uDdH3/Mn373z4jzAe9+8DFf/8br7F+/xi/9xt/ggZ5zODtF9SJIIrTQdDEci4JaGSav30TPSzoJYxfx0gu3+P1hQrY/ZHR1n52712gyRas0ca+P6xoiAiLliCNFJBSBkyjtmNcVIpSkoz4qiVi1voMeCIl1BhesbxVhRLEqyXoZqYV2umR5MSMa97FZSJgmWNtilYEgJApCRgdjjh4uMJnixi+9waCrqXTLKMh499t/yJ/83nfY2dvn3r17jEc5jx4+JYlzIhXRtn4SKISkqTuiONqCaLzdAZxQFLMVn7/3Kbt3xuRpj4unp4QiQEhJUzdIGeOc33xdnE9Js5TFfM7p8WOy0FNlrevIEkFdzUj2+9BJej1DHFfgloRhnytXRjj7hPFwjyju4eKQZTknTHvouubunds8fnTI+dER7/3oR1y5us9kd0RRNORpwtMnjyiKJW985TWatsbTWDvuvXCH6dmM1WqBTBPe/vrXOT46pN8f0FnLoD9gNr+gDXym5q0b16mLhm7R8mcf/hk3brxAmKT0ehlmWTOKBzx5/Dm600TdlwvNOXyi2ZlMSNOaNC0Z7aU8fVgQxyMG/QlprLhz+za21TgDg9GY+5/fJ1ABi3rBwbWrfPbZ50RxwNtvv8XZ+QWm61iVNUp6Gdmkl3NxMUN3HVnubUrlcsV4PKZuGlZl4SfUiyU4D5dr2m6tFHTrCVVFp/00suscRdVRN963LJViVVQo6Sn+SZJQVQ1RGBNGKbvjMVjD7Oycm9evMB4PCddSWWktTVthtCHvDTg8OuHh4ydUbU3WZJweHXvoqPRFWdt2RNbi8L68IIpwUlFUNWESEyhFu97gW+e4mM2IwhCzRpd60OV6ooLDGs3Zqfe1B0FEUVSebO8c5xdzsJadYY8kCpjNl1R1Q9PWhLFESdYTVcV4MmJvf4+To6ccPTlkMZ0ThiFXr+zw5OiUsukQUl3azOM9vsaizJogX1q/IfYnIk46HA3WFty5lxIKRSCH3LuTcPXGgIv5MeVMM+zHHD4+ZTVfEiWCl1+4SVlUnDxd8uiTmiBpODu3RIkiiAVfe/ttPvnsPRblknEgmPQmnJwekY0ko0nEsozJiBiMEqrG0rYFcZxDXRAnEdngy5XRlmW5LfiKomA8Hm+njU6A1Kw9jX4gobsWE7U0Vel/gLIgLAKBdV5ZloV+T3J2dEwYBGRRTCgk6I1MWm2nO21dY3DbSae1lsFgwHA4JIqitW1Fkmd9nFVEoaSq5yRZzsuv3uIf/a/+Dv/in/5PHB+vMFbTdZYoCtf3cJ83HATBc1T155Ru7tn9e1NkXp7oPiuyo+3eb7Mf3NjXNsW2EIJer8d4PN4+p5uJ9xcL0+fgZutGwLNmwPNw38vFuFwXLpuBgpJyvV15NunMsmxb7JdlSdH457aqqu3fvnlO/FRb+hij9T51Y8+7PGzafN+m2JXSqwA2f0vTNM/xkC4vb+/w0n3WE1dtNLQtxhrapmU2m5P38u1zutnXbibhm6bCpim02dNZa0E42rbeKn9+Fiz3570upsdkWUYcRkghEdJhjSWMYq5cu85kZ4fVcsnR4SGnp0eUqyUqCr3v+7nn7PmNpJDPe7vdBtq2ebtuumwGh8+K7mcFt3V+4r2BrLkNB+ELW9PLzZXnP/XFL9x8rZ/CrqmMKAFRIAmkPwdbHI21SOmIlCOSrQcv1zVt2xKEIVEgyWOfNuRkwKyocFYThhm6a3HOEicJGIFuvU1QKV+Ee0urxmG39RpAL8vo91OcKcnThJ1BxtlihogTnEroryqWqxIhIEsjoiAkjj1rII4D8iSmqSvCwDcBnO2oVnPK5Zxl4e8drZUcnk19Y1Q7ylpzcnpGT8P+1ZSdnV129/a4OA35fHFOlCbEeUZRlMwuzrBBRxh4pYY1dntNNNZgjD/HfHLYpvEikVjCnzM88BcgNfckuY2+SAqBkn66Cj63Fn8fRlt/kfSGAEPSE9y8s0cvC0migCgM6FpH13jZSBwpdNd44L4U6+gAiKOIKPBZvgaQQYSKUuJkQJLmRKEiiiXONBwfPsJ0HmYmZIBCousOYYXPtxOWOElZLJekeYbVhjTLMMYwn14ghWXQS8BqRoOcpunI15TKSCn6/SG27RDaEgaCwXBEsVrRWYlYb6RmsznKCHSgiIOYstbEQUwoBYFKcGiCxHcjrTEemNY0aF2jYoWwFm0bkCFKxCxXHrTSdA50S5KmnC+XFMaybA1zY2mcxFoIsARS+I55oJCAbg1CKUrdcIzgrDTMSp95bHVHrCS9MOLOwdgT2N2miyz95ks7gkChhJevu03XzrktoXED3XvuUPkZ0q+fKL6Bn9kq/AWuDsFgvMvTR0fMH54zGY64f/8p44lmtSqYTK7x43c/xDnBjatXaeYFtw72GPz6O1y/cYPD00N+9MMP+dbf+BZoy2svvsaff/8Dnp4f8s433+Lx42MG/QmzxTnHx6fcvnuTKE6YL1f0+yk3b434u//wLUyc8/73nhLlCToQWCzKWUIc0hryKCAzhlSF3L5zh+J0Rp4nTK6MCHeG7Lx8h9OmQCtL2M8pXIuVglhJpGuoZetljJ1BNIbVck6c5xSm5vruHqntczGd+hu46ZASEqGwGuowRMcB0e6YFiAOKEPo7+Q0TUMeJBhnOLh9nTRJCUKBFBYiyTRoufuNr3J+dIp7MuPtt77OH8/+hHJe8+TxKXt7kCQZIKiqZt3F3GzuvXzK4mjqiigOQUmcEcyOp9x/93PiYcogGFOfl4QixBp7SVZmUVLw6NEjbt+6CUjGowkBAQ/vf85sesZLN/Zxeo4Tin4/YDjSxOkSq0safc7B3m1GeY+XXnyVtqco6mMMYKylrEp2x7tc2z8gERFRkiERuKYjloqPP/uM61du8PW33mBZzPj4k885uHad6WwFMmR3f8RytuSPvvNH/Nq3fpUkSEnDnOt7u0yXC3Z2dljNZpSLCtEKvv+H3+fmtZu8cv1FqpXm/qMPefnlFzk9eURblygMw16ft15960s9RwbZkIgcRc1iWjKSEbdvH2BMitCGX/3aV8mSkK6EOI5wwqt/dnd3Wa6WICDLc27fvsHewTVGo5xiVaB1gxVgrKCsOoyusUazXLWEoSSMArTRSOmbjqtVSRCEVLVmdb5ib39MsVYCOefBR8ZA2zU4p5kvqzVQCsKNvFAphFQeiHlxgQUG/T5lUSCMZnc84saN69RVRWUt/bwHWMJeQprGvP/hR0yLkqfHx+jWx9MtFzCYjKibilYbgjhmVVbr2BhFGERMF3PqpiFNYqIwpK4bOq3RFpIoZjAc8fjJ4VYNtNlU+k1ywGyxZLmqGA5C4ighkY54TYNu25Ys96CdLM+o25ZISmLlN0ZplrFYzDm+OOfq9Aqzs1OwmjSOSbOU6cWFt11ZizGOKAwIo5CqLDHGX6mt9bJ4sF6Kjs/2DgKHkB15llDNYWHmpJElUJYw6AjDllpb8lFAXVqWq5ZxLDB1TSwcxxeHvPrKLT767IS7L4aURlNXkun8jOOTJfOLkp17Gf3+iLx3zmiY8+RhxXRRsbMXo3WE7hoOboTIcIUMexRlw2g4/lLPAV/cplsPc1VVW4vWYrlkXq68dDnw0+swDJmeestHmqUoBUmcbL3J0sHJ00NUoHCdZlWUjPtDJoMhi8WStqgI1nnNQviIz7iXb33O0+mUruvIsgzrLGEYEyjvP/cZyRKlQowr6Q8U3/rVN2nKhn/9r7/N2ekMKYWfYjsv1xf4iXdZlttCcVPIBkHg4w3XEu/L0900Tdl4i+Mk3Ra8Gx/yZRtbWZZbqNjG/9x1nYeZrQc3l/9tJuIb69tmEn15qvxF+9um0L88DNqoArTVhEqui4b4GXRNa5arFZVun0WbXQK3babg4J+rNE3JMq9stNYym822BW+v10MIsU3gAUiShDzPt4+/qqqtEuDy47fWbG2SYZD6Bl1Tk/f95NoYs22MbPK7R6PRc7Fixhji2OfHT6fT7d/pGSQSZMJyuVgDiZ+nxv+i1oPP7jMcDun3evR7OXEUIbAIJ2haC0jyfp8Xehk3b13n4uyMk6NDlssl1m52jpvs7k3KEjixJsMLWJfP66bRZnq9aW6sC3AncFb4Bsfa222R24IcnnEHxGWJ+/pjUgjWNLj1J9xzX7D9fwHOSaxYk7YFWFdj7QoVjcjDACUjEqFpOketBSsF56uahdbeymtqhsqBspRISguBFXS6pQ4kndU4AWGgqNuWrjUoGXpg33oCLITCEhAlIXpVEgYQK82da2PKlaQqFgz297h2ZZ+yNcxLQ6JiknHK1YMJo2FCURXMVisQhjiPkYFniRhp0MLXavNVyfnFlM5KrIixSFaFt4ylWc5o94DBZIcoyYmTmLyf0jUVq+USow2N6YjiBLsmvkdKkEYJeZgyqwsfMS19zKezFqkUYq2+8nWJt438vBkGv4DCewM38P+57gMBoDbtIOd9UJv63BkPdpGBv9C1XUNdWSQJnXYkSQ8pDE1TeL9PFJGmCV3b0jQ14BAuBiEIgpAwzkjyEeOdq2TZgK4tWSzOqYoFURyj4pCKAiUkVVERBBKpvLQwy3OWRUmS5etpmi+AZ7MZQRCQ5zmLxYKD/V3CKKYoCvr9Hm2jGY/GLJcFw/4Aow2DLEMqhdMR9ZqG2bUdUZpQ1SUXszlZnJFEMa0y6KYjjVOs1uscSLuevCvauqHVHpYTKcFqMSdJU7TRWOeomo5+v4+TgkpbOhGwaErmdUtt7HpT5AhCSRquIyKE9HFknaebI2A1nWNVgYsiOqOpi5JxnjFIUsIw8l6rtV1ASBBSrSU+HsCy9aisPf7+kHC4L3T7LvtmLv/3Zd/V9mM/94P2r7Y67bj/ySPoFCdP5zx2M6zWVCvJqij4pV9+mdFgyd6VXUxZ8/73f8zuZI/XX3uD9z54D43mm++8w+54l3/37d/l5HiOayXHD8+4uDtDBJLT0ylltQJiXnvjgI8+/oCXXr3F1WsDrlzb5bPP7/N73/lz0ldfRPVTKl0DIcI5kjhkPOyzd3uPkycPmS8q6qTDDkL+fP6U8Rt3CHsppIosSDHG0lWaPEvo8DFJoRR0ErR0pEpR1wWd6UgCRZr3KGZLnHGkKiQZ9+iURUk4+/QRSZwz3tmhdhbdGPLdMUk/pbQNr37lDX78ne9SL1bYwJGMXqW+WHAxXRCLAIRgWRacn5/z4fd/SP3hEwZ1xP7uAQdXbnowohB0jfYFs/ONu2dTFYuUwTpipfEJCnifd1u0LB5fQCtZni2pzpaM5GRLkA0jQZbF3H/wOY8fPOCtt94EQAi5Lig62rbg6pWUuIsRoiJNBIM+SFngZIuUFb2epJdElMslJ4uKmZ2zf2XM0ZPH3LtziySMWZolVjtOD48ZT8ZMxiOeHJ1w985d4jhlvpxyePQYqaDrGmbzKXGaM54MSZKQGzdvoYKYi+WSojyjbC1xFqNkSKACRv0JonVcGewwUil7gx3unz9mev8RZrLD//KXfw3T1Tz47FOG/QEH6ZcLlrpz/Q6ffvyAl1+8SiBSPrv/hKoTTKcnfOPNF3jh5hViJWmcJooCmrokyRJ2RgPOp2cUReGlkUKt7xqG8ahPr59xcTEH6SjKkt3dEdPzc9IkxZhmm3ghhWQ1X5FkOWWpOT2dEkchVVWjtUEF/v7R6hrwGcRFWdO2fnrkN+8+xzpOUh9jYjROCNI0oVoVCGcY93sc7O8i8IXmcDCgWC781KsLePT4mMeHp9TWUtYdvSQliCJUGJCuC6AkzVgsVzRdR5rlpElKVTWeeOy8fFxbR6M1SOktVDairOt1geLwE0hvNxIC6q4hiCKsbJgulkyGQ4JAsDcZUZQ1h6sl2qY4oGkq4kgy6veIA4VzPrImDgNUFFBXhY8ITGK6puXsfEqaJyRxTN15KazBkSgvF+608ZE1ynsgu84SygC79jZGecCNO0Pu3DxAhDXz+YpE5ShalDA4OkSscdIh44TTsyWGgHe+dpMHn3+C1jU2Kji42afRNe2q4vTIcvTkR1QV3L0V0WnLdHXCwUGP07MKLSRJHLKYdTRVS5ZLmtrRNCWj4T5dU1EUxZd6DgDbovTFF1/k4uLC58M3Df1+n2HWo6prrHH08mwL/RHCy8wDJ33qgoJEhSRpyu5wTNu2tEXNqlhQr0rUzi57ozGnp2coBE5bTk6O6UJJhtv+vslkwnK5ZLFYeF81gqZpthM/YxxCGkLl1g0hyT/4z3+T0aTHf/P/+Kecny5wW7n5s6n35Wn3X7SCICDLMh+Xtm44bOJlN/f4OI638K/L0vLNVHgjSd8UzJfl/MBPPIbLsvT/b1a0HuZcZgFtJOfTiwtq65NtgHU82PM54V46HtPr9UgSH1G7XC63TRCAwWCwbUT0er1to2UzFd/aEy7R1rd/rzXemiB9w8WtrwF5npIkqY9y08+k7hvFxWVp9WYSvnnsm+K+bVua1iKk3jZOLked/SLXR589YNjvMRz2GQ76jAZ9ellKlsQI5VVtVhukgDgMuHKwx8H+Dov5gqPTM+azOaZrwXlugtEaKbwa1qty18e189nebqNysGI77XZrRYF1XtmzlZlvM7qfZXL/tAGReIZG4Dl4m//FzxpDuPXj8HYOBzhrcF1N1wVEQUaW5cQyIrAdbWCptSNwCmtDjI5otWLYS9gfJxhnebKoacoaJQQG3yRK8xTTtHS1pmtrQKJC3ziKxbp5t86WDwNFEknQjlh09CI4uHHAfDFnNj0n7feo6o6z4zlFYxiORuRJzO3rV+n1M2bLFXVd0bQty8USpQICGVJXLUGUkPf73hJjBTv7eywbx2w5BSmJspzdK9e5fusFZJjQHw4wruPhk8dMZwv6wxHF7IKHT55wfjHF4f3skfJD2M0xjmDNkfGDWsTGae/Wzz8Y9zwz4steP//C+y9YDi+LEcJvajcSD60NSgm61nFyfI4eRjCMcVajjS/uJL4T2utl6y5hQ9u2gN/4FEWFw5HmGWmuONjbQYYBi9k5q/kZbbOia0t6WeybA86ipCIMJA5LU1ZI5acOURhjtMNoR55lOGfJ85y2bZnP59uLYVkUxLGn5PppS4aUkGUZ2mjCNGVVlH7CLD2YrViVhEHAbA6Bkgikpwv3+mAtgQioqxp066nL2hIIQRooEpV464k1ZHmKFRIhHFY4JrsjeoMBRkienM+Yli3zosYKgUQgJQQCklARh77jua6TUWvwStc1GOsljVmvBy1oJQmUIo4jkIHv9AmJddYnLuCzCZ1dx2esL0KXi2frHGwaLZuP/RSo2k/KzLfOl/9ZLNM6rJa896NPGGYThr0+vUHCBx+8T9t2rJZ/xC99820iJQj7fcbDqxwdnpLnR3z8yUP+zt/9TZqi5v0ffcTday/x4P0/YHa+5NreNQbpiK+/8zXe/+Bzvv+9H3D86IyXX7jLr33rG0SJIU1jzo/nfPbBEfOzhpEO6bQgIEBowXA4Zj4cEA9yLmZTamFhmGCjkKUxPF4dEY4SnO7opitE6/jWN77FBx9+jGklcZRiqBHCIFWINhbjJGXTEGc5cZYzGYwJtOWzdz8gHeS88PJLPJ6d0LUVXVPzK7/8a5xVJYum4fjBU2zdUeqWcJCwXMxR1vDmm1+ld21CNUiRrea1mzf4D9/+NnSOSTqgb0J2XMqMiPF4TBIOCWRA1fjpx+YWZdebMWt9ooDR2svetd8kqMDDApGSXjrAac1Ovsvh/YdQd4SZgrU4R0jHhx+9z8fvv8crb7zJa6++Sts0hFKQpAldVxMGliv7MX05wCzPiWNNlgukqOmsRsoW4QqiwPLkyX3KPKSwNXYyJiCkWbUczo6JwwThFDuTA+7cu8N8NaVYNWSp8BLBzkvljbNESUp/MGA8mWBNx8HBPlnYY35Rcnrm/dmtafnKV1/n3t0biDTj8NPPUWXLL3/1a8yOzxnKgL/51ptcz3skccArV68SSMc7L70EDrI0/1LPkTiQjIcJdT3DmYblzBDHFt3UtEXFJBuDdmjdMRgOWS4uyPIY4zSDUR8hA+4/eoySkkAoAiFJk5hXX32Jzz7/HIxlejGn61rve5PSTwisoViuiMLEw2+Mo6pajHFobde5wJKu1QRBSNdqcAq3BuVsbFBCbDKBO5zzxbiQgrzX5/T0FNt1XNndYXdvl7JpSPs9ev0+y6Kgrht2Jz3m8xVn8wWLpqVuOrrOYCJHYzryJOfk9ISmqNjd36OqSjqtGcbRlqgfBiFVXaNUQtN2aGPojPc5VlVNVdVeIidZF2wAlrr1/r6mM7Ta+61WVUUcSKKmAuWl6brtKOslwhn6eUoU+6jLrtXMFgUjJFXXkIQRzcozVOI4RTtF3Xobh8RPizYZs8Z4nkkchRirCQIFxr8OTmrSgWL/lmVVlxweTXn1q33iaIfjRzMmgxFJktA3kOSWplQ8frykbh3nF/Dd7zzk3q1rDF8Y88MfPObR04q9vYjlheHu3T3KpmW5Ety7u0Mvzfns408YDFNOz2oa4+gPJGkSoruKvb19qmpJEEakUY/+lV0ePvzsSz0HLi4u1uwYP/XeULtnsxlJkjDo9Umj2BO+44Tlckm3tpUqB11VU9tum8Ud5YpB3mOu5/TSFDmZgLE8ffiIoijI85zx2KvRhv0BXSQJs4ymaVitVmuw1zNLnXCaOArWha4iCAzaNCyXBZ3uiMIBZT3n9Tde5Dd+41v8v/7p7/D8hG7dEltPlv+yomwjDd943eMo3haRl8FiGz/8Zvq0mZobY7Z7vS/a1Dbri4Xvf+pyPLM0bqS2mwJcCIE1zxJ5NhL6y0spuW0mFEWxLbxXq9X2+VitVtuft6GOSym3U+9Nsb9RBlxuImitqZVEuBAhFMY6oljSH/TJ84w4inCho9PdtnB/RnZ+3vd+mdmzfT6doS5XXhJ8SQ7/i16Tq1c5PzvlfLGgn6UM85zJaMSg12PQ75FlCYHyNotgLR3uOs1oPCDv92nblsV8yvn5OVVREAQhWIux6yhRt7Y/YH3Ra9fQSWe37z+bftttEf7s9V57o9dF988qvuGy2/JnN4M2Vg3/vv+ntfaRhFT0kpQkDhEmpKwbgsC/toG0RCLCIBn0cyajlLLtOFzU1E1FlvSQxCCdH/QZRxc44lBiIoUKxZoJ0ZIEEXEQIhAoZ0mSEGEdUjim5+dEwR6DwYDpYkHTdDRNSxhIbFGwnJ/z+FFAPw/p57e4Mhxhen2OTs+Z1VNOZ+cgApI0o9fPSKKI2zdvMF8WpEnIslxRzs8hzgmilLQ/JBvtMpzskaYxUlhm8xnzsyNMV1M1HadnU4pVTRiFFE0DzhAp0NoRqMC/LliUsCjhX2Nv1fWviTEaa36+VcYvpvAWz94652UdsPakOF+o+Q2D23Y1pQwpi4aTkwuG+QHrspAoCui6GqM7olAhpaJpaqx1ayqm8j62DtIsIY4SnLMsFzO0mbNclFTFBb00QjpDXRZUReGBYqKlbZt1wQ1R4MmVypMFtht9Lz155k0ajUbeS2r8zWS1KsiyHg5LHEcsFksmkzHaQafbtbTRIIVjMMjXMUc+6mi1LEjSGOsMo9GIQAZkvYzlfOF9QOu87n6Wo9sWZx1SBIhAYgREWUaU5wRJgraW6WzJo5MzlnWLFRIVSDIpUHh5eRIHBGsvh7cxrT3wG5mYkGgEWeinqFYqpPNgu6btWBU1/eFg3T0BZ4zP/+OZ3GyznpOKO8vle9NftfD+n9PE+6Mfv8f9T4+5fe1FbAdvvfkVfvD9P+WN116j1xvz+//hP/KH//ZP2L8+YTLa4cP3n5BmOf/tf/s/8tbXvopwPYp5ye9/+3v0+xm6EOTBkN/4tb/NZD/nf/xn/4q3v/42e6MBVb2kH8dYI4hVTErG7/7+92iqiPnTkvP3j7CjEJcptO5osz7D6/vcn53iZEstO2ScEFuLUiEYSZgkREGI7jT1fMnJyRlJlFBaHxHWi3uoTkNlGYQ9EgtnZUeeDQlEiKs1i9MpzbzE4vjzd98l2c3RVYk1hu9//8/Ir10l7fXplgvaw3OQlptvvoiWlltfe4NrL97icHVOi2axXPLx6cdkgxHJhSZaOh5+58csH58wiIeIIMY6S9c1eNlqsN4cPJOGOWcuxeYADqqyIkmTtf9NUi9rrGiJbcjpw0PaRzPqrEKKgLbrODw6oyimvPray/wX/+gfEgYBq+UCGUuu7O9TVQV7e0PyzJI4TddqokwTp2Ct3lJls1TSyyQ1FmcMBztX+eEf/5C33nyd+cWKs5NTrl29yWrVUBRzOiPI+xm93g47u1f4/LNPuHFjl/2DPX74wz9Hd3Dr1l3yPOOD937MJ+99zLW9O/zpd3/M2cmSOI4Z7/T5o9/7HhfHT5jkCdeGQwZhiKgrRFVw895dru5d5asv3EFg0LomVJK6WpKlGXQ/GbPzn7IWxWOu3biGbQXf/u0/R8qY3Z0xL975KuMoJQ1S70G1PtLr6ZM5vX5CUzWo0NNGo1BhjCNLUm7fugHOcOvWXSY7Q6w2/Mff/w6LxQrdWqLIEgQOqaCqGoplS1m3NK1PZpDrKbYxei13DtCdoSzatZTP36SkFP66LNhCd6x1GG0gUFTVCqUUg17GwdUrlFWFUp4ac7FcoNsW4WC6XHBxfsGDJ0d0CJqmJY1T9vb20LZjVZV0TcdkMGC1WKK1IQxC6rJaNwsqnPD+167rqLVGRTFBGNC02mfFWrv+u/zD91Jgub4/BbS6Q0iwTlBUNS4OcErSNe3ao9eRxiFKRqgwRCrFvCjRlVdUKRVgioJ2Tcj2m3ZL22mqpkFKQZYmOOHj2C57KcMgwGlLW3c4qxBKEvcUezcVezct+diwqs9pTMvpPOLRYcViLgizUzq1xCJYTSGPFTuDGCUSnjyaMkxDrt4ROGGwwhLGkoOrEfdeHHB81vLJJ09ZPC3o5TG9XDIZD1itTiEShGGMChwSw3J1Tl0aer0UYUPm8zn3bt/5Us+BOPOSaqzl4vwC3XVMxmOEsTRFyWlVEq0nkEXhp0B+EGY9yX65whhP98U4Hi0WRHHE2dkpndZkeY8ASxinjOKYpmk4Pj3F4TzUSyoiCXkvpShK2rbGWOM30krRVRXLpiGMAuI4YjgcIJ1gPl+ilCDOHOfnJyiZMhwNkEpincRqwK3TAda+fqMtXafXLLh1Ub7xmsG2aNvEeeW5Z2ZIEax5MKC1WZP7PRhOCPVcQdt1HavVCng2wf7ivuFyxvXl9bOK8cvT9o3E/DJXpmkb2k2+r/MwuDhaS7HzHCslVdNgtd/bbXzv/vc5QhkSSEnbNFTFiqZpMLpFaEMShQRJShD5eNckSbl95xY3b93g4ePPefDgPo02Pgc99JJ1GUQ+nUd6KXPXtThncFZhrcLhrVJJnBGFKUEYkUWK1Wrp93fK0/CtNr4B2WmUVNsi3FrrZesb6rkK0Cu9VSb8rOf3573eeOurLBcLTo6OOTs84snxKdOLOXmWMR71GQ5ShoMBvV4GQYBw3mvvhCMIBFJF9PIrXDnYY7lccHZ6zGI292oAtzmWvLwbPDhtM0Tyhbe3oW0GSM6uFbyXJtzP1BX8ROH9PL/op028f3K59Rc75xsJ4F/vRpToNkPFOWkUgTUYHKEyBAYSQlyYkOcpaRrgMARrgHKUeLCjXdPwhXNkSQTOUhmNocMZjZCGOIRRv48UkqqsQYW0jW/YPjqZMa06dvb2MASEQjAcjrhyJafpOqazGW1b8emnn3F8dMjueMRossN0tuR0Oufw5ILOWIajMf2yJBSOKAx58d5dojTHiadcXOS4ZEicpAzGOwx29njl9bcAi3QNq+UF9z/8MWdnZzSrAguEceiZXNZnnzsnqOoKYyVJHCMRKOcL7s4aFI5Aym32u3M/3+P7F5DjvQ6XdxYpxPri4PNDnVgn7Tmx/TrjzBZMYIwliiKyLF/HVeR0xrAqKqzRSFKq0kvxPJFc0DYtUgTUXUPiBG3XIpRgMbugLGvqqkVJTeVqv4GwDqVCgkAhpUMGik4bIuWjY5z1Es8oiBBCEkYhdV1uu48+C9PLuNI0ZVUUhGFAliUsFkv8iWjJ0oRadyjpwQhhnhKFkZ+8SMd4NAAco+EA3VmcdTRdiw0cvUGP8c6Ysiioq5pyucJqjepldJ2HSIVRTJgm9EYjGqM5nc94enLM46NTFqsaqRTZWjoUBD6nMQkCpHQI6XBKYK0AIWlbf4NRSvjYAhXQT9fwm9ww6KXotmFRVCRZxa6xhEp6kY3w0+7nvNw/rQC39rnLzc+6IV72eW8udvZL7GT/pyxbBRw9nPLi9QGHR8f8i3/2r1FKkwQJbTnD1PDg4SN2RgO+8+d/jDYCYwMGgxG6M3zw3kdY3TE7W7K/s0sXaQ7PTvh3v/s73Lh5HTrJ7/72f+A/+4d/h529IZ9++iGL5TlaC7pO8OGfHCKjlPKs5MOj77P74hWGVydcnB5z91tfx4QBTetl1hb/upZPjrGzkkAIZnVHEHiS9CBNWTz9HCEFNgATB4h8QDevyVpJt1xSL2sWp1NUllFVLfPyBL0oQAlcJJjcvcqVr71E21Ycf/KAZlmR3NilLEvi60OUNAgcJR3t4oLF+TkX9Rl3vvkmkQw4bGo+/vAJ9975BmezOY9//AmRkIzjAc4JrBN+84HAKbktMgT+uvJs07CG26gQZwXadAjpG3tSCPIkx9iAk/uHvHr3RT46/QHOtjx5+piLixkH127yzjd/g3e++XUG/ZyqbMBY8qzH+ekJpmsYX+nRy2JCLWiKhig1qK2IQyIAJSw744yjk4rbd1/n4eMThJYII7h57TZPHx/z/vsfE8U5N27c5mI64+Rsys1b15EuZHY+Z2eUo+uWW9fuYm1ISMrZ4Tn9NEeO4ZP3P+RvfPNX+fMffUhZlRzsjPnKy3dQtuXe9QPGYQx1S2gN1/d3SKQFU1IuDVLBeNSn0y1JoogThQq+XKiII8QIyadPTmmF5Z2376C7OUKcc/f6N1FiHfHRteiqwHQteZaybBYI620voYTxYEyaBLx87yaHJ4dcuzEmy+Hh4yeEmWS26GhqxyQJ0dZirKUrLVkUEMcBy1pjjFyb+CzaWWzrASvaCJrG32g3f79X8mw2Ux56GQTOR2TVDRhDP42ZjAdYq1k1JflgwOOjYy/njCJ6WY+z6ZTTZYnF58UrHHfu3EJIWJ0XSGGZjIbeIoRlOOiT9nqUdcPZ+QW17vz3dpqmaegN+nRtt8449hNQ7+1s2Uxb1DrSL5Sh9362HcJYhHUIqcgHffppyqxpUFIShgrddVgnmF4s2d/bRXcdaS9iMhqBNQTGsVwU9HOfr5r3+3SHx8RpwN07N3n8+IiibggQBOs4SgLodIPuwDrpPcyuY7gTMdoDozXXrg25/WIKOO5/2rF/5SpVdU4rl7Sd4fb1m/Rv7fHgwYdkecrj+wVhDEEM84uCF14YcHB9hDGK8/mUjz46ZTlP6aUxSrZY1XLjhavkWU6sJHEGs1nLcBIxGmcYbQlDiW4s8/M5w6HPlf0y16KrydOMWEaYpsO1Hc1syW7aJ7SCNgYbGogUSbYGXrWasqpZLhbIUnB174BaV6yWBUWzIh2k1NQ0NKgop3EdUeojR4kS2rqiaRqGgx5xJCmKKVVd+0mqVGijaeoGIWAnHZElQw/+shGqkiRhRNK7SlVVFLOGxaIgT0OuXrlOv5dRrixVu25EIRgOkzUZXrCYF3SdRUk/qXbOg4vg2UR787br1nGn68GJE4Ku7rZSZ60FVelTaQaDAVEUsVgstvnWXyRQXx6IXN5TbMjmf1lRvrUbrfdKZtO9lQ1+OAKe8Ksou5ZNcyEwCrPU5HmPNE180Sqf0cOxgq4o0V2DaVtiDJF0hLEjkB0oi3YdSRDSz0MCav7JP/kNlu0r/PN/+d/z3T/+iEBOCNIBTSXpake/n9DrhchAIyuHtQ1GS4wWKBeju4a6tKyWBhHXmGSFDP25KZT3hTdNxXgyoZvNSdM+Td1gjPkJEnwUBPT6fTai3F6v92WeIn/lFUUB49GAfp5x5+YNpqdTjp8eMp9OuZheMBx4aOhwOGBvZ0K/l5PEMSBQoUAYizUaIaHXSxn0b1OVFdPpkrPzKUWxoccLrPGvtd9vBtjt/9YycH+TRyDXdu21t3vt7/9pe9rL6s/NsOAvdz+szd08f4zXbUFVp/TzlCxNEcLRdDVOCEQkiaXCBSFSWVxX47qWNJT00ggnPO09CL2l1ptFHEkkiUSAVJK2lbQ1xIGin4bgBIt5S91JutaRxjHLsuJ4NeOsEagwIpWa3WHGiy+NeP31l2i7juOTU+bLgov5jJPpfcInRxRVw+l0Ttm0OBHQyICiKAiwJFFAmuYkeZ8rB3s02rDsFC7LUWHIZO+A/ngH4Qy2XZDEEV3XYI2h61p6eQqJzyCvm27LaXBrK4AU6wSe9bA3cAKUIlqnQUnhyfE/z/ULKbwRnrC6OXy24Ik1jMJLPJ7RGq30X783GnD16oE/OJEslyVNqxEyBAt1rXFuswkJWC1rFosF89kCKRVZnqPbDqNb0lRTrlaEQUgvS1gsF/SCmMF4vL4B1J4SrALiJAMcbdPQ1CVhKJHSEShwVm8pkGmarqXlmn6/7/NRdUsv71HXFeBljWmWgHAo4RgP+pycnCKFz67FWcrSZ88u1zKw1aokyXNWqxVV25DkKaEMGO6OybqOycGOn8LjaJsWh8RYMM4xKysWRcn9x49ZlT4CJAkEYRxghfeIhOvokUhKnDTrPPMYbXzXzyhJpy1SSZI4AiTSWvppirSa3cmExWLOsiwYtEOa1hDmkcfxb9Bnju37m8L7slTcbibf6/V8J/BnSMzXWpsvU0L2n7I+ffcheiX597/1R0xPzghywdfeeY33PviIw89OCYKYe3fuUk6XhMA3f+VbPDl8Sq8X8dqrLzO9OOPw8QPe+aU36HTDL//KbzAvlnz62ad8/MFHvPnmC7z51Td4/bWbfPt3fpfz0xlaO3Yn17l55R6v/Ze/yWw55+z0iLosSPsRu9cnPNk5oYpS5qHPZ5VCE+BQxEzP5/Smhn/wd/42//Kf/yseP7pPPffEbOlg/8aYr//61xiPD/in/90/pzuvMJWBlc/FFEKxu3+VsmtYlOeIUKDShJvfeI1rb7/CiarpIsf4l15EOYE2hsgNufb6TZLGsri44OjkCCcEe719TD9AjiN28x2e5inLEKLdIYO9PXZcjKtb6rIj7g/89M0J7xtdF0gCh3Z2KzP36pl1w8ZarPayvTj3m0DpDz60sXzwpz/if/u/+y/ZiSLeuPsqUZDx+f0ndJ1h72BIZ1rK1YJyWXPzxjWSWPD+Z59SVyuGg1ucn1zQj2uiNGK0q0Es1senv44FwtFLQ1bLUw5/+GOsiwgIeXD/Cb1+n1//jd/kO9/9U3r5iNWq5oP3PmY46POVV9/gu3/wXWbTM9JA8tabX+X+Z0/4wQ8+5Je/9SseHmcdgyjlrVde5/TJMaE2vHH3DtqUrI6f8MLtG/SVYJzEXLt2nVhIrG7puoqT05L9q1cJQ0XVlahAIANJ7TwEcudLPEcePSjIBk9odcWrb1zl00/OePWlm6BbipWXki6XC3w0kSVLIqzuKFdLjNZ0bUO/l9HLE7IkYmcyYlXOSOKQNItBGtJeQDbwoCzbdBih6Jyk6bxEEilotT8+gjWQrVhpHJAmAoOjMRYpFJ3GXwfFxgrlJ2x5nnH3zi0uLs4xRrO/v8fR4VN2xkOKVQEorIHZbEmcxAxGY3avHlB0DWFRIZQkCBR52gNnOTk5o6pKJsMBAoExmp3JmDBJaLTxgDUhCaKIMIw4OzvHrP1/2vrcViklk8kE5xyPnzzx9YHy0lSlFM4YL1GXkiCUdJ1BBYI8z2gaQ91oFsuaYb+HCtYS51Yzmy9QMqKsDE1zQZ7EKCkIJaRJQhAo4jhgMhkilWI2n9LpjnZdyGvdMBxktEZT152/V4kQofy2NenD3o2M86XmsycNP/hgQRhIXrh+HRktCJykLALCIOFH3z3ka1/P6Q8zBkHA/s6I06MzNHPmpyWdhvlK4FzOxQwuzheEcU1vEFG3kt3ru2iriMKMQRZS1V6qvyxanOm4fv0qzjTotgSr0K2mrL/cODEXKoIs8Yo8C/ViRYwijdZTS9XQoal0i21r0jTBShCBRIYB125cJVERp0/PKJoltampXU3VVQwmA1CCIIyQYUCwvg521njSsoDOarTRXuVhjff+JhnWGk6Oj6nciuuTqwwGA5SUtG1H03aEQcDu3gE9bak1OAO9XsbO7oTzs0comeLWoLVN9JQx7XNwMXi+OAZfBG/k41VV0bYtQghGI7MlbfvvfyZjl1Ih5bPC+fJEelMcfjEK6qfFhf2VX7PnCnQHTsE2ZGg9xd+8j8B0DVGiCGPQtiGIBGEkGY/7PHz4iMVyRaAUSRR6dYmDUFjy2OctqySiE4JV2bFczInzkDCU3L1+k//6f/+PuX3vh/z2b/2IYtkwmhxwerKk05pOSyQGYzfyd9+clsLDJVerkouLKa0UuLyg1/cRu8vl0tsRlOLw6CnCCvJ4QL/f3wIAhRDbVBCletthyl/nkl2NEpIoCiAMSOOYg4NdZrMFJ8eHnB4fcf7klOx8ztnFjMGgx854wrDfI0sDwlCulZ0WIdYRbHHIlWt7THbHFEXF4eEx89liS0xnGzDl7+1sJs/+B3mm0YaVtnmgbuP3fn7q/fwQ6q8w7XZrn/elYn3zrZaOol1RNtnarhER+CghlBV0zmGkwBlD05XopiNPItLaMqtLLJIwilBSEQUC4wxxFJElAUkUsliuqAOFcxKF9jatrqF1EikkUZwQRAHHpxfY+Yo4z9CuIwsVpydHTEYZWa+HUmtLVK1ZNoZydr6F0akgIowS2lZT142vMZTg+HzKrKzI+kPGkzFm0dDbnXCwv8ft23fI8x5PHz+gWhz7fVYSosYDlq5lceFjppfLFcK0GB1gRABSEAjlxyLWoYAoCAGDA5TyzZZnSoWf3/q5F94e9LAGD0iHxIMfNjAYoRRSXL7IrX0maxiSlD7zs2ma9WEaMLuYYbqO8WiI0YKzszOiKGJ//4Cq1Pzozz8g62WMdkbcvnkNrWvatiaJA8IgpDMtea+PJQAZ0ctTTs9PKFpNlsZc279OsVpQro4QQhBHAUa3fjJg2IJINnANrTVRFFE3NUkSk/fyNThAUpYrhsMxURSibYfVnsg+mYxYLpdorQkCSZ5nINZkURzGatIsQwUBdVtTNRVIgVxPlrW1NE1DUZaYzjch6qalM4au0yyWK4SUZFmO7lYgWpwQqCgkEIpQKtAWoTbyFS9NcsYTyfUaJAdsO0R7kwlpFJDnGUoJHj46pNWGpuvIifEXIX/1WTcNf4JMvvmZ5lJh/tOAJ3+Z3Pynfe0veo17V+gGS44enZIMhuQjwXRxxq07N1helCyOSx5+9gjdFrz2lZeQxvDk4QN2dkccHz7mg/c+4H/xt3+dKA747p/+EdkoINzpc1QF/OqNV/kn/+Dvcf/zD/j27/wLBtkVbrx+j1de/grOpjy8fwpE7N6Z8OoLt5ieL5mfn9CuCnZ2dniSaDrRYY0mCKGz3rM5PZsRVDCMMmISIpUhJhmuK+nFgv/7/+3/wmC3z3RV8a+XhovDGuvpeMh1Z1cBgVJEkwEiANUPGb14hTLq0IHfFBlpQfp2m8OxomURaUQv5eq9V5DGkQpF6Rpa16BdQ7+fciJAphFpnqLPG9IgAhUikCjzjDy7IcqGa3pve8lz9uwYEQTSgzVSlSAV2A4CFRAkfcqTKW1Z0NmWs7On3Lr2ArduXOfBg4csFzMOruygRIhpDBfnZ+i2QHcNVbkkTRKOnxxSpAvuvpBCcIoKO5+rKQRGG6SwJJEiUCEnx1PCKObWnZvUuuYP/vC7fPNXvsmV6zf4t//y98n7Kb/6rV/jyaNH/Iv//l+QJhFvvvkqeR7w+NPH1AvNr77963z3D/6U1167QRga2qJilPepLxbcGI64MeoxGOzQz+/w2kv3ePLZp4yTmJ1+z5/zgUSFimVVIOOQxnQ8OXxMr5+zt79PUZTEafalniNdZwlCSx6E1AvNajUnTm6SBylB6KnNxWLJcDzAWeNtL06DNYRKUJmWKAzJkxBnfUE3GvRxRpP1cka7I4Y7farW0rWGUEBbaVrr6f6ddggZEMZreaQBYddyc2dRkUQbg5DQGq802uyH/GHvd1RRLOm6miSNGQx2mc8X682Domoabty8TdO2tMby2ksvIwR874c/YrlacrB/jbKq0LIljAKWqyVVVTHo94iiELG+Hx4dHTHZ26OoG08xXksYV0VB02qUYp2vKmmbdp2b7Gga7wfttMZZR9t0SGlom4YkCsj7GcvlCucsw2FOksQgFGXVgpAslhU3b17nYrZEhQGt1mjtpeTOWXRrmYx6ZFlMf9Cn7VrmiwX9/oBWa45OjjFGoEJJmue0XUOaxrgGyqLxzSjr0K1DpYI3v34HOTznybmjWwrmC0G1bBmE5xhnmK80N28kdIVmOBjzwcef8tpXb7C/d533fvwRu/s9Bv2YN9+6xw9++CEmMMwulgSBJs8dQmgWM83oIOSzz045iwWf68dc2RlxerrkdF6BMYQ7AV2jsFqSpfGWJNzL+1/qOSCSEJGEuDjEWofspwgZQBQhggBTtWjt45+0MYQuBiURYUCAYL5a4tIeUZoQ9iNUonDKcjw99mkwxpBmIXVdbwvPTTFaFgXWdSD8FHND05ZSsru7y2g4ItCKfpQTxz5yZ/P9dV1zNr1gWZZUdY0zAXu7N/na177C08enVIVBKkkv95Tu09PTLWX8L6NebwrbDel8cz3feId/MpdbrRsHdht5tVEdGmO2xf4GGPafujaE8mcP2HtDL30AxOXCvCWMLEXbkKYZr732Ku+8803Oz8/56PMPkAF0rSZNPNhMGkkgDL1e7lUJvQwtFfG84OjsnGLNC5LSx8f96q9+k7bt829/+w9ZLM5JEn+eta1AWY3u/GReSolUIYEKsXVN2/prCc5byjZkfWMMZVmSpinWWpbzJU2h19J+D93K83zrJa/rmiD6i9zIv5jVLedEcYKKIpAKEfribTfeZbgz4vqtW5yfn/P08WOOzqZczBecTxcM+zmTQcRo2KOX5cRRAMKX0zJQGGcJQhgOc4bDlyiKmuOjUy4uZiyWFU4oEAqpPHRNbF97u93vus2tw7n13tatFVbAX7DX/Vnr+b3vs49vWViio2xLVnVFGvcJZLi2ImickXTaq5iE8ElScRiQiYAobFFGkqc9lIqoq84fzs6ikKQ4UmdwSpDEIa31DeymqVFCE5qKOFTkKqQ/yAlcQ9Vphr2E3eEBSeAIlKRtSpzrmJ5fsJgvaVuHbSVpmK+Puw3rIcA5uKCkaFvCGJR2LKcz1LJkMJmwMxmzf/0Kw15O11Q4a8jSmNV5w3J2QVsVKKcZ5jGB7pFEEcIauqZGYP3+0Dmkkh60a3yjJJTKhzPgUFLSWa9Qdj/nI/3nXnjfG424mM/ohA+7bzpNoQ0FvuBT1iFYb3jAe1OUn8Yu65qj8znG5FTLGZPRGK0bPvvsIdp03Lh5nbbRHB0doVTI6OmU84szTs4W7DrDYr6gmAzo2nWcEBITeTn5pN8DC8vpGV2TYx20VrE73Ccb7fuc7HRBWxnatmJVFmgHy0WBWXdXN5v+pvEXNykkQRgQSEWwjmqJ48jncpoQgS+se3lOFIcEpUTK0OcRrpu7xhj29ncpynLtMTQIIambmqL0nZzFaklnvBStqiua2mLNBvThfe9hENA0LVEUECrfnVNB4IPinY+SscZ360Kp6NYTH7fxfkmHkutcUWsw2jAZjxkM+ixXK1Qg0Thaq2naFqcNcn0F2nIJrNuCJ5y1XvmwNiLaS4X4TxTSm7duE+XgnnufS5//61zVckldLRnu9zi4NeZbv/Ea+cChUERS8Gf//iNmJwVJqPjk/UeoIOHq7hWOTp5y/9PPSJMMq8EGcHax4Mcfvss7f+uXeSl6hT/6rT/gB9/7gF6e8rWv/CZJuM/O4BqffPIpVXnG3bsv0zQtf/idb/PJgw+ZzTuoSopuRvDShNt/95eQOBIHQnvFiHMS0zmsCvjeB+8ya2tMlNDr90iVRTTnHB4/Ih7e5vj0kL3ru8xPVz7qSoaIzlAXFfPZFJIQLQxBGtIlEjmIKF2NCiTSaO8JswYZCITVPt7PauIoxhqDDmG1Bi4p2+JsRz9PkMbiuo6s18OcV1RN7WOKjCAIEsBghVhHh5l1RqoiCAAunwO+wJJI2q7DSeEjmtaXVCElZVHy9OEj8nGMo+Phg88IoyHGdAxSX6CcHJ6zWtREgWI0SCnLgqYuWS4WXNvP2ZnkaHNOGBuEasF4IVoUpnSdIQoVg3xAXS+I04zP7n/KrXvXGe8NOZues7d3leFkyNnpGVmSEqLIg4TxYMTRo2O++sYLzJcLukLz/oMPefzJEwJTcrCf0k8SogQOhhNC13FrMuTgyohBP8CuZrzxwl1SFROpCK0tYRThFERZytHFGdP5lOOTQ+IkIchzoiRj0dZ/4TH//+l6641f5tPHf0I+TFG9jBdfTgnjFtP5oly4HElJU5W0TQtYymIFWMIgRDiLwIHT1FWL6Rof1yg8fG5nPGB/f0yWJJxlF3R1yepxhasFkYJEggoVjTUYJXBCgPaRblEiEdJSrar1Nsmtp9y+8hYbeVoAQlgW5Zw873Mxm4FQxFmP2apkb2eXvYMr/M6/+zZXr13lypWrfH7/c6QKGAzGPHj4gHK1IlZ+4lJUxTYRI1KCGzducHpySt14GruxluWqRAYRtukIoxgVegXVxmvuHFy9epXjk9M18O0ZFdozDnyDKs8zNlTaJIkZDHLSLKWsW5z00mBnHIdHJz4iCrMunvx1PAoDBpMRTetzzJ2AuvGe+fPpU7I8pdWAEKS5b9rUdUeUdOjOXFKfOKQMSWLo9SQ3X3qJh0++R1FUHAyH6GQFxhFHGffuSqxZ0hrBcJSS9jPGwx2clly7eovZbMb8IuTw6WPmi4I03+WwnNK1lkAJnFNkiWB1UbM76fPKvTEXT5Ys5yuskOSDgMI0OBRlWXH71phebpjs+HO/rL7cc0AFAcY5yqZGdx2BVDjlO5haWkrTYYwGCVIFmLVnWgSeKTO/WJGlGdmgT2NrlvWSKAuwEpbFkn7uoYIbaFccx9h1Y75tW2aLM7RuttC1TdEbRRGj4ZAsy+kqzfziHOcccRQTxREukMzmc5arFVIqyqpEm4rbt6+xtz/h/meHKBXQ62fEcbQtpJ9NrJ+tL/qvN9FmG7p2kiTbzOjL0VfGGKIoQK6nzZdBYF/8eRso2E8rbr44Df/i5764nm/wC4QLcE7hAYsW38HzUlUhHSLWpP2AyXiXb/zSN/jWL3+L6zeuc3Jywr/+nX/F+dGKNPUJAFEU4Vrr85jXpPO0n+OimCDKqDpN0o9pu5agtfT7fVpt+Tt/91eZzVb80//nv6Wf7xMGKV0nsQ6c2URjCZSUa4WAn9JGYchoNGKJVxb0+30GgwGLxQLnHKPRiMV0gZSS1Wq1jRDbUPCttSxXC8bjHs/rFH/x6+z4kCzLyXo9wjhBhSGBUjgpUVFANBrS7/e4crDPbH7ByfEJpyenXMznnCSK0XDAsN9nPOgx7PdIwhAZKAJpkcL4rGccvTwhf+E2N29e5/xizuHxlNl8vh4gejCdRxcoH7vl7Hpv6/DZDmtAm8BbE9Zr09xz62J8W5f/jPWTW1yLh4N5Q5uzhrbxwLReqojDEOsUtrO+4WYsQagIwhRCUGVLIAyjPCPtD5gtKpq2xmpNHDpyGZAIQWANg1iiI0FjfH62iALaOCQQljgSpIGjnwSEuwOmiyVXdnq8/OJdn8ddLWk7S60101XD2aJkVbYYben3BwSDFN015KmPiQZHGHuOicKxO9mhqCrmZYXWsDsYMOrnFMsLPvv4fcIoQawb9I8ePGS5WJIoB13LoJ/TlCXOtsSxAhnQaRBCg/PnnSfG+71FoAxOKG9vdt7Hr37Ox/nPvfB+e5By2C4wMiDKYx5etDyylmXgp2ehdYh1Nt6mW2SFo2w72s7SfXSfcS/Ftg2DbIHWhvPzKVY4lq2jaQ1N1eGoOJ03VE1BHCdcvX6V4XBIsVzRyxOKVcnx6RkH125w7eo1mqqBrqarSkxbsOwEyJTR/k3iwQ5RVWBMh8DQ7/cI05SziwWN9rTELMsYDAbbG90mmzOOY4z2ko35bMZkMiFNU8qy9B4ow1bi48FrCw4ODtDrzZQ2HU1TEwSKKAqpqwoZhEgJznYIAuJAgenoxyGiawliSdv5vD1r9Zbm6ALvMyWI0MYQqOjZjUtKjHBrOJu/IARr7L6UEhlIv0mVila31E3D2eyc/f19pJScnJ7ROEtjNU1TETD01HXcGhP3BXn45QL7C9PvzdoW2Jc9WzyjRm7BbPxk0f3XUYRrrWnagnmx4O2/dZvJFYljSRb2+drX7/FH3/5TnDGsSknVtHz00ecEia/Nfu1v/C3KVcW/+pe/x1e/fo+/+evvkE0y0jjjT//oPQ4fLvi++5z/4h/+Y4qFZTS4y3t//ill1fHqK69xcnLGt7/92zw5/phFNWOxsISdobQFV756jTaUGF0TOeUbKsJv6JNeAjbgu+/+GKKcfK+H0TWdKT15cphx+/ZN/uhPv8/jo6dkuzvIIKTtDEEeMOx53kI26DOIoA1bGAe4yHvVAouXNlU1YS9BWIdyAlNUhPjPiTjERYqWlihwNEVN0BMEKsBqw9MfvM8w8jfPV+68QJ72mV+sqFY1J9NTyqZYb/BArqPHEArnWozp/IZIKqxxPn6jsVi9lowZjWk7sjVsZFrN2Hv5VdrKkKiAri0JI0V/PcFZ1R29QZ+dwYjlfEpVtyRZwrAXMBoIQlmRJYosVR5UJgNQAmtbVOCLoPHOhFt3JTfvXef84oiyXJLlPVKVkIQZX/vGWzz4/D4/+MH3iazj2v4B+7sTDg8fMj264OmjE6TLefTxE37j7V/hl955lX5uySIIXMCt37yNNC3Yll4vYXpxjMYQObm+izjCSKGt9p3fOMRKuPvCPYyz1F2LFpJHh095fHrCL/2NL+8c2dkZ8umDGKFTpPCRb4KEriu4em/EqjghSb0Psu1q0txT1cMgWOexO4SwOGfQuqWqVzjbMRiOiboWY2K+8dVXOT0557AXoFVFvrPgwadTVCOJpSWMUsrWsapXdNZi7Tr6qLMslwXGeHuC56oJBAqEnxgqCUHgm6u7e7tYB7v7B1RVQ3V2jhGKbDTks4f3iRMPW/r93/99wiBkdj7DOMtysUJJSNKYxXJJGAYcXDkAZxn0h5yenJKmGUVZESlF0/jixU9AvbUqDCOsNT7RQxmiOPI8kShaS3XXVgvh/xYwxGlEnCSslh5EFUYBKvRAndl8ThzHFKvS+2aXK5SSZEmEMS0CiOOAvJevqeWGOPRyPRlETE882KuzFqECpFT0+n2qqsZaWC4L2tZ4WrCUOGlx0hLlMC9mqCeCeqXp9yJGmeTe6/e4OJuCU9y7cZv54ozTbsGwl3D9xi6mdQjlSMKQTz5+zMlhSRKF3HwhY3pRMRgMqJuK2UVBlgUkaYiSQ+69cMDi4pDFcsWt2y9iheOPf/ARSRLSH8ZkA8HkQNHLFdPpMRfnS9qu/fJOAEAvK5wIkEmCQrAqC7I8xwUebpUNetRVuVXS1bolSRJ/3TWaxnn2x2hniJaW4c4YLTr03EGgGI5GtK1XQGwmmE3TbIvrF+69wHR2xsXFBU3TEMe+2Msyn9/edC1ZntM5y8XFBedzH5W6M5kgAkUYKS7Oz8nzMaNRj3sv3mEwzJHKkecx1uqt6k9rzWAw+Ik4r80EfvPxaJ2cUtf1duq9Kbg3RPOiKBBCcOfOLVbFirZtt8Cvy1TtDQgW2E7B1Rc8mpvft/ncZqK9ybDWWv8FewgPqTPGg5fCSIFwaNMghCZKAoY7Pd76+sv8yq/8Kq+88gqHh08pujOu353w2ls3+I+n71KXNf1eRpZlNE6DNmjdrS28/m8YDhPKpsVITVmUjA4GnM1XBLGH7H7t66/wH373O5ydzIgjv9tK05g4kNtrgDEdUtt1A2bF6dkZL331Gp1JkIHY5nNv4pWklLz44ouEIuHk+MTHFK6VA6uVh0gOh0McGrN+fv+64Gq681L8uiqJ45i81yOJY5QKkEGEkwGBgiCPyfMr7O7tsFhe5+x8ytHhCQ+PF2TzmiycM+zn7IxGTIZDhv0AKVhznwx2LUWPEsu162MOruxRlBVPnh5xcnpOK9YcKusINuwqLNZqlJA44dbydHgWVrUlDHp5unNYxXMygucGS9v/27BGeG60rpxA4taK3hU2DjCtwRpH17SYVoPWGC1wSmHXCQH9LCQkoK5KFvMZbWvJIskoDphkAWkaogL/2FttqGpNJmOETAis4LSoiBNP6JcCJqMhCssgEgxi46MuG8HDx8dcFC1n85LpqkIbSxaFdBiOZxd0bcvOZAAI4kBwddKjKWuKZUHoHK7TdFVDoQoW8znjvYLKNJSd5WxnjLOO46dPmE5nnJ9dkEjHIAtRAcxmMzrdIhUQhBjdYawlEBbpPE8lUAKcQSoDStKumype5Pb/43C1VwYB16MhtdEUwt9o5u2S2hpat7b0f6GoMsbQWIsVjoIK09QkSmCazueBGouQiuWypmk6n2UdhdRNiVLwwkt3ee3VF5DSZ2U3dcX52RkHBwf0+31msymhcAjTcXpyRNYbkgx2uHHtKv08o1otMbojCEKWq46yquiPJ8RJTJpE1GXpJfTOU2fruiZN020ntm3braRnE8nQti1N9yyHsq7rrWRWKYVUkjgy5FnOaDji/PwcGYZ0bUe/18dYSxgEZGnmoyusB5OkSUJoQdYdgVIYbVBByAZoYq1BBiG2Njhr1h689ftKoIRESYlpGqzzsiZtvZTLOg+/23SUV6sV4/GY0WjE+YWns3ZtS9s0GLvpJOEVNvCcH/unyc1/lmz8i9Ptn+r1/hnf/4tcL774EqumJhjAletjwkTRVILHDx5zfXSLv//3fpl/+c/+kMY5VBxRdQ2/9mvv8OFHH3D/0WPisEecZ3z+8HNe+9qvkPYynn78lD///U94/d7L/L3f/EfYIualG3f5zp/8GbNizte+/jZPj4757X/zWzx6+jmr7pSqLegWjrYDlyvSK/vY0J9rXQ3T2QyRCJJIYWyJJQdChAhAtAyGjtfvvswbL1wHpzk7PKeeLbm6f8DFmSFUChEoTBCD1ggraRqNM5ZOlwS5oisWjPOcq3tjWmO5P7ugFRCEMabWHmjiHHEU0uIw1qCEzx8VyiG0xRjLjas3+fWv/wrvvP0OL9y5S1k11FWHbQRZ0ud0esLnDz/hk08+4eOPPqFtDVGQ4oTBCa8Q8Tc9371EGAICylWFkQEyVJhOUxdLjLB8dvSUG7/8VWbzlrHq2B0OGKqUoijQxhDnCVkvoSiWhEEKYYoKJXu7EVFySpYassgRrLPIjLNYIXyWN5rOalZVwYuv36XQcyb7OTeCCatpxcFwn9/5N3/Ah598yksv3eSDP/+Av/+bv8HV0R6mLpkkPQbBkE+nj/nWN75JWEfU5zMevfsJr796k+v3DpDUiOaYLO2BFUhtOJhc8U003eKc3lp7VBAQyhARhly7dhWM5fUXX6Fqao6mcx4eH1GIL/eG8/0/+fc4I6lXmtEwZ388ZDjoUznN0clnnA1vcGV0m+lqQZYPaNvGS061JloDjqTwcZEeoNnhnFfXpFFIHSv6SUDv+hX6WUThFtx77SY7Bw94+PEhurAs5wu0Vjjtr1EyEDQttK0gWKuWhG0Q1iLWGyjcpSxWJ0iSPnXVEqWpz6cOIuLEN1RPTk9xRvPKyy/z9Mljzs/OuXXrFjvjCWfn5ygl6fdStO5QUnp6PII0zdDWb2IXqxXW+aactfiiOk5omhZjO9q2JQjkmrDupX9nZ+fEcUy/P6AsCkDQ7w+2NicEdNpQVQ1Z5v12xkJRViyWq3WR7mjbDich72VY3a2ZJoIojRiPB+AsRkNZV0xnC5QKaY0hXoPdtPEk+byX07QNxjm6xkNSPW3dq9jCVHL1ToiTlgePnhCliiCIWM4tF2dTdnd77PQn7I32qGcrdkYdr7x0j/OzKZ++/4TRXkYnLHfu7DMeVLQVOFMyPVvhXMDB9R5JrKiqjv29EePekOnRzMvgVch0VXD/0TG9UcBiZmmbDlRJ1RgWqxrbJYwnY0Tw5Z4DuZVErcWZ2tOxWx/NFmQZMgrRtiVMYjprmK4jxqwUHkYrBb3REGkcle5oTIXKQ9J+j0EzZlnMkUpSls9k5hsw2d7eHlmWYWxDr59y9epVVqsVQgjm8zlt2zIYDJCEJL0eMgpxyhehT588RRUrH3W6mhPGiovpKQ8efMa9u2/wzW9+nc8+eYA2LWkabSdzm3v75cJsU/B+8f6/+dzm7abxsMn4Xq1WJEmCMb4hoHX3nLR8M+Huuo44jrc/xzm3jRvbrJ+AtF7yhP+0+K/LyzkPCQzDiCAER41UmkYvGQwTfumd1/jK2y/ya7/+TeI4pm1bhvsJeaYgbPjlv/kmf/qH71OsfGStFJIojJCBL/ytsz6Gr+swG9YRgqIoWMz9Y1ABBJHmxs09vvrmK/zev/8R1nboTtEqn1KTBAqhQiTx2oPcIYDz83M6rUmzlMXKv+5RFLFarYiiyDMhQk9gT5Jk+68oim1hbo2hKr1d5S8C1P2811bV07Y+5WG9906ThCjNkOtUBiW8OicMYGcyYNDPuXHtCudnFxwdPmW5WlGUK6bzBf1+j51hzGgYMxwMiKKAQHh1nDUWKQ1hIImilOHgLi+/fJfD4zMePz6kKEqwBiesH2CtaxqxttQ6Z7cpTuISs8Bt3/cKuUt/Id5L7inmlzkH209vl1unvPjnoYkaQgWms+iu23ryu7bFrIdoWRSzOxqx6hxHZ1MiLGEkGGYRwzQkDSBwFmkFWnfYtiNEEYWKKIqpkohCdzir6eqGrlYM85SrB3sESlGVJf1hn16eo2ZLVssFq2WBMdDLcvp5hnGG5XyJVIq2aYgV1Nowtx26bQFJUa0oq4JVsaBZTZmvFlihSIZ7hD04O3pM17Y8efA55XKBwCeGFM7QrP3o2PXQae3pxvrmrX/2HVEUghBop3DGDwtD6YvuwD3fOPyy18+98N6hZhhAJUOmMqCcxNxfdQSrxgsy1k2hy/Ik59Ybc+k3sp22BAQE0tFpgzHeS2ys96IFgaSqS4TQDPKU/f0dXzh2Dc45BoMBQRQiQy/ficIQiWM6PadqWvojRde1VMUCqyvauubi3Ev/iqomDAMQkuFw6D0D68d62c+0oWD67DtNVVX0+33yPN96kk7OzphMJtvvBUjTlCRJWCxWGN2i2wacJY0jmrYliUKc80AUJRVpktC1DUb7+AeBQGiDjR1h6OXtAuGfFyVotEaKiDDwMDYpQAoIA4W1grauCdOUIPRTCyGhqz310VkH8nnP2Hw9Kblx/TqVNmCs37zpjigIWLMn1r6Xn14gf1Eqdvnj2wbMJSL6T/N2/6xi/Be5anvG29+4iws7ZNRR646z0xWPPnzCi7/+Cv/4v/rPeO/9R3zww0coJXn5lVeRBJw9nSGupRzcvcWn9cdkWUg/G/Do4SNkMGJ3vM8//sf/FZGKuTLc5/HDT2m6GW//ypucnZ/yP337X3F8+BgpKv7r/8N/TtBX/OCPPuD977/HUhtGeUAuNGEvQCUhO8N9XFuS1DXj2zc4+fSEYS+hWFWIoOH/+n/+P/HuD77Pk6efcRFGXLt+h/2DffL+A05Oz3CdRISxl9wmCZKALEpRyqBx3Ly1xzuvvsTuKKIqZhwVBcerpd9QhAKjQmTWp54X9NIcZw0SzxmwpkbQUp4tePXOy/wf/9b/hjuTayRhwMnpCcuypN8bgRI8fnSfw+PHyBDu3r7Jwe4u3/v+j1guFt6DHqzlXXjIlIocddehnGExn9E0NUmaUVtDNOxz65U32Hv1GsdlQbE8Z3L1Dmnep5iW0DmyrIcJ/EQkSmJc52EkURwRKBgMJDu7AWFcorvWsyCsF4EhIqyVlFWNJUbYlkEeYwzYzhd3WZpw88o+Z0dH7KYjvvHam7x693X+/W//Lju9DKFrPnn6Ia/euc0gdfzd3/gajx58xsnTT2hv9Dg/clw92KWf5QSB9ERj5+h0izagdUsUeymXdhIDKBVSVzUS6adv8wVpL6eYLihnC0rx5d5wskhxffc2RWVoqwvy3QSlGqJQ8srLrzLoDwnDkCxLSdOEi9li7fkMCMOQXq+PM4Ys61GWK1YLv1lczmekvZRIObJE0c+GHBzsctaecFx+zovvpLz49gtMj5d89O4Ry6ljdhjSrrwiojMC4zxkTwJKhljrKc9y3UC0WxWSXfu9JWHgi4woihiPJ5yffcTsXHD39m0CYcF05GmMsz5DO00TLA5rWpq6od/vkcQJi8UCKYZcnM3J04Qwjmi1JnIelCWEoqlbulZ7Hsb6mqm1pmladGsIAh+3Np/NsMaihNz60sMwQGvDYrGi6TShdVgnWSxLAhWSpRlnZ+cIIeg6L0MXUqCNxmGJ4phBPyNNQh9B1fmJ4HxR0R/4TXrTtQRKobVZ39O8CsXzTzzoEOmpv0Y7lNPceXGPG3d3OJ1VBIsF81lBtTIsVhFRqsGu6NoTirpAJpqn558zO19RtjWZUZzP53RdQFlU7O2NmC3PyfsCIQ3lqsS0EUkCearoZZJbX7vNdH7C/5u6P3uyLMnv+8CPu5/97vfGnnvWvnX1DnQ3iQZBABIXQMOhUSJlks3IbF6kp3kYMz3Ow8hsHuZPmAdpxkYbNSJFitKIFNYmgG703l1dS1Zm5Z4Z293v2c9x93nwG1HVQBMkNdXA6JhVZ0Z0RGRE3ON+/Pf7fb+fr5dYzhdT9q/7NE1NFMD+QZ8oKtk/6JNvEtoqQXmggvbPvqn/Na+9oENTaxbrOefLOV4ngqRDLDzCKGa6yTFW01rHxWh0S5O3KKWIw4ir166RrtbM13P64xFhN3K+RCVIel2U77mDd1URBC4CtdNxSgWt3fQuzTas1y6SNEkSJpMJz58/5/j4mMl4H7s9CpZ1DQI2ZU7eVAz6fdIspRsFdDoxZZUDhjffeo3Jzu9xerK4nI598vrkxPuicX9R5P5JpdvF21VVIaWk1+tdvj+KItLUfe9Suqmw7/vEcYznORLybDa7nHRf/PlJj/kFj+eTILaLwhv+Fc8OoqZuCqywxB3F7n6X2y+8zOc+/zqvvf4iNtTIsOV8OaXT7RB1JX4Mvm956wuv8vbnXuc7v3OHTZoy6HUIlES04jLPu7Ya4xXUDaRliVWG5XLJ6MBHxQptGubnTxByyIsv3eB3fut7KHEx+begQYYKT0qECtzaEy7x4/j4mM16Teibyz3kk42Li2xyKbzLe+ZicBQEgWtutA113SDEx1nlfxGX3JKvLs99xpBuNuRZRhBlBHFIFMf4gY+QWz+vtSShIvQk3at7XD3a43w2Zzqdc3Y+ZXWeM11CLwmcF3w4YG8yphuHBJ6HEHbLHXF+cE94XD/a5drhPqvVmiePn7JcLKnKZqucklvllMCgsWxfo58qorc0tou/X17bnHBnHf9Egf7Tl8CB9LDbQWVdUVYVInRncCkkvvJBSoRwjQqhNcpAJBSN0MRK0g8USkkGiU8vkEhTIRqBR+AiMdvGeceVj2hKYk8wTALKuqKuNdK06Kak2xmQxDH+NtFiOBxwywtorcRwRmMF+/sHJGHI2WxGlqUIcLYyXRF4gjjsk3Q7WxinJGp9DqIJWVmx2hQ8evARMjxFhj1mZ6f4vs/x0yccP3lEWZQI3WAbSyf0CIMYYyra1qBbN/lX0mV1Y+z2vjBoC1oqpBAEQqCsJpSWzr+EUfH/6/VzL7xDAVILqsayriue5BWr2tJwQWr42Q8517ETWCu3cmMne2hbfXkokpKtbKgFNF7gJrzzxZz9YRdfwmq5IvCcFEtaEF5AY2rO51OyzcpJrrpdvDDBE4bF+TFWG4oixQ8Dok6C5ym38TQNwthtjqnb5C88Su57FuR5Tp7n+L5/+fDLsgy5JTFfUNDjOGa1WhEEAXme07Q1WE2vl+B7Dnam24pOx1FwpXCB9UGgiOOQosgYDgZUdc06zfB859lWwmW3NrUDtVjjvOVWa/wtKGMbRrj1AsnLzm/btgjlX4bMW+s6Z0q52Bpg+wCU7O3vc7i3z2o5d5E11uCLrYr8X6MgFj+rwOani/WLbvUnrz9ZdP9FFN5XbnfpJzGPnj5mvjAk4zFFFvOT753gV9/ni1+DX/jlX+D+B1PKrMUTIVXRcvX6dQ72jnj68DG3bl7DDyre+/Edwijie9//Ln/l6/8Wne4EWbds1hvef/8nvPq516nbgt/63f+Zp48fsTo74+/973+Dv/prv8idZ+/z9177Tar03+Af/pN/yq3DMfEg4eFsTmEUXpCwmZ9yozvg5Tdf5e//4AO87pA3XrjKcnVO4hmqLMOTPm1t+aM/+DZ37t3jl776Fa4dPSMg4sGDJ5ytU/KypGo0lV7iBxrpV3zprV/icy9cZXb8gFuH+yRaEnghH8yWaDwqGaBEyCrLmT9+jhp1qSKF8RXjTkAzy3jt1Tf5/NW32LF9bNFyfjZjtpyyc7CPpyRPnz5jejZjMT9DegIpFEnc5TNvvs43v/XHCKlACJT08ISLxgtDD097mKIgna9QbUvQAZTi9s1bJDs9irJhfv+Y+clzbiYTZlWA13qEXoQnfYIwIPQ8yiqn3xtsDyM+Jycn3Nxr0Vg8SqxocZKwAKNBBTG1CTDSZ7FcUNWaV1+/zZOTKVXdMugO+eijO0hTcnt/l/OPHtPvjPjhH/6QdJry5rXbvHj9kJ3JgJu3rtLUG6JI8aXPHnF2/ALj0Zg4iAlVQKACapNjcF135z0EpKZsauabHD+OUUFMWmR4Xsj09JzhYEhnZ8z5Ys5qy7HojPqf6hqJvS6DTpf93QFPn7VUmWbY7dIb7YAJ6SQ9pBXotiHNUlbrFZ4fbCf0DhIUdXokcYd0s0EKtY2SBIHBU1CXGTZO0BgenTykjE6JdlyaRYDhdjLB1gHzp4J6LTl5ckKwhMWioiwMtrEf218QWCuw4uPMb+edlIwGI/rDIVXTkOUFH939iEAJrh8ecvPqER9+8D5tXbG7u0MQRdy973zenudxNpvSTSLqqqWu1gCkaU4ceHhKkvQHiMZyejYlzXLkVrHg+x5NWbmf1hhWy/VlTnK9nfoA20lbtVUGSFptaZuWttUYC1XVkG5ymqalaVKsdZnLF/um1gbdGox2z49up4fRlqqq8Tz3PKnrFotrJnV7XYq6xPM9QgtNU7Nczmka9zxXUiCkQConfZdS0DaGplLESYja5AxHCVevjDh5vCRWIVnRMJtPGQ884q5HIU549uiUg4OrjG506fYjztdzDg6ukWWn7Oxphjv7nJ4vaWqPxSLj5q09losFi8WSKs8p2hkyqBjtw/hqhDEhH743Y/dKxPWrQzbrKZtlTlv5KKuwlNTm0/V4jwcDpKfoD3qMdka0AoJuQl3kLFcLKtVQ1CVg6fZ6ZHlOWZYEgU8YRjx89ohe3EF4grPzM+wC8irl2fFTRuMh8bUudbOVAFtLksQYq1mul6yWC5JuiFLOxlbkBWVZsFwsXDM+DCjLAmOdoi4IAzabzSVcLQwCdnYnLKanWFNy/eoufghJN2K8M+L0dOkiTf2LWCSDMRpjPi683ZS6QSpHFBbCeWFd4bGlK1gXBRQEIdYK2lbT6XRIkojVern9/gLCOMD3FXEccXCwRxgFbNZrHjx4QFWWVHXtvO1V/XGhrcHorUrXOHud1fYSougYWB/Led2a+DiSTAiL9DVCNty8ecSXf/GzvP25lxmOYrzA0urUretZQRAENE3JvXsf0ekk9PsD0k3GZ95+nXe+9ZD5bMVw0KOXxOimIdcVVVsTNCVGBVSNdckKomG1SvH9KwjVOOBUYUnCiDfefI3RqMtq0bjzsBVYbbB1he9bAl8SBhF+IBB4zGcbloucyNMMhl1aVZPlKTuTPVptaBpN22g8zzUkLlScF00cKSV1U+F7vlPcSLFN1fnzv+qyulSJurOs3VKqHRskL1LHDEhiV4CHAZ7vYbUh9HyMkTTacLC/w2gy5uj6Vc7PpyymCxbrlNV6yXRacHqyYW88ZjIc0O/HBJFASeP2Td04/giWnVGX3Z03Wa9Tjo9POX5+7hR6FwW4MS6W2FouIWywrX1cU/JSHQqX96N7l5Oz/ykGwYWqBOdRNliatqWsKzwVXvIQ5PbfuPh422oQLTQtvpR0wxCpNb4niD1B4ksUvgP16dapgqUAYZC0SKkYxB4qUmgTstpsCANJqIC2Jg57BIFPVVa0tiYKY65fvUIUd9gUFb7nIdEkvmLU7xJEsRsoKksShUzGQwLfJy8LVy+FEUEYslytqesTlos5lZ6RVy2z02dEYUy2WbOazsiLCoWT7vuEGCHcmtQGIVzBLaRECVwBzkVMnL0Ez8XSEFhIPOj+fOvun3/hraVEKomPz+npCQ82KQsZoGWAQF82gi4KsJ8CYAiJweJISRJtLAi1hd7orf9PXuZPt01DUViOn5+gmpKDvQkHOyPnU/E9J9kWktn5KU3bMBiN2N3dJU4SkAopNNlqikCSrhbESYiQCs8P3ERNCnTrvDe9Xu9S0lSWJb1ejyzLXGZxGNLr9biIYwBINxs6iSvEL7qJnudd+sSVlBRNw3g8xvecd8IYg++7g5vNS6IgoBPFtGVFHISEvg/GebuTOHIdHN1gjaMzzmYLfE84yXpbOUK8+1VhTYvyvUuaqJIKrY3zT2lHyXSbjEF5Hru7u+4A1jTkec5quWRnso+tq23joMXz1bYjKTEXUhf+xZLyP/n2xYPy8nH8Z0zMP/n+vyi5+Xivi29gs16QdCKE7dKUNYtjze+ff48Hx8fM04JSW4z1+P63f0TUEQyHA57kT/CUTyBDpFVcO7zJzu4+H7w75xe/8DVWq5wr+1d497vf5frN23Q6ff7wO9/m5MkpRV7RasOjR4/4wfcDHk/vM138iP/oP/zf8R/e+rv85IN3GCcd/tKrv8I/+L3fwTYVt/Z2efvoKuW85drhLmla8PnPvowKX2I1X1CkNeenzxn2BnSCiHxZ8e1vfIebtw755a/9Iv94esakG/LO+x+hpM+br75CpVN+8tEdvv/dH5ClT0hiyWQyYfFsyksvvc6Pvv0Rj57fI5ns43sx82enPH/3Dle+/BaTN2+zlppsnnIounz55c/irUEaS11UrJdrdse7BJ7P8ckJ06kj5k7Pz1hvVpRVSxx3uPXiCxwdHfDk2TOU9TBGOomUaTHWoFRAm5UUyxXjboeg63xsd779Q6q2pRYNg90ub3z+FY4fPcHf8bi6exXPugd1bQxNU7tmV5U7j24Qsru/R9JZYO0SRE0Y+ejGFUieCpBegm4CisYglY9tLHffuc/p2ZTdg0OIFbQlsi34zMu3+O7pEpFWLOfPORj2WJ48o+yHtBE8+GDO3v6A2ItZLmcc7o0Z9HpURYvaSlKV8twDUkhAI7cSNinANjDbrFgWZ0xXG268/ApPdcG94wWjyZjz6RnPl6f0r+xy+/bNT3WNvHjrJgfXrpJVmii6yXJ1jtGSm7dfoFisWK3PiOUQP/DQVlJVNXWj3b4PhGEEW9llVTnva1XnWGnRpqFqG1pAC8u6WHGyeEq4W2OamrZuWGw0uo0Z7XSITMb1165wdAvSleWDd+eUheLk2RrTOCgi2k3Btb14HsFg0GfQ7xOFIVVZ0h8NeX78HGtaRuMxk8GA5XzGYjFnMByQdBLuP3rCOs1ASJrSHQqkUGSb3E3StyBN3Y0AgxZzkIqTkzMaY+j1OgghCCPfxaHVDt5Zb8nlF1tekiSXk0Ip3fTZ3yZsOFCc+7imaVks1ttJn4MuwWW/Aa0NTdvg+z6T8YiiyEjznMHA+VvLsqFtzcWjmE43wuYNSklMi3vnVlrpeQJPetRNu22a4hIFDKSrmqPJq9y98wf0RwFKa168ep06q7jz+A5RN0FT0enH7HZ32d8PmC00vcGQKtuw09/nw588Zm8/oMoMi0XDcmo5urLP7OQpdW5JlwXdHkR9Q6s0wkqaumHUGRAHQ9L9ljDW+CLnxZu3sFaT1hVKeZzNp4x3Bp/qGtj0wfMF59MM2XUU/bijEEpimwaJpS4KrIVe0sEXkspYQs/Z2rK8QAea5XpBnqZEvk+v0+Gos4fXKB7de04rJJ1OhFUKLSxaaqbLU87OTwg2HspTl4kUkQioy5rGWHZGE/wgQZQNXuyxOJ8zn80IjKDf6WOrlr2jA4zIefDwAf5SMjmaQBizf+2In3zwHI1CKUPS8UmzhrxY/VSxIIR1SgJpkcog5MXzWoIwaKsp6wopPZQKMK2k040JQou2KdKvGOwOCWMPP7CEEfzCV97gtddvce36PlJYnj94yma1xmjN02fPqOuaPM959vQZjx9OOb6f0dTuHpRWoqzC90IkAbo1FLYmjAOkEpRlTtM0dLudywam7KS89No+v/7rf4kXXrxNHIeucWANwiYobVhO57RBS5IkHPQPyLLUqRT6A26/eIXOrs88t8yKnNwIoiimxTKvc3waut0d4mSMaRV5uuT9O0946Y2rjPcsttUMBkNMI4gTjxs3D/ne+V086SOFh5CKsshdM003NLWm2+sQRyOaIuTsqeH1K4f4AuKkoalyBBphBDQK3VrKprxUKlwMly6K76ZxewMWNumGweAvJsdbSafquShoPxnN5UuFtpq2blhXNXmWE0YRceLgf6J1YGUlBEZYPGHoxAGd60dcObjCepVydnLCZrmmOF+zWBR0kyXDYcLOTshwOKDX6eAr3EgaFzQmpKY/iBkMXuDFF29zejLj8aOnrNcZWBDCnbGdlf8iT/pi772YVontwOrCxi0uvjpsi+9Pzscv0uy2X4nGaIqqxFchURDhKRdv2dotV8Gy9TE10DqbrzKCQZwghXaFtXXqYbn9vnxPoE3reDk4+5GHQmhDECaEylJr7RJHrKbMU4TssCkK5ss1cW+A8COkbYl9SVVmVHWFBOLA3za3od/t0usmGA2Fbpgt1vhB4KCDUYyuWyLfQ1LSDQOk1sgqZbOeIRBEnqX2wZce0rQUZQbaJZp4frSltTtQqOd5KHXRmnC/XU9Yup6h7wtiKUgkhOp/5R5vP3bU7nyjQSkKa6mFdkW3+bNlja3WSAO+L2msQVonCXR0Yr2Vf2w9TZ4HSHTbUOSO4Lm7u4sU7ghXVRXr58+ptaEqUq4cHZJmOY02bLKMOAqhLsnSHN8PWK0WCDmkbhqiTkKZZ9sNqL3clKy1dLZ523meUxTF5QRcKXU5kaiqreR9OLgsErMsYzweX0JA2tYdYoLAJ003NE3lfCW+R9tufY3COq+s+Fgy7nkS31N4gcJouZWmu4lD4CkXBC8kJoyQcusp2sIxPCHRynm+fd9DaOlkWp7v8spxRfcFhKSqKqrKZe8WRUG6XrO/u8f59DmbLHMeQa0vN6V/ncL4sui2joRu/ozP+1ky87+I4juMB5TLnNdf+xKZ8rj/4VPe/e4dGltz/foOf/ff/Q3eu3+ff3z+e1QY9iZHnJ094/nqGV/6hS8yGo7IsiXj4YRe2Oef/pPf41d/6a/S5g2T7oQnD55zMlvxxv4rzM43fPTOR5hNw2q2QCnLfL3kwb3HzDenXLl+lcX0mB++8yOEhdqUHN68wd/63JdZbwpujEfsRAF/vP6Q/+D/8HfIy5JHTx9AbTmbHnP/4X2uHE7oJT5f+9IX2B93yDZrmibj5Pg+b731Ao8fPkI0hn/vP/hNfvOv/xv89//jf8+dh3f58ue+RC92BP93f/iY733nHu+9N+fHv/9j1rMSIR5C5ONJQaQUerFmEAaYqCVMNX/zK7+KXuTENkFhOTmfEoYRnW6Xs9k5JydnpGnKer7k6dNnKM9jZ/eAR48fc3J+zltvv8VstuCDDz4k9CMsGmEbbNNCA01V0+qKVlqu3NxhR004vXNMKBPnXTI+u1cPOX1wzCbdIPch8j2srtFG0+iWwXifVelidYSuieMOeXbOwaSLNhlVXRP6PkL6QIAMOrSFT1q2WBPgy4RAxjy+dxfV9tDrhqac8Td+9Zc5muzT0wJlAzbLNZNxn5dv3eDG0SF1VdIfJCA0UhqGnS4SMNoQeBLlWRA1SgiEVGhjqOrKgXB0TaNrpqsls7xABxGl7/GtO+8xK9YE3YSzTCO6kmockweS9b9AgfS/eI0kivc/fI/dnSOM0Tx48oCd0Q5SW25ducJJ+pzDjiAUO6xWBZ1OtAWtWXTTgK1oa4PnhZi2QiKIoi6NyDBejW0Fng3xgpDZ8jHdvYiwm1DXG6TuEoUFq6Jis25oMehgQ/cKdHc9XvnsL3B6vuLhwwesjltmD3PqpSTLqss4sv3diYNFGcNsvkB5Pjdv3SZQim4nZP9gnys3rnPvwX28bo8rt1/mJ+/8hPli7WRaQhN4Cs/zWGcF2mjsVrLohwHKD5nsHbDapFRlRVk3BL6HbVukdIeFqq7R2tl5jP7YJ3sxjYviEM93ub1t2xIq4Z4bTYPWP70Xu4OqBftxDq10J1mEsMTdDnlZsl5laKBuLYFw+3HdtESRRxT6SGHoRiFBEFFIj7IqkcIjijya9mJ6Y1HSo2pqjCfxQoH0NefTcz739heo9DlPn7zPfJYy7na4uTMhKzVBaxGNIBA7dHuCfJkx6fQ5X5Zc2dtlc5ax000YxBKvren4PSbjMTv9HZ6cPeHo1i6DTkjZntO2BUXRsjPeRaCIg4hJp0+341MVK2bFKY1u6A5H1DpHo1is1p/qGnhy9twpxgSEgc9mviKrXPO+P+zTGI2QLpEBC1EUMZlMLqeOQZxTVxVBFHCwfxtd1nTCiF4Yc3567gRsStC0Gt8qTs7OsLYmzdaEkUcUR+RFjhKC3d09Jv0hkecTKg9h4HyWbp/73mWhtdlsWK9WKKW4cmOPl15+GeVLZrMFta4Ioh5HV4/c0EKI7YTbHaTF9r66vLb078s/gQvg1IXP1RhoaoNZb5DCZzwZEMQabSRagPVgvNPltddf4MWXr5J0BEnXcLZ4QJ5uSPwOe4dDoihi/8rYRXEphW5biqzhj37rXb737R9z9+4D2sZSlaWDLNmaoqxppcLgYgXbtkZIS1mlGNMy2R3yytsv8Mu/9mV6vQ6Pntzn2rVrLs7PgucF7O9NCISz+vU6Pa5duUbTNCwWC6yF3VGPX/jK2zx69FtM5ysm44CibvADg+f71MaySlOq2kMSUzeGe/cecHLyEgdXr3E6fYSWgm7HoyhyglBSlhmdJMZaQ1NbpJVgPzHAQiKEh8Dn/GxFuhyTJF2W8ylY91zUrcS0Hqa1tKbenkGDSzL+xXTZ85ydIQxDet0+e7v7n+oa+Ve9lNiWTMZZTdlaW5y6RjnYvHATeV0bsianLCoCP6CbJFs/u4/nO4m1sS642QaKOOqxt9tjs8lYzFZMz+dM0zXLfM3ZzKPbmTEZDzg63KOTBASBchHBxiUPWRx478rVHY6u7rFYLHn8+Dkn5zPaLdTPaOsGX9vK+YLhdeHpvii8nePY4ppT4rJov/jYS+U6bm9uTevO515N6Ef4SqGlpWnNpR/fNK74N60lqxta3RD6Ek+2CNHSbifwUkjCIMAP3OBTW0Ndb7kKShALCAOJ6MYsNynKtiA9B5+tCrwoJgx8yjzHyprzsxm1NuzujDmY7GOkx7PTKcs0ozYthRIIq6lLQ1E5NXJvOKBuXNO0F3XYGU1oUQz6A9LNhs0mpclKQBJ7AtuNXDHdWGgtRuBUwAjaShNsJfByq2TZ6gyQGLqeZeALhqEgEYYQjfxfO1zNmsZtqFYyHvcZUbHIS0xdboPnf1pG8VMFlLWXXa221XhCoNR2Yalt3pp1WH1jHGggDAJuXL/F0dGRozNGzj94Pp1S1g2j3V1kv0NRFfiBTxhFlGXhfEBty3I+w1qJkO5rhmFImmUUeYYUUOclR4dHtG1LnufuwB26bEZHErWXXcOmacgyFz82Go4uZVzWmkt6Z13XLm8zz5lMxtR1dQkQcTmO7vfTti3dbtf5zWH7NTyatkHrhlBE25gLnK9QW5QniMLIxU1cRHP4ATY0l34wdy5zUzNfKTROXnIRlxZInziO3IHA9+kmsSOnWtdZrauK3d09VqsVvX6HJIycp8J+DFj5WUXxxcHsk6/7pTSMn5aXf1IF8bN8339RE+9R7wrvPbjDYpkyzzPOZ3MGSciv/NoX+frXv4AKNF/58tssTzb89j/5LkWR0+v3EELzk3feYTQc8PprL5KuVnznW1MW0yWf/cznOX6+Jt6JePjwQ8a7I4wU/OiH77A4nTM7Psbqii987fP82l//y3zrm79DGEaIouaf//bvcv3Vl9Da8Id/8HuIpmE82uPOD96h98ar+KOE29cOebI84/HpczrdDmlaEHe6NK3mhZducWV/wHe+9w1Onxzzf/1P/i88efKI/+of/k+8+vqb7O6N8ft9zmdP+Pv/7/+UrCz4D/+jf5/5cs1wuIPyQj54dkZreqRr0BuQmYDQHYCinQFRR5Kv1+giQxjNW9dfZOwn9KxPZBXpYkXTNuwe7FGUNfPFkn6vx/e+8z2mJ6eEScKrr72B7wfsHx3y3vvvc/fDj3jttTf40fffYZkuEBiEdYWL1E7ypdHYAK6+fIvd8Q7/8PF/Q51rhIHp6TlpW/LW1z7LsO2wns+Roe8yj5Ukivqk+ZpNmlPXFUmgOD+dMlIaoyOUlCipsLbCtBVGSIy2GBFStoI8belPuvgyJpu3/Mrf/RWuHAz4vd/5Bxw/us/L1w7523/736TZ1Ii2JfLcwRBTkMQepm3wPIXEp20MeBLfkxjZ0ujC2UWsj24tjTVbVRC4U4iHUZKw22NRtxDFeBIm8ZBMV6zyDSr0MYFHWtecLZaf6hpprWGT1giWjPf6jHbGKOUzWx/TH9YkoxeRgU++ypzvXCrwFS5iUtO0JUkcUZU5ngdt6wR6npI8O3/C3sEBO519Nm3GvdN7HL10wCZdkGU5cdRnZ2cfa1cYrQi8AKV8PF+g/IBGZMg45fYrY7KdlpNA8v63lwhh8baU4IPdCZ7vsUkzlJIUecY7P/4Rs+mUnd0xn//yF/nKL36FRlj64zHXrt3gW9/+roO7AL5SRFGAFYKiKF0xcFF0CJe5K6TkfDYjy6qttN3SNjVCCgKjHUm4bbaHtY/3Old8Qxj65LmTC8dJjPIc+LOuGi58hX9qj7x87LrjnX/RHFhvtv+ek+IWeQpRRJLEVHWzZdRYqqpBeYr1JnMxml7oZObS8UUQjkxfVvUlVOjq7Q69SYfZ+pxhUNLqnCxtXWO+qAjDgBs3D4n7Hc6WTxnIPcoyJy8z5jzl+HRFGIwJk5iyamjOaipTYKzH4uw5O6MrlPM1vog5uHVEVmx9w1uehZQxvXCHq2/f5unTeySB5Oz8mKgTE3gedVG76L8q/VTXQLfbvQSHrVarS/tZURRkeUYQR7CFhE2nU3q9HsElrV5QVRXPnz1zJWrT0g1jGiHpdrrUgxpdtmSNA/BFsUdZFBjrzhW+5zu/a/mxn1i0hkGni0o66FoTxTGNgdlyQX80JExi2geWzWa9zbj3KcuW/f0r7EwOXDSoMhxdOcD3BU1TorXL3b4Axv5JqvmfeVkX76c1SFratqZucsKOIkl8uqMet165xfVbVzk62iEIAVlhbEFbbTC2pGw8PD9ksV45OKPRl8MR3wv4a/+br/OXfvmL3L//kHt3H/LH3/oBZ6czVqsNWoLn92lNg9UazwMrNLv7E9J0zdd/+cv85t/9JbJqzmQy2SoR/cuzmxd6LBYLFouFA+MZ58++4BZJqeh1O/zlX/oKf/DPv8/DjxZUlTvnhVoRWoGUlsZUtE1KErmIrOfPTnj33bvcvL1LkVmyJiOJduj1Yz7/hdf5zrd/gmlqtPFQMvypXseFD/vi3HT87ISH93w6yU2XBIKkziqsVVhtENb5oS9hv1vv98U9CNDv97HWslqtWC6XcPipLI//xZdAbM/pLrVEtwbpKXf21FuJtzG0dYuuW+qywvc9wjAiTiKiyE0/hQAtGpQ0CM9jNI4ZDDvsH+0wny85O52yWeVk5YbFKuVsOmN/b8zOuE+/3yXwBUo4FgjgGgBoJuMuk9032WQtz58/58mTp2RpweXSuBwcbWXl28m33dKJ7dY2Bh8X3R9f9vJ/rbVgDI1uKMoS3wtQgfrYyYFwv4f2YkrvEfghTd1QNAVJLPECdQnVtMYglSCKI5QS1G2LMQVVXeEJ6ST7TYXCEPkuKabf69KTHYznUbWaMPAR2lLULXHoMep0uHb1CoNul/k6xeiGdLMhCEN0XVNmPkpG1K1rwqVpTttomrxG7u47MJo1mLZGYZC6wTYVSdKltRYjFVmWYZuaJAgck8cKsqxCCovvuYhlazQKi6cEvqcIJEy8lm4g6Kpt0a2bnzs88OdeeLeppsTnDMFxVlHnFtVAK6xrjdqfhQ5wN5PcRiwInN/OwcS2N5oQLqpkKz13NALNoD/g2tUjF6vlKbQVPDs+YzwesZfE1E1NUbioislkjNUOipRlBYv5Gs8fMDtbIqQh8GtaU9PpJHTiLnGcUMcFmyxzD3QhCKTzClRNgxWSbr9Lmm5YLFesN2uiKKTX7eAFHk2bU287cJ1OD6UkWluaWpPnGZPJkCTpUFXFpbxVKec90m1L2Ou5BdQ0+J5HFIbUVYW0kkG37zIYhaSXdGibhjIIiKOAVlusbsnq2kWR+e4GDDyFjQK3WJXAE5KmNVjl0UrjIgh0QxIk2LohCQMGwz5+FFDphlZbVpuUTv+IqjUsV2uCiUJa+Qk5zc+WmH9STv7Jafe/yBv+s8Bqf1Zh/+dxffeP3+Gdn9zl+HTBlWuHvHz7NsMk5OHdDwkCxT/4b/87rt18iZvXX2Q8ecji8RLpC5qq5OjaPm3TcOPaVaoi5fj4mL/513+DdLVhOOyzSefkxYKja3uUec5ivqSp3WYlfMMXvvQW5+fHPHn0jGxT8ObbVzi4eUTbwPfee59VoyGI+c63vo+tNJPRBETFZDTmn/3RN7n/7Alvf/YLXD26zfGzOUqFRJ0OeVOhYsXrn32TOx/d5cXbL5FWlj/+zo/55a98Ea01f/BH3+FX/upnSUYdkn7Mj959D6/VLBc5P/7JPfaPbmIbidYSKXys8BG+hU7MsljQliXp6ZzR0YS3rt6mXWd4nRBrWvIypdENyvc4P5tTlhWPHz/i8eOHdMKYN159FWNqsBYpDJ0kYL6oaGrN9SvXuPPe+whhthmXBv1JYq2Fux9+yIu/8QphPybLMzwr2BuPubq7j9UNm3KBLyVSeYxGPbQSnJye8sH7d/FkQtXUdAIwrSFPNet5xmRXuoljnW672g2mNWSlZp21eN6Q89M53W4f3ypeOLzCuOchypqj3R10U3F2/pRB2CXA0A1DOkHIfJGSZRm97pCqrJ1nzY+cVFNYjNlmTVt76cfVCqwnqNsGbVoa3bgcy0aD9KhbQ+h7hE1DHMRUnkDFCdpYVrMlH9179KmukdlqxXK9IStS1pVFJpL5IqcX+zw+mzPq7JKpkkFvB5FpyrQElEtu8CRJ0gNradqMRrcoz9tSZCEXNQ+mD+n3d3j/wbsU/pJ1MeR8PiOIa6yfEnYGxLmgKFpGnR6LZUoUg2cVulkQhIok6tAWC4Z7PRq5RHUEojFcOTzA8w15sXRxXtY6f2kUMhoOODw84q/+2q+RJAlXrl3j+s1bfP/7P2S5XIMxLtYRi+cp6qZBSnHJ2SgKd5DZjSbOl1o7P/bFJBsEQRDS7/Uot8DMomxcw9N+vOc1TYvWDo6krXGUaqmQ0hW9utGXBfqlg0u4pjWAUpdgDoxtUJ7F8z0wgtBXrtEU+xgDe3tjNpucNC2RvkedFmRpie9J2tZsIVvu32pbjed7W89ri/Tgxksj9q7v0HgVIi5pVik7O0ecP5nhBT2kJ9AI8jLHWsiykqpJgZrxTh9T7WCMo9fK0CMrNVHfZ388RlSKAMPnX32d89WU6fE5QmjCoMP+3hF11/09sAGb1QxtVvSiLsJqmipDRzFJGKDbBp/oU10DQRBQVdVl8kme55eAr80m5Wg0pNPtsl6vL4uas7OzSzCr3FrC9nb32BkMmZ9NWU5nXDk4dJPx+Ya0Xm5ZN85+ECcDmraibgp0qxkOh/Q6HfqdHoGQ6KpmPl+wWa1Ja0ttFJ7nMxoN0dqQ1gUNhvlqwdlszoujmxRlSlFv6PV8qrKg241odYUuanpx8olCU/4UxfxnNcd/upkORls8FZAkMWHkk+UrXnrtRT77+dvsX+mTjEIMDVI1+L4gTkLystrm7iraErw4osV53K21lEWzLbwFKq7w2pIXXt/nM198ia//2i/w27/9+3zjG99ks6owbUie6W3zyqPX79LolL/89bf5d/7dv4mMKyrtcXx8zHA4JI7jS8uglBK7HYx0u13KssQYQ5Ikl+rIzWbJjZtHvP76C8zPf+ykx0ZQVxqtDXHs43lO/ej7HkL4pLnkznsPeeONl3j5jZtUFM4K6Fd85rMvcfX6hPv3ZlgtScIYW33c7PiTELvlfM3DD59xuDfmpVcPWCyfYKoKi3EMbikJ4wS9bVhcsCMu1JoXr9eFB/wivu3P+zLG/KmfTSm1HdjYLRV+Oys2djv9vgCyGWdlqmvSdEMYBZcRfH7oEaqt+FgIjLKEvYBed4+DgzGzdcbsfMZyvuRkmXG+Khh0U3YmE3aHlsm4QyfpOsuNQyi5oaHU9PqWl7oHXL8+YT5f8/DBU2azJU3dEvge2kjaFpDKDRBpgRYrXZQmQrrm5XbSvRWfO3ibdT97qy0ag6kK8D2U8ohVjNE+otUI07rYPwtC+Qw8EJ5inVu08QjCiMAzBLLFoJyqrm1R0ieQHokfU5nGFb7WYI1FScUoiTBCEVpL4HvIOKLShqwo0AiUaEniPuOdHYb9BNqWcrOizjKUtXTDDp7y8KUi7iUUTU2tE/KyxO/4WCGYLqekecFyuWa93iCFxBqI4w6B7yO0pm4NYltzIFxhbbUlEhob+PhRSCBAGkNAQ6Ig8SSxgrGqCYRAWkexbw1bSO7P7/r5rx7lkWrL3dWcu6uc86qhVgothVsYf8anXiwuIQWeVMgLeYa9iIPYyjCMxfcciCSOIzwl0aam0x0wm56TpRsmOxPyPN8SLyM8VdPt9lBKsVgsEUKRphmr1Zx001A3OXEvoddPnAdaSMQnCsSPwRvipybXjlYutp5wSRTF+H6AVIpNuqGqapRSW4gIlwT0breH53kODFLXCAG+H1zK1ZvGxYVd5F1+DMVxEhZPedv/FJ5SYC1h4OiWkR9efq/drvPmtG2LAALPw3jK3ahSOp+JEihP0hpLWRbkecAgjgFDWRZo06ACjygKWG9KptM53V6CVFvAymWnjcvX65N/t/ZPZHX/L5hg/8kC/S+i+P7uD36IsSF/6Zf+CuenT3ly/yM23Qi0IFtueP32WyzXmvOiZjUrsMIQehEvv3KLxXLB5z7/Jh/euUPoK/7j/9N/zHKT8977D9g/GPHo8Qnj3TFJFPH0wQl33r9HkeYu1su23L93j7RYYEXI3rUJdRBw67U3eDafoqIOv/m3/x3ufO8HpJXhN//Gb7CxOQ8+usvmzkdIP2JvfIVn96c0m5CnT0+Igh5vvfUFHj15n1oqGs/j//Hf/HdMBofcefcx/ajL/cFjdFpy+9our7/5Jn/0g2/jj8fEow7vP33CclkyzTO8+Zx+PMDUzjfU1DV4jrKsNYgoYvN0wWevv8aoDukoR9jOs5TnJ8+5ceM263zNarOgLDKePrzPzqBLN444fnSHxeKUR88e0Rn02N27zttvvM2d9x+zt7vHR/4HLrPbSiweRrhOaSQltjUsPjwhxOPKlUM+WnzEmzde4G//rb/B0/NnNDEsq5KrwyOu37xKXWS8d+8es/mc69duYVrF+/fuMhr1SOKQttJI4ROGCqNrEE6uqwRY4ZGWlrKBthZIbflbv/Hr3N4bUaVn1CLmjZdeoRN2+O3f+l1euHWbF69dZ6/Toy0twgsIopgo6eB7AXmRI5UBXMyH3ZJTER7NNoom6fVY5GvOplOiToTvS+rGUhYVT54+pwl8otEEicBTitoalIZqnXFyOiOJEvJ18amuke4g4IXkCtgCFRpOpnPCSBFEitWm5v17H1EOYj7z0oBGtVivpcpyR8r2fHQh0I1Fty4iqSxKoKZRLdN8zjSb0Tx9DyMrknEIwpG5+1GPTscDWSMUDIdjpIhZrHKMhCD0mJ8vibp9WlvRUtLbDXnx7Q6dTsTsaU2ba9bpBs+TRElIGHZZLTc8f37McDjg9Tde5/qtm9RNw2c/91nW6w3/+X/+X2Ktpm1arHLxXrpt8D1FGPj0+z0WK+eBDcOQ/qDPdDp1zxOcektrl0gRhQFRFBD4irZu8T1BA+hLN4BTggWBdP7LtqaqCqTncnqDIKCxzTbS0h1Yg8CjqhrixDUA2qbFGItSAs9TBIHLMe0kXXTboITLez4/n7rpvLB0OhFmW3C4Z53CWI1p3PvkNh6zbR2QRyrwAkvS8+gPE07mMzargnqTczR+gb3OLmXREPc6+KFPUa2QFVR54QBRxpKuUjwvIRA1L9y+QtNYWqGp7ArhefjCp85y4qDL7mDMcLdHqxum0xk0lqYskUaS9BVZtiLyPTbrFIyg3xkwHAxpDShfcPz8+ae6Bi4KtLqu2d3dpa5rnj9/TpIkBNvm+SZNefz4MeCSTrrd7iVTxW6f96vlkl6ccO3aNf7o97/Bk4cP6SZdhkc3LouiNM3I85T1pubgcI8kCTmfnUEOnpRMhiMG3T7ZcsXh7j6z8ynn64JZVtK2mqJtsNawTDckcYwXR/zkvQ9YrTZ87vNv4Xk+k/EuZSHJNkssLVXdMpvNiMIIz/MuGwwX55aLhtKFZc3f5gl/MtvbGOtUPEZTVRnDcZ8XX7rKzdsHCL8g7oBQHnVdUNUFYdxFSUkQhAg8GplQ1CXdYZ8iL/CDgF7o4oI8JViXU1bZktFgAkHNzpUef+vf/mt8/Ve/ytnpgv/n//23uPPBI7rdgCiGuCP46te+yq/86tcI4xq/E9Af36SqKlar1WXUVqfTAaAoSrxtxOxFcRiG4SUTR4iGqsz5zNuv860/eheJt21Mu3WexD7KE0gRuhxpbQj8mOdPZ7zzo/tcuXGdZNhFSk2ctPiB5HNfuM3jR8foWpGlGzpBfOnF/uTE2jVDfM6P15w9XfLyC9fYHe2zyWYYrUmSHnnhIsYsdsvTqC4z4S/Sey5i2y7utb+I65OWmY+tM9tGDrgEiQvLojCX4GPdtlzQ0C8+r01birwkiiKSbkIUh4Rh5BJRtjAusESRz1Gyw97OiM06Z3a+YDZdMF0uWW5STiPJuJ+wszNiNB7Q77rmkW7d5NQIZ5FNkoggCDk6PGS5paE/e3pKUTZ4vkfTGmfHcD+Qs31vC25jNUJsGUqAxE3JBRexeK4Rr01L3VTUbUWgAqTwsEbSNtpZkayDktqtCsrB2zw8z6WNYJotpNH97HVdb9WrCmElpm2wnsaTEulJwjjEDyO8IERbi9WaSDkLq/UUYdR3+7PvUWYbiqyiqUu6SYSVTnFgtMv+xmp021x63qV0bAoHjmtotEVoXE67F5CEMW3Tkqc5jbF4SlE2FRZXuzRFiSckSkIkNaGCEEg8RSwtsScIhSGyTnKuNdsmBlvw2s/v+vlLzX2P0+Wcj+YrnmtL6iuMCrCtcSHl1vzMkbcQArPdvJXB5ZJa8LZSGNM6irAxxgEytwX4ZrPhyZMnvPryFeq6Zm9vj6rfJUtTsmxDvz9gsUzxlO+C5X13AMqyHM9TPHryhPNZBbbBjzxu3jhECc346gBMuyVvBpekb2OMkzhY6wAOgkt/TFXNqeuWJOlSlTXppkAIRafbp26cxK4sXG7tzs4YIZxcIssKfD9ESkVdN5RltZWdy62c3S22i6JbILaHquDSj9M0DZ7nYAJ+EFCW5VZKJLeFf+Ai0LDoRmwl7YLWuH6b0YaibED6JJ0BdVux3KxI4pAkCRknO/i+k+oXpYsLifG3/hN7wSr9U1Psn/o7/2qF9yc32Iu3f9bX+/O+5quMutrwkx/9EOU1+LLgzZcPuHV4wOz0AdevHjJ/5wHf+L0fUG4yJqMBV69dYbGY8Xf/3t9henbCoyzlxz/+gO9//x0Gowm9Xp+6Lnny7ClXb1ylNZonz57Q6oZVuqExmrjj8fDxQ6xs6I/GjPd36B+FVGieH5+wyjKePHrC++/dZ2+8ww/v3OOv/7Vf5vH0Gd/4Z7/HSy+/ihWCyWSXex/e4eT0lGvXb1GWGePdPe7/T7/LZJSjpcc/++1vsDM44Pjpc/7Jo8e88eYtXnrlVZ6cTZnlJbuNJs1yvvnN74D1yJcNNybX6IQRSSemKFI8a2irmvJ0RtANCfCZPzrjc3/vdSbBEN9aijRns0kZT8bEnYj5cklRpJwdP6UpN7x08wr3797B1yWff+WIV26F/ODd96DuENBwMBmzWC0IQ4+aFttKrJVgNL5QDsghBXXWMD2dMb5xhflywa/95l+lP+yw6084t2sCT3B49Sp5UfDg7kc0WnPr1i08FVLkDaNxH20ydveucGscUBQ/cRJzaqdOscL5ZwlYLHLqVnD96k36nR7LsyeEXkXoa5LY4+t/+es8O37C/uQIZcU2ugRaY9FVjfCCLaG6Jggk4CKdrNEYLS8fDlq7WMasKakw5KalzDICX6GsYdjt84ufP+CH771PnW7w+l2MdAWTNeAJhWlgmW1om093jaiwYNDrk20052crpuc5V6/u4IeWdiXoD3c5nU85y+dgIS3WxCoiUNDoFCkUnvTIq5wgjJBC04iKablkWS2QXUmxTolCRb8zZNAZU6UbfAu61FhPoUSH+TQnCAVSbd1dUrKzu4fRDZvNkjAJmK5PeOsX90jCPt+cP+Xk2QpPeuwf7FHVmsluj7rVnM+n3H7xRb7y1a/iBT790QAv8Piv/+u/z9NnT93P7Yktd8RijCuckk5ClmXO+42L/Cqrirr5OIbLWIOxW0CltZd5rL6vtgcx9/o7aeInD5LSQdu2/3ZdV/hh4JpeWMIowPcko/EQY1y8jB/4bNbpNiPcIwwilCfxfeX4KtIV0EVZbidcgt3dMcZYiiLHIsgoqGv3LJZKXlquwD0Hy6pCSIgjj93dDqfPnlHWa8LhmL3JAUc7QzAxD589oTQlp6dnWCqsqLC1a4534yF5WoEp2ZRr9ibX6HWG9Id91tmU6ekzWtvST3oIbRj1e6SLNZ1uj1F/grXQ68c8f/6MqurQ73Yx2ierp7S1YtjbZWe0hxcG5GWKPfh0nyVxHHORePL06dPLnGQppVOpRe5ZfP369ctip2kaisJZ4Oq6otWavMg5OT7m3vt3ePjoEbSaM3PKkQiQcYTnualev98nLzYIIej3+5xOTyjyAqM15yendMOYJAjpvva6a/a3DX4U0U9ilssVRZHTYkirAiMFVa05O51zejLF2Ir1KiVPNXmmGI0TqnTh7AnexwOBT0qdhWCbPy8uadQ/ZS0zW+bAltFcNwVNq/B8TaPXdLuKIHSQXnANjPUq23p7I6LIp9PtkRclYRKjAp+yLJGeK7pa3aACRdSNiAcJSvpUZUtWF+xd2SOvauJORKcTE0aCg8M+f+1vfJ3Pf/FVrl6bUDU5y3RJs3ZNlCxzvJ8kSdyUu9MhUh5VXlwWvm3bcufOHcIwJIoiijIjDLp88Uuf5dvffI9vf+sOk9E+rdZUVY6UnkvpkcrVIEbgeQFtY/jo7gkfvv+UVz97lU5f4vkW6Wn+yl/9Mt/4/R9SbHxUG2JaN4m8KIqTJKHf77NarXj04AmTYZ/6M5Z0UVC1U+IOxGFA5Hls6pQ8z/C2RftF1FgYhpf3r9aaLMtIkoQ0/XTtGP8617/srPexaojLxsMFq+hPni8vzu9FmRMGAVGSEMURQRTiB46ILqTzWAeeJBr3GA96HB3tc3xyxsnJKfN1xTptOV0UjIZLJsMOe3sDBv3OVrofXj63pXS2gtGoS7//Mrdv3+L0bM7Dh09ZrjKMEWgjnT0UBwOET1i6//RP69aXYitLd/asovSQno80IdYqdItLldAt1qsRYYgVCis8DBKEAjyMlZdSc90a6qbcEto9J/2unSoq7nVRno9rDRjnd9/uUcYKhDUIawnCEItAGePUCLYhjgL2dycEacVitaGsKqRMkJUlT53aKQpjtDGkaUldFazSnKxoXI3jexgURaUpi5LlOsNgsEJQt5ooFBRNja1bwjCi52t6XkUgIZRsC26LLyzKGVvRGrSxl7/3n3c18XMvvDdlQ608RCekSiu0VAgj8Frh6IJ/xufKLbTDCLDSSdi01lhtMNZsJU0GX3kYoynLlqrSPHz4EPSancmEa1ev0DYNcRyTJLFbZHnJ4dEYYwzr1QaLoSxKlyfb7TJ/MEegKWqBMT5B4FGWNWWebrNwXXF7MY3u9/us1+vLTq+UiqIo6fcH9HtD8rxkuVwjZIDn+VS1ptfrMpvNSNOMOE6wOHleVVWUZcn+/sEW0NZQVTXj8QQpJWVZUtc1k8nkUhLU7bnu+EWn1ZH71GVn0kHVBEL4RFFIWRZYq7c+RkGrHGjCImiMoDWC1kDVGpJOj+5ojLIaPwzZ3xnib/0RRkmSOKHVFVEcYUyD0U7muz0l/qki+ZMT73+ZrPyTHu+f9TF/kf5ugGQwYfP4OVWR8cIrR+SbM6ypubo/4ktv3aS3M+LZ9JhO0pKGkBU5z54/o9vtcO/efTbrOWEYkW5a3n33A97+3BfpDcbkRYlSim6/R9akfPj4PbQsadscKQ2D3RHhMGLv6JAir9g/GrJzpcvxs0ckUcC1mzc5ffqIV157GSlj/vj7P2adLfmVX/4F4t6P6I53OH78lMAvaGzFaBwzHIZ87zvfpmxqXrz9OkWaMdrvcOUo5e6dR9y+ccD5sxMOD/YYDUZ843vf4wtf+yp3P7jDBz96F2rJZp4hNPz42z+k0xvSGAMSF/PQGqzVCGXpj/scXD3i5Wu3qVYbPN9DEVBXDd1eHwSkmzXCalaLc4QuOX1+n0nf41e//BV6ScH+zVf5/NuH/Lf/6FtMnz/k4PB1imKN50vK8qKT6w5exrQYXEHbNC337t7n8M1bLJcnNH7F8fKEWlts6NEfDZgvVkznKaPhDom1VHVJMggQ0idKPIRqEKrBipwgqkkGHoLaTfnyGiE7YAM2acV0tsQzU16+fp2jSRdVb1itplT5hqpoMVrzwvWXqcolbVURDPvoVtNqC7bdZmi66bZu2q3Cxk29xXbaqJSCQJGZmsK2aE9gpWCdbjBFTuIFsFgStA35pnCQkX4XT3puKmMF1w58Ts6mHOfnn+oaefzkMYPeIbOzNcoLsU1Nlq4Zjie89PIe/a6g8iU/uP9HeEoSmQ7XR7eQIqCsa0IvwMNzUE0cZTVVOQ/md9m0GcNghBco4jDAbxQ7vQGhd0jTOtjO3fsfsFisESLh8PAa6dOpiykLEyLV4/T5E6wRRL0eSa+gsZYHH814cH+BrkMqa0jziihOODy6xv1HT/GjiC/8wpd49c036A8GlGW+VQZlDIZDzo5PCYOLqZ7z/sVJBEJSFAVSeURRTBCE1LWbiFVVcykx19ZRz5u2ZbPZsD0bIIEwCMC220xdN/Wo6wblOalR2zQEYUhZFYR+gLWORH4RQ+kpgR8FLMqS89MZbmreMuj3t95wB9Ip8tL5bk2LUpIoCMEaYilo6grfUzR1i+cJdOvAQMbYy1xhIRRxHFNVNcZY4p6iNzCMgz7SjBlHETuDHt0gZFVUNKah9QSj3QnLzSllWVCkzpNpdUDTGlabKXEc0ogGowvKacZ40KMThiglCcMEGs8BfoQi9D2sbFlkS/KyIIwUZb1i5IVEXkwdDykCS5HCk+oxcS8EX+IFn25G8Wq1+qlJmxCCJEmYTqecT6d0Bz3COGY0GgFcynlXqxVFWVJULtZLeT6bNOXJ40cuFUUIqrpivVkTWEMU+bS6RErLJl2iTUVV56SbFOVJF50ahKxnC45ncw5299zvKQpZpyXz4+WlF90KQdU07Ex2aCMDtaGpDRZD62m8QJHYkBs3r/DswTnS6MsJtrX2Uv6rtlPgC+/3J6XoH6v3QKDY8pqxRtPtxQzHHdo2I07GWANGCIyW6FZRVS2e8vH9ADyPtExptSbYpqwURcFw6GBrTQNVrkF5CM+jalqsVAwnO3hewAd3P6LX73H16iGIkjffeoUvfPEtdvZjqnZFXq7w/C6mdd97t9u9/LlWqxXz2QzfCkaDId1u99IukCQJm83G8Xn6EVePjmjKDv/+v//v8cG7/zeWyxUg8TzXJFZKIKVCCYkRhjBIaFvF08dTfvj9D3j5rZuEocds+YzxpMdoEvGZz7zEH/zeHYrCEKvEQcc+IRXv9/uUZUm6yQm0j2cjuuEAJVIC6QCk1mvBatJNihe4psHFOfNCOXNxprw4X/5pz/Gfz3Vxxv3k24747bw0F3yii4+54CVZa51NCf7UxF4IAVa4M35Zo3zP0dA7CUmnQxB4eMJZAAwWiyEMBDduHHB4tMtikXN+es58NqU8L5kvVpyerzg8OGA87IHNSDoJ3UHXTXWbGqlAedDrR3R6V7h1+zpPn53xwQf3WG8KdCvRlkvPNdsh1nZWvT3fXHz/F3sL7uNoKZsCWg8fiXVMb4ypttFxNdpKWgSNAV3UxFlJ0PWI/ZjAM0jPAwymbai040jpxsXwWW2p64ZIKpSnyPOMrMid5bcVaG1RQYC+SG+KQqzWNLqhqUpEK/Hx8K2mqXLapkF2nVK5bWrqxoKy5Nsoy7oo2WQFeW0pypYsr/G2KmNhnSxcSLd2PE9S1y2eMSS+ohtIxkHLwGvxJIRS4AuLtAbp4Fdos33mIjB2W4D/nAUdP/fCuw67ZFmNFh6CFs9IZGsJjUALMP+CZ5y1Fm3dLSOl8zh4nkKgaLXZbuxu88ZzE1oHHHMS8H6/z+HhIXmek25W7OxMKIucosgZDicMBn2UgqJMUcqnbd1UQbeA9BDSIy81cXdE5BvOZlN8D9qmJo7jS1l4EAQURUG/38dYw2K+oNvtUVUVo9GY9SolimKwCmMEs9mS4XDIYrFmtUpddy0IUMqjqgpWqw2Dwcj5yeuaPC8IgvAS0JLnOUEQEEXR5QNmPNm7zN2MoujSZySEYNDvY+Cy83zxEPR9H9/30Gb7e5bK3XRI8lqzyEryssHKhqxq6cQB+1eu0gkV3SigLnIqo/EDCcIB5rRutu6aLRxN2J96PT/538+ScvzLCul/2VT8z/t68+3P4xmJKXKOj094/bXb6LblwQcfcW33s2zWc27dus7rr1SI+hnT6YzFYklRFvz2b/8uv/k3/zrnJydIJXj55ddd/EPT8OzZMwJfcTp9Smc3gV5FkLbs7XUpq5y3v/QKb37tDebpCelsxv0Pv4uqr7J3dIUinfPR3Q8YDfpI32ed5Rxcu8rTx8/41j//FrFKECJmXRg+vPcT9kYJV/d3iEKfN1/7LN/+zjv8wTe+S+x75MsCowOG17q8+pde59rzA0IfxkGH8njDR9/9kNnJMSPVIxMwPujhG8X04ZzF7KnrEocBnSTCFhlCWgJfkGVr3nzzV11YhgXbCqqyQbfWeeeqAms0s/Mznj95yNGkiy7XfPHN17HpCXl2xsKP+KUvfZHjpzP+8FuP2dm5hRAtUSRYrd3BHyuxQtBaNxE2SKyQPHrwiDe//nneKzZ4aKQx+DbgcHefpa24d/cR13pjjHFSQlF5bNLCMSaEpawy2jbDkuF75XaP0i6SSsYIGVG2HnfvPQDhCMGBlEQoRt0eRVmyXKzZnVzh/PkpprL04y5R6JPVG8IghG3mpDEtRVW7DFUEdVHj+z7CgFSSqqnQnmA6P+fByXP8XhcCH9NojG7xjCUMPJIwot/psNysmRYVxw9PGO3sI0Of2A/IK8vJ42M6Ue9TXSNnx5Kd/i4v3L7GdPaE2bRG0DAe9QlouXvnx2itsL7EDyK8MibyYg5HN5mulwy6HaJORNgJaa3GTyKKqmajU1QAWZ4ThwnommKV81w+otNXpKuW5SrDanj55WvcuPEKz58viAJA5Fhq6qZwwM/BAfPFkjDusjm3vPuDKeuZwJqa4bCLUh6TyS6vvPoKdz+6xyZLeevtzzAZj5DWbCWFmi996Uv843/0P4J0ai3l++RFQRR4JEmH5XqNReD5AUVRonVLVdVUlZN7f/Iw22rXwS/rls0mp6pagsBjNBoShDWr5WYLy3EHLiHk9vnVkq43JHF0Sck224ZTHIVsNilKSfK8dJ//CeWRUh7WascK0JaidPapIPQw2k2xozBEa4M1kGbFpY/RbKE4YeC7aYluKUp3GPM9wWtvH9DrKUJfsTe4imoFqtXcv/cE1emCcL5CJcA2GoXED0KEDhj1xjRxiq5zJsNdVos1QaAJfEFdaPq9CKMUeVkxHA7w6VAs5tSm4mx+zCoriDsDBsMdegn0Oz6mtsTRIR/cecxwvMd4NKEl59GzB0Rx/KmuAc/zWS6XtK2LmlqvN4RhSJ4XdLtdBsMBQgiiKGS9WbNcLlmuVqRpipCSsqyIo5hut0ed5+zs7SEmmiovnIc/CrYNk4qiylyEqHIT0zTNqWuDZyRtYxkdTEjCiPtZxvlsRjfu0AhFmqcslguyNHOeV9/Hlx5Xr1/BtyHVqmRnZxdkje8rBD6e6vHFL3+GD975iOWJY0qYbdSd4wxsJ3xKIITcKigUQkha7aLmjLVYI1DSKSqEsEjPcPXqPgf7E4rmBM/zSIsaUJRVTV20SBlgtKByOHRsIBjvTOj3e6R5RrffI+64xs90OsWzjoujtaCuGmf/k4rz8xm9Xo+bNwMiP6Ju17zxxkskXZ+q2iC9iqQTkpdQViV17QjZnu+hdUtbNRRlgTJuKtppnWz48MoRAsHBwQFFkSOVZTo958Wb13jh1z/HyfMN/9l/+veZTdf0ej2MLl3RLSVSerDNNI+ikOn0jKKomM8XDCYj9vf3OT55xHC4x2/85q/x3jvPmJ+4oYc1rnBoWsMmzWi1ptPtsLMzhsywOJvz9OFjhL/k2o0R88WcQHrsDMfs9nuOnZHnbDYblKcux6zWWqqipBsn5HnOeDD8VNfIv+rVtu1PqSYuUoGkkFjxpyXCn1RZOMsNPwX/u1RlbD/eGEtT1dS1U5zkWU4ch3STkCAIkb6HsBaJ3gKf4eCgw85OTLreYT5dMztfcj4rmc+fcXgwZjJUTKfndLoxk90JvV4HrAbhzuKm0XhhxM0XblDVhvfeu7eFiV0UhO3WbuKSA7Z5X9vmwpb5AXChDBWG1jRkukK2PoGIEX6ErSsaU1LqlsqUVMZSGYNvPIqypYkUkZR4UmGN3cLpBBin5BMWBBKrBaa2tMoQJQ7QvNqsMRgSLyLwQpSAxlqE0XjWonWLrWt8oxHW0pQNpsjx2gaJpq4LB6kVAqtbyrp0kLYowmjQGtqmpakb95oKB2L1lCLwQxAGvU2NoG3whWUQKHZjwciDjmydxU447opjgrk/HDAUtHUF98XbP8/r5154f/f5CY+WG07zBiu87Q2lt4QAd3D4F4kogI87V0YTKCfdc4tJXsJEjDZbiIKL4+r1uuzu7VEU7sXc29tDSkFZlk5+M+gild0eEDRFXmO0YrFOOT+bYU2DED7T6YL33r9HFIEQDa+9+gJ+5bw98/n8shMohPvaToIkL71vYRBTlnN8P8b3QzZZSdIZslxntE2N5yuKsiKMIvKiJF2vLh9axlja1i3uwWCw9Uq5uJjRaOQkqNuNpG0b6tp5MzqdzqVU7UJqnhUFbetkGhdCCic596iaitZKFIqibSm0YJnVLHMX6dO0GQ8ePeXGjSvs7IxZLKcspwWdIMAGHr4XuwXg+QjhudfCfmIz4E8D1OBPSzn+JDDt4n0/68+/aKjaxXXnJ9+nrmo2q5zIhNy7/5SvvH2Dz375Nco25Q/+8Lsko9tEvZBX3niB0986QdcVWnk02vDHf/h9Tk+PSToxOwcjZtNz+l5EUa5J6wVCDHn29Bl0Wv6j/+O/i9pUfP+H30Xt9plVa7x+RI+Yk/s5N64fsXt4nbsPnrEz7HH85BmT3R0OD4/AKtqhx4cP7iD8Pvfv3if2E3ZGA8psiamGPD19xhuvfpbHjx5gtWa9aXj+5IzdK/scTvZ54dZt/vDBM3709Dnj3aucPluySj/k5rU9PvfFl9BC8eM7TyhKj2z+DsWiRIWC/sCn143YD0ZMz2ZEYUwQR7x2/QXaonQ+Ul/StK3Ltw0DFrNzyiolzXN6QYLO5nzpczcJ7QLRVAi/wZgaT875y199gd/67TvUOifp9REyQlo3tdHUgHbyPWuQQtAIWC1mNFnOYDAEIblydIWTR6fMPnrKUjYIX5E3Jf0wpCkL2qol9BP8MKDSLU2aYY1itZxy+HIXxMalCBgPtKJB0IqIhx/NKNYdNBuePnxMft5Q1xmvvPoKxw8fs/fCq2zOz7jz/nvcvnVEFA+RvqIoU4IgYhAH2LIm8T0aLHnbuIMZHokfUtYVudWstOaDJ8eEUYQFdJNTliVVUTLsDck8n7JpGCQJhwd7DMqa9TqlmM8QYcmT0zNU0ufJ4+f86r/51z7VNdIaj7qyJIkkCCK6SYcia7n3/jNuXN1DyQ73Hz6mvzuitGsm0QgSQ86G1K7YLM7odmN8v0uR1RhlKXTJlevXmc8XpKuCKI5RIqAtBYtsTS0l03mJ8hVVs0FbwYd3vwt6gDQBppYUxhJ4hn4cMp+uWGcpdaPIM8v0eYVEsnc4Jo4kuztDbty4QlUX9Podojji+vWrhGGANi2+pxiPhqwmY371V3+F//a/+QdURUnTtlRNS3/QA+kAZEJ6FEW1lXJLyjK9JKB/LIWEpnWQF2Naysrt803jJlHWmq2CSTk5otYIJJ7y3DSjbamEmzZcFvMWyrKi3sZBVlV7uQd7nmN6NI3jjxRF7Q4e1rFKfD9Aa0dWX6zWmNZs4W0tyleXUmKsdaoWFKY1VG2NtYIwkRxcS+j1Q2I/QlhNVrifvxUBuoZRZwJKsE7XjDtDlNch3azohB26oU+rAppkQL1pGXaGSD9kNOxRrs+2dH9JWmtMJvAtFOmSSbjH4cENjpSP1gqwlFlKlWUo4Sj3URzTNJq6bKh0Ruj5jPqDT3UNFHmDNVsOixcThQ6kdrB/FSGhrBcEkUddrzCUlCalkjnzes5gMGLcO6CuDFVjaKwl6CfotiLp+/R6HZTfZbnakGUZg6TPaDzi8PCQzWbNvbv3UHKPXmdE09Y0RrB344jns1NO8xWLumWys0PkaQLRcLI4IVA73Lx6m06nw+FuH2skctJBmxpr3fewXi9ZLT9isOfz0pt7/NHzD1CtoS5B2ABjnUzDCwxCC5rWR6gQ5ccoKanbglaD54eEfkLoddAmYzCWdAchb33uGkk3ILZHrKcN1w4OOZ+ek64yRsMOGk3RFKDYUuF9ynzFenlOnmXO7qcdWM62FbZuKaqMdW3Z3z+grisWZydYY7iyE9NTMUIsSDp7DMaKs7NHhJEg6fr4raJVAnz3DAkSH4QmSgI6g5iiLNBWoZQPSiGVh0JQrFPiICRJOlgr8D0LqsRLFvzG//Zz3L3/Xf7RP/x9WqPwpMRogZI+noyRUYgVDUJWqDDjxgt9rt7o07Y162ULesBiXvHyqzf5N//m5/l//We/g+dF6Maj0j6T3j4y8CiNxu8IDq8NsYucOGo4fnaPV14/ZHpyzHq9phP0CHVEtcmRvqLT69KIxk31lcUIjdWajg6QDehKM+p8ugDCf53rYup9oZy4KKz/5HUxZPrk51ywFi4K9os90m4VmlxA/6wr9DK9TR/YOAVP0knwPLfvOgirRDcVylhGvYR+t89wOCLLGs7O50yXc64cXmV395CyKpmen7NazOgPBy7hxvMJo5i60sxOT/E9DyUD8BSur9pikRiaLbDYRfJJLqL5xDbBxF1SuulvrQVV5dgvtfAJlEJFHXRZU9QNKXo78bZIL0AbQdNYaixWOR+4m4qA1Y4+oqRCNxaMR1tb2rZCSh8v8gn9kCzPSIs13U6PfhIgkLRodFNhhSSQzl6lpcRWDanWxEqgAh9tNeiWJIrZ5DVVVbPJKtKsJI4jlPIIlMEIp6hSwhJ4LokJa8kbTWMsHS9ECkikYeAZJh70PI3PRXybuYTUXRTY7VZibuylvZw/qyb9NK6fe+H9znrNNK0phZM2WCHQtFRim59n5QUx/4J8D3wMS7g4iAghthmo2yB57bqoQaDA2MvuV5I4SuF0OiX0fQaD/la6VdLpdJxMU5fUtVtgnvL54P5HbNYVedqSbQo8AU1VMp+1vFsWWNGwtz9k78ohskoxuqWua5Ikucy1NsZQNzWDZHD5/y1XK2azOculO1w9PT4lCEOGwz5B4CSkQeiz3mwIfQ9jIIk7JEmXpm7ZrFMELppIa72FdAiXCQqXG0gURi6TvHHdoIs/hXC+u1Y3WAyery5lqm3buENd3aCRGOGRlSWbqmVd1OS1wWiwumW5Tumv1hzsT9ikGbIp8YAgcLeP7ztIgueFWC4Oe9vJND9ddF8W2D/jXvlkYX5x/Uww2/+fTLyvH8UcHL7FnQ+e02oo8nMePzvhdH2FKl1iRcirr73B/+cbP6BKPWrTuillVaEbw90P7iIkvPrGK7RGU2nNfJ0yXS5Iq5xHd54wzRa8eGuf2fwxQ+nTHVoOX77OP/rnf8SNl454+8VbHIwGfPdHP+JXDq8TJh1ee/llXn3pVT648x7nxw95+aW3EL0uz54848rhNaJoyMnzU2QnZFUIdgcT8lnK9OQZu+MOHtdI55q29vD9gMf3nnLy6JyqbvjJe8e89MqaTn/EpljhB/ClL7zEvbvvcO3A53f/4B7CE9y4dYVbLx4xX5zgeYqrR7fwfJ/z4xmvvnSbm/vXyJZr/MDHCOMml3GCa2+WBL5gsZjTCQOuTHq8enNAKDTNIuWjx3dQQ1gu7/H6q1/gq1874n/4/W/ymS99FW0l0gaAxgu2ER+tQW33GeODrirW8zk3X3yZP37nJ7z5d95ikJXksyn9bp+m45NNZxQ6xzcNnXjEZHzEfLXACsl8kXH2fMXo0BD4PlZIjFaIrYTH+CGnZw2nzy2TwQFtHXJweIX9AeyO+ozHA25duY4Ukkn/TdIs5bd++59R6VvcvHUN3/dctmvbEBrroG2+wgrp5L1tjZYuezXXmnfPn3C6ytn3Y6pNjtEp0pNEnRgbJpzmFZ4FP5EoY+n2e1w9OmC+TiFwXqoP3nufMIx4/vz4U10jO/tjyiolrzTCa7h5+xBEzCZdIf0Nr33mgLqV5FqSZifk7ZqzzWNa07CqzzFNxcnqmKOdF9G+5vHZI3KZEnsdpqcP0U1BEHQoTU2n18cPAipdUpmKfuxz++oYKTVVZqiLislgiPEsjx+fc3C0Sxh3KXOJbRVR2CVdn2Eaw96kzy986Q2Mafn6179OUVa89ZnXiSIfi2Rvd9fZdooWT0rCTofd8YTPfOYt/vE/+u/JNhl5Xm7ltIayrsmKnKbWaGMvCcbGuH1Za7P1wXrbBquzQXn+dqIjFUbrLZXXKYuC0Fkpqi2J+OKQKRDUlWORaO2aoHXdbpVOIXo7bbTW0V+lFGTZhjD0UcpHeQrTGHzfTSitaZECrJRoYymqFmsdb6Cp3BTG8xxl14G0DFEUUhTukBTGEs8T5HkBgU9pliTdPqtlwaap6EUx2liwbnIuhMSPeozGMZvVknVWEsoAXwZ0+h1UFPL45BSNwcNFxUihiCNBEhuKNKVRLeusYi8cIbRBGRcvNFsXTHaHZHmB7xnqJifPUq5c28E3BmNbAhV+qmsgDGMHRpLOmmWtZTSabOPbljx8+ICkF9Eb9LFb+Fin16NTl0SdmFF3zHK2oWk0VdM4F5cnMbYhrTJs2WCsIE6cb7ysKmbzucuQFpLQDwnDgNYWPD99wvlSczJ7SlNDGHRpTYvveVRlycH+PmVZMptOuXXzlqP8tjVt69SF9+/fR2vNtWvXMKLF6JbPvP0yZw83PHk4I0k6GO1R5AUXeUZO+qsQ0nNeZqWQqkUatvdb4ArTQGFsSa/vmjSL5ZQ4SgiUT5PX9JMObVu6ol5ootinbEuWqylRPMCZMQxJEjn+zJa1I61BqZZWVigpMbqlLDKaZnsmHHXJ8jVR3yOIPabLM7zMsrM7RASC2XrNpjon6nQJw5DlenGpdgzDLSTXSpQKiMPIUcI9/2Pw1/Z/fc9jtZ6RFxvWq5I3336B/+F/+B20rhHCI89bAl+hfWcBCnyfstmwuzvkxs1D6jqnqstLAK8xhiKvuHFrj+u3etz/IMVTfawQZEWJESHrNCWMDG1bYnXB/sEOcbfi/oOPKKuVk+oTEEUZB0e3scZiG0uZVVSbiqgXokVLledc6e4QKA/dNK7g+Qu4Ot0OZVk5doXYTrovLBxKYuVPF0yX58ILKNllPPHH0+8L3pDcMqOMte5rbZWZF5aIvKxZLFf4nkc3Seh3u0jPI1ARhm1dYg3DUYLwN3RGO1w/PGAYelhj6PU7jMdDyqpktVgyPZ+xf3hIEIZk68ydt61AyQDlR9imcYUvArlVBzuYmvMmX5zxL2KEhbAOziagVRJjJVVhKMsKT0mCQKDCBJ2v0Rascv711liqpqUoDEpbjALluNX40kOGkra1sD1ztJWhtU7R2hroj/qEYUJVX4AUt8NR15FFKAlKOYJDbWi0xtMtoRB0gwCSmFpYEAGt8fD9AnI3KGyNRWtI4oTA9wk9RdPUSCHoRDFSCPKiQGuDNlDVFRENgdcyCBRDr8XHWQ0/HuCJbZF9wfT/eBjoItzcs+znef3cC2+/O6LZnGOEwljjQAXC0G5vdYlCGLCYT/zQOKqA/ERWt3IeIOdwUC7M3XO+odY021+apChqjluXn72/M8IaQRN7+L50XgVr6Qy6RHFMkRecn51z/PyM81lGYwKsUARRQFmnYCErG5q2RHoF61VLP3BRLUK4GIjNZkOSRGhj2Kw39Pt9wiBkuVxRFho/iPnRTz50lONNjjbt9oAjGI367O5N2N3bweoCgWC1WZP0O2w2G4qyZDweE8URdVNRNQ3dniOxX+SABkGAFobK1C6r2Gq0bmiaCmMt2mrqqkS3LcJCVVTuEOaFFK1x03cDRQPTVcYyq1kXDa0GpKSyDaooOH8+xdMuvqkTBsT9IShBXtSYpsa3AqVCWl3Qqi2l0Kht/I2+BBZcZAtum4p/ygP+yetngdkuPuTj3MOL68/fc/Rv/Z2v8uMfP+Sv/PoX+OH37/IHv/NDqCa8c3XF1cMhr3zuZb79zg85XyyoipDOwYR8vsQ2DV5ouXbtEGUVR1d2qWoPw5is8klzWC3WaFvQRdH3Ar71h9/k1uE13v7s29x9ckqzKOkFAwrt8eB0xvDaVbxxl1Jp3r3/iHsffMS1o13290aoNmQ1rUiaXU7vTrnxUh/pScb9Pi9dO8DHovyKo70BN69/nX/6T7+JLho6nT7vv/M+L71xi2/9wXd5fvKU1jb8zu9/C6E8J19CUNRrfu3Xv8jLZ2u++d13OM7WSCz9bh8/kNy6eYPpufM5ZnmBp3y6vS6r+QwpJVlRUNcV/eGQuqop05I8TUk3U/YiePmFQ6zN0aZmOLG82t3h2isDivYMKY/5zFtj/rt/doIQFUlHMhc5yvNdlJYxCE+it9nCwsKgN0G0mtHRPr/7B7/Db7/zx7x84xZRf4dZtuasWiDaHB/Y6Q7YG3eRnmE+O6PJS0bJiGpj6d8eoOQGi8ZanxaLlQ1WxByfNFRln5deepkHD55yPJvTC/fZ5BJkyTd+/3/m61//KjvjIbv7R3y9+QrrdEW2XhFGvst+lhaNwDTQWjfxbLOMqO9RaVfUKSTluqKsLU9Pz+mH0IsVVluUlDTSIlVMEEVsrKVsNR2tWbctszTj5otX+cKXJmzKbzE5OOK3f++ff6prRFHRH+7geYo0s7S0aJ1x5fAqSZzz9Pge48kuQQndyQ5VuYSo4Xx1Qq0rjMnZ6A1N2PD0+DGPFvcJ+4aDwR5vvvkKVm8QQpPVFWezU/qDMXESglZssnPqOqLKGzwZ8vnPv0ZdVPzovfu8cPs6vX7Cu+/9hK984WtsVhnLhSHPn3Dt6oBf/upXmc0X/Dv/9t/lxZdeYb6cc+vWLUbjEXHSpZNECCxSQOD7KM8njEJeefllrl65QrpKLxvHxgpW642LddzuU8ZYtDYuusaaLePD+bEvmsjWWuqq5YJt4pqmrZsa6BajzTbB4qLYbn5Katk07aX372LvdEW4di5BIURfTVMAAQAASURBVAgDn07i4fuK3qBPWTak6ZKmNUShIo4Cmrb9uAG8HQmIy6mAQAiDEoIwVLSNO/x5XgC0BJFgOA5ABjStxO91ODudsdys6fT6CF+TVSnjyT60gmaZIhSU6zW9foi2NVUtkEFAWtZ0fI8yy1jlG/YPDxj2OtR1SbfbRwjLYnmGjASqjhDCd410ZRCqJYg8SpMxW7WEUZe8yFEITKt5/OQZvZ2YysD6dPaproFP8lcuZK5CCI6Pj5lOz5hMdgnjgNYa0k0BnkQoD93CcrmhWT4n3+QcHO5xdHREWaXUdUFRZmTZGqzB88JLknWeuyb8ZrNx8m6vpjELNtkp1WKGkI3LWzcaUxryosNktEe3M2AwGDCdzbBba9x6ndHtJgSBYrFYXGY5XyTEpGlKt9fl1379q9x57wnf+L0fEvr9jx/0bOW+8uN86Au4qxBiSzj3MbVBSoNS8Prrr3B4tIfnCacw8SOKLKc36LrCS5c0jUuPsVt1nx8YlJKXRG/P87b2N8cECgOBaRy4LisLat1iBEjfw5eSg5t9zjYbfF9x9cXbtLoiTZdk8zXD0YCDcZduv4fWmufPn/8U7dv3fZAhFoOpG7SBIq+o84LOIKSTJGRlhVSuwVU3NW0tuXXrOvv7u5w8W6NUTNtapGiRoiUMQwcnbGAwGHDlyhWEdCBgp1ipKIqCuq45PDzkF37xi5w8+TZFnuN7EVm+QZsK6dUkHQhsC7p1HmUheOfdn9Dt+/S6ffKiodsdkxWWvcM9Xrz6At1Rl/lmRkNDVqYgodLu+0Ipyqb+VNfIv+oVhA6u1TYBzTa7vm7rrR1VYVtHI5dSoqTcFq7AdtgjxEWxDdaabWPSEbGRjlOx3bi3+6q5LMisseS1gyEvPG8bH9dzySN+iB9IqrqkrnMO93cYDHpOoWbZWjDd/d3r9+gOx9y/c5cnD55w5cohmBZfhkgkQdCjaiSgwAjQrfMwI5BohHQTbwm4pLSL6beLVAaLJwS+EtTKsGoKmkbiaYUCVwQ3gFEIqcjLlqYtyHJDJ4BJz6cXKgIl8KTEV65xoI1AKEVTpGjrMtOrXFN4kt6gzyDpUXsBURySdHuoIKA2zjJlBA64FvhkaYnnQxQramWxvks4WBc5RvgIBdKT+FJBY/Ckh698bKuJw9BJ/QW0unaNItMSKvdsarXBSpDaEKsAz7hY6m1rgotX4sJixfZrXZwNL15r83PWmv/84WpZ6UBa27cdgdx15u22ryC3KHwkWOHy1Bwu330MF94Na7cQDvmxNEBr2u1DzSBYZQUCWK8sRV4zGQ7p94ek6Zyk20EohfJDtBFkm4Ik7hFGHcomdX4hKfBxDz65hTEoGVIWhkePznj19oTpIsW0DVHkutdB4DKIk06MUh55nmG3PnQ/jMkbw3Q2J1Ah1kCWFXi+IC8b1mnJJi3Z2x8yHg8RXsD5fE5Tuy50VhQYLJtsjdZ66yW3pJmjevpBQNVUlG2F9FygQl2X1HWJCDwa3Ww9hIK2sWzSjLzQWF9SphmlFhgr2SwzzuYpaaVpLFgcaMdi0K2hymvStCbpdFilKYNuQbFZk28KfC9EDIcoT5DnKUEs8YOE1gYul3B7k1+c1S4VDv/aRfdF4a24ABH9RcrNc09zmk2Jdw555e2bTGfHPLn3iD/+3gekr11nfHiINYpyVXJ0eJNxpyS8NWE46rB3fZcXXrnN3mDI6aMpWTVHqIiqzCnmj7mxHxJEIxabJWf3P6TKa4TXZbnS3Hv/Kc2yYnO+ZDDuM1uXvPmFz5GtCnwVMp+tyMuGp8/PuX37Bpu04r/6L/8xofIIQ8netWvkRY5Q8Llf+hxZNufBo7s8f/aEV196i1G3w3q9pChW7ExGRMrnjVdeZzQY0pSWD+8+IOp2COIuyu/wgx+8z5W9LgeTI2Lfp6k0i2rNg/tPeOszr7FZFbz37h0UAb4KuHX7FmVZbYsOSxRFW7KlpMhLqrLl/PiYwNOEQc145CNZEfoQJw2doc94qEj6E1qzYGfkBuX9XkQn9rHCUDeVo9paSWsFbA91CMuLL9/g9os3eJyd0nthjzvFCYvTlslgyCxfsWwa2s2al1+8yu54Fz/w+ODdd/jo7kfQGgKRUKSGbmeAkimmrZAicnIwJWh0yPFxxeHRSyyWGcJTfPTgMWQaTInRK9arc6o6pzUhp6dTrl3bxeqdS4ZDbWuEUhgEnvSIVEQYxRg/JG8KKmFQUqC05HC4y/HqIW3dMk83JLsjhr0+1gaUlUZEETUK4Xs0UpNVFc9WKxbZhvrRA+rGsn+wx0uvvMR3v/PdT3WN9LuGKPY4O91w88YL3L//HnW9pNntslkJmlownz4izRWHN/bwOhFZtSZbG0bdIbr1yJpzfvLgW/zkvQ/wk4hf+Nwvok1Kr9MwHh3SiYfce3Cfj+59SBRUNHXMYmpI8w1J2CEMhpTFmj/65jddLKSakK1X9Psxg9GQZydPGHXGQMG1mxMGVwYcHIz47Oc+xy9+5Wv0ByMO8jXKk2RFyc5kF2sMRZk7aaASKE8RRQG3bl3jP/lP/s/8F//5f8G3vvkt5osFab5mNBwjpWK5WG9lku7e9wNnn2qaLbbnEzaaIPC3cCA33TBao5HEcUCWtfjKNYGlqImikKputoRxd/3JyJ+6rrHWHSouirQg8Oh1O3Q7CcPxmCfPTrYNAefxa7SmG3fQ2lKWzeVBNQwDjHb2EN+TCG2QVhAHHmVtSFP33Io7ES+9csB8OmN3b5eyWrvf+7CDtprWtmzSypntpFMrbDYzJjt9yqrB80AKTatT4iSgqEq0cokMYRiyTucslnO6aUG6yciKFd1hD2USwiQEA7PFEhkamlUJnmGVpyStJfK69Id73P3oPpMrY3Kvh9UV3fjTldFeQFgv2Cr9fv/Sq3pwcIhUDQZDXf1/mfuzZ0uz87wT+621vnnPZz55cqyseQBQVSAIAiAIUlSTVFOirJZFye5o2eHuULQjfNEeLhy+8x/QNw47HLZvHHbYPUhNSRRFUeJMECBmFGqecs484573N6/BF2ufkwmIkqVQlagVkaiqgzyZ+3z7+9Ze7/s+z+8pWC1LVlWBjEOm0yVtq7n83A2kk+hWs8pz+v0OvX6HxUJSFEuyLKOqNIvF4iLuKUk8O6ZpaqwrWBUFp+N7hFHLaLPL/v5lxqcrytxRVTW3Pr6DEILJZIEQMBgMOXx0wtWrV8FZVvmCyWRC27YMBgNOT0/9fl2WHB4fcnnzBr/0K19jNi35wXc/wE+f155Q4SW550X3OZzWObeeTIdop2lNTaeX8uprnyEvFigFSRpTFyUdGV1cw36nj6gElSnpdDr0R0Oqai0XXU8nz6141lqMNcSdPs4Y79utKqIkQhmNkdC0mqq1iEgRZSlOKTqdIWGSgXB0spSyWiJy73/31kX/s5dliZSKbtbz0U2twTaaXtYhdj5GslzmVG1Nb9SD1gCGbq/DwsC16/vcu3Oy5gZFROEaGIcfNgVBgHWe37M6XpBlKVmWsbm5eaF8nM/nfOELr/O9b93mvXfuYslwLqAsW5yoMDZko5sSZykEkudffgktF8SpQwqFlDE7W5d4682PCJOQxWKBjBXD4ZCP733M8dkRYIm6XolVtjWlrj/RZ+TfdMlQIVEEUUDsEowxFzZP21rPCrAGg8GsC/DzqEa8G+ZiPxVC4YnWZg2SfAwDdOZxqbYWKaONj4lEKbqDIaONDbKsQ2M0k8UEZzU7WxtcObhOuCbUO6Nxbi0HV8JHlDmvulMyoCpaMG49dXU4F2AJMeuRs3ICGxiEC0G0SDRCWl90W08UF2v6pk+JEjhnCBDE0tIEklZojlctqJBeEPiUF+HP+AZJYwXLvGIqWtJIIkJFFIUEMsBYTdvWaO1ojUC3xk/DHeAsprUUyxwlJJ1ul06nT9xJSbM+MgyIpfdO122LkBAqiQhCjJRUziJbTVXXtMY3KIMkpbaSZWXI5wVtbVGppK1b2lo/ro6FoNVe8Zt2UqKmxgqHDSJoC6JAkMi1atquo9nO1dPrN1bi+xpSeNu8Xce3OQRGfLp0tU+98J7kCxrnsFIgVehzfK30ZD5hQK4jcsS68+CMf1OF7+l4fwMY5/1uoTrH53twksVPuhtt/MHX+SB3sLTGsSgqBmVD1h2SZDFRHNE2mlZZrJMEYUQQpbTGok2LDB7HdJ17qqWUtG3Lxx/fIl8eEUrLoN9hMNogSTOUEAgV0OtkrFZLitzLRqaznP7GPoNBj9PxAoRESJ9bp42nCdZNy3JV8OjwmEE/Y2Nj5KE9okXgKMqKum5o2wqlAhYLH+OwKsp1VFhCUVe0ZU0nyYijhOl0SqM1cRIzW+asao1wkrN5QdMYWquoipbZasUibzBOUDeaVdnSWhDKF90YR4DEKEGJpmwr31GrKsZ3H+DygiiMSXqKoC0xZQ2LKWoJdLrI7sh3jySAP2hiuJjAwI8X1f+m619XsP/7XMtKknS3mC9WNHnOF7/0ErGyrOYN907HNN/4Nq+8+BIb/W1C5xBByRc//xQv/9SLnDUF8ybnpFgRdCyL2W26ySavPHeJn3vpl1BRwbKe8tzzL3I4PuP3/uiH/N4fvUlrFIvJkq1swHY2JDCK+UnBo3fO+MbXv87Tzz/NqNej3XAcnhzTkvLf/3e/yayYcv3mNa5dvkErJHle0GjDN771fe4+/JDPfOYFjJH8/X/wGxyfzBlsbmHMgv3dAWfHD3nvTUd31GWR56TDhMOTQ15+5UXmq5zf/b0f8TOvv46ctrSLDFtLhIRbH95nZ2uH0/Epjx4cYo1EuYAbN26gtaZuGvpxj+VySdPUDEZDqmVNWzmm4ynClgz7IVFYk4SWQFiSDGTgwJYIUyIx7O9sk8UNy/mMKInJOgl1ZdEtBML7Da3QWKe5fm2XX/2ln2dSz5mdHvLsc09jo4hJVTO+dQtd1gTdAYENOHxwzGac8fV/8XsIDS88/xK3H97n3vvHLFZdrAwQcu0bIsZZiZEJZzPJm+8+YjzdZlWfevVJ1PCwlVy5tMn+wWV2dzOOjx+yvZWhhKXKFx4cWVV04hQpveQ4CBNc46F7gVA+E1hBLSGWknZeszobI43GmJpysSLYHHHj4CqHZ1PK2hDHGTaJKIWmaStu3/qY+XjiI4aSDlEQUjYl73/wDoPBJ1t0XLq8zdHRMU2ruX+/Ic8XqKDk9OwhnaxD2lOoAFaLiqP7C0ZbkKYtw80eVTGjl3URYsVyOSZMDJEKuf3RI5JuTZLk3P7wLnuXrjNfztna2EabnHxlGW1t0GkzhpsDqqKhP+zz8P6SxUTT6JqNYcyymBKlGSenh3TjmFV1TNqzvHj5aW7svsDVq8+xs7ODCiOCUHB8/JC2aZDSw8OklFhjaXRLEggCBca2PPXUJf6r/+rv8Yefe54/+IM/4P0PPubXf/1vcevju/zWP/kd8rwCPMejE3epmwpzcZA9nxKufdP4mLAs81FkxjqMdQipaFu9bmqKi4L6XN76k4kQ/us+JxnWgjKpKIqa0bCLQzKZzJmM52hj/eerE4TKk9edc+sMWUcYShAGqaCfZf5aWEcnTajqch1oYYkzSX8TrtwYUrSPCETDbD7FuRCnLHVlSeKM/Z0OaRIwWeSo2GLLCm1DtDaMel1cW1MsV0jRQaEwBoIAxpNDiuKMrJORZhlxkNI0JRJFXRfEm4rFeEVRlUQqIs46NLpiMMxQTlAXLUk3Y7C5Qdm0DFxAqOR6mvrJrfMJ5Tlpuqoqoihid3eXJImZTk85Pj3m8PiUwebI7ytRQBgsKYolUZQQhiVHx0ccnxqGwx5PP3MD52A2m9HUgl5vSFV56fTW1har1YrJZEKaJnS6HYp6RZxKHH5CPJ8tiKMuwikW44Yib1BBQLfTXTdAG05PJiRxh24vAee4efMmWmtu3brFYrFAKcXx8TGjTp/58oh+d8jrP/Uyb735MW1jkUJ5ZYXzUnN47Kk9jzMFqOsKZzRpFvH88zfZ2d1kmR+xWs1J0wjpAmTQIev6HORlviCvclzgCJIAAZRVhRDygmsTxzHT6ZSyLMnSFBFIiqqk0i1RlpLEMVm/h7MWp0riTkZ09z66bnCtQ0YhoVgD1CrFcpGjTX1h+Yvj+CKzXAhBpBS6MZi6IVYBSRBhQohVgDMWJyxgyLKYbjfBaMXu3sCT1Pk+URSQZV2isEsUdtBa+zi59ZYgpWRrc5OskwHQtj4jejwes1gsGI12uHFzl9u374JrENJgDKxWJc4FJIEkTmLOZlOmyzlZv0unF7Czs0sYpOha8Nprr1E1FaenZ6hEEaSeTB/HMca2RFkCgSTuZt5K8Bewzu005/vbeSMniiJvxaiadYPxscXx/Pc4uICqPRktdv77zps1T8LWznUbxlkaremNhmzv7tDr9XDnvvJVRb+TsbO9RZrFSOml6sa069crIVhXq1rTVhXlskbnNXatxHNrppMlxKkQqUJwGqxGOo0QIUrGCB/2i8CinLfnPP7lJ97OeaCZs5I4VITK0uqasq7RgaMnFUJYrDAXqtiybdG2pWwFSShIVEigQiIkptVURemTn6WHI3IeXakCnPM59ioI6Wexp79bg20tMvSNZWc1YZiQpBmgKIqGSAZEQlCWFXEYI4KIsm6pqwZrzhvQFt004LwFqW5qyrIgSeJ1/e2bGUJFSOUbEpEzjDJFopwnpzvjlR7u/B19TIT3jglfRwp33v7wn5Wf5vrUC++udbhA0QpFrg3OnRfU3rvopMMIgTUQIBHGYQXeG2DXhwghfPFmLdiWQFicUuj1A4MDJwXt+iGrtSFLQpZVzb3DE7JOwnbQx5YNaZbR1IY8L3EoxtMFdWPoDwYcn84Q0mJYB6lr/WOAhrbVHJ3NEU7TGEdetizqnNGNKxhdIaWgLnOcACMgTDIarcmLnCCQGG3WmHpF27QEocQYhzWastQ+luAsp9s5I4oC9ne3fDa4ErjWECcd5ssVxgfrIcKAojXkRY1wIc4IiqJmuSxpjcBULdoJWhHS1pqyKKkbTdkaVlXNsiopWgHCHwINCifsRXyBtAKFglBiArBCY/IliTHk0wmBhrAniESGNQXNaoZbTH03ra6wSqGyDsYJjBA4PAHXnfMN/g2K7j///3MX3/8XuR68O+Y7v/8Wn3/tdcrVhJdev8I38ylOpkzLElWHnFQLXnj9Ze5/cBtTTcnnd8DtI5XfLMpiichnXL1yibaasDFMeXYzYbJc0RsEnB29TZJmbI4Eo0HMYnHKc8/dYDKZMTs65eGjY8YfTfm9H3wDJeD+ew/4+b/yNY4OJ5yeLLh95wRSw1d+9TPs7e6DHvD22+9ycnSHL33xy7zx/i3yes7PHVzlzvt3qIOIz3z+FZ57/ibPPXuFf/Tf/jOsbrlx7SpZL+W7P/in3HjxCntPPctXfvbzTO4+4M3xMd/65jv82Z9+zPtvHoERRJ2Qpmh45633CKIAZxVSeDDYaGNE27Z0Op017KTGmAaH8xM7F2BaizANe9sjksjRlCt6wx6INZfABF4BIyy9bsqgb2lbTRRlXLp0hfv3jzDa+wgFDhUKhBJMjs64/fY7fPlrX8a0DR88fMRZPuXS1RugQrQqKFeSB+8/4sXPH/DW997k8v4eV/YP0I1jb2eHB7c+ZlYZTpcl+8aRxRGyljiRot2Q+8eO07ljvqyoakMvjSgnEzYu7fD805cJgpqrV6+gZIOta0KlMNoicfSyPqbWyFAQBwGmbpAiwOgGKSMcjtPlgvePH3JltEeXiEQ4+kpQasNP/+yXSQTosqRYLFFphtY1RdlwPD0liCRvf/AhSkp6nS6l1VgrWZY52hp2D3Y/0Wdkc3iZKCg4jk7oZCmOKUIY4jhCKo2jZbEqufnUy1RVjXJL4iilRTLcGNGJE9rKUlcNN69dY7lq2N3pcXi2IHADlDS898F36XSGKHoI5acXMigwtebs7AxjKvq9Dv3+gMnp3B/MTMD27h6T+YwkFCzmh2SdgLYSHFy5xJX964xGo3Wj1E9FTk/HICOyrEPdlCjlJwBCOKxpUcJibA22IQktP/vl13jumct868++w1e+/Dl++S//HE8/dZnf/M1/xq3bD6lKD5GxZn044ycn1OeRYT5e6rxjXxQ1UgpabWi1QUqoG+/DDYLg4nAJ/zIj43xdsIiEYDJdcnTsc9SrRq/ZK45WWkybk8bh+qBq17LmCCEcujXopsVYSxJFtNrR+sE1oVRs7Cleem2T7rBhu5ehdYVUgijqYtqQ6XjK88/uMZ0eI7SkqSpM3eCMJI07NHXu5aMuIV/lbIxib/PSltpWvrDvD1gVJda16EbTzWLqpsI6qNqSwUaXrBdhpSPKQs7GXqJbFzWJiMhXBZKGYX9ApzNg/9ImH37w5if6DCyXy4sp7HmU0WQyQSk/VdTaUdeaw8MTDk/HRGnC9qV9ojDl8sEGbduytbXFbDYmSVOiKGIymVDXOb1+jzB47GkWQtDpeM5NVXlJ9tb2NnkBq3zio3J0wGqhfcOvgLYRRGHKYDBga2uLIAxZrCOxbt+6x87eBlmmyIuc+XzO8fExALu7u2RpSj9NMKuKVT5md/eAza0etz8+RApJGCmkivwAQwUXbAFj/L0ahiFGa1rbcnB5l2efvYmjpWlLBsMuvX6GsIqMzEvb8yVnizMIHYQCZSUof45Sau2mFn54Utc1eZ5TVRVVVbMxGtEZ9FitVswnS3q9Pr1el0EcE+qY56/cIIoSbly7iRABdaVpGsNkMuHK/lWMKi8m/k3zuMADoIY0SAmjGFM1PLp3n0gqnr5+g27W4WhxQuV81BtCYqwmTRXPPf8UG5s9tGkv4tjOi8UggLZ2ZJ0MrTXLZenZDpGf/nvliZee58WCr/zs63z3O29x/84ZmxsxwoVIIXDORzyJMKBoKo7HZ4xnp3QqhQY6nSHCBITGp/VUumI1X9FT3Ytc8k6SsshX5GV5cW3/IpaU8sf2scdZ8YIoEsRxQlWV62SGdcSd9qoHsf698OONyfP4sfNn01hvifVL4ASEScLe1cv0er21utZhTEuR52wOhmyONgCff40zF41ZoQK/n1qDabz9wDYGZRSutj4mU0gvk7bgREAQpTgRoU3jQdRYpPCKPcHjIls6A1bjnvynswhncLb1j0ggUUqClJSV9s9JHBBRY52mRXiwmZRYAgpjOVu2JEGLFZpMOlTjQDtCfPNVqOBCkh+FMUEUYnEX1HFd15TOosIAWolZZ2wb42HRRluEAyUEg04XXEXeGharkkle0RhFXTaYxqu6gsDT/sMoBuF81GRZIpX/HLPGggj8Gco2jFLJVicidBXC2QvF7fl6HMP2+D0Wbm0ncGtZ+k+wAj7p9akX3l+5tANRwlnV8tHxKXOjaaTACh9hpVHUa8K5dAFKCCosxkFoW39DOIV2ci1R9zI4bS0WgTH2QlIXhuH6JrcUTYvEMlmVvPvxXVblJi8885T/IDeO07MxR8djxrOc+aIAEaxlJhZjHmdunlPLtdZegqclbWNojUSFGXEYUlSaxWxO4Bu4RHHK0YMTwrjL6YNHnJ6O0S1YK7AWwihEyggEtG2DNoYg9ICRZlYzX5QEyjGZzNncHBGFirou6fdrwjhGqJDBcEhV1+jasiwa+p0OVkhao6haX0Q3lb8Ox6dLqtJ318pa0zpojKXQjto+tgH4a/f4nhNrf4QIJCpwZMLQNTUdZ1ABzFqNNQ3dwNHogqZd4ZolSAWlRc+91ETGqb/VxBNmCn688L4AkTzRifxXLX8f/PkHyn+fa/zgEYEWHN06Ynsj5srWJdpVTdFKOmmXZam5c3gfoy2Pxnf5S199lV/9j15HpDEnd0758O17bGcxl3sdnn36Oqdnp2RDRelW5K3m+HhCv59y+ugu1WzM3/mrX+H9j+9z73BMtxtxcjLh2999DyU7hE6xvdunOxrwwzffYrZcsL2zgW5avvKzr7KxEbI5HPL+m8fsbw/44uf/CmfznM7mBk9ffY7vvf0ub3z/LVylWZZL9vdHfO1nf5r3fvQR3/jGmxwdHtKv+jzzzA32rm9w9dltNjY1ZtXwX/yXf53MdfnWN+9gtCWKYuIwplpWREHGYDjk+NGYOE3pDzt0ux3/IdTU6266P3jVTUVerGgbzWw8o9eR9Duxz7cOJFI6Gm1prWcLjDYi2sbDlUabKafjUxyC+Wy5Zka0OBl7HsBapVRay/07h7z7vbd57umnGOiU/+d/8494tn+J7Z1dvv7WN7l3OMXVlj/63a/z5S+8wpXLV2kqT+EVUhKnXeZVza3Dlpc/O/QwMyMRsoMzu/zwR4cUbYYGIqFIHHzpK6/z2ReuEqiWm09fo21yEAHOrmMx1ryKQAV+mqGN95/aFutq7j14wHC4QZT2eHQ65cP7j0hUSm9zh6dvXqEzTTk9OeL69gaBgNkyZ29vk7OmpXA1SZTS7yQMBl2+8PnXuX90hDGGsJMwm87QztAW+Z9Lh/13ekZOJyRpl9lkTl3NKasxl6/2SFNLXVu00Yy2hsShZLWoODub8Pnd5zjNz4g7A7Qu0bVk1NtkuSpJIhBOM+j2uXLpMg8fNVjbp64c/dGAMBswW5x6DoUckq8M4+XHdDtQlA1JFmGp2Nvdp9/pU+Q5ulkgu1A3mijq0+tvkiQd0qxzoXxaLOasVgXXbxwQBAHaKMLAq5ckzr9PtqEqlijpCBSkkeTm9Ssc7O0gBKRpyt/7z/8n/Cd/4z/mD/7wG/zGb/w23/jG97DuvOj2+1gQyIvDYNPoCz/iuejRWvfEdPs8Bsx/Bp5Dg35yPTn5fnLfNVbQGp/d7V1dHqAmBOhGM+hnRIEkz3NwjkBFHhBnLEqAtgJtLEkkKWsvhW91i0oFT794iZvPb7F9EJNXU06Pl3z2cy+RrypWyzm9rqPXg9UywGhBtWxAO9Iooi40ug1YtJrd7S1mUYF1IW1h6Q1GBHaJNStvF+tlVEVBkzcYU6GiABusozIFtK5htjihr1I2dmJsIzkpC/KqoDNIWVRLgthn9P6LP/w9hoPsE30GVqsVURSt30+fTeuLYl9s3b9/n6KsKPKasm25fH1AtzugsdDr9ZlOZqiNDYT05xEpJUeHhyAMQehp9ucqvaIoePvtty+Ks263y2KeM10zZ6QKCVWKMxlVHbKYtWAhUDAcbrG7e+Cnfnipcl23zKYzWh2S5yvG4/HFZDCOY/oHB7Tlgk4vwVQpwiVsbQ24d/eIptb+9QUBCJ8HfR5V9iSZWkURUWA5ONin18/4znf+jMXqkNc//zlOTlsmpwu20m3iJIbQcyJgHUlqHCJQDIc7NI2fEi+XnrXT6/UYjUbEcczxyQlHpyfEccxgMFifHx1FVaHrlkGT8PT2Hr3eBjubl5Aqo1iUPmJwtODjxVu0kb/GVVUxGAwumlxGG0ITEFhFtcqZjyckQUgYh7RVQ41EtzVGNeuIVYk2jropuHnzBpubIw4fTWjbBkGDwKsBhPAU7r29PaIoYrma0OrGR1wKwXQ6JQgCRqMRQRCxuRnwC7/4M/z9/+b3qeucKOyRRMlFk85JQW805NrNG2yVKXkxoWxqaj0jDbqkTiIDSVmXLKslMl5nzqcZaSehjQxtq5HWxzr+Ra3zvfE8w/v8352DIFB0Op2L+//cB651C0Kur+vj4vsiKcfYx9wh3LqhKUnShNHmJoPRyBewOM9bqiuCQHL58h7dMEatrTnWaoQSIEPPrJISpw1NVVKtllhtiPB+Zdsaz2hy+JpDSLQDGaVIEaJsgHS+sSolF4pgPwn3Q0hnW7A+h106i7UaZ72qRD5xfUDQWoG2oKSlH57XUn76GwQBjgDTaFa15nBWUTaOfqwYRoKuSsDjsT0Rfn1PibXa6nw4WVcl1jWIQJFkGQRqzfXyzeGm0d4KYMyaMC6Iwph5viTPS8qypXWKumpwxpL1ekRRsFb9tutkiJA8b8micL0fKurG4HRLaBs2ooieMkTOrrkqrD/bWAP5zv9jfT9ZLuzQDsGnrDIH/n0U3gf7LFvN3BjSaslxXmCjgKyfYl3M/cmCKYbaQdxqIhGAhFJYEmHXnAMf9O6s934HWJ+5dk4htOtusrNo7bDGEDnvo5sXNUVVMtoYIIPYHxq0RcmY45MJx+MFBp9X57vSDoSXRZ0X3vAYkGKNQwUhq1XFnbsPubS7yWTyiHK14NlnrtNUC8I043Q8Zzw7om4snU6fxXxFYxriKME6jVl3fqWUa68rF7Ax5wRWO8yqpihPvNzCWcJoQdrJiNKEQWnXebEW3WiCLCQLY4y2zHLNarViVRYUdUPZ2nU7R9C2FiMk2kms8wc3zpmMT9av64dJSe+P7QWSvVixp0Dalja0NC4g6mUYBcVyjiiXBPjOm2sdIlfo0MtmZKAw6z+XJ6bdP+lDfHL9pM/7P7T1mVdu8tILn+W//X//Y6aHAv3Vr9FTHdpS8Vd+4a/x23/0mwye3uDs9AHdbp/Xvvx5jmYLHn5wjx+8d5/OYJc07VK2JX/8ze/xxhtv8nNf+Sk+e2OfP/zGWzw8mbC/0+eFp/Z59bl9JkdLXri8TZYm/M4ff5fpwpFFGZvDfUgcl2/sMFudcGPnGotyRX/Qo1hOuHHlOsvJKfffe5MP3rnHM089hWu3ufPoLjvXLvHuhx8TpfALf+WXeHD7Ae14ShT2+OH33iPrDukOhhwenlFVltd++nVW8owkDjg7fcj21oDp7ASXOkTYkmQKY53viDvBg/sPOTk6JQwj2qrx8MEwoGy9NLCuCuq6ojfoEcYBUgmaqkYJnxncSTMCWRDHIYt8TBhAnHmbibMCpQLiMKTb73H71owo6VNVKzZGCZNJhWtrAqTPVY5Sgjjgjfdu8f6Ht3n95Rf5Sz//83z1tc/yzg9/yBtOMFvVtBW41jJpFvzpt77NweVd0igkjBSRgSTLaKXjwbihspeITYuwBdoNeXAa8vZ7BUF4ne2tkPzklOs7ff72r/0CgZizWk4x5djvY2FM6yCUXs5rWs2qyVGBP+yEoaLRPq+6v50SpxF1a6mMo0WxzEs61zsMsghFzbVhl9j4RIVg1MMVJfNlQyQtTmhGnRDZ1ow6GeXWiLptsK1PHjibjtnf3V/Dsz659eiR9wc6W5CmPapCcvqoYDAIybod6kbR63Qol7mHxDjJ8dF97j04YdrN2d/ZwLWWvc0+eT7DWM3xo4e0RrExSNBmSj/LEEmfMFBMzya0Vc6qKigrzYsvfxH5cImUOUVdEiSKoBI4I9BVDbUhFAGjXo+wNqh0kzTtEicpnayPMe7CzymAzY2NdY4r4AxKOeqmAadROJSzHqajHUkYE0YRcRgRRgpnLYEy7O30+bVf/UVefOF5/vf/h/8j77xzi6Y53wf9hMp/rvnPHV9Mu4vPi/Mi2xfRYK15Yn8839N/fEnp5b7eJyvWyisvuzPWguSJWDOfVBEGgkAKullCsVwi8XnLtbFr5ZpPGkFAnIDSAm0ltg149sUuz77UY2Orw8nZPZKuZHt/yHI14/jhmL2dXXa3rxDIhDRNOD6ZI6QlzQJoQUo/7UhUSKwUvTRjYzBEOg/saYwiDCKOjo9pnabf2eV0MUYFlk7Wp21y8mbOyekRYQi1WxI2mvH0EFtDJ9lgY7SNxeKmY5bVnLAKCQJHoT9ZuJpcw8V021KUJaPRBlmWUVYVy+WKs7MpQRhhraTIS6aTOWF6TF5VzCZzdF4wHZ8iJRjb0OqIyXTmVXSmRbAiDBPiKEYFag1X9XGi3qOt0U2DQDGenCCiDnE0wjbKw1DrAkFNEIRkWXcND3NcunRA27QsVqeURYluNXGcsLuzw8OHD2mals3NLU5XE2SsyNuCQJS8+vor3L93wvhsDgjCICRJO2RZh263SxSG1E1N2/p0mDAQbG0NePGlZ3jp5Wf4zvcfsH/5WdI0w1rHUzeewuUQhAFRFqFiwXQ1QwuNEV5BVxQlAkkYhOtYPU0U+CxyrCMII6bzOWVVESepf26MpXEtbVUzPpqzdaVH0Fiq8YLp5BEfvH+Lm089x6VrV5EW5tM5zlmyToc4iv25bZ0aYLWmzAuqoqSTpGxvbFEtc2bjGXK4gUNghfWnfHze9nw+JUoGRInCWk3bagQtguYxX8e0HBzsc3Cwz7z2CTVpkhKEAVJJet0enU6H4+NjsjTm137tV3j3rbu89cZdnNXrwkTQ1JpVXmKcI84ywmyTpBdwdHREo1vSQICF+XJOXudoNPP5nO1L23T6GY1pUJGkahssjjiKPtFn5N/qeVoX2k9GhfkCU/D448s3s8MwIAgkbaspq4a6ri+Gaefny3MQm9baZ1evC9HeoM/23i7dbheQtE1DXVeU5YrNzSHDfo8wUN5bzXn6EoBAyABhDSavfFOwrhCcN9MtUgS0xhB1Ot73LRUQ4GSIigRGRGs5uUEKgRTnkEwL1uKsQboaZzXWtOtpt0EYvS7GwTnfBJDSXgA8jXPU2lGto708qloQSwXWUlsoGkvdlhSNQQ+6hGFMEguUqdC6RjSe7eFwtNLnckvlJehGGx87uJaAp93ORaFuAW0qnxGuBEEUMS9KpquGvDFAQCdLOZstvVomWFs9aktT16gwQsqAIFCkaUSSJBcxlsJaImcYRpLNRBHbBpzDrAl0Yt10Pv/14/fTutZY22Ef+/o/vfWpF96biUHpEmVaXt3qoTd7xGlIGAZMCosYz7BVgwtgt5sRyoA7qyVSOIZJQGschbE0xsMzhFj3XdbygXMAm3XCk4vx1DWpJBKBaS1JADJMqWqNrUuaquHsbEJZtbTGd049YTNYgxge+5HOPUmeoh4QqcB3p7G8+96HfuOqcq5fv4YVIbp1nJ7OODqZM54WxHFGv9OjWDUoWRFEXvbDReHtZd6tabCINVTOEwzbWmNNjVrDCApjmJYLWjtF33lIEEW0VqMU9B96r1W7KiiXqwu5VWsNGu+3MtphLB7vj79Ucp23uTbmecDPObhMgBWWLAzZ6SRc7aQMyxLtGqTSVCpGGkcxXxHZmrhtiNyaTu8cQVNiihUi7SFVhLF+45DOy9nPZVXwWPLz58WH/fh/+xf+H4LPezjq8eDBnOFmj8XRGT/4zhscjPZYTU9569s/5N7bd9joJtSzCcONiLfefZdIOcrWMi9zdm6kLNucRyfHnB7OELbLd753l0x1uXVYMi0kj86OCESHPDasjhaUumR44ybXrz/F3T97k1/9a7/C9771BuPmjNrFfOFnXuPB/VOOHh3xy7/0ImmckoQxf/xnf0ogY37xF75KICz3791lb3+L8eyEw4cP+Bv/47/Go4dHBEpx78GY97IHvPPGe0wWBY0N+PW/+df5Z//kn3JyOOFw9ZAXP/ML2GLO+z96D1e1vPh8j/2rl+l9NEPip031qd9kL10+YGNjxOnpMb1OB7kmJ/pcTYszdt3FXPlOcqhIkpAssWRJwmpxwrQ95Ke/dJP5bMnZ+Iid/U2Ma0BKGlNRNgWNDomEpm1ynr15nbuqICDl+uV9Pnj/Hnnj2L1ywJ3793BxxLRo+b0//Rbj5ZTawaKsOJ0tMEYRyoDeqMdnXnsJGfqu9KDbZ7k6paxLdGC4d2x4872Gn37xKbQ9QrPBn3zzLkF0GRVsEktL6x7y3FN7OD2lrM9QwqIIECrEGU2WdDHa72OeyOs/gx8ePqTbz8gGAUY2uARWtly/FodAsr21QxgGlOWKLJT0kpSyLFBpimlqdF2C0YD3W8VBQFWWmLain8XMli1GWOIoIgojVnnBw084TkwEE6pCkXYsSWKIowyMIhAZwoUIK8iLluPDE9K4v84gnbK1LUD7w7NzEXVV0csyymaF1ZYsFghRE4qQQb9HHPXRWlDOBVpnPHXjGnceHnP86DZ7W9uMVxUbw02Wi4Jhr4szirqoGWR9klghmpZOJDCVZtTrkiXZWnpovKRcawbDIb1e30vbnCPPV0gpOT46IgwEcewnz/mqoNfpkiQJSvpDtTMeqtQ2BdY64jBmZ6vD/+5/8/f4nd/5I/7Jb/0B0+lyLcc1F/ucMX6qgICdnU0QhtlsCW5NJ3eO896llOcTcf6lvfT8YCrE+b+zlvx6BZmfYpoL/kbbNDgr0ZFiuZyjAkGkIlaFxuGLbdaHniyTxFGAlBZnIAosX/vLz5MOVySZZiPqYmRNtWoY9rbYf+kah49uMT4+ZHMzpC5aolBStUtqU5J2YuIoJCBAtoJenFIGEbbK2djukpuWxbRiOjvDT6AaVGDpD1PCSGIUpJ0MEUDR5Oxv7nF09xihLFmmGGxk7G3vsJzBstKoVFLlJY6Kp5++yoPjO5/oM2DzFqMlYRLR7wyIooQoSTFSsagmdEabjCdTilrTtHB8eMZyWXq4XVuTZZZOJyKKUqp5w/VrN7m0+wx37z6g19um3+8znU7QQpEmHWbTFWFk2NjIGJ+dspVtcbn7NAuxpJ4mKBdTFhKjAjYu9Xhw5z2KxRk/ePM79EYpKjIsigWDdIDRFUcnR+ztbtHtjlitjlguK6xV3ProHsu5n3Dt7l+lG9U8uHufy89ucO25IWU9pykgDkPiTNI0c9pas793jdXKspgXaFGhAsvOlS43XxwRpA2ffe0lEI44ztCtYHdjF7sqcNYQRCGDQY+9zT3m8xlFVWJwrKyjP+jTVjWBVNR5QT2riLsxVVPR7fYIdmICJ+inHVyjiZDYRlPkLcu5ZRwsGLOi21lyNh7TTSOGg5jl9JCMgMxEVE1N1k2pFw3LIkc7S5YmqKokdZbN0ZBuNmIw2GVyvGA2KUjjKwx3QubmjOnsiPniBBUoNvcGzMY1O5dTbt2uEdIgpKGqF1AbZF2TdjXPv3RAlDn62YCqrtaKBMdwYwPnLIt8hVKKMl+xvbnPz331VcYnp5S5wzQNabhJlVcsbEs+M+hGImIFYcBgd4N2vccYrcm6KZnIsM4wn8+ZL+d+cm802jmatiVOEoqq+kSfkX+X9WQxJeU5v+I841uSJAlx7HxedtNe2ATOvd/WWlrdIvBFfNrN2NjeYnN7CxH487kuK8qyII0j9q9dI1Detm2Nwa6h0Orc/wxQNzRlQZ2XWK0JlC/nnFtzDqRCm4ZE9dYWVJ9+YZ1ABhFSxl7hgqeUXziO7doK6gzCSV9ky+DC5y1kizMSrPCydGX9fSU8eNkYQ2U0SkgyIQklSGuxxhA4QSolbk0jX2mLzCukACUihnFEohSmLj240HneiFtnh1sbY4RABRCEIYEUa+o6qECBxCsb24ZGW5wSVMZyMl+yKDQECYSgZIDVDY3W6FbjkvDCblVVEEYBGxsjtNEURU6gFCG+ztvMQvqBIFynYZnAk9uVa//cGgNAOrkeP65x38JdAKA/rfWpF95OtHRTj4bfCBVxEIJusW3DXicjubHNlWKBCEM2kj4SRfqgJk8E3azLvZM5RWtwMvA0QuCiHyFYy6PXnvF1YS6k7+JrawnDgCTr0O0NODsbMz68TyBDTs8WFGXjJ8DOIaXFaA34PEnn3AVoQSmFWku8jPbwt7bRzE3OfLH0ZNh5yWRRUZeasnaUlcahPKG5mBKGIcq0Xk4kBE44rDO+3yTEGpRjiaIIa9wFeVbKEIuktR6A5o89Du0sQvvuo7GaVdFyNl6SSEXkBBjjZZBKgvJFtQRYZx0K56+TNOcjaH+4MwjfkRKe8oeCYSflyqjPwLZENFjR0u0kHOxcocprTD4jDiyZc0h7TjC3uLbGlCW2KPxDJdfEyJ/I9H6y+/ik78JLLJ+4l9z5P39Cqv5p38T/ivX/+X/8Blt7O1w92GP7uWf5g9/+Q/7Sl75EXVqcLknSmCDuk4uaK/vbFKsa1YsZbW1woCs++PgNfuUv/zK/f+suH949ZX/zMp996QV+9O5DnEwxOFSyyYcPF9RduLZ5wMs3r3DnbAIuYndni+Vqxt6lEc/s7lK2S3Y2Nrn17j1ee+Uz2FYj4xDdKj7++Iyf+7mv0DhHZ9BBjSeEEp66fIVukjE/mqFKx9m9YyYPx/xg+T77l67zw3f/GCMsv/3P/zlaa7797e/Q3+tiyoh/+ve/ydGtByzGNW++cMqVy88RJQnlqmC+WKwPTyl11TCZTGjqhm6WURYFWms/OS4dZVGR1horDUJZzsaHFMWCzuW+9yilMfsHW2zuhswWpZdpVpZQRTTOECeht5k4B0bz9LUdIlfzwtVNXrxxg8++8jL/9Ld+n9bF/OiDh8RNxebGiJdeeoWz2Zyzu4dMVjWdUYckKmgbRxRIvvjF13nqyi51VdPpDeimfR7c+QFYR920lG2H3/rnHxPLz3Fp6zLf+cEtfvDuknmdscrv0wskB7tdXv3cMyBbfB6nQlvnp4lhiAwkKgwxztK2DflqThgpjNBUosboGhGDTUOaFmhrRACbgx7bwwHOGCSCOM0IopDUOuqqpqlqRv0hTRwzaUqWbUNd+c54KARJJyGSgroymKrl8v4lcArlPtmPhO3NLSa2QamKtjI0haFtKqIwIEoFbVOSBBl7uxuEYY/FPEDJBmMsvW5ImjQkg5Q0iBiNegg1Q4YZdbXg7OiIXtqlnwzpdgcslkuuXrrM2bhkNs7pdWLycs5iEoCIwEiG/RHVzK0JqTU7gy10XTIvlvQ2A0Ks/4xCkCa+W1+WK5SS3Lh+k0Apb9MpcvJi6fOqixyRxcSRJIkjn3FrDVa3qFBQ5HOqqqTTzUiimDLPkSogEJZnbx5w6e/+Td58831m0w/W/my3lu/56YhPFXU89/xTfP4Ln+XDDz6i39vgH/+j317Dk85BQ3K9l+qLAyjge9Hn8r71ZnkOb/OFu/frecmhWgN6/FGkbUtkAFEoMbbFWbumuEuUsiSRII4lxlU+psZZDq5FDDYlW3t7NO2cummom4I4VkRBQ5VXZLFAIekmKYEMqdraw6uqElxNIAKSwDdmmnxJP02Zz5fe5zzqkMQBZRUyLzXKeWXa3v4e8+WCqi1QcchyNSfpdAiCFIiZTit2dw7IEsnHH71Nf+squa0YbHe5du2A+ekZWRBxeevqJ/oMmLqlss4XOGFAYw0yDPz0Mc0ojyccn55xNpmilKLby1AioG1a8mVOkgQEYYpzllWek6YdtrcO0E1I2xqm4wWT6YLRqI/oq3VE1ILj42Pms5BwK6Z0LbPVEukSmspR6gqZRsynZ1RNThgrJrMzfvij7zMajQDQtiGOY7Z3ttnfu4QxhtvFXYyeMxptUJYlp6djNrc2sTJiY8fHVNarhq989RXy+YqjeyuqakUQQr/XpW0bppNT4jims7a+hIkmzgxhYqhbz5ro9foM+puMz5YcH59Rzsbsbm+jwoDVqsBaSyhjYunI64rh1hCEQGHY29xhIWe0qiKLYmIZ8nC5IOlm9NIOkZAs5xMaA6ZuqOY5k/EUab1PfrnKUUoSxSnGVuRFztnsCKsMnTjBFv4Qn9oAIxyxUQyzDt0woJMOSZMRUsbsH1xjdz9G147GVEiRoIKUIEyom5zTsyOK3LG9O2C00UWYiCiIaKVBG40TDf1BRpIKmqpgVa1o25Ysy0jDmLquL0B9m6MNylXFcjnlZ37mNX74/bf41jfeY9jroBtLrzNCUZGvGupKo5RlVeVY6WPVtG3IixVRGHlGQJRS1D4yrm19sWQFRHFMFEWMx5+sKuTfZp1PuN0auHXu+7bWXNgQz/eyx755sZ5+e66AT1Kp0NrzMLwiSDLa2GB7f484S3BSoJ2jbWpM07C3s02WRmsCuV77lB1OeWiycA6nW1xjqPOCtm4QzhGI9RDQurUFztEYQ2u1h0jb9ZRVCpABMkxQMkYFkgB7cfAVzv3ExFvibIRRHsJmbYsf2SmECHBOg2pBNgi39jFbQ20dzkm0FmShWEPafLEZCkG0HkBaY6iMYZoXSNvgejE7vZREKYSqaGofp2ec9bWMMagwJYojoigmUIEvLYzFSet92oGnmVdVSdkqamMpWs2q0UjToouGvGoQQqKUIFCCOAoQGoqyQEpBp5P66bq1WGORUpGGijQSDFNFLFuPS5Pn8DWQbt10xut7z1VhwvmmwWOn108UHZ/S+tQLbyEDAikQ0uGkxbQNeVn6YlAvuZ5lXE62EEHgPRIC9q9tU9qWk3yFS0JWJqJsLUJaAhzSW3suCi7fwVc/Jlu2a3mGFJbhoMNo2MfmK46PpuSFARURhhmCFmta779e5/hJZy9oeQjv69RG02p/c0rppdNCSozRtEby4PCMuNtFBTAeT1kWNQJJ07SEQUSznjZbd+5F8URkT29fT+idRCH8iWktZ7QSjPMRX7VpaazzxbMT3t/kHEJIL8WXDisMDb7wDqQkWuefn8evWefQTtNY60MIhDxXHK4v5vr6WYcLIEsiDjoZN/spdjZlFVUgFZmLGMgQIWp6WUgka2RjkcZ7aQUOZ1pEXWDzJU0U4dIUbRzSsgYePFlo+/U4Jkz8Off/uhjnL3bSfb7u3Z+QjTbZv7rBB299QFE03Hr/Y177/E+xcfMaf/y9r/PRO+/zV3/pV/n4o3c5PDzh1c8/y8awT5Io8smc7/7J97j17hGh62JawVvvfEA3U166LyQuTmiikA/GJ0yLFYMbW/zBn/0ZjehzejTn7e//Ll/6mc+ztbXJ+x8e83/5P/3fee2zn+Nzr7zKO2+9y6OPFxxcuYzQiuFoQJgEzFc5Dw4P+elrP4WKM24f32dxZ0UmYsLScTDYpzYSEYV0N7ucnU4pW41ylk4aEkh4dO8Rhx/PObxdEkcxb775kLOxJi9KFrM51ljSzEcUVVXF2dkxddHws1/+go8+Kr38SqkAgZeNNtQgHI6WMHI4GqxriWLF088fYNUJlw42mZ2ssK0/mKpU4qxmtSh4dG/Gz3/ta3ztV3+V4/u3CJxhqz9AuJhf+Pmv0c26/GedLv/iT/6QRkq2thREKbuTARwZNgd9nr9+wGQ8Y3d/nys7m/TjiN5whGgF3/n6d6jzmldeeokfvvt9xouWZGOPf/CPb9O2xxRtQNS9yp0PP2KYZfS3BvzVX/4qu5eGlPmcQGYYsQawBAoZBtRtCTSevO5aynJF2hlx+cY+42rKtFyAkZggQKMIhUa3BbbOoa5JUh9nUrjaQyitxWmHFCE4RV3WFxCUvKoQUhEpR1UsSVRIGIVUScrZaoHRhs++8JlP9BkZH9e88PxLPDr6kLIoSKKQXidmNOrT2pIk9vnPZq45PX3I+KwkjWO6SUInsDhbEicdJqdn7G1cYqu/ybysSNIUYzTCBiwXBYPeBmkUo5QgrfTaygB1XbAqLBrLzt4VGr1gc3/IztYm5XxKMc7pZQmpGGFMSyfuEgchUejj28warKaUpN/vI4SgrisWixmrYk6/f3UtIfe2nKapSeKQPM+JQoHWhjgJKEqD0ZrpKqfIC6I0QanQH8yUIwrhHK7mnI+68ZNr6dVfox4vvHCTn/7p1/jKV36GQCV89NEdvv2t711ca2P86UFJgVIC8/gTEuCiwHbOEQSSfr9HVVXUTbM+qIb++4VaSxul/wzSBhX6z8YwMcShQIWOz7x6g05maOuCuq4ZT3KcDHnlCyNk0DA+a0lTTSANaWBw2jE5PeLy7nVmbQ0WbFPSCTP6WUa/02VWnFDpGctlwWa/D42gm2U8enDIdDWncBXDtGG40SEIJXWtUWHMcrGiLkqWq5KwnxDImiCKybqbREmHza1tkkSQLytS2SENBlSVj/2UTlKtZmwOul4iGsWf6DNwcHCAdpbW+fvQSkFRVazKwpOSez16vR7T6ZS6rkmShCRJPNwVSxg46kpjrUYKxa1bt5jPC69I0Ia6qXDryKmTkxN6vcxHnKLY39tmb2eP4/tn3H90H40lTBMmixlBEtPt99gYjmjrJW3b8uDBA05PTy/o4FtbW+zv7tHr9Tg9PcWsI7nOo7qklPT6faRQRHHM5SsH3P/4Hp979RXymeW//X/9DmmWcnBwwNVr1zg+PmY8HjObzQjDkOFwSLfX4fqNbaSUVFXNKs9pW0MUemK+Ni3NeuI6nc+Zzf33pmmKc45VVYI0DIYD8jznTn6HjcGQNEtpyxqcp4srB+VqxXRVkKiAJE6IwhAhFVLHpFHHAxWfgLNNZhO0aTk+PKIzytjoXyKJY3TbItZUdtMamrpgEQjqxhGXBuFWNJWgKi3GCIJhiEtbWt2uz34pRdFgjc8yD8KAJOkQBR1P566htSVbW9v+LGosfRXjZEQWZyRhTO0kpYdcExhHGAasVjlXrt7g1dde4vvffQ/rWozRPn+9lcxmM5arJf3UMRqNLgpvnMRlhnzlM+CVUr44rfyEvSxKNP4z/RxE9hexfEPRraX4XPiZ16dJhFBPFOLrPUy59ff5AjyOI1qtfd6z1rRtQ5Kk7O/v0+v3kIHysOa2ZVms6KYJB/sjwijAWc/Q8GdXiRBrdpE2PsO9aSmXK2yrCWXg7SFYrA2BAGNrHAYhI9pWoo1CSoVoC4zQtDLEhBlKhchzXyZuTbd3CGdxwk/MBf71CK2xwgAaERiUNEjTYp1GhTUysAQiRDkfd1o7i7agW4d2EK8LUreuEaTQhOvQcyV9kvmqbXG5rz024xApIpSSSGewVvv4YuMIXEga9kiSGJykKRtUFADCqwdEiFQxYeA5VHGqcOGSRllsa9exmspbaE2DdY5IW5QKPOfHgmgtTnm2g1KSGEfiNMMY+rFDBRq9/uhTFw2Sx4owubbzXjSh8cwxt66P7IWy9tNbn3rh3fa66KLyWWquJQ4jMumLTRUqX2AaS6AsQSgp24Z+LImMotYJ/VQQVy2yabDisRz6XBp9Xij+WBG2Jmhra8B4T3NetVSrglLDqmpQIaTKA9WkW0cJOHvhl7NrsuE5jMG2fkorvE6Wtmlh7ZtrGk1llkx+8BYGh9Ua3Ro6SQoCD/LQfoPzPpDHcofziBEpJVIJTOtJzLDeKIT3ZZwXnCrwNPf1D3ox5fe/39PUvZzb+x5acx4z4JDriDatDcZZzBNAs5+8hufdoU6WsLe5QRbCQjfrrHCBazRmOSFsW+LQIGyL5AmPi1gX39ag6wpTV5gwwOLf858kDf74enx9/gO0dl+seNTjudc+Q5alvPk/fMSzB5f5whe/yvvvvcPbdz7gZ1/7LB/cucPv/MPfotNNWZRzXnjRkS8K0jjkSm+PP/7976EXhu3NEZPDQ56++jrDQZ9bJ2dEqaTT61G4FfN2SWVXfHByi3m95Pq1Zxn1xtweH/Pd777F9o0RV68/RRR0ODk+JgojqtLyJ3/wPb70VcX+/jarxZzlsibrJfS6Q9Ig4/jRnLP7c87uTSgmS37lF77E3/g7/yP+6//r/42qKQgiQWfYJy9yEtfy/Es3ydsl9WrOwaUdDm+PsS5gMOpwNh5TrmqE9XF/QRQxnYz9M9BqpHSEQUBdVyAcrW4wjSXrdEnjDkcPDwmF9r5FCVEYIdeNId/g0pydFQgREciUOIxpXIVzgrLQWA2bG9ucnZ7x9o/e4dH9EwwJURwynRwy7Cb853/31/mVX/wZWqX58NFDqrbk2ZsjntrfoK59znE67HF1Z4PNbsKo02F6NuZP//jbtLXlM69+lm4nQyIpS0trejjbJ68kw60djs/OsLpg1O3xX/zdv8XBTofVaooKUxSKKA5wQpPnC7S1BCrAWYPD0u93iIId8ipnMVsyaedYKWlrL1VOkw7SORazM67uXWJr2EdJgURSI9BCUNWNl+iqAIkgVSG1bTBryV3d1ERhhDENTd3QamjKEtto/uybb1Iuzf//G//fYs2nYz7+8AOitAJXcXpyxpWrewgEi0nBaHMTXVX0Oym6BeESHt49pXcpwmlYTCv6nQFZ0kUSkIQJjVNEnR7z2Zg4SEg6KbPFKUnUQbcN/UGAXVqsCrm0t4OTimVecHlvm/uHY4rFMW0/ZDqZsNPbYdQNSTsDysag2wyhLZujTe/L1drLzaWHxLS6ZTI54ej4EavVgmF/yHw+ZWtrQBzH5KsFdZVjTY2JFY22PucaR1mWzKcLJpMx165fR9MipCJLQj7/2st88MEdZstqvR+Li3SJwbDDr//6X+fpZ68TBArhDLPxKb008mKmi16tW/uzlVc6obEOtP5Jjoa4OIwESmBDDy4NA0+YVsKrksLQksSQpSFSCYIoZHNvyLyYg7S88MoGSs7pdVO0hcWyYjJfsncQkSSCTjZgOj1mOPL3/ntvHrGz2cG0AUnUJ0ti6mKJrlu2dvbAtmx1BwRJn0fuAZFs6W0Mmc8rrJQsqhxllrispie6KBkw7PVQcUrZLEiyiO5wg6PpKcWyZHPYo2kLigocJVvbe1QLRzftcX33Kh/c+QhjHRvb2yznC+bLJZf2r7I8mXyiz0CcJLi2oa5Kat3SOsOyyKl1SxDHxHHAzZs32draYjLxf3eWZYRhyGg0IC/HjMcnOOfY3z9gNBrhnPZWBhUxnY5/zKpSVhVCGqLIFwUf3fkIYUMu37jM2WRMqzW9Tup5MXHEolmilGJnZ4flcnkxEVwul5ycnNDWDav5gqIoODg44ObNm3zwwQfM53MODg4YDodIGZDnBaobc+XqAcWs4as/99Pcv/2It350l26vS7fbZTKZcJ7fHUXep7m1tcnrr7+KVIKiKAhUxHCw6SW+uiGMAqyEsvVxXiIKULFXO0VRxGZvi1L6e7aua6yQzOdz0iBidjb2asUsplqscNYRKkWrNZNqxnw64+zkDLs0zM/mbG1tMdrYoN/vUZYVja0ZbYzY3NogiBSBg9hJIgLiwO+xRZ0zN4bSOQw1rckJlAeB5k2D0Q49ARtppGqQQYMKnPcRbw0ZDAYopdZcj5SgMTjXYhvFxsZafVDVJOvp7tm9h5ycniKEYGdnhzAMKZY5dSBIkoiT04e88OLTPHXzgFsfztgYbCOlJ3MvlwvyvCAeSLRsLgpvJUPSILnwPMdxjHNuDSbT1HVFpVvqpiFNU7a3tz/RZ+TfdBnn882d8ywnACWl3yuFLxzPlZIOQAh/hgCfdrGWliMEKlCEcUSns81wOCSK47WC1FLkOc45Lu3skUQBytZ+wi4F1hiEkgjlz7LnEWF1WaKbFrl+FgPhPfkW78qxT9omraOqa+I0wa09tJ5wrlBBBNI3P8FPugXruGVrcVZ5T7c1gADlzwAWH/MohMHP2ANUBGEcrwGcj33oRhu0dBgDRkHgc1F9goezvikhvZ4+kII0DdkadullAbFyKANCS9AWZwIKCQh3ARt02mGlf6/CIEKueQga/3c76+skhaPfSSgazbI2yHXOuG5bMC1gCaOITq9P20zRRXNhCWh1QygFwjSkoWEjS+gmgsD54Z4T67rKBx88wUSBcxaKO68n177lC1Xtp3wff+qFd3D5CrKqqcdTKEpM0+BMi64bsk6McxaFxGoNbYtqW2IlkUqhG8v4dMmqcMgw4rz7Y9d5a0864H/Sz+bwkAQnJWezFW+89yHVfI5yEo3AaEOzWl7Im4WQhEKC8tmA513Ppmku/nylFOE6EkMbjbMOFUY+tkgqlkVNoS1K+q6KNBaMRjr/8HiPnc+wfFJq/Vh+7bsvcu3BdtJ7DI2zSBUSOEdtz6UnT3YcfUXvvPvuYmpshY9YM1oTSEmoPGTK2ieK3p9oXD6+HoIwUOyMBlze2cZO7oE1OKs9UMcqUpvTVZKgLVHCF96eDqiwwiGdQVgHbYOtSlwc4VTk1QXr1/vke/bEq+C8+P6Lnmr/69YrP3ONgxtDykXL1v4mDw6n/Pe/+4c8+Pge157a4T/527/MZi9luaz47jffIU56mFxxOm6YTR4y++gR1zY3CPZClqsFo0t9fvqlVxjfn7L5/Jf51hvfQsgVQVdwsHuJp5+6wnPPPM33v/sB0FAVK6SSfO5zP8XNmzc5Or7HU09dpi5WjEYjTk+n1KblRz98F4Hjd/7BH9MbpPyt//RXuX/rkB/98A7vv3OH+/eOcdoidM0fffsHXHvhKl/56hdoreRHb3iVSb8f8tnnn+XLX/gco80Rt27dZ7Gfo9K1gqINcQQI2a5hgSHLeYGUmt2dbU5PG7SBTielKgu0tt4TKsGYFq1bUhWAbpgupuR5hTNbOJcwPSv4wXfOyDYNb//gPi88fZ3Dk0MOrt/w2Y8l5HmDjAK+/cb3mZ+ckDpBEiRoEVE0NUF/g9JZ/uv/8/+XL3/xBn/lP/4qL1y+ROzOSGk4NUt6nYyT42NeeOZZLl2+jHPw5hs/4O233+G555+n1x+iIgfS0csG5K1gumrX0quE+fiM07sf8uqz1/i7f/tvsrvRoS1ylHUoBVEsqducslqhlCBfNiRxhlrH+Wlj6Yy6uBrmixVGSNLOiCSCulkg6hmjaIcvvvgZaieZlws6wxGDKCVsLLVp6G70cK1BaIfTDT0Bi7pCEPrucOAbGVIEZGlMkvUZDrf4wz/4Jtu7I+L0k532PXf9Cu+/d59nnt1DSsPmYIRtwbVw4+B5TNtwtljQ62dc3dmm6EhGcZ80DRFOYCqDLWKyICZ2IWXloVvtqiLNevQ7XZqqZraYMOzlbA+2yauCcdOysbvNcDRC65rT8QlteQT1imEnJZUt5bxipVdc37pMGgUoW1CjWCynGKNxaKytyfMFYagQQFEsMbYkChXShUwmEzr9LpP5nDiKWSwKnC7Z3R0SBJIqr8iXJfmq8owLJJcuX6NuNCpUSGsxuub1zz7Lndsv8/0ffczRyQznNEpCFAieefoyr33+FcI4pKlqTg4PufPRx8xO7rLVjykbQ1EbzHpKYYw/TBgL/mwqL4pyWB9CLOimxBmLAjpZ6n2PoSaNAwIVcGmvy3MvbvH08wcIIVmVNWf5mIenK7qDDTrDlq1eFykclYGoG9Kq3Cd9zAzL6YQohcmkwJQtXRUzjLt0VcLSatrCEAUBMpIU7crLJK1ksztCD0q0aUjjgCoUXD44YDxdcjw+pVMIutsdtjY2uF1OqI1muZgTpR0i12KNQYUBzlXEscS6kjBqGY+P6EYZRV5wf7YAJEo4GlMzLQva1nE681LuT3LNplOMgPFsyqOTI0QYYAWMtjZpmobFvMAYn8mcpunFtPFcXfHo4Rn9focsy9jd2SfrpCwWC8p6Sa/bI4oUda2o65pYBIzHY8JIsLE5YDqd0lQWa7xhwWLpD7pI0aWqKjb7Xa5c2uLD2x9eRDyeU8GHwyGz2Yw4ihBCsFgsmM1m7O7ucuPGDY6Ojtje3mYwGBKGIW274tat+4RCMDmaszO6ysuvPM33v/cBx8fHFEV5MU2N45iNjQ3iOGZ3d4fBoItxmigKkVLR7Q5QSjKZTDGmJc5SNJbusI+ezSnqmjT1cuDaaFQcIaVif3+fJAy5d+sOrfAy7CiKEGGIwmeob+9sUZQlaZbRHQ546rlnmT04YzGZMxyOUGto12BrgMMRZiFRGfPg/l2mp2dkUUwoJE9duYYKvGol63QpXENR1+iiAjfDWYXWFt0arI1oKs3GVkqv16OslmjdEvdiLx1PUzqdDtYoZBwQBH2ayZSbN59mNBxxdnyPtNPDakPbtDRVRdO0BFJ5+FcUYNKAoqwpy5rd/V0uXd7m4f0Vcewn82EYUlUr5rMZnY0OVTEl6UbMlgukCIhsiMCfT5fLJavVCmutj03DZzYbY1gsFmvg2F/AEvKisBZS+nvanU+fxYWd5vF+dz7EeXyW1NYgpKCTdOgPBsRJjApDrPMZ901VkWUZw8GIMAhwpj2v3LDOZ7wD4Bxt3VDnK5qq8nvpGpbsnKO1xp+V18pYpEIIaLVBeVkoSZpgXQFIrJV+qKASLAKlzmsCt/4FQhistGDl2pEskUicMEircVYhjMEJ6SPIQuv91rEHypnWeKiyY22GZ414sgjr1qA43811zoLxkc8bvT6Xd0cMexGumdMWJcr64ls3YIlojafeF6scYwxRFpN1M08ijwIIJM4ZAhUSBpbWaNJYsTPsUtUNVdl43o3wHvHWtISBJE46a/utXauyJHVd07QF/UDQDRx7XcFWCqloCYVvyDgBBF6JJvCWrXMLl3OPYaLnxff5fXL+tU9zfeqF9/2qJgsCRK9LmqUUp2O0lERRBCogcgZlDVEY4LQhUgFaKhoVYmlY5N4rbY0B5Z4QX/x4zfhkweipsM6T9ZxgtixYLnNSpbi0vY1sLFYbAqVodUtT175LdCFRseuoCPtj+Zv+wdZesucEMgiwzvuirXVoFC4IPYFcCYwMccKHxwdSkEXR2qfhLibd5x5yhwc1eLjb4+6YWUNspBS+W6f14xE35xuKuPC2OLvuWMH6Vlt7BddF+EXdzrm+5FxBwMXrOd+gkihkbzhgs9vh7O6c0Fm/aTkIRUBPtDhriKQjuGg1eiiblwF5eJsyGtnWCK1BBFjnpSR/3t/54z/Xv3z3n3/lPwTa+csvPs/bP3iXZikpJpbFrCZvTzDCcef2Mb/7W3/C3/rbf404gZeeeYY/+pPv8OaP3qGJ4dqVayTJFrsHMQdXely5tkOjFdWsRJc5V6/f5Mtf+Ap//zd/A60Ml69fQrUTHnzwXT585whT9Pnl/+hXmI5/g7v37/HS+AaTkyWnp8c8fHDMN77xHe7cfcirP/UZ7n54j6YuuX5jB0mLtJrpeM6PfvghkoyN4Rau0VhTcuPpfX7nX/w2P/PlL9GsCtIQ0JZQwdn4hLfeepOfev3zPLhzn6LIiVLFoL9BUZQUeU0oArTTWKM9eVUI8uUK4Rxponzndq0acQIa3TBbzOiPRgQI6tZQlH6KjfMfdEpGRCqgrkr2Lu1hRUFvKNCuxMmU43HBeNZgnCJIEjqjDUJt0I1G2xaVRp6s2RpKM2O+KEhVQD+M2M5S3n7rFleff5kgCOmkHUbDTeaTJe+89x63bt/ms597lb1Le5RVSZxkaGOJwwwnHGdnp8TKYao5qTK8eOM6/8v/+d+hnwW0VY5tS6IwQAmHbiuW8ylxGhIFIf3NPnXpCaRxElJWOZXWzIoZs2KGDkJcUTE/myFFziCIaE3JMBlSaIt2Da2uiWUATUMSB7S6BesIpUSpgI7KSK1mpStsIJBRRNu0WBRChKgwJlUpedlwaf+Al176ZKXmq9mKSNVMT6Y8++zLZOGUJBOsljlHD+6yszVkdzSi2+3SakVsAzq7PYrVgiuXr1LlJUkYEEpHN0oJA0erQBIjtUWXNaKqiTR0VEwoLFIbNjsb9MMRxbSk0hO2NhKUkIRmm3JekEnFdr8H2jCfL1gtYXt3F1d4KmwUScpiRdtWlNWC4WCTui4pihVNo5kvKqyIGc8KZrMFRleeT5ImRGGXIEho2paT0wlqHdmogoBur4vDMZkt6QZdtBb86Ifv8J3vvcGtW7dJk4h+11Puo1Cyv7fFz3/ty8RhyORsRr6YMzs74faHH5DGAQeXNqkaw3RZYKxkPvd0eOkdRp5Y7oL15xd+UiIc21sJSRJwdrYiCELqssA6w/aW4LOvHnDpUo9nnj5gMFJ0hwlBmPDw8IhgERL0+3R7fbqBZXOzS7WqqVc1TrdsbQw8EM/CU9evcza/x9n4mIHqsL07IoliqrJYg+cChBOEUcqj4zGD3hb7e5f8a3QJRV4gKcniDv3hFl/54hf56M4tTk4PieixnBjSKCRfLulkHfb293n/g1s0bcHOaB+so61aBr0u3bjHYrliOs+xHUEWhnQz3whWSUgax+TzlY9GWxcqn9Tav3SJxmga3cIJTKdTXvrMK1gBR/fuUVeG5XK1nhxLFosFAHEckyQpmxvbTKcTOtmQum7RpqGuS+q6ZLmaMp2WLBYF1mk6nRSHptcf0O32MKZhVedIGRKFIU1VIoUljWNOHt1ndnLEsy8/T5ati/myREpJ27aMx2OKouDS3j6DwYCjoyM6nc7FWWt3dxelFNPpDAQMB4lXEArD1et77G9eYtQb8vO/8Hm++acfUtd+WnoerSaEIE1Trl+/hjbNevKkwEmUDFFS0Ot1aNqa1UpzNp/xwe1b3gff6ZD0OlglWS6XNEuDFJIAQSR9pJRyAuVAWEdbVHSyFLShyAtWZUE26KHSGBVFbF/eJYwCer0eWZaxWq18xJK1iEgwHA3Y2/8pP+DQlkBK8rxgVTVUTYkNBMQSEQU4Wq/qsw2NrqhMgzUJqICyFKyKM5qmQBCSR95HHYahH/ggL6C+QRCQpAmt9lNTG0qsscS9jJ3wgCDw8v4kTqitZloscGjCyBFFjhs39vnBdz6mqgrUQKGUwEl/vYToEscxWZayf/mAsqg5vX+MFI+HTkmSXJyvOqqDETCZTi/i8f4ilv2xiZFnOSml/D6HWw9+HtcJ5+fIcxuqwxGEIZ1e19PpEz/Zb01LVfvkiq2tDdI48QpO03oQ5VpaKqS8mI7WZUmZ59i1VUetJ+DGGhwCJdbgDHceNWY92R5/5tWatV3V4Z4ovIWKkTiEXE+8hbeUOmvwyZPisSRVnOf/SkAihMUJi7QBThqC0BHGEVEceQ/oeuIbCEGgJIF0BHKd0a3811snMOthnrQeutbvxPSyiEEvoaqW6KZBIdY2XItQbg17M9Rl7f3XPAY1p52UII0JhK+RyBQitEgtcKFhPF/RtiuqBp+6ZM9t14LZfIlbN0XSIPHPh21RzpBIwVY3Yrdr6KgGaQxKrrcRIXDiosh5os7x945Yu/XPq+z124p9nOz5qa1PvfA+y3MkDtm2jKKY7tYGca+HrGuatiVRAooc09YoBEoohIwprcSmKWE3wVU+WgHr0fogLy7ikzLpi6mpcz6bDYcRDhkFtMai25rDszGxALeWYQv8wxysp9w4X2zb9dU/Jx+Cj59QwseDtNYQKkVjHdoJlAgwzqydJt5vl1c1oRIg5JpQ2oK1GGOR0ncWz3P22tZv1kp5OZE2Bi08kMU4hzOg1z+jW/+8FxWuvxCsxd0gJAaHWXfLpPO6QqkClATdtjjr8M0t9y9dw3M5Sq+bsTsaIE2Dq0qUNihxLu0RSOd9Z0qeWwD8tN43yozfuC4K7xahW5yKMEJe3Oz/Oq/Qn0cg9O/XfxhTcNGGfOePf8jZ3QJZx2wNt+nEEffu3Ka1jvFZxbe/+QOieMWv/c1f480P3+B3/uhHxIMEpRNevXED4iUn+T1udDq8/cYH/OBP77KXXGFzq8vu5hZN3rKoWupiwjf/4D2EtQw6Xd6e3eXl57/I3tY2b7z3Nv/o75d87S9/ieXH92lbxdnZlF/8xZ/HEjAdj3E64HOfe5HF9BiH5vnnb3J8OKYpK3av3EBYR1MuKZc5TWNpy5pXXriONTnvfXzPb362R55r3n/vLoKELLVsjYa0TY2ymq1uB2ssS6NpjLd5JJ2AIi8Bt46CCBBCoXWDcAa9lot1OhnlauJBGUnG4WGJkxZLQ5KGDIcJ989OGI4Sep0V126OICzQosN06cgbUGFEGESIJME2LWEcodsGvdZ65XXF9t6Ive0hextDbFsySAOU03z969/kpZc+y2iwyf37x7zz9nsEYcRnX36d0WBEmTeoIKKT9Tg8PGJrtEFRLHClZHJ6RD8L2B11+Z/9p3+dQSdiMTtl2E3REqoyp9vpoIRia7RF3VbgvOTRhXYdp+mn4kVTsiqW2HVjYj6dEISCOOmymC/Z2opIwgRrKqyShFIQBgHLukZifX5mknlNnlCoKObSxpDi7ITD5QwnPECyXT//eVEhCMiyLifHZ/zJH3+d/+1/9sk9I0kQ8/yzT3H4aEKxbBh0+ozHRxRlgW5LhEsZdbdYzFd0OpscHBxw5+4D9g8ugzV0ux2iMMRYjROCJI18tqmDTMWoLET1MsYzyUZvi36nzyAxnJ4umJ5M6Wx0WOQLouEA0UoOhnskGyFKhKi9mOWyZHN7SFM3zKYL9i9d4+Bgl+ViRpr2Kcs5RTFjc2ODxXLKYrHg5OyM2WqFNQEqDEmznofhKI02FfXSYE2ftm2ZjGf0Oz26vR7R2lu4KpYgYDyZ8eDeMX/y9e/yZ9/+IYtFgRCSNJQMOilBqHjppad58cVniYXk/kcfs1jMeHj3NvPFFIdlZ3eT6zefZpmXTCcL3n//Q5bLnKQjMMayWLSUhcfJRDHEkaDTTXj1tW0mZxVlWRNGEf1BSJbBweWQr37tKZ55Zg8JlOUSFRiKcsHmRgejOshIEwQhozQjDkKGW0N2dxLG8zmtaJkt5pSNZjYf46xGNzXbly+zN9rBWJgtPazOWstmf4sgyGgaKCtNWdaowCFFQC8bYBuNVI5qtWB7excpDuhm0O0mGKfJRh1Gex3GsxlxHPD5V5/lZHzCqrD0exvM56e0TUMnjdjd3GE8OUGbJTLZoBOE9AdDHpwck7mAjgwJLGz2B5/cAwAs5nMM69g54KWXXmJ/f5+P79ymyAsWi5zLl69eSHzrukZKSZZl9Pt9wiBiMp6jVEhZVty7//EaWCbo9jok8RZxHNO2fh+V0pEkCeB80SYMRgqcMTSmxOQ1tAn9NEY4uH/nDiShzy1OEsIwZLlcslgsiKKIIs9ZzuasViuSJOHk5IQoirhy5QpFUZB1+2xsblJXU7JOSidWmKpBqpbeIOaLX3qdH3zvPkVRoZT6scI7DEP29/do9UOMsehWgpMUeYU2NSowGGeotONsOuHd99+j2+3whS98gaTj5fgaB03l02zWU6w0TRHaYtYAqLZpGPT6NDKgyHO0M1SNJ5OXbUNQNkwXYwwtMhJYaahan7k+no+5d+8elw8uI5WkrCqCMODw8JAgDEnSBDNv6XQz4jjCCIs2LWGgGGz12Ilj2jYBEWFsziovOJ/EVpX3y59PvAURy+WKus4ZDofeHlTVqDhk1pT+XBpKgqTjz4kIcqFx0pGkCVIZpLQ0OueZ566Tdb5DuTwneAtkGDGdzbB2lyAIWCwWyDBgMV8xm87odLr0+30fSRkEPkZRCJIspagrojy/yMf+i1jnhbYHAD8uvtcV1HpoZdFa+9/nvPUS5+1vSZrQ6XSI0xShPKCraVvquqDX7TAaDH2N4c5J4utBgXzs5TZNQ1UUtFXtJe5r6bofsq0HZs5yHguJA+daPxxT57VHi9YOIRxID4gWMsJohbU+T10os5bJu4vMa4fACfO4qBR2/TV7nouFFBakQxiLiixhEpOk8YXsWvq/cn1PWCJpCb1iHaMdyq0l+zhv+VOOOFKEoSIIBFI5hDq33gqkAhX4yGddec+30j4yuW4b3LoZEWntOVo4GgcGhcZbfI0VCKXQpqax4GQAUlI3hhafCCLX77XAX1eFoxNKNjsRnaggxCDDdU0h5Hooum7BrOtvIeRjJa3w5bcTrKv8JyLhPmWGwadeeEdRRN3UVM5hjaYQgjhQKGKyMPSNG6MJsQht0E5AEDNrNDNrMVmM1tVj6tyT/uYnrs2TBZxzdg1BA4FcZy36r1Vao4LAxwBYS7gOYA+DECl8Lua57ODJ3Ddx3rlyHoTWGktdN5TGeuq4094XJx6/PmMM1q2n6EIQrT0aSj320Ng14RtASV/gN22LxdHiCeZV67PyzHlH74mfVZz/r1sX3WvtyEW3D3/p1LpbJ5GIcwn8uoh/cp2/HikVo/6AGwf7RMUE2gbJuY/GgbP+z8TLfcIwwOHJkqAvGnI+79YX3zQNLkyx63z2f5Nb+88tzP8DKbzDUDLqbPDUqy/z8EPvhTtbjslGPXSr+fjBA/J6xVe+9Bz/+B/+c6SL+aWvfJ533ruNWuVEaMrimGc/c4Bu5lzdHfK5v/0K8/sNh0eHBHFKpAKaomE2nRMFQ7pZhzRUPHp0l9/4H/4hjalIMsnWfo+qXpFXS157/SWuXbvBZJrzw+++wf27j2jqhqMHJ1y/vMv1my8zPasJZYwLapzN6XUyZJZxcvSAQb/L/taQzV6PKzubPP30M/zxn34LiWL/0lM8un9Mqy23bt2lm3UozBKhYNTps5wv0KEgUiHWGpLIk/2zrMPV65fZ3Npkla+Iwpj5YoFSiqqqWSznGNMSqYA07bBaFVRtjbE1gTSYtqGb9ZCqIUkEoSo8jMeGfHx/yrJyZFlKU9Q0ZQl4+uWVvS1UlCFkRLWasxG1/OLPfZFeGDCdL8iU4tkbB6hOww++9z2uHBzw7DMvcPkXD/jBD98gVIJeJ8E6TbfbZbWac+u9d3nxxWeRVUXUFzy9d53/xd/9n1LlM+IATL1k1EsJA0GZF3QyH+sThBHGGNIsRgY+G9o5h8RniDrhZV0iEBgjmC7mDOIuSgqmZ3OiIGFr5wqsWkzlJyXVcoERAYFUKKFIsi51o5nOFjgV0kYR09WK248ecef0hOlqTlUWHOxvc2n/AOcE0lmMa4iSgJ2drU/0GdnZ7rK50UWZkMV4yqVLO0ROEcR9Dq4/w3I5ZXmaMxxusr9zBUHEKE45vHWP0WgAUcSlGzeodUNrPJguDBJM2TLqDUljiaOhKivGpzNimeHaBqk1HSWhrrlx+RqL5QmRiOilCZ2oS1u3jDopOzsjnHTEUZeImE4oaMtT2jpAqX2q8pSyPEPJa0zGKxqt+fj2XaI0g8hRtzWbG9tIJxHAsD+gWJVMp9O1OtEx3OgjUCzzpacE65bpbMHp8ZSz05w/+foPma1y4ihGWocyFmUdzrUESpKEMT/6/vd5/+23EMJhTctw2Kc3HHDz2ecZbWyTFyXLxYwXXrhMWZ2xsRMQhI7btx7x4QePOLi0z/Z2SrcT4XC88PwV3nzjFqbJeebZp3nq6W2SrKHbN3S6hlavGHWH9LubNNoiXE3W6eBEQ5xE1K1g1B2wM+gTCoUTIWEYM11NSbciTsdThGmQpuXpK9fop31m4zmttpRtSximnr/SavppRDeKEdQsFxOENEhhCaQ/wCYSynzBvfkEFYZs9/pYWUGkOZ7MKQpFox2hUERSMR9P6QwyRLBitJ1wdjJDKk2kHKNuhG5rnFkyHy8YdhN6UUJdlWyN+gwGI5z7ZIuKO/fu0BsMiKKI7W0PEXv48CFlWbJarTxXIk3Isg5FUTCbzTDGkOcrmqbBWsH+3iWGgwGIlu2tbY5PG4yp2dwYIUWPfOWL+jCMyLKIui45OSkIQ0mSpSyLnMVy5ZkPRUUWKAIlqMuKZZWzebBHmmU45+j3+xRFTlHklGXFyekpg16P7e1tFssFRVnw3HPPUdUlt2/fojcYkXU6RFFIOa9xWuMaw3hywuZgj0uXdrl0aZ979x5irY+wO7fcnXuIaX2OdVODtR5SWFYLNrf7ICytFmxsb/LzBz9PVVUYZzk8OSKOY9Is85N4Y0Eb0IY8z5HWFx/COa+k1Jq6qrAShpsblE3Fo+MjeoM+Kq9oXIsIvWd7c3MT5xxpmjKbzdnc2kQ7Q7eT0So4m04Ihl0aqxGxpFrV2AJUFKCtptY1VgaEIkCEEZ0kAxdzNp4QJzH9YYe2cZhGYYyh1+2yubGJkjFCKOqmYGtnyGg48MkXQcTR+BhjLVmWMegMiJLkogh22tHUNdrkNG3BbLpka/Q0m5tDThuFVN7THIQhy/mCum6QsaOpG+7evk2WdYnX9oZqHRW2ublJURQIIQiUIl/ldDtdL8lu/mIKb7mW8vizpr2Yzvtia30uFF4dei7slFIRBAFZmpKkKWEUgfTfV9U1KlDsbW2RxtHa/826kAahBIQBOIura5q8oCkrdF37GsOBXTe8/TTZPj5TrwEcQvjIKouHbVpnkXgWB5J1E0GRFw21c7TO+dhRwdp26tZHfOtl4n4e7usA6ce7QlgvMXXrgtj6k78KNXESk3VS4jjElZX/fucjxBAWKSGSgmBdFLs1/Njgf/4w8O+/DCROek6UUNKzsYAoViD94NHUAm0sxtRY5widp44j1lA8HK2ARipKpzhdNZwtapa1I0o836BtvDzfIWi1t0IFSl5YB9ZVBVEgyCJBFjhC5Ye25wNIX/mtVbjn023758jIBQgnsM5cqCn+vKzvT3p96oV3J/Y+7jhNqJuGlXXk2qGEoJAKGyn68QhXhtSLHOMURWt5++ERb47nPKoMFRItfG4e5uJa8qTg/MculHMekY/3NDur17EsjqaFwHnzm1g7J4RUWOMd0va8i7OOWmnb1ssElff4qXWn1jqLts5nYwuH1haBRaKxwjsKzgvk1jmccWTSeSCHfNx1eTJOS1uzjkbDU9OdQaCwmHWyuJ9Kn99K50v4kvjiOviH0138/T6P1tG2GrnuFl14ZYT7lwpgKfwUbdDrMOpl5Me3wVovpzl/DdbhpP9AEABSYU2LNgaxpp1KsY4rcxZpDRjjVTHifFL/ryqg//15Lf5dlhYLfubnXua9bz/k+PAh2rTsXd/is198mTAJ+Pjd23zmhed561s/YjGfM9wYcGV3k8vDLkFQ8vDOO3zuy1fY2thC6ZrAabqRZP/pA6aTFVGg6PcG3H44wZgAkXTQVhPECVEacf3mDd57/12eunmV3f0RQja8+upL3LzxNOPxkvff+5Cy1FgdomRAuWr56IMJhu+zqkquXrmB0RVpLNne6nKwt0f77FO88+b7BCLmD3/3j5jNxvyX/+v/FR99+D63PnpEVRhOThc8OjykKHLm0xndNGarPyQWIaLXJ+1l7O1fYb6YUVZLdnZjZtMlTV1yfHzI1StXwDmSOFr7CjPCQJEbjcQRJxkWQVXXaNeiTO3TEQKFQNDvdpCuxLmIoo5474MxWTehm3YZZD1sHFIbCKKA0hjMYkWv28fUK4pqwZVLW5wcPiSgZnd7l+3JnHc+fsTrn3mWRw/v80e//5s4l3Jpf5OvfeVVglDwne9+i3sfHXH33j163U0GScvulRGff+3n6GUJiaxxqqWbJijpf7a6KhDSUVYFvUGfLOkynkwIosRLK9dqF59dLqiagta2GKfJq5IgihHGfxCZ1nH38JTP3DQk2pIE3j/opJcbKmu9v3CZY4WCIKLSFu0Es1VBpR2NgSDOSALFqq6YzCfsxglplhAlMeOzFYNB7xN9Rq5dusRiMSECrh/sEoYRcrSLMRCRsTNMvS1BxNjKESjLlb0DYiSdborA0hQlQkgiCUkYECUpWsQ+eku2WAEboyGIgLYuGSQZ3ajDqqypMXSSDrbR9JKYTpARq5RhNmRjaGmVYVGuUDamqzJ6vYRydYiMKg6PHnE6nhInA+I4wBpNXdWsVjWyEXQHPayDh48esdnPuHbpBnXli5FLl3bod2M2Rimz+YxVXiFUxHy24Jt/9j3e+OGb7O5c/v9R92cxvm35fR/2WdOe/nONZ7jn3HnqkWw2SYkUZYqyaCmWLVu2nCBx4glB4qcEgRHkMfBj8hIgQIAgQPKQBDbi2E7iyJbkRLNIizRFsrvZ453vGevU9B/2uKY8rP2vc253U6aV2+xkNRr3VJ1TVf//rj2s7+87MZ0d0nU9zgti5zAhoI3AhcDB6oBbp7eJPvCN3/1dnOs5ODrkS1/+BVzwmCJDFxUqS33Xd1465XBVsly9xdX2fQ6PKr78lVtcX73JbJIxKRVDZynzBdOqxISOe3cqfuZrP0PvdmzrC3bdJdPZhK7rKA4LvA9URU7wGdOiYLfTmPmUziZmWApG1YpAEVlN57jgEC5SVhlKT+jaLb5Nybou9sRg6boN02KKwqOFZ17lqCwgjMAFS9+2LCYz1u6CaVUwLUvW6zVZVlH3HcJ0WLdlfXXJavUWWud89NF7SBVZlceEUNO3V6yO7zBfCnbrDZUpmeUTjk5voVVke9UiZcbJ6Qn5pON624NyiM95V9SohjKvmM6WVEczlM7Y1S1102NkhtaR7e4a8FxdXWFMGmSfnz/l+vqC48NbTKqS68srJpOS49UdZDR4b7k6a9jsPsCNcuWua+i6egwlMywWc5TLCE1NqaZoma79802Lt46mrikmOXW9w/vksRYiMptNePIk0vcNSiq8D9y5cxuTa5SWOFqyasG914759ne+hykCr758l77vscFxcrBiPqmINORFyXy+omk+4PDgEGNy8jzH6IK6bvnog4e88lZOdJH5NLUVrH1DW19zJVoOjw+ZTiusc7RNYuFjGFLwLY6u3dKH1E2slURHQd+2hN5ikBRZDkJzdXkGUnJwfIyZlDx9+pghBtCKYjlHZRn9KA8+22wwxrBzjl1TM1lU1PWOq3VPNZ9RzDKK6YRNvaPtOm7fv0NpMqQUzNSCrmvJMsMw9Oyanrzs0ZnGGxj6HmkEwQn8EKivdlQqY5YbVgdHFJmm7c5RuUdVETnxKO9TRkhv8b6nbTfEmJ6deZ6O3UCgax1GSlrtmRQVr758h4sn72HtFYMp0UIhQk53HcmkJFeGPPdUhUFUqxsvLcB2ux0VaoLdrsEPkSACq9WKXv30erz3VbvJzx3H/e0oTJZixM3i5u/KsqSaVGmwOQazDX2PdY7pbMZ0OsEEP7YZjWpSIZAm7bqjd4S2pdvV2K4HHzCk+rAQAlGKVJk1bqSlEKlia3xNMqbuboQc2fqAHVI6uhApOLbZDqy3YCuPjQ4RIlIHpE6WWCWfO73jfiiAvMGZIkZSl/dY1Uti03WWkxUpR6CaVOitxY1BnCEEog8ILceubkji3vQ9vEitSkoIkIIwhjODQsqMpLcICCRGKPKgkCGx7m3fYZ1DWoUdBoZeo3UiYxrnsCajkRnruud83dAMo0JXSpQWeCTWOtxIkAoE2qRgPO8t0gjK3DAtNKVOlWARdSPBjyEN3G486/AC5uKFz6WqzTBWusmxeFzIPeL6yayffJ2YgPlkgsoyNtsNdrDoUtO3HT2Cp91AkxnKakFHRpSSPsBHHz3g0RDoBSkVNgIjwEwH2D8HjHEsPI/PGeAgX3gNMSUbxhBwPtCRQsukkITo0ZACyMZ/H2IKkoikWjIBSQZhk6x6H04mVApnsXb0XQtBFPq5Z2A0OouRIe4QRK0QIeLbjlzr8eRIrzrVOozfO6awJUdMNWAwXnhpsCdECo+IMo7HQrxwwY3vm1QX5oVCBfAu4CVYEQgyIhmnhFKMsnWRpOExMlWaVVEwyzXn28tRFAI+CKKMKDN2vY4ns7cuhdogiDHJzQPgZAL3iICKnjD6QeILHu90njy/OJ4D8h+O9d9/LJ9D9r1s5KewDk9zjmfHXH7S0AxbZCb5i//Kn4aJ49vf/z5v/fzrPPzogg8+fco7b72FszX1puGV2yf8iT/1BTwbmGkuLlqUHah0zra+5MnTx3zw0Ud8aXWPP/2rv0wnFB988hjvWi4uniL1ETIX/MZv/RZCw53Xb3N5ccnbb7/GxfklbWP57d/6XZ4+3RBjRlSG2AWcdRRVwdMnV+TTgsePnzKfGnDA0QHn52u6ZuCjjx/yH/2Hf5XbpwfMZhNWVY5vt2gEm+sNF5dbVFaRhcjLr82xTUPTdqhcc+v2HbZDw7beATCdVUzLKbbrOVzO8H1DYRRd55iUOZd9Sz+0ODuQGUXftEwmU7K84HqzxXN7DO3oyTKBMoKqVGit6EPGeqv51rd3dEPkrdduUemc6+tr5ssjgtFkBlx0qODQoeUXf+5dZmWGmU+ZVAusiHz1S28wWd6iGQa+9OYJw+D45je/yzvvvM4XXj/CGMGq+ipSfgWtU5iNiBD6jtmkom1q1hcXrFYL8izVm1nbUXc1jB4oScSFyMHREU3XkucVzlkQHrRA5Ro8DHagbhuCkEhp8H1H13RAxsMnl3znBx/w+mrFnXmy4zgRU92gd6jMpHpAZciyksurdZKSZwWrgxM+OnvGdtshTfKUPXhygVATimJFVkzIsjYxkZ/jOpidIAbIjqZkpmQYOuquYzk/SBkbg2O1PKBtUr3U6nCJ0ZqhbYjRj2FTmq7tMVKSK010qflhsAM+9GSTjKIo+fiTj/nC228wNQtsFykmkXpoAXjp5D6ZEmRkCC/IsxIXBtr6HBUdmUobCS08CsvZ2SO80Ag1Z7W8h7Me5zqePXvCdDqlsYqu0wztjvt3l9y9fczjxxdcXl5z+6X7TGeKtl5T73ZcXF6QFRXf+/a3+eDDD+nawNMnl9je8PDht1KojE8bOBkiwiTZ7727L/MLv/CLfOP3f5/N+hplJF/52a/w+htvsN1uae0ARtP3LVH0zFdTpnNNXnh0I/B+wLma45MCjSXYmiqruHV0QJFlzL74Mut6QjltMEOg6z0HqxlKaXRZMJvM6JoWj6DMDEZKDpdLtkNNZkDgiEGQFxWE9Jy0zhGiIlZlSnePliqryCYz+nZAyyKFRInAJC8pMkOmJOTgBNTdjhADpVHYrmNWTTmYHxCDYFrOGLoBKQT5MmPnIJNrCu2JbDHSMXSR2Ad0Lrn/6n2izmkFVKWnsz3L6QEHByc8evAer95/g6vLS6amQJYS3ydZZtPtPtdr4GJ3jlOe2qaQw+XyiCdPnvLw4SO00qhMoLXEuh4fLIiQ5NgKrBsIzhIRDF2PGyxaGmwHbevY1QN105CVGUWRjxJuOe49FESN62GoE/mQZTlSFZSTJSFENs3As8sr1vU18/mCxWIBo4Kt63rW6w1d58hMjskNWqd9Sjc0bOorqknBnZeOsa4mLwyZOWZoaojJYiRCYDE95eDgKFX05SVG50wnc2azBbtdwwcffML9196lzKdMJyVaw2o14fR0gZSQlxm7wdF2LU10CKETkKgqhEhNA5Nqhh0Guqal6XuKIkMaRZUVzKdzzi82xOApZ1Mmizm7vqWoSo70ETFGTFFgdGI8pTHsmoYsBCqlKGczCjxdX3O5vuKyviavSo5mx5jScHF1yWazZhsTINzXrJVlmSTZQjBQY3c7nj17DKFFyyNUyOhaT7NtqfIZmtQDfXS4ZNMc0cUr0AGHJysUx0cHnJ+fo5SkyA1KJvWL9x4VJJkxxFCwWp1y+/Q+7U5xenpEnr+P0g7wSJkRvcL1kttH90FtCWywYaCzqRd7b6201pLn+VitZimyMqkSOptYyZ/CEujnzDbP1aJCpKYG/OjwHhUVRZnS+7XWBBIA7rqGwmQcL5cYrZDOgZJjtW5Ea3VDDsWhx7YdQ9PinSMlZKbgNEEi6EIMxBsgJ26spGKk4myIEHwCtRFi0IQoEFqgibhmYHO5Ywg53vT0sQUv0S6gdUAanVLUR5JMkICwII7VvZDk6CPhdiOjjkQZMcWEYjplMp2Smx1+PGdiTK9TC4FGoEPCSp6ULSUiyCDJpEk92OzxRY5UEwgW1HNkkhUBLSBgaIOncxCtAisQzUBE4aSitg5QiFIxmZRMOkvvGnxwKTBPRIJP8n0hRGLdTVJjOG/xJHWTEoJCQaUdSuwl0XJv6R6PynhMiCBeqBGLyS4bRusvgFJjG5OMCPmTPb9/4sA7AtPJBOccVZYzkMLERAyp2iHPaQeHQ9HrDEdkcjDji7/0s9gfPOTJs0surtf0LmA9KSEwJto7CnFTPs/ozwZS5P9zEfbNyRpHcOoi6cQn1W4BlJnGkNLOo0gXaCRVcO1DorwQY7VXIMqxTgAHIiWWB8DdeE/Gdx/3cutIH8BZjwopQdAIgWI/nUuyOoREK8PeLR5Gf+q+onx/+u9v7iEG0pBmNDH8mBVi8m2YmPC1l2L0Sd9A+Rc45oTDtYJMQbu9ptleYSTEIIgiTdm0Drg+9SLGGMdkyVHOPsp8/FiHFiWk1MTEhgv5j6sS23vNw3MvxgufHw/lj/z7n8ZaFDO+9Xuf8MH3PiRG+Lmff41X35rx4PpT3vriyzz+qOPicpPOR9nzyjt32Dx+wr03blMP55zenvBk1/Dg8Y47R4fMFwXHqxlheMp0XnF2doZXOV3fkFc5u11DNJEnz54wmVeYKqduarZNmp62W81QZ/ztf/RbvPe9hyyPj3h2fkkY1RjVNEdLcH7A1h1lJllf1+SHhzz49IKHD54xny7Z7ALeddy7N+fp0wf09ZbjWUldDfzBt75FMTnieluTlxXO92zqGt86FtNDdv3AxfU1RueUuaLMDdF3HK+m3DqaMy0UrtvR1QPz5ZTppGC70RA8bd2wub6mKBY0neN77z2m/VNvYGQKbJtVMJ15qokjysDgCz74cMtHH67xVtJsW/IcjpdLRKmpfcQ6QWEMtGtePVnwT//Sz0MYKGezxKabiJSBL79xis4LOmcxWcZf/PVfpqlr+vac6CRH04jzllxH4nAFUWCUpm83CALTqkArwXa7Ji9ymqYFKVFakxXJxjIEh+9SZZmMgnYYKMsMYzLqdkPvLC54eucSYGhaJlJzuDjm47M1Pih65zg4PKDbXSQWuMjZWYu1A0bnmCJnvd1x3VmuB0vMqzSA0LCcrzi7WtN3Q+quRSDFGtc/5Xvf/ZTHn5wzK04/12tEOE1lFpTTQN9bApaj1ZLUT53uyd2uRQmd0tjHCfdiOmfoO7JMo6RGS4OUkeXigOvtBmWgrdepKiSkYWiWZeQ6Q0mFKhWFlOg+BWhmWoMP5HoKWJSQOMYpvwipmzqkaXnwLVURqWYVQi/JjOHy4hIp3MgyZYTOsNn1KCTew6cPH1IVOa++8xpZJnn46fdx7QbfOy6vLnn46Dt0vefk5DYv33udb//Be3z44Sds14k5mhQZSoFwAzoXTGYVs/kU7xy/8Ru/wbOLZ5zcPmG+OkBqw2J5QBUi1ve0JrDZbDm9dY/MOJrmGmTE+gFtIpOpIZOaOGhyWaJFoMwzsmyG0g5PwAnLwXLG4Hus8+RZTnCeTGe4ECknBXmmUTpVlNmYNp6ExNjMqhlllvzJzjuqXLNeJ7ZnPpnTDY6D2UHytxpJlEkF5QdLDJaiyFDZhMxIur4nBsiMoTQ5eMGknAKSq+GCXFqun12yGQaMqOi2G05vrxiOD7k4b5lNKzSeGTnOayYxJ8aWxXLG6fEttpuWIpvw5MlTlEh2kOAj87zAy0j/Q0Ph/2/Xa6+9RoyC7abl8uIZ3/zmdxBorPW0bUclC/I8Z7VasVgs+Na3voXWmul0irOO45NjclMwm8148uQJH3/8McMw4L1PQ6B+i1Kaokj9v2VZstvtUjWXNjeBs31vCT55zXe7htPTU0Dw5IlDqEBRTKiqGVmWAGNVTpnPVvSjT7ptW+7fv0OIluVyyXw253p9idaKkGg0DlYH+GpKrjTX55dsLreo0DKdTKmq6qZCrCzL5MMWgg8++IC7P1Cc3jqk7TImkwLve3SWwmx72zE7PCYvcqbTKX3f3/SM7xmsfQhuVVXIokSTgtVm5YTlfElTD2Q6I8uTxUEGSFFmaRekhMQU2Q17Op/PU3uNS5Y8JwKLxYJqNqW1PZb0ftfrNY8fPcZEgR7VkDFGZrMZw5A84ovFAmEyorNoLchNqnELnaLe7dhuW2ZmwuPHT+DpBYenJ5gsw2QzlFYMQ5OyT8oivb/xfabU+x7nHJkwZCJVdV5cOJaLI7I842C1uvHUK6XQOmMYAuvrlr7zmFLQ24Fds8aLKVKZm1afEFKglXOOrhsoyxmZyKjr+oYV/+NfCZjtm3vk2PwTQrjZZwslqaqSoqrIywLnPdb7pDQQgsV8TpUXKEbrKDEpVBEoNXZPeY9vW9rtFtsPqLhXeu4xRmL2XAhEkTKn9lJmOf5dCKmaDCFQZgyIdgLQtF2LVJG+bVhfXOOtIgpBb3taVyOUodAKEbgJOlNqH/KcjsQ+W+lm7Y9LHAF6DEkpaHKKMgFvYzSiHxAyBakZKdFCogHNnoyTBPYe99GmGhJei1EgZI7Snuh1YpSFRwqbQt2IlCLDSo3feTobkUN6LTb0uCwjajPuVQoWmWDXW7Z1m5BNjAzWMviE70L0pMOZ2jqs90SVrtsQYsp1iAEpQiL4iDck4gsjCcbodvbgPMY96z8qnEeQL2UKmRPiJ4spfuLA25iUECrHJPMsS/JS732KmZeaXnYJ+EWFtQNX2w3aGL787it86Qtv8PGDR3zy4AkXlxuuNy1aSDwyTS+SKwHgJmssqQ1eZFCfrxcBqhAjcyolLgTU2JMoxd7rnL5Gjb9PGVOntvUOhITgsS55A4IP47TmuSf8h29OEbDW4SOYUc4QQ8DG9LOMydLJTaoc8DGFtD2X1oubb7QPJ9n/9+Zn/CgqJROB3EcmCMqqYu0tG5tYrxj8zekYR/l+kJE4Sk6a7ZboXbKS+Bf9EuEm1GJ/AislbjziN8cCbnwXMcQ/8g37RSn+i+8r/hiJ+k8LeP/e3/6Ib/6XH3D+8IJpYXjnrXucP32ENJFZNuHOl97l4Tf+OtFbzp89ZV0/4e5yweOzD3n7i2+znEfWnWeSZ2w2NZlx3D6ec3TrkOVySwiCDz78iLZu6VqL1iV5pWl3W7SuxhPd8MknjzFK8Nf/6t+hqVteunuf1998h+9957uIzFCWhmlVcvX0nLavU+CEgiZ6bh0teenOPX7rt36PEDXvfOGLPH12gcpy3nvvIbNS8OzxGZ988AClJwQ7sNtssIOnrTvaZk1V5BzfOUZKxdPzpyxXC8q8IBOOX/oTXyEb0/gvLs548ukH8KUvI8aueTf0dG1N8J7tekOe5RRlQVFNePZ0zdX1wOHxFGNagrjg6CSispohZGzbjN/5vU+5uKxZHdxhWk0pjcFol9giIiEIMgJ/4utf5le+9jpHywwRLCiDIyOGnq7ZMq80OM9iMuP8/AL6jr4fUEpg24GqNJiiBCKbzYaynNK0HVlR4EPq6t1sN9Rty1Kq9N/VCiV1qmlSYkyvzW/uOeVkymo5ZbO5wAWfKhT92K3pHcIL7t67AyHj6bVDS812u6XudkyEQOocjyArMkKM5EVJ1zuaYWAI4KQkiCSDk1JRFRUAbTdgspLlcs7gAmfn52iTXvO3vvvdz/ciiZJJOaVtWsrcUBVTds0Wawfm0wXVSc52vaEs5iyXh8xmFX3XotB0IgW3aJMDEikDzqZqxTxXzP0MYzL6YSD6DoPm6cNnLBeOalKQ6Yqj5THOevp+S1Zqok+d2kpJClPQ2QyJR0uDMhkOQZbnmLxg8IHB7fDumr61eC8ZWst601OtTtl2ffLI1iUiWvLplPPNNZfnV9SbSw6mAi0cf/2v/Ra7esc/98//s5zeOiL4yBtv3ufJ46dMKo2znuWiAumpqhmvvPwSKtMIHfnmH3wDax1CGe7ce4VyOgOZnpvb6w2Pnz7g9t0pb751myxvsXaLqSSGjHa4IjcC5wSTao5SMMuLlFzrd+zqltl8SdPVlDlor1BWc3KwoO8tBM+kmNH0HVIGFIFC5aymK87X5+RZxm7boo3DKIkLNtWsqch6s6MsJkzyCVVektmWrmkpc43IFFmZMdQ1udAYrdPQROZopcAHMpMRfSR6R/RJPhujQktNVVbIUuO3ms1GIqPg/OkGITR3796m62qU12hvWFRTopGIvmcmp/g6YISh3gami8kYlhrJtWIxmxFUIAT3uV4CRVFgrb95Tr/00l3axnJ+fknf97RDjVCC3W5H13U4l/IkyrJk6Ac++uhjZpMZ9+/fxznHo0ePKIoC5xzX19f0naWsphT5BCEESmYMvefyYk3fObIs4+DggLJwbLcbiIr19Y5JNcfonKqao1TE6AKiwg6Bs7OUaF4WU6p022A6nfLqq6/RdlvqeofWjD7ogq7tOXt2xrSaoIVGiZzl/BjfSbxLeRb7wKvUP65uQuTqpuXs7IyDwzldF5jNKopigo9D2qOJyOPHjzBZxnK5pGkagBt/b900hKEjM4Y8y5IE3Qf8kIYFCkmuDZpU/3Tx9IxNU7M4PGCSl3zy6afoA1jO56P1p6csy5RCHZJNst1cM5umsLtY75DB0Q89dV0zmUw4nC+oN1uapmG1WjGZTLi4uKAoCpbLJdu2wxhYLCdEPyS5tNA0zUBTD8xXKZl7GLoUeJbDfDVBK01vLW27ocynN6nye1/zvp5NSkn0kTwv2Gyu0aog1zkmyxJLPQxU5RytMpwNrK8b1uuOlQEpFN5HOtejTbwB6vvBwzAMKWQNQ54XDGOX909jPd//jWTPeCy896AkWZElWXlRgBBYn+TKdrDMy4pJVaHVGM4sR5ZcJgupzFJlceg62t0W1/U4O4w/48eTQFJKXPAp9EuIm3Ny/2epEk4JPmVMhRDw0SEQlGXO0He0TUuQUzzgfMBGhwoCLyJKJgY9kdyJ/YXnHuTPWJH3oDsCBERUY6d4UppMJ1PyTCdJPZApSaYURgm0iOgRNe1HEeGmX1yMe02FkBlCepQuCNKBdwjhSCS7QJDqoGdaMYQevxsYbByHtMlKlJkcoQzWRRykwcU+DM17nLO4kWRNWEfhg8fZFLSYutjH33l8brp9ge78MWsMao57ojDsM/FGDJVk5kJKlPrDSczPa/0xAG819vS6MWmTUTaqyfIC5wP4BIC1KSicwoYknZyVOk3tFq/z2r07XFxu+eSTRzx4+JSLbYcfvdQBblKAAfYK6v36kY7vsUA9RvAh0nmL84GoNJlUCEIKOhOkybLzY31CxCMYvL9JMPQj0o8hjonrnwWNnwXF439J8xe//8gHfPQUOk8/03m6biAohYvh5gR88fv9MCD9w8IAJJGcyFGZcbsq0ZlGd4G2H3BSj4OL8djEcWp0I7eI2LYhOg/xeb5dCJE4euTFjV/9ud/mxXCC/Sm898781wHeL/75s+y3/PFf9Me8/tHf/JC33niHh999xr/8L/85jk8mhMEzr1Zstp4ffPe7fP2rX+HD3/+Q67OOk5fmvHz/Zb7y1ROWC81B5bjUA6/fOeXZs5b3f/Ax905O0IPni2+9Tbub8M1vfI/2aktRLFnvepQyqJgTBpmkm3nJpJxx/vgh10+vKMoJwcMnnz5AmwKdaQ5XqySJ3mwQQbHdNHgbuHV6yMt373JycMCf/TO/xO9/6zs8ePIhp3dPOHv8lOgy7pzeYX1Z87Uvv8sHn15x/6Up3//gKUblrFaHyNWCTEuGviP4nqpULErNr//aP8Xf+1t/ndOF4dWX7vI7v/07/Nv/+r+CE/D7336PvrV0ZUaeaYpc0bct9+/eY7dbY0mbnWqa8fhJw1u373K1ecSrdwTK7Bj8gAsHPDwz/L3ffJ/ByZSCvJhSCUnbXJIZwSTP0EKxffKAP/UL/xyvnM5w7TU6L3FS0HUWrTOUzgBHvW0IQG4MfdehpU7VSEpCSA/L4AJlXmF7i3eOGAPGaHzwzOYLyukUKSV35i8x2IGqmGDMQAgOryRaa5wLWOeJ3nH29AwpPWVe0rkeokQJw9F0wcnBMdkQuLjY0W16hrpjaLZMqoLcJTlkbwdEBkVZsg96sDbSx4hXKdgnCslms6bve6aTCWZSYoqcxXyK6waMNLz1hVeJ0eP6z1diVRV5ktnFSK4nXF5uWF9ckBcly+kRJrNoEVnMj9Eqo9ntMFqjhGI6mYIMKGkIPhCiw7YpLdhIzSyvqMoJg3GUWY52gXpXAx5rW6TMESZVjEXTMww7tMrIjcTvB7YBcpWqrZQx6CwDaZDSEF2NHXqEbDEm4/K8xlnB0EtE69LXq0jTDUzKCc/OPU27xfskhc8OM6Sz/OAH3+cv/0v/Em+//TaDbWiahi99+V0ePXjMe9/9GD9EXN/xJ3755/j1P/9neO2NV+nswIcffYISGR/84H1OTk/5uV/4ExwcHKOV4tmTZ/wH/9f/mLPz9/jzf+EX+dO/9jNIVSflxCBp+prlck6mFHk+QeuKOER0VqHFwGa3o7eWVZaRRUeOoW5SynwYJAqNAryzKCUYhhoRDJnJcFEwmySQ1xtLZjKkEFRFwfp6jVRQZDlFUXEwX5GpjN7WXPuIUjr5ar3E6JJgLdY6dJ4YlUlZYIcWpSXeOaxPto1IegYfH61oh4azzTMUMCunNM2G7bpmtlqSG9hsOqI3nJg5U1ORLUsW5ZTTu7ewNoGv6dEJi8MVmVZcPHuCHRwHkxleRPTh5/t82W63OJcqSqWUOOvo+o4QAmVZUvc7rq6uePbsGZvRWzybzbhz5w6bzZYnj3/Ah81HdF3HyckJs9mMpmkYBsvF5TVFlbHdNNy7VyAQ9L2HqDk8PE3AvhnwC8HQB9brhhhSAvbF+ZrJpOKluy+zq9ecnz/DDoHpdMr5s6vxXgVlkTGdlSzmC+p6R91sabstw9BRTQqOjpJtJMZA03RMsxm7ZgAn0HLGbjtwfn7BYrG4AYllWRJjHJOnA23bMptNufvSLaSMbLaX9ENDURjyMh/l1OEmkLKua2azWQrNqiqcEgx9TzYmshshcV3PIBS4iLACJXViIfuBQmcMTUtQgtvHJ1RFmXINioIQAtfX1zcp7/tYGkgD0bZtcWNl03w+RxuD9EnFaK1NrN0wJB+7MVxfX7PrG7zwxDAQvUXmEiEUXWOxvaBtLFU+wWRpS17XO2ZHC/qhZ4gDXd/gbWQymabBwgvEjtYahYJRbSml5OTklEyvuHtnR9932NwSo8C5BM7bOnJ1UZOXhtkyqSncztM0KbRzPp/fpNgvFguenZ3jnWAYnr+/n8YKaSPMXj4cY9rB6swwmaZ6MGMMYdxr+vEYrRYLJlqjRCKNxFitFZVEaYUQCgZH39a0ux3W9imgbK+iffE1jCBbyhSKmpSq4jP72+fVxBEh1Yg7AkKmBqS9Qs12/Y1qI6oUUmZENnZPi+fqzphUK8/NtKlC+LNgMylYU26TvMll0rogMwVVOSHPM4wSRAe5FGRKYATo0eMt9oRxTP7uKJL0XkmNFBlKlVgZQUukt0QcQngEGuHdzfvOtabsPU03MHQWRJ5abaJkcJH6aksbrhmk5mrX07TDTVCgc44QRxJUpj1TCCQsJJLFd//7JaobVXMib9PxEOIFvBX3tWHj+xprlUEg1chy3xCZ+2v9x+Opz2v9xIG3lGmKoZTEmDTlhEBVlaMXKRCEv5lQCStQPmC8JMYB1zmkNhzNSw5mE167e4unT5/xze9/xKOzSza7BhsDbu+vYUz3H3+++CEwDCk9PI7jjhBHJjcmq6tijNN/4QKSSiU5AgpPxCGxzo/ofjTjCxJbLT4Lhn+UjRajPFzSWptkHCNDb/0YmT9WAfmxi/x5IMCPAuzPgFzx2fotIVLmuImehRHcnWSE4KiDJRsiMfPsnfJiPGsVieE3MklPwtAj9kERIg0qxiHhC6A73lxw+15yhMCN4Rd+nOJFnW5EIaQ6hD+Mqd9//sXE9+efFy9cUP/4ocNPel0+bmlutRydLvg3/of/Br/3B7/Lv/fv/4f8+l/8M2TR8Z/93/9v3Dm9jfOWwuQ8/WTNh6snnD37Af/O//hfwdePOchzHm4e89brX+L7733At7/9lC/evcfjDx/wyp0v8qXXX+O73/8EZ3Ja36aU7MmExWxO29VcXJ3z5muvEbqa68srgnNcXV6ymM2wPslcH7ct/XwBUVJvaqq8ou977hyecLo65L3vfIcv/9yXOD6Z8Pj8ktPbt+n6mu6648MPH/LBew944/VX+ca3H3B10VKVGc4Jzh8/4XA5RRYZlRIM3lKVgqka+Pbv/DZffOWEV45KSrdh+/gjMleTFQXTXPNpfc3kYIUkkpkkeVJCEr1HZprZfMF2c803vvkxX75/yGuvLDk+8Sjl2NUVXbjL3/hbH/Gd93pMXpGXmoCl9xIhDErm4CwqbPkrf+nXODksadsdzbamKDPQgmEYEKIgy6fkZYYTyZuudX7Tj2qHAWUM9bYlIBLT1DREqSknqVNSaTluRhw6S1K9oR/SMGJw48ZNEGPAhpRS7AdHphXL1THPnj0kek9VlUyLKdOXFhTVFHpHHAaElSyrOctqgmu34C3OgfMSkxd4Ooa2gyDZbXuKvGRnLUFIXHDUbcfHDx6wsy1ZlYMM5IUiKyLe9dT1mkwb/uSf+jJVPvlcr5FstMxoU2L7gVmZc+vwNghB115TlitMniOl4mJzjkCw0KtkD1ARFzoyqRicBwHaJLbCDRbf9VxvG3SuCTLQdA1tu0OLUybZCilKhr7FhhqhOgIDPkgaAlJYCJJJOR8rZQaiG5JsNgSQhoDEx8jUCDaXDe3mGskUbSJ1sxsl7JKLy2v80pBXBktAKc123TEMgluHE/7Nf/Nf4K133iXLQeoJxpR87Wsr6m2N73vapuOt1+/yK7/yde7cvk2WF3gJr7z+JkoVfOlsx3K14vTOIcJoBmuZLnO+9NU7dH3Ou198CS0tzga0NAxxgOjpdi2TxZRCg4wdITo225blfI4d0jMoUxmWFIrpBomLnt7ZEfBUhD7VZnphsNZT5IpcBbxTeAGTqkxMhBsoqwnLxYzgPEPTUujUK9vbFm8tSkms7ZnOZglAhUiWFxiTI4IkzxQ6wuFkTjc0mOmEOIGm7qh314gyYnSyE1R6gnTXCDcwq0qWk4rFcoHSEmk9y/khhTFoFNV0ggyCVTbHa0svQZSaXGu8C9xa3aLpOrxznF1eUFafL5t3fb1mGCx5NqHv+5Q0nhcMhWO73eGsQ5t8zDNIe6TNZsPp6Snz2Ywvf+VLfPP3v8Wnn35K13XsE8HLsmSwA21niVGjVcHl5SXn5+dst1tOjo9ZLA6x1vLwwdMbIJVlGbtNgzYOIQwff/wISK9PYKh3Hd4Ljg4PCSFQlIbVasZ0NqXrOna7Hc71FOVzabZSAq00dnAMIpCJAiE0Asunnzzm/Pz8Rl4+nU5v5MwAu13Nw4cNdV2PLO6AVprrpiVGx3w55+7du9RNM/7spAho25ajoyOU1rTB3Uh8Y4xpsDE4Ag6D4qBaUeYVQULeF9R9R2sHjFLM5nPcCP53ux1t296w8iEE2rbDD5ZOdan6yDuyqkBqDd5hvSfXGbXbcnh4iNaa3W53o/Zs24bBtwRpMVqQF4YYInlWUNc9Xedhrsb9E6OnegRkIZLlBm2mY6CeH4+3+szetigLJlnJ5ZUHZlg7IKJlNp8nxYVLqfF95zC6oq0Du40lhoKLizPyCvIsx5j8BvCsViu891RVxcHBAc6lZ+bBwQH3793/XK+RP+pKYNY/D8ESUBYVVVlicpP2pKTMphACRZ5TFAVayFR5rUhSciJCgTRjb3nb0W2blJcREjudtvdJActN289zhalzLn1OyZGQCi8A7tEqKSA4B0S0SKjO+0DXeZTJaZs6DUyUAjRCGpQyaEFK6tYGKRVKpaFdAtwjOXYDOfdm0QS9xehvjQiCH8+PfEJZlMwmFddKoFBkAjIYq8QiWiSpvRIRFcCGNJ5WSiCFRsmcSIbQkEKfNeCIwqfXLlwaDkSHCIJqkmM9XMWOpncoFLr3GKWp256rpqENguvWsq0HButHrKgAhVCKTKuEIYk4ApnRCK1GGb24qX5LNcs3Uwr25Nxz3LcPy05YSsokWpYinRNS3siKx6///3Pgvb+JJE8KtG1KezSZYeiGVMSuFNWkom7bMbZeAQbnerwfe7VjhxCaKs95/eVTlssZH37ykG9+5wc8Od8QAiitGcKLJ+WPlyFLZIrKZ/+LIR19pcY6N59qt2RKENRGpx7uvksVX5IxOTytvYcqrR/HdO8/HqsBRpZ+8KM/m5iaB5xHyXTCiRCJYd9C94+XPrzIIr/4fqWUKCEwMZDHyDR6Mh1ojOC6FGykYm3dmBcRR985lAoqIci8QzqZTvJxgvRc6bOXFTw/zvvpFCR/94tdeS9i46SICYRxavjj1o+T9eyP74vTrJ/munt/Brqjjz3/7v/yf8HB8QED4IJE6pxX33qZJ59cITLNpm7IMsm33/uAo+MJ/+lf+y7/jV98m48++AG3375N3V9TLpb8nX/4LeRXMu7NDnjy0Qe8ee8OR7MJ3/34jDLTdK6mWXfMqpz6eo0MgsefPODO3Vv0XYMkY+h67tw95uMHH9O3O2aLKU+ePCBYz/27L3F9eUkYLDoEDmcLHn38ER/84EOuLq84Pjlms72k7ddM51OuH5+jdc7p6T1WywO+8/63Udmcg8WCRVEgvaXSGq0E2XzB5uqMLMDcDPyzv/YrVKal22746tv3ELZBZgpJxOgkNcq1IDMaby1RCLyziCzntdfe5OGnD3n06Iy2CxyfniDkI5pdydCf8q0fwN/6ew9wMScqwcmtFYGBXWs5nB6R65yhPeeXfvGLfP1n3iTGjrpp6QbP4rDC+pY8z9EqQyIZnCNKRTFJPeNCSLZtjZGKtmmZLRdp8qskynlcP9DWNQhBXhapRi9G1lfXFEXGZDLBhshiOaEfhlG2lyoIjSmIPpIVGW3dMPQ9s2mFiAItFFIY5OApVU7jLNILDucHfOmttzg5zLFdh3eaopgzxJrgAlVR0dcDZZ4zuFQH+OTpU57utmx3NZvtlmxekpUTrGsQNtA04yZGRTKjyQrNfPH5Am8tFUJJhj55JYXRN9VKSqcNhcczuA4hPFpLvGgROhCjRWrYdT1d66iqVEUoRwCnM433jiEGrrY7HpydMylnRF2gjaHvuyTZ147gO7wP5DoSnEMKSZ6VY/2hoCgS2BKjj8+7ASVkYsLaht0uEKNDyICUkeA802rK5cU51gIicL2+QipJsJ7rqzXPJj2L6pCf+/rPgUhTeylA5RlE+PN/4deZlhlNvabMFGBZb66QRUYz9KBKtldrTu7c5+DwECEsSmVIIvPpgr/4z/8FnL1kNhdsNmdMypIYBy63lyymM2xfI0KkyjJUiDTeElEMtkdJmQK02jo9Z4JHSBjanm5oyPIFvW3RShMIoNJzZtvsMNpAlLRjjkFZFsQY6YcOCZRlzmRSYt3Aen3FdDIjMxlqpqibhqIoiDHQ9y3lCAT3bI33gUwnubD1DiQUReqXjTENXKKAxXTOs8tzct0koBxBBgiDp1AZkzzH9j1RgMkU88kstW1EKIwhyyVKGbxMz1ipJJumRkmYTqrP9RqoqhLvE1iaTCZkWUXXWrqu4/r6GpUJhEj92VJKnj494/Lyiul0yunpreQNJQWe1XWdKgnLkqqq8M6z2w0cHlUMvR8B9pau6zg8OOVgdULbNjx88ISzp5e89NJdymLGxfkapQJVGdjVa7p+R1VVnJ6eolSSm4MmyxSzWcVisaCsMkK0KKnonEugMMsYhh4hIpku6AeLcB35ZEHwkuDgg/c/pa4bVquDG6l5jBGt9Rh21eF9xmaz4fp6TYyJSVssF1jb8cknn2AmU9wIAufzOdam49e2LT4EupCY2O12i46C48NDMpH2USrA4WSFkYZ26GlDR66Sz3ZzuWW73iDGAKs9qN0D3ARCBQxpmKWcTbY6mTy5+6GdcJ7Dw8ObpO3FYnHjwxdCoLQAkb63kpKhGyhyxfq6xjuB0RlqJI68DyitKYoCqSR5XqB0TvQCa90NM5h6mBXOOba7HY3fMdh2PE8amigZBkee5zS7ga7rkSJHSUcIkcvLLa+4Gbu2RmiDzidUkyne+5sBRAgBYwyrgxV9lyxLeZ6z236+AYR/1OVHibiLaSCR5xl5nqX0dZIS0/kE7iaTWZKQ74kplQCpUhKhZQKnztHWO7pNix/CDaiVImUjxRiSpN0/D87bA+v93tWNv+OkEHE3ZFiMcbSgqhsLjXcp3dw5S1WW+N5BjPgAIsvRpkConEyOLU5So6Qaz0M1eo9HYmqfas6e1d2rABh7vyNRpHMkM5HZZMbBYsFlkUFnKVWqETMyYsaQNSVFSmsXES1SsrmSYmTtM4TMU9BblInllh4Rk3ovBodAQ7QQAlJahDL4qLi87uldwlVKF2QF0DuatsMHhdQ5wnVpWKUENjxvhfI+4GMkjHhMqqR402qfYh8+M4j4YWwghcQHEqEJN6z2yA+Onm5IlPj+q/7/HHgPtqNpa+aLKZvtmrarKauDZJgPnmgt09mEoe9Gr2fgaLlKG1Wb5J2ZBqVTLL0SEqMDp6uCk4O3Wcxyvvvexzy+2NIMkWZIMmqh9kzxc/kz7KXmIaXmRTEa8kfp9+iNkIBWibkN3tO64Ua2Mogx/VDCjak8/nhg/MNy8JSRIG6k5jGGFGYwfq2RcrzIdGJ4eB56Jn7M933x4x9m128+FmP8f4CpEsxyjZMFbZbxSR3YOZ8k7zFNvAoBC6NZ6Iw8AM6mUDRAKIFEp0CDEPFjMMH+NbxYkxZ+5DX++GPz4g3sxb978dj9tDzc/1Xr8P6Eq/NnKKWodz0vv3HESy8L/sP/4G/w5/7Cr3J894SPPnqQpu5ZJGJ5+Z03+frP/TwfvP8R/6vf+Y/40tdPefP2XZ4+vmJtLVebgYuzlpOpRruOYXfOX/rzf5qz/9P/g6fX6zFIT1EUGX3fESXsdhtms9c4PbnLp588ZLfecfboMRgFUqHR3H/pJdzQkysJduBnv/AKv/5nf5m33niL3/j7v8Wu/oTjl44wSnP/nS/wwfc+weQBLT2TskJFwSTPWVU5h0cphboZdiynJccHE3bbNf/sP/NP0Wwv+ad+4WtsLi+JoUVEx3RS8iu//It8+MH3oZjx7W+9T6yOCX6JokSi6NqaXIPJDDZEum2LUVM2/Yb/4K/+A15+98+yMwtMvMP773n+L//JN/nBRwPz1R0GP5BnOUpJDk9PyTD4vuXX/tTX+ad/5R283RC9p5wUVJOK3to0JFLppoyQRKGQ2hDlqC4TkOVZUoEIgw3JT2RtwIZAUVaYLAfS9amU4vLykjzLEVEkBjoKrq7WOOswmWIyrTAGUhi1ZugGhqHlaHlKxOJDZFYsCEKQG4OtGzKTszys+OTZM5azilfvnFJEWK97TCwRxjC0liePHrKcH7M6OMW2A5+cP2Xwjm2zZd3s8DIgosMNDe3QEYPGeUeeacrpjGU1Q0tJ22w/12tkL8uLMWLyLLVFyHTP00YjjSIQiB5KXabQIZIqyduOwfcMKGxecOWTtSgTBkHqQB2yisZH2nzC8WsLrh4/5NOnF2x3Ww6X86RPitAndAwMaJWCdFItjSYzis52WGtH9mSCDx4pItv1GiUkAYeUGu96ut6SlSuIkSwrKQrD4FquN5cU+QQTJZOyxBiThiODG+tJBJvNlhBT/VmeZ7zxxqt85zvfwBiSwmvo6LqOy21N021R2RwzWeJQuHaLjD137xyg1cB2d4FWDtulJooYBopcY9uGdd8yn00R+4jaALnJcWMab6YVs2mFMZq280lqSURrwTSb0LUNfVOzWCwRSiFN8ip23YB1Aa003kUG16GUoKpKBpvCi6SSzBdz2q6l63oiHqUMIQSqyST5ZvOcsixS6F1IPk0A5zzeJYAVBPQ2hREWeY4g4HuHyXOUVhyvDlCjwur66irVVJUlmbYUuSFTCtc7hr6lLCYoIM8z+t4ifECptK8A8MFRZJrcqBfKOT+fNZ3OWK9T2FnbDDgXubzY0Pc9t26dMrgOJOx2O7abDbdOT5LX0To++ugj4hB56803ePfdd3nw4AHn5+csxuHVRx99BHQIJJcXl1xcXKSNqkvg6f3330dJxf17L7PbNlxfb6mqKUVRMPQDRhvu33uZx08/TUMApTk6OsJax9OnZ8znc6azpPzJi8S6lVWFdV1yyflA3zdUZYHIYRgsxAFrPGePL8Fpnj27ZDKZUFUVu10C+EVR3AAZpSSvvvoqIQSGoWc2q6ibNVlW0rY1l5dXLKRmvdmgtaZtWkxmmE1nPH78BKUVXfRJZr7eUGjD2aMnFEoTfcDWHW+cvsLhwRHVdJoGVF3L7ZNbOALr7QYnweQ55+fnWGvZbrcIIVJ6ellSqHT97uup6qZh8C4BghggOiZ5iVYaZ+2YURDo+h6tFZMqqVi8c2lQEQp225rttqYsJ1gXKPMc71O9UVWVrFZLtNLE2AOMdkaJMYkxH/qBsirxLpFby+mc0lRsNtccHS6wveB6fU0/DAwD9H2HEgVaDYQgefTwKa9cTlgez/G+RovnYW0hxMR4h0DTtljryU1F1/Vs1hsikT/57ud6mfyRVgo8FmPQXoVSaTDiQ0h+45AC9YosS3vrOKozhSCoeJMQTgy4uqHb7ei7nmhBBJGim8Zdd4zhxrO6f4bt71P74Yz3HpWZG9n5XiWxH7iYzBBCSoiXEfa5UiEOZJlkt0sDI+dTlokVamS4I1oKUObmPe4Vnzc8txA/gjr28vawD3pDjRJqn/IGFovURW93FFqQqYgWKY1835AuGCvIJeOgQqXAUmUS8Eam/wlNqjDzRGlHv7chhg4ZbQLsClzUeJnz7Lpms2vwWhNNktWHKBBKJyAaItFaeudxLnV5iyiTB91ojJLEmI55ZrIb7JHypFIW1vNBxPNjkrzjMQ2+R6ghpRgDBwVChptjl4jFn7yC9icOvLdNgxCS3to07S7TdHoYbAp8mFSYPCc6S3Ce2WyGMYbtZovWGcZoQvB0bYOzlpgZ2rZHaY0xBfduHbBaznl8vuX7Hz/hex98mqTbQo1sRhpvJAFG2lELMUoUhBixczqBrQ+46NEyIKJEkTaOzntCFLgIXsRRzjGe9De4WXzmIv3D1mfZ2htBfAptY5zy+BSsthePRCE+41mHH5JZjxMcSUodH/8FMgRKGZkTWBYZWgb6pqHMDCdlRj107GSkiWBJX69CJJeCHBDBE8KepU+vM7KPs0sSG6nUTZojPJfYpITzUX4fkxeSGNN06ofAdNinHDx/cz9yjF4QnD/3c7zw738a69V33uQdZ/hP/+P/nOrEsH52yR9847vUdctv/NY/5Bf/5BcR8S3iRvLkg2cMvuHX/plfAgeXynN4/z5Pm47fe/+C7RB4cr7mi2+9y7svv8aXj1eUBB5fb7hTLfjv/Xf/Bf6Tv/EbfPp0TT5ZoPMCVRYoEzCVQSjJ6uCYTz56nM5zGQh9qn44ffUljg+mPH74EfW2oTI5777+Gl//uS+PwYA903zGv/ZX/grf/P73+Gv/+W9Sxhw6x2t3DgnDlr/9//rrzLOcN+8c8a/+d/5b7DZb/vbf+pu8dOcWVaH58hffTGGgQ45vzunbK1zwLFYL8rzg4dkzun5Ay4FbhwuYTuljh+0kipzaXiCzEoPGdpGT1TGLasGVOuf9i5r/+f/6b/LLf/pdchX4jX/wbT5+uGMIGaIfOD5aISwYaYhdhw/XvPvWXX7pF1+nqy+RIqBlCn0SItC2AxBxzrFY5Df3CxmTPcJaixw9plJKMmUILtDb4eYM7PoenWc459FRUhjDnVt3kFKO4T8pdEjqxEg41yOkwHYDMSq00hAhMyVal1xd1iChblsOjw7o2wTwZpM5BZqyr7m4eIjdzei2LWdnO45fKonKEbzi4ZM1V2vNh582XLYND9sLzK0pR7cPMXXJ5XqdUtV7m5jisL8bgkbQth2fPHhEGOzneo14H8kySVmVDENKHs6LPDHDJKAltEaonM1uYB0yeg9KeGaZQQt348l7evGUPno29ZYYITcVwYPMKrLJnLxcUsxaOr/je+99j7ffuM+kLJA+BRcFoG7XVEVBVVTECGVRIKRk2+zShsUH7Fjp5IIjzwzRB4gt0ed0nSPPK4TRXFxtKMs5Skuu1k+JwWGkBtfT9RdMZ3dphxqjyvFYeLxPwUSTqsBozcHhEZPpDBV7qrJgUhZcXW9AF1g/QJRoqdnVW549+gHvvnmK1oa2uWLoLsgmGd56gmsRKiCi5Wi5QCtNkefMqwqFojCGIA0+OoJ1FHmOUZoYAlIIBjtQZhlaJ3tC1CmbZXBpU+pGJnoyn1Jva4bOUlQFrk45B9ZadvUuPbtmM7IsY76YUpYF9bZGeMjyHIS48fGBSsydSABsCB4tFUpoQI0brIJdvcUJR64VWWFwzpJlBccHh8ynyXdcmSJVcxmNHrrE9BcZqiiwg8e7HiVLjJRgcowRCKFGBiqilaRSBd5PU5jQ57guznd0radtdmM6tEdpKEvN4eEhZZGz3WxompaXjk84Pj6+YTWbuiZXGXdu3eZkMUUMh9xazcjznL4f+NIbrzIvnyLVQH39hFI7hJZYGYnDhqcPzpA65+d/4escHc64uLhgc32GEIIil2QG5ouSKI8QwtG0G56dpzT89eaCLBc8/rTBtyv67ZyiyKjrHXleUbBA9ROGIbLuB7xrUlWW6BB6hpzN+fbvf8jldiDzms3FRQIvfU8xnTI0DUbAwXzKKy+dkmsY+paPr85YHR/y5PKabhjIyiX9lcXXkdbW7C46Dg4PWR1VFGaRrtPo6DctJhjqdUtXNzQ61dZurq55dnbN6fEJB4eHKK3pneX45IQ7d+9w6/Zt1l3NoydPuLq6ous6hmHg9PSUg4ODVFPWd0l+PDikGmj7HqEki+WC6/UaIw2qDhRFxnrT4EOfUrSBvMroYouZa/rBs70eWExXPDh7xtP1OYMZqL0jDxVROKLoUDqw214g3JKqyujbHUpqjNSsr2vOn11R1y1KGRaLJbPlFPKAyiTTvMJMJf3Gcdmes/MbbDRoAzqDEHu63nFx6Wmb+9yrTri8fozJSjJZ4HVEYlGmoO0a9HTGyXKJ3TR0TUNVVdjP+TnxR11ZrsnzjKqqEjiMEe8dRMi1oczz9KyXKalejnt/JJBJhBbEvqevG/q6wQ1D2q+SrGAkwjtVhInnO3TnPbDvDw+4oUcrjckyQgzj/YwbxcNeku69G0OII0JopDQ4m1RXArAuEKLER4lRGq0kQYnnYFvtA5+fq0Zf9CC/oAsds64S0ExkndgjHqTWFHnJfD5nMV9wtauRSqClQIgReO5tsjG1ruxtsEpKhFagNELqsY1EglAIHEQHShBDGmhEF5FIkJJMwYQEvq/rlvPNls0woKqC1keE1GngQSDIJG+3zuIDEEMaHJgMpTWaQPRxlP7H5xXLQiFFevej4JkXDgvBjz3dYs92Jy+3UqPiVnz23+9x109y/cSB93VdM59O2TQNm13DrWqKMTlNXWNDIMs0g3d0bctiNmexWFDXNU3XsVod3JSnxyiYzZekIyMJUmNDJM8kSsDitRNQgY8fPWRok6dCwChbF/jIaKiPSLGvoh9P0phOJEfCztEFjAzIEDEIIprBRwYYLd37qdLotZH7KoHPPrBfZNnTl+6DGkbo/oJHx8dIi0vf3wtUABkliDAm44sbwPoZ0C3GFy0iIkhilCkNEU8ZI6/OKl7WgaNCIaVDKMHEGA598rmZ4LmMgsd1h4+CXEsM+6GDx4Z9sRmk3kSPE6CMwCiVatZIBzeMN5zEIkLEJ094ZOwyTzLOGAJiTJbcf+/Pnvvi5ifuP3Pzp8gLXo4f/ts/5qUtzja0tmZ2MPD0/LucnBQEP+HdL79GUQy88caUo8kx7x/lfPf9jxFF4HC65H1n+X//jW9gFnBZa1567WXaS4u803K+e4/r1VtMD+7SXG35P/8f/z0eXFiqxSFfOrnHo2dXtH1HURqy0hBxPHt2zrxaMZlOuL7apcTqztNsLR98/wc8yAX4HiUUt5bHRDL+9/+Hf58nZ0/Zbde8eveUu0cL/rO/+gccTQR/6c/9JX7z7/1t/mf/k3+L49Wc4D3v/eB9vvaVL/PavVs8+GTgL/4zv8qkzAjBkmvB1eU5ZS45P79AqhR2Np3PiD4weMtXfuarnF+uUZMpWyf55GKDKpOnzLqBtq8xmcY1PfNFyWIxBWFQ+pCuz/n3/v3fo5gt6XsQYs5iLhnaaw4nC37tF9/heL7kg+98n3ffeItf+PkvIkKNVOm6z/LsZkBUFCNTHfed93FsD0h1GkY/b2LYqzFMtg9sSdWB0TmGEcC4GyCRbqhZlrGv/dh78bqupm1a1usNBMNqdcjQD7hoOTvfYYwiL5Ij2g6WsqrSgNJ7nFK46HFjwm5VTpnNT6gD+OgwSvAzX/0iXSv54P0H/PZ/8Q/oK3jz6CuUE41aTFFas+1batcShMDogiCgaXqCihwup2yvW9TnXKWUZznOO7xPD8WmbymLMtWx+JBApO0ZYsaDrYVqSlAFu/Uzdmc/4EuvHXE0myNsCvR69MH3aW3DfD6laXaIKJE2p8qhqR3f/f73uXdrzuntU9abK7Q8oKpm6c4rItW0RJE2RcZkgMBZN4bHpHtVCAFtRJIpxgT6J1PNdpOqRrx1bC7PieRMZhN2u01Kwo6RenOFES1VZRFmx/Vmx/HBPVLMZaTIDX3fsNttKIuSPM8oCkMcPGWWJe+v0tRBYG2Lo6ezGy6ffkwu1qyWx2zWH3F1+ZiD1YyyUBBSmJtWkXZXI4JHaUOZZQTr6COYXKTnXogMQ08mk19UqlShqaVCSYEKOnWlBkeQgrquAZhO59gx4bioipQkHyGKQIiBrm+JMYyZAjWD60EEyrwkyxLAt7ZPQ2SZ6mq8HSizHOtsOtZKpeMUACRFnuTqxiSwbaRKibOS8dmrkXgWkzmlztFaY4NDa0031AQ7YExGbhRRyeR7FSTWxIJWijzL03sdxWsH89Xn/jyxQ0hKCF0wmfib1Ojtdst0WlLoDOE9y9mM1Wp10/oSQmA1m+LbnnZzzYO2pixLTg+WScbcOV556Tb377/Erm25uLhgOU9M8nqdwhSd8vS24fvf/xZNvWOxKMaaPsNsPmcyMVSFJsuXZDr1sHvv0VqPfnRDu93Rblu2V1um0ynX19fJAx0LCjUjzxb0saGtLVpLTAlXu2uiDXzw4BHbdmDmPLdOTnn9jTe4d+8e1lo+/vhjpsWU6Ke4riXPSrbrNavjI7K8ZDcM2CAhRNy6RcmMSV4itKLdWtr6KVmRU1QFeS7YOUhK10i5St3NbuaYzBYIF6DIqN2A79uUHh+T9+PQDvTBU9c1Simm0+lNeNh2u6XvexQCrRRaJNth9DCfzjhZnRA6TxU1y2JB23WIbrRSjQFrBTm73TVCSUoxRZZzbKP41je+z8XlFVpVRKlwQVM3G6ZzgckEZWEwStBsaoQM+NglS6OHKq9wPcQgydWUaTEnhC7JrMemB6WTpUMpRbWYkfrhBUWhAcngrplOZ0DOYnpEJgy5zohaoTJPHz2PnjzFikg3WPRuPA5Rst5sPuer5I+2ppOCzBikCATn8c6hpKIocnKjkzxbpF5tL5I8WSmdlC3BYTctfVPj+uGmy3oPzIVIgHvULSfL0U3H83OGWwiBGgPcnLM3bPgecD8H3SmFOwhQQqW2EhcQ0gCSECCQ0QeBqpborCDqQFA2ZYwIgSR5mZ83Jj3nmeILGUgvsvF7T2jcC16FREiNKXLKYkJVTjgXAQ+EfZ5SjMSxElmikHHPf3uMMag8I+aGYAzSK6RQxJju1YlYSynqOIgigyCJQoPwFLkgOJiUhqAk67rBNQOiKJDGYERAisjORhprCTJijE7h1d5jXQDlMTLeZOW4weJNwKNxQpALkfBSDMQok5o5BMJoUdrPUqUArZ+3T6XjJUZcx6hk/gyt9xNZP3HgXe9qptWEi/OLNEmRCjtYrHMorYEkb+m6ntlsTt8PXF+vU5rkeGC22y2TyYTJZDL6Tiy26zk+PmZ7+Qw7dEyLknunB/zMOy/zje98SG9ToFeISd+vRjDoIykJXSTBRIxh9F/tGWPBEBPzq0KS1CHAe4sN8bkcQ3wWOH+Gk/0nCfvas/DWo6JAxjQUkFKyd3r/uO8vEISYZJOp8w+CjCgRMQpmRc7JJCNzLSJ6ptWEIBUlkXmuOJYGPwys2x6hDBWKXOx7+wJRpHcc9vcjmfoqlYo3shZ4nqb5YjBaGDvWpUqTOzEmGuz71PfY+kel8/yQ3OPHg/B/4mP9Oa2uXxObhn/xr/wCropsv/EdTle3OVncYn5YEeSa6emEw0XBvftfI/+dKX/1P/t/8q//5f8m/+1/6V/kK7ff4R/8w9/i0//yI977re9yeHvOl964x7yy/Oa3f4/rp7+DMBNWL73BULX0LilHjg+WdK6n6a6RRjGZLrm6vGB7vWN7dcmknCCj4O6dWzx5kJJyV4sVr77yKvdu30dj+N73vw8qcL3tmM4WfO2r7/Low++TWc+/+z/9H3ByepfNoz9gajy5tDx69Jhv//63ePDgEw7nqeZGiMjv/+7v8+qr98lXc1aLCUpGykKlQZId6G1PlhmEkTw6e8TZ2QVvvPsVrlrHex9/greKrFwynU25vr7i5NYhgY4gBPfun/LdH7zHm298gbysePyo4TpITG547aU7fPDt3+NXf+kdTpaSv/RnvsLx8gD9Z3+Odrfj+uoZWS7xMSS/tbXsU0L33sI8z8f+V4X36QEsX+h0FEKkHtd9aOMYpIJKwz45DoGkTA9Zay1aqQQUvEMpiRYmPZQDaGlYLZZYGxDSU84ydrueySRN74e+p6yKFDIXArP5jLru0HnJ+cUll5drOh8wKqKrAr+rqWZ58jn3NbZ1/OwX3+DoZMHZsGGtBnbSU+j0IPTBM4SBIYSR8RY4F1IdWl7yZ371Vzl7+PBzvUa0VjjvEoMAY61aYiiSEiANSbu+obE9ylo0GQJJNJqHl2fsNlf0ted623D34Jh7t09ZHaxomo4oJeebLbVztK1FSlgsFty5veLi6aecPTvn9u2SvJww+A6pwEiNFMkz1/f9zb1r3wushQb8WGflccGR5ZoQB3zI2Wx3tF4jFAQc3dBQb3cIJFr2KLHm/r0JQl2lzZU4JFMF3qXgGN8OPHn8mOACR0dLTk6PefrpJ9ghZZ4gc+ptw+HhMd0Au66F2HLv7pzJxLK93pApi2JAxhzvB6SAQmdsXaDKU9UUYw9vZQxZZgg+scxZlo0DpMQMFUWRuppDQCJTUFST2jzm5ZzBWqKHTOfEGBncgMePsk/o2i5dDCLiYsB2DWpIgwsRI1pnOOtxMZCZnH6wifn2HjEGXCHAesf15TVHy2NmxqSfSyDPMqQA55M333uPUCngVGuN7XryLEu2sRDJjEKZkhjGdpIIQmQolSShMURyo1EywzqPCxEhJCH4BObF57st0mNd2j7Re3++KaVYzOeUJiPPMoYhJfsmGX6Zqq26js35JdeXV7Rte9OF7VyqCZtMJxTTObu2ZbVaAemZuF6vOTs7wzmHDYHL9Ybp9ISXX36ZzWZDVVUsl0tmsynGSHrbsZjNUyVXnqcgs+02ebJNBj5wdnbGcrlkMpmgtb6ptpJCUWVT2m6LjImduzx/xvXFU64uz6iKgpVeMp2uCE5wfbXDO8/6aocbwNnI+dkFBwevc/7kGdYF5ocrLq8u2dQ7Yogoyw1ZoUc5fF3XZFKzOpoyxI6yLGma5ibUDCDP8+SF74YbcGSMYTqdEkLg0aNHfPLpJ8wOVriYEt33XePDMNwMHyZFiQD6vqdpmpsqt+12i1aaTJfEIAgujkFUOtlYsgKBIraKzjpmkxkVOc8uN+ye7FiaBSdHd2gbRYgdi9UEREOMjtdee4WDgxVPntYYpdg1Nc4GptMl0+mSsmiIUVIUEzJVUsoJ3vWE3uJcYLve8uS9x5heMZ1XGC3JC8NkUjAMHdZHLi6eUU57hOiI3rJ9uGOz2zEER7WY8/Dp4zQsG2pePbjHpCgJPqRz4qewMqNH4JX2p5k2lEWR7t34RDqJ9BxXUqEyAwh83zG0O9pdjRutZoQ41vfGz4DnvRpuD6SBG+/2ix3nwI20PIRw8/zYA+BU7ZdDMATfE4NF6UBU4FXAS6gHRT47IZudYDEoFPsANSF5QWL+Ym7UZ22YP86OubeZCiHHjAFNcBlZlpMX+WijtRDVSH+FFMQ25kLJpM+/uU8ppZBKJ4Uroz8+jDp+xAh2HSH6JKcXEiE9MkaCgLyQzOdz5ruBxnoG64nOpUwvJUY1R3rmaqVT+wWBED29dwxDskFp0qBY4ogqooVCiz3xGW+whY8xJfAHUoieTDL/vcT8s+uHaL8/BkzxEwfeXd2zud7RtQ3T6Yxh8FxsrtI093CFEJKmacnzYvxzQ4yp0zqEcFNvMJlMbja3znkWq4M0GY6BSVmSSTialfzSz77Lalrx4SdP+fTRM+rWIYjYKIghBSCkCrIRzIoRGIoEqEMErxR9BFwg1wIbwI2S77RdTevFFPEfDlT7J1nSB4yNzHNDMak4q2uGcYOUMtc/u26qu+IopxGSMRsCLSATYEIKBFExYoRC+CTXwEe0h5k2bAdYGonQhiIq8uCRMQXuIJLMQ7gBrSUonbZcISUY7r0kLw4i9n74xPiNtQcySU+iEOMRjJ+RiH/mxhFflLc/f68v/veHj8FPYz1++Ii37r/C0eGK7z58n7brmBSak+UEpT2d8+iouL7eMJlWvHT3FvbvD/y9v/4bvPLr/xwTEfnam6+wOJjw3gffZaBnuLqmlQWL2y9xWV/x5GxL22m2TWC3q7l16xiIzPOKq+tntP1As224eHpODILZdM7Ras7l5TnPnjyh7y3Hh0veevN1Dg6XzOczLp5d0buBN998i/a73+aLX3ybn/3Ku0x0w//ov/+XWR1MefrwQ966f4ers6ecLqc020v+/J/7k9T1Vwm24aU7tzk/f8bJ8YqD5ZQQBjKjiD6kehUpiEbT+4Htesu9V+5Rb7asDpYQHVWuuHWw4MOHzziuZpR5gRCeoQ/kJme9bZgvSr7ypXe4vNiyua6ZlSuKZU5RafrNJX/yZ77Iv/Nv/2tMsw66a+rzHV07gJQURY71lhCh6zrW6zXT6ZQYuNmYJWYphWV5HyjyDOcS25Rl2c0UOI4PP5MZnHO0bZOqZrIcZxPTqZVC69TZva9b6fouBZtkWQqMEprGDWgjsbEn+EDrG+p6l/pvjeTy8oJcp2uupEJninW34/ziEms951dbOmOQomNxsML6DSEOdF3LtJyhsNw5PuB0csI//ME3KbUgSInPDM1gyLxEIHGj6qQsDdI6Hnz6MV05pdCf7yOh6wesdUglUUreMAjBp5AmY0zyVK6fcXF2hsiecOf2y5QZ+Cptcq63NaUseOP+y6A0nz4446NH16ybgWpxgKrmBKlxouD4tGdTOz74+Akv3TpiNl1wvdkyixKhQOmUvp8VBUKkc6FpG6RKfaxd05HpDBkD0hgEqUJI64zZomLnJUSP1hk+Rh4/fECIjrIoiXagMA0nh5HgnzAMFkGGcw2KCaAwWjGtKsy8wFpHNcnIqxW2q9mcXXNyktEGCcpglKYXFts3aCx3b5+Ca1jOJsyrBOL6piEGT5YppNBMJwt2bYupSrquwUiJyRXKpM3XZlOPqdB5ylNwA8671Gkb0jBiGHrm0zkhetqmITcFSIkPES8i1nusG9AmyT532x3BR3x0WJ+MSPPphIjAWo/tG4RUmCxj19S0XUdRVCitaNqW5WKBD57zy0smZcXghsSOe0/09mbwLaVk8Im1tq4ndZDE5Fsf5Zn4iIuOalLSNQ3E9EzXCpwf0GRIIQlBELxFaJ0UdGNPbKaSVPXzXFmW3WyO9wO//WZWKUU/DGitKcsyhUQJwXK5JM9ztpst7Xp744nWWt/4j8uyJMRwE1DWdQl8Wms5ODhgMklBidIoWjsw9D2r1YqmmTOZJJ+38y6Fp0aDipCZjNxkmKnipVu3aZoaQZLt7jup9/3bxpixrqwnLwxGZLi+5bI+5+qixfYFhZGoWcVEzhAonj495+OPH6SO8LLg5OSUsnJcn39KdJKvfeXrbJod27pN9XfRII1C5iopi/oB23WcPXlKsA5hPZssg0rc+OT3r63rOmKMY6p16lLO85zZLEnuIV3/eV6w3qxTivI41IgxjqF/CWzX4wDgxXCtLMuo65qhHzhbdxRvl2RZTow9bZsSxPMMhn7AN5K27RjUhqaxPH50ge41hTPIHia5pnPtWLHreXb+hD/49rcIvEoIPU3TI1W8OT/Cnt0cbULCSSaLQ5RIgVdSK7b1M9aPr3nrpdcZvERVGVWVo3QKnLv70i3KqmCwHdr0+NiC7FkscyazA45OT7l/74jzywt264bQ9+hiwq5pf2p7LjsqETJtKIoyDdxCGrhFOYJVJUe5uQTnsXVDvdtg3XCz5wzeJ3VrSLvRpIh6vn/dD8j2oHrPZO9/9z/O8/3iNX6TsO/jaGfxKJ16rOu+Z90GdKuYnb6JNnOsqJCyQIgb6J0ssjINEfYvbz8Y+GGm+0X88Tzfac+Up/20lPJmqGQyA51Lf0+A8OIePI622dEnLiVK6QSItSEITwzieVb0iK0IIqWzi5QtFEOyiUUFOjdMp7CaW3adpbneYnuLkDqpGpWmKhTLWWBwHhtHFa/SqSfde0RUZDEiY6QykmmpmZWGTHajrD41RlmXjkcgvRQxBuqltPTnGCJ5up/baP84109ean65pm97pFRomXNxcc12u2E6m+E9bDe7kYUy2MHR1C1apQj9fcjFvv8xpV96qknFbDqhbmryvMB1DYKIkQFhG16/e8Tr91/i0dNnPD675OJ6S2MjH336FB9s+k0IGHMBR2XJWPIuEiMeBbgQiIMnjB7u566K57+kF6diL64fvhD2F+v+4x9egshESxYhcqsqmB6v2H7S0LuAj2laE6P/sV8vADl6VCMpLCGLkamUHGSGXAZMECgBth9AabQQ5FJghWeZa3qXI3QBnUOSKtW882P4gcFkKWDBjyyf92GcqImb95oeSum979M7BSmxMQpJlJIgBUGKHxGT/1etH64V+2ky3fsVYuDuS6+y23VcXgdiLDlYLMlVR6El02KOs5pHT2s40WAjtxenbM+u+Tt/8+8zV4qvf+1tDlYFP//Fuzx89oy/+43fI8yn7NrAdHqLrY08enyO7eH0OIXu9N2W80+f0dYtppgwK0pEiOx2NblOSZ9aCCbTktPDEkEkuoHoHNt6y/XmGV/8ypvIPOf09hFtt+FgWbB+/BCmklwpfu+3fhvbD5yfXfNk9iRt9qclkyLjD779Hcpc42zH6ckhITiKMkcpwePHzzg+OmLXNBTTCQfHR3z7O99iMZ9z9/59zp4+S5v5csprL93i/GJNuz1ntjjARYNvIM8mFBJ6Z/niOy/zX/72P+L64pzbRxOqecSIhj/35/8Mv/z1L7PIYdi1yBix3qIzgylLohLYbU8KpE0VKEVRsN3uEIJxOr33IKcNlvfPE0mttQilUEannlCtUqiT0QQx9nS6FFhCjDhrgUhVVYlVGTdmzvlUnycj3nqMNgQdCDhq19LJVCfV+o7VbMniaEF0Aec8u27H47OnbPtIXhasNztENqFczHHdgIvJlrHZ1uR5xTSfJqmXc1ycXSCCQwuDj6lX0+jE1GMieIfMDVJIlFfMgmQxMZyuDj/Xa2RXN+R5TiT55KRI94VoXRrKhRRwFUPPTA8cLpdM/I6hdtxZHNP1DfKgRJVLrq1PoG9a4UXG8tYcbUpAo4VkWlnK6Zyrpw/51nf/EW3b8NLtFVHK1BUdBDLLMFqzZzWIYx+r91jvxuyQDBEC1qcgpLppWEwrJrOMbCcxRjD4BIKESn79MDisr5lPLbdvSfp+AOXJsgJlxBgaJjEyIyuTFO7k+IjL9WN8aDi9c0y3qam7mtpFAkk10TQ1wVu0dBwuKkRMbGEmUxJ4b+1YT6XJ8xxrLQtjaPoWtERpSW9bMieTV12AzjVKSwbXE4IjRDd64OTYx10SRpWCNJrgUxet7fvEPrieEBLbPKkmFFmBDY6m7+idHdUNEpMVSdJpLSqT4EhseQw0fYsiJTZnWc7V1SUHh0tsb4FA1zdoqXBuoBsS6xhCkrXnZUE/OGLwSO8JMRCsBx+x0eGcZbjuKfNsfDYKnLc4H8dKtIIQHEpIMiWJLqXmIsZw0BD/caf0f+2VsiQWhBC4vLxMYXDX1zcp5svDJdv1hslkkhhUrW+Y7+VyQbtZURUJlBdFQdd11HV9w4rHGJnNZsQYuby8pG1bDg8PEyMNRBkoZ6OqwfVkuULpFPAUY2Ive2tBJnbbW5cssUqz7S3r9ZpqMklp56OtZs8Aeu8hSmTQKE26nkKkzAy26VnOS7Qt8ZuOiKSocrTJ0FkK73r77VcJ7oCLc8+iXPDO6++SVSXffe8HfO+D91DCIo2i8z2zqsQICS5gZCIRjEyA3DaOINLA8+Tk5AZA71+jIO1Pdrsds9mM+XxO13WJ+Y4BI4uRHU1Ae71e34DvpmmwXf88HXvc8+xT6s+fnXP56QVfeP0r5NMJF901221KBS+LOUoZMj0lm8zp2oHLs3Munl4wLSoW1RJjcrxWKNdh3Y7ZIuetd3+Ww6NUP9cPLc41LJapp7ptW/puy6RakOcV8/kBzVWHbQWPHz+iri+5c/cO88mMv/KX/0Vyc8TDJ8/4z//+36Trd0wmFUVZgeiIDJyfnzOZCe7cPSbGGc7Z9Gxsa7RzrIqC0klCP1BfbzBa03f953qN/FGXAIq8oCxKjFI3GRVCSrQSSANaagTg2o5+VzO0bTpP5Qiz9lVfY3ZakhiLmyaefejfHlS/GBr8hwHu9G3DzXmx/9i7LoFWIxh8ZFtbVHGLe6+/TpSr8T6fsnhENAiSKlRKkRLO5EgKih9uBoo3e+0fDlXeDw1EosxHvXmyHGiT7iF5ljH0qZpQCjmSd0nRure0JjY7jn7zFPoshAK1/5Y62YLGkOkoExKPwhFDsu/GGBI7HgV5AYfLBbu243rb0A4e4QMiREJwWJv08S4EnE+ZLAnPS2yAaANCRgqt0EZRFRllJlPtsUiydx9GdV26nd94uZUcWfyR3x9PhDQ0EBLij1Mx/+TWTxx442FztRvhqsaHdGPLignr9Za+S9Igo3OIgmFwlGXqBt3VaXqZ5+lm04xVJEWeM/SJMXLOU1TTsQoiBSCsFhNikBR3T7h764jORurOkqvf53rdsG5b2t4TYgpVcR4ikuADUakEcAUoAriIlkkiL2PE/yFv88cBwT+sVmz/uefd14mhvjUteSMrmATHEDoKHJmU2FGuwY8BnJFxiCcj4JPEPHqmAk60YCUDuRSUeUEcBtw4QIg+/anQhlJGVlWG9YKBME4NBTY4fASpNDiBD6mqIY5+GJHe+I3sZi+JiTHeDMziOMTYy0+CkAQhUC8S3D9ykv9Xg/L/X0g6Pzk95On5GU+fbGjagM4LFoucw5nA9g3ra8/f/bsf8rf/7nu8+6V38NHy5OFDvv7lr/CVn/8T3Lt1iBaW/93/9n/Dv/Wv/qusDjK2u99lduuATA1p0xtTF+Tdl+6hgM31M7bbS5arBbfv3OPp+Zo8L1i+VDGbVtjBMZ1MmJclVW6wXcPRasXh0RFvvv0Of/Pv/B3miwnHRwuenF/wxmv3EN01x4czFvI2J4dLbNvyta9/nX/427/LdjdgspKPP36f5WpF27VMJiXzxQyp4PjkmKZtkixws+HNN96gKiu4PGdxtOL84oL7917l1ukJdnBYG/jmN7/B229/gaEdePvVu3zzvfcJpSGLmqt16pctc43JHIiOX/r5N7len9C3LbNK8qV3XucXvvYz2K4BG5hWM4rygMEOWO+wweNjYLpYEocBJdKD0FpLNjKsQsjRYqI/s5GyPknLpVI0bYMhR+q04fSktH6lVHo4AW6sdRFSjlLxijxLPeDXV1cAZFmOGwYsKYiq9S07V9OEnqbvxqGx5KrZMCunlCYDKWh3LV3omC6W6KuaL33hqxwc3MG7HhcD203PbFEhTcV8eQJW8+TxBdPliqt1zdHRKRsGNl1K8tZKUOQZvRrw0eJs8mRmMqXuvvbqS5TK/KHn+z/JqqqKfuhRcvRGSoGNEWUMRmcQE7g6XhyQK0lZTRGySIB3iHgxYXFyj+vWs+47ymqKq7vEOHvDer1Nw1qdKinXO8vV1pJNVlxutsTY4HvLnZM7HC6XYNO9jfhcqjdYSzt0iXWsyjT4sCkw5mZKjqQsM5SKKJ08/giRmJdyzAexjlfuL6iqi5RqLDRZMSXLDBGD8BpvPb1vqKoJIVi0ilxdn7NYnHBy95j1pmWIBhdGZdA43NRKoknDisEFiIE8N5Tlku3umoij61uUluy2NTpL4CpGhyfJ5e2QgvVCiFg/IAJYO9xsSLTRZFLhhwRYrJJIpdFCYZ3Hh5AGHzZtSss8Da4Ga0GlHAVHwLaOpm2oTIHvB4L3ZFLSdB06y0Gm5POhd8BA3bZYZymQCDFW+ASPYx/kGUZZu0QoTTsmnSPSZtk7T1EWWGcxhWEIAzEkwFvmZZKTO4dUhuDTZlmKxHgjAkILQu/GPBluGKbPax0eHiavdNsiZZJcZlnGarVKFrhR/gxJGu2cS2BvtK5sNxu0TCBvXyOmtUZrTd00GJGYptlsxnQ6TcqAYbj5WV4MBJlYu31XdYwWpVPtWy4zlEtWm6Io8d7R9wO+G1hOZmipMEV+c73sK6z20ngRJJWZcnQ8xYWas7PHrNst83LGopwQOo3LAvPZhDt377JcLm9IFCEG3v7i21TqHnluqK8bQpC8++YXEWg+efyQi+sLJrOSIs+IIdANDdu6IYaA3m/2C8jL/OYYKaUoy5LZbIYQgmlR4UYiZzab3VQ/HR4eIpUim5Q8u7zgyZMnN4OFfW1bURRMyyqFrHVJxTQMA0+ePLkBYIvFirOnF7x092XKYsuzsyukSEFak8kUrasU3suW5fEBs4Mls+mcqpoihOByu6buO5puRwgD1cQQCfR9us/s2wAuL6/Is9RZP6kWOBtZLpdkYmBzVuOI6Crn2fqM5eKQe6+/yWxyysnLp3x8/jEffPAJTbshyw1HxxXWNtx7+TbVJD37YghoVRCdp98O+N6igMwpHj98hNE5J6cnNGP2wx/3mk1nGG1STSVpX4lgtD9KhIwEa2l3NUPX4brhJl+IcX8KQEi5QxIx4oikANsPal4MSNvvb/e/63220/462JNq+/+n6lA3qt0UAk/fB1zMUXqJ0Hcx2TG9Lwn0COkhiOSrVhK0SHVnSo3+bvEcKAoSmB0R1Y/kSP0Q8I7yBTXsOCQ2xmBMhnvB9iJiAslx/DlCACKBbq0NWmVonSVb3h70j7+TGEjm6SiTR17KZH9lSERdSDk7QmpyoynzjLIoqH2Hdx7rWwZrqW2gGyxBiETSRW7CovdDATXKxvetVz5ohE74zYUxlFokH+D+Xq6UTCSgSFbDGNLzZE++guSHcdpPev3EgbcWJqX/ek/X9jh/naqmpKLvc2zf3kyDm6bFWpskUM5hbeogFELc9FfuJ0zeWzbrK1YHBykMSQhs2zKZr2jrGi1lqgaRsJhX9IPnn/5TX8M6x7Ora86vN3z/B5+w2Q0MMaRObW1wPqBJ/mjtIzJAWWiCkGyagTjKpffrxwHrP+p6MQFcC8jcwElZMImeK1czz2HbJInFQApC+NGJTJLYRNKwwAiYGcmdXPLatOI406ASK+BjROc5gYgYBwqD7xE+YoTBB4cZvRBCgouJYSq0JnQx+fWUJkQ/hlY9rzP4cRVnwY/xaTL5usMoMw9prvdZZ8WLjDY/9Jc/5jj/8M/6aaxXX73Pd7/xPg8enLO8/xJ37k4pZ2DynugtWmbcOb1LGN7nH/6dbyKM4KtffZdPHp7x1/7e3+X64ozFfM57n6z5B7/7Ea/cv8t13XPnYMU7t+7w7OElH733hLu3T5lP5zTbLcE7To6Pmc5mZOUMF/ORAbOUWU5XtxAji+mMzeUZVS75pV/4Gi7Ahx+8n/p7teR73/kO27ph+YW3ePfNV9lcX3D36ICsKLi63DBZLlidHOOGgav1hoOjIzyR3g1kZU45nVBMCpCCzg5kec7JrVtM58vEaEbJxbNL8iLn6PiYi4trhrbn6OgWb79lqfKCw9Uh+bTkrS+8xsOHl/zmb/4+ShTYtmdWLbj/2n1+87/4u9y5c8qv/cqvIojUV2d88a3XOb94mn4JKiNIhQ2CTdPhg8UHz3Q6I1ogCKJ87tmaVNObkJTkzXaEoEdQnqTNzjlMlpFnOVLrpH7xPgUO+pS4kGcpmCs4f7PJLcoy1a90bZLcj8xVjJG8KBi6lvX2EjER9GGgdR1OJVDXeouLIGxHlJHC5Fgc5ejhnpQF9+/c5xvf/A5dveP+nTtcX15SlJHX37rH42c7JtkCGzOq2RF3i4zffu/3iJWGPMmirbNJejUOxoKzWC8wyjA9mOJcxH3OVUoRiY8RpSUPr675/kcP6Jqa1bTkC6++w3J2StsKXDSsdx2dNUynSx4+eoApSqLJyE4kffQMztJeXOJtpG2veXD2hO12TVkWTCdzdk1Ds9sxK+BoljIsyqxkvjrlzukdFpMpvu9Yd9t0DyvSA9j5AaNSJ+rQpZqkvdzYyIxpMUVGjzICFBRFRmMDSMV0OmFSKS63awxbVvMTZvMF2zqwaRydjUTfsKxW+M6nkLDCIDOJzgpmakWMKzItyA8WnG/O2bVbol6OPtHEQivlGfyWQjgklrKY/H/Y+69e3bIsPRN7pl3uM9sdHxmRtjLLsIrVYjVIUSAFSKDodCGxrwQIEAQIfa1/oj8h9JVuZSC1pEaj1RBFVtFWFiszI03YY7b5zHLT6mKub58TUZnFUiqjKquxR+Dg2L137M+sNccY7/u8VJXGxal4bs2SMUsh/yZRXn9kRRaZcdka101VBqjek7Isj4PQKCPJweNjwtoig88pkokkkZnDjEuOcRoxlaVty9dPyePjTMoZHzPBRYywrM8u0ELghScrmH15ZWmx+DSXIIuUIsf+QN3UIIpqJQkI81gUElIitWb0HqMVoJG2YhyOKFkApNoYnCte7eQ9QspyjlCmgPSUAiLDPC0yyPLKRAlGN5bhZkxFEcAJsPSrq9N5pqoqXrx4QUqJzWbDer3m7va2nDGa5t633bbtApQLHA/Lhna1vlfTTNNEXdes1+vi3RQSae39gd97T9MUkv44DmQdsI0uQ7ZKsVHd4iMtj0NbVTx6fk7wAe9dySWOmbNVgb3d7O/Y9Uf88rmttWw2G4ZhoO97hNeIqNjfHKnbzNl6gx8d3gnauubR157xvW99h2984+vUdc3d3R0f/ewjdvsdH/7oQ5R+Qq1rpmHEzZGUBJvtBX/jN3+Xs7NLfvzTD5E2IqRgHEfcMHG33wGFlK+0RAeBzZbVaoX3ntevXzOOY/F4L8qAk4Wo7/t7n/ZHH31ETJFq1VF37X3jdWqy9GK9cePEPM8l8WKRst/e3jLPM4+uHlG3HX0/8f3v/ykA2+0FANPkUYeBetsxuYlJO7YvNkhZ7jNT3pOB7tLQBM3+kLi97dntbqjqS9qmKZ7mNCJEKkMXVTMMA69f3vLZZ6+4uvoZ6+6CY++oG7i4OuNHH/4J1UVFL3e8eXPH7nbmH/xP/ke0zYY//dMf8bOf/YTPXn7ID374J0jzjPOrLbba4sbAdrUhjBONbvjpD/4EP8+cby843u6pmwa/2RD9n7U+/mVUiessb2Epy9BKSVXAjGkmHHvGYWCe5uVenUs+elzk6GRIbxlaJzia1qoM1pcm+8tb7pPkXC2WMuC+6T7V6Tx/Gk5prcsQ10nIHXXzhFw9JlTnuFwTFZBMURolEEKRpSJrRda6DChPKUWCe6BzSmnpet9Kp99d5p1+f0pfQhS5epayyPCVvrcsnCToIssFhJxLE01erKIKayuMsUucmFoaV0DksoQrhixyVpAjKUZc9MxTIMWIRBFDJvmAFlAZQ20tlQv0PjG6omrqk8ClkhUvcsk/L5fqE5a69CA5gosBFwQxa7LUC4NKIhZIqJAn7hTFs87bvkmId+3Bp97iL2fTfaqvvPFerzdlAhsCiVw2UiGw2+3pj4LoZ8Ri4I8poZdpYuYtNXyaykWvqesSOzLPhOCwRuN9QAhNJuNiJoZAs9pQSZbJr2d2IwbJWWvxQfDsydfxMfP150/42Sdv+OzNntd3A9d3PUoK8kIzv+hadPRs1g1zFgyDo4QovJ2cfdkvIL7cMX6pypzqNC7KaFFeEiZnNkbyqDVUk6fa1DwKjpthJhlFkrnEmqW33gvESSqzTG8EaAkXXc23L7c8JWL8xLxsnoVS6KoqlE5dDmTZu5IZnCVRS1SCkAJJFo+Ej5FWaVJeXsBKMvnyKKScivTkncfhC4/HAlTKgsUfLxZCO3zJ4v3n1v2F5Bd5wv+KKibD17/+TZp2Q/3kjLaOHKZbnq43WLFl//HI//P//q+ZBmjrLXUjOWu3/OSj/8A/+8/+EUpm/tUf/THf/b2/xY8+fsXheEDJjBuPiJj5r//L/wqpOprGsrt7hZaG9168YJpG9vue4fUeaRo26w3T7sCdGzk725JiZLve8M0Xj7jcVmgCP/jRh3z68hZVW548ecp8HPnNb32AdDNPz8/4wff/Lc1v/yZP33ufvZv5L/6L/z3n5+f843/wDzAkxn5HTJnV+oy66XDeleGMi5xdXCKEwFYVwzQx9RPnFxfMbiRLmIaJu7tdyRM+L/mP6/WaylqMFRBnvvn+JT/+UU3Kmr/39/8+MUZevvqcv/uf/k1+83vfI4bAcBxozi7p+5mmawm5RO6QBfM8oS1s6jXJJeYxoKuamGORU8sysT5taoD7Jrt4jwNJS7RWzPOE93MZVoVyDbJGL6PdciPPKRGDR0tFygXC6GPg1ZvXGG1Yr1fUbYPxBuccn332GZXVrM82zHIi9AeQS25xTuQgqYzEHQ9kkelWa653t+hGErxn07VE5/nn/69/Tl1bPnj+Pq8/fwXKY9qK/+q/+UN+8zt/k1qv+PE//zdc+ztu8543n9xx/ugKVVtCKBLfMUwlBzPC0I+0m45Ve4mSHXe3v1parfMOSWYaRn7w44/52d3ASOCVv+Om/3e8/+jI5faCl68/Z3ccCcnznW8/Zf34nFdvbtl0W3xITNPE3d0tXb3m0aNnhJgJZJ48fsw8j/zJH3+f4/FI3Ri0l7z45jPOa8/F5gKjK0RKuLl44WPK+JhI00g+qXUo3Atlip8txlCgSaJ4M5WhNKyhRFS2TYWuCynYz47GJmxt2KwMgpmqMqykYXcI1LUjph11u0Uqiwu+DJ+FQuuKum7RstgQbG1IQy4rglxej1KAlAkhPFJm2q6hrqoi4RMCYiHx55xK/vhyD7PaFJVBChij8c4xjMO9f2/yeaHsFq908h6jLYnEHBw+OGY/YaqKEH259k9Tkd/2R3a3I9tNh64ss59BCCprEVEhUbilUWm6mhA93jlkDERXcqfruiGljLaauq1JcUJqzdBPVFWDCwlbFU9iigGtJLe7PWIunAQhC6+kbRvcnLCyKhT42ZEi1FWDkga1bFBEKEM556cyrJdloBZjpCgiy71rmqZf6XtASYltW/SirhmGAR/KtSun4tsdFzjayV7XNA0xRvb7HZVQBYq6MG9OG+1pmoqXeaE7AxhtMLqoS0IIHI8HlMlYq4oFSZdrnVKayhbY0tPNE56fP+XN9TWffPJJgd9Oc7ErNS0hJ+JJcXd6t+S0eEYrwgA1LZutZZjecLjbIXLmfLvhGx98m/ffex+ZPT/40R8V+baxSBNBHHn2Yo1zO4x9wpwEprZ0TVdeH+2aWlc0psJWGWVKLJ4QIJXCLWwCRKapNcfD/h6YeXd3VxSSVY2bZ14OnzEO431j3rYtXdex3+8xxnB3d8elNWw2a+Z5Lk1TKof3GMqgarPZFGL+svUuaQiKum5oQsvZ+SVVVXO++OuFELx+9YqbuxvGODGpmVhHIoH1ukMLyfG4J+fMpm2Z9g5j4NGTSyBycXlOt2oZhp7dvqeuLRcXl+z3A8fjkdX6nHZ/LK+FesZpj6kVgxjoxZEPX/2QQTia+pwxZj57+Qm/+9tPWG9anr94ytWThtv9mqpxbDYb+l7TNh0X2ys+/PwHvLp9w0cffg4+ER7B5CZSStzd3t6nHfyl17KJVvcb77KxjW7GDXvc2OO8W66v5ZwYSWRRhs05l2SHkFKB9om3ENUkWJp4uaQK5EXZ9raZFgv49PRn78LXIKN0IX6TS/pFdhqVztBii8pPiJwTqEgqkGVAptJcnzK+kZKoFHGBuJ3sDe829afIr1NzfC8r523jfV9LU/k2Kq1s0CtrmVVJiZAiL6rUcg0sEWxluy6VKsBJWdgwOb8lq2chS78jy9cQKd8T/7OQiEVhNM+B6DN6sejJe1tqURCGGIsdVUmQpU9IucSciiyQOaNSBpmWgYsghzK5lcoQT2lQsthpoXB7ymNRnm/uH7v09mEpv3rnMXpXhvvVvHxP9ZU33t77Ml3JGSXKVEeIRJg9Y85MzhHzLTEVqbi1mnMlFwnnkucZig+gsRZSJHjHOI6stluq5UDsnOd4t2O1XkHK6KZQTYXOhLHIYwGOfaSWiipHPrjaslKCb7x4widv9vzX/+9/zTFE5pyRouLr6zN+eysQqec/DIkfSokXFpUFIkfIASEhiQKdIYtlkvZFyuD9RGXB1mcyisRKSZ62LeEwciUF37ASoxPVukKQ+I5VnF0Z7oB/NUTwCRUlIQucTAgNUiRkVAQlmHWkEpk2BC5SppFLnNGyBZBKFHqz1khg9gX+U5mWKURqI0lCMcfMLBOOQB8nGl38HTp5sp9RORNgiRKI95KOfKKYU3LJhQCNYhKKXip6rYgpU80ls++toFzc/1Qm8V/0zH952/3r0HQD/Mt/8X2++/VvEGPik48/5vGTjikcmC8uGY+an/7syEc/u0EkzXbd8eTJGX/6/T9mtdX84E//PdGNJJ+5uxl4Mw2s62f8/b/zB7z0A5//9FNyUMvkNRGjY3QDk7LEkADF+XaLT2CVRDUNl5drzq8uOe4HjJBsWsnf+7t/wO3NDf+ff/EvGYYjVq849j2/+b3f4mtPnzPcfcqzR2fUj77Np599ys5F/uSnPyMbxT/+J/9jWimYBsfF5SOOxwOb9Yqmafj004/Znm05TVF8CEit2B0OtFXLNBUfqFACZOLJ1VOsqchZ8vjpMzarlu9//99w+eSCR08uub6+41tff8yz977GPF3jnefZk3NW33yf/tATXaDRFT4ZXMx4N/If/vTf861vf/u+6bBaIJKHEHHHid2bHWdPNmXK+86UGgpswxiDrSzTNHHY79ls1uVQqFTZtp04BUJgjaHve+Z5pl2tcOO4DAvj8v0XX9xms2EcRwQCH8JCddZIJVmvOxJl826MIgtFUpFhigilSVkQc+Cu3zFNM0FASo5V27LdXjLcHHh0ccEH3/iA58+fonNgjj2HvmdwkX/3pz/m849fU69ajgw0zzr0tuLHH33KarNmDBNOerRVGGMxdUsKEj+Bd4J9mPjBH38I/7Nf3XskuhmjBEIbYrYcpgmaFY7IEDS7w0jdJC6efJPz9yyiMsx+xlHx7OI3gJrjNDG4gaq2xBxpuorb2z1Df+Ts4pycA9/8ztdZrTo+e/USMd6RQuZqe0klBNdvXmKbmtSu0FWFWXzdp81BDJFVs2Kz3jAcR0KItG2HEOBTwCzNb0YsMUsjyrYoVaSP8+GWGEZ0M+PmPTCRRcQqQ1MJthtFmnuMrWjbS3Y7xao7p65r/DyhlUKI4kO0lSFFdz8kgsh6VeHuIlZLurqiNqaAAFPE9RElEkoWmeCq64jJF3ioABd8ObxlMFovmaYBYwvjIFHuCd4HlCjD1DnM9FNPyIFh7LEkjK1LZI9teP36dWGqaEPTrkoMzTzhvEPLTGfrJWZS0HVrfPb4XKLx8jzTH3sqU1PVDU1b/NbOF7m50QahI7ZqSGhQEheKlLM/9tzd7Tg7P18OxYkcynBHm5oMTGMkzB4lNDFkos5M88QUXQGkknHRk3IsoM+UELlsObfrs7JBU79auFqnaoZ+wK4su92Oqq5ZNQ21rjBdIYqHUGLQnPf44Blvy/XFh8B61dE0HW3bFb+wsTR1YdwIBPuffc64P/Ktb3+bb3z7G9Srlp9+9DNuhx0raenalraqqWyFz47b22saq/na2TMuzi/omo5KV0ymYmVrZiFxdU1GME4jImUed1tqbZAJjv2RwzzSNC3yvAJpkBj6YU+zueLRWUtMCSUtg/Z8+NmPaHNkGkdub2949OgxFxcXrDeWp8/OefPqDY1VTGmCQbLz12yn13zt6x+AGBB5YrqdePrsGbXU9IcjL549YwqeKXpiDKyMxOaMkcU3//ziEWMzohKcNytuB0fVrehWa1wocY3KGjq5oWpqntWGeRzIfqaSS/ySqalVS5awuqw4266obc08OqZ+wgbJrRNc2jOevvgaF+dPeXT1HKVqoERknl084vXrT/n4+DEeT9aBaRrZDXdorTFNYTXkCkQLVhq0VlxcnDMMA0Oc8TKxvnxMyomDA4ei2m5otx2P1RX7w4GRa+ptg+0kSQXe++B9hFDc3R05joFadezGj/nX/+HAOM2YtSXOA+fnl2Qx461h3o/UVnP95iWvPvuM/as7KlFhjCIOkSQCN7seWZsyiPkrKK01ShT7swCy8/j5yDgOuHkotpR3lKSwLGkWa1hp9kpEr1SSlDMxxbJdFbJ420PmRA4r9lWx8BhK+kkIebFOF5l6jkWSnXVA6UhyjnjMNGKFntcYd4aybVGZqYxvK2yz5Uimn/Zk6crWe9GBKknxnANBFFBxWqK1WGKGRQZEXI7OcpFiq/sGlFxCebPIQLrnViihsFLTWEUykoaMEAkvEklkVMl6uk9yUbJCSFO2ysu27MQCKcOHpUcVgCx9DUqToiRri3cjPo4gBaYyxAlSPpRUlbTY9YAgZRmGI0syjC7fU4kfjuic0Ci0NiASRsLKGKxqQGiyjgskMpb/fyIlBzyTliGCONmVTlu/pUkP4pT//fa/X7Ho6c++jr/aTw/j2N8feoVYDrtaQYrLC1wwjjOv31wjRC4TGCXwwaNlibY4WRwK9OgE9lAlpiREcg4c90e6tsUucKmTd+/k6bknVC6y0GmamMaeR5cbsjRoq9l972u8vNnz8s0RNXoYDpxtGoQfeIzhsZLcZFG2zxliWuQcWaBPnsH7rLkvkgdzXqZBlMgykaASkm88Ome1aTmTgUedReVEP/RIrbjQCtsItAucpciUcsnjTZlZFPDA22V3kas3GdZCYEIiqpIjqGXJMfQxlXiMul6256B1hVvy75RSZUBCIWOmnJljJOjydvQpo07yDGTZXp+a4My95+Uk4VBKItEIVRGUwUtJBtSXPCKnOslivlzvPo6/TvXRz16jvMSHnh9df4LW3+L3v/cBP/vkhpV9zh/+qz9lGhN1ZXjx/BGCibnv2Z6tESny/OqcnDX//LM/IkwD280H/M//p/+I/9s//xf8n/4v/y3n2ysSkpAz/dgTI5i2Yr3e4FxAomgrQ/ATx/2ef/bP/ik+BP7oD/8NFsnYH/i//p//j/zTf/pP+Mf/6B/yR3/8Q+y645NPPkEbxdXlBRfvn1GpkUZrHj1+xB//+GMunzzjf/jsku22Rc6eHCzjNCOkKq+JeeLZ06eFuKkUQz8UCEZKJTpMCLr1ihhnrNYFrKhr5jlgTcWb42synqZraeqG2tZcnK+pG8PucMvF1WOcM9xcX+PGCZEEbd1hTc1ucEidqUzD5eUljx89YnezQ+aEsRVGZVIOeDfzwx/+iN+ov8PZxRkg732UxhiUlvdT12kaabuapqlJMbPZbu7BPFCa9XkshNyqqtBSEkW5GZ8gPiXTs6QuHI9H2rrhbLslOI9znrOzM5QGqTKbZoXvHSE42romJ0+IguAdUgj6ceAw9+QUEWFG6kxteprqnH/yD/8ho5+oK82TJ1dMoWZ85fjg69/k+s2M0BZdNcxjz82r14TbyPb8jIuLR/z0459SrStW6xUiSYJQPLp8ikxwe3Pg0+s9//pfff9X+h6p646QPH3wNJsVT2i43h0hB168/w3qLGk2l4Sk6F3AO8ft4Za60xA1d7d3QKJpDauuImbJ69uXzH0BA4Uwc3vYM7qRIXlmIdlsLvnpyx1XF5fE6YA1FVVl8dHRmpbkS8xWoTJPVNrS1C1SFHJrpSuUyCRi8d9qTW0r5qRIaUapQk8VJA67PToLnB/oHmmEiozDhLGqxMckwXC8wagaPztWXYUxNfM407UNVVPjY00Md8Q8Ym2NVhY3LwMbnzBaEEVCi2KfaiqLm2ciEUHCKIF3JRnEuYnRjWht7uXGRdodmecik+26VXnduyIbjq4050oLYk54PzInByKjq5I5PY8TU55ZdWdYVWjmIXrm2YMq6RbOeYSWROXIizpqGCf246Ec4jTM/VQ2jk2H0npZ3GScd4zThFERoYrs0wVPpSpmX6IL98cjl1eXGKML4C0nUsy42YGV94ORumqx0iKlYZw9x3EkSZiCKwM3IWjalkBpuJVUVK0tN9Ov4BYz7o68fvkK8/w5KsB0d6Q5P6eVFet1i6eA3kiZTbfifLPheOyp64pxnMCVyK55csyzY+iLV3wcJrRUTLd7VtLwjUdP2eoKhea3vvEd/vTDH3J9c4McM8f+SLBlKLmh49yueaTPeN49QVrNhx/9mB/88IcEErYpUuY4DsjKEGYHLtBJQ3YBPzukVWQtiZVhDD1IQVCBi7MLdOyIIXI8Hpn8QAM01iKNRBqFspLruzfLNjIw+J7X06siMRVghCVPAfEycnt7y93xNS010zjiYiDMjrqpSwxbVSHIVMlTdzAMA+M8kGLigxfvIYREG83qaYXSGhcDh2lgtVnTuzLcjH5i6m+I3rFZnxPmmarqaKsWqxt0a4jywM3tS6LLtLqlVg0vzp/wYvucZ0+e0Z6doXSDVJqUNUJoUpip24aq1aSDQ8oicxWLbDjGkpF8UjcMaWDOM2EMnNsL3OCZhpkYI5vNJdELnI8IYxASdtOBemu5WK2ZXI+UnrZrFjVDjfeZdWdISdBYw/q8Ypz3VFsJOpHEjKorQjZ8ftgx9Xuu716jvKBa16zDhvluJE0RpGS1WrFtL2guttz0fzU53npZJuUQcdPI3Pf4aSLFombJ4u0W/HR/P9U94HhZ2YZ0srKoAgPLb5c8b0Fp+j5+tCSWvLXIlHjGQliPOSGEwXlBcBYtKmJokK7CREOeM9oKpLboqkOuLujWK0Z/oD/cMY0DMYSlhc5lC50zcpGXFz962d6KSNniGsgLNExIsbAwTgrUd9Why1ac8rgYram0xCuFSQVKWOYMpS+Roqh0QKC0AalhYTOVpnWRsLM8GPeXzaKSzVKB1MQc8UmgbL0wKQQ5TFhboWRR0U7OEVLGp1z82TkVSbw4gRvT8niAVkVJEIJnbTVn6zVNs0Iyk6RbBjIZmRPkQI5h+fiwKNtOzVIZtpLT4iEX9w9UuR+Jv7Aa95etr7zxTinhvVtuiBVCCrwLy4taUC8TSpFzyTGV8OnHn5YJhdIIKaibCpEzxlqUlOz2PVXdME/+3ovhnLs/WKeUmd3E7e1tOSjrIpUYhgGtNXeHA9ZoNufbYvKfJtaN4u/97d/j7u7I4Xbg1SevqPa3bM47zBAxueH67o7v73tSZ+il4GZMIA06a3Qoma5Rpvs3/henbokCR1Bkyg1GpkTqdzzZ1pybhulwLAe6lOjqFY1SpOPAY1XxvXliT4RuzQ/3Ow5kohDIpJAiYYnUAc4znEuFpsjDQozU95ECEa0NadlwSKkISeB8ACkLtVBlJAmtixc7xEwSClU1+ODKpoBlw326CnHK7X7rjxFCkKPAC5i1IAkNolDREZEv5nT/x19D8MXN969D/cv/ww/+3L//3/6vf7nP+63f/1/xn//nv9zH/nn1v/gL/Js/+NV/2T9TF8vPH7zzZ83y5++982fv/v2pnr7z628vPz/7Of/uBfC7f8H/n0d/wX/3F61v/QX+zfu/wq/3e7/Cz/WrLofmdjowZc/Z2YqgEsOuR2XFq48/Z9of2O1Huu05WVZU7YaLzXOm6ZY317coY6nbhhw9t7tbhLZ4f8fY90Q30x8Vs4ucXzzl5evPmP3Ip7eOw/UrPvz0DePhNd/79jN+7zc/4NGmZbe/ZnN2ha0sQz/QNu1CjJZM4xEJGK1IOeKdI1HIxilGxnGgsg1NKynMo8xqvWbeH7BWYBvYHe6obV0o3EtjqGRGa88cZo7DZ8h8hZQwzT2NrLB2g+cNxkK+dkjZonXZNK11h0wDXoqinlgozvIEismJaS7WLK01PqUlRi/fD7ytqRBwf3AMIS3Ufll8kCmhjCLmSPABFyOzd1RNTc7lMGuMJrhyENqs1sWre7hDKl1AbVliVdmuqpSJwZGRHA5H6q7BVBUxOcYYsbWha1YIJCkk9vsDtlKAYHaOFDMhpLLdrS3OzYzDkbPzLVaVyL4CvwrILMFyT9yWQqKlpjLlcOeyR1cVIQcIiw9SKZRWOOfvX6dClOFzIVn/agGD/bHwacZxLEThqiKlRN/3ZYjgZzptSXNg6kdevHjBxjbYquIm3xBUvvcen2TmQgisLZCi1dMrht2eP/n0ZzxJM0qqQiGXks16jU8LvEkIbN0gY2IaJ169fIVVmna9Ii4b9xg9zjl2ux0+JzbnZ2A1XoFRpoCNciw+/BCI44g0is1qw+FwIA7TfWSaF7Jk+Bq12HhqHq2eA6BrW1IkGst7V19nmiZCKO+x1facqqp4fbhjChPN2YY0ZT65eV0o1koRZoexls5UVFrDPHBMM4fZMw0T9aplN/ZkKRhvBl6cP6IyhTeEURhtUNEXIJcq8bKbzZrnz56z3/d4V2yD8zyTM8xpZH/YozFcPrpk02y5WF1wvr1CZEHvB1yccXNAihZjapAO52Z2+1f0wwFv8hJhWewNu92OeZ65urq6j5I72RxSSjx5+pS7uzvmuUDs5jESoqOqFFIVzpGQltrWpOzphwPWziiZ8C4TQjkzS2GxCxtpPiUPSMEQHHkaOI4DwziihODm1TW1qHh29gQaSyMrWlOz6TrqlSSoxN00YP+KcryVUkQfmIeeaRjw00gKvijT5NsN9ykC7Mvn0ncb8S/4uFH3H3f6O3X/mM2kBEpR4G2pqIaEKFDE0owahskQ8xojt7TnV6x1i5kTclfy4MOiMtPbS8T5I3K3phGXrDYDw3hkOO6ZhgPBjaQcIUVkyshFFi9T4VCIsCz3eOv/PplYy8/5nd9z/5i8qwTQUi0y9hOErFiS3gYtZ0r6U/GHl4HFlz/rouQVpz8TSFXuSWmRkVdVdf9YGhIqVNjKFjl/SgU4mCAkFth1seM450uPJMpzroQovQsRmyXbVcfZdltiQaNAyiKbFyREihADGU9Jglp862kZGtxf609L0QLLTXmJVfsVp1r8vPrKG2+r3+anxVAacGtU8VxSIrvuG6ok8d4xzyU2JEgIKVIZAzlxu9vz+PFjJh+pGo1AMY7jO9upt0TUcZGCtm0BZpx84rvdjm7dcfn4EdM4cNjvcW6itpK6Aru2fO3inN/4+jP6l5+g5j3IGX2M/M0XV1x0hoM1fDhNHLxjFpkYF9BDeucl+XO23kIU+YfKoAPUGrrs0dOMGxUkhTGqZGIqxeA8jbIIH/h2UzNYeCPgM5W4i4mYJCIrtEhslOCZ0bzQkvc2K2TyzD6gdIkBK6TOSGWrQhXXqhBpnSdIhdCm5GznjMjlZhRzYvKRMWSkrojSoGIqUyUK7O30vb1Lgcw5l6xwIZmFYpaaKDUFcVC2NzLLX+iH/7JM6M/K9h/qoR7qr0O93u8JIvKTjz/h+m5kniRP1o/ZHXZ89OmPSdlxO77mbHuB1hu+893fp+3WzH7iN95/xjzOfP7mc95cvypSuqbl89efI9yBrz19SibwzWePcGHG6ch1v2e/v+WwP7C7c0jR8y/+7WuUcvzB73yPSqqypc0ZP/tyo1cCYxTz6PE+MEwHjNFIUQiw/TiSI8QESmpqW+K4AhJrLMlArqCuJHVV0bYdwzRitaapJVoZkvAIGVCMGDXiPcSQOB4UxhqUssQ8gyhEXSUVhVxeIVNEa0Xw5TBDzgQfyWJpHLQtFiIkIS4y8xSQEqwukVrzXO6HznvivMRzxYjznsoapJL4uXi6j+OIixllTaHTpow1pVnOSSKbBqGLb1BkmMeZdtUxqwlBplutyCEyjh6fMlaYkm+cIIaKrm5R2tC2W6ZhxNoVRoOPM1oL2nXHPDm0gpw8b968ZLPZ0DY1pIyPkujKIcpai6nsQrqNhWDuE61tyZQzhvMeF2dyjmhhMFYvXniF0AKtzDKYKBTxX7XUHODJkyeLTWGmqiqGYQCgqixmUVW4eeb84gLlIuu25emzZzxan/HJq9cc+h7n3D206dTAbzYbslF89PHHfDbsUFNHnD3yzWuOuz3rruPoinf+8eUVz58/J80O148YIXnz5g2Hj35KEJHt2RafIqMred9RFMr6aAWirpHCokePMCWuSbU1etUUdWKArW24OL8oXJ15ImRFAoxUHNyIrSwX5+d89vnniz/c8PLuhiujQGTGMPNmd0t3ec48J24Pd8Wug6RtVgir6ExFayt2b65JIRNdIkiJSo4qSy7XW1bbDXrV8On1K4IElyOTm7HWokw52EtVfMJSKqQS2LpGa0PbdWw2F9zdHri53nF9vWOeHatzQdu0GGnJZPb7Pe7okBiiD3g5YeqK2mrqbo1SJVP87uZzhvEGYyArBdbeD4lKusZbCvVms1m8xYlXr14hpeTu7g6A/X7kuJ+Y5oHNtuXRo0sur7bl/S9K03ACEicliBGUslRVTQwCN5dh1TzN+BxBLx5ipbCVJeXMtlvx/OopNZYqW9bPW5QTdKZh3bXIOjIlz/d/8kPU/Kt/j/xFyvc9fd8zjQOkSI5xWbqW5vSkjP0yJO8E1zs93vBFBeUpCvfLdPJCOGexvZaGGxLGqMU2q5icZ/ICWT3m6vnvcn7xTbSoYBhhfwf5BjE58noN2wvk+RXy7BF0GyChmhmznui2A+Pxlv7uFdPhBhfmQmRfUh1ijqQldcjIEolJpmzeRUliQZyab+675LLkL4RzKYrtzhiNURKVC/RYkk9O2HLGliW3XOmS2CIWHzecehtx7xkvX6q06zGBD4mUBdbW9wMQYwxWJFycFmBcGRwrbUg5ABK1fD/lXlYSC4QoFlkpZNnMp0RjNBebNev1Cm01KkuUKs9teU34otiVHpb0JrEkyojijy2b9VSGzkIUTk/KJ1tCun8Iv6r66htva+6nGDnnxayv0Is/0lCavRAiRgiUtkhbclXH6BgPPYcQyAicT0hVlebN78pBJAbGaeDsbAMIfHCM04BzjrZt70PjTxe0uq5p6hL1E2OkH8sBadN1jMOBnALNasvsPerpGSu5RR8viR+9YT0EvludcxMz1+OAjRknI4hEluVVWzbWb9+8wNvNsMgYoFWSdc6cE1gTWakFSLBIiJwvU+cQMzEV4uE6ZSpZXnxdSDSRgsxPmVbCI6P47uUZj0VmW6kyGZMaqzX4gDIaqTVSqTLBywXshFTYumZWhiQUgozIipgCPiVElvRTKt47ZYneY1NCEEsEwfJ9qgUGcZoYZiAJhTOaSRuiMOS4RCO8c234cv3cjPOHZvuhHuqvZU0p8vrVG1q1YXX5BB81H37yCcHA5deecrWt+eb7V0zDzI9/csPNm59g9BPaZsCPn5KmQJ32fOf5ltt+5idvXmOE53vfec63nl7QH3tsncrw8/KCvrf4dLFsAyLdWqEoEEs/HtGrNUYpBALVCKrKlmYuOJCZ0Q04N9G1K4wWjL0j5IRCU9cV1hoqa4hTxCiNTJGuUVRKY0xACNjtDxhrsaZCCVGawRSI2YPokVkhlWOeB5RaofR6sWFptIkotUDwppHzZo3VNUoU7sA8uwVSo2ABDM1LJF2YU4ngSgkhClxLwP3m3gXPYTjStg1EDwiEVozzzOQm3DwWgFzOCKXv4V3FC56Z/Mw4uHuytdYKYwxV1WCM5TgccdPE46vL+60juz0xK7RpGUaHtQ3K1ChVI6XBWJah8IhU5YA8jD3BlyQOH30BFkkIMUASJfpHaHSlFthoAYLGFNGmHJDHeSTGAmdrmwbtBSEWvz65RGSmhWgcQkAbi9Wa6IuU+VdZm82GpineeKVU8XlXVYm9EoKLboUfR7yP/MYH3+DFey+Aci8ddwfubm5heaznuUiP53kuZ4QUcRqefecbxGlGKwMIaqX5yYcfsru74/LJY7pVR98f+ZM/+T6uH7lYb7nYbPns00/5+PNPuXx6RdN1NOuOJAV1XS+xbRlHJleaz69v6YKgkZLaVNRtQ70MWapcCNPHfV+250pSCYlPCZlB1pZq1dKcrVm5iaZpytJEwpzL9zPOI17CzXFfmsQFcvbmzWvG/mMutxdUSOIwM97ccbU+48n5ZeFxZAdK0Jxv0UYwpMjV0yesr86L3H5XKNc+BrIuEbV3xwPTONKuW8jQ9z1v3ryhbVZMk7tXUs7zTJcrlFYcdkf21wcqUROmQHAJqy1Hf00gYPWWzeoxT5++x/XNZ3z28scgJ6YccUqzWpVUjbOzMzabzT3o83ROraqqAEOX6rpuSdwI1DVcXp1TN5rtdoUAtDYYI5lmw/n5OVVVo6QhBkFKkqqq6Y9l6VRJgbGGtl4TSOgcqdqGFRmdYZU1X3v6Hk+2j4hHx/DmSDwGbC6vvV4MXD264ruV4uYP/8Wv9D3yF63j3Y5pnkgxLIss7r3Gp57zFAcG3J9JTwyFn7cQKz8vkcHL8uk0FLlv4kMkE1C6bFcFihgEwcOUWtrz93n67b9Nff5thKvIcyKZI9QgVkAXkWdniItLWG1gvUFUKxCgKo+KEeOGMqwlcYwzvZ+Z4rzwKCDKSNalOQ1LdHAJRFOL8DQXhVJORbIu5Mmjez9k0Vov9zBbIiqTJIlITGUrrJU4qcfLxyl13zsIJUtWd1425ULcP+4xlh7O+XlptkvDLnNGL19XZQ+5KKBDKCkXQmlElIRl255yQklR7q3LExpDJFKgoa2WrCpbGu+2Q9mSPJJYGulYYNukSIFuL6pofAGWplQUCimWIbdIEJfHbfkPIfgVJ0r+mfrKG2+1+ALk8sSL5fdCyQIYymm5gRTUvDTlxiGRCCWZs4NYVALz4Ll+dVOmOxSisrW6TPlT+TwiZIahp66LdOdEAh3HkWmaygY8JZSSzAsRve02rFYtwc0oZQjBU2nBPidSu8apmm2zoQGOn9+yyoo3tebj4UdoX2Jbnj3e8PHLHYclYuvdNz6UyVDOYHLiWS35+rZlGyeuKoNIAecTWQWCSIQw01iLNoY4hkI9tJJWlCD7r9UaYmInFOMMK+Cp1VxKQSsC3k9A5qzeUqFxRhJzObRxf6EpDXJVVYSqJgqJz2KBNERCmPE5kXNicJFGaSrdkJQjx7kM206eCLifIp4mXEIqglJMRjNpTRYKHSWJXGIU7t/dX6z/mI/7183n/VAP9VC/uMY5sT9Gvvcbv8ndzUCja/7TD77FrKEf9zTC49yOzz57xaPHFxz6G9ycUByZgsL1ExfrFXVVtptOXvLpy1cYJNPdG9a1RnNEaY3K0K0WJY7UCGHRlSiSS90yG0dWEi2Xwa+QSKGWPGKIMZRBotIl9jAXRdY8zxiVsbUixUQMocTaSIOVGSU8s5+xUhap7jyXDUNdBsGJRD8MTH6ia0qMY/Iz3kFTJ4JXJSs+JJCZLMsBJMbINM0IA03TlQY4l2gwKRWozBwngoiFDBvysv2VBRTEkk2fPP0wkEVGG8XuWCLYpCzfz/FwRGtFCr40u4CpqwLaWSJosshMcyGXKyPRVuEmx6vXr8BoqFTJnvcTN/sS+eaipFmfcewdL9ozJu/JyRHRpAB3hxJ9eHu3Q+pI3VBidZBoW2xmKSfqtoZ77ovFuUgWkmkKpOiRCNqmQZklAs5qcipAxNWqw3uHyJFV0xSlV4r4EErGbV4gS+ldf/ev9h7zv/lf/u9+6Y89fwzf+xu/5Af/Z7/0l/1q65t/yV/vG7/gz7/z1X7Ziyv4zm98tV/jK6sN8Pzn/9UL4PfRYm/vAADEyElEQVR/55f00f3/WWN/BCiS6HtAVi7u4lTUOacz4j1AE77QdL/LbjkpNeUyjD1tuU/n2RhjAaghMEYiZYFx5iwIXiNo2Fx8iye/8fvo5oroTxbMRFQSUbUYW5Vr06ojn53DZgN1TbZL+5WK1FkKkH5Gq6IuUVFgXGAW4JVAS4kXmZgSmbjIpkuudaGBn0TiRYYucoGriWUwIRePt15SWrSWiLBwopZmUwkBCpIsOm+lFGqBw3K/9RZvz//Lhtq5gHN+AZkVtauSsjT3utiJWSIq52lido4YMz4l5hBxISGJaAFCqPuoOCEEMSVCLLnoKENbWc5WHU3dYDQgctlkpwj4YmWVEYRGCoPImpT9AmpLZaMtyiClNNxlYF4i4RNvc9K/uvrqc7y1JgS/ZHCXxtEaU+IaRKGRp4UcK1CAJISE1RojNIRcZG1CIpVhGlzxJ4uSods0FZBQStB1DSkHgnes15v7N13f9/exEeRMYwzjMBJdZNVtsVXLsZ8RwjINR5qqY6UNSdd4JwnZYitN3SioJDIILkn8tvccdwObynDZVaTDkR8M5U16mrR9MdtbYmJiEx3vVTXnaM6bFp8SvRvKJEaAsgbd1MQ5lA26kozJ0SqD8ZGvtRVWaX58mEjJ86ixPG1qquhROhJ1Kn6sEEuepslLJqBAnsi2IZQGWRuy0ihRQu9DiiBEga+JTM6CiMRTSMhy1uTgimReKpJ466n5gkwHQVCSWWu81siksEkiRCq54+KtdOXL9dBcP9RD/Xej+mPm+fvfw5sV9eUKJSTCFvlz19WMhwPDzmO7J2Am6iYQ5z1kR60rhE2kdCBFRSVX+HHCCEm/Hxhyoqk6xumIQGGUJpBwoUcIi7UN83FCYqk6qLQo03sBKZatsEBgTVWudzmRZVEdhZgYhgN13WCsQaQirxvHETdpYnbYqsMYSVeDFYrKFtmh9zPbzYb+cMCaDFoQUlo2uDNKQmUFKQWk6pGyKl7pBMYaMhFt67JhQOKdIy+HypRjUTppwRxmMmVbH3IuZNZYDhFl426JITBNhThua1PiPJMHvwwVJkf0npXu8CkU3ofW+GliVTVlwECRzXofiBHqqqLvj4xDz91+R9WtaDYrjuNITInDMNC2a/pp4vrQE4Li+rZHm5phmmgbRVN3XL+5w1rF7XHPxWUHWnHYH6hMRV0bkhDUTcP+uCfMkRlJV2matuNw7BeYY8XsZnKKtG1LTJEYM0ZbqqYixCWPPESqpiHE0nQLrZYDsuR4PLBtNoQYC1FYPNx/Huqhfh1LLmfDQhoqkVIpFxBwTguZWrzN3X5Xyg+lGS98iHiv1DzVaVOulCofHwvRXBt9z0jyPhBDRkuDkSvOzr/G6v2/hbSPiSh8TkhVriPGWETXIGSF1AKxamC9gq4hW0mWLE2iQC5WZCIInzFToh0D1RjwWjIbxaREacKlKoNhZUjLPSwLSPfcJLHIqd9KwE8e7VPCizUGawxpnkr6jCypU0oWSXqWosQ8G402BqWXx+AEU8unXPG8WEuKSkMtXK5Tw66VKuC3RWVwgtRN01Tyu5NkdqmA1UQqIO2TR/+dQYlURfaulaCtLNtVR11VaAXkWC7ZKZKEglgGsuW1oMhZI3KRmpMSKYUiz8+BnEMZKgiJTKk8ASmWn7/C+kuRmqcUiHHJzdOl+U4pE1PxZtd1RcmDLpFUIUSEkMzOo0TJnFPGlClTSlhdoDB+LjTDTCJEz+XVBdoUMm1KEuciUiaGocif6qqQ9ZwLHPuRLHXxNqRYoGs3RwSZ5AKDL/6/4zRRtR3aGPZzz85NIDVXT7acbdfM+x5LJk0jP3n1ioOO9HNknGN5McWMFplKS3LMnEu4qBQbLVlJSw7Fl2akJrHI6UzJyk4xIkzx0qXlzVUbxZkA23TYuuO6C3zjcstjneBwR21FAZiFXKR0mZJ1ropXQkuIuWw+QqRIEynERC2KhCVQpC1FdpHxZIaYkUpjTAVhQuS0yDpKtINiWaZLSRSKUVoOusGr6v5llpf8WFHSsO7BbD8vn/vLzfefJzd/aNQf6qF+Pcs7yewiTFORPtYNkpKPPrrANGdkfYYPAUxmPlxzsV7T6prxOOKjx+dIZTvC3NPpxCHsSMFydvEMYyQiKMbZ0zQNfnYYvcbo4qWMUkAqUTFKF0JtzgkpSiZrXde44InBLaRyFqnpSAacmwtsSxbgS2MbXKvo+0BjJOedxUiBFRValsPFat1xc3dNYxr0kpG9WbUMoyDnkv07u4G264ihpx8dyBUxT4hcDi3aqCJxNwY/TghpygGThFSAyLjgEGqRPi6beKXLobCtW6IvUUs++LIVUJJ+1xNSYIzTIvFOKCEZ3QSJ4ssTArnkPCspCT5iZIkvS8mhdMV+d8CHiDaWOSRevrrG+0TbrghIxuDYDT2223K8PfLhxz/h8eOLIj+sasaQiUic91ijCM5xOxeo1/vP30ObipRAaMPNfk/XtvjRY02HkhnnZ9qmeE/7/R3aGJz3zN5T1y3Vonib+hEty/McY8J5BxRAkjIKkcGaEkdYtmKZ/AsGwg/1UA/1V1sxx3fk03Jp/k6q0uUMuniyFwY3OZVIqbLRLg2VVmYBlBUpM5yk5UU2TQKjLEoqYnSEMOBTRIqKWq7Rec16/Zy2e4ZzBp0rpCkLurK6liQEKluEaJB1BW1FqiuS1cvZN6Ji8RPnmIlhRk5HZH+H3L+hunuDcAGvNaqukHWFqixBl/uao1hPs8jEhf2Rc0lZylm8cx0rHb1YzvlSCrSWZYMuBSzW2BOrDdIyaMjFnqp18bOzRLEtZvBESaPwIYIon1eZpUHWugw1hFigbgXaFnOx47rgGX1gzJaUQeVEypEoBTJGQC6Z3OW7MFLSqMzKGi42azbdmrpqQCxxYTGSUwQhyaLYsEjhfsMtFk93ipGEJyZPFIEsIlJppIylgT9J1nP4Sl/HX3njHZcNqlSSnMCHiPPTMoFJKAX6BHqQEmkkiMwwTviYMbVdbohyoQkWyE1KLBvaMumaXeT1mzu0totPLHJ1dUFOHjePdF29+BoEw+CJaFZth5ZAnHl1/YacE5fn50hBQdx7TxaBymasVfRBUUtbDP+15JM3n9B0Defn5wxDxX//7G/y9Zs9r+4m/vTDl9zcHsk5USN4b9txoRNN9Hxts0YnGKYZrSDmRAyZlCRoyEriF1CcXqT5FRqyIIpIXQnWq4YX20eMVFx2hun6U/rZYBXggQWI41Ui+7hEBAhS8sTgUdqSpcQpUfwTLL5sPKOfiBQYXBYBlyMDFiE0lanxYSLEhEkZSz7Z10mAFxInKw6mY2c7hCgSUESB5S3DOO5JDn9OnaZdDx7vh3qov55lKkVtM0Z6+jFxN8xcPL4kBkcMHm1F8ajlM8gCaQ6MISNywJiKLAVKSyYvmMaZWkeenAvWK13UTUFjdEXXnQESiWL2M1pqpJDYalXALCGijSk0Y61IIePcREiekCLjPJXkDGlKmuqyDZEIgvdLI5gJ80ClV+hNx6ZteXZ5xpvXn2K1Zp5LKkUSiaar2TRbpr5HItBacb7eMruJqqqhKoe/lDx1LRinl8QcINds2i112jK6uSSCKIEyDSEciCEwugGlLYVpEoooLmuapqaqDFpXyCyIafFxS4nRhmkaCTHQTyMuFp+dUoba1uQk0EJR2xrvA8ZYamsZh6HYwVOJhMouME0D++OBqm7p1lvmlLi+2fHi+QfUdcv+8JJ+PGKrFpfgOO5JdcNPPvsZl1dnjK8dw27m0fkjrAF7tiGEkZQMTx494WxzRvSQs2C3OxBTZJom4pxxc8DoTFtVVEqhcmbVrmjbjhgDWkeqqiFFSBLapkRbpRRIImHrCmQZWsToEPnk58v44Bev51cc4vpQD/VQv1Rl5P25scjKeacBL8BEpXXZmr4L6U2nfl0uP8TCfYqlSReZeJKeixIVmlPCz4EYPSiF0i0iNqzkJVXcUKcLRGjRCeQ0l0ZeSEJloGrITY3UDYgObEXSimh0ybvOARlD8dD6QJ4n8vGWdPs54uVHhI8+JN/doE2D2ZyjqhXNxRVx1REqiwPm4OnHIz5MED0i5YXIvQwcKFtkRLqX5AuR7jfbUi623xM+/LS/yuXfJJlR2iCVWRrvgkfOC6jOeYePHqEESpUoR230PcerANSK9FwqseyQFSwNvEvghCy9SfY4MkmUBSOnDf0ia69UYq0z563l0dmWpmlRtiWkBa4nZogRhAIZyan4vN+Vl6cUidkTsyJJRVIRIRMyR1gk5iJHcn4bFfdV1VfeeOeckFLgfVxugJ4Y05KPJ4EiPw7h7Wr/BEKrqrr4Cxavhlwc7957oqBsB7RAKkOmRJGM456cYRhHXAhIkRn6Ay+eP8HWNeN0ZBrnckOOkRAEyUXmaWa1XhFTese/IKiqBikVx0Nfvm6ItG1FzpmmqVmvV/cQjlVX80JLnj/v2G62XN8c+Pzjz/DHkU4nvnu+RQ4DqyxI84SUII0iSUEawoK3BxafSg6ZJCh+vcVPHVJCaUNlDNZYtKrIbia6SKUtAl8kIlqjtMHNM4QCjsi5xIhlRMlkjhmkLHIMAQkBqmxaYkrLe6S8cGNKuKSR0pJMR5aSHGJRG1Ci0oJQeFnhVI3TFUh1Gk7yTubAn2Grfbmxftcf/+XG++dttx8a84d6qF/PurrsOE4HrICmElivcPs7UIr97Rsy8OTJc3bHno9ffoaKPatVy+A8m6oujW+MuNHhYySJwGpT07UNIXqMKJmfKRawSltX5BRRosSlxFSIryEF5n7GBkvKQyGZpoylYhh6lCqHimHsGYaBkBI5ZpQsiiwWm85q23GYJFY3WKVL9EuY0aoAbeZpRqjSuJIyTd0wjhO6tUgpSmSjKH7lcRrJOaO1wQWHFLDu1hgVy7aEjFUCYqa2lhhK9uzsZxTgQyDmSNu1KKGp6hqIGFkGBqMPTH5CqJLqkSQc+p6QE/vdiJCSFD3mvEHZCi0kSmiEFtTWlk1RzlR1ybc3WpBk+X/QpgFpCxskFqDOxx99xnZzRlVrVLaEIBaQW2ZKI36MrOcVIUxUWnN10fL69adM7o6z8xXGCay2TMOMd4kQEkd/xA8zq7OW9cUWmWDTrgrkU5v7g2OtagIeLcpmSyhJY6vlAF7OF7Y2yzCi+Cl9KIBQkSngU6MLvE5/5ceih3qoh/ol6yRbPi1mYjzFzcovAH6/DFI7Sc5PPu7Tx5SNc43KIJUjS8ccjmUTqxoiHVFeUtUbrs6eUI8K9oE0C6RJSDsh5BFSQESPSe0CNhPQGmgimIw0CqGW600JHCfbSPYT4niLef0ZfPop7mefEG4GTL0lX1yhLh+hHj0lby9gtYK6JqkCLuwOO8bdNdP+Du8mnIiEZQssyy647PqXJjbJQvMvG2ldHOEL7fx0RJfIQjXXFmPMEtWllj6s9GfeF67WCaqslCqpAe946U+k+FMTIKVcFm9vn7+8PE9KSoxcCOuCspkvsCyUACtLFv1mvWazPaOqG4TUZRAggFy23SpJUlKIGMhCkeUC2ktFoUvK5YfMlEckI0XJSc+n/O8c+Krpal/5HaZpanLOHI99IdktDbTWqmy6yfcE07Q03FKp4i1TJW8thXhPBj/h3qVgoZ0qEBLnI0oWQ78LgXH29J9+XuQKOaK0QemK/nigrSrOz+oi4U6Zw+GIEAqjbZEgkjkciidcClkOHcYyTTPDOLJare6p6VD8b5vNhmkeqQ2M7sizy4Yn5yu++fQMGQN3n3+OmBx1VTzWnkiSAhcCwiiSKtKQVIg+C0mxvClQSxSANggStmoxpsKogvnPcyS6iFWG2ljC3DPPjjF6Qkhoo1ELGCFLTRYCnyEpXeiuUp7sJbiUCCkVUigLuWFpvH0GIS3KgJeGSCTk4otIIpGUxuuKqCxhiWhJuUzgvtAb/0ca5Xcb6S831T+vyX6Qmj/UQ/161n/5//hvePT8Md/6zgvSfER4uDtGZHuGFJnaVszTgZgD51ePkKnl89tr1lU5BBx2t1hjMUKhrEApzTQOGKVp1itiLgRwpSI5JJCCkDMxpkIv1wo3O5RWEDJhoWCnHJmdZz8MpbnWFq000zgzjTPjVMjm1iimecZkaNcdeVc+nz/uWF1VWAXeDeg6kEWishahVMlopqIyptwb3Eyi5PAqXa7bMRUL0OwnQGArQ/ATwQcgUCnNZtVw3A0YZZhdYn8c0bYMVoXShBzL0sQV2nXXtmghizxPa6Su2Q9HZh9AC+qm4/rmGqM0GajqqgwuUkJXVVGMiRJDNs8TUgpCCngXmeZIuzIkl5ldYNWeMcwzb25f0VRrXn9+R1W11PUKLQUxBLqqJqfANDn8nEgh4IY924tLPv7kh2gtqBvL9c01SlrWVyvG44gbPVIb8InGVFxtz9m0W477I+MwsGpXVMYiAa1K7Ft2AL5I9aUmRkcWgmEa2B33VM7QNBUhOIxWBBeRErQocZtCC1brFcPQ/xW9Wx7qoR7qz6tTw3yqew/wu1G2PyeC9vR3p49/V00ZU6JClWtdHvFhJpAQekXIa7CPuHzvb3H++ClymMivd/jjLX6aYDiWJlZkRJzJvkJEj/AOMU4wzyQ/I+sGTIOwNSiNWM7cPgXE3GP2bxDXn5FefQIhUj/7GvLqEVw9Qmy20J0hVmfQNGStETmi3cSqirTG4dVMnx3H6Jl1JhlxLzBPQIoll14uNiJrLdYYJilRWRJkgUvKpQnPQqKMRWu7xO4VxbLz4X5Jqpel6OnXxpgCFaUsXAv7TiyKrCL5LwlW5XOkpQEWsjTeQonF9gqKjMx5GT4rWqtprWXddrRth7bNkuqx2ANyLt+pSCgZSUiQZct92vTl4JFIEsXuLBf6u6TA1EQucvMUPVJ+ta3xV954n/qk4vVOGFOa42J6z/dZeycYQkoJufge5CJB//LkipzK56C8UEKMSFG2E0qWcHifcmnkc/E13FzvkGiCd4yVpmtb6qbI6kKIGGMxxjLPjnkYiDHQdSvqugYk0zQwjhNN3Syb8oAxht1udx8XknNEp4z3M+erjv2ux7aKzWrD1abChEAaJ6b9gflNQvgACWqlyUYwRY+QZcNdIuskXiiE0Oi6RlqNloq661C2QQqFVYo5SdbdGdt1jZ8OvD7sGKaRLEAZQ2Wr8qITcvFxl+xXZSrQlpgzMVMyPL1j9K5sv1NGZO7lGhFBkIYoFUJVIE+NdyKJTFSKKBVBqmUKlRfJyOnNt6Ae0kI+/JKU/N34tS//2Zd//dBsP9RD/fpXYMW//ZPP+ez6hu9+cMblqi3QGW043L1CbTaFbJrBR1h3G9qNYjh8jjvucOPA5VlNiAkIGGWxlUVpwRzcPQtFq4ASCpzDVCX6B5GZpxEtFUaWOJQQIi5FfCzbAIQgC4GbPFlnEnC73zMMA7aqaNsCFwspc+wnlD7DmOWbS4HoRyCQiPi4QETJnG8vCHNJzxinEeSJvZsZ5xmhBNoa+mFESknXrtAy430o90o0w+iZphEfHNkUCE2nLSEPhHlCyeIV1HqBVmZKBEsKKK1p6or94EoqBpL9sef27g7vAjk6Vps1UkqqWhc5Ipn1ag05M88eJSu8i8Tkub27obKaLBtiBl1p3ty8Yg5FbmgJmEpz7PesVw19vwcp6PsdOTkEnsuzC67fvOTF40tSmoFM163phwMilSH661dvqJVhmkdin6jqiqePHrPdbCBElJE0TVcG87nEJaWUloNyYcR4PxPTjKmrcm+jAOmyyMRUDnzTOGFNRYwRrc39eWPyI6Mb/0reKw/1UA/159e7m+6fp4b8cuP9bkN+2oS/u/kulG9BCkd88CQVSdoQc42Qj+nOvsXVb/wB1foJqT8wiYyoGvQjgSJBbaBZI0xpiLOUBJGQYUa4GXE8Iq7fQFVB25UfdU0yligFygfk3TXcvCLfvSarjPngOVw+IZ1fwfYc2aygasHW5TIdA8l71HCA/Q3quMNMA8JNhFgSNYKqCEvzWLBw5SwvlMLot4BrpTQxhi+oUPM95bxck4UQ5CTwLhRullrSLk5Z30tcWBliFKUwFPYIcP+4nyKMS7+Xv8B4EmJJmHiHGaVlxogSmNEoQWMUq67FViWSsnyVAikVSi//42VzLZCQcvFuUxaAYvlPCVU25JTFt6L0NykW0HcWEvLpJv/V1FdPNTeSGFIB1PCWhDfPI959MW8vhLi8KUpTHnyRhd033/DOmygjkeQY71H8MZfgdXVC4QtNDIHoAz5EXn/2EikFvRZoJTk7O2OaRrpVu+RKTuQlfuyUX1pIrpFxLDAas+oWUntgHEesteScF0mGJPjSsFoJ69Yy9CO3N6+LDONqRb+HpHMJgx9nTCih82OccAqMVORQLg6qtiilSUpiV1vqpsaaqngEhQJVIaWmW28w6xUyztxcf17yS00BAoUUccGhUl4eW4lSBtmsUVXFHAUET4iewTsG7wgZkKeBB/cqAyjSd4QioyDLZZ6VCt1cSpJgIS3mt/6RxT5SJmGn4Um+fy5553l9t77cfP+8xvyL1PiHeqiH+nWq/+Tv/D1++slL/t2/+2+ZDjf8J7/1Xa6evs/rPlB1G/pxou8P3A0TIUVWK81ma+nqFSIf2LbnSKGJ08iqa1hvVkxuWnKxwccAWWK0wihL167wMTD1I21do5Ji3Pc4BNaUa3VWGalKjJjWJa+6rWu01tzc3DI7tyivCsyntMuC7Msm/PrNLeeXj9AiMvUD3k/M054sA1IqVqt1SYnQ4IJjmAakBFtbhBAFKCYMEdDGIpUiZck4jyhtECojUmkIx9mTkMQs0KoixYQ0ghg8QiiUVMs1vRySxnGkajuCc7jgCr2dxX+nCiulroo0XeQir67rGistZ6tzgi/KASVUgZXNgZQ9Wiucn8hDYnYlmsWFgTnOjG5A25qrJxfMvWcYDkilmP3ERx9/yO72msurCyolMF1FVRmmyWGEIDqPSZKcLbvbQxmGZ1883BV0bcv5+QVaGvp5j5IQo2MYI7WtmeaR4D3GaEKcCcFhlUGkXL53VTbeWZTNSlzuY6c7jdYGHyNaKmbvGKax3Dsf6qEe6teu3j0jvhthm790nnyXVn5a6Cml7hd9p4axyM4DCk+WiSxrImswj7l6/7/H2bPfIWdDGAY8gtx1mLpG5YyoDLmtwKxBVaBKM66dg9ERDj0cDqjjoeSOW43oWlivyF1LEhIzBcRxT3r1ihQC6vEjxNP3iI+ewXqDsjWgCpUsjOR5gnGA4x52N3DYEQ9HwjSQRKapLU3b4WyDkwafI5ObgYCI4Z63JZXEWIPRGhffsX7e/0Iuvu5iB55nhxcZqcy9vNwYcy9BfyvxP53F312YyaWHKJvw8vxIpMhf6AmKzbxYrIyEWimsyGgFRiZqq+majrrpyEIXNa3ISJVJ+SQ5LyA1kCAzMqdCwM+pkMuFQqp4T+ETufwgRrLUED0k9dcfrua9WzIyy0wlLRPnt5Mp7t8E9uTJSsWLbGz5sxPmvyxRM3nJddNakbO5z5cTgFEKaxRCKpzzTMEjxXLoSokYIiHDy5evGcexZHy+EXzwwfusViu8m2GRIuQsSAnGcWa/P9A0DcYUWt88z3jvsdZS1/WCv9dMc8Sairbu0MLhZsc0JkxXMRwnjv0IIeKkJBtDshqDKJTCdMT7iIxQKUXVNNRtV6ZUqzXS1ghjSboQG6WtynctYjkYDY6YuD9k5ZyY3CLRJ5NCIlIy+oTSJCEL0TclApk5eAbniBT/fEYQU5mYFSJiRIhIEpKMwCsob7B3vdx5gRUsf/UOs+FUp+03/PyG+/Tnv6i+vAV/2H4/1EP9elYfHLqt+NZ3fxsd7/jDf/cD/s7ZB0wu03YX9OEaayUbpdgdDozDQM4D1YXAj0eU1FSVRhnJNM10XYfRlvE4MxPxzmNMRex7rs5qnHcIKYkxlMzrfmR3e7fwZYqU7W4eePziGaqqOA49Skq894w5l2ttXRX/9HLf2R93JGHpukuGcSgyuhSAhDEKZVRRKynQp5GjkGSRipRQC6rKIpVkOI6knGnajpQSjTXEmJa82IzSqmyqj46UDD4o/Oy57BrSKFHSFnLtMhS12hC9o6otooyiCxx0AQWlGHHzjIsBsqAyTbl+JlMysqs1RtW0dVuiYaaRHEpUZF4keM4FhmEkxUhtDZXRjH3PPI+gikRvnkfsmSLOkWO/p2krYnZM84EQZsiZ/rBjs+14/eY1z588o9IGTSIlgQiCMCeSzcs2pjwOTd0U4JtzSCkYhiPr1QajFDIFvJ+pjCVHT3IF2JdsicYU3jNPfonRNMQUCaEMDeZh4vKixRiDc47ZO5xzKFWsBQ/1UA/161s/Twl7yuQ+nQ+/LEt/6+t++/enpj0iULojy3NW269z8d7fwKxfEGJJpVBKoioDeo1UBkxNbmtSa5E0ZRFGgOgQwwDpgB5mCI68v8Hvbsh+RiuN6jrkaoXRBuE9aZrxKWEvrhCPXsDVc9TmAkwBhOEnGEY47OBwB4c7xGGHPw5E78lKoruWutvQrM6g7kimBmvxyXMc9uwOt8R5KPA1Uzzb1li0MUgvF7dzGU6ePOin4cU0zdRVLP2Geuv31ktKCLwdfpxc4qdVW3mO4j2/6vTvtFZIlRCp9G2nyLCcEwqwsvi6jSycEytLjFjbNlhbF3I5xf8tkYTl3l4oekvjvfz6BM9E6UJMT2WYLk7/zymRRVwgcxKR1V9/uNrx2FNVFdZW92+WEBJVJakq+Y75nne0/yXWJadE9J4QS2NJhhgDYcmgLhvm0jgWP0LxLEsh7iMErBIIadCqOAdSlIQlQmC/OyBl8dYd9wfcPBfIWtey2W6X4PbIfr+n61a0bUNaNuLee6SUrNcbhADnHP04MY6ei/PzRWYhyUlgbM1qtaUaBlzoMVWDqDfc7XbMPhCX7DsrBXnyxCHgs8BLiVWmRMpQJOdGVSSpMUphqhoFpBiIRPrlDWysRQQPufjfwuKryBmkqanqimQt0+L/yEBMmdF5fEgLwD8RI2Vzk5Y30bLdFkuXnU8Tq2XosbjIS0Tb8uelxNsnGTi14r9o2/2wwX6oh/rvRv3045+wPwxM45E43vCb3/0OUcUS94Hh9nZE4plCYHez54P3n+PDnt3dLdu6IkTP7COtbcmpxDT2wwGhBC5FZueokQitiCmVGEaK13sODmk1l0+eLL5pCjRysqScOR4OJZ1BS5QQZUsbPCjJZntG162LDE/KAgYFxmGkthXBe64uzpHzLcexx68SWkqiC9wdjlRao7RimEdC8ggt0cKQKF9nmmesqSALss9kmYpqCoGUCTcfyWzK9F2U6EchNNM8sD2rESJidbdseiRGFWiOFAU+6n2htU/jxDD0aFvRVR2VbnDes9l0RCK7w55j3zP0AzpDW3c0tqGuKpCCcS6DBiFEUXcFMMbg5xlBiZFZNQ1GV9xcv6KxHXWlkDKRwkzbVthKs98fOb/cstvvePLoiqqq2b/ZUWuodYlzef7sKRm4291Sm6Ji2K7WyCQYDj3TfCT6CbNeY1VJOVEiQY54NyOFKLmxFCVEygmfCqHWmArvfYnBySVaTUhZMr2FYJpnpJS42VE3zV/hO+ahHuqhflGVc/XC6bhv9pZGHO7tjPd/9w7MS6qiEGJRw5DTAteSaNMR6dhefZfte38DtXpKNC0sMmolDVS2SL6VBW1JVcVkJFUUqBBJIYHLSJ/AB2RK5DBB6hHuQN4dST4UNrixYA0pO4IyqKsXCLsC1UI0iDmDc+RhTx560v6OvL9D7K7heEeeZ7Ju0KsVYr1Gbc7I3RbRnoNdIVEIItKPJBvI9cicPD6UzbVRqmRjy3KdjSktttwi0U4ChCz51sbW2KoGUyG0QWlJVVXvKAbivZyc/M7ZXbx7/k/kHImh2LGK5FtgZGnSlSq/jwtRXUuJlhmrJI3RNFazapvCMDEWIcq97r6jl6r0HVmW6DBxarxzGSiIjEyZLOOywE2LhXbpN2VccsMlJFXYVl9hffVwtXqFsYacyvTDWIUQgRA8SLkAxQrkLKREFgJlLORMzIEYypM0ubB4DTIxl2B0H/J9pICWy9QmRoTSOB9xrjSbRkvygp2XsjwBxUsg0FKiUmbaHXBSMHlXGn1rsaYAZgQZaw1CFI/CPE2M/cRmuyHHTFg83+MwLmHsAm0r4jgRc2K9WaGNxOtMEp6qXpXDS3D0/UDXtUzDVL4XXRGVx8+JSShEytiYqWLGKI1WJX/PKIXIuUACTEWMHl03rM7OyX5g2h8IIRdpRZjIOSGtxYvii/cxEUQBrRWoWsaF8timvBxohGB2mYhCWoGMAhXF/SZ7CRcoT3Q+XQ5FkZqLX7DuPjXw70jFf1Fs2LsX1S//2UM91EP9+tfjyw3n2xXTuIV0wc3uFYfpyPnZc4bjnhAGRJoxpuJ8s6U2NeOwY3RH6lSjO4N3gmNw1JUpSp0s8S4wugmjDGTJplvT2IqYPM654udGkESRlU1xZhxnYk60TcOh79mPI1XTYOuOmAut29QVUUo21YrKVqSk0bXh5q5n6GdiNEs8Zcs8TbRakSS4GDjsJyrZEELASYgkogxIqRmcoxICnxPZB2ohyCoVGftikTLSEnxAEjA24XxCCF2G00KgpEFlzTwegYDdtAWKphUxeEpuI4hccqt98GgtWXcrEKoAZxAoK8l5JuGQ2he6u22wQkMqYLdpLgMHKUEp2G631MaCh91hj0iKNy9fU7WW7XpLU1Xs+wO98+QIdV2RVeD27hoEvN7dIqzhfN2ihOTm+g3ZCeLksdsOVFiyzmfaqhywJJkcI+NxQAvFdrVif4z0w0hqi18vxsDkJk5xN0IscTe5DOyV1hgs0YdFlg8+ZpqmbPiNKYqDTOZwPNJWLfkhTeyhHurXssqlUC7b0zJ0vD+PnvKal3+ZRTmbCyGQRpNVWfrJkNEZlNCkHMkSPGvO3vsdzr7+u3D2HsFuiaoqgEepyEmRpSCrRdJMgMljxoT0E8wjcvZlM308QL8jHe7g5jO4/pR0mBFU2PUWlMS7Hj/vsL7HNluE9+TjBLZHSEV2BxgGuNuT97ck3yNFJikJj54h6w7ZdoimQdYNsarBNGRhEGiUF+RpJg979PiGtr+hciNh9vSzY04JIUqPpYTASlnUsKI8rmhBNBLZtdjNFtOtydIglcLoL8GSEQih7+2oxcpTkGUpLypZHDn0iLlH5kzKoMk0hNLkRwoEO0eMllRSYnLG5kwtIo2pWG/OWK23KGXK14NFVp45mVshw2J1zcswQGUQS6TaaUCQcyLlRJSxPJcUKnqJIIsQ/5p7vIUy+HCSeZQHJsTCrjv5AnwIC9m8/F3yJXfzXX93ihFjDAiJj5EQPXKRPEipcKFAvopUbCSlktMXgycniV4w/kYrjF2etAVjryTLgQMqLRHRsb95Q84wOcd6s2ETtyQSwU3sd3cYa9ELwTbFSD+NhBjZbLa0XUsIoUS4pETXdWit8MGjtMJWpnxtJTGmyDUyuWQFLm/yRCSEzOw8UiiaJTZHUgByLLJ5qUVRE5Bp247GZA43gSxl2f6XvQTaVEhbYnGyMiUvD0HK4EJknGamZUtSRCflzZGBGBPeR5SOSGOW6eIXvRz5fr/9dvf99t+8+y9PF8+f30z/ogb8QVL+UA/1169WreHQT5yfbZFyyzTt6Y9vyDHgXQYJIgXcLEmp5t//+484HN/w4rlhMoH16rw0si4ilCT1I1kUeXez5Gyv6oaubjFC4eYD89hjqgqrClGbDNooVFTkKOinkdv9Dp+hXa3KDVgIjuPIHHzxQdc12hicy4zjwOE40nWSrluxWVdYY2ibFjf0OO9xyhNSwgjBoe8L1Tt7qsYsJFlDP87M80RtLEoUebvQkEkEP9PoQkFfdRWfv+4JqSHHGSlYPs4QfaaqS6KH8zPOOYwRaCUgF6+blprj8UjMCWsstpLEKBgnR/QeFwOdyQgRaRtNRlLbijgHUgzMbsC7gK0s19evmWbPZn2OTAJC4NWrW0Y/kZxiTJ6zVjIPc6HkzgPT4KkqS4qZ4ALW1GTpiVlyd3vE5ATBY0TN+fYMYTQpOq5vXmNNiYpTQpJC4NXnn3O+eURdVfTjQGUb0nK/T6RysMtlgK6X+BtyRhmNTyVurbKWGCOzm3EhUFVVuecusB/n/QIFKtFuQqj/+Av7oR7qof4Kakn+4Yvsn5RKKpJajp8xBrIsChikQCSJcAaBJwtHsIoJg8tnmNUznvzW/4D1e99DqI6kGrSy6JTJwSNKXEKhXscIIYBffoRAjBNuGsF55Dwh93vy7TXp7hrR3yH8iLBr7OMX0J2BVphhR7p5Sb7N4BX0E0JfQw4w3eCFx7mp8Dkqiz67RDYrVLOCegUn77cUIDKKAHECvydPE4wOZkfyA8QJKzWYFh8cLs/omMr3smhepSqDhZgKdFQqg6lb6m5F3TbUjUVIs0SQnUDYkZROaoNlmZbT2waYZUm3yLlT8MRQ+CmZkiOukcRc2nSZxQKALpYpkT1WKbTINHXFZntOVbXFBnxa+gkJuQyU4fTllm5EKqRY1GzvqCROaohMRCa1RJgpQJFFJItIEn/Nqea3+2ORgiu1EMIFQttFDh7L5GGRdIeQ8C4sW+xCvi7I+mVDmxxKyTKhzhkR0zv5colTnhz5JEkpD3Qko5VamlyFVOU1IkUJfrdK3csStJEIEXDjzDh7XExM04zWFevNhr4/4pyn3WwL3CdnBufYHXtqW91LMA6HA8MwsFqV7fYw9EsEWUfXdfT9cO91qKqKXd4XZH8suaNF/h0pwvjiuROZRaJRmvDTi8zNM1IkbFUzh4l+cqRcfO3BO3TVYpuGrBU+RGTVIIQmuFhARCGw7weGaS4Zrapk6SUKkCCGktuntEZXqVzM/n+sU+P87sXyy7//eaTKU/0i8NpDPdRD/frWdBw5HHuEccz9AS3gct0yTTcMuwNVuyFlz+wLLOXQ34EcELJB2gYpa5TRDPHIcRg5OzvjdrdnvV5jdEUO8+JHFowhEKQs7ArnCbPHGouUGjc79rsDWQikKhP7xhhUiGgJWWWS1ng3sq1arM4cxyNJKW6GIz4psqoYhx1Ne8G2vWCzWnEX7vDBIZJAIQkxcL0/orWgrQxrWRUie8yMYWLf97Qm0JqGYRjptpqUIj4EKufQyRCmkTArHIGmAlLm0E9szlpysmVY6ibGw56ma3ATnG9WWK3wU2CcB6TWCKnJSVBXDW525ErQDwN1VaHRvHnzhslNbM436CyIUeGD4+hGYoiYUJQDxlicS1RW088OXa94/vgpUmtud9eMxwkahWwsN4c9KQTs3CBUhdUbrl+9QktDnjxCGQ77mbNNRd1Yso70Q8/hdmSz6lCNQAhPSrHYvqqu5NGmSE4a2zaMzjEcRkgRoxVN25RsWiWwRjFOIy46tFWLB7HcU7wPbFYdMXpEBhd9ubc5h9GG5qylrduHHO+Heqhf03qXTH469997t6UsXA5ASI1acqNTyqSQqYJEGMWsJJMyuOqK8w/+Ni9+4++j2kcgLDGCiBlmh5gHxHwku4Hse3IszX2OGRlBlvQqsmQxbSaIoXi5vUM4D3Mk6gZ19Qzx/tcR63MQktwfsbrG302kOaKOJf0hjdekriV3LXLTwtkGvb1Crq6gWoGqS1MZI2IqueE5jOB68rAjDwdSfyB7h1QaXXXLJlwTxwkRAjaCCREdIlZrMoZMGT4nBCgDusZUHVXdUtc1XW2XRV3ElW67KAnkojxYlN2nRjtTfi0BUi6S7hDuI6NjLqT1dOJCCYFVFklC4xHBU1tBYxW1Uay6FavVGdbWC4z0RGwucvglNoTig12+rih9oBTcK3OlyCCKyiyLEpUskyzwTULpO08xZF9hfeV3GGkr3DQxzyWiSmuDsWahu85E7/E+EuLSfKd03zhLo+99WC6WJyct2wNykZF4H4FIXqjdUpVsWMTbbL8Ca/Mlu9N7VC6wBKkVVmua2pYA9RhLmDoZYxVGCUaXcDFz/eoVfd/jw1Q25kIQUqa/u6PvB3yIbNYVUkqGYWC/3wNwfn5OzplpmvDe8+zZU6rKlo1EjPcAA2MMUUQSZfM/zRP4hDCF9p5i8SBYrbGLFP/eyx49efGt95NDVx3b9ZpaCHa7W+YYEbbBtEVSOQvFPHlijgQyUwiMyzYgkRFS8ba1XmB2IRBiIMaENr8c1OzdZvvLVPIvN91/3ud/92Pf/f1DPdRD/XrVJ69ec351UVROQnC9P3DeRbRMbLuKwU8chyO7w8xnn/8ILRXf+OYZF9szumZFTCVSa3YOqWAKDmU1SkuUEkhdkzPMs0cALgeSEBATLgSEkAiZuLm75dAPSFWiu7abM7TU1KYmxUwWgiTAh4hZG+5ubzm6CVFVjG6inwSrIEhJsFqvi9TuJK0TEhcikYBVmq5pyUSM0cVXqCT9NHCYy30iKUqGtBC4aaaqDTHD1A/UukMKi9WG2/1AW58hZWGTVHULvsLPAmmWyEkfqeuGFDMu+cWrF0kRSqy5Zn+3RytDyrBebwkpchxnJp+ZXGadDf3BEZNnHAbqynKClVbKUCmNFBajJOdnZ+Scub29IYXEerVhP/ZInbE64wbH5fkFJM04euYpsTl7xN7vMVaQg6C2a0QWDIPDu0BjDWoZhs/TjNICo6pyqMqKmAQyCaTUHPsBoRUhRYJ3KF2jpEKpkjQyjCPzNCOkoq4rvI845yGBVrbExhGpKsu26zjs9+iqpm2bkq+OJOev9tD1UA/1UL9cKaXuAczxJCNfGvAQI0rKYr2JkRhP12eBkBls8VM7cUl19g2+9lt/l/Xz34HUgffk+YBwAT9MiHFEjj1i6snBEWUGrQvwTFtEZUEbkAatDVoKyJHY78khICcHx4EoJ9TZGeLFe+SvfY10dlniknc7xDyj6x8h+iPeDSQ9ITeP0ZcXiKtncHkB2zXUa5ANoCBEhBthHsvnn3rc2BPmAdyE9A4DyKpF1C2YFTFpsguoINAhIuaR23GC4FFQ7LEIckoIocjSFMm6LElNUoDW5e+dD0ihSbxNhhBFbIUQcBL6C/EuZi0jYoToCd7hvGfynikIkpJoIRCiWFC1yFgBtYRuabrryrDZnLNaXWBsQzjtr8Vyl8rq9JvT031PvBfyHWXtYj9AyoWuXn5Ili0+EpEycFICfHX1lTfem80aaw3DMCClZHYTIXqEEMzTSPSFthpiJIbi9S7ZmhbvAymm4lVTGmU0iCXuPJds1dObrzTYGZETUkZqvZjjl+b05CU2VqNkMdtrKTBKcxIqpGVaoyVkISBLhJFURjD5wLC/A12e5P44MsiZ4+FAypmL83Oapi0U3P2ecRzZbDYAjOPIOI50XVc+th/wzheqbdPeDwcKTLDMZkKKZRCAZ1IzwfmFNpgXCqBEifLCSkmhjMQHh6naEo+mMoc3r3A+kLRFtSULMPjA5D1+8TTOMXKcJ0YfiHAvP09SnCyDnPLWvfc4N6ONLpI+/mzz+4Wm+he8Jt4lUv68Lfef5+n+RT7wh3qoh/r1K6ciU5zwU2B3ODK6hBYOGQZUyuQgEUlwtu5IvkR8GQlWWLQozRQikUQkpshx2FFXDbYxEDPD8YBPjk2zRQjo9xPzPKGlxE8zla057A44F1BKM88zxkT2x1suthd0WtGtWgY/sjvucM5xPB4RCXo3cvvmJW3XYsw53oNWBiUFIc5M01CI2lLQTxMpOpLOnJ+dFZVWmMhS4P2E1IKKmhBGpFAIKVFJcdjtUXILSS6JJ4uNKPoSh5VL5NXt4YaUzxAYYlDY2mJVpLGFSO6Dw0VHCrFEoSRFzoroHf1hpDI10lQkAaOb2U9HkpDYqiqS8BCYZ4dRFdbUjONAdAmrK6JPGCNJwTH5gbu7G9w8k3LiOPRMcSYCah5orGWaeg7XdxjT4UKAWjKGiWdnL7h72XM8zty9GahqTdNIUj2xaldopahsTYiOm+sdMgusbDEmsTvcgBS4HMgyM00zm1VHCIWvkinnBCEEUqulgQYQuNmjpEbJsjEzRmONQaSE1RqpJUoXEv7JqvZQD/VQv351arrftR+eEhyk1AgliTETQoFuSSmL6VFmnHRkseb86vd49Hv/ACnX8Gok5h1iugE3EHwi+lwsvwtcWDcdwnaIuoKuIdcWjC2wNaUhZoTz5HlExki2HZgDUUhS06CuruDRI/LVI9L2HKYZOY1kA7JOzONE6lbo589Q730Lnn5AOnuKXG1A6tKcOAdzD8MB9rfE44449qScSFKhtMVsL1DCFi6ItQQEKknk5BHxgJh62L8h3b0mjD0KiiogFQWYSMvWOIHUkhhCOfN7V5aEWiKzRJ6A2EBOYrnOZmLMZSAtS76GyCAX+GdMiRwDIcz4GBcFsyrXalkAmTE6rIJKJdaVYlVpKq1ZNR1nm0usXYEwpdkWFEI7ZSB7D3U7tQdSLj70pSFngbCpXD4uiSUyuWzEk0hIIYuMIcki+f8K66uHqzUVMToeP77E+8Dd3R05R4QoUpGsTHkTZUEWAaklSFWkCLH4jJF6iWdRhJxIoRD4Sgh7kRos/JkCcQsBtXgAUlrC0RdjvRQSa8oUR8ly2Im+AHiUWrzglK37CdZghEQoiAKCVMzDzKvPXt1P2uq6xgiNnx37cWCeJ6y1SCm5u7vj9vaWEDxdW99fOI7HYxkEGM0wjMzzjF4iT04QgBgjkhKBEmNc/ArlcdNSkkOJuzHLhC9ngTQWZSX98Y7r/y97f/Yj2ZmmeWK/bz2bbb7ESgaTuVRWVfcIPRqpBQGaAXQl6F6X+nuFAYTWqFvTqq6uyoVJMlZfzeys36qLzzwYySKrewbDSbbgD+GIoLmFL2Z27JznfZ/l7paQIrZqaNZnDDETAizJl6TzGJmco59mXIplU0R5IMXHJMLSYksSpFPtTRmMfOeTf8D3+7Z/CN/fVv/Q5x4+/0P3+fS2h/t8TFR8xCMe8bPC/vCOGAYMNY2xDC7x5u6GzSryxfOXxDGwVYJxWXj9zWtevXrJs4tLRBK0TY2PESsEiYSL4EJC6UiIGTdOzNOMrjoWt0COuLmQrJwS1tZMkyvBpxRVUdu2zHOEpNjf93RVh4qBYZlPF2lwGPpSWeY9UWSktoQ5IaVBisg0DiXfIwdm58gIDv1AXSmCm3HjyGrdkQDnFxY3l8CcLFCiDG59TCTvWRaHWwJNZdFK4NxCSBJtzMfNclMbfPDlPJclyxSR0rHZrGi6Fh8zzgecX04XRIl5mZDCQNJlYNGPJDGDUiSZOAwD63XH/e0dyzRjtCLHhG4aSAIlNNpYyIJ5GUqYaVrY90ekhhwy3kWePn/KV2++JQloKoObF9CSpEpThjGW9/tbokzc3x0YjiNzGKiUpDKS2jSk5HEuswiP9yVEVWtDWAL9OBIiuOBJZJYwk0klYT1mbG2Y57l4+LUii9KTrrXBnoh2XVuMrgi+VJAaW86zzpck85Qj8+xZloWmaUr6+SMe8YifHT691vv071IWDuBP1/KCQrzkyZopskTGiu3lr2nWX8CbIz7PRGaiGJEsSCVQuqJaNQjdgKmQtgbbgVkhrCYbTTYKoUuFLjmV7XNYEMEjFkceJ9JhzzLssbUl2wqpK6QwyFy21kwDTD2RRFpvMJ//CvWL35KfvyKdPyU3a4S0iNnDtIf9B+LdFbE/EudSdyhrjWlXqG4NpgFZIZIih2LjxS+IuUcc7+HuA/H6Le7+A9N4IApfksSNRviAyLmErFF2wOSEmyemcaJxHneSpQslCvFOhWQnASnmk/JAnPjYKT8qUYYS+aSadY55Hln8Qsi5hDBLWaTfKSBE4TKNFbRGYoVAJcGq2bJZX1BVaxD6u84kWZ7XB3UW4sFv/gn/eFCki5JblXM+9SOX9HZyCZmTIpMQH0PS+XEK878IfnLibZRgs2pZrVb0fU9wFXVdsywLizYoaZmmuXjc6vIkppSZl4XgIw+hhT4E4lJCDlJKJylB2Wo/9MOV28rmO8VUXggnopZiwjmHNab0fAsJWZBjefyNMVTWfCTeRVq9oEVGaoGKiZBLMnpSpZJAkFEI5mHg66++QmlJImKt5fz8HO/9iXSHj17vaZq4u7vHe896vSXGxOFwOMnkFXFeTiFzxQsRKBVr4vSLSqUwSpcLJalQQpbQnRTplwWRAxnPtCwIKWm7DrvZkoRiiZ45ZkIW+BCZ55lhHBmXmXgKJChJhLkcNA/5kDkTicRYJmAhhFJ9Ix98FT9ApP8T8u9/rj7s+92MP4R/jsA/4hGP+Hng/Td/oG8v2LQXaCRWSHK3wuWedrNhvasZxx4hFE/PN8z9LRe/+SvqpqJpNNIFhmmiqmt0alDasL+/ZzhMXO52GFOTEzi3oAS4eUFQqq/GecEazTgOLM7RrooiKQuNNopV3RJi5MPNDXN01G1FbW3xoQlJvVpxe3VkcZ5195Sqagh9z8XlOco7jFY4LzgejwghMcbQqYrGGpJ3SCmZl4WcE/2xp2rXtFVDTplxniBGqrpm8b4khgvwPhBkJBEQErxf6FqLUkXRFBePFBpBIelZCELOKK25u96fqjtroMKHogAztiLJzDDNQCTGki3S9z1K64+Db+88USm8UkTvOQwzWpYQOQQsy8g4T2QhmJYZFwO///1X+JzJJmN0RT8HRJK8u+rpbKmqGfoFXSlu391hsmJVNTRW01iFdx6BJPlAdj3VKXhUa41fPFIa0jwRUkQZVQjzMpdN9SfnDSlVSco1miwgEfHR4Z0r1xQ5F5uUkkxzyYopoaxLCUBtO5ZlYRonnHN/sePlEY94xD+PlE+LMSFOS6JyW1G+PFQKlv+kkEghMbFm5V6ibxsyPbl7S7IVsqrRVUNun5GrFlXXiKoCa8pW21qyKh9SqULqYwDvkYsrtV7LHanfI6/v4f0VvPmWdPMG7Q4g18TZIwZHvukRi0BMB/LdLenmmiVXVC9/iXr1W/LzXyCfPIPGkpODoScfjsSb1+Tb16TxSJYVevUEvb5AdFVR4J7yrAi52GRiQExH9HBfCPfVW9LdFcvxWOo0dcnFElKcwtlKd3dZVpYNcSITvCN4j5QKW9dUTWnsECGQZD6lyn+3/s4IZC6K3Zw55Wad/NWxWIO8c/jT84SUhBQheWoippJUVlAZiVEljVwLzbrb0bY7hDLkLE4E+yFYDcTJ3y0fyD+f9rs/SOLFd1Lz/CA7T+QsECfhfBanELgcST+x3egnJ951Zajr9am7LXNxflYuisaRmARNs+L6+vpjouj+fl9+MA1i9iWYBtBKfkykizEQs/wYoJY/uvrLwehToqoqjNbFCzaXhHQlQIv8UWIhTtLyRC6TnJPvWwpVUv5yLsmzAqQSkAWL9yf5n6ZtLDElljngg+M4LCijsbZifzjifCCkxGa7o9lsGKaJm5trQoisVmu0tez3B3wMrFZr5nEpkoksCS6TfEbISFCRJQZc8OSYEDGdtjiZpETpIs2cvBKKYRwJUaCaLbZtEF3H5APOu48eiylE7uaF635g9J6YT/4MARGJVyXAraj1ypvbEgJ5XjC61JqZU0heyuXf5U/eCB8GHj+0Bf8x0v39Lfc/R6q/T84ffd6PeMTPD2mCD+8/EM+g67bYroRfKR35w59+z3nXIaPkfHfOv/zrv2UYD4zjAa23zHMmU0K9YoTKVnz97TdFTYRECks/7Nk9uUQpRXALKSaU0JAkKSaGeSxD25xws2NxgSRriJAi5FwGtYXEZay23B1vySqQfNmgzrPDJk/qAkokBAGpJFppvF9KfohVaFX6UMdpQluFjwEXI/N8ZLPZcn72hGGcGIaeaTpSVxVt05Umj1S2ulnCYdiTUHRtQ38/YpRiiJ55mdFZsbhE0502u3VDiIHxeCQBd/t7YtS0TYfVFiUFy+LKuSwuJZSXzLQMeO+ptKFp25Okv1y41NYwx1iC6JIkzhFTG6yytLblrj8QQmLsJ1IQLC7S73v29xPaCnwO9ENAxMDlruV8fUaIAYMqW4wsEFlBEkSfUUrhYiAFh4+BnCPr1YZxnsmU0DopBVbVJS09BCpt2azWZCK3d3esWJEVHOeBmAKV1IgUySoTc2YaD7jF0XUdMQbq2qJiCeErFriFnKC1HY1p/9KHzSMe8YgfgMgjImsyFWAIMRGTR8qIUAlNLm/sakWSW6rmDDlOtLKiOv8t+uwCthvyqkE1HaLuEHVDatZgW4RVoGXp2NYSVLG2yijALYhlIs9F8p37AQ5HONzA/RXpw3u42yOmGeEdFk0cF8TdFbQrRIhgDHmZiG+/wl2/w1w8QX32C3jxC/KTZ6Rao+KMOBzg+gPp6h3xfo9AYnefIy4uoduCKkHVKTpICzIsMPYwDHA8wt0VaX/Psu8JQ48I7jR0jsRceEnOApUlBk0iIpQ4hY0lYhZ4MsIaVu2as2pNoytCnFjcwiIli4AoIyInfJaAhRSRyZ1aogRRSmI2ZAT5ZAvyKZOkQObi+5bBo5TCCGi0pDGCSmSUBFvXdGcXVOtVUVLlhNLf1cmVjXYZAJRBTKmMFFmeOMIpwfxhk/1Auh8qm3LZzgskImcSJxV0/GkXej858V6v1xhjuLm5QWvNer0m50zf95xtzxFC0lSGpmlLKIKfS4CCkMj7Hm0My7zw4Jp3y4LWaxbvyyQ/RkIsW2bvHHVTA5KUItZohITgZshl2q1VMdaHcJJaKFXST60minLQGlmeNIRAG1M2zyHgU0IIUAhIgXh6MdeVoa4MtjK4kOiPQ7loEILVZssSIu+vb3DDgFaai8tLcs7c3u0ZpwFbW5xf8N4hhGFZemIAgUKgQEhiKkFstbUliTBlpNalAiAmwuKwtQXvqG1Farf4qiOI0o8+OofzjpQCPniObuFmmjk4Rzi9xgQP0m0IglMw0YN8I5dEx5RQsgxCVF0qy3IuifL5Rzrnfygo7VOy/GN1YT8WsPb9bfiPJaE/4hGP+MsiDgqTPMPdLTF4LlcvGYeJiyeKcb7HqMhKrpEkdrtzurZF6EAWCWs7hIi4ZcBIxTDMxNnRrLcoWd4X1+sdISac8CglqeuW6BPTNBNCIV2lJjGUzYACoSUSiakrZu9Zgufu/obnL59grcFay9X+wJITykpiyKhaoWTG2IhWCZEE0zwhpCDHiFWa6D1RaByJ/jiCoNRL1jUxJ47HnraqOUbP7AYgnuxPloGJSoILMylLnBuZp4FpGhDigro2jEPP3/zqFR/e3yNkYJgPHGaHNJokErP3oDRKVQiti+op54c9Bj5HQs6lz9a5EpaTM4sv22UlBYsP5AwxpJMarEjwwpIYjjM+RPwc6Q8j8+LQSlMZyeITw+gQTjC7BYkix0jXtIgpchwdddfRGE0KnhQFy5LR9uFcm4kSFu+JMRDCvnjeMVRGI4A4DUWJ5iO79RbvPfMycuiPuBSoVjXDMpKJ9HOkqSuUVMWyFiGJTMgJFz1ucHR1U3rQlUZLTbfusLpCPKqoHvGInykiEknM6RQk+dAdTfEVI0HVKPuE82d/jY0Ny3JLt7tAvPwt7C5htYW2JdcVwmqwGmEqstZ/ptSUKZY6Me+QfoFxgP4A44GwvyXf3SFuDyw3t6j+FjveIWMiCwuqIksJcSHdXkPIcHMDxpCCY7m7whiDef4cnj6D83NSbZF5gvsreHfL8vZbwvGWuj1DXXwG5xfkriaRSn3YtCDnnjTcE/a3pPsb8v5AHgaSWxDKoFdb7JPPS4DaciT0H1j2V0QXysIsFym+Eqc2JZVKl3WArCObuqH2ibp3tI1i6EesdyRtiFogZUJnj8SSKBbhsj1PoBQhl7wNcQo0e4gzS0RkjugcqSTU2tJoqJXESlCiWI667Y52d4aoLEkmHtKjHkg1UJZ9py34d5lR6qTaPXGIj8z748vlO2RBzkVen2I+nS/+CyfexhiWpXgS1us1dV1zdXVF13U0Tc04Fj/0ZrNmHEfatmW73XK337NeN3TdCuccyzzTtC37/T273RnjNJ20+IJxHDnb7ViWhRAC290Z0zQjBUSrCHN5IS7OFR+D1acNu6SuK4TMCFGjtcZI+ZF4a63L916WQkhjIsZEyqdQgqypqwprbZE3+sCwLLgQydSElLi7veXu/p7tbsfZekddVSyLZxx6QvRYa0kpFp85Eu8D01jkb1oqpDxtkH1EpUL6Sx+5xlQVQgrm4EswnCmBOjkLpNUIlzBK4oI7DQ4iQcCUA/tp5LjM5eD7FKeJUIwJKTNSlMdCUlQpOZeEeO8cRhmkKMqBIi/5zyPOH7/Vj2y3fyxo7fv4z73fIx7xiL8MtNAsyaOM4MPNFUNITP7A569esFqt8FPCaINCoVXFbtuQ5My+P/DmzRvOz3a0VUVjKmodSPGSDzc3NO0KLTWrtsWYCu9GluiLZ0wKxnnCe1/Cw6RCac19P1A1DS70zIcRi+TZs0vSAmaq8LNnVdW4xeNDIElNpSvCnMgJpvFIZ0GqhIy6qKvCwqprEZ3F+xG/LHgpiCmyXW/ZrXfs+wPXt3cQM58/f1bOe+7A0B+gga5tSEkQSbjgGF3EJ4OQiRQdOS5oBYfDnml5jlAV2tZoWeNGz+HYs0TP0O9ZrVakmDkcjtSmKuTylIdiqpr+2BNdIqeTnSmE0mYRE01Vs15ZQqZs6l1AC0tIYKg4jAujm7k7jNz1AyEFLs46lAtYZbmfetp1x5cvnnG4L7WbQz/g5pla1xAEgUhTN8QkWGaHDGXbIEWkamyR1zuHNQIi5LRQVzXWKo7D4dSJrnAxcn88EqJjCZ6pd+B6hBHkHFBkTK1x3p8S7zXW1IzxJJ8k09oaawwpRNw0025rciwy9Ec84hE/P+Rcn6TAEzlPaCERQgMakS1ebqnOfsGLL/+WCsnw+z9h1xeIF8U/Lc7OYbUqQWlGklWRGEcg5YgKEekC0nmYHTiPciMsd9APxMOReX9P7HvsMCOPE8o5pEuIAGRFti1qfQbaoKLHDwfC9R3m/lAStUUmAfrlS/LuKWJ7CbZBeo8c7+HdW9w3b5iHAXN2jnzyHHY7UqWQwqHmCYYj3F8Rrq4ItzfkfU+aHCCoNlvkF18iLy5gcwF1C8HD8Q5z9Q3JR7x7R0iRmItkW8gEp3DPoDIpR1oSq2Fkc+ypRMUyDWAUZrVGmZqKRFh6pnHEGIWUiUlDTqoEQEtNSgIpI1pGRPZkIVHaYDTEmLBkaiGpraY2GaMESiSQCm0qLp48ZbPZYa0lyqJiC95/JyAXolQry4fl26d//vhS79OQvpzSx7qzkpX1w/lS/0viJyfeD9vt6kRQh6FI3Oq6xlaW+/s9bdtgrCYNkbZrqWpLNRtsbbBVxf39QttVVJXC++L906ZlOUnHpIzUtaauNcf+iDWCHDVKCnRtmfsD80mCIpTCWgucfAJ8V0eQUnnCpVIoKU8yc1EmU8aU7cZcKlsennDyqdYrF6N+DhEJNFWFqSzGWA7HI/c3N0zHhVW3QmtJJqGUxgWH9wsya2SSTOPIPDtiTCghP05qrFDw8KIzFoQ4Be4I5hRIVhJIRFnk58JoZE4474tnMUMUgjEEDsvCYZ7Kv/seYf00ZTxnirRdFH+EUAIliwQ9hUAIAa1N8b588nx//+v9T3kR/9jm+8fu+58T6PaIRzziL4PNZuDdHBnHgXEumRW//uvPePbsC969/YbzzQaVM1IYnj19wdXdW47DRD9PRDJSGpZx5q5/T9d2vHhyzvPnT7ndH6mrlv39gaUfkDKxWbXkDONhQEjJarOmalpMWLjf7zF1w2p7xv/4D//IuupAcFIBFWKaM8zTQtO0rDM4IamaitnNdN2Ktq6RaYTsGQbH1jRoo9muV+zjbRlGWstykkzHlJgnx6EfmX1gXbUM48Tkj7hlQYSMiJllnFnizHptOA5HxpBJeQ0krJG4ZUJWpWJyf9+jdcXhODEsPdLUTLMnyUxIghAzKQXEiTyO04yWqpzbtEFpS06Jzabmfn9PTIH9cSiZHTry9Zs3NLZi1XXMPnJ3e83F2SWhH7i535O1JmjLlDIhZsaQWAaPHyI6NwhvWe4dnepIjLTthrP1lmGYub+55/xyzXE4ElH47DBGo5RGikiS5QIqnCpC/RxYX25ASI6HgSQys3fMywJS0HWlAqxuW97dvAevqLoaSCS/kEQihUhdr+jaDik0d/f3qAybrvuYvGuVhpyZxgGjDVLYv+Qh84hHPOJHELIp19nZIURCSosQNSk1BLVh/ep/y9O/+T+hl4D//b8FN2M//zXp2a9IT5+id5viixa5yKEXXzzRfkF5h5gdYl7I4wTjTB7Hkh7ujuTZU1a6grrdYOwa1IAZjpAd+ImQBfryGTx9hWhqco7oq/eEb79CTEfIEW0sZnNWCPf6KalaQcrIuYd3b4lf/R5/fU199gxz8RJxcU5sq0KeD3vyh7e492/I12/hcERPHuEyot0hPnuF+OxzePYSzs5htSYZW6rGrt+DknB9Tbh/h8+JSCruViFQUhfyqSXBedY5UN3d0OQGuUTSdkv97AJ5fokwDWlxxBDJ8zW4EWnAtC1BaXIWeCkBjQwJhyP6mSVE0ilktFKCWkIlwKqMVekjIRVCsdqesbt8QrveoLU55X+VnK2HALWHPvf8EKwmHjqqTvFT3+MT/ySc+cT7UkrEU21zzuknD2z+yYn3Q41YVVWEEBiGgbqu2e12zPOM0oL1piMED2TatkYpSYqe1XZNVVXfTfJTIqWKs92afhwRJJrG4FyFMYVAO6ewViGB4Bx1VdO2bfEhOFcmTlDqRE7BAJ8+OSEEZE5kXTYaVVURY8Q5h5IKrcoTr5Qq0nWtThLtRIpl0i4onvC6qpGikPppmllmxzzdstmuEKIEIQgJoEoP6zgxDBMpgpQapcqmpm0b2rYtkkItkY1FqJLuF0IkVYqoJVZLspOkJROCw8XA4j0+J1wMzCmyn0duh57BO+Jp6PD9ZPCPZJbvJkoPQwaRckkq/JgAmEtIQ87/VMHxyeToPyUH/36394/hh/zcD33tj3jEI35eePFZxW5VoWvDLKE7W1NXisYk4jLRmAsu2jWNtez799RtxWHUGLWh3kDVGY43PT5mulVLZTTtak0MAUTm1WdPCD5AzLjZYW3F5eV5UQwZy3HY09SKqw8L3guapx2vnr9kOh7xfmYYyqZ5021OHjwFInF919PULa//8DWXl89JOePdBCjc6NEkgusJeaSuK5ZoCEnjlpnoI9vVjt1qgxKSpqnpx5FxKkqm1aqFlDCNJnhYlpmmshyHAdBokQlhoZbgTCbImUo2HCcPUrJZ7/jT68QUEu0qEkns+5HaNqQkGccRqyxV3TIMPWSPsYa20uXr3NxiW0NlG+5vbpnnhLaGfpzx88IgF/rJ07Rr9v1I1TkQEicyblnYjz395FBSM46J6biQlqJusELRVBXTstA2DdHBkBImGy7OzvF+Zg6JJc7MfqbtOjbrmpQlow8oIRAps8yOShtiTOQkMMqSsuA4jywpMISFefBUdY1fFvbHCdvVBOloupo5Thxub9FSsYkarRoSC0l4al1js0FE8MlTrzqkEIxDT2UrnJ/57C994DziEY/4J0hJlAwmacgkgmgIrFDNU1787b9m8+v/PWFu6N9/BYcj3XaL2J3jui2ytkCAaQTnEMuCmB0sDjkdyG4izxN+6AnzTPYOYrHeSFVh6y2qXUNbgcjkaQRtEDiYBYvI0LToJ88Qr74gb9clNftsRwoT/psjJkQygSxBaE3ygTSMqBjh9gq++gr/9deY2mI3Z7A6g7Yjy4joe/j6G/wf/oF0+wE5L9gsECGTbYt48Rn5N78lvPoSeX6JbFfEuiEoiZxHZPTkwx3eWOaccCnicml8iikRc5HuJ0QJZs6JZhqR6RqBot5toelgcwZmhZxn9DKxkgrfH7HascQAtcGT8HWDtRVLXFBEQvLMMeJCICeQZDQJI6DW0KiEISNP9trVZsd6e44yVVEap4gS+WQHKKnmUsiSdVXYCvDgFigb7+8T6Adu8dAalVJCkImnRWJKoYTC/cT4yYl3CAFrLSEE9vs9Wmu22y0P/XtKKarKcjwesVbTNA19f6TrOrq6Zp5ndus1bdtyv99jZUnxnhBoJZGAUQolBEbrEg5w2hSkANZqulWLUgI3L0zDQD942rrCWo3WZVv7sQ9cls3xwyTlgdA9PFFKlqAXrTRGKYgluEcIgT0lsaYYSzhb9CgpsUoQjS5+w9lxc3dH27RIJVGqVIG5cWbuF9zkkUlipEIphbWGpm2wXYOoDWrVoLYdMaXS7W0MGIGqDEKAtgafA6FPLMGDljgfGFNi7xY+HPbcDz1LCEViQjqF6sgfkHtn5ENaoBBIUpF1ZMgpFbJ9+nioE3j4Cv+5W+7v94D/kMzju68vT8n13932Qz3gj3jEI34eePr0nM//5TN+8zfPCVpzfTPyx7//HdEd+PxyzfPdls+efUFKnn7YE7zDWM32/Jx+6Fk1W6qzmry9YNUZpmFkHmfONltiTrRtyzIuVKZiOE4ICdpIFu9YvKfpag7HA2RY5gU3LzRVRZom2rYp9VGpSK1X6xXGavr7ay4u1xzu7tmsa6y1tO2KvAiCLxak2ggqqwgLQKayhsVr3DwjUARfsj6UhOPYsywz07BgL88xxhCcLhVgc6SuN3TtCqUyt3c3ICC4BR+P3N99oGlB5cT5bkfwHpEMWlhElJQQ21AGo6mEwwXtyQHmybHMvsi2ofSYT4Gmqk8drYmYMijF7B3DcY9C0FQNtdC4xaO1JYbEtMzc3Nxh67pIErPAaEu/P5JcpLJ1SSSRkuVUzWatYR4n6rpl1dXMbuL923eYtmKYZpTVKG1xPuCdozIVOSfO1mvG4xFbVRyPQ7nQFqC1xIfEoe8JJDabFVIZxsmBUOQsub65o5sb6kpjdY1Rmso0xeOdE9lHKqOJPjD64lGXSuOWhbrpIGcW91gn9ohH/ByhRBnERWqSrlnyiu7pX/P5v/pvaV98Se4D6fYD6d032GlGtuclK2I+ovYLHBNiGsnTBMNEPM7k2cF8JLmJmBPZKKgMetNimgZRtaA3CF2DMGQRCWFG5IioDUJGlumIjx7b1CW87fKC/OQJaIFYtyh/xM13xKt3aCVK2Nn9LZhvEcuIqCxcvyf94Y+IwxH7yy8R3QraFclUCDeg7nvin17Dt2+o4oQUVQljRkLbwsU56fIS9/QJdnuGVIYsFTJnZC7u6pgWpjAyR1fIcT5VBKdTRTMlYMxKS60NNgd0cqgUCqFVBqo1tBuy1GArGmuR04jwPdXsCZXGGY0SmmhXSG0ZRLF/TS4wLQ6SQSvQJLQALSOVTFgJ5ITShs3ZJbbuSJQecHkKb4ZT/pT4Lr085XzKoyob7x9qRvqUdH/KMUIIxVoWQ5Gd5/iTk++fnHg/dD47V0rYu65DCEHf98zzxGaz5nDYI0Smrmti9CzLTFXVaG0JYURrg1IGtxRPdM6CnEBJQwwl97Spi3TQ6AolNDmH0sNNpqpKp3ZT16QUwXuMMShVPNQlPK38vOJU65VUIdMPvdXfbVoTMYTThMR/7LMupFBhjS7VLzHgpokkyvcNITKyoIxgmT3jNKGUJafIPC/4aSL7EhyhlabSlrataCtDVVl0V1Nt16hNi7OSjMSLWOTolSZbhbEW14/MJ8JdtU0h3fNIHxauj9+R7pQemgSKZ+6j1J5Pts8PoWtCoIQ49YgLhMjEU0Kh9B6lNdKoP+u+++ck5v+pwLQf6/h+IN+f3v/7tz/iEY/4+cCuK677d7z7779ByQ43J0SSbC/WdM2aZ7tLZE7EFE5tCAmRA2N/YNV2bFZrxpSQorxHSW3RpikxOjKjkTSbLeNxojIGpRUhFzvQMA4gE9poLi/P+eLzHeM44saJZ0+e8vL5C1BwOB7K7dFjjaFb12S3sMwL220HQlBVimnJSCkYxwFhDcEYEDAMR/bhhnHu8Ytn3Z3jPXgZEUZSVxaptgiO9EOP0pkcXKnLQqOVoqlaYnAYXVMZBVRMfaapJctwR7eRVHbDeDxwj4AoWLVrlM50VUfKIyQIs6erV0zjQk6Z7eaM4/EekyTLtGBUje0spEBiYnGB6/t7lFGs2orkPCEklsWjBDR1y/E4oIxFa0NOMPYjRmji4uiPI0YolAjUbcfiZhYX2e12bDdr5jlgtSGmwLzMtN2K4zyidEXTtDgXGY4jz588oVYVWko6a9k8WVHZCu8jAsnxeEAbxbxEpNRYVSGyIoaElhWmbTjOPfNwIvDAer2hqSpyEszjTAwL59stCklKAVOVCrfD8YBSmsOxZ+wHvA/813/Ro+YRj3jEDyGnGSkbUm5I8pIXv/3XXP6r/w61fkY6Toj7t5jXv0N88w+YlEB2YO6wooa7DG4gupEwDfh5ISeBkhZRVaizHVW3QrQ1NC1UllxZslQIoclRg0swj+jgoT+S37/Bv/kW+gOWjBHiRE4bWG/IlSEK0OFX5LFndp68P6D7EfH2DcJ56O8IIiE/XCGvr7Fak6RFNi00hmQVuAzDRL7fY6Ivat0M5EiSkGVEEVApUvuiukVmdAqwOBgHcn/HdPjAob9miZ4lhmKJirEkfVO+pEJhlS62GyORBmJ0iMUhXYQoEFKT67oEwhmJdjPcHDHViKwNZrejWZ8TdMWk4E5ZxsXhQiLEElJtlaSSkkonKi2wsiSZp5RZbbZ06y3K2NKvjUCJcv59uOZPp3C9osz9jheUJPMf5x8PxDulklcVfMnASj5AjuQcSw/6T4ifnHhrY1icY5ompJTUTcMyL0UOZy3xFFgGAq0NwzAQY6JtO7wvnaNKiXIhoAzW1szzAhnqkwxcUDawDz3dlbV4F1Hq1ClHJqai3Y9k1Ceb2eLty0hbnkgfI8RYEs3Tw0tRoJTGmDJZediEa13SVjOZFEORLYgS3Oa9R6RMFhKhFHVVMYWA8xNZwP44EONIjsXTpkSmMZpK11ipqWzNZrdls2pYrVrsiXSLtsJriVQSUWoFCbpM8w/jUDoGtWSJgRQ8+2PPYVm460eu9vf084wLJchNKPmdnPxh450fqnU4xfKXvnIpJEo+BKyVgYpbZoQEW2m0OCVCnsh3zn/Gwz+iHAuC70cL/nMb8u9LyR88+Q943Hg/4hE/Tzz/bMub1/cMvUFhqW0FUiFWNZuNZfYDMY34xTGdsi3uDwdWm3PmceKbr/9EjhNKCrbbC/ppRpuas+2OeRqIPqGIVNYgrCHljJumk8VJlIn+Sa1ktUZUNfpM0dQV4zDgguNuf8fheGS1ajh7ukUF6Izl6eVvuDh/wh//eI0QnkiCrFBmjdD6o21JKoEVmhgt03FBrmt2uzUhjiidYfE0dc1VuKVpSoinrStUJzgeRoQoyqfgBZVtuLq7Ruot3UqxXj8j+YWuUmiZCfOIX4rFydYr2pVmq9a8v70i+szYHznMeySGHBIqGc53T9BG4PzMMo9UdcXZ2YbZBUgKQUUMgspuQCwYKVjGCWPA2IrDcaDpMlLqUpPpAl23Yp4mrDZIFNpaqqZCykx/PHB9fc1ut2O3WVPXDf3+FoCMYJwcVduxuEzygYuzc549ec7N+yuU1pAySEFKkWmZispKSaZpZLNa062f8+HmPao1uDFwtjunnyeu39+SVUZhWdUb1tWKnEIZREvompZV3VLZiv1+zxIDWkqkEozjxP3dnhR++mCdRzziEf/zYKXEy4pon/HFf/N/YfM3/0eyWrFMAY498u03yG9+h7l+izAryAOZd+RhT3Ku1G/VitxYqrZDrtbIdkXutlC3iKpB2IpcNadOY0lOnuyP0I+IYSDf35M+vEG++QbevYG5x5DB55LbkSMlPk0gdYVYrcE9wXzxa8Q4sfzHf0D0R7i7gbQQ/RlOCLi/w7oZqdfEJMpSMUOWGilN2WpbS1ZFqZpToGyxA3neIw9XiNsPyHoFMkJXIZKAfiTf3xLefcv9+z9xf3hPjGXL62Op/foo04ayZEOSlQFbI2zF4hyiP1LPE9ktyBgR1iLXK8SqQ1mNPx5IhyOpabD1CoXBC03Ek3MqdcRSorRG5cInrJZUWmB06XCSCYQ07M4uWW92GGuJp023lOIj8f7uLVqc+JwkZU6kG+BhEZdPIWsP//uJ1DwUpVV8yMEKoTxvuXi9f0r85MT7cBxYlpmc4ezsjH6YCkFVBoRiHMvnmqZhmhzT5GiaFTFm5nkGCrFyzmGMKdJA75Ai0zWlD1zLTAoL89iXjldRJHQxlSlOPBnypSm1YX4IHMcJawzWatRp86tkRihJFuVJjA+JeAKk1iXZOyakKlttLQQxlItFQfE6lz48sJUlxJIOnkKiqmq2TUNYIt5HFu+Z54jMoADbWHRTtgqNrdludmzPz9jsttRdi1135KbGaUEmEp0rHnRryfKUzHgqtJ9jYHALbpo4uJn7yXF7nBjmwOJC+b3kyautNCf6jRSnwvuUTi/yciBKmRBSoLQsfvZTjzghg5ckr8EaUMWbkU5l9fIH+8W+k6Y/kO/vh6R9ui3/vhT94baH+zwS7kc84ueLJle8OP8Mv2nJsUFkzf18w+v737FSFh0kF/aSYXD4qXj4Qir1kFbXSCFY/EKzapjdjDSafppQqtSyNNYgrUHoU7BKyiUvJGf0aUs7Dj11XbFatciuI6SM945MRknFarXCWIOtNNMyoY0iRsn19R33dwdy6ojBgRSY2iIUSFUaKIZx+Dg9FwhWqzUgmBdPXVd0mwp/H8gCjNUM04gUidWTJ2ih8EvisN9zvt4yjiPXtzelj/pwzzz+A08unnGx3XKx7limyO3+wCQVuyctwi4s84RLE0oobK0wSuGCI7qEm0sNZtde4txEcIF5nvns5TM4ueIqU6OFx9YNioq2awjzgLEabSzDvHAcerrtlphmxtl9rNfUWmM6i5s9KSVcKBJtayq6VcfN9Q3/1X/1EmsMYenpR1E4tTSEmDne7Xl2eUFtanKInEbYhBwQSYJQQMYFj3cL/fHIZ599hq4MfPgAEcLi0cpwvP/A86cvGJeRHCBGUTbdiyfIxGa1olGGaZ45HI8M80hjWlJMOLdHCU3KimGaSqf5Ix7xiJ8dfFzDxW/44r/7v9F8/l8TqWF/i719g/jmP+L/+PdMVzfUuUKGRJrvYXYk2WC6S/T6OWxWsN6RuzWi3SCqhlzbEyfRZCGASPQTcnEl9Ky/hft78tUV6cM70ocrRN8jlplsIylINBW4RHYH8HcI9wzqNcIa2Ozg5S8QLsDsGP7x79jIhFhVyM2GenVBOn/C8ub3pH6mHQbUfoQhQqXBnpGfefibvyGJBW7ekkSEFNE5lw3+hzcoXSGjQwyXUNuyEZ4muLvDf/s7br75B4Z5jz8FLuf8XUjZA5RYEEoQbEusz5C2QU8zcdyD2+PznopzkDW5WhHWa+R6RdYCvCcEjXIC7SXKJfBH+v6GiEeQ0UahMiACSiWMEpiUUWgEknq9Y7d7Rt1uyiCWjBYK+E5eLjhZYFU5azxUZj4oZvODXz2nIsfPnEL5HjzdHu8L6cYFREplUfr/LxvvZVlKbLy1eO8/VnO1bVvW+zGVaf/J3P6wSR7HEeccTdOgtWYYBtRJEj3PC1JI/KmLVCl1qgDJaKVIKbMsDq3tSYJQ+qhDCGhlwGaWecaFUPrllECGRP74dQQ5ZSLxVK9VlrkPJ2QhBN57hmVBClEi8JU6yTXKxliQySniFo+QClFBYyybtiVmx9Rk5qUn5ozSBmUMtq5p64bz7Y6zzY7t2Y71Zk3VNNjaUFXVx8cnpfQxbd3ngA+ObOE4DMze0buFaR65H0fuDiPHccB5/7GC7VThV16knzxfOaWSYI78OAgrL3JKuJr8Tpr+kB2YYiLFWKp8HlbdOfPp4uDH5OM/hh8j1p8S8QfPt1LqkYA/4hE/Q2zjJbvtS6LQ7IeZ1+/eYbeRLi88211y/3ZE2DXGgl8Whv6exTuubm7ZbS/YbbeMe8dyt1C3NfMSMbrC3d/QaEXXbEtIrZKkkAgnL1tVF4lgxNO2DckJVqsVw+GIVgrnM9MyE9zCdrMuaehLTx0rmq5muO0BzbJksouEJpKzpqo1Ta2wSjINI84t+MUxuInKWjarhuPgsLXBhcDx4OialqurK0SOrNqGrm0LUfWRHBOrtsYYSbuqWIcV+3GkaiQpZ3KemQfBKGCeF5pWUteSTKSpW27v7sky44NHVJKqrrDREkzGLXvqpmZxMyF4qqqmaWuM1kgkq7rFSMl21WDqhu2qxQBCV6Xqy2ju3r7HVhXjtOBCoqobpJRM04TIGUV5D44x0VQN/WFPzIn94cCrzz7n7u62DByGAWUMKU1lqL04dusdF7tzans638cSiGfrFqsV3nmUNAzThJ8cf/1Xf0tdddzt7/jF57+AnPFVyzTO5JSRSdKZlpgiShnujwO2Vmx2a1abjjg56rqmv7vizc07nm+e0DYlL2VyA8viylCAnz5c5xGPeMT/dJi//r/y6v/w36I2n4PPMNzA7XvS269wf/yKfNtTtTvUky1ivYbtlrBqEesVodmg2w7ZtXDabJe+bUWSEWJALSPZzcQwkKcD4rhH3B3g6kC6uSHcXZP6PSIsJ2IXkcGghCUaSfIT5u4a7m9w5z15tcFqi6gVbATq2Uw3Dgz7O5b7GyqzQrTnsH2Cbl8gO83w+39k7m9pbr9BnFVI+5K8OYfdDv3bf0lu17iv/0h89xqOe+w8on2A9wMcv0a868m7FXFlS4r54nB3t1y//xY3HchLIMYfDz7OiLI8O22ahRRoK3FzD24uQXAig1GIyqCsRRoLWpOzI4iAnw7Y6UA8Jvb9W+6u35ctM/lEhkt1mFUSK0Dn4t+HzHqzZnt2Trteo2yNyBkeOtqFOPmwy09a+ItAZkEinzbaAkT+KMDNnLhIhpwy3nnc4k4yc4/KD7yi/PsYI967n/R1/L9KuFpVVUgpGYah+PSkZJ7ncgFwIpIP8uyqqj4GmT38e+/9KWjMsixLCW4xuvR2x9IDG2OiqlradsXiHDFlqtoSQjyl3wn8PBNzJuSyHQ4p4nyRAcpalSfHB1IIGGNOieWivFAQpFRUcCmeYudP1FMbi9GqHIiiROELUST08pSALsovgwbWdcXsIoNVLD6UF7Ap3vK6bTi/vGC72lC3Dbapadcd1ppTmro+/Wz6lLa+kFLAzSMxBKZlol9mjn7m6CZux559PzJME/HB2P0wTXjosPtEyv3dn3y8D5QXrJAlzO4hhE7kIkVPKRJj2YAURg+cKnoe8P3gtofkwR/C97fb3//cA+kuHv1H4v2IR/xcMSwDIjvWuzNevTjHhTtmNdLZHUyBs805/WHg6v0d0SeMtKQk0VXN1f0dSYLPiZuba8zB0K63NKt1ORmfBqB9jlRNXb6hEtRtTaM0PkEWCedm6k2HUgrnPDEvLMGx2W3Y395S1y0hRqruDK01SkieXFzy/uoKjWLdPeV8fcFhCQiRaBpNpQXjYUDrMsRMIWPbmlXbYWymn2bu7/YoIditWkTKtHWDNIqua8khEX04WXiKbahbd9zc39O2NVkqKiPRRBZ3xHlJVRumY49oN1RNwzD1hBjpuhovC100VYVC4H2kbiq01hyHQwne1IJnTy5ABZyLNKuKV6+ecxwWvvn6W5rdmtZWRB/p70emw5HaWurVivcfrrk/9tRNxzwvKCnRRtGYiuAfznMlwV2cBrrjNLLedDRNQ1VVvH33gcoauroipEzXNOSU+PDhPU8uLxBCE5NgHByryzPaesX93R6S4uL8GU8unvHuw3vqqsa7QFtXdG2LC4ll5bFGMy8jw+K5vblFqkyXa3RdunOzTywuchxnMpJ5Ctxev6dtO7rVmpAGxmkixEfi/YhH/Bzx2f/5/46yljxOiOEW7q5OH3vSeot98RJVr6BZQ7tF2RZlWnJV4deaqCVSq6L2TIk89uRlQfoJsSwwTIh5QM1H0uGafH1Nuj3A3UQeB0z2CBnJIrEIQa4q7OolompIacSNt6jrD8h3H+D8lrQ+B7MFbaGVcOHBzbTzyP4//H+RSWJNhagbaGvkF39Fqy3DH/7A8eY1XSsQKkIO5HpNrlrkyy+p1ufw2efk6w+Iq/dwdwuHI/R7GI7kd0AliUaTRAm8dNMR7zzZJWJIH73Of37tnPGp8IKYEmQPaIRMpODJKSLj6f4ykWSx7p7Wc5AyRgaW/oZ0+47hKLk7vGW5KzWOIQVCdOR8sksBFQLzieL47HLHarel7jqSPClyM6cmpVx42AP5PtEDlQWkouPKJ2KfYyoh0ElAzKQY8c6xzPPHpW1R9Api4pTnFXDe4dzyk76Of3Li3TQNAPM8lzAu+TAhjxit/4xYPySdP/iNH+7nfQlVK9vumbquSTkTc0Lp4i9blhmEIKRUUkmFJAHOORJlS4uUICVSGZLw+PDQcT0jpUJrSEqgjCQLcZJuQ4jFD5BSKuEDspTAl75vgdSGdJq+KCnR1mBM2ZzHGLG2bKpDiKQYMMpgZKJtDEkUrXmC0lurNaaqaNcrlFan0MLSUxfzQ02YR4iSru4Wh5t6pMgcjj33hwP3Q/F175eF/TIxuIk5OAKZLEURZeT8T2iv4DThetgmi5KG+BCupmSRmpMzCnGqEYN8ktNnU6SCiYdgtv+0ZPzPvv8PkOcf8m9LKdFa/xnpfiTej3jEzw+qtihjWRYPUqNUy649J8aZaek5jkd0A6vzwDx4hv2EsRs+e/lLvv7mW77++h37+2t22wbbKPbDgavbPS+ePcN0K5Q2LH4migRCYrVhe7ZlXjz5ZKtpqhotDfO8oK2hsYqVXhFTZL3ecHN1TbdeUa1q9sMdbV2REhhVY2zN5fklhETGoY1GKs/iZpzvSSHT1A0rsSVH0EqitGRxE5cXO6y0RLewalfgR8ZlBMplitGaurFYazFGk5HUVU3MiaqpYKXIXkNQKJEwOrB9saG2DSioVIXWG47jHmkkznsWtyBykd0tYeY4eqSU7LZb1psWIeH8Yoep4XiYefriGb/73RtEhFXbURnNmAfaTUXlNZ91L3h/c01TNXifyAjWqzXWGOqqprE1Yz8gRGa96nBGI2V5T/bBgYBu1fL69fuPXnajFEomlrFnUcVTqKVgs1pzd3PLiy9e0dYt4zhwdXXF56++QCN4/e1rTG359pvXvPrsBVM/YrSmaxrW6xVXHz6QfeR8teG235OtwsdYaksRyKy5ub1nmGZq0xBjZr3ZMM+em/t7Dv2xDG3a5i96zDziEY/4YeSqJU4D8v6adPMBcTwiQkRuntKsNuSug7YhV5qsDTkLhCj1wsYN5MFBSqVSbF7ALYhxhPFI6gfCYSQ7T/IOuSzoQw99TwoTOnlELrahJAW57aievUQ8+TWsVkgGquvXLH/6hvqbN9j1c0K1BQx0LZgKug08eYbwDjs7pt/9B7h5g910pGgR7Rb1i3/BavWE8es/Mr+9QY4Re5jQZxcgTdn++YWkJKmtoWuQ3kKUuOOIBjQSOYOOhmgVPY4+zxz8jIv5pKb6p4uxnDOBUi/mUyCmSIq+5F4phVAGoS0YRVYgcgmrzj7iAaMMGojLjP/wGicz8+ED6f5Ampai2FWCHFPp7waM0BihyMJh247dk6eszs4xTUvMpyrjVBaZOXMKxP4uuTxnCOm7nZ8A0imv6uHGnDLBB5Z5KcOHU0q6kOq0Uedj2JpzZRv+U+InJ97GmI9d3g9d3A+euIett3Pu430fEtCdcx+3ug9EcJqmj53aMSVCiFSVJc4Lzj0Q45nZOYQswQgpQ4gRIyTi5BPIIqNMxeICS3AlME0tVDYhK1sC0aQqEfsn4v/wM4YYi0xClwTzJAVSKqQQKHki4qcwN3KisrYEoQFOACKjVaatFJEKoRRLLP7zrIqfPAlKLYEQKGsQp1QzJSTLsnwcQggUQgm01RwP94zLRD+NHOeRwTnGEPBCEIFY2mY+4qEi7Ls6rtMnTn8+1IPJslhCiqIaUCcJeHqoVjtJP1KM5BjJqBI4JOSfSdgfiPF3QWn/dKvwoIb4/r/5dMv9qcT8+5Vvj3jEI35euNn3PL28pFIamaCrO756/YaL8x3Xd9fICkiaaV4AgZCwuIlxPIJMHIYj/TTj/MQcJla7HSFGhmFkXdXMzrFZrZj9jHOOED26UWij8SERvS/2GClpuhqhJDEuZJmZ5pnkSk/rOM4kIzCmqKSGYShy68bQdob+9sBq3XC+XuH9RDqdl7fbFQsLYhE0dYU1GZ8SdWVONp2yUbBVjaw10zITfeBie05ynkobzrZbRl8SdnebHSF6YnRsdyumMSGyprMV67ZmHibInugDUZZMjhQj9+ORdtUxTCO71ZYQAnVtCcmxWreYSnNze4MUGaUyf/0vf80wL4zDPeuNousuIQlkltzcXNG2K4woZLjUreRyTkWeHk/F2A8EHZBACAtDLwix5Ih0TUO7aWnbjmmeibGc75UQNJVFG12CObVmc7nj8uKSSlfs6pr93TWNhQ/v33B+tmbV1dxc3dC2LXVT8ez5M9q2QVFz+eQJGcnbD++Zp4knZ+c477jYnPPt9VtQmcYIbN0RPCgsTbVi7G+52d/y9PIZxhjevXlNSIkkQVbmL3fAPOIRj/hR6JuvyXe3iP0t+e6OHCDVK2S7RlRbpKqLEtUHcpwgB6KbifOMGUbE4kjTTBqO5GUmjmMhiSKClFS6xWzWmOocsQSoDmBuCIdvybPHEMlC4HWN3F0iX34JX/4VnO2QaUK83xF7x3JzQ/2nP6LrFWgD6hKqimwtYr2Dp4E6BOx0z/H9a+JrQSMFVK+ge4pcPWG1eUZ685r5cMfx6zeY9+8x1qCtKde+HsQ0ExaPC5T09fWqbG6dx0gNRjJkx62YuBYTRxHw/NMl2IO182OlWAr46Eu+hlLoVAYNNB0YW0h4TojFweRw/cCkJLI5RwFVDEzLgPMT4bDHjxNxCShgVVWEmOhMppIRLYocXOiK9flTnrz8kotnnyOrjugXsl9OiSTyZPct6eY5c1LVFmusLEvvjwFxD9bXlE893d4TQzgtHUtLU6S0Vj1YnZcT90z/pXu8H2TkVVXRdd3HaULbthwPB5xz5Jw/kuzj8UhKiaZpPm6+P63seoiRjzEVEnzq3IwxFr9zKKEBpIzz4TTZAR8CWQik0kU6LhRCaRKCkAWLjwghqStBSvl0IVhIZ8oglS4EVBvICa0Uxugyvcn51DNXPNJ+ifhYvq9WsvSHitIPHkWpDGsqjbYVSEca3Eev9RI80zzjY2B3dlaSx5VEn4YStqqY5/lj714MkSU4+qnn7rTt3vc9o/OkLEp4mtEor4mpPB7yRyTeUAjzQ+a7pHSjKykxugTdpFh87krK0wNTHusYAvHk139IRf++jOXPN9N/nmz+/c34p/f/vrT8+4T7MYX2EY/4eaJaaerWkIMjK0fvrpjyLVfTPWM8ULmG4Bqq6gXXV9cIItKM/P6b/56XX/6SZ9ayGVfsPxzJAoZ+4MXTl1SqTP5jTkRSeV/0C8M8YRdDW68wRiGEZRz7IlUTrmR9uAXnfHGNVYahn1FZ0Pcz7Ubjw8Llk0tCfE9lNVdXb3FjYGefMvYTq3rFMI8gNPOysOpampVGKkFMHhkj5CPSSO7ublhXHT54JjdztjmjthUpZtq24enFBdE5WlXhfGazMRz7A03TIUTAWtiuOnJMCJlRWpZBsrHlfdnWSCNJx5JjEvFcX33g4vyS9WoDQiKRyAxn6w1aKXKA/+Hf/AfWmy0+BhY3YLU9DVctTy4uub6655e/+iX3+wP3d0emYUJKBUKwvz+UtpLZsaiItRJJxkeIWRFlJgjJFy9e8vbNN5yf79huttTGIJXg/nigW6/ZH/YoKVk1Hck5bu9vqWzDxcU563XFL37xt3gyf/zjDePs0NaSl5H1qmOeJs53W8a+p92s6doGq56wrhtu7m4I0XNxds5+vOYoHZu2QYmGcRoJIjBMPdvNiqqpOBwmtG5o6oZ+6nF+/5c+bB7xiEf8AORXfw+3t8QPV/jjgGrXyIunZGvAJHIE7heEc4h5hGlEzBPJO47LQvKhZFNIidAaWddUZ2fIrkW1HbZqAYlbFvLQI1JAhB45aB7SjzyC0K6pXryCl18QXj5HnT1BhIRQLWZy9H/3/4G3X1E3FViFUIF8fgFtS64sYrND+Ij+7b+izpnp3bdYNEp1UG/gbI3oVqjdU9rjHfXhBne4JrixtAllgXEZmTKi22G6LVKdFmhuwR/vmA53RD+zj47b7LhPM0vyyPxj1+SFv4QciEKxeM/kFmapqW1Hdf4CsbmEpgYlCvfqRziM+GXBPrlA7J6hpIb5QHz/Nf3NPX2aGUlEpailgKooeWsclrJ5TlIRpWb3/Auevvo1589eIaXBDwfCcM/iFyaRAfVdlVgqnvCUTnFUJzm64BTQ/ODZ/h7plkIUXpjSSY5elNbOObwr4aEPnPOnwv8qPd4Pf97f338MSAOoqgp/SitPpzowKeXHILaHHm0oXu9Pt98Iga0sMZUHLuXMcppUpAyIjB/8qeJLfNxal1CxIj03tqI61WKN08yyOETOyFUJoFFKfpRfyz/zEZffYZxmIFMZhVYK1IkMCjBCorVk8ZHsIy54koIsIeXi7TMCaqWYpGSJiZgzk1u4O9yzvlvTbdYYbXHB45YZa80pOG7BuQUhJM47pnnPfX/gvt9z6MeyVYmnOZBUmMpiYiB6yDFC+qcy8wdIKT7hw2WSZIyhPnnM3TIRnEfo8njkFEsyYkoEX27P8vSi/953+bSjW4j/PLL8/Q33p+T74fOPG+9HPOLnibdvrxBJsF43WKHRVmE05AVM7DhvnrKMCYzBXK44u9wwuw+IasCsFvQuI9wF13qNGzPr1RY3zmzP2yIHkzAsUwnFPKVA+hiYlhHvQvF0p4BQFi3LW9uhD4ToISdW3Ya6uaBptizekeWCsRltNFobrq6uePnsc1589jkiGzbdjnkMvH13Qw6eJ+crUnJsz1YkEj5KOlMk6vfHW9TFOQrJ1fUtQkoqU50ySQLdaof3C9ZocoQQIj44qsqSc+J43LPbnCGEwxiLRFB3dbFfnbpX94eRyc2IrEg+0NiGdbWCLLDW0gGH4z11JUkCXHToqgM0f/jjn/js+QuebC6RaMgw9DMX2x3bds161fL2/XtsW6PDzNX+iJQ1kws0UnDx9BwhJONwJLjE7d2B9fk5zarli88/449/+D2XFzuqqiOnEjZaHgPFssxUVUVbN/h5oW4bxuOEWlU8f/GMdpNwTHy43fPm7gbTrFArjZKGul2jFCgrSDly7HsOhyNn6w1tW9NPhpwVnV0hD57tui6rECWY4oLqNE9fPWejKoxqOfQLTdPhU0YrS86PqeaPeMTPEfnf/3vm91eIcaayNSJkUIIw34GfYRxIk0dGQfSJAGAsom1Qmy3NxQpVN8VT3VTQ1KTKYs0alS34hbwMyHSPUmPxc88jTBFCqfGiqrGXT1EvXpKfPSef76BdI5wm7zL8YqB2e8L/+O+J3/yOXGu0BayEypSe76ZDnEmQNU3MGLfg33yL1C1UFaLLxN0laXeGXLbI5Qn1cAC3nLhQwoS5bG9VSWQXFO96nhfM8Qr/1X+kf/cNexe5n2cG50jOIzwkqUoYGXyUXJccq1zsujEwyJFRWibdYNctzdOXsD1HrFZkrUjHAXkYiTf3SKVpXj0nnb8qfvbhlszI7d033AnHQSW8kVgvkNKQJejoUYhy7lYG6o4vfv0vePLyS7rNJXFxCDmWppKUMEqVLK2USEl+5HZFgn4KtD5ZaHNOZFFCstPJ6/0gL3+whqdTPpVbFqZpLkGpISBlUV//lPjJibdzrlTDWEuMkWmaviPVIXzs335IDN9ut2y3Ww6HY/E258x4CmUrqeTFyxZSRJ7Cz2KMKKmIISBOUrhICfcqPd2ciP13HvOcAzE5EBmlFdOw4BH0ckZLwXpjkUKXLDIy3pXaM6lPT1zOhBjK56Mkl4XwyRdeyGsMJ7mCKJtvYQwiQ/ABrQ1KGWJYWKQnBQlJkIAxzUwsDH7kvG2QSZKIpBxwvlxIKi1JMeLcRD/O3B1GDv1UvJQxUazjGaPKYMAbRYqC7MugAiE/DiGKD4aTr1sgSYic0VJgVEafiu2NMUiRmVKpa0MUqYeUApEjMXlEtoAi5yJL/3Qr/UC6ywHzaXVYeYyLf+NB2n5KWBfFr/gga/8okedEyj+RoD/iEY/4eaHPia/uvuGZ2bLce9ySkFkRFk3bbNmefY5oA4tf8CojcuZ4cCzRU60dda3p3zn8QfLq8xfs7w+cb8/Y7nbM08SwzKxsU1K9TzadYZ4IVURrjVaK+Tjio8dWlv440o8zdWNQCmZ3ZNWtcGGPNjXj7AgxE2IGKVhttpxdXGLrhsPdRGUKeVyvNxyPdxzcEWPh/U1PZWu61ZplmVFCYoRmCQJPYr3dcnt/h1gmulVLU1eF/Mcin9OyorE1WlUoLVjcQghzsUUpQVVpcpIopUlJEsZA8h7x8L6cJAmDloJKaZTReAKSTLOxeGaGMCGUYFwmbL1FGMmqbblod8isiVnQGofIEiUUfZhxMoFVoDUhgVEK3dS47Lk93CKAzraYyrB9fo7LmXa1YrPd8jf/4m9RsqjBKqWwWuKXiU3XcbvfMzuPjIlXz55Dirx89QUqSzbbhtz1vLl/x95Fnry4oKp3+Glgs25JZiGFhWa95XgcGIcBISTr7RajYbVpaU2pKq1UTWfXrGyDixlhJV/81ZeEaU8zCYKDZZkxtiKFQGtqtrv1X/qwecQjHvED8H//dwiXsNLAMMPQkz58i89LudaXGtms0dsLzOUTzHqNWK/J3Yqw2qCrGqRBNE3pxLYGlCQukjwu6GVGjHv0h2/Ir/9E+vCOfH2D8hEkBK2JdU212SI3G/LqROAVZeO+acjyGdb9FnO34P7xH5F/+DvQkKxGmBqx2oFU0DYkJQnpc1QawP07ltdfURsNtSTXK+T5ltRsyalDbs4QMaFzKtfo4RQAJjRIVaTmIZDnkfQ+MR1WXN3BzXGmdzNpDvglEZIgq1PFslBIocqJMwNJsnjL1M/ksKBsJO4M5tVn8Nkz8pNLQrtC+Rl5+AC370jDQPX8FeJXvyJfviCrDu5uyHFhfvePTMN7qspSxUgyMzI5ZJanj4esrERzfs7zL3/J6vwSLS1iGODuSLy7wbgRVRliU5ErSzaaGARLVqQs0FoQskerSCTgYyrh2THiQqlwjjGflMKpKOVOqul58XjnS76YyDS1oWv+C994P2wp67rGe/8xHA1O/dzeF6l2jNR1/TGELQPKWJqmYVkWknes1isEMFxfEUgl6CCVnrYs9Slx+zvJstKKSp18aUIwTQshRIwRLC7QtJaqMgQfyLFUf4UY8THhfUSfAtSkKMoKHwIhFdJfZN/Fa+1TJHkIWSKJ5ed5qFoRApEFbVsj6prDsfjymro9DQDAO0sYE6HwYYSShBwYl5FN3NGYGqUlzi1oLfG+EPrDcU/fF4n5/jgwjgsxPsjrT8KY04WbUYqoFFEI0oOPW5bu2wePtxKlfUAhkAKsVmWbryVlwZzK17KaZSmhdfEk2SD4EhCUP9l0n5KHP8V3snDxycd3CegpnerATz/Xpz70h9fMp15v8b3PP+IRj/j5YK/eUInE/u0bpj4TvcQYS041TX3G01XFEiKHoaef7zg7X9E1msv6FfVa8PrNa863T7h89QwhMtFHqrqmaprS96wiwihC9FirsbYuTQ8kkihbYV2VTfv+sCdFibKCdlUTo0MKGKYRrWvGxTEtA/My0q1WhBBZnKcfZ+YJ5tFhTAUxo3REVZk5TWjZoFUFUjIMPSVUM3B5cQHA3XBgdgtZgNSSdt0gM7hlIWRYdyuUNHTtBhc9UmbmZSmEWkqSyIzLREolrFRpiTSpeOOEwI/lPLherQnBkyn1YtKUXBXtBLOHxtbMy0JOEp0UVpf8kCAiVikqodGi4eLsKTe3t/z+m7fs54FEYlWv+cWLFXeHe5Yl0HZrbm/vqLVifXZGXZXA0+fPLlFG8W//3f+LX7/6jNWq5vnL54iQWSqNYoOUZShrqhohRZGJG83tsWe1rllyz7LcIJtEHCfW6gk6SJpVi2k8y3wofnqt2DRrrPQM44ibBnRl6ZoOnwNRKc66c9Z1ixHgwwzB8f7bb3m62SBRNLXl/PyMaXGY2uDCwocPb/6yB80jHvGIH4SeihQYEclIQpQEkZG1RV+co84vkRdPYHUGmzNy2yFO9WG63hSZtJFkCfgALiD7GdPfw/GedPMB9/Yblm//hLq5xiwTNgNCgRRkoZBSI1UFpkLUdaktzhlEKp3dqy08eYn4tUdNE8Pr39H8/iusXpNkjf8cZLtGo5BaIrZniJdfUh16pn/3b5lff0213iK7HViL2qzIxoDUJzVqQooMac3Ha+icgUR2Iylkxuy5DTNXYeRuGZm9J8RUEsuR6PzQhV10rUKUOuSYITqPihERM0Faui9+jf3yt4hnL2G9RYUAt1fw4TXuw2uEMahXX5KffIZ8cokQFjLIs3NyU5ftthAYBFFByLGkoSVKEGcGYuDVF3/FqjtH+Ui+e4d485b47R/Ih7dURpG7HeFCkZs1qulwIRLdgk8e7yOZBDJBjsiQwAWYPX4JLD4RYjpxy6KQ9sETfCDEYtvVWmGtpmkMbWN/2tfxT/rVgXEci5/7eCxkVKmPHd45JZSUtG2LUophGD4SqOA94zQyTT3TOBZJuTzF32uJVQZrK1KIpJRom4baFIn6tCw01lDXNUobcsosSyD6iAQQkbquyLF4z0uojOBwOJRgtBAYx5EYA7XVGK2xWhX5QRIk70ipyBnKxldRuGdEK05l7uLj72uMKVVoIaCFJCuF0acagQyLtRymCRcc0UuiD+zvD1S6QXPN2XYHBFKKJ5m5Y3GO4+HIsT9yd7dnGEe8Dx/L4x/4baaEDBhTKtdCiDjnT5z4FKAmBEoWu7aUoKVESUFtNU1lUEp9fD6lLPVvpYP9obK7PGb6oW/t4/f+ce/2A2n+NO3849/5ztP96cent/1Q2NojHvGInxeC6Hlx+YxKKZbZs7+fuL51uDFTmUv+h//n/4Nffv5b1rsdoR/YH2/ZtFu++eY1m/MV/dEz5ff4ZebJ2RPOzrfcH48MbkTXMEw9aVwI3oOqkVIVr/c0YIxGCWjqhpvbG7p6RU6Js/OOw/FAW3fkLEkohGkwFcxi4diP1KLm0B8xumUYJpqqkNR+PKIEbM9XRDkQcsM0OSpbURvwwZFjYLVakYnUTY2Ye7rVCqFgu90gpcQoxTxNqAyL83gSSmmQgmEaGMeBtmsAybEfyQhW7YqYE94tZJHIIiAVVLVCOom1mpg8wzQQQ8SHwMXlGY1q6XSHd4FaZKRWhBCxsiKQ6MOASD2drnm6fc6y9Mx+wfkR74/Mk0PLjpwiSqcysDY1T7ZPETnilsxvfvkLpJbsxwP311c83W5YWUlcet69/iPnuyesVx1xcTR1xebXv+H+uC/Sc2vomo7tdsf9/R1W1eTUlSDRFOjONrS5pp8/MDvHqmoxydDfHlk3aza7HXG3ITiPkRalNVksrKoV+2FGyoSUHklkYy3LfuDYR6rzSzyeyloO44DR9hQE+5NfFj3iEY/4nwEhKlReyESSAmcr5OVTzPPPkM+fwW4Dqx2iWZG7denqtgahDFK0ZJ1ZpCP4ATv0mOsDXN0h7r9muXrNsB8QQdLYFXqnSIc7/DSjlUEQ0TlDyLAEcAmSQsRSq0sWoAyyWZMvirVGSodhZvnTDSb+A4JMsAnx/DN0tQMsptrA2sOzl9Rf3LL/wx/Q796gVx2sLaIRZL0qW7mS2EmSEqF0+Z4pI3IA72GZ8P2e/f6OD/s77vqBOSVczrgccSKd2EnhKVEJsirXzykmspLUpihaV5eXvPjf/O/Y/fV/g7j8DOwaxhGxv4KrN4zffIU/Hlk9ewWXT8hnl8hVByGCDSx+4tj3BF9yr2KIyJQwQpKVIORIFuVX0MrwdPuMes6oD+/Jb1/j/vh7xm+/IjOjV+fU9pJu9Qy3uSBVNZqIdHvkfGByiaglYZFkX0KwhQ+I2eEnT+8LTyTnj3baHATFVXRaKBpL2xiqSp1aqX46/ORnmLOzs49b63EcWa/XH4lTONWEAXjv0Vp/1O2nVMrpUxJIVbr3hNQIYL2tiSGitCapiFaK2lq0LJtZqQR121E3DTHEEjfve+q6oqo2ZBFxfiH4QAyRGDxVVbbrwc0IITDGYIyhquxpf1s2s8GHj5H2D0RxWRZyzlhjkCiUVqVWTIoiMReCEHzZDhOLDz1GZAXWGJq2ppoc81wk59455nnmeDyybtf0fU/dlu261JrkHD4E+nHk7n7PcRiYnSt++NPCWZx+6kwhtVprjIk4p5AyngYGp8eLk7wbgRKFeGstT5UxBiXlyUufSoeeyGglCeEUyU/xV+aUT4mB+WOC+ved3N/vC//09u9I9J8Hqmmt0Vp//D2+H7qmtf6z4cAjHvGInweMSNx+mKn1hrYxkBfCGPls+ytWqkNVlk1t6boK0oblVC3S1IavX79jStecnzUMcaBxmbpZE8SAqlqMVdSiLrYYVSRzORcbS35olpCCQ38soTviQbmTqeu6XB+YhtZapNXcHu+5G3ucTCRVLmym2bFeJ2bfo6RgWTyV0tgF2q5hGhMueRrbgHhQSgmWMJNUxjaW59UzjscDMboyQFTqNAANKARde7JUzUcO/Z66aaiaskGeZ4cPCX36WaQugW5ScuoaldiqYr1qSgWaVYQ+MswzTdsRAgQXWTUdQhiarqFrOqZl4ngY+Pqbb9merRAxUD99zhR6UpYc/R1TPFK1mb/621/w1R+/pc0VZmqpx5awGNaNLRYkbfg3/+9/Q7Nu+eWvvuDyfMvOWsJw5PLinCgzKQcO/T2NMshs2V2ckVJJzY3BU1eG5OF4e8SoC7rVBbuzS552gcFFnFzY7c7JAbQ24AM6Fgm+EKccldljWktjK4S0xJTZvjxj8RMxTbTrimMYOL7+gFEV6ok6nacEMWbm48DxOPDLL7/8Cx4xj3jEI34MQiiyUESRyV1L/dkXqFe/hievyJdn5G2HbDqSqYtvWAAn6yTzAMOC9Ed0f4e6uyW+eUd4+w4/XIFRdLvn2PYMZocY9mQr8dfXpAk0CXIiz3NJVr+7gftbaGty1YKw5ARZaLLtCGeXSCJNcvjw9yzvPlD9DiqZSR7yU4GoN2RjiO0aeXmJ/Ow55vYd05s/sd6u4fKM3NRQdUSKDzuLkhUl82nTnSPSO/LU44/3DHfXHI/3eAG668jzES8UQQqiyggSSpRMKmlU8WsjiWR0ZTlfrdjtnvAv/vZf8/Lz36I2l4iYyYdrON7B66/xH94y3d7QnD9BPbmAs3Py+owsPSL0HA9v+fqbfyyW4axAJJTISCFJQpSFd06ILFAIVk1NdzjQvH8DV475q9+Rrq6xLpDbhvbp5+jPX8HTF+jdOcIY0nBPHm/AT4hxImYIOTMJQZAgtEBaUEkic8QvHpEl+aHi6VRVpqxGVorKKqpKozVFUfAT4icn3kqpP+tEe0gxl7JUY8VTaNrD9nK9XpNSoq5rrLBIWeqpEoJ+mPAh0g8HKqOprWXVNWitMFajhSCEBWs1KQXG/oiURf7slxkli2w8C1BKIIUhSYVHIFoIwTMGR0zxo598nkt1GEoCGaMt8uRX9sEXOeLiy1ZZCXKSpCTQSuHcwpIiWiu0McSc8YsjeE+QqvhFYsYoxbpr8EylYN57SKIcxLl4DX1KeF8i7/fHnn7oud0fuD/2LKcNNshTkt+fE14pJSiBUhprS11OziWoTvDg0c4IyWn7XQYGWkmM1h/V4v4UbleSAQtBTzmDKF9DIkghovTpZxB/3t/9Y6T74baHFPTv14U9bLM/7ez+NNn8gaA/4hGP+HlB9Fv+7vfv+c2/TBz9QoqCuqmoKs26bWjsjpQnAgIvEkd/pNFw8arCtw12fUalQbmK9aZGCsVGtqQ8sz84nFtOLQ3lPVLIVCongyf7TNe0LEv5u6+LncgvifVmjTWWeVqQKhIi9FNPPy1MS+Tb1zfoJJmmEWkEOTqaqmLTrTn0CSkU59tztHCcbatT4KeCBErqU75Ioq4lGk10NUoqnF+4+XDDMs10TUvXdYBAW/B+IavIcdgTkqRpWvrJEWOiqU0559wdUBp0pdC2QghBVdWoLMoFmEhsNxuadk0/Thz6kZQiN/d3tE3NTm1pqoa6qtidrbn+4weenJ1zdv6ELDRT8iit8GpG1BOXmzX1rmL39Jz7mwWtDSGM2Ebz5PkFN9fv+frbb6nrGl0J7g+3COfYPnnGb778JcfhiLCSoCJTnMgobKVREqrGIJNAUs41+/7Ii89ekhJEFzBKgI+sGktIhlVVMcg7slqobIVyitEvJJfwodSJbuwGqUvYaWsNoxtQsqQRH4ae3BjEuqXtdlRNg3eBGIvSzhpLW6+4+nD7lz5sHvGIR/wAwuxIuqSKN7/6NeLVL+HZF3DxkrRdleP71N9NSsjgSW6EZSL3R8RxwBwPxA/vWW6ucMM9VW2pX/0StXuOqNbgE0w96IjwNwgZUILi41aGLCTz/hrxze9oOkmyCfn0BdgVQjYQBVJYZL2BM4FIGSEU7t//e3h7Rf0fBCposo/w/AV5dUa2FXF7Tr7YUT09Y/jwnvDhHfL5Z8jtJawzQivI5etBQiZfvJkhkKaBMBwJw4E4DyglsU1Hu95yvL8lCkWUEmHVyf6qEFqTjSIrBRG00nRtw6svfsuzF7/is5e/xKoGpiOMC+zfEd6/hjfvCf1AbSvqFxWiqcl1hdAG3Mhw85Z//Lt/w1e//zuC90hp0BYqkYlLYAmJJHKpWc4JYqSTgvPjFd07wzzcM93dQZDo7TPaX/wG9csvCS+fIZ+eI+sO0Q/I/oi8u0fub5CzZ0GyaE3Smmg0sSkDhkomVkJR64oYEsFHYo4gCw9VQqEVVJXBGlVanX7igM2fnHjP8wwU8ldV1UnyHMk5s+o6hBAMw3AihOEjgfLeF6KZHEJpMhIwXN3clyn9quHZ5TltUyNEIWaZhLGq/H8uU+wUPMviiN5T1xqjFJ5AV7ekmPAuYI1hyiOrVUsKAT9NTNNUtid1hRSF0kpV/B2lizwCskzfKQl7wSdS9FSpBIOJU3R9IavptH1PWGMwVpfu61R82NYIKg05Qo4J74ok/ObuDhccISd88LjFMQwDh+OB/tgzu4VSOXeSoXyyn//4lxP5fdgOG2NO3fIPtWHF66FPIXBaK7SUCFEItpISkUsXOPm07faFXIsHyboovj3vPUn5IvH/Xs3XA7H+tGbsB+vDfoBUf19y/jC8+X7K+SMe8YifD5a7Bqss43jE1JrDjeSyfUJ/mBkOb1AWrg7v2E8Du4unnG0si5gxu4bLLyaymGC55HAnaTRM457Vas04zITkkBJmNyK1IiZHmEstpFIGowzHaUZLjakMLiXySUZ8OM5sNhahSs3qMk8QPQZN1iv8MnF5sSXdBW7ur2kbi60E0zLg58yq2RFTCZfMeNarHfOy8PTJM4SEY79nmeaTYsiU7B0pUbqmUhXrZs08TRht0UpyGG7xyZXgTGtQUdJPIx9u7rk4v6Rdr+n3B2qrUUowDCOrdYfWpliWUiLHQE4BJRTu1J19fXNNzIFnzy9IJjDEA+P7A88vXlA1lufPX3Bx9oRKV/jgiAlidIQ4se02fP32LX/69pYP1wdeffZbnm0vqaqezWrN6EbeX7+nWVkqa9GVxFSSrl2z2a5O7+3FO4cKKA11ZVitW7RRKC0ZjwtWG4JzrFpDVbXoqsLHGSEjf//Vt8RFsF2v6f0V98vr0jZiX5CWim13QV1rxrHHaE1IZQgulT6doxM5l0HJervlKoxMcWF0I8ejJmdJpsgskdC2Fc+ePf1LHjKPeMQjfgQ+e2LVUb36JeKXfwPPX8LTl+TVFqEFgoTwDhEiuAWO98jxQDrekY57lqs78n5ALQHT1VSvvkSeb2H7nCBqpA9IMcOSSeOReH+PjKEEPW92iCdPkarChMD9uzco6bGybJ05fwrdBQKDiJQAtWZNOst4I9AyoeLfE7+9QqaIyD3kAfn0S+T6CUlYcr1Cr9YYJUj3N+j9PeK4J6+3SH3aZiUHyZWFWIrkWJLX89yT3YiRibapMcYSQmZxZbCMkGhNUeRmQ5aySNbFafEWIhe7Nc+6MzZZY6cJFXuYetLdO8LVa9Jhj1oSldBkZYryV5x81c4RD3ve/u7v+ePf/1vm/haZBVpXNFZhomBGMsUJoQVaKmTwmAR1gma4xr/3DCGSdEP95DPaz3+D/PyX8Nlz5NkaYQXxeIO+uSZ/8yf8t39iub/BqRrajnq7wVYWYxJGJlSasEhaebL0e/ARfCgV0jEmjCzn1Icmq5wCp+Ktnww/OfF+6EQzpniuH+TCh8OhEO1TfdgDKZ+m6USiBDFkfEhUjSGmYh04HGeOg2PVNGitcYun69ryInMjxmhSTKQMWhc5tDEaqE9kr/iuhQRi8WlrbUAUMti2NdMpfT14TzSKpCRZilKsngOJTzvFv+sgjz4SfemGq2uLkqnUXKeyYSaDVSfZdM6ltiQLcohoKbBGMTuHXxyD7Mv9ZCaEhWa9ISWYFseH6xv6vi+bcSgHI+nPNsoPdDafpN/lYlSeZNvm40ZG5HRKCj/5t5XCaoWS/7/23qtJsmu71vuW2TZ9+fZAA8eSFC/l7oN+vUJvEt0hD3nggbbl0uf2y+lhZzWah9RVxFV0EIrYX0ehDcpkpanMseaYYxzj+b1HKIVSorecH90JUsr+hw0/d+c55+m8gyBJ835PnI8ux8d//vMJ+J9PsYUQH2zmD3vywIe/P6wk/JxSP3R5Dwz80nj68guu5Amdq3j75g5X5pw8fsZus6Rud4zSiKsnVyy//o5Xb+5YjiJGecmbZc2XvxkzSef88M/35PqKUlgEEc5I8nTCvthS1AVBOYK1YATCCYz1jMcRu90BgEh5hOsISJI45XAoKMuGum6ZTnOUhkkWk6YRehtxqCqW+xuMj5EqkOUjtEwIIUbrHJUG6rZmvV5ytpjhXYcxFVopTGeZTCbk5zm3d2+xrSEdZ8ggEA6moxlJkmKsoRB7yqIkTWOatkPGArSkrGukiDkUFfk4ZzKfUDUlaRajAjjvEAiaqkHmCuc8MkDT9A0iZdXXajpraduW0/NT5vM5Saq4v3sHBMpohJAKR2BTlkxSCMaglSSWmsXolGpnCGXMOM9xpxFJrmnqkrPpjPu7G7JJznyyQAJxnBBnMUFCnEWcXpzw41d/4uRyQTzJEESc5hm5ztBxROsNZVORjVIWsxkRMT74fiVL1DTUvLt9T5d44igmnfSH24tkgQwxk3iBSscE2wfZxbFGS42wYLqORPen2HGs8TbQGkNnPcIFEiEYJxFdZ5hMFxgnSJOMzX7NbDpiNhv9pz5mBgYG/mOstKTn50TPPiecP4PLxzCb4BUoa6BpCFXT93cfdrBd4rZL2vU9XVkhopTs5JRofoqYzmE6J+gYEUA3bT8Z315jXv+Eef+WuG0QJuC1Rlw+Jrz8LaRTorZm+uNX1D99hzYgjYcvA0FHiGTWi1oBCIVM5yRKwtOAagON7TC3b8n+ZYW0B2TtEecKmcTgIrAC5UAVe7h5hY8h2BaRjhGdg64Eb3BRggu99dx4izENUvTTee8sVdWwWm2oqgZnPd451LHr24t+ZTQEj3eWxAlSFFFnSfc75ihUvcHtd5jtBlXXyM4ShUAQIKTCG4era0TXIJsSxA633XLzw3d0u3ukbUh0jEdjdIc3Fhl7lIt6zWIDOigyJGMdgYPOS+TijNHFc7KrF4jTC8xijkwzlNFQbZD3r3Fvf+Lwp6+ob+8RUiEeP2M6W5CcLGglqKYg1BWqrfFK0+Qa6wW1gbIL2KBJvP7w3Bm8p++c/Nmh+yn59MI7eKIowh57vAHSJEGEQJb2YWhJmqCUJokidBJzOByI0oTlpmG7K5jONXGaszsUbHclcZwRJRmL03PGWb+D3bUtsda9fd17Yp0cbdCQpAlpluF96Cu+gsC0ll6ES7wzZFmGVhEuyfBeYP2Dwb1fxLe2b71rncE/VIYRsK5/gYMQR1GtkFLQdQYR+n2/mAilJA5/PJUPdKY5nrBECC3IVISXgtaE3mbuPFVVoaO+K7tqO3wIbLcbyqLAPOx085AAfuwc75etf/aai35/uxffDxNkgdYK5+htK8dqL6n6HUilJEr0gRHeO4LvXQgPwhv6aXMQfYK6ChIZjp3t3mNCjY4UIkk+WNMfCCEcp/z9BRNCIHk4IOh/yaPofnh7OLQJIRDHcR+OcKwf+3MRPzAw8MtBZoLV9RbbeU5Gn3P62QXrzZJsKsn8mCxVTPKc7vFn/PNX73BxRDRacHpxxurmQO2BUjM6T9jtd+RZzoikDwdLRog4omzL3qHkAip4atNiXaBpHc5bkjgiQiGl4lBVVFVLEme0ztKYDiENcaxoDegoZjIKxMk5bVfjfGA6PmG/rRlnI+rKUey36ABPHz/FeUekJd4bYq1oQx+CGcuM+WRBHAv2RUWejRhlEu8hTzPWmxalIxIgjhShBmP6JgslY5I4pSzXxElfi1UUB/I4YpLnTMZjvPPHLmxP03R0TUuiI5RQCGEpypKq6YjTlPFogmk80jsW4zlFue+fm6IEKwPfvfqB0+kpT84uabs+cPTidE65szy+jLkttoxjQberWWQ57WGP9gYtAk+uHlEeKoyzbDc7lIJECm7WdxxMQWJibGnRScxYK7IswQbLrtyRzjOUDBy6A4mOCSKQTjQ2NOjUE1eKJ+e/QoeA6QqCOcU0jjQboVxEEqe0vkRJQXB9fVsUp0xGfRCc9x4TLJU1dM5T1B2RTEhURKQ0k8mM4Prb3BN6i34aYU37n/2wGRgY+A/Q05To8SO4fI44e4rPpngBzlSI8oBcrQnrNWK3pVstabZrnO1I84z548/gZEE4WWCnM0QyRvqIUFtUuYT1NeH9W+pXP2K3KyLjUK7PMHKRgmyEX5yjLp4ibUeSakRXY79/i3ZgY4lTknQBIplCFBOOYWgqGsPsCj7zRL7D2wrz/j3edWQVyBJCnCFsAbsK2bQIZwg3rwi2xa83IGNcWffWb+Eo0hEFklYKTKRIxxlJqunaivVuz3q57p1hBpwJeBf6UE6O4lkoBP36ZhrFTKQktw5xd0c4FHShQ3QNsfUI40BovI5xQqCVJojQT8DXa5is8SOP2axoliuaQ4V0Bm/7FdY+HAqQgjTNaIzF+xYpA7HUpOkYcfaI7NlLoiefIy6ewGgK4wyVaVzdIDc72L4jvP2W+tX3NHf3ROmI/OoxyfNfo89PccojD1vi/Y7k/p7It5gkRsYZLoqJEk0Ua7oQsCFgrEO0fcVzZx3WWUJw+Icq6E91P/6knx1w7ihKk4TD4cA4H6GlOopsRdlU7A8VZdkgpGK6mFJ2LdXuwHdv1+z2BdHdDq0j2ralLBuiOKLuLPebHYIp0zyG4LBBE0cZ1gfiNKZpGqQWKK1pmoau6/rpdpDIoJHKk2Saru2wBLyFxhlCnJOMBb4p+0m2UAgVHTvg+q7uhwmzlBIZR3jvEDKgJceC9/6GCw4wEAnV/4Bw/Q6i9x5nLanWqFgjfCCVkkmWYGtDa1t86/Fb0/eful7YNm1L17b9xPd4HQch8PIYbPZnFm4RxDE87eHyiqMDoLe4e+cJshffH0S3FETyGHDn+wmSUhIfxDHNvS/bFokEaxE+ECGJpMIHg3WGtqsJWhFHx1j+B/F9rC4LAj4soz+I5hD6YLejKyCKog+/P0y8o0gTx/1BgD3u9Q3T7oGBXyamNcigybOE6+sltfOUzYqr8QIlJJu2oHYHZidz/uq3v6cTltvdd1SJwu3HOJ8SxQnxZIS1DWhLOnFYL5ifPmW1vOH98hpjA2Od904iYfEW2rJBZpJ9tWGS5NStAiIcAh1r0JbFoyl3t29xdUscL4iTKbHWUCUs1ys6K2jKO3bbkkk+QjhHrGOkh7ppqdoOUxdM8hiFpq4P9PWIkCUjlPT40DIez4iFpDgU4BzBWZTS1FWFFIJRknGzuaOy/cS8qgxaJVjrWa7WCAKTaYZMNM5DnuVkaYzDU1Z7jAlk6QjvLbHKkSoizhXSOYqiQo5GxEg617HdbMlUjjctDovzHU1z4F9+2PHo2Uv0bIYra3QUMztdsO1aJnpOnqRopdnaey7nzyjbluu3r0izCcEa8iSif3UFm6LAKolKY4y3OO9InabrDC44skmKiiXOG0xb0cUtXVdSNgKlI1KdMdE5FA4bLIlMiYgIqaQyFTKDLtQ4YZFC9xMYD046GlMzTnKqxnMwDYfQIKOEZDTGGkU2q4nyOXGc4i1Y23F2cspkmqO1p27L/8yHzMDAwP8DbraA0ytYXEA2RtpjCFp96Luj767p3rymu7sh1hHp6QXqxZeoszMYjwlpikvjPmizaZHFlrDa4FevcW9f4V9fk3QtSnm8hOACwlm8C8SuRchAmI3w+QKRSyIpEOZv2b+7xiWCPHh47OHkGXJ8RlCA6Pqe7XxKEALZOvKDodsbxM0Ntv0jcrdDZhPoHGH5ntC0WOFwqw2i8nB9IIjeKSt8S9vV3LU1ZRRhpiPMKEXlKdZ1eNOxKyrWu4K26XA20LQeZwKi7YhigdKGSCXEShGnMVJq0ihmluTMslOiKEH4GlxAdA1BSGyiEIs5MjvB2xq7WyM3K+TrtxCNaec17eY9cdchQ0RjO2yoifEoq9Ah7mvBfED6vv7LCQPpmPmLL5n81f9K9PQl4uQSpou+Z93VuGaP292j7m6x795Q//gjbVGSnF2hXnyOevoCPb0iSIuvltjb9/jvviMt99hEoMcTksTTaYNOUuIkwcUCNLRtwEtNJQJSOurO0nWW4P9/Lrwns8Vxt0BzdXWJdw7vDF7AoaywAZIk5937FZvtgUdtIOB59eaWm5sNzocPe98Pu+EhBHY7w1scGsc4u2Q6nULwNF0Loq8G+/P0aynlcXL6UAVmqJu+nss7iYw05WbPZlcQCU8UftaLgYD1Fil68fcwdRWiT/kPQaGE6m1tbY07BpH11ui+N856jzMOpXp7oPeBOECkFN71tnGtFErYPj3ROdrWUdeOznigF8P9x/bpvRwD0j7en/6YEMKHWq+H//+wG93/W9/fLQkIKdFRjI6ifuLt7Ifr3fu+A+/h+5JSEkeaICXag0aBUmh8nyDYdQjVoY63/b+5XB8Np4X8t7byXmj3IXAPgvvjJPP+e+pvg48T8AfxPTDwy+Pd7Vu6riRNpmzKDa/vXxFlCQdTcTgUpLHi4jRjMYIsm+FMRxZNUCFhNE/wJuLmboWoSvKJphMlN9s9h9Ixayy73YrWt7gAUZpTV3v2u4rnF5/jU8Gu3dIag8LRNRVKJmTTnPlZzrv3f+Qf//UbvI3Jk4QsCcwihfcdnYE0OmG7veP8asF0PsZxwFmHFjnzk0uiSFOWFVkcs1rtGI/6KfJ2WyDJ8J1lnEfg+p7srmn7DlFrmYxH2GNWSJql1Cag64xMCJqut80Hqam7lmq/47e/+RVRGqh9gRYQIRglCQGoygNl3VA0B5SG0PY/NzerDZPpDOc9nXOE1iCUIM6maJGw2e9Y7VboKPD8ixlvb7Z8f/cD8+eXvF4tuXvzBoTAO9/XpUmJDYE8y2mamjxJeHx2RlF1vVOt3qMiyeXFKVp6JpNTdCaomxplAo6MzjmsN+hOEJOQ6gwyzX15zbJc0vrAbDonbhps50CNeqca4IKnPOxpTEPuM7JxROMO6GhK2xpG8QSpFEhJazqMN33PeddhmpYgJGjIRjlpmpCR0FjLLJtzeXaB9TWb3T2xGurEBgZ+iUTnX8LsHJtCCEvkdo1aL4mul7S3t5TbFc46pldPSc4u4PwCRjPIc4QMCOuRyz2hqmC/xhUryu2SbrlErfeMjUGF3jTqJVgt0VKjfICmhqZC2BYRj+D09MFOivqHf8D9eEdUgTgYwq88Trm+R1xKRO/PRiYjxPwEnj4jWq9xmxvC3S12t0ekIxCKtmvRoynRZEo0O0HOzxDjXogKJXBNQXV/i7p9Q1vt2dd7Wl9RbwzlYUfoWhpj8ELhOotzHc4ajDGIYAheEqUaFQxax0gRcHHC9NlvOLt4wWh2jm8rxOYGcfOe0K6xQqEfv0Q8eQqjHEKLf/sT9evX+LtbkixH7FaUxT3CGEZxSsAgjxll1jk8Aa/61/yxjHAqpg0Qn19y+Zf/henv/wZxdg7jHBtJpGmRyy363Tv0uzeU716xWi6Rccr0978nf/wccXoBozHeN7jbG/yPP2G/+Rax3+KxuAaoLVHaopIUnWa4NEWMEkSsaIF9HlBaoDuJVoKgFL75tEvenz5czUKW6GMdlSPSgrppaYynajqa1jLKF2x3DTc3W1abFusc+8Ohj5z34cMe9cOesg/+mCSumUznWOsoioI4jmi7jjTLPojDJEk+9GlnWYYxHQjR2y1CoKwaOuOIVIyxhrJpuVuuSbXgZJSiE43xDkc/WcYbfHCoqBeIWkusM3Rdh/GS4H/eN34Q+9572rYDFdBRdBTkvQg2xgKCY/pBbwn3Dpw7ivWAca4/MQu9wPShT8N/qPLy8OGE4N+J7+P7/0f1XVL2ecB9qrn/qCewr2+Tx1A4a/tHz8PvQggi1YfKCQ0qCBQS4zwKifay76YVLUr0wWz90cXPX/vjtz+3lcdHwf3Qf/4grh8EfNd1OGc/HMIMDAz8Mnnz/obHV1ds9wecN4wnM4raUpSCu/uG4ASHQ8v/+NfnJNMW7S0vfvUbCJJ/+Md/xPiI6/2W5bcVeZZwdZ5zvhhhA9TGcL/ZsDusSaKYZr9mPEro2paurRmNY/YbjzEKNTphv9ui1IF49pzXb29pW4sJgvLgiE9jGlHRrN4xGS3QUc6jpydEuWaz3zJdnJAkgcO+wzSGQ1sRO8F0lPDm5gYZQl/V0kkWiwtU2jdoVG0NBG7vbhiNR3Suo21rtI7Jx2PqpsY4R3N8PluvNwQvMY1lNBoznk2puhbrHftDwWI2wdr+AFjpHBAY41hvdzTBYIMhj+YkekSajkmTEWW9o2r3GFuQ5QlRrGl8Rzwak9iKURax3Ta0dUdGRPn+HZ9PF3z2N79nUxbcv18ibSBLEnZ1iYoVzgABvvjsM3748RXL7ZJpnpNkmskoIYokxlXsyw1xqrE2ELTC+A6tAnVZIP0EGcN4Mka4hKKDOjR01ZpxNEaJmEmskD5QVRVJOmM0mtBsW+7u7hmZHBsMN3dLzmfn5PGUWGaM4hHW1CgBqYwY65zaNbSdoa4aqvUSFTWoZM7J/BwdpxgsVVmRZhm9zB8YGPjlkeKKCnb3hH2FXb2j+v414e6AlDGj8zPiy0e9gMtHEMf9a2PTEpoKtytwyw1+uyU0B6Q2JKEl0TEyylC17YPCAkRRSoiSvv63OhC2O6KHsLPFFEZjnI6xCnKhyP/2D4j3b3CmwvsGugJx9RSmZ0il8UHghEKPZ7A4gefP0G9+gLdviIoCV9Z0kynx46fET58jT65gegKzGSHPcFohCbjtBptmOLtjWy3ZdR116/vO7LYC06JVrwucDQR3/J4QSKGJpOodUVISi4CzLWdPXnL65V8xufotPtF023fE9Rbp++phMT9DvPwdvPiMME4QrkEnEbKsKd+/R736HpUltKbCliXKeyL0MRTa0nUGi0XEGi0TIqkITuFkzOjJC5LPvoTHz2A0wkmLaw6E5S3i/Tv8Dz/RvH5DZw0nz14QP39BdHGBSHJEkNhix+H+e+RP73Bfv0YUJWqk0dmYNICtK0K9wuiIOB+j5lN86DBKkKURLRoVCVIpiKWiUYEqmP/Xe+L/Fz658P7Hf/pXZtMRL55ekihJ13pa4+mcZTxZEKeBtoXtvqasPa4sjuFlvW1NyodJ7XEnQQhEEAh5TMvLxmjtCTiMs8Rpgg+eLMuAXuQZY/DeE8cxdV2DFEQ6pukMVW1xXpDOR7S+5VC1lE1HOhujkwykp7MWpcKHfm5J+FCpBb4PiIsipIyQot9bf+j2huOkHtDyWHiPQEmN8466bjGd7asPhERFCVkSY31H0bSYAOFYTxN8PznvRbYA5Ic96Qe79p9Pf/uv9rMY/1isSinhIT38WCfmA8e+8d6iL49i/2HS/XCIobXuT62cRUuFCALXGqR3qBCQPuA7gxUSLSRCSsIxeDwA6s/2sgU/H1Qo/XN6+ceT7p/T5EPf7/5RkvmQaj4w8MtD64jHj57y7bf/xNMnJ7St5PGjCTZ4TuYT7m4btutbNtuSR49PqaqKu+UtxsRk0xm+LRBpzb4qWZy94PTiKT989TW//8u/5OTynLZpaDqLbTsUsN1VZKM5290OnSiazvR27fUGgkXSUDZ3JDonmczoDhvm0wzTGYLqwzjBsRgpolwwEznjxZiqLtgu78myETrV7IoNsfZUDRgjkChi0fY1ZjbCCstiPKUtWlTc2+v2ZYFAoHzAmRYtp6RJQhscwQtC6A8st9sD8/GC8XRCkIJslLLbb5nlMdr3+9/WHDDBUZRNH8uuUqrS0hqDTQqUbbmYXRAJgQwWG2qSicT6ijQZc1v+xORkwuJRQneQVKUgkTOEqwmuomo1sgmMVER+9ZTdrqToaoquQIpAkqk+lCZYLh+dMD3N2RdbLi5OiQQo0Qdtdsah4phkNKVwHWVbo+mrKFMJXoEXAiVzaBOuLh5hveGwPbC9u2UzKpFp//PdKs3F9IrHsxnvr19DcIyyDOU1dWnxCVhhCQSSPKPZdHSNpakadocdi8UM6TuIEjAtp1cThHII7eiammyU05qa4IfD3IGBXyL+7i1SOkR3oNndUmzvECgmz78gWpwjTk8gHxHimCBAthV+s8JvN7RlifEQVER6NicRc6TpoCzB7CDxBFUSTJ/tpOMMN5sSlERsFdV+z/jtG/RshphkhItH2CSDxRV8IXsb+j85mteviP74FXHZEOoO9ywgpuconWGkwMUxYjLBzhdE5xc072+InUOMxqRf/Arx27/AXz4nzE4Q4xE+jghx3Acg1w3KeEKcc1sW3FcFu7pmvd+jJMSyz9gQwWLbBs9xBSd4EAKJRosYESSRkGAckUq4PL9iPDmBaITyLWlTYzcrwmaJBNT5HHs+wz2+IJotCNUOTMuobglV1e/SbztKYbHO4I3FtAbre/3kvMPLvgWp1yAO6xxWSKbnV6Rnl7hx1h8QbHZEN+/w715Tv39Nu1ySnpwwf/QC+fgKJqO+imm/h7t77NvXdHevcbcrRN2RXZ2gruZ9g9S6hGKPaSuE0ggNNIJ0lBDwlIeCrJKISGOlZKQ1BylQyaetJ/7kwnu1P3D56IIkzRnFEaYzXN/dsNoeWJz2tWGrZW/vRvZp1da7fpeBn8Wi9w4pA0rFgCMEyf5Q8erNOx6dTRmPImKlSLOErjN0TcdoNGK329G2LVmW4b0nSRKsC8RxRtXA7f2BpnUcaqjqmvvNAWTEaDonn+SYZo8QCuMszgaSB5s2Aus8Mgh8cAQCzlg4itQHfha5x3qzYP+N9d0ah7PhWOkVkL5DE0gjRdNJjP15wv3hGhF9jFo4TqgfhPXH4voDH4nb/6i6KwhxPAkDQR8g55zHq3BMQBQfrN4P0/veBq4RIkDQx13rXrgL4ZEEVABvPUE5vLWIo2PBH0PePn5p82CH/5By/lCJ9meXvRf//S76vxHtQ7DawMAvkoDjT3/6E7NZhPMlWo1omzXvbrYgA0+ffM5sYmnMgd2hYbvpaNoaHxp01AeXnc4mbP2e09OYonzL5eOYJ89nOK9RpFS7mnGW8+LJZ/z07lvqtkanMY0zlFVBlKRcXE6Zzac8epTz/vpHXCdoG8XdXcHlImKcZyx3W1rn0b7En8O+dNRVhTX984oNmqq1TFJJFAPBYlzAOE8Up5SmhkTRqIZif+Bmc4Otelt0rPt+2VTHjHRCluaYtmWSjaCtmY6mbIuSWCWMssBkMiZNE3QSU9UFWZr0wZzGE1zFaJxTmZqgJKgYHeecJTm7akPVFYTOsj5siGLJ1dUFjd0RZAfOM07GuKrGlR1l19IUEZ89fY4xLZttQVc16NEZkdLEOsYLxXpXECTYzmBMS2kt8/EEV7cEKdBxYHE25eLyDJxnf9iRJyOM8xjr0DLnbvuetmv4/PFnRCGiaR1KdphySxcMSo+I1Rl5EuO7Jen5lGa7wdgGoQWFKMh1zWwxIx1N2K2WxDJGu4w4jVmulszGU4xtyPMcGcdkSmG8R8UxCE+e59RVweRkzvR8zvc/vUKnKbuiJE4SxqMUEYZD3IGBXyL2+lvqwwb/ZooYZcwvniAfP8GfPYJs3IcqSQiuwx62dLfX2LtbUiAZTUnPF4TZBOIU3xjkoUGYBB9ZOnOP9wYdLMpLUBp1eobPM8RsjvnmB+q3r8nTCJVHICTRySVSp/jTM0zsUEkgURrz3Y/49juksSgH4soRTi9RaQIKglQIHRPyjDrNCFqQv/gcvvw14dlncPoUJmOCdgTTIdsSUTew2WJu79m/+on3d/fcbPbc3t8TxTHzyQitIVaCpthhO4dXksY6Gmv74ZoQ+BDQTmBM75yaZTGyajF3N9DGUG2xP/4T9t33JG2NTEcwTgi5xOcKsgyvgMtHaGPJm4b9V39kv7ymki2tN9jgcRwHpvRd2YiAswHnj+JcOMbjMY/OL8lkQtSVhOUKcX2D++En2uUdMouZ/e4vkFePYXaOiBShLeHuFvfmJ5off6C5ucG0lijPmfzuOVzOaZQjKmrsckfbNv2Kl/DEus/kEloxGk8JdQO7AlPUaC3RkeozRdLok96PP7nwDkozmS1oGkO9LymKmh9+vOVuU5Beb3G2oWksxtBbnVUvUr13/WNIqD6MCyAIrHEfup6rquWHH36k2k/44vOnLE6n7PY7rHUoJHVdkyQJUkomk8lxRxyss6xWe5brgtubPVVref1ujXEGqSR5lpHlY0bTMS4WmLamMw3GGKyHKEoIIvQ9cN72naRS0rXdQ8MWwAcb9cPk1gawx7S83lrdW+nBHa3jEuFaAgIpJLHW1M7hfOirCT76vHwkXr3vY/A/Ft8fJsXhY5P38Tb5KIStV8sc309ibJ9MLggEpdCiT36P4/jDx/Z714pYib4CxjkORUnA9/b+OMIFhTCi7/+2FiXFz/Z18SCt/9t8fEDx88686vvF5c8hcoPwHhj4ZVLWgcrXBBlzejbHe8Hd9ZJ8NGW1WvLtV1/z4sUJF6dnrDdbXAhsDzf9OkskwGkylfPkyyfoyNO1W6Qw/O3f/u+s156bt0uiKGKc5CRRznSy4G75jvl0hrfw+PEjvGkpD9dsDm8I6gxHR6QT0tEpo6wgHWdMF5p4nhBlE3b3mm+/e8XZ2YwkSlgut0hlefr5grYr2RUrIpeSRRp8INaKrg2M52OmpxlFu2G3O9AW0B4qXj55QVOXpGl+DOsJKBRNa4iThNV2TZpnnEznOCEosprDfk8RR6gkojMdZ6dzlPBU3Z7QGIRYYEyD1ineawIC5xv2+wOdaUlExnq9YToeMw0jCIo8mnJ5cY7rHG1hEVrS7O8JpoFwwJqaLM+I0pTV7sB4MkI5Q1HUxEnCfHFCKiKauma1WYKQ5KMRrWkpqpLT81PiOCESChEkPgRknqCiiMY51ssdzz97Rts52qbjydUlLnRIJehMxXJ5zeu3b7m8vKKzls/OHuGdoMWgEkUW53RtwevX9+ACxjiqxtF2JZeznNPLR/jWYjvL4VAwGk2wnUOgUHHMrtqwXN1R7A5E+wO3RUGa50RO0rqWm/e3jPOUi6HHe2DgF0nXlESzc7InT1FPniFPFzCfEXQKzkJVYLZ31NsVri6JhGZ0dkU0m0OeQ6xBgDcGaVo4rGhv31Mu73FdhRKOBEuwAmkMepTD6Snq/JJRUdN+9y3mm4ZAvwsuETA/R0QRTM8JzyO0i5Eqovvua+TXXxN1ntD0dm9xeYGQMXiP8uCFwwVDtLiAiytYnCBmE4QSiGJP8AXqUEBRwmqN2azZ3Vzz5tuvuL6/5v3dPc570jgieAEedmVBvS8AiZWBfd3QdIZIBMZxhCCgWwsBXADpCzY//sRZ6QnZDX63xizfo12LkDGWGO0lyjpU1yGtIShFmM4JVx4lJKkUXP/Jcdi8psP1ottJvJdI2U+PRXB99qYQeNVnZi3ymJlS6M0Wdndw+47yzRvsvmB0eYV+8TlcXcFsDtYQVvfw0/eYVz9SvntLV5ZEoxGLF49IHl8ipzkBT7zfUS1vOSzvCd5hTf8WTelDNWWMlzHTswVq0lDud9TFgfZQkstALD7t4esnF95t21EUFaP5DC8DNzfvuL7e0HqNtS3Q4Y7dq84bVKQQwuPxRDI+dmxD8A/C8kFoCry3qH6GitKaOIpxQeJ9yygb9XryWEHVNC37/R7nAkqlrFZ73r5fstmWGC8IUoJUGOMQtNzc3oGpmGTHyS7QG9oFD9vYDtEHGHiBB3ScEKzDWffveqt9CAihPgTEQb8z7XxvVRdSErxHyj4MxgnZR/2H8CHooc9S+3i6LY6i+qE+LHyo5ULSX0pxFN5/5p57MKv3l+2ovAk4azHeYYzAaE2iJUkcf7CXA8cQNIWSIJG40AezBUIvyKMYrQNVB521eNfviQulQMljwNt/ZOXoL8PHBwUfdtE/7INLhOhD4T4+ZBgYGPjl8fbtDikDy7Wi7gIvv3zOF19e0FaBWGS4riRCEawGZSmLJZ0pEQHSeIa3MYdtSywK5smU3drgTUk2SghIJtMpWsccDg3FrkX7FN9qsmzC9vqOw9KRBMn8YobJWu7v7kmzCXevv+F89pIknfD6+hbjIl6+POVQtvzxj18TiwVSJBx2NUmckGQRd6trRuOE4CzeOc5OnqK8oCor8smCy8sLCn9LUW7pjMV2CVUZuF0tEQFOhWQ8G2GMw3hHHCmatiFWmlhqoiSh7Fq22x1NXbP2Fp0nJFlCVZcoHWiaFaK2xMRIGbAyECVjorhmu7plmk+4ed9SNjtOFgsWl6c8evaYPFHcvHmDDhECSfARTeV4/Oglb95/z7a6xQP3yx3zhWc+W1B3d7RVxSI7ZXW75vLkEVeLM/Zqj7eQj0aMspSTOez2216gn0VgJZmeMJ8ujsFxHX/3pz9wNj+HxpNPNNPLBSLWJHHKdnNLhGaRJFzNUpCG/X5FFaU8Pb3CqoZdt6ds9rjScnp6wqEouV5dc7vZEo9TotMF9eGANp5MaFSQbHZrglPIKGK1WXFf3NF2HZOTM5brFXkQaKGYJBmpEJyOx+jj88vAwMAvj9lvfot89mvs819hzs6IkwjhPKoo8csbuvs32HJHFmvUfI6cnRPSGSZKCdqjmhZVFMjVPebmDfXdG1ToGM2vUOMrRLOle/cWuylwZcmo6SDNCKMp2Ze/Il4vsctb6m+/JkqSXqApgZicEocRZDH+KUjpiUNN+/W3hG+/QTuHjCU2FujpDNE0iMMBWe7JcWgpwLR05R65vEXbNaEq8eaA3+4I2z3t8o716pbXd2/55s0r3ltY7womkwl1bYh0RFNWVIcNygeEkBS2Y1M3tKYjlr0sEM4TB0nwCmE8prSMLZyud8zTnDz0q6AoTRc0LsRQGHTloGwha1Fp3AfHIUEoUgWZq2n/8Zq2quiO2VTh2GfsQ9+gpFD9yqkWBBeIhae+ucap14TijsO77+m0YPbyC/SLl4irF4TxGabYIu5+JHz3A+G7b7HLFVppss++JH7yBHFxQchifFujrpe47+/wr+4Q9qilVEIIlvVqyyTKmGRz8AorNP5sweh0Trzbk63XVKslcd190vvxJxfe6mB4+80bdvM9ddvw7t0treuj5G3XC0MhJFr2SeNSCITok0lDgM51P3c8P6RaE9BBoIQg0hGz2RylNV1nSSLNJItou5YoiujajjwfU9Utb272rLYFaTphtd6x2VeU3mKt74VkEAQfaHzHdutIpSONZkxGKc45pPNoIfHeHZPN9Udd2scObSWRShOc620vIoAIeOv6PQfrQfY2D+scSvdp4FL1lnFr7DEUwSEIRPTv54M+topLEPKDRPXh+GD6KNm8V6X9iY077qI/JJvzYOuGPm1R9Ne77d8B5+n7/ownjQQjJLkKKEDL3o0gdW9RN6EX9Mb1+yMPwlwKiVQCFzp8cLgQsNZhBagoBikIQtHnuYk+NM67PsQiWEKI/t3BhVLqQx1av/v/88R7CFkbGPhlMh3lNG1BkkQslxvyfMSTR5/jm5LYRcRJShpnzKYnvF+9QgTFIr+kbipmkwt+/z//Ff/8d//Edr+ilTWr5Q7lPMiMOJny2f/wGfvdhvdv3vDDT1/zqxfPeXTyjO19SRaN2d2WhFIST6Zks5Z923J/vePRozOsaTGt57e//hsWo4w3r74hTnIeXTyhKSy71Yrtakc+TmiNIJoGNrsDkpjQWBJdILxHaUPTVui9QWaCorSs79ckTAhB0XQW6S0iBFxnUDqGSFN2HaZtyeKY4D3eeIT3jEcZaRZTNTVV15BNMoQSvUURSZblCCUw1mK6jotHCyrryGKNcAHdRWzKLcSON8vXHJp7ZknGxWTRP7+4fjUqzyaMxqdE2ZrlYc3p1QLdduzbBltu6Oye03xCFke0Scpht2cxneGVQCUR48mUVEimacwkG9NZS0SC1BFFUfDm7g1Xjx5R25bL80foA9i64LDa4ExgcnZCwNI4h7KB0+kJSZbjvGd3qJnP5mitWO+WmMxRW4e0inJXsFjMKduaTgs6meDTMaPTC7pdyc3tDdNck2UREQm7/YEmdPgIkniEsTCajLm6PEMBpj5QVzVRpImyDMWn3e8bGBj478P99f+CvHyOnp0hlYDDEtb3uJs7mtUalWZkFy+QpxeQZqBA+BbdreFuS7i7w1y/p1utsIA+Pyd79gxx+hjyEb46EE1+oPiHv0NXNebtW5JHj+HsOXw2wbeW5u//L6LDmvD1v4L0CCnhEYjpAh9FyJM5wT9G2L/GBUn5zdckP/yRsaiJmhLOnoB1hO0Sf7tCG4fZ3RFdByKzx73+kdZ4fFESTEMnFSLJkNmI+PwS0+xY4ni1LaiCpGwtKYKDO6BMQYIlVorGW7Y2sGwFrdGMI41qFMQSQ5+/IRsDcYJ3/U47UYZ0Ha7r0EEhsYhwwG2v0ZsrOD2D6SloiVAppGOYBHy7xY8VrQCDxOH66172g1EvBC6ADuFYqxxQRjCqDMnbH4mqhq7Y4pOM0a//C+GL38HVE0KkYXuPvvke+y9/j/3pFhoPF0/Rn32OevIMMTsFDGK/RF6/xX73LdW7tzjhcHlGenJFMpvT2YLN9RuK+xuEtaTPXiAyjWZCSGNkMiXOZkTZhHZ1/Unvx59ceD8+v6LpOrabPfebDVXdIpVCSdUv2tNbiYXsp7fOuV4QSvlvdpeF7APV4GEHOKClIk9T5vM5i8UJwXU409ezFLbo66aCYL3e0HSB9bbg/c2KEHYY6+h8P93ttaxACYmnDxPTWjOfL5jPZwTXfLCM97vG9qPq6eMONxLHz0FwPNjMhcCZPoXbOtnvQguJ8w9TYIkCoiRGK2jrvitb4pFeECtJ52x/8PDBNv7w3/5r9YFrffz9g+6WH82Ng/z3wjQA8s92wvsiNzA+YIzB2H4/G+9ItOj3I2RfQ4Z4+IifP+/D9SOkOKZCSlxQ1F0fbiecBanot8ofpvTHOrTjr4eU9Y8t+v8tHkLVehfEwMDALwlNze9+9YTZyZS66tAq4//8P/6ey5M5J6MFbXMgJIrr6zc8evGMzXLD7n5FfSi49u+ou11/cKkM+3rN4jKh3Bj2ZU29qblbrjk5y3n2coovOv63//pbzi9+wx+++oq6bvhq9x3eGmJnKYsNzlqkDdR1S1mX7PeC7795xX/9n/6GsrUUjaetDdM8x7SW85MFLjiauqKTntV2w3h0wnx0QjJakCaQ5S1ObujcinKnSLMzfvf752xu7qiVQGJI4oSzxQnNoe4rY6yh6Tq8c6RC4JwhzXIyG/P+7oBOE5IsZVVsCQeIowXL9YbzxYJM9j8by6ojWcwhUZydPWLzxiBdx8tnV7RywapeY2jxUnO/KREmMB/NSdOYTjQkWU6QhpPzBbffXbNe74milNvdkpu1JdGKx58/5v7tkkRnlE3J65u3/YR5omjNhtPJOTExrWmJVMI0n7NZb3n3+h3F9sDtzR35JGfDHqtrLk5n3N+WXL9a8kU2RY0cjW+RnUEqgZcRu31FEGOM0yzyCftDyqHYEYmEoBQGSdcFzqYXpNmcP735iX/90zfYv8i5OH3EJJtw/fYPbN7dcD69YjKeouIYfwgE78mylK6oebt8wzgfMZtMiKK0f26LIgr7aRNtBwYG/vuIn79ATM9xTtHu7nHXr/HvX6OKiuz0HHn5BDG7IER5/7q4O2DW17Q377Dv3iM2WxLTEacx+dNniM+/hMtHMDuDfIQq9mAN8Xff4e9uqe7v0KsN4nFAzhdEX/yKyWGH+cPf4nY7tt9+g9JTUhETKUWYTXvtMp7DI8+oqkl3O9pX39B8+w0YiT1vEDj89U+IuyWRtfjgMbfvCdsNYjRFTRfofEx0cU4+W0A+AZUQ77ecxprkfkm3/pbG9I0PcauoVGAiDWmmcHha5ylbz77pMA4UkiQEtJfUriF1grGIWZye85u/+CuejKfMhYblNcL12kkGB95RVwfYron2e0RZIWIN2uOERkhFYzqW63ta0/XZU8IjJMQqwh2rmBH96/ReV3i00CRBIA57jPXoJGb65NfIJ5/BxXNIR/j9ku7mHeW//AH/zVeMbEL+7Et4+RJevIDJHCy09yvqVz9hvvkT6uYdkTeIOOX8xUui5y9hMgZXMJom7P71W7rlito6EgExMWo+R+cpejIhkZL80654I8IwKhwYGBgYGBgYGBgYGBgY+GQM8Z0DAwMDAwMDAwMDAwMDA5+QQXgPDAwMDAwMDAwMDAwMDHxCBuE9MDAwMDAwMDAwMDAwMPAJGYT3wMDAwMDAwMDAwMDAwMAnZBDeAwMDAwMDAwMDAwMDAwOfkEF4DwwMDAwMDAwMDAwMDAx8QgbhPTAwMDAwMDAwMDAwMDDwCRmE98DAwMDAwMDAwMDAwMDAJ2QQ3gMDAwMDAwMDAwMDAwMDn5D/G93nYJGBc/jhAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1000x500 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "!wget -q https://s3.amazonaws.com/auxdata.johnsnowlabs.com/public/resources/en/images/images.zip\n",
+    "import shutil\n",
+    "shutil.unpack_archive(\"images.zip\", \"images\", \"zip\")\n",
+    "\n",
+    "from PIL import Image\n",
+    "import matplotlib.pyplot as plt\n",
+    "import os\n",
+    "\n",
+    "_, axes = plt.subplots(2, 5, figsize=(10,5))\n",
+    "axes = axes.flatten()\n",
+    "\n",
+    "i = 0\n",
+    "images_path = \"images/images/\"\n",
+    "for file_name in os.listdir(images_path):\n",
+    "    if file_name.lower().endswith((\".png\", \".jpg\", \".jpeg\", \".gif\")):\n",
+    "        file_path = os.path.join(\"images/images/\", file_name)\n",
+    "        ax = axes[i]\n",
+    "        ax.imshow(Image.open(file_path).convert(\"RGB\"))\n",
+    "        ax.title.set_text(file_name)\n",
+    "        ax.axis(\"off\")\n",
+    "        i += 1\n",
+    "\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can load the images to Spark.\n",
+    "\n",
+    "**NOTE**: The llama.cpp backend of the annotator expects a different image byte format than the default format used by Spark. This annotator expects *raw* image bytes, instead of the OpenCV image compatible format, which is used by default.\n",
+    "\n",
+    "For this, we can use the helper function `loadImagesAsBytes` from the `ImageAssembler`. It will load the images in the right format in a Spark DataFrame. Additionally, we will add a column for the caption:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sparknlp.base import *\n",
+    "from pyspark.sql.functions import lit\n",
+    "\n",
+    "data = ImageAssembler.loadImagesAsBytes(spark, images_path)\n",
+    "# Add a caption to each image.\n",
+    "data = data.withColumn(\"caption\", lit(\"Caption this image.\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now We need an `ImageAssembler` and `DocumentAssembler` to turn the images and captions into the right format for Spark NLP. We also load the model we just saved above. Then we can assemble a pipeline and run it!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "25/01/18 13:46:33 WARN DAGScheduler: Broadcasting large task binary with size 1090.9 KiB\n",
+      "clip_model_load: model name:   openai/clip-vit-large-patch14-336    (0 + 1) / 1]\n",
+      "clip_model_load: description:  image encoder for LLaVA\n",
+      "clip_model_load: GGUF version: 3\n",
+      "clip_model_load: alignment:    32\n",
+      "clip_model_load: n_tensors:    377\n",
+      "clip_model_load: n_kv:         19\n",
+      "clip_model_load: ftype:        q4_0\n",
+      "\n",
+      "clip_model_load: loaded meta data with 19 key-value pairs and 377 tensors from /tmp/spark-5acddb2b-4bca-474e-befd-d8613d27a78e/userFiles-4926735e-f265-46bc-8a9f-9edb6a65484e/llava-v1.5-7b-mmproj-Q4_0.gguf\n",
+      "clip_model_load: Dumping metadata keys/values. Note: KV overrides do not apply in this output.\n",
+      "clip_model_load: - kv   0:                       general.architecture str              = clip\n",
+      "clip_model_load: - kv   1:                      clip.has_text_encoder bool             = false\n",
+      "clip_model_load: - kv   2:                    clip.has_vision_encoder bool             = true\n",
+      "clip_model_load: - kv   3:                   clip.has_llava_projector bool             = true\n",
+      "clip_model_load: - kv   4:                          general.file_type u32              = 2\n",
+      "clip_model_load: - kv   5:                               general.name str              = openai/clip-vit-large-patch14-336\n",
+      "clip_model_load: - kv   6:                        general.description str              = image encoder for LLaVA\n",
+      "clip_model_load: - kv   7:                     clip.vision.image_size u32              = 336\n",
+      "clip_model_load: - kv   8:                     clip.vision.patch_size u32              = 14\n",
+      "clip_model_load: - kv   9:               clip.vision.embedding_length u32              = 1024\n",
+      "clip_model_load: - kv  10:            clip.vision.feed_forward_length u32              = 4096\n",
+      "clip_model_load: - kv  11:                 clip.vision.projection_dim u32              = 768\n",
+      "clip_model_load: - kv  12:           clip.vision.attention.head_count u32              = 16\n",
+      "clip_model_load: - kv  13:   clip.vision.attention.layer_norm_epsilon f32              = 0.000010\n",
+      "clip_model_load: - kv  14:                    clip.vision.block_count u32              = 23\n",
+      "clip_model_load: - kv  15:                     clip.vision.image_mean arr[f32,3]       = [0.481455, 0.457828, 0.408211]\n",
+      "clip_model_load: - kv  16:                      clip.vision.image_std arr[f32,3]       = [0.268630, 0.261303, 0.275777]\n",
+      "clip_model_load: - kv  17:                              clip.use_gelu bool             = false\n",
+      "clip_model_load: - kv  18:               general.quantization_version u32              = 2\n",
+      "clip_model_load: - type  f32:  235 tensors\n",
+      "clip_model_load: - type  f16:    1 tensors\n",
+      "clip_model_load: - type q4_0:  141 tensors\n",
+      "ggml_cuda_init: GGML_CUDA_FORCE_MMQ:    no\n",
+      "ggml_cuda_init: GGML_CUDA_FORCE_CUBLAS: no\n",
+      "ggml_cuda_init: found 1 CUDA devices:\n",
+      "  Device 0: NVIDIA GeForce RTX 3070, compute capability 8.6, VMM: yes\n",
+      "clip_model_load: CLIP using CUDA backend\n",
+      "clip_model_load: text_encoder:   0\n",
+      "clip_model_load: vision_encoder: 1\n",
+      "clip_model_load: llava_projector:  1\n",
+      "clip_model_load: model size:     169.18 MB\n",
+      "clip_model_load: metadata size:  0.13 MB\n",
+      "clip_model_load: params backend buffer size =  169.18 MB (377 tensors)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] build info build=3534 commit=\"641f5dd2\"\n",
+      "[INFO] system info n_threads=6 n_threads_batch=-1 total_threads=6 system_info=\"AVX = 1 | AVX_VNNI = 0 | AVX2 = 1 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | AVX512_BF16 = 0 | FMA = 1 | NEON = 0 | SVE = 0 | ARM_FMA = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 | MATMUL_INT8 = 0 | LLAMAFILE = 1 | \"\n",
+      "[INFO] Multi Modal Mode Enabled\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "key clip.vision.image_grid_pinpoints not found in file\n",
+      "key clip.vision.mm_patch_merge_type not found in file\n",
+      "key clip.vision.image_crop_resolution not found in file\n",
+      "ggml_gallocr_reserve_n: reallocating CUDA0 buffer from size 0.00 MiB to 32.89 MiB\n",
+      "clip_model_load: compute allocated memory: 32.89 MB\n",
+      "llama_model_loader: loaded meta data with 19 key-value pairs and 291 tensors from /tmp/spark-5acddb2b-4bca-474e-befd-d8613d27a78e/userFiles-4926735e-f265-46bc-8a9f-9edb6a65484e/llava-v1.5-7b-Q4_K.gguf (version GGUF V3 (latest))\n",
+      "llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.\n",
+      "llama_model_loader: - kv   0:                       general.architecture str              = llama\n",
+      "llama_model_loader: - kv   1:                               general.name str              = LLaMA v2\n",
+      "llama_model_loader: - kv   2:                       llama.context_length u32              = 4096\n",
+      "llama_model_loader: - kv   3:                     llama.embedding_length u32              = 4096\n",
+      "llama_model_loader: - kv   4:                          llama.block_count u32              = 32\n",
+      "llama_model_loader: - kv   5:                  llama.feed_forward_length u32              = 11008\n",
+      "llama_model_loader: - kv   6:                 llama.rope.dimension_count u32              = 128\n",
+      "llama_model_loader: - kv   7:                 llama.attention.head_count u32              = 32\n",
+      "llama_model_loader: - kv   8:              llama.attention.head_count_kv u32              = 32\n",
+      "llama_model_loader: - kv   9:     llama.attention.layer_norm_rms_epsilon f32              = 0.000010\n",
+      "llama_model_loader: - kv  10:                          general.file_type u32              = 15\n",
+      "llama_model_loader: - kv  11:                       tokenizer.ggml.model str              = llama\n",
+      "llama_model_loader: - kv  12:                      tokenizer.ggml.tokens arr[str,32000]   = [\"<unk>\", \"<s>\", \"</s>\", \"<0x00>\", \"<...\n",
+      "llama_model_loader: - kv  13:                      tokenizer.ggml.scores arr[f32,32000]   = [0.000000, 0.000000, 0.000000, 0.0000...\n",
+      "llama_model_loader: - kv  14:                  tokenizer.ggml.token_type arr[i32,32000]   = [2, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, ...\n",
+      "llama_model_loader: - kv  15:                tokenizer.ggml.bos_token_id u32              = 1\n",
+      "llama_model_loader: - kv  16:                tokenizer.ggml.eos_token_id u32              = 2\n",
+      "llama_model_loader: - kv  17:            tokenizer.ggml.padding_token_id u32              = 0\n",
+      "llama_model_loader: - kv  18:               general.quantization_version u32              = 2\n",
+      "llama_model_loader: - type  f32:   65 tensors\n",
+      "llama_model_loader: - type q4_K:  193 tensors\n",
+      "llama_model_loader: - type q6_K:   33 tensors\n",
+      "llm_load_vocab: special tokens cache size = 3\n",
+      "llm_load_vocab: token to piece cache size = 0.1684 MB\n",
+      "llm_load_print_meta: format           = GGUF V3 (latest)\n",
+      "llm_load_print_meta: arch             = llama\n",
+      "llm_load_print_meta: vocab type       = SPM\n",
+      "llm_load_print_meta: n_vocab          = 32000\n",
+      "llm_load_print_meta: n_merges         = 0\n",
+      "llm_load_print_meta: vocab_only       = 0\n",
+      "llm_load_print_meta: n_ctx_train      = 4096\n",
+      "llm_load_print_meta: n_embd           = 4096\n",
+      "llm_load_print_meta: n_layer          = 32\n",
+      "llm_load_print_meta: n_head           = 32\n",
+      "llm_load_print_meta: n_head_kv        = 32\n",
+      "llm_load_print_meta: n_rot            = 128\n",
+      "llm_load_print_meta: n_swa            = 0\n",
+      "llm_load_print_meta: n_embd_head_k    = 128\n",
+      "llm_load_print_meta: n_embd_head_v    = 128\n",
+      "llm_load_print_meta: n_gqa            = 1\n",
+      "llm_load_print_meta: n_embd_k_gqa     = 4096\n",
+      "llm_load_print_meta: n_embd_v_gqa     = 4096\n",
+      "llm_load_print_meta: f_norm_eps       = 0.0e+00\n",
+      "llm_load_print_meta: f_norm_rms_eps   = 1.0e-05\n",
+      "llm_load_print_meta: f_clamp_kqv      = 0.0e+00\n",
+      "llm_load_print_meta: f_max_alibi_bias = 0.0e+00\n",
+      "llm_load_print_meta: f_logit_scale    = 0.0e+00\n",
+      "llm_load_print_meta: n_ff             = 11008\n",
+      "llm_load_print_meta: n_expert         = 0\n",
+      "llm_load_print_meta: n_expert_used    = 0\n",
+      "llm_load_print_meta: causal attn      = 1\n",
+      "llm_load_print_meta: pooling type     = 0\n",
+      "llm_load_print_meta: rope type        = 0\n",
+      "llm_load_print_meta: rope scaling     = linear\n",
+      "llm_load_print_meta: freq_base_train  = 10000.0\n",
+      "llm_load_print_meta: freq_scale_train = 1\n",
+      "llm_load_print_meta: n_ctx_orig_yarn  = 4096\n",
+      "llm_load_print_meta: rope_finetuned   = unknown\n",
+      "llm_load_print_meta: ssm_d_conv       = 0\n",
+      "llm_load_print_meta: ssm_d_inner      = 0\n",
+      "llm_load_print_meta: ssm_d_state      = 0\n",
+      "llm_load_print_meta: ssm_dt_rank      = 0\n",
+      "llm_load_print_meta: model type       = 7B\n",
+      "llm_load_print_meta: model ftype      = Q4_K - Medium\n",
+      "llm_load_print_meta: model params     = 6.74 B\n",
+      "llm_load_print_meta: model size       = 3.80 GiB (4.84 BPW) \n",
+      "llm_load_print_meta: general.name     = LLaMA v2\n",
+      "llm_load_print_meta: BOS token        = 1 '<s>'\n",
+      "llm_load_print_meta: EOS token        = 2 '</s>'\n",
+      "llm_load_print_meta: UNK token        = 0 '<unk>'\n",
+      "llm_load_print_meta: PAD token        = 0 '<unk>'\n",
+      "llm_load_print_meta: LF token         = 13 '<0x0A>'\n",
+      "llm_load_print_meta: max token length = 48\n",
+      "llm_load_tensors: ggml ctx size =    0.27 MiB\n",
+      "llm_load_tensors: offloading 32 repeating layers to GPU\n",
+      "llm_load_tensors: offloading non-repeating layers to GPU\n",
+      "llm_load_tensors: offloaded 33/33 layers to GPU\n",
+      "llm_load_tensors:        CPU buffer size =    70.31 MiB\n",
+      "llm_load_tensors:      CUDA0 buffer size =  3820.94 MiB\n",
+      "..................................................................................................\n",
+      "llama_new_context_with_model: n_ctx      = 4096\n",
+      "llama_new_context_with_model: n_batch    = 512\n",
+      "llama_new_context_with_model: n_ubatch   = 512\n",
+      "llama_new_context_with_model: flash_attn = 0\n",
+      "llama_new_context_with_model: freq_base  = 10000.0\n",
+      "llama_new_context_with_model: freq_scale = 1\n",
+      "llama_kv_cache_init:      CUDA0 KV buffer size =  2048.00 MiB\n",
+      "llama_new_context_with_model: KV self size  = 2048.00 MiB, K (f16): 1024.00 MiB, V (f16): 1024.00 MiB\n",
+      "llama_new_context_with_model:  CUDA_Host  output buffer size =     0.12 MiB\n",
+      "ggml_gallocr_reserve_n: reallocating CUDA0 buffer from size 0.00 MiB to 296.00 MiB\n",
+      "ggml_gallocr_reserve_n: reallocating CUDA_Host buffer from size 0.00 MiB to 16.01 MiB\n",
+      "llama_new_context_with_model:      CUDA0 compute buffer size =   296.00 MiB\n",
+      "llama_new_context_with_model:  CUDA_Host compute buffer size =    16.01 MiB\n",
+      "llama_new_context_with_model: graph nodes  = 1030\n",
+      "llama_new_context_with_model: graph splits = 2\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] initializing slots n_slots=1\n",
+      "[INFO] new slot slot_id=0 n_ctx_slot=4096\n",
+      "[INFO] model loaded\n",
+      "[INFO] chat template chat_example=\"You are a helpful assistant\\n\\nUSER: Hello\\nASSISTANT: Hi there</s>\\nUSER: How are you?\\nASSISTANT:\" built_in=false\n",
+      "[INFO] all slots are idle and system prompt is empty, clear the KV cache\n",
+      "[INFO] slot is processing task slot_id=0 task_id=0\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=0 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    76.17 ms by CLIP (    0.13 ms per image patch)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "llama_output_reserve: reallocating output buffer from size 0.12 MiB to 1.22 MiB\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     481.17 ms /     1 tokens (  481.17 ms per token,     2.08 tokens per second) slot_id=0 task_id=0 t_prompt_processing=481.165 n_prompt_tokens_processed=1 t_token=481.165 n_tokens_second=2.078289152369769\n",
+      "[INFO] generation eval time =     757.27 ms /    40 runs   (   18.93 ms per token,    52.82 tokens per second) slot_id=0 task_id=0 t_token_generation=757.271 n_decoded=40 t_token=18.931775 n_tokens_second=52.821248932020374\n",
+      "[INFO]           total time =    1238.44 ms slot_id=0 task_id=0 t_prompt_processing=481.165 t_token_generation=757.271 t_total=1238.436\n",
+      "[INFO] slot released slot_id=0 task_id=0 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=1\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=1 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    48.94 ms by CLIP (    0.08 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     418.86 ms /     1 tokens (  418.86 ms per token,     2.39 tokens per second) slot_id=0 task_id=1 t_prompt_processing=418.858 n_prompt_tokens_processed=1 t_token=418.858 n_tokens_second=2.387443954753162\n",
+      "[INFO] generation eval time =     760.78 ms /    40 runs   (   19.02 ms per token,    52.58 tokens per second) slot_id=0 task_id=1 t_token_generation=760.785 n_decoded=40 t_token=19.019624999999998 n_tokens_second=52.57727215967718\n",
+      "[INFO]           total time =    1179.64 ms slot_id=0 task_id=1 t_prompt_processing=418.858 t_token_generation=760.785 t_total=1179.643\n",
+      "[INFO] slot released slot_id=0 task_id=1 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "25/01/18 13:46:37 WARN DAGScheduler: Broadcasting large task binary with size 1090.9 KiB\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] slot is processing task slot_id=0 task_id=84\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=84 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    51.93 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     434.93 ms /     1 tokens (  434.93 ms per token,     2.30 tokens per second) slot_id=0 task_id=84 t_prompt_processing=434.926 n_prompt_tokens_processed=1 t_token=434.926 n_tokens_second=2.2992417100840146\n",
+      "[INFO] generation eval time =     759.00 ms /    40 runs   (   18.98 ms per token,    52.70 tokens per second) slot_id=0 task_id=84 t_token_generation=759.003 n_decoded=40 t_token=18.975075 n_tokens_second=52.70071396292241\n",
+      "[INFO]           total time =    1193.93 ms slot_id=0 task_id=84 t_prompt_processing=434.926 t_token_generation=759.003 t_total=1193.929\n",
+      "[INFO] slot released slot_id=0 task_id=84 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=85\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=85 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    49.35 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "encode_image_with_clip: image embedding created: 576 tokens         (1 + 3) / 4]\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    50.33 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     418.23 ms /     1 tokens (  418.23 ms per token,     2.39 tokens per second) slot_id=0 task_id=85 t_prompt_processing=418.234 n_prompt_tokens_processed=1 t_token=418.234 n_tokens_second=2.391005991861016\n",
+      "[INFO] generation eval time =     310.67 ms /    17 runs   (   18.27 ms per token,    54.72 tokens per second) slot_id=0 task_id=85 t_token_generation=310.665 n_decoded=17 t_token=18.274411764705885 n_tokens_second=54.72132361225113\n",
+      "[INFO]           total time =     728.90 ms slot_id=0 task_id=85 t_prompt_processing=418.234 t_token_generation=310.665 t_total=728.899\n",
+      "[INFO] slot released slot_id=0 task_id=85 n_ctx=4096 n_past=609 n_system_tokens=0 n_cache_tokens=18 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=87\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=87 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     423.11 ms /     1 tokens (  423.11 ms per token,     2.36 tokens per second) slot_id=0 task_id=87 t_prompt_processing=423.106 n_prompt_tokens_processed=1 t_token=423.106 n_tokens_second=2.3634739285190944\n",
+      "[INFO] generation eval time =     771.11 ms /    40 runs   (   19.28 ms per token,    51.87 tokens per second) slot_id=0 task_id=87 t_token_generation=771.106 n_decoded=40 t_token=19.27765 n_tokens_second=51.873542677660396\n",
+      "[INFO]           total time =    1194.21 ms slot_id=0 task_id=87 t_prompt_processing=423.106 t_token_generation=771.106 t_total=1194.212\n",
+      "[INFO] slot released slot_id=0 task_id=87 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=88\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=88 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    50.07 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     423.79 ms /     1 tokens (  423.79 ms per token,     2.36 tokens per second) slot_id=0 task_id=88 t_prompt_processing=423.79 n_prompt_tokens_processed=1 t_token=423.79 n_tokens_second=2.359659265202105\n",
+      "[INFO] generation eval time =     251.86 ms /    14 runs   (   17.99 ms per token,    55.59 tokens per second) slot_id=0 task_id=88 t_token_generation=251.863 n_decoded=14 t_token=17.990214285714284 n_tokens_second=55.58577480614461\n",
+      "[INFO]           total time =     675.65 ms slot_id=0 task_id=88 t_prompt_processing=423.79 t_token_generation=251.863 t_total=675.653\n",
+      "[INFO] slot released slot_id=0 task_id=88 n_ctx=4096 n_past=606 n_system_tokens=0 n_cache_tokens=15 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=89\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=89 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    49.78 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    50.26 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     422.05 ms /     1 tokens (  422.05 ms per token,     2.37 tokens per second) slot_id=0 task_id=89 t_prompt_processing=422.047 n_prompt_tokens_processed=1 t_token=422.047 n_tokens_second=2.369404355439086\n",
+      "[INFO] generation eval time =     351.31 ms /    19 runs   (   18.49 ms per token,    54.08 tokens per second) slot_id=0 task_id=89 t_token_generation=351.31 n_decoded=19 t_token=18.49 n_tokens_second=54.08328826392644\n",
+      "[INFO]           total time =     773.36 ms slot_id=0 task_id=89 t_prompt_processing=422.047 t_token_generation=351.31 t_total=773.357\n",
+      "[INFO] slot released slot_id=0 task_id=89 n_ctx=4096 n_past=611 n_system_tokens=0 n_cache_tokens=20 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=90\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=90 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     419.07 ms /     1 tokens (  419.07 ms per token,     2.39 tokens per second) slot_id=0 task_id=90 t_prompt_processing=419.071 n_prompt_tokens_processed=1 t_token=419.071 n_tokens_second=2.386230495548487\n",
+      "[INFO] generation eval time =     768.85 ms /    40 runs   (   19.22 ms per token,    52.03 tokens per second) slot_id=0 task_id=90 t_token_generation=768.849 n_decoded=40 t_token=19.221225 n_tokens_second=52.0258204146718\n",
+      "[INFO]           total time =    1187.92 ms slot_id=0 task_id=90 t_prompt_processing=419.071 t_token_generation=768.849 t_total=1187.92\n",
+      "[INFO] slot released slot_id=0 task_id=90 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=91\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=91 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    49.82 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     424.45 ms /     1 tokens (  424.45 ms per token,     2.36 tokens per second) slot_id=0 task_id=91 t_prompt_processing=424.45 n_prompt_tokens_processed=1 t_token=424.45 n_tokens_second=2.3559901048415597\n",
+      "[INFO] generation eval time =     761.95 ms /    40 runs   (   19.05 ms per token,    52.50 tokens per second) slot_id=0 task_id=91 t_token_generation=761.953 n_decoded=40 t_token=19.048825 n_tokens_second=52.49667630418149\n",
+      "[INFO]           total time =    1186.40 ms slot_id=0 task_id=91 t_prompt_processing=424.45 t_token_generation=761.953 t_total=1186.403\n",
+      "[INFO] slot released slot_id=0 task_id=91 n_ctx=4096 n_past=632 n_system_tokens=0 n_cache_tokens=41 truncated=false\n",
+      "[INFO] slot is processing task slot_id=0 task_id=92\n",
+      "[INFO] kv cache rm [p0, end) slot_id=0 task_id=92 p0=0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "encode_image_with_clip: image embedding created: 576 tokens\n",
+      "\n",
+      "encode_image_with_clip: image encoded in    49.04 ms by CLIP (    0.09 ms per image patch)\n",
+      "ggml_gallocr_needs_realloc: node inp_embd is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 1)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[INFO] prompt eval time     =     417.26 ms /     1 tokens (  417.26 ms per token,     2.40 tokens per second) slot_id=0 task_id=92 t_prompt_processing=417.263 n_prompt_tokens_processed=1 t_token=417.263 n_tokens_second=2.3965700289745318\n",
+      "[INFO] generation eval time =     329.49 ms /    18 runs   (   18.31 ms per token,    54.63 tokens per second) slot_id=0 task_id=92 t_token_generation=329.493 n_decoded=18 t_token=18.305166666666665 n_tokens_second=54.629385146270174\n",
+      "[INFO]           total time =     746.76 ms slot_id=0 task_id=92 t_prompt_processing=417.263 t_token_generation=329.493 t_total=746.756\n",
+      "[INFO] slot released slot_id=0 task_id=92 n_ctx=4096 n_past=610 n_system_tokens=0 n_cache_tokens=19 truncated=false\n",
+      "+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n",
+      "|image_name       |result                                                                                                                                                                                          |\n",
+      "+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n",
+      "|palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and yellow walls. It features an elegant sitting area with several chairs arranged around the space. There are also multiple c]     |\n",
+      "|egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the frame and appears to be sleeping while holding]               |\n",
+      "|hippopotamus.JPEG|[ A large brown hippo is swimming in a pond, with its head above the water. The hippo appears to be enjoying itself as it floats on top of the water.]                                          |\n",
+      "|hen.JPEG         |[ The image features a large white chicken standing next to several baby chicks. There are at least five visible chickens in the scene, with one adult and four young ones surrounding it. They]|\n",
+      "|ostrich.JPEG     |[ A large ostrich stands in a grassy field, surrounded by trees and bushes. The bird is the main focus of the image with its long neck stretched out as it looks around at]                     |\n",
+      "|junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow.]                                                                                                                      |\n",
+      "|bluetick.jpg     |[ A dog with a red collar is sitting on the floor.]                                                                                                                                             |\n",
+      "|chihuahua.jpg    |[ A small brown dog wearing a sweater and collar is sitting on the floor.]                                                                                                                      |\n",
+      "|tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels. The tractor appears to be parked on top of an agricultural field with rows of]                             |\n",
+      "|ox.JPEG          |[ A large bull with long horns is standing in a grassy field.]                                                                                                                                  |\n",
+      "+-----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "ggml_gallocr_needs_realloc: src 0 (KQ_mask) of node KQ_mask (view) is not valid\n",
+      "ggml_gallocr_alloc_graph: cannot reallocate multi buffer graph automatically, call reserve\n",
+      "ggml_backend_sched_alloc_splits: failed to allocate graph, reserving (backend_ids_changed = 0)\n",
+      "                                                                                \r"
+     ]
+    }
+   ],
+   "source": [
+    "import sparknlp\n",
+    "from sparknlp.base import *\n",
+    "from sparknlp.annotator import *\n",
+    "from pyspark.ml import Pipeline\n",
+    "\n",
+    "documentAssembler = (\n",
+    "    DocumentAssembler().setInputCol(\"caption\").setOutputCol(\"caption_document\")\n",
+    ")\n",
+    "imageAssembler = ImageAssembler().setInputCol(\"image\").setOutputCol(\"image_assembler\")\n",
+    "model = AutoGGUFVisionModel.load(\"llava_v1.5_7b_Q4_0_gguf_spark_nlp\")\n",
+    "pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])\n",
+    "\n",
+    "pipeline.fit(data).transform(data).selectExpr(\n",
+    "    \"reverse(split(image.origin, '/'))[0] as image_name\", \"completions.result\"\n",
+    ").show(truncate=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That's it! You can now go wild and use hundreds of GGUF models from HuggingFace 🤗 in Spark NLP 🚀\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "sparknlp_dev",
+   "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"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index fae6267df57f21..ff532c8d56eeb6 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -128,7 +128,7 @@ object Dependencies {
   val azureIdentity = "com.azure" % "azure-identity" % azureIdentityVersion % Provided
   val azureStorage = "com.azure" % "azure-storage-blob" % azureStorageVersion % Provided
 
-  val llamaCppVersion = "0.1.4"
+  val llamaCppVersion = "0.1.6"
   val llamaCppCPU = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-cpu" % llamaCppVersion
   val llamaCppGPU = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-gpu" % llamaCppVersion
   val llamaCppSilicon = "com.johnsnowlabs.nlp" %% "jsl-llamacpp-silicon" % llamaCppVersion
diff --git a/python/sparknlp/annotator/seq2seq/__init__.py b/python/sparknlp/annotator/seq2seq/__init__.py
index e9c3984c21ecc1..e946fbc0e472e8 100644
--- a/python/sparknlp/annotator/seq2seq/__init__.py
+++ b/python/sparknlp/annotator/seq2seq/__init__.py
@@ -22,6 +22,7 @@
 from sparknlp.annotator.seq2seq.phi2_transformer import *
 from sparknlp.annotator.seq2seq.mistral_transformer import *
 from sparknlp.annotator.seq2seq.auto_gguf_model import *
+from sparknlp.annotator.seq2seq.auto_gguf_vision_model import *
 from sparknlp.annotator.seq2seq.phi3_transformer import *
 from sparknlp.annotator.seq2seq.nllb_transformer import *
 from sparknlp.annotator.seq2seq.cpm_transformer import *
diff --git a/python/sparknlp/annotator/seq2seq/auto_gguf_model.py b/python/sparknlp/annotator/seq2seq/auto_gguf_model.py
index d28ac006c9da22..37c96319564782 100755
--- a/python/sparknlp/annotator/seq2seq/auto_gguf_model.py
+++ b/python/sparknlp/annotator/seq2seq/auto_gguf_model.py
@@ -17,7 +17,7 @@
 from sparknlp.common import *
 
 
-class AutoGGUFModel(AnnotatorModel, HasBatchedAnnotate):
+class AutoGGUFModel(AnnotatorModel, HasBatchedAnnotate, HasLlamaCppProperties):
     """
     Annotator that uses the llama.cpp library to generate text completions with large language
     models.
@@ -241,507 +241,6 @@ class AutoGGUFModel(AnnotatorModel, HasBatchedAnnotate):
     inputAnnotatorTypes = [AnnotatorType.DOCUMENT]
     outputAnnotatorType = AnnotatorType.DOCUMENT
 
-    # -------- MODEl PARAMETERS --------
-    nThreads = Param(Params._dummy(), "nThreads", "Set the number of threads to use during generation",
-                     typeConverter=TypeConverters.toInt)
-    nThreadsDraft = Param(Params._dummy(), "nThreadsDraft", "Set the number of threads to use during draft generation",
-                          typeConverter=TypeConverters.toInt)
-    nThreadsBatch = Param(Params._dummy(), "nThreadsBatch",
-                          "Set the number of threads to use during batch and prompt processing",
-                          typeConverter=TypeConverters.toInt)
-    nThreadsBatchDraft = Param(Params._dummy(), "nThreadsBatchDraft",
-                               "Set the number of threads to use during batch and prompt processing",
-                               typeConverter=TypeConverters.toInt)
-    nCtx = Param(Params._dummy(), "nCtx", "Set the size of the prompt context", typeConverter=TypeConverters.toInt)
-    nBatch = Param(Params._dummy(), "nBatch",
-                   "Set the logical batch size for prompt processing (must be >=32 to use BLAS)",
-                   typeConverter=TypeConverters.toInt)
-    nUbatch = Param(Params._dummy(), "nUbatch",
-                    "Set the physical batch size for prompt processing (must be >=32 to use BLAS)",
-                    typeConverter=TypeConverters.toInt)
-    nDraft = Param(Params._dummy(), "nDraft", "Set the number of tokens to draft for speculative decoding",
-                   typeConverter=TypeConverters.toInt)
-    nChunks = Param(Params._dummy(), "nChunks", "Set the maximal number of chunks to process",
-                    typeConverter=TypeConverters.toInt)
-    nSequences = Param(Params._dummy(), "nSequences", "Set the number of sequences to decode",
-                       typeConverter=TypeConverters.toInt)
-    pSplit = Param(Params._dummy(), "pSplit", "Set the speculative decoding split probability",
-                   typeConverter=TypeConverters.toFloat)
-    nGpuLayers = Param(Params._dummy(), "nGpuLayers", "Set the number of layers to store in VRAM (-1 - use default)",
-                       typeConverter=TypeConverters.toInt)
-    nGpuLayersDraft = Param(Params._dummy(), "nGpuLayersDraft",
-                            "Set the number of layers to store in VRAM for the draft model (-1 - use default)",
-                            typeConverter=TypeConverters.toInt)
-    # Set how to split the model across GPUs
-    #
-    #   - NONE: No GPU split
-    #   - LAYER: Split the model across GPUs by layer
-    #   - ROW: Split the model across GPUs by rows
-    gpuSplitMode = Param(Params._dummy(), "gpuSplitMode", "Set how to split the model across GPUs",
-                         typeConverter=TypeConverters.toString)
-    mainGpu = Param(Params._dummy(), "mainGpu", "Set the main GPU that is used for scratch and small tensors.",
-                    typeConverter=TypeConverters.toInt)
-    tensorSplit = Param(Params._dummy(), "tensorSplit", "Set how split tensors should be distributed across GPUs",
-                        typeConverter=TypeConverters.toListFloat)
-    grpAttnN = Param(Params._dummy(), "grpAttnN", "Set the group-attention factor", typeConverter=TypeConverters.toInt)
-    grpAttnW = Param(Params._dummy(), "grpAttnW", "Set the group-attention width", typeConverter=TypeConverters.toInt)
-    ropeFreqBase = Param(Params._dummy(), "ropeFreqBase", "Set the RoPE base frequency, used by NTK-aware scaling",
-                         typeConverter=TypeConverters.toFloat)
-    ropeFreqScale = Param(Params._dummy(), "ropeFreqScale",
-                          "Set the RoPE frequency scaling factor, expands context by a factor of 1/N",
-                          typeConverter=TypeConverters.toFloat)
-    yarnExtFactor = Param(Params._dummy(), "yarnExtFactor", "Set the YaRN extrapolation mix factor",
-                          typeConverter=TypeConverters.toFloat)
-    yarnAttnFactor = Param(Params._dummy(), "yarnAttnFactor", "Set the YaRN scale sqrt(t) or attention magnitude",
-                           typeConverter=TypeConverters.toFloat)
-    yarnBetaFast = Param(Params._dummy(), "yarnBetaFast", "Set the YaRN low correction dim or beta",
-                         typeConverter=TypeConverters.toFloat)
-    yarnBetaSlow = Param(Params._dummy(), "yarnBetaSlow", "Set the YaRN high correction dim or alpha",
-                         typeConverter=TypeConverters.toFloat)
-    yarnOrigCtx = Param(Params._dummy(), "yarnOrigCtx", "Set the YaRN original context size of model",
-                        typeConverter=TypeConverters.toInt)
-    defragmentationThreshold = Param(Params._dummy(), "defragmentationThreshold",
-                                     "Set the KV cache defragmentation threshold", typeConverter=TypeConverters.toFloat)
-    # Set optimization strategies that help on some NUMA systems (if available)
-    #
-    # Available Strategies:
-    #
-    #   - DISABLED: No NUMA optimizations
-    #   - DISTRIBUTE: Spread execution evenly over all
-    #   - ISOLATE: Only spawn threads on CPUs on the node that execution started on
-    #   - NUMA_CTL: Use the CPU map provided by numactl
-    #   - MIRROR: Mirrors the model across NUMA nodes
-    numaStrategy = Param(Params._dummy(), "numaStrategy",
-                         "Set optimization strategies that help on some NUMA systems (if available)",
-                         typeConverter=TypeConverters.toString)
-    # Set the RoPE frequency scaling method, defaults to linear unless specified by the model.
-    #
-    #   - UNSPECIFIED: Don't use any scaling
-    #   - LINEAR: Linear scaling
-    #   - YARN: YaRN RoPE scaling
-    ropeScalingType = Param(Params._dummy(), "ropeScalingType",
-                            "Set the RoPE frequency scaling method, defaults to linear unless specified by the model",
-                            typeConverter=TypeConverters.toString)
-    # Set the pooling type for embeddings, use model default if unspecified
-    #
-    #   - 0 UNSPECIFIED: Don't use any pooling
-    #   - 1 MEAN: Mean Pooling
-    #   - 2 CLS: CLS Pooling
-    poolingType = Param(Params._dummy(), "poolingType",
-                        "Set the pooling type for embeddings, use model default if unspecified",
-                        typeConverter=TypeConverters.toString)
-    modelDraft = Param(Params._dummy(), "modelDraft", "Set the draft model for speculative decoding",
-                       typeConverter=TypeConverters.toString)
-    modelAlias = Param(Params._dummy(), "modelAlias", "Set a model alias", typeConverter=TypeConverters.toString)
-    lookupCacheStaticFilePath = Param(Params._dummy(), "lookupCacheStaticFilePath",
-                                      "Set path to static lookup cache to use for lookup decoding (not updated by generation)",
-                                      typeConverter=TypeConverters.toString)
-    lookupCacheDynamicFilePath = Param(Params._dummy(), "lookupCacheDynamicFilePath",
-                                       "Set path to dynamic lookup cache to use for lookup decoding (updated by generation)",
-                                       typeConverter=TypeConverters.toString)
-    # loraAdapters = new StructFeature[Map[String, Float]](this, "loraAdapters")
-    embedding = Param(Params._dummy(), "embedding", "Whether to load model with embedding support",
-                      typeConverter=TypeConverters.toBoolean)
-    flashAttention = Param(Params._dummy(), "flashAttention", "Whether to enable Flash Attention",
-                           typeConverter=TypeConverters.toBoolean)
-    inputPrefixBos = Param(Params._dummy(), "inputPrefixBos",
-                           "Whether to add prefix BOS to user inputs, preceding the `--in-prefix` string",
-                           typeConverter=TypeConverters.toBoolean)
-    useMmap = Param(Params._dummy(), "useMmap",
-                    "Whether to use memory-map model (faster load but may increase pageouts if not using mlock)",
-                    typeConverter=TypeConverters.toBoolean)
-    useMlock = Param(Params._dummy(), "useMlock",
-                     "Whether to force the system to keep model in RAM rather than swapping or compressing",
-                     typeConverter=TypeConverters.toBoolean)
-    noKvOffload = Param(Params._dummy(), "noKvOffload", "Whether to disable KV offload",
-                        typeConverter=TypeConverters.toBoolean)
-    systemPrompt = Param(Params._dummy(), "systemPrompt", "Set a system prompt to use",
-                         typeConverter=TypeConverters.toString)
-    chatTemplate = Param(Params._dummy(), "chatTemplate", "The chat template to use",
-                         typeConverter=TypeConverters.toString)
-
-    # -------- INFERENCE PARAMETERS --------
-    inputPrefix = Param(Params._dummy(), "inputPrefix", "Set the prompt to start generation with",
-                        typeConverter=TypeConverters.toString)
-    inputSuffix = Param(Params._dummy(), "inputSuffix", "Set a suffix for infilling",
-                        typeConverter=TypeConverters.toString)
-    cachePrompt = Param(Params._dummy(), "cachePrompt", "Whether to remember the prompt to avoid reprocessing it",
-                        typeConverter=TypeConverters.toBoolean)
-    nPredict = Param(Params._dummy(), "nPredict", "Set the number of tokens to predict",
-                     typeConverter=TypeConverters.toInt)
-    topK = Param(Params._dummy(), "topK", "Set top-k sampling", typeConverter=TypeConverters.toInt)
-    topP = Param(Params._dummy(), "topP", "Set top-p sampling", typeConverter=TypeConverters.toFloat)
-    minP = Param(Params._dummy(), "minP", "Set min-p sampling", typeConverter=TypeConverters.toFloat)
-    tfsZ = Param(Params._dummy(), "tfsZ", "Set tail free sampling, parameter z", typeConverter=TypeConverters.toFloat)
-    typicalP = Param(Params._dummy(), "typicalP", "Set locally typical sampling, parameter p",
-                     typeConverter=TypeConverters.toFloat)
-    temperature = Param(Params._dummy(), "temperature", "Set the temperature", typeConverter=TypeConverters.toFloat)
-    dynamicTemperatureRange = Param(Params._dummy(), "dynatempRange", "Set the dynamic temperature range",
-                                    typeConverter=TypeConverters.toFloat)
-    dynamicTemperatureExponent = Param(Params._dummy(), "dynatempExponent", "Set the dynamic temperature exponent",
-                                       typeConverter=TypeConverters.toFloat)
-    repeatLastN = Param(Params._dummy(), "repeatLastN", "Set the last n tokens to consider for penalties",
-                        typeConverter=TypeConverters.toInt)
-    repeatPenalty = Param(Params._dummy(), "repeatPenalty", "Set the penalty of repeated sequences of tokens",
-                          typeConverter=TypeConverters.toFloat)
-    frequencyPenalty = Param(Params._dummy(), "frequencyPenalty", "Set the repetition alpha frequency penalty",
-                             typeConverter=TypeConverters.toFloat)
-    presencePenalty = Param(Params._dummy(), "presencePenalty", "Set the repetition alpha presence penalty",
-                            typeConverter=TypeConverters.toFloat)
-    miroStat = Param(Params._dummy(), "miroStat", "Set MiroStat sampling strategies.",
-                     typeConverter=TypeConverters.toString)
-    miroStatTau = Param(Params._dummy(), "mirostatTau", "Set the MiroStat target entropy, parameter tau",
-                        typeConverter=TypeConverters.toFloat)
-    miroStatEta = Param(Params._dummy(), "mirostatEta", "Set the MiroStat learning rate, parameter eta",
-                        typeConverter=TypeConverters.toFloat)
-    penalizeNl = Param(Params._dummy(), "penalizeNl", "Whether to penalize newline tokens",
-                       typeConverter=TypeConverters.toBoolean)
-    nKeep = Param(Params._dummy(), "nKeep", "Set the number of tokens to keep from the initial prompt",
-                  typeConverter=TypeConverters.toInt)
-    seed = Param(Params._dummy(), "seed", "Set the RNG seed", typeConverter=TypeConverters.toInt)
-    nProbs = Param(Params._dummy(), "nProbs", "Set the amount top tokens probabilities to output if greater than 0.",
-                   typeConverter=TypeConverters.toInt)
-    minKeep = Param(Params._dummy(), "minKeep",
-                    "Set the amount of tokens the samplers should return at least (0 = disabled)",
-                    typeConverter=TypeConverters.toInt)
-    grammar = Param(Params._dummy(), "grammar", "Set BNF-like grammar to constrain generations",
-                    typeConverter=TypeConverters.toString)
-    penaltyPrompt = Param(Params._dummy(), "penaltyPrompt",
-                          "Override which part of the prompt is penalized for repetition.",
-                          typeConverter=TypeConverters.toString)
-    ignoreEos = Param(Params._dummy(), "ignoreEos",
-                      "Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)",
-                      typeConverter=TypeConverters.toBoolean)
-    disableTokenIds = Param(Params._dummy(), "disableTokenIds", "Set the token ids to disable in the completion",
-                            typeConverter=TypeConverters.toListInt)
-    stopStrings = Param(Params._dummy(), "stopStrings", "Set strings upon seeing which token generation is stopped",
-                        typeConverter=TypeConverters.toListString)
-    samplers = Param(Params._dummy(), "samplers", "Set which samplers to use for token generation in the given order",
-                     typeConverter=TypeConverters.toListString)
-    useChatTemplate = Param(Params._dummy(), "useChatTemplate",
-                            "Set whether or not generate should apply a chat template",
-                            typeConverter=TypeConverters.toBoolean)
-
-    # -------- MODEL SETTERS --------
-    def setNThreads(self, nThreads: int):
-        """Set the number of threads to use during generation"""
-        return self._set(nThreads=nThreads)
-
-    def setNThreadsDraft(self, nThreadsDraft: int):
-        """Set the number of threads to use during draft generation"""
-        return self._set(nThreadsDraft=nThreadsDraft)
-
-    def setNThreadsBatch(self, nThreadsBatch: int):
-        """Set the number of threads to use during batch and prompt processing"""
-        return self._set(nThreadsBatch=nThreadsBatch)
-
-    def setNThreadsBatchDraft(self, nThreadsBatchDraft: int):
-        """Set the number of threads to use during batch and prompt processing"""
-        return self._set(nThreadsBatchDraft=nThreadsBatchDraft)
-
-    def setNCtx(self, nCtx: int):
-        """Set the size of the prompt context"""
-        return self._set(nCtx=nCtx)
-
-    def setNBatch(self, nBatch: int):
-        """Set the logical batch size for prompt processing (must be >=32 to use BLAS)"""
-        return self._set(nBatch=nBatch)
-
-    def setNUbatch(self, nUbatch: int):
-        """Set the physical batch size for prompt processing (must be >=32 to use BLAS)"""
-        return self._set(nUbatch=nUbatch)
-
-    def setNDraft(self, nDraft: int):
-        """Set the number of tokens to draft for speculative decoding"""
-        return self._set(nDraft=nDraft)
-
-    def setNChunks(self, nChunks: int):
-        """Set the maximal number of chunks to process"""
-        return self._set(nChunks=nChunks)
-
-    def setNSequences(self, nSequences: int):
-        """Set the number of sequences to decode"""
-        return self._set(nSequences=nSequences)
-
-    def setPSplit(self, pSplit: float):
-        """Set the speculative decoding split probability"""
-        return self._set(pSplit=pSplit)
-
-    def setNGpuLayers(self, nGpuLayers: int):
-        """Set the number of layers to store in VRAM (-1 - use default)"""
-        return self._set(nGpuLayers=nGpuLayers)
-
-    def setNGpuLayersDraft(self, nGpuLayersDraft: int):
-        """Set the number of layers to store in VRAM for the draft model (-1 - use default)"""
-        return self._set(nGpuLayersDraft=nGpuLayersDraft)
-
-    def setGpuSplitMode(self, gpuSplitMode: str):
-        """Set how to split the model across GPUs"""
-        return self._set(gpuSplitMode=gpuSplitMode)
-
-    def setMainGpu(self, mainGpu: int):
-        """Set the main GPU that is used for scratch and small tensors."""
-        return self._set(mainGpu=mainGpu)
-
-    def setTensorSplit(self, tensorSplit: List[float]):
-        """Set how split tensors should be distributed across GPUs"""
-        return self._set(tensorSplit=tensorSplit)
-
-    def setGrpAttnN(self, grpAttnN: int):
-        """Set the group-attention factor"""
-        return self._set(grpAttnN=grpAttnN)
-
-    def setGrpAttnW(self, grpAttnW: int):
-        """Set the group-attention width"""
-        return self._set(grpAttnW=grpAttnW)
-
-    def setRopeFreqBase(self, ropeFreqBase: float):
-        """Set the RoPE base frequency, used by NTK-aware scaling"""
-        return self._set(ropeFreqBase=ropeFreqBase)
-
-    def setRopeFreqScale(self, ropeFreqScale: float):
-        """Set the RoPE frequency scaling factor, expands context by a factor of 1/N"""
-        return self._set(ropeFreqScale=ropeFreqScale)
-
-    def setYarnExtFactor(self, yarnExtFactor: float):
-        """Set the YaRN extrapolation mix factor"""
-        return self._set(yarnExtFactor=yarnExtFactor)
-
-    def setYarnAttnFactor(self, yarnAttnFactor: float):
-        """Set the YaRN scale sqrt(t) or attention magnitude"""
-        return self._set(yarnAttnFactor=yarnAttnFactor)
-
-    def setYarnBetaFast(self, yarnBetaFast: float):
-        """Set the YaRN low correction dim or beta"""
-        return self._set(yarnBetaFast=yarnBetaFast)
-
-    def setYarnBetaSlow(self, yarnBetaSlow: float):
-        """Set the YaRN high correction dim or alpha"""
-        return self._set(yarnBetaSlow=yarnBetaSlow)
-
-    def setYarnOrigCtx(self, yarnOrigCtx: int):
-        """Set the YaRN original context size of model"""
-        return self._set(yarnOrigCtx=yarnOrigCtx)
-
-    def setDefragmentationThreshold(self, defragmentationThreshold: float):
-        """Set the KV cache defragmentation threshold"""
-        return self._set(defragmentationThreshold=defragmentationThreshold)
-
-    def setNumaStrategy(self, numaStrategy: str):
-        """Set optimization strategies that help on some NUMA systems (if available)"""
-        numaUpper = numaStrategy.upper()
-        numaStrategies = ["DISABLED", "DISTRIBUTE", "ISOLATE", "NUMA_CTL", "MIRROR"]
-        if numaUpper not in numaStrategies:
-            raise ValueError(
-                f"Invalid NUMA strategy: {numaUpper}. "
-                + f"Valid values are: {numaStrategies}"
-            )
-        return self._set(numaStrategy=numaStrategy)
-
-    def setRopeScalingType(self, ropeScalingType: str):
-        """Set the RoPE frequency scaling method, defaults to linear unless specified by the model"""
-        return self._set(ropeScalingType=ropeScalingType)
-
-    def setPoolingType(self, poolingType: bool):
-        """Set the pooling type for embeddings, use model default if unspecified"""
-        poolingTypeUpper = poolingType.upper()
-        poolingTypes = ["NONE", "MEAN", "CLS", "LAST"]
-        if poolingTypeUpper not in poolingTypes:
-            raise ValueError(
-                f"Invalid pooling type: {poolingType}. "
-                + f"Valid values are: {poolingTypes}"
-            )
-        return self._set(poolingType=poolingType)
-
-    def setModelDraft(self, modelDraft: str):
-        """Set the draft model for speculative decoding"""
-        return self._set(modelDraft=modelDraft)
-
-    def setModelAlias(self, modelAlias: str):
-        """Set a model alias"""
-        return self._set(modelAlias=modelAlias)
-
-    def setLookupCacheStaticFilePath(self, lookupCacheStaticFilePath: str):
-        """Set path to static lookup cache to use for lookup decoding (not updated by generation)"""
-        return self._set(lookupCacheStaticFilePath=lookupCacheStaticFilePath)
-
-    def setLookupCacheDynamicFilePath(self, lookupCacheDynamicFilePath: str):
-        """Set path to dynamic lookup cache to use for lookup decoding (updated by generation)"""
-        return self._set(lookupCacheDynamicFilePath=lookupCacheDynamicFilePath)
-
-    def setEmbedding(self, embedding: bool):
-        """Whether to load model with embedding support"""
-        return self._set(embedding=embedding)
-
-    def setFlashAttention(self, flashAttention: bool):
-        """Whether to enable Flash Attention"""
-        return self._set(flashAttention=flashAttention)
-
-    def setInputPrefixBos(self, inputPrefixBos: bool):
-        """Whether to add prefix BOS to user inputs, preceding the `--in-prefix` bool"""
-        return self._set(inputPrefixBos=inputPrefixBos)
-
-    def setUseMmap(self, useMmap: bool):
-        """Whether to use memory-map model (faster load but may increase pageouts if not using mlock)"""
-        return self._set(useMmap=useMmap)
-
-    def setUseMlock(self, useMlock: bool):
-        """Whether to force the system to keep model in RAM rather than swapping or compressing"""
-        return self._set(useMlock=useMlock)
-
-    def setNoKvOffload(self, noKvOffload: bool):
-        """Whether to disable KV offload"""
-        return self._set(noKvOffload=noKvOffload)
-
-    def setSystemPrompt(self, systemPrompt: bool):
-        """Set a system prompt to use"""
-        return self._set(systemPrompt=systemPrompt)
-
-    def setChatTemplate(self, chatTemplate: str):
-        """The chat template to use"""
-        return self._set(chatTemplate=chatTemplate)
-
-    # -------- INFERENCE SETTERS --------
-    def setInputPrefix(self, inputPrefix: str):
-        """Set the prompt to start generation with"""
-        return self._set(inputPrefix=inputPrefix)
-
-    def setInputSuffix(self, inputSuffix: str):
-        """Set a suffix for infilling"""
-        return self._set(inputSuffix=inputSuffix)
-
-    def setCachePrompt(self, cachePrompt: bool):
-        """Whether to remember the prompt to avoid reprocessing it"""
-        return self._set(cachePrompt=cachePrompt)
-
-    def setNPredict(self, nPredict: int):
-        """Set the number of tokens to predict"""
-        return self._set(nPredict=nPredict)
-
-    def setTopK(self, topK: int):
-        """Set top-k sampling"""
-        return self._set(topK=topK)
-
-    def setTopP(self, topP: float):
-        """Set top-p sampling"""
-        return self._set(topP=topP)
-
-    def setMinP(self, minP: float):
-        """Set min-p sampling"""
-        return self._set(minP=minP)
-
-    def setTfsZ(self, tfsZ: float):
-        """Set tail free sampling, parameter z"""
-        return self._set(tfsZ=tfsZ)
-
-    def setTypicalP(self, typicalP: float):
-        """Set locally typical sampling, parameter p"""
-        return self._set(typicalP=typicalP)
-
-    def setTemperature(self, temperature: float):
-        """Set the temperature"""
-        return self._set(temperature=temperature)
-
-    def setDynamicTemperatureRange(self, dynamicTemperatureRange: float):
-        """Set the dynamic temperature range"""
-        return self._set(dynamicTemperatureRange=dynamicTemperatureRange)
-
-    def setDynamicTemperatureExponent(self, dynamicTemperatureExponent: float):
-        """Set the dynamic temperature exponent"""
-        return self._set(dynamicTemperatureExponent=dynamicTemperatureExponent)
-
-    def setRepeatLastN(self, repeatLastN: int):
-        """Set the last n tokens to consider for penalties"""
-        return self._set(repeatLastN=repeatLastN)
-
-    def setRepeatPenalty(self, repeatPenalty: float):
-        """Set the penalty of repeated sequences of tokens"""
-        return self._set(repeatPenalty=repeatPenalty)
-
-    def setFrequencyPenalty(self, frequencyPenalty: float):
-        """Set the repetition alpha frequency penalty"""
-        return self._set(frequencyPenalty=frequencyPenalty)
-
-    def setPresencePenalty(self, presencePenalty: float):
-        """Set the repetition alpha presence penalty"""
-        return self._set(presencePenalty=presencePenalty)
-
-    def setMiroStat(self, miroStat: str):
-        """Set MiroStat sampling strategies."""
-        return self._set(miroStat=miroStat)
-
-    def setMiroStatTau(self, miroStatTau: float):
-        """Set the MiroStat target entropy, parameter tau"""
-        return self._set(miroStatTau=miroStatTau)
-
-    def setMiroStatEta(self, miroStatEta: float):
-        """Set the MiroStat learning rate, parameter eta"""
-        return self._set(miroStatEta=miroStatEta)
-
-    def setPenalizeNl(self, penalizeNl: bool):
-        """Whether to penalize newline tokens"""
-        return self._set(penalizeNl=penalizeNl)
-
-    def setNKeep(self, nKeep: int):
-        """Set the number of tokens to keep from the initial prompt"""
-        return self._set(nKeep=nKeep)
-
-    def setSeed(self, seed: int):
-        """Set the RNG seed"""
-        return self._set(seed=seed)
-
-    def setNProbs(self, nProbs: int):
-        """Set the amount top tokens probabilities to output if greater than 0."""
-        return self._set(nProbs=nProbs)
-
-    def setMinKeep(self, minKeep: int):
-        """Set the amount of tokens the samplers should return at least (0 = disabled)"""
-        return self._set(minKeep=minKeep)
-
-    def setGrammar(self, grammar: bool):
-        """Set BNF-like grammar to constrain generations"""
-        return self._set(grammar=grammar)
-
-    def setPenaltyPrompt(self, penaltyPrompt: str):
-        """Override which part of the prompt is penalized for repetition."""
-        return self._set(penaltyPrompt=penaltyPrompt)
-
-    def setIgnoreEos(self, ignoreEos: bool):
-        """Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)"""
-        return self._set(ignoreEos=ignoreEos)
-
-    def setDisableTokenIds(self, disableTokenIds: List[int]):
-        """Set the token ids to disable in the completion"""
-        return self._set(disableTokenIds=disableTokenIds)
-
-    def setStopStrings(self, stopStrings: List[str]):
-        """Set strings upon seeing which token generation is stopped"""
-        return self._set(stopStrings=stopStrings)
-
-    def setSamplers(self, samplers: List[str]):
-        """Set which samplers to use for token generation in the given order"""
-        return self._set(samplers=samplers)
-
-    def setUseChatTemplate(self, useChatTemplate: bool):
-        """Set whether generate should apply a chat template"""
-        return self._set(useChatTemplate=useChatTemplate)
-
-    # -------- JAVA SETTERS --------
-    def setTokenIdBias(self, tokenIdBias: Dict[int, float]):
-        """Set token id bias"""
-        return self._call_java("setTokenIdBias", tokenIdBias)
-
-    def setTokenBias(self, tokenBias: Dict[str, float]):
-        """Set token id bias"""
-        return self._call_java("setTokenBias", tokenBias)
-
-    def setLoraAdapters(self, loraAdapters: Dict[str, float]):
-        """Set token id bias"""
-        return self._call_java("setLoraAdapters", loraAdapters)
-
-    def getMetadata(self):
-        """Gets the metadata of the model"""
-        return self._call_java("getMetadata")
 
     @keyword_only
     def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFModel", java_model=None):
@@ -749,7 +248,13 @@ def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFMo
             classname=classname,
             java_model=java_model
         )
-        # self._setDefault()
+        self._setDefault(
+            useChatTemplate=True,
+            nCtx=4096,
+            nBatch=512,
+            embedding=False,
+            nPredict=100
+        )
 
     @staticmethod
     def loadSavedModel(folder, spark_session):
diff --git a/python/sparknlp/annotator/seq2seq/auto_gguf_vision_model.py b/python/sparknlp/annotator/seq2seq/auto_gguf_vision_model.py
new file mode 100755
index 00000000000000..b05150ed3b9905
--- /dev/null
+++ b/python/sparknlp/annotator/seq2seq/auto_gguf_vision_model.py
@@ -0,0 +1,333 @@
+#  Copyright 2017-2025 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the AutoGGUFVisionModel."""
+from sparknlp.common import *
+
+
+class AutoGGUFVisionModel(AnnotatorModel, HasBatchedAnnotate, HasLlamaCppProperties):
+    """Multimodal annotator that uses the llama.cpp library to generate text completions with large
+    language models. It supports ingesting images for captioning.
+
+    At the moment only CLIP based models are supported.
+
+    For settable parameters, and their explanations, see HasLlamaCppInferenceProperties,
+    HasLlamaCppModelProperties and refer to the llama.cpp documentation of
+    `server.cpp <https://github.com/ggerganov/llama.cpp/tree/7d5e8777ae1d21af99d4f95be10db4870720da91/examples/server>`__
+    for more information.
+
+    If the parameters are not set, the annotator will default to use the parameters provided by
+    the model.
+
+    This annotator expects a column of annotator type AnnotationImage for the image and
+    Annotation for the caption. Note that the image bytes in the image annotation need to be
+    raw image bytes without preprocessing. We provide the helper function
+    ImageAssembler.loadImagesAsBytes to load the image bytes from a directory.
+
+    Pretrained models can be loaded with ``pretrained`` of the companion object:
+
+    .. code-block:: python
+
+        autoGGUFVisionModel = AutoGGUFVisionModel.pretrained() \\
+            .setInputCols(["image", "document"]) \\
+            .setOutputCol("completions")
+
+
+    The default model is ``"llava_v1.5_7b_Q4_0_gguf"``, if no name is provided.
+
+    For available pretrained models please see the `Models Hub <https://sparknlp.org/models>`__.
+
+    For extended examples of usage, see the
+    `AutoGGUFVisionModelTest <https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTest.scala>`__
+    and the
+    `example notebook <https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb>`__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``IMAGE, DOCUMENT``    ``DOCUMENT``
+    ====================== ======================
+
+    Parameters
+    ----------
+    nThreads
+        Set the number of threads to use during generation
+    nThreadsDraft
+        Set the number of threads to use during draft generation
+    nThreadsBatch
+        Set the number of threads to use during batch and prompt processing
+    nThreadsBatchDraft
+        Set the number of threads to use during batch and prompt processing
+    nCtx
+        Set the size of the prompt context
+    nBatch
+        Set the logical batch size for prompt processing (must be >=32 to use BLAS)
+    nUbatch
+        Set the physical batch size for prompt processing (must be >=32 to use BLAS)
+    nDraft
+        Set the number of tokens to draft for speculative decoding
+    nChunks
+        Set the maximal number of chunks to process
+    nSequences
+        Set the number of sequences to decode
+    pSplit
+        Set the speculative decoding split probability
+    nGpuLayers
+        Set the number of layers to store in VRAM (-1 - use default)
+    nGpuLayersDraft
+        Set the number of layers to store in VRAM for the draft model (-1 - use default)
+    gpuSplitMode
+        Set how to split the model across GPUs
+    mainGpu
+        Set the main GPU that is used for scratch and small tensors.
+    tensorSplit
+        Set how split tensors should be distributed across GPUs
+    grpAttnN
+        Set the group-attention factor
+    grpAttnW
+        Set the group-attention width
+    ropeFreqBase
+        Set the RoPE base frequency, used by NTK-aware scaling
+    ropeFreqScale
+        Set the RoPE frequency scaling factor, expands context by a factor of 1/N
+    yarnExtFactor
+        Set the YaRN extrapolation mix factor
+    yarnAttnFactor
+        Set the YaRN scale sqrt(t) or attention magnitude
+    yarnBetaFast
+        Set the YaRN low correction dim or beta
+    yarnBetaSlow
+        Set the YaRN high correction dim or alpha
+    yarnOrigCtx
+        Set the YaRN original context size of model
+    defragmentationThreshold
+        Set the KV cache defragmentation threshold
+    numaStrategy
+        Set optimization strategies that help on some NUMA systems (if available)
+    ropeScalingType
+        Set the RoPE frequency scaling method, defaults to linear unless specified by the model
+    poolingType
+        Set the pooling type for embeddings, use model default if unspecified
+    modelDraft
+        Set the draft model for speculative decoding
+    modelAlias
+        Set a model alias
+    lookupCacheStaticFilePath
+        Set path to static lookup cache to use for lookup decoding (not updated by generation)
+    lookupCacheDynamicFilePath
+        Set path to dynamic lookup cache to use for lookup decoding (updated by generation)
+    embedding
+        Whether to load model with embedding support
+    flashAttention
+        Whether to enable Flash Attention
+    inputPrefixBos
+        Whether to add prefix BOS to user inputs, preceding the `--in-prefix` string
+    useMmap
+        Whether to use memory-map model (faster load but may increase pageouts if not using mlock)
+    useMlock
+        Whether to force the system to keep model in RAM rather than swapping or compressing
+    noKvOffload
+        Whether to disable KV offload
+    systemPrompt
+        Set a system prompt to use
+    chatTemplate
+        The chat template to use
+    inputPrefix
+        Set the prompt to start generation with
+    inputSuffix
+        Set a suffix for infilling
+    cachePrompt
+        Whether to remember the prompt to avoid reprocessing it
+    nPredict
+        Set the number of tokens to predict
+    topK
+        Set top-k sampling
+    topP
+        Set top-p sampling
+    minP
+        Set min-p sampling
+    tfsZ
+        Set tail free sampling, parameter z
+    typicalP
+        Set locally typical sampling, parameter p
+    temperature
+        Set the temperature
+    dynatempRange
+        Set the dynamic temperature range
+    dynatempExponent
+        Set the dynamic temperature exponent
+    repeatLastN
+        Set the last n tokens to consider for penalties
+    repeatPenalty
+        Set the penalty of repeated sequences of tokens
+    frequencyPenalty
+        Set the repetition alpha frequency penalty
+    presencePenalty
+        Set the repetition alpha presence penalty
+    miroStat
+        Set MiroStat sampling strategies.
+    mirostatTau
+        Set the MiroStat target entropy, parameter tau
+    mirostatEta
+        Set the MiroStat learning rate, parameter eta
+    penalizeNl
+        Whether to penalize newline tokens
+    nKeep
+        Set the number of tokens to keep from the initial prompt
+    seed
+        Set the RNG seed
+    nProbs
+        Set the amount top tokens probabilities to output if greater than 0.
+    minKeep
+        Set the amount of tokens the samplers should return at least (0 = disabled)
+    grammar
+        Set BNF-like grammar to constrain generations
+    penaltyPrompt
+        Override which part of the prompt is penalized for repetition.
+    ignoreEos
+        Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)
+    disableTokenIds
+        Set the token ids to disable in the completion
+    stopStrings
+        Set strings upon seeing which token generation is stopped
+    samplers
+        Set which samplers to use for token generation in the given order
+    useChatTemplate
+        Set whether or not generate should apply a chat template
+
+    Notes
+    -----
+    To use GPU inference with this annotator, make sure to use the Spark NLP GPU package and set
+    the number of GPU layers with the `setNGpuLayers` method.
+
+    When using larger models, we recommend adjusting GPU usage with `setNCtx` and `setNGpuLayers`
+    according to your hardware to avoid out-of-memory errors.
+
+    Examples
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> from pyspark.sql.functions import lit
+    >>> documentAssembler = DocumentAssembler() \\
+    ...     .setInputCol("caption") \\
+    ...     .setOutputCol("caption_document")
+    >>> imageAssembler = ImageAssembler() \\
+    ...     .setInputCol("image") \\
+    ...     .setOutputCol("image_assembler")
+    >>> imagesPath = "src/test/resources/image/"
+    >>> data = ImageAssembler \\
+    ...     .loadImagesAsBytes(spark, imagesPath) \\
+    ...     .withColumn("caption", lit("Caption this image.")) # Add a caption to each image.
+    >>> nPredict = 40
+    >>> model = AutoGGUFVisionModel.pretrained() \\
+    ...     .setInputCols(["caption_document", "image_assembler"]) \\
+    ...     .setOutputCol("completions") \\
+    ...     .setBatchSize(4) \\
+    ...     .setNGpuLayers(99) \\
+    ...     .setNCtx(4096) \\
+    ...     .setMinKeep(0) \\
+    ...     .setMinP(0.05) \\
+    ...     .setNPredict(nPredict) \\
+    ...     .setNProbs(0) \\
+    ...     .setPenalizeNl(False) \\
+    ...     .setRepeatLastN(256) \\
+    ...     .setRepeatPenalty(1.18) \\
+    ...     .setStopStrings(["</s>", "Llama:", "User:"]) \\
+    ...     .setTemperature(0.05) \\
+    ...     .setTfsZ(1) \\
+    ...     .setTypicalP(1) \\
+    ...     .setTopK(40) \\
+    ...     .setTopP(0.95)
+    >>> pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])
+    >>> pipeline.fit(data).transform(data) \\
+    ...     .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result") \\
+    ...     .show(truncate = False)
+    +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |image_name       |result                                                                                                                                                                                        |
+    +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+    |palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions]               |
+    |egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding]             |
+    |hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats]                            |
+    |hen.JPEG         |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] |
+    |ostrich.JPEG     |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to]              |
+    |junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out]  |
+    |bluetick.jpg     |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.]              |
+    |chihuahua.jpg    |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]|
+    |tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with]                                |
+    |ox.JPEG          |[ A large bull with horns is standing in a grassy field.]                                                                                                                                     |
+    +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------
+    """
+
+    name = "AutoGGUFVisionModel"
+    inputAnnotatorTypes = [AnnotatorType.IMAGE, AnnotatorType.DOCUMENT]
+    outputAnnotatorType = AnnotatorType.DOCUMENT
+
+    @keyword_only
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFVisionModel", java_model=None):
+        super(AutoGGUFVisionModel, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+
+        self._setDefault(
+            useChatTemplate=True,
+            nCtx=4096,
+            nBatch=512,
+            embedding=False,
+            nPredict=100
+        )
+
+    @staticmethod
+    def loadSavedModel(modelPath, mmprojPath, spark_session):
+        """Loads a locally saved modelPath.
+
+        Parameters
+        ----------
+        modelPath : str
+            Path to the modelPath file
+        mmprojPath : str
+            Path to the mmprojPath file
+        spark_session : pyspark.sql.SparkSession
+            The current SparkSession
+
+        Returns
+        -------
+        AutoGGUFVisionModel
+            The restored modelPath
+        """
+        from sparknlp.internal import _AutoGGUFVisionLoader
+        jModel = _AutoGGUFVisionLoader(modelPath, mmprojPath, spark_session._jsparkSession)._java_obj
+        return AutoGGUFVisionModel(java_model=jModel)
+
+    @staticmethod
+    def pretrained(name="llava_v1.5_7b_Q4_0_gguf", lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model, by default "llava_v1.5_7b_Q4_0_gguf"
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        AutoGGUFVisionModel
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(AutoGGUFVisionModel, name, lang, remote_loc)
diff --git a/python/sparknlp/base/image_assembler.py b/python/sparknlp/base/image_assembler.py
index cc8a9eb8c91253..61d4a283cdbb60 100644
--- a/python/sparknlp/base/image_assembler.py
+++ b/python/sparknlp/base/image_assembler.py
@@ -15,6 +15,8 @@
 
 from pyspark import keyword_only
 from pyspark.ml.param import TypeConverters, Params, Param
+from pyspark.sql import SparkSession, DataFrame
+from pyspark.sql.functions import regexp_replace, col
 
 from sparknlp.common import AnnotatorType
 from sparknlp.internal import AnnotatorTransformer
@@ -112,3 +114,59 @@ def setTextCol(self, value):
             Name of an optional input text column
         """
         return self._set(inputCol=value)
+
+    @classmethod
+    def loadImagesAsBytes(cls, spark: SparkSession, path: str):
+        """
+        Loads images from a given path and returns them as raw bytes, instead of the default
+        OpenCV-compatible format. Supported image types include JPEG, PNG, GIF, and BMP.
+
+        Multimodal inference with llama.cpp requires raw bytes as input.
+
+        Parameters
+        ----------
+        spark : SparkSession
+            The active SparkSession.
+        path : str
+            The path to the images. Supported image types are JPEG, PNG, GIF, and BMP.
+
+        Returns
+        -------
+        DataFrame
+            A DataFrame containing the images as raw bytes along with their metadata.
+        """
+
+        # Replace the path separator in the `origin` field and `path` column, so that they match
+        def replace_path(column_name: str):
+            return regexp_replace(col(column_name), ":///", ":/")
+
+        # Load the images as metadata with the default Spark image format
+        data = (
+            spark.read.format("image")
+            .option("dropInvalid", True)
+            .load(path)
+            .withColumn(
+                "image", col("image").withField("origin", replace_path("image.origin"))
+            )
+        )
+
+        # Load the images as raw binary files
+        image_bytes = (
+            spark.read.format("binaryFile")
+            .option("pathGlobFilter", "*.{jpeg,jpg,png,gif,bmp,JPEG,JPG,PNG,GIF,BMP}")
+            .option("dropInvalid", True)
+            .load(path)
+            .withColumn("path", replace_path("path"))
+        )
+
+        # Join the two datasets on the file path
+        df_joined = data.join(
+            image_bytes, data["image.origin"] == image_bytes["path"], "inner"
+        )
+
+        # Replace the `data` field of the `image` column with raw bytes
+        df_image_replaced = df_joined.withColumn(
+            "image", df_joined["image"].withField("data", df_joined["content"])
+        )
+
+        return df_image_replaced
diff --git a/python/sparknlp/common/properties.py b/python/sparknlp/common/properties.py
index f5d7e55cfbdccb..7930fe1228d2f5 100644
--- a/python/sparknlp/common/properties.py
+++ b/python/sparknlp/common/properties.py
@@ -12,6 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 """Contains classes for Annotator properties."""
+from typing import List, Dict
 
 from pyspark.ml.param import Param, Params, TypeConverters
 
@@ -601,133 +602,637 @@ class HasGeneratorProperties:
                              typeConverter=TypeConverters.toInt)
 
 
-def setTask(self, value):
-    """Sets the transformer's task, e.g. ``summarize:``.
+    def setTask(self, value):
+        """Sets the transformer's task, e.g. ``summarize:``.
 
-    Parameters
-    ----------
-    value : str
-        The transformer's task
-    """
-    return self._set(task=value)
+        Parameters
+        ----------
+        value : str
+            The transformer's task
+        """
+        return self._set(task=value)
+
+
+    def setMinOutputLength(self, value):
+        """Sets minimum length of the sequence to be generated.
+
+        Parameters
+        ----------
+        value : int
+            Minimum length of the sequence to be generated
+        """
+        return self._set(minOutputLength=value)
+
+
+    def setMaxOutputLength(self, value):
+        """Sets maximum length of output text.
+
+        Parameters
+        ----------
+        value : int
+            Maximum length of output text
+        """
+        return self._set(maxOutputLength=value)
+
+
+    def setDoSample(self, value):
+        """Sets whether or not to use sampling, use greedy decoding otherwise.
+
+        Parameters
+        ----------
+        value : bool
+            Whether or not to use sampling; use greedy decoding otherwise
+        """
+        return self._set(doSample=value)
+
+
+    def setTemperature(self, value):
+        """Sets the value used to module the next token probabilities.
+
+        Parameters
+        ----------
+        value : float
+            The value used to module the next token probabilities
+        """
+        return self._set(temperature=value)
+
+
+    def setTopK(self, value):
+        """Sets the number of highest probability vocabulary tokens to keep for
+        top-k-filtering.
+
+        Parameters
+        ----------
+        value : int
+            Number of highest probability vocabulary tokens to keep
+        """
+        return self._set(topK=value)
 
 
-def setMinOutputLength(self, value):
-    """Sets minimum length of the sequence to be generated.
+    def setTopP(self, value):
+        """Sets the top cumulative probability for vocabulary tokens.
 
-    Parameters
-    ----------
-    value : int
-        Minimum length of the sequence to be generated
-    """
-    return self._set(minOutputLength=value)
+        If set to float < 1, only the most probable tokens with probabilities
+        that add up to ``topP`` or higher are kept for generation.
 
+        Parameters
+        ----------
+        value : float
+            Cumulative probability for vocabulary tokens
+        """
+        return self._set(topP=value)
 
-def setMaxOutputLength(self, value):
-    """Sets maximum length of output text.
 
-    Parameters
-    ----------
-    value : int
-        Maximum length of output text
-    """
-    return self._set(maxOutputLength=value)
+    def setRepetitionPenalty(self, value):
+        """Sets the parameter for repetition penalty. 1.0 means no penalty.
 
+        Parameters
+        ----------
+        value : float
+            The repetition penalty
 
-def setDoSample(self, value):
-    """Sets whether or not to use sampling, use greedy decoding otherwise.
+        References
+        ----------
+        See `Ctrl: A Conditional Transformer Language Model For Controllable
+        Generation <https://arxiv.org/pdf/1909.05858.pdf>`__ for more details.
+        """
+        return self._set(repetitionPenalty=value)
 
-    Parameters
-    ----------
-    value : bool
-        Whether or not to use sampling; use greedy decoding otherwise
-    """
-    return self._set(doSample=value)
 
+    def setNoRepeatNgramSize(self, value):
+        """Sets size of n-grams that can only occur once.
 
-def setTemperature(self, value):
-    """Sets the value used to module the next token probabilities.
+        If set to int > 0, all ngrams of that size can only occur once.
 
-    Parameters
-    ----------
-    value : float
-        The value used to module the next token probabilities
-    """
-    return self._set(temperature=value)
+        Parameters
+        ----------
+        value : int
+            N-gram size can only occur once
+        """
+        return self._set(noRepeatNgramSize=value)
 
 
-def setTopK(self, value):
-    """Sets the number of highest probability vocabulary tokens to keep for
-    top-k-filtering.
+    def setBeamSize(self, value):
+        """Sets the number of beam size for beam search.
 
-    Parameters
-    ----------
-    value : int
-        Number of highest probability vocabulary tokens to keep
-    """
-    return self._set(topK=value)
+        Parameters
+        ----------
+        value : int
+            Number of beam size for beam search
+        """
+        return self._set(beamSize=value)
 
 
-def setTopP(self, value):
-    """Sets the top cumulative probability for vocabulary tokens.
+    def setNReturnSequences(self, value):
+        """Sets the number of sequences to return from the beam search.
 
-    If set to float < 1, only the most probable tokens with probabilities
-    that add up to ``topP`` or higher are kept for generation.
+        Parameters
+        ----------
+        value : int
+            Number of sequences to return
+        """
+        return self._set(nReturnSequences=value)
 
-    Parameters
-    ----------
-    value : float
-        Cumulative probability for vocabulary tokens
-    """
-    return self._set(topP=value)
 
+class HasLlamaCppProperties:
+    # -------- MODEl PARAMETERS --------
+    nThreads = Param(Params._dummy(), "nThreads", "Set the number of threads to use during generation",
+                     typeConverter=TypeConverters.toInt)
+    nThreadsDraft = Param(Params._dummy(), "nThreadsDraft", "Set the number of threads to use during draft generation",
+                          typeConverter=TypeConverters.toInt)
+    nThreadsBatch = Param(Params._dummy(), "nThreadsBatch",
+                          "Set the number of threads to use during batch and prompt processing",
+                          typeConverter=TypeConverters.toInt)
+    nThreadsBatchDraft = Param(Params._dummy(), "nThreadsBatchDraft",
+                               "Set the number of threads to use during batch and prompt processing",
+                               typeConverter=TypeConverters.toInt)
+    nCtx = Param(Params._dummy(), "nCtx", "Set the size of the prompt context", typeConverter=TypeConverters.toInt)
+    nBatch = Param(Params._dummy(), "nBatch",
+                   "Set the logical batch size for prompt processing (must be >=32 to use BLAS)",
+                   typeConverter=TypeConverters.toInt)
+    nUbatch = Param(Params._dummy(), "nUbatch",
+                    "Set the physical batch size for prompt processing (must be >=32 to use BLAS)",
+                    typeConverter=TypeConverters.toInt)
+    nDraft = Param(Params._dummy(), "nDraft", "Set the number of tokens to draft for speculative decoding",
+                   typeConverter=TypeConverters.toInt)
+    nChunks = Param(Params._dummy(), "nChunks", "Set the maximal number of chunks to process",
+                    typeConverter=TypeConverters.toInt)
+    nSequences = Param(Params._dummy(), "nSequences", "Set the number of sequences to decode",
+                       typeConverter=TypeConverters.toInt)
+    pSplit = Param(Params._dummy(), "pSplit", "Set the speculative decoding split probability",
+                   typeConverter=TypeConverters.toFloat)
+    nGpuLayers = Param(Params._dummy(), "nGpuLayers", "Set the number of layers to store in VRAM (-1 - use default)",
+                       typeConverter=TypeConverters.toInt)
+    nGpuLayersDraft = Param(Params._dummy(), "nGpuLayersDraft",
+                            "Set the number of layers to store in VRAM for the draft model (-1 - use default)",
+                            typeConverter=TypeConverters.toInt)
+    # Set how to split the model across GPUs
+    #
+    #   - NONE: No GPU split
+    #   - LAYER: Split the model across GPUs by layer
+    #   - ROW: Split the model across GPUs by rows
+    gpuSplitMode = Param(Params._dummy(), "gpuSplitMode", "Set how to split the model across GPUs",
+                         typeConverter=TypeConverters.toString)
+    mainGpu = Param(Params._dummy(), "mainGpu", "Set the main GPU that is used for scratch and small tensors.",
+                    typeConverter=TypeConverters.toInt)
+    tensorSplit = Param(Params._dummy(), "tensorSplit", "Set how split tensors should be distributed across GPUs",
+                        typeConverter=TypeConverters.toListFloat)
+    grpAttnN = Param(Params._dummy(), "grpAttnN", "Set the group-attention factor", typeConverter=TypeConverters.toInt)
+    grpAttnW = Param(Params._dummy(), "grpAttnW", "Set the group-attention width", typeConverter=TypeConverters.toInt)
+    ropeFreqBase = Param(Params._dummy(), "ropeFreqBase", "Set the RoPE base frequency, used by NTK-aware scaling",
+                         typeConverter=TypeConverters.toFloat)
+    ropeFreqScale = Param(Params._dummy(), "ropeFreqScale",
+                          "Set the RoPE frequency scaling factor, expands context by a factor of 1/N",
+                          typeConverter=TypeConverters.toFloat)
+    yarnExtFactor = Param(Params._dummy(), "yarnExtFactor", "Set the YaRN extrapolation mix factor",
+                          typeConverter=TypeConverters.toFloat)
+    yarnAttnFactor = Param(Params._dummy(), "yarnAttnFactor", "Set the YaRN scale sqrt(t) or attention magnitude",
+                           typeConverter=TypeConverters.toFloat)
+    yarnBetaFast = Param(Params._dummy(), "yarnBetaFast", "Set the YaRN low correction dim or beta",
+                         typeConverter=TypeConverters.toFloat)
+    yarnBetaSlow = Param(Params._dummy(), "yarnBetaSlow", "Set the YaRN high correction dim or alpha",
+                         typeConverter=TypeConverters.toFloat)
+    yarnOrigCtx = Param(Params._dummy(), "yarnOrigCtx", "Set the YaRN original context size of model",
+                        typeConverter=TypeConverters.toInt)
+    defragmentationThreshold = Param(Params._dummy(), "defragmentationThreshold",
+                                     "Set the KV cache defragmentation threshold", typeConverter=TypeConverters.toFloat)
+    # Set optimization strategies that help on some NUMA systems (if available)
+    #
+    # Available Strategies:
+    #
+    #   - DISABLED: No NUMA optimizations
+    #   - DISTRIBUTE: Spread execution evenly over all
+    #   - ISOLATE: Only spawn threads on CPUs on the node that execution started on
+    #   - NUMA_CTL: Use the CPU map provided by numactl
+    #   - MIRROR: Mirrors the model across NUMA nodes
+    numaStrategy = Param(Params._dummy(), "numaStrategy",
+                         "Set optimization strategies that help on some NUMA systems (if available)",
+                         typeConverter=TypeConverters.toString)
+    # Set the RoPE frequency scaling method, defaults to linear unless specified by the model.
+    #
+    #   - UNSPECIFIED: Don't use any scaling
+    #   - LINEAR: Linear scaling
+    #   - YARN: YaRN RoPE scaling
+    ropeScalingType = Param(Params._dummy(), "ropeScalingType",
+                            "Set the RoPE frequency scaling method, defaults to linear unless specified by the model",
+                            typeConverter=TypeConverters.toString)
+    # Set the pooling type for embeddings, use model default if unspecified
+    #
+    #   - 0 NONE: Don't use any pooling
+    #   - 1 MEAN: Mean Pooling
+    #   - 2 CLS: CLS Pooling
+    poolingType = Param(Params._dummy(), "poolingType",
+                        "Set the pooling type for embeddings, use model default if unspecified",
+                        typeConverter=TypeConverters.toString)
+    modelDraft = Param(Params._dummy(), "modelDraft", "Set the draft model for speculative decoding",
+                       typeConverter=TypeConverters.toString)
+    modelAlias = Param(Params._dummy(), "modelAlias", "Set a model alias", typeConverter=TypeConverters.toString)
+    lookupCacheStaticFilePath = Param(Params._dummy(), "lookupCacheStaticFilePath",
+                                      "Set path to static lookup cache to use for lookup decoding (not updated by generation)",
+                                      typeConverter=TypeConverters.toString)
+    lookupCacheDynamicFilePath = Param(Params._dummy(), "lookupCacheDynamicFilePath",
+                                       "Set path to dynamic lookup cache to use for lookup decoding (updated by generation)",
+                                       typeConverter=TypeConverters.toString)
+    # loraAdapters = new StructFeature[Map[String, Float]](this, "loraAdapters")
+    embedding = Param(Params._dummy(), "embedding", "Whether to load model with embedding support",
+                      typeConverter=TypeConverters.toBoolean)
+    flashAttention = Param(Params._dummy(), "flashAttention", "Whether to enable Flash Attention",
+                           typeConverter=TypeConverters.toBoolean)
+    inputPrefixBos = Param(Params._dummy(), "inputPrefixBos",
+                           "Whether to add prefix BOS to user inputs, preceding the `--in-prefix` string",
+                           typeConverter=TypeConverters.toBoolean)
+    useMmap = Param(Params._dummy(), "useMmap",
+                    "Whether to use memory-map model (faster load but may increase pageouts if not using mlock)",
+                    typeConverter=TypeConverters.toBoolean)
+    useMlock = Param(Params._dummy(), "useMlock",
+                     "Whether to force the system to keep model in RAM rather than swapping or compressing",
+                     typeConverter=TypeConverters.toBoolean)
+    noKvOffload = Param(Params._dummy(), "noKvOffload", "Whether to disable KV offload",
+                        typeConverter=TypeConverters.toBoolean)
+    systemPrompt = Param(Params._dummy(), "systemPrompt", "Set a system prompt to use",
+                         typeConverter=TypeConverters.toString)
+    chatTemplate = Param(Params._dummy(), "chatTemplate", "The chat template to use",
+                         typeConverter=TypeConverters.toString)
+
+    # -------- INFERENCE PARAMETERS --------
+    inputPrefix = Param(Params._dummy(), "inputPrefix", "Set the prompt to start generation with",
+                        typeConverter=TypeConverters.toString)
+    inputSuffix = Param(Params._dummy(), "inputSuffix", "Set a suffix for infilling",
+                        typeConverter=TypeConverters.toString)
+    cachePrompt = Param(Params._dummy(), "cachePrompt", "Whether to remember the prompt to avoid reprocessing it",
+                        typeConverter=TypeConverters.toBoolean)
+    nPredict = Param(Params._dummy(), "nPredict", "Set the number of tokens to predict",
+                     typeConverter=TypeConverters.toInt)
+    topK = Param(Params._dummy(), "topK", "Set top-k sampling", typeConverter=TypeConverters.toInt)
+    topP = Param(Params._dummy(), "topP", "Set top-p sampling", typeConverter=TypeConverters.toFloat)
+    minP = Param(Params._dummy(), "minP", "Set min-p sampling", typeConverter=TypeConverters.toFloat)
+    tfsZ = Param(Params._dummy(), "tfsZ", "Set tail free sampling, parameter z", typeConverter=TypeConverters.toFloat)
+    typicalP = Param(Params._dummy(), "typicalP", "Set locally typical sampling, parameter p",
+                     typeConverter=TypeConverters.toFloat)
+    temperature = Param(Params._dummy(), "temperature", "Set the temperature", typeConverter=TypeConverters.toFloat)
+    dynamicTemperatureRange = Param(Params._dummy(), "dynatempRange", "Set the dynamic temperature range",
+                                    typeConverter=TypeConverters.toFloat)
+    dynamicTemperatureExponent = Param(Params._dummy(), "dynatempExponent", "Set the dynamic temperature exponent",
+                                       typeConverter=TypeConverters.toFloat)
+    repeatLastN = Param(Params._dummy(), "repeatLastN", "Set the last n tokens to consider for penalties",
+                        typeConverter=TypeConverters.toInt)
+    repeatPenalty = Param(Params._dummy(), "repeatPenalty", "Set the penalty of repeated sequences of tokens",
+                          typeConverter=TypeConverters.toFloat)
+    frequencyPenalty = Param(Params._dummy(), "frequencyPenalty", "Set the repetition alpha frequency penalty",
+                             typeConverter=TypeConverters.toFloat)
+    presencePenalty = Param(Params._dummy(), "presencePenalty", "Set the repetition alpha presence penalty",
+                            typeConverter=TypeConverters.toFloat)
+    miroStat = Param(Params._dummy(), "miroStat", "Set MiroStat sampling strategies.",
+                     typeConverter=TypeConverters.toString)
+    miroStatTau = Param(Params._dummy(), "mirostatTau", "Set the MiroStat target entropy, parameter tau",
+                        typeConverter=TypeConverters.toFloat)
+    miroStatEta = Param(Params._dummy(), "mirostatEta", "Set the MiroStat learning rate, parameter eta",
+                        typeConverter=TypeConverters.toFloat)
+    penalizeNl = Param(Params._dummy(), "penalizeNl", "Whether to penalize newline tokens",
+                       typeConverter=TypeConverters.toBoolean)
+    nKeep = Param(Params._dummy(), "nKeep", "Set the number of tokens to keep from the initial prompt",
+                  typeConverter=TypeConverters.toInt)
+    seed = Param(Params._dummy(), "seed", "Set the RNG seed", typeConverter=TypeConverters.toInt)
+    nProbs = Param(Params._dummy(), "nProbs", "Set the amount top tokens probabilities to output if greater than 0.",
+                   typeConverter=TypeConverters.toInt)
+    minKeep = Param(Params._dummy(), "minKeep",
+                    "Set the amount of tokens the samplers should return at least (0 = disabled)",
+                    typeConverter=TypeConverters.toInt)
+    grammar = Param(Params._dummy(), "grammar", "Set BNF-like grammar to constrain generations",
+                    typeConverter=TypeConverters.toString)
+    penaltyPrompt = Param(Params._dummy(), "penaltyPrompt",
+                          "Override which part of the prompt is penalized for repetition.",
+                          typeConverter=TypeConverters.toString)
+    ignoreEos = Param(Params._dummy(), "ignoreEos",
+                      "Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)",
+                      typeConverter=TypeConverters.toBoolean)
+    disableTokenIds = Param(Params._dummy(), "disableTokenIds", "Set the token ids to disable in the completion",
+                            typeConverter=TypeConverters.toListInt)
+    stopStrings = Param(Params._dummy(), "stopStrings", "Set strings upon seeing which token generation is stopped",
+                        typeConverter=TypeConverters.toListString)
+    samplers = Param(Params._dummy(), "samplers", "Set which samplers to use for token generation in the given order",
+                     typeConverter=TypeConverters.toListString)
+    useChatTemplate = Param(Params._dummy(), "useChatTemplate",
+                            "Set whether or not generate should apply a chat template",
+                            typeConverter=TypeConverters.toBoolean)
+
+    # -------- MODEL SETTERS --------
+    def setNThreads(self, nThreads: int):
+        """Set the number of threads to use during generation"""
+        return self._set(nThreads=nThreads)
+
+    def setNThreadsDraft(self, nThreadsDraft: int):
+        """Set the number of threads to use during draft generation"""
+        return self._set(nThreadsDraft=nThreadsDraft)
+
+    def setNThreadsBatch(self, nThreadsBatch: int):
+        """Set the number of threads to use during batch and prompt processing"""
+        return self._set(nThreadsBatch=nThreadsBatch)
+
+    def setNThreadsBatchDraft(self, nThreadsBatchDraft: int):
+        """Set the number of threads to use during batch and prompt processing"""
+        return self._set(nThreadsBatchDraft=nThreadsBatchDraft)
+
+    def setNCtx(self, nCtx: int):
+        """Set the size of the prompt context"""
+        return self._set(nCtx=nCtx)
+
+    def setNBatch(self, nBatch: int):
+        """Set the logical batch size for prompt processing (must be >=32 to use BLAS)"""
+        return self._set(nBatch=nBatch)
+
+    def setNUbatch(self, nUbatch: int):
+        """Set the physical batch size for prompt processing (must be >=32 to use BLAS)"""
+        return self._set(nUbatch=nUbatch)
+
+    def setNDraft(self, nDraft: int):
+        """Set the number of tokens to draft for speculative decoding"""
+        return self._set(nDraft=nDraft)
+
+    def setNChunks(self, nChunks: int):
+        """Set the maximal number of chunks to process"""
+        return self._set(nChunks=nChunks)
+
+    def setNSequences(self, nSequences: int):
+        """Set the number of sequences to decode"""
+        return self._set(nSequences=nSequences)
+
+    def setPSplit(self, pSplit: float):
+        """Set the speculative decoding split probability"""
+        return self._set(pSplit=pSplit)
+
+    def setNGpuLayers(self, nGpuLayers: int):
+        """Set the number of layers to store in VRAM (-1 - use default)"""
+        return self._set(nGpuLayers=nGpuLayers)
+
+    def setNGpuLayersDraft(self, nGpuLayersDraft: int):
+        """Set the number of layers to store in VRAM for the draft model (-1 - use default)"""
+        return self._set(nGpuLayersDraft=nGpuLayersDraft)
+
+    def setGpuSplitMode(self, gpuSplitMode: str):
+        """Set how to split the model across GPUs"""
+        return self._set(gpuSplitMode=gpuSplitMode)
+
+    def setMainGpu(self, mainGpu: int):
+        """Set the main GPU that is used for scratch and small tensors."""
+        return self._set(mainGpu=mainGpu)
+
+    def setTensorSplit(self, tensorSplit: List[float]):
+        """Set how split tensors should be distributed across GPUs"""
+        return self._set(tensorSplit=tensorSplit)
+
+    def setGrpAttnN(self, grpAttnN: int):
+        """Set the group-attention factor"""
+        return self._set(grpAttnN=grpAttnN)
+
+    def setGrpAttnW(self, grpAttnW: int):
+        """Set the group-attention width"""
+        return self._set(grpAttnW=grpAttnW)
+
+    def setRopeFreqBase(self, ropeFreqBase: float):
+        """Set the RoPE base frequency, used by NTK-aware scaling"""
+        return self._set(ropeFreqBase=ropeFreqBase)
+
+    def setRopeFreqScale(self, ropeFreqScale: float):
+        """Set the RoPE frequency scaling factor, expands context by a factor of 1/N"""
+        return self._set(ropeFreqScale=ropeFreqScale)
+
+    def setYarnExtFactor(self, yarnExtFactor: float):
+        """Set the YaRN extrapolation mix factor"""
+        return self._set(yarnExtFactor=yarnExtFactor)
+
+    def setYarnAttnFactor(self, yarnAttnFactor: float):
+        """Set the YaRN scale sqrt(t) or attention magnitude"""
+        return self._set(yarnAttnFactor=yarnAttnFactor)
+
+    def setYarnBetaFast(self, yarnBetaFast: float):
+        """Set the YaRN low correction dim or beta"""
+        return self._set(yarnBetaFast=yarnBetaFast)
+
+    def setYarnBetaSlow(self, yarnBetaSlow: float):
+        """Set the YaRN high correction dim or alpha"""
+        return self._set(yarnBetaSlow=yarnBetaSlow)
+
+    def setYarnOrigCtx(self, yarnOrigCtx: int):
+        """Set the YaRN original context size of model"""
+        return self._set(yarnOrigCtx=yarnOrigCtx)
+
+    def setDefragmentationThreshold(self, defragmentationThreshold: float):
+        """Set the KV cache defragmentation threshold"""
+        return self._set(defragmentationThreshold=defragmentationThreshold)
 
-def setRepetitionPenalty(self, value):
-    """Sets the parameter for repetition penalty. 1.0 means no penalty.
+    def setNumaStrategy(self, numaStrategy: str):
+        """Set optimization strategies that help on some NUMA systems (if available)"""
+        numaUpper = numaStrategy.upper()
+        numaStrategies = ["DISABLED", "DISTRIBUTE", "ISOLATE", "NUMA_CTL", "MIRROR"]
+        if numaUpper not in numaStrategies:
+            raise ValueError(
+                f"Invalid NUMA strategy: {numaUpper}. "
+                + f"Valid values are: {numaStrategies}"
+            )
+        return self._set(numaStrategy=numaStrategy)
+
+    def setRopeScalingType(self, ropeScalingType: str):
+        """Set the RoPE frequency scaling method, defaults to linear unless specified by the model"""
+        return self._set(ropeScalingType=ropeScalingType)
+
+    def setPoolingType(self, poolingType: str):
+        """Set the pooling type for embeddings, use model default if unspecified"""
+        poolingTypeUpper = poolingType.upper()
+        poolingTypes = ["NONE", "MEAN", "CLS", "LAST"]
+        if poolingTypeUpper not in poolingTypes:
+            raise ValueError(
+                f"Invalid pooling type: {poolingType}. "
+                + f"Valid values are: {poolingTypes}"
+            )
+        return self._set(poolingType=poolingType)
+
+    def setModelDraft(self, modelDraft: str):
+        """Set the draft model for speculative decoding"""
+        return self._set(modelDraft=modelDraft)
+
+    def setModelAlias(self, modelAlias: str):
+        """Set a model alias"""
+        return self._set(modelAlias=modelAlias)
+
+    def setLookupCacheStaticFilePath(self, lookupCacheStaticFilePath: str):
+        """Set path to static lookup cache to use for lookup decoding (not updated by generation)"""
+        return self._set(lookupCacheStaticFilePath=lookupCacheStaticFilePath)
+
+    def setLookupCacheDynamicFilePath(self, lookupCacheDynamicFilePath: str):
+        """Set path to dynamic lookup cache to use for lookup decoding (updated by generation)"""
+        return self._set(lookupCacheDynamicFilePath=lookupCacheDynamicFilePath)
+
+    def setEmbedding(self, embedding: bool):
+        """Whether to load model with embedding support"""
+        return self._set(embedding=embedding)
+
+    def setFlashAttention(self, flashAttention: bool):
+        """Whether to enable Flash Attention"""
+        return self._set(flashAttention=flashAttention)
+
+    def setInputPrefixBos(self, inputPrefixBos: bool):
+        """Whether to add prefix BOS to user inputs, preceding the `--in-prefix` bool"""
+        return self._set(inputPrefixBos=inputPrefixBos)
+
+    def setUseMmap(self, useMmap: bool):
+        """Whether to use memory-map model (faster load but may increase pageouts if not using mlock)"""
+        return self._set(useMmap=useMmap)
+
+    def setUseMlock(self, useMlock: bool):
+        """Whether to force the system to keep model in RAM rather than swapping or compressing"""
+        return self._set(useMlock=useMlock)
+
+    def setNoKvOffload(self, noKvOffload: bool):
+        """Whether to disable KV offload"""
+        return self._set(noKvOffload=noKvOffload)
+
+    def setSystemPrompt(self, systemPrompt: bool):
+        """Set a system prompt to use"""
+        return self._set(systemPrompt=systemPrompt)
+
+    def setChatTemplate(self, chatTemplate: str):
+        """The chat template to use"""
+        return self._set(chatTemplate=chatTemplate)
+
+    # -------- INFERENCE SETTERS --------
+    def setInputPrefix(self, inputPrefix: str):
+        """Set the prompt to start generation with"""
+        return self._set(inputPrefix=inputPrefix)
 
-    Parameters
-    ----------
-    value : float
-        The repetition penalty
+    def setInputSuffix(self, inputSuffix: str):
+        """Set a suffix for infilling"""
+        return self._set(inputSuffix=inputSuffix)
 
-    References
-    ----------
-    See `Ctrl: A Conditional Transformer Language Model For Controllable
-    Generation <https://arxiv.org/pdf/1909.05858.pdf>`__ for more details.
-    """
-    return self._set(repetitionPenalty=value)
+    def setCachePrompt(self, cachePrompt: bool):
+        """Whether to remember the prompt to avoid reprocessing it"""
+        return self._set(cachePrompt=cachePrompt)
 
+    def setNPredict(self, nPredict: int):
+        """Set the number of tokens to predict"""
+        return self._set(nPredict=nPredict)
 
-def setNoRepeatNgramSize(self, value):
-    """Sets size of n-grams that can only occur once.
+    def setTopK(self, topK: int):
+        """Set top-k sampling"""
+        return self._set(topK=topK)
 
-    If set to int > 0, all ngrams of that size can only occur once.
+    def setTopP(self, topP: float):
+        """Set top-p sampling"""
+        return self._set(topP=topP)
 
-    Parameters
-    ----------
-    value : int
-        N-gram size can only occur once
-    """
-    return self._set(noRepeatNgramSize=value)
+    def setMinP(self, minP: float):
+        """Set min-p sampling"""
+        return self._set(minP=minP)
+
+    def setTfsZ(self, tfsZ: float):
+        """Set tail free sampling, parameter z"""
+        return self._set(tfsZ=tfsZ)
+
+    def setTypicalP(self, typicalP: float):
+        """Set locally typical sampling, parameter p"""
+        return self._set(typicalP=typicalP)
+
+    def setTemperature(self, temperature: float):
+        """Set the temperature"""
+        return self._set(temperature=temperature)
+
+    def setDynamicTemperatureRange(self, dynamicTemperatureRange: float):
+        """Set the dynamic temperature range"""
+        return self._set(dynamicTemperatureRange=dynamicTemperatureRange)
+
+    def setDynamicTemperatureExponent(self, dynamicTemperatureExponent: float):
+        """Set the dynamic temperature exponent"""
+        return self._set(dynamicTemperatureExponent=dynamicTemperatureExponent)
+
+    def setRepeatLastN(self, repeatLastN: int):
+        """Set the last n tokens to consider for penalties"""
+        return self._set(repeatLastN=repeatLastN)
+
+    def setRepeatPenalty(self, repeatPenalty: float):
+        """Set the penalty of repeated sequences of tokens"""
+        return self._set(repeatPenalty=repeatPenalty)
+
+    def setFrequencyPenalty(self, frequencyPenalty: float):
+        """Set the repetition alpha frequency penalty"""
+        return self._set(frequencyPenalty=frequencyPenalty)
+
+    def setPresencePenalty(self, presencePenalty: float):
+        """Set the repetition alpha presence penalty"""
+        return self._set(presencePenalty=presencePenalty)
+
+    def setMiroStat(self, miroStat: str):
+        """Set MiroStat sampling strategies."""
+        return self._set(miroStat=miroStat)
+
+    def setMiroStatTau(self, miroStatTau: float):
+        """Set the MiroStat target entropy, parameter tau"""
+        return self._set(miroStatTau=miroStatTau)
+
+    def setMiroStatEta(self, miroStatEta: float):
+        """Set the MiroStat learning rate, parameter eta"""
+        return self._set(miroStatEta=miroStatEta)
+
+    def setPenalizeNl(self, penalizeNl: bool):
+        """Whether to penalize newline tokens"""
+        return self._set(penalizeNl=penalizeNl)
+
+    def setNKeep(self, nKeep: int):
+        """Set the number of tokens to keep from the initial prompt"""
+        return self._set(nKeep=nKeep)
+
+    def setSeed(self, seed: int):
+        """Set the RNG seed"""
+        return self._set(seed=seed)
+
+    def setNProbs(self, nProbs: int):
+        """Set the amount top tokens probabilities to output if greater than 0."""
+        return self._set(nProbs=nProbs)
+
+    def setMinKeep(self, minKeep: int):
+        """Set the amount of tokens the samplers should return at least (0 = disabled)"""
+        return self._set(minKeep=minKeep)
+
+    def setGrammar(self, grammar: bool):
+        """Set BNF-like grammar to constrain generations"""
+        return self._set(grammar=grammar)
+
+    def setPenaltyPrompt(self, penaltyPrompt: str):
+        """Override which part of the prompt is penalized for repetition."""
+        return self._set(penaltyPrompt=penaltyPrompt)
 
+    def setIgnoreEos(self, ignoreEos: bool):
+        """Set whether to ignore end of stream token and continue generating (implies --logit-bias 2-inf)"""
+        return self._set(ignoreEos=ignoreEos)
 
-def setBeamSize(self, value):
-    """Sets the number of beam size for beam search.
+    def setDisableTokenIds(self, disableTokenIds: List[int]):
+        """Set the token ids to disable in the completion"""
+        return self._set(disableTokenIds=disableTokenIds)
 
-    Parameters
-    ----------
-    value : int
-        Number of beam size for beam search
-    """
-    return self._set(beamSize=value)
+    def setStopStrings(self, stopStrings: List[str]):
+        """Set strings upon seeing which token generation is stopped"""
+        return self._set(stopStrings=stopStrings)
 
+    def setSamplers(self, samplers: List[str]):
+        """Set which samplers to use for token generation in the given order"""
+        return self._set(samplers=samplers)
 
-def setNReturnSequences(self, value):
-    """Sets the number of sequences to return from the beam search.
+    def setUseChatTemplate(self, useChatTemplate: bool):
+        """Set whether generate should apply a chat template"""
+        return self._set(useChatTemplate=useChatTemplate)
 
-    Parameters
-    ----------
-    value : int
-        Number of sequences to return
-    """
-    return self._set(nReturnSequences=value)
+    # -------- JAVA SETTERS --------
+    def setTokenIdBias(self, tokenIdBias: Dict[int, float]):
+        """Set token id bias"""
+        return self._call_java("setTokenIdBias", tokenIdBias)
+
+    def setTokenBias(self, tokenBias: Dict[str, float]):
+        """Set token id bias"""
+        return self._call_java("setTokenBias", tokenBias)
+
+    def setLoraAdapters(self, loraAdapters: Dict[str, float]):
+        """Set token id bias"""
+        return self._call_java("setLoraAdapters", loraAdapters)
+
+    def getMetadata(self):
+        """Gets the metadata of the model"""
+        return self._call_java("getMetadata")
diff --git a/python/sparknlp/internal/__init__.py b/python/sparknlp/internal/__init__.py
index 4cb5321e8a8691..44504cb749151b 100644
--- a/python/sparknlp/internal/__init__.py
+++ b/python/sparknlp/internal/__init__.py
@@ -992,7 +992,7 @@ class _AutoGGUFLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
         super(_AutoGGUFLoader, self).__init__(
             "com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFModel.loadSavedModel", path, jspark)
-        
+
         
 class _MxbaiEmbeddingsLoader(ExtendedJavaWrapper):
     def __init__(self, path, jspark):
@@ -1021,3 +1021,9 @@ def __init__(self, path, jspark):
             path,
             jspark,
         )
+
+
+class _AutoGGUFVisionLoader(ExtendedJavaWrapper):
+    def __init__(self, modelPath, mmprojPath, jspark):
+        super(_AutoGGUFVisionLoader, self).__init__(
+            "com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFVisionModel.loadSavedModel", modelPath, mmprojPath, jspark)
diff --git a/python/test/annotator/seq2seq/auto_gguf_model_test.py b/python/test/annotator/seq2seq/auto_gguf_model_test.py
index e6553bc509e5ff..76ad82c21d0814 100644
--- a/python/test/annotator/seq2seq/auto_gguf_model_test.py
+++ b/python/test/annotator/seq2seq/auto_gguf_model_test.py
@@ -102,7 +102,6 @@ def runTest(self):
         model.setGpuSplitMode("NONE")
         model.setMainGpu(0)
         model.setTensorSplit([])
-        model.setNBeams(0)
         model.setGrpAttnN(1)
         model.setGrpAttnW(512)
         model.setRopeFreqBase(1.0)
@@ -115,11 +114,10 @@ def runTest(self):
         model.setDefragmentationThreshold(-1.0)
         model.setNumaStrategy("DISTRIBUTE")
         model.setRopeScalingType("UNSPECIFIED")
-        model.setPoolingType("UNSPECIFIED")
+        model.setPoolingType("NONE")
         model.setModelDraft("")
         model.setLookupCacheStaticFilePath("/tmp/sparknlp-llama-cpp-cache")
         model.setLookupCacheDynamicFilePath("/tmp/sparknlp-llama-cpp-cache")
-        model.setLoraBase("")
         model.setEmbedding(False)
         model.setFlashAttention(False)
         model.setInputPrefixBos(False)
@@ -171,6 +169,7 @@ def runTest(self):
         pipeline = Pipeline().setStages([document_assembler, model])
         results = pipeline.fit(data).transform(data)
 
+        # Can fail due to bogus parameters, but at least we are testing the setters
         results.select("completions").show(truncate=False)
 
 
diff --git a/python/test/annotator/seq2seq/auto_gguf_vision_model_test.py b/python/test/annotator/seq2seq/auto_gguf_vision_model_test.py
new file mode 100644
index 00000000000000..c0509a59841ba7
--- /dev/null
+++ b/python/test/annotator/seq2seq/auto_gguf_vision_model_test.py
@@ -0,0 +1,86 @@
+#  Copyright 2017-2023 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import unittest
+
+import pytest
+from pyspark.sql.functions import lit
+
+from sparknlp.annotator import *
+from sparknlp.base import *
+from test.util import SparkContextForTest
+
+
+@pytest.mark.slow
+class AutoGGUFVisionModelTestSpec(unittest.TestCase):
+    def setUp(self):
+        self.spark = SparkContextForTest.spark
+
+    def runTest(self):
+        documentAssembler = (
+            DocumentAssembler().setInputCol("caption").setOutputCol("caption_document")
+        )
+        imageAssembler = (
+            ImageAssembler().setInputCol("image").setOutputCol("image_assembler")
+        )
+        imagesPath = "../src/test/resources/image/"
+        data = ImageAssembler.loadImagesAsBytes(self.spark, imagesPath).withColumn(
+            "caption", lit("Caption this image.")
+        )  # Add a caption to each image.
+        nPredict = 40
+        model = (
+            AutoGGUFVisionModel.pretrained()
+            .setInputCols(["caption_document", "image_assembler"])
+            .setOutputCol("completions")
+            .setChatTemplate("vicuna")
+            .setBatchSize(4)
+            .setNGpuLayers(99)
+            .setNCtx(4096)
+            .setMinKeep(0)
+            .setMinP(0.05)
+            .setNPredict(nPredict)
+            .setNProbs(0)
+            .setPenalizeNl(False)
+            .setRepeatLastN(256)
+            .setRepeatPenalty(1.18)
+            .setStopStrings(["</s>", "Llama:", "User:"])
+            .setTemperature(0.05)
+            .setTfsZ(1)
+            .setTypicalP(1)
+            .setTopK(40)
+            .setTopP(0.95)
+        )
+        pipeline = Pipeline().setStages([documentAssembler, imageAssembler, model])
+        # pipeline.fit(data).transform(data).selectExpr(
+        #     "reverse(split(image.origin, '/'))[0] as image_name", "completions.result"
+        # ).show(truncate=False)
+
+        results = pipeline.fit(data).transform(data).collect()
+
+        expectedWords = {
+            "bluetick.jpg": "dog",
+            "chihuahua.jpg": "dog",
+            "egyptian_cat.jpeg": "cat",
+            "hen.JPEG": "chick",
+            "hippopotamus.JPEG": "hippo",
+            "junco.JPEG": "bird",
+            "ostrich.JPEG": "ostrich",
+            "ox.JPEG": "bull",
+            "palace.JPEG": "room",
+            "tractor.JPEG": "tractor",
+        }
+
+        for result in results:
+            image_name = result["image_assembler"][0]["origin"].split("/")[-1]
+            completion = result["completions"][0]["result"]
+            assert expectedWords[image_name] in completion, f"Expected '{expectedWords[image_name]}' in '{completion}'"
diff --git a/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala
index ef7091c3b5cd12..6f68ead3a51ef0 100644
--- a/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala
+++ b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapper.scala
@@ -77,6 +77,7 @@ object GGUFWrapper {
       new LlamaModel(modelParameters)
     }
 
+  /** Reads the GGUF model from file during loadSavedModel. */
   def read(sparkSession: SparkSession, modelPath: String): GGUFWrapper = {
     // TODO Better Sanity Check
     val modelFile = new File(modelPath)
@@ -92,6 +93,9 @@ object GGUFWrapper {
     new GGUFWrapper(modelFile.getName, modelFile.getParent)
   }
 
+  /** Reads the GGUF model from the folder passed by the Spark Reader during loading of a
+    * serialized model.
+    */
   def readModel(modelFolderPath: String, spark: SparkSession): GGUFWrapper = {
     def findGGUFModelInFolder(folderPath: String): String = {
       val folder = new File(folderPath)
diff --git a/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapperMultiModal.scala b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapperMultiModal.scala
new file mode 100644
index 00000000000000..89eb8f517360f2
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/ml/gguf/GGUFWrapperMultiModal.scala
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.ml.gguf
+
+import com.johnsnowlabs.nlp.llama.{LlamaModel, ModelParameters}
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import org.apache.hadoop.fs.{FileSystem, Path}
+import org.apache.spark.SparkFiles
+import org.apache.spark.sql.SparkSession
+
+import java.io.File
+import java.nio.file.{Files, Paths}
+
+class GGUFWrapperMultiModal(var modelFileName: String, var mmprojFileName: String)
+    extends Serializable {
+
+  /** For Deserialization */
+  def this() = {
+    this(null, null)
+  }
+
+  // Important for serialization on none-kryo serializers
+  @transient private var llamaModel: LlamaModel = _
+
+  def getSession(modelParameters: ModelParameters): LlamaModel =
+    this.synchronized {
+      if (llamaModel == null) {
+        val modelFilePath = SparkFiles.get(modelFileName)
+        val mmprojFilePath = SparkFiles.get(mmprojFileName)
+        val filesExist =
+          Paths.get(modelFilePath).toFile.exists() && Paths.get(mmprojFilePath).toFile.exists()
+
+        if (filesExist) {
+          modelParameters.setModelFilePath(modelFilePath)
+          modelParameters.setMMProj(mmprojFilePath)
+          llamaModel = GGUFWrapperMultiModal.withSafeGGUFModelLoader(modelParameters)
+        } else
+          throw new IllegalStateException(
+            s"Model file $modelFileName does not exist in SparkFiles.")
+      }
+      // TODO: if the model is already loaded then the model parameters will not apply. perhaps output a logline here.
+      llamaModel
+    }
+
+  def saveToFile(folder: String): Unit = {
+    val modelFilePath = SparkFiles.get(modelFileName)
+    val mmprojFilePath = SparkFiles.get(mmprojFileName)
+    val modelOutputPath = Paths.get(folder, modelFileName)
+    val mmprojOutputPath = Paths.get(folder, mmprojFileName)
+    Files.copy(Paths.get(modelFilePath), modelOutputPath)
+    Files.copy(Paths.get(mmprojFilePath), mmprojOutputPath)
+  }
+
+  // Destructor to free the model when this object is garbage collected
+  override def finalize(): Unit = {
+    if (llamaModel != null) {
+      llamaModel.close()
+    }
+  }
+
+}
+
+/** Companion object */
+object GGUFWrapperMultiModal {
+  private def withSafeGGUFModelLoader(modelParameters: ModelParameters): LlamaModel =
+    this.synchronized {
+      new LlamaModel(modelParameters)
+    }
+
+  /** Reads the GGUF model from file during loadSavedModel. */
+  def read(
+      sparkSession: SparkSession,
+      modelPath: String,
+      mmprojPath: String): GGUFWrapperMultiModal = {
+    val modelFile = new File(modelPath)
+    val mmprojFile = new File(mmprojPath)
+
+    if (!modelFile.getName.endsWith(".gguf"))
+      throw new IllegalArgumentException(s"Model file $modelPath is not a GGUF model file")
+
+    if (!mmprojFile.getName.endsWith(".gguf"))
+      throw new IllegalArgumentException(s"mmproj file $mmprojPath is not a GGUF model file")
+
+    if (!mmprojFile.getName.contains("mmproj"))
+      throw new IllegalArgumentException(
+        s"mmproj file $mmprojPath is not a GGUF mmproj file (should contain 'mmproj' in its name)")
+
+    if (modelFile.exists() && mmprojFile.exists()) {
+      sparkSession.sparkContext.addFile(modelPath)
+      sparkSession.sparkContext.addFile(mmprojPath)
+    } else
+      throw new IllegalArgumentException(
+        s"Model file $modelPath or mmproj file $mmprojPath does not exist")
+
+    new GGUFWrapperMultiModal(modelFile.getName, mmprojFile.getName)
+  }
+
+  /** Reads the GGUF model from the folder passed by the Spark Reader during loading of a
+    * serialized model.
+    */
+  def readModel(modelFolderPath: String, spark: SparkSession): GGUFWrapperMultiModal = {
+    def findGGUFModelsInFolder(folderPath: String): (String, String) = {
+      val folder = new File(folderPath)
+      if (folder.exists && folder.isDirectory) {
+        val ggufFiles: Array[String] = folder.listFiles
+          .filter(_.isFile)
+          .filter(_.getName.endsWith(".gguf"))
+          .map(_.getAbsolutePath)
+
+        val (ggufMainPath, ggufMmprojPath) =
+          if (ggufFiles.length == 2 && ggufFiles.exists(_.contains("mmproj"))) {
+            val Array(firstModel, secondModel) = ggufFiles
+            if (firstModel.contains("mmproj")) (secondModel, firstModel)
+            else (firstModel, secondModel)
+          } else
+            throw new IllegalArgumentException(
+              s"Could not determine main GGUF model or mmproj GGUF model in $folderPath." +
+                s" The folder should contain exactly two files:" +
+                s" One main GGUF model and one mmproj GGUF model." +
+                s" The mmproj model should have 'mmproj' in its name.")
+
+        (ggufMainPath, ggufMmprojPath)
+      } else {
+        throw new IllegalArgumentException(s"Path $folderPath is not a directory")
+      }
+    }
+
+    val uri = new java.net.URI(modelFolderPath.replaceAllLiterally("\\", "/"))
+    // In case the path belongs to a different file system but doesn't have the scheme prepended (e.g. dbfs)
+    val fileSystem: FileSystem = FileSystem.get(uri, spark.sparkContext.hadoopConfiguration)
+    val actualFolderPath = fileSystem.resolvePath(new Path(modelFolderPath)).toString
+    val localFolder = ResourceHelper.copyToLocal(actualFolderPath)
+    val (ggufMainPath, ggufMmprojPath) = findGGUFModelsInFolder(localFolder)
+    read(spark, ggufMainPath, ggufMmprojPath)
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala b/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala
index 1a350c750fc958..e1e75926a89ffa 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/AnnotatorModel.scala
@@ -111,6 +111,23 @@ abstract class AnnotatorModel[M <: Model[M]] extends RawAnnotator[M] with CanBeL
             })
             .withColumn(getOutputCol, wrapColumnMetadata(col(getOutputCol)))
           dfWithMetadata
+
+        case withBatchAnnotateTextImage: HasBatchedAnnotateTextImage[M] =>
+          implicit val encoder: ExpressionEncoder[Row] =
+            SparkNlpConfig.getEncoder(inputDataset, newStructType)
+          val processedDataFrame = inputDataset.mapPartitions(partition => {
+            withBatchAnnotateTextImage.batchProcess(partition)
+          })
+
+          // TODO: Do we really need to repeat this in every case?
+          /** Put back column metadata from `inputDataset` after destructive mapPartitions */
+          val dfWithMetadata = inputDataset.schema.fields
+            .foldLeft(processedDataFrame)((dataFrame, field) => {
+              dataFrame
+                .withColumn(field.name, dataFrame.col(field.name).as(field.name, field.metadata))
+            })
+            .withColumn(getOutputCol, wrapColumnMetadata(col(getOutputCol)))
+          dfWithMetadata
       }
     }
 
diff --git a/src/main/scala/com/johnsnowlabs/nlp/HasBatchedAnnotateTextImage.scala b/src/main/scala/com/johnsnowlabs/nlp/HasBatchedAnnotateTextImage.scala
new file mode 100644
index 00000000000000..6881e74dd12510
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/HasBatchedAnnotateTextImage.scala
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2017-2022 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.johnsnowlabs.nlp
+
+import org.apache.spark.ml.Model
+import org.apache.spark.ml.param.IntParam
+import org.apache.spark.sql.Row
+
+trait HasBatchedAnnotateTextImage[M <: Model[M]] {
+
+  this: RawAnnotator[M] =>
+
+  /** Size of every batch (Default depends on model).
+    *
+    * @group param
+    */
+  val batchSize = new IntParam(this, "batchSize", "Size of every batch.")
+
+  /** Size of every batch.
+    *
+    * @group setParam
+    */
+  def setBatchSize(size: Int): this.type = {
+    val recommended = size
+    require(recommended > 0, "batchSize must be greater than 0")
+    set(this.batchSize, recommended)
+  }
+
+  /** Size of every batch.
+    *
+    * @group getParam
+    */
+  def getBatchSize: Int = $(batchSize)
+
+  private def getCaptionImageAnnotations(row: Row): (Annotation, AnnotationImage) = {
+    require(
+      getInputCols.length == 2,
+      "Only two input columns are allowed for this annotator:" +
+        " One for text caption and one for image.")
+
+    // Assuming we only have one annotation per field
+    val inputAnnotations: Array[Row] =
+      getInputCols.map(row.fieldIndex).map(i => row.getAs[Seq[Row]](i).head)
+
+    val (documentStruct: Row, imageStruct: Row) =
+      if (inputAnnotations.head.getString(0) == AnnotatorType.DOCUMENT) {
+        (inputAnnotations.head, inputAnnotations.last)
+      } else {
+        (inputAnnotations.last, inputAnnotations.head)
+      }
+
+    val document = Annotation(documentStruct)
+    val image = AnnotationImage(imageStruct)
+    (document, image)
+  }
+
+  def batchProcess(rows: Iterator[_]): Iterator[Row] = {
+    rows
+      .grouped(getBatchSize)
+      .flatMap { case batchedRows: Seq[Row] =>
+        val inputAnnotations: Seq[(Annotation, AnnotationImage)] =
+          batchedRows.map(getCaptionImageAnnotations)
+        val outputAnnotations = batchAnnotate(inputAnnotations)
+
+        batchedRows.zip(outputAnnotations).map { case (row, annotations) =>
+          row.toSeq ++ Array(annotations.map(a => Row(a.productIterator.toSeq: _*)))
+        }
+      }
+      .map(Row.fromSeq)
+  }
+
+  /** takes a document and annotations and produces new annotations of this annotator's annotation
+    * type
+    *
+    * @param batchedAnnotations
+    *   Annotations in batches that correspond to inputAnnotationCols generated by previous
+    *   annotators if any
+    * @return
+    *   any number of annotations processed for every batch of input annotations. Not necessary
+    *   one to one relationship
+    */
+  def batchAnnotate(batchedAnnotations: Seq[(Annotation, AnnotationImage)]): Seq[Seq[Annotation]]
+
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala b/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala
index 73b08bae40d695..ae620dc78cbaa5 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/ImageAssembler.scala
@@ -22,9 +22,9 @@ import org.apache.spark.ml.Transformer
 import org.apache.spark.ml.param.{Param, ParamMap}
 import org.apache.spark.ml.util.{DefaultParamsReadable, DefaultParamsWritable, Identifiable}
 import org.apache.spark.sql.expressions.UserDefinedFunction
-import org.apache.spark.sql.functions.udf
+import org.apache.spark.sql.functions.{col, regexp_replace, udf}
 import org.apache.spark.sql.types._
-import org.apache.spark.sql.{DataFrame, Dataset}
+import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}
 
 /** Prepares images read by Spark into a format that is processable by Spark NLP. This component
   * is needed to process images.
@@ -213,4 +213,49 @@ private[nlp] case class ImageFields(
 /** This is the companion object of [[ImageAssembler]]. Please refer to that class for the
   * documentation.
   */
-object ImageAssembler extends DefaultParamsReadable[ImageAssembler]
+object ImageAssembler extends DefaultParamsReadable[ImageAssembler] {
+
+  /** Helper function that loads images from a path and returns them as raw bytes, instead of the
+    * default OpenCV compatible format.
+    *
+    * Supported image types are JPEG, PNG, GIF, BMP (limited to images supported by stb_image.h).
+    *
+    * Multimodal inference with llama.cpp requires raw bytes as input.
+    *
+    * @param spark
+    *   The SparkSession
+    * @param path
+    *   The path to the images. Supported image types are JPEG, PNG, GIF, BMP.
+    * @return
+    *   A dataframe with the images as raw bytes, as well as their metadata.
+    */
+  def loadImagesAsBytes(spark: SparkSession, path: String): DataFrame = {
+    // Replace the path separator in the `origin` field and `path` column, so that they match
+    def replacePath(columnName: String) = regexp_replace(col(columnName), ":///", ":/")
+
+    val data: DataFrame =
+      spark.read
+        .format("image")
+        .option("dropInvalid", value = true)
+        .load(path)
+        .withColumn("image", col("image").withField("origin", replacePath("image.origin")))
+
+    val imageBytes: DataFrame =
+      spark.read
+        .format("binaryFile")
+        .option("pathGlobFilter", "*.{jpeg,jpg,png,gif,bmp,JPEG,JPG,PNG,GIF,BMP}")
+        .option("dropInvalid", value = true)
+        .load(path)
+        .withColumn("path", replacePath("path"))
+
+    // Join on path
+    val dfJoined =
+      data.join(imageBytes, data("image.origin") === imageBytes("path"), "inner")
+
+    // Replace image column data with image bytes
+    val dfImageReplaced =
+      dfJoined.withColumn("image", dfJoined("image").withField("data", dfJoined("content")))
+
+    dfImageReplaced
+  }
+}
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotator.scala b/src/main/scala/com/johnsnowlabs/nlp/annotator.scala
index efbd3a288896c1..e88f5feaa9fb01 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotator.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotator.scala
@@ -833,4 +833,8 @@ package object annotator {
       extends ReadablePretrainedAutoGGUFEmbeddings
       with ReadAutoGGUFEmbeddings
 
+  type AutoGGUFVisionModel = com.johnsnowlabs.nlp.annotators.seq2seq.AutoGGUFVisionModel
+  object AutoGGUFVisionModel
+      extends ReadablePretrainedAutoGGUFVisionModel
+      with ReadAutoGGUFVisionModel
 }
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala
index ca5be6ba37dfdb..5bdafeca1b29e3 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/cv/util/io/ImageIOUtils.scala
@@ -67,20 +67,18 @@ private[johnsnowlabs] object ImageIOUtils {
   def readImage(file: File): Option[BufferedImage] = {
     Try(ImageIO.read(file)) match {
       case Success(bufferedImage) => Some(bufferedImage)
-      case Failure(_) => {
+      case Failure(_) =>
         logger.warn(s"Error in ImageIOUtils.readImage while reading file: ${file.getPath}")
         None
-      }
     }
   }
 
   def readImage(inputStream: InputStream): Option[BufferedImage] = {
     Try(ImageIO.read(inputStream)) match {
       case Success(bufferedImage) => Some(bufferedImage)
-      case Failure(_) => {
+      case Failure(_) =>
         logger.warn(s"Error in ImageIOUtils.readImage while reading inputStream")
         None
-      }
     }
   }
 
@@ -203,4 +201,7 @@ private[johnsnowlabs] object ImageIOUtils {
 
   }
 
+  def encodeImageBase64(image: Array[Byte]): String =
+    java.util.Base64.getEncoder.encodeToString(image)
+
 }
diff --git a/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala
new file mode 100644
index 00000000000000..f3de739613ece3
--- /dev/null
+++ b/src/main/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModel.scala
@@ -0,0 +1,326 @@
+/*
+ * Copyright 2017-2024 John Snow Labs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.ml.gguf.GGUFWrapperMultiModal
+import com.johnsnowlabs.ml.util.LlamaCPP
+import com.johnsnowlabs.nlp._
+import com.johnsnowlabs.nlp.annotators.cv.util.io.ImageIOUtils
+import com.johnsnowlabs.nlp.llama.{LlamaException, LlamaModel}
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import org.apache.spark.broadcast.Broadcast
+import org.apache.spark.ml.util.Identifiable
+import org.apache.spark.sql.SparkSession
+
+/** Multimodal annotator that uses the llama.cpp library to generate text completions with large
+  * language models. It supports ingesting images for captioning.
+  *
+  * At the moment only CLIP based models are supported.
+  *
+  * For settable parameters, and their explanations, see [[HasLlamaCppInferenceProperties]],
+  * [[HasLlamaCppModelProperties]] and refer to the llama.cpp documentation of
+  * [[https://github.com/ggerganov/llama.cpp/tree/7d5e8777ae1d21af99d4f95be10db4870720da91/examples/server server.cpp]]
+  * for more information.
+  *
+  * If the parameters are not set, the annotator will default to use the parameters provided by
+  * the model.
+  *
+  * This annotator expects a column of annotator type [[AnnotationImage]] for the image and
+  * [[Annotation]] for the caption. Note that the image bytes in the image annotation need to be
+  * raw image bytes without preprocessing. We provide the helper function
+  * [[ImageAssembler.loadImagesAsBytes]] to load the image bytes from a directory.
+  *
+  * Pretrained models can be loaded with `pretrained` of the companion object:
+  * {{{
+  * val autoGGUFVisionModel = AutoGGUFVisionModel.pretrained()
+  *   .setInputCols("image', "document")
+  *   .setOutputCol("completions")
+  * }}}
+  * The default model is `"llava_v1.5_7b_Q4_0_gguf"`, if no name is provided.
+  *
+  * For available pretrained models please see the [[https://sparknlp.org/models Models Hub]].
+  *
+  * For extended examples of usage, see the
+  * [[https://github.com/JohnSnowLabs/spark-nlp/tree/master/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTest.scala AutoGGUFVisionModelTest]]
+  * and the
+  * [[https://github.com/JohnSnowLabs/spark-nlp/tree/master/examples/python/llama.cpp/llama.cpp_in_Spark_NLP_AutoGGUFVisionModel.ipynb example notebook]].
+  *
+  * ==Note==
+  * To use GPU inference with this annotator, make sure to use the Spark NLP GPU package and set
+  * the number of GPU layers with the `setNGpuLayers` method.
+  *
+  * When using larger models, we recommend adjusting GPU usage with `setNCtx` and `setNGpuLayers`
+  * according to your hardware to avoid out-of-memory errors.
+  *
+  * ==Example==
+  *
+  * {{{
+  * import com.johnsnowlabs.nlp.ImageAssembler
+  * import com.johnsnowlabs.nlp.annotator._
+  * import com.johnsnowlabs.nlp.base._
+  * import org.apache.spark.ml.Pipeline
+  * import org.apache.spark.sql.DataFrame
+  * import org.apache.spark.sql.functions.lit
+  *
+  * val documentAssembler = new DocumentAssembler()
+  *   .setInputCol("caption")
+  *   .setOutputCol("caption_document")
+  *
+  * val imageAssembler = new ImageAssembler()
+  *   .setInputCol("image")
+  *   .setOutputCol("image_assembler")
+  *
+  * val imagesPath = "src/test/resources/image/"
+  * val data: DataFrame = ImageAssembler
+  *   .loadImagesAsBytes(ResourceHelper.spark, imagesPath)
+  *   .withColumn("caption", lit("Caption this image.")) // Add a caption to each image.
+  *
+  * val nPredict = 40
+  * val model = AutoGGUFVisionModel.pretrained()
+  *   .setInputCols("caption_document", "image_assembler")
+  *   .setOutputCol("completions")
+  *   .setBatchSize(4)
+  *   .setNGpuLayers(99)
+  *   .setNCtx(4096)
+  *   .setMinKeep(0)
+  *   .setMinP(0.05f)
+  *   .setNPredict(nPredict)
+  *   .setNProbs(0)
+  *   .setPenalizeNl(false)
+  *   .setRepeatLastN(256)
+  *   .setRepeatPenalty(1.18f)
+  *   .setStopStrings(Array("</s>", "Llama:", "User:"))
+  *   .setTemperature(0.05f)
+  *   .setTfsZ(1)
+  *   .setTypicalP(1)
+  *   .setTopK(40)
+  *   .setTopP(0.95f)
+  *
+  * val pipeline = new Pipeline().setStages(Array(documentAssembler, imageAssembler, model))
+  * pipeline
+  *   .fit(data)
+  *   .transform(data)
+  *   .selectExpr("reverse(split(image.origin, '/'))[0] as image_name", "completions.result")
+  *   .show(truncate = false)
+  * +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |image_name       |result                                                                                                                                                                                        |
+  * +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * |palace.JPEG      |[ The image depicts a large, ornate room with high ceilings and beautifully decorated walls. There are several chairs placed throughout the space, some of which have cushions]               |
+  * |egyptian_cat.jpeg|[ The image features two cats lying on a pink surface, possibly a bed or sofa. One cat is positioned towards the left side of the scene and appears to be sleeping while holding]             |
+  * |hippopotamus.JPEG|[ A large brown hippo is swimming in a body of water, possibly an aquarium. The hippo appears to be enjoying its time in the water and seems relaxed as it floats]                            |
+  * |hen.JPEG         |[ The image features a large chicken standing next to several baby chickens. In total, there are five birds in the scene: one adult and four young ones. They appear to be gathered together] |
+  * |ostrich.JPEG     |[ The image features a large, long-necked bird standing in the grass. It appears to be an ostrich or similar species with its head held high and looking around. In addition to]              |
+  * |junco.JPEG       |[ A small bird with a black head and white chest is standing on the snow. It appears to be looking at something, possibly food or another animal in its vicinity. The scene takes place out]  |
+  * |bluetick.jpg     |[ A dog with a red collar is sitting on the floor, looking at something. The dog appears to be staring into the distance or focusing its attention on an object in front of it.]              |
+  * |chihuahua.jpg    |[ A small brown dog wearing a sweater is sitting on the floor. The dog appears to be looking at something, possibly its owner or another animal in the room. It seems comfortable and relaxed]|
+  * |tractor.JPEG     |[ A man is sitting in the driver's seat of a green tractor, which has yellow wheels and tires. The tractor appears to be parked on top of an empty field with]                                |
+  * |ox.JPEG          |[ A large bull with horns is standing in a grassy field.]                                                                                                                                     |
+  * +-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+  * }}}
+  *
+  * @param uid
+  *   required uid for storing annotator to disk
+  * @groupname anno Annotator types
+  * @groupdesc anno
+  *   Required input and expected output annotator types
+  * @groupname Ungrouped Members
+  * @groupname param Parameters
+  * @groupname setParam Parameter setters
+  * @groupname getParam Parameter getters
+  * @groupname Ungrouped Members
+  * @groupprio param  1
+  * @groupprio anno  2
+  * @groupprio Ungrouped 3
+  * @groupprio setParam  4
+  * @groupprio getParam  5
+  * @groupdesc param
+  *   A list of (hyper-)parameter keys this annotator can take. Users can set and get the
+  *   parameter values through setters and getters, respectively.
+  */
+class AutoGGUFVisionModel(override val uid: String)
+    extends AnnotatorModel[AutoGGUFVisionModel]
+    with HasBatchedAnnotateTextImage[AutoGGUFVisionModel]
+    with HasEngine
+    with HasLlamaCppModelProperties
+    with HasLlamaCppInferenceProperties
+    with HasProtectedParams {
+
+  override val inputAnnotatorTypes: Array[AnnotatorType] =
+    Array(AnnotatorType.IMAGE, AnnotatorType.DOCUMENT)
+  override val outputAnnotatorType: AnnotatorType = AnnotatorType.DOCUMENT
+
+  /** Annotator reference id. Used to identify elements in metadata or to refer to this annotator
+    * type
+    */
+  def this() = this(Identifiable.randomUID("AutoGGUFVisionModel"))
+
+  private var _model: Option[Broadcast[GGUFWrapperMultiModal]] = None
+
+  /** @group getParam */
+  def getModelIfNotSet: GGUFWrapperMultiModal = _model.get.value
+
+  /** @group setParam */
+  def setModelIfNotSet(spark: SparkSession, wrapper: GGUFWrapperMultiModal): this.type = {
+    if (_model.isEmpty) {
+      _model = Some(spark.sparkContext.broadcast(wrapper))
+    }
+
+    // Entrypoint for models. Automatically set GPU support if detected.
+    setGpuSupportIfAvailable(spark)
+    this
+  }
+
+  private[johnsnowlabs] def setEngine(engineName: String): this.type = set(engine, engineName)
+
+  setDefault(
+    engine -> LlamaCPP.name,
+    useChatTemplate -> true,
+    nCtx -> 4096,
+    nBatch -> 512,
+    embedding -> false,
+    nPredict -> 100)
+
+//  val mmproj = new Param[String](
+//    this,
+//    "mmproj",
+//    "Name of the file for the multi-modal projection (mmproj) model, that encodes the images.")
+//
+//  /** Sets the path to the multi-modal projection (mmproj) model, that encodes the images.
+//    *
+//    * Should only be used by this class and not by the user.
+//    *
+//    * @param value
+//    *   Name of the file for the multi-modal projection (mmproj) model
+//    * @return
+//    */
+//  private def setMmproj(value: String): this.type = set(mmproj, value)
+//
+//  private def getMmproj: String = $(mmproj)
+
+  override def onWrite(path: String, spark: SparkSession): Unit = {
+    super.onWrite(path, spark)
+    getModelIfNotSet.saveToFile(path)
+  }
+
+  /** Completes the batch of annotations.
+    *
+    * @param batchedAnnotations
+    *   The single batch of annotations
+    * @return
+    *   Completed text sequences
+    *
+    * sentences that belong to the same original row !! (challenging)
+    */
+  override def batchAnnotate(
+      batchedAnnotations: Seq[(Annotation, AnnotationImage)]): Seq[Seq[Annotation]] = {
+    if (batchedAnnotations.nonEmpty) {
+
+      // set parallel decoding to batch size
+      val modelParams = getModelParameters.setNParallel(getBatchSize)
+      val model: LlamaModel = getModelIfNotSet.getSession(modelParams)
+
+      val (prompts, base64EncodedImages) = batchedAnnotations.unzip match {
+        case (promptAnnotations, imageAnnotations) =>
+          (
+            promptAnnotations.map(_.result).toArray,
+            imageAnnotations
+              .map(imgAnno => ImageIOUtils.encodeImageBase64(imgAnno.result))
+              .toArray)
+      }
+
+      val (completedTexts: Array[String], metadata: Map[String, String]) =
+        try {
+          (
+            model.requestBatchImageCompletion(
+              prompts,
+              base64EncodedImages,
+              getInferenceParameters),
+            Map.empty)
+        } catch {
+          case e: LlamaException =>
+            logger.error("Error in llama.cpp image batch completion", e)
+            (Array[String](), Map("LlamaException" -> e.getMessage))
+        }
+
+      val result: Seq[Seq[Annotation]] =
+        batchedAnnotations.zip(completedTexts).map {
+          case ((textAnnotation: Annotation, imageAnnotation: AnnotationImage), text) =>
+            val totalMetadata =
+              textAnnotation.metadata ++ imageAnnotation.metadata ++ metadata
+            Seq(new Annotation(outputAnnotatorType, 0, text.length - 1, text, totalMetadata))
+        }
+      result
+    } else Seq(Seq.empty[Annotation])
+  }
+}
+
+trait ReadablePretrainedAutoGGUFVisionModel
+    extends ParamsAndFeaturesReadable[AutoGGUFVisionModel]
+    with HasPretrained[AutoGGUFVisionModel] {
+  override val defaultModelName: Some[String] = Some("llava_v1.5_7b_Q4_0_gguf")
+  override val defaultLang: String = "en"
+
+  /** Java compliant-overrides */
+  override def pretrained(): AutoGGUFVisionModel = super.pretrained()
+
+  override def pretrained(name: String): AutoGGUFVisionModel = super.pretrained(name)
+
+  override def pretrained(name: String, lang: String): AutoGGUFVisionModel =
+    super.pretrained(name, lang)
+
+  override def pretrained(name: String, lang: String, remoteLoc: String): AutoGGUFVisionModel =
+    super.pretrained(name, lang, remoteLoc)
+}
+
+trait ReadAutoGGUFVisionModel {
+  this: ParamsAndFeaturesReadable[AutoGGUFVisionModel] =>
+
+  def readModel(instance: AutoGGUFVisionModel, path: String, spark: SparkSession): Unit = {
+    val model: GGUFWrapperMultiModal = GGUFWrapperMultiModal.readModel(path, spark)
+
+    instance.setModelIfNotSet(spark, model)
+  }
+
+  addReader(readModel)
+
+  def loadSavedModel(
+      modelPath: String,
+      mmprojPath: String,
+      spark: SparkSession): AutoGGUFVisionModel = {
+    // TODO potentially enable download from HF-URLS
+    val localPathModel: String = ResourceHelper.copyToLocal(modelPath)
+    val localPathMmproj: String = ResourceHelper.copyToLocal(mmprojPath)
+
+    val annotatorModel = new AutoGGUFVisionModel()
+    val wrapper = GGUFWrapperMultiModal.read(spark, localPathModel, localPathMmproj)
+
+    annotatorModel
+      .setModelIfNotSet(spark, wrapper)
+      .setEngine(LlamaCPP.name)
+
+    // TODO mmproj metadata necessary?
+    val metadata = LlamaModel.getMetadataFromFile(localPathModel)
+    if (metadata.nonEmpty) annotatorModel.setMetadata(metadata)
+    annotatorModel
+  }
+}
+
+/** This is the companion object of [[AutoGGUFVisionModel]]. Please refer to that class for the
+  * documentation.
+  */
+object AutoGGUFVisionModel
+    extends ReadablePretrainedAutoGGUFVisionModel
+    with ReadAutoGGUFVisionModel
diff --git a/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala b/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala
index 3a6e69b79c5cd1..1f17c8d711ea0c 100644
--- a/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala
+++ b/src/main/scala/com/johnsnowlabs/nlp/pretrained/ResourceDownloader.scala
@@ -691,12 +691,13 @@ object PythonResourceDownloader {
     "CamemBertForZeroShotClassification" -> CamemBertForZeroShotClassification,
     "BertForMultipleChoice" -> BertForMultipleChoice,
     "PromptAssembler" -> PromptAssembler,
-    "CPMTransformer"-> CPMTransformer,
+    "CPMTransformer" -> CPMTransformer,
     "NomicEmbeddings" -> NomicEmbeddings,
     "NLLBTransformer" -> NLLBTransformer,
     "Phi3Transformer" -> Phi3Transformer,
     "QwenTransformer" -> QwenTransformer,
-    "AutoGGUFEmbeddings" -> AutoGGUFEmbeddings)
+    "AutoGGUFEmbeddings" -> AutoGGUFEmbeddings,
+    "AutoGGUFVisionModel" -> AutoGGUFVisionModel)
 
   // List pairs of types such as the one with key type can load a pretrained model from the value type
   val typeMapper: Map[String, String] = Map("ZeroShotNerModel" -> "RoBertaForQuestionAnswering")
diff --git a/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTestSpec.scala b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTestSpec.scala
new file mode 100644
index 00000000000000..961e2fc49b4488
--- /dev/null
+++ b/src/test/scala/com/johnsnowlabs/nlp/annotators/seq2seq/AutoGGUFVisionModelTestSpec.scala
@@ -0,0 +1,121 @@
+package com.johnsnowlabs.nlp.annotators.seq2seq
+
+import com.johnsnowlabs.nlp.base.DocumentAssembler
+import com.johnsnowlabs.nlp.util.io.ResourceHelper
+import com.johnsnowlabs.nlp.{Annotation, AnnotationImage, ImageAssembler}
+import com.johnsnowlabs.tags.SlowTest
+import org.apache.spark.ml.Pipeline
+import org.apache.spark.sql.functions.lit
+import org.apache.spark.sql.{DataFrame, Row}
+import org.scalatest.flatspec.AnyFlatSpec
+
+import scala.collection.mutable
+
+class AutoGGUFVisionModelTestSpec extends AnyFlatSpec {
+
+  behavior of "AutoGGUFVisionModel"
+
+  lazy val documentAssembler = new DocumentAssembler()
+    .setInputCol("caption")
+    .setOutputCol("caption_document")
+
+  lazy val imageAssembler = new ImageAssembler()
+    .setInputCol("image")
+    .setOutputCol("image_assembler")
+
+  lazy val imagesPath = "src/test/resources/image/"
+  lazy val data: DataFrame = ImageAssembler
+    .loadImagesAsBytes(ResourceHelper.spark, imagesPath)
+    .withColumn("caption", lit("Caption this image.")) // Add a caption to each image.
+
+  lazy val expectedWords: Map[String, String] = Map(
+    "bluetick.jpg" -> "dog",
+    "chihuahua.jpg" -> "dog",
+    "egyptian_cat.jpeg" -> "cat",
+    "hen.JPEG" -> "chick",
+    "hippopotamus.JPEG" -> "hippo",
+    "junco.JPEG" -> "bird",
+    "ostrich.JPEG" -> "ostrich",
+    "ox.JPEG" -> "bull",
+    "palace.JPEG" -> "room",
+    "tractor.JPEG" -> "tractor")
+
+  lazy val nPredict = 40
+  lazy val model = AutoGGUFVisionModel
+    .pretrained()
+    .setInputCols("caption_document", "image_assembler")
+    .setOutputCol("completions")
+    .setChatTemplate("vicuna") // llava uses vicuna as default
+    .setBatchSize(2)
+    .setNGpuLayers(99)
+    .setNCtx(4096)
+    .setMinKeep(0)
+    .setMinP(0.05f)
+    .setNPredict(nPredict)
+    .setNProbs(0)
+    .setPenalizeNl(false)
+    .setRepeatLastN(256)
+    .setRepeatPenalty(1.18f)
+    .setStopStrings(Array("</s>", "Llama:", "User:"))
+    .setTemperature(0.05f)
+    .setTfsZ(1)
+    .setTypicalP(1)
+    .setTopK(40)
+    .setTopP(0.95f)
+
+  lazy val pipeline = new Pipeline().setStages(Array(documentAssembler, imageAssembler, model))
+
+  def checkBinaryContents(): Unit = {
+    val imageData = data.select("image.data").limit(1).collect()(0).getAs[Array[Byte]](0)
+    val byteContent = data.select("content").limit(1).collect()(0).getAs[Array[Byte]](0)
+
+    assert(imageData.length == byteContent.length)
+    assert(imageData sameElements byteContent)
+  }
+
+  it should "replace image data with bytes" taggedAs SlowTest in {
+    checkBinaryContents()
+  }
+
+  it should "caption the images correctly" taggedAs SlowTest in {
+    import java.lang.management.ManagementFactory
+    val pid = ManagementFactory.getRuntimeMXBean.getName.split("@")(0)
+    println(s"Current PID: $pid")
+
+    val result = pipeline.fit(data).transform(data.repartition(1))
+
+    val imageWithCompletions: Array[(AnnotationImage, Annotation)] =
+      result.select("image_assembler", "completions").collect().map { row =>
+        val image = AnnotationImage(row.getAs[mutable.WrappedArray[Row]](0).head)
+        val annotation = Annotation(row.getAs[mutable.WrappedArray[Row]](1).head)
+        (image, annotation)
+      }
+
+    imageWithCompletions.foreach { case (image, completion) =>
+      val fileName = image.origin.split("/").last
+      val expectedWord = expectedWords(fileName)
+      val wordFound = completion.result.contains(expectedWord)
+      assert(wordFound, s"Expected word $expectedWord not found in $result")
+    }
+  }
+
+  it should "be serializable" taggedAs SlowTest in {
+    val pipelineModel = pipeline.fit(data)
+    val savePath = "./tmp_autogguf_vision_model"
+    pipelineModel.stages.last
+      .asInstanceOf[AutoGGUFVisionModel]
+      .write
+      .overwrite()
+      .save(savePath)
+
+    val loadedModel = AutoGGUFVisionModel.load(savePath)
+    val newPipeline: Pipeline =
+      new Pipeline().setStages(Array(documentAssembler, imageAssembler, loadedModel))
+
+    newPipeline
+      .fit(data)
+      .transform(data.limit(1))
+      .select("completions")
+      .show(truncate = false)
+  }
+}