diff --git a/Segmentation Sample Models/tubule-segmentation/README.md b/Segmentation Sample Models/tubule-segmentation/README.md
new file mode 100644
index 0000000..7450f56
--- /dev/null
+++ b/Segmentation Sample Models/tubule-segmentation/README.md	
@@ -0,0 +1,15 @@
+# Tubule Segmentation
+## Dataset 
+The dataset used is available [here](http://andrewjanowczyk.com/wp-static/tubule.tgz) .
+
+The dataset consist of 85 images ColoRectal images scanned at 40x., where each image is 775 x 522 and contains a total of 795 regions.  The tubules were manually annotated across all images by an expert pathologist.
+
+This sample model is trained on br_masks for demonstration purpose to try to understand how to test models in caMicroscope.
+## Preprocessing
+Patch Extraction is performed.
+Pixel values are normalized between 0-1.
+## Model
+U-net: 256 -> 128 -> 64 -> 32 -> 16 -> 32 -> 64 -> 128 -> 256.
+
+Input image size: 256 x 256 x 3
+
diff --git a/Segmentation Sample Models/tubule-segmentation/Tubule_Segmentation.ipynb b/Segmentation Sample Models/tubule-segmentation/Tubule_Segmentation.ipynb
new file mode 100644
index 0000000..93632d7
--- /dev/null
+++ b/Segmentation Sample Models/tubule-segmentation/Tubule_Segmentation.ipynb	
@@ -0,0 +1,1139 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<h2> Data organization <h2>"
+      ],
+      "metadata": {
+        "id": "2L-sL0qmT7Ip"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "SkUUcjeKPhYS",
+        "outputId": "a38d5e3e-d935-4dd8-edbf-eca3c4c8440e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "--2024-03-28 18:20:17--  http://andrewjanowczyk.com/wp-static/tubule.tgz\n",
+            "Resolving andrewjanowczyk.com (andrewjanowczyk.com)... 129.22.181.85\n",
+            "Connecting to andrewjanowczyk.com (andrewjanowczyk.com)|129.22.181.85|:80... connected.\n",
+            "HTTP request sent, awaiting response... 200 OK\n",
+            "Length: 93888009 (90M) [application/x-gzip]\n",
+            "Saving to: ‘tubule.tgz’\n",
+            "\n",
+            "tubule.tgz          100%[===================>]  89.54M  1.02MB/s    in 43s     \n",
+            "\n",
+            "2024-03-28 18:21:00 (2.10 MB/s) - ‘tubule.tgz’ saved [93888009/93888009]\n",
+            "\n"
+          ]
+        }
+      ],
+      "source": [
+        "!wget http://andrewjanowczyk.com/wp-static/tubule.tgz"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "mkdir tubule"
+      ],
+      "metadata": {
+        "id": "aC7SoQ7sPpze"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!tar -xvzf tubule.tgz -C tubule"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YpLHKujqQ1CG",
+        "outputId": "27d42553-a236-4fab-926d-a4243ec7ce97"
+      },
+      "execution_count": 3,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "09-1339-01-1_anno.bmp\n",
+            "09-1339-01-1.bmp\n",
+            "09-1339-01-2_anno.bmp\n",
+            "09-1339-01-2.bmp\n",
+            "09-1339-01-3_anno.bmp\n",
+            "09-1339-01-3.bmp\n",
+            "09-1339-01-4_anno.bmp\n",
+            "09-1339-01-4.bmp\n",
+            "09-1339-02-1_anno.bmp\n",
+            "09-1339-02-1.bmp\n",
+            "09-1339-02-2_anno.bmp\n",
+            "09-1339-02-2.bmp\n",
+            "09-1339-02-3_anno.bmp\n",
+            "09-1339-02-3.bmp\n",
+            "09-1339-02-4_anno.bmp\n",
+            "09-1339-02-4.bmp\n",
+            "09-1339-05-1_anno.bmp\n",
+            "09-1339-05-1.bmp\n",
+            "09-1339-05-2_anno.bmp\n",
+            "09-1339-05-2.bmp\n",
+            "09-1339-05-3_anno.bmp\n",
+            "09-1339-05-3.bmp\n",
+            "09-1339-05-4_anno.bmp\n",
+            "09-1339-05-4.bmp\n",
+            "09-1646-01-1_anno.bmp\n",
+            "09-1646-01-1.bmp\n",
+            "09-1646-01-2_anno.bmp\n",
+            "09-1646-01-2.bmp\n",
+            "09-1646-01-3_anno.bmp\n",
+            "09-1646-01-3.bmp\n",
+            "09-1646-01-4_anno.bmp\n",
+            "09-1646-01-4.bmp\n",
+            "09-1646-02-1_anno.bmp\n",
+            "09-1646-02-1.bmp\n",
+            "09-1646-02-2_anno.bmp\n",
+            "09-1646-02-2.bmp\n",
+            "09-1646-02-3_anno.bmp\n",
+            "09-1646-02-3.bmp\n",
+            "09-1646-02-4_anno.bmp\n",
+            "09-1646-02-4.bmp\n",
+            "09-1646-03-1_anno.bmp\n",
+            "09-1646-03-1.bmp\n",
+            "09-1646-03-2_anno.bmp\n",
+            "09-1646-03-2.bmp\n",
+            "09-1646-03-3_anno.bmp\n",
+            "09-1646-03-3.bmp\n",
+            "09-1646-03-4_anno.bmp\n",
+            "09-1646-03-4.bmp\n",
+            "09-1646-05-1_anno.bmp\n",
+            "09-1646-05-1.bmp\n",
+            "09-1646-05-2_anno.bmp\n",
+            "09-1646-05-2.bmp\n",
+            "09-1646-05-3_anno.bmp\n",
+            "09-1646-05-3.bmp\n",
+            "09-1646-05-4_anno.bmp\n",
+            "09-1646-05-4.bmp\n",
+            "09-16566-02-1_anno.bmp\n",
+            "09-16566-02-1.bmp\n",
+            "09-16566-02-2_anno.bmp\n",
+            "09-16566-02-2.bmp\n",
+            "09-16566-02-3_anno.bmp\n",
+            "09-16566-02-3.bmp\n",
+            "09-16566-02-4_anno.bmp\n",
+            "09-16566-02-4.bmp\n",
+            "09-16566-03-1_anno.bmp\n",
+            "09-16566-03-1.bmp\n",
+            "09-16566-03-2_anno.bmp\n",
+            "09-16566-03-2.bmp\n",
+            "09-16566-03-3_anno.bmp\n",
+            "09-16566-03-3.bmp\n",
+            "09-16566-03-4_anno.bmp\n",
+            "09-16566-03-4.bmp\n",
+            "09-21631-03-1_anno.bmp\n",
+            "09-21631-03-1.bmp\n",
+            "09-21631-03-2_anno.bmp\n",
+            "09-21631-03-2.bmp\n",
+            "09-21631-03-3_anno.bmp\n",
+            "09-21631-03-3.bmp\n",
+            "09-21631-03-4_anno.bmp\n",
+            "09-21631-03-4.bmp\n",
+            "09-23232-02-1_anno.bmp\n",
+            "09-23232-02-1.bmp\n",
+            "09-23232-02-2_anno.bmp\n",
+            "09-23232-02-2.bmp\n",
+            "09-23232-02-3_anno.bmp\n",
+            "09-23232-02-3.bmp\n",
+            "09-23232-02-4_anno.bmp\n",
+            "09-23232-02-4.bmp\n",
+            "09-23757-01-1_anno.bmp\n",
+            "09-23757-01-1.bmp\n",
+            "09-23757-01-2_anno.bmp\n",
+            "09-23757-01-2.bmp\n",
+            "09-23757-01-3_anno.bmp\n",
+            "09-23757-01-3.bmp\n",
+            "09-23757-01-4_anno.bmp\n",
+            "09-23757-01-4.bmp\n",
+            "09-322-02-1_anno.bmp\n",
+            "09-322-02-1.bmp\n",
+            "09-322-02-2_anno.bmp\n",
+            "09-322-02-2.bmp\n",
+            "09-322-02-3_anno.bmp\n",
+            "09-322-02-3.bmp\n",
+            "09-322-02-4_anno.bmp\n",
+            "09-322-02-4.bmp\n",
+            "10-12813-01-1_anno.bmp\n",
+            "10-12813-01-1.bmp\n",
+            "10-12813-01-2_anno.bmp\n",
+            "10-12813-01-2.bmp\n",
+            "10-12813-01-3_anno.bmp\n",
+            "10-12813-01-3.bmp\n",
+            "10-12813-01-4_anno.bmp\n",
+            "10-12813-01-4.bmp\n",
+            "10-12813-05-1_anno.bmp\n",
+            "10-12813-05-1.bmp\n",
+            "10-12813-05-2_anno.bmp\n",
+            "10-12813-05-2.bmp\n",
+            "10-12813-05-3_anno.bmp\n",
+            "10-12813-05-3.bmp\n",
+            "10-12813-05-4_anno.bmp\n",
+            "10-12813-05-4.bmp\n",
+            "10-13799-01-1_anno.bmp\n",
+            "10-13799-01-1.bmp\n",
+            "10-13799-01-2_anno.bmp\n",
+            "10-13799-01-2.bmp\n",
+            "10-13799-01-3_anno.bmp\n",
+            "10-13799-01-3.bmp\n",
+            "10-13799-01-4_anno.bmp\n",
+            "10-13799-01-4.bmp\n",
+            "10-13799-02-1_anno.bmp\n",
+            "10-13799-02-1.bmp\n",
+            "10-13799-02-2_anno.bmp\n",
+            "10-13799-02-2.bmp\n",
+            "10-13799-02-3_anno.bmp\n",
+            "10-13799-02-3.bmp\n",
+            "10-13799-02-4_anno.bmp\n",
+            "10-13799-02-4.bmp\n",
+            "10-13799-05-1_anno.bmp\n",
+            "10-13799-05-1.bmp\n",
+            "10-13799-05-2_anno.bmp\n",
+            "10-13799-05-2.bmp\n",
+            "10-13799-05-4_anno.bmp\n",
+            "10-13799-05-4.bmp\n",
+            "10-13799-06-1_anno.bmp\n",
+            "10-13799-06-1.bmp\n",
+            "10-13799-06-2_anno.bmp\n",
+            "10-13799-06-2.bmp\n",
+            "10-13799-06-3_anno.bmp\n",
+            "10-13799-06-3.bmp\n",
+            "10-13799-06-4_anno.bmp\n",
+            "10-13799-06-4.bmp\n",
+            "10-15247-02-1_anno.bmp\n",
+            "10-15247-02-1.bmp\n",
+            "10-15247-02-2_anno.bmp\n",
+            "10-15247-02-2.bmp\n",
+            "10-15247-02-3_anno.bmp\n",
+            "10-15247-02-3.bmp\n",
+            "10-15247-02-4_anno.bmp\n",
+            "10-15247-02-4.bmp\n",
+            "benign.txt\n",
+            "m17_1421 IE-11 T3N2a_anno.bmp\n",
+            "m17_1421 IE-11 T3N2a.bmp\n",
+            "m18_1421 IE-11 1-86-31_anno.bmp\n",
+            "m18_1421 IE-11 1-86-31.bmp\n",
+            "m2_10449-11E-T3N1b_anno.bmp\n",
+            "m2_10449-11E-T3N1b.bmp\n",
+            "m39_10-1273_anno.bmp\n",
+            "m39_10-1273.bmp\n",
+            "m6_10719 T3N2a_anno.bmp\n",
+            "m6_10719 T3N2a.bmp\n",
+            "m9_10741F-12T2N0_anno.bmp\n",
+            "m9_10741F-12T2N0.bmp\n",
+            "malignant.txt\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "mkdir data data/images data/anno_masks"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "5rFfegKQQ9aT",
+        "outputId": "c959c8a3-3140-4f91-9eaf-136934dcab41"
+      },
+      "execution_count": 7,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "mkdir: cannot create directory ‘data’: File exists\n",
+            "mkdir: cannot create directory ‘data/images’: File exists\n",
+            "mkdir: cannot create directory ‘data/anno_masks’: File exists\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "mkdir data/images/patches_i data/anno_masks/patches_m"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "C0IDh1tJRG3W",
+        "outputId": "9cbc37a9-a8d3-4023-b82e-727b65162b8f"
+      },
+      "execution_count": 8,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "mkdir: cannot create directory ‘data/images/patches_i’: File exists\n",
+            "mkdir: cannot create directory ‘data/anno_masks/patches_m’: File exists\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "mv tubule/*_anno.bmp data/anno_masks/"
+      ],
+      "metadata": {
+        "id": "boaz-DR8RN19"
+      },
+      "execution_count": 10,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "mv tubule/*.bmp data/images"
+      ],
+      "metadata": {
+        "id": "prer63VoRScn"
+      },
+      "execution_count": 11,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<h2> Patch Extraction <h2>"
+      ],
+      "metadata": {
+        "id": "HgAGuuzqUGW1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Credits: ICIAR2018 by ImagingLabs\n",
+        "class PatchExtractor:\n",
+        "    def __init__(self, img, patch_size, stride):\n",
+        "        '''\n",
+        "        :param img: :py:class:`~PIL.Image.Image`\n",
+        "        :param patch_size: integer, size of the patch\n",
+        "        :param stride: integer, size of the stride\n",
+        "        '''\n",
+        "        self.img = img\n",
+        "        self.size = patch_size\n",
+        "        self.stride = stride\n",
+        "\n",
+        "    def extract_patches(self):\n",
+        "        \"\"\"\n",
+        "        extracts all patches from an image\n",
+        "        :returns: A list of :py:class:`~PIL.Image.Image` objects.\n",
+        "        \"\"\"\n",
+        "        wp, hp = self.shape()\n",
+        "        return [self.extract_patch((w, h)) for h in range(hp) for w in range(wp)]\n",
+        "\n",
+        "    def extract_patch(self, patch):\n",
+        "        \"\"\"\n",
+        "        extracts a patch from an input image\n",
+        "        :param patch: a tuple\n",
+        "        :rtype: :py:class:`~PIL.Image.Image`\n",
+        "        :returns: An :py:class:`~PIL.Image.Image` object.\n",
+        "        \"\"\"\n",
+        "        return self.img.crop((\n",
+        "            patch[0] * self.stride,  # left\n",
+        "            patch[1] * self.stride,  # up\n",
+        "            patch[0] * self.stride + self.size,  # right\n",
+        "            patch[1] * self.stride + self.size  # down\n",
+        "        ))\n",
+        "\n",
+        "    def shape(self):\n",
+        "        wp = int((self.img.width - self.size) / self.stride + 1)\n",
+        "        hp = int((self.img.height - self.size) / self.stride + 1)\n",
+        "        return wp, hp"
+      ],
+      "metadata": {
+        "id": "f38cInntR41i"
+      },
+      "execution_count": 12,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import glob\n",
+        "from PIL import Image\n",
+        "\n",
+        "PATCH_SIZE = 256\n",
+        "\n",
+        "# This is the folder you'll find after extracting the dataset.\n",
+        "train_folder = './data/images'\n",
+        "labels = glob.glob(train_folder +  '/*.bmp')\n",
+        "labels.sort()"
+      ],
+      "metadata": {
+        "id": "bCQxRdpDUVi-"
+      },
+      "execution_count": 13,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "for item in labels:\n",
+        "  try:\n",
+        "    with Image.open(item) as img:\n",
+        "      extractor = PatchExtractor(img=img, patch_size=PATCH_SIZE, stride=256)\n",
+        "      patches = extractor.extract_patches()\n",
+        "      count = 0\n",
+        "      for p in patches:\n",
+        "        count += 1\n",
+        "        p.save('./data/images/patches_i/' + str(count) + '_' + item.split('/')[-1][:-3] + 'bmp')\n",
+        "  except Exception as error:\n",
+        "    print('error with', item, error)\n"
+      ],
+      "metadata": {
+        "id": "VXXi947oUe6f"
+      },
+      "execution_count": 14,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "labels = glob.glob('./data/anno_masks/*.bmp')\n",
+        "labels.sort()"
+      ],
+      "metadata": {
+        "id": "8_QBaHMFVKXX"
+      },
+      "execution_count": 18,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "for item in labels:\n",
+        "  try:\n",
+        "    with Image.open(item) as img:\n",
+        "      extractor = PatchExtractor(img=img, patch_size=PATCH_SIZE, stride=256)\n",
+        "      patches = extractor.extract_patches()\n",
+        "      count = 0\n",
+        "      for p in patches:\n",
+        "        count += 1\n",
+        "        # print('./train/' + value + '/' + str(count) + '_' + key.split('/')[-1])\n",
+        "        p.save('./data/anno_masks/patches_m/' + str(count) + '_' + item.split('/')[-1])\n",
+        "  except Exception as error:\n",
+        "    print('error with', item, error)"
+      ],
+      "metadata": {
+        "id": "H07sC0acVOrT"
+      },
+      "execution_count": 19,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "images = [item for item in glob.glob('data/images/patches_i/*')]\n",
+        "# masks = [item for item in glob.glob('data/anno_masks/patches_m/*')]\n"
+      ],
+      "metadata": {
+        "id": "Q8e0cnfBUxsf"
+      },
+      "execution_count": 15,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "masks = [item for item in glob.glob('data/anno_masks/patches_m/*')]"
+      ],
+      "metadata": {
+        "id": "2KaI2vYsU9dw"
+      },
+      "execution_count": 20,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "len(images), len(masks)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KD1kbyUMU_VB",
+        "outputId": "154b6d5f-e516-474a-ca1d-1758fea1864d"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(486, 486)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 21
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "images.sort()\n",
+        "masks.sort()\n"
+      ],
+      "metadata": {
+        "id": "ftTYJS8HVA0o"
+      },
+      "execution_count": 22,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from PIL import Image\n",
+        "import numpy as np\n"
+      ],
+      "metadata": {
+        "id": "m3WeAVpWVWuP"
+      },
+      "execution_count": 23,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open('/content/data/images/patches_i/1_09-1339-01-1.bmp')\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 273
+        },
+        "id": "95OhT7FAVZTd",
+        "outputId": "502e0224-8bbc-4be6-8c27-260099d8ba9e"
+      },
+      "execution_count": 26,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.BmpImagePlugin.BmpImageFile image mode=RGB size=256x256>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4nCT81862W5aY540xZp5PeMOX/rTWqtjdbNKkAAoyYME+RB+Bz8Q7NiAZkGDaskSyu7q6qlb6wxfe9KSZ5/SGDuLeuoAb/6//3f+tNMFIltyOT8Pdo+xH9rt/86nbD5tzl1PhUMehf3rktYnz5bYtnT9/YTWOuz0T5TadoI5CKCSxLXPwMadSq6+NnKupvQCrXENT+5hEiAODY3ILJhfmzy6yy8LK9rVT8uPD4f5JhthCwu6w2+2OtYltnTrbOJsf7/9eCnm93Up7RcRaSl46LSVCy/WFi0Mo/YKd95sPm4iz1EIqoT7eA8pffn15+7P32xds3xgxxjjnMoPOjeUmcqaWsyAclOgU06yZh6isAclfvpJbC5EtbWIqN+6YrbVwtwHL91iD5HWw/uH4vlNjjPM0+ZIp1dct1HlLGt/lVLTU+rBWSiGvydm0Ai+6lx3aHGjxgW++TpOf1hDCVkoyrGjJjBRWcilZbXnX95zLrhsWLxvZt+v6erumuLj1KthizX2ORBBL3h7uRyXzOPS2s0x0PlZikotDrUlrldvnBplYC5Mxakixen+Biq1izSNrDkroh7o/vkeuQDSX0rSujKsc6zwtFKrl/MPT097wzdaVEl/D9RymyVWbsfLk856nu48wHJi3//78vM5np82P1DrOLBAADgByXl/zouIGLX+WveFKcOiW9RbzXMUViDfkNe5yjLxRJ6LUpjbRm4P3M6F7/BCFoK5ThPe1UEyobWHMhsDi1uWyLOtXXu8IQHLO+UnLQeCQymeudeFc0bGBd/6tqH8x427/8I4/7EdfHbBNSMaZzk5V3r9+9tukgISfT1YJzCIth9Wlt+ecgqbMuSxMOUaPnHe8P0mObm059ynN0KKVnVRiVVtuj4zz3FpgAyFLBafLOWyrgkwFtBIsRGQd4xXYlv09gJfa17R7fdm4qpD1BkUrHRMCNuKceIcAJSfBteAyOB88hUAp2jasq7u1KliQBTMIn71ttTXHGLyNtli1y7ml3BoK4H2KtaFINZWUG9bCcylNdqy/41yTGgafdapnasWoaHc61nyNLCeWAlb5vxj6Bxb/UT/93+8ePxhmpissE+UsKn4RqAfeaR1Sm4edsHe6lPF26843tc6vmC9y96OhBylMzowAWiVEYFQ5VSkzZ1VKFJyhdJwHUiOgilmF2ly4zP4S8qnkBBixipqgZuByQ55LDYx3TCqfImVdKpdknLu0WoksEQkuGLYAq/exFABA4oKI5VKpFA5NaGyspprjWkNeanFKZyikeKvZ+ey2mLW8y223OazzyecKrKVC1IgJw2XkirihWFhOkWHaFqn4wESP+pTy0horEamhlbyKl8Y+afNY3GI1I8eZPnCtXIkBxxiW4IquqxBMMuzkzYrAeLIKGWddZ4l4SqUTkgsWo1xmM00RoNbEK221ZiLEVkLKuVVi71AQ70NXDzkvHMti3sVq3y4Dv3sIpRXgmkkVfdAs3Q2KWqOwixF5QUIoW55j8eXm3dnFJNuFqMR8j9RSQ6YaCuluOPsJCtf0XskFGGaClu9qVq3oUmhap+fLy+X2rIXQh0OOg/exUmaqMSFKVSUjMgvFuhhDcLbXBF4IUkZVusVKjWoptlaoFTrDGInknQs9Jw6wEVJKvhVHbtPCyqrDsrTmLI9kc0Nube9Cay7GAgXVlrZUcgi+pY14bZVJpQ7Hfv+wA9lnbguiz2+ixW7v93d3s5e//tK56atoEyOVS5UtAS25uNxaKbK1kjIkkFiYJK5N5gh6aEzKEm0Btq51mrNA1w4nLkbObRFyg1BLg1IZgVBkNHBsyqDmEohz1QNjxqrWCgFti4ulQbW1OIZcIkCpDBrAqo1trQLYzdUGuetUTi34UPmbJBHXaJQgoJoyq5RzbRVLVRUJgTUWgQoJViW42mKu2UGtmSCrmhV1Wusoy+JuHs+3KtLW3RYo81oyIFAF3QohCqBKknPF840RYN+JZdkQVIyFoAIRI8FwERyEhJqZI1EqbyWwhqopKfqGOJd5Wdh8BRaoHyMbihkqN7MyXHWCKSm15bZX2vIckbXGmnAJb87nV2oKc8c0NMSUfQMRyQMuVj2gqKCWunoExGZD+pSrSIvh7z91AERslzJtceKw6KEQ9iWsYWVSiV72rNK23mQfjkd22d4oBamkkHuSuKalZEzQaqFUr1A0T4cFfq2cJ8ISVEkMmrpu0+v5vMZZK2olrW6ReCQWqGRlNsE0wb600LKOm17SCwAnkMguxFgphgmmdJcqu76KGConPaWzFCKXUsvBpy3FbwzvqVRCp/tou50Uu5xdhcjxMlrbGhO8Q6yphJRqatKFdfWO18Ba4ZJJVqViTAthBhSHZaF13UqtnHvGDWM9QA6uu13/POhXWX6bIWH/MyW73XKCxW2i1YqYSjJUi2LFaMOs6I+iiseYMEZfa+I8KZ6VsoIp5CoxiRCh1doyMRCcS9kYodCKC5Eiz8kgRq5FriUsYVo2HyBHU0KVDJiYCZALCbJZI1vjpTBIFYgH31plpbTaNjXsOy0YdMmHmKA2aE0gcKjKOw8sA0uS18pkqNBcTKm0KDghIVFpHBlqKanJ/s70Yos0Leu6cZEopdBaYYq3JmMuWTdE4kwAlVqCFIyJmYEoKQD0JVKuUMuNs52VkuQnBrvUABjW3IhxRjbV2nKILpaYeGtKNG3QDqRG2Y22O3RVSNv1FZjqJM88ZofESDS92+y6Fo912bfia2u51dYYZ4H0jOYQm/fLxP1VSeNcXjbWkGorfDz+GyEyUlu32bQRqeOceH13OW/KyK4Tusd1m1xqaSUh7ft75ObApDA6K8UKS1gstqq400zHFF39MThGnFWGy5oYz42WCK9CJwvcu0hQmARBe4CisfVKS4baBO85kM8QU2HG8FhuSjhkQinJ2DEmPm/pfK3btAlIu92NDVLwaLvReUxVtTj3WoRQqLNFs6pDXUJn+rI00eu0ZYo8I265XFO9+rhFCK5oKpLVjhGD1ESNHbb2UILwtwXqhalzYS+p/l/mZe9dEvybaqwvP3QqdYYPdtH5B9hMY6nGRBC7DsGTKHWUTI+iezBsyPN09OucltbxizlctXnV5qmBJrpPsPrqE20NnBJSAPEqjVFaqUole4JEwPm0iEa723RbFpfKjCHzhoasZBsDrkVhekTiDfkWHAZhzLj4wCAHt+yPAiFVtubYh8hasxViq63WnKNMKTLelPasKkhUoNYaEBm0hSEJphBErlXIUoG4uANSyBOynMtEqzEqM5EaTcCPPiJHBoVKbIJWSYE1ovwBueGS5epziikWzIC6xDgPtusKueC2UlPLRbVSVsGVBfuoL74u2C66S50OI/C7hx+YlfLYV9uE5jE7Eok3JuDIxXB93kDtlcHF+ZhPiBPyZnpeSTQkorvlprWxVu22QtsW53VjIiNlJiJX0ijTmCAmBHJIxQNrmu2AS7/FSsEnX2plxFspKQRli+yFGqxipmaoyKToBdfKO2MYQlrn4GPitSEPgvHWKkKxjNdWSySVmVQwyGDVK3LmS5HljmGSPLHeM7ZfV8vpjBBM7yXY3aE3j8Ye6zyF21uYZhFdwHJGdFLe9cOBdSGVRYJrdWBNVWa8rw0olZpTrLhWVhtjWQbA4D256q6LP5193FaBjbqgTO32/PGRH97t7e5dmPeX5SdXfrI9R0k+qSX8KVzuShxV5gdrOr71hg+9MIpzbCkuwDM0YFS5FCSk5NGomx73Ut4FJ+ebX6dUo+Z63u0PXMjoGiXAnIMrrSJjXCpszTXAzu76oeNCbD5GV2ooGbLfptq821LJJadEJTBgjAmrmZSCcwJ4Vynk5mq9UtvXSDnfCt0qm2p9Cs60OjRYQ2BQFWN3pV0azKlEwaSSFuWJqoQsiQAYZqyxJQQCoJAbAGBliMiQt9zcHGOYOXeC3bciSwNGImMr5BuuOUF00PxAeNnClbEBKQ6Dur7e5/Lc6gSpB+WJCqNdQQOFYVM1Q4w5+VAkCiZVzzuljdz1/aL6wu4aDkntjbhXTRMSxvNKqBhXnJvbtaViU8xQHxq+Nn4iOXIhGanUYgwlJS3YpYEJHv0WAaC2hjVzXoSsvNZSK7RSKyLngmsCqoCoUSYMOTjJrNQig6wtEmtaVyb2hYY1suxKSHvOTam8kRM2N55dnEsOhJKD0kaV4hEryQYaeWlRxscn8/S+aVtb66/T3XKeoFbJObGxNjGvi1TAWDNSdTo/vOvlvk+C5pSvM00T5lCoLRzQaNCyE92kDOOyX/2aUo1YVm987spFljhqDZzFYbiBZJkoRgqpujnkxVOJkjcGa6/1/bH7/nf34/3v53h4u/60+V/7wR/7f59LOt1Or5f/GrdnhtWk/37fdQI3LZhmQpLkjLnkU0mVEKA1BEIkKVjHuHi6XdTbqYT6K1TGGSPt7fDUyp1bGUOTgnMu1UacqQQtl6AkU5KMFIAcK8M6QZ1rSgVKBV1LIygMGyMpgDOQHIsUA5eqNahNUhWFfKu1tRuXG2E1zEiVhRHIdPRl2dYYbtSwVq+NYK00FmJICiyTCok4YxukUEuGSq22hhKglsILIpM55pSKm13FyKlKlRp4Yilja6CJLGseMm8ReMmMsCDGsDHO/QZQYw2NNyN4lgw5I0KXm0nAaiNEzhsggKhFsiBk7vYd523ocXg41EFlzZqWVWhg0q1udSpHXSt3W5kWTHPZTrXMOmUFolXoc5Ul6i2/5ASd1qJbiLEcOLTaWlWCA6/Eq1CMr/OlMS2FBAGZVakV4xS2yBXu7kxNpSSKPucKSMCV1JbYvkLn66aIcell3soyLzVHIiYFN4ZqrgCZKEqhCjXAQjxLjfdPKmP3/sPh4b1uTc8XWmdO7E0qC1mnNIa0FnSMCWisFdX1t35nijxMk3x7nV6e/fXlraSbFV5ktchodeQdCEXQIhTTGkXfVtegpRh8iavaUEkU1Ol9l1osqQSXakgWI7GkKVLZGGkpe6U/AdNzON1unxWXA/+4OxyYZnavapFu/RvUX6X4ZkxDICGlVoZQlNaACSYZUWOcE2cILFdxm8Pm5LLF03lB8ZU1aYzQZqfFfvbgvBXC+3D2uQEikQQQObUqWi255kIoJFqj1gQLiCiIAwkXaiuh5YSNcc4ECA6ZUAGa0uacZKuK10Nup1pfjZKMdGcGrm8oi0vrsqbNz6UGVlkrBqqRYu4kKY0SPqW85bY2VKnU1BoBYW2IIAhLbdQKtppTiiESgBGGhLHIgAPyfGutJGhN1mgxZdHIiK14Ij64/K3lcd2SkBOrpPiBq6+C99RYrq7WSsg4ETLGeWWQCQuHolUiQmP0/niv+t4r7iPHTVCrlfK25BTUdQ45pWVuIanT12fwEUOj5glYaA4oSlUbb0oJKSvWFqOjpo1mJTeleaGEHHSnuRJVqioNNcazaDFETQqxSi04k9GxdcoNW0PWiBojlCi6wHa5MgIukmc+5BBWAcCRZUDJTUAM6ZzZhec95wQoQFTGWT9wMu9Rd6dot+un5XTy01srR2n2LsbN1ZCIyYfNXTlrKOq4uyuFXc7b7WW8vizbHEP8XKNnBZOAlNfSeAEVC7+tsKwmJXad8m1dvb/Vugq8ulAPfUcolNgXMJxukuqha0z6VmarMuPQWwlgvLvzxBYX5yvd4kpRCm0Gy6U9d/ZRg0D/pPo31bHGOICQkudCJWc9aKlZo8g5E1I0VKWIaUlhxRw9p4VAcMpCxOPwG6akDxdU67w9b+tzgQcgXQtx6BpEjgSVSmrEUXENqostVUHEdUMpmeOUC3oClJJpm7u+omoRSvZqW3ItgfPCOSc0RjEu+G6ngO4KPUwOb9u/OrcSVMiGQ8w1Yje3ahhITrkgJMDV+ZgJUUJFEoitlZQQGgEAFERi1KQg3TVt0YShUgVSW0o1QfA+pHOKrRXdchCVqMnR7GOIFbJEEBaNqQ0HBF5rq9ATco6IiIwAReWUGGtKgTGitiblQHSfIqHi2UMknrcYc1jm1a/ez3VZk9vQR3U5fSVYVCMBSrROyNgwN9p6o41unF2rZyknpaMQFhG1ET5HJjgg58f7oShCjkwylKzGmAP4LafgtZUATZqOc5JcpFqIV+Cc8z2AaEWl0HKCkjO0orTAmjCWnDJyn/21lS3WifeaWAMhUfCqDJn9bcPrhc2vlNZqylXWD0nI1T/f0jbfUim9ZO79h+7hUXLbz0teklgvJayhlYnYDVltVeS2pFojtBget81cz3Z2a0rb6q6lplad5KjgGMOJ0HH1MzGu4J1h5X7kbNdrFnIsvYWKTJmBWLvNW3My507QefKnl7dfmeDzjFWurXrFNZcPncxmZI27nAVgaTGThW5UTEAsSISAQFiZAJlackspl5ROuilgoVFGsLUl5JnricImGHFWSm4u1pICY1UILBlCKLXkBg6QMWaJNUINzQhYR6ui0KLm3uTdLox9KwJarmHep3jO2VfYhDgKemDiIjUoW1rZuTzELcc4YwPONGcHohvhZvpAnKdCxroUaAkspdRSEQypNK7U2Ckt51wyUqiACITIkFXOmpZMoA6tZcgsNWqB2tbgG+BIZDgbgK0hrZ3cQXlRmkroUK4kriWPBVJqsZZDqVRygxYZVs5QCmat6Dqq1IQwFeTsEweNTNSWM5Yt+81tbvW388RhmE7XbS0hcqwhV9cAQ648aW1WKavgvJdaigIYUD4w5gE8QCHWiAEDIkY5NR4Qc2aUmTU91kqxrSdfmXEwNSSlrbWjX2sVt9ZcZaHU99Op4CKym91tTWvNMQoCDrJVpUUFE2OfsOyyG6WMUoEcJPY/AIkE+u0Zry/z9eVW1mfN1q5bNLJtXua0fVnKtjkF5beH+d2+v9/1V1b9Cuuln84/LZev1Z1167lmUATyNZXSGlE9Zr+G9MXPLTcPaaEYLW6cAsvvGpdC5H7fd53ysXrluneSsbYb73PpmWjKdFoPIVGMJwTNKoGO6rjPybLs0pkL1u95a+Swm1hXiHdh1dJQKgFo6/damUokeNmXzGNM2ER0dT2bEH5SuiIrUIcQkZid6xW2Ibkf4vwnWfec9QWmSqoSIZ+F8nog54+5MMlZrVdrG8koFecgS1Z7XUY+xoCaW6ncfs8E7KruimdLQ2IE1Re8pWI5G5GHYffOdu9jSpfzcyxXDglZFpi0AM6bVAplJMkbsq3sfcq1QC0h5ZkYtca5kLYTRJ61CogpD7XwXKIvC98Ooo3OtkwsNsjrAbe3viRrgGHvvC18YTxLBdu6Ceqo8gIboYohSFOgaajaJ5ZzCSERTQKFkEryzhjOVSwNGsmCsvKlNp5nQTJn2lqeW3ZamKSNWxpWwhasyDGhy8N1TYyakjPWjbVSt8a6TNQ1rjdIgrMWawhOKlVK7HoFVIlz7h2QAl4BUgnOxc23jCluIHLyqeu6htm54LcgleZaAip/jaur0W9YAkaTA0pkOVRCwRgJRMW6ZitYr4eOWxqORz7cfX3+8tPPf/v5x8/LKcUpDsLYo2CofH3dYt18jbfotluTK41teJflOHR12Px8fXu7nN6W6VRSslJ3ltVAOUHNgMBzSmFJcZ1ynhNA9iKlzGsRHBqmDNWMcbc/YFPrtAAV0Tczan0QQI9c0TgchGjQ5HJL89mltPWDtsU2BGg1Nx/KIrkwUit+kGSIGqmJFOvVcKefkFFIWEtWwgRYeWFY2eJSTbnmaA3XwsaALVpWsDlZ29pi5I3luhLPSvXb1hhPmgal9qqpLRpX6lJPQoAUYJXSQtWSU51sZ1vptEYtVGcP2shWMFKRTHZdq01BrFJ1CE6YZT/eHfZaMR22UhwoRo5Bbg5JV/RMdMoIZfeAfPGh+GtNWVGPSBl8TLMkS4wjCo4HIp4a1JZV16pmbvZrOAF4CUcUJa63df5CKRjBtfxg2FPeAOStgvKu1oytkXMZGm8NlDIcFLaaMfsQcy6QMxJDXlNyngrzsiFIa6WSHEUoImwQys+ighSNM3sc9wCK2pb9rKQJMYQUtoDzUlIoSgLxUGCrudSqYkatDZABX4Q2KDPxKDUTqnWdJUZuA35dZlstlzJt4G6phKa1gpxBaCZICh1S3PycUiyJrM45uRTKfJG1ZM6LSEUIwdot+I2akoq3yjnj2iSutLRquO+Ekm+XL3/9l3/+1z9/Pb1eU+CmUFYhRsfYb7mMN98uU5hua6i+60/7D98J24DZOLX5fFmndZ1uMc5Y+9asEFiBudnXIm63a0p5DftldS663UFm6HLkrI2mz94l2dS4OzB+nF7t6e2UUQzv2OH7/fiwI3HkgozGXN6K75O7Cm3JdtyqsNYUUyoBVW0sK60722lV5nmblxZz1oCjadZSiGWaay3t/l7VOoU5KylycK3mh/sdgVqWtk2XmIAETpMD8gxbjUFwxngnhJ7zVFseh0PNNQXeKs7z6uPL4djVpox6YMS3cGtESlpBfU0NoXZyJGlSSRzjQGMJrrZuODw0SOs29bt693Cn++RPEwcyUs9+0/ZYaofJSCEFb0xla828+GWdkaaGTcgktJLLMQfOOEsl1OxIdTVzwPTh/VF02YsRfsVvP12WS0a4AuSYX2oJh53UQhu918LctlRzkkJwYsgxxdJKQsRaWvDVb7G2OoczopI0rjkywYh7JACGy4pA2gwd4AxV+JliOzEloIpWs9aKcZGjZGxjMhPjpfRu45fldZovreahERbGtDR2sNYKYYGFlHothhgXpMxY4+T7w15qKLkSNZ7LXCpydkQQSnQ++UquUbHdntmEHOLS/HbDikIMilNNngt8/+EOQMV4ZkFxxjhoJ4GTrhDdjEi8wabMbr+/iwl+/vrtz3/585//9eV2rdHrmDPmjUMAPin7j63INayL8z5tvqyqg+P9nWHf1didXr5dThe3lHXZKnjFh5TzvDmsqlRMGbYpCoyupNsW5zUeD+rhSQeXYh4LxC297kZQ5hAK31xAiFbxcd/u3/fmfgCmMZccN7++FB9rdpxLobmgksLWDzzlyi2TWiFhTktsS4ZNmh+q292uW+WFm40LaHzKsZuu6/WNn79NuxGUXbtH6qy5vejqK5aK7bWknHOOQR528u5gGvAYgTPJueesSKG5lq3IpTotIaUzQz4Og9F9Lrm1KrViRJwrZKKVIoXKHIix1mSpSej82HfGdoBtmk5cYKusFSImS42AUahw3w8Ed/4mDvsBYXHxuUAtzUafSomAE5OT0KPYG7dkyWG3H8a+q6VRw9ZqSX5v+oaomTC8X5KsFUqqQt0jj4JVIUEbzXkmjiVhw1pqbtCkJiAMPkSfALDVGmJUPRGC1YwzRYTAGwAiypQxFwQgF9y28gadPvxZ8X8gOuqukIpCRZf3CM1omIFKLsGFeYmrrw0agYfgD/b4cDjePx6VMq5ACNxtW8FLbfF4tzMDCYW1Oe+ptsLvHzqtjeT1fLsxxs1ojQ3ni1P6jrRr1QvSRsnss+GiRgZQVNeEWQFTRy2dGABg0dKiYMrnrawFOFrTxt0OUf74l/PPX15//vV2OjcXqIHIfEKQjFuua27787l+O21v08mlTXbbd9/fNfCXz2yNb19+fb2tbplrjIVLAMQGEFPiII3pGIdeHCmyxV2kHlmg25u/G67KJBe687mlNuz3p35nSTAffmXk390/DUJSVLigq1vdiptXWEckFIEXnzlrMW98jIf3g+46Uq3FxISETOA+fk3nRtvH3xxyMX/98evbi93vDzXiYHTNKYeLlCKmTOV/N9UglT4e9r21tznO65VLYZli4Dura+VKU61tHBhxEjL1nQ2uOh/HkZMwj497IZvt8eX5bLs2h1sFhcB2I5bYhGlCi9IaEQOsY6IYvVKWMy5Y8yGuU8UyVoCC6fgwvFNKClU83zpWavQ5LqXOMWR5VF2clm3zVx3vk3Cmy7rzgkSrCFVYLeb5FHNcVnC/YM4u3ELPUO8zAJbaCuMxZkQmlQUyyOSwE9N0q60VyIwzbZSP0cfImDR6dM4DBIEsxDWJq+11KaW1gTOTUgFaS8urm7yvaz69+6Tt3Z0SsjMqV9g8QuYlr7UEQoSqsM0peR9bzFQbjKqNvR4Hzii54DPSHI1bl8vl0u3c2B2Ph6eu26ZpElxgOxDb+N39gzYmpYw3vq2r7Yh0KywliBxLCKvkajeMW9tKqqzImouW3Nzb6tbTaXv7lodh6KQUUkKjUniMW2s47NQw2Ofn9e3lfHqdcmRWH0udU0m1rkx0yPSy1LOslykt3sUSQ3Z3o9uN3XReb8/LtLlpnlNrseRca8uVQVBCUAPO0RjFBQJYRGW7yNWQApRIl9vMZcltTRE7a3d3l5KxVa3EqEx/2D0tt9vpTzNJ71JiAfOWTLCFJSSqNe2OGoiPdzu764C1bb1iqv2o4rLFdVIKuNXKMGPH3/PdL7/+iCxL3UpZV+eEsHzHG9SUNLacFffpAjl6H63ZaaU2v5bmpJAlh5g329mG7dNx9EE1gJLzui62A6js4f17ojIMdZ6nVOL9w8C33A8jZ/Z46G+XsyJoDImkEDqEG6MmhWBMOucaFGMsIw7AuIL73VEbhrBZbdNKC/Jffv1pcktVvAJUykLdCw+SRaokCJXMx3Hfm97dnFR8WubaaH/cz7OLa1PYjVKAmGnnuRBMiIIqRAWAHPTqEzZVRZs2X2vgjO37Ixdm3S7ItB1GaOo6zc7BMBAnJiVx1mothKoW3NYgu6yNNZ0ynen4qoaUwlDLCdmS/SFsettyZWct5TLF86nNU6lZ7neHrrUQJsES51apo5D3XB4qsC29xMiMkUjX4WC4wdfzmzFCGd2SXreNM/r07es3bjaZx5iCVLnxwe7HjD4GXyMIZdwiS24Ma/QXicydAYqsTfrXR7ddxsEs/kLNRx/jrNOa1mkSvI6q1BilXKwSYdNc7hUl5wPx73iJViWo/2Zu0xW/3uI1xSag++1vct4evp5r2S7Z+xSjR0jQimhCjLtB7QfVfBGKlC4gJHVQKd9Vs4YFjnE6719O1Vgm5dkifTjo7z9+2lbul8BEz0xWh254x5KgVsoyN5UbB3DPL18/IyMdIa6+7g4DY2I9R+/DNuex65cVlilVdEIqwsMWVygO+OHpOwuYke6hTqpXLWnR5PVy3ZwioOs0QyMpQ3Sz6YSUnYxinolVzhgJGYRuUnFtacBu23zK/L7tU6wpoOxKTO50c9s13d3tlWKHh4/90CH3bmpC38+Tl7h0vW015sxjarWVllcgGPYd0K2zFiEvAYTW0ggC1rC6nF+W1QFzZXTTucEs9ImL3/QjdeN9r1xn1WiMpidDaO/yGs+Ly4q+C+6kpSBKiW5WqhSIkBllOGrJx1z9Fs8unhBoqcjzYIcuRhf9RjRiZSWCMjzl2Ye5YkpF3KbPjDGT7nxqSnUAa6hxPBC3XHXMjDrXGEN3uzQhL0YaoWReTPEpLIvclZApFJNYH9Vfcnve4e9bMiSlYvGwN8fHe7B2Tcb7tjqiREPXqcPc7WOTJyh8eNwxhmEqKR355798vlyvx/tjgV/QkLIPPrBh2DWKm4vbVpeV82r6LjN4edvuOefRl5Bybb5WfHg45OyJGAALwT+/vClBajAxmdiS2beHd0+52FovwdcH/Ru/BaQV6pqTl7JD+pzKt7i+a+3bw1N/f/yU1v3L1xuDZ0GKGCeo1KJmcLcf7g97IwTrOyYIEF0MSlQhMEZEREECC0xLLTmpHnb39ne/fXr/DrabcVtJ4iZNh+i0GrSZ47Zkts9zB42m7RuCyDHtD6PtBGu0XWchFNQmSSYXfdlaKXcPeyQokMIWNu+YqIc7nVIs5DivjBBkZeDK9XXcm5Z4q6wkYED26U6KPmWMsQJokFFqwUXPOMUUl6Va20NjjCltWm0BOU/ly8vLN4z9sP+6u6e74+/VzktdOJPudZhei5/V4c4LTvPipRLESq4wzcunTx+M5ZdLtHaQAtYvHosQqHP2Lmy5ILJkOgSmy6KXNUDiQ6+V1lyWOxus1lIIKNoYgVjW5IdeeFeRyWHfEU9G70JwQUYqTznXSkKYeb0uy5QRHqUohZ0E6yWocXgXfYIqp8VLqUpJuYXaqtDZYkQcGeMpopCYUm6UiMPuMOjBAEEpzYWSsjJ66Drsragle7+01jrLtpAFV3eDvY5WyneXW5RUMO8Ul/2w3B37h/v9uuq38+dlXYBAMwYM+m7HSCOId08Pw3G3XS8pxWEY+OvzX5W2xQe2f+ISC7EtFBBUmr6dKxbW0rbdzrtBHEbqdlIqDizP2zWl2A2d0WZZHSNTIhNyx0TmsgyDriAbn4ehfuA7JhhX1c3zw/5TzWJb/haiBcTb4pEJbEYpOw7i7/7xzvBPX0/eOydYygTECmDWvJrBvHs4SqFSjLHW7DfBmbYca+INkXdAmWHFvTbqLqf4eC9Gu98NqoYg/ayAAjM5udu3m1RW9ia75J6n87fzPG1Kw/2R5+T3RyG7ZAe7bYlxKqWBhJJTLVlKpoRKqfp1nZ0vrZKYr0Vu20bEjREZsWQfHeNiL7hppTi/WaUAY9cppFCRk4qprQ3q/fsjIZunRSIDUEyIQeoGwqfWGN6m9e2U54WsjNIU02NtDYGWa1wmtd5++vz1r+8O74w8XE++VtYNggphQWvt5raGhGCCx2XZGjDnIkBtLZdccypSNimF6VijAJCkEXtz4RyEqo/HR2iEVSnBtKbL1e/2fa2MidLvd8aygi6ENt8guEOpz8v20o0rqk+n262lvWbgp2LtpyZeh3F33D+EFV9fziEuxmjnWyoSqUiBxLJie0aQSmLYaqtSobZKWi4Nr4ghp5Ayl6AsR6KS5TKl4IA4v16vjceGL8YOj8cibz2lJ6MIyk6Jzo6vx8MegL0959Pp0jBybip3lTUhnzg3gitrhrzkHLm1nEHlJEPBvOVI7h80a0b4+/u9EHpdyOYwXc5L+CyV5N3BpSYOVy6UlLqgmOYFqUkpbYWaZSUcxjE8xbhMOefKwnWKB9ntHgwyzpVazoVnl8GLQdbaKWVT/QvKu6Ol9fC6f9h9+vghnB6X9T8Dn2LMW3TE2M6yw87sRiOplpKnZb3OM2d1v+sNaqmotohN91ZVIMF48ZIh70juZB9v/ttl0hCowdtF39KX1LbL1O4OvzvefTgwxfdXI6A02ypnjAfXLrfp7l4oNVIWfnO5VMa0MZqxhtRB8duyxoDH4yPTqTYlkNsehOhKrblMqiuj0pL6t1/OjPFammCs5oYMpe6EIKl4yiepCKFpA8Z02+Jq81p3awi1NsahQtyCBQaFPZ8vYG1a16/v2YcURXb7Xz7/P/odM+NyPmlAFDq9vdXj3X4cG6wxhNiLD/sBQ0g1HC0PQnDO+TotKeVSmjVKSVUqchoGy0iwAQtnIHWTSrgtpVAATxJt1zNGxXunDCreebf4csGsgSoTfrrk0yn7YP16IZCKiRxLrRHwRGIB4t7rdW21etuDkoam5oNu2FL2WDdijRhyErpjOSepubKKS8WkiCHclrkbx8NRNPDrnOZrWaaAwXq/zPPEpVdWgGhGnGhghmmtNFStlCE5QBPrnNe5+lUxrob7XtmX44Puut2wGwHrtJy9KzVXLYgBcKHe9zudaeL9dHzsQW9LWlriFeXxe/Xw3dMv/1LCMytCDVafw49lJasfamWtMgAArA2K94GQA0ZhljhRWLk9+nX1ymg1bA8f9qWuvN7Nb7frdDJsVJqt65lBr9Xu04fxEv/09PBvw9r99cc/5xysNW/zSyXFhJQSBytHKxqkkEFpYxoaBVJxxsHoR7dGqE9GrzFNkXxvWH+3O+ymh+NKWE7Pv7zehtPZ//oS1zJP66X8L8+D/pfvP3733/zjf9sd5NPHYxR+e1Mtswa1lbzcCvQ65wqgOJc5B8ROKDlP5+vldJvfOvtuHAdu3DRzIRoXPqTMOCdFUFKDHJyfbx4qas4y5W3zQjEW2Lx4ANubB2oDY3WwTEkR19XHrQkqoSVHNVfFe25yaOCKWObCRHkvlmlbDocj0BfOHpQYL6+Y8qUfxhLU4YN/9xuTq1jKpjVSf3buqVRs0mnTrBU18WXhQBUAko+KC05tsDh2Xc6leaGlGEd1jfj1+bpcZju+vH//eNwNNUfvp5zAL5qLqvsuo9PazIGvbnEhAva8fLy/HzsbU/mlZhAwCHsHVZ7fwjo7zlFbGAZoiNyJVFJeY62ztJwz1g+91jrG2I+WcUaMNu9vyy3m+DjeDcO76brEbZsuc3CJtwtg6XqEKmVT4Eg1Y2Q3cib4PtZLP/AI/dvpcrtNsa1MrsRw9+CGQZie7fZ3Ma0NcsElJWIkfFhrTJzEnkn93e9+KP0bYDgvm6+5H6yxmalkD+9366NPstR4c+u4+7Su0XvijAitYMLaHaLMsdheItVe8jKxlLnVo0uyROPWau6lC2tOd8oqobBFkZN7/vYrF5+MFlyJ/k3uhuO2tnl9aZG22lyepSYExrlWivW9Qtb11BPXUwg1b5zBu3dm7CpTm6QmTYnX2Rjq2MGq3i3PL77sxh3Vu8vU5oBZu8tVvi1yGI8Pe1FVuf/DgUk1r5OnS38/+CVHvzARa0uttVJqKa36VrFVCPla1um6rhNXru81Ql3X9XarKSc0ubFoh9Hqg7+RRH29rAz6eZr6u96lUyreCKrrtqyb0XuX1Fu9WSs5ZbeGmrEUqLUhJWVUWorkOz2ctxRzHFNhi2sJVz2wu0/D2+vP/+E//p9++dt0veaY/lWaxPSK9LSuJbQ3PRStbUzMwefxsAfo3XJLk6+p5rp2Q1c8d0uTgte2MawI5L17O81KSw8a+cfpmq9nT7wEV7wsgitCXXNYrov3k+pCN74/HJS28263IxKtisNTUmbShrr2aVs2yaW2dznWAE5wgRhbW32YGxQmsDIvauIku44QK1cbMmV7bUzfCDa/Ldtamt/vjZLq/Jpevga3LNllaIx3ThlqrSp6VyO5NURXMvzLsBO2+zsjUoHtcpku03q6TMsWBBv7bhhsORzUb3/7fQoU3FZqBJZSFMgJoTnnOO2ex48fWY+b6ZVWw7AfGAjOiCrE3LzsDLuUr6wJBv00EYAobesMTzW2xuZpE1I2lnyOXHBg++HRw6HU1hnN+lH7WTjlt3Uqhfbj0Orh+lxzIga22/36eP/p7eT/+OH/rDr+/PXP0Xcx3oTAxjrRsGd0OI6Hhx+Y1IRVaRljeH/sChUugUuspVqlpTxlJ1kcpPS1ZqRwuL9fLvrL15qLTW7GmBirrVlluBwv3bj73R9/b4dlWs/AmlK/91sly7GmsDmsldJWCzTA1SeS3fO3S27sdroqBd/9Xg6jbDXPp57kpevo+O5IhiFCRei4zr5IG/o+1hQac3LoB/sAHPx57YzmHpKaQ5yH4ZPth9v1EipUlEwqotOuG0mXso0L7KCWjZckd9IUbp+VFSlnhPeH36F53//5v7xd/maJ6767u04r10b1FqkyaWtZVN/pXVcr3D5zwXmtK9GXZcGyPQ36qcR8XU7z1RCyGFsNVBHc7Lm+3B/0oe+kAULe8t555re6bl6o7vnt7aDEh+98Tmk7SyPuxvePyDbGHGGb56J4KeBBbpw/1ZIAAgdTSmHMJl8ZUw2h4DLYru//jlffaI3tC8CorV787KNf1qXr1bv7rusJo5pOb26bsbyM6lNybBwAu5BbXmbl/DRNl3i79HY97vYZ/0r43durf9vW03W83rpUf+yH+uE7+/B4NfY+x6HAibBq3dc8NlwZEOeQJXJ7Jwp3EWfq5u7uoaEGLtMa//bPfxl4t+vo9jL5eent0PXc5RtAfXzaQYshwjTfcErWWsH7VihnTKVpLnPd/LZZBcOoQwjLfL1/6HHcdcYoXWr0r78uT4+fhve/jrsKyO7ZH3785S9U1a5PtykIznh7Z2U4HMfd8NRZk3PkggGsUpTjHTrnGuRaNoDvhu6xyn92y3vGRiFCgSuX2374ofn8/PnnUpMQJSQneWngr7eTOdjU9LB7v82sRLTKRFcZQgg+hQCIFfC6OKV0jHF2Pq9byuW2LR0Xd/fHrqtc+RC2dTPWuv29FfsE8S7M1dNfcTqmtYbbxlpTnNfsh+7u+MO787fzkuYYa/TI2SKV2q41u7CskcRkhyMxKNsukJKCJxvGahjtQ+fdxEsJbX1X8jydw/VV7Ydo+/53v+2/QGSMKytdDJm85JoxqqW2DEoY8LjdVuSvxHn2sRZ7O6+W99vCpul2mRzUygULaQ2FD9pA4ab4YbTRmyX95KcwXdm2FKTM1VbWnAKrFdYbm+dNSnG8Y0rJZd2ik6USBx3zCsBzCtv6jeOQvA3+V2O0876mgURufLPD7nB4ZDS0dDcvr4wakHo7z0w24nD/tFda3N0Zzut5jdfL5NcoBYIptWU02Bi0RgXoOtdffl38fL7fz3ZELaacd5cL3m7DfLUEStj/z8MH9fSxDDvOmYUmmMicM+9T2grngC3VGFsgfve0R6I1TIOkmhwA5kCXX2/Xr961yp96qvbd06fpOm9bOM/n/X4HlWqj3e7o/VvOJecCmLxfrTUlLBFtcLIVoYRxCxWPrSRtTA5DTZSjRBJ2iHd3Zv/wBI0NnT1fXko4D7qq+3eaICUvenE40N/9/dPTk71/1zgTae1Oz3W6heVVT9PWdf1wFNC60pTg9nDcL7cKeJTdpiQpVWrSOXS2vwkrmhQN20Ng4/ixO+Snp11pGDYjFXJkcYuV+5I852SGQ071FvzbyTsfU2o+RsZ5itw+ma4zHDS1fU6LsHOrzC9UvnIlU/IxBJ1PS1xjXhMHhkSECKnMv7xez9fWUEiDxJXKgpmXX9DFC/Hw/retVL+5sm2U/W3c9/19Uf2wbXKZr06xda6YhpZu3kV31V9/eun6W2lu905xLpBjnOsSroKOWnecC+ZVXMp6vq3TNpj3WMga9vr1mxYjY/V0+XFza6XSaA0ppZx6kXvuMZOb/ngNYV6+uMBjci78s9FKCD4OXa3/XOUSsj6d+gaCi7RtL9BsCpHDzsfYAABbbY0LHsKtAFLdMxG5EAjSRQTIpmu23zHGt20+HAamtYtDaL7XcLjf11aFlDHUzbHreV7mHJKrmNEK+yR7YrsHzTW73a7nt3y75dsEPmYb8TZXlz42FpZlqeW+338N6SbVnTZkRxiGj1xawFrLeylvwV9zfal+JNAcN2wTb5GVVpXuaG63522ZpvnWzqebFn2KZRXRCFUg+1i9XxCND3i5eSEpl9pIkiSuFUAsMB/vx9sttRz3x713QNyVkpFRa4v3qaZKTAILyJvQKZVb8Gy5TjnL18tfe4OCFVKPPVfrOjFzG7udYffabKbrGLZaktAapnx5Y6ubuEhDQ8AMVLdlbNmBpBLk//6BCfWXNX3oj7vdYyzAiiEFue/lw+N7nxdj/XL90tHvdQ9MVmUZlKokNhI5snn2p7Of51BLa6V554mw79VgQFBi9X3xQ9wK4ufp1J+/uc52x/efpWK0HIp7hVwBWS58czGEGBvdphtXJKXpuv5wvI+brFlUsC5OVhplZSO1bglIcOmkqSiumvcoeENuVT/0ymrh5ikFKFG+fHklVmwvHn4rx6Mhq+3Gnr99A14yNs5QKe2uyzJtEBHG1vV2muaKOtbtPP+5AaLiebG3aUtJWPuumXOouhbm/K/r4rcNInxLqSGOuRqsUKGw9mTE0MpaquACfFi0bj6C94W1WSmVy1JrIEa3uagK1BwyrtjgtgxNqL7mlojzVClu2+KWzH/c7+4701FdrO2UhdvV1ZJLU2Fpr681pFmP7XE3jO/3u6cdQBF2aL6+XeZlWtxWoWqmoRJ3EYAMUzqmQOxcIZQSH+/+MHSg+FGYhdp9Ttjo1g1aq4fXnOfbVQhOFJUe+U//9ZuQst8jffHzsp5OkxDDw/HY9/3mZi1w226vb6fOdinV7969894To1Bzyln3w7q4b2+n/djd3d8hIVLtdsJavqyXFtdh0DvSuTKAKkzv3JaKbySIqd14n+vnUqoSTDO5LjeApkSOImDX+uFIrLllu319Cttam2N473wulLP6F0GmkY3Z90NVOk5vLrhMJLn0xgw5p8pg/N4/yv7w8GnbhutllVTiMltD28ZAhcSTsRzUCgZ9gBKhJtrW/Pr6+vXL6zplqCA4QVlZW2oKD+O7se+s1azxdV6pgQBbPc7XJa1Y0tJ1kjAqyQoTQCIF7nI6X9fL7TUnfzjqrIO2tMRvQnWL3xzEzDfed8CNUfevb19TwXE3MibOp7OLf2PIs8+GrOnYw5N/+3IfXUFQ6wzLulnTZ/0riXwY3tmPDw+UNxdKzfM2Y+DrupZSOzM+/dCt8+10+xbz47ysPlalTEW1BnNezkRcMnEtb2vgku8AcjcYpYYNnmsVBO+gSWuZ7UKe7nO7tZoy1VKy89On4WlzSapOayIKvc7eU4iYozXNlrpW+pXC98s8KaX4+IYNY+2qz9JQxi3W+baI++PHQYHpupBSylv2kRHzge0Oj7G5/T3eP/R4P8oDh1rryk6X+XoLjGHf926BJEFKJZStjScvU7AJJ9Lb3YP4zd+x/bhnTJ6/WW1qgxXFWch3ejcefLvNzxk9QCKuOORWai5bkhq/e3yvGsvF3A2j0Nh3Q23V2mE4ynX1tcrJn621w2BLa7U259Jdp9dFQi3eF8JEbUiBLm5arrUbO7c0v2ZrTcptXmmZS4x8OsWHwzjYYQrw9LT3W9VyIBBScs5BWcm5AuAAvh90w+u3XxCwU8NFSG56In5Q3DASRv5GyWlZnnO7CvOExPb3vLfdNK3aPAqdfXg9zWx6c7fzthtaWsN8u1rN+p6/e3gPRoISpdbLFOucckjTFL5+m59fTghxZx6M0lhD14Ox6rd/bPuHR86H2ymfLr9wydeVxZCcW/zmbm91v+/7w5mod756r32q0225nD3HbbfrAIkTcUZvr1+lOk6Ty0Smc4y36aaucE65St1yjttWMe8qvAmlsckKLGFqKpjhmEvcprI5+fJaXHz56fLn6+Xj37XLvf3H/n4nF7decVm3sKyrm420/WDj5v/rf/5zdmPc0AfRuB0PH+ZbmObpPP14OI5cp17dC64E72uRXDAay579W2S0biGlcjzsxu4+Dpd12awe5rgMgx6Oxw+ffvj8y1cjhm4Il+tVCcnbMC1r142cOFAgKqzJfuwf3h1qtzDW1Xa3JdCWApwI7q+XJNhid4CQU1QMbW5bTDHW/PiwL6wfjoAyl3gp3iLh7XpZpkUw8e7hYKgwzIHuTP2NEe9SO4f6Z+zeePr+8AQ//OHwm+//oAQ/n9fbm5z4y8vrTzny3/1dePj+IaTaqUcpeuBfiDyXmvaHvtszptH23CSWnIzZVYeNcmsNGQcCQZp4F6QDTZGa5IJq5TVyiN0A2UFc0/Q2SxyUOUtVoOzDlhJvwedS6rpu28s5ri7HqJQTNKf8VpfjyZVaqJYA5LtxNwwmRn67TblMTOx9VlytuzsNCCgmyd539uDUryUKaIL4CQqvgUm1Y33YHZUydptfAm1pUbR00HYvr3M5X9Lmnperi/va6O7hJsLH9WrFciZ1uM7+9JzqdtmW+Tbx1UPLorJn0b637F7pQzdO3/1wv39fuf6tm9Pb+nL1V5b5OvcphphZ8/sYv6W0XC7I2LVWzLWb8k+X63U+99bcxiMX0gjWUe3vd+a2tLGzo52oqdoSgNCj+/jHo9hjzgoqblO72wkkVssg2d471x2OFb9u6C5v3Zeb/uu3+OPpP3336zeBzt7/yszh+PHTdX19/dujFns//yXHlRmuunL78lqnUqNZ/N+YrNz4EPnlsnz7etJyd98/8LKO5l5IwVRrHa3b5e69un/czbN/+VqpdeMg7o4a4Xg5o+RmR4kxaBBv25lbQJG/na5E9nLRVG0riFSm+Fdrhr35PfSrSLN9jA56ZffK3velIGY53Pu3BylvTfyM+cO03MJmSovdMIrD0o1SaA/AloVxJlR3TV6lLXc6MgtrialQgwtTnvJ/zI3Py1LLLS06u8N4EO9/ePz+D09i9P40zsv+Fv6r++K//Lxg3uXly7e/fBNs0OJ71FkOLTPHSz7kbJZ5kdXcrh7qd3q4xhAZ7jivMW+b/5b9B6mYMMH0nKg0jC7WVipnklVCXpHl1DI0tm4sFhyYZsJag1pzR6tfWllLTj9DPXRq342NKf719Rw3yUghYn9odjBSFwKHZGwaUhwzPzV2VZ20xrQGDTS1OowMub5dUmt1i83Fm+mUHY/dfvQpku6Xn/JueHc6X1rl3sdffz7FNdYKJXWCO61RpUmVowHFWbcu/cvP7fPbz+D+pdfawH8b2z/1Kt0f/jCameFlHMjYD2Gu+fxDNP719LJOKxfc+5CjIF64qiE5NPnqb5JLMxyBqes1nhb/9euZRRh7pqQqAXxeOLXdYfz9/6FDoutrP9/C88u3pyf53X94z0cNHQHw1preMoUS/cZ1SvlXtImGcWjv306nUnen5S8/v/38bf1TnZ8PL3D3+sf7j2G3tXB7n9PciPztWPNXzrpa4tevG9LQqDJGUmgAezvn62WN+frwXtlBcWZQqab4x7//oXvPX9/E3Z0aDw/Deb3/JJ9/vGCrsTgOjYgr2W9lPtzvQn7dZt8Qb/PCZOw6I7ndZkXVuXo5vLunxk+Xq5uXw90ueVNYni7LnnXdvl+nq+B1I2hVpnj4Nn2+Xi7of4/iLRcp/R03keNMXEqpbdctW5zmmGOzUtaImCSjzGBjuOyPMpbDvK1hgRhKa+3pd7ff//3vhvcP4TK8npaX09uXX59xy53RaRkvz+n6mh4fpXzIxMLr68vmHW8tX69LLE6PUGvbDTxtEaCJLu72/fXmVs+E2fbHAzLk/dAqtEpujSEEzaXWKoTIZdsdhbGYIyE+IlLKcZlyy6oEFybBktXaO1+8D9LW6ZVP6z6mmdjn7757ePdRaTnGWM+vyrmUUqm0oHS7Y3cY76Dw6GOruwbt9e1zStnYMYQspRW6mY6hotVtQpoyQdjo5NzlLa7LdLlctxiBjHOBwvbuGHsBO9I76kVTwb9dXvXbt7f5Mj30QMlhevv+buy6R4yqtc+36/l8E7unn03Xv321yaTLdFNyh6hCWV9f5vGAu/14LS34WjkFwBiw1PJ8nZctXOc4sCCVRWx+jbavCKIVgHbm0hQvt6lJNlpr2Y5V3GpqJDogirTlzRkjKyVkRFy8frmxCP1uZ/diOPZ27PfyuyHrUvdSPN7t/lASVnxDqDm31mZs++hsdhqoA1ZiKVIZJRXj/Lo1F5bHH+z4RO9+d7cf3835n6QVw9+j/aSke5CKMLIWags1lA1qLjmzSlIYRKb7XSO+BbcsTSnLiO/vOiF5zZk0KCaOw74bzLY6WF1DHhN8/TJ196ZhjWlmq4OaGAgXbt4v0DbIWrCH4XGDdpBM+3BmleUkG9/Gw8O6xNvFQeVDN56fZ9E0JxE3H9actpbU6hNP0cUgWpP3D7vf/N067O/Syp9/wh9//Prty4/rKR+YMsqAXIE1LgUw9AGWdfnlF16pcZSBSKUbd99uxpDDieF+f+hrWecprvPWatc/huGulsJdBmgIDRCRoLUaGCOiyFRVilKsbvXbbN1aY73UwrFWzC3HmGIjvrM7Pc/uvPA//fyX2+YECk7eec7k/umxNWguLvPmiRhRk9L0w1Gpp9v5ejn5GkVpV2OF1juheIEstLUduTAhxGl1xoSWiIt6Ob08v1xutyikITGmmIP3gzjvlFGt4qKnlKQOGz3HqfbkH4UUmxWsMf6i4h4KFF/ni1mWu9QamG8Pnzq7wykr9CoVdjlfcq7eNaHT05MdelrDCQByYsPQbz7mspZUOUmijBilRMV7ZWbdEZNifp33+6Esvq3hbteXKeSvM9MIGgtuAFi9LyUI09fK3WaeP7/OZz/o6/t3nx7fud+6vXPf7W/qHl8/fnzs5O8QMwBgzQ8fr5gMuvfrEi+X1a3R7Ey6bdAIatucaxRuwam9f/hu/+//j795fPcOUef8JIwwH1hTQUiGpYInQv327RI3N3RaiiZQ7MZDiqrI4lxIznaWlFKckANvCWOMKBbOyv7uPrey+WvMXkoBQFS5WzdpyIeLC2jNmIIgnNf55le0du26jhF2Hee8ifSO1II8NaaSr53Vl2+f93vp2nbc3YW1tZLm5VKjlTTUWEsiKWwQwDR9+O7QDcO29K+v/l//NH39/Pb6ctZNdDZUHXVPnL2TamhifrueX14v81X2R88bKMblsCNZyG0LOCQRzl835CT0EBORYjG3zQfdJUSGjWqqjDEpZQnB+1grxBBTAmO6Cu02+eBotwsiKzd7UZVQqUFA/GNTl+vlLy/f3v/0fL6tF1aGu7Hzftrc8sc/4GE/zsu6BXf/cH946Lrd0ABPp3J6Xp6/nRQcmZ72x3vbiUIb07GJENI5+BuHO8X2bmqQh9fPp+evYZ6TGfT+bjf7m/v1LDE87cVBfRCNtTS93iapamhasvCbu+6DxddXSjkINitocSslUnbWiN4ePh+ezN37HfQ+um7H+u0mYGNuc7v9/vEJnVsul1BLJkSheyOEW2bI1+LcIGWviWGQoh6Ge7WHu4djyuN8Fj9+21JY+57ldGWbPv/kmcbIllqbUiZ7bAdE0DXHH//87fX5fD8+SpzDctp38LtPu1799uvrwdTx7//hd+PjLq465VkKN5ojFi2ykdfHaVpj2lx8IyGtfb/Fm3NzxJ/10fzw4em7f/jtd//hngQCiw6fkFE2jObKSLRQ4Arh1i6fZ4PKCl3ymTQLaXUuTC9CmQo4F3+8TXE3PBT9r0SiVl3LQ6PNlylsgkgMfSe12Fz0sQmTSkNgpPQdoN0cm05fWREss+vXVAYNDz9h/fuaFRsCRtYS2UM1KCwng2PanMuuv/sDltxpWw65JBVjkeqynAGhdWMZH+WnP6iW776+lV8/Lz/+8mU5X0sSqNZcIJc22L+XFrStazTrOU8LY8NZ2MaVHmotuQbmSLOdm/3aLkJYbe6EMSRYRReuZk6VsyaUrKVWKkojCFGYIiiIbdpcDuVw0N5tQ9cdd/3d+5KX7vNPb3krSjNtOkTtADPE1WFJZtcZQkDK83bjLzxsn9895XG/Ozyp7/7w0H+Yy9b903/55fO//nh5+ea37WDr/iFdTlNtcjgyzjmXNS/HwTxypUotYT1dLpfX8ylBHg+7dx8+resanbOy2U59vD/s2kdWWE6RN8Yr8041WXb3HTPMne9uy8rqiKqBd6xWI6QZdPeDfPzuH3j/6TRPa3WkUHRlX3aXy41g8wmXZdo2rBhjjPvx/ny+TfMqmdkNyBANp+OBus4oLbmSWwjPr7+kaV8zMeEkdrd5WV5O8sT2x9GXZZrPfT883X2HGorLtVWj2G++/9ACEdaX5187ZcahN7pXpli+7Q+cg50vp+eXb8Fv/81/FFzyvic0HC17e8s1eMk4KcwFHu925v77ww+j3Q8Pf7zDrlVWMvO62BISxMIaT5ft+ce3+SeHSQ5yd+wJsbxeok+esa0WU5oOHpPrJEsxhlv51YwDE6Jgi/AVEWPsd4fOKLYhxWsSQklJ2KfKotRSKHM9h5cX9FNmqGtkSjglOMSnxHNIJx0ec7wVcLbfu214PkWIe7fdhlFcLn8iVIz10l45/Ga64fk6be4iFN4d9cPH47jXryf5+m05vUzL+lxL7Uxv1Krbd5ruzbD2+7thv4Ptr/XlkMooUBb8ked4vZwWavtQO6KY80WyPWtKk9R0iamkhFLaHMLb7IZPI0AUMktGQEgkgksVmtZDYTJlCPmmUHEooQg+kv7At2fNsYfUtvVfQu4O+je/Ih+NMAYBefAhhZoSclW48R/+uLv/4bj7rn+b4k//9Pb//Z9+9vOanHv38DCMTIlDibKklhLjSLmshZi2g9X2/HILS3l+Pp2W6zCOsqOQz+fzNx7bYMZe6zDfitgEGQp6Lw9Sy0b/7EOX6p74QYhLiT4VWQLPGaWpw+PL8WHoPn6wY1db8Ynmm5vmBZuS7O7p6ftpmt7OtxCqd1Frs98/RY/Pt7KsFBY+qGJ79W7/+OGd/vDxo5B9ZvB2OZ2nm4nQSg7lFEO/rjoDP1jCitsbS0FdFm/F6d1vHxoFQGb3u5phK0EPGkS3XWeirZbW6dSbvpQU0/V6i6yaFtfL1yaV64fPh4+/tWtv7ur0V3s732p+2e+k0EqOD8cPdng30m7FjtWcERlE4V5DmDedw3b1p78tPBbWwLL7bfscQm5lbDABo1RiiFBSqsFXxpRSgitfSAheeFUDjLt+3OtaYoEKs74tZdwZEpF3saIifPj6c7mc5+tlKre+7zPqv+2UHIai9e+qChEu1F1NNW6ltiTiObT87flL8mEymsQ/7brfsmrvfnBxrTFCgiw79/Rud//4XtohR5iuVz8vzYUBhyo2zqAT3++UeLxju/eDuevMoNfbULVKMlb5zOEdZ6mNQrVU3+Yf9/uOU+RNjN0IrVDVNXlClrJrkGJar38Nx+Mw7vnmDbFCdL2cijFWy/dgXytcZXlHoEPONaq+Q3MUZf4QtjdGUbLvkGdlU9fLHO5rjkLnphehy4f36t//ux+U4rvuPl73v7zg//N/eoFbcW/AhUGJXCmwTe7Y44e7YWClBMKGsaBkCcPb+frrz6eXb+d1ypoJxank27fLcy7l/vDwkR7LEsqaYDzrbsjlUXYNeXHXQ4FrCM+S1d0Tm1ObbqdahLYaNZr9aI8HMYwJe15MBTlNz+ucsx+ZfEHAdQLEQTI7l78e1R8ZmGX9eb7EmMpym/T9rHvJzCYGNtwLAP1yWa5TOZ1AxM+csNQ87N5AgGZj3w9dr7udYfgbH7bxWHd/+I7vRKsxuOn8MtXCdFJGDz5f3eqMkXddYVqFlBoPu6OGZjtjt1tMitVCqK66Vw9j2emP9S/d6fm1YioEw2jHdyMdNPAFXGJMMGTwC1z/ub38ehU0G2XTBVpl3dAXHy/TCsA4M5QPMeOy5tt5FYywNGFq5pkQM0JrxBXKkR9+e2xpqifjXVqWtbRQEbsxmzuRor2+2l/+cr1Ol8p+2Yl/xzjTptdK9/tDLc3FtK0hI0hRdad11/30Zf3f/vS3l59myN4ofvf4Fd/ZYaez025ZCeH4sN4d/t6a0Xt8vnzzYbleLmkWLOWOiBlrterU+4cPW7+D4284U0btdgNtxAAg5kYhCa57bXpKsSitCCvDkZNSElMu0RMnS5Ld3E0ZeRjulrgkl86bNNo3yM7dzi98GEQ/XJhKxEHrURnv44z9pu8OhnWSlvNPNystuXBdluFQ3n13uz8+rFMGERpoIeG3vx13454zup2WLZTTeXWXYlrYD9zupDT24em4v1eMCtMNGaOqkktUNenDNufp/Bq2k2CbVkXIO8W6LXjL5n/3H/5+6Fv6m3ybzrlALK8uztB2/VGQArk+gvLiWHlf7+Qnfhx/+un07ds1YOskAZVBMU5t854anWe/THm++VZfRWYpJaE6weXlOgu+bxTfrpfVb0AaEDOUWNzszky4m/fPV8sZu8zu5bxcZ+hx7a0hOHKRERPDPF/XGEJ3qMY+McmVjVBSusZcoqjcMANGtrblEiqEzu6t1YA1ZF1KkoqUJe99rpkXo7Uhwvk2l9bkrqq79L3kZidub4sP3i35+lduxz6U7FYuuMKq80s8/XqdX1Yjcncv76ylhgL5zb0JLlIuLkwudw1oWWtyALy1khmrhRXCZvfdlrZu7A8PXc2z9zcWh+ubcxva/dbEwq2S+O+XNXz9fJuWH1NcrN4LXollrkkN+8IlsISVWb1PEWZ/5jJ/O9N//svP//LrZ3AfOh1TutgwDsc2Ptyq/w/efxU6jgc+HvsahA8/h6VtM7iXofhZlayV1XIY+qEbHfVR7pUYI5MMeGlZKw3Ibt6DIsmblA2atLKD6l1kaDhvxghD1UcqrYQSMjmtlDD90KV1bnHhSs2IAtuOU2oZfPgMoWdME1sZwxpbS7FkLcQg+hdgKuVunf/mPfvw8Xfdw+X6DG6pLglAezwerILVbffHvm3n0i6N5g8fm2XS6qEfjem4lExIbLUopUpqJTGte8h4u10bgOBy2N+hNGyX+l1HnD3RrsOHp/sDBZgH/+4fHn7+81/f5rkQcvx5J3/Hj4cPu0Td7+VokAT4OymPbeLrOa7rOkRIGXCa9waa5tfL7dslFA9uSXbc7o5/mKel4NZqVIb67jepvuR2LQ19bWsMBeuSEkxrQ1pCe36ber3FmFPMhERSozCs9SFcAcl0VDPdrq4JNq+/IqOtave//Mgkmt14FO+g0nVb9LEKVg+PUrYhxlKqLdlwagSxVpfzxnkVRK1k74EBtSTSXDJMhHzsBtVsiimmcPscwpl8iNullXSFpJZ4KilpBXfj0UrNGUueBb8t7rIulQniErCOMWa3rgwplww1N6pcCmUFV7gfRmmk4tbPa/Rle0lCGNW91JxbM36529bp85fXz1+eIWeslRONO6464pbxvt98gDbnYkrh8zUlvjx8tNOkp01toSv5c1wLA7hn35B9CsHm9RJisbZn1Nw0vb1dplOCrPyW61Kb7wVX2rZ+n8f9prp62lxfO2yCaSxuun1l0T1zfoquW5rndebeu1JduFwJRE2Q4eX3f/jB9iTNmGr0KfVHPfQdl93qXvu9rn04f8uCMcm7/eEEuEFjrbKam4vX6ZSgNVO70LHkw+Ule98aJrf2lXJF5Ko+ftSSm8u8pJylghKcsjSFMzC/O+jd/T1xywTPOUNKWvAUPAK1XKAxIkSJpNItLr7eOtvJvem7fof7NrTHTwfOgEDDawtfLizY/ne8svzD7ne//JfVlyhie13/9uHRyY8dHTUONoa+faPX0/zTdH2NcfHhGtNcaasQGcsM3k7Tt3NQBaKLRBiGuRuEDwqqtkY7h+tMPuDm5iXgEgMX4AtptLGM5wvsdoPWh3n5XNI2Wqvkft18ywvH2g8ml3VZwrZ51X035Z+0MWt4YtVqy25pFj0Clsf3ZteL6IKEg58x5BTTYmXhgseUYmjeMYYyxcgIU3CiEsNg97pKzYXSXbfeNh+Bk16W87rOwc0QaokFI9P7HbdKI3V6bK1um1tuKueybD64oWOqNefXnFLmyFy4CkHHo71/0EwSkyil6oa+tBKmdrt6jtx0aWD6LYvTqR/Gw3QVv57++fXlsq5wv7sHAYdDYyLsDp0YeykHPfQ+vCXPn7++3U7l8ANpK98uKoTO6I9J/b/8mSQaPtxCkbdbz9jExaGU7vSSlvnFu6UT7xnV63zx603gYTB9fwR7iLorGdDQUzjr2fysrmbbmrv5srmeK2cu3gl++3zjnK8+TJc4T+feHJh0f/7TX37/d+/0YLkgibyxUjDHNDPZoWzdPpf8wBGi99Jga63GA2MEAG1m63xLMfB1V/JZWTnuu8FErLU3H87XX87TTyhz37XKkh1rBSzF7Y+aap1uG0IDrA/3D9PsayspBWoopYLaGNT93ZiDA94i5Nt6C5BFf+iOR/ObJj72oBBbgtLAx/oS0jVmiOLhqp6OcNjp37LDp0+vf/2y/vK/TrduN9XuP3q8/6GBWL76bZr/9ed//euvP/sNWmubW1OtputvU53cloq4nmfDCkdaJraFvz69u+/scX+8z7lWvO3wMXhCxq7kfAuSOKujkiPjDJGIcaCGaIXcO+/DtJRUOi3iQnOOUseHd5+mxfXjQ82vh7ujZI/Xy61JZUwQIyaXSTemhjTXMGV3Xb1383zhohljY6xQx1YIWknOSylC8Pn8xgX78N1H+SS52PGu7x6wXEspTath29ZK6nDoFRNUMTWeYmIVXLilWNxapjMQtXnC4K9c7a1UraaUAichiGvJuGzcgrYSBcfK3RyAAUdyczwcxv6Q3FwF/dH2Jx/D2+lvv3w5u23T1na2cS4Oe6GE2R8Gsjy1BIDhmr5+WX7+6bkf1He/fdwdu3/6c57XMi3JxeeO848fPz7t/+2uvzei4+zJ+/z29nY+b6I1LccEr8tS3eqGYb+/o2HcpO0a7bYtr+kbT8d1m6GR6U9A1OGnp/vPSOv2ZZzWE98dxmXdPr++nD+7vlOBT4rAr/D6ubz7IXNFUrA1VyFpmr4wc1C6Nw87M0zn5xdksWVtjS2RlxKNUarjWj48/3pqpWRfrmmxx8oHk2PRPKuqtqkNeZe2VYx4PIw+JM5FypUE47YmXKRg8/KakuvtgXgBxisFs5MlbLEsqYbqm68YM5I56FEOnxT93dIqbGfafvH+pz+n11P95d7jdv/+UH/3aowXh6d2f4+Hcv/HH7r/lC6npR1Z6b6jTriLP//y8uWfX3/96TNBKVEBEMlW0YQs5zi53JfKQNbFrUqwwaqcao3t8Tsl9TZNc2cFI+g6UabHu95pbqXImO5rdcJ8+fjdv/3uh/sUw7r013MXa2xhU4JpAdzm2nIpHG0Ye2aeXCe/s1YHf32S0selJK/wY4YokBdXJenJvZY6r8vW3P3bbeG8Ql4Vr7VU51xt2BpC44f+fQv19tfCro6/7xN9s/f24XtVkLdsLmeeVruTUnIqcdGCn05T9rX4aZ3SNj3kvBJxgoc1/8+03ZDeEWGrG5DWzI69rnTOgo+P72sz6zXnEpBFYlEZnqkF320uh9aW9vl6DecX0bzqZLH2ZPj3dw/S9Ne+00rJnLk167Zt61mdnpf5hurhv3QP/x3rBJDOtcZcOMG7B/6b79Sd/nuMYy4iUnk9nV5enpFdteiH/uCWtm2T7mjcy/3hAIAu5ApLjDHnnkoWBMvJ+xsp3fV2q0fdWpfyYS6a18yvZ389J++LlIXilmreycP15vstDlpV5mNYgje9eaIu2o4gu7DOpeYCWSs0HXclcda0hOU2R99LccSczq8BVTX7QwNuVL/NobNji4wKdytKLl3JCWJ334UyzctKRHY/Wm0ZsumypNZU14UcVj8f9J5JzpAQaFmWXIs2+vg0xseFPnqAOf3J/tf/4eXz//ZPeL1qpow7siHyHHRv/eiEvKHYtolst+/++38U4cwF0iDbC3z707f/8v/73y7/LGro+/HsVvAujUO3U79TYijw/zZ6vE0pebZt39Sx43I0Uhz3vUImqtjr/bfnOccmQA9Gd72S9l5rOU+XUtb+UA/jv6nh8ac//en0yxW35Wgh2I6IUi1qvD48PMR8t2y5P0h9eGH1gRFyxhjntaoUynarRIxgXRaHRWj1FBxwxbXVdaHz6Y1qktRu122dhy19ZRx2e7ss/yhFDenPxat5S7Kv39/pfrCoZXRNppZrIo3dbiDaw2lQJNZ1Xic4nyaEYvdbCJQmu0w9p46z0HIqJQ+7jqG0O41mvHu8744P6ylfzy+cgQ/z5ZJt32dPnrnbNc6X+PnrMxQp+I71iksYD/TwuLu7NxViZyXDFmJ2noUgry8puratnjWmGOeECMtglrbPD4c/HgwzbK/U/95/2iKe30KrbOy/Z60idaYj1aE2hJW10gdHLoVC59Jca23Ud1BaEy169LlCAzPib357RD1S98hjLdO6IamuE7WlafHWUD7Px7uOK1FaJiqHw1HpnrEx8VPNKaw5RMyZabXfHx5bbSWfodTZb+5WttnXzJ3zUuP7+yeGqIxabtPtOsc5ppBaYRTE/CVkduM9HvbHYWeZQh8CZ0Jom2LNTUkqpZRhGIgNCEBcUEWAjCxoI4CBOAh5eF+BhX9Wz//D9cv/+CdxnQ+jMUIz7YXRGoGHt279b+vfunD+15dfvjVij//NH9XoYg71f32dvxxOP7m3X1WYNo6MUa9Ntr0+7O84hILBsu+30NblVornjEGlEuB+v7/r76vPIW5McGnylN/GR3v3/qg/+uFgOelpNpyBUr+5/Xj/P/+nn09fPj+M+u7eXF5eN5AxRsXx8V2f0iANQifWbb28dEpGwoQNyNfr9RqpqO18vOtLfSu+Js9Y3pPUVolGrcO7222Zbn+p4QODsUXm43rojl3/YX0NGwVpE9bcCv//k/QXy5aui4Ke9zH8PGhi0qJ9dtUpUKnCILnjhq/a4QhH2B2FLFvSoY0LcmXmpEE/fUxu1G28jffpurbtGeSx4FQozjQVAiEVIaLlcnFv34z2iwnr9DBOKxK/obwJuWTsUybe82C3rP2LIKKpOzlQ2SDRtZv9LoSwLKrkpK21RqXsUCT97c1pNE9fzpejsVZvNnWITtalaesPH253fRuiKgCGYCBCoFA982XJr8/rPCuIkhACZISwGDr7xx+HefR99T1JSCIRAsnELXZVGgPcIyS0AkQsiEcuHQYbBJieYCxTIp5AAiIHmWIxIlSMttEFVCgs7HW+IH2uN7xAUFcHsrs7/Pr1zeUVphVlECJdVs1E5M1kwqVv9glLTBuC5DROdGeKDhgKBOuSMmFtNFBpHT1KFszXORmaUigwdB2RG0KIBxB6m7Uacy7e6r7t1VkBj+ziMg+Q4ukyyj2DEICSEChWqct5goFiRighlFBCUQE56BgdQJDbAEWNIwyZWBLB9ddp/d82599+adB4d8s2Q51zyviS0qFiLWNTSEhfVPyKrn8Cv/32uflfQ7vHhCKoyZrMqP3JlhZpgjGI79ruWresaw6Mv3758hkt/wdEp7YRJqih+05yEZRdjuEVjvu9NPnKa3L/h+G26Yabnbjd4V5hjoqPw9RjwMw5/NvL+W+//tLXORJunb9q4LwqJSeCrq/b7OMf/ysHEl1Gs/61resrhJkTCj04nY+b++YwdBQj7ykF7OXtTS2/4na5uduRBuuFAsZ1UmmFdzc3sVtB3PTthpQtIM85u5Kp4EVQ1DUCAF8ySAlg1Fai8sUsR+9wsTNcTsJqfB3xOn/L0HG2wcSBQhirdruBMYqRZrjbbYbHx5Z1PGbPa4wRvpzGabJGL9asMGtZ80aKdVlPR/f2OqZY6npIMUoJBcsfPhy2Wx78GJOVFc05Bh+0LpcLf3vVz2/rNB5zNjFGiiVsb969VzVxZzHBhCisJa9DstopYwGmO4p7tfiCroUfQb0I8R2IlV58yBaU6L0DaKaCUQBjaDLOsmHjuFsWGLyd9DMxy7KSiEHMmYRCbaTTGpP+vRKboPt51Zs9CmghteU1GmeiZ4eJpxxImQBA3lqKa0IYhCTGvC6aJ5oDTB77NZk4H26HqqYZeClpYTA6IEVr85oiRlBWgoGY/Wy99zRwq12aIpdUMim59MpltyZXJDwQyNRVReCqWjpdUBFaacKaTELT16RC4PItfX2m9v8kSDX0O0lWkC0IuaI3V+8TjEVwlhSyProGwtuc3Ovn+OXXeP9w3wxkzct5PcMEas4FwZma/pZ1fR0d8D5Vst42YrXj8TJt++1tvffaXY2x2R/TmdLe8uXmdjv82Lc/DKChQHrgSUkJAiXQjR7J53++fvvbX0hcKwGUCteLOs5BgjB0DcUQIUUIpviecl6L+Px8HI+aUdrJ1luDCDpseSfINC+x1PPoTq+mIHv/A7j7UbBGZlOdVxmfDtN4zKhILDbdewTR5fw1hJlz3NayEwOOMGiqRtdSkaPP0UlMAmarWler7LSGXM9aT+vKxPUw3HT1dw785mGByAybIAWlkEh5sx2aYUMAa7TVsMBg8Hxxby8ThzCncrPf7A77lNDTy3Q+OlgQI6kSVYx2uxNti2/uWoyKlNE7lGIctofLaF5Pp5eX7suX87isNi5NAxElCFVgTAhBQszhgFGW0WHvdCxhUdYFVKE2pwiK6bpzN5Cmaw/bxxLAF/slZZ2ciKEmFBfgU3bOJ87T7vZ2nW+0erHWmHAVjJRcYLUyQYl2MURolkgKThFaZxmrMAZtV90/3i1q0QbKRoZkAYkxUMZYXVOKQfIxuPF6cdYaLg/T+aoXTTJtugpSWGBhlCPKnPV69Ua75GAtBzU7mojVljC27zkUCCbkjSUIxZzWy4Vj1LcNkIhABgAwxgJcIi2UcKsTITxkX/Om63tvx+UXpV5KjxElGw3KrPxodC2rdseEULiJpGFwxfytnJ9UWMZ9SyOMotrJmq1hBVZxF2/BQVZrga7upg/ffdrstssVBvPjdP7zon7lvL7d3YDc2vFUYmoamYJz0aZQy1be7G/ZwEEHcl5jZCTJ4gGKMC3g6a/TX/+Xb5dvLxhn4GFTw6baES4bEHebHoBUDet213hXQsoVaTfdcQ0o2ei8vbl5IByirC6nl3lR59OM8bbv9psH9vhHKrfSZt/fpv3aZPffT/wXNa8UonXGlGJjJxgTIIBQX2C7LCq9rjVEwVIPLZfRKD+/WahJzSXgdD4TvYJS4HbXbjaV0cfffo4pe1HFzSZDEBr+8PFHKLiclyA7olUGLlqnciAMVSXZApDsmoLp88vb5epzgpuhM/qCULw59LtdtdmIupE5huhNCF5U0lnjrU+BY4IRwaUoQuzhZnN72CIgxtfJxghghLAkEBJKyqtpcQARzmmO3tuRoEDZuN/9l93mHeBaLWmcF7ciRnLTVhRuvV+9XepK+2inZbnOeNIhhKiCgr6KJUke2gqRZbwKFN53jct/oBxwceK8qxr8+PhRNO+0fmUi8H7kEGsbXn9vYlDbgW/6QFOEOeKMcSEgixgy55yVQLYisyKGCtK8zsuyKlhYsinYWIxFGZYEXIYIM8kDRCxHOJ9fzKo4lyW37Z6kZBPk2pu6qmTVwJKddxQASbE1FqbgRp8EAzUzYwdijbne7FMB4fXnLiXC5cZ3o0RNTCBe75JpLkte3ZoLbJoOlkhrYPwJEsDrSgCQGUxRc47uHh43uz1h5Pa90Ofw8LgjsWGw0dQ9Pb3dNBykiLp3AYxGzzknM8LLk8HPuq1r3tTUbUBOMCF7kU9/sv/z//vP85O63T+EYCsqIJmbtmfV3UaCthEJWtHcYYKP56taVMnFKyJJBXnpG34YdpiQ9fSNcGXXNRu4+RDv3t9Ud4x0BUBMCGNdGu4yyqIXPz39/s0rteo5r8AohMDMeQ1yghTChKJ3ZekvqyONgDvoLeT1BsE2xjxZdbxGbRGCbB5t2xBA82Lxy+vl+x+2AIvtZrg99M0hGps1ZmrW1vquwyB7BDzFCRDYbjaQolHry2KMZxxHXEJbM1nFtkFdwwURZnUhhhBAAbX1UKAQVDEX8fbym57Pgo67TfXTx/3j9pAsLFDY/BmgbYjIB+NCUDET0TLM9WqiP1fcUZIruqOYxuiWJ3w5nZ31OVOMKIIJ4KNgFcdDLs0czK+fL6/TvISQc3G5Ws9vUsJbkYb2A1FvY4vw7v3w9frMBEyQybYfdk1BZbwsEciEahtwTGBZop/fCCLXl+zOjRA1xBhTyyEOaK62xBsn6Qb3hPc84zBOF2MVJbKvKkaILSqDxDj3swIQYgoow9rky3UNIAGkt1vBCHBaIxIFl5WonPNSMghxziUH50IWgsXVpAC8IaThGPiub3EOhGaIAhOU80HUom6IC6RgcL1cakwRwd1u13QbDJEy6+v1WTuVJMxIFFFUnCrSte1mt/lQ8d44Y30qsXx8935+W2M0sYz7e/Lh4Ycvn7+pUfc3DqI4W8ZZd14A+OtZqfDpj7vY63iVnLHTz+Z/+X/9/vzb+rjjm4E6W4KD0RTckpudJMIkrJhMMVWXq/n2zRmlrDab5tBtD03NK2l0emsqcXr+patuCegP8vH778/kHoI6AMwKppiKwlx30xCQLUyY3KuLPr2qaVxzcaVArYLTsuGqFYTQDcRJVLTa8+5wsAZkD91xHo9LXnGenvdN1fd1YMg6BzB+eNxWdalr8O7hnmDkvf/9t6t10QYqiaAMORfautY4A6Tath02Q0z+epzGk0OgriUJ3uz2XdeVuuZtzQkh66IQYghIYy1lXMXh5fXzt9e/Hb92MXTf/ZQOB94NLONOxVF2hPp7h5MB+jquUReQKU4xY1f0wknsmoYQzIl0E51erlZpkFBWEJSVIBiDJ6hNMCOKXr5pB/LbRV9Gw1jHKAtuE60hnOISJAtkGb/2kt8M2GPRDXW3u8H1HvECKheowZwlHSD2EFMm8W3Tg0yXc1YTnq+GVxQ3a9s0qUyNYCXihvTXPHcftvP5/PbruanrqmpShCmUum6RKCkk2pWYl4IypD2wXKvFpSIqDAoBEDinGSgAxwwwxWxdDEQAY8or5leHEI2hYApLBsAWZ3TVyBgBJhBTLBoOURZt7dElEx59xpwVfJY0y420Gk2TOl6unhLMhtVZtcSm7/uq+njHu5YLkex8WuYJxEICWSdFC1+uY0mpG/r/6X/908vr6bZqtu9ba/OXs+t7eNF6Gs/wl6WGj+QHGF4UCPTXf3sZjxfJMKsU5olA7wOuG9APQMj1eLmUgqS+v1yez+dzcNnPsmvvb4auqSdGkRS9zfA6jZl8IfgdwRJjfXoqjTOpP4P6U73BuL1W+664wqBfY4kAIdB6R/5baYg2UCYpqY05cVE5J2K+7OW2OTRsC/VXp7TOYS7ZlZT5AVc9oxJJ3BvrUoGEms2WbfrGG39eJohyhLnt+q5vGk7WZYaFggIRKASHpqEElXny5zdNYJUSUOZVSrq/2bVtoRQX6FIuXBDOpLHFowgL/PpNPz2t6xx2La/qzWYTGcMFcLHT9XaLCJekNstFe72q4KYUTKwwpNhglLiAHBPOKs77sCY9OZCjFHVCDKFQVTSXBDGeJ50KvKx+dVdlFyoihNBFwFDbtB/0emWITUdDvrz8PR42m3572G4wB1VDSc9kT/ltJ3bM++hPtukBBABNMc8++xh8RhgXlChnRKLh0K3WwIQRIMmlkrK6zhCAT5++10rFALONGFJKGCYA4eSL551IKSUIC2IFMWMyq0mGUEhCKEc4lowKLO12Y07GhMAAKDkngJ0NMRFJa86HoBVCJMYIMsol25x0ChQB2oiAABUMwCC6mgMICkhReGcNRInzqm6mZaQ8f3fYtF0jm+rxUMVgXZoJxJIkPfvzi0out2Jf4251+vQ0fnt6Ioze/Cib/ePrnAHMMdkMEoA9RRAGCieEVvT27ZxXcL//+PZyXKeL0RYhGAyMxSO4Co6D75wPM3ha5tlbxzDr96HvLATWmkCJZBzEBM/Hl/3uu01z5ww6vRFj/kKOgW3z5oHn0DeJ4KGUHGSdxW2NU5qflxACY4SKHIMryDsfQvKYUYgRwTB6Z66znsGyGJQRAAATSKtyqN9RSnIymHOllfU5g0UKac16fr7kHIZdDWmbMsGMSA71kmFmr0+Tc6atawTKNE56KZt+WBZljN4c0G7X7vaUkkwwDt6rdY0xY+wI5ZRA6/VlCikVDvqmnvq+MEgY7is5VLc/d/07tfQQrJxgFHMJAWNaOI7xv4nUIBQHoN5giuAUA2AcltCkqCHUjFSoEAAQJCEBMs7Ow6jMjHGu+yZntiw6IV0gPNzcphCevnnyMltfVoSa97dWratBuWGIbTeUM4QDFljUrK6x1ZFAtC5AMO7iBPNMGGGSYVEDRGMUbvUpODMusImIF8oYxZQzmR22wSOQCsyVIAXlGADBsqKMUH48++uqfHJVKS4pQGqAoPcRESJbAsqKRN7vh6rrg4rTy6iVIZxWdY24mJ9f62bjdaSYWWsiRLqUvqoSpRkliDLvK1JxEIszTju7eBcRJE1FRKmgeH83/PSHdwiDmMxknYpectENB4Dnr7/+Op5txWq7KiykMmWy/magjx8P/+n/uvP20X9ZKXxrpMW0dA8Ph/eAb5J5Tfpi1XjFIOy3d06ZyxTWo+IcMw4jjHQJbqERolRgwdP2Vmw3t1UlUjpBlGo5cLZt25pxb78+C8Y2wyfMqTb6dQlfLpdFHdsN+Q//ycJ3d1V5tywrY4ymWFQIrqgxHV8WCDOAQNZCSCnrDWAMMlxXedgcCizuNc/hKxeVrHe61BGsgV4F/QphQiWczrc5U4LYZL5SmglqAcAQZkZRM9zKhlcdPr38ihH3OllTIGSylznF62XSClMmCQ23G/rdD++qqkIQUsRLhskjtVhrIwSh21CIil4XRndCXGD7i9D/PXPt9l43+57XXQgyFpuJNddqeZ3AGgSFgFGI2Oniz69xGmcO9W64bAf57kFgvBWi8+BZXznKFWcBYIAgyenAqtPy9mRinxNt67Ziex8cI9jSUywJ8uE6g4wLwWx7VR6/zX0f97dbMTBbgrFrh4ZCIPA5JhBTjUDS87Fm91ov2uhKVlVXxbwul2hWpddUSooxZAvrgQ7bLYJwnTVCpCCEEfbOE4IxZs55zillFUJUrcC4BaDsTTQ2uyCdn13JJUMCUYYglljVlIpUyoIk2b3fEF6m07KoBWKwrmtdhHMGCQ4grdstBLTtCRIBEJRxqVsJCCdyCVgVT5GMgkEkUQHl5u7ddi8YlcHZdUJHddnebO8/PeBCwlQi6GZrL5MFQMTlJSQnBf34g/zhH7r9h/23v5cYAUEJQJVB9LDud7cFOT3HZTlXTcl04dj8tN19+dVfTy0Eod+6qmqbZjBrpcIoK1YPnx5+qA6PA69CCp/i6gns1OX08vqcbN3L3e2hRyRqb3RcPZ8g/H6ZqV5PAk7LMcb1Rd79H8WmNjp/+afnZbTT1Te1KDkaxRKVqwne5WHTFBAztIQigrn1NNvJOAOj9rZOARVI5uU2p1RKiBk470txQvD94SZqwrE0dkYUSklLSc9fL3Eeh/Y2BzK0ApEEoea0yf7itUvJDn39/uOurnLOxfuQIEqxGBUJZR0TGBNMy7LMwUchluCiwHshCCHBB4Qolg0vFcd1JQA0+jpfVUM3qEsJMhfzbK+v1zBdISXLrMfXc67k/eHAGecovnP4JZWrjwNPHFPi8ilFicEthCdGQMUYS4N3ZxQxpXEYDuN1BqAqxRNGOu0vAWnIKeEoR0poqCXGKABEKadckKwR5aSTSB/h9bQIxiSvGilZxS7TDICjmFFRICa13LEN5Y04v51zQUzUq1kYxxhDWnLwyuq5kRKhzATSIy/5SEjMnq1XV7FU86tkeyEaAJK3hfPaOcUEgCVhiCAppAIRxlyIM7ZnDfQLaSJhAWcpSl13XoiIkM+FFwRSdhhWUGwYqOLFE36tGGICErStqsaHyXltvC2gaanaSo7ZasbO+mSMf5vUOCkLZQZfYlx/2N6yjrX7m/V3dvz5RJzlsiNCNB3dDYiX5vR1CRE1/U3Xd8f5q1UgBdNvXAP76FXfTpgeBBtwK/ds2h5Y/33L+1uTwPk0+lEnC9zpYqZfPv/681Bv9v/Dd0LyWeVpytbSGBmk57ZLJL0vFrkJq+tawls6+tX1r39RMYaYlfPjbtjKjBXbGbOKCkk+55IREQE9YbZB4R1OYl7Glvvb7eabvlS0AiQbbdWqrIsh2boFw+6ubYdSNddxArDMdkrHz5zW0QmYhJmDoBBAVdW8oOJNBgULge7ft4yR6GPURWsrZBNy9sEnHKjIm+3GOTue51Qi41RWsG8Pp6MEMIiGN8M9G3JiR+L3ZWKnl5MaIxfbGPA0v+4P75xTq1KrATZVFhoXTYD4+YQQdNP5pcYQFV4SIhzarDiubOKz1lTQNAcAp9WsheBkDSuRy47xHaulTci6C/E+YVxpHY0iBLXe+Qjnit+iBNWzdc5YTSlQGIZWYlqTaBvOd+0eni/j9XfFK1lV9eZAMaVd3wOiIOfLukzT1DVbhGAIAQMEIeCCpRgyzrjCEKYcLOG2rutlCkIa7/T1NGLY3dwoQlJJtQcq44kwhFgNMS4R2sXNlwWj0ta8qWTJyC0SFOxhpKQAmCTEwBdQEAg4xOJtZtgGw0GhVWcqnAlNGODkUE5oPuMCFaVonV+dS5rDLOzLm//br19+fvrryzqakEyuEJg4LrCg7GBQ6fj6eb1Ijtka1DSuAMmP9cM4Tdbam8NDLTpeC5f288s6ntewehoowRKWDSV1SdAZRblthn0jNr//JfzzP/1tnQMtEhZ0fT2b+C8A+ULyt9ft47vHqq9UQZIAsuYWEi46Uba7ZpACmOl3BML5+HYak8SGUXw6eb26ro6VjJEcQig+LctcaWWqClRViSUjgMfLBaAsBSslAphlRWLIxuKYSYwm55QTZpQzSl0Kar2EYEFxDkCjJwIjB51NAdMXEJseb51p316/SCk2W1LJOoOYkouZrzpiTK0HxvkCYQKWiqSNUT7f3DxEDzAbIIw6/Nxv8zCgpqZK6+Wi/FFQMh+PJgSBolbLFZHJJXS6vjrVYD5RaEt6BKFalX1+9fOyGK1vNz/fdR/3w03Fiok22QLLhtUuwLWgG+XKrGzoJ+enqmKH+20isK/7PPOn0xvBzKeYAWano/v4QXBeO6NP31a+wskiZ0GKtcARAQu6lNVLjjYhDLKPXgkqZdVCCDF1MZfVaBV+pmSnVMSAcsyMMnrRnJBKSM6YB5lQjCkKLnjnE3CcD21dE9yva/beRstSSjEZTERKPoQEoDx/GY3xIHME0HhVnJBcA+ei1UZbOmw2zp2UujJGJBElohQKDDSXGH2y7lJQpowWEDGgMQKXQPQLBFpZk1zOCZgVek3VZY3Parby29PydLqe1hUAEgGlBUrGGGvd4p9+uUIourrOEXkfHKSHzY4TZsMquCQUA5Dn83h5mvVpBTaxxHJKiFDn9wUT6/TpMo4zSHHtT+H3380vf/qTWi84I4p5diJThGlzvmzIby9Myu/++Ph+00yzdlDknGBBHds16MZqHcwDJ2k0q1lhRR3CuO/q25ttCqYkkzKzrii3+MidBd45xKdNLyqaJOfOa+e10v5wGNYlhpQJw13fJ+CczyGAl2/H7EFKqSRFMaSk4YyXAlLKJVMX5oqZDIAyU7QDpnG37xFxy3KWkm139TrbvutSBqfzkko4j6+ZTEiUm4dNuxukrK3OtELLvDYHsN9VQiCvw3qBehXR1XPUy2wKnnPwKYR2TwjJTUO3w0eV/jkgHU2TIYvJz9p6UBdQ66gX/3IQVNJ3hArCBYaGgqpp63mykg3T9ULSllTzsMtVdwLwIadBKZvyRP7xP9+/vY0xyUqGcVnr0KXSHr85sQJSSxQRRVgCihGdj6fiPIA4BX0+quBjt6nv3j+qVSl7Ws1SpjUiA9PsHeBYXM2kFpVMjBggjKPPOYNSoHURJ5JjDj5D6Kq2SFl1LbXWEiwIziAXUBJC1PsEC40OEiC8S6Xkvt5yCoMtyzinVBJM1i/WBa2yc+ltPuEACSQVrSinlBEIsfFjzDbGVEBNqKSM8iaG4IBI1zN4fRqjpWZec0lpl02q51nDWFEQUwYQIowxJZQymh23a9X1rQ+5kRQQ4UH17vEAksYJCy7t5Favzm/X8cmTWFouAGa5CQjT84z++ttvq5oZx5KpEmafdpV4uD08/m70uk45agJ7lFy2PiSLybLZNHfvxeau0sbttlJIiBCoKUqjVcsFI5wd7Ovtecx6WXb77ePjLhV8fLHOoufryzi93ewkZ5xxFmNcVsW54TBQCquma7rKuGK9plUdltF54wPAlKBIKJIwx9PxOgx8M9Qh5BxJjJAxmrLmFbMzCAnHrIB+aypwv22rilnnmUtSopw9AoEQEkyIMfsYEaa7u02z4cPjADxcxxmyanHPNumCQk7kelEi7dxooqGw0OyNxChhj7E0GVNEBasE9cMGz7F1F2XjXOJEcGBMQAIBwOPMK65Zl5GkNW8xpSkeSW4Z783jr3FpW1ooLilJQVCFqKipsaamZdfsyH/87z68vA6rqm6q4/V8Wk4GIRqL7gva1kEIzjlxU6GYk1K5RABKNqzLKbhont/+qn3GGI9L1HaO2RIuCEqwgAjsEi3IoPiyqBE6MjPAKwoKThGCiKMD3kqE7LBBILegAGtMykaKjlGWwUwIgZhUsnE5UszO6ykGfTjsEEJ69UbbHHm/L9Gf7VLOb8F755WLZurb6rALolTeY0iqVGouKeYrJAITDmkFeQixLBb89u3669+PGJVoXAEZARRD9DZueNfv62lappjrBjcNkm2A4JbAfY48JRuiFSL9+N2H7a4ZJ0tJRQu/nFat1nVSzLU99wwVwJGXedbLear++uuzdWq7b3ryWy32MDX99v7uvj1PcFm/xuhyQslcIQQQzFe/LFt1/PoGQXO5TADX3aGqGk4oNDET5rUFG75llAjx1pCd4CIAhXETU0quLthvD0Pd9hlgm0wpicHkk8vAt5s6l1Bg2N3cnM7TNBtJ7wJac4lIGFBo9pRgICsMgcIQFIgiZADSGENIngsm/MYrCMgZU0/EsRserfZGFUoEZ7U1tsRonb2es1tQyPnm7u7D9wxzgLIDSECMrA4hgZwIyMIswNqCkIthVeuKkfQxAIgobtpebHcNb0CCXHBze29Dvl9HaOA/UwoYJiAg7RdEeUyBygNit4FbJHhBWbI7ihko8cNdNj0YdpVAvdV1CJ5LLFtWsGNV6IaGZO84Bof3NyFM8Topa1M0ALkOtJxLTGA3YFRhb/M6O8zvnVtOl9c//+li/KXq9WZ/23UtKoxz3gjeNTtACmUkWefm4nQcr6vVxTclWBcTYJzm6DFgACCCeUpKVlVwBUMKCvVRI0wor300yTtKoVdKrZ4SJipaV3vOqTOKMNhvawIrRJcQPUVVsuryOlFMCRQp0us1OP9KKOmGvtseeNXgOpIKYwIyoNM1XS/g+AJOx9W6iOhcSAkxcdeWdOUYcFr1m5tatm2MdZeaBm92zcA3JYFx1iEbgNJmRxC2xpxBTmpKJfvkYEW3EVOIKACaMNj04tWr1evzgiIkrG6dM4I3NRtQEd67nAPGOBcAEcEYgihKKcGBCoii2dMvo1JPEJOmbceXsJJAiHVL4oLmWE9LMF6V4n3i529X3LhGIBhJSYLhlTBiXVVVNBeFccCQBxedUIKjumorKVetAISloEQNkB4TEHRaV8XgJujFm9j2ptrc5VgQwozhEAKtqmn26xpBgbyx22qHOc8FrypOYyHUYxysTW6JlDCjU0rI+7TO5uVpuX9/sCo5o2KAOeGe76/qiiFPLuHClmlxVnm/Ugp9KNYGY/MHQj99f/DZZyge7+5eZkcAQgFTlIe2JRCEMWHCJWu6pmyH98n303TG2klZdW1Vt2VZJszw/Y3UxoT5loi5lNDssfN1XkEI1xBGEldPou/kNJa7/c0m+1mvr93QIEScqSBKVYWHHs/mWvUkFXS1NmIZy+b355+/63N/kJShbevrbiNrjmmIiMu2ny/nb38zp+NacrvZC9lyloj32foE8QoQgpAyVpwhqEjOSkpBVITEPpdckMOsLTaBnALwkgtjHZcyFqgmJQQhEjjrIpizKzlxsyBndCmmaglIu3mNSvlFPfc9o9VyuJfd+xp3W1zj4v38uqqXMk5unQyAtm7Bom2AuRAk7KDN/15VwJVhcg2rmnd1XTWW0lTJG4KBcnMGcDHXj9+/73YE4ByS89ZnC0tCxeJrSFrhCkDMSULZwOCxKBLOIRrnKcl1HZt6g1FTAvXmvE5XBssgO6N1zpqKOqaAWGGIxhBThBSBGMCv/2qjXwHQ9XDEtP6HP/4jk+LLWj4/nRY1LfNMcLhFceAHSUsk06G7ZsBW27X1ppGypJx8EW0tBSawBqkoNY4zoayqq+qqi7V5HNeUlYtBUERYYhyUXFwMmHFYUClLiBY6tGil9NR0Bcm37e09LrfTBOcFAlTJzkVgCqByeDdP62jWAiKWxad5Wfx7eIciyR5a7XIKeFVpXgQT3gBrLYEDAJX3bLz6DKIyGrN4OZnvv+sIyliElgkXHgX9FaFnFAUooKBEWkFQIUR1XWaoZJvU9SaW17a34fAnxN5PZoGUAA1BrsXgoEMIVhXfXo7P17dXO515liRCM9zUAU6b7iOFc9iGmnecs2B8yVcAQUogu10wZbcRVzc1sCROac2Ut832/uHjp2VZFn21MdJCIUKEsBKKndBy8U7lTYMeP/SUxhT8sgCtg1+rhD0XJcZcQFmWmVPmvaeUcikQQQAAREjG9TxeKU8lraJhAOiYS9UwUEDJACIcfRKiSglkSLjcDKSJJWiTvz2drpeXUH65w+1H/g5tIrtBsIGAQGBRkQnJgmQmLaQtyjFCgHmuOa2QoxX9wFGRYq5rOAzi5iEPzY/OBh7v7BSdTon9Ntyldrc0zUPJzPuQcyjFhZBhbJNRtJTkPcYEAgi8KLEUG/ZdOwmq1qvc9YBSUrWhMD3pL99eQwT7wzBP6HpyIMEUIiGov8ubh3LzkaXcX0bz+mqdH7fbOi/dy+W3ath9/OHj3788//r5WbsRIk1wqAMO+Mx7XEhwKGUQUJ7VVGGcInhGvsGoAchARl1M9gw8eru/+cM6t+f1/xOmc5zHhD80VcXZkuMZ0c6q2yJf7u4+ptQti7UJzGetV8iEl63bbHaV7K9vaDF/I5w3w701MmTf9wUwctXJeODD2g04ojfCcS4rAgeU4jqelb7WsUopt4ea11xy5g3xpITgV6OpIOO68grHN/Dbz3H/Qbf1wHmD5QkUSuEDApdlhKCQrnGJXXe79vHx9uPdh+iIOpXL1TkXJ6dMeKu72obr6ul+eyNqh7BEQD59C7/8ff369ar982a7JfvDbcwu+DUGs1wnwXOFe+9DN2woOQsp19lAVxjeGG2b29TCBr+WjPV3P/3w8bu7BIpPGeKSS9HGolBAzMmv86V0Vde9HzBw3YYGb0JQjHK5qbyuM5yjd33brctKMQ4+cMZzztF7jihAsCRbEI6YSsli0s1Ao/MAkJyLmkxKxTlfy6puKso5kZbWD29v6+fPl+e3359ev3gduJQ+NpFMicYAEwoAJwIBlxRIZGkpEsFN3cMIiKElBkaJ82vFqrbmu1u33dKPnzY3Hzy0GzUle6kqjqgsFg6f/jhs9r130SzMqDi/ca8cLLmR067vtTIJBIiKqCrny3q+JBdrWoYetk1DGcu0mR35/MtnZUNMHhMrqOl67lRwUbcd2hzQ4UFu9puG/eeXsx7nqdRPXbdd9ZJmmAgAuFymt+NljYD6jEIIOTrwhdBit/0Wl5bGewBpyPzt+Le+l013uPtA2x5zMWQQIbSidix/tEv1+Zff//xz8F7mxFJYIbxshrTbZ8awVTvEn0mFokarNco5TJthpzERbXVTVWOIGqBYMuN1g0jK+LluNoJtTzbNKrrIxulYMNrdlr5pQIR+IZfnVY3ehhUEIoSw2pcSpZSrmp0HhCLKqLH25vY+FudX9e3bwgdK6zOtdLIbisauNm55IHThvAgJDjf7//Af//D4sKnQ/te/fslEIb4EWDjq1wlbU7rdLqeIMjX2ajRRa/yXf13/+tcv1/Ec8qsvC1GTCdFBAitR9oeNd2i9esohk3CzuwMQumlRxlFCCaBcJGst46jvuod3f/zuU6/XCWRfCUYICSEED6IO87hIcqgbZI3qOqCW0VuHAIWgIBAoQQlgyipQQFu3RptaNM4aTDBGyHuXcwKoIN4I2WKSC0CMUg75PLp5XKPDhFKvLIOh5IgwrbpArvQ6X19P89v1dbYjzBUFjZAHXilRtYgKmAvMNJkYLh6sQXiwpVy2VGZSbC5sFQInkJqqOdxs7r/vut1w/25gbZhfKRVY40CY33Us5o9932OEU7qMl/Xypi9fsVeqkoju1krKEr2oSsI2IjCpgnHsG+ysqmVhvHVOvI32+eq+fFE+aUziZmsv4/GHTz98eL9f9dj0or9JDf1RsltCMxZamdN4IQC8YRzrxjdim3MVIoWFMdJAoLyLCKFVobfTK8a5FrSWHwFIpbxUQlJCCF3b5seh32qzAoiU9j5AiJfj6/z8JahzTDnnnF2aIAiCyRBITp7V4fH9x5zR5XLWy4wKGXqJcQOQazrMaKeWUlLTDapkiwkbugcIsLHLMnbno/MBUM64oG0nk6d6wV7ZtyeVAUNoy1lbSlE6WG1iPEHAKG0ACHXNC8qboV/NUqxXq0KoRUkmLaI9kZx60YDdyCjf77cPj8377zZ372+CSl9/vv722wUl2rZ3siaQ8AwAxWJZn4EXMNHET2qVL8/ml6/nUc+ZwBIaY2eyjPNut4Oo4EphQAhqILgShvsddgkUkIjAejmW0kh2t4xfvCt2hg+H23aIrcgUBcKKsTpl5lxEoCGA4mQoQxgtXKyykdMbClYwwhlx2swVrQjEOad1Wdumj654kJfFSilw9DF5hBFmsJBYt010My7Yrj4prK9AjZBTiXJhhaOSYCnz+bqqdhr18+u3zy9/NRZC3BOcaT3evn/48P6nzc0NFqIkADIK1unrspynbB1HEnGK+9panULijIiGDgPd7fi2fwf5otS8ms6oMo7r0/NIwPjwcIAEn94wpUIt4uX3Wa9AL2symgKmJxB1MjblPldbXggmXHy4a+Z1OZ6Pm+2uADYtZHTHlJPLbNU2JQXR3B52Qsj99qd1XUWFiRxbtt9u2lj/S7nsh/bOTMia14yiA+vmkDYDjWEn8Wiz3rRcNgMEKKzwfPk8DJIzFIJxQYv+WjUbRjFIQyznWBCEfU5gXcent7/R/A9K+RSRRLXz3nsfwIoxtaqarqCqy/3j2LXfXS5zDOehqSgi0cy0aiirSNmX/LtzNrjTobkLwUMACB/1Atdzezn7ZXIh6qryQ9cKwoKDpOsWZzOAMZLoq8XPMXrOEEFlnuftdk9Z1bRVCkRwqtfJqDXnC+WgE98zBJyewXpD8l/bauyqfrtP7z+0d4cfkASvX16//HIdj4CSDtO8PbSY5JRkiOlyGlF19WtVel44OZ7y3/8+vky/8wbnEJIVSr2SnAJGQDIR6FyJTidMeNztGyqDXYm2KsFQ9aVvKzO69TzX1cZpXQspmff2rNYVIWSsorh1JsLM20pUrEnBJKr3NzUoQfLeq+xMoQ0uMRXqm6Y7nk4IkRRLJRurDEzAa++SgjgPmx7CAgCoq1pFgyCKLs1nczmGeTSCZcoCF0hURa9Kaef0B7XMl/PJ5xdv7wiuEVsIv/Q7VW/vcF8BAotJMCLj7GLmWV2jjzyBBCOv6GbfJwUJhE1TNa1nrCTHAvTKGs7vZMW1KBGMIJeUS45TVkhycj3y+Ypz5ABdILYAFKv45BUXTJYSc/Leb3Y7KfPXr0/rtLb7Wx9JDJkKzAlZFc66NH3LhJOyxVBW7AZWG1FhyCrW/90kES67j59uZKVwIRL9ByH9Vf0bJisCDcJpsyPK2IIBxRWGPMDG65j9Rs+RN/fOTjaZspi2K5Cq6D+Ml7DbI2ViLkjPFaNX6wrO96CfEtPBpH095EiA77w1lOVQXo/PPcaMU+LXQCloJcN8xzjCTJVMEaTZ19PyVfBKKQBWiBHPxYxjzDnnYkJaUq5TpJJVbdsti68qNl79soRluSIEKkFvb/uBEimk1qqqGgcBoniapxxD8EpKykWkaFdC27Xlx+/+wdkA6ZdhaOumWtXL+Cxe38x49jmi/Y5TNlKphSTjpVwvQamMvMCFMiIhhymxefbaXhGTPnrKd8OwJ1X1cB1t2eYdJ9HldZK4lTqjCvOqri/X1RnbV++/viiMl+Bu5xfftbdyWDALr09P2O4AABzflOGt6wNp7qvInn87Yx5gqt3SumCD98pPeorzXEIIYIgFv8ouwfVT1EuMJuYrgBsXcAY1xhet1X7bItzYa8jBrSM8vU1uIcFfQA5aRXMkhAj0PLft1/uHnQLzdF3tBDr3E6pURhdOL4f6O1G+QwceucGcIEDyYtfR6DdpjsSpmHEQLFIa7jmxiBGKAJkh2Db1vYt6OUFR8+HxZ8z6hN0/8G3RTU6RVS0qKLrZWwP9BacikRK7vgC0aGyTmF9O3x+OVP2nodvVzFzPL9FOt7tPqKu0A4VY5Cn04a7hByGdmw/97n57l7xZ4/+339WMVZzeOUYTBXVTolk5gIdhy9snjFEEh1Utblr6LSL1pvBFmW8SEa0mAnLTbRPErCVr/KeMYFG1wE84C+o6d0UBZZL86u086mU1xiVCRIpP2w5HCAAOCG0RTRmchCC1aHrxbru5mRdFRWVttAVSXiH4GUAGSz3IB61XIEaBtjCC7BUsw3XR06hS7iAgxVNADSje2nD4UBQcDSgWLbpMPnmAb5W5UAG/Pv98OBxCiAR1TntQ+hgzKM1qZ462kgxKhev0LeWSU1VKJhXm4A95EZdTjOHpqrRVocZF1oGCJ+SifkWJS6Wn8/niQuK5Gwh1VxcsGudrBIaW27S8NDy37XHbPxA9F2sNRkVuEKNCNKzebjBBSqnkK2/x+ajP/pecPGNFdl1Vc9IVBFqjjF1omPVms8liZQ0a9n3K1TrZVLj3hlB2OpppfnU6jtcZp7bkSXAYeJ9hqltBqPZhCUFDSjEECKKIJiHzMNSsyGWMMRSjXbAkGhw9XFVGCKYUr8uaEgjpMtS2bzZku4AYOWJ1T3s+2OAb+qFlM82egIx9ggUCLdyJjF/o5fjzOiG35sIMkh2tBa6OggouJOEVrXxEL8EeCvRNt1GXljRrVdGmbgCE2qgMHQWNN5me0urNthsoZC6kUuC0KK/HvhfRkjJkE/X0FNdlElV7c9sEQJUJH2/t28WkFAXaUfwRlLztG5qkGe0lOgjnpskAnFe9Cym2HWQ8Xq/zZb7Q+DWnyMl2tyd9hwl0nx4el8vVK7Jpthqaim1gDlXFOI4xGco5kU3xDxADMUi2T7yippwAr5EhtO5CKs6GFP3v8VkI1h6a+/stwZDhRFGglDQ7Bnn080p4HgapV6XVSDYwAVSgzGQCNLZsx+s1OAjR4Xw+F4iUxk1jjb4OPby5P7R9zXgHAIeAAwCjByWiSna1vJ0xzVEDdFm1aw6cYxEDXhc/K6W9pmRP4aiV/uUvwXlUCklpZdwJgSs641TnAL09uWIrQYahTb49Hmdj34yqcwpQnhDgFAIKRgAQoUXFjUuK1tmpbPxEJGr3eDt0xC8MQbFpQwAOZEc47jd98F4Z+/ptUkuyC16vcwiq79DhXf3hh43YoRLbL38zKPVtRRgW9Z3e3G5EQ45fzDQbIurl5NV0en7+kj0VrMawJShqjQiotB4ZbFOEAHwjFLKWZtRkDFLxTZfv9ocU4vKK3FrWSVkLESKvLzNAnNA+5TSu0+vlSChlHOXIoyNtFQ9Dt+8H4JfC+8jxwO45+2caQ3w7EdImhDgAdry8fv7T/PmWhAXlTBBj9ZXWFMKa16IfeiYBltYFH4q77R6U1kmBNC/vP93yIUVY2l4QImBuposWfdPv9ilktU7jdbY2ULbn3BNchv72w3fvPn9++vpVcwJ2OynkmmZUY/AffoDL+39nTGbgARVgjC45GpM4bSSXKZrr1WI4L3ofUpwandH1dDlatxL+lqK/33/C+VZNoW+4IOa7Dz0pm7pughRdM+hlFoKllGNOkETCLKmcrNnDT93+4y4BFLIwSkJxl/F5vfzu3NK3hd3/w7AZdrtNV9+k4KNdo1V1XUOIllm3G1ZHDE3JXTWfz5xXshYFmnHklEPZjpX48Lo8a/e1bf/w9cvLNNtuyAT67bDZbauUoZRyuxlyYgBYxmBVUeBhBrDDKBWFyn1VVYw+JqBsmScbz1e/Lr7w3zGrKOTnMTvDjMlKTQC/NB0aatGwm67ZMclQANthy+p0UrBkodJpWkOKomNXAd/DSDuMMLKMcgimXGpKZQD/GxeuGaqheah5IZiwum3720B3h8urNtosi0UIYQJ224O3IPj5fDIx2qba2PWV0APumqyR9XY92VamhPxwWyPWvB1Xe5nM7BBk11c0qd/P18/3w3+p+a5tmnH5V4iqnNuMp6rtU0Ehz1BIWtWFyET10AkhJCV7/TJfjmo6zqigdQGp+NW4VJwQXYjFuIwwEoJxUVG6xpIQYpz5WmBGRaLUB4CCy2sqCs1P7nT5vek3gKHpyyJLQwYQNfYWUR4xJUwKJlDbd4xzm6dlzJRXvLsi+rFqREzz8Q3/8m/nTz/K5u4AMC4lw0Ts7E/PV2/iOi12vdZNtdkMQu6Dv4oKPXzcZ4jmxZRCrYnjZa5onRJAGHUtb8rdeNEwiwwWSmPMM5ccQMQlBYgus1ln4unfAIrHk74cxfWqEJSU3EAQ3Og5+v38ev3jv+9kn3/41OCyM9p3tzsM4QhxztHaOM8rgIkLsN/3m/3t4X5PKwxTyrhQ6JNfut5u+5bzvuuwuDsQQinlzi4ZhXrAGHSgQIS5DQBRACPVak4hCswQoTFkQnkMYV3XEKimL+ui1Joi089Pz85mvQCGWwTFoi9cVMO+gzyWALCIRHioFcgYwZ8ZQlaLnCAl1arN6ajGq1buGNMIaOCcAtpAUbnkHYAqJJOQc8mBkAtAreXZQhw2N3x/IADLdWLRu6A5jKwVXVvNpBRAS0kTpLUPJISEi5e0PGx2TZXuDvWu7gkaSLXThHivEa7IerHrMiV6enh8kARlSwFEMdEYZUxlmvP17Xm+vN/e3SAhZNXSopJ73T1WUopxEq9PtprHpMnreTTK4igfN/9u6AdGkbM6xRZSj7jqdnve45AjQw0TLaE88yjbuLlv44ivX/zzZ6POi/VL01TmnAtKm0N3Gadp0UZHiIqsJOMkWWzyutqRzkCrtWmozCRRpK0F6oWjGrk26bqpRItZVF6fQ036MHxFdR+DZDxyVlHBWTcB6pSzmLYu2AQQ4wCxiVNpFerqw/l0/vwXNVyhbKsMIvDh9LQAhYuG22pLGkoFZIxBgkl3v71phge9HhNMtBUYlQojEGzj8Vw3FW4O69txnI4U9bzyTc8o5yk1EJKQwetxejvP0bFA2Gm8qPhMwHtfkg1P2EKCS8ymJ3cMU7t0j98zIsk81W8+C8Z8MDHFnGAld3lDrVsQWSrRE1CN3zR8VoQiKmAqhad8GErTHWTXYk5xk4vz0WlQnFaTU2W32UKEIUJV1c3jGlxxJqGMKjEQibRx0dCQlumsj09Y1G+MNiX2r5dfjb421S2hWQiagU/Q9Ptde2CBXDBrM4lV29XV5unn43qdh35LBS2ApoDO4+Xrty/rsiAaur5q+x0jNEfe1H3Io6DUB+09kLAjOZMsa9ZVlDO+sjaTXjHyQb5ENV2J2zQYdRL3zUZIDhBwsWTP5tm7nIba1iK+Hx77+mboeElG24HUO2VWc36rpLsuV5MSc2YVgipvlVarWq7XaV4jJuT1ZKQ4vb2c+Psfuy3umo1gb4L6m8fOhxwMpPCWwxknefz6KvrnTfOPh813yv1lVdM0zbX8CYm/QXmtmp944zGwTFb99oAFi/CCGgQ7Fd7E8cX9/LdvPc7tlgDkbAp919RNtdhZK2BswCjUVQEpJ19mfz1P2T2tUa1tJ/1pTUhh7EXne/YuebaOgFXs6XIqOdr0ghnpyU+pXEuJXTeIOmASCfoQ0jwt57Z+sG5CObfibvcRTG/P3h0u51OOGYTD5eullNkF07Z3KNKWNoVlWFItqnbLZCWJaOTDvtlgUv1cg+787XBVr7VgnEtKbz22UIo5yIyuVExd3bdd2w8t5TimThs3K8VrXvdSqXwZ19VoKDDAldORVxIGhFEqcN5s2+2u5TJDFCjKm35jFcWYdVI4h6dRl1whUKTgsuv6HsCi5lcncPfl7c0Y3e3xw/vbpoc+znHWtKnwlLz3KZXRjjf7ffQuucilyBHMk54ns159HM37+4cKk5fzCwB5WY8obw/D7uXt7zS9hyBhYqLGMGGC7LzOAFcou77Nh/cd6QAEaJnUsN2LIr/+9tp2n9K01nQwbs0wnM/neT26cELMtc3udv99XfVG5UqCfdu9TeecFclzhWvGBms0VoIOlEZc17GqbpVl07zEGO7v6fVlxkxtd74fhoiQDUFU7wtp7XVpurf7/qN3pRdk10mK8LcvZSlHwumd3AZrv7ilpaXGsErrjb2wgues+mSmECfIXxFsl1F8th9AmSn8f5K7//H6zXr6yYv82wXvKZShfBzoz1fw169/vtrzT+9vNodU98d8GpyzXdMXMBIwbOXHZD0raeil3y6u3hfCSd2CQOMYTn9CT3/+grTlm7Lbv1u02d7Mfb9R2gJYdXuMRLY6QSxMCLacuOvAemh2T6jbTot9jZIiiTFcjf16eRp6+fFSSP2hIL5cBhehlIz2XfKB0tw9ZkE+GuVtvBbARXMI+OrJ/OHTfb3VbhXW1tNosydWaVaet5s7awyndFe1RvslTCZeUvLNTiijlRmlGNDw5n1q6100F4De2r1ECMmmjujYYiSqUNPntdwlVeQd3T3UAGYAoJ3mRCHEVY6xrmiOC+Nst71RroZoqoSiIO8G3lZ1I37aHdp3726QJBZT441OmiInaU0Q324QY9CFawtp1+6HbpvD2RothSDljjF0nf42fzsiytlU1zuUUwavPLs37y1ARd4MFdt5osa5uNdVveB8juty4mzqDhgJMkOiIrJW3d40kojxeq1oXTeL92mei7K03d4DkgamAdJ3H7f3338AhAGcMbinZYlRh+naotVzRb4DECjztl7PYZom7V2/vckl3t1tbw9DDKlueYu1XX4OClrHEblBNMeg67pGcA6oiIGZWJmvcZzmZHErO1HVh++fYfmAUfO2LMfRKh0ytTfV55qD3aG6+9C7mCHxyZAQsYZWSkSizxgjZxjHiQs0LxMREVNoUwwlZRRiSSnjkKK2RqlfC+tkf2NOn60uaoS0ur4GJ6t6d9c4Mx3P+PRGYXr03q3rFKNarnUIhWCK+HT7sK1qeL7M/Ia3w54PCVYpQ0MIyDN++vvL3//VL6drI9imwwQBRsm797ercozn9x+2JSPvW73a62V6fXkTtNrv+f6+hfh+XJWywZQXH5qoy3yyxrwsjrOOwG7Y7m+lLCSCtsW1NIwlQkFJcFx0DBiiLeMWJYtwbttm2N26cH37dsGQg4JzSpJzKQFlMAOMsCyYn6fp7epWg4yJo3lCwOaUpGjFke32u+0mU/FUD4GxksPDvLhldtvHfPdxgyhZXqpljKjQaIGxq6hoKiUBABip+kQD4FVFmt7aOC6rCadSIsrrbt/d7Def3m+qtlR1MV67SaaY/RL1rEAsdZNFhamsmOR9u4khBRuCYXqcHVYUrqiQWvYCIoqqig+kRONi8AEALkQnKoGbV0JtNMxc0/F51efsp68A2o0sdf1dSZVe6fX6JAQ+n8euwpfrXIuaULSoNaYSE/LWUQk5i/222e47WQteCYCQW6xSRisftQs+lAKyu9fazFe3LGZZIuaAELDf7x4f9k1dTdfFKTfNWM+NddYnl4ALYAJA16Ledl3X763jywLmFR5PsZBfbvcPnMnl8mjiW4FPEQHloNIOYU6SokyKZlsf8tA1YaRvX8L5ola1ApwIgCinwsjw+u3XzW7PJay6NheYAYO02GBciBhtnA6gQMShD+TyrS+XC4IlBssg45xQBL2djpdR6V0KFwLIeNbrck3ZCN72/XC4u0t4ODzumaBrfNW5QEZwJQtbU/TE77KS0zeoLxolwDHBKJdcGOMAAL2OlNG+FykUZwEu1C6k4fzu7vHTjzxle3qtZ2uUS4FeVp1z5IvHPnlo3ezEDQp1z0uKYcYlUW8CIghkoFdr3JkQETwSDW1FbV1sZG0X9fnzaR1d1wizWrUugjOCW4BdM2BMuNLutIxHla6TWtc5hCfBI0Fw6MCemlgFne6wQE3fARznK75csodxA0ZeD7Cu6Cuv8Ob09DrPdrNtIfIIJwIzJJRXEgCWE9qb2jp/Gs23Z4Ah66r393ftp4/vN02nVjsazxsGdKWmxaqUArImujxJROu2rjqKcM7eA4BgXiR3pTirCoB5swv9ftc0dd02Pl+8nVYzVYel3naMc1EPQSe/BuQyiRYDV1Bpmg0VzMXqMqll8QwztcwpjykwTChEJJVYAGi7DiF2PL6C7Jte7G83m8NG1pC0NUD4ernoxQYPQAK5QIhwymRVfpzmmKwQpOpA16Hvv79BMM3jGRbsTTJrAYUiWkr2ACKEwabf7Ye+ZiIXejorbaDxsGBJ2ScHyXVen7/F0X4FSFfVAxHAZUsxNeUrqOr+9hPbMECy0eR6nY+nSwBz8TWBRUcfOeFtsy8F+6h4qRZleVs1DcUY1KKqywDUKAQEeKjxNqp+taptaSN5XXeHw72kcJldCqVr5Xd/GASFsGwBXC+X5/1deHhs3n3YHV/6ZXbM5XbjRCPUqqig7AA5Q2mUb7/48+cIUywIzdqEl4Suz0xUq1qcd01Te3f1Nhhtk88gp/2uerzpUsnjqt8u41WfQzJns6YAOesAo5wL2cDNbTs8yOaRFQK8768XZ+eJUicEbnekvcnNkM/jNYEbKQblj5TQt+PJrLCtboPLwS1VzREEy+pkBZmkPruEkOikRefX9bwso/cnjoPkrGDeV2OwGGFcsYNAJMQXrZ8ZQ13d2En9/X8/ElTba8g+oYSCgqkmSPKYFcZE1pwwiTHTJqKEQIRDtUG3CNzmmtOO8aHaObWW7HP0JVTz6lIkCMq6YxADXIP+pqWMFYTGq7GrC2tJk6GU8YpS3LpgQrYxQmMyAMkl52yCGXP4kDQzJo/zl+Sxn/rpGc+TT1G3u3J7XyNGnIbGAJg6gFbKyMPN++tZCV4RwQvOkEAAM8SZV5gwUFWYUppTTh6RCJOzDJFEKOUYgpQ5gTlaN2IxY7HWjFAqY567jmESzbRmiymuGKCBjSl7EAmJmOCm5V1fC0F49DpEY4zOCBKBJSlev395eRqX1ZS3gEoqrFiO8sW6K0ZKsC+bm5/aAfkRpMKevobrdIplxMR5J4lTR5BBBhXljDAQSXRhnWZzaNvNFmw35PoKzBJ3tejr2ljLSA1LFBXa7LthS7Y3+1Ly25v2yRFG3t079L7jHK8T9LZwud3d5t1mwxApIatVaZQ3D6Cv6mWcUNhK50NS9rl++yUuRxzSEmMsAFxHjvMqefAhlAKW61JKKiUxSmpJ+0F2bXN/W31+iylSxK921tqaywU6d2lqzzE/7Ju7m/7Dd8P+u339rqHSctL+/vc3s5xDsADiJu0kJ0JWdaAo7VIWAF6d99M4YjCY1RFMZEW88VrpjOhyiWqcPQm8r2TTI7F6mBdvUyoZ4Ib3mA71Dg+Ph+0gWUVjtuNyYpthmcP1Fb6+OEx81xsJX/u2G/p9Qe14XKYp93vW9hUmKKREOKKM2HW2qyIs7ntZVRVFCMUl+QsuiTHWSLr6ERK53Q3GKCpAgam9qetN5WxwOhrlX7+d/AhIKFXFZC4++QwAFjxlaT1dlXfB5kwE72lhfnExeEdlCSTOyE8jK561oN3tZL3RHp2uY0kJIwMhSsEZmyCCTVvXdWeCxgylEACE+31f1TCmtcSSXPI6UuqcNskUEDKFlAoUQ4neM4mpRpQRQhjjvGX73abxOlBI66YyyjOMIw8uqIZ3++0GYx5t9qvySudgAEaS1wkBZVx03oUXa43VaQlnJnqGWSlTDI5TWVf008N/2fffg4L0Il5f7OtT9H7NyUSLSvakRFXJCiO/uz002xqwGuJ6Wi7ajjRVXZdvb8SkIEG8ESiLmwyyT253133/08Pm0Cx2fXl5S7nICnlrmuab7Heb/c7o1RnRr11xKBo+uliS3XQyJtewA0o4rKZhTZpn51GN2+TVOgXvzhBXVdVDco/dBHLq2sFoN44TY7JkV3f9zV7WNZaSMeEFP2ibMX9GOM/zvI5M+wuhsNuj9+8/fvzw8Ok7AXteSATSNru2OhWYQc0akAHF1TqHmEvO98oUayfKs48GAMAYv44zZwwjD2FhjFFYBQ3XdZnDtbrhvO4+fPphWoMNsSQoEb69+7CVh+HD78P7CrFLAG1VNYftP05X+fvr02+/kW/ffNOCIf1tj3iKmxATFxutonL67WS//+nju82BYSClLNnc3H9NIRQgp/VMydLKNq/Cr7GV7bIsQtZhHcigWe1ne626hgrSHmjMLkIXc9FaPz+/dGgrJVzNWESp2ltM4WhONGUQyXgJNj7Vsm4a5latlUKwgOZRjVodVbLTbt+2W8K6TUrkcg6n42W3rYlYo6urmqdk94c7KQUV1GZUt03yBQDEGYbINrKXgmEAzbwE48ZlgbnGkLZN2whu9LqEBZSGoNjWiBOKMb656XYbEYKWNEabg3OZBFwgo2LYbx8f3udcnn7/elqvpeSUAMNtxVubcQBR2ynCf+bifkCNuexLwhnAAP+K49A3t7d7+rD7DzfdPwT35+WaomE56RRCySWatukg8bHnsaFEio+OSAgBydm1rFpmVKLtWpnv7jia27rxxtm3G2WvvIndfezvwPPx15g6nzDnQ8gWohRgtGZFvrLoDTew27LrL3fjunAa6z5i0i0LWdNlvLq635fu2G4Pbe6Of1uP1z89vf7rY9+2gtai8Gq2SVFG+qpaZ9oKssyLkKwSCUJbSp0LNrZqD2dHzyvERnun091mAKl0rfjp3eM/fH/3h3/8SHeviEeQDBT3K9LsBlZUVBwBCNfMA2kx5ebyDQcZpnWxTuu1rpsMbCfqlCIXANbEmaKmaIg1dN0nDvBL3TrV3v4792NRBiyq7kVbmbvbFa8f8+VG3Ne0JUxgsNYv1/Hy/JVk9HBPAQTTZZ/zAhLmSNCcaCzUzQiZvDyRgoggzh8jxKJ5V1IpuATIIIDWZuACQcQaTVCx+to2hPPkprMQDegJ6YSVHughZqbmdV28kNtl7qg4d7u67eNhf5MAIIan1F2u6vVpudlu9nLbQ/H0++Q9HDb7EIw/z3pKrAdsX+UqHE+rteeXl+e6ATeHjdV9TCDmsBnE/g5gHCEIOfU+mBCu1UBBwQhWTScBAGoteqG55BgZgub2tq0YSinEEJwrICwYqMc7ISvOGIvwy2oeopdzHtUSo2d6xrmsQpL9/bh53AUdXl4YH4acQY3rEilGLExv6/kZev+w+ZBpY1zC7PvJTS5ahDYDL+/vwb//8N3tpwo0o57r5PX19ArcLuodQgDLr81GEKNtDjkJD0YL4lAyD46nmKcxX95+326G/b7dtB2G1Ol8Rq6ju83+nnVGZQ0lloTzbh8DCSExJhJYrBbfPntIBZNhs+FYjA1zJYV1tTEmhGUtUNPI7naDKgA8Wib9L//0/G//+ivETYIUcSH7vgACc4ihGO1jyKUUIXDb8QIDRCEVNU7j4fCAiiXAtPj+bu8xRFIWhn7kjPMKZTQTvhJUu5wZlrgqLJf9ps0vTpSNWYK9gOw0qnLjQ0ItxWw06zKiYMFmn+udstbOS2WVfH19y+gXCqM3fkwHFv0u2er29+b9j1z+w/ybcOrnShbKbvqeAhAKiCkDpVZtig1r07OcEgH0Oo2+GA/zGhT3XzO6KwkUMADotQ3LOUu/O10uGXtaLpwz2Yj7j+/OL0cIoVqMWhXJmFAMIGZSrAuArLQHIDccEpgLsy7lgGBucloZD6l+1gbLWmTqAtVMNNvu8fhqMkgxj6F4gPcvb/HqQ85Aj4uZC5Nl/+60uxtKtuq6n64ZItk0saD1dFljRNag3X5ze+gRjYiwZXKFYEprChyGMPjCKIc55ISjxX6pYvIpp3aIgmetn9QcYKEgYoT80FdV3UNIQwhKoWTgMvmcnVZ2mVeYhOwilnhO+mYj+c2wLwZfSQGlxn1Y2ZdfX357eYt65hgOnDQ9dA4wwzZpZ5wtLBx24P27/f0D4xU1JhoT58kZ60D2EKcCYjtU7dCSeVm6upIUjS8T3HAEeLQkxrQeI4hgHWfY0IoPzhpExfCJO7+C2oEq0Jrt9h3Mlff+5evFON2Lvq6bm3Z/PI0uybruQ4zKn4vXIKfx1cdYfvzh8XBXwNCDnIqKavQ//+XLX/7pW0q8ks1ozjVoni+XEArNMoV8RV8pTYyiblNjjDCuEcAIxe2uxmw2c2nxpnlU24cbiD/+9jO5vi3WqrfL/0/9xSR4ebj9r8OPCdYJssREUzAIQk+XlAopYq3EIEilzsvr5UkZd75oY0JV+0zz/Q8/uNP5tz8dLxf09O2FVWsPJKPU1hN5tiHl3r+Im/zu+0+g/R+mr2RdryYuzUC2u5q25u26FEic5ZjS7f4uWv/5y/nlLSK2LfTvobiUNisbAYiSJ5ZqyQZ9QQSu5jppXdH6fHu36/cPQIhmVZfXxfpofaywyKHEFCHJgWnCy9BRIXcpQetEdOv5NE1PWa14WTJAKXusrWdpFtAw2WHYIhyN1dafChLG+2mWMSdrjY+ToOiHf/ehPXhK7l5f/PWUY3Z1x/puOy101UZKyqT/8Gmr3Mv93V5pzTcSFJpCqGgddZ6n2Rlj4ih4DTLPsZQUEMhddaenokzIvkCYCOZtlzDGmMRUKCSYl+7pNb58swWMEOQYE8grz0At4e1t/mhVyeHup/0dGyCEcc6f/2V9unzTLiCEEYI+W1RML6mEeDbAFS52h/uP7PHddrMjOclpdDHk6ANFKMOAkAUwiRoRTonxixDE+SZeKLQBo5miyDnrJEqgmucpUCQ2MhWDEYZEEQ6YKE3ftsMmlzJd1WrXUEzBWTnFRJvQud8bZXG/kTEWKw+xmGUcKauczV+/fuM3U5O59QWE/PK7/vaXM3YMpGCt9VnT6Wz0ymEr2UgxlKiqZCeFaBrqw9o0lFAYE0GQe11zbKWkqZ5B6MYpvbytv/76z+tybuRS11xfzvrf//UHTKFuyP7Bzf0yYajz6ThSzqrHRZSbP/3Lb/ZrMepSUlwmpN0F0UZEPF6Js4MLz9f12ZWFlY826NXMDkWsb8cx3p/wLf6X7TBtH//zpv6PXz+/fH0+jZcgBeLtcHtzABA7i7YV/vb1TU9mvydtfzOvfpA/MEpruvPaxgAjQAxnjIvTSqHECorFBuNgBt5YCiBlPJaJcBYW7YGXgleySiXRzYVKRMRdSQ1I2K9pelNPvz0fv65+6QlhlN5X8sRlbjZdu7sTdT+N/nq9Wq0rynOCENPVuTxJ64Csyc0Pb3yrc7m/HHdvL68Ar9uDyqUQXG+7va8sJBYhp/3X4Z7ixrQNSQWXJHJiZslWqX67M2NZLo5suRCpanzwGQIxHxHCxNltyGPdMC6g1svh5pZJ5mLJpZCu+frVmmRT1oKVZhBqOXvNtt1GlnL5fdLWNNuImGuHSojusK/ubns/Rb9kjFBwVs02i6LV5JJnkm9vxeF+02xayBiKAkJPECIEc850sJQHWVMuYUaMUFlssDACoIS5OiH14UZ17WYY6NsRs82OyyaEaL0RdeagHufLdNI5UoFJSCFaEgxitCspOBO9EMuo60Z0Q6bCopz2N/cMweOz4ChNl7xM1iwQQjSvAeigX0Kduwa70uQEIshlViMldDvcHIa6rQVEV1llxnzFxXwdEKyCFvN6uWTFZZISxEynsfv1Zf3z3377/PQ5+DEFS+G+b2pOukZqv25XTEhc1rOcr7nMJ6s5ahC5D97Hr9+eb8UPN93g7MrY7ngGRhumTQy6a6uh2z99OzayRuQU461L0i7Pzn2WjL8egfjF+Qrgf+etYJ7zCqZlKgC6xU6Hd3eEEEaATefDvtSCffjYpwSMSzT00aeS3ekZlVSVFDF+NeYtvRF8bIUUOVsgoJotlfOGMohR1VTjMmMGEc4ZWCFbwllsJK8lITfOJO/D6W35/Nf55Ztdx5DicbPZAdwcbtD2ILd3A+Lb1YCnl5fz8dUpI1DftxwCnOCi7dg0/PYduf/03dvJuEl4pV9eL7ya0VoEr6KrKbNtDQkjEO4QzDmBUAphhFABC0khpoJkAykkJGZHaphZihkhTnApiYZUnFYpFcwzwGBar43cIiDnSavkKKGkLgk4SFIK0adQEEHU49xyvmWFjF+980m9nVw5dRvRbfq++e4f/vg9ht2v//TPQS2Z0UBhNgnK8Pi+2d0N2+9ws92jkNYzs+tFryr5CEqiBHAOCKf9UOPaQyoJgHGeF1t81BZAvb1Jh1uCCaGc1VJYm5wpHIHdbluwQ7qHzrkpvDplpzOrRIYge9F3GwV9Dio4CRJ3a7z5IWQYbFr64REgsEsM5onzdr8fLvPvzvlFxQ5RAaqOIHCDgMhv19ckkyC8ls2GvhP8ut0wWG5Azs7aZXKlEOeW3z//9vx0xpghxN9/2osK/8vfr//8658nNQesixWSD3ePzT/+++aH7+/e3d+eNQul8v7ijSMF2FXlue6buy0l2kuW8TJ9Y3vr03Jz9yNCza+//jJdf5f1XNV5193f73Hb8rP9vy9jo04Ou1shbQjORu4u0Z28dv9mEaY9qvK7b0//j3di7+dLOq6UUpAzyenh7j5veIpsmlXObD6dlsm4pUlx5JyGsCBQ2zUn4gt4zanDZccrsEzr3ftHRDjOUNZSS1uWXEAkgtY9C9Gm2FOyQ6Bb1Vkr+/r2+u0zGM8IZinb0YRnJJvdLd0eBGP109GfTtcvn38GiyaQklI55W8PDcRH0syPP777+FN9MbfWem36y+lPiz5hYWD6mByPBrCdwoBO1ytGD9225lQIAQFnIUNC8LqMtUR0L7/8+g1FMQwbAGDwhbMWwhxRTGUMRQ37hnGci2t5Zy50HsfVL5t3bdf3kWiIHeEMYgkLhAj3w7ahj9Mcjr+82tU56ymWojObvcTV0907st29e/zDbRpfp+eXvqt5Vbvgdx/7+5/EcCPEuwIoS2/z6ZKzWQgGGAGCYcEIS8wb2m9qKCVEW/L0ewEAMn4UIjrnqdt8/q2D4KGqxbKc3k4nSPKWdsYDWfEyffazaspWndW8arkp4l7tbjvU/l4Nm2bFx29nGzQm5fpyO4Qe460D55SyLzbqTnBW9zJQPp9+u9vI7XC3buP1olpPnUk3t9sQ+hgLZ5xQS6oQmOvgp/FFvz1pCFJCZVH6r5/fVr12fVdJ+7oO58+vvz89p3SkeI1q2bTkDz99+j//j+9++OMfuGB0Cw5+vRyfw+cNV2V9HUeTmvdf+Q+ZHm7bgVSH7vhbB9++csIV/58A/M66c/douls37NoY9mJDtPH61/+bRl8xPi+2JOMFpy46RToFD+vvCFG4HsdfwBO0/+7pd3b36e/1lRUoKfooHicgE9xAoDaN2Hz9fNVXyFEjOlygnNcVAmkDSgmiVHEmYKCMO7roftdNqy67hveSkrh3BAasX2dUPcwruHpe1JdWysW5vO71Ba1fCsvyZoOV/XPyBuaw65SmP26aPUCDO5PXv8+XJ1PR6O3quPvh4x+BYNv9h833aNj0Pg1qsk4tb29/nscrgjl6maDCxHV9Q3nrQ0qpz+EXTu9IdVMEKMRDmIImdU3Hr9q+RBx2jFRpcCnpRnpR5OXyUtAk6vLu40MpHe3Wy0WNa+hI93p8aXZk2IWqUyluP9x0MntveEazj4s1t+Pb3+frS/TvXLowUWrECGSw6momin5q7gvO78t3/130T7R6rUR3kHXVFB5F0dX4Z4XYCUJAQJOUZIDAemZdp3UAkCO2NrVYFvJyNGSZFcESRMpBwhlRVATP1kxqHq8XrXQpAK7TuWo4Itf0fOsCBeDoA233+W6DD58qTICyXaGl6aG93qv1ZxQMhxcOkl7129cFQQYhylF5KqOsoq4rATjHPlofABM9qwkYoPfBGgiRF5wQIigrlIBf/u317//2VhLxJZ+m6zhNypi6AoKDRnhMo8uryy8YNpK2uDV39+Lf/+P9T9//46YXx/Pxy28U5qQWUuaAwtu6zBFdur4jxICY9FI42xYkv76OII11b6OpZdM8Pu6a4Xur7DJPlLqP+2G+zqcnKFELpXYhtpwQudYNceF5nPYZnl+P13USRX3lrHXT7Wg5QmV/N6WslPF901MZv3x7SwozyXLIxiAXHePEZwkwhiAgbBjhCMAcFtZnxLz2F+RYfVsh0ZyPoylQbg5MtpdxvigH6QLLVyaI4OB8fQFwagcKAEhj442sJK/Zrm4hIiklatzx7fR5ndfZnYVAm03ANIoqPX5HANglwjMkLuXL7E+jCTZBkCAyVJQN7fq+hZBEikpOiGxcKlZZEjqEeUkJuPzy5W15NtjWQ9+XVEAMTV3xSjoNWF1hypqqxUiALPW0Tq8GZDHmZ9mCQiwVFSLZmGW7ayveThf3+nbUyzRdF71M0eMUAKKSU1wLeXsrPn28rao+85WUBiWU41vbrsO2qatWaz3l1+ArqSrKbsDqg9MwJEhmVslCaAHtUMlVzbLlhCdzvU4rIt4BLBjFfYnuZrc/7NvtriaY/f76qic6zwVjjkUCES1mhhcMQILQ82qItpyf7eH7W1BoCSZlDWBC3JQjweUWzPkyq8vlbCza7PiwaUl7de60TL6EDasIQMwYFsHaDHK8+BQTgABLz4kUXIoKkPD++DL+8tdfj1cbUjqu31Y/G2doqYnjKSBgJRasFm1bPSoNcy63+3efPvCffnzft3g+qZfP4/GlPdwEUlKEcF6CXiGVO32leeizz90u/9f/S3f/Y/ztf/7w+pUj6gTud7tD25af/+n05z//2zLB73+8eXys7h/ob3+GiIuustHturYpKG6Hare7h+Dm16ffnl6PPtxIvJYC1mtL97HbiMJOKQ7Zt/ZaZX1F3vRsayJTwSmd52WhlDnNCSYQIMoyBgCkAIgBMrd3G3po2IaDCqhnYxKJpIakVx48H8e300k2U8mp7XqKvFqW6AmACUHYNgOovZS07ytZF0LpdE5vx6dpPGcvSgKM4X5bmKCUIyqCWXgpRCl3GuN5stZDCEkIAftySykX3HlzOByWeYUo4rYAjkpuSyxJaefN9IWev67basO4z3le59LWOgWck+Qdbg93/41doqCs82l8PtWyDi62h48QF5MWp2Ry5HzURdtgoHqL6wuKuiEhMlgTnhb3305TIAsja1S1/vbmFvCblINSc4zXw550m5qLBpCiuSO1RLIwsNcqRhuLXjAJrBIBwAIDJghFQzhBlCMm6oEQzjpQMAC2a+hu22+GAWb8/HKyJmulcvSCsRjKOlkAOSJFyqau2np35lJAzr79duacWzBGy0uiMKu2q0ooi1JGee9gVW0FFQQKwTacEoO9WiqlLrH4rpcu86/P1wzKZtgwRmPw3i7RqVgYDnhelpByKUwrrVaQsRCc44wIykMvPtwJk3n0MDSdYi+I/P9J+q9d27IEMdMb3k277HbHhUtTWVlFtiigJUCtCz2BHlbXDQndjSabaLKqWJUZkRFxTpzt93LTDz+GLvgcP/D9cbfdfLoWFdmY8e3tK/S9bEuhtX14fH17+tyfNSVMijRa1JQSi6l+78oCXN8t9b/7/nVzO01Dd15Ccj/+9fjy+nz/8GW1Qe++g+3+dxGpD5+3r8+dW7KAXAIl2IeS1mEpMlMRwJgdpWNbNYRiE0fZls2OzN48/BggWCT1Ep8xyNjOELcwYUoMRRVFDArunAvRxSV58lpW/Ppuvf1TsXm3h4UEmIMIos52Qnam3Xk6n87n86mbLrw/1UULVZUcR6nJVjIOnNMEM172qnDlBkHwAYLV89Pl6+dXM0eS0qatbq6b9++atm0BBr2egAecscUFMy0gRopRTohwvm1lWRa77aYoyDJOY98zwrlqV9uK1y5a0Z3GqbPZHmoJOHbzFOtWbN9bGHAI2frE6OJinkYzD3NKoRRUSI5Z3u5qC9mkR5PC+euREDJfRuhAMG4+wrRY7BDLY0IoQVpI4jLQbkbzfJ5hMZy5fAe0vH98/unhS+im/Wrd2m692zfrRvGdqNYJ4OXs7RQqVaFMEwgpkARzwhfngyxRVb6DkIGQGc0EAQWyo2JQDVvvSqvT2EejGUhAu9+aVVW3YNFsng3n6+1VBXJoG9TuhCyrcTG9ccH4xcL/fgJWHJL9qHaIwu0yxGk0SlJEgvFj1gWlFQA5g0y5YhwYi7VzRaNksQUwe+/66ZRd3m13ZYmSAVBaVXKzEAKLnIDLC2EIId/WqVmzcpOY9hSCkkcPpFSsLNSmFvPJGgT0EBniJtgff51+e7TTMocwrtrSm85+WXbrAuV3yYFJ67fFxPFtuJjjYXh6+i3E0F2sMUkbXm1Gm8+4MCspr96/O5wjWnyhPEFDWVSEISYxaWLj2wQzgjEvnDJWt6zd3hxO/fMre7gfrLGF6N/t3PV23aA62gq4QMlQ8n2GCKIJEpQ08EFk9htSTbO/Lb+7RpsKIAQ0csep++18+my783J4moalc8GaEDnmIIjs2DJPKXqnsfVnQrAQTduUq00hJU2xnib062+/3H89MII3K7Ddkrv37XZ9lcCSInSOMuwTjDGHVUFoFjjMZklS8t223W9qJTjMSWsTYs4gKZhywIevMcGTsxbFlJe1lDzFhRQXtRJUNMtkk05zl9NwCb6b+0wglJLA7BFhmKPIXQwxwmS9P50Wo000PY2awZxdTQLiiOvYR7heHAguTlr7NAM4zT4GzI69/fm3159+uZ/hWXo8zd3WDUyB3V6mSNIMMoA5TEUJGA8xM5IRyCk6EYmHGJcblWL0TgsOaCEIIUIV7O4D+e7TLoUw6UzwJoSwmLlsMFdxMs/GMER4WTb7D4axXFWzHlqrsbc5G2WsdaYW4gTIhQKkmgoqEHQjKkZFivEhgYlJDCDu5mkYpgh8RdddF6hYECrGwS7uyDlFEOYkRRFFiftOX47m7c1jIgnpTZ7e3bL11UZIRjnftFXwDqOx4H5VoMBGZyUXhZIIBNhfLhTcYjhk5J6+nA9nC0jJarScl8nGFa1ILg9fs0z48fN0HqY+REjOfd893nfH7qsQXM+CsTWARQK9i8uwnJr9p+1Njf9tmMeLx18wMqp5XzfvdjeV59MdvfnHf/fvnx7+9vLbJDhvN0Cb1b/927PR25e3LyEMr/mfUKAf7/6v19vdeGk01gycGNhp62O4ABgwgULsVu8vHz5e3fzhm3wtA8xAWzTkl8/PDz++nb+gZQp2TITLlAHKs6BNtNibGGGPsMY8UmkxZlprfxgRkmOXkzpzIbQ5C86VpGUVrm7Lm7u2KKqLfca0UHJPmY4hi4pVA2A4Z784nlar+v27veCZU3q6HGMA3gasirAUkVO9nARrJWxTwqyyyzIDmDfbH0I0PnWQ3Phox0mDGL3Jaebr7craQWcji21RU8TG4xNIQJ1O8+mVvr1dYJivW1yuqwjWzkbG6pQeR4echUKohFYxy7Jhqx2iSn39cvnx59O48FSqQkqXM+CubnFRITCIZbTOaxsHtgYuB65uac7eemBUTohLyigaxnEeR8RBWd2S998M7z/evnu/rgp5OU31CkE8g9LSxQ5dM+igl4pLL2X68LvIihEC2msGMj4+9wSVKAWJSAy/pnlmOF7frmhbJY48mvySjDYkweiQqNavz79ZF0NMnNdxxopWyd07a4lLGGwyhliS6jpjQCa/dIf1r3/tL0c0Tv+U3DSNfYo7yYY/fPyTKAyl5nTuCNziMp5OR+G/Xe2cKpALKDDPsQyOpNzc3z//8pUvy4xwYmTiCbrJThRefapR7V/7ZwivfSDJmiHZ52P/0r/6hJ3LkJoM3yABdtx+/Yv4X/3h//7/WFvX2KwH8Li86O+/uYVixDBwAvc3Uv2wDynSWmzaO8pRR/+/D/8Jj0f3evz/TSpOwYLxB2keH69su30ipArBTx5a+BMUlM4qLIvCsVg9V9fb/R9/gB8ItN518+Xrpft17g8TN0WJDMSB18BCP2tbFc2K67UEq0oeBuXdtPlAfNge3o6vr48Q3d8/Pa3lD2pvpVCfNn/c/vG34P3N9btPf48xIQsMhKgcIUOhpNImZ9IscRGyq5pcVOV2uxFS5BwdzFRR4nnOMvki5sHaRAGB0SIcEAcexMgcYySmxTobp8xRRsFU1eH8phGm1ZYnfI7ec7wjEZluAWg0pjhf+sOx/+tffiSEvL/x64IVeCG8LRQw8wnnPsASZuL8E4F2tS5v/3Rz/eF758HzEDMxIZ/S/MaazW7Vvrv5vmqv+tFG2yTvOSYMDTyIEDxAKWZlFhTAA2GMifLyhA5v55zTalctvSP/8Pd/QhhECy5zjKHAkFPaOjwOnvXd2Rk0TxkhUJTYTEVV8L4bjYkEeDt7zAKANOXk5+ScD8FsV9cVFZH6mEAOOAeWYxm0fP2cu05s921EPgXD10O7Scj/6e34YGJHucY8Qgpzmoe3CkX5/OVvXU+eDudhfpSES9ksHr5ejl/fHq6uV3GM3QWMy5dSlIxwVBxH40SzLSpqNJ/15IM9Hv3r45zAJcGOMuZ9xgQEa6umBbAcBxD9UNRUlc08mNO4vL5MzoJmtYIQ5gSDt9ZotuYghbHv3h5Po9sfpsNpOZWFoFWD+MZCggvB2jgu8zIno+/KnZEFe/7yP7yMP1sSxv7bOT7EjBh2wfPjIT7cB+ZevPNAGFVygknkDIBR2xEivKlusCfpnLtf0tPX/vD0xjKUTAKWifLZTjAhElErC4RJxfel3BNKq+uftwXHsvnpr/D5ZXn8ahFhQoAj/Ss95aZuP15/evdx1dT1qt2p3XQ6HEHExo6rduu1Hs/1NMV5TMv0IgQqmKxapQoJIIs5JBB5wTCimSYECBYCIghQZoJxzha9CEIRTADkee4BAJxTVS5x8C8vQKlrSomzS1FUiJoUx8nMjKho137y0Eecp6ZAGEMBChRR9jjnOUMAYECQM/BWiri41c2n2F6F/ccrVa6GMbHygUwcm6oo1HqDbq7b/fZ26HQGiWLNiKAEorwyi40R63TGcE1wQcns4mJ9mgZEcplC7p+Dz2eCIXLGLqOHqM8ZIiSsDg/Pjy+HsxAcxJBhct7FyZwusG0/TL3pzqPEIdoYo18W898rFUJS6/wbDGIPy6uyEEGyyLgNZnTBYsAoK91COS2sWULQERPOkfSEVZVqS0SIj/H0nM0Ap/Pl8PjWm+I8dy4FkBRBUokyEW9hhmLz1395wFhEFL7+9Ov1brf6ELwn5+Hwu2++zwd2+fVp7N7mriGJF+rg/SJIlUOTSVhV9c1Vm7TwLgFoZzMCCqiowdhzCuu62u/2IcR5SmN/MWFRgu/a3apoX7+mV/vLNL2hXK83dbtqVLGst9I6ff9z9fbWn86dc0a1P3/7w3e9uXrpn4dFB1YAFEAyiL4JyjBbPIjW9QgQRdqmIoyTnBEXVzFuMu3sNJ++vqF78vDPz8ukKZJ1W3DOlzgxnooyg5iGbuCMl4W8/U4WVUokktqLQp0uzM5b70xCbphG5p2snpkvrbE04UrVTcNSdlPfT+MsZIUQjTE7F5BV89kvCxbc+6CLmiKcc47WGlEWLugMQ8KJFBlBF713PlBKEQbWGWuN1ZFxSggeJ40QpBRB5J0zhKiEzeycUqQsr+ZpmIajmU+JAQquaMoKU8vh9XaVUgIGDU5HDrgdnM5Gu5ATIrZkYHt3ef/7u2Zb4/YdqXO5yVGuN1d7vUC1mm4ERN6mROZxXK3qukkwISmY7gs9W+8TQIOULUg5IUeILyouUbNcyOvjqet6SCPBkCOAOK0AsOM0YOq6YXl5HYwnk3kt1cr4ZTiPHz81lNjTK/Vm4xcEEU0+nLo+ehdjjMFgQWKehjnf/zqVA61WrF6vOA9GY5/I8by8PnU5TlXJi8K27qNgd6QdaYB2yolGzAtFxNKvQ3X46ecfuw4/9F9Mst5Q7UZKFADnkpGqvfnbL4e/fb7f7q5cml8fJxia7RNrmitMijCvoyFB16ZPaSESVAhdE37BCG/aDSv21zf70/FpcA5FUNaVBVoPNoJ4tRX77TXlhjDqLD4mUIpd2re3d3K13tb12s1qeDyv0Hq1cjebcdNc1mpLfHl5CuOcTkP/8y8/z8ul3t4LykltN+vfD6dHVjz6EGFGrSo/XG9vrq/K8mq9vQY5uPBIYJE9RaheXxvK0LAkFEugi+5yzOlUlThn4ubFLw4kVokdRxUErpC0qpRSmLfQxjlF1RS7ar1BrHx+BPRxgnhx3lMmQHqfsjUh993cXdJ6tVYyjPMMocxJckYvpwUDLtADE2OGmiCKM1MFbzfttDgq6LgMQhEmqLEaEUIJRoQF7ynF3ltrHeccZhBCSAgoUUIIk0vBSgTjbk9G/VBSWig+HCdrPEwlDL0NMxFHCuuM8rquarFNKZnL4kZLEVaFYgRRHiLGZU2Uote/Z7K9E+Xaiqi9UVX5h99d2W+7CHwwd/rlMh4sBqEolVQCwMUHz1Na9BijxwSV1QZRaNzIFZBFC3M21r4+H5wJMBofZ5IyNsbllLOTKUKlyDzBw5uflrC+gdo6qYqr9d3v/7itVg/D+JQJQHwGUVqn9WAxFJQKillOCGSIcG1H50znDBNiRXixzPDr/fTTj2+X02VZPuc0/ekf1J+vE1dlSi1MtbMQMig2Iea+uCshWTVPt89fLj73GUzJ7TGcvTPtKu53f4Cpvv/6SBk0thtnf33Ld7vw9GBTJkXNx3M/dBPjvRSWpR4KmK1aYpZStbtGlIUQAs6q2HjnrFRs8QUizAK0Xt9IRSI+GZv6Xk9nv7hFKLS5gt///hoB/vArKDGT621O03rjKJpg+iRlk2B4fF2Op/PhcI6hzAvr9rn9s/509+f+WQ9u5HIsRH0j/ni3ltCT7hJYe18ILvGqUmya58VpztYBQg9cwXtj+zCXsmlTinoyPkwIwGCDw4AxIku2ua6KUkXgB5sxZbKkZbXjQslsuAgxnmDMBAXJKxTaDM6UQMYk44RgmJInBEtVpyQg0ghBkFOIA2E+JLdoUpRKFAWiGBEQQmAcO6cRzUoWCLJlAj7OGGNEkXUuw+x9oJhTQigmACFrLMHUTo4ASHhgfAcBMovrhl8LWUlWgKVwVkfdUxGS85xwAyhGWCLNt01dUri01iaMWXVdilKJQoqrXQjw0o1dF1ygQtJ21zUbRxQ4/Gr8AjGsrB8RRjkTkCSGQC8h5iUB3dYthsJnk6DhrJB8M/VTf/Lz5JIPALm2rsjlMunFBgdByKLAVMAMoyxoJpiKi9HzH//w73/48PsM31w+lurfexuCYNhTh2FRlYJggokJI6KRyCSKmaQ70wON5/y+RBxfxte38+XL49fz0Tmtc7KY5+3H/3x3eQuX/7cHXLKiunGkPeM00C0wU9FefctXf2FL3FRVH25m/bmuyx9+EGv54fnrmUDZNv7UvWKwLWRWkp7fVjDJYNF4Bi/PB6OXpBGjVgkGx48rNiMYQT7WXMS47NeVdkMGmFBx7gkifHSX/rjEQm5u5dVuHa5hXYbX8+ftVfUP/2Nz8+H28nRyVo39F7tYGu827VXONqEU6BHA3C2g19DmwvrMjIMm1YLtPvnunHT1hz7+x7oAO3BDiZvGi0kHM5qmFLVIMH2c57BEoa40IIHwxFDVnw9NTdX2d4e36XT8BUSNYerHx5z0u/d37e66bEqIoI+U4aQKAfmoZwVATIFwWDfyXWxYAk8Yd94clSwFZ2Wp6pqoklGWIWJCsJQIJFCpZuonOyaEGEYQIlHWGybx4nQEwAZblMpMPiWSAvIhRi9kKTFGOcWUU103KWQzW++CYJJSGYO32jGhEQaU4XX1/dff7ofBEzGstpJlbc80wZh8KLeO2iyYGmCWUhbSUYirgiHzzpiIEOFXLtCa8WLS42X09w+vwf350n9V5fwuTK6/lqxkaCp4bRPo5jeIuSwoyirEOAwDRCahpWr34xlZb7Sf8UDt4oc+XS6JUGn93KzqdrMmQZ+Qy2ACuFHf/+Mnub/AtklqGocai7zbtlc7BphNmab8bYMhkEjRPJ/HBQ2MN8ElHwNEiRNOMS3lKmJmXI9TjFBHCBBsMzDGJJu/Zoy5qLshnu/BS2Nh/2us0+79FrbKp523G3JI6fLG3aksVq36O5Jzu31r/X5b7xUqvCHOJIBOZpbRrAHRGTTnMyh2cXVXIgVeL4fzqMYOm/61VSFnJPBTA6kZJ8Fxjt3pfB4jzGgXIu7HadFvlCKILxQXQrbDBRKu6tXqu/9Qftes9rcrqgZ96jGD3E81UybibC0KGWM6HC0rSpsyIYvxxwg67fyukViSvdLbpoa/+3BeH5bT/zR2U8z9yzIVpYSRToaEyGlRhhCwwttVU1cyJlOS6H1obxqQW4J1WWgMnKAb70PbNIO/zKDC1Z1JLseUfBSIucnVZBvTS7TR6Q2inz9+awUHhPzBhxG1bxXlVVXcfVjtb/eQ0sxwrd7nlI1ZkIcZ58vhhIOQShLCt3vRrnlAy7gkSgkVfhmHUtQFbj06B2BI4RFiwUOGq3WDQfYud5wHPc3Hs8kBxugAtFAhIYQqG1gHoYI1gNN/zJGTEtbfDscDzLE10VABEU3XnwLnXlZNzHVMGWTnLrNkcupqXPGYwOcX+fllcLl6/u1/i31fMJyG1/jtRlVSVf9Pm+bR9pRJShinMljjrLfGEFrWzWpccio0SYpamgKdx3M2ri1iwK7kQMkaR0iErBIF1gy6vafv3wOhrnGJ+bvXB4PRB0oBiIbgY61UjOt6k18/d3NPl67KIRHpMjrWVT0vGRHSlC0ksD8eVI4VonDWCOFaFIVglGIASATA5ixotrbsT+pdK2a7HH55s7hSct1dpvgS7DDVcvXnb2MD3788Xab0wrlbV0GJ5BdfKTEtYp46hACkw+UcK1HcfR8LFYzV81nqadHTENxRJ2xHXVFCROCKO19Mp9lHtswqkT7mZCwBAGHM5rFy2HJqEtBsMevrfP2nNdqqZKZhmIY3cH6ac38V8lDWxA2Vnr2xWge3kDMv6piaRcdTf8lohBRDZDG85gW6/VjFPIxv0bkAgYXYVk1jg3g9HwshnMkphaLgwcLDyxiTVVWq61pxZjUDiWvdc1nRjDABNui2EkVFYzZ21ilmDDBVHUBsHmuMH7v+8nrPX14BRITzL7uN40yW6h9klZumbDeyWhFCMOeIUdBfRoxEdGA8T6YH13uCaRJVJVvlnQexqppjTtlpFjMiCCdwdDOFRAjpMc3ORgxTTMg5P/YzTohR6VAM2WIcIfJcXVOOfDT94wiz3O1WVM7z3F1GgmBTrgDAXVVVKTnKE4CeUYgoRbAGAU9Hi2V1GgYIrB4ildXzOTwcXh5ffpuHDo+KAY5hWt9hxKM5vhKYAbCUEEak1dkuUesAIIEkQep5gTPNMBfcgexzSARSmVg0UE/TlAByIZGqbazVFcC2bh5+OcRFOfMWgrV+qlebsuU+94G+0ua6lDfxl/DrX59xWpd8hQCnxJf1tmkaTBehmqKsX9+OXgz7bza3n27YngLia4+bNd1fFYtT51OfXdxsi2bbytVq92Gvf7kcHt6ef3tD4HHoLgIVhKKwbffvafUD59BqfdWUq/3uSiiomXX+LKSRGnT9ItJWiLDZKcHi69OZYJVddvqoZHZe6iHDBKjqF9xQpSb39PZay2Kr1mcqtqqobZjPZzFNiwuFn84IxhrgJoDoE8wWJogg4rRlNHGOLIk+BJDy3IOM/Ha3Xca3JdjgwfEMjqclRko5gCS4qK0uUpqKBidgAaIZJsEIUQjSAEMphEoxDV2/u25WbdldBspwysF7YK1FKErBbZ/7bsEIg+S4QDlE0fDVuqpqmRMIPnIkA5oAwMfjKY/l8TgdXpaX4y8QWYTOlYxVvf+wf1fftqoSADvKHROQMZisS9FLVvWD1p0XuXagBhFGXyoQtZkTsAhmgggGQFJqxnkIU0SsapUsSyIBd0CPyTuvrVtMhCHmGBBizUblbJtWRF5Rwvvz2M1DSna10st0BJBjtoYsSYaIBHW1Ct5iDoa+szGmAXKAYCKXbo5AD9NQ1MDAZAnopub+3p87kpJlKWGWArURZohpGAtRaVYxJUqG+DhYmKD1kTDKFZYNUSWz0SWTCSIu2JRyDMktYRz1NBnKixADYSUxwFUlIh7BIXSPs6oyoUDuSft+3ayriFuM3HQIn//1kv5VpGVTNoCyi+DMLjTo0qACwYwwmpZeu1B/X9TfMtKKLD0ECRe2aeCHuwbbm2veEIw/Xdmba769ZUOMz2e9OIH0ALJBCRQ74aN/urxA1lZlXreUX1Xrbcl57C4BQI9xYnml2AIKtl5dr7fOueH4UoaAh+FcVF0GfQgJ+A1FJKWA+HEIl2TDovmcHiDqmuojZhQSB8EMEbUW2nBhPGGaOa5LdhOXov/NFF7YAPve+tF9eLc7hwc9XB3fpkUDzBYPOOKG1USVWKpEIClFTRGheOou+vVJF+1bu95iWBGqMQ31qiKcWuuMMxl6nxymNqG5WpG63Y+znedRSlTWdByHUWuYriCJFAMCiFJCJFBuVVGXECOIIEIoZ0DZCiIyh6fL86ffvi6jfunNP0/jLPKHTx80vQrtxooCE5xiDhnkGOKgrSItozK6PBw7q62kgtjfCMNZo3G4RghgvuSwghAGfVkGgxET9MrRZ2u80wow5BYXHCZYdJcXkAFCGUCYY0KcMC5IEXhFYMSFu8boNaag/aHrct0IXkhaey44IDdRh0VH4uoYGmvj6XFezm8MYckMYHZ/VTXvqsWon/72Ms9nbzqGPVN4pdp1u95tKASSwILJcdWUMeLkMyAoBeStDdGJgvCCiFJCikMkIdhgtFkcTCSG5H3GRHFJYhaX8UJszETwogX74n332AsOz/3x+3/4uPk9zTWiDadegmdw+vLy9m8uPh1WbSkw9GbEHEDoXTB5WahCLmDjPKGs3WBRZcQZgAA4h5xHxu2LWmyEFZZh+v7q/H7Tbqr2b59Nv5wSShxerMbOkcEzLrHgtD+CqVsYL5HCiGhANWbFpmmKUnEkx+kZwljVlQ49ItDMW2dd9NnZAYEixpQBwjQYN4TIrIUuAcTG9XV1dXPdrjezHw6Hw+VtpcP94i4Z8NVOXe3bdbWvCpm8JVCEWaeYwcL0afDQ0mysjWW9BtlmgH1y04iSX3agaSv66V07DABGKYjouzx01lgLcqZ4l8FPIfXOE23z+TzO+hkBEpO9K1gE1oYFZIgpQ4SElGghV5LZZZ7dUDUgmqSIUFLGTJ2z9tjb6AiihapAxJRfTfPcjeaynA/j28vpFbEUEqeYATmoDWMVoRRlmBHEhIgUszdgzmkZrR8nMw8pxAzDAhlGlBeFMQZhQCFAOcaUnU7ZI64kBthbRDi2xuopCV6aIVESmroNYcgwOhf1rINOu6olhWBl4/oZsT7phQvq/aZuaNM2VFGdjV6AcaAJ/8b4FoRyOKLDcelf9PT2FYTx3bt49Wl/db0Ckiwzn3ui+OH7j7VzjEu+WldtU5d4ozgWWKniuZD1OJFlNlAwmGGIVhWkXRWi4YDQWVsfFAI6Jp1hElzOTvuQfEAxkvPFnDpNjoeBFyAx+/zb0J2XoUsep1/vX+YafvN+AzhOFuWLMm8v+PL27vsqBUfAlubGuxHhuWpMTBGTlouGiaofl7WSDGegYdbGDOP8mHMXUufHl5kgsr7eVDTI0NCwg47UJbBujPpZyr+vy31n8PPrX8oSrX1NSs8UG3q6WFuWjJGSywCJ3u5BWWNrPYHcpqqsNgQ0SS1llBlwvyAmuMPH7nSvfYend0yWxiaQcHul9tdtgNP0Jg+PtJv+huFOkc3d7+w3n6SShEFZtdA4k6JW6mMcjJ+5G/PZL3FMAKUQl2F5Xa34peuz3/fDKwyhqNLf/f5aL0U04Pz2Oi9jghATHgLQM+rnk/a99wqhtip3TAI9o2F0CFPr/bTMhSjH2aZMYgY5IsyoT5OxE2UwOUuZBCjnBIUotdPR+7Iqy6pahvlyMSES75vn4b88Dw8R7vyyr0pWr0B9Ra4/bevte++yszbmBBwAAFNa48D1POp+4hRFEEAyNeWYxGqlMKFDNycnEZ9jACgKnBOCxOcjhutCiXl+Ra62vdYzFFUmFEtVqJpOk0lraoOZzAxmiMcRIp3AI0DCOkjAFROTKIUO+vOX4XA8ztb847v/ysWtsd3r06fn56fz/dvp6T+vKrDfFing88HR/BFBeXclSBQ1+6apt7vrRMsDwHOYAQsFyjT65ExAmWJIvAsxJkpRs1JqXQAG9BLPpwnReiUpSqRgQrK11a+L7o0BMYJl8dZm8vLlJeUslRrPnbYDrwICcPwc6/DJvsvimkTsBk0Xz2ThGPww+hdS/wwwl4QbTZZuW5RFd9QZ9EykghdZsaxgeBvHz/74EF4+d5ehm5ZZg45meBie6MPe2MfvEa787UPnGZeL+qMN8vn4mNL9ipcs0GF6QyBmVnO8tUMQtPD2V3JeQYASSJBzSrFPh1LKaToD/hiNwpTnnBaH9eRDcoBt5KpBYoYgUEBAugY5WAMOJ/v6OE/9zLl9dws2m1IIRiBDkfBVqbPLvPVR6QNNEUnsrUyTPnFRlvVqmIxDz709xxA38puG3RIcE/iviHz4+Hd/fjzBhv8UfV8Uk7Pf9L04T8dLf2kb9e67yCk0Rhj758V1L8+YpCsav7ihQxoIdv3b0xNmnqYfvLPd5VSkd0oyXrxV65ihCY4O0ahtseGyYCzYuVijOKh/+/HXx9PL42v2oUUxcHe4UqsPN/D7v/v+7u+/jTKaf856ikqJMMecIyMgukBhBkKiSBczEl525HF/tUMSJla588KIsSPKCUPCHR8hMayAKs8FJ/5QxBByykATA79AglbFFV3bzb71XTUeX7R1TCPJjfdzBNHGFSTYwCmQ4vXL8PzF3v/yfwyXY8XJl9cdgLyfxtfhf5/naeizNtRj8utLpoVc62aPA6I6Dof3m2879UVWp90nWqvfmQmNLmv37PyAxLXVxGpHso0upQhoKUjhATvZlFxUCAMaFzt7mAGjbTfal1OvQZcp9ikYgwhEZNE55nTuz2HOixmrxK6u2hCTtcvpYG7KMgtAKCAEpoT6TmPKCrXxkFjjQEYAwQxAyi7lQBhNCeehGEanX/zTL8NP//Z56H0iYLEBIm6s0XZEBrIOQne5+VDebvb3T88hyvNl/Hr/VLfT9lsihVPihhTYBjvbuWpytcbeCyYbvThaGcljCE4vDQgWpjSMKbNJ67M3RcYB0Jy1TGmGAFPYBj8qhSmNMetx6pahnvVPTLj95uN+vWOMCEEiG1a7NgEDAXE+TJdlGWwMwRlLUc7UKJ4gZgAaxnx3AYVqAx1S1jGmCl+pAldC13SU77cIN+r6NVh4HtzlmcMI7m63mJ5ub/4vx6OJXrSbIWbhj8KgCm72h8MFQXd5DQG9eT3BBAt6laqZFgTBMmoQU8zJ+9DTBkBqPRa44GZR3Wk2fYS6KZGjBQj+vijNzTX58x//8ZtPv+Nirc3AZXDWWD8DkCghGWXEIFc55wgDKFZIslzJtmI1snHozhTDZR4kqTKEIEOlJCYJZo8hMosLLlEMXfA5BpIIyiTMIQycUDhd5svhFeagEA+EeQcRvpYFhRgnb46v8L/+l5+/fn7Wl/9cy9WWfHM5l9qA02XScHbe5QArUWxqxaJxPXKAagJ5GdMUCNOKZkmy4MT6ISVAOUWQYtQ6Y7O383BalTeYBO01wn4a4GwjlrjvjykhCLfBaSWpd+F8vOjZIIi5ENEvBEOMKRnnmHLOgHpzST44QwRlWGFEIs4cQUYorGugJJsTDjEBCO2S9Zjm2WJMGUcYQ8yzqOj6uk6+7h9t1+unL4fnh9MwuNFFbdxidVNznHMMwQcNe3n4pdtfhQ83vxu74bfn4BaPMsaoCMnbEGlkOFDgIcGYsYhwFnylip2QEKuD9kcYEid38+XIVeXMTHifkLUOAH4CxKFYYXyAwBEqpbxCiGFxBnHfH8XQ30uOVqt9tbbOLwCJTetoU6x3tTNo6mOIaO4DRqAsGwz7qiQ+EEYjmJec4vX2g5619/Tc+xzfNm17etxCeJhlvN3WYrMhgkG4e/k6LuNMcIcgupzieNoqBIwDAXzNkyCpdfjMBckJeMdfHi7ThABchenYNPzm4xQpsIDFiaAUIAQBOiSBVJSsfUYsZXk44reng5vmEuGrokiAeucEk99//N23f/gTAWj85TxHDYyTFZNKAJCWedZ6JIiyimAGss/EIgw8LhrnMwARIdUNHYhOlazvFwSZEkKbaVlmgXn0Piw0Y5BzEhwyolIGS7eEkIwdun4R0F7t1iXDixUx4pyBLCUW5fn+/ONfvv7LP/2b12ODRUFqmsmylMamGHMEBz3Pu9VmXay2bdnwhRgcUjyOY6bj+XgomRJFIiBH7fvhAQBY8I0QIkcUHXTmwjDMFgNklUAuTPOFUlkKSssacc5o3i9dIBiMo5nnhVEGEyAQC8qSRAhBAhJy1hnnsx6ruoWAP7881W214lnJW5AJzAkKgBCAkHIOAUrO6pxrCGnKKEMQUiQcqIJDioPJ3cV1fbichvPlFHxAmMHkc3TBAhw9hplijyP3i+1OXb262a6J8YoLut5IhD2OE4oAI+Z1kKpcrVnCy9AbLgvvDkJKrIO1IgQWzHwZLtvdutiWrFLv5MdxLM+nx77r5kjzEjnF23qvqjJknxH0ms+zpYzu71RZ84QSJu76drW6WiNcO52nbvntl1e92GSh4KzhDUwSA0wYIzStuMSTqWeDk3p7OxNxv2/2emScmZS5dehmj9vfc0j5dK+CnfSoJQk8b1++LNfvy276hTGB/Prh/jeMY70aN+XfT6fgJkX4K7T9NHoMudhuYtRIFDmnGCnEOaTggNE+9sbXhIpKhMAGl99en/QwUkZrQlNCiXwq69AWHzEIY38chgnjRtagbCTmLPkgoBKlQoCglKd+CsALJgSTMaWcqHc2hCRoCTA5vnWcFzHk6Tyogq3qVfLgMozZkowxwVAIjwDmnFEQ9SKyzwKDgqyzleeLnuaoXa/aZVimaabHU7NMi7NLigNKO5prQVLO1KZFCcRIpCjtmryv+bZVFWXQK6v9oXtZnA8pLzeHQhROg9cHk0koaqFqDB0dLzpHHBxgWMWU6rL2wZiouagYL92ylDVDkCDomCQ5BGO1MQtMSAkOEqxLVVAGUSbBO8locE6UimKCUOHthdGWC8SJyi4553gExi4Ec0xnhEPMBuNWSmGdSzBmlAhB2hn90qdw05n8Ns6D0TE5ayZVNEwIlgEBSFHIYEIh4sQ4rYajn/YjwW63K6nSLiRGy4K/V6Iy+nGZAWWJsi4BxrgiFLv8YiO0JxFs2fdLyn9rP/n9DwJwIKqaVnXw2XffDufl+LnvH5idbIEzVZ3iGMPWyLzaimb1jlbjYscEdruPYX0lzNK4Az0+96fDsT/2IKVVU1Dk3XxxyQGsCKMFrSIeALeqWt99egJ4hO5dWxshnKqqKM+bT7W4o7EyhKFEMCccBcJiJZnVsz4PX0frKVbY/slNY1GgihGcKjfP0VvtTjaOTFWrXakqlTPmBHIKsMIejz7OrIX19hOvBFkFKFGeAiLIGjv2oxIKJg9SZoxJxXwcX551StkYiEDkNcwwBecAJJQrhAhGdBlnGxDCHFEGKTfOY176yKLL0ScMmJnH5B3C3PuQOAMMReeDi8DnGLlHOoIeI76RjDGcU0UxLWkOU3V8nfuDttNyGV6QHKOyhF6X9f+tLt/dXH1jbGpDSwmHiTOaGckMJijhzW6/ktW79a4UMpspJpZhTiHMkxVFdemOBgLEuB85K4GqCsJ5ctjb5A1AqAIZZWycB5fL4DBpSwpBcNqOEVcVJvJEObY5F5V6//5d9DHZKfuIIIZSUQaIIFQWynmLIoAASK66yY3DsNqXKQBvooMuj24aOhlAWWFMoHYQBQoRhhgXK26tJQSv123K5v4300+x17abhhAsowiFWArZ1DUIsWQAg0jDjHPDUBsNorgggjEgsZgyZIIXcalg4ptt2F9VwWdSGkJakNn9y9fde1tU5O2hcprNvbn7Bv7uz/+e36wAmwFQAEBIngVZqWaz24rlZvf68KbPB8S1VAyBINXVfncjbw5WfyLdgqvY7Lk29uXZj7+N03nqL10hEGFo1XJGoPf94pYIHaYcUdneSh5gAi4lSonKOu9Wt1XDittnWH4bUSTVlOkKKEUq36zq4dQlMjQtblbXl+EKA2v0IOVf9/wjQTC581v/V23caMZxSN6rprrG/Ozzpd3sGM+cZ4dTQBNBZvfDvny/BhGDOoM8Ju1kIXf7fVySgC2lHkDD6m59V7Y7j1BBYA1pyDGB5LR2zgfJS0qZdVYv0zwtwcamrIwJl/O5IMlbK7AYPbUmOb3gRHPERuvRTssyVmu8qtarNRmO3mgQonNhJigUhcApFOp21i6kaHW+nMzh2Q6Hh5BCwlC+G7774XdcYYxvzfTHcz/UCXHEJdlDxlZVmREIaHz37l0jmrVq9bA8P78FnWEWBNGy4s1668BvxmfJJSGbqq7a1ToDP40aZKykcBGkkHPqn1/7lFDR7hACMS4EIzsFRXFApwwlwqSuCwP81I9NXSUftdYIQMog2dw0KQHuuD63enG1it+9/1MEGgX4+F9+3u52XKr5PMaJPM2enZ6aZgfiTSQFInB2c7siOKOqrr3By0iXi6UDET1GyJMahhBbptqUSwQVzUhIIoTB3xXMUOxXn6SNZlkCqSBV1aLHaU4o9kqottlENQTo8vKHcTyfL8/GLzCsgRMkXZnwt5uP7MPv9qQmZhlohCkGjGli0MNLxCCja3QzbBrhTnu7OKutKhqY08X/ak1nTEyMlRWcXvDrk3v9rc/6UCkm9poxLrjynlkXY8KI4uDmGHQ2rc2+s5dIWqL47TfvMZ5X10oKGtEPSFCffI6cBAq859+AghRNcc1/8njKMOHdtlz8CaErFqvk+nmezVIvBqRMckaF7KFKpXqoqaoJRw6zFmQUUcJt+73DBhQ5FT7jABlES52DTWYSSpZtVZGmLA0VZWS82F6jooQ8knSpV2WehB711A0x5skvnElnkw+JcraqW0LANPUJ2kATJDGzkHwQkmRLoS/0bK1ZQh498qvtpn4vgeT4cjY/OaMjxA1GKxehRJmwLwVAy8gG85yDhpAo9cH6xaUe+WVVHva3//PZ/b/YRk303wlqKZUgcppchN7Dub7+pq6rVbvOSwpLtoY7vQgeBSG4wqoBlO7VVqyvOK46VQiEB90Dt8zBBhilICREZ0OJCeWMQTa74DEDgkbBREzT3O2MnjAKGD/DHIqWUFw4QzjjxgQbLVmt1Pnc7/frF/fEUq63WKmEmcjZn4+LnhLBBbF7FjYiRrNMMUKXusheVMnbHVdVixByU7YzOjwvDBQsJRZQjUVMuVqvcoclLyiiqmSr25Ws5TnEYBCnJV0ZQFyFkaiYdZga6hYoKJQSWPwkVC346ulkD6flcrYE1UGvXk5jf5ptiJyH7njpI3E57W94iLQoq8BYggghknAGHhKqliC0nnMS5+5CcFmW1TTExYwIU3Qh/fP49PUNWstorBolxDtMMILIOgMB73vrtCAExuhP4HH+XEAqQcrra1pUQu0qrHjwyYw5Z5BjhMADgHMOGYPyJr/D9DLu81kzijzunS/05IeXaelnzjiCFGQ7jYONdrcvy0pKFjkDZV0SRoKrmKCRnJxNiFN3KeQq4UoC7fIJvv00f/3n4/D6mxSYFYeyKTa7FeAV3hBIAqRMgDYY58HonNWLz7FyE3nTMyVgtYdtxTHtuotFCQq6pjjlBJwGBNU5xpAv3utFu2jF62UqW5zQnHFP6v1u9S5M+eHx3oRDUdIYbQZkmdTQWdPj/uI4VpuGjqADywKiE1xQQrgi23eI13IctZkhSHQ8x1n/JcHY7tt2X1AaADaQowCW9qoczoGgvF/f9sAmhrZXZXPDqxUhhYS5mDrtegRiGeyCs0Mlo1ycXvrDeKacNULtVCMUS8DrORsdvIneOZCDYIAxFGIgzMWY6rZJ/bJZVaSsqI9cyRaxZwTFqqbD0QBLrIWy2i1zjsFJclAS8rU2Jodo1QqtbtvF6CXqaYbjOMi81sPMMct4XFWi4kX+WsJc64tWsEI48QrsfydXtyrCNE556WIiFAOJKE4wzfOrUGq7bTAgThtrdPS1tuvLm77/ejq+PntrNs1u6Jfn5yc9OBdHp8U4Rk9+hRT4mVdtSYBm1ZYXygVP+Uy57F7Pz29j9EZKitjUbNdVVWTQCHeBEGTD5vNxeOu3dbq6uipKkTxlhFOGE5gIFEGofiHTNCKMCZ3BoVqs3dxyUeXiGgd2CEDRduWWiGKGAHi9gIbihCCEsM4ypJGWHtB5mR+6v0R97Q0en0BTM6VaYx3IxlmDSABJt1VT1SwGWxRKCAXFajGjcYMoKwByHnSeYI5RD+Kn/7X/yz/9fPn6lFO/agXEkyrvqGzL7Y5sYwIgwRIt6nx4MdMlu/Uy6BxSjiHHjDmyepnHzGTGACihQEpKrENMIUTrqXVLxtklZ7w3MwWwnPVwHl7aBTcLTwH1IwKIZYhDBoSp47nrXofDSy/ALoWlqUnBicGkLEqeiZCSwncEC1LiCOpuHo+9f7p/nnscll+/+e5jWW84/S7l9OXrT9MJKt7WKyubT021pjKylI7jINZe1BCLiAn0E3AGAS9QMiAmQGYurt9ezNPLfco0hFxWVdHWjKbpYOaDjwEyMmGMnQ8oY4Ko91bHKaYwaZewp4UiskYm4piCYO/mabp/6OdupJSHkIsEEIIIpgB0oQQmbvudQgTzkqxutmJ2zpFgSkTo2NkcFpicELOsmJ7ju7CeLp5GsmnXN9+IjBZ4PZhWYM6v775b5bcY5qfP8v5fx7E3hIO6cU1r33+kTV0igo9P6vIKf/u6KFq2bRF8LlXiwmAyF+XOjdx67rsykKeMlvs8vf8hYZxUuwbQUpEBXGCg1aq6+RBPT3OpGJVSNaZY2xCYog1I+e0XaBfvdfSAeIMsSTC7kFK0GSR47kark3eKISokCbbD2CRt5x6t8iraDAmhhfTzRLFy2npjKsWQBwiDhFCa0fKadI+//Pg2j5fjPNRqt6p3FacIDimBEBKCEcNAaOIcSIXLSjhPMGeIicmN/Tj6pcyBRah33xMM5OFvl1//Uv0v/5+/9KeXSj5DoHI0KMe2tOM08/Wa4FqP8zRb7LBe8jJG3WfvMASLLJNSEECfIDY+UVXxAiIMAXIZHjPwIHtv93pZco7eBwAzwK4quM8UpuRmNoMw9MPwZgAMkODukpZl+vr1fjjF81u/b0NdnHPWlVKzO9/c7cu2kuuiWdcxpXkMn788/PS3H18flmmaEYQ/vNtc3d6p8vZ4eem67vF+wKh7dzfh6mp9hRg7hwSE3/BchTh256UMTIlwfH5dRk+DEiyXNYE5jyc9njQ0V0o5yjNDQ+jXzsbT8QRBWFdl0GoJ1i7GzJHOBCFQNgwL7JIhAsXsCCkhi3Se0ukIQBbWaEiyDSPltJsPMWYMMXBm1TR1IdpVWO82XEm+3uTL4Ae7mBNv+DxchMjAp0qtAJLR6fff1ENzBolhnFERIoDi+n2xazJIkGOGbh9/+fqXn05mCVIo596Ob/rl0STf7LbXCNHpuH16Pn755WG/rQo1G3OpuJJceOcpS5DlUY8AyaISVut4rFZXpKxFQolQjwTJASUNmVD7mxnMW7dkbSJkXX1VIFHkALQOb29em4lzGG3xeD+1W3R7R6QCfT/gXOOMo9M5aNmQuuYJbkkBipZeJju8JjMF2uJM+maz6c5d9pkg4CYvMAGQIsjGB/jzf+v7n8bzy7M1hvJN26KbK6yJ7ufkg0/Jgew4h0UtvvnmnZAMgMx5ESMcJvc69DkT3fHL5VWWYPuxnV7Y17+Ff/k/X55e7pf5NM0vrfwAI8/lZuynV/qcaKjyd+NsxzlwMFCEMJDGDoRgQiEViDCIKGIClRWXJU8Iex8yZHimzlhnweJOEACQsBAoZ8OFpwICVDXlNi3rcwfOx3l+e6SUIEbmAZwututg3/cu6tm9MXnmqE4Y335bf/v9hhY6U5KhPrxNh6fyL395+PrbabzMsoD1Kl69211/qBHXX/6lO51OAJ+3zdZ6erZ/EelOVFtCdT71m13JxMpoRLMAhmS7SMIoRs4aGyJjcuyM83B9HSnnqpBFVYzjEaFEubALGUcBwDSZOeQAMrGzBSCzgta19NHa7P1oiA1hNubloA+XF04Jp/ibj9923TjpWMp26PvFLNGey1qoSpRtK8rS58CBy8xbdGJNzAC0V8QcAkOyO0KHIuGN2l/2n8rkxsXKn35+A1jUeT1ZMNtZrZ7CCM/DMaPk3HQ+Putx+fTu++F4PpWwoJoxM8+jdYZyj6AhGEafCSoZ3Q49EKUJ2Z6HA2beZ9R3y2Z9rWcIUmmNRpJl4zOACIOg4zyf+oM8PM68lNVVzIlAknLEejL9ZU7RSIVzx7tTn/Ky3QFCy5StW4LR0JkEgI8pDIMupADVBGDEWHRv5vZuY49R1On1/DKOc45ASNGoHbIpuLnTw7/+H+a//qd/wcfDdSUZB0W7vb4Nn77JZhP/5Z+zMSZlj0heber3H7bv39+eL6d5nmQhrAvzaI/9wllxfBln/beb9+unR5BwPr+J+8fPFh4DGgAWhZS1Kku+dfpv89iLIfL6Q6UawtLSP2aAAUBEdlIoShXEBGDQbKhoTFFLwjOEq2UO3Tmb/mCW2ZqZSLZe7XKidE3PlzfGo6pFTIDx2rmiezs93B8rOAvWdif78tzPi9YuI5qrtUBoRjxUrahLdffp+3pbXIYfl9kixE9n+stf7elZQHe3rhIkw/t39Ps/fpRy/fMv/fPrc1mWGPwBYb+4RcUPkKxRsfHGIzJW6+xMcmdbsIKquuRhHMbFLThzghQMUjRmCgciC1LYgMfAXXIFRNIju+SFAEfy1iUDUAo+jfNIKRHFFWIkWZ8RcxGR89P6r//2usx9WvL+w26zL5ubmjYsHc66nwoFJRWZlSSnGFzOylkaM5xHP09B8e16s+6Hwds0xotzoFANRhPiPq9gXF9NHf9v//t2nMNmW14u/xrOJWGFNd3wuH78QgUrB/EC0SUszaX31pK++8nv/w4GSdLaLMeyuNb2ee4oI7tcPGt0rVH19KghROcTLlRnhzTP/Z9+X+7LVsYpnmQAmCrmw4yWEA0YvnB37lYcoeJEwXp+y6oi5py//tPz8nWOCyNIiioXJiY/vH7N0XCEV6fjiZFC22HuzXjhnLIz8qtRZBRRC6CY+MpdLub4EAQrkJNWj/OUFh6mJf/8y8PzC/2Xf3o+vnW7UhJ8qZUoNQIeE1qT7Xp7Be6/PqxuCiSpVGK9uVpsTBkzRnP0ZrEAtj66t4f+/MUKaeZzP7zZCP/h9BC8HdLsSkJvWlNXU61YmAyjDXWCQ1qtyOxGC/Bs0aZeY6JF87reYVmKSDGXHFAoii2hPNkAA9KnaX4dpmFxzhEstoRyzjLhnhlZUkg0oVARpejq/GZC6BnvML6LoHELGab/GINNbikLKjhbr5pN/R82W9ls5szMOMVprChfoUyz60GIqxqs151A1Xa/+t3fcfnd6u0x/3ZYOYyfLmeCfwH8D9vVByQXSOR0NsHQhOXT8wWAxBXHAhs9xpQYE2aeIQlCMGcvLmEH0HDy4fgqZF6NN9stYwRHOgWTAOYmP1kHGW+CMYWEqoy4egbtnmQaMmG5Ip9/+ddlOhVKUglkYWPyfTe3q+01ajrizGLmwQAAqMRUUQsABt7DnkNQb9Q8+6GLEBQppJTOlIKUH3mNdnd70e76o35+QS531TpmclqmECNyzkFJw5TnYRlnkGG5LtpUzM52QhJBts6wptpO/WzNEgApFesHZ7TNWSKIzbJcLiF4xznjHAPoFGa335RXt+/m2cwPxL+8fvrunbfMHtlwntOc66JMIRLB3AjtZPRx/vKX55eHA5gQyVmVVJDsKQ45AoCm3iBEgqEupmlIwWS7dCHY9bqs7XvjIiGgWjFGmZIoOheTI4jCHDnlz/fH//Kfl4eHowHWuQvnc9OuOW45au1w3b0eLpvFkJGK/faqwHxWtWiaBqTkbACJYCRiZM46baMxYZrG2R+pwJQoDEMyRqbYgCJi01ZyV9yuipIilaGAyUu+Wq9WTkOjgwfe52NAEaqlpAUSWG1lcb2GgiRgESEwZHe0oXPDOJnZJw1hoCHnRTxsOQqYIlxJujmd1dt5LCRet0Gyer/5UKnb/tIHHxLQShBCqTZpvVLv398SChTHdQMytufXjDA2zjXrDlNWFPruEx0Xi3leVcX7T5v1J+TCtdcOxsxQ1U9GrLiUkDK7aolezqfTTHEBMeRCmMVixIMJ2f93rGWJ2TNCmeQ6mONB56yCN9Mcosc4Lle7G5QpxoWqgNZx0cHqGWafCSArWl+XzR82pNnnCIJPODPi3OHDh+Z6fx38ICT3wZ/PfVNvb6/v5stvh77Xi65rIcqqXV+JTeIyF6zhhYwRvbw+0qDLogBAZ2Sp5BJhuRFUpu64vBwumIrdpym5YM0M/bUgFaUgwRnwqin8NOn+7McuuKkvGIYACbZFsDq8TefxrO0cEtmsmBAw+KSUGofB+wBBsm7Z7hqC7WLMx2/esRoGSCJQ3RsE1M7lzBHLIwYTEURnn7VZMhHDsBjjULSH+yHMsGGC0+SXCRKCcQYAVkUFgPA+6dnPo7Em5ZRiWCCKQgIuDaAWkOjdEly12wtBwfnYu5GQfDOe/PN9//ibHsaMZGIsW2O87zygqt2hwAEgenGeeAB0WaGAQ9M2ZSnsmBGVOQDngvfZW9R3dhiWaZ5NfIOo3V/f3V4v/TP7OvY1AO11UUjZimuZFQUCCWXQiSlTbF1WOtMkYGnnImdGOI/8XOxKdV3iJmXqsEggemATKiHsMMKUQriYJwByjNHOcuq4WDURrO6/DPcPuT++cu4Uf/74sby+vml3KwQra2JKHpFVoWSMG4jy9fX7EE0CaTB6XkwwbxAiCEnZIkHq1UqmbKrA1vsf6vp72TAo8vIKLpc+BFKXnOItZZESjVAfIiRIIoit7wUpIYpt1TDM9axRgnqeffBNWxRly7h8PXUhIKv9PA8QML34VQkxBs7podezCdb52eq4zAxm3ND6A998W7FvGEA4R4xH6F8TkYy2ddm0xLmd1qYst+cT+OmvLz981zoDzqchhrBZVTBTAlW9D0xIEGl0IoW02b6DNhCSrFqIyohBCFbep7Hzk58wC0LRQb94K0Kkw6BEYTfbComgL1Bxut93hWysSUEAAhdOUVOvpFRd3yGmQuy0MdbKnBElJHq/atV2szbWSEUQTNqOpSp+//0fYrgfhskYQEi5Wa3dMOScsy0LjjAP4xSc9T6RfrTzbLKzJKCKFyB6Y5eUwxIiZlgKKYQYB9910zJ551KMMLqEEKrKopSKEgkRtdABAFKmkNCizlrjqMOmrP/b86+Ht4sLJ4BM8HQ2wGmqmdf5zNRG8qlZEQBDikqVhBAUsSwkDnaCidvFwZQZIi7lnEFMyRprjNXOjLoPyaPMbdeBeWjozBVbtW1BtorqeekAjLIkaisBIZSs52nxgUJApSpoTeg1a293ULEQJ4hBCiGZgBLhTCFGGTEWeRiKnBOGmcoXpmpIxLmbfvr85eefL255gXlU7GWZlJ3zH363/vDh+rcvTwCeCQYYo5xIVdbWAuNywtq5mPNa1k3OyOls7ZERXIimkAdM1KrdhRTfng4ZJ8oRBi8QBgqH9VXVD4lhu99vmQhc1iwiE85NVRJMBW2Xi86ZTMOAUG7KQlVFzMA6kwGBCNiwxLwUQhCspKDeG+fd+TIPSw8QsJFyhkRB5JXcfSvLdxJQB4yfLn55ZKfPnlhbPT3Ox9NRtdeciX4aHx8GhBBKjykYEDLOgeSYvdHzuIyScRVTTMmmnKtGDm/j4XQOJlJZYSaCR15PYTQewYikMSxFRUjrYEoAQzpTSUMoh+5idL+5Pn3z6Q/TkOfzyru3zbqkiCDiRYnHIytUpRQg2AbvCYLORcHFpw8fp+nJedT350KCdze73arurJjtpIqqZKzldLjYcTgTmjBiIXOEWFEIG5DTRo8ORpRAgoy4tFAOVFlBgdtSxRAvl8sye63NNBuYmZ519EYqiBHLiU6TAwgFRDlVlLbOzt45zHDRQExiSKPLoyhARHDxSGsk+AZiy5QHBGg9NhDE7AhvhGRCkACd93bsJxJLgRXE0HqfQGYClDVFR+i0g7DMZBr0Mad3wGUOk6oGJuXNfkfJSlEYD0siBG8a3lY6oMtvpxBgUZYIJUxDc8XRXQUVANBhSCDB0ADsCQgQWDxPehjnfrIZYucCRAlBkCJ+e/J//e385bfDb88PgnQgLlGkqYMEVJyXL4/m+emEqWvrDQAwOo9JTtmYMET00myvc5KibHPA5nkZpheQMwcKJ1CJIi7p5fDSD0NGeHcLFAsMTjgmBuDN5n1Ro7aqURkiFBxLUfhCNjgT1+dFu+hS8Ekw2JRFRmnuJx8ARoQQgnEmjMRAFW+sHs7HIQOgZxoSDcEDWIvVcvUNb765KvY0wYSM0q/88387H/52Oj4cyNzTgz6tNn6MZ5jx6+Px+Ny9v7tb2JTDXCmGIZQcCY5gdrrfcOQnfRYqYMT0Qr3np9PI4lpyCjHS5hCW2UxTQJTyBiCpk2KYwpxkk+oNC3B5fOSff/wCoqlu3/bXf1/XNLX1PJJC0XnpuKKQktOF5wwABFrbaZiVKCCQKfm///vvfBDPL/dCwG+/Wd1eXQe/cN4krLXp1utmOtigqRlA2WLnkwk8zAOGwAfsXYoBSEGynwHOVSW2NztECaAUOUNw1Lqf53FZNIIYZjjPXfAeAHLOEeVIqqeikQSpjGCCFmTkLcKwYEIuI6J8LRXv5ifrfYwxg6DKgsCAQJmS4qQqG8YVtjBTRrgUBPhlGTHGFKHobAwhw7RaryDi4XFQQmJIS7nj0ix6yJFdXV89PX7mhd3uPjarNgOazV6qSq62pnoMOMxxWMI4Dtb4OUFNyIYwBXhwwSCESGbARuQJmKLTPum0dNprlxPwyc1mYowIfrXM4vURPdxPx4P10erlrSkYJbxtrt+9+173y3CuYJJV0SbDnbNVVTAZjpfX9VVd36kYTFVJVKbo0KjddBm1ZQY7RBFF5eUI7v82T5MLCerpdbf+cHt1SxE2Wiumoj+/vVyKK0pKcXWzATdXQFOwRP06pQz7fqm5xMSQmkfjgjd9t4wL8b5yBniHjPZBLxO7jKODEGvTAKGMHjHD1Qai4qxDKcM1oWx6RF/+yf/Tf3w+fn4Zhi/k+++r00UHOIKlnsbe91oBk6ZTohAD3qptURalwgBFG8I+95cvs/dQk1mpFcyt8084XlbNTU4u5zT0cbkYAmnVwBhfBBNTf0b1sruuCISSbS+n6fzy4ka3adbIUkooq3JUT0rVy+g3Nxbj5u1V121qu9XlbFOCTYPapqABA/dFoP7TFVxX1xneVPvRAnkycdtkkHRVw/PhAbgmZixXt2XDtZ7t+By957yIHrCMCiaEhGwrrq5XlHul6DIbq71xOYbsDHAXSxLKLrq0RDdnDGfnM4XCBdZhTjjZWEi1DUMyzfGXRXFeiAHjyx//zGClwa/fnv75b9lfStQ3JL/f80+f3m02pZC2Wtcpw5wwLPPoepILM5hCFCjPOSdACQyrQm1TjGv6rFzekBKTjP1K5V1VXVs07n+QAP3hw+9u5tmeDgOoMGgQ31I33U1jcOek7TDPiabp7n1Fk/PnFwhvrEuIaiYQ9Bl65S66Ow1h6aAuhM1mwLPXsz5vtxu8rV0Qc6DH80/L/KyAh5g2DP7uB/mnP/3JJ34+EZA+v7uuYloP5AxRDoi86l/X11fN/iPn4Ol4vP/c39wMdbFvkBx0SWTjWUZl8a9Px5d7/nT/SgkQNPLYcbhb726mEB3wn+9PND8zrK+W6/qPZ9CaWP4A7RLmw9BBYFW03ARf3doMn0bjT93u9YW9dWc7/1MO2k/fYP4UyxMlTzl+J/iGEJkTkChl/LMsWyoKZPbjZ8cqMhzmz/+57z/buLhNq4hiDteFoDdI4L7PJV2mHjHKc05cCiqYrIRHhlComjJoOnfOepMARusc8yvFLUouxBFE7izohp4jqKRkHIecUrZFKZu6xAgJLNxsusPFTUvTwqKxdXVrNSGUWTfFEAAlZt4tGp7PQKdLUfGULAKaQrpqFadYj/HFXZyri6KJGRDsMs5UMJhPDG3NFNzEJQsAa4KTd2iZnXM2A5ghiMAR5lXFVUW4FIUS2ob+4pclTYOzMwAZAoNhKhBACQQQAkGVjSYDF50VHNS7zeZmBVbnzXVVrPjjr5fjwXAEYfCstn/3D7//9/+oVnU1jfP53FWy/vD+6v31+vtPfySYpYQCNNNwiagn5jpHmoCNKUJIUFi72VNKo3XH7nGetTN41RrnzDxQiAEhAVddoYo7snauAKzR4zkLj+hZKgHQ7KOVUhFCCC6Sd5wKxTZLPxEgz7++YYJimJM9V6rx03w5dnpZCMGcFNqDw2zG0yMEFsUasgBg0jaM4wCgb1rAc3WzX//97/64b98N/ejdWfCc8hSAj34nKzTHz3c315vtvqppjCz47qe/HF2vP7yvnTkjqCHwSjSnHn/55dcvv3Y539/dXCOQkLy2YDtNq2f9T+fz+e1+yvbxalOk4sfK/h6YGhzGfElvX6bLcynIIaWe82s3ySnBt2PfvaVkSr3829TbGDIA/01lLtWuWt0V4krPwPko2rGoDYQ3ICYCpRSyn83h6XJ+AfOpL6i//cZtd3fk8jCWhWhUQlwAzn1RS6wY4wghiFO9YatraaJWJSsbZBYiaMuoTqCJ3okq6YFKvuPUTks8H+ccIkTIG8sUKmuJCSwxhRCHEJko5/NiJqunebVCTSvu3u21Ty7atzekh0XJ2ul47A7d0Gtv/OgIxFdXpClWpZIMsWW6OOtFKVWVuJKsLky0CXrTbYfJ6jkCbyFpGC6pOAJwLprg7SbmCUIsVKZcKSVTMlRQCIA1cJmDc7nvk588ypCAhBAiCKVEvXEZwpg8QBpAX1fh5g98e6f4uhW7zXLqUM71SuUABS4STMe3Y/Ohef8N+5/oD9MEV6t0d3sVbMKJxYhTJNpdInWAaC6K6FIKZyGQVMKd+Xg8EByX+eXx/vl8HNryIy7bIgjjlgB7Z0AMQe1pI/AwXwweySYkFKOFCksXsvc+peV86oXgVSnrQszTqJSYp6XvzgAAP5k4+Yn10cTgYcxIbW4CqL6+Pvz49fVGgu16g6jA6oJMZOJGsFXwvq2iRMvvf9h9vLvyU84+l1zEkDPy3fCF4O1iL7i+3N3+j8fTOacZJsJxUfLZz8Pp5ZS93lQfN82Gsen8W+csjK5MMKoK3dwRFz6dlvL++e1fvvx8OV/8cq5pyjStPSmwAFOwz+fplZwfoJ8MphZnAKEJVvQLuDyvusucskcwCCGDi9XK3N5uP3z4gEHZncPg+4iOPo6FIrvdVVEeQ5hy7pRAKcRYhW8+IT3Dti1vbt8RRfOqEAKyy9lFh0vSVCtCGfbZQGn272W7xTpQQpEN4zhkLihhKAbkfAiDprlBCNrZhyUn7QQUKHoIIIKAS8Ilq3br4OHl1L++zb/9+nR6OxsT1ZKDzjFPTGEAkZ7rw+FQV3Yc32Z9IQSV+EOM2upZz+dNs16vGwzEEkLdSqxg6BNXNwABAABJREFUogbJBHmklgWfywLrPgoqGa5g1hDGHKN3kJDa2uBiUAhQgsLitQ45BWMQhHbWwTiYAcowaTtgAJuSCoUwQtiCOWGeSHIYk1CtSLkyzYdUXEWC6ziw81tCAK6uEmOkKat5xIfjYfrb0Lxj778TBHzrNNE6RG8IuSCaIbHQx0LQ5G+i1zF6lJMSBUpo6Xqc88vXh8PL5xQDcK4/3sezlkXRFHkhKQVzenOZesx4feUBZuEYQb8lOD89dDHMzjqjdfSOkLTZtIJ5yglCGESLY5gnkx2RWHljOQVN22gTIYLH8/Hh+avNs1zJ+moFJUJk2F+v5k/V6/P7ywVj/PLdp3e31+2yPOvRcV56T4tC+DRzUfv8ALFbrVZBl8fHtw70m6bAJjVinA4B2ku16ir1DcN0HgeUJMwdK5ZqTfd3zXa7eTrd/fL517/8/OOXL+eYYlEdZHGVci7EO0HK0I/zC7+8WmgVAedgmOBXEJ+dQ9OYlv5qMX814ZIyA8AKiW5vb66vlZCLvlwtw9HMBooDxU0pt00bECqDCTPwAAFG0WbDFVT9WQ+n9X95nIgQkDAYQMIAwphSjIhkRACjaXVTyDIbN2gTnLM54SXORNYUCV54ErnRAKPFez8dPYiBxACjKJQiBOaoAUiYwAiBC/DU67/+9HR87obzwCG73cr9pqZAurhMy2hs5WOXYc6JCKEYw3pBPsK23V7f0fWqtHGY+4EWnqk2C5cRXpxHC44TMrOt6oFziDJOS87ZpuwplNEi4DkjOjM2LwtIEaZECc0RaRNyjpgJVdAMAS281yCHQCRgnCGYI8Y1aiAnKgvK8N3d6vqdVPUOkFrPfDr3yWZIF1UTSrEOftAWYI4pMAPMHnAxdcMwT4uglcBrq120EKZxsxFFlb2P1qew8EnnaHt9mcJkhvNp7iLGINjIxQypZqxmtPYRYojn2fApbW+vkGitBjgbgauX49dxNGPf22XKMZplUiXOKYRYpKgwJAChVbNHaY5YMIRCMJQbQDMl1Pk8jQOC4WojuJoA6XlV1PwWhmK3Y3/6B/H8yArx7Xc3N4LDFPt2U6eMlm7G2LgQlPzusfvf3r/7XtGPp5dL1G7se9Qpo3s8X/oXrShbfQqSSgwIQaSuy7KGHxrw7Q/ftNV+OTedsX/95ZevXz+jEAuptg2+Xu1uth92uxLkZjzbyznkAApOBstzJNEjbU3wYtLeRpORkSVEaGvnI8Vp1WKCqJ3TPPQxTgRbCDjKiCJkzEsMK8ZrphKhFCGyzNXpMD8/jk8P/Wk8E8luYvQ63o+9yBASwURDqlpAira7qigVQKi04unpkCIn7CwLjiCVVbgcDQa1s08552gUSj77hcIVSKBQBa4ooSSkwEF2KZ2G8eX1AiLBTK3ahkttXXd4YuWOcVKv1jilLAujuxISKjiJ0dY35e3tzfVdgwA4HU+QIsIJ4TQzzERrBx0sBUF7Z/UolYo5WRsXDnbBQY7BlN7G8QLirm0pwjm5eDkeu37AQGJEMMFlVfGSQgwySY3k3jiYDEYwZ8CExJZCKjGNshDffHdz9R6h6v04gtPT+eX5C2Pw7mPVbt+hDPsO+uRjjkWZCa0BwMuko8el2vZH8C9//XHqp7bgN1tRokJmdDwdAKDINrbzw6VLS08i9D5CUEbnrDGyiCHOMRDO3qMMoyPnwxEIsrlahRl1xwVj0XePT68P5+PJLiYH56xFMOWkorvYxQYXncVcMMGFs8wucAaRC+aCRilCgLtuvBzPktLVWklUxgWL1d6PDYTEmXNRv/zjVXu9+cTN6nQYQxB8xbRddu+o0fPiYtC729sPegEkNNP4o2CAVsCdpvPhdR4uZYXLUtbqBoYGBENlx8vw8dui2X68visuR/P2OB6HUzd1KMumOZUlfb+7er97/+c//odi/ZhiMfdimJ6Qdw4Cs5RKEohCTJDzknOf6Sm5XBYbTCXHZfRLjCcYNgS3OU4gT5wFkK9TOKU0Ukgy8aKIzZUjqoo6H776rl/GWY/ua2dOhNKS0hh8x3hBOW22BVCuXilaKSxI5lRrC4hHMkWzbLBXvp/c9PAEhs6ZeSEOccYrZapGOCFSzgaD1BCATAiurWoYzjAwDnyjbnAyMwiSXbBYmVxE7ehYAgB3NYXudtFarWbGE+dpdeXL63KzTwJe68NoXCcK0KyVLKmFwYWF8zyP2pkjFzAY6nKRU5IyweicN4c3aHWaBlvXD6SoVpsNiuVkD0hSmmoiR0wjZTnTURYSoLKpE8z06SshKKcUipaAyRdrhtRy8911u29BWQcIQxyV8h/fNzF6SqjPPuQ840luE9apGwMNUUhmmHPCfHl8/st/EtNjQBn69RcuVuskg4EIr6PL0S3ATXG5hDmFzKwFEfmYLBEkJ9KyFUoUYZf9fhycE8aZN6RDtZlS/uNl0tMAz0d3PkZrZQQeIgqRtQthFtg4ty0bT96TIhZb71AMA5cJJYJgK+lqGJbL8TVGC2FGMC9ggExGGUMP++G8mLG93u6vV6yeXN+eXjqBVqP9mTMmcAmLT+f+ydF7Tm6ZiDo8UFIv42z6FJdDCAsjHKO4K3c1v7P8Myho0ZQwWyErIvkyYBNYYhREURU1cNP1ptlut3/4w/r77z+0KwPjzeV1PJ+6NCYLqpgRgE/E74NjbRu4oDLQwqDFFHpMQjwZr6USQhZCAD2dIOSUrhFGITsuGUzJn2/4bt5dVyBS89VfDkMYJY6QAlaIb9vASGKn5npDTVtd9UVZMGUO3aWbzxIWcSKFqpxNcz+czx0CBLC7h/uuG+dlWHKEktaCIUFYwTFleLW9OVzicp5eD682/Viq23UL7r6zHK4liC28sfHzsJwj2uFWNGo1TP3z+LjerOt2vVkVGIcSwpDneTnfXq32n+4IJpen7ny6eABVVcq2hUU7nB4TyFVVnbsTjA5DSgnQy1lKkbLJCQKcvM1uDgyoMHlX+qG7VCq1ddtdurK1qmy1XpgaXABGe0i1CaSQlawoxBPnrGygspwJkZms9wWrS7PQSc/DMHJEymZr9DIsZnzqrPcZMZignjJwuKy/it0ahvrhb+pf/8/T82+v2A9KIOvAOBijoZLvYyBzPzBUnfpZB0U477p+QRTwCLND0CEQeRlV1XgWGcyHy3C4vyiF3w7D9XvWtMY6HAItKzRO1gUTtYwpMqY8e6MMh5xPJ4EAWddFsX8iwkoGqqrIOcLEQET6bYouFqS21iRNYSAYUDiAwY+L6T1+pewdIdDPsjvreZoTMySfQZA5MLGeeantMCQAEcYgEG+im+zS2eWgEaAE4HL9VraWKZM4UpsKrSVFKbpwenl2I4GZKKC5FT/cfhDfXu9ux/V6/e2f6/Zmj0A2r0E/2ss4QV1HZCOIySCiuqZSRdFQprQJKQ8g8f4y9eR5vSGlAgLVBDpGvUMKAphjhljDSN0ErThWWPppthN5uZ+CA8kxDHRTxqIiW7siq1uYyFSIKgLqfFi6NA08RtgdYfQQIz1PWk9m6Hsl5TN+QzhByGrO9Dg3gl2tmJQi5EvO6tLr3x59f+ljjEiWJsE33VFi900VTprrqVJlc/1RqGazm0X1mpCGgAgxgEydCSihjCqYhKRtLd6zKM9vz+enoxk1RbRSpbfZL34edM5BEFqy7D2lVCDEaIVVwUTJ3BymQceDdwnCTKMBw1dT1GQppmgKxVZSjN0x+yB3ZY4GeZ8phxFdMhwxayHBkCJa1NXVNqbs0IjLmImd/dkvmAIUwqXrGUa0UNuQJ7toTmiwXEKyuZGgFZmQp5/mn/5rfv4ZxDhDMCKsvKv64TIvw/7KaEsRIj4CB2nmeDT5YlOEjBGAMUUwI5AQx+1+PcYmOzAa7aEE2enZMM4oWQhTiotSNZJ3GE1ZlUZ7kBGmWHJGMAm+gjADCnS6MImYYqLCjEqv6XB0WhsQYSMbDQjQgbOKZBFtzig15RoKjMLGTooXRc5Gqsq7MM9CbbZNfWVhlKrIAIGIrPaCCB+St8HMOscgC9kU6uYPaH/bQpYn76HxdGIuuWWen5/eiqwkUw3L391qwlXRVmJdKqXq6wpJGrU2GWVMY0bJOpNmiDJwFFSzbABh+3M3LBq4kLyDZslMGUmLTS1qehv8GKzGsIjOT+Nscwc8xBBcXxs5lAkMwO2WzsLMcpw3TUBrgAVYbEFkJebZuAyyYdZBADB2JIekFxeDCcHP81QUQtCEs/G5L1QBACAJ0kYlb4Zp9FFGOm6aq/uvz799hUYfNpuSgNvFzBAucWpO514/LzXuMOQRF0iO08i0IQjiui4RVCmS4GYEcwAG01CvpQcP3dfy+HKiCG6KKqWIkkue6GFiiVPE8YJaWPfYZED6eSlX0hNcbApRJgMAEACy5HXEEDBMYUjLOEsuq5IL4b8O9xmA2ohliggzShln5diPjKRE9KydaCBDpVkc4AFGFnUKmg6v94VUhdxCETCBMXZxAnECSNlVkzEhslAjqh9eln/+578+3k8gaZSmQkmCeIgUU0J4sv5H7a5SZjGG7U11PF68niMKAQSOKRMNBpEBz8qdjtVxQJd5sjn7QBEcyoJFk5O7FBVRhMVlr0vjEyWIO0eChRndEYxBggixlI2NA6P73XpDKEQYCdFY7UJMOcOcE6UZIxqdT+JM6pKvsCihKnEiUnu4uJFvzO5bKNp8eMSMreqrLeQGdisMsqQSMwzCzLGKbOEcli0utkVVqutdq95tcN1En6NFp5O1Z+OTJQg15XYlVykkIMDvbwYfQgQeC16XipAVCMRO+HKazmczzg4sxueFCiwIlZIinKcRjKP5/5P0Xz2WrUmCpmefFktt5SI8Io5IVdldzW4UCfCOf5u3BAYEZoienq7sqqyUR8QJ4eG+5VKfFrzIn2EGs+ctlUWnjDljavYHsRs2kjZuZTFqqNI7WNYwLX42wS23RrHHN5jLrVCScjHsCq6cIeDSI5ypxCFIej073TYZynSzCBAm4OfJexdjYpSSkim4XutG9NYZnxNDyac820IRma5z4w2eyPaBquhtCIT0qmkQRcfb+XqcBFPfbnYP/eZSXuK87Hbo4d3+w3KdXKVIEAQ+VxJzMXE1IaesGimVRhkvs8Mh+4VSlREvm43uHnrn0vU6jTfDEafbbr6tEUK3USjB7bQMBTU9JkRy3vSaEO1tMrgmIlDK3tvMyHW11nmqW7B2uV0qJUQrHCMYm8yS2/uGMGT9NJ+ny6t3LnS7JhrBGINF+pHlNZX7k+R3xuZ5LLheucJEMBBdZRjtrLkNf/lp+dOfX8p8VoxKrgTnQvKmJU9P77fDfY4fIgLZaHe9kGraBsbLqHjwxSndbmWPa+E5kf5wtvFlcaf1FHH0nhIyS3WoAaq3xS6y0X1D931rDS85URIDdSUrSLWCY8yWkmtqS6gEUUZISNG5sKx2tXVeV+eCYzinwHBiSjKlKe+ElCHZgq8Z4VJrZR3bw9AQqoUgPWVkniY/5ZRSLpFLudkKnKGRuttA8VqJLBVTHQc1pAprsLmQXDPBqGk6zpnSEgpZV7sG3yybZZ1XM+uO8MQURTHnZYqXL8vzp9v17LljlBdRQTapbQYCeFqqD/U2jeeXnQtX3fj9nu63B4bVNM7BcUb71/PL19PNuDBPIcYX0SimWsQl5kMJqN9pDFQQui7B+cgqI0RSzfec8NFc7FhTTBSXaCvBkiLIvpYY/YxvCDXtEA0VLXYmvx4vqynOB4KJ9hMh5M1v3hXIFWVnjY/GuuTwbJ12hp5Opw1UAqXR7/p+1Z2RCR9NXVbXaVoxXW0Iq0OAEUJ9PzSDOl9OqRacgTGFWSnUyU2LG0oQmKPb3T9lV/713/6Sl9SI9P13RIp2HqdNt/FjTu4WbEQJFAGuOabJFoYQdh68yajiFFXGjOKW5Pta/HwpBHW8edUqcVJzEDj29lJCFBiTwsrVnlTDUCUIZcBSiO95Q8x84RssyTutNOWledKEIpPR8cfy4cMvy7wMIiAUCN4gVO8fNu++Y3fDm2HY1lSndXsebbYRiAvOSJbEBlkDu528GwYMADGulAYfCq2hrpVUrmijWNtIbGWNZB09QUVJt91QXjdmNZDXlAwhGOFSsGW8lkxxGsbzc6Nqv2tiRSlF77OxeZrHmljOeZnnRsObe9m0SOnslodQRtRdKiE1kZL31eXsggt+WmIKQOphPP9r17e5Ju943w8Uy2iSbEFsNcZBKAa0Tt7lXCtGTSN8cLXG7WaotYZoL0soFU0+/P0/iDUxej/sx+VS5aevlVBEaDCpBIyzRGSgJBCclC6qHTAitRLrbl++vKxX0WzLZo+GTaukKpE6b87nlFP8Mv44LmvKJUaN6ap7LBqdMnVOQIpCSLPadYrTONUC283Amy11Jb5+uiVDVxfs4hiWFHOMCiGBCOxjlrIjQmLBNm23Qv7448+vLyeWtFYKQiJdOhw2apCYKaqHcS2QdArr21/dIW04LaUsmQx8EMRvxkXcfojy7ttffyeAkWxP2SzRxxpkZYUypHeOiUKW1d1EdR9RSQV9U5kqUZYQU6Bdc5eDPx/H8+utLt/Sx68RzP5xV4bOgRFhE6bw8vkEJgkmiWJeMOwzKbnfEEFU9BGnl6alMWWMzxUEUGrMWHJH6OZyvsRqdasJJZxk5+w4stlUjEPbMaRq02JWzjDltkS+UUHl4Z7hjUIMA0f5PPK1gQu5P8wN0iXUtJROzt+8f/vwQPsdAjJXzHosbF5ul2maV7ssiqJu0/Tb9u2331aQMRQo3I5LlSTll73uUU0UzL55UFiLQUHFGFOuvOg2Ifl1/SsNQ4WUIPoaKONQNlCiFoKkxT77wFMgPgmZcjaOmSWOVy8RnfGtoPXufSe3WrYN0rRr54qxcfcgc4Uwvv4ipianmk1kFRQjMXzZdA8lFwL/8N9FJZi20jmXGC61hoJoIYAXKFXrPgUf40oYSs7nQq9TTvnN8XX+y1/scvzfks8CKUI/cbqDvFf6u1w4SjWVuMZVMrzX5c1eDg+HgvV1Ca83OB+n6D1t/9+7w+Hd2zeb/teMNK/H05fLu4/zny/r1xq/qgQ4pu82t0Kap+7p4e1vuHq/mozKQmkzvy7ZFCGI1AwDup0Xer1M3iRzW+fXqVTXdhnTQrkUorPJHJ4UlpUIUkr9+hJ++OF6PrkSBScKFa6lothi4ATjpsXffLv92w9fzl8NYDTbz7q9o4iHiEHGh732J3RdMUJNdxf7uxYz+vXDOs5AaXNbLrKvQGtGBLB2vi4jJhjlFCQ+ciIKUDuj6cYR6PUU5+NEYl8r0A6aB656kRk1NoQV2xkuL6asrm+zkoIwDFiLRjcNin6a5jGsMdddTiRFBigjXAEmk0SwGZPEBakZESYJYqEkZx1DlGCcXel33e065pQennY5hEIqk5RqDoLUkv4xcskOydaPI4pFoEIQpM2mGzaNbhHjTKjWB+h20ni+XLBdM0AiWDBMHg93vVI1k9s6EgQUEYJQ03rGMBQp6j0uBRXMVRgOCghhSlLRILpWRGqthOCmaQUqIRQqOlRv3iROKqYwLVa5J9ljgZFxc8qckAahQtWt75u7h7eJFKY3qus4Y4iiPC+ZFEp5yrmUJKUUhBcXQvA1R920KeWSK8aQi48pxyU1jS6lwD8S8gURLJkU0YtlSlxsuXSVpHkNIfTPL+bHnz786e9/ru7KMSM5yI2R3WagGrN2vqXbbb1dRsjAZaGyDPdKtPI2u5hqStGZtcR4d3e36/rDZttqsqzoFsiYrzf38nr9hflKkOxZo9mou6YXgIxAXWh21F635/nVlJMUj1RixOi6ypfzB1ojCjZFl0i+07I20oR8DgEIIf3wuNn3lfpY22Wp52N4ff4Sgu0b2eqsZN0PLWtqTlkw0fcCM/eb3/YUmJnB3Xy/33PKgVxsWTddq/WCQ8YkD09rwXj1JWWMUbtOPpa47RViERPiLTof/XgSSlWAyjrbbDQRydhYSuGUIZQ5r5RF1Y1v/mmr3zahOEY1R+h68nECO+P1bNOa97tBCqgNQrWKSm2yQJHQMoWSASimIUYfHELFwDyvK6W0Kx1GKcdgzJxSLpC4YpwgwnmIiSuVEVyXUTRc9BL1FGgtyeWUKKWK8X4DD090PPZ15RjwZuD7A1YNVx0VjYw5qc1dZP7NsNvftce/vv74lx/cHN70O9UOt9uUU6GEBj8qwWtNM6XVYSm0xB2KQQoSvA3V393d864CqFxZiDmlQDBmDDd6u6weoSamiSAMmDVdU3FGPFLeCCljhWRiiJLh+vCo204h4ZVijcaCZw84p5Qxrgj7kBnlBDgkEn0qoaLKeq0QJ4AAAFLM1tlckvOmQuGMc85ns0opE6CSUnIoRyEkDdlWWJe1vDyTl1fxtx8+HccPHRso5yVDKDhUEjJxF+csG6/GGyMob4Tf3WnWklCLjdH64sxizEUIdNjcPd5t95udasRSsuc+4a5U4S3Qcuv6u11DW9wPeteKDUKOyYQkvp2tjVR3bxVfkfv+6xezuJ9SrtSZuoweJ9Zsb86meepku9/dyWa36j5QGu26rVHXMmLxue9iyWW7yRtdpIC+QbLbj+OUA1CM2lZ+92vEWTkfp+nlTd8Ap2GzV3rbJyIrzZgShHByjS2xAKmgYnIuJNlQ3QkqBILheoNxQsZFgMIYxRgo1bUwREBtcr8BscV8T5t3224Dh98eRCfHz3a5mGRR8aJkUgszHtUUOEuQaEZXVglnd1IetCZmDWucV78gMDWBt74WHGQuCAiRtYhpDN7Py3pljOiek0ZT1Q1bnUSezcyV2DxsEK2sF6ghBZdUKkEUZZydHzr22+/v8oWVtdQUGrXeP/Rd31aaz/6s2o5vizyIsmIuZXKkn83x5/PrFAKeQlwYLozSWrNQAkMgSeFcO7URNDFEUk61tIQp3Q9852+fszeJEqI6CbXmkhAgRnlILAMFhNbo83LZ33ftYZXdQAjt6pZ986q7TjHdNF0BN/sPDdujEkoEmxDCCCqXRBUo62w6JVMqfskEMCGIMZlwBagAqEDCmDSd3Oy2tVZrXAEQUiFMqgO7rpQgIfoU7TytzRZjxKbRfP4SrAXKRS01payFopwRRkIs0eYU+XidCcqbge825e7xUHBMURKM5/l0uf2idHr/9PCw7/e7LSGyYtB6kCJwbilZtAx7OPRs07Ou274+vO/unu7Zw1vS8koq03jDNadsva5fj6fLbc6xYBwpqgxVFmxkXaEyNptxe6e2O4mwJozVmrl+JUUl5O93W1naUlyjSysoQbxGYEgwxJfR5hzFXT9kK6VQbQpt30rSNbLbdGJAVKDFuetXnDz165H0TSX0drVmXfpNtz3IyhKh1Jv2chqD4zHblJ2UmBASPTOmVEG7+0R3ob0j+K4/4J3sK1a8lEpkDu7m5lh953wd12VxMVNcLmvth+wjV1lQs327ZYzngpYl+eijL8GvJaf9vqNCF4tixNknjHAFyjiN2bIWH942+7tNhDxebnf3++2hLTLLQWOFqyCAgSBCKgefss0kpYaRrW73jxKjYO3f20FXTCJmpMv6ntONByry6oEKrjqph5SWZYVSfE6B8yQlu9t3NbNgneRYUdZIQgHN0xETJBqGWe523UphGW0JeWiahvYpxpjhZnPMdbHeVxejx5i+a93dm7fDsMkMlRK5FAh0qZVjgTkhWA3NNwzuc2UYaLBnjJEUNLl4u95qLsgTjHBNiXACUADlHFiMEVCugDBmjHGEUIqxlMI5a9tuXdf1umIa261VXAFQTh+WcK4ZIcjBBgKcVL1ppDNW6UZJ0jSi6zoL6uvVpBQoTUrVYRO10N5XlHqUg1s8webuTjy8kdu2J0xSpjFNtPCB7x42p+SpRGpwbx6a3WHo79/b+98M8mnIZAOoYoyktNnlcVyOH8n5/AwQURli9DSFtNtuk/RI+K6/6waWajQGMCE4FgBgXEMWfvWoUkl7ANeI0CmBEbc5p1iDz9akCJnzSkgsgXM49HvmF2sXx+gBt6PqhdJovjIMutS/uJnOxkWDu05vNy1XkwmFALELn24xReTDSmHsGqVUx1kXU6IcqyEGMLRp2mGXIyItBlpRiLpj2z3c0nh6vc0TPl/H2djExWJnQRRYQlfA+LLbN5gqJrFudp8/r+fXlbPSdpLrmEjDU02JxQyp1lodU3S3uXv/20F0cg6jTU42arMbFrtcrqdf9d8TRhEhFQFCCDIAQoTw8XTDsXSaKxUICZtD0216yjnVjXpSaOARJjKJZDKYul7ycl6yyxEhl2IqEZfIlEghcTxAWlpdJZcl5xI4gBqn8/2GUoXH6egK92uoqRCCoGZAhXGOA/Vxva2zSaMxy247bO77zX5nVzW6EVBVWoaZpciGQ9/sWS1oug4OfcYING8xAiWks3OJYde36zQ3imBCYqwI5ZhCLCXlbUoIY0QZKyV5F3NJxqxt17R9A1Ctt02r+q2WQ60ul4yFUDE1nuRhS94+Dqt5Ta4n1UgKj3fdmwe07QdU8DTOz89HzjAliHHYbDRkjjKrgXo7Qyn3D5u3j12/UUoo6yMrEHxJfmXVqar24mH70D80ja60EazdvCf6rvBhijf/FSji4/SzvQyXo3XzxGgTfKjolaEN/a//9dvL5cXbFTHZdBjRsUZNMBGyIXpxti62+rW/zvn5PObwUQlgucT5rRCkV3RMF8YjwgynmkZ7/kDPn0ONjSOfS3FKcQ+iJRugGzd9oq1Rh1ztPx+/nLE1d48toVT2KBPXb7DW5Jc/+Xn+6v2cAhVaMcQkUzEvmNVYV+uEohxSAnqt2a8vHVfAmqYWwhnyYfY5WtvW2sdUjv6FsZonu23vNVUy5mVWOavKJlvAlrWoI8K999VNnHY1WIPzPQE/zdduv2z2w/3jUBPKbrcuZv+0Zw1c5ksO4vHNO4JEnE2ykiuBaEXgKyG5iJ48hnJW3S+4L7qTbf9WNy2hFNEMlgGlBMmytn60Lz99Pf5oP37+UkuthK/LRCm6e9QRvLGBbW73TwKn31qL1nW+LkfrHGFyzfWean8N0wWZMSUbMc2B1Ir46NIU919v88n83U3HTa+/e9jJ3bcXr6bP1xpECk7wkbCb1ryUMH2VOdPLKSJcVKNCFmu51FJKLYpJSECBqqZJMYVSgi1C9hjJBJBxSWW1xgopCOcJ8tO3bzHPkJNdDEi/exRMNG5WzoiKLOLHUuVw0LyJWvNCxMtLQ81yeLfdHlwjvy1RjOcumCAI55y0bX932Je8dTNwgjE6Mjbv9lnI/WH3RBDKqUApy3wjnLkA43orDtGlI3UAfMkqRQZL/pU7E53QmlczczOby7MBv3LKtrLmXFGumYrkAm2+mVa4yKJQYoAiItWYUQ0bKgPmPFl3vB5fX66X6/V0Obnz14fDRj1tPJslazJ2xctGN7vHK6n6/IO/HEdGBSLRTBphkinFyAkpwGa78BRQocy5hfWh62q/MzXthFZyh3C6txOM5tmHlTOGW4dxwJiR9A7DLaVLtl28DCJ1af1Usvz8y+X8ajZ39c3TfqNV9QhlwXmbqcnMLNnMayK4zvnZB7cbBp+t7vkju895rGXQmmCsWREl1WWds2EVsOrGkkuPYX/4rtnPNr+K/OtmGJ8eWAx38/xpnE7tQCm9N5OJa1K7poIvRRUr7Zyn44jPdbyeVRMpFX27bXVXYMrRBo8Y3grOCzJ2Cj//9cunPy+3z5+W2Wz4r5wNt9G0vTPLEyVg6wvr2WbTo4DX6XJbTsHNnKKYA4K2liYUfrn5GF5CXGusCaVY0HnOK6Dr7ZZQI7f/+vj+/dM397vt+5eXy+vzfDsas85KgJDm8fFgTI4OxVChNrq/QVVAXdOT5BdWOUQwxnDG5vOVC1azZ6QqIZkkhKHnF5MQyS3fvN+JAxBOMIgys/CyzGdbw7yOG6lqiqHACBkr9kRJvt0WVMVuk/7p14eNZtTtMamU1mR5stWtIXnPKZaUdZrtNhuOEULGpznVoDSiQlHCEdR5WjrZQZEpwbLEcbmcr0dzfOfczZorHm/9IO7vDz1j4HbNIqb80zxuX1/WtM6NMrjlGn5HRQHEpuvDunykp+djzJShFkcekwfCSrIEdTlxP4vjS/zlZ//TLy/jbcwVVIopxpwT6xFRuYBBYb897LvNyc719sok6jC3Kc7J7oVak/PGv67jnQg8W72uz4rTlEq32WEGhMVgecwg613Jw/U6zZcmx05wGkupJWPEYz6DoTFoqhiK5vz5tE5seo2//Ohd+KgHEr6P7b+8kbTbtdUvlbeu2VO4VTeTkrJDMyQcUmqV6ftNzmnYVlz6x8Ndxbv1VqZxdnYZz7FrOzLMmIVh3+wPT4ksBcX79w3RdZzM3/708vHjny/Xz2+/Lf/lv/2Xh8cHImW4WA/WjuH1h9OXX77SbA8D1Uq29EmoKDBO/mJnXCrCvApt04q+voSvf53+9h9fxq8OApbiLuZqoi2kIqZuy4kR6BvkwmGxA4OKWALqWOtKWRmqqtWICkp1wq5GjNKAw29Q9weModYGWK4kdAN6uPtvv//1P39z9/+cc359/fJ6XL9+PscYGM5SeGvQszjvugMCQiqSIgwPh93dPX6r/PmGAw+3wgQyq03BHZqd1IxRARUt83T8fJ7d+vBPb+WvB/2mKcRDkn4py2W5/XQMxg+yv8XE7Mp4Vtz7lc9Hfjz9sCyG0oY2t8OwHdSbMK/GmFohRmKtDXaqOTaydr3YDZJBKskK1SdEJBOIkZBSzcWtS4khYul8Vrq5Tsv1hOZbf1t/XuxpNdPQvaFVvc7Ms1MrKiJhPg7Pp3Gcl6FJhGZMC6beeuocmZY4L57+j/9PYYQpke/uL5RRTLGSiPOSwSffTNdluo05XyqsGLG+0YIRQKUdGtVyRFHGane3zUibxXiTKYYECJFmONwEa81al0uHyBcivxS0K1GbWbfdtUBwNiFfALmCRjJ3UM636dOyPPq4EA5AAma+32yU4qm0kBQVp9Nr+PLpiNZ/8cu52KXBOk12flnWV8MIkowI7fsiI+y+ntd5NiUhhETI4nhLFcjt5tf5tZF7rQRFDLGEO4IRudQF0zXmxZhmc9c+ffNEtKn1PuZi/XL+uP3xx/Hnz//uZ8Dozt3864ewb7QiXUzuw4dfzl9eYJF5CrSGzFGzaSjKrOj1nIyxMdoKVTRNAW38+OefPj7/OURbOU6AdxyryTxHbAqLi2W5flaCSn4QFFC2BXmuG95uEex8fRk2ze5p0+2x0ug7YuLzo19rcmYtMbiYUbmNdV0ylbrRY9NYTD/Or31c6jJ56yIAOJ/GZXWhKoYk7pRUkqO2FYKjUn22mHAVA7wczxihCll3HHHAkhHezdf1w4fr6Yfn/VO3eRTijlQGYOT6FcbjuD5fsgnb/sBJq9+Qkoqb3fEYP/18PH88G/NT06g3b+8PvdrvN/NcZxQqLlCa29XnnCu2iAWt+HZo24Z7v3JmEdqhSimBWgtFiHGca6o45ZRqKeN4G8fb7SrHa1rCJUdNqozZT7PPVQ3DdxXg9XQ8PYs1WKgREyvZrpObWE/TNFhLlvgcaqDIGSC1lmwMa9sOEQoo5LTEmpcbE5gOWvoQJSVQqSxl2OjtVgvRpFScRVyljObp2uBiuTDI7oBQhBCRR6iF8srZwbuLoEi2EQoG5HPOdq45oVBuQvO2a3STjs/r6/FlWmBeL5iJRrFGD0pua5WqpVTB8xH9/Pc8jx24D5ItFWx0Cljw6/j8k0DsuRta3TO9e9zsD5dLSOsUnC928LXxOeRcp3HZ9JpiEAzW1cS8YNb1W5oxZ6RPqcjBNjuGpSdCOR8zwPPPt18+vP744+fN8DDsCkACv5y+XON3ie/Eyyf/+W9xObuWRpxSp4dBt7SKmpy5cedK8DzmMybAcevO6nzxYcQtZ0zqda6+xFJLQTXVmgHWdS4JQaa35PAPPzy9faBNzbjb3KvNw1usDk0jCIbkyrysh0PLH96Ey/j5l5+f/9Zfx/WyLOflMpmv/nLbH+11oDuQOLed0KQWzrHzLkHyISHjEodxnYDUoVNdzypy6/yV4Sdn4nr2OGFMgGDUKW7nEXvO+7vq0PHjS17EcoLX/xj1ivsdjraGLymcR10YG2i/YwFNdN9I2t7+mv7wr/C3v7xkO725I5Uk3cc3b/8JM+bzVZeCKItWplOswIRMALndKCHblHJOWQjpvPMBhBYYAUFIUO5dpSCCq6Xy22V0lt/G8zitjBFBQXNGWVQN2+/apuXW+escl1oYrwIxjjmn2+jFvPrVrCHWAh5Iop0CwUlKxq0dQYJ4Ni/VrSmWEK3MrkfZb5v3pCXjuO67fL8flCqL8ZRTwArztIbreMat9hXNKXVAZoJyK79HdIpq4W304Z0xtX2bn74px5cf/fy75VxRZVivEj3w2tZ8cXNrbvvgo1/VnDneVaYeNvo3rDs6tL5eLn/5w2GaEuf6Ov/3nXqiqIHicPFQmZkzyLndsv1D1x6GZPD5uKb1YuYlXOktZiGYaghA2e+2TaOVJCkGgAwoEMIOdyoMFID2m7dAzDit95u42/nxFpe/vE/hp+BNiBfOivemJEyEzcVcrl9fPsXxmLJHuAVAIJjc79uUI873q18Irl0Lt8vAiOC4d2Gax1O1w5v7uM7zyycbykop95E7zziXCJvs712mVGb7dcork/fr3W/ffP/738hHQBwhivyJff0j/OWPfx0Ee7N9V3JzG7kJz4sfJ+tT2hPUOvs8P79bunu8SX2jXR8byWNVIRlGcM4sleIj+OBrVUBMsG+U2tSMaWDYJljLm81hNRNhKBkvGBVSrsf68mkMI5DI4sye/xLR1/ndN3Q7cDjehkqG3UOQc8Yz2lzbX//L/MH9+W+nP/1pWWbcqPJ6uWHVgWgIba+X82qXttMVoZpFzgYQVwoB4L7rITKzJIx4itXHudQs2w3jLMbobJlHK0Vj1xIz5KhQFs5eMGabHSAYlSR3w79IJRCuk/vDy2sNkQF+QzDuG7kRj5zCeLutS+vLa4YAtUU4UNoyE/OaNbZutGfGb434riS6ejhdvl7H2+JWBjuM1mFDt+221ztcUKxrsFUIHuZaKKGZhlnmcJjd3FSCIyGDjbXeFn8YGtb57Qb6oauIK8HPt6QUhuTUFnZvHZf5/DLMY0m+JzDd70QtfmBUsqMQfYj1y8v81x+/VkqEiNP1FQeOlcU4pEI4Ett2z4hO2IZYQTSwpQWvlMlBvyNhLm3S6dS0rRS9ZHjT9mHpONTiC8NtQbkmRzgd9ooJroSyLkAUdkEIdtFY3t3C2VUMvkwscO8Kxa1STY7y9ePixvnQERD0MNx7v/R3U61dLeDyS0quadsCgERuNmI0y+222mlmdeWk14edd/inDxiTllIPdnQmMow9XJyvFfcPO+Jh5kyyoVf3O7QniPMa8eLz7XS5vZylzja1Wrd5qjg9QJScZwqeJ6ngt4qfNVtxZEJnTvLdfkjnYFY0e4ML5VTQIoIP1k2hXBdWuxZKhvWZQ0br6+nrPFFB9J2obNtutYfz63FdZ7MfgurbirNQOeFrGfG83Nk5twNe058Wo2Wv2/6f6g1++NfTx3+ThPylaxKFzsRpdn60y5dfpuPrWXEcISjeNH3eNtWY0AvRbKjU+Xr1GfGc2fF4xBi6rsUVUVSMX1LEhYrbajPSi1sqQs6+NNKJjfzmd6jv/l85cV/Py8jHs691g8JKY9zoJBTteyGF976yBlNkyogQUhh7ggS9zPVym2+LKSWmtAxb+P4baw28vqbP578sS1gXxPAnrapQBHX9drctpbyeVq00RcJZZ1MmpNiwrsuqm5bLJAS63czqfDfctW13XS6tbu1Mr5dXSjBmsxZ7DLzZtELr5O35eHx9Md6vCBvBM6pFCCx3OvDy4Wv84YP58Evg8gQ+OGtaQhulGEVkcPeP27uDjrGeb2S9wX2I6Uv68vNlOZ4VSC55rXPGj0rLoZUE5WyCg1D8JKTw0YaytEMjNW7uUoaAk6yV5whhyXa9AWAGlWTECsdRMolDDT6cGvn768nnMgqBGqVwGLjwhCXd9hlCQaXtuzpj54p1KUQ6T/nzl1NMSUrFuUzZpRJUg999c2dtiKVgXABBrRXVTAgWElWsIypqK3fftnhbA6zxRsajff5zefnpCAGLPtYaCEa9fAjtD8FNyOkGiykRKrLIh2y7mFnX5w2WS7x7nQDhlFJmqpacUsk+onkJxrSwbsrcx1D82ZrFMNRNp6SHevjOsZ5Uyq4/Vnt55SVxHKR8DMnn6BHFgurksGDb8/EI04Ja3ihBVnx+mX/846fpLHA1mIJdbYhkWfDtxv7w9Y/GXA9b/rRRRLCUORdVqqbfUMqEtY4SCiJczy+4et0yRDIQ5RJQteENvuu26+LGS76aYlZfUb+5g2Ejh00rJbM2XL+k6TpbExP+IvjQ7e8Oh6G/c5u90nLnDJpuZjwnLIi1HmzF2dEvR3O8vq7lE0pvECqibywEs+TjSM/r1+DRagQuX2LCO9uG8ihbUmvBZxFjrjBR2JUaKVut8Riga4EgNt/WydT+rmn7PuETkzGkZNeNW3Df9QxbH03XCcZVXqpzKBoSbPBmrcVQgnJKTdOzTl+D/fA5fvmanr/GUn4aNGIERLNVLZaK/O6fv1FSex/8xS5jWaaw//KFUlhf505O6v5esQZidr7DhEOJMWTgvEYoAAWDtSHUABW47HRDL9Pl9RXX0CkxXM9fmIpSCSnQ470isJ0Wd7se7+53b95u77fv52nEzLVNZ1drV4rIdHffd0M7mdXHQIqQTWeMB0ShlPPrUjIZr7dTPL//5t3qroSQzea+33bn821aZs5krbXEkGtBgGopQFmzVe/+0/3hn+9BQzWF+z7bGi8lThVHvK7nln/r7IpJuts2isO85HmJ1AYpWkKw4G0lG9oESZC4acoPmMWQZxvPJfmW44K6EGuKTaoeaOrbZgo1QoZEIPL2wEj7sVA+X9Jf/1LS9UhKotESzkK0VMb9U2pE41IzjmldqcB9nckxjONlmqIKY9lqMS/Iew8oE7JjtDm/iunyKaeFi/43UprlGiY8bLiUMqOxFtW0d8yj8/oz5ZFWXmss1RO6QZw2XVsElVLNxee1VkHNbI0lXPk8z6FA05pxvFxeVSoB08qa28Obu2+/fbp/6jePCnNcgsgLUUNgIgCW5+MV0kQVpePqnZcV/6pWyyhpukaqYV7MZby5iCpQIBgqqbXGGJoWx7SmCLp3wZeYJFEnwoDyu+29A8je15cv51a3+4NoDli0rpKVa3U+jeZap4v9GC5PD227YxWl8WZTpJQqv7gSkDeh79DQdzHw3fZBKVxw7Ac5TCAFCx4ICU9vD988DvdvhsPd5u5dVyK1p9u4WGdBMGrG1Pbr3V7sdxuJtOTSjHg+Y2ddihEzFFxAIKBiY0JMlQgJiCrV50hv57Nbq2DIByc19DulW9ltUL/Xj9/I1docH9qm5ZRdXsYUPYE8j7eSoO02/dC2XRtL1m1DGLPOU4IRgaZTMcycYyHaebz03ZZgghFqu+abb58QVc4vu12HKsqplJAyoQRVyTDTaPvYbb/ZoYFDCbwRyCFSCYSMC0OFOZei81AL4hPUphm63UMdzy76K8E7PkxSQyhy9tcCErOu6Rp0xN7FikLNMREMNVKKdUP1hhAZQCDUREFJtKTtKhpyafW66D/+cP73H67p9hHn2FMEeMU4Pz01223PBV9uJVWRijTjOo23nOzDg27ef/f0sDWs//J5s+BZt7Jpv+36dja3UjJCmOH29HnhBCuCu4aWknMJQqJSsvM5pcqoZrUIiaXgUuNISmExYfJ6Mz9/uV1fw3xzLkQbp4KtkDLYDMVALpJRm142O3H47vFXv3u6f3+gsk0JT8f5+nUMhkRfx6MfT5NdPUGUokIBzZhkXAZOfNOQ+zut1Y6SHNJY0wYBIsxzuJe8EJJuZ7MeTNfzEHbGHVlzk/J3QohMpvHCj8d5dfOGl2+/3+PGRBpVy03cTxP8+PfX5fq5+phTInG7f3pLRZznhIqswLw1qFaKc9dgrREoLjmXmC0udbLcbYl/23qL37xhv/3du7vHLBrd9o3LklFGRDTWxbwKgdaFITFSVnNW3VZQRsOoVjNFmzFgRhkSFCMRSy4lYZqpzvdvd80WooPkKGPQdB7hIru6f9NTpaNlwgYd5R1REssc4fq1hnhCqHCiGAGu+d2hzQWlSABGpdte9zrl4/HEOdcSzWtY5xNkvNu3Qsjkw8Njv90Pqk2xzL/7Tw+UAZTobUwOQFBKgdPEhWn7wjoGGKdQasWUACUZsuOU+ooyyAKeUCyHJnGqGr3f73Tvrqu1S+ZS2Rjz/FpmrVuJScQsGXcEFDAmCHFGMOPQ9XS/h168hSCtK85MUBmjTaLPCdBq1U8/o//5h/OPn3+yp793kt23nOs9xRmY2u7ainPGZLJhMn5yS7HBu2XbwNuDvbvfmMtGqV+dry+Yx7bflFrCS4wyNFIppnBoqRAVHALJKK4gMHNQA8ISQeOM74awHbTWQmlIebVxYfK765ROZ3R6gek6Mgpcz5KTYRhyiLgiJVuRZM/F4VG//+6/3j32mJHzM/7y1+fT8/FyuiVfEeAcanIBI6QkBcBUa59htvlZpN1+aLcDy54knymLrO5rjYwFRbXWWBCQtPFrFUxnctS9luppe6fWZf3p7/H19fV4PELV3a9wd2DkjpsFFmOen8UvH6affwqC+1YFQuJiiPNtIaUWjmqZpzG4pWRXayhQUsKbYSMECcZRQI93gqAi2G63/f39PVUNpu3R5/By/UrEe43Bh5yBM8m5Yimql5dfEIld+1v2bggufvla4lw54qXUECpnvABKNWAOhFSmw+6BJbLcXuHu8EApMv6iNOvvOVUUUE1QMReUkFS995OZ/bq0d4eeYiihIBQZx91AgtcVoNI1pbKaWUhBGR623fl4vI5fN7u+REgepRR3+63q3dAzjE1Ofru9+9WvHwSj3sdgDeSWEsDE7e/bx28fpdbgUUkEELFXu0xjiIFxwoWQctdtRbdph7dv2YOnWgLuKor98VzwF0z7kEJJt4ol5aSiZP1tMWehKspcMLppxG6H7h/6zZ61CgPKPjheNEacYGVI6Lr95YT+4w/hx789T+vnuL42fMhZcnWnJLt/2qvHe3O042yvN3y+jrdlHCRjhBIM1n0B7qUW//m/vLfu7jp/SRWmaWm6VEu523VaK5SGzX4gdKGUIIySq0IDphUgCa4lGVRzQoCgQK0xV19qUY1wthhLjUnX6yRF3Qw3LvZtw+SWdXI73cwc0/D4sLvTvfzGr24+Lz/9Ff/whw92vNbsoBJGmZQM4eSDT7Uw1lMt3q3zRRV0aPK7w15TgvChofNWqZ5P3nrGeTf8qOiTKv9NxhvLodSxdrXpO9o0l0n+6YdffvjjhxSM5MTaz3/7aaNb//T7q3N0u3swi5vGyZq575RoCNTo7O56dspHku9rztfLKEXJvD30nCTbKN13g3UY6WVzEN2W6Tv2LWwQJhgJY0IZ95wBDlbSCfn99cuCScCi2GKWxZTUKCnePPrknl++vriVc4VD9KOJZq0p1RIQa780Hb1//P13//WhqBzqA++uQ8ett4I9tsPA1BQC4ZoT/bWYhlIx3dDlSKC0mAbFec25QsYId32bU2Z8jikiwJQEJArUuBn2UIn3DKCpoLkkWkPJaRgYuLJ8WQsiDq72alLZ7h7V4c1jFS8lq5QrQhRnL3SzfCzoNWMps0+XD/Xv/2s6/pK4C9FZSpHt4uF7yb+L9E0LmLrLanihW73Bv1rDpRbcP9237wjlWYyPhHgldPZXRRTHqJGgu/LwtGVqz4eSU7bjVcHeJVP7qXl8D2z49PP69ePf4nzuKlJ3d5IOpH67Q6f3b969fXyaT93PH6bLJdxOPrkibA/Ybg57X8L1z83Ci2qOCZ7bvm81izUxyhkRj4f/KriAgu4VUzJjwhErSinjHS3768tcvBciAxSqRWY1CFQjI+KNkHK8xuvtcrt9BYzalkIJOTKu4O13GzfX4HMl9eGdVu1WcXX8+mwT/vTl9edfTrfTiWHUy1vD3vbtPtIyenCLCeHEpkLfPQiBRIlindaaEcaWlNJKuWvumDpHzzjqN/02RcxRwUqb7JmI+zePw+bw9bX+7//bv/71b3/L5vrN05Ng3N+khfUvf/1fpNlu7nqlMCEsx6KE5jwM3QEjdLaLWfH+bh/tlFMDVWidb+czYbXvttsdM+6saCvbmupYEGp74r330bgYF29RJpSqtu0kJ8upJJcgVUoIQLHOlIwZJeuMi19fnu00NoDQ8XSbZ1TJaNYRZTKUBam2e/BquMOkxmL6g3R2QRy6RhFar+dzTkRa2e0wVzz5UqPDZZhuNuVVSx6jEQwr3kuhCQiMS6ymlIAI5ZwA4FJIjAUIkUqF6BFiTds0euAUH0OogIqfgiFm9Hi4Pn5zp79vqjiAR1BZuep6M3/9t7+PtyzUrhZs1/Llw/z548tyjVq4WtcXd5z/MKyjebPcd9eeUJojdkttNAZKUMBYyM0j1/3bFHmloBu+2/Uc206oWqLWcH/Y7HYHKWRYB7c6b7qcPJFVdFnr1gc63WypF4RmimojDoIJDDPl4fFxFxz54aeXdU3n81zSVCHqHnSrMZXrItZLGPZiWa90n7fDAAjt+zfe+p25byl1Zl2na8UxFJBSllKNydaiksy62JIjRlFKxqjDmAfrgdcYigZ+PtvbcTo9nxsuh5ZjQIctevfmPnu/jHPyWXDZNE2tOXp3vUzn0f/886fbnFsFraKD+rYVd1K0BiYTOMqAADKe6PaOb/ffHp8TQdn7EBap2dqK/PaOt93bZfYlCK0TAooKxVrwoaBm6ndba/B//99/+Ouff8yp3u87iHGe1n33RNXKRGbksNsOGINdPVTQWnMRCVLBZUwMAubtTMpbQp1QCy07DIBI3RwsI0OshMtVcO5SOJ8tIpwyQRVvG2r9ZP0owqaRfJmcmSoqiAHGmOQCDDPj0rq4169m0+8Q6pcRv67n0/WcgpD9FQvfquHh/Te7ne62xFuUELbETq842vrm4amG/vnT8vw84soBLd/9um20jLGC3wmRMbXLxQhEGzVwWXVXx+nDfr+3nseEBHsq+Qa4pJQp47kWYy1m1C6u7zrO+ThNCOpp9oLRtqYNfgg5MV37g6gqFSkJc2V24xd0/mH59//xNYbaNtFaf74uX75cY4wI40hKSHa9TumSb8/+88fL7qnHBBPGNO+HYSCcEoqHfdffcUbvokcFFoZDIzBrh0FhIXTf4/3ugCrxId0uH7WSQiZrCsW5lYW3OpwLR6hR5m6HwSuOZKvk3b3+51//CkBcTsv1ZJZ1XdcVI8sZajuNMQ+hhIQ58hWRbkvvf7fdHKgHGO67dG3ClIXPySyaIMqgQsq1pkSWZT1fZgwLwaQRpORICWghfCg5RFLEbCzGIjqUQ2AY4xxJDb/+1dP7d0Tx9nS8ICi7TVNyBgiMKSlVDpNfI0Ni18ldb7VCCj+URK31gZoaGYpEchAy0tsiGq2IPt89dcts7LIR3cjYut04jh6Bu0IYF7OU2q04y9ofut13A+fD//H//eMf//WTlpRgQWA2s9e83W414tBtJAZaEr+drbMTY7XWTFFjjZvGuWmKFF1wpO+ct5Sglgu22fGcfaMHZxclBdRY3F0Jm0BG1uR+K4HReYxmIawccKbBpmAuyxWqK7jQXIkzbl2Cs3Uxk3WFEeVMtK7G7ITCGS/GL9tt8833+8PmTmsRU5nnzKTCWkmFtOIYofPL/PL5pfiCAYTgy2Ux40s/7DCgkvLQdSUarcv9nYbqc8qN3npPU65a61ydtYsEXgpOJZppDS7UDJ3qJWuX0V4uU8nxNhWtpOqwboSoHKBefzF8LOqxVUSks7Gn5etfbulMEfUeRmvM9XI2fgYEBXJyvFQE6D6EkJNATqUjLbV0vawdK4K44A1Ku3tFsb69oGm019Pn7OdOVMG2gq3DRvdb1jYtQogLrniDEV7nEdFUIMdIaqq4lrf3et63LYo0o1bJ3b57fNJ3/bvz5Ra9q+Ccu9YaKapa6O1mP7sUYuKa7neU8Pj0/dPhu4d1HH2I2UWCMSc1umBmWwNWGkpFwXsEGiPcaB2DxaQgkhstG60RrgjXWkMIHqPSapqx2A583DBSoFP5sFWHgUWnaG2ZSE0r21aXAoR0jCnOVwxx6A7GZcixBliLH6fV+cjaGWWqWNUt23UNXe0aQxBYz+5kfXI+e+mkgJqBVtdIhEAR0QDOwM5cat0IJdVPfxn/8H/+MI1hv50JojlCigzLHuiUc9Zy37TscrKn05Xxcv8wTLcVFWn9Uamy329ave/7DrETSj1v5Hg9CQGbzYajBlXDOEJACTFKFVK5D9mtlCosBRYyK5RoYuvFjS9ovkxQEECLMM/Ombnebss4jS46RgAjolr5iN+8nl8X85mTdtBvOCk1VCqVX73WSTU1S6wIpphMx1drQMsEFNVU9jtF21BR4jKYZSyFUEqbFjiPsUwcMUIapbvxZpgEylEMN6iRIgGl5pKjjwyxWICAevl8ncdrKYUTGhc8maiZ0NuVcW68+Ph/nGxc92/5r7/7btP1pX6M42tPMoiKtfaxJugSzphUzCwjLIaCo1jQ2DCJKaGVlVxoJDTjaONcVktC8uCmdPycPn78eDr+X11VmoiW9Y8PQrVUb0i7GwqqREGY3TKvqFauMGHKjBjjG6p408aHftNj3nJxuCe64VKjeTr74KMHXBslcqPj0Fup6OM7LudmWmLMHW0doZyzO/PcvHxZFlfHX/6+2wyNYDkhAIywnq4XrVtv3Wbbc9IqyYypgEr0a9tvlNLz6BgjWlNXZiAFiOt68f7bTQFDElYkcEa8DWYRlPSAbSql3W1TiCXLEArljVQJ4WTcbBaWCCQ8ro6nCCSRRoRGoKFX++E9/fT3SYq834eYtrrp202RkiopzBSBOqgoJVLDGxuOiVzf7Hqu6PWr+bf//mrGTCFJlgkBRQ4KS8mbil/3+8Pdw6bfii+fw+UcIowE63kZw9IVeP3+V3ebTd8PCqGcw6Ab9vOPP0ry2DRoMyjvrp14SIlwdRKShxCltEOHuF5vayqeS9rLsp9ul9tpRiHiikJIzq0ZyHgzt4v1ESjVy3z7/PXL27dPTIeydiSplmst71qx1frWaNn2uiJgIjBpMrEEbbzJr8/XsjabZlt8qZTkhIsF1nDjEmYi2ufgsxD9pr0LLhLJdM+tHan0gJmxDiEhWSEIuZQxYEEFJdU6c12u87RABu89QiFFEaInItS9a8XmNtJ//9fndb1t9mb6xf7nf/6nQuLbR3XBdgyuwp7iRqrWX2pyhgnLVKGYcM4qLkuab+tVc84oscFkXzmKLiyOuMvx9vUYXz6l//jjn5flb795fPPu4ZuWKYJdDK5WwbksqBq34vyQ3KyEYvqFy+Z0TOeXo5K8BD/ofhBtJ3k7jKWG5KGg6JP3rmV1oyhRjb97xJjkrs+F9BnY+cKPZ6ek+PxznsZ5Gm2Ii/N//fbbxzdvGsU2hFbA3I6xUbiUiBDKJa3rXJDvWmUpw5yHjGOmFTImuNbio1nsbXffP77tuUBxycWvSooUx3X2NQuhMUY02uRCjBHG0aRIORM5IcFYDDJnqMQyQRljgleMHMFZECpIR3tdMCbRthrIdsPv72K36cxaatqPs5zmZ8AfwugJ9d98e9cOwY7XTz9Wemm/a++d/FlIRShF8bFIk+vcqP3bXzdvf8vOz2icPWP9OtoYFmtMw2nf74dmEKQASRlBSTiEeHd3n6PvOh1CwFwAX1DJwFVkECpi5ADE3aZpmeRmhw97ff2pQgqSwnJjJbLkfIzR53S5TaEAFiza5P0m37LSZBhuq68VQS//SXVfD3fju+94P9AKJiHJG1oRoYBwapbzTbMdHiDnBRiu4KgWWLZUAeGVYQ7l7e06UqFQTQQnqtXsLaYMCEouooooRGCsVgEZblPJmWNAmIXT7WU2Sy2sZISRbnxscRLpJeJ/NrB9PvKPr7d5fT3Vsaf4WaKHb991DX12ryUyTBmEQmpGZCllWuMzrV3D+wYfIuxooSiqxZWCs8GR+FlyAS7Uhi89nRWbl8vldNP4n3I4reuCGXgShMas8NX+I9CtabwpXGpItah1zsnHEG2xsZRMleJMYFRthJJQsnB2JIbBORXykRLfaKfKnRRNmpTQ4fGtYMPNHu+vl+U/Pv9pdXUcTxitQ3sdT6Xj2+5hkJT4kIbunbW24nK5BkpJSj0SMULAjKw2YSCYGwSolpxDzKVo3kIpkELX4JAK5X0w1syIxsApKr4uPvv5wqW2fvEheudTCMl7xVDlJQRfA2OwYFxZQoRgikVJrQ+eKkQwEIlUt2XdlonW+DICl4DZL79YABViOx+taty775iGX//xrz++fM6cje/ekFwOjMqUklkBk0EIsbsft1vKaDz+wsKMcEHFSsb80NKuPw36LSMKo8Q5jTXnUAAXKjDBtNRYIWFcAQpApZQABkAZ4VILiq5KxrVop/Pter5ByjHlGFOM2UUXY11WU7LljBUIWiQhi1Sk0Sj4yedXvZFPT5vt5vu2bXHqptsqNWweQWqJGM2VLyFkSIQRpdQ8TUpIxkUqkTBMOcOUcq01p5zy5Jw1VkiOcS0hLYtFBLVSl5RSSEx3NlQT8mICAIkBLhdzuThjYi2Fc4kgEgiK18Pbu6CH1eXreH29vPo4rTA+E3b/5vAonrA+ZHJM3mIHnewUnHqaXa0BKCOVscpZlpxThIFgn5BPecoZQcphEZAG2pn1SrSSwvddaBl+eFStQoNCAVkpBaoBI+vs0sodhAvHmFC8LvvbPMXkGR2sCTH5ze6k2yYaH50MpYzrMo3SuThdAfOgVDXOU3xxyQx0eHzz/jIuFemE8NfLy+eXD9bqFDwnVanZRxG8tjMK0QFZoW6dT7lkhJZ5noZh03JllxEDIiTWUjnHEUMEAMGGVnW7DkkWQ/DeI0CQ0TIZkgmC4q2JUBDDIbnTeDM+hpAqsBDKPK9QiQ/Zu4AqCMY4YyVjQAQKjQ7WPNNtqwCKEGX3hnUbadyai4qBnC5m9YHS7OISquwk0b04/kJuXzEHJcVPnAghhRQHjMmFGh/QZjPs93MO+PjRrHOy61oyMGq4SMPQUy77VkmJmQKEKyO0xFJzKrUgXAChppOxOBu8blog2HpLCOYcakI4M0LK9DqtsyWAK2IpIMYJpjgkR0rFtfRac80S9lI1/Z2SrSCMXG4Xtqlvnu5/80+PYX74+PPlpw818S8Pbxv9bhBCIUpqKphCrUVpLakIUeSSKcUloYpRqZVgnDOUGAhBGUoqmVLqnMs1M8kxwbGkUnKjBKbtbbytJhoXSoJpcpeLNWvxHtWaCakpGRBGtQ1tCajtx6/Hv/7014Iywnid0dTdYjFAHW443zYrvHZD8j7d7fK87EE8VvJ/I9RSWgTzlVNUIZe8hOxCWSuDXGtCCOXgV294A/X+0Pnv71Eyw0A3XT/otopd0zWUCUaLFrj6OictpBSC40CTi7EswWsfbNuL3RsnRIqekfir48syf/mcUlhmE5NGYMfpcsi15rwTVA+SNXr9Mn79kj5/sM8v9mrm4DhkRJQWalayLZHbkQJmmNtQISWSIlnNV6VUyXMJMi5ZcI55pgRxylz1WLP7/RuucMUFamScEUKndQWLaqYlAQGeks+QCaEpZ+tCATpNy+oWjLhzKeWcSwjBQa4hCsZ4w0SKiYVYaS0kUSoz4/DmqVW7xofs136ZlPX+Oq4FnWN1TF368n6z47m464tZ54DAl2pwQ4ZmQwBDqbUa3cn7t5y1PAb5y6fj4mbMdNMOTJac8MPDlqC7fu+5yBWVgjLnEnIONiGMOGP/cAdSzYRQjDECihAIwRAKZkklEcguLCQ5QiAHl2uGWjNGwBgmmFHCUs5APG359tDf/+qgho4w5vP3FYGQjXfxj387/dv/+jEYieXHT0fiUPurX/u7+zvKCCccleTc6pItpaJ/fKpzijFghBilMSa7OoIwY6zmUCETSiAhxojQilRUc8k+WJvHm1tWY9eUczUmWuNzRJyqCp6QUsGzNj/9+q67QxPVL6/mdjsjVClliB5qPWISqQzdPUI/J1g260q996XGza5iwhAhBFHGQLBiMQkhVYt9KibFOQOpUVGSQ4zeM9LfDbLfvVOMrdNnSWLTbhinersllAFoweOcbXKAyljTEj01i5puF59HJlzTyoc3bb9psNAK9XBjnz7wGFpn/0YIYBydHYM3ZqWNbBjmupNusd7VZSQ+VB9qLoTQSjnRmlKktRgUG7RoCBOpBFdpzmhdMqUFQ8rJzrcIlSJKKxQgKVcmNCu0csUYp8HZ4pCdyu1kx7MlmUQbSQVUVMkilhBtTjm5jAqCmFhJJBUSXMaY57wgCFQwgjJgn1FNUBHgijDCQN//7pFyXCHezuV6WUrRzqPruFQUlKDzEghFca014WVZbss1I5/zxMs2RzHdAleLtTai/Pi27x+iLZoRvH0QumnXKVtjtab9dugHhTFpusH6FTBCmBJCfC0pZ4IwYzTlHGLEDFPCzOozFCZKhZxTQiAEVQgWxodifK1XBIwzVTGY1VFCCFatpMaaAG7/0P76P33T/v4Ra4EkjmsNJ/j8y+sf//Xyb//zr68vJynQDsvjz8v/vC5wa+jvdNcJqfl+M7y+XN0aEKDtbtCNqDWHaFPINhvvo+Rt8KGkyBjDGJeSCcGMc8Jo8dF5xzDxvpRCYojO2WU2zgBBSAkmhKg1Y5IQSZs3/cPb3XafXl/Q5byWkhjGpdS+fdxu/P39Zui5uxyxnAntxzMfp2mJ61o+c467Xt3pZrcZeiVzv//46evz7Tg5nwFnjK0ZCeENh06LRrBGcE5F27f9cCCxdN2OYo54BAwUNxk9h2KkuI83bU1OBY6Xm/OoIF3x1FPEuMvrHrzMmYyv8/XyxdlQY+aYx4oEVYpLVmoNyBmT8y3auW1512CjfddWcAoRLxjZD2RoB4IJ57gbfC4RRWwNDq6EgClLMZUKIVcqeU+opCoXHIlSus82ztW7nGRy1Rl0fXXXk5uvkdb4j+ZfShUTsVq3OoMJBgzOh1IqxSzmQhBmmNXMc60MCGUEEyCkUIwwVEQIIYJmahjXKTI3yhoqoEzQTGDFDCR/oKhtG+ZZ3zcA6YtLV6Zz8R7qEyBaUEg1uGi63eHwZoOFR7FBbB32JYtv9vs8jre2YY9vtbHXgl5DerhcYtNR1fJUcgwhhoiZyDmF4IQShPGYEGACGQGquXiKiSAiuOqTDSu7jSunoSRIOVGSlOY5QYmIEZ5SEqJ7fDcM3x4Kw+46p1I/fDm9/vXy818/ffg7d+t86FtGR5IQL226la9/upAR/frX36H3njeyxOptdNb1rSadSKnElFjFOWZUIaVQaqaUlOineRSaDftdrrWWyoUKPlkXnDGSs6R1inlZFgS1bdpaqmA4VZpr1g3/ze+/3T0Muo3igjZtv+0GAmVd5qHh796/++a777nS0Pj9Iz0ep+M6n8abqyVkVEq4jRkGtlF8exBld3e5roBeEcaE4Jpc2xCMU4X8D6uo4QqjJEQdhg4iJoTllFxchWgJysfTa8o1o7BAtjkuNhUvvE2Y8v0j2mz6ENx0zc7e5pt11kTvovcD740JDPGu35ScoKQYTss8RUPR0LQd7beAhdg+vPFpE+KtJH8Y5GPfoFIAe8BzCK4i8N4HHwngHEvFICSSvCFYIoYxB+sNR7miIgWlmASX7ZzcQuxYIYiwriasUnIgRUgOmEc7u7hwzCBjgFJLCcmiwiSnuHgm25RELAEDcMK4wLhASbkUXEFQKT3BkBIxJocwMz73HLd3jLK9TSX3tWDz9o2pCft59+3TmfFunrvbaRCayGYl1CAhuBgqGox3l7i0fuMmzvlEBN3sJBC4TnGaCmM9AldzhqgAvLFjjb3Eaj/sY30trHBdV5troTFkXAvkGH1ObqjJ55RjRqu/ROIwvZOqdFzVcnPrcDmb7KbkN5Cw2jTdNvv0yf7lO2/Kp4+fXn75cr0wcxWplJwCI7xk/smZArAVZm8LI7IiV8nu9bi8foXT14Vg2N+vGuHCCsMtyiQFT6otHgggIIXwSiWXikJJGOHs4TwuMRYEDaWT0hQoCpVt8bDeMi08hSQYKoQzIZ6+P7z/52+YImad96r8l28bcfsuVy+kGLbzP/32X5rmfbxA1LX75s7/x2mC/zEVE/zjFNZSl7b7+b78P2ZzTVG16DdPu4fz9pWsQAjpcyWMB2/6bgt6wQorTBF+bQ8UEAEtcqklF/A9l320a3V7DrAur8gUVbG5LWsyvvhOCE57MyGUlR6y8Wa+jBQeaakS++DOMaXM1iKAUxkMFkwLToJVWCnRqP/8f7+z1J7Pt+n2ReW7ZANNWFMDFXPezWvLWJ/SbK1LOeYaSxAAsD08SM0QjgUiJg1jIqYxLEx3XXTI3JwzcT3luuJwyziRHGPlSA8MMb6syfsiWVU85dR5XCrOCK+4Ek4xIxMgiYCFlCjClGBFtJASAHGMJEc0TQ8FkXVcbDoSWjHGUOV2s5Oyn/wYUlxtQCAJITak4SAf3jx9/XKbFk8192VteD3sd7lSlybEU4z2clvA5aIFCYQxukbLBe+0iDFDha6VGFWzmJAiyZURiihDIDCumIlsI2eAMXbLtayHHAlJMtewLHPhC1bkYT9gzCkCShCFx2vKDFtcH2ouMXjn7Hrbz1PyAU6vn//2lz+XW6u6jWI855eMl1BjSZbigTDlVrvKWrEEgb++hL/9+PX4+cZw3Gy17GjTi2meYs60ihgdY7RiDwikVEK1gHAuQKicxillvywTINR2HaGUMVYxIIyUJA3POBGzLJKj/rDrt+32sZMSWTczVro+PDxiCffBpe1GbXrEULd8nYMr5G1p1XB3oD9+CLGOPhHnTpT6msq8XlanTESDZqp03/3mdwV/Mou14w6VJiQrtVPN/rC/E/0k+D1gOs9L17V2tTEmRiUnolQQWI+3aboa2mx9SJ6wuJqaI6qkppRqBSHsZJfbQgG0RCU4Tu1lis57roKWTkviIDEmmSAgdFJ2+6Ynh7UvPUJC0VZBXW4jSYn6DUZYSeWMoYSZmdNSIFROmA/2sD8IyqN3fd/+QyHlWFhvcBW+5GidW2JO1btoTa1QYo4VMSDSORYdrBalyBnVgAmlXcyRcyg1Bo8zcPoPurzRjLWMElQBA6OYaaVLzD4udLmkGEzJnnMMFaWEaqFNYqfLJTPvgy+VOUPt6nBS19t8eMiV5USSLbUCQilXF0q5kSA2Q6NKR0K4XF9Qjd2293ZFBLTkbavHaaGENLqJMeWIS8QEU0TxYhckC9dNwYAJopTEkCnxHOlcZMWhoqwYgU7IrTg8HkA0COR6mtczm+2zMZajVCupJRIkBVNrWE7P87/9X3/zxm1Zq2mqusiZ56BTRBiAUUt51rT86tffbw+Pv3xF/+e//+HLl9dO4+++6Q4P3TA0MQVCkeIERYyxYEVw6VLyuYb1H1ellWISY8q1Zq5pSqEio5q+lioQVk2fYp5bSwpdJ6C47h60bgVmbh29Da5rGOfrmyd23/fnz4kgyMaOlzMCQlHLKRnet4+Huts8Xs7eecRIJ1hLK/Wuudzwh+fKvvsqW/XtZt/KzTIu49EvkwfEK2JMo/39Ru9bN8cUfAEoKUMFVIFhAgXc6s0azBoIVkq1zk9AqBBY8EYIKMkJxmuu07xmX7VoNIeqampThKwS51QLJCBVKQA1ob1r2yct3rZsEIWZemp5LQl0dC8YgtK41o4glEJMeZpPt+WGJWkEZsEbwejQtiVaTIBRSjkSQqScci0YGKQabI2ullSDCcEnjGmqJVU8L/E8m1x9TChMWamAEGYk+OAIpZRipmSjO1xijo6R2AihJSeY5FhzrqjGmEzKK5UqEpqDS+Ck4AoTEp2NIRVIiKiu301Lfn2dx6vBsIpw0sMNMRBd66MHJEgm82ndbJtus9ND44tMy4kQhBASjCspEMdcilIKxggQMs7a1focSkVcVqYg5rXbCKb0sixct9VHbwupDFgtJSSYRFe3mz4KEUXIfaKbCgQo6GSUi8/TvGg+UjiItr1/eC9bf3w+zaOKK9Z0J/nacM4J7JptmH1YHCUTbaZd1/3+u8O//P6fnYU//7t9/WySRyBMyXWz4UppInBKKNcsBKcEUFRCYRqRWaOxIabCKMGlaN2m6ikTyzoVyKXkkmvFBeHCBL572BaXBYeaQoUcc5CE+dkRQlAgGIWuEYtNNerTZYxmNdNLoxpJ8aYHEs3dvv76twfEnfw8XU+s5kSKQrSaZD6fg/nD/+/p3f233z50w3/ZPj7ef7/Mly8pFWd109fNtvG33vqXnKOSKnhPCQWOSMUYaq0lpowJlVozeQZ8ZCxirvb7vlRHcJRCeJuCBYobQZqakhaUbBntAdWGpG0wUKrXGxBv7NN39+ppQ5S059l6gNPLMpl1Sgjs0LWC4ogdquCDAVTH+VqqYIhRjlxMj49b3XEbDJesooQQBgDnPCaspFRyJkAYlrM1MaAQcq0ZSiaY5ArBgotrrpBjIWSBmhnJKWeMhRBRq67TPAdcqxCc1GJzzpwpDEhJ7oMBbGULtNvX8eppESyomiHGmNEUUZQd80ifb/FPfz6/vHwSonR9fAARC5ICqU65i68FmZiu43L3rlM9IyJLSY7WcSa4lLkUJmQlyPoACGFCQ4xQgXABa1RCcUGYzBQV3ifEK4lVkG4cb9Gz5LhfHWMN0zQlP96m0mHVMkQxMAeOVhRLFtv9bjmfJamKDH27e/jmIAa79SbeP770P6/TBQFgH1GsnexWLVKqgsv794ff/6df/epxY8b04w/P87JrhRQo9M26HehhK6PN1tdcOZWVc2mTdy7FYDCqmEilcVnNalchOI6IcWqdrUAoE/PqARBrOOLUOV9jakWTTVmt1UxIqmslAjPBRQ65IO+D//Tx+ukHdjkuFPuSllJQwDR+GiUvfDf85vePD+83bz+eXj9db+fb+DoBRBtNsvT0b6+3l2PyM5P0afukv9Eqv4/Tev40MyxCZmENuRSlNAKcU2CcYCiE1FxCJbnQInrJmFjDafUOUd7vWtnyZZkKFKkkJYhWble3uuLchZDCRVaUEMwo5ZEkYKx9g7e/e6u6wRvuXtD1DHZa0+kUglOa7bZ3PRtKKlTHGHPLlZ3pZgOlJoy5WUMn1eFpk0uiuMbqs4scRKmwLqZpNzHPMVnO73PkyzJ6h4Ory7JUlAlntVaKKgYAQAgQKjl5hxkrqcQSGa6cV8kQF00oVUqFITOKKSHOhFxyKYkw4C2j83Lmss1RSo588E0ntg87wrHJ5npefvjw/MPPJpdRQxWQ3n3zn3eHbcEW0wIkY0QAF8Qq5ZCTCWuyBpWcGZMIEe+L9SsSWCrBBCsljdOMEWmaDipILjHBQIPuGBI1Bxdzzi6djmM0vqyOYUdwaXeVdTT6aEOgGuOWQUjpeoGISgqEppgsuA0oVL3NLx/Mx8U475elktwMklS2TiWGLDQ6bJFQum/evPnm8N279zTy2/nZLgEju+2FM6yV/H7X961cbVmdb7o2R3ueb/gfFRYqS0m1YowIYzzloluFMeqGNl685FoKiSha1zWmyArBGFa/QoCUoFbmXTVrbChWQmNEo3cxo9Np/vDT+ccfwCxu31PBoRSEMKqOnz8teIHu/fDNu8f9/Te3t/nDD19+Kl/G21e7XmOCMGW/XCtipXmO/Ffftv/E5BsiJW19vOnoCsMjqkhQuZoZSvE55Jio5j54510oQesGkbrObYKqZMdpAJyF5lpj1Sq/0OTEdZ6zX6JdMC77vdg29wCIEMJ7l0kiDXWRf/n75fWlgKnzeL4df9oTOmz09m4Y1NZNwfuyu0e1gFKNW2w/0JxnobpU167f8pbfbrdYEtTCOIUCzvrgI8IWSKyoUFoCgHE+eJYSNiZWHFE0peRSufW4VAKhlFxQrSCzUkopQVkkgGvMmFNJqWCqlgK5ViCCUestIASEpFxoM/SAaXuvYZ6Or8v+8K77xjiXf/nRfD5+TjU2khFqOWOq9mwoWFWzlmVy3npMc9+LN48PyfZ5bYuxy/PXYktNJMaihy6mVHyGmnIoNTtNOCKkFtCSoewI6wtNSOBaWV07ZjbXT5O9nZxbOOpyfOYMCfmGCi65ggpgaZ1ZtixYIxu9vxvtyjBhed18SW4+X6cfv+wQwykv68fXS5KqebeLPW+YwrtMNj1pN2z/8NTsDSOXTz831iMhm18htIZoEOy67x7ebAuutUaKazDL4i6MPACgWF+jRxiQEBuESPTAGAcUGKe53oREtdQcgJQsCClg7elMCGmJJpkSTAHRaBYgCVPAtNaCSaKXZ/bysRy/uNUfKy1E7CTa0NTQSAiFYnKKsWw+9O9x/4iU6C8jBsXdGQNSJBUv7jPFP/9CQjnTMA7yp8N3A/agcGPZVHKhVCHCF+MQ4gjXnCuXOmaSC4oJA+aLiZSgafUVM5firg+leowobxBt6Gj1L+Py+TaWdBW2wTUJXBKam043DeW6mebVvVL/+bSs9nKZEM2fPv8iFcYt2T7uMWUZuzWMVPBpoZQSa03TlWWZpeQUh77l+zf7SqEK4Z3byI5WTBIqJT/u38wluJl0zVDK6+U61hpFM4SMEOtduMZypazU/JhqDtHXXFxilAiOSMpJyg5n0AIRHIKnjPicAyUSgOSQCIWSE6CCoEZXKcC9EDwVdz7FxccWvzDXnY7x+RdqDBFC3D2UkvcxOITzatw0udOruZwLwpHJ5eHhCWOEw2Cu0VrjzEpAYoa6De4PqCC8riksKSYqWd80BOEKPAmxBQDSc9Ao41w99qYcX6aXXy7RZUqk9anVrO01YZRQlHKoEL1Ly4QYYYxwZBB24nZdMd0EFI8X/+H5eHUf3+lGAPJWLGUx8fzYPYqWcEpzXWI8CNRX/AsK3/30pxHw15J2DG95u9wNd5cbfnjcDl2bfZpvlouNdTGXvgBFgIEMSE6lhpBWjDKgXGtFFbyzpRAAgRHJqUZbAUipLAVuQthuJKUyBZ9SwphhLNbFJUQJpS+f58tLXq+5eqqYdnbNcUUSSnXAMBdaCLrGfD2vh8vMsTDrP/bWKICzZWm1rNMQfHXef/4ytZuvj9/T3UOsmRAktGqjDyhBzmVdTdsqrYVZVwDICWFMKKW8ssvlBhVwBrtaLTUQw4hyUWDUGot/fv7rn39+Ob5cUOI9ypLHTC4P9K0QCLIsgfvVXsd1WmKI0SdfYGkEf/v28HbPGaUYo1orIQRVVDL2qQRIUKpdS4lVNVFqwTiz3gRnMUZUsr5po4vOrEopZ1IsKZrZzNUtMyWBZswJ6bRM1ePS4koSCoSlkm1GWVBKGPXZUIpDYgyBC0vJlRJNEColN83aDwpQKYkhxIIvIZJULT1dr3yV3ldrUNtvC1lfvpDXVz+eyHWynGNCEi7UpdQ0eui3wRcoslXEhhWTudYb5wpn7mY3T4kLTASjXOoBZFeoZDWH9RQkk9UJn2PTydW+xFKbvi+0IIQZk/M1zjd3vczL5JPLUDOhRWkqGhVyzDEXKDF5ATKuOWWAlJy9KdZAVkJspvQaI01J2GDPbj30m5SkavHu0JVSRnsRnGJEa+JmdWhykuAcaLdpOGrNGnxxgGDoVT9QJduSo7WG8z7FgAlLeapQOS9UoVIQ5EwQUCqcN6jiFGNwVkjSte24hnWZCMaUVSm1MXZd18JxgcpFpYwSUlfjbXRat/N1XEYUTCSZMcRCQSnGzCrCdLNt26FnQpcZLUsevyZs6/Fkby9hnUOuFTF0sydMmxwzZbXtpFQcAKWYnY3BIg6AC2XAKomUU0xQyTHngFEiSFpjrbGUquDrulrGJlSskqym3kdEOTufvfPrx1+uH7+M02ghR8+n7SB5ZhUtQm4Fh5QRKhgyJqgSlFuNCoJh2L7/di8BjLUI4RIyyggVUnKtAKXkEMK6etA0Ii+V9OsyLhdnl+2255ra4nzyMUfnffalBO+LNSMrsQgCJYcUV0ZBCVRyVyvn/EYqKzUFhBXnjNFg3Wo8oLrrh5hRToAqzijmkkRVqfAUA0I1VY8otIoCUXReX6htS9hRzoVS3t6WG8mOlnRBEafkRZeUbjmp3757N4ieUY1UUofWxRLKjEpFFVL0IXiMoVWbKeTzeYpcISHnr6fpZPLCMnG+ANBkjFvDZMt52G/e/LbTclM8ToZfX4+34zkHWgsza6By6tnQHJpKcCy5lEwqCba6JYZ1AV9b3WZWaQEtiCQEVZ+j5YTUnDFCSnPaYK3asgaf8zKtFPZCTCVZnXcFps0BoLSk8QUbhgRGTFIhG6CymW7X7b4r1ce6KLFlfAWUdMuY0IJvs8PrGEqMuADKsGk3uUZrq12MWUIuTirVNConDwCUQUUWUywVijHMiym5IlwYJ1rxa1mX+WpWH4IjCCPAwWeLodSG4ccaCcoludN8nVAM08mZ2+iWebrOhECtQomj0FTz/uHt8N03d0/fvOfDIblpXnNIHlfQVHjshKCcM1yKoAJVGK9LCAUKyiXlnEJ0uFYlGiXbuLTny9fd/bJaNo7+esTryHJQjMRYLyF1Jd1lWClPQpFoSq4RcGy62mLadIpxqbTgtEo2pIwxEinWHEuuUUq1riamRBnhghZIPriKK0zZmxnlTCmikq5mzRQwo+frxd5sdEZKznBHQazGETQR7BAmqvbWEhdSrUHIbZWcFEeBMOCIJig+R8yIwkhWVGNEsVhAObh2TOB85dKrpmwG1W5xrZyaOXZNpSgOG55yuZ6IXSDmoNRR4jvvZ0HNtmuyZoowNwbcUJSNpLpttql+32mJAOZsqUyq45z2DJew5B9+GH/+cb5czhvRNAwJ6gSJMRcfg42eqMywTSsuvLUujS/58npeppGXLSCcSlG69vc6MQ9YSr7xPjsfPv/y/OXTl0M73G+GjJExa1hNWueGNL00ii6YdZolSnjXMSS3BCuprsb7aYoUpf0dVkLkCpiZphW1iGbgiwHVbGsR6zrz1iEEjCtGybQ4IljbbeUGp7IyRrnYEiJu62pNVFwKpQjyqCBcsZkn50eEmq5rmlYppa5nRzAXQkvOL+dL8oXRJvg0z6GwAighpGIajVkAgWoQIbxWb4LHFMeCfT1a51PuUcHJQPKwvKY0g8Z028ZUDNfxIEWreyUO+4f/P0v/sSzbkmVXgmvpUr6JsUMuecTdIwKBZNUuKan/b5RISgGJrAQQEXD3xy45xMw2Va5ajcivGI0pY476w+OPQ/8Zk0qOB7+3NGEtpHiSxLiuhWFmUFj20KLA0nqtQmvGMpdz37Fh7AD9+9fituS32qnPG9xaeVOisApKDJ18MSKNtjx9+ETCLHu83jYXvO0VsDYchmGUUhER1dIUHAJjbsusAVbOELCWmn2rSepeKGIEhfet5pgc50wrIRUvmJgiEtRq5gVEi0iqZeS8dOZSs+F2G86HlOoyXWJ+KWGNMdcSJGmuOcPGEDGTtl1rhQByCMR4jJ4kKqWUAqWrtsQEmI4Px5EJ9LHwsOvB6IbLL3+7YbMlHmuOsaydDQ1RcsFIjr2FZrKv25vz0wZiU5ag6uPw4zzfUkopLacH0Q8iec1qNd3h77+9316X5HM+cyf358ej4SbFREwqpRjfOGPrtOV0BeDX17yvvpUqRHOuAOLloT89dqIDxrTfy99/+WOb8P7u17WJHPbbHx+eHg2HGme/3Tl0p16eOtpKd+j5YI3qKaMWpPc9zEvZPeuMU+pgzRDr620qudnDoe/6IRWH1JDy6WFQlt1vE5GqrbXGpRqEtcJkt0S3SFh8K97NXhGNw+Am13iKcVdSD90JmqsVaqnBR84lorWWuBQ5Uc2COHLehZC8E+vd1xQ1UQyxlKyNrFCMkaW1f/caN7fg1eZcbN8uo9JdC+guZ5ninlI9nH8oNfRH/fnQS1IpqK7Pqp3814BjiL4yJKEEJ+oNYXdIIdVcsPBaWmvY94d5WUurrRalGOOJ+LOUx3Vbtu3VGEUgDv14v89KbedT3VcQ1fSyOw/60wf49NOfW2MxMEYgVTODUZ0+HAfitabSKhKTy5zmybtt7TolBSdBzm/EkRgHiCRYN3bM2n1d/bIoQV3XdUOXGXAr1yU6t1GhWoGhkVL3owxOIeenDzZ5en2ZAAxyIkm8WVaBWGm55JiVFL1RRkFKXmCWmp+OY8oArCCC7qrpGmDzPjOyOQu/t2nbOMB4m1Lwr6IYgITsmlIgQqpH3s/GGGInxc267DGTj1nahl1Y4b/o9Hndzvd7LKV0fQ05ln13Hgvo9/v71++/JCexyGWZuqe6x2Xo/kJKIdPUv/cHhawpetAkd+f8xLapBQ/ytKRMh3HQ6parI64E0MvLNH+b/S4FSCMtcgqb+/XX3z+fz6xkVgQp/0DnMPwZSMTmpeaZuVqW+fbNxyLa0DF1Ob+chx8hpr57Vsz3aiyJT+tVdqLB0YU1lrTfY3PpeBD3PdSOLs/nNvo187tTb7/KfZ5LihLcw3G3IsT9TJ1zftn2i4SThAH5a8kBqNbGhL6s7m32fyP/J8Be68Yk7mV734mSvb06Y78K0Z4eJaeuVimE2ra5iEWwGlfYgpOSefaH0B/Dhur02KnDaRRKvtdiGWunC//08YPW5vuX67S8vnx5a1xXZIKTFMTaSUshFWuFuX32futU0to0gfN9Zbz5kOd1DTGwUlOd9wir98Z8WpaXcQxSfMX2ZTCd6ft8gRxJhs9jx45j0we9u4icyUqscGlgOEptkQjDxvbNl5T3dwqusIqE1btV8I5xTih8ijGky3AwttvEXFWUqBQpMwxNIBMtl6A1i0q9/PbKNy2bpdzxpxs/Jv6Ulym9fbUvf4j7/V9jFbuXS42qXa3EhqIVIG408FGb7jgqXobDaDvpSw45AkJ3fjBmmNc1VRfWNN2v0Iqvnge/CQFQMddGhEIjiIrYKhbV2dP5UHJd72tIOwPhaGKpc6/PezUAJaf/HNN/7Wx39D+A6D/+8MTI3ZY9NY9EIe6SV8YZF5wRMlm0iqfLsLFwejiGlJEyY7Zl2qcp7U4SxtVhkZrsw3hQ9kkPT+5e7muNVb1PW86x74yQdXq9spp300w9SzwwRqEsUgeuBUsSkJwL877vYecSWEs//vzpeDkoIaBhRs8an11V406y2NMxeJYdW+57uXaivVBtjMBwoSlM677Oz/P78D/++p9ef3/HBkejw5MvoR50n/zGCEuOjZw1lpg2BkvL+75532wnZNdVhFIi54qperzYt3f3+vU9R9f394N5GoaRiBqTOVeDh2V630Mm0ezASSEZLOChwcNwFGha8UooVqSU7HwSJGqunqs2CMU1dBfdP0hmejm3tCdBLdd13yDXBFBLSTmT2/KyJM5VdHWZPCOmaJAA7r7sUyh7EjxLoVuD3nafn4aE4F1IoRnkfYdIYdlOMZUUc4EQ0taoilC4kqwCF4dS2brmGBbv187qnCCGBoNKMdVWYkmoUoWYGuRQUshGW2bUjqllZEDdcGqcVefCPcpkYrkeO5aXLOqpxfbbv/z6/s2/v7qEU2mmAHOurfuceml7xYj5UpqLvca+10LzWJKf7hlA6GattoYBphT2sO8l5hhiw4YSeYgbcTOMD9GhkKQsZihckFBMy74/nu7v6/V2bRU6zec6zvewbZsrt5wSBySanI8QD+cn01nNTS1EBfjT40+8XVtpUhYELbi5z6s+kTkdz5+fzeljrazEOH/D316WaXEVajcMya8giu5hvJzpNPJBzt9u7/d7qm3bA8MWQlnv133yl8NYAjXs9oix3kNdtzhLXhrrY4zLHEMpxAShH4/w/EkZ9QAYkTWXki8IGYYDU0cuBvkyl+u1vn1xcFts9elej0+JiXCvBsY/sSJ+/9sff//7H9t1VVy1lRm+9dpaDJl49nFd7r0Bxo5DRy44Eng4XXDNDVND4iqLXEjKWO7dKA4Xfv8eSqbguQNMMUvrL8/dvocmVN2U23PL4SQ478VwGnTXl5K15YRyd6xk5EIQgl82pRrjvDuowVBGLw5IDwaNZtXLhpLTPvlWj8Q0SV3ivngffDweziFkIYpWLJdih872+uvXl/u8yLQexj4Xtq3R6I5jK7X52gILXS9tL9UwLk7Py3afpoZ78LPtKwohNTNKA1Br3LnEaiBWOcfWGjLa9pRrSSUCL4MVTLY9TLVKqw23omimlEoIgkzlavttnb87FkRcAlNzioW2humgqO/FcRERcGUmp+i9K1LKUruGWBogYYGWSp7X1WhBTLLKkRgJ1XLJHuf34Pw6zUtNlQAEI2kANXBtuNQ8pkbScM10j8z2h8MwHHrFT9N1vd28c623ffDtOo+/f/3bEr6j+A5ZjeqnTox7RjzE8cS43mqWvZH7Ei/9o0g8OmeFy141fZjijV9YVcV8fmhcMSbynF2i91tbtlhzPDFsJIHv6oTUCW0qUMphud++10SHvrte73+83jD6B3sa1UPZw73MOVWmSkbmQiPDdr+FkGPeGKbO6MPRfng0tiNBJJTURm7eZqwoQNja4Hi98X/917df/q/3+e12kW/P7Ie6E6eN4e3Jfujt87bhH19+/fZ9ky0R0HXepbgeRj12uzVmvblpuafsGtsQDuOj8tHHiNqoEJ3f4dSznJGhJoJOKc4LimJJQrapQK7xMMLhGaWj+42zWWJKtWCsMVUsTAirJJOZNVQSlF6vdb3fS4pa5wvbicgOR2U5l0RWAG/JLeueDOr/u22QOWecC+m9LzkJIiGwVQgsKwmd0EjN7WbfTS21wVtpKka9zZtz22B1r3pjTWUojo0JUW13X/1vX79+//Y7wooYHx/FOPa1GCF02l1K+7ZPJlUiGUJMKQopS42A0CAboy4PgxmMj1CLbATccOg5CcYa51GsX5fv//a23vx8d2XJgt+W9eXDD13XdaeT+fnjKWf3fp/nGmqrKQctG+sstFYrlQQ5p1ycKLB3arBk+04qVUnsc2iZt61se8yZJBOtesYaYgbKHCXGmvclCL7KjGK0j4/04fOohh6d+ePLl+t8SyUTJ+e2aV9W/zZt34VcNRcp1oiTsfbDD+LTjz2Q22Zd46ZgO+oD0zKxyiFmz90MoLS0ort0oKG6VEud32/L+8HdWd0xxhgWxwUjUc5nVSH7eRY5WhKfLw/vr5uvlXJluR674fl0ziGyVLgNqGtpshRTMK2OpvmVOHZ9OfT9+XS4XM7DQCkHIQqw2ABj5GpMpCogpP345Uv8T//7H99+vwa3tPO349BR0NubIt74D4bzOM/tet9dashDQmxFb2G/r7fPnzJXvdByOBouohmbsGzdQ2nAXGvkdrcJqRCRMdaqJC6QWKutH4gY7jNPey7NoWrHp/a5f3z9roC227souywt1NZKrci57kyhkCqbYv77y/3bl7Xk3HX4s09CsMcPtZfdeTiY0wmNTe9LSkw3ve3JLwBsN30PLfnd244ll3KMCAwbZ8W0xuZ1c+mbX6aWHcpSAXfH1znnWFj1BqSWkunGulaweSZWv31//fby+gpl7Tsx2C5ulZqSTBbEnGNOQfJDTH7flm4gLqA2p63FwqQVUhuhLOOQAQtmbokZIkkQCBOqyrf3/fVt9nu8XW9peRuMmJcvjw/RSs7lKAUfh6PbT9GF5J3FwEWXS2PIais5ZsnZOPTjMEghBAkCCiHXkhlBqRVbUySosQq1pJQ8kCC+Ob/vsUYD7SZts48H3T+qA6HBuvvSErDi0zpt6L0HPts+O99DE0YdsGy53K3VHz7p4Xhy6+42YHVTPPQSHXhkoabEUMawq5F0z8yDAWoErPrmr+n2ZfX3wgGMMaNSBcnYaDTu87S/s9qoeBpkXwx7m5ZPD6d06HulKbuvL1+eDmc1mmlf3162XA2A3uYtZ6+Nen7u/vzzj+fTiVXBRFuWKcTVuXUcj4oeGK3Hs+0G88cv7Nd/vWfHWoneL/e97MOrtUeJPwisNUiXXudluF5dja6wUlqxlqSUIcSGSXXyrC5DG3Kaur4TTNaUNVcIIsaQIxCI2qrtVMuwpOLW4APlFktutTFuihb89CBT3UX/eIExxh+RSbd6f115ZKa20kqB+u/ljLcp/PY+zVuF1mbvyU1acUZDs/XwMLTCIGMKpZQWYgmrrzt2D7scJITAMAmh9znm5ktBIYfjeJ7njZrMays71p0CRCnRb9Pu4+V4iv59X9fWBEte9kxYUVhrCKVVhrWkwqrCzGqu2KhULqjjuBip/B6JmFQSEXa3S41ERjJkGL13SICipoJmNImF2jbGewhQlvr116/bHK09zPPr9+3eZ5LifHt/ZfASf/6s7Xg+nt5v5W03VkkaZdtDbVkIAqzQspX8YbSdljXlbc0xVq1MakhUAWrOueRGTJTCU0w+ON5gGAfem35frrn4QcihF3ZgYLnLhS2c7dZNhpeOZAlVTLEQyE4Lb7rU3knExn+1+JdT95Ns3L+ymi4qLQ1lSCkVzK2tbq+7EnK3nUgtKfsI6Ft4yFt7/7K8/Db++ts3X4ocb1xA67BG+PjjJyF5ah7WYdCPib53h1EUej7zEtjrt2tczbpfc6tz5Ler2EI/ba61a9cpxu+XEz9fuo8/fESl/v7tm4v1LLQizhFtu9SZqzGlnGpuWn06X8TjE/vXf3uXZRk43uD8B2xNiofoL0oMyqz0tIS3WOZnLFkcGfJObl09PMiL5ah6tNpm3WN+iC4qphVSConF5G+AgWis87zYUYsx43J8+/rqQhS6v77doHSkv8me53rC+jh9L4gbtsuy3n1afcsM4EOXtd45NmDdl3f4t79/f58XiXKdpoPm1X70qd7nfAqIHtPXpUwbT7nDFmNstZIQKUzLexGlB3dc55ycARWAkCQaKedlx1zXWqbkXAwnfbpfN0V/r+qHzITlsuTJe11wHN785R96MYaQnn76y4feXOu9KMkfj3Z8gABXVwXLI5dmGLbQPAD8OwyE6GrJ7h67URmqWkGpa84h14tGktZGtuToAPvb+/byfc3JuD3UJDt7VOzq/bfOPiDH79evz/YieFfzVbDITeYiVfxHn/5V68hqVgzGvrMCj4PkxJVUtVbJsYQEjUpu1QtWwIVYcUHRAnNM9ICSjw+mKXWdfzPC2pM2A09hv7+/YUkH+BlazqlRMixLEQhhxpg7WUI88hLH8fLUPZwOQ4lqml6RGldDDCx6uk9xduW2+ORS30PkzRrBq4Ug856X13j7Ov/+L82vd0GVtajYabunf/rnT71Wac+1HmrI3ERGrLU0dgxBv8+LYFQwETJOijPCusrqexkLFC2rOT3+8PNPUumY2n/9ty+//va7NuM/PHWK2j/9+QfdM+9dKfz22hrg438ox2d6uJany4d9LZntS759f32X2G7qjwFMk5Rc3KZ7J+Rl/Oyw9l03UD2Y9PjwBFBrcbwJLaTqDXQcQizRRNdCWBlPmjWGRG2Y3qL0ulXj5tZSmeZ9dbFE6Koc7Pn7H8KtL4/P4+Oz663SVNx9sGI6HezxrLvHRybMHMSX/+b+eL01YK3llHZ7GlNyUnCjlGCixra+7zJrLoRk3HTqfbtFn06jhgop+pYbARBBbUxLXRtG7xkAJ2TtKnCrooSw17KcHuvpoo69pqXc3xZlhBi5UkgsP5wsN1rb5/PJp+sagz+dx9NZdHZQpIFAEhMkUqsNWE1cGodN1nhm+r02sW8WguNKMnUE9pXGT4BSsg9M4vYe3r6+JJ9qLdAAgNV4CDEhZQkBCFNN92XfQ0xRQ3lAWhhz2H03/lGi5bwMmndKaUqd6YyWtYTaai2VA63zJoSURI2g5BYL8UanrkMBNST+/PC/aP1yOA2dOjXICnV4i5loGGkOv1yeK6F8+8Nty8Sw8sZzwdzY7hWj8OHD8WI+KKXmq011Gk9E7LmkPbq2rmGPZYs5FQiL64qww0Naq/+yOBfXtV3/uG9XpYX7/HmAeomOYaOnZxCc50QutJoXaAuDHIsj3jjKWveuJ9YiF0qKI+dIaDaGSQFprq3WfT+eHr+9vH+/rq/3PYIoJb8vSydp3Xd70cTz7TZPc7m/XQ+f2OV5tHr/0w8/fL+m6/ZS0rQleruG6/PrM/8nX+T8uu9v15HrkT8c1FWq8uHSf3ge+kErU/2+NVCGM6il5Rb3FDcWHUIKnDLjgIQtWwnj9II+OA7jtv/+9r6mmDnLpe0hMj9byNjrEoa5BGmkl5fudPzB9MhNyoJQ8NW192XjynLq27JcDoPkwGpVgmuhILMasBBm0VBhgYaIOVcibuRQUkqt1BoQmBK8cRKkbtOyz6FmaABWnJvVgs3f31+Gjj0/nvTDeBpGfelSucrOgOmVgJxa3JMy+/MHOQ4f3uV3zsbe6PMwci6w0uY353bnS0UGDZE1Tl2KKce7jJXxTLiHzHjH1aC1GnNNDVEOrC5lf8u8CYWaZO07mcrSg5d1JGBIfkvt25uU27aGX2+Lc6kyKinXnF80F9x2kFNoKLFrKa/rULJeF8dJcRKm6zgjVlmBFbEJqgSGSBLxBqHEyIXYxp7Z9jCOyqjObWW53bvLIAH5kR8eH0lLF7BJ0cthD/eQstR9d7KEyFrJKwopIfTr/VZr1rrta5znbV1oD2vJkZCM5JLQCGmF4khpz9cv7vrHrrVnVIdBlwj78vVPf/qRq6DVgYEscUucLfNdCi1EzTVIaS8PR85EOLqaxn3377ffw1qHvrOHgQw11mR/mNb5tz9+W1z1aUVKxHMuUgi9rFOvKpRaduCFpmn+l//9/h/+158+Pn+Mz/Cvx9PbdQUwCh7D5he8y8MlgN2mmaflocOu6OEsjif54dPD8aEnzhqV1LJAK+tQF5YTa0nwiG7d3Lb3hriSMdXCizRdLunl7eq8v95vilOODsBLtQ+j7c/mOJ6sEn65p7AcBjqeSPCTHSSeFzoYUiZdr9UHXhoUYNwiyVQdYQOClHPwpRbGm9jnqCyBIKTIqEnRgq8l1VZaaYUT08qEwpyvb1cXXdPK5JYT1spqalSY2aO7TvO52/TT48jFcHlmaljr8Ha94eq7yM3TYu0ouTk8DQTQSc1gyK74Zbvd12XxIfAUcHOLD3cxjwge4a3ky7PWl2eU5yfRC+wR+VMKjvcGSktx8utaQzyY4fY+MREuF6WftN+021vY+HIv5a2pbtnynGqMzSDKEIpzuwBeToq3GqEJVhU0zwJDJGpKISes1XEOxDAlxagp2VLZhWC1VShdq8iV/HvNjeXzuv4Pwkc3Ud6KPDNJqEbedM92UOfuj/e///r7O7YrcTuOD6fPU2/P99faMBIn1lIprETMtMa8O7+UomtYDS+G2NBJTlWLxrDk5O9bmG4qrIPo/4W18fpW97U8PPf/8D8979sNOGHFBqFmmVJ1WZohD+PYWp9LUdoee7q/Zy7l4dK1gxn6ox5aaKFClYO87dO83p1ntUbWSo1h9XsNWy8PMJ6hsLitJe2jxu21/PL/m5m/jLb99MPx/fry8mVrqUgjhufGrJ69T+7a21lR0bU9Pp8//fDQHbuIOUFLpTDgDDR6tkzOuVByk6mFbYtrylmopolDKul+f7ku+9s8Xa9TiCjgTYlqxJMhq9mhM7K11bkmaxn6h7FHaX3KfM/JShSDqj5KVi5GvgruPXIxhuhDZZL7is3HVBtrjdweI8/Ii1ZUMdpRWCXzBqU2gMy5Ii6YUD6WeXPTmgRTjYnVr9M+bDvd7+z79RfJlkFv9vEDly0kj1aDNDlpF0oJfsP0URdLVQojxyHFCLVh1HHb3FyC897FZW1rgJfv95T24m69JasiP67eiZKUdzMzg6QhlkkexxoLKNaK3qe35IKRPEW3eQi5RHm4rzivoXqPsWFDzJlr0Mos6ykE8t4t+2SFDklLJYjqHu7IoWKJJWguAQuSWNc1xwclTeUvTDTGsOUhJ8MYLzg15nivjZu8aBfO3XItcQFMfHpZhJGC+kbwvkz/+b/9+uX330VFUeQ4Htbd/vHy14cjc1s7amIUtCAjun7sqiCfmTDKGlYyCWF6UtYAF+3Q65zL7b4se3YLWXEazipu3e1tezj/9I//QVTZpt9z8e7fx0go+vXrO1Z4InFPGWpetny7v5MI0TOju348csltL1RHB6UBmffd4VA+PD8sCy33ad83QJAKBbGxH0psfts1F8AICFI000v+W/r+z//r8Kcfn6b5aOGBNbpchv/5fyvjxQQHysjx0AcXNDYuLUBXqt7zmkom4ornUpLztNyW6/Xq3C5c65RuGZbk9yXzTrGTenn9/u2+LGuJOQl1GCR3254CMPPEymW+3bhYcglKEdbRdr1LZYt3aZj7tvXxj84OsoaHvv/8cPzqr6m01jAnVkUtNecca2XbnhY/8TH3Rz2eOi5YirHEHaHPKUOFVABK3KPL9SEGljIKw3Nty+aXoO7b/dv8+zS9WRmmLYQ4c5mVZbb21ync5pm1JiRH8IbEoI3QXYDMGbp5W6Ypx8wq63SfYrje0zTHaSkl8xpfazUtdn133ZzY5w+NLcCZGIx8bCXMRBe4wXIFQgvN5+y1ItHG+dttL8fYUgqt5sKpILTYQJPV0gZ2TC1xVok3RgUwKtNJhn7dgAYtn6FiSyJ4Ev0gambakUxYDiml0EouMzKnpa1RMSn45h+acGt49a8f1ulNwawptmKjszqftrfw9Y/8y982wXqlnY/sGqYWvX/ppBDIXqQcGZXT+akpqay5ty2+8/78zHAduo9QgeVgOqo1SyNjsHHLxe/E3mP6RvFBia3rpj//6R/HUV5/++X+HXYxPT3q6GBbplZ2STLM2ABShrtfb8sbieMwpNg2ox8at7e94iZUl6SisOrzEf/5n398+ZLfOS4LX6faEXy8nCgzpnM/sAV83UXJrNZSsouR5XB8emL/9A+jxf8ZcH7+MH76wEl70izEf2Rvz9v0lmjdlmsUSewcsEqlBOv7xwDU1ut5m9rrl2X327E0OTDOmVAil3RfYinl7S3Y7sJaYXEae+PCjwXmKpct2z9e3jBdeQ6c0WkYX8L/eP701MjmZG6vG/6hzhcMx2oP+OmTqeWYKk23pc5bJ02vmTFguhIy+/3rPUF+Oi7D8YnRgviAUHLLLBsIianC1KGCn9z/VbenbSW/thwnLbuSbcnd/f46T++KKgED9swhEnfyYi76tJeb3sr4+dO+vUnanb/srqfqpdVu20rIUF4QWWmYYpdiSdlRy2Mn3u9vQl32uGntK7VY022eNZ1rK3J8F+qxNQZAzZV9uTHwWrOwbdbQ0Jtetd+/3Ms+kar3LLbAQsiC8wtoKJzVl9Y2KassP3DwgrpSxbRsOTWr8LbMSgjWGpbW2CaJS6krgK8tZgFNEVlrKheY4Q5C87/++nq/31PKbn9TAjQ6KyAgiJOG23ybynxbP336cbp9j9nX9iX6au14HD4y8ELySNVo2dQxVP724v/Pv//r/j5pLjtulRJjN2AMPiwkZQMWfQ4p7WtkWLoOWynI+MPlgxlnNx2pfTgcFwbKu316jymkHLwQybk0zfeY09v27Ta/AazHoXx8Ps3NMUfL7nIqUnsSMA7+859O1oyY2rq83xdPRmW2z75paQlab/tSoJSSG1QEIQhYvd1fo5tyLuNIQplPP5zHJwRlSmh7YGDj1u7zdg9h/vL2yrkaBj4OXd95MzRseL29vL6++ziVGkvBeZ6tlaBYRSCl9pBbZVCZIhqsVQLSHh4660td15iLT3GHsHHG7ls5VX9+PitRiQ0+OJ+/OZ++fWM//nw0HA6DPZjevYqTHru+cmat1crwlPaYI9PgnXebV1onF6ZpZSRZuAoFsRTOVWlY0vD2Ps/Tvrks6wLQuOz2L9/j9IphBQPDqetHceguxVGZObBwOKEYs5Vjjh/vr3ZZ35U2FHKbNgTkVdRWt3XfZy8Uy9Uz9MBKw0jEat61BMIo0XRiAI95czn62TZN2ugupeqvKW+ecsGSStx73Q9H0Y2nvYXX37YUClCJsF/3d2IZxWCLTCn5VJA44ySYDDGnMCE0IYTLCXzzKWLLkkgglwIBp1Yz1otgCQlIBMZGLozgsZmZ/9f//vu8ziknQYZYU5QkoJBYFR7Q12bAO00Hx5kvwBu/nMbT6fDx+KHUyJnimsbLpVD3f/7nv/+Pv/3x5fZfWSrU4GCGXtpPHz+eey2MRqjTtLbVC6GSK0PHFWcxNaHt04cHMt/DfkA4cLPwxv0Wbu+L4lULpbWpLJeG922/Lfu8B6iCtdyb2FMUFf3cpnmubDOGl+cg39/7oQf2lDHf1vd9kwpvy06sfmwdy0VGD6uLDbHIqgSrWN/ut4g85drbQz/IkHbntZK0Rj/5+1aWNa/z/UaN14rYaNvXefafP1L0ffZpvq/OLbWlWiiWxDlxLZCDtbaqLgSodb9fNymQE1ALj+NAnE8J563N25orZF+tEswX6V0qqaM6T3vIEWhfNu42l9Mm4PV8PJ37ro2jtYrz9wySODGO0HbTKd7VvhPr7GplgmP2mZMt9WatdSu6LazbCuxIjFKKrTKkAEyUSg7uO1x3eH3gIydOqLDJlGjdsBz3/hGeHpXA/vYS1k0K7eyoGcr5zXHGc8XoSkW+xcjrBAidwVghF0Z0dMu75NAZxqHHrKHxfbpxXeKM9mMUaEJKbtqrT2kJcYpuzsKwt5edC81oZOCS33MtwJBxBlh82VuKrLbWOBRshXLNrBXOuZZKack4hRJjTBwzkSgQElSESgS2KxVlbVAKFgiL3+2J9R8uvDbZqtpWr9RWcrRaKNTNxbeX5fgorKaB43W5KtGUMWzvzn0/SFR1jDnk6OIQKmPTuv3bX//4+vXWnbjQY3DJJYh+bfiaz92njxcimJc7AGFHLLMmkzDELT9chufP58IDdJaYje643ZKLvkDMmXFSRCajB6GmEN/X1YXQiaE0XJ33KmRR9lSu85pS6geq8oX6wQx9iv3q8nVZU+5cXkPGy+FxbGzZfUnMlyi05Aq55IDgPSCh4koKpjW3VuVEZa8kuvFM3csOrNTMkCIjYkXWPKWYjaJen/Y1RMd8wBhZy6cEb9yoylvlxR5tIttybUyvbiHnjKbToz0Nj7vz87Ih1hBCqqHFCFIyBATMKQHgttRtwwJ8m7bWCue3Xg6cwekoB2lyClKy2i67i6lWJdzh1DETle4hIxaBPEmJkitkulXAppx392kuUGMJPt2RlB3YOOjpjSP92FjJdWvbVzJMwrkCX114/OFB/2hRVBhKeS+Lm7QZHz580MqUHff3WFKtAV2AvhuF8nHfz8fz2XZ6qEPf1SLmqUGNvSy9PFMz0GSIixqMMkoZzhRDX7ExyeUaEwOTQ3xfXCxZarsXHn0roVQorHGrhwaMQeNMaqGakCUDJIQaiFNnlBACGSsA3nto5dgpbbXptNXCml4IkXDfN9q3nDNHukrdzOEouwuPIbs9etdq2jjnziWuB0Rwa2reM+b/8vFBczbvtzXnbhg6wzodNGKKqeRyvX+3vdy92TaXQxM5NcZqU8EHTbTsXksYne073XWWMQ6AnBAQbd/rkbqjyrTuoef8ytgbinNhKbec2txSV1EzDnur19W9z+667bmlUh1n6eFh6Mdhwvh9e/8237IXW5LQx4fG99B+/c2/3oLPLOamGh5MD0w2RjHVGD3wZHopBy0EjzGmJDTHw2iEylLlh6ch8LQ61w3ydFTbQ/d66USEFnkrvPqzICcpKZYJU2fJdA63F8Ezg6NBC4Lf9tvYHZkVUnTMlUrSx9ry7lyyxh0v/9AKZKitZcEbxAgtKkhW2tNwUKQZStJLmt7v92m+74IzQGjiPF9jemAaMTiw5uFwEinmVqkg6ztjDkbp51KzMkhyyblCdYzEuoda9La9lZKnZeMqKhuMPJ0eluPBQjEn49LAFPLHJn5+uHw+/4BCgCH1g052ksZWoBCy92HQEftWMLEsjDHb7IKvKeHuci6YtsgHsJzl3h77s9tRyZug1tKdJV2Ah5CCXEVn9ahlfwRhyUfGKyvAWOKyaS1373e33Nf3LUOKibNkiEOuXItcTUtOVBqNEdzmXHXLsTDBG4MKrZZUYikMmdZ66E0/dNp0WpJLKSEwYYEqiEy8KmO6Tvb9UJDxfV1bKcdxUFLYrts3N/TSGns+iU4pLcT56ePHn/i3V/Uycf/u+g5OI9Zlz2kuhe3LygHGTgymmyHvawHyuTDvvOwNcVEBS2m1IUPIJTFGx6Mdz+Z0OeihAS+36bo7q4eJkT/b56dPz1rrZVvWbynFljHf0/bl5e192XNrUlnNue7gcBqQy+s6f53ev0138NKFOH7YfaU982mv07SlVJA3ybg2GlCFCFDR53j80JlBupRX56CBEUaKSKwIVY4PnJ6kasrdppx2YP448j/99DTSvs4vIfiycaGzMah1LSn33fH5aUh1JuJQj22bGGQibcbjFsr3l/sfr+vff/v9/X0ZuixFu8/bQ3SkJXGmRXk+Wb/vhdRgxKETh1EP46iMUfzMKmtRSroJXoj26Km19uX791b+zhixu/gRLgjYsmSiGqn6XnNld7eVnFTHhJbelX3NqbSY3TxvyAgRW0vGiM4ILkprEdtw5kUd1MfD06Gqnz7/3I+HWJLuZIWFGQnW+Peyb15wOWiinmEhAbobxTzvmwucILgQXcop5Bh8zDsLw3CWgp9Ph8Nowyb3N0lcxOrsoT8+nIbzsXEJuZTMUgS3pRB8y2CsgFrntE7z+14zVGoNGIwEmTHgLKZSoGXEJkUTBFipQtegEGdMMCIefOy0tVYbyVtF5zwkllmOlfIy+jRxgX1PxHUDnisiRn4ejrWPymbbXwj5Ijehvj49PZxONiCcT2fWDab/70dKW+SlGVZzSIsxXGq9vYaDMZ8PT2uC46F3D+zvL7+PxltF/653Iisxc58Z81ULJlVTmo0jPj4fd+fjjUup637sVdluUCsd/ryp3uRb7M+Pii3rdb7N8H1eX2733F56fNStP6r906P8/Mn6aXh7f53n4qpV5bUz8WA2ezjfPV33X930dhTMse9DB5w2UQ4laQAAyd/CyypW744cEsfGctZSZg+kSR0Z4J34k7GjljKlqx6fwolRnLFUyRyYUmIvSbRyjEEkgccLqP6H1trtdtf6oZaK/UjH029/3P7rv7a7//22vIdcdSPF1R5YKN8/PT0Xr1QIgtntfoxeGaNJYUF+OD9yA8e5u11FiZiLOJ9P3RDmt36et799eY0lM2LAmC+3h7EfiX368HzpdVIU5ASUyx4ZHCugh01xI3Ta3e9KPLgQANYUOik5sWwkowYKzqf+18eDIP4nFuUwdqF8K5nP7zP7NR7Zc3O13WuIL6enUfEDtT0X9B4dbIFFJkwKv1KTba9KQsjeZQ7Cu2XVne3tiA1KO5su5LoOtj785U/jaUSpkfu45biJ5nB+3SCmmlCS3CNP0LhRlG+Vcow+7YSEREV3jeMpJyxYImyMg7aPnGshUCpOxLRWMXgluOQcSqkpt0oNlcDAGVYRBIqu72L2W7g/fXxs2fOkudJi3eaQ1rwLTuZ9AXST7I+qM+DVr3/cudhVlxhyyVMV5b57HuWny7DFqxjC0ydLype9s6qTLD0cefXZL+l8Pmll9m3TvS3FOx+VJGWUsfx4NiSSwuZ2nxN2xi7ru1vD4+PZcJPX3Sh9PtAaxfW7X5YtxcJQdKpjBftejIN6eDwPh2FfHGs3v/wiUR9H+fnT03l0lo3Xryu6dLFdjlmZw0l3VtgGqVESguY57nG73XJ0+TC048GIjnun3N4GwLoPBViG3ArzmHMo4EK876qKUYyhqFpTqkxJIYkHvykJKMrl47nVkrF1KLZtp54lzN/fv3z7rjPfuq7TVBhMfl+Hc/fwDOMpU3mydGi59JbX3FKqwfOSaN+A5RslJ9v780UW/mAGzXSIs/m+vf8xzQiZITi3YzGzW//540WMmLkDSd1hDHvNiZLLzoctJQYp+MTygzZl92utQIxpxQ9HlPzJiNPS9oG346HjnLa9T7H4xKkMb39N72/3x5dwOJ2V7UcjtGackl9icDWuGTxjmRsuWz18/f3bqB+MvbQKghGwfpkWjvr04QwNvq7fuOIM4fRhOP9lQF5wSBAqAXfr6rZQUryM3Xbfcw6MpLUaCCWWhiKl4kwIERgJw/8shU28APzBeBKC69YLvh5GRUSMKOcstKg1tVY5Y9JwyTln0JooBbiwXFCr6PatIG5zMAclJPFYkkt7Ci8uo1L9MmVQka7OF+/mF2TxeMLz8MPDQ98NiEWGdRUdvnz53Qhu1BH95K4F/f6XD52I/rh8Xjb39vaetsgrdkpLSYwVJRlgRMLxMChD0jAIEHyDlluB5P3lcFZcZ5dKIeeC83V3rTQVa2q1HYdTzJUVOHb09HD4/OmT1db28Pliyo+Xe8UBlJbi4XA22JflflL04cOj21g99APZFFIuGwhM2GrjvT4sy1T3zEfWd1pbHmadM8zT7e3r9vB8er19VcJopaKPeflWtg1jJxG5lDXjGohlrBEEKbeWRpnhpow6HD9orgP4JnMDMkOvpFiXIMhILrVUUqjHy+Gnn0bGKgudZQeGuCwZM3t7mWo6unX/7//Xb/Z8PapTJ+fj4yd5fEBBS1vcLy0yEsOYwuKCLwi3rYa4n6x6Wt/lg9R8KLXm0rAqt7Zly5WLhLdWhKQfuPhbg73vOsYF57kbKsRj9tL5KyZKHkEQlznlIITAOt6/39a/3+5/zM8f/ePnZ3rYs2mNl7S4nCA7qptYrw5D1qStPgAmLLyz1jnfyt4bOp86qXDfHAnWAHMpJHSOwIVC4gAFaiVkxLHrjWy4Qs4lc6F4wxYK55xLOQzCxzbPXYh5c+DCRoScS4i5FSbkzSApJqJPjcB7z7moFTPWAiAFMYDGCiOqtWGBVmvKpWQWC1zf1hOhEB2P4KXVxXdxAymatiXDh/sd1u399vLKRf659SwFLeXQQ9nT43is7cZZ4UxTsvub/7I5M7peasy/PerzqTs+ny7ObTH5YeyNFUo0bJWIhNCAnHFVCqRUBBesMbdvRJURSMVTgZe3dV789VrX9+Xtdl0iA2wNWies7dqpF8+n40EfMdLYyx8unx+68/fiO7IlxofT2YdKpT52NGjbzpT7D3GatlRA43DUy7ogk0a07kHRxTDlBKOUuphLZ606sBii34IV5N0ioGDEHGfBSwlFESCn0BJrDWuLe4GKROxwOYctQWG2t6Vga7LWKoX89Pzp27mkYjstWaMSczcMP//4c0sUS1GSE7fLPGkjtjlIqxhT6+stxlQxV/VlOHQ//OkiusOyb6yJD+duud62Va/RNSa04alg4iyWtjtXG9QK25zDXmXQaY9YSElhlApA1WnBVd91yBGg1paI6ZS58yGEhWNx2ctOHQdygW2JLzub1rRupZYo2wqRaN0uTx/sZeDQEFpteZ9r3EpLnqtj3x3X5Vtqw+5jyoGbYKxRFmPad7eWnBjIGmF629728PjpoWtEpkDlgzVT3pOLhVPJqZTMOcdUai0554aVqAo6cpKzX9/n35Btw2BGvGDVOWGi11bOLQOhJBKVU65AxErNMcWYM7qE//crGWuAJUNrIKVMzpWU3RIEeZ4gN6Dgbd6A2Toevdt/nNcbV64ii7mVqlJ2KXMA+eGz8C68fvdj18eYpSjv99hneff705P+j//rP/31b98gMWMsZ9X5yhkQVKUMY01rxXnnPWxrqTnEGI3mSBCCaxC5VhkD8i608t//+svrlZb3397fvnJmjBrc7i9WDtYMRlDBr7+81wqNW9V6Waxg6/F4ZthC3G7Tq5Vs/NhrkZQav/txXt4vRwFGi07flr1k0Rt6ehy1ki/Xb875+6yzn+EhdQ+x5eq3eH7oISMDzmXfbCJKIQ+IoeQE2IwxfdcRa7ubUfHkgGQjzDX5HIdWSXGOol7O5ucfeKryenuRZC7n7h//6edh6Kb3yrlUPPi4+7S2nNZtRSBpvdSVSLCqCn+7fH7sLiMA0upMc4/2eFWUrRU5bg0BGOOl0+wwamskwxZdEPqArZZcWwtStFCv2+pqtj54bPp8esp4jTEraZQYKkNoBaBxYZS2jHSLBTKGBNc9LrlFRm17P5wMA9speT4M0vSF2DIts59vV1YKAqa397mz1CgKpXMOqtd26IWSFcTucoqtpBr2rbQ8uS1bp7BCtYefLgiSAY8+L/N2Oh+lEIQkhfEFlUwuBu9q2AvIl1hFrGsuiCwVhhU3BI0gYmiu+k0sSpmcam5196EBpJIRquCMCIlDQY8AqWItJISSSlRQiCr4uN5Xbo2NPkjFzz09HI19wpevx/t051SJ+O72aY283vsBSjocHs3f/ve/1nRc9oAMYyuBQnDh5Rf/y5f1n/7pLz/8hwGCcWvKeRHSAAJxiiFoowgIK5WI05tH4LVwLI4Reu9zRXOK1ogCfFnLvNVff/v99vobQlYyxRBqbvfAjrodOr3NcZp3YpJJHz21Rov109udYX0cszEHI4RoASEJYcmXYRB91wemAzRCyXljVBqkkltrTOuBdh3beymOMeRc9MMI0FrD4JJAmyKtqys+M+Tr7qMDaLnonFIkUftBIM2267gIm5uMVAwKARKWXtNf/qKG80/Xmxn70+FA5/OhpJ3TRQiV07btt66zyz0KaYKPWuHlMngfOCnZDST1druyVovb/e7A3c6G2eePB6tu91sDMH2Toj08jf3BkmBATBKGVrAFoiIUDzFuW5acEYOWohbc6t7F+zgMRj3UOMUAnHqr36RKe3wr23MC2qPYQl59CMlZll0OlTbTWT1S4XV/d24LOTYA7sO6b29psgjWdA1a5ZxLhdIcOZc5k9tvKaScGlQ0WhWI6mAUFckqDkO9l23ziAWxMsQYas1ArDGs1orQlEuUAmvsC5LRNh7wRERSNi4iJ2LQsBkkyjWxyp3fSmsuxQoNAKTm3AopBeeghUVokGurTVmhleZcIGKe5hyRP58+pzDpZzBajw/Pd1B//fbrmt5shIf++XsI3+9z8vl0HOsGb4uY7/ygpZXfEYcULrObEFmsx/29lDL/P//f+6e/PC5LWDytS2wVESBHxzs6H1Vn9Mv3V8k6YU6bS9+W/1KrYCihfnDrG4ldyse0uLJurPw3xR5K1liv1pJgAkNDocgO68Zdagx53N8Cb6ll/3UXBLUk086dDNHP0tpufPC5quqZ0qkigOGInRrlwx2ZirG4ILeVjJXnx0U+4tOT/vyXj8yS7uB+m/c9SFKt+TBh2rlUYd/Zy+sNqgCcYnXW9FbYZS2N5W1FpZWyT1W3kPe84yAFUnn8uJ6fHwAfWitcNGm1X9y+hgqgDG/FxpAEs1r0rJYamOTkis8wW1DFsxRBq3Dqxnx94OnrgSdczaNOH3/szw9jf+TAERSy0VJ/UVaKRolz1vPi9bb7uB1aq9frbsWroBfBhhpOZrwy7WVvRpmnfT49jxf5ad/9Hv203yvQ6pHVpfiJFUQxRo9M5+4yVCXWKfEqMcV9gT20+xxr4qfBYMudMpwqCU6S57a3worvffyt1YaISh20Ad6VZoVQgosRGCaft8Xt6zuneJ8noCHFJliWOqY6P+hupjTvLraBcdQGhIi8dYTUSS4kphJAAGuHPdO2h4aptsRsEYKElFIZqXqljHdl9bZErOUd2qpsNQyJdfsaqh9y3fnpIqR4eL58ev7zp/sS/8f/51/f33+Vii17Ved5GMV9rhGvxnye1/V+bYpbIsb5qVU7z2WZnDHGKAUyAMzL7Pe+JScJOmoMAI0mgNR3nFNqsCtdOM+1+Wm+v7/3Xc9OpwHty/x2TNsJ1JqLVxoE++eCa8RkNNOSC2QfLh+eL50V4ppCKa2xusYtRUDGai6AZHUXQljWlXOUWnHJUwmkRIw+xFhqQC5rYiWTC5FqlFwaw84Xa876OFz6TpMRQBRjial1tmdAzYPpTX8Yb/fZpQml9/6lBSoFaplPh8/3+9RKd7ooVgl8v+eQHGM9ZZ9LzUVXEpJIIEhCBom8l7FOnRm0PpbIvN9yLoCBeK1QY8gAwFrfUN+m9vE8Kn6av7y9/ct1n2eG3EaSUh4Pw4/PH4Y/sdaJeZ0D1EI5NVFTAYZa69Wv3k85R0wkKFS6c/FcmHBwG8aT7JW6zNYPoZnkX9F1Lu/veZpnH6OrFBD7Tqt9qdBepWTERysvrUgsu9KM8ZxSienadTLvT6bz0Co2rcca016ZEmKshd2WtUFcp1VU/uF0Li1YJYqg4+UUMC9/neJS5pdluzshhDbG2OHbdGutnc/nBmnP2BGTQvrcFZSFYwxO8soJrCVrRwBWmfLuvix3xqPS2ACHsZdS1wo5qLTLvNO+ond3hObdV46OICgsinpBhVjKJfGnP63DIB8fkI/i9uX97etNscyY2Fac5i9KjKbpsw3HQbqyRS+HvhO8oRime/76uqaWSipKLKczGYPjeMg5OheVoCwZMRo0F2rorGJIOQJjJgbaXZjXGBxIwXPkymxUP4t6WrZfrLaH4dgpmPiaS5BYLofu8Xh5NI+CErQCLaaSWmUgkqicM6at0VqcDmPOCyJorZHT4l2Iyfu2bXtMMWVqLUzTTNwfO91p1XemCHZ80PacrRWllGV3yh4Y4zkKqIBQNAkuMYQ4rYsyw8+nx919md9wW3biWWowlrGmjucoREox5TwYeQCI27IOhx4YQMV12hhpKbXbt22rzKzIScgLEWvVp5wEb1xgjimEIqQw6lIxCtVBZfdfppff3tLViVAZa5JqQ1bvy/wV46ieLn8y0Ny276Eahi2WFGtx+/0+ESNEzPU+jodWj6zP0rbTmfcPP9JJQ/PAlqefTtvr+Fb1e3j77X29fr0j+MPJ9xwfj0PRPZr1cFJKcSgy3TcAX1ABq4KrYczbnLCaZfvlfDxJ3ak+YgIupU95vu/3K9b63kqRagCWK2Zfgh4OaDlCE7t4e71fv90N2c50WFlJlQFfpy2mhQskQTVtRlRkfcWuNmqlapM5VSWrlIRMpTKinrQgwS9SmJwr4QCFY2057CFu0FwuLkUiUlA5cR18vb7fOp2gIRInBP7z/9ZJYxnT2/fy/vp+IPrnDz9fr5McYi1MlHrq1J8///B4GG9uHzupLG9ij62/uf1t3gosDw8PBCmX29OHD+fHS42ILGhVw5YQKwH02krirEofKDg2L/i+3qZ1ieUaprYGccnu84fH41Gg24Ed95WO54VXEx0fe/8PHz88P35Y3rYYd63lMNrU/LZ7yZsigtaIkdF86EUp1nT8fDn2w7jtJWZwaZ9dyRlLrSkti1seLmw8y+NZHo8WpLSDwj5VBtyYrnUhqnnyy9RYCZwBH9i6+uv11piUw/358yNnD/cXePkGklplwLWqCfaUBm2Z5jxR8RFb08pIrrhWfk8l+MqqgAYZrNAoOsEMIUlZteY1cYbM7S7GKozG3Pa0p/t06MT17esv/99f0u4ftJbChOARdgF637b3r/Pp8ec2M8asIuBSCKmIEMoevEfgUungm+qPsu+hVjsILnmOmN1XpBGaLa4rsfmQcurd9rDO++y/alWI0Ip0Gah7OGT58fg4PHy8UC+36zWUQMwCCKEaLrtWHFUcbHe5jIfR9Kc+V5i2RBHj7qGofZt6a4VsBaPtueiifbStQzUe8ItkcAVAJTVDnlP0Pngf9rKUadWGoA4ubg1ybNAolobbNm0uEFWjQPvMhc5lTY2QHmqCdYopRdZWrSTnFL3zu2OI0FqMUKtnpWlU2bG91By3WrOwSnaKJ4soZAnj9Dr7231o6Xz+y6xv7/5b2Eyv9VHwh6PthMKht/2zHpjnb1+vPd18VW6fNmAXKdvxQj/8pVdjP33xcc9QeSsArcS9ViOBiCmeU1vmMC/sj5d4XXJ2jON16PloPklSYyeN+gcU5ObNPf8c2ywb9sfU9X3e1gaNK5KdFMYKaadpSc0pLWsp43i02kglGgqhyFhlx6FgvC9bKi01FVtLGUJ0Lm+k5PGRjmd2PErUUlqRyOciGdO19tfbfr/u291rin6fb7oh4zFnO5j+GHUXOBy6o+sDxU1Oa0HkpHKhsYq+wQ4QS3RSUT/2MaXlbWYo7++rVlkz8vPUWan5gygKUiFMWrUSqRbtvd8cmoG5us/+RjG6zlKpFbRL8QqzbLyUnNKrrieA5hbPvm5Xc5VHXXUkyZA5JWWrtaXiwzqMPSPSF3F4PGBe02s3fV9CmvjI+iPo88boqdWI5lv6xmP4XvNXkhUBmpfWZCvCaUjq8ufj89g/KlTBnmSeWAnG7aHWzJjqO9T8/jg8K0N6TIwdc4rTuuKaeAOJbOj08dCfD700nHThI8mTgdOQW4SWZK+YwLD50kr2cZ2DD1n3ukIpNbh1f9/a6mvEK/Ip1ZxCYK1wxjRvQq9C8oIVW89AMqq1hBgcw9x11hrTUvN7ZIyEUIKnlILWRgrOGRktmMxIZB/54bnjtYLzwW172PbBKBCbSHCUph8uoddQgsb9+DAeH4eua0f+sdrckAVU65wPx3Ia/kwk+4F//uHRWP7+Om/vkJwyWh57KrlwvrWaa8FW+1rS7hbvtK/rzb2mW1XyzXQGeZ/KnkskrZhctL09nboWEWPjKkLBGBIJ3Y1WatEqF1IpzXMC4q22/PnHB21kbTWVRkIx4g3Z4vwf317XFfbQUq4519Y2oUH3TFsSGkhWJmUDKEVo061LeH1df/n793Vx83Wm4jm1Qx+HY287+/h4GIZTimzdldsC4pALj9E3yAInVpoFMoOX0GUMpaTdO6UUFaipHccDNqgxHvqeWMkrlC0m6WMqOZUcS6k8F5aScPdpc0tj8YPR1btWmRkO93m/hSJakoLvERNWJWUMvr2+DqM995dWfClFMQ1c1BZrjcrwlN147PTZy4HF6zC/4PvrHuJfH47/L8U0t68wXs1Fi0L+hT0cpH8aIbuwbck1OgNnkcgd+h+10H7eUly6/kRcre/x9fW2LovBQ2kBYEc2NqjAkttgWVMJRMkPfV9KluwkhGitkWj2aM0nXXRhvPrdi8KlJCLMrSkp/RxKiZwDNGyFKdlXwRvm2KIvEzSfcoRWa2xQyt6wsb1haWwnSAyrtYOkPvgscGS1QS5Qc4o7Y8D42hmtFAymE5WgNqUZKDC9Gp7M6YeBl1eZA8MoDg+HELfp/lu4v9VUTBKIBbhI4gBPe7Di9OmJ9TKHTKDHW/jwROwfn/xiSin/8D/H5+fjoPs4yc3fFCLBzhXdt11LJwVDRL9hDC34PN/z5uLuHcFsRH/uPudy23Y5LQO1Ky4c82PH3G54IfDFxFgY06UUv9cYorUoiIqAVg4Si7XcdmXP3w6nUbSR0THE9n3yf//j/XUKKUjnV+dWwnA80I+fn3/6fLbdyKWJQKIZt8acD25ev39//fL75deXP+Z1Xu+JFz10hov4bOlyMYcxgyyMqOxudy0n5n1ZJl9rFpr8dlVEYzdyOTBeGgsZEgEcL2abVxKVg51uQXJVi4r+XmvSFqIfSmGxuJh9zdma8e7vtTbOLlK/9wdl9GOlkt79tkpiAVIuRbCOCrXW5PlAhW0xa6U6zlT2MkylRJVc44yICYTCooJgp9ftly+/Xl9eyDW5/mcRHtS3jv1Q+4+cLs+Pfc2f7HH86ePl/PWPX6luZlTSmKHvRd7i3btryh3jl6a6uvMaYljfAurfLudLyodKJbbyOjnDSvWoolD6gAqkWpv/WRvOypXrLDoN3SN2a942vlBzrHoQRHsxXJxSjozHsE8cFXHTmgqlMlZ6w9GVCkHwknNGrWMsDXgtLeUETJViOSMHPlPmJJUka5pWMfuq5ciQODgFWkqpqhaIQjFJO5NAWGKgZUP+9Y8qOIbt5dhdLudP5Sc/p3K/Xt02byEdHx5SxC+/3/atjMcf+MEpk7NfUa4PH02v7D6VnPP5iQ4fHwmwtmp6aDlIGrb1HfgeouigZ0wwlcpaECSyKbk3SLO183F8HkcxdE+MOW22Uuo6Z0FHNvBYyvX1Pk1TKQ0ZIrZtvxujns6n43j2AZbZGZ2VHuJ+ABDFdahQcrFM07e/z+9fN8pqc3dWg5tfnx6Gy7G7nIfjYeg7q7RyubroQizTGtZ1/uWXl/ut3Ny2uT253FGsNQyDaIX5tSws8r4K1YKr6xK3La0T1JRDcCy4VPO6mdstqV7tOVhLjJXVTUJGgEIMonfLfWPoJR9CKdu+KZeTzyEkJhMylkvjTB6PArDVGovGoED3Erdsz8OeNyl0TjE1PoedIR6GruGxlLHVEZutmYWYW2qckZQit9wgAatLUWHZ36Z19y6nmJfp2/Qyff3a2QP+XZ6fjx//Hz/Jy8MxST7o0tx4/mGQ4sAph+hc3dYJOAuY3Oy60fR6wCqgKIatlZoCSCGIeEix5Ci0S2UTKo3dEHLUjQmtDGfJ0fffF700eNu6pyK5Nryf5/L2Ns3rzkjFmpuQFZCZAaXYM+SU1loAiDfG0SLKBiVTROTEc0WsVKySMecCWQmm+FkINFpaAYZZhZrppAUKzhj0xJlUkrWEFTprGbuk4oMvKdx1BQ4FEFlycHfbYbDjeGnnvHq3LR47PXl/X1x+//Xp8cmwp6d8rjXksrslMmhc156ikEIZjlTn28zU2B9huU0hkAvr6WJrGoFpZELIIAQNw4DczVkI3g0DnPqhH+3j5ePxDFa7eWvelegdirIC+7Ju7+9TycV7X3NAyJ3Vbt/jYyupbNPOeYq5uK23w6kEivHdren99Zo27IiD4ayWHNvpx4/Pz8d+5IOVRqvWsFZkTJYI37+9/v7l7f3ulzWUkoOHmjlnGNOrMZfDoA/9AVGUhBBaq7VkTAnclpxrteZSi1VkLGkjtOHiuI5DEcxC7Pxe4z7uk2fIsBTimbEiVIHa36Ypt5R8yDkfehGiZ0SpeCPq8WRzFocPz4w4N/2HHw612WX+l+AD59IMh9oiFxz7jllAXQq5lBsDYowNw1hL22NJDZEJacR0n1zL4R5wTxRKcCG2nMPu1lbvGOfYCX34D52qJpYyXpogTQnbToAYfUgpkgLek+RMSglEwNzhpA0e8p5yikNnBNe5tFoo7uS2cjiBHYgCZ2HAJrzzb/e87u7ghJqz3DVTuXXRT97f7xKKUK2VDdDXloSERrjP07KusVaCRoi9YVLI2mqIHJAV2RCxVAUIuZhaViEY5pHQ9UpaXWWzrEjCKjBYyQ0/VAAixigRcs4hJelDRIEafPI7f/v+R4nU3Njy7XtLY0cQzkxZqsn59n6bbpPz6T1n2cq/fV5+BixdJ7SyANVqFBKNEYBQYl2WnTVZYvBu1zT2Q19q5pIaq6mm7CIgISWt5fP5dOi6flSMWAUMkWuraw1+bc7Ht+vC7eHttvzx7W26rSVntzvO6uVoUgrrVhatOZHSJE3tjyRFJWpS8tfvWwhX7/xoh17qnMuhu+RUxnGUmumOPT5cjuOwOB98qa36rb59u79/mWYfnU8NZqhoxRDCokR+epRdV4/HYy3UWGCM51CTqzm2ELL3NcQ95whYtYeUBiGMUiPVOr8v2RWGjGGWCmrOKSUhFSMCotoo5Co5pgwxVh9yTEVrhY1qBKO7Sqo3EhBbQY3cCnXqxpftuw/+8cNRdkNIoTv1+rTxITWxp+pFk0b0RNByxYaAApgA0qOKWAgUZepS3ZbAMlEDzCm2mLOk+te/fZbvH3/6cbQqVx596rujpO5l+d4aOxxHn3Yu8fD8rLrez1sud8a8tZaJvtViNNXMapQ5qGmK675KCcuBaiKWx5jz2/v6+1tsjRWIp1hVItahC7n5wnI8jwpbQ0z8xOe53G9LcLtk+ePjkGts6JEVaJIzs20hpUwcWWmMqAEHRGgdAQneWDUIpJXoNcfEsaExneBcKZIcS0UAENISUQwxlDUXzxD2KU/TxqevkZB3MjGo67pMvvgZdu/fpnvhZt6rS8JH2ENdd//tb3/vu54fTuIohRSSZEzRlRhCoguFXUS/qdI4drqrnJ/f3+4ZJlUlNgiOIVbnryWax+NTzomrz6FdU9n3UINDsoYBY+pKXbk7+fXrb/viOOOAjRgNnZKSIeSuU1IVQTBoqzsw1naWcir7ti7vuK5eKn46ImeiFbGvGkds0JBlzgUnue/RbaHU5r0LnkSVR3MQcn3LLuaVM6W55lRP5+75sX+4yNZyaa0/KFb4bZ+3xbk9x1BSqYDYsOVaUq6lJACAIrVQUTTAhhVazCWlWluBpvteSFkR4wYguLIiB0mN1Vr77rIsW44FGNPCtKwgbENvWU5WNJH3S8fEg9l8PZ9JH5U0w+n55Nc7EwTIW2u1UImt1IwVBKdQINeElbEeS6hNIkhTRReYjSXU1jIAK4kHr/Z0uz08fXyQ6qjbrxDBCEtR5JCIAaOkBdOjPDycS2vrGlLIMVQKzJIUmhHVPUS3R+/E+/u9tqUx2JOpAbijJe7f3udf3nbn7obiXx6JLtR3prC4xxZq7a3O3vXj+PmnD68vyxb/ur7vQoqnp0cmCjLY932dUfCh5ritE7Ts/EI82K5jhNCIstSMxgNxdk6pUpMoghD1eDxia621xmNNhMhzMTHFXLDRLHgjzqmd0ub425d8GHil7xIYQUVgOZXWmAt4v88hJhdSimnd/cO5SQiDOWhBOUQlFMOWc0IhOOu3W17ekuQqxtqpA+DOhXj68Mmlt1Jja7WsXGlJyHPlpcpl88vL1ZWXXPebvWM7/+lPn4j3UpOt4o+XsM5ei04bXlOdGVmdsQTB2XE4dlYQA6VJ675UrvoOXX5//45Vad5LouQzULC2E+Po8+7jPgxaGd0qxZiCL97H4AUnuByHXvXTLiCn3UGKFdL+dDL//B//+fmhM6rm1Di1VoPSo1GFtQi15FxTTAiZAKTgXce7oVNHy4SrzSNGav22hOq7aUqMcLjQ4dlKRZWl8mtTmkgCEgjFpaZWhdtLK8G/7vuaLpfHXmGL2x+/3Ead93kabLZabS6bjn7+n57Hnz/d378IOCMyLokLIMY4o33z/x4kLTUhgRAEg8xrqVqAhirXZkxwMeXaULRUdcrAiXV3D7833HmF0fYtt8XtKHmO6ev76+PHBzMOjPg8zSHXmjVHUQv65GvlDERwNaXqw9aaHw7yeOKF6VRaCPF1jr++3H59mdf5G9UNox2UPeaOuTSMf85FIrG7f0+E4/lH1R2G49PmXrZtebsv/SCtOZXEUwzEjNKd0cLFye0TilUZLoRsgFaMrGFtW0rYKillGSXOK2JD1NCg0c4aKiX8jrEUIYgMGNsJrlh9khh4cnEuWatyQOr7sRbBOdu8L7WFuvu8x7IQtlpjTuvj8Z+sOrbUTduUam3GCRULRKts2bNCBs4p0nmvOYvcNiZ4AykYEUMHCyQ2mLGW+fs9fn2Zpuk/aX7UwmB3DQUWL7pOn7sDsvrU42T7HWJML5IpI8Hqqrk5HY/Plz+RXIVorfJGmqsja+My/X1d7rw+5FxqA78fS+9d3u1YuWAfHk6k1lRaSHn3bp7S6/e7aMdhmIiXjnNzeDjq0+3+ep9eUw4//6l7Pj12wvolStlqDWVl++b9UoIvCEAI1DKW2PW6l1UZTpIxLWq2++pqblryUtdaWIG9QuqeBvuDbTVAE+oauwOW6hpXwFjIqey8VSHUWkKL2ywfq9+Ob6/7f/8/pGRvWpeHyytGGJSx8jiMpllgpQ2p+W3FCpAVEwobJ6GWfS61oIiCU227xXOpjBVDkjIAdcn72eWs7acEnVdq7zCDc2E2XU8NYkox0YZqYvK2byUF3doBEABbLh1XGUHQnuittStA57bB76KWtvt3UvXpw9PD5fz+1bGSN5y/L+Mfr3mebxwXxsptC7f668mrZ/sTpqiBpTWFKV7/uIoiamPjiLUMLy9+nq7rikomRJnp7qoHoITSxRwSMthDYJxbLHallEs1lQvcDr0p8EWyjppwy2q7wgU16Bh5SWHJkSlWGHCl7eHc2Z7lU0lX/uPzsK13I8qHD38WXLot+uQJi4SY9jdBreIy9Pnh0J4f2PM/nLQZ1w0EOzYMw4PiTAkhysLduirbgHvJYV925/omSo17rTvGQ02cFYUsEzqqh5yuMS+Xh/NgDlKIP/3l/OHTgQsQOnaXS2Npusenp8Ovv34HL5tYx5E9Hh87I8+n4/FYtgVZE93AzFkPBxnidZp8LoZz30Ber5u2u58KUtNWPn36UynggkkthG3dVn599fsGhO8h1PNxkEM4DOpMWss69EJwJhWLe76HFbESkZSCOJqupORqC4wYEUhJNTHOGTZQ3LbC91tgOPoFoTKpQOv+9TZVKofLoAaZ6t6wVYbdydq72RcwtuOMr/Or232O1RiK2REhVP3yTf2X/+OP9XoK4evzc3e6cC6ZPgxkaZpDJ5fColJnDbLknFKuKUNriBxYrZiJ127slSVuALfEJHVDPV0EgInRZn8fjVCns9JgORI8xP1Q7PAe5hBwW/HtNb29bPt2U/q3D0kwzUDJUl32XDTJGwALOR05ty4GpdRy3UpllX/Vh2NmAWqTJBSntLfiATM3upOsdpKnbU5uMqo4evPLtq/m+1fuvU7xN22hGzSDTglyrWXnt/kVUBa2AONSSu9Fzg5xZYxaoxQbpFpwKa3UYLUMSmNqnthQM2PUwjZJxa15gFadK63y7AqwxgWkPU/7DBH9HvnT4VB7pWV9/OEhhJRy4KwYgafO5vbUoIRsHkYxDN3z8Ufzcb08DJ2njLwUNp57XlRwbnsBv6YSZXU5U3BhA47QrHO5RiYh15w5Uk6ssw8Nc7ml2lpnL12nLudD37FagKSokJLL21o35zinceiYHUh8uVz0sb+MxkpOKb8A6KF/OD9hxFSqm5b7thdoXSj3CgepR6a+WdMhA63qvi/OV+cVCNeg7qtISRAxgGtM1FCnOge/cl4YlkNvGWPO741YSpUxVhA5SFYF9sB4Exw5r0RFKWBCWiWJEmaCiCWyRlvwd2uJpORQUHlj+PhgyGAoiUsNbBAWhssIrWsJodba4rpkBAjBbW55fn5mdPg+sckxH+cQ/6j0odKHRnxLLM3b1/+WhVlOPxTQBRqWCt57rbQ1xvkoJIdaqyiyU9yw+7TGVLlktmeXB3MaPh2Oauit7XrOUUg0qgJFX+Y9aVeO396uX/94vb674FfFQ0eyNc6wqw5DgM2vOpxLKCn4uh1XV3za0GRg2VhtH/XhQdyX9whjYzwjbCG4mGJqmTdkpTRGhh0eBq4xL59buTG+S0mIcr5Zt/D7dyj1rdQEwKh8aGVFBi2rmFOTrbZIvNlOa9FrrgmoMUQmWoqg37kaQgYB57XspXiFh7AQLGw4ftdMlFSgdg0ZEQtuv6bZ7Q7iCrXx8+FYa5AiIg8tBhLJSgZFtozIVC6ZlHh6OGJrHE5vL+v9vsYI9ig+fLwwoyAKd32fJp9TxNKQrX4Xgp7GM0lxYsX7WAHuQiSjDHJ5uhzL/q/qOzCi1qyP/j7fx8Mj800IIYCub/Gv/+O6rS2m1vcdx8aoe3w6nYfhcjymEN+vouutkMztsSLl0G7f674QNJazJGDj6RDKmiulkHAm5mNtFGPgDJXWBXPMLobYWuKQN7eF7JNcOMVaM2PQWkPEUkophRgRYQipFJCJEeNSyliSMUJyXnwgVq2SHAkq1oioNsZ3Y7XUMVd/fFS616ZXyEpNmApPVeTpS4PE+RHBee8YRE5djD6k7eHj4S//+Kdtld9uX9bk7+vL48MmO/92daQ725Huxdt3CGk2PRs/0u4da6WzVilVcoJaiFhjvFIFwBDiurYSUBI/nawRWJySih/GASV3wXed4QL5WI+nk+nP4Vc+Tfl6f1+2VwZltPJyfFJsLFu3RQa1Rypui9sUUwCeW84BqOa09INpRB9/+Kmzw74E1Ko2Sj4UqiAQeV32d6OYME/nx+Pl6SkC5LJxUVpr3SGWUgDvNZmWqaTRxyllJ9WvQvZS2pL7tu1xz5UFTtRra/SIrbRWhY6VAVHh/GCMjsEzmWOStfaIPJY9xhAK1zLVUjhyhIbY2L6UHGOInQDBib9cvw6D+vj57DnPORslwbZWW45N96OLoRE1IB/9v/79l/j3knLkiv/8H/tjdzInBiW3FHMK2KogJgVvwlsDQGJdvqbYSuLYUMpeqQO3EkgUOH7+6VC5otynvLiw5nw2eui6vrF9nvz9FmIGtxdoLKXfjcbVDedzcmkptUjx0HUaoLU6COFqCayiEG7fb4zZ40Pk8n29ujUsQlCBc03a+ZzgbmVPiTNxZ8rluGNWhe3z9q45NpUBaspeKUFEjGppSUgB1KTmMQWEEjyWCrWAFPJ0FNHHrYSSvZIHJbjmEgu0YqySCCW45vbChe37A7DKSoQI87J5j6y+MSDNPxQNLTrRi9CbZc3HS/9P/9Ofje3+5W8vf/v1+zQvStYf/3Q6nbq4HUNhWBhACgGVIqu2rjc+BMFw6G3NxbsV4N9ByvvhpPqDc/eWu+Rj8ZmXEFwqe67Qjg8Hc1TTNtuuE8qMz0/IxPdvy5ffX90SebOsqFaD5PJyVpeLZLQzdcLIqOnV7ctaazCGZqkEkW4220GIro76BzfFFgUAlpyzc4Pgl554Q6y81/LHp9MoVVwiJ2XtTKxMMUsSjXH1GPfNp1ApHvMmfYohY0vvqdw0/xFbW+YltUkp2XWWQd9gJ6r90Ut+YtinrLRpUREirhOWzPfdA+w5hxDsyndGIFGUlEuORjvC1mptsjZsnEuKJdy3qx4+tIqlsFKrUIYHuG7Tsq8+BxDYalvmOXlkVI9n5Zay3K7HJ4apYzC22sJWGtNSqL6r2tDrN32bvgvFlQbBLGMcxMI7CjWSCc/Dh4bolxKjOh6Px2NvOykVm9Z6v22t8mm+7hvm1EK+XUZ9vy8PZ95boRRpvDDhtm2GIqMnbJyVB/n/Z+m/li3Nku1Az92n/OUSW0VkZqSoqnMAdIMGdlMZH4DvzitatxEGNI4oFRliq7XWL6eezovic4wxvqGf5zVQPUxbnL9fnTOAqeubbZXHUTgfsphsPRG1bX8FaJhLWg2i9yEgHzY3930HiPPuAFkpIoEtg1IFJOWSEid/czmXzclmsKfzWEK+lLJMV0lRkNVaSpLXt6pNk3bHnEqR2NDb9/fVzWagyuo2rcxx7IEZJOLQY46lFNn20A7Dxz/cffjhhz//+e1vX77dbpFZ/vzr+eGBiHTOw7ot769vcp7KIv+nTz+f7orbtuS91JRcyikLUilxiFEiAOcS0z7X68vmVp+mgKtHLr2lQnN7uOsONquqjTXNKBu7bPG//8vL3//6uSQg7kRuiOg89P1Ap3st2wxWvN/CsojL7KclVJe5mbQ+lKwwV2IeeoVF7vOqoAdGRGhF/nAWGPtteLJkjBI/nh4xhPltvXsw2R0bo3jcoPY5J7cJbNIU55iWmGMqsfpPMf8PkvOhHxhsKblUXyhyBSmC1Kltxf1TK/iJcNjjS2FTQXpPka+prNGzQitFD2LZk1Mka/Yl5ZSCMtB2DQErWQWSDJ673pDo0hbdEnbHr0tlxteb38N6na4+rNp0OVVmqajhutW48trVNaSrI3HcVjXtU94zq36Emiu+zfPXr2OF2jCZhoYHQOFcmiv/um/FNjOJQUFJ+i9WoJRSSq4Qr/Pq3BhzWfdl97CkLeUkucu4SrNr/E3UmuJew5kT5Wi8KyGtQlJBUTSLXu7x+zJ9WJa7Zf0e0ya1Ow6nApMUmApX8IfzvfA2B9M1dvJXzmPOCRopqVTIwETS5FJ9YiqEQjLJMKdxHL3fmYNzIYY25ndBtaE7K21tGuQV8n2NqphVFGlAA6tcsxBE6JC4hJ3loLW860alTAqESNrshZZuTDkc5I++a0dl795e8F/+x7ysVVbk6u9O+3j4Y+bmL+/z1/f36NangTi8CHEn9Mf16iUpgSI66/a9xLhupXBtxgr2Jae4XR/i/OXy/XL7HuOydq04jNt4l3TTaUlK9kQ6ZChL/P3vty9/TYFxXpZGkJBvSgZl3OH4f2PoQdgYcQ/0++f185ermy/oX8WpE6i6ptPYGDWUyM/L3zjBsbl30je9tsXri7vv5D39YtVx6BujGYTUWhTloJ6lIUFe17ZTXXl950UQF5GfBD4LubO+mfwhhrSHzSp9PIwIUUvue3vs9HiSw0Ebeap8WpYcw7gFPy1bQi4VfWatVCqZBGWvSLLWFbJvbFOysIqwZGOUlqFVnZR2Oj987If2OoUt+lgwxnC9zc7HVHZFmVRV6NtjD0VUiIgwHtr7h9q3pWzltv39y9/+5i/Klgx1qmjma7lt8+YikxOmSSwqUdMZ5AMjBkxAxm9l83i5eiXkPN+Y5aPttJE+uQpy3bbbtPvyxTZgBUiRDodm7O2+rvuaFILS/TpV5+XiN6mKz1+zf6zlTjR/YzEplY3eACbm4lejCbRWTAdQb2YwPp4BXdM33qfpsqdYLV9FsSVC2zSFmTmlyihECCnXKgTiHnzMNeqS0JeX7KcKa4MhbYtWQuMHDjY7Bn1V+l5pkIZioX1frTGFy+PTSTft5uJpPDrnS0VtBIrXkg+nh1MpNy5Py5z+/d+Xz9//6/Pze4ojIkpNuqk//vCHkNt/+XtY1s/BLZ2Q9/0hJYxxXVepla1Cx7UuU8hxj54Yq9ECvMpVbK/l/VKvM399WfN66xpIHIeHA0rDSFKy82uG1OTHOLm8pPfl6p3LIh87YZvheLgf+oP3KaNOZPZdff9+va3vt/fnDvNiC1M4PT58+PneufT1swu7HzpT1NY+dUo127P68vkhusWQuz+9kr7jSsEvanso+QG7m4Wu7bCibBobktmWHRWUWohk0/SbY8S9bwpiFBj6cWjsnZRkrTZqRPA5Yi0Yc5o2P81XHzaA2hrJEoaxUdrOs7/Ny3TbGjMjWKuo7aQgoQg1sVHSSGxML4/3+vTQCVTdKPeYQ46VMJTkU5CinI59Z8fBmsf7Byi41FBq6g/2P/4vw3j4mFz37d/+t99//5vx/9QOBmXNZEL0OYq2T9LobjDtIEMtYdvASG2zGSmzcoldqJsXYQ9+9yGw7nE4GGkaEFkaTjlwrNra3uiP5/Hp+DMABAdcLEu3hzBtt2nZrutX00isR8AJGOp8Iv3S9Mk2XUpjyolKK7WvtClxDM5eXinsRphLTd52rQu3eX9dv5q7rmiVtGYAIBCCc/YppCi1JiV8ZEYQ4GOK3reMKWe9pC91t83xbKSRehGUy/YYuKa0KYNSM1dS0rZG+hhTqm4PWsUUWbeCBFtrFdngw+F0fPli/tt//+9/+cvndQUSNpet1F3rzCUpUhkUl1RzbBtlFPd9KyU5t9d8SpVuq3PX3W071yXGqI0YsZUSEaT3uKw1JJ2KLACL99qFVMdlcwVuGQmQjQVxmHGcoF9g5VpSrMna5nAYuv5xdXsunD2APF/fi480z1cfdmNEqO7Uiv7EutHTEt8vJW2JWN4fsz3dvT7vn7+Yl+sl+snKJaULkBrbNtem1iq10yUD7sODIIWZk2yhP0vTdtnXsjmCkApiTlyCVKnRZBQKQUSSWYRM0fEWci1+9XuIOfqlFGeMapXQ2hhjCuqS2TunrDLSGDKCWWMxSihEJZVSSqKImeXpfC+kEkIKAG1NyLtLOeayOjd0wABCiM7q1mgtlJYti9oczfBwB2qIoYYgATquwCyEagJBAbBNa/pg7aCUVVaSlntwqKRtZTPI788h11DAV6ZlzjmKt7eI//L3//K//LMUpWnhcBTjzAb10Im7o/pwd5RA+3yDPGCV07Tf5jLPfvH7lmoo1YgiVcop5SQtai0sqGsJD0SN7aOm+xh8xsvlAiR00+LuUwjQ2T/wfX6fv+/7ZBXHKqWXXWNMo1RBH3yKBWopmVNMKESjsdG6sRD9j5QtwaT62TRrSjGDqlABJcucqbotKQtSieyQQFxflwoYCxOHxvYAmzY6Z5mr6w5dKvj73937awJaRP2x5EL03nc4Dk2rKbgdEO/v6P7a9516GtLTqX28a2QFIyRXXne3zSVFn/JNWbB90594uJMAoumJmKCAoBrBVXYgWGiZ/+FnaR6GVjdlrR8ZTyQ2wW9Qs2n4ODwe+wNkMd3ehGpIm/eLu1387TblELUiY1LT5x9/uTveP8TUTMu2btJvHkX66Se9b/D739fnr2Lnf3HpmkrgbP8hvjCdNuckvdqLCf/Y1951zHVsW2vb7GsJCV4whmytlXAMLqDYrR6BNSCkCiUREuUEIcVtm0JchUApgGv2oRiNQqpaakybJX469/eHPu+2a6yiMrTWaMUp11KBmAXlUmVrf4ghKZOdz86HZd3X3a+7dz7H7LadamlaIQRNYzuALuO57Q44z/FwYqR5NI/5IHY/1Wjt2IPaOmO6rmf195pxW/cwge3aEHN7UkrWdhTThTdyQgXvdwRjlCk+Tu+XfQndodyde64H0zpdhkPfdA3KMpSARpJL8nrx7/O3eRMxcRVRifsSwalvFk+Acjwba/uUy2WN040YQMapq1GRMCOTwLazBbf317pv8OFpadunh/u4+/+6xElkmdlLdW+7g2IyymoBlagixVRyrew6YVRzXpJoSmalhJVEVJ1XNVbeVmmqtVIrmaKPPo2HYV/2WkuNWZkGkTFzTcnYNm7xNv9uxE+H0/j1879N107LsTEHNlgZMhZQNHaml6Pf3pqh/PrbMfOvAvOPd+HjPZ/vGufbotda2WEkRGMkCS0tm8YKY5msoI7M0OjFUxoaLDErBeNBdX0jlTRNS4oPd0emZXn/otmPjX8nIM6tAUOoAMIeKl2PJykETJfbMk3b8sYRGisOh3D/ZB4/nHJqrmv77bnMLpe0+ff99Fx6McbVC6aainNT1i/H8T9kId4nsfLXzLFO/geDA5hTyj98/A+AWDJc2Yccx0Mfw8ltQsJYCllVC08p2JSIBSjdVqR1L3t2KbsQbA0TQbRtJ5TKzJ4lRs6cw7JKZKNka5SvQ9sMBLsVQiFUBFSqFnbRV2TpHKSc3Twta3x/Xy/XbVrKvPlYUtkWbm3pWkDNKEDy8WCPp142FPbA1mHxh64x4v779p0TaEnKgLJ2GIctNa4o5/O2xu/fl5zLQxhOD13bt4pUY7i1UjCPveUsas6HYbi9XY+HJ9Ma+0ENvYCloSJjuAqyY3OK6RIizovf460SZoxABcoTVNnYrrHa+8il1x1kF9bbj5f576k69/bepHh3GH8dnk7nn9r+h98/f/v69fO6rkn89Z8+/T9//vRPy749f/v37PeS+8MhtDkiCC6xsSJnk6EycU5x3dy+hQFqa2cpCvClxgOIA3ID9JKLrwXyJq01OSfGmJssFcU9WdU0TRNzllJVrDmKkGqtnkFcvi5Y8+mg3Yph6+9G6odxmkfGehyHsX/QKjWNEsZeLza43Zim6Qo3WhdzsEhIJda4FgRp8MwyMZlceu86RFMSSUaFNLQWgJXGw6isHgi1kMjSF0oAjdiK8XiSVH+818IZFTa3CVkB8dyDMU1MsiT0zlmdu04eD/qXn9rffrk/HB6eX/jtPb/fgksrlrSv8+fP6UGqvr3/8MEE94mg6jb1R0UC54kv6TsIXbHF6c8Rh/5afuFJdH28hcIllyKV6buTRIXZuj0KyaE0vtSUcko5QxJCogAFhrl6AKUlcGIoAIYZSqWQmAFiqkRMEhpBtm/brgshQ61QiZD+QSRKo3Vj5PevL7nk59fnl9s6zWnfmtXVUqmWtZPx3PajMI2gj4/j4YxieIzMr3+fD3d6q4Fk1//Ao+giPe3vfofbmQahu2n3X19FSXXfaZ5djXAcTlR9jSWtsaSzRp13b2VrVKk1QF2VAE1dcYBYLVAsA5fKsUg0jH5zz7uz16Vcl+RrT9opI2u5U031YVLwwJklCVQb4SHHvKwvbl+Yss/PIp1DoPH0cvfLf7lu+dtXmqbL7m7uG5zb//Yf/vQffvrtf47L2+X1uRseBFq3pz34HN7/8Osf0v44+StnqJxdjTmncJ1O7dC3bavvbZuJZiFzxbOkkmkK0HqPwFoLs2yKyAQXm6ZJAZXRuaaKZXuLRJRCb7qvKJtBDvgUOG4n22tNjVX48ZMZWyGxG3Xbn1PJ+20dtOmUiiU8X+Sx6lyfSf1gVOtDBJ6FFCRa0IIr707vewlhul2WmsgIK23TD2ely/mkJN5JEk1LSW63a9L0z0JYxPfHj+ZMMB7Lt99vEcLO+9DV4f4/hty75R7ipCoc23C+Ww/j8bcf/unjD48+0m13n9+/RgxbusEsSjRuyZfvf/74Ax/PxxTb+/yJqVek51vaQwi5yZWFFXs98IT9O9xeP9+ZT0aru/PAUVzetxhiScDhfWgGv6eQqlQlFAeEe1xyzkKokgshnSwV6oQaKBUjNQIqVEi6xFqrjjW2qEjrwyiNjtuiky/RccpZtcwqPX069Oez/PbXK0O9XLfXa9pdSgkzR6xBYTn26u5kPjw2P/5wurvvK/rPf7nZRkzb93n9aTxmYa6nc9vo7ofHPy7q93V6i+kQXH6f57//HkN6YYhxEYZs6YmM96mvU43sKzWLizGDINDaQA6Nlq1p4+ooYi2wTUkXLVGwuuSIXLRf9HR7CfEW89qqnoStUEhrifa2XZxfj8dRNrrE4jZPkCWy914JhbQdz4e7R9kNw/f39fX6FxfWmNN+NS+vn3/+dOr6/9S05v7+NA4a0V5va0rfDvYulYZV3iYIWURV20763Vf2uVIFodtBG+W9V6ppzYd13fOeE6UKXFIiI1RvQ9hy8UQFBBWGwkVpkmWEDK3ojMxKgLWBBDbjsG1BCixcnj5+pE6t0zpPJYlamLyXtW7zPBtl05owmJIGfVyu7nr9kqBu1CghEMuPQqvb6+319pfgclhty7mRRps7of5PpkGjN2W38TQoI/16H0MpckJozdjJlnTT2q7zHmuZ+kEejpK4qQWjW0u4WpHb4XT3WA7D6f7xn8zp+e//er1cflj3b5UTFIqRJDYAlVecv/vzA/36R2Hsx2k6fvs8xXjLHHO0lTatXhUQispQ5ttklGnaVlYdt32/prgUrIY9RZZCSm1E8KtSWinefMjVMwWU2VjdN+0eUSqNkQVLBCy5Qk0hxJp3qRIjWItK9esSUgBgRERrW1I1ZpRkNRnJKXVtm02zNlRTzHHCvFuFjVU/3I8fn+4/3J+GYahZ3GZ+e5ky18u8J/z38WDHAx1eXv74xz92yuwopRxX769v+5fnt+ubYVrblgkPuXBMpRnFeDyjUJFwvdZtc6Ww99kY3bW9VdCaVkCFxNHFGgojFSyxXLxrmsYo6gV+0SoWCEoMWmlUCUyvKs7Ln2/zS9uhUh+JpCTVtyplpVVb+f7Q9Y/3H2ucX38v3/8W923iUhvdBh6n5V9fL117/uXx8UHCXanieoG366abrcdPswMQ6+u0uBCrnUbssOLh7vBw/9DYxtoul7VKEXPNac05a61c8DEG4ILGcA1E0BpBkJOvgiUJsqqFVu+7AxIZs5KiaOjux8p8FIYZdueKNft+K4YioChYikhBleJz2v2y11i3637oftz88zLvdbsbRgCIzjuGH8HV319v78uXeXKq/vCo58eHu9PZSH0vNRWR2rHqRgRn4q6IglDfsij3H44l4tevwdf44dMPl3d3vB/aDmqywfG+zVRvx46UPFhF4/C0hMvyu7nOzXV7hspQavUO+DqMrW6UyQN6pajcf+Dz3d2//Y+15E0I3XTZJ1vF1g9Lr+SHD48//vQgczc9+7kIxWn9jmmTVFmgSORjrUIqVKhYSaMqsVCmSYmxcq1aKyKSVLGKWhKBSClraWLINValZKNRApcYPKZ9T5KkkmS0QcLNLTXDy7fr5bpIo3jotMaxqm1osg81RtZCNsL++HB4uDt1nWKkxCLU5rZ8X9Y8OT3X39PvwUj5px9MDuKf/tBJ+yhSN6+vf/1y+fc/f8U6aruStDLvNdSJagoKkStH70XwDmpSkgSUVuvjYLuGtBA1VkHU6gZShsJcM6IlNMhKK9V1bYWAebdNUboASZbarSHmdRj1eLCN7jgDgWhblYpGMjE1g+4wtq9/S5dy+f48QY0CoKbCWKhyTTmH3Ta2MdpnuT4/v6/zUcub2+p06do+lrxsc443rm5om67pTudHpUwI9X1+Dd6VuFuxd62FeiNUhEVJlMTZ77pTXKBwFUoIUDWz37JoMuVUoRZUKNsIiFV575tBVxLYNW/TkmZEBm1No0+vzxdSjtJgNAb/bXN4nd79Ca1x67xZsoQVCXPGze0x8/t12xO9v++qXo3dnh4O58fcHnLhOvuk276C8HslEAiQ/ETNuTs8uXmXYj8e2iBaIce21dqIsrVuW4NbrHF9o2tqIDEXyvTi5//zPJXF/++Uj5hyS6hO7niyAquqvZEg1WbskYS+LfF9fiPC1kpgUs1w/yN8+nj48PRRS+sm4ULwE2pid9PRbTE6Iq6wAdpSay6VAYCo5EKgFSkggZKklLnkEn1MWTBKJXIMijJiVgqUEApQo4JErpbKEghJsNKQc9FSIaAShohljK6k7jweSakytiQSF6gZISsJSaEWMmMbSMniMoh2DZfvl+vztgksjd4wbqvbh/af/vTPfxqP9ssSX97+Nt2245nWea8xn7pwaAZJoYbeu9mXfV0+1Jh6g1UoAdRZAZyttkoINFQSAYIUhtGnlLnc11rWLQJNSvVKlLF348nYxuxr66MVnM9je3f/aKzRqpmuYd+d0qwsOedTFEWs6+Ix9Ct8R96GNiVQMZTG0rn/obrudblUvJzvjsP4G+tva1p4tjhMqFiJozLA6LlWIW79wP2hbXuNZN6u28vrvm+rYDl2onKRakExNkYZRUaCEkiVBREycabsIeVaCzbSNxIqmZqhOuXXsC2T1FIKb7pWtpZz+v796l1ojXL891wXCR8jvZVaS/ot4e9RpOd17Rfn9xVHKNB17UHg4JjD7PZUpgl9kFVvIe8ubiDuhjtbgXg3yjQ5l4zXRh1Kgrg8ElqexP6W748jVxXUcLp7Yi5Q83rV3mNKXptNG1VYt+NqbdJDH0rxcUlB6LJr4EN/7g/F2nZZI6NBlai5Iv6X5+f4+ev1ff089oPCvuvpcDIPh/affv3PiBj2QDVRrVDTsr9ebtd1iSkVpXQFAoop7ynFWisRVWBE0Fp340gCSw05upiqdwXyii0VDrluQkojhWA0Sh6GvpOiqC5VTGHOOV+vSwypH05KKSVUSk4KpWPOXKE3FtAQFSwUQ2GSFRYQ1Zd96Jvxrs9t5H/dKhGLyNVUSrNbLV+Exj//Hw9N9/tP//xrezo37ajlLKmAkJ3tjXTWgjWiFppu+xrnZe8pVcSspGqUkgKpqhhK3+nzg5mu5XbdgBSSCvueQrP7sO0bymQ6LRo6/9jdPT0a07597f78t+8xe2VaYH19X716jwkqBGNkk7Xb9lIEYgCMzGOjPfVZgLX3R+/yHNDt6eU57/UNxXvbqseP3f3Tqf3dBIfr6rmgzFeltqHPFftWONvEthFKC+fDdbque4yRjRSlwLq6w0E3jej7Dhi4FEDhfRQSlFa2UYSYY6wZMJema6w16xbneVl9WtLtdBryOp3uBjF2hdh2uusNwpoc9n2T/Y3cY9ivzm3L0pBofH7nOiEkZaxpxfHuWOi0Zn/bNhf29/cdQWhVu4NhCcsmDq5lJK4pF84luXizuo2hVn/XmKnk95wvUp6WZTkcWpYagbYpSCGlQGVQaVIaNcnjx9r1OtQ7n79UWCSeAb4qKTrZtOJRVEl5R2CkCpoLHb69vry9v2GtyLXkSKIiqBrt5euaUxGoWiulEtVevF9TeS2UWapCZvc2xRxjymUppRKS1JVIl1ojXEvmylwLQz0SYiwu59JaqVQyqjVaS1YaiEvxOZYkcoUUPWsquZAQKUcjmxji4le5B87RN3XtT8yMyYPgpqZIsiTaqD9hOx5++Lk2Zn79C456/T3VoAR8LlUWaCefZEjTm/v8b1/3ec/d6Ti235W0oLpTM/Z2aC1QvbvvTNeW1IVFl+zWPewpcMCdttdLODa/LltAUbr7a5HdnpP3lT37TRRel32/3uZYgjm9/Kf//OmX//S4XB4+fwsvz5f39Z25xlX5HbQ6AMdadikzZGnJPIx3XkmoS65wDTcL6mit1L8djsfbNC/ffn9Zoo5U6nuLtzgaQf/6pz/+uiz7v/3b/yfNBx9llH9+Otu+F96fOtlrpTF/2mb1frnt606stRDIIAhLrlAOxV+ak6ncuEwhMJERoqZSNSQjVKNF9CE7WbUoTV6X7XbbUzleorm8bh+HPdy9PfzyY/z0QT+E02Gsvslrub4tYaLkA+eaPECOhNhapfPcGH0chr4XbSt9UW1LxqjGxsFaQbpVexZjxju3D8u7Q1Gp9SU1pQgoDynLkBfSt8KnmC1Sn6NWsvjyRRlRs7DNAfvk92BlQ3QHCO0xmYd70vfh/bGExm0T8W60arQYu9Thn/Z945gQZqiYQGfA3W2U3j7an/vWUBNSJI66znrK/2bMgOpQqRNEUIwQ5XC8+3i3aKuY+fp8ev5+XZboA/rFItqIrxIOhMfVzZANoSz1vdEHjtzZZuylpKqh9nIYmnG0h5T8ssxMLGqFDAo6iAjVMsSM/I+/Iq5GUu1jjE4go2MGo1thWCCjKCAyy9QdeqVrxmQb/nDXfDb0HkWRIeTiimYWcq/5+Brmw+u6qI/8h9/uL9cveQuIMufS2XtjxaE/atX4wJghuXqd/XV2EFbiHThjfu9bmGbsXkvYqt/2ZaGQ7G1Kov1c+bDmkvG5H9PhQ3N5fvjv//X9enWvt3+vAZTQxCiaJpUkKyJpzpiSABaSZNsY1Fiqz3WPnLQUbfsxOMpRSVSH5uhcDM403cO2mNn9t5+e/ul/+tP/6tz/8V5ZEw6H4zg+VkalrIGipLjN5dvLs/O+ZoEsFEnI0a+uaYyVChBSjkoZoup9ULopReWciIRCw0WmsOuzCiV9/7q/fNlyQh/dNXnCyPN7rrK7Pw4dqKEXWhYiJczu4vXbFmLOZbMWYslSoW6o51NrTN90XaO47FioMaJv4+Eg0J+QGUGL/MlvJvj9y8uf+8EebE9SKkmHO0i7zxgFG9re8sYWEY9Gka6gUsmIWEXIVMhUKXrbdLl6O/DQPISg3Zz2dQ3bJjh3rTKK+qFthZ32d91jh3E42q6TDEmrbKU8WzOOXUGJhrBUFdNKCjRlXkreS85F3g1PPz42/fnnWdvmeptC+jCk/1EgxDQAI4Ll0jDhui21WgGc0m57p5UzUg3tsVXG7ZtQRWt5PLWHzt5uhbwk7IApZy8ESalqjUjqH/kJC1LSSOAco3NR1JKFFE1DBT2riKbe3z8Mx749dyF4yerDhwex15cv5+1dbbndbs7noFi5KFJ+V/CfHsafQPq7T+ci/vT7vz1///uLEApRt21nmz7XNM/buvt1rdclX7eKeWoEWily2ZTosfD8XrZt2veU47CE9epuWALwXHV9+sQfPvzy7Wv42/94m7d3QM5JcNiVKtbaVlcA7roeGJzjUqByEVJIzWBlcFDSU4qBWQM/A2DOJTtTc1GohmZh0m/TRv9ys/Tn4/HxDz/8X1X+S4yeGuvTGH3etuUSLloLY01KCQklia6rJSdQsdO671TTJRJP21prDQxUChWfmBUAeZdKugIwEqO0PqbLlOeVliWsLi51aS1B9YejUgKlcagFUIKMQAa1ZJGBqhC+s0RUpSKl8CA/SpKCR43IAZhz36jz0W77oGNbYgm7dfHFXzMLeTyofU3K9KpPp4fBl9fj/WP9ssepX1C64MfjQcGqhCUcsbIg8PHq416hMFhGAgKhKxBO83y5bm5/rvUqsArFw3FsekxpL8YND2qow+Mvd+pD2UIpALk2LnvaRYjpcJACqFTotbRoajJbmt3umuP1x1+ejLFxo+RF2DgVT3xPVQn1V9ncEDkGrOXmvTdqJ6EZs+FPrZZ9p6k2OVRNPVaPjLWWLUwuZgbKRae01JqAWJFse4UkiRQzhJRi2uXTh+brl2soS2uOygiWHGm3rR7u+v7u5Ly/vm8h57bvmq4dWvXxw/H5S7jeHiZ8QY6KDBSBEIioZj6Od61tDuOwHuLNLCmWPfgBTIEoDKlW1xDf5uXt5ldfBE6kGy3akFbGhoG9U7tfQk574D0+g1w4H3RbPn46nx7XfeqCV97lkC6FffYHWXclQMlEApWUh4MpGb13qWRlrGmUT/syyWmGHK9cYtPY6DXUrLVS1ikAQnLebMVFn+Dz4enx/3u++8OP5/97jP7L97++T/vl7TnHymUJYROC+r43WllriFTTWO+dIG6bloTYI9Uoc8pIFUTBf8B84R/79OzCqjXdnTst9baV6G3K4vX98r5O3OY9csrL2fWVBIqYtdJKEigEiUqapqmtF2gglQO3QhBgasWpROZqostKKxKaKo9t9/hwB66Zrusc3ZfXl/Fg3LcV6HSSp3Xem/HxWovuDxnr8dQlE7ka5GwIlDEMVEqNgQF4vsXsS8mF08IOSHFONF3NMrFzYr7lEvXQN4qEpEOuKtS7qvgWFoO3LeTH9g57u2dIpc+8TLvb98pmOQ+ntmkHu9VM0R3mbfVBgb58//3Lssbb1dhWdp2tYWIMhW4lU61SCpJCAu7Me02tULU7No/3+WBPnLEUloSlFmaOsd5uq5GCqxJELm61emslcyjsh3bkgrVSZYRaanHy/rHNedzmjMaIRqGpulV3T3f93aDa4/r7t9eXW9zz49Mwqj4Ld7prxjEdtk+rqpW/nvRIRDHsLmzEb+i6699e//L5729f1mUJJZX325vqXdHt/fGpVf3F+9fVXW6uVGG1yyjBotYgJZVScmkyUBXkMwO7sL+0uv3lh4eHp+NtGqfXvC5+2f++7ZuQqlSmioIkIjNXhrLvPiWKiXNRKRaXNxeXFBuoXOqMBCGl7BtjTMxR6iKEVMrY7knV27LOgtsa9uIy867oJGAvqlb2tYQaSyrFRY9EldvKUDWPx7O2PaJIqbiY0xbzchUIXa8qJqUVShtcUlIKZIYshMmVo+Ow8TrV4LhWTHWvkG63iSTFYhMXsKLqypqRDSQhTNcdUAQ4H/q874osIgCUfcdaKxIus+t6Ug2lFJWWbSel5gIhllBE47KcN9T2dnw4gpqUPgVfkU4c0BiBcJtjKdJ4Ug02uWYSlXOJvvhZY4AUdoDVkBn7g8JmSbCF7GPZ9pWRgaiydgFdxrfb/nyZp/SK9j2jbz7Zux9hbLqxvZP0LgQp1RlzGw7Hh7PV3F8vKSa4Lr7Uyot4eXt9fp78TsqE47FtbExV78HFcM4xoCYojTLc2FaUR622+3PX9Vyi8jsAeCVqrQFSTV67UsBopQFqkbQo0ytlY04ApdQMlYLjnICR+qaX1ja//eHXZXFudUJmUmyaFkj6PW/bHDxjkQg1+VhDtIPuBt0MpX3V930v9s5kPAxjo/Xitooapvf32/X59bLPFBiroOf5Kt+8EsU/DUX1DsEFl+Kklel1O+i+1935qGxnaq0hllwJUKGMosjffvzDeDyMY9Pq9urvOP0e/WzsInEsWTa2QpZKKKUkoUixvu4hcxFCyEZdLn7bHChv9CoNAWtBtpaa4ZqLFkIqetJKphQLT5VjI9V5hLvDH6Een6//x3WSbicWICk1nRD6ScbPKee+z02zE5KUafXPglQp4jLNMeZceKAskIuTJKBTHSaCilygACjVSDJ+r/9omoZ9zzn3vd1F+56u07aej6aKHKsH1GSZpeBIlMA7F51Tksa+jTJb1ULlmOK2bShYyFwwVJLSlFariiAjSZPaAcZIqR+n61yr3ZaUo+oG1QzuaIyP74b/6Nc43bSCVWKlvG/1IBShzMhQYoakakw1V9nl/tAcz53Ag6tbKC/77lJ5blqTituqTbnzO/3L3/7y/PaFTPigtnbEt7/+xYo/fRj76bSkkA+jNfqc6WYVEKZcx1BuiW6oXGeMMXfLklIyJFMI6+vb7Tx2JQ9pbxCKUrEWX2ILVABByABYCsPt5cHtQQqpZYwYtRa5ZIEkhMyFRS21ZtNUgW1OlAvUWvbNS+wILWIFKlIaeZmnrm9OH7qfOvn+fg0RtLnLSe07zMulbaySWGu43P5u2zCYJwHwcHec3p7PXbstv0DmWqqSD0qK82kw5TZF7ukYCd/SdHHXs6IPQ2u8rjFnK9ZaqLpWvZ/Pw0/9zwfTnIbxcBKR655CKDFHTKlacTuefjC6Uc2VSE2Tnxfv/FXpMrRPqmu0MsXlNetYSkWVKhKJUrtQvnDxCjCHY41t8st4L6lkIYPgVto210KYm6YJ+ypMMQ1B6VrfCUV6+Ca6ca/qLy9/9zNtu8teSbN0XStF1kZrNbT6aElppQizpnbbwvt1z0CMUtqcK6daoCoNat/RyqIVScE5OQDSSpWcKru2NR8+tC8vr+CijkPeWYjI4gLyRnIX9cDNXoGJGApQSphCa1XKO2rS3bDv/v19C17G4IP8enzQ1CTROSOGfc+Gx4djGBspYOPtXhQRxPPYO61nqBzWI2di/e5DyBBAvZViCmdJSYmRCMOeVG4gRCy8xz0l145CGJUgmrbU2xF5q2lRsenaoWDasV2D+f6avrxcvAsjpIWWUPz+Ojvzfu67n3/F11vftcYogvKTljpWJZM3KhHuv1jbtp2rdrnFzgoXSIgjcLZCiG6XxkV/8EGvazAGQWZOqQqMCG/rGvcEvJUSe/nBKGmqpLpJUUUrhNlN3yJQSg81akCQmtyegYySbUzVtEqaEvMu5+Wd9Onx9GRblK4E3oSpDGFb18K16QapRpzU67cvbrkNX4uUqhfnP3xUXLkUrj5u22YF9K0ZdePXpTiVgpr859v13UUvH3IzHNispd4pESUtEuWhfXo8PPR9OfTw6y9HyccvX29l9ylsMQRCNrrVVqbqt3dxoRsDpGLcXgWZrIvU3HTapcYFX5D8PiHtQ98CkiabE9TkR8GPd22oFbECkmmaVh8AVCrZJ4fM1ighoWmbkjtQw7aviqg9QKkeua636LdChSpuWfnI7yp/kNSnWkhIM1hCebxTUoY1/auGVqsh7I8IU4UoQCmyCmVNXIFiqVzZp1haSKmQ2KyV51NL9f5yXZbgFK+daoyQjdFSYOUkYwOp8syweY5BoNdGzsvatENmtflwm8kISMhcAKlhMDWLUhAKxm2HyL22p+7ok4GG9uoau1sra6VSYF0jWWUQay1IieSbFKAsSXUfYyml0eoQk1v3q/c++Cqol6hqloS+5B7qAeHSdkuFZDtdytltebpEt87AjovvWuTMaT778M00J6PTb7/8z9qItkO/1eDiOu8iedJglX348E9c6/N7UCIBe+9mgW4YbGOFPJywO0ineK8enWCXShASCKM0Yt0WYJZUnNsIXgk7BGVkJuPtKIyVQvZGD7Bpn6/CsiQGtlIqH0MplUQlJYQQEvkgZLOmL/vL6XYLlfmgUWklYy5YQCaJuu3O1q7rHK6XyXnXWNM2urGmUYitNC1hLgTofCosUTQhujm/Ccr3Y//p3g8ncfyhGx9/0IPyH4/xEye/KsHDKf/y210/0PV79pG947BvDLtpNEnFWArkaZKxLF1vSfq+61OEFB2gf7u+Ub2zOpFEzrHAey7vTfMDQYfQcgm1SC2JisKoGm3Ho9XivG9x9SiZBVIzjj5fd+8Rusx/9jQfmk4rnRJ/evoP5fpcDbSGYm5LKQVVkXPIC+aBRZCclHYeh/7e/tT+T85nH2KC7+wRGZAyUlFaY2FFjMRCKRKy69oQIOWVOWiyh1bXaDYPaxpS4mOzDE2jkdK80m1MPuc54RzTNRoSse7tqIQEoSUL3GLY40YEWpta7XSN0XmAVFKdr4uiNsdqWYr63puq6501PNofx+6UcWl6JZoqS5XFAvwQ0gcprKRWmpmBgyOfSmEsUFyo+87ewbyswyU8fMAiD9uyBl+k9tpKEB7SxxxT3CPwxerSN6lrB4KWykNJm9u51iT4qKVoBwBWIaaYWZRMVRAIrY/Pzy+vb3vMEFJGqkoSl9SYlvmOIxa/yTocGmuVqrXPOeYEh/6w465ku/vQytQ0t5pnEtw2dhiOSvQS71D2oBoapkZTDp64Nyj23deSUXDOpSQllJJCLgTq218DeAwxNZ2QoDrb5sOwy+1wtFzUewy6oYbN9LxfF3ddN6NpHPu78xFr9jVjKb1tqbGkSlNMLdMSnFX1x8fht/vxdDifHp50ayCmD+0R/thsy/dxME8/HbvhvCzbZZmX/eaiz3kmjaTJ1Zi3kEuZVllrsk2PIubqXAhKCanJh3B/V/7w8ZiSe387sShAGcHMEyhpKpVSRCyp1L6VeuiHrpfZU8mlptwYWyojC0S9u33fZ6mckFKWT9OrrgVGc/74mNflvW0nonPO5IPdo939Sk3QvdGdovoQ4r1tTsPItl+2fRJmyssEtQqUXGLKQBUJBVUkQgCO0YfoFBGnUmvQUI4tkehkL7ZdDGo7dW2jmhqBbjR93/xtO2hruUMMIc6mEYysrJqXG0BB4lJqLbpmWyKuoSzzW2Mbq2zfjPO8coJGCCbSbXP+wf34s5XG7liE1DHqCmnoWwAuMOumaEVxK1IZYTJnr1sWm969e7us6zIJ4WyDf4iH/miX5cKlSFXGoXP5ZhQTeyzXRi73h/5h7InvuPZCyhzVmhMSzOk5RClEV+sIVYbI1UPNmWtR5vbl99e367anmFJEylIIo1RJstY1rT75i5L6MPbDKGps9jWGNI+tGJvRNLBHs/uUd5My9lY2OhnZIVvTSdMByVjigbGYRuXQ54iyugy3WFzTGjM0IYPMIb38Ps2TUjAhVR7UPGyCBQI/Pd0pTTkn1YXTo+DX7XAadrdu6zq7mFPhzAI4xtQQjM1IKHxwOceU35jpblS/fWx/Pt033Rn5ME+v5QZU5diUc2/v7ocKP377nC43uSxp2i85OUEI0iYwUwxEkGKO1deEL883ZSLz1g4SuAdSQz/c/Qj9g71NWfmnwkaqGj1bqwQpFrNWJiXB5QfIWRgbsk8x267XTc45retWMxrbO19qVYoOirAEdXn72vWNlrptaJk90Np2H7Y9Rz8ZrbU8AVgDPDTDHr9elu+RT1b8TNgkDwqlboWWBIzrbYmRqQJXEoJyKZbk5iqzslLsqytQj61sem0sZK0OXfvh+NPHB2uHh4JH4gzr1V3mpj9JKRmBVJM8troPG02XZOlYIDBXqFQCQValYM1EKK0x3gfnQsqsMGsj787jw0/XcUyxwt3dwfm8X6vRvq0ys+uGKmXgXBh6RlTWE/Dmo5RaqD6W63X5LvUebjubp59yylE28odWnXvdCRmRhRalsWFQzYf7u45apT6R0Kz2+WJCXPsDynZp8cyxqRn9kuOW3989VwguXt7/7Jxb3BbZxxwEIrGGovYrOvqWINg+GaWIkou3Gu8KSLIw+UkIGcuC/BRchPrNCN3JgwWpxGZsalsrbW/bQfKLn1FgF7Ly7LME1ebGVGWCsmzlQc5XVWslQOAsFEUfL89LChVkWTenG207JTWeHwehZYn6TciSiwCRQ3l7uUBORKTGIYeUSSQXGik/3OnU/vDTHf7hp6ezviPblgAhbXUlWZUwTkvjluJinK9puoZlu+UaSIOVndAjkATGbdn3PSBUKW2tVQkFQtpWb2uet4hSzHvYvut1+wfQTkIIqiyRSZSha0+HD+/v0+9/e53Wd6lFjBHC+TCcER2JDbFazdZ2fg/moMaxKRxIvDF5kgNx23S260YueZ7ysoaKsh/Xkv2y5jQPAun1XUzb2zCuff+Xksi7MHTHbuiVGTWNTN6HIFhtexAEiGmsB4SqbQXUTdunkgHBuZ1s29ssR/PTp/70w7FWEy6Qv/6+XV/ikjcuQoimH4XtSCrm7uvnZV8Q2e/rJElocdrmmFMgEaViY6TUdp68c7wuIdOtaYf+mLT5FGIj7YHrW2MFH+W63rYtGn1uZa0572vQaozJM3llLFNFsqezDnElsVWmt7fNrYtbtBEna1XbtMCy0Q85shU8GtObh1P/UHZNZAAxpi16qrX2o+4aeno6KzXc3rzbXAogq+JaQ67LclNKSWEquFSDlgel2phqAhuZq2xiDj7qWoCkFKARLEG+3eYYnTSrBVUTHjrbdiup1dqusz81ehRCFXHVhywUYVVhhRCDi5fdzU9P+dd//rE99qhGkoP8evnXvjm24kFpFkoi1bDLnIJthwK5ViAVWWgkhcomyHvC2x6kJMJktZSShYAs4HW6Pcg7X4ql+vPd+KE03dg+9g+iNSnH/W2uJUsiIVgWCfUuBh38kvx7jZMWuTmfiIQgDRX3bVcpuFgsNU0nhAQpiAQB9AAoVWIIy7aXr0ZDDD4W8e+IbUpVoFQ0CyySz8exBUyv60tYSStZsZSU3PWyu0Wa7+NB6V7et/+xBK5lJWQiBVS1eliWamRlDg8fTynCtoU9zAqPArvLFPftQ3e3XOPLWqxL5/m7Q/mMqddKVvyK9KHRVvXEdN3jJOEHrgA1A73ASjHmfhBWEXAWCs34JAuXSoMJ3ahEV7m5X57nbYpp8mEWKo9WMUMmUVAKZe3r+3yZcoFc4HshHQL3jcy8IkShV931aMX7gq83mife1g2rQBGe/vmz6f9f0zRpmAYlSpbK34v6KoXy9VpulFPKJVK4A0LUkrhXWCWh1peffhzvjr/4PY12jOn91LVWGwLXH6mWirVvZOxUPdlOmQeGXtijNGvMxb1nKdfDse0He3f6KIValu8xG6BCsp4Gvbm1ct7CVACN+hPnDZSEMFSRpa5sn7EMOUvnSy6hci05CvEZmAWzADAAFnqFIAwODXb6IAU0elRaCl0iBB84T7WIwV1WUagUn+HSn+qHf34afvuZrA0QsAOZfASVuxbbri81KV1J8e4mpcEa2w1G2VJF43Zc1vS8XL7Pb0vyljTXwoJVrodDJ7TwYb+5W82uMfen471LiQVsu9jebynHEEPXNnfHAyECg4+L0LTvwbtSkrL6wWhDhDGtzk8IUaptGASi6AeNRAwMIFIkBMFaaaGUUkJyCAEFl9iHtNeatcpcmUtp5cr12jXh2PWv13FbwIx/BTEVZilHLsN85d7mu2M0nZ4mlf2bMqKhxxz129trKV+twJ9+/LG3nxSFbf4KBFRlq/r22NieXVj7dstOlkBx76SaSalaFOUuO7PlEhxwRTJTocK1Bg9hS1KgT6azDiCd2rFyOp5PPqUqTk2nuYbpy/b2ut8uWYaVuLRNJh4qZiHZWAEA662keA3+kmPU0CpRhbhWOWsj2kPbHn7dHX67xb8+P6/LtZTLQzPl0hn6DxpE3APg5ZZycGK7iGop+cpqV/ypViilFPj342nMvry9vy23rSQ4n9qScew+WNN++fbnzC8/PtgYC0E9jmfvt+Avh+Y3ea/G5lZKXzNp6lefp+UNaH98NMNRa6tKGl+/pZCUVAhYbRvnkCKKSg+Za86ZcGo6LaKN5Uvb5XGUWnQuVR/RuxxzZK6hes65liKIrNZWa6u5twFqbMQPrT7kXAsmX7KWpmYbHW4XrFy1LkzBF1c1nX54HD99onF06+65qlRkydvQ3x+GXJGEVEJloKokCOJtnUDYVsvD8WMq8Ta/fP/2NbhdSdIESAJy0lrkuOcEQ9tYJUMmAN7dFnIRRm+be73cSkmIUFJVpMahFwjrHEHQdF2DjymGnFIMSmtdSq4xGa0VjNCYyojIIcacCyIQiRACIitKxEFA1VZhxm0j55zSABwEdDlz8ZvC7XTfpT/9Og63t/cr4uj2JEhVpRGHGD2wTLA0velVmKfCRPOal+fv6zoLut4dB86ZWQoggc2Wrn1nexSMb7U+FC8a4vbTm5CQ07gvTa217+zd0WL1zu2CzPH4pK1gqIRiW0LYfC0L0+52+/hwp7QSTd3yBay0XYdC7c6+v2yfP7/uS32wvmsktQHryRgt9a4UvF+uJdu317/nGM79WUkkpLYtKE3T993dY8D2+fXt31+//PX5c/DeaDzoeTgcuuORMdUawkZQNLI2uqq+Raaa2ijfhSatqLjMObubvTy7bXNK1HYYApfDw6GKVLA9P/2qSnN5u9YMmloyrOXSw5nP7W1ZopfWtsHXelN7UVreNd0Yk3x9C25/Mdbaxgqp2qYH1tr0+5Y9C67vDLI7rFYflgXmzXencTwfFPxB+a3NcVvVtm0M0I9djqmWopAaY4zWkuGoJZYcYxN9QYGp7oRGGltjW9ycwjae9qZpUqyKBYNqVIsbFEyXlzmWyDHLw2h+/vnx3A3XWUilY1pzBq1sySiryhG5CqFtSNvfvn6Oy64ZtJadFefzQWAdW+uca0xzf36IIYaAQBVl0krGHK7T4ryPKSqlmNO0VKUBmXOgwsKtPmRXSmROWnfGdJxRg9bKpshFNC7mfdnWLZZaSXBK2zxPY6+tqVzjeBBEoyhCC+obrZTAWgUUklUKrCULwqfH0RzwuCg/nV+evwjBurlorUshoxukWkp+ePzp8cMv67J/+bqu6y5IWX1o9VAiVp201odDH2f/vsylFoECxTPLoIy4P398fHhsrLzcvk3TVZLAnIw2sgvkmlKEsQck0EpavaTxKxe0sm1VE3IerMGmomR7kuPjOcxwe13+8rfbX//yzNXVtt4dh2H8QApNZ0hnRii1LOt7Y1sy5uE8FgjGqH400nZCN1ke5jl9ubx9fv+3y3rlQsgnJNH1hxrp+/I5RE/Y5Z2bRh7vqurFsqYcR92uUoHS1HQ/hx3DWrbLtm/Z6HyrMwrU4hu3t5//+NieGvfVaAkpleCiMappDiKFzU1K83BQXWdD5KDbxcfo+e2NgTdjov4UhkYIXf1WBWrBHaeLrKEzACARsO2MVp+UUHa4md4Wwi1GRGr6I6smky65IIJukBAVoBFKClFi8q7KYn1cC7luaBAK1nadYkgZxdodan/eMP3kosRk0av9ObzycxW3r88vGQMxy7YZkGQCVC0K4pgrsSKQkO3by1t7UOagmRkEouIUS4yp67rDSf7y68Pp1MQQmE9S9oTD97/8/nxNG11/ehib/hhicN4DiVKhxkwIIaR13ZUAY5uYk7UIQWohKnZGaEiSS9KS2gbR8pQhh+Jj2kLOpTBwDsV50beNc2vOWQpodJFCjL0rtalMnCTyNBzM/WlQYtwWLmoLyaxb3Pa5O5dxVEZ1Vn6cb/s8r4RrSZTb0+MPP7+9/XlaL4UdoXIbvfr1/ft8Pj+btkOhlWy/fo+lgmnfDD5ZM0j97XqZFR3M4U/HwzuRmJ7HCu7u4Q7J8EW+vr16+GtjNMkBy2MnsrZgNfb9GFLwNVeMh2N/+KlFkm/f3v/8+fqXv31bVgd47RGaRoZg9jJpwUhq9cmXLG346fin6DYhFuaTtrYdS3PqCqv3hZZVvL+n2zVw9kZqq0I7KlL6/cVclnchpaJtbM6pBEZOOUiJphURKIeUfFInFUq5zcv18lZj8Yn922o6/vbtv97/Sj9+Oos65Dwx5xwp1lepBgx2dy8hRqGPaEOWWIrxrlnmy77PJX+3Bp66pukPUilgiqGmGG7XyfFfrDV3D3en9H8JIRS41JJbi0bF4PrXV3dZrlD90DeIGJxDQGDWUkkpOeWQA9eaY7QMWgiSQRJyTtX3i/MTb909NUelrEhwyMkuPvqAYYM3t+zXMPuUmc1IYFieho9uRU4gTAk+xZBaS0QSQCjzKCzkzJfXWZP+pz/8tP417dulck4oPOeAlVojiLzHt5fXv3593lbVjSwVMZdaKpFwLgNLACoFcuGYi9JKqcjsu7ZRwpYKDBJBl8KlzISeiNpWxZTnuGPIDLnU4oPf111KVVhgNVJqY0yt5HwGGXMuJTMzt5r64Wg74bzc9gD64vL99W1f3V//8NvD6TxAPrrp/Pmv++Uy//hr+vGnM9IlhA9fvn7f172z1midalIgSk4xBCYeDsexPzatX90WAuTiSxLJPyp9e379N7dfuuZo7B9Muyj8QfAQ+TWD93lyF5e7mgJrdqiyxUHkj7Xc7u8Gx0VpqMC5lPW6f/1y/fZ9um174VqK91ltMa9+oxCOwih9vweY13fQvGwbQZXIRo4EFMuV6oaqTYQxdttMxbHBNFpxGrbj/UE1rXcq7LrUQGIObhcCmu6kQFZmVGEch5RzDLkkqJlj3EvdpNDVy1odKIGIWuj57daFI/KOdRNopSbmsvsU/DoM9zm319ddqTzdwrcvsMyJeRdyM1aOJ3N//lhL3dfd7zWGENPk0sdUEzW7Fp+rKKXOJVtRbdrFeg3vX9dl/64sQ94BKKdMQgrGjF6QkAycCzJQBdYVlWgMKWoQRN6Fq64djB2wsFpvKaXTvrtpWtFnUbema1pjjRlSLvpI/bmTp/6plgIZM9lalBb28WNSxmTGW6ymNWter39+PZ37jyO1/4//9X/73+H18vX6Plmjprkz5lxK2Rd+eX673da+69pBFAox1FQqQxVSUQVAFIpTTbEExUV6URNzUsyqFI7MgBGRUdc9Rn+Ln5pfxjs5pavYRMmFc1Vis2ZrGlt5LjkboUGxwH6dNsoKxd70guvatZ+Evntd/qVsDXIHwiDxfTd2jTwMh2E4m479qb6u3g6fpP5dW620D2V6vXxWaBWQqCwMKZQAMudkqDWq392m/3F7IgvitZa1QOe2FRHiqGdbh7EV+j1zmL6VXMS6x+QTVlm8d3EXlio2pagiv1tLtUKrx5KCxrYsNH1Xb1/h+h4qli3sSDqUfvHs4OtDcxxGg9KmuZRsc0GpE1TYN314cDmHdfYbyeO9rTIKkiHsBK+93R5O+tPT8PDxP0t7nN7fo0vzbSJKcbgdz8MWsLf3ubBtO9Dfmk6Zqv2ziVPhpPq2yZ4raik/C2zumo+NzEM3qM5vz764rAUq/WHbby68SyHGQxM3efmip7hwyQrYih0oSGnOx/6XT0/ZFykFAiuyPkclbFtdzTA9A2snhFxTmzKX7LLPcb8s+xxdrpQy7Fx1zVArSBJaoFaiUSSJBAkrTAPYCN3rAFCVVAskrqW7G1ykt7cwLyyKL+xv0zuU166Z7swDU2/EQ/LRklZgJGE1DZF0Ge9TDD7EdQuWWVrR9NR0SmSZ91z81LVVfOz+FH6G/xGvr+/7m6u6yBGEEHGel9urd+HufNJWL/uectZmMMLKLEMIpRQtBFeOW9SEC2mlmizmdbMxiHWXoK79KJLfUqjWWnXYhoc/uUz7st+dzb67piHYNvoAABV2SURBVGlyckIgFsvMUkqoWXXTfVOtOCn5qLVd5z0HM71jqJLzhWjW9ka1Dv1BlGOpte9bO8rDcQBB68TXaZa9OT4cpnerYGxb36g2+kKs9/IS415ZS/tQynFL/766qKzRtvdryKXmGL3zOacUtDH+9n4p8L0191BJygZQNUorbVNcFQnOpZIJHrvR+qBAaNGzHaB/6GKUIeZ1W1f3zYcbQ8Yyck055VqFahphbK5YMpaIVvRGiNv7Na/ZWB+yY+PG1iopNToj0thwPJkPp/Z8OPz04QetnuY5T1PZpy3nEsNN2ZoSI7A1TYi5FtLck2yh8przuq0xxlpszUUIE4Jou6Yd2sNB2qbPhX3yprVajLfrfr2FUul4HPyOYc/7vmzb3HXyNI7bnJVplfWffno8H37d12tOispJilBzpWS0MjGlsO3L9crMoWLKOcQAlUtMwXujJKGqmWuRKaZaKlAhwZhRJm7a/twPWugaCwAwY82mRFmhnO5abcsyqesbX66x6383FlFMzKWAWPcsoGoNgc26iw2cjL7UjMZqOXgft8wpQJLCKEvHuwEwQ9V3+bgv83pdi7oeD81//KffttOHt5dXg3KUjZSSukqP1afUHTQQlWoKQy6EIPbNpxitMchUYtVWSRa5tntQoSx7flvD5oLA1HXDh5Qa1SxPP56o2+ZtCpGJpDUmeN9ai5aUFDVZZhZC5Lqu6951rTSCoazbNM+bkmbf9xCiUiyFqFUolVOM+26mda7w2o2d1DGXEtkPh8fffvuDVPX7561v28aMXdMK3G+X2+5Cqdx0qqD/+vr327yuW25bOJ7bVndu91hsSRsyEghkmUMCKVKIwEQktRLWGiV18RGLyDEVFAUIUfiksKjWVGEBZdHqgMRcM1Eg9EqQSBbL1jWtNoqUYqJp9vvEmFV05W2+zLdZy2b/flMGeyFLgpqKhDDa+umpH5vz46l9ON8/nn68Bbuv1xhzLl4qgCokqvP4NLYDZlvcvu6uJjqeKFcmJr/t0fnsVXBFFadEW5mAgqKRq9n2BZUNDqZ5//L5GnxQihRxCes++WW+kShEVajrb78OpeTuIf/w6bAsq9IBhfIrprBwCSlTLbpkqAnyXmJKiQsQ1BgBskDQkhuLqWIpAlhoJVABlgA1cAFElMASOXtfckFAAZxiqDXqQSql1225TVAqAmDml3Ho9ABU7qwu1kjSdvM4zXF7nx0v0rlca+lyY9u3/mD7sRPttOa5VBqPJwZInkjZAh64J8+axcPhMIKaXr6JKt0tM2cp9Yf+bFutO95cBtmm6N3uiaQPLvqAwIIUEbZt23XNxqvbN78NteSashBrY1suc9tv94/Gtvnl97HQtrvgl7xOE5bcNy2iklLkqH0ogMQokjssQW80K12ZS8yb6TSWre7DGjYp5bH5VTbsY0qhd7V+/uuVlKsYpcLHx+7+9On6hrfL++tlVa3MsY8pKEOqCQ0PALIfTeHl+/NL8E3JdQ5728pjfxTWdPY8dDKlnIIoFWsoBRGBiVhSIYxQMIYYt5gAmTNyqbYs7qZlzzEMpbVCl5hjnowcD0PzdHe/LZkzY6YWxP1xHE+t7VuwJte8rc5vYZnW63RhwBBdnn0/WGnNPu1+XltbxYC//Hjwjz/0Tfd4/1Hh3fe/Tt6tNW/WVEFglXl6eHy4+wmZ5vewbpRr9emz1omEcWu/rzHGXIJJqWaehCgFWFrQqk87TG9h2eq+5eVavn6bYnSHgypxapuc98TMjbGSyukku75DgvPPH2uCZV5iKY2BDDHXCgQ5+90FQMAKmiRDQWAABJKVmZCFlDUXEoYBYo5QWQqSyEiICEIIALFvIboqkJWSGVTOXmlprNi3EisCJ2VXFa9Nz/aQm9608odDbxFrDHt51+jKvsjZF5nAtUNjOkwpKKWllCgFV6BOJeV0bxo2jehAh7KL+O0SPKfcr1cbtj6jBLyEEE5HrVF1cOjKKZYpQoVcgQGBjVE5x81v1vTd0CprSAosu1SrlDpH3cs7oU13TCi+NYPs27t9q9v7aS9fVnfxs5iv175rcyhSodS2EBeuIaZ533JctRJYUboxBDbix6yhEfeyOb8t/+8Mzg5nafVtXnY3JGDnfK41lXkY7Wnkb397/fblrVGUtWZSBdctRGvk+fwEJwEMKefrtHIiq0XIadvnfeZj0x0PR6tbKUvK+VYikja9ZSpljRKptVJKgVi99zUnYJSSUt5VzSFHZGf0wDyUIGugWreSpdXi6fBxqr4kT+Du9OE4dm2rVatT8t7n6Hz2sYaAwCRpCxEqOZf3FZWs27RqqqKGVuNPn34iGhHs63O4vb2lfRMQnj70CMWq7uPHe0F197ECV6ggsHKIcfPe3V54ufll3rZbZN779r2AAVHbQRrdB1+T18x226bLNYZU990jehrkvjvNeuyHfmi0TIfxZBplWkHFzusVNXB+iln4MoXQ7C7GzAJrZVaCWi01QSWRcrZKl1JyTkBcOYMSVSMhb5tLqXaNbKwmYFA6FNqcJ7YaY60silVtPJxQNHWdNWNn25s6XPqH/fH0p+EnfPzxXsMfkl/WdeoZSTUJcY2mIMvhKH/46c4OYl0aKRuETrRGVFepQluhKYBAAEdry4pp/ekSLjGHGG8s5jkyJ84Jx9Bl7wuFCi+SkUlaoyuLlAogWqtjDEJB31utkEvR0CvbaQ5GBEEaxUmabRhPx7tDCeecdqjP1c+y5LEnaxprVaVcwC57nadt3yMKgVCVPFrb1Zi2xe2bax96qcS6LtFbZcamO4Sap9lfbtNyDYy3ptGcG4CSt7heU/VCMkjJlyWEnLVcZEGE5un+U9cRQP3+9YbFNOrYtugEGYVDy4fT6XQ65yr2Ai74yW1C2LZtSpU1VSBC0I22tRSWXC0TkrYSZbENGMskStdr3ZUEJUFpD/Y+6BL6+1Zv9z6EjSG3JIyV0hgA3De/LjRNIYbksksFBKJQknONrrpFtE1029ZYxhj3eT2dWtlBTLFWqYlZsjYwHpQUprFK6Xb3q7C+wZFJCAXj3R+1bq/X2/fXffXAJFOtMXjG0HUgrJbaCtI17YboFsvb+3S5eKxCS1tSWBcniGSjQqhB4/n4Q/aVkBjjesv92JOGfTr6fQ++bJuKUUhtC/haUqkJoJFSkmIiFKQBmpg34EzYBCiZq6aMtTi3aym0NgjMIFNBH4oVlQwKASSh67rx0PvCWioXM+B+POvx1D2efx3/YOVDG55doqSFsPIgRJerygG0BHn3oW1PitpGxipIeldV6G3fisF7dpI06iOAJBaAQtw1+ZKxQIlQCr4s14pRSnkIqUdh5ahlr8tiLTTWLlsumUlC17dNc+otnIdWEWUfPRMQIh2puaConAerHmQ1cZ44RVX40PpWnZmF6tmOTchxcgJ53PfMm0c5IRcFJVWzLFBSjX5DkUL5nPKHXGqEyQXrCsp22ZzZduv8bLUblRasueZWaEvdFFVhYnMbxIfl28XNUfGG3C2brDhoY9pj94NSwcdG6liXmI3u5fnHU678/fn2+fN2u25+SY32fecIN0oiIimyrTTAtbPGyJ0EgEhN19vWmE6rUfV3rf0wyfHMjJka01Tb+lGX/j895VKXmZb9e9taa/pt3qSQxQ1KSR+vc7yUNIoKgEXyJkHUeCIVpC7j2JbJQCT/LsehkKhaQzegMjCetLbYNg2wcnvPAP3o5ltoGnE6dTie1jXNgW+huXq3r9dlmZFL235w5T2yDHnItaYcQ1i+f13XaREFFFmAmiPevAdMkaHBDQTQixwHQbKoLqlmUNSu6x6cjyGmWL33tdZSYgGZISXeqfZCiFJv/xhSKDy2IwtZ4t5RqfO2l+B7bTspGWoKFZAEwNgoathAHUdpNGkFprmL0frgrclCZWjsYE/347k96MJaeDm7b9656EN7+CNUQZUOHagipGi6LWUOWw5Va841kChSoW5Q6QZZgZcQibOptRQmkCZmNy3RBc6FbD8QEaD8hx/KwvRtGc9tLBLFQrJSKg+Pg7W672Rv7DxNIGvaEUCmxPvOlStCLJnclny41Cy0NBVYKymE6vVdThT2/Xad9vQ95rSHPWVfa2VmysyFm3YdT4WQW2ukTC1ApTUUAFZxfUj7Xr035nXsDlYrgX0oL8OdZiFqHd/fr0k6IdgIu2UGIQDEy8ub3nep1NMPPx6PAwDUGJrmn2NMe7zctun5+eX3329+bUsEqsgxgUJrgZUn4Frcui9d1zMYpVohVK6Mktp+NC3z3VXdF3W6sx/PwHL9LL99m66v8dRuR/GxOzb9vT/tnxrbbVta5iJlA+Rtlza3EScSQYiitRTwzgBtq4+j6VtFLJ1zKbrd1VJGpUzXS3z8EMIyHIOlB0SIcZHCScL5KkJ8bbvOjg9VmXl+3zdn7V1Jl3XaKV/7prGcpR/LKlNwa3oPqC/rh9ff/7v3SilRJOw+LMmtLiCny3rr6Yr0UFNN6T8pg0et7h6Gksu+By68LNsyr7FIgByiAzlW0InbmiJmBKqISASxTq2koW2XxYW8acuaUAujZMeoYyrruhGRViIDWlFtI9vWKGEQakoOSi2lNI0RyvirT7a8LS9iPg9nVbdGBBGu6TrP263kLVHm3rK8XguKpFrgGHWvmk52P5DqUR0zVMyrXy7OTUFLPA0GZcuEt215fn7dggcWOTERx5IE4rQuVVOrSSkttO27KpXRMQohSinBsyQFQpdcpISUakxzSrEyx/R+m7MxBiHXnIvWSEXqudSye5hcmubteb48v3/1ycUauQpmEtRaDq0WTz8MP3z8gCgkPHlXokxb/JrrBihr0gRBiWxt27cdIWR6l0pXlC8v+76XLcxqtzW/AMPYmqEbtJYsISaa17jEizEyBK+V6DsWpKZZ3q5+nrRUD6dj4OqLu1ItjbaKlZYjAigVpMhQdyRBKIUwqRaALDWIxrPtZHsEM0BbQBLMYE5KR1H4Nu+5QxYGgXRmcqG63QbHqSxSpaePjbU/uD0iILGQ2Fpj+/Hh1A+i6O2Kr6+XUjIDkaykcjtyfxxiEsZ6/2bctjNzqYsgzfyobKqFalYMKNgqsrnMSGvf1m6oQwOWU9uerWapE5hQK113lcNak3cley7ztm2RM0u3eYvJNBE4WlWVwWFsrCUStK5LdIUKuC0tWwguC8mJS8mVWcSkY3IAQJiVEpokoJvWunknhECKWguSVEJBUI1ujab/fy+uRuRkNJKsjDlXImAiIaXAyjUlXS0VcpPb4h5eczMEhIw5vz3PEzioSEC15L5X8vbqrCVL2tzJ/lGK0TQfJSjI7ETp0lbqjG2VVqIQTnR30gBzdH7yMbFSy7QJKXdN2uoQyRZFaiyEFZikVEC6cgoREZCVUUhoffYhRgQg6QArV1QmM8ZSI1RjTDW2eFdvU6kMXfaxAKE6tWfBcl6X23rbgqulGkv9mPou2+YBYciJSmlTzoBGqW4cMJfseRKESkqlDlxNKkwiSHGYLvDyvGb4XiBH95DSG3M6j8P93aNSOhX5Orno4evrFQlut2vXaZT/aqwC1sgaEAma3t5rKUT/ZEVpjM5hY0RgUvBBi6GkUkUmvQM5UJd/5NW6nBp7atsHMoV5RSHsPX0ovdB9eF83tzsfAYXSErHcrn56A+9uJNa+x6eHD2PXff/+mStDlio/jt2xax9l7r3PpYbgvSBGSqZrUWAMrj+bsEONzR6W23STLCW5kqMRo8QGFHLhBG9S3Ur5zkV17Xo36F7dWaktmn5opeXhaJrG7nsu5WptqNVtfncx15yVVJyKgNh35m68a/SgCZWu2uL5btBKr/MqhV6XFEPNGXwESLmKWqoDoBAg5g0ABEghZalVUADSMVVDRUklSWKpucSKpZYcU47eCco1oTGi761UghlKLYxEJGotJGjf94SpCi5TrcS7m8LitNSGpAwCKyBUxKpEtVpJEiQkdh3WHpu7hsZmrTdZhJQt+nvYHC3ctt5IAvagom3r8WzOxybfQuJgVJYSjJZNC9qUpqunp9H0yu1ZGGbBimtKGREEipLitu1cqW06JbUyEYBqVaj2lJJzrkZrTADM3pXNiVLF5i+6AW3Vx+Pwx1+fts1N07Turzm74UDH029EkutdTcZvwYWXdbsAci2odc8lpnRV4tA11vTXko8xQEquljxNUww2Fac0Rv+iDDBUa4RAbrTOrpSUYvAhbKX6nNd1SSiP28o5v0nltUIvqhT3fTs0eCDxYNWpVpHlN6QqoMMokTDGUDgzYEXMIe7L0jRW4ojVAywcBgQrUYLCth3LNc77VwQ8jD8KaJbJPX+et2vvfVL9e9cNtpHER+cm73wtpg1SsQrbtq05pVQ5FZ60RRKV2EAFoyWD+vZ8nb6b9f1r8tnCeejTNN1qjunbt59/e6r8rPG3Rjatqp8+pm0tx1EP5rgua3R+fBJNZ5q2ozi46zeNb8PYKamUaLUoQYbMeYf3fsznozj3zXHsrdS6rXcPbX8/+qkAgEC1zN77yqwLQ4g+1QAycxXJYeYrAGAZoBalhJCzEfdaDrXc4s6EJKHkkGMNUQWSSsrSWK1E1UScuQBLpSRJIZQQgmstXIVWPvoEWVUVMWvJCL4GnarWgAigpEgpoaR9jVJYZJlBUT8eQFCFykLpboBKEOD6HP7+X5+hPv/82/nDHwVmL6iOQ3s+javfQowshFLSKOpaPbb2dB7Gc5uJi49AGakKWYUgAJai5rpv+/XQ3bVtH0PxPpbSAst9dbVWYNHYgzVbyovWJtSSY179dysSKHU0D6ejGQd8vG8r98zUn5zbH7atcXPvdret6bL+RagqiZhHgqZkzAlLQmOt6hJtjd+qc1Do92W/tOoXxL5rlNTv1h6EUF3Xr+sSY1q2lEuNcSV0hee2rTkvLEjrnvyJg8wBlcm3eMETN2cvLBYKW6B9Am2M1u9Qb9YYLgj5AbCR9IT0zBGkfFNiRBZcbhwPNWFwxX1Pt5eddzUeVWM1IbMXRnScp7fXZVnfh/vp7k6mFLW2/diXWktSlorAtEe3R1VKAWBSvm1Ha8nvOeTUHLq3d//ly+JeLALXjGlL3r16F6TIETahSua34s85eEkFOJ+O/cePZwiHec4gEFSQVhI2aVduiQpWa04CGoVoiTc3u3QjW4mw1V5K1Xemkz3LOt6NhPn9/b3WsjsfQ5NSYUYgyoVdiNJCzSJFmcEBACTJNXXYMCaOQXWDMkLT4B2nlId+UJLWdQFipUXbWgWZkHMqSkiltJYGgGqpqeSKtR8HWZXn2A7dvC/nQSDk/18AGADn//z2Av36AAEEAwD7Av7+/fr6+gD+A/34/SiY9wS0rYkVAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {},
+          "execution_count": 26
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open('/content/data/anno_masks/patches_m/1_09-1339-01-1_anno.bmp')\n",
+        "# Faintly visible needs thresholding for clearer output"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 273
+        },
+        "id": "1JhEA-QuVatb",
+        "outputId": "b7e0dad0-37f3-4458-c8fe-47a21bbc82c1"
+      },
+      "execution_count": 37,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.BmpImagePlugin.BmpImageFile image mode=L size=256x256>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAAAAAB5Gfe6AAACoElEQVR4nO3byW4cMQxFUbXl///leGEYHmoiKVU9hbxnkwGIId6mykPQrQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGj1N/UJtHp7qY+g1FtrlTegt9YKb0D//KVqgP71m5oB+vdvSz4DfsxfM8BPBa9A//Wn8htQL8DvBSh3Bfrfvyi2AZv5iwXYzl8rwM78pQLszV8pwO78lQLsqxNgfwHqBDiYv0yAo/nLBDhUJMDhAhQJcDx/iW+GTsavsgEnCKA+wP1Ob0CBAOfz5w9wMX/6AFfzpw9wKXmAywVIHuB6/twBDPPnDmBBAPUBbmS5AakDmCQOYFqAxAFs8ycOYJQ2gHEB8gawIoD6AGoEUB/gJtZnYNoAZkkDmBcgawA7AqgPoJYzgP0RkDSAAwHUB1BLGcDxCEgZwDN/ygAuBFAfQI0A6gOoEUB9ADUCqA+gRgD1AdQIoD7AfK7vhTIG8CGA+gBqBFAfQO192kfavv3q37SPfaNZAfbeffb6HxpMedvc2Qd5PIHvy4Apz4DTiKu/MXH8fJaP8OAaOBdg8Blgzbfw02DoCqy+3hYjAVzzvxatNRDAO9EjBbyPgIFngH+eJZ8E4Q2IvZ7r3YNogOgkyxWIXYGBMV6LXYPQBoy9jGstQSTA6AQ3FnB/EogEeOar56dofiCyUIHyPxHyB1jo1dvwPwJUG7BORa6A9x+s89ptBW6AO8DK84dwBdQHmChyA7wBVr4BoflTbUCIL0C+BWADXAFWXoAoT4CM83MFHAFSLkCeDQh+EnAEyLkAaTYgugD2AEkXwBwg6/xprkCYMcDsBZj932PhRwAbQAD1AdQIoD6Ami3A6l8FxD8JsAEEUB9ArXyAD2dlCcBf0ZxUAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {},
+          "execution_count": 37
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import sys\n",
+        "import os\n",
+        "from keras.utils import Progbar\n",
+        "from skimage.io import imread, imshow, imread_collection, concatenate_images\n",
+        "from skimage.transform import resize\n",
+        "from skimage.morphology import label\n",
+        "# Function read train images and mask return as nump array\n",
+        "def read_train_data(IMG_WIDTH=256,IMG_HEIGHT=256,IMG_CHANNELS=3):\n",
+        "    X_train = np.zeros((len(images), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)\n",
+        "    Y_train = np.zeros((len(masks), IMG_HEIGHT, IMG_WIDTH, 1), dtype=bool)\n",
+        "    print('Getting and resizing train images and masks ... ')\n",
+        "    sys.stdout.flush()\n",
+        "    if os.path.isfile(\"train_img.npy\") and os.path.isfile(\"train_mask.npy\"):\n",
+        "        print(\"Train file loaded from memory\")\n",
+        "        X_train = np.load(\"train_img.npy\")\n",
+        "        Y_train = np.load(\"train_mask.npy\")\n",
+        "        return X_train,Y_train\n",
+        "    a = Progbar(len(images))\n",
+        "    for n, p in enumerate(zip(images, masks)):\n",
+        "        path = p[0]\n",
+        "        img = imread(path)[:,:,:IMG_CHANNELS]\n",
+        "        img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)\n",
+        "        X_train[n] = img\n",
+        "        mask = np.zeros((IMG_HEIGHT, IMG_WIDTH, 1), dtype=bool)\n",
+        "        mask_ = imread(p[1])\n",
+        "        mask_ = np.expand_dims(resize(mask_, (IMG_HEIGHT, IMG_WIDTH), mode='constant',\n",
+        "                                    preserve_range=True), axis=-1)\n",
+        "        mask = np.maximum(mask, mask_)\n",
+        "        Y_train[n] = mask\n",
+        "        a.update(n)\n",
+        "    np.save(\"train_img\",X_train)\n",
+        "    np.save(\"train_mask\",Y_train)\n",
+        "    return X_train,Y_train"
+      ],
+      "metadata": {
+        "id": "-5ofUnvxVqCq"
+      },
+      "execution_count": 44,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "train_img,train_mask = read_train_data()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "isk8O_vZYcu0",
+        "outputId": "553b6c78-80fd-474c-f459-025eba3c110b"
+      },
+      "execution_count": 45,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Getting and resizing train images and masks ... \n",
+            "484/486 [============================>.] - ETA: 0s"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<h2> Model Training <h2>"
+      ],
+      "metadata": {
+        "id": "wEkgU8fPZqeC"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Metric function\n",
+        "def dice_coef(y_true, y_pred):\n",
+        "    y_true_f = K.flatten(y_true)\n",
+        "    y_pred_f = K.flatten(y_pred)\n",
+        "    intersection = K.sum(y_true_f * y_pred_f)\n",
+        "    return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)\n",
+        "\n",
+        "# Loss funtion\n",
+        "def dice_coef_loss(y_true, y_pred):\n",
+        "    return -dice_coef(y_true, y_pred)"
+      ],
+      "metadata": {
+        "id": "rLzB2Gt6YgYs"
+      },
+      "execution_count": 46,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "import random\n",
+        "import sys\n",
+        "import warnings\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "from itertools import chain\n",
+        "from skimage.io import imread, imshow, imread_collection, concatenate_images\n",
+        "from skimage.transform import resize\n",
+        "from skimage.morphology import label\n",
+        "from keras.utils import Progbar\n",
+        "\n",
+        "from keras.models import Model, load_model\n",
+        "from keras.layers import Input\n",
+        "# from keras.layers.core import Dropout, Lambda\n",
+        "from keras.layers import Dense, Activation, Dropout, Reshape, Permute, Lambda\n",
+        "from keras.layers import Conv2D, Conv2DTranspose,Convolution2D\n",
+        "from keras.layers import MaxPooling2D\n",
+        "from keras.layers import concatenate\n",
+        "from keras import backend as K\n",
+        "\n",
+        "warnings.filterwarnings('ignore', category=UserWarning, module='skimage')\n",
+        "\n",
+        "# Setting seed for reproducability\n",
+        "seed = 42\n",
+        "random.seed = seed\n",
+        "np.random.seed = seed\n",
+        "smooth = 1.\n",
+        "epochs = 50"
+      ],
+      "metadata": {
+        "id": "4pAW-luRZuhK"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def get_unet(IMG_WIDTH=256,IMG_HEIGHT=256,IMG_CHANNELS=3):\n",
+        "    inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))\n",
+        "\n",
+        "    c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (inputs)\n",
+        "    c1 = Dropout(0.1) (c1)\n",
+        "    c1 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c1)\n",
+        "    p1 = MaxPooling2D((2, 2)) (c1)\n",
+        "    c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p1)\n",
+        "    c2 = Dropout(0.1) (c2)\n",
+        "    c2 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c2)\n",
+        "    p2 = MaxPooling2D((2, 2)) (c2)\n",
+        "\n",
+        "    c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p2)\n",
+        "    c3 = Dropout(0.2) (c3)\n",
+        "    c3 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c3)\n",
+        "    p3 = MaxPooling2D((2, 2)) (c3)\n",
+        "\n",
+        "    c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p3)\n",
+        "    c4 = Dropout(0.2) (c4)\n",
+        "    c4 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c4)\n",
+        "    p4 = MaxPooling2D(pool_size=(2, 2)) (c4)\n",
+        "\n",
+        "    c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (p4)\n",
+        "    c5 = Dropout(0.3) (c5)\n",
+        "    c5 = Conv2D(256, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c5)\n",
+        "\n",
+        "    u6 = Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same') (c5)\n",
+        "    u6 = concatenate([u6, c4])\n",
+        "    c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u6)\n",
+        "    c6 = Dropout(0.2) (c6)\n",
+        "    c6 = Conv2D(128, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c6)\n",
+        "\n",
+        "    u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c6)\n",
+        "    u7 = concatenate([u7, c3])\n",
+        "    c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u7)\n",
+        "    c7 = Dropout(0.2) (c7)\n",
+        "    c7 = Conv2D(64, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c7)\n",
+        "\n",
+        "    u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c7)\n",
+        "    u8 = concatenate([u8, c2])\n",
+        "    c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u8)\n",
+        "    c8 = Dropout(0.1) (c8)\n",
+        "    c8 = Conv2D(32, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c8)\n",
+        "\n",
+        "    u9 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c8)\n",
+        "    u9 = concatenate([u9, c1], axis=3)\n",
+        "    c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (u9)\n",
+        "    c9 = Dropout(0.1) (c9)\n",
+        "    c9 = Conv2D(16, (3, 3), activation='elu', kernel_initializer='he_normal', padding='same') (c9)\n",
+        "\n",
+        "    outputs = Conv2D(1, (1, 1), activation='sigmoid') (c9)\n",
+        "\n",
+        "    model = Model(inputs=[inputs], outputs=[outputs])\n",
+        "    model.compile(optimizer='adam',loss='binary_crossentropy', metrics=[dice_coef])\n",
+        "    return model"
+      ],
+      "metadata": {
+        "id": "K0vUwUY8ZxJG"
+      },
+      "execution_count": 52,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "u_net = get_unet()\n",
+        "u_net.summary()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VOkye55GaiGX",
+        "outputId": "c52ca3ab-85ce-4c7c-e3c7-96c2bba48bec"
+      },
+      "execution_count": 53,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Model: \"model\"\n",
+            "__________________________________________________________________________________________________\n",
+            " Layer (type)                Output Shape                 Param #   Connected to                  \n",
+            "==================================================================================================\n",
+            " input_1 (InputLayer)        [(None, 256, 256, 3)]        0         []                            \n",
+            "                                                                                                  \n",
+            " conv2d (Conv2D)             (None, 256, 256, 16)         448       ['input_1[0][0]']             \n",
+            "                                                                                                  \n",
+            " dropout (Dropout)           (None, 256, 256, 16)         0         ['conv2d[0][0]']              \n",
+            "                                                                                                  \n",
+            " conv2d_1 (Conv2D)           (None, 256, 256, 16)         2320      ['dropout[0][0]']             \n",
+            "                                                                                                  \n",
+            " max_pooling2d (MaxPooling2  (None, 128, 128, 16)         0         ['conv2d_1[0][0]']            \n",
+            " D)                                                                                               \n",
+            "                                                                                                  \n",
+            " conv2d_2 (Conv2D)           (None, 128, 128, 32)         4640      ['max_pooling2d[0][0]']       \n",
+            "                                                                                                  \n",
+            " dropout_1 (Dropout)         (None, 128, 128, 32)         0         ['conv2d_2[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_3 (Conv2D)           (None, 128, 128, 32)         9248      ['dropout_1[0][0]']           \n",
+            "                                                                                                  \n",
+            " max_pooling2d_1 (MaxPoolin  (None, 64, 64, 32)           0         ['conv2d_3[0][0]']            \n",
+            " g2D)                                                                                             \n",
+            "                                                                                                  \n",
+            " conv2d_4 (Conv2D)           (None, 64, 64, 64)           18496     ['max_pooling2d_1[0][0]']     \n",
+            "                                                                                                  \n",
+            " dropout_2 (Dropout)         (None, 64, 64, 64)           0         ['conv2d_4[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_5 (Conv2D)           (None, 64, 64, 64)           36928     ['dropout_2[0][0]']           \n",
+            "                                                                                                  \n",
+            " max_pooling2d_2 (MaxPoolin  (None, 32, 32, 64)           0         ['conv2d_5[0][0]']            \n",
+            " g2D)                                                                                             \n",
+            "                                                                                                  \n",
+            " conv2d_6 (Conv2D)           (None, 32, 32, 128)          73856     ['max_pooling2d_2[0][0]']     \n",
+            "                                                                                                  \n",
+            " dropout_3 (Dropout)         (None, 32, 32, 128)          0         ['conv2d_6[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_7 (Conv2D)           (None, 32, 32, 128)          147584    ['dropout_3[0][0]']           \n",
+            "                                                                                                  \n",
+            " max_pooling2d_3 (MaxPoolin  (None, 16, 16, 128)          0         ['conv2d_7[0][0]']            \n",
+            " g2D)                                                                                             \n",
+            "                                                                                                  \n",
+            " conv2d_8 (Conv2D)           (None, 16, 16, 256)          295168    ['max_pooling2d_3[0][0]']     \n",
+            "                                                                                                  \n",
+            " dropout_4 (Dropout)         (None, 16, 16, 256)          0         ['conv2d_8[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_9 (Conv2D)           (None, 16, 16, 256)          590080    ['dropout_4[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_transpose (Conv2DTr  (None, 32, 32, 128)          131200    ['conv2d_9[0][0]']            \n",
+            " anspose)                                                                                         \n",
+            "                                                                                                  \n",
+            " concatenate (Concatenate)   (None, 32, 32, 256)          0         ['conv2d_transpose[0][0]',    \n",
+            "                                                                     'conv2d_7[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_10 (Conv2D)          (None, 32, 32, 128)          295040    ['concatenate[0][0]']         \n",
+            "                                                                                                  \n",
+            " dropout_5 (Dropout)         (None, 32, 32, 128)          0         ['conv2d_10[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_11 (Conv2D)          (None, 32, 32, 128)          147584    ['dropout_5[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_transpose_1 (Conv2D  (None, 64, 64, 64)           32832     ['conv2d_11[0][0]']           \n",
+            " Transpose)                                                                                       \n",
+            "                                                                                                  \n",
+            " concatenate_1 (Concatenate  (None, 64, 64, 128)          0         ['conv2d_transpose_1[0][0]',  \n",
+            " )                                                                   'conv2d_5[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_12 (Conv2D)          (None, 64, 64, 64)           73792     ['concatenate_1[0][0]']       \n",
+            "                                                                                                  \n",
+            " dropout_6 (Dropout)         (None, 64, 64, 64)           0         ['conv2d_12[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_13 (Conv2D)          (None, 64, 64, 64)           36928     ['dropout_6[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_transpose_2 (Conv2D  (None, 128, 128, 32)         8224      ['conv2d_13[0][0]']           \n",
+            " Transpose)                                                                                       \n",
+            "                                                                                                  \n",
+            " concatenate_2 (Concatenate  (None, 128, 128, 64)         0         ['conv2d_transpose_2[0][0]',  \n",
+            " )                                                                   'conv2d_3[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_14 (Conv2D)          (None, 128, 128, 32)         18464     ['concatenate_2[0][0]']       \n",
+            "                                                                                                  \n",
+            " dropout_7 (Dropout)         (None, 128, 128, 32)         0         ['conv2d_14[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_15 (Conv2D)          (None, 128, 128, 32)         9248      ['dropout_7[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_transpose_3 (Conv2D  (None, 256, 256, 16)         2064      ['conv2d_15[0][0]']           \n",
+            " Transpose)                                                                                       \n",
+            "                                                                                                  \n",
+            " concatenate_3 (Concatenate  (None, 256, 256, 32)         0         ['conv2d_transpose_3[0][0]',  \n",
+            " )                                                                   'conv2d_1[0][0]']            \n",
+            "                                                                                                  \n",
+            " conv2d_16 (Conv2D)          (None, 256, 256, 16)         4624      ['concatenate_3[0][0]']       \n",
+            "                                                                                                  \n",
+            " dropout_8 (Dropout)         (None, 256, 256, 16)         0         ['conv2d_16[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_17 (Conv2D)          (None, 256, 256, 16)         2320      ['dropout_8[0][0]']           \n",
+            "                                                                                                  \n",
+            " conv2d_18 (Conv2D)          (None, 256, 256, 1)          17        ['conv2d_17[0][0]']           \n",
+            "                                                                                                  \n",
+            "==================================================================================================\n",
+            "Total params: 1941105 (7.40 MB)\n",
+            "Trainable params: 1941105 (7.40 MB)\n",
+            "Non-trainable params: 0 (0.00 Byte)\n",
+            "__________________________________________________________________________________________________\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(\"\\nTraining...\")\n",
+        "u_net.fit(train_img,train_mask,batch_size=96,epochs=15)"
+      ],
+      "metadata": {
+        "id": "rr7EaxYjakKA"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from PIL import Image"
+      ],
+      "metadata": {
+        "id": "fn5m8NIXtPqo"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "im = Image.open('/content/data/images/patches_i/1_09-1339-01-2.bmp')"
+      ],
+      "metadata": {
+        "id": "o9oGptIgap-h"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Image.open('/content/data/images/patches_i/1_09-1339-01-2.bmp')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 273
+        },
+        "id": "Jgz1HBxWnL1L",
+        "outputId": "e24f011f-2cf0-42d7-fad3-812f0e247346"
+      },
+      "execution_count": 5,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<PIL.BmpImagePlugin.BmpImageFile image mode=RGB size=256x256>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {},
+          "execution_count": 5
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "px = np.array(im)/255\n",
+        "px = px.reshape((1,256,256,3))\n",
+        "e = u_net.predict(px).reshape((256,256))\n",
+        "# Image.fromarray((e*255).astype('uint8'))"
+      ],
+      "metadata": {
+        "id": "zoyzh1Rsl3r3"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<h2> Segmentation Model Output <h2>"
+      ],
+      "metadata": {
+        "id": "CSiGazUTrEFw"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "threshold = 0.0  # Adjust this threshold as needed\n",
+        "bw_image = np.where(e > threshold, 255, 0)\n",
+        "\n",
+        "# Convert to uint8 and create a PIL Image\n",
+        "bw_image = bw_image.astype('uint8')\n",
+        "Image.fromarray(bw_image)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 273
+        },
+        "id": "zUrVL-MInz2Q",
+        "outputId": "0d2cc938-c34e-4b9e-f5d4-57b4e4569edf"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<PIL.Image.Image image mode=L size=256x256>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAAAAAB5Gfe6AAAEi0lEQVR4nO2d3XrbMAxDlX17/1fuLrK0zZo2+gEIMMO5bkzqmGJsR3LHCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEF6GS1mkN3kGuvDfjf0zKg+/CmLMjH/ujwgQxS8PSVIEtKA7Z1RhgBNzv57LHeADHk/mWgfwaIhmVqkAGwvVygsNIEMBv8nqDACvA5Df5HVXBTDV6JSragAUh3HGahT8Pj+E6iIWw7Fm4vBLSuC0CTJPf0lpHQrg5lhhYLsH9J75H2zOs6rh89vAToTKk083sB6guPbZBlaPXz/1yQaWDq9pfFwDK1+Dr9L471gQoBo/N+68gJc8/wsCXnT80x1GO35iH5ysAPH5l99yOtQ/qQoqfhu0ZkqAQwGwmBHgMX5SFo2mAMfA89bicf7HGJw+2KgCOOeilQCGgV4CCAaaCcAb6CYATjsB6BJoJwBtoJ8AMA0FYEvguQDxWt4HQA1MVICfASQNpwC2BKZOr9H90A1YWXYVMFAOpqbAK3eBuR5gaQBTl4tD85oMiPOy+C3gVQqShdleNXB+SjY+b6bg0MDux30siARcsdBwNoSzS2GvnrgFYAjqMjgbgu1+gQWOxgC7G7w0nQ6em6bWOBqD1c7RTTwFjFEmwVfAqHHg0QS/wb438p8JmhsoeCjqbeDn7NZn8OPjcTsBrQlup/3loFQBtEvh06zvDi1f67n8afQjR54BhgBotrcQLAWE5wHYVG9H87wkeJAUc0Gi3y7zMgEfwbzeNPD10xXf2eU/7658nH37csGGOW0sX5og/fbtbwBQRzw+TO1F279Bz4MdC5CsEHkfN/78nR+hemP8UTzAPJIJQEwERB/59xilz3XPFGDaqFTAXfjVyJyvkeoH+7vhcbcVYgGbT2SAt1VyAepHhvfhG/60dYrDUtk35Q/sVQ/unqIqA4cKkGIjwOHN0r3XumxiUwFDdAI+CVAXgCYDpwoQX4fpC2CMUd8I3ivAZPzlAB/PIamrA/BDaiQ1EowFjFEh4doDXMdfkNilJswB5CLwug54BPlm+TLMC2CMQa2Ci//ox2Aa8J8CYwzmPGgigDdP2whgFUEfAaQi6CSAQisBjFnQSgBDQTMBeAXtBKBpKKD6RUp+VL9IyQ+kgZYCkAZ6CgDSVACuBJoKwBnoKgBGBKgTUBMB6gTURIA6ATURoE5ATQSoE1ATAeoE1HQVAPu5uKsAGBGgTmAP3IKJngKAC0ZaCkAumNn+5+sVfLOCC7pgyLoC3gb/3TPWFXDlcl8FYCHWFXCDWQTm6wSrFkv/x0SAOoGf4U9QcwF8A+4C6ESAOoFnsOeAvQA2EaBOQI2/AHIT8BdANtBAANdABwFUAy0EMIkAdQJTEOdADwFEmgjglUATATy6CMjeYRYRoE5gluwez+7x7B6n0EoAowRaCWAQAeoE1PQSkDdI4IkAdQJqIkCdgJoIUCegJgLUCaiJAHUCaiJAncAShLXTrQQw1o53EkBZO99IAGfvQCMBHBrsGbrC2juSClAnMAVx61CLCmBunWpQAdydY38AQZSkM8vukHsAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<h2> Actual Mask <h2>"
+      ],
+      "metadata": {
+        "id": "nJSTWqw-n8ej"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from IPython.display import display\n",
+        "\n",
+        "im1=Image.open('/content/data/anno_masks/patches_m/1_09-1339-01-2_anno.bmp')\n",
+        "\n",
+        "im1_gray = im1.convert('L')\n",
+        "\n",
+        "threshold = 0.0\n",
+        "bw_image = im1_gray.point(lambda p: p > threshold and 255)\n",
+        "\n",
+        "display(bw_image)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 273
+        },
+        "id": "ytuvV8NimBVe",
+        "outputId": "b4a918f4-4ade-4f7f-fc8e-8ce6d2817dce"
+      },
+      "execution_count": 137,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<PIL.Image.Image image mode=L size=256x256>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAAAAAB5Gfe6AAAEi0lEQVR4nO2d3XrbMAxDlX17/1fuLrK0zZo2+gEIMMO5bkzqmGJsR3LHCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEF6GS1mkN3kGuvDfjf0zKg+/CmLMjH/ujwgQxS8PSVIEtKA7Z1RhgBNzv57LHeADHk/mWgfwaIhmVqkAGwvVygsNIEMBv8nqDACvA5Df5HVXBTDV6JSragAUh3HGahT8Pj+E6iIWw7Fm4vBLSuC0CTJPf0lpHQrg5lhhYLsH9J75H2zOs6rh89vAToTKk083sB6guPbZBlaPXz/1yQaWDq9pfFwDK1+Dr9L471gQoBo/N+68gJc8/wsCXnT80x1GO35iH5ysAPH5l99yOtQ/qQoqfhu0ZkqAQwGwmBHgMX5SFo2mAMfA89bicf7HGJw+2KgCOOeilQCGgV4CCAaaCcAb6CYATjsB6BJoJwBtoJ8AMA0FYEvguQDxWt4HQA1MVICfASQNpwC2BKZOr9H90A1YWXYVMFAOpqbAK3eBuR5gaQBTl4tD85oMiPOy+C3gVQqShdleNXB+SjY+b6bg0MDux30siARcsdBwNoSzS2GvnrgFYAjqMjgbgu1+gQWOxgC7G7w0nQ6em6bWOBqD1c7RTTwFjFEmwVfAqHHg0QS/wb438p8JmhsoeCjqbeDn7NZn8OPjcTsBrQlup/3loFQBtEvh06zvDi1f67n8afQjR54BhgBotrcQLAWE5wHYVG9H87wkeJAUc0Gi3y7zMgEfwbzeNPD10xXf2eU/7658nH37csGGOW0sX5og/fbtbwBQRzw+TO1F279Bz4MdC5CsEHkfN/78nR+hemP8UTzAPJIJQEwERB/59xilz3XPFGDaqFTAXfjVyJyvkeoH+7vhcbcVYgGbT2SAt1VyAepHhvfhG/60dYrDUtk35Q/sVQ/unqIqA4cKkGIjwOHN0r3XumxiUwFDdAI+CVAXgCYDpwoQX4fpC2CMUd8I3ivAZPzlAB/PIamrA/BDaiQ1EowFjFEh4doDXMdfkNilJswB5CLwug54BPlm+TLMC2CMQa2Ci//ox2Aa8J8CYwzmPGgigDdP2whgFUEfAaQi6CSAQisBjFnQSgBDQTMBeAXtBKBpKKD6RUp+VL9IyQ+kgZYCkAZ6CgDSVACuBJoKwBnoKgBGBKgTUBMB6gTURIA6ATURoE5ATQSoE1ATAeoE1HQVAPu5uKsAGBGgTmAP3IKJngKAC0ZaCkAumNn+5+sVfLOCC7pgyLoC3gb/3TPWFXDlcl8FYCHWFXCDWQTm6wSrFkv/x0SAOoGf4U9QcwF8A+4C6ESAOoFnsOeAvQA2EaBOQI2/AHIT8BdANtBAANdABwFUAy0EMIkAdQJTEOdADwFEmgjglUATATy6CMjeYRYRoE5gluwez+7x7B6n0EoAowRaCWAQAeoE1PQSkDdI4IkAdQJqIkCdgJoIUCegJgLUCaiJAHUCaiJAncAShLXTrQQw1o53EkBZO99IAGfvQCMBHBrsGbrC2juSClAnMAVx61CLCmBunWpQAdydY38AQZSkM8vukHsAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "u_net.save('tubule_seg_model.hdf5')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jTPi_9Qkp3bP",
+        "outputId": "c187d392-21b0-4bfd-9c02-b8f7ff535562"
+      },
+      "execution_count": 157,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
+            "  saving_api.save_model(\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<h2> Conversion <h2>"
+      ],
+      "metadata": {
+        "id": "qt9zzcwUzp7Z"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install tensorflowjs\n",
+        "!tensorflowjs_converter --input_format=keras ./model.hdf5 ./tfjs_model"
+      ],
+      "metadata": {
+        "id": "eFSp4yAJxxNL"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "-PGF5NavzPc2"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Segmentation Sample Models/tubule-segmentation/model.hdf5 b/Segmentation Sample Models/tubule-segmentation/model.hdf5
new file mode 100644
index 0000000..2120361
Binary files /dev/null and b/Segmentation Sample Models/tubule-segmentation/model.hdf5 differ
diff --git a/Segmentation Sample Models/tubule-segmentation/tfjs_model/group1-shard1of2.bin b/Segmentation Sample Models/tubule-segmentation/tfjs_model/group1-shard1of2.bin
new file mode 100644
index 0000000..bef1b0c
Binary files /dev/null and b/Segmentation Sample Models/tubule-segmentation/tfjs_model/group1-shard1of2.bin differ
diff --git a/Segmentation Sample Models/tubule-segmentation/tfjs_model/group1-shard2of2.bin b/Segmentation Sample Models/tubule-segmentation/tfjs_model/group1-shard2of2.bin
new file mode 100644
index 0000000..b568524
Binary files /dev/null and b/Segmentation Sample Models/tubule-segmentation/tfjs_model/group1-shard2of2.bin differ
diff --git a/Segmentation Sample Models/tubule-segmentation/tfjs_model/model.json b/Segmentation Sample Models/tubule-segmentation/tfjs_model/model.json
new file mode 100644
index 0000000..9dcaecf
--- /dev/null
+++ b/Segmentation Sample Models/tubule-segmentation/tfjs_model/model.json	
@@ -0,0 +1 @@
+{"format": "layers-model", "generatedBy": "keras v2.15.0", "convertedBy": "TensorFlow.js Converter v4.17.0", "modelTopology": {"keras_version": "2.15.0", "backend": "tensorflow", "model_config": {"class_name": "Functional", "config": {"name": "model", "trainable": true, "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": [null, 256, 256, 3], "dtype": "float32", "sparse": false, "ragged": false, "name": "input_1"}, "name": "input_1", "inbound_nodes": []}, {"class_name": "Conv2D", "config": {"name": "conv2d", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d", "inbound_nodes": [[["input_1", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout", "trainable": true, "dtype": "float32", "rate": 0.1, "noise_shape": null, "seed": null}, "name": "dropout", "inbound_nodes": [[["conv2d", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_1", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_1", "inbound_nodes": [[["dropout", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "max_pooling2d", "inbound_nodes": [[["conv2d_1", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_2", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_2", "inbound_nodes": [[["max_pooling2d", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_1", "trainable": true, "dtype": "float32", "rate": 0.1, "noise_shape": null, "seed": null}, "name": "dropout_1", "inbound_nodes": [[["conv2d_2", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_3", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_3", "inbound_nodes": [[["dropout_1", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_1", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "max_pooling2d_1", "inbound_nodes": [[["conv2d_3", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_4", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_4", "inbound_nodes": [[["max_pooling2d_1", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_2", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "name": "dropout_2", "inbound_nodes": [[["conv2d_4", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_5", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_5", "inbound_nodes": [[["dropout_2", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_2", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "max_pooling2d_2", "inbound_nodes": [[["conv2d_5", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_6", "trainable": true, "dtype": "float32", "filters": 128, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_6", "inbound_nodes": [[["max_pooling2d_2", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_3", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "name": "dropout_3", "inbound_nodes": [[["conv2d_6", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_7", "trainable": true, "dtype": "float32", "filters": 128, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_7", "inbound_nodes": [[["dropout_3", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_3", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "max_pooling2d_3", "inbound_nodes": [[["conv2d_7", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_8", "trainable": true, "dtype": "float32", "filters": 256, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_8", "inbound_nodes": [[["max_pooling2d_3", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_4", "trainable": true, "dtype": "float32", "rate": 0.3, "noise_shape": null, "seed": null}, "name": "dropout_4", "inbound_nodes": [[["conv2d_8", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_9", "trainable": true, "dtype": "float32", "filters": 256, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_9", "inbound_nodes": [[["dropout_4", 0, 0, {}]]]}, {"class_name": "Conv2DTranspose", "config": {"name": "conv2d_transpose", "trainable": true, "dtype": "float32", "filters": 128, "kernel_size": [2, 2], "strides": [2, 2], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null, "output_padding": null}, "name": "conv2d_transpose", "inbound_nodes": [[["conv2d_9", 0, 0, {}]]]}, {"class_name": "Concatenate", "config": {"name": "concatenate", "trainable": true, "dtype": "float32", "axis": -1}, "name": "concatenate", "inbound_nodes": [[["conv2d_transpose", 0, 0, {}], ["conv2d_7", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_10", "trainable": true, "dtype": "float32", "filters": 128, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_10", "inbound_nodes": [[["concatenate", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_5", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "name": "dropout_5", "inbound_nodes": [[["conv2d_10", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_11", "trainable": true, "dtype": "float32", "filters": 128, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_11", "inbound_nodes": [[["dropout_5", 0, 0, {}]]]}, {"class_name": "Conv2DTranspose", "config": {"name": "conv2d_transpose_1", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": [2, 2], "strides": [2, 2], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null, "output_padding": null}, "name": "conv2d_transpose_1", "inbound_nodes": [[["conv2d_11", 0, 0, {}]]]}, {"class_name": "Concatenate", "config": {"name": "concatenate_1", "trainable": true, "dtype": "float32", "axis": -1}, "name": "concatenate_1", "inbound_nodes": [[["conv2d_transpose_1", 0, 0, {}], ["conv2d_5", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_12", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_12", "inbound_nodes": [[["concatenate_1", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_6", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "name": "dropout_6", "inbound_nodes": [[["conv2d_12", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_13", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_13", "inbound_nodes": [[["dropout_6", 0, 0, {}]]]}, {"class_name": "Conv2DTranspose", "config": {"name": "conv2d_transpose_2", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": [2, 2], "strides": [2, 2], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null, "output_padding": null}, "name": "conv2d_transpose_2", "inbound_nodes": [[["conv2d_13", 0, 0, {}]]]}, {"class_name": "Concatenate", "config": {"name": "concatenate_2", "trainable": true, "dtype": "float32", "axis": -1}, "name": "concatenate_2", "inbound_nodes": [[["conv2d_transpose_2", 0, 0, {}], ["conv2d_3", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_14", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_14", "inbound_nodes": [[["concatenate_2", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_7", "trainable": true, "dtype": "float32", "rate": 0.1, "noise_shape": null, "seed": null}, "name": "dropout_7", "inbound_nodes": [[["conv2d_14", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_15", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_15", "inbound_nodes": [[["dropout_7", 0, 0, {}]]]}, {"class_name": "Conv2DTranspose", "config": {"name": "conv2d_transpose_3", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": [2, 2], "strides": [2, 2], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "linear", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null, "output_padding": null}, "name": "conv2d_transpose_3", "inbound_nodes": [[["conv2d_15", 0, 0, {}]]]}, {"class_name": "Concatenate", "config": {"name": "concatenate_3", "trainable": true, "dtype": "float32", "axis": 3}, "name": "concatenate_3", "inbound_nodes": [[["conv2d_transpose_3", 0, 0, {}], ["conv2d_1", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_16", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_16", "inbound_nodes": [[["concatenate_3", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_8", "trainable": true, "dtype": "float32", "rate": 0.1, "noise_shape": null, "seed": null}, "name": "dropout_8", "inbound_nodes": [[["conv2d_16", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_17", "trainable": true, "dtype": "float32", "filters": 16, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "elu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_17", "inbound_nodes": [[["dropout_8", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "conv2d_18", "trainable": true, "dtype": "float32", "filters": 1, "kernel_size": [1, 1], "strides": [1, 1], "padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "sigmoid", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv2d_18", "inbound_nodes": [[["conv2d_17", 0, 0, {}]]]}], "input_layers": [["input_1", 0, 0]], "output_layers": [["conv2d_18", 0, 0]]}}, "training_config": {"loss": "binary_crossentropy", "metrics": [[{"class_name": "MeanMetricWrapper", "config": {"name": "dice_coef", "dtype": "float32", "fn": "dice_coef"}}]], "weighted_metrics": null, "loss_weights": null, "optimizer_config": {"class_name": "Custom>Adam", "config": {"name": "Adam", "weight_decay": null, "clipnorm": null, "global_clipnorm": null, "clipvalue": null, "use_ema": false, "ema_momentum": 0.99, "ema_overwrite_frequency": null, "jit_compile": false, "is_legacy_optimizer": false, "learning_rate": 0.0010000000474974513, "beta_1": 0.9, "beta_2": 0.999, "epsilon": 1e-07, "amsgrad": false}}}}, "weightsManifest": [{"paths": ["group1-shard1of2.bin", "group1-shard2of2.bin"], "weights": [{"name": "conv2d/kernel", "shape": [3, 3, 3, 16], "dtype": "float32"}, {"name": "conv2d/bias", "shape": [16], "dtype": "float32"}, {"name": "conv2d_1/kernel", "shape": [3, 3, 16, 16], "dtype": "float32"}, {"name": "conv2d_1/bias", "shape": [16], "dtype": "float32"}, {"name": "conv2d_10/kernel", "shape": [3, 3, 256, 128], "dtype": "float32"}, {"name": "conv2d_10/bias", "shape": [128], "dtype": "float32"}, {"name": "conv2d_11/kernel", "shape": [3, 3, 128, 128], "dtype": "float32"}, {"name": "conv2d_11/bias", "shape": [128], "dtype": "float32"}, {"name": "conv2d_12/kernel", "shape": [3, 3, 128, 64], "dtype": "float32"}, {"name": "conv2d_12/bias", "shape": [64], "dtype": "float32"}, {"name": "conv2d_13/kernel", "shape": [3, 3, 64, 64], "dtype": "float32"}, {"name": "conv2d_13/bias", "shape": [64], "dtype": "float32"}, {"name": "conv2d_14/kernel", "shape": [3, 3, 64, 32], "dtype": "float32"}, {"name": "conv2d_14/bias", "shape": [32], "dtype": "float32"}, {"name": "conv2d_15/kernel", "shape": [3, 3, 32, 32], "dtype": "float32"}, {"name": "conv2d_15/bias", "shape": [32], "dtype": "float32"}, {"name": "conv2d_16/kernel", "shape": [3, 3, 32, 16], "dtype": "float32"}, {"name": "conv2d_16/bias", "shape": [16], "dtype": "float32"}, {"name": "conv2d_17/kernel", "shape": [3, 3, 16, 16], "dtype": "float32"}, {"name": "conv2d_17/bias", "shape": [16], "dtype": "float32"}, {"name": "conv2d_18/kernel", "shape": [1, 1, 16, 1], "dtype": "float32"}, {"name": "conv2d_18/bias", "shape": [1], "dtype": "float32"}, {"name": "conv2d_2/kernel", "shape": [3, 3, 16, 32], "dtype": "float32"}, {"name": "conv2d_2/bias", "shape": [32], "dtype": "float32"}, {"name": "conv2d_3/kernel", "shape": [3, 3, 32, 32], "dtype": "float32"}, {"name": "conv2d_3/bias", "shape": [32], "dtype": "float32"}, {"name": "conv2d_4/kernel", "shape": [3, 3, 32, 64], "dtype": "float32"}, {"name": "conv2d_4/bias", "shape": [64], "dtype": "float32"}, {"name": "conv2d_5/kernel", "shape": [3, 3, 64, 64], "dtype": "float32"}, {"name": "conv2d_5/bias", "shape": [64], "dtype": "float32"}, {"name": "conv2d_6/kernel", "shape": [3, 3, 64, 128], "dtype": "float32"}, {"name": "conv2d_6/bias", "shape": [128], "dtype": "float32"}, {"name": "conv2d_7/kernel", "shape": [3, 3, 128, 128], "dtype": "float32"}, {"name": "conv2d_7/bias", "shape": [128], "dtype": "float32"}, {"name": "conv2d_8/kernel", "shape": [3, 3, 128, 256], "dtype": "float32"}, {"name": "conv2d_8/bias", "shape": [256], "dtype": "float32"}, {"name": "conv2d_9/kernel", "shape": [3, 3, 256, 256], "dtype": "float32"}, {"name": "conv2d_9/bias", "shape": [256], "dtype": "float32"}, {"name": "conv2d_transpose/kernel", "shape": [2, 2, 128, 256], "dtype": "float32"}, {"name": "conv2d_transpose/bias", "shape": [128], "dtype": "float32"}, {"name": "conv2d_transpose_1/kernel", "shape": [2, 2, 64, 128], "dtype": "float32"}, {"name": "conv2d_transpose_1/bias", "shape": [64], "dtype": "float32"}, {"name": "conv2d_transpose_2/kernel", "shape": [2, 2, 32, 64], "dtype": "float32"}, {"name": "conv2d_transpose_2/bias", "shape": [32], "dtype": "float32"}, {"name": "conv2d_transpose_3/kernel", "shape": [2, 2, 16, 32], "dtype": "float32"}, {"name": "conv2d_transpose_3/bias", "shape": [16], "dtype": "float32"}]}]}
\ No newline at end of file