t-flora/cs110_pcw_2_1.ipynb

## cs110_pcw_2_1.ipynb
{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n",
    "\n",
    "Make sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "NAME = \"Tiago Flora\"\n",
    "COLLABORATORS = [\"Ara Mkhoyan\", \"Cameron Watts\", \"Chloe Gabrielle Go\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "4394bdd5d17d8ce7ce4e758066ee0266",
     "grade": false,
     "grade_id": "cell-9e44910e5a73668d",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# CS110 Pre-class Work 2.1\n",
    "\n",
    "## Question 1.\n",
    "\n",
    "First, please read carefully [this note](https://drive.google.com/open?id=1SfrRTKWDb6szsJENgvNF7-u2B96ecaF2) which reviews the MERGE operation in Cormen et al.\n",
    "\n",
    "After reviewing the example above (Cormen et. al., Figure 2.3),  you need to manually create similar illustrations as in the example above but this time for the input array:\n",
    "\n",
    "![array](array.png)\n",
    "\n",
    "For this exercise, assume that the call to the algorithm is MERGE(A, 1, 3, 6) and draw different resulting stages of the arrays A, L, and R as the merge algorithm is executed.  You can hand-draw or use any drawing tool to produce panel illustrations as in the example above.  Include your final drawings in the cell below. Feel free to use additional cells (Markdown or Code) for this question.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "b4d0caf51fb6b587f68db4e806af35d0",
     "grade": true,
     "grade_id": "cell-badbff7790708987",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "source": [
    "![img](https://i.ibb.co/k6ffpmv/Page1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![img](https://i.ibb.co/HPHbC59/Page2.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "7c9608898d23ecbe07c084ca6d6da655",
     "grade": false,
     "grade_id": "cell-6dd1317d1ea8ab9f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 2.\n",
    "Now using your understanding of Part I of the merge algorithm, can you think of an efficient way to implement this part in Python? (hint: using Python list). Give your answer in prose in the cell below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "9bf35550640c33f366c5cffad7fdf33a",
     "grade": true,
     "grade_id": "cell-4f961721620a6645",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "source": [
    "First, one defines the (empty) left and right arrays (using lists), which are to be filled with the values of the array A until and after q, respectively. Then, in the desired range (from A[1] to A[n1] and from A[n1+1] to A[n2]), we append the elements of A onto the L and R arrays (using the .append() function). At last, we assign the last elements of the L and R arrays to be float(math.inf), so no value will be larger than the sentinel values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "010584ea3a4f00fba43b52bb04cd0ed2",
     "grade": false,
     "grade_id": "cell-84932c7c0c20b750",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 3.\n",
    "\n",
    "Write a Python implementation of the merge pseudocode (both parts), your Python function must take the same four input arguments as described in the $MERGE(A,p,q,r)$. Test your code by running the example in problem 1 and 2 of this pre-class work. Feel free to come up with additional cases to check if your code is working properly. Your code should return A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "43760e27d0b385c30476353b3d546a79",
     "grade": false,
     "grade_id": "cell-a67719d65c1ac9f3",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "count_steps = 0\n",
    "\n",
    "def merge(A, p, q, r):\n",
    "    # Define global variable for counting steps\n",
    "    global count_steps \n",
    "    # Define n1 and n2, the ranges of the L and R subarrays\n",
    "    no = q - p\n",
    "    nt = r - q\n",
    "    # Create L and R\n",
    "    L = []\n",
    "    R = []\n",
    "    count_steps += 4\n",
    "    # Append the A elements left of q to L\n",
    "    for i in range(no+1):\n",
    "        L.append(A[p+i-1])\n",
    "        count_steps += 2\n",
    "    count_steps += 1\n",
    "#    print(L)\n",
    "    # Append the A elements right of q to R\n",
    "    for j in range(nt):\n",
    "        R.append(A[q+j])\n",
    "        count_steps += 2\n",
    "    count_steps += 1\n",
    "#    print(R)\n",
    "    # Define sentinel values\n",
    "    L.append(float(math.inf)) # Or we could have 2**(32)...\n",
    "    R.append(float(math.inf))\n",
    "    # Define indices to compare the elements of the L and R arrays\n",
    "    i = 0\n",
    "    j = 0\n",
    "    count_steps += 4\n",
    "    for k in range(p-1, r):\n",
    "        count_steps += 2\n",
    "        if L[i] <= R[j]:\n",
    "            count_steps += 1\n",
    "            A[k] = L[i]\n",
    "            i += 1\n",
    "        else:\n",
    "            A[k] = R[j]\n",
    "            j += 1\n",
    "            count_steps += 2\n",
    "    return A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 2, 4, 5, 6, 10, 5]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = [3,6,10,5,1,4,2,4,5]\n",
    "merge(B, 1, 4, 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "699908274975a6bff4f9fb021e666ce4",
     "grade": true,
     "grade_id": "cell-e98759fe14428af0",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Please ignore this cell. This cell is for us to implement the tests \n",
    "# to see if your code works properly. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "35e241fec3dd026733d04a51fa2972fe",
     "grade": false,
     "grade_id": "cell-49f3f61ee6d72bb9",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Question 2\n",
    "Suppose that your Python implementation of the merge algorithm is already working. Inspect the code for merge sort below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "53611abb1448334a346783091382fb12",
     "grade": false,
     "grade_id": "cell-073a21c6aac8225e",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "def merge_sort(A,p,r):\n",
    "    if p < r:\n",
    "        q = (p+r)/2\n",
    "        merge_sort(A,p,q)\n",
    "        merge_sort(A,q+1,r)\n",
    "        merge(A,p,q,r)\n",
    "    return(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b708edb1e6e70731f3ec68d1d11c2890",
     "grade": false,
     "grade_id": "cell-c19a4320995e15b2",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Copy and paste the code above to the cell below and fix the bug in it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "d52aee435812fe91886c6dcdfc4e3f6d",
     "grade": false,
     "grade_id": "cell-311695db35c06d65",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "def merge_sort(A,p,r):\n",
    "    # We ensure p, r and q will be integer values.\n",
    "    p = int(p)\n",
    "    r = int(r)\n",
    "    if p < r:\n",
    "        # q will always be the floor of the average of p and r if it is\n",
    "        # not an integer\n",
    "        q = math.floor((p+r)/2)\n",
    "        merge_sort(A,p,q)\n",
    "        merge_sort(A,q+1,r)\n",
    "        merge(A,p,q,r)\n",
    "    return(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 10, 11]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = [10,3,6,5,11,4,2,1]\n",
    "merge_sort(B, 1, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "35fbb3c437b3ba39ede0d87d6719223b",
     "grade": true,
     "grade_id": "cell-a3a71f67390c1f82",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Please ignore this cell. This cell is for us to implement the tests \n",
    "# to see if your code works properly. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "61cfba995efe3c9c37092a650047fdf3",
     "grade": false,
     "grade_id": "cell-5b296f793fefdbfe",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# Question 5.\n",
    "As in the previous Lesson, count the number of steps and time your merge_sort() function with the following input: `list_k = [i for i in range(100*k, 0, -1)] `, where $k= 1, 2, 3, …, 15 $. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We redefine merge_sort to contain a step counter and return it\n",
    "def merge_sort(A,p,r):\n",
    "    global step_counter\n",
    "    p = int(p)\n",
    "    r = int(r)\n",
    "    step_counter += 1\n",
    "    if p < r:\n",
    "        q = math.floor((p+r)/2)\n",
    "        step_counter += 1\n",
    "        merge_sort(A,p,q)\n",
    "        merge_sort(A,q+1,r)\n",
    "        merge(A,p,q,r)\n",
    "    return(step_counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "cc3f59157e795d05422e849f3e7cc03a",
     "grade": true,
     "grade_id": "cell-8a4233ab58d3d0bb",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[298, 598, 898, 1198, 1498, 1798, 2098, 2398, 2698, 2998, 3298, 3598, 3898, 4198, 4498] [0.0009970664978027344, 0.0009975433349609375, 0.0019941329956054688, 0.0029926300048828125, 0.003989458084106445, 0.003989219665527344, 0.005983591079711914, 0.006017208099365234, 0.006981372833251953, 0.007977962493896484, 0.008943319320678711, 0.009973287582397461, 0.011003732681274414, 0.014445066452026367, 0.02378702163696289]\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "# Create arrays to store number of steps per list size and run time\n",
    "# per list size\n",
    "lst = []\n",
    "time_lst = []\n",
    "\n",
    "for k in range(15):\n",
    "    # Reset counter value to 0\n",
    "    step_counter = 0\n",
    "    list_k = list(range(100*(k+1), 0, -1))\n",
    "    # We use the time module to count the running time of each iteration\n",
    "    # of the algorithm\n",
    "    starting_time = time.time()\n",
    "    # We append to the step counter list the number of steps in every iteration\n",
    "    lst.append(merge_sort(list_k,1,len(list_k)))    \n",
    "    ending_time = time.time()\n",
    "    time_lst.append(ending_time-starting_time)\n",
    "\n",
    "print(lst, time_lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Question 6. \n",
    "Use the code you wrote for Lesson 1.2 (i.e., selection sort, bubble sort, insertion sort). Plot the following graphs:\n",
    "* **Graph 1**: 4 lines for **the number of steps** of each of the 4 sorting algorithms (i.e., selection sort, bubble sort, insertion sort, merge sort). Which algorithm performs best? Why? \n",
    "* **Graph 2**: 4 lines for **the timing** of each of the 4 sorting algorithms (i.e., selection sort, bubble sort, insertion sort, merge sort). Which algorithm performs best? Why?\n",
    "\n",
    "Using as many cells as you wish (code cells or markdown cells alike) to complete this question.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bubbleSort(A):\n",
    "    global step_counter_b\n",
    "    step_counter_b = 0\n",
    "    step_counter_b += 1\n",
    "    for i in range(len(A)):\n",
    "        step_counter_b += 2\n",
    "        # j must start at len(A)-1, and  move backwards\n",
    "        for j in range(len(A)-1, 0, -1):\n",
    "            step_counter_b += 3\n",
    "            # If an element is larger than the preceding number, they swap orders\n",
    "            if A[j] < A[j-1]:\n",
    "                step_counter_b += 1\n",
    "                A[j], A[j-1] = A[j-1], A[j]\n",
    "            j -= 1\n",
    "    return step_counter_b\n",
    "\n",
    "def insertionSort(A):\n",
    "    global step_counter_i\n",
    "    step_counter_i = 0\n",
    "    step_counter_i += 1\n",
    "    for j in range(len(A)):\n",
    "        step_counter_i += 5\n",
    "        key = A[j]\n",
    "        i= j-1\n",
    "        while i >= 0 and A[i]>key:\n",
    "            step_counter_i += 4\n",
    "            A[i+1] = A[i]\n",
    "            i -= 1\n",
    "        A[i+1] = key\n",
    "    return step_counter_i\n",
    "\n",
    "def selectionSort(A):\n",
    "    global step_counter_s\n",
    "    step_counter_s = 0\n",
    "    # Iterate over the whole array and assume an element is the smallest for comparison\n",
    "    step_counter_s += 1\n",
    "    for i in range(len(A)):\n",
    "        step_counter_s += 2\n",
    "        minidx = i\n",
    "        for j in range(len(A)):\n",
    "            step_counter_s += 2\n",
    "            # For every next element, compare it to the current one\n",
    "            if A[j] > A[minidx]:\n",
    "                step_counter_s += 1\n",
    "                # If any element is smaller, the minimum element is now assumed to be it\n",
    "                minidx = j\n",
    "            # Swap the positions of the original element being compared (A[i]) and the new minimum\n",
    "            A[i], A[minidx] = A[minidx], A[i]\n",
    "    return step_counter_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "0561f29260f91795736500d62066a4c7",
     "grade": true,
     "grade_id": "cell-d09efb7c7fe55e69",
     "locked": false,
     "points": 0,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# We create lists for all algorithms\n",
    "time_bubble = []\n",
    "time_insert = []\n",
    "time_select = []\n",
    "steps_bubble = []\n",
    "steps_insert = []\n",
    "steps_select = []\n",
    "\n",
    "for k in range(15):\n",
    "    step_counter_b = 0\n",
    "    list_k = list(range(100*(k+1), 0, -1))\n",
    "    starting_time = time.time()\n",
    "    steps_bubble.append(bubbleSort(list_k))    \n",
    "    ending_time = time.time()\n",
    "    time_bubble.append(ending_time-starting_time)\n",
    "    \n",
    "for k in range(15):\n",
    "    step_counter_i = 0\n",
    "    list_k = list(range(100*(k+1), 0, -1))\n",
    "    starting_time = time.time()\n",
    "    steps_insert.append(insertionSort(list_k))    \n",
    "    ending_time = time.time()\n",
    "    time_insert.append(ending_time-starting_time)\n",
    "\n",
    "for k in range(15):\n",
    "    step_counter_s = 0\n",
    "    list_k = list(range(100*(k+1), 0, -1))\n",
    "    starting_time = time.time()\n",
    "    steps_select.append(selectionSort(list_k))    \n",
    "    ending_time = time.time()\n",
    "    time_select.append(ending_time-starting_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbgAAAElCAYAAACWMvcuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOydZ3gV1daA30UCCb1GBEKVDgkBAliQXgQREEEQ6SpiQ/D6Wa+I2BWvqCheVHovlyI2lCZoRBJAOhIgQAglBBIIEEhZ34+ZxENIOQmcnJT9Ps95zsyeXdbsKWt2W0tUFYPBYDAY8huF3C2AwWAwGAyuwCg4g8FgMORLjIIzGAwGQ77EKDiDwWAw5EuMgjMYDAZDvsQoOIPBYDDkS4yCMxjyCSIyXkTmuFsOgyG3YBScweAiRGSAiGwWkYsictreflJExN2yAYjImyKyU0QSRGS8u+UxGG42RsEZDC5ARP4FfAJ8CNwKVARGAXcBRdJJ45FjAlqEAi8A3+VwuQZDjmAUnMFwkxGR0sAE4ElVXaKqF9Rim6o+rKpX7HgzRGSKiHwvIheB9iJyr4hsE5HzInLMsWUlIjVEREVkpIhEiMgJW5E6UkREZonIBRHZLSKB6cmpqjNV9Qfgws2vBYPB/RgFZzDcfO4AvIAVTsQdCLwNlAQ2AReBIUAZ4F7gCRHpnSpNe6AO0AV4SUQ6ORzrCSyw068EJmf/NAyGvI1RcAbDzacCcEZVE5IDROR3EYkWkcsi0sYh7gpV/U1Vk1Q1TlXXq+pOe38HMB9omyr/N1T1oqruBKYDDzkc26Sq36tqIjAbaOKaUzQYcj9GwRkMN58ooIKIeCYHqOqdqlrGPub43B1zTCgirURknYhEikgM1rhdhVT5O6Y5AlR22D/psH0J8HaUw2AoSBgFZzDcfIKAK0AvJ+KmducxD6trsaqqlga+BFLPuqzqsF0NiMimnAZDvsYoOIPhJqOq0cAbwBci0ldESohIIREJAIpnkrwkcFZV40SkJdYYXWpeE5FiItIIGA4szI6cIlJYRLyx3gOeIuLthpmcBoPLMF0XBoMLUNUPROQ41jT8WViTRw4BLwK/Z5D0SeAjEZkMbAAWYU0YcWQD1hT/QsBEVV2dTTG/AoY67L+KpTBnZDM/gyFXIcbhqcGQNxCRGsBhoLDjBBaDwZA2povSYDAYDPkSo+AMBoPBkC8xXZQGg8FgyJeYFpzBYDAY8iVGweUxRORuEdnvbjmSEYvpInJORP50tzzuREQeFpHszmjMSjnDRGSTk3Fdfn1EJCzZXJiIvCIiXzscu9+2qRkrIk1FpJ5ta/OCiIx2hTy5FXc9uyLSTkTCXZh/rIjUyuB4yv2R0+S7ZQK2K5KDQJyqNnS3PDcbVd0I1HO3HA60BjoDvqp6MSsJRUSBOqoa6hLJchhVnQvMvdF8bnK9ZPv6ZAdVfSdV0ETgaVVdASAi3wDrVbWpq2VJjYi0A+aoqm8OlXfNdcyFz+5NQVVLJG+LyAwgXFX/7T6J/iE/tuDaALcAtUSkhbuFuZnkUpNL1YGwnHh5GrJFtq/PTbrfqgO7M9jPaXlcTl6R80bJE+epqvnqB0zD+or+HzA5k7hV7XiRWDYCJ9vhhYB/Y9n5O421ULe0fawGlnml4Vg2Ac9h2QtsAewAoh3LBYYBvwGfATHAPqCjw/HhwF4slyWHgMcdjrUDwrEWB5/EMp7bDusLKTnOi8BxO/3+5LyxrNlPwjLjFGFve6XK91/2+Z0AhmdQT5WxzEedxVpg/Jgd/ggQByQCsVhGgFOnrY21MDkGOAMstMN/tevxop22vx3eA9hu1+PvgL9DXmHAy8Aeu96nA972sQrAKjvdWWAjUCid8/nEvnbngRDgbodjRYGZdv57sRZqO9b3S1g9BBdsOe5Pda03OeyrfW8csPP7nH8mdmWpXlLJn7qcD7E8EZROFS/N6wM8Zl/Hs/Z1rZxK5qdsmQ+nU3+DsZ6NKKzF4WFAJ/vYeGAO1v0X63AuB4G1tixx9rG6dryJwFHgFJZpsqLp3f9O3iPPYz2LMVhWXryxLMhcBpLssmMdz9shfXf7ul7Aeq6edzjmdL2ldR25/tlNU1aH4y9gPZsRwKN2frXTuSaZvkcc9psB2+y4i+1y38rOeTqE1QZGAvHAVfucv83sPB2u8Qv88y7qbV+Hv20ZXnEovyUQjPXsngL+k+E7/mYoldzyA4rZJ94deADrxVEknbgewF/Ax/bN7w20to+NsC9wLaAElhJMfrhq2Bf0SztNF6wHdjlWy7GKfaHaOryMEoCxQGH7Ro8BytnH7wVuw7I32BbLQG4zh4ufALyP9SIo6nizYnV3HEu+AW3ZbrO3JwB/2DL5YL0I3kyV7wRbpu52uWXTqasNwBf2+QZgfRB0dDi/TRlck/lYL8FCjnXs+GCkevBOA63s6zMU6+FIVsxhwC6sD5NyWB8Ob9nH3rWvSWH7dze2MklDpkFAeawu+n9hvTyTH7j37PMtC/hiPZSOL4d+WAq/kH0tLwKV0qoL+/xWYVkiqWbX2z1ZrZc05B+GpdAKYVkj+QkollFch/0OWM9FM6x76jPg11Rl/2zXb9E08muI9fJqY6f/j30vXaPgMrjG64FHHfYnYb1Ey2GZKfsWeDeD+9+Ze+RP+xqVw3rpj3LILzy9erXjnMD+4LHvgWbZrbc0zv2a8jOR9R6s+7IR1nttdkb3BZm/R5LfGUWwPk6exXpO+mAppLduxnliWcF5K5VsmV2TBGCcLc9jWM/JPPt+aIT1fq1lxw8CBtvbJYDbM7yeziqPvPDDenFFYr24vLC+8O5PJ+4dyXHTOLYGy1ll8n49rC8TT/5RcFUcjkfh8KUNLAXGOLxgInB42doXe3A6ci0HnnW4+Fe59qvO8WatjfWwd8KybuGYz0Ggu8N+V6yuquQ8Ljueu53PdTcLljJJBEo6hL0LzHA4v4wU3CxgKtYYUOpjqV8AU7CVsEPYfv75WAhLfjDs/e7AQXt7Apb/tXQVQwYyngOa2NuHgK4Oxx4lg5ciVkuiV1p1YZ+fo+JaBLyU1XpJ4/gwYDPWl/BS0vmIS0emb4APHPZLYN3bNRzK7pBBfuOABQ77xe17NMsKDutlfBH7o8zhuTycwf3vzD0yyOHYB8CXqZ+dDM7vKPA4UCpVeJbrLY1zv6b8TGSdhq3o7f3amd0XqcpO/R5Jfme0wWqZOr6PNvGPgruh8yR9BZfRNbkMeNj7Je38WjnEDwF629u/Ytl5reBMPeS3MbihwCJVTVDLa/L/uNbWniNVgSOatsmjylhfOckcwVJuFR3CTjlsX05jv4TD/nG1r45DfpUBRKSbiPwhImdFJBrrpe3oHiVSVePSOgG1Bq/HYL1UTovIAhFJdp2S1jk4ulWJSnXul1LJnExlLOO/jl6fj2C1VJ3hBawX2Z+2h+kRGcStDvzL9psWbddH1VRyp+cq5kOsVvdqETkkIi+lV4iI/EtE9opIjF1Gaf6p88qpykjtzmaIiGx3kK8x17uzcSS1+5rkOs5KvaRFbSxvBW+o6tUspLvmvlDVWKwPNMfreSx1olTpU46rNbYXlYXyHfHBap2EONTnj3Z4Mqnvf2fukfTq3BkewHoGj4jIBhG5ww6/0XpLj/RkzfA+TI0T75FkKnP9++hYquM5eZ5gvYsS7e3L9n9679NHsLq294nIFhHpkVGh+UbBiYgvVvN6kIicFJGTQF+gu4ikdaGPAdXSGSiNwHqQkqmG1Yw+lUZcZ6hiz+50zC9CRLywvsAnAhXV8hf2Pde6R3G8Ea9DVeepamtbXsXqzknvHLLjViUCKCciJVPlddyZxKp6UlUfU9XKWF/GX4hI7XSiHwPeVtUyDr9iqjrfIU6armJU9YKq/ktVawH3Ac+JSMfUBYjI3VhjOg9idcmWweoyTq7zE1hdk9eVJyLVsboEnwbK22l3wXXubDIli/WSFnuxxl1+EJGszMy75r4QkeJY3bWO1zOje+4E19ZJMTt9djiD9fJq5HC9S6vDrLw0ZHHmHkmPDJ8lAFXdoqq9sLr2l2O1uuHG6y2rpHsfpsbJ94hjvqnfR4553+h53sw6uD5z1QOq+hDW9XkfWGLLmCb5RsFhDXz/jdWdGGD/6mINYD6URvw/sS72eyJS3HYVcpd9bD4wVkRqikgJ4B2sSQDZNXB7CzDadk/SD2iAdQMWwepKjQQSRKQb1pieU9hrijrYN3gc1ssi+UtoPvBvEfGxFfw4rMH/LKGqx7DG796168gf6yvKqenwItLP/vgAqytQHWQ8hTXOmcxXwCixnH6KfV3uTaVcnxIRXxEpB7yC7SpGRHqISG37wT1vl5HI9ZTE+liJxHIRMw4o5XB8EfCyiJQVkSpYyiyZ4rb8kXaZw7FacFkmi/WSJvZL/RXgFxG5zcmi5wHDRSTAvm/eATarapiT6ZcAPUSktYgUweoaztZ7RFWTsK75xyJyC4CIVBGRrhkkc+YeSY9TQHkRKZ3WQREpItZaxtKqGs8/9xFkr96cuo7psMgur4H9ETEug7hZeY8EYZ3T0yLiKSK9sCZuJHOj98eNnHOmiMggEfGx751oOzit5xzIXwpuKPCF/WWc8sOaeHBdN6XdJL4Pq6vnKJYi7G8fnoY1qPsr1oyoOOCZG5BtM1AH64v1baCvqkbZ3X6jsW7mc1i+v1ZmIV8vrEkRZ7C6AG7BeuEBvIU122gHsBPYaodlh4ewxh4jgGXA66r6s5NpWwCbRSQW69yeVdXD9rHxwEy7q+lBVQ3GGmSejFUfoVhjSI7MA1ZjjZUdcjinOsAvWBMggrDuhfVpyPMT8APWx9ARrGvr2OUyAeteOGzntwTLeSmqugf4yM7/FOCHNdElOzhdLxlloqozbZnXiuVtIENUdQ3wGtYX/wmsiQkDnBVaVXdjzaKbZ6c/h1Vf2eVFrOv8h4icx6rzdFukTt4j6aXdh/Xhd8iu28ppRBsMhNmyjMIa189uvY3HyeuYhqw/AJ8C67DOMcg+dCWNuE6/R+zu7D5YH6nRWOe3in/u8Ru6P7DG8Bra57w8C+mc5R5gt/3cfAIMSG8IB4wtSpcjIsOwBtVbu1uWvI6IhGHV5S85WOYTWA9R25wq02BIjYg0wOoO97qBnqT08t6MNelj+s3MNzeQn1pwBsMNIyKVROQusTxw18NaRrDM3XIZCh5imTkrIiJlscabvr0Zyk1E2orIrXYX5VDAH2tyT77DKDiD4VqKAP/FWgS7FmvpwRdulchQUHkca1ztINY40xM3Kd96WGuAY7A+4Pqq6omblHeuwnRRGgwGgyFfYlpwBoPBYMiX5H5jmW6mQoUKWqNGDXeLYTAYDHmKkJCQM6rqk3lM12EUXCbUqFGD4OBgd4thMBgMeQoROZJ5LNdiuigNBoPBkC8xCs5gMBgM+RKXKjgRGSuWIdldIjLfNvVUU0Q2i8gBEVlom/tBRLzs/VD7eA2HfF62w/c7mvERkXvssFBxMK6bnTIMBoPBkL9w2RicbcdvNNBQVS+LyCIsky/dgY9VdYGIfIllMmaK/X9OVWuLyACshY39RaShna4RlqXrX0Skrl3M50BnLFNBW0RkpW1O6f2slJHVc4uPjyc8PJy4uHQtxBjciLe3N76+vhQuXNjdohgMBjfi6kkmnkBREYnHcotxAsvi/0D7+Ewse21TsFx/jLfDlwCTbcO5vbD8T10BDotIKP8YBw1V1UMAIrIA6CUie7NahmZxMWB4eDglS5akRo0aiGTZkLzBhagqUVFRhIeHU7NmTXeLYzAY3IjLuihV9Tj/uKI/gbVqPgSIdjA3E84/foaqYBu9tY/HYLlpSAlPlSa98PLZKOMaRGSkiASLSHBkZOR15xYXF0f58uWNcsuFiAjly5c3rWuDweA6BWfbT+sF1MTqWiwOdEsjanLrKS1toTcxPKMyrg1Qnaqqgaoa6OOT9jIOo9xyL+baGAwGcO0kk05Yrucjbd9K/wPuBMrIP05GffnHCWc4tuM9+3hp4KxjeKo06YWfyUYZBoPBYEgmKRF+ehWij7pbkhvClQruKHC7iBSzx9I6Anuw/Bv1teMMxTJmC5b/omS/bX2BtfbY2EpggD0DsiaW368/gS1AHXvGZBGsiSgr7TRZLSPP8fbbb9OoUSP8/f0JCAhg8+bNGcYfNmwYS5YsyXI5YWFhzJs3L2U/ODiY0aNHZzmftJg2bRp+fn74+/vTuHFjVqxYkXkiB5YvX86ePXtuiiwGg8GBn8dB0GQIXeNuSW4Il00yUdXNIrIEy9FmArANmAp8BywQkbfssG/sJN8As+1JJGexneyp6m57BuYeO5+nbGeliMjTWA4sPYBptjNGsJwoOl1GXiMoKIhVq1axdetWvLy8OHPmDFevXnVJWckKbuBAa85OYGAggYGBN5xveHg4b7/9Nlu3bqV06dLExsaS1nhneiQkJLB8+XJ69OhBw4YNb1geg8FgEzzNUm4tH4fA4e6W5sZQVfPL4Ne8eXNNzZ49e64Ly0mWLl2qPXr0SPNYcHCwtmnTRps1a6ZdunTRiIgIVVUdOnSoLl68OMM4Bw4c0I4dO6q/v782bdpUQ0NDtVWrVlqqVClt0qSJ/uc//9F169bpvffeq6qqUVFR2qtXL/Xz89NWrVrpX3/9paqqr7/+ug4fPlzbtm2rNWvW1E8++eQ6OUNCQrRJkyaakJBw3bFt27Zpq1at1M/PT3v37q1nz55VVdW2bdvqyy+/rG3atNG33npLy5YtqzVq1NAmTZpoaGjoNXm4+xoZDHmSA7+oji+rOqevakL8DWUFBKub39/GFuUN8sa3u9kTcf6m5tmwcilev69Ruse7dOnChAkTqFu3Lp06daJ///60bduW+Ph4nnnmGVasWIGPjw8LFy7k1VdfZdq0aSlpM4rz8MMP89JLL3H//fcTFxdHUlIS7733HhMnTmTVqlUArF+/PiWv119/naZNm7J8+XLWrl3LkCFD2L59OwD79u1j3bp1XLhwgXr16vHEE09csy6tSZMmVKxYkZo1a9KxY0f69OnDfffdB8CQIUP47LPPaNu2LePGjeONN95g0qRJAERHR7NhwwYADhw4QI8ePejbty8Gg+EGObUHFg+DWxpA32ngkffVQ94/gwJIiRIlCAkJYePGjaxbt47+/fvz3nvvERgYyK5du+jcuTMAiYmJVKpU6Zq0+/fvTzPOhQsXOH78OPfffz9gLZbOjE2bNrF06VIAOnToQFRUFDExMQDce++9eHl54eXlxS233MKpU6fw9fVNSevh4cGPP/7Ili1bWLNmDWPHjiUkJISxY8cSHR1N27ZtARg6dCj9+vVLSde/f5bX5RsMhsyIPQ3z+kPhYjBwIXiVdLdENwWj4G6QjFparsTDw4N27drRrl07/Pz8mDlzJs2bN6dRo0YEBQWlm05V04xz/nzWW6Gaxvyc5Cn6Xl5e18iakJCQZtyWLVvSsmVLOnfuzPDhwxk7dmyGZRYvXjzLchoMhgyIvwzzH4JLZ2D491DaN/M0eQRjbDkPsn//fg4cOJCyv337dqpXr069evWIjIxMUV7x8fHs3r37mrTpxSlVqhS+vr4sX74cgCtXrnDp0iVKlizJhQsX0pSjTZs2zJ07F7C6LitUqECpUqWcOoeIiAi2bt163TmULl2asmXLsnHjRgBmz56d0ppLTUayGQwGJ0hKgmWj4HgI9PkKKjd1t0Q3FdOCy4PExsbyzDPPEB0djaenJ7Vr12bq1KkUKVKEJUuWMHr0aGJiYkhISGDMmDE0avRPKzOjOLNnz+bxxx9n3LhxFC5cmMWLF+Pv74+npydNmjRh2LBhNG36zwMwfvx4hg8fjr+/P8WKFWPmzJlOn0N8fDzPP/88EREReHt74+Pjw5dffgnAzJkzGTVqFJcuXaJWrVpMnz49zTwGDBjAY489xqeffsqSJUu47bbbslmjBkMBZd1bsGc5dHkLGvRwtzQ3HUmrm8nwD4GBgZra4enevXtp0KCBmyQyOIO5RgZDJmybAyuegubDoMckuMkWgEQkRFVvfE3RDWC6KA0Gg6GgcfhX+PZZqNUeuk+86cott2AUnMFgMBQkzhyAhYOhfG3oNwM88q9bKaPgDAaDoaBwMQrm9oNCntZygKJl3C2RSzGTTAwGg6EgkHAFFj4M5yNg2HdQtoa7JXI5RsEZDAZDfkcVVj4DR4Og73So2sLdEuUIpovSYDAY8jsbPoAdC6HDa9C4j7ulyTGMgsujeHh4EBAQQJMmTWjWrBm///57pmlq1KjBmTNnrgtPz5XO+vXr6dHD+bUxSUlJjB49msaNG+Pn50eLFi04fPiw0+kBJk2axKVLl7KUxmAwZMCOxbD+HWgyEO7+l7ulyVFMF2UepWjRoimGjX/66SdefvnlFCPE7mLhwoVERESwY8cOChUqRHh4eJZMayUmJjJp0iQGDRpEsWLFXCipwVBAOPoHrHgSqreG+z7Jt8sB0sO04PIB58+fp2zZssD1ra6nn36aGTNmpOx/+OGHKfYfQ0NDU8J/+eUX7r77burWrZviOcCRixcvMmLECFq0aEHTpk3TdE564sQJKlWqRKFC1m3l6+ubItf8+fPx8/OjcePGvPjiiylpSpQowbhx42jVqhVvv/02ERERtG/fnvbt299YpRgMBZ2zh2DBQChdFfrPBs8i7pYoxzEtuBvlh5fg5M6bm+etftDtvQyjXL58mYCAAOLi4jhx4gRr1651KutSpUrx559/MmvWLMaMGZOizMLCwtiwYQMHDx6kffv21yg/sDyId+jQgWnTphEdHU3Lli3p1KnTNS20Bx98kNatW7Nx40Y6duzIoEGDaNq0KREREbz44ouEhIRQtmxZunTpwvLly+nduzcXL16kcePGTJgwAbC8fK9bt44KFSpkpcYMBoMjl8/B3AdBk+DhxVCsnLslcgsua8GJSD0R2e7wOy8iY0SknIj8LCIH7P+ydnwRkU9FJFREdohIM4e8htrxD4jIUIfw5iKy007zqdim7LNTRl4juYty3759/PjjjwwZMiRN6/6peeihh1L+HT0KPPjggxQqVIg6depQq1Yt9u3bd0261atX89577xEQEEC7du2Ii4vj6NGj18Tx9fVl//79vPvuuxQqVIiOHTuyZs0atmzZQrt27fDx8cHT05OHH36YX3/9FbDGEh944IEbrQ6DwZBMwlVrIfe5MBgwD8oXXButLmvBqep+IABARDyA48Ay4CVgjaq+JyIv2fsvAt2AOvavFTAFaCUi5YDXgUBAgRARWamq5+w4I4E/gO+Be4AfslrGDZ1oJi2tnOCOO+7gzJkzREZG4unpSVJSUsqxuLi4a+KKQx98ettp7asqS5cupV69ehnK4uXlRbdu3ejWrRsVK1Zk+fLldOzYMd343t7eeHh4ZJinwWBwElX4biyEbYT7p0L1O90tkVvJqTG4jsBBVT0C9AKSzc7PBHrb272AWba38z+AMiJSCegK/KyqZ22l9jNwj32slKoG2e7RZ6XKKytl5Gn27dtHYmIi5cuXp3r16uzZs4crV64QExPDmjVrrom7cOHClP877rgjJXzx4sUkJSVx8OBBDh06dJ0i69q1K5999llKK3Hbtm3XybF161YiIiIAa0bljh07qF69Oq1atWLDhg2cOXOGxMRE5s+fb1zgGAyu4LdJlhHlti9CE+McOKfG4AYA8+3tiqp6AkBVT4jILXZ4FeCYQ5pwOyyj8PA0wrNTxglHYUVkJFbLkGrVqmXpRHOK5DE4sFpXM2fOxMPDg6pVq/Lggw/i7+9PnTp1rnFvA5aft1atWpGUlMT8+fNTwuvVq0fbtm05deoUX3755XUevV977TXGjBmDv78/qkqNGjWum4xy+vRpHnvsMa5cuQJAy5Ytefrpp/H29ubdd9+lffv2qCrdu3enV69eaZ7XyJEj6datG5UqVWLdunU3XE8GQ4Fh93L4ZTw07gvtXna3NLkCl7vLEZEiQATQSFVPiUi0qpZxOH5OVcuKyHfAu6q6yQ5fA7wAdAC8VPUtO/w14BLwqx2/kx1+N/CCqt6X1TJUNSQ9+Y27nLyJuUaGAkV4CMzoDpWawJCVUNg78zQupqC4y+kGbFXVU/b+qeRuQfv/tB0eDlR1SOeLpRgzCvdNIzw7ZRgMBkPeJPoozB8AJSpak0pygXLLLeSEgnuIf7onAVYCyTMhhwIrHMKH2DMdbwdi7G7Gn4AuIlLWng3ZBfjJPnZBRG63Z08OSZVXVsowGAyGvMels9ZygIQr1nKA4mZ5jSMuHYMTkWJAZ+Bxh+D3gEUi8ghwFOhnh38PdAdCsboghwOo6lkReRPYYseboKpn7e0ngBlAUazZkz9kpwyDwWDIc1y9CPP6w9mDMOh/4JPxDOeCiEsVnKpeAsqnCovCmlWZOq4CT6WTzzRgWhrhwUDjNMKzXIbBYDDkGRLjYdFQOB4M/WZCzbvdLVGuxFgyMRgMhrxEUhIsfxJCf7bsSzbs6W6Jci3GFqXBYDDkFVThp1dg5yLoOA6aD3O3RLkao+DyKCVKlHBp/tu3b+f7779P2V+5ciXvvXdzrLa8/fbbNGrUCH9/fwICAti8eXOW0s+YMSNlQbnBUKDY+BFsngK3PwWtn3O3NLke00VpuI6EhAS2b99OcHAw3bt3B6Bnz5707HnjXSFBQUGsWrWKrVu34uXlxZkzZ7h69arT6RMTE5kxYwaNGzemcuXKNyyPwZBnCJ4Oa98E//7Q5a0C5/omOxgFl8dZv34948ePp0KFCuzatYvmzZszZ84cRISXXnqJlStX4unpSZcuXZg4cSKRkZGMGjUqxVDypEmTuOuuuxg/fjwRERGEhYVRoUIFNm3axOXLl9m0aRMvv/wyly9fJjg4mMmTJ3PkyBFGjBhBZGQkPj4+TJ8+nWrVqjFs2DBKlSpFcHAwJ0+e5IMPPqBv377XyHvixAkqVKiAl5cXwDVeA9asWcPzzz9PQkICLVq0YMqUKXh5eVGjRg1GjBjB6tWrGTVqFMHBwTz88MMULVqUoKAgihYtmnMVbjC4gz0r4LvnoE4X6PU5FDKdb85gFNwN8v6f77Pv7L7MI2aB+uXq82kRfDEAACAASURBVGLLFzOPaLNt2zZ2795N5cqVueuuu/jtt99o2LAhy5YtY9++fYgI0dHRADz77LOMHTuW1q1bc/ToUbp27crevXsBCAkJYdOmTRQtWpQZM2akKDTgGp9yTz/9NEOGDGHo0KFMmzaN0aNHs3z5csBSYJs2bWLfvn307NnzOgXXpUsXJkyYQN26denUqRP9+/enbdu2xMXFMWzYMNasWUPdunUZMmQIU6ZMYcyYMYBllHnTpk0AfP3110ycOJHAQLcaSTAYcoZDG2Dpo+Dbwpox6VHY3RLlGcxnQD6gZcuW+Pr6UqhQIQICAggLC6NUqVJ4e3vz6KOP8r///S/FQ/Yvv/zC008/TUBAAD179uT8+fMpxo179uzpVGsoKCiIgQMHAjB48OAUxQPQu3dvChUqRMOGDTl16tR1aUuUKEFISAhTp07Fx8eH/v37M2PGDPbv30/NmjWpW7cuAEOHDk1xqQPQv78xHGsogERss5yWlq8NAxdCEePpPiuYFtwNkpWWlqtI7u4Dy79aQkICnp6e/Pnnn6xZs4YFCxYwefJk1q5dS1JSUrrdeo7OS7OCo2sdR1nSs3Pq4eFBu3btaNeuHX5+fsycOTPFcHR6ZFc2gyHPciYU5vSFouVg0FIoWtbdEuU5TAsunxIbG0tMTAzdu3dn0qRJbN++HbC6CJO7HYGU8NRk5LbmzjvvZMGCBQDMnTuX1q1bOy3X/v37OXDgwDXlV69enfr16xMWFpbiSXz27NnGpY6h4HI+Ambfb20PXgalzISq7GAUXD7lwoUL9OjRA39/f9q2bcvHH38MwKeffkpwcDD+/v40bNiQL7/8Ms307du3Z8+ePQQEBKT4kEvm008/Zfr06fj7+zN79mw++eQTp+WKjY1l6NChNGzYEH9/f/bs2cP48ePx9vZm+vTp9OvXDz8/PwoVKsSoUaPSzGPYsGGMGjWKgIAALl++7HTZBkOe4NJZmN0HLp+DQUugQm13S5Rncbm7nLyOcZeTNzHXyJAnuXoJZve2xt4GLYWabdwtUbbJDe5yzBicwWAw5AYS42HREAjfYtuXzLvKLbdgFJzBYDC4m6QkWPGUsS95kzFjcAaDweBOVGH1q7BjIXR4zdiXvIkYBWcwGAzuZNN/4I8voNUTcPe/3C1NvsIoOIPBYHAXITNgzQTwexC6vmPsS95kXKrgRKSMiCwRkX0isldE7hCRciLys4gcsP/L2nFFRD4VkVAR2SEizRzyGWrHPyAiQx3Cm4vITjvNp2KvOM5OGQaDwZCj7FkJq8ZC7c7Q+wtjX9IFuLpGPwF+VNX6QBNgL/ASsEZV6wBr7H2AbkAd+zcSmAKWsgJeB1oBLYHXkxWWHWekQ7p77PAslZEXEREGDx6csp+QkICPjw89evTIUTn2799Pu3btCAgIoEGDBowcOTJL6cPCwpg3b56LpDMYcimHf4Wlj0CVQHjQ2Jd0FS5TcCJSCmgDfAOgqldVNRroBcy0o80EetvbvYBZavEHUEZEKgFdgZ9V9ayqngN+Bu6xj5VS1SC1FvPNSpVXVsrIcxQvXpxdu3alLHT++eefqVKlSpbySEhIuGE5Ro8ezdixY9m+fTt79+7lmWeeyVL5RsEZChwR22H+QCh3m21f0pihcxWubMHVAiKB6SKyTUS+FpHiQEVVPQFg/99ix68CHHNIH26HZRQenkY42SjjGkRkpIgEi0hwZGRk1s46B+nWrRvfffcdAPPnz+ehhx5KOXbx4kVGjBhBixYtaNq0KStWrAAsrwD9+vXjvvvuo0uXLiQlJfHkk0/SqFEjevToQffu3VmyZAlgeRdo27YtzZs3p2vXrpw4ceI6GU6cOIGvr2/Kvp+fHwBxcXEMHz4cPz8/mjZtyrp169Is/6WXXmLjxo0EBASkWFsxGPItUQdhzgOWXcnB/4Ni5dwtUb7GlevgPIFmwDOqullEPuGfrsK0SGt0VbMRnhFOpVHVqcBUsCyZZJThyXfe4crem+sux6tBfW595ZVM4w0YMIAJEybQo0cPduzYwYgRI9i4cSNgec3u0KED06ZNIzo6mpYtW9KpUyfA8gawY8cOypUrx5IlSwgLC2Pnzp2cPn2aBg0aMGLECOLj43nmmWdYsWIFPj4+LFy4kFdffZVp06ZdI8PYsWPp0KEDd955J126dGH48OGUKVOGzz//HICdO3eyb98+unTpwt9//31d+evXr2fixImsWrXqZlahwZD7OH/CslKCGvuSOYQrFVw4EK6qm+39JVgK7pSIVFLVE3b34GmH+FUd0vsCEXZ4u1Th6+1w3zTik40y8iT+/v6EhYUxf/78FM/byaxevZqVK1cyceJEwGpRJTs57dy5M+XKWV+OmzZtol+/fhQqVIhbb72V9u3bA9bY2q5du+jcuTNgedKuVOn63tzhw4fTtWtXfvzxR1asWMF///tf/vrrLzZt2pTSXVm/fn2qV6+eouAcyzcYCgQXTsGsnpadyaHfGvuSOYTLFJyqnhSRYyJST1X3Ax2BPfZvKPCe/b/CTrISeFpEFmBNKImxFdRPwDsOE0u6AC+r6lkRuSAitwObgSHAZw55OV3GjZynMy0tV9KzZ0+ef/551q9fT1RUVEq4qrJ06VLq1at3TfzNmzdf43omPVukqkqjRo0ICgrKVIbKlSszYsQIRowYQePGjdm1a1e6+YJxfWMoYMSehpn3Qcxxy3hyFTN5O6dw9SzKZ4C5IrIDCADewVI6nUXkANDZ3gf4HjgEhAJfAU8CqOpZ4E1gi/2bYIcBPAF8bac5CPxgh2epjLzMiBEjGDduXMrYVzJdu3bls88+S1E027ZtSzN969atWbp0KUlJSZw6dYr169cDUK9ePSIjI1MUXHx8PLt3774u/Y8//kh8fDwAJ0+eJCoqiipVqtCmTRvmzp0LwN9//83Ro0evU7ZgXN8Y8jmxkTCzJ8Qcg4cXQfU73S1RgcKltihVdTuQljXpjmnEVeCpdPKZBkxLIzwYaJxGeFRWy8ir+Pr68uyzz14X/tprrzFmzBj8/f1RVWrUqJHmONcDDzzAmjVraNy4MXXr1qVVq1aULl2aIkWKsGTJEkaPHk1MTAwJCQmMGTOGRo0aXZN+9erVPPvss3h7ewPw4Ycfcuutt/Lkk08yatQo/Pz88PT0ZMaMGdc4Q03G398fT09PmjRpwrBhwxg7duxNqhmDwc1cPAOzesG5MEu51XDeb6Lh5mDc5WRCQXCXExsbS4kSJYiKiqJly5b89ttv3Hrrre4W64bIb9fIkMe4GGWNuUWFWksBarVzt0Q5jnGXY8gV9OjRg+joaK5evcprr72W55WbweBWLp2F2b3gzAEYuKBAKrfcglFwhpRxN4PBcINcOmt1S0b+DQ/Ng9s6uFuibLPt6Dn8qpTG0yPvmhDLu5K7GdO1m3sx18bgFi6fg9n3Q+Q+GDAPandyt0TZQlWZ8dthHpjyO19vOuxucW4I04LLBt7e3kRFRVG+fHnEWP/OVagqUVFRKZNeDIYc4XI0zO4Dp3bDgLlQJ28qt/jEJN74djdz/jhKpwYVGXx7dXeLdEMYBZcNfH19CQ8PJzeb8SrIeHt7X2M+zGBwKXExMKcPnNwJ/WdD3a7ulihbxFyK58l5IfwWGsXjbWvxQtf6eBTK2x/wRsFlg8KFC1OzZk13i2EwGNxN3HnLtuSJv+DBWVCvm7slyhaHz1zkkRlbOHbuEh/29adfYNXME+UBjIIzGAyG7HDlAsztCxHboN8MqH+vuyXKFr+HnuGJuVspJDD30dtpWTP/mNEzCs5gMBiyypVYmNsPwoOh33RocJ+7JcoW8zYfZdyKXdSsUJxvhragWvli7hbppmIUnMFgMGSFqxdh3oNw7E/o+w007OVuibJMQmISb3+/l+m/hdG2rg+fDWxKKe/853TVKDiDwWBwlqsXYV5/OBoED3wNje53t0RZ5nxcPKPnb2P9/khG3FWTV7rXz9Nr3TLCKDiDwWBwhquXLOV25De4fyo0fsDdEmWZo1GXeGTmFg6fucjb9zfm4VZ5exlAZhgFZzAYDJkRfxkWPARhm+D+/4J/P3dLlGX+PHyWUXNCSExSZo1oyZ21K7hbJJdjFJzBYDBkRPxlmP8QHNoAvadAk/7ulijLLA4+xivLdlK1bDG+HhpILZ8S7hYpRzAKzmAwGNIjPg4WPAyH1kOvzyHgIXdLlCUSk5QPftzHf389xF21y/PFwOaULpb/JpOkh1FwBoPBkBYJV2DRYDi4BnpOhqYPu1uiLHHxSgLPLtjOL3tPMej2arx+XyMK59PJJOnh0rMVkTAR2Ski20Uk2A4rJyI/i8gB+7+sHS4i8qmIhIrIDhFp5pDPUDv+AREZ6hDe3M4/1E4r2S3DYDAYUki4AgsHw4HVcN8n0GywuyXKEsejL/PAlN9Zu+8Ub/RsxJu9Ghc45QY5402gvaoGODi+ewlYo6p1gDX2PkA3oI79GwlMAUtZAa8DrYCWwOvJCsuOM9Ih3T3ZKcNgMBhSSLgKi4bCgZ+gx8fQfJi7JcoSW4+eo9fk3zh+7jLTh7dk6J01CqxReHeo9F7ATHt7JtDbIXyWWvwBlBGRSkBX4GdVPauq54CfgXvsY6VUNUgt/yizUuWVlTIMBoPBWuc2fwD8/QN0nwiBI9wtUZZYsf04A6b+QbEiHix76k7a1vVxt0huxdUKToHVIhIiIiPtsIqqegLA/r/FDq8CHHNIG26HZRQenkZ4dsq4BhEZKSLBIhJsPAYYDAWEZH9uh9ZBz8+g5WPulshpkpKUj1bv59kF2wmoWoblT91F7VtKulsst+PqSSZ3qWqEiNwC/Cwi+zKIm1YbWrMRnhFOpVHVqcBUgMDAQOM902DI71w4ZSm3qAOW4eQ8ZH7r8tVE/rV4O9/vPMmDgb681duPIp4Fb7wtLVyq4FQ1wv4/LSLLsMbQTolIJVU9YXcPnrajhwOOPhp8gQg7vF2q8PV2uG8a8clGGQaDoaByLgxm9YbY0zBwIdzWwd0SOc2xs5d4Ym4IuyPO82r3Bjx6d80CO96WFi5T8yJSXERKJm8DXYBdwEogeSbkUGCFvb0SGGLPdLwdiLG7F38CuohIWXtySRfgJ/vYBRG53Z49OSRVXlkpw2AwFERO74Vp91jdk0NW5Cnltn7/ae6bvIkjUZf4ekggj7WpZZRbKlzZgqsILLMr3BOYp6o/isgWYJGIPAIcBZJt3nwPdAdCgUvAcABVPSsibwJb7HgTVPWsvf0EMAMoCvxg/wDey0oZBoOhABIebPlz8/CC4T9AxYbulsgpkpKUz9aGMmnN39SrWJIvBzWnRoXi7hYrVyLWBERDegQGBmpwcLC7xTAYDDeTQ+th/kAo4QODl0O5mu6WyCliLsUzZuE21u2PpE/TKrx9vx9Fi3i4W6w0EZEQh+VhbsFYMjEYDAWLvd/CkhFQvg4M/h+UvNXdEjnFruMxPDE3hJMxcbzZuzGDWlUzXZKZYBScwWAoOGybAyufgSrNYeAiKFbO3RI5xZKQcF5dtpOyxYqw8PE7aFatbOaJDEbBGQyGAsLvk2H1q9ZEkv5zoEjuH7e6kpDIhG/3MHfzUe6oVZ7PBjalQgkvd4uVZzAKzmAw5G9UYe1bsHEiNOwNfaaCZ+5XEsejL/Pk3K38dSyaUW1v4/kudfOt521XYRScwWDIvyQlwQ//B1u+hmZDoMckKJQ7J2U4sunAGUYv2MbVhCS+HNScexrnjXHC3IZRcAaDIX+SGA/LRsGuJXDXs9DpDcjlkzKSkpQpGw7y0er91L6lBF8Oau4256SxV2MpXrh4np7IYtq7BoMh/3H1EiwYaCm3TuOh84Rcr9zOx8Xz+JwQPvxpP/f6V2bZk3e5TbmtObKGe5fdyw+Hf8g8ci7GtOAMBkP+Ii4G5g2Ao0FWl2Rg7rfnsO/keUbNDiH83GVev68hw9zk4iY6Lpp3/3yX7w9/T/1y9bmtzG05LsPNxCg4g8GQf4g9DXP6wOl90HcaNO7jbokyZcX247y0dCclvT2ZP/J2WtRwz9KFdUfXMeGPCUTHRfNkwJM86vcohQsVdossNwuj4AwGQ/4g+qhlNPl8BDy0AOp0crdEGXI1IYl3vt/LjN/DaFmzHJMHNuWWkt45LkfMlRje//N9vj30LXXL1mVKpynUL1c/x+VwBVlWcLbB46qqusMF8hgMBkPWifwbZveGq7EwZDlUu93dEmXIyZg4npwbwtaj0TzauiYvdqtPYTcsAdhwbANvBL3B2bizPO7/OI/7P05hj7zdanPEKQUnIuuBnnb87UCkiGxQ1edcKJvBYDBkzvGtltFk8YBh38Otjd0tUYYEHYzimflbuXQ1kckDm9LDv3KOy3D+6nne//N9Vh5cSe0ytfms42c0Kt8ox+VwNc624Eqr6nkReRSYrqqvi4hpwRkMBvdyeCPMH2CZ3Bq8HMrn3kkRqsrXGw/z3o/7qFG+GPMfu506FXPe6/bG8I2MDxpP1OUoHvN7jFFNRlHEo0iOy5ETOKvgPG3HoQ8Cr7pQHoPBYHCOnUtg+ZOWJ4DBy6BUzreEnOXcxau8uHQHq/ecorvfrXzQtwklvHJ2CsSFqxf4cMuHLAtdxm2lb+OT9p/QuELubu3eKM7W8AQsx6O/qeoWEakFHHCdWAaDwZAOqrDhfVj/LlS/y7IrmYuNJgcdjGLswu1EXbzCv+9twCOtc97r9u/Hf2fc7+OIvBzJI40f4YmAJ/DyyP3mym4UpxScqi4GFjvsHwIecJVQBoPBkCbxcbDyadi5GJoMhPs+Ac/c2b0Wn5jEpF/+5ov1B6lZvjhfD72LxlVK56gMsVdjmRg8kaUHllKzdE1mt5uNv49/jsrgTpyatiMitUTkWxGJFJHTIrJCRJzyECgiHiKyTURW2fs1RWSziBwQkYUiUsQO97L3Q+3jNRzyeNkO3y8iXR3C77HDQkXkJYfwLJdhMBhyORfPwKyelnLrOA56f5FrldvRqEv0+zKIz9cd5MHmVfn2mdY5rtyCIoLos7IPy0KXMbzRcBbft7hAKTdw3lTXPGARUAmojNWaW+Bk2meBvQ777wMfq2od4BzwiB3+CHBOVWsDH9vxEJGGwACgEXAP8IWtND2Az4FuQEPgITtulsswGAy5nNP74KsOcOIv6DcT7v5XrjW9tWL7cbp/upGDkbFMHtiU9/v6UzwHx9suxl9kQtAERv48Ei8PL2beM5PnAp8rEF2SqXFWwYmqzlbVBPs3B9BME4n4AvcCX9v7AnQAlthRZgK97e1e9j728Y52/F7AAlW9oqqHgVCgpf0LVdVDqnoVS+H2ymYZBoMht3JwLXzTGeIvW8sAGvXOPI0biL2SwHOLtvPsgu3Uv7UkPzx7d44vAdh8YjN9VvRhyd9LGNpwKIvvW0zALQE5KkNuwtnPinV2F+ACLMXWH/hORMoBqOrZdNJNAl4AkufClgeiVTXB3g8HqtjbVYBjdn4JIhJjx68C/OGQp2OaY6nCW2WzjDOOQovISGAkQLVq1dI5NYPB4HK2fAPf/x/41IeBC6FMVXdLlCZ/HYtm9IJtHDt7iTGd6vB0+9o56rvtUvwl/hPyHxbuX0i1ktWY2W0mTW9pmmPl51acVXD97f/HU4WPwFJ4tVInEJEewGlVDRGRdsnBaeStmRxLLzytuyej+JmV/0+A6lRgKkBgYGCmLVWDwXCTSUqE1f+GP76AOl0su5JeOb9mLDOSkpT//nqIj1bvp2IpbxY+fkeO25LccnILr/32GhGxEQxqMIjRzUZT1LNojsqQW3F2FqVTE0pScRfQU0S6A95AKawWXRkR8bRbWL5AhB0/HKgKhIuIJ1AaOOsQnoxjmrTCz2SjDIPBkFu4EgtLH4G/f4RWo6DL2+CR+8zmnjofx3OLtvNbaBT3+lXinfv9KF0s58xcRcdF81HIRywPXU7VklWZfs90mldsnmPl5wWcnUVZTET+LSJT7f06dgstXVT1ZVX1VdUaWJNE1qrqw8A6oK8dbSiwwt5eae9jH1+rqmqHD7BnQNYE6gB/AluAOvaMySJ2GSvtNFktw2Aw5AZiwmHaPXDgZ+g+Ebq9nyuV2y97TnHPpF/ZeiSa9x/wY/LApjmm3FSVlQdX0nN5T1YdXMWIxiNY2nOpUW5p4OydMx0IAe6098OxZlKuykaZLwILROQtYBvwjR3+DTBbREKxWlUDAFR1t4gsAvYACcBTqpoIICJPYy1A9wCmqeru7JRhMBhyARHbLD9uVy/CwEW50htAXHwi736/l5lBR2hYqRSfPtSU2rfknFPSsJgw3vzjTf48+SdNfJow7o5x1C1bN8fKz2uIMw0YEQlW1UAR2aaqTe2wv1S1icsldDOBgYEaHBzsbjEMhvzNnpXwv5FQ3MeaTFKxYeZpcpi/T13gmXnb2H/qAo+0rskL99TDy9MjR8q+mniVb3Z+w1c7v8Lbw5sxzcfQt25fCknOeyBwFhEJUdVAd8rgbAvuqogUxZ6QISK3AVdcJpXBYCgYqMJvk+CX8eDbAgbMgxK3uFuqa1BV5mw+ylur9lDS25MZw1vQrl7Oybjl5BYmBE0g7HwY3Wp044WWL1ChaIUcKz8v46yCGw/8CFQVkblYE0hyvx94g8GQe0m4Ct+NhW1zoFEfyzJJ4dw1+8/RSHLbuj5M7NcEn5I5s2D6XNw5JgZPZOXBlVQpUYUvO33JXVXuypGy8wvOzqJcLSIhwO1YU+2fVdUzmSQzGAyGtLl0FhYNgbCN0OYFaPcyFMpd3W2/HzzDcwv/SjGSPOKumhQq5Hq7EKrKioMr+Cj4I2KvxvKo36OM9B9ppv5nA2cdnq5R1Y7Ad2mEGQwGg/NEHYR5D0L0Ubh/KjTpn3maHOQaI8kVctZI8qGYQ7wZ9CbBp4JpektTXrv9NeqUrZMjZedHMlRwIuINFAMqiEhZ/lkoXQrLJqXBYDA4T9gmWDgIEBiyEqrf4W6JrmF3RAz/t3gHe06cp39gVV7v2ZBiRVy/TOFK4hW+3vk13+z8Bm9Pb16/43X61OmTqyeR5AUyu3KPA2OwlFmIQ/gFLEPHBoPB4Bzb58HK0ZaD0oELodx1BpDcxtWEJD5fF8rn60IpU6wI/x3cnK6Nbs2Rsjef2Mybf7zJkfNHuLfWvTwf+LyZRHKTyEzB/Y7lRaCvqn4mIkOx/MCFYXkYMBgMhoxJTIC1b1qzJWu2hQdnQdEy7pYqhd0RMTy/eAd7T5zn/qZVeP2+hpQp5no3PGfjzjJxy0S+PfQtVUtW5b+d/8udle/MPKHBaTJTcP8FOtnKrQ3wLvAMEIBlq7FvRokNBkMBJ/Y0LBlhTSZpPhy6fwgeOWfOKiOuJiQxeV0oX6wLpWzxInw1JJDODSu6vFxVZXnocj4K+YiL8Rd5zO8xRvqPxNvT2+VlFzQyU3AeDp4C+gNTVXUpsFREtrtWNIPBkKc5EgSLh0FcNPSeAgED3S1RCruOx/D84r/Yd/ICfZpVYVyPnGm1HYo+xIQ/JhByKoRmtzRj3B3juK3MbS4vt6CSqYJzMFrcEduFjJNpDQZDQUQVgibDz69D2eowaCnc2tjdUgFwJSGRyWtD+WL9QcoXL8I3QwPp2MD1rbaL8Rf5eufXzNg9g2KexXjjzjfoXbu3mUTiYjJTUvOBDSJyBrgMbAQQkdpAjItlMxgMeY24GFj+JOxbBQ3ug16fg3fOTLHPjB3h0fzf4h3sP3WBB5r5Mq5HQ5cbSE7SJFYdWsWkkElEXo6k5209ea75c5QvWt6l5RosMlRwqvq2iKwBKgGrHSzvF8IaizMYDAaLkzutxdvnjlgubu54CsT1C6Mz40pCIp+uOcCXGw5RoUQRpg0LpEN917fa/or8i/f/fJ+dZ3biV8GPSe0n4e/j7/JyDf+QaTejqv6RRtjfrhHHYDDkSbbNge/+BUXLwrDvcs36th3h0Ty/+C/+PhVLv+a+/LtHQ0oXdW2r7dTFU3yy9RO+PfQtPkV9eKf1O9xb617THekGzDiawWDIPvGX4fv/g22zoWYbeGAalPBxt1TExSfyyZoDTP31ED4lvJg+vAXtXWwg+UriFWbtnsVXO78iISmBx/we41G/RylWuJhLyzWkj1FwBoMhe5w9ZHVJntwJdz8P7V+BQjnjPiYjth+L5v8W/8WB07H0D6zKqz0aUMrbda02VeWXo7/wUfBHHI89TqdqnXgu8DmqlqzqsjINzmEUnMFgyDp7V1mTSUQs56R1u7pbIuLiE5n0ywGm/nqQiqW8mTmiJW3rurY1uf/sft7f8j5bTm6hdpnafN3la1pVauXSMg3O4zIFZ9ux/BXwsstZoqqvi0hNYAFQDtgKDFbVqyLiBcwCmgNRQH9VDbPzehl4BEgERqvqT3b4PcAnWB69v1bV9+zwLJdhMBicIDEB1oyH3z+Dyk2h30xrKYCb2Xr0HP+3+C8ORl5kQIuqvHKva1tt5+LOMXnbZJYcWELJIiX5d6t/80DdB/AsZNoMuQlXXo0rQAdVjRWRwsAmEfkBeA74WFUXiMiXWIpriv1/TlVri8gA4H2gv4g0BAYAjbBsYv4iIsk+2j8HOgPhwBYRWamqe+y0TpfhwjowGPIPF07C4uFw9HcIfATueRc8c8Y3WnrExSfy8c9/89XGQ9xayptZI1rSxoWttvikeBbtX8Tn2z/nUvwlHqr/EE80eYLSXrljKYThWlym4OwlBbH2bmH7p0AHINmkwUwsZ6pTgF72NsASYLKIiB2+QFWvAIdFJBRoaccLVdVDACKyAOglInuzWobD8geDwZAWhzdaJreuxkKfr8D/QXdLxO+hZ/j3il0cirzIQy2r8Ur3+pR0Yavtt+O/8cGWDzgUc4g7Kt3Biy1fNFZIcjkubU+LiAeWF4LaWK2tg0C0bRkFrJZXFXu7CnAMQFUTRCQGKG+HOy5VcExzLFV4KztNVsswzlsNwxlUmQAAIABJREFUhrRISrKMJK99E8rdBkNXwi0N3CrS6fNxvPXdXlb+FUG1csWY/UhL7q7julbbkfNH+HDLh2wI30C1ktX4rMNntPVti+SCNX6GjHGpglPVRCBARMoAy4C0nozk1lNad4tmEJ7WopKM4mdUxjWIyEhss2TVqlVLI4nBUAC4fA6WPQF//wCN+kDPT8GrpNvESUhMYmbQET7++W+uJibxbMc6PNHuNrwLu2bm5oWrF5i6Yypz9s7By8OL55o/x8MNHqaIh+ttVhpuDjkyIqqq0SKyHrgdKONg39IXiLCjhQNVgXAR8QRKA2cdwpNxTJNW+JlslJFa3qlY3hIIDAw03ZeGgkfEdmsJwPkI6PYBtBzpVqskwWFn+ffyXew7eYG2dX14o2cjalQo7pKyEpMSWXFwBZ9s/YRzcefoXbs3o5uNNj7a8iCunEXpA8Tbyq0o0AlrUsc6LDc7C4ChwAo7yUp7P8g+vlZVVURWAvNE5D9Yk0zqAH9itcbq2DMmj2NNRBlop/n/9u48rqo6f/z4630BRUFUUARBRFBDRHPBLbNcyqXNyqnJNquZaWqy5jt9Z7410/SbrSmb6TvfbJqanPZlssVsdW+iRc0EFxA3UFCuAorssnM/vz/OwciQRblclvfTBw+5n3vO5/O+5wLvez7ncz6fFrXhrmOgVIdjDCS9DKsfAL/+cPtqGDTBY+GcKK1kyeq9vJPkZGBvX/558zjmjAxxS/egMYaErASe2v4U6YXpjOk/hmdmPcPIfiNbvS3VNtx5BhcKvGJfh3MAbxtjPhaR3cByEXkE2A68YG//AvCaPYgkHythYYxJFZG3gd1ADXCP3fWJiCwG1mLdJvCiMSbVruuBlrShlALK8mHVL2HXCoieCdc+D36emRS41mVYvvUwf1mzj5OVNdx1cTT3zRpKz27u+ZOVmJPIk9ueZOfxnQwOGMxfL/4rcwbP0etsHZzoCUzj4uPjTWJioqfDUMq90jbAB/dAWR5c/CBMu99js5KkOIv47fsp7HQWMTkqkD/Nj2PYAPdc+9uXv48ntz3JV0e+IrhHMHePuZv5Q+fj42gfi7J2ZCKSZIyJ92QMeleiUl1ZZSmsfxgSX4T+MXDjWzBwjEdCKSqr5ol1+3h9yyGC/Lqz9IYxXHX+QLecRWUVZ/H0jqdZlbGKgG4B3D/+fhbGLNRVtTsZTXBKdVWHv4aVd0FBJkxZDDMfBp+2/wNvjGHFtiM8tmoPBWVVLJoSyf2zh7tlJpLjZcd5Lvk5VuxfgbfDmx+P+jG3x91OQLeAVm9LeZ4mOKW6mppKSHgMNi6F3uHW8jaRUz0Syt6cYh5+fxdbMwsYG9GHV380kZEDW39WkOKqYl7e9TKv73md6tpqFgxfwE9H/5T+PT2/8oFyH01wSnUlObtg5U8hdxeMuxXmPOqRe9tKK2t4cv1+XtqUSYCvN48vGMV14wfhcLRud2RFTQVv7n2T51Oep7iqmHlD5rF4zGIiAvT+1q5AE5xSXYGr1jpj++xRa1HShW/BeXPbPAxjDJ+kZPOnj3eTW1zJwomD+J85MfT1a92bp2tcNbyf/j7P7nyWY2XHuDDsQu4bex8jgjw7C4tqW5rglOrsThyA9++GrC0w4iq44kmPDP8/cLyU332QylfpeYwcGMCzN49nXETfVm3DGMO6Q+t4evvTZBZnMrr/aJZMW8KEEM/dy6c8RxOcUp2VMdboyHW/BYePNUnyqOvafEaS4opqnk04wPNfHsTXx4s/XDWSmycPxquVuyM3H93Mk9ueZPeJ3UT3jmbpjKXMGDRD72XrwjTBKdUZFR+FDxbDgU8hajrMfwZ6hzW1V6uqqnHx5jeHWfppGvknq7h2bBgPXhZDcK/WHamZcjyFpduWsiVnC6F+oTwy9RGuiLoCr3awurjyLE1wSnU2Ke/CJ/9tjZa87Alr7TZHQ3OTu4cxhjW7cnh8zV4yT5QxJSqI31w2glHhrTs6cm/+Xp7b+RwbDm+gb/e+PDDhAa4/73qdDFmdoglOqc6iLB8+uR9SV0L4BLj6n9BvaJuGkJiZz6Or9rDtcCHDgv158bZ4ZpwX3KrdhCnHU1iWvIwEZwJ+Pn7cff7dLBq5CD8f90y+rDouTXBKdQb718GHi6HshHXD9tT/Aq+2+/U+eLyUx9fsZW1qLsG9uvP4glEsGBeOt1frnTkm5Sbx3M7n2Jy9md7de3PPmHtYGLNQV9NWZ6QJTqmOrLIU1j1krQAQHAs3vQOh57dZ83mllSzdkMa/vzmMr7eD+y8dzo+nDWm1SZGNMWzO3syy5GUk5SYR6BvIL8b/gh+e90M9Y1NN0gSnVEd1aDO8fxcUHIIL7oMZD7XZVFvlVbU8/+VB/vn5ASpqXNw4MYL7Zg2jf6/urVK/MYYvnF+wLHkZyXnJBPcM5sGJD3LtsGvp4d2jVdpQnZ8mOKU6mvIC+M8jsPUF6BMBt6+CwRe0SdO1LsO7SVn8bf1+cosrmR07gAfmxRDd379V6ncZFxsObWBZ8jL2FewjzD+Mhyc/zNVDr9bBI6rFNMEp1VEYAzvfhHUPQ3m+tcr2rIfbZKotYwwJ+46zZPVe9uWWMDaiD0/fOI4JkYGtUn+Nq4Y1mWv4V/K/OFh0kMiASB6Z+giXRV2mS9eos6YJTqmOIDfVGvp/eLM1QvLy99rsWtuuI0U8umoPmw6cYHBQT565aRzz4lpnVe3q2mo+Pvgxz6c8z+GSwwztM5S/XPQXZg+erfexqXOmCU6p9qyyBBKWwNfPgm9vuOrvMObmNrmvzVlQxhNr9/H+jqP07enD76+M5cZJg+nmfe5tV9ZWsjJtJS/uepHsk9mMCBzBk9OfZEbEDBzSdvfsqc7NbQlORAYBrwIhgAtYZoxZKiKBwFtAJJAJXG+MKRDr4+BS4DKgDLjNGLPNrmsR8Fu76keMMa/Y5eOBl4EewCrg58YYczZtKNWuGAOp78Hah6AkG8Ytgkt+Dz1bp0uwMUVl1fwjIZ2XN2YiAj+bHs1d06NbZX22suoy3t3/Li+nvszx8uOc3/98Hp78MBeGXahTaqlW584zuBrgv40x20SkF5AkIuuB24BPjTFLRORB4EHgAWAeMMz+mgQ8C0yyk9XvgHjA2PV8aIwpsLe5E/gaK8HNBVbbdTa7DTceA6VaLi8NVv0SDiZAyGj44esQHu/2Zksra3ht8yH++fkBiiuqWTAunPsvHc7APuc+arG0qpTl+5bzauqrFFQWMDFkIo9Ne4yJIRM1sSm3cVuCM8ZkA9n29yUisgcIA+YD0+3NXgESsJLPfOBVY4wBvhaRPiISam+73hiTD2AnybkikgAEGGM22+WvAldjJbgWtWHHqpRnVZXBl0/AxqfAp6c9zdYd4OZrUcUV1byyMZMXNmZQWFbNxcP788DcGGIHnvsq184SJ//e+29Wpq2ktLqUC8Mu5M7RdzI2eGwrRK5U49rkGpyIRAJjgS3AgLqEYozJFpFge7MwIKvebk67rLFyZwPlnEUb30lwInIn1pkhERG6MKJqA3tXweoHoOgwjL4BZv8J/IOb3u8cFJVV8+LGDF7cmEFJRQ2zYoK5d9Ywxgzqc071GmPYfmw7r+1+jf9k/QcHDi6NvJRFsYsY2W9kK0WvVNPcnuBExB9YAfyXMaa4ke6Ihp4wZ1HeaDjN2ccYswxYBhAfH99UnUqdvfwMWPMg7F8D/UfAbasgcqp7mzxZxQtfHeSVTYcoraxhzsgB3DtzGHFh5zblVXVtNWsy1/D6ntfZfWI3Ad0CuH3k7dwQcwMhfiGtFL1SzefWBCciPljJ7Q1jzHt2cW5dt6DdBXnMLncCg+rtHg4ctcunn1aeYJeHN7D92bShVNuqroBNT8GX/wsOb5j9CEy6C7zcd8/X8ZJKnv/yIK99fYjy6louiwtl8cyhjAg9t67IgooC3tn/Dsv3Lud4+XEiAyJ5ePLDXBF1BT19erZS9Eq1nDtHUQrwArDHGPO3ek99CCwCltj/f1CvfLGILMca+FFkJ6i1wKMiUrf072zg18aYfBEpEZHJWF2ftwJ/P5s2Wvu1K9Wo9A2w6leQfxBGXgOz/+zWtdqOFVfw3BcHeWPLIapqXFx5/kAWzxjKsAHndoN4ekE6r+95nY8PfkxlbSUXDLyAP1zwB6aGTdWh/qpdcOcZ3FTgFiBFRHbYZb/BSjpvi8iPgMPAdfZzq7CG76djDeG/HcBOZH8Cttrb/bFuwAlwN9/eJrDa/qKlbSjVJoqOwNpfw+4PIDAablkJ0TPd1lx2UTn/TDjAm1uzqHUZrh4Txj0zook6h2m1XMbFxiMbeX3P62w6uonuXt25IuoKbh5xM0P7tu3SPEo1RawBhepM4uPjTWJioqfDUB1ZbTV8/QwkPA6mFi76pTU5snfrTEx8OmdBGc8mHOCdRCcuY1gwLpyfzYhmcNDZz75fXlPORwc+4vU9r5NRlEH/Hv25IeYGrht+HX19+zZdgepyRCTJGOP++1saoTOZKOUuxsDeT+DTP0LePjjvMpi7BPoOdktzh06c5JnPDrBimxMRuD5+EHdPjya879lfB8s5mcPyvct5Z/87FFcVExsUy2PTHmPO4Dn4uPF6oVKtQROcUu5w4DMrsR3dBkHDYOFyOG+eW5o6eLyUpz9L54MdR/FyCDdNiuCnF0ef0w3aKcdTeG3Pa6zPXI8LFzMHzeSW2FsYGzxWb8xWHYYmOKVakzMRPv0DZHwBAeFw1dNw/kK3rK6dllvC05+l89HOo3TzdnDbBZH89KIoggPObk24ytpKNhzawPK9y9lxfAd+Pn4sHLGQG2NuJLxXeNMVKNXOaIJTqjXk7rbWaNv3CfTsB3Mfh/jbW/06mzGGr9LzeGljJp/tO0YPHy9+clEUP5kWRT//s2srrSCNFWkr+OjARxRXFRPuH84DEx7g6qFX49+tddZ5U8oTNMEpdS7yMyDhMUh+21qXbeZvYdLd0L11E0N5VS3vbXfy8sZM0o6V0s+/G/fOHMZtF0QS6NfyhUDLqstYk7mGFWkrSD6ejI/Dh1kRs7h22LVMCp2kw/xVp6AJTqmzUZwNX/wVtr0CDh+Y+nPrq5Vn+z9SWM6rmzNZ/k0WReXVjBwYwBPXnc+V54fS3btlc1QaY0g9kcq7+99ldcZqymrKiOodxa/if8WV0VfqaEjV6WiCU6olyvJh45OwZRm4qq1lbC76FQSEtloTxhgSDxXw0sYM1qbmYoxhblwIt10whAmRfVs8yKOosohPDn7Ce2nvsa9gH75evsyJnMOC4QsY03+MDhpRnZYmOKWao7LUWnR001PWIqSjfwjTH4TAIa3XRE0tH+/M5qVNGew6UkyArzc/vnAIt0wZ3OKh/sYYknKTeC/tPdYdWkdlbSUjAkfw8OSHmTdkHr26ndssJkp1BJrglGpMdQUkvQRfPAFleRBzBcx4CAbEtloTx0oqeOPrw7yx5TB5pZUMDfbnz9fEcc3YMHp2a9mv6InyE3x04CNWpK0gszgTfx9/rh56NdcOu5bYoNaLWamOQBOcUg2prYGdb0LCEih2wpCLYNbvWnXh0RRnES9tzOCj5KNU1xpmxgRz+9RILhzar0Xdhi7jYvPRzaxIW8FnWZ9R46phbPBYfjzqx1w6+FKd8Fh1WZrglKrP5YI9H8B//gwn0iBsPFz9D4ia3irV19S6WJuay0sbM0g8VIBfNy9umjSYRRdEMqRfy6bSyjmZw/vp77MybSVHTx6lT/c+3BhzI9cOu5boPtGtEq9SHZkmOKXASmxpa+GzRyEn2Vqb7YdvQMzl0AqDMArLqnjzmyxe25zJ0aIKIgJ78vAVsVwXH06Ab/OnvCqqLGLDoQ2szlzN1pytuIyLyaGT+UX8L5g5aCbdvFp+y4BSnZUmONW1VZVZXZFfPwMn0qHPYLjmORh1HThaNgz/dMYYtmcV8k5iFiu3H6Gi2sUF0UH8YX4cM2OC8XI0L3GWVZeRkJXA6ozVfHX0K2pcNUT0iuAno37C/KHzGdRrUNOVKNUFaYJTXVNxNmz9FyS+COUFMHAsLHgBYuef86KjOUUVvLfdybtJTg4eP4mvj4Orx4Rx29RIYkKat7hoVW0VXx35itUZq/nc+TnlNeUE9wzmppibmBc1j9jAWB3er1QTNMGpriU72TpbS3kXXDVWF+SUeyBiyjl1RVZU17J+dy7vJjn5Mu04LgMTIwO566Jo5o0KoVczuiFrXDV8k/MNazLWsOHwBkqqSujbvS9XRV/F3Mi5jBswTmcYUaoFNMGpzs/lgvT1sPlpaxJkHz+IvwMm3wWBUWddrTGGHVmFvJvk5KOdRymuqGFgb1/umTGUBePCiWzGoBFjDDuP72RVxirWZq4lvyIfPx8/ZkXMYt6QeUwKnYSPQ5elUepsuC3BiciLwBXAMWNMnF0WCLwFRAKZwPXGmAKx+lqWYq22XQbcZozZZu+zCPitXe0jxphX7PLxfLua9yrg58YYczZtqE7q1PW1Z60RkQFhcOkfYdyt0OPsp6XKLa5g5fYjvJvkJP1YKb4+DubFhfKD8eFMiQrC0cS1NWMM+wr2WUktYy1HTx6lu1d3Lgq/iMuGXMa08Gl093LPYqhKdSXuPIN7GXgaeLVe2YPAp8aYJSLyoP34AWAeMMz+mgQ8C0yyk9XvgHjAAEki8qExpsDe5k7ga6wENxdY3dI23PbqleeU5MA3/4LEF1rt+lpFdS0b9lhdkF/st7ogJ0T25fEFo7hsVGizuiAPFR9iVcYqVmesJqMoA2/xZsrAKSweu5gZg2bozP1KtTK3JThjzBciEnla8Xxguv39K0ACVvKZD7xqjDHA1yLSR0RC7W3XG2PyAURkPTBXRBKAAGPMZrv8VeBqrATXojaMMdmt+bqVB7Xy9TVjDMnOIt5JyuLDHVYXZGhvX342fSgLxoc36761jKKMUyMg9+TvQRDGDxjPzSNu5tLBl+oEx0q5UVtfgxtQl1CMMdkiEmyXhwFZ9bZz2mWNlTsbKD+bNr6X4ETkTqyzQyIiIlr4ElWbcsP1tWP1uiDTjpXS3dvBvLgQfjB+EFOigxod3l/tqmbHsR0kZCXwufNzDhUfAiAuKI5fxf+KOZFzGOA34KziUkq1THsZZNLQXwxzFuVn08b3C41ZBiwDiI+Pb6pe5QmtfH2tpKKa/+w9xvvbj/C53QU5fnBfHrt2FJePDm30ZuyiyiI2HtlIgjOBr458RUlVCT4OHyaGTOSmETdxcfjFDPQfeC6vVil1Fto6weXWdQvaXZDH7HInUP9u1XDgqF0+/bTyBLs8vIHtz6YN1VEYY80ysvMt2Pnvc76+lldayfrduaxNzWFT+gmqal2EBPhy9/RoFowLJ6r/ma+JHSo+dOosbVvuNmpNLYG+gcwcNJPpg6YzZeAU/HxaNvWWUqp1tXWC+xBYBCyx//+gXvliEVmONfCjyE5Qa4FHRaTuI/ls4NfGmHwRKRGRycAW4Fbg72fThhtfq2otRUcg5W0rsR3fYy0wet48mHx3i6+vOQvKWJuay9pdOSQeysdlICKwJ4suGMyckSGMjejbYBdkjauGHcd28LnzcxKyEsgszgRgaJ+h3B53OxeHX8yofqPwOsfZT5RSrcedtwm8iXX21U9EnFijIZcAb4vIj4DDwHX25quwhu+nYw3hvx3ATmR/Arba2/2xbsAJcDff3iaw2v6ipW2odqqyBPZ8ZHVDZnwJGBg0CS7/G4y8ptkrZxtjSDtWytpdOaxJzSH1aDEAMSG9uHfmMOaMDGFEaK8GZwUpqSo51fX4pfNLiquK8XZ4M2HABG6IuYHpg6YT5h/2vf2UUu2DWIMK1ZnEx8ebxMRET4fRNdTWwMEESF4Oez6GmnLoO8RaXHT09RDUvBnyXS7DTmcha1NzWZeaw8G8kwCMi+jD3LgQZseGnPEm7MPFh/nc+TmfZ31OUm4SNaaGvt37Mi18mtX1GDpFh/Mr1QwikmSMab31pc5Cexlkorqq+tfVUt6Bk8fAtw+MWQijb4BBE5vVBVld6+KbjHzWpuawLjWXnOIKvB3ClOgg7rhwCLNjBxAc4Pu9/fLK89ias5Vvcr5ha87WU6Meh/YZyqKRi5g+aLp2PSrVQWmCU57R0HW14XPg/Btg2Gzwbnomj4rqWr7Yf5y1qbl8ujeXwrJqfH0cXDy8P/8z8jxmxQygd8/vDjwpqCggMTeRb7KthHag6AAA/j7+jB8wnoUxC7ko/CKdoV+pTkATnGo7DV1XC58Il/8vjLy2WdfVsvLL2HzgBJ/tO0bCvuOUV9cS4OvNJSMGMHtkCBcP70+Pbt+ebRVXFZOYk3jqLG1/wX4Aenj3YFzwOK6MvpJJoZOICYzB26G/Dkp1JvobrdyrwetqkXDxA826rpZXWsmmAyfYlJ7HpgMnOJxfBkBwr+4sGB/GnJEhTI4KwsfLmmX/ZPVJvnAmnUpoe/P34jIuunt1Z0zwGO4dey8TQyYyst9IncRYqU5OE5xqfeUFVlJL2wBp61p0Xa24opotB/PZdCCPTekn2JdbAkAvX28mRwVxx9RILhjaj2HB/ogI5TXlbM39+lSXY+qJVGpNLT4OH0b3H81do+9iQsgERvcfratdK9XFaIJT587lguwdkP6pNW2WcysYF/j2huiZELfgjNfVKqprSTpUwEb7DC3ZWYjLQHdvBxMiA5k/diBTo/sxcmAA3l4OCisK2XViJ+t27GBrzlaS85KpcdXgLd7E9Yvjjrg7mBg6kTH9x+Dr/f1BJUqprkMTnDo7J/PgwH8gfYOV2MryrPKBY2HaL2HoJRA2Hry++yNWU+si+UgRm9Lz2Jh+gqTDBVTVuPByCGMG9WHxjKFMie7HuMF9qDWV7Mnfw468jbx+cBe78nbhLLWmIHWIg9jAWG6NvZWJIRMZGzyWnj492/ooKKXaMU1wqnlctXAkCdLWW0nt6HbAQM8giJ5lJbTomeDf/7u7uQz7ckvYmJ7H5gMn2JKRT2llDQCxoQHcOnkwU4f2Y0xEL46WHyQ1byerc3bxl10pHCw6iMu4AAj1CyWuXxzXnXcdcUFxxAbF6v1oSqlGaYJTZ1aSY3c7brDO1ioKQRwQPgFm/AaGzoLQseBwnNolt7iCFGcRyUeKSHEWstNZRP7JKgCG9PNj/piBTI4KJDy4lKyyfezK+5LnD6Syd+teqlzWdn269yGuXxyXDL6EUf1GERsUS78e/TxyCJRSHZcmOPWt2mrI2mJ3O26AnBSr3D8EYq6wElrU9FPD+Y+XVLJrfx7JziJSjhSS7CziWEklAA6BYcG9mHFef2IHufDvnc3R8u3sytvFo6m7Kd1RCljD9WODYlkYs5C4/nHEBcUR5h/W4NRZSinVEprgurKTeXB0h9XdeCQJMr+CqhJweMOgyXDJ762uxwFx5JdVk3KkiJSvT5DsPEjKkSKyiyoAa0BkVH8/JkR7Exx0kh498yiXbLJKMkksTGPdfmv6UG+HN8P7DufyqMsZGTSSuH5xRPWO0llClFJuoQmuqyjLtxJZtp3Qju6AonrrvwYNhVELYOilFIVcQEqei+QjhaRsKCLZ+RlHCsvtDV0MDq4menAJY3vlQ7dcCmucHCrO4IvK4lMLEPn5+BHVO4ppYdOIDYplVL9RDA8cTnevpmcoUUqp1qAJrjMqL4DsnXYis5NZ4aFvnw+MhkETqY7/CUd7xrBfokgrFlKPFpPyURGH8zcDtUi3fEKCiugfVkjo0DzK5SjHK7LIryknvxrIh77d+xLVJ4o5kXOI7hPNkN5DiO4dTXDPYO1mVEp5lCa4jq6iqF4ys8/OCjJOPe3qE8nJoNFkR1zPfkc0SdWD2VvgIDPtJNmJJxHvPBw+6YhPIb0DCgkIOcHg8FyKa7KpMdWUAqUuCDbBRAdEM23QBKJ6R1lffaII9G3esjVKKdXWNMF1FFVlUOSEosNwbO+33Y0n0k9tUu4XTk7P80gLnU1idSQJpX05UFgKpYU4fIoQ74349lhFd98SGFhIwMACDK5T+1cj9PAPt5PXrG8TWe8oHZKvlOpwNMG1B8ZYQ/ALs6zrYqf+P4yxH0vdjdS2XJ8BbO0+mC3+l7G91p8sLx8qfMpxUIS3Iwnx/xTTq4r6tz77OHwY0HMAof6hhPqNrPd9KCE9QwjvFa6zfyilOo0ul+BEZC6wFPACnjfGLHF7oy6XNR9jYRYUHaa24DBVeYeoLTgMRYepKTtKmamgyOGgyOGg2OHghFd3nF7+HJUeHPcNIb9nGCVeDsodLiq9K8G7DMixvyz9fAIZ6B9KeK/RhPiFEOoXSqi/lbxC/UMJ9A3EIY4zhqmUUp1Jl0pwIuIF/AO4FHACW0XkQ2PM7tZu68sNT5Gx/20qqwuoMicpdRiKHF4UeVlJrMDhTZHDi5K+4AoMOmM9Dlz4ennh5x1AULcA+vr2YYBfP4b0Cfs2efmFMsBvgE4mrJRS9XSpBAdMBNKNMQcBRGQ5MB9o9QSXvnY94ZtO2I96IKf+ORDxwiFeeDkceIkX3uLA2+GFl8MLL3HgEC8cYj337UhEAxRZXyYTSDzVVhWQRQOMaX7ALdjW0JJ6m7+pu+Jt9rZ6DFq8bbOPQyc+Bi07Xm7QklhbuP2ABx+gz4IFLQyo/ehqCS6M7+YCJzDp9I1E5E7gToCIiIizamjWxXdw8uQqunt1w8fhjTTVNdjCEfXNH4LfgopbMqzfbdu2pNqWHLRmbtvBjkFL6nXL8WpJDHoMWr6tu+ps5ubdhgxpeSztSFdLcA29rd/7OGOMWQYsA4iPjz+rD10RV1wDV1xzNrsqpZRqBV1txIETGFTvcTin5t5QSinVmXS1BLcVGCYiQ0SkG3AD8KGHY1JKKeUGXaqL0hhTIyKLgbVYtwm8aIxJ9XBYSiml3KBLJTgAY8wqYJWn41BKKeVeXa2LUimlVBehCU4ppVSnpAlOKaVUp6QJTimqTVxlAAAKgUlEQVSlVKckpqXTvHQxInIcONTkhm2rH5DX5FbtR0eKV2N1n44Ub0eKFdpnvIONMf09GYAmuA5IRBKNMfGejqO5OlK8Gqv7dKR4O1Ks0PHibSvaRamUUqpT0gSnlFKqU9IE1zEt83QALdSR4tVY3acjxduRYoWOF2+b0GtwSimlOiU9g1NKKdUpaYJTSinVKWmC60BEZJCIfCYie0QkVUR+7umYmiIiXiKyXUQ+9nQsTRGRPiLyrojstY/xFE/HdCYi8gv7Z2CXiLwpIr6ejqk+EXlRRI6JyK56ZYEisl5E0uz/+3oyxjpniPWv9s9BsoisFJE+noyxvobirffcL0XEiEg/T8TW3miC61hqgP82xowAJgP3iEish2Nqys+BPZ4OopmWAmuMMTHA+bTTuEUkDLgPiDfGxGEt/XSDZ6P6npeBuaeVPQh8aowZBnxqP24PXub7sa4H4owxo4H9wK/bOqhGvMz340VEBgGXAofbOqD2ShNcB2KMyTbGbLO/L8H6Axzm2ajOTETCgcuB5z0dS1NEJAC4CHgBwBhTZYwp9GxUjfIGeoiIN9CTdrYyvTHmCyD/tOL5wCv2968AV7dpUGfQUKzGmHXGmBr74ddAeJsHdgZnOLYA/wf8D6AjB22a4DooEYkExgJbPBtJo57E+oVzeTqQZogCjgMv2V2qz4uIn6eDaogx5gjwBNYn9WygyBizzrNRNcsAY0w2WB/WgGAPx9NcdwCrPR1EY0TkKuCIMWanp2NpTzTBdUAi4g+sAP7LGFPs6XgaIiJXAMeMMUmejqWZvIFxwLPGmLHASdpPF9p32Neu5gNDgIGAn4jc7NmoOicReQjr0sAbno7lTESkJ/AQ8P88HUt7owmugxERH6zk9oYx5j1Px9OIqcBVIpIJLAdmisjrng2pUU7AaYypOyN+FyvhtUeXABnGmOPGmGrgPeACD8fUHLkiEgpg/3/Mw/E0SkQWAVcAN5n2fcNwNNaHnZ3271s4sE1EQjwaVTugCa4DERHBuka0xxjzN0/H0xhjzK+NMeHGmEisARD/Mca027MMY0wOkCUi59lFs4DdHgypMYeBySLS0/6ZmEU7HRBzmg+BRfb3i4APPBhLo0RkLvAAcJUxpszT8TTGGJNijAk2xkTav29OYJz9M92laYLrWKYCt2CdDe2wvy7zdFCdyL3AGyKSDIwBHvVwPA2yzzLfBbYBKVi/x+1qqiYReRPYDJwnIk4R+RGwBLhURNKwRvst8WSMdc4Q69NAL2C9/Xv2T48GWc8Z4lUN0Km6lFJKdUp6BqeUUqpT0gSnlFKqU9IEp5RSqlPSBKeUUqpT0gSnlFKqU9IEp9qEiEQ2NPt5A9uF1q08ICLT3b0KgYj8pqUxNlJXfxHZYk/1Na2R7dz+ulpCRH4vIr+0v/+jiFzSSvVm1s1qLyKbmtj2N008/2sRuem0shgR2SwilXXx13turojsE5F0EXmwXvkQ+z1KE5G3RKSbXb5YRG5v6WtU7ZsmONXe3A/8qw3ba/QPawvNAvYaY8YaY75sxXrbjDHm/xljNrih3qZmWmnqfZgNnD7fZj7WqgpP1C8UES/gH8A8IBZYWG/VjceB/7NXNCgA6u4he9GuS3UimuBUmxORKPssZ0IDTy8A1jSx/3gR+VxEkkRkbb3pnxJE5HER+UZE9tedRdkzfrxtr+31lv0JPl5ElmDNyL9DROrmGvQSkX+JtdbaOhHp0UD7g0XkU7u+T0UkQkTGAH8BLrPr63HaPnPFWl/sK+DaeuV+Yq3vtdU+JvPt8pH269hhtzPMLr/VfrxTRF6zy/qLyAq7jq0iMtUu/71dd4KIHBSR++q1+5B9hrMBOK9e+csi8gP7+0wR+YOIbBORFBGJqdfeerv8ORE5JE2sPyYipfb/oSLyhf26donItDO8D/X3DQC6GWOO1y83xhwzxmwFqk/bZSKQbow5aIypwpoqbr6ICDAT6yZ5qLeigT1bSaaITGzsdaiORROcalNiTYW1Arjd/uNU/7khQIExprKR/X2AvwM/MMaMx/rk/ed6m3gbYyYC/wX8zi77mV3vaOBPwHgAY8yDQLkxZowxpq77axjwD2PMSKAQK+Ge7mngVbu+N4CnjDE7sCa7fcuur7xezL5YZ6VXAtOA+nMEPoQ1jdkEYAbwV7FWMbgLWGqMGQPEA04RGWlvP9MYcz7WWntgrWP3f3YdC/ju8kQxwBysP/q/ExEfERmPNX3aWKxk29AHjTp5xphxwLNAXTfg7+yYxwErgYhG9j/djcBa+3WdD+w4w/tQ3yVY68c1VxiQVe+x0y4LAgrrLYNTV14nEev9UZ2Et6cDUF1Kf6z5BxcYY1IbeD4Ua8maxpwHxGFNoQTWYp/Z9Z6vm4A6CYi0v78QKwlgjNkl1lRcZ5JhJ6vT66hvCt+ehb2GdebWmBi73jQAsSadvtN+bjbWpNR1ycMXK2FsBh4Sa02994wxaSIyE3jXGJNnv5a6NcEuAWLt4wEQICK97O8/sT8wVIrIMWAA1h/xlXVzLIrIh43EXv941r3mC4Fr7BjWiEhBE6+/vq3Ai/YHlffrHevGzAVeakEb0kCZaaS8zjGs90p1EprgVFsqwvpkPRVoKMGVY/2Bb4wAqcaYKWd4vu7sr5Zvf74b+sN2JvXPHmuB73VRNqA5892daRvBSvj7TivfIyJbsBaMXSsiP7a3bageBzCl/lkjgJ3wTn89dcekuXP0nevx/A5jzBcichHW63pNRP5qjHm1id0mAne3oBknMKje43CsBWHzgD4i4m2fxdWV1/HF+hlUnYR2Uaq2VIV1zeNWEbmxgef30/AZU337gP4iMgWsLku7664xXwHX29vHAqPqPVdtn020xCasLj6Am+z6G7MXGCIi0fbjhfWeWwvca18fQkTG2v9HAQeNMU9hzcI/Gqub7noRCbK3CbTrWAcsrqvQvh7YmC+Aa0Skh32md2UT25+u/vGcDfRt7o4iMhhrncB/Ya2MUbckUYPvg/3e7jXG1LYgvq3AMLFGTHbDeq8+tJe8+Qz4gb3d6SsaDAfOehStan80wak2ZYw5ibXG1i/qBlSc9twBERlar3iWWDOmO0XEiXX97AfA4yKyE9hB02uhPYOVFJOxlkBJxjqbBGsW/uSGBjc04j7gdru+W/j2WliDjDEVWF2Sn9iDTA7Ve/pPgI8dwy77McAPgV0isgOr2+xVu1v3z8Dn9muvWzLpPiDeHnyyG+v6XWPxbAPewjp2K4CWjvj8AzBbRLZhjVTMBkqaue90YIeIbMe6XrjULj/T+zCPMww6EpEQ+2fifuC39s9IgH12thjrw8Me4O16XeIPAPeLSDrWNbkX6lU5FWj1EaTKc3Q1AdWuiMg1wHhjzG9bsU4vwMcYU2GfRX0KDLdH2KkWEpHuQK0xpsY+k37WHjTijrbWA7caY7Kb3Pjc2hkL3G+MucWd7ai2pdfgVLtijFlZ1wXXinoCn9ldYALcrcntnEQAb4uIA6vb+SfuasgYc6m76j5NP+DhNmpLtRE9g1NKKdUp6TU4pZRSnZImOKWUUp2SJjillFKdkiY4pZRSnZImOKWUUp3S/wdAl5rbamr3FgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "# Define k to be an array with integers from 1 to 15\n",
    "k = list(range(1, 16))\n",
    "\n",
    "plt.plot(k, steps_select, label=\"Selection Sort\")\n",
    "plt.plot(k, steps_bubble, label=\"Bubble Sort\")\n",
    "plt.plot(k, steps_insert, label=\"Insertion Sort\")\n",
    "plt.plot(k, lst, label=\"Merge Sort\")\n",
    "plt.xlabel('k (Length of descending list / 100)')\n",
    "plt.ylabel('Steps')\n",
    "plt.title('Graph 1 \\n A comparison of steps against k for different sorting algorithms')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "k = list(range(1, 16))\n",
    "\n",
    "plt.plot(k, time_select, label = \"Selection Sort\")\n",
    "plt.plot(k, time_bubble, label = \"Bubble Sort\")\n",
    "plt.plot(k, time_insert, label = \"Insertion Sort\")\n",
    "plt.plot(k, time_lst, label = \"Merge Sort\")\n",
    "\n",
    "plt.xlabel('k (Length of descending list / 100)')\n",
    "plt.ylabel('Time (s)')\n",
    "plt.title('Graph 1 \\n A comparison of running time against k for different sorting algorithms')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}