diff --git a/s23/Gurmail_lecture_notes/09_Conditionals-2/.ipynb_checkpoints/lec_09_Conditionals_2-checkpoint.ipynb b/s23/Gurmail_lecture_notes/09_Conditionals-2/.ipynb_checkpoints/lec_09_Conditionals_2-checkpoint.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..78c0eae74dda71792bb02a748a8a14351d8d8918
--- /dev/null
+++ b/s23/Gurmail_lecture_notes/09_Conditionals-2/.ipynb_checkpoints/lec_09_Conditionals_2-checkpoint.ipynb
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fcdba72c",
+   "metadata": {},
+   "source": [
+    "# Conditionals 2\n",
+    "\n",
+    "## Readings\n",
+    "\n",
+    "- Parts of Chapter 5 of Think Python\n",
+    "- Chapter 4.6 to end (skip 4.7) of Python for Everybody"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d944b30",
+   "metadata": {},
+   "source": [
+    "## Learning Objectives\n",
+    "\n",
+    "- Read and write nested conditional statements\n",
+    "- Define, state reasons for, and provide examples of refactoring\n",
+    "- Refactor code containing conditional statements into boolean expressions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc7d8729",
+   "metadata": {},
+   "source": [
+    "### Warmup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ab5912f2",
+   "metadata": {},
+   "source": [
+    "What's wrong with this code? "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ececa83c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Yay, go badgers!\n"
+     ]
+    }
+   ],
+   "source": [
+    "team = \"Badgers\"\n",
+    "\n",
+    "# if team == \"Gophers\" or \"Hawkeyes\" or \"Spartans\":  # code with bug\n",
+    "if team == \"Gophers\" or team == \"Hawkeyes\" or team == \"Spartans\": \n",
+    "    # fix: problem == has higher precedence than \"or\"\n",
+    "    # conditions should always be written with expansions\n",
+    "    print(\"Ahh no badgers!\")\n",
+    "else:\n",
+    "    print(\"Yay, go badgers!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f207c28",
+   "metadata": {},
+   "source": [
+    "**Find a partner to do these TODOs**\n",
+    "\n",
+    "TODO: try to compute the boolean expression yourself, by inserting a new cell below. Change team variable's value to all three possible values.\n",
+    "\n",
+    "TODO: fix the expression after your experiments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "30bb2225",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hawkeyes\n"
+     ]
+    }
+   ],
+   "source": [
+    "team = \"Badgers\"\n",
+    "print(team == \"Gophers\" or \"Hawkeyes\" or \"Spartans\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "277df345",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "team = \"Gophers\"\n",
+    "print(team == \"Gophers\" or \"Hawkeyes\" or \"Spartans\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "beeb3adf",
+   "metadata": {},
+   "source": [
+    "## Example 1: Classifying Children by Age\n",
+    "- Chained conditionals:\n",
+    "    - multiple branch within the same conditional\n",
+    "        - connected conditions\n",
+    "    - if conditional branch\n",
+    "    - elif subjective conditional branch(es)\n",
+    "        - elif conditions are subjective to the if condition\n",
+    "        - that is, only when if condition evaluates to `False`, the next elif condition is evaluated\n",
+    "        - only when the first elif condition evaluates to `False`, the second elif condition is evaluated\n",
+    "        - and so on ...\n",
+    "    - else alternate branch\n",
+    "\n",
+    "Age classification:\n",
+    "- \"baby\" 0 to 1\n",
+    "- \"toddler\" 2 to 3\n",
+    "- \"kid\" 4 to 10\n",
+    "- \"tween\" 11 to 12\n",
+    "- \"teen\" 13 to 17\n",
+    "- \"adult\" 18+ (alternate execution)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1cec8460",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter your age: 10\n",
+      "You are a: kid\n"
+     ]
+    }
+   ],
+   "source": [
+    "age = int(input(\"Enter your age: \")) \n",
+    "\n",
+    "def categorize_age(age):\n",
+    "    if 0 <= age <= 1:\n",
+    "        return \"infant\"\n",
+    "    elif 2 <= age <= 3:\n",
+    "        return \"toddler\"\n",
+    "    elif 4 <= age <= 10:\n",
+    "        return \"kid\"\n",
+    "    elif 11 <= age <= 12:\n",
+    "        return \"tween\"\n",
+    "    elif 13 <= age <= 17:\n",
+    "        return \"teen\"\n",
+    "    else:\n",
+    "        return \"adult\"\n",
+    "    \n",
+    "print(\"You are a:\", categorize_age(age))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8fd63040",
+   "metadata": {},
+   "source": [
+    "## Example 2: Date Printer\n",
+    "- converts 2/14/2022 to \"Feb 14th of ‘22\"\n",
+    "- decompose a big problem into appropriate steps, by writing functions for individual components"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7c72488a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def format_month(month):\n",
+    "    \"\"\"Convert a month (as an integer) into a string. \n",
+    "    1 is Jan, 2 is Feb, etc.\"\"\"\n",
+    "    if month == 1:\n",
+    "        return \"Jan\"\n",
+    "    elif month == 2:\n",
+    "        return \"Feb\"\n",
+    "    elif month == 3:\n",
+    "        return \"Mar\"\n",
+    "    elif month == 4:\n",
+    "        return \"Apr\"\n",
+    "    elif month == 5:\n",
+    "        return \"May\"\n",
+    "    elif month == 6:\n",
+    "        return \"Jun\"\n",
+    "    elif month == 7:\n",
+    "        return \"Jul\"\n",
+    "    elif month == 8:\n",
+    "        return \"Aug\"\n",
+    "    elif month == 9:\n",
+    "        return \"Sep\"\n",
+    "    elif month == 10:\n",
+    "        return \"Oct\"\n",
+    "    elif month == 11:\n",
+    "        return \"Nov\"\n",
+    "    elif month == 12:\n",
+    "        return \"Dec\"\n",
+    "    else:\n",
+    "        return \"Invalid month!\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "71bf7f2d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1st\n",
+      "2nd\n",
+      "3rd\n",
+      "11th\n",
+      "21st\n",
+      "111th\n",
+      "error\n"
+     ]
+    }
+   ],
+   "source": [
+    "def format_day(day):\n",
+    "    \"\"\"Covert a day into a date string with proper ending. \n",
+    "    16 --> '16th',    23 --> '23rd', \"\"\"\n",
+    "    suffix = \"\"\n",
+    "    if day < 1:\n",
+    "        suffix = \"error\"\n",
+    "    elif 11 <= day % 100 <= 20:\n",
+    "        suffix = str(day) + \"th\"\n",
+    "    elif day % 10 == 1:\n",
+    "        suffix = str(day) + \"st\"\n",
+    "    elif day % 10 == 2:\n",
+    "        suffix = str(day) + \"nd\"\n",
+    "    elif day % 10 == 3:\n",
+    "        suffix = str(day) + \"rd\"\n",
+    "    else:\n",
+    "        suffix = str(day) + \"th\"\n",
+    "        \n",
+    "    return suffix\n",
+    "\n",
+    "print(format_day(1))\n",
+    "print(format_day(2))\n",
+    "print(format_day(3))\n",
+    "print(format_day(11))\n",
+    "print(format_day(21))\n",
+    "print(format_day(111))\n",
+    "print(format_day(-1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c142acc7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def format_date(month, day, year):\n",
+    "    \"\"\"returns a string representing the date, such as Feb 11th of ‘22\"\"\"\n",
+    "    result_str = \"\"\n",
+    "    result_str += format_month(month)\n",
+    "    result_str += \" \" + format_day(day)\n",
+    "    result_str += \" of '\" + str(year % 100)\n",
+    "    \n",
+    "    return result_str"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e45d4fd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Sep 26th of '22\""
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "format_date(9, 26, 2022)"
+   ]
+  },
+  {
+   "attachments": {
+    "Stoplight.png": {
+     "image/png": "iVBORw0KGgoAAAANSUhEUgAABaIAAAQfCAYAAADhvp7hAAAMa2lDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnluSkJDQAhGQEnoTRHqREkKLICBVsBGSQEKJMSGI2NFFBXtBFCu6KqLoWgBZVMReFsXeF2VRWVkXdVEUlTcpoOu+8r3zfXPnv2fO/KfcmXvvAKDdx5VIclEdAPLE+dL4iBDm+NQ0JukZQAEOKMAZ6HB5MgkrLi4aQBns/y7vbgNE0d9wVnD9c/y/ih5fIOMBgEyEOIMv4+VB3AwAvoknkeYDQFTorabnSxR4HsT6UhggxGsVOEuF9yhwhgo3KW0S49kQXwNAg8rlSrMA0HoI9cwCXhbk0foEsauYLxIDoD0C4kCekMuHWBH7iLy8qQpcAbE9tJdADOMBPhnfcGb9jT9jiJ/LzRrCqryUohEqkklyuTP+z9L8b8nLlQ/6sIWNKpRGxivyhzW8mzM1SoGpEHeLM2JiFbWGuE/EV9UdAJQilEcmqexRE56MDesHGBC78rmhURCbQBwuzo2JVuszMkXhHIjhakELRfmcRIgNIV4skIUlqG22SafGq32hdZlSNkutv8CVKv0qfD2W5ySx1PxvhAKOmh/TKhImpkBMgdi6QJQcA7EWxC6ynIQotc3oIiE7ZtBGKo9XxG8NcbxAHBGi4scKMqXh8Wr70jzZYL7YNqGIE6PGh/KFiZGq+mBneFxl/DAX7JpAzEoa5BHIxkcP5sIXhIapcsdeCMRJCWqePkl+SLxqLk6R5Map7XFLQW6EQm8JsYesIEE9F0/Oh4tTxY9nSvLjElVx4kXZ3DFxqnjwlSAasEEoYAI5bBlgKsgGotbu+m54pxoJB1wgBVlAAHeoSjM4I0U5IobXBFAE/oBIAGRD80KUowJQAPWfh7SqqzPIVI4WKGfkgGcQ54EokAvv5cpZ4iFvyeA3qBH9wzsXNh6MNxc2xfi/1w9qv2pYUBOt1sgHPTK1By2JYcRQYiQxnOiAG+OBuD8eDa/BsLnhPrjvYB5f7QnPCG2Ep4RbhHbCvSmiYul3UY4F7ZA/XF2LjG9rgdtCTk88BA+A7JAZZ+DGwBn3gH5YeBD07Am1bHXciqowv+P+WwbfPA21HdmVjJKHkYPJ9t/P1HLU8hxiUdT62/qoYs0Yqjd7aOR7/+xvqs+HfdT3lthi7DB2HjuFXcSasHrAxE5iDdgV7LgCD62u35Sra9BbvDKeHMgj+oc/rtqnopIy1xrXLtdPqrF8QWG+YuOxp0pmSEVZwnwmC34dBEyOmOcygunm6uYGgOJbo3p9vWUovyEI49JXXfEyAAI8BgYGmr7qorUBOAL3DKXjq87eD74mCgG4sJwnlxaodLjiQoBvCW2404yAGbAC9jAfN+AF/EEwCANjQCxIBKlgMqyyEK5zKZgOZoH5oASUgZVgHdgItoIdYA/YDw6BetAEToFz4DK4Bm6BB3D1dIKXoAe8A/0IgpAQGkJHjBBzxAZxQtwQHyQQCUOikXgkFUlHshAxIkdmIQuQMmQ1shHZjlQjPyHHkFPIRaQNuYc8QbqQN8hHFEOpqD5qitqiI1EflIVGoYnoJDQLnYYWoQvR5WgFWoXuQ+vQU+hl9Bbajr5EezGAaWIMzAJzxnwwNhaLpWGZmBSbg5Vi5VgVVos1wud8A2vHurEPOBGn40zcGa7gSDwJ5+HT8Dn4Unwjvgevw8/gN/AneA/+hUAjmBCcCH4EDmE8IYswnVBCKCfsIhwlnIV7qZPwjkgkMoh2RG+4F1OJ2cSZxKXEzcQDxGZiG7GD2EsikYxITqQAUiyJS8onlZA2kPaRTpKukzpJfRqaGuYabhrhGmkaYo1ijXKNvRonNK5rPNfoJ+uQbch+5FgynzyDvIK8k9xIvkruJPdTdCl2lABKIiWbMp9SQamlnKU8pLzV1NS01PTVHKcp0pynWaF5UPOC5hPND1Q9qiOVTZ1IlVOXU3dTm6n3qG9pNJotLZiWRsunLadV007THtP6tOhaLlocLb7WXK1KrTqt61qvtMnaNtos7cnaRdrl2oe1r2p365B1bHXYOlydOTqVOsd07uj06tJ1R+nG6ubpLtXdq3tR94UeSc9WL0yPr7dQb4feab0OOka3orPpPPoC+k76WXqnPlHfTp+jn61fpr9fv1W/x0DPwMMg2aDQoNLguEE7A2PYMjiMXMYKxiHGbcbHYabDWMMEw5YMqx12fdh7w+GGwYYCw1LDA4a3DD8aMY3CjHKMVhnVGz0yxo0djccZTzfeYnzWuHu4/nD/4bzhpcMPDb9vgpo4msSbzDTZYXLFpNfUzDTCVGK6wfS0abcZwyzYLNtsrdkJsy5zunmguch8rflJ89+ZBkwWM5dZwTzD7LEwsYi0kFtst2i16Le0s0yyLLY8YPnIimLlY5VptdaqxarH2tx6rPUs6xrr+zZkGx8boc16m/M2723tbFNsF9nW276wM7Tj2BXZ1dg9tKfZB9lPs6+yv+lAdPBxyHHY7HDNEXX0dBQ6VjpedUKdvJxETpud2kYQRviOEI+oGnHHmerMci5wrnF+4sJwiXYpdql3eTXSemTayFUjz4/84urpmuu60/XBKL1RY0YVj2oc9cbN0Y3nVul2053mHu4+173B/bWHk4fAY4vHXU+651jPRZ4tnp+9vL2kXrVeXd7W3unem7zv+Oj7xPks9bngS/AN8Z3r2+T7wc/LL9/vkN+f/s7+Of57/V+MthstGL1zdEeAZQA3YHtAeyAzMD1wW2B7kEUQN6gq6GmwVTA/eFfwc5YDK5u1j/UqxDVEGnI05D3bjz2b3RyKhUaEloa2humFJYVtDHscbhmeFV4T3hPhGTEzojmSEBkVuSryDseUw+NUc3rGeI+ZPeZMFDUqIWpj1NNox2hpdONYdOyYsWvGPoyxiRHH1MeCWE7smthHcXZx0+J+HkccFzeuctyz+FHxs+LPJ9ATpiTsTXiXGJK4IvFBkn2SPKklWTt5YnJ18vuU0JTVKe3jR46fPf5yqnGqKLUhjZSWnLYrrXdC2IR1Ezonek4smXh7kt2kwkkXJxtPzp18fIr2FO6Uw+mE9JT0vemfuLHcKm5vBidjU0YPj81bz3vJD+av5XcJAgSrBc8zAzJXZ77ICshak9UlDBKWC7tFbNFG0evsyOyt2e9zYnN25wzkpuQeyNPIS887JtYT54jPTDWbWji1TeIkKZG0T/Obtm5ajzRKukuGyCbJGvL14U/9Fbm9/Af5k4LAgsqCvunJ0w8X6haKC6/McJyxZMbzovCiH2fiM3kzW2ZZzJo/68ls1uztc5A5GXNa5lrNXTi3c17EvD3zKfNz5v9S7Fq8uvivBSkLGheaLpy3sOOHiB9qSrRKpCV3Fvkv2roYXyxa3LrEfcmGJV9K+aWXylzLyss+LeUtvbRs1LKKZQPLM5e3rvBasWUlcaV45e1VQav2rNZdXbS6Y83YNXVrmWtL1/61bsq6i+Ue5VvXU9bL17dXRFc0bLDesHLDp43CjbcqQyoPbDLZtGTT+838zde3BG+p3Wq6tWzrx22ibXe3R2yvq7KtKt9B3FGw49nO5J3nf/T5sXqX8a6yXZ93i3e374nfc6bau7p6r8neFTVojbyma9/Efdf2h+5vqHWu3X6AcaDsIDgoP/j7T+k/3T4UdajlsM/h2iM2RzYdpR8trUPqZtT11Avr2xtSG9qOjTnW0ujfePRnl593N1k0VR43OL7iBOXEwhMDJ4tO9jZLmrtPZZ3qaJnS8uD0+NM3z4w703o26uyFc+HnTp9nnT95IeBC00W/i8cu+Vyqv+x1ue6K55Wjv3j+crTVq7XuqvfVhmu+1xrbRreduB50/dSN0BvnbnJuXr4Vc6vtdtLtu3cm3mm/y7/74l7uvdf3C+73P5j3kPCw9JHOo/LHJo+rfnX49UC7V/vxJ6FPrjxNePqgg9fx8jfZb586Fz6jPSt/bv68+oXbi6au8K5rv0/4vfOl5GV/d8kfun9semX/6sifwX9e6Rnf0/la+nrgzdK3Rm93/+XxV0tvXO/jd3nv+t+X9hn17fng8+H8x5SPz/unfyJ9qvjs8LnxS9SXhwN5AwMSrpSr/BXAYEMzMwF4sxsAWioAdHhuo0xQnQWVgqjOr0oE/hNWnReV4gVALewUv/HsZgAOwmYLG20eAIpf+MRggLq7DzW1yDLd3VRcVHgSIvQNDLw1BYDUCMBn6cBA/+aBgc87YbD3AGiepjqDKoQIzwzblBzXGYXzwHeiOp9+k+P3PVBE4AG+7/8FlTiO10mPo7EAAABcZVhJZk1NACoAAAAIAAQBBgADAAAAAQACAAABEgADAAAAAQABAAABKAADAAAAAQACAACHaQAEAAAAAQAAAD4AAAAAAAKgAgAEAAAAAQAABaKgAwAEAAAAAQAABB8AAAAATEKa0wAAArhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3JlIDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIKICAgICAgICAgICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPHRpZmY6Q29tcHJlc3Npb24+MTwvdGlmZjpDb21wcmVzc2lvbj4KICAgICAgICAgPHRpZmY6UmVzb2x1dGlvblVuaXQ+MjwvdGlmZjpSZXNvbHV0aW9uVW5pdD4KICAgICAgICAgPHRpZmY6T3JpZW50YXRpb24+MTwvdGlmZjpPcmllbnRhdGlvbj4KICAgICAgICAgPHRpZmY6UGhvdG9tZXRyaWNJbnRlcnByZXRhdGlvbj4yPC90aWZmOlBob3RvbWV0cmljSW50ZXJwcmV0YXRpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj4xNDQyPC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjEwNTU8L2V4aWY6UGl4ZWxZRGltZW5zaW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4Kt5BbpAAAQABJREFUeAHs3QW8FNXbwPGHbkFSQkJAAQuULqUkRExQ0kKwMFARAf8CEqKCrSiIohgYYBEqtiCYCIogobSEdNe+84zvvey9dyd2d3bvzu7vfD4Le2fOnDnznY17nznznBwBowgFAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIEYCeSMUbs0iwACCCCAAAIIIIAAAggggAACCCCAAAIIIICAKUAgmhcCAggggAACCCCAAAIIIIAAAggggAACCCCAQEwFCETHlJfGEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBAhE8xpAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQiKkAgeiY8tI4AggggAACCCCAAAIIIIAAAggggAACCCCAAIFoXgMIIIAAAggggAACCCCAAAIIIIAAAggggAACMRUgEB1TXhpHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQIBDNawABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgpgIEomPKS+MIIIAAAggggAACCCCAAAIIIIAAAggggAACBKJ5DSCAAAIIIIAAAggggAACCCCAAAIIIIAAAgjEVIBAdEx5aRwBBBBAAAEEEEAAAQQQQAABBBBAAAEEEECAQDSvAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAIGYChCIjikvjSOAAAIIIIAAAggggAACCCCAAAIIIIAAAggQiOY1gAACCCCAAAIIIIAAAggggAACCCCAAAIIIBBTAQLRMeWlcQQQQAABBBBAAAEEEEAAAQQQQAABBBBAAAEC0bwGEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABBGIqQCA6prw0jgACCCCAAAIIIIAAAggggAACCCCAAAIIIEAgmtcAAggggAACCCCAAAIIIIAAAggggAACCCCAQEwFCETHlJfGEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABBAhE8xpAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQiKkAgeiY8tI4AggggAACCCCAAAIIIIAAAggggAACCCCAAIFoXgMIIIAAAggggAACCCCAAAIIIIAAAggggAACMRUgEB1TXhpHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQQIBDNawABBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAgpgIEomPKS+MIIIAAAggggAACCCCAAAIIIIAAAgggkMgCf/31l9xxxx1Sq1YtKVCggPmoUaOG9OvXT1asWJHIXfdV33IEjOKrHtNZBBBAAAEEEEAAAQQQQAABBBBAAAEEEEDAA4H3339funbtKvv37w/ZWr58+eTVV1+Vzp07h1zPQvcCBKLdW1ETAQQQQAABBBBAAAEEEEAAAQQQQAABBJJEYM+ePVK+fHnZtWuX7REVKlRI1q1bJ8WKFbOtx0p7gdz2q1mLAAIIIIAAAggggAACCCCAAAIIIIAAAgj4S2Dt2rXy8MMPy+7duy07vn37dscgtG68d+9e6dGjh5QsWdKyrXLlysngwYNFg9aU0AIEokO7sBQBBBBAAAEEEEAAAQQQQAABBBBAAAEEfCpw7733yhtvvOFZ72fMmOHY1gknnCADBw50rJeqFZisMFXPPMeNAAIIIIAAAggggAACCCCAAAIIIIBAkgps3bo17ke2ZcuWuO/TTzskEO2ns0VfEUAAAQQQQAABBBBAAAEEEEAAAQQQQAABHwoQiPbhSaPLCCCAAAIIIIAAAggggAACCCCAAAIIIICAnwTIEe2ns0VfEUAAAQQQQAABBBBAAAEEEEAAAQQQSFGB9957T7Zt22Z79A0bNpRatWrZ1on1ylmzZsmff/5pu5tSpUpJt27dbOsk20oC0cl2RjkeBBBAAAEEEEAAAQQQQAABBBBAAAEEklCgT58+4pSH+Yknnsj2QPTkyZNl6tSptmegdOnSKReIJjWH7UuClQgggAACCCCAAAIIIIAAAggggAACCCCQCALt27ePSTdq1qwpjz32mPz++++yZ88e2b17t/z2228yduxYOfXUU2Oyzw4dOsSk3URulEB0Ip8d+oYAAggggAACCCCAAAIIIIAAAggggAACpkCnTp08lcidO7cZbF68eLHccccd5kjqQoUKSeHCheX000+X/v37m8HpMWPGSK5cuTzdt9fH4mnnYtQYgegYwdIsAggggAACCCCAAAIIIIAAAggggAACCHgn0LZtW8mbN68nDWpgedq0aWaw2S7IrMHqAQMGyFtvvSU5c3oTSs2XL59ccMEFnhyHnxrxRs9PR0xfEUAAAQQQQAABBBBAAAEEEEAAAQQQQMB3AjpSuUWLFp70e9iwYXLRRRe5buuyyy6TIUOGuK5vV7Fly5aiI69TrRCITrUzzvEigAACCCCAAAIIIIAAAggggAACCCDgUwEvUlpUrFhR7r777rAFBg4cKOXKlQt7u8wbeHEMmdv0w88Eov1wlugjAggggAACCCCAAAIIIIAAAggggAACCIQ1itmKq1evXqLpMcItBQoUkB49eoS7WZb6HTt2zLIsFRYQiE6Fs8wxIoAAAggggAACCCCAAAIIIIAAAgggkAQCJ598stSuXTuqI2ndunXE27dp0ybibXXDc845RypUqBBVG37dmEC0X88c/UYAAQQQQAABBBBAAAEEEEAAAQQQQCAFBaJNbaHB7EhLNNvqPqPte6T9ToTtCEQnwlmgDwgggAACCCCAAAIIIIAAAggggAACCCDgSiCcSQZDNRgIBEItjsuyaPsel07GaCcEomMES7MIIIAAAggggAACCCCAAAIIIIAAAggg4L1A3bp1o5o0cO3atRF3as2aNRFvqyk5NDVHqhYC0al65jluBBBAAAEEEEAAAQQQQAABBBBAAAEEfCoQzcjiTz/9NOKjjmbbVJ2kMA2bQHSaBP8jgAACCCCAAAIIIIAAAggggAACCCCAgC8EoglEv/LKK3LgwIGwj3Pfvn0yZcqUsLdL2yCV80OrAYHotFcC/yOAAAIIIIAAAggggAACCCCAAAIIIICALwRatWolBQsWjKiv69atkzFjxoS97ejRo2Xjxo1hb6cbFCpUSFq2bBnRtsmyEYHoZDmTHAcCCCCAAAIIIIAAAggggAACCCCAAAIpIpA/f35p06ZNxEc7fPhwmT59uuvt33nnHRk5cqTr+pkrXnDBBZIvX77Mi1Pq59wpdbQcLAIIIIBAUgrojMd6VXrbtm2yfft22blzp+TOnVtOPPFE81G8eHEpWbJkUh47B4UAAggggAACCCCAAAIIpKqAprp4//33Izr8Y8eOSefOnc3g8l133WX+DRmqocOHD8sjjzwi999/v+jfnpGWVE/LoW4EoiN99STIdhs2bJA9e/YkRG9Kly4txYoVS4i+0AkEvBLYvHmz7Nixw7K5smXLSpEiRSzXsyI2AvoLw1dffSUzZ86Un3/+2XzYnSftRalSpaR+/frmQ2+Hatq0aWw6R6sJJeDFe9iLNhIKJURndOZvuxx5VapUkTx58oTYkkUIIIAAAggggAACCGSfgE7+lzNnTtG/ESMpR48elYEDB8qLL74oN9xwg7Rt21YqVqxoBpz1d+SPP/5YJkyYICtWrIik+fRttI8XXnhh+s+p+oRAtI/P/Nq1a6VSpUpRXY3x8vCffvppueWWW7xskrYQyFYB/UKqUKGC6NVPqzJ16lTp0qWL1WqWeyygebyefPJJeeONN0Sfh1O2bNkiM2bMMB8PPPCAVK9eXa6//nq55pprpEyZMuE0RV2fCHjxHvaijUTn+umnn6Ru3bq23Vy1apVoMJqCAAIIIIAAAggggEAiCeigSB1wNH/+/Ki6tXz5chkwYID5iKohi40bNmxoDo6yWJ0yiwlE+/hUHzlyJGGC0D5mpOsIWAroLTd2QWjLDVnhucD+/fvNW6F0MgmdpdiLor9o6JXvESNGyIMPPij9+vWTXLlyedE0bSSIgBfvYS/aSBAOy27wOWdJwwoEEEAAAQQQQAABHwi88MILMnfu3PSeNmnSJP15dj3p27dvhvzVjRs3zq6uJNR+CUQn1OmgMwgggAACmQWWLl1q3sKkIzJjUTS90Z133imvvvqqTJkyRWrWrBnRbubMmSMHDx603LZWrVqMKLXUYQUCzgK8x5yNqIEAAggggAACCKSiwJlnnin6SKTSokUL0QclowCB6Iwe/IQAAgggkEAC3377rVx88cXmJISx7pbmmm7evLl88sknUqdOnbB316NHD9m0aZPlduPGjTMD3pYVWIEAArYCvMdseViJAAIIIIAAAggggEDCC+RM+B7SQQQQQACBlBRYuHCheSvTtm3b4nb8W7duFZ3I8Pvvv4/bPtkRAggggAACCCCAAAIIIIAAAqkgQCA6Fc4yx4gAAgj4TEDzQHft2lUOHDgQ957v2LFDrrjiCtm1a1fc980OEUAAAQQQQAABBBBAAAEEEEhWAVJzJOuZ5bgQQAABHwvcc889ormh3ZaiRYvKJZdcIqeffrqUK1dO9OfNmzfL6tWrzceCBQvCam/t2rVy9913i056QUEAAQQQQAABBBBAAAEEEEAAgegFCERHb5jwLdSrVy8ufSxdunRc9sNOEEAguQW2b98ukyZNcnWQGngeOnSodOzYUfLnz2+5TSAQkNmzZ8vYsWPls88+s6wXvGLChAly9dVXSyLMuBzcL57HVyBHjhxi9z1aoEABadiwYXw7xd4QQAABBBBAAAEEEEAAAR8KEIj24UkLp8samCHXaThi1EUAgewWmDJliquUHM2aNZMPPvhAihUr5thlDSa2b9/efMycOdOcAPHIkSOO202cOJFAtKNSclfIlSsX36PJfYo5OgQQQAABBBBAAAEEEIiTADmi4wTNbhBAAAEE3Am8+uqrjhUbN24sn3zyiasgdObGOnToIE8//XTmxSF/fvfdd2X//v0h17EQAQQQQAABBBBAAAEEEEAAAQTcCxCIdm9FTQQQQACBOAgsW7bMcS/Dhg2zTcXh1EDfvn2lX79+TtVk9+7doiOoKQgggAACCCCAAAIIIIAAAgggEJ0Agejo/NgaAQQQQMBDgV27dok+7ErOnDnlvPPOs6viat3tt9/uqp6bwLirhqiEAAIIIIAAAggggAACCCCAQAoLkCM6hU8+h+4ssGLFClm9erVs3LhR/vnnn/T/d+7cKSVLlpTy5cunPypUqCC1a9cWzSca73L06FH5+uuvRfu7Zs0a87Ft2zYpVaqUnHzyyVKpUiVp27at2Ve3fTt8+LB8+umnZpvr1q0TfezZs0f0OKtWrZrhUbBgQbfNelLvl19+kXnz5smGDRvMx9atW6Vw4cJy0kknmY+yZctK8+bNpXLlyp7sL16N6DmbM2eOrF271nyt6fHpiFw9j+qu57JKlSrmseXNmzde3YrrfvR15lQ0EO3F+0xfx+XKlTNfQ3b7XL9+vd3qbF+n7//vvvtOFi9eLJs3bzYfmzZtkkOHDpmfUzqRrD4qVqwoLVu2lOLFi2d7n5P1PRwNrH6vaLqZv//+O/39v3fvXilTpoz5/tfzd8EFF5jPo9mP19v++eefMnfuXPO7Ur8v9fNYP4urV6+e/tD3mk7qSEEAAQQQQAABBBBAIFoBjW3o3z12ZcCAAdK1a1e7KjFfN3DgQPn4449t96O/N8+aNcu2TrKtJBCdbGc0gY5n8ODB8u233zr2aPTo0aL5XsMtemv90qVLbTfTCcr0jZ8vXz7besErNeD82muvySuvvCKLFi0KXuX4XINa1157rVx33XVyyimnONbPXEGDcL1797bMSVuvXj159NFH0zfTYJNOpvbCCy+Ywef0FSGeaPCudevWZvudO3cOUeO/RRrIHj9+vEyaNEm0faeiwYX+/fvLvffeK0WKFHGqnr7+2LFjcuWVV1p+gZxwwgny4YcfptfXiwGPP/64vPPOO7Jq1ar05XZPzj33XLniiiukV69eZsDRrm52rdP8w1OnTpW33nrLDELrBQCnUqJECfNL9eqrr5a6des6VbdcHwgERB9ORV878SoaeHMqOsngypUrzSCXU12n9XrB4s0337StphcEgsvIkSPNgGHwMn2uFxLsiualfu+990JWueWWW6RLly4h14VaqO+fadOmyfTp02X27NmO+05rQwP4jRo1ko4dO4q+fvQXn0hLqryHnY5T/YYOHSotWrQIm1Lb1s+0119/3TyPBw8etG1Dv9P0boBrrrnG/FzTn7Xo9s8//7zltnoh4u2337ZcH+4KfQ9qv/W754svvnDcXPup3ztjxoyRyi4uECbCe8zxoKiAAAIIIIAAAgggkC0CGoReuHCh7b63bNliu95qpQ74atiwoTmYT/9W1oEW8+fPFzd/p2duUweYOPWzfv36mTdL/p8NWIpPBYxgnEaQbB/58+fPtqN7+OGHbfuW1vdq1aoFjOBTWP186qmnXLVt3Hrvul0jYB1o3759wAjUuGo7rf+h/jf+6A60atUqYPyB7nr/WtEY1Wi7b2M0XHp72t8TTzzRtn6ovumyq666KmCMbk5vK+2JEZALGMHkiNo0Ru0GjEBbwBiFmdac7f/GB7ntfoxRm+nbGxcGIj5WPV49pnHjxgWM4El6m26eOPVR2zaCyG6aClnno48+ChgjnG0drM5h2nLjanDAuHgQsn2nhcZFD1f7Vrt4FeNCkKs+GQEtT7pkBPACRjDf9nHDDTdk2JcRvHbVx7Rz5Ob/sWPHZtiH3Q8zZswInHnmmVH3oVChQoEHHnggYIy6t9ud5Tqn90eyvIedjlPPbySfAz///HOgQYMGEZ9H48JiwLhAZ56fhx56yLYd424Ky/OoK5y+e/QY9XcOLcZFoIDxC7Pt/qxe8/o7yX333ef4msvu95h5oPyDAAIIIIAAAgggkJAC999/v+Pvok888YTZ9zZt2jjW1d9d9W8X/bvXuEsxyzHv2LEjoPGtYsWKuWrLGKhntmEMvHOsP2LEiCz7S/YFOhqO4lOBRA9EGyO9Aho4tfqDNHj5rbfe6vos/PbbbwH9YzZ4+1DPzznnnIAxusyxXeO2dvMPYw0eh2onmmXG1bSAMQLSsQ9pFZyCAWmBaA1aRRswr1WrVsC4kmjuWg2Mids8Of5OnToFtD2n4hTcSQtiGSPMPemXnsezzz47sHz5cqeupa936qO2GUkAavv27YGLL77Ys+MyRo8HjJHx6f12+yQRA9Hadw2QOr3v9DPg999/d3uontbLriCZkfLA9Weqk1/weiP1Q8CYkDFsI6f3R7K8h52OM5LPAf3lOdrPcN2vXgD86aefAvEKRBujqiO+WBn8mjNG4gf0u9yqZNd7zKo/LEcAAQQQQAABBBBIHIEffvjB8e/FcALRderUCRjpMR0P0Bjh7GpAUDiBaOMufMf9JluF+N1vbfwFQkktAb0VV9NbaH5Lp/LMM8/I559/7lRN9Lbl7t27y4EDB2zraooITXfglEdXb4u+/PLLRdODGG9u2zYjWak5WvV25HfffTeSzUNuM2XKFLnrrrtE88JGU5YsWWKm09A27rzzTjFGmUfTXPq2H3zwgRhBlvSfo3ny7LPPyksvvRRNExm2/fXXX+X8888XIxidYXk8f9B0J9qH999/37Pd6uR+mtLFuKDjWZvZ2ZCbtDb6GaD5jo3RwdnZ1bjtW1+zeouY5hD2uuhr8qKLLjJT8njddjK+h6Mx0u8ZTcPy4IMPRv0Zrv3QWw41952blDbR9Fu31XkIunXrZuatj7YtTYF14YUXmnMvRNsW2yOAAAIIIIAAAgikloCmp9S0qF4U/dtT52nSOZmcis699dlnn5lpO5zqulmv7Rl3urqpmlR1CEQn1elMvIPRILQGozUobVf0j3PNrawBNbsyaNAg0WCiU3nuuefESPnhVM0MmFrlbHXc2GUFYzSdGKkwzHyaLjexrGbcyi19+vSxXB/uipdfftnM0/zkk0+Gu6ltfWPEdtQBBs23q7mnvS468ZwGgnVix3gXnYSwWbNmrl7DkfRNL+horm6/F81h7KZoAFVzHWuu8S+//DImF5Pc9CPWdXRiPzWJ5WtWL2zddNNN8r///c+zw0nG93C0ODq3gQbnvSw6WaAGtmNdNC+1fp95VTTfnl5UpSCAAAIIIIAAAgggEK6A/h3oRdF4lXEnp+umjDsSPRssZ9xN7nq/yVSRQHQync0EPRYjnYTcc889jr3TSfJ0ZK5V+fTTT+Wxxx6zWp2+XAPaOmraqWjgatSoUU7VPFmvEzsZ+apF/4+mGLfmW05kGEm7egFAJ8nzuujIdS9GWDtN3BVpv3XyuR49eoiOiI9X0XOvEyfGejS2kbtK9OHnosH03Lndz6Wrr2GdKK569erm+0xHSRs50P1MkN53vTind1X8+++/6cti+UQDml5enEum93C07jqh4IQJE6JtJqm214lC//jjj6Q6Jg4GAQQQQAABBBBAIPYCXgRxNVbVpEmTsDurf3vq4LZoixfHEG0fsmN793/pZ0fv2GfUAhpo1FGDsSo5c+YUvSLkVIwE7OaIxe+//9626qRJk+Syyy4zb9kNrqhBGB2NpcdjV2rUqCHGhHl2VdLXuQ3W6THq1Ta9Jbly5cpiTPokRn5aMfL8ytKlS8XIrWqmWdCRtnZFg5/Tpk2TLl262FULe5326eqrrxadbbVmzZrmrdraL/0Df9asWWG3pxucdtpp5ijTs846y7xVpGjRouYI59mzZ5sBZqdj1Ta07siRI/Wpp6V06dJmQFc/tKtWrSrGhAGiIy81wGtMamgauwl+LViwQHQk+B133OFp/6waGzZsmDi9/nVbtb7kkkvEyHEuRq4qM7WNkUvVnKlXL54Y+bCsdpG+fMiQIWaqBX09+LHo7VG9evUS/TwIpxiTqJnnVM9rnjx5zFQWxuQUoo969eqJkZM3nOYs6+pnUaj0IXqHgV3RPpx++ukhq1gt15QrelxuSvny5c07S/QXqrTPKWMyOzHyjplX7b/66is3zZht6GtPbxWLRfHrezgaC/3M1JQcbkqBAgXMdBs60t+YzFSMSWlFL0LqZ5xedJk+fXpcUnE49TVfvnxmaiu9NVIf+prTuz70+0dTKhlzHjg1YV4M1LqZv4/j+R5z7CQVEEAAAQQQQAABBBJOoFWrVlKwYEHZt29fxH3TAT+RFo3r6N/nkRZjnic577zzIt3c39sZgT2KTwXcTFZovDo1chvTh5H/2JWgEUwJ6KRqTv0pW7ZswAg8Z2jz0ksvddxOJy8z0nZk2M7qB2MEVsDN5ITGVa7AX3/9ZdVM+nKdWdXId+nYR+PW9/RtQj1xmqwws52R8iOgM7iGKjpZ5KOPPhr2hFhqbYzCDNWkuUzPoxFwcDxWnYhr9+7dlu24mQAs+HiNCwLmhIp2fdOd6fvCGBnr2D9tWyfFMwJEUfXRzWSFRtDb1XkwvkwDxp0Blv3RFTrpgk6CGWwT6rnxpWbbjq5M1MkKtW/6OjMCXY7HGerYQy3Tzx7j4oXpF6tJDnXSv1D7TlumszCHU9555x3b9tLa1f+Nu0kCxqh72+aNQLTrmZ7btWtn25auTJX3sJvjdPocMC5kujqXOomscdHS1t5I0RIwUk+5ai/tNaKf2XYl3O8e3b9OkmhVdMJaI7js6rPq3HPPtWomy3Kv32NZdsACBBBAAAEEEEAAAd8IXHzxxZa/E7uZrNBIfRrxserf+Gm/a2f+381khUYgO+J9+31DUnMYrxhKdALGzKGuGtARhOPHj3esqyP4gidd01uZdQSYUzGCPKIjeN0UTUZvvHltq+rEYB9++KE5Ctq2orFSr2bpJH1OV7Q0/YhXRdOKvPHGG+YI2lBtal5uzb+p6SDcFs0RqxMr6mSPVkXPo17505HIdkVzznp5y7Xm/daRrnZ90/7oCMJvv/1WjOCGXffMdTrB18SJEx3rRVvBaWIyPVeadkbTz+ioQrty2223ydy5c6VixYp21URHv2oqAL8WfZ1p/70axawpLvQ9qilydPSxTm7Rs2dPM4e9fuYkYnnooYccu6WvHR1Nqp9/TlbNmzeXb775RnTktFPROxoWLlzoVC2s9X5+D4d1oJkqr1u3zlUKpDPOOEO++OILMS7GZmoh4496J4iONm7QoEHGFXH6yfiFX3S+Ar1rw6ronUSakqtfv35WVdKXaw70/fv3p//MEwQQQAABBBBAAAEE3AhEm9rCzd39Vv2IZlttUyeLT9VCIDpVz3w2HXfXrl3luuuuc9y7BliN0YCikzDZ5Y1Oa+jyyy83J9pK+9np/yVLljhVkSlTpkjhwoUd66VV0D+8nYK+blJapLVn97/eNu92UjoNXLopepv10KFDHSeW1LY0SKi3/zsVTV/iRbn77rvDmqRRb/3XgI7mbnIqL774YkxzRetrTXMW2xVNv6ApQjSo6KbobfCahsSpeJGn22kfsVyvaXr0OI2R657vRoPP+h7XtDYa/Nec4V5eOIm2w/r6/fHHH22b0TzakydPdpWDP60hDXbOmzdPNI2RU8mcLsGpvt16P7+H7Y7LzTpNF+U0P4BeRNVzrp9dbkrJkiXl888/l6ZNm7qp7lkd3a+moHG6IJi2Q/2ecvoe1Vz9W7ZsSduE/xFAAAEEEEAAAQQQcCVg3JUuGoeJtEQTr4hmWx1A1KFDh0i77fvtIj9jvj90DiC7BHRUq5sgiAbnWrdu7ZgLs7KRIzncUa1OgWjtn446C7c4BQWcghFu9qfBSg1suP3Abdy4sZx00kmOTevoULdBEG1MczI5FSNtiFMVx/Wa92ngwIGO9TJX0ECJBkycJr3TUeoff/xx5s09+1lHqtqNvteRuY888kjY+9PXmp4zuzJ//nzbyRH1Na6vD7tHs2bNzBzLdvuJ5TrNk6t5sWvXrh2z3ejofQ14a5DWSHcjmpM7u4ubXPd6/p1eA6GOQ0fT6wUYp6L5iDdv3uxUzXG939/DjgfoUEE/h5yKXjTSIG84RV2HDx8eziZR19W7O5zuhgneiY4U0QvQTiVek3E69YP1CCCAAAIIIIAAAv4RMNK2mXNlRdpjp7iQXbvRbKt/yxcvXtyu+aRex2SFSX16E/PgdHSjTqSntxXbTSpn5F0WfdgVDTLq6Olw/jDW9jSIauTitGw6kplTtTGdUMquuB3xateGpv/QwGE4pUKFCuZkg3bbaOA/nOKUhkTb0tQX0ZYbbrhBSpQoEVEzGnDTwKKOfLUrn332mbRv396uSkTrNAD9/vvv226rgWqdoDCSoiNWNW3Nnj17LDd/5ZVXRINHoYoG+CMJ8odqK5bLdNJFTQWggVEdta+TocWi6MhMI9eveTeGBqY1CJ4dRfuho13tin6WaOqdSIt+hjRq1Mh2QjkN0GsanmgnWPXzezhS37TtdJS904TBOjmspk2JpOhdH3qHjKa3iHXRfuq5DLe4mTRVU+dQEEAAAQQQQAABBBAIV0DTc+gArEiK/i0d6d987733XiS7NLdJ5bQcCsCI6IhfOmwYjcDZZ58txkR60TRhbjtixAjRXM7hlvvvv1+effZZy0f37t3DbdIMuj7wwAO229mNjLXdMGil2zzYQZuY+XCDfw713Jh8KtRiy2Xhjt6zbMhmRZ48eaIKtmnTmqfUqUT6xeXU7uLFi20vTugtOR07dnRqxnK9jnR3uiDw0UcfWW7vpxUaeNVfEjSwZ0wMYZ5XTRETi6IBWP0M0KB0dhTNzex0N4ExmaCZ6zqa/mm6DKeigehoit/fw9Ecu27rxi+S4G5wv9ykrwquH+lz/axxykMeqm1j8thQizMs8+K7MUOD/IAAAggggAACCCCQEgLRBHV1fqxly5aF7aSjoaMJREeb2zrsDifYBgSiE+yEpFJ3dELCaN6Abdu2lQEDBmQ7mabb0EkYNZCruVdjXexGclvt2ynlRoECBcIedazbxLroKGWnyfuc+qCBe32t2BUdbXv48GG7KhGtcxrVqucy2vzHThdidPSwjrBNplK/fn1zgr6VK1fKihUrzPef5mf38vam7AxGuwleugkiO53zSy65xDEFkZu+2O3H7+9hu2Nzs04nFbQrefPmNfOU29VxWqd3fWg7sS46yWckJdyLnJHsg20QQAABBBBAAAEEUlNA0ytWqVIlooPXWI7OYXbo0CHX2+td/bqN/r0YSdE0sG4GakTStl+2ye2XjtLPyAQ0dYWXE06F6oXTiMxQ26QtmzRpkpn7dd26dWmLXP2vI0E15YAXqS5c7dCopB84Gvhavny5OYni77//buaS1ath+/fvd9tM1PUiCQY4jWIrX7582P3Knz9/2NuEu8Gpp54a7iYh6+tr1C4PtJ4/PbducpeH3IHFQqfJ5nQU4KeffmqxtbvFu3fvtq144MAB89iS9ctO81zro2/fvmbAXVMU6KRv+vjmm2/EyccOT3+50F8yNP2B08Ucu3bCXed0VV4/1yNN5RDcF80zr8emr32rohPG6us00s9av7+HrVzcLtdJMe2KvnajvbtER53rBTu782jXB7fr9Jf8SEqkqYci2RfbIIAAAggggAACCKSegI6K1rnIIik6mFDvvNXUjDoHi13R1KM6/4neoRtpiWYEd6T7TLTtCEQn2hnxuD8asIjXbbuRdF1z/2r+Xs3Z7PaKkgZPdJtYBYb0lnidrExTAAQ/1q5dmxAjS3VyO6+Lm8kMM+9Tz4OOwgvn6mHmNpx+rlSpklMVV+vdpHCIxWRZThO96evsggsucHUM0VTSiyXJGogOdtHX5Lnnnms+dMSwXuH+/vvv5ZNPPjED/voLg9vPmbR29+3bZ04mGcmEkmlthPu/U655zfmun+1eFKfRA+qln4knnnhiRLvz+3s4ooMO2sjpXEZyETCo+fSnOmlvrAPRXp3L9E7zBAEEEEAAAQQQQAABDwT0TvtIA9G6e02zoXfd6vxNVn+fz549W/r372/GiKLpcjRZAaLZbyJt681fsol0RPTFdwI6WnXIkCEybNgwV32/9tprzcC1q8ouK2mwZdasWaIjtDWnbizSNLjsimO1SEcm2jWsAbxISiz6EtwPrwIfbgLR27dvD961J8+3bNniSTvRNpKqE4FpsFYn5dPH0KFDRS826IQUb7/9tsyZM8f1haXnnnvOTANUqlSpaE+Fq+2dLoo4BY9d7eT/K7lpS4OpfghEx+I9HI5lqLpOgWi9qOBF0UB0rEuk3xOx7hftI4AAAggggAACCKS2gN4tqnfh7dy5M2IIveNdU3pq7ED/r1ixonln6Jo1a8y7q//666+I207bUAdi6oTxqV4iiz6luhrH77mA1VWnUDvSUaQ60tGLordWDBo0yLytWW+R0CBVIgehvThmP7XhVSDaTbAtFkEspyBUvM5Fvnz54rWrhN6PfvH37t3b/EXiq6++csyPnHYw+jmhweh4FafXjZdBRzdtOQXG7Vz8/h62OzY365zuGPHqDpdixYq56Q51EEAAAQQQQAABBBBIOgFNVde5c2dPjmvVqlXm33733XefGSvS+cAiDUJritTgR7du3SKa/NuTA0ugRghEJ9DJSNWuaA7XXr16uT58vb1++PDhrutbVdRczzrR2+jRo8Upj6dVG8HLnfIJBdfluTsB/ULxohQpUsSxGc0B7nVJlIsaBKKzntmmTZvKr7/+agams67NuuSnn37KujBGS5wml/TqfaHdd5Piw6k/dgxe9TW73sN2x+ZmnVO/nQLVbvahdZzSALlth3oIIIAAAggggAACCPhRYMKECeYIZp3fRh+33XZbth+G5p3WQZRpj2jSh2T7wXjYAVJzeIhJU5EJ3HrrrWHnthw1apR5u0STJk0i2qmOOGzZsqWEO0li8M4KFy4s1apVM3Pv6q0gPXr0kDFjxshDDz0UXC3D81inssiwsyT4QW+DqVmzZtRH4uY8n3DCCVHvJ3MDOkpx06ZNmRfH/ecCBQrEfZ/h7lDT43To0MHxdirNzeXV6M9ChQrJ888/b+aRXrRokW2XddK+eJXixYvb7mr16tW268NZqe8xp+LUH7vt/f4etjs2N+ucXqt///23m2Yc67g5j46NUAEBBBBAAAEEEEAAAQQQiLEAgegYA9O8vcAbb7whr7zyin2lEGs1aKWBXx3RGEkAUUdguwlO6q7z588vDRo0EA1616hRw7ydXwPQsZosMcThpuwivS3Gi6ITTToVp4CR0/ah1jsF8PR1FI8rtXqhJNGL5p/98ssvHSe/1LsXvDxXul/NUd+lSxdbIp0ITq9kuxlBbNuQi5WaQsSueBW81H24uc3MqT92ffX7e9ju2Nys01x1dsWrc+nmM86uH6xDAAEEEEAAAQQQQAABBOIhQCA6HsrsI6SAjuq76aabQq5zs1D/gL/55ptlypQpbqqn1/nhhx/MiQnTF1g8Ofnkk0XzAunkiBqMpsRfwE2QzE2v3Fx0iHQyNrv9OwXwzjrrLOnXr59dEymzTu8W0Hy5ToE5DUR7MUo+GPbMM88M/jHkc02z8s8//4hXk8uF3Mn/LyxZsqTdatHPTr3dzIs7LJzeY7oPpwsqdp11at9u2+B12fUeDu5DJM+dckB7EajXHOZufCLpP9sggAACCCCAAAIIIIAAAl4KkCPaS03aci2gI5q7d+/ueBu+U4Oac0cf4ZSXXnrJsXrjxo1Fb8XXQDlBaEeumFVYsWKFJ20vXrzYsR03k7Y5NpKpQvny5TMtyfij5imnHBdwE+T94osvjm/g0bNSpUq5aimSuy9cNZypks7QbFcOHDggbl7Tdm2krfvxxx/Tnob8X1/DOsFGpMXv7+FIjzttuzp16qQ9Dfn/tm3b5Ouvvw65zu3C119/3fFOArdtUQ8BBBBAAAEEEEAAAQQQiKUAgehY6tK2pcCIESNk7ty5lut1hU6w5ia3rY6KdhpFGbyjTz75JPjHLM/Lli0r06ZNiygArQF2incCs2bNinoiSZ2E0Onigwb+3AYjwzm6Ro0a2VbXIJ2me6D8J+AmEP3OO+94zrVs2TLHNnXSuXgFot2kUnniiScc++xU4bvvvjPzY9vVc9MXu+39/h62OzY365wC0drG2LFj3TRlWee5556zXMcKBBBAAAEEEEAAAQQQQCCRBAhEJ9LZSJG+zJs3Tx588EHHo9WUGx9++KHj7ee7du0y80W7DQJv2LDBdt+dOnWSMmXK2NaxWul0e7TeTk9xL6AjPx9++GH3G4SoqXnIt2zZEmLN8UV169Y9/oOHz5o2bWrb2v79+2Xy5Mm2dZxWap7066+/3vLh5r3mtI94rdc7EZzK0qVL5amnnnKqFtZ6p1HB2pibILnTTt2+//UChl6Isyv6+aipQqIpjz76qOPm559/vmMduwp+fw/bHZubdRqIdhpRrt9zkU6GOX/+fPnll1/cdCUl6rh9j6UEBgeJAAIIIIAAAggggEACChCITsCTksxd2rlzp5mSwylo3LlzZ7niiiukVatWcuuttzqS6OjqkSNHOtbbsWOHaPDPrtSuXdtuteW6Y8eOyYIFCyzXsyIygeeff142bdoU2cbGVk8++aTjtm4CoI6NhKhQtWpV0RH2dmX48OGio7YjLYMGDZJJkyZZPiINcEXan2i20/e9U9BO2+/fv7989tln0ewqfVv9THj88cfTf7Z64kXqFg3KuimaDqhhw4a2VQ8dOhRVQF5H47/33nu2+9CVLVq0cKzjVMHP72GnY3NarxNr6veYXdHgaSQXjPRuimHDhtk1nXLr3L7HUg6GA0YAAQQQQAABBBBAIEEECEQnyIlIlW64SaOhKRKeeeaZdJKHHnpITj311PSfrZ7oH/I6OsyuaJBLJyG0K5EGPXWEotPEU15MLmbX92RcpxcONFgbSdEArdNowZw5c8pVV10VSfOutunWrZttvTVr1sgLL7xgW8dq5ffffy8zZ860Wm0uv/jiiy3Xjx49WnT0rdPjzTfftGzDyxUnnXSSuBmBqwG4Ll26yMqVK6Pe/XXXXSduJtS77LLLot7X7t27Xbeh/XIq+jn5888/O1XLsl6DdbfddpvoxTO70qxZM6lWrZpdFVfr/P4ednWQNpV69epls/a/Vfr9ceONNzqek7SG9OLV5ZdfLrNnz05bxP+GQDjvMcAQQAABBBBAAAEEEEAg/gIEouNvnrJ7fPXVV0UnVXIqGlwJztdbsGBBeeWVVxxHSmpwSidAtPtDVAPRa9eute3CW2+9Zbs+1ErNW3vDDTeEWpVhmVPgJ0NlfkgXePbZZ82JI8PJp6wjoXv37p3ehtUTHa3oNKmg1bZulvfr18/xtTt48GB5//333TSXXkdfx04BdH3vtGvXLn2bzE/0wolevHF6bNy4MfOmMfvZTdBOd66TvLVs2VImTpwY0YhyPSZNaTJ9+nTHYylcuLCjtTaSN29e27Z++OEH2/XBK7t27ep40UzvMNHA/eeffx68qe1z3aZt27aiuZudyoABA5yquF7v5/ew64O0qHjppZe6yi+uI8f1wtXhw4ctWvpv8b59+6Rjx47ywQcf2NZLxpVevseS0YdjQgABBBBAAAEEEEAg0QUIRCf6GYqyfzryrWjRonF51KhRw7K3GvC65ZZbLNenrdB0HHp7fubSoEEDGThwYObFWX7W/dil8tDAnHrYlSVLlphpQewC2mnba4oRDbBoQFBvlXcqGjyjRCYwfvx4M4C2fft2xwb0dvXbb79d3OQL1WBkLEulSpVEA1F2RV9rWue+++4Tp7Q12o6mVdCUCU4jeXXUqwZR/VR69OjhmJYi7Xh0NLleADrllFNE8x27ec/++++/ogFWTZuiI+bdFH1/u3F0uqDx1Vdfybfffutml5InTx654447HOvqMbdv317cTOKoOaXPO+88+frrrx3brVWrllx44YWO9cKp4Nf3cDjHGKqufu/873//C7Uqy7KpU6eKjkTXC6KZv1P27NljXnjR78M5c+Zk2TYVFnj5HksFL44RAQQQQAABBBBIRgG9M1bvfLZ7OM0TFQ8X/btd72K2e/gplaZnZkaghuJTASPoqjPfJcyjXLlyISWN0V0BI9+pYz9LliwZMNJihGxDFxp/lAeMiZ8c21ETI5WAZTvGCFhXbRi3pAfGjBkTMCZHy9CWMao5oPZGsDNgTGDmqq3g82SMYsvQXvAP3333nWN7uu9wS9++fW3bbd68ebhNmvWNCdVs2zUCfZbt6usi2MXt8ypVqgTGjRsXMIJqGdo2blUPvP322wFjlKzrdo2ATkDPp1Vx00cjcGS1efpyfQ0ZwShX/TKCUAFjgsWAEWBM316fGKMgA/r6uPLKKwPGyH7Htk488cSAEbTP0EbmH4wR447t6HlR73iWxYsXB4xArKu+Bb9ujNzKgdNOOy1wwQUXBIwAdcBI1xMw8j8HjNQugZtuuilw7rnnBnLnzh1Wu6VLlw4Yo6ddHb5xEc2xbT0uI9hu9s0YARswJuMM9OnTJzBjxows+zBSWgTOPvtsxzbVwEgxEzDSlQQ+/fTTgHHnQIa2jAsWgfvvvz9gpD5x3dYXX3yRoY1QP7h5fwSfn7TnfnsPuzlOp88BbePMM8905Z/mpK/n6tWrB4zJVAPGBa2I3hNpbRkpqUKdwvRlsfru0R0YEwQ7Hreb15u25fV7TNukIIAAAggggAACCPhLwJiHxfH3yyeeeMI8qDZt2jjWTfud2av/jTmNzH3r3+5ObRrZAPyF70FvcxsoFARiKqCjU51yN2sHnn76aTGCPpZ90RGCmqLD+KPc8VZ8zbWpeW8rVqyYpT295d3NRGd69eree+81HzrhlPZNU0OsX7/ecf9Zdhq0oFOnTmbeVU0TMmLECHP0ddBqnjoI6ChgnaxOH8bFCzONi044p7m9w0l9ormhNQ1MPPJ2G8FRMb4IXaVv+eabb0Qf+vooU6aM6Gtv69atsnnzZgeZ46uNYKu8/PLL5rbHl/rn2RlnnGGOIDWCp2F1Wu8AWbZsmfkIa0OLyvra0M8czV3tpjjln9c2jICkaD7gzEVfIx06dMiwWCct1JGxRgBddDSsXdHXvtbVh55/7bNuoyPs3YwUD277gQceMFN+BC/z8rkf38PRHr+eE80Fr6lU3E5Oqq/n5cuXu9p1oUKFZO/eva7q+rmS1+8xP1vQdwQQQAABBBBAIFUF9HdqNxOvh+ujd8Hq3EDGwCbRO5uNmKusXr1aPv74Y5k2bZpoijyvixeTw3vdp1i3R2qOWAunePt6C/ioUaMcFfTNblwtcqynASqdlNCpaGCyZ8+eIQOTup+aNWs6NZFhvbant0xo6g+3QYQMDWT6QYPcGjBze5t+ps358f8FNED7xx9/iOb7DScIrZtregYN8MWraL5qnWDPbdEAojGSUDRVTDhBaA2waz52veDh5zJkyBDzHGXnMehFNM2n7LY0adLEbVXX9XSi1gkTJoieV7dFL5itW7dO9HMr3CC0Hq/ax6v46T0crYlxZ5CZQkUvqnpZNM/9oEGDvGwyYduKxXssYQ+WjiGAAAIIIIAAAgiEFIjF37oaP9I4zeTJk825x5o2bWqmzNPUkfr3ta5zmqMpZGcdFsbiWBx2me2r3f9lm+1dpQN+E7ALBgcfS4kSJeS5554LXmT7/K677hL9UHAqGgR/6KGHslTTq1wffvihFC9ePMs6FiSWgObILVCggOeduuaaa1xdIPF6xzoSVr/gYlV0BK8GLWPxBRmrPtu1a6TGyZYAW9ro1XBHZGuebyP9gt0hRbROz6eRdiYm74XgDundIjppZjhB7+DtQz1PtvdwqGMMZ5lOMqiT9jpNuue2TSN1i7z22muOE6K6bS/R68XqPZbox03/EEAAAQQQQAABBI4L6Fw2Xv7NooMn9U5YvSPZqpQtW1aMFJoydOhQqyphL9e7oDPfFRt2Iz7cgEC0D0+aX7ps5D0VnUzMqTil5Mi8vX7g6FUqN5OH6S3mP/zwQ+YmzInKdHIvDTh5WXRyOL1iRvFGQNOr6Ie9fkB7VTSoN3HixLik5MjcZx0Jqa9dnZTQ66LviyeffFKuu+46r5vO1vZGjhwp7777rhj52OPSD50MbdasWa7SqGTukF4I8PIXk+D29a6RL7/80vaXo+D64TzXfusoaA1oGnnfw9nUsW6yvYcdD9hFBZ2UVydWady4sYva1lWuvvpqMXI7x+Q1Yb3X7F0Ty/dY9h4Ze0cAAQQQQAABBBBwK6BpU3UCby/KtddeG9bf5xpj8irmowMsjbmdvDgMX7VBINpXp8s/nX3ppZfMEXxOPdbRTZGM3jzllFNk7NixTs2bOZ27d+8eMr+q5uIxJpiSypUrO7bjVMGYfMscSah5gG+55RZPr8457TvZ11988cXy448/Rh20KVq0qJk32evAdrj+GkjRK65fffWV1KtXL9zNs9TXIL2OstYUHrfeemuW9cmwQIOwenw6utarkaSZXU444QTRoLfm5G3dunXm1a5/1s80zf3u5RX6tJ3Xr19fjIkvzbz1mj/ai3L++eebszhryiN9bcaiJNt72AujWrVqmbngx48fL7Vr1w6ryXPOOcccVa154NPuGNF0LHbFy4t5dvuJx7pYvsfi0X/2gQACCCCAAAIIIBC9wEUXXRR1IxojePTRR8NuZ9y4cVKkSJGwt8u8QSqm5VADAtGZXwk++lkDEYn0x2XwbQyaW9WphJuSI3N7OuK6ffv2mRdn+VkDSxp8DFU0wKW5n1988UXR4HY4RQNNmsRe03xovqC0DxHNA6rtRRLU0QmnYlGCz02o9p3Wh9rGzTKv2tVAjebT1gscZ511lptdp9fRyf769u0rixcvFh1BGE7Rc1iwYEHbTdxOZJe5kebNm8uCBQvMgFKzZs3Cfi/r6Orrr7/ezDWutxHpZHfhFrevN6/OY7j9C66vX/SPPfaYmTf7qaeeEg3GRVv0/OpVaL2AtHLlSjMNSFpgL9K2tc3BgwfLokWLzNedm8nVdF9u8wbr61lTDunnml54iGSkuH536C1gM2bMkC+++MKcADbS43W7nZ/fw7H6HNDvEP1s0tHR+j2kFzAuueQS0e+QysYFUj1PeteOfjdpHuibb77ZHAH9008/iaZRCS5Odx85va7dfhYE79Ptc33vOn2Oum1L68X6PRZOX6iLAAIIIIAAAgggkD0CafGXaPbeq1eviFK2lipVSrp16xbNrs1tvQimR92JbGgghzELZCAb9ssuEUg4AR1Rprfk68hLDfJocFkfOtmX5pMuWbKkeQt0nTp1zOCVBgv0CppV0ckIX3jhBZk3b545cZjOuqqTHVasWNHMI6vBx3bt2oneVpKKRb2dgm86Yj3UBH86c61eAPjmm2/MiQo3bdokW7ZsMYO55cqVE02voAG6Nm3amBcIvE43EIvztX37dvP1p4FBnaRQJyjU49Jc6/pFV716dalWrZr5vz7X16HmqUrlou9TDeZrYE5HzetoYfUKNTpUg376HtYJTzWvrj505LO+VmJd9Fz+9ddf5mfJrl27zIk1NbWQjsLW97/2wSlQaNfHX3/9VT766CP57bffzNeM7k8fhw4dEr3gp/vQiwkaFNeLZxrU9CIwyHvY7qzEd52e088//9xyp+edd56Z2sWygs9XxPo95nMeuo8AAggggAACCCSlgA7Y0L+zQhUdbKSpU/Xvn08//TRUFZk5c6arwY2hNv7ggw9E7/wMVfr372/ewa93/2tMI1SpUaOG/PHHH6FWJf0ybxPkJj0XB5jMAjryTK9IeXVVSkeoukkfksymsTo2DerraNBkSkWhuaH0qqoXV1Zj5Z5o7WpAXh+Zc3Tt2bPHDEjv3bvXDLjqBSMdlakjKbOjaCA4lhec0gLr2XFske4zGd/DkVp4sZ1eNLUrp556qt1q36+L9XvM90AcAAIIIIAAAgggkIQCOipaA86RlnDvig/eTzTbajtejOgO7o+fnhOI9tPZoq8IIIAAAo4COtrYzWSmjg1RAQEPBL7++mt59dVXLVvSOQYGDRpkud5phd5BsW7dOttqyR6Itj14ViKAAAIIIIAAAggkpYAOIowmEB3NXanRbKsnw6sBkH48sQSi/XjW6DMCCCCAAAII+EJA5yiYOHGiZV91pH7nzp3N0f2WlWxWDBw40Ez3YlPFs1nF7fbBOgQQQAABBBBAAAEE4img8y7p3a87d+6MaLc6oENTp0ZSdNtIi6aM1LmKUrUwWWGqnnmOGwEEEEAAAQRiLlC3bl3bfehUHU8++aRtHauVmiN9ypQpVqvN5TqhapMmTWzrsBIBBBBAAAEEEEAAAb8J6JxT7du3j7jbeudipCWabS+88MJId5sU2xGITorTyEEggAACCCCAQCIK1K9f37Fbzz//vLz44ouO9YIr6ES4PXv2FKc5py+77DLRyTopCCCAAAIIIIAAAggkm0A0KS6cBnTYWb3++ut2q23XRdNn24Z9spK/THxyougmAggggAACCPhP4Mwzz3QckXz48GHp3bu3OQGr1czfaUe+bds26dOnj3k73/Lly9MWh/w/f/78cs8994Rcx0IEEEAAAQQQQAABBPwuoCOic+eOLOvw4sWLZfLkyWETTJo0SZYsWRL2drpBvnz5pG3bthFtmywbRXa2kuXoOQ4EEEAAAQQQQCDGAsOGDZPWrVs77uWZZ54RfZx++ulm8PrEE0+UggULyqZNm2TFihWigec1a9bI0aNHHdvSCv3795fKlSu7qkslBBBAAAEEEEAAAQT8JqC/L2u+5S+//DKirt96661Sp04dOeuss1xtv3DhQrnttttc1Q1V6fzzz5fChQuHWpUyywhEp8yp5kARQAABBBBAIDsEWrVqJddcc428/PLLrnb/+++/iz6iKQ0bNpTBgwdH0wTbIoAAAggggAACCCCQ8AKdOnWKOBC9Z88e0eCwTjDuNFJ59uzZ0rVrV9m7d2GKT0AAAEAASURBVG/EJtrXVC+k5kj1VwDHjwACCCCAAAIxF3jhhRekTZs2Md+P7qBmzZry0UcfmaOp47JDdoIAAggggAACCCCAQDYJRJtzefv27dKuXTvRuVXmzJkjR44cST8STaH36aefyqWXXmpOjLhjx470dZE8ibavkewz0bYhEJ1oZ4T+IIAAAggggEDSCeis3u+9955ce+21MT22yy+/XL755hspUaJETPdD4wgggAACCCCAAAIIJIJAtWrVzIEY0fZl+vTp5sARTZ1RpUoVM8WdPr/gggvM3+Ojbb927dpy8sknR9uM77cnNYfvTyEHgAACCCCAAAJ+ENB8zzq5if4yO2LEiKjTbwQfc5kyZeSRRx6Rnj17Bi/mOQIIIIAAAggggAACSS/w0EMPyYwZM9KP84wzzkh/Hu6TgwcPyt9//x3uZlnqa6qPUqVKpS/v2LFj+vNUfpIjYJRUBuDYEUAgewT0dpf8+fNb7rxAgQLy7bffytlnn21ZhxUIIJB9AryHo7f/8ccfzbzRmpNu27ZtETXYvHlzufnmm81bCXXUNQUBBBBAAAEEEEAAAQT+E9ABIJpaI55FJwwfO3ZsPHfpq30xItpXp4vOIpA8Arlz586Qeyl5jowjQSA1BHgPR3+e69atK/rQX1RnzZolS5YskQ0bNsj69evN//W5TqBSpEgRKVasmPkoWbKk6G199evXNx/FixePviO0gAACCCCAAAIIIIAAAgjEQYBAdByQ2QUCCCCAAAIIIGAlkC9fPrnkkkvMh1UdliOAAAIIIIAAAggggAACfhdgskK/n0H6jwACCCCAAAIIIIAAAggggAACCCCAAAIZBPQuzngX0uXZixOItvdhLQIIIIAAAggggAACCCCAAAIIIIAAAgj4TOD6668309zFq9tly5aVLl26xGt3vtwPkxX68rTRaQQQQAABBBBAAAEEEEAAAQQQQAABBBDwQmDo0KGOzbip49hIilcgEJ3iLwAOHwEEEEAAAQQQQAABBBBAAAEEEEAAgVQWyJEjh+PhBwIBxzpUsBcgNYe9D2sRQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEohQgEB0lIJsjgAACCCCAAAIIIIAAAggggAACCCCAAAII2AsQiLb3YS0CCCCAAAIIIIAAAggggAACCCCAAAIIIIBAlAIEoqMEZHMEEEAAAQQQQAABBBBAAAEEEEAAAQQQQAABewEC0fY+rEUAAQQQQAABBBBAAAEEEEAAAQQQQAABBBCIUoBAdJSAbI4AAggggAACCCCAAAIIIIAAAggggAACCCBgL0Ag2t6HtQgggAACCCCAAAIIIIAAAggggAACCCCAAAJRChCIjhKQzRFAAAEEEEAAAQQQQAABBBBAAAEEEEAAAQTsBQhE2/uwFgEEEEAAAQQQQAABBBBAAAEEEEAAAQQQQCBKAQLRUQKyOQIIIIAAAggggAACCCCAAAIIIIAAAggggIC9AIFoex/WIoAAAggggAACCCCAAAIIIIAAAggggAACCEQpQCA6SkA2RwABBBBAAAEEEEAAAQQQQAABBBBAAAEEELAXIBBt78NaBBBAAAEEEEAAAQQQQAABBBBAAAEEEEAAgSgFCERHCcjmCCCAAAIIIIAAAggggAACCCCAAAIIIIAAAvYCBKLtfViLAAIIIIAAAggggAACCCCAAAIIIIAAAgggEKUAgegoAdkcAQQQQAABBBBAAAEEEEAAAQQQQAABBBBAwF6AQLS9D2sRQAABBBBAAAEEEEAAAQQQQAABBBBAAAEEohQgEB0lIJsjgAACCCCAAAIIIIAAAggggIC1wE033SQ5cuQI+WjVqpX1hqxBAAEEEEgqgRwBoyTVEXEwCCCAAAIIIIAAAggggAACCCCQMAIbNmyQatWqyf79+0P26bXXXpNu3bqFXMdCBBBAIB4CerHMqRBCdRJyXs+IaGcjaiCAAAIIIIAAAggggAACCCCAQIQC5cqVk379+llufdddd8muXbss17MCAQQQQCA5BAhEJ8d55CgQQAABBBBAAAEEEEAAAQQQSFiBe++9V4oWLRqyf//8848MGTIk5DoWIoAAAggkjwCB6OQ5lxwJAggggAACCCCAAAIIIIAAAgkpULx4cbnnnnss+/bss8/KL7/8YrmeFQgggAAC/hcgR7T/zyFHgAACCCCAAAIIIIAAAggggEDCC+zdu1dOOeUU2bx5c8i+NmjQQL777jtzUsOQFViIAAIIxEiAHNExgs3ULCOiM4HwIwIIIOBngYOHj0qfCQvkuvHfmY9ZC9f7+XDoOwIIIIAAAggggEASCRQqVMg2BceCBQtkwoQJSXTEHAoCCCCAQLAAI6KDNXiOAAII+Fxgx95Dct7wOelH0adlVbml7WnpP/MEAQQQQAABBBBAAIHsFDh06JCceuqpsnr16pDd0BQey5Ytk5IlS4Zcz0IEEEAgFgKMiI6FatY2GRGd1YQlCCCAAAIIIIAAAggggAACCCAQA4G8efPKsGHDLFvetm2bDBgwwHI9KxBAAAEE/CtAINq/546eI4AAAggggAACCCCAAAIIIOA7gR49ekjNmjUt+/3yyy/L3LlzLdezAgEEEEDAnwIEov153ug1AggggAACCCCAAAIIIIAAAr4UyJUrl4wcOdKy74FAQG6++WY5cuSIZR1WIIAAAgj4T4BAtP/OGT1GAAEEEEAAAQQQQAABBBBAwNcCl156qdSrV8/yGBYtWiRPPfWU5XpWIIAAAgj4T4BAtP/OGT1GAAEEEEAAAQQQQAABBBBAwPcCo0ePtj2GBx54QDZs2GBbh5UIIIAAAv4RIBDtn3NFTxFAwKcCemvhph37ZfPO/XL0WMCnRxFet7fuPii79h0ObyNqI4AAAggggAACCKSUQKtWrUQfVmX37t1y5513Wq1mOQIIIICAzwRy+6y/dBcBBBDwhcD+Q0dlwucr5KdV/8ryf3bL3oNHzX7nyplDqpUpLBfWKS8XnlNeShbJl+V4NIj7xe//yJ8bd8vKTbvl0JFjUjBfbql+UhHz0easslLI+NmLEs2+rn9+gWzbc9DsRuszysgtbU+T71f8KyOnL5a/t+6THMYa7fONbapLqzNO8qK7tIEAAggggAACCCCQZAKjRo2SBg0aWB7VW2+9Jb1795Y2bdpY1mEFAggggIA/BHIYI/VSY3ieP84HvUQAgSQQ+HX1dhky9VdZ8+8+26Pp1ayK3NXx+Gzh+nE87fu18tjMZbL7gPVo4rLFCsiQS8+QpjVKZWl/x95Dct7wOenL+7SsagaI0xf8/xMv9tX4fx+nB9gvMILjHWqXlbun/CJHQoz6vva8KnJHh+PHmrk//IwAAggggAACCCCQugKXXXaZTJ8+3RKgevXqsnjxYsmXL+sgDsuNWIEAAgiEIZAjhw6lsi+EUO193KwlNYcbJeoggAACLgWWbdgl146f7xiEztycpuy4ZdIPMnzab7ZBaN1uo5Hm45aXfpBxM/7I3Iyrn2OxrzVb98p9bywMGYTWTh06wjVPVyeHSggggAACCCCAQAoKjBgxQnLmtA5PLF++XB5++OEUlOGQEUAAgeQS8Obe7uQy4WgQQACBiAT06ujI6b9lyQOtI4XrVC4umpZD03TMWrhRduw7lGEfEz9fLnP/3JphWcUShaTuKcUlX56csnnXQZn/5xbZa6T8SCuTv/5L6lUtIc1qlE5b5Or/WOxrqRGA11KycF65uN7JcuzYMfnw5/WydfchKV4oj9xkpOegIIAAAggggAACCCAQSqBWrVrSs2dPmTx5cqjV5jJN4dG9e3c55ZRTLOuwAgEEEEAgsQUIRCf2+aF3CCDgI4EZv2yQX9fsSO9xwby55JHu52RJoXFbu9PkzXmrpUrpQmbdJet2yPOfrUzfzohXS59W1eSGltUkd67jI0P+MUZCPzhtsXy77HjAeug7i2R6//PkhIJ50re3exLLfZU/sYBM7NtAyp1Y0OxCr+anyKj3fpfWRn7oIgXc9c+u76xDAAEEEEAAAQQQSF6BoUOHyhtvvCGHDmUcsJF2xAcOHJB+/frJjBkz0hbxPwIIIICAzwSORzh81nG6iwACCCSawE+rtmXo0o2tq2cJQmsFnXjwuhZVpcXp/03gpyOkNV1GWrmqcSVjBPGpGYLQuu4kIzf0E1fXldPKFkmrao44/nrp5vSfnZ7Ecl93X1QzPQit/SheOJ882uMcaVe7nFO3WI8AAggggAACCCCQ4gKVK1eWvn372irMnDnTNpe07casRAABBBDIdgEC0dl+CugAAggki8CqzbvTD6VI/jzSvWnl9J/tnixee3wUdSFjFHW/tqdZVtcR0jpRYXD5c+N/aTGCl1k9j9W+ShXJLy3/P7ButW+WI4AAAggggAACCCBgJzB48GApVOi/uwat6t1+++2yd+9eq9UsRwABBBBIYAEC0Ql8cugaAgj4S+DvLfvSO1y1TKEsI5rTVwY90bzSS9YdDyRXN0Y764hpu3L6ycUkX+7jH986QaKbEst9VSn9XzoON/2gDgIIIIAAAggggAACoQTKlCkjd9xxR6hV6cvWrl0rw4cPT/+ZJwgggAAC/hE4HsnwT5/pKQIIIJCQAvuDJhLMkcNI9OyiaEaOw0ePT0BYIK99EFqb1EkP8+bOld76lt0H05/bPYnlvooVyme3a9YhgAACCCCAAAIIIOBK4J577pHixYvb1n3sscdkyZIltnVYiQACCCCQeAIEohPvnNAjBBDwqUDlUsdHBf+12d3tghpUrlyqcPoR/7V5T/pzqydbdh2U3QcOp68uZ+SOdlPiuS83/aEOAggggAACCCCAAAKZBYoWLSr33ntv5sUZfj58+LDcfPPNcuzYMdG7/hL1kaHT/IAAAgggIASieREggAACHglULXM8oLxj3yGZ9v0aVy3XLHdCer1/dh6QGb+sT/851JMXv1iRYfE5VexHjARXjue+gvfLcwQQQAABBBBAAAEE3Ar069dPypWzn/D6q6++kly5cknOnDkT9qH900kYBwwYIFu3bnV7+NRDAAEEklbA+R7wpD10DgwBBNIEDh48KMuWLZOlS5fK+vXrZePGjemPTZs2yb59++TAgQOyf/9+83+tnydPHsmfP3/6o0CBAlKyZEkpW7Zshkf16tWlVq1aUqxYsbTdJe3/NcsXlZkLN6Yf39gZS+WU0kWkduUT05cFPzl4+Kjky5NL6hiB5BkLN6Sveuj936ViiUJyZsWsZh/9vE7enLc6va4+OfcU94HoeO4rQyf5AQEEEEAAAQQQSACBQ4cOJUAvvOmCBjn1kawld27/hyt0xPbq1avlkUcekalTp8o333wjFStWTNZTxnEhgAACjgL+/2R3PEQqIIBAsMCuXbtk/vz5MnfuXPn111/N3GqrVq2So0F5ioPrWz3XYLQ+du7caVUlw3INUGtA+owzzpCGDRtK06ZNpUKFChnq+P2Hzg0rmUHi9dv3m4ey58ARuea57+TiuhWk8aklpdyJBWXX/sPy29qdMmvhejPX87v9m8tl9U+WD39aJ7+u2WFut2v/Een17DxzeaPqJaVkkfyyfvs+mW0Eq79euiUDU/uzy8nZlUIHujNU/P8f4rmvUPtnGQIIIIAAAgggkJ0C+fIlz7wWOifJCSecYA4GSfsdu02bNnLuuedmJ7En+x41apSsWePu7kJPdhiHRvR4evbsKTqSm4IAAgikqkAOI5eSMVUWBQEEklVARzLPmTNHPv74Y/n2229l0aJFZi61RDjeSpUqmQHpFi1aSMeOHUVnyfZ7mb98q/Sd+L2rwyhr5HaefV8Ls+6arXuly+PfyP7Dx1xtq5VOLl5A3ry9mRTOf/ya4o69h+S84XPS2+jTsqrc0va09J/1iVf7avy/j2Xvwf8mWrzgrLLySPc6GfbDDwgggAACCCCAQKIJuJ1QOtH6HU5/dPBHnz59pG/fvubdi+Fsmwh1V6xYYQ5e0UEvyVgWLFgg9evXT8ZD45gQ8LWAm+8HQqjRn2JyREdvSAsIJJzAv//+Ky+//LJceumlUqJECbnooovk6aefloULFyZMEFrR9Da11157TXr37m3mgGvSpImMGTPGTBOScKguO9TQGME88sqzpVjBvC63+K9axZKFZNKNjeS0skVcbXdezdIysW/DDEFoVxsaleK5L7d9oh4CCCCAAAIIIICANwJLliyRO+64Q6pWrSovvfSSN43GsZXbb7/dvPMyjruM6640PQcFAQQQSFUBAtGpeuY57qQT0PxjOuq5S5cuZlD32muvlffee8/M7+yHg9X+z5s3TwYOHCg1atSQRo0aycSJE2XPnj1+6H6GPnY8p7xMv6uZXGKk5NBRzzkyrBXz5xrGBIVXNDg5w5paFYrK6/2ayO3tT5PqJxWRPLkyblkoXy6pXamYPNbrHHnymrpyktF25pI7V07JnfP4dgXyHh8tHVzXi30VyHs8J2GBPHydBPvyHAEEEEAAAQQQyG6BDRs2yHXXXSft2rUTfe6H8sEHH8jMmTP90NWI+5hMecojRmBDBBBIWQFSc6TsqefAk0Vg27Zt8swzz5hB22TLo6bnqHDhwnLllVdK//79zRzTfjxv+w8dlb827zbTWJQonFdKFy3gaiTzkaPH5O8te2W7kW7j5BIFQwaevfKI57686jPtIIAAAggggAAC4Qq4ufU63Db9UF/na5k2bZo5V0ui9ldTCmpakb/++itRu+hJvzT/9X333edJWzSCAALeCbj5fiA1R/TeBKKjN6QFBLJFYOPGjTJu3DgZP368L0cNh4umXwqXXHKJDBo0SOrWrRvu5tRHAAEEEEAAAQQQQEDcBBqSlUknanz33XflwgsvTMhDHDp0qAwbNiwh++ZlpwhEe6lJWwh4J+Dm+4FAdPTe3EsdvSEtIBBXAR0Bfdttt0mVKlXk0UcfTYkgtALrB/706dOlXr165u2Fv/32W1zd2RkCCCCAAAIIIIAAAn4W0Mn/dA4ZTX+RaEVHQetcMRQEEEAAgeQWIBCd3OeXo0sigaNHj8qzzz4r1atXl6eeeiqpJ/BwOm2aC7t27dpy6623igbmKQgggAACCCCAAAIIIOAscPjwYbnqqqvMuVmca8evhk5QqKk5KAgggAACyS1AIDq5zy9HlyQCP/74o9SpU0duueUWAq//f041MK+5sTUw78fZwJPkpclhIIAAAggggAACCPhMYP/+/WbKu7Vr1yZEz2fMmCEffvhhQvSFTiCAAAIIxFaAQHRsfWkdgagENNg6cuRIadSokSxevDiqtpJ1Yx0RrbOBX3bZZfLvv/8m62FyXAgggAACCCCAAAIIeCawZcsW6dy5sxw5csSzNiNpSNOF6GhoCgIIIIBAaggQiE6N88xR+lBgzZo1ct5558mQIUOy/RdEP/Bp/ugzzzxT5syZ44fu0kcEEEAAAQQQQAABBLJVYMGCBTJ8+PBs7cPDDz8sK1euzNY+sHMEEEAAgfgJEIiOnzV7QsC1wPfffy/169eXuXPnut6GiiIbN240JzLUXNoUBBBAAAEEEEAAAQQQsBcYPXq0/Prrr/aVYrR29erVovunIIAAAgikjgCB6NQ51xypTwTeeecdOf/882XTpk0+6XFidVPTmWgu7TvvvFOOHTuWWJ2jNwgggAACCCCAAAIIJJCApua48cYbJRAIxL1X+vu65qumIIAAAgikjgCB6NQ51xypDwSee+456dKlC7+QeXCuHn/8cbnyyitJa+KBJU0ggAACCCCAAAIIJK/A/Pnz5c0334zrAX788ceiqfUoCCCAAAKpJUAgOrXON0ebwALPP/+83HzzzdkyGiGBWaLqmo4u79q1KyOjo1JkYwQQQAABBBBAAIFkF7j//vtF7yyMRzl06JD069cvHrtiHwgggAACCSZAIDrBTgjdSU2BadOmmUHo1Dz62B61BqM1VQcFAQQQQAABBBBAAAEEQgvohIFTp04NvdLjpWPHjpXly5d73CrNIYAAAgj4QSCHkQsq/smg/CBDHxGIk4BODtK4cWPZt29fnPaYmrt58sknGXmRmqeeo0YAAQQQQAABBNIFcuTIkf6cJxkF8ufPL0WKFMm4MAY/bd++PaXT540aNUruu+++GMjSJAIIRCPg5vuBEGo0wv9tmzv6JmgBAQQiFdi9e7dcdtllBKEjBQxju/79+0v9+vWlQYMGYWxFVQQQQAABBBBAAAEEUkPgwIEDog8KAggggAACsRIgNUesZGkXARcCt912m6xatcpFTapEK6Azgnfv3l327t0bbVNsjwACCCCAAAIIIIAAAggggAACCCAQpgAjosMEozoCXgl89tln8vLLL3vVHO24ENDcd8OGDZOHH37YRW2qIIAAAggggAACCCDgrcBJJ50k1atXl6pVq0rx4sWlcOHCkjt3bnOwxK5du2T16tWyYsUK0d9b4zV5oLdHSGsIIIAAAghYCxCItrZhDQIxEzh27JjcfvvtMWufhq0FHn/8cenTp49Uq1bNuhJrEEAAAQQQQAABBBDwQEADzZ06dZIOHTpIs2bNpGLFiq5a3bNnj8ybN08+//xz0cm3NTBNiVwgZ86cctZZZ0ndunXNCwFVqlSRYsWKmRcCtFW9a3LHjh3m3ap6IeDHH3+URYsWcTEgcnK2RAABBEIKMFlhSBYWIhBbgVdffVV69eoV253QuqVAt27d5LXXXrNczwoEEEAAAQQQQACB5BRwMxmVF0der149ufPOO+XSSy8VnQQw2vLDDz/IU089JVOnTpVDhw5F21xKbF+oUCHp2LGjdO7cWdq0aSMnnHBCWMet8/nMmTNH3n77bfnwww9FLw54UZis0AtF2kDAewE33w9MVhi9O4Ho6A1pAYGwBfRq/OLFi8Pejg28EciVK5c52sHtiBRv9korCCCAAAIIIIAAAtkt4CbQEE0fzz33XHnkkUekRYsW0TRjue2GDRvkgQcekJdeeonRuhZK+ju+zsXTu3dvKVq0qEWt8Bbv3LlTJk2aJE8++aT8/fff4W2cqTaB6Ewg/IhAggi4+X4gEB39yWKywugNaQGBsAS++eYbgtBhiXlfWfPtvfDCC943TIsIIIAAAggggAACKSmgaR40UKkjl2MVhFbYcuXKyYQJE+SXX34x00ykJLbFQWvO7bFjx8ry5cvlrrvu8iwIrbvTgLaOcF+2bJloqr8SJUpY9ILFCCCAAAJ2AgSi7XRYh0AMBEgJEQPUCJrkPESAxiYIIIAAAggggAACWQRatmxpDjS59tprxc2IuiwNRLDgzDPPlO+++86ciFvzH6d6ueKKK+SPP/6Q/v37S968eWPGoW3rXD+6ry5dukS0n/3798v27dstHxE1ykYIIICATwRIzeGTE0U3k0egQoUKsn79+uQ5IB8fiaZHOeOMM3x8BHQdAQQQQAABBBBAIBwBrwPFmgJi3LhxoqnfsqvMnDlTdA4UTR+RakXzb48fP16uvvrqbDl0nfunb9++osFlrwq3/nslSTsIhCfg5vuB92d4pqFqE4gOpcIyBGIkoLdy1ahRI0at02y4Ak888YSZPy7c7aiPAAIIIIAAAggg4E8BN4EGt0emAWhN1xBuWbVqlSxdulTWrFkju3btkiNHjkiRIkWkVKlSctppp0nNmjXDnuBw0aJF0rp1a9myZUu43fFt/bJly5qTCGpe7nCKGi1ZskRWrlwpO3bsMIPIBQsWFE2vUq1aNTn99NNF03y4LZomRSdF1PzdXhQCXV4o0gYC4Qu4+X7g/Rm+a+YtcmdewM8IIBA7gZ9++il2jdNy2AI//vhj2NuwAQIIIIAAAggggAACOmldv379XEEcPnxYZs2aJVOnTpXPPvtMNm3aZLtdvnz5pFGjRnLxxRebI51Lly5tW19X6mToX375pZx//vkpEYyuVKmSaVm1alVHG62gf4dpar7Zs2ebaTXsNtJglN412a5dO+nZs6doGhS7UqdOHdF5gPRCwF9//WVXlXUIIIBAygswIjrlXwIAxFNg6NChZh63eO6TfVkLNGjQQObPn29dgTUIIIAAAggggAACSSXgZsSb0wEPHDhQRo8e7VRN9u7dK88995w5gd4///zjWD9Uhdy5c5vB6EGDBpmjpUPVCV6mv9vqZIkHDhwIXpxUz3UktObH1mC0U3nvvfdk5MiREs0AlCZNmsjgwYOlffv2trvTEe56ASHakdGMuLRlZiUCMRNw8/3A+zN6fmY1iN6QFhBwLbBu3TrXdakYewHOR+yN2QMCCCCAAAIIIJBMAjpKedSoUY6H9O6775op+e655x6JNAitO9G0Ha+88oo5Qvfuu+82g9t2O2/YsKG8+OKLdlV8va5w4cKiObGdgtC///67NG/eXC699NKogtCKNXfuXOnQoYO0bdtWVqxYYelXsWJFc+S7plmhIIAAAgiEFiAQHdqFpQjERGD37t0xaZdGIxPgfETmxlYIIIAAAggggEAqCpQrV04mTZokdqPm9u3bJ9dcc41cccUV4uWgBw1Ijx07Vs455xzRfNB2RScuzK7J++z65cW6CRMmSO3atW2b0lHomjda02V4WT755BNz3zpBoVXRFCnaRwoCCCCAQGgBUnOEdmFpkIDeUqa5tL7++mszn5ZO7pDMt3oFHbrnT/WX0T179njeLg1GJqB/ROiEMBT3Anny5JETTzxRqlevLo0bNzZHh5x00knuG6AmAggggAACCCCQjQJ2QWSnbunfRDoq1qps3rzZTN/w888/W1XxZLlOrPf222+bv4dZNagDLnTSw/Xr11tV8d3y6667zna097Fjx+Tmm2+W559/PubHNmDAABkzZozlfm644QaZOHGi5Xq7Fdz6b6fDOgRiJ+Dm+4H3Z/T+BKKjN0zaFjRoqrnPJk+e7HgLWNIicGAIIGArkCtXLunUqZPcf//9ohO1UBBAAAEEEEAAgUQWcBNoCNV/Tcmh+Yatik5A2KxZM1m+fLlVFU+Xa+7ot956y0w9YdXwm2++KV27drVa7avlZcqUkaVLl0qxYsVC9luD0D169JA33ngj5PpYLLzxxhvNHOCh2t65c6eZmiWStCwEukKJsgyB2Au4+X7g/Rn9eSA1R/SGSdeCvrEef/xx84vz2WefJQiddGeYA0LAO4GjR4/K9OnTpW7duubM8dwt4Z0tLSGAAAIIIIBAYgjohXdNi2FV9I5HncguXkFo7Yem6tAgs136iauuukrq169v1W1fLX/44Yctg9B6IHfccUdcg9C6z/Hjx4tORh+qFC1aVLTP4Ra9+5CCAAIIJLMAI6KT+exGcGwaRNIryTq5BgUBBBAIV0DzFuoEMjpqhYIAAggggAACCCSagJsRb5n7rDmXX3vttcyL03/u2bOnTJkyJf3neD7RFGkLFy60/N3rgw8+EB3N7eeiKUZ+++03yZkz9Dg6PTf6N2x2FH09ffTRRyHTpOgo7TPOOMNMb+m2byVKlJCtW7e6rU49BBDwUMDN9wMjoqMHD/1JHn27tOBDgcOHD8sll1xCENqH544uI5AoApoT8fzzzxe9HZGCAAIIIIAAAggkg8Ddd99teRhTp07NtiC0dkpTP/Tu3duyfxdddJGceuqpluv9sGLw4MGWQWhNJ6kpMrKraFBKJ4bctm1bli5o4Fz7Hk6pVKlSONWpiwACCPhOgBHRvjtlsevwTTfdZN5eFLs90DICCKSKQLt27czRIXorKwUBBBBAAAEEEEgUATcj3oL7evbZZ5sjjoOXpT3XCQF14uuNGzemLXL9f9myZaVly5aigUdNx6ATwn///ffy008/SSQj7jR/tdXI51GjRoUdEHV9IDGuWKpUKdFgc968eUPu6YorrohoIJVO+NiiRQtzQsfChQuLnsvff/9dvvzyS4kk1VyfPn1CTpJ46NAhKV++vOtRzjrJ4QsvvBDyWFmIAAKxFXDz/RDJ53Nse+2/1glE+++cxaTHeiv9hRdeGJO2aRQBBFJTYOTIkTJo0KDUPHiOGgEEEEAAAQQSUsBNoCG445rn95577glelP48kgBvq1atzLzCTZo0kVB9Wb9+vTzxxBPy1FNPhRUQPf3002Xx4sUh21yzZo0Z8E7vuI+e9O/f3zI/twbtdZ6ScEqVKlVk+PDhcvnll0uBAgWybLp3717RSR4197MGwN0WHXyxbNkyqVq1apZN7rrrLhk3blyW5aEW6N/lmm+cggAC8RcI9ZmcuRcEojOLhP8zgejwzZJuC51sTPNuxXNyjaRD5IAQQCCLgP5yv3LlStERPxQEEEAAAQQQQCARBNwEGoL7qaNka9WqFbzIfH7w4EGpUKGC65Gu+fPnl4kTJ0r37t2ztBVqgf4OpWkTNTey2/L+++9Lp06dQlbXXMV6LH4rc+fOlcaNG4fsdufOneWdd94JuS7UQr0D+PHHH7ccXR28zf79+6Vv377y6quvBi+2fW41KlqPoWnTprbb6kp9nS1atEi4o9CRigoIxETAzfcDgejo6ckRHb2h71vQL2+C0L4/jRwAAgknoL/AP/bYYwnXLzqEAAIIIIAAAgi4EdCJAEMFoXVbnQTQ7aRyenH+s88+cx2E1vZ1ZO28efOkQYMG+qOr8uKLL1rWa926teW6RF1RvHhxy+NXew28uy0jRoyQZ5991lUQWtvUc/bKK69YjoYPtd833nhD9PffzKVhw4aikxDaldy5c5upPQhC2ymxDgEEkkGAQHQynMUoj+Hll1+OsgU2RwABBEILTJ48WY4cORJ6JUsRQAABBBBAAIEEFrALAmvQ0W3RkdBWo3rt2ihSpIho7udy5crZVUtfN2vWLMsJo+vXr59ezy9PmjVrZjk6+N1335XDhw+7OhQdhR7upIFpDY8ZM0Z0wkc3RfNMz5gxI0tVDS7bnf98+fLJ66+/7mrUdJbGWYAAAgj4TIBAtM9OmNfd1YkYdEIGCgIIIBALgc2bN8uCBQti0TRtIoAAAggggAACMRXQ9IWhyrFjx+SLL74ItSrLsjZt2ki3bt2yLHe7QEdljx492lV1Dcx+/fXXIetqag6/lXPOOceyy3PmzLFcF7yiaNGiZs7t4GXhPNdb9XUktaZWcVOs+nXuuedm2TxnzpzSsWNH+fnnn0XTjFAQQACBVBDInQoHyTFaC+iEFpHMCmzdImsQQACBjALfffed6IQ8FAQQQAABBBBAILsFHnzwQddd6NChQ8i6mmt5x44dIddlXjhs2LDMi8L+uUePHqL9XrFiheO2mo841AheDarrJIh+ulPNyl8R9DjdlH79+jmmxXBqR3OB9+7dW55++mmnqmY6lVCVrr/+etELGPq60eD4aaedJi1atHA92j1UmyxDAAEE/ChAINqPZ83DPq9atcrD1mgKAQQQyCqwdOnSrAtZggACCCCAAAIIZIPAkCFDot7rsmXLXLWhAcxGjRq5qmtXSUfOXn755aJpIpyK1e9defLkkdtuu81pc1+s37Vrl2zcuNFVX6+44gpX9Zwq6YhlN4HoP//80ww46zkLLvpa8OKiRHCbPEcAAQT8KJDx09GPR0CfoxLQL3EKAgggEEsBtxP5xLIPtI0AAggggAACCHgl8Pfff7tqqlWrVq7quankdrJBt31zs89ErbN69WpXXStVqpSc/X/s3Qd4HNXVgOGzWvUuWZYlN2TcKzYYY1zANi7gimkJhJKQhEAIEBIgPSSkEwKBEDopJJQACdUQ2h+aaaYbg3vvTc2SrLLSf8+IldW9K22bme8+z3h3Z2dueWetlc7ePfeoowI69nAH6bf7dAHDw5Xq6mrZuXPn4Q7jeQQQQMC1AgSiXXvpGwfu8/lcLsDwEUAg3AKBLiQT7n5QPwIIIIAAAgggEAoBXZQukFJUVBTIYQEdE2hdgfYtoEZj9KBAJ1MFahbIMHXBwX79+gVyqATav4Aq4yAEEEDAYQIEoh12QRkOAggggAACCCCAAAIIIIBA+ARqamoCqjwxMTGg4wI5KNC6Au1bIG3G6jGBTnLQdCShLIHWF2j/Qtk36kIAAQTsIkAg2i5Xin4igAACCCCAAAIIIIAAAghEXSA9PT2gPuzZsyeg4wI5KNC6Au1bIG3G6jGBjjHU6eECrS/Q/sWqL/1CAAEEwilAIDqcutSNAAIIIIAAAggggAACCCDgKIG8vLyAxvPuu+8GdFwgBwVaV6B9C6TNWD0m0DGuW7dOiouLQzKMLVu2yK5duwKqK9D+BVQZByGAAAIOEyAQ7bALynAQQAABBBBAAAEEEEAAAQTCJzBkyJCAKn/jjTck0JnMh6vwiSeeONwh1vNDhw4N6Dg7H9S/f39JTk4+7BB0PaQlS5Yc9rhADnjyyScDOUwKCgokIyMjoGM5CAEEEHCjAIFoN151xowAAggggAACCCCAAAIIINAlgTFjxojH4znsufX19XLbbbcd9rjDHbBq1Sp54YUXDneY9fxRRx0V0HF2PiguLk5GjRoV0BD+9Kc/BXRcZwdpQDvQ6zh27NjOquI5BBBAwPUCBKJd/xIAAAEEEEAAAQQQQAABBBBAIFCBHj16iAajAyk33HCDbNu2LZBDOzzm6quvlrq6ug6fb/7E9OnTmz907P0ZM2YENLZ33nlHHnzwwYCO7eigu+++Wz799NOOnm6x3y3+LQbNAwQQQCAIAQLRQWBxKAIIIIAAAggggAACCCCAAAILFiwICOHAgQOyePFiOXjwYEDHtz7o+uuvl6eeeqr17nYfDxgwIOCZwu1WYKOd8+fPD7i33/jGNwIOJLeuVHNzX3nlla13d/g40NdFhxXwBAIIIOBwAQLRDr/ADA8BBBBAAAEEEEAAAQQQQCC0Auedd17AFS5btkw0cBrswnk6m/oHP/hBwO0E06eAK43RA6dMmSIaeA+klJeXy+zZs+W9994L5PCmY1577TWZO3duwB8ijB8/XoYPH950PncQQAABBNoKEIhua8IeBBBAAAEEEEAAAQQQQAABBDoU0AULTz755A6fb/3ESy+9JBqoDGTRwXXr1slpp50mmpJD80wHUpKSkuTiiy8O5FBHHKM5ui+//PKAx6LpUaZOnSq//e1vpaqqqtPzdBb7z372M5k5c2ZQi01eccUVndbLkwgggAACIp4GU4Bwr8Add9whl1xyiXsBGDkCCIRdQGeShGrF8rB3lgYQQAABBBBAAIEABZYuXSo6MzfYogvanXHGGXLSSSdJUVGRJCQkyO7du0XzGWug+umnn5ba2tqgqr300kvl1ltvDeocux9cWVkpRx55pOzatSuooRQWFlr+8+bNs2Ywp6enS1lZmaxYscKy//e//x1UAFobHzRokKxcuVK8Xm9QfeFgBBCIHYFAFqElhNr960UguvuGtq6BQLStLx+dR8AWAgSibXGZ6CQCCCCAAAIIdEHgnHPO6fZieF1otsUpunjiqlWrRG/dVu677z654IILoj5snXShv/NSEEDAvgIEoiNz7UjNERlnWkEAAQQQQAABBBBAAAEEEHCYwI033ij5+flRHdUtt9ziyiC0op9//vkyZ86cqPrrhxEEoaN6CWgcAQRsJEAg2kYXi64igAACCCCAAAIIIIAAAgjEjkBBQYH885//lLi46Pxp/dWvflU0EOrm8o9//EN69+4dFQLNFa7fMqYggAACCAQmEJ13y8D6xlEIIIAAAggggAACCCCAAAIIxLTArFmz5M9//nPE+6jt3nbbbRFvN9Ya7NmzpzzzzDOSlZUV0a716tVLnn32WcnIyIhouzSGAAII2FmAQLSdrx59RwABBBBAAAEEEEAAAQQQiLrAxRdfLJqmI5Aco6HorC50+J///EcSExNDUZ3t6zjqqKOsoHBOTk5ExqILHr744ovWYokRaZBGEEAAAYcIEIh2yIVkGAgggAACCCCAAAIIIIAAAtETuPLKK600HampqWHthOZF1hnA6enpYW3HbpUff/zx8tprr8nAgQPD2vXRo0fLG2+8IaNGjQprO1SOAAIIOFGAQLQTrypjQgABBBBAAAEEEEAAAQQQiLiA5mt+5513RGfohrpkZmbKvffeK3//+9+ZCd0B7siRI+X999+XL33pSx0c0fXdOttdZ76//fbbUlRU1PWKOBMBBBBwsQCBaBdffIaOAAIIIIAAAggggAACCCAQWgENhr733nty0003ieYv7m7xer2is6BXrlwpF154YXerc/z5GrDXBSRfeOEFGTNmTEjGO3HiRFm6dKncfvvtkpKSEpI6qQQBBBBwowCBaDdedcaMAAIIIIAAAggggAACCCAQNgENHn/729+WjRs3yi233CJjx44Nui0NYl9++eWyatUqaxa05iWmBC4wc+ZM+fDDD+XJJ5+UefPmSXx8fOAnmyM1//Zpp51m5YJ+8803RVN/UBBAAAEEuifgaTCle1Vwtp0F7rjjDrnkkkvsPAT6jgACMS4wd+5cWbJkSYz3ku4hgAACCCCAAALhFdCA8ksvvWTlF9b7mzdvlrKyMqmrq5OMjAxr9vTQoUNl3LhxMmPGDJk0aZIkJCSEt1Muqn3v3r2W/yuvvCKffvqprFu3TkpKSqSqqko0r3d2drYMHjxYdEb7tGnTrGug+ygIIOAOgUAWmyWE2v3XAoHo7hvaugYC0ba+fHQeAVsIEIi2xWWikwgggAACCCCAAAIIIICAawUIREfm0pOaIzLOtIIAAggggAACCCCAAAIIIIAAAggggAACCLhWgEC0ay89A0cAAQQQQAABBBBAAAEEEEAAAQQQQAABBCIjQCA6Ms60ggACCCCAAAIIIIAAAggggAACCCCAAAIIuFaAQLRrLz0DRwABBBBAAAEEEEAAAQQQQAABBBBAAAEEIiNAIDoyzrSCAAIIIIAAAggggAACCCCAAAIIIIAAAgi4VoBAtGsvPQNHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQiI0AgOjLOtIIAAggggAACCCCAAAIIIIAAAggggAACCLhWgEC0ay89A0cAAQQQQAABBBBAAAEEEEAAAQQQQAABBCIjQCA6Ms60ggACCCCAAAIIIIAAAggggAACCCCAAAIIuFaAQLRrLz0DRwABBBBAAAEEEEAAAQQQQAABBBBAAAEEIiNAIDoyzrSCAAIIIIAAAggggAACCCCAAAIIIIAAAgi4VoBAtGsvPQNHAAEEEEAAAQQQQAABBBBAAAEEEEAAAQQiI0AgOjLOtIIAAggggAACCCCAAAIIIIAAAggggAACCLhWIN61I2fgCCCAAAK2Eairq5NHHnnENv21W0eTk5OlqKhIxo4dKx6Px27dp78IIIAAAggggAACCCCAAAI2EAhbIHr79u1yyy23yMsvvyz79++X+vp6G3DYp4u9e/eWV1991T4dpqcIIIBANwSqq6vlnHPO6UYNnBqIgAajr7/+ejnzzDMDOZxjEEAAAQQQQAABBBBAAAEEEAhYICyBaA0+L168WEpKSgLuCAcGJ1BbWxvcCRyNAAIIIIDAYQQ2btwoZ511lvzud7+Ta6655jBH8zQCCCCAAAIIIIAAAggggAACgQuEPEe0zoRetGgRQejArwFHIoAAAgggEFMC3//+9+X999+PqT7RGQQQQAABBBBAAAEEEEAAAXsLhDwQrbOoysrK7K1C7xFAAAEEEHCxQENDg/zhD39wsQBDRwABBBBAAAEEEEAAAQQQCLVAyFNzLFmyJNR9pD4EEEAAAQQQiLCAptmiIIAAAggggAACCCCAAAJuELj22mvdMMyojzHkgegdO3ZEfVB0AAEEEEAAAQS6J1BcXNy9CjgbAQQQQAABBBBAAAEEELCJwM9+9jOb9NTe3Qx5ao7c3Fx7i9B7BBBAAAEEEJB+/fqhgAACCCCAAAIIIIAAAggggEDIBEIeiJ40aVLIOkdFCCCAAAIIIBAdgWnTpkWnYVpFAAEEEEAAAQQQQAABBBBwpEDIA9GLFi1yJBSDQgABBBBAwE0CvJ+76WozVgQQQAABBBBAAAEEEEAg/AIhD0TPmTNHvF5v+HtOCwgggAACCCAQFoGUlBSZPn16WOqmUgQQQAABBBBAAAEEEEAAAXcKhDwQ3aNHDznxxBPdqcmoEUAAAQQQcIDAKaecIhqMpiCAAAIIIIAAAggggAACCCAQKoGQB6K1YwsXLgxV/6gHAQQQQAABBCIswPt4hMFpDgEEEEAAAQQQQAABBBBwgUBYAtHz5s1zAR1DRAABBBBAwHkCcXFxojOiKQgggAACCCCAAAIIIIAAAgiEUiA+lJX56xo0aJCMHj1ali9f7t/FLQII2EAg1RsnfZMSzBYvPRLiJTshTrLjvdaWFOeRBI9HEs2t19zW1jdIbUOD1Jjbqvp6KakzW61Piut8sqemTrZW18r26jrrGBsMnS4igMDnApMnT5b8/Hw8EEAAAQQQQAABBBBAAAEEEAipQFgC0drDRYsWEYgO6aWiMgRCJ6AB55FpSTI0NUmGmdth5vaI5ATJSQjtQqP1psu7TVB6XVWNrKqollWV1fKZdVsjPhPEpiCAQOwJ6Ps3BQEEEEAAAQQQQAABBBBAAIFQC4QtEK35JX/5y1+Gur/UhwACXRDQWc2Ts1NlfEaKHJOZYgWgvZ4uVBTkKZr7pyAx3tomZ6U2nV1lZlF/VF4l75UflGVllWarkmqzj4IAAtEXWLBgQfQ7QQ8QQAABBBBAAAEEEEAAAQQcJxC2QPT48eOloKBAdu7c6Tg0BoSAHQRGpSfLjJw0OTE7TUZnJEtYEsJ3ESLFpPeYaALTuonkykEThH6rtFJeKamQl/YfsFJ6dLFqTkMAgW4IDBs2TIYMGdKNGjgVAQQQQAABBBBAAAEEEEAAgfYFwhaI9pgcsvr13jvvvLP9ltmLAAIhF9A0G/N7ZMjcvAzpb1Jt2KUkm8D0NBM01+2nA/LlQzNTesnecnlmX7mV2sMu46CfCNhdgLQcdr+C9B8BBBBAAAEEEEAAAQQQiF2BsAWidcianoNAdOxefHrmDIEMk+95Yc9M+UKvLBlhAtF2L5oxZJyZwa3bDwf0lFeKK+Rfu0rlf+aWvNJ2v7r0P9YF9H2bggACCCCAAAIIIIAAAggggEA4BMIaiJ4xY4akpKRIVVVVOPpOnQi4WmBgSqJ8tXeOLDBBaE114cSi6USmm1nSuumihw+agPQ/d5ZIca3PicNlTAhEVSA/P1+OO+64qPaBxhFAAAEEEEAAAQQQQAABBJwrENa0scnJyXLKKac4V4+RIRAFgQlmscG7h/eR/44rkrPMLGinBqFb0+abRQ+v6NdDXjvmSLnuyHw5wkapR1qPhccIxKLA/Pnzxev1xmLX6BMCCCCAAAIIIIAAAggggIADBMIaiFYf8k064FXCEGJCYLwJQN8/sq88MKqfNUPYmXOgD0+t+aTPKciW58cNkN8OKpC+SfbJhX340XEEAtET4P06eva0jAACCCCAAAIIIIAAAgi4QSCsqTkUcO7cuRIXFyf19fVu8GSMCIRcQBcg/P4RPWVKdmrI67ZzhV4TiT8jP1NO7ZkhD5uUHTdv2Sf7SNlh50tK36MokJSUJDNnzoxiD2gaAQQQQAABBBBAAAEEEEDA6QJhnxGdl5cnU6ZMcboj40Mg5AK5CV755cBe8uRRRxCE7kQ33tM4Q/qlowfI10zO7ATzmIIAAsEJzJkzR1JT+bArODWORgABBBBAAAEEYlugvKpWbn9htfzztQ2x3VF6h0CEBO5/fYP5P7FG9P8GJToCYQ9E67AWLlwYndHRKgI2FNAw6rkm9YQGVr9ockBH5D+pDZ1adzndGyffL+opz447QiZlEVBr7cNjBDoT4H26Mx2eQwABBBBAAAEE7CXgD0Cf/Nv/yR0vrpXygwTd7HUF6W24BMpMAPqOF9fIKb99mYB0uJAPU29EYlzz5s07TDd4GgEEVGBgSqL8a3Q/+ZlZjC/DBFYpwQsUJSfKfSaX9u9M/ujseBZeC16QM9wm4DHfItA0WhQEEEAAAQQQQAABewu0DkAfOFhn7wHRewTCJKAfzhCQDhPuYaoNe45obX/YsGEyfPhw+eyzzw7THZ5GwJ0CGnK+qG+uXNGvB6klQvQSON3kjz4xJ01+uG6n/N/+ihDVSjUIOE9g4sSJUlhY6LyBMSIEEEAAAQQQQMAlAhqA/qdJOfDP1zdKe8FnnRWtGwUBBFoK+APS95v/O1+aUiTnmi0jJaHlQTwKqUDEplzytd+QXjcqc5BAYVK8/HNUP7mqfx5B6BBf1zyTZ/uuYX3kOjPDPDmO3NEh5qU6hwjw/uyQC8kwEEAAAQQQQMCVAtv2V8qZf3zdCjS3F4R2JQqDRiBIAX9A+qybXxP9P0UJn0DEAtGLFi0K3yioGQGbCszOTZclRxXJhMwUm47AHt0+x+TcfsIs+jg4NdEeHaaXCERQgPfnCGLTFAIIIIAAAgggEGKBPrmp8si3p8jFMwdJenJEvvQe4hFQHQLRF9D/O/p/6OErpor+n6KETyBiP6UmTJggeXl5snfv3vCNhpoRsImA10zOvdLMgL64T65Nemz/bmr+7f+M7i/fX7dLluwtt/+AGAECIRAYMGCAlTorBFVRBQIIIIAAAggggECUBDSVwCWzhpi0AgPaTdGhATZ9noKA2wVuf2F1izQ1GoDWdBz6f4eUHJF5dURsRrTX6xVmXUXmotJKbAvoAnp/GdGXIHQULlOKWQDy5iGF8sOinqIfBlAQcLvAaaed5nYCxo8AAggggAACCDhGwB+Q/u/3pzND2jFXlYGEQ8A/A1r/r+iHNAShw6Hcfp0RmxGtzWseynvvvbf9nrAXARcI9EtOkL8M7yMDzOxcSvQELuydI0XmGlyxaodU1ddHryO0jECUBcgPHeULQPMIIIAAAggggEAYBPwBaf8M6QzzdygFAQRE9P+CfkOAGdDRezVENBB90kknSXJyshw8eDB6I6ZlBKIkMDYj2Vo4L9csoEeJvsCMnDR5aHQ/+fpn22R3TV30O0QPEIiwQHZ2tkyaNCnCrdIcAggggAACCCCAQKQE/AHpSLVHOwjEusC5UwfEehcd37+IpeZQybS0NJk9e7bjURkgAq0FTshOk3+O7CcEoVvLRPfxyLQkecQEo/szQyC6F4LWoyKgs6Hj4yP6eXRUxkmjCCCAAAIIIIAAAggggAACsSEQ0UC0DpmvAcfGhacXkROY0yNd7hzeW5LjSEocOfXAW+qTlCAPjeong1JJlxK4Gkc6QYD3YydcRcaAAAIIIIAAAggggAACCNhHIOKB6Pnz54vHQ0DOPi8RetodgYV5GXLLkN6SwGu+O4xhPzc/MV4eNDPWh5kZ0hQE3CCQlJQks2bNcsNQGSMCCCCAAAIIIIAAAggggECMCEQ8EN2rVy+ZOHFijAyfbiAQPgGdCf37wYXi5XOX8CGHsOYck7v7vhF9ZSALSYZQlapiVWDGjBmSmZkZq92jXwgggAACCCCAAAIIIIAAAg4UiHggWg0XLVrkQEqGhMAhAc0J/cchBKEPidjjnubw/sfIvtKPnNH2uGD0sssCvA93mY4TEUAAAQQQQAABBBBAAAEEuigQlUA0eSm7eLU4zRYC4zKS5bZhpOOwxcVqp5OapuMfZmZ0nglKUxBwqsC8efOcOjTGhQACCCCAAAIIIIAAAgggEKMCUQlEDx8+XAYMGBCjJHQLga4L9Dczae8a1oeFCbtOGBNn9tXrOLyPpLDAZExcDzoRWoFjjz1W+vbtG9pKqQ0BBBBAAAEEEEAAAQQQQACBwwhEJRCtfTrttNMO0zWeRsBeAtnxXrnXBC811zDF/gJj0pPlJpNeJWo/JO1PyAhiVIBvJcXohaFbCCCAAAIIIIAAAggggIDDBaIWY+EPYYe/slw2PF2Q8JahhTKAhe4cdeVn5qbLd47Ic9SYGAwCvP/yGkAAAQQQQAABBBBAAAECwPINAABAAElEQVQEEIiGQNQC0ZMmTZKcnJxojJk2EQi5wHf758mkrNSQ10uF0Re4uE+uzDYBaQoCThDo16+fjBkzxglDYQwIIIAAAggggAACCIRVoLrWJ3W++rC2QeUIuE0gPloDjo+PlwULFsh9990XrS7QLgIhEZjTI10uMsFKinMFfj+4QNZ+vFnWV9U4d5CMzBUCixcvdsU4GSQCCCCAAAIIIIAAAl0RqKmrl9ueXyOvrdwl63cfsKoozE6Rn54+WiYO5tuyXTHlHASaC0RtRrR2YtGiRc37wn0EbCfQJylBfjuowHb9psPBCaR54+Rmky86kcULg4Pj6JgT4H035i4JHUIAAQQQQAABBBCIEYF95dXylTvelL++sk7W7jog9Q1ibduKq6S0kklJMXKZ6IbNBaIaiJ41a5YkJibanJDuu1VA//PcYGbKZpggJcX5AsPTkuRqk4KFgoBdBTIzM2Xq1Kl27T79RgABBBBAAAEEEEAgrAK3PrdaPtlSGtY2qBwBtwtENYKWkZEhM2fOdPs1YPw2Fbi4b64cm5li097T7a4IfLl3jkzJJhd4V+w4J/oC8+fPl4SEhOh3hB4ggAACCCCAAAIIIBBjApv3VsgT721t0asx/bPl9An9ZNrwXtI/L63FczxAAIGuCUQtR7S/uwsXLpRnnnnG/5BbBGwhMCQ1SS7v18MWfaWToRPwmKp+M7BATv5wo1SwaEXoYKkpIgL6fktBAAEEEEAAAQQQQACBtgL/t2KX+DQXx+flvKlFctX8Ef6H3CKAQIgEojojWscwb968EA2FahCIjID+p/n1wF4S79GwJMVtAoVJ8XL1EaTocNt1t/t4dYHgOXPm2H0Y9B8BBBBAAAEEEEAAgbAI7CiubKpXlwa6cNqgpsexdGfV9jI555alsdQl+oJAUAJRD0T37dtXjj322KA6zcEIRFPgvMJsGZuRHM0u0HaUBc4pyJajM0jLEuXLQPNBCEyfPl2ys7ODOINDEUAAAQQQQAABBBBwj8B2syChv+SmJUpueuytZ/bZtlL5+l1vybrd5f6ucouA7QSiHohWMb4ubLvXjWs7nJfgle+wYJ1rr79/4PqD8+dH5ktM/AD1d4pbBDoR4H22ExyeQgABBBBAAAEEEHC9wP6KmiaDnPSkpvud3amtq5dt+yulrotpG4M5/5MtJSYI/Y6UVtV11iWeQyDmBaKeI1qFFi1aJD/5yU9iHosOIvBdE4RO8xJ+5JUgMjwtSb7QK0se3MWqyrweYl9AFyqkIIAAAggggAACCCCAQEuBc29dKhXVPlm/+0DTE2t2lsviP7xqPdZc0adN6N/0XIkJWP/5+dXy0aZi65xaX4MkeD0yqFeGTBjUQy6dPUSSzAS2jkpXzv/YtHXJX5bJgYONQeiDtfVN/fO3M7pfllx31lH+h9wiELMCMRGIHj16tPTv3182b94cs1B0DIERJvB4ugk8UhDwC1xpPph4em+5lHfxE3B/PdwiEE6BsWPHSlFRUTiboG4EEEAAAQQQQAABBGwp8Om2shaLFPoH4Q9MN0/Z8c7affLDhz6SPeUH/YdZtxqM/szkbtZt6ao9csO5R8uA/PQWx+iDrpz/4cZi+ea970hFja9Fff7++XemJHYc/PYfwy0CsSAQM1M7Fy9eHAse9AGBDgV+UNSTVAwd6rjziVzzSffFfXPdOXhGbRsB/dYRBQEEEEAAAQQQQAABBLouoPmZv3HP222C0K1rXLvrgFxy7zKpMWk7mpeunL/BzNK+pJ0gdPN6uY+A3QRiYka0omn+yptvvtlufvTXJQLHZaXK8WajINBa4HyzcOFfthfLvtqWn1C3Po7HCERLgPzQ0ZKnXQQQQAABBBBAAIFYF/jhqSOl0qTmuPd/66SksjFPdFZKvHxtxmCr68cOzJWGhgb57RMrpL7h0Gg0FcYls4ZIn9wU2bKvUv7031WyakfjIoI7SqrkwaUb5YITj7RO6Or5C47pa7WhlTy2bEuL9CHfnTf8UGfMvb49Ulo85gECsSoQM4HoqVOnSmZmppSVlcWqFf1yscCV/Xq4ePQMvTOBFJMzXGdF/2rDns4O4zkEoiLQu3dvGTduXFTaplEEEEAAAQQQQAABBGJd4IzjGvM///ej7U2B6L65aXL+CQOauv7SJzvlw00lTY/HFeXIvd+YKN44j7WvqGe6TBjYQ06/8VXZsr/K2nfP/9bKuVMHWMf834pdXT7f3481O8uaAtHJCXEt+tfUMe4gYAOBmEnNkZCQICymZINXjAu7ONnMhB6fyaeLLrz0AQ/5nF7Z0jMhZj7XC7jfHOh8gVNPPVU8nsZfkJ0/WkaIAAIIIIAAAggggEDoBXRhwuZFZ1H7g9D+/bpA4YXTB/ofSllVnew0M6O1dPf8pkq5g4ADBGIqcqJfH37ggQccwMoQnCTw9T7kAHbS9QzHWJLMJ+HnF2bLHzbvDUf11IlAlwVIy9FlOk5EAAEEEEAAAQQQQMAS2LinooXE9U9+2uKx/8GmvZX+u9btZvO4T26qdPf8FpXyAAGbC8RUIHrOnDkSHx8vdXV1Nmel+04RGJqaJFOyyQ3tlOsZznGcU5Alt23dL1X1LRelCGeb1I1AZwLp6ekybdq0zg7hOQQQQAABBBBAAAEEEDiMQOtA8rL1+w9zRuPTW/drADuvTSA62PMDaoyDELCJQEwForOzs2X69Onywgsv2ISPbjpd4Ku9c5w+RMYXIoGseK+c2StT7ttxKHdYiKqmGgS6JHDKKadIUlJSl87lJAQQQAABBBBAAAEEEGgUqG812WjhMX0CohnUK8M6rrvnB9QYByFgE4GYCkSr2aJFiwhE2+TF4/RuZpvA4vy8xjcOp4+V8YVG4EsF2QSiQ0NJLSEQ0PdTCgIIIIAAAggggAACCHRPID8ruWkRwniTlvHHi0eJ5oQOtHT3/EDb4TgE7CAQM4sV+rHmzZvnv8stAlEVOLVnpiR+vgpuVDtC47YRGJiSyMKWtrlazu6o1+uVk08+2dmDZHQIIIAAAggggAACCERAoH9eWlMrdfUN8q83Nzc9DuROd8/XNuKaLUBe62uQ6lpfIE1zDAIxJxBzgeiioiIZN25czEHRIfcJnGXSLFAQCFbgC72ygj2F4xEIucAJJ5wgPXr0CHm9VIgAAggggAACCCCAgNsE5ozp3WLItz63Spat29din/9BbV29PLh0o5z8m//J1n2Nixx293ytO8F7KHznM8Hw9zcU+5u0buvNPt0oCMS6QMyl5lCwhQsXygcffBDrdvTPwQJj0pNliFmokIJAsAKn9MiQa9fvlkofixYGa8fxoRPQ91EKAggggAACCCCAAAIIdF/guEE9ZGTfLFmxtdSqrNoEm79+19sy/+g+MnlonuRlJMu2/ZWyfvcBeWH5DtlefNA67mBt49+E3T1fK8tNbxmfuOPF1VYbvbKS5L0N++W+VzfKSaPy5dtzh1v7+QeBWBWIyUC05rX8+c9/Hqtm9MsFAvPIDe2CqxyeISabdC4zc9Lkyb3l4WmAWhEIQGD+/PkBHMUhCCCAAAIIIIAAAgggcDiBOPM33q1fOVbO//PSplzROvf4qfe3WVu4z9f6jx2YK3e+dKilDzeVyMX3vnNoh7nnD3y32MkDBGJM4NDc/hjq2NixY6V375ZffYih7tEVhwt4zPh0VisFga4KzOWDjK7ScV4IBEaNGiWDBg0KQU1UgQACCCCAAAIIIIAAAiqQm54ot311guSkJQQEMqhXumSnJTYd293zxx+ZK1PM7GsKAnYXiMlAtMckYT/11FPtbkv/bSow1nytpndSTH5ZwKai7uv2Cdlpkt4sh5f7BBhxNAVIyxFNfdpGAAEEEEAAAQQQsKNASoK3qdvJie2HynTRwfu+OUnOmNBPkhPaHpOW6JWji3Lkj+cfLY9eOdWk7GiZTqM752uc7MbzjpFvzhrSpm2dTDd5SJ6cfBQTOpsuIndiVsDTYEos9u7555+XOXPmxGLXYqJP/fv3l02bNnW7L3fccYdccskl3a7HSRVc1T9PLu6b66QhMZYoCFy2aoc8u4/0HEo/d+5cWbJkSbeuQkVFhaSnp3erDrec/Pbbb8uECRPcMlzGiQACCCCAAAIIIIBAxAV0YcB9B6qlsrpOan0N0jMzWbJSA5strZ3tzvl1Zj2irSYn9e7SamumdmFOiqQxmS7irwEa7JpAzE77PPHEE62gw4EDB7o2Ms5CoIsCJ5r8vhQEuitwQk4qgejuInJ+0AK9evWS8ePHB30eJyCAAAIIIIAAAggggEDgApo3WoPPXS3dOT/efPu2qGe6tXW1fc5DIFoCbb9LEK2etGo3KSnJmkXXajcPEQirQH5ivAxLa/n1mbA2SOWOFTjRpOegIBBpAV3sNy4uZt/aI81BewgggAACCCCAAAIIIIAAAjEkENN/rZLnMoZeKS7pyuSsVNH8ShQEuiugH2oMTeVDje46cn5wArxvBufF0QgggAACCCCAAAIIIIAAApETiOlA9CmnnCJe76GE8ZFjoSW3CozPTHHr0Bl3GAR4PYUBlSo7FEhNTZUZM2Z0+DxPIIAAAggggAACCCCAAAIIIBBNgZgOROfm5soJJ5wQTR/adpnAMRkEol12ycM63KMzup4zLKwdo3JHCugCvykp/Axz5MVlUAgggAACCCCAAAIIIICAAwRiOhCtvnzN2AGvMpsMITveKwNTE23SW7ppBwFmRNvhKjmnj7xfOudaMhIEEEAAAQQQQAABBBBAwIkCMR+IXrBggRPdGVMMCoxKTyI/dAxeFzt3qU9SgvRIIL2Qna+hXfquCxTOnTvXLt2lnwgggAACCCCAAAIIIIAAAi4UiI/1MQ8cOFBGjRoln3zySax3lf7ZXGCYTReWi8vNkZRJ0zvVry8rldotG8S3Y5s0HKzu9NhA6uuogsqXn5OGAxXW00mTpkp8bs+ODm3a7ystEd/eXWbbLfX79orUNzQ954Q7umDhG6WVThgKY4hhgUmTJkl+fn4M95CuIYAAAggggAACCCCAAAIIuF0g5gPReoEWLVpEINrtr9QIjH9YWlIEWgl9E0lHHy8FP/hNQBU3NDRIyVMPS/Edv5eG0vJ2zwmmvtYVbN21Q6qXvWntzr/qF5LYq7D1IZ0+rjXB6NIlj0rFs/+Rui1bOj3WLk/q64pAtF2uln37qe+TFAQQQAABBBBAAAEEEEAAAQRiWSDmU3MoHnkvY/kl5Jy+6cxVpxePxyM5C78gRzz6iiSMGBlzw03Iy5e8C74pRzz0ouR896ciiQkx18dgO+SG11WwJhwfegHeJ0NvSo0IIIAAAggggAACCCCAAAKhFbBFIPrYY4+VXr16hXbk1IZAK4GiZPsHPVsNqcOH3tQ0Kfz1beJJT+vwmGg/kXval6Tv35+S+L59ot2VbrU/IMU9r6tuQXFylwWGDRsmQ4YM6fL5nIgAAggggAACCCCAAAIIIIBAJARskZpDZ3Hq147vuuuuSJjQhgsFcs2CcileW3wuE9DVKXvleTlgtrjkVEk5dpKkT5gi3rT0Fucm9CyQzPMvkdLbbmixv70H5W+9KhVvvtzeUy321azuPJf7zpuuazreE+eVhMK+knjkIEkaMEQSerTNJ53Uf4AU3PR32XbBAmmorGo61053+poFCykIhFOA2dDh1KVuBBBAAAEEEEAAAQQQQACBUAnYIhCtgyUQHapLTj3tCfRzWLCwYun/SdVzT1lDrXjiX7LXBNlzvv1j0VnGzUvKqHFS2nxHB/cP/N8zUrnksQ6eDWx3XfE+qXj0/g4PTpp0gvS65heiAfLmJal3P+l53c2y++qLRGy4jmHPxHhJjPNIjcMWYWx+jbgfXQEC0dH1p3UEEEAAAQQQQAABBBBAAIHABGwzBXT69OmSlha7aQQC4+aoWBXo4/S0HL56Kbnnpjb8KUNjJ0909RuvyuYvzpKS559o08+M40+UpHHj2+y3ww6P6WQfh33QYQd3t/QxLy9PJk6c6JbhMk4EEEAAAQQQQAABBBBAAAEbC9gmEJ2SkiKzZ8+2MTVdj2WBHiY1h+NLbV3bIXrNlyI0Uhor5WCN7Pvdj6Vmx9Y2Pco844I2++yywxWvL7tcDIf1c8GCBeL1uuDnl8OuG8NBAAEEEEAAAQQQQAABBNwoYJtAtF4cTc9BQSAcAjnxzg/kpC38Qhu6mm2bYy/dhQlG77ruqjZ9zZg6UzyZGW3222GHG15fdrgOTuwj74tOvKqMCQEEEEAAAQQQQAABBBBwpoBtckQr/9y5cyUuLk7q6+udeTUYVdQEnBYo9Ob1Ek9OtuiCgN5eBZI++1TJOf3cNr4HXnuxzb72dqQeP00aamrae6ppX73JAV397ltNj7tzp+bjD6Rm1w5J7FXYVI3H/N+P79tfaj9d0bTPLney3TDj3i4Xw0H9TE5OlpkzZzpoRAwFAQQQQAABBBBAAAEEEEDAyQK2CkT37NlTJk+eLK+99pqTrwlji4JAlsMChfkXXSm6dVZ8B8ql7MF7Ojuk6bms6SeLbp0VDRxvOW1aZ4cE9Vz12pUtAtF6cnxBX3sGouNt9eWToK4TB0dPYNasWaydED1+WkYAAQQQQAABBBBAAAEEEAhSwHbRkYULFwY5RA5H4PACyXGxlCj58P3t7hGVKz6SzRfMl4bSsu5WFbbzqzetb1O3N//QDOk2T8bwjmQzm5uCQKgFeD8MtSj1IYAAAggggAACCCCAAAIIhFPAdtGR+fPnh9ODul0qkOBxTyC6oaFBdnzrS1K/c2dMX+24tLQ2/WuoqW6zzw473PT6ssP1cEIfPeZn1rx585wwFMaAAAIIIIAAAggggAACCCDgEgFbpebQazJs2DBrW7lypUsuEcOMhIDTAoW1+/eKz+RsTh44tA2fBrAKbrxXdl31dWk4GFhg98C7S6XynaVt6mq+o27PruYPu30/edDwNnXU7djaZl8kdzw5/lJJrS6VwTvel377Vklcgy+g5hNdNuM+IBQO6pbAcccdJ4WF9vyGQLcGzskIIIAAAggggAACCCCAAAK2FbBdIFql9evIBKJt+5qLyY4nOGxC9N47bpDKJY+JJytTci/9vmTPO72Fe9q44yT3O9fKvl//sMX+jh6UP/+UVV9Hz4d8f1KiCaIPaVOtb+f2NvsitcMXFy/Pj71AauKTrSaTaitl4M4PZdDO92Xw9velaM8KSaqrarc7Xoe9vtodJDsjKkBajohy0xgCCCCAAAIIIIAAAggggEAIBGwZiF60aJFcf/31IRg+VSDQKFDb4EwJzQG977c/Ek9SsmTNbPk1fg1Olz/1sNQs/zDmBp9z0XckLjmlRb985aVSt3VTi32RfLApb0RTEFrbrU5IlU/7TbI2fez11ckRez4xgekPZMj2D2Tg7g8k7WCpPiV19dYN/yAQMgF9H6QggAACCCCAAAIIIIAAAgggYCcBWwaiJ06cKHl5ebJ37147WdPXGBaoMXmTHVvqG2TvL6+RlJFHSWJh3xbDzPvOz2T7VxeLmGNipSQMHyk5X/hym+4UP/Evkdq6NvsjtWNN4TGdNuXzxsv6grHW9vzYr4jHvKZ6F6+VQTs+lN0rXpGk8v9K9f7ophbpdAA8aRuBAQMGyIgRI2zTXzqKAAIIIIAAAggggAACCCCAgArYbrFCq9NxcVZ6Di4hAqESqI2hQGyoxtSiHhPA3f27H7fYpQ9ShgyXlGmz2+yP1o6UOQukz01/E81j3bw01NdL+WP3N98V8ftrC8cF1WaDGcO23MHyysgzZdNZt8rkP66VSTetlZEX/1X6TP+apPXWHNgtxxlUAxzsWoHFi82HRxQEEEAAAQQQQAABBBBAAAEEbCZgyxnRaqz5Mf/yl7/YjJvuxqrAQRPodHqpXvamHFj2uqQfO6XFUHtcfJVsfeUFEV8UDOLjJL6gULxHDJJsMws6/ZhJLfrmf7Drj7+Q+p07/Q8jfttgAsZrC4ILRLfXyeQefSV50tnSy2xaag/sl9LVb0jJqqVme13KN30oDb7a9k5lHwJNAuSHbqLgDgIIIIAAAggggAACCCCAgI0EbBuInjlzpiQnJ8vBgwdtxE1XY1WgxCVJfPfd8htJ/8eSFpchqU9/SZ29UCqffbzF/uYPCr73K6n72hXNd7V7f99fb5WKJx9t97n4nB7S/7GXDz1nZgzH5/YUj9d7aF8790qWPCoV/36gnWcit2tHzkCpSM4KeYMJ6bmSd/R8a9PK62uqpHTtO1ZQunT1Uuu+r/pAyNulQvsK5OTkyOTJk+07AHqOAAIIIIAAAggggAACCCDgWgHbBqLT0tJk1qxZ8tRTT7n24jHw0AmU1PlCV1kM11S3fq2UPv+kZJnAc/OS943vyOaXTIC6pv3ZuBosTsgvbH5Ku/e9PfLb3e/fGUgd/mPr6+pk7903SfmD9/p3Re12TZBpObra0bjEFMkZcaK1aR0N9T4p3/ihmTWtM6bNZmZP15bv6Wr1nOcAgfnz50t8vG3fuh1wBRgCAggggAACCCCAAAIIIIBAVwVs/dfsokWLCER39cpzXguB4lp3BKJ10Ptv/71kzJgrcc2CWQk9e0nml74mZX+9vYVLNB40mEX+Kt5dKvtMOo66jRuj0YU2ba4rPLrNvkjs8MR5JfPIY6yt38mXW01W7ljdlMpDg9MH926MRFdoI0YESMsRIxeCbiCAAAIIIIAAAggggAACCAQtYOtA9Lx586xFzTRwRUGgOwJ7zWJ+di31ByvbdL3hYFWbff4d9bt3y/4H7pG88y/277Jus089xwpEt1dfiwM7edC83fqqik6ObHxKFyGs279XanfvNNsOqXr3Dan837PSUFJ62HMjecDqgugEotsbY2rhENGt97SvWE/XlOyQ4pWvW8FpnTl9YOsKnUrd3qnss7lAYmKizJkzx+ajoPsIIIAAAgggEEmBsrIy+cEPfiD+v5mvuOIKGTp0aCS7EPa23DDGsCPSAAIIIBAhAVsHogsKCuS4446Tt956K0JcNONUga3V9g1EV7/+sqybHNwvk6V33iS6tVe6Ul979Wz70rz2dttu3/70Qtmfcfi0JNEaWGJ2ofSaeKa1aR/qKktNKo83TRqPzxdA3PC+1NdVR6t7tBtCgRkzZkhGRkYIa6QqBBBAAAEEEHC6QHFxsdx2221Nw9TJXF0NRFdWVkpqampTXbFyJ5RjjJUx0Q8EEEDAqQK2DkTrRdH0HASinfryjNy4th5sPzdy5HpAS7EqsLpgXKx2rd1+xadmSY+xJ1ubHlBfWy1l65d9ns5jqZStfVvqqmJrxnm7A2FnGwF9v6MggAACCCCAAALREPjWt74ld999twwYMEAeeeQRGT16dDS6QZsIIIAAAjYXsH0gWvNl6leNKAh0R0AXK6zw1UuaN6471XCuAwXWFR5j61HFJSRJ9tAp1qYD0XQoFVuWf774YeMCiJregxL7ArpQIQUBBBBAAAEEEIi0wMqVK+XPf/6z1eyqVavk5ptvlnvuuSfS3aA9BBBAAAEHCNg+ED1ixAgZNGiQrF271gGXgyFEU2BDVY2MSk+OZhdoOwYF1hTaa0b04Qg9cXGSfsRR1tZ39jetw6t2rTepPPx5pk2e7p1rDlcNz0dYYPz48dK3b98It0pzCCCAAAIIIICASHZ2tiQkJEhtbeO3SHv27AkLAggggAACXRJwxPRPnRVNQaC7Aisra7pbBec7TOBAUqbsyBnosFG1HU5KryOlcOr5Mvxrd8rE65fL1Fs3y+jLHpR+s78lGUVmoUaPt+1J7ImoAO9zEeWmMQQQQAABBBBoJqBrM911111y1FFHyZe//GX59re/3ezZlndLSkpEF0QMVQl1faHqF/UggAACCHRNwPYzonXYmjfzxhtv7JoAZyHwucDqShZ048XQUmBdwdHS4PG03OmCRwmZ+dLz2MXWpsP1HTwgpWveMuk8zKzp1W9I2bplJvd0lQskYmeI5IeOnWtBTxBAAAEEEHCjgAagdeus6KKBs2fPlj179ljpOzo7NpDnQl1fIG1yDAIIIIBAeAUcEYieNGmS5Obmyv79+8OrRe2OFlhZQSDa0Re4C4NzWlqOLhBYp3iT0yV39Exr0x0NdbVStuE9KV1tckyvekNK1rwhdRXFXa2e8w4j0L9/fxkzZsxhjuJpBBBAAAEEEEAgegL79u2TWbNmyQcffCBHHHFEtzsS6vq63SEqQAABBBAIiYAjAtHx8fEyb948+cc//hESFCpxp8DHBw5KvRm6I/LVuPMShnzUawtNWgpKGwFPfIJkDZ5obf3nfddEphukYtunhxZAXLVUqvdvbXMeO7omwGzorrlxFgIIIIAAAgi0L6Azlm+77TZ58803ZdmyZdK7d2+ZM2eO9U3jqVOntnvSueeeKzU1jakML7roIpk5c2bTcVqfPv7444+tfdu3b5czzzyz6Xm9M3HiRPnud83vjQGUUNTXlTH6u9Zgfrf929/+Jq+++qoVWF+/fr0MHDhQjj76aDnllFPkjDPO8B/a5du9e/fKM888Ixs2bJCNGzdKRUVFu3WdffbZsnjxYus5PedPf/qTfPTRR7J8+XLRxwMGDBBdN+vqq6+WceM6Xtvm6aefthac1MUm1UbXHhk8eLBo+jdtIy0trd322YkAAgiEWsBjfsg2hLrSaNT373//OyRvCNHoe1fa1BlymzZt6sqpLc6544475JJLLmmxz80Pnh57hAxLTXIzAWP/XKDGmyxXXPiG+LyO+Lwu4tf14N4tJjD9mpk1/YaM6eWVJQ/cId3JcqK/nKenp0d8HLHQ4IsvvignnXRSLHSFPiCAAAIIIICAzQT0b8aioqKmXv/iF7+Qu+++WzZv3ty0z3/HY35Ze+ihh+Sss87y72q69Xq9Ul+v03ZEbrnlFrnsssus+7t27bJ+T1mxYoX1uKN/dOKYBkMPV7pSX6jGqH3bsWOHnH/++aK/f3VULrjgAiuQn5qa2tEhHe6vrKyUX/7yl1ZA+cCBAx0e53/iJz/5iVx33XXy0ksvyXnnnWf1z/9c81u9dj/84Q+tupvv1/tf//rX5Z577mm9u+lxVlaWvPfee1awvWkndxBAAIEwCTgmwqK5qBITE5s+pQ2TF9U6XOC9sioC0Q6/xoEOb09mX0mpLZcD3pxAT+G4ZgLJef2kIO8cKZh8jmjSm8UPV8vo/DhrG5XvkSE94iSerx80E2v/bmZmppxwwgntP8leBBBAAAEEEEAgSAENbPqL/v2sxT/TWeeoaZBVU2scd9xx/sM6vNUcztOnT5fPPvusw2OCeSJU9XV1jJrqU2c979y5s9Nu//3vf7eO+e9//9vpca2f9Pl88sUvflGeeuqp1k91+DgurvEXZo13+D8IaO9gvXa/+tWvrOu2YMGCpkN0wl5nQWg9sLS0VMrLy5vO4Q4CCCAQTgHHBKIzMjKsT2KfffbZcHpRt8MF3jWB6C8VZDt8lAwvEIE+xWvlD3+bJjtyBsrawnFmO1pWm8UL92cUBnI6x7QSKDff5Hxja7216VNJXpERPeNkVE+PmTEdJ8Pz4iQlodVJPLTSTiUkAMNLAQEEEEAAAQRCJ6BpGfSbsTNmzBANdOpM2htvvNFq4ODBg/Kb3/xGHn/88YAa/NrXvmYd95///EeWLl1q3ddvsf385z9vcf6QIUNaPO7oQajq68oYNYDdPAitPj/60Y+s9BeanuPaa69tGuNzzz0nzz//vLU4Y0djab3/4YcfbhGE1j5eeOGF1uz0J554QjQQr0VTj77zzjtW+gydlKDFH4TWWdj6TTntm86ofuSRR5pSouhxel2bB6Jbz+zW63L66afL1q1b5YUXXpA777zTqkfPpSCAAAKREHBMag7FclOaCVJzhOe/R06CV94+diB5osPD64hai9N6yerex8jagmNEFzPUQHWD+SocpXsCcYZwcK6nadb0SBOgzkk55OrW1BwPPvigNXOme7qcjQACCCCAQHQFNBnks2t9Vif0G1GNm+fzW/9j/+2h/QnmWG/T8fq8R/z79HcHyuEFWqetGD16tOjkrT59+rQ4+fjjj5e33nrL2pednd0UFPUf1FFqDv/z11xzjfz+97+3HuqMas173J0STH2hGKOmFjnqqKNEZy1r0dzJGhxuXvQ5nSmuaSy0HHPMMfLuu+82P6TT+6eeempTnUceeaRVj1prqa6utiYgaAoOLZoe5V//+pd1X//R1BsazNc+DRs2rGm/9qmgoMDKF607W8cJNJ+1zor2F83fXVh4aGKN5pnWVCuarrP5fv/x3CKAAAKhFnDMjGiFmT9/PvmOQ/0KcVl9xbU++cQsWjgmPdllI2e4gQrkVOyS49Y8Y216TkVihqwzQenVvRtnTW/OGyF1XmawBurpP67e/IG6al+D2Xzy6GeNfwD0z/TIKCudh0cGujA9tM6GOfnkk/1E3CKAAAIIIGBbAf3Mfvnuenl+fWOO4VAMROPQGpQ280jEax50HtxuDGIfCoL7j9c6PK2C3Y31ej8Peus5GgzXtg6dfyhYfmhfx200HnPonGgG0XW2c+sgtF4PTRnhD0SXlJSIzoxOTrbn30RdGaMGgP1BaA363n777W1ephqM11nTGlDW8sEHH1gB5KSkwNYYaj7b+sorrxR/EFrr0jq+973vWbmg9fFrr72mN03lK1/5itx0002i+ZybF+3TaaedJnfddZe1W3NQNy+jRo1qEYjWRSk1tYh/YcO8vDwrB3Xzc7iPAAIIhFPAUYFo/WrL+PHjg/pUMpy41G1PgVeKKwhE2/PSRaXXaTXlMmbzy9amHdBFDjfkj5I/Jg6RPf2OlayBE8SbkhGVvtm90c1lDbK5zCfPrNWRxMvkm9ebBRCXWlvp6qVyYKtZFKchdH/QxprXtGnTWvyBEmv9oz8IIIAAAggEI3D2qHh5YX2NmM+eQ1K0nhrza4Buh0pntXf23KEawn1v3iCvfOf42PszXGcxNy8ajNaZtk4qnY1x5cqVTUPVfMsazG6v6GKK/qLpMjRlx/Dhw/27Or3VoLG/+FNt+B/rrT9Xt95Xf+2HBsW1/OUvf7FuW/+zbNky2bZtW9Nuf05p/w6d6axpV/w5oJcvX27N6r7iiivkpz/9qWiKUwoCCCAQSYHYewfs5uj1KzTBfD2mm81xugMFXjKB6Mv69XDgyBhSJAQSfQdlwLZl8uayh+SAz/xl5PFKxhFHSfbQyZI9ZLJkDTleErN6RaIrjmsjKae39Jp4prXp4OoqS6V09ZtSYoLSJatel/IN70t9nS6N6Iyi72cUBBBAAAEEnCLQP8sjU/rFyWtbWkSOnTK8gMYxxKQhu2xCbP4J3npNCk0V4bTS2RhXrVrVYri33npri8cdPVi7dm3AgWidnfzGG29YVWkaE/3mmz93tuZs/vGPf9zUjC4C6Q9CN+38/M6aNWvkb3/7m5W6Y926dS2ebh7M1id69epl5bLW3yv37NljHVtbWys33HCDPProo9bsaBbGbkHIAwQQCLNAbL4LdmPQixYtsj7Z60YVnOpyAU3NsflgrfRPJr2Cy18KXR7+qyUVjUForaHBJ+Ub37e2Lc/9yaoztWCwCUibwLQGp4dOkZT8AV1uy80nxqdmSY+xJ1ubOtTXVkvZ+mVNs6bL1r4tdVWltiVqvtCMbQdBxxFAAAEEEGgmcM7oeBOINisYu7BkmewNP5+WYKUSceHwY37IVVVVTX3UBQHPPPPMpsed3Qkmr/Kll14q99xzj7XwoAaehw4dKhMnTpSUlBR55ZVXmhYk1Pba+z1QZz7rYoM6O9qfRiQtLc2a1dw87Ufr/mobb775plxwwQVNiy3qMZrHWwPeWp8+R0EAAQQiIeC4QPSYMWOsBP2bN2+OhB9tOFTgmb3lcnHfXIeOjmGFW0BfP52Vyp1rRLcdr/7NOkxnSGtAunGbLGl9R4nHrGBOCU4gLiGpyVHPbDBfl6zYsrwxMG3Nml4qNaU7g6s0SkfrYjlFRUVRap1mEUAAAQQQCI/AkB4eObogTt7f6a5Z0Zpc4cdTEyQ/rTHNQnh0qbU7Ar179246PTc315px3LQjRHc0VnHbbbdZ61pp2g0t/rzczZs477zz5KKLLmq+y1rYcMaMGVJWVmbt17SkV199tWju6L/+9a+iqTY6KwMHDrTyTuuxmotaFynUoilCtC1/ULyzOngOAQQQCIWA4wLRiqKLB+jKrxQEuirw9D4C0V21c/t5B82qey+a9C7BlJrSXbL7nX9bm57nTc40aTyON0FVTeUxWTIHHCNxifZcLCYYh1Afq8H8dJMWRbe+s79pVV+1y+SZXv1606zpql1WAupQN93t+vTbPRQEEEAAAQScKPCl0V7XBaK/Ni5eji509iSD5rmJQ5HWI9T1He7/0uDBg5sO0dnKL7/8suh6HaEu3/jGNyQ/P99aYLB13ZqvWYPC119/vTQfvwaLdcayPwg9YcIEeeGFFyQzM7N1FZ0+1lQfF154oRUv+da3viUPPvigdbym87j55put2dmdVsCTCCCAQAgEHPluSF7NELwyXF7FyopqWWE2CgLBCjxrPsSo1NzQ3Si+g2Wy7+PnZN0jP5X3f3WSvPKNfHn/lzNk3cM/lX0fPSd1FSXdqN3dp6b0OlIKp54vw792pxz/+09k6q2bZfRlD0q/2d8yubzHWTm9Y0GI97FYuAr0AQEEEEAgHAJjzYzo4XnumRk82eTF/sLIQ4vUhcM0FupMSjK5Rz4vmiaide5i/3OB3oa6vsO1+8UvfrHFIV/+8pel+cKELZ40D95++23RiQOlpcGlgXv66afl3HPPtarTxQtPOukk+d3vficvvfSS7Nixw8rd3DwIrQdq/uoVK8wi3Z+Xyy+/POAg9E9+8hNrJrT/XL3VGd/333+/6Kxqf3n99df9d7lFAAEEwirgyEC0JtvPysoKKxyVO1/gX7sI9jn/Kod+hA/vCu6X0UB60OCrMbN435BNT18vH/1hkbz6zd7yzo8myOr7rpTdbz8q1fsPrZQdSH0cc0ggITNfeh67WAafe4Mc+4s35cQ7d8nYq5+WooXfl+xhUyUuIeXQwRG6p18NPfrooyPUGs0ggAACCCAQeYGzRznyi7ltIPtmeOR7kxLMonNtnnLcjp49e7YYk87q1cXxdDbvu+++K2effbbcfvvtLY7p7EGo6+usLX1O06Lp4oH+smnTJmsRQl208LPPPrMCzu+//74VwF28eLE1e/jJJ5+UYGd/64KElZWVVjP6Te4XX3xRrrnmGtG0G5rvub2yffv2FrtbP9bFC1sX/6KFzzzzjGh8RPuseaLr6uqsQ5ctWya7d+9uOq118LvpCe4ggAACIRZw5G8Auhru3Llzm75qEmIzqnOJwJN7yuUHRfmSEueC3xxdck3DPcz1VTWyrOzQQidha6+hXg5s+djatr7Y+At9Ss8Bjak8NNf0kEmSWjgkbM07uWJvcrrkjp5pbTrOhrpaKdvwnpR+nmO6ZI35Bb6iOKwEOrumo1XSw9owlSOAAAIIIBAhgUl946QoyyMbSxvz5Eao2Yg2k2z+0tbFCdMSI9ps1BrTRe+al7vuustaBE//NvcvBDhy5Mjmh3R6P9T1ddrY508+/PDDVtD2ww8/tPYUFxfLZZddFsipAR+juZg/+ugj6/gnnnhCNFWHfhNu6tSpHc5yHjZsWIv6f/3rX1tB/uHDh8tjjz0mTz31VNPzJSUlcvHFF1v7nn/++ab9jz/+uOimwW6dEb1ly5am5/TO/PnzWzzmAQIIIBAuAUfOiFYs8muG6yXjnnoPmPQKT+xpXAzCPaNmpN0RuH9n9GbRV+3ZIDte/6esvPdieet7Y+S1S/vK8lu+KFv++ycpW/+eNPgaZz90Z3xuPNcTnyBZgydK/3nflTHf+Y+ccNt2Oe7X78nQC26RXhPPkqTcQ19pDJUP71+hkqQeBBBAAIFYFdAZwmePcna6iquOj5eibPdMaNEg8/nnn9/iJaezb/1B6BZPBPAg1PUF0KRojmadQXzEEUcEcrhorubU1NSAjvUfpKky/EV9NGCvQeCcnBwZN26cfPvb37byP/sXM9Rj+/Tp0yKntAabf//731v5npsHof313nnnnaKzpnU2enJyy3VmKioq2gShBwwYINdee63/dG4RQACBsAo4NhCtX6vRT18pCHRH4C/bi8W58zS6I8O5rQXK6urlkd2x88FFbfle2fPu47Lmgavl3Z9NNnmme8kHv5snGx//tRR/+or4qhu/Eth6HDw+jID5yzmt70jpc9JFMvKb98nkP66VSTeukRHf+Iv0nvZVSes93FTQ9T8609PTw7IwzmFGxdMIIIAAAghEXGB6kVcK0rr+nhnxDgfR4JnDvaLji4USH9/yS9Ad/Y3cen9n57U+1j/Oe++9V2688UbJzs7277JutS5NQ7FgwYIW+w/3IND6Outr8zZa97v1eXpsYWGhlVP5iiuuaHeGso5t5syZorONNU+0/u4WSPH5fPKLX/zCCl63d7wGjXUmti4aOHv2bJkzZ44VTPYfe88990jrPNbal6uuusrKx92/f3//oVafrrvuOhkyZIgsWbJEbrnlFhk1alTT8/47iYmJcumll8pbb71lLaDo388tAgggEE4Bj/mkzbFxtlmzZlk5l8IJGK269Y1G81Z1t9xxxx1yySWXdLcaR59/17A+MiO3/Xxdjh44gwtK4I5t++WGTXuDOieaB3u8CZJRNM6k82hM5ZE1+HhJyOgRzS45pu3a8n1WTm9/Oo/yTR+aGem1AY3vjDPOkEceeSSgYzkIAQQQQAABuws8scont7zjrG9tjcn3yA2zEsXr2Clfh3/VaVB1w4YN1szb/Px8KSoqCnrmcPNWQl1f87o7u6+hEs2jvHfvXmt2sf4N3tW1qH7wgx/Ib3/72xbNaZqMgQMHigap169f32b2+HHHHSdLly4VXdTQX3Q29NatW61+9OvXz7/b6t8HH3xg3WrQOSWl7Ton5eXlsnHjRms8OstaZ0K3Ds43VcgdBBBAIEwCjg5E68ICoc7pFKbrEHS1BKKDJuvyCeMzU+ShUYfe5LtcESc6VqCmvkGmvb9BdtfY+Q8pM9O3z3Arz7TmmM4aMkWS83jdh+JFq7PPy9a9IyWrXje5pt+Q0rXvmBnpB9qt+h//+EfTSurtHsBOBBBAAAEEHCRQ4xM55z/VUnzQGYPqYWJ/d85LlJwUZ870dsZVivwodEFDTftRW9s4MUEXRtRYhQaa/YFgTWGis5e/+93vyubNm5s6+cILL1gzsJt2cAcBBBCwuYCjA9E6Y1g/fXViIRAd2av695F9ZXJWcPm/IttDWoumwN93lMgvNhxadTqafQll25r/uHHG9GQrQK2Balcs+x5KxHbq0nzdOku6ZNVSKzBdYhZC1FQqOttl165d0qMHM9PbYWMXAggggIBDBR76xCd3f2DnD/MbL0y8iT3fNCdBRvR08VRoh75GuzusTz/9VJov1KgpPTS/dHtFg9DNc1TfdNNNVt7o9o5lHwIIIGBHgZYJo+w4gk76rD/Ax44da+Va6uQwnkLgsAI3bd4rk0cfyrt12BM4wDUCB81s6Du27nfkeKv3b5Vdbz5kbTrA+NRsKzCdZWZM5wydbKX28MS7ZCn4EF5hjzdeMo8cb21yyhVWzZXbV0lK2Xp5ryRbRic2SGEGM6lCSE5VCCCAAAIxLLBgiFce+KROKgLLYhWzI/nmsfEEoWP26kS3Y7169TJzOTziz4q6ZcuWDgPROnu6eQl2McTm53IfAQQQiEUBRweiFXzhwoUEomPxlWezPn1YflBeLq6QaTnkirbZpQt7d+/fWSJ7au0/iycQqLrKEtn7wdPWpsfHJaRI1qAJJo3HpMYA9cAJ4k3JCKQqjmklkNp7qIjZfvdG42tJv9o7plecjDKzqvS2KNsjccSmW6nxEAEEEEDACQJp5jPtRUM1GG3ydNi0zBoQZ43Bpt2n22EW0G+7ad7m5cuXWy1dcMEFsnLlSpk/f75ormb/t+J0AcTmeaQ1eD158uQw947qEUAAgcgKODo1h1K+//77cswxx0RWNQKtkZojAsitmhicmihPH1UkXoJBrWTc+7Ckzicnvb9RSs0txQh4vJJZNLYxMD1ksrk9XhKzekETAoG0BJHR+SYwbbbRZhGkoT3iJOHQujUhaIEqEEAAAQQQiJ5AycEGkyu6Rqpt+CvVwByP/OnkREly/BSv6L0+nNCyLjo4Z84cqaioCHg4l19+udx8880BH8+BCCCAgB0EHP92OW7cOOtTxm3bttnhetDHGBZYU1kjD+4qkXMLsmO4l3QtkgJ/3LyPIHRz8AaflG14z9q2PPcn65nUgiEy5fRvyIyzL5Pluxtkx4GG5mdwP0AB/bryW9vqrU1PSTDpJ4fneT4PTMfJSDNzWmeUURBAAAEEELCjQEaix/rA9d0d9bbqfoZ57/35iQkEoW111aLTWZ3Z/Mwzz8iVV15pTZbrrBf5+fly1VVXydVXX93ZYTyHAAII2FLA8YFo/TqLpue4/fbbbXmB6HRsCWjgcUFehmTFMxUxtq5M5Huz1vpgojTyDdusxcqdqyV+w0vyvcnfsXq+r7LBBKTrraC03q4vbhBC08Ff1Frzd/rHJrD/8W6dOuYT/aKGzsjSWdOjrZQeHumRytc3gpflDAQQQACBSArUmrex59b55KEVPtt9WK3vsj+YksC6DpF8wdi8rRNOOEHee+89ef3110XTcGiuaF2csKamRnr37i39+vUTnUh35plnSmIiMwxsfrnpPgIIdCDg+EC0jnvRokUEojt4AbA7OAFNxXD9pr3yq4GkGwhOzllHa+D0J+t3ia+BEGqwV1aDo9OKvGZrPLOiRmTFHg1M18vHu+pl9b4GqbHXZKhgCcJyvL4S15qg/tpinzy2qvF7zX3MgoejTBoPKzhtAtR9MwlMhwWfShFAAAEEghaoNN/0eXq1Tx79rE72VQV9ekyccP4YrxzXx3xFiYJAkAJTpkwR3SgIIICAGwVcEYieNm2apKeny4EDB9x4jRlziAUe3lUqi3pmyoRMs5oYxZUC/zKvgWVlNv2rKcaumKaTmGD+iNNNi86MWrVPg9KNM6c/NUHqA+aPVUrwAtvKG0S359Y1RvZzkhvzTPsD00eaGdRe/n4OHpYzEEAAAQS6LFBqckE/ttInj5sPTcvNh9F2Lcf1jpPzxrjiT2m7XiL6jQACCCAQowKuePdMSkqSU045RR555JEYvQx0y04COvPwR+t2mYULj5CkOGYY2unahaKvu2vq5Hcb94SiKupoR0AX4NMF+Ubl65NeqTf/4TaYmb7vbT0ov7jrP9ZCiEk5vds5k12HEyg+KPLq5npr02NTzW8AI0xuaV38UNN5DDMLILLQ0uEUeR4BBBBAoCsCeyoa5JFPffL0Gp8tFyRsPubCdI9JyREvJgMkBQEEEEAAAQSCFHBFIFpNNE80geggXx0c3qHAhqoa+cPmvfLDop4dHsMTzhTQDyHKfeSOiNTV1c96BuZ6pCCpXr7w53OtZlN6DpDsoZMla+gUyR4yWVILB0eqO45qp7JORBeFeneHDssn8cZ6SA+PjDFBaZ01PaKnRzKT+CvbURedwSCAAAIRFtha1iAPfuKTF9f7pM4BGc2SzAfmujhhBu+PEX4l0RwCCCCAgFMEXBOInjt3rni9XvH5GnNnOuUCMo7oCfx1e7GcmJMmk7NSo9cJWo6owP07S+R/xRURbZPG2gpU7dkguu14/Z/WkwkZeSYw3RiU1gB1ev8x4vG65u2tLVAX92iA4NO9DWZrXDRKQ9BF2f4c05pvOk7y0whMd5GX0xBAAAFXCawxaz48uKJOXt1U76hFia+cGG99QO6qi8lgEUAAAQQQCKGAa/5Sz83NlalTp8rLL78cQj6qcrOATuq4es1OeWbsEZIdb6ZHUBwtsM7Mgv8NKTli8hrXlu+VPe8+bm3aQW9SumQOOk5yTFBaA9QZR443+/jAKNiLpz/jNpQ0mM0nT65uPLuXCURbqTxMUFpnTvczCyDy1eRgZTkeAQQQcK6ALjx8/3Kf9Y0bp41y0VCvzDqS3/mddl0ZDwIIIIBAZAVcE4hW1kWLFhGIjuzry/Gtab7gq0ww+u7hfYR5gs693FUmUfHlq3bIQU1YTIl5AV/1ASle8ZK1aWc9XvMV2qJxjbOmNaXHoImSkNEj5scRix3cZXJ87trQIC9uaExPk2kWm9SZ0o3pPDwyKDdO4lkAMRYvHX1CAAEEwibQYH49enubBqDrrG/WhK2hKFY8Is8j3xzvqj+do6hN0wgggAACThZw1bvpggUL5Morr3Ty9WRsURB42aRq+NOWfXJ5PwJbUeCPSJM/WrtTVlVWR6QtGgm9QIOvVsrWvWNtm5+50TTgkbQ+wxvzTJsc05pnOjmvX+gbdkGNZTUib2yttzYdrubObFoA0QSoh+fFSUqCCyAYIgIIIOBCAV0y45VNPnnA5IDWb9A4teQki1xr8kLzQatTrzDjQgABBBCIpICrAtEDBw6UkSNHyooVKyJpTFsuENBA9Jj0ZJlmckZTnCXw9x0l8uTecmcNyvWjaZCKbZ9a27b/u9vSSMrt+/mMac01PckKVJNzIvgXSrVZhuGDnfVm03N94jVfFRlkFpvUxQ91G5Xvkexkvj8SvCxnIIAAArEjUGt+1j+3rnE9gR0HnBuAVnF9H/vJCQmSl8p7V+y8AukJAggggICdBVwViNYLpek5CETb+SUbm33XX8GvXL1D/jW6nwxJTYrNTtKroAVeL6mUX5MXOmg3O55QvX+r7HrzIWvT/sen5VgzpXXxQw1MZxQdLZ54pvYGe2195ofjKrNg1ap9Pnn0s8bFgvubvNJWYLqXWQCxZ5wUZvDHfbCuHI8AAghEQ6CyVuTp1frzvE72VUWjB5Fv86Kj4+UosyYCBQEEEEAAAQRCI+C6QPTChQvl17/+dWj0qAWBZgLl5vuJX/tsm/x7TH/pmeC6/1rNJJxxV1NxfGvVdvFp4kOK6wTqKopl7wdPW5sOPi4hxeSWntCUziPLLIboTU53nUsoBry5rEE2l/lkydrG2vJSREabP/L9s6aLsj0SR2w6FNTUgQACCIREoPRggzy20iePr/JJuUnJ5JYy7Yg4OWMEixO65XozTgQQQACByAi4Llo2YcIEKSgokJ07re8NR0aZVlwjsL26Tr7+2XZ5YGRfSfUye8KuF36XWYRSP1Q4oMkPKQgYgfraKin+7BVrs0A8XsksGitZVo7pSSZAPUkSMvOx6oLAXjOr7n8b661NT083E891AUR/Ko+hPeIkgThAF2Q5BQEEEOiewB6zQO0jn/rk6TU+0dRLbipHZHnkquP5JpSbrjljRQABBBCIjIDrAtEej0d00cK7727MCxoZZlpxk8AnBw7KRSu3y73D+0gS0/psd+n3m8SH56/YKjvMhwoUBDoUaPBJ2Yb3rG3Lc7dYh6UWDPl8xrQGpqdISv6ADk/niY4FDpivfr+1rd7a9KhE85nesLzGdB4aoB5p0nmkJXZ8Ps8ggAACCHRPYKv55sqDZgHCF9f7pM6FXwxLM/Hn66YlsNhu915GnI0AAggggEC7Aq4LRKuC5okmEN3u64GdIRJ4q7TSSutw+7DeEm8+/KDYQ6Csrl6+/OlWWVflou+d2uPS2KKXlTtXi27bX/mr1d/ErALJHqaLH5o80ybXdFrfUeKJ45sSwV7MGvPFhI93N5hNp+P5RH+iDszxyBiTzkMD06N6eqQHi0gFy8rxCCCAQBuBNSan/4Mr6uTVTfXiwviz5aHvMddMSpC+Zj0DCgIIIIAAAgiEXsCVgeiTTjpJUlNTpbKyMvSi1IjA5wL/K66QK8wChjcPKSQYbYNXheb4vvCz39RFSwAAQABJREFUrfJpRbUNeksX7SBQU7pTdr/9qLVpf+NTskwqj+Ol99iZMv2Ll1mL+NWS/SXoS6nBkbXFDWbzyX9MzlItfcyCh6PzzeKHn6f0IIBgsfAPAgggEJDAR7vq5YHlPnl3B29KZ4/yypT+fGgc0AuHgxBAAAEEEOiCgCsD0cnJyTJnzhx57LHHukDGKQgELvDcvgNyiUnTcevQ3qTpCJwt4kcWm3QcOhN6BUHoiNu7qcG6qlLZ99F/ZcG4Arn55EQxLzv5bG+9fGJm+y7fXS8r9tRLhUlLQQleYFt5g+j233WNQZScZLMA4udBab090sygJm1/8K6tz/jrh3VylJmJfnQhQZrWNjxGwG4Cuhbz2yYN0v3L6+TTvW6d/9zyqh1dECdfPsqVfx63hOARAggggAACYRRw7TvtwoULCUSH8YVF1YcEdGa0Lnx3l0nTkUIk5BBMjNzbbRYmvMAEoddUko4jRi6J47uh6aG06AJ8ml5iTC995JV6EwdYb2b6fmKC0hqY1m2fWciPErxA8UGRVzfXW5uenWp+2xlhckvrrOnRxnyYWQAxybW/AQXv6T/jjS31Vt7YyyfEy/whrCDpd+EWATsJ6DrML2/yWf+XN5TYKwCti9nWmA9xNWVTqEu+SfH046nxfGgZaljqQwABBBBAoJWAa/8MmzdvnsSZXJ319WH4TaYVMg8ReNPkjD7bLIB39/De0jPBtf/tYu6FsNYEn/VDgq3VTEONuYvj0A7pN3JmzZrV7uh0bdNBuR6zeeXUYY1Bvu1mlq8GpjVH8nLz1emt5jEleIFKs/aofuX83R16rk8SzITeIT0aF0DUGdMjTZ7pjCTygXYme8B8VqdBK30F3vR2nXX/m+MJ2nRmxnMIxJKAfgvnuXU+eWiFT3YcsNd7Sa75lsvpw+Nl4VCv3PtBnTy+qjEtU6h89T3h52Zxwqxk3gdCZUo9CCCAAAIIdCTg2ohYz549ZdKkSfL66693ZMN+BEIq8MmBg3L6x5vl3uF9ZXBqYkjrprLgBXRByW+u2i66QCEFgUgJzJw5U9LS0gJurrfJfdw7wyuzBzaeUlxlAtN7GoPSOmNacyXrTGpKcAKam3uFcVyxpzEoo6GHomx/YLrxtmcaAYnmqvqBSPOXmgaCtpY1yE9PSJA03tKaU3EfgZgSqDSftT+12if//qzOdt+yKUz3yFkjvHLKIK/1LSKF/cJIrzUeX/MfSN0U12956IeTFAQQQAABBBAIv4BrA9FKq+k5CESH/0VGC4cEtlfXyVnLN8tNZgHDaTmBB6MO1cC9UAj8a1ep/Gz9bqnVBIkUBCIooO873Sk5KR6Z2l+3xhy9VSbAoLmlG9N5NFg5p6tDO1GsO921zbn6k0Bn+24o8cmTqxu7XWAC0aM0lYeZMa0pVPplesTj4jiFvsZaF51l/q1na+RXMxLMByYuxmkNw2MEYkCg9GCDPGYWdNUPjcptln1sgPlg8Ism4Dy9yNsmVUa++dl80oA4eX59259JXWGfa4LccweTaqgrdpyDAAIIIIBAVwRcH4i+5ppruuLGOQh0WaDcJOf7ukkHcVm/HtbGn+5dpgz6xBozdfRnG3bLwyYQTUEg0gIeE8WcP39+SJtNMfkyx/eOszatWCf4r96n+aUbF0DU4KHdAhAhBepGZTsrGmTnhgZ5cUNjsCPTzPod9XlQWnNND86NaxMg6UZzMX+qzsBvr2w2s6IvfaZGrj0xQcaahb4oCCAQXYE95mfXw5/6ZMkan9jtg8kReR45e1S8HN83rtMP/vSYF9bXtPiWRlfUh5h0WDobmoIAAggggAACkRNw9Tvv0KFDRbdVq1ZFTpyWEDACOvvuli37ZLlJ1/H7wQWSHc9MjHC/MLYerJXLV++Qj405BYFoCEyYMEEKCwvD2nS8iQPqonwjejZ+fVkn/W8qbQxKf2xyTGuAek8l3wToykUoMzMK39hab216fpL5sd20AKIJUA/PixP9YMCJRRcHW7Wv49eN2nzvxVq54rh4ZhY68QXAmGwhsMX8rNf8zy+u90ldx/9dY3IsxxTGyTmjvAF/mNU/yyOT+8XJ62YB1a6WrKTGvNC6cDAFAQQQQAABBCIn4OpAtDIvWrRIrr/++siJ0xICzQT+V1whcz/cZAWjJ2elNnuGu6EUeGJPmVxrUnEc0KXiKQhESUDfbyJdNJWE5j4uyvbKgiGNf23vNrPl/EFpneW62QQvbBaziDRju+3pTMMPdtabTZ/2iddY62KTmsqjcfM4ZuGrlXvrRfNqd1Y08PWHt+qs19NFx8SLLr5JQQCB8AusMR8SPfBJnby2uWUe9/C33L0W9EeEppnS2c1dyc98tglcdzUQrW3/eGqCaJoPCgIIIIAAAghEVsD1gWjN10kgOrIvOlprKbC7pk6+vGKrXNg7R77TP0+S+Ou9JVA3HpXW/T979wEmVXU2cPydustW2KV3lr6ANOlIkSZVJPYaS0xsURONPUY/S4xRY+8takxi71hiL2BFELAhIiC9SGfrd967zjjbZ3an3DvzP88zzq3nnvO7w7jzzpn3lFq5oJ/buL0RtXAqAtERaGx+6Oi0QqwP3hMLPDKxoKLGbXvNBIg/p/LQwLQGNZw2mi5aNo2pRyfO0lHDX20qlceXViTq7mjySltB6VYVz63NxFtOLDqSPtzymOm7frlxsZnEMCNJR4iHa8FxCMRS4HPzK5d/LSoVzdXupOI1b4MTCkwAuo9XOpiRzQ0tvcyvUAaZdECfmi8EIy0nDvTKIDMKm4IAAggggAAC8RdI+UD0iBEjpEWLFrJhw4b463NFBH4W0I/49/64RV43I6Sv6tpKhuQ0waaRAnM3bZfLvtsgG4pLGlkTpyPQeIGCggLp06dP4yuKQQ05aS4Z2UEfFR/KzZyq1qSHGpReuK5iAsTd/DNqkLzmT/5hm8nV+m3F6c3NW3s/M/FhYNS0jlZ3wnePteWHrg1l/o9lcsbPkxg6NfheW9/YjkAiBTTd0vzVZfLIohJZsjH8L4gS2ebAtTWd0XQzKeAhhZ6ojUTWdB6RBqI1pYdOhEhBAAEEEEAAgcQIpHwg2u12W5NH3X///Ym5A1wVgRCB5buL5MgvVsrhrXLlnE7NJZfc0SE64S2uMVG0y8yEhK9t3hHeCRyFQBwEEpGWo6HdSjN/Geikc4GJ5zSjzbItgXQeZbJ4Q5lsIdV6g3g37hZ54/sy66EVZJkRwzoBYiCVR498t9gtX6mZ41WWmHseafnejIrWSQwvG+ez+hjp+RyPAAK/COj78JsrSuXRL0pl+VZnBaD1fe7Anh75VW9P1NMVDTSjmnubCQ6XhhmUb5/tkvNG+uqcCPEXdZYQQAABBBBAIBYCKR+IVlT9uTSB6Fi8vKizIQL68eLRdT/JS5t2yNkd801QuqmVe7QhdaXSObtNtOTu1ZvlLvPYo5ETCgI2ErBLWo6GkHjMQGnN39kj3yMHm5FsWnRSLB0lW/EolzU7+DfXENsdxSLzzOhGfWjxG+teJqhSkc7DTDppfnqe6W9IzdE75zvzJcRO086GlK17Rc55tVj+MNwrk7syArEhhpyT2gLFJsvPy8tKrUkInfY+m5cuJvjslVkmCB3LND2aY/rPb9b/JpVuPvXqF2OJfk9N7Vc0vUcAAQQQQECEQLR5FUyePFnS09Nlzx6GePGPwj4CW01+Y51g75G1P8mfzOjocc0y7dM4G7VE87I+u3GbXP/DRtHR0BQE7CaQl5cno0ePtluzGtUezevZIdcj08zPrLVs3BUITGu+6TLR4CWh6ciJi0w8eqHJx7xwvYk+mZGPmrajwKTv2OfndB59W7okr0nDc6pG3iKxvmxoyHmBc3SSw2ver5jE8ASTl9UJqUgCbecZgUQJ7DJx1ee+Nvnml5TIZod9PGljcuEfar60nNrNE5dfeIxs75ZO5v9JK8wXpHWVc0Z4rcl76zqGfQgggAACCCAQewEC0cY4IyNDJk6cKM8//3zsxbkCAhEKfL1rr5y0dLUMzE43I6Sby8jcjAhrSM7D9ePGi2YSwhtXbpLvTEoTCgJ2FZg2bZp4vcn9v9vmGS4Z39ljHhV3Yaf5J/mFSeewyEympaOmdRI/DUhSIhPQH3d8a4L6324plSe/rJgAsZ35aXk/E5DWUdOa1qO9mRAxliXS/NC1teXRxaVWoOjC0T5pwiSGtTGxPcUFftpTLk+Zf+tPf1Uq2x32p00X86WZ5l7W/xfoL2niVVzmLfAIkyv6r+/VPhjhYJMWRNtFQQABBBBAAIHECyT3J+MIfDV/J4HoCMA4NO4Cn23fI8cuXiX7mokMT26bJ+PzMiW24Ye4dzGsCxabmXqe27Bd7jGTO2qQnoKA3QWclB86Wpb60+dh7dzWQ+vUn5cv3ahB6YoR05pnuqHpHqLVRqfWs3p7uehj7rKKyH4z8/P3wOSH+lzQzBXVIJCOcI9WeX9VmZz5cpFcMd4XtcnKotU26kEgkQLrd5bLY0vMxKbflMreiu+cEtmciK5daNIJaXqMEWZksgaFE1H2N0HmBxaUylrjWLXsY94XTx7ER96qLqwjgAACCCCQKAH+r/yz/IwZM8wfTy4p1+moKQjYWODjbbvl422rpaCJX05o20wObJ4tTeI59CRBNltMJOs/63+Sf67ZKuuLah/1kqDmcVkEahTw+/0yZcqUGvel0kadgE/TS+zTSnvtER3pq+k7dLStBjr1eZOZyI8SuYBOHPn2D2XWQ8/OMH/ZFbZQa5c1Yrq3yTPtb+BAwNXbyqN+X3Tiy1PNJIaXm1yt2k4KAqksoPn2/21+LfDad6VS4rCPIPuaiQJ1JHJgYttE3kf9M/hQMxr7pg8r/32Y30Tkz2O8Uf1yLpH95NoIIIAAAggkgwCB6J/vYuvWrWXYsGEyb968ZLiv9CEFBDQdxcXL1slfv98gs1pky2FmUsM+mWlJ1XP9TPbBT7vkP2byxlfM5I06GpqCgJMExo8fL9nZ2U5qclzaqnmCu+W5zMMjB/WqiJL+aEb5LjSpPL7YYALU5nmVWadELrDLxGE+XlNmHnpuqfhMgEYnmwyMmu7TwiXZaeENW4xWWo6qvdDg+R9fKZZzRnplQpcGRsmrVso6Ag4S+MakK/rXFyXyjvkSyUnvdPrOsV9HDUB7rfcVO5FrTuqHFpaIvr9o8ZrG/mWsT5rFOa9+xdX5LwIIIIAAAgjUJkAgOkRm1qxZBKJDPFh0hsCO0jL5l5nQUB+9MtJkuhkhPc08OqU7Nwnn4p175QWT/1lzQK/aW/9M6M64U7QyFQVSMS1HQ+9zW5P7uG22Rw7oVlHDlt06YroilYcGRDVXso6kpkQmoLm5F5vg/uINpdbISw0kdTa5XCsC0xXPLTJrDkyrf6yKTsx41bsloiNCj+vvTdhP+mPVP+pFoCaBz82XbP9aVGp9WVTTfrtu06DuxAK3yQHtNRPV1vx+kei26y8/ftXbK/d8VjEq+pR9vfzqItE3hesjgAACCCBQgwCB6BAUDURfeOGFIVtYRMBZAl+anMlf/rBXrvthozU6ekJeloxtmin9zESHdv4BdJGJLn20fbe8tWWn/G/zDlmxh+Czs155tLY2gZkzZ9a2i+31COgotjGd9FHx7rXbvC1obumKVB7lVs5pp+VSrafLcdmtoeXlW8vNo1Se/brikq1NIFonQNTJDzWFSsefA02xGhEd2tGHTFBuhQlGnzfKJ+n8VRpKw3KSCOiPueaZ/Og6AnrJxth9uRMLrjQT3J3e3SOHFHockdd9Vg+PPGqcR5p81bN//rVNLFyoEwEEEEAAAQQaLsCf/CF2ffr0ka5du8qyZctCtrKIgDMFdFSxPm5auUmaej0yqmmG7JvdRAabyQ57mpHTngQOaNlrAs+LduyRT0zwWXNez/tpt+wui96EWM68Y7Q62QQGDx4s7du3T7ZuJaw/TcyPPPZt67Ye2ogS85bx9aaKCRA1YKoB6u1FCWueoy+sE3ytXV4ury6veB/ONVmeNH+zTooYj6I5rtfsqJjEsHlGAv/nFI/Oco2UETA/WJM3V5SawGip9eWPkzqeZd5vNZA7xzxy053zb1Inyv39UK9JH0LKHye93mgrAggggEBqCRCIrnK/dVT0DTfcUGUrqwg4W2BriZmJ3aS50IeWDDOri+aT7qUPE5TWwHRnE+XRgHU0i4YwNpiJBTWf9Ve7ikRHbH9lguNLzYN8z9GUpi47Cuj/TyixE/CagdIaLC1sIXKYmaRKRx1+b0b6fmFGTWuuaU0rsWFXfAKpsetlYmr+aa/Jz29GcMazfLO5YhLDK8b7bZd7Np4OXMv5AmZuZZm7zEywbCYhXLPDWe9BeekV6S1m9fRIhkMzvE0siO7fss5/RdIDBBBAAAEE7CVAILrK/dB8ngSiq6CwmnQCu8wwnY/MSGR9hJZME6Bun+aTdub30fk+rzQzgWl95JqIT5qZXcxvHj6Xy4ymdpnZ3ctFU2poQHm3ed5qPnltMQHvLeZ5Q3GJrN6rj2LrmNBrsIxAqgiQHzq+d9q8LUmXZi7z8MhM8/NsLevNSN9AUFpHTf9gUkA4KywUX8NEX22T+V/SWS8XyZ/MJIbjOhNMSvT94PoNE9hdUi53fFIieypSFTeskjif1SbLZX2hd0BXj/j4pxdnfS6HAAIIIIBAagkQiK5yv0ePHi15eXmyefPmKntYRSD5BXaaAPVXOmrZPCgIINBwgY4dO0r//v0bXgFnRkWgpcl9rKPjJhZUVLdtr05+qJMg6ojpMvlmU7n5Ui0ql6KSKAlo3u8r3jGTGG4rl2P24c/UKLFSTRwFctJcMsPkVX58qXkx27x0MROXHm5+UTLefPFjxiJQEEAAAQQQQACBmAvwF34VYo/HI9OnT5eHHnqoyh5WEUAAAQQQCE+A0dDhOcX7KA0Qjeygj4qIi45Y/HJjRVB64bqKCRB3O2gUY7z94nU9/W7ggc9LrVQrOomhnxGa8aLnOlES0Mn9nvmqVIrjm+Em7NYXNnfJkX29MtxM6qe/JqEggAACCCCAAALxEiAQXYO05vUkEF0DDJsQQAABBMISID90WEwJP8hkIZIBrd3WQxujk4st2xJI51ExAeJWfiCSsPv05ooyWWsmMbx8nE/ymcQwYfeBC0cuoJNuTja/xnjhW3uNit63jVuO6OsJvudF3jPOQAABBBBAAAEEGidAILoGvylTpojf75eioqIa9rIJAQQQQACB2gVyc3Nl7NixtR/AHtsK6E/Te+S7zMMjB5sRjVpWmrzSgVQeOgGi0yYfsy12mA370qRPOe2lItFJDLvlMXQzTDYOs4GATqL6oglEJzr7j/6r2a+j2xoB3d28v1EQQAABBBBAAIFEChCIrkE/Oztb9t9/f5k7d24Ne9mEAAIIIIBA7QJTp04Vn89X+wHscZRAh1yXdMj1yDST81XLxl2BwLR5Xlcmy7cyAWKsb+iGXSK/n1skF472yWgTUKMg4ASBdjkuGdvJLTqyPxHFa2LOEwvcJge017yHEYBOxD3gmggggAACCCBQXYBAdHUTa4v+rJpAdC04bEYAAQQQqFWAtBy10iTFDv3JvU7sNb5zRXd2mh9PfbHB5Jk2QWkdOf2VGcFr17ywTr4BOonhX94qlhMGeOXIfiSNdvK9TKW2ax7mN1fE9xeWaeafx3TzxZnmqdYJWykIIIAAAggggICdBAhE13I3NJBw6qmn1rKXzQgggAACCFQX0JHQ06ZNq76DLUkrkOkXGdbObT20k8UmYLrUmgCxYuT0EhOk3lmctN2Pa8c0xcG9C0pkxU9lcs4In/iIR8fVn4tFLtDVpJMZ1tYt83+M/ajoLPNDnNm9PDLHPHLTCUBHfrc4AwEEEEAAAQTiIUAguhbldu3ayeDBg+WTTz6p5Qg2I4AAAgggUFlgzJgxojmiKakroMHRfVq5zUMNPFJmoqffmQkQA3mmvzCjpjftTl2faPT8teVl8uP2ikkMmzUh4BYNU+qInYCO4I9lIDovXeRXvb0yq6dHMsgKFbsbSc0IIIAAAgggEBUBAtF1MB544IEEouvwYRcCCCCAQGUB/f8GBYFQAbeJk+oke93yPHKQGamo5cft5bLQSuVRLhqYXmXWKZEJLNmokxgWm0kMfVLQzF7B6Keeekr08dFHH1n54gsKCuSvf/2r9OrVK7JOcnRYAosXL5Zbb701eOzxxx8vQ4YMCa7XtnDzzTfL0qVLa9sd3N60aVO56qqrguuRLvRt6Za+LVwmhU90/523yXKJToh4QFcPvw6I9KZwPAIIIIAAAggkTIBAdB30Bx98sPz5z3+u4wh2IYAAAgggUCGQkZEhRxxxBBwI1CvQNtslbbNNAKlbxaFbduuI6YpR0xqY/taMoNaR1JS6BdbtLLcmMbzITGI4okPiJzEsLi6Ws88+u1JQVHuwaNEi+f3vf08guu7b2eC9X375pdx+++3B8wcNGhRWIPqxxx6Td955J3hebQt5eXmNCkRrvUf288qFr0cnR0+Xpi4zAaHmqfeIJ/Ev+9rY2I4AAggggAACCNQoQCC6RpaKjb179xYNRj/++ON1HMUuBBBAAAEERC6//HJp3rw5FAhELKDpJcZ00kdFVGmXiVdpbmlN5/GFCVBrzmmdrI9SXWB3icglbxbLyYO8cqgJziWy3HbbbdWC0IlsD9e2j4Dmke9qRu4vM18yNbQUNneJTn44vL1bXPb6EUBDu8R5CCCAAAIIIJCCAgSi67npd999tyxbtkw+++yzeo5kNwIIIIBAqgqceeaZ8sc//jFVu0+/oyygeV73NROc6UNLiZnn7OtNZSadh0nlYQLUOmrapEim/Cygob07P62YxPCsYYmZxHDnzp1y9dVXV7on48aNk8LCQvnxxx+lTZs2lfal+srq1avlvvvuk9/97nfSokWLhHNobv9+/frV2I78/Pwat0e68Yi+HrniHfPNSYRl3zZu0XMHtGb4c4R0HI4AAggggAACNhQgEF3PTdG8cPqzvcsuu8z62d+OHTvqOYPdCCCAAALRFigvb/gosmi3JVCf3++XUaNGybnnnitTp04NbOYZgagLeE38qbCF2zy0ao/oP4fvt/4yAaKm9diwy37/RqIOUU+Fc5eVyWoTob9srE9y0+M7ZPT555+XdevWBVuoQenzzz8/uM5ChcBbb70lt9xyizz99NNSUlIis2fPtkUgWt/DH3300ZjeprGdPHL/glLzGq3/36q+evfr6LZGQHfPj+9rOaYIVI4AAggggAACKS9AIDqMl0BmZqb87W9/k//7v/+ThQsXytatW8M4K7aHpKebKbIpCCCAQIoIZGVlyebNm23TW5f5XXROTo643YxQs81NSaGG6M/yu5if+Xdp5pFZPSvSUazbEQhMVzz/8FO51B/uSj40DcrrJIZXmkkMO5lcuvEq3333XfBS+n6lOaHtWvTv2EsvvVRuvPHGuDRRR4s/8sgjVgBa82WnatGJS3Vywevn1T4q2muOmVjgNjmgvdIhN36v31S9J/QbAQQQQAABBOIvQCA6AvO0tLSwJj+JoEoORQABBBAIU6BZs2ZhHslhCKSeQKssl7TK8pggVkXft+3VgLRJ5WHSeGiu6W82lUtJikSm15ig/Blzi+Ti/Xwy1OTmjUdZsWJF8DIFBQWik5fasWzZskUmT54sGzZsiHkg+ttvvxXNm33//ffXOIhDB3roI5XK5AKPPPh5iWzaXbnXaeb7pOndPXJIoUdaZhKArqzDGgIIIIAAAggkkwCB6GS6m/QFAQQQQAABBBAwAjlpLhnVQR8Vgdg9ZhDmUs0vbR6aa3qJmQBRtyVr2WkmfLzojWI5ZbBX5vSO/SSGmgc6UOyQ8zjQltDnTZs2yaRJk6x5Tzp16hS6K2rLmkbppZdeskY/z50716SRqf7tR58+fazc0Mcee6z1y5KoXdwBFfnMS/GQQq/c8UnFP74skw9+di+PzDGPeKeTcQAXTUQAAQQQQACBJBQgEJ2EN5UuIYAAAggggAACoQLp5i++gWbSM31oKTUTIH6zWSc+rEjl8cmaMtmdZIHpMhMDvfVjncTQjJAe6hXNtR3tcvrpp8v69evl/fffD1a9YMECOfTQQ631k08+WSZOnBjcp4HZBx54QN5++20rIKwpPbp27SqDBg2ycs0ffPDBwWNrW2hIHToCWtuhKea0aOD8kEMOqXSJ4cOHN3jSVU33oZMP6ghoneS7atGc+nPmzJFTTjlFxowZU3V3Sq3PMCOf535bKpO7emRmD4/o5KQUBBBAAAEEEEAgVQQIRKfKnaafCCCAAAIIIIDAzwIeE5Tt1dxtHiIHm3QAxz9TJD9sqz56NRnAnv+mVFaZvl061muNFI9mn5588klZs2ZNpSp15PFjjz1mbRs9enQwEK3H6Sjg1157rdLxGrjWhwZyjzvuOCuYW1tqj4bUoZMoTpgwQRYvXhy8bnFxsTz++OPBdV3YvXt3xIFoDWzfeuut8vDDD8uuXbsq1acrOvL6t7/9rZx44onSsmXLavvtskHvo04+26tXLyksLJT99ttPhg4dGpPmNTGB53tn+WNSN5UigAACCCCAAAJ2FyAQbfc7RPsQQAABBBBAAIEYCmg+6ZVJGoQOsC1YVyan/zyJYSImgdPJVnXU89q1awNNqvH5wQcftI7RtBZVS0Pq0JzQ48ePl6VLl1atrtHrzz33nMyaNataPTqJ69SpU63Rz/rshEldi4qKrFHtoSPbjznmGLnuuuvErqlWqsGzAQEEEEAAAQQQcIAAgWgH3CSaiAACCCCAAAIIxEpAJzVMzrHQlcVWby83wegiuWSMT/ZtG508HVdccYU1Ed/tt98uOjmflm7dullBWF3ef//99UkuueSSSkFo3X7RRRdJly5dRNNzXHrppfLee+9Zx7788svyyiuvWJMKWht+/k9D6hgyZIicdNJJVg066jdwjaysLLnssstCq5cePXpUWq9vRUdQVy1nnXWWnHnmmdK5c+equxy3/tBDD8mLL74o8+fPt9KnOK4DNBgBBBBAAAEEELChAIFoG94UmoQAAggggAACCMRLYJEZLZwqZYeZxPDC14vl1H291iRxje33CSecYFXxv//9LxiI1oDuH/7wh2DVmhLjzjvvDK7rKOJnnnkmuK7B6HHjxsmwYcPkk08+sbZfeOGFlQLRDa3j448/DrZFR2MHAtH5+fnB7cGGRGFBg7c+n8+ajLCgoCAKNcauCr1POtq5VatWsnPnTvnmm28sfx0dHSiaZuXoo4+Wd999Vzye2E96GbguzwgggAACCCCAQLIKuJO1Y/QLAQQQQAABBBBAoH6BReuTPxDtMgydcl2iE8WdO9IrI9rH709gDVKXlpZaN8LlcomOnq5aNMipI54D5bPPPpO9e/cGViUadQQri9LCwIED5YADDhDtU6Bo4Pbaa6+1RoVPmzZNnn/+eSkrs+fr65577pEnnnjCysmtKVE0LcfXX38tRx55ZKA71vO8efPkxhtvrLSNFQQQQAABBBBAAIGGCTAiumFunIUAAggggAACCDheYE+JyDebky8xh8/EmXvku6RfS7f0bWEeLV2SnfZLwDSeN+7LL78MXq68vFyuvvrq4Hrogk4qGCgavNWUHb1797Y2RaOOQN3Reu7evbu89NJLVvD2lltukQceeEC2b99uVa/91H360DQdgQkL7Z5vWSdXfOSRRyQtLU3uv//+IJWmSgkd5R7cwQICCCCAAAIIIIBARAIEoiPi4mAEEEAAAQQQQCB5BJZuKJPSJIhDZ/tFCptrwLki6NzbLPtskknhq6++qvSC0aBtOEVzTgcC0dGoI5xrNuQYTXFx0003yZVXXmkFo7V/OrI4UL7//nu54IIL5C9/+YscfPDBcuqpp8rIkSMDu235fNttt8m///1vCeTBXrBggS3bSaMQQAABBBBAAAGnCRCIdtodo70IIIAAAggggECUBJyalqNFho52dlmBZx313KWpy6SIiBJKlKsJBDO12oyMDDnkkEPCukKbNm2Cx0WjjmBlMVrIzs6WM844Q04//XTRCRdvvvlma0S0jo7WoqlGdLSxPgYMGGBN6HjcccdZo49j1KQGV5ueni59+/aVjz76yKpDR6tv2bJFmjVr1uA6OREBBBBAAAEEEEBAhEA0rwIEEEAAAQQQQCBFBRatt/9waI0vdzaBZivNhgk+63PLTJtGnWt4HbVt2za4NS8vzxo1HNwQ5kI06gjzUo0+THNGa+5ofeiobh0hrWkutm3bFqxbRxhruo4RI0ZIv379gtvttLBq1apgc3QCRv0SgYIAAggggAACCCDQOIH4zdTSuHZyNgIIIIAAAggggEAUBUrNHHJLNtpvIjm/+etURzsf2dcjV+3vk2cOS5N7ZvrlzGFemdDF46ggtN4uzaUcKBrcfPPNNwOrYT9How63+5c/+0MnQgy7EQ04sFu3bvKPf/xDVq9ebQWke/Xq1YBa4n+KpuVYs2ZN8MIaLNe80RQEEEAAAQQQQACBxgn88hdp4+rhbAQQQAABBBBAAAEHCXyzuUx0ssJElxyT33lEe7f8ZqBXbprik2cPT5N/TPHLiWZ9WDu3ZJr9Ti6HH354peb/+te/ltCJCSvtNCvz58+XAw88UH766afgrmjUERpIXbt2rSxbtixYf6wXsrKy5LTTTpMlS5aITvw3Y8YMCQ2Mx/r6ofXfeOONcvTRR0voBJCh+5999lk56aSTQjfJkCFDKq1HY2XVNvv/GiEa/aQOBBBAAAEEEEAgVIDUHKEaLCOAAAIIIIAAAikikKi0HK1NWo2+P6fY0MkFO+XaN79zNF4K/fv3t9JUzJ0716puxYoV1iSEl19+uUyYMEE07YYGhZcuXSqPP/64PP3009ZxoaOWo1FHixYtKnXnb3/7m1xxxRWSn58vn376qVx33XUyZswYK3dzpQOjuKJpOyZNmmQ9Vq5cKaF5sKN4mTqr2rx5s5Wn+tFHH7XaofmqtR2aOuT111+vNmJdU3KcffbZddYZ6c4ft5fLyc8XyeA2bjnLjPTPNznPKQgggAACCCCAQCoIEIhOhbtMHxFAAAEEEEAAgSoC8Zio0G3iawUmv7MGnAPB5+YpGHT773//awV5NTeyFp34Tif2i6Q0to7x48dXutxdd90l9913n2j+48BkiH369Kl0TCxXOnToEMvq6627rKzMmlRRJ1asq1x77bXSs2fPug6JaJ/O3XjdByWyt1Tk/VVlsnBdkZw2xCuTu3oiqoeDEUAAAQQQQAABJwoQiHbiXaPNCCCAAAIIIIBAIwW+WB/9/NBpJpbWu3lF0FmDz31auCXD18iGJsHp2dnZ8uKLL1qT8+mI6PrK0KFDq02O19g6NMh87LHHyj//+c/g5UtKSkQfqVT8/vByvWRmZspf/vIXOfXUU6PK8/w3pbJg3S//9nYUi1zzfom8trxM/jjcK62yGB0dVXAqQwABBBBAAAFbCZAj2la3g8YggAACCCCAAAKxF/jhp3L5aW/jr9PUzN82qoNbfjfYK7ccUJHf+brJPjl+gFeGtE2dILSOKg6U0OXANn3W9A/vvPOOnHnmmZKTkxO6y1pu2rSpTJw40cqhrHmiNa9y1dLYOu699165/vrrRa8VWrxer8yePVtmzpwZutkRy1W9q65X7cSFF14ob7zxhhWU17QkoUVTh3Ts2FGOOOIIWbx4sZxzzjmhuxu9vH5nudz1Sc2B/0/WlMmJzxXJs1+Vio6apiCAAAIIIIAAAsko4Co3JRk7Rp/CE7jjjjtimgswvFZwFAIIJLPAtGnT5IUXXkjmLtI3BBwn8IIZlXn9vJoDYnV1pq0ZrRlIsaEjnjua/M6UyAX0z+/169fLxo0bRVNEaPAzNzc3oooaU4dec/ny5aJ5mlu2bCmdO3euNgI7osY4+ODt27eLjlL3eDyi6UJq+gIgWt274H/F8uGPv4yGrq3evi1ccu5In7TP4d9XbUZsRwABBBBAAAFnCpCaw5n3jVYjgAACCCCAAAINFlgUkhqgtko0v3O3ZhX5nfv9nOM5rwmBsdq8ItmuI29btWplPSI5L/TYxtThdrula9eu1iO0zlRc1pQnffv2jXnXX1lWGlYQWhvyxYZy+Y0ZHX3CQK/M6eURD79hjfn94QIIIIAAAgggEB8BAtHxceYqCCCAAAIIIICAbQQ00FW1pJu/Cgt/zu+sgWfN9dzkl4wTVQ9nHQEEwhTYsrtcbvs4sl8gFJmB03eYNB6vLy+1RkcXmC+FKAgggAACCCCAgNMFCEQ7/Q7SfgQQQAABBBBAIAKBjbvKZc2OcmmWLtLXTCbYr5V5mMBzVxPoYuRlBJAcikCYAjd9WCLbi8I8uMphX28ul1NeKJKj9/HI4X284jMTglIQQAABBBBAAAGnChCIduqdo90IIIAAAggggEADBHzmZ/4PHugn/2wD7DgFgUgF3l5RJm//UH9e6LrqLTE/YHjg81J5y9R1zgiv9DK/VqAggAACCCCAAAJOFOCvGCfeNdqMAAIIIIAAAgg0UCA33UUQuoF2nIZAJALb9pbLTR8WR3JKnccu31ouZ8wtlrs/LZG9kWX6qLNediKAAAIIIIAAAvESIBAdL2mugwACCCCAAAIIIIAAAikjcNtHJbJlT3S7W2ZGR/97can85vkiWRjGpKPRvTq1IYAAAggggAACjRMgEN04P85GAAEEEEAAAQQQQAABBCoJfLi6TF5d3riUHJUqrLKyenu5/OGVYrnF5J/eHb1B11WuwioCCCCAAAIIIBBdAQLR0fWkNgQQQAABBBBAAAEEEEhhgZ1mYsLr58U+d4YZHC1PfVUqJz5XJB//GLugdwrfSrqOAAIIIIAAAlEWIBAdZVCqQwABBBBAAAEEEEAAgdQVuMvkcN6wS8PE8SnrdpbLef8rlr9/UCI7TBCcggACCCCAAAII2FWAQLRd7wztQgABBBBAAAEEEEAAAUcJLFhbJi98U5qQNr/0bamc8OxeefcHRkcn5AZwUQQQQAABBBCoV4BAdL1EHIAAAggggAACCCCAAAII1C2wx2TjuM6MSo7fWOjq7dm0W+TSt4rlineKZeueRLaketvYggACCCCAAAIIEIjmNYAAAggggAACCCCAAAIINFLgh5/KTWoMewR/3/i+TI5/pkj+tzwxo7MbScnpCCCAAAIIIJCkAgSik/TG0i0EEEAAAQQQQAABBBCIn0CPfJfcN8sv+3Wwx0esbSZf9FXvlshFrxfLxjjmrI6fOFdCAAEEEEAAAacJ2OOvJKep0V4EEEAAAQQQQAABBBBAoIpAsyYu+cs4n1w21id56VV2Jmh13uoykzu6SDSHNAUBBBBAAAEEEEikAIHoROpzbQQQQAABBBBAAAEEEEg6gdEd3dbo6Ild7PFxa2exyN9N/upzXy2WNdvtkT4k6W46HUIAAQQQQACBegXs8ZdRvc3kAAQQQAABBBBAAAEEEEDAOQLZaS65YLRPrt7fJy0zXLZo+Kdry+Sk54vkqS9LpYx4tC3uCY1AAAEEEEAglQQIRKfS3aavCCCAAAIIIIAAAgggEFeBoe3ccq/JHT2ju0fsEI7eUyJyy0clctbLRaITLFIQQAABBBBAAIF4CRCIjpc010EAAQQQQAABBBBAAIGUFMjwiZw93CvXTfZJu2w7hKNFFm8ol5PN6Oh/f1EqpWUpeVvoNAIIIIAAAgjEWYBAdJzBuRwCCCCAAAIIIIAAAgikpkD/Vm65e4ZfDu7tEbcN4tHFJgB992clctpLRbJsM6OjU/NVSa8RQAABBBCInwCB6PhZcyUEEEAAAQQQQAABBBBIcYE0r8gp+3rl5gN80jnXBtFocz++MUHoU18skgcWlEhxaYrfILqPAAIIIIAAAjETIBAdM1oqRgABBBBAAAEEEEAAAQRqFujV3C13TPfLUX094rVBPLrEDIh+aFGp/PaFIlm6gVwdNd81tiKAAAIIIIBAYwQIRDdGj3MRQAABBBBAAAEEEEAAgQYK+DwiJwz0yu0mIN0jzwbRaNOPFWYCwzPmFsudn5TIXjOxIQUBBBBAAAEEEIiWAIHoaElSDwIIIIAAAggggAACCCDQAIGCZi65ZapfThjgFb8NPqFptuj/LimVk54rkgVrGR3dgFvKKQgggAACCCBQg4AN/sypoVVsQgABBBBAAAEEEEAAAQRSSMBjPpkd1c8jd5nJDPu2sMfo6B93lMs5rxbLjfNLZFdxCt0MuooAAggggAACMREgEB0TVipFAAEEEEAAAQQQQAABBCIX6GAmMLxhil9OMxMappuJDRNddHT0s1+XygnPFsmHqxkdnej7wfURQAABBBBwsgCBaCffPdqOAAIIIIAAAggggAACSSfgNgOi5/T2yL0z/TKotT0+sm3YVS4XvF4s17xXLNv2aniaggACCCCAAAIIRCZgj79qImszRyOAAAIIIIAAAggggAACSS/QOssl107yyR+GeyXTZ4/uvvJdmTU6+t0fGB1tjztCKxBAAAEEEHCOAIFo59wrWooAAggggAACCCCAAAIpKDC9u0fum+WXEe3t8fFtyx6RS98qlsvMY8tuRken4EuSLiOAAAIIINAgAXv8JdOgpnMSAggggAACCCCAAAIIIJAaAs0zXHLFeJ9cNNoruWn26PPbZlT08SZ39GvfldqjQaYVq7eVy7Nf2ac9toGhIQgggAACCNhAgEC0DW4CTUAAAQQQQAABBBBAAAEEwhHYv0vF6OhxnezxUW57kcjV75XIhf8rlg07Ezs6utxc/u8flMg9n5UwUjucFxPHIIAAAgggEGcBe/z1EudOczkEEEAAAQQQQAABBBBAwKkCTdNdcskYn1w+zif5TezRi/k/lsmJzxXJ81+XigaEE1GeNddeuL5MdhaLCUYzKjoR94BrIoAAAgggUJcAgei6dNiHAAIIIIAAAggggAACCNhUYFQHt8kdnSZTutrjY50GgG+YXyLnvFosP26PbzR6vRmNfc+nJcE79fKyUvl6U3zbELw4CwgggAACCCBQo4A9/mKpsWlsRAABBBBAAAEEEEAAAQQQqEsgyy/yp5E+uWaCT1pluuo6NG77Fqwrk5PM6OgnlpZKWZxiwdfPK5Fdv8ShRS9784fFCRudHTdsLoQAAggggICDBAhEO+hm0VQEEEAAAQQQQAABBBBAoCaBfdu65d6ZfpnVwyN2CEfvNZkxbvu4RM6cWyQrtsY2Gj3321L5yKQGqVqWbCyX15aToqOqC+sIIIAAAggkSoBAdKLkuS4CCCCAAAIIIIAAAgggEEWBJj6RM4d55R9TfNI+2w7haBENBv/2hSJ5ZFGplFaPFTe695t3l8sdn4QMha5S490mXcdukzKEggACCCCAAAKJFyAQnfh7QAsQQAABBBBAAAEEEEAAgagJ9G3plrvN6OhDCz3itkE8utgEoO9bUCKnvlgk326O7ujom0xO6u1FtdNt2i3y8KLaA9W1n8keBBBAAAEEEIi2AIHoaItSHwIIIIAAAggggAACCCCQYAG/R+S3g71y61S/dGlqg2i08fh2S7kVjL73sxIpjkLGjDe/L5V3VtY/zFpzVcd78sQE334ujwACCCCAgC0FCETb8rbQKAQQQAABBBBAAAEEEECg8QI98l1yx3S/HLuPR3w2+PRXagZE/+uLUjn5+SJZsqH+IHJtAtv2lsstH4U30llHZN8a5rG1XY/tCCCAAAIIINB4ARv8KdL4TlADAggggAACCCCAAAIIIIBAzQJe86nvuP5euX2aX3qawLQdyg/byuX3c4vlNhMg3hNePLlSszWwvGVPpU11rsxbXVbjhIZ1nsROBBBAAAEEEIiqAIHoqHJSGQIIIIAAAggggAACCCBgT4EuzVxy8wF++c1Ar6SZ1B2JLpot+okvS+Wk54rkszXhj46eb4LKry0P//hAPzXoXRL5aYHTeUYAAQQQQACBRgoQiG4kIKcjgAACCCCAAAIIIIAAAk4R8JhPgIf39chdM/zSr6U9Rkev2VEu57xWLDfMK5GddUw8qMa6/4Z5xQ3i1lHYT5nANwUBBBBAAAEEEiNAIDox7lwVAQQQQAABBBBAAAEEEEiYQPscl9ww2S9nDPFKE2/CmlHpws9/UyonPLtX5q2qfdjynZ+UyIZdlU6LaOWhhSalx24di01BAAEEEEAAgXgLEIiOtzjXQwABBBBAAAEEEEAAAQRsIOAyA6Jn9/LIvTP9sm8be3w03Lhb5KI3iuXqd4tFJyQMLQvWlsmL3zZuRPNOM5j6ns8akJQ6tCEsI4AAAggggECDBOzx10aDms5JCCCAAAIIIIAAAggggAACjRVoleWSayb65JwRXsnyNba26JyvOaBPeLZI3lpRMTpaJzT8+wclUjk03bBrvbysTL7eFI2aGnZ9zkIAAQQQQCBVBQhEp+qdp98IIIAAAggggAACCCCAQIjA1G4euW+WX0Z1sMfHxC17RC5/u1gufbNYbv6wRDSXdDSK1nLzh8VSHp3qotEk6kAAAQQQQCAlBOzxF0ZKUNNJBBBAAAEEEEAAAQQQQMDeAvkZLrl8nE8u3s8rTdPs0dZ3V5bJ3GWNS8lRtSdLNpbLq99Ft86q12AdAQQQQAABBCoLEIiu7MEaAggggAACCCCAAAIIIJDyAuM7e+T+A/2yf+fk/ciouaJ3m5zRFAQQQAABBBCIj0Dy/lURHz+uggACCCCAAAIIIIAAAggkpUBOmksu2s8nV473SfMmydfFTWZixIcXMXFh8t1ZeoQAAgggYFcBAtF2vTO0CwEEEEAAAQQQQAABBBCwgcDw9m6TOzpNNId0spUnlpbK6m0ki062+0p/EEAAAQTsKUAg2p73hVYhgAACCCCAAAIIIIAAArYRyPSLnDPCK9dO9EmbLJdt2tXYhhSXidz2MaOiG+vI+QgggAACCIQjQCA6HCWOQQABBBBAAAEEEEAAAQQQkEFt3HL3DL/M6eWRZAlHz1tdJh+aBwUBBBBAAAEEYitAIDq2vtSOAAIIIIAAAggggAACCCSVQBOfyGlDvHLjFJ90zEmOcLSOii4hFp1Ur1M6gwACCCBgPwEC0fa7J7QIAQQQQAABBBBAAAEEELC9QJ+WbrnLjI4+oo9HPA6PR680eaKf+rLU9uY0EAEEEEAAAScLEIh28t2j7QgggAACCCCAAAIIIIBAAgV8Zv7CkwZ55dapfunazNnR6IcWlsiW3UxcmMCXE5dGAAEEEEhyAQLRSX6D6R4CCCCAAAIIIIAAAgggEGuB7vkuuW2aX37d3yM+h37K3Fkscs9nTFwY69cK9SOAAAIIpK6AQ/9ESN0bRs8RQAABBBBAAAEEEEAAATsKeM2ny2P28cqd0/3Su7kzR0e/vKxMvtxIsmg7vr5oEwIIIICA8wUIRDv/HtIDBBBAAAEEEEAAAQQQQMA2Ap2auuSmA/zyu8FeSTOpO5xUNDHHrR+VSDkZOpx022grAggggIBDBAhEO+RG0UwEEEAAAQQQQAABBBBAwCkCbjMg+pBCj9wz0y8DWjnrY+eSjeXy6ndMXOiU1xrtRAABBBBwjoCz/iJwjistRQABBBBAAAEEEEAAAQRSXqBttkv+PsknZw3zSobXORyaK3qXyRlNQQABBBBAAIHoCRCIjp4lNSGAAAIIIIAAAggggAACCFQRcJnR0TN7eOTeWX4Z2tYZH0E37RZ5ZBETF1a5lawigAACCCDQKAFn/BXQqC5yMgIIIIAAAggggAACCCCAQKIFWma65OoJPjlvpFey/YluTf3Xf2JpqazaRrLo+qU4AgEEEEAAgfAECESH58RRCCCAAAIIIIAAAggggAACURCY3NUj95vR0flNolBZDKsoLhO5/WNGRceQmKoRQAABBFJMgEB0it1wuosAAggggAACCCCAAAIIJFpg8YZy0fQXdi/zVpfJh+ZBQQABBBBAAIHGCxCIbrwhNSCAAAIIIIAAAggggAACCIQpsH1vudw43zkzAd5mRkWXEIsO8+5yGAIIIIAAArULEIiu3YY9CCCAAAIIIIAAAggggAACURbQwO7mPVGuNIbVrTR5op80+aIpCCCAAAIIINA4AQLRjfPjbAQQQAABBBBAAAEEEEAAgTAFNM3FK985b3jxw4tKZMtuJi4M8zZzGAIIIIAAAjUKEIiukYWNCCCAAAIIIIAAAggggAAC0RTYZbJx3DDPmZP/7TRtv/szZ7Y9mveQuhBAAAEEEGiMAIHoxuhxLgIIIIAAAggggAACCCCAQFgCd39aIut3OXdU8SvLyuTLjc4bzR3WzeEgBBBAAAEE4iDgjcM1uAQCCCCAAAIIIIAAAggggEAKC3y+rkye+9rZeZY1hH7LRyVy8wF+cblS+GY6vOvr1q2Tyy67LNiLCy64QDp06BBcZ6G6wNlnny179+61dhx11FEyatSo6gexBQEEEAhDgEB0GEgcggACCCCAAAIIIIAAAggg0DCBvSajxXUflIhzx0L/0u+lG8vl1e9KZXJXzy8bWXKUwJo1a+T2228Ptvnoo48mEB3UqHnhpptukrKyil8D9O7dm0B0zUxsRQCBMARIzREGEocggAACCCCAAAIIIIAAAgg0TOD+BSWyensyhKEr+q8pRjTfNQUBBBBAAAEEIhMgEB2ZF0cjgAACCCCAAAIIIIAAAgiEKaA5lZ/40tkpOap2dfMekYcWMnFhVRfWEUAAAQQQqE+AQHR9QuxHAAEEEEAAAQQQQAABBBCIWKDYxJ+vfb9EypJnMHTQ4CkTXF+1LQk7FuwhCwgggAACCERfgEB09E2pEQEEEEAAAQQQQAABBBBIeYFHFpXI9z8lZ7C22KTLvf1jZ4yK3rp1q5x55pkp/3oEoLoAr43qJmxBAIHYChCIjq0vtSOAAAIIIIAAAggggAACKSfw3ZZyefSL5ErJUfUmzltdJh+ah53Lli1bZNKkSfLMM8/YuZm0LQECvDYSgM4lEUBACETzIkAAAQQQQAABBBBAAAEEEIiaQKmJzV77frGUJOdg6EpOt35UIiU2jUVv2rRJJkyYIB9//HGlNrOCAK8NXgMIIJAoAW+iLsx1EUAAAQQQQAABBBBAAAEEkk/gv0tK5evNKRCFNrdu1fZyeXJpqRzaxxPzG/n888/LrbfeKl999ZVs2LBB2rdvL927d5dZs2bJEUccIZmZmcE26P6JEyfKwoULrW0//vijHHLIIcH9ujB8+HD54x//WGmbrpSWlsqHH34oX3zxhSxatEg0aNmmTRvp16+f7LPPPjJw4MBq5wQ2fP3113LxxRcHVoPPPp9PunTpIl27dpVu3brJkCFDJD09Pbi/IQsbN26Um2++WT7//HOrnbqu1ygsLJRzzz23znaGXm/Pnj1y3XXXifouXrxYduzYIQMGDLDaeOqpp0rPnj1DDw8uq93KlSut9ZkzZ8oxxxwjq1evlvPPP19eeeUVycjIkHHjxlke2m9Ng3HyyScHz7/kkkss0+CGnxc++eQTueaaa6w1l8sl9913X/DeRsO3Ma+NQFv1NXHKKacEVq37evXVVwfXqy6cccYZsm7dOmuzx+ORhx56SLxewlFVnVhHIBUEXOWmpEJH6WPNAnfccUel/4HUfBRbEUAAgYYLTJs2TV544YWGV8CZCCCAAAIIIOAYgZUmJ/TJzxdJkU1HCccCMsPE0x6c7Ze8Jq5YVG/V+Zvf/EbuueeeWuvPzc0VDWBqwFMDfjoSWoOqdZXp06dbwdfQYxYsWCB6rbpGUevfdvo5skOHDqGnWstvvPGG7L///tW2V93QqVMnueqqq6wAugZbIy3/+9//rMDvmjVrajxV67zwwgvliiuuqLZf+1hXMD30hOzsbLn//vvlV7/6Vehma1m/BPj222+t5dNPP93Kwz127FjRoDA1y3sAAEAASURBVH9oycrKknvvvVeGDRsmnTt3Du7SwLfeg6rliSeekIMPPji4We9ny5YtrfXG+jb0taHB47Kyin/UN910k2h/Bw0aJGoZKJ9++mmNrm+//baoS6BMnjxZXn755cAqzwggkGICpOZIsRtOdxFAAAEEEEAAAQQQQACBWAnoJH6/HeyVw80I4f07u6VvC5e0yHCJO/JYY6yaGPV6d5k5C+/5zPwnRkUDk3UFofWyP/30k2zfvl007+/48ePrDULX1FQd0aojlesKQut5L774ovTp00cef/zxmqoJa9uKFSvkqKOOkjFjxoiOSI60aDCztiC01qXj7a688kp57rnnIq260vFqqkHhp556qtL2qis7d+60gspVg9B6nI6wDgSsq54Xq/WafBvz2qjaTg3064ju0KJfLNRUrr322kqbdcQ4BQEEUleA30Kk7r2n5wgggAACCCCAAAIIIIBAVAUKmrmkoFn1NBWaN3rT7nLZsLNc1pnH+p0iG3bp8y+PbUVRbUpcK3tlWZnM6lEmvZpHf6zXa6+9Vqkvl112mTVCd9WqVfLqq6/KnXfeaQU7AweddNJJ1uKTTz4p7733nrWso3L1vNDSo0eP4Kr+ek1HEIeWvn37yujRo6Vp06by3XffibZj8+bN1iEaoD3++OOtUbEFBQWhp1Va1iCujn7etm2b9dCUH8uXLw8e8+6778p5550nN954Y3BbOAuB0bma/kJHf+sobA34PvbYY8F0JFqPjtzWtBn1FR3dfMIJJ4iaaPqL2267LZh2Q8/905/+JDNmzBBNMVJT0VHTWnTE869//WsrvYmmn/j++++tVCSaxmPt2rU1ndqobZH6NuS1UVsDDzroINHXiKZw0aKvN00bE5rKZOnSpZV+GTl06FDri5La6mQ7AggkvwCB6OS/x/QQAQQQQAABBBBAAAEEEEiogMfEZ1tmuqxHn1passcMKv4lUG2C1sFAtVgBa13fW1rLyQnerPkubzETF958gF/MYNGoFs3pG1o0dYbmbNZRyVOmTLFyEmu6hFatWkmzZs3kD3/4g3W4Bj4Dgej8/Pzg9tC6dHn9+vVWEDaw3e/3i46OPuuss8Tt/iWwru3QlAz//e9/rUM18KtB1zfffLPScYF69Pnss8+WkSNHhm6Sf/7zn9b1NBe1Fs3zfOCBB4aV0iO0Ig0aP/PMM9KrV6/g5gsuuEBat24tmi9aSyBIGjyghgX1VL/QnNUasNXA8/z5860zdETz3XffLZozuraiObQ1WB9Io3HOOefI73//eyv9SFpaWm2nNWp7pL6RvjbqalxgVPRhhx1mHaZfDujr5oEHHgieprm3Q7PBMho6SMMCAikr8Mv/VVKWgI4jgAACCCCAAAIIIIAAAggkWiDdDJPqkOuSfdu6ZVp3jxzX3yvnjvTJtZN8Vg7mF49MkycP8csd0/xy2VifnD7EK4cWemRcJ7cUNndJ8yYiUY4BR0SydGO5vPpd9CPlOuo0tGjw+bPPPgtuat68uVx++eVWcDq4MYKF//znP1YwOnCKplzQgGVoEFr3tWjRQv79739XChi/8847oqOaIynHHnusVU/gHA1UBoLbgW31PetobB1dHRqE1nM0l/GcOXOCp+/atSu4XNuCBtNDg9B6nJpq4DnU4K233qqtCmv77bffHgxC64acnBwrKKv3K54lGr7htldHZPfu3Tt4+COPPCKaFkSLfhHy8MMPB/fpvZo9e3ZwnQUEEEhNAQLRqXnf6TUCCCCAAAIIIIAAAggg4DiB3HSXdM93yeiObjmol8fKR33JGJ/cPNUv/zk4TV4+Kk3+dZBfbpjskwtHe+WkgV6TMsMjw9u5paCpS7L9se3y3Z+WyK7i6F7jlFNOEZ00L1AWLVpkTXx37rnnWnmhA9sb+hwY9avnt2/f3kqVUVtdOgpWA7ShJXTCutDtdS1rALNLly7BQ8IZuRw82Czcd999ohM0Vi0fffSRrF69Org5NJAc3Bjmgo5w1rQfgfLNN98EFqs99+/fX0aNGlVte6I2NNY33Har78UXXxw8vKSkRAI5oXWU+d69e4P7NL2Jvn4oCCCQ2gIxS82hP9u5/vrr5dlnn7VyK+kbEiV6AjpDseZfoiCAAAKpIKATwOgoHEpsBHQUUOfOna1RKvoTUs0FSUEAAQQQQMCJApoCpFWWy3rU1v7dJlBs5aYOpv4I5Kn+JW+1TrrYkLLZzLv30MISK0DekPNrOkdTbrzyyisya9YsCaTpKC4ulr///e/WhIEPPvigNelfTeeGsy00EK2TFdaWBzlQl+aEbtu2rQQm5vv8888DuyJ61okKA/miIw1Eh15IA8SaDkJHdi9btix0lxQVNS7xuI721TzcWuoKRIeOCq7UgASuRMu3vi5oag7NP665tbXce++9VloXzc8dKPoFx9FHHx1Y5RkBBFJYICaB6E8//VSmTZsm69atS2Ha2Ha9ITMLx7ZF1I4AAgjEVmD37t2xvUAK1662OpO6/sz3rrvukhdffFH22WefFBah6wgggAACySzQxMw318mMjtZHTcVkipCtezRHtfw8sWIgUP1L3urN5s8SzQtdU3nqy1KZblKLtM+puf6azqlv2/Dhw+WDDz6Q4447Lpj3Wc/RyfDGjx9vjRDWfQ0pOpFgoGgu6XCKpq4IBKK1DQ0pOrgqUDTftA5e83rDD1HoyGcNgOro6EC+6czMTGv0eLQmBgzN7Rya6zjQ7sCzetitNNY33P5oOpSLLrrIem3qORqrGDBggOhAkkDRVC/1fcEROJZnBBBIboHw3+XDdNAPsgShw8TiMAQQQAABBGwmoB/qpk6dKkuWLKnxJ682ay7NQQABBBBAIOoCmj2gWROXeYj0MGlAairFJhX0Rh1RHRxV/fOEijsrtj34eYlctJ+JeEexdO3aVTQn8/3332+lzwhMyKeTxJ188snSs2dP0YB1pKWwsDCYI3rp0qX1nq5B38DoVz24Y8eO9Z5T0wGhI4y1b5EEoT/55BMrV3UgiK4jbjVVieaOVp8zzzyzpktGvC20n+rUmFI1TUg4+asbc73G+EZ63SOPPNLKUx4YkR4ahM7LyxOdEJKCAAIIqEDUc0RrOg5GQvPiQgABBBBAwLkCOsJJ8/pREEAAAQQQQKBmAZ9HpE22S/q3csukAo8c1c8jZw/3ylUTfHLPTH/Ug9CBVmiO3RNOOMFK03jEEUcENlspKG688cbgui6EBj5Dc/VWOsis6OjVQNEJABcuXBhYrfH5oYceska9BnaOHj06sBj28+bNm+W1114LHl91QsbgjhoWNPCuo78DQeihQ4fK4sWLRdOLhebSruHUiDbpl/OhbezTp09E51c9uGpO60CalarHRWO9Pt9wXxvhtkW/RLjwwgtrPPy0006TrKysGvexEQEEUk8g6oHop556KvUU6TECCCCAAAJJJqDpOSgIIIAAAgggkHiBSy65xBoJHdoSHWX6yCOPWJMLBra/++67gUXrOTSthKaqCIxWrXSQWdFcwoGiuac1yKuBzJqKjpg+++yzK+0aO3ZspfVwVnTiuk2bNgUPjWQkt86VpIHnQNEAdE5OTmA1Ks/qcMYZZ1RKLxFJG2tqhAbJQwPAGvSvWjT9RzT+BqvPN9zXRtX21bV+zDHHWHOOhB6TkZFhfUEQuo1lBBBIbYGoB6JXrFiR2qL0HgEEEEAAgSQQCPzcNwm6QhcQQAABBBBwtIAGJjVYfNBBB1l5ojWXspaPPvoomFJD10ODnLpedaLnv/3tb9Zkhzqi+OOPPxYdUX377bdb9c6YMUNPscqCBQtEJ9/T3MsavNacvzqZ4BVXXCGDBg2SrVu3Bg61UmB069YtuF51QSdZDA2Aa0Bc+6ET2gWKnq9B33BLIDd14Piq66EpKQLH1DVp4csvvyzvv/++ZaOjrN98803Zb7/9JHSQnY4aP/HEEwPVNehZR7P3798/eO5jjz0m8+bNC65rnuxf//rXlntwYz0LDfUN97VRz+Ur7dYc0JqiI7SomR3zZ4e2kWUEEIivQNRzROs3XvoGSkEAAQQQQAAB5wp06tTJuY2n5QgggAACCCShwNNPPy360An5dET0ypUrK/UyNJisO3QSw9CiExJrcFkDhoFJoAPpJu655x7p16+fFYzVc9avX19v4HXgwIGiwe26ik4mqI82bdpY1/3hhx+qHX7nnXdKenp6te21bejVq1elXVdddZXVbg2ea/D4ueeeC+7XoPnvfvc7a5sGbQP9DR5gFi6//HLrEbotdFnTTqhbJDmsQ88PXT7ssMOsyaF1m+aI1oD34MGDRYPU+uVA4EuG0HPqWm6obySvjbquH7pPR3M/88wzwU3qdc455wTXWUAAAQRUIOojovfdd19kEUAAAQQQQMDhAhMnTnR4D2g+AggggAACySFQNUirE8FVDUJ36dJFLr300kod1qDrscceW2mbBjoDQejQHa1atZK3335bRo0aFbq51uWjjjpK5s6dK36/v9ZjQnesWbNGqgahdaSsjgref//9Qw+td7ldu3YyZ86c4HEabL722mut3NmhQejAARro1lHTOhI80qKuOiJdg+7RKJoyI/Se6P2YP3++NTJalz0ejzXqPNJrReobyWsj3LaofWjKFB1x39CJLMO9JschgIDzBKIeiJ45c6bzFGgxAggggAACCFQSOPDAAyuts4IAAggggAACiRF44YUXrEmEa5rQTwPBOhmcpnho2bJltQZqCozrr79emjZtWmmfjladPXu2hH5+15HG77zzjtx6661W4LVqALxZs2ai+aB1Ar+HH364xutVuohZ0UBu1fzNGkjWQLam+zj44IOrnhLWuo7gPvzwwysdq33UEbiaCiQ0AKoT5emo5x49eljH9+zZU3R0uH7pXtPkhmqjFho01jZOmjSp0nUCKzqyPFBClwPbanrWkc86uvrcc8+V0JQmeh/1S4C33nqr0hcKerwGp2srjfGN5LUR2r/Q5dB2/fWvfw2uarvPO++84DoLCCCAQEDAZX4+UR5YicazfjMb+qYfjTqpo7qAGkcjH/cdd9whp5xySvULsAUBBBCIksC0adNEP0A1pujIH2bbboxgZOcWFBRUyucY2dkcjQACCCCAAAKxEti+fbt8//33onM5aEBXA5G1BQZD26CjgZcvX26NpNaAdefOnUXTatZVSktLRfMta5qO7t27W+k16jpe973xxhuVRji/9957MmLECKuedevWSWFhoeTn59dXTdj7dTT0qlWrJDc3Vzp06BA8T/v72WefWaOgNYDfpEmT4L6qCz/99JM1Ylrbp7mTNWAdjmnVehqyrvdSRzPriOuqgf+a6ouFb0NeG1XbpqPpQyet1C84nn322aqHsY4AAghI1HNE65u/pufQ/EYUBBBAAAEEEHCegE4iREEAAQQQQAAB+wnoCF7N5Rxp0YkMu3btaj3CPVdH4urI4Ko5mcM9P3Ccjo7V4G5gRHJgezSedRR01dHeWq/2V3Mvh1M0iK0PzTEd76JfCOijMaWxvg15bVRtb+hoaN13/vnnVz2EdQQQQMASiHpqDq111qxZ8CKAAAIIIICAQwVIy+HQG0ezEUAAAQQQQACBOAssWLBAXnrppeBVdQLGkSNHBtdZQAABBEIFCESHarCMAAIIIIBAigvk5eVZP6FNcQa6jwACCCCAAAIIIBCGwDXXXFPpKEZDV+JgBQEEqghEPTWH1t+/f38rT3TVWXGrXJtVBBCwmYD51Zy0yXdLx1Z+ad7UL/k5fsnL9UvTLK+k+T3m4Ra/1yVej1uKS8tkb3GZFJvHrj1lsnlbkXkUW89rN+2VH9bpclRT0NtMi+YgkJwCmtNPJ+mhIIAAAggggAACCCBQl4BODPnYY48FD9lnn31E54ehIIAAArUJxOyTpv6s9+abb67tumxHAIEECpg4svTo6JO+BVnSp0u29CnIloJ2mdKhZbr4fdH7ocSO3aWyYu0u+XrlTlny3Xb54rttsvi7XSZIXZrA3nNpBBCoS4D0WnXpsA8BBBBAAAEEEEAgIHDttdeKTmoZKOedd15gkWcEEECgRgEC0TWysBGB5BJI84mM7Jcpw/s2k2HmMaRXU8ls4ol5J7PMNaxAtwl2HzSmdfB667bslfmLt8q8L7bI+ws3y4JvioL7WEAAgcQJpKWlyaRJkxLXAK6MAAIIIIAAAggg4AiBtWvXygMPPBBsa5cuXeSwww4LrrOAAAII1CQQs0C0JqjPycmRbdu21XRdtiGAQIwFOrX2yJRh+TJpaAsZ3T9fmqRFb6RzY5veqlmazBrdynpoXRu2FsnrH2+UVz/cIK98uFW27SSlR2ONOR+BhghMmDBBsrOzG3Iq5yCAAAIIIIAAApKfny9Dhw4NSujcE5ToCdjJ98MPP7TSsgZ6d9ppp4nHE/vBToHr8YwAAs4UiFkg2u/3y/Tp0+XRRx91pgytRsCBAu1auGX2mJYyZ3wbGdwz1zE9aGHyUR82sa31KDI5p1//ZKM8+eYaefH9rbJjN0Fpx9xIGup4AdJyOP4W0gEEEEAAAQQSKqA5gufPn5/QNiTzxe3kq3838rdjMr/a6BsCsRGIWSBam6tvSgSiY3PjqBWBgIDP/CueNjJXjpvWQcYPai464aCTi+aoPmB4S+uxe2+ZPP32GnnghZUmlcceJ3eLtiPgCAH9ApmCAAIIIIAAAggggAACCCCAQCwEYhqIPuCAA8Tr9UpJSUks2k6dCKS0QKs8t/x2dns5Zmp70RHFyVg0ncgRk9pZj69+2CF3PrVC/vXKBtlDSulkvN30KcECQ4YMkfbt2ye4FVweAQQQQAABBBBAAAEEEEAgWQVimjS2adOmMm7cuGS1o18IJESgVyef3HpON1n08Gj5wxEFSRuErorbs2OWXH9mH1n86Ci54Nj2kp8b07evqpdnHYGkFzjwwAOTvo90EAEEEEAAAQQQQAABBBBAIHECMY/kkDMocTeXKyeXQPcOXrnv4p7ywd2j5Kgp7UVTWKRiyc/xyXnHdJOFD42SS0/sKE2zHZ6LJBVvIn22pQD/v7blbaFRCCCAAAIIIIAAAggggEDSCMQ8kjVz5sykwaIjCCRCoL2ZgPCO87rLvHtGy5yxbRyfAzpahplNPHL24QVWQPr8Y9pLRjoB6WjZUk/qCXTu3Fn69euXeh2nxwgggAACCCCAAAIIIIAAAnETiHkgWj/c9u/fP24d4kIIJItAkzSXlYLio/tHy+ET24kn5v9anSmXk+mV84/tJh/dP0wOndDMmZ2g1QgkWIC0HAm+AVweAQQQQAABBBBAAAEEEEgBgbiEtviAmwKvJLoYVYGZo3OtwKqmoNAJ+yj1C7Rrni53nd9fXrlpgPQp8NV/AkcggEBQgLQcQQoWEEAAAQQQQAABBBBAAAEEYiQQlwgXH3BjdPeoNukEWuW55aFLe5vHQGnfIj3p+hePDg3t3VTeum2kXHJ8B0kjHh0Pcq7hcIHc3FzZb7/9HN4Lmo8AAggggAACCCCAAAIIIGB3gbgEogcNGiTt2rWzuwXtQyChAkdMypMP7xspM0e3Smg7kuHiXo9L/nhkV3nvriEyuFdaMnSJPiAQM4Hp06eLz8e3NjEDpmIEEEAAAQQQQAABBBBAAAFLIC6BaJfLJYyK5hWHQM0COZkuue/innL7n/aRXJPvmBI9gW7tM+XlfwyXc45sK+64vNtFr+3UhEC8BEifFS9proMAAggggAACCCCAAAIIpLZA3EIzBKJT+4VG72sWGFqYbkbtDpM5Y9vUfABbGy2go6MvPr6HvHBdf2mTH7e3vEa3mwoQiIeAjoQ+4IAD4nEproEAAggggAACCCCAAAIIIJDiAnGLyowfP14yMzNTnJvuI/CLwEmzWprg6DDp0JJc0L+oxG5pRN9m8tbtw2VUvyaxuwg1I+AwAf1/c05OjsNaTXMRQAABBBBAAAEEEEAAAQScKBC3QHRaWppMnTrViUa0GYGoCugEerf/qbv8/YxC8XldUa2byuoWaNnML89cO1ROmUMe7rql2JsqAvxaKVXuNP1EAAEEEEAAAQQQQAABBBIvELdAtHaVPJSJv+G0ILECeTkuefbvA+SISUzemag7oak6rj6lt/zj7K7iies7YKJ6zHURqF1gxowZte9kDwIIIIAAAggggAACCCCAAAJRFIhrGEZHRHs8nig2n6oQcI5AQVuPvHrTEBlW2NQ5jU7ilv56Wgf5z5V9JasJo9KT+DbTtToEBg4cKJ06darjCHYhgAACCCCAAAIIIIAAAgggED2BuAai8/PzZb/99ote66kJAYcI9O/ul1dvHi5d22U4pMWp0cyJ+zaXF64fKPm5cX0rTA1ceml7AdJy2P4W0UAEEEAAAQQQQAABBBBAIKkE4h594YNvUr1+6EwYAkML0+VZk5c4P8ckh6bYTqB/txx58fpB0jov7m+HtrOgQaklQLqs1Lrf9BYBBBBAAAEEEEAAAQQQSLRA3CMvBKITfcu5fjwFxgzIkKf+OkRyM73xvCzXilCgZ8csefGGfaV9i7i/JUbYUg5HIDoC7du3lwEDBkSnMmpBAAEEEEAAAQQQQAABBBBAIAyBuEddunbtKn369AmjaRyCgLMFhvVJl3//32DJbEJedCfcyYK2GWYiyX2lFSOjnXC7aGMjBXQ0tMtFfvRGMnI6AggggAACCCCAAAIIIIBABAJxD0Rr2xgVHcEd4lBHCmhO6P9eua9kpBOEdtIN1GD0M38bJHk5BOicdN9oa+QC/H84cjPOQAABBBBAAAEEEEAAAQQQaJxAQgLR5KVs3E3jbHsLdG3nlSdJx2Hvm1RH63p1ypInrh4gmekEo+tgYpeDBbKysmTcuHEO7gFNRwABBBBAAAEEEEAAAQQQcKJAQgLRQ4YMkZYtWzrRizYjUKdAfq5bHrtqEBMT1qlk/50De+TKfRcXijsh75D296GFzhaYNm2a+P1+Z3eC1iOAAAIIIIAAAggggAACCDhOICFhFreJ7jAq2nGvFRpcj0CaT+Rfl+8jmt6B4nyBKcNayDWnFTi/I/QAgSoCpOWoAsIqAggggAACCCCAAAIIIIBAXAQSEojWnvFBOC73l4vEUeCmP/aQYYVN43hFLhVrgd/M6ii/mcWvN2LtTP3xE/B4PDJ16tT4XZArIYAAAggggAACCCCAAAIIIPCzQMIC0RMmTJAmTZpwIxBICoGTD2wph01omxR9oROVBa46pbcMLUyvvJE1BBwqMGbMGMnLy3No62k2AggggAACCCCAAAIIIICAkwUSFojWIPSUKVOcbEfbEbAEhvVJlyt/1xuNJBXweV3y4J8HSstmCXu7TFJZupUIAdJiJUKdayKAAAIIIIAAAggggAACCKhAQiMrpOfgReh0gabZLjOp3QDRYCUleQXa5KfJXRf0Sd4O0rOUEZgxY0bK9JWOIoAAAggggAACCCCAAAII2EsgoYHo6dOni05cSEHAqQL/OKuntGtO2gan3r9I2j1uYL6cfnDrSE7hWARsJdCvXz/p2rWrrdpEYxBAAAEEEEAAAQQQQAABBFJHIKFR4JYtW8qIESNSR5ueJpXAUZPzZfYYApNJdVPr6cyfT+ghfbv66zmK3QjYU4BfIdnzvtAqBBBAAAEEEEAAAQQQQCBVBBIaiFZk8lWmykstufrZtrlb/noaeaGT667W3xu/zy13ntdPvJ76j+UIBOwmQCDabneE9iCAAAIIIIAAAggggAACqSWQ8EA0H4xT6wWXLL297ve9JDvDmyzdoR8RCPTpki1nHto2gjM4FIHEC7Ru3VqGDBmS+IbQAgQQQAABBBBAAAEEEEAAgZQVSHggumfPntK9e/eUvQF03HkCs8fkytQRLZ3XcFocNYE/Hd1NurXni4iogVJRzAX0S1+Xi0lVYw7NBRBAAAEEEEAAAQQQQAABBGoVSHggWls2e/bsWhvIDgTsJJCZ7pKrTy20U5NoSwIE0vxuue73pGZJAD2XbKAAabAaCMdpCCCAAAIIIIAAAggggAACUROwRSCa9BxRu59UFGOBPxzRXtrkp8X4KlTvBIGxA/Nl2sgcJzSVNqa4QEZGhuy///4prkD3EUAAAQQQQAABBBBAAAEEEi1gi0D0iBEjJD8/P9EWXB+BOgU6tfbI6Qd3qfMYdqaWwBW/7SV+X2r1md46T+CAAw6Q9PR05zWcFiOAAAIIIIAAAggggAACCCSVgC0C0R6PR2bOnJlUsHQm+QT+fGI30ZQMFAQCAgVtM+Q3s1oHVnlGwJYC/OrIlreFRiGAAAIIIIAAAggggAACKSdgm6ga+StT7rXnqA737uyTOWPbOKrNNDY+AmcdXiCaO5yCgB0F3G63TJs2zY5No00IIIAAAggggAACCCCAAAIpJmCbQPSkSZMkLY3cuyn2+nNMdy88rpu4iDU65n7Fs6Etmvrlt7P5kiKe5lwrfIFRo0ZJixYtwj+BIxFAAAEEEEAAAQQQQAABBBCIkYBtAtGZmZmiwWgKAnYT6NfVLzNHt7Jbs2iPjQTOOLSLZDXhmwob3RKa8rMAaTl4KSCAAAIIIIAAAggggAACCNhFwDaBaAXhA7NdXha0I1TgzMOYoDDUg+XqAs2yfXLsNL6sqC7DlkQLMP9Cou8A10cAAQQQQAABBBBAAAEEEAgI2CoQPX36dJP+gFGFgZvDc+IF2rdwy+wxTEaX+Dth/xacMqezeGz1jmp/M1oYW4FevXpJz549Y3sRakcAAQQQQAABBBBAAAEEEEAgTAFbhU3atm0rQ4cODbPpHIZA7AV+d1AH8Xr4ciT20s6/QoeW6XLQ2GbO7wg9SBoBJgFOmltJRxBAAAEEEEAAAQQQQACBpBCwVSBaRUnPkRSvq6ToRLpf5JhpHZKiL3QiPgK/md0pPhfiKgiEIcD/T8NA4hAEEEAAAQQQQAABBBBAAIG4CdguEM0Irrjdey5Uj8DsMXmSm+mt5yh2I/CLwLDCptKrk++XDSwhkCCBFi1ayPDhwxN0dS6LAAIIIIAAAggggAACCCCAQHUB2wWi+/TpI126MDlc9VvFlngLHDed0dDxNk+G6x03vV0ydIM+OFxAJyl0u233v3iHq9J8BBBAAAEEEEAAAQQQQACBxgjY8lPq7NmzG9MnzkWg0QJd23llRF/y/TYaMgUrOGxCO5NXPAU7TpdtJUBaDlvdDhqDAAIIIIAAAggggAACCCBgBGwZiOYDNK/NRAvMGdcq0U3g+g4VyMvxyf6DsxzaepqdDALp6ekyceLEZOgKfUAAAQQQQAABBBBAAAEEEEgiAVsGokePHi1NmzZNIma64jSBOePaOK3JtNdGAnPG8/qx0e1IuaZMmjRJMjMzU67fdBgBBBBAAAEEEEAAAQQQQMDeArYMRHu9XpkxY4a95Whd0gr07OiV3p0Z0Zq0NzgOHZs2opX4mbMwDtJcoiYBJv2tSYVtCCCAAAIIIIAAAggggAACiRawZSBaUUjPkeiXRupef/rIlqnbeXoeFYGcTK/s158vM6KCSSURCbhcLpk+fXpE53AwAggggAACCCCAAAIIIIAAAvEQsG0gesqUKeL3++NhwDUQqCQwcWiLSuusINAQgUlDmzfkNM5BoFECw4cPl9atWzeqDk5GAAEEEEAAAQQQQAABBBBAIBYCtg1E5+TkyPjx42PRZ+pEoFaB7AyXDC0kP3mtQOwIW2DiEL7QCBuLA6MmwK+JokZJRQgggAACCCCAAAIIIIAAAlEWsG0gWvtJnsso322qq1dg7MBs8Xpc9R7HAQjUJ9CtfaZ0au2p7zD2IxBVAQLRUeWkMgQQQAABBBBAAAEEEEAAgSgK2DoQzYSFUbzTVBWWwKj+eWEdx0EIhCMwsl9uOIdxDAJRESgoKJDCwsKo1EUlCCCAAAIIIIAAAggggAACCERbwNaB6A4dOsjgwYOj3WfqQ6BWgWF9mtW6jx0IRCowrC+vp0jNOL7hArNnz274yZyJAAIIIIAAAggggAACCCCAQIwFbB2I1r7zM+MYvwKoPijQJM0l+3TNCa6zgEBjBYZX+WKjaY+R4vZnNrZazkegRgHSWdXIwkYEEEAAAQQQQAABBBBAAAGbCBCItsmNoBmJFxjYI5380Im/DUnVgp4ds0QnwNSiAej+5z4n+926UgpPvlfy+k0Wl8eXVP2lM4kTyMvLk1GjRiWuAVwZAQQQQAABBBBAAAEEEEAAgXoEbB+IHjBggGiKDgoCsRbo0yU71peg/hQTcJkYdGGXNKvXLQbPEE9apnlkSOvRR8mAc5+V0Td9Lz2OuUFyuw0zxzBJZoq9PKLaXZ1TweNhcsyoolIZAggggAACCCCAAAIIIIBAVAW8Ua0tRpXpz41vueWWGNVOtQhUCPTpWn8g2p3dXDy5vauRFa+bL1JcVG17pQ1ut/jajjSbKgccS3/6Usq2bxBvyz7i8kc+WWL5nrVSsvGb4KWq1lNevFVK1i0K7g9nIRp11Hod4+DN6y7ujPbiSm9tRgrni5TtlfLSPeZpnZTt/lFKNi0RKSmpvYoa7kPp5s+lbNe2Ws8J7khLF1+LIcFVXSj+8T3ThrJK22pacee0Ek9Oj0q7SjZ8IuV7d1XaFrqiX3DMX7xHWo84PHSztezLzpf2k06xHns2rpS17z0i6z74j+z8cWm1Y9mAQF0CpLGqS4d9CCCAAAIIIIAAAggggAACdhAgEG2Hu0AbbCFQGMaIaE9Od8nodXm19hY3f112Lfi/attDN6T3OEHS2h8Vusla3vXln61AdJMeF4k7vU21/fVtKNm+2ASiTw8eVrWesqLNsn3dr4L7w1mIRh1Vr+POyhd/+4PE33qWuLx1B/3LTWC6eMOrUrTqMSnd8kPVqsTXcqykd/mlz3pA0dqnZfcXN1Y7tuqGtI6zJb3Tbytt3lV2vglGmy8T6ilNel0g3pz+lY7aWXSGlKz/otK20BX9gsOXVSZ5fSeGbq62nN68g3Q+8HzrsXPVElnz7sOy/sMnZM/GFdWOZQMCoQJ+v18mT54cuollBBBAAAEEEEAAAQQQQAABBGwnYPvUHCo2ZswYyclhEjnbvXqSrEE9OtQ/iVzx6g+kaN1z1Xrua76/+DuMr7Y9sEFHGNcUhC5aP1eKV70TOCxJn12S1mW6ZA37j2VQXxBaEVzuNPG3miFZgx+U9F4nick5UMmm6MeXpby8vNI2X8tpIj5/pW3VVtwe8betPjLZ3+HYaodW3eDOal4tCF1WtElKNpjR23WUHh2ypOXQX5nge/j5oDPbF0q3w6+Skdd/JQMveFXajjvRBLPNyHEKAjUITJgwQbKz6/5yp4bT2IQAAggggAACCCCAAAIIIIBAXAUcEYjW0V7TppkgEwWBGAnohHJNs8ILFO5ecqNJAbG8WkvSu58v7qzqqTVc6RnSpPdV1Y4v273y/9k7D/goqi2Mf9sSQkILEFoIhCa9S5MuoKBYEFSs76nPZ0GxYe/l2fXZ+xO7KGBHVJogvUhv0kkChJIQCEl2s5t3z+Au25Jskt1kd/Y7v98wM3du/d/ZJfvNmXORt/FFn3RdJSjhN777k6jW8i4YDJ5icqDjFAG/Ru/3ABVSw2lFecdhPzLfeartDcYYJTIP8kjzPrE0PB1GSy3vZJhrtIepdhOfdPeEmOTz3E+1Y2vGFKCo5JAeKQ3i0LCfr/jtU1kxCXXaDUDba95A/9d2o/NtU5HUe6y28GEx2ZkchQQYliMKJ51DJgESIAESIAESIAESIAESIIEIJBARoTmEq/zQ/vLLLyMQMbscCQSaNQpMhNbGYrcjd+1dSOj1uea56xyfCKHVOz2H40tV2AeH/WSyWq2ueqfHlfjp6dFf5LBpdZQUB1kqyPvLV8B2tufcS0zlcLW49hNUPGiJi+1rwsCevRyO/HR10Q5jbCMlBp8Og6m6T2Zj9VTEd34auSvvdMVyLtj7Bcx1PYXn2CaXwbr7N5/yzoTYlOI9n2OaXoq87GIeDCiP7JiGY5zVaHvxyLamz/BI83cSm5iCWq37+rtUpjSDyYx63c/VNruKSX1w+TfYv/hLZG2cp+Jr28pUFzPri4AsVEgjARIgARIgARIgARIgARIgARIggXAnEDFC9MiRI2E2m5VuV/wCZuEOm/0LXwIpDU552wbSS8fxI8jb/Ciqt3/aI7spviXiTrsWeZve1dJjW4yBuVYPjzxykv/X0youdKZPunuCxHYuSVR1zxuOxzFNByvx9gKfrsmihPk7XoI143ffBR6V4GtpcLpi+IgSpD3nxFyrK+La/kt5kb+j1Vl4eKsSsferuNoNXW0YqzeHqU4zFVfaN66yqXYyTAm+C006C1uSRiIv9k2gIM+Z5NpLnwxmz9At4pFdlJfrylPcwSLrUBVrxFDc5XKlm2Kro2H/y7XNduwwDiz5CvsXfYGc7ctVfUXlqpOFIpNAz549kZycHJmdZ69JgARIgARIgARIgARIgARIgASiikBEhOaQGalduzYGDfL0foyqmeJgQ0qgYWJsmeu3ZSyBdd83PuVimoyHOamjJojGNr/Z57r14C+w7p3rk66rBCUoV2upvJe9zJG3G8eXXXpSYLdZva6qU+VtLlxz//yX8vI94XPd0ugSGOP/9i7XPJI/98kTkzzOJ00SxOO5JJPQIbHJI/1miUke75NekBbYGxrz8wb7lA1mgqVGXSQPvxE9H5mvYkpvRYuLHkV847bBbIJ1hTGB888/P4x7x66RAAmQAAmQAAmQAAmQAAmQAAmQwCkCESNES5cZB/PUxPEouAQSa5YhNIdb03mb34A9d5tbysnD6p1eQXy395UjrKcnrCMvDXkbign/4FNL5CZYGvVVHsQJHgMoshcgd/UdcOQe9Uj3d2LPTsPxVUqMLvT0OBaeMU0vchUpyPhNLVr4dxiUv1Mt9c9SqrPXg4XYOFiSznaVK+4gRoX2gNHza9FYQxYp7OxRRDyxCw9t8Ujzd7Lbloo9han+LoUkrVq9pmh+/r3o/cxq9P7PSqSMvB3V6qaEpC1WGh4E+P9ieMwDe0ECJEACJEACJEACJEACJEACJFA6AU/FpfT8VZpj9OjRVdo+G9cvgcRaMeUbnPLgPbF2kvLezfcobzAYVfxoz8g3WlzodXcBhfqP5yte4d5WsOddJUIf8U4u9txxNAN5Wx7xuR7TSHk8K76aFeTDdtAzJrRwj2k81KOceDp7L5ZYkPYZCo+u9shnjKmrBOtuHmkxTXzDi1gzvlARMEoPgbEgxN7QHh31OolP7oBW459WXtJb0O2+39B48DWwJNT1ysXTSCbQrFkzdO7s+ZAkksfDvpMACZAACZAACZAACZAACZAACeibQEQJ0ampqfzRre/7scpGV16PaOmwIzdbxYt+qNS+5297Fo6cA6Xmc2YwxiTC0rh3qRtiPWMpO8tX2V55LZsSTvNoXlvYL+MXj7RATmwH/oTD5ulBbTDFwRh3ytvamvaVT1WxmhD+tze68nDWPJ29cln3TlMhUj7xSlXO1ClXnkqTRQobXXjqXB2JB3ZBuqf47ZHh75OiIgMW5A/xd6ly09R81Gk3AG2veRP9X9uNzrdNRVKvi2CM8Yx5XbmdYmvBIMCwHMGgyDpIgARIgARIgARIgARIgARIgAQqi4Cny2ZltVqBduSH99q1aytQA4uSgC+BuFiTb2IZUmz7VsBa5yvliXux31LWg7/Cume232slJVZv/0xJl7VrJzbeo+IqLys1X2VlMFSr7uN9XJS/N6CF/Xz66HCgMHs5YuoP87hkjKsHx4kcLc1+ZBck9rQxrpkrjzGuKcx1U1F4eIfm4Syezu5WeGSReoCQpeo4CkebQ0qUree6bK7ZBcaaDbSHBpaGvdSiidVd1+TAdmiW3wUNPTKpky229jhoT/JOrtJzg8mMet3P1TZ7QS4OLv8G+xdPQdaGuShyFFZp39h42QkwLEfZmbEECZAACZAACZAACZAACZAACZBA1RGIKI9owcQf3lV3s+i55VhLxT8KeZvfgf24b9xgR366igv9gp7xeYzNGFvH41w7KXL4pgWaYs30yWmo1sAtrQgFab6LFlqSTz4U8PBw/rtUwd5PTx6pfln9lI1teol2PSZZxYz2MpsfD2yvLNrp7yc8w4P4y1OVaabYeDTsfwW6TvpB85Ruc8VLqNmyl+qSZ1zzquwj2y6eQK1atTBw4MDiM/AKCZAACZAACZAACZAACZAACZAACYQZgYqrb5U8oB49eqBx48aV3Cqb0zsBizkIHwXlvVuw+wMfVAV7PoyKuNDOgRfZrc5D195h91x00HUhkAM3b2VXdq+Y3NaMecqj17NdS71hMCd1UAsNdnEVkwN5MFB4cLMrrSB9pu+Chw3OhbleG5hrdHTl08rm7VFe1js90vydFBaZsSh/gL9LYZlmqVEXySNuQs9H5msxpVtc9AjiG7cNy76yUycJjBo1ChZL+RZZJUMSIAESIAESIAESIAESIAESIAESqAoCEReaw6DinYpX9Ntvv10VvNimTgnEBMEjWkPjz/O3qPwhD/K3v1gqcXv2plLzVGYGR362T3OmuBTlaKs8bQNY4M+7sDmhnXcS7Hn7PdNsVtgyZyCm4amFBWVxwvjOr3vmU2cFWlxot4UGC/JU2Z8Ro8RnpxmMFsR3fcd56toXpKtFCuFW1nXF82B1QXccK6rpmRghZ9XqpaD5+fdp2/G967H/j8+QuWwa8g/viZARREc3GR86OuaZoyQBEiABEiABEiABEiABEiABPRGIOCFa4MsPcArReroNq34shfbSxcXK7qXDegQFO3+s7GYr3p4ShYvsJzxiKxvMNVTM5jYoPOQbuqSkBg2xsjBhU58sjvwsnzRr2jQPIdong0ooshfAmjHH55J175ceQrRPBinrsPkt6y/vgrwwWKTQX8fKmJbQtCNajX8arS79D7I3L1DxpL/EwRXfwnb8SBlrYvZgEhBP6LPPPjuYVbIuEiABEiABEiABEiABEiABEiABEgg5gSDEIwh5H30aGDJkCOLj433SmUAC5SVgK6xADOPyNqrjcrYjC3xGF5t6PWAs21dOXLu7fOrR4nAX5PumZ6fBnvuXT7p7gm3/dLXaoM09STu2Z6twHcc2+qS7J9gO/gxYPcN/uF93Huc7qmFZQV/nqT72ypu9druBaHvNm+j/6m50mvg1knpdpBZ59FzIUR+DDf9RDB48GBIjmkYCJEACJEACJEACJEACJEACJEACkUSgbKpQmIwsNjaW3mBhMhd66UaBlUJ0MOfSusd38UBzre4q3MUTSow2BdSUpXFvWOoN9clbsGeyT5ozwZr2mfPQ775g71S/6ZJo3ftxsddOXi++rHvBo47aaGn+C4ZyhCFxrydcjw1mC+r3GI2OEz7DgDf2ov0Nk5HYaTgMxoh8wSZcMZfYLy7aWyIeXiQBEiABEiABEiABEiABEiABEghTAhEpRAtLxscM0zsqQrtVYKMQHcyps2ftgf24b+xqc2I/xHd7CjCVIEYrr+nYVhcjrp3K52USrsS2f5lX6qlT676FKvyGr7e05CjMXgZHCSElbPuXw2HzjW8tZe2522HP3iuHpVoD8348WW8S3m9wGa6u8T5SzdtLLROpGUyx8WjY71J0nfQD+r+2C22ueAk1W/ZSw1HxwGkhI0AhOmRoWTEJkAAJkAAJkAAJkAAJkAAJkEAICUSsED1q1CilZZUgZoUQGqvWH4GsY77hGvQ3ysod0Yl1D2ixor1bNdfpjRp9JiM29VwY4+sAZuVJq2LemmonIyZ5oLr2Aao1v1Gtbej5+S5SC0GeWK9CdThKeGhQWAjbgW+9m9TOC/Z84jfdlajqtaZ/6Tp1PyjN09o9r/O4jikL5ydMxYv1b0bDHwZg13dP48S+kkOHOMtG4t5Sox6SR9yEno/MR7+XtqDFRY+geqPTInEoYd3nrl27IiUlJaz7yM6RAAmQAAmQAAmQAAmQAAmQAAmQgD8CEfsudd26ddG/f3/8/vvv/sbFNBIoE4EjR0uP/VumCoOQ2RiTiBr9vyi9Jkc+ji2+Rq2m53/BxYDrUS3l73wdtvSFPm2Wpw5HbpYmHMd3edO3vrhkVGt5p7b5XCwmIX/bs7Af2VnM1VPJBXu/QUzjS08lqCNH/j4UHtzgkebvxJr+I2KbXa9E8FPP6LQFDvf94S97wGk5GVuwY+Fy7Jj2mOYx3LDfeCSdfgFiajcKuI5IylitXgqan3+fth3fsw6Fh1chM7cISfH0lK7oPNIbuqIEWZ4ESIAESIAESIAESIAESIAESKCqCESsEC3A5Ac5heiqunX01e7hnPATooWwsVrDwECrxeSKE6LLUo8xtn6x7QXaF/c6Cg9uQu6amxDX/ikYLcr7uRxW5ChA/l/PqhjOcwMq7TiWicKcdTDX7OTKX5CmvKGLEepdmdRBUV4ubIdmIab+CFey7cD3Kq5HxTzms3JOlc/Zvgyybf30TiR2PBMN+16Ket3Phbm6PhefS0jphEK1XTbdii4NjBiaasSAFCNqxlKUdt1kZThgWKoywGJWEiABEiABEiABEiABEiABEiCBsCJwyu0vrLoVWGfoGRYYJ+YqncCh7PAUokvvefjnEDH62JLLlMA7p8ydLTy2AceXjg9YhHY24B5KQ4Rsa/ps56VS994LLRakTS+1TGkZDmafEqJdeVWokSPrfsPGd6/FHxNSsP71y3Fo1Y8qTnWBK4ueDsRff/UBB15aUohxX1vx0Fwbft/tQH6hnkYZ2rEkJyejW7duoW2EtZMACZAACZAACZAACZAACZAACZBAiAhEtEd0q1at0L59e2zcuDFEeFhttBDYeyAvKEMtcvjWU9zied4NFtlPeCcFdK7V7+btW956pLEi+8n+B6MOj84X5OPE6idgrP5fWBqNQEzD82GolqxCYPh6xTqsh2DLnAFrxgw4cg54VBPoie3AChS1OQ6DOUEtbqg8mm2BP2iwZ+1WixNugym+FQqPbVR92B9os8Xm25tpL/aaXHAUFiBz2TRtM8fVQlLvsWigPKVrn3YGDGrxRr1ZoVKlF6U5tK2a+l9ooPKQPjPVhG4NjTDpb7hBmz55+OrvMxO0BlgRCZAACZAACZAACZAACZAACZAACYSQgKFIWQjrD3nV9913H5555pmQtxNuDchiVbt3765wt95++23ceOONFa4n0itIqmPE1q8GRvowIqv/Kg6zoVocjLG1Vb+NKLJmq1jOSox3lCzaBjpIo1o8z2BJUKKyEpKVEF4WM8bXhCE2EUX5R+A4kVOWoj55M7OsaHPxIp/0QBJiajVEwzMuU+E7LkFCsy6BFInoPLVigaHNTUqUNqJdfU9FOjc3FwkJCRE9vop2fubMmTjrrLMqWg3LkwAJkAAJkAAJkAAJkAAJkAAJkECVEIh4IXrJkiXo27dvlcCrykYpRAef/v6fBqJajKf4FfxWWGO0EVix+SiG3fJnhYddvWFrJUpfrnlLV2/YqsL1hXsFDdXChsNbSExpE1JqGRDtQrSI8IcOHUJsrFLraSRAAiRAAiRAAiRAAiRAAiRAAiQQgQQiXnXr1asXGjRoEIHo2eVwI7AjPTfcusT+6IDAzozg3Fcn9v+FHdMexZK7O2Ll44OQ9ttbsGbv0wEh/0PYn1uET9bZ8c/vrfjXD1Z8+5cRsYnJ/jNHQerIkSMpQkfBPHOIJEACJEACJEACJEACJEACJKBnAhEdI1omxqjip44ePRrvv/++nueJY6sEAht3HUf71BqV0BKbiCYC67cfC/pwj25bCtm2fnonEjsO00J31Ot+LszVawW9rXCocEd2EXZkG3HGy38he/MC7F/0BTJXfIvC3Kxw6F6l9IGL81YKZjZCAiRAAiRAAiRAAiRAAiSgCDz55JPIyMjQWIwYMQIXXHABuZBAUAhEvBAtFOQHOoXooNwPUV3J+u05GDukUVQz4OCDT2DDzuAL0a5eFjlwZN2v2mY0x6Jej9FKlL4UiZ2Gw2jRYQgHtbhl7XYDte20q1/FoTU/48DiKTi0+mc4rOVb7NPFMowPTCYTRo0aFcY9ZNdIgARIgARIgAT0TuDEiROoXr263ofJ8ZEACfxNYPLkydi+fbt2ZjabKUTzzggagYgPzSEkhg0bhri4uKBBYUXRSWBjKAXD6ETKUSsCG3dWjkDqKCxA5tKpWPvfsfhjQgo2/+9mZG1agCKHQ5fzYDBbUL/Heeg44TMMeH0P2v3rPc073GDUxfNVjzkbMGAAEhMTPdJ4QgIkQAIkQAIkQAKVRWDChAmoU6cO2rZti3Xr1lVWs2yHBEiABEhAhwR0IUSLCC2vCtBIoCIEVm2tHMGwIn1k2cgisP9IATIOVb4QXJh3FBnzPsCfTw/HwoktsO3L+3F895rIgleG3pqqJaDRgCvR9e4f0f/VnWhzxYuo2eL0MtQQ3lnPP//88O4ge0cCJEACJEACJKBbAps3b8Ybb7wBq9WKLVu24JVXXtHtWDkwEiABEiCB0BPQhRAtmPhDPfQ3i95bOJTtwPZ0itF6n+fKHN+yjdmV2ZzftqxH92PPjJew7KHeaqHDTtj13TM4sX+b37x6SLTUrI/kETej56ML0O/FzWgx5mFUb3RaRA9N1kGgkQAJkAAJkAAJkEBVEKhduzYsFour6fr167uOeUACJEACJEACZSWgGyH6nHPO0RYuLCsA5icBdwJLN0TP4mfu4+ZxaAgsWR9e99OJ/X9hx7RHlSDdESsfH4S0396CNXt/aAYfBrVWq98czS+4H32eXYNeTy5DysjbEJuYHAY9C7wLHTt2RMuWLQMvwJwkQAIkQAIkQAIkECCB7OxsTJw4scTcDRs2xLvvvosuXbrgH//4B2677bYS8/NiyQQCYV5yDbxKAiRAApFNQDdCdFJSEvr06RPZs8HeVzmBJeuOVHkf2AH9EAg3Idqd7NFtS7H1k9vxx8SWWP38edj/x2ew5+W4Z9HVcUJKZ7Qa/wzOePkvdLv3FzQe9E+Y4+uE/RhlMV4aCZAACZAACZAACQSbQFZWFoYPH47vvvuu1KpFgF69ejU+/PBDNGjQoNT8zOCfQFmY+6+BqSRAAiQQ+QR0I0TLVDA8R+TfkFU9gjkrw8uDtap5sP3yE8g6ZsPqvwrKX0FllSyy48i6X7Hx3WuxQC1yuP6NK3Doz5/gsEVA38vDyGBAnfaD0PbatzDgtT3oNPErJPW6CMaY8FwFnv+vlWeSWYYESIAESIAESKAkAocPH8aZZ56JFStWlJSN14JIgMyDCJNVkQAJRDQBc0T33qvz4jl2zz33eKXylAQCJ5B20IHNu4+jbbOEwAsxJwn4ITBn5SE4Kn+dQj89CTzJYctH5tKp2mauXlsTaBv2uxS12pwBg1FXzy01KAazBfV7nKdt9vzjyFz+DQ4snoKsjfNQ5CgMHFyIcsqrsKefrp9FF0OEidWSAAmQAAmQQJUQ+OabbzB79mysWbMGGzZsgEE97E5OTtb+777iiiswaNAgLc1f5+x2O5YtW4b169dj3bp1EJGyUaNG6NSpEzp37oxu3br5KwYJ63D99de7rt1xxx1o164dXnvtNfzxxx9anU2bNsXZZ5+NMWPGoHfv3q68zoODBw9i2LBhWLt2rZaUkZGBcePGOS9re3nT+M4773SlyXhksUIxaV/KiwWjP951PPTQQxoHrQG3f1auXIlnn31WSxHW//vf/xAfH++W4+RhUVERJk+ejPnz5+PPP//Ejh07tDBn3bt3x8iRIzF27FifMoEmHDp0SGMtcy7zJuepqalo3749Jk2aVOy8lYd5oH368ccftcUkZSFJaUfuwdatW0O0kfHjx/swKs8Y0tPTcfvtt7u69Mwzz6Bu3boaC/kMrFq1Srtv5b6Qe8U9rJx8Tn744Qf89ttv2v0i97bcmxJmpIjpAABAAElEQVQSRuaxOAvlPDrbLAu7rVu34sEHH3QWde0lfrrcAzLmVq1aaZ//atWqua4XdxCM8QWjDvne+PLLL7XvA+d3gsyRfF727NlTXPeZTgIVImBQN29RhWoIs8Jt2rTBX3/9FWa9Cn53UlJSsHv37gpX/Pbbb+PGG2+scD16quDJ65thwrhUPQ2JY6kCAjc9vw6f/3q4CloOfpMxtRuhYb/xarsUEuJC72bLOYgDS77C/kVfIGdH1XkK/etf/9JiMuqdN8dHAiRAAiRAApFEQIS8G264AdOmTSux2y+88IKHmOvMLCEu5P/4kryRR40aBfmdJqKyu8nvv+bNm7uSRPwUoW/bNt+FqM1mM6ZPnw73RY8PHDigeUKLcF6SyfpLItI5zWQyKQeLkx4Wr776Km655RbtUkX7I5V41yHtSvveJrzdRWQZi4TndLd9+/bhqquuwqxZs9yTPY6vvvpqvPnmm6hevWxvw4ngeuWVV0La8Gciqt5///148sknPS6Xl7lHJcWcyH30/vvvF3MVqFWrFkTAdwrD5R2D3LPuD0fkwcd///tfbN++3adtcaQQcVP0iptvvhnvvfeeTx5JkIcC3377LWJiYnyuh3IenY2Vld3cuXMxdOhQZ/Fi982aNcN//vMf7SFAcUJ7MMZX0Try8vK0+1U+z87PdrGDUhfkMy95aSQQDAK6c3Hja8zBuC2iu46ZSzKjGwBHX2ECdvV3+m/L9BPmxZq9D3tmvIRlD/ZSCx12xq7vn0XeAd8/PCsMLkwqsNSsj+QRN6Pno3+g34ub0WLMw4hv3K7Se8f/zyodORskARIgARIggRIJSIzfrl27lipCSyXi9extTz/9tOYxWZIILWVmzJiBDh06YOrUqd5VeJw///zzfkVoyVRYWIiLL74YixYt0spI34cMGaJ5b3tUEsSTsvQniM1qVR05ckTz4ixJhJaMH330keaRW9b2R4wYUawILXWJf99TTz2lef866w4lcxHmSxKhpQ9Hjx7FsWPHnN1BecbgKux2IKKkPxFasuzfv18TbAcPHlysCC35fv75Z78OF6GeR2m7POykXCAmD1Yuv/xyDBw4EPn5+T5FgjG+itYhwrN4r8vDhEBEaJ9BMIEEKkiAQnQFAbK4/ggsXJeHA1k6jY+rv+kKyxEtXHsYB7MjLC5HgCRP7N+KHVMfweJJHbDy8UFIm/U2rNn7Aywdedmq1W+O5hfcj97P/InTH1+MlJG3IbZOk5APRLx0JHYjjQRIgARIgARIIHwIiMerhClwmngKX3PNNZrgJgv5SagMCbHhz3766SfNA1EEYqd17NhR866+9957NdE4MTHReUkTEP/5z39qoSVciX4OxEP6008/1QTAtLQ03Hrrra5cIoSJOOy06667Di+++CLOOOMMZxISEhK0NEl3buLxXV4rS3/K24a/chLSQ0RQp4n3qngAS2gOEafdx/zLL7/g119/dWYNaO8U7ORvNPEyf/nll/HEE09oISncKxBPdncLFXNvwf2xxx7TQr3MnDlT88SXefW28o7Bux45l/BxEm4jJycHmzZt0h5yOPNJSAfnAxB5+/r333+HhLYQXka3cH8i3NtsNmcxbR/qeZRGysPOo5PqRLzzJXyNeFZfcsklWngO9zziFe4vbGwwxlfROsSj3Tk/0md5e+K+++7TPNl37dqlCfXysCEuLs59SDwmgaAR0F1oDnnyLCv5SpwtPRtDc4R2dp+bkIrrz28W2kZYu24J3P7fDfjwp4O6HZ/PwAwmJHY8UwvdUb/7uTDF1fTJoqsE5fGStWm+Frrj4MrvUJgbfO/3Cy+8UHudVlfcOBgSIAESIAESiGACEuKgV69eLg/CevXqaWEx+vfv7zEqEX8lHIHEi5XwA2KZmZla3GPZi0k4AvGOvu222zyEOYnxO2HCBHz11VdaPvlnwIABmDdvnpbPO4yFtDFnzhyfEB7Sz+XLl2t1SHgGicPsbnfffbdLoJZQAiI+lWSBhuYoT3+8x1Se0BwSaqRLly4uL3SJj/zdd995DEl0AomZLfMo1qNHjxLDo3gUVicSZkHCgEq9bdu2dV2WeiUchYRsESvud3pZmbsaKOZAhFD38DAS69v9IYj0R0IpiBDsTC/vGLxDc0iMZ3n44S5USnuNGzf2EJbF+1xCpbibPCgRIdRpElZV7huxyphHaac87LxDcyxcuBD9+vWT6lz28ccfaw+mnG9DCG8RvZ0hPYIxvorWIQ9rhHdubq7Wb5lD+Q6RuPDeJvmcnu8MzeFNh+cVIaA7j2j5T/Lcc8+tCBOWJQF8M89/7C+iIYHSCBTai/D9H/p+EObDoMiOI+t+xcZ3rsGCCSlY/8aVOPTnTygqPLmojU/+SE9Qf1TWaT8I7a57GwNe241OE79C0uljYLQEz2tAfkDRSIAESIAESIAEwoeAeDQ7PUqlV+I97C1CS7osVCaijVOElrQpU6ZoYrQci4lHo3hPu3uHSnr9+vW1hcOcwpWkLViwQPNUlGNve/jhh31EaMlz0UUXubJKeIaCgsp527Oq+iOez+7i31tvveUav/NAdALh7jRZyLAsXMQ7XRaYdBehpS6pV4RZp504ccJ5GNK9eNO721lnnaUtzuhMkwcljz/+uEuElvRgjUE8gd1FaKlb2nMXZkXE9BahnX2QvdPcH4JUxjxKu+Vh5+xvSXsZryz85zQJ1+L+UCkY46toHeIJ7RShpZ/ygMSfCO0cA/ckEAoC5lBUWtV1SlxNefpGI4HyEli8Ph/b00+gZZOyLWJR3vZYTj8Efl12EIeP6jMsRyCz5LDlI3Pp19pmrl4bDXqPRbtzbkRRUgfoamXcv2EYzDGo3+M8bbPnH0fm8m+Up/SXyNo4TwUL9I0NGQhD+VHqb5GeQMoyDwmQAAmQQOQTkKXkNx9ywGQ0wKzchmQzGdTmc3zyuvNa5I88vEcg4Qec1qJFC78im/O6937p0qWupOTkZL+v7DsziBeleFQ7F5iTdPFIlZiz3iZ5/Zl4prqbxCoWr91QW1X1Z/Pmza6hifgn3ub+TBYOdJo8VJCwHe3atXMmlbj/3//+5/e6eJ67h2vxfrjgt1AQEsXT+aWXXnLFgF63bp3m8T1x4kTIA4EaNWr4tBLqMTg9r30adktorkLJuNvevXtdp5Uxj9JYedi5OlnKgXhbp6amYufOnVrO9evXu0oEY3wVrcO9P9IxeSBGI4HKJqBLIVqC8MfGxpbpCWdlg2d74U/gk5/34tHrTgv/jrKHYUXgo59O/TEVVh2rgs4UnshG+tz30SUuAx99/SNm7XBgzi47tmfpUZJWAkG1BDQacKW22XIysX/xVziw+Evk7FhRJvriTSIeUTQSIAESIIHoJCDa4idr7ViaUbYH22a/YrUI2QYfIVsTtzVh++Q157mI2k7x26g64jyWvarGdX4ynyr7t0juzOeRR4R09z5Je65zz3alvFNQd/ZXS/u73XC4E9yF6M6dO5epS+5CtMTWtVgsJZYXoVvEZAm3ILZmzZoS83tfrFOnjkdSWTx/PQoG6STU/dmyZYtHT19//XWP8+JOtm3bFrAQ7V6HhJOYPHmy5unuDF3gvG61Vs4bgRKOVOJcy1t0EtJFTOItv/DCC9oil+KY5+/hhbOfoRiD9zw723Lf16zpGcLPnVdlzWNF2bmPx9+xcPcnRAdjfBWtY+PGja4uN2nSBN7z4brIAxIIIQFdCtHx8fHaKqDy+hSNBMpL4PNfD+DBf7aBWf4qppFAAATSD+Xjt+WnVqYOoEjUZKlX3YBLO5q0be/RIvy6w455uxzIOK5PUdpSMwlNz5qgbXmZO7F/4eeal3huximPneImn2E5iiPDdBIgARKIHgLyf2ZZhehC9V9qoXoZp8DnhZyS/q8t6VrV8x7ZyoS7+obHT1b3OMveYQlKIyULujmtbt26zsMS9xLqwClEu4cvKLHQ3xeL80wOpGwo8oS6P3l5ea5uy2KC48aNc52XdBCIB697efF8lkUBxbPYGQpEtAfxPnZfKNG9TCiPJaTC4sWLcfXVV0NiFjtN7pchQ4Zo/ZRr7hbKMUiYkopYZc2j9LE87AIdW9OmTV1Zjx8/DlmgVBYEDMb4KlqH9MNp7oujOtOK24f6M1xcu0zXJ4FTd6HOxic/5ClE62xSK3k4mVkO/LDwAC4cGPrX2Cp5aGwuRAQ+Vt7Q6i0/WikEmtYy4NpuZrWpRUkyHZitBOn5u+3Iyi+lYIRejktKReqFD2jbsV1/aqE7MpdORUFWut8RUYj2i4WJJEACJBBVBDo3MKJzkgFrM8NbKA7lpLRONODWXuHzc1UWqpOF9cTcX48PhEH79u1dMaLdPauLKysi59atW12XZQE8vZp3KIvyxFh2D0Ui4pp4KwfbZJFDid3tfKggIVYmTZqkxV3+8MMPISExqsIkhIvEEZc+3HPPPa5FEyX0yPXXX4/TTjvNFQM4XMfg5FYZ8+hsS/ZlYederrRj8TZ3mrThFH+DMb6K1uEe49z5febsa0l7CXlDI4FgEVAvO+nTZMFCPrXR59xW5qhe/3pnZTbHtiKYQL7Vgfd/4CKXZZ3CDklG7UfmlIti8fRQC4alGlE9fH5zlnU4peav0bwbWl/2LM747zZ0u3cmGg38BySWttPkx4JsNBIgARIgARK4rJOO/0MsZXprxACPDrIgpmIOlqW0UrbLHTp0cBVYu3YtJDZwoNa1a1dXVlnwTsqXZJ988gny8089ofe3KGJJ5Uu75i7+VnXYjlq1anl01xlmwiOxlJPWrVu7cqSlpWHevHmu82AciKgrnsVOEbpXr17YsGEDbr31Vr+xmP21GUrmontcc801kLAN48ePdzUvYS9eeeUV7TwYY3BVHKKDUM+jv24Hws5fueLSjhw5glmzZrkuuy+MGIzxVbQOdyFa7mdZvJBGApVNQLdCtDwpkvhbNBKoCIGVmwuweH1WRapg2Sgh8MVv6VG9SGFFp1liTPZqYsR9/S2YdnEsHuhvRt9kIyx6/V9K/WCo034w2l33Nga8vgedbp2CpNPHYPQFYyuKkuVJgARIgAR0QuD0xka0qhN9IeJkxPervwcaJoTX2Lt37+66s8Rj+Z///CcOHz7sSivpwD1Wr8TxFVFTBCt/Jh7Tt99+u8elQYMGeZxX9ETWU3KahJTwjnPsvFYZewlr4S7SilDvbeKNOWPGDO9k1/mll17qOpaDf/zjH3BfmNDjojqRmN3nn38+jh496n3J77kIvCI8O00E6LLG1g0284ceekjzhHb2SfbiDf7ZZ59BvLWd9scff2iHwRiDs85Q7UM9j85+l5Wds1wg+7vvvtvje0FCgDgtGOOraB3SH/d7URYrdH/o5ewr9yQQSgJ6/YmvMZP/XGgkUFECr0zZUdEqWF7nBOwqHMcbU0++qqnzoVbK8MT7aWiqCU8OsWDquFjc3tuMDnUdKNJp3BODOQb1e56Pjrd8jg0d78dzi2xYoRaokvuKRgIkQAIkEN0ELo9Cr+iru5i0h9PhNvPiadqtm4or9reJMCnehW+//bYWqkME5n379mnhIa+44gpcdNFFzqy48MILIW/sOm316tXaInkSa1hEYBGC1q9fjyeffBIieLvHo5aQD61atXIWDcree1Hk5557TlvwTrxmV6xYoXnVvvXWW0Fpq7RKxCO1S5curmxff/01lixZ4jqXGLsiLAur4kzKn3322a7LEnKgXbt2kEULRdgXwXnVqlWaSCtzIWLc999/j0C9wZ2xup0NeJ+7h2Jw5nFfhE/Sgs1chHl5wCHjkTjREodYTDz1MzMztWP5xynye/fZ+zyQMbgqDdFBqOfR2e2ysnOWc9/LQpHuD3DkgY7MxQcffODKJp/bW265xXUejPFVtA55SCEhXJwmD2V69OiheXHL944z9rnzOvckEAoCun7fS+JsPvDAA6HgxjqjiMDMJcewZlsOurTyXOE3ihBwqKUQmD4vA9vSTv7xV0pWXi4jgQT1au65bUwY0sSBuk3boEHf8WjY71IkpHQqY02Rkb2gyIRftju0rU41YEhzE85U4Ura1tP1c+PImBz2kgRIgASqgED/FCOa1jRgb050xOfsrbzArwhT8V3ivL7//vuQsAxOsebQoUO48cYb/d4ZPXv29EiXsp06ddIEX7kgYuG1117rkcf7RIRvEYmDbbKQnbu9++67mtBrsVhcC6q5hyJxzxuK40suuQR//vmnVrXEiB4wYIAmjolILcK4U2Qtqe2vvvpKE2ZF5BfLysryEAFLKlvaNfdwBpL3P//5jzaPInZ/8803+OGHH1xViJh3ww03aGkiVjo5hor5t99+C9lk0UTxiN67d6+rL3LgfABSkTF4VBjik1DOo3fXA2XnXU7OZdFK2WTBS/nc7NmzxyfbO++8g2rV1B/0bhaM8VW0jvvuuw+ff/45tm3bpvVs48aNGD58uKuXsuikfPYC+dy5CvGABMpAQNe/bCUeT2pqahlwMCsJ+Cfw1IenFgvxn4Op0UrAbi/CMx/Ta74y5r8gKwN7ZryIZQ+ejiX3dMGu759F3gH9spfFG6dvtuPmn2244hsrJq8uxJ6j0SFEVMb9xDZIgARIIBIIGFV0iss6qleFosAaqVAc96nQXEr/CFsTb2URHps0aVLmPjZo0ADz58/HGWecEVDZyy+/HDNnzkRMjHoqH2QTcfSqq67yqFVEp7y8PI+0yjqRcAbu/ZG+iKemeEbLsQhj7qFR/PVLQnyIp2uzZs38XfZJkwcK1atX90n3lyDzPWbMGNclEZuff/55LS6zuwjtzCACpHgci4e504LN3FvgzM3N9RGhRQt55JFHtC4EYwzOsYRyH8p5dPa7rOyc5fzt5S0IbxG6Xr16EM9+WdzS24IxvorWIeOXz9a4ceO8u6edy4M2itB+0TAxSAR0LUQLI4bnCNKdEuXV/LrsOJZvyo5yChy+PwJfzkrH9nR6Q/tjE8q0E/u2YMfUR7B4UnusfHww0ma9DevRA6Fsskrr3ne8CJ+sU/Eov7fixp+s+HqjHYdOUJSu0klh4yRAAiRQSQQkXFVS9TBWZ4PAIUb9KpXFCWvEhv84R48eDfEglFfuW7Zs6Qp94MQgoRB69+6txYF2pjn34pW6YMECvPHGG1qYD29BrE6dOpB40LLY2aeffoqkpCRnUW0vXtnuJp6Y/sw73buclJEQAi+99BJq1z61aLKkS94LLrgAMk6nudfnfuxdr/s1Z1nZe6d7lxPvSwm9MWnSJI8wJCLCi3D/+++/uwRVqU/yizjtbeKdKnwlnIm/GM4y1mHDhkE8lUXoTkhI8K6i2HPxaPeOzyv13XXXXVqIhpSUFFdZqffxxx9HmzZtXGlyUBbmHgX9nPz000949dVX4b4YnjObcLv55ps1sdH9HirvGLznz/vc2a57uvux87rsZe7c599fvlDOo/ShPOyknLuJyO99j4nYLw+QJMzO2LHFr/sSjPFVtI66detCPKunT5+uvZkhD2bEq7448zdPxeVlOgmURsCgAv/r+pfs3Llz/T6JKg1MuF+X/+gk9lVFTWKaFfc6WUXr1lv5vh2r4eeXTy02oLfxcTxlJ5BX4EDPf/6B9IOnvB3KXov+S4waNUr7g68iIxUvj1J/LBhMqNtpmBa6o163c2GKq1GRJsO+rPxU79rQiKHNjRigXt2OhB/vYQ+VHSQBEiCBMCXw3RY7Xl2m3wffk/qacXYrX2ExTKfDo1viRSwLweXk5EC8nkWMKvVvlr9rEM9Dic0rYTpat26tvebvUXklnIjX7s6dOzVvWhEtmzdvHrCncKi6t2vXLi3etoQm8RbrA21TZA7hKuFTZIzy+7lWrVqBFi82n3hDp6WlaXU1bdrUlU/akPAishdxOC4uznXN+yDYzI8dOwZhJmOV+09E0pKEw2CMwXtMoToP1Tw6+xsoO29daeHChejbt6/2+ZWFMdu3bw8Rd8tqwRhfMOooa7+ZnwQqQkD3QrS8UiD/oUqMKD0Zheiqmc3/PXgaxgxqVDWNs9WwI/DMx9vwzCdpYdevcOtQpQnRbgM3WuJQr/u5SpQer4nTsiCgns2iPMl6NzGqeNImbR/r6TCl56FzbCRAAiQQFQQKlAZ9+TcFkLBNerNzW5twex/+x6W3eeV4SEBPBPwJ0f369dPTEDkWEqg0AroPzSGvfYgIQiOBYBB45N1tyLfS+zUYLCO9jrSD+Xjlq/RIH4Zu+++w5SFz6ddY+/IYLJiQgi0fTkD2lj8Anb4EZFNfS3/sdeCx+TaM/boAzy2yYdU+B+z8utLtPc6BkQAJRBcBecA4tp3+xNrT6how4XT9jSu67k6OlgRIgARIgAQCJ6B7IVpQME504DcEc5ZMYG+mHS98dnJ12ZJz8qreCdz/1ibkFeg6spFuprDwRDbS576PVU8Nw8LbWmL7lAdxfM863YzPeyAnlNfcL9sdmDTLhkumFeCN5YXYfIiKtDcnnpMACZBApBEY3caEBP8hgSNtKFp/a6qXlSQutCUyI3JEJHN2mgRIgARIgASqmkBUCNFnnXVWSFYbrurJY/tVQ+C/UzKwceexqmmcrYYFgRmLM/H9gqNh0Rd2omwECrIysPunF7DswdOx9N6u2P3Dc8jL3Fm2SiIot7zCPX2zHTf/bMOV31gxeXUh9hzlA5QImkJ2lQRIgARcBOKVcHthW32otrLOwQMDLEiKlyMaCZAACZAACZBAtBCICiFaVjMdPHhwtMwpxxliAoV24JaX1vOV9xBzDtfqc3ILcecrm8O1e+xXGQjkZmzG9q8fxuK72mHl44ORNusd2HIyy1BDZGXNOF6ET9bZ8c/vrbjxJyumbrTj0AmK0pE1i+wtCZBAtBMQITpWB1r0P7ua0LNxVPwUjfZbluMnARIgARIgAQ8CUfO/P8NzeMw7TypIYOVm9br7VP16UVYQj66LP/D2Juw7zDAHepvko9uWYOvHE7HgllSsefECHFj0Bex5+n3zYeuRIry1shCXTrPirt9s+HmbHceteptVjocESIAE9EegVjUDJERHJFvfZCMu68i40JE8h+w7CZAACZAACZSXQNT8BTB69GjcfPPN5eXEciTgQ+CJD3djcPe66Nyqps81JuiTwA9/HMAnMw/rc3Ac1UkCRXYcXjNT24yWONTvMRoN+l6Kup2GwWBW70TrzMQf+s/9Dm17ZWkhejcx4sxUE/ookSAmsnUOnc0Uh0MCJEACpwiMa2/Cd1vskIVqI80aJxhw7xkWGBiRI9Kmjv0lgagmULduXfTq1cvFIDEx0XXMAxIggbIRiBohumnTpujevTtWrVpVNkLMTQLFELCpBcGu+89a/P5WP8TFRs3LBcXQ0H9yxuEC3PoSQ3Lof6ZPjdBhy8OBJV9pm7l6bTToM06J0pegdpszoMdf0CJo/LHXoW3xajGsASknRekuDYww8Svu1I3BIxIgARKoYgL1qhu07+g5uyJLiZaQIrI4YYL+nutW8R3B5kmABEJNoHPnzli6dGmom2H9JBAVBKLqp+V5550XFZPKQVYega17C3H36xsqr0G2VCUE7PYiXP+f1cg6xni6VTIBYdBo4YlspM95D6ueGoaFt7XC9ikP4viedWHQs9B0IdcGzNzuwKRZNlwyrQBvLi/E5kORJXiEhgxrJQESIIGqJfDX4SI8Pt+GuREmQgu123qb0TKRrtBVewexdRIgARIgARKoWgJRJUQzTnTV3mx6bV1CNUyesVevw+O4FIFH3t+CP9bmkQUJaAQKstKx+6cXsOzB07H03q7Y/cNzyMvUb8z4rHxg2mY7bv7Zhqu+teKjNYXYe5QPZfhxIAESIIHKJLA+04H7Zttwwwwrft/tQKR9C5+n4lqPaMmYT5V5z7AtEiABEiABEghHAlETmkPgd+3aFRKiY+9eiobheDNGcp/ufn07OrWsiR6n1YrkYbDvfgh8O38/Xp+6388VJpEAkJuxGdu/fljbarXuq8WTbtDrQlhqJukST7p6K+DjtXZta6O82iSe9ODmRshr4jQSIAESIIHgE1ie4cCnawux/mCkSc+nWLSrZ8BNPaPqZ+epwfOIBEiABEiABEjAg0BUeUTLyBmew2P+eRIkAlb1GvsVj6xB+iHlOkjTDYE123Jw8/NbdDMeDiS0BI7+tRhbP56IP25tgTUvXoADi76APf94aButwtq3HinCWysLcek0Kyb9ZsPP2+w4bq3CDrFpEiABEtAJAYfSnOcrr+d//2jFvcoLOpJF6Nqx6s2ygRZY6Aytk7uTwyABEiABEiCBihGIukfTEp7jjTfeqBg1liYBPwT2HXbg4gdWYubLvVGjetR9tPwQieykvZn5uOSB1cjNj1wPpMiegcjtfZGjEIfXzNQ2oyUO9XuM1jyl63YaBoNZfys0ySdk1X6Htr2ytBB9mhgxVHlK90k2IobCQ+TeyOw5CZBApRMoVKH45+y047N1dqTpYF0Ko3pZ5oEBFtSP51szlX4zsUESIAESIAESCFMCUaeWDRo0CDVr1kROTk6YTgm7FckENuyw4R9PrMaUJ3vAbOIf3ZE6lzm5hdpDhf1HuDhbpM5huPTbYcvDgSVfaZs5vg4a9B6ridK12/QDDPr7jrCpj8yCvQ5ti7cAA1KMWviOLg2MMEXdO1jhcheyHyRAAuFOoKAQ2lslUzbYkXlCPw/Ar+lqRvdG/PIP9/uP/SMBEiABEiCByiQQdX8ZxMTEYOTIkZXJmG1FGYHZK47jhmfXwk4NMyJn/kS+HZc8uAKbdql4KzQSCCKBwtwspM95D6ueOhPn5H2Nf3Uzo2Ud/YnRTmS56iM0c7sDk2bZVPiOAry5vBCbD0XXF2Mev0actwP3JEACfgjkqnBGX6634/JvCvCa+o7UkwjdT70Vc2kHvhbjZ9qZRAIkQAIkQAJRTSDqPKJltiVO9JQpU6J64jn40BKYOjcL8dXW45U7Ooa2IdYeVAJW5c55xaOrsHg9Y30HFSwr8yFw8TlDkJxswqUdTdidXYRZ6lXsubsc2HdcP55w7oM+oj5S0zbbta1JDVnkUIXvaG5C01r6FeJl/Lf/asVtvc1oWy/qnvu7Tz+PSYAEvAgcVWG/vlHfidPVJg/t9GbyPX/vGRY9vvijt6nieEiABEiABEig0glEpRA9atQomM1mFBaq9+BoJBAiAh/9fAixsRvx3M3tQ9QCqw0mARGhr37iT8xZmRvMalkXCfgQ6NGjhxKhk13pzWobcK3yjr62G7A+04HZOx1qkSo7sgtcWXR1kK7inn681q5tbRJFlDZhcHMj6lXXlyi96aADf6kFHWWhsReHx6ClGiuNBEggugkczC3C1E12/LDVjgK7PlnEKifoRwdZEK+/JRH0OWEcFQmQAAmQAAlUMoGoFKJr166NgQMHYs6cOZWMm81FG4F3v82E1erAixM7Mj5qGE9+XoEDVz62CrOWHw/jXrJreiEgi+YWZx2TjJBtwulmrNjnwKwddixOcyBPp89NtyqhduuRQry9EujWUBY5NGJgikkXAsYc5eEudky9en/3LCteGhEDeehAIwESiD4C6TlFkPjPv6rvdImlr2e7o48ZLXQcdkrPc8exkQAJkAAJkEBlEIhKIVrAihBAIboybjG2MXnGIZwoWIO3JnWGiQsYht0NcTzPjktVTOg/1uaFXd/YIX0SkPBQpZks7Ne7iVHb8pUIvWivXfOUXpHhQKEOo3fIkFbtd2jbK0sL0UeN/cwWJm38MREYYlTWCJi365S7o3i3T/pbjE6uSTG6tPuf10lALwR2ZBXhi/WFmLfbAYcOv7u95+mC00wYpr67aSRAAiRAAiRAAiRQHIGoFaJHjx6NiRMnFseF6SQQVAJfzc7CkZyVmPxQNyTE8Q/0oMKtQGX7jxSohQlXYs1fymWRRgKVQKBZs2bo0qVLmVqqpv6nHqrCV8iWU1CkBE4J32HHhoNF0KOuId6CC/Y6tC3eAgxIUaK0GnuXBsaIebPkTyWqS1xsdzusnnXd9ZsN/z3LgoYJFKPd2fCYBPRGYKMKzfOFWoRQ3mjR4/e0v/lqX8+AG3tG7U9Lf0iYRgIkQAIkQAIk4IdA1P61kJqaik6dOmHdunV+sDCJBIJPQMI+jLx9KaY81QON68YGvwHWWCYCm3Ydx7j7VyFN/VikkUBlEQjEG7qkvtSMNeA85XEmW6aKNSrxpEWU3qkWPNSjySJeM7c7tC2xGjBELXAo3nZt6oa3kCtz4s8OnijSxOiXR1hQPz68x+Cv/0wjARIomcAqFVLpcyVAy8OoaLI66vv5ERUX2sx1WaNp2jlWEiABEiABEigXgaj+c6GkOJ3loslCJFAKgXXbrRh+y1Ks/iunlJy8HEoCvy0/iBETV1KEDiVk1u2XQDD/30lSQub4jia8PzoGH6htfAcTGupY3BQP42mb7bhxhhVXfWvFx2sKkabiroabWZUGvVB5dBdn+46fFKOP5IVf34vrM9NJgASKJ1CkPsp/7HHgJvXdNGmWLepEaKN6pvbgAIvuFpwtfsZ5hQRIgARIgARIoCIEolqIrqhnWkXAs2z0EkhXHrhnTVyFz35Ji14IVTRy+bH4/KfbcPEDG3BMeSbSSKAyCdSqVUtbKDcUbTZXi+Bd192Mz8bE4BUV+uG8NibU1vGLF+nHivDRWjuu/s6KG3+yYtomOw6HyWdaXsUXT+6SLE31f5IK03E0n99DJXHiNRIIZwISC17efrjuByse+d2GLYej8/N8XTczuqrFZmkkQAIkQAIkQAIkEAiBqA3NIXB69uyJxo0bIyMjIxBWzEMCQSNQoESKm1/YhhWbjuKZm9ohNoZ/wAcNbjEVZR2z4cbn1mLmkmPF5GAyCYSWwMiRI2GxqKDHIbaOSUbINuF0M5arxQ1FKBFxNE8teqhH23qkCFuPFOKtFUA3JYacmWpUcaVNiI+pmtHO2uE/LId3b3YdLcLdynvyxRExSKiivnr3ieckQAKlE7Cpj/gv2+34coMd8oZDNNuApkZcot7GoZEACZAACZAACZBAoASiWog2GAyQRQvfeeedQHkxHwkElcCHPx3Ekg3Z+OD+zmifWiOodbOyUwQWrDmCfz+zHhmHin9d/lRuHpFAaAgEMyxHID00qedbfZKN2pavROiFe+2Yo2JKr1DidKEOtRMZ0ioVl1W2/y4tRF81dlngsU8TIyyVpJMcV+ueivgfqG3LKsI9s6x4fngMqof+GUWg3WI+EiABPwTylBPBj3/Z8fXGQsjio9FuTWsacPcZ/OKK9vuA4ycBEiABEiCBshKIaiFaYIkwQCG6rLcN8weTwKZdNgy5eSUe+1dz/PuC5lDPR2hBImC1OfDU5L/w6tf7IGE5aCRQVQTEE1o8oqvKqqn/7c9UoqxsOQVFmLfrpKf0hoNF0ONHQ330MV/FbJUtXukk4iEtntLy+rjEMw2Vzd9th7RdFtusXue/f44Vz5wZA5knGgmQQHgRkO/M77bYtRBAx9TDpkgyk/q+s4fgS16+qx5VixPyAVok3Q3sKwmQAAmQAAmEB4Go/8kzdOhQJCQk4Pjx4+ExI+xFVBKQUB33vrkL383fj1fv6ITWTeOjkkMwB710YzZufXE9tuzRaTyCYMJiXSEnMGjQIEiM6HCwmrEGnHeaSdsyc4tU6I6TovTO7BCoFWEwYInXPFO9Ri9b3ThgSPOTgnybusFXpIVleWxdZhEemmvDU0MtiKkk7+3y9JNlSCCaCMiCohJ/XkToSAptJN9s/VXIjCs6mzF318kQIsGetzv7mCFrE9BIgARIgARIgARIoKwEol6Ijo2NxYgRIzB9+vSysmN+Egg6gcXr83HGv5fj7sub4taLUxFjYezoskLOyS3EE//bivd/yKQXdFnhMX/ICITr4rhJ8QaM72jStl1KiJb4xnOVt/R+JVDr0eR1+qlKWJKtSQ0DhikvaQnfkaxeMa+oHVKLJa45UD4hWtqWkCKPzrPhscGWSgslUtExszwJ6JHAfhX3eYqK/zxzmx3W8n+kKx2NWX2NDVXfaZd1NKNprZPfaYlxJkxX33fBHMeYtibte7PSB8gGSYAESIAESIAEdEGAKpeaxsqO26mLO4eDCBkBq/Lee3LyXvS5biF+XpwZsnb0VrGsXv/xz2no8Y9FeO97itB6m99IH0+4CtHuXMW77bruZnx6YQxeOcuC89qYUCvWPYe+jtOPFeGjtXZc/Z0VN82wap6Ph5WYXF4TAb/8pU+2ulTFl35ygQ3yfUYjARKoXAJ71AKizy604apvrfh+a3DF21COJFa9RSHf15+o7+57VMxmpwgtbSbGGXB2q+C9ZtGxvgH/7hH1fkyhnE7WTQIkQAIkQAK6J8C/JNQUn3POOTCZTLDbA1vpXvd3BQcYFgR2ZNgx/uGNGNJ9Nx6/vi06teRihsVNzPzVh/HgO1uwdluEBW8sbkBM1xWBLl26oFmzZhEzJolT3zHJqG0TTjdri+/N3mnHojQHZNFDPdoWFad5y+FCvLUC6KbiSEs8aYkrHR8T+GjFmzwY9sdeB55WYtj9/S0hjWcdjL6yDhLQA4Gt6vP/xfpCLFAx5Sv6MKkyeUj8+3Nam3BxexPqKMG5OLukgwk/qUUWKxorOrEa8PBAC8x0YyoONdNJgARIgARIgAQCIEAhWkGqW7cuzjjjDMyfPz8AZMxCApVLYO6qXAy4YSXOH1gL91/dGqelJFRuB8K4tSUbsvAftRjh/NUnwriX7Fq0E4jkt25MSnDok2zUNhGhF+61Y/YOB1buc6AwkhSbAG9CGZKEyJDtv0sL0VeNXUJ39GliLDFchnhSbssKHhDxro4x2TCpr4UL2AY4d8xGAmUlsFaF0vlsnR0r1PdZJJm8qXKhCo9xYVszEgJ4WNYwwaA9XPtVfXeX12TRw4eUCF23evGCd3nrZjkSIAESIAESIIHoIkAh+u/5ltemKURH180faaP9bv5RfL9gBcYMqo1bLm6Brq1rRtoQgtbfeX8exqtTdmDOytyg1cmKSCBUBCIhLEcgY6+m/mI4U4mysuUUFGGeEkvFU3rDwaKI8iIMZKySx6Y0m/nKQ1I28TwUD2nxlO6qPKaNXlqMcAi2/bJdidHGQtymFgWjkQAJBI/A0nQRoAu1767g1Rr6muqpxVbHtjdjtArDId/HZbHxKm70bzus5f6u/pcK29S5AV2hy8KceUmABEiABEiABPwTKOOfMf4r0UOqeKzdddddehgKx6BjAkXK4W7avGy1rcLArtUxYVwqhp9ePyo85qxKFfrm9/14beourN/OEBw6vs11NbQmTZqge/fuuhqTDKZmrAHnnWbStky1sOHsnSdF6Z1qwUM9Wq6K3T9zu1q8TG11lRg0pPlJQb5N3ZOK9Bw1/lDYD+p1+hgV3vUmFSKFRgIkUH4CDvXVNH+3HZ+vt2N7EN9eKH+PAi8pC6tK+I2zWppKfDOjpBpT1OKFA1KM2oO1kvL5uzaomRHjVPs0EiABEiABEiABEggGAf6y+Ztiq1at0K5dO2zatCkYXFkHCYScgISjmL96A1IamHDl2Y1w+cimaFxXfyuLbd2Ti49m7MWXszJx+GhoxJ6QTxYbiFoC4g1tkKDLOrakeAPGdzRp204l8MzZpcJ3KGH2gBKo9WiH84Cpm+zalqwEIvGQzjgeurFO23xSjJaFJGkkQAJlI1Co/myQ+O1fKAE6TS1QGkmWqhaQvVTFd5YHXxImqaImXtHz95TtQX5KTYMWIqiibbM8CZAACZAACZAACTgJ8FeNk4Tai1c0hWg3IDyMCAJ7Dtjx1EdpePqTNAztkYAxgxvhnDMaoFZ85H689x0uwHfz92P6vH1YtjE/IuaBnSQBfwT0EpbD39j8paXWMeDaOmZc0xXqtXeHEoAktIUdRwv85Y78NBG20o4FPyyHN5kvNtgRq77Sr+wcud/r3mPiOQmEkkCBimk/Y5sdU9Rn5+CJyBKg29dTArQSjfupGPXBfI4pb3D0bGQMOCZ2nPq6eWywBXEqNBGNBEiABEiABEiABIJFgL9o3EiKYPDMM8+4pfCQBCKHgEO8fpYfV9tfsLz8F87sWQNn901S+/pomqSWOg9z27LnOH5behA/L87EovV5kDAkNBKIZAI1atTA0KFDI3kI5e67iCcdk4zadksvM5ZnnAzdsSjNAVn0kFZ2ApPXKDFarRh2sfKQpJEACfgnkKscfr/bYse0TYXIjrAHYN3U2xWXqbdLuiuxOFR2eSdTwEL0pH4WSEgPGgmQAAmQAAmQAAkEkwCFaDeavXv3RoMGDXDgwAG3VB6SQOQRsCmhZ+aSY9oGbEfbZhYM6ZGIvp0S0btDbTSoU/UhPHbuO4GlG7KweG0WZq84gjTlPUkjAT0ROOussxATE6OnIZVrLPJKeR/l2Sdbnoq1vHCvHRJTeeU+Bwr5wKlMTN9ZVajFjL6gLcXoMoFjZt0TyM4vUuKzXROhJaZ7pJjIvPLdeIUSiNvWC50A7eQhCw52rG/AerXIbEk2tp0JEhuaRgIkQAIkQAIkQALBJkAh2o2o0WjEueeeiw8++MAtlYckEPkENu+2YfPuA3hr+smHLC0am9CtTQ20T62Bji1ravvk+tWC+gqok1qhvQi7lOi8fscxbFDb+h05WLk5F5lZFJ6djLjXJwEJ90TzJCCveA9rYdK2nIIizN3lUKK0XYXxKELJsohnPdF89vryk2L0qNYUo6P5PuDYTxKQxVK/3mjHT2phz4LQR8kJGnajUqAHK6H38k5mNFexoCvTLlNt3j+neLW+c5IB1zMmfWVOCdsiARIgARIggagiQCHaa7olPAeFaC8oPNUdgR0ZduzIyMa0edmuscUqgahpAzOaNaymFkCMQ73aMUisZUFizRjUqWFBrMWImL83s3o93KZcGa02B6xqJaC8fDuO5FjVZtO2zCMF2L3/BPYcsCL9oB12as4uzjyIDgImkwmjRo2KjsGWc5Q1Yw04/zSTth1Qi/3JAoey0OHObErSJSEVOi8tOSlGi6hPI4FoJJCWU4QvVfzn37bbI+rNCvVnFEaoz60s8NpILXZaFda7iRGtVDz/bWpxWW+rGwc8NNASlMURvevmOQmQAAmQAAmQAAkIAQrRXvfB8OHDERcXh7y8PK8rPCUBfRMoUM4x29IK1XZcDVQ2GgmQQHkJ9O/fH4mJieUtHnXlGiQYcJl6NV22HUocma28pMVb+oDydqT5EhAqzy4SMdqAgXx93hcQU3RLYPuRIny+vhC/73ZE1FsU1dQvrnPVWwzj2ptQr3rVCNDuN4V4RT8+39MrWn2d4GElQifGVX3/3PvKYxIgARIgARIgAX0RoBDtNZ8iQosY/f3333td4SkJkAAJkAAJBEaAYTkC4+QvVwvlqdeijhnXdQPWZUroDocSnexQL13Q3Ag4lBr91AIbLEYL+jZlLFc3NDzUIYEN6rvg8/V2LEmPrFesaqhlAuTNj4tUzGV5CyRcbECKEcnKIzvt2KmHfTf0MGsLzIZLH9kPEiABEiABEiABfRKgEO1nXkVAoBDtBwyTSIAESIAEAiIgYZ5oFSNgUJqNLKwl24ReZqzIcGie0ovSHMhXC7LSoIUkeEx5NT45xIKejSlG857QHwH53H+hBOjVByJLgE6sBiU+m3GeEqGrq9Bn4WYSo1rCgzy/+OSX6ZDmRoxRYjmNBEiABEiABEiABEJNgEK0H8KyYKEsXOhwRNYfvX6GwiQSIAESIIFKJtChQwe0bNmyklvVd3NmpbH2STZqW556m3zhXrvmKb1inwNqPdSoNhWqHw/Ps+E/Qy3o2pBidFTfDDoZfJH6TC/c68Bn6wqxVYXiiCRrGG/Qwm/IYqIxYa7rSoz5j9bYNaH8zj5hqJZH0sSzryRAAiRAAiRAAgEToBDtB1VSUhL69OmDRYsW+bnKJBIgARIgARIongC9oYtnE4wrcUovEQFFtqP5RZinYsXOUTGlNxwsiqiYscFg4ayjwA48ONeG54ZZ0L4+xWgnF+4ji4AsbCwLlooH9O6jkSVAp9Q0aB7GZ6aaImahP3nAd3UXEzqo7wz5XqWRAAmQAAmQAAmQQGUQoBBdDGUREihEFwOHySRAAiRAAsUSYHzoYtEE/UKtagYt/qrEYD1wXBY5VKK0ErJ2ZkeWiBUMMHnqDft7Z9vwwvAYtKkbPrFogzE21qFvAjb1IGXmdjumbLBjn/ocR5K1SRQB2gyJuSzhhCLNzm4V5m7bkQaU/SUBEiABEiABEiiVAN1mikFEj7ZiwDCZBEiABEigWAINGzZEr169ir3OC6Ej0CDBgMs6mfD+6Bi8d24MLu1gQlL1CFSGKoAoV4UtuXuWFTuyIkvMq8CQWVQHBI5bi/DWisKIEqE7JRnwtAqH89Y5MRjYLDJFaB3cOhwCCZAACZAACZBABBKgEF3MpLVr1w6tW7cu5iqTSYAESIAESMCXwOjRo5VXXHSJn74Uqj6lRR0D/tXdjM/HxODlERaMVvFaa8ZUfb8qowfHrCfF6D0RFtqgMtiwjfAkUCfOgJER4pnbSy0K+spZFvz3rBj0asKfUeF5R7FXJEACJEACJEAC4UyAf0GVMDv0ii4BDi+RAAmQAAn4EOD/Gz5IqjRBngl0bmDEbX3M+HpcLJ4aYsGQ5kbE6vxt9Kx84K7frEjPoWd0ld6AbDxgApeoNxjMYfoMT7o1SHk9v6O8n58+04KOSfz5FPDEMiMJkAAJkAAJkAAJeBHgX1JeQNxPL7roIvdTHpMACZAACZBAsQRq166N4cOHF3udF6qWgCzM1SfZiAcHWDBNidL3nWGGeDeawlT8qiitw3kiRtu02NkVrYvlSSDUBJLiDTizRXj9LBFh/KyWRkw+PwYPD7SglYoHTSMBEiABEiABEiABEqgYgfD6i69iYwl66b59+6Jfv35Br5cVkgAJkAAJ6I/A3XffjdjYWP0NTIcjirMAw1qYNO/Gr8fG4NZeZnSob4DeZKbME0W4U4nRh9SeRgLhTmB8B3NYfAbljYkL1AKon1wYg7v7WZBcU2/fDOF+J7B/JEACJEACJEACeiZAIbqU2f3000/RqFGjUnLxMgmQAAmQQDQTGDt2LO65555oRhCxY69VzYDzlej06tkx+FQJT9d0NaN5Lf0IT/uOF2me0Vl5FKMj9iaNko43VZ87WfivqixePaAar0KEfKa+B25RD6fES5tGAiRAAiRAAiRAAiQQXAJV99decMcRstpSU1OxZMkSjBw5MmRtsGISIAESIIHIJJCSkoLXXnsNU6ZMgdHI/1IjcxZP9bphggGXdzLhg/Ni8N65MbhUiVJJ1SNfjNqrYkVPmmVDTgHF6FOzzaNwJHBZR3Old6u2epHlmq4mfDEmFtepRU5l8UQaCZAACZAACZAACZBAaAhU/l97oRlHSGsVoWHGjBnYvHkzFi5ciKysrJC2F0jlNWvWDCQb85AACZCALgjExcVh6dKlYTMWg1oFr379+mjevHnY9IkdCS6BFnUMaFHHjOu6AWsOODQh1xHBOu7O7CLcrcToF4bHICEmuKxYGwkEi4DEYZbY7csyHMGqsth66lcHxrU345zWJlTjL6JiOfECCZAACZAACZAACQSTAP/sKgPNtm3bQjYaCZAACZBA5RIQb+NevXpVbqNsjQQUAfXMATaliUWyCO2cyL+OFOG+2VY8NywGEiebRgLhSEDeSgilEN2khkF722G4ihNvUfGgaSRAAiRAAiRAAiRAApVHgEJ05bFmSyRAAiRAAiRAAhFIYM5OewT22n+XNx4qwv1zrGqhxpiw8QL95ptvINvy5cthsVjQokULPPPMM3z4738Ky5RaVFSEBQsW4Msvv8SGDRuQlpYGq9WKli1bonXr1hg+fDguvvjigOvcs2cP3nzzTe0NwQMHDqBWrVro2bMnbr31VrRr1y7gekrK2DHJiE5JBqzLDO4rCC1qGzC+owmDm5tgZPSNkqaA10iABEiABEiABEggZAQM6g/U4P6VF7KusuJQEHj77bdx4403hqJq1kkCJEACGoFRo0bhp59+Ig0SiEgCBYXA2K8LcELt9WQ9Ghnx1BBLlXqE2mw23H777XjjjTd80M6ePRtDhw71SWdC2QhIDHsRiUuyfv364Z133kHHjh1LyobPP/8c1113HfLy8nzymc1mvPLKK7jpppt8rpUnYVm6A/fNsZWnqE+Z9vUk9rsZfZIZx98HDhNIgARIgARIgARIoJIJ8C+ySgbO5kiABEiABEiABCKHwOI0u+5EaKG/cp8Dj/5uQ2HoQ/EWO9niWetPhC62AC+UmUBhYelPUBYtWoRzzjkHR48eLbb+6dOn4/LLL/crQkshaefmm2/GRx99VGwdZbnQq4kRrVW86IpY94ZGvDjcgtdGxlCErghIliUBEiABEiABEiCBIBKgEB1EmKyKBEiABEiABEhAXwRm76xCpTbEKJcor9OnFthgr4Ih5ubm4umnn/YY4eDBgzWP2gsuuACNGjXyuBbNJ+np6XjiiSdw8ODBcmOoVq0ahO+1116LcePGoWHDhh51SciNiRMneqQ5T/bv349//OMfzlNtbzKZ0LlzZ8TEeK58KR7Ru3fv9shb3pPLOpY9gqBI12c0NeKNkRY8r0TorkqMppEACZAACZAACZAACYQPAf51Fj5zwZ6QAAmQAAmQAAmEEYFjBUVYnlEFKm0lMpi/x4FnFtoqfTHGH3/8ERJj2GkiSs+dO1fzkJZ40cGKN+ysPxL3v//+uyYaN2/eHA8//DBEEC6rdevWDS+//DJEzBa+77//Pr766its27YN119/vUd1wt2fvffeezh27JjrUp8+fZCRkYE1a9ZofTrzzDNd106cOAEJ+xYM659iRErNwLyiTSrbsFQjPhgdg8cHW9C2Hn/iBGMOWAcJkAAJkAAJkAAJBJsA/0oLNlHWRwIkQAIkQAIkoAsCItLa9K1Da/M0Z5cDLy4uRGWuGrJjxw7XPZKQkFBqHGNX5ko+yM7OLtZTOBRdEU/xd999V/M2Fg/mqVOnamEvytuW1HHbbbchMTHRo4r4+Hht0cHu3bu70nNycrBr1y7XuRxIyA3pj9Pq1KmDKVOmICkpSUuScwnHIXunffDBB9qCiM7z8u5lQUFZXLAks6hfMue2NuGj82NwX38LmqkFCWkkQAIkQAIkQAIkQALhS4BCdPjODXtGAiRAAiRAAiRQhQTm6DgshzfWmdvteHVZ6fGEvcuV99w9fEOLFi1QvXr18lYVsnJZWVkYPnw4vvvuu5C14axYPJTvuOMOJCcn49///jfWrVvnvKTtRTiWLZgm4TWGDRvmUeXOnTs9zr///nukpaW50iT0RkpKiutcDpo0aYIbbrjBlSYhRERAD4admWpCg3hfcTlORe0Y186Ezy6Mwe19zGhUwzdPMNpnHSRAAiRAAiRAAiRAAsElQCE6uDxZGwmQAAmQAAmQgA4IHMwtwpoDUeAO7TZX32+1460VlSNGS2gHp9WvX995GDb7w4cPQ0JOrFixImR9KlIu6DNmzMCoUaPQpk0bLYSGeGC7W4cOHfDaa69poTBEsA+2iRe0u7Vv3979FNOmTfM4Hz16tMe580TG4G7BEqJN6pfKxe1PeUXXUCGpr+pswudjYnBDTzPqVqcA7c6dxyRAAiRAAiRAAiQQ7gSUPwGNBEiABEiABEiABEjAncBcFa6iyD0hSo6nbrIjVul+13QLzZ+IEyZMQGZmJhYtWuQiunr1alx88cXaucQtdvfSFbF28uTJmD9/Pv78809ISI+WLVtCQkqMHDkSY8eOddXj76A85cWjV/qwdu1arUoRzWWBP3eTOMl33nmne1LAxyI2/+9//9NCY2zfvt2nnCwAOGbMGNx4440YOHCgz/VgJezbtw/Tp093VSdieIMGC4F7+gAAQABJREFUDVznciCLGDpNwnH06tXLeeqx79u3L2rXrg2nkO7u8e6RsRwno1TojZ+32SHe0aPbmBBnKUclLEICJEACJEACJEACJBAWBELzKyMshsZOkAAJkAAJkAAJkED5CMzeaS9fwQgpFa/EvIYJBi3sgftejmULlYnwKQKou4n38ddff60l9e/f3yVES76rrroKs2bNcs8OEa5lEzH36quv1gRdf6E9ylNeFlAUT+gNGza42rTZbD6hJvLy8sosRIuw/cYbb+DTTz+FLOrnbc2aNdPCclx77bWuGMzeeYJxLgsPzpw5U1sAUR4KOM39AYAzzT0sR6tWrWAw+L83JMyHPCBYuXKlVtS9nLOu8u5j1IORd85VrtA0EiABEiABEiABEiCBiCdAITrip5ADIAESIAESIAESCCaBPUeLsC0rsv2hvYVmb7E5Icx1vSNHjmhez/v37y9xamWhPMkjwqq7lae8xIQeMmQINm3a5F5VUI5/+OEHnHfeeT51GY1GzbNbvJ/Fw1vOQ2UiQDdv3hzCxtskBMjTTz/tkSze5Onp6a60evXquY79HdStW9eVLF7lBQUFiI2NdaXxgARIgARIgARIgARIgAQoRPMeIAESIAESIAESIAE3ApHgDZ3g9GgWD2a1mFsDN+/mRuo4PkyF5ieffFIL3/DWW29BFugTE09bEWLFhg4dqu0feughTWDWTv5Of+CBB5CamqqF53jkkUewcOFC7fIvv/yCX3/9FSNGjHBmR3nKn3766bjuuuu0OsRz21l/QkICHnvsMVfdciBhLMpi4kHtbbfddhsmTpyoicPe10JxLp7d/kRoCamxYMEC1KxZ06NZ8Q6XMk4rTYhOTEx0ZoVTxA5FXGtXIzwgARIgARIgARIgARKIOAIUoiNuythhEiABEiABEiCBUBKYvbPqFyn0Fpo1j+a/RWc5DlehubR5ueaaa7Qss2fPdgnRIurecccdrqISFuOdd95xnYsn8Xfffec6FzF68ODB6N27tysUxP333+8SostbXhYmdPZDvKydQrR4+jrTXZ0IwsEnn3wCi8WCG264AVUp2EpcZ/EElwUG5aGA07zDh0js6pKsWrVqHpfFI5pGAiRAAiRAAiRAAiRAAu4EKES70+AxCZAACZAACZBAVBPYeNCBfcdDH5ajhtL0GihPZhGVnWEzxKtZvJsjWWgOxs0jIrXdfjJGt8QkFu9pb5OYxOL1fMEFF2iXZCFDZyiIipb3bisY5926dcPZZ58N8d4Wb2ExiY39/PPP44UXXtCu3XTTTRg1alTIwnOIUHzllVdiy5YtWoxtq9XqGtqaNWtw6623YsaMGa60Ro0auY7lQEKXlGTe1xs3blxSdl4jARIgARIgARIgARKIQgIUoqNw0jlkEiABEiABEiAB/wTmBMkb2p/Q7C46R6pHs39qwU3dvHmzq0IRbb1jFzsvSugIpzkcDi1kR7t27VDR8s46g7lv3bo1fv75Z2zduhWvv/46Jk+eDInZLCZjlGuySQznf//735AFC+vXrx/MLkAWdPz444+1OqVtEZ6lH06T9letWqXF5pa0uLg41KlTxyVAHzp0yJnV7979uoQzqVWrlt98TCQBEiABEiABEiABEoheAhSio3fuOXISIAESIAESIAE3AnYVkWPe7pOeuG7Jfg9FaNaEZa/4zE7vZgrNfrEFlCgeu+4mwm0gJjGnRYiuaPlA2ipvHglD8uqrr+Kpp57SRGAZm4jTTtu1axfuu+8+PProoxg7dizES7pfv37Oy0Hb16hRAx9++CF27tyJ33//3VXv8uXLXUK0JDZp0sQlRGdmZrry+TtwfzCQnJzsLwvTSIAESIAESIAESIAEopwAhegovwE4fBIgARIgARIggZMEVu13ICv/5LG30OwuOstxdbVYIC00BNwX9hMv3nHjxgXUkDOUREXLB9RYBTOJEHzLLbdgwoQJWriO1157TfOIdobtkDAjn332mbZ17dpVW8zx6quvRmxsbAVb9ix+/fXXewjR7qK45BQhev369Vohib0tXs/+Fi1MT093xfyWzBSiNWT8hwRIgARIgARIgARIwIsAhWgvIDwlARIgARIgARKITgJNahjw3rkxmqczheaquwfcYwsnJiZ6hI8IpFcVLR9IG8HKIzGwJXa0bOLRLR7S4qmck5PjamL16tVauI6+/2fvPuCkqs7Gjz+zU7Y32KW3pXcEKYqAgCAdNNFEX/OqwRYsQRPTjOWvSTRvNCRqrFijxhSNBTWoWKKogAVUFATpve7Sdtmdsv9z7jKzM1tnd6fcO/M7+Uz23jv3nvK9I7vzzJnnnHqqDBo0KHA8Ehs6hUZwcbvdwbvG7Gid11oXnf5Ep+/QeaZrlkWLFoUc0n2lIIAAAggggAACCCBQUyCl5gH2EUAAAQQQQACBZBTooALR3fOZ7Rzve6/zKfvL9u3b5d133/XvhvWzpdfrRlJSqv9E1rOTY1F69uwpf/7zn0XPLtYB6b59+0a92aVLl4a0MWTIkJD9yy67THSw3F+eeuop/2bgpw5QBx/XC0nq6ygIIIAAAggggAACCNQUqP4ru+Yz7COAAAIIIIAAAgggEGOB8847L6TFiy++WILzD4c8qXaWL18uc+bMkUOHDhlPtfR6XUlwCozdu3fLhg0bjLpj8X96lvJVV10lX3/9tbzxxhsyc+bMkMB4uH3weDxGao3f/OY3UlJSUuuy999/X+6+++6Q48OGDQvZLyoqkilTpgSOvfnmm6LTiASX22+/XT788MPAId3fzp07B/YjtbH9cGWkqqIeBBBAAAEEEEAAgTgJkJojTvA0iwACCCCAAAIIIFBbQM/K1akqFi9ebDy5ZcsWYxHC2267Tc444wzRqTd0YHjNmjXy3HPPyYsvvmic55+53NLrdWWFhYVGnf7/+8Mf/iC//e1vpXXr1vLZZ5/JH//4Rxk3bpyRu9l/TqR/6pnIkydPNh7btm0Tfw7scNvR+aZ37twpN998s9x5551Gf/v37y863YlO9/Gvf/3LSLfhr2/UqFEyePBg/27g549+9KPAvdAHr7/+euN6HbTWHwL87W9/C5yrN/QCi5EuO49UyuWvVMjJ7VPk2lEOaZ1RPUs70m1RHwIIIIAAAggggED0BGzqj1SmF0TP1/Q1P/jgg1F9E2V6ADqIAAJRF5g+fbq8+uqrUW+HBhBAwDoCM2bMkNdee83ocF3/Rhw5csQInOqAabhFz5pu06aNcXpLr9cL8w0cODCkaYfDIU6nU/yLIeqZxjfeeGPIOWba0fmeXS5XWF1KT0+XlStXSp8+fWqdr98q6FnO/vtV64SgA9///vfl73//e9CRlm/qdyrXv+mWVXt8RmVZaqHQq0Y45Mwe9pZXTg0IIIAAAggggAACMRUgNUdMuWkMAQQQQAABBBBAoDGB7OxsI/DZtWvXxk41nh85cqRkZGQEzm3p9QMGDJALL7wwUJ/e0Kku/EHokCcsvqOD9//4xz/qDELroemZ2U8//bRo44bK+PHj5ZFHHmnolGY998p6byAIrSs4qtZT/L8PPfLzJW7Zc5T5NM1C5SIEEEAAAQQQQCBOAgSi4wRPswgggAACCCCAQLIK6JnF/hK87T+mf+pUFDqP8fz58yUnJyf4KWM7Ly9PJk2aZORR1ikidG7l4NLS6x999FFZsGCB6HaCi54ZfdZZZ8msWbOCD5tuW7vqWc7XXHONFBQU1Opf27ZtZe7cuUaKk8bGkp+fL++9957cdNNNtdKWtGvXzkhbovNH17wHtRpt4oG9xyrl4U89dV716S6fXLKoQl7+xit8v7NOIg4igAACCCCAAAKmEyA1h+luSWw7RGqO2HrTGgLJKFDX1+6T0YExI4BA8wV0eoi9e/fK/v37jbzGXbp0kdzc3LArbMn1Pp9PNm3aJDpPs5493K1bt5DZ12F3Is4nHjx4UHS+7aNHj0rfvn1rBZTD7Z6eGa4tdPoT/QGBXpjQbo9OmoxfveWWFTurUnI01L+BhTb52WindMohd3RDTjyHAAIIIIAAAgjEW4DFCuN9B2gfAQQQQAABBBBAoEEBnR5Cz+DVj+aUllyfkpIiPXr0MB7Nadss1+hFCvWjpUXPCC8qKmppNY1e/8YGb1hBaF3R6n2VcpmaHT13qEO+09cudr7z2agvJyCAAAIIIIAAAvEQ4M+0eKjTJgIIIIAAAggggAACCNQpUFxWKfd/UndKjjovUAcr1MTpB1Uaj6v/UyEbi8kdXZ8TxxFAAAEEEEAAgXgKEIiOpz5tI4AAAggggAACCCCAQIjAPSs8cqQi5FDYO+sOVsq8VyvkqS884vaGfRknIoAAAggggAACCMRAgEB0DJBpAgEEEEAAAQQQQAABBBoXeG+LT97b2nhe6IZq8qgJ0U987pV5r1XI2v0tq6uhdngOAQQQQAABBBBAoGkCBKKb5sXZCCCAAAIIIIAAAgggEAWBw+WVcs8Kd8Rq3lRSKdcsdsvCzzxS3rRMHxHrAxUhgAACCCCAAAIIVAsQiK62YAsBBBBAAAEEEEAAAQTiJHD/xx4pPh7Zxn1qdvTfv/LKZa9UyBd7mB0dWV1qQwABBBBAAAEEmiZAILppXpyNAAIIIIAAAggggAACERZYscMnb26KXqB4x5FK+ckbbvmLyj9dFrlJ1xFWoDoEEEAAAQQQQCCxBQhEJ/b9ZXQIIIAAAggggAACCJha4JhamHDBsujnzlCTo+WFb7xyyaIK+WRn9ILepsamcwgggAACCCCAQBwFCETHEZ+mEUAAAQQQQAABBBBIdoGHVQ7nfaU6TBybsudYpfziLbfc9ZFHjqogOAUBBBBAAAEEEEAgNgIEomPjTCsIIIAAAggggAACCCBQQ2DVbp+8ut5b42hsdv/zrVfmvlwuS7cyOzo24rSCAAIIIIAAAskuQCA62V8BjB8BBBBAAAEEEEAAgTgIHFfZOP6oZiXHbi507UEeKBO55b9u+e37bik5Hs+e1O4bRxBAAAEEEEAAgUQTIBCdaHeU8SCAAAIIIIAAAgggYAGBrYcqVWoMcwR/39nskx++VCFvbYrP7GwL3C66iAACCCCAAAIItFiAQHSLCakAAQQQQAABBBBAAAEEmirQu7VNHpvtkrGdzfGW5LDKF337Uo/8+m237I9hzuqmunE+AggggAACCCBgVQFz/NVnVT36jQACCCCAAAIIIIAAAs0WyE+3yf8b75RbT3dKq7RmVxPRC5ft8Knc0RWic0hTEEAAAQQQQAABBCInQCA6cpbUhAACCCCAAAIIIIAAAs0QGNMlxZgdPanIHG9PjrlF7lL5q3/2plt2HTFH+pBmsHIJAggggAACCCBgKgFz/KVnKhI6gwACCCCAAAIIIIAAArEWyE61ya/GOOWOiU5pk2GLdfN1tvfZbp9c+kqFvLDWKz7i0XUacRABBBBAAAEEEAhXgEB0uFKchwACCCCAAAIIIIAAAlEXGNkxRR5VuaNn9rKLGcLRxz0if/nYI9e+XiF6gUUKAggggAACCCCAQPMECEQ3z42rEEAAAQQQQAABBBBAIEoCGU6R605xyB/PdErHbDOEo0W+2lcpl6vZ0X9f7RWvL0oDp1oEEEAAAQQQQCCBBQhEJ/DNZWgIIIAAAggggAACCFhZYEjbFFk40yXn9LNLigni0W4VgF640iNX/adCNhxkdrSVX1v0HQEEEEAAAQRiL0AgOvbmtIgAAggggAACCCCAAAJhCqQ6ROYNd8i9U53SLdcE0WjV7/UqCH3laxXyxCqPuL1hDoTTEEAAAQQQQACBJBcgEJ3kLwCGjwACCCCAAAIIIICAFQT6FqTIgzNccsFAuzhMEI/2qAnRT33plSterZA1+8jVYYXXEH1EAAEEEEAAgfgKEIiOrz+tI4AAAggggAACCCCAQJgCTrvI3KEOeUAFpHu3MkE0WvV7i1rA8JrFbnnoU4+Uq4UNKQgggAACCCCAAAJ1CxCIrtuFowgggAACCCCAAAIIIGBSge75NvnLNJfMPckhLhO8o9HZov/5tVcuXVQhq3YzO9qkLxu6hQACCCCAAAJxFjDBn21xFqB5BBBAAAEEEEAAAQQQsJyAXb2TuWCQXR5WixkOLDTH7OidRyvl+jfdcvdyj5S6LUdKhxFAAAEEEEAAgagKEIiOKi+VI4AAAggggAACCCCAQDQFOqsFDP80xSVXqQUN09TChvEuenb0y+u8MvflClmxg9nR8b4ftI8AAggggAAC5hEgEG2ee0FPEEAAAQQQQAABBBBAoBkCKWpC9Hf62eXRWS4Z1s4cb3H2lVbKr952y/994JbD5To8TUEAAQQQQAABBJJbwBx/pSX3PWD0CCCAAAIIIIAAAgggEAGBdlk2uXOyU35yikMynRGoMAJVvLHRZ8yOXrqV2dER4KQKBBBAAAEEELCwAIFoC988uo4AAggggAACCCCAAAK1BWb0sstjs11yaidzvN0pPi5yy3/dcqt6FJcxO7r2HeMIAggggAACCCSDgDn+MksGacaIAAIIIIAAAggggAACMRMoyLDJbyc45ddjHJKbGrNmG2zoPTUr+ocqd/SSjd4Gz4vlkzsOV8rL35inP7EcO20hgAACCCCAQGwFCETH1pvWEEAAAQQQQAABBBBAIIYCE4uqZkeP72qOtz5HKkTu+MAjN7zlln3H4js7ulI1f9dHHnlkpYeZ2jF8TdIUAggggAACySpgjr/GklWfcSOAAAIIIIAAAggggEDUBfLSbHLTOKfcNt4prdOj3lxYDSzf6ZNLFlXIK+u8ogPC8Sgvq7a/2OuTY25RwWhmRcfjHtAmAggggAACySRAIDqZ7jZjRQABBBBAAAEEEEAgiQVO65yickenypQe5ngbpAPAf1rukevfdMvOI7GNRu9Vs7Ef+cwTeDW8vsEr6w7Etg+BxtlAAAEEEEAAgaQQMMdfYElBzSARQAABBBBAAAEEEEAg3gJZLpGfj3bK/53hlLaZtnh3x2h/1R6fXKpmRz+/xiu+GMWCFyzzSGl1HFp0s/eucMdtdrYpbgSdQAABBBBAAIGoChCIjiovlSOAAAIIIIAAAggggIAZBYZ3SJFHZ7lkdm+7mCEcXa4yY9z/iUfmL66QLSXRjUYv/tYrH6vUIDXL1/srZckmUnTUdGEfAQQQQAABBCIjQCA6Mo7UggACCCCAAAIIIIAAAhYTSHeKzB/lkD9PcUqnbDOEo0V0MPiKVyvkmS+94q0dK26x8MGySnnw06Cp0DVqXKjSdZSplCEUBBBAAAEEEEAg0gIEoiMtSn0IIIAAAggggAACCCBgKYGBbVJkoZod/b3+dkkxQTzarQLQj63yyJWvVci3ByM7O/oelZP6SEX9t+dAmcjTX9YfqK7/Sp5BAAEEEEAAAQQaFiAQ3bAPzyKAAAIIIIAAAggggEASCLjsIlec7JD7prmkKM8E0Whl/m1xpRGMfnSlR9wRyJjx7mavvL+t8WnWOld1rBdPTIKXGENEAAEEEEAg6QUIRCf9SwAABBBAAAEEEEAAAQQQ8Av0bm2TB2e45MLBdnGa4N2SV02I/ttqr1z+SoV8va/xILJ/HDV/Hi6vlL98HN5MZz0j+74wz63ZDvsIIIAAAggggEB9Aib406q+rnEcAQQQQAABBBBAAAEEEIi9gEO9S7poiEMemO6SPiowbYay9XCl/HixW+5XAeLj4cWTQ7qtA8vFx0MONbizbIevzgUNG7yIJxFAAAEEEEAAgQYECEQ3gMNTCCCAAAIIIIAAAgggkLwCRfk2uXeqSy4b6pBUlboj3kVni35+rVcuXVQhK3eFPzt6uQoqL9kU/vn+ceqgt6fpl/kv5ycCCCCAAAIIIBAiQCA6hIMdBBBAAAEEEEAAAQQQQKBawK7eMZ030C4Pz3TJoDbmmB2962ilXL/ELX9a5pFjDSw8qEehn//TMnf1gJqwpWdhv6AC3xQEEEAAAQQQQCASAgSiI6FIHQgggAACCCCAAAIIIJDQAp1ybPKnM11yzQiHpDvMMdRX1ntl7svlsmx7/dOWH/rUI/tKm9/fp75QKT3K9FxsCgIIIIAAAggg0DIBAtEt8+NqBBBAAAEEEEAAAQQQSBIBm5oQfVZfuzw6yyXD25vjrdT+MpFfv+OWO5a6RS9IGFxW7fbJa9+2bEbzMTWZ+pGVzUhKHdwRthFAAAEEEEAAASVgjr+euBUIIIAAAggggAACCCCAgEUE2mbZ5P8mOeX6Ux2S5TRHp3UO6LkvV8h/t1TNjtYLGt71kUdCQ9PN6+vrG3yy7kAkampe+1yFAAIIIIAAAokhQCA6Me4jo0AAAQQQQAABBBBAAIEYC0zraZfHZrvktM7meFtVfFzktvfccsu7brl3hUd0LulIFF3LvSvcUhmZ6iLRJepAAAEEEEAAAQsKmOMvJgvC0WUEEEAAAQQQQAABBBBAoHWGTW4b75QbxzokL9UcHku3+WTxhpal5Kg5kq/3V8qbGyNbZ8022EcAAQQQQACBxBYgEJ3Y95fRIYAAAggggAACCCCAQAwEJnSzy+NzXDKxW+K+xdK5ostUzmgKAggggAACCCDQHIHE/SupORpcgwACCCCAAAIIIIAAAgg0UyAn1Sa/HuuU301wSkF6Mysx8WUH1MKIT3/JwoUmvkV0DQEEEEAAAVMLEIg29e2hcwgggAACCCCAAAIIIGA1gVM6pajc0amic0gnWnl+jVd2HCZZdKLdV8aDAAIIIIBALAQIRMdCmTYQQAABBBBAAAEEEEAgqQQyXSLXn+qQOyc5pX2WLWHG7vaJ3P8Js6IT5oYyEAQQQAABBGIoQCA6htg0hQACCCCAAAIIIIAAAsklMKx9iiyc6ZLv9LVLooSjl+3wyQr1oCCAAAIIIIAAAk0RIBDdFC3ORQABBBBAAAEEEEAAAQSaKJDuFLlqhEPunuKULjmJEY7Ws6I9xKKb+ErgdAQQQAABBJJbgEB0ct9/Ro8AAggggAACCCCAAAIxEhjQJkUeVrOjzx9gF7vF49HbVJ7oF9Z6YyRHMwgggAACCCCQCAIEohPhLjIGBBBAAAEEEEAAAQQQsISAU61feOkwh9w3zSU98q0djX7qC48Ul7FwoSVeeHQSAQQQQAABEwgQiDbBTaALCCCAAAIIIIAAAgggkFwCvVrb5P7pLrl4iF2cFn1Xdswt8shKFi5Mrlcuo0UAAQQQQKD5Ahb9k6f5A+ZKBBBAAAEEEEAAAQQQQMAMAg71bux/BzvkoRku6VdgzdnRr2/wydr9JIs2w+uJPiCAAAIIIGB2AQLRZr9D9A8BBBBAAAEEEEAAAQQSWqBrnk3umeqSH53skFSVusNKRSfmuO9jj1SSocNKt42+IoAAAgggEBcBAtFxYadRBBBAAAEEEEAAAQQQQKBaIEVNiD63v10emeWSk9pa623a1/sr5c2NLFxYfTfZQgABBBBAAIG6BKz1F05dI+AYAggggAACCCCAAAIIIJAgAh2ybXLXZKdcO8ohGQ7rDErnii5VOaMpCCCAAAIIIIBAfQIEouuT4TgCCCCAAAIIIIAAAgggEAcBm5odPau3XR6d7ZKRHazxlu1AmcgzX7JwYRxeLjSJAAIIIICAZQSs8VeNZTjpKAIIIIAAAggggAACCCAQGYE2mTa54wyn/GK0Q7JdkakzmrU8v8Yr2w+TLDqaxtSNAAIIIICAlQUIRFv57tF3BBBAAAEEEEAAAQQQSHiBM3vY5XE1O7p1urmH6vaJPPAJs6LNfZfoHQIIIIAAAvETIBAdP3taRgABBBBAAAEEEEAAAQTCEvhqX6Xo9BdmL8t2+GSFelAQQAABBBBAAIGaAgSia4qwjwACCCCAAAIIIIAAAgiYSOBIeaXcvdw6KwHer2ZFe4hFm+gVRFcQQAABBBAwhwCBaHPcB3qBAAIIIIAAAggggAACCNQpoAO7B4/X+ZQpD25TeaL/rfJFUxBAAAEEEEAAgWABAtHBGmwjgAACCCCAAAIIIIAAAiYS0Gku3thovenFT3/pkeIyFi400UuJriCAAAIIIBB3AQLRcb8FdAABBBBAAAEEEEAAAQQQqC1QqrJx/GmZNRf/O6b6vnClNfte+05wBAEEEEAAAQQiIUAgOhKK1IEAAggggAACCCCAAAIIRFhg4Wce2Vtq3VnFb2zwydr91pvNHeHbSHUIIIAAAgggcEKAQDQvBQQQQAABBBBAAAEEEEDAZAKf7/HJonXWzrOsQ+h/+dgjldaNpZvsVUF3EEAAAQQQsLYAgWhr3z96jwACCCCAAAIIIIAAAgkmUK4yWvzxIxXATYBxrdlfKW9utHZAPQFuA0NAAAEEEEDAFAIEok1xG+gEAggggAACCCCAAAIIIFAl8Pgqj+w4kghh6Krx6BQjOt81BQEEEEAAAQSSW4BAdHLff0aPAAIIIIAAAggggAACJhLQOZWfX5tYM4gPHhd56gsWLjTRy4yuIIAAAgggEBcBAtFxYadRBBBAAAEEEEAAAQQQQCBUwK3iz3d+6BFf4kyGDgzwBRVc3344AQcWGCEbCCCAAAIIINCYAIHoxoR4HgEEEEAAAQQQQAABBBCIgcAzX3pk86HEDNa6fSIPfMKs6Bi8jGgCAQQQQAAB0woQiDbtraFjCCCAAAIIIIAAAgggkCwCG4sr5dnViZWSo+a9W7bDJyvUw+ylpKRE5s+fb/Zu0j8EEEAAAQQsJ0Ag2nK3jA4jgAACCCCAAAIIIIBAIgl4VWz2zg/d4knMydAht+q+jz3iMXEsuri4WCZPniwvvfRSSL/ZQQABBBBAAIGWCzhaXkXdNXi9XnnjjTfknXfeEf3LXO9TIifQunVrufPOOyNXITUhgAACJhYoKyuTUaNGmbiH1u5aWlqadOvWTebMmSPf//73xeGI2p8H1oai9wgggECUBP75tVfWHUyCKLTy236kUv69xivfG2CPkmbzqz1w4IARhF65cqV07dq1+RVxJQIIIIAAAgjUKRCVd5rbtm2Tc889V5YvX15noxxsuUCXLl0IRLeckRoQQMAiAj6fT7788kuL9Naa3fz444/lX//6lyxYsEBefPFF6dy5szUHQq8RQAABiwlsUzmh//p5cuVOfuoLj0zqniKt0m1Ru1uvvPKK3HffffLNN9/Ivn37pFOnTtKrVy+ZPXu2nH/++ZKZmRnStj5n0qRJ8sUXXxjHd+7cabynDT7plFNOkZ/+9KfBh4xtPelqxYoVsnr1auPvFR3Qbt++vQwaNEgGDx4sQ4cOrXWN/8C6devkxhtv9O8GfjqdTikqKpIePXpIz549ZcSIEaI/OKYggAACCCBgZYGIB6L1rLUzzzxT1q5da2UX+o4AAggggEBSCnz22WcyZcoU0T95w5uULwEGjQACMRbQi/hdcbJD9pVWyt5jVY89x0QOlFWKL0EnSZequPsjKz3y89HOqGhfdtll8sgjj4TUrd+f6seiRYvk+uuvl08//dQI8uqT9uzZI2eccYZ89dVXgWvcbrc899xzgX29od/r1gxEr1q1SnR7n3zySci5wTvTp0+XBx98sM4PeXfs2GF8EBx8fl3beob27bffbgTRbbboBfDraptjCCCAAAIIREog4oHoe+65hyB0pO4O9SCAAAIIIBAHgTVr1sgDDzwg1113XRxap0kEEEAguQS659uke37tNBU6b7QORu9Twek9RoBaQoLVOmh9uMK6Vm9s8Mns3j7pWxDZZYuef/75WkHomkqHDh2SI0eOGId1GskJEyaI/t3X1HLHHXfIzTffLB5PwzPaX3vtNRkwYIA89thjcs455zS1GeP8LVu2yAUXXGD8fn7zzTf5sLhZilyEAAIIIBBvgYgHov/5z3/Ge0y0jwACCCCAAAItFNDpOQhEtxCRyxFAAIEWCNhVfLZNps14DKinnuMq/lkdqFZB68CsajFmV+v9cpMu1aMne/9FLVx471SXRHKC75IlS0K0br31Vvnud78r27dvFx3Afeihh+To0aMh51x66aXG/r///W/54IMPjO2srCzR1waX3r17B3ZfffVVueGGGwL7emPgwIEyZswYycvLk40bN4ruy8GDB41zdOD7hz/8oQwbNky6d+8ecl3wjg5U69nPhw8fNh465cemTZsCpyxdulR+8YtfyN133x04xgYCCCCAAAJWEYh4IHr9+vVWGTv9RAABBBBAAIF6BHbt2lXPMxxGAAEEEDCLQJp6N9c512Y86uvToeM63YdKP6FmUFcHqqvTgBwoE4lXBpA1+yvlzY1eObNH7Rnh9Y2nseM613Nw0WkzdL5mPSNZp5765S9/KfpbvG3btjVOy8/Pl5/85CfG9u7duwOBaL04vP94cH16e+/evTJ37tzAYZfLJXp29LXXXispKdUzvHVfrr76avFP1tIB8IsvvljefffdkPMCFakN/SHw6NGjgw/JX//6V6M9nYtal3vvvddYYHjixIkh57GDAAIIIICA2QUiHojWiypQEEAAAQQQQMDaAu3atbP2AOg9AggggIAhkJtmk1y1xl2v1nXnFdYpQParmdPVgeqq2dT+fNU6eH0kiilAFn7mkTFd7JIRobeRelayTs/hLzr4/OSTTwYWDCwoKJDbbrvN/3Szfv7jH/8wgtH+i2+66aY6g9aFhYXy97//Xfbv3y9vv/22cfr7778velbzuHHj/Jc3+vPCCy+UjIyMwOKJlZWVRnCbQHSjdJyAAAIIIGAygYgHok866aTAL1mTjZXuIIAAAggggECYApMmTQrzTE5DAAEEELCygE4B0jbLZjzqG0eZ+0RwOpD6wz+jujpvtV50sTnl4HGRp77wGAs2Nuf6mtfMmzdPFixYEMgB/eWXX8qoUaNk/vz5Rj7n7Ozsmpc0eX/58uWBazp16mSkyggcqLGhFxZcuHBhYGFE/bRe4LApgWh9jU7ZUVRUFEjTsXr1an2YggACCCCAgKUEIh6InjZtGoFoS70E6CwCCCCAAAK1Bc4+++zaBzmCAAIIIJCUAulqtnLXPJvxqAtATdCVEpUCZF9pVQoQ/2xq/dOfDuRgAylAXljrlRm97NIpp+5Z23W1Wd8xnXLjjTfekNmzZ4s/TYfb7Za77rpLnnvuOWN2dFODwDXbCg5EjxgxQhr7VrDOCd2hQwfZuXOnUdXnn39es8qw9nW//fmiCUSHRcZJCCCAAAImE4h4IFr/wv/Zz35msmHSHQQQQAABBBAIV6Bz584yaNCgcE/nPAQQQACBJBfQiw3mp9vUQ6R3PSlA3Cq9sU4Bsjcwq/rEgooqWK2PPfm5R349NjL5OU455RT56KOP5KKLLgrkfNa3aPPmzTJhwgR57LHHjOeae9v0QoL+onNJh1N0ShB/IFr3ozlF/372F51v2uPxiMMR8bf0/ib4iQACCCCAQMQFIv5bS68k3LdvX1m7dm3EO0uFCCCAAAIIIBB9AWZDR9+YFhBAAIFkE3Cq9QjbZ9uMRyzG3qNHD9H5mB9//HEjdYbO06yLz+eTyy+/XPr06SM6YN2c0r9//0CO6DVr1jRahV5kcN26dYHzunTpEthuysb69esDp+vxEYQOcLCBAAIIIGARgeolfSPY4Tlz5kSwNqpCAAEEEEAAgVgK8Hs8ltq0hQACCCAQLQGdn3nu3LnyzTffyPnnnx9opqKiQu6+++7Avn8jJaX67XF5ebn/cK2fel0kf1mxYoV88cUX/t06fz711FNy/LhKhn2ijBkzxr8Z9s+DBw/KkiVLAufrRRkpCCCAAAIIWE2g+jdtBHuu03NQEEAAAQQQQMB6AnoRp+a8QbbeSOkxAggggEAiCtx0003GTOjgsbVq1UqeeeYZ0QsL+svSpUv9m4Gfqampge3du3fLhg0bAvvBG8E5pnX+aZ0CRAeK6yp6xvR1110X8tTpp58esh/Ozs9//nM5cOBA4NTmzuYOVMAGAggggAACcRCIeGoOPQb9S7FNmzaBryvFYVw0iQACLRBwZtglq1WqpOe7JDPPJWk5LnG4UtTDLnanTVIcKeLz+MRT4ROvWiLdXeaV0kPlUlpcIaUlFXLsQLk6rlatoSCAgOUEZs2aJS6Xy3L9psMIIIAAAghogddee01++9vfyllnnSU6eKsXE9QpLD7++OOQ96fBs5/9coWFhf5N4+cf/vAHoy6dB/qzzz6TP/7xj6KD0PPmzZOZM2fKK6+8Ypy3atUq6devn9xxxx2ig8wdO3aUb7/9Vl588UX53e9+FzIbev78+dKzZ8+QdoJ39EKLesFFnXpDFx0Q1+3puvxFX3/NNdf4d/mJAAIIIICAZQSiEojWv9T1L2a9CAQFAQTMKZDisElBUZa07Z2rHjnSuku25HXMkPyOmZKe28IglIpBH9lbJsU7S6V4+zHZv/mI7Fl3SPZ8UyIlO6u/lmhOGXqFQHIL8K2m5L7/jB4BBBBIFAEduNWPzMxM0TOit23bFjI0/X61ZtELGQaXhx9+2HhP63Q6payszHhqwIABxs9HHnnEWNh33759xv7evXvlkksuCb681vbQoUNFB7cbKrfeeqvoR/v27UW3u3Xr1lqnP/TQQ5KWllbrOAcQQAABBBAwu0BUAtF60PqNLIFos99++pdMAlkFLuk8tLV0HVYgXdTP9n3yJMUZlew8Imrl9Oy26cZDtxVcyo96ZMeXB2TLygOydeV+2fZ5sbhL1TLqFAQQiLuAnjE2ZcqUuPeDDiCAAAIIINBcgZoB2mPHjol+BJeioiK55ZZbgg8Z2zrIfOGFF8pf//rXwHMej0f0o2bRs5bfe+89ufTSS+WDDz6o+XSt/QsuuEAWLFgQ9reOdu3aVauOgoICeeCBB2TixIm1nuMAAggggAACVhCIWiB68uTJkp6eHvjk2AoY9BGBRBLQM567DGslvca0Mx565rMZSmqWQ7qf2tZ46P74VGoPHZRev3S3rH9/t+xdf8QM3aQPCCSlgJ4JlpeXl5RjZ9AIIIAAAokh8Oqrr4peHFDPZl69enXIoHTqqcsuu0xuvvlmI5VkyJMndh599FHRixHedtttUlJSEjhFf1irZ1HrFFb+0rdvXyMftQ4O6xnSOh908KKE+fn5MnjwYNF5q8844wz/ZQ3+1EFynQv68OHDgfN0qo/x48cbqUF0AJyCAAIIIICAVQVslapEq/N6VvSiRYuiVX1S19ulSxfZsmVLiw0efPBBI+dYiyuiAlMI2Owi3U9pI4OmdJJ+kzqq3M5OU/SrKZ3QqTxWv75NVv9nu+xeW/0HeFPq4FxzCUyfPl30m8KWFD2TKSsrqyVVcG0YAvfee69cffXVYZzJKQgggAACCJhf4MiRI7J582bZv3+/kbdZB3l1uotwis/nk02bNhkpPfT6R926dZOMjIwGL/V6vbJ+/XojF3WvXr2M9BoNXqCefOedd0JmOOvZ1aeeeqpRz549e6R///6ic1RTEEAAAQQQSASBqM2I1jhz5swhEJ0IrxLGYHqBwh7ZcvI53WTIzC6SkV+92rfpO15HB/M7ZcrYS/oaj/2bjshn/94kK1/aIqUH3XWczSEEEIikQF35MiNZP3UhgAACCCAQS4Hs7Gwjj3Nz2tTrHukFA/2LBoZTh91uFz1LWj9aUmw2m/Tu3dt4tKQerkUAAQQQQMBsAlENROs3tPqXaBQnXZvNk/4gEDMBnXpj4NSOMvK8HtL5pMScJVFQlC1n/nSwTPrxQFn7zk5Z/uwG2fzxgZgZ0xACySSgv4asZ3tREEAAAQQQQAABBBBAAAEEEIiGQFQD0Tp/1SmnnCIfffRRNPpOnQgkpYAr0yEjvtdNTvlBL8lRCwImQ9GLKvY/s5Px2PlVsXzw+Dr56s0dUskah8lw+xljjAT0t5goCCCAAAIIIIAAAggggAACCERLIKqBaN1pnSeaQHS0bh/1JpOADkCPvqinjL6wt+gF/5K1dBiQL+feNUombTsm7zzwtXzxyjap9CWrBuNGIHIC+vc1BQEEEEAAAQQQQAABBBBAAIFoCaREq2J/vcyw8kvwE4HmCTjSUmTsZb3lJ29MlQlX9k/qIHSwYH7nTPnO7SPk6pcmGylKgp9jGwEEmibQoUMHGTp0aNMu4mwEEEAAAQQQQAABBBBAAAEEmiAQ9UB0v379mrTAQxP6zqkIJLzAoOmdZP4rU2TS/IGSnutK+PE2Z4A6j7SeIX3pM+Olw6C85lTBNQgkvcBZZ51lrOmQ9BAAIIAAAggggAACCCCAAAIIRE0gJt/v17OiFyxYELVBUDECiSbQrm+OzLxxaMIuQhiN+9V5SCu54m8TZdWiLfL6XV9I6UF3NJqhTgQSUoBvLyXkbWVQCCCAAAIWEGjdurWMHDky0NNWrVoFttlAAAEEEEAg0QQIRCfaHWU8lhZwpNpk/JX95LSL+kiKw2bpscSl84rspNldpc+49rL4zs9l1Uvb4tINGkXASgKZmZly+umnW6nL9BUBBBBAAIGEERg8eLAsX748YcbDQBBAAAEEEGhIIOqpOXTjp512muhPeikIIFC/QJdhreSqf0+WsZf0JQhdP1NYz6TnueTs342QixaeJjnt0sK6hpMQSFaB6dOnS2pqarIOn3EjgAACCCCAAAIIIIAAAgjESCAmgWi73S4zZsyI0ZBoBgFrCdjsIhOv6SdznzhdWnXNslbnTd7b7qe2NYL7A6d2NHlP6R4C8RMgLUf87GkZAQQQQAABBBBAAAEEEEgmgZgEojXo7Nmzk8mVsSIQlkBex3S59OnxcvoV/cSWQiqOsNCaeFJajtNYzPDs208WZ4aK+lMQQCAg4HA4ZOrUqYF9NhBAAAEEEEAAAQQQQAABBBCIlkDMAtFTpkzhq7/RuovUa0mBXmPbyLx/TZJOg1iQJBY3UOeOvuLZCdK6W2YsmqMNBCwhMHbsWFJnWeJO0UkEEEAAAQQQQAABBBBAwPoCMQtEZ2VlycSJE60vxggQiIDA+Hl95Af3jxE9W5cSO4HCHjlyxd/PkL4T28WuUVpCwMQCfFvJxDeHriGAAAIIIIAAAggggAACCSYQs0C0diMPZYK9ehhOkwUcLpt8748jZcJVA0TIxNFkv0hckJrlkPPvHi1jLukVieqoAwFLC7B+g6VvH51HAAEEEEAAAQQQQAABBCwlENNA9MyZM8VmI/pmqVcInY2YQHqeUy5+bJwMmNIpYnVSUTMF1D9Dk68bJLNuOUn0YpEUBJJRYODAgdKrFx/IJOO9Z8wIIIAAAggggAACCCCAQDwEYhqI7tixo5x88snxGCdtIhBXgbwOaXL53yZI55Nax7UfNB4qMPzc7nLBX0aLI5UPyEJl2EsGAdJyJMNdZowIIIAAAggggAACCCCAgHkEYhqI1sMmPYd5bj49iY1Aq66ZcslfJ0irLlmxaZBWmiTQa2w7+d+Hxogzg6nRTYLjZMsL8PvY8reQASCAAAIIIIAAAggggAAClhKIeSCaGViWen3Q2RYKtOmVLZc8OV5y2qW3sCYuj6ZAt+GFcvGjYyUt2xHNZqgbAdMItG3bVoYPH26a/tARBBBAAAEEEEAAAQQQQACBxBeIeSB68ODB0rVr18SXZYRJL9C6W6b88NFxklWQmvQWVgDoNKiVXLhwjLiYGW2F20UfWyigZ0OnpMT8T4AW9prLEUAAAQQQQAABBBBAAAEErCwQl3ehfB3Yyi8Z+h6OQF7HdDXDdpxktCIIHY6XWc7pOLCV/OCB08SRFpd/Gs3CQD+SQIBvJyXBTWaICCCAAAIIIIAAAggggIDJBOISbSEQbbJXAd2JqEBWgcsIQue0JR1HRGFjVFnXkwvk/LtPlRQHCxjGiJxmYiyQmZkpEydOjHGrNIcAAggggAACCCCAAAIIIJDsAnEJRI8dO1Zyc3OT3Z7xJ6CAMz1FLrj/NMnvlJmAo0ueIfU8ra3Mvnlo8gyYkSaVwJlnninp6XxQllQ3ncEigAACCCCAAAIIIIAAAiYQiEsg2ul0yvTp000wfLqAQOQEbOq/pnPvHCUd+udHrlJqipvA0O90k3FX9Ilb+zSMQLQE+FZStGSpFwEEEEAAAQQQQAABBBBAoCGBuASidYd4I9zQbeE5KwpMuX6Q9Bnf3opdp8/1CJxxzQDpP6VDPc9yGAHrCegFCqdNm2a9jtNjBBBAAAEEEEAAAQQQQAABywvELRA9depU0TOjKQgkgsDAqR3l1At7JcJQGEMNgbN/M1wKe2TXOMouAtYUGD16tLRp08aanafXCCCAAAIIIIAAAggggAAClhaIWyBa54geP368pfHoPAJaoLBntsy57WQwElTAleGQ8/58irgy7Ak6QoaVTAJ8GymZ7jZjRQABBBBAAAEEEEAAAQTMJRC3QLRmmD17trk06A0CTRRwpKXIeX/SQUpHE6/kdCsJFBRly1m/4cMGK90z+lq3wMyZM+t+gqMIIIAAAggggAACCCCAAAIIRFkgroHoWbNmRXl4VI9AdAWm/Xyw6CAlJfEFBkzpJCed1SXxB8oIE1agb9++oh8UBBBAAAEEEEAAAQQQQAABBOIhENdAdNeuXeWkk06Kx7hpE4EWC/SZ0E6Gf697i+uhAusIzPjVSZLfOcM6HaanCAQJ8C2kIAw2EUAAAQQQQAABBBBAAAEEYi4Q10C0Hi1vjGN+z2kwAgLpeU4561ZSNUSA0lJVuDId8p3bR4jYLNVtOouAIUB+aF4ICCCAAAIIIIAAAggggAAC8RSIeyCaN8bxvP203VyBqSolR0ar1OZeznUWFugytLWM+H6RhUdA15NRoHXr1jJq1KhkHDpjRgABBBBAAAEEEEAAAQQQMIlA3APRw4YNk06dOpmEg24g0LhA99GFctLsro2fyBkJKzD52kGS0zYtYcfHwBJPQH/7yG63J97AGBECCCCAAAIIIIAAAggggIBlBOIeiNZSpOewzOsl6Ttqd9pk9k3Dkt4h2QFSsxwy/Qby2yf768BK4+fbR1a6W/QVAQQQQAABBBBAAAEEEEhMAQLRiXlfGVWUBE69sKdarC4zSrVTrZUE+p3RQYpGFVipy/Q1SQVSU1Nl0qRJSTp6ho0AAggggAACCCCAAAIIIGAWAVMEoidMmCDZ2dlmMaEfCNQpkFngktMv71fncxxMToHpvxwiNlP8K5qc/ow6PIEzzzxTMjP5AC08Lc5CAAEEEEAAAQQQQAABBBCIloApQigul0umTp0arTFSLwIREZh0zQBxZToiUheVJIZAm165cvJ3yReeGHczcUdB+qvEvbeMDAEEEEAAAQQQQAABBBCwkoApAtEajPyVVnrZJF9f8ztnyElzuiXfwBlxowKnX9FfdO5wCgJmFLDZbDJ9+nQzdo0+IYAAAggggAACCCCAAAIIJJmAaQLR06ZNE7vdnmT8DNcqAhOu7C8pDoKNVrlfsexnTrt0GfH9olg2SVsIhC0watQo6dChQ9jncyICCCCAAAIIIIAAAggggAAC0RIwTSC6VatWMnbs2GiNk3oRaLZA626ZMnhG52Zfz4WJLzD20n7iSOWDisS/09YbId82st49o8cIIIAAAggggAACCCCAQKIKmCYQrYF5w5yoLzNrj2vMD3urBekIMlr7Lka391kFqSp1C7mio6tM7c0RID90c9S4BgEEEEAAAQQQQAABBBBAIBoCpgpEz5o1KxpjpE4Emi2QWeCSIbMIMDYbMIkuHH1hbxE+r0iiO27+oRYVFUn//v3N31F6iAACCCCAAAIIIIAAAgggkBQCpgpE9+jRQwYOHJgU8AzSGgKjzu8hdpep/jOxBlwS9rJ1tyzpO7F9Eo6cIZtV4OyzzzZr1+gXAggggAACCCCAAAIIIIBAEgqYLsLG14iT8FVo0iHbnTYZ8b3uJu0d3TKjwCn/08OM3aJPSSrA79MkvfEMGwEEEEAAAQQQQAABBBAwqYDpAtHkiTbpKyUJu9VHzW7NyE9NwpEz5OYKFI1sI/mdM5p7OdchEDGBvLw8Oe200yJWHxUhgAACCCCAAAIIIIAAAggg0FIB0wWiR4wYIe3atWvpuLgegRYLjDinqMV1UEGSCagc0Sef0y3JBs1wzSig11xwOBxm7Bp9QgABBBBAAAEEEEAAAQQQSFIB0wWibTab8HXiJH01mmjYeR3SpPspbU3UI7piFYGhc4rEZrp/Wa2iRz8jJcC3iyIlST0IIIAAAggggAACCCCAAAKREjBluIRAdKRuL/U0V2DA1M4ianYrBYGmCmQVpErRqIKmXsb5CERMwOVyyeTJkyNWHxUhgAACCCCAAAIIIIAAAgggEAkBUwaizzjjDMnIIM9qJG4wdTRPYODUTs27kKsQUAIDp6gPMigIxElg4sSJkpOTE6fWaRYBBBBAAAEEEEAAAQQQQACBugVMGYhOS0uTKVOm1N1jjiIQZQG92FyH/vlRboXqE1mg/6SOkuJgSn0i32Mzj420HGa+O/QNAQQQQAABBBBAAAEEEEheAVMGovXtID1H8r4o4z3y/pM6xLsLtG9xgfQ8l3Q9ubXFR0H3rSowY8YMq3adfiOAAAIIIIAAAggggAACCCSwgGkD0fqNdEqKabuXwC8JhtZzTDsQEGixQK+xvI5ajEgFTRYYPny4dO5Mapgmw3EBAggggAACCCCAAAIIIIBA1AVMG+ktLCyU0aNHRx2ABhAIFnBm2KXrUBaaCzZhu3kCvca0bd6FXIVACwT4NlEL8LgUAQQQQAABBBBAAAEEEEAgqgKmDUTrUZPnMqr3nsrrEOg+qlDsLlP/Z1FHrzlkRoE2PXMlp22aGbtGnxJYgN+bCXxzGRoCCCCAAAIIIIAAAgggYHEBU0fcZs2aZXFeum81ga4nMxvaavfMzP3tOpzXk5nvT6L1TafkGDx4cKINi/EggAACCCCAAAIIIIAAAggkiICpA9F9+vQR/aAgECuBLqTliBV1UrTTdRgLFibFjTbJIM8++2yT9IRuIIAAAggggAACCCCAAAIIIFBbwNSBaN1dvmZc+6ZxJDoCDpdNOvTLi07l1JqUAnywkZS3PW6DJj903OhpGAEEEEAAAQQQQAABBBBAIAwB0weieWMdxl3klIgItO+fR37oiEhSiV+gTc8c0QtgUhCItkBOTo6MGzcu2s1QPwIIIIAAAggggAACCCCAAALNFjB9IPrUU0+VwsLCZg+QCxEIV6Bt79xwT+U8BMISsKXYpE3P7LDO5SQEWiIwY8YMcTqdLamCaxFAAAEEEEAAAQQQQAABBBCIqoDpA9EpKSkyc+bMqCJQOQJaoF0fAtG8EiIv0I4POCKPSo21BPj2UC0SDiCAAAIIIIAAAggggAACCJhMwGGy/tTZHZ0n+vHHH6/zOQ4iECmBtr3jmx/aJjbplN5L2qR1kWxna8lxFojbVy42m00OV+yXQx71qNgnO8q+FW+lp85h98k5WTLt9Y/DJz5Vx145WLFLDruLpVL9r6HSWH31Xav7ueHYF4GnI1FPtiNfemUPC9Spe/5lyXviqXQHjjW20SWjjxSkdgqcVqF8Vx9aGtiPxkbbPvp+bIlG1dSJgCHgcDhk6tSpaCCAAAIIIIAAAggggAACCCBgagFLBKInT54saWlpcvz4cVNj0jlrCxQWxSeFQq4KOg/LnyyD8yZIrgo+N1aO+0pl7eGP5KuSpbK59OuQoPTUtpdJriu8VDYlKiD9xp7HVF0f19tkU+oLrmRn2QbZsPHngUORqKdb1kCZ2eHKQJ16o0fmEHl++58aDaj7Lzqt4DsqmD3cv2v8jHYgurB7fF5XIYNkJ6EFxo8fL3l59X8AldCDZ3AIIIAAAggggAACCCCAAAKWEbBEIDojI0N0MHrRokWWgaWj1hLQC8ql57li3umh+WfIlHaXiCslNey201Iy5KS8M4zHqpK35eUd94V9bfCJea428r3Ov5Q1h5fJc9vuCjuYG1xHvLf7556mZnfvluRqEv4AAEAASURBVLf3/i3eXam3/fQ2A2T0n54Q9+G9UnF4n7iP7DN+GtsnjuntCrXtVj99nvJ66+IJBOoS0N8aoiCAAAIIIIAAAggggAACCCBgdgFLBKI1os5/SSDa7C8n6/Yvv2NGTDtvtzlUEPhntWbnNrUTKdLyNO/9ck6RUwtmyYf7X25q86Y4f0zhd+VAxQ75vOS/puhPzU648tpJWutOxqPmc3Xte8tLpaJktxGYrgpWVwWpA8HqI/urAto6cH1MpVfxhp+apK72OGZ9Ab1QIQUBBBBAAAEEEEAAAQQQQAABswtYJhCtFyzUuXIrKxvOaWt2cPpnToH8Tpkx7diMDpc3GITefXyj7C/fIWXeo5LpyJVWrnaS72ovqSnpTe7nSzvuMa4pcHVSbZ6sclB3rVXHxDY/kJXFb6n2jtV6ruaB13c/WvNQrf0S955ax2oeiFQ9ul6dsqO4Yo9sLV1bs5m473t8OU3qgz01Q9Lbdjce4VzoDgSmTwSs1b5/9nXNWdee0kOqSv4NDcfVKucMGTJEioqKrNJd+okAAggggAACCCCAAAIIIJDEApYJRLdr105GjRoly5YtS+LbxdCjJZBdEH5qjJb2YWSraUZajZr16A9Zlh14WT4tfl2lm6g7kFuQ2kFdO9G4PsPReICz1HM4ZKbwW3ufkcLUjnJJ9z+odCBpgS6k2OzSVgWoNx/7OnCsrg1d3/IDr9X1VJOORaoef6N6hvn3u9wgj6m81AdUqg4zlQpPblS748wuEP2Qjv0abafS55WKQ3uMFCD+GdY1Z10Hpw7xVZQ2WicnxFeAtBzx9ad1BBBAAAEEEEAAAQQQQACB8AUsE4jWQ9LpOQhEh39zOTN8gfT86qBs+Fc1/Uwd/B3f9n9qXVjmPSL/2HqHmtH7Ta3ngg/sL98pS/Y8LW/veVZ65pwkxz2Nz2AOvl5v71MzrT8veUdGqIB4cGmbVtRoIDr4fLNtp9sz5fwuN8qjm34R1szuWPXf42n8A4NY9cWWYpfU/A7GI5w2fRXHVeC6Ok1IddC6Ol2Izmtt5Lc+elClCakIp1rOiaCA/r1IQQABBBBAAAEEEEAAAQQQQMAKApYKROuZXzfccIMVXOmjxQQyY7RQ4aDcsaIXGwwueib0c9vubDQIHXyNT7yy7vCnwYeatO311c4rHIl8003qRBRObpXaXr7X5Zfy9OZbxVvpiUILTa+ywh3dGdFN71H4V6S40iStsJvxCOcqtwpGV6UKqVp40T/r2tO5jby3xSd56vOevDSb8TPLZZMUWzi1ck59Ah06dJBhw4bV9zTHEUAAAQQQQAABBBBAAAEEEDCVgKUC0f3795cePXrIhg0bTIVIZ6wvkJ7riskghreaWqudT4oXy6ZjX9U6Hq0DeubwgNwxtaovDiOvc62L4nxgS+lX0jVjQEgvumb0VzmjfyQv7fhLyPF47VR4suPVdMzbdWa1Ev3IaN87pG39kcCt74V++KFj0PqLCFWB6argdL4KUueqR/VxfY5+joh1COiJHf3hrF47gYIAAggggAACCCCAAAIIIICAFQQsFYjWoPqN94IFC6xgSx8tJOBKt0e9t3rGcWFq51rtfHJwca1jkTrgTEmVLLXYoS7p9ixjocLxhedLtrNVSBMeX7lsbSQ/tL5A56UenDcu5Nq6djYe/VyOevTCeHWXSNXz0f4XZU/WJhnZamZIQ0PyJsgBlcZk6f5/hxyPx47bRKk54jH++trUSyYePK4feqvxBRSdKQ4ZvWCdSgOyryrH9ZHQWdeB4/r5owfE51aVJ3ghP3SC32CGhwACCCCAAAIIIIAAAggkmIDlAtE6HyaB6AR7FZpgOCnOlKj3IsuZp1IRhAa8j7gPqpzN26PWtg5E/6TPY43Wv+zAK1LqPdroefqEszrOb/S8F3b8Wb4seb/B8yJVzxu7npRWzo7SM3toSHsT214gB9075etDy0KOx3rHHeXFCmM9nni15/aJpBV0MR7h9MFTeuhE0Hqv8bMqUK22j+yvymlt5Lb257cuVrFwbzjVmuacrKwsGT9+vGn6Q0cQQAABBBBAAAEEEEAAAQQQaEzAcoHoMWPGSKtWreTgwYONjY3nEQhbwOEKDRCHfWETTsxxhM5C1pcecu9rsIbC1I4ysc0F9Z6j8yC/uONe8VSGpj2o94IaT+jrl+x5SlYceLXGM9bZ9YlPnt9+l8zt/vtaM87P7nitHKr4tewoi186nwp3jnUwE6injoxc0Q9p17PxUak87e4jOiitH8GB6hpBbD3bWgWyPWX1z/ZvvLHInDFt2jRJTU2NTGXUggACCCCAAAIIIIAAAggggEAMBCwXiLbb7TJjxgx56qmnYsBDE8kiYI/BjGhPHYvnpal0GQ2VfFdb6ZMzqqFT5LVdD4vH27xA9OJdj8inxW82WL8Vniz3HZdnt/xWLu1+p5E+xN9nu80p53e5URZuvF4F/Q/4D8fsp8ebKr5KgoUxA29uQyrPsjOnjfHIDKOOSo9bBaz3nAhc61Qh1QFrY+a1Cmq7jaB21fFopAnR3w6iIIAAAggggAACCCCAAAIIIGAlAcsFojWufgNOINpKLzPz97XSq773H+Vy2L2/VgutXO3FoYKlzZ3RXKvCOg5sLV0jbVJVSgO1SGHNMrX9JVLmO9Kk9BVvqRnUjZVtx9Y0dopEqh5/QyXK9+9bfycXFf1O7Lbqf9p0Pur/6XqTPLbxV/5TY/aT/NAxo45pQzaHU1JbdTIe4TTsLT8mFSU6cK3yWhupQU6kBAkKVvtTh7iPHpRKn17esf6iP5DVM6IpCCAQOYFVu33y0XafXDTEIRnOyNVLTQgggAACCCCAAAIIIFAtUB2tqT5m+q0pU6aIy+WSiooK0/eVDlpDwONufLG0lo5E52CuUIsCulTeZn9JsaVI+7Qi2Va2zn8o5GdlGIu4hVxQY6fUc1ie2HSjWiYxRbpm9pdzO/88JCCtZwyf1WG+7CnbIgcqdtW4uvauru8DtUBgS0uk6qnZj+1l38pLKlXJdzpdF/KUXiTynM7XhxyLxY6HhQpjwWz6NuypmZLetrvxaLSzOk2ICkZXpQnRqUCqZlVXz7reLwN6dJRSlerHVV4pWS6bqAndFAQQaKHA/tJKeW6NV97d7JWrRjhlXNforx3Rwi5zOQIIIIAAAggggAAClhOwZCA6OztbJk6cKIsXL7YcOB02p4BXr4QWg7Ll2GrplX1ySEvTOlwuj278peh8zTXLhiNfyAPf/jhweI5aKLBDeo/AfrgbOo/yJtX2M1tulQu7/Ub0Iob+4khxycyO8+TJTTf7D1n65+pDS6VA5dYeV/i9kHH0yDopZD8WOyxUGAvlBGtDpwnJbm08Mjv2rXdwF79c9UGsXQWh89JE8tNs6qd+6P3q7arj1cfSLPlbv14GnkAgYgIlx6uq2l8mcut7bhnePkV+PNIhHXP4pCdiyFSEAAIIIIAAAgggkPQCln1LOmfOHALRSf/yjRyAp9wbucoaqGnZgUW1AtHt1IzoCW3OU4sGPl3rSp94ZV/5jsDxY57iwHZzNvSifYt3PyqzOlwZcnnXjAEqF/XJ8s3hT0OOW3Xnv3v/KQWujtI/97S4DqHckx3X9mk88QW86sscB1Tg7ECZ/lZH49/sSFXrstYMTucHgtfVAWsd0M5NVUFxdT4FgWQQKDke+t/PJ7t8csmiCrlgkF3OG+Dgv4VkeBEwRgQQQAABBBBAAIGoC1g2ED1r1iyZN29e1IFoIDkEjh+JTZqXTce+VIHl7VKY2ikEdnTB2ZLpyFPB6KfkmOdQyHOR3llV/LYMy58sHdN7hVR9RpuLZP3hlWrudGxmh4c0HuEdndLkRZWiI8/VrlkzyCPVHbc7N1JVUQ8CERHQn7ntPlapHrq60MBbXQ1ku/zB6aoAtg5O+2dd56dXbfsD2zpNSAqTR+ti5JgFBIpPzIgO7qr+stQTn3vlzY0+Y3b08A6k6wj2YRsBBBBAAAEEEEAAgaYKWDYQ3bFjRxk+fLh88sknTR0z5yNQS+BYcWwC0brhF7YvkLlFd4gjKD2GPj4kb4L0yzlVPtz/guw8/q0cKN8ph90HxWlzGakmemePUMHj3vrUFhUdpH1916Myt/vvQ+rR6SwG5o2RL0reCzlu1R29AKRevPDS7ndKjrN1XIbBYoVxYafRCAroz+iOVFTKtsO60oYD1zoInauy/ujUIP7gtD9NSF2zrlkQLoI3iqpaLFBzRnRwhTuOVMov3nLLeJU3et5whxRk8IlLsA/bCCCAAAIIIIAAAgiEK2DZQLQe4OzZswlEh3unOa9BgbKS8gafj+STu49vkRd33iPndPpZrWpdKWkyvs35tY5H+sD2svUqDccKlY5jZEjV4wvPl68OfVhnvmp9YoYjR+b3fijkmrp2PL4Kldt6fr2zqyNVT11tBx87qmaXP7v1tyrw//uQvNjB50Rzm0B0NHWp22wCPhWn1rNKi1WKg02NBK11351qcqk/YG38TK9KB+I/FhzQzlXBbRdpQsx2yxOqPw0Fov0DfXeLT1bsqJCLT3LIWX3sYmeCtJ+GnwgggAACCCCAAAIIhCVg+UD0zTcnxgJrYd0tToqawLGDsZsRrQfx9aFl8pzcKTPaXynp9syojauhit/e+7TKVz1cfZW++p10nquNSttxhnx88PV6L811FtT7XPATNl1vZf1pPiJVT3CbdW3vOb5Vnt/xR/l+p1+JTS0EF8tSQWqOWHLTlsUEdNqDvaWV6qE73vBsa31GprM6TUhwkLpq1nVo6pAclUKEIKFWo4QrcCjMz6NL1brC93/ikdc3eOXaUQ7pX1j9OzTctjgPAQQQQAABBBBAAIFkFbB0IHrIkCHStWtX2bJlS7LeP8YdIYGSnUbC1AjVFl41Ohi99dgaY+FAHRBuSvGqtBOfl7wryw68LKXeo025NHCuXgRxVclbRr7owEG1Mb7NBbL60AdS1sx6g+syy/Y6tQjjkj1PyuR2F8e0S24WK4ypN40ltsAxt8gxd6XsOKLH2XDgWn/k5E8TEhKoVoswVs24rs51rZ/PUrmwKcktoGfyN6VsKK6UHy92y/Sedrl0mF30hx8UBBBAAAEEEEAAAQQQaFjA0oFoPTSdnuPee+9teJQ8i0AjAiU7Yh+I1l2qSh1xh+SrmcgDc8fKoNzTpbWrQ62Zuz41s/iQe58UV+ySLaVr5DM1Y/mY14jGhIysojJ0Sle5ryzk+Zo77+x9VgbkjpHUFPWd+BNFz9DukzNcVhW/KzXr85/T2E+3r1wqK6vf1EeiHl1nzVLXsZrn+Pc/OrBICtM6y0l5Z/gPSYWvjtWpAs+2fGNo3xvlyIF0efjCL8SZXSCunEL1aGP8dJ746T/mzCkQe2p8Zse3fKTUgIC5BPS/PjrjUkm52jpU/W9Rfb10qBhi/onUIFWzrf2zr08syKgWZtQBbH9wO9Xyfz3VJ5Gcx4+rWc760dSiX1mvfuuVpdu8cvkwh0zpYVe/v5taC+cjgAACCCCAAAIIIJA8AjYVLGr8HZqJPd566y2ZNGmSiXsYna516dIlIjPBH3zwQZk3b150OmmxWm/+7Cyxu+L/FdsUsUumysWc7cwXh1qo8LB7v3oUq3zLXouJ0l0tsPPrYnnoe++EhZHiSBVXXrtAwNoZHLg2Atn+IHahOLNaS4pTrQxHQQCBmAukqUC0DkxXL8IYPMM6dNZ1LmlCYn5/mtrg7qOVcsELLU/RNbDQJvNHOaV7PtHopt4DzkcAAQQQQAABBBBIDgHLz+kZN26c5ObmyqFDh5LjjjHKqAkUbz8mBd2zo1Z/uBXrgPMRT7HxCPcazjOvQPG28Gfb+zzlcnz/FuMRzogcGXnGDOuqgLWebV318M+2dmZXBa71cUdmvthS4v9BSzjj4hwEzC6gZ8/uUsHLXUZmpIY/z9chyWyV+sOfIqTqZ+0gtjHjWqUOyXbZmFUb4xdAOAsVhtOl1fsq5UevVsh3+9nlwsEOSVd5zSkIIIAAAggggAACCCBQLWD5QLTT6ZTp06fLs88+Wz0qthBohsCe9YdMEYhuRte5xMQCu9dF70MyT2mJ6IfsXte4gFo80qVmVfuD1NUpQarShdRMHWJPj/+HMo0PijMQML+ADlMfVpNtD1dUytbDur8NB67tKnKdpwLSdQWsdWqQqhzX1c8T7Gz5a6AkglmavOr2/vNrr7yz2StXjXDK2C58ANjyO0QNCCCAAAIIIIAAAokiYPlAtL4ROk80gehEeUnGbxw6YDhgSqf4dYCWE1Jgr/qAwxRF5RmvOLzXeIQzR9tmd0lqXtvqGdc1gtg1A9o2B6u9meI+0wnLC+hA5gGV3v9AmQ5YNxy01oNNtdcMTlcHqWumDtFpQpzqfEqoQFMXKgy9uu69faUi/++/bhnZIUV+PNIh7bNJ11G3FEcRQAABBBBAAAEEkkkgIQLR06ZNEz0z2u12J9O9Y6wRFtgTxZmrEe4q1VlIYPc3JglEN9Gs0lshxw9sMx7hXGpPzRJXrg5cq/zVNRZi7NJnsAwZNU7019/147BaRE4H2ygIINBygXK1fMDuY5Xqoetq/D+sLJUuwp8mpGp2dWh+a/2cf9Z1tgpcpyRB/DSSM6Jr3tEVO30y9+UKuWCQXb4/wMEHATWB2EcAAQQQQAABBBBIKoGECETrHNGnn366LFmyJKluHoONrMCO1QcjWyG1Jb1A2aEKKdmhpjYmQfGWH5WyvfqxodZoe6r0SXfdeEbguF4i91C5DkqLEZjWsxEPBbarjumAdfGJY6XqM8bGw2uB6tlAAIEGBI6q/56Ouitl+xF9UsP/ZekgtE4H4g9O56qUIf4gdV2pQzIsmhM5Ujmi62Ov8Ik8/rlX3tzoU4sZOmRYe9J11GfFcQQQQAABBBBAAIHEFkiIQLS+RTo9B4HoxH6xRnt0R/dViF6wML9TZrSbov4kEdj2OR9u1HWrbUYO3KpZmCKNT7f0qiDOjoPHZODwMWq2tX9RxqqFGI19tSijM6fASCOiZ2SnuNLrapZjCCDQRAGfilPrD4T0h0WbGgla66qdKr5aFbSunnXtD2IH573W2zqgbZY0IdEORPvZtx+plJ8tccuEbiky72SHtM5o/N8//7X8RAABBBBAAAEEEEAgEQQSKhD94x//OBHuCWOIo8DWlQcIRMfRP9Ga3rpyf6INKS7jsavgVmsVWz6yZVVY7ae4MiRVpQmpClqfCFhnVwWwg48ZaUSyWovNYdFpnGFpcBICsRNwqw+N9pVWqodus+HZ1vqMzKA0IcYMa5UKpDpg7Z99XXUsRz2n/y2IRolmao66+vvOZp+s2FEhFw9xyJw+9qiNq662OdawwHXXXSfl5Sp/lCoXXHCBnHbaaQ1fwLMIIIAAAggggAACTRJImEB0165dZciQIfL55583CYCTEQgW0IHDIbO6BB9iG4FmC+gPNiixF/BVlErZvk3GI5zWnVmtxHkiUO1S+a3rnnWtc1+rR2a+msTNLMZwXDkHgcYEjqk0IcdUmpAdYaQJ0f/V5QSlCakvYO1PGZLVhPVTYzUjOthDj/2+Tzzy+gavXKvSdfQrjFKUPbhRtg2B0tJSycjIqFPjnnvuEZ9PfaKiSr9+/QhE16nEQQQQQAABBBBAoPkCCROI1gRz5swhEN381wJXKoENH+3FAYGICFSUemQ7qTkiYhntStxHD4p+lO76pvGmbHZjQcbaAesCFaiumn2tZ1obz6vZ1vb07Mbr5AwEEGhUQM+vPqQmqur88lsONT7bWqcJ8ee39qcLyQ1aiLEqYF0161qnHolX+ba4Uq5Z7JYZvexy6VC76AUiKdETuPrqq2XhwoVSVFQk//rXv2TQoEHRa4yaEUAAAQQQQAABBGoJJFQgWueJvu2222oNkgMIhCtQvK1UDm45Kq26ZoV7CechUKfAphX7xKtm+lESTKDSKxWHdhuPcEaW4kwTl04Tkl2dw7pmENuZ3boqcK3OSXGqKZ8UBBBosYBOE7JfrRW7v0z/O2zuf4t1715Z75WlW71yhcodfWYPe4vHTwW1BdauXSv33Xef8cQ333wjd999tzzyyCO1T+QIAggggAACCCCAQNQEEioQPWzYMOnYsaPs2LEjamBUnPgC6z/YLaO69kz8gTLCqAqsX7o7qvVTuTUEfO7jcnz/FuMRTo8dGXknZlwXypSzzpMLLrlSdNoAncPW/1PP3tTbh9XsUHOH18IZMecggIBfoET9N/1/H3rktW91ug6ndMtjdrTfJhI/8/LyxOl0itut8qKoUlhYGIlqqQMBBBBAAAEEEECgCQIJFYi2qbydelb0Aw880AQCTkUgVOCb/6pA9P8QiA5VYa+pAuvf29XUSzgfAfGUlhiP0t3r5bxTfyazetc/M9KnotCHVEC6WAWpq37WHbDWQWydzkDnpKUggID5Bb7cWylXvFIh5/S3yw8GOSSd9VQjctPatWsnDz/8sPz5z3+WoUOHyrXXXhuReqkEAQQQQAABBBBAIHyBhApE62ETiA7/5nNm3QKblu+TspIKSc9rwkpHdVfF0SQV2PlVsZTsVNE/CgLNFEhLS5PJkyc3eHWKmiyZn25TD31a4zMn3V5RQevgYHVVELtqpnX1cR3YPqwC1+XqfAoCCMRHwKM+aPr7V155e5NPrhrhkDFdWMwwEnfi4osvFv2gIIAAAggggAACCMRHIOEC0RMmTJDs7Gw5csRYgj0+qrRqaQGfevf39ZIdcvI5RZYeB52Pn8Dqxdvi1zgtJ4TApEmTJDMzM6JjcarJ1W0ybeqhq208cH2swp8ORAWpVcqA4IB1zYC2ThPiJU9IRO8XlSGgBfaWVsot/3XLKR1T5GoVkG6f3fh/u8ghgAACCCCAAAIIIGBWgYQLRKempsqUKVPkueeeM6s5/bKAwOrXtxGItsB9MmsXv3p9u1m7Rr8sIqC/3RPvkqm+FJLpsknHnMYDX5UqCK1nUes0IP4c1v681nWlDtFpQohbx/sO076VBJbt8MnK3RVygUrV8T2VskN/sGTm8sorrxgLA+pFAfft2yedOnWSXr16Gd9cPP/880M+aNNru1x33XWB4fz+97+X1q1by7333itvvfWWfPbZZzJ48GDRH9D94Ac/kB49egTOfeGFF2TRokXy5ptvSklJiZFy4zvf+Y7Mnz9fdMq+mkVfX1GhPmVT5fLLLzfqrHlOY/uV6h+8J554Qt577z1ZuXKlbNy40eiTXqtm2rRpcs455zRWBc8jgAACCCCAAAJJK2BTf0wl3HvBp59+Wv73f/83oW9qly5dZMuWLS0e44MPPijz5s1rcT0JV4F67/LTN6dJTjvjO+8JNzwGFD2BLZ/ul8cuei96DViw5unTp8urr77aop4fO3ZMsrKyWlSHVS7WwRMdmGnfvr1Vutzkfnp8/hnWVYFrf67r+mZdkyakycRckMACndWHQ/NHOmRoe3Om67jsssvkkUceqfcO5ObmyqeffhoIKK9atcoIIPsv0AFoncd5w4YN/kOBnzrP89KlS0X/HXzVVVfJwoULA88Fb+iA8IsvviguV2iaNbvdLj6f+gdIlXvuuUeuueaa4Muksed37dolF154oSxZsiTkuuCdiy66SO6//37JyMgIPsw2AggggAACCCCAgBJIuBnR+q7qoIf+Q9LrJcElr/JmCqiPZz57YZOMn9e/mRVwWbIKfPLcxmQdOuOOkMDIkSMTOgitmRwqflaQYVMPvVd71qI+GlyOe1TAukzPuA6edV0VzNYzsA8FpQ45pGZl6/y6FAQSVWDb4Uq5folbJnZLkXnDHdJK5Yo3S3n++ecbDELrfh46dKjBFHo1g8PBY9u9e7dMnDjRmGH94YcfBj8Vsv2f//zHWJjw6quvDjnekp2DBw+KnvWs+9BQefLJJ41zFi9e3NBpPIcAAggggAACCCSlQEIGolu1aiVjx46Vd999NylvKoOOjMCnz2+W06/oJza9IhgFgTAEyo+45es3doRxJqcgUL/AnDlz6n8ySZ9JU3+t6Ny44ebH9acJ8Qeu/TOtdZoQ/7Y/jchR9S194tZJ+sKy+LDf3uyT5TsqZO5JDpndxy5m+HOl5kzhW2+9Vb773e/K9u3bjfQZDz30kBw9erRR+REjRsjtt98uo0aNMr4hcuWVV8o777xjXLd161bRD130t/rOO+8848O7f/zjH3LLLbcEZjz/7ne/kyuuuEKcTqdxbkv/76abbgoJQuuA+K9//WspKioy0nPotj/44AOjmddff13eeOMNOfPMM1vaLNcjgAACCCCAAAIJJZCQgWh9h3R+TQLRCfVajflgDu8+Luvf3y29T0/cr8fHHDXBG1z58hbxqDy5FARaImCG/NAt6b8Zrs1JtUlOqkiX3MY/SPSqb+kfOpHfWgepgxdi9Aeug1OHlKnZ2RQEzCKg863f+7FHXt/glfmjHNK3IL7pOnQ+6OCi03ToNEMDBgww1nD55S9/aaTEaNu2bfBpIds6x7NOs5eeXpUerW/fvvLPf/5TOnToIG63GvCJomce6zQZ/nLjjTfK3r17jdzS+pieuazT2PXs2dN/SrN/fvXVV6KD6P6i/51+6aWX/LtGMHr8+PFG4FynHdHlhhtuIBAdEGIDAQQQQAABBBCoEkjoQPRPfvIT7jMCLRL44Ml1BKJbJJg8F1f6KmXZU98mz4AZaVQE9Mw6HbChxE7AruJ2OrVBKyPm1XjgukJl/dJpQoID1v6FGasC2dWzrnXKEHdVOtrYDYiWklJg3cFKufo/bpnV2y6XDHVIVmhq5JiZDBw4UHR6Dn/RC4jrgPHQoUONQwUFBXLbbbf5n67z509/+tNAENp/gr5u9OjR8t///tc4pIPLwUFo/3k//OEPA4FofWzz5s0RCUTrRRP9Kf90Hv8HHnjA32Tgp04LqGdNn3XWWcYxvZBheXm56IXUKQgggAACCCCAAAJVAgkbiNYraus383oGAwWB5gpsXnFAdq0pkfb98ppbBdclicDat3dK8fbSJBktw4yWgD+AEa36qbflAi67SNssm/EIpzad+iM4HUjNWdfBQWwduOY7FeGock5dAvq18/I6r7y/1StXnOyQyd3VizXGRafKWLBgQSAH9JdffmnMEp4/f77cfPPNkp2d3ewehbOAa7du3ULq37ZtW8h+c3fWrl0buFSv837HHXcE9oM39uzZE9jViyJu3LhR+vXrFzjGBgIIIIAAAgggkOwCCRuI1jdWf22OQHSyv8RbPv4PHl8n5/xhZMsrooaEFvjgiXUJPT4GFxsB0nLExjmWreiZqVkum3TKaXy2tfpiheg0IP7gtH/WtT91SNV+9fM6LQMFgZoCOqXM7z/wyOJvfUa6jnBS1NSso7n7OuWGzo2s/y3zp+nQ6TTuuusuee6554zZ0ePGjWtW9fn5+Y1el5OTE3JORYX6JCgC5Ztvvgmp5S9/+UvIfn073377LYHo+nA4jgACCCCAAAJJKZDQgWi94FN9MxaS8m4z6GYJrF68XcbP6ycFRc2fxdOshrnIMgIbl++VbauKLdNfOmpOAR1kGTNmjDk7R69iIqAXm8tXaULyw0wT4tZpQlTg+pAKPAYHqYO3q2ZjV83KriBNSEzuo1kaWbXHJ5ctqpBz+9vlB4Mdohf9jEU55ZRT5KOPPpKLLroosHifblenyZgwYYI89thjxnNN7YtOfRGvUlZWFmg6IyNDzj333MB+QxvhzOJu6HqeQwABBBBAAAEEEk0gRn+Sxodt5MiR0q5du5AVruPTE1q1skCleuP+zn1fy7l3jbLyMOh7FAXevpcUQFHkTZqqZ8yYIQ5HQv9aTpp7GauBOlVcrk2mTT10i43PuC5VM6j9aUL8CzEGB6r1TGx/EFunCdEztCnWFvCoe/jsV155e7NPrh7hkNGdY7OYoU6R9/7778vjjz8uv/jFL2T//v0GpE5Xcfnll0ufPn1EB6ytUvRCif7SqlUreeKJJ/y7/EQAAQQQQAABBBBogkBCv+PVi4nMmjVLFi5c2AQSTkWgtsDq13fI6Vcckja9cms/yZGkFli/dDezoZP6FRC5wetv8VAQiKZAhlMkw2mTDtmNB61VGlw5XH4iDciJn3qRxuDAdVXQWqUTUc/rXNjEraN595pfd4b6a39EhxQpzGj8vje/ldpX6r/D586dayzed/XVV8uzzz5rnKTTZdx9992WCkT36tUrMMDt27fLu+++K+PHjw8cYwMBBBBAAAEEEEAgPIGEDkRrAp2jjkB0eC8GzmpAQL27fuNPX8oP7udr8w0oJd1TlWq64JI/r066cTPgyAu4XC6ZMmVK5CumRgSaKaBiiJKbZlMPka5hzLb2qG8PBQep9Xb1rGv/c1WBbR3ALldpRSjRFejT2iYze9llQje7pKsPIWJRbrrpJjnzzDNl7Nixgeb0DOJnnnnGmCGtg7i6LF26NPC8FTbOO+88+f3vfx/o6sUXXyzLly8XnRO7rqKfu/322+Wvf/2r5OYyiaEuI44hgAACCCCAQHIKJHwgetKkSaJzuZWWlibnHWbUERNY/95e0bNfe41pF7E6qcjaAitf2Cy71x629iDovSkEJk6cKNnZ5KE3xc2gE80ScKiMDwVqxm1Bhr688Zm3xz0qDciJGdY6DYh/dnVVMDs4iF2VA/v/t3cvQFaV9wHA/7t3l8ey4KIg6BLAF44SRIKKEIoSJCJCtZg0j9qmmcZJ0o5pO9MxcdpqTU0zmcZmakxjtIkmxkd8RNv4TETjA6oIhKgBjRHBByqggMhzefSeVWDBe3nsnr17z72/M3Pk3O+c853/9/uOy90/3/lOMsWEZd8CvfIJ50lH5FoT0EcdvO9+2HeNB3bEvffeG5dffnnrKOiLLrooTj755NYph5566qlYvnz5zspqa0szRcjOC3ZwY+TIkTFlypS4//77W2taunRp60sIv/71r8ekSZMimbrjxRdfjEWLFrW+lPGuu+5qPW7TpvzNbSFAgAABAgQIENgpUPGJ6B49erSOzNjxhXBny20QaIfA/d/6bRx16oCorSv9L3ftCNcpnSiw6d0t8asrjYbuROKqqjp5esdCoJoEkhfnHZafIiRZ92dZu2N6kPxo6mQu67YJ62RqkFX5d8ntKFtbhdOEHN+vJs7Oj34+PT/6uVQvJdxbvyXfu5O1V69ekYyIfuWVV3Y7fNq0abt9zsKHW2+9NSZMmBALFixoDXfVqlVx4YUXZiF0MRIgQIAAAQIEykag4hPRiXTyC75EdNncc5kOZOVL6+KJG1+IcZ8blul2CL7jAg9/f2Gsfyv/5i8LgRQEkvcZWAgQKC7Qu3tN9O4e8aGD9p243pqfJiRJTrdNWO96EeOuhPXSNdtjXYZ/jPfuFnFGfvRzkoA+ou++XYrrprcnGQDSdlm3bl0ka9vliCOOiEsvvbRtUSa2k6dWkhHfY8eOjWRE9L6W5KXpyVOZFgIECBAgQIAAgV0CVZGITkZdJI8AJm/qthDoqMDM7y6M4yY1R99BvTpalfMzKrBs4ap44oY/ZDR6YZebwOjRo2PQoEHlFpZ4CGRWIJef9eHgnjX5NWlC8QTtPz/cErNfzd53ww/3f2/082lDctG9zL7J33PPPXHDDTfENddcE88+u/tTQ8lc+BdccEFccsklceihh+68v+rrd5/Aes/POw5sW952e8f+5M/kBYl1dXWxZUt+7pf8sudxyecd02XsuW/H8Xvbf9hhh7XOdX3FFVfEddddF++8s/v0XE1NTXHSSSdFMi3J5MmTW2PwHwIECBAgQIAAgV0CNdvzy66Plbs1fvz4mDVrVsU0cPDgwfs1GmNfDb766qvjy1/+8r4Os38PgSPH9Y/PXbPrRTx77PaxggW25Scq/cGnZ5ob+gD6eOrUqZEkJzqyJCPqGhsbO1JF2Z572WWXtSZmyjZAgRGoUIEL79scC1dm42twMvr540fm534elovB+zEqvBy6bO3atbFkyZJYuXJlNDc3RzISulDytxxibU8Mya9QybzXSfuSwS7Jd3MvJmyPpHMIECBAgACBahIos3EUnUd/zjnnVFQiuvOk1Lw/Aotnr4j5d7wUHznviP053DEVJPD4dc9LQldQf5ZDU5K/nywECJReIJmuo9yXEw6tzSefa2PC4FzU58o92t3jS6ayGDFixO6FFfQpGX09YMCA1rWCmqUpBAgQIECAAIFOFcjWK6s7QOFFUB3Ac2pBgXu/9XS8/fK7BfcprEyBZb9bFQ9/b1FlNk6rukQgGUE3cuTILrm2ixKodoHk5YbluByUnwv7k8fl4sfndIvvnFkfk/LzQGctCV2OrmIiQIAAAQIECBDoeoGqSUQfe+yxMWyYF8x1/S1XORG0rN8at311TiRTNVgqX6Blw9a4XX9XfkeXuIVGQ5cY3OUIvC+weWvE+vemES4Lk2Qm61EDa+Of/qgufnZe9/jSSXUxqE/x+a3LImhBECBAgAABAgQIEDhAgapJRCcufuE/wLvD4fsUWPbM6pj53d1fxrPPkxyQSYF7/u038daSdZmMXdDlK+BpnfLtG5FVtkC5jIbu2yPi08PfG/387cn1MXGo0c+VfedpHQECBAgQIECgugWqKhHtF/7qvtk7q/WP//CFWDRzWWdVr94yEEjmA//NnS+XQSRCqCSBPn36xGmnnVZJTdIWApkR6Mr5oZNxzqMPq41LJ9THLfnRzxd8pC6ajX7OzL0jUAIECBAgQIAAgfYLVM3LChOicePGRb9+/Vrfbt1+MmcS+KDAzy9+Kr74s49FvyN6f3CnkkwLvPbs23H35Qsy3QbBl6fA1KlTo76+vjyDExWBChfoihHRh/SMOPOoXEw9OheH9TbtRoXfYppHgAABAgQIECBQQKCqRkTX1ubfPD5tWgEGRQQ6JrA5P1/0zV+ZHRvfaelYRc4uK4G1KzbGLX/7RGxtMQ94WXVMhQTjKZ0K6UjNyKRAqRLRSbr5lMNr47LT6uPmGd3jr0bVSUJn8o4RNAECBAgQIECAQBoCVZWITsDME53GbaOOQgIrX1oXN//d7NjWsq3QbmUZE9icf4vVjX8zK955c2PGIhduFgTq6urirLPOykKoYiRQkQKrOvlHe7/86Oc/H5GLm2Z0i29Oqo/xg2sjV3Xfuivy1tEoAgQIECBAgACBDghU1dQcidPkyZOjR48esXFjJ/8G0oFOcWp2BZbMeSvuvGRunPfNU7LbCJHH9m3b47aLnozXF66hQaBTBJK5oZuamjqlbpUSILBvgc4YEV2bH/6cjH6edkwuTmmWeN53LziCAAECBAgQIECg2gSqLhHdq1evOOOMM+Luu++utr7W3hIJPP2LV6PxkB5x5j+cUKIrukyqAvlZOP73X+bH73/9ZqrVqoxAWwFP57TVsE2g9AJpJqL7N9Tk532ujbPycz/372Xu59L3pisSIECAAAECBAhkRaDqEtFJxyTzckpEZ+UWzWacs6//Q3RrqIuJf318NhtQxVHf960FMf/nS6tYQNNLITB9+vRSXMY1CBAoItDRqTly+XzzmPyo52nDcnFyfhR0MhraQoAAAQIECBAgQIDA3gWqMhGdJABqampi+3YvINv77WFvRwR+/V/PRX3PXIz//LEdqca5JRR48D+fjSd+uriEV3SpahQYOXJkDB06tBqbrs0EykagvSOiB+ZHPE89pjbOPCoX/fIjoS0ECBAgQIAAAQIECOy/QFUmogcOHBinnHJKPPnkk/sv5UgC7RD41RW/iy2btsXpXzquHWc7pZQCD3z76UhGslsIdLZA8lSOhQCBrhU4kER0XT7fPHZQbZydH/08+jCjn7u251ydAAECBAgQIEAgywJVmYhOOixJBEhEZ/nWzU7sD1+1KFo2bInJfz8iO0FXU6T5ByN+8a/zY+6tS6qp1drahQIS0V2I79IE3hdYvR/vrD68MRn9nIspR9VG355GP7t5CBAgQIAAAQIECHRUoLajFWT1fC+KymrPZTPux3/4Qv4FePNi2xbTwZRTD27dvC1uu+hJSehy6pQKj6W5uTlGjx5d4a3UPALlLbBuc0TLtsIx1ue/GZ8+pDb+/Yz6+Mm53eIzH85JQhemUkqAAAECBAgQIEDggAWqdkT08OHD48gjj4zFi80He8B3jRPaJTDv9qWx+vUN8akrTo3ujVX7v1677DrjpA2rN8dNX5kdL89/uzOqVyeBggI73lFQcKdCAgRKIlBoWo7m3jVxdn7085n50c9NPYx+LklHuAgBAgQIECBAgEDVCVTtiOikp42Krrr7vcsb/OKs5fHff/FwrFm2vstjqeYA3lryblzzZw9LQlfzTdBFbff3ThfBuyyBNgI7EtHJ6OePDa2NKya/N/r5U8NzktBtnGwSIECAAAECBAgQSFugqhPR5ulM+3ZS3/4ILP/92vj+n86Mxf/35v4c7piUBZ57aFlc/amH4u2l61KuWXUE9i7Q2NgYEydO3PtB9hIg0OkCtfkBz18aXRe3fqJb/OMf1ceJA6v663Cne7sAAQIECBAgQIAAgR0CVf3Ne/z48XHwwQfvsPAngZIJbFjdEj/54qx47IfPRZg2uiTu27dtjwev/F3c/JUnYvO6LSW5posQaCswZcqU6N69e9si2wQIdIHAcf1r45PH56JPd1NwdAG/SxIgQIAAAQIECFSxQFUnouvq6mLq1KlV3P2a3pUC2/MvSnrwOwvjx198LNau2NiVoVT8tVe/tj5+9JePxGPXPF/xbdXA8hXwFE759o3ICBAgQIAAAQIECBAgQKDzBao6EZ3wSgx0/k3mCnsXWDx7RXzvT34VyZQRlvQFnrnnlfjejAfNB50+rRoPQCCXy/mHzwPwcigBAgQIECBAgAABAgQIVJ5AXeU16cBalDwq3a1bt9i8efOBnehoAikKJFN1JFNGjDh7UEz92sho6Ovx/Y7yrl2+Me75xm9i0czXO1qV8wl0WCCZCuqQQw7pcD0qIECAAAECBAgQIECAAAECWRWo+hHRvXv39vKorN69FRj3M/e8Glf+8S/j6btfrsDWlahJ+Tm35962OK6c/ktJ6BKRu8y+BTx9s28jRxAgQIAAAQIECBAgQIBAZQtUfSI66d5zzjmnsntZ6zIlsGFVS9zxtblx3ecfiTeeX5Op2Ls62Feffjt+8NmH4heXLfBCwq7uDNffTUAiejcOHwgQIECAAAECBAgQIECgCgUkovOdPn369Crsek0ud4ElT70V3//EzHxSdV68u3JTuYfbpfGteX193P7VOXHtZ38dy55Z3aWxuDiBPQWOP/74OProo/cs9pkAAQIECBAgQIAAAQIECFSVQNXPEZ309qBBg2L06NExb968qup8jc2AQOs0E0vjt3e/Eqd85qgY//lh5o9u021rV2yMR699Lubd9lJsbcljWQiUoYCnbsqwU4REgAABAgQIECBAgAABAiUXkIh+nzx5bFoiuuT3nwvup0DLhm0x60cvxJxbFsep5x8dp3726GjsV70vNExGQM/+yQsx99bFsWWTBPR+3kYO6yIB03J0EbzLEiBAgAABAgQIECBAgEBZCZia4/3ukCgoq/tSMEUEWtZvjceueT7+Y/K98T+XzIsVi9cWObIyi5ctXBW3XzQnvjPl/njihhcloSuzmyuqVQMGDIgxY8ZUVJs0hgABAgQIECBAgAABAgQItEfAiOj31U488cQYPHhwvPzyy+1xdA6Bkgok01DM//nS1nXoKYfESecdGcdPbo5ct8r7t6XN67fEs/e9EnPveClee9r8zyW90VyswwLJOwhqamo6XI8KCBAgQIAAAQIECBAgQIBA1gUkotv0YDIq+qqrrmpTYpNA+QssmfNWJGvPby6IEWcNyq8fisGj+kVkOPe1bcv2eGnO8ngmn4B+9oHXIhkJbiGQRQFP22Sx18RMgAABAgQIECBAgAABAp0hIBHdRjV5oZREdBsQm5kS2LC6Jebc/FLr2vvQ7jH8481x7MTDY0g+KZ2FkdItG7bGS0+tiOceei0WPrgskvZYCGRZoKGhIc4444wsN0HsBAgQIECAAAECBAgQIEAgNQGJ6DaUp512Whx00EGxZs2aNqU2CWRPYO3yTfHETxe3rvUNuThyTP84etyAGDK6Xxx6dJ+oqe364dLbWrbFsudWx9J5K+MPs96IpXPfimTKEQuBShGYPHly9OzZs1Kaox0ECBAgQIAAAQIECBAgQKBDAhLRbfjq6+vjrLPOiltuuaVNqU0C2RZIprV4/uE3WtekJd161cWHTjw4mj/cNwYOOygG5NdDhjR2anJ66+ZtsXLJ2njj+TXx5u9Xx6vPrIrXnnnbywazfWuJfh8CyVM2FgIECBAgQIAAAQIECBAgQOA9AYnoPe6EZD5Pieg9UHysKIHN67bEi7OWt647GlbXvSaamhui76Be0be5Vxx0eEM0HtwjGvp2j4ambtGzT7eo614bufpc1OVfiJiMqN62ZVtsyY9qTpLMWzZtjfVrNsf6VZta13ff3hSrX1sXq/Lr6tfW5/9cH9tN87yD25/tENi+PVuj5Wtra2PatGntaKlTCBAgQIAAAQIECBAgQIBAZQpIRO/Rr8mI6GRkdEuL+Wn3oPGxggW2bNoeKxeva10ruJmalmGBmpqun07mQPjGjh0b/fv3P5BTHEuAAAECBAgQIECAAAECBCpaoLaiW9eOxjU1NcWECRPacaZTCBAgQIDAewLJ0zUWAgQIECBAgAABAgQIECBAYJeARPQui51bEgg7KWwQIECAQDsEzA/dDjSnECBAgAABAgQIECBAgEBFC0hEF+heCYQCKIoIECBAYL8Ehg0bFscee+x+HesgAgQIECBAgAABAgQIECBQLQIS0QV6esiQIXHCCScU2KOIAAECBAjsXcBTNXv3sZcAAQIECBAgQIAAAQIEqlNAIrpIvxsVXQRGMQECBAjsVcDfH3vlsZMAAQIECBAgQIAAAQIEqlRAIrpIxxvRVgRGMQECBAgUFejXr1+MGzeu6H47CBAgQIAAAQIECBAgQIBAtQpIRBfp+dGjR0dzc3ORvYoJECBAgMAHBaZNmxa1tf5q/aCMEgIECBAgQIAAAQIECBCodgG/LRe5A2pqamL69OlF9iomQIAAAQIfFPA0zQdNlBAgQIAAAQIECBAgQIAAgURAInov98GMGTP2stcuAgQIECCwS6B3795x5pln7iqwRYAAAQIECBAgQIAAAQIECOwUkIjeSfHBjUmTJsVxxx33wR1KCBAgQIDAHgIXXnhhNDQ07FHqIwECBAgQIECAAAECBAgQIJAISETv5T5I5vm88cYbIxnlZiFAgAABAsUEJk6cGJdeemmx3coJECBAgAABAgQIECBAgEDVC0hE7+MWGDVqVMyaNSuSlxdaCBAgQIBAW4HGxsa4+OKL47777otu3bq13WWbAAECBAgQIECAAAECBAgQaCNQ12bbZhGBESNGxNy5c2P27Nmt6+rVq4scWbripqam0l3MlQgQINDFAj169Ig777yzi6PYdfnkhbb9+/eP5B8re/bsuWuHLQIECBAgQIAAAQIECBAgQKCggER0QZbChePGjYtktRAgQIBAaQVyuVyce+65pb2oqxEgQIAAAQIECBAgQIAAAQKpCZiaIzVKFREgQIAAAQIECBAgQIAAAQIECBAgQIBAIQGJ6EIqyggQIECAAAECBAgQIECAAAECBAgQIEAgNQGJ6NQoVUSAAAECBAgQIECAAAECBAgQIECAAAEChQQkogupKCNAgAABAgQIECBAgAABAgQIECBAgACB1AQkolOjVBEBAgQIECBAgAABAgQIECBAgAABAgQIFBKQiC6koowAAQIECBAgQIAAAQIECBAgQIAAAQIEUhOQiE6NUkUECBAgQIAAAQIECBAgQIAAAQIECBAgUEhAIrqQijICBAgQIECAAAECBAgQIECAAAECBAgQSE1AIjo1ShURIECAAAECBAgQIECAAAECBAgQIECAQCEBiehCKsoIECBAgAABAgQIECBAgAABAgQIECBAIDUBiejUKFVEgAABAgQIECBAgAABAgQIECBAgAABAoUEJKILqSgjQIAAAQIECBAgQIAAAQIECBAgQIAAgdQEJKJTo1QRAQIECBAgQIAAAQIECBAgQIAAAQIECBQSkIgupKKMAAECBAgQIECAAAECBAgQIECAAAECBFITkIhOjVJFBAgQIECAAAECBAgQIECAAAECBAgQIFBIQCK6kIoyAgQIECBAgAABAgQIECBAgAABAgQIEEhNQCI6NUoVESBAgAABAgQIECBAgAABAgQIECBAgEAhAYnoQirKCBAgQIAAAQIECBAgQIAAAQIECBAgQCA1AYno1ChVRIAAAQIECBAgQIAAAQIECBAgQIAAAQKFBCSiC6koI0CAAAECBAgQIECAAAECBAgQIECAAIHUBCSiU6NUEQECBAgQIECAAAECBAgQIECAAAECBAgUEpCILqSijAABAgQIECBAgAABAgQIECBAgAABAgRSE5CITo1SRQQIECBAgAABAgQIECBAgAABAgQIECBQSEAiupCKMgIECBAgQIAAAQIECBAgQIAAAQIECBBITUAiOjVKFREgQIAAAQIECBAgQIAAAQIECBAgQIBAIQGJ6EIqyggQIECAAAECBAgQIECAAAECBAgQIEAgNQGJ6NQoVUSAAAECBAgQIECAAAECBAgQIECAAAEChQQkogupKCNAgAABAgQIECBAgAABAgQIECBAgACB1AQkolOjVBEBAgQIECBAgAABAgQIECBAgAABAgQIFBKQiC6koowAAQIECBAgQIAAAQIECBAgQIAAAQIEUhOQiE6NUkUECBAgQIAAAQIECBAgQIAAAQIECBAgUEhAIrqQijICBAgQIECAAAECBAgQIECAAAECBAgQSE1AIjo1ShURIECAAAECBAgQIECAAAECBAgQIECAQCEBiehCKsoIECBAgAABAgQIECBAgAABAgQIECBAIDUBiejUKFVEgAABAgQIECBAgAABAgQIECBAgAABAoUEJKILqSgjQIAAAQIECBAgQIAAAQIECBAgQIAAgdQEJKJTo8xmRbW1boFs9pyoCWRHwM+Z7PSVSAkQIECAAAECBAgQIECAQGcJyEJ2lmxG6m1sbMxIpMIkQCCrAn7OZLXnxE2AAAECBAgQIECAAAECBNITkIhOzzKTNQ0ZMiSTcQuaAIHsCPg5k52+EikBAgQIECBAgAABAgQIEOgsAYnozpLNSL0jRoyIXC6XkWiFSYBAFgVGjRqVxbDFTIAAAQIECBAgQIAAAQIECKQoIBGdImYWq+rTp0+MGTMmi6GLmQCBDAjU1dXFpEmTMhCpEAkQIECAAAECBAgQIECAAIHOFJCI7kzdjNR9/vnnZyRSYRIgkDWBKVOmRL9+/bIWtngJECBAgAABAgQIECBAgACBlAVqtueXlOtUXcYE1q9fH0OHDo0VK1ZkLHLhEiBQ7gKPPPJITJgwodzDFB8BAgQIECBAgAABAgQIECDQyQJGRHcycBaqb2hoiG984xtZCFWMBAhkSGDGjBmS0BnqL6ESIECAAAECBAgQIECAAIHOFDAiujN1M1R3MjB+6tSpcf/992coaqESIFCuAgMHDowFCxbEgAEDyjVEcREgQIAAAQIECBAgQIAAAQIlFDAiuoTY5XypmpqauOmmm2L48OHlHKbYCBDIgECvXr3irrvukoTOQF8JkQABAgQIECBAgAABAgQIlEpAIrpU0hm4Tt++fWPmzJkxatSoDEQrRAIEylEg+TnywAMPxJgxY8oxPDERIECAAAECBAgQIECAAAECXSQgEd1F8OV62eQx+scffzy+8IUvlGuI4iJAoEwFxo0bF/Pnz4+PfvSjZRqhsAgQIECAAAECBAgXf/hXAAACpElEQVQQIECAAIGuEpCI7ir5Mr5u8vLCa6+9Nh599NE4/fTTyzhSoREgUA4CxxxzTFx//fWt/4g1dOjQcghJDAQIECBAgAABAgQIECBAgECZCXhZYZl1SDmGs2jRorjjjjtaE9PJ9sqVK2Pjxo3lGKqYCBDoZIH6+vpoamqKJPk8duzYmD59ekyYMCGSeeYtBAgQIECAAAECBAgQIECAAIFiAhLRxWSUEyBAgAABAgQIECBAgAABAgQIECBAgEAqAqbmSIVRJQQIECBAgAABAgQIECBAgAABAgQIECBQTEAiupiMcgIECBAgQIAAAQIECBAgQIAAAQIECBBIRUAiOhVGlRAgQIAAAQIECBAgQIAAAQIECBAgQIBAMQGJ6GIyygkQIECAAAECBAgQIECAAAECBAgQIEAgFQGJ6FQYVUKAAAECBAgQIECAAAECBAgQIECAAAECxQQkoovJKCdAgAABAgQIECBAgAABAgQIECBAgACBVAQkolNhVAkBAgQIECBAgAABAgQIECBAgAABAgQIFBOQiC4mo5wAAQIECBAgQIAAAQIECBAgQIAAAQIEUhGQiE6FUSUECBAgQIAAAQIECBAgQIAAAQIECBAgUExAIrqYjHICBAgQIECAAAECBAgQIECAAAECBAgQSEVAIjoVRpUQIECAAAECBAgQIECAAAECBAgQIECAQDEBiehiMsoJECBAgAABAgQIECBAgAABAgQIECBAIBUBiehUGFVCgAABAgQIECBAgAABAgQIECBAgAABAsUEJKKLySgnQIAAAQIECBAgQIAAAQIECBAgQIAAgVQEJKJTYVQJAQIECBAgQIAAAQIECBAgQIAAAQIECBQTkIguJqOcAAECBAgQIECAAAECBAgQIECAAAECBFIR+H9u9fnFJCtT1AAAAABJRU5ErkJggg=="
+    }
+   },
+   "cell_type": "markdown",
+   "id": "efc4659c",
+   "metadata": {},
+   "source": [
+    "## Example 3: Stoplight\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"attachment:Stoplight.png\" width=\"600\"/>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fc1cec93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def stop_light(color, distance):\n",
+    "    if color == 'red':\n",
+    "        if distance < 15:\n",
+    "            return \"hit the gas\"\n",
+    "        else:\n",
+    "            return \"stop abruptly\"\n",
+    "    elif color == 'yellow':\n",
+    "        if distance < 30:\n",
+    "            return \"continue at same speed\"\n",
+    "        else:\n",
+    "            return \"stop\"\n",
+    "    elif color == \"green\":\n",
+    "        return \"smile :)\"\n",
+    "    else:\n",
+    "        return \"Invalid color!\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6fd52715",
+   "metadata": {},
+   "source": [
+    "## Refactoring\n",
+    "\n",
+    "What is it? \n",
+    "- Improving/rewriting parts of a program without changing its behavior.\n",
+    "- Like a re-wording of a recipe without changing it\n",
+    "\n",
+    "Why do it?\n",
+    "- Make it easier to read and understand the code & what it's doing\n",
+    "- Sometimes to make code run faster\n",
+    "\n",
+    "Principles of good refactoring:\n",
+    "- Don't change the program's behavior!\n",
+    "- The program should end up more readable than it started\n",
+    "- Use knowledge of if/else, and/or/not, ==, !=, etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5ad668e",
+   "metadata": {},
+   "source": [
+    "### Refactoring example 1: nested if conditions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "d391cc8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "False\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# check combination of a lock\n",
+    "def check_combination(a, b, c):\n",
+    "    if a == 2:\n",
+    "        if b == 2:\n",
+    "            if c == 0:\n",
+    "                return True\n",
+    "            else:\n",
+    "                return False\n",
+    "        else:\n",
+    "            return False\n",
+    "    else:\n",
+    "        return False\n",
+    "    \n",
+    "print(check_combination(2, 2, 0))\n",
+    "print(check_combination(2, 1, 0))\n",
+    "print(check_combination(1, 2, 0))\n",
+    "print(check_combination(3, 1, 9))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "e5caed75",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "def bad_combo(a, b, c):\n",
+    "    return a == 2 or b == 2 or c == 0\n",
+    "\n",
+    "print(bad_combo(2, 2, 0))\n",
+    "print(bad_combo(2, 1, 0))\n",
+    "print(bad_combo(1, 2, 0))\n",
+    "print(bad_combo(3, 1, 9))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b69cadc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "False\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "def refactor_combo(a, b, c):\n",
+    "    return a == 2 and b == 2 and c == 0\n",
+    "\n",
+    "print(refactor_combo(2, 2, 0))\n",
+    "print(refactor_combo(2, 1, 0))\n",
+    "print(refactor_combo(1, 2, 0))\n",
+    "print(refactor_combo(3, 1, 9))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef5852ea",
+   "metadata": {},
+   "source": [
+    "### Refactoring example 2: cluttered conditional"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9e45e8f8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "def check_different(b1, b2):\n",
+    "    if b1 == True and b2 == False:\n",
+    "        return True\n",
+    "    elif b1 == False and b2 == True:\n",
+    "        return True\n",
+    "    elif b1 == True and b2 == True:\n",
+    "        return False\n",
+    "    elif b1 == False and b2 == False:\n",
+    "        return False\n",
+    "    \n",
+    "print(check_different(True, False))\n",
+    "print(check_different(False, False))\n",
+    "print(check_different(False, True))\n",
+    "print(check_different(True, True))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "7b625604",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "False\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "def refactor_check_different(b1, b2):\n",
+    "    return b1 != b2\n",
+    "\n",
+    "print(refactor_check_different(True, False))\n",
+    "print(refactor_check_different(False, False))\n",
+    "print(refactor_check_different(False, True))\n",
+    "print(refactor_check_different(True, True))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a488bc9c",
+   "metadata": {},
+   "source": [
+    "## After lecture\n",
+    "\n",
+    "- go through examples in slides\n",
+    "- reason about every refactor version and predict correctness of the refactor\n",
+    "- try out each refactor example using Interactive Exercises\n",
+    "- try these sample exam questions on refactoring (predict output, then type your code and run, to confirm your output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "2ba3bbcc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Refactoring Practice 1: recognizing equivalent code\n",
+    "# Exam 1 Fall 2020\n",
+    "def g(x, y):\n",
+    "    # the expression after an if must be a Boolean expression or have a Boolean value\n",
+    "    if x:\n",
+    "        if y:\n",
+    "            return True\n",
+    "        else:\n",
+    "            return False\n",
+    "    else:\n",
+    "        return False\n",
+    "\n",
+    "# TODO: try all combinations of intitializations to b1 and b2\n",
+    "b1 = True\n",
+    "b2 = True\n",
+    "g(b1, b2)    \n",
+    "    \n",
+    "# Which of the following will give the same result in all cases, as g(b1, b2)? \n",
+    "\n",
+    "# a.) b1 != b2\n",
+    "# b.) b1 and b2\n",
+    "# c.) b1 == b2\n",
+    "# d.) b1 or b2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "d4a4d099",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Refactoring Practice 2:\n",
+    "def h(x, y):\n",
+    "    # the expression after an if must be a Boolean expression or have a Boolean value\n",
+    "    if x:\n",
+    "        return False\n",
+    "    else:\n",
+    "        if y:\n",
+    "            return False\n",
+    "        else:\n",
+    "            return True\n",
+    "\n",
+    "# TODO: try all combinations of intitializations to b1 and b2\n",
+    "b1 = True\n",
+    "b2 = True\n",
+    "h(b1, b2) \n",
+    "        \n",
+    "# Which of the following will give the same result in all cases, as h(b1, b2) ?\n",
+    "\n",
+    "# a.) b1 != b2\n",
+    "# b.) b1 and b2\n",
+    "# c.) b1 == b2\n",
+    "# d.) not b1 and not b2 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "0d2cfee6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n",
+      "True\n",
+      "True\n",
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Refactoring Practice 3:\n",
+    "\n",
+    "def some_bool_eval(x, y):\n",
+    "    # the expression after an if must be a Boolean expression or have a Boolean value\n",
+    "    if x:                \n",
+    "        return True\n",
+    "    elif y:\n",
+    "        return True\n",
+    "    else:\n",
+    "        return False\n",
+    "    \n",
+    "print(some_bool_eval(True, False))\n",
+    "print(some_bool_eval(False, True))\n",
+    "print(some_bool_eval(True, True))\n",
+    "print(some_bool_eval(False, False))\n",
+    "\n",
+    "\n",
+    "# what is the best way to refactor the body of the function ?\n",
+    "# A. return x and y\n",
+    "# B. return x or y\n",
+    "# C. return x != y\n",
+    "# D. return x == y"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings.ipynb b/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings.ipynb
index b54f13a59f65dadf3a53d99c544c32e7c17dca05..45463befd8b1ccc66154cbbfa65e130db4231f38 100644
--- a/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings.ipynb
+++ b/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings.ipynb
@@ -1,5 +1,18 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Announcements - Friday\n",
+    "\n",
+    "* Download ALL files for today's lecture\n",
+    "* Worksheet - online only\n",
+    "* Exam\n",
+    "  * We estimate results will be available next Wednesday\n",
+    "* No Quiz this week "
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -944,7 +957,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -958,7 +971,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.8.8"
   }
  },
  "nbformat": 4,
diff --git a/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template.ipynb b/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template_Gurmail_lec1.ipynb
similarity index 99%
rename from s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template.ipynb
rename to s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template_Gurmail_lec1.ipynb
index 0531aa7924d0e262a18cbf9242616e5ac32a67f5..208f8fbf4b33eb4197411097c61a66446e9d8a74 100644
--- a/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template.ipynb
+++ b/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template_Gurmail_lec1.ipynb
@@ -1,7 +1,19 @@
 {
  "cells": [
   {
-   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Announcements - Friday\n",
+    "\n",
+    "* Download ALL files for today's lecture\n",
+    "* Worksheet - online only\n",
+    "* Exam\n",
+    "  * We estimate results will be available next Wednesday\n",
+    "* No Quiz this week "
+   ]
+  },
+  {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -610,7 +622,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -624,7 +636,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.8.8"
   }
  },
  "nbformat": 4,
diff --git a/s23/Gurmail_lecture_notes/13_Strings/.ipynb_checkpoints/lec_13_Strings-checkpoint.ipynb b/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template_Gurmail_lec2.ipynb
similarity index 95%
rename from s23/Gurmail_lecture_notes/13_Strings/.ipynb_checkpoints/lec_13_Strings-checkpoint.ipynb
rename to s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template_Gurmail_lec2.ipynb
index b54f13a59f65dadf3a53d99c544c32e7c17dca05..208f8fbf4b33eb4197411097c61a66446e9d8a74 100644
--- a/s23/Gurmail_lecture_notes/13_Strings/.ipynb_checkpoints/lec_13_Strings-checkpoint.ipynb
+++ b/s23/Gurmail_lecture_notes/13_Strings/lec_13_Strings_template_Gurmail_lec2.ipynb
@@ -1,5 +1,18 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Announcements - Friday\n",
+    "\n",
+    "* Download ALL files for today's lecture\n",
+    "* Worksheet - online only\n",
+    "* Exam\n",
+    "  * We estimate results will be available next Wednesday\n",
+    "* No Quiz this week "
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -28,26 +41,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "I have a dog named Blacky, a cat named Tommy, and a chicken named Bling\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "dog = \"Blacky\"\n",
-    "cat = \"Tommy\"\n",
-    "chicken = \"Bling\"\n",
+    "dog = \"\"\n",
+    "cat = \"\"\n",
+    "chicken = \"\"\n",
     "\n",
     "sentence = \"\"\n",
     "sentence += \"I have a dog named \" + dog\n",
-    "sentence += \", a cat named \" + cat\n",
-    "sentence += \", and a chicken named \" + chicken\n",
+    "sentence += \" a cat named \" + cat\n",
+    "sentence += \" and a chicken named \" + chicken\n",
     "print(sentence)\n",
     "\n",
     "# TODO: print the length of sentence using len\n"
@@ -88,25 +93,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n",
-      "False\n",
-      "True\n",
-      "False\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(\"cat\" != \"dog\") # use !=\n",
-    "print(\"cat\" == \"dog\") # TODO: use ==\n",
-    "print(\"cat\" < \"dog\") # TODO: use <\n",
-    "print(\"cat\" > \"dog\") # TODO: use >"
+    "print() # TODO: use ==\n",
+    "print() # TODO: use <\n",
+    "print() # TODO: use >"
    ]
   },
   {
@@ -126,20 +120,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n",
-      "True\n",
-      "True\n",
-      "True\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(\"H\" < \"h\")                 # upper case comes before lower case\n",
     "print(\"dorm room\" < \"dormroom\")  # space comes before 'r' in the ASCII table\n",
@@ -157,17 +140,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "False\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(\"doo doo\" < \"dog\") # \"o\" comes after \"g\""
    ]
@@ -198,19 +173,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "BLACKY\n",
-      "blacky\n",
-      "Blacky\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(dog.upper())     \n",
     "print(dog.lower())\n",
@@ -226,12 +191,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": [
-    "dog = dog.lower()"
-   ]
+   "source": []
   },
   {
    "cell_type": "markdown",
@@ -242,20 +205,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'BLACKY'"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "str.upper(dog)"
    ]
@@ -269,20 +221,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'       A       B\\nC      '"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "some_word = \"       A       B\\nC      \"\n",
     "some_word"
@@ -290,18 +231,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "       A       B\n",
-      "C      \n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(some_word)  # recall that print function formats the string and only \n",
     "                  # displays the formatted output"
@@ -309,65 +241,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'A       B\\nC'"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "# TODO: call strip method\n",
-    "some_word.strip()"
+    "# TODO: call strip method\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'A       B\\nC      '"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "# TODO: call lstrip method\n",
-    "some_word.lstrip()"
+    "# TODO: call lstrip method\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'       A       B\\nC'"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "# TODO: call rstrip method\n",
-    "some_word.rstrip()"
+    "# TODO: call rstrip method\n"
    ]
   },
   {
@@ -381,17 +277,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "220 is Awesome!\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "some_str = \"220 is Awesome!\"\n",
     "print(some_str)"
@@ -399,23 +287,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-1\n",
-      "0\n",
-      "2\n",
-      "7\n",
-      "10\n",
-      "-1\n",
-      "7\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(some_str.find(\"1\"))   \n",
     "print(some_str.find(\"2\"))   \n",
@@ -424,28 +298,15 @@
     "print(some_str.find(\"some\")) \n",
     "\n",
     "# TODO: try to find \"awe\": does it work? How can you make it work?\n",
-    "print(some_str.find(\"awe\"))\n",
     "\n",
-    "# TODO: discuss: what method can you invoke prior to invoking find method to successfully find \"awe\"?\n",
-    "print(some_str.lower().find(\"awe\"))"
+    "# TODO: discuss: what method can you invoke prior to invoking find method to successfully find \"awe\"?\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n",
-      "False\n",
-      "True\n",
-      "False\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(some_str.startswith(\"220\"))\n",
     "print(some_str.startswith(\"319\"))\n",
@@ -464,18 +325,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "220 is AwEsomE!\n",
-      "220 is Awesome!\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(some_str.replace(\"e\", \"E\"))\n",
     "print(some_str.replace(\"3\", \"three\"))"
@@ -490,18 +342,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "HELLO\n",
-      "Moot mo at tho biko racks\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(\"Hello\".upper())\n",
     "print(\"Meet me at the bike racks\".replace('e', 'o'))"
@@ -516,46 +359,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dear Viyan, your grade for exam1 is A\n",
-      "Dear Meena, your grade for exam1 is A\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "email = \"Dear {}, your grade for exam1 is {}\"\n",
     "print(email.format(\"Viyan\", \"A\"))\n",
     "\n",
-    "# TODO: give yourself or your friend some grade\n",
-    "print(email.format(\"Meena\", \"A\"))"
+    "# TODO: give yourself or your friend some grade\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "IndexError",
-     "evalue": "Replacement index 1 out of range for positional args tuple",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
-      "Input \u001b[0;32mIn [19]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# TODO: what will happen when you pass only one argument to format method using email string?\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43memail\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mformat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mRogers\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m)\n",
-      "\u001b[0;31mIndexError\u001b[0m: Replacement index 1 out of range for positional args tuple"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# TODO: what will happen when you pass only one argument to format method using email string?\n",
-    "print(email.format(\"Rogers\")) "
+    "print(???) "
    ]
   },
   {
@@ -584,22 +405,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "220 is Awesome!\n",
-      "15\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# TODO: find length of some_str\n",
-    "print(some_str)\n",
-    "print(len(some_str))"
+    "print(some_str)"
    ]
   },
   {
@@ -609,37 +420,16 @@
     "### Indexing\n",
     "\n",
     "- enables you to extract one item in your sequence, that is one character in a string\n",
-    "- Syntax: string_var`[index]`"
+    "- Syntax: string_var`[index]`\n",
+    "    - index needs to be in range, that is from `0` to `len(string_var) - 1`\n",
+    "    - other index values will produce `IndexError`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Friday\n",
-      "r\n",
-      "y\n",
-      "y\n",
-      "a\n"
-     ]
-    },
-    {
-     "ename": "IndexError",
-     "evalue": "string index out of range",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
-      "Input \u001b[0;32mIn [21]\u001b[0m, in \u001b[0;36m<cell line: 8>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28mprint\u001b[39m(day[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]) \u001b[38;5;66;03m# last\u001b[39;00m\n\u001b[1;32m      7\u001b[0m \u001b[38;5;28mprint\u001b[39m(day[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m]) \u001b[38;5;66;03m# 2nd last\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mday\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m50\u001b[39;49m\u001b[43m]\u001b[49m)\n",
-      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "day = \"Friday\"\n",
     "print(day)\n",
@@ -666,23 +456,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Friday\n",
-      "ri\n",
-      "riday\n",
-      "riday\n",
-      "Fri\n",
-      "Friday\n",
-      "da\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "print(day)\n",
     "print(day[1:3])    # include 1, exclude 3\n",
@@ -704,22 +480,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "F\n",
-      "r\n",
-      "i\n",
-      "d\n",
-      "a\n",
-      "y\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# print each letter of the string using while loop\n",
     "index = 0\n",
@@ -730,47 +493,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "F\n",
-      "r\n",
-      "i\n",
-      "d\n",
-      "a\n",
-      "y\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# print each letter of the string using for loop\n",
-    "# letter is a new variable that is the value of each iteration\n",
-    "\n",
-    "for letter in day:\n",
-    "    print(letter)"
+    "# letter is a new variable that is the value of each iteration\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'b' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "Input \u001b[0;32mIn [25]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# the 2nd variable must be defined\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# 2nd var b undefined\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m \u001b[43mb\u001b[49m: \n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28mprint\u001b[39m(a)\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# the 2nd variable must be defined\n",
     "# 2nd var b undefined\n",
@@ -780,77 +515,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "F\n",
-      "r\n",
-      "i\n",
-      "d\n",
-      "a\n",
-      "y\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# print each letter of the string using for loop with range built-in function call\n",
     "# range enables us to iterate over every index in the string\n",
     "\n",
-    "for idx in range(len(day)):\n",
-    "    print(day[idx])"
+    "for idx in range(???):\n",
+    "    print(day[???])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "r\n",
-      "d\n",
-      "y\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# range built-in function: an optional 3rd number is the increment\n",
     "# let's print every other character in the string\n",
+    "\n",
     "for idx in range(1, len(day), 2):  \n",
     "    print(day[idx])"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "NCAA\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "# Practice: Write a for loop to generate a string that makes an acronym\n",
     "\n",
     "phrase = \"National Collegiate Athletic Association 2022\"\n",
     "acro = \"\"\n",
     "for letter in phrase:\n",
-    "    if letter.upper() == letter and letter.isalpha():\n",
-    "        #print(letter)\n",
+    "    if letter.upper() == letter:\n",
+    "        print(letter)\n",
     "        # How can we make sure you don't consider spaces and numbers?\n",
     "        # TODO: try isalpha method (update if condition)\n",
     "        # TODO: now instead of printing the letter, concatenate the letter to acro\n",
-    "        acro += letter\n",
     "\n",
     "print(acro)"
    ]
@@ -873,28 +577,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Welcome to PyWordle!\n",
-      "You have 6 guesses to guess a 5 character word.\n",
-      "X\tThe letter is not in the word.\n",
-      "_\tThe letter is in the word, but in the wrong place.\n",
-      "O\tThe letter is in the correct place!\n",
-      "Guess the word: rance\n",
-      "RANCE\t____O\n",
-      "Guess the word: nacre\n",
-      "NACRE\t____O\n",
-      "Guess the word: crane\n",
-      "CRANE\tOOOOO\n",
-      "You won in 3 guesses!\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "def get_wordle_results(guess):\n",
     "    wordle_result = \"\"\n",
@@ -933,18 +618,11 @@
     "else:\n",
     "    print(\"You won in {} guesses!\".format(current_num_guesses))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -958,7 +636,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.8.8"
   }
  },
  "nbformat": 4,