From 2dff63bedc0460b75faa86b973916196d8c65590 Mon Sep 17 00:00:00 2001 From: Reetika-A <163577113+Reetika-A@users.noreply.github.com> Date: Sun, 16 Jun 2024 23:46:57 +0530 Subject: [PATCH 1/5] Add files via upload --- Task/Q1.ipynb | 55 +++++++++++++++++++++++ Task/Q10.ipynb | 66 ++++++++++++++++++++++++++++ Task/Q2.ipynb | 89 +++++++++++++++++++++++++++++++++++++ Task/Q3.ipynb | 70 +++++++++++++++++++++++++++++ Task/Q5.ipynb | 117 +++++++++++++++++++++++++++++++++++++++++++++++++ Task/Q6.ipynb | 74 +++++++++++++++++++++++++++++++ Task/Q7.ipynb | 69 +++++++++++++++++++++++++++++ Task/Q8.ipynb | 49 +++++++++++++++++++++ 8 files changed, 589 insertions(+) create mode 100644 Task/Q1.ipynb create mode 100644 Task/Q10.ipynb create mode 100644 Task/Q2.ipynb create mode 100644 Task/Q3.ipynb create mode 100644 Task/Q5.ipynb create mode 100644 Task/Q6.ipynb create mode 100644 Task/Q7.ipynb create mode 100644 Task/Q8.ipynb diff --git a/Task/Q1.ipynb b/Task/Q1.ipynb new file mode 100644 index 0000000..a990f2a --- /dev/null +++ b/Task/Q1.ipynb @@ -0,0 +1,55 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Q1. Given two strings s and t, return true if t is an anagram of s, and false otherwise" + ], + "metadata": { + "id": "SU_J1Ndf0ym7" + } + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jGOGuVeij9uL", + "outputId": "a98ce750-2f91-4ce7-ec04-1550c9f91495" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "True\n" + ] + } + ], + "source": [ + "def is_it_anagram(a, b):\n", + " return sorted(a) == sorted(b)\n", + "\n", + "a1 = \"sharp\"\n", + "b1 = \"harps\"\n", + "print(is_it_anagram(a1, b1))\n" + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q10.ipynb b/Task/Q10.ipynb new file mode 100644 index 0000000..2b39cbc --- /dev/null +++ b/Task/Q10.ipynb @@ -0,0 +1,66 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 10: We need to transpose a 2D integer array matrix." + ], + "metadata": { + "id": "fOtyyF31_PE5" + } + }, + { + "cell_type": "code", + "source": [ + "def transpose_matrix(matrix):\n", + " transposed = []\n", + " for i in range(len(matrix[0])):\n", + " new_row = []\n", + " for row in matrix:\n", + " new_row.append(row[i])\n", + " transposed.append(new_row)\n", + " return transposed\n", + "\n", + "\n", + "matrix_input = [\n", + " [2, 9, 0],\n", + " [7, 2, 0],\n", + " [0, 4, 1]\n", + "]\n", + "print(transpose_matrix(matrix_input))\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oWPev5kZ_U3x", + "outputId": "6307b4bd-a006-4c1e-bffc-47270b8488b4" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[2, 7, 0], [9, 2, 4], [0, 0, 1]]\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q2.ipynb b/Task/Q2.ipynb new file mode 100644 index 0000000..e32be30 --- /dev/null +++ b/Task/Q2.ipynb @@ -0,0 +1,89 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 2: We need to count the frequency of each character in a string, considering upper and lower case letters separately, and ignoring spaces." + ], + "metadata": { + "id": "QLiWt8by7F1d" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lot-iyh0lZFs", + "outputId": "790f7a73-cc9f-463a-cd0a-96e595f1c49d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The character T , appears : 1 number of times.\n", + "The character a , appears : 1 number of times.\n", + "The character b , appears : 1 number of times.\n", + "The character c , appears : 1 number of times.\n", + "The character d , appears : 2 number of times.\n", + "The character e , appears : 4 number of times.\n", + "The character f , appears : 1 number of times.\n", + "The character g , appears : 1 number of times.\n", + "The character h , appears : 2 number of times.\n", + "The character i , appears : 1 number of times.\n", + "The character j , appears : 1 number of times.\n", + "The character k , appears : 1 number of times.\n", + "The character l , appears : 1 number of times.\n", + "The character m , appears : 1 number of times.\n", + "The character n , appears : 1 number of times.\n", + "The character o , appears : 4 number of times.\n", + "The character p , appears : 1 number of times.\n", + "The character q , appears : 1 number of times.\n", + "The character r , appears : 2 number of times.\n", + "The character t , appears : 1 number of times.\n", + "The character u , appears : 2 number of times.\n", + "The character v , appears : 1 number of times.\n", + "The character w , appears : 1 number of times.\n", + "The character x , appears : 1 number of times.\n", + "The character y , appears : 1 number of times.\n", + "The character z , appears : 1 number of times.\n" + ] + } + ], + "source": [ + "def frequency_of_characters(s):\n", + " freq = {}\n", + " for char in s:\n", + " if char.isalpha():\n", + " if char in freq:\n", + " freq[char] += 1\n", + " else:\n", + " freq[char] = 1\n", + "\n", + " sorted_chars = sorted(freq.keys())\n", + " for char in sorted_chars:\n", + " print(\"The character \", char ,\", appears :\", freq[char] ,\" number of times.\")\n", + "\n", + "input_str = \"The quick brown fox jumped over the lazy dog\"\n", + "frequency_of_characters(input_str)" + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q3.ipynb b/Task/Q3.ipynb new file mode 100644 index 0000000..4d41e63 --- /dev/null +++ b/Task/Q3.ipynb @@ -0,0 +1,70 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 3: To increment a large integer represented as an array of digits, we can process the array from the end to handle the carry." + ], + "metadata": { + "id": "ilf-SW998Rhi" + } + }, + { + "cell_type": "code", + "source": [ + "def increment_number(digits):\n", + "\n", + " reversed_digits = digits[::-1]\n", + "\n", + " length = len(reversed_digits)\n", + " for i in range(length):\n", + " if reversed_digits[i] < 9:\n", + " reversed_digits[i] += 1\n", + " break\n", + " else:\n", + " reversed_digits[i] = 0\n", + "\n", + "\n", + " digits = reversed_digits[::-1]\n", + "\n", + " return digits\n", + "\n", + "\n", + "digits_input = [1, 4, 3, 1, 9]\n", + "print(increment_number(digits_input))\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-DABAC498TsN", + "outputId": "2615b9d0-f08c-40c5-f0dc-3e542dd0d503" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[1, 4, 3, 2, 0]\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q5.ipynb b/Task/Q5.ipynb new file mode 100644 index 0000000..223bd26 --- /dev/null +++ b/Task/Q5.ipynb @@ -0,0 +1,117 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 5: Alternative way, that is taking images from a URL" + ], + "metadata": { + "id": "3ojSEOf9Fup9" + } + }, + { + "cell_type": "code", + "source": [ + "# We need some additional packages\n", + "!pip install opencv-python-headless numpy requests pillow\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gWwKTYCtFy9H", + "outputId": "a0f40e11-3d91-4129-c0fd-19ee6d5ad62b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: opencv-python-headless in /usr/local/lib/python3.10/dist-packages (4.10.0.82)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (2.31.0)\n", + "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (9.4.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests) (2024.6.2)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cv2\n", + "import numpy as np\n", + "import requests\n", + "from PIL import Image\n", + "from io import BytesIO\n", + "from google.colab.patches import cv2_imshow\n", + "\n", + "def detect_edges_from_url(image_url):\n", + " response = requests.get(image_url)\n", + " img = Image.open(BytesIO(response.content)).convert('RGB')\n", + " img = np.array(img)\n", + "\n", + " # Converting to grayscale\n", + " gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n", + "\n", + " edges = cv2.Canny(gray, 100, 200)\n", + "\n", + " cv2_imshow(cv2.cvtColor(img, cv2.COLOR_RGB2BGR))\n", + " cv2_imshow(edges)\n", + "\n", + "# Example:\n", + "image_url = \"https://www.omlet.nl/images/cache/438/512/90/Dog-Labrador_Retriever-A_healthy_adult_Labrador_sitting%2C_waiting_for_some_attention_from_it%27s_owner.webp\"\n", + "detect_edges_from_url(image_url)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "dMeHG0XpF7M0", + "outputId": "4440312a-1446-4da1-ba18-f8a11321e2d4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q6.ipynb b/Task/Q6.ipynb new file mode 100644 index 0000000..cd4ebce --- /dev/null +++ b/Task/Q6.ipynb @@ -0,0 +1,74 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 6: We need to find the prime numbers in an array and compute the absolute difference between the smallest and largest ones." + ], + "metadata": { + "id": "-z36PJSu-YXl" + } + }, + { + "cell_type": "code", + "source": [ + "def is_prime(n):\n", + " if n <= 1:\n", + " return False\n", + " for i in range(2, n):\n", + " if n % i == 0:\n", + " return False\n", + " return True\n", + "\n", + "def prime_difference(N, A):\n", + " primes = []\n", + " for i in range(N):\n", + " if is_prime(A[i]):\n", + " primes.append(A[i])\n", + "\n", + " if len(primes) == 0:\n", + " return 1\n", + "\n", + " smallest_prime = min(primes)\n", + " largest_prime = max(primes)\n", + " return largest_prime - smallest_prime\n", + "\n", + "A = [1, 2, 3, 4, 5, 41] # Array\n", + "N = 6 # Array Size\n", + "print(prime_difference(N, A))\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8zjDJhLc-eQJ", + "outputId": "77c16a39-e2f1-48a1-d902-7c8993d510a6" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "39\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q7.ipynb b/Task/Q7.ipynb new file mode 100644 index 0000000..5738029 --- /dev/null +++ b/Task/Q7.ipynb @@ -0,0 +1,69 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 7: For each product, we need to find the minimum prime factor of its MRP." + ], + "metadata": { + "id": "xp5I8Z40-ktO" + } + }, + { + "cell_type": "code", + "source": [ + "def smallest_prime_factor(n):\n", + " if n <= 1:\n", + " return n\n", + " for i in range(2, n + 1):\n", + " if n % i == 0:\n", + " return i\n", + " return n\n", + "\n", + "def amount_roy_pays(N, prices):\n", + " results = []\n", + " for price in prices:\n", + " min_prime = smallest_prime_factor(price)\n", + " roy_pays = price - min_prime\n", + " results.append(roy_pays)\n", + " return results\n", + "\n", + "\n", + "N = 2 # Array Size\n", + "prices = [5, 10] # Value of prices!\n", + "print(amount_roy_pays(N, prices))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jd8Qoge_-pSC", + "outputId": "8fda6619-fcff-4b84-9e36-63e607c0f10e" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[0, 8]\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/Task/Q8.ipynb b/Task/Q8.ipynb new file mode 100644 index 0000000..86474a6 --- /dev/null +++ b/Task/Q8.ipynb @@ -0,0 +1,49 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Problem 8: We need to count the frequency of each element in a list and return it as a dictionary." + ], + "metadata": { + "id": "Wx6GsI5k-tWE" + } + }, + { + "cell_type": "code", + "source": [ + "def frequency_count(input_list):\n", + " frequency = {}\n", + " for element in input_list:\n", + " if element in frequency:\n", + " frequency[element] += 1\n", + " else:\n", + " frequency[element] = 1\n", + " return frequency\n", + "\n", + "\n", + "input_list = [1, 2, 2, 3, 3, 3]\n", + "print(frequency_count(input_list))\n" + ], + "metadata": { + "id": "u6xn0fsr-yUe" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 9a1ba697521bca7324841692dff465f2a0ac86d2 Mon Sep 17 00:00:00 2001 From: Reetika-A <163577113+Reetika-A@users.noreply.github.com> Date: Mon, 17 Jun 2024 23:37:30 +0530 Subject: [PATCH 2/5] Delete Task directory --- Task/Q1.ipynb | 55 --------------- Task/Q10.ipynb | 66 ------------------ Task/Q2.ipynb | 89 ------------------------ Task/Q3.ipynb | 70 ------------------- Task/Q5.ipynb | 117 -------------------------------- Task/Q6.ipynb | 74 -------------------- Task/Q7.ipynb | 69 ------------------- Task/Q8.ipynb | 49 ------------- Task/Reetika Acharya/readme.txt | 1 - Task/Sample_Name/sampletask1.py | 1 - Task/hello.txt | 1 - Task/sample name 2/sample2.py | 1 - 12 files changed, 593 deletions(-) delete mode 100644 Task/Q1.ipynb delete mode 100644 Task/Q10.ipynb delete mode 100644 Task/Q2.ipynb delete mode 100644 Task/Q3.ipynb delete mode 100644 Task/Q5.ipynb delete mode 100644 Task/Q6.ipynb delete mode 100644 Task/Q7.ipynb delete mode 100644 Task/Q8.ipynb delete mode 100644 Task/Reetika Acharya/readme.txt delete mode 100644 Task/Sample_Name/sampletask1.py delete mode 100644 Task/hello.txt delete mode 100644 Task/sample name 2/sample2.py diff --git a/Task/Q1.ipynb b/Task/Q1.ipynb deleted file mode 100644 index a990f2a..0000000 --- a/Task/Q1.ipynb +++ /dev/null @@ -1,55 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Q1. Given two strings s and t, return true if t is an anagram of s, and false otherwise" - ], - "metadata": { - "id": "SU_J1Ndf0ym7" - } - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "jGOGuVeij9uL", - "outputId": "a98ce750-2f91-4ce7-ec04-1550c9f91495" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "True\n" - ] - } - ], - "source": [ - "def is_it_anagram(a, b):\n", - " return sorted(a) == sorted(b)\n", - "\n", - "a1 = \"sharp\"\n", - "b1 = \"harps\"\n", - "print(is_it_anagram(a1, b1))\n" - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q10.ipynb b/Task/Q10.ipynb deleted file mode 100644 index 2b39cbc..0000000 --- a/Task/Q10.ipynb +++ /dev/null @@ -1,66 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 10: We need to transpose a 2D integer array matrix." - ], - "metadata": { - "id": "fOtyyF31_PE5" - } - }, - { - "cell_type": "code", - "source": [ - "def transpose_matrix(matrix):\n", - " transposed = []\n", - " for i in range(len(matrix[0])):\n", - " new_row = []\n", - " for row in matrix:\n", - " new_row.append(row[i])\n", - " transposed.append(new_row)\n", - " return transposed\n", - "\n", - "\n", - "matrix_input = [\n", - " [2, 9, 0],\n", - " [7, 2, 0],\n", - " [0, 4, 1]\n", - "]\n", - "print(transpose_matrix(matrix_input))\n", - "\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "oWPev5kZ_U3x", - "outputId": "6307b4bd-a006-4c1e-bffc-47270b8488b4" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[[2, 7, 0], [9, 2, 4], [0, 0, 1]]\n" - ] - } - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q2.ipynb b/Task/Q2.ipynb deleted file mode 100644 index e32be30..0000000 --- a/Task/Q2.ipynb +++ /dev/null @@ -1,89 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 2: We need to count the frequency of each character in a string, considering upper and lower case letters separately, and ignoring spaces." - ], - "metadata": { - "id": "QLiWt8by7F1d" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "lot-iyh0lZFs", - "outputId": "790f7a73-cc9f-463a-cd0a-96e595f1c49d" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The character T , appears : 1 number of times.\n", - "The character a , appears : 1 number of times.\n", - "The character b , appears : 1 number of times.\n", - "The character c , appears : 1 number of times.\n", - "The character d , appears : 2 number of times.\n", - "The character e , appears : 4 number of times.\n", - "The character f , appears : 1 number of times.\n", - "The character g , appears : 1 number of times.\n", - "The character h , appears : 2 number of times.\n", - "The character i , appears : 1 number of times.\n", - "The character j , appears : 1 number of times.\n", - "The character k , appears : 1 number of times.\n", - "The character l , appears : 1 number of times.\n", - "The character m , appears : 1 number of times.\n", - "The character n , appears : 1 number of times.\n", - "The character o , appears : 4 number of times.\n", - "The character p , appears : 1 number of times.\n", - "The character q , appears : 1 number of times.\n", - "The character r , appears : 2 number of times.\n", - "The character t , appears : 1 number of times.\n", - "The character u , appears : 2 number of times.\n", - "The character v , appears : 1 number of times.\n", - "The character w , appears : 1 number of times.\n", - "The character x , appears : 1 number of times.\n", - "The character y , appears : 1 number of times.\n", - "The character z , appears : 1 number of times.\n" - ] - } - ], - "source": [ - "def frequency_of_characters(s):\n", - " freq = {}\n", - " for char in s:\n", - " if char.isalpha():\n", - " if char in freq:\n", - " freq[char] += 1\n", - " else:\n", - " freq[char] = 1\n", - "\n", - " sorted_chars = sorted(freq.keys())\n", - " for char in sorted_chars:\n", - " print(\"The character \", char ,\", appears :\", freq[char] ,\" number of times.\")\n", - "\n", - "input_str = \"The quick brown fox jumped over the lazy dog\"\n", - "frequency_of_characters(input_str)" - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q3.ipynb b/Task/Q3.ipynb deleted file mode 100644 index 4d41e63..0000000 --- a/Task/Q3.ipynb +++ /dev/null @@ -1,70 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 3: To increment a large integer represented as an array of digits, we can process the array from the end to handle the carry." - ], - "metadata": { - "id": "ilf-SW998Rhi" - } - }, - { - "cell_type": "code", - "source": [ - "def increment_number(digits):\n", - "\n", - " reversed_digits = digits[::-1]\n", - "\n", - " length = len(reversed_digits)\n", - " for i in range(length):\n", - " if reversed_digits[i] < 9:\n", - " reversed_digits[i] += 1\n", - " break\n", - " else:\n", - " reversed_digits[i] = 0\n", - "\n", - "\n", - " digits = reversed_digits[::-1]\n", - "\n", - " return digits\n", - "\n", - "\n", - "digits_input = [1, 4, 3, 1, 9]\n", - "print(increment_number(digits_input))\n", - "\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "-DABAC498TsN", - "outputId": "2615b9d0-f08c-40c5-f0dc-3e542dd0d503" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[1, 4, 3, 2, 0]\n" - ] - } - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q5.ipynb b/Task/Q5.ipynb deleted file mode 100644 index 223bd26..0000000 --- a/Task/Q5.ipynb +++ /dev/null @@ -1,117 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 5: Alternative way, that is taking images from a URL" - ], - "metadata": { - "id": "3ojSEOf9Fup9" - } - }, - { - "cell_type": "code", - "source": [ - "# We need some additional packages\n", - "!pip install opencv-python-headless numpy requests pillow\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "gWwKTYCtFy9H", - "outputId": "a0f40e11-3d91-4129-c0fd-19ee6d5ad62b" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Requirement already satisfied: opencv-python-headless in /usr/local/lib/python3.10/dist-packages (4.10.0.82)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (2.31.0)\n", - "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (9.4.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests) (3.3.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests) (3.7)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests) (2.0.7)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests) (2024.6.2)\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "import cv2\n", - "import numpy as np\n", - "import requests\n", - "from PIL import Image\n", - "from io import BytesIO\n", - "from google.colab.patches import cv2_imshow\n", - "\n", - "def detect_edges_from_url(image_url):\n", - " response = requests.get(image_url)\n", - " img = Image.open(BytesIO(response.content)).convert('RGB')\n", - " img = np.array(img)\n", - "\n", - " # Converting to grayscale\n", - " gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)\n", - "\n", - " edges = cv2.Canny(gray, 100, 200)\n", - "\n", - " cv2_imshow(cv2.cvtColor(img, cv2.COLOR_RGB2BGR))\n", - " cv2_imshow(edges)\n", - "\n", - "# Example:\n", - "image_url = \"https://www.omlet.nl/images/cache/438/512/90/Dog-Labrador_Retriever-A_healthy_adult_Labrador_sitting%2C_waiting_for_some_attention_from_it%27s_owner.webp\"\n", - "detect_edges_from_url(image_url)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "dMeHG0XpF7M0", - "outputId": "4440312a-1446-4da1-ba18-f8a11321e2d4" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbYAAAIACAIAAABhEN7SAAEAAElEQVR4nOz9969uaZbfh63wPM9Obzjx3rq3cnWe6YkccjgcYRgUSEE0CNEQbMOCLBiWYcMwBFk/+Q8RLCdaBgxZgAEThmUQkjAaMYjk5NTTsXK4+YQ37b2fsNbyD/vcquqeqp5QXdVN9v7g4IZzcPabzvs961npi2YGMzMzMzMfBf2w78DMzMzMjy6zRM7MzMx8LLNEzszMzHwss0TOzMzMfCyzRM7MzMx8LLNEzszMzHwss0TOzMzMfCyzRM7MzMx8LLNEzszMzHwss0TOzMzMfCyzRM7MzMx8LLNEzszMzHwss0TOzMzMfCyzRM7MzMx8LLNEzszMzHwss0TOzMzMfCyzRM7MzMx8LLNEzszMzHwss0TOzMzMfCyzRM7MzMx8LLNEzszMzHws7od9B2ZmftTRD/17jil+3JglcmbmT8tH6ONksYx/ygvoR32SPvyFWYJ/1JglcubHmo8Ure/5yodkCwHs6Z8AgICTOhqAgZqZISIgA4AZmIGxISDdXE3BAFDfv+r7t2Ef+syskj9SzBI5M/P9+LBgmalJBgBiBoA/Fj0aaFLRGGPfD8zUti0QkWdy/kZM8Y9f9ebTk/TO+vijBprZD/s+zMx8puj3iR2f8v2kSs3MzNRMAIAMAABB09D3++047A6by+GwN0h13bXLo+XRyeLomHwNXBmSgoenUknT3flT3/LMZ88skTM/hvzJEvkBH35/mIKknPI4DilHFYGnMheHUSVqGaHEYXslsY9jH3My5NOzZ87u3Fken1O9BNdQaBQIgekjb+VPm9ac+YyYD9ozP4YQGIAZIAIaAIAqAAAimIFmESUAJALRFGO/O6SUUk6OtOhgVswM0RCJERHRTNiAQNAVJqDKoWsk8H6/vXhy/yptynh5uD4DrruT86Pjc66WENaTuj5NX36ix/NBdnPmB80cRc78y8/7P+SIH5IiNZGkJWtJIiIiaRjNTE3MLI+RHaNaSmMRcUhEiGiACaHwTS4SAIDApuujCYCwgko2KXmM47Ad91f7/Ra8Pzu/PWQz8nXTVd1xd3SnXhy16yNgB+AA8JMEkLNEfnrMUeTMv1x8+Df+U835sDJOUVuMcb/fp34HeSd5TCmVkkENEQkREauqcRaQEYJZzIwEAIhGCISMgISoJu9flgzMCIAUFRwTFUKqHFHw4lyMsR+Gpq77/fXl5X01Ds3R0fkzp7fvtqtjAScAoV35evlJajazUH4azFHkzL8Y3ERq+MdCrZv2G/2u/34vCiaa0jiOQ4wpJylSpEAeOw8pHsZxTCmFEIjIsSMmAGhCRcSqkkuabhcRAZQRAcAQAEDVpvtGRjc3hAoARRKhEZrGmNM4DPt+v3MEoFJi6vs+Z6nq1jeL1emtsZiru/X53fXp7WZ9G4AA3xe6P5XizRWfT49ZImd+VPnurmwzQ9ObzB3h06+9/2WBIqAZmLXEsR92ux3qdP4FQAUdQEVVsxQAct4DQMmR0JrKp5Q3m+uctW0aH8IUSIIKMwEo0ndJMxoQooA91U02M33/OI8KMH0ASnaGaJJKiXHYba/H3VbiWBHFcWcmSMjozYV6dUr1MnSnz7zwhao7css1IAGQqincZDxveiqNPjiR21Nx/L5n9FkxPwnzQXvmR5XvftsjIuCNNN5UWnLMKUrOkiOAopqZjGVU1TTGcRzJbjpyCI0gmYmoTELG1jrviYGJEckxN01byk5UqRRAMFM0UAEmIgY0BQB9epcEpnM3IjMiICKZCYCBmCiSASgiIXsTBQAXmL2rquoJ0GZ4tLu+8lQqVii5mBWFCovmcYjjm4ddvTpdrY/b1XF36w6RI3AACmA3T8j3qOTMp8wskTM/uvyx4WgEAChqpZTxkONhHPsUh1IGQiMEJBMRIrKiKEllKlQrAwoqqoiqmSKzaQFBMAV0WhTMau+ydwhmUrIZqBEioSETKE73RfFpODlFuIRmZihEbIpTwySAIeAk6QZg6BSLAQBBVa2OFNUgabE8+AooHWK/G7cH09IcqesKlWHoLw+PvG9WZ9evnN99CZbnIAL0oRzl0/han96XD3VZzvyAmQ/aMz+ifER+zRRSLilpiZvHDyQPKUcpCSwTg3NERMNwICYVSCn5m7rz08OomqgW1eVy4V01NX9PZ2okNJ0CPpBSioiUwojMzhEgGqPB0/wjwE05e/pWIyRk+FCMOd0k0XQMJ7MCzGbq2QFAGsbt9cX1o/fy7gmm3bi5iMPBkOvV6dn5HTUjVxlX5NsEVWiPVme37jz7YlgfgfMAdPOBDpAA5xLNp84skTM/uujTgIlBARDGg8bx+vLi6smDNF63dfAhAIAjMDXVYqaiZRxHkcTOVVy9f6kYIzt27IwQgKayzPsHdwAwRbObuFOKEJEjAlDTYiYgUorkkpeLJQAAECIyETEDoREi8CSgZgjvy6XRh3UzVA1MSVUo4/764t23to/fHq4e52Gz32yz2Oc//8WqqlSoIAm6ultpCOwDujoWYay6xXK1PDk+u1ufnENVQ1WDqSkiOXh/WHw+g/9AmQ/aMz+6GJgB3vyMlihx9/jdty8e3iu5rypvApJFVZGdSC5SVLU/7JGMHbOSQX7/UiVHNQZQMkL2AGSmoKQqagaT5iEzUSkCVqQIIpsVlayaNUuRYmbjMOU3SRGYaKodGWHwNRAiOiNkclOBW1FRTZHIwIglF2CnRIy+WZ6ePQtqGmNmsaoR3W0fvPfGyy99ITgypAxZxyuUgCWQC86gP6TNe+WtrOCqk2funr/w0q3nX2wWJxhaQAdFgee48gfPLJEzPyIofNDZd/MG56e9PPlwGLcXmydvP3zj1cP2SdM0J+uXqa4ZTCSNecg5lTTmkiWVqgoMDtVUP5BIM3taukE0mPKLBKaoYAYAalQxAoCCikmOByHQIiLJpBCoqCJifxh5OmgTAoARIhIgSzUiO+c9skMOzN50ykkCGSAACgCYERJ5Yl9y7k7vvtAu2sXq27/7Gxk2BNpvLveH67pZOVe0yBgzO48+qPcZ0VKBwyj7fhyH3XvffvTG+uFzn7vz+Z+59dwXqlvPTQONCiA3TyZ9pEp+hID+2fa5/dgxS+TMjxwffhsTAJQybi8u7r9x781vH64eOVK/WpiZ5qKoOUWVVNIYxz6lsWuaOhAzacmmqAhmNoV77NzU+agCT/t1iInen5QxLUQeAExKGofKs5RU0mgm+HRLGaGJAQAZwpTKtCmWtOy9Y6vRBbUpTckEoEaGaoIAomIA5hwjTREwQGiX53dOn3vxjc2TnMuwP1w8uVyutfY+pkGSMrOGGnwIiwUCIOQsh4B5PGwO4+Xu4tHVk038icPLOfHROTQtTdX0z/41+5eXWSJnfuh87zvann6WAABkd/Hek3e/8+jd18bDBWDpTs/On3ueqR6GPo77ktM47BGKmXhUKzFFQRyhgBoiE7kAAMerNRBOJWliQzQAA8SblkMAABDVGIdxHHOKFTkYk8kIElMcnPeLbplLSSkyGiIaAiGCASkCkBNiANHRpoO7EXsiJlMRRQIwRUVloDIOKpGZFBXMuW555+Uv7ve7x1JcaDe7nogjQeUdSBKhPo2C1CJUVeMbH6RKVyOSQS5o/e6dr//Rk3cv3vijl77407e/+nNQtVwvGMhMwKZQ96Z79MPP8oe2Uup3x4/zAf17mSVy5kcHgpv8o91UH0qKu8eP3vvOe298Y/vkQdFxuToK7aIgaYklDSmNWnIcekfqAzMzGuQxIjKRd+yZHBGTc2aGCkQopog3VcpSCjzdZgaTRI5jTgkkk6iamBSTgqCoRUuWlJypqRiAmpoZE8PNsA2mIkxOnHn0CBkAVJ0iKBjo1LPkAIBASRBBxEhBwahdnj778hfyfvfuq1/XMdbeVw5Lv5+kzIAUychpV0IIdd307mAxxmEU2fv6YHF/Px6e3Hv75NWvv/CVn372yz8BqxPEAPgnzTLOtZ0/BbNEzvzQ+a638dOd3ZD7w7i9eHLv2/3VA4fStNVicdqt19R1MSfMcYibHGMRMRNE59AFDsM4lpKZrW2quq4RSZGsiLqMSDa1cDyVSJsawnXKRZoUKTmBCJioZZMCUkwyA4KalqIxxTgUEZE0bQMKIQTviRmNkKWgRzH2wQhBDXnqKmIBBQCGguTIgIyhEAEZEgDUdfvM3RcgDf1++/Y3/+gadiddUwWSIQKAIglSgU3OuevaJlSVDyP2gFoklkPMJVU5ldRf6Dj2jy8ffue5L/zk8UtfhbAEIhNB/vi3udGHt6DP/HFmiZz5EYLej2skjduLi3tvDFcPH7/3Zsm5W3W+alyokZyZjMM2jX2MEQ3aumZARBBVQgQAJqqqKoQgoiJqZiZqZGiIqCZ2k4BEiMMw3bSZqKpJATPJiVTNokFGEzMjY8iiRa4uLrRISmMu2dQWbdd1rQshFA11hWQmEqoGwADFqFR1C0+ny3Ga9lEzywAOEQjUEFJKzvnl8fntZ18cN9vL994KiI5qUSWbOtE1HfZFEpQE7ZIZmLGua+dwGEdJMZUsObLpWIb7uyfbJw+P3nt09twrt599ERcrMAX03zORczPKaTDP6nx/Zomc+Yz5k2IWA7CStheP3n1t+/CduLvPJQ0lj6OvOs5iMA4ljeNuL6kHgMqHfr8Ftaqq6rp2BFXX1m0XfJVzAQACNbAYB2Jy7KagaRpullxACkyqVVIpYqKqGVGBcBz7HA8A6oiIK5N8fXFJQNMmCwVKJfX7veRct00R8c6HBsWM0VQNWJlAS0J008PyVTDJgATIAAXQkMwAtGCS4uru/LkX3n399X4seeibcO6IUxxFQU1d5ShbBhsBED0aDHEcxlFK8ewQ0FLOux3kVMV+H0sa4+7xu/sHz6/OnlmdPlutTqFdSFZ2HgDA7KYndBbHP4lZImd+xDCANPTXj2HYQN5tHj1IklyzWqyOlsulIuQxlnEwzYhIoCa5Dj6nlNKoWph5uVwyWJE89TsCACIygEkRFWIEAAQGANSCoGaCoiqFQXTaQCGSUy6pT2kEE193NxVwQg+87/uUk3PezFJKUiSLHHkvOVODvq5TSoaGbFgMWYxueo+QpmVrTCTIHp+e8YGJmV3d3n7mua/+zM9vLx6999o3H11c3jpZKYKaihZIxWFAg6hUVUBE3oecsymoWNRckcs2TsnTYJbyqMOh7C8v779N9Xp9fvfs7ourk3OtGvTN9zt6z3w38zM180Phe2NJBSVQQIY49NdP7r/z+v7irf3j+7vNBftqcbZYLpfElPt9PGxTHMAcs0NT0RIYwbKJiOWuWQXH7ByRG4f0/m0x0xBHMwvBEd10XqoJqqoWLQnMzAzQEBRBi2bRYlpAzbFj5wiZ2fVDH2NMKYuHnAUAUomjZCCcCkJHJ8FXTskhsyEZgMnNWsk0jMDkXUUe0DK+v+gXkMADu+Dr2889/7mf+OphfzWO+9041N4lKGYKCpgKeAJLEahqGu8dEZG3NIygBl6deVFNIAUNUnQEDAnSYXk87t69vH7nG83JnfULXzm5+1K7WAF9sBV45vswS+TMD5EPmk9u/lLZXj78o9/679PucQ3DcNgiu6pbHa2PEbk/HPr9PvVbyamuFw4DIpYSs4hIRlBGTnmkgcysqhrTAgBTcQaJJScVqagGdkY6LaG40UcpZkaIaoYGBsBMjsCQgIEYmAGBmGG73YpILmUYhiQSggcATenxw0eH3T7HRACrk1tKGdmRC84HYzc1rccYvXfKABqIvEGegtOxz8774Gvw5Nr2p3/hF0scf+fX/+H1/nB2tFQAMywqZlmRAKjoEELw7EIIFuMgoiU7qqaBc0qqZnVTl/GQCfKwZyvsKwPaDPtHF5efT7F+8RVaHgH5+aT9JzJL5MxnwPfpZb5RyRLVBSfXj976+u8dHt/rvEoZAQirxag8JsEYr7ZXJY6m6pgAiormnIfDHi2DiXfOO2dFMwxsYCmmlFwV2DeTEqIWT2CazVSJEBkASs6EoCAlJQDw3vlQEYWiMPSQc6mqCgBKEckjmi4W7WaziXHoDwMwH/Z9aOqjRadlCMXK4bC/uCSD1clZKSkO/eJoHcvIvmZfLV1zGA9pPNRN56A1ZGZA5OBZzAykALqqQoLbn/vC7Xvvbe+9pmLIrpScc/HEBhmBgeCwPwCTlsyIBJCyFFbvDAgUlNVAZTj0Jhrabr+5XqyPyLH0Sbabr1/c237+J7/8c3+Jz14CZUFjN0eUH8sskTM/Ahi4ytlm84e//c/fe+0bcfOQV/W429579Lg5Pr9z69m6bXa7nZQiIqYFFbKlojItizQtntGzq6uqrjoAQFXNA4pgIaBMiGSIoKiKigoGJqYMQFVVgeWsKJKC8yXmUiwEh6aqqiopp5S8c2oCBqKTwqpMNrEpJw6+Cg0hx6G/d+8ePHioQL5tlotVzPnOc3dPbz9zdP5MSeaaBROpiMZRg0OqDODG8UElpeQAkmhVVUe37jzzwss2bDT3hABGplgQUGCyfCiSCINznLN654WLiiopGiKikqoqYzGzG4ey/baqWwWrgQ/77Xvf6DX1X/q5Xwm3nudQqyp99LzizCyRM58FT00Lvvsz+uH/yPidr//Wa9/4vc3jd9cVQKZDvxfJ7733nu9WioqIUkou0aQgQs5WxqHkDCqSY2ZENQKsuBJVydGkMBE7LplC8I6YiVVyESDn7akVtgsVAptmIkZEdsDeee+2m00c8zS8OI5jCAENVItoES0qKqpEvD4+Pjk5efbus48fPdilURyCwWq1yiIxxpiGh++8LrEf9321PqbbDhw7DWhUipDL7ycYRFW1IJohKPH6+PiVL30pHy6fvP2qB618GIqYghCgApXCzIji2Snk4HzxebKaQERCQkIVx8ymKirsvZmlnL1zYBJA+s3DN762yzF99S//jfDcF2nOS348s0TO/HD4Ln2E9Orv/rM//O1/0l8/qlhNyzhijHG5WH3hZ790evvuMByur6/ViuZiWhShiIzjKCk7gqaq1MSKlpSuLh4DAKgQgHOeiLgiAE9MCHqzFZJo8k4QMDJ1CI5d0zaXj590bcdeYxz6Qy9SmJ2Z5ZwR0RGb6U36EqRYWTaro5PTplvsY0oU3PK4dWfLxWq5XBO5lHJT+TIerq8vXn/126uzM2RqlytPfpp/1JLZu5stlYBoJjk7dnEYua3uPP/c9ZOXrh4/sHioqqaUUkoxNX3q0oMgiDfGjH5q5bm5EAKAqFRYmVnJpVkGdt6IRFXH5Ahq0mG8/sbv/ON6sfjy4oyOz+dJm49jlsiZzwx6Xxhv9vfkUnmX9lff/L3feP1rv1EOTyRtpUQjWC9XBs4oZJHDeMgxisjkjgBFD2m0FCUnz8iuijGKFte5cRhzyahSV772ARBNiyN0hOPYV5VPmveHfUNcoSlo27RFBFCQnamZSS7RFTcMAzuuvPPexxjruhnHYTQTkaPT9RDHtfNHZz5l81VT1QvyTSGBut308b13LhzvNtdbIn92cnSyqM7P7t5aVu++9/abX/+Dlz7/pdM7L4ILRbJqlqxVVakIIRkYGjIaMYmqc+6Fz3/l4sGjJ29+M449kZOS2UFd1yUWMhIVyOC8C8EBKqBKsWks0tRijCEEZp/GaKIZs4J4VxWFnEaWqOPYVe3Ve69TPoCsgdzT12jmu5glcuazhD583K487R/f/81//Kv33/g62yHFHUpigvOz26IArjq9dbtq2pRSTsnMpIiJSs5pGE2zpDRaHobhaL0Mnl0VJOUmeEehpHHTH5bLpe5UDc0UmBWJHQbHJcZSixKxF8eMRGjqHC8WCy2p7/cppa6p0tDnnEspauacE9GUEqK1Xc2+EuNDn7z3RWGIGfzy0cOL1954/d137yHybt+LQluF8+PVs8+cfOlzz37liy+98Z1vvvPGG+1i1a1PPGMSZUJGAzS48cbRKcmIYGa2Pjp79sVXHr3xna5Z5DQCQM4xxthWtRoWlVyy846YSIiIgAEE1BQEcoyOnXdV3bSlFOYakLIWIzSkXNTMnJVh8+T1P/qtV/7KvwGuAnSGH2Mz+WPMLJEznzEfdPlY7F/7+u++/oe/HiAKJi2JA1U+VG338NGT/ZjXRl233OyuU0qoYiKS8zCOOSUf2NdVVS+C994RgxlqkgjoQSznLDmOPUNDHBP7CAAENZoy0WGIPo/G6rWelvaQigg474Y0HvqD914RFusVAFy/955DDsET+aZtSxmqytfNIguoegU69MN2lMfb+MY7D7/z2jv3Hz5KRZOZiprZqm1fvNpd7XpRf+v0dr+7fOtbf/jKF7/UHp+CFDVRRgNAICAEUwGSElm9CQxSvvDFn9g9fOc7f/jbLRHXNYMVEXaMooZI6FTVcVAGZShQAG5Usq5rMzv0h6JG/mb/es6FnNdCRUMRBWPv7NHbrx6f3zn+ys9+jxrMk9sTs0TO/BAgA4D0+7/+j37vn/1a3l+sjtohZSSrQrVou33f9zGFrmmPVgAguYhkNLCS8zhIjmY2DMNyuTw6OT09OTXJYz8Mw2GIctgeELRxrmraIcZ2sTIQE4k5EZpzOO0YTymBQ5ejGDMalBhjBC0qQogI3NTtdMRum7aqqjgMfX9AtOWqMTMjNCUjyxmu98PVdrx3Odx7dPnocrM5RHUuNK13rqR0OcTxrQf7fX8Y4ueev/ULP/2lGHeXjx5y1WZVMwFQRET2DExIYqYCiupQlHgfx8995SvXTx5e3nu7cdy0TYwx58RMjh2hy1mUlIiIyYF7XyWJqEhRA3KuSKpQAaioOVXDUCCPBUIqmkXH7f13Xj3+8k8Dzar4EcwSOfMD5o/3QNJ3f5XUoBx+55/86utf/+3x+mHwKCKOQwhhHPZpuGoXqyHG5+8+x4x9vx/HMQ59cLzbXqehV9Pau+efe7GqKjV49PByHMdDf0jD6JDKaCmOXePDWKqax5ww+EO/r6oqp4TGgFykeFG1JFK6rj3s9wyATGBcFNp2CcR1e2wwFI3Lo+PdbsPBH9UdABAU59SQU7Hl8uze4+s+2pPtcIgFXB18/dIrty6H8aVXPv+lL33xte98+41vv7p5cvHGgyfknSEA8c985ZU33nuSubn7/HPb7bWW3DRNEYmGYiigwdd1XTsilYgM0dytF17ZXlzkYdc11Wi9GQOAc459JRABiYhq71JKpJxzgYJN3ZZSnCPnnYhIEQweAEpRMkA0ARHjaRlwioe0uw7Hd1DftzCbXrW5iDNL5Mynz4cWuAJl0XH7a//g799/41u7y3uHzZMXX3xeTRFsHMf+0HvyvpJS8pgj972IOCQLoaTx/Pw8j8Nw2A3DsN1uHXNKpR/Tfne42m4kla5pchorIu+qlJKYQ+4NoaoqQvQh5Jy9I88OEauqqnwQyUWygmYxBmJfIbMLNTlPTgm5UlUwzQUUyRTQIagqF8377WHXx+v9eIhFDMZxfP65u9ns3mb3v/2P/uO/9bf+zX/+j//R//4/+g+PmvrJk8f3Hl6kNG72OwH7qa98/r37D0/Oz46Wq2E4SM4CVhQMCJlMS0lRSZioadvlycnD9951VRWHTZLC7OCp+SIA8NNpazPz3pWCAEBEk2O4qLBajLFW8YimeGMEieAcO+ecY8fkmUIdpot82PJsBmaJnPmB8+EeyPfdNW+OcKayf/gb//C/ubr3eoDMVtZHazWoqmq73x92u3jYH61PD4c+hOC9G4aBAYtZcG6xOtpvrvfbjZbUVHVJYxLY7/f7ftj34/XV9mq7A9Vbp2ddU7lh0BKLBhEBACKHlhCAgsslq0jJuVmuEZGZnWM0dI5NLNQNADRNx977Wpk9MiChZhEpOSZCBDQ1l4sehjGJ9UnEUFXKeHj27ksXm/3YH/6T/9P/+T/7z//fD99+k0u6e7Js2B48fnR9OIS6+oNvv7U8Pnnxzsn9e/fWq8WyaxlBSpEiBsAWxABVmH1BUJBFt3rxlZcfvvb1/YV5EWYCUGY3SaRjft/ENJaCiMwOUSVlVQUEUTWVcRzJN0hYsoAKIdINTExMNBz2dXX84fUWOh+5AWCWyJnPgCksIVCw8dd/7R88fvtV6Q+M1jVtSmNTN8M4DIfDbrdDKVVVbfYHVzer1Wp3GOpQeeKYhs3m5pRtZuM45jiIwNXm6ur6MJRSlMRot+8vN2+drJa3zo6qQKoaY0Sk4ANWU+egBl+nnMBgoSZFmq5LOZCBqsahD96LlFA3yMTBO2YFMsPCiXJEREkKxFJABa43u0Oy7f7QR8kGZuJRUIbawX/3X/0DVy9P2+ZLZ/WicUWaXV8/c/fzm/1udfbM17/1xrB5Aq88z6bBMZkHMw8Si+YiIQhQg95pkeAXw9AHdlVTh6YmVNXinwoZkiESwI1KIiHp5OxFxUxUEElVg/MxRqW9rzpTo48qWD988PC59W1H/o9/6cecWSJnPhU+3N2DCmgpbi9+6x/91w++/YedA19RkXJ12HWLhWd8st1urjf9fu+ZAICDW65Xh0OPhiay3x8QzczYOTCPTFpKv5fX3nh9THZ8fr5ojw5DTLgN4HdX1xHoej+0tVctJ6uOPO/2O6SVqB4OablYA/FisXDeI9NmswMAAWAOXUeIhIhFVWNG5pjUhLruKA37iGiKAiM7N40lNm17ubucormqqsjj/QfvnJ6efu7W0fmqiHFXhfN1d7Tqourd23dWJ8eL4/XJ2bmTeHF1/4++to/Di8GxXy9TGsfYp1IMGRdLNNBSfNNKzsh+HA4vf+4L995+o6m8Iy85EeBThzJEAscVIg59DwCECIhN05iZSQFAE22a1lWtACDA+5ZkqipSAODq+vr2C0ZEN4s06aY9Xed1u7NEznzaIACSpuvL3/un/+3b3/y9zhKIGVLJkkv23uWcVUWkFBFHiIT2NH2mAkPKaOKDc4iHcTAzyfHQH15/7Y0x69n5LeHmej9sDuPlIY5Jqe6ScC+AKVchAKGKTp3hQOTQMztkN51PRQHp6VsAkYwAVc1KzL4iR47IKQggk6tAMnIGUEkxj1ElDYehpIimlWd1+MUvfun+G98skn/my1++uLoec1kvurOjo91+Nw6pW62GQ990beXYh3Bc36otS5Gri4uaOctQ4likhLo2SVq8c6ySY6QsYx72+/0WmcwRqCKigjIqAMOkiQAAsFguRURFUk6O3X6/J1Am9t4xOyQiQwBBAAL03quWUiSlpK4sFh2xg8nV8cdeFj/MLJEzPwD+eLfIzVQdAIGW7ZPf/If/1cVb3ziurIyixlktFTGgum7G8bDb7VLKUgowTWfeuq5TyuM4VD4EdmSQS04pgUl/GB49evzw8ur0/E7G6uHjy8t9vNwerveDinbeL2rnwwJ91XTdYn1UNW3bVHUdmlAxwHK1GlJ2vipqpaS67RQIUMlAsnnntYhYcYZFhciRC4aETjE7YiK0kvtx6EvKZRhRS+OpcuFQ4I++8c2To/bxdiAazo7O6rYywv3u8Pq7D50PL9959s133ly2VRfwdLWqsK1QV8umaZrrzYVJ0RJVJTgirUEKg2kR8twEv6yrq4dvCWPOhdgQYHIoczdB5NPSzdNVFCTc972qOue6pgF2RI7sxs4s5+wIKx+A/HQdRFp0izn3+JHMEjnzqfCBB6mm3/gnv3Z5722Kh2HYO+8FLYvFkn0IANDvD5KLlqKqZoZoy2WHZNfXF0S+rRpEU82xP8SxB4DNZvPoyTVQ7dr16+8+evfxxW7IT653m8PIzBXa+fGSHBLCydHSOCSxBqEoiBkxEZN3ztS0SBEg8oigBgikoKo4GcsqghVDUs9kngDZcTAaCVFyLKmXLAQlMATnqW59lpeeu/Peg3ePjk72Y7y83g7DIUnej6VbrV986cU33nz95GhxdtTeOlmsu/p0vXCmVaDawcP7V2jZJINJibXWhVxGgOC8Yy6iQ4mh6UxtN+591xAh2tOnFz6wOZSbJxCrqjKzqlIzG4uEilRVSxExU1MBNXMhVE0VQkAXKHgiB4Cgk1XOzAfMEjnz5+aPbw4HAzNFAHAIgKC7i1//J7/2znf+CIZdEGjadcrJEE2jlnx+cnx1efno0aMYY86CRifHJyGEIY6HQ69F0COSacm7ca8l1T4MMYPRvh+XR8+8ff/63Se7x1fxcnNNzrOv+nG0Krz7eFs33dHx8SHL1a73vGgLMquAtXWFTFN+TRSIeLfbOeYQAjBPgzYGUkxJUcXIFB2LKAEBO3IeAJhdVzcxHUruV23HoaEq6NXu1lHXNS/HrP1QqGt9oNJHwkSBrrYXZ+fL28frV569/ewz54suSJGuqco4MOli0W6uLiRnzyi5oBoDlZgAPXIWpJyziihgcL5pmzjmfhi6ppqe9sn/C5Fd8KUomJlaVbcpJQVDJjFjhMllDNREChqqqg/eVaEXffbWnbprASbHL4QPUslzXDlL5MyfH/qIfwEKApQMjoYH7/3Wr/93777+LR1266Zic/1hh4yoYGrT2Xkcx5TS0I9q6J1frVYxxmEYfLMIIYTgyTSVlIYxjj0Ybbfbq+0O0Edz1/v95pC3+6Gu2yylaBGjf+1v/u02uF/9r/9/Z+dHq7E+jOUQSxUTkneOQy5uSOwrMwWYcnn6tCKszjERq5p3HskYiYkZTUq58cFGrtqu6RYPL66RrG2CD85Q47C9dbRALVbQDFd3z1SAiKvaAZGKtIHXXfvy83cdCkFxXAGg94TgZRyqtlnbut/t0CSlJKKOKIQAxKpmZMw8jmm73b7yzKnpd81Q6+TCA4BMTAykImKmKWVlBCLnKjMEcuSYxUosoIY3TT+QigiHuy+8DC6AIiDNA9rfwyyRM39OvnubmQKAiSI7tlzi9p0/+varX//9t978VsXQeCppFAMXgkh+/wr7zbbf71WsFElFVqcnTV2PaRj6CK4O5J3zRVIpMeWxZFHVku3QZ+NwuT3sxzGlkVDWXbs7lIOoqr7++pt/9Vd+eYj50ZPrxpNjm/brkq08cfLJMbf+Jv4CVAIkUAQlADMlQDAgUMnZuwpNJUcVJQYmM6TQrqou1u1V2Q+B46L1XbswxaEUxsVqvUhKGJo0ZtHsCEMIVeXXq+Wqa5dd3dah7WpHaKq73RasVASlZCJu2iYNPYA+NbbWpq2SoCGH4Jpuud3s8dnbTVOlzdbwps0bp2wkoZk5dnzjZSseneaEiK6qcxZDMjMRFSlTNgOd7eOATO3RWXd6B7j+7H50/oVilsiZT8QHOUdQZAfx8OThew/fef3JW68+evu1dSBGAC3TIY/ISnm/nRxyLjo1OZbsfLVarWIcYoqlFCk62sAOm4pFlNkJ6ZiyCzW5Crx7+ORqc4gAsFx2bRWG4TAtXvy93/+db3/nm2VMV9vNuguNp+DIEQQi7zBUzrncApgZgZohASIomaJRzoW1iKiknHKiGgwhF/XOGxiYIqIBOF/defb5+++9IzkG1AC5AHSeu2aprhH2Cg7Za0kxDiWNp2dnR8uVma3X6xDC5C+2ub5MKTmC/dD3+wObesYQAgA4ZtGSUqIY+ySCVFVVVVXtYhV8jUhErEBiaGpGNo2LAwIjKoD3nogtEPsAhMwh5YMpZrMsKqJoAozA5JpqNG7XZxC6qXt1DiH/OLNEzvw5+d40lQqk8fLBe9/+2u8OmycXb79mqUerYs7MHBwhopSc4kCIOZU8xpyzihKxii463zXV5GhtZjHGplsS8tgPaMbkQu0EynbcKvGuH5LBtKqsq8LR8Xp/OJyfVI8ut0bMCL5yJZe+77c1VYFyPLAVR4BopUjbtpVr0SDncSoGi2mKgxRZLBpmTFpAZewPTJnRk2MVkRJVCyI67478wtJtByDj0Hgac6qb1jiY94W9Dy2wQ+wYj4bDngHbOiDSom2c434cD31feyYm57jitqSeRBgNkLu2QQLvnKvcYbdxVUfs8hh328NqdSSGddtt94cx5dqHouCnYR8zMihFyLGameE4JmIiIgWs65ZcOBwO19fXJMZoVc0GpBTAN3de+TzULRB/zzj2nIacmCVy5geBGohcPXz3j373N7eXD3YXD3fXj2vHnqciCACAasklxhi9c0TkQygm3ruqqnLJgEqMRJBzds4ROQBSRRPDaReOQ1f5xero3kX/ZLPpkyU1NUxqi255sj56fLX73PN3zbn+0G83F6AGADHG3W5XPFxXDiWh5Zq55Gx2IC4CVnKxIoV5GlU8QAGAHGORQkSAgA4OfVYtqglU2TmRVPnQ1OH22ek47Esc26qqWg/s1VdKvqobcoEdMjGqaBEiXq1WzvEwjsREBrvdvmu7KrDGYb0+0jKWcShJkLCUEtNgzpuCagEhNa2qyoV6HMdSOgVSRVFTFXQOAMxMVTVnR+h8QOcA2YiRSZFKipBSKqqillNVhyo0vm6y0emdZ0/uPAvzUM3HM0vkzCdCAUCA1NKhf/WbX3v03pvj9uriyUNHsFwu2NWEaCWCmkoucbzJWuLNRhkj4uBcDojmHAJYSsm4EpGUkkNgUgQlIgIy1RjzZt8DcdtVBbgfUyzlYns4Pz9ftJ0CRZEy7trAt05Wz9+9RVA8Q3AgImAUfGjaJg6jIjAP7EMpwkQmJKrIlFIBAFFJKdZ16xkJrRQxLWYZ1PKYATWbAmG77BBxk1JTN13XGQfzjVIw9uxD5dm7yshLUUfo6+bq4nHbNLvtpohcXVzQ6ZFkkjysVx1DFfd82G0QMecMLrEkVQIrqKAKzaKtqup6+/j0eG2GZiZm065fMxPTorZcdkYIAEXFVUGQzMDMimrJMo6jqFQOQuNCUxPXReFLP/HTrm0BPIDNgeNHMkvkzCdCVRkApFzeu//g3bcO28sH775bOSqIpjiOI6i1tTPTaX6mqioASllSSrEUKaWoGioQIBOqicio2XRwxUxy1wRmAiDGahw3Dx88vrp4fOv4TELbVP3j6+vdbvfmG2/mZ24ddZ1J2V9dl8Nh4d0Ld2+fnxyneABNFYOmWFdHi7atHOeSSs5ErmoUiVQLIQMYI5YiAEBMzAyoPrjg65SS3YS0pT/0Mj0UVVcHRfChjkXqUsAIMBciKwBGSiwOg6+posNhu9tum7p+8uSxmbZ1ODs7Wa8WkiM3PgRyFJggSzFEE8u5xBjJBbMCgAZWVbWr/NUwZkFTnLQPAIjIzEqZqtijC7Vj4uCjWlErIipgZimnnLOZVW1dNzWTS8XOXnx5fet543qwscJqFsiPZJbImU+EIwLJ5bD51td+9/rho/3VZrlYXV9fasmOOLBbtE1KKZcoOZVSiCtmNDMBU5VcMoAOQ9+09ZiFVQ358vpqtT4DNxouHjx+sui6JlRocbvdO4fP3jofCxRJd0+WZ8fL9+4/vLq8vHf/0QOAtqo94+dffOlovUBLHmG5WgIWSAdOcr5aLOpqt9ulOABA1dTes6imlJgZAJquM7Ope8Y1lSps9xvEPQA4djENntlVnpSn0tCUGQRiSXnoI5FUnTs5PuvFfGjB1SqQyxAc1xXvN9u9SI59EVk0oaQxj4yE15fXp7eP1QDYWQgxJRcCO4eIampFmIiBTMrxan1fScG1i2W9vY593wZPDFIA0RiQiJuqyiJIFnyDopi1YMmbKCmhmveeyK2WJ6FqR6p/9i/+CoSjDJ7RzyHkxzFL5MwnRMHk/jtvbi8fSBwP291QsuTcNZVzrpT85Ko/OzkGAEQkckik0yoFxLpuxMyUQ9Ps94dhHCr2AojsBRQK9MMQqma76a/LzjnOuYDandtn/RijInGdiVRi43HooyNaVO3Z6dH5yXEc98FrcCi5r2o+Oz/zko8W3bQliBCYCBGLFFVFFVAG4pKSIrBSNJsm88yslOicA1BRAYA6eERCVHBOVB27qm4TxpiLqoJaSSO7uogQCSKB6FhGNGG0IjmnuN/tII/dYkGgdajD6VEVmlxiQVocrfe7HSE7ZABQAysJETlUZOC8r6t2jHK0aNumGyQSYoyRkBipmImUlEZF8ogAoE+rL0VKyqmIVo6Xy7UaDlmOnr9dnd8FVxF4g9kk9mOZJXLmE2AASJDya9/5xsP775a4Tzlud30phcAIjBmXXSelIBgQEjoCNkBEIcQ+xcPhkKWkVAwhZ81xvN7ssggA5CwieS9jv+9ZYbFoSymr1ULAlqtmhaxA4HzFR+frNo65clW3aE6PTto6XG8wOCQodbUyTXHYLbtFzGVMmxiH9dGSnGOEHAcAIGLDQs7nggCgzKQFpv2yiAAUh4h1wwB18CKKiEAOEUVHBPXsMiZybGaKOqRY+Vo1ozpi5wMfDmnse89kUhgNVEqKkn1KyA6rqkopFRNVNcambkUUFaeduNPdADX2TIgn57c2+93xesnei1nOhdBqH8ixiECRyZ3me14lIgI1Rmuququ7mG00+cWf/XlwHpDp6TjNzEcyS+TMJ6OUiwf3X3/tWyX3JcYQ2BTGMY0Vd11jBEOK3jOhAQIRKQICvL8FtpRSxAzoMMQhZYdkyDHHLIZIIhZjliJFBPbQdY2BdF1XSvHeFxXvma165uy4ZPEhLJfrtqlKTm1zbhqD467xpYyHjVtUFTmH6AEAkdmxAkkRFfUeAYCBBKIBEan3bmrJnkrx3nsA2u/3/WGom5qIHfO0nXsYBk/BTEIIQ4qpFMbRSeNcbZqRlJlATUtOSTxzV1e0XgZHRNjUNRExuyq4MSczybmIiKpqVlVVBMc3epdSXh2f3rv3UAX2+33OAkCqUrIVZIKCalqKegf6XSEhGdQ+RGZG13VdUUjI9dHZ6sXPATMgzuL4/ZklcuaToED4nW98bdxtNY5dV+/2u5SyAfRxxM3V7dvndd34umIw0eKIVCDlBEDALmep63bcbsZxJHKHYTxarrLoEPNSwSHEGKVozmJSAKDBBkSvri+6rmHnvFFV0fnJraZdnN9+Zoi5lLLf74mw8j74GlRAcnBOQlUUWME5QnYGNMasZmTQtK2KqGqMCQuJYdu1sR+7RSdFFotFVVWlFCnWdAsz2ex3UiSE0C06VPO+7vudZ+e8pyJSNFRcV14JACx4l/LoCDyzgYHKYbep67puqv1+v91a3Tbe87AbjMgxex8c0TDoNINUVS0iIjk1VUVTULE+xiHl5dHxYXclhjImM6uRAKjk7KsAKv2hr9cNKKnmPBndiqzWR3XbFcNdzH/jl/4qVB3MKcg/BbNEznwidHf1+qvffPzowe2jTotMnyxSwKp2sajrzqwgoiGQMTJKSmomBkzfFezEnIYxnZ3WY8pZTBEE0Feh5MN09nWOpBQlE7FSlNGqujpaLleL9dHJWZ/Go9Xy8nqb8qhZGG3aqyZmICBFUy5ENG27yCKIgERK2KdMROycZxfqxhDJM3lFF5gNnB9TMUOcNgQRhFD3/T7GuN/tj1Zr7z1z2O43lau99955RFMtRMjsAEuMQ45DHgeTopKLZEeNQ2rbpmlaINztdk23RCZiIuLDYVAR55xz7jD0zK5qmCkwM3lXtYscxXEw1ePjs8P2CahQJmYhh0kKp+SRDRWBHYNQUdWh79um6boWEbPhy1/66nMvfxkgADgAApvmzz/7n51/MZglcuaToL//u7/55uvfZkAil3M2RSXNuSQhM4wxMlpKiYlFs1MGZkIoWVNON9cwAqAUZRhTSjLt/TZTJKcmuWS1QkhElFIi5ixWsu770Tkys5zz4XBA7662m1zS1GYUiJWNmVUR1GIuoFIUWNXQckmOHSMRkorWPlTdsq7rbrkmz6kUM/XOi2rtXUqlpISISISETRNcCOM49vv9dn9oGm3bBgBijIo3IVlKYwAgRkkGUkyKWAIrOScCBdRc4uX11Slat1w3TZOK3OQDzbqujZElJ0QMITC7EAL70PfjOIxAKCZNu+h3V0BY1e3++gINyGXvaCrNkwsGIlIUKWfpDyM7V9c1syuqWLc//0u/BMsjoAbsqT/NrI8fzyyRM5+It95+c7fbBc1xLGA3UWTWEqNdb7dD3y8XLRMxgarC0xoIEblpLARBEVTNDEoum811VVXd1O7s1NQQiZkduxDCOI5mJmJZNG02U1Om472/ul6dnCpCfxhLTADAHk0RHQOQiOWsdV0pQtYSSwZQQwBzRM4QXd21q+Ou69SQ2Jd4QHIKjj2xd5p7rhsQFREtgqwutAvnEfmw3Q3D0ISqbRvv/TgOQ4qdczlGVfWliKp3LIyByQCRUY1VJKWxq6sYo8omNDWyNyrOFUQc+0GKOILga0Scfs1YKiHUxNQ0zaFpM2K9XKVdAkJVyYpYCmbOOTvnOWcmHsYeuIoxbva79WLJvgLPhyF99ad+vnvpiyAABHP8+KdhlsiZTwT7akhZNV9eXa4XnSmaghTBKgzDyG1jaqLqfBU8IWLKqWnakvP+sO+W6/HJExERKc55UdlsNqcnp/0YQZQCJSkheAFkNFFtmialhKQxDsSw72PRg3euqmQXSzGJw9jVixijNbpo26EfconX15fOkYANcXQJnGcfGDmYc4V9XbW+aQ39YcihrrQIIptaSkVEDgDOExOFUEGROBxIrO/3DFjVDS5wc3VxeXV1enICUIi4qUJVVaLiiEAN1bRkz64OfhziYtVJKmba1nU/jm2oikLKadnUABDj2A+Dc85Mjaqspa5bES0KCtIE3zaVqsacM/vl6uhwuBTAql2UNIpKkdI1bSklx4Eqb6jOYQjOOd73g6+aXR5Pnn3hiz//y4ANOP+BO+WEfeTLOwvoLJEzn4yf+7m/cO+173z7D34rgcjT95kiHYYIAF3dGrEBmZmaEQAiHfb7lJKoppSJ2TmXs5QswipQUh4ZwUQYpvZFp6LTdRExxiggTdWpiAr0Y3Qs+3503rH3BNDHQVLxjGOMWnKKUVVSguvNZrGoj1aLtvHs2LFjX4MPvlqgb4qxirF6AMhFRaQfeimZmKqqUkl1U1eVD81aSjKgYoKxtG0bhz7lcRgG4htfhJRSXVWgJpJVFdHMhAyqqoKiZooIRNC0jYKoaFMtJJcxJwDoum56jADQNK19SLb6YTDRqvLdaqHMrut822KOltNkMCskBDflaStCmgnKlN9Us3a96EW/+gu/5E9uA1YfXPfHXgH/RGaJnPkk0HOf+8LP/YVfePXrv7/dX50crQ3K1EaScqqDK2ox5sElNXNEhCiqu91usWhjjEWklDKdvEEnFVUzY+ap94WJHHtQBMlm2rTtMBz6fZ8kLxdLAFDVWGIumYmnjWGKIDnvTbz3dfBDHKd8pag69j4wOw6OHZMLBC6Yq4QqIxZVTaaq45hSyn0/9MNhUqsQwmq1Oj05WbRNW3MVXEljHgcRPDpeWWljjGKChKJasjZVy0xjHodhDA4BVLSoCqiYCbFzznVVpYoDJucZGShpKjKZ9hDRH/dxnawKvfdt01ZNM8T8zJ0X3tkffGglaUyDiYia954VNKXS95WvQ/DNovbksthzn/vqna/+4ndtrHj/Rj4uhJyZJXLmE4GguRh7Ct5VXhEUYNoIy+QNeRzTpHRSJvdnjTEeHR8NwwEJUXHaOu5dGCCZGgAQICMWMTNzyM47yVkEwKg/HMizr0KMMeXkvAeEIgURU0qioqYlKzMvq1ZFxrFMLoDDOJ6eHi+Wy8q5EkdPrRGasikD1ZsE2+3VZrMZhqGU0vd9jDHnPI5jzpmJU05HR0fP3H7m9un6Sy/e6SqHrh7LkHf7EseuaY6Ojq6uLokIDFIaS8kAHgBESjY0kyIJQBnNzAiNGPp+qKrKNO+3CZlcCHXls1iMkW6i0UJEamhoYMDskGXa56gK7GtkQdeaM/bFl6JZwMR7DwBadNjumrrl1oemrtiH1fqnf+GXwS/A5kGaPxuzRM58Iqhd3Hn++W617ndX/bhHBERzCBkgZ9GavK8BKGdFtBD8qql3h32Msa4bQkBkRJq2Z5tZSjmnVDft/noDAMRUUp66uJFQwBDJh1CkDP1gam27rH0AAGGnonmMMeamaQ/7fROq4bBLKTWVBwApBURNrQqLLMqhM9dFqu/dv3j97QcXlxdTHSmnnHMmpnEY3w8hiWm8ODzZvvXu/ebJk4vjVfW5F14AdXkYHNiCfR/j6vhoHEdNJYRQihCx92G9PjrsNqKCauyIeKrWaxxGQhwOhRCDYyDKaWTn6qpBZDMzZAAoCtNTBGCpyProqB/idog55SyW2N956fNvf+ubrlqiSjxsAXC/37OvfF0tl8scU7d2d565/fji8oWXP7949hXIBJ7mmPHPxCyRM58EAtC7z79wevuZYX9ZSiQmAEAyNMxih3FAxOVymXMscRTxuXDOZfpmRKSpxweJmc3MTIsplFJS1lxg2u0FMPkPmCkAOOa6bg77/TiOzMG59sN3yLETKQA09MOkcXVdpzQuu1ZLUgtNt6qXq6z88Prw5oO37l/1Dx9dX11dee9VlWg65hKRM0ZmFsQihopskDd9ybl2drWNX3rlhWV3tGh80wSCAgRVVamAit48NEIzREQpgmCoVtcNABComZYipWQwYuf6cURHi27V1KGogTlDAgAxNLNJ0RBxc33t2C0Xy1G5ZIGqPrp1dNgeHr39undBxNBZUVURUpBSYow8jk3dnpw9szq9Bd5roblT/M/K/IzNfELILVa/8iu/4tjFnKTI1FIjZoZQsgzD8OjJ4+1+d3F19fDx431/2O4PVdNMJio32UdTZiYiAStFP7g23hRqjBDog/ScY55Oozmnm9mRUkSKiPTDMA6j944dSxFE2h0OxFwFt1wuz89unz3zrHJ7bzP83qv3fuNrr775zsPN7qCAqWhRKHrjHaNAoW5C3fqqcaE25CyWBDZJnxzkjfeevPngqloec72M5qKRIQNxVXvnCFABVdVEivdeVWx6qKaTyiMSmuSY9rvNdnsd02BFi6SUEnwUiLharZz3hOaZipSimgxGsZ/6hV8wH6Jqs1wkkAwlqgpYn/IQx7HvTbFbnzTLY0Ak1o+8/sz3YZbImU+EqgLQV3/u5+48/1IWzKJTuk1ViqkRZZHNZjfmguyyluvNrq7r/b5ndj5M+BAcTYk6xSmUc8Fz8FPvpH536WIajiZm5z0RlZIncZyWT3rvRFVVh2E4OT09OTnuh2G9Xi+6br0+Rl892cbf+fprv/mHr772zv0+2n7fq6pznhxXbVM1ta+q0DTdanl0cnJyfnZ8drpYr5pF56pgyEXJN4td1K996/W3Hl1Gc+brMYECIpIR+uCBUEVEipZMBESsIgCQUk4pp5RSSmZaShrHcbfbmaliiTFuNpuSteRSipRyI6xTYPvo0SNVHYbeTM9Oz4go5uKa5enzn7v7hS/71YmGSikUdEUhF41Fi0KMcex7K+KIwARoTkT+mZkP2jOfAAOSAuSxWv71v/k/eOvVN6GMdW28HxCzqZUcyTlj3u73KmJazk5Od4e+a2ozHceMaMF5qmDoB5kq1GPulrZer2OMwOQ4VFUF4HOMooBMTjGpkE0eXSZPD7ZmOo7jJJ6gVkoZhr6uw8svvcRo7WKVlMiv7j3ZvXF/c7Ebi7FzlUYBQe9Cs2iR6ejouF12kxVM23ZtXQPAouvu3b//4P79/WE3DiMidm2Hjn77D7757N3no0iouyKjiPiqKjmPYz8qEhGImmRGFLP9Yb/s2hDCtFl9vexKEQUCAA7OAJApFXHeAbqUSh/Htu7ULKdBReu22V7vDsMgxo2PjkjEolDk7i//zb/zXz5+OIxjveKy2cZhGHNhFSFwKZTxUIb99eMH6899Fb7Xn2bmT2aOImc+GUgABlx9/ss//dWf+QWkyk8rYR0DgKhmFSnl5qwJFHMyRTAqCjHf1LtDCEiIZM67EAIAqdl+v596X55aOCAzOcdEREwnpyfL5QIRS5nqOVNiE4l4SiVOM+Cbzeb6+trXzeOLyyHr9S5+49tvXu7TfpDDELfbraoSQAi+bZqzs7Pnnnvu7p27J+ujuq69d4uue/bus+fn588///zdZ589OjpB5KEf9v3Qx1QU//t/9psKDqlSJGCnZkVVEQSKqk6OMiLqvF+tVl3b1nVd13XXtTFG76rFokMmZK6axfHp+d07d0PVeO9gisN1CsmRmHIpQMbkCTmlZGZEnMUu9n17cudn/srfKNUqQfBVVzWdCqiiieYxjrtdv7ncXT3Rfj/r45+DOYqc+QSgAgGYALJvl//63/4777739ntvfKvruqHI1DttStEKISIZI/Z9v2haI7QPGqMVwBwBOO+Ym6Yhx7dv38nvvUt8kzwzBEIyRCICBioYY7SbNdrkvJ8MpVWllJttuKIy9LFbtL5uNts9qPju9Ori8v7DR4ujs4cX15vdxhEVcoiiqqKKiOM47Ha7R48egQgA3Kuquq73h0NKaeiHaTu6KsRhRCmlbd+7/+Ctt++98OypK7JofGhcP+xVBPRms1EppeTCDquqKSIpZwAlIgNSEzCqqoa9R6acc85WGRuxmgGAqgAAMjNC1VQqstXDdtuvTlopBenGHI3b5U/85b/+zW++ev9bv+ec1kQZ+kBYIztViaPEcbe97Pebxer29LL9EH5U/oVllsiZTwYZmAE68O6ZF1/+5b/+r//9+2/vrq+8C6mImYmqqgA7npp4ciqmZialBB+yac655IxIDCU4DpUD9p/7wpeKyuXlBsAUgYzgaV0biYm4pGRmYggAjhmRRJSIzfJkB4iIjmkKZodxZF/tx/Tu/et2sXrvwaPddpslE3tDyyKHYTDCVPLl5VXOab/dxRirqvLeq+ihPwz9YGbO09W1LZdLkbK7lq5uUhzeePe981vHNow+tBUQss9ihAimllVVY4qYDcnWi67kDHizj3LfF5Fct10xRUMzNLDr3da7MNX4SxHnJu9YyjkBgGM3+X8pgeUiqmooRTh0f/ff+1/8f/7ef/rozW9i6r1a65xnJAZCJsY8xuFwWJQIrvr+r+fM9zBL5MwnBvEmMKnbX/prf/W1b/3hb//GPw2qArbdbs3MuWmRLU6DN0M/LLtWVKvgFotFCG6z2eQxemY06erK2mW1WLSL1fVu34QGAPr9jhGR2BQQbJJKAEBAREwpO8dTY+NEluLZZdFUJJVDaLpUZDfkIcrVdrfdHcaciFFQhlxUpE99n/rmUBGRSIkxliLj2HvvmXkyV42lWLa2acZx9C4A2IMHj+/cufWN1988v332+btnMWfgsFidjH2vcTQDLVlFCRDMSsy0ZmJGpKqqktjquJZi+34ITV23bfCtIrii2+0WjUrOVVUpAHpkdlnyoe+HFNn7zW5LVRswGFC3Wis4UsCw+Dv/8//NH/zTX/v9f/Kruq/BUmiqtgrF1IeqrmtEBMdgNkeRfyZmiZz5hHyQzs4l+uXZ3/o7//Z3Xn31wb13vfOTkIkUZje1PQJAkSKlePbMzqyYoWf2zETgGdnR7edfOj69LfYtx05VnffeO1AjU9FiZsTETGoGhkR0I5eIAMBExKSqGYpncs4baVHZ9WUbLzZ9Pgzj1fV1qKsYh1KUiFTVmQlSmg61aqCWc/bem1kp5cmTJ8PQZxFmZiK1adIazPD8mbvv3n/rW6+9eft4vTjtxpgb77yrSlEkKUWzGdz0EfHQ9z4E5yhmDXXlfNCA4H0WQWQBNcGpfk1GylxEAjMAaBZmDCHUtQAKOKfkzSyllLMaECCBAbjup3/5X73zzJ1//N/8l/urB72mdrFwauCDOQdAMO18n/mzMJdrZj4J9PTDAMy7AFDufOEn/u3/0f9kdbQmppPjk9VqhYgiRVQnC9accy4ZAFQljiXGqALOee+9D85795Nf/cn10Uldt9PotGP2ITh2SJPlltJkrUBMRPTdjSxTtUZEcy5VValq38dxTEZ8sd3FmK83O8dsZgzY1c0wDIfD4dD3wzDEYSwpFRFTKymhmpmmlA6HQ0p5cj2c2tEBwLuQRbMoIGfAwzgi+6KgCPT+PePvum/snJkZcds2RG7KnzJ5xx4IzSyrSDERm5qYAMA7N80UElFd14tuVddtVVU31hEGJY6IhMhAXEShWp7/xF/8u/+r/90v/q1/6/QLX9gjwXIJTcdVa+xBdH7L/1mZo8iZHyCTIsjP/6V/JY3x//X//L/vr6/aptEsh7FXsUJAgCiScwGgOOZxOOQ0mqhzTITkHLnw4uc+t4ulWbRmpiLsnBdf1NQQAPSp6ZWoqCEiiRQzNxU3iPj9QpB3wczquj5/5tk37z+OcXcY0jCO+8MQ6qqrq/1+t73eSClElKqK18eEyI7NrOQCDahaznkYBlVlZnKcpDj2zN47z45LznXdSs5Scs65aSsp0RTVDM2mFZnMJKoAcHFxsVqtkGm72fu6MqsNuRQl5xFZDFVKKSXGiAYl52EcEZFLiTkdna4rF0w1FRv7CEjMHEJQFcabx4vMoAZI4Lov/fxf+eJP/dTj+/fi/tBUTbc6a26/NI8e/jmYJXLmEzKd3KY3nwIggON2+cv/6t9sl4v//P/6f7h++HDR1rnkAqiiaGioZubYVZ5zHEZVNGua2jl2HpvV8plXPvfw97/WLhZN0whnxyyIRKQAiKjTajUgNRTRnAciBiiI6L1TgSICQI5ZwEysa2rnPYI7DHG9Pn/rvUdTQw+hBee9c6YgIvv9AEa3bt125KUkdF4MHdA4Jsc+SS6mZLrwvqgeLToyWi7by6urlPtldXS8Xg79tuKFpB4QxJREEbGqqpIMQHOJTE4FzND5QORKUR+CqTD74KssNg5pu93mGAmwP/RN0wVfV01NnodhcE6rZgl95MD7Q6zq2szaugWd2iuBiWBaEcQO+AjD6tbnnr15cZAA3E3/1HzW/rMwS+TMD5CnhzgECN3P/St/tfP+7/2n/8nF44fL5fJqtwdTVUFHbtok7hwRT13fZoro6rY7Pj0zsXaxOj+//fj43pPHjwGAmUoyIp4q1KqiT62uAWAyvJ7KQcSAqgAwrXqczulM1HWtlBJzaprq8cUlQNtUTRMqzyGjqhaR0g/DoT9MJ3gmnroaiWixXIrpMPa5lIuLi/2+v3pytVis6gv/8ovPe3aOMJfYek+Irqqyjt7XqiM7OPQHBGB2UzZWVfo+mo3L1ZEibA+bpmn6w6iG5DmEYGYiSnyz242ZpsN4zlLKSNw0dT3kgkjT4A18yE4S3l+hZgQYbl4I+NBvMZz18c/MLJEzPxA+6p2X7Yu/+Cv/ruF/8Z/9Xy6fPFhI2lz1hIjI7FzwYco8EuLk54BM3XL9zN3n0AV+2iJOiEVk0hfnGMkjYs5AqkTT3Mr33uz7yxaZnVk2w1IMABAxl/yFz39+iF8PPhBx1qIiZkqEAE7BxhRDilVVIVMxNVVkPjo5iTE2TZVL6cdhkqRhHM9OjlVLTsNycYvRGPCw3zsURgvBp5ympTr29LkRAyNXhTA1YIrhmAsiiqERNq6tqmq5XJoIAzGRc1yKKERF8N5N0+w+hKlqRDzlOulPm16cxfHPxSyRM58CRgAKvgWAr/7lX/mPn73z//h7/8c/+J3fHGufx4joiMh79p6Ip/RiAUQkqNvu5PT2o/v3Lx49njoTEdFUyU0lC8anebdpxSwRqsL7FW2zD8oRU8hWiiCmqYkHAN59972v/tStO3fulpLj0A/jOIyjmDJzVblSylQmBgBimjYSMVEpmRBPb92axm9SKment548evz2W290TZVzPjs53m63FSwZrQ0MCN5RCHVJo6uClpSLqCg7B0ZDP2YRIwYAH+rNZuNCpQguOKpwuVz0+32OSVWd0xgjZASmdtn6qvLVcoyCcFMPQuBpjntOMn56zBI58+lgT/cSIh0//+V/73/9H/79/+L/9k9/7Vc3l0/atl4s2lBximOMQ5HMjPvDpl0s2Fen57dN5OH9ByeLxjvXNE0pNgwDEU2HcSYD527UE0EBkND7MBVwCMlIp6O3GBpSFtkf9rlo07b66Op3fud3Fqujw2F/2FwP/RBCQL4pi082gQAgot47VRFBZgIA531K8txzLzz33HNvvPbmr//zfz4e9kzwuOx/5qe/tFo260XlvKsc94ftelmrqPM+OCaCHAfOpUgBAGTXNC2X7EPY73aH/oCIV9eXnSzqtgGI6/VJigUUPXkrErrO11UqeRxHqMkgpmKKYGbeVVU194F/6swSOfMpgB/e9U+qZX3r5f/pv/8foOp/+w/+v867xaJBNMBp8C+HyoNxVfmi9uzzL26j5BJTMlc5ZGbTZGZmRYTZAMDUmF0IN0uAEJEdAwCWm6Bykkjv/VQgLoqCoQnV0Wr15Hr/xhuvM7uAUFUVOW9E8P60HyIRT7L4waNBNNMnT578xm/85td+/492ux0jHq+W52dHXcvH68X19UXnTiBnt+xC8H0fHUFFFBwJYFHIorko0bRvx5z3h/2eOZwsVpdXlyJyfb0z5NPTcxFZr9fXl1dt0xYph8OhBq2aKscUcyrmAb0ZulA3i7ZpumnJGtjNUsnP7BX+8WGWyJlPEwRAIGSD7Ffn/87/7H+pJX7rD37HVQGYzaxINjPvueI6hHD79l1oF8P1/XHfp4Dee3ZsImaqoghWSn5fvyaZA4CpPg7v120I0W5UspQSYyaBXeyJ/Gq5GguIYQiBtIzjiOSzlml4EQjJMTIBf9dq7qmmFEIYhn7sR1M7Oz2+/cz5S8/d7Q+X2+31yy/cBcKsRVUqdmoKoFmKGboQJottAyDnyflc1MzIBURk9neeeRYfPdrud9vtvqqapumOjk4lFwTMIk3TEN0Yfk0mPMCuampjJeIxRXjaMz/zKTH3kc586pgpAgPU7fEz/+6//x/85M/+vOMbkykpBUyC813bVlX18he+rId88fBiHA6gBjAVbNBMREVVSski+n4N17Hz0/pcx+z4e8QixphLfr/qrap15Rdt6FrfNVXtHagAKhFNheMPRsCfbkNnJiLy/qZYNPWrr5fd0XJReffOu286h9vr681ms2g77zwiiaGrAjIrQswJ2YWqcqFmH+q2JRcE8HAYLi+vVWG327EPt+/cPTm/ZWa73WG/3/uqOj4/z4AuVECompEs54LAhJxzPhwGKYb4vY935tNglsiZT4ep0HpzEOanP2nsz178ub/0K75q9tvtdrtNYyQDMmjbZbM6fvFLP9UL7rf97vIq5+x9AICqqoh4sViklEV0jL1qNhB42l8pKkzMxITEzJM1QghBVAAgSbm8vmYkydFiX5k8s16edM2zd575hb/wF26f3wKVnDM9Fcfp24HQ19V07jYzJppmWlarhQ8BEZFsv9+lMd595tmu7kopbdcx0W6/izGnlJgZnTeE0LTL9dHq+BSIxbAojKmkolebXTG43u4V6eTsnJw3IDUuSM3J7fMXXlB2ueSU8ziMy+USEYuIKtR1E4J3zGdnZ6ujtREaguHTnp65s+cHynzQnvksIQBMSfNYPPnH13sRW9Ttolsu1kfPPPfC8tadJ4+2D+7dsyRWjJCbpgW1tmslx6ryqiJq0yJFRET28HT/DQBM882lFCKa1pmXXKYocr/fxAwAUDHENLIPwbd1E87Ojoc47ve9mIUQ4Gk0OX3XFEjGGIMPzM57R0wA2sd+u4Wuq51zUrSt2jzGQYp5p6JEfH19aM9PN9fXZou6CWp2GEZmDsEDwMExKV9ttpvd4fjsTNktF4v10enV9WZMZRiT74iqum6bYRenXRhVlmIs04MmQvKuCjePGudA51NklsiZzxKFnJ7cv1/GwVLRpK1vjpaL9fo4LNY//5f+Sknx4aMHXVf7QLvN9uh0XTe1ltS13eZqJCZAReKcS5ZCTyPHEMJ0de89ADVNk3LqD/3kSV2FRg2tmEjOYjkXABzHccwXV7u9r5qzk5Mb524EUy2mAPZBN+PTZN/Upy0gDChS+vHAVJna4dAP/eBdtd1c3bl9K6VUcj45PmHv7zz3PCKqFlFd++rx44uuW8aYz24/8+D+gzFdD8NOjQ2IfVgs1xdX25jzmPMasQpN3XTb6ytQRaSckpI3dEoA7Oqq9XVF3sFTp4qZT4n598/MZ0scH7z7jpYy7A91XXftYtGtqmZVL89vvfylq8vNG6995w9///eunlzGGCsfAjvHLgRW1cloe/qzFJlss6YO8+na7Hi1WqlqTrlpmiLFzJipqWotGcmayi8WLTsE0FJiHPo4HBBtveyIiAEBgJ4Wat7/R1VV0/agp7YzQgzTeE+36EIIAuaCPz8/B4Dz8/OqqqqmBrhZQVTXbV21AHTnmWf2/ci+KlmbpnOuErGr7fZqs7u83gJy3XVZS1EbhyQiRg45KBD7kMX0aWBLiBx8mM77cwj5KTM/vzOfIQbDdvv44f3hsAeAo/V6eXS0XJ9G45/5xb9m2KQikqNJDsEFx9dX15vNxocwTeNN4RIShhC6rjU1SQXUyKCuKhOtfLi6uipSpm2406YJNen7g3fu1ulZXQcABVDnGUCr2mvJY3/QkoIjyVFLLpJLTATa1hUjoGlJo5Zskj2TpDyNJ56enJ6fn6eUFouOHccYSy7jOOz2u3EcLy6u+nE8DBHQXW12u0NfNa2r6qZbAPvJT3G1PnahHmIRQ2QHxKujY3kaveYsq6PjZrEa+rzb9WAERshUVMUwjtmxDyF8zy64mR8480F75jMlxkFMXfChDs4Fx26U3C1uff6nfi6Dr+v6ZL1+vOw218OUBEwpN3Vd0ui9d8wF1AwBYOjHcRzNokhp266uqeva3W6HxN75aYFYSimnPI6jaklFLq/KGHMIvmvqfT80dYjjEEJdVEygqXweHYGioYISIBE557z3i8UixjhFrItFK6VElWHoH8XDreOjRdvEMaNmD6AlFXbicsojoDK7ybuGPOeiotp0ncpuEE1Fxlyqur3eH8YUx2EsR9q2bc5ZRHLJXejYOw4V+8YRDONYdcyI3jsBUIQx5+2+X577H/ZL+i85s0TOfIYgKIIRkXeOyde1FMlmf+2X/opVnQq17TJ4ynHQUna7HTKvVstpVWLTNHGobJRpsdjR8fF+vz/s+74fnPPd4vblxYWoStHgAzOras75qRMWAYiUYlZ86MaY67oOdZNSOQzRRLJmLi5UXBRZUdgBgPdE9MEuiZwnywdh5+rgN5vNC3dvX11egUr3wnOXV1dWGlTx7I5WCykyjTwehkhEHimpTJt+yIUs26IQc86ijv3V9bbplusYF4sFB3+92zL7EAL7MAWPYDA12auqghYTZ9Y2zd27d4nY5hDy02Q+aM98prAP5LwCJdDrzWYzjs9+/otf/It/CcmllB4+enR9dZ1zaZu6SG6aZrffv/veu/Q068eTBSLitHH2ZiE5wNAPRKyiwziIyKSPMcZSyuQD49ktFu1iuWzquq7ro+OVmiACqIjklNKh3zM7z8zMnm+2BnnvQwiHQ++9a9sGABDpfdl9/Phx1TWro3VOiYmm+Z+c8/Vms91uN5vr7Wa/3+9TKkUtjTmEcL3bhuDZsVkppez226at97vNbnu922z7vj9ZHzWhmhqPcik55yg5FmVfIXDOeRxHALh9+85zz77ETfdDfTF/LJglcuYzxKxquna1LsBPLraX+z03i3/zf/g/hqqTnCXGnMYYY90EQmTA/WZbch76Yb/fN3UzVa4ll5wSqKGaippZVVXD0Jup9+5ofRRjLFImdWvbtq1qh7RcLI9Pjr33OZdpY24axiePHptZ1y2855TSOI5mpgrL5ToEH0IghlIiAIQQci5t25jpyfFJKSWXAgCnJ6eIOOZ8cnS0Wq0Wi+74+EhKKVIQ3W6/866q265tl6FqRECKXu/2bdN2i4VKXHYVQll1oYwHRnEEwfk0Rs9sasNhNwwDEwNhFZoQ6qmlCZkIWMyDBJgbyD9l5oP2zGcIUmi7Z1/8/MP33sWq+8mf+Mrf/rv/Tnt+FyAQg2cMIVRVFZxLmQBAzYqIat4fDl3Ttm2bcxwARYpzHhGNeOiHlBPATUln34/MU7037Pf792dmVMUhk0Ef42GIrvLsuKoqM4v9nhFPT08NmQgDubquu+WySNlut2qT5aF2XUvEPjjP3B2fNJVP4/D662++8tILzbK5uLhcLWvPLqX9Yr0iUyRsF7e71YqI97vdcrWSoogcx6QIQ9bnX/rcvfv3yn535+6zuSRVMSmoEkIIITCiGCy7ziP0/SHmEvcHReWqRURfN8G3c4v4Z8AskTOfKVR1/9rf+rdeeuWVo+PFc88955ZHUpCdR8Ip4bhcLi9C0JIVEQxUpIhM3TaTCJaUACDlVEpWUVUZhzH4UFVVKeRyYeLlcplScu7mx1tEgF2RklIqUlRFCi2Xi5LUVfWTJ0/qtisKk/tr1SxC8IYwbPqryysAeP75F2OMXbfw3rNDzcJopaQQApoQ0qNHjxoPkuNy2YEVybFrW2KuiftD3zQNMG33u/X62Ii3+34fY5/UBR6wCUdNJnO1VzUtxcyaUIlq3w8GMvYHM1utVoYu5ywqiNi1y/V6XbXND/OF/LFhlsiZzxKSIouzZ3/29AxwWgeE7NzkDjY5vSCiYzd5DJgVYmSjcRzHcQQVYnbOlyKEWFWVoQDAMPQAMG2HZOJbt27tD/sqVDj1ECoiYqiqGOMwDC7UTdMqQl3Xh8OgInfv3tkfRjKY7GFdqGPUYnp1fX1xeWFqRI6ZVOX8/FwFidAxXW/7RVuvVquUU4wxcPXk8qKYtlXIWLzzVUX90C+W68urq9Pzs5zk8uJagXIB4wYDXRz6nP2Dt94+6txzz5wsAFPKRDepVQllu7liYmYW0c3uiQD6qmnb7uzsbLlYo5vtDD8LZomc+UxB7xUA8INWFQICtXHs+/3u+np7cXkhKmaWUtwfDmdnxzFG0dIPfeUYbkZoAKDOOYFlRnSORUrOxUwXbTv2g0Nu63rreNrSGELoD72Znp+fDzFnUVXdbDYAsD8ckFBUkZiIu26Vc+77/uGDh847VGvq+uH9e85xv9vFoW+atuvaJvimaRZdl+JQPL/44kub6wtfdaXoaKnk6L2rqkYFttebbrUUsZRKHxNS2Mci6F679wh8ncf0zAtfeOs7XwvBt85Vtxpici6M4yiIJWsBFRlLSWNO5JgcF7VStGpquGl1n/l0mSVy5rNDP1gjeVMnvHmPIzrHXdfC6enh7vOvPrl/cbgvhuv1shSZBmnIIKmolmmxIwA456n1LmfpbVpCzs5VVTWN3xCxFCm5pJRU1Qyapt3s9sEFlawApRQpBgBxzGqoquzg0O/7OO73h/1hn3MGgP1+r6ql5JTSMI5VVb300ov77fVqsSSDXIaUx5THJviuW4KJmpLzcSx9iKtlNxWUYozFbIx5iOPv/cHXtmO692T3ha98tSj0Dx6vTm/t+z0QA6EUGYYBAIhouVgM45hSKqV4Ty5Udd21zaJdrMi5D6Z/Zj5NZomc+YxQ+C77APzAQgEA1TkvOaac9/tDjDGEIGYljUZYShJVEymgAApqH7KB9UQUc5okcnKkEZ08u3Nd19PWyJQSAoYQ1Mw5J0MEABFJuTRNowJN06Qi4zhut9ur7WYYhmkXb103OSdVI8JxHGOMRHx8fJTjWPkAKt6Dd97UttttU/m6rsDKol1pLmaG5MFSyXksUpS22/1uyEPWIeUnF4/XD+5H1dPT4+Ad5IJMHFwfx5hTXddAWC+6bX9wIRTLdV25UC26brk6Wi7X4Kq5HeWzYZbImc+YaVM4fVgfYfLFFpBSshaqahi85jGlxN5PeyKRsIgg2fvBEyKpmWPmp/t0nWMzVbNxHFVlvV5775nZOdfHpCq194goIlkKqJVSyJWc1YhjLrt9v91ud7udiEyjNSIFEWMcm6Zmdjkn59zl5aUjTClJilXtCUCCC46HFKvK56JNtyBTQosxhuDHXAxoiPLOew+vN7sh5s12H2PcbC53Y1527duPH3z5pWdiVp1sbc0mo4gU46Lrrq6uFt0CyUJVhaatmiVxdXPKng/anz6zRM58RhCA3vz9ofjn6ZscyYUQVscnr3zxSyX1fb/L/YEYnhoPSEpq0yZHAAAIweeUndP3zVRTSqLaVPVms5kmW3xK6/UaAJxzjgMx7eDgnQ/eM3NVkRgQuxTjYb9HdrmUcRzN0LlKSkHg6S43Ta1qAOR9DWDX19dd3Tx+/PjkaFUkN6FSMwBU0cM4aJaUchNczKmt6rpd7Pd9H9Orr799ebF998HjF77whT/45rfrpjNyR8tqe3Wxu7iwu+dVVYWmLrF03WJqdZyMDlerlZqsVoukCj6E5aJZrYF4tmH4bJglcuaz46lKfjSOuW7b5frI1Q1XtQuBoaQspjYN34Hp+yvEh6GomQhNTtnTFhwmElURndxmrq6uvPdN0zBz8JpLRqT9btc17a4fihgqevISVLMUtTwVckSlCNFHHGMJEREQMcZ4mXLsh7Pz02Eci3B7vAQm5lB5GIbeLHh2AngYxn0/Pn5y+e6797xrxjFJsaLQVMHM6srvN1sy3V5vav/KMBw8+8krHABEJOfcdYtSYsypWqyQ3Pr41DUVIM0x5GfDLJEznykflT8jADBVIFIEBZjcDZmJFFWLWp6EC/VmIZiKmik7BwAlZ0I0tcmfe/z/s/enzZVl2XUguKdz7vAGAA73iEgymRwkkRSpLpOx27qrW12f2trayur39mBWVbKWTK2SREmkmJlkjpGRMYePAN5w7z1nD/3hPMA9MimKzPSIpDHfsjA3BPwB774Lfwv77L32WvMswkQ8zzMQtoSv4/EIQQCwXq2O08Ipw3FiohbPjUgRdZ4XrfWvvWZEJDrlYZ/CG4gx4HA4qJUyHd/7xjulKDGhz10SKzV8pWwIKTFaIJEM/coM16v185ev2iLQzc2Lad9jWE+0LFPXJ1d1TpwSAJgbIG1WF6a2WV9NZRrGDQ8X6+2ldEPjx3A4e6F91Tjf4DP+XiAQIvB4mF7e3hV1EmEWPfk2hIdHhJm3irLRVJKTZ2JLs2nJhdN0bCs6bUFbVc2sJTQgYco5IrRWdyfiruuamLyUejwcl2UxVWKS9DeVDg+G5BFxPByfPn3+4vnLD37y4csXN/NcIhhCmPubV7sf/vDHU7FHV09++7d/7913v6EOm0ePvnj+TKQDgHFcqVavmiX1KQtyzhmAWg5Pe6Lj4aimd7tDP2zUKferav4QeXHmx68B5yryjL8vCIBu6J88eaLz7sOf/JWGEVPKCRcADgutbZgdDkDE1HKuI6LU4ubDOJRSzHwYxlrr7e3N9vLy7u5ORK4ur47HuUnTicgDLi8v56XO89JoyD3MTc0iEBDc/N7KG+ENTgSAcABEdXMIIc45C8GLFzcEvt8fP0ny6PJy7POyTLrUq8eP/oC61eYqp5ze/8iQLh89fv6d76S+06WK4NXV42effsKb/vJqS0yqwQmWuRWziMDDqs8pG2AN6vrV+uJ6WG3Olc3XifO9PuPvBRwgCImYON3e3l5dPuqGvmhNzRq3WfoIt/oxwk21Vl2WRdWa6w8hqtrDId3NX7x4gYSImHISESJq3hZqalarFrWas/T9mHNPKBDU8mCJf/Z98WBbe9rYQURkRH79iKDmcS6cEWSZbb26eO+931qtLoZxW4rvdofcd09fPB+Goe/75oh+PEzjuGGRR48uhmFYjeNpxYgQCUUkPJZl2R+PDpTHzbDacMqvnzPO0sivHGeKPOPvC4iIU5dz/v0//Kff+M3fCkeiBPf05BHM8sCSjR/neW57Ne07qFZCdLe+71lkWZaPP/1U3T1iGAbhfEI6BWOllIipeXc3oTgRMTEQOQC8Do59CJBFYiLiFptzuu5oYY+k6uGRc16t1u6wWm/fe+cb47BWjVcvb6a5/O4/+icffPjhanvxJ3/yfwgPZur7YbNZAfjl5ZWpzfNsahFBSMIiSR6u2JG6YRxWa+IegP6GqdcZbxdnijzjV48m8AYAYuLUbdYXl9dXqe+6oV+WRc3M9FQqEjeWVK1Va9W6LEvTjQOAqpVaVK3v+34cSPj5i1fvf/DT/aLSr6QfkAkoVquhRSR2fb+9eHR5eXlxcTmuRqLXB2r6cmZWu0I3T5KYiIiQgu5lNxTgEdGGSJxSN1xsrzbbS5YEQXd3dy9evASAb37zm5fXV6tx/OAnPyEmkfTkyZOU5OLi4p13H6emAHVr4Y5E1NqjEcGUujzkfkTJD/zYHvZ1/Yh+fXGmyDP+XoCC0AEBU0ooDEGXjx7XWsPDVJllvV4TAAUIshBtVuvtuB67XpCzJFcN8zovgizCu93+3XffXW03eRj/y1/+8F////70+f64AADLOI5IAQCpG+4OR+b0jfd+IyWppSJigAVYy7dpCqWHChLQAR0pkIIZEJGFmTMxA8B2XF1cXDy6uN5uLy8urn7/D//ov/8X/1dO3dOnT+9e3dzs7r75zW/+9OOPlrl+85vf/Of//J8T8rPPv/gvf/FniPFHf/SH2+1WkghzkhQUGrV6TX3S0OpFcpbU9f1aONVaTxHliH+jhuqMt4PzuOaMXz0Qkdu/RAck0qV88fTpPM+cupQ09b1HLMsCAObm7q3IcnABSSnllAEg1Fx1jinn1I19P44XF1fqt1eXjz774tmff/d7WuY/+Ee/Y7WY6gcff2LB73/w03H96DfWK+bczMnRHRDQA4EiTgRExG0xvNWSDNj40atm4S6ljuXR5eVmtb64uPjGO+9eXV9HxDvvvfvuu+9+/tnnn3/+OTO9eHUjqzUiSko//fBD92hbj89fvLi+fiQodZ77QbIkYGKmtmBjphFRtXYsJEKUmM/v2a8V59t9xt8POAACQkDV50+fPf3scyLabDaTmWupy1JLafOWWmvLXailIFI/9FWrMB+m47IsfT+WUjkz98M4jIdpefLk6umrl69evnr/g5+Gx9OnT1POXzx97iDToh99/PHv/+E/BcK2ysJE8FpMc78kGUHEbgaI4EFMwpKYgWUzrDbb7aYf3r1+dLnZrjebJ+++s7m4WKySSJfydnv5gx/86MXzm0+fff57//SP/uAP/iCCfvTD993hYr397d/91pAosTCLEydJjoR8mhq5e1sTItRxGJrC6Vf18/m1xZkiz/j7AQIA0Ll8/tmHf/af/vTjD3/65GoF7mZWlsXMRRJ6IGGSVLW2cAUW7vt+WRZJSZhpGJjE3Go1oMoEfRJf9+88uTosyzvvvPPxF89rtVdPv3jnnXd++uHH4fDBRx8X1YgQESZyZgDALw+KW4A3EZuZODBTR5xI1qtxu90+uX58tdm+c3V9sd5ITutx8+TJu0stRLI/Tu+///40TZ9+9um43UyHw3oYN5dX3x/H6XDMXffTn3ywWXffH+idy1WKgmS5GyJCBBCJmfu+zzmnYTuuVhQAHu5Gwn/dHTzjK8GZIs/4e4Tnn3/y7f/4Hz55/0c5Yn9zO/aCwuqQ+wE8qi7uAeFEtF6t2vlamCtRzrnkPE0TgKFiC6gZu36W4zLr9Xa1/+wlAIcDSR84Pb/dp2Hc3+7r4fj9H/5ou1qTJCEO9ForNHU6nYQ+hOLhaooKnGTTrYTo0cXVk8dXV1ePHl1ePt5ebteb1bgZV2M/Du646leJ8vd//Fd3+90PfvLjQNjtd7/9j/7x93784/HmLpG8861vffHZZ9UqRvc7v/M7iAgBtRRATimpea0VhYZhjAhTTZJEMjDRl/Ti56LyK8d5XHPG3w8YzLv9D7//V5998tPD7c3+7ub25pY5991IRM255/UEGdEjHrZQhr5PIimlvu+7rss5CyfCFOZd4l6gF3/n0cXu5tW4Gp69eE6SDtNciyJTRHz00Ufb7XY9rABAiDpJklIT9zCLsOSc+9wNXZclrYZxu948uri6vrp6fHX95PLqycWji812NW6GcViNq67rNqtVl/Lt8xfLVP7iu9+5vb293e+GcX13t//f/fE/+5M/+ZOUZH+3Cw9JiYn/9b/+1x9++GHf58vtRd+9RkoZmq+le4Q7BOCXHeXO+OpxriLP+JXhYRxLAMui3//+Dz786IPd3c3ueFeXQ9d1u8NeCHLOVjU88N4IwyOITo5h7iaSAB3AmyE5AoGHu07HKWdaDVmtd/DryzVhbNebu8OcU2+wECAIHvY7xDCvBBjEieSkQCJKKRFRrSYirnrE43a1evzo0XZYPbq4vHr06NHF5WazWQ1D13WSMzABQJeypLQahu//4Aevnt8gJ1sWd//Rj370xfNnv/s7vyPEu8OtuXrBly9vUsyff/b5n/yz3y+15K5rgkty0GbXRpRzRhREbv3aM75OnCnyjL8XuLt5+v4Pvzsfd7e3r/aHXSc0leWTzz5/tF2vhs5qjQjwL1kFnebabhFRq1atTBwOHgpAEXF7++ryarvqVwAEoBfj+PnN7njcH6dCkty9ug05rTeb6XDc390xIBM1lwqhtgOeKIlI7rrOq93t7obcvfv4ydV6O/b940ePtutN25YJhDZgMcecckoJEa8vr8ZxPJQZmfLQ/+Hv/M53v/Pd75ey2+3MtB96Tp2E/t43f+d3f+/33K3LYu5oDgDuXooSYe6HbrUGlqCzu8+vAGeKPONXhoBgQNOYlv0HP/z2dPt0d/tctQDA3eHAJLrUzWoEoGrhVVnIA5vyxsyJIqWkWpuv+ND3pVRXIyIWYiJfretUBfv1sK3lcH1xOZssIbv9p2agSNJ35rZdrXa3dz0ngpwk9X0vSTb9mERSziSCQl3XWambfhj7/vri6tHF5Xa1Hsf1Zr3p+77N2dtQJ0ln6n2fqtk//se/Pw6r3TRLSs+ePdsdDsf5cDgeiWhZzGKhahnx5cub42GapklLcE7FFvRQh8M0X1xdS78qxmuS0z37EkueGfMrx5kiz/iVgQHd3cN++P3vffCTH758/untq1fHaQ8AKcnu7pg7vru7G/uch/5QdwjRVNzWdl3cSikPK9OnxWlmJAKAiGjD7nlaEHm7Xb/YHYkZAyQlBSRAC5Sg66tH7z5+cnjxCmp0Kae+61O+XK2zpJwzCSNz6jvwWPcjum9Xq4v1ZlyNq37sUmZhImLhiGBmYc45Nwv0q8urb/7Gb94dD5ePLz/+4nOdDpePrnSx/e2dCAMzkzBCSun66pFXLeaJqGh1VQC4ungs/QjSkyTOHQKfOfHrx5kiz/iVwawwy/s/ev8nP/7hYX8XEe6KiOq23x1JaJ7mG7lbrdfb7ZpT0rpkSU4EEF4dkVQXAOi6zh1ZiP20Od0YVITcqYK7V0R+5/Gjp3fHq6vty91tuJsFOYD7O4+f3L142XO62GwlSd8PnchFv8oikjMlAcRxNQbCOve7/W673qzHse/6nLMIM3Hb9Q4PTklSkpQAoMzLtMz/w7/4F58++yLnvN1ugTAi+nUWgpvdHSEyZ0a7vNpuNmPKQVyrLvM8Q0ROHRGZqZoCp5yyZAEAP89Yv16cKfKMXxWcWV4+/eJ73/n2/vbGVdXU3LTqYX/w8LrUruuWoje3t7nrct/ta7FwOpnaEiJVLa8dJhAJI4moupt7hBBFREqSs0zTNC96sV3/6IO/SsyGYqZuVZDRXYgfXz4au7FPuc2SO5LcepEiQTh0AzFJECGuh9UwDMTMLEQkSVr2d9CpitRat9tt3/d+F++++9715dWnzz/fbDYvb18dpuk3nrzz8uUrYUQiYRTAf/ZP/5CFIso0zQ5hteac1+s1JQbOY7+6uLigxERnOeSvAGeKPONrwpvz6/Z/892r7/z5f5x2L7xOx2map5bmGsQUEQZ2OBybtQRzeufxIyYyMxQi4kAFgFKKMO92ewAgJSZSVQAAdK1lHLth6FS11BnAe6FNz2MvT29u+81ll4dlf3iy3l6tty9203ZcDdINuZMuJ5aOOHPKOVNioNR1vSQZuhGA1hcXfTcAwGo1IiISI2KbfSMTEqlZKYWYc85JKwLUUmKi/fG4LMvL3V3uuyxDqfW9J4/RlsurddczK0jQ/jixyHpYj+MmDaNTR8wRkVN/Lh9/JThT5Bm/GkRZfvSD77949tTqVOZ9mY7LsjQP8IjwcDd3t2maiGiYjqtphSTuHuaJKRAAABHNPSVGRCYiYsYwNwrourQsU8tUyJRnPQB4TvTk8aNPXx6a3WOW9D/9j//j8W6/6ocxd2Mack7CIil1xElSOvUiJeckKal7N/TN7Oe+BUr3zkB02vJGzDkTs5uVebGi33jnvZ989EHOOSXphn673arWhPh46P7pH/z+t775ztU29eT1cHDVi80WmYduREQzdcwk3HVdu2ln14qvH2eKPONrxUMh9Pmnn3z08U+Px31d5t1uN03TMp9YsoV5mZubR4S7L7Xsj4fV0AWAmhGGR6CQsFStpoWYm2gyAMIDCREwwh6U1u0YnoXefXLF73962B+ZRcyFSM0uxs3lasNOIiySWpNRJKUuozBTykOfkqh7XxYRIaYkSViQsGkhm9AciH5mjZoRr7YXVes4jE/kCac0rlZD7t67vv7jP/qDJ9cXaHOdX+m8m6a5zLPkPidpkvhx3BTgiChqP38Dz/h6cKbIM74+3L+9Pcryve9/79mzZ/ubl2U6HHZ3yzKVUpqhrJq2DyIipeTupZTb/Q7Qhy4DYDVjACIiJlAotaBSq+Oa466wsLBIMrOWYEMYEZGEVkP3+NH19PkLRkyJxy5zP27XG3LopK35ZWZiFkqMwpSEiCkxiYh76zwScdvAaQdtaD7hiAFAiKWUnBISdV3XJu9WtOu61fVlNR267jfee/dbv/WNdx5fCvlxmpmYRYahz0zM1Pf9dr0lyUUVJIl0D1XkGV8/zhR5xteExo9hvtvdfvu//Nnz50/rPJlqqYt5VVO/jxkwNXNzV8BoBjyqPk1TYiIIZiTXxDwfp4hgIq1o4UwoiYdhiPBWfpal2dMyUTh4ztkiNuP6d3/7N5++vK2lbjZXYz9QrgCQmFfrFREDIREN63GpVXICJpEMiEEoktqKdCBUU07CRBGhbtJlR4AIDSdhDWcgAHCzPnfSpWEcNo+uXrx6tV2vnlxfXm77lC3Muj7Nd3d1mt085dyPK6I0l8VLBUwAaRyGruvaL4Cz5Ofrx5kiz/hagUzPPv/ii6efvXr1aj4eluNhmaZ5nmutbaLdhtEPqSxmBgBEAgDzXJih7xLDKU07PIi4fcXpbK71tCHDtF6t3V1NAaQxTGBK1H3j3Sd9Ejd/8s41qK374WJcjylnzkTkjMjMKUmESEIhTomZ20Am5dSEkEjYfL8NTtG1LXgMLJhbfqEHwjTPc1kiopT5xfMvLtbjb717fbVKObnaDI4E2HUdWqm2ABCRMBMRRWDKWVarYVjl1COe36q/Gpzv+xlfK25evvje9//y1fNnZZmWZSq11FJrNW0M6V71dZi1u4M5uGtQsBy0iqwSExKYO0W0HC4mel2BmkYQIoHZRJO3ktJ8PfZBgiwVE/rx8fXFJ58+lcCrYW3lIOrDmIUzMoUQJMk5A0DOqdElizSKFJaH1JpW1TEgsdRam9ckAFAkDKAAAJB+6Mbx+tH1ehxevvj0sNzWbd8/WQuhmRGwWbl9eRd1Yoq+T0wt94EBkDl3eeiGgYTh5xLHzvh6cKbIM75yvJGy4t/99n95/vTzw+72sLtzm+dpLstirfvo5uYPWV3tCyHC1BAMAMx8WXJiwi652cPRs+s6c2+Pp/AHuqy1NvtbSi3LANzAyYXwt77xZLfbfePdJ7uXN9f96nK9AY88ZGTyzNBYqk3IuQV0P3zmRFUtSBYRTxGyHm005O4IQAEPrkQhlFdDYjzuXmx4NYpmDl0KMhFhKbXrOgNDCABHCiImwnA202bIpmZy/049S8e/Zpwp8oyvHA/8+JMf//DVqxfH6W467Jfp4FatLqpqLY8lwNxady/utwnbqVu1mikx3N3dhY1ZNo6InMMRAFLOUErziJznJSXJOTNzqXVIiYjUTAgIOTgl4qsNv7qRq814/WjLgi1ddrUa+75HJktEIm1CnbvOI+ZliZxZBBFJxMy0aGPGlFLKiZAiojGXmU37o+W8Xq/c41iX23n+v/3f/x+PH6+u13i8+WK7HqxOmHOb8wiRCdtyn9MdXkohZMnMKXnE4XhYdys5D2x+RThT5BlfByLik48++s5ffHt396IuU7gygpuCt/DAOE7H8IgIJAw7lYGnUGlEAGx1ohHWWpelojoGiEiEAzQ/RVMzd6sV4D4rsUW/RgSk+9NxAIc+vthM714f93erb222q8v1MApxEglhTgyEkhIyk7CWorUKMwAQszAbIqD7fbJNeDg5BRggBVAAeojwzc3NVIsS/NE/++Pf+r3f+fyTH3/zG+/ue+z7MRwpgIkIsI2TmAER2hGekJkzS2qpNbvdziBfRE79SHI+b3/dOFPkGV8pmq8X3N3dffvb37l59Wo63FidEcO9mlnrNoZ6Tn1EUFQ3X3xpkmxmnpfSdRmCa1VCNNNScJ5nYGaMrpWnYYjIIh6BIvcjFAM/HXaFvkQsjHG57o9XF/OxXL13DSYmPPZDlwcAMAKDAICu63LfVbOUhRIBhYFJShwRZqYGrwtkAADVigGCxMJhHuqS0v/yv/y/H3/rm9e/8d477/3G5z/6c05dpJ67kUiEmFGIYrFDmCO4oXlpY3RvlNwM1qZpIt4PDsN6IDq/Z79WnG/3GV85MPyHf/Wdw+5GdS7TweqCYa6GHmbakqOZqdSylKVW5S8zGhGHY4QDcESoaq0V3HIWcUdEISE8meCCuJkHQoS3DmfOWbrsQAxg7iSYRXrJl7M+3d/s9rePNtfjZhjymHM2AwyncINISSSJCOe8BkIAMNWUkpu1TqPb60ISEL0aBkRCrZpz5iw/+umPP/3sQxzwe9/9T+JLYkrjSJKQhYkEhYgCUUvRMgOqRxhaFwzIJMYSACDM6rY/3DkCMQyrFQCeLX++Npwp8oy3jEYb9yRHEPrFJz958fTj+e4Zlpk5EtM0T2H1OB8AINCDo5TJI4go5+TuFOhAENBSGZLkzWYD4FWXCL+9vX33ybV5BFBiQYIAYAgmDA4wNTXzmI6LCAOQqUMiRwiPZVnQYxzTxbieu+lH3/32f/fH/7ww1eYymTtkcQhRA/BlmfqcAknVEIAJsc3QWea7eRiGU2wsYp0rBpR5Yl6lzAY2R/1//c//T07+u+9t/ebDvkvLvB8uH63HFXc9sBARACHiaj1yFLcFmcZxRdITcfPojYhSF0xYqsfOPJYIG4Y18tkY7WvCmSLP+KoQYa7l9ublX37n27tXz9EWiFqm4zJNdV7UjImslYHMRgTuhOTgbfm5fRMRVjV3N3cmIEpg1SGOcwEARIx+yEIAgBjgoG2fxiw8UkqSRJIwy7IsQZyEhAWJELHL8uhy88XHn/3L//WzP/zDP/7f/8n/MfcdWPHgiAAPCkAERwiEMEMkJGJAIiamNzdeIgLUsTVTTU1RMP2r/+1fVZ9/9zd/sxxvc7KlWs45JUY81YaIVLXqcqzHndY5C+c8SOqIE0qSlJHIzdHMoSCLB+hCN/YyIsZxc2bJrwdnijzjLePhkGx1MddPPvxpmY9JBLIs8z7M3LUl0DzoCyOATpMKQG+D3ZNOiFnc3MPMClN+eJa7uzuKrXsQEgQzS8SpM4hIQB4Aq3Ht7kV1mudhGAijak2QkMhMk6TNdsW/9eSzz774l//mf3XG/8t//z9sxkssEAHgBu1AiwAIqB4UQadkCAaS9jrbMwaAaQSEq3vNKf3ZX/zHb//Vn1+/e7W9GN2KE05a87ASTs1wI0yB0F3N6zQdvEwUnaSu1kqBBBBIOfceDrW4Reo4zLUsYHbYEQYM6xVSOrPkV40zRZ7xVcABAsHrMt28fG510TKXZZqOU4QhoqTEpbifLBDNHQkJmAIc/E1DGyZSxLY6ExL3wLLUY54B4EBH827IkVgiImcJDgo2g7vdHRELM4s0K3JTraUMw0q1enIWyaM8fvfq+e2r7/34L3/vH/2T/I1u4CEqtAE6ACACAqAHBiBHKYWIGBA8HkY1LeEawd1Vg/fT7X/4T/9uM3bbdV+nnfQS0ud+IE5B0tqay7K0MLKU+OJypRMlzrnrICWQjCyckrsDgaoCBYh4mLqB6RwA4IA+rDZnlvyqcZYQnPEVIRjiww/eL8tkdQE3N++7FOZhWsocYGal1lJ1MVVhFMEhp7HLnTBDCGHfJRZhkb7vh3Foh98W3YWIy1zNHYIQMQI1TMPmasVCNUopCILIiEwkd3d3z549c1dmcdcIk5RKmQFcEl49vtgdb//nf/n/+fO/+LNj2ferlEgogFqF6CFEGKBLaZqeMs1N33NS+QQQuJldXm6D7T//lz8ltMfX64H9eHfjywIAjkDSS+40HAhFMgCE1Xneqy1IBhSLVlWLCCJhTqo2TZO7C2FZJi2zlqPVSctxmY+H/d102IVZK3jP+IpwriLP+Gqg5ekXn7168XxZJrXqWt2KWZmmfUQAOgt10HlE84WEIDWrpagpi4g7iwCA1pqShEdbu76X2jA2l7BScs59JIvg5hiJqGZuxkSt30dMbj7PU9d1HmF1nibv+76UgoQRjoTrsa/Vdvvb//zt/2Cuf/RP/vDx+rqTTt2DsJSWZB0QoWFuTkxMHPfSSAwg4TzkSHH7/ObDj3662Xa9IFhBq1YXFt5uLjcXW05dsXjY/4kwQF/miVzDmZr88oRmSKnu1Y0JEQEJAEHdoC7ejvy5G5gztA2fs83FV4AzRZ7x1uEADm4vnj8/7G6tFquL6mKlaFmGsXczd/GIZVlMNYjMyVRD7b6ZiIRoEQDAwuYe6ElS9UKn6C43AI/QWk11nmcTYxwoCyI0dXdEJMmqtixLeOSUc8rzPJtqzj0AHI87NduOawjarNZewzqcl+O//tP/76Ec/s//7P/0+OpdiShaOSWEiAhzI+fZZq+W+8RvSBS5z5Ti85ef/dt//29V57CuHmpivL7YFtX1am0QqRuaE7CZMhBgtPhv99pWD5m/FL3Q5D7h4Vo5CwbiSW2krrAgOFI3TZt1j41yzwz5FeBMkWe8TTyMWeZ5vn31kiHAF6uLa/GoqpqIF7Naa6lVmJ3IVQFCzSKcmDruEMlUSykt8KC1IFnEam1uDu6OBNQ0MaXUpYxjjwF9RM4tSYYBYFmWNguPcDWDZSm1rFdrjwjzw36PSDV3ESFIjy63L1/eACxdL9/7wbcPz27/uz/+59/61m9Ll7q+j0AACA8Wxrsws6HPKee4Z6Xd4e6jn3747/70f3tx89TqMcnm6vrSvQrLo+trYrq4eoSIjmDgUZVTGz05ABAlRsypT11X7WGfHYiZjFTVPCSotUUpCMDdFapbwLK/3fQDcIZzss1XgzNFnvHWgeH+8vnzpUxIlpgAHAkYeTUMx3lmJEZiwDJXACBkCM/EymAnVzFoLchSymroIUxVKRzACUESA3B4rVUXdZhLYjoeZ3PTsC2OLNIOqV2XzN1MVUENAWAYRgCg8FcvngHAsFoRAxO7Wq1lven7Ic3zNE/HTz9///nLTy+2V//49//wN3/jm8OwVlNCHIbx7nCLiEvZdV0HTPvd7umLZ9/74V998MH7x+Ww2ayQouu61A3b7ZPN5Tp1nXS9mmIYKEaYmVGfASLn3OfLSiKEiRMyI0MgIxIATMej36sjAQANCQk8hAUAIMK16P7myDxePUEZAR5M1s8V5VvDmSLPePsopex2t64lXM0rC2EIZDelrguitioDtU7uHh6tIYmI3IxtNAhRmCNJc9Np8YYsEhEU4BHCYmrqoXo/r1gcAIYuIWKjSCaOiFpVax363txNtaq1rfCcJTFO08HNCREA+pS61AkBxeQ1jscbjbL81f473/2zZa7DOAbi5eXF3d2de6jWUsqyLFNZ3HXcjIsdxnXabrrt5tH1o0ePLi+kS6nrSBKnjJwiAlCJBBFNdRh7QJqPRSQTIECEAyAzU7ueUguJNLNKCvoZ0kMAdtB52tMtSDciYzp7Xbx9nCnyjLeJdkhcluV4PDbLW7P6xt8TU3IGQmeGrnN3dzNz3w6DuRet8zzH/c41vga12Cw3c7UwSzmXUgDA3ao5oAMkAJinLkkXjkg0zzMSdl3X9727e63mHm6JpLn7TNMUS0QEthO09ymllGi1HplkWPd9PwRyREx13h3nqSyv7r5YliWIlmXJOZVSgbAfc7/i9ebRdrtdDd3jR1cskrokzCyMzWH3ZMlBkoSImYCZAUOaQ68FhAbc27AxMZ/emyfrSQS491h7kys9Ylmmbpm0rlKjyHP9+FZxpsgz3jIiQpfi1UI9zHQprsUstLqqGoSpupupvQ72M3c3rRUQcs6lKCEKUvCXhrRtmuFqAECILKymFg7hUE/D5Wma+r4XQkQcxhHuuWkqpaU4OLGaNhYG4OPxSETogQXrvOScx3E1DIOZP358OZVlnidmub7e3N3dOaGbDivJQ1+LEBHLeuj7lOXqaiuSxj7nnLOIqQG4dF0gQHjESUTZ+F6Es7CZAUTOPZkFVVcPC75/wY6QU3Y82aP1ffM0eu3me3Jjy8kDS11GLaAF5LW6/oy3gjNFnvHW8MZKDCEhMc1TaZ8HgGZaEwhE3PdDytnd27Jg+3Ji1lJqrV0S9FAyUy1LYcAmAAoPQQrmiADwnLO711pTyloXdeiIOKWpTOvMOfdNGAQA7k5MHkHMjFjdAjwASjVBUjV3Cw8jAPB2fBbhaTocj5NqHYaBRR5fXz1Udg3jOLSBEgoRooMJQRYKdA3t0mAQoMaJGaBtPeacHUgkqZacMyO6OhIuc6nzBEBj6gCgmW6wCANEGAlX1STiEQ+uRUkyEbcbWpd5Ot5xTswMyF+OLD/jl8KZIs94m2hOPIfDcZ6Ptcy1LtBEPIQ5ZyIyiIcE2FqKqTaWTJKSSHgAgFcFwkxkRIfjUZhTSsw8zzMAMLO7R4Sw5JTDozUeAaCoHY6H6+EKAPaH/XpYt0vyCCJOidzMXMkRlE31IW3R3CN80QoAkhIiLsuiGqUsEbHb3xERoRHT2A0PL3aZdom56zpOKTiGvsecAACRiAQImQRImBkIgRBakCwgAIhIKYUxsjBGMAvkHgg1nMMhwu8F4YjYBt8PeT7hgYwRoWFIKdw9fFmmri4kDNgDnqfbbw1nijzjrSEciaHWend3N81TqXOtFcLj3rcREeN+PhMRSMBCHSYsAOCIkDtGCkpSSimlmBsTEEOzniAGNycCYkBMEd7Om2GV+PQUfd+HY63WdZ2a0RsHdUSUxOQIXhUg0Gq1tsl30nK+fqjX6mXRAEAEr+oAyzwDuNUCbeUGQGvNkoZhyH3XjQMO2GbNzEkdhTOQ5JybZ497AADnRI4AkHN2t7IULQu4aqnulVkoEEiIXwectUrQH/4AaOwZ4G0eZWAUUJZpng6cuocIh3MJ+VZwpsgz3ioCXMt8PNR5KnOJiGi+uQAQ2ParTxGuEaeDpzMRt7RrREpJGLlxn5r1fQ8A4WGuSdJiCwC0DCw1YIGUcyh4G4iLzPPs5v3Qa9XNatXyZQAgINpUnATRe4AZIAOAnYo+iwjJXdd1SBERboaEQrKUSVrd2vZrmssGAII3FmMmFhmGYRjWiIwoAETEQSzMJBKBjic5DhM5YES8fPmy67quGyI0rBV9KaVUq7kDWAT6f23y0u5ia3ICOQB4GBmU6dgPK0gdCfF5avOWcKbIM35RnDY6Xje+iAEcjnevbl98MU87DA2z435q9ZEIo5DPlYUZoBSjpscO0KV4RCIeVyth3h/2ADDPs9Z6cXGxP+ybmHw1DAhQS0kpEwMWB2CrRQEeOpuBSOThSCSp7xo7mxoiA6KBcxBRYvbwJSJBYk4AYOABAIFILOoWHO6u1qrRmlJulNdMiYgIKTbbyzAjSU3WQ/ddQkTs+15EgIlI3F1Yuq6T3AMQEJR52W4v53lelkUEOUnXdUQBQJJoLlU1OiYNdzMkzjm1nUWti1bqx/FnasS20+laSild52dj8reI87084y3AAaj9YeXu5tV0uHWtZZqPh/3+sEeMzWbTWJKZj8dji5QhplJKG22zMBEf9ntiaqPnvu9rrU0SSYjBZO5MFJIAIMIiQlqYjCrjqUQlYjevtRLRs2fPmLh98ySpXapBAAIiAxCAnXb+EMMD/XV4NyIBaCsDM0FKSVJKIqlZ4RICAAuDcEq57/uu6xAxAHLfBXJ7ODIzU0QQUSCTJPcIhJSzuidJQIwEBIFCZq7qTBKOreB+8w63joEjQOD9+jYCYURAGIUD0Gq9zn06b9m8XZwp8oxfFPdrcg89MqvVtSzTQcty3N/Nu7v94aB1Gcc1OoZ5UXWwCM1ZUpLj/uCuSE3CYtM0DWNXSi2liHDXp4gRAEROehl3ZSFidLNSIyKIWVKqqoho/joeVlWRUGvJORMTy5doo9GPIzjCkF+rZHQpTcvZwsKIiEVSTowtQZtZhFN6ECKFR/vmOWdmacuIOaeqgUjMzEmQmRCYmJlzzupt45AYmAWJ2L0SIwtqVdcFwIoXCvBEQIQUJ2/NxnxID/WjY1MAOfw1eC0POuOXxJkiz/hl4UAA7uCI4Vru7l7evHp62N3Ou7taKjLNyxHQ17juh94deRB3a8fMlDIA1FpaX7KUGuEpCRG7W+669letNemqOWdELBHtVNvWsdvHTESIHo6OqgoAkpiFHySEABCOgO7W7IIIAN701lGA5lXx8HgmSilROBERMyG62QNFIgISElK7AHcHJmapWh+M0xERQSyQCUkESgGAlLq6aO47ZnGlpUylWK31eDwOwwDg7dcPI7pDtD1upohoT/gz95/ut4kO+z1K16XV+W39FnG+l2f8UvCHniQACR+P++eff+w6T4d9IlTwu7u71Thy33VZNqsRCPf7/aKaJfVXV2ZWSomQNqhJyQ6HQ2IxVatqpmVesqSIEOIKqGZElERUte/7ZVlyzuv1er/fE/MwDGVZGsdFBEBKgm5QFhXOiAgQEETMEU5ESbpiQYRmDmbqEIGBgMQYbRkcSikMgURQ68+89iy0GlfmtixL7ruiCmw3NzepG7p7Wjf3QLIH7ScJJQGn3HcWaGoImLvhOB2mZV5qaXpPNVWrmRHBAaBqAQBgZkJOCZo1u0E0q4twRELmph71MInzjs1bw5kiz/jF8cCPDeF1v3u1u7u5efmiT2xV1QqY7vb7nPN6XHlVFO77PqVUSmlj6BYG2z7Tqr95mts3FBZEZKI23RYRVXV3IBIRAFiWpdZKiC000QGYWFUNXie4tolNKYWZRajtbnsQgKs2Iae7W4vwRkAAQUS6f2FuHuDkjl/WDwEAIUdELaWJb3a73Xu/8c1lWUjSaWQPp0IyMBDZLBARgYOAgAHb96G+S8uyMOdhQNcHIm5BjB4RYPfvVCZE5JzD3ZEQKcIjEAKBwlTNPZ2NI98qzhR5xi8Lv2+PIYmWwhhCgA5Wl/BIOaWUpsP+VjhnQaaUc6k6z7NIAgAiSinlnEsp6NGnDOl1f7DUYqoP59YHlkREImKiqmoAeM+Sbfyieor5UtP2fe6/nFg4MWmtAIJIbUUcACL8FE6LBgAYEBFa1SMozO+n1U2EdHrhEea2LI5Ir25edt2w3++7bqi1mmlEIFBTjztaI3ppGzLCpzjsIAI/zFN1c7dlWRITADTDc3NjYjV18+YN3Ba4W7Rsu+vu4e4UjgZqJav+zJznjF8SZ4o845cFnf500LIcDwyQWKZ5V2tFirHr727342okpuN0vLi6AgAiyjm7t7EGIqKZI2LXdSziZmqmtapZTrkA1FofKiMRCXc1a8pKIjoeDsM4tkoTCSmImc2s1HJ6fMRpOTqRgLT+Iyo6qTuJQLPTaLQIgM1PyNwAwFSJ8WRCQfR6VnNS4SgiMlc/esq9q9JA7q5qABCEgSyUNIAocXupgMyCeH/bgHxZxnFkhDJPJ83jG/UvACA9dD+Rif2+pG3XYBGAgBHq1mw3v/qf+a8RzhR5xltAewe71dtXLw7Hw7JMze927PplWfrcocfLF88vLi+6YUAmSWm1HuZpbk3DnBMA5I5bzOp0OKKHudZa1IoIptTd3t5mTmpKSEgIAaYmhK4+9p1pERaGUHBARwykIERAN68AUHWJyZhRWPZqKSUgghBGO0mFnJropynbAQACiYyYIpy4qTmhkxThZh4ASRIxMWPKHIRhJr24O0lqGp0kKRA55TFlEkZgB2QmRziRXgACrFarad65OzNjADgSkUiqy4IMIoIk5kb3Q2oiOqnWiRAxSXItEZFzNiu1ah9xPmq/LZwp8oxfHPRlyYlXLaVaXShgngsRswibqdbjcVp0BoBAfu83v9F13fFwKKWklFiYmdtOooe6OxERYUoCbcPaHRFTyq5matVryomJg0OSAIC56aTmxsJVa+PZiHBwtzbuqK1deDgelmVh4WEYmj95o5uIYEYkaB1Jat+BA4KJqY1r2ti61aRE7m5NUZQSd12nboikqqmDnDNKImHmHCDEbOEiYhAE6AAU8eY4JSIwAN1FxKq6ORGrVr3vMLBwNXePh+k7IhIgALTzOxKFBQCEuZaipknOop+3gzNFnvEWQAAAVEpdprkUQ2RiSnIatpRacs4atWrt+56JTXVZlraC0vixxWVphKqmlBpRMgsizvOMiMPQ16V4eNTQqs0Ug4lDImrklEstD/rwBnd39PZBKYWdETE8WuQD85BTBrAHUVGTEQGA02k/0jHCgzHebIZGhJm1FRoWFpaUkiCQpJxzzjlJyjmn1OfcqZFwQgjmpG2/GwEJPYzuzSba5Mrc3Z2o7cmEKzS3DkQkYrhvqv4NQEQ311rP7ci3iDNFnvGWYG61LsuitTLAOAwAoFZZeBwGcx/6YbvdDH2/LEvXddfX1x7hZmZmbmMaDU5inabIOW06RzRpJEAW5NaeOw2yuXEkH8txGIcmaYSTtc+pkjS3RosRYWoVq4sjolZV1a7rMCRCAYCI0b3NiJtpYxA5hrkx0MOE++GQCwDjakwpIWIAdV1O3dD3PUkrITNJJhGIoLYReWovGhGamnRy0j8GmFVTjTCksGKMpO4t+Lv1QJnhwRDTw+lLd70ZXHhroSIhgGtdkiQ8+/28DZwp8oy3hPBlWWop2+1W54PVpe/73b4CgLpP0zTNh5vbm5vd4fr60ZPHTzB3ZZpabPQ4DIm5Bqz64eARcUpK6Pq+zkvmdDgecs56P/6GViGaT9M0rsZhHEztTYn4A9y9TcBLLZv1hu5NvZuFBAQFerTza0AgQ1MaEmKAm5MguUMYYZuxoLunJKV4zlmrAkA/rt1su7mkJA4ExON664BLVaxKJId5Epa5LN4cjyIIYD5OAMCcmIiYEJIp18UwzMPcIyz6lLssYIoB6/W62okl79sIEOGAAqEE4HHK/VqWpSvLMKy/pp/7P3ScKfKMt4PwuL299Yh2YOy6bp7nUgohUlPzMTc7yL7vkfDm5lUzp9hut0hYSokIixBmcwQAIvaInPPd3V1KiYlmUwBIkoRlWZZihYVbsvbpGk7pYA/FaJi3vcR48zHteu6rzte8QwGICETtUN0ehkTozemRiMi1EjGRMZO5oSIAIHMeeiAGEskdsoSDA5lBILpZQe2c21W4WbQ1IA/EtrHjtZRSFnP3MApgJgBkwXYJtc5d7vB+Dx2bhikAkZrTXEQQUmPwADtJjs4Tm7eBM0We8bfDzyU1/7y0pJQC6Eyw2q5vX70qdV6NI4vUm1fEQESBEaHPnz89Toeh79fri9V2e5wmESZiRNRakRC8uQbBsix3d3f90Pd9Px2n+1QXanJLcwP0UhZEBHywfXyNxo/Neq19pqlnmiK9EeiDU1FEBJxk6k31jYjAyB7MqVWfzASJJaUgFGYg4tx1XRcAgYBEIpJzZhGrp+xFINYwMnJv8V2ACAREiHe7WwBYr9Z9ymZaa9W6IAAxCrfSEpGQBNW9AyDiABCWdsX3C46BQcQAQUTUXqrqzy4CnfEL40yRZ/yyOOnGwT/58KdJhJgOx33OktKq69LheGjj4NPs2LyqRkTKWbWWSqvV2Ax0u64z9yzZvUSEqs3zvN1uzW2/27X8BnMrpbSxT845gud5Zv5S083DW8vywd68DT3iPh8CEZHuKzJ6WN8OhyBEd7ufzQAiBiFQi19kRMy5l8RM1MzJ+3EY16tq4QYijJwciJmgtqt1dD1VtPc7iM2e5263c/N5nm9fvvjt3/qW64JhYc5t3ZwpSdcK4XYxtVZOAzEBQIQB0Cnwiwg8AhENkAIj0A3d8b5ujngdzH3GL4AzRZ7x30J8+WMEeKNaI4BwQIT5OC1lmqfDsiyM2GJeSi21qldlJEYotUbii/XqYrPNkobVCADzfDxO02a9OR53RJwz1yrLskQEEaWcVnl1d3eXJBGRVlUoAH487tu58nRkNgtz9KAA9ACPaJ4UENVMta5W67kWXni9WqvpsizNpyfMaq2EJEmsKg2D1XBTyJkQIZyJmAQQOXXjOLYVxtwNaroaV9W1qFdz6eHeWx2m40IkfT+UomaGxBFqgYf9vu8HnXy1GpiFGMt8LPP02Uc/XnUypg4QPGDeHy27XOScemBqM+0IjIi28ginlmbTyTMgepCBsQcGsIbOSymlG87v7reA80084xdHCy9FAijL+z/63u2rlwx1tRq6JNNhV+dlXuZpOp68FEMBICKePn16PM7vvfeeA5gpAHRd9+rVy9V63fe9mtVSWsXXdV0tNSLa2p/NJknUWFXbvg0hMXMbyLSw2fYU4dEceOBkPsZmakampqZNHFOxoqG7NnNJD7eqOafwABFunUIMv9/MISIk4pwQ0d2YULoMnizQgRwJgrwl1BABYQSoWwpCcABq5/1aKyKrOgDM08zMQkBevdhxWVJKgMDC0jTkAIh8OsPfCzO9NXTBASU8HspFRDI9BVGEaWgBGL/2fxH/AHGmyDP+W7jfA3n98YNnIQJ4gNUPP/jxt7/95zc3L662PQmfcgR1BoD1el1rZSFSFtFpqcM4iNDhsJtfvSSicbVaETFLEgGA/W7XDpcizCwUMM9zSumw3wNASsksLctyP4RpB+pwP0VyAwBiADohMTGRMxMAlFIBIJGkkoRFTe8NgczMmFlETNXNPQLd4pQ1gwRAwgCAzMjEnALBPdR9KQos4U6SmQRZmImZHSiQLMLMmFLbOgwzdyxFh17MDMCJaeiGVfeuTXfkZnWZ52M3rnLObXvdwxnAkRBYOL8xciKAk0laAzOZeQQQSzi05cvOFPn8Bv9lcY4AOuNvh5+JuAcAcADVcnz/h9/9D//u3zz7/JOhz9v1Zuz6CB83Y5KEGKeWoKl7beWeqZVS5nm+uLi4uLgkxJubm3meWutQUuq6jpmYpeu6Uss0T13XpZwBQJhb57FxW61VTdvHHqEPOTmvzXia/QOaqba0Q7WIcHOtWkqxN77ktOHz5QkPECIS3htDAiGRAND+OL28vZtLXaoiC1AK5EAGFqCTSaXbadG7mTwSorsTc7gj4pC76XBYlqX59SLisiwA0OzZISgcAagRoru1s/bDpZ4u2C3CPaLZm7dtIoJwra1CPzcif0mcf8mc8bfDl6rICK9mZT4e/vIv/vO3/+zP0IuWY/AQ5n3Ky/Fg6iwMmFWVWZidmIm559RiDET4uD88fPtuyBgwHQ6bzaYURZKcstbKzKvVqpQiLErKwlx5HEZEnKZpWVyrpcQPTj8egYRd17kZkpMHMbgHMxGFux6OuwArpWw2GyKa5yIiRDTPszBN09R2sUstzJIoQZB6EPNStNTdu8NogXe74zQt6l4cc879mgIJOVWLzKkuSyAJ08vbV5eX15wQApalmrubt7WisFrDRJKA6qy1FkZYrVdWFzdPKY/jMC3VzTkJEjXZY+NNFAJ3wNf7n+HhBPfeFgZI5b5ZccYviTNFnvG3QptF3B86IkIPu1f/4d//2z//9/82Ma6GPqxoQauLovhJlXgvT7yfKTORxcnDRhUAQpglpbbV9+LFi3Ec53lmTk2d4/YlEU9bzSYiSdJF16pIM3vo0xGiuTcTHSQkIGYOB0jJ3IlaDg7tdrvNZvPq1avVavUw7QEA9GCBprPU+2/ozA9lJhMBSrgiYk5Zl2Jmpeg8zxdXj0hSKWVaSq0GYKp2PE45HbquA4BSa3hUrbggADAEhLnWAG2/dxAp5xQRSbou5VMd6kYRGBSO4QEYiBht94YQ740t2n4706m+DrCfjb094xfFmSLP+DL+2/pHB8Dd7u4//qc//e5f/LnbMYLmaWbyqpO7AggzuTMxQxgTTzq3hRkWSZJyyo0BEZrThTTvstZzVNWry+tWAbVT6gNSStLStQBaFEyjyFqr++u1PCZqRIkYzOz3nyRu2Q2YUtrv9yJSaxWRRrLQgmEUGktS24lGIjMxAADHCICqdVmWZVlOJF691nm3212/64kJOZm5qZs7uh33e5G83mwQsZTCRG2B2s3W4/D6lj/INtuqOFF4tAO4ufOXVTsR0TSkKWUkrKUZkqPHqTn58GA8F5FvA2eKPONvhTet/l8++/jf/Zt/9cH7P1h2Nxw+7W9ZpOuyKyzLkhI1Q1tTDwM1dT95gDPROK4eZIyI3CwUG8c143Fmrlobl/2Mpq99UkSYSKsyc9d1jVsj4l7xeEKTNwKACKue/pLvsSwLIq7Xa1V9WMYxVccWbQhujujm1qY6Zk6E5jYdp+N0nKYppS6zqHstZWZZprkfVykJMC9LdfcwraXqUvx+zn5a0zZzQEmCjo5BgFUXh9M2THgARZDXWiWN7Qvjy43gcOeU2raPPSTTRgCgmz84bpzxVnCmyDPu8V/XPwYAAxhEWNy9fPr+d7774uMPy6vnXKZS5ywJAKb90ayZ6Iw5Zy0zBgDiPM/DMNZamBMxJ0kR4e5mzoQiKQgBIOfs7o5w/eh6vz+u12sNq2Z9ykEhfDJGU1MikdR5YAK4NwEa5nk2M+CTykeYFaDvOwAopdRlvx5XEcFJcs7H/WEYhqYWepNQzJ0Ql2XCijiumu+ks8zzhEhURISnw2TqKXUnMWZEn9P+9q5M8/5u1w0rn2tETMdjWSZwv7u7uZ6u+r6fjsd8cdl1XZgjYp2X9XokTL4c0zjWBY/7OyJwN59gIG4B3MRCRCzcD6uq1SNYuOtXTYru3hZroP0+8LAI83sRZUS0zfM3fpRO5wnt3xFnijzjv42WJYVaXzx/9pMffu973/7zZ599NO1vw5fcp4hoE+quG9yslDrPUzMcI+a+7wXF3Vry9QM/tm28h9ZhKy1TTi9evkjSHQ8HADBTzF3bFwQAvR/RIqKpnU7r9+Vh0+5YswEXgXvjspTSOI7tAe28nVJqBenrM+n9+LtJzsGilOJ+L45ETkIAoGqq1p5OVetS3L1yPR73u7ub4zI9eec31xeXt7e3Ye7ViLkfB606z/O4WrmbpLTaDCJCeAqdycMAiuAGzA/ltrvnRHbyKs9M7G58imFkAHgI10HCJpT80nDm9TrmOS32l8WZIs+4x39F/9gKSbJ48fzZj/7qOx/8+K9u717UsribYCrFELXWWmslkhYMgEjYQl/rnFLy6u6uphLBJGbeuMDDVJ2cmkEkIqJHmeb1o/F4PKaUsnBESBIKgjcoEgDatnbLjNWqLdPmNLRhTkla0EuT9TROjPvIgnEcG1M3cm+GZiklr82jEaB5jxs6ubtrrc2JUrWWOg99z4hhLR5CXWOZ5vmwY9OyTMuUmLlJkYQxpwwApZRhGCKibQ09urjcrEazUstsajl1OSxPGZgonO47kmbAzE1rqWZd7ujLhph/0w/z3Ih8SzhT5BlfBp4WCh9A4ADw6uXTn/zwez/+8V8++/Sj4+5mPty5KiSZy9TCVJlpmiatlVn6nsNqznmaDmpq1R90fC3jsHX3cs6q5h4pJS1Lzt18PHZd10q/ZhcEAehBiH6qnk5X1pxrzWvOeb/fk52G2tAmM8REXE1rre27vfkSc84t/KvpzeNhf4YZCSl+dpKuau5GJKrWssaYBbGKcLM2h7Dnz77YPnq8LFPXj6nLQODkqe/a0wUAIQ6r1TgMajaVJcK260236Vyr28ypy/1AGHVekFov1YkSn0ySqCyVSSQlO3H4X4P7w/X9b5Ff+t/CGXCmyDN+HhGg1doystWp1Pmwu/vBX3732acfvXz62fFwazYTw2pYNe+JaT7WWgBg6Mbd3d311aUkMbP9fm9uZvbgHeERViozrVZr1UpEAAYAZt51nauiW6kFw0UYIsq89H0P3jIHvJNUa2WgIXcGUUoBIDPtuq75igPAOAw5ZwCotTIFgXergYlrrYiiphC6LC1AERHxYr3puk5NBYn7HBHutZlomPu020XA9eVj8CDwoUvgAR4s0WcpMxi4u4mg6xI2a5lJHBHX69UeDJHcg1Nmkap6kVK/3arqNE0QcJiPfd93khDctfZ9jwFw7+1m7ikzIjGLR/T9YBCZhARLqX5qLwb6qThug3JzRwSRdBb9vC2cKfKMnwNDOg2dTa1+/vmn3//uXyyHu5tXX2g5upbpcARXeGOBr2mzu66bjpO59dy3OggAEDHlVAqo1VJKkjwMq3meatVxHFq9Y6au7fFO0I7hLet1WfVX0zSlJMthqfp6EwYACJGJU0qm0EbbEeHajvABALUqEbWSsMkkBVryDDXLHAAgb01JQsK+77XWUlXVTk63iDnLskzDsKq1Dn3v91uPACCSalURWPU9MhAGRA1T6bEbO4C1uUPQPM+Prq+TiJqp6mq1Gvo+zGutTdEoScBFCy3L1JRJOWdOnQWoG2glwG7giCiqKUkQQhtzA8CDw+79xPxhQO8RHAEeQPhzm1Fn/G1xpsgzTnjTvAcAzIrr8uFHP/7xD77/+acflsPN3Yvn0zTt73ZmNQtprbmT47GolfZ+3e/277333tAP0zS18QsTu38pdCXnfDgcay3r9cZKJWYAd7XZjYna+zxMKcQDtdR5OQKcWnilzgCAICf5NJIkQcQIY+d2QtdSalWtFQBqKSnndpTOORueYhualrshDFpsDrOcNrqNmb1ZbzCbSOpylxKXUtQqMT0MQ/ohlzqD4mazXsqBIdDVrHRdkk6GLk3Hpe/H/X4y9YuLzb3oJ1LuaymhFSIIkQgpZUu5LrNWbb1R5sSYiDsgPI22IEJrSiLCtZ7u6kMJGR4iYu7h4aqRLEIhAiLgTJC/BM4UecbPwgHKfDzu7774/OOPP/rJiy8+13na372cDncRGGHgkVIK05Sy6k37KkRa5mWz2VStzVbiQaJYSo1wJuq6blmWWnW9XrX6MzMjYmvw2X08NAConVQsz549u350vdvtx3Fs6Qv3vrEnoSUmVCMmFpGu69CjlGruTFS1dl1XXAGgw67Ngk2NhePBQTKAiIOCEJslZUpZhEVSa5gy0+Xl5TzPzUd9GDsAaH4ZTCQshNgPXdUZCdwVVTthDwwS5hyO7777rqkfD4erR4+ahnxZlmYWJyzEZKY5px5HCH3xxQ2G1ZRZYLVZA6YgDKCIaJVvrcpZEBEioNXLHuBBbfkHAE6GkicEwlkl+cvgTJFnnNDeXkUrCyH4cb9b9jubJrYaddZpmY67Za4iIoIAjky7413LLyDhUspqtZIkpZScMwCVUtpgF+4HNfM8L0sdx1XL/EskAIDIiG7qLBLhporgGCaSOmEDfPnqJQQdj0cMyCntj4f1el2PioQpZyaepoOHD8OQJLla13URXkrdbDYAwE4RDmGMaOCA3viOidVUUgKAFvcKGpvNZr+/HYZNrRUZ+1VGRKK4utpOU1mtxohTSM6yLKv12A/ZVJPIu++9W7SCB4TdvXi+ubhMuScSyWOSHBG16m63E5acu5QZAACFCJpkR2sN8zfmLQQAFkiMiIynYAupZtUUqjORh7uZm+kyA0BKab+7FRYECG82RwmIMM5jm18KZ4o84004Yxz3dzfPnn76ycdffPzTaX8z7+7KYa9l7vtBWOy1L44BwPE4jeMgwiJDljwOoyQys2maSim1VgCvRaEZ/rgTsbtFMCKycHgEBmLbqUOtOs3z0DV5ebXAaq3FRofDcnV1eTgcifk4Te6BgeFhZG9KAtsWtrBg1zKvXATCyVRBhJAcHVsqA7aalB52E5uOkllY2N2YRQSJeJrnVgDmnG9ubwGARVYpMcHFxcVut1uWZVwNBEwBVuoxdu6+3l5KHgWJpQV2Mym1aTsAEAZhu8LgADwlSNaUOCVOSVJK7gbOCAiBAEbChEiI8zRRszsyc9emhYIIRnArRAyA1PzS4bVu/Hze/sVwpsgzHuAAMM3Hzz/95NMPP3j+xefluNP5WLWoWdd1VGmep2VZVuOqlFL1gfiaaIaur6/HcUSK4/FYa1XVCAdwEXZ3NSul5Ny7u6p1XZdzNlWtRsRuhkgtGkzViMgDCHk6TiyCyG5urqqLI0AQeHiEtfW8AAqgAAQQQXcmyk192WTq7uauboZtaw+pjX1SSjnL6XMoQ+5qrTnnnCXCkkjXdSnRNM93dzcAMIz90GckIIKuy3w/0xnGsesGZQ2kZVkGycuy4GG/ZjGryRNzQiLu+zYbigiMQAZ0BHCkCAtXK3V58+cRpo58H1ur4MxMSGhVEZyQzNVKNS0AgMzgAegQfhb8vEWcKfKMN+FWy+2rF7ubV67VtSAFQ+gyl1qm6WBqfT+oaSsSialpmyPC7JRlqLW2xb7GO0ixv92LpNU49n1/PEyqxhxEmCSZaitLm36IiVKSWgszhRoiOpguRkQ59zc3N0QEAUOfjtPkDmaqbRyEHmAAllJCJDNWtVorgEJzAEIwUwLAiJS51hoBlLAlixEReuTMpcws3C4sJcodN9ONxLzdbo/zvFqvm7ooItyj7/O4WhFRSkJE1cJqpQBB8mrLNCNkIskZwrHrh2aHHmHoARjhbmok0RoRprqoARtXJV4kM0YFSIAY7gAdIQkjCzK0sbzcTcdmmuThSEgOAGFY/VRZx0P5iGcN0C+EM0WecYKZutaXz57vbm7LMpVlqmWxOtVakBDcwI0w0LWWmhilzx7hyE37cnFxcXm5bSfHiNNCy253U5dyeXlZqwYYqPZ936axZr4/7B+ePeeMSBGBSA6g7hFm7hSgqt5CIABmrYi0HA/DMMzLHO7zcmxJW2HICMyJAA0QA6wuAU4EnBJiLqWIyOFw6JKAG0BgGEMgGLgBUpjmRMLMGOtxQAohDNcuiRCW6ShMrqXPoqqH3e0wDJb4crMGAJR0fb3dHaZlqaWUblxxSrWUfvQIQwpJgm4IQEBA4PcbgzkntwURx3Fkxrubl8QsgsIevhBwW6xeajERq8vsSogIYTUirBOeltnd1aLve4gIcwCM08j71IKgs0jyF8WZIs8AdyeiWvX25tUXn39yd/tqOR6sLg//1VoaUeacmUjN3MBcW0j14bDPOf/e7/1uP/S1VrXSFleWZUGkzXojJCKy290iPtgrQFtYbj7b0nXmDm4ep51oRIwAQnQzpIAgD3UP1dKuuUV0EbFVZUIQap4OKYk7VjdTE+b2XMJs7s1ViJnf3KhhkYfNaAAQFhZEChFhppyFiMKaAZBjBDADuAgNY9c+2Q855zwtlZm3261bBPFcln4cHChnrrrEZMOwkmYM7ifNUJi2PK8GZh6GIeJyWaamik8dhRVCJKL1uNofD33fgweQWzStuIdXYnB3AETw5l8BQVW1xZwBnTuQvxTOFPnrije6981z+7NPPvnkow9vXr2YDztVda1mxdRUrR3l2p6yuwlz9aYaVzPo+/69977x+PFjAmwpW42MiKjruq5Lrr4sy7hazdP0sAuYms0tMwBU1fDwlnzwZZhXptQ+yCmbgTZ/MjVXlYxM4G6kEAwAWFX9VLWR++mft6QEtZqd5jMtEjul1Pd9SrQstV0PoKeUmAnAAxQxMXNKHNa0hx7hDITgSdJmNSxLQXDw6HOn6rXWflyBEKcu993N3S73QykVEYHAtSjjfVgugIe5ZmY1Aw8hBAjhtNpcoEhdJnMVUycK53Bh8PU47Ha7cTVaNQBwr26upnga+8ApD9IjIHQpqvpm4M25QfmL4UyRZ8CyLC+fP336+Wd3N8/rcjDXxLTUqmphJbSY1ZSFiWrVUgoRI1l4mPt6vU1JvvWtbyGiVWt+hV3XlVKYUSRVrXWuKeUAG8ZRq51MfVI63O3G1QoApuOxqjZFdxuvNKNyc48IYoAgc2uLhliroWGABLcQBXVr5mBmTugGQcTM4u6t5hRhM0VsnUfKOQtzynm1WuG934OkhAEi3KYpWhWRAgyBJYm5mzp4EAMGCNFqGIVYVa0uuhQRWuqcNasHhQfyZrM6LuWwu11fbFmo1Ik4DJmFGShC0QMY5uOhzxwogOAIkvMIoMyupqoeQRFgFYLVoes6q+pmrQvhbvM855Sb0tPN2q8cJFSb48ui/TN+MZwp8tcREYHRwk8QABijLIcyvVzmu+N+b3WxWtRKrXMm6PoEOPS501p3da9LPS537fsIM2Ks1uNmu3JXR3SEIJzLUssMAKUWM2PGtvgcEQAkItD2sscRCM0gSIax77rucNyb+ziOx/1dSkwBeRjdLcARIVytLhgxH/dd1yFR1QWRpO2fhLtBgcrMgLRar/bHue/71kYYBjRXFur6BOAsBOhVl5xyP3TMTBhEGGHEDOF9zsQU6jVmlGSmq3Hlqvv9oe97xnj14tnV1SNws7pombkfBKOUWboeMVpEQie83gyIZnUSkWWZhJNQh4Lzfk4sy3Ts0r3eGwkCVUPugxmmaarV5nkWZkc/WbCf1JNeSr24uChlcVdCaoMsN2MRx6jL4dWrz9/bXEIY4tkP7RfHmSJ/HYGADzu+VpdXL56/ePrF3d1NXQ61Lm5V64JuQ5eX6bBMRwDfLbta6nE6LmX50gJfxG9/61st37V5KbbeWd/3EeGuqgpvBAq6472Y3NsONQQwUUSoWUQwESMm6QC8GZjFfbCfqTZZZdd1iFRqSSLr9ep4XNzB3QBaaAGd5D6qSNj3AxHN8zFJSpLcnJvAkFqoK4zD+vb2VlLKubv3kGz5he5Ywbnp4cu8jOOQc0lJMIAhDrvbnDMRHo676806dRkRLcJcocVIDB26EgkBRFhAqAHW4EqMGGHNRal5xyEiUUIiJEIMRBpWnDRyrdWtzbhci7vXWoeh77pkVrquU61NJBBwyjijAARf5uM8H/rh8mv8l/UPEGeK/PXDKcP+lElfymxeD8d9W30RQnciSRbepYRhBBFgdV5UVUT6vtc3ImWurx9dXT2C5m+m2sYg3Ix6ItyRmcs0n4gHsSmEmgdaE9xABAufMrkQ+36A0OY1KSJVFzdv6QilQFvCG1erZVnYmuT7SyXSfYkaqtpGMTknMxdhpF74pAlvGduSEoBLSi2B9tSkJIjA5mHRhOURxoLuFbHvupSzYARSmBU1GPoe3cOXzfqyGlbzXjoND3AwRRI88aAQUTOgsDBqSzQAAEDCSALESEJEiBQY0YwvGXLf1VqXMtWqgG5WzPQ4Wd/3UYkpkfBiXuaFiSBnikAE9CjTsS7TMF407/HX0edn/F1wpshfU0QEQpgVt/rxT99/+fypLoW5mTQAMpXQu7ubxJhSWhaNiFprkwT2uXuwmbl+/HhcjYT49OlTka5RJCGGe0S0ZW0Web0AE2RWW+GTc5uNACrlnMIjch5W43TYswBUYE7TPJ9cGtwNIqW++VCYqgwDAEzT8fSNPQCgWee2x6/64TBPRDxPMxImSTmnUupJC8kkLEuZtNb1ej0fj8TMRIjIctqeFsLmy9uagGrWDzkivNowjO4nGw5JaTlOm/UFIVgtWRK6swhwWwB0DKKAnDt1R7zvG97fFCJBFCZGZAgEoLZ/HtAKQhShQACc3SslysS73R4xhr6v6oRM1FIrDJeCHtQBgGOALZMuB+m2gOf1ml8QZ4r8NYWGJSCry+effnjz6nlYRQJGIiDw0EaFfe9aPJyYECNnEeoBoJqVUo7HoyR5/Pixu+/2+5SzaW3nbEk4HxetCgCSBKGNv72doxdzAOi6rk11EGm73Ub48XBcjesIY+bqFQjnsjQP8y5nYubWORWPCBZpSYe1FABMSVp+ixC4RZfE1SCZEIRVwoCALqcud7Shw2G/2Wybq+52vS6lrld5uLzCIK21y0nNEECQc2aRlHnwCOp7AGg72rnvkIhYcs5EJNJF4G5/uxo349AxQc69RQQhtGyZCDdNEUJkAQBAyIBOlInJAgnAADFQWNoSJSAS80kOCtCtM5ZkEHp0YR6GTnWpBYQzIIx956qmZrUQuHQCHmU+zru7q0fvnNgR4awB+gVwpshfX9Rl+vyLz7747NOyHNxbqgEt8zE8kClFsjo/PLgdPFuBVrW6e8rp0dWjRnNtQ8bd+z4D+OF4fPOJiLh5dqla1cpMzPkhhjDnnHPa7w/DMBDzslRmMmNmMVM+rTWzMMupQgSPSJKIiax1KoOIiZSIVC0ivB3ONQlSk162K1dVMx3HsR2i1+s1gDt7C6rVRQGARbquM9c2/iZEgHYRhBQASZCaqkkSmyoRDX1fitalLDivt+tAJAhJCZmB2BEciCSdlJhIHkEna4p2rGZEptZtOD1R02ECAZ3cc61aIEnOvVudOEssERGt6K+1MiM6LLVWdV4SJhGAshz2ty/Wj1eABBAADsHnWvLvhDNF/pqCEHeHw92rly9ePA0rZlWSRETXj1rmZVp8+dK+sLAg4amNaN7Os+NqNNW23OLmzELEVdVU6d6Bi5CQqOXwMWEKifs4MGbJObdRDxPlnNUsJbHqLCzO7iZJ7lmSEOjeLfdLSJJYxEyZpZEjACBS1TIOw+1+1w89IrhrKRoROffMCAhEQJwAQJIkSRTU0qv7oTcwAGBARAxkZGJJxMBEcn89AABU+9xJymHAgIBu5pzR3Rmp9TsDwJGQBVtFiUQAENRyF1rzEYiZ08lQMk6hhRhkAAjoCA4SEIGJxMENJCgAPBARAmqpKaeqhoTuteoiIiCiZd7dvFpdvotJzsfsXwxnivy1BLrWcnv34m53k7LUuRJRIKi5FQsDJqGU6lJef0VLVvBo59mUUrMUQ0RhXgDcbRjGqlVrJWa4NwTy8BYMCwrmVpYl55xzbp46OScALKVKOiUprlb9sRYmMmIiBieiNjwhbGHRp+gbbcNxrTWPvTAziwgDcBNsNs0gMS3L0g/9yV7sdDCHvu8BYJ7ndsZvJJula1N198hdf3JddI9wwkQk7VkIkUVaBCFJBiLiLjg4UUoJiNRDqzlpYpZwRGk3IsJbSRjQBOQIQeHoBOQY9LPc3xq+3hIiEyESRDiiuocBJw5TxABEtdrhgGhE2vqw7p6JAnx/uJsO+3GbARDwrB7/O+NMkb9OiNOBE1Bf3Xz+8sWn+8PdNE1DTlXrPFeAJk6uGuaGfd9bxRA2K4fdbS0lIoZhuNvvl2VZr9dd12VJx/3BzYauL7W4mTkgMjBnyQ+bwUzs6FpVWFr4dd/3qjZNEwCIJGY0s5RoWRZEdjMiEQ6H2oYYy1LvTdIQghA5PABjGAZicLCcxex0UmagqtH3/eFwvNxuu5RLKQAozNz3ALQsFRE3mwsiXo09IkFQIGwvL1rmoFk0b7Q8DIfDQZCBWB1SlwgJT3UkAwsTBXOXxghXcyQi5r7LRIxMHvcbPcgtsNURsc1kgrwdt5GDGJAB8X6Ec8rW8fvKzzQgnFCIIfWiNLuW8KJlBoC+Hz2g78cILzUQkYAjAhAJdH/zbNxsARMgwc/V4Gf8zThT5K8ZEMO91jId9sf9zmoBgP1+z8J931tVV/NqXtXdVUuYhdXjdCylAgAzuXvLO22OOLXWtnEIAG5tRIFwsvlp43GwUh1PWYNd3z+YfjOT2SnA+s1rPB4OKeeTD/l9G1GE78XT0L4cCH7m8Ij3+bEAwE6OwNyUkujmEUEoHrEax4jYbDZt31FVmRgEUtdBUykSrofxeDj265WwjMjoCEDd0Fdz5iAHjECSRMI5PexNElBE2+9mJvLTnRA+xXYLQJuXkAPfUyc5nmYoce+m/jP8CADLsoB7mIK5ENRqVs1dCeghDzZOWY9uEEwUHkiBwV4XWCbo/7YBs2e8iTNF/johogWhzPM8HY/7/b6JeFLqELFlYYc5A3ZdR8DHQ/HAea4tCkZSopZByCe2ame6xo/Lsnic8ryaDvqNpw0WRkIPx8QpsVZVUwRoqkb88ph1u92a+/G401pTJ2oOAIk5CMIjEBxPOdE/vzfSpJIA4MTEDoDEwEKSOTyIQSjdO8y2Cpe1qrNLEmEBABAiInVYbS9KKblLY+6tGiIiZwQF4lMVmQU5EzJgm74gIzoCEyFKIAYCIgJxIAMiIXsbLAMh4L2r7ukWecSDghx/Lkth6PvwAK+hXpaJEBUhAgEpECAIAQzcETgn/vI6dillOh6HfgtucN60+TviTJG/RogIBAwPXcoyzbVqG7boUsysTXizSJ2XZTqWpYikuRQAYBaryzgMGEBEpSm/PWqtRNQCWhFRzYhJiKBZq92HBYpwkoSETKyqxBQR8zSvhoEpkPBBzNiuM+Ws00TEF5cXy7KYLgCt1GSP8uYrQqQ2K4fXQVcnmgYAJnJzJiLE1TjWqshETNNx7vt+v9+v12uRpKYUJ6bGJnwCWJYFmfpx2O+ny8vLbr2KcFXLqW/j9TadBmJvSqnAIGIRwNbPIGwfIQIQAAWiYztcn15NY0QACHcACKLmhYv35WTE6ZfHqcpmDOBgEOHgDOgKEVYQT9tSD7YkwuKNJT0cVeuylGlwhSCQM0X+3XBu3/6awE9NMHNXe/78eWsCEvM0TX3fr1arcTVKklrV3JFQUlKtzVgbAK4fP2aWealFHYAQuO9HAGr7cBFhZsTU5h5to65tZDMJBM1zmY5LrWZmy7KoakrJ3Rs/vrkh03VdIEjO3TA60LQsyOJIu90RCKuFBW7WWwsESkCY+i6nHoKa7QUFhDkjhVliaUxWa5WUUhJGzJJWQxeuGLZMMyNuVuux77GZX3KGoKrRjysAssDt5UUgzUtVB5IUxAFkgQYIyBbogY7kSIHkJ/tzCnz4rzUZOZAdxJEaY54ej+AIxNxknvQGYzY0PXzzzlRVVTU1Iq5VVc3diJolMAN602wCgNkpL+hepKWH3QHMIOWv91/dPwScq8hfJxDaUl+8eHHPa9513WocXc3DH3KmXM3U3DTnTkukJO6pKWkkpXYehIcVxoi2kX1zc7Met8uyXK4uVO3u7k7kdADvc/eGyxmBQ1BgoJkTYrM4vN9Q/Nnf2cM4ulmttdrJt8bd5rKICCICeHio17ZzrWbEfArJQez7/kTf7lprC5CBFualZqbu1rIMT72/tpUDJ4ehvu+D8DiXcVw7mtYCAKvV+v7XBjlis+cBAGpz6i9fvwMhUrSmZCtHggDAIdy9HfQRsWvrj/fuluHeWJKTvD5xE5gjgANiWABQOCJKTgzopczLMmdJp/1FpxYNGxEQ0aT7bnYuiH4BnCnyHzhaQdLeG642z/PhcPfs2RdI1HUdmJu7MIOBhrZlQQQIIwh2rXAyWaBSShtEIGILommVYylls9m8fPmSmY+HQ4uJqVpzTsTctrZbs/IEPJVIiFjnJe5Xs6Gdi+/nFQ8P5yTm5gg556ksDk7NHzcJIoF7RJQ6dV0nyFWR6KRtfEjsas+nZsJMhG6euo5ZqpKpV1VETK192SJuIMLqfr9nlmE1curMHQiZu4hopWK7owSEgY0HHRFPf3X/QgGBMJCBGJrn2v0KoD/8TIL+Brmimb/ZpXWzMEePU2z2l39XtfVtgEytlYmvNURm1n4Z0DnW5u+OM0X+moDaQdsjhmF01d3+ZuiYUkLVkwIZAFpOABJDuMGxToEAhDmnY5kBoIkPj8eju4dHKYWI9vu9qjLzUsqTJ09yyqa62m6naTKAYRhaCdlKJL4/U2Pg4s5MHoH3R8uH9KuHDmOjYybOubu5edl1XR4zs2RmVYtT/KzlFKe23X1bExHtlIstiKmq3p87T83KnLJiNSvMOdwRyc1DAiPcfT2szbTUkruu7Qi2CldVEYnZiQioTWlO45f2wgKhbWEDIgIi4gMP+msrCbxfBhcAaPnd7Sa8Odx3N9cHeWk8jGuSPDBjlFJTJhbJnq1WdwdwJA98zYatrG4V5Vk//nfFmSL/wcK//DEBIBNR7Pav3Eufxd2axhraeZmpiWNOX+LNo5spZy2+ubwyVatqZsNqtIjb29u1WzEFgGq6Px4eXV8vy9L8GUup7QAO900xbzYTwEwEYe4+rDalFEB0wMYpAI1jAogQYei64/5uu97M83x3d9fnYTWOqpZTggDEdmCPcRgAAICGbgQSZBlW63mal7kSCgEysYNhtPEvllJEuO00ukeEwSlmMFxLEFGAWkmSW0S15H673i61sMiyLBHqkImQhA2QAq35ubWCkTCC2qiGmICa5rEFbAHck2DLRWtr5n4yXwJE9Dc6GADwhpwIvHnwCs7TEdCRgiBaUixgeGCgtDL85ycyZj7Pcxq3f83fnfE34kyRv0bQMu9ubw67W4sv+VGf3o1IwOBvWFWnlNzBNSKJLpWYs6SI2B8P03RUU3dv4a6NTN3cET2C7ifLDfhaEX363wa4p4PT4p17YwREZGYGBgBibu3CnFKWZOY559V6fTweuE2KAx6cw5FbIcl2T/SttGzlZNvdJmIkVDUAYJb2jG6uViW1lcgMI07LEuZBBKZWF7MiRB6eRCLC2+J26tol3qvDKQgRmuPlQ7X2uoJ+02cT2lA7gu6v/ss35JTHFT+/bgnQD727umJdZgIw04dfiA/PG+HQIn8AANisqFXAFptzPmv/HXCmyH+wOPUf3/h4Wabd/na3vyUMB8e/5t33X0WbvbRyp5RaSiXEaZ7dvbnSNGm3ObK541+TQvM3oHHoA0dEeLrfR+z7/ubVKzPbbrdhPs9zkxkxi7e2JlrY61fSonXams0DX7TTt5mpekqns+zJAJjaZQcZLJNpKd73nFISilC8Z5NlmofVKkxZmm9uk/IAM5EkYML78owIibi1X/9agnt4yQ+/Od68Vz8/sPp53Ly6YaHESIRhoWqtw4vUgmssACMw3ME9EAD4wcjujL8rzhT5DxzU3qgYAL67uznsXrmrENX4b6+i1VrNTmnafdepWl2WWus0HRFRUjoejuZ+GrawmDt5uJsHYcQblRQAQIuQvm81vp5iN7xZQzG1BMQwNy1LPwxt65gRU0oist/vx2E4sYwhBCBFKwzb1NrtvntwcrgBuD/vmyowiXAzZ4uINuZ2dyAG8GWZoC6PnlwvSwVTYEEn1RKe7zdfiDmZxWnbh5yY3qwQ23ZjzpmZ53l+eF2NpJqyXVq6Waum/+u0+FBZv4lhHCIMw1tmz2kO/1CtOwA1tdApDhEAzMzsHGXzi+BMkf/wgQGAYEsp8/7m5Yvj4a5LYmZhpzSudhqN+7hSJEwpCY1WSoBh+0cSTdYiFmoG7lHmMgwDANx79iRi1lrNlKteXz8yd1NtkwJhRvK+73Up963JUxAYNHoCWJZT5EPXJUS8u7tz8/Vq02yBajVgYU4Q1HUDUcJwAIUAEVYzgEgiSCcmIuKic0R0LS/BrGVFqCqEElLuUq211jIMAyKGWwQ13pQkzz7/bL25kCQQqsUkg1bllM29qS1bCETXdchiELUWuu8vuvs8z6babD7gvv+IyD+zdOQAjIhvCCEdT+a4rb3Q+gwt8szcrSwYkYXn+Wi1gCsjROgD27Ys8mVZHCRJBwClFMkS5ofDEeLNBvUZfyucKfIfOgIAA6oe93dffPbpdLx1VQ1XNRFGxFJLS39tOGmP3WutBp6k45QRYzoc3FyrabXmcoiIzHSqjO6DGVpRKYTHaWrSFGhbK0jCrLW2M2+rxR7OoYhYSlmv16oKAKra/HoliVe7fzzDGwNfJAQnQjRCx2hKl7ah7MJmyExLuBu2Os79ZArp7icLHwARMTO/j9gGsDYXacflF0+/wHffG4cBmkF7XSQJEzCx5Nz3VNQaLQkRIkd4W1h/YEZE5PYBvRZFPkxjEJHemMy0vyLm8BCAODUHTmGQiCjMlBJ6EME4rpYp5v8/e3+6JEl2pAeiup1ji7tHRFZVA02Z4X3/R7kiI3JlSDYvu5uNRmMt1JZL+GJm5+gyP9Q8MgsNzhAg1pr4pASIyop0d/NFXY/qt9xahAdYeGTvfR8Bv9wFCEtEZFPeWq/yyh7//fA6uP2Bw60BEiB98823X3/95bYtjBFhw1BUu7lO02iuHuZhgB5gAM5EwzD83d/93dPTUxkGVfc7RxoAaHeYJSJe1tUjkNDcW2tJhAQA7d10P9kdDwd3y1/gJF7vAr57vUPMM+m6rsx8uV6IqEjpratpnoUzwuHf4f6HhCQsQy21ipRSSi2VOXNszMzSYiN/19TC4yVQW1VT57PfFO6m6BFxOZ/z9OrmaZR5vVzO5/O6Xt19mmcAaH1t6xbWMfzFPFiYSyl5Jqf7xX56yS8X/um/RsSH9x+u10u6FN97R1e11lqmoZVarpdLa41ZDoejmdmdz7Rf3d6Teu9bRNRaEDGtPbZt+UPeQ//vxmsX+cOGuys5bsv18vy+L7fKWLkQ09v373n/2Gxp7AoA7iAiJFJFhEDbsvXWmq5tK1wNFRzFLPtHZtqb0FqzjuwRhrK/qYh2WZ2aPT8/H47HpzdvrKULhhNRLpoTyRYahuF8PpdSAOD5+bnWmh/4NMr5lNO396e7Yg+JgYkze8eM3ZBFSil639u8sJFeulckBAcR2baNmCpVD+X7XTDRm8/ePJ+vagZAEIqh1jcEtL5tK7DI+n6xwFpHqfdwHuuBZNYAIK2Cce9PISJynfJy+997ne4F7vHpUXvftm3btloreBCgiJi7WbteN2s6DqWtS4RVIQPHiBRjo9AeGBkBtFtjDKU0U0L06Na3MMff/WXzit+N1xL5A4YDgNTBbXv//tt333z95vhwu5y/ff/V2rbpMNdhqmVUtd7btm1Fhmmesnty02Xb2nLzAGSa51PfFkIOARIGQmAmEQ1bl1aLrtRdW1cdi1A4hY/D2FobhrnUaqpPT2/Gady2zVoXkWEYlmVJSnN2ebj7p+E0TTmanOcjAAiKmplqLRxgnjsfojTUCYhBBgCIiPlYXXXtPZfKEMBVlstWawGAQOoWFk3VGBmAhOumGwAR7Z+CJId2oywiiHg6ndZ1BeQBBhLFrICBFce+btPhqBpqXW82TVMAiDAyhaNb38xYRIAAIkeEiA4AxBQeHpFVMsWOLz1gbAqAQ6lDqa2t6OHu7R6hXZikSmtNmMFiXdfT8dS1LdcrIl2uF8x8XQxCJMYAul1vJENggPd1uzyFQsgrgfx/Hq8l8geP6Nr+6b/9l/OHb7bL2bUj+FBKleLmq62qNo5jKbWUmjHT5g6m6h6EYOmPCxa7HWv2RMKcwVvbtl0uF3MrJIV2pktEmBqk/4Jqlh7tXXufxvF2u8UeI2MAkHubF5Gi+2+vFD7lx+y5sgCc+a0AAFClmOntdp3nA+md2oLALMMwCHPrLTxSh9N6m+q+fTazrNd35U/Ztq2OQ2t9KKObI0t4cKW0Mqq1AqCa9m1RUkQM4ty/a1uZxDxQHIGBmJHcvbtiGpUBIDoThWMOGdNi7t9fLAAAOoWDq0dkQO7+xJpH+FgkwFrXbVuW5Xw8nSiP0grwyWSTiPdMCMKXEUp4vNqh/V54LZE/YOz04y9/9rOvfvPL5fKWzApzKQOwRIRqBwBhKZUgCBHUunuoGoFnukpgAcewNF+g/KhnrIKa9daaqa9AzNNpqMLpOFFq0UzmQkx1HRNt25Z+lL33UkqtdVkWRBSRnAlmL/k7rwQJw+JlnPdbfMPe++FwAPB1XV+4TBggwtM0EWLXXmplpvTruAsRAwBUXVjMWu+pu0TvqqpxAA2HrrXiers+PDyI0Lqu03SwroobsG3b9vj4Bgn72qQIkAdRGCMXIgABCAr6uEZGxAhE34N9fkcKDwDDXjcNPcwiLMxfSmSuboDLC6fVVZ/fvXt4eLgtC0Uaqflvrc4Rfy8K7Cu+h9cS+QPHu2+//uUvfno7f1cFqnzs1MwsEMZxPByP7ta1haMI324bE9XCREJEqi0DTR2Idh1jxgAELMu2bWUcst4wSynirikHNjUZBBGt92me12XNPIZ7LwbX6zWZgzkfhDut76VQJkX803KWY0R3y6wxRETicJ+n6XK5MAMiQnDuW/J8OwwDIV5vt3muAIAtrHzvPb+ua5GCFOu6Ho5TrfW2XAgpzMPMzRQgwxojYphGdNNtBfBSR5by4d3bWsvp9AhhYRDAGVht4e6ELBT00cX2vs3PhZfcrdo9Au8zysB9X0TuWR/BPKvsXlZd1YwYmGEcymK6bdv5fKa7zDGfot9+H8ReMc399TP/e+H16fqB4FMVzQv6tvzqZ//yq5/+y+kwkHfVJlKR2ALc4HQ8DsPQtpbZgUBkrddahZlxlyQSSve+bZtIwXDg0lTXdenmQGgQbFZqhXvZRWQAW5d1nEY2/vDhwzAMz8/PwzCM49i7ZpVsrR0OB1V96Qpvt9tL5NY0TVk6x3E8f3jOa4kIoOJmiIElHXAZEYuQhddxMHcmYYht29yNWZ7ePLbW2rYdj4d5PmRarBtY78ttQ2QiqrW21o7HeVmWt9+9/fGPf7yuKxO3voKCar9dnj978xlj6esCAPMwvnk8LW1zbUWYCyP45fnDMAxMBYIBrYxThFtYqAJAECPvqyQAMHN3d1VhGYaBhVNs7e6pbGx9dTciFIK2LOnn9vDw0LVbb2Z9MxcCERTB42EcK/eehP2PjKI9ldd9Pj6op3Cbw5JLfpfDv+J/Aq8l8gcLd//1r37x85/8M1NHa0yw9V7LQAzhNA9ipsuye7KqdgSutUYmJex2OPscUEQcsNZ6PX8gEgjK9XEtxdwlws23basyJbNPWBDx/bv38/FBihcRRJRSAMDV0hoWAJKomA/1RYiSPWZ+1LdtY6I8qucGHBGZKCLSMQgz4MWs907M8zSdP7xHxFLrICVbP2KqUPMvipRSfRyG5bbsUbceTDwMQ+/9cmnrugrLOI1gzsLmYGrPz89PTKfTae3bertKHQvzum3gFRiZdmq6u5sLEyMRcUFioIAgcFPrWwRzyakCERELIno4GhJgLq6yS9z9jwOW62K9m2oQPZ/f52tRGPvWlMIMiZFiP7Dj3cM87ULWdS0yqPm6NC4VhRAx/Hc1mK/4v8VrifxB4VOLgvP5/F/+y386P3/DvljfNvVxnNvae3RgqTHVWmsdiGi5bR6YI8H8AOXwy8ORMD0iDWBZbkXkfD4DQNZNKcW2Lf3K1nU9HSYiEiH+d+7/pkrMRBy4T9Ze+NW5tMG7d1nmDmZruW1becmiyZkmM9GuL8yomZwt0t01Bwnlbk7xKZjJRWqtmQvTWmNhYdGuLJw8JEbs6yZEhfFyfa6lDsPw5rPHy4fnbbmVwiLSWuvmXAuLqHYODOhShjQLN2vOYoBcQmplFB7EPSigmUaYewAwC/N9jW5uBhEeHgoe5/OH0MZCVXhbLhh5cAZXYCZmAUHGyN8GAyEAAMSMZbgbUgL0rqmu6dqRpVAhYvt3q7BX/D/itUT+MBFt+/lP/+ndb34JerV+Kyy1DuvarsuN6vD42edDHeo4RcT5fDH1aZ5rKe62e9wCwH04mE3Pcr0CwPl82bYtD3FpWGtmeaxTN4coxBnPsG3b05snDxTmrtpaSzp6kntKKdm45e2nHlFE4L7gzorZWivjlA+gA5gpEUWYu5dSdgULoVvM06Sq5/N5HqoIm/u6bY/Hw7asbt56G6eRmUsRRESPYRiyXU01YfanNfWFCG4+jmN2tQ8PQ4ANY2ltbQ2m6QCmXdswzr13FwfYPcMRmBl9H1YCEfJAt9uCuAdvA4J/XxkfLzbjEe4OoQ+Hebnasl6bW2EURndvbStS1MhczUhEwgPCMkEICV947+EOqY0klDIEetwtQhAxXT7/TG/BHwpeSaQ/QETbvvv6lz/9r//fkS6wXqI1a/1yuV4ul4eHh+PpNA/TMAy38/V6XSNwHEdENHciLkwUewZDDu8gaFla7kw0TGp9fHwEACaZxkNlYcDlthAzs3ARLsO75zMQI5VpHoixr4trE8K2LYFOhQzsfH0264hBBEgxH8ZahQVL4QhblqtqG4ayh2YLT4c5G8wszkSCyFkaTnfl4ul0AkJ1b9prqdfbtZsG4enp0QECgUsZx/H09DjO83w8Pr55AgB3r7Ue5gMS1lpSeE7EeZnm/sXf/d3tehUiBNjaMs1jhAL6cZ4Q3FUJHF0xDNwAnBgi1Exb6/tw0BzMCaBKKcwZAQEAQBgItcowlCrSu27rVdtKEOD6/u13H969DVN0Q/DCOBYZh8LMwzAkY18d1CEcw8PNkcJsnSbJVX5+6+D3ZY7xuzbpr/gf4bWL/OHBIewXP/3Jen17e/8bcBxLva1rLeM0jrXWcT7clpvdFkQepgMRvSgFIxyBpRTt/Xw+j2U/sYowlHq93VRtGIacZxExcZRSuioA9NYu18tnb97crtf8r0jYWu+9Q0T2jKmWcbfwoE80Hm6OhOa7rcb9wcQLX9Jy2phTSOac6CEiEexanTutkkVMVViEuRlk7OJHhw5EQFDtx+NBpKj2N09vlnVBxHEaf1R+1LtGKEs5Hg9pe1GKWNPT6ZQJFkvb1tvl6eFpU0eAwzgBUCrTmRRACKGU6oFurtZQogzVHTyisECAm6kbE7AwOiDh8/m5SGGCwtjV2rbcbpdpqIxhvVnfECIJ+QieZkbEVKhEhPbujuEBiGp9KnUYhtYbS4FP/JOy00fE38k0esX/DV5L5A8KGQz69W++/OlP/vtyvdYyVinW+9PTk3bnUjPaZV236XAiElWl7wuH3Xt2lNlbEZNn9pc2YRZhZmrrlgdkJi612vkMANu2maqanc+Xw2EGAO0dwHtrYQ4A2ehxLTk9NHWgj35obilHdrTvLVtf6OUvDPOsjwBARONYASBzpf0TjYqUggHpnZFqlvzz/RfuGh53nk7jMAxSiIkIQbVHGBGcL+fT8UREp+NpvS2ICNrHcXp4eDhfr9uyWuC12+HwMExj7ujBI8ghaF1XklKHiaRuar33ykNEXJ/Px+OxiIACYoSpI1DsV9HXbbmdBYwJhyLX84exSuubNiYRAidwAKfY9+PChUi8uFu4mlpzAzOSofamLyyfV/wv4rVE/nCQ9RHCf/Wzf72e3/XWxrl07UK8bRtTyVyBy22dDsdCDMzeOo+T3025Ad3MVTsETdPEe3ApsrOb11prGVX7Tk8hZmLXndKYO+XL+dx6G310t94d0BFxnCZ3P51OewMZ8Wk5S+zhKvdZZJbglz9Ml7EskfmQIkL24BdNaqWrrssyzSOLCPO2rBC7SlxBXwInAECkIJJqL0Xc/Xg6Sm493EqRZbmeL8/n8/kwH969fdda///8b//7+/fvSq0srGqnw4FI0ANIkjsvQ90zczwAow41gNQ6hANyGGhsVcrnnz29//DsEafjCQnVHSLCvNYaoUqRebLffvPVPNbleqk0W9/aisM0IhQMJ3BAT9U2ESLWUqR3162ZFYDrujQSYhoByB3jI2ecXvjnf/I34g8LryXyhwWP9vz+61//G4ce5ykjvdZ1UQdhV48gHIYhzLt2cmeh2+V5nmdwRSTvOA7DeduYcRB2896zIAaXYds2KoKuiDiOBxbU3jeEcZ62bSsk29qZaRgGN7vebog4T4PdG0A1JaTlcqu1ZthhEnfMDdLGIjz5N0S0risxIeFxOkXEui6WrHJmJiSRNInopghQpzk8bts6znMRab1H4MPDU1tuABDhTFykPD8/j+NYSjkdT+lnXorMw3S9XZfbTc3efffNYT68ffdtKaU1+9WvvlSN33z5VVtaa40CWPh0PA3DMKfCvQ6ATCSItGzbPM+BrN22bavDVGt1C+A9LjFMLx/ez9PsZs/v347jWMbBTC/XKzO7KxExwe35ua3XD999dZzH5/fvBmFtq2pbrpeHpzezHBni8vweLmcSJmLmwlRYuDAfjz92962rR3QLAszvsaT7AKJb1Fr/RxKmV/xOvJbIHwh24Z3bv/3kX87Pb00XRwvXttwwAFkAnRiJBImQKTNqluV2PB63bSmlcCkAcbleAOB0Om3blqyaxJ5oT8QkQZK70fRiGIbB3MF8WZY3b96YNRDR3sdxREIKlCJurl0jYj7MqUTcuURubh4RpRYAMLXL5ZItp2W+GOJtXYl4W25S64v7713XCAFgumfVIuJ2W4TZ3Nd1XW5XYSnDnuX1xRdfTNNETMvl5m4p0fv666+XdYmwUkpr/bvvfjGMJWO488LzEG2qgcjA27apaWtN5MblTCJcKqIcTsfr9Spc6zRebtt1uRUZxsM0DjNS0kuhMIP1cB+GEmF9XSJiKGKqFHD+8O764f2Hb7+6nN/PY304Hr768terB6AhMyKv6zodjiQVgAKZRIAQgETqNE5SakQwlVLFNADDkQiIgCz2iWQpRZhfeeO/F15L5A8EDAgQ1/fv/+1f/+X6/MF0BXAMY+GBS4qy3Q2AEFPygbfbMp8O7hpgxCXCtq2b2WeffbYs13QkS+AeX8W7w6KIWo9wU2ORAaCrdttaa0QYwIjU2vrw8LBnHuSOxi0iCny82ayP2aXWWrdt69oBIIsdAMzT/Otf/3qaZzebDwdkQiZEinDthohUmJhYmIwA4Ha9Hed527bldiOAWiuz1MrCcrlcIuLrr782NwZyN5EyDMP1fL5db103IsKwUmRd1uPxsKvBaaciIaGQ1FLdHR2To6Pbxu4CxBKX63kcZxBvrR2Pw7q2rbfLs/ahlVKKFGJyIgByc4PdT5eYCUCq3K7Xtm6uXQjR+npr1/NAActyaa2RSCBs2of1hiDjeESmEGYiYCmluGspRfs4DFOBKdLkBzEnHWBATFyLDBXl9SP/++H1+fqBwF0J4qtf/+L87tuC5taaGgsRIwCo6rIsdZwQlaQAdWgwHk7oZuBFqrC03i6X5y+++FFazKqqfN9Y8G79v7uWJSMSIoh5GAZrnRG3bZOy+/0QUTZrqc4mJmG5XW+11iIlq2ZEZKEchmFdVjM7no55KkfEd999Nx8OhHiYZ0SkIo67U2TvKsIexEjn83kap9v1hojbtj0/PwPAw+NjW5cI31bfcHP3y+Xy3du30zjmuqnWMk1zYWZhD2Zm3XSYBnfNiIjc9jizMAPzUOo4ju/evRtxxIqlFAv0iL5t7mUu5XY7Dzo/ff4GAY+nw2yxdTs/X1P3UqQg4TiObn653ObT8Xg8pvp7WZZpGr548/QeWvHD+szLert8eH58Olnf3JyYDYIhwMPB3BVRwMARS9qJ97VrD0cDqEjDMBnkDjvSSTL9ffi1hfz98VoifyAgksu3v/rpP/6n9fmb7fK2tc2ZWQZE/O7923GcRCTLCgYxch0GdHMMAum6PH94xyQPxxMxtL6GIxGFdQRgoIigAEIUYkPd5S4RiDgM9UVvc7stwzAwT7fb9XA8rutaqxAD7txwN+ssfDodrrdr123cmzLD8PdvvyWAcRrGItfrmt0c3j0v8lhtvWUQKwAMwzAMg5nersvD8UBMzMfWW286jnMpTMRMaanrEHi7bYj89z/+8TiOzx/eAQATPT8/E+DDw0OtcrlchmHatu10Oqnquq6Pj4+tASJN87TcliDcepOhlnEgqU37tmkZh3EYS0kPR0GKy+UiQ7VrdHPVmA5HAFBtl+tzKSXCmEsp3NflfVuLFBY+HSYAVwqR8mG9DENxlevtVmqVYZyYzB0cANjNuSSbJ4iAMFpbSxkEhQvz3SnO3dxTQAqBAAERYYHDMAHAa07s74XXEvnDgIPpr3/+03ff/nq9vl8u52kaaBoC6cOHD/M0E9G63ubjiblwKUUEicK1dwjfPDAi0qqntWZqiBwRnxqvIhJTBgdyTgkBgIXdTJjVTESYMx5r1z4Hxa54++hgSLXW6+2aBcXuuX1J4hmGQUpprTHT7XabhlFYPlXM7eLmUpKb2XoDgGmaSikeHhBMLEPmZfXr9Vp5l+sAwPF4AIDW1/P5XEttvW3b9qMf/ej84VlVD4cDAIS5lEJEtVJyLZmt1mLmxCwiEXvKTe7kSdKnCIl4GIq5b9vmy+1weuRSToeZSwVgZFKtUuj5+TkiiPTFPqMUXtdNe5unwXq7nj+4R2sKXJ4eHxBREIlGiWB3zMMyc1LniRiIMCJju4XI1Bw6EAMV4mKAucZHYgcSZC7l1Uz398VrifyB4Otf/fz//w//5dvvvkHtXETD7Xrb+h5SqKZ7iik6gAeYqbmDuqU4Tbgyg7uubQtHFmbHwghBAI4IzBRBzMJswSoiqmmarXveKRERp1671pqZ2uQQERSOlHxnRsRlWSCNctPijBkBaq1SCiFahKqP4ziP021Z6JM4qixPIizC1+uWcdu1ViK6XW9uPs2T951HCbufuCjsgm4pMs3DYT70th7pcLlcW+vDMEzjtKxLrdW7sgiAi2BEMJERjeOIHrWUWktrfZhKKQWRzXwowsJE+7NaCg9TJSrCDLwrHYNAkLCUiOkwR2st7TKZcNuWvi3CxPMUit9983VhLMNIwwiqXAZEpABiAIDbdeWSgvX9fxAxAEQK38fEn74faq3q4GrmQRklJlzr+Od5N/6Q8FoifxAIXy/vl/M7CgfEWmvXhgSH4yFJHtfLlSp11awdZppuWZzcai5MiAHruqYVduExqdiIfichOxIwkQi6AhGxSHiodWFeY/dz9LtCRs0Q0YmkoHYXIRQkppxgikhvvdwNE1lkGAZVtYhSShECgMv1Wkv9tIvMzYm5L+u6LLf5cCi1mvvz83UYBiy4LisBmDkzHI9HVx2GQU3crXe93W6IkZQjc394eNi2LWNi5nkmojWWYRh6W2ut+fhzC+xqRSS/Y7iUUoo7AvRpnCAzcO6hWkEI0Hs4RxCSAei2eR0BwHxPqc14hufz8+eff35+/46YMHxZ18+enr766svr9cplGOfDMJRt25CYBImIuzEzEhEVRAwEh8AAJLzLMYWkcBlEhkw661tHJowIQiAWrsKvhuO/N15L5N82siWJtn7z5S+hXcO6WTdXQHcDtyUiltvy8PCgptEDmbfYmCiNaoJ9oAk9ACJAgZAxpBRGEELXrupMVGpFcMYIDIZ7/CmRgQMQSyXaInrmhUUgIXftTgAApo6EwzBN83C5XJbrbZ6mtqwAQKVkxeR7Atc0z6o6TpP2XgrlvqF3BYAyDmaWq6RSytPDIwBQgKoSU8Z4EVNfN2GZptmaIpKaqfbr9ZqOPqXwtm3EsLatmz0ej03kdkv6ZDDRYZ6frQFQLYO7Pz6+cXcogYhmUMvoCGYBECIlndZwP3rHZupt03BBmecDEE91GIYpHB1hkuP5fJ7HQ4Rp72r09W+++vzzp9Z6t2DEb9+/3bpKHQGgFHagh6fPIzzMe19Px2NXdaA6DvskcV+dJTuSiEhYAsDdrOuyLEACAEEoLz3mJ2nAr/ifxGuJ/BtGtmPu/u0333z75S/77ebWTTWlImlefb2cx3Furan2WqeXv+tm6dztnkkAAgAYiPeAwK4bRLpkl7yvl9DSiMgBnKrl6ibtI8HFfW++4t5XsgiYeniG1biZues9+zBnmm52OZ8fHx9vy1Jr3Y24kcyjbSsiMgsFWFdzY+a4i3NUNSI+5rsCRMQ4jeu6ejfGSPUhE5e5pLs4Irrr8XBU0+fn58fTQyYjpr9v/px/BQAQCTEyNxwAkJDubSMizvMhwtW9m7mbIzBxZRnLVEoRpN62AoBchEtmKizXG6AXKUQ0DEPvuiy3WisPw+Ew11rfvv9AxIFARFtPPjmWYQI3xr0cIgoABCYr/uP5moiChKhwHRA4YI+0ARZEqrV+6pb2iv9JvJbIvzXc3+Se/jEA5vblr37xzde/6dsV1Kx3GvdmISKGUrStwPs5MQdYu6pPBJmy9gFArkMQKDy6djRETP4xEUVvL6nO/hLu6m65Qk1jtMhWLjcJ2WmK1Frbopm40FrLjkeYc8lNezitH0+n3vvxcKi1pgsZIgLEOI4iJeNVt22FOw/JzFKhyMyE/BIKNgzD9XprrT0eT9Y3YRGmnIQCQGbJdg0iggbN194aIqarGyKq5phVkxaafXEVuftBkCPQ3YStt2Zu6m4Qh+ORmAgFCdFDt2a9Exc1lTpKJUJ8fHx0t8v1vCzX8BinMf3eh2E4HI4Axwh/Pl9ZmBE+ZecQMbFkLmNOQt3dIj5dTBPi5XoBLFwGMT89jQGUivTUKY3jCB6vq+zfF68l8m8Q9yqZzrXvv/rqn/7rf9Z1CVO1jggRaVILcHeoPT48rMvKQgBAAQ4BEbJ3cL6b/Yi8GFqYavZNxHS31014Olf7HibD7hnGACSMKkKWh77dp4dImDvuVl299+N8SB4PAJh7hm6bqq7rMAyZah0RhBjuZn2YByZprV1uV3cf0yBDNU0nYY9q2esjASzr2ns/Ho8AUMZBmEVIitxuN0SMgDyS51+p0/ju+cNQarpPIpG7EwmAMguAIiIzkcgutskuEjh/3nQjKrUSMEkdLBOBNLR1bc3NZahSx1rbMIYMA4tM82jertcOBP2egOgeZgoAZn44HtPuF8PTzAjct217eDihZqQP5kuTl/DSQTvC4XQCKlLHOkxEbMzk4RqICMhSxwDE1xr5e+K1RP4Nww3Qtl/95B+4n63fkMJdWTA10WDORB5Wa7Xexlr32Ndw8AjCZbkO0zhOc9vU3dEMmAH9drulF6FpTPNUCi/LambuxiLRlAAR3YAQOQg9EFkocBz3MNXkijOLGVxvN21tGIbrdRmGaZwOauZAACDMEBShKaw+HY+32+Vyvbx588Xtet22bRxHc5cCS1sAPZfLFpYH+d57rlMIHACW21JqrVwIEDw09DQf1nU9X5cUPgIAEyDielsAgJkQeRwdABwo3SeDCAimwwkRA8kiRNgAITDZPcSc+yuDqJOkti8AzMENzDzMw11qZQYAQgozW7crbltfFyKex3Esdd1uqqoOItzNu0UtFUKPx0Pvg/auphCAyCh0HAcgliopuqes1WR+T6Fx3B3Pcj7gEcSUQnhEX27L02cnYrp/A75Wyd8DryXybxUEAAy2rr/4t3++nb/DUHN37ww17QspnBD39GXbR/vfuwUij2itpXAGACJC796RZsZSihRzW7dVu7mHiLTWmTF/C3GPt2ER8HC3UiTCzfTp6Q0i9t7MfBrGru12u33+xee3202KZNcmRK01d2eRN09P58vldj2zyHK7tdaGYVjX9e/+7jH7SmaRUmqtl9u11vpC6+m9I9NtWcZxHIahrxsAnM/nN09PHz58WNcVwKdpWm4LCzOBuTPhuqwRMQxDpoEj4jCN27IyMXFOHF402kJEyd4MksAM6YKkjnKQIyAASQU0AHLUOo7gFhHuXVURLRdXXbd83Ux1WW9EyGVgprTO1AjTWJcG6CilkoRnGwtJ8UFEQEgmEBCEI7p5Ji4CwB4yTvng3T0AXyYq8zzXWl+lNX8AXkvk3zJ0/af/9l/W60XbmosQc2f3cA8AIvQIjLQBc1DlKgA7kTsJhgHQe0eUIkLMOW3M2+691zKysLsvt8XuZrfulhO6nT2eo8cIFNn6RsTWNe0SuvYMeSWi5bwkyUa7llqkiKldLlcmmuYx56TrsuRZfl3X+XCIiC+++MLNVW0cR8pWNfRF/5MzRHfvW5+meZ6ny+WyLWsp5c3T0+Vy3dry+Ph4OIzmbnkjDNu2gTkxRzgxjeOUcYPMktUImZCFCUDVEYAEs/8ipk9ScQJ5b8qCDCIciEqZBkFw62ZkveUDJBIWIpDWNMLUo7Xu7mbRu6raw9MQHqrWW1NLt11ChIy/zuYVWQCc8mtpNywHAPD4uPiKCHOHCIwAN/dwoAggkuPxKMPwuqv5A/BaIv/W8PFNrt/+5hc/+af/dHn/XWsrhAJAmLsbeoBwqrPdPEeQefp2d/Bw8ALMLElVEREkJMSXMBkKcLWhlIjYtm3btlzDpLXFS5kgwkhxTESgl1JULSKmaVrWFQCYyUzP5/Pj42Mp5bvvvhuGIQ2EuvZaSymFmLrq7XpFonmcb9fbw8PT5XJJI3FTZ5bHx8femrk/Pz8P05ips0RiZuAqUkqRy+UCAIQozMu6liLH02eIdFsW7V3urhymChHDUHOymhk17qHa707mWRApCHA/jyMRIwsiJpMmBwU5C3YgBhjHUVVba703RoAIIA5XszDrEYEYaubmTW3btq4t8xWmOqSQ2i26dhImjBy2EhLvW3Xaj9dgiMCE4UEQQYhOEbtuXTUCmjqSYZ057omHdarMBeB1o/2H4LVE/u3B3YnA1+t//8f/vF7ft3YG10KsYNM4qqlaH4TCwd0znJryzOXhXQOhikBEYV7XtaQrTECYgQdEMGNft3kY53H67t3b9NMmciGqQtZfljqAiEgldrE2b65mziS9qewy6aK6vHk8AUDv9vDwVAoj4nJbbrfb4+mBWSDgdru21ubDAQA++/zv8qD99OaNm6na6XhS7V17a02E27qNdYAAbSsAlMKFa5i6dgCY5tHd3KyO4zhO67og4sPDg7mrKXkMw7CtazbLy7KU4+lyubx585R1P7mGeYFSR76fXHcyELKhxG7syxmjMwgTcX6LSB2pVnBDVwdL+VCEWdr7RACAEGMdhlLXdTUNKVJrfb6c26allHGqrTWAEJEwD0RAAiJEBnDAguAO4GD3iAVCgoi4XpbjwySl1nEsw7QBBPK6rEjyxcNDrRVgp7H+2d+wf9t4LZF/e4jQ9Xz75qtffPfNr9r2HNYxvJvDfcs8Fs5c5pRdZ2f3wlVETOINC/IwDOHY1Hrft7f3zFVKd7JtWdVdZGdHq2rKk90dAIkYCFVzLCgADNDv/Bj0CDdjEgAC+CiTuVwvGTE4DAMTpQHa05s3t+s1Y3Naa1988UVr7XK9/v2P/0Nr7WUcmf2rmbt3gCiljONIhOfzeZpGZsnV8OEw326Lu5ciTLys6zzNw1DV+vVyQQARMTciOp/PtdaShhoYu+EbIVChl45y50ORIgMJUskU7FyABJIFSB0jnAIA3XrzcFdz19iN4Ho45pdWRkYmAb4Mg7DcrteICLDLdVEbEXEYBnfHIPw4FAUAAggHovuT6ebuQVRYCg01EK7Ldlt1OuFwPHYLQB6GaT6eUGT3lf8zvUl/OHjdbf3tAZEc7J//8R/ef/e1t4XCXVW3Va17RITn2TAJd7XWiNDeX+pjKXuctLsJS8bCtNaSo5dcayJ+OboCQEqhk9sIAC81N/cDmRuF/4NVwDTPaXqW/5rWZ8R0OB725GvEbHXnw2EYhm3bDofDsiwfPnx4eHjovX/48KHWWksVSV9fEMlUCCYGYmhtq4OUKq2vqn0YyrLeUtzYezO3Wuu79+8ul2vKK7/99rtlXU2NmM00SUgRjlSQBVmIKzOxMKZ4hgtyARZkkjJJHblULoPUkaQCcQAlU/7+AmFEmGlr5u52j+VJ08z84bYsuXeOiK0tRDAfxrze/CrqvWuYRzgCIGVW4k7AQshAxyAkZk7iPhMLD8NQx6GMA4moOyLWaTwejsAMEfFaIH9/vHaRf3Nwt/V6fnd9/13frmKKYa49i1cahV0u1+PxME1zhDPvumbOEknILMzS2k1Nyzj0vjmgqhEhE5lptpBptV1K8d6SW7NtW+oF3dXTgBBAkLedi+6Zr513JxERgaVEKEn5tItMH7NpnNbbDQCKlHEar7dLahCPp9Pb774bx/Hx8VF775seDsfr9TZPUxZlNY+IyuxmAPseBgAu53OptQ71tizp7KCmp9Opltq1n06n8OiqiHiY57IngPs4TslSYpIyMiKn1wYRAWGymojI0zochKsE1tT9ISF4mFmgaXcKxwBAZyALVAdVLUNBRPcwi963XKWY+zxNh8NxOs5cyuC6abfN1NQd0rbY3U0NADAfT7IOgiIcYl8TMQOhAHBuewIb13k6HJgZgCLAIGqtKBUCw1/nkH8IXkvk3xYcwtfL5R/+z/+jbde/e3rz9utfrbclx11EyezBuRyn6eDahmHYliYoUEmYMY1dEdd1JeJaazdtvRUZhBDctvWWy+WwDkBd2/F4MAUhCOtCoK6llOt1IWIC9x4tGrgH2GYAAExiAOpu63o4zI4OHkTUm41T7b1/eH/+4osvAOB8vnqKr49lXVZTN3MzvbT2+PjYVSMdN9zZ7XCYRQqYIVKpFBER6kK55gaIJPdEmPvuMQ4AP/r8C93acr242eFwEGYAXrY2zVNrnYnCY9lu4ziO03GaJ9UgZNyXMACAAETMQYWQ9zO1OUBDIgXwpJPf9UXoaKGgWoZSoBB4YXJtqtZbV1MiNrVNu6rWMgChm5+v77ZtK6UgBRjUKr1vANB7n48nYiERlkKIbu6hSESQunYPRwMjQgdwCy6AhBHhSGCOSA8Pp88/+ztAhsyaxNdT4++N1xL5twZt//xf//O3v/kleDtfP+imgkKMUAkAgIOIAnDbNgwH2JIRXUjM/EXOHOEi5c7a2T0Ocu5WSlHV1FOXIkVKLypScsZ3H0dmxgPA9wPsiTgiCNAdSpFt22rIcZ5NbT7M7nq5XEopL3qYUopHpLgw75255hHezYj5dr1Ow5xV+3a7Vim1MBGq9kwHIwZTbb1H2jsSresipYhwqfXd+3ellGEodZrMrXCBVCjerm5exrGUEuYZ+R2O4eEMTPhiDIHMQQzIkDx5AN4F2vCiRNzN4ogMnAKdy9bUVbuqq7pqaFfTnGa4gbqZGVYCgO5qaruVGQLTbsM+iZRSzBzRIjhN4Pf7CoyXWWSGGkJwEZHyabZhN+dST8dTttgAEK/18Q/Ca4n8G8O//NM//vIXP23rUkmTH6carlsZKmJ4Ws60DQCGKhGOGKVIeLp+O+xu4fsWAgmlSEoyMqI6K2AeqCmpQIiE6EgRoaZgO38IdmrkfnhjJvcIYgBP5p6qsRCzMNC6rq2ttdYURKYUGhHDXdXMNDz2+yLqus8Hi8jheFzXJSKKlFoqC5v13rUUIiLT1nrvvafNV1dV6yyEBEw4nQ6ZBpEMc+3aezezTyaDXmvNZRQAdLdChEhUGIAxA2lZHAiAgAiB4K5ExDszFAAIwNgZwIDYA1gAXUAsDIODAr1EhLi7W92bT0yaqke4d3dwBHNjgnycqVUn4W5RSFkIEYUwIrrb/uQjIwWngSSxOsCutIHuNgzz8fGJxvllyOG7dvIVvwdeS+TfFMJ/8bOfvP36q+hXZLs8P3vrwow8BLq5m6qGZ583DsXMwnczmNZakdp7FxYgTMU1Ax7mw7Z1vFt/r+saEcxca21q2XtmBgMAmFpEmO1FNiJe0vUAgHaPCcoiS4RM4u7aWuoFT6cT3FXV7t7de1cAzy1KUrOZaNu2v//xj8/n89ObN5fni0fshrucR+zovY/jIfchgEBExOxm98wZDHc15ZQMUUTE8Xg0t957a01Kid577623p9NDNr8R4eYgKRlid49AEkIEIgKUnX+Du7bmZayHiIHZ3DGjG3jfmlq3ptYVvIPns0eIzMwimEY+qTEX4cv1FhGOrqoyHVprAFdVHcaZpGRIGZgB7l1ja5p+HGkXlA29qgIVi5Bw9xCpp9O9hfxEgfOK3xevJfKvFPnF/1tHoy9/+cvL+7e+3R7mQkha5bpde98QaRqKqyHRLHWlhlgYsNZhGufr9YZMY6nbeit8xMJMWEsV5jpN67qst5UAKCDU1nXNdhIRxzqAOQAw0/V6I+JcZIS1cGOkbuGBL0xy3L23Smo8AICInp8vx3l081KGbevz8RgR3by19XSYAWAc5+f2bNYeD4/JCT/Mxw/vzx6xbct8mJdlifBSJGxfnZ9Op9vtCgClyrquU61q1lsvLA+nw/t377v2z57+A5F07d1UqCzXi4ho+Nobbts4ju5+Op6u19ubN09d47bchvFAnAxEQBYiJhJABpRc10BQeiXRp4uPgLSRi/BuEdrLOFSvUTUsuTtOhBCkZm6WG7OIYK4A4ObC3FVrKQ7R1+0wTWWYDofDsvXelajUIsuySMmUyq0UAQDHAATtDgDuKnWK+Ph+EZbP3nwuw1HbJjLsL9Drvub3x2uJ/NtATrJ+/cufr5dnAUOgvi19XaxpMsmTLBLh/S6yfgEisnBEjOOYP6j2cZxT+QsAvetu8OUEmZO3W4hHJrua7SEzsnuytn0E6QEBgfFy7r5Ti5CF3Xxd1zCH44SBSS0spbx//06kSCUAOJ1Oy3LT3g/Hw7qup9OpSFnWNa8Fdp48EfEuR773s7mpX9d1HMcw1d4r8eF4/Pbbb0spP/rRj8yt1GEcR0fQ3jXnm0TjOLZlTRFRNo/btgGVzJ4FIHcHRxIJpAAiKkGMhA4ECLtzZL4o8dKbYQAi08ADDENoM1AIRCiFcrjhEVFlePf+3bqupZTPn964mZqpZdjWPtudpskNANEsitQyDkQlqaNwz8JGDGIijLQ427YeHmYmdWAqRIWQ5+NJSgH4+AX2ij8MryXyrxovUXXW+pdffvnzn//8ej5XAgpflkXNkCIXLxGWVA9T/bRXcA9EFJYkJKuZh+fR0t0ysSD22hBAuzdE8k7y/JuTvuR4Z67WsvzuRxsfSwZQQADo1ojZzJkJg4koz8K96/H0EK7ae1KUhmG43ZRZPKK3hvdEWjPP5Ym5y/ftYwGAiYTlw/lDa30sZds2RHp4eFiWhYhSuxIA+bWR/PMigohqOtc5S+TttkwHzrgxNEey3fQMMQgNvHJ1hL02GjrsRoxZ15KB01rL1p8ApDCnmRJCRDpyhppr7/N0zAYWmVtvrTf7Plux1qoawkWkNDVX26y31oSwq5ZCzALoEeGAYNB7772rAwXW8c58Zz6eTlJHgMBPevzX0/YfgNcS+beBMP31L35yef9VWCMCNVPVUiSMc90c5rVWzVTD77O4ifYMawCI8Iy9bq0RokGYKac2eT9G7w0jwG6tGBFqlvuQlNzkzZq5ugHQ77QgzHKpZnOtZgogiFhqXdeViR4eHhxh23pYn6cpeTPTNKv26/UW4RScBPiIyIeHiLnS+fS6DsfjuqwAcDodGUh7Px4Pz8/PRcowDMfDqffuCOM05RQSAIZh6K1nTKO7R/i22XSALMe6Ow6jEGfMKiEF4cs0725d8dvVZpoms961Z3QPEkeAu+bZNu2Ib+fruq4eOgzDOI7pcgTonw4KzR2RSq3zNE1A13UJjyJF26pm2mGap2EY0mGJAFwtszRoGHdhEAuSTNMxIhAcScAjXs/YfyheS+TfAlR1O9v519i/M78ZS3QfhuF6fgagph08mIkKkkKECQ1MFBGllN5XImIIpCiloBAiue+6QN1UsByOBRFv12uq4sADI/k9DZiY003BWaj1FQCDCIDU89gL4IEQiGiBEftR1BEJoEjpXWHxeT4M01iG2s2HYUBkUyOmZkgQ6dNwW9dt2xCRSUqt7pbluJQy8pgJtNrbw8NDa+04jdfb7Xa9AcBhPhGEu0/zoGYM0bXjgoE8DAMEnp+vSFhkWNe1dycpbn5dtjAbx8MsDEC3bT3MR5IiMqS3eXayqWnJpRS8WNgmd6orwF478+tEkEG4LWuYuSsApAXZfDoyYBWOOKUecVmuyc8HgCTzY+gg0pfOwr21q2MdJwAI89bbst2YWXgw28cLLATmrbWI4EIS4IF97Sj64x9/xqkZzQeajiavWro/CK8l8q8fDuDf/uaX1+evvV0I1ILVNMySK4cRgJA+Zsl8zPX0fDgsy5Ldn7tD1w6da4kICIpMokcCgCJ73rRH8J6UYJDlknbmDwBkgisAEHKSR3p3kUKInzZ3sEdjs7sRU5qNb9vGRXJRzsyutm0b4+44ae5du7sxETEVKWp6u91ut+Xx8VGkEHF4LMvt4eEBAB4fH7/++jfELEV0a4i0bg3ARYb3798WkWE+Ho4HLoO7h+MwDGaqvU/T1LULi6G5OTD31ggnCysyqAM5hCtRZUSM3dgi9qtHCCL8aATn3+vW82ckgFKHO5VnV15q7938Pqt1ADidTrmaB4Ds6HfXJAbIPEXt63Nv2lvT3pUrD8NQSsY3qqqZa6j1bYsICUKyx9MUZZxPj9PhyHdXjv1r7BV/KF5L5F81CADAdbn+7Kf/+u7bt3ZPIMhPl2pnFgQgJgrIoX4m843TtCxL1j4AUDMwKyQUwszqBgC5D0EkFnE3Fsb7yhiRwmOeZ7uvTXJsl7eWAVtwD7Z+4QP5nW4J90QHJsrCnVVSRJg/tjLmxsQI6Gab99RuZ/iMmRLRw8ODCCd1UdWmaYZ9S/6c5O4IDuLn5+fj4ThOtfX1dDoiotQiIq21x8fHWsdt227L8t13b1n4eDi+PICICMdmOpVZhnIfwxYiypqYQVr7LzvC7joGgAYATB/tOfZtMgIBMkiAuUN4LOsa4YBO8ems1tV027ZlWUwNUxhahBApKVOqjuFInvRU4WGotVZGQqKhDCIS4QrmbuHo7hoGhOM8zcfTOMzABfCVBPlHwGuJ/OtF1kcI//XPf/rlr362rmt49KaITIhukJ4SzEWE1tuNWXZvB66Xy2UYBhaxJEnuLuFtmEZENM8bYcjpJKJ5EHEt9UWB4+5jreqmZtr7py4VDOiU7QlmCxkefm9g99ztAEQHICR0xYiwrtvWRXJ9xMMwrMs1i7ub9e4ALqUUKSKcNz6No7mXIkTcWutdD4fPbtdb1/7FF59db7duLkU+/+xzJHTvKVXmNBP2mOZ527brbdXe5/nw+eefLet6OMy3ZUnJs6rXoZAUqRVIRCpJlVqZJBDTYJyQAcjv6/QIuwvSY6zlZeybbB7ITU5AOIajuYpwBCVFJw/jnyKd0LZlEZZSaymyLEt4QLhFGKCF5yG/1kq0r9PNIqKbaVu3ytUpkASpqMOITFTg3tS/EABe8QfjtUT+9aK1VmuFtv3kn/9hubzf1uu63p5OT6fD8cOHd621eZqI0fp2uSyHafCP1Bw0g1S5lNSWuJkqMXTdEGtECDMiZ/XJ7fA0jrlxfqG1jOPYtLP7tm1t06fHx+cPH2qptdasm0KcDotxn9cJS/NWKLlBgR4QBh7LdUFkgLUcTuiIzLUyI5gbOhLBMOwtz23ZIEi4PDw8RMRtuV4u18fHx+v19sUXX3zzzTfbtv3H//gfL5fbNM0MCB6u2tvatrW11czGO2V6ud0ulwWZnt48Nevvz8/LbTH3eT4igbsXBtWI3oHkMJUIaNotsI6EzggYCBAwjqMbZMrrnQeeZ1jfk3Pds2Fnrgx4X600NTXrad3mamEWYSLEwufzGQDm6bht22E+5bWbmqoBIUAYwDBNm/YiQ+8dWYY6AIB2Hae6LWtE1FpNzdzJAcxJ6nQ4Pb75DGQ3GA/keB1B/q/htUT+lYIAIqxdPvzTf/7/fXj3rbZbRBSWvrUP/cPWNmIah2FZLpmoBXdxC1GSbCQDTCgoBdEsQkSm1rGnELiIqFqtDADEjITC0npLfTQi2p5njYjITB5RpKQa8QX74iJlH0mKBEbe/SUNHZFzqZ4kwCJ7/CGUAkCIDhBI+OmKGAkJObO2ay3jOH355a9Px9O3336bUaullGVZ1nXFMJGyLDfrmif6cRwPhwOJ3K5L6z4f54enRyLurR0Px3Vdl3WdpsOed2vBpRzmIxA9P1+4DPN8GqYxN0ZEBZkgaF0bADAJIgVoRABEgGF6Z/677XatNXtrdt62NHsPIA4zABAh8/7Zm8+utysipl15VjEHng7o7o5USYK4AAzDwMyZG0EBIWHmFuEeQkRMQSxDHYZpmg7zfKS9Pr4Wxj8OXkvkXy1iGMa2rl99+esP779ry83dah2TGzgMg3e93q5mmmaO5h0AECnpHbn3AAB1ywI6ThMgbtYRMQLNrNbYtq0UVnN3zQlkYWrWmApxcmICSUgKA0WEDMXNiRkhwBnxe+wXNw8JIAzaq2cevbkUDYW0tbxzhgBAaE/vizu7MJEmiE07M4+13m5XkeIRql2kDMNwuy2IaKZDEXffti1MzRWZH988ta7eNuZ6GMrp8QGIe2ul1mEYihQAuFyvTEQkRDzPR4fQpmUcxuFU6hCO3W1MknwQIratEaLTHq2Vs0UP9SRC3hn4L6BMFf9+6UziPRI23bpqPz9r7/NchmEIwj3xGoGBt20joDoM6oDMdRpLRPLeKYCCVTczDQfPWYYwl6GMw3w6TocTCEME4J4e8Yr/Rbw+iX+1QLDtX3/y366Xd2DN92hsXJc1nSbOl3NE1FqYeVnW/DsRng6yLJLKtuzFWAQQzS1F1hHuZrBrrt1MX1QxeTvJzutm+WspBw7cNS3ISS3fk17gfurM5ubTZOesfSIszNm66ta3Hb9NQH85wKbrTxbobdtaaynuHsex1tpa/+7bb3tXIqq1Lsuttda0B1GS0tOFSMOHYWit69ameUpTYSml1Pr8/Lysa3Lp88JFeKgTIXZVR5oPp95d0/pClfeoyHVdb+bd7i5HvetLGtqnSGMeMzML7a5qqrr1FoSttXVdt21jolJHEc4NO4mQiLAQsjmYexA6AiILcxFBovzucbckVMYu8UQRqbWUYZqPJ6oVgMJfu8g/Gl67yL9OOJh++O6rr371k9v1a2FljGa2bb0WqbW+f/sdESNCax3AS5Vahtvt5h6Hwyx1VO3hcb6tNTc4wh7h7sd5Zpbe1DxcDQDULACI6TCN67pCBoFZBxgi3AIFsYwDrICITAS19taEAAiAGBF7a8QMCsMwIAoRRnqFEbsQOnkYEYf3QtJ1A/RkMgHAMAzIWRLFze/n7XTBIGYmkCKAyNptGGvvfV2XcRrNNEKez9fbbZsOBzMlwmkaunazyGKasQ3q8OHts7v/+te/ruNQaj0dj7XWcRpqKd00Ah0ibovUKMOBSFprwzTeXwmKnta2iBC9byICgLXWYAL0cEfCOggAZNxFmCGG6rqua6nVvW+b5cxSan2cak573U3q2LV/mifjYTJUAAqEOg5E4khMXLPkRQ4fals3BwP0IFR3dnh4enN4eAKWf09rf8X/Cl5L5F8pQtdvfvOr5+dvtvWC1t013/kRcb1cI2KepvV2TTaeqm1xN7mJWNeFifcDeOsvVMfdgdyUZQ+WyRiG3ZXrxWIrOZJmhWbV7gjM7MzuHh47C9KCiBE7AObONRzTd5aILB1cmcgJRKwbMXkgkltg7z1br5xmZnHJlO/c+7iru6ebhqsdjsfldosIZknSTV5IkfLd83cPT4+uvTV4eDj+5jdfVuGnN0/hkYSkZVksEBG3bfvsszffvH2b+jwAMNWe5GokRmKRWqswo0cg5x05AoB5WHqqMVFvK0BkU1nktzu1DKlxtQittYoQEbW+vjR9AMAi2ZaC5rfOR+IUABAKR1oBFUR2IEQwCGbGAHcj4r4uL7eGSMRlOpzm4wPIkFZoyK9b7D8aXkvkXyf8+fz+5z/7lw/v3q63pYCpeuwlBdVUmD2iay8lc+PIcQABAABJREFUfRI7IlbhzLdCJCSspSLhag6cihpNhXXvWmshRLMuVQIsmYObooenmtsi1OxYpGmH9L5193UzCCIiEYuOSOgUGeyXmSoRGOHu6nY4HFQ1iIEiiCEciTUCHSNip3CWgr1rKIsIhxABEYQTfLT45SKX23XbtnGeluXW06hc+/FwfPvu7TiOEaGqh8P8/HxBpPl0VHdTO9SyrisiAnF2lN9++y0TPT8/v/nss1RVRoTUERFJpJaSHh8ZDJun6ZyQJlu7LRbu45DL+o/na6QA2EngAJD5uvcIbAKAWsZaRmK4Xs9J6+dSwhQckNAsqnz8GHIUAHIgJsqtGAQRi/atShGRUOuqboaUmzSmIvN8fHr6DJDgxdHyFX8kvJbIv0oE/Nu//NOvfvav2/VM4eoK5oAE4GbARFXKhw8fXLUUjnBT45HMnBmGYXix6lLVPevZDRFLkWXpdB/5qWmhwd1YJNbVzQAImYAw1NWNhRh3uxth7kxgnh452a4Scw5GwcNd0xIos1WIMr2PgQyZzCGI0S0/wBTRtSdnE3tQ4WEYnLjs6RGDWgMAM7ter+kAtHeRO2VdrrdrOmKsy3o8jK316+VyPJ2m6WDaaq3n8zl6PD49DtPB3c/n87IsAPDRs9Is3HPBTkQsEh7pDomIWSJ391tAJkqDuLbcWDgnh+EfeY7btuT4j8ALiXv03t09zXHnw8yE83zMEk9EYLuvRBbNvBFEJICUw8gw3tYmd6a9G4AAc4liWY73TpFpnA7T4YRUAAiA72LyP9278/9deC2Rf3Vw98v7b7/58pdo21zL0rdl3dSa1PE4zx8+fKD7uWyaZ/eMsUczB+jzPHmEds0wA8z5Wex1bVmWtPsGgIgQFlVl5r5pLaNn7UKcjw/v3r0Lt+fnZyYicDAlJCE2v58HqUSkhZoCQKpiAiDCAJkC0qYXWSqRIxtgsDqS9c3Mu5u5rTcahoFrAQVgcPTuSERNr4Q0DMPz8+Xd229//Pd/P03Ttm2tqUgpRXrXZVlOx1OEzYfRPd6/ezcfDuM4WuuIbM0w8M3nbwCg9zWnmhFu7tM0lTKkI4ZI4SLIaZUULASB2rurDdOAiEEYEdvWiwi4967H09HMwjTMk6Key2iWkqmFmzVjwbv9ezM9356/eRe11jcPj0WGINz65oHDfHj/7v0wjVKHj69+NyZ0AAiapoN2QyTEnHLg4XS4mh7m+Xq7hMK29soDSXn67HOeD4AffSwdID7aY7zWyz8cryXyrwhZ7FprP/+3n37z1a84dF1uujVVG4aBS12Wq7Bs26a9lVrder75iel6vTw+PvaurbWh1N95+4hYSslB3qdHxTsIAEiEAOo4vCgOzR1Vfyv5hJnS5iuHj0Ts6Nkh5ucyzXsQgSLP2hYAwO760Rux9QYAFQFKaa0Rs0SACBPXWs1tXdb5cEDEdV2XZZnHaubZDDILC6fKZVvXx6fH1PM9Hg+X6+Xh4SF334ToCGrr+3fPX3/19Wd/98U4TYySUk4qvLaNyBnNHSoQM0staZZuCBGASKlzz+lkJk1CjmvdkzYPAO5qrhEGALfbbZ5nM2utBaFHmNqiizU7nU6H02kcD7fl4uZci5Sy65HQc9nl5ohAJIEfn6usua23dV3NM8o8wB2I5/k0jDMgQdBrMfyj47VE/lUgfSERMcy//vrrn/zkJ9bb7cP78/sPjMgsRYZA3LbNNFjYupkqggM4MzLiltNAt3s6AiBhqH3iAAtuzsKE6L+19ESHu2F1KZVZWlPt3c0MkVw962DcP6/wMcg0uY+7DPGTm+SXwyMABoUzgCMxCJtpDlXDo/WW875t20ouTCJkKIioXaWICOVxdds2cGMmZhFh1ds0ze59XdfHx8cPHz5cLtenp6fz5ZwGmtu2MTNJUe3ruh4O849+/KPpcLhdr9N0AAAuQy0DUiEmJhEZkFlImIhFEN1NzR3ACdjcGZCZVZWQ8urM9J6L62m7mWrOYSzLetN9OsnDMEQNUxuGSWpNghQhRsQwDKUI7KRI2WeLDHuaWGCgZKQDEbnZuq6XyyXcw8zDwhkAxvlQxhkMXoJpfgcR6RV/KF7JU395vGwnXQ2s//rffvL+6199+O6r6/l5nEZmKaWYu3UlRBbWrd+u16FK9iwAgEin44mIe9d5GAnxJdL6U6hp7x/J258Snnd5NUAWoFrrMAwpy4mk6X0v6fCT2dluwEv0SU0EAMa9dqbxEBMgxgvn8eVOw6O1tm3buq7b1rqqqYZHMidzBJkcQyLqvQ3DUGu5XC6n07G3lrZguU2a51l1y17vN1/+pvcuIkVK7sEPh+M0zdfr1Qxu15tF2nczkTAJETPRUCcW9oimW09zs73jhlAzs5xRpBO7CEakv5Kau5ru48sI06i1pNeZ9l6kHA/H0+m4rsu2bb233hWA3KOWgXaxJgAAAwuxcBEuL/7hL0+1hfa+besN3faXJqKUcRgmIPHf9Yq/4n8dr13kXx6IGO7uQcjvv/5y/e7X/cNXT8eDj3y73S7rDQVCo7U2TUfXbtbGYTBVIcpzHlO467q0ImXbqLBgGAZh2DTN27a5u5mlcRkLu5t5Z6ldjZmXpR0OMwJmgmsqGrt2RCZg5mqmRoFpOeHOVNQUIgCI61CQ0mgyNo0IR0cgAKcARyq1AuMWDYLD9d5xYjpdRoSqrduNWVpb1drDw0PrFB6I+OHDBwDPGCwAKKX23s36MJSu7XI9Pz0+Hg4HC3v6/HG9Lpfr5bbe4nZ9enpzPB7V+3pbtdubLz6LiOkwd9N5nobp5BBr01plGEYACIRuYetKJFwK7JJBRDMGAnAWDPPeViZCcPdY1+ZqLwftWkYzM7NsmrtGAE2Hk7m13g6HI7O4IxE2M3J/eHi4XtcMxY1wIk7TWyJhDEQCJPc8X+9vElW13p+fn6cihCGlDPM8DEM4minKC5ETIpv311P3HwOvJfIviRcjFiICAtjsv//jP/zyp/9USNfbtq5XMxuGgVl6b/N8cNd0iyGMNK9FRMDfbh/yJFsLAoAUUdPWW2uNmZeti/A4jnmcyy2t3xXWacNFu2xmdzxT7XDPkMkUWbszKPPBl1LShidjCAECwNOo/D73/NixftreZrq0ursbs4vwtm2327Vv28vvJ7UQAMzsMI3LcgNwcz+/ffsf/v7vpZTeeykcBEiRZ31hWdflyy8XGeRwOMhQk/N0PB579+uyDYfHwmUcaF8l70OGFFyauqMQMgcgAwIY3vmeHmGuhBhuGbyQem0AigAiQUR3AyADd/V8olLcXUohwlQrElHvloZGfleIwn27LUGO5AgIkdR07xFg23IjNyGIMEzZYSlM1HsnRED+JMjjFX80vJbIvyQQ0V2JBABiXX/2r//861/+W2sLugI4ESNSFo78/d7Vu+VRNSIQiSgAkJn9+6led3UavygLU9KXVZWI85WvtSb9xc0d0MwcqBASogiHo5qZGiLNhbP5Y2Z3BHBEzLyXrMjuJswv9c9Uay1SJL4v0cPvr31eqkNrTRVLcQBgRGHJgG/EyLgxM1vXpXd177XWH//oR8Mw1FLOl8vnnz8BsjCzSK14ly32N8MTIjJLrWW5+fF0sMDn58vlchmmeZoOQnKYJgjKRX0e8y0MDN2MmSF1P5ih1UAQYRGYlkoeAdkpA4CbDcOAWFpfEcmjJxnreDwhUjggMorsownmdV3n+ZT1NMIQYWeQIyFxjh/Vt4hQ625eENqyCpoQUgASigy1jFKG1vvu+PuKPwFeS+RfA8K27fz+21/97F+ul29MF2+3jMTqXZ+fr6p2OMy329XdEYgQzU1YmADQk9uz39CnAVtMoT31vJn85+7jNN55M2Cm2RX6fdYYWS+NCJFZHMJbU7cX61xEelnp5l0QU0q8sxsl5uywPu5uCCPuhhYvvaRHhEtmpRI3U7NtWVZVAwBGdHEAgAICtFd5jxykIsVcCgDkmnsYChFgUMpz6jTfbtdt2w6Hw9PjIwAA+DAM69JIyjwfuYxrMyBWdwsT9Zf1BhNRKRShpq2twVXS8Uhkj/fB6N4BHZEgINwzPDYczY2YmVlNAByge4S7jeOk6gDgZkxZIhkRkyAZHsTs5oFggeliGYSIYu6ECG6uLcIgfFtvUoswuxoQIwtJYSJTRcTXtOw/EV5L5F8YRBKmrv0f/+E/ffPlz3U9M3YHP0zTcluu15tqn6bpcrkA8DDUaRoiwtPY9X5oDQ9h7up7q0gEd5OFXHTM05wZCVlMe1czZRZVbU2neeqtAQtzAYDMwEamiAjCwrXWnTkoQmYEAerh7kzs5qrWuyJSrRwRbGC+H+E/vdD9/9HznwjD7KMBBil929DDeo9SW3itVYqUUvq6WVaTcO7AhEJEAcv1Wkpdluv04x/1deuq8zDezpfjPApBYTo8HFmEGJDpcrmO89Gch6mUiUaHbmGmGODhGJAnbiIyM1c1M0ECV3MFAG1Qaq21shAKd/Ws8Qj7JEFdBx6sGUiMpa59BYBhGCComxMLEFsgUUHEANq2Nh8P6uaAhOyp4QxUB5YCyMhkvXXVsN6361SkrxuYXy7P81j5MHcLIOZaeu9FemR+l3tgBOBrmNcfEa8l8q8C2+3Sltu6vHe7uauHvX//VtVFeJ6n221B3CMMVS0PfTmGzLYhDcFYmJikFN3aOI7aey6a92njnpuAbq7aMyvPNNP9IE0p8sF4BO8dX7yci1NlfDf+irQZJ89AZ6RPOsREhKfzNgC+MIoSeZsR4RbZhwKAsCQXUm3nvWvX3nphLKVIKRGu20ZEAJGpWK1d58Noatu2ddXT4TAfZnfPIIeH00O3DpCjCAAWAg5kIeHCEhgR2rtkuEIqsvMiI/mGH+cDZs5OZgjACHYP8oEMcgAARCESBAwPA2cm0vzPSCQIwsQRIFw8Qs0JBZEjDJHMLbMYLYeYDkDBJAaZvaHaNg213jM4G5GSVBCE4ZErcOTXD/KfCq/P7F8YEYYY4dqXs7YbQrIdIY91gbSua+9tHEcE7F3LVACRkSLit8JFK1UmdrP95EvILMLiERGuHmkGbm5mLlKIqHWVUv5Hj+1T9N4jdm8I4kALikAKIsky91sl0szZHXfakN3NuZ0/IQxF9AhO84thKCz7YZ6ZiQDQ3W0cT0nrUVPrTVgCdNu2NLg8nWY1JQUAMDVh0daGYQBAFuoGFPsGg4kCWbggIVJOOdlEtW2q7qZuhszmZq7uSnh3uQUQAtdm4GGUvB+iIJQITMoOk7FIhEe4q3FlIk5fJCJmYiJBpG4KCG5aawUApgIAL2SdiPBwDWPfiT7btmzLta0bG5oZoZFwfuFxKSRi4OjxopF/xZ8CryXyLwxEDl3ffvubD++/xegEDgC9NQCUUpqaqiZTmBBLkZ0Zft9BZ1uRwQC5cu3rKkTbtj08PKgaMYF5nouzhTQzZgLi7gaE6d3gCAQed1bjixfhy/+ameqLrhEjwswQUXinRv67C3Nwg7RWDEvWeXg4xPeGkhERISIyi5vx/Xi+E4NKGYah1kpMCF5Lde9IGGHX2/UwH3rXjLXJorNtW/a/ar4uK3AAULJy9k6XkKggCWRyeK1IwJ1bR0BLnuMewAAA+3dV9rzeWqN79G4gI8ueIg4U5MgEBhFmEIL4sgT/HvkU0czy68QNZKDwgNiJDZEDFANEQ3cM8K1Zb9pWDXI3BGfmJJMysRCF+bZthZa+LTzKrq3Bl5fxFX8EvJbIvzj8w/tv//mf/s/3H34T2xV627YNHKdpsrSiGaYFt2yFetdhGPKkHOHlHvc81tF2LrGzCAEyS++aNfElPCDDBcOjjBOyUJ7ZIsowWdvUHa0XqmAWiF1Vap2mum3b1hYAEGF3JaJcwQOAmW++IVJuxrdtq6WCkKp2N/cOHZDCrGWQzjAMbVuYgSiSq9R7r4hS6XA8ImJ2Saq6riszn06nwiwsrq2rjkPpzcwtzMZSC/Pl+vz05n/XraHHtvXebZgnVVvXNcKIqDflMpwe523ZhkncHMED3AMwqylLLqYD1BUiWlIyrTfEYCYE3xnwpRAJ8hDA6t56Gw8zCBtghBhkJhcClmWzUobW2jDOhByElhldQADBBBExzpNHOLrHTsEEhACCfZbSbVmid9vWKgQAkWSv9DY2Pc4zOkpg2xYFNtVCAmmF9log/6h4LZF/WTiEf/nLX7z99svwRYgUAAkLybque4o8CSLnRhXc12XFzD/MLhIgtShMlG0IMsjd3YdZPKK39sJ8zL2su7nH4fTYt6WbDUUqhLnjboexgyN2T7CUJ4PdXTA8j8Pu3zvfvfSSqf0wd4xOgC97dg2L9DPMMBbyQeR0Oj08PNRaEIlkP2NGRB7MAaC1JgTH02G9XqZ5Wpbr1hamcr3eHj97ePvdd0+PT9u2uWM2uS/Q3s2DHFtrPEjvXdjNncQBme5cH3dXv59VPV7IqjuCACnTYCIQHIMJiQhZ3RAYkJA5wqkIGZhpMiX32S4TfjLn/fjYNJDwbur+kaGZCzfX5tbberXWMdxBI4IyWBERglpbC9XmjnUoxGWfRb6SIv/4eC2Rf2G024evv/zlcju7mjlo9zxTt74GZH1EzjVLpNAtT3GBiEORCHO3rIAvY77wAAYzJ9ptHCN8GAYzJyYyynnb4XD45bvvDsdD5qIAQHJuXpDyOrvL3TDQOU/qe4i2uwLmAtwBQliQUFXVemQ8LDk4mTmGh1tu24NLKekrDiJYK49j3SOxCiPi7XpzdylymE9h5u6CVKqE9tt66b0f5sO6rofDdLteH5+e1nUJj2nCUvYYGRRClr52RPYIVSVx61tEtTBUKzKEBCKSVERkAANwNzcLc0AMAkDyzN8Bov2PCCkQg4oAwKZdIoSQBMxQpBhFNw2E/McRmNjTYALATR0AEBDBTLPvR0K46zQhiBAhwDXVlTe3zmjpdmwAHDkbZVeDwbetDUVYhJnvmppX/JHxWiL/ogj/+U/++4d3X09Dbc+2LVtbtyA3cxEhIpFCxM/PFw1EjFrL+XxjIiCQwkgRDukfjvQxrsTcoffcw5gpMzGXcZwi9ujC8JjG6Xw+SxEAaK2LsLm33moZUwCDSG4WGUlz55zf52UqIoiUTmgveHHQiHAHo+BwcnD0MA/0HDIyoqczbymSZ30zBfjoTjQf5pwtWtMIqyKqenm+qDUmnA/Tui7TNJVS1ExE1mUVkVIKC2eAV0QMdViXVsoopSKwWQuEbobI6BYR6MRchTiV1mEaphSg4RFwp5p+2pftXafQ7pjp2xaOKLRPLYXl39WooJ1/kOd3JATg8Ng8D85BRMNw35gh5mgy3Kxvrh3C1JsQEklEsAhz2iztJkxqCuCBgO6fBjy84o+F1xL5F8DLUa6vt+cP3y7n97cP7xmh35s4ERrrwExmsC0rAFB4IIfjWCoiqjXZLWlk28wiCAoATfO8rksef/l+uN77R0SLXW8jwsMwLNsyjRMiaigARlgeqPO42rvuCYiITJSMnG3bpmky74IECO7dnURk25SZWtuIWIRNs2QriCSvBX3PjwVwRHbsyEUYzL13X5fGXAkxc2OlFFAnJirEWLdt69vatX329PB8fr/cFgaaptJar7Voa8RcakXEaZwCGQBOwwEATiDDMKxrE2aDiDASEmZ1X5YLSR0HinBECtO+Lb13xgAPoEAUYAJEQGKpEbG2djgckCT3Y0Q0DJO7qUetA0TXbsQ8zlPrW7MGTMgFgHLCGEiePSPk3FMdQUAA6IWygwHgjhS6tfW2zIfx3XfPpQJQyQwvLkN4EDASunkpUum+waPXFvJPgtcS+RdA1sd1XX/z8198+Yt/267PCH758FyoCHEgOjoztdYi52vE4dHNr7db5TSnISJellsytGutAMTMaZPjHoiUHBRCzLqWgmja+eCEhMMwlFI83Hog4os6++VB5vmdmIn5xcYmE2zcHDH25fjvvsaIADOPCLAs2nt0195P3dMTM89Wez8cjwA+H+be9Xq71lrffPbUlptaj7BamRiJGAmRopSCSOrBxMMwDMOQnV3TLlyFaykSgcMwIHI3I3REykM3pMMuuLkSCwUEOICHKQgCOLEQEWBqLhkAhMXFISjTfgL8fgViZr13YXazjCAno2w4iQhzFhn0qfCp9yAJAiCiUkrKvQEgECKi9+16Pbe+uq5Jq8oMBmZhliCn2JfsgHC+nOX0lE/5n+Ct+orXEvnnRi5Dcj3dv/n2q7fffuNts3ULM5HBAxyhiKi1iCBmJioilmnR2oAn3BO40ldm17Hkh6337g7gjm5u7OZInnUNAFprRcrdnMLqOCAixF6y00kIvq9iRMTCDAB7OKKlnHt3kzW3FOT89jXizkY0U9UAu3960fFugZF5VejGwsIyjuO2bfM8nM+XbdsOh3kc67ZtvTVEZNmV1wDALEUKEdVKUxlqrd1UanEEg+it8VhYWGTg4iQVzdAdmRCJkCPQM40HyaxhmCFaS6Vm92CkEOZABpBIHzdiLpUBHKFQCQgghIB0e2Nk25N42czcDZkgGO5pupGzyHD4+DQQOQEhcyVhQLy/LdzNXfu2XLdtwVAmKoX2XT8LEbnfv2vQAUjdgAVFIhzx9aD9x8drifwLwN0x/Luvfv0v//Rfdb0WivNyPcwHcESyXLq01oc6MVPWpN5ahM+Hg6kGmFqvLnvKipm7T9PELOu6JpE4PPc4Hqa11nVZ58OsanznZ6/rMkyjmrbWSAQA1Iw4nXgYslDuETQoLMuyJIdxjwa838vLRf0WdTwHl6rmboJ7GQ2HMEcKJgFy9CDEJLI8Pz8Pw3C7+TAMb56emGBb1svlwzgO0zwF4/Vytd5y71RrHerUegsgljxER0qMkvxkakaf2BEREiEApkNEeBARILlZOr9Z762vnMt3ImJ2oAAQ4dy0JA8/Ven6cVSCEIiEzCUizIKpmHdEZspYR35xa0ckvAvXiTkYmISZEeXFlxeCuvbb7dpao3DtG/Hu4MksdyP372mxp2mepxmIfmsP/4o/Fl5L5J8Ln4QuEVG/Xt/+5hd6fVc5+m09TIMbWNYMRCI8Hk5wZ89QOO6tGQ5DMfexVPAotbTWzLwUEZFt23YpG4JBQJht60yohhBExKVIhCMTAJRStmVFplqrqU3zWJiFSB3SqRcpwryOtbemptY3KYXAw5WBwSw8CIACtmXNHxiCMMBBkAjJ3RgxPIICEWst29a6GwEFmgBzGbIkrV2HWpFQuDDTtqxubRzrf/jxjwCg997cpZA2E2QugoitNyaaDofbchOkrLyhxoAM6G7X23mcD5lGjcaZdxgRlPQAz2BIZEE3TxJlADggCXtK1A2IipshFQtEFkTuikGIjC/fCQxSpGarLsQE3LRDIBEJF4wXmoGnP665EqWPOAkWRE4+eYRpX9uyrreltdWtRRiRpF1Fao+mcb4ti0cDAAoAjIiQIoAciBYAAAQBAPFaL/9IeC2RfwFE2z68/fb64S3oau2WNENAS9e/5HOb7Qkledwm4+y29vkgEQBkfUyT8DyERoR7pB4mOZKQPlm7TQO72z1r9uNHSE2X23I6nn7rcQ7DQIjmrr1LKcKcLW7uHPy+VE1ynxMhUTpOAkC44yd3lF1eml1mwxUUjJQNkpl9uF5KrcOg20JFaBhKKaXUcr1ccwwqxKXuTEMASJpM187ETOS5rCfEYKTwMO37tj3X0KYqZcgfAiiAwh2JvLuZunuqaDCd4gDg7sROzEgIQSiMwLtLJyB9fAJ3yfn+akUgCmK6THL497zgbJe6Z/YDEzAig1AOdsFtvV2tb+FqZruGEdKJ8qPuKL84c4CKkmzQVwHinwqvJfLPhU+/1MPeffP1+e13YJrDPkuqxy4gcwDwvhshMCMCO6e+mbs3RCDkiO+FL5h59kf8/Zh5s49Wr8yk2gOwFPr0I5Xn5Vrruq5A/JJsg4SqJswZx4qI2Hp8Xw7s7ntUVupEItQsO+HIZBtmgHAztehtlVLSwELDhJipGNi2bdu65u1gqYdpYKLW2rJcPYKJiEGYcwdkEeGRAp/W2jAMRQZVBYBUQ5sZAn2sdIgAYA5kjvm8QXhEShIjuhmo7wm0gQQkkNzTZLkTBREyEwkyheYgle4LsY95Fe6WCkW+n4h/61Bs7uFBTHfVNmePyYBu1ralL8t6u5h1uA86EBmAiCQQXs7sbg4AAR4ghWnMCbK/nrT/JHgtkX8+RAYkh1+fP3z91a+29SIIQOzeIT/JO28DAYDSMEKYiVtTJEyvCLibzADAno6ihthKKRkiw0zruiIiAEFqe++URiIycwRiRnVH3F/9jHhNZ/IyTi8PuLVGiKXWWmoRcd+91HaCZJKK7iEqqYbZKehmhei3i6lZ75px1blet1BmRop1WREo69H9FrQt27pd52mOQpWFpbSlmZmGu3kpB0S0rjSRlD2UlXkfAgYAC4cHYAARAAlz7wawZ4UTYexuQ+AORCXpUEwEkd9LGEBMZIDEBUmQCYKA9llIPsP3oQSG5hdEuBsXwcgy+rFEphLqXh9TxMkElK7i27a1ZV1ul60tBYwhgF8iGTgcs3e+q6T8RTlO+Nuaolf8cfGqWPrzIcwhCEzbdu3b9d3XX05F0tE63SiIML37iUiYmcjVtnWFMIbIM9dUBwzQtFkFqLUejwd3H8c6TjUtGMwCgcdxjvB00s0Qwd71cJgBYF2XWitRJHE7fSIAgIXRTQiEAN3AnACXy7WKuBp4FGJBYiDwoAACrIMA+DhWFlIzSuJRRB60M8wUACLiZSe+n0c9zO16vd6ua9KY1qVt20ZM1+v1ermaaS2VMAqLEGnvtZS8kWEYiJiYD8cDIeXtEdEwDEi4rGsaW7zU6Gk6piWPO0REay2lfvlf3QKBI5J7T4gMQUAcxI6EJEgCLIDsuBtcOkIgAGEgOkJTBUKpJRBIBBFLyVUMAcn9H2QsTAVYkIXTduT+3kCK23L55uvfoFtSAiICA4gKUwmEoQ7juKfTIFKu3cdxYpZhGMDx9bP8J8JrF/nnRUTf+i9//q/nd98+HQ+uK+y7Ts/lNQAwEwCBh5sRItzbsftHep9FMouI5Ol4nmdEZEoPLqy1hkdG8qUXBhEzx+k4q2lapV1vt3maImK5LcfTg3YNj7SkNDXYx5270eweGB2RwbAZAYiEhQt80tVm3nT+8PJXIu0X78jTtJu7G3ziTm6mZtoatW0L02Eow1BL4bEWAGh9XddVN621ztOEiBGOwJEGYrvtNphZawp7zHc4BIRTCOweHGwGkVt6ZgeIcDX3CAYwNX5RiCMFEKEEEJAEMaM4grtJ4WSHdvda627mg/hbLfO/ByLBy9cgogdG7M+Pm7d10baatQ6WpM28ChFmLkTy6cQz3wxB6Ai1SsZLvk4j/0R4LZF/NjgRgce6Luvten5+S9viugb07AeJKO220kfr5S2P90+FgEWARiCiiIjI3ZosapUULDIDEU3TcLteW2tde+9GBMxuhsTk3c291Oq5DwIwNybORcrLeRwA3H0YhnxIvfd5npP9h4iqnpHcwqLxUdb9Yj1Za73ebi8l8tMZWa4a3M3c8ZPx2bJlgOpGAAQh5cHNr229nLWWihSmyszjOPau7pYKRczDMkCmJPbeI6DWIqWGp6olL8qlVgcgh3BkpCLVIppHpl0HQtM+CjsCIL1subIwZT3CIAALDyREYmsGTPvrlImJL0DYpybfnw2mjxEiOgK4h4M7QLjptizLcr1Ya4DRQyVHLlSIJE/ljpBZjN+/RaxlJCmACHdnzFf8cfH6nP6ZEOYZeaBt++rLXzF7KazalluWhu6fZFVnN7evUxFzSPeJlyJlGCEi3W43JEzrxgQR15pOP+7mpuZumt4SvWdaXspR3MzD50yRNc+zdm5mXopj1rikXjLzvWdCD4+Il7br/rD3f00HSVN1M/9+exW+O5Z/Cg/P5O5SCjCfHh+GYdi27fn5+aVFRcK0s+3aiXjX+UQg4kucjpnN87wLKLW/3GmSL4VrXkKRnWMYHhlf4RFd+wvrM+G4b8NfpC8A0Hp7ucB7Vtr/VLTWx3M9QvpR5Mvt7mqt3262XkHX3lZzT1dNZkLmdEB7IQa8VMlAciAoFcoA8P/cxr7iD8NrifwzIcKtb7fL869/9jPzzVw/XD4s6wp3QkxymAHAbadA5+e/1jrNMwCkUHoYhuPxkIsaMxXJTHpRdeGaSudt2+ogT09PxHS5PmdMdwZ35fk3ndbygZnbut4iLMICrFZpfX0+vyem/HPzjhjuKoWW5QoARDAMxV0Rg1lSbSPCra8RhhS5oR3GMs2jCGZYDTHUgYkhB6DjWB3dwLr3rW/jOJ5OJxJe18Xcl225LbdsFd3+L/b+rEmWK0kTxHQ7xxZf4m5AZVfPdE/3dI3MkEKKkC/8/08UCt9I4ci09FRXVVYuAO4Si7vbcs5RVT6oud+4ACozkQ2g5iFUQnADER7u5uZu6rp8SyGH/bDb73Yxtg2E/O1TQUSWZTGz4/G4/cmzzxsAUDDhzMKO5IRN9bKc13X9+OnTXObmrdbFXTdMEgAwuXnf93hT4r2a8SaR1lrcedOAYjHTtR12ckOM1MbshE5sQAaEV9B+HFK8EAgG1uo6f/r4TTk/ghawUttaa+XUpW6QoM2QE5GphbCIJAnTCwfhvAfuYn8eSfyW2V/iZ4mXFPkrBYlw1yG0VqbT48M6nWtdgJwYbqUZBGYwPFuD8Bslm2qYC25rbuJb5UKEKWV3zzmnnHNOKee+H6IS7PvhpuHo7rXWqJLas6LVzFg+V52SZFmWZVlSYrvOEKPADP3KGAv4tYiLLfCt3oytursHG+RW9uI10cSe97oA19tXsHe6rtvv9vM8l1I9FBLVooZy93VdzUxSGndjq/V4PMbh5ZxjzgAA67oiYt/339vzImKsrYkw9R2LXKbp6ekJrtbewd5DQmIiJH+WZZCQrigpRLo9mef3HxXo8yT4xaNfNSauXkC3nYx6q4/3n5bpbK1iqxtsiDlIRCnFMXO8MZqqmbbaqpo6GtL+1VtABtjGI47XcvclfqZ4mUX+SuFqyDadn373z/8wX05WVia6vbO32zwDc8AV9wNXvPHWRzuFcoSIuHtKmZncoxHnG1+bmbo+5cxmm8hY8PMQUd1arR0nNQsX0nE31lpdN0Bf9OMAoKYYituESFvt5u72RZ9sLCLCpubmIizCbh4eWyFjkRKrRlokRDOr7t5aey7fCx2ScGt1vkyJEXEQAgBQVaJMTGpKwFEzEnPsoAAgfhJbqVLKutacslUFpzyMdOP/MaE7qVjsoBCn6TJdLn3fA5ABGShSQkpExMKtfNZ5w0BIoiF5eInjhvf8HIFVRETiLxxxr8CdGJewA4BDmMu6q2opdbr/+H5d55EArrDK3HecEgnHYcfLt32oqJVSDInEGeXu7g4I/YqpfYmfPV6qyF8pkGl+fJrOD+enT9AqoXddIkRmisWlCKeU4htEuuVHJLoN3QiRia/dH6ra0PettZyzmba2zRwttiFqZrYbdyHe5e61NncnxPhms9xyi9FnfK+qG3Gl1hgZAmx1bvTmttVc17LIQXjzSgWAUKMBgNBq227zeU4aRjcYuJ+brri7z/OyrqWUsq5rUy2lxLrJNzU2NrWUM/M2QxyHYZouxBRW4HF4l8slp4yE5ICEtyoYfEPzOAIA1bWpbkXxs5cogKfMlBB+RA8CHW6Txx86Pm6qw/QjVWR8xMSpM9+eMiK6q7WqdV2WM7oik6RMRP3Qp5Qi1d7u5MYTMPembduDRXHqP166vsTPEi8p8pcJ/yElDLPw+z/+Vsu5Zxol12U97PaI2KXcpSxIwS/2gB9v7qN4Pp/naRqGQZjNXZKUUkLUq+u6ppEfTVgCFDlNl8iDkqTv+3E3qjZEbK0NfR/XZ0zZkEhLzSy1lMvpvEwzmpNDLeUw7sq8EEDHyVVdbTpdjru9IKE5gRHY2Oe6rNM0ZUlChAAsEhkt5VxrE+ah77uuE0nRnYqkqGS7rgv3CHdjpkjn8YxevXoV5jwAYGqBaqq17nZjPK+mer6c7x8eiOjydALzxCJIXcqJxVo7P51KKW43pWHo+2GTZXNyQ07dslZ15NQBcT/siWR/PHT9mIcxdQMQp9wDUGihAwCY33Kjh9R7a+5+vlzcDQlTWI1ftz1M1Fq9ZcOIG2QHAIC8lOJQP3z8ptUpZQGAYbeLlVRrWksBMzBHc7zaRSASmgc1IHCgu90IL/nxl4yXRvtXCQdQPZ/Pl9OjrVNdZ2t1f9gh4mG3n6cpGNY556ZaWnX3phpMXmHuui7sTdj9Mk2hjVgrm2mtwEyxI9ZSEPF4PK7rut/t13WN8jCursPhUGqptTKkGCAGtY6Z52ky1a7rhnFstcZiOgaL9w8POaeUPlMSn+N4WDg7ShLCv2irCwDMRMQ3rLwZ3MaU27SxqbZKDJ4ECWutqjXgnKrQdV3wuvf7PQDs9nttTXGjfptpjBRZmMAYHR3AHNRxgxixeyHMAIRIQRxCQqaU80CUwgIIkQidiYD4+fN9/hyvBBswd1B9DvAJovzn2vmHGkgICqagy3S6nJ6yMIEbgHnwqeg2u3xe596a9ySJibquOxyPdAVaoQHiyxzy54+XFPlzx78EvUD+9ttv/+m3//j4dP9qGLiTcRzN2ul00taIeWMT1mq+0fi2ZYjIOAzLsizzHDoRNyy3qqqqe9gbGCIxb2aEtdVa626323TCmyZJVwdtbu3WiNut20VEJlpayzmrbSqTZmrGXwwN41lG4gCMTY6attr+knEYbfQ7QsSUUjTv30uv4zAA2LqurSwE+zCYrbUFCSfMJJjF3XLOplpb5euHQWT/lNgUWISJ1EHVYo++7Z/jNCIOfd/3Y065md0WI2YqKUEjooRX/Pz14L9IlHTdIxnA8xRpV9egW0v+eS5xBZmbGaCVeZrOT2OXWlkSd2pKVwomIsZUYdM59s/pTwItmfjV69eQ+z9/0l/ivyFeGu2fNX6QH7cqAO3+07ff/OG3oPXrr79W8H4c1zLfP9zP80zMSURba7XaFbkdBD4AYKLaWmh5IeIwDO4+TXPcv5m31uIijZY2OtkkKfwY3Hy/3xNTiOLcRoRtjXFfWdc158wiABAr4/je3VvTw+HwI9vbazvp7qGBaPpZxedPn6GYSPIVKRPHE4kjGvD9bldraxtMnYJxSEzEZGa1tXVdp3mepouZaWsppcjyfnN53BYptrkKupu34A66GxMxb1IdKefwydk4n1tu2qTKbjWg2488qaslV8gbf/8jBABigXb739sRIiI6aKnr+bJMFyLIOYemOAB8bwv0/Hz6FaWPiMwiMvTDIUiT7mj0Z878S/x18ZIif5aw7QuffXP7HkDbTD5rfRrG/jIvKefLdPn06f5yOSF6q+ta5qb1zdvXx+M+C4NpIEKaV2e/zGeFxpmRt2tm6PuQrGitqmpsopnDMAtNLRCX67r2Qy+SxnEHAPOyRJertc7zvE5TlFTMvBtHEam1lmXVUhPxrh/Q23w5j30+nx73Y39+ehSCNVxqgWOxCwDrOpe6IDo5kAOaE0CXUrBL0MMjFdHh7ku9tWvhFmQeHYZeVU/ns7ttg7ZxfPPmTZJOmy9zCeB3l/Jxt08s6HCZpnlZ+j4DWKT7eT6XsrhrLEbM9VbBGQIiOTIzD31vCIe7gwOgpL4fhXPOPZFsGjxModR7wxIRIFz3V9sdut+gRbflibtvwhNAodAGt0znBMCEQg6nD/c+1+l8FmJvPnR93JJCecOB4FZ4uruaa2vaTN0h56yO7jn3xxv/JwQsCSDsxH7s3Qk/kshf4s/FS6P9C4aZXYEpfrr/bn66L3XJOZf5PF8u2iozx6WVJLFI+5JjA9GyMSFti2y8qhkiork/Pj4EBJKY3L3WKiyt6feKvqA/x/dd15mZqgKEb6sq0bqu4QDRriwdInRHM0dEM+/7vtZy21cQifCGQyzaot83s41fR+jmKaXbMhpCpgyp6ReOic/bz2EYh2GwJgSodU0pJcmSZF2qWmNmYUkpyZVixMxRYAZWnJhyzmbbbv3p6Wkcx1IXEpYsuOl9ExAhaPSwIgzOIbEOV+FbIgwL3Nj4AwATfaE69+zgb6/U59abCQAcwEwJWNFuzr23ZY65t9rasmqdXY1Irk26/XCee3uIVquaaanQNDE1NczDMN5FinzJfb9cvKTInyWio4vvP79dESze/efHpz/+/p+fHu7rsrK3x8dH15aFchZ4xlOurbamoXB1uzbcPIxPQ0dL1RHJrIUQbHSsAYiptWnT1mpOnw1XETFwjoiYc0opxT40Co2bFvcwDLA1+4UIzdiuJjPunnOepjmSEROFTxYBELMgXO0AO9Ob8QAlScHVMzdGZmEseKP0fHHuCIlwXddSqrVSS3nu5bcsC5IzMwsjoodlj2pse/q+a7VeedNAgCIIAL6qefMKLedEblYdr5xO3ETXRX7ouvM5zH4kYf1wafO9CAA5XScVAZZ8niUBQFsrtZSytDJvm24iMAOEayLfSm/Ez7glRjBTsFZbYcwueLg7wjhGo/0nnshL/DfGS4r82YNgM2sCRAS3ZZk+vP/jx2+/sTJZK+fzqSxznzea8GYYbaalwLVq+B68LkqzKCTNNJrKWmvMJWutcVeqraqp6fMUCQCRU4hoHMZaa2stp7zUFlBJFwlhWgZoqsu8uDkxm+owjkRoZjnny+U8joN7YJ6bNtDWWCRwy8ycUlqWLQOaWljH0LYg3qpLbZ/b3ucIGCIG0JtCbUgNVUZGX9dVEnVdJyzBxa6tufthv5/mOXU5hRLwNQFFQX133F/mSTpsrWppmPj2oLciVISjPHT37wtOAMRngAd6E54PBL8Y+d2mqKa+zSafSRrfsuS1rkdTbara2jzPjEaIFtPMjb9j+Ozub6BRAEg5bV0J8VLLbni1P76CHyhlvMTPHi+fPz9f4PXLaWvckMBNCNbL+dN3v2/LxcrC3g67fZcyI1rzeZ4u53MpJSUhB1ettbWmpraJTZgRc7SrahYp9Xg8ishutzPbSCbuZmq1VcRt5ztNk7uFRoaqLcuSci6lwrUtZSYwn8+XTsRaQ/NdPxyOx3lZRAQJGVCQETG8t+Z5QaSckzYdxo4YVUtdVjQfuq6tpcvdbWfCV/ZhTOsiu7m7CN/6989nDlGEA/+o17qp1jYvy9t3b/f7PRFdpsu6rkGhcfMPHz+KyHyZLk8nQYKmoNZJysRtXciNwLxV11bqAl88FkeVi4jNzQkdqB8HQ1B3dTfYhM3hJn3kkCUFaPR5RCpP6XM1StfBQrwi3+vQb+CByzTlvFm/5rzR6vEGYwjykjmYBWjpfHps6+raXFuc0m7o98dX8GJ5+MvHSxX5C8TzD3b0j++//ad/+C/ojdy8FTCNz6XPNRQTIZZSybcyhxCHcVP/HoZhWZYa5gdE0qWc8zzPh/2hthoE5+DwbrY2iK22Gi0tw+l0Eg6sXZrnyd1SSqbGSMEyROyI2M1VNecEAIFFZ5YwjWFOiJhSjoY6PHVqbeu6utsw7AkxAERxvW7N47OI/jqn7OLTOsOXuuXwrHUVETQPZ5io36bLZN7iV+/evVvX9e3bt/f39wAQA9CbRFtmZuZSa0qp1JJY1AFNycFd8fkABIlIkNPtVaithQ0ZRP3oHp6rNx31W3y5Yja47vfd3TUUMCDk3Dcswxc+P+5u2rStxd3IQYjiIyGl5Gb8zCUx7plkG7m4VVBFVzUVyF035H4AfOmyf/F4SZE/c9wuRAICMC/l4eOnZZqFEAjBlTmE0bYI84XASLdS9ru9EM7z/Pw+A7IDAFEe1lq7rnPzzUDqe/4H7vOyqDYisuLCMowDs6i26TJJkgBgdt0QSarvU2utqcp1uTQMQ1nXcbery4yEJBRKP3G1r+taVZkhUjMziEgtjYUdFAnQEAnVNHpMU3N3bdr3fTCpASCl1NptNcRhexOuEpzRtUUJpqoPD3POnHI+Ho7ffvvtbrc7nU45Z0KKFTxsm3ECgGnavNJYkImvtBNz30RwIqGwcCzNN78z5lZXJIRnvMOYHqxr6bovzvDzLY2a8SZ/ac+LYk5oP0CSAgCaadOyrsuygDkRUUq6NhZGcqst5eStEjMTEIe2kLk7gYGqW3OtoAAA/Th24xifxi+7ml80Xj6CftFAMF8vT6f7D+gGVgHshwo0kXpUW9d10zwty7Lf7+Yr8nGe55jECUuXh1LKbty11mJxfNssP7+May2t6bqurVVzDzzgsixqGjVXqPkThfxQt2l0XxcUXdepGTPXVm+g8VKLqdVap2ne/LyIETH8bYiD5BfAvW2CZldhyCQpmN211sjLgWC/oqo3pCTEiDCl2Aubmpr1fR+OYGtZ4/Baa6WUfuj7vg+Nn+AmhZliPNOcs/sX+5bn5+dq3s3bsyAstXwGe16rQiQyU7zCVL+XKGOXYltlaFFxP/vzHwXbq2ppbW1lMWuMzgTkBmCJGNCCwh7smlvEn6vFGMCvhhwDdAPcxt4v8YvFS4r8mSOwgVusxcr08N0/D1TRa7OWEl+mEzHEV0qBFLbWakrsrsfjfrfrz+dT1yezer48jbuxqnLqkGVeF+S0NnWkZrDWouDmSJKagZrPZTUwABj6HgByyrvdSMStNpHU98Nhf2Dm3W5U1VCfbK0dduObV8d3b14R2NAlAnt13C+XMxEdDvssSWvtOAXVToQO+/26rszADCy0lpkYl+Vi1mpd1zIzYyC3a1vNW/wVgKX0GQV5E7mIwPDGNXO3JCnEjeLjpO/7lNLT05O7T9MUSXZdV21tGIbD4dA9i5QzIs6XSVLiL1WUAOCzHq37fr+DwPTYNnlclgnJAbXUhQXdm1kTwefJMUkKt8UA8YQnWhzz53RW14BQIpIDOEJIvtW1dFmW+bTOZ0YHczDvum7segRIJIBGzCwIAIQoyGFQDgDuiogMjgDI/O7rr+DHtDZe4mePlxT5cwcCAKCBN2hl+X//v/6f3/7ht2QV0LquC0S3hB7OZ41ujlxwd3cXkzuRzYHg7du3bp6kCyFIZmmttVZTyufzOSA7TXVZFm0tPEjBfBiG+4f7ruvM/XKZ3C3lHA/RtK3rejqdwCzUJWNjwMw3eUdhQURiCh70sswpJSRclnmZl9sON74JcSFTDWvT60n4LN8QSmW4MbItuunbY93CTGuttbWYcsYQMIlIktg4RaJ091abu/d9j0S1lOXLoUSSlJK42eYm5hYekGrttkpSvWpEkiN9ngjHNxuoAMnMiOlWVF7niXq7nz/xLrjexsDcw+3Rqllbp8s6n5M4bX63SgDWFMCIo4sPF3J/rtYe6iHuikTCnCSnboBnlhgv8cvFyyzy5w93sKbQ1j/87h+/++b3fZ+hlsupztPF3d68fhNXLwBgFJCtCvP+cHAER8g5933vJK/evEXCYcwErBa0aV+4jMNw//DgrgyMRA5ayko5u5qrmbVlqq+Oe3cF191uT2DWGosIgRAy87IUs8YoBIaukexaq7VW19ZM3UwIEB0JzNow9EgoQiRoTq5NCIWglFZDh4Kg1hqGEFFHNwubLWTmdV0jL0YnLpKI9AbqJCL3L7UXN6oymBmhh9ZZzvl8PodjT8ppXdd5mps2Yem6DADMvGGbxt3Dw6cxx6KZwkYBmhnWkJiLMxktLQA8o0JtgYhM1JqGufaXx7Yx13/4ut8+PK4vriGgO7mba4uR4jxdyjT1KT9/uJhyhFJcrWbW1JUNzYmciREcbEVVJQfJ4+7uTf/qLbg7+IvMzy8dL1XkLxDeTFdryx9++w/gFV2nyyXYxIfD4fHxcYPPISPi2lqSNAxjTjl3XYzeQkmsH/qu64RZMuWco9brOJVlfXU4/ubrryXx0KUsiRzAHL2BVVdLSayqlpY5oXlbq6vtx/FyOq3zrLWatS7luqzT+QLmWqqWVpa1zMuyLGVdzXRd1/PlIsw5537oEWncjeNuRxjXMxFF4lbVpq2ZtedUt2iHb0IPfBWPAACRjQMTdxJZUiSllJgTb/pG4u7zsrTawqjnppYmSaZpaq2FmqQk4bhHkTBoPJ+nV6/egJMrMFC08MSEm+ysubfroujZzO8HueYmSQfPdu4Bx1HTH6Xc3G7w+XvVyI+utazzMp3JDcHQNtC+uaptBTgxhDvkpiCitlXrCIE/NXfO6fD6LXQ7cALzlwv4l46XKvLnD2QSsn/4x7+///DHXqC2RhxyshkAdse7XT/k1Jt7rcvd3evYNnTD2Pd9bbXVZu5dl4Wl1CUlMTcgEKauG5ZpZu7GcVjXFeyQRS7nS2IchkG1vn//fj/2RMRdBwDT5fL0eM9Efd8zOpr2SR7vP3Xjbp0u6zK7e2s+mS7Lcpkuy7qmnEX43bt3MRBcppmzLPPmFWNqfT9Iyq02JDdrHsRHQnAt6zwOQ0GrrYA5oqTUEVHOfSmltSYiXcpEHC1113WtKVFChJz7JBIS28H8u3qAGXMKifUwKojT1VoLSk/f92Pfr+sqxOTQjWMtJbAwDEgOYQ7DwxERAQxRQqqWCAlTjAJqraoqKT0vD4n4ai8u4QauZvXKoazXieRVSOILV4ZnyheK5ojmYG0tp4dHYjA1cHNvDBRikIgOgLVUIiIHRIKrOTgA2OZiBkSYuuHVV/8GUDZVtZf4heMlRf68YQDmdf347R9+/89/38pkPpWyuFuUORG7fgcAQaYuVnbHgzATc9cN61oRcTcM7t607cZd0wYNSMjNrZWx69VUS1umua2lT3ncjYEyvL8/HY/H/bhbltlUL9N0Pp3iTpAw7MN++9vfdl03zbPf3S21lVICcH6rfcKG8Jtvvn3z5nXOWbWR8TAO8zQTM0bFx1JL0WbDMADA6elpniZJSYSaVq3F1FLu3UBV+Zl0DX6PMoQkwqGMFtbg6IErlzBvAABJKajZRBScIgBw9xuzCBG1tiQSzfg0z2bGlK+LfjMzUBNECCdrB3Kw7QHpy0Oi8KJ4/ooiYoC0/Mp18Wv59/xm8bPr83p2n+aA5lqX6fJ4/6nvUinFvLkr8eehrTuYNTDIEvZEm57m9d5J1atpAjbA8fAawogWf4QX9BI/b7ykyJ8hnndcBICM63J+/Pgte2u1oGvOAsbCIklEpJmFtj5n2XMfgmChGY6IoR2JiMuyrOs6zVOfMmHSWqd5HrteW6sA0+XcpQTWyjyrtWm61Nq6rvvmm98L0vl8qa3mnNHUtZV5OpciKRF6LQsTXaYTUUJTNwUwEXZkJrJWgPH13aEs8+l0RsR+HFQ15Uxbb0pgniXVtg65K62lnJdlGlLvWltza0Xydm1bU+m3EaQB+KaFY/Q5PzITmQiqhlCiK+m/sIfYjTtiujWiW2FrNq9T9/p1JKlQkExdVlMt5mZkBqaRFgEACZs2ZAr4JMJn6zFCbFe2EtJnsPlzrbPA95BR+I8/P7xAyH8P1GWgiaW28vHTp7JMXWJ0NY/lDBMBIQJCUzNzNW/g8XlwmxsAADO7OZOQJMldfzgCxaT1JT/+4vGSIn/OIAAA0nXROu/7pPOMDUySJMJr0WGqkkRAcs7jbnTzabrUVofcBVc6rrvz5YyI03RmwHlZBvNSyuXppH2NUWAtpaxrqes8T62pCKu2x8eLqgoSko9jJ9J5143DYO6lFG2as4RF9el0DvstA+z73oAQ0dyF8/l81k2tF/f7nbtfLpdca9/3XRIAXtd1v9/hiojYtISILyKW2kKQ5rDvqqoDIfJzAxb6wbyPSYgZVWMmiU5O9ixDWqsrEdxaTmjbsjg2MznnJLKUSoitVkWULqvZuq6llETJgZyVBRxUCDz0jdxDHJeJN2QqISLeSshQ/WUKCV56niL16iHxvSdi/hka+b1w91qWy9NjxzidT13XMQOEKuUmYYagYGau2qUMAHQl6d8eWpIAkOS+H16ZM29bBHvJkr90vKTIny1oqzrw44fv/vf/7f9zefgmmRE6Mllzbepu+8NhWRYB2O935j5P8zKfx2Ec+r7VliVpa2VZ5qbMVNZiVZdShsSfnh5rbQCwTmrBxzYTpNPjqTVlostccsoNaV2n/bt3AEDA8V8zIKLd7sgMiLSsl1brbjf2fY+cWmsOBCzBUUmJl6krpQQ0J56agp/naa1lD7gb5fjqda0VOTHzXe7XtnDqXGvqtGoDg2VZOPWRy+Zpmss6z/PucAdu1yua9rtDKUUSuCGTmDuiIG5uMylnUCprnZfldH76zW9+I0JdknVdwb3ruq3wA5vOp5T7wNJ3XVfmBRFzTmq6H/dPl0kcyM21YUIHUDNA2hTXERiwViUS4RTVZK0VgEwBkZe5xFaGmWsrIsyAqmbmwhlgU1ELYHzOmX8AZnIgInp8fJyn09Jan4TAiCTeK34lHEZ+xE1JyAHMXdHpWfMuwAZ5/+5v/wPjAA5wpSq+bGx+0XhJkT9D0Od/23J++vThu1Zmggbm5opA5j4Mg5kty9L3/au7u3VdY+3w9ddff/vNt/Wx7Xe7tram2tp6Y7MhYp/y4+MnQQbVdV0NLZpxQVrXpdZmYO6MSLU1Zrq7u4uBISIJJ2IiB7vOznInwzjUYwMAkszMBjiMh7VpKUVVSXK3S90OhDglWWtZ5mWtBYDQaF5KqZqm+bDbD8Ouauu6jpokqU0rFWHOy7KsVfu0mcn4M5dwpC/SR9iBNXcixmAEAgAJkQBsWo39OLpnVb1czrHqifwYY0TTzbDWzMDAxCSFliXn1EfDHvSYWqvkRiSgCoTmrmoeA8prR61mUZ0h4Y8abJh+oUyB+AVh8UffG2p6OV0ePn1k8K2tBoutUcxgEcAdrgAADlNe+FIJyd1rKQ2lz+Pd66+AErwMIX+teEmRf0V8D+3xXCwSlvn07R9/t5a5y7mViYgBnCVcomy/26ckT09P5/Pl7ds3APDNH78JYPbT0xMjhvVdUwVrfrVRNTPgMBSQUudQk0RibWqmQBgodHM38NZ0GEQ4p5wBIIojgM3kvuuFiRW8lKKORNSlDiX1uR92ByAmIgwfGDVtym7Dwd39fD63VpZSiYAkP51Pa2ndblBwThlJ2BKy5NxI0nRZzEDVwE1pO13kgMjNY+RKgT2ElAC0VgcgJERHROz7vtbJEfuhJ/Bazdxev37DoeBtXkvxlEQYCbXUdV1jmBAcSu444OJmysQUUhGtamuSwdzBzAmuYj6fX0h329iJRD/aNBPTepl5O9uGz1CQ/1II4e/ff7NcTgwmLGGP1lSzZGJiRnRQ+37b/iMPTQQOkvPucIQUkuT4LzslvcTPFi8p8q+OuPJpe5d6/MR+/4//Vdt83I9PH76LgVbqhFNq2o7H4/lyDu7du3dvP93fa9PE2FqrrbVSKOdb4bC5fbXWSkVrT3VGQmFOgRBUbaWEUhkSs8j9p0+7/V5SMmtEKbYrRRunDJyEOW7IIg5qTXd3b6JZ7rvRkBzBkRFZDYCplDKvJUsCDFEvP77+al4WWuday8PpPPTZWaE0M5aUUhIiJnfktM8D8fT4+AhbfbeB3jdYtbrDZ7wzE0Ha1G6EGYwMWyllXhfQlhNYqylxWVdTG/ueiEOhY16W4FaaWmsFEcFDXFJyzkVXooTXUq1aY+hqK46rOyGh+8ZuSc/aVLNN7wyflZbfi9YaM99YN7cIWd/v3xqtluXDd99yNM5MTmQIAE5MwgJohG64yazRhird1O3g6kMZayitgMggKRbZ1/ffS/yy8ZIif3IYxPVjdBN8doCyAuk//Zf/36f3v19OD16eduPIiInEqLm7FVuW0nejiNRl/vT+Iwsjkak3rYJ8d3xjWspy6rIMlKdpMjMRGvv9dD6zkGorZZ2nCcKXahzWeQHYpCL/5m/+1t0MYbfb991YanHmbtilbiBkFA6ItggzZyKa14W7ZECLOhI6ESCDExAbAOVhTD36ppjdVNd1Bc79rhsZzk8PrZbLXKtiSp5SC3YgUgemxDQeSMHny0Wbmzq5C5KrSkrlWeVFzG6WRNalpi4ToPkmyuvuqi1EuoOeTMTzNIfERt+nrmMivpzPxHR3eLVMc0qy1vb69b85Xy7I1PcUdElDGI93lzJ1TM4dgQASuCMyXaEFOeWYe1jAedyaKiGKsJmFfwYTmdrNGWKDmxMShGocXZfj10SJhqaX85O3siyXsd8EIoEQOSEjMdRqKbMzEwOWICwagxCQmZ5O53EctvFDYkF+8+5r6PpIo5FU7SVL/sLxkiL/6rgmx5gKsX/727///T/9748fvwVdhIkSgdO0LO5FUgpDgZxTKWWep1ILKZlZVB/F9HQ+LdP5zes3pm1d18B8lLpczufEqIY55b4f9rtdGB4wS8gocEpd150vZ04p5wRMzY1ESBiZOAsgC2ckzKknIkoCTh0lA0dEC+QzkIIbEAAQhAktrGWttTJx13UOhJJrKZfTZb4soFVSMjBkZJC1+Hk6vTruncABkWQ37gFoPs/aFAnDpzBgjO4eaUSYmxMi3xwHwcgQ+v0OobUwgFAUoVDcEKTz5Zwkqba7uzszSznnnLWpsNTa3r59s64rIb5+/XpellrrMIy1VrVqpr5p5jK4oSMDOXoUjEgYcuWEaECIFMPQiBsUsmm7wTxvbkKxq4ls+UXb7QSgj58+qhfia03KzswksmVYb+gsGCyjbRgSmygD4CttXMHNDCX14w7cIRbgQC/J8VeIlxT510W8O2lLkaqnD9/87h//8/2n33tdd2MWotPpNOQh9Z01n+dZOIlQreV0OmmtACAs1SsJzPOstbr5OIzLsizrtBUORPZsJFZqWc/rOO5aU9WGWBV8dzgQ4uVy6cddiFE7ITFzTjn1hpBzBmSSjMiSekR0QoAQkgAA2EQnIR7M3R3MYluRGLP0S1k/fnq/LMvj4+O0FDBjYmsNkXNeL9Mfjsfj11+/u9vvqpokMXdBggS7cSSjy3QRJiZa1woAprYpfREBE4VIOzMRIZEZIXNYGzStZJ6TEIG5tdaQpeu6w+FARLW2yGhdl6fTzLIJsy/Lstvv52WxzeWmSUq1VCFERGZQ84A6EQk5ETrgluz+pZVL5Ee9mvlELgzyIiHpVZ8cCa9zF8LQ8TX/dP8BLehVjhw24t/DU0JIHocZZJAL4g2gqNFla9NmzuM47vfP/9Be1H5++XhJkX9NfM6PAIDQzh//4X/7//7xd//YZaA+LdNTzvKbr9+15mVdNUS9nMx0mud5nhmQhSVJ01bqKimBebPq7qWUvu9jznW+nOf54qrzfLk7HN396enpcpkCoiwiScS7btjt7u7unGQD+LFwTuO4TzmrQcq9X1MkkESdaBjLZQIARnYidDJUtHBSUURyt323X2rpEFJK0zSN47hWXdf69PAwVy9rmdeaOD3cP8ZpOfqQUgZwQycSSDTso08v6EBE1QJDvpU/Ie8I6EgIRBCzPORuzLXN5gVM3bXU2qYGAIfd7u7ubprmWkqY35Zanv7wtBt2tXDe7e/vH/bHw+V87schRJWWZXl3dzxPU7cfGVAQQag2jXc+0zZzjJz9L80fPdbf8HnFjFdBR3N7ljY/708cARyeTg91vSQy3riPiBhCuV/4azMTUlSSn+tCJGTga/2KZppJ+nEXW5rYxL/ErxAvKfInx1Uza7scfL3889//r6dPf0xtbXXVWrougbX3798PeVCzVmtTFebzZUELcqGu6zpf2jgO1ioAYJIg6h4Ou2WalmVx11aLIGFmU3v/8ZOb11aTeNBvhmHY9SMxGZAhJWFm5tSRCEkiJETJXUp9p46xhynm6oooTLTf35l6a+ruwmQAYkwpAOSttRDwcpKcOLlbNxxMlZgfHx/HvDf3b7/95uH+gdDuHx+//fDt5fz0P/3d/ygpqdZ3717XtQJUSKkfh2mGVgol6jkv8wJETtL3PXiYRPs4dApOhIbU74bF2qK2lBVbS4ylrgCQUy6lPD4+9n3fD31o8OSUW9O7u0MpdZrOx+MhQN3TPLv70Hdq9vh4n7oB1MB8mqd+15GDEYIDIhoyE6m7A6VuAIBEBMQAaym1H/ok0hqqmhsSiYMRfCHmhuThChkIBE6CKG0tZbk8PT2wG5sRIkIQ9SO5esgLdV1nVVE2/1hmMYBmIERABOi2bWww59GRMXe33PhSP/468ZIi/xsCAZqeHj6+/+53Dx/+8Hj/ISfq++wKAATmT09PRBxD+k/394fDIVFaliVnYWZXW9cVNyEyLaUkRkRc1zXnfP/wKeR2lmUJXRw1e/36TThiMwsRHw6HdV0dMbYlzMIpI7MjEUlY3deqgAIEBoQsQsKUEHktBgAO6A6mGsMwFAYAMszCbhgwGm2tNXf3vu8lSZL8+hWs03o8Hn//u9/9/g//3HVDSumffvs7V/u//F//z4j46dPjYbcnSgAqHfTuK2JrtTVFyQhAiDcCn7sbAiBCTPeASByuVEVV6LpuHMa+7101aItuXrQwEwv3fR+blpSzpBR0lKDL3F4oArBq0AMAqFVEATBA/NE8Y+5BhYpWumkLZ+1NpfyqD/T5znFTfVd3JGZKfT+eTdulzPM55ObcGXxb7sWo8fbnsfSHZ5YPN+jl7VHM0Q2JBVnMHfBq1+3wYoL4S8dLivxrAwEcrC3/8Pf/+Zs//G6dL0ieEps1MwIEMxNCc7VmALDf7U11KdFNG4uIxAajAACgITmTPD09dSlP8xzmheH2l4dkxjn5OA7BpQkLQ0oskIQlpcQpsXCShEwGBCQhOMHSWQhVUwJKyLJNHildqckIocBlWqo2LYFhdreuG8C1WavWtPnD6TxNJ2Z5/epNPw4k/B//7j+9++rtf/37v394+nQ8Hv/xn/5x3I3/6T/9RyJZ1tr1CRkIIPdkgECsvpIZkEQmVHC/MqHjWJETCSZOOeVKpADH49G81VqneRpyF6ttZnJz6jpkEuHgvuechWVaV2HhZ06EEbW1HgDQbpQ+fO6kdfvJVaOCEEObLJTeQvEibCq+WFtf/zCcJajLXTfs93ellFLK6enheoMNUUAB6yd+jmg0NWJi4wCEEXFoX97unIiQctfvur4Heikff9V4SZF/fZiW88PH93/4xzKdGLwbupxlWRZ3J3NXa62xSE6bv4oBUWJmRkJyWNf1cpnMWkoizJS7KCqXZZkuF2KYp9ncj8cjACDSuB9a05QkHAiYJTa2KV1lX50MQZCTZGRBzsxEkhwZWQAIkA0JkJtrbSsih8B4C/1qBEmJhbWFy6F/engotSzzUkvrc7fb7eZpenw8/fEP36na33z99d98/XXXDf/Df/gfvv12+PDhu3df8T/94z+9ffP27tWh6zpYoOsTMoFW5kQoiDwtCwAwb43qduBIxLwB14FECJHByd2/+/bbYezDGndZFpE09MIsThYuXa0pOiBim+d1XSX3cF0Nxz7HARBdtZqZI7lrYArd3dyAf2SmF4rfTISIamq2SUuY+/cszm8uM13XASfpc9/vhmHHImrrPF/6sBuLLIp443Q+79PVVJANUdWJ4LY09y+h6cIMIvCcWPNSQv7y8ZIi//qwVv/pH/7X6fTerex3mRjuP35Iksoye6A3HMxbM9PaAKCu6ziOjPjw6QEB3LzVAmCP53PXdaWU+TIFDrHv+9P5kZjQXbUlSefpYqYhSJ4kufs0XQ6HA1z97NVbSoicgCFJAhZkBiJVdXQ3YJLUd+DogITMzAHjc3dU2rKkKxOTsGkDR+GcUrcbD621T+/vP3z43buvvwIgbaalfvOHP3z7xz/+n/7n/4V3x8txvVwuK1Mp5el82t8dY6eEBa8T0lRK1VKvdGxGREcwc0cA95Q6M+i6wdRUdRh2NfVitphepgsiivC420UpBgBv376dptlMx3Goa1mWhYjihERxrFdqTeo7JhrHnVllFjBHQQADZ3NlZNtU1z4LjLs7JnbzqhrlYTMDs2vZvaUlJlbTnPLucJdyb0B3r990XdfW9vp4+C/zZeiYVt28cx1CsmTc74MxampEgIjLulormWU39CKMYOjA6Ip+2/8oWOo7aGb0Avb5VeMlRf718XR6mJ/ue8a7d3frfP70/mMY77mDoQMAA13FrKC1zaV6WRZ8Zp1a6hKXXM7Zmn76+PGKSQYAULVa2+l0cvdQJg9kc+Y0junx4XG33/d9724iKQxblmXpmwEJckKmw+HOMTEJcAInJgyPVHV03GoZZBSPHtOmaUkp5Zx54GVZtGnTJiJ3d3e73fjHb79193dv39VS1nWdLtN//s//+d/9u3+33++X128f7z/CHfzDP/zT8XjcH3aiZqpE0tRyypIwJ/VwqTZHRrgO+IJFGSa64MZMjRKRAHNKSbWqNtV22O3j1DDRloKR3DbeYdh5c9re0m5OG+UnJomhN6H42cdc/yWUD3wW9HV3Dw+2G2Lcr17nRNswNOesCK9ev0VOiLzb92ATWNE6C/FtT15bFWJXM1K69vmh+2sAsU+Ppjsegm+zSGB1zzm/7LF//XhJkX99PN1/uv/4ra6X+eny6f7D2CfwZrc3O0BQjm+3J+J1XcPrKjS1SinuCIgfP97P03w5nXLOTcthfwAidVdtpcB+v3fzlKS2au6qrZbcdd3+cGCmWgoAmC6UhBNGA44M6IbK67qKICYGVYitKQMTg4Ph1pASkvomxLCTbOYGYJvtopGqq+13x1JK6rppms5PJ3fnlF69fnX/6dM377/7u7/7OwBg9A8fvgOA0+nUD7kyoQqwuSGSSeqk02rlJtCw7Xaj7mNCQ3cCqMFo5NQRtJSRCEJAk4hiXQMA67rGWlnNTC3nFJqb/KyHJd4WzU116FkRTdVBc95ekfjt9waLEbf8qKZJBL7UA970LrssnHLX9eMAkof9DpwERbKMwwAALALtcxbWpt2u24a/MQRwxy9rwpuiGhHhbW+OZMX7foQfjEFf4peOlxT514S7Xk6P9x/+cD49wHJZ58vdfgemftWiNjdEVPObRXUoeM/z3Pd9cJZNrWljYhZutc3zLCn1fc8ynk6nw93e3asqAJRSNjKytnfvjrU2c1eznulaYA5v714reDNore6GkYiQExC21lqbfFlEOgNESSlXTp1TNNoOAIYOuC2XAYAIzTykwJlIiVwcHfq+J6I3b978/p9/N8/TsiyK+O7du48fP/3xD38Yxn63O9Zawx71PC2cOnJDU2+ekph7Tr221jTctLfVBwC4fU6WRCzMJl2STq0u0yWcCJOkqB9jYzPPU9/3TNJM3Y2vvMDnsZWoUQkSq5qjPxd//JMvMQYT8fkP4yEiPxJJ34+E2Pd9l4fxeFdVh2FAZDCVlJhl7Ppa5+sdekDUzZSA3c0C8/SDaaKaIqGqDjkbgrszilnLKQMRvkwff914SZF/TaDWcvru/tvfqpZ1WWtZT4/nu+M+p7yuRVvrum4tdRiH1lR1Ph6P83y+XKZXr19dzie4+o6Ow0jAl/N56MbDv9nN8zwv03QpQP7hw4f9fr8tnYk5CeekxdURWcgBgO7vn1qtOWdt/unxYbfbNTdwerz/NOz2j4/f5n48vnpNkiX3zJAkoSRzWJbFCUWYJAOAgTdd1aA1ZWBJQkjztLTWcs6hvjHX0nVdgNt/8zd/8/79+27oP77/iIiHV3eXy9O4G8z07u6uteKEqo64uUF0eZjWJWmS67Nwa+C0dZpMToDmiIEeJwAQ6ZrrtMw5JbVyOV9yTityTGb7oScibYGVoXG3u700Q3jXMBOzu9dSmHl3PFzOZ84dMVnIVcRpxc0Y7fbCxj/X0pLBiTcO0m3/L00bJx52+6HvUzd0XdcNY+q6BASA4AAKmPr97vX08aP7DFt7bkxkZshAYElyWVcHlEQ55zYXFgbVwAN5u+qzleoIJOIYeub8mZP9kip/lXhJkX9NqLWHD394+PjH89PDMl069ru710L48PAQSmKI1HVdcKiHvl/XtTUdx4EQa23LNO33+77v1XS5TMPYiUisW1m804yIv/3tb91duvzm7nU0jEM/dF33+PiYc767uzvuD+fTqX/1qqmWVodhaG4h9LCuNSy6qrZSVzIDABOdTk/j/jjs9kPKVc0BrDZgdnRC3OxciC/nyzAMYXv94cOHx8fH3X53vDsu8xIKN13Ku/0emZjl8fEx7AdVW+zHzSBJ13XD09P5eDyWUsZxr6a11dpq32ciCqGdz2QSjz0xAhEANVNJ3I/jMj8OQ04CpRRJgubhdRjGXsIB78FlmqOyc/ZlmbXpRuBjRsScMzlkSU7EIizJPpduBH9SBeIm3oOITJtpZS9jN/S7491ut8/D2HUdSd7uKhwJEQE5pf4qrQbXESqbWihdlnVVM9pIk3Mg2yXn5/5iy7K0FmPaxMyS0ov62a8fLynyJ0Q4IpgZaPvw3bdPHz8s08zoQ9e76+UysfBziaz7+0+7/R4A7h8eIlmcTqf7h4ev374TlqallHJ4dViWZa1rqQsRIWMiliT/6e/+o5uv69plYeZaapAxUt9pa8iwlHlt9fXuTVPN4EC43+9Pl/PdbujH3XaozRMzszAzsex2qet7FiIETtkMqm6dJLM4AqImSpKktsrEkuRwOJxOpw/v329eAeYpp9R3ue+meUopvXp9nC5TTukmwTD0Q2s2DuP79+/3OwOAVhshqWvsQETEvKF/YV/lRATssHlyJUn9uKNP/HD/IGy565j4eDwAgEavXltsruAHfg9EFArqiCgpAUBTRZabOI/j58T3L+9rCG50QyIOnClTyr2ktN8dDq9edf1Iklgk0J2fcy0TIA597+7CTOjIzF/OHM1dmBGwlFJrY4RaSkrp+W1KKe5OKACQUuq6AX6kL3+JXzZeUuRPiNi0hI3y9PigtSTG3bC3MjODu3c5K6C25m6l1MPhIJJKKa9fvQoU5FrW4/E4DMO6ru6+2+3ev38/jB0zsbK7IiEhhRXqq1dvkDCnLMLTPI/DkIfB1Od5bk3VoR/3wGmZFs6JObnjv/3b/15VRWSalnVdd7vdeZpZzBHYzCBMo0jZc+qYiBNosxaaPwhEbGZv37y9v78HAFPr+z66zo8fP759+/bTx4+vXr9KksIHkYnrXMbDbn/YL5epamPn129ev3//PqWeiM7nqR/y6XQ6HA7MrKC1as5CKED22dYGAZGcrvwTEkBzQhTphz4LNm1PT08Pnz7td/uUs7vnnEwRMfg22yBSmJd5gfBIENnvdmamZqhq5uRI4mbVPQEKAAAabsLj8D39R3hGdxEWRCZiQOr7PvXD7nDYH1+ZgyOZo9023denAwApZ9NYtUMgN9HBwWPMkiQRQK3VtbEgAa7LHCjaAJBjFPYALJxzqsiS5CVF/vrxkiJ/QqSU4pp5/823H95/K6AGen740HVdKy1M7tVtt9ubWW01vF5ZEgHOl8lau9sfhmEI6sVuN3z89L7rsmolSa/f3D08nl7fvco5DcNIRMLJ3WN1O+6P0dAh4ljKsiyq8OrurtTSqQ27HQA4QDNAFkcadmO4XDXVnHOgkYehv0zTsiz746vVptI0D2OXB0FaanE1dyckVT0ej7VWFo7sNk/zq7s7d3v79VcfP3zQpsfjMaU0zdMAu67rptOl70cttanud8fHh1NrlUjWtfZ9L6lDZCHRtpqCOzIl9wbI5hYEPmIywFjvJhZrSz+OnKRVB0BhyTlXh/PlvIf9/nAI98RxGEotl6fT69dvSi2f7u/v7l53XZdYksh8mbquq+tKQ6+gQOiaU59Wd3dF4lD9UEd3hy9klTZElLAwU601ZwktpWE37o53u3FUc5LsSFcSoH9WsXAA8KEfIZbatTiZK2LCyI+MFBqU1jZFEmsl5axamhsxrcsy7HYtfgsZkXLOIAL4Qq35teMlRf60iJFSret8OaM20AYA6zzdMCL9OCBha9pqfXh4uLu7A4BPnz4tyzIMg4iEzsI4jGrtq6++ArBWa612mdfd7ng47Ifd4WYS22rNwzjsDtGiqrsbIOfdYWDmrhukNscUt7+J1sShiru7dsPIzM2g1CX1HaK761pmTtZ1Q2uVulEBmFgEW1MEvAEAD/vDuq5u3nWdgs/zxKyv37ypy1prjWmguRNxztmZyzJPj4/rug7jsCzLfr///e9//+rVq7o27SxGlqYBayFEUTMAxNg7g/vVMEbdEYCZJafL/crOu91uP44fP34C6JCwlmLGseCuraacHx8fA/vt5m5eSnE3RKq1EhGYB4zHrGldgQAoXXW7AQDcze0LO5gAGDETIh8Oo0jquo4kdcPY5QE4mdpWfm4mCfiFUBBi3/csXC+FTIVT13WACIw38kycZwayVhGR2N2haUuYAABUs0hVbbUuZU15+EXe0C/x5+IlRf7ZMIDN6M4dkKCU8t13363ThctqZtZq26QTEAmZJfjOzNJ3XfCsSynDMAzDgMzE1KdcayXEeVnmZUkpJck5df/+3/8Hd1fH2mrqchqkP3Yh02BmrVkoYOeck3SIWNvKKefOZJthbbw6AHA3ZgRIOSrfdV3UzFpiMiRTSxlLKbvjXSlFup6ZkYWogW0jwqCB78aduxPRtC7DMLZaEVG6tNZCSfpx8AWDydflLCIBJMwpmxmRqGNpZrbmoSdJJKSmzY2IHKGpRTcZupGGsKlXIBALSU6pr62el8syX6IezDm7YeBDc852NQg0U3dOkswaYFqWCWkQ5tx1Oed5mswRzd29NYUMeO2r3dzCPMKdgvPjjhh0Ht4SZepSyv045py7PHBOgBzySOCIP7QCQwegw2GXJDXY/LvhthYnMjPZsJaEEKBQd9vmtkkSgNVWHFlN3ZhMU6hg4F+EWHqJnzFeUuRPjuX09M3vfkeIZtZ0M2aiILsR11YBgIm6rpumKZgqQRxEREqYJN1//PTq1avLMq9rdZDjm6++/vo3wrmUUtWIUre7IyLpMiG25qnbuXvgnYmICM3Q3Fu1ruskA0vscwKf4mVZmSiEseEqhkgMbS2cOmGmxLWtu8Od1QZIiC4s4ERE3iDAh5EpdvvdPM2qekP8BKIz5exuxCnnrK0xsUgCp67rcs6PD49ImHL+zW/+5uPHj7vdoNoIkYgXM7ruLlQVeJOzVfCrDieFeyuykKS74xssF0k89r3v3VSX2rQpkSNi13W1IJgPd/00zywMAK3W23+/++67YRhSSkji1sAUvSGEPFl4xqo72mchyE3JQpgxIJhE67oyc0qpH3bdbkTE4PMgYIB88FaAPnPcysPoIpJ7q7Oaruu6O/Txq/hzdxdhMGdgsxY/CaMIAGitVa1AyAmFMyID8osE2q8fLynyL4vrNeCr1supTQ/T5ZRC5p8lC3ZdN8+X3W48n8+B+NHW9scDs3TdIMJaikHrkszz9Obtq3meBWWt/h/+7n9+9e5drW0xff3VbwAoFt8A0CH1Q9+PnanNy9JaRcRx7Nd1VW2C5MTq4MTnaWEGQmZBcu7HTba6teKOtbbjq9f+SIgYlq1WGxAv09z1mPoBANABmZJx4y2XDWNycyYexsHd11rcPKWURLY9hhNhSkLg1Pfgau6WU19aoyTutpT1/v5hWZY3b14BQCgbMQnChp7Z73bzsri7mjkEWYYQEIgZ0Kg/3r1bPv1hnZsQnB+fUs6OgEgpp1pKdzfUZWXh+KCKjygAaKpd1/V9P81zisK2tdRty2JEUjVJbhhqb+5AhGhb8Uh9nwHCncjVWnUnSaYwjPs89Agc9mSf1+IAgEAAwTaHDRsJmI8yvtHpzErqgEx9Sk5UdL2NZWKF4+5ICEbMNOzG7+HVAQCcunwAzJ9HAS8msb9WvKTIvzgcwADQkvjl6fGw26+X+3HYlbokSbW2ruuenp5qrV999RURuyTV5u6tVnd105xTLUWYSSR1w7Lq/+3//v/AflBHZNrvh9L046fvcuqRZbfbAYApFCtmptoQMaX09PQ0DH3X7QCAa0XEDfZoDWNfQJg5IWKttTXrM4nw09NTwDDdUF0BiNAZncBADcGBgRzsmYZYmOoQEACoKRE7OhERc6KQYGAAIGJmc2Y1l5SWZZnmy9dff/0P//W/jrtdLYWJlmXOOZkZC4skuGrwBB4ypge304yIiIwOTpD6QXK/hsQOorYGQECo0ADgfDoRetd1u3E8HA6XaQrkZtyPmg19bxuJ0DremmhyszCqdXOnW6bZFHuuc1i4rrOZJHdD0Xqap68O+6s00Z/NTw4p97vj/JHgyoVvquRODoZwc4V0c07sDqq1lJqSmMNmiOhgQCHghJyA0/cciV/iV4gXVvxPCHdAEtfGhI+nswJ+enyo6qF7eJlnJ/zqq69i8Z1zSjmLMJKbaSgVIgpwejrN3eHNv/tP/0vjxKmLYV8p5f37j0yp7/vdbieSaq2BDYouL6XEzPv9LqUMAGYqW2axlLjrupSSsMDWjG+tv4KRiKojck59SokQAS0xIbqaNS0IFvakjC5JJAnxpvK1jQ+IU5IkQZ6WnLKkhLTBv8NxJcCJwzB2Xbeua9d15/M59d3TdGlm07rMZW1m0mUFX1tDEQVHkWYKV4Q2QfSTV7cvp37cObEFuv2ZEFmks7u7u+PxKCmVUkx13I1R45pVs6bW3MPSy90NEQnM3MAULX6ot7vakuP1SExtmZd5WYIDXkp9enpqQYe/pkd69gUQbgzb0QFAEJOeF4SlFFU1dyJqramqxr2rhUyk/cC9GxE9SI8cCj/6FxIoX+LnipcU+ZcFGgCQANj6z//4Dx8/frfOy/k859SH9OHHjx+Jaew2FOHrN68lpXEYctelnCUxIp5Op27cLc3f/ea/37962x9ejftD/O3j42Nr7XA4fP311+4ukuZ5muc5Zn/H43Ecx5RyYF/MVLURMRK1WmuYhUnsFtDca63uzsJd12nTgHOXUlJKt1xATOhKbq6N3MgNwZBcZHOfMjW+WVgRiSRJKYlwfF2B0OYeqQuY9ocDAKSU5nkutTATMe93O0mdqS3LvK6rCN+Q3m7IJB6Cit8730RMBISSR8CkIeCWEucUHxf5GtNlCp32w+EwDkNoggOAmV7O55DvjD2+mbkZaCMHV7Wm8AMs5PboDqWWeZ7Xaa5luUxnVV0ul6enp5/wlqE0jAMAKGynSFUDzxD1aayPAG0tMwCkJFFi09W2AemzEw4Rhc74D/GbL/GLxkuj/WdiY00gABggQS0fP/5B6yyCbGKtlWZP99Or43G/3xFilpRYWq3aVAH6vkeBWuH+/tObd19PRf/mN/9+ONwhp/M0L3OptfbjvksSq+ppmlX14eGeKFS2RBJP0znyIDBrVdl8GhSJx93OzEwVwJgpustlmsNj9grkJGIQkJDsFUJXd20O1MqSugFcwVHVxqFXdweP+jGGYkwEBCET1A+9qanZuBvnab56ChBA9Nvej0NzrfMiuZ/nmdzff7xvbnd3dxtm0zDlXpelltZ1Q2uNSJe5xKraEYMe7WZEJKlzzpTH5K21ZZCOmNbSLtPUJzbGh/sHM93Jfl6Woe8v0zTkblLVqnOdxt1oagw4DMO0LMOAzc0chYcwHwcWvi6JgxTQcVrX9bzM3ny+XJzQCbsBmUmtPT4+9uMwjOOVaPjFWwXp9qN41/g47pDJzIGBKLk3d3RHXUvXp7Ws6CBJ+r6vZammuZNI3+GvaGCIjg7o0A0jwHUs4Ne9EL7YaP/i8ZIi/3x8fhu2Ns9PT08PWkvC2BcjIPZDn3IW5hRehq35tUtVba21qnZ88/XDaf23f/vv07BH6k6Xy1JWdDgcDsyUhWNzamZmDgBd1zETCzKR2mYnQMzBJKm1Lsty3B/8S8VDBAbwnHOSayNMTD+QYEWAaIdNrZViomhopNYqUXYKPwWAL+xT1N2Zxa1uv6INOYMIRGTKwulSzw8PD1HP/uY3v/nw6RMiztPc932rNWo5CAdtVTVDopRSU912F9ddL2xuB9T1u27Y1/kJkL77+Gk3dF0/3t3dkVuk574fWq2NuaXUar3UNTgtABAVNCJa0z53iJSScBJDBVfy77e1IiE3Z8uy3H94cLduGNpahFNj5qbz5bzOi6SUpPsTbxhXQ2YAPxwOxFwABcjdTE0E3C2wR4gIrkLJWlNtak2M+r6f1qJ1ZREkcQYiJKKcciyGiH8IMnqJXzBeUuRPCW9rmc9PD0zAAHgtJfp+N/T9dZ1axjyen07H41Hd11KamTFfan339b/N4yvi7uF0bq0Jc85MYGBeqyFSUHRzfgZAMW/Q3LbMQqpMP/6SIbC7A2jAUczN24bRISO4arXe7pk8tgGAbrUsKMnAtXbSZUQMYdrn+ZcMVJsIqzbcFGzJwU2NhTbTK8IoVJnlcOgC0H48Hi/TaV3XeVm6yyUdmJiJyGvV1p7PASHQMPRZw1E4Dbt9vz8u04mdXr96FVY3hFhK0dZYBADC7iUGsDklJo5PkVJLThkAaq1D7tU3yiP6lmQo8OKbxBm5edX68PCwrquZns+Xpawpp6bKqmratD0+PnZD/6dT5PXp4OFwEGYmMjdVBTMzQwU1w/ClZCbiupRSqlkFlnVd1UzN2rrmjjyAmUT90MPmNCsvKfLXjJcU+RcHAqSEDlrXnDO2SlfghQh3XQdordSU0uPj4253qLWW1opWEkk8/Hd/+99JHkvR0iYiGocR0FpZuBsgJkxurQEA0HVjoGoOLZxFo+c1s1orESNS6E7ij61Wa60hLrmua3jVxw8Ph89VZyyCwm+2tJKJTL21Jh0E/zpWHLf7DHi8mxMx4SakGDS+7fSga9Na67u37+ZlEeEk6XA4PD09MZG7z/NMiIfdPm4fUt43wXC4ZmRTBQBzZyJgSP2Q+8EcEEFSKvNUtdbWhGAYRmLaeNBEOeeg9CFi0zZNExFhh+5erSVXbbrimhyIOjAF0u0Ark9hXmYiev/+fRL5dP/ARGPeMbG711qpsLDM8zwvi6QuyReSEz8IBwjXyQRA7q5qV+d10NYIWVLKmc20abjyKjosl2kYx5zzdLlYDtMKA4CcMuBmVROC8S8w8l8nXlLkn4kve1Rc15Uc+pSAaZnmWCkTcaklManWuoY65DQtRd1JUkfyb37ztw2pLGs4WDGC1pUFu66ra+gJchIhwnVd3bXrus04FABAHZiAuq6b5jklJA7gIIWGLzESs18XnVtzzQRqZs1sszpprdRlzTkDSWu2tjXnzETruo7DTh2ECA0RkUUc0eyLHh5N0c3dyI0JyI0c1JwSI7ojWLO11a/+5t/s9sOHDx+WZbkss7sTUykKsAgnNzxdzq9evXZ3Rwhv2Giq3X2jqoBb8AWBdl1Xi4+7OwBC5KfTZejSmKiUomaLWuyTxl1v1qbpBABqVlVFuBuHUhcgr1Za84A9ZW+EA0Q5p4YCqiYChNRaE6GHh4emBRHdNf47zRPVQomLFiLuhvH8+JRSyodXcWaeJ6rN8gEB3BFxf3xF2CMkBiMAJwRCCM6BYS9MxK2W0I1nRFVFIm2NEx+Px6qOsCEniXljd32pf/4Sv3S8zHr/otguA1MirrWiQ5mXcLh+8/Zt/LLWWlvVpsuyrOvaWlO1lLquG9xwuiy1ltrWUhfVuqwTb/w2DDNXADBVYUbEeZ6eP/owjiwSykAQMtpmiBjdaxL54bTR1AAo5BTVVEMVx4xFhGUzm97YOKbWMFp0B1f70zvTgMVcgdYY/TUABIhGRFpt4zBq02meuq6LpriUcrlMl+lyvlzWst7gh8+77IiACsY3S23LWolSN+5Ls4080zTE0BCx7/vj8Rh9MbPEw4lwoPchMmZtAJBSEhGRlBIBgFmNlbFDA4BohD/df7p/uF/X9enpAXHDGBFB13U55RgWt9aaaq1Vr8SqHz9LkfRJXr9+Z0o3CUtzD3vJ9GyUISnJBlZybU1rs9pi4e7Xseztjv/Eg77ELxEvVeRPCfeu6w6Hw6ene3Pf73ex9Ig3t6mWtaErTDAvxREw524c3rz56v39R8A07HZZUmstYIMAMM9zn5O7m2stZRjGy/ni7sMwXNMyAcD5fDazEDOP6VvEOG5iX/ashHR3BAoeW5KuYQl17sBJmmpI58ZsM/7KzBAbNDBrta0ukpngmS2Bud/mmGZGiNts9EuH1bu7OzNb17mUEunsdDrt9vsYSgZc/NOnT/vdrsvdc7g4PGP+wQYsJ3Nb5kUIp3VB5JyyYEN0JOz7XrWa6XSZpss0jF0MI3VjRm72W8KiTc20u7nVAACAEDYDRGTAgAe4e2ttWZZlXpi4lpK5Cz9rImImpw1IFPbW39uSfS8+48/Nj8dDv9tRxXk6pz61WqNBzjm7ebWK7jnnWt0VAaC2CuboamYGGwCLmO3FD/ZfKV6qyL8obmuO3//ud+fzpbYaJlOIGHWfmgUYuDVf17qua2t2PLza7Y/vP35CYABg2ZbLwzAAwB//+EfEUFSt8zxfLtPT05O755xFvvjomudZmM19XdfnP//w8UOt9f7TJ1O9uUTFrkabxl0RxlTRmTjnvK5roAifX+SxY7XozGt1ba4Ng5XogA5hA018Y6Jvz52f2d5HCRnZn4V34+7x8XFdV2GptTZttdVpnudpneZ5LSs/c5S+VUk3Zl58X2pZ15WJ+nGoVZ+ezk9PT8uyEGHOKeccjbYwR1EWKMgoGIk5imhzV2+tldZaa7XWlpIwoKvFiwIA8TnzcP9wuZzXdWXcnqpcOdra1NVqK7UsAGBNgzr55943+OrNOzNt6ojobk21NQUAkYRbqrWUKMwOEUCbqhbV2rSYNXcPnvhf+EZ9iZ89XqrIPxfb2jr0fuDbP/7x4eF+33VC0OeultUA0D3qC0Rs1oDz/nAHLJL7ora/O5rjuD+aoaslllaWx4fHu+NxOj/1fS+SwgZ6XedhHGpbWTYbqQ8fvhvHwzD0AeqOAIBlWeZlGYedaht3u67raitIvs5r3/fLsiRJIROZkjJz0N2mea6ljPt9pFq/kopPl4tITtKVuvSSOkJtRTg3+9xLoruBIzgDAqCjNDZTC1OzVqtbXZu7+3maWfKu3929evPw8KBeOXVm2gzYYBS+nKfD/q4W7boOCaPe8sB1w7a3CX+CgAEhABGnlHI6oBuBtabEoE2XZe77oeu6ZV4ul0mEp6l1Xdf3w1a3MtlqSZI7uDaABGiXy0Rpp60lgLYWR6ilLNO0TDNjGIhhIsmhHCySAw3aCko2tTJPeDzinxpHfFZTzzkDbAh/kuygoZbbyoKIaGDuy7KAKzkoKKGn3Fmr0KC0ksxJEo1zlwdweikkf/14SZE/JVS7lI/7A5RTTvlyPuVOYl9pZsEm2+2Pbg7EwALESbrHp9NXX/1NKYVIwEHNRJCYSi21tnHkZVnGcVzWSbXVUtTM3aNsdHeztq7rOA6ttWHoAUBVa9vEJohpni/CDGgBtTOzUDBTUy1fIP/meTI1XGZVDeUhc1e7ekwjoKpra2Vxd+wQm145daTgzRTdwWlzeN6W2h6Gt6b2vBXMOR2Px9/+9rfMgoRgYGraWq3tcplOp1PUegwMYe1CiJuXt5vbtjgibq2Cgak38/ly6dizcM65lhUA1KyUcjqfa62vXr1CpJxTTpuE8Lquu3EcxsFMEVlV13V2IkrsXIHQ3Jta03Vd11rb4bCPASQhWrOcMxK6KqgRk0jX5YG28pmI/kWD2echXQYkBSfkTbYCAABqrUQoiIxoDmoWNWPf90/3D/ux3+/352kprdXajiKO8GKi/a8SLynyp4R7rS2l1BpN80UEmXmazpJkmwiqllZrtSQ554FTd7pMu91xba3V2nXgDuu6qjKA1VqIaS3zMi/9kM1azOu11UbQ9wfVNu6GnDoiOZ8vwzBM0zwOVFsDAEnJQWspiFhbEeFSFyJUbX0/qnprzbw9bwb1mkNhMxtAM7RaWXJo3ZhVa2WZLgCQmKxt5oAGZOCI4BYolI1ZvP2j2/885xGmlGJQqzYTYnM3a6VAETbTp9PTbtxFP46OMdMMBM+ty45FFhGhx6SRU0rWllrVzFKfUpKgS1dt3dBPy3w8HltTxHb7mImZaSklp75ZBTDkkjBhCk9xEObzvJzOp3VdL/McsnV914FT3/fRy5dSfOOs834Yg+tJ9H3S5I9G341O6ObI7P5Z/qLWgkiYmBxMTVXjHHYpj+OI6Pf3992wY99Qn//tb96X+OviJUX+lHB9ujwudcnoTg6A58tT8KBjPRIZBRFTN7y6e1OaE3Huu2VZaq2SEjnUUtaiAJCEuq47nx7V7HJ5ak1zziklu17VYXZqpn3fq8qyLPM8IzKFG3bOpno6nd599UbVQr0856xqahqMQHIya01LHL6k5G5ExMyRlXxbQ3OsfQjRXVtZAMC1A9PNbwsJEdwJLJiKbtdlayS1yJKxl99+7t5UmWVZzqE1qWoArbbq7pfzOVrpruuSpPiemIjJPfxdDAyIiEUcGiehxHUxcGfhvu+XMjNTwD+JkKiGPU6WFGNiVTsej6fT2UxbUyINvCStBbmDuroBtvb4OJ/namZ934e/o7tf5rnPQyTFqjqOY3PT1nRr/wn/4uFg6jIQG1JGALBt+29GigAmBE0bWFPVOG+llJylLJOkNE3nPB7cfbpcAADMX3YHv368nPI/F9smcUsoIagzlxURVevQD6p1Xi7uqo6Hu+PT4xmQd8fDUlYWPh5fXaZLLDGmy2VdV3Ovawtqcy0lxL0f7h9SSgBUq4KTGszz2tRr1WmeVRsiAFpKkhLXVlpb7+8/wJVHqNpKKYhElACg1WbWVHWeZ0R0Q3d/enpKkrU5UxrHfa1quhVrDDh0PVpDMLcW65qHTx+tFXCd58tyOUFpUJtbDSQKogsRARJD0wJoSRIRsCCC1WXWUrXUeZ6IqNYa1mbMIpyTdOAEQOu6Xs6X2CDdYPBNm+kVTq3NVM2diXfjDpH2+/04DJv3w7wQU9d1Xdchbuj02G8AQC2l1tb3/d3hSADEkBKP3bjbjWPfk6loactlvpxvS7Cu64ZxOB6Pd3d3Oeda27QurbVSCpqzyDgOAGGl+5ddOAic8uFw2BRGEICo1ereRESEQvFcVd11XVcicNdlWcxdWzscDkjurizCP1JI/hmH25f4WeKlivxpoa1pawDQVE0bKbTWuq5T1a7L9/cPAHD36q7VRtLtd8emejqdD4d9rA5igBV7WHdTw8tl6boEAH3fL3NBRgCIDTMisWwbVQBIkpIkxM1hMUqzOKrWtB9yKdVMd7tRS9tWvSIsnCEDSillo7LwtvDZjbuUJSaSrVaMy1j1JjAzzTPTuizl+OpOSwEWo9hzEwLFg0d2Y2YmPp0utVU3DxVeEck5q9nj42POqeu6lKS1hois3FpD9Mvlgog558vl0lufU84pR6aDGHS6oisAODEQA5BIyvuEDBefAjETG3l3j6U/IoqwpCSCtbaA6ZhaN3Zd6qwBZQhlI4Ymidhu/oWfB4sBVED5MYb7M022PxtE7MiE6OaAoKpNG7GoVSYGtNBAcwd3dZeUxFXRQFIyNwA0U1NN6U9RHl/il4uXFPmTwmorddP9X00rordWhmFnZu6m2v7mb/8tIiLyu3fviuqn+/tXh2Ot1QGEkBnMKosQgrtqg1arMOszlCLERQgMAOYOZrHvZhFhbq3GzE4k1VZi1d5aPZ9qra2UxiyllowZMRSyw5Is5dSbG3ty83makam5ghIRtba6u0gCMFe8SYQh0ukyDbtxvkwAINi7kyKQRIpvqjXSLhNH5VdKISQmLqUEWdu9AsBlmtZ1HXe7PmW4Wl3HgkJEiEhV52m2zm7MIoukpw2hBUo0iSx10boC2PG45yxMHMRMd49etZk2NzBsbgkTInpM+pYlJbFq7tiPu3g1IexkzWMCGrgbw1AXhu012E7FtmcJMTgWiXb+zwWRJCRsbmBNiFprpdScJWYLIoyExFxdPUYTgIQEaIRoaoYIamoG8nKp/uvEy3n/i8MBAILZIWBN1VojonDdAqB5mve7IwCU1l69fn2Z58fzpe97YV6WmRmEU2xLMpGaUUCyic3MzedpuvlKR2GlrZVSltZSWEGVioSM0g99rS3QzsyEiK2pmQaSHBHneY7KbmPROAgIAIzDuNLq7uf58tVXX53Pl1rbfr9TNVVNKZsZUGhxAwDM8zz2fUr8dLqwMCghJ3R3RWBQq2YWLWTTFkijeZrVtbWgdAMztQbT5TLuduMwMG9VZCgnIjkSTvMUDOvaaui0I5KaurmCa61MRo5AaAjBj+y7tGod+oGILtNFNlx3JB0hxKa6zLO1wkRZ0tAPhhBe2l2Xn5MGU0q41tCqvf3QniXH5/uuG+UGMXLmn9ciQ0RAvp1TVVVt6GBmHPY1zOZEDh7+h4BmimE4BuBIG1D0BRr5rxQv5/0vCwcAwL6HZjH4O0+XZtDMUpdzPyLzMOy6riOSrhtqa+YWqe10PiGSpOTuD5/u+9zVtaA5OgjS27fv9vu7vh9rNW1GwGYunJa5tOZEKaf+cLhzx5y7w/6OmIZhBAB3r7XU2oi467rdbt/3fWstiHHutiwLACzLYuAKLl0CJmBy4tZ8mtbWzNTXpW4eNIShOpESm7VlmVhwWabf//6fp/NTSjzPl2k6mTcAu47wDNTQvJQSSkL7/d7MTufTXNZ+HJjlw4cPd3d3+90u5QwA4zAmSe5eShEWN9em67ouy+LmiLQsS5SlSBg4KlOf17ouVZubY4wC3bzW+vT0lHOuawMn5jwMOyKal6WWknMO+TUiMrfE7FUBoJTSVOf5Mi8LhDxEaHmbBrtmWZbACdxe/PgY6LqOiN08hEH/0ncOcdd1pkpIy7zE/aiqtRaw/LKsVhuY97mzqwBnjFOIKOVeOI3DAIgvJtr/KvFSRf6UWNemjVkuT+sw7IQwJSLiuKK6LrOINiWBVuvh+GpeSgyh+rFvtWzSZETzPN/d3cWl8r1HUDMidvegGwJADCKfM5HDY6AGJ7y24/GYc661RhmlatqaMgcK6TLPBtB1AABlmRGRmPtx6LpOmN2dmGPdHK1xSvx0egCA3W738PAQc703b94s64puwqlLvNYS2EDEz+UbAAiLqd3d3Z1OJ5KtLpOUQpooVhPvP7zf3AT73qzFBh83pR+L9XocCRJKkqo1unLKfct9nQsi73bHbP3p/Ljf7wHgzdu3AR1d1/Xx8dL3PTDPl8vYZXNvrZlZ8Hy2DNU2SLy2BgmIuRMx06jNzXTL4CIxz40bEyKASabE8gzD/ecKSSTmjCgAFQCEGNyyCAMwEZqHx5iZuiqahwMFArqjSG4AktK8FPCXauZfJ15S5E8JxDdvXv3+v9ZxHBmd0RG3RiznzCTm3rTtUpaue3p6aqqkOowDIp7PF+JN5ixgN8z8PQZbbbW2mnNe5kZMNx40Il4uU2v1eDx+/PiJmfq+Z6bz6RQgkrjISikQiMIkKITgyMzCkQRDSC0k1FJKJEzCwcjLwrWW1rTWYq2llJKk8/n8+Hj/9de/SX1nZmaNKIaGVmtF7n54/M/DwpZFGxOJbNZarekwDNE5llJYkJjWdY0xLrOklKJkCw+0MOaGsLIRSSKr6XmeAC1n0abSiZouy0zEnz7dM9FuP7S2KaHJbqi1FXNtGogiVUXCAJYCWm3FxYmIEB2o63jDe7obeDPbgJnoIkToABC4dGbSwH392eDUdZ0It3V291ii5ZwZXFJCUwO4Ee3NDBACURTZeVnW5vNX//4IiC/Umn+VeEmRPyWIT6dTKbUndXAzMFAAGIZdSsnU17XevXk1l/U4jtN8SrmvtR6P+9PppNqQUvhTHw4HBK5FkcjNb13bOO5U2zjuwg/2cpkAYLcbH+4fSi3H4zH4xWaOiLW2lHP87bquRHyVs90YJkradZ0kYeJaa2uNRYi5lBWuQo2quq5rltFMS6kA9bALaQw9n8/jbgSwthYASMzESc2WZalNe+mBOJr6q2oaNW1m9vj4KElqa63W4CMTMRJaUzMNPHgsu5lIWGqrbW7TPG+kSeFQKR/GIUkSIhBkMgdvbn03JgFhLtFKa9uNu8vTadX1cDi0pqfzOYkMw5BzJmL3UmugUFPOuay11abmJAIArTXXCtqUuKn1SZgItvqXhDkKT75uZpBQREjkewJof1K4kTiLE97UlYRYWJiAiaJijToXrts5x9D89aenp+FwnKuOw/CzvYdf4ifGS4r8s/Gsk9J2Op3GXW9zTSmVZW2tSEqbLhbx7nhozVOSgNQ08ySyLAFsZAQmYUcCACeutbIEZSPck/0yr8PQL6UG2rE03e12JNmpjPvjWm3YsSPPa0EWVTXAlLtpKSn3ZkaSzEwdtXkFq7Wqetd1zKmUBkBJshu01qIAXJZF1XLOqi1MuiL1iEjM+BhwviycBBFXq8iNU4csr169akYO5E7A5E0jUbhh1w0PT78fxkFb++677wxh3O8BaC2llNKnrh9yayrCXd9LSq0pIBPx5XI+62KbMaEHDsma7vbDq8P+zd0uo4K7g7dqYfSaWHpJZanDOOScW1PVdZnmV69eCVFZVuwTAMzzpes64m1kcblcuqE/X552hzu2th/y47QWp+CwJ0ZOnTBvUh1MQMSpc/O1tMzdq1dvrlwgvtV1f6IH1nXuug7AkLzvBncbhh2iM2FT1VbNXFWJEYwdbN+Pta0ehSxRUx2GHSKB+/e9s+OD6aW0/IXjJUX+hPCmoQeBhLVWM0XEJELEAOSG4SuATqE4wCKEuK6rqm0Gq8wQpDT3uTV3Tn0iZncjZCJIKQcBJurEWuswDDGqY6awjY3pWNd1sR9vrRJhXGkAYGZhs1drRcTHx8fj8ejuRLwJbbQGIWnuDhDCaLE+BbjKggUQZ52Xvu9TzrGyl6ABSmJEQFJAYRFWMwNzIhrHsdZ6Op9yTo+Pj6fTOZAx87Ss60pM42EfSjlqtq5rKTVGBK1p3/dEWivE502rNXjTp9NjK6/PDx/bcvkf//vfeG0NDID6LgtzjCNyzufz2d2HYRRkJo6/ZQZz31QmtYWTI6ClnEdhEQb0VpbEqOZOoGpmCLUac/huI24sbCQU6fe7XR56JjKIdvjP56eboHpOWZBIOOcsBOEwAcrIihhyPkystdawBntxy/4/SLykyJ8QpS5NS9AMr4wL7rqOiRCpqpsq4mcNxZSSm5WyLRyEGcPkhTl8nymlEN0KgVogIsLWXFU3y0OAWmvkRJG0uSkQqWpKiVlaW2FTydkYbN9bAS3Lst/vEdFdzYgI3Lfbm4UL9hf2zfEZEEPAtkFwEBGZUxIJLHutFvRpZJIkTY2wAUMAenLKT09PtbZlmTmnVmvMSd+9exdqZIjo6su8iYkF7e/jp4+wafzoBnEnjknrhw8fOvKvXh+fP68YbtbatLXTqTALIZpp7LhCcHdelgD9qKpXZ2bmJCyPj4/jYc9CeRimsmTplgKIJCLkoGDWlHIKZCSBWW3I3PX5q6++GvreiQj5yrv6M4kMmU0BEfuhr8u6Mb2F2trUWvCyaaODQjARAEBedjP/h4mXFPkTorWmTd0NAWq1zEgkSTpiUgcFdwO5iowBACIu6+puKXUhaEjEgeeITNEPg6Fd7WWoNQ26W4wIU5KU0rqu4fXKTMtSU0oppVprVJruFtuDWyXo7nEbAAjj2a7r4m5zltCGYCYzC5McZnqmebZVkbFtD4l10bzb7Zptv1Wz4MIhIlFiciY1MlMjok+fPomwOZXLJecMzE9PTwD09u3bdV1ZRM1CXWItayklWlpE3O/2yzKfTudlmeGKRnT3w25MzHfH3fF4yDk3aARNhLVpNW2qQe5EVGIxNRm6K2yIaivOPvZdKQUJY7wgSaZ1JcS6rIBTA5e+QzdG6vouCN2qDbwhMnkYMnoSHne7ftw5IQIB4l8EmHMKpA4h5pTOj09ZuWkTprXM1lqtq7fKBMTblVhrZRYDYCZA2pbd/iennS/xS8bLp9VPiPfv39dSdv3eFJgJkZubgp8uczMLFQuzq5wXYZmnLktruhtHAGhNSym3ci/A4bHkAaCcc84dUQIgVd/vju7B7yA3zKknknHYj+OIiH3f932fUlLVG0Ou1gLXPUxrLX7e931o6M7zHIl1XasES9oJnNZ1nabJ3d3wclmmaXn96m04STAJQGzP+TYi9KsCWKCoIx9J7vthb+CB7r6czyn3BjRdZpZ0PB6jIF3XVVtrqk9PT6fTKaxip8vl8fHx6enpxpU+nc4fP346nU5EhMg594e7V4fDHplyzmpAiE1ba84ku3Gfc86pT7lPua+lMFGrdVkWFk6Spmla13We5lJLTGBzlk8f3wOAuScmNO2TgHldZzBldCF0bQSG5MQAaO5+OOy7rkPISALAAAiOfx6Lo3o6nQ7HY6mlaVnX9fHT/el0Op1O2iroRiSty1zWmT5/NuA0rUTojqqgZuB+Exz+Zd7dL/Hj8VJF/iVhAAQOoAYAtVVXTcRNlYGRyQBUrar3Cd3cyGMDWluFcE1JaZrndu2dh2Ef+YuY9XPmcWEJFa+cclMdx11tVViC3B0FoJkNwxDtsJntdvtpuuScAYCZRTZ8z+3QN3gNMzMHErvrumWZxyv+HBzdABlxI3tI09a0sTA5IFL4KTqxuaMbbFmS3CHYNdcr18KjJtCaZV4DWxMz01Zbay2lxJz++MdvSt3wSc+O03LOLOJufT+UWpio7/su5ZwEAIp6p07g7r42HbuBg8CHWOoS3g/zPHdJ3F1SMrOyrp49MW5l+DP5suPxmHJ2cyaaazVHQXQDa0VEmJEIhMBN67Lm3f74+s0wHiT3yD9RPALJmpZ5WU7nuqwVzG0F78HUhNwVHK2VOIPaGgtuLyChOjIAEoa1xkv8q8RLivzLw5oWBlxLubWBScSacqxW1Pq+NwTaNBYBEKs2+TH8YDTCapZzii3K7VfBPmzzPPR9kPNos0TYpMZyzsuyiIiqdl13Pp9icJlzDuuF0OzaDtoUAAJyKJIeHx+JhIj1y/kjc4ob56EPr4iUUhBmWmvFSj/ub7fX1kgEwCBkvdXcLHredV2DoVLVfKM+w+l0AoDQ1Pjw7TfTdAGAUkp6xjs+r2u5v2eicbcLo4XgpC/T7CrzkjLDvhtTStYE3JhYCIAJkQYZQz6DiJqruztC1ZZYhFmY4CqJVGvd7/dPl3Pf9/N8RurApT+8Y+w/PZyRlNysmbAIbQ2yAQ7D7uuvvx73B04/GXxT5nndYlY18wau5NZlMsPQGK2lIjkiE5O5qzYDIiK1mrjb2PQvm+t/pXhJkT8hzAzArFU3L1qTyDDs53llJle1ZqqA7ODkuCmnRfMYg8W4k5REW8NIka31460kdEJ3N2GJJAgAIUZJn7nBJEJRGO53+1qru4lIgASZhZkRMVbtiORuMaoz0ys52oahiyY3jsdBg9IDAKrGwtpUmw79oKifMefhfYoQXonWGgndTAzd3dRKqbWU2lptNWaXLHw+n0Uk5byu64cPH5+enuZlWdf1zevXy7I01YBPxjEHmPHt2zellNPptCzLcdxBkiRpHAZJKQ8EYLouzdQdyN3ZATCl1FTnaQpdD3d19+rqbou2dV3fvn273+3p/8/efz1Jlmb5gdgRn7jC3UNkZmXJrqrphhgAxBqMD8s3PtCMLwR3+e/yaZdGwgiSS2B3iYEY1apEqohwdcUnzjl8+DyiqhsDYHpQ02NWncfSyiIjvVxcv/fcI36C3DzPMcYQQs7ZeVdNVZIAEFRQBURTq1DZsdQau9778PzZ8832yv0NtHZQ5/mcl7nKpYEwNTEtZMFHEQFTUaxSyYi5gdih2mWdbWbIZAj/eU/K9/G3Gu9nkX+9QACEw8N9XlZVqSLBR+aQ5pkRES6upK0HbRQKMUxV0AV0gZxXICAm59lHRShSi1RFyDnPaVWE8zIpgiEI2FoyMGWpYsbBG2FVUQRyHHxnil03NInvZurAFxJhbTJiqrosCxEOw2Bm5/N0Op2Ymdk1xUmRolZTXgyk5XZyfl7XcRyKSDUJfQdMiChVqkLohrZJZ3beufYS9l1g21879m1yKlUbye90OgOAqEitKaVlnk+nqRYZh02tllLKOdcqZiqqVS5OjVWk4QSGvi9Fx2HTdYMPYbPbOPaKoAhFRQ0QmcmXUkXg0QkHhmEcNxs1886DWtd1m82m3XXu7+9rrZJLXlPORWuRuqjMWmewZFpVipRcU5JqAMyOb1988PKjj52LLgQA0P8CUPy3Qh/uv73fv5KSqohzFGP0wQEAGIkYAKmA42BmoObZNfiANKegy6iXfNfDY5+Bf316+Pv4IeJ9Ffk7RIPseecDGtrlZJVaQx/AQIHEFM08gAK0+o4fyX8XQOVlofzdUKyImFpKKfjmbtooarws4pyLsfH8tEnGAoCoIF4MDJ6G90229uk5W2XX1uINODmOQ5tIPuEiG0WnlZytPVdVH6M8Pk97z6ISyAGAIqjqdDqNw9bANUUFVTTFZZmbVSGiW5b14eHeOZ/rCt+bMK7rUnI+T1Ot8uzZs67r5nmaptRW5KYXE9qGZzSzVuQ672+f38YYcs65eBEgx+xDzWtwHcKFdokAIrXh92uVdV0BFNVqzrVW77kdn3bwG5i0ideZmVqRko0QUNJaEZkBjRjYsQ/Xt88/+/TzbrNrUpV/g3NmXWetxTG7rlvnCUHp8fACEJEZ0TBscllBVMWIHKK0nmFdV4/EzF3X/Q1e+n38IPE+Rf41Q5v6KTGBEho1JavvT/S+C7osfM2MmUspy7K2f2ngu9+YPBJ21JVSGoO4rVyYv3sMM+Oj0SsAqGiDgohKrfWpuPt+ivTe55ybYXfLjK1SK6UCNPMcVRUibvuftslhx6JaSm3pSVWKSJNra+iinLOIppR8/I3T5nw+V9VlWZo7Ljx5M6i24jql5J1/9+6dmW63267rVKUxyluYqVRFJKlVVZs5zDCOgSj4wM41OGdVjc4H31VKisBKitpkxEqpT0rAItVMAEBEci6llCbzEWN8dOy5ULFFRMUSLejRczjX1TkyJiTPPl5dv3jxwcfjzTMg11DiYvC71nCiYKYOiRjXx3MJ0apUb06BBCTnmlIBrczOx56I2QCYpSRWBUJ6HNq+LyF///G+0f5rh8EQu+A8qpVa6HF58p8BYTTGyzTN67o8odsuu2y66A4O/dBqhO9vottjmiKOc23T4hARL6aIpq01/e7x+PSwVrq2KjLnklLqur6BDUvJTfNGpKoqMzFzE4skohhjLcVMkVBVm2IQEraddc7lfJ6GYfiP7wrrurYqclnW+/s7Ir7IsqmE4AGg1DLNMwAg0m63W9d1v9+v65pSWtZ1XdaU0jTPzdamQaOWZQEANXs4HhTMx0jeGRK5wD4i+1SqISA5F4OAitS29vX+CfvJfdebtdydavsszbFHTVRA1Jp6RK1o4ggdITP70IWu74erDz786Or6Fpx/skDg3zVBGXhiRAcAbb9PT7Pb2sQrrDUEzBxjHMaBCNs9kgyYL5rntZb/wgu9j7+1eJ8i/4vxHcij1MJEtRrZBaotZobAxIjovTPD7/dERJhzaYlLwKZ1AcIG5pjXDMQK1NYjDcz4yGNxAHC93XUhSknz+choWrMjAFTPKCX10YOJQxq7ngGb8qDDi23pY09NIfjtdutcox5eOllV3Ww2Lbmfz2eRenV1paoIrlZFdNO0mqFjL4BVwZDWXFSEG/IcEQlrrW0XdD6fa61pLfN8WUyZ6cPDPSKb4rrk+/vDOIz7h4dhHDbj2LTOVG1d16dCMudCiNP5fDweG1Lq+vp66HszQ7IlpVyV2CMymPNxvHn2wWZ3DewAQEXMTESneVrnaZ2XsiYpFQDu7u9ald0ApK3CVVUpxUS7EK1KFyIZgMrYe0aLMbLvu83Vxz/58vaDj8LmCsAB2BOJ5nf1i9lut83oJi0rghJD++vljqil/UBEqs2gd3kSztgMg2fn0Hdtk/6+hPy7iPcp8neI3XanZk8UNzMjQjBaS5V6YfF9v6hsdJdLUUPknUe6FILUmIiE7bptTimNGd34hd/tsIma0CQitcxSakVE730Ioe1fnnBF7RW/z0EchiGlNAzD00q9RWuua5XWa6vaPE9d1yNia7TL4wa8bdundSHEWut5mp4W6PM8ldJKvwIA03RuoEh4hEOWUq+vr6Z58t7XUp1z87yklJr2ml1qYWkTSQBAJH78vOfz5JiLVAE1QnJBgeSiROyRnYIVbWthBIDWZz+iTB8nqVVaheucO5/Op9OplMLMjeAkKiIVQFGl5vX6ZkeIw2b30WdfPHv5Yb+9AfYAfw18+H/mnNntgvNaqmNmIs/Os2s9hIiWUpvQenuwiDA3EUlEZELXRDnfV5F/h/E+Rf4X47sdJjG1q9E7L1IvjepFJpoa9hC+NzAy00f5L3beNxVbqdKWyw3wqEWCc857QgzBMznvI190HlurxY/UbHxMKdL+/KfecRtEtiUPPEIpW+Z6Cudc03Ns1lrM5L0vTSvXuVaK/uazEl3kIUqDYZvZuq61ViZStRBCzkWkrutaSkWklFKbAEznSVRb+/+0xVa9SIpf/lvr4zqL2bkme/HRxx9vNhvvfS1lmqci1rbY5LwLIUttJeRTiiG7/GnBjpHQ1FrX3955u7WUWnPObVEGAKIlr8vQ9/1m/OQnn330yWfj9gb5MoJ8dMH8m0RbPdV2z2v+29Tk4FBrfjwUbed2cRgW1YZIBQDnPRLmXN6XkH9X8T5F/jVDAeGzz798+dGHAECPUhVtIumYXfShi93QC3yfMXL5mZmYqMGhn5T3n/57qQdddC6qGRHF2DddxSYWkXMmQAI0Ue89MVeRZV0vmowN8wJAjzbWrUBrY8vT6RRCUNVlmZ/kfNqQtJWQ7VOcTidEfGrVAUBqbVsaVSPCruuIXCnFx0COk5RUsqnt9/tpns/n07LM+/3D6XQy09vbm1LyNE1d1y3LknNe1yXGCGqlZBF5Ej2Tx83JRU6REOlSPocQ3rx5U6uAGhIyuaomgEAM7JEDuQBA7Xjaozfs4+e2hksNPjgXmPl8OocQuq4LPlwkMGpVq20hTgAl5xjjy5cvP/v8i92z58g/yCaT9g9HATMEVXXsmvAPIzriBjYwkSeMfYMZmImaNAXf9vha63/+Zd7H3168T5F/nXhEwjk/l5JrEbjwYZiaIo4EH4gppwpGQCwmQJhK9bFXAAUi8uO4a5xrAGAmNGG0Wsu6rkPsQghD3w/bDbkg1ZrGrUPSUh0xA/rmtSByucJzDo4QVLQiGhEQwWbotOYucBNFJ1CtUlLWUjsfUJUBGRBVT/uDI2IkreKIlmle5wUArBoqmmIVa5O3otUIh35U1VSqKoYQHHPbt9Rai9RapVaZ52Wa5r4fYoyS09V2M8Rw9+a1iZJB1xSA0jp0oabVpJIBqpkIGRCgQ/bEDNgQgsGH3XZ3vd01eGPOpWHmqyqyG8bbrr/qxi1cVH8UAARMURWfkIvkfHDOqULfj4isWktN5+lkVh2jiPQh1ixEXEXm8/STn3zpY4/02yjx70Osvou/RnX581/8vJ1CxPDEpidiM+37fjP0iEAGaNq8xWsVxObXSwAgAvooW/c+/k7iPejndwlCco69z/P0pOUDRo6999H5DqmuJQOAqCJKjPFpv/x0eTyC877bbaqa956BqgggIKKpNsTiusq8LLtxY2bTeXJIzntJqV0zzZHVGvnmey6A9D0yct91PgQmahvVpyt6u90u69oQ2sfjcTOOMcbDfj/EUURIpU3BmFiqOO+IOOe1VhvGvohZSSmlolXhu9zhvSfEcRzO56mKdF13PB4BIKV0dXU9L4tqYwpdlNIb2J6QyJGaElM7Vl3XlVIeHu5LLR++fLndboc+hhCkSlWtUlV8JQBzKSXJhRiqaZNwb4uVC50cQEUNGgWz7aysLehVVEjpsSdf5rXbbBujCUNnpvjDeWk1zrtXa2wkckyAwExVrMkEoxIxAjYlXSICRHn0KXov8/N3G+9T5O8QyP7Zi5f7b/9SyZsVfFRLbfYDrUW99I9to+K8mbWpH3yv726ARGRqsEEiQvYg0tYgACpWSy45Z5AGODcATWkFgBA2bQIIADmtzMjeETGzaxsK5otHcwuOjp0z/Q5vdPksDddZLwIJorrMMzETU0kFqzSXMXYsKgFjrWqKbdlaSllTmaa5lCoX35VLWX19c21q67p473LO5+ncBnCO+ZRSOw4xxq7vLyAYIuTLYaQLHZ0Q8cMPP+zHwTnfeDJmthk3paYmcElEXRfKMMiE5F2pWUUVTFUefXbhiaxZqqqoqYnIxbmbqOHvQXlZ89Xtc2OrqlZrSqknMrUfavT38uXL/Ztfz+wIazt6DEaggEKm2hCvUtp8sg0ciNiQxEzV3nse/p3H+0b7vxwKpEAAxD68/OhjQBf6ToGeUl7OuW0h2ib1wqUzagDp3+qSHjkejOCIKHSDCx086k2YKKqZ1Hk+revaFujruhJTQ6oHR6hitRBozmut1URNhAEbFFpV2bnmZtVkEVSkbSeY6DILIzpPU+PkTfMstRJiExmC3wR7EjVFWFpTIed96KpCEVtyWXMpzW2xVlUT0aurq1oFCRsKpzm1qugw9PvDIaXknG8i4bvdrmmhtwPS1lzU5q/M3vtaq1bZbEYA6HxAxPN0DiF0ITaGdcu27bCriGpp6e9JNklFhnFoD3aP23wRaX627a9t75TXxOTACMmW5QwKRD9Y6fDF5188f/68WUfYo4Tw5VbQ7pSIzK7h85+Arm0uTPSedPh3H+9T5F8R9r1oydGAFChVvbp5Fvshp8rMVaGKuBiIsFkJNngNA3axYYAjADkOjr2PnSFVBSA2pDWVquZCt7m67vvRDIdhiypacy1JSiKDzjvn0EwQcT6fYuCx79I8DX3cbQdU6YKreTWpqDafj2mZa15NiokwUN8PRMyPHtBtLd7yx7qufd+XUoi57zq7uFpzS+gXYl5Tk0VoB4G8q2jAripUtVxFzNg5EdBHtV0AaE6tTXbhSR3DITMiI5IBIk7TFLwPIQTvW9vbjMkAoMmtk0Ef4maz0SqdD+M4Xm93V5tt9MHMpJR283jKhoTYDwM7BlBQQwMyQICnaSkiqik8ovGfMk7Ouc0k8ppMhInP56n9029xsZ9Qq7/ruRQ34z/7Z/8MAKSKmgAAExPzOAx93zkCNG1admbWdd0QOyJqe3k0SMualsyI720a/q7ifaP9V8RvEAQb4RoAgWLoX7x4OQzDmR0SmtRcCwAZYWtR7VHRtsGDHbu1LCmlYRys2S5caDOh613wwfugAlUBANtUfl2TWjVV59m5QMQOSUqqggAQY1zX2UwBXJXcEOPwKGyDBooAAE1popSyriuRYyKpNYQgj/3+9ztueMxuuVkmqDV0uKo4di4G9iH23bRkBPYhGPHxPKW1FLFL2lUjQhETqW2JjIhNwAIA1Ow8neGiwb72XZdLOR6PpTkymjX0UpuKNgXyVpWbWQiBHnlIROAcMjvHjh3zYyUGjEOM63IuayJm+x4WyrGLMbbPejgcVJQYzKxIYecQaYieDAAVoEFBk2ppd8gfDGQTgkOyqimlLvq2mEIDrfJbFhpPJTyCKlgDY9L38/J7P6+/i/gDTJG/ZfD5V8TjySoKpAjWoDCmHiwO/e2LD95++ys2VNNSM5F37JiIidvqobWZDcbIzlUTZEIADh4RVTR0se0lXAgpFVFAUFFgx+tcU1o8U/CdI3SORISYreZS1HuupSiImZSaPfFjuUOiFZpeGZComBlpU0W74MBjjPqIDUL+jRlXc3kty+K9R7LmaYWIZuhdICfOO5sTcOi6blrSuqxVLKUyzYv/Xk9aqzjn2wF85IxrrUlqJmZEayVbM4qIMZ4BGvnRtfnD46Ax5zzNcz9N3vtx0xOjc46Ygw/syDti1zIkoCM0qlJNjYiRTOSyEWqptqPOEGrD+TOxQx+85KoqqkI+fv98yDlXEfhh1yO/CTtvKC4TyDmbVDNzjh8nuWzatl9qSKrVFIEjM6pejL9/44x9nyt/L/EHmCJ/I55ggN+PnFdQA4DmNGCKioBWq0jQfHtz2zYfhmhqueZ+2OAjE8YuC2UFgJxLP/RVNefiou+cb8CgxqdGJiQWyGpKoKbsXTQ7glq/7WvNiK7WimpqFyDhPINqaRlcavXhMdOhqpY2zTOUlBYmz94755tomdTadd28LI05w0T6vQnpUxXZtLvbASHinHNnAxKbIhh5FxSpqZellKZ5kSoXaa/H53GO53lZlkWkti67KZuVWglxs9mcz+ex79dlOS5L13XYNvdysZNutmLPbm6aGwQzEyIxIRoTsXPOYZPaJWrNLzDR+XQI0fsughZ9hBAikvM+hCBaLv4/aj7y0A+VcqmllEqueucJlAxMTfWi4YaIP1hfW7IIIHIXvkvHZioi8Mh2b1NIBDSzxjewx70fMyCaqAK+32v/3cQfSIr8T55eZlKrNZEIE5Vaz9Mpl3U5T6VkIpRSmJ2P3rOzXLd9MIXr6+s0HWte1bCJWj8NxdQMQHNK43CxxOq6TqTGsIuxFxFmu7q6qaUmKXlNT++EmZZpnpdl7KKKtl6sgcEZ8XQ+ichms1FVdljWorVA9CLFtFQFMGnmpSaypnJz06/ramYqVlTZuVKrmTXf2mVd2/zRzCCEoe/fvn27222cb86oqFrYBfZ+XTP7KCqIAdGtS56nZV1WM+28Eyap9Xw+eR+Y6fDw4J03kAZgKSmbWYN81tNJzWrOXdedz2d27oMPPlimGRik1mKXRrv9EyI55rImEAW1NsFsCnKPcHomtPNxDwCA2veDgYgULY/rjoY/V7U2K1VlcgLGQKAXDo/3jghUiyovuXLXd10npf7AA3rnD4eDqjBT83RrdyDnnNaLb6X3vm3kCDGlomqIhch/lxalQErQ96CXCYAC0OWsfr9O+NuNP5AU+RS/fT4RuctcTuy0P9w/vFuWSUrKeW2jokDf1Zid75YDBBcRL6mkQRKf9r9tE2yPNiltt9tkx57MWne7nT7ujolYVAkJTHNOVbJjdI6IiZ2XKst5AoDY+SdloPP5eHV95b1LKZmJaqklDeNYS3WeipgW3W63y7Kc53Uchyq/cXtYluWRvqwqgkQ55wwwbjbt3ZoZM2tbDyADMlJADmRSS1nW1Mwkmrh4LjmtpeGNzufJsQOAUoqIDMMwz3OtdbfbTdP0eLSpmefAI4QTAIg5EH7yycdPCu1m2g/DZhwBoLlEdF3A789PUfSyq6li5oIDZUAyrGkt8LhdAQARaQzRxqfMaE2+CBFrFbHkO2IzNWVRBgzBAyIYEP5O0rn/6cj5z//032stUnJwDlABlIhNFAnRyEzal9veZDutAARQEblh6wGg5NX3CvRfwYV8H3+j+ANJkf+JO609rmNqfrh/9/bt24e7t6JVtSLixVGZ2BEpAAChYq6VnQuxL2lCx1S4ySxe5CdUkV0p1XvXSrZaKzK54AAAmQgp9n1KxUAJkRyXtBCCiK15lVIbGRHJTERrPk/nGD1XBFAzzWVt6Q0AGqLINTNYoqYN06wBLaU2ClTRlhoansbMpFk0iLQFDj1CO6VWRDcMsVptrjBVIbInDkSeyCHqmvK6LLUU75yxKrMJi9MQwjwvptYPPSJSusjxAoDzhGgixUyIjIiJwtPhD84v84yEm3FzPk8ppXYY2wfshkFNQwjec4PTX740VABW1drGdVY1o4mAVJP6pP7Rkk4pFzAQPFlv1+LYNUEmBbhoyomKlkBu048AAD/cumY57n/161+YmZmE0Lfc7bzLj1YNiNhcv5u4hlp7n7/1NFpS8qpADtSaIOn7GvL3E38gKfI3whSQHveDCrLO83l//+bb/cPrdZqZwcxcCISYpdZajDmEjhyXUhxhydXF7lJFMhGiPaqFgxlerGO8GnLLPqKB3O76qqmTqdqjtwy2vs8xiknJKToiJSRzSEuacy4pLePYMQMxpZSq1K7rtNaaVausJd/c3CBiFWk79EbW3t8/7K6vgLDUUkshZqDGRRTvnDzWksRMzKbaRH22223OmZnYB1Os7YIkRnZMTiVP85RSEtXj/b0+SqmLaM55ms61lHVZG6SGmRtTBQBKLaqKBgTUqshlngGgHwZEfP78OTtXS4kxTvOESMs898PgmPuhJ6Krq12Mnv4jizQzbKUwqkTfGZIRKhqIPTHo28E3UH6UpDUT77zzvus7U0tSAEBEzIBEGdGHAO0L/WGKNf3Vr37BYN6DGLF7kkn+jetunqeG3wSAeT47x0+Y8SfXmpzXAbD1KT/Qe3sff634A0qRT30TtiwJBmDrcX//9s3rV1893H97Pj8453e768N+H7zvuy74LuWs5tQ5NofOlZJUoevHB0MwYnq6GhUAmKjxkU1xWaft9Q0TOudDCCF0iIzoVA2BwQBBFbShuck0L5PvO5OynAuCLsviCILzJSUCCOQyIiExYlrWoe8xxPPpAGpqOgzDw/lgZkA8n6cYG9SxOMdVSmB0RIiQ1kSmr775NsZ4fXsTQmjsNqn1gw8+kKpStR83ACQIV9c3KuBdZOZ5XmrVXC7J1IfgvU8pHY9HRnbIV9vdhFNZ09j3KS0553mex3E0kyoVDQJzKbXmTOR3my0S7nY77zw7dzqdNtut1Hp1dW2mN9fX7Dj40IU4DoOhGV6mDGYKwGgXvaUQQka8wCoNyJSwSblhF2ITpowxAmpppTQRsWuQLCLONfddv+aqqvxINyw5AxH8cJ6sOU1VEyEQIxNWqaVCcJ6ZsxQBZWZkRubzPKWUNpvBRJEcANSWH01M6vlwvP4YwOx9o/17jj+gFAntBAO4pDWzej69e/3NN1/96rB/p3Ku62mttp73wXdqVhFBqncR0NCUEFMtzN6TbK+v334ThFyFIlpb4QkAiFjrd3NGAIgx+u5SIDxFCKGKSKlaS2AEE9OKoDWvSIYGpRQpKfTDdjs0D2gRZXb7/cNHH3woWFJKzvumNrYsaZ3n7z29prQgIhoyu3Ec1mVdSvHOI+L9w/3z58/V1HnfxpHe+5vbW3bucDiM2y0AAToDNSQBVSCrlkp+d7+vUlXkghAqpWniplTGYUwpzcscQmhC2YjYiJXzPGutjmjNmR1vujH0wzIvMUZEmubZTHe73fF4jDHe3tw0r9emg9l3XYwR2HwIji5Q06bwAABEFLoOCMEIgQHEzBSMzBTsfD4DQN939ugm+P1Y17XNQ5k9oqE9CuqUmnOGWpH8D3PCoYpk1URWiazU4oljDCGEmlfEpul+wTAhYpPqMFPNVcHYx9o0kktOy9pa7L8BfP19/NfEH1aKRARs9+GSz6f9r/7yTx/evjkf77WuqlMM1HeOidd1rSamhYnHLQG4Ugty6rodE9esyM7HuM4IACrK37ugRKqaIaJzzMRd13dDH/7T9kwxxnWeSklmIqqkWkrJOXNr3dmFEM7nc5uuPTnHppRqKezc3d39MAzn88TBgbXBKjjH0/kc+g4wnE6nGKNDLrXknPu+d55C6JpJA/sYY2TnlmXpht45NgRDUgQFKiKdmYDuT+emMd4ojyLSLGhKKc297/7hPqV0s7sCgCrSYJgN+xlCaFZotze3x+MxpdTa3sNhPw7j1dUNIm43267v+qEfcKyldF3nvO/HIcZIjN47E0U0AENkRXBIwYXt9urwzmUEMGhwGWsuvhd2kIkEIgHQltafxnbXN9fDMD6NAp6i1LQsi6TEw/A7n1sXXPf3oIsGAJBLKjUHE0T0xM45Ez2fz46oDQSIybvLCRSCZ8fEnFdBgMZtb8PZ83QGEXD+Pc3m9xx/QCmSAADUwMBsmY+vvvrFV7/485IXWc/rcjIrnpGbXSeQkRoXQQcAoR+wVlFAin7cuBhCCjHGxTlhV0o2UwA1EATXoD9IBCKI6KIPfRdCyPU7mcicc1ODdMEzk4GoVQJFs1xqSklV+mFTpWqpiJhS6rqu1OKdL7Vsxk0pdVlmIlrXJee82+0AAODCEjG1EFwIYf/wMAzbkvNcLuJAfdf3fX+ezk2/J8aoZsv5vN1uqwq5oOCQnYk2u9e11KqSUlrXdTpPanUYhr7v52mqIpvN5nSalnlZ13W72eZcAGBd11qK8z44txkG7/3pcPTOv379Ksa4u75Z5mVeluvrGyYqtahoy5IppefPnuech3Fkon4YQgjMSExWBACq5Ce2CTF13UAUEBmJEAjBAG2Z5ugcs2MmM1NVRGu7+6czoflNAkBwfrWMAICABpJLySuUDKBgRH/Dcu37WVKhrCipqQ0dT/tx2HYhqhbvvGNnZADgvDMzFfDet/IWQC/kSCIidER5meECIP+bvav38TeMH3+KfGyB4bK9LuV43H/7619889UvpMzr+WGdjwSKSPOcRc8NPg3kgvf9uC2luCAxdApaJa/rzA597HfXV2k6qMmSFwBtiBmElqPocVMqwQdEVoF1Xna7HRlYFUdopoBEiMtyrpJRBdEe9vd9iPN8Ynbecy7Zqu7vHnwgNJGSYnAi+d3dmxCC82xZfNdLraqynlPf9/M0IyJ7z0TTPEcfUK2WUnLpuq4f+hhjSouZbHcjGDnGnOs4DAZEjksF9pE4bjacqzRf73VdRcp+fx9j9BxrrW1L7pgPh0NK6e27tyLlPB2vNtvjaR98GMcOEZfzzEBd8P72el2X2Pm+H9/evfPO39zsuq4DvQDCiaiLfuiCaN3uxpubW+8dskfExjchR4g4DBs1YSBEVlHH4cMXn//qnBSyQwKqUmoIHk2RDEDXddput+00UBH0HpGHvm+Q9UDOMQ9dBwDLkomc8wxSl4e7zeYG3ONsRM0QEP+T0O3/zE7Zlunt17/QZRIUYooxIlkuay2JcUCypjdKQABggQEAgbxnR8jOpZKdQ1UTrY4sLVOMm/Z69LvZeb+Pv3n8+FPkhbqACCBW0nSeXn3z61ff/nqeDtPxHupKUEutm34gC2rKxFUqaq1CNa+h24iUaT4ZkHNxVSWiQHp1dbW/i7zOjTXXvK0BKz4KtKhI3w/snFRR0jabM7Mq9ZEirWAqIrVUNQUTVDETLTIMIwCcz+fr7e54OiIF5y423Ou6NgGzpgzUEDwAMC8zIpYqRGR2cckGgNP5xMzXN9ebcdOspp9KFalmZuScGRIyMBk6BWJzudacS65Sp2me55RSK1Rzzuu6TufzuNmISN/3IjJNU0qp7dYdO2KsVaSUUgui1cqlVFWLMTpHu92OiGOMIfiaLsAXM3PsiMmF0Pd9jNE5JhdEviMyE7ZZJCKSIrgYsGrf7xA9gSCIPVoykHOt2NxsNu1QIxG0Df6jWudFW+iRiLnZbA7TzGbLdDq8e715+TE4/9cp2H4jP+KFDFpK8d6D2jdf/Tqtc+ed6W+AiJAwpeQ8Ob6gtUztkdREzVtNWYAiErPjph51no7x6oP3ZeTvOX78KRIe21tTmZfl1be/evXNV/P5KCUxIoeA3klJ67oiohmKSIxRRVNaUkobhd6xcx7Zz/OJyCGzOejCZX7knHeO8WI5At+/arqu897Na0bFvusBoLGnm3tXg+WZGaihSm0m18vKjj1zq1h1s805E4H3ruE/LmI8FgAACZv5CQDUUqtUM2BCMaNHo9Tr6+uWEUopuWTv/PMXz+/v7wFINDuKpGqEiuA4qLGaFc2lyJpSFVHVeZ6naSo5u0eNnKvdLviwrmsVKbksy9L0MauImtVScsl5TQzoHOU1VVUzawK6IYTtZsuOn3YmZo0kqd7FzXY7jkOzltULSxkAvmM6I7IhMCIAOYfjbhO6qN+bKuLjYoeI1Az1gjRQxCZ61NJiw5M2cZ3zeQKrXd85hyWvd/dvPp4nDB24DsBa1vutko2+PxD8zSWzArT8C7L+h3/3Jznnvh9zSWQKF2lxNUVkNEWji8YoEjbqaiMROecQjU0bQSvngloPh4dnnxr8UHik9/HXiz+cFKlS68P9u1fffDVPeylJSgKAUgqBOubmQA1AOefT6dQcmGKM5+kshhzWUs3FLnZD13XKIaW05lQflawI0UxNBYieLGK89yqXEgkfWbdPzk0NyA1aL4TutHjG8zJvt1cAUGolg5SSiohUkWYQ2NY20OwMU0oNBQ7NfAu9kRCxiCKyc+Ccu7q6qqWKSippXdd4Fe/v78dhezqdkD1SM0dAQn7stQ2q5FpzKfM8N3UyVSVmJkKiJrOwLAsRpZTOp1PzUTCRvKy1FECdp0lK9SEgMRQQsFZE11qud1epZFHdjBvPLI9EHzMbxmG73bTjKWBVpS1hHne4BIZIlxteLcV759htN9tjOrYlBiI64ouuuKqIFIDmLw4N3s/cvoiWRkspucqw2eYlA8B23CSDZT68fvOrW8dh3IF3j0wd+609zF+5NvleJrVlOf3qV7/YushmDMZojW9qQAAghkzIzIQkJmAECKoS+r6UoirsnKnkkiUXojVKmedTGxg84Svfx+8h/iBSJAAAUK7l62++uXvzuqaTajWpjeVaRFKqZkKOnXMeyLtW3VwkX0pNomJIZbWa8nSAF89uz6d3v/zlr9Dkg+cvUkoh1Bi7Zc0EikQppRcvXmy3m1QVgYlcSqnrOxWNMdbmC6oIIqrGaJ4pL9PQheAp57wc9ldX1whQ0oKgkiuNgABSSvMnkFyr1FKKlIKIh8PBu6iGRB6MhmGsRfqu22630+lERCJl6OLVZswlO+6meWL2m804LSsgx9AheSInhsG7ZUnLPE/z3LKMPLrlnKfJO5dLSfNyc3WtVaJzNWUGZKK6JNf1nQ+5rIQkAITo2IUQqtQhdo4odsNms3HLSkybcbOuSy1FzTabzWYcx2Fs8woOvqYkBt77eU0xRkRItUT267oyUs2lDzF73gQcxmGZIimhEDJrzQ1nvi7rpbqvtZay2W7bVLqWsrm5uQgREYXeq5gixBDXdQXnTdf7N1+/evfW99sPP/4k9MP29vnFQFuxuTReXGvseyUk/ibbxeT1q19vxsC1jjH2Oq7zWQWcd8RwXFfSEuMGiOc1bbfblJIIMFPVRp3SUtQQ1NAzApoLeDy8rXlBHh5f8j2z5vcRfxApsvHu7h8e1nU1KIyGaEAACM5FAI+EWosKLPOaUkrLioRN3Ix9JKrGWMq62V4RoapOp8Orr795eDhEz8s4Bx/AKOeac+66Doyc8+zjmsVMG5Wi1Y+i0rRdTc1EwAy01LxqzQwkuaJarauKljWty9qa01JLi1rq0A+t4za1Zt5ASAbkO+8UiNkMN+OWiKvJZRVeytD387K0mrTvXYN/r6kUsa7vQuzFsCqo2ryeG797XRYAKLWmRzrjZrOJMZb9oWEfRUxEUU1r7fyQc9EqwQck6LyPIRIhgJVSdrtdjDGXfHV1VUX6oWciVSFmIo7e7Xa7q6urGCM+iqubKbFndiGY9w4RzGxZluNxX9Z0Oh4dEqPdjnHsvssUioTsHWOplfg7dyBmTimpcxHx0bTXKYKqknPi0Av03bDUNVcxXpZ5P1fI9+/2D29c6J4/+7AbxptnL4bdNYoCMHxfTa5lzO90RdsvNS3nlKexD13fGUgphashY/PPIUa4eBzRNM8xxhh96z8ML37oVSpdTL6ySELX5TIPcfx9XDPv4zF+5CnySXzqdDq+fv36dDowmkFVFTMZhqGWWmqVpTzZy4QQUkq51pSmWorv+hhj3/ch9p5xt9vWKl9/8/Xbt28P+/3Yd4fgQwjeR/bOea8ITMjOtefx3jWGohqoXQSBVKuoqAGpSslpWVEyEuaSTG1N2czO5/PpfLq6vmrskRYlFzVtRWhKqaqJgqKRglSRYAyMBO/e3TGTj33Xh1qEGNm5oe+naQUwQzAARVhLZt8bcRGpoilLVTufl1RyKbXBknwI2+0WEUspzrnz8VRL6UNERFAF0dP54D0PYxdjrKnGGJ1nVXXMaqYgAHB1ddWOrfNOq3Zdx0Q5F8c8etd142Z31Q1d8wVs9xJgRkQBbTlOxXLJKS2Hw/54eLh/+2BVrsbh5OFq9NfbCABN44GYFM0xQwjzNDUIepMXMmYkcsxLWmOMCpBS6jeEyN57H0JByWmVukhd1mk5LWk6xhDH+XjwofvVL/quG4bNLgTfxTHGcHN7i8zAoeXGtitqJxyYrvNxmY6TdGQwbvqr6+dHfQsqYJWYQ2BFANHm9I2IzvlG5b6cswi1VAyBAEqpy3Ty1B8OD8Pm+VMefl9G/h7iR54iW4iWtE6n+7d5PkJaoYpIBoDD4QCPkt1kUKsSQAjh+ubmSeuhiKkZE19f7ZDd/vBQS51OD6Um1Zrycp78oLqWNTCuaxo2IyIiEzvOJbehYZvfPfoImIigGlhVrZJTWZcmK1NKaSqNRFRE1uWyhZAq7U+VWnJpijjrunbDhsghEpCrCkEvJtRFy2Z7NfS9mHEwUV3X1bHfbMa1ZGCSojUr+74fN8ucikmqknKtIkWk4b3b+zSzWmur4IhonqemBN70jUSFmZ89eyYiXdeFjW8cbVVpgmbGl3WEVOn7vi1t2oeKMXJw3vkYex+Cd17b4uYCcAQ1A9VaiqrUKikv93dv7+9ePzzs79+9YwVJY+esc89he3lONQOwyEyMjXXefjkvCzGzc941HXJyIShCrqWUygSqYKhMFGM0UymLrFOZJuo2xKQrOE9QLGtO00HMxFpx6l9+/NGnn37ab6+AA15SFgEYIC5LTqkk5FoeUkq7zRadRzESDt57z6ZmKkw+9rF5aj8u8aCdM1XFt/5D63Q6jG6Y7t/BRz8BCmZs8H65/fuIH2+KfOx50ASkvnv1dZ7ecZmkJpNKQETYvFBaLlzWpWWEOa0OHSIpogCyo8gOmPbHvRbJJa/rXGoqaWnSEic6H88n38UXXe9CQCR01Pe9AVxdXRWposLEtVbvPQKQgVZBK6YFJAfPTJDXFRFzFscXdsjd3Z33/nw+prTMy7nrQ875cDh0Xcg5LynXKrEb2HszNKQu9ufzqd+MH7x8CaJVcq6LVMG+qyqGAEylqAGtuYgxsQMLy1zEULWZQxCYqV5SkpmhNT9VMbM+dufTSUUFFcmQbNgO94f762e3jlmrbDYbZmZulLrfqG/WJSNCCN47H/poZuQ4xj7GyD42VFbOlZgUwdSaXAMAmhkHDwCS0v3d3etX39y9ef3u7o2UVHK6e1M2Q++gbDfdJjqAombrMlfngmN7tHxosdlsfAhzWqtpZx1QKx1936R94sUP3Tmfq5ro2Mf/+V//6812F0K/3d0KYFVVgWG7vbq52V3fhtidpuNf/On+fLz/e3//H22uXtKjiVgp1Xsa+u3QXTkHaHKeFyJXlmRl2XTBs0MgJPAx+hCabLCKImFJ1TlSoFoLPtINmyK51/r65//hp1/8FMfnZvheF+33Ez/eFAnQVP8M9Xw6LNOxpknzYlKf/l1Emu8KkVdpWtNSSilrURMDICbHTs1KSqpKBqWmUpM8Qm3akzDzw/3D9e0zdqHVALvrK+8CMpFSrUpIzjl2DGJqYjWbFdMMkvO6lNZEr8kxr+uqpfouppRUdWkDwZyXeW5OVdM0mUIpNefqu349nUVtCF0z1UllPR2PTCBVUl1rrXNaAWgYNvOS1KwqKGgVCOxATbWqYiqPNXOVIuWp2tVa29pdVZpXondut9s+zeHcxSyBXSTvffuRHSP+Roq8uMsy9kPP3puZ986F5vp1WfRftsQN/tPmcQBg5oinef7m669+/aufg1QpyTOxcVmSc9R5ZschhJzXGByqBx9jcJ4JHjUiW/Dja9VaG9OZmEybsxgjGhCNw4Z9nNaFDHyIV5vN/nDse13XXPViGb6Zx7Sc1/nsvR+3V1brq69+Wdb0v/kn/9v++gVc4A0EwJ9/+dP/6V/+izkt6XwQwNPh2DncdC6lVPMaQkCmUhUJnfOeXc5zdHEcexVZahVVZEaHQOYUO+fW8z52+PXP/+LTf/ocFczeZ8jfR/yoUyQAgKLpw93bw/5uneaSMz9K7iM6ERCRZVlLqTH2BNDkV9E5K6WKmIoYSpVc1qaEprWKFNUqJTUz+7bKOJ1Pp9P52YuXQAzM3vths1mXrKbE1LCWwYdqarVKyWDFNGGty3Ra52lZ5pyT1pqWpR8367pqlap2Op2GYZjmGYlKKYg4LeswjJvQpXihKhL5GOP9/s7IVEVqIUSpkmvJWgHKZtwdTkfmUNWqghpqSxZaapGsIrUJm10yFRJecNrN7lW1loJIz25vEbGU2g0XynkIgR05x13Xm2kM0TlqnXgp31VwtZS2146xoRGBmbz3wIxoWi3n3A9R/yoCS6llmecGbHrY38/nY17PADr2PQGo1vPpnHMOCGZYTb+fnb377vRuFkBNqI2IkZmIlbQUJSDHxMyh75Edl1pVyfCjjz693//blBKJVr1U98daVVVKcs69efXtzc2zcRg1nf/X/+X/88VP/+EHn36JIbJjkHx1e3P74vm/+1f/7+PhYduPhOZIu48+6HsfxqGWhABtnEiIItWxU1UgziXnWoCQAJvfugOoUteUwdy3X//y07//T7Hz71V/fj/x402RTXXUFEznw306n0taaq3mLlalZnY4HNps0MxqETMDVLCLGis5FpHpPJmpaFXVmouJqlYzaV15G9gBADl/93B/+/wFAn/wwQfMLudcagm+A4CqNYTgHNWitRatmVRABCTLupQ1lXUpuQDA4XDYbLbNshUAlmVp2ovuAniOzA6Rl5xOp1OjrIx9DMH1Q78s5+12GzbD6XC8HASjcRzP84rIVaoiGZAigZGAqWpWqaV834nPsWudMhOfDmeVC3LRTHOWho5k59ohYucYyHu3GcdlXZ2jZjjjvQfIT3hvduyDk7U0BDs2VTgCIDSgavVJgfy3ggz2p+P5uD/uH9I8pfksJZkJoa3rOviI7MDq4f7dBy+epZS4jVYeF9nOuYuABeKyrkTk2IW+a2poQIjqCNW5ELxnH12IJUuuVcVqkQ9ffvTV199WMUAmQ1VVLUTsCAgUVBzAfHjnrKbAtx90v/71ny45ffHTPwbvm5zU9mqnSPuHfVmTlPTlZ5+Y6byuQxfYR2JgYuc8O16Wpcmzl7Su61pNvXOXapfYtM7LhBRzWspy3r/75vrTAZHep8jfQ/x4UyQAAAHkN7/6+duvf61pJgNmNhMBQICSUtf1F2AIYa2yrotUIUcGtKxrLVUR1mX23scYnOPpdMqlEmLDVJuZGJSqQEBVUirrut4+3/UhmimIemIpRYG8d9XUirCjPK1ai9Qc0ObpfHjYS0meXYF02B8R4HjcT6ej88xM53m5vr6OMfoQ+nHLRD50ucq65HHYjk2UYuwcQd/Hq7Al5w6HY9NkQ+QQwjInETW6jNKMGAgROLX3Dc0WBgGgVsk5d0Pfdj4AEGOczucqNca4LisSSq1rrX0X+q7zIUzns2fvgyPEse+dI+fZuwAAIYR1XUUEkbouAmoXXBe8SS2leO7QIHo/LWmdz8uyBEdd1wGTijKhqjiC8/mc1ymnZZ2X/f0dIUjJOSU0GftYRXQu38yTSX1+e4OIYNRERKTWnHPX945ZDOd1NUNFij7ULGrZxc6TW2vaXV0TOSIPxCqwu7lVoDllAGD22+3V+bzEbkhVSs5VEMlKKQTo2hs2SfPpBJprff7hJ4e7V/9+Xf/BP/hHGAOw+/yLv/eLj//0q1/+Iue1985qXufperdh9s2JiIjWdQWgm5tneZlNdF0zk0OEUmo39LvddSrZMaPjVIShpvXw6uufX7/40PyAFP6z5//7+AHiR5oiWwsiZT7c7+9ez+ej1syOUF2pYtoIDtB3nahIlVqldYvruszT7GInVapJLcLEOeeUFjOreTU1QqtVWuGDSF3X1VoAIOd8PB5fvPwQkYk8ABkYETgXiABAay1W1v3D3RDY8jrl+fRwByqMdpyneZpQLRATUAihlDpsx+A7Zt7tdv246bqOfTyfZxV9+eHLEMJ2O3Yhxr5z7JacTucFkAFo/3B0jtnHtBYfQ0qzmjoXz/OE7JmZHCJ/p4QwTUtDO202Y1WVKkkqADj0wziUUhuEvOaKSJtx9N43m7Am+9Z4fdAYPu2jqiJao0cDGBGpoqGZCTGQmFk1oZJSTWtJS855mZfv77vb8VymeTqeD/d3aTkPsStl3gydIxWpREQGbf2VUlrX3AVftbZBCjF77x0zO2dq7Ng737BcXdd1MdRaBazv+ypChmiMiuy9iiI7hGYh625unt/d/7zCKqKEGGMP0Grxi+tDF5xI3u+TT2uu5aNPviwMf/Fnf/JHP/uHNPSff/7T7e46xmh1DcENY9/26QCAjhUIzdixNEZ8zk1MgIid5xhjP44l51xKk0RDy7UkMX64e7Oc9/1VgPcp8m8/fqQpEgBUJKXD/u7Xv/5lTkvzhm58GQIANQR42D8wcTPBVlHneOgHx25aUpWaS2Z2xChJSk05Z8/kvat5BQAzIyKrhdmVbIaaczkej0SMTEykSNi2BIQlFzJF0OPDnUnJ05LnU1nOh4f7sY9IUNYl+kAA3gcfgw8EyDHGJZec883Ns9BFBUqlfvjxxyF0KjqM3dAFM9Na5rJOy+JdrFpL0RgjMR1P52Gzu384IrtU0v50VgH25kLHLKTf55L3IXgzW9cVCJvMBBOnJa3L2mQsGi6n7/t+GEKj9AEAADtmZvc9e8LGPWfnqRZARcQQfK1SVkEy57CWNp/I6MA0i6hJLTmDmWgNXXTckWpKab/fv371dVlTSsv9w7s+cvBeChPodykSALEx6zdSVWtyzI6AiXwITIQKZtZ05AAghLDb7YxQRVOtRMqkzARoPnTVhJiqifdRzD78+JOvvvn2dJ59CMBeQBs23tDE1IpqoK4LAXipIiV9+/XPdze3APqrX/75Fz/9Y6QwDJtPP/308Pab600/9jE4BiJFcOyWZem78PzZ87v7exWpIkTkQ9e09Mi5xvnvQ5zTsru+NrO15JKm+bB/8+rbz29f/t4vqj/E+PGkyMel6IXDCyL3D+9efftqv98jACMWs5xLqzIae6EtGcxMpBbRaZ6a4iGyI8RmJ7KcZzNFROecY/Ter/N0qWKIEKlWYeeKqFNJRZCJnAOmtgRA5JRSlSzr0kf/cPfu4xe37775dV0XK6uUtEDtui4Ej0jM3TCM5BkR11TaO/Smoeu6bnQhitm42eWSu9gj88PhxGhtUtD57nie1zVvd9cAdJoXCvFX335LLkiuqeSUio89IiATPrplPakoNkdZIzTVZqtoaimVZZrNdNyMUmUYh67rEY0ds3NSmw9aREQkA7hQTtoXYaaILWMCszO1SmZmbawhqoTmKBCDd1CpCSQWVVYRm2cXQxdcjH6e5sP+7nzYT9NJqt8MnWOnWpvcAxoiYCp1SavAroiQqSIgMyO6izmPOXVtXBBi7Ps+5zxsNyGEaZrAimoTWQ9qoqqlVAAIIahqF4eXL18avnt4eFCcn93eXpA9KgrgA61rLqWELhL7dZ5cLG9fL1JtXTK78bPPP/8//p/++bPbzf/rf/i/BishBMfYjkk7u7Tm/X7fvv1W8wKymSkCMSDSdDwN47AdNn3sTIqVDBkJ7Ztf//yjz74IGwLy7yHkf6vx40mR34UBIJzO+/3h3X5/752rkERFzUJgydqsqcxMpapdvIxJySoAEBOJCTtChNPpMJ3OIfi2gTUp0zSJ1FoNkcHUIQkYIjM7IL59/uLZi4/IeSCHiCVnxAoqZV3Gwd+9/sYznk+HlBco63TYd11QVXDQ+tbQd4jI5IjIgIC55Pri+YfAjpCBGdkZQIwRER/uH4a+78f+cDgw6JuHQy067q7muRhSUjgdT/vz2m95SU2HgtackImtglFKc993gFDrxWNaRES0+Um0NCdgLnjn3Lqu19c7YgJQIhqGiAZaFVVKya0C9f7iiwumYNaWKmKgWgnEEWDX5bwSIaKhCjLN51OVCro6rlKSEaIFYhTDlJdlWWtenz+7Vsk1p5ITgM7THCL347apkCAwAqaUHvb7Z89vgRjAtT4bSHIp2xgZaV3XIrYZxwZhco5DCDH0aVmXeUayGKPJ+nC/Xl2/iHEg5xFZK611/fzLL6dlCcH9+V/+xbAZudZhHIAvjrqt404pjdsOCVEFDe7fvdnsbk+Ht8fjbrPdDNe3293O1aXWGkJnTbeNqUpFYlRTUTRtCNDtZqsXuRNZ07wu52U6bbZbTeswjrefflnUvT6sdVl+9af/9mf/7H8HEJ9Oe/1uefNowPs+e/5Xx48nReL3BPm05vuHd4fDQ5XMjkoxMW2bawDQRpU2a8JiDfcHgqrK1Bo4W9d1Wpe2fr1odalZbSGlFPedijWJYa5y9ezZBx9+7LseAM3UxIjAEb1+92o7Duf93Xw+9Z179+aVpJlU2tXFgVVgs92WWqQKMQGIgK2leLCPP/s0raVWKVqrgoBJrT6EGKMUuZvu9w+OmUT0PK8x9vuHg7E34lVkWde1CqRSajVTByGE4L1vq5i+7wCg1qoKpnJxUYHmCX75aJs+SJBlnq+urpwjorbtbh+aDEFAz+ezc06keL+FpntI2I4zMSEZQJAqaqZaAMCMyMCwArjGskOoBEVRyBiB2KqpIVAgLIyqte+j7MZSkpRkUtvApL0PMgCgfojH05RS6YOnS5egJtV7X0UAYegHF+LpdN7uBiJq8FLJomIAkFJyjkoRDiAlBd85ZENCUlUL0TvH3Xj9OXz5l3/5iyL19vbZbtwgGaMFRxQjO1JVQAIFRM1p/uarX33x0/HXv/rFT//ez8btVeiHfJhQKqfkw0WL6HLegqJBm0gg4rLOqFarqtWa1rTMZU11XQ5kw2a32a5he3W121EIaXp4+4s/ffHFPwC62Ei819n924gfT4p8CinldNovy3Se9ikvpuXRcllMm/2yiIJZw7JYy5iePSGuJaeUihbn2DE/psgGGlSTWmuVqqpgDIqgSI1d6J1/9uyDzz//0tSUAKXWWpl0v78Hq4f9+d2rb3bjcNo/rOtclnk79hz8si5jHA2giOYqKSUiJiqEqEjX1y9LKefpvC75kQMjZqiiueS3b+7Wdf3888+7vnt3f7/dbg+n45LKsNnlKmupuSg5MgGo5sk5oJ67znXMThEIfS1FDRCYmBgYHQGAijT1dAAAhU2/cUhVJPqAiOQJEdsjFEiBpvl88+zZu3dvuz4E36kqU5OtJUIkbPxLEakE3KQeFJtnrBoYmZIpm5pq6//Zqqoie2OM3o2bYZpPirDZbJbJtIIRqBqzfyRFq/exip1Pp+HFMxM0xVKL5NTuB+QcMfkQzMw5DwDUCnzFZrMVnJdcVAFKMamAikiIxCKGGLzfXl+9e3d3tbv5+KP05u7ul7/8xfPnz2+vrwhMYyQnRoRSHflqxkRE7nw4vv72m37cvNmO0XPfdWmPUmsy9d1GsXXqAKhqQKaA+mS7qKWmvEguYKJpllqSJaBmlEhCoGml2HfjVZofIM0weDBucmpPWfJ99fhDxY8qRbaF4Lqsx9NpWc6qCqCn04lRFRSskUn0UUtC+fFmjojrvDrvm7V0cLiua1Vppq+qWmtVVZMiIgLW8CUABCBNZvHDjz/9yRdfbsYNAphUqVlLPp0elnV2BA93b2vK0MfTcf/Nr3/1/PaW2aW0FNHzefHO3d3f16oxRkJsC5+PPv6067r9/uHVN9+01hvZEzkwk5zznObTg2NnZf3V66/v7t68/OgjVezHzXrei6HUgkgR+ghVEIisCxwZAiiBGmDOi9biXIiBa6rE5sgBgJA9eTd7dsvpwTsm00hkZI7Q6DfOmRjj6XxQre/evfv4o08BoA0cG6nOMyKSWVXlNuhrrCT7Hp6PDKRtXUAJFFUZEEwcoXfEgCEERJqmyXOTXpTmlIDUxpFaRK+2m2lJVQFqrWxSa01rCGGz3frQTdOScx7GgckVLaHrpJq0Ute5sRse7h9i3y0515pqXtl17L050qyl1n/w9//Bef5flnlxoXt2+xzZ3d/fd13XR19KniZzLl3f3qgAEorAssxLkq++ffXZ55+H4D5++cy5qECoKig55971ohfFdWpQBzOzCgCuISiWuaaMJqbVsxHhuNuwD+yIWdGKZnx9eNifjsd5/fyn/3jcPoc4gGJrrd/Xkj9g/KhSJADknEutpRTno1UoRZiDdyZCpSwqDa8jTemWmGqR2hwHgVNKtUlEIrjgSbmUspZcRWrKpRTnyEwVgZjIO6gaohPADz/+5PMvf3p7c8uOUSWldZlO+/u3y3QKkc7LjGqd469+/cvz4RiC3+12p+n88LCP3leFd3cPueTt5up+f2hQxE8//TR4//Uvvz6dD5989BGhNcVvM5unOSVFmV8+H1JK+/tfe4APnw0DZwpMOCG5tQgzbMYtQAWDiuowRMi7bhBNNS1iwsCeCAGwlEAODKBmaN3vRScT5v3kHAYKPkQnC4LDpkmDUVS0Fke8vb1hgqvNSEzn6Xh1dYXYhM4IEYEIiRxEM8NoAL2ZlVJyXrU2XThCF1DEx3YqkqqSC0XqtKR393eGdNgfSs4vXrx4uHtLTFrMDMWQkYiJEbXWIpZabYqQc/Z8kf4uOZPzse/mJRlQrrUfBkNkD4hcVb3vqur2+kpVvFpaZhHYXT0TVR+6DLqu6/Xts08++eTf/fs/XXLJoksqQO7t3cOzm6uxj+yBnE+p+I489lXUhS4d37395qu333x13t+N/+1/u91u3znvicCKSC0547gBANNiemF+mohI6fse0ZhIyObzzNRuBLCus1NFcitO5ELc+Ge78Zymb37x56f9+Ys/+ocvv/gZ+L6Byd+PIH/A+LGlyAYx2Yy7tJw247asyXKVkqporVpy1VpE1AzN1KqpaMOCTPPcyF5IFGPUnEqtuZTGXW6VUaMnAoAinI5T34/jbhv74er62W63++DlB4iGUB/uXn/9618+3L0Ojj948Syt82l/2G22aZ7Natf10zQ1u9SuG7759lsAcM6RY0O4vr3543/8j06H43ScQ/DPnz9/8fxFF5xqPZ1O+/t3UnOazpKX3sNu6Nm54INzjG2AxwTo1KAWZU+liIoYKaCy5Pl+NrMm6A1AiITs8OLj2phw1ng1bbC7DYqIng2tQGZFMmQjDjstRTQvBBmEnYuNWQgA+/3++vpaqpgzILg4z1B7RjIzBGC2EDp1Wms18cglhJjS8vgdkgEYkIKlUpechnE8nU+vX7++vd69ffvaEZWipqhspKxEwQVFUiBmn6oxNo9b7LrOiHNVRPMhsOMQnAvBEKqIVDVER+TJIZqRIxfACACPh4ft7hpBGU2R12Udt1fAHpBP0/F+fzw+PJSaVZU/eOEjpFpD35vikkqp1TEPsdtuhrIuf/7v/s0Xn37U9x37qHVBhSLGqimlNs0kAyQjIEQj8ug4snPOidVuGMxEtBQVVBapuawMaKkgIccuIImslo/z4d1yv+uffQTkn/Qr38cPEj+qFNlEyMiH7XYj5fkQu+Di0cX9w1sVNcsikNfyNIJsogmtOmtr4gaISSmlnNZ1XZdFSrWLtAJ8nyeHjopK8N2L5y+319cudKXquq7T/vW7V7/e3782qS7waX9Y15kAj8e9lMx4wQ0Ckwvx4XAIXf/BBx+klF68/PDm2YvbZ89KWrx32+3gQzA1ZiqlLNP5sL87Hfe1ZrO63fimtuvYOU+MqIKqVa2aVlKUUqwumsUHj0Smy6O/N3pET4jY/O0JES2fH4dX2nUdAXt28LiPIsyGICJVQQFF+bTcg/fOh+uR11qJo5qJ1OjD2PX3d/fDOFSpDpw2bW6DagIAl5cDNGQgIkcVKhMDKCu0A2NIpahRY8XkV69eex+2m6uHd/fffPNN14c1Ze8dmJISNaKyVFtrCFxUnGNEZURkSKUoUu9jPw7ztLoQfOe985dRSRNcI1QgMGVGB4DoAMgpVKm++aEjnM/z9bPn3MyA2DfbQpF6d3c3DF3sO2+2fzh0w8aFzgzWJaMIg6Ejz+G0v9988vn17fP9m1+bKhqJasqLIwBmbIY6pOi8QwRkjh1QMXYcTbQ4uZCgAJ0aQpMaIdwSdcO2iJCW8/nh7s3rj+LI4w0QAr/PkT9Y/HhS5JMEAwJH6j/68OOUlu2wfR36qpANsBoWWOsCBqZQazVRYmgwFwJTRS1FwE7zsfFnpNRamzPMZUv7OKcj5vD82Qc3z18cz+e3+8NnomZy3r+zfHi4fz2fjyY6BJ9qSssaY0SFq6srZhYRF8LpfIoxbsbdRx9/zET90CNSjOHh3f3xePzg+YvO++aDGD0/PDwcDod1Xvqum+YcwkB8URgSFUvNZEBNVGpVBWZnIj4EYCPIjE6glrzmXInYsSfiftgwGVFT/zezy2gscnDeh8DkXKnp6SMzqQMpYqi0phy6sWYCwc5tIqhpXuc17NiMYoyn04mIIYADp6BrTmZGxM190B45OfOamcmTV6vIDqCJUNCaVyAnBjlnZt7vD6XUq5vbw8P9w/3BzJAdcyZyzX1yO44glVxIuW5DiESOjNG6vqsqRbIvoUj1qkxMTM2KxxGoKgMTsUlRU6nivXYhso9rKo34hMSGMJ3Pn3zyyTev/pX3HEKIw+C8X9Nyvz+50PVDP3b9WirUpVZ7eLjP03R6eDv23Sef/uTVu+NwnXy/caHPNbMRiNWU0ZNzCMDS3JOYgf2aEzoy8wYuW2X0PrqLfQ4hkUdCEJVSVbX3TqWqLGU5zqe7+3fD89hhHJpV8fv4QeLHkyKfrj1gJKNaCoc43r74bNj117cvTqdXr7457+8N42n/cDo/AKBnyik5ql3XtTVLs0AI7EsqUgoA0CPwbZrm7XZrBmaqWrdD/+7du1/++uvd9dXu9rrm+S/+3dcfv7jeP9yfD8eclrHrc86dDzH2Oefnz28v3B6kUiT47sOPP7q+fsZMOedhs0PTN2/ezNPx2fWNYyZikQoqS0UR2WxG1VJqvrp6JlJ2u926Tj6EWmrOWVWc8+Qv6axKFUu5incupQU0NQOt4AO5IGqpqBdLJROjDx5Qq4j3vus6F7vguyY6yz62WhsBcl4BiFU5YBe3KlJVKgJg6bBWosriwUKMdVk24246n6XvhmEMzkcfAEBFT6cTkiPmBrtXBe89MS5TZSRVgyZqC/Tt6zex62M/Hr/+dl7zfr8PB4+ID4cl59y65pbviOB4PCPicclffv7Z7vkGm8qblXVZQ981SPwwjiEEEUO00HUP9/cxRgYMPoiqqOacd7tdSimV0nNg51Qlxl7JEdBxmc7TsdQshoAaYw+xn9f8cJhunr3UWQTEVVAoInKccx83/4f/7n//7OYWgL756tuXn/1s/+7VYf+6rKdaamBvBlUkSkhSSk3Bh1OZgw/A7uHh+Oz2xbMXH93f3RNDWmcwGPrR1ATEqrJzZnU6HgBg3NyktJ7WN6qKDjHy889+dtl+vY8fIn48KfL7YQjsnBkTA/vwYd/v5vnZhx9Ox9P85d/fv3vz6tXXD/ev377+BhgETQy1ViklV6miDp1pczDQ5ohQL/7UDV8tqvLu3bvmbIOE8+n4r/+/33zx6UeHvU6n8/5wYLCwu6opz1W8c1dXV947ERWpphZj/PTTT7thBAAz6/v+dDot04yqDWMEAN475/x0mht1V1XGzW6/v99urg6Hh8P+uNmOMUSVxTtoXBdRFZO2fGcfWTSXdZlXQiQkIy6CUqtzodtsrp+/UFUiCMEpQi5rLTWbbodxWdLV1VUXh6JizdcUddhdqeh5Op8Px65jYHZmaphNvJPOO+/H87JIccGTghFTk09nommehn7IOfd9XxVEJKXUhMoBoFZhoqYPqaoiJoDb69s3794Ow+bZi5f+ePahOzzs15R8v3HRclmrQpGqqxpUh4yILnTzmolZqqKpI09MxETMxNTHAQAan1xFxs2GEJ8EJYnIe9/EgRCxmiI7MaumBARAtzc3f/pnf3Gezg8P5/v9kR1f394+e/7h8Xj89s09O7fb7XwXTbXJUvz0J19+8bM//uSTT7bDzjkO7P/1v16KERA7QETuus6sNHDuvKzWY5Mo6vrgfSeGhhTGba11c7NZ50mBmLCNiXNJiCSqy3KuVTfbq/PxbGbsnev6bnezufrgfZb8oeLHmSIBAJkuNnFGzrngg9oujVf40cfr/MWX58PD3ds3r76+e/v67etX63Je12MRlCq1yPE8z8tcSxUtzf+v67pxHNOyWJWac6kFgaspK9y9eZ3ystuMy3QeHKSUovOI+HB/iDF6hOg7HwMYESIwEdntzW1b/Hz11Vefffb5w/3DMHbBh+DJB+6jD8EjY61pTmstFaw6dofjkcndH/Zd13vnVOu8JFEwJFNIRQDArJV6QM362WizuyUAUxSwqtCFbthsN5uNC52qALML3PWxlrRM07xMRSwO/Vpl+2zUqmCE7ABAZVnXifr+2bjJpcDFnBpcEQ7kAntkP0QFNMRpzt6zCORcmFZVvX+434wbqZLWFQDUDAFqWh3BxQdCi6qooVRhZibZba+Z/bi9uns4EKJnzjmzc975XC40eRUxEAKspbLj59cjEooCgDr2jSwPTMiM3qloExsHAO9IpDrv24DWhw5FqoL3QUSLVO+9AVQF58iMFOjDjz7Tf/Pvwcdxe90Nm6urqxDCi1I2m81muw0+knO3tzcffPDBRx9/3BzNxq53zvWxKzl/8OLDPxFwLkYEJmBmVVNEI95d3XRdRwBdF6qkcexF/d3Dcc01V9mEOOxuUAqaNqID+6BaHTMCresaQ09a6jqxVdK8Hu822yug/u/kuvvxxY8wRX6fZgNPDTihQ0fjqKbIbtjtbp49//Knf+/wcH/39vXrb7++e/v6YX//8O6u1jy/eq3GYqLG43YTY2QikyqGVS1VKbkCWK21R055LXkRj2k90c14//BuPk3OMbNjx4MfmDnnXImC8yEEx4xIc0rneRmHrZltt1vRIqCpVMfsXVSRKU+qWktFxO3mer/fh9A5T7VUNeHgT/sp+LAdtwCwLMsyH5qnWPAOIaeUVcX7fhiGnPO6rjlXILcdd5urK+fjuL0SEXQcfAAUDr2RL4DNlHV3fXVOmX3PPsZug2jHk3HvnGqpFSggARB5Jg+gZgZkRD04Rer6MYbycDhXIhVtFCYAOB6PXd8BQM45pVRq2YybGCM5IiYzD81N0UCqDMMG2PmuJ+dffvRpSinG6J0HgK7riNE5dkhNv9KHAADLvJzuXy1vfy6qT8YQRtTYRG1B59g3C4Rc8jLPm80GALWdHtCUONgIa6kqSs6bWjOuzsv6k88//z//8//++YefAnpiarqizrkmaEJEhBxj7PsBCWOMKmpQFaiIhmG8ffa8KjgOzIhQihgaBHZD58bNpilpOsfEcHf3sLt6MQ7b//VP/tVPvvgjJZ9Enm23ktZ1XUspRORdTwTE5Dys60pERer9u7fcbwuGq+cvfR/fTyR/kPhRpcjfSo7f/z0iKgA6JuPeOQDohkFr7cft8w9e/r1/8A+n4+l43N+9e3s8Ht+8fXU8Hh/u3u4f9kPXicg0nebzWZSqkiiIca3GSOt0lrL0nfvw+c3NbvvVr365nmczVUHv8OrqZl1XMNpuw2bctT3GBy8/2u/3aui7vuvCklIIQYoM/WBa0tKKLJSs7Nj54J1PqZjiMI5mcjidhmEQw931bUrp4XgyteZT5qID5LWID3HXj6KScyliCmjOE7ACGTsOw7C92lxdi2g1MTPVWiUr+TjsQiwplVWE1QYXBBx49l0MZqUmMojeq8jh8OCIqqonZyrIHEIMvjvPK6K/vb3qx923376paCLinBcVUV2XNYQgqm2YkEs+T+cQQtd1AuCh05KLKHMwpJvrZ+xDqorsmIiaJhMis0PCrusctgxJZsbMuyslzdOrnzfJoQbyBwDHzkQAIISAiOu6NpvFYRzVLqaULY8TsQ8BDZOmcj5f3QR2rtRC7BnJpPzsyy+s2wF6ImIORKiPMHtmIvKOGRGJWQzZeUBGxKqgax53V2suzzZDTcs8T72nrg+GGmNcc8lVQgjOhyq43Y1IMXT+POf704xd3PRxyeVRocMh8bAZmxNcAzwg0nQ4uW40qXmd33zz7cefbdD3phUAgPj718Lf5iX4I4wfVYr86wQi2AVey8yEiEROJL8Yr3fPnr/48OOUkmq5f3h49/rN3f3bV19/ezwecwUuVtcqqEpRqSrkWgpb6Rx/+PzZH/3k4/1+v0wTO0ZtTs28zAs73u12ZrbkNGw36GjJBZ1nlN1uh4itCGsmKjE4IDRCMjQzQnTsnOMkdbfbHY/Hcbd99uKDdV2XNSOZQxIzQNheX7WBQDUttSATOSDnPMDpfK611lpKNQ5RCCj42HdV1QBMsZqpmhoCOmAl57VOU8pQtELox6GIrNOUSlUhRMhJmMl1WwIsKXlmIGMkRx2T345ezcZ+IORxGM7TWQByLo4dBFiW5VJhqUyHCQCe3T4rtRwOh824AwQFqlW6vnMhuhBd6OIYkLCV3iF4I9fSUIzxkiCb/CIyAGheXv25F0VTNQRsiYuJENdl9d4RsaoQMSI1I0kCBoCGAwOoLeGWNdUqMzukuQDHIhSiD05K2lx14AZ6YugTfu/U4ub90NKQIgAQw4XPqUDDZusilJqAfZZsKXlVZPLox6H3vssmPg5GjNQRxd3N7c//8hfbqx1t/Hw6gmUAQnTsPbuemNjYeyIO7LgY9uO2iAzsztNRVB0CMmmt+L6c/K+IP6AUeQH+AQDod30YEDEwdQDQ9dvQDVuAaTr7/ur65oNP1+Vnf++8f3g4HB4e9vuvv/76dNrfv7s7nvaSa1nONz19+GL7j/7+F/P55BA67wSwCfR679d1HTdjKlnN+nFzf7/fXu2WdR03OwAoYjkvu02fc2Xnc15LsVJqLcVEFcEIybELAZjTPIe+K1K7rmsNlHN4d3eH7Mig74d1XZv+2Dhua6lEbGaiUEopUnMpRWp0VK2KSjX1ItbMBqSqCoAZIWEwU/bB1JZ1LfJQNIsUATw8LEbNKtz7zpuAIWy3V4jIaKimaoiNsq6odTOMt9dlmmfJRQABXMMbvH37djNuuq67vr5++/atmX386ael5DmtIfZ9N5Ar42b0ofOxdzGwj41/2RIisHuyjnDssG1jiFSAmK7qcxe6FbSKECMxU/t/iRWximjOZtb3Q6lFaiVmuGCeGvRVDQTNSAtKzdNRkQBdzWu/uVZHaljzOnSbJpVm9h1Q1hAQqeEfHulJCABiRAZCxmY3N7dOV10mx2zKuYqh9MShH2I3uhDNjLwjDMgRga+ub9+8fXt4uHtxMxpZXgsAddGHrvddz+QASxx6BYueIYxKDByqCVR7/frbjz75CTn3W1Zr7+N3jT+gFPkY3/kUIwAQgnlEuAhVgJlZ6EYXpB83kuvVdb794KWIHA6Hf/RP83Q63d+/Ox32d29f79983UH+5MXOUTUpjmC7GaZlBWgOLpxSAYDXb95st1fEvK5rSqnv+3marm+uj8djcJyTlFr6EAEgL3POOecoWsgAkeiRSJeYEcDMcilMpGbznMZhJKb7t++Ox+PN7e0yp1LLRffbbF3XeZqG7YCNu6EX94U5zf4Ud7trFTMtqNrs7YkQEEWByLOjtdRxHAgIEcc4fjPdqxB53m7HaUkvP3wpVdZUN9ux84HR8ppM8nk6d11Yl9P1Tb/bjJ3nyQwQUypm6jiowOE8CeDV1dXLj8K6rvO8Xl9fT0vCIuNu2Phr9pF9iH3nQ+d8NEIiYvLsGIHJO0RsQO5WI7JztYhz3m1G7z0YqVbgy2OaSkd0PqUiooi4TBMANBsyZhIRBTDD83lhUzNb56mmnABUlZynOATUCkV88v0mDr3fRISQq/DjuaQIpn91D6sIDKAIw3aUWYywvelaDZhd6IrCYZ5d1dgPm7BBZMJAzLvdbrvdeu9Pp9PVblNrKUWqomFQ8kheCSj0AEAxeuWH03n0sYiNo//66699HG9vb1wIj6JC7+NvEn9wKfKJvorNhrhZOCAgEgJdDkht8q/GrC7GbuxFdHd9cz5P+Vn+8ONPl2U63d+l0wPXY5nvprtv0ARMVItJNbH9Yf/s2Yt5msdhZPJVNRepCst5vd7dzOVcUwKVrhun42kcx5xXVd0fDs0rwvsoVZBdLamqtHKSvUspAfJxmsa+KzmXvI7DGIIzk3k+mdoyLwDAjkvO7IgdmTV9Ik2rsKN1TTXVM5xNQGoF1K7rDAGZnYveu1xr7DZEtHv2bJrmEEL0nXfxp3/0x2/f3pGjVFcRU3CGNFztxqHvgrecJJeUKzFISebxfHiVjbab7u39fk7ZsSfya8nXNy/u9g+lwpJkM+7Y9/OyDKPF2HddR+TMbBwHYOdC511k76HZcZHjp6oQiV3T7wVQREFPARS6OL548eLh678AgL4fRLU1wqqalnVdlzYY7bwPIeScxQyCr7WaWVrWss6v794u6xTYac2I5Lxz7FxZD+mcx223ezZFb2xdH13cujCoKmg1EwIyRLm8ocuCCFqfYiBmDPb5Z1/+h3/zPwHA1dW1SVqWhRwbMYdQAJF9MmdJPTFiiR6//PLL/f7+p19+cT7sTb3zm93VhtCtVZzgZhhvn724eziMw3Bechiujq/v56+++skXf7Suq3P0L/7v/7f/7v/y3wMQYqMuXYwy3sfvFH9wKfK34686ZRoHBgCAiZlQGUjI7Pq2SylJqX0at+O4HDdlent+W853rxA4hNAFX1Ixkz5GqTk4rlK7fnOep/N0zrm4kVJKp9Mp+FBLbdbY67rmvDbsCwDUUgkppeS8M9P94dBvRgFzREDUINNSa5W63W73D/s1TfO81FpMresGM0tTyjk7h7nk8zylVFIREQP0RRTB9d1wdscYY/RBtHbDGLxjx8jcxa4VZ4i43Vw9sqs9EjN5IGX2teo8zUSu61AVzEAA1UxEUE0k50U0lvOcr28+0l98czqdDGkcNymV3a7b7nbzNI0Aqrrb7cZhaLv4NnAk5xWIjMDIEC6itc1MlRziRdmSvuNHUhtEAsBlJYUASABgqszsvEM1sUIqtWRTFatiVWtVkXWR8/k8z3NeU0oLiJSaEdEhOUd914mP7NhMp1qO59NQiilOm6ublxEpAJFZA0U9nT5NJfPSrqCBIpCBAWyudi7EWuuKCrUQueB7QOfiWIvEfmtI6OL5PKdl8d5/9snHn332uWO/2113XUeuQ0QjvLm6JeezqAc+HM9/+ue/+PiTj2OWq5vn/+Jf/j+XIn/8D//Jw939L3/58z/7sz/72c9+5kL3t3Px/EHEH3yK/KsCEZn5SRNMSdsUX1W7rrNozqFGHxxmV+t08P3Gd32pmZhjjCmdb692D8dT14/e+XU5m1he5pzLTJDTpi0KHqVntZRUamnQopTSskqM0Xt/9/Awjl37PRAqAiLWUolIVEqpb9++zTmTac2r9z7XmtOScyk555zZcSplSUVVihgYATpeF1VYulVy/eijD2OMjj0AIJL3HTpi75kI2DeluMucrhRCp1YDUR/6d8t8Pu5d6LbbUZuHrJamRMfsRKWKkcD19S3F8JMvPj+lv/zm1ZuS5eWHH6LK7fWuD54IguPd2CMiAJFzREQuuNCxc+S89755ziLy42LmUj82Mv7Tl/VduvxNhZvt9mq3uya0ZTpLWvJ8bPiYs2qrIs3sdNinlErOAI2xjQQgIsYO1FdVj7jMC3kOvnMupuPxrvxinZea8u1HX/huZxRECKkAgHu85dqjKfklP5op2LjdAfmqJgYGGGMP3s9rMV/EUKfkXVj0+Jd/9nMpdV2n/f3dduzJhXVdvSGxX0sO3E2pvLh6fjqd3ry7f3N3fzxNd//m33766ae766uc6p/8yb/75OPPd7sdO2RHLry3APuvivcp8q+ICzCCLj8TkIo2mR9ErLW60Bk7R5CpLvOxe7h2hwebTrUIGdzstimn4Pjmanf3sI8xmmhOSxFb5uV4PC7zkktWkZxX5y97DO/8LDLNs9Raco4xiurQ96VU38WWFMTJdJwcck6rY061ppSm06Hvu9PpRETzYSWmdVlzyY5dznnJxbA1WaTT2WZAZBU9n063tzchhND3yFTVPFjwHhEVm/RNo2Y7RDT0Jet8Phz3yUyMkCUiYi5rH70omlTV4pwjcMasWms1Ut0Nmw8/Hv/lv/r/PX/2wXk6v3nz5rOPPySDjz/8UKpUqWoWnB82OzNlH9nHdlmT8yEEdN672O5YTaMTvxeXL4sQH9fKeNGhJH10sDG1OS/3794Fk2U6zdOMhKfTKYRQSlFVduSZx6utc0zEyzKfTue8zHG7Jc8xRheDj71ULSppPl+Fofc071/9xb9NZvbso5/67prJgV6Uw6HJnZAioKkB2KPAOAE5Q1JyGAKKd11fFfbn03GVfhznu/319bP7+/08r3dv3+12m9fv7krZIfspl4ozE+UKvg+n0+z78/7hGEL4xc9/2XXDJx9/8vO/+MXnf/Tldnt1ms5ff/3tP/mn/80//+f//Muf/f336rr/lfE+RV7iPwacf3+iRExIKCKqyk/YNzTrd1cvPjo83JVf/TIV6fueO62pgMnV1dXxcOy9UxPPhCrrvBzS/XbT57Tcv31zdXVlFQUREdvipevH87TknFMqPnSO/bKuhAjEzjsiV8oSfFjnZX/Y11JR5Xg8SslSi6g0dlpKaV3XUkuliohSa1ExZO/iPE1GxHycpzmEAExG6KNHcGvJpchazrvrq1xyVWiVrIiJgKmIyus3X6XzOUZ/dXttUrdXm/l8hJJxMzaZj5xSjNH5qIqkpoam0I+bm2fP377Zf/LpT9DUx7jbbPtx7PteRNqGY81l3IzEIXQ9Ou98ROe9886FZuPVgsg1raD2jTx9U631VtWS67IkIraC65rO53PXdctyLjkjFAAVq2lOqnVZCjN775i9Y1fVtGg/xJcffnJ9k97dvQs+gKPd9c20zJsYq7eIDESeAXTtnEv5+NVf/mlV+vTzP1aIofcAoNIEjVCNLonSABEFEBTYh+sXL46Hd0RQKZ+LLHMSdMhRjNn1/+P/8P/YbTY1lWfPbhGti8Oru7vr5y/CsJ2Xpes8IL16fffiw4//7C9+6dj/2Z/9z7dXt3/yJ3/yT/7xf/P/b+/MnuS6jvSeeba71dJdvaABEKAgihQFkqY0pPzgGVlvdtgvdjjsCIcd4T/V4fCDYzT2SCJH3ECCIAgQS3fXftezZPrhVi8AVRI3OUzq/B4a1dW3K7ou7v0qz8nML6u6vX//4WK1zAdF09Rd63726osA8mzHPSrlNyRK5FelvxVBbNp1gJhIySTPh3vZcAdUkg9GwitqGnAOiXzXet8BiD6imLettVZpXZZrACirVdvVRFzkg+FwCADWWQqUFwVwcNb22dgQPEg1X8wPDg6ss4hivpwzc900EpC8IyJnXUuOiIQQ3l10s/QNyIiin77TV2sLRArk2EFfpyIlSMnA5Lju6n4fEJURUhMIRokSEfppaDbVymOQqJr1arQ3Eci7u8NmXXadUAJDIJ0YrbUQglk4a0EqlBqF2pscFMPdNE2LLB8OhtlGfEORpnDuQC6VFFJqA1KbNFfKoJIAoOTFJfpV6vu899ibnqNAgU1T12XVdR0hEwExdNYDYJblfXQnEyN1QtbmwyETewHpaDBGrspSCKyaOs0HaV54IkQJApVKnLeIkCQa0Z4+eRBYvvTT14EDoRRSMhMCInEvlNhHkUyMjKD3D64+/uLzrqma1nkfEGU2GCwX69livZovbOc/eHDnRzduAovWdyfTmdCiatqyqaWUAb1zvm7tclXWtZ3NnxKI//4//meepu+8+0+j8fh0Ns8Hg+VyPZstJ5OJ2Awlp5ik+TZEifwaoEDZVxqHIKQKTCGQMul478rOweHUramyUktsUUjki1ILAhAhWBs6gvD05PHOzp4jn0CSJMnxyZPp7GQ4HO7t7dVNl2cZAQdgFii1qutWC4EoloslMw8GAwCYz2dKKdfZuirbpiXve3vXc4mUSmqlgw+Bgjapt4GJffAoFAr0TOxZGSOlAsGda7XWQkIbuiw1AMLoBKXoPceAEIEkgEiS8XjMXZ0abdKEg09S3bSVlsjBEwgpRZIkSZIIIUXwgQilAqFQ6ls/eVkoI4RI0xwAlDRKKSGeuW+TRPP56EcQ3Dt3IoZ+2Gwf5m8tXqHzr52zIORGWFk0bds7AwnwKik8Q2WdQDE6OOi6zlpbO3tld3+S5xRCAPbkpZDjvT0C1loLVH2GpC96YIGkgaVCIYSQeWJEJlbLp5/dE9duvKJM3vvxAQALEr1QQggMzJKBneXRzl4x3Png8/snT49Xq1XTtnkxTEy2WqzKZZmZpGvdyXSW5lkIblEtDw4O/vHddwKF4WBcFIXRSevC00/uhAD37n3WNe1qVR4eHrWNBSyvXL3++3ffsdbefv2f7e0dAOr+UrrcXRP5ukSJ/Cb0yz2lVCDJrNJs+MKNl5bT47oqBcuAAoUSUiitGUCCIAQCJbXOi9w7T957SxBIMHRdp5VeLBZlWY1GOwKxLEtjjBRSSeU9KU0Kpes6o81yPp/PZ/PTGSBpIdfLMgQnkQUqxiBQIro+yDXGMHNjHUgphITgmUNfRdxvp5o0EyYJLG3jUpaIggm1MoBSyASldC6gSIn7IWbCmGRnd9fVy8xo57s0zcjbJEmM1AAglBKolE6kVlJKDopbK1AJlIg4Go1QmCzLAyCCBBB9BJdswhzAfhp4vyAE0bvafLP/Gueot1YEgUTEgUGq0XBA3gkJKHVAsa7q4WiCVcnQ7EwOGEVWDJbLubU2hNDWXZLo8Wj38ZPHaZpKoXVbeyKBMkjMjFJJolB7CiFYyW6QJavlSZqNdvavaZMCAJ1NtkCBwChQMjCzztJcIv/4pZ9+du/zT+//brFcBk/GLJIkG2QDBtF6qq0Tq9Ut81K5alpLrNSH79/Z3Z1MZ2tjUiWlyfKu67yjsq4VKg9499MHaT4ytb31ysGNF2797d/97a9//avheBQnfX0nRIn8M5zvUZ77kxMIlEBMUkgtFAlpTGry0XjyQlf7unvEJs2yAolNPqqrygc3GA2FEKuyqqpaayOl8BRSo31wRTEIwffZg66uIYR6XYck1EndVI2WhhzrVNfrmjQvFvPlYgFEzvtVvdJSCCn6UeAucNvVPgRmhiCUD0Jp8F6gFCilZGb2PnDoXPBSZ13A2aoVphqPd5Qe1HU1GB2Oh/sBQAodSBCLuiGJ2BciAlCWZUpKpSUKtTMcpDoljzLPEKSUQutUG6P6gV7oi6HunO/34FAok2UqSZFBoAIWvYiE86iQeeM4AcgoEJGI+/3NvngHhGDmvr6v57w5GhEZ+ybCwBS0Vo2QgKpPk1Ogg/1JkeVNXYfghqMEULctVnUgUMOdXSW1lKosG/agWCohiUJofcCwO9qdLRZFoepy5UJQCrNi3KzL0TgxhamWlQtzLNcoksnRjaZaDkY7aZqC6N3YBPX+Hn25EkqCIKTJUvmTV9545eU3/uN/+m8nJycPHt4/OTlZzFe+s23bWtceXJs+efTFnfuf3bz54mBnj1FIVaxLm6YpIKOQLnDnAhMUw3FVNaYYFMUwHY1v37791ttvHR0dHV25AkigNAAASsC+mOH/0f3ywyNK5DcHBSolQ5DGmHww3tm7Wq7L2eypQFO1dlhkTVVnxZAoWGvzQaGNKVgEIkQsBqPFfJ5kmTaaAoQAzFg1fa7G+hC6rhuPd9I09d7V61owcICmrJuy7avBEZX1rhc+ItcbVjAEJnbOslJaa0bZdI77cVbM1rYgCACRuvp4+uDJb97+5S9/fnAtoNGpTNJB0wWV6LrthEoRJaIRAgA8QAiWdncm86KQklzVEgUASJIMUEuVKCWFVCbJpFLMJHw/SofJBSbHqIo0AyGRJaIkAMHPhzb94DAWKM+8IfqveDYX+/zIi/7oC5jOypP6AFwKnRjddm40GBb5kCGgQPJMgaz1VdMNHBejMbPv+7WZyRNiAA4EgCHQel31cl9VVZoZAEKZIFOqje+sk2aQ57PFKslSrUS9nifFXrlaoFRpXjADQ8BntwUEC8FEIIAFIB4eXT84vPbTn70GvbMjIjMzBwoBBVrrmqbWQkklXQhKydVqFQJ57/ox7kSkVZKmaVpkSuk0TbMs1doAACDC5nP97KRFffwWRIn8qpy7mvc3LSICsRCCpC6GI0TUUmktrauPjz9nlifL2ii9mK/29ydSp9YHYgkShGBrbVfVSVawQE/gCQSxJ3DOd52zPrDzXddZT0mSkPPO+yLNhBRV46xj6ywTo0BrmQIRBQDRemYGRgTAgNg4chSElJ3v+oVnCKDSjIVEKRlU2QYXwnvvf5ik+cuvvJxlGaFABAbRdV6xA6G6bq2lMAoMgndWCNl5zpVOihHqDKU2SWYZtUmVVlJIoQwIDD44TwGImety1XoGYQ4PD4XSzgMLIc7qBC7DyJuAnZ9ZGfbieLnegM/m+vbfCiEQuR+dyORHO3vV4il4QqXYEwgMwLZpnLeOrOC+6FWvy3Z374pznVCMDJ5s8Kx06kOTJYlvA/ugpE51enz8BHmQJAkFCJ4yIUkwsR9kw9W68p3VKmEfvG3Xq4VQWuoE+2w7Amw+CQTyZg8BgAVyIPIhIKKUSMTUz81FhH4bVcrEZHk+YEJmLqRg4tFw0ks5AKDS0Lc2aBmck1JtNPH8JDEA8tkSOwrktyJK5LdDCKmNVMkoSUaj3Z3J7uELVz//7O4ndz4uV4vFdCYK8+B4mRdpoo2nwCBRIKRpcN5RoC4kifLgEaQnDqg8+aBMsL4LcLoopayRgZlXddf3fbeMlpACUecD9e2TkhEcKUIClogoteoCtZ6kAGs5TZNAbINTMgnMriPvmkBap9m6bX/3hz90RLdu3dJZUeQZoSAUdWe14t7Ftl5V3tbtutzZHZkkywaFSozSWpg0CAEkVJL04w08MXCwznedA2BkaJrq+PjUEd64cSMplJAJgmR8XiKJCfFyggv6z4DN4z/ZY9znqc6cKHhvb7J4nNe2coESra3163XV2SqEVgImSaZMmg9Gq7JygUBIFAjsGYVlKNLcE5s8t8TCkFBaGW66AGU7RAlKs3UpU6oLIiTmg4ODLx4/NYFTKb1t2cMSpUnzfDhgEH1R5Hnnz2XkRSBMQiCC6N8IMwJhAEABAiVKBQJt1wkhEBQTBQJmVhzQSEAAAqk0MD8jgwzADMhRHL8TokR+DfrI5dy5ABABJApgAhQGEhhf/dH46o9+8trbv/pXPjjnbVuWq9Vi2VZlWa3W5XIxna/LdVWWVV1X5aqtm2XXAcqq4eDBB6CAAoQP0rGBABAoECGRlCCQpOKm8T4wCmSUznvoF5kIgCYABR8CkTFIhM4Fa1sAUK6hQCwktA1KDVJIkQidklDGpIH1+x98ui4diPTwUGVpZq1nRts1Agh816wX1LUA8PGduypR6VgFFs5j0Ioc54Nh1XStDYNBUVa1VBgCucCSw+mTR4Lp+MGD0d7e55/efe0X/xyVZlQA0LftwJn8EQsm7iMtZiLmfuIfInrox1Ve3oWk83wUEYUQ+mkKACBQjMa7JsunU0eMzvqDvX0GUdaNMQIAm84JlRYj0Yawrkpt1Ol8ORmPhTKBazRJrlRAHO0dLhYzAME6He4fzk9PVJpJkIjKkUhVKoR0JJRJj67dKOu6c1a5Js0S15Tr5TTJMqGBNkEx97l7BCRgQCRgvKh7F4Kh93UXl66xs3cKwNy3xzBib48Cfc6c4SK//+Vc/8aAIPIdECXyW9NXVLAE2LgHotBCAmqXFKPhzuHRNc/EKBjPdqdCCM45Jh+8L8vK27Zp6q7rFstlVVbVelmW5XK+qMpyOjtdr9ez01PP7JyjrnOOrHMUKITgrWO4GPMNAGFT/GgRMRB55wJRP0EBABiENEGZVErOB1pISUK3HijYJ6dzeO+jH62r69evCyERJXNg202PHxoOCHTz+s3P7t9ftlUZ/P6VoyRNBEvyLDqHiCxCY7suOAgQfAjONrPp08eP5sdPAWAwKB58evdvfvkvglT96eo1Ec4kUp4ZiJ3Fgnw+v1dtTJj62kwOIVzkzYj6b51zm08v9qjMaLw7PcmaZp0naWBsnQdUwQfHlCrjgRihrsvgg9YmSbQNJJiF0rVzeVoorUPwxXgSQlBCHujks88fOJCYDIqdoc5GMskJhEwylkpnCXdeJ8Xp8cmLt0aMPD09GU/2E10IxEB8nppnPBc1cSFvLAhpa0nOpfQU4GXJO1fAGCr+xYkS+d3QL3WIN1eyREat+zsBA2K/FEIEZkCUCqRhkBKYB3sAHAAAKPTGrkrKQASBiLjvf27Kqm3b1WrVNNWjx48W88VsPl8ulydPn3Z1VVartm1Xq0U/gMF5DwwhBEfeEXvfAYTGdsFzOkiNUKmRUia1Deio7YIQmohmy9VgtHP38weEop+XIJEX0+NmterWs6P9PWtbFOqddz+Yle3V2u3uTQ73IE1y4soYI1m5EJz11tpAXjGlWVqk2WfzmRBiPNr1XQBiYQRg35rHsPF6OJMNIeGstVnwJv0CAAKQz+jn4p6vu/u8DV2C2Wsli9FY6qSeT5Mk80y+dQh6sVoXadEy51lKSNZ3LpDxYV2XllxffuQ8EAqZZBLAKF2WZapVMd65+uLp8fFx6wWaPB3tgTY+MKKR0qikkJmbr9ftav3pnY92rtzsQFTVSue5koL7qWXnuanNHGN+ZteQBeCFB8azNTq05Xm8sD+9LJ1fSoJFvj1RIr8DCPD8micCvPiu10t9diAD0SbiQwBAJiYgRImIqPrtJQYAwYQKNgEIcVKMBMNVZkT8ObMPAXpF9cEH67313tu2LstqsZiv1+vpdObarqzKui7n83nn3HK5KJvaWts527Wu84SI3gXnPTGEQHXT/e6dd99+++2P790fDAqjZJboh3c/VhiuH+xqlUyny7a189V6+dHHx+v13sGVq4ervb1Jok2epFIpAAieqrbx3qZKXh+P0zQdFMXJbNF5Gu/uNJ3LM2Tspx2e3fxis7Q8bysMFJhZnLse4yZV3dtknB/ZN4P2HhZE1I87DyGQ9Sx1NhqrxSwwe4DG+cSoYry/mM6uHoxPjqeHVyZaahBJlmWr9aKp28Rkg9HYE7eeDcvhYAgA0hELlFr/5Ke3y9aKrMjG+yYfu8Bd16JCrVJPOBhP7t/7zC6nTbUeTBc3Xnp1OV/s7B6yYAmSnlsD43fV60J//pDId0GUyG/I5T2jZxZK+Mw/z9wgiCDkM+sl+eW+h14F5MV91Bujn+3II4DWlw//0q3SL1H7zTsk53znbNO2ztq6adq2rcq6btvlcrler2fzWVVW0+l0Ops+fvT4f//2d7dv37Y+NFVJXWvrlSI/yrJuzCbJp7Pq5HTBplR5rrMhiNP7D7/YGY5Gg4EUsus6IQGl+OSTT1+8ekVevbI7zPPd/Ru7R1d//Mobv3g7zQfnBXoCt1bqbU6JPH83/vxH5zq4OTFC0NkYHKUUABBraRJlkiQbpHnhvWVUZjRq2naQDw7M8OTJky/u36tXywzQXL4AAAiDSURBVCwp8uGOZwor1ElmkoJRZ3mGSuukSPOhtQ6wbb2br5bZoNi7dn21WjEIEGZ6Mv3ggw9Go9HtN96QIgyHw8wki2qRSCl9tT59fHD9BgpkYkDCS7kmlP2Gab8bs2XO0qWSpq8tpXHN/RcgSuRfmO/qqt36Ol9aW/U1NUICACJqBTqDYsjMfF5R2C9bnXPWeu/9er2ez+effPLJ3bt3f/P3v5lNp1qK0aBoqvVstnrl5cyCni7L1nOajRpvHz86bS1dPbo6Go3KuvGeiKjruuVy7r2v6/bG4ZU2hNpytrM/Obj6+i/eOrp2U6qMUbDAP5Wf/iPv+/kPkX6tfXlrsn9eKUVARBKlFsookydFDkqty7ULXFZzyWCbFkCsVqXO8jasJgf7L956yRhDgRmEMmkAAJQ28GyxfPToibe2rFZFnu1fOWytM1k+na/fffe9+/c/U8ZcuXr94OCgqqqjo2v37/x+72CyWK3QFN62Evp6Tr5oGtqIo9gmjpH/P4kS+QPkOdciODMuOq8oRERElSSq7wDc3d29efPm7duvLxaLf//v/sN7f3jnww8/On36JEsSKc3TRTma0M2bN18r8p++9eZiVc6W87KsVqvV6fFUCWGM0UoLKRCSQTEaZGGxast9Pc4nb7/55quvvR48SZ0QCGBGFFvmF2yBL0XrvSUawLk49uU+F29TqoCAUimdySSVBj2BUKYt113nbFW7ai1QeZAQGDxpkx4eHXSt67oOpUKptNKN7ZKsKOv2/v3P0TolADurhNjfnVhPddN88NGdqqoJ+N79z0e7E7b+yt7B9Ru3yvlcgJmeLLqmBQpG6C54qZOLPy+K4/eQKJE/fJiZAgFA7xp2/iScielmrSrl/t7ewcHejesv/Nt//W+8921XW9uWq0VZlpPJZDKZeCaBEqREkOy9D6F/ZQCQSjKzVtoYXTcNBRoMCmL2LHWawMbMEfmPNcf86T/+/HG/+Xi+I/lcFAkAAYBAMWqUWuq0s62QIctH09lKmeTJF0/q1XJvNJQy3Z1MQCAxMmpphBGSGOvWzpan165effj4iZBqPl8MdDLeGR8dXnl8+iSHcfP5A+uk1MmrP7v10Z2PHj54fOPGj4qicIFefe1v/uHv/xcFCp47G5i530WNsvh9J0rkDx9E3Ex6efbJ88fPqBZDVqQAkAAUMALYJEwAqc8+MwH2XpDnv3FmqXlutT3USZ+D6rdeN3IMAUHy13VVQLjIbl/6O/vHfZ2g915KqZRyznnv03w0GE3m0ykSC4mIOivG3nuWZr5ux6O93YMjaZQPLknzuukAQCWma631ITD85re/GxQjyVCVtaX6YLL38NHjwXiwWpXjveTe/Qens/mtl17e3TuYLZfvf3jnzTffJGHYMOfjh0/up1nx4iuvmrwggjQ3zFv2HOM86+8JUSIjl3gmuXT+SFDfcwmMDIjQD0O9uPfpTL/URXKif8AAfcX0l1/+q9Pnds7tc76MUqqfdaiU6lqnTJoPxpO9o5PjR853AQIKQ8w6zWrr/vHd9+7eu3/l6ODq1f29K0cgFQgErdFRuary0bj89F7d+gef3pseP72yu1d23Wg0UGlWl2vTuawYZNmgabr9/cO2af7pvfePrr2gTAIS/uH37y2mi//8X//LaGeXogj+UIgSGbnElptaMPQd3BfpegTatAXTprdD9P12AgCYw6VY8byARyHAdqH7M4jt86AJ6GyyjdrdP+iaXAJ7262W87KpfGeb1q7L9bpsCJQjfPj0xDHfePFmZW27CCBQJaZqus6HL+7eUyb95JNPtTYO8OOHDx8cPz44OvzZz17Jh4NHxyccknwwnOwfrFarFGXTuf/z29/O1uud8eTtX/7dWz//+euvv2GKjDa13lElv/dEiYxsoC+V2m2mZZ0L4LZffEYH6EtKtqkE7F/9L6QZZ2WVmEiVGTPKssnOaH9/9/3337//xcNlOa/rFqXJR+N1bavV+ni2eufDOy/W9Wg0IgRl0rprm7ory9p2XZoP1ssVCe1BTte1U7P9Zf3CaOfBFyfz2bpt/HS6KOtqNBqNdnavXr/xL3/16xdvvZTneaqNSswfOwmR7yvPeAdEIpeF8rmBgsybDch+if1cYvo8xBRnr/DcNlx/vPyaIvnVr8/NkX2HCQcOjpnD2a8vl8tN95G1s/msWpWz+WlZrk9OTuq6sdaikkxUlg0AJElSrddPnzztui7NTJZlu7s7t279eDabAYu27bIs392fvPXW29dvvPDCCy/0y/x+TOPld7w5H5HvM1EiI8/w1SVyc/xFI9FzEimeu7S+mUR+AyhsejovfB7OStWf63XBfpKPd8E6FOh9aNsWAJSU/SghpbUUQpwNFh8MBv1oINFbsAmUQj6XCjvvl48S+cMgSmTkh8llc6Bz+ijvGde1M1MMOFPMvkxHwMaYlqnvgCToG8nFpurIWmueHVH93K105loSJfL7TZTIyF8Rl6tBzy0m+zDwUvS3OZIDCSEA0VsrpBRn0eJzR56/7HPPR4n8YRAlMhL5DnimySeW+/yAiBntSOSPsK02KcaEf21EiYxEnuGyOPaRIW75aZTLvwaiREYiW4kL5kjci4xEIpGtxLVCJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbCVKZCQSiWwlSmQkEolsJUpkJBKJbOX/Agv3+BRllhWjAAAAAElFTkSuQmCC\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q6.ipynb b/Task/Q6.ipynb deleted file mode 100644 index cd4ebce..0000000 --- a/Task/Q6.ipynb +++ /dev/null @@ -1,74 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 6: We need to find the prime numbers in an array and compute the absolute difference between the smallest and largest ones." - ], - "metadata": { - "id": "-z36PJSu-YXl" - } - }, - { - "cell_type": "code", - "source": [ - "def is_prime(n):\n", - " if n <= 1:\n", - " return False\n", - " for i in range(2, n):\n", - " if n % i == 0:\n", - " return False\n", - " return True\n", - "\n", - "def prime_difference(N, A):\n", - " primes = []\n", - " for i in range(N):\n", - " if is_prime(A[i]):\n", - " primes.append(A[i])\n", - "\n", - " if len(primes) == 0:\n", - " return 1\n", - "\n", - " smallest_prime = min(primes)\n", - " largest_prime = max(primes)\n", - " return largest_prime - smallest_prime\n", - "\n", - "A = [1, 2, 3, 4, 5, 41] # Array\n", - "N = 6 # Array Size\n", - "print(prime_difference(N, A))\n", - "\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "8zjDJhLc-eQJ", - "outputId": "77c16a39-e2f1-48a1-d902-7c8993d510a6" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "39\n" - ] - } - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q7.ipynb b/Task/Q7.ipynb deleted file mode 100644 index 5738029..0000000 --- a/Task/Q7.ipynb +++ /dev/null @@ -1,69 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 7: For each product, we need to find the minimum prime factor of its MRP." - ], - "metadata": { - "id": "xp5I8Z40-ktO" - } - }, - { - "cell_type": "code", - "source": [ - "def smallest_prime_factor(n):\n", - " if n <= 1:\n", - " return n\n", - " for i in range(2, n + 1):\n", - " if n % i == 0:\n", - " return i\n", - " return n\n", - "\n", - "def amount_roy_pays(N, prices):\n", - " results = []\n", - " for price in prices:\n", - " min_prime = smallest_prime_factor(price)\n", - " roy_pays = price - min_prime\n", - " results.append(roy_pays)\n", - " return results\n", - "\n", - "\n", - "N = 2 # Array Size\n", - "prices = [5, 10] # Value of prices!\n", - "print(amount_roy_pays(N, prices))\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "jd8Qoge_-pSC", - "outputId": "8fda6619-fcff-4b84-9e36-63e607c0f10e" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[0, 8]\n" - ] - } - ] - } - ] -} \ No newline at end of file diff --git a/Task/Q8.ipynb b/Task/Q8.ipynb deleted file mode 100644 index 86474a6..0000000 --- a/Task/Q8.ipynb +++ /dev/null @@ -1,49 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Problem 8: We need to count the frequency of each element in a list and return it as a dictionary." - ], - "metadata": { - "id": "Wx6GsI5k-tWE" - } - }, - { - "cell_type": "code", - "source": [ - "def frequency_count(input_list):\n", - " frequency = {}\n", - " for element in input_list:\n", - " if element in frequency:\n", - " frequency[element] += 1\n", - " else:\n", - " frequency[element] = 1\n", - " return frequency\n", - "\n", - "\n", - "input_list = [1, 2, 2, 3, 3, 3]\n", - "print(frequency_count(input_list))\n" - ], - "metadata": { - "id": "u6xn0fsr-yUe" - }, - "execution_count": null, - "outputs": [] - } - ] -} \ No newline at end of file diff --git a/Task/Reetika Acharya/readme.txt b/Task/Reetika Acharya/readme.txt deleted file mode 100644 index f8b8202..0000000 --- a/Task/Reetika Acharya/readme.txt +++ /dev/null @@ -1 +0,0 @@ -python taskkk diff --git a/Task/Sample_Name/sampletask1.py b/Task/Sample_Name/sampletask1.py deleted file mode 100644 index 8ed92c7..0000000 --- a/Task/Sample_Name/sampletask1.py +++ /dev/null @@ -1 +0,0 @@ -print("hello,world") diff --git a/Task/hello.txt b/Task/hello.txt deleted file mode 100644 index fa49b07..0000000 --- a/Task/hello.txt +++ /dev/null @@ -1 +0,0 @@ -new file diff --git a/Task/sample name 2/sample2.py b/Task/sample name 2/sample2.py deleted file mode 100644 index 8cde782..0000000 --- a/Task/sample name 2/sample2.py +++ /dev/null @@ -1 +0,0 @@ -print("hello world") From 80edebf7d026459a54b89293f4e05239fde0447f Mon Sep 17 00:00:00 2001 From: Reetika-A <163577113+Reetika-A@users.noreply.github.com> Date: Mon, 17 Jun 2024 23:46:49 +0530 Subject: [PATCH 3/5] Create Hello.txt --- Task/Hello.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 Task/Hello.txt diff --git a/Task/Hello.txt b/Task/Hello.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Task/Hello.txt @@ -0,0 +1 @@ + From 78b20dcc1227d5f4c11d183a1efd7d67a7c2a0b9 Mon Sep 17 00:00:00 2001 From: Reetika-A <163577113+Reetika-A@users.noreply.github.com> Date: Mon, 17 Jun 2024 23:48:40 +0530 Subject: [PATCH 4/5] Create hi.txt --- Task/Reetika Acharya/hi.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 Task/Reetika Acharya/hi.txt diff --git a/Task/Reetika Acharya/hi.txt b/Task/Reetika Acharya/hi.txt new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Task/Reetika Acharya/hi.txt @@ -0,0 +1 @@ + From 3648a06ae28c4c2ff406e24d8c52bcb8a2e0e78e Mon Sep 17 00:00:00 2001 From: Reetika-A <163577113+Reetika-A@users.noreply.github.com> Date: Mon, 17 Jun 2024 23:50:54 +0530 Subject: [PATCH 5/5] Add files via upload --- Task/Reetika Acharya/q1.py | 17 +++++++++++++++++ Task/Reetika Acharya/q10.py | 28 ++++++++++++++++++++++++++++ Task/Reetika Acharya/q2.py | 26 ++++++++++++++++++++++++++ Task/Reetika Acharya/q3.py | 31 +++++++++++++++++++++++++++++++ Task/Reetika Acharya/q5.py | 37 +++++++++++++++++++++++++++++++++++++ Task/Reetika Acharya/q6.py | 35 +++++++++++++++++++++++++++++++++++ Task/Reetika Acharya/q7.py | 31 +++++++++++++++++++++++++++++++ Task/Reetika Acharya/q8.py | 23 +++++++++++++++++++++++ 8 files changed, 228 insertions(+) create mode 100644 Task/Reetika Acharya/q1.py create mode 100644 Task/Reetika Acharya/q10.py create mode 100644 Task/Reetika Acharya/q2.py create mode 100644 Task/Reetika Acharya/q3.py create mode 100644 Task/Reetika Acharya/q5.py create mode 100644 Task/Reetika Acharya/q6.py create mode 100644 Task/Reetika Acharya/q7.py create mode 100644 Task/Reetika Acharya/q8.py diff --git a/Task/Reetika Acharya/q1.py b/Task/Reetika Acharya/q1.py new file mode 100644 index 0000000..6fc6709 --- /dev/null +++ b/Task/Reetika Acharya/q1.py @@ -0,0 +1,17 @@ +# -*- coding: utf-8 -*- +"""Q1.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1_qefXhBTnSuDgCuwjyJm6uLQWpKgXtXy + +Q1. Given two strings s and t, return true if t is an anagram of s, and false otherwise +""" + +def is_it_anagram(a, b): + return sorted(a) == sorted(b) + +a1 = "sharp" +b1 = "harps" +print(is_it_anagram(a1, b1)) \ No newline at end of file diff --git a/Task/Reetika Acharya/q10.py b/Task/Reetika Acharya/q10.py new file mode 100644 index 0000000..8f5b771 --- /dev/null +++ b/Task/Reetika Acharya/q10.py @@ -0,0 +1,28 @@ +# -*- coding: utf-8 -*- +"""Q10.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1-817KKsWYI-BHnRzBgKoNHHsPlkrKM14 + +Problem 10: We need to transpose a 2D integer array matrix. +""" + +def transpose_matrix(matrix): + transposed = [] + for i in range(len(matrix[0])): + new_row = [] + for row in matrix: + new_row.append(row[i]) + transposed.append(new_row) + return transposed + + +matrix_input = [ + [2, 9, 0], + [7, 2, 0], + [0, 4, 1] +] +print(transpose_matrix(matrix_input)) + diff --git a/Task/Reetika Acharya/q2.py b/Task/Reetika Acharya/q2.py new file mode 100644 index 0000000..96df612 --- /dev/null +++ b/Task/Reetika Acharya/q2.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +"""Q2.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1OMuQ-7hTg1qkhu7dyIt0nX97cKzz14wx + +Problem 2: We need to count the frequency of each character in a string, considering upper and lower case letters separately, and ignoring spaces. +""" + +def frequency_of_characters(s): + freq = {} + for char in s: + if char.isalpha(): + if char in freq: + freq[char] += 1 + else: + freq[char] = 1 + + sorted_chars = sorted(freq.keys()) + for char in sorted_chars: + print("The character ", char ,", appears :", freq[char] ," number of times.") + +input_str = "The quick brown fox jumped over the lazy dog" +frequency_of_characters(input_str) \ No newline at end of file diff --git a/Task/Reetika Acharya/q3.py b/Task/Reetika Acharya/q3.py new file mode 100644 index 0000000..86a222f --- /dev/null +++ b/Task/Reetika Acharya/q3.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +"""Q3.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1sadMtX96lpZC9uzNofbnj6moykdE6JYa + +Problem 3: To increment a large integer represented as an array of digits, we can process the array from the end to handle the carry. +""" + +def increment_number(digits): + + reversed_digits = digits[::-1] + + length = len(reversed_digits) + for i in range(length): + if reversed_digits[i] < 9: + reversed_digits[i] += 1 + break + else: + reversed_digits[i] = 0 + + + digits = reversed_digits[::-1] + + return digits + + +digits_input = [1, 4, 3, 1, 9] +print(increment_number(digits_input)) \ No newline at end of file diff --git a/Task/Reetika Acharya/q5.py b/Task/Reetika Acharya/q5.py new file mode 100644 index 0000000..02f25da --- /dev/null +++ b/Task/Reetika Acharya/q5.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- +"""Q5.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1CxRsflmUb0WMdPrh0IS21aJDs244tH0t + +Problem 5: Alternative way, that is taking images from a URL +""" + +# We need some additional packages +!pip install opencv-python-headless numpy requests pillow + +import cv2 +import numpy as np +import requests +from PIL import Image +from io import BytesIO +from google.colab.patches import cv2_imshow + +def detect_edges_from_url(image_url): + response = requests.get(image_url) + img = Image.open(BytesIO(response.content)).convert('RGB') + img = np.array(img) + + # Converting to grayscale + gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) + + edges = cv2.Canny(gray, 100, 200) + + cv2_imshow(cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) + cv2_imshow(edges) + +# Example: +image_url = "https://www.omlet.nl/images/cache/438/512/90/Dog-Labrador_Retriever-A_healthy_adult_Labrador_sitting%2C_waiting_for_some_attention_from_it%27s_owner.webp" +detect_edges_from_url(image_url) \ No newline at end of file diff --git a/Task/Reetika Acharya/q6.py b/Task/Reetika Acharya/q6.py new file mode 100644 index 0000000..7e9ff30 --- /dev/null +++ b/Task/Reetika Acharya/q6.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +"""Q6.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1f3HVSneY4soTc8fuknWI20HUEtIpAKiO + +Problem 6: We need to find the prime numbers in an array and compute the absolute difference between the smallest and largest ones. +""" + +def is_prime(n): + if n <= 1: + return False + for i in range(2, n): + if n % i == 0: + return False + return True + +def prime_difference(N, A): + primes = [] + for i in range(N): + if is_prime(A[i]): + primes.append(A[i]) + + if len(primes) == 0: + return 1 + + smallest_prime = min(primes) + largest_prime = max(primes) + return largest_prime - smallest_prime + +A = [1, 2, 3, 4, 5, 41] # Array +N = 6 # Array Size +print(prime_difference(N, A)) \ No newline at end of file diff --git a/Task/Reetika Acharya/q7.py b/Task/Reetika Acharya/q7.py new file mode 100644 index 0000000..673e18a --- /dev/null +++ b/Task/Reetika Acharya/q7.py @@ -0,0 +1,31 @@ +# -*- coding: utf-8 -*- +"""Q7.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1FarMJ1RQ9zDo1A69GDdsPK4AgsqBNCF8 + +Problem 7: For each product, we need to find the minimum prime factor of its MRP. +""" + +def smallest_prime_factor(n): + if n <= 1: + return n + for i in range(2, n + 1): + if n % i == 0: + return i + return n + +def amount_roy_pays(N, prices): + results = [] + for price in prices: + min_prime = smallest_prime_factor(price) + roy_pays = price - min_prime + results.append(roy_pays) + return results + + +N = 2 # Array Size +prices = [5, 10] # Value of prices! +print(amount_roy_pays(N, prices)) \ No newline at end of file diff --git a/Task/Reetika Acharya/q8.py b/Task/Reetika Acharya/q8.py new file mode 100644 index 0000000..9ed4cdc --- /dev/null +++ b/Task/Reetika Acharya/q8.py @@ -0,0 +1,23 @@ +# -*- coding: utf-8 -*- +"""Q8.ipynb + +Automatically generated by Colab. + +Original file is located at + https://colab.research.google.com/drive/1q9OL93fUDpJFoQdG-z3lbX32SlDPe7Iq + +Problem 8: We need to count the frequency of each element in a list and return it as a dictionary. +""" + +def frequency_count(input_list): + frequency = {} + for element in input_list: + if element in frequency: + frequency[element] += 1 + else: + frequency[element] = 1 + return frequency + + +input_list = [1, 2, 2, 3, 3, 3] +print(frequency_count(input_list)) \ No newline at end of file