From a4b4f0aa097d9daee43a57fa7774373cc40bd310 Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Fri, 23 Jan 2026 11:47:12 -0800 Subject: [PATCH] Add files via upload --- ipynb/TruncatablePrimes.ipynb | 336 ++++++++++++++++++++++++++-------- 1 file changed, 262 insertions(+), 74 deletions(-) diff --git a/ipynb/TruncatablePrimes.ipynb b/ipynb/TruncatablePrimes.ipynb index 5fe62dd..0ffad83 100644 --- a/ipynb/TruncatablePrimes.ipynb +++ b/ipynb/TruncatablePrimes.ipynb @@ -25,7 +25,7 @@ "\n", "Numbers like this are called [**truncatable primes**](https://en.wikipedia.org/wiki/Truncatable_prime). \n", "\n", - "I thought I would write a program to find all the truncatable primes. My function `truncatable_primes` below starts with the list of one-digit primes: [2, 3, 5, 7]. Then it creates a list of one-digit-longer new primes by placing each possible digit 1–9 to the left of each of the one-digit primes, and testing if each resulting number is prime. If there are any new primes, it recursively adds digits to them, giving us three-digit primes, then four-digit primes, and so on, stopping when there are no more new primes. In the end, the function returns all the truncatable primes in sorted order." + "I thought I would write a program to find all the truncatable primes. (It is not immediately obvious that there is a finite number of them, but it turns out to be true.) My function `truncatable_primes` below starts with the list of one-digit primes, [2, 3, 5, 7], and on each iteration creates a list of new numbers that are one digit longer by placing each possible digit 1–9 to the left of each prime. Then out of those numbers we find just the new primes. If there are any new primes, the function recursively adds digits to them, giving us three-digit primes, then four-digit primes, and so on, stopping when there are no more new primes. In the end, the function returns all the truncatable primes in sorted order." ] }, { @@ -38,8 +38,9 @@ "from sympy import isprime # isprime(n) returns True if n is a prime\n", "\n", "def truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n", - " \"\"\"All truncatable primes, in ascending order.\"\"\"\n", - " new_primes = [dp for d in \"123456789\" for p in primes if isprime(dp := int(d + str(p)))]\n", + " \"\"\"Truncatable primes, in ascending order.\"\"\"\n", + " new_numbers = (int(d + str(p)) for d in \"123456789\" for p in primes)\n", + " new_primes = [n for n in new_numbers if isprime(n)]\n", " if new_primes:\n", " return primes + truncatable_primes(new_primes)\n", " else:\n", @@ -147,6 +148,8 @@ "id": "e82700e8-8fb2-45cf-bcf0-7805e46174bb", "metadata": {}, "source": [ + "## Right-Truncatable Primes\n", + "\n", "What if you sharpen the pencil from the other end? The primes we found so far are called **left-truncatable primes**; there are also **right-trunctable primes**:" ] }, @@ -160,7 +163,8 @@ "def right_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n", " \"\"\"All right-truncatable primes, in ascending order.\"\"\"\n", " # Only consider (1, 3, 7, 9) as the digit on the right; placing any other digit forms a composite number\n", - " new_primes = [pd for p in primes for d in (1, 3, 7, 9) if isprime(pd := 10 * p + d)]\n", + " new_numbers = (10 * p + d for p in primes for d in (1, 3, 7, 9))\n", + " new_primes = [n for n in new_numbers if isprime(n)]\n", " if new_primes:\n", " return primes + right_truncatable_primes(new_primes)\n", " else:\n", @@ -287,7 +291,9 @@ "source": [ "There are only 9 of them, with 373 the largest.\n", "\n", - "What about primes that are both truncatable and [**palindromic primes**](https://en.wikipedia.org/wiki/Palindromic_prime)?" + "## Palindromic Primes\n", + "\n", + "What about primes that are both truncatable and [**palindromic**](https://en.wikipedia.org/wiki/Palindromic_prime) (the same when you reverse the digits)?" ] }, { @@ -316,7 +322,139 @@ "id": "cd0da3ad-54c0-47dc-979c-4eecc935425c", "metadata": {}, "source": [ - "There are 13 **palindromic truncatable primes**." + "There are 13 **palindromic truncatable primes**, with only 4 of them longer than 3 digits.\n", + "\n", + "**Aside**: Now I'm curious about [**palindromic primes**]((https://en.wikipedia.org/wiki/Palindromic_prime) that are not truncatable. To find them, I'll enumerate the \"first half\" of numbers, and then concatenate the reverse of the first half, forming both odd- and even-length numbers, e.g. from 123, the function `palindromes` produces the palindromes 12321 and 123321. Then all we have to do is check each palindrome for primality." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fc208a86-c3f4-4426-913d-62ec0a639576", + "metadata": {}, + "outputs": [], + "source": [ + "def palindromic_primes(digit_length: int) -> list[int]:\n", + " \"\"\"Generate all palindromic primes of up to `digit_length` digits.\"\"\"\n", + " end = 10 ** ((digit_length + 1) // 2)\n", + " return [n for half in range(1, end)\n", + " for n in palindromes(half)\n", + " if isprime(n)]\n", + "\n", + "def palindromes(half: int) -> tuple[int]:\n", + " \"\"\"Given the left half of a palindrome, make two full palindromes,\n", + " one without the middle digit repeated, one with.\"\"\"\n", + " left = str(half)\n", + " right = left[::-1]\n", + " return int(left + right[1:]), int(left + right)\n", + "\n", + "assert palindromes(123) == (12321, 123321)" + ] + }, + { + "cell_type": "markdown", + "id": "ec5f9d5a-c89e-4dc9-812b-232437e4801e", + "metadata": {}, + "source": [ + "Let's count the palindromic primes of up to 11 digits, and peek at some of them:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3f9c6d25-8d40-4267-a45f-c0284b910c86", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "47995" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PP = palindromic_primes(11)\n", + "\n", + "len(PP)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "69149eb4-d79d-4cfa-8e48-40946e54c48f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[11,\n", + " 2,\n", + " 3,\n", + " 5,\n", + " 7,\n", + " 101,\n", + " 131,\n", + " 151,\n", + " 181,\n", + " 191,\n", + " 313,\n", + " 353,\n", + " 373,\n", + " 383,\n", + " 727,\n", + " 757,\n", + " 787,\n", + " 797,\n", + " 919,\n", + " 929,\n", + " 10301,\n", + " 10501,\n", + " 10601,\n", + " 11311,\n", + " 11411]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PP[:25]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3bebaad1-8fb2-4892-87f8-8846062d92d4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[99985958999,\n", + " 99986068999,\n", + " 99988688999,\n", + " 99988988999,\n", + " 99991819999,\n", + " 99994349999,\n", + " 99995759999,\n", + " 99998189999,\n", + " 99998989999,\n", + " 99999199999]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PP[-10:]" ] }, { @@ -326,12 +464,12 @@ "source": [ "# Digit Lengths\n", "\n", - "How many digits are in these truncatable primes? The function `digit_lengths` returns a {number_of_digits: count_of_primes_with_that_many_digits} dict, and plots a bar chart for that data:" + "How many digits are in these primes? The function `digit_lengths` returns a {number_of_digits: count_of_primes_with_that_many_digits} dict, and plots a bar chart for that data:" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "id": "28b0bc97-1b22-449f-b33a-6f8c84fd890d", "metadata": {}, "outputs": [], @@ -343,7 +481,8 @@ " \"\"\"Plot a bar chart and return a dict of the number of digits in these primes.\"\"\"\n", " digits = Counter(len(str(p)) for p in primes)\n", " plt.bar(list(digits), list(digits.values()))\n", - " plt.xlabel('Number of digits'); plt.ylabel('Count')\n", + " plt.xlabel('Number of digits')\n", + " plt.ylabel('Count')\n", " return dict(digits)" ] }, @@ -357,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "id": "defd769e-9f92-4e4f-a12b-88a653b6efee", "metadata": {}, "outputs": [ @@ -390,7 +529,7 @@ " 24: 1}" ] }, - "execution_count": 12, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -419,7 +558,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "id": "09f29951-d8f2-47a3-b666-bfa6fd5d1c87", "metadata": {}, "outputs": [ @@ -429,7 +568,7 @@ "{1: 4, 2: 9, 3: 14, 4: 16, 5: 15, 6: 12, 7: 8, 8: 5}" ] }, - "execution_count": 13, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -448,12 +587,52 @@ "digit_lengths(TPr)" ] }, + { + "cell_type": "markdown", + "id": "8618e5bc-ea92-4116-aa74-2380fbfd0dc3", + "metadata": {}, + "source": [ + "Finally, for the palindromic primes, we find that \"11\" is the only even-digit-length palindromic prime; it turns out that any even-digit-length palindromic number is [divisible by 11](https://www.geeksforgeeks.org/dsa/g-fact-all-palindromes-with-an-even-number-of-digits-are-divisible-by-11/). The counts of primes grow so quickly that it is better to use a log scale on the y axis: " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "ed392e12-7480-4d96-994f-96cdb786f8f9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{2: 1, 1: 4, 3: 15, 5: 93, 7: 668, 9: 5172, 11: 42042}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.yscale('log')\n", + "digit_lengths(PP)" + ] + }, { "cell_type": "markdown", "id": "f2323985-2518-41d1-8a3b-6e21e40d27be", "metadata": {}, "source": [ - "# Summary of Truncatable Prime Facts\n", + "# Summary \n", "\n", "Here's what we learned:\n", "\n", @@ -474,6 +653,9 @@ "- Palindromic truncatable primes:\n", " - Count: 13\n", " - Largest: 799636997 (9 digits)\n", + "- Palindromic primes:\n", + " - Count: infinite\n", + " - All except \"11\" have an odd number of digits\n", "\n", "\n", "# Primality Testing\n", @@ -483,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "id": "1d460931-3d70-485d-807f-8fb360ef4ef2", "metadata": {}, "outputs": [], @@ -507,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "id": "647fb66b-32ae-494a-8945-cf7358c2f958", "metadata": {}, "outputs": [], @@ -559,7 +741,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "id": "c8a59c5e-a01c-49be-a931-c1547c4ac712", "metadata": {}, "outputs": [], @@ -582,7 +764,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "id": "476282dd-a48a-4eb5-8fed-8495d4878ec2", "metadata": {}, "outputs": [], @@ -615,7 +797,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 23, "id": "45a11a93-9ef3-48d1-80fa-e0113041346e", "metadata": {}, "outputs": [], @@ -638,26 +820,26 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "id": "9eba96df-c298-4d71-b68a-3bf36bf15095", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{3: 1.433229785995569,\n", - " 4: 0.47277977521728054,\n", - " 5: 0.12450624459417024,\n", - " 6: 0.04328208013677137,\n", - " 7: 0.010154128989503837,\n", - " 8: 0.0021231309812580613,\n", - " 9: 0.0005263573440008422,\n", - " 10: 0,\n", + "{3: 1.4119561859956755,\n", + " 4: 0.44668416368593794,\n", + " 5: 0.12196467991169978,\n", + " 6: 0.028730958963517104,\n", + " 7: 0.008030451471981755,\n", + " 8: 0.0026523932544334754,\n", + " 9: 0.0005267205326198026,\n", + " 10: 0.0005232807610595388,\n", " 11: 0,\n", " 12: 0}" ] }, - "execution_count": 19, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -678,7 +860,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 25, "id": "8880c588-32f5-46e8-b59c-f9b49d492d3b", "metadata": {}, "outputs": [ @@ -688,8 +870,8 @@ "{3: 0,\n", " 4: 0,\n", " 5: 0,\n", - " 6: 0.0003613604498214879,\n", - " 7: 0.000356548185704557,\n", + " 6: 0.0003605006633212205,\n", + " 7: 0,\n", " 8: 0,\n", " 9: 0,\n", " 10: 0,\n", @@ -697,7 +879,7 @@ " 12: 0}" ] }, - "execution_count": 20, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -720,35 +902,35 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 26, "id": "7871aaa7-af1c-462b-85bb-d46818ccabea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{561: 56.84,\n", - " 1105: 69.72,\n", - " 1729: 74.68,\n", - " 2465: 72.79,\n", - " 2821: 76.78,\n", - " 6601: 80.1,\n", - " 8911: 80.1,\n", - " 41041: 70.28,\n", - " 101101: 71.63,\n", - " 294409: 95.18,\n", - " 340561: 81.13,\n", - " 825265: 59.82,\n", - " 56052361: 99.19,\n", - " 118901521: 99.24,\n", - " 172947529: 99.45,\n", + "{561: 56.85,\n", + " 1105: 68.86,\n", + " 1729: 76.46,\n", + " 2465: 72.11,\n", + " 2821: 76.03,\n", + " 6601: 80.03,\n", + " 8911: 79.98,\n", + " 41041: 70.17,\n", + " 101101: 70.69,\n", + " 294409: 95.11,\n", + " 340561: 81.57,\n", + " 825265: 60.17,\n", + " 56052361: 99.21,\n", + " 118901521: 99.29,\n", + " 172947529: 99.43,\n", " 216821881: 99.4,\n", - " 1299963601: 99.65,\n", - " 2301745249: 99.76,\n", - " 9624742921: 99.9}" + " 1299963601: 99.64,\n", + " 2301745249: 99.72,\n", + " 9624742921: 99.84}" ] }, - "execution_count": 21, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -770,7 +952,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 27, "id": "de492047-77b6-46a3-8a77-46308f219efd", "metadata": {}, "outputs": [ @@ -786,19 +968,19 @@ " 8911: 0,\n", " 41041: 0,\n", " 101101: 0,\n", - " 294409: 4,\n", + " 294409: 6,\n", " 340561: 0,\n", " 825265: 0,\n", - " 56052361: 58,\n", - " 118901521: 66,\n", - " 172947529: 80,\n", - " 216821881: 86,\n", - " 1299963601: 90,\n", - " 2301745249: 87,\n", - " 9624742921: 94}" + " 56052361: 62,\n", + " 118901521: 81,\n", + " 172947529: 75,\n", + " 216821881: 71,\n", + " 1299963601: 91,\n", + " 2301745249: 94,\n", + " 9624742921: 92}" ] }, - "execution_count": 22, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -823,7 +1005,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 28, "id": "be5f2fe7-b1e0-4a02-b7f0-7903e865c4b8", "metadata": {}, "outputs": [], @@ -845,7 +1027,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 29, "id": "8109d9fc-bbae-4ef0-a75c-908d9746a557", "metadata": {}, "outputs": [], @@ -884,13 +1066,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 30, "id": "b1ab0f3d-6ce6-4b8c-9d4d-bb78bb1ac432", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwwAAAINCAYAAACTVPhqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAwGpJREFUeJzs3Qd8U1X7B/BfuncpnbTsIVL2liUyFJQhQ/EVF+6BrwiC4MTXAbgQB/5Bfd0TEX2VJYjI3hsqsjedQPdM8v88J01oS0fSJs36ff1cc3Jzc3PuTWnvc89zztHo9Xo9iIiIiIiIyuFR3koiIiIiIiIGDEREREREVCm2MBARERERUYUYMBARERERUYUYMBARERERUYUYMBARERERUYUYMBARERERUYUYMBARERERUYW8Kn6JhE6nw7lz5xAcHAyNRsOTQkREREROT+ZuzszMRGxsLDw8Km9DYMBQBQkWGjRoYM3vh4iIiIjIIZw+fRr169evdBsGDFWQlgXjyQwJCbHet0NEREREZCcZGRnqprjxWrcyDBiqYExDkmCBAQMRERERuRJzUu7Z6ZmIiIiIiCrEgIGIiIiIiCrEgIGIiIiIiCrEPgxEREREdhrWsqioCFqtluefbMLb2xuenp413g8DhgrMnTtXLfxHTERERNZWUFCA8+fPIycnhyeXbNqhWYZMDQoKqtl+9BLeUqVDToWGhiI9PZ2jJBEREZFVJoU9fPiwuvMbGRkJHx8fTg5LVieX+CkpKSoobdGixRUtDZZc47KFgYiIiKiWWxckaJAx8AMCAnjuyWYkID1x4gQKCwtrlJrETs9EREREduDhwcswsv8cC+bgTyoREREREVWIAQMREREREVWIAQMRERGRk9Lq9Nh0NA3/231WPcpzW7ruuuvw5JNP2mz/km8vaTS7d++GIzpRi/Vr3Lgx5syZA0fATs9ERERETmj5/vP4z28JOJ+eZ1pXL9QP04fFY3Cbejb5zEWLFqmx/W1FOoLLcLMRERFwRA0cvH62whYGIiIiIicMFh79emepYEEkpuep9fK6LdStWxfBwcE2Gz1KRvKJiYmBl5dj3tP2dPD62QoDBnI6td38SkREVBtj5ucUFJm1ZOYVYvqvB1DeXz/jupd+TVDbmbM/S6bkKpmS9OGHH6rx/f38/BAdHY1bbrml1HaPP/64WmSsf7kj/8ILL5T6LEm5eeWVV3D33XereQAeeuihK1J+/vrrL/X8999/R8eOHeHv74/+/fsjOTkZy5YtQ6tWrdR7x44dW2oSPBm2dubMmWjSpIl6T/v27bFw4UKzjvHixYu444471JCk8t4WLVrgs88+U69Zq37mnJ+yLl26hAceeEDVS/Ypn7Nnzx7UBvcKj8jp2aP5lYiIyNZyC7WIf/F3q+xLLjkTM/LQ9qUVZm2f8PIgBPhYdkm4fft2PPHEE/jqq6/Qs2dPXLhwAevWrSu1zRdffIH7778fW7duVdtLQNCwYUM8+OCDpm3eeustvPjii5g+fXqln/fSSy/hgw8+UPNWjBkzRi2+vr749ttvkZWVhZEjR+L999/H1KlT1fYSLHz99deYN2+euuBfu3Yt7rzzTnWx3bdv30o/Sy7cExIS1AW/XMgfOXIEubm5Vq2fueenpFtvvVUFJFIvCTLmz5+PAQMG4NChQ6rlx5YYMJDTNb+Wjb2Nza//d2cnBg1ERES14NSpUwgMDMTQoUNVilKjRo3UHfay+f7vvPOOugPfsmVL7Nu3Tz0veUEsd8mfeuop03O5g1+eV199Fb169VJluch+5plncPToUTRt2lStk9aN1atXqwvy/Px8zJgxA3/88Qd69OihXpft1q9fry6yqwoY5NjkWLp06WJqCamKJfWz5PwYSd0lsJCWCwlEjMHWL7/8olpOJNiwJQYMFZg7d65atFqtTb8AMo+kHUnLQkXNrzItibx+fXwMPD2sM0kJkcvTaYGTG4GsJCAoGmjUE/Co/kygRFR9/t6e6k6/ObYev4Bxn22rcrvP7+2Kbk3qmvXZlrr++utVkCAXxIMHD1aL3EUvOXP1NddcU2riMLl4f/vtt9W1lXHWYeNFeVXatWtnKkv6k3yO8WLcuE4uqIW0CEj6j9SxbB+JskFNeR599FGMHj0aO3fuxA033IARI0aoVhRr1c+S82MkqUfSUhEeHl5qvbR8SGBiawwYKjB+/Hi1ZGRkqGYfsi/55Vi2Y1fZoEFel+16NCv9j4mIypHwK7B8KpBx7vK6kFhg8OtA/HCeMqJaJheO5qYF9WkRqdJxpYW9vBtpcgkaE+qntrPVTTRpVZALasnhX7FihUorkrScbdu2oU6dOmbvR1opzFFyZCY5V2VHapJ10m9ByIW1WLJkCeLi4kptZ7w7X5kbb7wRJ0+exNKlS7Fy5UqV9iPXhHJH3xr1qw45pnr16qnzXZYl57u62OmZnEJyZp5VtyNyaxIsLLi7dLAgMs4b1svrROSwJAiQvnuibDhgfC6v27rFXUYKGjhwIN544w3s3btXpRP9+eefpte3bNlSavvNmzer/gRl755bW3x8vAoMJLWoefPmpRZJAzKH9HW45557VD+IOXPm4KOPPrJ6PS05P506dUJiYqI652WPqTaGeGULAzmFqGA/q25H5NZpSNKyUFmC3/JpwNVDmJ5E5MBkoA/pu1d2IJCYWhoIZPHixTh27BiuvfZahIWFqbvxcgddcvGN5IJ90qRJePjhh1VrhHT6lZQbW5PWj8mTJ2PixImqTr1790Z6ejo2bNigRheSQKAy0lrSuXNntG7dWvWHWLx4sRrtyNosOT8SmEnKkqRHSYB21VVX4dy5c6oVRVLBzE3tqi4GDOQUJAdTml8rSksyNr+ak6tJ5Nakz0LZloVS9EDGWcN2TfrUYsWIyFISFEjfPUnHlRZ2uWkmfwdroy+fpMHIJG6ShpSXl6fujH/33XfqIttIhkuVHPtu3bqpu+YTJkyweedcIxmuVVoJZLQkCWykvnKX/tlnn63yvT4+PqrTsrSYyKhEffr0wffff2/1OlpyfiSlSYKy5557Dvfeey9SUlLUfBASsEn/CFvT6C0ZfNcNGfswSGQqUSnZd5SkR77eecV6469FjpJEZIZ9C4Gf7q96u9H/BdpeHlOdiKxHLrCPHz+u5giQOQxckcwz0KFDB5XOQ/Y7P5X9rFlyjcs+DOQ0ereIhI/XlT+y0rLAYIHITDIakjW3IyIil8eUJHIaS/eeR0GRDk3CAzBjVFskZ+bXavMrkUtocA3gHQAUXp5xtDSNYbQkGWKViMgFPfLII6ozc3lkcjeZ7I1KY8BATuPHHafV461dG6BHM9uPCEDkcrRFwG//rjxYEINnscMzEdVIecN/OoqXX35ZdYouT22ln//lwOenPAwYyCkcS8nCthMXIQ0JozvVt3d1iJyPthBY9CBw4GdA4wl0fxhI+KWceRhmcR4GInJpUVFRaiHzMWAgp7Bwxxn1eO1VkYgOcc0OYkQ2U5gH/DgOOLQM8PAGbv0MaDUMuOFVzvRMRERVYsBADk+r02PRzrOqfGtn8yZcIaJiBTnA92OBY6sBLz/gtm+AFgMNr3l4cuhUIiKqEgMGcnjrDqcgMSMPdQK8MTCeTYhEZsvPBL69DTi5AfAOBMZ+DzS5lieQiIgswoCBHN6P2w3pSCM6xMHXy7bTyRO5jNyLwNe3AGe3A74hwB0LgYbd7V0rIiJyQm4xD4NM6S1TlcsshJ988om9q0MWuJRTgJUJSap8S2d2diYyS3Yq8MUwQ7DgHwbc8yuDBSIiqjaXDxiKioowadIk/Pnnn9i1axfefPNNpKWl2btaZKb/7T6HAq0O8fVC0CYulOeNqCqZicDnQ4DEfUBgFDBuCRDbkeeNyFXptMDxdYZZ3OVRntt4huInn3zSZvs/ceIENBoNdu/eDXvasGED2rZtC29vb4wYMQLuzuVTkrZu3YrWrVsjLi5OPb/xxhuxYsUK3H777fauGlky90IXti4QVenSaeDL4cCFY0BwrKFlIaIFTxyRq0r4FVg+tZzhkV+32fDIixYtUhfRttKgQQOcP38eERH2nW9JbjZ36NABy5YtQ1BQUI3399JLL+GXX36xeyDksi0Ma9euxbBhwxAbG6siTjnZZc2dOxeNGzeGn58funfvroIEo3PnzpmCBSHls2cNI+6QY0s4l4H9ZzPg7anBzR0uf4dEVA4JEj67yfBYpyFw3zIGC0SuHiwsuLt0sCAyzhvWy+s2ULduXQQHB9tk3wUFBfD09ERMTAy8vOx7T/vo0aPo378/6tevjzp16sBRyDmyB4cPGLKzs9G+fXsVFJTnhx9+UFHg9OnTsXPnTrXtoEGDkJycXOt1Jdu0LlwfH426gT48vUQVSTlkCBbSTwHhzYF7lwNhjXm+iJyJXg8UZJu35GUAy56WN5W3I8ODtDzIdubsTz67GilJH374oeofKjdso6Ojccstt5Ta7vHHH1dLaGioajF44YUXoC/xWXKz95VXXsHdd9+tZlh+6KGHrkhJkhmR5fnvv/+Ojh07wt/fX13Iy3We3P1v1aqVeu/YsWORk3N5FnudToeZM2eiSZMm6j1yfbhw4cIqj8/4+ZK+ft9996ny559/Dq1Wi/vvv9+0P+kb++6775Z6r9S1W7duCAwMVEFGr169cPLkSfX+//znP9izZ4/an3Gf4tKlS3jggQcQGRmpjkOOTbYr2TIhLR3SB1c+W861PTh8SpKkEMlSkdmzZ+PBBx/Evffeq57PmzcPS5Yswaeffopp06aplomSLQpSli+zIvn5+WoxysjIUI+FhYWmPhFCIl9ZJ1962bIxQpalbFle9/DwUJ8hTXrllX18DBfHsn3Jsq+vr/oHIJ9VXlnqJtvLD7UsZcvyuvxDlc8qW3a0Y9J4euOXXZfnXnCFY3LF74nH5ADf04V/gK9GQpOTCkTFQ3fnIhT61oVv8R9Mfk/898TfEY73e8/4e0L2I+vld4MuPwses6yVfqs3tDzMMnPuomfPQe8doOoi50UeKyobbdu2DU888QS++uor9OjRAxcuXMD69evVMcnxiC+++EJddEvmhyyPPPIIGjZsqC68jdu89dZbKpCQG7/G81Hy3JS8cH7//ffVxfq//vUvjBkzRp3nb7/9FpmZmRg1apR6/emnn1bvk2Dh66+/VkGNXNyvWbMGd955p7owv/baays8PslEkZQoeY9c5MtnBQcHq+9VWhvkRrUEP5s2bVIBjrSG3HbbbepnRvo6yDXpN998o35W5BzJPqWu+/fvx/Lly7Fy5Up17LJPee3WW29VQcDSpUtVYDV//nwMGDAA//zzD8LCwtSxHzlyRAU7kg4m9ZRzU9X3VLYsyv59Mj53iRaGysiXs2PHDgwcOPDyAXl4qOfyRQoJDuRLkkAhKytLRaPSAlER+QGTL8y4SC6dkC9YrFq1Si1C9iX/OISkSskPhliwYIEpOpR/SAcPHlRliQ6PHTumytJiYgxkJOhJTU1V5VmzZqkffDk2KcujPJeykO1keyHvN7a8yH6NI0DJ58nnCqmH1EdI/YwpXVJvqb+jHtOqv5NwMacQgZ5F6NMiwiWOyRW/Jx6Tfb+nL2c+qUZDkmDhHAwdnFPzPPk98d8Tf0c4+O+9zZs3q7Jcl8giLqWnw54keDKel7y8PNMAMXLX/uLFi6asD+NF5qFDhxAQEIChQ4eqC9tmzZqpAEJutBqPSW7avvrqq+ri+6abblIBwzvvvKP2LZ8h5C68tELI++Ui2niDVrYpeUErF+89e/ZEvXr1VBAiAYCsk1YHCVhk/6tXr1bvP336NGbMmIH/+7//Q+fOndG0aVN14S8tIHJBXvaY5C6/kHrLcwkChAQkUi4sLFTnRz6vefPmiIqKwh133KH6w3733Xemlon09HR1PuT6UT7znnvuUcGAXKBLPwi5cJdgQ/Yp20ravQRS7733nqqnnIOnnnpKtU7Iz1FSkmGUSPm5lMBKjlXOpTnfk/GYZH1ubm65f5+M18pm0TsRqe7PP/9sen727Fm1buPGjaW2mzJlir5bt26m5//73//0LVq00Ddr1kw/f/78Sj8jLy9Pn56eblpOnz6tPiM1NVW9XlhYqBZRUFBQbjk/P19fVFRUblmr1Zo+p6KyTqdTS9mykO0qKsv+hXxeeWWpn9SzvLKjHdO9n23VN5q6WP/qb/td5phc8XviMdnxezqxQa97LVavnx6i1308UJ93KYnfE/898XeEk/zey8zM1CckJOizs7PV56l9FhXpdXmZen1+ll6bm1F5+dAK9W+/qkV7cLnaXhZ5r+yj3HLxcRvPS2Xlvn376idMmKCukdq2bauPiIjQ33nnnfqvvvpKHY9sa9xu3Lhxl49Pq1XXcF5eXupcyPpGjRrpX3nllVLbHDt2TF137dixQ61fvXq1ep6UlGSqy3//+199QEBAqXq98MIL+o4dO6ry3r171XsCAwNLLd7e3ur60JxjDQ0N1X/66aemeul0Ov0HH3yg79Spkzpm4/66du1q2kaO19fXVz9kyBD9O++8oz937pzpvdOnT9e3b9++1LG+//77eg8PjyvqKevkWla2kfc1b97crO+mvHJOTo7+wIED+tzc3Cv+PqWlpanzJN9lVRw+Jckahg8frhZzSFOjLGUZRwQo2Qmn5CgBJcvGJs3KyiU/w5KytKBUVDbu35jeULZcsu4VlR3hmC7l6/HXP4Y+KP/q3sgljskVvycekx2/p2N/Ad/dDhTmAI37QHP79/D1NYziwe+J/574O8Lxf+8Zn8t+jKk5HvI+z+J/x6atKyg3628YDUk6OJfbj0GjXvdoMVB2bFxjeqywXFwXY559eWUjybeXvqOSty+jT0pKkdyBl5YVYyfhku8tdawlynLnvapthJxv4/7kNWNamfFzjKk6Ujb2ZZAU9ZID3xi/28qOr+RnlqzL999/j8mTJ+Ptt99WLRrSGiJD9W/ZssW0zWeffaZaWST1SFoIJNVKMlSuueaacvcpLQHSYiLnsCw5h8bjkz4RJY/VnO+pvHLZv0+WdCx36oBBmnXkH6axycZInhubk6pLmh1lkZw1ql2Ldp6FTg90bhSGZpE1H8qMyKnJmOonNwJZSUBQNJCfBfx4D6DNB5oPBG77GvD2t3ctiag2SRAgQ6fKaEjqUr9k0FB8wTt4lilYsBW54JQ0cFkkYJCLXJn3SvoTCOPFtJGkYkknaWNQZSvx8fEqMDh16hT69u1rtXkZevbsiccee6zUSEplSdqQLM8884wKLKSPhQQMxj4uJXXq1AmJiYnqPEoHcEfm1AGDnHzJ+ZJ8LOOkGhJdynPJh6uJ8ePHq0Vy8SQXjWqHZJ6Z5l7gzM7k7sobY93o6qHALZ8CXle2iBKRG5B5FsZ8WcE8DLNsNg+D0eLFi1VfDulALH0YpNOuXINJjr2RXLDLSJYPP/ywao2QTslyh97W5O6/tAZMnDhR1al3796qz4Bc9EvLiPQtsFSLFi3w5ZdfqtGaZLQi6bcirSlSFsePH8dHH32kMlqk74Z0Wj58+LAaAUpIQCDbyOhP0nla6iiBlgQVcg37xhtv4KqrrlLTAUjLyMiRI9GlSxc4CocPGKQDivQONzKebBkHWHrayw+ifPFyUqWD85w5c1QTj3HUJHIuO09dwrGUbPh7e2JIu3r2rg6R/cdYLzfdAECbWxgsELk7CQquHlK6FbJRT5u3LAhpTZBRe2T0Iul8KxfU0gFYJss1kotl6XAr12fSqjBhwgQ1slBtkOFaZUQkGcxGAhupr9zRf/bZZ6u1v4cffhi7du1SIyJJio90eJbWBmNndukALh3gZWQo6YgsqUZy41neJ0aPHq3OV79+/VSHZElfGjdunAq0nnvuOXXdmpKSojJkJAiTYWodiUY6MsCBSV6XnNyyJEgwjmH7wQcfqDwyadaRsWqlt7lM4GatlCQZCUAiU4lKybaeWbQX3209jVGd4jB7TAeebnLfNKQ5bcpvWSiRn4wn99XKhQERWZdcYMsNUHuOq29rMg+DXJPJjVxyzJ81YxaNOde4Xs7wA1dVTGOcGMSamJJU+3IKivDbnvOmuReI3JbcLawwWDCOsX7WsF2TPrVYMSIickdOPQ8DuZbl+xORlV+EhnUD0L1JXXtXh8h+JLXAmtsREZGJzAchozOVt8hr5IQtDOQ+ftx+Rj3e0rk+PDwuD2tG5HY8zPzVLPnKREQOqLyhQh3Fyy+/rDpFl4fp5+VjwFABDqtau06l5WDTsTTIUMGjOToSubNzu4Fl06rYqLgPg3RuJCIii8hMzbKQ+ZiSVEkfhoSEBDVkFtnewp2G1oVezSIQV4djypObSvgf8OlgIOs8EBJXZlql2h9jnYiISDBgILvT6fT4aYchYLi1S317V4eo9snADmvfNAyjWpRrmJDtsU2GMdZDygwvLC0Lst7GY6wTEREZMSWJ7G7j0TScvZSLYD8vDGpdsxm6iZxOYR7w67+BfQsMz7s/CtzwKuDpZdcx1omIiIwYMFSAfRhqj3Fm5+HtY+HnzQshciNZycD3dwBntho6Ot/0JtDlvtLbSHDAoVOJiMiOmJJUAfZhqB3puYVqOFUxpgvnXiA3krgf+Li/IVjwCwXuXHRlsEBEROQAGDCQXf225xzyi3S4KjoI7eqH8tsg93BwKfDfG4D000DdZsADfwJN+9q7VkREZk2o++STT9rsTJ04cQIajQa7d++267exYcMGtG3bFt7e3hgxYgTcHVOSyK5+NHZ27txA/YIgcvnOzRvfA1ZON8zW3KQvMOYLwD/M3jUjIiel1WmxM3knUnJSEBkQiU5RneBpw35OixYtUhfRttKgQQOcP38eERERsKdJkyahQ4cOWLZsmZrQzdFIYNWkSRPs2rVL1dPWGDCQ3RxOysSe05fg5aHBiI4yhCSRCysqABZPBHZ/bXgu6Uc3vgF42u4PLxG5tj9O/oFZW2chKefyrO/RAdGY1m0aBjYaaJPPrFu3LmyloKAAPj4+iImx/wAoR48eVbM+169f/dEbjcfjCpiSVEmn5/j4eHTt2rV2vxE3bF3od3UUIoN97V0dItvJTgO+vNkQLGg8DIHCkNkMFoioRsHCpL8mlQoWRHJOslovr9s6JenDDz9EixYt4Ofnh+joaNxyyy2ltnv88cfVEhoaqloMXnjhBeilpbVY48aN8corr+Duu+9WMyw/9NBDV6QkyYzR8vz3339Hx44d4e/vj/79+yM5OVnd/W/VqpV679ixY5GTk2Pat06nw8yZM9VdeHlP+/btsXDhwiqPz/j5aWlpuO+++1T5888/V6/t378fN954o2pxkOO96667kJqaesUxy/mR4x00aFC16798+XL07t0bderUQXh4OIYOHaqCGCM5LiH7lP3LZ9sSA4YKsNOzbRVqdVhUPFnbrZzZmVxZ8kHg437AqY2Abwgw9keg+8NQ05oTERWTC+mcwhyzlsz8TMzcOhN6SW0sQ1/8n7Q8yHbm7K/kRby5tm/fjieeeAIvv/wy/vnnH3WBe+2115ba5osvvoCXlxe2bt2Kd999F7Nnz8Ynn3xSapu33npLXcxLao0EFBV56aWX8MEHH2Djxo04ffo0xowZgzlz5uDbb7/FkiVLsGLFCrz//vum7SVY+PLLLzFv3jwcOHAAEydOxJ133ok1a9aYlRIlF/GyfynfdtttuHTpkrrQlwt0OXY53qSkJFWPsscsrQrSB0I+u7r1z87OVmlR8lmrVq2Ch4cHRo4cqQIhIedU/PHHH6qOkipmS0xJIrv4658UpGYVICLIR7UwELmkw38AC+8F8jOAsMbA7T8AUVfbu1ZE5IByi3LR/dvuVtuftDz0/L6nWdtuGbsFAd4BFu3/1KlTCAwMVHe+g4OD0ahRI3UxXfbi+5133lF3wFu2bIl9+/ap5w8++KBpG7kIf+qpp0rd4S/Pq6++il69eqny/fffj2eeeUbdcW/atKlaJ60bq1evxtSpU5Gfn48ZM2aoi+kePXqo12W79evXY/78+ejbt+JBJjw9PVVKlNRZWkaM6VFvv/22Oj7Zr9Gnn36qjvHQoUO46qqr1DppcXnjjTdM28jFvKX1F6NHjy5VL/msyMhIJCQkoE2bNqospPWhNlK42MJAdvHjdsPcCyM7xsHbkz+G5MR0WuD4OmDfQsOjPJe7dZvnAd/eaggWGvY0jITEYIGIXMT111+vggS54JXUnG+++aZUSo245pprSg1oIhfvhw8fhlarNa3r0qWLWZ/Xrl07U1nSgQICAkwX28Z1kuYjjhw5ouoidZT0IeMiLQ4l03ossWfPHnVBX3J/V19tuAFUcp+dO3eucf2FnKfbb79dbSOtHZK+ZQzU7IEtDFTrUrPy8edBwz+KWzn3AjmzhF+B5VOBjHOX1wXHApEtgWOrDc873AkMfQfwco2Ob0RkG/5e/upOvzl2JO3AY6seq3K7Dwd8iM7Rnc36bEtJq8LOnTtVjr6k07z44osq7Wbbtm0q795c0kphjpIjM0kQUnakJllnTNfJyspSj5LqExdXelAVX9/q9ZnMysrCsGHD8Prrr1/xWr169ao8HkvqL+SzJCD7+OOPERsbq16TlgXpSG0PDBio1v2y6yyKdHq0rx+Kq6KD+Q2Qc5JgYcHdhuFRS8o8Z1jE9a8APf/N/gpEVCW5YDQ3LahnbE81GpJ0cC6vH4MGGvW6bGfLIValf8LAgQPVMn36dBUo/Pnnnxg1apR6fcuW0gHQ5s2bVcqOpP3YkgxaI4GB3I2vLP3IEp06dcJPP/2k7vTLcduSdLiWfiESLPTp00etk3SqkoyjL5VsrbEl5oJQrZKOVQuK05HYukBOS9KOpGWhnD/UJgHhQI/xDBaIyOokCJChU43BQUnG51O7TbVpsLB48WK89957ajSjkydPqnQfuQsufRWM5IJdOu7Kxe93332nOvVOmDABtiatH5MnT1YdnaUTsqQMSWuIfL48r+5gOBcuXFBpQtKKIvuUkY/uvfdeq1+0h4WFqb4JH330kUqvkiBMzmNJUVFRasQlY+fr9PR02BIDhgpwWFXb2HsmHYeSsuDr5YFh7WNt9ClENnZyY+k0pPLkpBm2IyKyAZlnYfZ1sxEVUHrgEGlZkPW2mofBSFoTZGQe6bQsQ4PKiEASFLRu3dq0jQyXmpubi27duqkLbgkWZOjU2iDDtcqoSzJaktRv8ODBKkXJOByppWJjY9XIRxIc3HDDDWoWaBk+Vc6DjGBkTbK/77//Hjt27FBpSBL4vPnmm6W2kVYOCdikE7fU7eabb4YtafTVGUvLjWRkZKhe8hK5SacTqpnnf9mHrzefwvD2sXjv9tKjKRA5Deng/NP9VW83+r9A28vjkhMRiby8PBw/flxdvMocBs4007O5ZF4AmYFYhg4lx/xZs+Qal30YqNbkFWrx627DXdkx7OxMziwo2rrbERFVkwQHXWM4ySzZFlOSqNasSEhCRl4R4ur4o2ezcJ55cl6NegIhlaXUaYCQOMN2RETkUB555JFSw6OWXOQ1uhJbGKjW514Y3SkOHh6c5ZacmDT33zADWDiunBeLf7YHzzJsR0TkhmS4VUcls1NLp+jyMP28fAwYqFacvZSL9UdSVfmWzg141sn5GYdOVQFCia5g0vIgwUL8cHvVjIiIKiEjDMlC5mPAQLVi0Y4zavLba5rWRcNwy6afJ3I46WeAP18zlIfOBsJbAFlJhj4LkobElgUiInIhDBjI5nQ6PX7ccUaVb2XrArmCZVOBwmygwTVAp3EyBp69a0RERGQz/CtXAc7DYD1bT1zAqQs5CPL1wo1tY6y4ZyI7OLgEOLgY8PAChs1hsEBERC6PAUMFZIKRhIQENZsf1cyP2w2tC0Pb1UOADxu1yInlZwJLpxjKPZ8AolrZu0ZEREQ2x4CBbCorvwhL951X5Vu71OfZJue2eiaQcRao0wi4tjhwICIicnEMGMimluw9h9xCLZpGBqJTwzCebXJe5/cAW/7PUB4yG/Bh530icj8yg/OTTz5ps/2fOHECGo0Gu3fvttlnkOWYH0K1ko4knZ3lFwCRU9Jpgd8mAHod0HoU0GKgvWtERKTotVrkbN+BopQUeEVGIqBLZ2g8bTcHzKJFi+Dt7W2z/Tdo0ADnz59HRESEzT6DLMeAgaxOq9Nj6/EL2H82HdtPXlSj1I/qFMczTc5r23+Bc7sA3xBg8Ex714aISMlYsQJJM2aiKDHRdEa8YmIQ/ewzCLnhBpucpbp169rs7BcUFMDHxwcxMRwgxdEwJYmsavn+8+j9+p+4/ePNeG3p32qdj5cHdp26yDNNzinjHLDqZUN54HQgmH/IiMgxgoWzE54sFSyIoqQktV5et3VK0ocffogWLVrAz88P0dHRuOWWW0pt9/jjj6slNDRUtRi88MIL0MukTMUaN26MV155BXfffbeaYfmhhx66IiVJZoyW57///js6duwIf39/9O/fH8nJyVi2bBlatWql3jt27Fjk5OSY9q3T6TBz5kw0adJEvad9+/ZYuHChTc6JO2ALA1k1WHj0650l57xV8ot0av3/3dkJg9vU4xkn57J8GlCQCcR1ATrfZ+/aEJGLkgtpfW6uedtqtUh69TV5U3k7UhPQJ702A4E9epiVnqTx97c4bXj79u144okn8NVXX6Fnz564cOEC1q1bV2qbL774Avfffz+2bt2qtpeAoGHDhnjwwQdN27z11lt48cUXMX369Eo/76WXXsIHH3yAgIAAjBkzRi2+vr749ttvkZWVhZEjR+L999/H1KlT1fYSLHz99deYN2+eCmrWrl2LO++8E5GRkejbt69Fx0oMGMiKaUj/+S3himChJHn9+vgYeHqwLwM5iUO/Awn/AzSenHOBiGxKgoV/OnW20s4MLQ2HunYza/OWO3dAE2DZQA6nTp1CYGAghg4diuDgYDRq1Ei1AJTtj/DOO++oYKRly5bYt2+fel4yYJDWgqeeesr0XFoYyvPqq6+iV69eqixByDPPPIOjR4+iadOmap20bqxevVoFDPn5+ZgxYwb++OMP9OjRQ70u261fvx7z589nwFANTEkiq5A+C+fT8yp8XQIJeV22I3IKBdnAksmGco/HgJi29q4REZHDuP7661WQIBfid911F7755ptSKUHimmuuKdVyIRfvhw8fhlarNa3r0qWLWZ/Xrl07U1nSn6SlwRgsGNdJmpI4cuSIqovUMSgoyLR8+eWXKsggyzEliawiOTPPqtsR2d2a14H0U0BoA+C6Z+xdGyJycZIWJHf6zZGzfTtOP/Rwlds1+Gg+Asy4IJfPtpS0KuzcuVP1MVixYoVKK5K0IZnwtk6dOmbvR1opzFFyZCYJQsqO1CTrpN+CkBQlsWTJEsTFlR50RdKYyHIMGCowd+5ctZSMgqliUcF+Vt2OyK4S9wMbPzCUb3oL8DHvDxoRUXXJBa+5aUGBvXqp0ZAk7ajcfgwaDbyio9V2thxi1cvLCwMHDlSL9EGQQOHPP//EqFGj1Otbtmwptf3mzZtVfwJPG9ZJxMfHq8BA0qbYX8E6GDBUYPz48WrJyMhQvfupct2a1EW9UD8kpueV249BGiRjQv3UdkQOTe5QLX5SehUCrYYBLQfbu0ZERKVIECBDp8poSBIclAoailOA5HVbBguLFy/GsWPHcO211yIsLAxLly5Vd/ilr4KRXLBPmjQJDz/8sGqNkE7Jb7/9ts2/TWn9mDx5MiZOnKjq1Lt3b6Snp2PDhg1qRKV77rnH5nVwNQwYyCqkI/P0YfFqNKSyjNmL8jo7PJPD2/EZcGYb4BMM3PiGvWtDRFQuNc/Cu3OunIchOtqm8zAYSWuCTOImaUh5eXmq5eC7775D69atTdvIcKm5ubno1q2balWYMGGCGimpNshwrTIikoyWJIGN1LdTp0549tlna+XzXY1GX3JAXLqCsYVBIlOJSqlyL/92AJ9uKD3CgbQ8SLDAIVXJ4WUmAR90BfLTgcGvA9c8Yu8aEZELkgvs48ePqzkCZA4DZ5rp2VwyD0OHDh0wZ84ce1fFreVV8rNmyTUuWxjIqk5fNIwhPaJDLPpdHaX6LEgaElsWyCn8/qwhWKjXAeh2edg/IiJHJcFBYHfzhk8lqi4GDGQ1GXmFWPNPiio/3LcZWtVjiww5kSOrgP0LAY0HMOxdwMP+d+iIiIgcAQMGspo/EpJQoNWhWWQgro4J5pkl51GYCyyZZCh3exiI7WDvGhEROTUZbpVcByduI6tZvPe8ehzaLtbiKeaJ7Grtm8DFE0BwLND/OX4ZREREJTBgIKtIzynEusOGdKSh7erxrJLzSP4b2PCeoXzTG4AvW8eIqHZw3Blylp8xBgxkFb8fSEShVo+W0cFoEc0LLnKmORcmArpCoOVNwNVD7V0jInIDxlmKc3Jy7F0VcnEFBQXqsaaT5bEPA1nF4n3GdCS2LpAT2f01cGoT4B1omHOBqXREVAvk4k3mBUhOTlbPAwICmMpLVieT1qWkpKifL5mVuyYYMFCNXcguwIYjqao8tH0szyg5h6wUYMULhnK/Z4E6DexdIyJyIzExMerRGDQQ2YKHhwcaNmxY44CUAQPV2PL9idDq9GgdG4ImEYE8o+QcVjwP5F0CYtoC3TlBGxHVLrmAq1evHqKiolBYWMjTTzbh4+OjgoaaYsBANbZ47znT6EhETuHYGmDv9/InGxj6LuDJX4VEZL/0pJrmlxPZmlt0eh45ciTCwsJwyy232LsqLiclMx+bj6Wp8pC27L9ATqAwz9DRWXR9AKjf2d41IiIicmhuETBMmDABX375pb2r4ZKW7z8PnR5oXz8UDcMD7F0dovLptMDxdcC+hcDiJ4ELR4GgGGBAcR8GIiIiqpBbtMNfd911nHHQRn4rMVkbkUNK+BVYPhXIMKTOmbS9BfALtVetiIiInIbdWxjWrl2LYcOGITbWMDvwL7/8csU2c+fORePGjeHn54fu3btj69atdqkrlZaUkYdtJy6o8k0cTpUcNVhYcPeVwYLYNNfwOhERETl2wJCdnY327duroKA8P/zwAyZNmoTp06dj586dattBgwaVGoasQ4cOaNOmzRXLuXPlXCSQ1SzZex4ygWCnhnUQV8efZ5YcLw1JWhZQySyXy6cZtiMiIiLHDRhuvPFGvPrqq6pjcnlmz56NBx98EPfeey/i4+Mxb948NQHFp59+atpm9+7d2L9//xWLtFpYKj8/HxkZGaUWYRzyrKioSC3GdeWVZVY9rVZbblkm0TB+TkVlmcZblrJlIdtVVDbO5iefV15Z6lfyOGp6TEuKJ2szdnZ2hWNyxe/JbY/p5MbyWxZM9EDGWRQcWeM8x+SK3xOPid8Tf/b474m/I2DP3+VOETBURg58x44dGDhwoGmdjCUrzzdt2mSTz5w5cyZCQ0NNS4MGhsmcVq5cqR5XrVqlFrFs2TKsX79elSWVatu2baq8YMEC7NmzR5W/+uorHDx4UJU/+eQTHDt2TJWlReXs2bOmoCg11TDx2axZs5CZmamOXcryKM+lLGQ72V7I+40tM7Jf2b+Qz5PPFVIPqY+Q+hlTvqTeUv/qHtO6Hfux4+RFddHVOqTAJY7JFb8ntz6mrCSYY9mCz5znmFzxe+Ix8Xvizx7/PfF3BOzxu9ySa2mNXsIZByF9GH7++WeMGDFCPZeUori4OGzcuBE9evQwbff0009jzZo12LJli1n7lQBDTqSkP9WtWxc//vhjqf2VJBGcMYoT0sIgQYN8ceHh4aZoTKbYluhM6ly2LF+6cVzlsmV5XYIe+Qxvb+9yyzLJhpDtS5Z9fX1VZCmfVV5Z6ibbS5QpS9myvC5ft3xW2bKlx/TZplOYuewfdG1UBz883MMljskVvye3PqaTG4Avhlb5+6Fg7M/wuaq/cxyTK35PPCZ+T/zZ478n/o6APX6XS4Ai17bp6ekICQmp9G+lWwQMNSEBg7Q0mHMy3cnNH6zHnjPpePnm1ri7R2N7V4foStI3YVYjoCCzgrOjAUJigSf3AR6cNImIiNxLhgXXuA6dkhQREaHuUCUllU4tkOcxMTE2/Wxp+pE+E127drXp5zijU2k5Kljw0AA3tuFkbeSgDvxcebAgBs9isEBERFQFhw4YpFmlc+fOpnwrIU0x8ryilCJrGT9+PBISEkz5uXSZsbPzNU3DERnsy1NDjufMDuB/4w3lljcaWhJKkudjvgTih9ulekRERM7E7hO3ZWVl4ciRI6bnx48fV6MeSV+Dhg0bqiFV77nnHnTp0gXdunXDnDlzVF8EGTWJ7GPxXsPIM5ysjRxS+hng+9uBojzgqsHAbd8Y1suoSdIROigaaNSTLQtERETOEjBs374d/fr1Mz2XAEFIkPD555/jtttuQ0pKCl588UUkJiaqOReWL1+O6OhoO9bafR1PzcaBcxnw9NBgcBvbpoURWSw/C/juX4bAIKo1MPqTy4FBkz48oURERM4YMFx33XWq93ZlHn/8cbXUJunDIItxLHEyWLzH0LrQs1k46gYaevQTOQQZx/vnh4HEfUBgJDD2e8A32N61IiIicnoO3YfBntiHofL+C8PaWT4pHpFN/fkycHAx4OkD/OtboE5DnnAiIiIrYMBAZjuSnImDiZnw9tRgUGumI5ED2f0dsP4dQ3n4B0CDbvauERERkctgwFABDqt6pd/2GFoX+rSIRGiAty1/LonMd2oz8NsThnKfp4D2t/HsERERWREDhgowJak06WdiHB1pSFvOvUAO4uJJ4Ps7AG0B0GoY0O95e9eIiIjI5TBgILNIKtLRlGz4eHrg+tYcoYocQF6GYUSknFSgXntg5HzAg7/SiIiIrI1/XcksS/Ya0pH6toxEiB/TkcjOdFrgpweA5AQgKAb413eAT6C9a0VEROSSGDCQRelIQ9sxHYkcwMoXgcO/A15+wO3fAqFx9q4RERGRy2LAUAF2er5MJmo7kZYDXy8PDGzFdCSysx1fAJs+MJRH/B8Q19neNSIiInJpDBgqwE7Pl/1W3LrQ/+ooBPrafa4/cmfH1wFLDLPB47pngTaj7F0jIiIil8eAgapMRzL2XxjKydrIntKOAgvuAnRFQJvRQN+n+X0QERHVAgYMVKk9Z9Jx5mIuAnw8VQsDkV3kXgK+vQ3IvWhIQbp5LqDR8MsgIiKqBQwYqFKL9xjSkQa0ioa/jyfPFtU+bRHw4zgg7TAQEgf861vA25/fBBERUS2xOCH9+PHjWLduHU6ePImcnBxERkaiY8eO6NGjB/z8/OBKnZ5l0Wq1cFc6nR5L9hnSkThZG9nN8mnAsdWAdwBw+/dAcAy/DCIiIkcMGL755hu8++672L59O6KjoxEbGwt/f39cuHABR48eVcHCHXfcgalTp6JRo0ZwhU7PsmRkZCA0NBTuaOepizifnocgXy9c1zLS3tUhd7T1Y2DbxwA0wKiPgXrt7F0jIiIit2NWwCAtCD4+Phg3bhx++uknNGjQoNTr+fn52LRpE77//nt06dIFH374IW699VZb1ZlqyeLizs7Xx0fDz5vpSFTLjv4JLJtqKA+cDrQayq+AiIjIUQOGWbNmYdCgQRW+7uvri+uuu04tr732Gk6cOGHNOpIdaHV6LC1OR+JkbVQrMzef3AhkJQFB0UBABLBgHKDXAu1vB3o9yS+BiIjIkQOGyoKFssLDw9VCzm3biQtIzsxHsJ8XereIsHd1yJUl/AosnwpkGDrYKxpPQ7DQ4Bpg2LscEYmIiMjZRkmSPgvPP/88br/9diQnJ6t1y5Ytw4EDB6xdP7KTxcWTtQ1qHQNfL6YjkQ2DhQV3lw4WhAQLotPdgJcvTz8REZEzBQxr1qxB27ZtsWXLFixatAhZWVlq/Z49ezB9+nS4ChkhKT4+Hl27doW7KdLqsGxfoiozHYlsmoYkLQvQV7zN6tcM2xEREZHzBAzTpk3Dq6++ipUrV6qO0Eb9+/fH5s2b4SpkhKSEhARs27YN7mbL8QtIyy5AWIA3ejVnOhLZiPRZKNuyUFbGWcN2RERE5DwBw759+zBy5Mgr1kdFRSE1NdVa9SIHSEca3CYG3p6c249sRDo4W3M7IiIisgmLrwbr1KmD8+cNo+eUtGvXLsTFxVmrXmQnhZKOtN+QjjSkbSy/B7IdGQ3JmtsRERGRYwQM//rXv9TkbImJidBoNNDpdNiwYQMmT56Mu+++2za1pFqz4UgqLuUUIjzQB9c0rcszT7bTqCcQIkGppoINNEBInGE7IiIicp6AYcaMGbj66qvV5G3S4Vk6Bl977bXo2bOnGjmJnNuS4snabmwbAy+mI5EteXgCg1+voNNzcRAxeJZhOyIiInLseRhKko7OH3/8MV544QXs379fBQ0yE3SLFi1sU0OqNQVFOvx+wDg6EtORqBa0uB7wDQHyM0qvl5YHCRbih/NrICIicraAwahhw4ZqIdex7nAKMvKKEBnsi66NmY5EtWDHF4ZgIaQBcPP7QE6aoc+CpCGxZYGIiMh5AoZJkyaZvcPZs2fDVeZhkEWrdZ8x4BcXpyMNaVsPnh4V5ZUTWUlhHrBhjqF87VNAs348tURERM4aMMgISOaQTtCuNA+DLBkZGQgNDYWryyvUYmWCYfhKTtZGtWLXV0DmeSCkPtBhLE86ERGRMwcMq1evtn1NyK7WHEpBVn4R6oX6oVPDMH4bZFtF+cD6dwzl3k8CXr4840RERA6Ks3LRFelIHkxHIlvb/a1hFufgekDHu3i+iYiIXK3T8/bt27FgwQKcOnUKBQUFpV5btGiRtepGtSS3QItVfxvSkYa0q8fzTralLQTWFfd16vUk4O3HM05ERORKLQzff/+9mnPh77//xs8//4zCwkIcOHAAf/75p1vk+ruiPw8mI6dAi/ph/ujQoI69q0Oubs/3QPopIDAK6HyPvWtDREREtpi47Z133sFvv/2m5mR49913cfDgQYwZM4bDrDqpJfvOmVoXXKnjOjkgbRGw7i1DudcEwNvf3jUiIiIiawcMR48exZAhQ1RZAobs7Gx1kTlx4kR89NFHlu6O7Cw7v0i1MIhhnKyNbG3fj8DFE0BABNDlXp5vIiIiVwwYwsLCkJmZqcpxcXFqtmdx6dIl5OTkWL+GZFN//J2EvEIdGoUHoHVsCM822Y5OC6x901Du+W/AJ5Bnm4iIyBU7PV977bVYuXIl2rZti1tvvRUTJkxQ/Rdk3YABA2xTS7I6rU6Prccv4ON1x9Tzm9rGMB2JbGv/IuDCUcC/LtD1AZ5tIiIiVw0YPvjgA+Tl5anyc889B29vb2zcuBGjR4/G888/b4s6kpUt338e//ktAefTDd+j+HH7GbSvXweD23CUJLJx60KP8YBvEE8zERGRk9Do9Xq9vSvhyIwzPaenpyMkJMQlgoVHv96Jsl+6savz/93ZiUED2aZ1YeG9gF8o8OR+wM/5/y0RERG5yzWuxX0Yli5dit9///2K9StWrMCyZcvgKubOnYv4+Hh07doVrpSGJC0L5UWIxnXyumxHZDU63eXWhWvGM1ggIiJyMhYHDNOmTYNWq71ivU6nU6+5ivHjxyMhIQHbtm2Dq5A+CyXTkMqSMEFel+2IrObgYiA5AfANAbo/zBNLRETk6gHD4cOH1Z33sq6++mocOXLEWvUiG0jOzLPqdkRVkozHNW8Yyt0fAfw5MSAREZHLBwyS63TsmGFknZIkWAgM5DCJjiwq2M+q2xFV6Z9lQNI+wCcIuOZRnjAiIiJ3CBhuvvlmPPnkk2oCt5LBwlNPPYXhw4dbu35kRd2a1EW9UD9TB+eyZL28LtsRWad14fXiH76HgAD+XBEREblFwPDGG2+olgRJQWrSpIlaWrVqhfDwcLz11lu2qSVZhaeHBtOHxZfb6dkYRMjrsh1RjR1eCZzfDXgHAj0e5wklIiJyl3kYJCVJ5l2Qidr27NkDf39/tGvXTk3oRo5P5lm4s3tDfL3lVKn1MaF+KljgPAxk9daFrvcDgeE8sURERO4SMAiNRoMbbrhBLeLSpUvWrhfZ0MXcQvU4qlMc+l4VqfosSBoSWxbIao7+CZzdDnj5Az3/zRNLRETkTilJr7/+On744QfT8zFjxqh0pLi4ONXiQI5Np9Nj45FUVb69W0Pc3CEOPZqFM1gg27QudLkPCIri2SUiInKngGHevHlo0KCBKktakiwyYduNN96IKVOm2KKOZEUHzmXgYk4hgny90KEBh7gkGzi+Fji9BfD0BXo9wVNMRETkbilJiYmJpoBh8eLFqoVBUpMaN26M7t2726KOZEXrjqSox2ua1oW3p8XxIlHVjPMudB4HBMfwjBERETk5i68Yw8LCcPr0aVVevnw5Bg4cqMp6vb7cGaDJsaw/bEhH6t08wt5VIVd0Yj1wcj3g6QP0mmDv2hAREZE9WhhGjRqFsWPHokWLFkhLS1OpSGLXrl1o3ry5NepENpJboMX2ExdVuXeLSJ5nsl3rQse7gNA4nmEiIiJ3DBjeeecdlX4krQwyJ0NQUJBaf/78eTz22GO2qCNZydYTF1Cg1anJ2ZpFclZusrJTm4HjawAPb6D3RJ5eIiIidw0YvL29MXny5CvWT5zomBcIEtjcddddSE5OhpeXF1544QXceuutcEfrD6eY0pFkaFwim7QudBgL1DH0cyIiIiI3nYfBmUiQMGfOHHTo0EF12O7cuTNuuukmNVu1u1ln7L/Qgv0XyMrObAeOrgI0nkCfSTy9RERELsTlA4Z69eqpRcTExCAiIgIXLlxwu4AhJTMfBxMzVbkXOzyTtRnnXWh/OxDWmOeXiIjIhdh9XM21a9di2LBhiI2NVWkyv/zyyxXbzJ07V/Wb8PPzU0O3bt26tVqftWPHDjWSk3FYWHeyoXiytvh6IYgI8rV3dciVnN0JHF4BaDzYukBEROSC7B4wZGdno3379iooKI/MKj1p0iRMnz4dO3fuVNsOGjRI9UkwknSjNm3aXLGcO3fOtI20Ktx999346KOP4I6M6Uh9mI5E1rb2TcNj2zFAeDOeXyIiIhdj94BBhmV99dVXMXLkyHJfnz17Nh588EHce++9iI+PVzNNBwQE4NNPPzVts3v3buzfv/+KRVotRH5+PkaMGIFp06ahZ8+eldZHts3IyCi1iMLCQvVYVFSkFuO68soFBQWmOSnKlnU6nelzKirLnBaylC0L2a6isuxfyOeVLMs2640TtjUJMx2HMx+TsVz2OHhMtfw9nd8D/LMUemiAayfze+K/J/6O4O89/i7n3ydeRxQ417WRzSZuq1u37hVLeHg44uLi0LdvX3z22WewBjlwSSMyTg6nKuzhoZ5v2rTJrH3IyR83bhz69++vRkuqysyZMxEaGmpajOlLK1euVI+rVq1Si1i2bBnWr1+vypJKtW3bNlVesGAB9uzZo8pfffUVDh48qMqffPIJjh07psrSonL27FlTUJSaamgBmDVrFjIzM9WxS1ke5bmUhWwn2wt5v7FlRvYr+xfyefK5Quox96ufkJSRD28P4PzedWq91Fvq76zHJPURUj9jGhuPyQ7fU3HrwmHfdkBEC35P/PfE3xH8vcff5fz7xOuIT5zj2sjca2lFb6HZs2frw8PD9Xfeeaf+vffeU4uUIyIi9K+99pr+gQce0Pv6+uo/+ugjS3etl+r8/PPPpudnz55V6zZu3FhquylTpui7detm1j7XrVun12g0+vbt25uWvXv3Vrh9Xl6ePj093bScPn1a1SE1NVW9XlhYqBZRUFBQbjk/P19fVFRUblmr1Zo+p6KyTqdTS9mykO0qKsv+hXxeyfJHfx3WN5q6WD/2o02qnsbjKFl2tmMylsseB4+p9r6n/FM79frpIXrd9FB9wZk9/J7474m/I/h7j7/L+feJ1xF657k2SktLU9e4cr1bFY38z/zwAhg9ejSuv/56PPLII6XWz58/HytWrMBPP/2E999/X/UV2LdvnyW7Vp2ef/75Z5U+JKQPgrRabNy4ET169DBt9/TTT2PNmjXYsmULbE1SkqSlIT09HSEhIXBG932+DX8eTMa0G6/GI32ZY05W8uM44MDPQPwIYMwXPK1EREROxJJrXItTkn7//fdSKUJGAwYMUK8JmefA2BRTEzIEqqenJ5KSkkqtl+cyRKotSdOP9Jno2rUrnFlBkQ6bj6WZJmwjsorkg8CB4hHNrp3Ck0pEROTCLA4YpL/Cb7/9dsV6WSevGUc+Cg4OrnHlfHx81ERrxnwrY2cPeV6yxcEWxo8fj4SEBFMOv7Padeoicgq0CA/0UUOqElnFurekFRO4eigQ04YnlYiIyIVZPHHbCy+8gEcffRSrV69Gt27d1Dq5qF66dKkawcjYQVg6P5sjKysLR44cMT0/fvy4GvVIgo+GDRuqIVXvuecedOnSRX2ezNosAYmMmkRVW188/0LP5hHw8NDwlFH16bTAyY3A+d3AvoWGdX2f5hklIiJycRYHDDLEqaTqfPDBB1i0aJFa17JlS9WnwDhk6VNPPWX2/rZv345+/fqZnkuAICRI+Pzzz3HbbbchJSUFL774IhITE9WcC8uXL0d0dDRsnZIki3FYSqeff4HpSFQTCb8Cy6cCGZfnNoGXH3DxJFCvPc8tERGRC7O407O7ceZOz+k5hej4ygro9MDGaf0RW8ff3lUiZw0WFtxtSEG6ggYY8yUQP9wOFSMiIqLauMa1uIVByF13Gd/177//Vs9bt26N4cOHqw7K5Dg2HUtVwULTyEAGC1T9NCRpWSg3WCi2fBpw9RDAg//+iYiIXJHFAYP0N5BRkGQSCUlFMk52JhOcLVmyBM2acdhOR0tHurZFpL2rQs5K+iyUTEO6gh7IOGvYrkmfWqwYEREROewoSU888YQKCk6fPo2dO3eq5dSpU2jSpIl6zVW4wrCqxg7PHE6Vqi0rybrbERERkeu3MEjn5s2bN5uGUBXh4eFqKutevXrBVciwqrIY87uczekLOTiZlgMvDw2uaRZu7+qQswqKtu52RERE5PotDL6+vsjMzCx3eFSZN4EcKx2pY8M6CPKtVlcVIqBRTyCoskkSNUBInGE7IiIickkWBwxDhw7FQw89hC1btkAGWJJFWhweeeQR1fGZHMP6IynqsXdz9l+gGtB4ACGxFb1oeBg8ix2eiYiIXJjFAcN7772n+jDITMt+fn5qkVSk5s2b491334WrcOY+DFqdHhuOpKly7xYR9q4OObO/fwXO7TQEDoFRpV+TQIJDqhIREbm8as/DcPjwYRw8eFCVW7VqpQIGV+SM8zDsOX0JN8/dgGA/L+x64Xp4eVocFxIBuReBud0NHZqvfRq4bpphNCR5Ln0WJA2JQ6kSERE5JZvPwyBatGihFnLc0ZF6NA1nsEDVt/JFQ3AQ3gLo85QhOODQqURERG7HrIBh0qRJZu9w9uzZNakPWcG6w4b+C32YjkTVdXwdsPNLQ3n4e4C3H88lERGRmzIrYNi1a5dZO9NoijtBkt3kFBRhx8mLqtybE7ZRdRTmAr9NMJS73McRkIiIiNycWQHD6tWr4W6k07MsWq0WzmTL8Qso1OoRV8cfjcMD7F0dckZr3gAuHAWC6wEDX7J3bYiIiMjO2Bu2AjJpW0JCArZt2wZnsr54/gVJR2KLD1kscR+woXi0syFvA37ON2khERER2SFgkDkWzpw5Y9YOf/jhB3zzzTc1rRfVMGDgcKpkMZ0W+PXfgF4LtBoOXD2EJ5GIiIjMS0mKjIxE69at1XwLw4YNQ5cuXRAbG6vmYLh48aK6E79+/Xp8//33av1HH33EU2sHyRl5+CcpE9KVpFczzr9AFtoyDzi3C/ANBW56k6ePiIiIzA8YXnnlFTz++OP45JNP8OGHH6oAoaTg4GAMHDhQBQqDBw82Z5dkw+FU28SGIizQh+eYzHfxBPDnq4byDa8AwTE8e0RERGTZPAzR0dF47rnn1CKtCqdOnUJubi4iIiLUzM/Ml7c/piNRtcjcjYsnAoU5QOM+QKe7eSKJiIioZhO3hYWFqYUch0zYbWxh6NOc6Uhkgb0/AEf/BDx9gWHvyvjIPH1ERERkwlGSKiBDqsbHx6Nr165wBoeSspCcmQ8/bw90bsxgjsyUnQosf8ZQvm4qEN6Mp46IiIhKYcDgIsOqGmd37tYkHL5envauDjkLCRZyLwDRbYCeT9i7NkREROSAGDC4CKYjkcUOrwT2LQA0HsDw9wBPb55EIiIiugIDBheQX6TFlmMXVJnzL5B5PzRZho7O4prHgLjOPHFERERknYBBRkbKyckxPT958iTmzJmDFStWWLorspKdJy8ht1CLiCBfXB0TzPNKVZMhVNNPA3UaAv2e5RkjIiIi6wUMN998M7788ktVvnTpErp37463335brf+///s/S3dHVrD+iKH/Qu/m4Rzelqp2ZrthkjYxdA7gE8izRkRERNYLGHbu3Ik+ffqo8sKFC9X8DNLKIEHEe++9Z+nuyKrzL0TyfFLligqAX/8tA/EC7f4FNB/AM0ZERETWDRgkHUlmdhaShjRq1Ch4eHjgmmuuUYED1a5LOQXYezZdlXtz/gWqysZ3geQEICAcGDSD54uIiIisHzA0b94cv/zyC06fPo3ff/8dN9xwg1qfnJyMkJAQuApnmYdh49E0NVFvi6ggxIT62bs65MhSDgFr3jCUB78OBIbbu0ZERETkigHDiy++iMmTJ6Nx48aq/0KPHj1MrQ0dO3aEq3CWeRjWmdKROLszVUKnA36bAGgLgObXA21v4ekiIiIis3jBQrfccgt69+6N8+fPo3379qb1AwYMwMiRIy3dHVmpw3MfBgxUmZ2fA6c2At6BwNDZgEbD80VERES2CRhETEyMWkrq1q1bdXZFNXAyLRunL+TC21OD7k2YXkIVyDgHrJxuKA94wTCUKhEREZE1Awbp2GyuRYsWmb0tWScdqWPDMAT6Viv2I3ewdAqQn2GYnK3bQ/auDREREbliH4bQ0FDTIh2bV61ahe3bt5te37Fjh1onr1PtD6fah6MjUUUSfgUOLgY8vIDh7wMenjxXREREZBGzbkt/9tlnpvLUqVMxZswYzJs3D56ehosPrVaLxx57zKVGSXJ0Wp0eG4+ywzNVIvcSsHSyodx7IhDdmqeLiIiIbD9K0qeffqpGSTIGC0LKkyZNUq9R7dh75hIy8ooQ4ueFdvXr8LTTlVa+CGQlAeEtgD7FgQMRERGRhSxOfC8qKsLBgwfRsmXLUutlnU6GbqRaTUfq2SwCnh4c8YZk6FQtcHKjIUjISgZ2fmE4LcPeBbw5RwcRERHVUsBw77334v7778fRo0dNIyNt2bIFs2bNUq9R7Vh3hOlIVKavwvKphhGRSmraD2jci6eKiIiIai9geOutt9SQqm+//baai0HUq1cPU6ZMwVNPPVX9mpDZsvOLsOvURVXm/AukgoUFdwPQX3kyjv1leD1+OE8UERER1U7A4OHhgaefflotGRkZap0rdnaeO3euWqRDt6PZcjwNhVo9GtT1R6PwQHtXh+ydhiQtC+UFC0bLpwFXD+EISURERFQ7nZ5LkkDBFYMFMX78eCQkJGDbtm1w1PkXejePtHdVyN6kz0LZNKRS9EDGWcN2RERERLURMCQlJeGuu+5CbGwsvLy81AhJJReqvQ7P17aI4Ol2d+mnzdtOOkITERER1UZK0rhx43Dq1Cm88MILqu+CRsMRempTYnoeDidnQQZGkhGSyE3JiGT7FxqGTjVHULSta0REREQuyuKAYf369Vi3bh06dOhgmxpR5ee/eHSktvXrIDTAm2fLHR1fB6x4Hji/2/Bc4wHoKxrSWAOExAKNetZmDYmIiMidA4YGDRpAr6+kgyXZ1PrDKeqxT3O2LridlEPAH9OBf5YanvsEA30mAnUaAT89ULxRyX+bxa1/g2exwzMRERHVXsAwZ84cTJs2DfPnz0fjxo2r/8lkMQnU1h9JU+Xe7L/gPrJSgL9mAjs+B/RaQOMJdLkX6DsNCCru+O7pc+U8DNKyIMECh1QlIiKi2gwYbrvtNuTk5KBZs2YICAiAt3fptJgLFy7UpD5UiYOJmUjNykeAjyc6NQzjuXJ1BTnA5g+B9XOAgkzDupY3AQP/A0ReVXpbCQpk6FTjTM/SZ0HSkDw4EAERERHZoYWB7Ds6UvcmdeHjVaMRccnROzTv/R5Y9QqQWdxiENsRuOFVoHHvit8nwUGTPrVWTSIiInIPFgcM99xzj21qQlVaV9zhuXcLzr/gso6uBla+ACTuMzwPbQAMmA60GS2zJtq7dkREROSGLA4YhMx+/Msvv+Dvv/9Wz1u3bo3hw4dzHgYbyivUYutxQ/+FPuy/4NwzM5eXNpSUYBgi9chKw3a+ocC1TwHdHga8/exdayIiInJjFgcMR44cwU033YSzZ8+iZcuWat3MmTPV6ElLlixRfRvI+naevIi8Qh2iQ3zRIiqIp9gZJfx6ZcfkoBgg8mrgxFrD0KgeXkDXB4BrnwYCw+1ZWyIiIqLqBQxPPPGECgo2b96MunXrqnVpaWm488471WsSNJDt0pF6NY/gZHnOGiwsuLvMsKcyAlKiYRGthgMDXwLCGXQTERGREwcMa9asKRUsiPDwcMyaNQu9evWydv2oTIdnpiM5aRqStCyUDRZKCowEbv2coxoRERGRw7G4F6Wvry8yM4uHeCwhKysLPj4+cDSXLl1Cly5d1MzUbdq0wccffwxnczG7APvPpZtaGMjJSJ+FkmlI5clOMWxHRERE5OwBw9ChQ/HQQw9hy5YtaiIxWaTF4ZFHHlEdnx1NcHAw1q5di927d6s6z5gxQ6VQOZMNR1Mhk2tfHROMqGB2gHU60sHZmtsREREROXLA8N5776k+DD169ICfn59aJBWpefPmePfdd+FoPD091QRzIj8/3xTkOGM6Um+2LjgnGQ3JmtsREREROXLAUKdOHfzvf//DoUOHsHDhQrX8888/+PnnnxEaGmpxBeTu/7BhwxAbG6s688pwrWXNnTsXjRs3VsFJ9+7dsXXrVovTktq3b4/69etjypQpiIhwnrQeCW7WGQMGDqfqnGTo1IDKRjzSACFxhu2IiIiIXGEeBiEtCrLUVHZ2trqYv++++zBq1KgrXv/hhx8wadIkzJs3TwULMtP0oEGDVJASFRWltpH+CUVFRVe8d8WKFSoQkSBnz549SEpKUp9xyy23IDraOe7mHk/NxtlLufDx9ED3Jhxm0ykV5lYSm2sMD4NnscMzERERuUYLw+jRo/H6669fsf6NN97ArbfeanEFbrzxRrz66qsYOXJkua/Pnj0bDz74IO69917Ex8erwEFSjD799FPTNtI/Yf/+/VcsEiyUJEGCBCfr1q2rsD6StpSRkVFqEYWFhepRAhNjcCLryisXFBSoye3KK+t0OtPnVFSWVoUirQ5rD57Hh6uPqPUdGoTA38dTbSfbiLJl2b+QzyuvLPUreRy1fUyylC2Xdxyudkz6VS8DOSmqlUEfXK/Uz5s+JBYY8yW0LYc41TG54vfEY+L3xJ89/nvi7wj+LnfHv082CRgkhUgmbivvwl9esyY58B07dmDgwIGmdR4eHur5pk2bzNqHtCoYR3VKT09XdTROOFcemYROUquMi0xIJ1auNMzAu2rVKrWIZcuWYf369aosqVTbtm1T5QULFqgWDfHVV1/h4MGDqvzJJ5/g2LFjpjQrmfzOGBSlphrSjmR42p+3HUfv1//E3Z/vxMKdhm12nUjF8v3n1XayvZD3y36E7Ff2L+Tz5HOF1EPqI6R+xpQvqbfUv7aOSb4D+T6lLI/yXMrCpY/p1GZg60eGH65RH+PosP/hlzoPAqP/i+N9P8BnIROB+OHOdUyu+D3xmPg98WeP/574O4K/y93s79MmM6+lhUZvYQ9gf39/dUe/7EW3VLpjx47IzZX0i+qRPgzSF2LEiBHq+blz5xAXF4eNGzeqTtZGTz/9tJoPQkY9qor0d5BRnYyR2/jx4/Hwww9XuL1EcMYoTkgLgwQN8sXJfBPGaMzLy0tFZ1LnsmX50qWztSxly/K6BD3yGd7e3leUf9t1Gk/8sLfcEfsleWXu2I4Y0DJcDW8rUaZ8rrEsdZOhbSXKlKVsWV6XcyCfVbZsy2OSsnHIXdm+ZLm843CZY8rJgO9nA4C0I9C2ux2eo+Y5/zG54vfEY+L3xJ89/nvi7wj+LnfDv0+ZmZnq2lZuqIeEhFg3YOjWrZsaWvXFF18stf6ll17Cb7/9ploEHClgqCkJGKSlwZyTWVNanV61LJxPzyv3dQkYYkL9sH5qf3h6FOe+k+NaOR3YMAcIigHGbwb8w+xdIyIiIiKLr3Et7vT8wgsvqI7DR48eRf/+/dU6ad747rvv8OOPP8KaZDQjidQkragkeR4TEwNbkqYfWYz5aLVh6/ELFQYLQiI7eV2269GMHaAd2tmdwMb3DOWh7zBYICIiIqdlcR8GGQJV8qKOHDmCxx57DE899RTOnDmDP/74w9QyYC3SrNK5c2dTvpWQphh5XrLFwRYkdSkhIcGUp1YbkjPzrLod2UlRAfC/xwG9DmgzGrj6yj4/RERERC49rOqQIUPUYg1ZWVkq+DA6fvy46iNRt25dNGzYUA2pes8996BLly4qHUqGVZWhWGXUJFdj7izOnO3Zwa2fDSQfMMy9cOMb9q4NERERUe0HDDIRmkzYJj21J0+erC7ud+7cqYYtlT4Hlti+fTv69etnei4BgpAg4fPPP8dtt92GlJQU1WciMTFRzbmwfPlyp5lHwRLdmtRFvVA/JKbnVdjpWfowyHbkoJIOAGvfNJRvehMIdJ5JAomIiIis0ul57969alhT6SRx4sQJNYFa06ZN8fzzz+PUqVP48ssv4QpK9mGQWa1ro9OzkKFTH/16pyqX/GKMXZz/785OGNym9Fj+5CC0RcB/BwLndgEthwD/+kZ68tu7VkREREQ16vRscR8GaQEYN24cDh8+DD+/yyk0MjeDtedhsCd79GEQEgxIUCAtCSXJcwYLDm7TB4ZgwS8UGPI2gwUiIiJyz5QkuYCeP3/+FeslFUlShsg6QcP18TFqNCTp4Cx9FiQNiUOpOrDUw8DqGYbyoJlACFuBiIiIyE0DBpk0QpowypK0ncjISLgKewyrWpIEBxw61UnINO8yKpI2H2g2AOgw1t41IiIiIrIai1OShg8fjpdfflnNEGecbE36LkydOhWjR4+Gq7BXShI5oW0fA6c3Az5BwLA5TEUiIiIi9w4Y3n77bTUUalRUFHJzc9G3b180b94cwcHBeO2112xTSyJHdfEE8MdLhvL1/wHqNLR3jYiIiIjsm5IkvalXrlyJDRs2YM+ePSp46NSpkxo5icityABjvz4BFOYAjXoBne+zd42IiIiIHGMeBtGrVy+1GOdlIHI7O78Ejq8BvPyB4e8DHhY32BERERE5PIuvcF5//XX88MMPpudjxoxBeHi4GiVJWhxchXR4jo+PR9euXe1dFXJE6WeBFc8byv2fB8Kb2btGRERERI4RMMybNw8NGjRQZUlNkmXZsmW48cYbMWXKFLgKdnqmSlORFk8E8jOAuC7ANY/yZBEREZHLsjglSeZaMAYMixcvVi0MN9xwAxo3bozu3bvboo5EjmXfj8Dh3wFPH+DmDwAPT3vXiIiIiMhxWhjCwsJw+vRpVV6+fLmps7Ner7fbnAVEtSYrGVj2tKHc92kgqhVPPhEREbk0i1sYRo0ahbFjx6JFixZIS0tTqUhi165danhVIpe2dDKQexGIaQv0etLetSEiIiJyvIDhnXfeUelH0srwxhtvICgoSK0/f/48HnvsMbgKe8/0TA4o4X+GReMJ3DwX8PS2d42IiIiIbE6jl1wiqlBGRoaaeyI9PR0hISE8U+4q5wIwtzuQnQz0mQwMeMHeNSIiIiKqlWtcDhxPZI7lzxiChYiWhr4LRERERG6CAQNRVQ6tAPZ+Lw1yhlQkL1+eMyIiInIbDBiIKpOXDiwu7tzcYzzQgBP5ERERkXuxuNMzkUvTaYGTG4GsJCAoGti3AMg4C4Q1Afo9Z+/aERERETlPwFBQUIDk5GTodLpS6xs2bAhXwFGS3FDCr8DyqUDGuStfkwnafALsUSsiIiIi5xol6fDhw7jvvvuwcePGUutlNxqNxuWGIeUoSW4ULCy4W36Sy399zFdA/PDarhURERGR3a9xLW5hGDduHLy8vLB48WLUq1dPBQlETp+GJC0LFQUL0tl5+TTg6iGAh2ctV46IiIjIviwOGHbv3o0dO3bg6quvtk2NiGqb9FkoLw3JRG/oxyDbNelTixUjIiIicsJRkuLj45Gammqb2hDZg3RwtuZ2RERERO4cMLz++ut4+umn8ddffyEtLU3lP5VciJyOjIZkze2IiIiIqqDVabEtcRuWHluqHuW5y6QkDRw4UD0OGDDALTo9kxto1BMIia0kLUljeF22IyIiIqqhP07+gVlbZyEp53L2QnRANKZ1m4aBjQzX2k4dMKxevdo2NSGyF+nI3HoksGluOS8Wd+ofPIsdnomIiMgqwcKkvyZBX2awleScZLV+9nWzHS5osDhg6Nu3L9wB52FwI0kJwPbPDWWfIKAg6/Jr0rIgwQKHVCUiIrKYpNnsTN6JlJwURAZEolNUJ3i68YiDWp1WtSyUDRaErNNAg9e3vo5+Dfo51Hkyax6GvXv3ok2bNvDw8FDlyrRr1w6uhPMwuLjcS8DH/YALx4Cm1wG3LwDObL0807OkITnQP1giIiJnuaivjbQbZwtItiVuw32/31fldp8O+hRdY7o61zwMHTp0QGJiIqKiolRZ+iqUF2ewDwM5FZml/OeHDcFCaANg9KeAty+HTiUiIrdhq4v62ki7cZZ+AAXaAuxK3oUNZzdg2YllZr1HAiBHYlbAcPz4cURGRprKRC5h7ZvAoeWApy9w21dAYLi9a0RERFRrbHFRn6/NR2puKl7d/GqFaTfitS2voXN0Z9TxrVOtSYAdvR/A6czTKkCQZUviFuQW5Vr0fmktcSRmpSS5M6YkuahDvwPf3maYlO3mD4GOd9i7RkRERLVGUnkG/TSo1N35kiSXPiogCt/c9A0yCjJwKf8SLuZdLP2YfxGX8ko/Wnph7KnxRKhvqAocTItfiXKJdbJdmG8YAr0CcdPPN1Vad2lpWD56eY3SkyxJd8otylXpRipIOLcBJzNOlno93C8cveJ6oUe9Hpi9Y7YKqsoLqKxVd7ukJBG5lLSjwKIHDcFC1wcYLBARkduRC+GKLriFXMzK6wMXWn6XXi56y7sYLo9Wr8WFvAtqsRb57MScRKw6tQr9G/aHl4eX1dOd9Ho9jqUfw/qz61WQsCNpBwp0BaZtvTReaB/VHr3jeqNXbC+0rNsSHhrD9Gd+Xn6qFaTseZLnYmq3qQ7XD4MtDFVgC4OLKcgGPrkeSD4A1O8GjFsCePnYu1ZERES1Ru6cz909Fx/v+9is7eWuvtzhV4++dRDmV8Fj8XZ/p/2N+1fcX+V+5w2ch+Z1mqvWCtOSd7mcnp+uWi3k0fhaZmGmRccqF+lyd19aCKL8o9SjWvwjVQuKPMrzun51TRf0FaU7GV1T7xqcyDiBxOxElFQvsJ4hQIjrhe4x3REkIy9aEJDEBMSoYKG2UqksucZlwGDFk0kOTrLvfrof2P8TEBgFPLwWCKln71oRERHZnNwR35+6H0uPL8XvJ35HSq55nWo/vv5jXBN7TbXSnaQ/gbXTbgp1hVhzeg0m/jXRqi0d0iIQ7h+OCL8IHEk/ovpiVMXHw0eNZCQBgixNQppY1B/D3iM8MSWJqDybPzQEC9I0OeYLBgtEROTyjl46iiXHlmD5ieWqI65RsHcwivRFFfY5MF7UV2doT7noldQdW6TdeHt4qzkKpG5VBSRLRi5BRmGG2k4uypNzix/leW6KKstjWm6aOhdyt7+yNK2SJnaaiNtb3Q5/L39Ulxy/rYdOtZZq9WG4dOkSFi5ciKNHj2LKlCmoW7cudu7ciejoaMTFxVm/lkQ1dXwdsOIFQ3nQDMP8CkRERC7obNZZLDu+TC2HLh4yrZeL2+saXIebmtyk8urXnFmjLuqFtXPpJa1GRioqrx9ATdNuzA1IfLx8EOEVgQj/CKCSgRCLdEUqaJDgQc7ZlwlfVlmHmMCYGgULzsbilCSZuG3gwIEqTefEiRP4559/0LRpUzz//PM4deoUvvyy6pPsTJiS5ALSzwDz+wI5qUC7fwEj58mkIfauFRERkdVSV2TUnRUnVqgL3t0pu03rpcNv79jeuKnpTehbvy8CvANqNZfelmk3tqi7I02s5tR9GCRY6NSpE9544w0EBwdjz549KmDYuHEjxo4dq4IIV8KAwckV5gGf3Qic2wnEtAXuWwH4lP5lSUREjsHeOd2OqLLRerrX665GApIgYfP5zdDpdaa77HIxKy0JcuEsw5G66nm3dt1t2f/C0di0D8O2bdswf/78K9ZLKpLMBu0q5s6dqxatVmvvqlBNLHvaECz41QFu+5rBAhGRg7L1rL22vii2xf4rGq1HzpF0+pWOupJ7b9Q2oi1ubHIjBjUepEYAcsVcelvX3Zb9L5yZxQGDr6+vikjKOnTokGk2aFcwfvx4tRijL3JCOz4Hdn6h/onjlv8CYY3tXSMiIrLDrL22DkZssf+cwhw1G3Jlo/xIsCAj8wxpOkQFCg1DGlbrs6j2+l84K4tTkh544AGkpaVhwYIFqrOz9Gnw9PTEiBEjcO2112LOnDlwJUxJclJndgCfDQa0BUD/F4BrJ9u7RkREVM0Zh2uSAlJRMGK8W2yNYMTc/cuIRNK5Ni0vzfQofQ+kLBOXlXwtqzDLrM//7w3/Rbd63apdf3LNVC2792GQnd5yyy3Yvn07MjMzERsbq1KRevTogaVLlyIwMBCuhAGDE8pKAT7qC2ScBa4eakhFYidnIpfijOkltbHv2ti/tZnbyVTy8RuHNIa3pzd8PX3VGPg+nj7qubEsj+q5p4/axlPjiYdWPqQuyisik3l9M+Qb06zDOp3O8KjXqTv48lhyvfE1eSzUFuLZ9c+qScUqGwZUAh4JCHKKcmBtr/d5XXVoJnLIidvWr1+vWheysrJUJ2jpDO2KGDA4GW0R8OXNwMn1QHgL4ME/AT9OuEfkSpwxvaQ29l0b+69pMCKXHDLk58ELB/H3hb/V466kXRbP3uvMJJCRmYdlkjDjo8wyrJ4XTxwmjyczTuLff/7bLUbrIfvgTM92OpnkAH5/Dtj0ASDTsUuwENnS3jUiIitypPQSR9p3be3fkmBExrY/kX7CFBgYg4TMguoFBwMbDkSYXxgKtAUo0BWou/syG6+xbFwvjzIbsDxmFWQhV1v+xGRlz5EEPtIi4aHxUJ2JPTw8TM/l0fSah5d6lCW7MBvns89Xuf9H2j2Coc2GqgAh0DvQrNmA3Wm0HnLRgEFGSlq9ejWSk5NVE11Js2fPhithwOBE9i0EfrrfUB7zFRA/3N41IqJazHUXdXzr4LXer6mLOnXRV+ICz3hBqJaS5eLn8ufw9iW3q8mbylOTCzRz8/SXjlqqLg6NF73GC19jWS6My1ufV5SnLuYzCq4clMRILlY/G/wZQnxCEOQTpNJ3zLlwNScYef3a19EguIEhOEgzBAYyYZhc0Jcl30eLOi3QKrwVrq57NVqGtcSUtVNUq4W1L4xtPaa+rfdvPO+ivNF6ahoEknvLsGXAMGPGDDVJW8uWLdXMziV/2Uj5zz//hCthwOAkEvcD/70eKMwBek8CBk63d42IyMrMvTirDRJkyN88+c94t1moMjzU4GzGsmxXpC1CRmHFF/P2IBfuQd5B6o636dHH8BjsHYxAH8N6mc123p55lQYjFQnwClBBgXGRIKFZaDPVz6A2LoxtfZe+NloBbD2xGrmvDFsGDBIkvP766xg3bhzcAQMGJ5B7EfioH3DxONC0H3DnTwCbZ4lczk+HfsJLm16qcrvYwFh14as6reoud1otWVaL7vKjsYOro5FWErm4lot7Y4de6URbsixLekE6jl46WuX+5H2StmMLEmS0jWxrCAzqGloPZJhPYzBlrwtjW9+lr41WAGfryE7OwaYBQ7169bB27Vq0aNEC7oABgwPSaYGTG4GsJCAwCtj4HnBkJRDaEHh4DRBQ1941JCIrknSb7w5+h/l756uccXunl7xz3TtoH9leBRlygSh/RnXyn8yyq4epbHpNr8PelL1mBTtz+s1B95juhiBB42X2RaElqTFysSmj9ci5lBx/Gb5TlY2PBYZH47rDFw9jb+reKvc9q88sNR+AI14Y2/ouPVsByBnZdKbniRMnqhmQXW2+BXISCb8Cy6cCGedKr/fwBm77isECkQuR3PyfD/+M+XvmIzk32ZQKJK0C5TGmf8hFZnXI++T9VaWX9GvQz+KL2KahTfF/e/6vyn1fV/+6al0gm1t34wV4sE+wWhBovWDEkpmFa3vGYQkK5Huz1V16W++fyN4sDhgmT56MIUOGoFmzZoiPj4e3d+k8xEWLFlmzfkSlg4UFd6tG3yvoCoFLp4DYDjxjRE5O7sgvO74Mc3fPxenM06Y0o8c6PKby6SevmVxh+ofcMa7uRZq8T0b8kfQS2Z8192/Lfdt6/5YEI47MVsFIbe2fyJ7MSyws4YknnlAjJF111VUIDw9XTRklFyKbpSFJy0J5wYKiAZZPM2xHRE5J0nfWnF6DW3+7FdPWTVPBgoxPLxfCv438DTc3vxk3NL5B5YSXvZstF6zWyBWX99tq/7bcty33bwxGSgYf1gx2iMjxWdyHITg4GN9//71qZXAH7MPgII6vA74YWvV29ywGmvSpjRoRkRVJ2st7O9/D7pTdpg6049qMw52t7kSAd4BLzZbsrHVnnj6Ra7FpH4a6deuqdCRnk5OTg1atWuHWW2/FW2+9Ze/qkKWkg7M1tyMih5CQlqAChQ3nNqjnfp5+GNtqLO5rcx9CfUNdMr3EWevOPH0i92VxwPDSSy9h+vTp+OyzzxAQcOVdH0f12muv4ZprrrF3Nai6gqKtux0R2Vxld7qPpR/DB7s+wMqTK9VzGRFo9FWj8XC7h9W25JhsHezotVrkbN+BopQUeEVGIqBLZ2g8mepE5HQBw3vvvYejR4+q+RgaN258RafnnTt3wtEcPnwYBw8exLBhw7B//357V4eqo1FPIDACyE6tYAMNEBJr2I6I7K689BXJpZeAYF/qPvzv6P9U52bJgZehOKVDs8wUTO4rY8UKJM2YiaLERNM6r5gYRD/7DEJuuKHG+2cwQlSLAcOIESNgTTKnw5tvvokdO3bg/Pnz+Pnnn6/4DBnGVbZJTExE+/bt8f7776Nbt24Wjewk79+4caNV6061KOcCoK2oQ3NxJ7zBszhhG5EDME5kVXZEHQkeXt78sum5DEP5eMfHcVXYVXaoJTlasHB2wpPS873U+qKkJMP6d+fUKGiwdTBC5OosDhgkHcmasrOzVRBw3333YdSoUVe8/sMPP2DSpEmYN28eunfvruZ/GDRoEP755x9ERRlGgujQoQOKiq6coXPFihXYtm2bGtFJFgYMTkpbBCy8F8i7CATXM6zLPH/5dWlZkGAhfrjdqkhEl9OQpGWhvOE3S842/MmgT9AxqiNPG6k7/3IxXzZYUGSdRqNeDx4woFrpSbYORojcgcUBg7XdeOONaqnI7Nmz8eCDD+Lee+9VzyVwWLJkCT799FNMm2YY5m33bsOoGuXZvHmzGtXpxx9/RFZWFgoLC1VP8BdffLHc7fPz89VSsge5kPcJY2Di5eWl1mk0mivKBQUF8PT0VEvZsrzu4eGhPkPSucor+/j4qM+Q7UuWfX19odPp1GeVV5a6yfZarVYtZcvyugyKJZ9VtuzQx7R2BnBiHfTeAdDc/T9o6zSB7sQGeOelQesfAV2Da+Dt6+dcx+SK3xOPid+Tpyc2nt9YKg2pPAW6AuTk5aifHf7s8d9T4a7dpe78X0GvV68fG3MbvCMj4eHjA72XFzQ+3vD09YPe0wMevr5q0Xl4qHUevj7QeXjCw8cbqe/MqTIYCerfH4XFv4P5e49/n9zlb25ROTfbazQPg4yMlJpqyB0PCwtTzytarElOmqQqDRx4eexoOcnyfNOmTWbtY+bMmTh9+jROnDihRkeS4KOiYMG4fcl5JRo0MOTUrlxp6Ji3atUqtYhly5Zh/fr1qvzLL7+o1gyxYMEC7NmzR5W/+uor1X9CfPLJJzh27Jgpzers2bOmoMh4fmfNmoXMzEx17FKWR3kuZSHbyfZC3i/7EbJf2b+Qz5PPFVIPqY+Q+kk9hdRb6u/ox/TH3EnA+nfU89UhtwCRLbFn3378sOUs0PYWbE3xxS+//uZUx+SK35M7H5PcUf/sj88w63+z1NCgK/9Y6Vbf08pNK7HixAo89P1DGPnTSIxfNR7m+HLRlw57TK74PTnkMW3bht9few0pxdtVpeDAAWT/9RcyV6xA1tKlyPzlf7j0ww9I//Y7XPzsc6TNm4+LH/4fUt95B8mzXkfqjBlIfuk/0KWnVxmMZGzezO/JnX72eEyQ78nca2mz52H44osv8K9//UtFNp9//rmKrCpyzz33mP3hV1RGoynVh+HcuXOIi4tTqUQ9evQwbff0009jzZo12LJli0X7l7pLp+fKhlUtr4VBggb5YZSJ6twh4nSYY0o9As3H10GTnwld90dQNOAV5z8mV/ye3PiY/jj1B97a8dYVHXundJ6CQU0HOfwxeXp5Ytv5bUjOTka9kHpoV7cdPDQeFX5PHp4eOJR6CHtS96hlV/IunMk6g+qY128eetTvwZ89N/v3VHDhAjLXrEHuX2uQtXYt9Lm5Zv/M1HngfvjUbwCNTgttbh70hQXQaLUoys2DRlJXC4ugzcsFirSSFgBtfj6Kzp5F/t9/V7nv2LfehN/11/P3ngv/7PGYvK/4niTokmtbc+ZhsHjiNluydcBQHZy4zU4KcoD/Xg8k7QcaXAOMWwx4lh6Ri8gRO/YaZ761xsy99hjFSGb0NdY7X5uPA6kH1NCoEhzsTt6NjAJDmmbJ421ZtyU6RHZAp+hOaBfZDvcsuwfJOcnl9mOQ7eVzlo9ezpmBbcTRRgMqTExE5qpVyFq1Ctlbt0lub6mOx0H9+iFz+XJoL10qP3VILjijo9F81R8WH0f2lq04ZcaNzIZffIHA7uYPpkLkCmw6cZtEgzKakbHDsVFaWppaJxGctURERKjPS0oqnQ8rz2NiYmBL0pwlizWPh8wkfzAWTzQEC4FRwK2fM1ggp+nYK+vkovj1ra+rUYBqOsOuLWbtrWwUo4l/TVT1vph3EQfSDqBQZ+i/ZeTv5Y+2EW1Vh2WpiwQIQT5BpbaRoEP2L+eh5GcYg6mp3aY6fLBgy4tuW+7bEYYmlfuQBUePIvOPP5D5xyrklRnO3LdFCwQNHIDgAQPh1zpe3SwM7HGNoQOyZDCUDBqKMxqk/tU5R1I/OX7p4FxuMCLXNcXHQURWDBgqapAo2VxkLbK/zp07q7w4Y6uDNC/J88cffxy2NH78eLUYoy+qRds/BfZ+D2g8gVs/A0KKR0YicpCLbpmVuLKOvXKRnJiTqCYlu77R9dX+LHNaASxVqC3EjC0zKh3FaPXp1aZyuF+4ajmQAEEWaU3w9qi8tU/qJi0s5dVdggVHbnmx9UW3rfdtr6FJgwcORO7uPchc9Qey/liFgpMnL79Ro4F/x45qlKPgAf3h07jxFftW9Xp3zpX7j46u0bmRIEPeX24wYqJXrRte4eHV+gwid2B2SpJM2CYmTpyIV155BUFBl+8oyV14mU9BOhbv2rXLogrIyEVHjhxR5Y4dO6pOK/369VMdqBs2bKiGVZV+EfPnz1dzL8iwqtJxRjqvyORxtsaUpFp2Zgfw2WBAWwBc/zLQa0Jt14BcTHUvuot0RTibdRYnM07iePpx9Xgi4wROpp9Ecm6y2Z8vMxjHBMYgLigOccFxiA2MRWxQLOoH11dlCWCk34C1Up6yC7ORmJ2I89nnDUvWeXXsxvK57HNqwrSq3NfmPtzS4hZVz8r6rdV264itVXTRbbzTHVeDi25b7lvu/B8ZMLDi0YZqkNZTad2LeQQHQ5eZefnjvL0R2LOnoSWhXz94RUTYtfWl3GAnKgr6oiJoL1yAX+vWKi3JMyiwxp9F5CwsucY1O2Bo0qSJejx58iTq16+vUoVKtgTIrM8vv/yymivBEn/99ZcKEMqSIEE6KYsPPvjANHGbzLkgwYuln1OTlKRDhw6ZdTKphrLTgPnXAhlngFbDgDFfmf6QElVHVRfdb/d9Gx2jO+JE+glTQKCW9BM4k3kGRXrzh5wrjwQCVV2cy916CSBKBhIxATF4c/ubuJB3ocL3hfqG4p74e1QwUDJAyCy4fNFWE6/3eR03Nb0J7sSaF916nU5djEq+vuxXl5+PEyNHqQvhinjWqYOoZ58FCgugy8uDPi8funzDoz4/Dzp5zMtT+5LOwuqx+Ln24sXKhyY1fkZ4ODyCAqHx8oZGhiaVxdtQhrdXmfWG1/SenshctrzKDsqaoCAEX3cdggcOQGDvPg538V1eMFJw6hROjr1Dnb/Anj3QYN48aKycLUHkVgGDkVzcL1q0SA2v6g7YwlBLdFrg69HAsdVA3WbAQ38BfgzQqPrk7vagnwZVmjpUNse+LD9PPzQMaYjGIY3RKKQRmoQ2UY/1g+pjzOIxVXbsXTJyCS7kX1AtFeeyzqkRheRRFlknF/pavfX7SQX7BKNeYD21SOuGLMbnUucpa6dUuY9PB32KrjFd4U7M7SArQYNcUMsFaMmgwFSWR8cZT6TWNPjvJwjq1QvOJnffPpy8Zxz0OTkIGTIEsW++AY2HWaPOEzk1m3Z6Xr36cm4rkdX8NdMQLHgHALd9zWDBzVgrdUU66J7KOIUjl45gzZk1VU4gZrzYl3QhCQoahxoCA1UOaYzowOhy04XM7djr4+WDGC/DBXvn6M7lpj3JBbwED8agQh73pezD8YzjVR6vnCfZb72geqUChEDvwErPtQQzVQU7sm93U9nd/1LblRmIw5p8mjWDd/04ePj6QePnW/zoBw+/4ufyKBOT+fmqR+O6/GPHkDzTMCZ9ZaKnvwi/li2hL5TAptAU4OgLC4vXlVgvzwsLkbt/PzKLx9uvjPbiJTgj/7ZtUf/dd3H60UeRsWSJSp+Kmja12ql4RK7I7jM9E+HQ78DaNw0nYth7QHQ8T4oDslU+enX6GEhd5G69BAZHLh7B0UtHcfjSYZVOJBfhlni116u4ufnNFtfbGh17vTy8DOlIQbHoist382UCuPt+v6/K9z/e8XGLWwHkO3OFUYxsQZtlXjpX9HPPwr9dO8BTUnc8Dek8np6G1B5JVSpRVq95eSFnxw6cvrfq7zTmxRerNbyn9Be48NnnFY8GVJxOFTZmTLWGJjUnYJA0H2cV1Kc3Yme8hnNPT8WFL76AV1Qkwu+/397VInIYDBgqwGFVa8mF48CiBw3lbg8B7W6trU8mO4/WU1kfA7n7Levf6vsWWke0NgQEFw+rRwkSjqUfU3MElCfAKwDN6zRHiE8I1p8zzDZaGblYry45dhmC1NqBlOzDlq0Azj6KkbXpcnOR8v4HuPDZZ5VvaLzoHjvW4ovuwG7dKh/es3jf1R3es9LRgGw9NGkN6+4oQocPR1FKKpLffBPJb76l+nvUKR6hkcgd5kxxmonbHBH7MNhQYa5hcrbEfUD9rsC4pYAXO5u5ywRlBUUFuHHRjZWOOFRZHwNfT180DW2qgoNmdZqhRVgL9ShpOZJGZOzD4KwTiBnPuyivFcAaE8M54yhG1iZ3z8+/+AIKT55Sz/27dEHu9u0VXnRbZZQkYeV923rY1tqou6NIev0NQ/Do6YkG//chgq691t5VIheUYeM5U+ze6dndMGCwof+NB3Z9DQREAA+vBULjbPlpLs8WF3/mdBwO9QnF+A7jkafNQ05RDnIKc5BblGsqy2NuoeG5Wl+8rqIWgrLk4l8CgxZ1DAFB87DmKkiQjsdVHV9tXHTXdsuOjKDkjq0A1qbNzETyW2/j0g8/mP5Qx7w0XY3y46zzMNhlaNJavsCpDTLC1bmp05Dx22/Q+Puj0eefwb99e3tXi1xIhg2HWHaogOHSpUvYunUrkpOT1URqJd19991wJQwYbGTHF8BvTwDSofSun4Gm18EdOFI/gLLkV4EM42nsgCvLrqRdWHt2LexpRu8ZGNZsmNtedLMVwPoyV69G4kv/MXVervOv2xA1eTI8S8wv5KwzPduaM9fdEvqCApx+9DFkb9ighrtt9O238G1qGF6eLDyXbvIz4yhzpjhMwPDbb7/hjjvuUBOuyc5LjiIg5QsXKh433JlwHgYbOrcL+O8gQO4wD3gR6PMU3EFt9wMo7y56RkEGzmZeHuLTFBzIuuxzqgWgOtqEt0HTOk3h7+Wv+hD4exseA7wDDM9lfXHZuP7ghYOYsHpCrQzvyYtuEkUXLiDptRlqJBzh3agh6r3yiupfQFSWLjtbDbeat38/vGNj0ei77+AdHcUT5SYtatbctzY9HflHjiD/8BFkrV+PrD/+qPI9MpFgdQZAcJiA4aqrrsJNN92EGTNmICAgAK6OLQxWlnMBmN8XSD8FtLwJuO0bwA3Gu7ZpP4Cfb1R5+hWRXP8mIU1wNvtslZN6SX2iAqIMsxIHxckK/Hb0N5tc1Dt7HwNyHvJnLmPJUiS99pqaoEt+59S9dxwiH38cHv7+9q4eObCitDScGDtW9XHxbdkSjb7+Cp7BwfaullOojbQbR0sf1GZkmAIDeSw4aiibO2RzSbFvvYXQoUPgtAFDYGAg9u3bh6ZNm8IdMGCwIklf+3YMcGQlENbEMDmbfx24OnP6AcgEYX3r91XzCBToClCoNTwWaAsuPy8uy6PaTltQrUm/6vrVNQUEagmOQ1yg4VE6DPt4+tTaRb2z9zEgx1eYmKjSj7L++ks9973qKtR77TX4t21j76qRkyg4cwYnbr8d2pRUBHTtigaffAwPX197VwvunnZjy4Ckqn3Xe30WfBo0MAQFJQKEouSKb955xdaDb/Pm8AgMMmuYYqdvYRg1ahT+9a9/YcyYMXAHDBis6K9ZhgnavPyBB1YCMW3hDswdU9+WxsWPU3MNyBCikg7kSBf1zt7HgBy34+qlHxeqITJ1WVlqXoSIxx5VY+trfDgaG1km7++/cfLOu1SaUvD11yNuzjtunYdvrVnTPcLrwissDB4BgfAIDDA8BgSULqvnpdfLZIZnHn8c2tTUCvftFR2FxgsXqr9UEsBAZmOXG5flPZZ4XSYrPPvkRENrZDV4xcSowEAtLQyPPs2awzMosHQwVcUwxY7Wh8HieRiGDBmCKVOmICEhAW3btoW3t3ep14cPH255jcn1Hf7DEDCIoe+4TbAgpIOzOYY3G472ke3VHX4fDx/Do6cPvD28S63z9vQ2lQ+kHsATq5+oct/XNrhWjS7kiGP222ouA3JfBSdP4vwLLyJn61b1XEa4qffaq+oPN1F1+LVqhfpz5+L0gw8ic+VKJL76qppkj7NB12w2dF3aBRSk2abva1FSMo70sd2QuB516sA/Pl4FBT7GAKF58ypT1mw5Z4otWdzC4FFJvrn8w9FKlOYC2Om5BnRa4ORGICsJCIoGQuKAT/oDuReBLvcZAgY3Ym4Lg6P3A2DHYXIk5XVGFBe++BIp770HfV6eGhIzauKTCLvjDof740vOKWP5cpydOEld5EU88W9EPvaYvavkUOSSMmv1ajW4QOHZs1VuH/3SdPg2bgJdTo5qvVGPasmGLrv4Ub12uazPyUFhSip0ly6ZVym5bpVZ16t6VLO0e0CXkwutGX0OYmvYx8ARhinmPAx2OpkEIOFXYPlUIOPc5dPh4Q3oCoHYTsB9ywEv98r9zMjPwLU/XFthfwP2AyCq+R9amZVX0hYKTxkmYAvocQ3qvfyyyjMmsqYLX3+DpFdfVeWYl/+DsFpI0XaGoUmzt25Fyux3kLt7t2FF2bvnVky7MTflqcEXnyOoe3eb7LuhFfoY2Pt7tWlKElGlwcICmYejzC8ICRZEp7vcLljQ6XV4fsPzlQYLQlJ7qtsCYOuUISJHUlFnRG1amloktznmhecROmoU00XIJureeYe6wEubP191qPcKD0fwgAE2O9uOcCe6MrkHDiDlnTnIXr9ePZeWvbp33QWfpk1w/plnDRtZOe1GLqzlHFTVDyCwSxeb7TuguFWzJuT4bd2x2W4pSS+//HKlr7/44otwJWxhsCANaU6b0i0LZUlq0pP7ADfKTX9/1/v4aO9Hqs/BYx0ew3cHv7NZ516mDBHcfeQVuZCKikLz1X863N1Xci1y6XT++eeR/tMiaHx90fDT/8K/Qwer3y12lBmBy5N/7LhK/8tcvtywwstLtbZEPPqIOv7aGPZUnZsKAhKrjJJkg307EpumJHXs2LHU88LCQhw/fhxeXl5o1qwZdu7cCVfCgMFMx9cBXwytert7FgNN+sAdLD++HFPWTlHl13q/pjo186KeqPpqM1WAqCr6oiKc+fcTKmdf7qrLKD7SymWtC2NHmhG47FDFqXPn4tKin9XIQlKPkGFDEfnvf5ebAmjLtBtHm4fB2dg0JWnXrl3lfuC4ceMwcuRIS3dHrkI6OFtzOyeXkJaAFza8oMrjWo9TwYKQtKOazlpM5K5y9+41a7vqTJJEZCmNlxfiZr+N4yNHoeDECWhzc0v/HCYlGe5SV3E3WobyVB1+MzOhzcyCLjtLlXN27a60NU3ufMvrcjFeGwFy0cWLSPvoY1z85hvoCwrUuqB+/RD55JPwa3mVXdJu5LxKOpgtAhJb7tsZWaUPg0Ql//nPfzBs2DDcdddd1tglORsZDcma2zmx1NxUPPHnE8jT5qFXXC882am4WZOIqp36kPrBB8hYutSs7Y3pEES2JnN6yMg95SpO4Dj3zLPIWrvOEAhkFQcGWZmmsgQLNXHhyy+hy8qEX5u28I6OqtY+KmsF0GZl48IXn+PCp5+Z6hrQpQsiJ01CQKfSWSf2YMuAxJn6GNia1To9S3OGLK6i5LCqZIZGPYGQ2Er6MGgMr8t2LkxmX564eqLqp9A4pDHeuPYNzidAVN1/T2fOIvXDD5H+yy+GmeLlN4mfL/R5+eW/wYqdEYnMoS6yK5ndV+izs5G+cGGV+5LJBT2Cg+ERHATPwCDVTyL/77+rfF/WqlVqMfbh8WvXFv5t2sKvbRv4t2kDz9DQaqXeRD09RU2MljpvPrQXDHMl+LZqhahJExHYuzcHFXAzFvdheO+9967s+HP+PL766iv07dsX3377LVwJ+zBYYP8iYOG95bxg6CSEMV8C8a47sZ/8W5i+cTp+PvIzgr2D8e2Qb9E4tLG9q0XkdAqTkpA6bx4uLfxJOspdTn2Y8AQKTp1yi86I5BzSFy/BucmTq9wueNAgBHTuDI+gIENAIIFBULCa/dcQJATDo8wM5FXOCCyjloeEIGjgAOTvP4D8I0dMgXVJPo0awa9tW/i3baMeZRI6D3//yjtVl7MP+fcXPHiwYd4Ccgk27cPwzjvvXDGRW2RkJO655x4888wzlteWXEdyguFR4yFJmZfXS8vC4FkuHSyIbw9+q4IFD40H3uz7JoMFIgsVpaUZcqS/+86UIx3Ys6e6UJHZmoXf1VernPAr7ohGR7tUZ0RyDuamv4WNHWtxaos5MwLXe/UV08+8pEblJSQgd99+5O3bh9z9+9W8JDLzuSwZixcb3uvpCd8WLeDXpjUyV6ysPFjw8ED0Cy8g7JbRqgWE3JfFLQyVyc3NhX9x1Ooq2MJgpnO7gY/7yy0R4JbPgcCIyzM9SxqSiw+luvHcRjz6x6Nq3oXJXSbjntZVj+RCRAba9HSk/fdTXPj6azWLq/Dv3FkFCoHdujnkhEdEZrUCWGEko5qM1iMdlfP2H0De/n3I3StBxD5oU1It+nyOOua6an3itvz8fJXv/8YbbyCxsh795JqKCoBfHjMEC61HAm3ca7SskxknMWXNFBUsyGhId8fL5HVEVBVtVpbqsHnhs89V508hKROREyYgsFfPSnOk2RmRHIE5rQA1maCspqP1eIWFIahPb7UIuUcswY2MOJb+8y9qSNiqcNQxUj9LlgQFL730ElauXAkfHx88/fTTGDFiBD799FM8//zz8PT0xMSJE3lW3dG6t4DkA0BAOHDTW3AnmQWZakSkjIIMtItshxd7vMiOYERVtALocnNx8dtvkfbxJ9BeuqS29b3qKtWiENS/P/8NkVNRd/ltnCZnrQBZgnDvmBi1eIbWMStg4KhjpH4OzD0NMoPz/PnzMXDgQGzcuBG33nor7r33XmzevBmzZ89WzyVoIDdzfg+w7m1DecjbhlQkNyGTsE1bNw3H0o8hKiAKc66bA19PX3tXi8ghlJtGER2NwD59kLXmL1NahE+TJoj89+PsTElOzRnH7Jf6SWpTVelUHHWMLAoYfvzxR3z55ZcYPnw49u/fj3bt2qGoqAh79uzh3SB3T0XSFQHxNxvSkdzI+7vex9oza1WQ8F6/9xAZwLHfiSobeUUuTIzDS3rHxSHi8ccROmyomgCLyNk5W5pcbaRTkeswe2ysM2fOoHNnw9jWbdq0ga+vr0pBqizH1JlJn4z4+Hh07cpZeSskLQtJ+4tTkYpbGdzEkmNL8N/9/1Xll3u+jNYRre1dJSKHSUOSloXKRl6RoSCbLv4NdUaOYLBAZOeWERmKWFoSSpLnHKKYSjL7to5MYCZ9F0xv9PJCUFAQXNX48ePVYuxBTmWc32vouyCk30KQ+9xd35+6X823IB5o+wBuanqTvatEZHfajAzk7tuHjKXLSqUhlUcn2+7d51R3Y4lclTOmU5EDBwzSs37cuHGqZUHk5eXhkUceQWBgYKntFi1aZP1akmPRFl5ORWo13K1SkVJyUjDhzwnI1+bjuvrX4d8d/23vKhFVW3WHJpU5EvL+OYTcvXuQJ0M17t2LguPHLfpsjrxC5DicLZ2KHDhgkInZSrrzzjttUR9ymlSkfYB/XUNHZxdNSytLgoQnVz+J5NxkNAtthpl9ZqpJ2oickblju8vNosLTp5G7Zy9y9+1F3p69yPv7b9PEaiV5N2ig+ibkbN5c5edz5BUiIhcMGD777DPb1oScQ+I+YO2bhvJNbwJBUXAHctH0n43/wd7UvQjxCcH7/d9HkI/rpuSR+3ZKPvvEBOQ9+gg0nl6mFgTj0KcleYaGwq9dO/i3bQv/9u3U/AledeuaPZEVR14hInIeHJqCLExFerQ4FWkY0Ga025y9LxO+xG/HfoOnxhNvX/c2GoQ0sHeViKzfKbl4Xdr/zSu1WuPtDd/4VvBv204FBxIkeDdqVO6gFxx5hYjI9TBgIPOtf8fQwuAfBgyZ7TapSOvPrsfsHbNVeUrXKbim3jX2rhJRtWVv2lRlp2QR0LMHgvsPUAGCb8uW8Cgx6IUjTGRFRES1hwEDmSdxP7DmjRKjIkW57GRsO5N3qs7NMq9CmF8Ynl7zNHR6HUa3GI2xV4+1dxWJLFaYlIystWuQ9dcaZK1da9Z76owajdChQ6p9tjnyChGR62DAQBakIhUCVw912VSkP07+gVlbZyEpJ8m0TlKQtHotOkV1wnPdn3PZeUeo9kcasiW9Toe8AwnI+usvteQdOGDxPqzRKZkjrxARuQYGDFS19XOAxL0unYokwcKkvyZBj9J53RIsiBHNR8Db09tOtSNnH2moNgISXXa2SjfKlCBhzRpoU1Ivv6jRwK9dWwRfdx0C+/TBmccfR1FSMjslExGRWTR6Gf6FKmScuC09PR0hISHud6aSDgDz+xpaF0Z9ArS7Fa6YhjTop0GlWhbKigmIwfLRy+HpwYlsqPKRhowBtTVmSa0qICk4cwZZqw0BQs6WLdAXFpq28wgIQGDv3gi67joEXdsHXhERV9ZdlKy/FetORESuc43LFgYyLxWp5RCg7S0uebakz0JlwYJIzElU23WN6Vpr9SLnHmkocfpL8AwLg2dQkLp4l0XjL4/+0Hh4VH/o08RENfRpUkw0ihKTrpgHIajfdaolwb9Llwo7KrNTMhERWYIBQwXmzp2rFq3WkJLiljbMAc7vAfzqAEMdJxWpbMdk6V9gyZ3/9Px0JKQl4EDaAfW4LXGbWe+TzyMSKkWoipGGtBcv4tRdd5f7msbfHx6yFAcShsUfGmNg4euHjCVLyg9IiqlgwcMDAZ07G1oR+l0HnyZNzO5nw07JRERkLqYkVcFtU5KSEoD51xpaF0Z+BLS/DY7aMTk6IBrTuk3DwEYDr9g+qyALf1/4GwdSD6gAQZbTmaer9dmfDvqULQxuTjI48/btQ9JbbyF3a9WBpmdEuAq09Tm50OXkVBoAVEf9D+ciuH9/q+6TiIjcQwZTkqhGtEUlUpFuAtqNqdUWAEs7JifnJKv1M/vMRL3AeqbAQIKEExknyt1Xg+AGaB3eWi2twlvh2XXPIiU35Yp9Cw00KiiR4yD3pM3KQsZvv+High+R//ffZr8v7u3ZCOzezRRs6PPyVOCgy82FLjsHupxs6KUs69RiKOfu3o3MFSuq3L9sT0REZGtMSaIrbXwXOL8b8AsFhr5jUSqSpS0AlgQhst/yLuiN66atm1bueyWIaBPRBvHh8SpAkMdQ39BS2zzT/RkVdEhwUPIz5LmY2m0qOzy7odx9+3FpwQ9IX7IUemkhkJ8JHx8EDboBORs2qrSjclsNNBo1SZmMaHR5lcaUilSV7C1bzQoYrDH0KRERUVUYMNCVqUh/zTKUb3wDCI6xWgvA7Otmm4IGmQgtsyATGQUZhiU/44rnJcvns89X2TFZ1PGpgw7RHUytBxIchPuHV/k+qZfUr7xgR4KFmgQ75Fy0WdnIWLwYlxYsQF5Cgmm9T9OmqDPmVoTefDO8wsIud0qWgLqckYZkJKPqzscggYaMhlSUlMShT4mIyO7Yh6EKbtWHQVKR/jsQOLcLuGowcPv3ZrcumDM0qZfGC1EBUcgszFR9C8prLaip1/u8jpua3lTt99sqnYrsy5y5DHIPHMClHxaoYEH1N5BfkN7eCB40CGG3jVGjDpXtUGzLeRg49CkREdkS+zBQ9S6MN75nCBZUKtKcSoMFyceWloN/Lv6DQxcPYdPZTVW2ABTpi3Au+1ypdf5e/gj2DkaIbwhCfIqXEuVgH8NrSdlJeG/Xe1UelxxLTUhwwKFTXUtlF/VBvXohfckSXFrwI/L27ze97tO4MercdhtCRxhaE+wx0hCHPiUiIkfBFgY3bGEot5+BXzimnT6CgVmZwIh5QIfbTa/la/Nx9NJR/HPBEBzIIoGCDE9qqcfaP4ZBTQaZAgIfz/LHia+oBUOClMo6JnNyNedk7mzGVptcrZjG1xf6/HzDE29vhFx/vQoUArp1NXt4Umc9N0RE5N4yOEoSWdzPIDcNkyLq4MXoVoiOiMM/+z7BoQuG4EBGGtLqr5yPwlPjicYhjXFV2FUI8A7AT4d/qvLEd4npgqahTat15186TrNjsuuxVVpPpZOrGbfJz4d3w4YIk9aEkSPgVbcuHI0EB8aRloiIiOyBLQxu1MJQZT8DubCq4K6qjCrUMqylCg5kaVm3JZrVaQZfT99abQEor3UkJiCGHZOdVIUtAMU/h3HvzqkwaJC0OBmaVHshDUWpaabHogtp0KZdQN6hQ8jdVvVcCQ2++BxB3btb54CIiIicBFsYqFzSZ6HSfgbFF2mxgbFoH9keV9W9yhQkSGflylI0aqsFQEYr6tegHzsmu4BKWwCK151/cToKz56F9uIlFKWlqkCgKE0CAgkMLqh5DWpKm5Ja430QERG5Mg6r6gbOZJ7B7yd+x4J/Fpi1/YROE6o10lBtDU3KjsmuQeXll0hDKo/u0iUkv/5GpdvI3AZe4eHwDK8Lr/AIeIXXhWfdcOiysnDxm2+qrAfnMiAiIqocAwYXlZidqIKE5ceXY3/a5dFfzBHpV/08brYAkDl0+fnI/OMPs7b179Aefm3awisiHJ51JSgILw4QDI8eAQEVtmBkrlrFuQyIiIhqyC0ChsaNG6v+Bx4eHggLC8Pq1avhimSI1BUnV6ggYXfKbtN6D40HukZ3xfVBTTD/4NdI9fSEvpz0Io1ej2itFp3yikeNqSa2AFCFo/1s2YL0xUvULMbSAmCOyImTqtXpVzoLS8dpW02uRkRE5C7cImAQGzduRFBQEJyFuROIpeWmqY7Ay08sx46kHaa+A9JvoFN0JwxqPAjXN7oeEf4RwL6FCE+7iElRESo4KBk0yHMxNe0iPLNTavFIyZVJx+S8/QeQsfg3pC9dWqq/gGdMDPSZmdBlZ5f/Zo0GXtHRahjR6uJcBkRERDXnNgGD08+TEBCtOhVLys+lvEtYdWqVChK2Jm6FTq8zbSedlQc3HqyChOjA6NI7DorGwJxczE5OxazwMCR5Xf76pWVBggV5XbYjqsl8AAUnTqiWBJk1WcpGnqGhCB48GKHDhsK/UyeVlqRaANQH2KYFwJaTqxEREbkDuw+runbtWrz55pvYsWMHzp8/j59//hkjRowotc3cuXPVNomJiWjfvj3ef/99dOtmfopCkyZNULduXZWS9OSTT+KOO+5w2GFVK5onwejqulfjyMUjatZko9bhrVWQcEPjGxAbFFvxznVaYE4bIOMcZFaFnX6+SPH0RGRxGpKnjGYUEgs8uQ+o4WhG5H5zJcjFeMayZUj/bTHy9u0zbafx80Nw/34IGToMQb17QePjUyvzMBAREZGLDKuanZ2tgoD77rsPo0aNuuL1H374AZMmTcK8efPQvXt3zJkzB4MGDcI///yDqKgotU2HDh1QVHT5AtpoxYoViI2Nxfr16xEXF6cCkoEDB6Jt27Zo164dHDENSVoWKgoWxMELB9WjDHc6uMlgDGo0CA1CGpj3ARIEXPcc8Ot4SDjQtVRfheL0pMGzGCw4qdqeLbkoKQlnn5iA7LFjUXjiBLI3bwZ0xa1dMtlYz54IHToEQQMGwjMosML9swWAiIjIsdm9haEkGee/bAuDBAldu3bFBx98oJ7rdDo0aNAA//73vzFt2jSLP2PKlClo3bo1xo0bV+7r+fn5aikZfcnnpaamIjw83BSYeHl5obCwUNW5bLmgoACenp5qKVuW16WlQz7D29u7VHlH8g7c9/t9VR7DS91fwuirR6tzIZ/r6+urylI3Hx8faLVatZQty+uaVf+B56b3oPfwhkZXaNqnPiQOmsGzUNjiRqsek7Esny9k+5JlY91LHoelxyQ/wvJZZcu2+p4c8Ziy/1iFlNdfL3WX3jM6GlHPTEOdwYOrfUwShBwZMBDapErm7yjBr317BN04GGFDh0ITFsbvyQ1+9nhM/J74s8d/T/wd4emUv8szMzPVta05LQwecGBy0iRVSVoFjOQky/NNmzaZ3YIhJ0RkZWXhzz//VAFDRWbOnKmaZ4yLBAti5cqV6nHVqlVqEcuWLVOtF+KXX37BtuJZZRcsWIA9e/ao8ldffYWDBw2tAp988gmOHTtmSrM6e/asKs+ePVsFJNLB2Rwrlq9Qj/J+2Y+Q/cr+hXyefK6Qekh9xK4Nq6DbMl+V97eajA0tngVG/xdb46djRfzbQPxwqx+TmDVrlvoO5PuUsjzKcykL2U62r84xSf2knkLqLfW39fdUk2M6evgwFr70ksrvP7hwIb764osaH9Ofr83AuYkTr5jTQFoAzj05UbUQmHVMM2ciPSkJ2SdOYN7TT+PSX3/h7OzZZgUL51q1QrMVvyPnxRfwq1YLr4gIp/6eXPFnj8fE74k/e/z3xN8R/F2+qsTfJ3OvpR2+heHcuXMqlUhGOOrRo4dpu6effhpr1qzBli1bqtyn/JEcOXKkKkvk9eCDD2LChAkVbu8MLQzz+s1Dr4a9LI44dX+8DI/1bwMxbVF0/2qV+MS7h7V3lzd/zRokvTbDMC9AiVaAmOeeReCAAdW6y+up0eBw/wGVXtTLfAUR01+EJjsbukvpKEhLhT4jE7r0dBSmpUGXkaEmSCu6eBEovNzqZImoWbMQPuJm3rnm3Xi2mjjQ3UO2BDnHXV5+T/yenKGFweUDhpqqzU7P0odh0E+DkJyTXG4/BhkqVUZLWj56eblDrFYq9xIwpy2QnwGM+Uq1JlDtqagfgHE0oLh355jVwVeXk6P6KBiXnO3bcfGbb61aV+mU7Fmnjlogf1CL735XpuEXX1RrrgQiIiKyD6fq9FyZiIgIdbcqqczdU3keExNj08+WZnxZJFqrLRIEyNCpMkqSBAclgwZ5LqZ2m2p5sCAkFUmChah44Oqh1qw2VUH6AcgoQFcEC+pFvQoapOXBp1EjaC9cuBwQJF8ODIxLhXMWVMG7fn21fxUIhIWZAgLDc8OjV/FzTUCACt6NdZc+DKpVpLz6W2GuBCIiInJsDh0wSLNK586dVb6VsdVBmmLk+eOPP27Tzx4/frxajNFXbZF5FmZfN7vceRgkWJDXLZaXAWw25DHj2snqrjHVHjVyUZn+BaXo9eqC/PjNpYcTrojG31+NgiQLPD2Qu9WQF1+Zeq+9xtmSiYiIyDkDBumIfOTIEdPz48ePY/fu3WrehIYNG6ohVe+55x506dJFzb0gw6pKR+Z7770XrkqCgn4N+pk107NZtn0M5KUDEVcB8eZdlJL1SMuAuYGAd2ysKRgod4mKhEdgYK22AHC2ZCIiIvdm94Bh+/bt6Nevn+m5BAhCgoTPP/8ct912G1JSUvDiiy+qidtkzoXly5cjOtq1ZyOW4KBrTNea7yg/C9hoGJIWfaR1gROy1TbVEmCGBvPmWdwKIPMsyARnqn+EBBGcLZmIiIiszKE6PTuSkn0YDh06VGszPVvdhveAlS8AdZsC47cBnnaPEd2OqRWgorSk4laA5qv+qPZEa5wtmYiIiGzV6ZkBgxVPpsMpyAHebQdkpwA3fwh0vMPeNXJbF7//Hokv/efKFywcJckeMz0TERGR63GZUZKohnZ+YQgW6jQE2o3h6bSj7M1bTEOW6gsKTOulZUFSimoaLKh9e3pyaFMiIiKyOgYMDjSsqlUV5gHr5xjKfZ4CPL3tXSO3lb1lKzKXL1ejUzX6/jvoMrPYCkBEREROgwGDgw2rajW7vgKyEoGQ+kD7sfaujZvPwTBDlevcNgb+8fH2rhIRERGRRTggvysqygfWv2Mo934S8DJMN06179KPPyL/n3/gERqKyCee4FdARERETocBgyva/S2QcRYIrgd0vMvetXFb2vR0pMx5V5UjH38cXmFh9q4SERERkcUYMLgabSGwfrah3GsC4O1n7xq5rZQP5kJ76RJ8WzRH2O3/snd1iIiIiKqFAUMFpMNzfHw8una1wuRptWnvD8ClU0BgFNDpHnvXxm3lHzmCi99+q8rRzzwDjRe7CxEREZFzYsBQAenwnJCQgG3btsFpaIuAtW8Zyj3/DfgE2LtGbknmQkyaMRPQahE0cAACe/a0d5WIiIiIqo0BgyvZ/xNw8TgQEA50uc/etXFbWatXI3vjRmi8vRH99NP2rg4RERFRjTBgcBU6LbD2TUO5x+OAb5C9a+SWdAUFSJr1uirXvfde+DRsaO8qEREREdUIAwZXkfALkHYY8KsDdHvQ3rVxWxe++AKFp07BKzIS4Q89ZO/qEBEREdUYAwZX6PSs0wFrjK0L4wHfYHvXyC0VJicj7f/mqXLU5KfgGRRo7yoRERER1RgDBlfo9HxwMZDyN+AbAnTjXW17SZn9DnQ5OfBr3w4hw4bZrR5ERERE1sSAwdnp9cCaNwzl7o8A/nXsXSO3lLtnD9J/+UWVY557DhoP/tMiIiIi18CrGmf3zzIgaR/gEwRc86i9a+OW9DodEl+bocqhI0bAv107e1eJiIiIyGoYMDh768La4tYF6egcUNfeNXJL6b/+iry9e+EREIDISRPtXR0iIiIiq2LA4MyO/AGc2wV4BxiGUqVap83KRvLbb6ty+KOPwDsqit8CERERuRQGDM46SpLqu2AY719N0hYYYe8auaW0+fOhTUmFd8OGqHvPPfauDhEREZHVafR6ufKkimRkZCA0NBTp6ekICQlxnBN1dDXw1QjAyw+YsBcIjrZ3jdxOwcmTODZ0GPSFhaj/4VwE9+9v7yoRERERWf0aly0Mzso4MlLnexks2EnSG2+qYCGwVy8E9etnr2oQERER2RQDBmd0Yj1waiPg6QP0esLetXFLWRs2IGvVKsDTE9HPTINGo7F3lYiIiIhsggGDMzL2Xeh0NxASa+/auB1pVUiaOVOVw+4YC9/mze1dJSIiIiKbYcDgbE5tBo6vBTy8gV5P2rs2bunid9+j4MhReNapg8jx4+1dHSIiIiKbYsDgrH0XOowF6jSwd23cTtHFi0j54ANVjnzySXiGhtq7SkREREQ2xYDBmZzZARxdBWg8gT6T7F0bt5Ty7rvQZWTA9+qrUefWW+xdHSIiIiKbY8DgTPMwGGd1bv8vIKyxvWvjdvIOHsSlBT+qcvSzz0Dj6WnvKhERERHZHAOGCowfPx4JCQnYtm0bHMK53cCh5YDGA+jzlL1r43ZkupKk12YAOh2CBw9GYLdu9q4SERERUa1gwOAs1r5peGxzCxDezN61cTuZv69AzrZt0Pj6InrKZHtXh4iIiKjWMGBwBon7gYOLZWJu4FperNY2XV4ekt8wpIOF338/vOPiar0ORERERPbiZbdPpsrptMDJjUBWErDjM8O61iOByJY8c7Us7dNPUXjuHLxiYhD+4AM8/0RERORWGDA4ooRfgeVTgYxzpdfX72KvGrmtwvPnkfbRx6ocNWUyPPz97V0lIiIiolrFgMERg4UFd0s32ytf+/05ILQBED+8xh+j12qRs30HilJS4BUZiYAunTnqTzmS33ob+rw8+HfpjJCbbqrxeSciIiJyNgwYHC0NSVoWygsWjJZPA64eAnhUf0jPjBUrkDRjJooSE03rJN1GhgoNueEGuHMwUrLu2osXkLFkCaDRIObZZ6HRaOxdPSIiIqJax4DBkUifhbJpSKXogYyzhu2a9Kl2sHB2wpMyTmip9UVJSYb1786pUdBg62DElsqruwi45hr4xcfbrV5ERERE9sRRkhyJdHC25nbl3D2XC+KywYLhRb1aZK4BXVFRjYKRshfcxmBEXndUFdVd5Gza5NB1JyIiIrIltjA4kqBo625Xhkq1KeeCuOzF/T/tO8AzLAyedULhWaeOafEqfvQIDS31XK0LCqo8GNFo1OvBAwbUOD3J2ilPlQZSwop1JyIiInI2DBgcSaOeQEgskHG+gn4MGsPrsl01yAW2WbRaaFNT1WI1er0KVjKWLkXw9dfDw8/PbilPupwcNUxq4dmz6jFn2/bKA6niukuQEtidMzwTERGRe2HAUIG5c+eqRavV1t63IR2ZB79ePEqSpkzQUNzhdvCsand4lrvx5oh9ZzZ8mzSB9tKl0svFMs9lSU9XS4V358s4N+Vp9egREgLv6Ch4RUbBKyoKXtHR8IqKVGVvVY6CV3g4NN7eFve/0GZlGYKBs5eDAsNzQ1l78aJF583igIuIiIjIhWj0ejOv9NxURkYGQkNDkZ6ejpCQEPvNwxASZwgWajCkqqTe/NO1K/Q5ueVvoNGoC/fmq/6wKPVGr9Mha/VfODN+fNUbSwBQWGjejjUaeEaEwzsyCp6RkcjZuhX63ArqLry8oPH3hz4zs8pdewQHqxmb1azNHh7IWrmyyvc0/OILtjAQERGR213jsoXBEUlQIEOnGmd6lj4LkoZUg6FURfpvv1UaLAhJ7bE0T1/j4YGg6/qq1CC5219ua0NxMNLsj5XQ5+SgKDlZLYXymJRc4nkSipJTDHfzi4qgTUlVi1mKikzBgvSrUAFBbOzlx/rFj7Gx8CzxD0MCqSMDBlZZd+krQURERORuGDA4KgkOqjl0anny/v4bidNfUuXgwYORu3t36X4A0dE1GvpUggx5v0oNkuCj5IV3iWDEw8sLCAlRF+y+zZtX2mqhvXDBFFRk/rEK6QsXVlmPqMlPIez22+ERGGj1urPDMxEREbkjBgxuQPoYnHliAvT5+Qi8tg/iZr+tLoqtPbmaCjbenXNlp+RqBCPSauEVEaEWmQPBwz/ArIDBr207i4IFW9SdiIiIyJWwD4Mj9mGwIrlTf+bRx5C1Zo1KzWny00KVrmPTz7TBTM/mpg1Z2v+iNupORERE5GjYh4FMUufNU8GCxtcX9d9/z+bBgpALbGsPP1pbaUO2qDsRERGRM+NMzy4sa906pL7/gSrHTJ+uUnucmaQFxb07R7UklCTPZT3ThoiIiIisj30YXFTBmTM4O3mKuhNf57bbUGfUSLgCCQpkxmWmDRERERHVDgYMLkiXl4ezT0yALj0dfm3bIvq5Z+FKmDZEREREVHuYkuRiZB6+xJdfQV5CAjzDwlD/3Tnw8PGxd7WIiIiIyEkxYHAxl378EemLFqnZi2X4VJmkjIiIiIiouhgwuJDcffuQ9Mqrqhz55JMI7NHD3lUiIiIiIifHgMFFFF28aJicrbAQQQMHIPzBB+xdJSIiIiJyAW4RMBw/fhz9+vVDfHw82rZti+zsbLgSmWzs3FNPoej8efg0aoTYmTOhKZ6bgIiIiIioJtxilKRx48bh1VdfRZ8+fXDhwgX4+vrClaS89z6yN26Cxt8fcTI5W3CwvatERERERC7C5QOGAwcOwNvbWwULom7dunAlmatWIW3+fFWu98or8LvqKntXiYiIiIhciN1TktauXYthw4YhNjZWpdH88ssvV2wzd+5cNG7cGH5+fujevTu2bt1q9v4PHz6MoKAg9RmdOnXCjBkz4CoKTpzAuanTVDns7rsQOnSIvatERERERC7G7i0M0p+gffv2uO+++zBq1KgrXv/hhx8wadIkzJs3TwULc+bMwaBBg/DPP/8gKipKbdOhQwcUFRVd8d4VK1ao9evWrcPu3bvV9oMHD0bXrl1x/fXXw5npcnJw5t9PQJeVBf9OnRA9ZYq9q0RERERELsjuLQw33nij6l8wcuTIcl+fPXs2HnzwQdx7772q07IEDgEBAfj0009N20gwsH///isWabWIi4tDly5d0KBBA9V34aabblLbVyQ/Px8ZGRmlFlFYWKgeJQAxBieyrrxyQUEBtFptuWWdTmf6nIrKMvmaLGXLQrbLy8vD+RenI//wYXhGRCBuzjvQe3qq/Qv5vPLKUr+Sx+FIx1RRmcfE74k/e/z3xN8R/F3Ov0/8m8vriHybXRs5RcBQGTnwHTt2YODAgaZ1Hh4e6vmmTZvM2oe0JiQnJ+PixYvqJEsKVKtWrSrcfubMmQgNDTUtEmiIlStXqsdVq1apRSxbtgzr169XZUml2rZtmyovWLAAe/bsUeWvvvoKBw8eVOVPPvkEx44dM6VZnT171hQUpaamqvKsWbOQmZmpjl3K8ijPpSxku18eehgZixerydk29LgG3lFRar+yfyGfJ58rpB5SHyH1M6Z8Sb2l/o5yTLK9kPfLfgSPid8Tf/b474m/I/i7nH+f+DeX1xFnbXJtZO61tKJ3IFKdn3/+2fT87Nmzat3GjRtLbTdlyhR9t27dzN7v0qVL9W3atNG3bt1aP3HixEq3zcvL06enp5uW06dPqzqkpqaq1wsLC9UiCgoKyi3n5+fri4qKyi1rtVrT51RU1ul0ailbFlnbt+sTWrfRJ7S8Wp/y2Wem9fJ+2b+QzyuvLPWTepZXtucxyXYVlXlM/J74s8d/T/wdwd/l/PvEv7m8jsiz+rVRWlqausaV692qaOR/cBDS6fnnn3/GiBEj1PNz586plKKNGzeiR4lZi59++mmsWbMGW7ZssXmdJCVJWhrS09MREhICeypKScHx0begKDkZITfdiNi33+Z8C0RERERk02tch05JioiIgKenJ5KSkkqtl+cxMTE2/Wxp+pE+E5LS5AhkBuezEyepYMGneTM1hConZyMiIiIiW3PogMHHxwedO3c25VsJ6Ycgz0u2ONjC+PHjkZCQYMrht8fszdlbtiJ98RL1mPTW28jZvh0egYGo/9776pHo/9s7DygpqqyPv4EhZwSGnAWUJDmDEgZQCbIHDEgQVEDioizBMChHGJIkUQQVXHQBXYkiOSoiOMSFJQ3CkmZgJEhSYGbqO/+7W/1193RNV3e9SfD/ndMMFfr2q/ferXo3vFeEEEIIIff9sqo3b95U0dHRru1Tp07JKkZ4wVrp0qVlSdVevXrJSkf169eXZVWxFCtWTbpfub5+vbo4foKKj41NcqxY5ASVrXy5NCkXIYQQQgh58EhzgyEqKko98cQTrm0YCABGwoIFC9Szzz6r4uLi1DvvvKNiY2PlnQtr165VYWFhKZ6ShI+5fGhqGgvnhw7DbHTfJ6SfKSeEEEIIIeQBIF1Nek6PpOakZ6QhRbdq7TOyIISEqNCwMFVx00YVkjlzipaFEEIIIYTcv9w3k54fNG5H7bE2FoBhyHGcRwghhBBCSGpAgyEdgWVTdZ5HCCGEEEKIU2gwpKNlVUMLF9Z6HiGEEEIIIU7hHIb0OIcB753wNbWEcxgIIYQQQogGOIchg4KJzGFjRv9vI8Tr4H+3cZwTngkhhBBCSGrBlKR0Rt7wcFVixnRZDckdbGM/jhNCCCGEEPLAvIchvZJW72EAMArytGr131WT4uJkzkLOunUYWSCEEEIIIakO5zCkozkMhBBCCCGEpAacw0AIIYQQQgjRAucwEEIIIYQQQiyhwUAIIYQQQgixhAZDOnpxGyGEEEIIIekNTnr2Ayc9E0IIIYSQ+w1OeiaEEEIIIYRogSlJhBBCCCGEEEtoMBBCCCGEEEIsocFACCGEEEIIsYQGAyGEEEIIIcQSGgwWcFlVQgghhBBCuKyqX7isKiGEEEIIud/gsqqEEEIIIYQQLYTqEXP/YhiGywojhBBCCCHkfsAc25pj3eSgweCHGzduyN9SpUrpaBtCCCGEEELS1Vg3X758yZ4TYtgxKx5gEhMT1YULF1SePHlUSEhIqlt+MFTOnj2r8ubNm6Hks+ysd/aZjKFP1FXWO/tMxtAn6irrXTcwAWAsFC9eXGXKlPw6SIww+AEVWLJkSZWW4KaTEgZDashn2Vnv7DMZQ5+oq6x39pmMoU/UVda7TvxFFky4rCohhBBCCCHEEhoMhBBCCCGEEEtoMKRjsmXLpiIiIuRvRpPPsrPe2Wcyhj5RV1nv7DMZQ5+oq6z3tISTngkhhBBCCCGWMMJACCGEEEIIsYQGAyGEEEIIIcQSGgyEEEIIIYQQS2gwEEIIIYQQQiyhwZAOGTt2rLxV2v1TpUoVrb9x/vx59eKLL6qHHnpI5ciRQ1WvXl1FRUU5llu2bNkkZcdn4MCBjmUnJCSot99+W5UrV07KXKFCBTVu3Dh5U6Eu8MbDYcOGqTJlyshvNG7cWP3yyy9Bydq+fbvq0KGDvEERdbB8+XKP4yj3O++8o4oVKya/1bp1a3XixAktspcuXarCw8OlfXF8//792sp+7949NXLkSOkzuXLlknN69uwpb0TXUXb0f/R3yC5QoIDUy65du7SU3Zv+/fvLOdOnT9ciu3fv3kn6frt27bSV+8iRI6pjx47yoh3UT7169dSZM2e0yPelt/hMnjzZseybN2+qQYMGyUsw0dcfffRRNWfOHFvltiP/4sWLUvc4njNnTqlzu7o0YcIEqcc8efKoIkWKqM6dO6tjx455nPPnn3/KPQz6lDt3bvWXv/xFflOH7Llz56rHH39cXsaFa7t27ZqtctuRf+XKFTV48GBVuXJlqffSpUurIUOGqN9//11L2fv16yf3YcguXLiw6tSpkzp69KiWsnvfK9u3b+9XnwORjTr37uu4H+gs+86dO1XLli1FV9G+zZs3V3/88Ycj2adPn7bU1W+++UZL2WNjY1WPHj1U0aJFpey1a9dW3377rRbZJ0+eVM8884z0F9RJt27dbOkS+Pjjj1WNGjVcL65r1KiRWrNmjWM9tSN7rgM99SffiZ6mJjQY0ilVq1ZVMTExrs+PP/6oTfbVq1dVkyZNVJYsWaTD/vvf/1ZTp06VwZlTMLh2L/eGDRtkf9euXR3Lnjhxoijdhx9+KAMnbE+aNEnNmjVL6eLll1+WMi9cuFD961//kkE3BqwwsALl1q1bqmbNmmr27Nk+j6PsM2fOlIETBsS4Mbdt21Zuek5l43jTpk2ljoIhOfm3b99We/fuFeMNf2Gc4KGAgaxT2aBSpUrSxqh/9HsYoWiHuLg4LfJNli1bpn7++WcZZNrFjmwMVt11YNGiRVpk40GLNoUxtXXrVnXw4EFpg+zZs2uR715mfD7//HN5MOKh61T28OHD1dq1a9WXX34pugujHAbEypUrHZcdg0kMTH799Ve1YsUKtW/fPjH4obf4nj+2bdsmgwz0Beg+DGL0N/fv/vWvf1WrVq2SARnOh3HcpUsXLbKhT+gzY8aMsVUXgchHOfGZMmWKOnTokFqwYIG0Q9++fbWUvU6dOmr+/PnSpuvWrZO2wDlw7uiQbwKDHn1RV72YvPLKKx59HvdkXfJhLKBdsX/37t3ybESfz5QpkyPZpUqVSqKr7777rgyQYVTpKDscQLinQz9xH0Zfx8AeuuVENv5iG225efNmtWPHDnX37l1xBiQmJvotOxwOkZGRas+ePeLghDEGI/Xw4cOO9NSO7NsO9NSffCd6mqoYJN0RERFh1KxZM8Xkjxw50mjatKmRGgwdOtSoUKGCkZiY6FjWU089ZfTp08djX5cuXYzu3bsbOrh9+7aROXNm47vvvvPYX7t2bePNN990JBuqtmzZMtc26qNo0aLG5MmTXfuuXbtmZMuWzVi0aJEj2e6cOnVKju/bt09b2X2xe/duOe8///mPdtm///67nLdx48aAZCcn/9y5c0aJEiWMQ4cOGWXKlDGmTZumRXavXr2MTp06BSzLjuxnn33WePHFFx3LtpLvDa6jZcuWWmRXrVrVeO+997Tolbf8Y8eOyT60pUlCQoJRuHBhY968eQHLv3Tpksjbtm2bSy+zZMlifPPNN65zjhw5Iufs3LnTkWx3tmzZIseuXr0acJntyDf5+uuvjaxZsxr37t3TLvvAgQNyTnR0dECyk5OPexd0NSYmxla/tSu7RYsW8nzSgS/5DRo0MN56660Uke3NY489luTZ6ER+rly5jL///e8e5xUsWDBgffKWvW7dOiNTpkxyTzeBfoWEhBgbNmwIqvwFChQwPv30U6166i1bt54mJ9+pnqYkjDCkUxBOh+ezfPnyqnv37rbTDuwAr0HdunXF64+wYa1atdS8efOUbuA5gEexT58+AXmHrEB60KZNm9Tx48dl+8CBA+KBtuNVsUN8fLx4xrw9tggR6ozwgFOnTknYF15QE6SZNGjQQDxTGQ2ETtHG+fPn196HEApG3cDDrAN4shBuHzFihETydAPvP/QK4eUBAwaoy5cvaynz6tWrJfqCKBTko6/YSc8IBoTx8Xu6PFzQXdx3EKnDmH/Lli2ix/A2OuXOnTvy111v4cXFS66C0VszDaBgwYLyFx5BeErddRVRHqQNBKqr3rJ1Y0c+zkFKRGhoqFbZ8B4j2oCUUXjBA8WXfHh1X3jhBYksIT0mWKzK/tVXX6lChQqpatWqqdGjR8vv6ZB/6dIliRpDT9H3w8LCVIsWLbT0R2/QP5FyGqyu+pKPMi9ZskRSZXDvWbx4sUS+kZLjRDZ0Fc8J95faQW+hr4HWDZ7VKBf6HdJ7dOqpt2zdJNiQH6yepihpbbGQpHz//fdiXcJbs3btWqNRo0ZG6dKljevXr2upLnix8Rk9erSxd+9e45NPPjGyZ89uLFiwQGtzLFmyRDz258+f1yIPXkNER+CNCA0Nlb/jx483dIK6hucJZY6PjzcWLlwoHpFKlSo5kuvtGduxY4fsu3Dhgsd5Xbt2Nbp16+ZIdmpHGP744w/xFr/wwgvaZK9atUq8XGjj4sWLSwQjGHzJR59p06aNK+qlM8KA6NCKFSuMgwcPyrFHHnnEqFevnvQlJ7JN72rOnDmNDz74QNpzwoQJUj9bt27VUnZ3Jk6cKN4vtK0O2X/++afRs2dPOQbdhefsiy++CFi2L/l3796V+yN058qVK8adO3eMyMhIOS88PDzgewwimU2aNHHt++qrr6S83qBd//a3vzmSrdNz6U8+iIuLk7oaM2aMNtmzZ88WXUXZK1euHFR0wUr+q6++avTt29e1HUyEwUo2nnt4vkJXv/zyS4liPPPMM1rKDo82ygqv/Oeffy7P2WHDhkk/On78uOOyuzNgwAC5zwSDlXz0QeiOqa958+aV6IBT2Yg4QBYiO7du3TJu3rxpDBo0SH4HbW0HtBf6G8YW+fLlM1avXq1NT61k69LTgzbkO9HTlIYGQwYAHRNKZhW6ChSE7TAwdmfw4MFGw4YNDZ3ghvP0009rk4fBWMmSJeUvFA8hU9yQdRo6eNg1b95cbghQatxskPJUpUoVR3LvV4MBg7UOHToYtWrV8ggzO5WNB8mJEyfkwYtQe9myZY2LFy86lh8VFWWEhYV5GLE6DQZvTp48GVQ6lbdslBf7nn/+eY/zUPfPPfec9rJj4IcHeTD4ko3UOxjdK1euFEfIrFmzjNy5cweVhuBLPtoVaZym3rZt29Zo37690a5du4Bk9+/fX/rD2bNntRsMvmTrNBj8yYd+1q9fX+oEeqtLNlJBMAhG2gn6I5wHgRqavuTD8K5YsaJx48YNRwaDv3ox2bRpU1DpVL7km/d3OOXcqV69ujFq1ChtZUcaLQaeU6ZMCajM/uRD99FXcN/av3+/MXbsWPkdPHedyobhUb58eXF2QFeRZok+g/PtAIcAng3QedRloUKFjMOHD2vRUyvZuvT0jg35TvQ0paHBkEGoW7duQDea5IDl6u61AR999JF4cnVx+vRp8cwvX75cm0wYCx9++KHHvnHjxsngRjcYsJqDeQzgn3zySUfyvB905kDSeyAPY2XIkCGOZKeWwYCbWefOnY0aNWoYv/32m1bZ3mDgEEw0yVs+DAPzQWV+cA76Kh5uKVF2PBTmzJnjSDYeNPD0ob+7gwdh48aNA5LtS74727dvl+MYKASDt2wMauCk8J4bhHsQBvZO5XsPXuHFBHjovvbaa7blDhw4UO4xv/76q8+BpPcAAfdRRHucyNY1EPEnH9FpOIlatWoV8GDeTtnd+ymiYP/4xz8cy4cX2kpXEQXWXXbc8yEfUQenZcc2ZCFC7Q6eJXYjsXbKDqcZdMvs84FgJR8Gk/ecIIC+069fP21lhxfd7Otw4kyaNCngazDLheiEDj21kp1Scxhaecl3oqepAecwZACwJCFWSMHymzrACkneS50hnxgri+gCuazI33zqqae0yUR+qfcKE5kzZ7a1ukKgYMUi1DdWlMLqH1jNQCfI80VOLuZkmFy/fl3yXlMiZ1I3yBXFqhmYa7Nx40ZZxi4lQRubuepOwNwFrC6EnF/zg7lCmM+AdtbNuXPnZA6DU93NmjWrLFeY0noLPvvsM1n9RtecEfQVfFJDdzHXBcs1ol9iJRI7egsbBKvXYNUsrNwC3XQHdYEV5dx1Fe2AeWX+dNWfbKfYkY/7CuaKoA9hHondVbWCKfv/nJC2dNWf/FGjRiXRVTBt2jR5vuguuynfjq76k4+V3XBfCUZfAyk7dBWr06HP28WffHMeRzD6GkjZMXcEc95wHuZ82F1lz+rZ4ERP/clOKRLd5Aerp6lKWlssJCmvv/665CXDO4zQZuvWrcVLGYwXwRfIB4e38v3335fwGEJ58Aohj1MHyF2EVY/5BjrBCjTIM4WnEnWzdOlSqZdA0gL8Ae/SmjVrxDOyfv16SXPAahfBhAYRSodnHx+ompl7bq4khDzr/Pnzu3LesSpNuXLlbHkW/Mm+fPmybCNHEscXL14s28iFd1p21EXHjh3FgwQvNGSaH3gYnciGlw9hfKQiIUqF0O1LL70kc268PV7B1o03gaQkJScbx9544w0pO/onwvkItT/88MOSw++03Ojv8CbOnTtX9BZpPfC6/vDDD9rqBeFw3As+/vhjWzLtyoZHGCslwTsH3Zo/f77Mm0JkU4d8zPmCbETuENVEm2IFNTsgBxzpFrjnuvdlREZMkC6Be9rmzZulT8IL6J3WGaxsbONasAINrg0RHmxDh53KR3vi/oVUGHiO3c/xN6/Gn2zUNaJ+qA+0A55VSElCmqid9EE7dRNsVM+fbNQFVu1C2aGruAcjTQYRXjvYKTvuKUglxqo90FesmIQ+7y/lyW69QCYiMHheBYI/+bi/I6LbrFkzY9euXVJepDzht6xy7gMpO+Z04B4JuYjAoL8MHz7cVtmRZYHUN7QZnpnYRrnwrHaip3ZkxzjQU3/ynehpakKDIR2C5ROLFSsm+XgYIGM7mIlkyYFJpdWqVZOBGPLzMQjRBXIUoVBY7lAnCNchTI0bAm68uMFjWUY7g9RAJmpDLuoey54itIo0h2AwQ5feHxg+AJNu3377bQnHoh0QhrRbZ/5kY0Dm6ziW7HUq30xz8vXB95zIhrGEiYdIj0MbQA9gnAQy6dlf3TgxGJKTjYci5u1gOU8M7CH3lVdeMWJjY7WV+7PPPpOHOfo/jNlAUv7syMdE0Bw5cgTc5/3JxoOvd+/e0q4oO9IIp06danu5ZX/yZ8yYIQYs6h33BwzO7N4XrPoydMgE/RLpTZgIDoMKfdSO8W1HNnTS3znByreqN3ygx05kY14N5okUKVJE6h31j3Sbo0eP+i233boJ1mDwJ/vMmTNiHGCwinsvdGrEiBG252HZLTsWJkC9oM9g4GrHuLcrG46VUqVKiYMuEOzIx5wUGNxoW5Qdaafey6wGKxuORDzz0GfgTAnkPoD5bLiv4tmA+yyemeaA3ome2pEd4UBP/cl3oqepSQj+SesoByGEEEIIISR9wjkMhBBCCCGEEEtoMBBCCCGEEEIsocFACCGEEEIIsYQGAyGEEEIIIcQSGgyEEEIIIYQQS2gwEEIIIYQQQiyhwUAIIYQQQgixhAYDIYRkME6fPq1CQkLU/v37VXrh6NGjqmHDhip79uzqscces/29xx9/XA0bNsy1XbZsWTV9+vQ0rYutW7eKzGvXrqm0oHfv3qpz585p8tuEEOILGgyEEBLEgA4DysjISI/9y5cvl/0PIhERESpXrlzq2LFjatOmTUHL+eWXX9Srr75q+/xSpUqpmJgYVa1aNW2D/caNG4vMfPnyqbRgxowZasGCBWny24QQ4gsaDIQQEgTwpE+cOFFdvXr1vqm/u3fvBv3dkydPqqZNm6oyZcqohx56KGg5hQsXVjlz5rR9fubMmVXRokVVaGio0kXWrFlFZmobfwkJCSoxMVEMlfz586fqbxNCSHLQYCCEkCBo3bq1DConTJhgec7YsWOTpOcg3QZpN97pJ+PHj1dhYWEyUHzvvfdUfHy8GjFihCpYsKAqWbKkmj9/vs80IHjDYbzAw75t2zaP44cOHVLt27dXuXPnFtk9evRQv/32m0c60KBBgyQlqFChQqpt27Y+rwODWJQJ5ciWLZtc09q1a13HMbDes2ePnIP/47p9cevWLdWzZ08pT7FixdTUqVOTnOOdkoRrhCGCa3z00UfVxo0b5TcQzfFOScL/n3jiCdlfoEAB2Y/6Bf/85z9V9erVVY4cOcSgQfuhPL7wjlLA2492WbdunXrkkUek/O3atZMohBWmjNWrV6saNWpI+ZGyhTYxMeWuXLlSrg11e+bMmSQpSWinwYMHSzvhutCW8+bNk/K/9NJLKk+ePKpixYpqzZo1AbU/IYTYhQYDIYQEATzbGOTPmjVLnTt3zlEdbt68WV24cEFt375dffDBB5Le8/TTT8vgcNeuXap///6qX79+SX4HBsXrr7+u9u3bpxo1aqQ6dOigLl++LMcw2G3ZsqWqVauWioqKkgH+xYsXVbdu3TxkfPHFF+JR37Fjh5ozZ45ligwG91OmTFEHDx4Uw6Jjx47qxIkTchwD56pVq0pZ8P833njDpxyUF0bNihUr1Pr162VQvXfv3mQ97hg4I+KAepg7d6568803k01P+vbbb+X/SI1CWVB2/H3++edVnz591JEjR+R3u3TpogzDUHa5ffu2XP/ChQulnTCwt7pO72tG3SHVCtETtNG9e/c85CJS9emnn6rDhw+rIkWK+JSDdoJRt3v3bjEeBgwYoLp27SoGI+owPDxcDALIC6T9CSHEFgYhhJCA6NWrl9GpUyf5f8OGDY0+ffrI/5ctW4YRqOu8iIgIo2bNmh7fnTZtmlGmTBkPWdhOSEhw7atcubLRrFkz13Z8fLyRK1cuY9GiRbJ96tQp+Z3IyEjXOffu3TNKlixpTJw4UbbHjRtnhIeHe/z22bNn5XvHjh2T7RYtWhi1atXye73Fixc33n//fY999erVM1577TXXNq4T12vFjRs3jKxZsxpff/21a9/ly5eNHDlyGEOHDnXtQ12gjsCaNWuM0NBQIyYmxnV8w4YNcg2oa/e62Ldvn2xv2bJFtq9ever6zp49e2Tf6dOn/V6rLxnz58+X7ejoaNc5s2fPNsLCwvzKWLx4cZLrXbJkiYfc/fv3W/Yvs52aNm2apD/06NHDtQ91BFk7d+603f6EEGIXRhgIIcQB8A7D+wvPdbDAO58p0//fjpE+gvQZ92gG0mguXbrk8T1EFUyQw1+3bl1XOQ4cOKC2bNki6Sjmp0qVKq75BiZ16tRJtmzXr1+X6EeTJk089mM7kGvGb2KORIMGDVz7kG5VuXJly+8gSoCoAVK/TOrXr68CpWbNmqpVq1ZSp/DKI50n0LkniHJUqFDBtY2UKu/28IV7G5nX615viO4gZckf7ueY/cG9j6DPALNMdtufEELsoG+WGCGEPIA0b95cUnRGjx7typc3gRHgnfbino5ikiVLFo9t5L772oe5BHa5efOmpL/AoPEGg10TrGx0v4MB9oYNG9RPP/0kqVBII0NqE9KcypUrZ0uGr/YIJKXJCsypsDO52l8fMWWYfcRu+xNCiB0YYSCEEIdgedVVq1apnTt3euxHznpsbKzHwFLn+wJ+/vln1/8xSRoTjzEpF9SuXVty4jGJGBNi3T+BGAl58+ZVxYsXlzkO7mAbE3XtAu88BrgYpJvAy3/8+HHL78Abf/bsWcm9N8FcgOSAx96c/+AOBtSIirz77rsy5wPnLVu2TKU07m1kXq/ZRimJrvYnhBBAg4EQQhyC1JDu3burmTNneuzH6jZxcXFq0qRJkgYye/bsJCvZOAHyMOjFSkIDBw6UASkm9gJsX7lyRSb7YpCN38cqP1hVx3swbWfiLjzVS5YskTShUaNGieEzdOhQ2zKQEtO3b1+RhUneWMEHERn3VCxv2rRpI4ZGr169ZLI1jJS33npLjll55bGsK4599913UvfwtMNIwQR1TP7FZOWlS5fKsdQYuGPlKLyXwrxeTFxOjZey6Wx/QgihwUAIIZoGht4pQxiQfvTRRzKwRx49Vrixs7JOIJENfCD7xx9/lOU5MSAFZlQAg0OsoAOjBstyYhnP5AbpvhgyZIgaPny4rIIEOVhxB7/18MMPByRn8uTJqlmzZpIqg2VNsVxqcnMokEqE5VMx6K9Xr556+eWXXaskYZlSX5QoUUKiCDBqkNePZWMRJcHKRk8++aSqVKmSGB1YuQhLjqY0aB8YVrhORJsQiTKjICmJzvYnhJAQzHxmNRBCCMkIYBAMQyM6OtpjEnJ6A0u34p0QiPrwJWyEkIwOJz0TQghJtyDlCulMiGbASIC3HnMR0rOxQAgh9xs0GAghhKRbbty4oUaOHClzD5BuhVQmX2+IJoQQknIwJYkQQgghhBBiCWc+EUIIIYQQQiyhwUAIIYQQQgixhAYDIYQQQgghxBIaDIQQQgghhBBLaDAQQgghhBBCLKHBQAghhBBCCLGEBgMhhBBCCCHEEhoMhBBCCCGEEEtoMBBCCCGEEEKUFf8Hb1RbXauG9YgAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwwAAAINCAYAAACTVPhqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAv9BJREFUeJzs3Qd8U1X7B/BfuncpdFH2EmRvBBRkyBIQVHALoqiv+EdBBcerOAEX4sAXFXHgAhEcLBkiQ/YUqMjeHbSleyf5f54TEtrSkbRJs35fP9ec3NzenHvThvvc85xzNHq9Xg8iIiIiIqJSeJS2koiIiIiIiAEDERERERGViy0MRERERERUJgYMRERERERUJgYMRERERERUJgYMRERERERUJgYMRERERERUJgYMRERERERUJq+yXyKh0+lw4cIFBAcHQ6PR8KQQERERkdOTuZszMjIQExMDD4/y2xAYMFRAgoV69epZ8/MhIiIiInIIZ8+eRd26dcvdhgFDBaRlwXgyQ0JCrPfpEBERERHZSXp6uropbrzWLQ8DhgoY05AkWGDAQERERESuxJyUe3Z6JiIiIiKiMjFgICIiIiKiMjFgICIiIiKiMrEPAxEREZGdhrUsLCyEVqvl+Seb8Pb2hqenZ5X3w4CBiIiIqJrl5+cjLi4O2dnZPPdk0w7NMmRqUFBQlfbDgKEMc+bMUQujfiIiIrL2pLAnT55Ud35l0iwfHx9ODks2acG6ePEizp07h2bNmlWppUGjl71RuWPUhoaGIi0tjcOqEhERUZXl5uaqgKFBgwYICAjgGSWbycnJwalTp9CoUSP4+flV+hqXnZ6JiIiI7MDDg5dhZP85FszB31QiIiIiIioTAwYiIiIiIioTAwYiIiIiJ6XV6bH1eDJ+2XdePcpzW7rxxhvx5JNP2mz/km8vaTT79u2DIzpVjfVr2LAhZs+eDUfAUZKIiIiInNCqg3F45bdYxKXlmtbVDvXDtGEtMah1bZu855IlS9TY/rZSr149NdxseHg4HFE9B6+frbCFgYiIiMgJg4X/fLOnWLAg4tNy1Xp53RZq1qyJ4OBgm81NIUN/RkdHw8vLMe9pezp4/WyFAQM5nepufiUiIrI1GeU+O7/QrCUjtwDTfj2E0v71M657+ddYtZ05+7NkhP2iKUkff/yxGt9fhuuMiorC7bffXmy7xx9/XC0ydKfckX/xxReLvZek3Lz22mu4//771bCeDz/88FUpP3/++ad6/vvvv6NDhw7w9/dH3759kZiYiJUrV+Laa69VP3v33XcXmwRP5rqYMWOGGk5UfqZdu3ZYvHixWcd46dIl3HPPPYiIiFA/26xZM3zxxRfqNWvVz5zzU1JqaioeeughVS/Zp7zP/v37UR3cKzwip2eP5lciIiJbyynQouVLv1tlX3LJGZ+eizYvrzZr+9hXByLAx7JLwl27dmHixIlYsGABevTogZSUFGzatKnYNl999RUefPBB7NixQ20vAUH9+vUxfvx40zbvvPMOXnrpJUybNq3c93v55Zfx0UcfqXkrRo8erRZfX1989913yMzMxMiRI/Hhhx9i6tSpansJFr755hvMnTtXXfBv3LgR9957r7rY7t27d7nvJRfusbGx6oJfLuSPHTum5jOwZv3MPT9FjRo1SgUkUi8JMj755BP069cPR44cUS0/tsSAgZyu+bVk7G1sfv3fvR0ZNBAREVWDM2fOIDAwEEOHDlUpSjIJndxhL5nv/95776k78M2bN8eBAwfU86IXxHKX/KmnnjI9lzv4pXn99dfRs2dPVZaL7Oeeew7Hjx9H48aN1Tpp3Vi/fr26IM/Ly8P06dOxdu1adO/eXb0u223evFldZFcUMMixybF07tzZ1BJSEUvqZ8n5MZK6S2AhLRcSiBiDrZ9//lm1nEiwYUsMGMowZ84ctWi1Wpt+AGQeSTuSloWyml9lWhJ5/aaW0fD0sM4kJUQuT6cFTm8BMhOAoCigQQ/Aw9PetSJyS/7enupOvzl2nEzB2C92Vrjdlw90QddGNc16b0vddNNNKkiQC+JBgwapRe6iF525+rrrris2cZhcvL/77rvq2kr6AgjjRXlF2rZtaypL+pO8j/Fi3LhOLqiFtAhI+o/UsWQfiZJBTWn+85//4LbbbsOePXswYMAAjBgxQrWiWKt+lpwfI0k9kpaKWrVqFVsvLR8SmNgaA4YyTJgwQS3GabPJvuTLsWTHrpJBg7wu23VvUvyPiYhKEfsrsGoqkH7hyrqQGGDQm0DL4TxlRNVMLhzNTQu6oVmESseVFvbSbqTJJWh0qJ/azlY30aRVQS6oJYd/9erVKq1I0nJ27tyJGjVqmL0faaUwR9GRmeRclRypSdZJvwUhF9Zi+fLlqFOnTrHtjHfnyzN48GCcPn0aK1aswJo1a1Taj1wTyh19a9SvMuSYateurc53SZac78pip2dyCokZuVbdjsitSbCw6P7iwYJIjzOsl9eJyGFJECB990TJcMD4XF63dYu7jBTUv39/vPXWW/j7779VOtEff/xhen379u3Ftt+2bZvqT1Dy7rm1tWzZUgUGklrUtGnTYoukAZlD+jqMGTNG9YOYPXs2Pv30U6vX05Lz07FjR8THx6tzXvKYqmOIV7YwkFOIDPaz6nZEbp2GJC0L5SX4rXoWaHEz05OIHJgM9CF990oOBBJdTQOBLFu2DCdOnECvXr0QFham7sbLHXTJxTeSC/bJkyfjkUceUa0R0ulXUm5sTVo/nn76aUyaNEnV6frrr0daWhr++usvNbqQBALlkdaSTp06oVWrVqo/xLJly9RoR9ZmyfmRwExSliQ9SgK0a665BhcuXFCtKJIKZm5qV2UxYCCnIDmY0vxaVlqSsfnVnFxNIrcmfRZKtiwUowfSzxu2a3RDNVaMiCwlQYH03ZN0XGlhl5tm8u9gdfTlkzQYmcRN0pByc3PVnfHvv/9eXWQbyXCpkmPftWtXddf8iSeesHnnXCMZrlVaCWS0JAlspL5yl/7555+v8Gd9fHxUp2VpMZFRiW644Qb88MMPVq+jJedHUpokKHvhhRfwwAMP4OLFi2o+CAnYpH+ErWn0lgy+64aMfRgkMpWolOw7StKj3+y5ar3xa5GjJBGZ4cBi4KcHK97uts+BNlfGVCci65EL7JMnT6o5AmQOA1ck8wy0b99epfOQ/c5Peb9rllzjsg8DOQ3pvOXjdfWvrLQsMFggMpOMhmTN7YiIyOUxJYmcxvIDccgv1KFRrQBMv7UNEjPyqrX5lcgl1O8O+AQC+VllbKAxjJYkQ6wSEbmgRx99VHVmLo1M7iaTvVFxDBjIafy466x6vL1zPXRvYvsRAYhcjgzpt+Kp8oMFMWgmOzwTUZWUNvyno3j11VdVp+jSVFf6+Z8OfH5Kw4CBnMLJpCzsPHUJ0pBwW8e69q4OkfPRFgK/TAD+/gHQeACdHwT+XV7KPAwzOQ8DEbm0yMhItZD5GDCQU1i829C60OuaCNVngYgsUJgPLHkIiP0F0HgCt35q6NA8+E3O9ExERBViwEAOT6vT46fd51V5VCfzJlwhossKcoEfxwBHVgGePsCoLw1zLAgPTw6dSkREFWLAQA5v09GLiE/PRY0Ab/RvySZEIrNJX4Uf7gZO/Al4+QF3fgs07c8TSEREFmHAQA7vx93n1OMt7WLg62Xb6eSJXEZuOvDdaODMVsA7ELh7IVsTiIioUtxiHgaZ0lumKpdZCOfNm2fv6pAFUrPzseZQgiqP6sx0JCKzZKcAX99iCBZ8Q4H7f2GwQERElebyAUNhYSEmT56MP/74A3v37sXbb7+N5ORke1eLzPTr/gvI1+pwbe0QtK4TyvNGVJHMi8BXw4ELewD/msCYX4F6XXjeiFyVTguc3GSYxV0e5bmNZyh+8sknbbb/U6dOQaPRYN++fbCnv/76C23atIG3tzdGjBgBd+fyKUk7duxAq1atUKdOHfV88ODBWL16Ne666y57V43MsOjy3AujOnEoVaIKpccBXw8Hko4AgZGGloWoljxxRK4q9ldg1dRShkd+02bDIy9ZskRdRNtKvXr1EBcXh/Bw+863JDeb27dvj5UrVyIoKKjK+3v55Zfx888/2z0QctkWho0bN2LYsGGIiYlREaec7JLmzJmDhg0bws/PD926dVNBgtGFCxdMwYKQ8vnzhhF3yLH9E5eOg+fT4e2pwYgOVz5DIipF6hngi8GGYCGkDvDASgYLRK4eLCy6v3iwYLxxIOvldRuoWbMmgoODbbLv/Px8eHp6Ijo6Gl5e9r2nffz4cfTt2xd169ZFjRo14CjkHNmDwwcMWVlZaNeunQoKSrNw4UIVBU6bNg179uxR2w4cOBCJiYnVXleyrh93GTo79782CjUDfXh6icqSfByYPxi4dBKo0cAQLIQ35fkiciZ6vWFkM3MWGdRg5RT5odJ2ZHiQlgfZzpz9yXtXIiXp448/Vv1D5YZtVFQUbr/99mLbPf7442oJDQ1VLQYvvvgi9EXeS272vvbaa7j//vvVDMsPP/zwVSlJMiOyPP/999/RoUMH+Pv7qwt5uc6Tu//XXnut+tm7774b2dnZpn3rdDrMmDEDjRo1Uj8j14eLFy+u8PiM7y/p6+PGjVPlL7/8ElqtFg8++KBpf9I39v333y/2s1LXrl27IjAwUAUZPXv2xOnTp9XPv/LKK9i/f7/an3GfIjU1FQ899BAiIiLUccixyXZFWyakpUP64Mp7y7m2B4dPSZIUIlnKMmvWLIwfPx4PPPCAej537lwsX74c8+fPx7PPPqtaJoq2KEhZPsyy5OXlqcUoPT1dPRYUFJj6RAiJfGWdfOgly8YIWZaSZXndw8NDvYc06ZVW9vExXBzL9kXLvr6+6g9A3qu0stRNtpdfallKluV1+UOV9ypZdrRj0nh64+e9hoBhVOe6LnFMrvg58Zgc4HNKOwF8PQKazHigVjPo7vsZBf4R8L38DyY/J/498TvC8b73jN8Tsh9ZL98NurxMeMy0Vvqt3tDyMNPMwUKevwC9d4Cqi5wXeSyrbLRz505MnDgRCxYsQPfu3ZGSkoLNmzerY5LjEV999ZW66JbMD1keffRR1K9fX114G7d55513VCAhN36N56PouSl64fzhhx+qi/U777wTo0ePVuf5u+++Q0ZGBm699Vb1+pQpU9TPSbDwzTffqKBGLu43bNiAe++9V12Y9+rVq8zjk0wUSYmSn5GLfHmv4OBg9blKa4PcqJbgZ+vWrSrAkdaQO+64Q/3OSF8HuSb99ttv1e+KnCPZp9T14MGDWLVqFdasWaOOXfYpr40aNUoFAStWrFCB1SeffIJ+/frh33//RVhYmDr2Y8eOqWBH0sGknnJuKvqcSpZFyX+fjM9dooWhPPLh7N69G/37XxlXXE6OPJcPUkhwIB+SBAqZmZkqGpUWiLLIL5h8YMZFcumEfMBi3bp1ahGyL/njEJIqJb8YYtGiRaboUP6QDh8+rMoSHZ44cUKVpcXEGMhI0JOUlKTKM2fOVL/4cmxSlkd5LmUh28n2Qn7e2PIi+zWOACXvJ+8rpB5SHyH1M6Z0Sb2l/o56TH8cTkBKdgECPQvRq1mESxyTK35OPCb7fk5fzJgMfHGzChYSEA48sAJJ+T78nPj3xO8IB//e27ZtmyrLdYksIjUtDfYkwZPxvOTm5poGiJG79pcuXTJlfRgvMo8cOYKAgAAMHTpUXdg2adJEBRByo9V4THLT9vXXX1cX30OGDFEBw3vvvaf2Le8h5C68tELIz8tFtPEGrWxT9IJWLt579OiB2rVrqyBEAgBZJ60OErDI/tevX69+/uzZs5g+fTr+97//oVOnTmjcuLG68JcWELkgL3lMcpdfSL3luQQBQgISKRcUFKjzI+/XtGlTREZG4p577lH9Yb///ntTy0RaWpo6H3L9KO85ZswYFQzIBbr0g5ALdwk2ZJ+yraTdSyD1wQcfqHrKOXjqqadU64T8HiUkGEaJlN9LCazkWOVcmvM5GY9J1ufk5JT675PxWtkseici1V26dKnp+fnz59W6LVu2FNvumWee0Xft2tX0/JdfftE3a9ZM36RJE/0nn3xS7nvk5ubq09LSTMvZs2fVeyQlJanXCwoK1CLy8/NLLefl5ekLCwtLLWu1WtP7lFXW6XRqKVkWsl1ZZdm/kPcrrSz1k3qWVna0Yxr3xQ59g6nL9K//dtBljskVPycekx0/pzM79LoZ9fT6aSF63Se99bmX4vg58e+J3xFO8r2XkZGhj42N1WdlZan3U/ssLNTrcjP0+rxMvTYnvfzykdXqb7+iRXt4ldpeFvlZ2Uep5cvHbTwv5ZV79+6tf+KJJ9Q1Ups2bfTh4eH6e++9V79gwQJ1PLKtcbuxY8deOT6tVl3DeXl5qXMh6xs0aKB/7bXXim1z4sQJdd21e/dutX79+vXqeUJCgqkun3/+uT4gIKBYvV588UV9hw4dVPnvv/9WPxMYGFhs8fb2VteH5hxraGiofv78+aZ66XQ6/UcffaTv2LGjOmbj/rp06WLaRo7X19dXf/PNN+vfe+89/YULF0w/O23aNH27du2KHeuHH36o9/DwuKqesk6uZWUb+bmmTZua9dmUVs7OztYfOnRIn5OTc9W/T8nJyeo8yWdZEYdPSbKG4cOHq8Uc0tQoS0nGEQGKdsIpOkpA0bKxSbO8ctH3sKQsLShllY37N6Y3lCwXrXtZZUc4prR8Pf48clE9v7NbA5c4Jlf8nHhMdvycTv1lmJQtPxOodx009yyCr59h2GF+Tvx74neE43/vGZ/LfoypOR7yc55BV6V/lFpu0tcwGpJ0cC61H4NGve7RrL/s2LjG9Fhm+XJdjHn2pZWNJN9e+o5K3r6MPikpRXIHXlpWjJ2Ei/5ssWMtUpY77xVtI+R8G/cnrxnTyozvY0zVkbKxL4OkqBcd+Mb42ZZ3fEXfs2hdfvjhBzz99NN49913VYuGtIbIUP3bt283bfPFF1+oVhZJPZIWAkm1kgyV6667rtR9SkuAtJjIOSxJzqHx+KRPRNFjNedzKq1c8t8nSzqWO3XAIM068odpbLIxkufG5qTKkmZHWSRnjarX0j3nodXp0bF+DTSJqPpQZkROTcZUP70FyEwAgqKAwlxg4X1AYQ7QqBdw1w+AT6C9a0lE1UmCABk6VUZDUpf6RYOGyxe8g2aaggVbkQtOSQOXRQIGuciVea+kP4EwXkwbSSqWdJI2BlW20rJlSxUYnDlzBr1797bavAw9evTAY489VmwkpZIkbUiW5557TgUW0sdCAgZjH5eiOnbsiPj4eHUepQO4I3PqgEFOvuR8ST6WcVINiS7lueTDVcWECRPUIrl4kotG1UMyz0xzL3BmZ3J3pY2xbtRsADD6a8Db3x41IyJ7k3kW5Dug1HkYZtpsHgajZcuWqb4c0oFY+jBIp125BpMceyO5YJeRLB955BHVGiGdkuUOva3J3X9pDZg0aZKq0/XXX6/6DMhFv7SMSN8CSzVr1gxff/21Gq1JRiuSfivSmiJlcfLkSXz66acqo0X6bkin5aNHj6oRoIQEBLKNjP4knaeljhJoSVAh17BvvfUWrrnmGjUdgLSMjBw5Ep07d4ajcPiAQTqgSO9wI+PJlnGApae9/CLKBy8nVTo4z549WzXxGEdNIuey92wqjl/Mgp+3B4a2rW3v6hDZf4z1UtMNALS7i8ECkbuToKDFzcVbIRv0sHnLgpDWBBm1R0Yvks63ckEtHYBlslwjuViWDrdyfSatCk888YQaWag6yHCtMiKSDGYjgY3UV+7oP//885Xa3yOPPIK9e/eqEZEkxUc6PEtrg7Ezu3QAlw7wMjKUdESWVCO58Sw/J2677TZ1vvr06aM6JEv60tixY1Wg9cILL6jr1osXL6oMGQnCZJhaR6KRjgxwYJLXJSe3JAkSjGPYfvTRRyqPTJp1ZKxa6W0uE7hZKyVJRgKQyFSiUrKt55YcwPc7zuDWDnUw6472PN3kvmlIs1uX3rJQJD8ZTx6olgsDIrIuucCWG6D2HFff1mQeBrkmkxu55Ji/a8YsGnOucb2c4ReuopjGODGINTElqfrl5Gvx237DBdLtna01FjWRE5K7hWUGC8Yx1s8btmt0QzVWjIiI3JFTz8NArmXVoThk5hWibpg/rmtUy97VIbIfSS2w5nZERGQi80HI6EylLfIaOWELA7mPH3ddntm5Uz14eFwZ1ozI7Zg76pHkKxMROaDShgp1FK+++qrqFF0app+XjgFDGTisavU6m5KNLceTIUMF39ap+JjJRG7l0ilg9UsVbHS5D4N0biQiIovITM2ykPmYklROH4bY2Fg1ZBbZ3uLdhtaFHk1qoW5YAE85uaezO4HP+gHJRwC/sMsrS7a2Vd8Y60RERIIBA9mdTqc3BQySjkTklg4tBb4aCmQnAdFtgce2AKMXACElhheWlgUZe93GY6wTEREZMSWJ7G7biWScT81BsJ8XBrWu2gzdRE5HRoHbPAtY96rh+TWDgdvmAb5Bdh1jnYiIyIgBQxnYh6H6/Hi5dWFYuxj4efNCiNxIYT6wfBKw9xvD827/AQa+UTwgkDKHTiUiIjtiSlIZ2IeheqTnFmDFgThVHtWJcy+QG8m5BHx7myFY0HgAQ94BBrNfAhEROR4GDGRXy/bHIa9Qh6aRQWhfrwY/DXIPKSeBzwcAJzcCPkHAXQuBruPtXSsiIrMm1H3yySdtdqZOnToFjUaDffv22fXT+Ouvv9CmTRt4e3tjxIgRcHdMSSK7+nH3WfU4unNd9QVB5PLO7gC+v8vQuTmkDnD3QiC6jb1rRUROSqvTYk/iHlzMvoiIgAh0jOwITxv2c1qyZIm6iLaVevXqIS4uDuHh4bCnyZMno3379li5cqWa0M3RSGDVqFEj7N27V9XT1hgwkN0cS8zA3jOp8PTQYEQHzr1AbuDgT8DS/wDaPKB2O0PLQslRkIiIzLT29FrM3DETCdlXZn2PCojCs12fRf8G/W1yHmvWrGmzzyc/Px8+Pj6Ijrb/ACjHjx9Xsz7XrVv5dGnj8bgCpiSV0+m5ZcuW6NKlS/V+Im44s3Of5hGIDPazd3WIbDsS0sZ3gMXjDMFC8yHAAysZLBBRlYKFyX9OLhYsiMTsRLVeXrd1StLHH3+MZs2awc/PD1FRUbj99tuLbff444+rJTQ0VLUYvPjii9DL9+FlDRs2xGuvvYb7779fzbD88MMPX5WSJDNGy/Pff/8dHTp0gL+/P/r27YvExER19//aa69VP3v33XcjOzvbtG+dTocZM2aou/DyM+3atcPixYsrPD7j+ycnJ2PcuHGq/OWXX6rXDh48iMGDB6sWBzne++67D0lJSVcds5wfOd6BAwdWuv6rVq3C9ddfjxo1aqBWrVoYOnSoCmKM5LiE7FP2L+9tSwwYysBOz7ZVqNVhyd7zqjyqM+deIBcfCemXCcAfrxmeXzcBuOMbwCfQ3jUjIgciF9LZBdlmLRl5GZixYwb00F+9n8v/ScuDbGfO/opexJtr165dmDhxIl599VX8+++/6gK3V69exbb56quv4OXlhR07duD999/HrFmzMG/evGLbvPPOO+piXlJrJKAoy8svv4yPPvoIW7ZswdmzZzF69GjMnj0b3333HZYvX47Vq1fjww8/NG0vwcLXX3+NuXPn4tChQ5g0aRLuvfdebNiwwayUKLmIl/1L+Y477kBqaqq60JcLdDl2Od6EhARVj5LHLK0K0gdC3ruy9c/KylJpUfJe69atg4eHB0aOHKkCISHnVKxdu1bVUVLFbIkpSWQXG45cxMWMPNQK9EHfFpyenVx4JKSF9wGnNl0eCeltoMtD9q4VETmgnMIcdPuum9X2Jy0PPX7oYda22+/ejgDvAIv2f+bMGQQGBqo738HBwWjQoIG6mC558f3ee++pO+DNmzfHgQMH1PPx468M8iAX4U899VSxO/ylef3119GzZ09VfvDBB/Hcc8+pO+6NGzdW66R1Y/369Zg6dSry8vIwffp0dTHdvXt39bpst3nzZnzyySfo3bt3mcfl6empUqKkztIyYkyPevfdd9XxyX6N5s+fr47xyJEjuOaaa9Q6aXF56623TNvIxbyl9Re33XZbsXrJe0VERCA2NhatW7dWZSGtD9WRwsUWBrJrOpL0XfD25K8huaCUE8C8mwzBgoyEdPciBgtE5DJuuukmFSTIBa+k5nz77bfFUmrEddddV2xAE7l4P3r0KLRarWld586dzXq/tm3bmsqSDhQQEGC62DaukzQfcezYMVUXqaOkDxkXaXEomtZjif3796sL+qL7a9GihXqt6D47depU5foLOU933XWX2kZaOyR9yxio2QNbGKjaJWfmYe0/hpzLUZ059wI5OZ326pmYz+0EfrgbyE6+PBLSIiC6tb1rSkQOzN/LX93pN8fuhN14bN1jFW73cb+P0Smqk1nvbSlpVdizZ4/K0Zd0mpdeekml3ezcuVPl3ZtLWinMUXRkJglCSo7UJOuM6TqZmZnqUVJ96tQpPqiKr68vKiMzMxPDhg3Dm2++edVrtWvXrvB4LKm/kPeSgOyzzz5DTEyMek1aFqQjtT0wYKBq9/O+CyjU6dG2bihaRIfwEyDnFfsrsGoqkH7hyjr/MCAvA9AVciQkIjKbXDCamxbUI6aHGg1JOjiX1o9BA416Xbaz5RCr0j+hf//+apk2bZoKFP744w/ceuut6vXt24sHQNu2bVMpO5L2Y0syaI0EBnI3vrz0I0t07NgRP/30k7rTL8dtS9LhWvqFSLBwww03qHWSTlWUcfSloq01tsRcEKpW0rHqx12GuRc4szM5fbCw6P7iwYKx34IECzEdORISEdmEBAEydKoxOCjK+Hxq16k2DRaWLVuGDz74QI1mdPr0aZXuI3fBpa+CkVywS8ddufj9/vvvVafeJ554ArYmrR9PP/206ugsnZAlZUhaQ+T95XllB8NJSUlRaULSiiL7lJGPHnjgAatftIeFham+CZ9++qlKr5IgTM5jUZGRkWrEJWPn67S0NNgSA4YycFhV2zh0IR2H4zPg4+WB4e049wI5cRqStCyUcmfPRFKUvDhcMBHZhsyzMOvGWYgMKD5wiLQsyHpbzcNgJK0JMjKPdFqWoUFlRCAJClq1amXaRoZLzcnJQdeuXdUFtwQLMnRqdZDhWmXUJRktSeo3aNAglaJkHI7UUjExMWrkIwkOBgwYoGaBluFT5TzICEbWJPv74YcfsHv3bpWGJIHP22+/XWwbaeWQgE06cUvdbrnlFtiSRl+ZsbTcSHp6uuolL5GbdDqhqnnpl4P4eutpDG1bGx/d3ZGnk5zTyU3AV0Mr3m7MMqCRoTmZiMgoNzcXJ0+eVBevMoeBM830bC6ZF0BmIJahQ8kxf9csucZlHwaqNrkFWvyyz5C+MZpzL5Azk9YDa25HRFRJEhx0ieYks2RbTEmiaiMjI6XlFKB2qB96Ng3nmSfnJaMhWXM7IiKqNo8++mix4VGLLvIaXY0tDFTtcy/c1rEuPD2Kd9IicioydGpIzNUdnk00htdlOyIiNyTDrToqmZ1aOkWXhunnpWPAQNUiLi0HG49eVOXbO3HuBXJykh/c+UHgj9dKefFyMDxopmE7IiJyKDLCkCxkPqYkUbVYsuc8pHt910Y10TDcvElaiBxWYR7w9yJDueS46dKyMPproOVwu1SNiIjI2tjCQDbHuRfI5WyaBST9CwRGAv/ZAlw8XHymZ7YsEBGRC2HAUM48DLJU1wx6rmzX6Us4lZyNAB9PDGlzZfp0IqeU+A+w6V1DechbQFCEYSEiInJRTEkqg0wwEhsbq2bzo6pZtNMws/PNbWoj0JcxKjn5hG2//h+gKwCuGQy0HGHvGhEREdkcAwayqay8Qiw/EKfKo7vU49km57bzc+DcTsAnGLj5XUDD0b6IiMj1MWAgm1pxIA7Z+Vo0Cg9E5wZhPNvkvFLPAuteMZT7TwNC69i7RkREdpnB+cknn7TZ/k+dOgWNRoN9+/bZ7D3IcswPIZv6cfc501Cq8gVA5JRkiK/lk4H8TKBeN8OQqkREDkCv1SJ7124UXrwIr4gIBHTuBI2n7YZ0XrJkCby9vW22/3r16iEuLg7h4Zzg1ZEwYCCr0+r02HEyBbEX0tSjhAm3duTdWHJiB38Cjq4GPH2AYR8AHmycJSL7S1+9GgnTZ6AwPt60zis6GlHPP4eQAQNs8p41a9aEreTn58PHxwfR0dE2ew+qHP6rR1a16mAcrn/zD9z12Ta8tvwftc7bywP7z6byTJNzyk4BVk41lG94GohsYe8aERGpYOH8E08WCxZEYUKCWi+v2zol6eOPP0azZs3g5+eHqKgo3H777cW2e/zxx9USGhqqWgxefPFFNdS6UcOGDfHaa6/h/vvvVzMsP/zww1elJMmM0fL8999/R4cOHeDv74++ffsiMTERK1euxLXXXqt+9u6770Z2drZp3zqdDjNmzECjRo3Uz7Rr1w6LFy/mb04lsYWBrBos/OebPbjyVWCQX6hT6/93b0cMas1hVcnJ/P4CkJ0ERFwLXD/J3rUhIhclF9L6nBzzttVqkfD6G4Z0yat3pCacT3hjOgK7dzcrPUnj729x2vCuXbswceJELFiwAD169EBKSgo2bdpUbJuvvvoKDz74IHbs2KG2l4Cgfv36GD9+vGmbd955By+99BKmTZtW7vu9/PLL+OijjxAQEIDRo0erxdfXF9999x0yMzMxcuRIfPjhh5g61XCDR4KFb775BnPnzlVBzcaNG3HvvfciIiICvXv3tuhYiQEDWTEN6ZXfYq8KFoqS129qGQ1PD/ZlICdx/A9g/3fyzykw/APAy8feNSIiFyXBwr8dO1lpZ4aWhiNdupq1efM9u6EJKDFrfQXOnDmDwMBADB06FMHBwWjQoIFqASjZH+G9995TwUjz5s1x4MAB9bxowCCtBU899ZTpubQwlOb1119Hz549VVmCkOeeew7Hjx9H48aN1Tpp3Vi/fr0KGPLy8jB9+nSsXbsW3bt3V6/Ldps3b8Ynn3zCgKESmJJEViF9FeLScst8XQIJeV22I3IK+VnAb5dHAun6MFDPvH94iYjcwU033aSCBLkQv++++/Dtt98WSwkS1113XbGWC7l4P3r0aLFJcTt37mzW+7Vt29ZUlvQnaWkwBgvGdZKmJI4dO6bqInUMCgoyLV9//bUKMshyTEkiq0jMyLXqdkR2t346kHoaCKkL9HvR3rUhIhcnaUFyp98c2bt24ezDj1S4Xb1PP0GAGRfk8t6WklaFPXv2qD4Gq1evVmlFkjYkE97WqFHD7P1IK4U5io7MJEFIyZGaZJ30WxCSoiSWL1+OOnWKD7oiaUxkOQYMZZgzZ45aikbBVLbIYD+rbkdkV+f3ANs+NpSHzgJ8g/mBEJFNyQWvuWlBgT17qtGQJO2o1H4MGg28oqLUdrYcYtXLywv9+/dXi/RBkEDhjz/+wK233qpe3759e7Htt23bpvoTeNqwTqJly5YqMJC0KfZXsA4GDGWYMGGCWtLT01Xvfipf10Y1UTvUD/FpuaX2Y5AGyehQP7UdkUPTFgC/TgT0OqD17cA1A+1dIyKiYiQIkKFTZTQkNeN80aDhcgqQvG7LYGHZsmU4ceIEevXqhbCwMKxYsULd4Ze+CkZywT558mQ88sgjqjVCOiW/++67Nv80pfXj6aefxqRJk1Sdrr/+eqSlpeGvv/5SIyqNGTPG5nVwNQwYyCqkI/O0YS3VaEglGbMX5XV2eCaHt+VDIOEA4B8GDJpp79oQEZVKzbPw/uyr52GIirLpPAxG0pogk7hJGlJubq5qOfj+++/RqlUr0zYyXGpOTg66du2qWhWeeOIJNVJSdZDhWmVEJBktSQIbqW/Hjh3x/PPPV8v7uxqNvuiAuHQVYwuDRKYSlVL53lgei882nSy2TloeJFjgkKrk8JKPAx93B7R5wIi5QPu77F0jInJBcoF98uRJNUeAzGHgTDM9m0vmYWjfvj1mz55t76q4tdxyftcsucZlCwNZ1flUwxjSw9rVRv9ro1SfBUlDYssCOTy5d/LbE4ZgoXEfoN2d9q4REVGFJDgI7MZR3Mi2GDCQ1WTlFeKPw4YhzR7p1QSt67DvBzmRvQuAU5sA7wBg2GxTHjAREZG7Y8BAVrPucCJyC3RoUCsArWKYvkVOJCMeWP1fQ7nPC0BYQ3vXiIjIqclwq+Q6OHEbWc3yvy+ox6Fta1s8xTyRXa2cAuSmATEdgG6P8sMgIiIqggEDWUVmXiHW/3tRlW9uE8OzSs7jn2VA7C+SCAwM/xDwZMMrEVUPjjtDzvI7xoCBrGJtbALyC3VoHBGIa2tzkityEtKqsOJpQ7nnE0B0G3vXiIjcgHGW4uzsbHtXhVxcfn6+eqzqZHm8lUZWsezvOPU4tA3TkciJrH0ZyIgDajYBek+xd22IyE3IxZvMC5CYaBgoJCAggKm8ZHUyad3FixfV75fMyl0VDBioytJyCrDxyOV0pLZMRyIncXoLsGu+oTz8A8Db3941IiI3Eh0drR6NQQORLXh4eKB+/fpVDkgZMJB10pG0OjSLDELzaKYjkRMoyAV+nWgodxwDNLze3jUiIjcjF3C1a9dGZGQkCgoK7F0dclE+Pj4qaKgqBgxUZcsuj450c9vaPJvkHDa9AyQfBYKigJtetXdtiMjN05Oqml9OZGtu0el55MiRCAsLw+23327vqrictOwCbDqaZBpOlcjhJRwCNr9nKA95B/CvYe8aEREROTS3CBieeOIJfP311/auhkv6/VA8CnV6tIgORtNIpiORg9JpgZObgL8XAT+OBXSFQIuhQMvh9q4ZERGRw3OLlKQbb7yRMw7ayLIDl0dHYusCOarYX4FVU4F0Q+qcgQZoNsCOlSIiInIedm9h2LhxI4YNG4aYmBjVAejnn3++aps5c+agYcOG8PPzQ7du3bBjxw671JWKu5SVj7+OGdKRhrRhOhI5aLCw6P4SwYLQA789YXidiIiIHDtgyMrKQrt27VRQUJqFCxdi8uTJmDZtGvbs2aO2HThwYLFhyNq3b4/WrVtftVy4UPIigaxp1aF4aHV6tKwdgsYRQTy55HhpSNKyIMFBWVY9a9iOiIiIHDdgGDx4MF5//XXVMbk0s2bNwvjx4/HAAw+gZcuWmDt3rpqAYv78y+OnA9i3bx8OHjx41SKtFpbKy8tDenp6sUUYhzwrLCxUi3FdaWWZVU+r1ZZalkk0jO9TVlmm8ZalZFnIdmWVjbP5yfuVVpb6FT2Oqh7T8suTtd3cNtpljskVPye3PSaZZ+GqloWi9ED6eeQf2+A8x+SKnxOPiZ8Tf/f498TvCNjzu9wpAobyyIHv3r0b/fv3N62TsWTl+datW23ynjNmzEBoaKhpqVevnlq/Zs0a9bhu3Tq1iJUrV2Lz5s2qLKlUO3fuVOVFixZh//79qrxgwQIcPnxYlefNm4cTJ06osrSonD9/3hQUJSUZUntmzpyJjIwMdexSlkd5LmUh28n2Qn7e2DIj+5X9C3k/eV8h9ZD6CKmfMeVL6i31r+wxbdt7CFuOG+rcJrTAJY7JFT8ntz6mzASYY+WiL5znmFzxc+Ix8XPi7x7/nvgdAXt8l1tyLa3RSzjjIKQPw9KlSzFixAj1XFKK6tSpgy1btqB79+6m7aZMmYINGzZg+/btZu1XAgw5kZL+VLNmTfz444/F9leURHDGKE5IC4MEDfLB1apVyxSNyRTbEp1JnUuW5UM3jqtcsiyvS9Aj7+Ht7V1qWSbZELJ90bKvr6+KLOW9SitL3WR7iTJlKVmW1+XjlvcqWbb0mBbuOo8Xf41F65gQ/Pp4T5c4Jlf8nNz6mE7/BXw1tMLvh/y7l8Lnmr7OcUyu+DnxmPg58XePf0/8joA9vsslQJFr27S0NISEhJT7b6VbBAxVIQGDtDSYczLdyZ2fbsW2Eyl4bnALPNK7ib2rQ3S1S2eAD9oBekPay9U0QEgM8OQBwIOTJhERkXtJt+Aa16FTksLDw9UdqoSE4qkF8jw62pA3byvS9CN9Jrp06WLT93FGiRm52H4yRZU5uzM5pLxMYOHdRYIFTYkNLj8fNJPBAhERUQUcOmCQZpVOnTqZ8q2ENMXI87JSiqxlwoQJiI2NNeXn0hWrDsZD2qXa16uBumEBPDXkWGTUoyXjgfgDQGAEcPMsIKTEsL/SsjD6a07cRkRE5AwTt2VmZuLYsWOm5ydPnlSjHklfg/r166shVceMGYPOnTuja9eumD17tuqLIKMmkX0s28/J2siBrZ0G/LsC8PQF7vwOqNcV6DTWMGqSdIQOigIa9GDLAhERkbMEDLt27UKfPn1MzyVAEBIkfPnll7jjjjtw8eJFvPTSS4iPj1dzLqxatQpRUVF2rLX7ik/Lxc7ThnQkTtZGDmf3V8CWDw3lER8bggUhfRQa3WDXqhERETkruwcMN954o+q9XZ7HH39cLdVJ+jDIYhxLnAxWHIhT6UidGoQhpoY/Tws5jhMbgOWGGw648Tmgze32rhEREZFLcOg+DPbEPgylW36A6UjkgJKOAovuA3SFQOvbgd4ywzMRERFZAwMGMtuF1BzsPn0JGg3TkciBZKcA340GctOAul2BW+bIGM32rhUREZHLYMBQBg6rWno6kujSsCaiQvxs+XtJZJ7CfGDhfUDKCSC0PnDnt4A3fzeJiIisiQFDGZiSdLXf/mY6EjkQ6UyzbBJwejPgEwzcvRAIirR3rYiIiFwOAwYyy9mUbOw/mwoPDTCotW0nzSMyy1+zgX3fABoPYNSXQFRLnjgiIiIbYMBAFqUjdWtUC5HBTPkgO4v9FVj7sqE86E2gWX9714iIiMhlMWAgsyy7nI50c9sSM+YSVbcLe4ElDxvKXcYD3S6XiYiIyCYYMJSBnZ6vOJ2chQPn01Q60mCmI5E9pV8Avr8LKMwBmvQDBs3k50FERGRjDBjKwE7PV7cu9GgSjlpBvrb+nSQqXV4m8N0dQEYcENECGPUF4Gn3uSeJiIhcHgMGqtByjo5E9qbTGdKQ4v8GAsINIyL5hdq7VkRERG6BAQOV68TFTMTGpcPLQ4OBrTg6EtnJ2mnAv8sBT1/gzu+AsIb8KIiIiKoJAwYyq3WhZ9NwhAX68GxR9dvzNbDlA0NZZnGu342fAhERUTWyOAH45MmT2LRpE06fPo3s7GxERESgQ4cO6N69O/z8/Fyq07MsWq0W7oyjI5FdndxomJxN9H4WaDuKHwgREVE10+j1Ml1qxb799lu8//772LVrF6KiohATEwN/f3+kpKTg+PHjKli45557MHXqVDRo0ACuIj09HaGhoUhLS0NISAjcydGEDNz03kZ4e2qw64WbEBrgbe8qkTtJOgbM6wfkpgKtbwNu+xzQaOxdKyIiIre7xjWrhUFaEHx8fDB27Fj89NNPqFevXrHX8/LysHXrVvzwww/o3LkzPv74Y4waxTuBzm755cnabmgWwWCBbEunBU5vATITgKAowyhI3402BAt1uwC3fMxggYiIyE7MChhmzpyJgQMHlvm6r68vbrzxRrW88cYbOHXqlDXrSHYgDU+mdKQ2nKyNbDxr86qphjkWjDx9AG0+EFrf0MnZ23XSHYmIiFwyYCgvWCipVq1aaiHndiQhE8cSM+Hj6YGbWkXZuzrkysHCovslRC2+XoIFcd1/gKBIu1SNiIiIqjBKkvRZ+O9//4u77roLiYmJat3KlStx6NChyuyOHNCyvw13e3tdE4EQP/ZdIBulIUnLQslgoaitHxm2IyIiIucJGDZs2IA2bdpg+/btWLJkCTIzM9X6/fv3Y9q0aXAVMkJSy5Yt0aVLF7hjOpJxONVh7ZiORDYifRaKpiGVJv28YTsiIiJynoDh2Wefxeuvv441a9aojtBGffv2xbZt2+AqJkyYgNjYWOzcuRPuRiZqO5GUBR8vD/S7lulIZCPSwdma2xEREZFjBAwHDhzAyJEjr1ofGRmJpKQka9WL7MjYutCneQSCfC2eqoPIPDIakjW3IyIiIscIGGrUqIG4OMMFZVF79+5FnTp1rFUvsmc60uXhVIe2jeHnQLbToAcQIr9jZc2toAFC6hi2IyIiIucJGO688041OVt8fDw0Gg10Oh3++usvPP3007j/fhnthJzZwfPpOJ2cDT9vD/RtwdFpyIY8PIFBb5bR6flyEDFopmE7IiIicp6AYfr06WjRooWavE06PEvH4F69eqFHjx5q5CRybssOGDqh9msRhUCmI5GttRhqaEUoSVoeRn8NtBzOz4CIiMjOLE5Ql47On332GV588UUcPHhQBQ0yE3SzZs1sU0Oyy+hIN7fl6EhUDQ4vM4yE5BMM3PYZkJ9l6LMgaUhsWSAiInIIle7RWr9+fbWQ69h/Lg3nLuUgwMcTfZozHYlsTK8HNr5tKHd7BGg+mKeciIjIWQOGyZMnm73DWbNmwVXmYZBFq3WfSaOW7b+cjnRtFPx9mDdONnZ0NRD/N+AdCFz3GE83ERGRMwcMMgKSOaQTtCvNwyBLeno6QkND4ep0Oj1WXB4d6eY2TEeiamhd2PCWodzlQSCwFk85ERGRMwcM69evt31NyK72nr2EC2m5CPTxxI3NI/hpkG2d+BM4vwvw8gO6P86zTURE5EqjJJFrWna5s/NNLaPg5810JLIxY9+FTmOBYE7MRkRE5HKdnnft2oVFixbhzJkzyM/PL/bakiVLrFU3skM6EidrI5s79Rdw+i/A0wfoMZEnnIiIyNVaGH744Qc158I///yDpUuXoqCgAIcOHcIff/zhFrn+rmjX6UtISM9DsJ8Xbrgm3N7VIXdpXWh/DxDK2eGJiIhccuK29957D7/99puak+H999/H4cOHMXr0aA6z6qSW/20YHWlAy2j4ejEdiWzo3C7gxHpA4wlcP4mnmoiIyBUDhuPHj+Pmm29WZQkYsrKy1OhIkyZNwqeffmqLOpINaSUd6WC8Kg/lZG1UXa0L7e4EwhrwfBMREbliwBAWFoaMjAxVrlOnjprtWaSmpiI7O9v6NSSb2nEyBRcz8hDq742eTZmORDYUtx84sgrQeAA3PMVTTURE5Kqdnnv16oU1a9agTZs2GDVqFJ544gnVf0HW9evXzza1JJu0LEiw8NEfR9Xzm1pGwseLg2ZRNbQutL4NqNWEp5qIiMhVA4aPPvoIubm5qvzCCy/A29sbW7ZswW233Yb//ve/tqgjWdmqg3F45bdYxKUZPkex7p+Lav2g1py0jWwg8R/gn98MZbYuEBERORWNXi9TrlJZjDM9p6WlISQkxOlPlAQF//lmD0p+6MY5uv93b0cGDWR9ix8EDi4Grh0O3LGAZ5iIiMiJrnEtzkFZsWIFfv/996vWr169GitXroSrmDNnDlq2bIkuXbrAldKQpGWhtAjRuE5el+2IrCbpGHDo8vwsvZ7miSUiInIyFgcMzz77LLRa7VXrdTqdes1VTJgwAbGxsdi5cydchfRZKJqGVJKECfK6bEdkNZtnAXodcM0goHY7nlgiIiJXDxiOHj2q7ryX1KJFCxw7dsxa9SIbSMzItep2RBW6dArY/4Oh3OsZnjAiIiJ3CBgk1+nEiRNXrZdgITAw0Fr1IhuIDPaz6nZEFdo8G9BrgcZ9gLqdecKIiIjcIWC45ZZb8OSTT6oJ3IoGC0899RSGDx9u7fqRFXVtVBO1Q/1MHZxLkvXyumxHVGVp54F93xrKvafwhBIREblLwPDWW2+plgRJQWrUqJFarr32WtSqVQvvvPOObWpJVuHpocG0YVenkwljECGvy3ZEVfbX+4A2H2hwPdCgB08oERGRu8zDIClJMu+CTNS2f/9++Pv7o23btmpCN3J8Ms/CY32aYM76Ky1EIjrUTwULnIeBrCIjAdjzlaHMkZGIiIjcK2AQGo0GAwYMUItITU21dr3IhrLzDaNc9W0RiVvax6g+C5KGxJYFspqtHwKFuUDdLkDjG3liiYiI3Ckl6c0338TChQtNz0ePHq3SkerUqaNaHMjx/XUsST3e1rEubmlfB92b1GKwQNaTlQzsnH9lZCQNU9yIiIjcKmCYO3cu6tWrp8qSliSLTNg2ePBgPPMMh010dAnpuTiSkKmu4Xo0qWXv6pAr2vYxUJBlmHOhmaEVkoiIiNwoJSk+Pt4UMCxbtky1MEhqUsOGDdGtWzdb1JFs0LrQOiYUYYE+PLdkXTmpwI5PDWW2LhAREblnC0NYWBjOnj2ryqtWrUL//v1VWa/XlzoDNDmWzZcDhuubhdu7KuSKJFjISwciWwLNb7Z3bYiIiMgeLQy33nor7r77bjRr1gzJyckqFUns3bsXTZs2tUadyEYkqNt89HLA0JQBA1lZXoYhHUnc8BTgYfH9CCIiInKFgOG9995T6UfSyiBzMgQFBan1cXFxeOyxx2xRR7KSY4mZSMzIg6+XBzo1CON5Jeva+TmQcwmo1RRoNZJnl4iIyF0DBm9vbzz99NNXrZ80aRIckQQ29913HxITE+Hl5YUXX3wRo0aNgjunI8kQqn7envauDrmS/Gxg60dFWhf4+0VEROTW8zA4EwkSZs+ejfbt26sO2506dcKQIUPUbNXuxpiO1JPpSGRtu78Esi4CNRoAbdwzICciInJVLh8w1K5dWy0iOjoa4eHhSElJcbuAoUCrw7YTyarM/gtk3V+uXGDLB4by9ZMAT2+eYCIiIhdi916JGzduxLBhwxATE6NmkP7555+v2mbOnDmq34Sfn58aunXHjh2Veq/du3erkZyMw8K6k/1nU5GVr0VYgDda1g6xd3XIlez7BsiIA0LqAO3vtndtiIiIyNUChqysLLRr104FBaWRWaUnT56MadOmYc+ePWrbgQMHqj4JRpJu1Lp166uWCxcumLaRVoX7778fn356eYx4N7PpcjpSj6bh8PDgzLtkJYX5wObZhnLPJwEvX55aIiIiF2P3gEGGZX399dcxcmTpo6rMmjUL48ePxwMPPICWLVuqmaYDAgIwf/580zb79u3DwYMHr1qk1ULk5eVhxIgRePbZZ9GjR49y6yPbpqenF1tEQUGBeiwsLFSLcV1p5fz8fNOcFCXLOp3O9D5llWX4U1lKloVsV1ZZ9i/k/UqWjRO2dW9kGB1J6ursx1TacfCYqvlz+nshkHYW+sAIoON9/Jz498TvCH7v8buc/z7xOiLfua6NbDZxW82aNa9aatWqhTp16qB379744osvYA1y4JJGZJwcTlXYw0M937p1q1n7kJM/duxY9O3bV42WVJEZM2YgNDTUtBjTl9asWaMe161bpxaxcuVKbN68WZUllWrnzp2qvGjRIuzfv1+VFyxYgMOHD6vyvHnzcOLECVWWFpXz58+bgqKkJMMF/cyZM5GRkaGOXcryKM+lLGQ72V7IzxtbZmS/sn8h7yfvK6QeX3+/CHvPpqrnWcd3q0ept9TfWY9J6iOkfsY0Nh5T9X5OH3/0IbDpXfV8i6YL4O3Pz4l/T/yO4Pcev8v57xOvI+Y5x7WRudfSit5Cs2bN0teqVUt/77336j/44AO1SDk8PFz/xhtv6B966CG9r6+v/tNPP7V013qpztKlS03Pz58/r9Zt2bKl2HbPPPOMvmvXrmbtc9OmTXqNRqNv166dafn777/L3D43N1eflpZmWs6ePavqkJSUpF4vKChQi8jPzy+1nJeXpy8sLCy1rNVqTe9TVlmn06mlZFnIdmWVZf9C3q9oeeX+c/oGU5fpb3hznaqn8TiKlp3tmIzlksfBY6q+zyl/1zd6/bQQvW5mQ31eRgo/J/498TuC33v8Lue/T7yO0DvPtVFycrK6xpXr3Ypo5H/mhxfAbbfdhptuugmPPvposfWffPIJVq9ejZ9++gkffvih6itw4MABS3atOj0vXbpUpQ8J6YMgrRZbtmxB9+7dTdtNmTIFGzZswPbt22FrkpIkLQ1paWkICXHOzsIv/3oIX245hXu61ccbI9vYuzrkCqRJ9ePrgKR/gb4vAr2unpuFiIiIHJcl17gWpyT9/vvvxVKEjPr166deEzLPgbEppipkCFRPT08kJCQUWy/PZYhUW5KmH+kz0aVLF7jKhG0cTpWs5p9fDMGCXyjQ9WGeWCIiIhdmccAg/RV+++23q9bLOnnNOPJRcHBwlSvn4+OjJloz5lsZO3vI86ItDrYwYcIExMbGmnL4nVV8Wi6OJWZCowG6N6ll7+qQK5BGyY3vGMrdHgX8nLPljYiIiGw0cduLL76I//znP1i/fj26du2q1slF9YoVK9QIRsYOwtL52RyZmZk4duyY6fnJkyfVqEcSfNSvX18NqTpmzBh07txZvZ/M2iwBiYyaRBUzjo7Utk4oagT48JRR5em0wOktwJFVQMJBwDvQEDAQERGRS7M4YJAhTiVV56OPPsKSJUvUuubNm6s+BcYhS5966imz97dr1y706dPH9FwCBCFBwpdffok77rgDFy9exEsvvYT4+Hg158KqVasQFRUFW6ckyWIcltLZ05F6Ng23d1XImcX+CqyaCqRfmdtENVud2gy0HG7PmhEREZGNWdzp2d04c6dn+Wi7Tl+Hixl5+O6hbmrSNqJKBQuL7pffqBIvXJ4AcPTXDBqIiIhc+BrX4hYGIXfdZXzXf/75Rz1v1aoVhg8frjook+M4mpipggU/bw90bGCYsI3I4jQkaVm4KljA5XUaYNWzQIubAQ/+/RMREbkiiwMG6W8goyDJJBKSimSc7EwmOFu+fDmaNGlii3pSJWw6akhH6tKwJvy8eTFHlSB9FoqmIV1FD6SfN2zX6AaeYiIiIhdk8ShJEydOVEHB2bNnsWfPHrWcOXMGjRo1Uq+5ClcYVtXY4ZnDqVKlZSZYdzsiIiJy/RYG6dy8bds20xCqolatWmoq6549e8JVyLCqshjzu5xNgVaHbSeSVfn6Zuy7QJUUFGXd7YiIiMj1Wxh8fX2RkZFR6vCoMm8COYa9Z1KRna9FrUAfXBvtXJ21yYE06AEElBdwaoCQOobtiIiIyCVZHDAMHToUDz/8MLZv365G4ZFFWhweffRR1fGZHGs4VRkZycPj8mg2RJbSFgAeZTVEXv69GjSTHZ6JiIhcmMUBwwcffKD6MMhMy35+fmqRVKSmTZvi/fffh6tw9j4MV/ovcHZnqoKNbwOZ8YBfDSC4dvHXQmI4pCoREZEbqPQ8DEePHsXhw4dV+dprr1UBgytyxnkY0nML0OHVNdDq9Ng8tQ/qhgXYu0rkjOIPAp/2BnSFwOgFhqFTZTQk6eAsfRYkDYlDqRIRETklm8/DIJo1a6YWcjzbT6SoYKFReCCDBar8/Au/TTQECy2GXpmYjUOnEhERuR2zAobJkyebvcNZs2ZVpT5kBZuPXlSPPZmORJW141Pg/G7ANwQY8g7PIxERkRszK2DYu3evWTvTaNi51pE6PHP+BaqUS6eBda8Zyje9CoSU6LtAREREbsWsgGH9+vVwN9LpWRatVgtnEpeWg+MXsyADI3VvzPkXyELSpWnZJKAgC6jfA+g4hqeQiIjIzVk8SpK7kEnbYmNjsXPnTjiTzUcNrQtt6tZAaIC3vatDzubAj8DxdYCnDzD8A8CDXxFERETuzqyrAZlj4dy5c2btcOHChfj222+rWi+qJA6nSpWWlQysetZQ7j0FCOegBkRERGRmSlJERARatWql5lsYNmwYOnfujJiYGDUHw6VLl9Sd+M2bN+OHH35Q6z/99FOeWzuQEXI3H0tW5eubRvAzIMv8/jyQnQxEtgJ6PMGzR0REROYHDK+99hoef/xxzJs3Dx9//LEKEIoKDg5G//79VaAwaNAgc3ZJNvBvQgaSMvPg7+2Jjg1q8ByT+Y6tBf7+wTB7s6Qiefnw7BEREZFl8zBERUXhhRdeUIu0Kpw5cwY5OTkIDw9XMz9zhCTH6b/QtVFN+Hp52rs65CzyswwdnUW3R4G6ne1dIyIiInIglZq4LSwsTC3kqP0XODoSWWD9dCD1DBBaD+j7X546IiIiKoZDoJRBhlRt2bIlunTpAmeQX6jD9pMpqtyTAQOZSyZn2/axoTz0PcA3iOeOiIiIimHA4CLDqu49cwnZ+VqEB/mgRXSwvatDzkBbAPw6EdDrgDajgWY32btGRERE5IAYMLhYOlKPJuHwkFnbiCqy5QMg4SDgXxMYNIPni4iIiErFgMFFbGL/BbJE0jHgzzcNZQkWAtnvhYiIiKwUMMjISNnZ2abnp0+fxuzZs7F69WpLd0VWkp5bgP1nU1W5ZzNe+FEFdDrgtycAbR7QpC/Q9g6eMiIiIrJewHDLLbfg66+/VuXU1FR069YN7777rlr/v//9z9LdkRVsPZ4MnR5oHB6IOjX8eU6pfHsXAKc3A94Bho7OGqawERERkRUDhj179uCGG25Q5cWLF6v5GaSVQYKIDz74wNLdkRX7L3B0JKpQRjyw+kVDuc8LQFhDnjQiIiKybsAg6Ugys7OQNKRbb70VHh4euO6661TgQNVvs7H/AtORqCIrngHy0oCYDoZJ2oiIiIisHTA0bdoUP//8M86ePYvff/8dAwYMUOsTExMREhICV+Es8zBcSM3BiYtZkIGRrmtcy97VIUf2zzLgn18BjScw/EPAs1LzNhIREZGbsThgeOmll/D000+jYcOGqv9C9+7dTa0NHTp0gKtwlnkYjK0L7erVQKi/t72rQ44qNw1Y8bSh3PMJILqNvWtERERETsLiW4y33347rr/+esTFxaFdu3am9f369cPIkSOtXT8ys//C9Zzdmcqz9mUgIw6o2QToPYXnioiIiMxWqZyE6OhotRTVtWvXyuyKqkCn07PDM1Xs9BZg13xDedj7gDdH0iIiIiIrBwzSsdlcS5YsseDtqSr+TchAUmY+/L090bF+GE8mXa0gF/h1oqHc8X6gkWGEMyIiIiKr9mEIDQ01LdKxed26ddi1a5fp9d27d6t18jpVfzpSt8Y14ePFSbupFJveBZKPAkFRwE2v8hQRERGRbVoYvvjiC1N56tSpGD16NObOnQtPT0+1TqvV4rHHHnOpUZKcwaaj7L9A5Ug4BGyeZSgPeRvwZysUERERVUMfhvnz52Pz5s2mYEFIefLkyejRowfefvvtSlSDLJVXqMWOkymqzPkXSNFpDf0VMhOAwAhg7SuArhBoMRS4djhPEhEREVVPwFBYWIjDhw+jefPmxdbLOp1OV7lakMX2nklFToEW4UE+aB5lmEiP3Fjsr8CqqUD6heLrvfwNrQsajb1qRkRERO4WMDzwwAN48MEHcfz4cdPISNu3b8fMmTPVa1Q9Nl9OR+rZNBwaXgy6NwkWFt0PQH/1a4U5wLldQEu2MBAREVE1BQzvvPOOGlL13XffVXMxiNq1a+OZZ57BU089VclqUGUnbOP8C25O0pCkZaG0YEHRAKueBVrcDHhcSSMkIiIislnA4OHhgSlTpqglPT1drXPFzs5z5sxRi3TodjRp2QX4+1yqKrP/gpuTPgsl05CK0QPp5w3bcUhVIiIiqoQqjcUpgYIrBgtiwoQJiI2Nxc6dO+Fotp5Ihk4PNIkIRO1QTsLl1qSDszW3IyIiIqpqwJCQkID77rsPMTEx8PLyUiMkFV2o+uZfYDoSISfNvJMg8zAQERERVUdK0tixY3HmzBm8+OKLqu8CO9zar/+CdHgmN3XpFLDuVeDgTxVsqAFCYoAGPaqpYkRERAR3DxhkDoZNmzahffv2tqkRlevcpWycTMqCp4cG1zWpxbPlbnIuARvfAXZ8CmjzDQFBg+uB05svb1C08/PloVQHzWSHZyIiIqq+gKFevXrQ68sakYVsbcuxZPXYrm4oQvy8ecLdRWEesOMzYOPbQK6hwzsa3wjc9BpQu23p8zBIy4IECxxSlYiIiKozYJg9ezaeffZZfPLJJ2jYsCFPfjXbxP4L7kWC80NLgbUvA6mnDesiWxoChab9rkzIJkGBDJ1qnOlZ+ixIGhKHUiUiIqLqDhjuuOMOZGdno0mTJggICIC3d/G73CkpKVWtE5VBp9NjizFgaBbB8+TqTm8FVv8XOL/L8DwoGuj7AtD+ntIDAVnHoVOJiIjIEVoYyD4Ox2cgOSsfAT6eaF+vBj8GV5V0DFg7DTi8zPDcOxDo+QTQ43HAJ9DetSMiIiI3Y3HAMGbMGNvUhCq0+dhF9ditUU34eFVpCg2y58zMZaUNZSUBf84Edn8B6AoBjQfQ8X7gxueBYA6LSkRERE4SMAiZ/fjnn3/GP//8o563atUKw4cP5zwMNrb5codnpiM5qbI6Jkt/BOmfsOk9ID/DsP6aQUD/V4DIFnarLhEREVGlAoZjx45hyJAhOH/+PJo3b67WzZgxQ42etHz5ctW3gawvr1CLHScvBwycf8E5g4VF95cY9hSG4OGnB688j24LDHgdaNy72qtIREREVBqL81omTpyogoKzZ89iz549apGJ3Bo1aqReI9vYffoScgt0iAj2xTVRQTzNzpaGJC0LJYOFojSewIi5wMMbGCwQERGRc7cwbNiwAdu2bUPNmjVN62rVqoWZM2eiZ8+e1q4fXfZXkeFUObu2k5E+C0XTkEqj1wKhdQEP9k0hIiIix2Lx1Ymvry8yMi7nWReRmZkJHx8fOJrU1FR07txZzUzdunVrfPbZZ3BGm48aAoaeTEdyPtLB2ZrbERERETlywDB06FA8/PDD2L59u5rxWRZpcXj00UdVx2dHExwcjI0bN2Lfvn2qztOnT0dysqEvgLNIyy7A3+fTVJn9F5yQjIZkze2IiIiIHDlg+OCDD1Qfhu7du8PPz08tkorUtGlTvP/++3A0np6eaoI5kZeXZwpynMnWE0lqwt+mkUGIDvWzd3XIUjJ0anBMORtogJA6hu2IiIiInD1gqFGjBn755RccOXIEixcvVsu///6LpUuXIjQ01OIKyN3/YcOGISYmRuXmy3CtJc2ZMwcNGzZUwUm3bt2wY8cOi9OS2rVrh7p16+KZZ55BeHg4nMmmy+lIbF1wUmoG5l5lvKgxPAyaWfrszURERETOOA+DkBYFWaoqKytLXcyPGzcOt95661WvL1y4EJMnT8bcuXNVsCAzTQ8cOFAFKZGRkWob6Z9QWFh41c+uXr1aBSIS5Ozfvx8JCQnqPW6//XZERUU5ZYdnctKZm2MvB8J+NYDc1OLzMEiw0NLx0vmIiIiIKtXCcNttt+HNN9+8av1bb72FUaNGWXxWBw8ejNdffx0jR44s9fVZs2Zh/PjxeOCBB9CyZUsVOEiK0fz5803bSP+EgwcPXrVIsFCUBAkSnGzatKnM+kjaUnp6erFFFBQUqEcJTIzBiawrrZyfn68mtyutrNPpTO9TVtmYNiXlsylZOJWcDU8PDbo1rqm2k/WiZFn2L+T9SitL/Yoeh72OqWi5tONwqWPS6aD/ZQJQmAs06QvdU0dRcM/PwG2fQ3vfr8h/bLcKFpzqmFzxc+Ix8XPi7x7/nvgdwe9yN/33ySYBg6QQycRtpV34y2vWJAe+e/du9O/f37TOw8NDPd+6datZ+5BWBeOoTmlpaaqOxgnnSiOT0ElqlXGRCenEmjVr1OO6devUIlauXInNmzersqRS7dy5U5UXLVqkWjTEggULcPjwYVWeN28eTpw4YUqzksnvjEFRUpKhFUGGp5X65uTm4Yk35uCDtUfU+pr6DAT7eavtZHshPy/7EbJf2b+Q95P3FVIPqY+Q+hlTvqTeUv/qPCb5PKUsj/JcysKlj2nX59Cc3YZ8+ADD3seJ02fw2Zp/gDa343BuOBZ8+53zHZMrfk48Jn5O/N3j3xO/I/hd7mb/Pm0181paaPQW9gD29/dXd/RLXnRLpTt06ICcnBxLdle8MhqN6gsxYsQI9fzChQuoU6cOtmzZojpZG02ZMkXNByGjHlVE+jvIqE7GyG3ChAl45JFHytxeIjhjFCekhUGCBvngZL4JYzTm5eWlojOpc8myfOjS2VqWkmV5XYIeeQ9vb+9Sy38cScEry2IRn5ZrqkeQryfeGdUOA1pGqfeS4W0lyixalrrJ0LYSZcpSsiyvyzmQ9ypZtvUxGYfcle2Llks7Dpc5povH4TuvN1CQhYIBM+Dd4zHnPyZX/Jx4TPyc+LvHvyd+R/C73A3/fcrIyFDXtnJDPSQkxLoBQ9euXdXQqi+99FKx9S+//DJ+++031SLgSAFDVUnAIC0N5pxMa1h1MA7/+WZPqXMCS/fY/93bEYNa17Z5PaiK5M9qwUjgxHqgfg9g7HJOykZEREQOw5JrXIs7Pb/44ouq4/Dx48fRt29ftU6aN77//nv8+OOPsCYZzUgiNUkrKkqeR0dHw5ak6UcWYz5addDq9Hjlt9hSgwUjef2mltGqTwM5sH3fGoIFLz/glo8YLBAREZHTsrgPgwyBKnlRx44dw2OPPYannnoK586dw9q1a00tA9YizSqdOnUy5VsJaYqR50VbHGxBUpdiY2NNeWrVYcfJFMQVSUMqSQIJeV22IweWHgeset5Q7vM8UKuJvWtEREREVL3Dqt58881qsYbMzEwVfBidPHlS9ZGoWbMm6tevr4ZUHTNmDDp37qzSoWRYVRmKVUZNcjWJGblW3Y7slIq0/CkgLw2I6QhcN4EfAxEREblfwCATocmEbdJT++mnn1YX93v27FHDlkqfA0vs2rULffr0MT2XAEFIkPDll1/ijjvuwMWLF1Wfifj4eDXnwqpVq2w+j4I9UpIig/2suh3ZwaElwL/SX8EbuGUO4FnpqU6IiIiIHILFnZ7//vtvNaypdJI4deqUmkCtcePG+O9//4szZ87g66+/hiupzk7P0ofh+jf/UKMjldXpOTrUD5un9mUfBkeUlQTM6QpkJwM3Pgfc+Ky9a0RERERU5Wtci/swSAvA2LFjcfToUfj5XbnTLXMzWHseBncjHZmnDWupyiW7NBufy+vs8OygVk41BAuRrYDrDS1lRERERM7O4oBBOgGXNo+BpCJJyhBVjQyZKkOnSktCUfKcQ6o6sMMrgIOLAY2HYVQkL8N4ykRERETOzuIEa5k0QpowSjpy5AgiIiLgKuzRh6Fo0CBDp8poSNLBWfosdG1Uky0LjionFVg2yVDuMRGo09HeNSIiIiKyXx+Ghx56CMnJyWr6aensLH0aZK4EGVK1V69eahQjV1LdE7eRE/rlcWDvAqBWU+DRzYC3v71rRERERGS/PgzvvvuuGgo1MjISOTk56N27N5o2bYrg4GC88cYblu6OyLkd/8MQLEgvk+EfMVggIiIil2NxSpJEImvWrMFff/2F/fv3q+ChY8eOauQkIreSlwn8+oSh3PVhoIFtJxMkIiIisodKDxLfs2dPtRjnZSByO+teBdLOADXqA/1esndtiIiIiGzC4pSkN998EwsXLjQ9Hz16NGrVqqVGSZIWB1chHZ5btmyJLl262Lsq5IhObwV2fGooD3sf8A2yd42IiIiIHCNgmDt3LurVq6fKkpoky8qVKzF48GA888wzcBUTJkxAbGysGkaWqJiCHODXxwGZXq/DfUCTvjxBRERE5LIsTkmSuRaMAcOyZctUC8OAAQPQsGFDdOvWzRZ1JHIsf84Eko8BwbWBAa/buzZEREREjtXCEBYWhrNnz6ryqlWrTJ2dZXRWe8xZQFStzu8BtnxoKN88C/CvwQ+AiIiIXJrFLQy33nor7r77bjRr1kzNxyCpSGLv3r1qeFUil1WYb5hzQa8FWt8OtBhi7xoREREROV7A8N5776n0I2lleOuttxAUZOjsGRcXh8ceewyuwp4zPZOD2vwekHgICKgFDH7T3rUhIiIicsyZnt0NZ3omJSEW+KQXoCsAbvscaHM7TwwRERE5LZvO9EzkdrSFwC8TDMFC85uB1rfZu0ZERERE1YYBA1FFtn0MXNgD+IYCN78LaDQ8Z0REROQ2GDAQlSf5OLD+DUN54BtASG2eLyIiInIrFnd6JnJpOi1weguQmQAERgLrpwOFuUDjPkCHe+1dOyIiIiLnCRjy8/ORmJgInU5XbH39+vXhCjhKkhuK/RVYNRVIv1B8vacvMOx9piIRERGRW7J4lKSjR49i3Lhx2LJlS7H1shuNRuNyw5BylCQ3ChYW3S+/yaW/PnoB0HJ4ddeKiIiIyO7XuBa3MIwdOxZeXl5YtmwZateurYIEIqdPQ5KWhbKCBWiAVc8CLW4GPDyruXJERERE9mVxwLBv3z7s3r0bLVq0sE2NiKqb9FkomYZUjB5IP2/YrtEN1VgxIiIiIiccJally5ZISkqyTW2I7EE6OFtzOyIiIiJ3DhjefPNNTJkyBX/++SeSk5NV/lPRhcjpBEVZdzsiIiKiCmh1WuyM34kVJ1aoR3nuMilJ/fv3V4/9+vVzi07P5AYa9ACCY4CMstKSNEBIjGE7IiIioipae3otZu6YiYTsK9kLUQFReLbrs+jfwHCt7dQBw/r1621TEyJ7kY7MtduVETBc7tQ/aCY7PBMREVlI7prvSdyDi9kXEREQgY6RHeHp5gOIrD29FpP/nAx9icFWErMT1fpZN85yuKDB4oChd+/ecAech8GN/P0jcGSloexfE8hJufKatCxIsMAhVYmIiFz6Lnp1BVAzd8y8KlgQsk4DDd7c8Sb61OvjUIGVWfMw/P3332jdujU8PDxUuTxt27aFK+E8DC4ubj/w+UCgMAfo9Qxw43NXZnqWPguShuRAf7BERETO0ApQ1l10uSAW1rqL7mwtGOvPrMfE9RMr3G7+wPnoEt3FueZhaN++PeLj4xEZGanK0lehtDiDfRjIqWQlAz/cawgWmg0wBAvyJcOhU4mIyE3YohWguu6iO0MLhl6vx8m0k9hwbgP+PPsn9ibuNevnJAByJGYFDCdPnkRERISpTOT0tIXA4geAtDNAzcbArZ+xJYGIiNxKVXPpdXod0vPScSnvEtLy0nAp9xJS81Lxd9LfxS7iS5L3i8+Ox3u730OHqA4I8w1DDb8a6jHEJ8SsIMKR+wEUaAuwK2EXNp7bqIKEc5nnLN6HtJY4ErNSktwZU5Jc1OoXgS0fAN6BwENrgaiW9q4RERFRtZFWgIE/DSz3wl4u3h9s/SDS8tNUIGAMCNSSm6rWS9BgTdL6EOobihq+NRDmF1b88XJgEeoTipe3voyU3JQy9yEtDatuW1WlFgxL0p1SclOw+fxmFSBsubAFWQVZpte8PbzRNboretfrjZ51emLcqnEqsCmtBcZadbdLShKRSzn4kyFYECM+ZrBARERuRy6EywsWRHp+Ot7b816F+wryDjJd2MvFvlxob43bWuHPtQtvpwYjNAYj8n5yEW0MSk6ln0JlGFswvjj0BXrX7Y2YoBgEyg1CK6Y76fV6HEs9plKNNpzdgP0X9xcLAGr51UKvur3U+3eP6Y4A7wDTa7IPaQWR4KDozxj7d0ztOtXh+mGwhaECbGFwMfEHgM8HAAXZwPWTgP4v27tGRERE1erYpWOYvWe2utitSIfIDmhVq5XpLn/JO/9yt9/b07vU1gtL76IX6gpValPR1gxJd5Jy0een005bnOYT7BOM2oG11RIdGG0qSzAhzyP8I0x1KSvdyej6OterfgnnM8+jqBY1W6gg4ca6N6JVeCt4aDwsCkiiA6JVsFBdqVSWXOMyYLDiySQHl50CfHojkHoaaNIXuGcx+y0QEZFbkAvuFSdX4NfjvyI2Odbsn6vsaD3Gi25R2l30qvQxkFmRx/0+rsLt6gXVU2lT0nJREU+NpwpiZPkn5R/kanMr/BlfT190q91NtSJIoCCBhzON8MSUJKKSZLr1nx40BAthDYHbPmewQERELk0630rH21+O/4JN5zahUF+o1ntpvNRd8n0X96k7+uW1AshFbGVIMCBBQWlpPVW9iy51kv1U1ILx28jf1AW49CeIz4pHXFacYcmMU88vZF1QjwlZCercyHNZzDGxw0Tcc+09xVKNLCV1s/XQqdZSqT4MqampWLx4MY4fP45nnnkGNWvWxJ49exAVFYU6depYv5ZEVfXHa8DxPwD5w77jWyCgJs8pERG5HMmtP5R8CL8c+wUrT61UAYFRy1otMbzJcAxpNESlExlbAWyVSy9BgQydau276PLzlvQDkP4LTWo0UUtZd/qTcpJUMLHy5Ep8d/i7CutQJ6hOlYIFZ2NxwCATt/Xv31+l6Zw6dQrjx49XAcOSJUtw5swZfP3117apKVFlHVoKbL7caeuWj4Do1jyXRETkNMxJXZG75MtOLFMpRyfSTpjWR/pH4uYmN2N44+FoGta02loBbH0X3Zp1lzpGBUappUBXYFbAEOFgw57amsV9GCRY6NixI9566y0EBwdj//79aNy4MbZs2YK7775bBRGuhH0YnFxCLDCvPyDDm/WYCAx4zd41IiIiO+R02zpf3Fb7L2+0Hhmic92Zdfjt+G/YFrfNNMSp5Nb3rd8XtzS5BdfVvq7Cetg7l74qrF33ynbYdkY27fQsO5b0oyZNmhQLGE6fPo3mzZsjN7fiTiLOYM6cOWrRarU4cuQIOz07o5xLwKd9gEsngcY3Avf8BHhyJGEiIkdky1l7bT0jsK32X9FoPRIY5GnzTM/lYvmWprfgpgY3qVGBqGrn3RYdtt0mYIiMjMTvv/+ODh06FAsY1qxZg3HjxuHs2bNwJWxhcOJOzt/dARxbA9SoDzy8gf0WiIgcVFkXxta4QLPlvm25f7nTPeCnAepOd3liAmNUkDCsyTDUC65n8fuQ4w576tQBw0MPPYTk5GQsWrRI9V2QPg2enp4YMWIEevXqhdmzZ8OVMGBwUuteAza9A3j5Aw+uBmq3tXeNiMiKnDmFgiyfcVju1i8dvlSN96/RaOABD8OjxkNdmEu5MvuuanqJufv/bcRvyCzMNM2OLPMJpOelmyYok47JxvkH5PW03DQ134Dk01dk3oB5amhPsj5X/55Jt2XAIDu9/fbbsWvXLmRkZCAmJgbx8fHo3r07VqxYgcBAy2bSc3QMGJxQ7K/AovsM5VvnAW1H2btGRGRFtk4vcXbOdJEjOfcyms9LW16q8r4keDAGEvKfPJf95+vyK/xZ+f2R2Yo9PDzUkKMyJr+xLPuR81e0LK/LIgHAjoQdsKc3b3gTQxoPsWsdyDnZdB4G2bGkH23evFm1LmRmZqpO0NIZmsjuEg8DP//HUL5uAoMFIhdTVvqHpG3IemvlFjtr51tbB1NVrbtMoHXg4gE1/v/+xP04kHQAmQWZsAYJDuS/MtL9yyXnS/6zJQliQnxD1AzJMjtyqG+ooexbevlU+ilM3Ti1wv2622g9ZB+c6bkCbGFwIrlphk7OKceBhjcA9/3MTs5ELsTW6SXO3vm2OnL1Lam7XMCfSjtlCA4u7lcBwvG041dt5+PhY1YrwMf9PkanqE6mwEASJGRRz/SXn0NvKst6ec+pmyq+6J7aZSquCbsGWr1WLbKPQl2h6bn87hVdZyyfTDuJH/79ocL9f9DnAzUTsCW/l+40Wg+5YEqS2LlzJ9avX4/ExETodIYhvIxmzZoFV8KAwUnI7+EPdwFHVgGh9YCH/wQCw+1dKyKyop3xOzHu93EVbtcuvB0a12isJqaq6VdTLSXLMrqMK3W+tXUwZU7dZfjOv5P+NgQHF/fj74t/IyM/46p9ScfcdhHt0D6iPdpFtkOjkEa4eenNNrkwtvVFt6337y6j9ZALpiRNnz4d//3vf9UQqjKzc9GORmV1OiKyuQ0zDcGClx9wxzcMFohckKTBmGN/0n61lEdmfg3zLR5ESBrIj0d+LPXCz7jutW2vqe2Md7KNd5uNi/G5etTpit2NnrV7Vrn7fvGvF00TbhW9S150/2pdkTvsxvUqpaacTsPyHvHZ8Xhz55vqTroETLL4efnBx9MHfp5XHn29DK8ZF+kXIC0L5dX9mQ3PoFBfeNXrsr9W4a0MwUFEO7SNaIta/rWu2s6SWXttOSOwo+2/OiZWIzKHxS0MEiS8+eabGDt2LNwBWxicwOHlwA93G8ojPwHa3WnvGhGRlWUXZKuLdZnJtiJjWo5ReeApuSlquZR7SY04k5KTgpS8FHXxTrZRJ6iOCgzUEtlOBSfeHt52H8bS1kNk2nr/ztSRnZyHTVOSateujY0bN6JZs2ZwBwwYHHSOhdNbgMwEQFsALH8akE5z3R4FBr9p79oRkRXJP1G/n/od7+x6p9w76Oamf8j+MgoyDEFE7iUk5yabyrsTduOvC39VWKdw/3A1KZYaSUdG5rm8GJ+Xtj4pJwn/Xvq3wn13juqMBiENTD9rHO1HlS8PJ2oqX35djjUuMw6/HP+lwv13ieqCQJ9A5BXmqQm/Sl0uv1bWZGFl+e91/8Udze+AO3Y2r479EzlVStKkSZPUDMiuNt8COdGQqaumAukXiq+PaAEMeN1etSIiG/g35V/M2DFDXcgb714PaDAAXx76Uj2vTPqHXGiH+ISoRS7Mi2of396sgOGtXm+hS3QXm/S/eKz9Yxbv23ixui1uW4W59J8N+Mysi1gJrGQOAAkctsdtx6Q/J1X4M41DG6OqpG6VOX5777s69k9kTxYHDE8//TRuvvlmNGnSBC1btoS3d/GmxiVLllizfkQl5le4X10mXOXiv8C/K4GWw3nGiJycjG3/0b6PVH8Cyc+XPPgH2zyIsa3Gqpx7yYO3RU633BGW/VR00S3bOdK+bZFLL4GV9GmQpU+9PjatOxG5YMAwceJENUJSnz59UKtWLXZ0pupLQ5KWhfKayFc9C7S4GWATMJFTkr4Fi48sxod7P1Tj9YuBDQfiqU5PoXZQbdN2EhTIRay10z9s2YHV1p1jbdlBtjrqTkSOzeI+DMHBwfjhhx9UK4M7YB8GB3FyE/DV0Iq3G7MMaHRDddSIiKxIUnbkQvfIpSPqebOwZniu63N2SfFw5s63tsylr466E5GL9GGoWbOmSkdyNtnZ2bj22msxatQovPPOO/auDllKOjhbczsicgjxWfF4d9e7WHVqlXoufQse7/A4Rl0zCl4eFv8TZRW2asGw9b5tnUtfHXUnIsdk8bfxyy+/jGnTpuGLL75AQEAAnMUbb7yB6667zt7VoMoKirLudkRkV7mFuarz8ucHPkeuNleN+CNBwuPtH0cNvxp2/3ScufOtLdm67nqtFtm7dqPw4kV4RUQgoHMnaDwZkBA5XcDwwQcf4Pjx42o+hoYNG17V6XnPnj1wNEePHsXhw4cxbNgwHDx40N7Vocqo3x3w9gcKcsrYQAOExAANevD8EjmI0lJjJDD448wfeHvX2zifeV5tJ+uf6/YcWtRsYe8qkx2lr16NhOkzUBgfb1rnFR2NqOefQ8iAAVXeP4MRomoMGEaMGAFrkjkd3n77bezevRtxcXFYunTpVe8hw7jKNvHx8WjXrh0+/PBDdO3a1aKRneTnt2zZYtW6UzXaOa/8YEEMmskOz0QOorR891p+tdRyJNXQTyEyIBJPd34agxoO4gAabk6ChfNPPCnjuRZbX5iQYFj//uwqBQ22DkaIXJ3FAYOkI1lTVlaWCgLGjRuHW2+99arXFy5ciMmTJ2Pu3Lno1q2bmv9h4MCB+PfffxEZGam2ad++PQoLr565c/Xq1di5cyeuueYatZgTMOTl5amlaIcQUVBQoB6N7+Pl5aXWydBzJcv5+fnw9PRUS8myvO7h4aHeQ1pnSiv7+Pio95Dti5Z9fX2h0+nUe5VWlrrJ9lqtVi0ly/K69HGX9ypZduhjitsF/eoXDGFB+3ugP74emowr8zDoQ2KgGTQThdcMgb6gwDmOyRU/Jx4TP6fLv2+rjq/ClM1TrhqCUyZJk8VL44Ux147BQ20fQpBvEH/33PzvydvTEwlvTL8qWDB8wetljFd1se/Xqxc8vLwsPqbMtWvLD0Zmz0bwgJv4veeGv3vufkyFpVw7l8UDdjZ48GC8/vrrGDlyZKmvz5o1C+PHj8cDDzyg5n2QwEH6TsyfP9+0zb59+1SqUcklJiYG27ZtU6M6SfqUtDR89tlnePXVV8usz4wZM1SPceNSr149tX7NmjXqcd26dWoRK1euxObNm1X5559/VsGJWLRoEfbv36/KCxYsUOlQYt68eThx4oSp1eT8+fOmY0xKSlLlmTNnIiMjQ/3CSFke5bmUhWwn2wv5edmPkP3K/oW8n7yvkHpIfYTUT+oppN5Sf0c/pu8+mQUsGgONrhDHAzoAt8zB3hu/xpqYJ4DbPsehLm9icd1pav4FZzkmV/yceEz8nIy/e5KG9MqmV8qdJVj6KGStzUJ2WjZ/9/j3ZOizkFDOgBV6vWoZiB0wAIdG3oozD43HnlGjceiBcbgw9VlsGzMWsZMnI+Htt/HnI4/g8BtvIHn+F1j5fxNx9OOPEffiS+qCqbT9yvr46dORl5PD7z1+l7vdv7lbt26FVYdVlZGRjhw5gvDwcISFhZXbdJySkmL2m19VGY2mWEqSnDwJDhYvXlwsTWnMmDFITU3FL7/8YtH+v/zySxVIlDdKUmktDBI0yAcn8064Q8TpMMdUkKuGUvU4txP6yJYouH8FfILCnPuYXPFz4jHxc/LyUr8/Z7PO4ufjP+Or2K8q/D6e22cuutftzt89N/17kn3mHjuGjPV/ImPpUuSfPAl7qvfVl/Bu357fe27wu8djgumzkQBFrm3NGVbVrIDhq6++wp133qlOvlx0lxcwyMW8tQKGCxcuoE6dOiqVqHv37qbtpkyZgg0bNmD79u1WDxhK4jwMdrT8aWDnZ4BvKPDweqCW8w3nS67PVmPeO3rdZZK1fy/9iz0JewxL4h6k5Jp/w+jNG97EkMZDqlB7cjaSMpq9ezcy169Hxp9/ouD0GYt+PvyJifBt2BC6vDzo8/Khz5clr/jzvDzo8q88zz9zBnn//FPhvmPeeQehQ91jfikim83DUDQIGDt2LJyVJXWXph9ZJBolO9j3vSFYELd+ymCBnKZjr8yqK7PiOvpEVpbWPU+bhwMXD6jAQAKEfRf3Iasgq9g2Ph4+aBja0DT5WnkkQCHbsOVoQJbuu/DSJWRt3KgChKxNm6HLzLzyorc3Art0QWDv3kj+7DNok5NL78cgd6ijohD+8MMWH0fW9h04Y8aNTDkWIrJip2dpPpLRjIwdjo2Sk5PVOmteYEsKlLxfQoncRnkeHR0NW5owYYJajNEXVaO4/cCyJw3l3s8CzQfx9JNDXnBP/nPyVbn6idmJav2sG2c5bNBgTt271e6GfYn7sDthtwoSDiYdRIHOMPiDUZB3EDpEdkDHqI7oFNUJrWq1gqfGEwN/Gqj2VVo/Bg00KjCR1gxH5kgX3Y4yGpA5+5akhXxJNfrzT2Su/xM5+/YBOp1pe8+aNRHUuzeCbrwRgT17wjMoUK33rh1t6IAsGQxFg4bLGQ3yHpU5R3JupY6qj0QZCRWelz8DIrJiwFBWBlPR/DJrkf116tRJddAwpilJPpo8f/zxx636XuQgslOAhfcBhblAswFA76n2rhG5AGunDcn+5O58aRfEsk4uit/c8aaaFbeq6UnVXXfxzIZnoNVrr9om3D9cvb8xQGhWo1mpdZFWCgk85DwU3Yc8F1O7TnXotC17X3Q74tCkFe079z+PQpeegUxJNTp3rtg2vs2bI6jPjQi+8Ub4tWlT6oW/qtf7s68+N1FRVTo38l7y86UGI0ZaLQqTkuEdVfxGKBFVImCQCduM/Qykd3ZQUJDpNWlVkPkUWrSwfNKdzMxMHDt2zPT85MmTatQj6Whdv359NaSqpER17txZzb0gw6rKUKwyahK5GJ0W+OkhIPU0ENbQkIrkYfeBvMjJWSttSG6WyJCg5zLOYcPZDcX2d9W20CM+O17NYty3fl/UDa4LPy8/u9XdKLsgG7+f+r3cuotCvaEDY73geipAkOBAFnleXh82I6mbtFKUVncJFhy15cXeF92W7ltaKvS5uSqHX5eVhfhXXyt7aFIA8a+8Cu86deAhN/c8PQ0X7sZHD09ovOTRAxovL2jku/fya/LTciFf3r6TP/6faZXGxwcB13VTrQgSJHjHxJh1PHLswf36Wb31pcxgJDISep0O2qQknB0/Hg2+WQDPCvK4idyVWZ2eRaNGjdTj6dOnUbduXZUqVLQlQIYtleFKZa4ES/z555/o06fPVeslSJBOyuKjjz4yTdwmcy5I8GLp+1iqaB8GGSHKnA4hVEV/vA5sfBvw8gceWgNEt+EpJZuk3hjvdJdMG5KUm7jMOJzNOKsWCQ5UOdNQziksa/LAikX6R6rAQS6664fUV4/GJVQ69lex7sZ+BhcyL6gZlOXxXOY5w/OM82rdpbxLZtf3hW4v4M4Wd8KdOoTLBfixfv2LXVSWlkvfdN3aUi9i5eJTXcDn5kKfk6MeVTk3F9qsbMRNmQJtamqZ76/x90dQ/35AfoEpEDA9Fi1ffoQFY6hXh8BevRB2x2gEXncdPAINqUaOpLRUsIILF3Dq7ruhvZgE/06dUP/zefDwszy4J3L1Ts9mBwxGcnG/ZMkSNbyqO+AoSdXk8Argh7sM5Vs/A9qOrq53JhclF6uSS1/e3XTJwR/YcKC6sJaAIC4rDjr9lXzrkuRiPTowGqE+oTh8yTDednnqB9fHpdxLyCjIKHe7YJ/gYgFE3aC6eH/P++Ve4If4hGDUNaNUnY1BwsWcixXWKcArANmFhvkPyjN/4Hx0ie4Cd2JuB1mfJk3UXXhdbg70uXmmAEFG5bEbCWDM6EOoCQ5Wk5/JxbNsb3qUfgZV7IPorCMN5f77L07fex90GRkI6tMHdT/8QH2+RK4u3ZYBg7thwFANko4Bn/UB8tKBbo8Cg9+sjnclB2LtO9Fy0b/y5Eo8u+lZi3/Wz9NPtQQYWwPk4t14IR8TFAMfTx9TMFJRx95Vt62Ch8YDaXlpplYLWc5knDG1XphzkW8Jfy9/1Amqo+ot9ZVyneA66lGeB3oFml13R24NsIW0Zctx4emnrbIvja8vNH5+6m61LDqZVfXClRnqyxIydCj8O7RXP6PxkX34Gsq+vvAw7vPyo2mdr6+6c25OsFP/q68Q2K1rqa+pywFpJSkRTGTt3Inzj/9flfbt6LJ37cKZBx9SLTmhI0ei9vQ3zEq/I3LUARDsMqwqkc3kZQIL7zUEC/W7AwNe58l2M1XJ05cUIrnoPpF6AifSTuB46nH1eCrtFHK1uWa9f7/6/Qz9DC4HBtKxt6ILBbmQtqRjr8xsLEubiKvT7CTNyZT6dHmRYUuPph6tsO7X1b4O3WO6G4KCy0sN3xoV1t/ZOyXbiuTemyN84kT4t20LD38/wwW8v7/hwl0e5UJelhL9r8xtvagxalSlLrorHA3ocjpVeaMBqd8bY5+GIoL79Knyvh1dQOfOqPPeLJz7v4lIW7oUXrVqItJKwSNRdQ+AYAtsYSgD+zBUA/mHZ/EDwKGlQFA08MgGINi2w+WSY+Wjm5unL7n5EgQUDQokSDidcVpNIFYaL42XqfOurVJvSgt2ogOiq9yxd2f8Toz7fZxT1t0ZyZ31tF9+Uf9469LTy96wgj4MZvWPqOCiuzL7vqpTtXrDq4cmrWONDts22LcjSf1pCeJeeEGVI595BrUerPjvkMhaAyBU998TU5LsdDLJQls+Ala/AHh4AWNXAPVt25GdHGuCMnP6GPh6+iLCPwIXsi6U2bdAUnCahDZB4xqN0TjUsDSp0URd/A5ZOsTmqTe2CKQsSXlytLo7m/xz5xE/bRqy/vpLPfeqUweF58+XOR+Ao190O+uQsI4ked48JL7zrirXnjEDNUYahnUncoTBFayJAYOdTiZZ4OQm4Otb5C8HGPw20O1hnj4HZcloPXKnVjrUZuRnqLx9eUzPTzc9msp56TiTfgb7k/abXQ/p5CuBQNGgQB6lE3JZKTjGuqu6lZJ64wyTqzlj3Z3lH+1L33yDxNnvqw7L0g8g/PEJqDV2LDLWr3fqi25nnXTOUcj3WOJbbyPliy9Uilbdjz5UaVnkfr8ztqh75l9/4eyDDzlEnyCbBwypqanYsWMHEhMT1URqRd1///1wJQwYbCDtPPBJLyA7CWh7JzByrukOG8Hh7nQP+GmAutNdFm8Pb3U3P7MgUwUD5qQBWeLhNg/jrmvvQi2/WpXqhOjMqTfOXHdHlnvkCOJefBG5+/9WzwO6dEHt116FT8OGpm140e3eZNSouOeeV6lqEkzWn/85Ajo5bx8Ne3HmALkqdddmZCD/zBkUnD2L/DNnUXD2DPJPn0H+2bMojItzmFHHbBow/Pbbb7jnnnvUhGuy86L/gEs5JSUFroB9GGykMA/4YghwfhcQ1QZ4cDXgEwB3YasUkKqkDMlXgAzfWbTTrbETrvQXkFYBS3l5eKkWAeMS7BuMEO8QhPiGqCFEZV1yTjK+iv2qWob3dObUG2euu6PR5ecjee4nSPrsM6CgAB5BQSpPvcao26/qpEykLyjAucf/D5kbNsAjJAQNFiyAX/NreGIcKE/fVgFJhXWfPVuNZlZaQFBw5ky5862Yy+lbGK655hoMGTIE06dPR0CA61/osYXByn57Etj9BeBXA3j4T6CmYUJAd2CLfgDmpgzdWO9GxGfFFwsIZO4B4/OsgqwqHBnwaNtHMaDhAEOA4BuihiatqDWguvL0iUT23r2qVSH/2HH1PKhvX0RPewneUVE8QVQmXU4Ozox7EDl796q71w2+/x4+devwjDlAnr6tAhKZV+X4TQNUi0VVeNaqBZ/69eFTvx686xkf66nZ1k+NHo3ChESbDYDgEAFDYGAgDhw4gMaNG8MdMGCwoj0LgF8fV5eCuGcx0Mx9UioqM2tveRfaMmqQDBuaXZCNe1fci+Tc5DK399R4ShI8tCh/Uia5OC86eZgs0rrw2rbXbNYKwDx9sjVdVpbqpyD9FeQfZ/lHPPq/LyB40CCOs09m0aalqYnd8o4ehU+DBmjw3bfwqlWLZ68c5g4jHNSvL3wbN1EzgxdbggLhWXJdYKBpQj1zA5KGi39UE/Lp0tJQmJqqHuXuv9b4mFrieVoadJmZ5n22Go26+C8ZEEiQ4F23HjyDAh1+1DGbBgy33nor7rzzTowe7R4z8TJgsJLze4D5gwBtHtDnBaD3FLgLc0YDkjvy19e5Hvm6fOQVGoIBCQrUUvR5YV6l+whIXwMZp79kUCCLTOwlIxLZoxWAefpkK5mbNqsRkAouT5gWOmIEIqdOgVdYGE86WaQgIQGn77pb/S75tWql0kXKuyB0d9acBLEoNe9JYKDqjK5NLLtvXXWImTkToSNucepRx2w6cdvNN9+MZ555BrGxsWjTpg28vb2LvT58+HDLa0yuRacFTm8BMhOAoCggvDmw6H5DsHDNYOAG95oMR/LPywsWhAQEa8+stXjf0nqglZGmKvBc1+dwR/M7LL6ot3SCssqQlpU+9fowT5+spvDSJSTOnIm0X35Vz+UuYPQrryDo+p48y1QpkrpW7/N5OH33Pcg9dAjn/u9x1PvkE3iYOdmfO9FmZiJz00aztg0ZPgyeNWqolkBdVra6u28oX1m0WVmqz5HQ5+ZCm2vepJxGEmDIe3iGhhoeaxgfr6zzCA2F1+XHvBMncH6CZEOUz6t2bVSFBAXB/fo5zQhSFrcweJTTMUxylrUylbwLYKfnSor9FVg1FUg33NFT5M61BAs1GwPj1wP+NeBOVpxYgambpla43S1NbkGnqE7w8fRRLQ6+Xr7qrr9x8fPyMzx6+qltpCzBiK0n+BJsBSBHU9rIKPDwQPqKFUh4Yzq0MgCHRoOa99+HiIkTDXcliaoo58BBlWqjy85G8MCBqDPrXYe9wLPHoAKpP/yApP/NhfbSpfI3tjBPX/ZdNIjI3rFD/Z1XRIK8oJ49HW6SRUfBeRjsdDLdngQL0pJQSuqKMnAG0P0xtztNtpy1tzo7DnO0HnIUpTXle0ZEwDsyUt39Fb7NmqL266/Dv107O9aUXFHWli0488ij6q53jTvvQPS0aTbvD+PIcxnIELTpy5fj4uz3USCTHgLwadRIDSyQMn++TfL0bX1R7yh9DGyNAYOdTibcPQ1pduviLQslhdQBnjwAuNmINzkFOej5Q08U6AxNqta+qGfHYXInZY6MYuTpifDH/oPw8eOhYboI2er3cOVKnJ/8lPo9DJ8wARH/97hDzgdgS5KgkrX5LyS++y7yDh821CsiAuH/9zhq3Hqr6qBs65nHbXlR76jn3WkChldffbXc11966SW4EgYMFszc/NXQircbswxodAPcyStbX8HiI4tLfc1as/YyZYjcQYUjo0i8EB6OZhv+dJi7r+S6Ln3/PeJfMVwThd5+O7I2b67++QDsdKc758ABJL47C9nbtqnnMqdJrfHjVQqgh79/tbWO2Pqi3pFbdhw+YOjQoUOx5wUFBTh58iS8vLzQpEkT7NmzB66EAYOZDiwGfnqw4u1u+xxoczvcxaJ/F6lhSSUwGN92PH459ovNZu1lyhC5OnOHaqyOCY+IxMWP5iDpo49KPxlVvKivjrkMLJV/6pQapjhj1SpDFby9EXbPPaj1yMN2G33M1S/qnXaUpL1795b6hmPHjsXIkSMt3R25ChkNyZrbuYC9iXsxY8cMVZ7YcSIeavMQHmv3mM1GA5L9VHVGZCJHJfe2MjeaN/JKVSdcIjJXrUcfQfL8z6HPzrn6Rbkfq9GoO+AyGo5cxEq+v3SYlrkBtDI/gIwKlJlpKGfICEFXynJxXl5rmuxfXpeLZVsHyPI3dfHjj5H642KgsFAdV+jw4YiY+H9qFDJ7kvPKGwS2Z3HAUBqJSl555RUMGzYM9913nzV2Sc6mQQ8gJKacPgwaw+uynRtIyErApPWTUKgrxIAGA/Bga0PrCy/qiSyjLyxE+spVSP7sM+QdOWLWz8hdRqLqkLN7T+nBQomL+iM39AIuj/RTZv+bSjr/1FMI7NZNzQ9hWFrCMyjIKnfpZYhU6bic/MWX0OcYjjOwdy9ETp4Mv+bNrXoc5AYBg5DmDFlcRdFhVckMcpdcRkH6sbR0gcujRwya6RYdnmWCtUl/TlKzLzcLa4bXer7GGWWJLKTLzUXqkiVI+Xy+aeQVjeRGazTQZ2eXm6KhhlglqgbmtmbpZJjfory91UW9R3CwYVbjoGBVVuvU+iA1NGnqwkUV7lublKRGKZLFyKdhwyIBRPlBRKn9AKKiENizJzLXrzcNkerXti0iVXDCdD93ZHHA8MEHH1zVTBwXF4cFCxZg8ODBcBUTJkxQizG/i8yQfr5IgFDkDoq0LEiw0NL1J/WTv4fXtr6GA0kHEOobivf7vI8A7wB7V4vIaWjT03Hpu++R8vXXhrkUpGUuLAw1x9yPsLvuQtb27eWOjCKdHZm/TNXF3NasqJenqVYATwkQgoPVCF4VDcUqd/0zN2wsf+jQiAhEv/Yq8v75Rw0pnHPoEAovxKl0JlkqCiJkiNjSOlXLe6YtWWL6uYhJkxA84Cbe/HJjFnd6btSo0VUTuUVERKBv37547rnnEBwcDFfCTs9mSj4O/K8nUJgD3DwLCL/mykzPkobkBi0L4rt/vlP9Fjw0Hpjbfy66x3S3d5WInEJBQiJSvv4KqT8sNKRtyE3YmBjUfHCcGqKx6Mgr7jDcITkHR5wPoDAlRQUPxsUYRJRK6lROJoVHSAiabdwADz8/i+tOjs9u8zDk5OTAv8RwWs6OAYMZdDrgq2HA6c1Ao97A/b+YvszcbYK28avHQ6vX4unOT2NMq4pHcyFyd3IXNPnz+Uj7+WfoCwxzlfg2a4ZaD49HyKBBahSW0nBkFHIUzjAfgCGIiEXuoYMVBxElcNQx11XtAUNeXp7K93/rrbcQX16PfifEgMEMOz4DVjwNeAcCj20BwhrC3cRlxuGOZXfgUt4l3Nz4Zsy4fgabbsntlXdRn3PwEJLnzUPG77+bLrL8O3ZUgUJQ7978+yGn4ozzAVz6YSHiX365wu1i3nkHoUNvrtJ7kRsNqypBwcsvv4w1a9bAx8cHU6ZMwYgRIzB//nz897//haenJyZNmmSN+pMzuXQaWDPNUO7/slsGC7mFuXhi/RMqWLi25rWY1n0aL3bI7ZV+ARWFGrffjpw9e1XutJEECBIoBHRiZ2VyThIUyNCptpoPwBZDh/qUSDEvC0cdI/V7YO5pkBmcP/nkE/Tv3x9btmzBqFGj8MADD2Dbtm2YNWuWei5BA7kRuSv42xNAQRZQvwfQ5SG4G2mgk5mc/0n5B2G+YZjdZzb8vVwrLY/IWrPTFsYnIOmjOYYnnp4IGTIEtR56kMMzkktwtvkAJKCRVpCK+l9w1DGyKGD48ccf8fXXX2P48OE4ePAg2rZti8LCQuzfv593U93V3gXAifWAlx9wy0fSAx7uZkHsAiw7sQyeGk+8e+O7iAmKsXeViOxKUiekZaG8seY1AQFotHQJfBs0qNa6EVGRv0NPT5UypYJ76W/BUceoHGZf4Z07dw6dLjcXt27dGr6+vioFqaJhwZyV9Mlo2bIlunThzLmlSjsP/P6Codz3v0CtJnA3Wy9sxbu731XlZ7o8w1mWySkv7rO270DasuXqUZ5Xaj86HfJOnkTab8twfvJT5c9OK9tnZ6vWBiKyfyqVdMqWloSi5HlVO2uTm7YwyARm0nfB9INeXgiycCZBZ8J5GMohdyGWPQnkpQN1OgPXPQZ3cy7jHJ7Z+Ax0eh1uaXIL7m5xt72rRFQtnTQlDa/g3DnkHjyInIMHkXvQMHSjLjPTJhNeEZFz978gNwsY5B+JsWPHqpYFkZubi0cffRSBgYHFtltyeaIPcmF/LwSOrgY8fYBb5rjNHAtG2QXZqpNzWl4aWtdqjRe7v+iyLW3kZn0MEhIM6y/fWZTv/cK4uCuBgQQJEhykpV21T42vL/xatIBnRAQy166tsA7sSEnkOJyt/wU5cMAwZkzxMeXvvfdeW9SHHF1GArByqqF847NAZAu4E7mAemnLSzhy6Qhq+tXEe33eg6+nIYgmcvo+BpfXxT3/Ai79+CPyDsWaZlsuSuZG8G3eHH6tW8G/dWv4SZpqkyZqvbkTWbEjJRGRCwYMX3zxhW1rQo5P/vFfPhnITQVqtwN6TIS7+eLQF/j91O/w0njhvRvfQ3RgtL2rRGQRlXZQQR8DSS/K3rTZ8MTLC77XNIN/K0NgIEGCX7Nm0BRJUS2KHSmJiNw4YCDCoaXA4WWAhxdwy8eAZ+kzsLqqzec3Y/bu2ar8XLfn0DGqo72rRGRxC1n23r1mbRty60jUvPNO1ZLgcTkV1VyqD8T7s6/uIxEVZbWJrIiIqPowYCDzZCUZZnMWNzwNRLd2qzN3Jv0MpmycAj30uK3ZbRh1zSh7V4nILPqCAmTv2oWMteuQ8ccfqk+COWrcMgL+bdtW+iyzIyURketgwEDmWTkFyE4GIlsBNzzlVmctqyBLdXLOyM9Au4h2eL7b8+zkTCaSs+9oo4toM7OQtXkTMtb9gcwNG6BLT7/yop8fNHo99Hl5pf+wFfsYsCMlEZFrYMBAFftnGXDwJ/nXHxgxB/AqPXfZFcmwqS9sfgHHUo8hwj9C9VvwkdGhiKowNKktApKCxERkrv8TGevWInvrNtWyYORZsyaC+vZBcN9+COzRHZkbNxpGQ1JvUKRj8uXRvqT+9g56iIjIcTBgoPJlpxg6OoueE4GYDi59xrQ6LfYk7sHF7IuICIjArvhdWHdmHbw9vNWISLKOyJKhSW0ZkOSdOKFSjTLXrUPO/v3Ffta7QX0E9+uP4P794N+uXbEAgH0MiIjIEhq99IKjMqWnpyM0NBRpaWkICQlxvzO19D/A/u+A8GuARzYB3n5wVWtPr8XMHTORkH31DLQvd38Zt11zm13qRY7HNHRoOaMNeYbXQoOvvoJHUDA8Avzh4e8PjZdXlQMSI2ltKDn5mV/btgju21cFCT4yzGkF84M4YjoVERE53jUuWxjKMGfOHLXIDNdu6+gaQ7AAjWGCNhcPFib/OVl1ai5NqG9otdeJnHtoUm1SMk7cPLTYOhmKVAUOAQHq0ePyo0YFFAFXnvv5InXhojKDBaGCBS8vBHbvjuB+fRHUpy+8oyItOg72MSAiInOwhaECbtvCkJsGfNwdSD8PdH8cGPgGHDVtqGNkR3hWYbZp2d/AnwaW2rIgNNAgKiAKq25bVaX3IddQkJCAhOnTkfH76gq3ldmP9YWFgI1uPNSdOxfBN/a2yb6JiMi1pbOFgaps9YuGYKFmY6DPCw6dNiQX8892fRb9G/Sv8OfztHm4kHlBLeczz6vlwMUDZQYLQlod4rPjVZDSJbqL1Y6FnIdep0PWX1twaeEPqmOxuQFAvU8/RUDXLqoDsi4rC/qcHOhkyZbHbOiysw3r1HN5zFbrcw8eQtamTRXuXyZYIyIisjWmJNHVjq8H9nxlKA//CPAJcOi0ocTsRLV+1o2z0KtuL8RlxalAoGhQYCwn5SRV+v2lRYPcS2FyMlKXLEHqoh9RcPasab1/p07IO3bMMFxpaWlDRYYmlX4EKhVJZkYOCzPrfbO27zArYJB+B0RERLbGgIGKy8sEfptoKHcZDzTsafeUIeM+pWWhtD4GxnVPbXhKDYNakQCvANQJroM6gXXUY6G2EAuPLKzw5zhCkhvNhrxzJ1J/WIj0NWuAy8OTegQHI3TECITdMRq+TZte6ZQsHYutPDSpBBoyGpKMuFRRQEJERGRrDBiouHWvAKlngND6QP+Xqz1lyHjBdinvkppd+VT6KfUoAUh5aUPCGCz4efqhTlAdxATFqEdT+XKQIB2Yi44eI8HIn+f+VC0VpQUkxj4MEviQczJnNCBtWhrSfvkFl35YiPwTJ4qNPBR2xx0IGTJYdUiujqFJpW6yD1sFJERERJZgp+cKuFWn51N/AV8OMZTv+xlo0scqKUNywS0kZaho0CAzJxcNCk5nnMbptNPqUV6rjBevexGjrhll8UzMxrqLovUvq+7kPMqbyyD4ppuQ+/ffKkhIX7HCNPuxjGIUOnQoatwxGv6tWtltaNLqmBiOiIjcU7oF17gMGKx4Mp3JVWlDNVrA89NeQMoJoOMYYPgHVh1pSAR5B6Ff/X44k3EGp9NPIyU3pdx9RgdGo0FIAzQIbqAu3M1JG5o/cH6lOyaX1joSHRCNqV2nMliwMVtddFc4l0GdOig8f9703PeaaxB2150IGTYMnkFBcAScK4GIiGyBAYOdTqazKDVtyMMPz8adRX+vmsBjWwG/0ArThtLy0pCYk6iCjh3xOzD/4HyL61LLr5YhKAhpgPoh9dEwpKF6rBdcD/5e/lcFJBWlDVV16FNb9L8g+9xFN2dyNcXbG6FDhqDGnXfAv317i1uniIiInBGHVSXLRxrS5mByZDjebT4WXaBH4qUjSMpOMgUEF3Muqkd5LuvleYHO0BnUEjc1uAn96/dHg1BDy0GQj3l3ceWiXfpBSN0lOCgtbUhaAqp6cS8/z6FTq09ZLQDS2Vetf392hUGDBAba1FRoL11CYUoKtCmXoE29hOy//644WJC5DGbPVhOfERERUenY6dmNlDvSkOpYCUw+8hUgi5lq+NZQd+J9PXxxMPlghdvf1eKuSl+QSx8C6UtQWqdqpg05H7nQl5aFUtOFLq+Ln/aymr9Am5qmAgLtpRQUyqMEBeoxBdqyhjY1k8x/QERERGVjwOBG1p9dX/5IQ0UyMcJ8wxAeEI5I/0gVEET4R1z1GO4fDh9PH4tShqo60pAEDX3q9WHakAtQfRYqaAGQoCDuuefN2p9naCg8a9aEZ1gYPGuGqcnSsjZsrPDnOJcBERFR+RgwuDiZqGzN6TX4/dTv2J2w26yfmd7jdQxrdotF71NdKUPG92LakHOTi/nMjRVfzAvfZs1UZ2RDMFADXvJYwxAUeKngoKYKFjReXqX3YeBcBkRERFXCgMGFg4TVp1arIKG0O/7lic6s3GzITBmiijrK5+zbh/TfliF95UrVemCOqP/+F4Hdulp8cjmXARERkXW4RcDQsGFDNcKRh4cHwsLCsH79ejg6S0frKS9IaBvRFgMaDEC/nHyM3T8LiZ6ehj4LJWj0ekRptejoGVzpejNliErKO3ECab/9hvRly1Fw9qxpvUdYmJr3QJ+dXfpJs8JsxracXI2IiMhduEXAILZs2YIgBxlX3VqzJZsTJMhSO6i2YeXJTXg2+ZIaDUmCg6JBgzwXU5MvwTP48vaVxJQh12TJfAAFCYlqIrT0335Dbmysab1MiBbcrx9Chw1FYPfuyFi/3jAaknoD28xmLEGBvKetJlcjIiJydW4xcZu0MBw8eLBSAUN1z8NQ0WzJL/d4GfnafFOfhGJBQnhbDGhYIkgoSqcFZrfG2sJLmFkrDAlFcr6jCwsxNTkV/b3CgCcPAJx7gCycK0GbkYGM1auRtmwZsrdtvxIAeHkhqGdPNRlacN8+8AgIKHZuOZsxERFR9XOqids2btyIt99+G7t370ZcXByWLl2KESNGFNtmzpw5apv4+Hi0a9cOH374Ibp2NT+nuVGjRqhZs6ZKSXryySdxzz33OGTAYM5sySVVGCSUFPsLsOh+aAHs8fPFRU9PREgaUm4+1P3W0V8DLYdX6TjITWZLvtwKUHPcOJVqlPnnn9Dn55te9u/QASHDhiJk0CDVUdkedSciIiIXmLgtKytLBQHjxo3DrbfeetXrCxcuxOTJkzF37lx069YNs2fPxsCBA/Hvv/8iMjJSbdO+fXsUFhZe9bOrV69GTEwMNm/ejDp16qiApH///mjTpg3atm0LRyN9FswJFhqHNMat19yqJkGLCYqx7E38aqgHuRTrkpt3ZX1IHWDQTAYLTsqWsyVXNFdCyuefm1b5NGmi0o1Chg6FT926Zr+PBAeV6dhMREREtucBOxs8eDBef/11jBw5stTXZ82ahfHjx+OBBx5Ay5YtVeAQEBCA+fPnm7bZt2+fSjkquUiwICRYELVr18aQIUOwZ8+eMuuTl5enIq6iiygoMMxqLIGJMTiRdaWV8/PzodVqSy3rdDrT+5QsSwdnc4xrNQ5jWo1BdEC0+lkhPy/7F/J+pZWlfrqN7xi27zQOhff+DNz2ObT3/oLCx/eqYMHax2QsS0OWLCXLxrqXVTbnmIp+NtXxOTnaMV1auVK1AJSc08A4W7IEE+Yek07eI+USMo8cQfbefUia97lZsyUHDhiARkt+QoNffkbIuHEqWODn5Pq/ezwmfk783ePfE78jtE7/Xe4UAUN55MAlVUlaBYwkrUieb9261ewWjIyMDFXOzMzEH3/8gVatWpW5/YwZM1TzjHGpV6+eWr9mzRr1uG7dOrWIlStXqtYL8fPPP2Pnzp2qvGjRIuzfv1+VFyxYgMOHD6vyvHnzcOLECVOa1fnz501BUVJSkhoNyRzrfzOM8iQ/L/sRsl/Zv5D3k/cVUg+pj/hnzQJ4nNoIeHhhu3cPrIjNANrcjrXH87Bu/Z82OSYxc+ZM9RnI5ylleZTnUhaynWxfmWOS+kk9hdRb6m/rz6kqx3T86FEsfvllpC1bjsOLF2PBV19V6ZikBeDMtJfVl8xVLn/5xL/yKn7674s49sUXSPnmW/w+7kGceP4FnJ8yBVuG3Izjt92OYwMH4p8uXfFvm7Y42qMHzg6/BafvugtJ771n1u/kDo0Gfi1bqpY/V/icXPF3j8fEz4m/e/x74ncEv8vXFfn3ydxraYfow1CURqMp1ofhwoULqnVARjjq3r27abspU6Zgw4YN2L59e4X7lH8kja0XEn1Ja8UTTzxR5vYSwRmjOCEtDBI0yD/CtWrVMkVjXl5eKjqTOpcsyz/gnp6eailZltcl6JH38Pb2LlaWDswDFg/AxZyLZc6WHBkQiV+H/ooA/wAVZcr7+vr6qrLUzcfHRx2nLCXLuu/ugMeRVUD7e1E49H11MSnva8tjMpbl/YVsX7RsrHvR47DkmOT1osfhyMeUt2EDEt6YbphI7DLPqChEv/A8Avv1M+uY9DodNGlpyLlwAdqLF5G7cxcuXQ46rEkTGGiYDM3bGwWnT1e4fczn8xDas6dLfE6u+LvHY+LnxN89/j3xO4Lf5YUl/n2Sm01ybesUnZ5tHTBUlb1GSRKlzZY868ZZxYZWNVvCIeB/PdSe8PhOILyZ9SpNVe44XGf2bAT26K6CicLERDUsqTyq5xcTUaDKiSiUu8wWNCEaedWuDZ/69VUQ4FmjxpXHGsbHIutCQqC5fBFq7mzJTdetZSdlIiIiJ+JUnZ7LEx4eru66JRS5IyvkeXR0tE3fW5rxZTHmo1UXm82WvPlyaknLWxgsVDNzOg6fL6fVq9SL9PBweEmnfx8f5O7dW+GPxMycydmSiYiIqFIcOmCQpvZOnTqpfCtjq4M0scvzxx9/3KbvPWHCBLUYo6/qZPXZklNOAAd/MpRveMqqdaWKqeFCzeg4LDxCQuAVGQHvyCgVEMjde/U8qsjzWrWguTyHhrktAJwtmYiIiJw2YJCOyMeOHTM9P3nypBr1SOZNqF+/vhpSdcyYMejcubOae0GGVZWOzDJqkiuz6mzJm2cDeh3QbABQ2/GGk3V1MreAOWpPfwM1ShlauKLhSGXoVJXuJOlNnC2ZiIiIXC1g2LVrF/r06WN6LgGCkCDhyy+/xB133IGLFy/ipZdeUhO3yZwLq1atQlRUlEumJFld+gVg33eGMlsX7EImIjOHdx3z5y0oSs2z8P7sq+dhiIqq8jwMRXGuBCIiIvfkUJ2eHVF1d3q2ulXPA9vmAA16Ag+ssHdt3JJKG+rTV3ViLpWVOg5ztmQiIiJyu07PVEVZycDuLwxlti7YjQQBfm3bInPt2lJeNIySJC0BVQkWjO/D2ZKJiIjI2hx64jaqou3/AwqygdrtgSZ9eTrtJP/ceWRt3KjKMmxpUdKyUOf92VZLGyIiIiKyNrYwuGofhtx0YPunV1oXLt/JpuqX+O470OfnI+C661Bv3mfI2b1HdYSWvg0yelFVWxaIiIiIbIl9GFy1D4PMu7D2ZSC8OfDYNsCDjUn2kL1nD07ffY8K2BotXQK/Fi3sUg8iIiKiyl7j8irSFRXkAFvnGMo3TGawYCd6nQ4JM2aqco3bb2OwQERERE6JAYMr2rMAyLoI1KgPtL7N3rVxW+nLliH3wAF4BAQgYuJEe1eHiIiIqFIYMJRB+i+0bNkSXbpYafK06lKYD/z1vqHc8wnA09veNXJLupwcJM56T5VrPfKI2XMxEBERETkaBgxlmDBhAmJjY7Fz5044lQM/AunngKAooP299q6N20qeP19NouYdE4OaY8fYuzpERERElcaAwZXotMDmWYZy98cBbz9718gtFSQkIHne56oc+czT8PD1tXeViIiIiCqNAYMr+edXIPkY4FcD6PyAvWvjti7Oeg/6nBz4d+yI4EGD7F0dIiIioiphwOAq9Hpg07uGcrdHAd9ge9fILeUcOIi0X35R5ajnnoWG818QERGRk2PA4CqOrQXiDwDegUC3R+xdG7ek1+uRMNMwjGrI8GHwb9PG3lUiIiIiqjIGDK4wSpK0Lmx8x1DuMg4IqGnvGrmljN9XI2f3bmj8/BA5ebK9q0NERERkFQwYXGGUpNNbgLPbAE8fQ2dnqna6vDwkvmMI2mqNGwfv6Gh+CkREROQSGDC4AmPfhQ73AsG8ULWHSwsWoODcOXhFRqLWQw/apQ5EREREtsCAwdld2AscXwdoPA0TtVG1K0xORtL/5qpyxKRJamZnIiIiIlfBgMFVWhfajALCGtq7Nm7p4gcfQpeVBb9WrRB6y3B7V4eIiIjIqhgwOLPEw8A/vxnK10+yd23cUu6/R5D6449XhlH14J8UERERuRZe3TjzKEl/zTY8thgKRLawd23cchjVxDffBHQ6BA8YgIDOne1dJSIiIiKr0+jlqofKlJ6ejtDQUKSlpSEkJMRxztSl08AHHQC9Fhi/HqjT0d41cjsZf/6Jc4/+BxpvbzResRw+9erZu0pEREREVr/GZQuDs/rrfUOw0KQvgwU70BcUIPHNt1S55pj7GSwQERGRy2LA4Iwy4oG93xjKNzxl79q4pUvf/4D8kyfhWbMmaj36qL2rQ0RERGQzDBic0dY5gDYPqNcNaNDT3rVxO9rUVFycM0eVIyZOhGdQkL2rRERERGQzDBicTXYKsGv+ldYFjcbeNXI7Fz/+GLq0NPg2a4Yat99m7+oQERER2RQDBmez41MgPxOIagM0G2Dv2ridvBMncem771U58tmp0Hh52btKRERERDbFgMGZ5GUA2/5nKN8wma0LdpD49ttAYSGCevdGUE+mgxEREZHrY8DgTPMw7P4SyE0FajYBWt5i79q4naytW5G5fj3g5YXIqVPsXR0iIiKiasGAoQwTJkxAbGwsdu7cCYdQkAts+ejKrM4envaukVvRa7VImPmmKofdeSd8Gze2d5WIiIiIqgUDBmex71sgMx4IqQu0vcPetXE7qT/9hLx//4VHaCjCJzxm7+oQERERVRsGDM5AWwj8NdtQ7jkR8PKxd43cijYzExff/0CVIx77D7zCwuxdJSIiIqJqwyFeHJVOC5zeAmQmAAmxQOoZICAc6HCfvWvmdpI/+RTa5GT4NGyIsLvusnd1iIiIiKoVAwZHFPsrsGoqkH6h+PomfQCfAHvVyi3lnzuHlK++UuXIKVOg8WHrDhEREbkXBgyOGCwsul+62V792oHFwLXDgZbDrdKJN3vXbhRevAiviAgEdO4EjSc7UpeU+M670OfnI6D7dQjqc2OVzzsRERGRs2HA4GhpSNKyUFqwYLTqWaDFzVUaJSl99WokTJ+Bwvh40zqv6GhEPf8cQgYMcOtgpGjdtZdSkLFqFeDhgahnn4WGs2oTERGRG2LA4Eikz0LJNKRi9ED6ecN2jW6odLBw/oknAX3xoKQwIcGw/v3ZVQoabB2M2FJpdRcB3brBr3lzu9WLiIiIyJ44SpIjkQ7O1tyutLkEps+4KlgwvKhXS8Ib06ErKKhSMFLygtsYjMjrjqqsuovsrVsduu5EREREtsQWBkcSFGXd7UpQqTalXBCXvLj/t207eIaFwbNGDcNjWA1V9jKuq2Fcd+U1j6Cg8oMRjUa9HtyvX5XTk6yd8lRuICWsWHciIiIiZ8OAwZE06AGExADpcWX0Y9AYXpftKkEusM2i10ObkqIWs0l+f1kX3Jf3KcFK+vLl6sLbIzAQ9kp50uXkoCAuHoXxceoxa9fO8gOpy3WXICWwW9dK1ZuIiIjIWTFgKMOcOXPUotVqq+/TkI7Mg968PEqSpkTQIM8BDJpZ6Q7PcjfeHDHvz4Zvo0bQXkqF9tIlaFNToU29ZHieegmFal2a6TVdRkb5wUIRF6ZIp27AIyAAnhHh8AqPgFd4uKqb4fFK2VOe16wJjZeX2f0vgm68UV3cFw0ICuLjUBifgIL4eBTGxUGblmbxubMo4CIiIiJyIRq93swrPTeVnp6O0NBQpKWlISQkxH7zMITUMQQLVRhSVVJv/u3cBfqcnNI30GjgFRWFpuvWWpR6I8OOZvz5J85PfKLijX19gbw88yvt4QHPmjXhWasWCk6eVO9V3rbQ6czbbUAAvGrXhnd0NODpiayNGyv8mfpffcUWBiIiInK7a1y2MDgiCQpk6FTjTM/SZ0HSkKowlKpI+/nncoMFIak9lubpy2RmkmYkqUFyt7/U1oYiwYg+NxeFSUnqjr3hsUg56aLhedJFaJNTVACgTUpSS4UuBwsaX18VCBgDAq/a0fCOrg3v2tHwiopWjx7BwaZhUiWQOtavf4V1l74SRERERO6GAYOjkuCgkkOnlibn0CHEv/KqKofcPATZu/cU7wcQFVWloU8lyJCfV6lBJfszlAhGNIGB8JGlQYNy9ykX8tKPQgKJtOUrkDJvXoX1iH7lZdQYPdqiORMsqTsRERGRu2HA4Aakz4GkC0k6j+T4x7z9trootvbkairYeH/21Z2SKxmMSH1Uf4aICGjTM8wKGHwaNqrUBGvWrjsRERGRq2AfBkfsw2BFcpf+7KP/QdamTfCuXx+NFv8ITxsfhy1mejY3bcjS/hfVUXciIiIiR8M+DGSS9PH/VLCg8fND3Q/et3mwIOQC29rDj1ZX2pAt6k5ERETkzDjTswuTkYuS5sxR5dqvvgK/Fi3gzCQtqM77s1VLQlHyXNYzbYiIiIjI+tiHwUXlnz1rmvMg7O67EDq88sOxOhIJCmREJqYNEREREVUPBgwuSGYyPvd/E6FLT4d/u3aIevZZuBKmDRERERFVH6YkuRiZhy/+5VeQd/iwmvBMUnVkngQiIiIiospgwOBiUhcuRNovv6hZj+vMmmWYyZiIiIiIqJIYMLiQnP37Ef/GdFWOnDwJgdd1s3eViIiIiMjJuUXAcPLkSfTp0wctW7ZEmzZtkJWVBVdTmJKCczLkaEEBgm/qj5oPPmjvKhERERGRC3CLTs9jx47F66+/jhtuuAEpKSnw9fWFK9EXFuL85KfUDMU+DRui9owZlZrtmIiIiIjI7QKGQ4cOwdvbWwULombNmnA1F9//ANnbtkETEIC6H34Az6Age1eJiIiIiFyE3VOSNm7ciGHDhiEmJkbdFf/555+v2mbOnDlo2LAh/Pz80K1bN+zYscPs/R89ehRBQUHqPTp27Ijp0w05/q4iY+1aJH/2mSrHvP4afJs1s3eViIiIiMiF2L2FQfoTtGvXDuPGjcOtt9561esLFy7E5MmTMXfuXBUszJ49GwMHDsS///6LyMhItU379u1RWFh41c+uXr1ard+0aRP27dunth80aBC6dOmCm266Cc4u7+RJXHj2OVWuOeZ+hAwZYu8qEREREZGLsXsLw+DBg1X/gpEjR5b6+qxZszB+/Hg88MADqtOyBA4BAQGYP3++aRsJBg4ePHjVIq0WderUQefOnVGvXj3Vd2HIkCFq+7Lk5eUhPT292CIKCgrUowQgxuBE1pVWzs/Ph1arLbWs0+lM71NWWeZSkKVkWch2avvsbMPkbJmZ8O/UCeGTJ6v9C3m/0spSv6LH4WjHVFqZx8TPib97/HvidwS/y/nvE//N5XWE7a6NnCJgKI8c+O7du9G/f3/TOg8PD/V869atZu1DWhMSExNx6dIldZIlBeraa68tc/sZM2YgNDTUtEigIdasWaMe161bpxaxcuVKbN68WZUllWrnzp2qvGjRIuzfv1+VFyxYgMOHD6vyvHnzcOLECVOa1fnz501BUVJSkirPnDkTGRkZ6tilLI/yXMpCtpv17ruIe/El5B87hlx/f9R5bxZOnj2r9i/k/eR9hdRD6iOkfsaUL6m31N9hjmnWLFWWn5f9CNkvj4mfE3/3+PfE7wh+l/PfJ/6by+uIOVa/NjL3WlrROxCpztKlS03Pz58/r9Zt2bKl2HbPPPOMvmvXrmbvd8WKFfrWrVvrW7VqpZ80aVK52+bm5urT0tJMy9mzZ1UdkpKS1OsFBQVqEfn5+aWW8/Ly9IWFhaWWtVqt6X3KKut0OrWULAvZLuHz+frY5i30sa1a61O3bDWtl/0Leb/SylI/qWdpZXsfU1llHhM/J/7u8e+J3xH8Lue/T/w3l9cRuVa/NkpOTlbXuHK9WxGN/A8OQjo9L126FCNGjFDPL1y4oFKKtmzZgu7du5u2mzJlCjZs2IDt27fbvE6SkiQtDWlpaQgJCYG9Ze/Zg9P3j5F2JUQ9/xxq3n+/vatERERERE7Gkmtch05JCg8Ph6enJxISEoqtl+fR0dE2fW9Ji5E+E5LS5CgKL17EeZmcrbAQIUMGI+y+++xdJSIiIiJycQ4dMPj4+KBTp06mfCsh/RDkedEWB1uYMGECYmNjTTn89qYvKMD5SZNV0ODTtAlqv/YaJ2cjIiIiItcfVjUzMxPHjh0zPT958qQaxUgmWKtfv74aUnXMmDFqpKOuXbuqYVVlKFYZNcmV6bVaZO/arQIEr4gIZKxbh+xdu+ARGIi6H3yoHomIiIiIXD5g2LVrF/r06WN6LgGCkCDhyy+/xB133IGLFy/ipZdeQnx8vJpzYdWqVYiKioKrSl+9GgnTZ6AwPv6q12rPnAHfxo3sUi8iIiIicj8O1enZkUgfBllkXNsjR45UW6dnCRZUP4UyPpY6H7yPkAEDbF4PIiIiInJdlnR6ZsBgxZNpjTSkY/36l9qyoGg08IqKQtN1a6Hx9LRpXYj+v73zgJKi6NpwLSw5I7BEyUFJkiSDAhIliAcMSBBUQKIoEtRvUY6Sk4giqKCogIEoApJRRJAsSBYEZAkSJClht/7z3mPPPzM7vdMzXbvs4vucMywd5k51Vd3uuqGqCSGEEHLncseskvRfQ+Ys2BkLQGs5jvMIIYQQQghJCmgwJKNlVTHB2eR5hBBCCCGEuIUGQzJaVhWrIZk8jxBCCCGEELfQYEhGZKxaRUXihXQREfZzGPLmlfMIIYQQQghJCmgwJCMwkTlq6JB/N/yMhn+3cZwTngkhhBBCSFJBgyGZgSVTC0yaKKsheYNt7OeSqoQQQggh5D/14raU8B6GpAZGQZaGDX3e9Iw0JEYWCCGEEEJIUsP3MCSj9zAQQgghhBCSFPA9DIQQQgghhBAjcA4DIYQQQgghxBYaDIQQQgghhBBbaDAkozc9E0IIIYQQktzgpOcgcNIzIYQQQgi50+CkZ0IIIYQQQogRmJJECCGEEEIIsYUGAyGEEEIIIcQWGgyEEEIIIYQQW2gw2MBVkgghhBBCCOEqSUHhKkmEEEIIIeROg6skEUIIIYQQQozAlCRCCCGEEEKILZH2hwjQWnvCNoQQQgghhNwJWGNba6ybEDQYgnD58mX5W6hQIRNtQwghhBBCSLIa62bLli3BcyK0E7PiP0xcXJw6efKkypIli4qIiEhyyw+GyvHjx1XWrFlTlHyWnfXOPpMy9Im6ynpnn0kZ+kRdZb2bBiYAjIX8+fOrVKkSnqXACEMQUIEFCxZUtxPcdBLDYEgK+Sw76519JmXoE3WV9c4+kzL0ibrKejdJsMiCBSc9E0IIIYQQQmyhwUAIIYQQQgixhQZDMiZdunQqOjpa/qY0+Sw76519JmXoE3WV9c4+kzL0ibrKer+dcNIzIYQQQgghxBZGGAghhBBCCCG20GAghBBCCCGE2EKDgRBCCCGEEGILDQZCCCGEEEKILTQYkiHDhg2Tt0p7f8qUKWP0N/744w/11FNPqbvuuktlyJBBlS9fXm3ZssW13CJFisQrOz69evVyLTs2Nla99tprqmjRolLm4sWLq+HDh8ubCk2BNx72799fFS5cWH6jVq1a6ueffw5L1vr161XLli3lDYqogwULFvgcR7n/97//qXz58slvNWrUSB08eNCI7Hnz5qnGjRtL++L4jh07jJX95s2batCgQdJnMmXKJOd06tRJ3ohuouzo/+jvkJ0jRw6pl02bNhkpuz89evSQcyZOnGhEdpcuXeL1/aZNmxor9969e1WrVq3kRTuon2rVqqljx44ZkR9Ib/EZM2aMa9lXrlxRvXv3lpdgoq/fe++9aurUqY7K7UT+6dOnpe5xPGPGjFLnTnVpxIgRUo9ZsmRRefLkUW3atFH79+/3Oeeff/6Rexj0KXPmzOrRRx+V3zQhe9q0aeqBBx6Ql3Hh2i5evOio3E7knz9/XvXp00eVLl1a6v3uu+9Wffv2VX/99ZeRsnfv3l3uw5CdO3du1bp1a7Vv3z4jZfe/VzZr1iyoPociG3Xu39dxPzBZ9o0bN6oGDRqIrqJ969Wrp/7++29Xso8ePWqrq19++aWRsp86dUp17NhR5c2bV8peuXJl9fXXXxuRffjwYfXII49If0GdtG/f3pEugffee09VqFDB8+K6mjVrqqVLl7rWUyeyp7nQ02Dy3ehpUkKDIZlStmxZFRMT4/n88MMPxmRfuHBB1a5dW6VJk0Y67K+//qrGjRsngzO3YHDtXe4VK1bI/nbt2rmWPWrUKFG6d955RwZO2B49erSaPHmyMsUzzzwjZZ41a5b65ZdfZNCNASsMrFC5evWqqlixopoyZUrA4yj722+/LQMnDIhxY27SpInc9NzKxvE6depIHYVDQvKvXbumtm3bJsYb/sI4wUMBA1m3skGpUqWkjVH/6PcwQtEOZ8+eNSLfYv78+eqnn36SQaZTnMjGYNVbB2bPnm1ENh60aFMYU2vXrlW7du2SNkifPr0R+d5lxuejjz6SByMeum5lDxgwQC1btkx9+umnorswymFALFq0yHXZMZjEwOS3335TCxcuVNu3bxeDH3qL7wVj3bp1MshAX4DuwyBGf/P+7gsvvKAWL14sAzKcD+O4bdu2RmRDn9Bnhg4d6qguQpGPcuIzduxYtXv3bjVz5kxph27duhkpe5UqVdSMGTOkTZcvXy5tgXPg3DEh3wIGPfqiqXqxePbZZ336PO7JpuTDWEC7Yv/mzZvl2Yg+nypVKleyCxUqFE9XX3/9dRkgw6gyUXY4gHBPh37iPoy+joE9dMuNbPzFNtpy9erVasOGDerGjRviDIiLiwtadjgcRo4cqbZu3SoOThhjMFL37NnjSk+dyL7mQk+DyXejp0mKJsmO6OhoXbFixUSTP2jQIF2nTh2dFPTr108XL15cx8XFuZbVokUL3bVrV599bdu21R06dNAmuHbtmk6dOrX+5ptvfPZXrlxZv/LKK65kQ9Xmz5/v2UZ95M2bV48ZM8az7+LFizpdunR69uzZrmR7c+TIETm+fft2Y2UPxObNm+W833//3bjsv/76S85buXJlSLITkn/ixAldoEABvXv3bl24cGE9YcIEI7I7d+6sW7duHbIsJ7Ife+wx/dRTT7mWbSffH1xHgwYNjMguW7asfuONN4zolb/8/fv3yz60pUVsbKzOnTu3nj59esjyz5w5I/LWrVvn0cs0adLoL7/80nPO3r175ZyNGze6ku3NmjVr5NiFCxdCLrMT+RZffPGFTps2rb5586Zx2Tt37pRzDh06FJLshOTj3gVdjYmJcdRvncquX7++PJ9MEEh+9erV9auvvpoosv2577774j0b3cjPlCmT/uSTT3zOy5kzZ8j65C97+fLlOlWqVHJPt4B+RURE6BUrVoRV/hw5cugPPvjAqJ76yzatpwnJd6uniQkjDMkUhNPh+SxWrJjq0KGD47QDJ8BrULVqVfH6I2xYqVIlNX36dGUaeA7gUezatWtI3iE7kB60atUqdeDAAdneuXOneKCdeFWccOvWLfGM+XtsESI0GeEBR44ckbAvvKAWSDOpXr26eKZSGgidoo2zZ89uvA8hFIy6gYfZBPBkIdw+cOBAieSZBt5/6BXCyz179lTnzp0zUuYlS5ZI9AVRKMhHX3GSnhEOCOPj90x5uKC7uO8gUocx/5o1a0SP4W10y/Xr1+Wvt97Ci4uXXIWjt1YaQM6cOeUvPILwlHrrKqI8SBsIVVf9ZZvGiXycg5SIyMhIo7LhPUa0ASmj8IKHSiD58Oo++eSTEllCeky42JX9s88+U7ly5VLlypVTQ4YMkd8zIf/MmTMSNYaeou9HRUWp+vXrG+mP/qB/IuU0XF0NJB9lnjt3rqTK4N4zZ84ciXwjJceNbOgqnhPeL7WD3kJfQ60bPKtRLvQ7pPeY1FN/2aaJdSA/XD1NVG63xULi8+2334p1CW/NsmXLdM2aNfXdd9+tL126ZKS64MXGZ8iQIXrbtm36/fff1+nTp9czZ8402hxz584Vj/0ff/xhRB68hoiOwBsRGRkpf9966y1tEtQ1PE8o861bt/SsWbPEI1KqVClXcv09Yxs2bJB9J0+e9DmvXbt2un379q5kJ3WE4e+//xZv8ZNPPmlM9uLFi8XLhTbOnz+/RDDCIZB89JmHHnrIE/UyGWFAdGjhwoV6165dcuyee+7R1apVk77kRrblXc2YMaMeP368tOeIESOkftauXWuk7N6MGjVKvF9oWxOy//nnH92pUyc5Bt2F5+zjjz8OWXYg+Tdu3JD7I3Tn/Pnz+vr163rkyJFyXuPGjUO+xyCSWbt2bc++zz77TMrrD9r15ZdfdiXbpOcymHxw9uxZqauhQ4cakz1lyhTRVZS9dOnSYUUX7OQ/99xzulu3bp7tcCIMdrLx3MPzFbr66aefShTjkUceMVJ2eLRRVnjlP/roI3nO9u/fX/rRgQMHXJfdm549e8p9Jhzs5KMPQncsfc2aNatEB9zKRsQBshDZuXr1qr5y5Yru3bu3/A7a2gloL/Q3jC2yZcumlyxZYkxP7WSb0tNdDuS70dPEhgZDCgAdE0pmF7oKFYTtMDD2pk+fPrpGjRraJLjhPPzww8bkYTBWsGBB+QvFQ8gUN2SThg4edvXq1ZMbApQaNxukPJUpU8aV3DvVYMBgrWXLlrpSpUo+YWa3svEgOXjwoDx4EWovUqSIPn36tGv5W7Zs0VFRUT5GrEmDwZ/Dhw+HlU7lLxvlxb4nnnjC5zzU/eOPP2687Bj44UEeDoFkI/UORveiRYvEETJ58mSdOXPmsNIQAslHuyKN09LbJk2a6GbNmummTZuGJLtHjx7SH44fP27cYAgk26TBEEw+9PP++++XOoHempKNVBAMgpF2gv4I50GohmYg+TC8S5QooS9fvuzKYAhWLxarVq0KK50qkHzr/g6nnDfly5fXgwcPNlZ2pNFi4Dl27NiQyhxMPnQffQX3rR07duhhw4bJ7+C561Y2DI9ixYqJswO6ijRL9Bmc7wQ4BPBsgM6jLnPlyqX37NljRE/tZJvS0+sO5LvR08SGBkMKoWrVqiHdaBIClqu31wa8++674sk1xdGjR8Uzv2DBAmMyYSy88847PvuGDx8ugxvTYMBqDeYxgG/evLkref4POmsg6T+Qh7HSt29fV7KTymDAzaxNmza6QoUK+s8//zQq2x8MHMKJJvnLh2FgPaisD85BX8XDLTHKjofC1KlTXcnGgwaePvR3b/AgrFWrVkiyA8n3Zv369XIcA4Vw8JeNQQ2cFP5zg3APwsDerXz/wSu8mAAP3eeff96x3F69esk95rfffgs4kPQfIOA+imiPG9mmBiLB5CM6DSdRw4YNQx7MOym7dz9FFOzzzz93LR9eaDtdRRTYdNlxz4d8RB3clh3bkIUItTd4ljiNxDopO5xm0C2rz4eCnXwYTP5zggD6Tvfu3Y2VHV50q6/DiTN69OiQr8EqF6ITJvTUTnZizWFo6CffjZ4mBZzDkALAkoRYIQXLb5oAKyT5L3WGfGKsLGIK5LIif7NFixbGZCK/1H+FidSpUztaXSFUsGIR6hsrSmH1D6xmYBLk+SInF3MyLC5duiR5r4mRM2ka5Ipi1QzMtVm5cqUsY5eYoI2tXHU3YO4CVhdCzq/1wVwhzGdAO5vmxIkTMofBre6mTZtWlitMbL0FH374oax+Y2rOCPoKPkmhu5jrguUa0S+xEokTvYUNgtVrsGoWVm6BbnqDusCKct66inbAvLJguhpMtlucyMd9BXNF0Icwj8TpqlrhlP1fJ6QjXQ0mf/DgwfF0FUyYMEGeL6bLbsl3oqvB5GNlN9xXwtHXUMoOXcXqdOjzTgkm35rHEY6+hlJ2zB3BnDechzkfTlfZs3s2uNHTYLITizgv+eHqaZJyuy0WEp8XX3xR8pLhHUZos1GjRuKlDMeLEAjkg8Nb+eabb0p4DKE8eIWQx2kC5C7Cqsd8A5NgBRrkmcJTibqZN2+e1EsoaQHBgHdp6dKl4hn57rvvJM0Bq12EExpEKB2efXygalbuubWSEPKss2fP7sl5x6o0RYsWdeRZCCb73Llzso0cSRyfM2eObCMX3m3ZURetWrUSDxK80JBpfeBhdCMbXj6E8ZGKhCgVQrdPP/20zLnx93iFWzf+hJKSlJBsHHvppZek7OifCOcj1F6yZEnJ4XdbbvR3eBOnTZsmeou0Hnhdv//+e2P1gnA47gXvvfeeI5lOZcMjjJWS4J2Dbs2YMUPmTSGyaUI+5nxBNiJ3iGqiTbGCmhOQA450C9xzvfsyIiMWSJfAPW316tXSJ+EF9E/rDFc2tnEtWIEG14YID7ahw27loz1x/0IqDDzH3ucEm1cTTDbqGlE/1AfaAc8qpCQhTdRJ+qCTugk3qhdMNuoCq3ah7NBV3IORJoMIrxOclB33FKQSY9Ue6CtWTEKfD5by5LReIBMRGDyvQiGYfNzfEdGtW7eu3rRpk5QXKU/4Lbuc+1DKjjkduEdCLiIw6C8DBgxwVHZkWSD1DW2GZya2US48q93oqRPZMS70NJh8N3qalNBgSIZg+cR8+fJJPh4GyNgOZyJZQmBSably5WQghvx8DEJMgRxFKBSWOzQJwnUIU+OGgBsvbvBYltHJIDWUidqQi7rHsqcIrSLNIRys0KX/B4YPwKTb1157TcKxaAeEIZ3WWTDZGJAFOo4le93Kt9KcAn3wPTeyYSxh4iHS49AG0AMYJ6FMeg5WN24MhoRk46GIeTtYzhMDe8h99tln9alTp4yV+8MPP5SHOfo/jNlQUv6cyMdE0AwZMoTc54PJxoOvS5cu0q4oO9IIx40b53i55WDyJ02aJAYs6h33BwzOnN4X7PoydMgC/RLpTZgIDoMKfdSJ8e1ENnQy2DnhyrerN3ygx25kY14N5onkyZNH6h31j3Sbffv2BS2307oJ12AIJvvYsWNiHGCwinsvdGrgwIGO52E5LTsWJkC9oM9g4OrEuHcqG46VQoUKiYMuFJzIx5wUGNxoW5Qdaaf+y6yGKxuORDzz0GfgTAnlPoD5bLiv4tmA+yyemdaA3o2eOpEd7UJPg8l3o6dJSQT+ud1RDkIIIYQQQkjyhHMYCCGEEEIIIbbQYCCEEEIIIYTYQoOBEEIIIYQQYgsNBkIIIYQQQogtNBgIIYQQQgghttBgIIQQQgghhNhCg4EQQgghhBBiCw0GQghJYRw9elRFRESoHTt2qOTCvn37VI0aNVT69OnVfffd5/h7DzzwgOrfv79nu0iRImrixIm3tS7Wrl0rMi9evKhuB126dFFt2rS5Lb9NCCGBoMFACCFhDOgwoBw5cqTP/gULFsj+/yLR0dEqU6ZMav/+/WrVqlVhy/n555/Vc8895/j8QoUKqZiYGFWuXDljg/1atWqJzGzZsqnbwaRJk9TMmTNvy28TQkggaDAQQkgYwJM+atQodeHChTum/m7cuBH2dw8fPqzq1KmjChcurO66666w5eTOnVtlzJjR8fmpU6dWefPmVZGRkcoUadOmFZlJbfzFxsaquLg4MVSyZ8+epL9NCCEJQYOBEELCoFGjRjKoHDFihO05w4YNi5eeg3QbpN34p5+89dZbKioqSgaKb7zxhrp165YaOHCgypkzpypYsKCaMWNGwDQgeMNhvMDDvm7dOp/ju3fvVs2aNVOZM2cW2R07dlR//vmnTzpQ7969JSUoV65cqkmTJgGvA4NYlAnlSJcunVzTsmXLPMcxsN66daucg//jugNx9epV1alTJylPvnz51Lhx4+Kd45+ShGuEIYJrvPfee9XKlSvlNxDN8U9Jwv8ffPBB2Z8jRw7Zj/oFX331lSpfvrzKkCGDGDRoP5QnEP5RCnj70S7Lly9X99xzj5S/adOmEoWww5KxZMkSVaFCBSk/UrbQJhaW3EWLFsm1oW6PHTsWLyUJ7dSnTx9pJ1wX2nL69OlS/qefflplyZJFlShRQi1dujSk9ieEEKfQYCCEkDCAZxuD/MmTJ6sTJ064qsPVq1erkydPqvXr16vx48dLes/DDz8sg8NNmzapHj16qO7du8f7HRgUL774otq+fbuqWbOmatmypTp37pwcw2C3QYMGqlKlSmrLli0ywD99+rRq3769j4yPP/5YPOobNmxQU6dOtU2RweB+7NixateuXWJYtGrVSh08eFCOY+BctmxZKQv+/9JLLwWUg/LCqFm4cKH67rvvZFC9bdu2BD3uGDgj4oB6mDZtmnrllVcSTE/6+uuv5f9IjUJZUHb8feKJJ1TXrl3V3r175Xfbtm2rtNbKKdeuXZPrnzVrlrQTBvZ21+l/zag7pFoheoI2unnzpo9cRKo++OADtWfPHpUnT56ActBOMOo2b94sxkPPnj1Vu3btxGBEHTZu3FgMAsgLpf0JIcQRmhBCSEh07txZt27dWv5fo0YN3bVrV/n//PnzMQL1nBcdHa0rVqzo890JEybowoUL+8jCdmxsrGdf6dKldd26dT3bt27d0pkyZdKzZ8+W7SNHjsjvjBw50nPOzZs3dcGCBfWoUaNke/jw4bpx48Y+v338+HH53v79+2W7fv36ulKlSkGvN3/+/PrNN9/02VetWjX9/PPPe7ZxnbheOy5fvqzTpk2rv/jiC8++c+fO6QwZMuh+/fp59qEuUEdg6dKlOjIyUsfExHiOr1ixQq4Bde1dF9u3b5ftNWvWyPaFCxc839m6davsO3r0aNBrDSRjxowZsn3o0CHPOVOmTNFRUVFBZcyZMyfe9c6dO9dH7o4dO2z7l9VOderUidcfOnbs6NmHOoKsjRs3Om5/QghxCiMMhBDiAniH4f2F5zpc4J1Pler/b8dIH0H6jHc0A2k0Z86c8fkeogoWyOGvWrWqpxw7d+5Ua9askXQU61OmTBnPfAOLKlWqJFi2S5cuSfSjdu3aPvuxHco14zcxR6J69eqefUi3Kl26tO13ECVA1ACpXxb333+/CpWKFSuqhg0bSp3CK490nlDnniDKUbx4cc82Uqr82yMQ3m1kXa93vSG6g5SlYHifY/UH7z6CPgOsMjltf0IIcYK5WWKEEPIfpF69epKiM2TIEE++vAWMAP+0F+90FIs0adL4bCP3PdA+zCVwypUrVyT9BQaNPxjsWmBlozsdDLBXrFihfvzxR0mFQhoZUpuQ5lS0aFFHMgK1RygpTXZgToWTydXB+oglw+ojTtufEEKcwAgDIYS4BMurLl68WG3cuNFnP3LWT5065TOwNPm+gJ9++snzf0ySxsRjTMoFlStXlpx4TCLGhFjvTyhGQtasWVX+/PlljoM32MZEXafAO48BLgbpFvDyHzhwwPY78MYfP35ccu8tMBcgIeCxt+Y/eIMBNaIir7/+usz5wHnz589XiY13G1nXa7VRYmKq/QkhBNBgIIQQlyA1pEOHDurtt9/22Y/Vbc6ePatGjx4taSBTpkyJt5KNGyAPg16sJNSrVy8ZkGJiL8D2+fPnZbIvBtn4fazyg1V1/AfTTibuwlM9d+5cSRMaPHiwGD79+vVzLAMpMd26dRNZmOSNFXwQkfFOxfLnoYceEkOjc+fOMtkaRsqrr74qx+y88ljWFce++eYbqXt42mGkYII6Jv9isvK8efPkWFIM3LFyFN5LYV0vJi4nxUvZTLY/IYTQYCCEEEMDQ/+UIQxI3333XRnYI48eK9w4WVknlMgGPpD9ww8/yPKcGJACKyqAwSFW0IFRg2U5sYxnQoP0QPTt21cNGDBAVkGCHKy4g98qWbJkSHLGjBmj6tatK6kyWNYUy6UmNIcCqURYPhWD/mrVqqlnnnnGs0oSlikNRIECBSSKAKMGef1YNhZREqxs1Lx5c1WqVCkxOrByEZYcTWzQPjCscJ2INiESZUVBEhOT7U8IIRGY+cxqIIQQkhLAIBiGxqFDh3wmISc3sHQr3gmBqA9fwkYISelw0jMhhJBkC1KukM6EaAaMBHjrMRchORsLhBByp0GDgRBCSLLl8uXLatCgQTL3AOlWSGUK9IZoQgghiQdTkgghhBBCCCG2cOYTIYQQQgghxBYaDIQQQgghhBBbaDAQQgghhBBCbKHBQAghhBBCCLGFBgMhhBBCCCHEFhoMhBBCCCGEEFtoMBBCCCGEEEJsocFACCGEEEIIsYUGAyGEEEIIIUTZ8X+pOAwgzQOiAwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -929,7 +1111,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 31, "id": "4f377075-e352-46f9-a716-f1de673a7086", "metadata": {}, "outputs": [], @@ -952,12 +1134,18 @@ "\n", "Just one more thing: none of this would work unless we can efficiently compute *a*(*n* - 1) (mod *n*). How does the `pow` builtin function do it? When *a* and *n* are 24-digit numbers, if we naively tried to compute `a ** (n - 1)`, we'd have two problems: we'd need nearly a billion petabytes to store the result, and we'd need centuries to compute it. The way around these problems is to use [modular exponentiation](https://en.wikipedia.org/wiki/Modular_exponentiation) where we apply the modulus to each intermediate result, and cut the exponent in half each iteration, so we need only do *O*(log *n*) multiplications, not *O*(*n*). That's a big difference: 1024 is a trillion trillion, and log2(1024) is only 80. \n", "\n", - "The key idea is that *b*2*e* is equal to (*b* × *b*)*e*. Here is an implementation:" + "There are two key ides that make this work:\n", + "1) *b*2*e* = (*b* × *b*)*e*\n", + "2) *b*2 (mod *m*) = (*b* (mod *m*))2 (mod *m*)\n", + " - Proof: let *r* = *b* (mod *m*); then *b* = (*km* + *r*) for some integer value of *k*, and:\n", + " - *b*2 (mod *m*) = (*km* + *r*)2 (mod *m*) = ((*km*)2 + 2*kmr* + *r*2) (mod *m*) = *r*2 (mod *m*)\n", + "\n", + "Here is an implementation:" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 32, "id": "e71eb140-7e1a-4146-87a7-8c4eebf61486", "metadata": {}, "outputs": [], @@ -980,7 +1168,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 33, "id": "01838139-52dd-48a0-8f62-bcdef351345e", "metadata": {}, "outputs": [ @@ -988,8 +1176,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 25 μs, sys: 0 ns, total: 25 μs\n", - "Wall time: 27.2 μs\n" + "CPU times: user 23 μs, sys: 1 μs, total: 24 μs\n", + "Wall time: 24.1 μs\n" ] }, { @@ -998,7 +1186,7 @@ "1" ] }, - "execution_count": 28, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" }